1 /* Tree lowering pass. This pass converts the GENERIC functions-as-trees
2 tree representation into the GIMPLE form.
3 Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011,
4 2012 Free Software Foundation, Inc.
5 Major work done by Sebastian Pop <s.pop@laposte.net>,
6 Diego Novillo <dnovillo@redhat.com> and Jason Merrill <jason@redhat.com>.
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify it under
11 the terms of the GNU General Public License as published by the Free
12 Software Foundation; either version 3, or (at your option) any later
15 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
16 WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING3. If not see
22 <http://www.gnu.org/licenses/>. */
26 #include "coretypes.h"
30 #include "tree-iterator.h"
31 #include "tree-inline.h"
32 #include "tree-pretty-print.h"
33 #include "langhooks.h"
34 #include "tree-flow.h"
42 #include "diagnostic-core.h"
44 #include "pointer-set.h"
45 #include "splay-tree.h"
48 #include "tree-pass.h"
50 #include "langhooks-def.h" /* FIXME: for lhd_set_decl_assembler_name. */
51 #include "expr.h" /* FIXME: for can_move_by_pieces
52 and STACK_CHECK_MAX_VAR_SIZE. */
54 enum gimplify_omp_var_data
60 GOVD_FIRSTPRIVATE = 16,
61 GOVD_LASTPRIVATE = 32,
64 GOVD_DEBUG_PRIVATE = 256,
65 GOVD_PRIVATE_OUTER_REF = 512,
66 GOVD_DATA_SHARE_CLASS = (GOVD_SHARED | GOVD_PRIVATE | GOVD_FIRSTPRIVATE
67 | GOVD_LASTPRIVATE | GOVD_REDUCTION | GOVD_LOCAL)
75 ORT_COMBINED_PARALLEL = 3,
80 struct gimplify_omp_ctx
82 struct gimplify_omp_ctx *outer_context;
84 struct pointer_set_t *privatized_types;
86 enum omp_clause_default_kind default_kind;
87 enum omp_region_type region_type;
90 static struct gimplify_ctx *gimplify_ctxp;
91 static struct gimplify_omp_ctx *gimplify_omp_ctxp;
94 /* Formal (expression) temporary table handling: multiple occurrences of
95 the same scalar expression are evaluated into the same temporary. */
97 typedef struct gimple_temp_hash_elt
100 tree temp; /* Value */
103 /* Forward declaration. */
104 static enum gimplify_status gimplify_compound_expr (tree *, gimple_seq *, bool);
106 /* Mark X addressable. Unlike the langhook we expect X to be in gimple
107 form and we don't do any syntax checking. */
110 mark_addressable (tree x)
112 while (handled_component_p (x))
113 x = TREE_OPERAND (x, 0);
114 if (TREE_CODE (x) == MEM_REF
115 && TREE_CODE (TREE_OPERAND (x, 0)) == ADDR_EXPR)
116 x = TREE_OPERAND (TREE_OPERAND (x, 0), 0);
117 if (TREE_CODE (x) != VAR_DECL
118 && TREE_CODE (x) != PARM_DECL
119 && TREE_CODE (x) != RESULT_DECL)
121 TREE_ADDRESSABLE (x) = 1;
124 /* Return a hash value for a formal temporary table entry. */
127 gimple_tree_hash (const void *p)
129 tree t = ((const elt_t *) p)->val;
130 return iterative_hash_expr (t, 0);
133 /* Compare two formal temporary table entries. */
136 gimple_tree_eq (const void *p1, const void *p2)
138 tree t1 = ((const elt_t *) p1)->val;
139 tree t2 = ((const elt_t *) p2)->val;
140 enum tree_code code = TREE_CODE (t1);
142 if (TREE_CODE (t2) != code
143 || TREE_TYPE (t1) != TREE_TYPE (t2))
146 if (!operand_equal_p (t1, t2, 0))
149 #ifdef ENABLE_CHECKING
150 /* Only allow them to compare equal if they also hash equal; otherwise
151 results are nondeterminate, and we fail bootstrap comparison. */
152 gcc_assert (gimple_tree_hash (p1) == gimple_tree_hash (p2));
158 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
159 *SEQ_P is NULL, a new sequence is allocated. This function is
160 similar to gimple_seq_add_stmt, but does not scan the operands.
161 During gimplification, we need to manipulate statement sequences
162 before the def/use vectors have been constructed. */
165 gimple_seq_add_stmt_without_update (gimple_seq *seq_p, gimple gs)
167 gimple_stmt_iterator si;
173 *seq_p = gimple_seq_alloc ();
175 si = gsi_last (*seq_p);
177 gsi_insert_after_without_update (&si, gs, GSI_NEW_STMT);
180 /* Shorter alias name for the above function for use in gimplify.c
184 gimplify_seq_add_stmt (gimple_seq *seq_p, gimple gs)
186 gimple_seq_add_stmt_without_update (seq_p, gs);
189 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
190 NULL, a new sequence is allocated. This function is
191 similar to gimple_seq_add_seq, but does not scan the operands.
192 During gimplification, we need to manipulate statement sequences
193 before the def/use vectors have been constructed. */
196 gimplify_seq_add_seq (gimple_seq *dst_p, gimple_seq src)
198 gimple_stmt_iterator si;
204 *dst_p = gimple_seq_alloc ();
206 si = gsi_last (*dst_p);
207 gsi_insert_seq_after_without_update (&si, src, GSI_NEW_STMT);
210 /* Set up a context for the gimplifier. */
213 push_gimplify_context (struct gimplify_ctx *c)
215 memset (c, '\0', sizeof (*c));
216 c->prev_context = gimplify_ctxp;
220 /* Tear down a context for the gimplifier. If BODY is non-null, then
221 put the temporaries into the outer BIND_EXPR. Otherwise, put them
224 BODY is not a sequence, but the first tuple in a sequence. */
227 pop_gimplify_context (gimple body)
229 struct gimplify_ctx *c = gimplify_ctxp;
231 gcc_assert (c && (c->bind_expr_stack == NULL
232 || VEC_empty (gimple, c->bind_expr_stack)));
233 VEC_free (gimple, heap, c->bind_expr_stack);
234 gimplify_ctxp = c->prev_context;
237 declare_vars (c->temps, body, false);
239 record_vars (c->temps);
242 htab_delete (c->temp_htab);
245 /* Push a GIMPLE_BIND tuple onto the stack of bindings. */
248 gimple_push_bind_expr (gimple gimple_bind)
250 if (gimplify_ctxp->bind_expr_stack == NULL)
251 gimplify_ctxp->bind_expr_stack = VEC_alloc (gimple, heap, 8);
252 VEC_safe_push (gimple, heap, gimplify_ctxp->bind_expr_stack, gimple_bind);
255 /* Pop the first element off the stack of bindings. */
258 gimple_pop_bind_expr (void)
260 VEC_pop (gimple, gimplify_ctxp->bind_expr_stack);
263 /* Return the first element of the stack of bindings. */
266 gimple_current_bind_expr (void)
268 return VEC_last (gimple, gimplify_ctxp->bind_expr_stack);
271 /* Return the stack of bindings created during gimplification. */
274 gimple_bind_expr_stack (void)
276 return gimplify_ctxp->bind_expr_stack;
279 /* Return true iff there is a COND_EXPR between us and the innermost
280 CLEANUP_POINT_EXPR. This info is used by gimple_push_cleanup. */
283 gimple_conditional_context (void)
285 return gimplify_ctxp->conditions > 0;
288 /* Note that we've entered a COND_EXPR. */
291 gimple_push_condition (void)
293 #ifdef ENABLE_GIMPLE_CHECKING
294 if (gimplify_ctxp->conditions == 0)
295 gcc_assert (gimple_seq_empty_p (gimplify_ctxp->conditional_cleanups));
297 ++(gimplify_ctxp->conditions);
300 /* Note that we've left a COND_EXPR. If we're back at unconditional scope
301 now, add any conditional cleanups we've seen to the prequeue. */
304 gimple_pop_condition (gimple_seq *pre_p)
306 int conds = --(gimplify_ctxp->conditions);
308 gcc_assert (conds >= 0);
311 gimplify_seq_add_seq (pre_p, gimplify_ctxp->conditional_cleanups);
312 gimplify_ctxp->conditional_cleanups = NULL;
316 /* A stable comparison routine for use with splay trees and DECLs. */
319 splay_tree_compare_decl_uid (splay_tree_key xa, splay_tree_key xb)
324 return DECL_UID (a) - DECL_UID (b);
327 /* Create a new omp construct that deals with variable remapping. */
329 static struct gimplify_omp_ctx *
330 new_omp_context (enum omp_region_type region_type)
332 struct gimplify_omp_ctx *c;
334 c = XCNEW (struct gimplify_omp_ctx);
335 c->outer_context = gimplify_omp_ctxp;
336 c->variables = splay_tree_new (splay_tree_compare_decl_uid, 0, 0);
337 c->privatized_types = pointer_set_create ();
338 c->location = input_location;
339 c->region_type = region_type;
340 if ((region_type & ORT_TASK) == 0)
341 c->default_kind = OMP_CLAUSE_DEFAULT_SHARED;
343 c->default_kind = OMP_CLAUSE_DEFAULT_UNSPECIFIED;
348 /* Destroy an omp construct that deals with variable remapping. */
351 delete_omp_context (struct gimplify_omp_ctx *c)
353 splay_tree_delete (c->variables);
354 pointer_set_destroy (c->privatized_types);
358 static void omp_add_variable (struct gimplify_omp_ctx *, tree, unsigned int);
359 static bool omp_notice_variable (struct gimplify_omp_ctx *, tree, bool);
361 /* Both gimplify the statement T and append it to *SEQ_P. This function
362 behaves exactly as gimplify_stmt, but you don't have to pass T as a
366 gimplify_and_add (tree t, gimple_seq *seq_p)
368 gimplify_stmt (&t, seq_p);
371 /* Gimplify statement T into sequence *SEQ_P, and return the first
372 tuple in the sequence of generated tuples for this statement.
373 Return NULL if gimplifying T produced no tuples. */
376 gimplify_and_return_first (tree t, gimple_seq *seq_p)
378 gimple_stmt_iterator last = gsi_last (*seq_p);
380 gimplify_and_add (t, seq_p);
382 if (!gsi_end_p (last))
385 return gsi_stmt (last);
388 return gimple_seq_first_stmt (*seq_p);
391 /* Strip off a legitimate source ending from the input string NAME of
392 length LEN. Rather than having to know the names used by all of
393 our front ends, we strip off an ending of a period followed by
394 up to five characters. (Java uses ".class".) */
397 remove_suffix (char *name, int len)
401 for (i = 2; i < 8 && len > i; i++)
403 if (name[len - i] == '.')
405 name[len - i] = '\0';
411 /* Create a new temporary name with PREFIX. Return an identifier. */
413 static GTY(()) unsigned int tmp_var_id_num;
416 create_tmp_var_name (const char *prefix)
422 char *preftmp = ASTRDUP (prefix);
424 remove_suffix (preftmp, strlen (preftmp));
425 clean_symbol_name (preftmp);
430 ASM_FORMAT_PRIVATE_NAME (tmp_name, prefix ? prefix : "T", tmp_var_id_num++);
431 return get_identifier (tmp_name);
434 /* Create a new temporary variable declaration of type TYPE.
435 Do NOT push it into the current binding. */
438 create_tmp_var_raw (tree type, const char *prefix)
442 tmp_var = build_decl (input_location,
443 VAR_DECL, prefix ? create_tmp_var_name (prefix) : NULL,
446 /* The variable was declared by the compiler. */
447 DECL_ARTIFICIAL (tmp_var) = 1;
448 /* And we don't want debug info for it. */
449 DECL_IGNORED_P (tmp_var) = 1;
451 /* Make the variable writable. */
452 TREE_READONLY (tmp_var) = 0;
454 DECL_EXTERNAL (tmp_var) = 0;
455 TREE_STATIC (tmp_var) = 0;
456 TREE_USED (tmp_var) = 1;
461 /* Create a new temporary variable declaration of type TYPE. DO push the
462 variable into the current binding. Further, assume that this is called
463 only from gimplification or optimization, at which point the creation of
464 certain types are bugs. */
467 create_tmp_var (tree type, const char *prefix)
471 /* We don't allow types that are addressable (meaning we can't make copies),
472 or incomplete. We also used to reject every variable size objects here,
473 but now support those for which a constant upper bound can be obtained.
474 The processing for variable sizes is performed in gimple_add_tmp_var,
475 point at which it really matters and possibly reached via paths not going
476 through this function, e.g. after direct calls to create_tmp_var_raw. */
477 gcc_assert (!TREE_ADDRESSABLE (type) && COMPLETE_TYPE_P (type));
479 tmp_var = create_tmp_var_raw (type, prefix);
480 gimple_add_tmp_var (tmp_var);
484 /* Create a new temporary variable declaration of type TYPE by calling
485 create_tmp_var and if TYPE is a vector or a complex number, mark the new
486 temporary as gimple register. */
489 create_tmp_reg (tree type, const char *prefix)
493 tmp = create_tmp_var (type, prefix);
494 if (TREE_CODE (type) == COMPLEX_TYPE
495 || TREE_CODE (type) == VECTOR_TYPE)
496 DECL_GIMPLE_REG_P (tmp) = 1;
501 /* Create a temporary with a name derived from VAL. Subroutine of
502 lookup_tmp_var; nobody else should call this function. */
505 create_tmp_from_val (tree val)
507 return create_tmp_var (TREE_TYPE (val), get_name (val));
510 /* Create a temporary to hold the value of VAL. If IS_FORMAL, try to reuse
511 an existing expression temporary. */
514 lookup_tmp_var (tree val, bool is_formal)
518 /* If not optimizing, never really reuse a temporary. local-alloc
519 won't allocate any variable that is used in more than one basic
520 block, which means it will go into memory, causing much extra
521 work in reload and final and poorer code generation, outweighing
522 the extra memory allocation here. */
523 if (!optimize || !is_formal || TREE_SIDE_EFFECTS (val))
524 ret = create_tmp_from_val (val);
531 if (gimplify_ctxp->temp_htab == NULL)
532 gimplify_ctxp->temp_htab
533 = htab_create (1000, gimple_tree_hash, gimple_tree_eq, free);
534 slot = htab_find_slot (gimplify_ctxp->temp_htab, (void *)&elt, INSERT);
537 elt_p = XNEW (elt_t);
539 elt_p->temp = ret = create_tmp_from_val (val);
540 *slot = (void *) elt_p;
544 elt_p = (elt_t *) *slot;
552 /* Return true if T is a CALL_EXPR or an expression that can be
553 assigned to a temporary. Note that this predicate should only be
554 used during gimplification. See the rationale for this in
555 gimplify_modify_expr. */
558 is_gimple_reg_rhs_or_call (tree t)
560 return (get_gimple_rhs_class (TREE_CODE (t)) != GIMPLE_INVALID_RHS
561 || TREE_CODE (t) == CALL_EXPR);
564 /* Return true if T is a valid memory RHS or a CALL_EXPR. Note that
565 this predicate should only be used during gimplification. See the
566 rationale for this in gimplify_modify_expr. */
569 is_gimple_mem_rhs_or_call (tree t)
571 /* If we're dealing with a renamable type, either source or dest must be
572 a renamed variable. */
573 if (is_gimple_reg_type (TREE_TYPE (t)))
574 return is_gimple_val (t);
576 return (is_gimple_val (t) || is_gimple_lvalue (t)
577 || TREE_CODE (t) == CALL_EXPR);
580 /* Helper for get_formal_tmp_var and get_initialized_tmp_var. */
583 internal_get_tmp_var (tree val, gimple_seq *pre_p, gimple_seq *post_p,
588 /* Notice that we explicitly allow VAL to be a CALL_EXPR so that we
589 can create an INIT_EXPR and convert it into a GIMPLE_CALL below. */
590 gimplify_expr (&val, pre_p, post_p, is_gimple_reg_rhs_or_call,
593 t = lookup_tmp_var (val, is_formal);
596 && (TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE
597 || TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE))
598 DECL_GIMPLE_REG_P (t) = 1;
600 mod = build2 (INIT_EXPR, TREE_TYPE (t), t, unshare_expr (val));
602 SET_EXPR_LOCATION (mod, EXPR_LOC_OR_HERE (val));
604 /* gimplify_modify_expr might want to reduce this further. */
605 gimplify_and_add (mod, pre_p);
608 /* If we're gimplifying into ssa, gimplify_modify_expr will have
609 given our temporary an SSA name. Find and return it. */
610 if (gimplify_ctxp->into_ssa)
612 gimple last = gimple_seq_last_stmt (*pre_p);
613 t = gimple_get_lhs (last);
619 /* Return a formal temporary variable initialized with VAL. PRE_P is as
620 in gimplify_expr. Only use this function if:
622 1) The value of the unfactored expression represented by VAL will not
623 change between the initialization and use of the temporary, and
624 2) The temporary will not be otherwise modified.
626 For instance, #1 means that this is inappropriate for SAVE_EXPR temps,
627 and #2 means it is inappropriate for && temps.
629 For other cases, use get_initialized_tmp_var instead. */
632 get_formal_tmp_var (tree val, gimple_seq *pre_p)
634 return internal_get_tmp_var (val, pre_p, NULL, true);
637 /* Return a temporary variable initialized with VAL. PRE_P and POST_P
638 are as in gimplify_expr. */
641 get_initialized_tmp_var (tree val, gimple_seq *pre_p, gimple_seq *post_p)
643 return internal_get_tmp_var (val, pre_p, post_p, false);
646 /* Declare all the variables in VARS in SCOPE. If DEBUG_INFO is true,
647 generate debug info for them; otherwise don't. */
650 declare_vars (tree vars, gimple scope, bool debug_info)
657 gcc_assert (gimple_code (scope) == GIMPLE_BIND);
659 temps = nreverse (last);
661 block = gimple_bind_block (scope);
662 gcc_assert (!block || TREE_CODE (block) == BLOCK);
663 if (!block || !debug_info)
665 DECL_CHAIN (last) = gimple_bind_vars (scope);
666 gimple_bind_set_vars (scope, temps);
670 /* We need to attach the nodes both to the BIND_EXPR and to its
671 associated BLOCK for debugging purposes. The key point here
672 is that the BLOCK_VARS of the BIND_EXPR_BLOCK of a BIND_EXPR
673 is a subchain of the BIND_EXPR_VARS of the BIND_EXPR. */
674 if (BLOCK_VARS (block))
675 BLOCK_VARS (block) = chainon (BLOCK_VARS (block), temps);
678 gimple_bind_set_vars (scope,
679 chainon (gimple_bind_vars (scope), temps));
680 BLOCK_VARS (block) = temps;
686 /* For VAR a VAR_DECL of variable size, try to find a constant upper bound
687 for the size and adjust DECL_SIZE/DECL_SIZE_UNIT accordingly. Abort if
688 no such upper bound can be obtained. */
691 force_constant_size (tree var)
693 /* The only attempt we make is by querying the maximum size of objects
694 of the variable's type. */
696 HOST_WIDE_INT max_size;
698 gcc_assert (TREE_CODE (var) == VAR_DECL);
700 max_size = max_int_size_in_bytes (TREE_TYPE (var));
702 gcc_assert (max_size >= 0);
705 = build_int_cst (TREE_TYPE (DECL_SIZE_UNIT (var)), max_size);
707 = build_int_cst (TREE_TYPE (DECL_SIZE (var)), max_size * BITS_PER_UNIT);
710 /* Push the temporary variable TMP into the current binding. */
713 gimple_add_tmp_var (tree tmp)
715 gcc_assert (!DECL_CHAIN (tmp) && !DECL_SEEN_IN_BIND_EXPR_P (tmp));
717 /* Later processing assumes that the object size is constant, which might
718 not be true at this point. Force the use of a constant upper bound in
720 if (!host_integerp (DECL_SIZE_UNIT (tmp), 1))
721 force_constant_size (tmp);
723 DECL_CONTEXT (tmp) = current_function_decl;
724 DECL_SEEN_IN_BIND_EXPR_P (tmp) = 1;
728 DECL_CHAIN (tmp) = gimplify_ctxp->temps;
729 gimplify_ctxp->temps = tmp;
731 /* Mark temporaries local within the nearest enclosing parallel. */
732 if (gimplify_omp_ctxp)
734 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
735 while (ctx && ctx->region_type == ORT_WORKSHARE)
736 ctx = ctx->outer_context;
738 omp_add_variable (ctx, tmp, GOVD_LOCAL | GOVD_SEEN);
747 /* This case is for nested functions. We need to expose the locals
749 body_seq = gimple_body (current_function_decl);
750 declare_vars (tmp, gimple_seq_first_stmt (body_seq), false);
754 /* Determine whether to assign a location to the statement GS. */
757 should_carry_location_p (gimple gs)
759 /* Don't emit a line note for a label. We particularly don't want to
760 emit one for the break label, since it doesn't actually correspond
761 to the beginning of the loop/switch. */
762 if (gimple_code (gs) == GIMPLE_LABEL)
768 /* Return true if a location should not be emitted for this statement
769 by annotate_one_with_location. */
772 gimple_do_not_emit_location_p (gimple g)
774 return gimple_plf (g, GF_PLF_1);
777 /* Mark statement G so a location will not be emitted by
778 annotate_one_with_location. */
781 gimple_set_do_not_emit_location (gimple g)
783 /* The PLF flags are initialized to 0 when a new tuple is created,
784 so no need to initialize it anywhere. */
785 gimple_set_plf (g, GF_PLF_1, true);
788 /* Set the location for gimple statement GS to LOCATION. */
791 annotate_one_with_location (gimple gs, location_t location)
793 if (!gimple_has_location (gs)
794 && !gimple_do_not_emit_location_p (gs)
795 && should_carry_location_p (gs))
796 gimple_set_location (gs, location);
799 /* Set LOCATION for all the statements after iterator GSI in sequence
800 SEQ. If GSI is pointing to the end of the sequence, start with the
801 first statement in SEQ. */
804 annotate_all_with_location_after (gimple_seq seq, gimple_stmt_iterator gsi,
808 gsi = gsi_start (seq);
812 for (; !gsi_end_p (gsi); gsi_next (&gsi))
813 annotate_one_with_location (gsi_stmt (gsi), location);
816 /* Set the location for all the statements in a sequence STMT_P to LOCATION. */
819 annotate_all_with_location (gimple_seq stmt_p, location_t location)
821 gimple_stmt_iterator i;
823 if (gimple_seq_empty_p (stmt_p))
826 for (i = gsi_start (stmt_p); !gsi_end_p (i); gsi_next (&i))
828 gimple gs = gsi_stmt (i);
829 annotate_one_with_location (gs, location);
833 /* This page contains routines to unshare tree nodes, i.e. to duplicate tree
834 nodes that are referenced more than once in GENERIC functions. This is
835 necessary because gimplification (translation into GIMPLE) is performed
836 by modifying tree nodes in-place, so gimplication of a shared node in a
837 first context could generate an invalid GIMPLE form in a second context.
839 This is achieved with a simple mark/copy/unmark algorithm that walks the
840 GENERIC representation top-down, marks nodes with TREE_VISITED the first
841 time it encounters them, duplicates them if they already have TREE_VISITED
842 set, and finally removes the TREE_VISITED marks it has set.
844 The algorithm works only at the function level, i.e. it generates a GENERIC
845 representation of a function with no nodes shared within the function when
846 passed a GENERIC function (except for nodes that are allowed to be shared).
848 At the global level, it is also necessary to unshare tree nodes that are
849 referenced in more than one function, for the same aforementioned reason.
850 This requires some cooperation from the front-end. There are 2 strategies:
852 1. Manual unsharing. The front-end needs to call unshare_expr on every
853 expression that might end up being shared across functions.
855 2. Deep unsharing. This is an extension of regular unsharing. Instead
856 of calling unshare_expr on expressions that might be shared across
857 functions, the front-end pre-marks them with TREE_VISITED. This will
858 ensure that they are unshared on the first reference within functions
859 when the regular unsharing algorithm runs. The counterpart is that
860 this algorithm must look deeper than for manual unsharing, which is
861 specified by LANG_HOOKS_DEEP_UNSHARING.
863 If there are only few specific cases of node sharing across functions, it is
864 probably easier for a front-end to unshare the expressions manually. On the
865 contrary, if the expressions generated at the global level are as widespread
866 as expressions generated within functions, deep unsharing is very likely the
869 /* Similar to copy_tree_r but do not copy SAVE_EXPR or TARGET_EXPR nodes.
870 These nodes model computations that should only be done once. If we
871 were to unshare something like SAVE_EXPR(i++), the gimplification
872 process would create wrong code. */
875 mostly_copy_tree_r (tree *tp, int *walk_subtrees, void *data)
878 enum tree_code code = TREE_CODE (t);
880 /* Do not copy SAVE_EXPR, TARGET_EXPR or BIND_EXPR nodes themselves, but
881 copy their subtrees if we can make sure to do it only once. */
882 if (code == SAVE_EXPR || code == TARGET_EXPR || code == BIND_EXPR)
884 if (data && !pointer_set_insert ((struct pointer_set_t *)data, t))
890 /* Stop at types, decls, constants like copy_tree_r. */
891 else if (TREE_CODE_CLASS (code) == tcc_type
892 || TREE_CODE_CLASS (code) == tcc_declaration
893 || TREE_CODE_CLASS (code) == tcc_constant
894 /* We can't do anything sensible with a BLOCK used as an
895 expression, but we also can't just die when we see it
896 because of non-expression uses. So we avert our eyes
897 and cross our fingers. Silly Java. */
901 /* Cope with the statement expression extension. */
902 else if (code == STATEMENT_LIST)
905 /* Leave the bulk of the work to copy_tree_r itself. */
907 copy_tree_r (tp, walk_subtrees, NULL);
912 /* Callback for walk_tree to unshare most of the shared trees rooted at
913 *TP. If *TP has been visited already (i.e., TREE_VISITED (*TP) == 1),
914 then *TP is deep copied by calling mostly_copy_tree_r. */
917 copy_if_shared_r (tree *tp, int *walk_subtrees, void *data)
920 enum tree_code code = TREE_CODE (t);
922 /* Skip types, decls, and constants. But we do want to look at their
923 types and the bounds of types. Mark them as visited so we properly
924 unmark their subtrees on the unmark pass. If we've already seen them,
925 don't look down further. */
926 if (TREE_CODE_CLASS (code) == tcc_type
927 || TREE_CODE_CLASS (code) == tcc_declaration
928 || TREE_CODE_CLASS (code) == tcc_constant)
930 if (TREE_VISITED (t))
933 TREE_VISITED (t) = 1;
936 /* If this node has been visited already, unshare it and don't look
938 else if (TREE_VISITED (t))
940 walk_tree (tp, mostly_copy_tree_r, data, NULL);
944 /* Otherwise, mark the node as visited and keep looking. */
946 TREE_VISITED (t) = 1;
951 /* Unshare most of the shared trees rooted at *TP. */
954 copy_if_shared (tree *tp)
956 /* If the language requires deep unsharing, we need a pointer set to make
957 sure we don't repeatedly unshare subtrees of unshareable nodes. */
958 struct pointer_set_t *visited
959 = lang_hooks.deep_unsharing ? pointer_set_create () : NULL;
960 walk_tree (tp, copy_if_shared_r, visited, NULL);
962 pointer_set_destroy (visited);
965 /* Unshare all the trees in BODY_P, a pointer into the body of FNDECL, and the
966 bodies of any nested functions if we are unsharing the entire body of
970 unshare_body (tree *body_p, tree fndecl)
972 struct cgraph_node *cgn = cgraph_get_node (fndecl);
974 copy_if_shared (body_p);
976 if (cgn && body_p == &DECL_SAVED_TREE (fndecl))
977 for (cgn = cgn->nested; cgn; cgn = cgn->next_nested)
978 unshare_body (&DECL_SAVED_TREE (cgn->decl), cgn->decl);
981 /* Callback for walk_tree to unmark the visited trees rooted at *TP.
982 Subtrees are walked until the first unvisited node is encountered. */
985 unmark_visited_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
989 /* If this node has been visited, unmark it and keep looking. */
990 if (TREE_VISITED (t))
991 TREE_VISITED (t) = 0;
993 /* Otherwise, don't look any deeper. */
1000 /* Unmark the visited trees rooted at *TP. */
1003 unmark_visited (tree *tp)
1005 walk_tree (tp, unmark_visited_r, NULL, NULL);
1008 /* Likewise, but mark all trees as not visited. */
1011 unvisit_body (tree *body_p, tree fndecl)
1013 struct cgraph_node *cgn = cgraph_get_node (fndecl);
1015 unmark_visited (body_p);
1017 if (cgn && body_p == &DECL_SAVED_TREE (fndecl))
1018 for (cgn = cgn->nested; cgn; cgn = cgn->next_nested)
1019 unvisit_body (&DECL_SAVED_TREE (cgn->decl), cgn->decl);
1022 /* Unconditionally make an unshared copy of EXPR. This is used when using
1023 stored expressions which span multiple functions, such as BINFO_VTABLE,
1024 as the normal unsharing process can't tell that they're shared. */
1027 unshare_expr (tree expr)
1029 walk_tree (&expr, mostly_copy_tree_r, NULL, NULL);
1033 /* WRAPPER is a code such as BIND_EXPR or CLEANUP_POINT_EXPR which can both
1034 contain statements and have a value. Assign its value to a temporary
1035 and give it void_type_node. Return the temporary, or NULL_TREE if
1036 WRAPPER was already void. */
1039 voidify_wrapper_expr (tree wrapper, tree temp)
1041 tree type = TREE_TYPE (wrapper);
1042 if (type && !VOID_TYPE_P (type))
1046 /* Set p to point to the body of the wrapper. Loop until we find
1047 something that isn't a wrapper. */
1048 for (p = &wrapper; p && *p; )
1050 switch (TREE_CODE (*p))
1053 TREE_SIDE_EFFECTS (*p) = 1;
1054 TREE_TYPE (*p) = void_type_node;
1055 /* For a BIND_EXPR, the body is operand 1. */
1056 p = &BIND_EXPR_BODY (*p);
1059 case CLEANUP_POINT_EXPR:
1060 case TRY_FINALLY_EXPR:
1061 case TRY_CATCH_EXPR:
1062 TREE_SIDE_EFFECTS (*p) = 1;
1063 TREE_TYPE (*p) = void_type_node;
1064 p = &TREE_OPERAND (*p, 0);
1067 case STATEMENT_LIST:
1069 tree_stmt_iterator i = tsi_last (*p);
1070 TREE_SIDE_EFFECTS (*p) = 1;
1071 TREE_TYPE (*p) = void_type_node;
1072 p = tsi_end_p (i) ? NULL : tsi_stmt_ptr (i);
1077 /* Advance to the last statement. Set all container types to
1079 for (; TREE_CODE (*p) == COMPOUND_EXPR; p = &TREE_OPERAND (*p, 1))
1081 TREE_SIDE_EFFECTS (*p) = 1;
1082 TREE_TYPE (*p) = void_type_node;
1086 case TRANSACTION_EXPR:
1087 TREE_SIDE_EFFECTS (*p) = 1;
1088 TREE_TYPE (*p) = void_type_node;
1089 p = &TRANSACTION_EXPR_BODY (*p);
1093 /* Assume that any tree upon which voidify_wrapper_expr is
1094 directly called is a wrapper, and that its body is op0. */
1097 TREE_SIDE_EFFECTS (*p) = 1;
1098 TREE_TYPE (*p) = void_type_node;
1099 p = &TREE_OPERAND (*p, 0);
1107 if (p == NULL || IS_EMPTY_STMT (*p))
1111 /* The wrapper is on the RHS of an assignment that we're pushing
1113 gcc_assert (TREE_CODE (temp) == INIT_EXPR
1114 || TREE_CODE (temp) == MODIFY_EXPR);
1115 TREE_OPERAND (temp, 1) = *p;
1120 temp = create_tmp_var (type, "retval");
1121 *p = build2 (INIT_EXPR, type, temp, *p);
1130 /* Prepare calls to builtins to SAVE and RESTORE the stack as well as
1131 a temporary through which they communicate. */
1134 build_stack_save_restore (gimple *save, gimple *restore)
1138 *save = gimple_build_call (builtin_decl_implicit (BUILT_IN_STACK_SAVE), 0);
1139 tmp_var = create_tmp_var (ptr_type_node, "saved_stack");
1140 gimple_call_set_lhs (*save, tmp_var);
1143 = gimple_build_call (builtin_decl_implicit (BUILT_IN_STACK_RESTORE),
1147 /* Gimplify a BIND_EXPR. Just voidify and recurse. */
1149 static enum gimplify_status
1150 gimplify_bind_expr (tree *expr_p, gimple_seq *pre_p)
1152 tree bind_expr = *expr_p;
1153 bool old_save_stack = gimplify_ctxp->save_stack;
1156 gimple_seq body, cleanup;
1159 tree temp = voidify_wrapper_expr (bind_expr, NULL);
1161 /* Mark variables seen in this bind expr. */
1162 for (t = BIND_EXPR_VARS (bind_expr); t ; t = DECL_CHAIN (t))
1164 if (TREE_CODE (t) == VAR_DECL)
1166 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
1168 /* Mark variable as local. */
1169 if (ctx && !DECL_EXTERNAL (t)
1170 && (! DECL_SEEN_IN_BIND_EXPR_P (t)
1171 || splay_tree_lookup (ctx->variables,
1172 (splay_tree_key) t) == NULL))
1173 omp_add_variable (gimplify_omp_ctxp, t, GOVD_LOCAL | GOVD_SEEN);
1175 DECL_SEEN_IN_BIND_EXPR_P (t) = 1;
1177 if (DECL_HARD_REGISTER (t) && !is_global_var (t) && cfun)
1178 cfun->has_local_explicit_reg_vars = true;
1181 /* Preliminarily mark non-addressed complex variables as eligible
1182 for promotion to gimple registers. We'll transform their uses
1184 if ((TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE
1185 || TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
1186 && !TREE_THIS_VOLATILE (t)
1187 && (TREE_CODE (t) == VAR_DECL && !DECL_HARD_REGISTER (t))
1188 && !needs_to_live_in_memory (t))
1189 DECL_GIMPLE_REG_P (t) = 1;
1192 gimple_bind = gimple_build_bind (BIND_EXPR_VARS (bind_expr), NULL,
1193 BIND_EXPR_BLOCK (bind_expr));
1194 gimple_push_bind_expr (gimple_bind);
1196 gimplify_ctxp->save_stack = false;
1198 /* Gimplify the body into the GIMPLE_BIND tuple's body. */
1200 gimplify_stmt (&BIND_EXPR_BODY (bind_expr), &body);
1201 gimple_bind_set_body (gimple_bind, body);
1205 if (gimplify_ctxp->save_stack)
1207 gimple stack_restore;
1209 /* Save stack on entry and restore it on exit. Add a try_finally
1210 block to achieve this. Note that mudflap depends on the
1211 format of the emitted code: see mx_register_decls(). */
1212 build_stack_save_restore (&stack_save, &stack_restore);
1214 gimplify_seq_add_stmt (&cleanup, stack_restore);
1217 /* Add clobbers for all variables that go out of scope. */
1218 for (t = BIND_EXPR_VARS (bind_expr); t ; t = DECL_CHAIN (t))
1220 if (TREE_CODE (t) == VAR_DECL
1221 && !is_global_var (t)
1222 && DECL_CONTEXT (t) == current_function_decl
1223 && !DECL_HARD_REGISTER (t)
1224 && !TREE_THIS_VOLATILE (t)
1225 && !DECL_HAS_VALUE_EXPR_P (t)
1226 /* Only care for variables that have to be in memory. Others
1227 will be rewritten into SSA names, hence moved to the top-level. */
1228 && needs_to_live_in_memory (t))
1230 tree clobber = build_constructor (TREE_TYPE (t), NULL);
1231 TREE_THIS_VOLATILE (clobber) = 1;
1232 gimplify_seq_add_stmt (&cleanup, gimple_build_assign (t, clobber));
1239 gimple_seq new_body;
1242 gs = gimple_build_try (gimple_bind_body (gimple_bind), cleanup,
1243 GIMPLE_TRY_FINALLY);
1246 gimplify_seq_add_stmt (&new_body, stack_save);
1247 gimplify_seq_add_stmt (&new_body, gs);
1248 gimple_bind_set_body (gimple_bind, new_body);
1251 gimplify_ctxp->save_stack = old_save_stack;
1252 gimple_pop_bind_expr ();
1254 gimplify_seq_add_stmt (pre_p, gimple_bind);
1262 *expr_p = NULL_TREE;
1266 /* Gimplify a RETURN_EXPR. If the expression to be returned is not a
1267 GIMPLE value, it is assigned to a new temporary and the statement is
1268 re-written to return the temporary.
1270 PRE_P points to the sequence where side effects that must happen before
1271 STMT should be stored. */
1273 static enum gimplify_status
1274 gimplify_return_expr (tree stmt, gimple_seq *pre_p)
1277 tree ret_expr = TREE_OPERAND (stmt, 0);
1278 tree result_decl, result;
1280 if (ret_expr == error_mark_node)
1284 || TREE_CODE (ret_expr) == RESULT_DECL
1285 || ret_expr == error_mark_node)
1287 gimple ret = gimple_build_return (ret_expr);
1288 gimple_set_no_warning (ret, TREE_NO_WARNING (stmt));
1289 gimplify_seq_add_stmt (pre_p, ret);
1293 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl))))
1294 result_decl = NULL_TREE;
1297 result_decl = TREE_OPERAND (ret_expr, 0);
1299 /* See through a return by reference. */
1300 if (TREE_CODE (result_decl) == INDIRECT_REF)
1301 result_decl = TREE_OPERAND (result_decl, 0);
1303 gcc_assert ((TREE_CODE (ret_expr) == MODIFY_EXPR
1304 || TREE_CODE (ret_expr) == INIT_EXPR)
1305 && TREE_CODE (result_decl) == RESULT_DECL);
1308 /* If aggregate_value_p is true, then we can return the bare RESULT_DECL.
1309 Recall that aggregate_value_p is FALSE for any aggregate type that is
1310 returned in registers. If we're returning values in registers, then
1311 we don't want to extend the lifetime of the RESULT_DECL, particularly
1312 across another call. In addition, for those aggregates for which
1313 hard_function_value generates a PARALLEL, we'll die during normal
1314 expansion of structure assignments; there's special code in expand_return
1315 to handle this case that does not exist in expand_expr. */
1318 else if (aggregate_value_p (result_decl, TREE_TYPE (current_function_decl)))
1320 if (TREE_CODE (DECL_SIZE (result_decl)) != INTEGER_CST)
1322 if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (result_decl)))
1323 gimplify_type_sizes (TREE_TYPE (result_decl), pre_p);
1324 /* Note that we don't use gimplify_vla_decl because the RESULT_DECL
1325 should be effectively allocated by the caller, i.e. all calls to
1326 this function must be subject to the Return Slot Optimization. */
1327 gimplify_one_sizepos (&DECL_SIZE (result_decl), pre_p);
1328 gimplify_one_sizepos (&DECL_SIZE_UNIT (result_decl), pre_p);
1330 result = result_decl;
1332 else if (gimplify_ctxp->return_temp)
1333 result = gimplify_ctxp->return_temp;
1336 result = create_tmp_reg (TREE_TYPE (result_decl), NULL);
1338 /* ??? With complex control flow (usually involving abnormal edges),
1339 we can wind up warning about an uninitialized value for this. Due
1340 to how this variable is constructed and initialized, this is never
1341 true. Give up and never warn. */
1342 TREE_NO_WARNING (result) = 1;
1344 gimplify_ctxp->return_temp = result;
1347 /* Smash the lhs of the MODIFY_EXPR to the temporary we plan to use.
1348 Then gimplify the whole thing. */
1349 if (result != result_decl)
1350 TREE_OPERAND (ret_expr, 0) = result;
1352 gimplify_and_add (TREE_OPERAND (stmt, 0), pre_p);
1354 ret = gimple_build_return (result);
1355 gimple_set_no_warning (ret, TREE_NO_WARNING (stmt));
1356 gimplify_seq_add_stmt (pre_p, ret);
1361 /* Gimplify a variable-length array DECL. */
1364 gimplify_vla_decl (tree decl, gimple_seq *seq_p)
1366 /* This is a variable-sized decl. Simplify its size and mark it
1367 for deferred expansion. Note that mudflap depends on the format
1368 of the emitted code: see mx_register_decls(). */
1369 tree t, addr, ptr_type;
1371 gimplify_one_sizepos (&DECL_SIZE (decl), seq_p);
1372 gimplify_one_sizepos (&DECL_SIZE_UNIT (decl), seq_p);
1374 /* All occurrences of this decl in final gimplified code will be
1375 replaced by indirection. Setting DECL_VALUE_EXPR does two
1376 things: First, it lets the rest of the gimplifier know what
1377 replacement to use. Second, it lets the debug info know
1378 where to find the value. */
1379 ptr_type = build_pointer_type (TREE_TYPE (decl));
1380 addr = create_tmp_var (ptr_type, get_name (decl));
1381 DECL_IGNORED_P (addr) = 0;
1382 t = build_fold_indirect_ref (addr);
1383 TREE_THIS_NOTRAP (t) = 1;
1384 SET_DECL_VALUE_EXPR (decl, t);
1385 DECL_HAS_VALUE_EXPR_P (decl) = 1;
1387 t = builtin_decl_explicit (BUILT_IN_ALLOCA_WITH_ALIGN);
1388 t = build_call_expr (t, 2, DECL_SIZE_UNIT (decl),
1389 size_int (DECL_ALIGN (decl)));
1390 /* The call has been built for a variable-sized object. */
1391 CALL_ALLOCA_FOR_VAR_P (t) = 1;
1392 t = fold_convert (ptr_type, t);
1393 t = build2 (MODIFY_EXPR, TREE_TYPE (addr), addr, t);
1395 gimplify_and_add (t, seq_p);
1397 /* Indicate that we need to restore the stack level when the
1398 enclosing BIND_EXPR is exited. */
1399 gimplify_ctxp->save_stack = true;
1402 /* Gimplify a DECL_EXPR node *STMT_P by making any necessary allocation
1403 and initialization explicit. */
1405 static enum gimplify_status
1406 gimplify_decl_expr (tree *stmt_p, gimple_seq *seq_p)
1408 tree stmt = *stmt_p;
1409 tree decl = DECL_EXPR_DECL (stmt);
1411 *stmt_p = NULL_TREE;
1413 if (TREE_TYPE (decl) == error_mark_node)
1416 if ((TREE_CODE (decl) == TYPE_DECL
1417 || TREE_CODE (decl) == VAR_DECL)
1418 && !TYPE_SIZES_GIMPLIFIED (TREE_TYPE (decl)))
1419 gimplify_type_sizes (TREE_TYPE (decl), seq_p);
1421 if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl))
1423 tree init = DECL_INITIAL (decl);
1425 if (TREE_CODE (DECL_SIZE_UNIT (decl)) != INTEGER_CST
1426 || (!TREE_STATIC (decl)
1427 && flag_stack_check == GENERIC_STACK_CHECK
1428 && compare_tree_int (DECL_SIZE_UNIT (decl),
1429 STACK_CHECK_MAX_VAR_SIZE) > 0))
1430 gimplify_vla_decl (decl, seq_p);
1432 /* Some front ends do not explicitly declare all anonymous
1433 artificial variables. We compensate here by declaring the
1434 variables, though it would be better if the front ends would
1435 explicitly declare them. */
1436 if (!DECL_SEEN_IN_BIND_EXPR_P (decl)
1437 && DECL_ARTIFICIAL (decl) && DECL_NAME (decl) == NULL_TREE)
1438 gimple_add_tmp_var (decl);
1440 if (init && init != error_mark_node)
1442 if (!TREE_STATIC (decl))
1444 DECL_INITIAL (decl) = NULL_TREE;
1445 init = build2 (INIT_EXPR, void_type_node, decl, init);
1446 gimplify_and_add (init, seq_p);
1450 /* We must still examine initializers for static variables
1451 as they may contain a label address. */
1452 walk_tree (&init, force_labels_r, NULL, NULL);
1459 /* Gimplify a LOOP_EXPR. Normally this just involves gimplifying the body
1460 and replacing the LOOP_EXPR with goto, but if the loop contains an
1461 EXIT_EXPR, we need to append a label for it to jump to. */
1463 static enum gimplify_status
1464 gimplify_loop_expr (tree *expr_p, gimple_seq *pre_p)
1466 tree saved_label = gimplify_ctxp->exit_label;
1467 tree start_label = create_artificial_label (UNKNOWN_LOCATION);
1469 gimplify_seq_add_stmt (pre_p, gimple_build_label (start_label));
1471 gimplify_ctxp->exit_label = NULL_TREE;
1473 gimplify_and_add (LOOP_EXPR_BODY (*expr_p), pre_p);
1475 gimplify_seq_add_stmt (pre_p, gimple_build_goto (start_label));
1477 if (gimplify_ctxp->exit_label)
1478 gimplify_seq_add_stmt (pre_p,
1479 gimple_build_label (gimplify_ctxp->exit_label));
1481 gimplify_ctxp->exit_label = saved_label;
1487 /* Gimplify a statement list onto a sequence. These may be created either
1488 by an enlightened front-end, or by shortcut_cond_expr. */
1490 static enum gimplify_status
1491 gimplify_statement_list (tree *expr_p, gimple_seq *pre_p)
1493 tree temp = voidify_wrapper_expr (*expr_p, NULL);
1495 tree_stmt_iterator i = tsi_start (*expr_p);
1497 while (!tsi_end_p (i))
1499 gimplify_stmt (tsi_stmt_ptr (i), pre_p);
1512 /* Compare two case labels. Because the front end should already have
1513 made sure that case ranges do not overlap, it is enough to only compare
1514 the CASE_LOW values of each case label. */
1517 compare_case_labels (const void *p1, const void *p2)
1519 const_tree const case1 = *(const_tree const*)p1;
1520 const_tree const case2 = *(const_tree const*)p2;
1522 /* The 'default' case label always goes first. */
1523 if (!CASE_LOW (case1))
1525 else if (!CASE_LOW (case2))
1528 return tree_int_cst_compare (CASE_LOW (case1), CASE_LOW (case2));
1531 /* Sort the case labels in LABEL_VEC in place in ascending order. */
1534 sort_case_labels (VEC(tree,heap)* label_vec)
1536 VEC_qsort (tree, label_vec, compare_case_labels);
1539 /* Gimplify a SWITCH_EXPR, and collect a TREE_VEC of the labels it can
1542 static enum gimplify_status
1543 gimplify_switch_expr (tree *expr_p, gimple_seq *pre_p)
1545 tree switch_expr = *expr_p;
1546 gimple_seq switch_body_seq = NULL;
1547 enum gimplify_status ret;
1549 ret = gimplify_expr (&SWITCH_COND (switch_expr), pre_p, NULL, is_gimple_val,
1551 if (ret == GS_ERROR || ret == GS_UNHANDLED)
1554 if (SWITCH_BODY (switch_expr))
1556 VEC (tree,heap) *labels;
1557 VEC (tree,heap) *saved_labels;
1558 tree default_case = NULL_TREE;
1560 gimple gimple_switch;
1562 /* If someone can be bothered to fill in the labels, they can
1563 be bothered to null out the body too. */
1564 gcc_assert (!SWITCH_LABELS (switch_expr));
1566 /* save old labels, get new ones from body, then restore the old
1567 labels. Save all the things from the switch body to append after. */
1568 saved_labels = gimplify_ctxp->case_labels;
1569 gimplify_ctxp->case_labels = VEC_alloc (tree, heap, 8);
1571 gimplify_stmt (&SWITCH_BODY (switch_expr), &switch_body_seq);
1572 labels = gimplify_ctxp->case_labels;
1573 gimplify_ctxp->case_labels = saved_labels;
1576 while (i < VEC_length (tree, labels))
1578 tree elt = VEC_index (tree, labels, i);
1579 tree low = CASE_LOW (elt);
1580 bool remove_element = FALSE;
1584 /* Discard empty ranges. */
1585 tree high = CASE_HIGH (elt);
1586 if (high && tree_int_cst_lt (high, low))
1587 remove_element = TRUE;
1591 /* The default case must be the last label in the list. */
1592 gcc_assert (!default_case);
1594 remove_element = TRUE;
1598 VEC_ordered_remove (tree, labels, i);
1604 if (!VEC_empty (tree, labels))
1605 sort_case_labels (labels);
1609 tree type = TREE_TYPE (switch_expr);
1611 /* If the switch has no default label, add one, so that we jump
1612 around the switch body. If the labels already cover the whole
1613 range of type, add the default label pointing to one of the
1615 if (type == void_type_node)
1616 type = TREE_TYPE (SWITCH_COND (switch_expr));
1618 && INTEGRAL_TYPE_P (type)
1619 && TYPE_MIN_VALUE (type)
1620 && TYPE_MAX_VALUE (type)
1621 && tree_int_cst_equal (CASE_LOW (VEC_index (tree, labels, 0)),
1622 TYPE_MIN_VALUE (type)))
1624 tree low, high = CASE_HIGH (VEC_index (tree, labels, len - 1));
1626 high = CASE_LOW (VEC_index (tree, labels, len - 1));
1627 if (tree_int_cst_equal (high, TYPE_MAX_VALUE (type)))
1629 for (i = 1; i < len; i++)
1631 high = CASE_LOW (VEC_index (tree, labels, i));
1632 low = CASE_HIGH (VEC_index (tree, labels, i - 1));
1634 low = CASE_LOW (VEC_index (tree, labels, i - 1));
1635 if ((TREE_INT_CST_LOW (low) + 1
1636 != TREE_INT_CST_LOW (high))
1637 || (TREE_INT_CST_HIGH (low)
1638 + (TREE_INT_CST_LOW (high) == 0)
1639 != TREE_INT_CST_HIGH (high)))
1644 tree label = CASE_LABEL (VEC_index (tree, labels, 0));
1645 default_case = build_case_label (NULL_TREE, NULL_TREE,
1656 = build_case_label (NULL_TREE, NULL_TREE,
1657 create_artificial_label (UNKNOWN_LOCATION));
1658 new_default = gimple_build_label (CASE_LABEL (default_case));
1659 gimplify_seq_add_stmt (&switch_body_seq, new_default);
1663 gimple_switch = gimple_build_switch_vec (SWITCH_COND (switch_expr),
1664 default_case, labels);
1665 gimplify_seq_add_stmt (pre_p, gimple_switch);
1666 gimplify_seq_add_seq (pre_p, switch_body_seq);
1667 VEC_free(tree, heap, labels);
1670 gcc_assert (SWITCH_LABELS (switch_expr));
1675 /* Gimplify the CASE_LABEL_EXPR pointed to by EXPR_P. */
1677 static enum gimplify_status
1678 gimplify_case_label_expr (tree *expr_p, gimple_seq *pre_p)
1680 struct gimplify_ctx *ctxp;
1681 gimple gimple_label;
1683 /* Invalid OpenMP programs can play Duff's Device type games with
1684 #pragma omp parallel. At least in the C front end, we don't
1685 detect such invalid branches until after gimplification. */
1686 for (ctxp = gimplify_ctxp; ; ctxp = ctxp->prev_context)
1687 if (ctxp->case_labels)
1690 gimple_label = gimple_build_label (CASE_LABEL (*expr_p));
1691 VEC_safe_push (tree, heap, ctxp->case_labels, *expr_p);
1692 gimplify_seq_add_stmt (pre_p, gimple_label);
1697 /* Build a GOTO to the LABEL_DECL pointed to by LABEL_P, building it first
1701 build_and_jump (tree *label_p)
1703 if (label_p == NULL)
1704 /* If there's nowhere to jump, just fall through. */
1707 if (*label_p == NULL_TREE)
1709 tree label = create_artificial_label (UNKNOWN_LOCATION);
1713 return build1 (GOTO_EXPR, void_type_node, *label_p);
1716 /* Gimplify an EXIT_EXPR by converting to a GOTO_EXPR inside a COND_EXPR.
1717 This also involves building a label to jump to and communicating it to
1718 gimplify_loop_expr through gimplify_ctxp->exit_label. */
1720 static enum gimplify_status
1721 gimplify_exit_expr (tree *expr_p)
1723 tree cond = TREE_OPERAND (*expr_p, 0);
1726 expr = build_and_jump (&gimplify_ctxp->exit_label);
1727 expr = build3 (COND_EXPR, void_type_node, cond, expr, NULL_TREE);
1733 /* A helper function to be called via walk_tree. Mark all labels under *TP
1734 as being forced. To be called for DECL_INITIAL of static variables. */
1737 force_labels_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
1741 if (TREE_CODE (*tp) == LABEL_DECL)
1742 FORCED_LABEL (*tp) = 1;
1747 /* *EXPR_P is a COMPONENT_REF being used as an rvalue. If its type is
1748 different from its canonical type, wrap the whole thing inside a
1749 NOP_EXPR and force the type of the COMPONENT_REF to be the canonical
1752 The canonical type of a COMPONENT_REF is the type of the field being
1753 referenced--unless the field is a bit-field which can be read directly
1754 in a smaller mode, in which case the canonical type is the
1755 sign-appropriate type corresponding to that mode. */
1758 canonicalize_component_ref (tree *expr_p)
1760 tree expr = *expr_p;
1763 gcc_assert (TREE_CODE (expr) == COMPONENT_REF);
1765 if (INTEGRAL_TYPE_P (TREE_TYPE (expr)))
1766 type = TREE_TYPE (get_unwidened (expr, NULL_TREE));
1768 type = TREE_TYPE (TREE_OPERAND (expr, 1));
1770 /* One could argue that all the stuff below is not necessary for
1771 the non-bitfield case and declare it a FE error if type
1772 adjustment would be needed. */
1773 if (TREE_TYPE (expr) != type)
1775 #ifdef ENABLE_TYPES_CHECKING
1776 tree old_type = TREE_TYPE (expr);
1780 /* We need to preserve qualifiers and propagate them from
1782 type_quals = TYPE_QUALS (type)
1783 | TYPE_QUALS (TREE_TYPE (TREE_OPERAND (expr, 0)));
1784 if (TYPE_QUALS (type) != type_quals)
1785 type = build_qualified_type (TYPE_MAIN_VARIANT (type), type_quals);
1787 /* Set the type of the COMPONENT_REF to the underlying type. */
1788 TREE_TYPE (expr) = type;
1790 #ifdef ENABLE_TYPES_CHECKING
1791 /* It is now a FE error, if the conversion from the canonical
1792 type to the original expression type is not useless. */
1793 gcc_assert (useless_type_conversion_p (old_type, type));
1798 /* If a NOP conversion is changing a pointer to array of foo to a pointer
1799 to foo, embed that change in the ADDR_EXPR by converting
1804 where L is the lower bound. For simplicity, only do this for constant
1806 The constraint is that the type of &array[L] is trivially convertible
1810 canonicalize_addr_expr (tree *expr_p)
1812 tree expr = *expr_p;
1813 tree addr_expr = TREE_OPERAND (expr, 0);
1814 tree datype, ddatype, pddatype;
1816 /* We simplify only conversions from an ADDR_EXPR to a pointer type. */
1817 if (!POINTER_TYPE_P (TREE_TYPE (expr))
1818 || TREE_CODE (addr_expr) != ADDR_EXPR)
1821 /* The addr_expr type should be a pointer to an array. */
1822 datype = TREE_TYPE (TREE_TYPE (addr_expr));
1823 if (TREE_CODE (datype) != ARRAY_TYPE)
1826 /* The pointer to element type shall be trivially convertible to
1827 the expression pointer type. */
1828 ddatype = TREE_TYPE (datype);
1829 pddatype = build_pointer_type (ddatype);
1830 if (!useless_type_conversion_p (TYPE_MAIN_VARIANT (TREE_TYPE (expr)),
1834 /* The lower bound and element sizes must be constant. */
1835 if (!TYPE_SIZE_UNIT (ddatype)
1836 || TREE_CODE (TYPE_SIZE_UNIT (ddatype)) != INTEGER_CST
1837 || !TYPE_DOMAIN (datype) || !TYPE_MIN_VALUE (TYPE_DOMAIN (datype))
1838 || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (datype))) != INTEGER_CST)
1841 /* All checks succeeded. Build a new node to merge the cast. */
1842 *expr_p = build4 (ARRAY_REF, ddatype, TREE_OPERAND (addr_expr, 0),
1843 TYPE_MIN_VALUE (TYPE_DOMAIN (datype)),
1844 NULL_TREE, NULL_TREE);
1845 *expr_p = build1 (ADDR_EXPR, pddatype, *expr_p);
1847 /* We can have stripped a required restrict qualifier above. */
1848 if (!useless_type_conversion_p (TREE_TYPE (expr), TREE_TYPE (*expr_p)))
1849 *expr_p = fold_convert (TREE_TYPE (expr), *expr_p);
1852 /* *EXPR_P is a NOP_EXPR or CONVERT_EXPR. Remove it and/or other conversions
1853 underneath as appropriate. */
1855 static enum gimplify_status
1856 gimplify_conversion (tree *expr_p)
1858 location_t loc = EXPR_LOCATION (*expr_p);
1859 gcc_assert (CONVERT_EXPR_P (*expr_p));
1861 /* Then strip away all but the outermost conversion. */
1862 STRIP_SIGN_NOPS (TREE_OPERAND (*expr_p, 0));
1864 /* And remove the outermost conversion if it's useless. */
1865 if (tree_ssa_useless_type_conversion (*expr_p))
1866 *expr_p = TREE_OPERAND (*expr_p, 0);
1868 /* If we still have a conversion at the toplevel,
1869 then canonicalize some constructs. */
1870 if (CONVERT_EXPR_P (*expr_p))
1872 tree sub = TREE_OPERAND (*expr_p, 0);
1874 /* If a NOP conversion is changing the type of a COMPONENT_REF
1875 expression, then canonicalize its type now in order to expose more
1876 redundant conversions. */
1877 if (TREE_CODE (sub) == COMPONENT_REF)
1878 canonicalize_component_ref (&TREE_OPERAND (*expr_p, 0));
1880 /* If a NOP conversion is changing a pointer to array of foo
1881 to a pointer to foo, embed that change in the ADDR_EXPR. */
1882 else if (TREE_CODE (sub) == ADDR_EXPR)
1883 canonicalize_addr_expr (expr_p);
1886 /* If we have a conversion to a non-register type force the
1887 use of a VIEW_CONVERT_EXPR instead. */
1888 if (CONVERT_EXPR_P (*expr_p) && !is_gimple_reg_type (TREE_TYPE (*expr_p)))
1889 *expr_p = fold_build1_loc (loc, VIEW_CONVERT_EXPR, TREE_TYPE (*expr_p),
1890 TREE_OPERAND (*expr_p, 0));
1895 /* Nonlocal VLAs seen in the current function. */
1896 static struct pointer_set_t *nonlocal_vlas;
1898 /* Gimplify a VAR_DECL or PARM_DECL. Return GS_OK if we expanded a
1899 DECL_VALUE_EXPR, and it's worth re-examining things. */
1901 static enum gimplify_status
1902 gimplify_var_or_parm_decl (tree *expr_p)
1904 tree decl = *expr_p;
1906 /* ??? If this is a local variable, and it has not been seen in any
1907 outer BIND_EXPR, then it's probably the result of a duplicate
1908 declaration, for which we've already issued an error. It would
1909 be really nice if the front end wouldn't leak these at all.
1910 Currently the only known culprit is C++ destructors, as seen
1911 in g++.old-deja/g++.jason/binding.C. */
1912 if (TREE_CODE (decl) == VAR_DECL
1913 && !DECL_SEEN_IN_BIND_EXPR_P (decl)
1914 && !TREE_STATIC (decl) && !DECL_EXTERNAL (decl)
1915 && decl_function_context (decl) == current_function_decl)
1917 gcc_assert (seen_error ());
1921 /* When within an OpenMP context, notice uses of variables. */
1922 if (gimplify_omp_ctxp && omp_notice_variable (gimplify_omp_ctxp, decl, true))
1925 /* If the decl is an alias for another expression, substitute it now. */
1926 if (DECL_HAS_VALUE_EXPR_P (decl))
1928 tree value_expr = DECL_VALUE_EXPR (decl);
1930 /* For referenced nonlocal VLAs add a decl for debugging purposes
1931 to the current function. */
1932 if (TREE_CODE (decl) == VAR_DECL
1933 && TREE_CODE (DECL_SIZE_UNIT (decl)) != INTEGER_CST
1934 && nonlocal_vlas != NULL
1935 && TREE_CODE (value_expr) == INDIRECT_REF
1936 && TREE_CODE (TREE_OPERAND (value_expr, 0)) == VAR_DECL
1937 && decl_function_context (decl) != current_function_decl)
1939 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
1940 while (ctx && ctx->region_type == ORT_WORKSHARE)
1941 ctx = ctx->outer_context;
1942 if (!ctx && !pointer_set_insert (nonlocal_vlas, decl))
1944 tree copy = copy_node (decl), block;
1946 lang_hooks.dup_lang_specific_decl (copy);
1947 SET_DECL_RTL (copy, 0);
1948 TREE_USED (copy) = 1;
1949 block = DECL_INITIAL (current_function_decl);
1950 DECL_CHAIN (copy) = BLOCK_VARS (block);
1951 BLOCK_VARS (block) = copy;
1952 SET_DECL_VALUE_EXPR (copy, unshare_expr (value_expr));
1953 DECL_HAS_VALUE_EXPR_P (copy) = 1;
1957 *expr_p = unshare_expr (value_expr);
1964 /* Gimplify the COMPONENT_REF, ARRAY_REF, REALPART_EXPR or IMAGPART_EXPR
1968 : min_lval '[' val ']'
1970 | compound_lval '[' val ']'
1971 | compound_lval '.' ID
1973 This is not part of the original SIMPLE definition, which separates
1974 array and member references, but it seems reasonable to handle them
1975 together. Also, this way we don't run into problems with union
1976 aliasing; gcc requires that for accesses through a union to alias, the
1977 union reference must be explicit, which was not always the case when we
1978 were splitting up array and member refs.
1980 PRE_P points to the sequence where side effects that must happen before
1981 *EXPR_P should be stored.
1983 POST_P points to the sequence where side effects that must happen after
1984 *EXPR_P should be stored. */
1986 static enum gimplify_status
1987 gimplify_compound_lval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
1988 fallback_t fallback)
1991 VEC(tree,heap) *stack;
1992 enum gimplify_status ret = GS_ALL_DONE, tret;
1994 location_t loc = EXPR_LOCATION (*expr_p);
1995 tree expr = *expr_p;
1997 /* Create a stack of the subexpressions so later we can walk them in
1998 order from inner to outer. */
1999 stack = VEC_alloc (tree, heap, 10);
2001 /* We can handle anything that get_inner_reference can deal with. */
2002 for (p = expr_p; ; p = &TREE_OPERAND (*p, 0))
2005 /* Fold INDIRECT_REFs now to turn them into ARRAY_REFs. */
2006 if (TREE_CODE (*p) == INDIRECT_REF)
2007 *p = fold_indirect_ref_loc (loc, *p);
2009 if (handled_component_p (*p))
2011 /* Expand DECL_VALUE_EXPR now. In some cases that may expose
2012 additional COMPONENT_REFs. */
2013 else if ((TREE_CODE (*p) == VAR_DECL || TREE_CODE (*p) == PARM_DECL)
2014 && gimplify_var_or_parm_decl (p) == GS_OK)
2019 VEC_safe_push (tree, heap, stack, *p);
2022 gcc_assert (VEC_length (tree, stack));
2024 /* Now STACK is a stack of pointers to all the refs we've walked through
2025 and P points to the innermost expression.
2027 Java requires that we elaborated nodes in source order. That
2028 means we must gimplify the inner expression followed by each of
2029 the indices, in order. But we can't gimplify the inner
2030 expression until we deal with any variable bounds, sizes, or
2031 positions in order to deal with PLACEHOLDER_EXPRs.
2033 So we do this in three steps. First we deal with the annotations
2034 for any variables in the components, then we gimplify the base,
2035 then we gimplify any indices, from left to right. */
2036 for (i = VEC_length (tree, stack) - 1; i >= 0; i--)
2038 tree t = VEC_index (tree, stack, i);
2040 if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
2042 /* Gimplify the low bound and element type size and put them into
2043 the ARRAY_REF. If these values are set, they have already been
2045 if (TREE_OPERAND (t, 2) == NULL_TREE)
2047 tree low = unshare_expr (array_ref_low_bound (t));
2048 if (!is_gimple_min_invariant (low))
2050 TREE_OPERAND (t, 2) = low;
2051 tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p,
2052 post_p, is_gimple_reg,
2054 ret = MIN (ret, tret);
2059 tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p,
2060 is_gimple_reg, fb_rvalue);
2061 ret = MIN (ret, tret);
2064 if (TREE_OPERAND (t, 3) == NULL_TREE)
2066 tree elmt_type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (t, 0)));
2067 tree elmt_size = unshare_expr (array_ref_element_size (t));
2068 tree factor = size_int (TYPE_ALIGN_UNIT (elmt_type));
2070 /* Divide the element size by the alignment of the element
2073 = size_binop_loc (loc, EXACT_DIV_EXPR, elmt_size, factor);
2075 if (!is_gimple_min_invariant (elmt_size))
2077 TREE_OPERAND (t, 3) = elmt_size;
2078 tret = gimplify_expr (&TREE_OPERAND (t, 3), pre_p,
2079 post_p, is_gimple_reg,
2081 ret = MIN (ret, tret);
2086 tret = gimplify_expr (&TREE_OPERAND (t, 3), pre_p, post_p,
2087 is_gimple_reg, fb_rvalue);
2088 ret = MIN (ret, tret);
2091 else if (TREE_CODE (t) == COMPONENT_REF)
2093 /* Set the field offset into T and gimplify it. */
2094 if (TREE_OPERAND (t, 2) == NULL_TREE)
2096 tree offset = unshare_expr (component_ref_field_offset (t));
2097 tree field = TREE_OPERAND (t, 1);
2099 = size_int (DECL_OFFSET_ALIGN (field) / BITS_PER_UNIT);
2101 /* Divide the offset by its alignment. */
2102 offset = size_binop_loc (loc, EXACT_DIV_EXPR, offset, factor);
2104 if (!is_gimple_min_invariant (offset))
2106 TREE_OPERAND (t, 2) = offset;
2107 tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p,
2108 post_p, is_gimple_reg,
2110 ret = MIN (ret, tret);
2115 tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p,
2116 is_gimple_reg, fb_rvalue);
2117 ret = MIN (ret, tret);
2122 /* Step 2 is to gimplify the base expression. Make sure lvalue is set
2123 so as to match the min_lval predicate. Failure to do so may result
2124 in the creation of large aggregate temporaries. */
2125 tret = gimplify_expr (p, pre_p, post_p, is_gimple_min_lval,
2126 fallback | fb_lvalue);
2127 ret = MIN (ret, tret);
2129 /* And finally, the indices and operands to BIT_FIELD_REF. During this
2130 loop we also remove any useless conversions. */
2131 for (; VEC_length (tree, stack) > 0; )
2133 tree t = VEC_pop (tree, stack);
2135 if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
2137 /* Gimplify the dimension. */
2138 if (!is_gimple_min_invariant (TREE_OPERAND (t, 1)))
2140 tret = gimplify_expr (&TREE_OPERAND (t, 1), pre_p, post_p,
2141 is_gimple_val, fb_rvalue);
2142 ret = MIN (ret, tret);
2145 else if (TREE_CODE (t) == BIT_FIELD_REF)
2147 tret = gimplify_expr (&TREE_OPERAND (t, 1), pre_p, post_p,
2148 is_gimple_val, fb_rvalue);
2149 ret = MIN (ret, tret);
2150 tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p,
2151 is_gimple_val, fb_rvalue);
2152 ret = MIN (ret, tret);
2155 STRIP_USELESS_TYPE_CONVERSION (TREE_OPERAND (t, 0));
2157 /* The innermost expression P may have originally had
2158 TREE_SIDE_EFFECTS set which would have caused all the outer
2159 expressions in *EXPR_P leading to P to also have had
2160 TREE_SIDE_EFFECTS set. */
2161 recalculate_side_effects (t);
2164 /* If the outermost expression is a COMPONENT_REF, canonicalize its type. */
2165 if ((fallback & fb_rvalue) && TREE_CODE (*expr_p) == COMPONENT_REF)
2167 canonicalize_component_ref (expr_p);
2170 VEC_free (tree, heap, stack);
2172 gcc_assert (*expr_p == expr || ret != GS_ALL_DONE);
2177 /* Gimplify the self modifying expression pointed to by EXPR_P
2180 PRE_P points to the list where side effects that must happen before
2181 *EXPR_P should be stored.
2183 POST_P points to the list where side effects that must happen after
2184 *EXPR_P should be stored.
2186 WANT_VALUE is nonzero iff we want to use the value of this expression
2187 in another expression. */
2189 static enum gimplify_status
2190 gimplify_self_mod_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
2193 enum tree_code code;
2194 tree lhs, lvalue, rhs, t1;
2195 gimple_seq post = NULL, *orig_post_p = post_p;
2197 enum tree_code arith_code;
2198 enum gimplify_status ret;
2199 location_t loc = EXPR_LOCATION (*expr_p);
2201 code = TREE_CODE (*expr_p);
2203 gcc_assert (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR
2204 || code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR);
2206 /* Prefix or postfix? */
2207 if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
2208 /* Faster to treat as prefix if result is not used. */
2209 postfix = want_value;
2213 /* For postfix, make sure the inner expression's post side effects
2214 are executed after side effects from this expression. */
2218 /* Add or subtract? */
2219 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
2220 arith_code = PLUS_EXPR;
2222 arith_code = MINUS_EXPR;
2224 /* Gimplify the LHS into a GIMPLE lvalue. */
2225 lvalue = TREE_OPERAND (*expr_p, 0);
2226 ret = gimplify_expr (&lvalue, pre_p, post_p, is_gimple_lvalue, fb_lvalue);
2227 if (ret == GS_ERROR)
2230 /* Extract the operands to the arithmetic operation. */
2232 rhs = TREE_OPERAND (*expr_p, 1);
2234 /* For postfix operator, we evaluate the LHS to an rvalue and then use
2235 that as the result value and in the postqueue operation. We also
2236 make sure to make lvalue a minimal lval, see
2237 gcc.c-torture/execute/20040313-1.c for an example where this matters. */
2240 if (!is_gimple_min_lval (lvalue))
2242 mark_addressable (lvalue);
2243 lvalue = build_fold_addr_expr_loc (input_location, lvalue);
2244 gimplify_expr (&lvalue, pre_p, post_p, is_gimple_val, fb_rvalue);
2245 lvalue = build_fold_indirect_ref_loc (input_location, lvalue);
2247 ret = gimplify_expr (&lhs, pre_p, post_p, is_gimple_val, fb_rvalue);
2248 if (ret == GS_ERROR)
2252 /* For POINTERs increment, use POINTER_PLUS_EXPR. */
2253 if (POINTER_TYPE_P (TREE_TYPE (lhs)))
2255 rhs = convert_to_ptrofftype_loc (loc, rhs);
2256 if (arith_code == MINUS_EXPR)
2257 rhs = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (rhs), rhs);
2258 arith_code = POINTER_PLUS_EXPR;
2261 t1 = build2 (arith_code, TREE_TYPE (*expr_p), lhs, rhs);
2265 gimplify_assign (lvalue, t1, orig_post_p);
2266 gimplify_seq_add_seq (orig_post_p, post);
2272 *expr_p = build2 (MODIFY_EXPR, TREE_TYPE (lvalue), lvalue, t1);
2277 /* If *EXPR_P has a variable sized type, wrap it in a WITH_SIZE_EXPR. */
2280 maybe_with_size_expr (tree *expr_p)
2282 tree expr = *expr_p;
2283 tree type = TREE_TYPE (expr);
2286 /* If we've already wrapped this or the type is error_mark_node, we can't do
2288 if (TREE_CODE (expr) == WITH_SIZE_EXPR
2289 || type == error_mark_node)
2292 /* If the size isn't known or is a constant, we have nothing to do. */
2293 size = TYPE_SIZE_UNIT (type);
2294 if (!size || TREE_CODE (size) == INTEGER_CST)
2297 /* Otherwise, make a WITH_SIZE_EXPR. */
2298 size = unshare_expr (size);
2299 size = SUBSTITUTE_PLACEHOLDER_IN_EXPR (size, expr);
2300 *expr_p = build2 (WITH_SIZE_EXPR, type, expr, size);
2303 /* Helper for gimplify_call_expr. Gimplify a single argument *ARG_P
2304 Store any side-effects in PRE_P. CALL_LOCATION is the location of
2307 static enum gimplify_status
2308 gimplify_arg (tree *arg_p, gimple_seq *pre_p, location_t call_location)
2310 bool (*test) (tree);
2313 /* In general, we allow lvalues for function arguments to avoid
2314 extra overhead of copying large aggregates out of even larger
2315 aggregates into temporaries only to copy the temporaries to
2316 the argument list. Make optimizers happy by pulling out to
2317 temporaries those types that fit in registers. */
2318 if (is_gimple_reg_type (TREE_TYPE (*arg_p)))
2319 test = is_gimple_val, fb = fb_rvalue;
2322 test = is_gimple_lvalue, fb = fb_either;
2323 /* Also strip a TARGET_EXPR that would force an extra copy. */
2324 if (TREE_CODE (*arg_p) == TARGET_EXPR)
2326 tree init = TARGET_EXPR_INITIAL (*arg_p);
2328 && !VOID_TYPE_P (TREE_TYPE (init)))
2333 /* If this is a variable sized type, we must remember the size. */
2334 maybe_with_size_expr (arg_p);
2336 /* FIXME diagnostics: This will mess up gcc.dg/Warray-bounds.c. */
2337 /* Make sure arguments have the same location as the function call
2339 protected_set_expr_location (*arg_p, call_location);
2341 /* There is a sequence point before a function call. Side effects in
2342 the argument list must occur before the actual call. So, when
2343 gimplifying arguments, force gimplify_expr to use an internal
2344 post queue which is then appended to the end of PRE_P. */
2345 return gimplify_expr (arg_p, pre_p, NULL, test, fb);
2348 /* Gimplify the CALL_EXPR node *EXPR_P into the GIMPLE sequence PRE_P.
2349 WANT_VALUE is true if the result of the call is desired. */
2351 static enum gimplify_status
2352 gimplify_call_expr (tree *expr_p, gimple_seq *pre_p, bool want_value)
2354 tree fndecl, parms, p, fnptrtype;
2355 enum gimplify_status ret;
2358 bool builtin_va_start_p = FALSE;
2359 location_t loc = EXPR_LOCATION (*expr_p);
2361 gcc_assert (TREE_CODE (*expr_p) == CALL_EXPR);
2363 /* For reliable diagnostics during inlining, it is necessary that
2364 every call_expr be annotated with file and line. */
2365 if (! EXPR_HAS_LOCATION (*expr_p))
2366 SET_EXPR_LOCATION (*expr_p, input_location);
2368 /* This may be a call to a builtin function.
2370 Builtin function calls may be transformed into different
2371 (and more efficient) builtin function calls under certain
2372 circumstances. Unfortunately, gimplification can muck things
2373 up enough that the builtin expanders are not aware that certain
2374 transformations are still valid.
2376 So we attempt transformation/gimplification of the call before
2377 we gimplify the CALL_EXPR. At this time we do not manage to
2378 transform all calls in the same manner as the expanders do, but
2379 we do transform most of them. */
2380 fndecl = get_callee_fndecl (*expr_p);
2381 if (fndecl && DECL_BUILT_IN (fndecl))
2383 tree new_tree = fold_call_expr (input_location, *expr_p, !want_value);
2385 if (new_tree && new_tree != *expr_p)
2387 /* There was a transformation of this call which computes the
2388 same value, but in a more efficient way. Return and try
2394 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
2395 && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_VA_START)
2397 builtin_va_start_p = TRUE;
2398 if (call_expr_nargs (*expr_p) < 2)
2400 error ("too few arguments to function %<va_start%>");
2401 *expr_p = build_empty_stmt (EXPR_LOCATION (*expr_p));
2405 if (fold_builtin_next_arg (*expr_p, true))
2407 *expr_p = build_empty_stmt (EXPR_LOCATION (*expr_p));
2413 /* Remember the original function pointer type. */
2414 fnptrtype = TREE_TYPE (CALL_EXPR_FN (*expr_p));
2416 /* There is a sequence point before the call, so any side effects in
2417 the calling expression must occur before the actual call. Force
2418 gimplify_expr to use an internal post queue. */
2419 ret = gimplify_expr (&CALL_EXPR_FN (*expr_p), pre_p, NULL,
2420 is_gimple_call_addr, fb_rvalue);
2422 nargs = call_expr_nargs (*expr_p);
2424 /* Get argument types for verification. */
2425 fndecl = get_callee_fndecl (*expr_p);
2428 parms = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
2429 else if (POINTER_TYPE_P (TREE_TYPE (CALL_EXPR_FN (*expr_p))))
2430 parms = TYPE_ARG_TYPES (TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (*expr_p))));
2432 if (fndecl && DECL_ARGUMENTS (fndecl))
2433 p = DECL_ARGUMENTS (fndecl);
2438 for (i = 0; i < nargs && p; i++, p = TREE_CHAIN (p))
2441 /* If the last argument is __builtin_va_arg_pack () and it is not
2442 passed as a named argument, decrease the number of CALL_EXPR
2443 arguments and set instead the CALL_EXPR_VA_ARG_PACK flag. */
2446 && TREE_CODE (CALL_EXPR_ARG (*expr_p, nargs - 1)) == CALL_EXPR)
2448 tree last_arg = CALL_EXPR_ARG (*expr_p, nargs - 1);
2449 tree last_arg_fndecl = get_callee_fndecl (last_arg);
2452 && TREE_CODE (last_arg_fndecl) == FUNCTION_DECL
2453 && DECL_BUILT_IN_CLASS (last_arg_fndecl) == BUILT_IN_NORMAL
2454 && DECL_FUNCTION_CODE (last_arg_fndecl) == BUILT_IN_VA_ARG_PACK)
2456 tree call = *expr_p;
2459 *expr_p = build_call_array_loc (loc, TREE_TYPE (call),
2460 CALL_EXPR_FN (call),
2461 nargs, CALL_EXPR_ARGP (call));
2463 /* Copy all CALL_EXPR flags, location and block, except
2464 CALL_EXPR_VA_ARG_PACK flag. */
2465 CALL_EXPR_STATIC_CHAIN (*expr_p) = CALL_EXPR_STATIC_CHAIN (call);
2466 CALL_EXPR_TAILCALL (*expr_p) = CALL_EXPR_TAILCALL (call);
2467 CALL_EXPR_RETURN_SLOT_OPT (*expr_p)
2468 = CALL_EXPR_RETURN_SLOT_OPT (call);
2469 CALL_FROM_THUNK_P (*expr_p) = CALL_FROM_THUNK_P (call);
2470 SET_EXPR_LOCATION (*expr_p, EXPR_LOCATION (call));
2471 TREE_BLOCK (*expr_p) = TREE_BLOCK (call);
2473 /* Set CALL_EXPR_VA_ARG_PACK. */
2474 CALL_EXPR_VA_ARG_PACK (*expr_p) = 1;
2478 /* Finally, gimplify the function arguments. */
2481 for (i = (PUSH_ARGS_REVERSED ? nargs - 1 : 0);
2482 PUSH_ARGS_REVERSED ? i >= 0 : i < nargs;
2483 PUSH_ARGS_REVERSED ? i-- : i++)
2485 enum gimplify_status t;
2487 /* Avoid gimplifying the second argument to va_start, which needs to
2488 be the plain PARM_DECL. */
2489 if ((i != 1) || !builtin_va_start_p)
2491 t = gimplify_arg (&CALL_EXPR_ARG (*expr_p, i), pre_p,
2492 EXPR_LOCATION (*expr_p));
2500 /* Verify the function result. */
2501 if (want_value && fndecl
2502 && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fnptrtype))))
2504 error_at (loc, "using result of function returning %<void%>");
2508 /* Try this again in case gimplification exposed something. */
2509 if (ret != GS_ERROR)
2511 tree new_tree = fold_call_expr (input_location, *expr_p, !want_value);
2513 if (new_tree && new_tree != *expr_p)
2515 /* There was a transformation of this call which computes the
2516 same value, but in a more efficient way. Return and try
2524 *expr_p = error_mark_node;
2528 /* If the function is "const" or "pure", then clear TREE_SIDE_EFFECTS on its
2529 decl. This allows us to eliminate redundant or useless
2530 calls to "const" functions. */
2531 if (TREE_CODE (*expr_p) == CALL_EXPR)
2533 int flags = call_expr_flags (*expr_p);
2534 if (flags & (ECF_CONST | ECF_PURE)
2535 /* An infinite loop is considered a side effect. */
2536 && !(flags & (ECF_LOOPING_CONST_OR_PURE)))
2537 TREE_SIDE_EFFECTS (*expr_p) = 0;
2540 /* If the value is not needed by the caller, emit a new GIMPLE_CALL
2541 and clear *EXPR_P. Otherwise, leave *EXPR_P in its gimplified
2542 form and delegate the creation of a GIMPLE_CALL to
2543 gimplify_modify_expr. This is always possible because when
2544 WANT_VALUE is true, the caller wants the result of this call into
2545 a temporary, which means that we will emit an INIT_EXPR in
2546 internal_get_tmp_var which will then be handled by
2547 gimplify_modify_expr. */
2550 /* The CALL_EXPR in *EXPR_P is already in GIMPLE form, so all we
2551 have to do is replicate it as a GIMPLE_CALL tuple. */
2552 gimple_stmt_iterator gsi;
2553 call = gimple_build_call_from_tree (*expr_p);
2554 gimple_call_set_fntype (call, TREE_TYPE (fnptrtype));
2555 gimplify_seq_add_stmt (pre_p, call);
2556 gsi = gsi_last (*pre_p);
2558 *expr_p = NULL_TREE;
2561 /* Remember the original function type. */
2562 CALL_EXPR_FN (*expr_p) = build1 (NOP_EXPR, fnptrtype,
2563 CALL_EXPR_FN (*expr_p));
2568 /* Handle shortcut semantics in the predicate operand of a COND_EXPR by
2569 rewriting it into multiple COND_EXPRs, and possibly GOTO_EXPRs.
2571 TRUE_LABEL_P and FALSE_LABEL_P point to the labels to jump to if the
2572 condition is true or false, respectively. If null, we should generate
2573 our own to skip over the evaluation of this specific expression.
2575 LOCUS is the source location of the COND_EXPR.
2577 This function is the tree equivalent of do_jump.
2579 shortcut_cond_r should only be called by shortcut_cond_expr. */
2582 shortcut_cond_r (tree pred, tree *true_label_p, tree *false_label_p,
2585 tree local_label = NULL_TREE;
2586 tree t, expr = NULL;
2588 /* OK, it's not a simple case; we need to pull apart the COND_EXPR to
2589 retain the shortcut semantics. Just insert the gotos here;
2590 shortcut_cond_expr will append the real blocks later. */
2591 if (TREE_CODE (pred) == TRUTH_ANDIF_EXPR)
2593 location_t new_locus;
2595 /* Turn if (a && b) into
2597 if (a); else goto no;
2598 if (b) goto yes; else goto no;
2601 if (false_label_p == NULL)
2602 false_label_p = &local_label;
2604 /* Keep the original source location on the first 'if'. */
2605 t = shortcut_cond_r (TREE_OPERAND (pred, 0), NULL, false_label_p, locus);
2606 append_to_statement_list (t, &expr);
2608 /* Set the source location of the && on the second 'if'. */
2609 new_locus = EXPR_HAS_LOCATION (pred) ? EXPR_LOCATION (pred) : locus;
2610 t = shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p, false_label_p,
2612 append_to_statement_list (t, &expr);
2614 else if (TREE_CODE (pred) == TRUTH_ORIF_EXPR)
2616 location_t new_locus;
2618 /* Turn if (a || b) into
2621 if (b) goto yes; else goto no;
2624 if (true_label_p == NULL)
2625 true_label_p = &local_label;
2627 /* Keep the original source location on the first 'if'. */
2628 t = shortcut_cond_r (TREE_OPERAND (pred, 0), true_label_p, NULL, locus);
2629 append_to_statement_list (t, &expr);
2631 /* Set the source location of the || on the second 'if'. */
2632 new_locus = EXPR_HAS_LOCATION (pred) ? EXPR_LOCATION (pred) : locus;
2633 t = shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p, false_label_p,
2635 append_to_statement_list (t, &expr);
2637 else if (TREE_CODE (pred) == COND_EXPR
2638 && !VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (pred, 1)))
2639 && !VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (pred, 2))))
2641 location_t new_locus;
2643 /* As long as we're messing with gotos, turn if (a ? b : c) into
2645 if (b) goto yes; else goto no;
2647 if (c) goto yes; else goto no;
2649 Don't do this if one of the arms has void type, which can happen
2650 in C++ when the arm is throw. */
2652 /* Keep the original source location on the first 'if'. Set the source
2653 location of the ? on the second 'if'. */
2654 new_locus = EXPR_HAS_LOCATION (pred) ? EXPR_LOCATION (pred) : locus;
2655 expr = build3 (COND_EXPR, void_type_node, TREE_OPERAND (pred, 0),
2656 shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p,
2657 false_label_p, locus),
2658 shortcut_cond_r (TREE_OPERAND (pred, 2), true_label_p,
2659 false_label_p, new_locus));
2663 expr = build3 (COND_EXPR, void_type_node, pred,
2664 build_and_jump (true_label_p),
2665 build_and_jump (false_label_p));
2666 SET_EXPR_LOCATION (expr, locus);
2671 t = build1 (LABEL_EXPR, void_type_node, local_label);
2672 append_to_statement_list (t, &expr);
2678 /* Given a conditional expression EXPR with short-circuit boolean
2679 predicates using TRUTH_ANDIF_EXPR or TRUTH_ORIF_EXPR, break the
2680 predicate appart into the equivalent sequence of conditionals. */
2683 shortcut_cond_expr (tree expr)
2685 tree pred = TREE_OPERAND (expr, 0);
2686 tree then_ = TREE_OPERAND (expr, 1);
2687 tree else_ = TREE_OPERAND (expr, 2);
2688 tree true_label, false_label, end_label, t;
2690 tree *false_label_p;
2691 bool emit_end, emit_false, jump_over_else;
2692 bool then_se = then_ && TREE_SIDE_EFFECTS (then_);
2693 bool else_se = else_ && TREE_SIDE_EFFECTS (else_);
2695 /* First do simple transformations. */
2698 /* If there is no 'else', turn
2701 if (a) if (b) then c. */
2702 while (TREE_CODE (pred) == TRUTH_ANDIF_EXPR)
2704 /* Keep the original source location on the first 'if'. */
2705 location_t locus = EXPR_LOC_OR_HERE (expr);
2706 TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1);
2707 /* Set the source location of the && on the second 'if'. */
2708 if (EXPR_HAS_LOCATION (pred))
2709 SET_EXPR_LOCATION (expr, EXPR_LOCATION (pred));
2710 then_ = shortcut_cond_expr (expr);
2711 then_se = then_ && TREE_SIDE_EFFECTS (then_);
2712 pred = TREE_OPERAND (pred, 0);
2713 expr = build3 (COND_EXPR, void_type_node, pred, then_, NULL_TREE);
2714 SET_EXPR_LOCATION (expr, locus);
2720 /* If there is no 'then', turn
2723 if (a); else if (b); else d. */
2724 while (TREE_CODE (pred) == TRUTH_ORIF_EXPR)
2726 /* Keep the original source location on the first 'if'. */
2727 location_t locus = EXPR_LOC_OR_HERE (expr);
2728 TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1);
2729 /* Set the source location of the || on the second 'if'. */
2730 if (EXPR_HAS_LOCATION (pred))
2731 SET_EXPR_LOCATION (expr, EXPR_LOCATION (pred));
2732 else_ = shortcut_cond_expr (expr);
2733 else_se = else_ && TREE_SIDE_EFFECTS (else_);
2734 pred = TREE_OPERAND (pred, 0);
2735 expr = build3 (COND_EXPR, void_type_node, pred, NULL_TREE, else_);
2736 SET_EXPR_LOCATION (expr, locus);
2740 /* If we're done, great. */
2741 if (TREE_CODE (pred) != TRUTH_ANDIF_EXPR
2742 && TREE_CODE (pred) != TRUTH_ORIF_EXPR)
2745 /* Otherwise we need to mess with gotos. Change
2748 if (a); else goto no;
2751 and recursively gimplify the condition. */
2753 true_label = false_label = end_label = NULL_TREE;
2755 /* If our arms just jump somewhere, hijack those labels so we don't
2756 generate jumps to jumps. */
2759 && TREE_CODE (then_) == GOTO_EXPR
2760 && TREE_CODE (GOTO_DESTINATION (then_)) == LABEL_DECL)
2762 true_label = GOTO_DESTINATION (then_);
2768 && TREE_CODE (else_) == GOTO_EXPR
2769 && TREE_CODE (GOTO_DESTINATION (else_)) == LABEL_DECL)
2771 false_label = GOTO_DESTINATION (else_);
2776 /* If we aren't hijacking a label for the 'then' branch, it falls through. */
2778 true_label_p = &true_label;
2780 true_label_p = NULL;
2782 /* The 'else' branch also needs a label if it contains interesting code. */
2783 if (false_label || else_se)
2784 false_label_p = &false_label;
2786 false_label_p = NULL;
2788 /* If there was nothing else in our arms, just forward the label(s). */
2789 if (!then_se && !else_se)
2790 return shortcut_cond_r (pred, true_label_p, false_label_p,
2791 EXPR_LOC_OR_HERE (expr));
2793 /* If our last subexpression already has a terminal label, reuse it. */
2795 t = expr_last (else_);
2797 t = expr_last (then_);
2800 if (t && TREE_CODE (t) == LABEL_EXPR)
2801 end_label = LABEL_EXPR_LABEL (t);
2803 /* If we don't care about jumping to the 'else' branch, jump to the end
2804 if the condition is false. */
2806 false_label_p = &end_label;
2808 /* We only want to emit these labels if we aren't hijacking them. */
2809 emit_end = (end_label == NULL_TREE);
2810 emit_false = (false_label == NULL_TREE);
2812 /* We only emit the jump over the else clause if we have to--if the
2813 then clause may fall through. Otherwise we can wind up with a
2814 useless jump and a useless label at the end of gimplified code,
2815 which will cause us to think that this conditional as a whole
2816 falls through even if it doesn't. If we then inline a function
2817 which ends with such a condition, that can cause us to issue an
2818 inappropriate warning about control reaching the end of a
2819 non-void function. */
2820 jump_over_else = block_may_fallthru (then_);
2822 pred = shortcut_cond_r (pred, true_label_p, false_label_p,
2823 EXPR_LOC_OR_HERE (expr));
2826 append_to_statement_list (pred, &expr);
2828 append_to_statement_list (then_, &expr);
2833 tree last = expr_last (expr);
2834 t = build_and_jump (&end_label);
2835 if (EXPR_HAS_LOCATION (last))
2836 SET_EXPR_LOCATION (t, EXPR_LOCATION (last));
2837 append_to_statement_list (t, &expr);
2841 t = build1 (LABEL_EXPR, void_type_node, false_label);
2842 append_to_statement_list (t, &expr);
2844 append_to_statement_list (else_, &expr);
2846 if (emit_end && end_label)
2848 t = build1 (LABEL_EXPR, void_type_node, end_label);
2849 append_to_statement_list (t, &expr);
2855 /* EXPR is used in a boolean context; make sure it has BOOLEAN_TYPE. */
2858 gimple_boolify (tree expr)
2860 tree type = TREE_TYPE (expr);
2861 location_t loc = EXPR_LOCATION (expr);
2863 if (TREE_CODE (expr) == NE_EXPR
2864 && TREE_CODE (TREE_OPERAND (expr, 0)) == CALL_EXPR
2865 && integer_zerop (TREE_OPERAND (expr, 1)))
2867 tree call = TREE_OPERAND (expr, 0);
2868 tree fn = get_callee_fndecl (call);
2870 /* For __builtin_expect ((long) (x), y) recurse into x as well
2871 if x is truth_value_p. */
2873 && DECL_BUILT_IN_CLASS (fn) == BUILT_IN_NORMAL
2874 && DECL_FUNCTION_CODE (fn) == BUILT_IN_EXPECT
2875 && call_expr_nargs (call) == 2)
2877 tree arg = CALL_EXPR_ARG (call, 0);
2880 if (TREE_CODE (arg) == NOP_EXPR
2881 && TREE_TYPE (arg) == TREE_TYPE (call))
2882 arg = TREE_OPERAND (arg, 0);
2883 if (truth_value_p (TREE_CODE (arg)))
2885 arg = gimple_boolify (arg);
2886 CALL_EXPR_ARG (call, 0)
2887 = fold_convert_loc (loc, TREE_TYPE (call), arg);
2893 switch (TREE_CODE (expr))
2895 case TRUTH_AND_EXPR:
2897 case TRUTH_XOR_EXPR:
2898 case TRUTH_ANDIF_EXPR:
2899 case TRUTH_ORIF_EXPR:
2900 /* Also boolify the arguments of truth exprs. */
2901 TREE_OPERAND (expr, 1) = gimple_boolify (TREE_OPERAND (expr, 1));
2904 case TRUTH_NOT_EXPR:
2905 TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0));
2907 /* These expressions always produce boolean results. */
2908 if (TREE_CODE (type) != BOOLEAN_TYPE)
2909 TREE_TYPE (expr) = boolean_type_node;
2913 if (COMPARISON_CLASS_P (expr))
2915 /* There expressions always prduce boolean results. */
2916 if (TREE_CODE (type) != BOOLEAN_TYPE)
2917 TREE_TYPE (expr) = boolean_type_node;
2920 /* Other expressions that get here must have boolean values, but
2921 might need to be converted to the appropriate mode. */
2922 if (TREE_CODE (type) == BOOLEAN_TYPE)
2924 return fold_convert_loc (loc, boolean_type_node, expr);
2928 /* Given a conditional expression *EXPR_P without side effects, gimplify
2929 its operands. New statements are inserted to PRE_P. */
2931 static enum gimplify_status
2932 gimplify_pure_cond_expr (tree *expr_p, gimple_seq *pre_p)
2934 tree expr = *expr_p, cond;
2935 enum gimplify_status ret, tret;
2936 enum tree_code code;
2938 cond = gimple_boolify (COND_EXPR_COND (expr));
2940 /* We need to handle && and || specially, as their gimplification
2941 creates pure cond_expr, thus leading to an infinite cycle otherwise. */
2942 code = TREE_CODE (cond);
2943 if (code == TRUTH_ANDIF_EXPR)
2944 TREE_SET_CODE (cond, TRUTH_AND_EXPR);
2945 else if (code == TRUTH_ORIF_EXPR)
2946 TREE_SET_CODE (cond, TRUTH_OR_EXPR);
2947 ret = gimplify_expr (&cond, pre_p, NULL, is_gimple_condexpr, fb_rvalue);
2948 COND_EXPR_COND (*expr_p) = cond;
2950 tret = gimplify_expr (&COND_EXPR_THEN (expr), pre_p, NULL,
2951 is_gimple_val, fb_rvalue);
2952 ret = MIN (ret, tret);
2953 tret = gimplify_expr (&COND_EXPR_ELSE (expr), pre_p, NULL,
2954 is_gimple_val, fb_rvalue);
2956 return MIN (ret, tret);
2959 /* Return true if evaluating EXPR could trap.
2960 EXPR is GENERIC, while tree_could_trap_p can be called
2964 generic_expr_could_trap_p (tree expr)
2968 if (!expr || is_gimple_val (expr))
2971 if (!EXPR_P (expr) || tree_could_trap_p (expr))
2974 n = TREE_OPERAND_LENGTH (expr);
2975 for (i = 0; i < n; i++)
2976 if (generic_expr_could_trap_p (TREE_OPERAND (expr, i)))
2982 /* Convert the conditional expression pointed to by EXPR_P '(p) ? a : b;'
2991 The second form is used when *EXPR_P is of type void.
2993 PRE_P points to the list where side effects that must happen before
2994 *EXPR_P should be stored. */
2996 static enum gimplify_status
2997 gimplify_cond_expr (tree *expr_p, gimple_seq *pre_p, fallback_t fallback)
2999 tree expr = *expr_p;
3000 tree type = TREE_TYPE (expr);
3001 location_t loc = EXPR_LOCATION (expr);
3002 tree tmp, arm1, arm2;
3003 enum gimplify_status ret;
3004 tree label_true, label_false, label_cont;
3005 bool have_then_clause_p, have_else_clause_p;
3007 enum tree_code pred_code;
3008 gimple_seq seq = NULL;
3010 /* If this COND_EXPR has a value, copy the values into a temporary within
3012 if (!VOID_TYPE_P (type))
3014 tree then_ = TREE_OPERAND (expr, 1), else_ = TREE_OPERAND (expr, 2);
3017 /* If either an rvalue is ok or we do not require an lvalue, create the
3018 temporary. But we cannot do that if the type is addressable. */
3019 if (((fallback & fb_rvalue) || !(fallback & fb_lvalue))
3020 && !TREE_ADDRESSABLE (type))
3022 if (gimplify_ctxp->allow_rhs_cond_expr
3023 /* If either branch has side effects or could trap, it can't be
3024 evaluated unconditionally. */
3025 && !TREE_SIDE_EFFECTS (then_)
3026 && !generic_expr_could_trap_p (then_)
3027 && !TREE_SIDE_EFFECTS (else_)
3028 && !generic_expr_could_trap_p (else_))
3029 return gimplify_pure_cond_expr (expr_p, pre_p);
3031 tmp = create_tmp_var (type, "iftmp");
3035 /* Otherwise, only create and copy references to the values. */
3038 type = build_pointer_type (type);
3040 if (!VOID_TYPE_P (TREE_TYPE (then_)))
3041 then_ = build_fold_addr_expr_loc (loc, then_);
3043 if (!VOID_TYPE_P (TREE_TYPE (else_)))
3044 else_ = build_fold_addr_expr_loc (loc, else_);
3047 = build3 (COND_EXPR, type, TREE_OPERAND (expr, 0), then_, else_);
3049 tmp = create_tmp_var (type, "iftmp");
3050 result = build_simple_mem_ref_loc (loc, tmp);
3053 /* Build the new then clause, `tmp = then_;'. But don't build the
3054 assignment if the value is void; in C++ it can be if it's a throw. */
3055 if (!VOID_TYPE_P (TREE_TYPE (then_)))
3056 TREE_OPERAND (expr, 1) = build2 (MODIFY_EXPR, type, tmp, then_);
3058 /* Similarly, build the new else clause, `tmp = else_;'. */
3059 if (!VOID_TYPE_P (TREE_TYPE (else_)))
3060 TREE_OPERAND (expr, 2) = build2 (MODIFY_EXPR, type, tmp, else_);
3062 TREE_TYPE (expr) = void_type_node;
3063 recalculate_side_effects (expr);
3065 /* Move the COND_EXPR to the prequeue. */
3066 gimplify_stmt (&expr, pre_p);
3072 /* Remove any COMPOUND_EXPR so the following cases will be caught. */
3073 STRIP_TYPE_NOPS (TREE_OPERAND (expr, 0));
3074 if (TREE_CODE (TREE_OPERAND (expr, 0)) == COMPOUND_EXPR)
3075 gimplify_compound_expr (&TREE_OPERAND (expr, 0), pre_p, true);
3077 /* Make sure the condition has BOOLEAN_TYPE. */
3078 TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0));
3080 /* Break apart && and || conditions. */
3081 if (TREE_CODE (TREE_OPERAND (expr, 0)) == TRUTH_ANDIF_EXPR
3082 || TREE_CODE (TREE_OPERAND (expr, 0)) == TRUTH_ORIF_EXPR)
3084 expr = shortcut_cond_expr (expr);
3086 if (expr != *expr_p)
3090 /* We can't rely on gimplify_expr to re-gimplify the expanded
3091 form properly, as cleanups might cause the target labels to be
3092 wrapped in a TRY_FINALLY_EXPR. To prevent that, we need to
3093 set up a conditional context. */
3094 gimple_push_condition ();
3095 gimplify_stmt (expr_p, &seq);
3096 gimple_pop_condition (pre_p);
3097 gimple_seq_add_seq (pre_p, seq);
3103 /* Now do the normal gimplification. */
3105 /* Gimplify condition. */
3106 ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, NULL, is_gimple_condexpr,
3108 if (ret == GS_ERROR)
3110 gcc_assert (TREE_OPERAND (expr, 0) != NULL_TREE);
3112 gimple_push_condition ();
3114 have_then_clause_p = have_else_clause_p = false;
3115 if (TREE_OPERAND (expr, 1) != NULL
3116 && TREE_CODE (TREE_OPERAND (expr, 1)) == GOTO_EXPR
3117 && TREE_CODE (GOTO_DESTINATION (TREE_OPERAND (expr, 1))) == LABEL_DECL
3118 && (DECL_CONTEXT (GOTO_DESTINATION (TREE_OPERAND (expr, 1)))
3119 == current_function_decl)
3120 /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
3121 have different locations, otherwise we end up with incorrect
3122 location information on the branches. */
3124 || !EXPR_HAS_LOCATION (expr)
3125 || !EXPR_HAS_LOCATION (TREE_OPERAND (expr, 1))
3126 || EXPR_LOCATION (expr) == EXPR_LOCATION (TREE_OPERAND (expr, 1))))
3128 label_true = GOTO_DESTINATION (TREE_OPERAND (expr, 1));
3129 have_then_clause_p = true;
3132 label_true = create_artificial_label (UNKNOWN_LOCATION);
3133 if (TREE_OPERAND (expr, 2) != NULL
3134 && TREE_CODE (TREE_OPERAND (expr, 2)) == GOTO_EXPR
3135 && TREE_CODE (GOTO_DESTINATION (TREE_OPERAND (expr, 2))) == LABEL_DECL
3136 && (DECL_CONTEXT (GOTO_DESTINATION (TREE_OPERAND (expr, 2)))
3137 == current_function_decl)
3138 /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
3139 have different locations, otherwise we end up with incorrect
3140 location information on the branches. */
3142 || !EXPR_HAS_LOCATION (expr)
3143 || !EXPR_HAS_LOCATION (TREE_OPERAND (expr, 2))
3144 || EXPR_LOCATION (expr) == EXPR_LOCATION (TREE_OPERAND (expr, 2))))
3146 label_false = GOTO_DESTINATION (TREE_OPERAND (expr, 2));
3147 have_else_clause_p = true;
3150 label_false = create_artificial_label (UNKNOWN_LOCATION);
3152 gimple_cond_get_ops_from_tree (COND_EXPR_COND (expr), &pred_code, &arm1,
3155 gimple_cond = gimple_build_cond (pred_code, arm1, arm2, label_true,
3158 gimplify_seq_add_stmt (&seq, gimple_cond);
3159 label_cont = NULL_TREE;
3160 if (!have_then_clause_p)
3162 /* For if (...) {} else { code; } put label_true after
3164 if (TREE_OPERAND (expr, 1) == NULL_TREE
3165 && !have_else_clause_p
3166 && TREE_OPERAND (expr, 2) != NULL_TREE)
3167 label_cont = label_true;
3170 gimplify_seq_add_stmt (&seq, gimple_build_label (label_true));
3171 have_then_clause_p = gimplify_stmt (&TREE_OPERAND (expr, 1), &seq);
3172 /* For if (...) { code; } else {} or
3173 if (...) { code; } else goto label; or
3174 if (...) { code; return; } else { ... }
3175 label_cont isn't needed. */
3176 if (!have_else_clause_p
3177 && TREE_OPERAND (expr, 2) != NULL_TREE
3178 && gimple_seq_may_fallthru (seq))
3181 label_cont = create_artificial_label (UNKNOWN_LOCATION);
3183 g = gimple_build_goto (label_cont);
3185 /* GIMPLE_COND's are very low level; they have embedded
3186 gotos. This particular embedded goto should not be marked
3187 with the location of the original COND_EXPR, as it would
3188 correspond to the COND_EXPR's condition, not the ELSE or the
3189 THEN arms. To avoid marking it with the wrong location, flag
3190 it as "no location". */
3191 gimple_set_do_not_emit_location (g);
3193 gimplify_seq_add_stmt (&seq, g);
3197 if (!have_else_clause_p)
3199 gimplify_seq_add_stmt (&seq, gimple_build_label (label_false));
3200 have_else_clause_p = gimplify_stmt (&TREE_OPERAND (expr, 2), &seq);
3203 gimplify_seq_add_stmt (&seq, gimple_build_label (label_cont));
3205 gimple_pop_condition (pre_p);
3206 gimple_seq_add_seq (pre_p, seq);
3208 if (ret == GS_ERROR)
3210 else if (have_then_clause_p || have_else_clause_p)
3214 /* Both arms are empty; replace the COND_EXPR with its predicate. */
3215 expr = TREE_OPERAND (expr, 0);
3216 gimplify_stmt (&expr, pre_p);
3223 /* Prepare the node pointed to by EXPR_P, an is_gimple_addressable expression,
3224 to be marked addressable.
3226 We cannot rely on such an expression being directly markable if a temporary
3227 has been created by the gimplification. In this case, we create another
3228 temporary and initialize it with a copy, which will become a store after we
3229 mark it addressable. This can happen if the front-end passed us something
3230 that it could not mark addressable yet, like a Fortran pass-by-reference
3231 parameter (int) floatvar. */
3234 prepare_gimple_addressable (tree *expr_p, gimple_seq *seq_p)
3236 while (handled_component_p (*expr_p))
3237 expr_p = &TREE_OPERAND (*expr_p, 0);
3238 if (is_gimple_reg (*expr_p))
3239 *expr_p = get_initialized_tmp_var (*expr_p, seq_p, NULL);
3242 /* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with
3243 a call to __builtin_memcpy. */
3245 static enum gimplify_status
3246 gimplify_modify_expr_to_memcpy (tree *expr_p, tree size, bool want_value,
3249 tree t, to, to_ptr, from, from_ptr;
3251 location_t loc = EXPR_LOCATION (*expr_p);
3253 to = TREE_OPERAND (*expr_p, 0);
3254 from = TREE_OPERAND (*expr_p, 1);
3256 /* Mark the RHS addressable. Beware that it may not be possible to do so
3257 directly if a temporary has been created by the gimplification. */
3258 prepare_gimple_addressable (&from, seq_p);
3260 mark_addressable (from);
3261 from_ptr = build_fold_addr_expr_loc (loc, from);
3262 gimplify_arg (&from_ptr, seq_p, loc);
3264 mark_addressable (to);
3265 to_ptr = build_fold_addr_expr_loc (loc, to);
3266 gimplify_arg (&to_ptr, seq_p, loc);
3268 t = builtin_decl_implicit (BUILT_IN_MEMCPY);
3270 gs = gimple_build_call (t, 3, to_ptr, from_ptr, size);
3274 /* tmp = memcpy() */
3275 t = create_tmp_var (TREE_TYPE (to_ptr), NULL);
3276 gimple_call_set_lhs (gs, t);
3277 gimplify_seq_add_stmt (seq_p, gs);
3279 *expr_p = build_simple_mem_ref (t);
3283 gimplify_seq_add_stmt (seq_p, gs);
3288 /* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with
3289 a call to __builtin_memset. In this case we know that the RHS is
3290 a CONSTRUCTOR with an empty element list. */
3292 static enum gimplify_status
3293 gimplify_modify_expr_to_memset (tree *expr_p, tree size, bool want_value,
3296 tree t, from, to, to_ptr;
3298 location_t loc = EXPR_LOCATION (*expr_p);
3300 /* Assert our assumptions, to abort instead of producing wrong code
3301 silently if they are not met. Beware that the RHS CONSTRUCTOR might
3302 not be immediately exposed. */
3303 from = TREE_OPERAND (*expr_p, 1);
3304 if (TREE_CODE (from) == WITH_SIZE_EXPR)
3305 from = TREE_OPERAND (from, 0);
3307 gcc_assert (TREE_CODE (from) == CONSTRUCTOR
3308 && VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (from)));
3311 to = TREE_OPERAND (*expr_p, 0);
3313 to_ptr = build_fold_addr_expr_loc (loc, to);
3314 gimplify_arg (&to_ptr, seq_p, loc);
3315 t = builtin_decl_implicit (BUILT_IN_MEMSET);
3317 gs = gimple_build_call (t, 3, to_ptr, integer_zero_node, size);
3321 /* tmp = memset() */
3322 t = create_tmp_var (TREE_TYPE (to_ptr), NULL);
3323 gimple_call_set_lhs (gs, t);
3324 gimplify_seq_add_stmt (seq_p, gs);
3326 *expr_p = build1 (INDIRECT_REF, TREE_TYPE (to), t);
3330 gimplify_seq_add_stmt (seq_p, gs);
3335 /* A subroutine of gimplify_init_ctor_preeval. Called via walk_tree,
3336 determine, cautiously, if a CONSTRUCTOR overlaps the lhs of an
3337 assignment. Return non-null if we detect a potential overlap. */
3339 struct gimplify_init_ctor_preeval_data
3341 /* The base decl of the lhs object. May be NULL, in which case we
3342 have to assume the lhs is indirect. */
3345 /* The alias set of the lhs object. */
3346 alias_set_type lhs_alias_set;
3350 gimplify_init_ctor_preeval_1 (tree *tp, int *walk_subtrees, void *xdata)
3352 struct gimplify_init_ctor_preeval_data *data
3353 = (struct gimplify_init_ctor_preeval_data *) xdata;
3356 /* If we find the base object, obviously we have overlap. */
3357 if (data->lhs_base_decl == t)
3360 /* If the constructor component is indirect, determine if we have a
3361 potential overlap with the lhs. The only bits of information we
3362 have to go on at this point are addressability and alias sets. */
3363 if ((INDIRECT_REF_P (t)
3364 || TREE_CODE (t) == MEM_REF)
3365 && (!data->lhs_base_decl || TREE_ADDRESSABLE (data->lhs_base_decl))
3366 && alias_sets_conflict_p (data->lhs_alias_set, get_alias_set (t)))
3369 /* If the constructor component is a call, determine if it can hide a
3370 potential overlap with the lhs through an INDIRECT_REF like above.
3371 ??? Ugh - this is completely broken. In fact this whole analysis
3372 doesn't look conservative. */
3373 if (TREE_CODE (t) == CALL_EXPR)
3375 tree type, fntype = TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (t)));
3377 for (type = TYPE_ARG_TYPES (fntype); type; type = TREE_CHAIN (type))
3378 if (POINTER_TYPE_P (TREE_VALUE (type))
3379 && (!data->lhs_base_decl || TREE_ADDRESSABLE (data->lhs_base_decl))
3380 && alias_sets_conflict_p (data->lhs_alias_set,
3382 (TREE_TYPE (TREE_VALUE (type)))))
3386 if (IS_TYPE_OR_DECL_P (t))
3391 /* A subroutine of gimplify_init_constructor. Pre-evaluate EXPR,
3392 force values that overlap with the lhs (as described by *DATA)
3393 into temporaries. */
3396 gimplify_init_ctor_preeval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
3397 struct gimplify_init_ctor_preeval_data *data)
3399 enum gimplify_status one;
3401 /* If the value is constant, then there's nothing to pre-evaluate. */
3402 if (TREE_CONSTANT (*expr_p))
3404 /* Ensure it does not have side effects, it might contain a reference to
3405 the object we're initializing. */
3406 gcc_assert (!TREE_SIDE_EFFECTS (*expr_p));
3410 /* If the type has non-trivial constructors, we can't pre-evaluate. */
3411 if (TREE_ADDRESSABLE (TREE_TYPE (*expr_p)))
3414 /* Recurse for nested constructors. */
3415 if (TREE_CODE (*expr_p) == CONSTRUCTOR)
3417 unsigned HOST_WIDE_INT ix;
3418 constructor_elt *ce;
3419 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (*expr_p);
3421 FOR_EACH_VEC_ELT (constructor_elt, v, ix, ce)
3422 gimplify_init_ctor_preeval (&ce->value, pre_p, post_p, data);
3427 /* If this is a variable sized type, we must remember the size. */
3428 maybe_with_size_expr (expr_p);
3430 /* Gimplify the constructor element to something appropriate for the rhs
3431 of a MODIFY_EXPR. Given that we know the LHS is an aggregate, we know
3432 the gimplifier will consider this a store to memory. Doing this
3433 gimplification now means that we won't have to deal with complicated
3434 language-specific trees, nor trees like SAVE_EXPR that can induce
3435 exponential search behavior. */
3436 one = gimplify_expr (expr_p, pre_p, post_p, is_gimple_mem_rhs, fb_rvalue);
3437 if (one == GS_ERROR)
3443 /* If we gimplified to a bare decl, we can be sure that it doesn't overlap
3444 with the lhs, since "a = { .x=a }" doesn't make sense. This will
3445 always be true for all scalars, since is_gimple_mem_rhs insists on a
3446 temporary variable for them. */
3447 if (DECL_P (*expr_p))
3450 /* If this is of variable size, we have no choice but to assume it doesn't
3451 overlap since we can't make a temporary for it. */
3452 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (*expr_p))) != INTEGER_CST)
3455 /* Otherwise, we must search for overlap ... */
3456 if (!walk_tree (expr_p, gimplify_init_ctor_preeval_1, data, NULL))
3459 /* ... and if found, force the value into a temporary. */
3460 *expr_p = get_formal_tmp_var (*expr_p, pre_p);
3463 /* A subroutine of gimplify_init_ctor_eval. Create a loop for
3464 a RANGE_EXPR in a CONSTRUCTOR for an array.
3468 object[var] = value;
3475 We increment var _after_ the loop exit check because we might otherwise
3476 fail if upper == TYPE_MAX_VALUE (type for upper).
3478 Note that we never have to deal with SAVE_EXPRs here, because this has
3479 already been taken care of for us, in gimplify_init_ctor_preeval(). */
3481 static void gimplify_init_ctor_eval (tree, VEC(constructor_elt,gc) *,
3482 gimple_seq *, bool);
3485 gimplify_init_ctor_eval_range (tree object, tree lower, tree upper,
3486 tree value, tree array_elt_type,
3487 gimple_seq *pre_p, bool cleared)
3489 tree loop_entry_label, loop_exit_label, fall_thru_label;
3490 tree var, var_type, cref, tmp;
3492 loop_entry_label = create_artificial_label (UNKNOWN_LOCATION);
3493 loop_exit_label = create_artificial_label (UNKNOWN_LOCATION);
3494 fall_thru_label = create_artificial_label (UNKNOWN_LOCATION);
3496 /* Create and initialize the index variable. */
3497 var_type = TREE_TYPE (upper);
3498 var = create_tmp_var (var_type, NULL);
3499 gimplify_seq_add_stmt (pre_p, gimple_build_assign (var, lower));
3501 /* Add the loop entry label. */
3502 gimplify_seq_add_stmt (pre_p, gimple_build_label (loop_entry_label));
3504 /* Build the reference. */
3505 cref = build4 (ARRAY_REF, array_elt_type, unshare_expr (object),
3506 var, NULL_TREE, NULL_TREE);
3508 /* If we are a constructor, just call gimplify_init_ctor_eval to do
3509 the store. Otherwise just assign value to the reference. */
3511 if (TREE_CODE (value) == CONSTRUCTOR)
3512 /* NB we might have to call ourself recursively through
3513 gimplify_init_ctor_eval if the value is a constructor. */
3514 gimplify_init_ctor_eval (cref, CONSTRUCTOR_ELTS (value),
3517 gimplify_seq_add_stmt (pre_p, gimple_build_assign (cref, value));
3519 /* We exit the loop when the index var is equal to the upper bound. */
3520 gimplify_seq_add_stmt (pre_p,
3521 gimple_build_cond (EQ_EXPR, var, upper,
3522 loop_exit_label, fall_thru_label));
3524 gimplify_seq_add_stmt (pre_p, gimple_build_label (fall_thru_label));
3526 /* Otherwise, increment the index var... */
3527 tmp = build2 (PLUS_EXPR, var_type, var,
3528 fold_convert (var_type, integer_one_node));
3529 gimplify_seq_add_stmt (pre_p, gimple_build_assign (var, tmp));
3531 /* ...and jump back to the loop entry. */
3532 gimplify_seq_add_stmt (pre_p, gimple_build_goto (loop_entry_label));
3534 /* Add the loop exit label. */
3535 gimplify_seq_add_stmt (pre_p, gimple_build_label (loop_exit_label));
3538 /* Return true if FDECL is accessing a field that is zero sized. */
3541 zero_sized_field_decl (const_tree fdecl)
3543 if (TREE_CODE (fdecl) == FIELD_DECL && DECL_SIZE (fdecl)
3544 && integer_zerop (DECL_SIZE (fdecl)))
3549 /* Return true if TYPE is zero sized. */
3552 zero_sized_type (const_tree type)
3554 if (AGGREGATE_TYPE_P (type) && TYPE_SIZE (type)
3555 && integer_zerop (TYPE_SIZE (type)))
3560 /* A subroutine of gimplify_init_constructor. Generate individual
3561 MODIFY_EXPRs for a CONSTRUCTOR. OBJECT is the LHS against which the
3562 assignments should happen. ELTS is the CONSTRUCTOR_ELTS of the
3563 CONSTRUCTOR. CLEARED is true if the entire LHS object has been
3567 gimplify_init_ctor_eval (tree object, VEC(constructor_elt,gc) *elts,
3568 gimple_seq *pre_p, bool cleared)
3570 tree array_elt_type = NULL;
3571 unsigned HOST_WIDE_INT ix;
3572 tree purpose, value;
3574 if (TREE_CODE (TREE_TYPE (object)) == ARRAY_TYPE)
3575 array_elt_type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (object)));
3577 FOR_EACH_CONSTRUCTOR_ELT (elts, ix, purpose, value)
3581 /* NULL values are created above for gimplification errors. */
3585 if (cleared && initializer_zerop (value))
3588 /* ??? Here's to hoping the front end fills in all of the indices,
3589 so we don't have to figure out what's missing ourselves. */
3590 gcc_assert (purpose);
3592 /* Skip zero-sized fields, unless value has side-effects. This can
3593 happen with calls to functions returning a zero-sized type, which
3594 we shouldn't discard. As a number of downstream passes don't
3595 expect sets of zero-sized fields, we rely on the gimplification of
3596 the MODIFY_EXPR we make below to drop the assignment statement. */
3597 if (! TREE_SIDE_EFFECTS (value) && zero_sized_field_decl (purpose))
3600 /* If we have a RANGE_EXPR, we have to build a loop to assign the
3602 if (TREE_CODE (purpose) == RANGE_EXPR)
3604 tree lower = TREE_OPERAND (purpose, 0);
3605 tree upper = TREE_OPERAND (purpose, 1);
3607 /* If the lower bound is equal to upper, just treat it as if
3608 upper was the index. */
3609 if (simple_cst_equal (lower, upper))
3613 gimplify_init_ctor_eval_range (object, lower, upper, value,
3614 array_elt_type, pre_p, cleared);
3621 /* Do not use bitsizetype for ARRAY_REF indices. */
3622 if (TYPE_DOMAIN (TREE_TYPE (object)))
3624 = fold_convert (TREE_TYPE (TYPE_DOMAIN (TREE_TYPE (object))),
3626 cref = build4 (ARRAY_REF, array_elt_type, unshare_expr (object),
3627 purpose, NULL_TREE, NULL_TREE);
3631 gcc_assert (TREE_CODE (purpose) == FIELD_DECL);
3632 cref = build3 (COMPONENT_REF, TREE_TYPE (purpose),
3633 unshare_expr (object), purpose, NULL_TREE);
3636 if (TREE_CODE (value) == CONSTRUCTOR
3637 && TREE_CODE (TREE_TYPE (value)) != VECTOR_TYPE)
3638 gimplify_init_ctor_eval (cref, CONSTRUCTOR_ELTS (value),
3642 tree init = build2 (INIT_EXPR, TREE_TYPE (cref), cref, value);
3643 gimplify_and_add (init, pre_p);
3649 /* Return the appropriate RHS predicate for this LHS. */
3652 rhs_predicate_for (tree lhs)
3654 if (is_gimple_reg (lhs))
3655 return is_gimple_reg_rhs_or_call;
3657 return is_gimple_mem_rhs_or_call;
3660 /* Gimplify a C99 compound literal expression. This just means adding
3661 the DECL_EXPR before the current statement and using its anonymous
3664 static enum gimplify_status
3665 gimplify_compound_literal_expr (tree *expr_p, gimple_seq *pre_p)
3667 tree decl_s = COMPOUND_LITERAL_EXPR_DECL_EXPR (*expr_p);
3668 tree decl = DECL_EXPR_DECL (decl_s);
3669 /* Mark the decl as addressable if the compound literal
3670 expression is addressable now, otherwise it is marked too late
3671 after we gimplify the initialization expression. */
3672 if (TREE_ADDRESSABLE (*expr_p))
3673 TREE_ADDRESSABLE (decl) = 1;
3675 /* Preliminarily mark non-addressed complex variables as eligible
3676 for promotion to gimple registers. We'll transform their uses
3678 if ((TREE_CODE (TREE_TYPE (decl)) == COMPLEX_TYPE
3679 || TREE_CODE (TREE_TYPE (decl)) == VECTOR_TYPE)
3680 && !TREE_THIS_VOLATILE (decl)
3681 && !needs_to_live_in_memory (decl))
3682 DECL_GIMPLE_REG_P (decl) = 1;
3684 /* This decl isn't mentioned in the enclosing block, so add it to the
3685 list of temps. FIXME it seems a bit of a kludge to say that
3686 anonymous artificial vars aren't pushed, but everything else is. */
3687 if (DECL_NAME (decl) == NULL_TREE && !DECL_SEEN_IN_BIND_EXPR_P (decl))
3688 gimple_add_tmp_var (decl);
3690 gimplify_and_add (decl_s, pre_p);
3695 /* Optimize embedded COMPOUND_LITERAL_EXPRs within a CONSTRUCTOR,
3696 return a new CONSTRUCTOR if something changed. */
3699 optimize_compound_literals_in_ctor (tree orig_ctor)
3701 tree ctor = orig_ctor;
3702 VEC(constructor_elt,gc) *elts = CONSTRUCTOR_ELTS (ctor);
3703 unsigned int idx, num = VEC_length (constructor_elt, elts);
3705 for (idx = 0; idx < num; idx++)
3707 tree value = VEC_index (constructor_elt, elts, idx)->value;
3708 tree newval = value;
3709 if (TREE_CODE (value) == CONSTRUCTOR)
3710 newval = optimize_compound_literals_in_ctor (value);
3711 else if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR)
3713 tree decl_s = COMPOUND_LITERAL_EXPR_DECL_EXPR (value);
3714 tree decl = DECL_EXPR_DECL (decl_s);
3715 tree init = DECL_INITIAL (decl);
3717 if (!TREE_ADDRESSABLE (value)
3718 && !TREE_ADDRESSABLE (decl)
3720 newval = optimize_compound_literals_in_ctor (init);
3722 if (newval == value)
3725 if (ctor == orig_ctor)
3727 ctor = copy_node (orig_ctor);
3728 CONSTRUCTOR_ELTS (ctor) = VEC_copy (constructor_elt, gc, elts);
3729 elts = CONSTRUCTOR_ELTS (ctor);
3731 VEC_index (constructor_elt, elts, idx)->value = newval;
3736 /* A subroutine of gimplify_modify_expr. Break out elements of a
3737 CONSTRUCTOR used as an initializer into separate MODIFY_EXPRs.
3739 Note that we still need to clear any elements that don't have explicit
3740 initializers, so if not all elements are initialized we keep the
3741 original MODIFY_EXPR, we just remove all of the constructor elements.
3743 If NOTIFY_TEMP_CREATION is true, do not gimplify, just return
3744 GS_ERROR if we would have to create a temporary when gimplifying
3745 this constructor. Otherwise, return GS_OK.
3747 If NOTIFY_TEMP_CREATION is false, just do the gimplification. */
3749 static enum gimplify_status
3750 gimplify_init_constructor (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
3751 bool want_value, bool notify_temp_creation)
3753 tree object, ctor, type;
3754 enum gimplify_status ret;
3755 VEC(constructor_elt,gc) *elts;
3757 gcc_assert (TREE_CODE (TREE_OPERAND (*expr_p, 1)) == CONSTRUCTOR);
3759 if (!notify_temp_creation)
3761 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
3762 is_gimple_lvalue, fb_lvalue);
3763 if (ret == GS_ERROR)
3767 object = TREE_OPERAND (*expr_p, 0);
3768 ctor = TREE_OPERAND (*expr_p, 1) =
3769 optimize_compound_literals_in_ctor (TREE_OPERAND (*expr_p, 1));
3770 type = TREE_TYPE (ctor);
3771 elts = CONSTRUCTOR_ELTS (ctor);
3774 switch (TREE_CODE (type))
3778 case QUAL_UNION_TYPE:
3781 struct gimplify_init_ctor_preeval_data preeval_data;
3782 HOST_WIDE_INT num_ctor_elements, num_nonzero_elements;
3783 bool cleared, complete_p, valid_const_initializer;
3785 /* Aggregate types must lower constructors to initialization of
3786 individual elements. The exception is that a CONSTRUCTOR node
3787 with no elements indicates zero-initialization of the whole. */
3788 if (VEC_empty (constructor_elt, elts))
3790 if (notify_temp_creation)
3795 /* Fetch information about the constructor to direct later processing.
3796 We might want to make static versions of it in various cases, and
3797 can only do so if it known to be a valid constant initializer. */
3798 valid_const_initializer
3799 = categorize_ctor_elements (ctor, &num_nonzero_elements,
3800 &num_ctor_elements, &complete_p);
3802 /* If a const aggregate variable is being initialized, then it
3803 should never be a lose to promote the variable to be static. */
3804 if (valid_const_initializer
3805 && num_nonzero_elements > 1
3806 && TREE_READONLY (object)
3807 && TREE_CODE (object) == VAR_DECL
3808 && (flag_merge_constants >= 2 || !TREE_ADDRESSABLE (object)))
3810 if (notify_temp_creation)
3812 DECL_INITIAL (object) = ctor;
3813 TREE_STATIC (object) = 1;
3814 if (!DECL_NAME (object))
3815 DECL_NAME (object) = create_tmp_var_name ("C");
3816 walk_tree (&DECL_INITIAL (object), force_labels_r, NULL, NULL);
3818 /* ??? C++ doesn't automatically append a .<number> to the
3819 assembler name, and even when it does, it looks a FE private
3820 data structures to figure out what that number should be,
3821 which are not set for this variable. I suppose this is
3822 important for local statics for inline functions, which aren't
3823 "local" in the object file sense. So in order to get a unique
3824 TU-local symbol, we must invoke the lhd version now. */
3825 lhd_set_decl_assembler_name (object);
3827 *expr_p = NULL_TREE;
3831 /* If there are "lots" of initialized elements, even discounting
3832 those that are not address constants (and thus *must* be
3833 computed at runtime), then partition the constructor into
3834 constant and non-constant parts. Block copy the constant
3835 parts in, then generate code for the non-constant parts. */
3836 /* TODO. There's code in cp/typeck.c to do this. */
3838 if (int_size_in_bytes (TREE_TYPE (ctor)) < 0)
3839 /* store_constructor will ignore the clearing of variable-sized
3840 objects. Initializers for such objects must explicitly set
3841 every field that needs to be set. */
3843 else if (!complete_p)
3844 /* If the constructor isn't complete, clear the whole object
3847 ??? This ought not to be needed. For any element not present
3848 in the initializer, we should simply set them to zero. Except
3849 we'd need to *find* the elements that are not present, and that
3850 requires trickery to avoid quadratic compile-time behavior in
3851 large cases or excessive memory use in small cases. */
3853 else if (num_ctor_elements - num_nonzero_elements
3854 > CLEAR_RATIO (optimize_function_for_speed_p (cfun))
3855 && num_nonzero_elements < num_ctor_elements / 4)
3856 /* If there are "lots" of zeros, it's more efficient to clear
3857 the memory and then set the nonzero elements. */
3862 /* If there are "lots" of initialized elements, and all of them
3863 are valid address constants, then the entire initializer can
3864 be dropped to memory, and then memcpy'd out. Don't do this
3865 for sparse arrays, though, as it's more efficient to follow
3866 the standard CONSTRUCTOR behavior of memset followed by
3867 individual element initialization. Also don't do this for small
3868 all-zero initializers (which aren't big enough to merit
3869 clearing), and don't try to make bitwise copies of
3870 TREE_ADDRESSABLE types. */
3871 if (valid_const_initializer
3872 && !(cleared || num_nonzero_elements == 0)
3873 && !TREE_ADDRESSABLE (type))
3875 HOST_WIDE_INT size = int_size_in_bytes (type);
3878 /* ??? We can still get unbounded array types, at least
3879 from the C++ front end. This seems wrong, but attempt
3880 to work around it for now. */
3883 size = int_size_in_bytes (TREE_TYPE (object));
3885 TREE_TYPE (ctor) = type = TREE_TYPE (object);
3888 /* Find the maximum alignment we can assume for the object. */
3889 /* ??? Make use of DECL_OFFSET_ALIGN. */
3890 if (DECL_P (object))
3891 align = DECL_ALIGN (object);
3893 align = TYPE_ALIGN (type);
3896 && num_nonzero_elements > 1
3897 && !can_move_by_pieces (size, align))
3899 if (notify_temp_creation)
3902 walk_tree (&ctor, force_labels_r, NULL, NULL);
3903 ctor = tree_output_constant_def (ctor);
3904 if (!useless_type_conversion_p (type, TREE_TYPE (ctor)))
3905 ctor = build1 (VIEW_CONVERT_EXPR, type, ctor);
3906 TREE_OPERAND (*expr_p, 1) = ctor;
3908 /* This is no longer an assignment of a CONSTRUCTOR, but
3909 we still may have processing to do on the LHS. So
3910 pretend we didn't do anything here to let that happen. */
3911 return GS_UNHANDLED;
3915 /* If the target is volatile, we have non-zero elements and more than
3916 one field to assign, initialize the target from a temporary. */
3917 if (TREE_THIS_VOLATILE (object)
3918 && !TREE_ADDRESSABLE (type)
3919 && num_nonzero_elements > 0
3920 && VEC_length (constructor_elt, elts) > 1)
3922 tree temp = create_tmp_var (TYPE_MAIN_VARIANT (type), NULL);
3923 TREE_OPERAND (*expr_p, 0) = temp;
3924 *expr_p = build2 (COMPOUND_EXPR, TREE_TYPE (*expr_p),
3926 build2 (MODIFY_EXPR, void_type_node,
3931 if (notify_temp_creation)
3934 /* If there are nonzero elements and if needed, pre-evaluate to capture
3935 elements overlapping with the lhs into temporaries. We must do this
3936 before clearing to fetch the values before they are zeroed-out. */
3937 if (num_nonzero_elements > 0 && TREE_CODE (*expr_p) != INIT_EXPR)
3939 preeval_data.lhs_base_decl = get_base_address (object);
3940 if (!DECL_P (preeval_data.lhs_base_decl))
3941 preeval_data.lhs_base_decl = NULL;
3942 preeval_data.lhs_alias_set = get_alias_set (object);
3944 gimplify_init_ctor_preeval (&TREE_OPERAND (*expr_p, 1),
3945 pre_p, post_p, &preeval_data);
3950 /* Zap the CONSTRUCTOR element list, which simplifies this case.
3951 Note that we still have to gimplify, in order to handle the
3952 case of variable sized types. Avoid shared tree structures. */
3953 CONSTRUCTOR_ELTS (ctor) = NULL;
3954 TREE_SIDE_EFFECTS (ctor) = 0;
3955 object = unshare_expr (object);
3956 gimplify_stmt (expr_p, pre_p);
3959 /* If we have not block cleared the object, or if there are nonzero
3960 elements in the constructor, add assignments to the individual
3961 scalar fields of the object. */
3962 if (!cleared || num_nonzero_elements > 0)
3963 gimplify_init_ctor_eval (object, elts, pre_p, cleared);
3965 *expr_p = NULL_TREE;
3973 if (notify_temp_creation)
3976 /* Extract the real and imaginary parts out of the ctor. */
3977 gcc_assert (VEC_length (constructor_elt, elts) == 2);
3978 r = VEC_index (constructor_elt, elts, 0)->value;
3979 i = VEC_index (constructor_elt, elts, 1)->value;
3980 if (r == NULL || i == NULL)
3982 tree zero = build_zero_cst (TREE_TYPE (type));
3989 /* Complex types have either COMPLEX_CST or COMPLEX_EXPR to
3990 represent creation of a complex value. */
3991 if (TREE_CONSTANT (r) && TREE_CONSTANT (i))
3993 ctor = build_complex (type, r, i);
3994 TREE_OPERAND (*expr_p, 1) = ctor;
3998 ctor = build2 (COMPLEX_EXPR, type, r, i);
3999 TREE_OPERAND (*expr_p, 1) = ctor;
4000 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 1),
4003 rhs_predicate_for (TREE_OPERAND (*expr_p, 0)),
4011 unsigned HOST_WIDE_INT ix;
4012 constructor_elt *ce;
4014 if (notify_temp_creation)
4017 /* Go ahead and simplify constant constructors to VECTOR_CST. */
4018 if (TREE_CONSTANT (ctor))
4020 bool constant_p = true;
4023 /* Even when ctor is constant, it might contain non-*_CST
4024 elements, such as addresses or trapping values like
4025 1.0/0.0 - 1.0/0.0. Such expressions don't belong
4026 in VECTOR_CST nodes. */
4027 FOR_EACH_CONSTRUCTOR_VALUE (elts, ix, value)
4028 if (!CONSTANT_CLASS_P (value))
4036 TREE_OPERAND (*expr_p, 1) = build_vector_from_ctor (type, elts);
4040 /* Don't reduce an initializer constant even if we can't
4041 make a VECTOR_CST. It won't do anything for us, and it'll
4042 prevent us from representing it as a single constant. */
4043 if (initializer_constant_valid_p (ctor, type))
4046 TREE_CONSTANT (ctor) = 0;
4049 /* Vector types use CONSTRUCTOR all the way through gimple
4050 compilation as a general initializer. */
4051 FOR_EACH_VEC_ELT (constructor_elt, elts, ix, ce)
4053 enum gimplify_status tret;
4054 tret = gimplify_expr (&ce->value, pre_p, post_p, is_gimple_val,
4056 if (tret == GS_ERROR)
4059 if (!is_gimple_reg (TREE_OPERAND (*expr_p, 0)))
4060 TREE_OPERAND (*expr_p, 1) = get_formal_tmp_var (ctor, pre_p);
4065 /* So how did we get a CONSTRUCTOR for a scalar type? */
4069 if (ret == GS_ERROR)
4071 else if (want_value)
4078 /* If we have gimplified both sides of the initializer but have
4079 not emitted an assignment, do so now. */
4082 tree lhs = TREE_OPERAND (*expr_p, 0);
4083 tree rhs = TREE_OPERAND (*expr_p, 1);
4084 gimple init = gimple_build_assign (lhs, rhs);
4085 gimplify_seq_add_stmt (pre_p, init);
4093 /* Given a pointer value OP0, return a simplified version of an
4094 indirection through OP0, or NULL_TREE if no simplification is
4095 possible. Note that the resulting type may be different from
4096 the type pointed to in the sense that it is still compatible
4097 from the langhooks point of view. */
4100 gimple_fold_indirect_ref (tree t)
4102 tree ptype = TREE_TYPE (t), type = TREE_TYPE (ptype);
4107 subtype = TREE_TYPE (sub);
4108 if (!POINTER_TYPE_P (subtype))
4111 if (TREE_CODE (sub) == ADDR_EXPR)
4113 tree op = TREE_OPERAND (sub, 0);
4114 tree optype = TREE_TYPE (op);
4116 if (useless_type_conversion_p (type, optype))
4119 /* *(foo *)&fooarray => fooarray[0] */
4120 if (TREE_CODE (optype) == ARRAY_TYPE
4121 && TREE_CODE (TYPE_SIZE (TREE_TYPE (optype))) == INTEGER_CST
4122 && useless_type_conversion_p (type, TREE_TYPE (optype)))
4124 tree type_domain = TYPE_DOMAIN (optype);
4125 tree min_val = size_zero_node;
4126 if (type_domain && TYPE_MIN_VALUE (type_domain))
4127 min_val = TYPE_MIN_VALUE (type_domain);
4128 if (TREE_CODE (min_val) == INTEGER_CST)
4129 return build4 (ARRAY_REF, type, op, min_val, NULL_TREE, NULL_TREE);
4131 /* *(foo *)&complexfoo => __real__ complexfoo */
4132 else if (TREE_CODE (optype) == COMPLEX_TYPE
4133 && useless_type_conversion_p (type, TREE_TYPE (optype)))
4134 return fold_build1 (REALPART_EXPR, type, op);
4135 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
4136 else if (TREE_CODE (optype) == VECTOR_TYPE
4137 && useless_type_conversion_p (type, TREE_TYPE (optype)))
4139 tree part_width = TYPE_SIZE (type);
4140 tree index = bitsize_int (0);
4141 return fold_build3 (BIT_FIELD_REF, type, op, part_width, index);
4145 /* *(p + CST) -> ... */
4146 if (TREE_CODE (sub) == POINTER_PLUS_EXPR
4147 && TREE_CODE (TREE_OPERAND (sub, 1)) == INTEGER_CST)
4149 tree addr = TREE_OPERAND (sub, 0);
4150 tree off = TREE_OPERAND (sub, 1);
4154 addrtype = TREE_TYPE (addr);
4156 /* ((foo*)&vectorfoo)[1] -> BIT_FIELD_REF<vectorfoo,...> */
4157 if (TREE_CODE (addr) == ADDR_EXPR
4158 && TREE_CODE (TREE_TYPE (addrtype)) == VECTOR_TYPE
4159 && useless_type_conversion_p (type, TREE_TYPE (TREE_TYPE (addrtype)))
4160 && host_integerp (off, 1))
4162 unsigned HOST_WIDE_INT offset = tree_low_cst (off, 1);
4163 tree part_width = TYPE_SIZE (type);
4164 unsigned HOST_WIDE_INT part_widthi
4165 = tree_low_cst (part_width, 0) / BITS_PER_UNIT;
4166 unsigned HOST_WIDE_INT indexi = offset * BITS_PER_UNIT;
4167 tree index = bitsize_int (indexi);
4168 if (offset / part_widthi
4169 <= TYPE_VECTOR_SUBPARTS (TREE_TYPE (addrtype)))
4170 return fold_build3 (BIT_FIELD_REF, type, TREE_OPERAND (addr, 0),
4174 /* ((foo*)&complexfoo)[1] -> __imag__ complexfoo */
4175 if (TREE_CODE (addr) == ADDR_EXPR
4176 && TREE_CODE (TREE_TYPE (addrtype)) == COMPLEX_TYPE
4177 && useless_type_conversion_p (type, TREE_TYPE (TREE_TYPE (addrtype))))
4179 tree size = TYPE_SIZE_UNIT (type);
4180 if (tree_int_cst_equal (size, off))
4181 return fold_build1 (IMAGPART_EXPR, type, TREE_OPERAND (addr, 0));
4184 /* *(p + CST) -> MEM_REF <p, CST>. */
4185 if (TREE_CODE (addr) != ADDR_EXPR
4186 || DECL_P (TREE_OPERAND (addr, 0)))
4187 return fold_build2 (MEM_REF, type,
4189 build_int_cst_wide (ptype,
4190 TREE_INT_CST_LOW (off),
4191 TREE_INT_CST_HIGH (off)));
4194 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
4195 if (TREE_CODE (TREE_TYPE (subtype)) == ARRAY_TYPE
4196 && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (subtype)))) == INTEGER_CST
4197 && useless_type_conversion_p (type, TREE_TYPE (TREE_TYPE (subtype))))
4200 tree min_val = size_zero_node;
4202 sub = gimple_fold_indirect_ref (sub);
4204 sub = build1 (INDIRECT_REF, TREE_TYPE (subtype), osub);
4205 type_domain = TYPE_DOMAIN (TREE_TYPE (sub));
4206 if (type_domain && TYPE_MIN_VALUE (type_domain))
4207 min_val = TYPE_MIN_VALUE (type_domain);
4208 if (TREE_CODE (min_val) == INTEGER_CST)
4209 return build4 (ARRAY_REF, type, sub, min_val, NULL_TREE, NULL_TREE);
4215 /* Given a pointer value OP0, return a simplified version of an
4216 indirection through OP0, or NULL_TREE if no simplification is
4217 possible. This may only be applied to a rhs of an expression.
4218 Note that the resulting type may be different from the type pointed
4219 to in the sense that it is still compatible from the langhooks
4223 gimple_fold_indirect_ref_rhs (tree t)
4225 return gimple_fold_indirect_ref (t);
4228 /* Subroutine of gimplify_modify_expr to do simplifications of
4229 MODIFY_EXPRs based on the code of the RHS. We loop for as long as
4230 something changes. */
4232 static enum gimplify_status
4233 gimplify_modify_expr_rhs (tree *expr_p, tree *from_p, tree *to_p,
4234 gimple_seq *pre_p, gimple_seq *post_p,
4237 enum gimplify_status ret = GS_UNHANDLED;
4243 switch (TREE_CODE (*from_p))
4246 /* If we're assigning from a read-only variable initialized with
4247 a constructor, do the direct assignment from the constructor,
4248 but only if neither source nor target are volatile since this
4249 latter assignment might end up being done on a per-field basis. */
4250 if (DECL_INITIAL (*from_p)
4251 && TREE_READONLY (*from_p)
4252 && !TREE_THIS_VOLATILE (*from_p)
4253 && !TREE_THIS_VOLATILE (*to_p)
4254 && TREE_CODE (DECL_INITIAL (*from_p)) == CONSTRUCTOR)
4256 tree old_from = *from_p;
4257 enum gimplify_status subret;
4259 /* Move the constructor into the RHS. */
4260 *from_p = unshare_expr (DECL_INITIAL (*from_p));
4262 /* Let's see if gimplify_init_constructor will need to put
4264 subret = gimplify_init_constructor (expr_p, NULL, NULL,
4266 if (subret == GS_ERROR)
4268 /* If so, revert the change. */
4280 /* If we have code like
4284 where the type of "x" is a (possibly cv-qualified variant
4285 of "A"), treat the entire expression as identical to "x".
4286 This kind of code arises in C++ when an object is bound
4287 to a const reference, and if "x" is a TARGET_EXPR we want
4288 to take advantage of the optimization below. */
4289 bool volatile_p = TREE_THIS_VOLATILE (*from_p);
4290 tree t = gimple_fold_indirect_ref_rhs (TREE_OPERAND (*from_p, 0));
4293 if (TREE_THIS_VOLATILE (t) != volatile_p)
4295 if (TREE_CODE_CLASS (TREE_CODE (t)) == tcc_declaration)
4296 t = build_simple_mem_ref_loc (EXPR_LOCATION (*from_p),
4297 build_fold_addr_expr (t));
4298 if (REFERENCE_CLASS_P (t))
4299 TREE_THIS_VOLATILE (t) = volatile_p;
4310 /* If we are initializing something from a TARGET_EXPR, strip the
4311 TARGET_EXPR and initialize it directly, if possible. This can't
4312 be done if the initializer is void, since that implies that the
4313 temporary is set in some non-trivial way.
4315 ??? What about code that pulls out the temp and uses it
4316 elsewhere? I think that such code never uses the TARGET_EXPR as
4317 an initializer. If I'm wrong, we'll die because the temp won't
4318 have any RTL. In that case, I guess we'll need to replace
4319 references somehow. */
4320 tree init = TARGET_EXPR_INITIAL (*from_p);
4323 && !VOID_TYPE_P (TREE_TYPE (init)))
4333 /* Remove any COMPOUND_EXPR in the RHS so the following cases will be
4335 gimplify_compound_expr (from_p, pre_p, true);
4341 /* If we already made some changes, let the front end have a
4342 crack at this before we break it down. */
4343 if (ret != GS_UNHANDLED)
4345 /* If we're initializing from a CONSTRUCTOR, break this into
4346 individual MODIFY_EXPRs. */
4347 return gimplify_init_constructor (expr_p, pre_p, post_p, want_value,
4351 /* If we're assigning to a non-register type, push the assignment
4352 down into the branches. This is mandatory for ADDRESSABLE types,
4353 since we cannot generate temporaries for such, but it saves a
4354 copy in other cases as well. */
4355 if (!is_gimple_reg_type (TREE_TYPE (*from_p)))
4357 /* This code should mirror the code in gimplify_cond_expr. */
4358 enum tree_code code = TREE_CODE (*expr_p);
4359 tree cond = *from_p;
4360 tree result = *to_p;
4362 ret = gimplify_expr (&result, pre_p, post_p,
4363 is_gimple_lvalue, fb_lvalue);
4364 if (ret != GS_ERROR)
4367 if (TREE_TYPE (TREE_OPERAND (cond, 1)) != void_type_node)
4368 TREE_OPERAND (cond, 1)
4369 = build2 (code, void_type_node, result,
4370 TREE_OPERAND (cond, 1));
4371 if (TREE_TYPE (TREE_OPERAND (cond, 2)) != void_type_node)
4372 TREE_OPERAND (cond, 2)
4373 = build2 (code, void_type_node, unshare_expr (result),
4374 TREE_OPERAND (cond, 2));
4376 TREE_TYPE (cond) = void_type_node;
4377 recalculate_side_effects (cond);
4381 gimplify_and_add (cond, pre_p);
4382 *expr_p = unshare_expr (result);
4391 /* For calls that return in memory, give *to_p as the CALL_EXPR's
4392 return slot so that we don't generate a temporary. */
4393 if (!CALL_EXPR_RETURN_SLOT_OPT (*from_p)
4394 && aggregate_value_p (*from_p, *from_p))
4398 if (!(rhs_predicate_for (*to_p))(*from_p))
4399 /* If we need a temporary, *to_p isn't accurate. */
4401 /* It's OK to use the return slot directly unless it's an NRV. */
4402 else if (TREE_CODE (*to_p) == RESULT_DECL
4403 && DECL_NAME (*to_p) == NULL_TREE
4404 && needs_to_live_in_memory (*to_p))
4406 else if (is_gimple_reg_type (TREE_TYPE (*to_p))
4407 || (DECL_P (*to_p) && DECL_REGISTER (*to_p)))
4408 /* Don't force regs into memory. */
4410 else if (TREE_CODE (*expr_p) == INIT_EXPR)
4411 /* It's OK to use the target directly if it's being
4414 else if (TREE_CODE (*to_p) != SSA_NAME
4415 && (!is_gimple_variable (*to_p)
4416 || needs_to_live_in_memory (*to_p)))
4417 /* Don't use the original target if it's already addressable;
4418 if its address escapes, and the called function uses the
4419 NRV optimization, a conforming program could see *to_p
4420 change before the called function returns; see c++/19317.
4421 When optimizing, the return_slot pass marks more functions
4422 as safe after we have escape info. */
4429 CALL_EXPR_RETURN_SLOT_OPT (*from_p) = 1;
4430 mark_addressable (*to_p);
4435 case WITH_SIZE_EXPR:
4436 /* Likewise for calls that return an aggregate of non-constant size,
4437 since we would not be able to generate a temporary at all. */
4438 if (TREE_CODE (TREE_OPERAND (*from_p, 0)) == CALL_EXPR)
4440 *from_p = TREE_OPERAND (*from_p, 0);
4441 /* We don't change ret in this case because the
4442 WITH_SIZE_EXPR might have been added in
4443 gimplify_modify_expr, so returning GS_OK would lead to an
4449 /* If we're initializing from a container, push the initialization
4451 case CLEANUP_POINT_EXPR:
4453 case STATEMENT_LIST:
4455 tree wrap = *from_p;
4458 ret = gimplify_expr (to_p, pre_p, post_p, is_gimple_min_lval,
4460 if (ret != GS_ERROR)
4463 t = voidify_wrapper_expr (wrap, *expr_p);
4464 gcc_assert (t == *expr_p);
4468 gimplify_and_add (wrap, pre_p);
4469 *expr_p = unshare_expr (*to_p);
4476 case COMPOUND_LITERAL_EXPR:
4478 tree complit = TREE_OPERAND (*expr_p, 1);
4479 tree decl_s = COMPOUND_LITERAL_EXPR_DECL_EXPR (complit);
4480 tree decl = DECL_EXPR_DECL (decl_s);
4481 tree init = DECL_INITIAL (decl);
4483 /* struct T x = (struct T) { 0, 1, 2 } can be optimized
4484 into struct T x = { 0, 1, 2 } if the address of the
4485 compound literal has never been taken. */
4486 if (!TREE_ADDRESSABLE (complit)
4487 && !TREE_ADDRESSABLE (decl)
4490 *expr_p = copy_node (*expr_p);
4491 TREE_OPERAND (*expr_p, 1) = init;
4505 /* Promote partial stores to COMPLEX variables to total stores. *EXPR_P is
4506 a MODIFY_EXPR with a lhs of a REAL/IMAGPART_EXPR of a variable with
4507 DECL_GIMPLE_REG_P set.
4509 IMPORTANT NOTE: This promotion is performed by introducing a load of the
4510 other, unmodified part of the complex object just before the total store.
4511 As a consequence, if the object is still uninitialized, an undefined value
4512 will be loaded into a register, which may result in a spurious exception
4513 if the register is floating-point and the value happens to be a signaling
4514 NaN for example. Then the fully-fledged complex operations lowering pass
4515 followed by a DCE pass are necessary in order to fix things up. */
4517 static enum gimplify_status
4518 gimplify_modify_expr_complex_part (tree *expr_p, gimple_seq *pre_p,
4521 enum tree_code code, ocode;
4522 tree lhs, rhs, new_rhs, other, realpart, imagpart;
4524 lhs = TREE_OPERAND (*expr_p, 0);
4525 rhs = TREE_OPERAND (*expr_p, 1);
4526 code = TREE_CODE (lhs);
4527 lhs = TREE_OPERAND (lhs, 0);
4529 ocode = code == REALPART_EXPR ? IMAGPART_EXPR : REALPART_EXPR;
4530 other = build1 (ocode, TREE_TYPE (rhs), lhs);
4531 TREE_NO_WARNING (other) = 1;
4532 other = get_formal_tmp_var (other, pre_p);
4534 realpart = code == REALPART_EXPR ? rhs : other;
4535 imagpart = code == REALPART_EXPR ? other : rhs;
4537 if (TREE_CONSTANT (realpart) && TREE_CONSTANT (imagpart))
4538 new_rhs = build_complex (TREE_TYPE (lhs), realpart, imagpart);
4540 new_rhs = build2 (COMPLEX_EXPR, TREE_TYPE (lhs), realpart, imagpart);
4542 gimplify_seq_add_stmt (pre_p, gimple_build_assign (lhs, new_rhs));
4543 *expr_p = (want_value) ? rhs : NULL_TREE;
4548 /* Gimplify the MODIFY_EXPR node pointed to by EXPR_P.
4554 PRE_P points to the list where side effects that must happen before
4555 *EXPR_P should be stored.
4557 POST_P points to the list where side effects that must happen after
4558 *EXPR_P should be stored.
4560 WANT_VALUE is nonzero iff we want to use the value of this expression
4561 in another expression. */
4563 static enum gimplify_status
4564 gimplify_modify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
4567 tree *from_p = &TREE_OPERAND (*expr_p, 1);
4568 tree *to_p = &TREE_OPERAND (*expr_p, 0);
4569 enum gimplify_status ret = GS_UNHANDLED;
4571 location_t loc = EXPR_LOCATION (*expr_p);
4573 gcc_assert (TREE_CODE (*expr_p) == MODIFY_EXPR
4574 || TREE_CODE (*expr_p) == INIT_EXPR);
4576 /* Trying to simplify a clobber using normal logic doesn't work,
4577 so handle it here. */
4578 if (TREE_CLOBBER_P (*from_p))
4580 gcc_assert (!want_value && TREE_CODE (*to_p) == VAR_DECL);
4581 gimplify_seq_add_stmt (pre_p, gimple_build_assign (*to_p, *from_p));
4586 /* Insert pointer conversions required by the middle-end that are not
4587 required by the frontend. This fixes middle-end type checking for
4588 for example gcc.dg/redecl-6.c. */
4589 if (POINTER_TYPE_P (TREE_TYPE (*to_p)))
4591 STRIP_USELESS_TYPE_CONVERSION (*from_p);
4592 if (!useless_type_conversion_p (TREE_TYPE (*to_p), TREE_TYPE (*from_p)))
4593 *from_p = fold_convert_loc (loc, TREE_TYPE (*to_p), *from_p);
4596 /* See if any simplifications can be done based on what the RHS is. */
4597 ret = gimplify_modify_expr_rhs (expr_p, from_p, to_p, pre_p, post_p,
4599 if (ret != GS_UNHANDLED)
4602 /* For zero sized types only gimplify the left hand side and right hand
4603 side as statements and throw away the assignment. Do this after
4604 gimplify_modify_expr_rhs so we handle TARGET_EXPRs of addressable
4606 if (zero_sized_type (TREE_TYPE (*from_p)) && !want_value)
4608 gimplify_stmt (from_p, pre_p);
4609 gimplify_stmt (to_p, pre_p);
4610 *expr_p = NULL_TREE;
4614 /* If the value being copied is of variable width, compute the length
4615 of the copy into a WITH_SIZE_EXPR. Note that we need to do this
4616 before gimplifying any of the operands so that we can resolve any
4617 PLACEHOLDER_EXPRs in the size. Also note that the RTL expander uses
4618 the size of the expression to be copied, not of the destination, so
4619 that is what we must do here. */
4620 maybe_with_size_expr (from_p);
4622 ret = gimplify_expr (to_p, pre_p, post_p, is_gimple_lvalue, fb_lvalue);
4623 if (ret == GS_ERROR)
4626 /* As a special case, we have to temporarily allow for assignments
4627 with a CALL_EXPR on the RHS. Since in GIMPLE a function call is
4628 a toplevel statement, when gimplifying the GENERIC expression
4629 MODIFY_EXPR <a, CALL_EXPR <foo>>, we cannot create the tuple
4630 GIMPLE_ASSIGN <a, GIMPLE_CALL <foo>>.
4632 Instead, we need to create the tuple GIMPLE_CALL <a, foo>. To
4633 prevent gimplify_expr from trying to create a new temporary for
4634 foo's LHS, we tell it that it should only gimplify until it
4635 reaches the CALL_EXPR. On return from gimplify_expr, the newly
4636 created GIMPLE_CALL <foo> will be the last statement in *PRE_P
4637 and all we need to do here is set 'a' to be its LHS. */
4638 ret = gimplify_expr (from_p, pre_p, post_p, rhs_predicate_for (*to_p),
4640 if (ret == GS_ERROR)
4643 /* Now see if the above changed *from_p to something we handle specially. */
4644 ret = gimplify_modify_expr_rhs (expr_p, from_p, to_p, pre_p, post_p,
4646 if (ret != GS_UNHANDLED)
4649 /* If we've got a variable sized assignment between two lvalues (i.e. does
4650 not involve a call), then we can make things a bit more straightforward
4651 by converting the assignment to memcpy or memset. */
4652 if (TREE_CODE (*from_p) == WITH_SIZE_EXPR)
4654 tree from = TREE_OPERAND (*from_p, 0);
4655 tree size = TREE_OPERAND (*from_p, 1);
4657 if (TREE_CODE (from) == CONSTRUCTOR)
4658 return gimplify_modify_expr_to_memset (expr_p, size, want_value, pre_p);
4660 if (is_gimple_addressable (from))
4663 return gimplify_modify_expr_to_memcpy (expr_p, size, want_value,
4668 /* Transform partial stores to non-addressable complex variables into
4669 total stores. This allows us to use real instead of virtual operands
4670 for these variables, which improves optimization. */
4671 if ((TREE_CODE (*to_p) == REALPART_EXPR
4672 || TREE_CODE (*to_p) == IMAGPART_EXPR)
4673 && is_gimple_reg (TREE_OPERAND (*to_p, 0)))
4674 return gimplify_modify_expr_complex_part (expr_p, pre_p, want_value);
4676 /* Try to alleviate the effects of the gimplification creating artificial
4677 temporaries (see for example is_gimple_reg_rhs) on the debug info. */
4678 if (!gimplify_ctxp->into_ssa
4679 && TREE_CODE (*from_p) == VAR_DECL
4680 && DECL_IGNORED_P (*from_p)
4682 && !DECL_IGNORED_P (*to_p))
4684 if (!DECL_NAME (*from_p) && DECL_NAME (*to_p))
4686 = create_tmp_var_name (IDENTIFIER_POINTER (DECL_NAME (*to_p)));
4687 DECL_DEBUG_EXPR_IS_FROM (*from_p) = 1;
4688 SET_DECL_DEBUG_EXPR (*from_p, *to_p);
4691 if (want_value && TREE_THIS_VOLATILE (*to_p))
4692 *from_p = get_initialized_tmp_var (*from_p, pre_p, post_p);
4694 if (TREE_CODE (*from_p) == CALL_EXPR)
4696 /* Since the RHS is a CALL_EXPR, we need to create a GIMPLE_CALL
4697 instead of a GIMPLE_ASSIGN. */
4698 tree fnptrtype = TREE_TYPE (CALL_EXPR_FN (*from_p));
4699 CALL_EXPR_FN (*from_p) = TREE_OPERAND (CALL_EXPR_FN (*from_p), 0);
4700 STRIP_USELESS_TYPE_CONVERSION (CALL_EXPR_FN (*from_p));
4701 assign = gimple_build_call_from_tree (*from_p);
4702 gimple_call_set_fntype (assign, TREE_TYPE (fnptrtype));
4703 if (!gimple_call_noreturn_p (assign))
4704 gimple_call_set_lhs (assign, *to_p);
4708 assign = gimple_build_assign (*to_p, *from_p);
4709 gimple_set_location (assign, EXPR_LOCATION (*expr_p));
4712 gimplify_seq_add_stmt (pre_p, assign);
4714 if (gimplify_ctxp->into_ssa && is_gimple_reg (*to_p))
4716 /* If we've somehow already got an SSA_NAME on the LHS, then
4717 we've probably modified it twice. Not good. */
4718 gcc_assert (TREE_CODE (*to_p) != SSA_NAME);
4719 *to_p = make_ssa_name (*to_p, assign);
4720 gimple_set_lhs (assign, *to_p);
4725 *expr_p = TREE_THIS_VOLATILE (*to_p) ? *from_p : unshare_expr (*to_p);
4734 /* Gimplify a comparison between two variable-sized objects. Do this
4735 with a call to BUILT_IN_MEMCMP. */
4737 static enum gimplify_status
4738 gimplify_variable_sized_compare (tree *expr_p)
4740 location_t loc = EXPR_LOCATION (*expr_p);
4741 tree op0 = TREE_OPERAND (*expr_p, 0);
4742 tree op1 = TREE_OPERAND (*expr_p, 1);
4743 tree t, arg, dest, src, expr;
4745 arg = TYPE_SIZE_UNIT (TREE_TYPE (op0));
4746 arg = unshare_expr (arg);
4747 arg = SUBSTITUTE_PLACEHOLDER_IN_EXPR (arg, op0);
4748 src = build_fold_addr_expr_loc (loc, op1);
4749 dest = build_fold_addr_expr_loc (loc, op0);
4750 t = builtin_decl_implicit (BUILT_IN_MEMCMP);
4751 t = build_call_expr_loc (loc, t, 3, dest, src, arg);
4754 = build2 (TREE_CODE (*expr_p), TREE_TYPE (*expr_p), t, integer_zero_node);
4755 SET_EXPR_LOCATION (expr, loc);
4761 /* Gimplify a comparison between two aggregate objects of integral scalar
4762 mode as a comparison between the bitwise equivalent scalar values. */
4764 static enum gimplify_status
4765 gimplify_scalar_mode_aggregate_compare (tree *expr_p)
4767 location_t loc = EXPR_LOCATION (*expr_p);
4768 tree op0 = TREE_OPERAND (*expr_p, 0);
4769 tree op1 = TREE_OPERAND (*expr_p, 1);
4771 tree type = TREE_TYPE (op0);
4772 tree scalar_type = lang_hooks.types.type_for_mode (TYPE_MODE (type), 1);
4774 op0 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, scalar_type, op0);
4775 op1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, scalar_type, op1);
4778 = fold_build2_loc (loc, TREE_CODE (*expr_p), TREE_TYPE (*expr_p), op0, op1);
4783 /* Gimplify an expression sequence. This function gimplifies each
4784 expression and rewrites the original expression with the last
4785 expression of the sequence in GIMPLE form.
4787 PRE_P points to the list where the side effects for all the
4788 expressions in the sequence will be emitted.
4790 WANT_VALUE is true when the result of the last COMPOUND_EXPR is used. */
4792 static enum gimplify_status
4793 gimplify_compound_expr (tree *expr_p, gimple_seq *pre_p, bool want_value)
4799 tree *sub_p = &TREE_OPERAND (t, 0);
4801 if (TREE_CODE (*sub_p) == COMPOUND_EXPR)
4802 gimplify_compound_expr (sub_p, pre_p, false);
4804 gimplify_stmt (sub_p, pre_p);
4806 t = TREE_OPERAND (t, 1);
4808 while (TREE_CODE (t) == COMPOUND_EXPR);
4815 gimplify_stmt (expr_p, pre_p);
4820 /* Gimplify a SAVE_EXPR node. EXPR_P points to the expression to
4821 gimplify. After gimplification, EXPR_P will point to a new temporary
4822 that holds the original value of the SAVE_EXPR node.
4824 PRE_P points to the list where side effects that must happen before
4825 *EXPR_P should be stored. */
4827 static enum gimplify_status
4828 gimplify_save_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
4830 enum gimplify_status ret = GS_ALL_DONE;
4833 gcc_assert (TREE_CODE (*expr_p) == SAVE_EXPR);
4834 val = TREE_OPERAND (*expr_p, 0);
4836 /* If the SAVE_EXPR has not been resolved, then evaluate it once. */
4837 if (!SAVE_EXPR_RESOLVED_P (*expr_p))
4839 /* The operand may be a void-valued expression such as SAVE_EXPRs
4840 generated by the Java frontend for class initialization. It is
4841 being executed only for its side-effects. */
4842 if (TREE_TYPE (val) == void_type_node)
4844 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
4845 is_gimple_stmt, fb_none);
4849 val = get_initialized_tmp_var (val, pre_p, post_p);
4851 TREE_OPERAND (*expr_p, 0) = val;
4852 SAVE_EXPR_RESOLVED_P (*expr_p) = 1;
4860 /* Rewrite the ADDR_EXPR node pointed to by EXPR_P
4867 PRE_P points to the list where side effects that must happen before
4868 *EXPR_P should be stored.
4870 POST_P points to the list where side effects that must happen after
4871 *EXPR_P should be stored. */
4873 static enum gimplify_status
4874 gimplify_addr_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
4876 tree expr = *expr_p;
4877 tree op0 = TREE_OPERAND (expr, 0);
4878 enum gimplify_status ret;
4879 location_t loc = EXPR_LOCATION (*expr_p);
4881 switch (TREE_CODE (op0))
4885 /* Check if we are dealing with an expression of the form '&*ptr'.
4886 While the front end folds away '&*ptr' into 'ptr', these
4887 expressions may be generated internally by the compiler (e.g.,
4888 builtins like __builtin_va_end). */
4889 /* Caution: the silent array decomposition semantics we allow for
4890 ADDR_EXPR means we can't always discard the pair. */
4891 /* Gimplification of the ADDR_EXPR operand may drop
4892 cv-qualification conversions, so make sure we add them if
4895 tree op00 = TREE_OPERAND (op0, 0);
4896 tree t_expr = TREE_TYPE (expr);
4897 tree t_op00 = TREE_TYPE (op00);
4899 if (!useless_type_conversion_p (t_expr, t_op00))
4900 op00 = fold_convert_loc (loc, TREE_TYPE (expr), op00);
4906 case VIEW_CONVERT_EXPR:
4907 /* Take the address of our operand and then convert it to the type of
4910 ??? The interactions of VIEW_CONVERT_EXPR and aliasing is not at
4911 all clear. The impact of this transformation is even less clear. */
4913 /* If the operand is a useless conversion, look through it. Doing so
4914 guarantees that the ADDR_EXPR and its operand will remain of the
4916 if (tree_ssa_useless_type_conversion (TREE_OPERAND (op0, 0)))
4917 op0 = TREE_OPERAND (op0, 0);
4919 *expr_p = fold_convert_loc (loc, TREE_TYPE (expr),
4920 build_fold_addr_expr_loc (loc,
4921 TREE_OPERAND (op0, 0)));
4926 /* We use fb_either here because the C frontend sometimes takes
4927 the address of a call that returns a struct; see
4928 gcc.dg/c99-array-lval-1.c. The gimplifier will correctly make
4929 the implied temporary explicit. */
4931 /* Make the operand addressable. */
4932 ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, post_p,
4933 is_gimple_addressable, fb_either);
4934 if (ret == GS_ERROR)
4937 /* Then mark it. Beware that it may not be possible to do so directly
4938 if a temporary has been created by the gimplification. */
4939 prepare_gimple_addressable (&TREE_OPERAND (expr, 0), pre_p);
4941 op0 = TREE_OPERAND (expr, 0);
4943 /* For various reasons, the gimplification of the expression
4944 may have made a new INDIRECT_REF. */
4945 if (TREE_CODE (op0) == INDIRECT_REF)
4946 goto do_indirect_ref;
4948 mark_addressable (TREE_OPERAND (expr, 0));
4950 /* The FEs may end up building ADDR_EXPRs early on a decl with
4951 an incomplete type. Re-build ADDR_EXPRs in canonical form
4953 if (!types_compatible_p (TREE_TYPE (op0), TREE_TYPE (TREE_TYPE (expr))))
4954 *expr_p = build_fold_addr_expr (op0);
4956 /* Make sure TREE_CONSTANT and TREE_SIDE_EFFECTS are set properly. */
4957 recompute_tree_invariant_for_addr_expr (*expr_p);
4959 /* If we re-built the ADDR_EXPR add a conversion to the original type
4961 if (!useless_type_conversion_p (TREE_TYPE (expr), TREE_TYPE (*expr_p)))
4962 *expr_p = fold_convert (TREE_TYPE (expr), *expr_p);
4970 /* Gimplify the operands of an ASM_EXPR. Input operands should be a gimple
4971 value; output operands should be a gimple lvalue. */
4973 static enum gimplify_status
4974 gimplify_asm_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
4978 const char **oconstraints;
4981 const char *constraint;
4982 bool allows_mem, allows_reg, is_inout;
4983 enum gimplify_status ret, tret;
4985 VEC(tree, gc) *inputs;
4986 VEC(tree, gc) *outputs;
4987 VEC(tree, gc) *clobbers;
4988 VEC(tree, gc) *labels;
4992 noutputs = list_length (ASM_OUTPUTS (expr));
4993 oconstraints = (const char **) alloca ((noutputs) * sizeof (const char *));
4995 inputs = outputs = clobbers = labels = NULL;
4998 link_next = NULL_TREE;
4999 for (i = 0, link = ASM_OUTPUTS (expr); link; ++i, link = link_next)
5002 size_t constraint_len;
5004 link_next = TREE_CHAIN (link);
5008 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
5009 constraint_len = strlen (constraint);
5010 if (constraint_len == 0)
5013 ok = parse_output_constraint (&constraint, i, 0, 0,
5014 &allows_mem, &allows_reg, &is_inout);
5021 if (!allows_reg && allows_mem)
5022 mark_addressable (TREE_VALUE (link));
5024 tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
5025 is_inout ? is_gimple_min_lval : is_gimple_lvalue,
5026 fb_lvalue | fb_mayfail);
5027 if (tret == GS_ERROR)
5029 error ("invalid lvalue in asm output %d", i);
5033 VEC_safe_push (tree, gc, outputs, link);
5034 TREE_CHAIN (link) = NULL_TREE;
5038 /* An input/output operand. To give the optimizers more
5039 flexibility, split it into separate input and output
5044 /* Turn the in/out constraint into an output constraint. */
5045 char *p = xstrdup (constraint);
5047 TREE_VALUE (TREE_PURPOSE (link)) = build_string (constraint_len, p);
5049 /* And add a matching input constraint. */
5052 sprintf (buf, "%d", i);
5054 /* If there are multiple alternatives in the constraint,
5055 handle each of them individually. Those that allow register
5056 will be replaced with operand number, the others will stay
5058 if (strchr (p, ',') != NULL)
5060 size_t len = 0, buflen = strlen (buf);
5061 char *beg, *end, *str, *dst;
5065 end = strchr (beg, ',');
5067 end = strchr (beg, '\0');
5068 if ((size_t) (end - beg) < buflen)
5071 len += end - beg + 1;
5078 str = (char *) alloca (len);
5079 for (beg = p + 1, dst = str;;)
5082 bool mem_p, reg_p, inout_p;
5084 end = strchr (beg, ',');
5089 parse_output_constraint (&tem, i, 0, 0,
5090 &mem_p, ®_p, &inout_p);
5095 memcpy (dst, buf, buflen);
5104 memcpy (dst, beg, len);
5113 input = build_string (dst - str, str);
5116 input = build_string (strlen (buf), buf);
5119 input = build_string (constraint_len - 1, constraint + 1);
5123 input = build_tree_list (build_tree_list (NULL_TREE, input),
5124 unshare_expr (TREE_VALUE (link)));
5125 ASM_INPUTS (expr) = chainon (ASM_INPUTS (expr), input);
5129 link_next = NULL_TREE;
5130 for (link = ASM_INPUTS (expr); link; ++i, link = link_next)
5132 link_next = TREE_CHAIN (link);
5133 constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
5134 parse_input_constraint (&constraint, 0, 0, noutputs, 0,
5135 oconstraints, &allows_mem, &allows_reg);
5137 /* If we can't make copies, we can only accept memory. */
5138 if (TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (link))))
5144 error ("impossible constraint in %<asm%>");
5145 error ("non-memory input %d must stay in memory", i);
5150 /* If the operand is a memory input, it should be an lvalue. */
5151 if (!allows_reg && allows_mem)
5153 tree inputv = TREE_VALUE (link);
5154 STRIP_NOPS (inputv);
5155 if (TREE_CODE (inputv) == PREDECREMENT_EXPR
5156 || TREE_CODE (inputv) == PREINCREMENT_EXPR
5157 || TREE_CODE (inputv) == POSTDECREMENT_EXPR
5158 || TREE_CODE (inputv) == POSTINCREMENT_EXPR)
5159 TREE_VALUE (link) = error_mark_node;
5160 tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
5161 is_gimple_lvalue, fb_lvalue | fb_mayfail);
5162 mark_addressable (TREE_VALUE (link));
5163 if (tret == GS_ERROR)
5165 if (EXPR_HAS_LOCATION (TREE_VALUE (link)))
5166 input_location = EXPR_LOCATION (TREE_VALUE (link));
5167 error ("memory input %d is not directly addressable", i);
5173 tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
5174 is_gimple_asm_val, fb_rvalue);
5175 if (tret == GS_ERROR)
5179 TREE_CHAIN (link) = NULL_TREE;
5180 VEC_safe_push (tree, gc, inputs, link);
5183 for (link = ASM_CLOBBERS (expr); link; ++i, link = TREE_CHAIN (link))
5184 VEC_safe_push (tree, gc, clobbers, link);
5186 for (link = ASM_LABELS (expr); link; ++i, link = TREE_CHAIN (link))
5187 VEC_safe_push (tree, gc, labels, link);
5189 /* Do not add ASMs with errors to the gimple IL stream. */
5190 if (ret != GS_ERROR)
5192 stmt = gimple_build_asm_vec (TREE_STRING_POINTER (ASM_STRING (expr)),
5193 inputs, outputs, clobbers, labels);
5195 gimple_asm_set_volatile (stmt, ASM_VOLATILE_P (expr));
5196 gimple_asm_set_input (stmt, ASM_INPUT_P (expr));
5198 gimplify_seq_add_stmt (pre_p, stmt);
5204 /* Gimplify a CLEANUP_POINT_EXPR. Currently this works by adding
5205 GIMPLE_WITH_CLEANUP_EXPRs to the prequeue as we encounter cleanups while
5206 gimplifying the body, and converting them to TRY_FINALLY_EXPRs when we
5207 return to this function.
5209 FIXME should we complexify the prequeue handling instead? Or use flags
5210 for all the cleanups and let the optimizer tighten them up? The current
5211 code seems pretty fragile; it will break on a cleanup within any
5212 non-conditional nesting. But any such nesting would be broken, anyway;
5213 we can't write a TRY_FINALLY_EXPR that starts inside a nesting construct
5214 and continues out of it. We can do that at the RTL level, though, so
5215 having an optimizer to tighten up try/finally regions would be a Good
5218 static enum gimplify_status
5219 gimplify_cleanup_point_expr (tree *expr_p, gimple_seq *pre_p)
5221 gimple_stmt_iterator iter;
5222 gimple_seq body_sequence = NULL;
5224 tree temp = voidify_wrapper_expr (*expr_p, NULL);
5226 /* We only care about the number of conditions between the innermost
5227 CLEANUP_POINT_EXPR and the cleanup. So save and reset the count and
5228 any cleanups collected outside the CLEANUP_POINT_EXPR. */
5229 int old_conds = gimplify_ctxp->conditions;
5230 gimple_seq old_cleanups = gimplify_ctxp->conditional_cleanups;
5231 bool old_in_cleanup_point_expr = gimplify_ctxp->in_cleanup_point_expr;
5232 gimplify_ctxp->conditions = 0;
5233 gimplify_ctxp->conditional_cleanups = NULL;
5234 gimplify_ctxp->in_cleanup_point_expr = true;
5236 gimplify_stmt (&TREE_OPERAND (*expr_p, 0), &body_sequence);
5238 gimplify_ctxp->conditions = old_conds;
5239 gimplify_ctxp->conditional_cleanups = old_cleanups;
5240 gimplify_ctxp->in_cleanup_point_expr = old_in_cleanup_point_expr;
5242 for (iter = gsi_start (body_sequence); !gsi_end_p (iter); )
5244 gimple wce = gsi_stmt (iter);
5246 if (gimple_code (wce) == GIMPLE_WITH_CLEANUP_EXPR)
5248 if (gsi_one_before_end_p (iter))
5250 /* Note that gsi_insert_seq_before and gsi_remove do not
5251 scan operands, unlike some other sequence mutators. */
5252 if (!gimple_wce_cleanup_eh_only (wce))
5253 gsi_insert_seq_before_without_update (&iter,
5254 gimple_wce_cleanup (wce),
5256 gsi_remove (&iter, true);
5263 enum gimple_try_flags kind;
5265 if (gimple_wce_cleanup_eh_only (wce))
5266 kind = GIMPLE_TRY_CATCH;
5268 kind = GIMPLE_TRY_FINALLY;
5269 seq = gsi_split_seq_after (iter);
5271 gtry = gimple_build_try (seq, gimple_wce_cleanup (wce), kind);
5272 /* Do not use gsi_replace here, as it may scan operands.
5273 We want to do a simple structural modification only. */
5274 *gsi_stmt_ptr (&iter) = gtry;
5275 iter = gsi_start (seq);
5282 gimplify_seq_add_seq (pre_p, body_sequence);
5295 /* Insert a cleanup marker for gimplify_cleanup_point_expr. CLEANUP
5296 is the cleanup action required. EH_ONLY is true if the cleanup should
5297 only be executed if an exception is thrown, not on normal exit. */
5300 gimple_push_cleanup (tree var, tree cleanup, bool eh_only, gimple_seq *pre_p)
5303 gimple_seq cleanup_stmts = NULL;
5305 /* Errors can result in improperly nested cleanups. Which results in
5306 confusion when trying to resolve the GIMPLE_WITH_CLEANUP_EXPR. */
5310 if (gimple_conditional_context ())
5312 /* If we're in a conditional context, this is more complex. We only
5313 want to run the cleanup if we actually ran the initialization that
5314 necessitates it, but we want to run it after the end of the
5315 conditional context. So we wrap the try/finally around the
5316 condition and use a flag to determine whether or not to actually
5317 run the destructor. Thus
5321 becomes (approximately)
5325 if (test) { A::A(temp); flag = 1; val = f(temp); }
5328 if (flag) A::~A(temp);
5332 tree flag = create_tmp_var (boolean_type_node, "cleanup");
5333 gimple ffalse = gimple_build_assign (flag, boolean_false_node);
5334 gimple ftrue = gimple_build_assign (flag, boolean_true_node);
5336 cleanup = build3 (COND_EXPR, void_type_node, flag, cleanup, NULL);
5337 gimplify_stmt (&cleanup, &cleanup_stmts);
5338 wce = gimple_build_wce (cleanup_stmts);
5340 gimplify_seq_add_stmt (&gimplify_ctxp->conditional_cleanups, ffalse);
5341 gimplify_seq_add_stmt (&gimplify_ctxp->conditional_cleanups, wce);
5342 gimplify_seq_add_stmt (pre_p, ftrue);
5344 /* Because of this manipulation, and the EH edges that jump
5345 threading cannot redirect, the temporary (VAR) will appear
5346 to be used uninitialized. Don't warn. */
5347 TREE_NO_WARNING (var) = 1;
5351 gimplify_stmt (&cleanup, &cleanup_stmts);
5352 wce = gimple_build_wce (cleanup_stmts);
5353 gimple_wce_set_cleanup_eh_only (wce, eh_only);
5354 gimplify_seq_add_stmt (pre_p, wce);
5358 /* Gimplify a TARGET_EXPR which doesn't appear on the rhs of an INIT_EXPR. */
5360 static enum gimplify_status
5361 gimplify_target_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
5363 tree targ = *expr_p;
5364 tree temp = TARGET_EXPR_SLOT (targ);
5365 tree init = TARGET_EXPR_INITIAL (targ);
5366 enum gimplify_status ret;
5370 tree cleanup = NULL_TREE;
5372 /* TARGET_EXPR temps aren't part of the enclosing block, so add it
5373 to the temps list. Handle also variable length TARGET_EXPRs. */
5374 if (TREE_CODE (DECL_SIZE (temp)) != INTEGER_CST)
5376 if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (temp)))
5377 gimplify_type_sizes (TREE_TYPE (temp), pre_p);
5378 gimplify_vla_decl (temp, pre_p);
5381 gimple_add_tmp_var (temp);
5383 /* If TARGET_EXPR_INITIAL is void, then the mere evaluation of the
5384 expression is supposed to initialize the slot. */
5385 if (VOID_TYPE_P (TREE_TYPE (init)))
5386 ret = gimplify_expr (&init, pre_p, post_p, is_gimple_stmt, fb_none);
5389 tree init_expr = build2 (INIT_EXPR, void_type_node, temp, init);
5391 ret = gimplify_expr (&init, pre_p, post_p, is_gimple_stmt, fb_none);
5393 ggc_free (init_expr);
5395 if (ret == GS_ERROR)
5397 /* PR c++/28266 Make sure this is expanded only once. */
5398 TARGET_EXPR_INITIAL (targ) = NULL_TREE;
5402 gimplify_and_add (init, pre_p);
5404 /* If needed, push the cleanup for the temp. */
5405 if (TARGET_EXPR_CLEANUP (targ))
5407 if (CLEANUP_EH_ONLY (targ))
5408 gimple_push_cleanup (temp, TARGET_EXPR_CLEANUP (targ),
5409 CLEANUP_EH_ONLY (targ), pre_p);
5411 cleanup = TARGET_EXPR_CLEANUP (targ);
5414 /* Add a clobber for the temporary going out of scope, like
5415 gimplify_bind_expr. */
5416 if (gimplify_ctxp->in_cleanup_point_expr
5417 && needs_to_live_in_memory (temp))
5419 tree clobber = build_constructor (TREE_TYPE (temp), NULL);
5420 TREE_THIS_VOLATILE (clobber) = true;
5421 clobber = build2 (MODIFY_EXPR, TREE_TYPE (temp), temp, clobber);
5423 cleanup = build2 (COMPOUND_EXPR, void_type_node, cleanup,
5430 gimple_push_cleanup (temp, cleanup, false, pre_p);
5432 /* Only expand this once. */
5433 TREE_OPERAND (targ, 3) = init;
5434 TARGET_EXPR_INITIAL (targ) = NULL_TREE;
5437 /* We should have expanded this before. */
5438 gcc_assert (DECL_SEEN_IN_BIND_EXPR_P (temp));
5444 /* Gimplification of expression trees. */
5446 /* Gimplify an expression which appears at statement context. The
5447 corresponding GIMPLE statements are added to *SEQ_P. If *SEQ_P is
5448 NULL, a new sequence is allocated.
5450 Return true if we actually added a statement to the queue. */
5453 gimplify_stmt (tree *stmt_p, gimple_seq *seq_p)
5455 gimple_seq_node last;
5458 *seq_p = gimple_seq_alloc ();
5460 last = gimple_seq_last (*seq_p);
5461 gimplify_expr (stmt_p, seq_p, NULL, is_gimple_stmt, fb_none);
5462 return last != gimple_seq_last (*seq_p);
5465 /* Add FIRSTPRIVATE entries for DECL in the OpenMP the surrounding parallels
5466 to CTX. If entries already exist, force them to be some flavor of private.
5467 If there is no enclosing parallel, do nothing. */
5470 omp_firstprivatize_variable (struct gimplify_omp_ctx *ctx, tree decl)
5474 if (decl == NULL || !DECL_P (decl))
5479 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
5482 if (n->value & GOVD_SHARED)
5483 n->value = GOVD_FIRSTPRIVATE | (n->value & GOVD_SEEN);
5487 else if (ctx->region_type != ORT_WORKSHARE)
5488 omp_add_variable (ctx, decl, GOVD_FIRSTPRIVATE);
5490 ctx = ctx->outer_context;
5495 /* Similarly for each of the type sizes of TYPE. */
5498 omp_firstprivatize_type_sizes (struct gimplify_omp_ctx *ctx, tree type)
5500 if (type == NULL || type == error_mark_node)
5502 type = TYPE_MAIN_VARIANT (type);
5504 if (pointer_set_insert (ctx->privatized_types, type))
5507 switch (TREE_CODE (type))
5513 case FIXED_POINT_TYPE:
5514 omp_firstprivatize_variable (ctx, TYPE_MIN_VALUE (type));
5515 omp_firstprivatize_variable (ctx, TYPE_MAX_VALUE (type));
5519 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (type));
5520 omp_firstprivatize_type_sizes (ctx, TYPE_DOMAIN (type));
5525 case QUAL_UNION_TYPE:
5528 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
5529 if (TREE_CODE (field) == FIELD_DECL)
5531 omp_firstprivatize_variable (ctx, DECL_FIELD_OFFSET (field));
5532 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (field));
5538 case REFERENCE_TYPE:
5539 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (type));
5546 omp_firstprivatize_variable (ctx, TYPE_SIZE (type));
5547 omp_firstprivatize_variable (ctx, TYPE_SIZE_UNIT (type));
5548 lang_hooks.types.omp_firstprivatize_type_sizes (ctx, type);
5551 /* Add an entry for DECL in the OpenMP context CTX with FLAGS. */
5554 omp_add_variable (struct gimplify_omp_ctx *ctx, tree decl, unsigned int flags)
5557 unsigned int nflags;
5560 if (error_operand_p (decl))
5563 /* Never elide decls whose type has TREE_ADDRESSABLE set. This means
5564 there are constructors involved somewhere. */
5565 if (TREE_ADDRESSABLE (TREE_TYPE (decl))
5566 || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
5569 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
5572 /* We shouldn't be re-adding the decl with the same data
5574 gcc_assert ((n->value & GOVD_DATA_SHARE_CLASS & flags) == 0);
5575 /* The only combination of data sharing classes we should see is
5576 FIRSTPRIVATE and LASTPRIVATE. */
5577 nflags = n->value | flags;
5578 gcc_assert ((nflags & GOVD_DATA_SHARE_CLASS)
5579 == (GOVD_FIRSTPRIVATE | GOVD_LASTPRIVATE));
5584 /* When adding a variable-sized variable, we have to handle all sorts
5585 of additional bits of data: the pointer replacement variable, and
5586 the parameters of the type. */
5587 if (DECL_SIZE (decl) && TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
5589 /* Add the pointer replacement variable as PRIVATE if the variable
5590 replacement is private, else FIRSTPRIVATE since we'll need the
5591 address of the original variable either for SHARED, or for the
5592 copy into or out of the context. */
5593 if (!(flags & GOVD_LOCAL))
5595 nflags = flags & GOVD_PRIVATE ? GOVD_PRIVATE : GOVD_FIRSTPRIVATE;
5596 nflags |= flags & GOVD_SEEN;
5597 t = DECL_VALUE_EXPR (decl);
5598 gcc_assert (TREE_CODE (t) == INDIRECT_REF);
5599 t = TREE_OPERAND (t, 0);
5600 gcc_assert (DECL_P (t));
5601 omp_add_variable (ctx, t, nflags);
5604 /* Add all of the variable and type parameters (which should have
5605 been gimplified to a formal temporary) as FIRSTPRIVATE. */
5606 omp_firstprivatize_variable (ctx, DECL_SIZE_UNIT (decl));
5607 omp_firstprivatize_variable (ctx, DECL_SIZE (decl));
5608 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (decl));
5610 /* The variable-sized variable itself is never SHARED, only some form
5611 of PRIVATE. The sharing would take place via the pointer variable
5612 which we remapped above. */
5613 if (flags & GOVD_SHARED)
5614 flags = GOVD_PRIVATE | GOVD_DEBUG_PRIVATE
5615 | (flags & (GOVD_SEEN | GOVD_EXPLICIT));
5617 /* We're going to make use of the TYPE_SIZE_UNIT at least in the
5618 alloca statement we generate for the variable, so make sure it
5619 is available. This isn't automatically needed for the SHARED
5620 case, since we won't be allocating local storage then.
5621 For local variables TYPE_SIZE_UNIT might not be gimplified yet,
5622 in this case omp_notice_variable will be called later
5623 on when it is gimplified. */
5624 else if (! (flags & GOVD_LOCAL)
5625 && DECL_P (TYPE_SIZE_UNIT (TREE_TYPE (decl))))
5626 omp_notice_variable (ctx, TYPE_SIZE_UNIT (TREE_TYPE (decl)), true);
5628 else if (lang_hooks.decls.omp_privatize_by_reference (decl))
5630 gcc_assert ((flags & GOVD_LOCAL) == 0);
5631 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (decl));
5633 /* Similar to the direct variable sized case above, we'll need the
5634 size of references being privatized. */
5635 if ((flags & GOVD_SHARED) == 0)
5637 t = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl)));
5638 if (TREE_CODE (t) != INTEGER_CST)
5639 omp_notice_variable (ctx, t, true);
5643 splay_tree_insert (ctx->variables, (splay_tree_key)decl, flags);
5646 /* Notice a threadprivate variable DECL used in OpenMP context CTX.
5647 This just prints out diagnostics about threadprivate variable uses
5648 in untied tasks. If DECL2 is non-NULL, prevent this warning
5649 on that variable. */
5652 omp_notice_threadprivate_variable (struct gimplify_omp_ctx *ctx, tree decl,
5657 if (ctx->region_type != ORT_UNTIED_TASK)
5659 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
5662 error ("threadprivate variable %qE used in untied task",
5664 error_at (ctx->location, "enclosing task");
5665 splay_tree_insert (ctx->variables, (splay_tree_key)decl, 0);
5668 splay_tree_insert (ctx->variables, (splay_tree_key)decl2, 0);
5672 /* Record the fact that DECL was used within the OpenMP context CTX.
5673 IN_CODE is true when real code uses DECL, and false when we should
5674 merely emit default(none) errors. Return true if DECL is going to
5675 be remapped and thus DECL shouldn't be gimplified into its
5676 DECL_VALUE_EXPR (if any). */
5679 omp_notice_variable (struct gimplify_omp_ctx *ctx, tree decl, bool in_code)
5682 unsigned flags = in_code ? GOVD_SEEN : 0;
5683 bool ret = false, shared;
5685 if (error_operand_p (decl))
5688 /* Threadprivate variables are predetermined. */
5689 if (is_global_var (decl))
5691 if (DECL_THREAD_LOCAL_P (decl))
5692 return omp_notice_threadprivate_variable (ctx, decl, NULL_TREE);
5694 if (DECL_HAS_VALUE_EXPR_P (decl))
5696 tree value = get_base_address (DECL_VALUE_EXPR (decl));
5698 if (value && DECL_P (value) && DECL_THREAD_LOCAL_P (value))
5699 return omp_notice_threadprivate_variable (ctx, decl, value);
5703 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
5706 enum omp_clause_default_kind default_kind, kind;
5707 struct gimplify_omp_ctx *octx;
5709 if (ctx->region_type == ORT_WORKSHARE)
5712 /* ??? Some compiler-generated variables (like SAVE_EXPRs) could be
5713 remapped firstprivate instead of shared. To some extent this is
5714 addressed in omp_firstprivatize_type_sizes, but not effectively. */
5715 default_kind = ctx->default_kind;
5716 kind = lang_hooks.decls.omp_predetermined_sharing (decl);
5717 if (kind != OMP_CLAUSE_DEFAULT_UNSPECIFIED)
5718 default_kind = kind;
5720 switch (default_kind)
5722 case OMP_CLAUSE_DEFAULT_NONE:
5723 error ("%qE not specified in enclosing parallel",
5724 DECL_NAME (lang_hooks.decls.omp_report_decl (decl)));
5725 if ((ctx->region_type & ORT_TASK) != 0)
5726 error_at (ctx->location, "enclosing task");
5728 error_at (ctx->location, "enclosing parallel");
5730 case OMP_CLAUSE_DEFAULT_SHARED:
5731 flags |= GOVD_SHARED;
5733 case OMP_CLAUSE_DEFAULT_PRIVATE:
5734 flags |= GOVD_PRIVATE;
5736 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE:
5737 flags |= GOVD_FIRSTPRIVATE;
5739 case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
5740 /* decl will be either GOVD_FIRSTPRIVATE or GOVD_SHARED. */
5741 gcc_assert ((ctx->region_type & ORT_TASK) != 0);
5742 if (ctx->outer_context)
5743 omp_notice_variable (ctx->outer_context, decl, in_code);
5744 for (octx = ctx->outer_context; octx; octx = octx->outer_context)
5748 n2 = splay_tree_lookup (octx->variables, (splay_tree_key) decl);
5749 if (n2 && (n2->value & GOVD_DATA_SHARE_CLASS) != GOVD_SHARED)
5751 flags |= GOVD_FIRSTPRIVATE;
5754 if ((octx->region_type & ORT_PARALLEL) != 0)
5757 if (flags & GOVD_FIRSTPRIVATE)
5760 && (TREE_CODE (decl) == PARM_DECL
5761 || (!is_global_var (decl)
5762 && DECL_CONTEXT (decl) == current_function_decl)))
5764 flags |= GOVD_FIRSTPRIVATE;
5767 flags |= GOVD_SHARED;
5773 if ((flags & GOVD_PRIVATE)
5774 && lang_hooks.decls.omp_private_outer_ref (decl))
5775 flags |= GOVD_PRIVATE_OUTER_REF;
5777 omp_add_variable (ctx, decl, flags);
5779 shared = (flags & GOVD_SHARED) != 0;
5780 ret = lang_hooks.decls.omp_disregard_value_expr (decl, shared);
5784 if ((n->value & (GOVD_SEEN | GOVD_LOCAL)) == 0
5785 && (flags & (GOVD_SEEN | GOVD_LOCAL)) == GOVD_SEEN
5787 && TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
5790 tree t = DECL_VALUE_EXPR (decl);
5791 gcc_assert (TREE_CODE (t) == INDIRECT_REF);
5792 t = TREE_OPERAND (t, 0);
5793 gcc_assert (DECL_P (t));
5794 n2 = splay_tree_lookup (ctx->variables, (splay_tree_key) t);
5795 n2->value |= GOVD_SEEN;
5798 shared = ((flags | n->value) & GOVD_SHARED) != 0;
5799 ret = lang_hooks.decls.omp_disregard_value_expr (decl, shared);
5801 /* If nothing changed, there's nothing left to do. */
5802 if ((n->value & flags) == flags)
5808 /* If the variable is private in the current context, then we don't
5809 need to propagate anything to an outer context. */
5810 if ((flags & GOVD_PRIVATE) && !(flags & GOVD_PRIVATE_OUTER_REF))
5812 if (ctx->outer_context
5813 && omp_notice_variable (ctx->outer_context, decl, in_code))
5818 /* Verify that DECL is private within CTX. If there's specific information
5819 to the contrary in the innermost scope, generate an error. */
5822 omp_is_private (struct gimplify_omp_ctx *ctx, tree decl)
5826 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
5829 if (n->value & GOVD_SHARED)
5831 if (ctx == gimplify_omp_ctxp)
5833 error ("iteration variable %qE should be private",
5835 n->value = GOVD_PRIVATE;
5841 else if ((n->value & GOVD_EXPLICIT) != 0
5842 && (ctx == gimplify_omp_ctxp
5843 || (ctx->region_type == ORT_COMBINED_PARALLEL
5844 && gimplify_omp_ctxp->outer_context == ctx)))
5846 if ((n->value & GOVD_FIRSTPRIVATE) != 0)
5847 error ("iteration variable %qE should not be firstprivate",
5849 else if ((n->value & GOVD_REDUCTION) != 0)
5850 error ("iteration variable %qE should not be reduction",
5853 return (ctx == gimplify_omp_ctxp
5854 || (ctx->region_type == ORT_COMBINED_PARALLEL
5855 && gimplify_omp_ctxp->outer_context == ctx));
5858 if (ctx->region_type != ORT_WORKSHARE)
5860 else if (ctx->outer_context)
5861 return omp_is_private (ctx->outer_context, decl);
5865 /* Return true if DECL is private within a parallel region
5866 that binds to the current construct's context or in parallel
5867 region's REDUCTION clause. */
5870 omp_check_private (struct gimplify_omp_ctx *ctx, tree decl)
5876 ctx = ctx->outer_context;
5878 return !(is_global_var (decl)
5879 /* References might be private, but might be shared too. */
5880 || lang_hooks.decls.omp_privatize_by_reference (decl));
5882 n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
5884 return (n->value & GOVD_SHARED) == 0;
5886 while (ctx->region_type == ORT_WORKSHARE);
5890 /* Scan the OpenMP clauses in *LIST_P, installing mappings into a new
5891 and previous omp contexts. */
5894 gimplify_scan_omp_clauses (tree *list_p, gimple_seq *pre_p,
5895 enum omp_region_type region_type)
5897 struct gimplify_omp_ctx *ctx, *outer_ctx;
5898 struct gimplify_ctx gctx;
5901 ctx = new_omp_context (region_type);
5902 outer_ctx = ctx->outer_context;
5904 while ((c = *list_p) != NULL)
5906 bool remove = false;
5907 bool notice_outer = true;
5908 const char *check_non_private = NULL;
5912 switch (OMP_CLAUSE_CODE (c))
5914 case OMP_CLAUSE_PRIVATE:
5915 flags = GOVD_PRIVATE | GOVD_EXPLICIT;
5916 if (lang_hooks.decls.omp_private_outer_ref (OMP_CLAUSE_DECL (c)))
5918 flags |= GOVD_PRIVATE_OUTER_REF;
5919 OMP_CLAUSE_PRIVATE_OUTER_REF (c) = 1;
5922 notice_outer = false;
5924 case OMP_CLAUSE_SHARED:
5925 flags = GOVD_SHARED | GOVD_EXPLICIT;
5927 case OMP_CLAUSE_FIRSTPRIVATE:
5928 flags = GOVD_FIRSTPRIVATE | GOVD_EXPLICIT;
5929 check_non_private = "firstprivate";
5931 case OMP_CLAUSE_LASTPRIVATE:
5932 flags = GOVD_LASTPRIVATE | GOVD_SEEN | GOVD_EXPLICIT;
5933 check_non_private = "lastprivate";
5935 case OMP_CLAUSE_REDUCTION:
5936 flags = GOVD_REDUCTION | GOVD_SEEN | GOVD_EXPLICIT;
5937 check_non_private = "reduction";
5941 decl = OMP_CLAUSE_DECL (c);
5942 if (error_operand_p (decl))
5947 omp_add_variable (ctx, decl, flags);
5948 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION
5949 && OMP_CLAUSE_REDUCTION_PLACEHOLDER (c))
5951 omp_add_variable (ctx, OMP_CLAUSE_REDUCTION_PLACEHOLDER (c),
5952 GOVD_LOCAL | GOVD_SEEN);
5953 gimplify_omp_ctxp = ctx;
5954 push_gimplify_context (&gctx);
5956 OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c) = gimple_seq_alloc ();
5957 OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c) = gimple_seq_alloc ();
5959 gimplify_and_add (OMP_CLAUSE_REDUCTION_INIT (c),
5960 &OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c));
5961 pop_gimplify_context
5962 (gimple_seq_first_stmt (OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c)));
5963 push_gimplify_context (&gctx);
5964 gimplify_and_add (OMP_CLAUSE_REDUCTION_MERGE (c),
5965 &OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c));
5966 pop_gimplify_context
5967 (gimple_seq_first_stmt (OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c)));
5968 OMP_CLAUSE_REDUCTION_INIT (c) = NULL_TREE;
5969 OMP_CLAUSE_REDUCTION_MERGE (c) = NULL_TREE;
5971 gimplify_omp_ctxp = outer_ctx;
5973 else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LASTPRIVATE
5974 && OMP_CLAUSE_LASTPRIVATE_STMT (c))
5976 gimplify_omp_ctxp = ctx;
5977 push_gimplify_context (&gctx);
5978 if (TREE_CODE (OMP_CLAUSE_LASTPRIVATE_STMT (c)) != BIND_EXPR)
5980 tree bind = build3 (BIND_EXPR, void_type_node, NULL,
5982 TREE_SIDE_EFFECTS (bind) = 1;
5983 BIND_EXPR_BODY (bind) = OMP_CLAUSE_LASTPRIVATE_STMT (c);
5984 OMP_CLAUSE_LASTPRIVATE_STMT (c) = bind;
5986 gimplify_and_add (OMP_CLAUSE_LASTPRIVATE_STMT (c),
5987 &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c));
5988 pop_gimplify_context
5989 (gimple_seq_first_stmt (OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c)));
5990 OMP_CLAUSE_LASTPRIVATE_STMT (c) = NULL_TREE;
5992 gimplify_omp_ctxp = outer_ctx;
5998 case OMP_CLAUSE_COPYIN:
5999 case OMP_CLAUSE_COPYPRIVATE:
6000 decl = OMP_CLAUSE_DECL (c);
6001 if (error_operand_p (decl))
6008 omp_notice_variable (outer_ctx, decl, true);
6009 if (check_non_private
6010 && region_type == ORT_WORKSHARE
6011 && omp_check_private (ctx, decl))
6013 error ("%s variable %qE is private in outer context",
6014 check_non_private, DECL_NAME (decl));
6019 case OMP_CLAUSE_FINAL:
6021 OMP_CLAUSE_OPERAND (c, 0)
6022 = gimple_boolify (OMP_CLAUSE_OPERAND (c, 0));
6025 case OMP_CLAUSE_SCHEDULE:
6026 case OMP_CLAUSE_NUM_THREADS:
6027 if (gimplify_expr (&OMP_CLAUSE_OPERAND (c, 0), pre_p, NULL,
6028 is_gimple_val, fb_rvalue) == GS_ERROR)
6032 case OMP_CLAUSE_NOWAIT:
6033 case OMP_CLAUSE_ORDERED:
6034 case OMP_CLAUSE_UNTIED:
6035 case OMP_CLAUSE_COLLAPSE:
6036 case OMP_CLAUSE_MERGEABLE:
6039 case OMP_CLAUSE_DEFAULT:
6040 ctx->default_kind = OMP_CLAUSE_DEFAULT_KIND (c);
6048 *list_p = OMP_CLAUSE_CHAIN (c);
6050 list_p = &OMP_CLAUSE_CHAIN (c);
6053 gimplify_omp_ctxp = ctx;
6056 /* For all variables that were not actually used within the context,
6057 remove PRIVATE, SHARED, and FIRSTPRIVATE clauses. */
6060 gimplify_adjust_omp_clauses_1 (splay_tree_node n, void *data)
6062 tree *list_p = (tree *) data;
6063 tree decl = (tree) n->key;
6064 unsigned flags = n->value;
6065 enum omp_clause_code code;
6069 if (flags & (GOVD_EXPLICIT | GOVD_LOCAL))
6071 if ((flags & GOVD_SEEN) == 0)
6073 if (flags & GOVD_DEBUG_PRIVATE)
6075 gcc_assert ((flags & GOVD_DATA_SHARE_CLASS) == GOVD_PRIVATE);
6076 private_debug = true;
6080 = lang_hooks.decls.omp_private_debug_clause (decl,
6081 !!(flags & GOVD_SHARED));
6083 code = OMP_CLAUSE_PRIVATE;
6084 else if (flags & GOVD_SHARED)
6086 if (is_global_var (decl))
6088 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp->outer_context;
6092 = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
6093 if (on && (on->value & (GOVD_FIRSTPRIVATE | GOVD_LASTPRIVATE
6094 | GOVD_PRIVATE | GOVD_REDUCTION)) != 0)
6096 ctx = ctx->outer_context;
6101 code = OMP_CLAUSE_SHARED;
6103 else if (flags & GOVD_PRIVATE)
6104 code = OMP_CLAUSE_PRIVATE;
6105 else if (flags & GOVD_FIRSTPRIVATE)
6106 code = OMP_CLAUSE_FIRSTPRIVATE;
6110 clause = build_omp_clause (input_location, code);
6111 OMP_CLAUSE_DECL (clause) = decl;
6112 OMP_CLAUSE_CHAIN (clause) = *list_p;
6114 OMP_CLAUSE_PRIVATE_DEBUG (clause) = 1;
6115 else if (code == OMP_CLAUSE_PRIVATE && (flags & GOVD_PRIVATE_OUTER_REF))
6116 OMP_CLAUSE_PRIVATE_OUTER_REF (clause) = 1;
6118 lang_hooks.decls.omp_finish_clause (clause);
6124 gimplify_adjust_omp_clauses (tree *list_p)
6126 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
6129 while ((c = *list_p) != NULL)
6132 bool remove = false;
6134 switch (OMP_CLAUSE_CODE (c))
6136 case OMP_CLAUSE_PRIVATE:
6137 case OMP_CLAUSE_SHARED:
6138 case OMP_CLAUSE_FIRSTPRIVATE:
6139 decl = OMP_CLAUSE_DECL (c);
6140 n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
6141 remove = !(n->value & GOVD_SEEN);
6144 bool shared = OMP_CLAUSE_CODE (c) == OMP_CLAUSE_SHARED;
6145 if ((n->value & GOVD_DEBUG_PRIVATE)
6146 || lang_hooks.decls.omp_private_debug_clause (decl, shared))
6148 gcc_assert ((n->value & GOVD_DEBUG_PRIVATE) == 0
6149 || ((n->value & GOVD_DATA_SHARE_CLASS)
6151 OMP_CLAUSE_SET_CODE (c, OMP_CLAUSE_PRIVATE);
6152 OMP_CLAUSE_PRIVATE_DEBUG (c) = 1;
6157 case OMP_CLAUSE_LASTPRIVATE:
6158 /* Make sure OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE is set to
6159 accurately reflect the presence of a FIRSTPRIVATE clause. */
6160 decl = OMP_CLAUSE_DECL (c);
6161 n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
6162 OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c)
6163 = (n->value & GOVD_FIRSTPRIVATE) != 0;
6166 case OMP_CLAUSE_REDUCTION:
6167 case OMP_CLAUSE_COPYIN:
6168 case OMP_CLAUSE_COPYPRIVATE:
6170 case OMP_CLAUSE_NUM_THREADS:
6171 case OMP_CLAUSE_SCHEDULE:
6172 case OMP_CLAUSE_NOWAIT:
6173 case OMP_CLAUSE_ORDERED:
6174 case OMP_CLAUSE_DEFAULT:
6175 case OMP_CLAUSE_UNTIED:
6176 case OMP_CLAUSE_COLLAPSE:
6177 case OMP_CLAUSE_FINAL:
6178 case OMP_CLAUSE_MERGEABLE:
6186 *list_p = OMP_CLAUSE_CHAIN (c);
6188 list_p = &OMP_CLAUSE_CHAIN (c);
6191 /* Add in any implicit data sharing. */
6192 splay_tree_foreach (ctx->variables, gimplify_adjust_omp_clauses_1, list_p);
6194 gimplify_omp_ctxp = ctx->outer_context;
6195 delete_omp_context (ctx);
6198 /* Gimplify the contents of an OMP_PARALLEL statement. This involves
6199 gimplification of the body, as well as scanning the body for used
6200 variables. We need to do this scan now, because variable-sized
6201 decls will be decomposed during gimplification. */
6204 gimplify_omp_parallel (tree *expr_p, gimple_seq *pre_p)
6206 tree expr = *expr_p;
6208 gimple_seq body = NULL;
6209 struct gimplify_ctx gctx;
6211 gimplify_scan_omp_clauses (&OMP_PARALLEL_CLAUSES (expr), pre_p,
6212 OMP_PARALLEL_COMBINED (expr)
6213 ? ORT_COMBINED_PARALLEL
6216 push_gimplify_context (&gctx);
6218 g = gimplify_and_return_first (OMP_PARALLEL_BODY (expr), &body);
6219 if (gimple_code (g) == GIMPLE_BIND)
6220 pop_gimplify_context (g);
6222 pop_gimplify_context (NULL);
6224 gimplify_adjust_omp_clauses (&OMP_PARALLEL_CLAUSES (expr));
6226 g = gimple_build_omp_parallel (body,
6227 OMP_PARALLEL_CLAUSES (expr),
6228 NULL_TREE, NULL_TREE);
6229 if (OMP_PARALLEL_COMBINED (expr))
6230 gimple_omp_set_subcode (g, GF_OMP_PARALLEL_COMBINED);
6231 gimplify_seq_add_stmt (pre_p, g);
6232 *expr_p = NULL_TREE;
6235 /* Gimplify the contents of an OMP_TASK statement. This involves
6236 gimplification of the body, as well as scanning the body for used
6237 variables. We need to do this scan now, because variable-sized
6238 decls will be decomposed during gimplification. */
6241 gimplify_omp_task (tree *expr_p, gimple_seq *pre_p)
6243 tree expr = *expr_p;
6245 gimple_seq body = NULL;
6246 struct gimplify_ctx gctx;
6248 gimplify_scan_omp_clauses (&OMP_TASK_CLAUSES (expr), pre_p,
6249 find_omp_clause (OMP_TASK_CLAUSES (expr),
6251 ? ORT_UNTIED_TASK : ORT_TASK);
6253 push_gimplify_context (&gctx);
6255 g = gimplify_and_return_first (OMP_TASK_BODY (expr), &body);
6256 if (gimple_code (g) == GIMPLE_BIND)
6257 pop_gimplify_context (g);
6259 pop_gimplify_context (NULL);
6261 gimplify_adjust_omp_clauses (&OMP_TASK_CLAUSES (expr));
6263 g = gimple_build_omp_task (body,
6264 OMP_TASK_CLAUSES (expr),
6265 NULL_TREE, NULL_TREE,
6266 NULL_TREE, NULL_TREE, NULL_TREE);
6267 gimplify_seq_add_stmt (pre_p, g);
6268 *expr_p = NULL_TREE;
6271 /* Gimplify the gross structure of an OMP_FOR statement. */
6273 static enum gimplify_status
6274 gimplify_omp_for (tree *expr_p, gimple_seq *pre_p)
6276 tree for_stmt, decl, var, t;
6277 enum gimplify_status ret = GS_ALL_DONE;
6278 enum gimplify_status tret;
6280 gimple_seq for_body, for_pre_body;
6285 gimplify_scan_omp_clauses (&OMP_FOR_CLAUSES (for_stmt), pre_p,
6288 /* Handle OMP_FOR_INIT. */
6289 for_pre_body = NULL;
6290 gimplify_and_add (OMP_FOR_PRE_BODY (for_stmt), &for_pre_body);
6291 OMP_FOR_PRE_BODY (for_stmt) = NULL_TREE;
6293 for_body = gimple_seq_alloc ();
6294 gcc_assert (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt))
6295 == TREE_VEC_LENGTH (OMP_FOR_COND (for_stmt)));
6296 gcc_assert (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt))
6297 == TREE_VEC_LENGTH (OMP_FOR_INCR (for_stmt)));
6298 for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)); i++)
6300 t = TREE_VEC_ELT (OMP_FOR_INIT (for_stmt), i);
6301 gcc_assert (TREE_CODE (t) == MODIFY_EXPR);
6302 decl = TREE_OPERAND (t, 0);
6303 gcc_assert (DECL_P (decl));
6304 gcc_assert (INTEGRAL_TYPE_P (TREE_TYPE (decl))
6305 || POINTER_TYPE_P (TREE_TYPE (decl)));
6307 /* Make sure the iteration variable is private. */
6308 if (omp_is_private (gimplify_omp_ctxp, decl))
6309 omp_notice_variable (gimplify_omp_ctxp, decl, true);
6311 omp_add_variable (gimplify_omp_ctxp, decl, GOVD_PRIVATE | GOVD_SEEN);
6313 /* If DECL is not a gimple register, create a temporary variable to act
6314 as an iteration counter. This is valid, since DECL cannot be
6315 modified in the body of the loop. */
6316 if (!is_gimple_reg (decl))
6318 var = create_tmp_var (TREE_TYPE (decl), get_name (decl));
6319 TREE_OPERAND (t, 0) = var;
6321 gimplify_seq_add_stmt (&for_body, gimple_build_assign (decl, var));
6323 omp_add_variable (gimplify_omp_ctxp, var, GOVD_PRIVATE | GOVD_SEEN);
6328 tret = gimplify_expr (&TREE_OPERAND (t, 1), &for_pre_body, NULL,
6329 is_gimple_val, fb_rvalue);
6330 ret = MIN (ret, tret);
6331 if (ret == GS_ERROR)
6334 /* Handle OMP_FOR_COND. */
6335 t = TREE_VEC_ELT (OMP_FOR_COND (for_stmt), i);
6336 gcc_assert (COMPARISON_CLASS_P (t));
6337 gcc_assert (TREE_OPERAND (t, 0) == decl);
6339 tret = gimplify_expr (&TREE_OPERAND (t, 1), &for_pre_body, NULL,
6340 is_gimple_val, fb_rvalue);
6341 ret = MIN (ret, tret);
6343 /* Handle OMP_FOR_INCR. */
6344 t = TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i);
6345 switch (TREE_CODE (t))
6347 case PREINCREMENT_EXPR:
6348 case POSTINCREMENT_EXPR:
6349 t = build_int_cst (TREE_TYPE (decl), 1);
6350 t = build2 (PLUS_EXPR, TREE_TYPE (decl), var, t);
6351 t = build2 (MODIFY_EXPR, TREE_TYPE (var), var, t);
6352 TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i) = t;
6355 case PREDECREMENT_EXPR:
6356 case POSTDECREMENT_EXPR:
6357 t = build_int_cst (TREE_TYPE (decl), -1);
6358 t = build2 (PLUS_EXPR, TREE_TYPE (decl), var, t);
6359 t = build2 (MODIFY_EXPR, TREE_TYPE (var), var, t);
6360 TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i) = t;
6364 gcc_assert (TREE_OPERAND (t, 0) == decl);
6365 TREE_OPERAND (t, 0) = var;
6367 t = TREE_OPERAND (t, 1);
6368 switch (TREE_CODE (t))
6371 if (TREE_OPERAND (t, 1) == decl)
6373 TREE_OPERAND (t, 1) = TREE_OPERAND (t, 0);
6374 TREE_OPERAND (t, 0) = var;
6380 case POINTER_PLUS_EXPR:
6381 gcc_assert (TREE_OPERAND (t, 0) == decl);
6382 TREE_OPERAND (t, 0) = var;
6388 tret = gimplify_expr (&TREE_OPERAND (t, 1), &for_pre_body, NULL,
6389 is_gimple_val, fb_rvalue);
6390 ret = MIN (ret, tret);
6397 if (var != decl || TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)) > 1)
6400 for (c = OMP_FOR_CLAUSES (for_stmt); c ; c = OMP_CLAUSE_CHAIN (c))
6401 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LASTPRIVATE
6402 && OMP_CLAUSE_DECL (c) == decl
6403 && OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c) == NULL)
6405 t = TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i);
6406 gcc_assert (TREE_CODE (t) == MODIFY_EXPR);
6407 gcc_assert (TREE_OPERAND (t, 0) == var);
6408 t = TREE_OPERAND (t, 1);
6409 gcc_assert (TREE_CODE (t) == PLUS_EXPR
6410 || TREE_CODE (t) == MINUS_EXPR
6411 || TREE_CODE (t) == POINTER_PLUS_EXPR);
6412 gcc_assert (TREE_OPERAND (t, 0) == var);
6413 t = build2 (TREE_CODE (t), TREE_TYPE (decl), decl,
6414 TREE_OPERAND (t, 1));
6415 gimplify_assign (decl, t,
6416 &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c));
6421 gimplify_and_add (OMP_FOR_BODY (for_stmt), &for_body);
6423 gimplify_adjust_omp_clauses (&OMP_FOR_CLAUSES (for_stmt));
6425 gfor = gimple_build_omp_for (for_body, OMP_FOR_CLAUSES (for_stmt),
6426 TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)),
6429 for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)); i++)
6431 t = TREE_VEC_ELT (OMP_FOR_INIT (for_stmt), i);
6432 gimple_omp_for_set_index (gfor, i, TREE_OPERAND (t, 0));
6433 gimple_omp_for_set_initial (gfor, i, TREE_OPERAND (t, 1));
6434 t = TREE_VEC_ELT (OMP_FOR_COND (for_stmt), i);
6435 gimple_omp_for_set_cond (gfor, i, TREE_CODE (t));
6436 gimple_omp_for_set_final (gfor, i, TREE_OPERAND (t, 1));
6437 t = TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i);
6438 gimple_omp_for_set_incr (gfor, i, TREE_OPERAND (t, 1));
6441 gimplify_seq_add_stmt (pre_p, gfor);
6442 return ret == GS_ALL_DONE ? GS_ALL_DONE : GS_ERROR;
6445 /* Gimplify the gross structure of other OpenMP worksharing constructs.
6446 In particular, OMP_SECTIONS and OMP_SINGLE. */
6449 gimplify_omp_workshare (tree *expr_p, gimple_seq *pre_p)
6451 tree expr = *expr_p;
6453 gimple_seq body = NULL;
6455 gimplify_scan_omp_clauses (&OMP_CLAUSES (expr), pre_p, ORT_WORKSHARE);
6456 gimplify_and_add (OMP_BODY (expr), &body);
6457 gimplify_adjust_omp_clauses (&OMP_CLAUSES (expr));
6459 if (TREE_CODE (expr) == OMP_SECTIONS)
6460 stmt = gimple_build_omp_sections (body, OMP_CLAUSES (expr));
6461 else if (TREE_CODE (expr) == OMP_SINGLE)
6462 stmt = gimple_build_omp_single (body, OMP_CLAUSES (expr));
6466 gimplify_seq_add_stmt (pre_p, stmt);
6469 /* A subroutine of gimplify_omp_atomic. The front end is supposed to have
6470 stabilized the lhs of the atomic operation as *ADDR. Return true if
6471 EXPR is this stabilized form. */
6474 goa_lhs_expr_p (tree expr, tree addr)
6476 /* Also include casts to other type variants. The C front end is fond
6477 of adding these for e.g. volatile variables. This is like
6478 STRIP_TYPE_NOPS but includes the main variant lookup. */
6479 STRIP_USELESS_TYPE_CONVERSION (expr);
6481 if (TREE_CODE (expr) == INDIRECT_REF)
6483 expr = TREE_OPERAND (expr, 0);
6485 && (CONVERT_EXPR_P (expr)
6486 || TREE_CODE (expr) == NON_LVALUE_EXPR)
6487 && TREE_CODE (expr) == TREE_CODE (addr)
6488 && types_compatible_p (TREE_TYPE (expr), TREE_TYPE (addr)))
6490 expr = TREE_OPERAND (expr, 0);
6491 addr = TREE_OPERAND (addr, 0);
6495 return (TREE_CODE (addr) == ADDR_EXPR
6496 && TREE_CODE (expr) == ADDR_EXPR
6497 && TREE_OPERAND (addr, 0) == TREE_OPERAND (expr, 0));
6499 if (TREE_CODE (addr) == ADDR_EXPR && expr == TREE_OPERAND (addr, 0))
6504 /* Walk *EXPR_P and replace appearances of *LHS_ADDR with LHS_VAR. If an
6505 expression does not involve the lhs, evaluate it into a temporary.
6506 Return 1 if the lhs appeared as a subexpression, 0 if it did not,
6507 or -1 if an error was encountered. */
6510 goa_stabilize_expr (tree *expr_p, gimple_seq *pre_p, tree lhs_addr,
6513 tree expr = *expr_p;
6516 if (goa_lhs_expr_p (expr, lhs_addr))
6521 if (is_gimple_val (expr))
6525 switch (TREE_CODE_CLASS (TREE_CODE (expr)))
6528 case tcc_comparison:
6529 saw_lhs |= goa_stabilize_expr (&TREE_OPERAND (expr, 1), pre_p, lhs_addr,
6532 saw_lhs |= goa_stabilize_expr (&TREE_OPERAND (expr, 0), pre_p, lhs_addr,
6535 case tcc_expression:
6536 switch (TREE_CODE (expr))
6538 case TRUTH_ANDIF_EXPR:
6539 case TRUTH_ORIF_EXPR:
6540 case TRUTH_AND_EXPR:
6542 case TRUTH_XOR_EXPR:
6543 saw_lhs |= goa_stabilize_expr (&TREE_OPERAND (expr, 1), pre_p,
6545 case TRUTH_NOT_EXPR:
6546 saw_lhs |= goa_stabilize_expr (&TREE_OPERAND (expr, 0), pre_p,
6550 /* Break out any preevaluations from cp_build_modify_expr. */
6551 for (; TREE_CODE (expr) == COMPOUND_EXPR;
6552 expr = TREE_OPERAND (expr, 1))
6553 gimplify_stmt (&TREE_OPERAND (expr, 0), pre_p);
6555 return goa_stabilize_expr (expr_p, pre_p, lhs_addr, lhs_var);
6566 enum gimplify_status gs;
6567 gs = gimplify_expr (expr_p, pre_p, NULL, is_gimple_val, fb_rvalue);
6568 if (gs != GS_ALL_DONE)
6575 /* Gimplify an OMP_ATOMIC statement. */
6577 static enum gimplify_status
6578 gimplify_omp_atomic (tree *expr_p, gimple_seq *pre_p)
6580 tree addr = TREE_OPERAND (*expr_p, 0);
6581 tree rhs = TREE_CODE (*expr_p) == OMP_ATOMIC_READ
6582 ? NULL : TREE_OPERAND (*expr_p, 1);
6583 tree type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (addr)));
6585 gimple loadstmt, storestmt;
6587 tmp_load = create_tmp_reg (type, NULL);
6588 if (rhs && goa_stabilize_expr (&rhs, pre_p, addr, tmp_load) < 0)
6591 if (gimplify_expr (&addr, pre_p, NULL, is_gimple_val, fb_rvalue)
6595 loadstmt = gimple_build_omp_atomic_load (tmp_load, addr);
6596 gimplify_seq_add_stmt (pre_p, loadstmt);
6597 if (rhs && gimplify_expr (&rhs, pre_p, NULL, is_gimple_val, fb_rvalue)
6601 if (TREE_CODE (*expr_p) == OMP_ATOMIC_READ)
6603 storestmt = gimple_build_omp_atomic_store (rhs);
6604 gimplify_seq_add_stmt (pre_p, storestmt);
6605 switch (TREE_CODE (*expr_p))
6607 case OMP_ATOMIC_READ:
6608 case OMP_ATOMIC_CAPTURE_OLD:
6610 gimple_omp_atomic_set_need_value (loadstmt);
6612 case OMP_ATOMIC_CAPTURE_NEW:
6614 gimple_omp_atomic_set_need_value (storestmt);
6624 /* Gimplify a TRANSACTION_EXPR. This involves gimplification of the
6625 body, and adding some EH bits. */
6627 static enum gimplify_status
6628 gimplify_transaction (tree *expr_p, gimple_seq *pre_p)
6630 tree expr = *expr_p, temp, tbody = TRANSACTION_EXPR_BODY (expr);
6632 gimple_seq body = NULL;
6633 struct gimplify_ctx gctx;
6636 /* Wrap the transaction body in a BIND_EXPR so we have a context
6637 where to put decls for OpenMP. */
6638 if (TREE_CODE (tbody) != BIND_EXPR)
6640 tree bind = build3 (BIND_EXPR, void_type_node, NULL, tbody, NULL);
6641 TREE_SIDE_EFFECTS (bind) = 1;
6642 SET_EXPR_LOCATION (bind, EXPR_LOCATION (tbody));
6643 TRANSACTION_EXPR_BODY (expr) = bind;
6646 push_gimplify_context (&gctx);
6647 temp = voidify_wrapper_expr (*expr_p, NULL);
6649 g = gimplify_and_return_first (TRANSACTION_EXPR_BODY (expr), &body);
6650 pop_gimplify_context (g);
6652 g = gimple_build_transaction (body, NULL);
6653 if (TRANSACTION_EXPR_OUTER (expr))
6654 subcode = GTMA_IS_OUTER;
6655 else if (TRANSACTION_EXPR_RELAXED (expr))
6656 subcode = GTMA_IS_RELAXED;
6657 gimple_transaction_set_subcode (g, subcode);
6659 gimplify_seq_add_stmt (pre_p, g);
6667 *expr_p = NULL_TREE;
6671 /* Convert the GENERIC expression tree *EXPR_P to GIMPLE. If the
6672 expression produces a value to be used as an operand inside a GIMPLE
6673 statement, the value will be stored back in *EXPR_P. This value will
6674 be a tree of class tcc_declaration, tcc_constant, tcc_reference or
6675 an SSA_NAME. The corresponding sequence of GIMPLE statements is
6676 emitted in PRE_P and POST_P.
6678 Additionally, this process may overwrite parts of the input
6679 expression during gimplification. Ideally, it should be
6680 possible to do non-destructive gimplification.
6682 EXPR_P points to the GENERIC expression to convert to GIMPLE. If
6683 the expression needs to evaluate to a value to be used as
6684 an operand in a GIMPLE statement, this value will be stored in
6685 *EXPR_P on exit. This happens when the caller specifies one
6686 of fb_lvalue or fb_rvalue fallback flags.
6688 PRE_P will contain the sequence of GIMPLE statements corresponding
6689 to the evaluation of EXPR and all the side-effects that must
6690 be executed before the main expression. On exit, the last
6691 statement of PRE_P is the core statement being gimplified. For
6692 instance, when gimplifying 'if (++a)' the last statement in
6693 PRE_P will be 'if (t.1)' where t.1 is the result of
6694 pre-incrementing 'a'.
6696 POST_P will contain the sequence of GIMPLE statements corresponding
6697 to the evaluation of all the side-effects that must be executed
6698 after the main expression. If this is NULL, the post
6699 side-effects are stored at the end of PRE_P.
6701 The reason why the output is split in two is to handle post
6702 side-effects explicitly. In some cases, an expression may have
6703 inner and outer post side-effects which need to be emitted in
6704 an order different from the one given by the recursive
6705 traversal. For instance, for the expression (*p--)++ the post
6706 side-effects of '--' must actually occur *after* the post
6707 side-effects of '++'. However, gimplification will first visit
6708 the inner expression, so if a separate POST sequence was not
6709 used, the resulting sequence would be:
6716 However, the post-decrement operation in line #2 must not be
6717 evaluated until after the store to *p at line #4, so the
6718 correct sequence should be:
6725 So, by specifying a separate post queue, it is possible
6726 to emit the post side-effects in the correct order.
6727 If POST_P is NULL, an internal queue will be used. Before
6728 returning to the caller, the sequence POST_P is appended to
6729 the main output sequence PRE_P.
6731 GIMPLE_TEST_F points to a function that takes a tree T and
6732 returns nonzero if T is in the GIMPLE form requested by the
6733 caller. The GIMPLE predicates are in gimple.c.
6735 FALLBACK tells the function what sort of a temporary we want if
6736 gimplification cannot produce an expression that complies with
6739 fb_none means that no temporary should be generated
6740 fb_rvalue means that an rvalue is OK to generate
6741 fb_lvalue means that an lvalue is OK to generate
6742 fb_either means that either is OK, but an lvalue is preferable.
6743 fb_mayfail means that gimplification may fail (in which case
6744 GS_ERROR will be returned)
6746 The return value is either GS_ERROR or GS_ALL_DONE, since this
6747 function iterates until EXPR is completely gimplified or an error
6750 enum gimplify_status
6751 gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
6752 bool (*gimple_test_f) (tree), fallback_t fallback)
6755 gimple_seq internal_pre = NULL;
6756 gimple_seq internal_post = NULL;
6759 location_t saved_location;
6760 enum gimplify_status ret;
6761 gimple_stmt_iterator pre_last_gsi, post_last_gsi;
6763 save_expr = *expr_p;
6764 if (save_expr == NULL_TREE)
6767 /* If we are gimplifying a top-level statement, PRE_P must be valid. */
6768 is_statement = gimple_test_f == is_gimple_stmt;
6772 /* Consistency checks. */
6773 if (gimple_test_f == is_gimple_reg)
6774 gcc_assert (fallback & (fb_rvalue | fb_lvalue));
6775 else if (gimple_test_f == is_gimple_val
6776 || gimple_test_f == is_gimple_call_addr
6777 || gimple_test_f == is_gimple_condexpr
6778 || gimple_test_f == is_gimple_mem_rhs
6779 || gimple_test_f == is_gimple_mem_rhs_or_call
6780 || gimple_test_f == is_gimple_reg_rhs
6781 || gimple_test_f == is_gimple_reg_rhs_or_call
6782 || gimple_test_f == is_gimple_asm_val
6783 || gimple_test_f == is_gimple_mem_ref_addr)
6784 gcc_assert (fallback & fb_rvalue);
6785 else if (gimple_test_f == is_gimple_min_lval
6786 || gimple_test_f == is_gimple_lvalue)
6787 gcc_assert (fallback & fb_lvalue);
6788 else if (gimple_test_f == is_gimple_addressable)
6789 gcc_assert (fallback & fb_either);
6790 else if (gimple_test_f == is_gimple_stmt)
6791 gcc_assert (fallback == fb_none);
6794 /* We should have recognized the GIMPLE_TEST_F predicate to
6795 know what kind of fallback to use in case a temporary is
6796 needed to hold the value or address of *EXPR_P. */
6800 /* We used to check the predicate here and return immediately if it
6801 succeeds. This is wrong; the design is for gimplification to be
6802 idempotent, and for the predicates to only test for valid forms, not
6803 whether they are fully simplified. */
6805 pre_p = &internal_pre;
6808 post_p = &internal_post;
6810 /* Remember the last statements added to PRE_P and POST_P. Every
6811 new statement added by the gimplification helpers needs to be
6812 annotated with location information. To centralize the
6813 responsibility, we remember the last statement that had been
6814 added to both queues before gimplifying *EXPR_P. If
6815 gimplification produces new statements in PRE_P and POST_P, those
6816 statements will be annotated with the same location information
6818 pre_last_gsi = gsi_last (*pre_p);
6819 post_last_gsi = gsi_last (*post_p);
6821 saved_location = input_location;
6822 if (save_expr != error_mark_node
6823 && EXPR_HAS_LOCATION (*expr_p))
6824 input_location = EXPR_LOCATION (*expr_p);
6826 /* Loop over the specific gimplifiers until the toplevel node
6827 remains the same. */
6830 /* Strip away as many useless type conversions as possible
6832 STRIP_USELESS_TYPE_CONVERSION (*expr_p);
6834 /* Remember the expr. */
6835 save_expr = *expr_p;
6837 /* Die, die, die, my darling. */
6838 if (save_expr == error_mark_node
6839 || (TREE_TYPE (save_expr)
6840 && TREE_TYPE (save_expr) == error_mark_node))
6846 /* Do any language-specific gimplification. */
6847 ret = ((enum gimplify_status)
6848 lang_hooks.gimplify_expr (expr_p, pre_p, post_p));
6851 if (*expr_p == NULL_TREE)
6853 if (*expr_p != save_expr)
6856 else if (ret != GS_UNHANDLED)
6859 /* Make sure that all the cases set 'ret' appropriately. */
6861 switch (TREE_CODE (*expr_p))
6863 /* First deal with the special cases. */
6865 case POSTINCREMENT_EXPR:
6866 case POSTDECREMENT_EXPR:
6867 case PREINCREMENT_EXPR:
6868 case PREDECREMENT_EXPR:
6869 ret = gimplify_self_mod_expr (expr_p, pre_p, post_p,
6870 fallback != fb_none);
6874 case ARRAY_RANGE_REF:
6878 case VIEW_CONVERT_EXPR:
6879 ret = gimplify_compound_lval (expr_p, pre_p, post_p,
6880 fallback ? fallback : fb_rvalue);
6884 ret = gimplify_cond_expr (expr_p, pre_p, fallback);
6886 /* C99 code may assign to an array in a structure value of a
6887 conditional expression, and this has undefined behavior
6888 only on execution, so create a temporary if an lvalue is
6890 if (fallback == fb_lvalue)
6892 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
6893 mark_addressable (*expr_p);
6899 ret = gimplify_call_expr (expr_p, pre_p, fallback != fb_none);
6901 /* C99 code may assign to an array in a structure returned
6902 from a function, and this has undefined behavior only on
6903 execution, so create a temporary if an lvalue is
6905 if (fallback == fb_lvalue)
6907 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
6908 mark_addressable (*expr_p);
6917 ret = gimplify_compound_expr (expr_p, pre_p, fallback != fb_none);
6920 case COMPOUND_LITERAL_EXPR:
6921 ret = gimplify_compound_literal_expr (expr_p, pre_p);
6926 ret = gimplify_modify_expr (expr_p, pre_p, post_p,
6927 fallback != fb_none);
6930 case TRUTH_ANDIF_EXPR:
6931 case TRUTH_ORIF_EXPR:
6933 /* Preserve the original type of the expression and the
6934 source location of the outer expression. */
6935 tree org_type = TREE_TYPE (*expr_p);
6936 *expr_p = gimple_boolify (*expr_p);
6937 *expr_p = build3_loc (input_location, COND_EXPR,
6941 org_type, boolean_true_node),
6944 org_type, boolean_false_node));
6949 case TRUTH_NOT_EXPR:
6951 tree type = TREE_TYPE (*expr_p);
6952 /* The parsers are careful to generate TRUTH_NOT_EXPR
6953 only with operands that are always zero or one.
6954 We do not fold here but handle the only interesting case
6955 manually, as fold may re-introduce the TRUTH_NOT_EXPR. */
6956 *expr_p = gimple_boolify (*expr_p);
6957 if (TYPE_PRECISION (TREE_TYPE (*expr_p)) == 1)
6958 *expr_p = build1_loc (input_location, BIT_NOT_EXPR,
6959 TREE_TYPE (*expr_p),
6960 TREE_OPERAND (*expr_p, 0));
6962 *expr_p = build2_loc (input_location, BIT_XOR_EXPR,
6963 TREE_TYPE (*expr_p),
6964 TREE_OPERAND (*expr_p, 0),
6965 build_int_cst (TREE_TYPE (*expr_p), 1));
6966 if (!useless_type_conversion_p (type, TREE_TYPE (*expr_p)))
6967 *expr_p = fold_convert_loc (input_location, type, *expr_p);
6973 ret = gimplify_addr_expr (expr_p, pre_p, post_p);
6977 ret = gimplify_va_arg_expr (expr_p, pre_p, post_p);
6981 if (IS_EMPTY_STMT (*expr_p))
6987 if (VOID_TYPE_P (TREE_TYPE (*expr_p))
6988 || fallback == fb_none)
6990 /* Just strip a conversion to void (or in void context) and
6992 *expr_p = TREE_OPERAND (*expr_p, 0);
6997 ret = gimplify_conversion (expr_p);
6998 if (ret == GS_ERROR)
7000 if (*expr_p != save_expr)
7004 case FIX_TRUNC_EXPR:
7005 /* unary_expr: ... | '(' cast ')' val | ... */
7006 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
7007 is_gimple_val, fb_rvalue);
7008 recalculate_side_effects (*expr_p);
7013 bool volatilep = TREE_THIS_VOLATILE (*expr_p);
7014 bool notrap = TREE_THIS_NOTRAP (*expr_p);
7015 tree saved_ptr_type = TREE_TYPE (TREE_OPERAND (*expr_p, 0));
7017 *expr_p = fold_indirect_ref_loc (input_location, *expr_p);
7018 if (*expr_p != save_expr)
7024 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
7025 is_gimple_reg, fb_rvalue);
7026 if (ret == GS_ERROR)
7029 recalculate_side_effects (*expr_p);
7030 *expr_p = fold_build2_loc (input_location, MEM_REF,
7031 TREE_TYPE (*expr_p),
7032 TREE_OPERAND (*expr_p, 0),
7033 build_int_cst (saved_ptr_type, 0));
7034 TREE_THIS_VOLATILE (*expr_p) = volatilep;
7035 TREE_THIS_NOTRAP (*expr_p) = notrap;
7040 /* We arrive here through the various re-gimplifcation paths. */
7042 /* First try re-folding the whole thing. */
7043 tmp = fold_binary (MEM_REF, TREE_TYPE (*expr_p),
7044 TREE_OPERAND (*expr_p, 0),
7045 TREE_OPERAND (*expr_p, 1));
7049 recalculate_side_effects (*expr_p);
7053 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
7054 is_gimple_mem_ref_addr, fb_rvalue);
7055 if (ret == GS_ERROR)
7057 recalculate_side_effects (*expr_p);
7061 /* Constants need not be gimplified. */
7072 /* If we require an lvalue, such as for ADDR_EXPR, retain the
7073 CONST_DECL node. Otherwise the decl is replaceable by its
7075 /* ??? Should be == fb_lvalue, but ADDR_EXPR passes fb_either. */
7076 if (fallback & fb_lvalue)
7080 *expr_p = DECL_INITIAL (*expr_p);
7086 ret = gimplify_decl_expr (expr_p, pre_p);
7090 ret = gimplify_bind_expr (expr_p, pre_p);
7094 ret = gimplify_loop_expr (expr_p, pre_p);
7098 ret = gimplify_switch_expr (expr_p, pre_p);
7102 ret = gimplify_exit_expr (expr_p);
7106 /* If the target is not LABEL, then it is a computed jump
7107 and the target needs to be gimplified. */
7108 if (TREE_CODE (GOTO_DESTINATION (*expr_p)) != LABEL_DECL)
7110 ret = gimplify_expr (&GOTO_DESTINATION (*expr_p), pre_p,
7111 NULL, is_gimple_val, fb_rvalue);
7112 if (ret == GS_ERROR)
7115 gimplify_seq_add_stmt (pre_p,
7116 gimple_build_goto (GOTO_DESTINATION (*expr_p)));
7121 gimplify_seq_add_stmt (pre_p,
7122 gimple_build_predict (PREDICT_EXPR_PREDICTOR (*expr_p),
7123 PREDICT_EXPR_OUTCOME (*expr_p)));
7129 gcc_assert (decl_function_context (LABEL_EXPR_LABEL (*expr_p))
7130 == current_function_decl);
7131 gimplify_seq_add_stmt (pre_p,
7132 gimple_build_label (LABEL_EXPR_LABEL (*expr_p)));
7135 case CASE_LABEL_EXPR:
7136 ret = gimplify_case_label_expr (expr_p, pre_p);
7140 ret = gimplify_return_expr (*expr_p, pre_p);
7144 /* Don't reduce this in place; let gimplify_init_constructor work its
7145 magic. Buf if we're just elaborating this for side effects, just
7146 gimplify any element that has side-effects. */
7147 if (fallback == fb_none)
7149 unsigned HOST_WIDE_INT ix;
7151 tree temp = NULL_TREE;
7152 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (*expr_p), ix, val)
7153 if (TREE_SIDE_EFFECTS (val))
7154 append_to_statement_list (val, &temp);
7157 ret = temp ? GS_OK : GS_ALL_DONE;
7159 /* C99 code may assign to an array in a constructed
7160 structure or union, and this has undefined behavior only
7161 on execution, so create a temporary if an lvalue is
7163 else if (fallback == fb_lvalue)
7165 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
7166 mark_addressable (*expr_p);
7173 /* The following are special cases that are not handled by the
7174 original GIMPLE grammar. */
7176 /* SAVE_EXPR nodes are converted into a GIMPLE identifier and
7179 ret = gimplify_save_expr (expr_p, pre_p, post_p);
7184 enum gimplify_status r0, r1, r2;
7186 r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
7187 post_p, is_gimple_lvalue, fb_either);
7188 r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p,
7189 post_p, is_gimple_val, fb_rvalue);
7190 r2 = gimplify_expr (&TREE_OPERAND (*expr_p, 2), pre_p,
7191 post_p, is_gimple_val, fb_rvalue);
7192 recalculate_side_effects (*expr_p);
7194 ret = MIN (r0, MIN (r1, r2));
7198 case TARGET_MEM_REF:
7200 enum gimplify_status r0 = GS_ALL_DONE, r1 = GS_ALL_DONE;
7202 if (TMR_BASE (*expr_p))
7203 r0 = gimplify_expr (&TMR_BASE (*expr_p), pre_p,
7204 post_p, is_gimple_mem_ref_addr, fb_either);
7205 if (TMR_INDEX (*expr_p))
7206 r1 = gimplify_expr (&TMR_INDEX (*expr_p), pre_p,
7207 post_p, is_gimple_val, fb_rvalue);
7208 if (TMR_INDEX2 (*expr_p))
7209 r1 = gimplify_expr (&TMR_INDEX2 (*expr_p), pre_p,
7210 post_p, is_gimple_val, fb_rvalue);
7211 /* TMR_STEP and TMR_OFFSET are always integer constants. */
7216 case NON_LVALUE_EXPR:
7217 /* This should have been stripped above. */
7221 ret = gimplify_asm_expr (expr_p, pre_p, post_p);
7224 case TRY_FINALLY_EXPR:
7225 case TRY_CATCH_EXPR:
7227 gimple_seq eval, cleanup;
7230 eval = cleanup = NULL;
7231 gimplify_and_add (TREE_OPERAND (*expr_p, 0), &eval);
7232 gimplify_and_add (TREE_OPERAND (*expr_p, 1), &cleanup);
7233 /* Don't create bogus GIMPLE_TRY with empty cleanup. */
7234 if (gimple_seq_empty_p (cleanup))
7236 gimple_seq_add_seq (pre_p, eval);
7240 try_ = gimple_build_try (eval, cleanup,
7241 TREE_CODE (*expr_p) == TRY_FINALLY_EXPR
7242 ? GIMPLE_TRY_FINALLY
7243 : GIMPLE_TRY_CATCH);
7244 if (TREE_CODE (*expr_p) == TRY_CATCH_EXPR)
7245 gimple_try_set_catch_is_cleanup (try_,
7246 TRY_CATCH_IS_CLEANUP (*expr_p));
7247 gimplify_seq_add_stmt (pre_p, try_);
7252 case CLEANUP_POINT_EXPR:
7253 ret = gimplify_cleanup_point_expr (expr_p, pre_p);
7257 ret = gimplify_target_expr (expr_p, pre_p, post_p);
7263 gimple_seq handler = NULL;
7264 gimplify_and_add (CATCH_BODY (*expr_p), &handler);
7265 c = gimple_build_catch (CATCH_TYPES (*expr_p), handler);
7266 gimplify_seq_add_stmt (pre_p, c);
7271 case EH_FILTER_EXPR:
7274 gimple_seq failure = NULL;
7276 gimplify_and_add (EH_FILTER_FAILURE (*expr_p), &failure);
7277 ehf = gimple_build_eh_filter (EH_FILTER_TYPES (*expr_p), failure);
7278 gimple_set_no_warning (ehf, TREE_NO_WARNING (*expr_p));
7279 gimplify_seq_add_stmt (pre_p, ehf);
7286 enum gimplify_status r0, r1;
7287 r0 = gimplify_expr (&OBJ_TYPE_REF_OBJECT (*expr_p), pre_p,
7288 post_p, is_gimple_val, fb_rvalue);
7289 r1 = gimplify_expr (&OBJ_TYPE_REF_EXPR (*expr_p), pre_p,
7290 post_p, is_gimple_val, fb_rvalue);
7291 TREE_SIDE_EFFECTS (*expr_p) = 0;
7297 /* We get here when taking the address of a label. We mark
7298 the label as "forced"; meaning it can never be removed and
7299 it is a potential target for any computed goto. */
7300 FORCED_LABEL (*expr_p) = 1;
7304 case STATEMENT_LIST:
7305 ret = gimplify_statement_list (expr_p, pre_p);
7308 case WITH_SIZE_EXPR:
7310 gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
7311 post_p == &internal_post ? NULL : post_p,
7312 gimple_test_f, fallback);
7313 gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p,
7314 is_gimple_val, fb_rvalue);
7321 ret = gimplify_var_or_parm_decl (expr_p);
7325 /* When within an OpenMP context, notice uses of variables. */
7326 if (gimplify_omp_ctxp)
7327 omp_notice_variable (gimplify_omp_ctxp, *expr_p, true);
7332 /* Allow callbacks into the gimplifier during optimization. */
7337 gimplify_omp_parallel (expr_p, pre_p);
7342 gimplify_omp_task (expr_p, pre_p);
7347 ret = gimplify_omp_for (expr_p, pre_p);
7352 gimplify_omp_workshare (expr_p, pre_p);
7361 gimple_seq body = NULL;
7364 gimplify_and_add (OMP_BODY (*expr_p), &body);
7365 switch (TREE_CODE (*expr_p))
7368 g = gimple_build_omp_section (body);
7371 g = gimple_build_omp_master (body);
7374 g = gimple_build_omp_ordered (body);
7377 g = gimple_build_omp_critical (body,
7378 OMP_CRITICAL_NAME (*expr_p));
7383 gimplify_seq_add_stmt (pre_p, g);
7389 case OMP_ATOMIC_READ:
7390 case OMP_ATOMIC_CAPTURE_OLD:
7391 case OMP_ATOMIC_CAPTURE_NEW:
7392 ret = gimplify_omp_atomic (expr_p, pre_p);
7395 case TRANSACTION_EXPR:
7396 ret = gimplify_transaction (expr_p, pre_p);
7399 case TRUTH_AND_EXPR:
7401 case TRUTH_XOR_EXPR:
7403 tree orig_type = TREE_TYPE (*expr_p);
7404 tree new_type, xop0, xop1;
7405 *expr_p = gimple_boolify (*expr_p);
7406 new_type = TREE_TYPE (*expr_p);
7407 if (!useless_type_conversion_p (orig_type, new_type))
7409 *expr_p = fold_convert_loc (input_location, orig_type, *expr_p);
7414 /* Boolified binary truth expressions are semantically equivalent
7415 to bitwise binary expressions. Canonicalize them to the
7417 switch (TREE_CODE (*expr_p))
7419 case TRUTH_AND_EXPR:
7420 TREE_SET_CODE (*expr_p, BIT_AND_EXPR);
7423 TREE_SET_CODE (*expr_p, BIT_IOR_EXPR);
7425 case TRUTH_XOR_EXPR:
7426 TREE_SET_CODE (*expr_p, BIT_XOR_EXPR);
7431 /* Now make sure that operands have compatible type to
7432 expression's new_type. */
7433 xop0 = TREE_OPERAND (*expr_p, 0);
7434 xop1 = TREE_OPERAND (*expr_p, 1);
7435 if (!useless_type_conversion_p (new_type, TREE_TYPE (xop0)))
7436 TREE_OPERAND (*expr_p, 0) = fold_convert_loc (input_location,
7439 if (!useless_type_conversion_p (new_type, TREE_TYPE (xop1)))
7440 TREE_OPERAND (*expr_p, 1) = fold_convert_loc (input_location,
7443 /* Continue classified as tcc_binary. */
7449 /* Classified as tcc_expression. */
7452 case POINTER_PLUS_EXPR:
7454 enum gimplify_status r0, r1;
7455 r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
7456 post_p, is_gimple_val, fb_rvalue);
7457 r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p,
7458 post_p, is_gimple_val, fb_rvalue);
7459 recalculate_side_effects (*expr_p);
7461 /* Convert &X + CST to invariant &MEM[&X, CST]. Do this
7462 after gimplifying operands - this is similar to how
7463 it would be folding all gimplified stmts on creation
7464 to have them canonicalized, which is what we eventually
7465 should do anyway. */
7466 if (TREE_CODE (TREE_OPERAND (*expr_p, 1)) == INTEGER_CST
7467 && is_gimple_min_invariant (TREE_OPERAND (*expr_p, 0)))
7469 *expr_p = build_fold_addr_expr_with_type_loc
7471 fold_build2 (MEM_REF, TREE_TYPE (TREE_TYPE (*expr_p)),
7472 TREE_OPERAND (*expr_p, 0),
7473 fold_convert (ptr_type_node,
7474 TREE_OPERAND (*expr_p, 1))),
7475 TREE_TYPE (*expr_p));
7476 ret = MIN (ret, GS_OK);
7482 switch (TREE_CODE_CLASS (TREE_CODE (*expr_p)))
7484 case tcc_comparison:
7485 /* Handle comparison of objects of non scalar mode aggregates
7486 with a call to memcmp. It would be nice to only have to do
7487 this for variable-sized objects, but then we'd have to allow
7488 the same nest of reference nodes we allow for MODIFY_EXPR and
7491 Compare scalar mode aggregates as scalar mode values. Using
7492 memcmp for them would be very inefficient at best, and is
7493 plain wrong if bitfields are involved. */
7495 tree type = TREE_TYPE (TREE_OPERAND (*expr_p, 1));
7497 /* Vector comparisons need no boolification. */
7498 if (TREE_CODE (type) == VECTOR_TYPE)
7500 else if (!AGGREGATE_TYPE_P (type))
7502 tree org_type = TREE_TYPE (*expr_p);
7503 *expr_p = gimple_boolify (*expr_p);
7504 if (!useless_type_conversion_p (org_type,
7505 TREE_TYPE (*expr_p)))
7507 *expr_p = fold_convert_loc (input_location,
7514 else if (TYPE_MODE (type) != BLKmode)
7515 ret = gimplify_scalar_mode_aggregate_compare (expr_p);
7517 ret = gimplify_variable_sized_compare (expr_p);
7522 /* If *EXPR_P does not need to be special-cased, handle it
7523 according to its class. */
7525 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
7526 post_p, is_gimple_val, fb_rvalue);
7532 enum gimplify_status r0, r1;
7534 r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
7535 post_p, is_gimple_val, fb_rvalue);
7536 r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p,
7537 post_p, is_gimple_val, fb_rvalue);
7545 enum gimplify_status r0, r1, r2;
7547 r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
7548 post_p, is_gimple_val, fb_rvalue);
7549 r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p,
7550 post_p, is_gimple_val, fb_rvalue);
7551 r2 = gimplify_expr (&TREE_OPERAND (*expr_p, 2), pre_p,
7552 post_p, is_gimple_val, fb_rvalue);
7554 ret = MIN (MIN (r0, r1), r2);
7558 case tcc_declaration:
7561 goto dont_recalculate;
7567 recalculate_side_effects (*expr_p);
7573 gcc_assert (*expr_p || ret != GS_OK);
7575 while (ret == GS_OK);
7577 /* If we encountered an error_mark somewhere nested inside, either
7578 stub out the statement or propagate the error back out. */
7579 if (ret == GS_ERROR)
7586 /* This was only valid as a return value from the langhook, which
7587 we handled. Make sure it doesn't escape from any other context. */
7588 gcc_assert (ret != GS_UNHANDLED);
7590 if (fallback == fb_none && *expr_p && !is_gimple_stmt (*expr_p))
7592 /* We aren't looking for a value, and we don't have a valid
7593 statement. If it doesn't have side-effects, throw it away. */
7594 if (!TREE_SIDE_EFFECTS (*expr_p))
7596 else if (!TREE_THIS_VOLATILE (*expr_p))
7598 /* This is probably a _REF that contains something nested that
7599 has side effects. Recurse through the operands to find it. */
7600 enum tree_code code = TREE_CODE (*expr_p);
7607 case VIEW_CONVERT_EXPR:
7608 gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
7609 gimple_test_f, fallback);
7613 case ARRAY_RANGE_REF:
7614 gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
7615 gimple_test_f, fallback);
7616 gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p,
7617 gimple_test_f, fallback);
7621 /* Anything else with side-effects must be converted to
7622 a valid statement before we get here. */
7628 else if (COMPLETE_TYPE_P (TREE_TYPE (*expr_p))
7629 && TYPE_MODE (TREE_TYPE (*expr_p)) != BLKmode)
7631 /* Historically, the compiler has treated a bare reference
7632 to a non-BLKmode volatile lvalue as forcing a load. */
7633 tree type = TYPE_MAIN_VARIANT (TREE_TYPE (*expr_p));
7635 /* Normally, we do not want to create a temporary for a
7636 TREE_ADDRESSABLE type because such a type should not be
7637 copied by bitwise-assignment. However, we make an
7638 exception here, as all we are doing here is ensuring that
7639 we read the bytes that make up the type. We use
7640 create_tmp_var_raw because create_tmp_var will abort when
7641 given a TREE_ADDRESSABLE type. */
7642 tree tmp = create_tmp_var_raw (type, "vol");
7643 gimple_add_tmp_var (tmp);
7644 gimplify_assign (tmp, *expr_p, pre_p);
7648 /* We can't do anything useful with a volatile reference to
7649 an incomplete type, so just throw it away. Likewise for
7650 a BLKmode type, since any implicit inner load should
7651 already have been turned into an explicit one by the
7652 gimplification process. */
7656 /* If we are gimplifying at the statement level, we're done. Tack
7657 everything together and return. */
7658 if (fallback == fb_none || is_statement)
7660 /* Since *EXPR_P has been converted into a GIMPLE tuple, clear
7661 it out for GC to reclaim it. */
7662 *expr_p = NULL_TREE;
7664 if (!gimple_seq_empty_p (internal_pre)
7665 || !gimple_seq_empty_p (internal_post))
7667 gimplify_seq_add_seq (&internal_pre, internal_post);
7668 gimplify_seq_add_seq (pre_p, internal_pre);
7671 /* The result of gimplifying *EXPR_P is going to be the last few
7672 statements in *PRE_P and *POST_P. Add location information
7673 to all the statements that were added by the gimplification
7675 if (!gimple_seq_empty_p (*pre_p))
7676 annotate_all_with_location_after (*pre_p, pre_last_gsi, input_location);
7678 if (!gimple_seq_empty_p (*post_p))
7679 annotate_all_with_location_after (*post_p, post_last_gsi,
7685 #ifdef ENABLE_GIMPLE_CHECKING
7688 enum tree_code code = TREE_CODE (*expr_p);
7689 /* These expressions should already be in gimple IR form. */
7690 gcc_assert (code != MODIFY_EXPR
7692 && code != BIND_EXPR
7693 && code != CATCH_EXPR
7694 && (code != COND_EXPR || gimplify_ctxp->allow_rhs_cond_expr)
7695 && code != EH_FILTER_EXPR
7696 && code != GOTO_EXPR
7697 && code != LABEL_EXPR
7698 && code != LOOP_EXPR
7699 && code != SWITCH_EXPR
7700 && code != TRY_FINALLY_EXPR
7701 && code != OMP_CRITICAL
7703 && code != OMP_MASTER
7704 && code != OMP_ORDERED
7705 && code != OMP_PARALLEL
7706 && code != OMP_SECTIONS
7707 && code != OMP_SECTION
7708 && code != OMP_SINGLE);
7712 /* Otherwise we're gimplifying a subexpression, so the resulting
7713 value is interesting. If it's a valid operand that matches
7714 GIMPLE_TEST_F, we're done. Unless we are handling some
7715 post-effects internally; if that's the case, we need to copy into
7716 a temporary before adding the post-effects to POST_P. */
7717 if (gimple_seq_empty_p (internal_post) && (*gimple_test_f) (*expr_p))
7720 /* Otherwise, we need to create a new temporary for the gimplified
7723 /* We can't return an lvalue if we have an internal postqueue. The
7724 object the lvalue refers to would (probably) be modified by the
7725 postqueue; we need to copy the value out first, which means an
7727 if ((fallback & fb_lvalue)
7728 && gimple_seq_empty_p (internal_post)
7729 && is_gimple_addressable (*expr_p))
7731 /* An lvalue will do. Take the address of the expression, store it
7732 in a temporary, and replace the expression with an INDIRECT_REF of
7734 tmp = build_fold_addr_expr_loc (input_location, *expr_p);
7735 gimplify_expr (&tmp, pre_p, post_p, is_gimple_reg, fb_rvalue);
7736 *expr_p = build_simple_mem_ref (tmp);
7738 else if ((fallback & fb_rvalue) && is_gimple_reg_rhs_or_call (*expr_p))
7740 /* An rvalue will do. Assign the gimplified expression into a
7741 new temporary TMP and replace the original expression with
7742 TMP. First, make sure that the expression has a type so that
7743 it can be assigned into a temporary. */
7744 gcc_assert (!VOID_TYPE_P (TREE_TYPE (*expr_p)));
7746 if (!gimple_seq_empty_p (internal_post) || (fallback & fb_lvalue))
7747 /* The postqueue might change the value of the expression between
7748 the initialization and use of the temporary, so we can't use a
7749 formal temp. FIXME do we care? */
7751 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
7752 if (TREE_CODE (TREE_TYPE (*expr_p)) == COMPLEX_TYPE
7753 || TREE_CODE (TREE_TYPE (*expr_p)) == VECTOR_TYPE)
7754 DECL_GIMPLE_REG_P (*expr_p) = 1;
7757 *expr_p = get_formal_tmp_var (*expr_p, pre_p);
7761 #ifdef ENABLE_GIMPLE_CHECKING
7762 if (!(fallback & fb_mayfail))
7764 fprintf (stderr, "gimplification failed:\n");
7765 print_generic_expr (stderr, *expr_p, 0);
7766 debug_tree (*expr_p);
7767 internal_error ("gimplification failed");
7770 gcc_assert (fallback & fb_mayfail);
7772 /* If this is an asm statement, and the user asked for the
7773 impossible, don't die. Fail and let gimplify_asm_expr
7779 /* Make sure the temporary matches our predicate. */
7780 gcc_assert ((*gimple_test_f) (*expr_p));
7782 if (!gimple_seq_empty_p (internal_post))
7784 annotate_all_with_location (internal_post, input_location);
7785 gimplify_seq_add_seq (pre_p, internal_post);
7789 input_location = saved_location;
7793 /* Look through TYPE for variable-sized objects and gimplify each such
7794 size that we find. Add to LIST_P any statements generated. */
7797 gimplify_type_sizes (tree type, gimple_seq *list_p)
7801 if (type == NULL || type == error_mark_node)
7804 /* We first do the main variant, then copy into any other variants. */
7805 type = TYPE_MAIN_VARIANT (type);
7807 /* Avoid infinite recursion. */
7808 if (TYPE_SIZES_GIMPLIFIED (type))
7811 TYPE_SIZES_GIMPLIFIED (type) = 1;
7813 switch (TREE_CODE (type))
7819 case FIXED_POINT_TYPE:
7820 gimplify_one_sizepos (&TYPE_MIN_VALUE (type), list_p);
7821 gimplify_one_sizepos (&TYPE_MAX_VALUE (type), list_p);
7823 for (t = TYPE_NEXT_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
7825 TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (type);
7826 TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (type);
7831 /* These types may not have declarations, so handle them here. */
7832 gimplify_type_sizes (TREE_TYPE (type), list_p);
7833 gimplify_type_sizes (TYPE_DOMAIN (type), list_p);
7834 /* Ensure VLA bounds aren't removed, for -O0 they should be variables
7835 with assigned stack slots, for -O1+ -g they should be tracked
7837 if (!(TYPE_NAME (type)
7838 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
7839 && DECL_IGNORED_P (TYPE_NAME (type)))
7840 && TYPE_DOMAIN (type)
7841 && INTEGRAL_TYPE_P (TYPE_DOMAIN (type)))
7843 t = TYPE_MIN_VALUE (TYPE_DOMAIN (type));
7844 if (t && TREE_CODE (t) == VAR_DECL && DECL_ARTIFICIAL (t))
7845 DECL_IGNORED_P (t) = 0;
7846 t = TYPE_MAX_VALUE (TYPE_DOMAIN (type));
7847 if (t && TREE_CODE (t) == VAR_DECL && DECL_ARTIFICIAL (t))
7848 DECL_IGNORED_P (t) = 0;
7854 case QUAL_UNION_TYPE:
7855 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
7856 if (TREE_CODE (field) == FIELD_DECL)
7858 gimplify_one_sizepos (&DECL_FIELD_OFFSET (field), list_p);
7859 gimplify_one_sizepos (&DECL_SIZE (field), list_p);
7860 gimplify_one_sizepos (&DECL_SIZE_UNIT (field), list_p);
7861 gimplify_type_sizes (TREE_TYPE (field), list_p);
7866 case REFERENCE_TYPE:
7867 /* We used to recurse on the pointed-to type here, which turned out to
7868 be incorrect because its definition might refer to variables not
7869 yet initialized at this point if a forward declaration is involved.
7871 It was actually useful for anonymous pointed-to types to ensure
7872 that the sizes evaluation dominates every possible later use of the
7873 values. Restricting to such types here would be safe since there
7874 is no possible forward declaration around, but would introduce an
7875 undesirable middle-end semantic to anonymity. We then defer to
7876 front-ends the responsibility of ensuring that the sizes are
7877 evaluated both early and late enough, e.g. by attaching artificial
7878 type declarations to the tree. */
7885 gimplify_one_sizepos (&TYPE_SIZE (type), list_p);
7886 gimplify_one_sizepos (&TYPE_SIZE_UNIT (type), list_p);
7888 for (t = TYPE_NEXT_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
7890 TYPE_SIZE (t) = TYPE_SIZE (type);
7891 TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (type);
7892 TYPE_SIZES_GIMPLIFIED (t) = 1;
7896 /* A subroutine of gimplify_type_sizes to make sure that *EXPR_P,
7897 a size or position, has had all of its SAVE_EXPRs evaluated.
7898 We add any required statements to *STMT_P. */
7901 gimplify_one_sizepos (tree *expr_p, gimple_seq *stmt_p)
7903 tree type, expr = *expr_p;
7905 /* We don't do anything if the value isn't there, is constant, or contains
7906 A PLACEHOLDER_EXPR. We also don't want to do anything if it's already
7907 a VAR_DECL. If it's a VAR_DECL from another function, the gimplifier
7908 will want to replace it with a new variable, but that will cause problems
7909 if this type is from outside the function. It's OK to have that here. */
7910 if (expr == NULL_TREE || TREE_CONSTANT (expr)
7911 || TREE_CODE (expr) == VAR_DECL
7912 || CONTAINS_PLACEHOLDER_P (expr))
7915 type = TREE_TYPE (expr);
7916 *expr_p = unshare_expr (expr);
7918 gimplify_expr (expr_p, stmt_p, NULL, is_gimple_val, fb_rvalue);
7921 /* Verify that we've an exact type match with the original expression.
7922 In particular, we do not wish to drop a "sizetype" in favour of a
7923 type of similar dimensions. We don't want to pollute the generic
7924 type-stripping code with this knowledge because it doesn't matter
7925 for the bulk of GENERIC/GIMPLE. It only matters that TYPE_SIZE_UNIT
7926 and friends retain their "sizetype-ness". */
7927 if (TREE_TYPE (expr) != type
7928 && TREE_CODE (type) == INTEGER_TYPE
7929 && TYPE_IS_SIZETYPE (type))
7934 *expr_p = create_tmp_var (type, NULL);
7935 tmp = build1 (NOP_EXPR, type, expr);
7936 stmt = gimplify_assign (*expr_p, tmp, stmt_p);
7937 gimple_set_location (stmt, EXPR_LOC_OR_HERE (expr));
7941 /* Gimplify the body of statements pointed to by BODY_P and return a
7942 GIMPLE_BIND containing the sequence of GIMPLE statements
7943 corresponding to BODY_P. FNDECL is the function decl containing
7947 gimplify_body (tree *body_p, tree fndecl, bool do_parms)
7949 location_t saved_location = input_location;
7950 gimple_seq parm_stmts, seq;
7952 struct gimplify_ctx gctx;
7953 struct cgraph_node *cgn;
7955 timevar_push (TV_TREE_GIMPLIFY);
7957 /* Initialize for optimize_insn_for_s{ize,peed}_p possibly called during
7959 default_rtl_profile ();
7961 gcc_assert (gimplify_ctxp == NULL);
7962 push_gimplify_context (&gctx);
7964 /* Unshare most shared trees in the body and in that of any nested functions.
7965 It would seem we don't have to do this for nested functions because
7966 they are supposed to be output and then the outer function gimplified
7967 first, but the g++ front end doesn't always do it that way. */
7968 unshare_body (body_p, fndecl);
7969 unvisit_body (body_p, fndecl);
7971 cgn = cgraph_get_node (fndecl);
7972 if (cgn && cgn->origin)
7973 nonlocal_vlas = pointer_set_create ();
7975 /* Make sure input_location isn't set to something weird. */
7976 input_location = DECL_SOURCE_LOCATION (fndecl);
7978 /* Resolve callee-copies. This has to be done before processing
7979 the body so that DECL_VALUE_EXPR gets processed correctly. */
7980 parm_stmts = (do_parms) ? gimplify_parameters () : NULL;
7982 /* Gimplify the function's body. */
7984 gimplify_stmt (body_p, &seq);
7985 outer_bind = gimple_seq_first_stmt (seq);
7988 outer_bind = gimple_build_nop ();
7989 gimplify_seq_add_stmt (&seq, outer_bind);
7992 /* The body must contain exactly one statement, a GIMPLE_BIND. If this is
7993 not the case, wrap everything in a GIMPLE_BIND to make it so. */
7994 if (gimple_code (outer_bind) == GIMPLE_BIND
7995 && gimple_seq_first (seq) == gimple_seq_last (seq))
7998 outer_bind = gimple_build_bind (NULL_TREE, seq, NULL);
8000 *body_p = NULL_TREE;
8002 /* If we had callee-copies statements, insert them at the beginning
8003 of the function and clear DECL_VALUE_EXPR_P on the parameters. */
8004 if (!gimple_seq_empty_p (parm_stmts))
8008 gimplify_seq_add_seq (&parm_stmts, gimple_bind_body (outer_bind));
8009 gimple_bind_set_body (outer_bind, parm_stmts);
8011 for (parm = DECL_ARGUMENTS (current_function_decl);
8012 parm; parm = DECL_CHAIN (parm))
8013 if (DECL_HAS_VALUE_EXPR_P (parm))
8015 DECL_HAS_VALUE_EXPR_P (parm) = 0;
8016 DECL_IGNORED_P (parm) = 0;
8022 pointer_set_destroy (nonlocal_vlas);
8023 nonlocal_vlas = NULL;
8026 pop_gimplify_context (outer_bind);
8027 gcc_assert (gimplify_ctxp == NULL);
8030 verify_gimple_in_seq (gimple_bind_body (outer_bind));
8032 timevar_pop (TV_TREE_GIMPLIFY);
8033 input_location = saved_location;
8038 typedef char *char_p; /* For DEF_VEC_P. */
8040 DEF_VEC_ALLOC_P(char_p,heap);
8042 /* Return whether we should exclude FNDECL from instrumentation. */
8045 flag_instrument_functions_exclude_p (tree fndecl)
8047 VEC(char_p,heap) *vec;
8049 vec = (VEC(char_p,heap) *) flag_instrument_functions_exclude_functions;
8050 if (VEC_length (char_p, vec) > 0)
8056 name = lang_hooks.decl_printable_name (fndecl, 0);
8057 FOR_EACH_VEC_ELT (char_p, vec, i, s)
8058 if (strstr (name, s) != NULL)
8062 vec = (VEC(char_p,heap) *) flag_instrument_functions_exclude_files;
8063 if (VEC_length (char_p, vec) > 0)
8069 name = DECL_SOURCE_FILE (fndecl);
8070 FOR_EACH_VEC_ELT (char_p, vec, i, s)
8071 if (strstr (name, s) != NULL)
8078 /* Entry point to the gimplification pass. FNDECL is the FUNCTION_DECL
8079 node for the function we want to gimplify.
8081 Return the sequence of GIMPLE statements corresponding to the body
8085 gimplify_function_tree (tree fndecl)
8087 tree oldfn, parm, ret;
8091 gcc_assert (!gimple_body (fndecl));
8093 oldfn = current_function_decl;
8094 current_function_decl = fndecl;
8095 if (DECL_STRUCT_FUNCTION (fndecl))
8096 push_cfun (DECL_STRUCT_FUNCTION (fndecl));
8098 push_struct_function (fndecl);
8100 for (parm = DECL_ARGUMENTS (fndecl); parm ; parm = DECL_CHAIN (parm))
8102 /* Preliminarily mark non-addressed complex variables as eligible
8103 for promotion to gimple registers. We'll transform their uses
8105 if ((TREE_CODE (TREE_TYPE (parm)) == COMPLEX_TYPE
8106 || TREE_CODE (TREE_TYPE (parm)) == VECTOR_TYPE)
8107 && !TREE_THIS_VOLATILE (parm)
8108 && !needs_to_live_in_memory (parm))
8109 DECL_GIMPLE_REG_P (parm) = 1;
8112 ret = DECL_RESULT (fndecl);
8113 if ((TREE_CODE (TREE_TYPE (ret)) == COMPLEX_TYPE
8114 || TREE_CODE (TREE_TYPE (ret)) == VECTOR_TYPE)
8115 && !needs_to_live_in_memory (ret))
8116 DECL_GIMPLE_REG_P (ret) = 1;
8118 bind = gimplify_body (&DECL_SAVED_TREE (fndecl), fndecl, true);
8120 /* The tree body of the function is no longer needed, replace it
8121 with the new GIMPLE body. */
8122 seq = gimple_seq_alloc ();
8123 gimple_seq_add_stmt (&seq, bind);
8124 gimple_set_body (fndecl, seq);
8126 /* If we're instrumenting function entry/exit, then prepend the call to
8127 the entry hook and wrap the whole function in a TRY_FINALLY_EXPR to
8128 catch the exit hook. */
8129 /* ??? Add some way to ignore exceptions for this TFE. */
8130 if (flag_instrument_function_entry_exit
8131 && !DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (fndecl)
8132 && !flag_instrument_functions_exclude_p (fndecl))
8137 gimple_seq cleanup = NULL, body = NULL;
8141 x = builtin_decl_implicit (BUILT_IN_RETURN_ADDRESS);
8142 call = gimple_build_call (x, 1, integer_zero_node);
8143 tmp_var = create_tmp_var (ptr_type_node, "return_addr");
8144 gimple_call_set_lhs (call, tmp_var);
8145 gimplify_seq_add_stmt (&cleanup, call);
8146 x = builtin_decl_implicit (BUILT_IN_PROFILE_FUNC_EXIT);
8147 call = gimple_build_call (x, 2,
8148 build_fold_addr_expr (current_function_decl),
8150 gimplify_seq_add_stmt (&cleanup, call);
8151 tf = gimple_build_try (seq, cleanup, GIMPLE_TRY_FINALLY);
8153 x = builtin_decl_implicit (BUILT_IN_RETURN_ADDRESS);
8154 call = gimple_build_call (x, 1, integer_zero_node);
8155 tmp_var = create_tmp_var (ptr_type_node, "return_addr");
8156 gimple_call_set_lhs (call, tmp_var);
8157 gimplify_seq_add_stmt (&body, call);
8158 x = builtin_decl_implicit (BUILT_IN_PROFILE_FUNC_ENTER);
8159 call = gimple_build_call (x, 2,
8160 build_fold_addr_expr (current_function_decl),
8162 gimplify_seq_add_stmt (&body, call);
8163 gimplify_seq_add_stmt (&body, tf);
8164 new_bind = gimple_build_bind (NULL, body, gimple_bind_block (bind));
8165 /* Clear the block for BIND, since it is no longer directly inside
8166 the function, but within a try block. */
8167 gimple_bind_set_block (bind, NULL);
8169 /* Replace the current function body with the body
8170 wrapped in the try/finally TF. */
8171 seq = gimple_seq_alloc ();
8172 gimple_seq_add_stmt (&seq, new_bind);
8173 gimple_set_body (fndecl, seq);
8176 DECL_SAVED_TREE (fndecl) = NULL_TREE;
8177 cfun->curr_properties = PROP_gimple_any;
8179 current_function_decl = oldfn;
8183 /* Some transformations like inlining may invalidate the GIMPLE form
8184 for operands. This function traverses all the operands in STMT and
8185 gimplifies anything that is not a valid gimple operand. Any new
8186 GIMPLE statements are inserted before *GSI_P. */
8189 gimple_regimplify_operands (gimple stmt, gimple_stmt_iterator *gsi_p)
8192 tree orig_lhs = NULL_TREE, lhs, t;
8193 gimple_seq pre = NULL;
8194 gimple post_stmt = NULL;
8195 struct gimplify_ctx gctx;
8197 push_gimplify_context (&gctx);
8198 gimplify_ctxp->into_ssa = gimple_in_ssa_p (cfun);
8200 switch (gimple_code (stmt))
8203 gimplify_expr (gimple_cond_lhs_ptr (stmt), &pre, NULL,
8204 is_gimple_val, fb_rvalue);
8205 gimplify_expr (gimple_cond_rhs_ptr (stmt), &pre, NULL,
8206 is_gimple_val, fb_rvalue);
8209 gimplify_expr (gimple_switch_index_ptr (stmt), &pre, NULL,
8210 is_gimple_val, fb_rvalue);
8212 case GIMPLE_OMP_ATOMIC_LOAD:
8213 gimplify_expr (gimple_omp_atomic_load_rhs_ptr (stmt), &pre, NULL,
8214 is_gimple_val, fb_rvalue);
8218 size_t i, noutputs = gimple_asm_noutputs (stmt);
8219 const char *constraint, **oconstraints;
8220 bool allows_mem, allows_reg, is_inout;
8223 = (const char **) alloca ((noutputs) * sizeof (const char *));
8224 for (i = 0; i < noutputs; i++)
8226 tree op = gimple_asm_output_op (stmt, i);
8227 constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op)));
8228 oconstraints[i] = constraint;
8229 parse_output_constraint (&constraint, i, 0, 0, &allows_mem,
8230 &allows_reg, &is_inout);
8231 gimplify_expr (&TREE_VALUE (op), &pre, NULL,
8232 is_inout ? is_gimple_min_lval : is_gimple_lvalue,
8233 fb_lvalue | fb_mayfail);
8235 for (i = 0; i < gimple_asm_ninputs (stmt); i++)
8237 tree op = gimple_asm_input_op (stmt, i);
8238 constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op)));
8239 parse_input_constraint (&constraint, 0, 0, noutputs, 0,
8240 oconstraints, &allows_mem, &allows_reg);
8241 if (TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (op))) && allows_mem)
8243 if (!allows_reg && allows_mem)
8244 gimplify_expr (&TREE_VALUE (op), &pre, NULL,
8245 is_gimple_lvalue, fb_lvalue | fb_mayfail);
8247 gimplify_expr (&TREE_VALUE (op), &pre, NULL,
8248 is_gimple_asm_val, fb_rvalue);
8253 /* NOTE: We start gimplifying operands from last to first to
8254 make sure that side-effects on the RHS of calls, assignments
8255 and ASMs are executed before the LHS. The ordering is not
8256 important for other statements. */
8257 num_ops = gimple_num_ops (stmt);
8258 orig_lhs = gimple_get_lhs (stmt);
8259 for (i = num_ops; i > 0; i--)
8261 tree op = gimple_op (stmt, i - 1);
8262 if (op == NULL_TREE)
8264 if (i == 1 && (is_gimple_call (stmt) || is_gimple_assign (stmt)))
8265 gimplify_expr (&op, &pre, NULL, is_gimple_lvalue, fb_lvalue);
8267 && is_gimple_assign (stmt)
8269 && get_gimple_rhs_class (gimple_expr_code (stmt))
8270 == GIMPLE_SINGLE_RHS)
8271 gimplify_expr (&op, &pre, NULL,
8272 rhs_predicate_for (gimple_assign_lhs (stmt)),
8274 else if (i == 2 && is_gimple_call (stmt))
8276 if (TREE_CODE (op) == FUNCTION_DECL)
8278 gimplify_expr (&op, &pre, NULL, is_gimple_call_addr, fb_rvalue);
8281 gimplify_expr (&op, &pre, NULL, is_gimple_val, fb_rvalue);
8282 gimple_set_op (stmt, i - 1, op);
8285 lhs = gimple_get_lhs (stmt);
8286 /* If the LHS changed it in a way that requires a simple RHS,
8287 create temporary. */
8288 if (lhs && !is_gimple_reg (lhs))
8290 bool need_temp = false;
8292 if (is_gimple_assign (stmt)
8294 && get_gimple_rhs_class (gimple_expr_code (stmt))
8295 == GIMPLE_SINGLE_RHS)
8296 gimplify_expr (gimple_assign_rhs1_ptr (stmt), &pre, NULL,
8297 rhs_predicate_for (gimple_assign_lhs (stmt)),
8299 else if (is_gimple_reg (lhs))
8301 if (is_gimple_reg_type (TREE_TYPE (lhs)))
8303 if (is_gimple_call (stmt))
8305 i = gimple_call_flags (stmt);
8306 if ((i & ECF_LOOPING_CONST_OR_PURE)
8307 || !(i & (ECF_CONST | ECF_PURE)))
8310 if (stmt_can_throw_internal (stmt))
8316 if (is_gimple_reg_type (TREE_TYPE (lhs)))
8318 else if (TYPE_MODE (TREE_TYPE (lhs)) != BLKmode)
8320 if (is_gimple_call (stmt))
8322 tree fndecl = gimple_call_fndecl (stmt);
8324 if (!aggregate_value_p (TREE_TYPE (lhs), fndecl)
8325 && !(fndecl && DECL_RESULT (fndecl)
8326 && DECL_BY_REFERENCE (DECL_RESULT (fndecl))))
8335 tree temp = create_tmp_reg (TREE_TYPE (lhs), NULL);
8337 if (TREE_CODE (orig_lhs) == SSA_NAME)
8338 orig_lhs = SSA_NAME_VAR (orig_lhs);
8340 if (gimple_in_ssa_p (cfun))
8341 temp = make_ssa_name (temp, NULL);
8342 gimple_set_lhs (stmt, temp);
8343 post_stmt = gimple_build_assign (lhs, temp);
8344 if (TREE_CODE (lhs) == SSA_NAME)
8345 SSA_NAME_DEF_STMT (lhs) = post_stmt;
8351 if (gimple_referenced_vars (cfun))
8352 for (t = gimplify_ctxp->temps; t ; t = TREE_CHAIN (t))
8353 add_referenced_var (t);
8355 if (!gimple_seq_empty_p (pre))
8357 if (gimple_in_ssa_p (cfun))
8359 gimple_stmt_iterator i;
8361 for (i = gsi_start (pre); !gsi_end_p (i); gsi_next (&i))
8362 mark_symbols_for_renaming (gsi_stmt (i));
8364 gsi_insert_seq_before (gsi_p, pre, GSI_SAME_STMT);
8367 gsi_insert_after (gsi_p, post_stmt, GSI_NEW_STMT);
8369 pop_gimplify_context (NULL);
8372 /* Expand EXPR to list of gimple statements STMTS. GIMPLE_TEST_F specifies
8373 the predicate that will hold for the result. If VAR is not NULL, make the
8374 base variable of the final destination be VAR if suitable. */
8377 force_gimple_operand_1 (tree expr, gimple_seq *stmts,
8378 gimple_predicate gimple_test_f, tree var)
8381 enum gimplify_status ret;
8382 struct gimplify_ctx gctx;
8386 /* gimple_test_f might be more strict than is_gimple_val, make
8387 sure we pass both. Just checking gimple_test_f doesn't work
8388 because most gimple predicates do not work recursively. */
8389 if (is_gimple_val (expr)
8390 && (*gimple_test_f) (expr))
8393 push_gimplify_context (&gctx);
8394 gimplify_ctxp->into_ssa = gimple_in_ssa_p (cfun);
8395 gimplify_ctxp->allow_rhs_cond_expr = true;
8398 expr = build2 (MODIFY_EXPR, TREE_TYPE (var), var, expr);
8400 if (TREE_CODE (expr) != MODIFY_EXPR
8401 && TREE_TYPE (expr) == void_type_node)
8403 gimplify_and_add (expr, stmts);
8408 ret = gimplify_expr (&expr, stmts, NULL, gimple_test_f, fb_rvalue);
8409 gcc_assert (ret != GS_ERROR);
8412 if (gimple_referenced_vars (cfun))
8413 for (t = gimplify_ctxp->temps; t ; t = DECL_CHAIN (t))
8414 add_referenced_var (t);
8416 pop_gimplify_context (NULL);
8421 /* Expand EXPR to list of gimple statements STMTS. If SIMPLE is true,
8422 force the result to be either ssa_name or an invariant, otherwise
8423 just force it to be a rhs expression. If VAR is not NULL, make the
8424 base variable of the final destination be VAR if suitable. */
8427 force_gimple_operand (tree expr, gimple_seq *stmts, bool simple, tree var)
8429 return force_gimple_operand_1 (expr, stmts,
8430 simple ? is_gimple_val : is_gimple_reg_rhs,
8434 /* Invoke force_gimple_operand_1 for EXPR with parameters GIMPLE_TEST_F
8435 and VAR. If some statements are produced, emits them at GSI.
8436 If BEFORE is true. the statements are appended before GSI, otherwise
8437 they are appended after it. M specifies the way GSI moves after
8438 insertion (GSI_SAME_STMT or GSI_CONTINUE_LINKING are the usual values). */
8441 force_gimple_operand_gsi_1 (gimple_stmt_iterator *gsi, tree expr,
8442 gimple_predicate gimple_test_f,
8443 tree var, bool before,
8444 enum gsi_iterator_update m)
8448 expr = force_gimple_operand_1 (expr, &stmts, gimple_test_f, var);
8450 if (!gimple_seq_empty_p (stmts))
8452 if (gimple_in_ssa_p (cfun))
8454 gimple_stmt_iterator i;
8456 for (i = gsi_start (stmts); !gsi_end_p (i); gsi_next (&i))
8457 mark_symbols_for_renaming (gsi_stmt (i));
8461 gsi_insert_seq_before (gsi, stmts, m);
8463 gsi_insert_seq_after (gsi, stmts, m);
8469 /* Invoke force_gimple_operand_1 for EXPR with parameter VAR.
8470 If SIMPLE is true, force the result to be either ssa_name or an invariant,
8471 otherwise just force it to be a rhs expression. If some statements are
8472 produced, emits them at GSI. If BEFORE is true, the statements are
8473 appended before GSI, otherwise they are appended after it. M specifies
8474 the way GSI moves after insertion (GSI_SAME_STMT or GSI_CONTINUE_LINKING
8475 are the usual values). */
8478 force_gimple_operand_gsi (gimple_stmt_iterator *gsi, tree expr,
8479 bool simple_p, tree var, bool before,
8480 enum gsi_iterator_update m)
8482 return force_gimple_operand_gsi_1 (gsi, expr,
8484 ? is_gimple_val : is_gimple_reg_rhs,
8489 #include "gt-gimplify.h"