1 /* Tree lowering pass. This pass converts the GENERIC functions-as-trees
2 tree representation into the GIMPLE form.
3 Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011,
4 2012 Free Software Foundation, Inc.
5 Major work done by Sebastian Pop <s.pop@laposte.net>,
6 Diego Novillo <dnovillo@redhat.com> and Jason Merrill <jason@redhat.com>.
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify it under
11 the terms of the GNU General Public License as published by the Free
12 Software Foundation; either version 3, or (at your option) any later
15 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
16 WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING3. If not see
22 <http://www.gnu.org/licenses/>. */
26 #include "coretypes.h"
30 #include "tree-iterator.h"
31 #include "tree-inline.h"
32 #include "tree-pretty-print.h"
33 #include "langhooks.h"
34 #include "tree-flow.h"
42 #include "diagnostic-core.h"
44 #include "pointer-set.h"
45 #include "splay-tree.h"
48 #include "tree-pass.h"
50 #include "langhooks-def.h" /* FIXME: for lhd_set_decl_assembler_name. */
51 #include "expr.h" /* FIXME: for can_move_by_pieces
52 and STACK_CHECK_MAX_VAR_SIZE. */
54 enum gimplify_omp_var_data
60 GOVD_FIRSTPRIVATE = 16,
61 GOVD_LASTPRIVATE = 32,
64 GOVD_DEBUG_PRIVATE = 256,
65 GOVD_PRIVATE_OUTER_REF = 512,
66 GOVD_DATA_SHARE_CLASS = (GOVD_SHARED | GOVD_PRIVATE | GOVD_FIRSTPRIVATE
67 | GOVD_LASTPRIVATE | GOVD_REDUCTION | GOVD_LOCAL)
75 ORT_COMBINED_PARALLEL = 3,
80 struct gimplify_omp_ctx
82 struct gimplify_omp_ctx *outer_context;
84 struct pointer_set_t *privatized_types;
86 enum omp_clause_default_kind default_kind;
87 enum omp_region_type region_type;
90 static struct gimplify_ctx *gimplify_ctxp;
91 static struct gimplify_omp_ctx *gimplify_omp_ctxp;
94 /* Formal (expression) temporary table handling: multiple occurrences of
95 the same scalar expression are evaluated into the same temporary. */
97 typedef struct gimple_temp_hash_elt
100 tree temp; /* Value */
103 /* Forward declaration. */
104 static enum gimplify_status gimplify_compound_expr (tree *, gimple_seq *, bool);
106 /* Mark X addressable. Unlike the langhook we expect X to be in gimple
107 form and we don't do any syntax checking. */
110 mark_addressable (tree x)
112 while (handled_component_p (x))
113 x = TREE_OPERAND (x, 0);
114 if (TREE_CODE (x) == MEM_REF
115 && TREE_CODE (TREE_OPERAND (x, 0)) == ADDR_EXPR)
116 x = TREE_OPERAND (TREE_OPERAND (x, 0), 0);
117 if (TREE_CODE (x) != VAR_DECL
118 && TREE_CODE (x) != PARM_DECL
119 && TREE_CODE (x) != RESULT_DECL)
121 TREE_ADDRESSABLE (x) = 1;
124 /* Return a hash value for a formal temporary table entry. */
127 gimple_tree_hash (const void *p)
129 tree t = ((const elt_t *) p)->val;
130 return iterative_hash_expr (t, 0);
133 /* Compare two formal temporary table entries. */
136 gimple_tree_eq (const void *p1, const void *p2)
138 tree t1 = ((const elt_t *) p1)->val;
139 tree t2 = ((const elt_t *) p2)->val;
140 enum tree_code code = TREE_CODE (t1);
142 if (TREE_CODE (t2) != code
143 || TREE_TYPE (t1) != TREE_TYPE (t2))
146 if (!operand_equal_p (t1, t2, 0))
149 #ifdef ENABLE_CHECKING
150 /* Only allow them to compare equal if they also hash equal; otherwise
151 results are nondeterminate, and we fail bootstrap comparison. */
152 gcc_assert (gimple_tree_hash (p1) == gimple_tree_hash (p2));
158 /* Link gimple statement GS to the end of the sequence *SEQ_P. If
159 *SEQ_P is NULL, a new sequence is allocated. This function is
160 similar to gimple_seq_add_stmt, but does not scan the operands.
161 During gimplification, we need to manipulate statement sequences
162 before the def/use vectors have been constructed. */
165 gimple_seq_add_stmt_without_update (gimple_seq *seq_p, gimple gs)
167 gimple_stmt_iterator si;
173 *seq_p = gimple_seq_alloc ();
175 si = gsi_last (*seq_p);
177 gsi_insert_after_without_update (&si, gs, GSI_NEW_STMT);
180 /* Shorter alias name for the above function for use in gimplify.c
184 gimplify_seq_add_stmt (gimple_seq *seq_p, gimple gs)
186 gimple_seq_add_stmt_without_update (seq_p, gs);
189 /* Append sequence SRC to the end of sequence *DST_P. If *DST_P is
190 NULL, a new sequence is allocated. This function is
191 similar to gimple_seq_add_seq, but does not scan the operands.
192 During gimplification, we need to manipulate statement sequences
193 before the def/use vectors have been constructed. */
196 gimplify_seq_add_seq (gimple_seq *dst_p, gimple_seq src)
198 gimple_stmt_iterator si;
204 *dst_p = gimple_seq_alloc ();
206 si = gsi_last (*dst_p);
207 gsi_insert_seq_after_without_update (&si, src, GSI_NEW_STMT);
210 /* Set up a context for the gimplifier. */
213 push_gimplify_context (struct gimplify_ctx *c)
215 memset (c, '\0', sizeof (*c));
216 c->prev_context = gimplify_ctxp;
220 /* Tear down a context for the gimplifier. If BODY is non-null, then
221 put the temporaries into the outer BIND_EXPR. Otherwise, put them
224 BODY is not a sequence, but the first tuple in a sequence. */
227 pop_gimplify_context (gimple body)
229 struct gimplify_ctx *c = gimplify_ctxp;
231 gcc_assert (c && (c->bind_expr_stack == NULL
232 || VEC_empty (gimple, c->bind_expr_stack)));
233 VEC_free (gimple, heap, c->bind_expr_stack);
234 gimplify_ctxp = c->prev_context;
237 declare_vars (c->temps, body, false);
239 record_vars (c->temps);
242 htab_delete (c->temp_htab);
245 /* Push a GIMPLE_BIND tuple onto the stack of bindings. */
248 gimple_push_bind_expr (gimple gimple_bind)
250 if (gimplify_ctxp->bind_expr_stack == NULL)
251 gimplify_ctxp->bind_expr_stack = VEC_alloc (gimple, heap, 8);
252 VEC_safe_push (gimple, heap, gimplify_ctxp->bind_expr_stack, gimple_bind);
255 /* Pop the first element off the stack of bindings. */
258 gimple_pop_bind_expr (void)
260 VEC_pop (gimple, gimplify_ctxp->bind_expr_stack);
263 /* Return the first element of the stack of bindings. */
266 gimple_current_bind_expr (void)
268 return VEC_last (gimple, gimplify_ctxp->bind_expr_stack);
271 /* Return the stack of bindings created during gimplification. */
274 gimple_bind_expr_stack (void)
276 return gimplify_ctxp->bind_expr_stack;
279 /* Return true iff there is a COND_EXPR between us and the innermost
280 CLEANUP_POINT_EXPR. This info is used by gimple_push_cleanup. */
283 gimple_conditional_context (void)
285 return gimplify_ctxp->conditions > 0;
288 /* Note that we've entered a COND_EXPR. */
291 gimple_push_condition (void)
293 #ifdef ENABLE_GIMPLE_CHECKING
294 if (gimplify_ctxp->conditions == 0)
295 gcc_assert (gimple_seq_empty_p (gimplify_ctxp->conditional_cleanups));
297 ++(gimplify_ctxp->conditions);
300 /* Note that we've left a COND_EXPR. If we're back at unconditional scope
301 now, add any conditional cleanups we've seen to the prequeue. */
304 gimple_pop_condition (gimple_seq *pre_p)
306 int conds = --(gimplify_ctxp->conditions);
308 gcc_assert (conds >= 0);
311 gimplify_seq_add_seq (pre_p, gimplify_ctxp->conditional_cleanups);
312 gimplify_ctxp->conditional_cleanups = NULL;
316 /* A stable comparison routine for use with splay trees and DECLs. */
319 splay_tree_compare_decl_uid (splay_tree_key xa, splay_tree_key xb)
324 return DECL_UID (a) - DECL_UID (b);
327 /* Create a new omp construct that deals with variable remapping. */
329 static struct gimplify_omp_ctx *
330 new_omp_context (enum omp_region_type region_type)
332 struct gimplify_omp_ctx *c;
334 c = XCNEW (struct gimplify_omp_ctx);
335 c->outer_context = gimplify_omp_ctxp;
336 c->variables = splay_tree_new (splay_tree_compare_decl_uid, 0, 0);
337 c->privatized_types = pointer_set_create ();
338 c->location = input_location;
339 c->region_type = region_type;
340 if ((region_type & ORT_TASK) == 0)
341 c->default_kind = OMP_CLAUSE_DEFAULT_SHARED;
343 c->default_kind = OMP_CLAUSE_DEFAULT_UNSPECIFIED;
348 /* Destroy an omp construct that deals with variable remapping. */
351 delete_omp_context (struct gimplify_omp_ctx *c)
353 splay_tree_delete (c->variables);
354 pointer_set_destroy (c->privatized_types);
358 static void omp_add_variable (struct gimplify_omp_ctx *, tree, unsigned int);
359 static bool omp_notice_variable (struct gimplify_omp_ctx *, tree, bool);
361 /* Both gimplify the statement T and append it to *SEQ_P. This function
362 behaves exactly as gimplify_stmt, but you don't have to pass T as a
366 gimplify_and_add (tree t, gimple_seq *seq_p)
368 gimplify_stmt (&t, seq_p);
371 /* Gimplify statement T into sequence *SEQ_P, and return the first
372 tuple in the sequence of generated tuples for this statement.
373 Return NULL if gimplifying T produced no tuples. */
376 gimplify_and_return_first (tree t, gimple_seq *seq_p)
378 gimple_stmt_iterator last = gsi_last (*seq_p);
380 gimplify_and_add (t, seq_p);
382 if (!gsi_end_p (last))
385 return gsi_stmt (last);
388 return gimple_seq_first_stmt (*seq_p);
391 /* Strip off a legitimate source ending from the input string NAME of
392 length LEN. Rather than having to know the names used by all of
393 our front ends, we strip off an ending of a period followed by
394 up to five characters. (Java uses ".class".) */
397 remove_suffix (char *name, int len)
401 for (i = 2; i < 8 && len > i; i++)
403 if (name[len - i] == '.')
405 name[len - i] = '\0';
411 /* Create a new temporary name with PREFIX. Return an identifier. */
413 static GTY(()) unsigned int tmp_var_id_num;
416 create_tmp_var_name (const char *prefix)
422 char *preftmp = ASTRDUP (prefix);
424 remove_suffix (preftmp, strlen (preftmp));
425 clean_symbol_name (preftmp);
430 ASM_FORMAT_PRIVATE_NAME (tmp_name, prefix ? prefix : "T", tmp_var_id_num++);
431 return get_identifier (tmp_name);
434 /* Create a new temporary variable declaration of type TYPE.
435 Do NOT push it into the current binding. */
438 create_tmp_var_raw (tree type, const char *prefix)
442 tmp_var = build_decl (input_location,
443 VAR_DECL, prefix ? create_tmp_var_name (prefix) : NULL,
446 /* The variable was declared by the compiler. */
447 DECL_ARTIFICIAL (tmp_var) = 1;
448 /* And we don't want debug info for it. */
449 DECL_IGNORED_P (tmp_var) = 1;
451 /* Make the variable writable. */
452 TREE_READONLY (tmp_var) = 0;
454 DECL_EXTERNAL (tmp_var) = 0;
455 TREE_STATIC (tmp_var) = 0;
456 TREE_USED (tmp_var) = 1;
461 /* Create a new temporary variable declaration of type TYPE. DO push the
462 variable into the current binding. Further, assume that this is called
463 only from gimplification or optimization, at which point the creation of
464 certain types are bugs. */
467 create_tmp_var (tree type, const char *prefix)
471 /* We don't allow types that are addressable (meaning we can't make copies),
472 or incomplete. We also used to reject every variable size objects here,
473 but now support those for which a constant upper bound can be obtained.
474 The processing for variable sizes is performed in gimple_add_tmp_var,
475 point at which it really matters and possibly reached via paths not going
476 through this function, e.g. after direct calls to create_tmp_var_raw. */
477 gcc_assert (!TREE_ADDRESSABLE (type) && COMPLETE_TYPE_P (type));
479 tmp_var = create_tmp_var_raw (type, prefix);
480 gimple_add_tmp_var (tmp_var);
484 /* Create a new temporary variable declaration of type TYPE by calling
485 create_tmp_var and if TYPE is a vector or a complex number, mark the new
486 temporary as gimple register. */
489 create_tmp_reg (tree type, const char *prefix)
493 tmp = create_tmp_var (type, prefix);
494 if (TREE_CODE (type) == COMPLEX_TYPE
495 || TREE_CODE (type) == VECTOR_TYPE)
496 DECL_GIMPLE_REG_P (tmp) = 1;
501 /* Create a temporary with a name derived from VAL. Subroutine of
502 lookup_tmp_var; nobody else should call this function. */
505 create_tmp_from_val (tree val)
507 /* Drop all qualifiers and address-space information from the value type. */
508 return create_tmp_var (TYPE_MAIN_VARIANT (TREE_TYPE (val)), get_name (val));
511 /* Create a temporary to hold the value of VAL. If IS_FORMAL, try to reuse
512 an existing expression temporary. */
515 lookup_tmp_var (tree val, bool is_formal)
519 /* If not optimizing, never really reuse a temporary. local-alloc
520 won't allocate any variable that is used in more than one basic
521 block, which means it will go into memory, causing much extra
522 work in reload and final and poorer code generation, outweighing
523 the extra memory allocation here. */
524 if (!optimize || !is_formal || TREE_SIDE_EFFECTS (val))
525 ret = create_tmp_from_val (val);
532 if (gimplify_ctxp->temp_htab == NULL)
533 gimplify_ctxp->temp_htab
534 = htab_create (1000, gimple_tree_hash, gimple_tree_eq, free);
535 slot = htab_find_slot (gimplify_ctxp->temp_htab, (void *)&elt, INSERT);
538 elt_p = XNEW (elt_t);
540 elt_p->temp = ret = create_tmp_from_val (val);
541 *slot = (void *) elt_p;
545 elt_p = (elt_t *) *slot;
553 /* Returns true iff T is a valid RHS for an assignment to a renamed
554 user -- or front-end generated artificial -- variable. */
557 is_gimple_reg_rhs (tree t)
559 return get_gimple_rhs_class (TREE_CODE (t)) != GIMPLE_INVALID_RHS;
562 /* Returns true iff T is a valid RHS for an assignment to an un-renamed
563 LHS, or for a call argument. */
566 is_gimple_mem_rhs (tree t)
568 /* If we're dealing with a renamable type, either source or dest must be
569 a renamed variable. */
570 if (is_gimple_reg_type (TREE_TYPE (t)))
571 return is_gimple_val (t);
573 return is_gimple_val (t) || is_gimple_lvalue (t);
576 /* Return true if T is a CALL_EXPR or an expression that can be
577 assigned to a temporary. Note that this predicate should only be
578 used during gimplification. See the rationale for this in
579 gimplify_modify_expr. */
582 is_gimple_reg_rhs_or_call (tree t)
584 return (get_gimple_rhs_class (TREE_CODE (t)) != GIMPLE_INVALID_RHS
585 || TREE_CODE (t) == CALL_EXPR);
588 /* Return true if T is a valid memory RHS or a CALL_EXPR. Note that
589 this predicate should only be used during gimplification. See the
590 rationale for this in gimplify_modify_expr. */
593 is_gimple_mem_rhs_or_call (tree t)
595 /* If we're dealing with a renamable type, either source or dest must be
596 a renamed variable. */
597 if (is_gimple_reg_type (TREE_TYPE (t)))
598 return is_gimple_val (t);
600 return (is_gimple_val (t) || is_gimple_lvalue (t)
601 || TREE_CODE (t) == CALL_EXPR);
604 /* Helper for get_formal_tmp_var and get_initialized_tmp_var. */
607 internal_get_tmp_var (tree val, gimple_seq *pre_p, gimple_seq *post_p,
612 /* Notice that we explicitly allow VAL to be a CALL_EXPR so that we
613 can create an INIT_EXPR and convert it into a GIMPLE_CALL below. */
614 gimplify_expr (&val, pre_p, post_p, is_gimple_reg_rhs_or_call,
617 t = lookup_tmp_var (val, is_formal);
620 && (TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE
621 || TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE))
622 DECL_GIMPLE_REG_P (t) = 1;
624 mod = build2 (INIT_EXPR, TREE_TYPE (t), t, unshare_expr (val));
626 SET_EXPR_LOCATION (mod, EXPR_LOC_OR_HERE (val));
628 /* gimplify_modify_expr might want to reduce this further. */
629 gimplify_and_add (mod, pre_p);
632 /* If we're gimplifying into ssa, gimplify_modify_expr will have
633 given our temporary an SSA name. Find and return it. */
634 if (gimplify_ctxp->into_ssa)
636 gimple last = gimple_seq_last_stmt (*pre_p);
637 t = gimple_get_lhs (last);
643 /* Return a formal temporary variable initialized with VAL. PRE_P is as
644 in gimplify_expr. Only use this function if:
646 1) The value of the unfactored expression represented by VAL will not
647 change between the initialization and use of the temporary, and
648 2) The temporary will not be otherwise modified.
650 For instance, #1 means that this is inappropriate for SAVE_EXPR temps,
651 and #2 means it is inappropriate for && temps.
653 For other cases, use get_initialized_tmp_var instead. */
656 get_formal_tmp_var (tree val, gimple_seq *pre_p)
658 return internal_get_tmp_var (val, pre_p, NULL, true);
661 /* Return a temporary variable initialized with VAL. PRE_P and POST_P
662 are as in gimplify_expr. */
665 get_initialized_tmp_var (tree val, gimple_seq *pre_p, gimple_seq *post_p)
667 return internal_get_tmp_var (val, pre_p, post_p, false);
670 /* Declare all the variables in VARS in SCOPE. If DEBUG_INFO is true,
671 generate debug info for them; otherwise don't. */
674 declare_vars (tree vars, gimple scope, bool debug_info)
681 gcc_assert (gimple_code (scope) == GIMPLE_BIND);
683 temps = nreverse (last);
685 block = gimple_bind_block (scope);
686 gcc_assert (!block || TREE_CODE (block) == BLOCK);
687 if (!block || !debug_info)
689 DECL_CHAIN (last) = gimple_bind_vars (scope);
690 gimple_bind_set_vars (scope, temps);
694 /* We need to attach the nodes both to the BIND_EXPR and to its
695 associated BLOCK for debugging purposes. The key point here
696 is that the BLOCK_VARS of the BIND_EXPR_BLOCK of a BIND_EXPR
697 is a subchain of the BIND_EXPR_VARS of the BIND_EXPR. */
698 if (BLOCK_VARS (block))
699 BLOCK_VARS (block) = chainon (BLOCK_VARS (block), temps);
702 gimple_bind_set_vars (scope,
703 chainon (gimple_bind_vars (scope), temps));
704 BLOCK_VARS (block) = temps;
710 /* For VAR a VAR_DECL of variable size, try to find a constant upper bound
711 for the size and adjust DECL_SIZE/DECL_SIZE_UNIT accordingly. Abort if
712 no such upper bound can be obtained. */
715 force_constant_size (tree var)
717 /* The only attempt we make is by querying the maximum size of objects
718 of the variable's type. */
720 HOST_WIDE_INT max_size;
722 gcc_assert (TREE_CODE (var) == VAR_DECL);
724 max_size = max_int_size_in_bytes (TREE_TYPE (var));
726 gcc_assert (max_size >= 0);
729 = build_int_cst (TREE_TYPE (DECL_SIZE_UNIT (var)), max_size);
731 = build_int_cst (TREE_TYPE (DECL_SIZE (var)), max_size * BITS_PER_UNIT);
734 /* Push the temporary variable TMP into the current binding. */
737 gimple_add_tmp_var (tree tmp)
739 gcc_assert (!DECL_CHAIN (tmp) && !DECL_SEEN_IN_BIND_EXPR_P (tmp));
741 /* Later processing assumes that the object size is constant, which might
742 not be true at this point. Force the use of a constant upper bound in
744 if (!host_integerp (DECL_SIZE_UNIT (tmp), 1))
745 force_constant_size (tmp);
747 DECL_CONTEXT (tmp) = current_function_decl;
748 DECL_SEEN_IN_BIND_EXPR_P (tmp) = 1;
752 DECL_CHAIN (tmp) = gimplify_ctxp->temps;
753 gimplify_ctxp->temps = tmp;
755 /* Mark temporaries local within the nearest enclosing parallel. */
756 if (gimplify_omp_ctxp)
758 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
759 while (ctx && ctx->region_type == ORT_WORKSHARE)
760 ctx = ctx->outer_context;
762 omp_add_variable (ctx, tmp, GOVD_LOCAL | GOVD_SEEN);
771 /* This case is for nested functions. We need to expose the locals
773 body_seq = gimple_body (current_function_decl);
774 declare_vars (tmp, gimple_seq_first_stmt (body_seq), false);
778 /* Determine whether to assign a location to the statement GS. */
781 should_carry_location_p (gimple gs)
783 /* Don't emit a line note for a label. We particularly don't want to
784 emit one for the break label, since it doesn't actually correspond
785 to the beginning of the loop/switch. */
786 if (gimple_code (gs) == GIMPLE_LABEL)
792 /* Return true if a location should not be emitted for this statement
793 by annotate_one_with_location. */
796 gimple_do_not_emit_location_p (gimple g)
798 return gimple_plf (g, GF_PLF_1);
801 /* Mark statement G so a location will not be emitted by
802 annotate_one_with_location. */
805 gimple_set_do_not_emit_location (gimple g)
807 /* The PLF flags are initialized to 0 when a new tuple is created,
808 so no need to initialize it anywhere. */
809 gimple_set_plf (g, GF_PLF_1, true);
812 /* Set the location for gimple statement GS to LOCATION. */
815 annotate_one_with_location (gimple gs, location_t location)
817 if (!gimple_has_location (gs)
818 && !gimple_do_not_emit_location_p (gs)
819 && should_carry_location_p (gs))
820 gimple_set_location (gs, location);
823 /* Set LOCATION for all the statements after iterator GSI in sequence
824 SEQ. If GSI is pointing to the end of the sequence, start with the
825 first statement in SEQ. */
828 annotate_all_with_location_after (gimple_seq seq, gimple_stmt_iterator gsi,
832 gsi = gsi_start (seq);
836 for (; !gsi_end_p (gsi); gsi_next (&gsi))
837 annotate_one_with_location (gsi_stmt (gsi), location);
840 /* Set the location for all the statements in a sequence STMT_P to LOCATION. */
843 annotate_all_with_location (gimple_seq stmt_p, location_t location)
845 gimple_stmt_iterator i;
847 if (gimple_seq_empty_p (stmt_p))
850 for (i = gsi_start (stmt_p); !gsi_end_p (i); gsi_next (&i))
852 gimple gs = gsi_stmt (i);
853 annotate_one_with_location (gs, location);
857 /* This page contains routines to unshare tree nodes, i.e. to duplicate tree
858 nodes that are referenced more than once in GENERIC functions. This is
859 necessary because gimplification (translation into GIMPLE) is performed
860 by modifying tree nodes in-place, so gimplication of a shared node in a
861 first context could generate an invalid GIMPLE form in a second context.
863 This is achieved with a simple mark/copy/unmark algorithm that walks the
864 GENERIC representation top-down, marks nodes with TREE_VISITED the first
865 time it encounters them, duplicates them if they already have TREE_VISITED
866 set, and finally removes the TREE_VISITED marks it has set.
868 The algorithm works only at the function level, i.e. it generates a GENERIC
869 representation of a function with no nodes shared within the function when
870 passed a GENERIC function (except for nodes that are allowed to be shared).
872 At the global level, it is also necessary to unshare tree nodes that are
873 referenced in more than one function, for the same aforementioned reason.
874 This requires some cooperation from the front-end. There are 2 strategies:
876 1. Manual unsharing. The front-end needs to call unshare_expr on every
877 expression that might end up being shared across functions.
879 2. Deep unsharing. This is an extension of regular unsharing. Instead
880 of calling unshare_expr on expressions that might be shared across
881 functions, the front-end pre-marks them with TREE_VISITED. This will
882 ensure that they are unshared on the first reference within functions
883 when the regular unsharing algorithm runs. The counterpart is that
884 this algorithm must look deeper than for manual unsharing, which is
885 specified by LANG_HOOKS_DEEP_UNSHARING.
887 If there are only few specific cases of node sharing across functions, it is
888 probably easier for a front-end to unshare the expressions manually. On the
889 contrary, if the expressions generated at the global level are as widespread
890 as expressions generated within functions, deep unsharing is very likely the
893 /* Similar to copy_tree_r but do not copy SAVE_EXPR or TARGET_EXPR nodes.
894 These nodes model computations that must be done once. If we were to
895 unshare something like SAVE_EXPR(i++), the gimplification process would
896 create wrong code. However, if DATA is non-null, it must hold a pointer
897 set that is used to unshare the subtrees of these nodes. */
900 mostly_copy_tree_r (tree *tp, int *walk_subtrees, void *data)
903 enum tree_code code = TREE_CODE (t);
905 /* Do not copy SAVE_EXPR, TARGET_EXPR or BIND_EXPR nodes themselves, but
906 copy their subtrees if we can make sure to do it only once. */
907 if (code == SAVE_EXPR || code == TARGET_EXPR || code == BIND_EXPR)
909 if (data && !pointer_set_insert ((struct pointer_set_t *)data, t))
915 /* Stop at types, decls, constants like copy_tree_r. */
916 else if (TREE_CODE_CLASS (code) == tcc_type
917 || TREE_CODE_CLASS (code) == tcc_declaration
918 || TREE_CODE_CLASS (code) == tcc_constant
919 /* We can't do anything sensible with a BLOCK used as an
920 expression, but we also can't just die when we see it
921 because of non-expression uses. So we avert our eyes
922 and cross our fingers. Silly Java. */
926 /* Cope with the statement expression extension. */
927 else if (code == STATEMENT_LIST)
930 /* Leave the bulk of the work to copy_tree_r itself. */
932 copy_tree_r (tp, walk_subtrees, NULL);
937 /* Callback for walk_tree to unshare most of the shared trees rooted at *TP.
938 If *TP has been visited already, then *TP is deeply copied by calling
939 mostly_copy_tree_r. DATA is passed to mostly_copy_tree_r unmodified. */
942 copy_if_shared_r (tree *tp, int *walk_subtrees, void *data)
945 enum tree_code code = TREE_CODE (t);
947 /* Skip types, decls, and constants. But we do want to look at their
948 types and the bounds of types. Mark them as visited so we properly
949 unmark their subtrees on the unmark pass. If we've already seen them,
950 don't look down further. */
951 if (TREE_CODE_CLASS (code) == tcc_type
952 || TREE_CODE_CLASS (code) == tcc_declaration
953 || TREE_CODE_CLASS (code) == tcc_constant)
955 if (TREE_VISITED (t))
958 TREE_VISITED (t) = 1;
961 /* If this node has been visited already, unshare it and don't look
963 else if (TREE_VISITED (t))
965 walk_tree (tp, mostly_copy_tree_r, data, NULL);
969 /* Otherwise, mark the node as visited and keep looking. */
971 TREE_VISITED (t) = 1;
976 /* Unshare most of the shared trees rooted at *TP. DATA is passed to the
977 copy_if_shared_r callback unmodified. */
980 copy_if_shared (tree *tp, void *data)
982 walk_tree (tp, copy_if_shared_r, data, NULL);
985 /* Unshare all the trees in the body of FNDECL, as well as in the bodies of
986 any nested functions. */
989 unshare_body (tree fndecl)
991 struct cgraph_node *cgn = cgraph_get_node (fndecl);
992 /* If the language requires deep unsharing, we need a pointer set to make
993 sure we don't repeatedly unshare subtrees of unshareable nodes. */
994 struct pointer_set_t *visited
995 = lang_hooks.deep_unsharing ? pointer_set_create () : NULL;
997 copy_if_shared (&DECL_SAVED_TREE (fndecl), visited);
998 copy_if_shared (&DECL_SIZE (DECL_RESULT (fndecl)), visited);
999 copy_if_shared (&DECL_SIZE_UNIT (DECL_RESULT (fndecl)), visited);
1002 pointer_set_destroy (visited);
1005 for (cgn = cgn->nested; cgn; cgn = cgn->next_nested)
1006 unshare_body (cgn->symbol.decl);
1009 /* Callback for walk_tree to unmark the visited trees rooted at *TP.
1010 Subtrees are walked until the first unvisited node is encountered. */
1013 unmark_visited_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
1017 /* If this node has been visited, unmark it and keep looking. */
1018 if (TREE_VISITED (t))
1019 TREE_VISITED (t) = 0;
1021 /* Otherwise, don't look any deeper. */
1028 /* Unmark the visited trees rooted at *TP. */
1031 unmark_visited (tree *tp)
1033 walk_tree (tp, unmark_visited_r, NULL, NULL);
1036 /* Likewise, but mark all trees as not visited. */
1039 unvisit_body (tree fndecl)
1041 struct cgraph_node *cgn = cgraph_get_node (fndecl);
1043 unmark_visited (&DECL_SAVED_TREE (fndecl));
1044 unmark_visited (&DECL_SIZE (DECL_RESULT (fndecl)));
1045 unmark_visited (&DECL_SIZE_UNIT (DECL_RESULT (fndecl)));
1048 for (cgn = cgn->nested; cgn; cgn = cgn->next_nested)
1049 unvisit_body (cgn->symbol.decl);
1052 /* Unconditionally make an unshared copy of EXPR. This is used when using
1053 stored expressions which span multiple functions, such as BINFO_VTABLE,
1054 as the normal unsharing process can't tell that they're shared. */
1057 unshare_expr (tree expr)
1059 walk_tree (&expr, mostly_copy_tree_r, NULL, NULL);
1063 /* WRAPPER is a code such as BIND_EXPR or CLEANUP_POINT_EXPR which can both
1064 contain statements and have a value. Assign its value to a temporary
1065 and give it void_type_node. Return the temporary, or NULL_TREE if
1066 WRAPPER was already void. */
1069 voidify_wrapper_expr (tree wrapper, tree temp)
1071 tree type = TREE_TYPE (wrapper);
1072 if (type && !VOID_TYPE_P (type))
1076 /* Set p to point to the body of the wrapper. Loop until we find
1077 something that isn't a wrapper. */
1078 for (p = &wrapper; p && *p; )
1080 switch (TREE_CODE (*p))
1083 TREE_SIDE_EFFECTS (*p) = 1;
1084 TREE_TYPE (*p) = void_type_node;
1085 /* For a BIND_EXPR, the body is operand 1. */
1086 p = &BIND_EXPR_BODY (*p);
1089 case CLEANUP_POINT_EXPR:
1090 case TRY_FINALLY_EXPR:
1091 case TRY_CATCH_EXPR:
1092 TREE_SIDE_EFFECTS (*p) = 1;
1093 TREE_TYPE (*p) = void_type_node;
1094 p = &TREE_OPERAND (*p, 0);
1097 case STATEMENT_LIST:
1099 tree_stmt_iterator i = tsi_last (*p);
1100 TREE_SIDE_EFFECTS (*p) = 1;
1101 TREE_TYPE (*p) = void_type_node;
1102 p = tsi_end_p (i) ? NULL : tsi_stmt_ptr (i);
1107 /* Advance to the last statement. Set all container types to
1109 for (; TREE_CODE (*p) == COMPOUND_EXPR; p = &TREE_OPERAND (*p, 1))
1111 TREE_SIDE_EFFECTS (*p) = 1;
1112 TREE_TYPE (*p) = void_type_node;
1116 case TRANSACTION_EXPR:
1117 TREE_SIDE_EFFECTS (*p) = 1;
1118 TREE_TYPE (*p) = void_type_node;
1119 p = &TRANSACTION_EXPR_BODY (*p);
1123 /* Assume that any tree upon which voidify_wrapper_expr is
1124 directly called is a wrapper, and that its body is op0. */
1127 TREE_SIDE_EFFECTS (*p) = 1;
1128 TREE_TYPE (*p) = void_type_node;
1129 p = &TREE_OPERAND (*p, 0);
1137 if (p == NULL || IS_EMPTY_STMT (*p))
1141 /* The wrapper is on the RHS of an assignment that we're pushing
1143 gcc_assert (TREE_CODE (temp) == INIT_EXPR
1144 || TREE_CODE (temp) == MODIFY_EXPR);
1145 TREE_OPERAND (temp, 1) = *p;
1150 temp = create_tmp_var (type, "retval");
1151 *p = build2 (INIT_EXPR, type, temp, *p);
1160 /* Prepare calls to builtins to SAVE and RESTORE the stack as well as
1161 a temporary through which they communicate. */
1164 build_stack_save_restore (gimple *save, gimple *restore)
1168 *save = gimple_build_call (builtin_decl_implicit (BUILT_IN_STACK_SAVE), 0);
1169 tmp_var = create_tmp_var (ptr_type_node, "saved_stack");
1170 gimple_call_set_lhs (*save, tmp_var);
1173 = gimple_build_call (builtin_decl_implicit (BUILT_IN_STACK_RESTORE),
1177 /* Gimplify a BIND_EXPR. Just voidify and recurse. */
1179 static enum gimplify_status
1180 gimplify_bind_expr (tree *expr_p, gimple_seq *pre_p)
1182 tree bind_expr = *expr_p;
1183 bool old_save_stack = gimplify_ctxp->save_stack;
1186 gimple_seq body, cleanup;
1189 tree temp = voidify_wrapper_expr (bind_expr, NULL);
1191 /* Mark variables seen in this bind expr. */
1192 for (t = BIND_EXPR_VARS (bind_expr); t ; t = DECL_CHAIN (t))
1194 if (TREE_CODE (t) == VAR_DECL)
1196 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
1198 /* Mark variable as local. */
1199 if (ctx && !DECL_EXTERNAL (t)
1200 && (! DECL_SEEN_IN_BIND_EXPR_P (t)
1201 || splay_tree_lookup (ctx->variables,
1202 (splay_tree_key) t) == NULL))
1203 omp_add_variable (gimplify_omp_ctxp, t, GOVD_LOCAL | GOVD_SEEN);
1205 DECL_SEEN_IN_BIND_EXPR_P (t) = 1;
1207 if (DECL_HARD_REGISTER (t) && !is_global_var (t) && cfun)
1208 cfun->has_local_explicit_reg_vars = true;
1211 /* Preliminarily mark non-addressed complex variables as eligible
1212 for promotion to gimple registers. We'll transform their uses
1214 if ((TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE
1215 || TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
1216 && !TREE_THIS_VOLATILE (t)
1217 && (TREE_CODE (t) == VAR_DECL && !DECL_HARD_REGISTER (t))
1218 && !needs_to_live_in_memory (t))
1219 DECL_GIMPLE_REG_P (t) = 1;
1222 gimple_bind = gimple_build_bind (BIND_EXPR_VARS (bind_expr), NULL,
1223 BIND_EXPR_BLOCK (bind_expr));
1224 gimple_push_bind_expr (gimple_bind);
1226 gimplify_ctxp->save_stack = false;
1228 /* Gimplify the body into the GIMPLE_BIND tuple's body. */
1230 gimplify_stmt (&BIND_EXPR_BODY (bind_expr), &body);
1231 gimple_bind_set_body (gimple_bind, body);
1235 if (gimplify_ctxp->save_stack)
1237 gimple stack_restore;
1239 /* Save stack on entry and restore it on exit. Add a try_finally
1240 block to achieve this. Note that mudflap depends on the
1241 format of the emitted code: see mx_register_decls(). */
1242 build_stack_save_restore (&stack_save, &stack_restore);
1244 gimplify_seq_add_stmt (&cleanup, stack_restore);
1247 /* Add clobbers for all variables that go out of scope. */
1248 for (t = BIND_EXPR_VARS (bind_expr); t ; t = DECL_CHAIN (t))
1250 if (TREE_CODE (t) == VAR_DECL
1251 && !is_global_var (t)
1252 && DECL_CONTEXT (t) == current_function_decl
1253 && !DECL_HARD_REGISTER (t)
1254 && !TREE_THIS_VOLATILE (t)
1255 && !DECL_HAS_VALUE_EXPR_P (t)
1256 /* Only care for variables that have to be in memory. Others
1257 will be rewritten into SSA names, hence moved to the top-level. */
1258 && !is_gimple_reg (t))
1260 tree clobber = build_constructor (TREE_TYPE (t), NULL);
1261 TREE_THIS_VOLATILE (clobber) = 1;
1262 gimplify_seq_add_stmt (&cleanup, gimple_build_assign (t, clobber));
1269 gimple_seq new_body;
1272 gs = gimple_build_try (gimple_bind_body (gimple_bind), cleanup,
1273 GIMPLE_TRY_FINALLY);
1276 gimplify_seq_add_stmt (&new_body, stack_save);
1277 gimplify_seq_add_stmt (&new_body, gs);
1278 gimple_bind_set_body (gimple_bind, new_body);
1281 gimplify_ctxp->save_stack = old_save_stack;
1282 gimple_pop_bind_expr ();
1284 gimplify_seq_add_stmt (pre_p, gimple_bind);
1292 *expr_p = NULL_TREE;
1296 /* Gimplify a RETURN_EXPR. If the expression to be returned is not a
1297 GIMPLE value, it is assigned to a new temporary and the statement is
1298 re-written to return the temporary.
1300 PRE_P points to the sequence where side effects that must happen before
1301 STMT should be stored. */
1303 static enum gimplify_status
1304 gimplify_return_expr (tree stmt, gimple_seq *pre_p)
1307 tree ret_expr = TREE_OPERAND (stmt, 0);
1308 tree result_decl, result;
1310 if (ret_expr == error_mark_node)
1314 || TREE_CODE (ret_expr) == RESULT_DECL
1315 || ret_expr == error_mark_node)
1317 gimple ret = gimple_build_return (ret_expr);
1318 gimple_set_no_warning (ret, TREE_NO_WARNING (stmt));
1319 gimplify_seq_add_stmt (pre_p, ret);
1323 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl))))
1324 result_decl = NULL_TREE;
1327 result_decl = TREE_OPERAND (ret_expr, 0);
1329 /* See through a return by reference. */
1330 if (TREE_CODE (result_decl) == INDIRECT_REF)
1331 result_decl = TREE_OPERAND (result_decl, 0);
1333 gcc_assert ((TREE_CODE (ret_expr) == MODIFY_EXPR
1334 || TREE_CODE (ret_expr) == INIT_EXPR)
1335 && TREE_CODE (result_decl) == RESULT_DECL);
1338 /* If aggregate_value_p is true, then we can return the bare RESULT_DECL.
1339 Recall that aggregate_value_p is FALSE for any aggregate type that is
1340 returned in registers. If we're returning values in registers, then
1341 we don't want to extend the lifetime of the RESULT_DECL, particularly
1342 across another call. In addition, for those aggregates for which
1343 hard_function_value generates a PARALLEL, we'll die during normal
1344 expansion of structure assignments; there's special code in expand_return
1345 to handle this case that does not exist in expand_expr. */
1348 else if (aggregate_value_p (result_decl, TREE_TYPE (current_function_decl)))
1350 if (TREE_CODE (DECL_SIZE (result_decl)) != INTEGER_CST)
1352 if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (result_decl)))
1353 gimplify_type_sizes (TREE_TYPE (result_decl), pre_p);
1354 /* Note that we don't use gimplify_vla_decl because the RESULT_DECL
1355 should be effectively allocated by the caller, i.e. all calls to
1356 this function must be subject to the Return Slot Optimization. */
1357 gimplify_one_sizepos (&DECL_SIZE (result_decl), pre_p);
1358 gimplify_one_sizepos (&DECL_SIZE_UNIT (result_decl), pre_p);
1360 result = result_decl;
1362 else if (gimplify_ctxp->return_temp)
1363 result = gimplify_ctxp->return_temp;
1366 result = create_tmp_reg (TREE_TYPE (result_decl), NULL);
1368 /* ??? With complex control flow (usually involving abnormal edges),
1369 we can wind up warning about an uninitialized value for this. Due
1370 to how this variable is constructed and initialized, this is never
1371 true. Give up and never warn. */
1372 TREE_NO_WARNING (result) = 1;
1374 gimplify_ctxp->return_temp = result;
1377 /* Smash the lhs of the MODIFY_EXPR to the temporary we plan to use.
1378 Then gimplify the whole thing. */
1379 if (result != result_decl)
1380 TREE_OPERAND (ret_expr, 0) = result;
1382 gimplify_and_add (TREE_OPERAND (stmt, 0), pre_p);
1384 ret = gimple_build_return (result);
1385 gimple_set_no_warning (ret, TREE_NO_WARNING (stmt));
1386 gimplify_seq_add_stmt (pre_p, ret);
1391 /* Gimplify a variable-length array DECL. */
1394 gimplify_vla_decl (tree decl, gimple_seq *seq_p)
1396 /* This is a variable-sized decl. Simplify its size and mark it
1397 for deferred expansion. Note that mudflap depends on the format
1398 of the emitted code: see mx_register_decls(). */
1399 tree t, addr, ptr_type;
1401 gimplify_one_sizepos (&DECL_SIZE (decl), seq_p);
1402 gimplify_one_sizepos (&DECL_SIZE_UNIT (decl), seq_p);
1404 /* All occurrences of this decl in final gimplified code will be
1405 replaced by indirection. Setting DECL_VALUE_EXPR does two
1406 things: First, it lets the rest of the gimplifier know what
1407 replacement to use. Second, it lets the debug info know
1408 where to find the value. */
1409 ptr_type = build_pointer_type (TREE_TYPE (decl));
1410 addr = create_tmp_var (ptr_type, get_name (decl));
1411 DECL_IGNORED_P (addr) = 0;
1412 t = build_fold_indirect_ref (addr);
1413 TREE_THIS_NOTRAP (t) = 1;
1414 SET_DECL_VALUE_EXPR (decl, t);
1415 DECL_HAS_VALUE_EXPR_P (decl) = 1;
1417 t = builtin_decl_explicit (BUILT_IN_ALLOCA_WITH_ALIGN);
1418 t = build_call_expr (t, 2, DECL_SIZE_UNIT (decl),
1419 size_int (DECL_ALIGN (decl)));
1420 /* The call has been built for a variable-sized object. */
1421 CALL_ALLOCA_FOR_VAR_P (t) = 1;
1422 t = fold_convert (ptr_type, t);
1423 t = build2 (MODIFY_EXPR, TREE_TYPE (addr), addr, t);
1425 gimplify_and_add (t, seq_p);
1427 /* Indicate that we need to restore the stack level when the
1428 enclosing BIND_EXPR is exited. */
1429 gimplify_ctxp->save_stack = true;
1432 /* Gimplify a DECL_EXPR node *STMT_P by making any necessary allocation
1433 and initialization explicit. */
1435 static enum gimplify_status
1436 gimplify_decl_expr (tree *stmt_p, gimple_seq *seq_p)
1438 tree stmt = *stmt_p;
1439 tree decl = DECL_EXPR_DECL (stmt);
1441 *stmt_p = NULL_TREE;
1443 if (TREE_TYPE (decl) == error_mark_node)
1446 if ((TREE_CODE (decl) == TYPE_DECL
1447 || TREE_CODE (decl) == VAR_DECL)
1448 && !TYPE_SIZES_GIMPLIFIED (TREE_TYPE (decl)))
1449 gimplify_type_sizes (TREE_TYPE (decl), seq_p);
1451 if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl))
1453 tree init = DECL_INITIAL (decl);
1455 if (TREE_CODE (DECL_SIZE_UNIT (decl)) != INTEGER_CST
1456 || (!TREE_STATIC (decl)
1457 && flag_stack_check == GENERIC_STACK_CHECK
1458 && compare_tree_int (DECL_SIZE_UNIT (decl),
1459 STACK_CHECK_MAX_VAR_SIZE) > 0))
1460 gimplify_vla_decl (decl, seq_p);
1462 /* Some front ends do not explicitly declare all anonymous
1463 artificial variables. We compensate here by declaring the
1464 variables, though it would be better if the front ends would
1465 explicitly declare them. */
1466 if (!DECL_SEEN_IN_BIND_EXPR_P (decl)
1467 && DECL_ARTIFICIAL (decl) && DECL_NAME (decl) == NULL_TREE)
1468 gimple_add_tmp_var (decl);
1470 if (init && init != error_mark_node)
1472 if (!TREE_STATIC (decl))
1474 DECL_INITIAL (decl) = NULL_TREE;
1475 init = build2 (INIT_EXPR, void_type_node, decl, init);
1476 gimplify_and_add (init, seq_p);
1480 /* We must still examine initializers for static variables
1481 as they may contain a label address. */
1482 walk_tree (&init, force_labels_r, NULL, NULL);
1489 /* Gimplify a LOOP_EXPR. Normally this just involves gimplifying the body
1490 and replacing the LOOP_EXPR with goto, but if the loop contains an
1491 EXIT_EXPR, we need to append a label for it to jump to. */
1493 static enum gimplify_status
1494 gimplify_loop_expr (tree *expr_p, gimple_seq *pre_p)
1496 tree saved_label = gimplify_ctxp->exit_label;
1497 tree start_label = create_artificial_label (UNKNOWN_LOCATION);
1499 gimplify_seq_add_stmt (pre_p, gimple_build_label (start_label));
1501 gimplify_ctxp->exit_label = NULL_TREE;
1503 gimplify_and_add (LOOP_EXPR_BODY (*expr_p), pre_p);
1505 gimplify_seq_add_stmt (pre_p, gimple_build_goto (start_label));
1507 if (gimplify_ctxp->exit_label)
1508 gimplify_seq_add_stmt (pre_p,
1509 gimple_build_label (gimplify_ctxp->exit_label));
1511 gimplify_ctxp->exit_label = saved_label;
1517 /* Gimplify a statement list onto a sequence. These may be created either
1518 by an enlightened front-end, or by shortcut_cond_expr. */
1520 static enum gimplify_status
1521 gimplify_statement_list (tree *expr_p, gimple_seq *pre_p)
1523 tree temp = voidify_wrapper_expr (*expr_p, NULL);
1525 tree_stmt_iterator i = tsi_start (*expr_p);
1527 while (!tsi_end_p (i))
1529 gimplify_stmt (tsi_stmt_ptr (i), pre_p);
1542 /* Compare two case labels. Because the front end should already have
1543 made sure that case ranges do not overlap, it is enough to only compare
1544 the CASE_LOW values of each case label. */
1547 compare_case_labels (const void *p1, const void *p2)
1549 const_tree const case1 = *(const_tree const*)p1;
1550 const_tree const case2 = *(const_tree const*)p2;
1552 /* The 'default' case label always goes first. */
1553 if (!CASE_LOW (case1))
1555 else if (!CASE_LOW (case2))
1558 return tree_int_cst_compare (CASE_LOW (case1), CASE_LOW (case2));
1561 /* Sort the case labels in LABEL_VEC in place in ascending order. */
1564 sort_case_labels (VEC(tree,heap)* label_vec)
1566 VEC_qsort (tree, label_vec, compare_case_labels);
1569 /* Gimplify a SWITCH_EXPR, and collect a TREE_VEC of the labels it can
1572 static enum gimplify_status
1573 gimplify_switch_expr (tree *expr_p, gimple_seq *pre_p)
1575 tree switch_expr = *expr_p;
1576 gimple_seq switch_body_seq = NULL;
1577 enum gimplify_status ret;
1578 tree index_type = TREE_TYPE (switch_expr);
1579 if (index_type == NULL_TREE)
1580 index_type = TREE_TYPE (SWITCH_COND (switch_expr));
1582 ret = gimplify_expr (&SWITCH_COND (switch_expr), pre_p, NULL, is_gimple_val,
1584 if (ret == GS_ERROR || ret == GS_UNHANDLED)
1587 if (SWITCH_BODY (switch_expr))
1589 VEC (tree,heap) *labels;
1590 VEC (tree,heap) *saved_labels;
1591 tree min_value, max_value;
1592 tree default_case = NULL_TREE;
1594 gimple gimple_switch;
1596 /* If someone can be bothered to fill in the labels, they can
1597 be bothered to null out the body too. */
1598 gcc_assert (!SWITCH_LABELS (switch_expr));
1600 /* Save old labels, get new ones from body, then restore the old
1601 labels. Save all the things from the switch body to append after. */
1602 saved_labels = gimplify_ctxp->case_labels;
1603 gimplify_ctxp->case_labels = VEC_alloc (tree, heap, 8);
1605 gimplify_stmt (&SWITCH_BODY (switch_expr), &switch_body_seq);
1606 labels = gimplify_ctxp->case_labels;
1607 gimplify_ctxp->case_labels = saved_labels;
1610 min_value = TYPE_MIN_VALUE (index_type);
1611 max_value = TYPE_MAX_VALUE (index_type);
1612 while (i < VEC_length (tree, labels))
1614 tree elt = VEC_index (tree, labels, i);
1615 tree low = CASE_LOW (elt);
1616 tree high = CASE_HIGH (elt);
1617 bool remove_element = FALSE;
1622 gcc_checking_assert (TREE_CODE (low) == INTEGER_CST);
1623 gcc_checking_assert (!high || TREE_CODE (high) == INTEGER_CST);
1625 /* This is a non-default case label, i.e. it has a value.
1627 See if the case label is reachable within the range of
1628 the index type. Remove out-of-range case values. Turn
1629 case ranges into a canonical form (high > low strictly)
1630 and convert the case label values to the index type.
1632 NB: The type of gimple_switch_index() may be the promoted
1633 type, but the case labels retain the original type. */
1637 /* This is a case range. Discard empty ranges.
1638 If the bounds or the range are equal, turn this
1639 into a simple (one-value) case. */
1640 int cmp = tree_int_cst_compare (high, low);
1642 remove_element = TRUE;
1649 /* If the simple case value is unreachable, ignore it. */
1650 if ((TREE_CODE (min_value) == INTEGER_CST
1651 && tree_int_cst_compare (low, min_value) < 0)
1652 || (TREE_CODE (max_value) == INTEGER_CST
1653 && tree_int_cst_compare (low, max_value) > 0))
1654 remove_element = TRUE;
1656 low = fold_convert (index_type, low);
1660 /* If the entire case range is unreachable, ignore it. */
1661 if ((TREE_CODE (min_value) == INTEGER_CST
1662 && tree_int_cst_compare (high, min_value) < 0)
1663 || (TREE_CODE (max_value) == INTEGER_CST
1664 && tree_int_cst_compare (low, max_value) > 0))
1665 remove_element = TRUE;
1668 /* If the lower bound is less than the index type's
1669 minimum value, truncate the range bounds. */
1670 if (TREE_CODE (min_value) == INTEGER_CST
1671 && tree_int_cst_compare (low, min_value) < 0)
1673 low = fold_convert (index_type, low);
1675 /* If the upper bound is greater than the index type's
1676 maximum value, truncate the range bounds. */
1677 if (TREE_CODE (max_value) == INTEGER_CST
1678 && tree_int_cst_compare (high, max_value) > 0)
1680 high = fold_convert (index_type, high);
1684 CASE_LOW (elt) = low;
1685 CASE_HIGH (elt) = high;
1689 /* The default case must be the last label in the list. */
1690 gcc_assert (!default_case);
1692 remove_element = TRUE;
1696 VEC_ordered_remove (tree, labels, i);
1702 if (!VEC_empty (tree, labels))
1703 sort_case_labels (labels);
1707 /* If the switch has no default label, add one, so that we jump
1708 around the switch body. If the labels already cover the whole
1709 range of the switch index_type, add the default label pointing
1710 to one of the existing labels. */
1712 && TYPE_MIN_VALUE (index_type)
1713 && TYPE_MAX_VALUE (index_type)
1714 && tree_int_cst_equal (CASE_LOW (VEC_index (tree, labels, 0)),
1715 TYPE_MIN_VALUE (index_type)))
1717 tree low, high = CASE_HIGH (VEC_index (tree, labels, len - 1));
1719 high = CASE_LOW (VEC_index (tree, labels, len - 1));
1720 if (tree_int_cst_equal (high, TYPE_MAX_VALUE (index_type)))
1722 for (i = 1; i < len; i++)
1724 high = CASE_LOW (VEC_index (tree, labels, i));
1725 low = CASE_HIGH (VEC_index (tree, labels, i - 1));
1727 low = CASE_LOW (VEC_index (tree, labels, i - 1));
1728 if ((TREE_INT_CST_LOW (low) + 1
1729 != TREE_INT_CST_LOW (high))
1730 || (TREE_INT_CST_HIGH (low)
1731 + (TREE_INT_CST_LOW (high) == 0)
1732 != TREE_INT_CST_HIGH (high)))
1737 tree label = CASE_LABEL (VEC_index (tree, labels, 0));
1738 default_case = build_case_label (NULL_TREE, NULL_TREE,
1749 = build_case_label (NULL_TREE, NULL_TREE,
1750 create_artificial_label (UNKNOWN_LOCATION));
1751 new_default = gimple_build_label (CASE_LABEL (default_case));
1752 gimplify_seq_add_stmt (&switch_body_seq, new_default);
1756 gimple_switch = gimple_build_switch_vec (SWITCH_COND (switch_expr),
1757 default_case, labels);
1758 gimplify_seq_add_stmt (pre_p, gimple_switch);
1759 gimplify_seq_add_seq (pre_p, switch_body_seq);
1760 VEC_free(tree, heap, labels);
1763 gcc_assert (SWITCH_LABELS (switch_expr));
1768 /* Gimplify the CASE_LABEL_EXPR pointed to by EXPR_P. */
1770 static enum gimplify_status
1771 gimplify_case_label_expr (tree *expr_p, gimple_seq *pre_p)
1773 struct gimplify_ctx *ctxp;
1774 gimple gimple_label;
1776 /* Invalid OpenMP programs can play Duff's Device type games with
1777 #pragma omp parallel. At least in the C front end, we don't
1778 detect such invalid branches until after gimplification. */
1779 for (ctxp = gimplify_ctxp; ; ctxp = ctxp->prev_context)
1780 if (ctxp->case_labels)
1783 gimple_label = gimple_build_label (CASE_LABEL (*expr_p));
1784 VEC_safe_push (tree, heap, ctxp->case_labels, *expr_p);
1785 gimplify_seq_add_stmt (pre_p, gimple_label);
1790 /* Build a GOTO to the LABEL_DECL pointed to by LABEL_P, building it first
1794 build_and_jump (tree *label_p)
1796 if (label_p == NULL)
1797 /* If there's nowhere to jump, just fall through. */
1800 if (*label_p == NULL_TREE)
1802 tree label = create_artificial_label (UNKNOWN_LOCATION);
1806 return build1 (GOTO_EXPR, void_type_node, *label_p);
1809 /* Gimplify an EXIT_EXPR by converting to a GOTO_EXPR inside a COND_EXPR.
1810 This also involves building a label to jump to and communicating it to
1811 gimplify_loop_expr through gimplify_ctxp->exit_label. */
1813 static enum gimplify_status
1814 gimplify_exit_expr (tree *expr_p)
1816 tree cond = TREE_OPERAND (*expr_p, 0);
1819 expr = build_and_jump (&gimplify_ctxp->exit_label);
1820 expr = build3 (COND_EXPR, void_type_node, cond, expr, NULL_TREE);
1826 /* A helper function to be called via walk_tree. Mark all labels under *TP
1827 as being forced. To be called for DECL_INITIAL of static variables. */
1830 force_labels_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
1834 if (TREE_CODE (*tp) == LABEL_DECL)
1835 FORCED_LABEL (*tp) = 1;
1840 /* *EXPR_P is a COMPONENT_REF being used as an rvalue. If its type is
1841 different from its canonical type, wrap the whole thing inside a
1842 NOP_EXPR and force the type of the COMPONENT_REF to be the canonical
1845 The canonical type of a COMPONENT_REF is the type of the field being
1846 referenced--unless the field is a bit-field which can be read directly
1847 in a smaller mode, in which case the canonical type is the
1848 sign-appropriate type corresponding to that mode. */
1851 canonicalize_component_ref (tree *expr_p)
1853 tree expr = *expr_p;
1856 gcc_assert (TREE_CODE (expr) == COMPONENT_REF);
1858 if (INTEGRAL_TYPE_P (TREE_TYPE (expr)))
1859 type = TREE_TYPE (get_unwidened (expr, NULL_TREE));
1861 type = TREE_TYPE (TREE_OPERAND (expr, 1));
1863 /* One could argue that all the stuff below is not necessary for
1864 the non-bitfield case and declare it a FE error if type
1865 adjustment would be needed. */
1866 if (TREE_TYPE (expr) != type)
1868 #ifdef ENABLE_TYPES_CHECKING
1869 tree old_type = TREE_TYPE (expr);
1873 /* We need to preserve qualifiers and propagate them from
1875 type_quals = TYPE_QUALS (type)
1876 | TYPE_QUALS (TREE_TYPE (TREE_OPERAND (expr, 0)));
1877 if (TYPE_QUALS (type) != type_quals)
1878 type = build_qualified_type (TYPE_MAIN_VARIANT (type), type_quals);
1880 /* Set the type of the COMPONENT_REF to the underlying type. */
1881 TREE_TYPE (expr) = type;
1883 #ifdef ENABLE_TYPES_CHECKING
1884 /* It is now a FE error, if the conversion from the canonical
1885 type to the original expression type is not useless. */
1886 gcc_assert (useless_type_conversion_p (old_type, type));
1891 /* If a NOP conversion is changing a pointer to array of foo to a pointer
1892 to foo, embed that change in the ADDR_EXPR by converting
1897 where L is the lower bound. For simplicity, only do this for constant
1899 The constraint is that the type of &array[L] is trivially convertible
1903 canonicalize_addr_expr (tree *expr_p)
1905 tree expr = *expr_p;
1906 tree addr_expr = TREE_OPERAND (expr, 0);
1907 tree datype, ddatype, pddatype;
1909 /* We simplify only conversions from an ADDR_EXPR to a pointer type. */
1910 if (!POINTER_TYPE_P (TREE_TYPE (expr))
1911 || TREE_CODE (addr_expr) != ADDR_EXPR)
1914 /* The addr_expr type should be a pointer to an array. */
1915 datype = TREE_TYPE (TREE_TYPE (addr_expr));
1916 if (TREE_CODE (datype) != ARRAY_TYPE)
1919 /* The pointer to element type shall be trivially convertible to
1920 the expression pointer type. */
1921 ddatype = TREE_TYPE (datype);
1922 pddatype = build_pointer_type (ddatype);
1923 if (!useless_type_conversion_p (TYPE_MAIN_VARIANT (TREE_TYPE (expr)),
1927 /* The lower bound and element sizes must be constant. */
1928 if (!TYPE_SIZE_UNIT (ddatype)
1929 || TREE_CODE (TYPE_SIZE_UNIT (ddatype)) != INTEGER_CST
1930 || !TYPE_DOMAIN (datype) || !TYPE_MIN_VALUE (TYPE_DOMAIN (datype))
1931 || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (datype))) != INTEGER_CST)
1934 /* All checks succeeded. Build a new node to merge the cast. */
1935 *expr_p = build4 (ARRAY_REF, ddatype, TREE_OPERAND (addr_expr, 0),
1936 TYPE_MIN_VALUE (TYPE_DOMAIN (datype)),
1937 NULL_TREE, NULL_TREE);
1938 *expr_p = build1 (ADDR_EXPR, pddatype, *expr_p);
1940 /* We can have stripped a required restrict qualifier above. */
1941 if (!useless_type_conversion_p (TREE_TYPE (expr), TREE_TYPE (*expr_p)))
1942 *expr_p = fold_convert (TREE_TYPE (expr), *expr_p);
1945 /* *EXPR_P is a NOP_EXPR or CONVERT_EXPR. Remove it and/or other conversions
1946 underneath as appropriate. */
1948 static enum gimplify_status
1949 gimplify_conversion (tree *expr_p)
1951 location_t loc = EXPR_LOCATION (*expr_p);
1952 gcc_assert (CONVERT_EXPR_P (*expr_p));
1954 /* Then strip away all but the outermost conversion. */
1955 STRIP_SIGN_NOPS (TREE_OPERAND (*expr_p, 0));
1957 /* And remove the outermost conversion if it's useless. */
1958 if (tree_ssa_useless_type_conversion (*expr_p))
1959 *expr_p = TREE_OPERAND (*expr_p, 0);
1961 /* If we still have a conversion at the toplevel,
1962 then canonicalize some constructs. */
1963 if (CONVERT_EXPR_P (*expr_p))
1965 tree sub = TREE_OPERAND (*expr_p, 0);
1967 /* If a NOP conversion is changing the type of a COMPONENT_REF
1968 expression, then canonicalize its type now in order to expose more
1969 redundant conversions. */
1970 if (TREE_CODE (sub) == COMPONENT_REF)
1971 canonicalize_component_ref (&TREE_OPERAND (*expr_p, 0));
1973 /* If a NOP conversion is changing a pointer to array of foo
1974 to a pointer to foo, embed that change in the ADDR_EXPR. */
1975 else if (TREE_CODE (sub) == ADDR_EXPR)
1976 canonicalize_addr_expr (expr_p);
1979 /* If we have a conversion to a non-register type force the
1980 use of a VIEW_CONVERT_EXPR instead. */
1981 if (CONVERT_EXPR_P (*expr_p) && !is_gimple_reg_type (TREE_TYPE (*expr_p)))
1982 *expr_p = fold_build1_loc (loc, VIEW_CONVERT_EXPR, TREE_TYPE (*expr_p),
1983 TREE_OPERAND (*expr_p, 0));
1988 /* Nonlocal VLAs seen in the current function. */
1989 static struct pointer_set_t *nonlocal_vlas;
1991 /* Gimplify a VAR_DECL or PARM_DECL. Return GS_OK if we expanded a
1992 DECL_VALUE_EXPR, and it's worth re-examining things. */
1994 static enum gimplify_status
1995 gimplify_var_or_parm_decl (tree *expr_p)
1997 tree decl = *expr_p;
1999 /* ??? If this is a local variable, and it has not been seen in any
2000 outer BIND_EXPR, then it's probably the result of a duplicate
2001 declaration, for which we've already issued an error. It would
2002 be really nice if the front end wouldn't leak these at all.
2003 Currently the only known culprit is C++ destructors, as seen
2004 in g++.old-deja/g++.jason/binding.C. */
2005 if (TREE_CODE (decl) == VAR_DECL
2006 && !DECL_SEEN_IN_BIND_EXPR_P (decl)
2007 && !TREE_STATIC (decl) && !DECL_EXTERNAL (decl)
2008 && decl_function_context (decl) == current_function_decl)
2010 gcc_assert (seen_error ());
2014 /* When within an OpenMP context, notice uses of variables. */
2015 if (gimplify_omp_ctxp && omp_notice_variable (gimplify_omp_ctxp, decl, true))
2018 /* If the decl is an alias for another expression, substitute it now. */
2019 if (DECL_HAS_VALUE_EXPR_P (decl))
2021 tree value_expr = DECL_VALUE_EXPR (decl);
2023 /* For referenced nonlocal VLAs add a decl for debugging purposes
2024 to the current function. */
2025 if (TREE_CODE (decl) == VAR_DECL
2026 && TREE_CODE (DECL_SIZE_UNIT (decl)) != INTEGER_CST
2027 && nonlocal_vlas != NULL
2028 && TREE_CODE (value_expr) == INDIRECT_REF
2029 && TREE_CODE (TREE_OPERAND (value_expr, 0)) == VAR_DECL
2030 && decl_function_context (decl) != current_function_decl)
2032 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
2033 while (ctx && ctx->region_type == ORT_WORKSHARE)
2034 ctx = ctx->outer_context;
2035 if (!ctx && !pointer_set_insert (nonlocal_vlas, decl))
2037 tree copy = copy_node (decl), block;
2039 lang_hooks.dup_lang_specific_decl (copy);
2040 SET_DECL_RTL (copy, 0);
2041 TREE_USED (copy) = 1;
2042 block = DECL_INITIAL (current_function_decl);
2043 DECL_CHAIN (copy) = BLOCK_VARS (block);
2044 BLOCK_VARS (block) = copy;
2045 SET_DECL_VALUE_EXPR (copy, unshare_expr (value_expr));
2046 DECL_HAS_VALUE_EXPR_P (copy) = 1;
2050 *expr_p = unshare_expr (value_expr);
2057 /* Gimplify the COMPONENT_REF, ARRAY_REF, REALPART_EXPR or IMAGPART_EXPR
2061 : min_lval '[' val ']'
2063 | compound_lval '[' val ']'
2064 | compound_lval '.' ID
2066 This is not part of the original SIMPLE definition, which separates
2067 array and member references, but it seems reasonable to handle them
2068 together. Also, this way we don't run into problems with union
2069 aliasing; gcc requires that for accesses through a union to alias, the
2070 union reference must be explicit, which was not always the case when we
2071 were splitting up array and member refs.
2073 PRE_P points to the sequence where side effects that must happen before
2074 *EXPR_P should be stored.
2076 POST_P points to the sequence where side effects that must happen after
2077 *EXPR_P should be stored. */
2079 static enum gimplify_status
2080 gimplify_compound_lval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
2081 fallback_t fallback)
2084 VEC(tree,heap) *stack;
2085 enum gimplify_status ret = GS_ALL_DONE, tret;
2087 location_t loc = EXPR_LOCATION (*expr_p);
2088 tree expr = *expr_p;
2090 /* Create a stack of the subexpressions so later we can walk them in
2091 order from inner to outer. */
2092 stack = VEC_alloc (tree, heap, 10);
2094 /* We can handle anything that get_inner_reference can deal with. */
2095 for (p = expr_p; ; p = &TREE_OPERAND (*p, 0))
2098 /* Fold INDIRECT_REFs now to turn them into ARRAY_REFs. */
2099 if (TREE_CODE (*p) == INDIRECT_REF)
2100 *p = fold_indirect_ref_loc (loc, *p);
2102 if (handled_component_p (*p))
2104 /* Expand DECL_VALUE_EXPR now. In some cases that may expose
2105 additional COMPONENT_REFs. */
2106 else if ((TREE_CODE (*p) == VAR_DECL || TREE_CODE (*p) == PARM_DECL)
2107 && gimplify_var_or_parm_decl (p) == GS_OK)
2112 VEC_safe_push (tree, heap, stack, *p);
2115 gcc_assert (VEC_length (tree, stack));
2117 /* Now STACK is a stack of pointers to all the refs we've walked through
2118 and P points to the innermost expression.
2120 Java requires that we elaborated nodes in source order. That
2121 means we must gimplify the inner expression followed by each of
2122 the indices, in order. But we can't gimplify the inner
2123 expression until we deal with any variable bounds, sizes, or
2124 positions in order to deal with PLACEHOLDER_EXPRs.
2126 So we do this in three steps. First we deal with the annotations
2127 for any variables in the components, then we gimplify the base,
2128 then we gimplify any indices, from left to right. */
2129 for (i = VEC_length (tree, stack) - 1; i >= 0; i--)
2131 tree t = VEC_index (tree, stack, i);
2133 if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
2135 /* Gimplify the low bound and element type size and put them into
2136 the ARRAY_REF. If these values are set, they have already been
2138 if (TREE_OPERAND (t, 2) == NULL_TREE)
2140 tree low = unshare_expr (array_ref_low_bound (t));
2141 if (!is_gimple_min_invariant (low))
2143 TREE_OPERAND (t, 2) = low;
2144 tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p,
2145 post_p, is_gimple_reg,
2147 ret = MIN (ret, tret);
2152 tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p,
2153 is_gimple_reg, fb_rvalue);
2154 ret = MIN (ret, tret);
2157 if (TREE_OPERAND (t, 3) == NULL_TREE)
2159 tree elmt_type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (t, 0)));
2160 tree elmt_size = unshare_expr (array_ref_element_size (t));
2161 tree factor = size_int (TYPE_ALIGN_UNIT (elmt_type));
2163 /* Divide the element size by the alignment of the element
2166 = size_binop_loc (loc, EXACT_DIV_EXPR, elmt_size, factor);
2168 if (!is_gimple_min_invariant (elmt_size))
2170 TREE_OPERAND (t, 3) = elmt_size;
2171 tret = gimplify_expr (&TREE_OPERAND (t, 3), pre_p,
2172 post_p, is_gimple_reg,
2174 ret = MIN (ret, tret);
2179 tret = gimplify_expr (&TREE_OPERAND (t, 3), pre_p, post_p,
2180 is_gimple_reg, fb_rvalue);
2181 ret = MIN (ret, tret);
2184 else if (TREE_CODE (t) == COMPONENT_REF)
2186 /* Set the field offset into T and gimplify it. */
2187 if (TREE_OPERAND (t, 2) == NULL_TREE)
2189 tree offset = unshare_expr (component_ref_field_offset (t));
2190 tree field = TREE_OPERAND (t, 1);
2192 = size_int (DECL_OFFSET_ALIGN (field) / BITS_PER_UNIT);
2194 /* Divide the offset by its alignment. */
2195 offset = size_binop_loc (loc, EXACT_DIV_EXPR, offset, factor);
2197 if (!is_gimple_min_invariant (offset))
2199 TREE_OPERAND (t, 2) = offset;
2200 tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p,
2201 post_p, is_gimple_reg,
2203 ret = MIN (ret, tret);
2208 tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p,
2209 is_gimple_reg, fb_rvalue);
2210 ret = MIN (ret, tret);
2215 /* Step 2 is to gimplify the base expression. Make sure lvalue is set
2216 so as to match the min_lval predicate. Failure to do so may result
2217 in the creation of large aggregate temporaries. */
2218 tret = gimplify_expr (p, pre_p, post_p, is_gimple_min_lval,
2219 fallback | fb_lvalue);
2220 ret = MIN (ret, tret);
2222 /* And finally, the indices and operands to BIT_FIELD_REF. During this
2223 loop we also remove any useless conversions. */
2224 for (; VEC_length (tree, stack) > 0; )
2226 tree t = VEC_pop (tree, stack);
2228 if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
2230 /* Gimplify the dimension. */
2231 if (!is_gimple_min_invariant (TREE_OPERAND (t, 1)))
2233 tret = gimplify_expr (&TREE_OPERAND (t, 1), pre_p, post_p,
2234 is_gimple_val, fb_rvalue);
2235 ret = MIN (ret, tret);
2238 else if (TREE_CODE (t) == BIT_FIELD_REF)
2240 tret = gimplify_expr (&TREE_OPERAND (t, 1), pre_p, post_p,
2241 is_gimple_val, fb_rvalue);
2242 ret = MIN (ret, tret);
2243 tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p,
2244 is_gimple_val, fb_rvalue);
2245 ret = MIN (ret, tret);
2248 STRIP_USELESS_TYPE_CONVERSION (TREE_OPERAND (t, 0));
2250 /* The innermost expression P may have originally had
2251 TREE_SIDE_EFFECTS set which would have caused all the outer
2252 expressions in *EXPR_P leading to P to also have had
2253 TREE_SIDE_EFFECTS set. */
2254 recalculate_side_effects (t);
2257 /* If the outermost expression is a COMPONENT_REF, canonicalize its type. */
2258 if ((fallback & fb_rvalue) && TREE_CODE (*expr_p) == COMPONENT_REF)
2260 canonicalize_component_ref (expr_p);
2263 VEC_free (tree, heap, stack);
2265 gcc_assert (*expr_p == expr || ret != GS_ALL_DONE);
2270 /* Gimplify the self modifying expression pointed to by EXPR_P
2273 PRE_P points to the list where side effects that must happen before
2274 *EXPR_P should be stored.
2276 POST_P points to the list where side effects that must happen after
2277 *EXPR_P should be stored.
2279 WANT_VALUE is nonzero iff we want to use the value of this expression
2280 in another expression. */
2282 static enum gimplify_status
2283 gimplify_self_mod_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
2286 enum tree_code code;
2287 tree lhs, lvalue, rhs, t1;
2288 gimple_seq post = NULL, *orig_post_p = post_p;
2290 enum tree_code arith_code;
2291 enum gimplify_status ret;
2292 location_t loc = EXPR_LOCATION (*expr_p);
2294 code = TREE_CODE (*expr_p);
2296 gcc_assert (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR
2297 || code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR);
2299 /* Prefix or postfix? */
2300 if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
2301 /* Faster to treat as prefix if result is not used. */
2302 postfix = want_value;
2306 /* For postfix, make sure the inner expression's post side effects
2307 are executed after side effects from this expression. */
2311 /* Add or subtract? */
2312 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
2313 arith_code = PLUS_EXPR;
2315 arith_code = MINUS_EXPR;
2317 /* Gimplify the LHS into a GIMPLE lvalue. */
2318 lvalue = TREE_OPERAND (*expr_p, 0);
2319 ret = gimplify_expr (&lvalue, pre_p, post_p, is_gimple_lvalue, fb_lvalue);
2320 if (ret == GS_ERROR)
2323 /* Extract the operands to the arithmetic operation. */
2325 rhs = TREE_OPERAND (*expr_p, 1);
2327 /* For postfix operator, we evaluate the LHS to an rvalue and then use
2328 that as the result value and in the postqueue operation. We also
2329 make sure to make lvalue a minimal lval, see
2330 gcc.c-torture/execute/20040313-1.c for an example where this matters. */
2333 if (!is_gimple_min_lval (lvalue))
2335 mark_addressable (lvalue);
2336 lvalue = build_fold_addr_expr_loc (input_location, lvalue);
2337 gimplify_expr (&lvalue, pre_p, post_p, is_gimple_val, fb_rvalue);
2338 lvalue = build_fold_indirect_ref_loc (input_location, lvalue);
2340 ret = gimplify_expr (&lhs, pre_p, post_p, is_gimple_val, fb_rvalue);
2341 if (ret == GS_ERROR)
2345 /* For POINTERs increment, use POINTER_PLUS_EXPR. */
2346 if (POINTER_TYPE_P (TREE_TYPE (lhs)))
2348 rhs = convert_to_ptrofftype_loc (loc, rhs);
2349 if (arith_code == MINUS_EXPR)
2350 rhs = fold_build1_loc (loc, NEGATE_EXPR, TREE_TYPE (rhs), rhs);
2351 arith_code = POINTER_PLUS_EXPR;
2356 tree t2 = get_initialized_tmp_var (lhs, pre_p, NULL);
2357 t1 = build2 (arith_code, TREE_TYPE (*expr_p), t2, rhs);
2358 gimplify_assign (lvalue, t1, pre_p);
2359 gimplify_seq_add_seq (orig_post_p, post);
2365 t1 = build2 (arith_code, TREE_TYPE (*expr_p), lhs, rhs);
2366 *expr_p = build2 (MODIFY_EXPR, TREE_TYPE (lvalue), lvalue, t1);
2371 /* If *EXPR_P has a variable sized type, wrap it in a WITH_SIZE_EXPR. */
2374 maybe_with_size_expr (tree *expr_p)
2376 tree expr = *expr_p;
2377 tree type = TREE_TYPE (expr);
2380 /* If we've already wrapped this or the type is error_mark_node, we can't do
2382 if (TREE_CODE (expr) == WITH_SIZE_EXPR
2383 || type == error_mark_node)
2386 /* If the size isn't known or is a constant, we have nothing to do. */
2387 size = TYPE_SIZE_UNIT (type);
2388 if (!size || TREE_CODE (size) == INTEGER_CST)
2391 /* Otherwise, make a WITH_SIZE_EXPR. */
2392 size = unshare_expr (size);
2393 size = SUBSTITUTE_PLACEHOLDER_IN_EXPR (size, expr);
2394 *expr_p = build2 (WITH_SIZE_EXPR, type, expr, size);
2397 /* Helper for gimplify_call_expr. Gimplify a single argument *ARG_P
2398 Store any side-effects in PRE_P. CALL_LOCATION is the location of
2401 static enum gimplify_status
2402 gimplify_arg (tree *arg_p, gimple_seq *pre_p, location_t call_location)
2404 bool (*test) (tree);
2407 /* In general, we allow lvalues for function arguments to avoid
2408 extra overhead of copying large aggregates out of even larger
2409 aggregates into temporaries only to copy the temporaries to
2410 the argument list. Make optimizers happy by pulling out to
2411 temporaries those types that fit in registers. */
2412 if (is_gimple_reg_type (TREE_TYPE (*arg_p)))
2413 test = is_gimple_val, fb = fb_rvalue;
2416 test = is_gimple_lvalue, fb = fb_either;
2417 /* Also strip a TARGET_EXPR that would force an extra copy. */
2418 if (TREE_CODE (*arg_p) == TARGET_EXPR)
2420 tree init = TARGET_EXPR_INITIAL (*arg_p);
2422 && !VOID_TYPE_P (TREE_TYPE (init)))
2427 /* If this is a variable sized type, we must remember the size. */
2428 maybe_with_size_expr (arg_p);
2430 /* FIXME diagnostics: This will mess up gcc.dg/Warray-bounds.c. */
2431 /* Make sure arguments have the same location as the function call
2433 protected_set_expr_location (*arg_p, call_location);
2435 /* There is a sequence point before a function call. Side effects in
2436 the argument list must occur before the actual call. So, when
2437 gimplifying arguments, force gimplify_expr to use an internal
2438 post queue which is then appended to the end of PRE_P. */
2439 return gimplify_expr (arg_p, pre_p, NULL, test, fb);
2442 /* Gimplify the CALL_EXPR node *EXPR_P into the GIMPLE sequence PRE_P.
2443 WANT_VALUE is true if the result of the call is desired. */
2445 static enum gimplify_status
2446 gimplify_call_expr (tree *expr_p, gimple_seq *pre_p, bool want_value)
2448 tree fndecl, parms, p, fnptrtype;
2449 enum gimplify_status ret;
2452 bool builtin_va_start_p = FALSE;
2453 location_t loc = EXPR_LOCATION (*expr_p);
2455 gcc_assert (TREE_CODE (*expr_p) == CALL_EXPR);
2457 /* For reliable diagnostics during inlining, it is necessary that
2458 every call_expr be annotated with file and line. */
2459 if (! EXPR_HAS_LOCATION (*expr_p))
2460 SET_EXPR_LOCATION (*expr_p, input_location);
2462 /* This may be a call to a builtin function.
2464 Builtin function calls may be transformed into different
2465 (and more efficient) builtin function calls under certain
2466 circumstances. Unfortunately, gimplification can muck things
2467 up enough that the builtin expanders are not aware that certain
2468 transformations are still valid.
2470 So we attempt transformation/gimplification of the call before
2471 we gimplify the CALL_EXPR. At this time we do not manage to
2472 transform all calls in the same manner as the expanders do, but
2473 we do transform most of them. */
2474 fndecl = get_callee_fndecl (*expr_p);
2475 if (fndecl && DECL_BUILT_IN (fndecl))
2477 tree new_tree = fold_call_expr (input_location, *expr_p, !want_value);
2479 if (new_tree && new_tree != *expr_p)
2481 /* There was a transformation of this call which computes the
2482 same value, but in a more efficient way. Return and try
2488 if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
2489 && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_VA_START)
2491 builtin_va_start_p = TRUE;
2492 if (call_expr_nargs (*expr_p) < 2)
2494 error ("too few arguments to function %<va_start%>");
2495 *expr_p = build_empty_stmt (EXPR_LOCATION (*expr_p));
2499 if (fold_builtin_next_arg (*expr_p, true))
2501 *expr_p = build_empty_stmt (EXPR_LOCATION (*expr_p));
2507 /* Remember the original function pointer type. */
2508 fnptrtype = TREE_TYPE (CALL_EXPR_FN (*expr_p));
2510 /* There is a sequence point before the call, so any side effects in
2511 the calling expression must occur before the actual call. Force
2512 gimplify_expr to use an internal post queue. */
2513 ret = gimplify_expr (&CALL_EXPR_FN (*expr_p), pre_p, NULL,
2514 is_gimple_call_addr, fb_rvalue);
2516 nargs = call_expr_nargs (*expr_p);
2518 /* Get argument types for verification. */
2519 fndecl = get_callee_fndecl (*expr_p);
2522 parms = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
2523 else if (POINTER_TYPE_P (TREE_TYPE (CALL_EXPR_FN (*expr_p))))
2524 parms = TYPE_ARG_TYPES (TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (*expr_p))));
2526 if (fndecl && DECL_ARGUMENTS (fndecl))
2527 p = DECL_ARGUMENTS (fndecl);
2532 for (i = 0; i < nargs && p; i++, p = TREE_CHAIN (p))
2535 /* If the last argument is __builtin_va_arg_pack () and it is not
2536 passed as a named argument, decrease the number of CALL_EXPR
2537 arguments and set instead the CALL_EXPR_VA_ARG_PACK flag. */
2540 && TREE_CODE (CALL_EXPR_ARG (*expr_p, nargs - 1)) == CALL_EXPR)
2542 tree last_arg = CALL_EXPR_ARG (*expr_p, nargs - 1);
2543 tree last_arg_fndecl = get_callee_fndecl (last_arg);
2546 && TREE_CODE (last_arg_fndecl) == FUNCTION_DECL
2547 && DECL_BUILT_IN_CLASS (last_arg_fndecl) == BUILT_IN_NORMAL
2548 && DECL_FUNCTION_CODE (last_arg_fndecl) == BUILT_IN_VA_ARG_PACK)
2550 tree call = *expr_p;
2553 *expr_p = build_call_array_loc (loc, TREE_TYPE (call),
2554 CALL_EXPR_FN (call),
2555 nargs, CALL_EXPR_ARGP (call));
2557 /* Copy all CALL_EXPR flags, location and block, except
2558 CALL_EXPR_VA_ARG_PACK flag. */
2559 CALL_EXPR_STATIC_CHAIN (*expr_p) = CALL_EXPR_STATIC_CHAIN (call);
2560 CALL_EXPR_TAILCALL (*expr_p) = CALL_EXPR_TAILCALL (call);
2561 CALL_EXPR_RETURN_SLOT_OPT (*expr_p)
2562 = CALL_EXPR_RETURN_SLOT_OPT (call);
2563 CALL_FROM_THUNK_P (*expr_p) = CALL_FROM_THUNK_P (call);
2564 SET_EXPR_LOCATION (*expr_p, EXPR_LOCATION (call));
2565 TREE_BLOCK (*expr_p) = TREE_BLOCK (call);
2567 /* Set CALL_EXPR_VA_ARG_PACK. */
2568 CALL_EXPR_VA_ARG_PACK (*expr_p) = 1;
2572 /* Finally, gimplify the function arguments. */
2575 for (i = (PUSH_ARGS_REVERSED ? nargs - 1 : 0);
2576 PUSH_ARGS_REVERSED ? i >= 0 : i < nargs;
2577 PUSH_ARGS_REVERSED ? i-- : i++)
2579 enum gimplify_status t;
2581 /* Avoid gimplifying the second argument to va_start, which needs to
2582 be the plain PARM_DECL. */
2583 if ((i != 1) || !builtin_va_start_p)
2585 t = gimplify_arg (&CALL_EXPR_ARG (*expr_p, i), pre_p,
2586 EXPR_LOCATION (*expr_p));
2594 /* Verify the function result. */
2595 if (want_value && fndecl
2596 && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fnptrtype))))
2598 error_at (loc, "using result of function returning %<void%>");
2602 /* Try this again in case gimplification exposed something. */
2603 if (ret != GS_ERROR)
2605 tree new_tree = fold_call_expr (input_location, *expr_p, !want_value);
2607 if (new_tree && new_tree != *expr_p)
2609 /* There was a transformation of this call which computes the
2610 same value, but in a more efficient way. Return and try
2618 *expr_p = error_mark_node;
2622 /* If the function is "const" or "pure", then clear TREE_SIDE_EFFECTS on its
2623 decl. This allows us to eliminate redundant or useless
2624 calls to "const" functions. */
2625 if (TREE_CODE (*expr_p) == CALL_EXPR)
2627 int flags = call_expr_flags (*expr_p);
2628 if (flags & (ECF_CONST | ECF_PURE)
2629 /* An infinite loop is considered a side effect. */
2630 && !(flags & (ECF_LOOPING_CONST_OR_PURE)))
2631 TREE_SIDE_EFFECTS (*expr_p) = 0;
2634 /* If the value is not needed by the caller, emit a new GIMPLE_CALL
2635 and clear *EXPR_P. Otherwise, leave *EXPR_P in its gimplified
2636 form and delegate the creation of a GIMPLE_CALL to
2637 gimplify_modify_expr. This is always possible because when
2638 WANT_VALUE is true, the caller wants the result of this call into
2639 a temporary, which means that we will emit an INIT_EXPR in
2640 internal_get_tmp_var which will then be handled by
2641 gimplify_modify_expr. */
2644 /* The CALL_EXPR in *EXPR_P is already in GIMPLE form, so all we
2645 have to do is replicate it as a GIMPLE_CALL tuple. */
2646 gimple_stmt_iterator gsi;
2647 call = gimple_build_call_from_tree (*expr_p);
2648 gimple_call_set_fntype (call, TREE_TYPE (fnptrtype));
2649 gimplify_seq_add_stmt (pre_p, call);
2650 gsi = gsi_last (*pre_p);
2652 *expr_p = NULL_TREE;
2655 /* Remember the original function type. */
2656 CALL_EXPR_FN (*expr_p) = build1 (NOP_EXPR, fnptrtype,
2657 CALL_EXPR_FN (*expr_p));
2662 /* Handle shortcut semantics in the predicate operand of a COND_EXPR by
2663 rewriting it into multiple COND_EXPRs, and possibly GOTO_EXPRs.
2665 TRUE_LABEL_P and FALSE_LABEL_P point to the labels to jump to if the
2666 condition is true or false, respectively. If null, we should generate
2667 our own to skip over the evaluation of this specific expression.
2669 LOCUS is the source location of the COND_EXPR.
2671 This function is the tree equivalent of do_jump.
2673 shortcut_cond_r should only be called by shortcut_cond_expr. */
2676 shortcut_cond_r (tree pred, tree *true_label_p, tree *false_label_p,
2679 tree local_label = NULL_TREE;
2680 tree t, expr = NULL;
2682 /* OK, it's not a simple case; we need to pull apart the COND_EXPR to
2683 retain the shortcut semantics. Just insert the gotos here;
2684 shortcut_cond_expr will append the real blocks later. */
2685 if (TREE_CODE (pred) == TRUTH_ANDIF_EXPR)
2687 location_t new_locus;
2689 /* Turn if (a && b) into
2691 if (a); else goto no;
2692 if (b) goto yes; else goto no;
2695 if (false_label_p == NULL)
2696 false_label_p = &local_label;
2698 /* Keep the original source location on the first 'if'. */
2699 t = shortcut_cond_r (TREE_OPERAND (pred, 0), NULL, false_label_p, locus);
2700 append_to_statement_list (t, &expr);
2702 /* Set the source location of the && on the second 'if'. */
2703 new_locus = EXPR_HAS_LOCATION (pred) ? EXPR_LOCATION (pred) : locus;
2704 t = shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p, false_label_p,
2706 append_to_statement_list (t, &expr);
2708 else if (TREE_CODE (pred) == TRUTH_ORIF_EXPR)
2710 location_t new_locus;
2712 /* Turn if (a || b) into
2715 if (b) goto yes; else goto no;
2718 if (true_label_p == NULL)
2719 true_label_p = &local_label;
2721 /* Keep the original source location on the first 'if'. */
2722 t = shortcut_cond_r (TREE_OPERAND (pred, 0), true_label_p, NULL, locus);
2723 append_to_statement_list (t, &expr);
2725 /* Set the source location of the || on the second 'if'. */
2726 new_locus = EXPR_HAS_LOCATION (pred) ? EXPR_LOCATION (pred) : locus;
2727 t = shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p, false_label_p,
2729 append_to_statement_list (t, &expr);
2731 else if (TREE_CODE (pred) == COND_EXPR
2732 && !VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (pred, 1)))
2733 && !VOID_TYPE_P (TREE_TYPE (TREE_OPERAND (pred, 2))))
2735 location_t new_locus;
2737 /* As long as we're messing with gotos, turn if (a ? b : c) into
2739 if (b) goto yes; else goto no;
2741 if (c) goto yes; else goto no;
2743 Don't do this if one of the arms has void type, which can happen
2744 in C++ when the arm is throw. */
2746 /* Keep the original source location on the first 'if'. Set the source
2747 location of the ? on the second 'if'. */
2748 new_locus = EXPR_HAS_LOCATION (pred) ? EXPR_LOCATION (pred) : locus;
2749 expr = build3 (COND_EXPR, void_type_node, TREE_OPERAND (pred, 0),
2750 shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p,
2751 false_label_p, locus),
2752 shortcut_cond_r (TREE_OPERAND (pred, 2), true_label_p,
2753 false_label_p, new_locus));
2757 expr = build3 (COND_EXPR, void_type_node, pred,
2758 build_and_jump (true_label_p),
2759 build_and_jump (false_label_p));
2760 SET_EXPR_LOCATION (expr, locus);
2765 t = build1 (LABEL_EXPR, void_type_node, local_label);
2766 append_to_statement_list (t, &expr);
2772 /* Given a conditional expression EXPR with short-circuit boolean
2773 predicates using TRUTH_ANDIF_EXPR or TRUTH_ORIF_EXPR, break the
2774 predicate appart into the equivalent sequence of conditionals. */
2777 shortcut_cond_expr (tree expr)
2779 tree pred = TREE_OPERAND (expr, 0);
2780 tree then_ = TREE_OPERAND (expr, 1);
2781 tree else_ = TREE_OPERAND (expr, 2);
2782 tree true_label, false_label, end_label, t;
2784 tree *false_label_p;
2785 bool emit_end, emit_false, jump_over_else;
2786 bool then_se = then_ && TREE_SIDE_EFFECTS (then_);
2787 bool else_se = else_ && TREE_SIDE_EFFECTS (else_);
2789 /* First do simple transformations. */
2792 /* If there is no 'else', turn
2795 if (a) if (b) then c. */
2796 while (TREE_CODE (pred) == TRUTH_ANDIF_EXPR)
2798 /* Keep the original source location on the first 'if'. */
2799 location_t locus = EXPR_LOC_OR_HERE (expr);
2800 TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1);
2801 /* Set the source location of the && on the second 'if'. */
2802 if (EXPR_HAS_LOCATION (pred))
2803 SET_EXPR_LOCATION (expr, EXPR_LOCATION (pred));
2804 then_ = shortcut_cond_expr (expr);
2805 then_se = then_ && TREE_SIDE_EFFECTS (then_);
2806 pred = TREE_OPERAND (pred, 0);
2807 expr = build3 (COND_EXPR, void_type_node, pred, then_, NULL_TREE);
2808 SET_EXPR_LOCATION (expr, locus);
2814 /* If there is no 'then', turn
2817 if (a); else if (b); else d. */
2818 while (TREE_CODE (pred) == TRUTH_ORIF_EXPR)
2820 /* Keep the original source location on the first 'if'. */
2821 location_t locus = EXPR_LOC_OR_HERE (expr);
2822 TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1);
2823 /* Set the source location of the || on the second 'if'. */
2824 if (EXPR_HAS_LOCATION (pred))
2825 SET_EXPR_LOCATION (expr, EXPR_LOCATION (pred));
2826 else_ = shortcut_cond_expr (expr);
2827 else_se = else_ && TREE_SIDE_EFFECTS (else_);
2828 pred = TREE_OPERAND (pred, 0);
2829 expr = build3 (COND_EXPR, void_type_node, pred, NULL_TREE, else_);
2830 SET_EXPR_LOCATION (expr, locus);
2834 /* If we're done, great. */
2835 if (TREE_CODE (pred) != TRUTH_ANDIF_EXPR
2836 && TREE_CODE (pred) != TRUTH_ORIF_EXPR)
2839 /* Otherwise we need to mess with gotos. Change
2842 if (a); else goto no;
2845 and recursively gimplify the condition. */
2847 true_label = false_label = end_label = NULL_TREE;
2849 /* If our arms just jump somewhere, hijack those labels so we don't
2850 generate jumps to jumps. */
2853 && TREE_CODE (then_) == GOTO_EXPR
2854 && TREE_CODE (GOTO_DESTINATION (then_)) == LABEL_DECL)
2856 true_label = GOTO_DESTINATION (then_);
2862 && TREE_CODE (else_) == GOTO_EXPR
2863 && TREE_CODE (GOTO_DESTINATION (else_)) == LABEL_DECL)
2865 false_label = GOTO_DESTINATION (else_);
2870 /* If we aren't hijacking a label for the 'then' branch, it falls through. */
2872 true_label_p = &true_label;
2874 true_label_p = NULL;
2876 /* The 'else' branch also needs a label if it contains interesting code. */
2877 if (false_label || else_se)
2878 false_label_p = &false_label;
2880 false_label_p = NULL;
2882 /* If there was nothing else in our arms, just forward the label(s). */
2883 if (!then_se && !else_se)
2884 return shortcut_cond_r (pred, true_label_p, false_label_p,
2885 EXPR_LOC_OR_HERE (expr));
2887 /* If our last subexpression already has a terminal label, reuse it. */
2889 t = expr_last (else_);
2891 t = expr_last (then_);
2894 if (t && TREE_CODE (t) == LABEL_EXPR)
2895 end_label = LABEL_EXPR_LABEL (t);
2897 /* If we don't care about jumping to the 'else' branch, jump to the end
2898 if the condition is false. */
2900 false_label_p = &end_label;
2902 /* We only want to emit these labels if we aren't hijacking them. */
2903 emit_end = (end_label == NULL_TREE);
2904 emit_false = (false_label == NULL_TREE);
2906 /* We only emit the jump over the else clause if we have to--if the
2907 then clause may fall through. Otherwise we can wind up with a
2908 useless jump and a useless label at the end of gimplified code,
2909 which will cause us to think that this conditional as a whole
2910 falls through even if it doesn't. If we then inline a function
2911 which ends with such a condition, that can cause us to issue an
2912 inappropriate warning about control reaching the end of a
2913 non-void function. */
2914 jump_over_else = block_may_fallthru (then_);
2916 pred = shortcut_cond_r (pred, true_label_p, false_label_p,
2917 EXPR_LOC_OR_HERE (expr));
2920 append_to_statement_list (pred, &expr);
2922 append_to_statement_list (then_, &expr);
2927 tree last = expr_last (expr);
2928 t = build_and_jump (&end_label);
2929 if (EXPR_HAS_LOCATION (last))
2930 SET_EXPR_LOCATION (t, EXPR_LOCATION (last));
2931 append_to_statement_list (t, &expr);
2935 t = build1 (LABEL_EXPR, void_type_node, false_label);
2936 append_to_statement_list (t, &expr);
2938 append_to_statement_list (else_, &expr);
2940 if (emit_end && end_label)
2942 t = build1 (LABEL_EXPR, void_type_node, end_label);
2943 append_to_statement_list (t, &expr);
2949 /* EXPR is used in a boolean context; make sure it has BOOLEAN_TYPE. */
2952 gimple_boolify (tree expr)
2954 tree type = TREE_TYPE (expr);
2955 location_t loc = EXPR_LOCATION (expr);
2957 if (TREE_CODE (expr) == NE_EXPR
2958 && TREE_CODE (TREE_OPERAND (expr, 0)) == CALL_EXPR
2959 && integer_zerop (TREE_OPERAND (expr, 1)))
2961 tree call = TREE_OPERAND (expr, 0);
2962 tree fn = get_callee_fndecl (call);
2964 /* For __builtin_expect ((long) (x), y) recurse into x as well
2965 if x is truth_value_p. */
2967 && DECL_BUILT_IN_CLASS (fn) == BUILT_IN_NORMAL
2968 && DECL_FUNCTION_CODE (fn) == BUILT_IN_EXPECT
2969 && call_expr_nargs (call) == 2)
2971 tree arg = CALL_EXPR_ARG (call, 0);
2974 if (TREE_CODE (arg) == NOP_EXPR
2975 && TREE_TYPE (arg) == TREE_TYPE (call))
2976 arg = TREE_OPERAND (arg, 0);
2977 if (truth_value_p (TREE_CODE (arg)))
2979 arg = gimple_boolify (arg);
2980 CALL_EXPR_ARG (call, 0)
2981 = fold_convert_loc (loc, TREE_TYPE (call), arg);
2987 switch (TREE_CODE (expr))
2989 case TRUTH_AND_EXPR:
2991 case TRUTH_XOR_EXPR:
2992 case TRUTH_ANDIF_EXPR:
2993 case TRUTH_ORIF_EXPR:
2994 /* Also boolify the arguments of truth exprs. */
2995 TREE_OPERAND (expr, 1) = gimple_boolify (TREE_OPERAND (expr, 1));
2998 case TRUTH_NOT_EXPR:
2999 TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0));
3001 /* These expressions always produce boolean results. */
3002 if (TREE_CODE (type) != BOOLEAN_TYPE)
3003 TREE_TYPE (expr) = boolean_type_node;
3007 if (COMPARISON_CLASS_P (expr))
3009 /* There expressions always prduce boolean results. */
3010 if (TREE_CODE (type) != BOOLEAN_TYPE)
3011 TREE_TYPE (expr) = boolean_type_node;
3014 /* Other expressions that get here must have boolean values, but
3015 might need to be converted to the appropriate mode. */
3016 if (TREE_CODE (type) == BOOLEAN_TYPE)
3018 return fold_convert_loc (loc, boolean_type_node, expr);
3022 /* Given a conditional expression *EXPR_P without side effects, gimplify
3023 its operands. New statements are inserted to PRE_P. */
3025 static enum gimplify_status
3026 gimplify_pure_cond_expr (tree *expr_p, gimple_seq *pre_p)
3028 tree expr = *expr_p, cond;
3029 enum gimplify_status ret, tret;
3030 enum tree_code code;
3032 cond = gimple_boolify (COND_EXPR_COND (expr));
3034 /* We need to handle && and || specially, as their gimplification
3035 creates pure cond_expr, thus leading to an infinite cycle otherwise. */
3036 code = TREE_CODE (cond);
3037 if (code == TRUTH_ANDIF_EXPR)
3038 TREE_SET_CODE (cond, TRUTH_AND_EXPR);
3039 else if (code == TRUTH_ORIF_EXPR)
3040 TREE_SET_CODE (cond, TRUTH_OR_EXPR);
3041 ret = gimplify_expr (&cond, pre_p, NULL, is_gimple_condexpr, fb_rvalue);
3042 COND_EXPR_COND (*expr_p) = cond;
3044 tret = gimplify_expr (&COND_EXPR_THEN (expr), pre_p, NULL,
3045 is_gimple_val, fb_rvalue);
3046 ret = MIN (ret, tret);
3047 tret = gimplify_expr (&COND_EXPR_ELSE (expr), pre_p, NULL,
3048 is_gimple_val, fb_rvalue);
3050 return MIN (ret, tret);
3053 /* Return true if evaluating EXPR could trap.
3054 EXPR is GENERIC, while tree_could_trap_p can be called
3058 generic_expr_could_trap_p (tree expr)
3062 if (!expr || is_gimple_val (expr))
3065 if (!EXPR_P (expr) || tree_could_trap_p (expr))
3068 n = TREE_OPERAND_LENGTH (expr);
3069 for (i = 0; i < n; i++)
3070 if (generic_expr_could_trap_p (TREE_OPERAND (expr, i)))
3076 /* Convert the conditional expression pointed to by EXPR_P '(p) ? a : b;'
3085 The second form is used when *EXPR_P is of type void.
3087 PRE_P points to the list where side effects that must happen before
3088 *EXPR_P should be stored. */
3090 static enum gimplify_status
3091 gimplify_cond_expr (tree *expr_p, gimple_seq *pre_p, fallback_t fallback)
3093 tree expr = *expr_p;
3094 tree type = TREE_TYPE (expr);
3095 location_t loc = EXPR_LOCATION (expr);
3096 tree tmp, arm1, arm2;
3097 enum gimplify_status ret;
3098 tree label_true, label_false, label_cont;
3099 bool have_then_clause_p, have_else_clause_p;
3101 enum tree_code pred_code;
3102 gimple_seq seq = NULL;
3104 /* If this COND_EXPR has a value, copy the values into a temporary within
3106 if (!VOID_TYPE_P (type))
3108 tree then_ = TREE_OPERAND (expr, 1), else_ = TREE_OPERAND (expr, 2);
3111 /* If either an rvalue is ok or we do not require an lvalue, create the
3112 temporary. But we cannot do that if the type is addressable. */
3113 if (((fallback & fb_rvalue) || !(fallback & fb_lvalue))
3114 && !TREE_ADDRESSABLE (type))
3116 if (gimplify_ctxp->allow_rhs_cond_expr
3117 /* If either branch has side effects or could trap, it can't be
3118 evaluated unconditionally. */
3119 && !TREE_SIDE_EFFECTS (then_)
3120 && !generic_expr_could_trap_p (then_)
3121 && !TREE_SIDE_EFFECTS (else_)
3122 && !generic_expr_could_trap_p (else_))
3123 return gimplify_pure_cond_expr (expr_p, pre_p);
3125 tmp = create_tmp_var (type, "iftmp");
3129 /* Otherwise, only create and copy references to the values. */
3132 type = build_pointer_type (type);
3134 if (!VOID_TYPE_P (TREE_TYPE (then_)))
3135 then_ = build_fold_addr_expr_loc (loc, then_);
3137 if (!VOID_TYPE_P (TREE_TYPE (else_)))
3138 else_ = build_fold_addr_expr_loc (loc, else_);
3141 = build3 (COND_EXPR, type, TREE_OPERAND (expr, 0), then_, else_);
3143 tmp = create_tmp_var (type, "iftmp");
3144 result = build_simple_mem_ref_loc (loc, tmp);
3147 /* Build the new then clause, `tmp = then_;'. But don't build the
3148 assignment if the value is void; in C++ it can be if it's a throw. */
3149 if (!VOID_TYPE_P (TREE_TYPE (then_)))
3150 TREE_OPERAND (expr, 1) = build2 (MODIFY_EXPR, type, tmp, then_);
3152 /* Similarly, build the new else clause, `tmp = else_;'. */
3153 if (!VOID_TYPE_P (TREE_TYPE (else_)))
3154 TREE_OPERAND (expr, 2) = build2 (MODIFY_EXPR, type, tmp, else_);
3156 TREE_TYPE (expr) = void_type_node;
3157 recalculate_side_effects (expr);
3159 /* Move the COND_EXPR to the prequeue. */
3160 gimplify_stmt (&expr, pre_p);
3166 /* Remove any COMPOUND_EXPR so the following cases will be caught. */
3167 STRIP_TYPE_NOPS (TREE_OPERAND (expr, 0));
3168 if (TREE_CODE (TREE_OPERAND (expr, 0)) == COMPOUND_EXPR)
3169 gimplify_compound_expr (&TREE_OPERAND (expr, 0), pre_p, true);
3171 /* Make sure the condition has BOOLEAN_TYPE. */
3172 TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0));
3174 /* Break apart && and || conditions. */
3175 if (TREE_CODE (TREE_OPERAND (expr, 0)) == TRUTH_ANDIF_EXPR
3176 || TREE_CODE (TREE_OPERAND (expr, 0)) == TRUTH_ORIF_EXPR)
3178 expr = shortcut_cond_expr (expr);
3180 if (expr != *expr_p)
3184 /* We can't rely on gimplify_expr to re-gimplify the expanded
3185 form properly, as cleanups might cause the target labels to be
3186 wrapped in a TRY_FINALLY_EXPR. To prevent that, we need to
3187 set up a conditional context. */
3188 gimple_push_condition ();
3189 gimplify_stmt (expr_p, &seq);
3190 gimple_pop_condition (pre_p);
3191 gimple_seq_add_seq (pre_p, seq);
3197 /* Now do the normal gimplification. */
3199 /* Gimplify condition. */
3200 ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, NULL, is_gimple_condexpr,
3202 if (ret == GS_ERROR)
3204 gcc_assert (TREE_OPERAND (expr, 0) != NULL_TREE);
3206 gimple_push_condition ();
3208 have_then_clause_p = have_else_clause_p = false;
3209 if (TREE_OPERAND (expr, 1) != NULL
3210 && TREE_CODE (TREE_OPERAND (expr, 1)) == GOTO_EXPR
3211 && TREE_CODE (GOTO_DESTINATION (TREE_OPERAND (expr, 1))) == LABEL_DECL
3212 && (DECL_CONTEXT (GOTO_DESTINATION (TREE_OPERAND (expr, 1)))
3213 == current_function_decl)
3214 /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
3215 have different locations, otherwise we end up with incorrect
3216 location information on the branches. */
3218 || !EXPR_HAS_LOCATION (expr)
3219 || !EXPR_HAS_LOCATION (TREE_OPERAND (expr, 1))
3220 || EXPR_LOCATION (expr) == EXPR_LOCATION (TREE_OPERAND (expr, 1))))
3222 label_true = GOTO_DESTINATION (TREE_OPERAND (expr, 1));
3223 have_then_clause_p = true;
3226 label_true = create_artificial_label (UNKNOWN_LOCATION);
3227 if (TREE_OPERAND (expr, 2) != NULL
3228 && TREE_CODE (TREE_OPERAND (expr, 2)) == GOTO_EXPR
3229 && TREE_CODE (GOTO_DESTINATION (TREE_OPERAND (expr, 2))) == LABEL_DECL
3230 && (DECL_CONTEXT (GOTO_DESTINATION (TREE_OPERAND (expr, 2)))
3231 == current_function_decl)
3232 /* For -O0 avoid this optimization if the COND_EXPR and GOTO_EXPR
3233 have different locations, otherwise we end up with incorrect
3234 location information on the branches. */
3236 || !EXPR_HAS_LOCATION (expr)
3237 || !EXPR_HAS_LOCATION (TREE_OPERAND (expr, 2))
3238 || EXPR_LOCATION (expr) == EXPR_LOCATION (TREE_OPERAND (expr, 2))))
3240 label_false = GOTO_DESTINATION (TREE_OPERAND (expr, 2));
3241 have_else_clause_p = true;
3244 label_false = create_artificial_label (UNKNOWN_LOCATION);
3246 gimple_cond_get_ops_from_tree (COND_EXPR_COND (expr), &pred_code, &arm1,
3249 gimple_cond = gimple_build_cond (pred_code, arm1, arm2, label_true,
3252 gimplify_seq_add_stmt (&seq, gimple_cond);
3253 label_cont = NULL_TREE;
3254 if (!have_then_clause_p)
3256 /* For if (...) {} else { code; } put label_true after
3258 if (TREE_OPERAND (expr, 1) == NULL_TREE
3259 && !have_else_clause_p
3260 && TREE_OPERAND (expr, 2) != NULL_TREE)
3261 label_cont = label_true;
3264 gimplify_seq_add_stmt (&seq, gimple_build_label (label_true));
3265 have_then_clause_p = gimplify_stmt (&TREE_OPERAND (expr, 1), &seq);
3266 /* For if (...) { code; } else {} or
3267 if (...) { code; } else goto label; or
3268 if (...) { code; return; } else { ... }
3269 label_cont isn't needed. */
3270 if (!have_else_clause_p
3271 && TREE_OPERAND (expr, 2) != NULL_TREE
3272 && gimple_seq_may_fallthru (seq))
3275 label_cont = create_artificial_label (UNKNOWN_LOCATION);
3277 g = gimple_build_goto (label_cont);
3279 /* GIMPLE_COND's are very low level; they have embedded
3280 gotos. This particular embedded goto should not be marked
3281 with the location of the original COND_EXPR, as it would
3282 correspond to the COND_EXPR's condition, not the ELSE or the
3283 THEN arms. To avoid marking it with the wrong location, flag
3284 it as "no location". */
3285 gimple_set_do_not_emit_location (g);
3287 gimplify_seq_add_stmt (&seq, g);
3291 if (!have_else_clause_p)
3293 gimplify_seq_add_stmt (&seq, gimple_build_label (label_false));
3294 have_else_clause_p = gimplify_stmt (&TREE_OPERAND (expr, 2), &seq);
3297 gimplify_seq_add_stmt (&seq, gimple_build_label (label_cont));
3299 gimple_pop_condition (pre_p);
3300 gimple_seq_add_seq (pre_p, seq);
3302 if (ret == GS_ERROR)
3304 else if (have_then_clause_p || have_else_clause_p)
3308 /* Both arms are empty; replace the COND_EXPR with its predicate. */
3309 expr = TREE_OPERAND (expr, 0);
3310 gimplify_stmt (&expr, pre_p);
3317 /* Prepare the node pointed to by EXPR_P, an is_gimple_addressable expression,
3318 to be marked addressable.
3320 We cannot rely on such an expression being directly markable if a temporary
3321 has been created by the gimplification. In this case, we create another
3322 temporary and initialize it with a copy, which will become a store after we
3323 mark it addressable. This can happen if the front-end passed us something
3324 that it could not mark addressable yet, like a Fortran pass-by-reference
3325 parameter (int) floatvar. */
3328 prepare_gimple_addressable (tree *expr_p, gimple_seq *seq_p)
3330 while (handled_component_p (*expr_p))
3331 expr_p = &TREE_OPERAND (*expr_p, 0);
3332 if (is_gimple_reg (*expr_p))
3333 *expr_p = get_initialized_tmp_var (*expr_p, seq_p, NULL);
3336 /* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with
3337 a call to __builtin_memcpy. */
3339 static enum gimplify_status
3340 gimplify_modify_expr_to_memcpy (tree *expr_p, tree size, bool want_value,
3343 tree t, to, to_ptr, from, from_ptr;
3345 location_t loc = EXPR_LOCATION (*expr_p);
3347 to = TREE_OPERAND (*expr_p, 0);
3348 from = TREE_OPERAND (*expr_p, 1);
3350 /* Mark the RHS addressable. Beware that it may not be possible to do so
3351 directly if a temporary has been created by the gimplification. */
3352 prepare_gimple_addressable (&from, seq_p);
3354 mark_addressable (from);
3355 from_ptr = build_fold_addr_expr_loc (loc, from);
3356 gimplify_arg (&from_ptr, seq_p, loc);
3358 mark_addressable (to);
3359 to_ptr = build_fold_addr_expr_loc (loc, to);
3360 gimplify_arg (&to_ptr, seq_p, loc);
3362 t = builtin_decl_implicit (BUILT_IN_MEMCPY);
3364 gs = gimple_build_call (t, 3, to_ptr, from_ptr, size);
3368 /* tmp = memcpy() */
3369 t = create_tmp_var (TREE_TYPE (to_ptr), NULL);
3370 gimple_call_set_lhs (gs, t);
3371 gimplify_seq_add_stmt (seq_p, gs);
3373 *expr_p = build_simple_mem_ref (t);
3377 gimplify_seq_add_stmt (seq_p, gs);
3382 /* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with
3383 a call to __builtin_memset. In this case we know that the RHS is
3384 a CONSTRUCTOR with an empty element list. */
3386 static enum gimplify_status
3387 gimplify_modify_expr_to_memset (tree *expr_p, tree size, bool want_value,
3390 tree t, from, to, to_ptr;
3392 location_t loc = EXPR_LOCATION (*expr_p);
3394 /* Assert our assumptions, to abort instead of producing wrong code
3395 silently if they are not met. Beware that the RHS CONSTRUCTOR might
3396 not be immediately exposed. */
3397 from = TREE_OPERAND (*expr_p, 1);
3398 if (TREE_CODE (from) == WITH_SIZE_EXPR)
3399 from = TREE_OPERAND (from, 0);
3401 gcc_assert (TREE_CODE (from) == CONSTRUCTOR
3402 && VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (from)));
3405 to = TREE_OPERAND (*expr_p, 0);
3407 to_ptr = build_fold_addr_expr_loc (loc, to);
3408 gimplify_arg (&to_ptr, seq_p, loc);
3409 t = builtin_decl_implicit (BUILT_IN_MEMSET);
3411 gs = gimple_build_call (t, 3, to_ptr, integer_zero_node, size);
3415 /* tmp = memset() */
3416 t = create_tmp_var (TREE_TYPE (to_ptr), NULL);
3417 gimple_call_set_lhs (gs, t);
3418 gimplify_seq_add_stmt (seq_p, gs);
3420 *expr_p = build1 (INDIRECT_REF, TREE_TYPE (to), t);
3424 gimplify_seq_add_stmt (seq_p, gs);
3429 /* A subroutine of gimplify_init_ctor_preeval. Called via walk_tree,
3430 determine, cautiously, if a CONSTRUCTOR overlaps the lhs of an
3431 assignment. Return non-null if we detect a potential overlap. */
3433 struct gimplify_init_ctor_preeval_data
3435 /* The base decl of the lhs object. May be NULL, in which case we
3436 have to assume the lhs is indirect. */
3439 /* The alias set of the lhs object. */
3440 alias_set_type lhs_alias_set;
3444 gimplify_init_ctor_preeval_1 (tree *tp, int *walk_subtrees, void *xdata)
3446 struct gimplify_init_ctor_preeval_data *data
3447 = (struct gimplify_init_ctor_preeval_data *) xdata;
3450 /* If we find the base object, obviously we have overlap. */
3451 if (data->lhs_base_decl == t)
3454 /* If the constructor component is indirect, determine if we have a
3455 potential overlap with the lhs. The only bits of information we
3456 have to go on at this point are addressability and alias sets. */
3457 if ((INDIRECT_REF_P (t)
3458 || TREE_CODE (t) == MEM_REF)
3459 && (!data->lhs_base_decl || TREE_ADDRESSABLE (data->lhs_base_decl))
3460 && alias_sets_conflict_p (data->lhs_alias_set, get_alias_set (t)))
3463 /* If the constructor component is a call, determine if it can hide a
3464 potential overlap with the lhs through an INDIRECT_REF like above.
3465 ??? Ugh - this is completely broken. In fact this whole analysis
3466 doesn't look conservative. */
3467 if (TREE_CODE (t) == CALL_EXPR)
3469 tree type, fntype = TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (t)));
3471 for (type = TYPE_ARG_TYPES (fntype); type; type = TREE_CHAIN (type))
3472 if (POINTER_TYPE_P (TREE_VALUE (type))
3473 && (!data->lhs_base_decl || TREE_ADDRESSABLE (data->lhs_base_decl))
3474 && alias_sets_conflict_p (data->lhs_alias_set,
3476 (TREE_TYPE (TREE_VALUE (type)))))
3480 if (IS_TYPE_OR_DECL_P (t))
3485 /* A subroutine of gimplify_init_constructor. Pre-evaluate EXPR,
3486 force values that overlap with the lhs (as described by *DATA)
3487 into temporaries. */
3490 gimplify_init_ctor_preeval (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
3491 struct gimplify_init_ctor_preeval_data *data)
3493 enum gimplify_status one;
3495 /* If the value is constant, then there's nothing to pre-evaluate. */
3496 if (TREE_CONSTANT (*expr_p))
3498 /* Ensure it does not have side effects, it might contain a reference to
3499 the object we're initializing. */
3500 gcc_assert (!TREE_SIDE_EFFECTS (*expr_p));
3504 /* If the type has non-trivial constructors, we can't pre-evaluate. */
3505 if (TREE_ADDRESSABLE (TREE_TYPE (*expr_p)))
3508 /* Recurse for nested constructors. */
3509 if (TREE_CODE (*expr_p) == CONSTRUCTOR)
3511 unsigned HOST_WIDE_INT ix;
3512 constructor_elt *ce;
3513 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (*expr_p);
3515 FOR_EACH_VEC_ELT (constructor_elt, v, ix, ce)
3516 gimplify_init_ctor_preeval (&ce->value, pre_p, post_p, data);
3521 /* If this is a variable sized type, we must remember the size. */
3522 maybe_with_size_expr (expr_p);
3524 /* Gimplify the constructor element to something appropriate for the rhs
3525 of a MODIFY_EXPR. Given that we know the LHS is an aggregate, we know
3526 the gimplifier will consider this a store to memory. Doing this
3527 gimplification now means that we won't have to deal with complicated
3528 language-specific trees, nor trees like SAVE_EXPR that can induce
3529 exponential search behavior. */
3530 one = gimplify_expr (expr_p, pre_p, post_p, is_gimple_mem_rhs, fb_rvalue);
3531 if (one == GS_ERROR)
3537 /* If we gimplified to a bare decl, we can be sure that it doesn't overlap
3538 with the lhs, since "a = { .x=a }" doesn't make sense. This will
3539 always be true for all scalars, since is_gimple_mem_rhs insists on a
3540 temporary variable for them. */
3541 if (DECL_P (*expr_p))
3544 /* If this is of variable size, we have no choice but to assume it doesn't
3545 overlap since we can't make a temporary for it. */
3546 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (*expr_p))) != INTEGER_CST)
3549 /* Otherwise, we must search for overlap ... */
3550 if (!walk_tree (expr_p, gimplify_init_ctor_preeval_1, data, NULL))
3553 /* ... and if found, force the value into a temporary. */
3554 *expr_p = get_formal_tmp_var (*expr_p, pre_p);
3557 /* A subroutine of gimplify_init_ctor_eval. Create a loop for
3558 a RANGE_EXPR in a CONSTRUCTOR for an array.
3562 object[var] = value;
3569 We increment var _after_ the loop exit check because we might otherwise
3570 fail if upper == TYPE_MAX_VALUE (type for upper).
3572 Note that we never have to deal with SAVE_EXPRs here, because this has
3573 already been taken care of for us, in gimplify_init_ctor_preeval(). */
3575 static void gimplify_init_ctor_eval (tree, VEC(constructor_elt,gc) *,
3576 gimple_seq *, bool);
3579 gimplify_init_ctor_eval_range (tree object, tree lower, tree upper,
3580 tree value, tree array_elt_type,
3581 gimple_seq *pre_p, bool cleared)
3583 tree loop_entry_label, loop_exit_label, fall_thru_label;
3584 tree var, var_type, cref, tmp;
3586 loop_entry_label = create_artificial_label (UNKNOWN_LOCATION);
3587 loop_exit_label = create_artificial_label (UNKNOWN_LOCATION);
3588 fall_thru_label = create_artificial_label (UNKNOWN_LOCATION);
3590 /* Create and initialize the index variable. */
3591 var_type = TREE_TYPE (upper);
3592 var = create_tmp_var (var_type, NULL);
3593 gimplify_seq_add_stmt (pre_p, gimple_build_assign (var, lower));
3595 /* Add the loop entry label. */
3596 gimplify_seq_add_stmt (pre_p, gimple_build_label (loop_entry_label));
3598 /* Build the reference. */
3599 cref = build4 (ARRAY_REF, array_elt_type, unshare_expr (object),
3600 var, NULL_TREE, NULL_TREE);
3602 /* If we are a constructor, just call gimplify_init_ctor_eval to do
3603 the store. Otherwise just assign value to the reference. */
3605 if (TREE_CODE (value) == CONSTRUCTOR)
3606 /* NB we might have to call ourself recursively through
3607 gimplify_init_ctor_eval if the value is a constructor. */
3608 gimplify_init_ctor_eval (cref, CONSTRUCTOR_ELTS (value),
3611 gimplify_seq_add_stmt (pre_p, gimple_build_assign (cref, value));
3613 /* We exit the loop when the index var is equal to the upper bound. */
3614 gimplify_seq_add_stmt (pre_p,
3615 gimple_build_cond (EQ_EXPR, var, upper,
3616 loop_exit_label, fall_thru_label));
3618 gimplify_seq_add_stmt (pre_p, gimple_build_label (fall_thru_label));
3620 /* Otherwise, increment the index var... */
3621 tmp = build2 (PLUS_EXPR, var_type, var,
3622 fold_convert (var_type, integer_one_node));
3623 gimplify_seq_add_stmt (pre_p, gimple_build_assign (var, tmp));
3625 /* ...and jump back to the loop entry. */
3626 gimplify_seq_add_stmt (pre_p, gimple_build_goto (loop_entry_label));
3628 /* Add the loop exit label. */
3629 gimplify_seq_add_stmt (pre_p, gimple_build_label (loop_exit_label));
3632 /* Return true if FDECL is accessing a field that is zero sized. */
3635 zero_sized_field_decl (const_tree fdecl)
3637 if (TREE_CODE (fdecl) == FIELD_DECL && DECL_SIZE (fdecl)
3638 && integer_zerop (DECL_SIZE (fdecl)))
3643 /* Return true if TYPE is zero sized. */
3646 zero_sized_type (const_tree type)
3648 if (AGGREGATE_TYPE_P (type) && TYPE_SIZE (type)
3649 && integer_zerop (TYPE_SIZE (type)))
3654 /* A subroutine of gimplify_init_constructor. Generate individual
3655 MODIFY_EXPRs for a CONSTRUCTOR. OBJECT is the LHS against which the
3656 assignments should happen. ELTS is the CONSTRUCTOR_ELTS of the
3657 CONSTRUCTOR. CLEARED is true if the entire LHS object has been
3661 gimplify_init_ctor_eval (tree object, VEC(constructor_elt,gc) *elts,
3662 gimple_seq *pre_p, bool cleared)
3664 tree array_elt_type = NULL;
3665 unsigned HOST_WIDE_INT ix;
3666 tree purpose, value;
3668 if (TREE_CODE (TREE_TYPE (object)) == ARRAY_TYPE)
3669 array_elt_type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (object)));
3671 FOR_EACH_CONSTRUCTOR_ELT (elts, ix, purpose, value)
3675 /* NULL values are created above for gimplification errors. */
3679 if (cleared && initializer_zerop (value))
3682 /* ??? Here's to hoping the front end fills in all of the indices,
3683 so we don't have to figure out what's missing ourselves. */
3684 gcc_assert (purpose);
3686 /* Skip zero-sized fields, unless value has side-effects. This can
3687 happen with calls to functions returning a zero-sized type, which
3688 we shouldn't discard. As a number of downstream passes don't
3689 expect sets of zero-sized fields, we rely on the gimplification of
3690 the MODIFY_EXPR we make below to drop the assignment statement. */
3691 if (! TREE_SIDE_EFFECTS (value) && zero_sized_field_decl (purpose))
3694 /* If we have a RANGE_EXPR, we have to build a loop to assign the
3696 if (TREE_CODE (purpose) == RANGE_EXPR)
3698 tree lower = TREE_OPERAND (purpose, 0);
3699 tree upper = TREE_OPERAND (purpose, 1);
3701 /* If the lower bound is equal to upper, just treat it as if
3702 upper was the index. */
3703 if (simple_cst_equal (lower, upper))
3707 gimplify_init_ctor_eval_range (object, lower, upper, value,
3708 array_elt_type, pre_p, cleared);
3715 /* Do not use bitsizetype for ARRAY_REF indices. */
3716 if (TYPE_DOMAIN (TREE_TYPE (object)))
3718 = fold_convert (TREE_TYPE (TYPE_DOMAIN (TREE_TYPE (object))),
3720 cref = build4 (ARRAY_REF, array_elt_type, unshare_expr (object),
3721 purpose, NULL_TREE, NULL_TREE);
3725 gcc_assert (TREE_CODE (purpose) == FIELD_DECL);
3726 cref = build3 (COMPONENT_REF, TREE_TYPE (purpose),
3727 unshare_expr (object), purpose, NULL_TREE);
3730 if (TREE_CODE (value) == CONSTRUCTOR
3731 && TREE_CODE (TREE_TYPE (value)) != VECTOR_TYPE)
3732 gimplify_init_ctor_eval (cref, CONSTRUCTOR_ELTS (value),
3736 tree init = build2 (INIT_EXPR, TREE_TYPE (cref), cref, value);
3737 gimplify_and_add (init, pre_p);
3743 /* Return the appropriate RHS predicate for this LHS. */
3746 rhs_predicate_for (tree lhs)
3748 if (is_gimple_reg (lhs))
3749 return is_gimple_reg_rhs_or_call;
3751 return is_gimple_mem_rhs_or_call;
3754 /* Gimplify a C99 compound literal expression. This just means adding
3755 the DECL_EXPR before the current statement and using its anonymous
3758 static enum gimplify_status
3759 gimplify_compound_literal_expr (tree *expr_p, gimple_seq *pre_p,
3760 fallback_t fallback)
3762 tree decl_s = COMPOUND_LITERAL_EXPR_DECL_EXPR (*expr_p);
3763 tree decl = DECL_EXPR_DECL (decl_s);
3764 /* Mark the decl as addressable if the compound literal
3765 expression is addressable now, otherwise it is marked too late
3766 after we gimplify the initialization expression. */
3767 if (TREE_ADDRESSABLE (*expr_p))
3768 TREE_ADDRESSABLE (decl) = 1;
3770 /* Preliminarily mark non-addressed complex variables as eligible
3771 for promotion to gimple registers. We'll transform their uses
3773 if ((TREE_CODE (TREE_TYPE (decl)) == COMPLEX_TYPE
3774 || TREE_CODE (TREE_TYPE (decl)) == VECTOR_TYPE)
3775 && !TREE_THIS_VOLATILE (decl)
3776 && !needs_to_live_in_memory (decl))
3777 DECL_GIMPLE_REG_P (decl) = 1;
3779 /* If the decl is not addressable, then it is being used in some
3780 expression or on the right hand side of a statement, and it can
3781 be put into a readonly data section. */
3782 if (!TREE_ADDRESSABLE (decl) && (fallback & fb_lvalue) == 0)
3783 TREE_READONLY (decl) = 1;
3785 /* This decl isn't mentioned in the enclosing block, so add it to the
3786 list of temps. FIXME it seems a bit of a kludge to say that
3787 anonymous artificial vars aren't pushed, but everything else is. */
3788 if (DECL_NAME (decl) == NULL_TREE && !DECL_SEEN_IN_BIND_EXPR_P (decl))
3789 gimple_add_tmp_var (decl);
3791 gimplify_and_add (decl_s, pre_p);
3796 /* Optimize embedded COMPOUND_LITERAL_EXPRs within a CONSTRUCTOR,
3797 return a new CONSTRUCTOR if something changed. */
3800 optimize_compound_literals_in_ctor (tree orig_ctor)
3802 tree ctor = orig_ctor;
3803 VEC(constructor_elt,gc) *elts = CONSTRUCTOR_ELTS (ctor);
3804 unsigned int idx, num = VEC_length (constructor_elt, elts);
3806 for (idx = 0; idx < num; idx++)
3808 tree value = VEC_index (constructor_elt, elts, idx)->value;
3809 tree newval = value;
3810 if (TREE_CODE (value) == CONSTRUCTOR)
3811 newval = optimize_compound_literals_in_ctor (value);
3812 else if (TREE_CODE (value) == COMPOUND_LITERAL_EXPR)
3814 tree decl_s = COMPOUND_LITERAL_EXPR_DECL_EXPR (value);
3815 tree decl = DECL_EXPR_DECL (decl_s);
3816 tree init = DECL_INITIAL (decl);
3818 if (!TREE_ADDRESSABLE (value)
3819 && !TREE_ADDRESSABLE (decl)
3821 newval = optimize_compound_literals_in_ctor (init);
3823 if (newval == value)
3826 if (ctor == orig_ctor)
3828 ctor = copy_node (orig_ctor);
3829 CONSTRUCTOR_ELTS (ctor) = VEC_copy (constructor_elt, gc, elts);
3830 elts = CONSTRUCTOR_ELTS (ctor);
3832 VEC_index (constructor_elt, elts, idx)->value = newval;
3837 /* A subroutine of gimplify_modify_expr. Break out elements of a
3838 CONSTRUCTOR used as an initializer into separate MODIFY_EXPRs.
3840 Note that we still need to clear any elements that don't have explicit
3841 initializers, so if not all elements are initialized we keep the
3842 original MODIFY_EXPR, we just remove all of the constructor elements.
3844 If NOTIFY_TEMP_CREATION is true, do not gimplify, just return
3845 GS_ERROR if we would have to create a temporary when gimplifying
3846 this constructor. Otherwise, return GS_OK.
3848 If NOTIFY_TEMP_CREATION is false, just do the gimplification. */
3850 static enum gimplify_status
3851 gimplify_init_constructor (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
3852 bool want_value, bool notify_temp_creation)
3854 tree object, ctor, type;
3855 enum gimplify_status ret;
3856 VEC(constructor_elt,gc) *elts;
3858 gcc_assert (TREE_CODE (TREE_OPERAND (*expr_p, 1)) == CONSTRUCTOR);
3860 if (!notify_temp_creation)
3862 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
3863 is_gimple_lvalue, fb_lvalue);
3864 if (ret == GS_ERROR)
3868 object = TREE_OPERAND (*expr_p, 0);
3869 ctor = TREE_OPERAND (*expr_p, 1) =
3870 optimize_compound_literals_in_ctor (TREE_OPERAND (*expr_p, 1));
3871 type = TREE_TYPE (ctor);
3872 elts = CONSTRUCTOR_ELTS (ctor);
3875 switch (TREE_CODE (type))
3879 case QUAL_UNION_TYPE:
3882 struct gimplify_init_ctor_preeval_data preeval_data;
3883 HOST_WIDE_INT num_ctor_elements, num_nonzero_elements;
3884 bool cleared, complete_p, valid_const_initializer;
3886 /* Aggregate types must lower constructors to initialization of
3887 individual elements. The exception is that a CONSTRUCTOR node
3888 with no elements indicates zero-initialization of the whole. */
3889 if (VEC_empty (constructor_elt, elts))
3891 if (notify_temp_creation)
3896 /* Fetch information about the constructor to direct later processing.
3897 We might want to make static versions of it in various cases, and
3898 can only do so if it known to be a valid constant initializer. */
3899 valid_const_initializer
3900 = categorize_ctor_elements (ctor, &num_nonzero_elements,
3901 &num_ctor_elements, &complete_p);
3903 /* If a const aggregate variable is being initialized, then it
3904 should never be a lose to promote the variable to be static. */
3905 if (valid_const_initializer
3906 && num_nonzero_elements > 1
3907 && TREE_READONLY (object)
3908 && TREE_CODE (object) == VAR_DECL
3909 && (flag_merge_constants >= 2 || !TREE_ADDRESSABLE (object)))
3911 if (notify_temp_creation)
3913 DECL_INITIAL (object) = ctor;
3914 TREE_STATIC (object) = 1;
3915 if (!DECL_NAME (object))
3916 DECL_NAME (object) = create_tmp_var_name ("C");
3917 walk_tree (&DECL_INITIAL (object), force_labels_r, NULL, NULL);
3919 /* ??? C++ doesn't automatically append a .<number> to the
3920 assembler name, and even when it does, it looks a FE private
3921 data structures to figure out what that number should be,
3922 which are not set for this variable. I suppose this is
3923 important for local statics for inline functions, which aren't
3924 "local" in the object file sense. So in order to get a unique
3925 TU-local symbol, we must invoke the lhd version now. */
3926 lhd_set_decl_assembler_name (object);
3928 *expr_p = NULL_TREE;
3932 /* If there are "lots" of initialized elements, even discounting
3933 those that are not address constants (and thus *must* be
3934 computed at runtime), then partition the constructor into
3935 constant and non-constant parts. Block copy the constant
3936 parts in, then generate code for the non-constant parts. */
3937 /* TODO. There's code in cp/typeck.c to do this. */
3939 if (int_size_in_bytes (TREE_TYPE (ctor)) < 0)
3940 /* store_constructor will ignore the clearing of variable-sized
3941 objects. Initializers for such objects must explicitly set
3942 every field that needs to be set. */
3944 else if (!complete_p)
3945 /* If the constructor isn't complete, clear the whole object
3948 ??? This ought not to be needed. For any element not present
3949 in the initializer, we should simply set them to zero. Except
3950 we'd need to *find* the elements that are not present, and that
3951 requires trickery to avoid quadratic compile-time behavior in
3952 large cases or excessive memory use in small cases. */
3954 else if (num_ctor_elements - num_nonzero_elements
3955 > CLEAR_RATIO (optimize_function_for_speed_p (cfun))
3956 && num_nonzero_elements < num_ctor_elements / 4)
3957 /* If there are "lots" of zeros, it's more efficient to clear
3958 the memory and then set the nonzero elements. */
3963 /* If there are "lots" of initialized elements, and all of them
3964 are valid address constants, then the entire initializer can
3965 be dropped to memory, and then memcpy'd out. Don't do this
3966 for sparse arrays, though, as it's more efficient to follow
3967 the standard CONSTRUCTOR behavior of memset followed by
3968 individual element initialization. Also don't do this for small
3969 all-zero initializers (which aren't big enough to merit
3970 clearing), and don't try to make bitwise copies of
3971 TREE_ADDRESSABLE types. */
3972 if (valid_const_initializer
3973 && !(cleared || num_nonzero_elements == 0)
3974 && !TREE_ADDRESSABLE (type))
3976 HOST_WIDE_INT size = int_size_in_bytes (type);
3979 /* ??? We can still get unbounded array types, at least
3980 from the C++ front end. This seems wrong, but attempt
3981 to work around it for now. */
3984 size = int_size_in_bytes (TREE_TYPE (object));
3986 TREE_TYPE (ctor) = type = TREE_TYPE (object);
3989 /* Find the maximum alignment we can assume for the object. */
3990 /* ??? Make use of DECL_OFFSET_ALIGN. */
3991 if (DECL_P (object))
3992 align = DECL_ALIGN (object);
3994 align = TYPE_ALIGN (type);
3997 && num_nonzero_elements > 1
3998 && !can_move_by_pieces (size, align))
4000 if (notify_temp_creation)
4003 walk_tree (&ctor, force_labels_r, NULL, NULL);
4004 ctor = tree_output_constant_def (ctor);
4005 if (!useless_type_conversion_p (type, TREE_TYPE (ctor)))
4006 ctor = build1 (VIEW_CONVERT_EXPR, type, ctor);
4007 TREE_OPERAND (*expr_p, 1) = ctor;
4009 /* This is no longer an assignment of a CONSTRUCTOR, but
4010 we still may have processing to do on the LHS. So
4011 pretend we didn't do anything here to let that happen. */
4012 return GS_UNHANDLED;
4016 /* If the target is volatile, we have non-zero elements and more than
4017 one field to assign, initialize the target from a temporary. */
4018 if (TREE_THIS_VOLATILE (object)
4019 && !TREE_ADDRESSABLE (type)
4020 && num_nonzero_elements > 0
4021 && VEC_length (constructor_elt, elts) > 1)
4023 tree temp = create_tmp_var (TYPE_MAIN_VARIANT (type), NULL);
4024 TREE_OPERAND (*expr_p, 0) = temp;
4025 *expr_p = build2 (COMPOUND_EXPR, TREE_TYPE (*expr_p),
4027 build2 (MODIFY_EXPR, void_type_node,
4032 if (notify_temp_creation)
4035 /* If there are nonzero elements and if needed, pre-evaluate to capture
4036 elements overlapping with the lhs into temporaries. We must do this
4037 before clearing to fetch the values before they are zeroed-out. */
4038 if (num_nonzero_elements > 0 && TREE_CODE (*expr_p) != INIT_EXPR)
4040 preeval_data.lhs_base_decl = get_base_address (object);
4041 if (!DECL_P (preeval_data.lhs_base_decl))
4042 preeval_data.lhs_base_decl = NULL;
4043 preeval_data.lhs_alias_set = get_alias_set (object);
4045 gimplify_init_ctor_preeval (&TREE_OPERAND (*expr_p, 1),
4046 pre_p, post_p, &preeval_data);
4051 /* Zap the CONSTRUCTOR element list, which simplifies this case.
4052 Note that we still have to gimplify, in order to handle the
4053 case of variable sized types. Avoid shared tree structures. */
4054 CONSTRUCTOR_ELTS (ctor) = NULL;
4055 TREE_SIDE_EFFECTS (ctor) = 0;
4056 object = unshare_expr (object);
4057 gimplify_stmt (expr_p, pre_p);
4060 /* If we have not block cleared the object, or if there are nonzero
4061 elements in the constructor, add assignments to the individual
4062 scalar fields of the object. */
4063 if (!cleared || num_nonzero_elements > 0)
4064 gimplify_init_ctor_eval (object, elts, pre_p, cleared);
4066 *expr_p = NULL_TREE;
4074 if (notify_temp_creation)
4077 /* Extract the real and imaginary parts out of the ctor. */
4078 gcc_assert (VEC_length (constructor_elt, elts) == 2);
4079 r = VEC_index (constructor_elt, elts, 0)->value;
4080 i = VEC_index (constructor_elt, elts, 1)->value;
4081 if (r == NULL || i == NULL)
4083 tree zero = build_zero_cst (TREE_TYPE (type));
4090 /* Complex types have either COMPLEX_CST or COMPLEX_EXPR to
4091 represent creation of a complex value. */
4092 if (TREE_CONSTANT (r) && TREE_CONSTANT (i))
4094 ctor = build_complex (type, r, i);
4095 TREE_OPERAND (*expr_p, 1) = ctor;
4099 ctor = build2 (COMPLEX_EXPR, type, r, i);
4100 TREE_OPERAND (*expr_p, 1) = ctor;
4101 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 1),
4104 rhs_predicate_for (TREE_OPERAND (*expr_p, 0)),
4112 unsigned HOST_WIDE_INT ix;
4113 constructor_elt *ce;
4115 if (notify_temp_creation)
4118 /* Go ahead and simplify constant constructors to VECTOR_CST. */
4119 if (TREE_CONSTANT (ctor))
4121 bool constant_p = true;
4124 /* Even when ctor is constant, it might contain non-*_CST
4125 elements, such as addresses or trapping values like
4126 1.0/0.0 - 1.0/0.0. Such expressions don't belong
4127 in VECTOR_CST nodes. */
4128 FOR_EACH_CONSTRUCTOR_VALUE (elts, ix, value)
4129 if (!CONSTANT_CLASS_P (value))
4137 TREE_OPERAND (*expr_p, 1) = build_vector_from_ctor (type, elts);
4141 /* Don't reduce an initializer constant even if we can't
4142 make a VECTOR_CST. It won't do anything for us, and it'll
4143 prevent us from representing it as a single constant. */
4144 if (initializer_constant_valid_p (ctor, type))
4147 TREE_CONSTANT (ctor) = 0;
4150 /* Vector types use CONSTRUCTOR all the way through gimple
4151 compilation as a general initializer. */
4152 FOR_EACH_VEC_ELT (constructor_elt, elts, ix, ce)
4154 enum gimplify_status tret;
4155 tret = gimplify_expr (&ce->value, pre_p, post_p, is_gimple_val,
4157 if (tret == GS_ERROR)
4160 if (!is_gimple_reg (TREE_OPERAND (*expr_p, 0)))
4161 TREE_OPERAND (*expr_p, 1) = get_formal_tmp_var (ctor, pre_p);
4166 /* So how did we get a CONSTRUCTOR for a scalar type? */
4170 if (ret == GS_ERROR)
4172 else if (want_value)
4179 /* If we have gimplified both sides of the initializer but have
4180 not emitted an assignment, do so now. */
4183 tree lhs = TREE_OPERAND (*expr_p, 0);
4184 tree rhs = TREE_OPERAND (*expr_p, 1);
4185 gimple init = gimple_build_assign (lhs, rhs);
4186 gimplify_seq_add_stmt (pre_p, init);
4194 /* Given a pointer value OP0, return a simplified version of an
4195 indirection through OP0, or NULL_TREE if no simplification is
4196 possible. Note that the resulting type may be different from
4197 the type pointed to in the sense that it is still compatible
4198 from the langhooks point of view. */
4201 gimple_fold_indirect_ref (tree t)
4203 tree ptype = TREE_TYPE (t), type = TREE_TYPE (ptype);
4208 subtype = TREE_TYPE (sub);
4209 if (!POINTER_TYPE_P (subtype))
4212 if (TREE_CODE (sub) == ADDR_EXPR)
4214 tree op = TREE_OPERAND (sub, 0);
4215 tree optype = TREE_TYPE (op);
4217 if (useless_type_conversion_p (type, optype))
4220 /* *(foo *)&fooarray => fooarray[0] */
4221 if (TREE_CODE (optype) == ARRAY_TYPE
4222 && TREE_CODE (TYPE_SIZE (TREE_TYPE (optype))) == INTEGER_CST
4223 && useless_type_conversion_p (type, TREE_TYPE (optype)))
4225 tree type_domain = TYPE_DOMAIN (optype);
4226 tree min_val = size_zero_node;
4227 if (type_domain && TYPE_MIN_VALUE (type_domain))
4228 min_val = TYPE_MIN_VALUE (type_domain);
4229 if (TREE_CODE (min_val) == INTEGER_CST)
4230 return build4 (ARRAY_REF, type, op, min_val, NULL_TREE, NULL_TREE);
4232 /* *(foo *)&complexfoo => __real__ complexfoo */
4233 else if (TREE_CODE (optype) == COMPLEX_TYPE
4234 && useless_type_conversion_p (type, TREE_TYPE (optype)))
4235 return fold_build1 (REALPART_EXPR, type, op);
4236 /* *(foo *)&vectorfoo => BIT_FIELD_REF<vectorfoo,...> */
4237 else if (TREE_CODE (optype) == VECTOR_TYPE
4238 && useless_type_conversion_p (type, TREE_TYPE (optype)))
4240 tree part_width = TYPE_SIZE (type);
4241 tree index = bitsize_int (0);
4242 return fold_build3 (BIT_FIELD_REF, type, op, part_width, index);
4246 /* *(p + CST) -> ... */
4247 if (TREE_CODE (sub) == POINTER_PLUS_EXPR
4248 && TREE_CODE (TREE_OPERAND (sub, 1)) == INTEGER_CST)
4250 tree addr = TREE_OPERAND (sub, 0);
4251 tree off = TREE_OPERAND (sub, 1);
4255 addrtype = TREE_TYPE (addr);
4257 /* ((foo*)&vectorfoo)[1] -> BIT_FIELD_REF<vectorfoo,...> */
4258 if (TREE_CODE (addr) == ADDR_EXPR
4259 && TREE_CODE (TREE_TYPE (addrtype)) == VECTOR_TYPE
4260 && useless_type_conversion_p (type, TREE_TYPE (TREE_TYPE (addrtype)))
4261 && host_integerp (off, 1))
4263 unsigned HOST_WIDE_INT offset = tree_low_cst (off, 1);
4264 tree part_width = TYPE_SIZE (type);
4265 unsigned HOST_WIDE_INT part_widthi
4266 = tree_low_cst (part_width, 0) / BITS_PER_UNIT;
4267 unsigned HOST_WIDE_INT indexi = offset * BITS_PER_UNIT;
4268 tree index = bitsize_int (indexi);
4269 if (offset / part_widthi
4270 <= TYPE_VECTOR_SUBPARTS (TREE_TYPE (addrtype)))
4271 return fold_build3 (BIT_FIELD_REF, type, TREE_OPERAND (addr, 0),
4275 /* ((foo*)&complexfoo)[1] -> __imag__ complexfoo */
4276 if (TREE_CODE (addr) == ADDR_EXPR
4277 && TREE_CODE (TREE_TYPE (addrtype)) == COMPLEX_TYPE
4278 && useless_type_conversion_p (type, TREE_TYPE (TREE_TYPE (addrtype))))
4280 tree size = TYPE_SIZE_UNIT (type);
4281 if (tree_int_cst_equal (size, off))
4282 return fold_build1 (IMAGPART_EXPR, type, TREE_OPERAND (addr, 0));
4285 /* *(p + CST) -> MEM_REF <p, CST>. */
4286 if (TREE_CODE (addr) != ADDR_EXPR
4287 || DECL_P (TREE_OPERAND (addr, 0)))
4288 return fold_build2 (MEM_REF, type,
4290 build_int_cst_wide (ptype,
4291 TREE_INT_CST_LOW (off),
4292 TREE_INT_CST_HIGH (off)));
4295 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
4296 if (TREE_CODE (TREE_TYPE (subtype)) == ARRAY_TYPE
4297 && TREE_CODE (TYPE_SIZE (TREE_TYPE (TREE_TYPE (subtype)))) == INTEGER_CST
4298 && useless_type_conversion_p (type, TREE_TYPE (TREE_TYPE (subtype))))
4301 tree min_val = size_zero_node;
4303 sub = gimple_fold_indirect_ref (sub);
4305 sub = build1 (INDIRECT_REF, TREE_TYPE (subtype), osub);
4306 type_domain = TYPE_DOMAIN (TREE_TYPE (sub));
4307 if (type_domain && TYPE_MIN_VALUE (type_domain))
4308 min_val = TYPE_MIN_VALUE (type_domain);
4309 if (TREE_CODE (min_val) == INTEGER_CST)
4310 return build4 (ARRAY_REF, type, sub, min_val, NULL_TREE, NULL_TREE);
4316 /* Given a pointer value OP0, return a simplified version of an
4317 indirection through OP0, or NULL_TREE if no simplification is
4318 possible. This may only be applied to a rhs of an expression.
4319 Note that the resulting type may be different from the type pointed
4320 to in the sense that it is still compatible from the langhooks
4324 gimple_fold_indirect_ref_rhs (tree t)
4326 return gimple_fold_indirect_ref (t);
4329 /* Subroutine of gimplify_modify_expr to do simplifications of
4330 MODIFY_EXPRs based on the code of the RHS. We loop for as long as
4331 something changes. */
4333 static enum gimplify_status
4334 gimplify_modify_expr_rhs (tree *expr_p, tree *from_p, tree *to_p,
4335 gimple_seq *pre_p, gimple_seq *post_p,
4338 enum gimplify_status ret = GS_UNHANDLED;
4344 switch (TREE_CODE (*from_p))
4347 /* If we're assigning from a read-only variable initialized with
4348 a constructor, do the direct assignment from the constructor,
4349 but only if neither source nor target are volatile since this
4350 latter assignment might end up being done on a per-field basis. */
4351 if (DECL_INITIAL (*from_p)
4352 && TREE_READONLY (*from_p)
4353 && !TREE_THIS_VOLATILE (*from_p)
4354 && !TREE_THIS_VOLATILE (*to_p)
4355 && TREE_CODE (DECL_INITIAL (*from_p)) == CONSTRUCTOR)
4357 tree old_from = *from_p;
4358 enum gimplify_status subret;
4360 /* Move the constructor into the RHS. */
4361 *from_p = unshare_expr (DECL_INITIAL (*from_p));
4363 /* Let's see if gimplify_init_constructor will need to put
4365 subret = gimplify_init_constructor (expr_p, NULL, NULL,
4367 if (subret == GS_ERROR)
4369 /* If so, revert the change. */
4381 /* If we have code like
4385 where the type of "x" is a (possibly cv-qualified variant
4386 of "A"), treat the entire expression as identical to "x".
4387 This kind of code arises in C++ when an object is bound
4388 to a const reference, and if "x" is a TARGET_EXPR we want
4389 to take advantage of the optimization below. */
4390 bool volatile_p = TREE_THIS_VOLATILE (*from_p);
4391 tree t = gimple_fold_indirect_ref_rhs (TREE_OPERAND (*from_p, 0));
4394 if (TREE_THIS_VOLATILE (t) != volatile_p)
4396 if (TREE_CODE_CLASS (TREE_CODE (t)) == tcc_declaration)
4397 t = build_simple_mem_ref_loc (EXPR_LOCATION (*from_p),
4398 build_fold_addr_expr (t));
4399 if (REFERENCE_CLASS_P (t))
4400 TREE_THIS_VOLATILE (t) = volatile_p;
4411 /* If we are initializing something from a TARGET_EXPR, strip the
4412 TARGET_EXPR and initialize it directly, if possible. This can't
4413 be done if the initializer is void, since that implies that the
4414 temporary is set in some non-trivial way.
4416 ??? What about code that pulls out the temp and uses it
4417 elsewhere? I think that such code never uses the TARGET_EXPR as
4418 an initializer. If I'm wrong, we'll die because the temp won't
4419 have any RTL. In that case, I guess we'll need to replace
4420 references somehow. */
4421 tree init = TARGET_EXPR_INITIAL (*from_p);
4424 && !VOID_TYPE_P (TREE_TYPE (init)))
4434 /* Remove any COMPOUND_EXPR in the RHS so the following cases will be
4436 gimplify_compound_expr (from_p, pre_p, true);
4442 /* If we already made some changes, let the front end have a
4443 crack at this before we break it down. */
4444 if (ret != GS_UNHANDLED)
4446 /* If we're initializing from a CONSTRUCTOR, break this into
4447 individual MODIFY_EXPRs. */
4448 return gimplify_init_constructor (expr_p, pre_p, post_p, want_value,
4452 /* If we're assigning to a non-register type, push the assignment
4453 down into the branches. This is mandatory for ADDRESSABLE types,
4454 since we cannot generate temporaries for such, but it saves a
4455 copy in other cases as well. */
4456 if (!is_gimple_reg_type (TREE_TYPE (*from_p)))
4458 /* This code should mirror the code in gimplify_cond_expr. */
4459 enum tree_code code = TREE_CODE (*expr_p);
4460 tree cond = *from_p;
4461 tree result = *to_p;
4463 ret = gimplify_expr (&result, pre_p, post_p,
4464 is_gimple_lvalue, fb_lvalue);
4465 if (ret != GS_ERROR)
4468 if (TREE_TYPE (TREE_OPERAND (cond, 1)) != void_type_node)
4469 TREE_OPERAND (cond, 1)
4470 = build2 (code, void_type_node, result,
4471 TREE_OPERAND (cond, 1));
4472 if (TREE_TYPE (TREE_OPERAND (cond, 2)) != void_type_node)
4473 TREE_OPERAND (cond, 2)
4474 = build2 (code, void_type_node, unshare_expr (result),
4475 TREE_OPERAND (cond, 2));
4477 TREE_TYPE (cond) = void_type_node;
4478 recalculate_side_effects (cond);
4482 gimplify_and_add (cond, pre_p);
4483 *expr_p = unshare_expr (result);
4492 /* For calls that return in memory, give *to_p as the CALL_EXPR's
4493 return slot so that we don't generate a temporary. */
4494 if (!CALL_EXPR_RETURN_SLOT_OPT (*from_p)
4495 && aggregate_value_p (*from_p, *from_p))
4499 if (!(rhs_predicate_for (*to_p))(*from_p))
4500 /* If we need a temporary, *to_p isn't accurate. */
4502 /* It's OK to use the return slot directly unless it's an NRV. */
4503 else if (TREE_CODE (*to_p) == RESULT_DECL
4504 && DECL_NAME (*to_p) == NULL_TREE
4505 && needs_to_live_in_memory (*to_p))
4507 else if (is_gimple_reg_type (TREE_TYPE (*to_p))
4508 || (DECL_P (*to_p) && DECL_REGISTER (*to_p)))
4509 /* Don't force regs into memory. */
4511 else if (TREE_CODE (*expr_p) == INIT_EXPR)
4512 /* It's OK to use the target directly if it's being
4515 else if (variably_modified_type_p (TREE_TYPE (*to_p), NULL_TREE))
4516 /* Always use the target and thus RSO for variable-sized types.
4517 GIMPLE cannot deal with a variable-sized assignment
4518 embedded in a call statement. */
4520 else if (TREE_CODE (*to_p) != SSA_NAME
4521 && (!is_gimple_variable (*to_p)
4522 || needs_to_live_in_memory (*to_p)))
4523 /* Don't use the original target if it's already addressable;
4524 if its address escapes, and the called function uses the
4525 NRV optimization, a conforming program could see *to_p
4526 change before the called function returns; see c++/19317.
4527 When optimizing, the return_slot pass marks more functions
4528 as safe after we have escape info. */
4535 CALL_EXPR_RETURN_SLOT_OPT (*from_p) = 1;
4536 mark_addressable (*to_p);
4541 case WITH_SIZE_EXPR:
4542 /* Likewise for calls that return an aggregate of non-constant size,
4543 since we would not be able to generate a temporary at all. */
4544 if (TREE_CODE (TREE_OPERAND (*from_p, 0)) == CALL_EXPR)
4546 *from_p = TREE_OPERAND (*from_p, 0);
4547 /* We don't change ret in this case because the
4548 WITH_SIZE_EXPR might have been added in
4549 gimplify_modify_expr, so returning GS_OK would lead to an
4555 /* If we're initializing from a container, push the initialization
4557 case CLEANUP_POINT_EXPR:
4559 case STATEMENT_LIST:
4561 tree wrap = *from_p;
4564 ret = gimplify_expr (to_p, pre_p, post_p, is_gimple_min_lval,
4566 if (ret != GS_ERROR)
4569 t = voidify_wrapper_expr (wrap, *expr_p);
4570 gcc_assert (t == *expr_p);
4574 gimplify_and_add (wrap, pre_p);
4575 *expr_p = unshare_expr (*to_p);
4582 case COMPOUND_LITERAL_EXPR:
4584 tree complit = TREE_OPERAND (*expr_p, 1);
4585 tree decl_s = COMPOUND_LITERAL_EXPR_DECL_EXPR (complit);
4586 tree decl = DECL_EXPR_DECL (decl_s);
4587 tree init = DECL_INITIAL (decl);
4589 /* struct T x = (struct T) { 0, 1, 2 } can be optimized
4590 into struct T x = { 0, 1, 2 } if the address of the
4591 compound literal has never been taken. */
4592 if (!TREE_ADDRESSABLE (complit)
4593 && !TREE_ADDRESSABLE (decl)
4596 *expr_p = copy_node (*expr_p);
4597 TREE_OPERAND (*expr_p, 1) = init;
4612 /* Return true if T looks like a valid GIMPLE statement. */
4615 is_gimple_stmt (tree t)
4617 const enum tree_code code = TREE_CODE (t);
4622 /* The only valid NOP_EXPR is the empty statement. */
4623 return IS_EMPTY_STMT (t);
4627 /* These are only valid if they're void. */
4628 return TREE_TYPE (t) == NULL || VOID_TYPE_P (TREE_TYPE (t));
4634 case CASE_LABEL_EXPR:
4635 case TRY_CATCH_EXPR:
4636 case TRY_FINALLY_EXPR:
4637 case EH_FILTER_EXPR:
4640 case STATEMENT_LIST:
4650 /* These are always void. */
4656 /* These are valid regardless of their type. */
4665 /* Promote partial stores to COMPLEX variables to total stores. *EXPR_P is
4666 a MODIFY_EXPR with a lhs of a REAL/IMAGPART_EXPR of a variable with
4667 DECL_GIMPLE_REG_P set.
4669 IMPORTANT NOTE: This promotion is performed by introducing a load of the
4670 other, unmodified part of the complex object just before the total store.
4671 As a consequence, if the object is still uninitialized, an undefined value
4672 will be loaded into a register, which may result in a spurious exception
4673 if the register is floating-point and the value happens to be a signaling
4674 NaN for example. Then the fully-fledged complex operations lowering pass
4675 followed by a DCE pass are necessary in order to fix things up. */
4677 static enum gimplify_status
4678 gimplify_modify_expr_complex_part (tree *expr_p, gimple_seq *pre_p,
4681 enum tree_code code, ocode;
4682 tree lhs, rhs, new_rhs, other, realpart, imagpart;
4684 lhs = TREE_OPERAND (*expr_p, 0);
4685 rhs = TREE_OPERAND (*expr_p, 1);
4686 code = TREE_CODE (lhs);
4687 lhs = TREE_OPERAND (lhs, 0);
4689 ocode = code == REALPART_EXPR ? IMAGPART_EXPR : REALPART_EXPR;
4690 other = build1 (ocode, TREE_TYPE (rhs), lhs);
4691 TREE_NO_WARNING (other) = 1;
4692 other = get_formal_tmp_var (other, pre_p);
4694 realpart = code == REALPART_EXPR ? rhs : other;
4695 imagpart = code == REALPART_EXPR ? other : rhs;
4697 if (TREE_CONSTANT (realpart) && TREE_CONSTANT (imagpart))
4698 new_rhs = build_complex (TREE_TYPE (lhs), realpart, imagpart);
4700 new_rhs = build2 (COMPLEX_EXPR, TREE_TYPE (lhs), realpart, imagpart);
4702 gimplify_seq_add_stmt (pre_p, gimple_build_assign (lhs, new_rhs));
4703 *expr_p = (want_value) ? rhs : NULL_TREE;
4708 /* Gimplify the MODIFY_EXPR node pointed to by EXPR_P.
4714 PRE_P points to the list where side effects that must happen before
4715 *EXPR_P should be stored.
4717 POST_P points to the list where side effects that must happen after
4718 *EXPR_P should be stored.
4720 WANT_VALUE is nonzero iff we want to use the value of this expression
4721 in another expression. */
4723 static enum gimplify_status
4724 gimplify_modify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
4727 tree *from_p = &TREE_OPERAND (*expr_p, 1);
4728 tree *to_p = &TREE_OPERAND (*expr_p, 0);
4729 enum gimplify_status ret = GS_UNHANDLED;
4731 location_t loc = EXPR_LOCATION (*expr_p);
4733 gcc_assert (TREE_CODE (*expr_p) == MODIFY_EXPR
4734 || TREE_CODE (*expr_p) == INIT_EXPR);
4736 /* Trying to simplify a clobber using normal logic doesn't work,
4737 so handle it here. */
4738 if (TREE_CLOBBER_P (*from_p))
4740 gcc_assert (!want_value && TREE_CODE (*to_p) == VAR_DECL);
4741 gimplify_seq_add_stmt (pre_p, gimple_build_assign (*to_p, *from_p));
4746 /* Insert pointer conversions required by the middle-end that are not
4747 required by the frontend. This fixes middle-end type checking for
4748 for example gcc.dg/redecl-6.c. */
4749 if (POINTER_TYPE_P (TREE_TYPE (*to_p)))
4751 STRIP_USELESS_TYPE_CONVERSION (*from_p);
4752 if (!useless_type_conversion_p (TREE_TYPE (*to_p), TREE_TYPE (*from_p)))
4753 *from_p = fold_convert_loc (loc, TREE_TYPE (*to_p), *from_p);
4756 /* See if any simplifications can be done based on what the RHS is. */
4757 ret = gimplify_modify_expr_rhs (expr_p, from_p, to_p, pre_p, post_p,
4759 if (ret != GS_UNHANDLED)
4762 /* For zero sized types only gimplify the left hand side and right hand
4763 side as statements and throw away the assignment. Do this after
4764 gimplify_modify_expr_rhs so we handle TARGET_EXPRs of addressable
4766 if (zero_sized_type (TREE_TYPE (*from_p)) && !want_value)
4768 gimplify_stmt (from_p, pre_p);
4769 gimplify_stmt (to_p, pre_p);
4770 *expr_p = NULL_TREE;
4774 /* If the value being copied is of variable width, compute the length
4775 of the copy into a WITH_SIZE_EXPR. Note that we need to do this
4776 before gimplifying any of the operands so that we can resolve any
4777 PLACEHOLDER_EXPRs in the size. Also note that the RTL expander uses
4778 the size of the expression to be copied, not of the destination, so
4779 that is what we must do here. */
4780 maybe_with_size_expr (from_p);
4782 ret = gimplify_expr (to_p, pre_p, post_p, is_gimple_lvalue, fb_lvalue);
4783 if (ret == GS_ERROR)
4786 /* As a special case, we have to temporarily allow for assignments
4787 with a CALL_EXPR on the RHS. Since in GIMPLE a function call is
4788 a toplevel statement, when gimplifying the GENERIC expression
4789 MODIFY_EXPR <a, CALL_EXPR <foo>>, we cannot create the tuple
4790 GIMPLE_ASSIGN <a, GIMPLE_CALL <foo>>.
4792 Instead, we need to create the tuple GIMPLE_CALL <a, foo>. To
4793 prevent gimplify_expr from trying to create a new temporary for
4794 foo's LHS, we tell it that it should only gimplify until it
4795 reaches the CALL_EXPR. On return from gimplify_expr, the newly
4796 created GIMPLE_CALL <foo> will be the last statement in *PRE_P
4797 and all we need to do here is set 'a' to be its LHS. */
4798 ret = gimplify_expr (from_p, pre_p, post_p, rhs_predicate_for (*to_p),
4800 if (ret == GS_ERROR)
4803 /* Now see if the above changed *from_p to something we handle specially. */
4804 ret = gimplify_modify_expr_rhs (expr_p, from_p, to_p, pre_p, post_p,
4806 if (ret != GS_UNHANDLED)
4809 /* If we've got a variable sized assignment between two lvalues (i.e. does
4810 not involve a call), then we can make things a bit more straightforward
4811 by converting the assignment to memcpy or memset. */
4812 if (TREE_CODE (*from_p) == WITH_SIZE_EXPR)
4814 tree from = TREE_OPERAND (*from_p, 0);
4815 tree size = TREE_OPERAND (*from_p, 1);
4817 if (TREE_CODE (from) == CONSTRUCTOR)
4818 return gimplify_modify_expr_to_memset (expr_p, size, want_value, pre_p);
4820 if (is_gimple_addressable (from))
4823 return gimplify_modify_expr_to_memcpy (expr_p, size, want_value,
4828 /* Transform partial stores to non-addressable complex variables into
4829 total stores. This allows us to use real instead of virtual operands
4830 for these variables, which improves optimization. */
4831 if ((TREE_CODE (*to_p) == REALPART_EXPR
4832 || TREE_CODE (*to_p) == IMAGPART_EXPR)
4833 && is_gimple_reg (TREE_OPERAND (*to_p, 0)))
4834 return gimplify_modify_expr_complex_part (expr_p, pre_p, want_value);
4836 /* Try to alleviate the effects of the gimplification creating artificial
4837 temporaries (see for example is_gimple_reg_rhs) on the debug info. */
4838 if (!gimplify_ctxp->into_ssa
4839 && TREE_CODE (*from_p) == VAR_DECL
4840 && DECL_IGNORED_P (*from_p)
4842 && !DECL_IGNORED_P (*to_p))
4844 if (!DECL_NAME (*from_p) && DECL_NAME (*to_p))
4846 = create_tmp_var_name (IDENTIFIER_POINTER (DECL_NAME (*to_p)));
4847 DECL_DEBUG_EXPR_IS_FROM (*from_p) = 1;
4848 SET_DECL_DEBUG_EXPR (*from_p, *to_p);
4851 if (want_value && TREE_THIS_VOLATILE (*to_p))
4852 *from_p = get_initialized_tmp_var (*from_p, pre_p, post_p);
4854 if (TREE_CODE (*from_p) == CALL_EXPR)
4856 /* Since the RHS is a CALL_EXPR, we need to create a GIMPLE_CALL
4857 instead of a GIMPLE_ASSIGN. */
4858 tree fnptrtype = TREE_TYPE (CALL_EXPR_FN (*from_p));
4859 CALL_EXPR_FN (*from_p) = TREE_OPERAND (CALL_EXPR_FN (*from_p), 0);
4860 STRIP_USELESS_TYPE_CONVERSION (CALL_EXPR_FN (*from_p));
4861 assign = gimple_build_call_from_tree (*from_p);
4862 gimple_call_set_fntype (assign, TREE_TYPE (fnptrtype));
4863 if (!gimple_call_noreturn_p (assign))
4864 gimple_call_set_lhs (assign, *to_p);
4868 assign = gimple_build_assign (*to_p, *from_p);
4869 gimple_set_location (assign, EXPR_LOCATION (*expr_p));
4872 gimplify_seq_add_stmt (pre_p, assign);
4874 if (gimplify_ctxp->into_ssa && is_gimple_reg (*to_p))
4876 /* If we've somehow already got an SSA_NAME on the LHS, then
4877 we've probably modified it twice. Not good. */
4878 gcc_assert (TREE_CODE (*to_p) != SSA_NAME);
4879 *to_p = make_ssa_name (*to_p, assign);
4880 gimple_set_lhs (assign, *to_p);
4885 *expr_p = TREE_THIS_VOLATILE (*to_p) ? *from_p : unshare_expr (*to_p);
4894 /* Gimplify a comparison between two variable-sized objects. Do this
4895 with a call to BUILT_IN_MEMCMP. */
4897 static enum gimplify_status
4898 gimplify_variable_sized_compare (tree *expr_p)
4900 location_t loc = EXPR_LOCATION (*expr_p);
4901 tree op0 = TREE_OPERAND (*expr_p, 0);
4902 tree op1 = TREE_OPERAND (*expr_p, 1);
4903 tree t, arg, dest, src, expr;
4905 arg = TYPE_SIZE_UNIT (TREE_TYPE (op0));
4906 arg = unshare_expr (arg);
4907 arg = SUBSTITUTE_PLACEHOLDER_IN_EXPR (arg, op0);
4908 src = build_fold_addr_expr_loc (loc, op1);
4909 dest = build_fold_addr_expr_loc (loc, op0);
4910 t = builtin_decl_implicit (BUILT_IN_MEMCMP);
4911 t = build_call_expr_loc (loc, t, 3, dest, src, arg);
4914 = build2 (TREE_CODE (*expr_p), TREE_TYPE (*expr_p), t, integer_zero_node);
4915 SET_EXPR_LOCATION (expr, loc);
4921 /* Gimplify a comparison between two aggregate objects of integral scalar
4922 mode as a comparison between the bitwise equivalent scalar values. */
4924 static enum gimplify_status
4925 gimplify_scalar_mode_aggregate_compare (tree *expr_p)
4927 location_t loc = EXPR_LOCATION (*expr_p);
4928 tree op0 = TREE_OPERAND (*expr_p, 0);
4929 tree op1 = TREE_OPERAND (*expr_p, 1);
4931 tree type = TREE_TYPE (op0);
4932 tree scalar_type = lang_hooks.types.type_for_mode (TYPE_MODE (type), 1);
4934 op0 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, scalar_type, op0);
4935 op1 = fold_build1_loc (loc, VIEW_CONVERT_EXPR, scalar_type, op1);
4938 = fold_build2_loc (loc, TREE_CODE (*expr_p), TREE_TYPE (*expr_p), op0, op1);
4943 /* Gimplify an expression sequence. This function gimplifies each
4944 expression and rewrites the original expression with the last
4945 expression of the sequence in GIMPLE form.
4947 PRE_P points to the list where the side effects for all the
4948 expressions in the sequence will be emitted.
4950 WANT_VALUE is true when the result of the last COMPOUND_EXPR is used. */
4952 static enum gimplify_status
4953 gimplify_compound_expr (tree *expr_p, gimple_seq *pre_p, bool want_value)
4959 tree *sub_p = &TREE_OPERAND (t, 0);
4961 if (TREE_CODE (*sub_p) == COMPOUND_EXPR)
4962 gimplify_compound_expr (sub_p, pre_p, false);
4964 gimplify_stmt (sub_p, pre_p);
4966 t = TREE_OPERAND (t, 1);
4968 while (TREE_CODE (t) == COMPOUND_EXPR);
4975 gimplify_stmt (expr_p, pre_p);
4980 /* Gimplify a SAVE_EXPR node. EXPR_P points to the expression to
4981 gimplify. After gimplification, EXPR_P will point to a new temporary
4982 that holds the original value of the SAVE_EXPR node.
4984 PRE_P points to the list where side effects that must happen before
4985 *EXPR_P should be stored. */
4987 static enum gimplify_status
4988 gimplify_save_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
4990 enum gimplify_status ret = GS_ALL_DONE;
4993 gcc_assert (TREE_CODE (*expr_p) == SAVE_EXPR);
4994 val = TREE_OPERAND (*expr_p, 0);
4996 /* If the SAVE_EXPR has not been resolved, then evaluate it once. */
4997 if (!SAVE_EXPR_RESOLVED_P (*expr_p))
4999 /* The operand may be a void-valued expression such as SAVE_EXPRs
5000 generated by the Java frontend for class initialization. It is
5001 being executed only for its side-effects. */
5002 if (TREE_TYPE (val) == void_type_node)
5004 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
5005 is_gimple_stmt, fb_none);
5009 val = get_initialized_tmp_var (val, pre_p, post_p);
5011 TREE_OPERAND (*expr_p, 0) = val;
5012 SAVE_EXPR_RESOLVED_P (*expr_p) = 1;
5020 /* Rewrite the ADDR_EXPR node pointed to by EXPR_P
5027 PRE_P points to the list where side effects that must happen before
5028 *EXPR_P should be stored.
5030 POST_P points to the list where side effects that must happen after
5031 *EXPR_P should be stored. */
5033 static enum gimplify_status
5034 gimplify_addr_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
5036 tree expr = *expr_p;
5037 tree op0 = TREE_OPERAND (expr, 0);
5038 enum gimplify_status ret;
5039 location_t loc = EXPR_LOCATION (*expr_p);
5041 switch (TREE_CODE (op0))
5045 /* Check if we are dealing with an expression of the form '&*ptr'.
5046 While the front end folds away '&*ptr' into 'ptr', these
5047 expressions may be generated internally by the compiler (e.g.,
5048 builtins like __builtin_va_end). */
5049 /* Caution: the silent array decomposition semantics we allow for
5050 ADDR_EXPR means we can't always discard the pair. */
5051 /* Gimplification of the ADDR_EXPR operand may drop
5052 cv-qualification conversions, so make sure we add them if
5055 tree op00 = TREE_OPERAND (op0, 0);
5056 tree t_expr = TREE_TYPE (expr);
5057 tree t_op00 = TREE_TYPE (op00);
5059 if (!useless_type_conversion_p (t_expr, t_op00))
5060 op00 = fold_convert_loc (loc, TREE_TYPE (expr), op00);
5066 case VIEW_CONVERT_EXPR:
5067 /* Take the address of our operand and then convert it to the type of
5070 ??? The interactions of VIEW_CONVERT_EXPR and aliasing is not at
5071 all clear. The impact of this transformation is even less clear. */
5073 /* If the operand is a useless conversion, look through it. Doing so
5074 guarantees that the ADDR_EXPR and its operand will remain of the
5076 if (tree_ssa_useless_type_conversion (TREE_OPERAND (op0, 0)))
5077 op0 = TREE_OPERAND (op0, 0);
5079 *expr_p = fold_convert_loc (loc, TREE_TYPE (expr),
5080 build_fold_addr_expr_loc (loc,
5081 TREE_OPERAND (op0, 0)));
5086 /* We use fb_either here because the C frontend sometimes takes
5087 the address of a call that returns a struct; see
5088 gcc.dg/c99-array-lval-1.c. The gimplifier will correctly make
5089 the implied temporary explicit. */
5091 /* Make the operand addressable. */
5092 ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, post_p,
5093 is_gimple_addressable, fb_either);
5094 if (ret == GS_ERROR)
5097 /* Then mark it. Beware that it may not be possible to do so directly
5098 if a temporary has been created by the gimplification. */
5099 prepare_gimple_addressable (&TREE_OPERAND (expr, 0), pre_p);
5101 op0 = TREE_OPERAND (expr, 0);
5103 /* For various reasons, the gimplification of the expression
5104 may have made a new INDIRECT_REF. */
5105 if (TREE_CODE (op0) == INDIRECT_REF)
5106 goto do_indirect_ref;
5108 mark_addressable (TREE_OPERAND (expr, 0));
5110 /* The FEs may end up building ADDR_EXPRs early on a decl with
5111 an incomplete type. Re-build ADDR_EXPRs in canonical form
5113 if (!types_compatible_p (TREE_TYPE (op0), TREE_TYPE (TREE_TYPE (expr))))
5114 *expr_p = build_fold_addr_expr (op0);
5116 /* Make sure TREE_CONSTANT and TREE_SIDE_EFFECTS are set properly. */
5117 recompute_tree_invariant_for_addr_expr (*expr_p);
5119 /* If we re-built the ADDR_EXPR add a conversion to the original type
5121 if (!useless_type_conversion_p (TREE_TYPE (expr), TREE_TYPE (*expr_p)))
5122 *expr_p = fold_convert (TREE_TYPE (expr), *expr_p);
5130 /* Gimplify the operands of an ASM_EXPR. Input operands should be a gimple
5131 value; output operands should be a gimple lvalue. */
5133 static enum gimplify_status
5134 gimplify_asm_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
5138 const char **oconstraints;
5141 const char *constraint;
5142 bool allows_mem, allows_reg, is_inout;
5143 enum gimplify_status ret, tret;
5145 VEC(tree, gc) *inputs;
5146 VEC(tree, gc) *outputs;
5147 VEC(tree, gc) *clobbers;
5148 VEC(tree, gc) *labels;
5152 noutputs = list_length (ASM_OUTPUTS (expr));
5153 oconstraints = (const char **) alloca ((noutputs) * sizeof (const char *));
5155 inputs = outputs = clobbers = labels = NULL;
5158 link_next = NULL_TREE;
5159 for (i = 0, link = ASM_OUTPUTS (expr); link; ++i, link = link_next)
5162 size_t constraint_len;
5164 link_next = TREE_CHAIN (link);
5168 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
5169 constraint_len = strlen (constraint);
5170 if (constraint_len == 0)
5173 ok = parse_output_constraint (&constraint, i, 0, 0,
5174 &allows_mem, &allows_reg, &is_inout);
5181 if (!allows_reg && allows_mem)
5182 mark_addressable (TREE_VALUE (link));
5184 tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
5185 is_inout ? is_gimple_min_lval : is_gimple_lvalue,
5186 fb_lvalue | fb_mayfail);
5187 if (tret == GS_ERROR)
5189 error ("invalid lvalue in asm output %d", i);
5193 VEC_safe_push (tree, gc, outputs, link);
5194 TREE_CHAIN (link) = NULL_TREE;
5198 /* An input/output operand. To give the optimizers more
5199 flexibility, split it into separate input and output
5204 /* Turn the in/out constraint into an output constraint. */
5205 char *p = xstrdup (constraint);
5207 TREE_VALUE (TREE_PURPOSE (link)) = build_string (constraint_len, p);
5209 /* And add a matching input constraint. */
5212 sprintf (buf, "%d", i);
5214 /* If there are multiple alternatives in the constraint,
5215 handle each of them individually. Those that allow register
5216 will be replaced with operand number, the others will stay
5218 if (strchr (p, ',') != NULL)
5220 size_t len = 0, buflen = strlen (buf);
5221 char *beg, *end, *str, *dst;
5225 end = strchr (beg, ',');
5227 end = strchr (beg, '\0');
5228 if ((size_t) (end - beg) < buflen)
5231 len += end - beg + 1;
5238 str = (char *) alloca (len);
5239 for (beg = p + 1, dst = str;;)
5242 bool mem_p, reg_p, inout_p;
5244 end = strchr (beg, ',');
5249 parse_output_constraint (&tem, i, 0, 0,
5250 &mem_p, ®_p, &inout_p);
5255 memcpy (dst, buf, buflen);
5264 memcpy (dst, beg, len);
5273 input = build_string (dst - str, str);
5276 input = build_string (strlen (buf), buf);
5279 input = build_string (constraint_len - 1, constraint + 1);
5283 input = build_tree_list (build_tree_list (NULL_TREE, input),
5284 unshare_expr (TREE_VALUE (link)));
5285 ASM_INPUTS (expr) = chainon (ASM_INPUTS (expr), input);
5289 link_next = NULL_TREE;
5290 for (link = ASM_INPUTS (expr); link; ++i, link = link_next)
5292 link_next = TREE_CHAIN (link);
5293 constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
5294 parse_input_constraint (&constraint, 0, 0, noutputs, 0,
5295 oconstraints, &allows_mem, &allows_reg);
5297 /* If we can't make copies, we can only accept memory. */
5298 if (TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (link))))
5304 error ("impossible constraint in %<asm%>");
5305 error ("non-memory input %d must stay in memory", i);
5310 /* If the operand is a memory input, it should be an lvalue. */
5311 if (!allows_reg && allows_mem)
5313 tree inputv = TREE_VALUE (link);
5314 STRIP_NOPS (inputv);
5315 if (TREE_CODE (inputv) == PREDECREMENT_EXPR
5316 || TREE_CODE (inputv) == PREINCREMENT_EXPR
5317 || TREE_CODE (inputv) == POSTDECREMENT_EXPR
5318 || TREE_CODE (inputv) == POSTINCREMENT_EXPR)
5319 TREE_VALUE (link) = error_mark_node;
5320 tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
5321 is_gimple_lvalue, fb_lvalue | fb_mayfail);
5322 mark_addressable (TREE_VALUE (link));
5323 if (tret == GS_ERROR)
5325 if (EXPR_HAS_LOCATION (TREE_VALUE (link)))
5326 input_location = EXPR_LOCATION (TREE_VALUE (link));
5327 error ("memory input %d is not directly addressable", i);
5333 tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
5334 is_gimple_asm_val, fb_rvalue);
5335 if (tret == GS_ERROR)
5339 TREE_CHAIN (link) = NULL_TREE;
5340 VEC_safe_push (tree, gc, inputs, link);
5343 for (link = ASM_CLOBBERS (expr); link; ++i, link = TREE_CHAIN (link))
5344 VEC_safe_push (tree, gc, clobbers, link);
5346 for (link = ASM_LABELS (expr); link; ++i, link = TREE_CHAIN (link))
5347 VEC_safe_push (tree, gc, labels, link);
5349 /* Do not add ASMs with errors to the gimple IL stream. */
5350 if (ret != GS_ERROR)
5352 stmt = gimple_build_asm_vec (TREE_STRING_POINTER (ASM_STRING (expr)),
5353 inputs, outputs, clobbers, labels);
5355 gimple_asm_set_volatile (stmt, ASM_VOLATILE_P (expr));
5356 gimple_asm_set_input (stmt, ASM_INPUT_P (expr));
5358 gimplify_seq_add_stmt (pre_p, stmt);
5364 /* Gimplify a CLEANUP_POINT_EXPR. Currently this works by adding
5365 GIMPLE_WITH_CLEANUP_EXPRs to the prequeue as we encounter cleanups while
5366 gimplifying the body, and converting them to TRY_FINALLY_EXPRs when we
5367 return to this function.
5369 FIXME should we complexify the prequeue handling instead? Or use flags
5370 for all the cleanups and let the optimizer tighten them up? The current
5371 code seems pretty fragile; it will break on a cleanup within any
5372 non-conditional nesting. But any such nesting would be broken, anyway;
5373 we can't write a TRY_FINALLY_EXPR that starts inside a nesting construct
5374 and continues out of it. We can do that at the RTL level, though, so
5375 having an optimizer to tighten up try/finally regions would be a Good
5378 static enum gimplify_status
5379 gimplify_cleanup_point_expr (tree *expr_p, gimple_seq *pre_p)
5381 gimple_stmt_iterator iter;
5382 gimple_seq body_sequence = NULL;
5384 tree temp = voidify_wrapper_expr (*expr_p, NULL);
5386 /* We only care about the number of conditions between the innermost
5387 CLEANUP_POINT_EXPR and the cleanup. So save and reset the count and
5388 any cleanups collected outside the CLEANUP_POINT_EXPR. */
5389 int old_conds = gimplify_ctxp->conditions;
5390 gimple_seq old_cleanups = gimplify_ctxp->conditional_cleanups;
5391 bool old_in_cleanup_point_expr = gimplify_ctxp->in_cleanup_point_expr;
5392 gimplify_ctxp->conditions = 0;
5393 gimplify_ctxp->conditional_cleanups = NULL;
5394 gimplify_ctxp->in_cleanup_point_expr = true;
5396 gimplify_stmt (&TREE_OPERAND (*expr_p, 0), &body_sequence);
5398 gimplify_ctxp->conditions = old_conds;
5399 gimplify_ctxp->conditional_cleanups = old_cleanups;
5400 gimplify_ctxp->in_cleanup_point_expr = old_in_cleanup_point_expr;
5402 for (iter = gsi_start (body_sequence); !gsi_end_p (iter); )
5404 gimple wce = gsi_stmt (iter);
5406 if (gimple_code (wce) == GIMPLE_WITH_CLEANUP_EXPR)
5408 if (gsi_one_before_end_p (iter))
5410 /* Note that gsi_insert_seq_before and gsi_remove do not
5411 scan operands, unlike some other sequence mutators. */
5412 if (!gimple_wce_cleanup_eh_only (wce))
5413 gsi_insert_seq_before_without_update (&iter,
5414 gimple_wce_cleanup (wce),
5416 gsi_remove (&iter, true);
5423 enum gimple_try_flags kind;
5425 if (gimple_wce_cleanup_eh_only (wce))
5426 kind = GIMPLE_TRY_CATCH;
5428 kind = GIMPLE_TRY_FINALLY;
5429 seq = gsi_split_seq_after (iter);
5431 gtry = gimple_build_try (seq, gimple_wce_cleanup (wce), kind);
5432 /* Do not use gsi_replace here, as it may scan operands.
5433 We want to do a simple structural modification only. */
5434 *gsi_stmt_ptr (&iter) = gtry;
5435 iter = gsi_start (seq);
5442 gimplify_seq_add_seq (pre_p, body_sequence);
5455 /* Insert a cleanup marker for gimplify_cleanup_point_expr. CLEANUP
5456 is the cleanup action required. EH_ONLY is true if the cleanup should
5457 only be executed if an exception is thrown, not on normal exit. */
5460 gimple_push_cleanup (tree var, tree cleanup, bool eh_only, gimple_seq *pre_p)
5463 gimple_seq cleanup_stmts = NULL;
5465 /* Errors can result in improperly nested cleanups. Which results in
5466 confusion when trying to resolve the GIMPLE_WITH_CLEANUP_EXPR. */
5470 if (gimple_conditional_context ())
5472 /* If we're in a conditional context, this is more complex. We only
5473 want to run the cleanup if we actually ran the initialization that
5474 necessitates it, but we want to run it after the end of the
5475 conditional context. So we wrap the try/finally around the
5476 condition and use a flag to determine whether or not to actually
5477 run the destructor. Thus
5481 becomes (approximately)
5485 if (test) { A::A(temp); flag = 1; val = f(temp); }
5488 if (flag) A::~A(temp);
5492 tree flag = create_tmp_var (boolean_type_node, "cleanup");
5493 gimple ffalse = gimple_build_assign (flag, boolean_false_node);
5494 gimple ftrue = gimple_build_assign (flag, boolean_true_node);
5496 cleanup = build3 (COND_EXPR, void_type_node, flag, cleanup, NULL);
5497 gimplify_stmt (&cleanup, &cleanup_stmts);
5498 wce = gimple_build_wce (cleanup_stmts);
5500 gimplify_seq_add_stmt (&gimplify_ctxp->conditional_cleanups, ffalse);
5501 gimplify_seq_add_stmt (&gimplify_ctxp->conditional_cleanups, wce);
5502 gimplify_seq_add_stmt (pre_p, ftrue);
5504 /* Because of this manipulation, and the EH edges that jump
5505 threading cannot redirect, the temporary (VAR) will appear
5506 to be used uninitialized. Don't warn. */
5507 TREE_NO_WARNING (var) = 1;
5511 gimplify_stmt (&cleanup, &cleanup_stmts);
5512 wce = gimple_build_wce (cleanup_stmts);
5513 gimple_wce_set_cleanup_eh_only (wce, eh_only);
5514 gimplify_seq_add_stmt (pre_p, wce);
5518 /* Gimplify a TARGET_EXPR which doesn't appear on the rhs of an INIT_EXPR. */
5520 static enum gimplify_status
5521 gimplify_target_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p)
5523 tree targ = *expr_p;
5524 tree temp = TARGET_EXPR_SLOT (targ);
5525 tree init = TARGET_EXPR_INITIAL (targ);
5526 enum gimplify_status ret;
5530 tree cleanup = NULL_TREE;
5532 /* TARGET_EXPR temps aren't part of the enclosing block, so add it
5533 to the temps list. Handle also variable length TARGET_EXPRs. */
5534 if (TREE_CODE (DECL_SIZE (temp)) != INTEGER_CST)
5536 if (!TYPE_SIZES_GIMPLIFIED (TREE_TYPE (temp)))
5537 gimplify_type_sizes (TREE_TYPE (temp), pre_p);
5538 gimplify_vla_decl (temp, pre_p);
5541 gimple_add_tmp_var (temp);
5543 /* If TARGET_EXPR_INITIAL is void, then the mere evaluation of the
5544 expression is supposed to initialize the slot. */
5545 if (VOID_TYPE_P (TREE_TYPE (init)))
5546 ret = gimplify_expr (&init, pre_p, post_p, is_gimple_stmt, fb_none);
5549 tree init_expr = build2 (INIT_EXPR, void_type_node, temp, init);
5551 ret = gimplify_expr (&init, pre_p, post_p, is_gimple_stmt, fb_none);
5553 ggc_free (init_expr);
5555 if (ret == GS_ERROR)
5557 /* PR c++/28266 Make sure this is expanded only once. */
5558 TARGET_EXPR_INITIAL (targ) = NULL_TREE;
5562 gimplify_and_add (init, pre_p);
5564 /* If needed, push the cleanup for the temp. */
5565 if (TARGET_EXPR_CLEANUP (targ))
5567 if (CLEANUP_EH_ONLY (targ))
5568 gimple_push_cleanup (temp, TARGET_EXPR_CLEANUP (targ),
5569 CLEANUP_EH_ONLY (targ), pre_p);
5571 cleanup = TARGET_EXPR_CLEANUP (targ);
5574 /* Add a clobber for the temporary going out of scope, like
5575 gimplify_bind_expr. */
5576 if (gimplify_ctxp->in_cleanup_point_expr
5577 && needs_to_live_in_memory (temp))
5579 tree clobber = build_constructor (TREE_TYPE (temp), NULL);
5580 TREE_THIS_VOLATILE (clobber) = true;
5581 clobber = build2 (MODIFY_EXPR, TREE_TYPE (temp), temp, clobber);
5583 cleanup = build2 (COMPOUND_EXPR, void_type_node, cleanup,
5590 gimple_push_cleanup (temp, cleanup, false, pre_p);
5592 /* Only expand this once. */
5593 TREE_OPERAND (targ, 3) = init;
5594 TARGET_EXPR_INITIAL (targ) = NULL_TREE;
5597 /* We should have expanded this before. */
5598 gcc_assert (DECL_SEEN_IN_BIND_EXPR_P (temp));
5604 /* Gimplification of expression trees. */
5606 /* Gimplify an expression which appears at statement context. The
5607 corresponding GIMPLE statements are added to *SEQ_P. If *SEQ_P is
5608 NULL, a new sequence is allocated.
5610 Return true if we actually added a statement to the queue. */
5613 gimplify_stmt (tree *stmt_p, gimple_seq *seq_p)
5615 gimple_seq_node last;
5618 *seq_p = gimple_seq_alloc ();
5620 last = gimple_seq_last (*seq_p);
5621 gimplify_expr (stmt_p, seq_p, NULL, is_gimple_stmt, fb_none);
5622 return last != gimple_seq_last (*seq_p);
5625 /* Add FIRSTPRIVATE entries for DECL in the OpenMP the surrounding parallels
5626 to CTX. If entries already exist, force them to be some flavor of private.
5627 If there is no enclosing parallel, do nothing. */
5630 omp_firstprivatize_variable (struct gimplify_omp_ctx *ctx, tree decl)
5634 if (decl == NULL || !DECL_P (decl))
5639 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
5642 if (n->value & GOVD_SHARED)
5643 n->value = GOVD_FIRSTPRIVATE | (n->value & GOVD_SEEN);
5647 else if (ctx->region_type != ORT_WORKSHARE)
5648 omp_add_variable (ctx, decl, GOVD_FIRSTPRIVATE);
5650 ctx = ctx->outer_context;
5655 /* Similarly for each of the type sizes of TYPE. */
5658 omp_firstprivatize_type_sizes (struct gimplify_omp_ctx *ctx, tree type)
5660 if (type == NULL || type == error_mark_node)
5662 type = TYPE_MAIN_VARIANT (type);
5664 if (pointer_set_insert (ctx->privatized_types, type))
5667 switch (TREE_CODE (type))
5673 case FIXED_POINT_TYPE:
5674 omp_firstprivatize_variable (ctx, TYPE_MIN_VALUE (type));
5675 omp_firstprivatize_variable (ctx, TYPE_MAX_VALUE (type));
5679 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (type));
5680 omp_firstprivatize_type_sizes (ctx, TYPE_DOMAIN (type));
5685 case QUAL_UNION_TYPE:
5688 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
5689 if (TREE_CODE (field) == FIELD_DECL)
5691 omp_firstprivatize_variable (ctx, DECL_FIELD_OFFSET (field));
5692 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (field));
5698 case REFERENCE_TYPE:
5699 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (type));
5706 omp_firstprivatize_variable (ctx, TYPE_SIZE (type));
5707 omp_firstprivatize_variable (ctx, TYPE_SIZE_UNIT (type));
5708 lang_hooks.types.omp_firstprivatize_type_sizes (ctx, type);
5711 /* Add an entry for DECL in the OpenMP context CTX with FLAGS. */
5714 omp_add_variable (struct gimplify_omp_ctx *ctx, tree decl, unsigned int flags)
5717 unsigned int nflags;
5720 if (error_operand_p (decl))
5723 /* Never elide decls whose type has TREE_ADDRESSABLE set. This means
5724 there are constructors involved somewhere. */
5725 if (TREE_ADDRESSABLE (TREE_TYPE (decl))
5726 || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
5729 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
5732 /* We shouldn't be re-adding the decl with the same data
5734 gcc_assert ((n->value & GOVD_DATA_SHARE_CLASS & flags) == 0);
5735 /* The only combination of data sharing classes we should see is
5736 FIRSTPRIVATE and LASTPRIVATE. */
5737 nflags = n->value | flags;
5738 gcc_assert ((nflags & GOVD_DATA_SHARE_CLASS)
5739 == (GOVD_FIRSTPRIVATE | GOVD_LASTPRIVATE));
5744 /* When adding a variable-sized variable, we have to handle all sorts
5745 of additional bits of data: the pointer replacement variable, and
5746 the parameters of the type. */
5747 if (DECL_SIZE (decl) && TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
5749 /* Add the pointer replacement variable as PRIVATE if the variable
5750 replacement is private, else FIRSTPRIVATE since we'll need the
5751 address of the original variable either for SHARED, or for the
5752 copy into or out of the context. */
5753 if (!(flags & GOVD_LOCAL))
5755 nflags = flags & GOVD_PRIVATE ? GOVD_PRIVATE : GOVD_FIRSTPRIVATE;
5756 nflags |= flags & GOVD_SEEN;
5757 t = DECL_VALUE_EXPR (decl);
5758 gcc_assert (TREE_CODE (t) == INDIRECT_REF);
5759 t = TREE_OPERAND (t, 0);
5760 gcc_assert (DECL_P (t));
5761 omp_add_variable (ctx, t, nflags);
5764 /* Add all of the variable and type parameters (which should have
5765 been gimplified to a formal temporary) as FIRSTPRIVATE. */
5766 omp_firstprivatize_variable (ctx, DECL_SIZE_UNIT (decl));
5767 omp_firstprivatize_variable (ctx, DECL_SIZE (decl));
5768 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (decl));
5770 /* The variable-sized variable itself is never SHARED, only some form
5771 of PRIVATE. The sharing would take place via the pointer variable
5772 which we remapped above. */
5773 if (flags & GOVD_SHARED)
5774 flags = GOVD_PRIVATE | GOVD_DEBUG_PRIVATE
5775 | (flags & (GOVD_SEEN | GOVD_EXPLICIT));
5777 /* We're going to make use of the TYPE_SIZE_UNIT at least in the
5778 alloca statement we generate for the variable, so make sure it
5779 is available. This isn't automatically needed for the SHARED
5780 case, since we won't be allocating local storage then.
5781 For local variables TYPE_SIZE_UNIT might not be gimplified yet,
5782 in this case omp_notice_variable will be called later
5783 on when it is gimplified. */
5784 else if (! (flags & GOVD_LOCAL)
5785 && DECL_P (TYPE_SIZE_UNIT (TREE_TYPE (decl))))
5786 omp_notice_variable (ctx, TYPE_SIZE_UNIT (TREE_TYPE (decl)), true);
5788 else if (lang_hooks.decls.omp_privatize_by_reference (decl))
5790 gcc_assert ((flags & GOVD_LOCAL) == 0);
5791 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (decl));
5793 /* Similar to the direct variable sized case above, we'll need the
5794 size of references being privatized. */
5795 if ((flags & GOVD_SHARED) == 0)
5797 t = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl)));
5798 if (TREE_CODE (t) != INTEGER_CST)
5799 omp_notice_variable (ctx, t, true);
5803 splay_tree_insert (ctx->variables, (splay_tree_key)decl, flags);
5806 /* Notice a threadprivate variable DECL used in OpenMP context CTX.
5807 This just prints out diagnostics about threadprivate variable uses
5808 in untied tasks. If DECL2 is non-NULL, prevent this warning
5809 on that variable. */
5812 omp_notice_threadprivate_variable (struct gimplify_omp_ctx *ctx, tree decl,
5817 if (ctx->region_type != ORT_UNTIED_TASK)
5819 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
5822 error ("threadprivate variable %qE used in untied task",
5824 error_at (ctx->location, "enclosing task");
5825 splay_tree_insert (ctx->variables, (splay_tree_key)decl, 0);
5828 splay_tree_insert (ctx->variables, (splay_tree_key)decl2, 0);
5832 /* Record the fact that DECL was used within the OpenMP context CTX.
5833 IN_CODE is true when real code uses DECL, and false when we should
5834 merely emit default(none) errors. Return true if DECL is going to
5835 be remapped and thus DECL shouldn't be gimplified into its
5836 DECL_VALUE_EXPR (if any). */
5839 omp_notice_variable (struct gimplify_omp_ctx *ctx, tree decl, bool in_code)
5842 unsigned flags = in_code ? GOVD_SEEN : 0;
5843 bool ret = false, shared;
5845 if (error_operand_p (decl))
5848 /* Threadprivate variables are predetermined. */
5849 if (is_global_var (decl))
5851 if (DECL_THREAD_LOCAL_P (decl))
5852 return omp_notice_threadprivate_variable (ctx, decl, NULL_TREE);
5854 if (DECL_HAS_VALUE_EXPR_P (decl))
5856 tree value = get_base_address (DECL_VALUE_EXPR (decl));
5858 if (value && DECL_P (value) && DECL_THREAD_LOCAL_P (value))
5859 return omp_notice_threadprivate_variable (ctx, decl, value);
5863 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
5866 enum omp_clause_default_kind default_kind, kind;
5867 struct gimplify_omp_ctx *octx;
5869 if (ctx->region_type == ORT_WORKSHARE)
5872 /* ??? Some compiler-generated variables (like SAVE_EXPRs) could be
5873 remapped firstprivate instead of shared. To some extent this is
5874 addressed in omp_firstprivatize_type_sizes, but not effectively. */
5875 default_kind = ctx->default_kind;
5876 kind = lang_hooks.decls.omp_predetermined_sharing (decl);
5877 if (kind != OMP_CLAUSE_DEFAULT_UNSPECIFIED)
5878 default_kind = kind;
5880 switch (default_kind)
5882 case OMP_CLAUSE_DEFAULT_NONE:
5883 error ("%qE not specified in enclosing parallel",
5884 DECL_NAME (lang_hooks.decls.omp_report_decl (decl)));
5885 if ((ctx->region_type & ORT_TASK) != 0)
5886 error_at (ctx->location, "enclosing task");
5888 error_at (ctx->location, "enclosing parallel");
5890 case OMP_CLAUSE_DEFAULT_SHARED:
5891 flags |= GOVD_SHARED;
5893 case OMP_CLAUSE_DEFAULT_PRIVATE:
5894 flags |= GOVD_PRIVATE;
5896 case OMP_CLAUSE_DEFAULT_FIRSTPRIVATE:
5897 flags |= GOVD_FIRSTPRIVATE;
5899 case OMP_CLAUSE_DEFAULT_UNSPECIFIED:
5900 /* decl will be either GOVD_FIRSTPRIVATE or GOVD_SHARED. */
5901 gcc_assert ((ctx->region_type & ORT_TASK) != 0);
5902 if (ctx->outer_context)
5903 omp_notice_variable (ctx->outer_context, decl, in_code);
5904 for (octx = ctx->outer_context; octx; octx = octx->outer_context)
5908 n2 = splay_tree_lookup (octx->variables, (splay_tree_key) decl);
5909 if (n2 && (n2->value & GOVD_DATA_SHARE_CLASS) != GOVD_SHARED)
5911 flags |= GOVD_FIRSTPRIVATE;
5914 if ((octx->region_type & ORT_PARALLEL) != 0)
5917 if (flags & GOVD_FIRSTPRIVATE)
5920 && (TREE_CODE (decl) == PARM_DECL
5921 || (!is_global_var (decl)
5922 && DECL_CONTEXT (decl) == current_function_decl)))
5924 flags |= GOVD_FIRSTPRIVATE;
5927 flags |= GOVD_SHARED;
5933 if ((flags & GOVD_PRIVATE)
5934 && lang_hooks.decls.omp_private_outer_ref (decl))
5935 flags |= GOVD_PRIVATE_OUTER_REF;
5937 omp_add_variable (ctx, decl, flags);
5939 shared = (flags & GOVD_SHARED) != 0;
5940 ret = lang_hooks.decls.omp_disregard_value_expr (decl, shared);
5944 if ((n->value & (GOVD_SEEN | GOVD_LOCAL)) == 0
5945 && (flags & (GOVD_SEEN | GOVD_LOCAL)) == GOVD_SEEN
5947 && TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
5950 tree t = DECL_VALUE_EXPR (decl);
5951 gcc_assert (TREE_CODE (t) == INDIRECT_REF);
5952 t = TREE_OPERAND (t, 0);
5953 gcc_assert (DECL_P (t));
5954 n2 = splay_tree_lookup (ctx->variables, (splay_tree_key) t);
5955 n2->value |= GOVD_SEEN;
5958 shared = ((flags | n->value) & GOVD_SHARED) != 0;
5959 ret = lang_hooks.decls.omp_disregard_value_expr (decl, shared);
5961 /* If nothing changed, there's nothing left to do. */
5962 if ((n->value & flags) == flags)
5968 /* If the variable is private in the current context, then we don't
5969 need to propagate anything to an outer context. */
5970 if ((flags & GOVD_PRIVATE) && !(flags & GOVD_PRIVATE_OUTER_REF))
5972 if (ctx->outer_context
5973 && omp_notice_variable (ctx->outer_context, decl, in_code))
5978 /* Verify that DECL is private within CTX. If there's specific information
5979 to the contrary in the innermost scope, generate an error. */
5982 omp_is_private (struct gimplify_omp_ctx *ctx, tree decl)
5986 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
5989 if (n->value & GOVD_SHARED)
5991 if (ctx == gimplify_omp_ctxp)
5993 error ("iteration variable %qE should be private",
5995 n->value = GOVD_PRIVATE;
6001 else if ((n->value & GOVD_EXPLICIT) != 0
6002 && (ctx == gimplify_omp_ctxp
6003 || (ctx->region_type == ORT_COMBINED_PARALLEL
6004 && gimplify_omp_ctxp->outer_context == ctx)))
6006 if ((n->value & GOVD_FIRSTPRIVATE) != 0)
6007 error ("iteration variable %qE should not be firstprivate",
6009 else if ((n->value & GOVD_REDUCTION) != 0)
6010 error ("iteration variable %qE should not be reduction",
6013 return (ctx == gimplify_omp_ctxp
6014 || (ctx->region_type == ORT_COMBINED_PARALLEL
6015 && gimplify_omp_ctxp->outer_context == ctx));
6018 if (ctx->region_type != ORT_WORKSHARE)
6020 else if (ctx->outer_context)
6021 return omp_is_private (ctx->outer_context, decl);
6025 /* Return true if DECL is private within a parallel region
6026 that binds to the current construct's context or in parallel
6027 region's REDUCTION clause. */
6030 omp_check_private (struct gimplify_omp_ctx *ctx, tree decl)
6036 ctx = ctx->outer_context;
6038 return !(is_global_var (decl)
6039 /* References might be private, but might be shared too. */
6040 || lang_hooks.decls.omp_privatize_by_reference (decl));
6042 n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
6044 return (n->value & GOVD_SHARED) == 0;
6046 while (ctx->region_type == ORT_WORKSHARE);
6050 /* Scan the OpenMP clauses in *LIST_P, installing mappings into a new
6051 and previous omp contexts. */
6054 gimplify_scan_omp_clauses (tree *list_p, gimple_seq *pre_p,
6055 enum omp_region_type region_type)
6057 struct gimplify_omp_ctx *ctx, *outer_ctx;
6058 struct gimplify_ctx gctx;
6061 ctx = new_omp_context (region_type);
6062 outer_ctx = ctx->outer_context;
6064 while ((c = *list_p) != NULL)
6066 bool remove = false;
6067 bool notice_outer = true;
6068 const char *check_non_private = NULL;
6072 switch (OMP_CLAUSE_CODE (c))
6074 case OMP_CLAUSE_PRIVATE:
6075 flags = GOVD_PRIVATE | GOVD_EXPLICIT;
6076 if (lang_hooks.decls.omp_private_outer_ref (OMP_CLAUSE_DECL (c)))
6078 flags |= GOVD_PRIVATE_OUTER_REF;
6079 OMP_CLAUSE_PRIVATE_OUTER_REF (c) = 1;
6082 notice_outer = false;
6084 case OMP_CLAUSE_SHARED:
6085 flags = GOVD_SHARED | GOVD_EXPLICIT;
6087 case OMP_CLAUSE_FIRSTPRIVATE:
6088 flags = GOVD_FIRSTPRIVATE | GOVD_EXPLICIT;
6089 check_non_private = "firstprivate";
6091 case OMP_CLAUSE_LASTPRIVATE:
6092 flags = GOVD_LASTPRIVATE | GOVD_SEEN | GOVD_EXPLICIT;
6093 check_non_private = "lastprivate";
6095 case OMP_CLAUSE_REDUCTION:
6096 flags = GOVD_REDUCTION | GOVD_SEEN | GOVD_EXPLICIT;
6097 check_non_private = "reduction";
6101 decl = OMP_CLAUSE_DECL (c);
6102 if (error_operand_p (decl))
6107 omp_add_variable (ctx, decl, flags);
6108 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION
6109 && OMP_CLAUSE_REDUCTION_PLACEHOLDER (c))
6111 omp_add_variable (ctx, OMP_CLAUSE_REDUCTION_PLACEHOLDER (c),
6112 GOVD_LOCAL | GOVD_SEEN);
6113 gimplify_omp_ctxp = ctx;
6114 push_gimplify_context (&gctx);
6116 OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c) = gimple_seq_alloc ();
6117 OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c) = gimple_seq_alloc ();
6119 gimplify_and_add (OMP_CLAUSE_REDUCTION_INIT (c),
6120 &OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c));
6121 pop_gimplify_context
6122 (gimple_seq_first_stmt (OMP_CLAUSE_REDUCTION_GIMPLE_INIT (c)));
6123 push_gimplify_context (&gctx);
6124 gimplify_and_add (OMP_CLAUSE_REDUCTION_MERGE (c),
6125 &OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c));
6126 pop_gimplify_context
6127 (gimple_seq_first_stmt (OMP_CLAUSE_REDUCTION_GIMPLE_MERGE (c)));
6128 OMP_CLAUSE_REDUCTION_INIT (c) = NULL_TREE;
6129 OMP_CLAUSE_REDUCTION_MERGE (c) = NULL_TREE;
6131 gimplify_omp_ctxp = outer_ctx;
6133 else if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LASTPRIVATE
6134 && OMP_CLAUSE_LASTPRIVATE_STMT (c))
6136 gimplify_omp_ctxp = ctx;
6137 push_gimplify_context (&gctx);
6138 if (TREE_CODE (OMP_CLAUSE_LASTPRIVATE_STMT (c)) != BIND_EXPR)
6140 tree bind = build3 (BIND_EXPR, void_type_node, NULL,
6142 TREE_SIDE_EFFECTS (bind) = 1;
6143 BIND_EXPR_BODY (bind) = OMP_CLAUSE_LASTPRIVATE_STMT (c);
6144 OMP_CLAUSE_LASTPRIVATE_STMT (c) = bind;
6146 gimplify_and_add (OMP_CLAUSE_LASTPRIVATE_STMT (c),
6147 &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c));
6148 pop_gimplify_context
6149 (gimple_seq_first_stmt (OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c)));
6150 OMP_CLAUSE_LASTPRIVATE_STMT (c) = NULL_TREE;
6152 gimplify_omp_ctxp = outer_ctx;
6158 case OMP_CLAUSE_COPYIN:
6159 case OMP_CLAUSE_COPYPRIVATE:
6160 decl = OMP_CLAUSE_DECL (c);
6161 if (error_operand_p (decl))
6168 omp_notice_variable (outer_ctx, decl, true);
6169 if (check_non_private
6170 && region_type == ORT_WORKSHARE
6171 && omp_check_private (ctx, decl))
6173 error ("%s variable %qE is private in outer context",
6174 check_non_private, DECL_NAME (decl));
6179 case OMP_CLAUSE_FINAL:
6181 OMP_CLAUSE_OPERAND (c, 0)
6182 = gimple_boolify (OMP_CLAUSE_OPERAND (c, 0));
6185 case OMP_CLAUSE_SCHEDULE:
6186 case OMP_CLAUSE_NUM_THREADS:
6187 if (gimplify_expr (&OMP_CLAUSE_OPERAND (c, 0), pre_p, NULL,
6188 is_gimple_val, fb_rvalue) == GS_ERROR)
6192 case OMP_CLAUSE_NOWAIT:
6193 case OMP_CLAUSE_ORDERED:
6194 case OMP_CLAUSE_UNTIED:
6195 case OMP_CLAUSE_COLLAPSE:
6196 case OMP_CLAUSE_MERGEABLE:
6199 case OMP_CLAUSE_DEFAULT:
6200 ctx->default_kind = OMP_CLAUSE_DEFAULT_KIND (c);
6208 *list_p = OMP_CLAUSE_CHAIN (c);
6210 list_p = &OMP_CLAUSE_CHAIN (c);
6213 gimplify_omp_ctxp = ctx;
6216 /* For all variables that were not actually used within the context,
6217 remove PRIVATE, SHARED, and FIRSTPRIVATE clauses. */
6220 gimplify_adjust_omp_clauses_1 (splay_tree_node n, void *data)
6222 tree *list_p = (tree *) data;
6223 tree decl = (tree) n->key;
6224 unsigned flags = n->value;
6225 enum omp_clause_code code;
6229 if (flags & (GOVD_EXPLICIT | GOVD_LOCAL))
6231 if ((flags & GOVD_SEEN) == 0)
6233 if (flags & GOVD_DEBUG_PRIVATE)
6235 gcc_assert ((flags & GOVD_DATA_SHARE_CLASS) == GOVD_PRIVATE);
6236 private_debug = true;
6240 = lang_hooks.decls.omp_private_debug_clause (decl,
6241 !!(flags & GOVD_SHARED));
6243 code = OMP_CLAUSE_PRIVATE;
6244 else if (flags & GOVD_SHARED)
6246 if (is_global_var (decl))
6248 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp->outer_context;
6252 = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
6253 if (on && (on->value & (GOVD_FIRSTPRIVATE | GOVD_LASTPRIVATE
6254 | GOVD_PRIVATE | GOVD_REDUCTION)) != 0)
6256 ctx = ctx->outer_context;
6261 code = OMP_CLAUSE_SHARED;
6263 else if (flags & GOVD_PRIVATE)
6264 code = OMP_CLAUSE_PRIVATE;
6265 else if (flags & GOVD_FIRSTPRIVATE)
6266 code = OMP_CLAUSE_FIRSTPRIVATE;
6270 clause = build_omp_clause (input_location, code);
6271 OMP_CLAUSE_DECL (clause) = decl;
6272 OMP_CLAUSE_CHAIN (clause) = *list_p;
6274 OMP_CLAUSE_PRIVATE_DEBUG (clause) = 1;
6275 else if (code == OMP_CLAUSE_PRIVATE && (flags & GOVD_PRIVATE_OUTER_REF))
6276 OMP_CLAUSE_PRIVATE_OUTER_REF (clause) = 1;
6278 lang_hooks.decls.omp_finish_clause (clause);
6284 gimplify_adjust_omp_clauses (tree *list_p)
6286 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
6289 while ((c = *list_p) != NULL)
6292 bool remove = false;
6294 switch (OMP_CLAUSE_CODE (c))
6296 case OMP_CLAUSE_PRIVATE:
6297 case OMP_CLAUSE_SHARED:
6298 case OMP_CLAUSE_FIRSTPRIVATE:
6299 decl = OMP_CLAUSE_DECL (c);
6300 n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
6301 remove = !(n->value & GOVD_SEEN);
6304 bool shared = OMP_CLAUSE_CODE (c) == OMP_CLAUSE_SHARED;
6305 if ((n->value & GOVD_DEBUG_PRIVATE)
6306 || lang_hooks.decls.omp_private_debug_clause (decl, shared))
6308 gcc_assert ((n->value & GOVD_DEBUG_PRIVATE) == 0
6309 || ((n->value & GOVD_DATA_SHARE_CLASS)
6311 OMP_CLAUSE_SET_CODE (c, OMP_CLAUSE_PRIVATE);
6312 OMP_CLAUSE_PRIVATE_DEBUG (c) = 1;
6317 case OMP_CLAUSE_LASTPRIVATE:
6318 /* Make sure OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE is set to
6319 accurately reflect the presence of a FIRSTPRIVATE clause. */
6320 decl = OMP_CLAUSE_DECL (c);
6321 n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
6322 OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c)
6323 = (n->value & GOVD_FIRSTPRIVATE) != 0;
6326 case OMP_CLAUSE_REDUCTION:
6327 case OMP_CLAUSE_COPYIN:
6328 case OMP_CLAUSE_COPYPRIVATE:
6330 case OMP_CLAUSE_NUM_THREADS:
6331 case OMP_CLAUSE_SCHEDULE:
6332 case OMP_CLAUSE_NOWAIT:
6333 case OMP_CLAUSE_ORDERED:
6334 case OMP_CLAUSE_DEFAULT:
6335 case OMP_CLAUSE_UNTIED:
6336 case OMP_CLAUSE_COLLAPSE:
6337 case OMP_CLAUSE_FINAL:
6338 case OMP_CLAUSE_MERGEABLE:
6346 *list_p = OMP_CLAUSE_CHAIN (c);
6348 list_p = &OMP_CLAUSE_CHAIN (c);
6351 /* Add in any implicit data sharing. */
6352 splay_tree_foreach (ctx->variables, gimplify_adjust_omp_clauses_1, list_p);
6354 gimplify_omp_ctxp = ctx->outer_context;
6355 delete_omp_context (ctx);
6358 /* Gimplify the contents of an OMP_PARALLEL statement. This involves
6359 gimplification of the body, as well as scanning the body for used
6360 variables. We need to do this scan now, because variable-sized
6361 decls will be decomposed during gimplification. */
6364 gimplify_omp_parallel (tree *expr_p, gimple_seq *pre_p)
6366 tree expr = *expr_p;
6368 gimple_seq body = NULL;
6369 struct gimplify_ctx gctx;
6371 gimplify_scan_omp_clauses (&OMP_PARALLEL_CLAUSES (expr), pre_p,
6372 OMP_PARALLEL_COMBINED (expr)
6373 ? ORT_COMBINED_PARALLEL
6376 push_gimplify_context (&gctx);
6378 g = gimplify_and_return_first (OMP_PARALLEL_BODY (expr), &body);
6379 if (gimple_code (g) == GIMPLE_BIND)
6380 pop_gimplify_context (g);
6382 pop_gimplify_context (NULL);
6384 gimplify_adjust_omp_clauses (&OMP_PARALLEL_CLAUSES (expr));
6386 g = gimple_build_omp_parallel (body,
6387 OMP_PARALLEL_CLAUSES (expr),
6388 NULL_TREE, NULL_TREE);
6389 if (OMP_PARALLEL_COMBINED (expr))
6390 gimple_omp_set_subcode (g, GF_OMP_PARALLEL_COMBINED);
6391 gimplify_seq_add_stmt (pre_p, g);
6392 *expr_p = NULL_TREE;
6395 /* Gimplify the contents of an OMP_TASK statement. This involves
6396 gimplification of the body, as well as scanning the body for used
6397 variables. We need to do this scan now, because variable-sized
6398 decls will be decomposed during gimplification. */
6401 gimplify_omp_task (tree *expr_p, gimple_seq *pre_p)
6403 tree expr = *expr_p;
6405 gimple_seq body = NULL;
6406 struct gimplify_ctx gctx;
6408 gimplify_scan_omp_clauses (&OMP_TASK_CLAUSES (expr), pre_p,
6409 find_omp_clause (OMP_TASK_CLAUSES (expr),
6411 ? ORT_UNTIED_TASK : ORT_TASK);
6413 push_gimplify_context (&gctx);
6415 g = gimplify_and_return_first (OMP_TASK_BODY (expr), &body);
6416 if (gimple_code (g) == GIMPLE_BIND)
6417 pop_gimplify_context (g);
6419 pop_gimplify_context (NULL);
6421 gimplify_adjust_omp_clauses (&OMP_TASK_CLAUSES (expr));
6423 g = gimple_build_omp_task (body,
6424 OMP_TASK_CLAUSES (expr),
6425 NULL_TREE, NULL_TREE,
6426 NULL_TREE, NULL_TREE, NULL_TREE);
6427 gimplify_seq_add_stmt (pre_p, g);
6428 *expr_p = NULL_TREE;
6431 /* Gimplify the gross structure of an OMP_FOR statement. */
6433 static enum gimplify_status
6434 gimplify_omp_for (tree *expr_p, gimple_seq *pre_p)
6436 tree for_stmt, decl, var, t;
6437 enum gimplify_status ret = GS_ALL_DONE;
6438 enum gimplify_status tret;
6440 gimple_seq for_body, for_pre_body;
6445 gimplify_scan_omp_clauses (&OMP_FOR_CLAUSES (for_stmt), pre_p,
6448 /* Handle OMP_FOR_INIT. */
6449 for_pre_body = NULL;
6450 gimplify_and_add (OMP_FOR_PRE_BODY (for_stmt), &for_pre_body);
6451 OMP_FOR_PRE_BODY (for_stmt) = NULL_TREE;
6453 for_body = gimple_seq_alloc ();
6454 gcc_assert (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt))
6455 == TREE_VEC_LENGTH (OMP_FOR_COND (for_stmt)));
6456 gcc_assert (TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt))
6457 == TREE_VEC_LENGTH (OMP_FOR_INCR (for_stmt)));
6458 for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)); i++)
6460 t = TREE_VEC_ELT (OMP_FOR_INIT (for_stmt), i);
6461 gcc_assert (TREE_CODE (t) == MODIFY_EXPR);
6462 decl = TREE_OPERAND (t, 0);
6463 gcc_assert (DECL_P (decl));
6464 gcc_assert (INTEGRAL_TYPE_P (TREE_TYPE (decl))
6465 || POINTER_TYPE_P (TREE_TYPE (decl)));
6467 /* Make sure the iteration variable is private. */
6468 if (omp_is_private (gimplify_omp_ctxp, decl))
6469 omp_notice_variable (gimplify_omp_ctxp, decl, true);
6471 omp_add_variable (gimplify_omp_ctxp, decl, GOVD_PRIVATE | GOVD_SEEN);
6473 /* If DECL is not a gimple register, create a temporary variable to act
6474 as an iteration counter. This is valid, since DECL cannot be
6475 modified in the body of the loop. */
6476 if (!is_gimple_reg (decl))
6478 var = create_tmp_var (TREE_TYPE (decl), get_name (decl));
6479 TREE_OPERAND (t, 0) = var;
6481 gimplify_seq_add_stmt (&for_body, gimple_build_assign (decl, var));
6483 omp_add_variable (gimplify_omp_ctxp, var, GOVD_PRIVATE | GOVD_SEEN);
6488 tret = gimplify_expr (&TREE_OPERAND (t, 1), &for_pre_body, NULL,
6489 is_gimple_val, fb_rvalue);
6490 ret = MIN (ret, tret);
6491 if (ret == GS_ERROR)
6494 /* Handle OMP_FOR_COND. */
6495 t = TREE_VEC_ELT (OMP_FOR_COND (for_stmt), i);
6496 gcc_assert (COMPARISON_CLASS_P (t));
6497 gcc_assert (TREE_OPERAND (t, 0) == decl);
6499 tret = gimplify_expr (&TREE_OPERAND (t, 1), &for_pre_body, NULL,
6500 is_gimple_val, fb_rvalue);
6501 ret = MIN (ret, tret);
6503 /* Handle OMP_FOR_INCR. */
6504 t = TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i);
6505 switch (TREE_CODE (t))
6507 case PREINCREMENT_EXPR:
6508 case POSTINCREMENT_EXPR:
6509 t = build_int_cst (TREE_TYPE (decl), 1);
6510 t = build2 (PLUS_EXPR, TREE_TYPE (decl), var, t);
6511 t = build2 (MODIFY_EXPR, TREE_TYPE (var), var, t);
6512 TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i) = t;
6515 case PREDECREMENT_EXPR:
6516 case POSTDECREMENT_EXPR:
6517 t = build_int_cst (TREE_TYPE (decl), -1);
6518 t = build2 (PLUS_EXPR, TREE_TYPE (decl), var, t);
6519 t = build2 (MODIFY_EXPR, TREE_TYPE (var), var, t);
6520 TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i) = t;
6524 gcc_assert (TREE_OPERAND (t, 0) == decl);
6525 TREE_OPERAND (t, 0) = var;
6527 t = TREE_OPERAND (t, 1);
6528 switch (TREE_CODE (t))
6531 if (TREE_OPERAND (t, 1) == decl)
6533 TREE_OPERAND (t, 1) = TREE_OPERAND (t, 0);
6534 TREE_OPERAND (t, 0) = var;
6540 case POINTER_PLUS_EXPR:
6541 gcc_assert (TREE_OPERAND (t, 0) == decl);
6542 TREE_OPERAND (t, 0) = var;
6548 tret = gimplify_expr (&TREE_OPERAND (t, 1), &for_pre_body, NULL,
6549 is_gimple_val, fb_rvalue);
6550 ret = MIN (ret, tret);
6557 if (var != decl || TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)) > 1)
6560 for (c = OMP_FOR_CLAUSES (for_stmt); c ; c = OMP_CLAUSE_CHAIN (c))
6561 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_LASTPRIVATE
6562 && OMP_CLAUSE_DECL (c) == decl
6563 && OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c) == NULL)
6565 t = TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i);
6566 gcc_assert (TREE_CODE (t) == MODIFY_EXPR);
6567 gcc_assert (TREE_OPERAND (t, 0) == var);
6568 t = TREE_OPERAND (t, 1);
6569 gcc_assert (TREE_CODE (t) == PLUS_EXPR
6570 || TREE_CODE (t) == MINUS_EXPR
6571 || TREE_CODE (t) == POINTER_PLUS_EXPR);
6572 gcc_assert (TREE_OPERAND (t, 0) == var);
6573 t = build2 (TREE_CODE (t), TREE_TYPE (decl), decl,
6574 TREE_OPERAND (t, 1));
6575 gimplify_assign (decl, t,
6576 &OMP_CLAUSE_LASTPRIVATE_GIMPLE_SEQ (c));
6581 gimplify_and_add (OMP_FOR_BODY (for_stmt), &for_body);
6583 gimplify_adjust_omp_clauses (&OMP_FOR_CLAUSES (for_stmt));
6585 gfor = gimple_build_omp_for (for_body, OMP_FOR_CLAUSES (for_stmt),
6586 TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)),
6589 for (i = 0; i < TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)); i++)
6591 t = TREE_VEC_ELT (OMP_FOR_INIT (for_stmt), i);
6592 gimple_omp_for_set_index (gfor, i, TREE_OPERAND (t, 0));
6593 gimple_omp_for_set_initial (gfor, i, TREE_OPERAND (t, 1));
6594 t = TREE_VEC_ELT (OMP_FOR_COND (for_stmt), i);
6595 gimple_omp_for_set_cond (gfor, i, TREE_CODE (t));
6596 gimple_omp_for_set_final (gfor, i, TREE_OPERAND (t, 1));
6597 t = TREE_VEC_ELT (OMP_FOR_INCR (for_stmt), i);
6598 gimple_omp_for_set_incr (gfor, i, TREE_OPERAND (t, 1));
6601 gimplify_seq_add_stmt (pre_p, gfor);
6602 return ret == GS_ALL_DONE ? GS_ALL_DONE : GS_ERROR;
6605 /* Gimplify the gross structure of other OpenMP worksharing constructs.
6606 In particular, OMP_SECTIONS and OMP_SINGLE. */
6609 gimplify_omp_workshare (tree *expr_p, gimple_seq *pre_p)
6611 tree expr = *expr_p;
6613 gimple_seq body = NULL;
6615 gimplify_scan_omp_clauses (&OMP_CLAUSES (expr), pre_p, ORT_WORKSHARE);
6616 gimplify_and_add (OMP_BODY (expr), &body);
6617 gimplify_adjust_omp_clauses (&OMP_CLAUSES (expr));
6619 if (TREE_CODE (expr) == OMP_SECTIONS)
6620 stmt = gimple_build_omp_sections (body, OMP_CLAUSES (expr));
6621 else if (TREE_CODE (expr) == OMP_SINGLE)
6622 stmt = gimple_build_omp_single (body, OMP_CLAUSES (expr));
6626 gimplify_seq_add_stmt (pre_p, stmt);
6629 /* A subroutine of gimplify_omp_atomic. The front end is supposed to have
6630 stabilized the lhs of the atomic operation as *ADDR. Return true if
6631 EXPR is this stabilized form. */
6634 goa_lhs_expr_p (tree expr, tree addr)
6636 /* Also include casts to other type variants. The C front end is fond
6637 of adding these for e.g. volatile variables. This is like
6638 STRIP_TYPE_NOPS but includes the main variant lookup. */
6639 STRIP_USELESS_TYPE_CONVERSION (expr);
6641 if (TREE_CODE (expr) == INDIRECT_REF)
6643 expr = TREE_OPERAND (expr, 0);
6645 && (CONVERT_EXPR_P (expr)
6646 || TREE_CODE (expr) == NON_LVALUE_EXPR)
6647 && TREE_CODE (expr) == TREE_CODE (addr)
6648 && types_compatible_p (TREE_TYPE (expr), TREE_TYPE (addr)))
6650 expr = TREE_OPERAND (expr, 0);
6651 addr = TREE_OPERAND (addr, 0);
6655 return (TREE_CODE (addr) == ADDR_EXPR
6656 && TREE_CODE (expr) == ADDR_EXPR
6657 && TREE_OPERAND (addr, 0) == TREE_OPERAND (expr, 0));
6659 if (TREE_CODE (addr) == ADDR_EXPR && expr == TREE_OPERAND (addr, 0))
6664 /* Walk *EXPR_P and replace appearances of *LHS_ADDR with LHS_VAR. If an
6665 expression does not involve the lhs, evaluate it into a temporary.
6666 Return 1 if the lhs appeared as a subexpression, 0 if it did not,
6667 or -1 if an error was encountered. */
6670 goa_stabilize_expr (tree *expr_p, gimple_seq *pre_p, tree lhs_addr,
6673 tree expr = *expr_p;
6676 if (goa_lhs_expr_p (expr, lhs_addr))
6681 if (is_gimple_val (expr))
6685 switch (TREE_CODE_CLASS (TREE_CODE (expr)))
6688 case tcc_comparison:
6689 saw_lhs |= goa_stabilize_expr (&TREE_OPERAND (expr, 1), pre_p, lhs_addr,
6692 saw_lhs |= goa_stabilize_expr (&TREE_OPERAND (expr, 0), pre_p, lhs_addr,
6695 case tcc_expression:
6696 switch (TREE_CODE (expr))
6698 case TRUTH_ANDIF_EXPR:
6699 case TRUTH_ORIF_EXPR:
6700 case TRUTH_AND_EXPR:
6702 case TRUTH_XOR_EXPR:
6703 saw_lhs |= goa_stabilize_expr (&TREE_OPERAND (expr, 1), pre_p,
6705 case TRUTH_NOT_EXPR:
6706 saw_lhs |= goa_stabilize_expr (&TREE_OPERAND (expr, 0), pre_p,
6710 /* Break out any preevaluations from cp_build_modify_expr. */
6711 for (; TREE_CODE (expr) == COMPOUND_EXPR;
6712 expr = TREE_OPERAND (expr, 1))
6713 gimplify_stmt (&TREE_OPERAND (expr, 0), pre_p);
6715 return goa_stabilize_expr (expr_p, pre_p, lhs_addr, lhs_var);
6726 enum gimplify_status gs;
6727 gs = gimplify_expr (expr_p, pre_p, NULL, is_gimple_val, fb_rvalue);
6728 if (gs != GS_ALL_DONE)
6735 /* Gimplify an OMP_ATOMIC statement. */
6737 static enum gimplify_status
6738 gimplify_omp_atomic (tree *expr_p, gimple_seq *pre_p)
6740 tree addr = TREE_OPERAND (*expr_p, 0);
6741 tree rhs = TREE_CODE (*expr_p) == OMP_ATOMIC_READ
6742 ? NULL : TREE_OPERAND (*expr_p, 1);
6743 tree type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (addr)));
6745 gimple loadstmt, storestmt;
6747 tmp_load = create_tmp_reg (type, NULL);
6748 if (rhs && goa_stabilize_expr (&rhs, pre_p, addr, tmp_load) < 0)
6751 if (gimplify_expr (&addr, pre_p, NULL, is_gimple_val, fb_rvalue)
6755 loadstmt = gimple_build_omp_atomic_load (tmp_load, addr);
6756 gimplify_seq_add_stmt (pre_p, loadstmt);
6757 if (rhs && gimplify_expr (&rhs, pre_p, NULL, is_gimple_val, fb_rvalue)
6761 if (TREE_CODE (*expr_p) == OMP_ATOMIC_READ)
6763 storestmt = gimple_build_omp_atomic_store (rhs);
6764 gimplify_seq_add_stmt (pre_p, storestmt);
6765 switch (TREE_CODE (*expr_p))
6767 case OMP_ATOMIC_READ:
6768 case OMP_ATOMIC_CAPTURE_OLD:
6770 gimple_omp_atomic_set_need_value (loadstmt);
6772 case OMP_ATOMIC_CAPTURE_NEW:
6774 gimple_omp_atomic_set_need_value (storestmt);
6784 /* Gimplify a TRANSACTION_EXPR. This involves gimplification of the
6785 body, and adding some EH bits. */
6787 static enum gimplify_status
6788 gimplify_transaction (tree *expr_p, gimple_seq *pre_p)
6790 tree expr = *expr_p, temp, tbody = TRANSACTION_EXPR_BODY (expr);
6792 gimple_seq body = NULL;
6793 struct gimplify_ctx gctx;
6796 /* Wrap the transaction body in a BIND_EXPR so we have a context
6797 where to put decls for OpenMP. */
6798 if (TREE_CODE (tbody) != BIND_EXPR)
6800 tree bind = build3 (BIND_EXPR, void_type_node, NULL, tbody, NULL);
6801 TREE_SIDE_EFFECTS (bind) = 1;
6802 SET_EXPR_LOCATION (bind, EXPR_LOCATION (tbody));
6803 TRANSACTION_EXPR_BODY (expr) = bind;
6806 push_gimplify_context (&gctx);
6807 temp = voidify_wrapper_expr (*expr_p, NULL);
6809 g = gimplify_and_return_first (TRANSACTION_EXPR_BODY (expr), &body);
6810 pop_gimplify_context (g);
6812 g = gimple_build_transaction (body, NULL);
6813 if (TRANSACTION_EXPR_OUTER (expr))
6814 subcode = GTMA_IS_OUTER;
6815 else if (TRANSACTION_EXPR_RELAXED (expr))
6816 subcode = GTMA_IS_RELAXED;
6817 gimple_transaction_set_subcode (g, subcode);
6819 gimplify_seq_add_stmt (pre_p, g);
6827 *expr_p = NULL_TREE;
6831 /* Convert the GENERIC expression tree *EXPR_P to GIMPLE. If the
6832 expression produces a value to be used as an operand inside a GIMPLE
6833 statement, the value will be stored back in *EXPR_P. This value will
6834 be a tree of class tcc_declaration, tcc_constant, tcc_reference or
6835 an SSA_NAME. The corresponding sequence of GIMPLE statements is
6836 emitted in PRE_P and POST_P.
6838 Additionally, this process may overwrite parts of the input
6839 expression during gimplification. Ideally, it should be
6840 possible to do non-destructive gimplification.
6842 EXPR_P points to the GENERIC expression to convert to GIMPLE. If
6843 the expression needs to evaluate to a value to be used as
6844 an operand in a GIMPLE statement, this value will be stored in
6845 *EXPR_P on exit. This happens when the caller specifies one
6846 of fb_lvalue or fb_rvalue fallback flags.
6848 PRE_P will contain the sequence of GIMPLE statements corresponding
6849 to the evaluation of EXPR and all the side-effects that must
6850 be executed before the main expression. On exit, the last
6851 statement of PRE_P is the core statement being gimplified. For
6852 instance, when gimplifying 'if (++a)' the last statement in
6853 PRE_P will be 'if (t.1)' where t.1 is the result of
6854 pre-incrementing 'a'.
6856 POST_P will contain the sequence of GIMPLE statements corresponding
6857 to the evaluation of all the side-effects that must be executed
6858 after the main expression. If this is NULL, the post
6859 side-effects are stored at the end of PRE_P.
6861 The reason why the output is split in two is to handle post
6862 side-effects explicitly. In some cases, an expression may have
6863 inner and outer post side-effects which need to be emitted in
6864 an order different from the one given by the recursive
6865 traversal. For instance, for the expression (*p--)++ the post
6866 side-effects of '--' must actually occur *after* the post
6867 side-effects of '++'. However, gimplification will first visit
6868 the inner expression, so if a separate POST sequence was not
6869 used, the resulting sequence would be:
6876 However, the post-decrement operation in line #2 must not be
6877 evaluated until after the store to *p at line #4, so the
6878 correct sequence should be:
6885 So, by specifying a separate post queue, it is possible
6886 to emit the post side-effects in the correct order.
6887 If POST_P is NULL, an internal queue will be used. Before
6888 returning to the caller, the sequence POST_P is appended to
6889 the main output sequence PRE_P.
6891 GIMPLE_TEST_F points to a function that takes a tree T and
6892 returns nonzero if T is in the GIMPLE form requested by the
6893 caller. The GIMPLE predicates are in gimple.c.
6895 FALLBACK tells the function what sort of a temporary we want if
6896 gimplification cannot produce an expression that complies with
6899 fb_none means that no temporary should be generated
6900 fb_rvalue means that an rvalue is OK to generate
6901 fb_lvalue means that an lvalue is OK to generate
6902 fb_either means that either is OK, but an lvalue is preferable.
6903 fb_mayfail means that gimplification may fail (in which case
6904 GS_ERROR will be returned)
6906 The return value is either GS_ERROR or GS_ALL_DONE, since this
6907 function iterates until EXPR is completely gimplified or an error
6910 enum gimplify_status
6911 gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p,
6912 bool (*gimple_test_f) (tree), fallback_t fallback)
6915 gimple_seq internal_pre = NULL;
6916 gimple_seq internal_post = NULL;
6919 location_t saved_location;
6920 enum gimplify_status ret;
6921 gimple_stmt_iterator pre_last_gsi, post_last_gsi;
6923 save_expr = *expr_p;
6924 if (save_expr == NULL_TREE)
6927 /* If we are gimplifying a top-level statement, PRE_P must be valid. */
6928 is_statement = gimple_test_f == is_gimple_stmt;
6932 /* Consistency checks. */
6933 if (gimple_test_f == is_gimple_reg)
6934 gcc_assert (fallback & (fb_rvalue | fb_lvalue));
6935 else if (gimple_test_f == is_gimple_val
6936 || gimple_test_f == is_gimple_call_addr
6937 || gimple_test_f == is_gimple_condexpr
6938 || gimple_test_f == is_gimple_mem_rhs
6939 || gimple_test_f == is_gimple_mem_rhs_or_call
6940 || gimple_test_f == is_gimple_reg_rhs
6941 || gimple_test_f == is_gimple_reg_rhs_or_call
6942 || gimple_test_f == is_gimple_asm_val
6943 || gimple_test_f == is_gimple_mem_ref_addr)
6944 gcc_assert (fallback & fb_rvalue);
6945 else if (gimple_test_f == is_gimple_min_lval
6946 || gimple_test_f == is_gimple_lvalue)
6947 gcc_assert (fallback & fb_lvalue);
6948 else if (gimple_test_f == is_gimple_addressable)
6949 gcc_assert (fallback & fb_either);
6950 else if (gimple_test_f == is_gimple_stmt)
6951 gcc_assert (fallback == fb_none);
6954 /* We should have recognized the GIMPLE_TEST_F predicate to
6955 know what kind of fallback to use in case a temporary is
6956 needed to hold the value or address of *EXPR_P. */
6960 /* We used to check the predicate here and return immediately if it
6961 succeeds. This is wrong; the design is for gimplification to be
6962 idempotent, and for the predicates to only test for valid forms, not
6963 whether they are fully simplified. */
6965 pre_p = &internal_pre;
6968 post_p = &internal_post;
6970 /* Remember the last statements added to PRE_P and POST_P. Every
6971 new statement added by the gimplification helpers needs to be
6972 annotated with location information. To centralize the
6973 responsibility, we remember the last statement that had been
6974 added to both queues before gimplifying *EXPR_P. If
6975 gimplification produces new statements in PRE_P and POST_P, those
6976 statements will be annotated with the same location information
6978 pre_last_gsi = gsi_last (*pre_p);
6979 post_last_gsi = gsi_last (*post_p);
6981 saved_location = input_location;
6982 if (save_expr != error_mark_node
6983 && EXPR_HAS_LOCATION (*expr_p))
6984 input_location = EXPR_LOCATION (*expr_p);
6986 /* Loop over the specific gimplifiers until the toplevel node
6987 remains the same. */
6990 /* Strip away as many useless type conversions as possible
6992 STRIP_USELESS_TYPE_CONVERSION (*expr_p);
6994 /* Remember the expr. */
6995 save_expr = *expr_p;
6997 /* Die, die, die, my darling. */
6998 if (save_expr == error_mark_node
6999 || (TREE_TYPE (save_expr)
7000 && TREE_TYPE (save_expr) == error_mark_node))
7006 /* Do any language-specific gimplification. */
7007 ret = ((enum gimplify_status)
7008 lang_hooks.gimplify_expr (expr_p, pre_p, post_p));
7011 if (*expr_p == NULL_TREE)
7013 if (*expr_p != save_expr)
7016 else if (ret != GS_UNHANDLED)
7019 /* Make sure that all the cases set 'ret' appropriately. */
7021 switch (TREE_CODE (*expr_p))
7023 /* First deal with the special cases. */
7025 case POSTINCREMENT_EXPR:
7026 case POSTDECREMENT_EXPR:
7027 case PREINCREMENT_EXPR:
7028 case PREDECREMENT_EXPR:
7029 ret = gimplify_self_mod_expr (expr_p, pre_p, post_p,
7030 fallback != fb_none);
7034 case ARRAY_RANGE_REF:
7038 case VIEW_CONVERT_EXPR:
7039 ret = gimplify_compound_lval (expr_p, pre_p, post_p,
7040 fallback ? fallback : fb_rvalue);
7044 ret = gimplify_cond_expr (expr_p, pre_p, fallback);
7046 /* C99 code may assign to an array in a structure value of a
7047 conditional expression, and this has undefined behavior
7048 only on execution, so create a temporary if an lvalue is
7050 if (fallback == fb_lvalue)
7052 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
7053 mark_addressable (*expr_p);
7059 ret = gimplify_call_expr (expr_p, pre_p, fallback != fb_none);
7061 /* C99 code may assign to an array in a structure returned
7062 from a function, and this has undefined behavior only on
7063 execution, so create a temporary if an lvalue is
7065 if (fallback == fb_lvalue)
7067 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
7068 mark_addressable (*expr_p);
7077 ret = gimplify_compound_expr (expr_p, pre_p, fallback != fb_none);
7080 case COMPOUND_LITERAL_EXPR:
7081 ret = gimplify_compound_literal_expr (expr_p, pre_p, fallback);
7086 ret = gimplify_modify_expr (expr_p, pre_p, post_p,
7087 fallback != fb_none);
7090 case TRUTH_ANDIF_EXPR:
7091 case TRUTH_ORIF_EXPR:
7093 /* Preserve the original type of the expression and the
7094 source location of the outer expression. */
7095 tree org_type = TREE_TYPE (*expr_p);
7096 *expr_p = gimple_boolify (*expr_p);
7097 *expr_p = build3_loc (input_location, COND_EXPR,
7101 org_type, boolean_true_node),
7104 org_type, boolean_false_node));
7109 case TRUTH_NOT_EXPR:
7111 tree type = TREE_TYPE (*expr_p);
7112 /* The parsers are careful to generate TRUTH_NOT_EXPR
7113 only with operands that are always zero or one.
7114 We do not fold here but handle the only interesting case
7115 manually, as fold may re-introduce the TRUTH_NOT_EXPR. */
7116 *expr_p = gimple_boolify (*expr_p);
7117 if (TYPE_PRECISION (TREE_TYPE (*expr_p)) == 1)
7118 *expr_p = build1_loc (input_location, BIT_NOT_EXPR,
7119 TREE_TYPE (*expr_p),
7120 TREE_OPERAND (*expr_p, 0));
7122 *expr_p = build2_loc (input_location, BIT_XOR_EXPR,
7123 TREE_TYPE (*expr_p),
7124 TREE_OPERAND (*expr_p, 0),
7125 build_int_cst (TREE_TYPE (*expr_p), 1));
7126 if (!useless_type_conversion_p (type, TREE_TYPE (*expr_p)))
7127 *expr_p = fold_convert_loc (input_location, type, *expr_p);
7133 ret = gimplify_addr_expr (expr_p, pre_p, post_p);
7137 ret = gimplify_va_arg_expr (expr_p, pre_p, post_p);
7141 if (IS_EMPTY_STMT (*expr_p))
7147 if (VOID_TYPE_P (TREE_TYPE (*expr_p))
7148 || fallback == fb_none)
7150 /* Just strip a conversion to void (or in void context) and
7152 *expr_p = TREE_OPERAND (*expr_p, 0);
7157 ret = gimplify_conversion (expr_p);
7158 if (ret == GS_ERROR)
7160 if (*expr_p != save_expr)
7164 case FIX_TRUNC_EXPR:
7165 /* unary_expr: ... | '(' cast ')' val | ... */
7166 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
7167 is_gimple_val, fb_rvalue);
7168 recalculate_side_effects (*expr_p);
7173 bool volatilep = TREE_THIS_VOLATILE (*expr_p);
7174 bool notrap = TREE_THIS_NOTRAP (*expr_p);
7175 tree saved_ptr_type = TREE_TYPE (TREE_OPERAND (*expr_p, 0));
7177 *expr_p = fold_indirect_ref_loc (input_location, *expr_p);
7178 if (*expr_p != save_expr)
7184 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
7185 is_gimple_reg, fb_rvalue);
7186 if (ret == GS_ERROR)
7189 recalculate_side_effects (*expr_p);
7190 *expr_p = fold_build2_loc (input_location, MEM_REF,
7191 TREE_TYPE (*expr_p),
7192 TREE_OPERAND (*expr_p, 0),
7193 build_int_cst (saved_ptr_type, 0));
7194 TREE_THIS_VOLATILE (*expr_p) = volatilep;
7195 TREE_THIS_NOTRAP (*expr_p) = notrap;
7200 /* We arrive here through the various re-gimplifcation paths. */
7202 /* First try re-folding the whole thing. */
7203 tmp = fold_binary (MEM_REF, TREE_TYPE (*expr_p),
7204 TREE_OPERAND (*expr_p, 0),
7205 TREE_OPERAND (*expr_p, 1));
7209 recalculate_side_effects (*expr_p);
7213 /* Avoid re-gimplifying the address operand if it is already
7214 in suitable form. Re-gimplifying would mark the address
7215 operand addressable. Always gimplify when not in SSA form
7216 as we still may have to gimplify decls with value-exprs. */
7217 if (!gimplify_ctxp || !gimplify_ctxp->into_ssa
7218 || !is_gimple_mem_ref_addr (TREE_OPERAND (*expr_p, 0)))
7220 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
7221 is_gimple_mem_ref_addr, fb_rvalue);
7222 if (ret == GS_ERROR)
7225 recalculate_side_effects (*expr_p);
7229 /* Constants need not be gimplified. */
7240 /* If we require an lvalue, such as for ADDR_EXPR, retain the
7241 CONST_DECL node. Otherwise the decl is replaceable by its
7243 /* ??? Should be == fb_lvalue, but ADDR_EXPR passes fb_either. */
7244 if (fallback & fb_lvalue)
7248 *expr_p = DECL_INITIAL (*expr_p);
7254 ret = gimplify_decl_expr (expr_p, pre_p);
7258 ret = gimplify_bind_expr (expr_p, pre_p);
7262 ret = gimplify_loop_expr (expr_p, pre_p);
7266 ret = gimplify_switch_expr (expr_p, pre_p);
7270 ret = gimplify_exit_expr (expr_p);
7274 /* If the target is not LABEL, then it is a computed jump
7275 and the target needs to be gimplified. */
7276 if (TREE_CODE (GOTO_DESTINATION (*expr_p)) != LABEL_DECL)
7278 ret = gimplify_expr (&GOTO_DESTINATION (*expr_p), pre_p,
7279 NULL, is_gimple_val, fb_rvalue);
7280 if (ret == GS_ERROR)
7283 gimplify_seq_add_stmt (pre_p,
7284 gimple_build_goto (GOTO_DESTINATION (*expr_p)));
7289 gimplify_seq_add_stmt (pre_p,
7290 gimple_build_predict (PREDICT_EXPR_PREDICTOR (*expr_p),
7291 PREDICT_EXPR_OUTCOME (*expr_p)));
7297 gcc_assert (decl_function_context (LABEL_EXPR_LABEL (*expr_p))
7298 == current_function_decl);
7299 gimplify_seq_add_stmt (pre_p,
7300 gimple_build_label (LABEL_EXPR_LABEL (*expr_p)));
7303 case CASE_LABEL_EXPR:
7304 ret = gimplify_case_label_expr (expr_p, pre_p);
7308 ret = gimplify_return_expr (*expr_p, pre_p);
7312 /* Don't reduce this in place; let gimplify_init_constructor work its
7313 magic. Buf if we're just elaborating this for side effects, just
7314 gimplify any element that has side-effects. */
7315 if (fallback == fb_none)
7317 unsigned HOST_WIDE_INT ix;
7319 tree temp = NULL_TREE;
7320 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (*expr_p), ix, val)
7321 if (TREE_SIDE_EFFECTS (val))
7322 append_to_statement_list (val, &temp);
7325 ret = temp ? GS_OK : GS_ALL_DONE;
7327 /* C99 code may assign to an array in a constructed
7328 structure or union, and this has undefined behavior only
7329 on execution, so create a temporary if an lvalue is
7331 else if (fallback == fb_lvalue)
7333 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
7334 mark_addressable (*expr_p);
7341 /* The following are special cases that are not handled by the
7342 original GIMPLE grammar. */
7344 /* SAVE_EXPR nodes are converted into a GIMPLE identifier and
7347 ret = gimplify_save_expr (expr_p, pre_p, post_p);
7352 enum gimplify_status r0, r1, r2;
7354 r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
7355 post_p, is_gimple_lvalue, fb_either);
7356 r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p,
7357 post_p, is_gimple_val, fb_rvalue);
7358 r2 = gimplify_expr (&TREE_OPERAND (*expr_p, 2), pre_p,
7359 post_p, is_gimple_val, fb_rvalue);
7360 recalculate_side_effects (*expr_p);
7362 ret = MIN (r0, MIN (r1, r2));
7366 case TARGET_MEM_REF:
7368 enum gimplify_status r0 = GS_ALL_DONE, r1 = GS_ALL_DONE;
7370 if (TMR_BASE (*expr_p))
7371 r0 = gimplify_expr (&TMR_BASE (*expr_p), pre_p,
7372 post_p, is_gimple_mem_ref_addr, fb_either);
7373 if (TMR_INDEX (*expr_p))
7374 r1 = gimplify_expr (&TMR_INDEX (*expr_p), pre_p,
7375 post_p, is_gimple_val, fb_rvalue);
7376 if (TMR_INDEX2 (*expr_p))
7377 r1 = gimplify_expr (&TMR_INDEX2 (*expr_p), pre_p,
7378 post_p, is_gimple_val, fb_rvalue);
7379 /* TMR_STEP and TMR_OFFSET are always integer constants. */
7384 case NON_LVALUE_EXPR:
7385 /* This should have been stripped above. */
7389 ret = gimplify_asm_expr (expr_p, pre_p, post_p);
7392 case TRY_FINALLY_EXPR:
7393 case TRY_CATCH_EXPR:
7395 gimple_seq eval, cleanup;
7398 eval = cleanup = NULL;
7399 gimplify_and_add (TREE_OPERAND (*expr_p, 0), &eval);
7400 gimplify_and_add (TREE_OPERAND (*expr_p, 1), &cleanup);
7401 /* Don't create bogus GIMPLE_TRY with empty cleanup. */
7402 if (gimple_seq_empty_p (cleanup))
7404 gimple_seq_add_seq (pre_p, eval);
7408 try_ = gimple_build_try (eval, cleanup,
7409 TREE_CODE (*expr_p) == TRY_FINALLY_EXPR
7410 ? GIMPLE_TRY_FINALLY
7411 : GIMPLE_TRY_CATCH);
7412 if (TREE_CODE (*expr_p) == TRY_CATCH_EXPR)
7413 gimple_try_set_catch_is_cleanup (try_,
7414 TRY_CATCH_IS_CLEANUP (*expr_p));
7415 gimplify_seq_add_stmt (pre_p, try_);
7420 case CLEANUP_POINT_EXPR:
7421 ret = gimplify_cleanup_point_expr (expr_p, pre_p);
7425 ret = gimplify_target_expr (expr_p, pre_p, post_p);
7431 gimple_seq handler = NULL;
7432 gimplify_and_add (CATCH_BODY (*expr_p), &handler);
7433 c = gimple_build_catch (CATCH_TYPES (*expr_p), handler);
7434 gimplify_seq_add_stmt (pre_p, c);
7439 case EH_FILTER_EXPR:
7442 gimple_seq failure = NULL;
7444 gimplify_and_add (EH_FILTER_FAILURE (*expr_p), &failure);
7445 ehf = gimple_build_eh_filter (EH_FILTER_TYPES (*expr_p), failure);
7446 gimple_set_no_warning (ehf, TREE_NO_WARNING (*expr_p));
7447 gimplify_seq_add_stmt (pre_p, ehf);
7454 enum gimplify_status r0, r1;
7455 r0 = gimplify_expr (&OBJ_TYPE_REF_OBJECT (*expr_p), pre_p,
7456 post_p, is_gimple_val, fb_rvalue);
7457 r1 = gimplify_expr (&OBJ_TYPE_REF_EXPR (*expr_p), pre_p,
7458 post_p, is_gimple_val, fb_rvalue);
7459 TREE_SIDE_EFFECTS (*expr_p) = 0;
7465 /* We get here when taking the address of a label. We mark
7466 the label as "forced"; meaning it can never be removed and
7467 it is a potential target for any computed goto. */
7468 FORCED_LABEL (*expr_p) = 1;
7472 case STATEMENT_LIST:
7473 ret = gimplify_statement_list (expr_p, pre_p);
7476 case WITH_SIZE_EXPR:
7478 gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
7479 post_p == &internal_post ? NULL : post_p,
7480 gimple_test_f, fallback);
7481 gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p,
7482 is_gimple_val, fb_rvalue);
7489 ret = gimplify_var_or_parm_decl (expr_p);
7493 /* When within an OpenMP context, notice uses of variables. */
7494 if (gimplify_omp_ctxp)
7495 omp_notice_variable (gimplify_omp_ctxp, *expr_p, true);
7500 /* Allow callbacks into the gimplifier during optimization. */
7505 gimplify_omp_parallel (expr_p, pre_p);
7510 gimplify_omp_task (expr_p, pre_p);
7515 ret = gimplify_omp_for (expr_p, pre_p);
7520 gimplify_omp_workshare (expr_p, pre_p);
7529 gimple_seq body = NULL;
7532 gimplify_and_add (OMP_BODY (*expr_p), &body);
7533 switch (TREE_CODE (*expr_p))
7536 g = gimple_build_omp_section (body);
7539 g = gimple_build_omp_master (body);
7542 g = gimple_build_omp_ordered (body);
7545 g = gimple_build_omp_critical (body,
7546 OMP_CRITICAL_NAME (*expr_p));
7551 gimplify_seq_add_stmt (pre_p, g);
7557 case OMP_ATOMIC_READ:
7558 case OMP_ATOMIC_CAPTURE_OLD:
7559 case OMP_ATOMIC_CAPTURE_NEW:
7560 ret = gimplify_omp_atomic (expr_p, pre_p);
7563 case TRANSACTION_EXPR:
7564 ret = gimplify_transaction (expr_p, pre_p);
7567 case TRUTH_AND_EXPR:
7569 case TRUTH_XOR_EXPR:
7571 tree orig_type = TREE_TYPE (*expr_p);
7572 tree new_type, xop0, xop1;
7573 *expr_p = gimple_boolify (*expr_p);
7574 new_type = TREE_TYPE (*expr_p);
7575 if (!useless_type_conversion_p (orig_type, new_type))
7577 *expr_p = fold_convert_loc (input_location, orig_type, *expr_p);
7582 /* Boolified binary truth expressions are semantically equivalent
7583 to bitwise binary expressions. Canonicalize them to the
7585 switch (TREE_CODE (*expr_p))
7587 case TRUTH_AND_EXPR:
7588 TREE_SET_CODE (*expr_p, BIT_AND_EXPR);
7591 TREE_SET_CODE (*expr_p, BIT_IOR_EXPR);
7593 case TRUTH_XOR_EXPR:
7594 TREE_SET_CODE (*expr_p, BIT_XOR_EXPR);
7599 /* Now make sure that operands have compatible type to
7600 expression's new_type. */
7601 xop0 = TREE_OPERAND (*expr_p, 0);
7602 xop1 = TREE_OPERAND (*expr_p, 1);
7603 if (!useless_type_conversion_p (new_type, TREE_TYPE (xop0)))
7604 TREE_OPERAND (*expr_p, 0) = fold_convert_loc (input_location,
7607 if (!useless_type_conversion_p (new_type, TREE_TYPE (xop1)))
7608 TREE_OPERAND (*expr_p, 1) = fold_convert_loc (input_location,
7611 /* Continue classified as tcc_binary. */
7617 /* Classified as tcc_expression. */
7620 case POINTER_PLUS_EXPR:
7622 enum gimplify_status r0, r1;
7623 r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
7624 post_p, is_gimple_val, fb_rvalue);
7625 r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p,
7626 post_p, is_gimple_val, fb_rvalue);
7627 recalculate_side_effects (*expr_p);
7629 /* Convert &X + CST to invariant &MEM[&X, CST]. Do this
7630 after gimplifying operands - this is similar to how
7631 it would be folding all gimplified stmts on creation
7632 to have them canonicalized, which is what we eventually
7633 should do anyway. */
7634 if (TREE_CODE (TREE_OPERAND (*expr_p, 1)) == INTEGER_CST
7635 && is_gimple_min_invariant (TREE_OPERAND (*expr_p, 0)))
7637 *expr_p = build_fold_addr_expr_with_type_loc
7639 fold_build2 (MEM_REF, TREE_TYPE (TREE_TYPE (*expr_p)),
7640 TREE_OPERAND (*expr_p, 0),
7641 fold_convert (ptr_type_node,
7642 TREE_OPERAND (*expr_p, 1))),
7643 TREE_TYPE (*expr_p));
7644 ret = MIN (ret, GS_OK);
7650 switch (TREE_CODE_CLASS (TREE_CODE (*expr_p)))
7652 case tcc_comparison:
7653 /* Handle comparison of objects of non scalar mode aggregates
7654 with a call to memcmp. It would be nice to only have to do
7655 this for variable-sized objects, but then we'd have to allow
7656 the same nest of reference nodes we allow for MODIFY_EXPR and
7659 Compare scalar mode aggregates as scalar mode values. Using
7660 memcmp for them would be very inefficient at best, and is
7661 plain wrong if bitfields are involved. */
7663 tree type = TREE_TYPE (TREE_OPERAND (*expr_p, 1));
7665 /* Vector comparisons need no boolification. */
7666 if (TREE_CODE (type) == VECTOR_TYPE)
7668 else if (!AGGREGATE_TYPE_P (type))
7670 tree org_type = TREE_TYPE (*expr_p);
7671 *expr_p = gimple_boolify (*expr_p);
7672 if (!useless_type_conversion_p (org_type,
7673 TREE_TYPE (*expr_p)))
7675 *expr_p = fold_convert_loc (input_location,
7682 else if (TYPE_MODE (type) != BLKmode)
7683 ret = gimplify_scalar_mode_aggregate_compare (expr_p);
7685 ret = gimplify_variable_sized_compare (expr_p);
7690 /* If *EXPR_P does not need to be special-cased, handle it
7691 according to its class. */
7693 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
7694 post_p, is_gimple_val, fb_rvalue);
7700 enum gimplify_status r0, r1;
7702 r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
7703 post_p, is_gimple_val, fb_rvalue);
7704 r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p,
7705 post_p, is_gimple_val, fb_rvalue);
7713 enum gimplify_status r0, r1, r2;
7715 r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
7716 post_p, is_gimple_val, fb_rvalue);
7717 r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p,
7718 post_p, is_gimple_val, fb_rvalue);
7719 r2 = gimplify_expr (&TREE_OPERAND (*expr_p, 2), pre_p,
7720 post_p, is_gimple_val, fb_rvalue);
7722 ret = MIN (MIN (r0, r1), r2);
7726 case tcc_declaration:
7729 goto dont_recalculate;
7735 recalculate_side_effects (*expr_p);
7741 gcc_assert (*expr_p || ret != GS_OK);
7743 while (ret == GS_OK);
7745 /* If we encountered an error_mark somewhere nested inside, either
7746 stub out the statement or propagate the error back out. */
7747 if (ret == GS_ERROR)
7754 /* This was only valid as a return value from the langhook, which
7755 we handled. Make sure it doesn't escape from any other context. */
7756 gcc_assert (ret != GS_UNHANDLED);
7758 if (fallback == fb_none && *expr_p && !is_gimple_stmt (*expr_p))
7760 /* We aren't looking for a value, and we don't have a valid
7761 statement. If it doesn't have side-effects, throw it away. */
7762 if (!TREE_SIDE_EFFECTS (*expr_p))
7764 else if (!TREE_THIS_VOLATILE (*expr_p))
7766 /* This is probably a _REF that contains something nested that
7767 has side effects. Recurse through the operands to find it. */
7768 enum tree_code code = TREE_CODE (*expr_p);
7775 case VIEW_CONVERT_EXPR:
7776 gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
7777 gimple_test_f, fallback);
7781 case ARRAY_RANGE_REF:
7782 gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
7783 gimple_test_f, fallback);
7784 gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p,
7785 gimple_test_f, fallback);
7789 /* Anything else with side-effects must be converted to
7790 a valid statement before we get here. */
7796 else if (COMPLETE_TYPE_P (TREE_TYPE (*expr_p))
7797 && TYPE_MODE (TREE_TYPE (*expr_p)) != BLKmode)
7799 /* Historically, the compiler has treated a bare reference
7800 to a non-BLKmode volatile lvalue as forcing a load. */
7801 tree type = TYPE_MAIN_VARIANT (TREE_TYPE (*expr_p));
7803 /* Normally, we do not want to create a temporary for a
7804 TREE_ADDRESSABLE type because such a type should not be
7805 copied by bitwise-assignment. However, we make an
7806 exception here, as all we are doing here is ensuring that
7807 we read the bytes that make up the type. We use
7808 create_tmp_var_raw because create_tmp_var will abort when
7809 given a TREE_ADDRESSABLE type. */
7810 tree tmp = create_tmp_var_raw (type, "vol");
7811 gimple_add_tmp_var (tmp);
7812 gimplify_assign (tmp, *expr_p, pre_p);
7816 /* We can't do anything useful with a volatile reference to
7817 an incomplete type, so just throw it away. Likewise for
7818 a BLKmode type, since any implicit inner load should
7819 already have been turned into an explicit one by the
7820 gimplification process. */
7824 /* If we are gimplifying at the statement level, we're done. Tack
7825 everything together and return. */
7826 if (fallback == fb_none || is_statement)
7828 /* Since *EXPR_P has been converted into a GIMPLE tuple, clear
7829 it out for GC to reclaim it. */
7830 *expr_p = NULL_TREE;
7832 if (!gimple_seq_empty_p (internal_pre)
7833 || !gimple_seq_empty_p (internal_post))
7835 gimplify_seq_add_seq (&internal_pre, internal_post);
7836 gimplify_seq_add_seq (pre_p, internal_pre);
7839 /* The result of gimplifying *EXPR_P is going to be the last few
7840 statements in *PRE_P and *POST_P. Add location information
7841 to all the statements that were added by the gimplification
7843 if (!gimple_seq_empty_p (*pre_p))
7844 annotate_all_with_location_after (*pre_p, pre_last_gsi, input_location);
7846 if (!gimple_seq_empty_p (*post_p))
7847 annotate_all_with_location_after (*post_p, post_last_gsi,
7853 #ifdef ENABLE_GIMPLE_CHECKING
7856 enum tree_code code = TREE_CODE (*expr_p);
7857 /* These expressions should already be in gimple IR form. */
7858 gcc_assert (code != MODIFY_EXPR
7860 && code != BIND_EXPR
7861 && code != CATCH_EXPR
7862 && (code != COND_EXPR || gimplify_ctxp->allow_rhs_cond_expr)
7863 && code != EH_FILTER_EXPR
7864 && code != GOTO_EXPR
7865 && code != LABEL_EXPR
7866 && code != LOOP_EXPR
7867 && code != SWITCH_EXPR
7868 && code != TRY_FINALLY_EXPR
7869 && code != OMP_CRITICAL
7871 && code != OMP_MASTER
7872 && code != OMP_ORDERED
7873 && code != OMP_PARALLEL
7874 && code != OMP_SECTIONS
7875 && code != OMP_SECTION
7876 && code != OMP_SINGLE);
7880 /* Otherwise we're gimplifying a subexpression, so the resulting
7881 value is interesting. If it's a valid operand that matches
7882 GIMPLE_TEST_F, we're done. Unless we are handling some
7883 post-effects internally; if that's the case, we need to copy into
7884 a temporary before adding the post-effects to POST_P. */
7885 if (gimple_seq_empty_p (internal_post) && (*gimple_test_f) (*expr_p))
7888 /* Otherwise, we need to create a new temporary for the gimplified
7891 /* We can't return an lvalue if we have an internal postqueue. The
7892 object the lvalue refers to would (probably) be modified by the
7893 postqueue; we need to copy the value out first, which means an
7895 if ((fallback & fb_lvalue)
7896 && gimple_seq_empty_p (internal_post)
7897 && is_gimple_addressable (*expr_p))
7899 /* An lvalue will do. Take the address of the expression, store it
7900 in a temporary, and replace the expression with an INDIRECT_REF of
7902 tmp = build_fold_addr_expr_loc (input_location, *expr_p);
7903 gimplify_expr (&tmp, pre_p, post_p, is_gimple_reg, fb_rvalue);
7904 *expr_p = build_simple_mem_ref (tmp);
7906 else if ((fallback & fb_rvalue) && is_gimple_reg_rhs_or_call (*expr_p))
7908 /* An rvalue will do. Assign the gimplified expression into a
7909 new temporary TMP and replace the original expression with
7910 TMP. First, make sure that the expression has a type so that
7911 it can be assigned into a temporary. */
7912 gcc_assert (!VOID_TYPE_P (TREE_TYPE (*expr_p)));
7914 if (!gimple_seq_empty_p (internal_post) || (fallback & fb_lvalue))
7915 /* The postqueue might change the value of the expression between
7916 the initialization and use of the temporary, so we can't use a
7917 formal temp. FIXME do we care? */
7919 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
7920 if (TREE_CODE (TREE_TYPE (*expr_p)) == COMPLEX_TYPE
7921 || TREE_CODE (TREE_TYPE (*expr_p)) == VECTOR_TYPE)
7922 DECL_GIMPLE_REG_P (*expr_p) = 1;
7925 *expr_p = get_formal_tmp_var (*expr_p, pre_p);
7929 #ifdef ENABLE_GIMPLE_CHECKING
7930 if (!(fallback & fb_mayfail))
7932 fprintf (stderr, "gimplification failed:\n");
7933 print_generic_expr (stderr, *expr_p, 0);
7934 debug_tree (*expr_p);
7935 internal_error ("gimplification failed");
7938 gcc_assert (fallback & fb_mayfail);
7940 /* If this is an asm statement, and the user asked for the
7941 impossible, don't die. Fail and let gimplify_asm_expr
7947 /* Make sure the temporary matches our predicate. */
7948 gcc_assert ((*gimple_test_f) (*expr_p));
7950 if (!gimple_seq_empty_p (internal_post))
7952 annotate_all_with_location (internal_post, input_location);
7953 gimplify_seq_add_seq (pre_p, internal_post);
7957 input_location = saved_location;
7961 /* Look through TYPE for variable-sized objects and gimplify each such
7962 size that we find. Add to LIST_P any statements generated. */
7965 gimplify_type_sizes (tree type, gimple_seq *list_p)
7969 if (type == NULL || type == error_mark_node)
7972 /* We first do the main variant, then copy into any other variants. */
7973 type = TYPE_MAIN_VARIANT (type);
7975 /* Avoid infinite recursion. */
7976 if (TYPE_SIZES_GIMPLIFIED (type))
7979 TYPE_SIZES_GIMPLIFIED (type) = 1;
7981 switch (TREE_CODE (type))
7987 case FIXED_POINT_TYPE:
7988 gimplify_one_sizepos (&TYPE_MIN_VALUE (type), list_p);
7989 gimplify_one_sizepos (&TYPE_MAX_VALUE (type), list_p);
7991 for (t = TYPE_NEXT_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
7993 TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (type);
7994 TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (type);
7999 /* These types may not have declarations, so handle them here. */
8000 gimplify_type_sizes (TREE_TYPE (type), list_p);
8001 gimplify_type_sizes (TYPE_DOMAIN (type), list_p);
8002 /* Ensure VLA bounds aren't removed, for -O0 they should be variables
8003 with assigned stack slots, for -O1+ -g they should be tracked
8005 if (!(TYPE_NAME (type)
8006 && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
8007 && DECL_IGNORED_P (TYPE_NAME (type)))
8008 && TYPE_DOMAIN (type)
8009 && INTEGRAL_TYPE_P (TYPE_DOMAIN (type)))
8011 t = TYPE_MIN_VALUE (TYPE_DOMAIN (type));
8012 if (t && TREE_CODE (t) == VAR_DECL && DECL_ARTIFICIAL (t))
8013 DECL_IGNORED_P (t) = 0;
8014 t = TYPE_MAX_VALUE (TYPE_DOMAIN (type));
8015 if (t && TREE_CODE (t) == VAR_DECL && DECL_ARTIFICIAL (t))
8016 DECL_IGNORED_P (t) = 0;
8022 case QUAL_UNION_TYPE:
8023 for (field = TYPE_FIELDS (type); field; field = DECL_CHAIN (field))
8024 if (TREE_CODE (field) == FIELD_DECL)
8026 gimplify_one_sizepos (&DECL_FIELD_OFFSET (field), list_p);
8027 gimplify_one_sizepos (&DECL_SIZE (field), list_p);
8028 gimplify_one_sizepos (&DECL_SIZE_UNIT (field), list_p);
8029 gimplify_type_sizes (TREE_TYPE (field), list_p);
8034 case REFERENCE_TYPE:
8035 /* We used to recurse on the pointed-to type here, which turned out to
8036 be incorrect because its definition might refer to variables not
8037 yet initialized at this point if a forward declaration is involved.
8039 It was actually useful for anonymous pointed-to types to ensure
8040 that the sizes evaluation dominates every possible later use of the
8041 values. Restricting to such types here would be safe since there
8042 is no possible forward declaration around, but would introduce an
8043 undesirable middle-end semantic to anonymity. We then defer to
8044 front-ends the responsibility of ensuring that the sizes are
8045 evaluated both early and late enough, e.g. by attaching artificial
8046 type declarations to the tree. */
8053 gimplify_one_sizepos (&TYPE_SIZE (type), list_p);
8054 gimplify_one_sizepos (&TYPE_SIZE_UNIT (type), list_p);
8056 for (t = TYPE_NEXT_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
8058 TYPE_SIZE (t) = TYPE_SIZE (type);
8059 TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (type);
8060 TYPE_SIZES_GIMPLIFIED (t) = 1;
8064 /* A subroutine of gimplify_type_sizes to make sure that *EXPR_P,
8065 a size or position, has had all of its SAVE_EXPRs evaluated.
8066 We add any required statements to *STMT_P. */
8069 gimplify_one_sizepos (tree *expr_p, gimple_seq *stmt_p)
8071 tree type, expr = *expr_p;
8073 /* We don't do anything if the value isn't there, is constant, or contains
8074 A PLACEHOLDER_EXPR. We also don't want to do anything if it's already
8075 a VAR_DECL. If it's a VAR_DECL from another function, the gimplifier
8076 will want to replace it with a new variable, but that will cause problems
8077 if this type is from outside the function. It's OK to have that here. */
8078 if (expr == NULL_TREE || TREE_CONSTANT (expr)
8079 || TREE_CODE (expr) == VAR_DECL
8080 || CONTAINS_PLACEHOLDER_P (expr))
8083 type = TREE_TYPE (expr);
8084 *expr_p = unshare_expr (expr);
8086 gimplify_expr (expr_p, stmt_p, NULL, is_gimple_val, fb_rvalue);
8089 /* Verify that we've an exact type match with the original expression.
8090 In particular, we do not wish to drop a "sizetype" in favour of a
8091 type of similar dimensions. We don't want to pollute the generic
8092 type-stripping code with this knowledge because it doesn't matter
8093 for the bulk of GENERIC/GIMPLE. It only matters that TYPE_SIZE_UNIT
8094 and friends retain their "sizetype-ness". */
8095 if (TREE_TYPE (expr) != type
8096 && TREE_CODE (type) == INTEGER_TYPE
8097 && TYPE_IS_SIZETYPE (type))
8102 *expr_p = create_tmp_var (type, NULL);
8103 tmp = build1 (NOP_EXPR, type, expr);
8104 stmt = gimplify_assign (*expr_p, tmp, stmt_p);
8105 gimple_set_location (stmt, EXPR_LOC_OR_HERE (expr));
8109 /* Gimplify the body of statements of FNDECL and return a GIMPLE_BIND node
8110 containing the sequence of corresponding GIMPLE statements. If DO_PARMS
8111 is true, also gimplify the parameters. */
8114 gimplify_body (tree fndecl, bool do_parms)
8116 location_t saved_location = input_location;
8117 gimple_seq parm_stmts, seq;
8119 struct gimplify_ctx gctx;
8120 struct cgraph_node *cgn;
8122 timevar_push (TV_TREE_GIMPLIFY);
8124 /* Initialize for optimize_insn_for_s{ize,peed}_p possibly called during
8126 default_rtl_profile ();
8128 gcc_assert (gimplify_ctxp == NULL);
8129 push_gimplify_context (&gctx);
8131 /* Unshare most shared trees in the body and in that of any nested functions.
8132 It would seem we don't have to do this for nested functions because
8133 they are supposed to be output and then the outer function gimplified
8134 first, but the g++ front end doesn't always do it that way. */
8135 unshare_body (fndecl);
8136 unvisit_body (fndecl);
8138 cgn = cgraph_get_node (fndecl);
8139 if (cgn && cgn->origin)
8140 nonlocal_vlas = pointer_set_create ();
8142 /* Make sure input_location isn't set to something weird. */
8143 input_location = DECL_SOURCE_LOCATION (fndecl);
8145 /* Resolve callee-copies. This has to be done before processing
8146 the body so that DECL_VALUE_EXPR gets processed correctly. */
8147 parm_stmts = do_parms ? gimplify_parameters () : NULL;
8149 /* Gimplify the function's body. */
8151 gimplify_stmt (&DECL_SAVED_TREE (fndecl), &seq);
8152 outer_bind = gimple_seq_first_stmt (seq);
8155 outer_bind = gimple_build_nop ();
8156 gimplify_seq_add_stmt (&seq, outer_bind);
8159 /* The body must contain exactly one statement, a GIMPLE_BIND. If this is
8160 not the case, wrap everything in a GIMPLE_BIND to make it so. */
8161 if (gimple_code (outer_bind) == GIMPLE_BIND
8162 && gimple_seq_first (seq) == gimple_seq_last (seq))
8165 outer_bind = gimple_build_bind (NULL_TREE, seq, NULL);
8167 DECL_SAVED_TREE (fndecl) = NULL_TREE;
8169 /* If we had callee-copies statements, insert them at the beginning
8170 of the function and clear DECL_VALUE_EXPR_P on the parameters. */
8171 if (!gimple_seq_empty_p (parm_stmts))
8175 gimplify_seq_add_seq (&parm_stmts, gimple_bind_body (outer_bind));
8176 gimple_bind_set_body (outer_bind, parm_stmts);
8178 for (parm = DECL_ARGUMENTS (current_function_decl);
8179 parm; parm = DECL_CHAIN (parm))
8180 if (DECL_HAS_VALUE_EXPR_P (parm))
8182 DECL_HAS_VALUE_EXPR_P (parm) = 0;
8183 DECL_IGNORED_P (parm) = 0;
8189 pointer_set_destroy (nonlocal_vlas);
8190 nonlocal_vlas = NULL;
8193 pop_gimplify_context (outer_bind);
8194 gcc_assert (gimplify_ctxp == NULL);
8197 verify_gimple_in_seq (gimple_bind_body (outer_bind));
8199 timevar_pop (TV_TREE_GIMPLIFY);
8200 input_location = saved_location;
8205 typedef char *char_p; /* For DEF_VEC_P. */
8207 DEF_VEC_ALLOC_P(char_p,heap);
8209 /* Return whether we should exclude FNDECL from instrumentation. */
8212 flag_instrument_functions_exclude_p (tree fndecl)
8214 VEC(char_p,heap) *vec;
8216 vec = (VEC(char_p,heap) *) flag_instrument_functions_exclude_functions;
8217 if (VEC_length (char_p, vec) > 0)
8223 name = lang_hooks.decl_printable_name (fndecl, 0);
8224 FOR_EACH_VEC_ELT (char_p, vec, i, s)
8225 if (strstr (name, s) != NULL)
8229 vec = (VEC(char_p,heap) *) flag_instrument_functions_exclude_files;
8230 if (VEC_length (char_p, vec) > 0)
8236 name = DECL_SOURCE_FILE (fndecl);
8237 FOR_EACH_VEC_ELT (char_p, vec, i, s)
8238 if (strstr (name, s) != NULL)
8245 /* Entry point to the gimplification pass. FNDECL is the FUNCTION_DECL
8246 node for the function we want to gimplify.
8248 Return the sequence of GIMPLE statements corresponding to the body
8252 gimplify_function_tree (tree fndecl)
8254 tree oldfn, parm, ret;
8258 gcc_assert (!gimple_body (fndecl));
8260 oldfn = current_function_decl;
8261 current_function_decl = fndecl;
8262 if (DECL_STRUCT_FUNCTION (fndecl))
8263 push_cfun (DECL_STRUCT_FUNCTION (fndecl));
8265 push_struct_function (fndecl);
8267 for (parm = DECL_ARGUMENTS (fndecl); parm ; parm = DECL_CHAIN (parm))
8269 /* Preliminarily mark non-addressed complex variables as eligible
8270 for promotion to gimple registers. We'll transform their uses
8272 if ((TREE_CODE (TREE_TYPE (parm)) == COMPLEX_TYPE
8273 || TREE_CODE (TREE_TYPE (parm)) == VECTOR_TYPE)
8274 && !TREE_THIS_VOLATILE (parm)
8275 && !needs_to_live_in_memory (parm))
8276 DECL_GIMPLE_REG_P (parm) = 1;
8279 ret = DECL_RESULT (fndecl);
8280 if ((TREE_CODE (TREE_TYPE (ret)) == COMPLEX_TYPE
8281 || TREE_CODE (TREE_TYPE (ret)) == VECTOR_TYPE)
8282 && !needs_to_live_in_memory (ret))
8283 DECL_GIMPLE_REG_P (ret) = 1;
8285 bind = gimplify_body (fndecl, true);
8287 /* The tree body of the function is no longer needed, replace it
8288 with the new GIMPLE body. */
8289 seq = gimple_seq_alloc ();
8290 gimple_seq_add_stmt (&seq, bind);
8291 gimple_set_body (fndecl, seq);
8293 /* If we're instrumenting function entry/exit, then prepend the call to
8294 the entry hook and wrap the whole function in a TRY_FINALLY_EXPR to
8295 catch the exit hook. */
8296 /* ??? Add some way to ignore exceptions for this TFE. */
8297 if (flag_instrument_function_entry_exit
8298 && !DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (fndecl)
8299 && !flag_instrument_functions_exclude_p (fndecl))
8304 gimple_seq cleanup = NULL, body = NULL;
8308 x = builtin_decl_implicit (BUILT_IN_RETURN_ADDRESS);
8309 call = gimple_build_call (x, 1, integer_zero_node);
8310 tmp_var = create_tmp_var (ptr_type_node, "return_addr");
8311 gimple_call_set_lhs (call, tmp_var);
8312 gimplify_seq_add_stmt (&cleanup, call);
8313 x = builtin_decl_implicit (BUILT_IN_PROFILE_FUNC_EXIT);
8314 call = gimple_build_call (x, 2,
8315 build_fold_addr_expr (current_function_decl),
8317 gimplify_seq_add_stmt (&cleanup, call);
8318 tf = gimple_build_try (seq, cleanup, GIMPLE_TRY_FINALLY);
8320 x = builtin_decl_implicit (BUILT_IN_RETURN_ADDRESS);
8321 call = gimple_build_call (x, 1, integer_zero_node);
8322 tmp_var = create_tmp_var (ptr_type_node, "return_addr");
8323 gimple_call_set_lhs (call, tmp_var);
8324 gimplify_seq_add_stmt (&body, call);
8325 x = builtin_decl_implicit (BUILT_IN_PROFILE_FUNC_ENTER);
8326 call = gimple_build_call (x, 2,
8327 build_fold_addr_expr (current_function_decl),
8329 gimplify_seq_add_stmt (&body, call);
8330 gimplify_seq_add_stmt (&body, tf);
8331 new_bind = gimple_build_bind (NULL, body, gimple_bind_block (bind));
8332 /* Clear the block for BIND, since it is no longer directly inside
8333 the function, but within a try block. */
8334 gimple_bind_set_block (bind, NULL);
8336 /* Replace the current function body with the body
8337 wrapped in the try/finally TF. */
8338 seq = gimple_seq_alloc ();
8339 gimple_seq_add_stmt (&seq, new_bind);
8340 gimple_set_body (fndecl, seq);
8343 DECL_SAVED_TREE (fndecl) = NULL_TREE;
8344 cfun->curr_properties = PROP_gimple_any;
8346 current_function_decl = oldfn;
8350 /* Some transformations like inlining may invalidate the GIMPLE form
8351 for operands. This function traverses all the operands in STMT and
8352 gimplifies anything that is not a valid gimple operand. Any new
8353 GIMPLE statements are inserted before *GSI_P. */
8356 gimple_regimplify_operands (gimple stmt, gimple_stmt_iterator *gsi_p)
8359 tree orig_lhs = NULL_TREE, lhs, t;
8360 gimple_seq pre = NULL;
8361 gimple post_stmt = NULL;
8362 struct gimplify_ctx gctx;
8364 push_gimplify_context (&gctx);
8365 gimplify_ctxp->into_ssa = gimple_in_ssa_p (cfun);
8367 switch (gimple_code (stmt))
8370 gimplify_expr (gimple_cond_lhs_ptr (stmt), &pre, NULL,
8371 is_gimple_val, fb_rvalue);
8372 gimplify_expr (gimple_cond_rhs_ptr (stmt), &pre, NULL,
8373 is_gimple_val, fb_rvalue);
8376 gimplify_expr (gimple_switch_index_ptr (stmt), &pre, NULL,
8377 is_gimple_val, fb_rvalue);
8379 case GIMPLE_OMP_ATOMIC_LOAD:
8380 gimplify_expr (gimple_omp_atomic_load_rhs_ptr (stmt), &pre, NULL,
8381 is_gimple_val, fb_rvalue);
8385 size_t i, noutputs = gimple_asm_noutputs (stmt);
8386 const char *constraint, **oconstraints;
8387 bool allows_mem, allows_reg, is_inout;
8390 = (const char **) alloca ((noutputs) * sizeof (const char *));
8391 for (i = 0; i < noutputs; i++)
8393 tree op = gimple_asm_output_op (stmt, i);
8394 constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op)));
8395 oconstraints[i] = constraint;
8396 parse_output_constraint (&constraint, i, 0, 0, &allows_mem,
8397 &allows_reg, &is_inout);
8398 gimplify_expr (&TREE_VALUE (op), &pre, NULL,
8399 is_inout ? is_gimple_min_lval : is_gimple_lvalue,
8400 fb_lvalue | fb_mayfail);
8402 for (i = 0; i < gimple_asm_ninputs (stmt); i++)
8404 tree op = gimple_asm_input_op (stmt, i);
8405 constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op)));
8406 parse_input_constraint (&constraint, 0, 0, noutputs, 0,
8407 oconstraints, &allows_mem, &allows_reg);
8408 if (TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (op))) && allows_mem)
8410 if (!allows_reg && allows_mem)
8411 gimplify_expr (&TREE_VALUE (op), &pre, NULL,
8412 is_gimple_lvalue, fb_lvalue | fb_mayfail);
8414 gimplify_expr (&TREE_VALUE (op), &pre, NULL,
8415 is_gimple_asm_val, fb_rvalue);
8420 /* NOTE: We start gimplifying operands from last to first to
8421 make sure that side-effects on the RHS of calls, assignments
8422 and ASMs are executed before the LHS. The ordering is not
8423 important for other statements. */
8424 num_ops = gimple_num_ops (stmt);
8425 orig_lhs = gimple_get_lhs (stmt);
8426 for (i = num_ops; i > 0; i--)
8428 tree op = gimple_op (stmt, i - 1);
8429 if (op == NULL_TREE)
8431 if (i == 1 && (is_gimple_call (stmt) || is_gimple_assign (stmt)))
8432 gimplify_expr (&op, &pre, NULL, is_gimple_lvalue, fb_lvalue);
8434 && is_gimple_assign (stmt)
8436 && get_gimple_rhs_class (gimple_expr_code (stmt))
8437 == GIMPLE_SINGLE_RHS)
8438 gimplify_expr (&op, &pre, NULL,
8439 rhs_predicate_for (gimple_assign_lhs (stmt)),
8441 else if (i == 2 && is_gimple_call (stmt))
8443 if (TREE_CODE (op) == FUNCTION_DECL)
8445 gimplify_expr (&op, &pre, NULL, is_gimple_call_addr, fb_rvalue);
8448 gimplify_expr (&op, &pre, NULL, is_gimple_val, fb_rvalue);
8449 gimple_set_op (stmt, i - 1, op);
8452 lhs = gimple_get_lhs (stmt);
8453 /* If the LHS changed it in a way that requires a simple RHS,
8454 create temporary. */
8455 if (lhs && !is_gimple_reg (lhs))
8457 bool need_temp = false;
8459 if (is_gimple_assign (stmt)
8461 && get_gimple_rhs_class (gimple_expr_code (stmt))
8462 == GIMPLE_SINGLE_RHS)
8463 gimplify_expr (gimple_assign_rhs1_ptr (stmt), &pre, NULL,
8464 rhs_predicate_for (gimple_assign_lhs (stmt)),
8466 else if (is_gimple_reg (lhs))
8468 if (is_gimple_reg_type (TREE_TYPE (lhs)))
8470 if (is_gimple_call (stmt))
8472 i = gimple_call_flags (stmt);
8473 if ((i & ECF_LOOPING_CONST_OR_PURE)
8474 || !(i & (ECF_CONST | ECF_PURE)))
8477 if (stmt_can_throw_internal (stmt))
8483 if (is_gimple_reg_type (TREE_TYPE (lhs)))
8485 else if (TYPE_MODE (TREE_TYPE (lhs)) != BLKmode)
8487 if (is_gimple_call (stmt))
8489 tree fndecl = gimple_call_fndecl (stmt);
8491 if (!aggregate_value_p (TREE_TYPE (lhs), fndecl)
8492 && !(fndecl && DECL_RESULT (fndecl)
8493 && DECL_BY_REFERENCE (DECL_RESULT (fndecl))))
8502 tree temp = create_tmp_reg (TREE_TYPE (lhs), NULL);
8504 if (TREE_CODE (orig_lhs) == SSA_NAME)
8505 orig_lhs = SSA_NAME_VAR (orig_lhs);
8507 if (gimple_in_ssa_p (cfun))
8508 temp = make_ssa_name (temp, NULL);
8509 gimple_set_lhs (stmt, temp);
8510 post_stmt = gimple_build_assign (lhs, temp);
8511 if (TREE_CODE (lhs) == SSA_NAME)
8512 SSA_NAME_DEF_STMT (lhs) = post_stmt;
8518 if (gimple_referenced_vars (cfun))
8519 for (t = gimplify_ctxp->temps; t ; t = TREE_CHAIN (t))
8520 add_referenced_var (t);
8522 if (!gimple_seq_empty_p (pre))
8524 if (gimple_in_ssa_p (cfun))
8526 gimple_stmt_iterator i;
8528 for (i = gsi_start (pre); !gsi_end_p (i); gsi_next (&i))
8529 mark_symbols_for_renaming (gsi_stmt (i));
8531 gsi_insert_seq_before (gsi_p, pre, GSI_SAME_STMT);
8534 gsi_insert_after (gsi_p, post_stmt, GSI_NEW_STMT);
8536 pop_gimplify_context (NULL);
8539 /* Expand EXPR to list of gimple statements STMTS. GIMPLE_TEST_F specifies
8540 the predicate that will hold for the result. If VAR is not NULL, make the
8541 base variable of the final destination be VAR if suitable. */
8544 force_gimple_operand_1 (tree expr, gimple_seq *stmts,
8545 gimple_predicate gimple_test_f, tree var)
8548 enum gimplify_status ret;
8549 struct gimplify_ctx gctx;
8553 /* gimple_test_f might be more strict than is_gimple_val, make
8554 sure we pass both. Just checking gimple_test_f doesn't work
8555 because most gimple predicates do not work recursively. */
8556 if (is_gimple_val (expr)
8557 && (*gimple_test_f) (expr))
8560 push_gimplify_context (&gctx);
8561 gimplify_ctxp->into_ssa = gimple_in_ssa_p (cfun);
8562 gimplify_ctxp->allow_rhs_cond_expr = true;
8565 expr = build2 (MODIFY_EXPR, TREE_TYPE (var), var, expr);
8567 if (TREE_CODE (expr) != MODIFY_EXPR
8568 && TREE_TYPE (expr) == void_type_node)
8570 gimplify_and_add (expr, stmts);
8575 ret = gimplify_expr (&expr, stmts, NULL, gimple_test_f, fb_rvalue);
8576 gcc_assert (ret != GS_ERROR);
8579 if (gimple_referenced_vars (cfun))
8580 for (t = gimplify_ctxp->temps; t ; t = DECL_CHAIN (t))
8581 add_referenced_var (t);
8583 pop_gimplify_context (NULL);
8588 /* Expand EXPR to list of gimple statements STMTS. If SIMPLE is true,
8589 force the result to be either ssa_name or an invariant, otherwise
8590 just force it to be a rhs expression. If VAR is not NULL, make the
8591 base variable of the final destination be VAR if suitable. */
8594 force_gimple_operand (tree expr, gimple_seq *stmts, bool simple, tree var)
8596 return force_gimple_operand_1 (expr, stmts,
8597 simple ? is_gimple_val : is_gimple_reg_rhs,
8601 /* Invoke force_gimple_operand_1 for EXPR with parameters GIMPLE_TEST_F
8602 and VAR. If some statements are produced, emits them at GSI.
8603 If BEFORE is true. the statements are appended before GSI, otherwise
8604 they are appended after it. M specifies the way GSI moves after
8605 insertion (GSI_SAME_STMT or GSI_CONTINUE_LINKING are the usual values). */
8608 force_gimple_operand_gsi_1 (gimple_stmt_iterator *gsi, tree expr,
8609 gimple_predicate gimple_test_f,
8610 tree var, bool before,
8611 enum gsi_iterator_update m)
8615 expr = force_gimple_operand_1 (expr, &stmts, gimple_test_f, var);
8617 if (!gimple_seq_empty_p (stmts))
8619 if (gimple_in_ssa_p (cfun))
8621 gimple_stmt_iterator i;
8623 for (i = gsi_start (stmts); !gsi_end_p (i); gsi_next (&i))
8624 mark_symbols_for_renaming (gsi_stmt (i));
8628 gsi_insert_seq_before (gsi, stmts, m);
8630 gsi_insert_seq_after (gsi, stmts, m);
8636 /* Invoke force_gimple_operand_1 for EXPR with parameter VAR.
8637 If SIMPLE is true, force the result to be either ssa_name or an invariant,
8638 otherwise just force it to be a rhs expression. If some statements are
8639 produced, emits them at GSI. If BEFORE is true, the statements are
8640 appended before GSI, otherwise they are appended after it. M specifies
8641 the way GSI moves after insertion (GSI_SAME_STMT or GSI_CONTINUE_LINKING
8642 are the usual values). */
8645 force_gimple_operand_gsi (gimple_stmt_iterator *gsi, tree expr,
8646 bool simple_p, tree var, bool before,
8647 enum gsi_iterator_update m)
8649 return force_gimple_operand_gsi_1 (gsi, expr,
8651 ? is_gimple_val : is_gimple_reg_rhs,
8656 #include "gt-gimplify.h"