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 Free Software Foundation, Inc.
4 Major work done by Sebastian Pop <s.pop@laposte.net>,
5 Diego Novillo <dnovillo@redhat.com> and Jason Merrill <jason@redhat.com>.
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify it under
10 the terms of the GNU General Public License as published by the Free
11 Software Foundation; either version 2, or (at your option) any later
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING. If not, write to the Free
21 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
26 #include "coretypes.h"
31 #include "tree-gimple.h"
32 #include "tree-inline.h"
33 #include "diagnostic.h"
34 #include "langhooks.h"
35 #include "langhooks-def.h"
36 #include "tree-flow.h"
50 #include "pointer-set.h"
53 enum gimplify_omp_var_data
59 GOVD_FIRSTPRIVATE = 16,
60 GOVD_LASTPRIVATE = 32,
63 GOVD_DEBUG_PRIVATE = 256,
64 GOVD_DATA_SHARE_CLASS = (GOVD_SHARED | GOVD_PRIVATE | GOVD_FIRSTPRIVATE
65 | GOVD_LASTPRIVATE | GOVD_REDUCTION | GOVD_LOCAL)
68 struct gimplify_omp_ctx
70 struct gimplify_omp_ctx *outer_context;
72 struct pointer_set_t *privatized_types;
74 enum omp_clause_default_kind default_kind;
76 bool is_combined_parallel;
81 struct gimplify_ctx *prev_context;
83 tree current_bind_expr;
85 tree conditional_cleanups;
89 VEC(tree,heap) *case_labels;
90 /* The formal temporary table. Should this be persistent? */
98 static struct gimplify_ctx *gimplify_ctxp;
99 static struct gimplify_omp_ctx *gimplify_omp_ctxp;
103 /* Formal (expression) temporary table handling: Multiple occurrences of
104 the same scalar expression are evaluated into the same temporary. */
106 typedef struct gimple_temp_hash_elt
109 tree temp; /* Value */
112 /* Forward declarations. */
113 static enum gimplify_status gimplify_compound_expr (tree *, tree *, bool);
114 #ifdef ENABLE_CHECKING
115 static bool cpt_same_type (tree a, tree b);
119 /* Return a hash value for a formal temporary table entry. */
122 gimple_tree_hash (const void *p)
124 tree t = ((const elt_t *) p)->val;
125 return iterative_hash_expr (t, 0);
128 /* Compare two formal temporary table entries. */
131 gimple_tree_eq (const void *p1, const void *p2)
133 tree t1 = ((const elt_t *) p1)->val;
134 tree t2 = ((const elt_t *) p2)->val;
135 enum tree_code code = TREE_CODE (t1);
137 if (TREE_CODE (t2) != code
138 || TREE_TYPE (t1) != TREE_TYPE (t2))
141 if (!operand_equal_p (t1, t2, 0))
144 /* Only allow them to compare equal if they also hash equal; otherwise
145 results are nondeterminate, and we fail bootstrap comparison. */
146 gcc_assert (gimple_tree_hash (p1) == gimple_tree_hash (p2));
151 /* Set up a context for the gimplifier. */
154 push_gimplify_context (void)
156 struct gimplify_ctx *c;
158 c = (struct gimplify_ctx *) xcalloc (1, sizeof (struct gimplify_ctx));
159 c->prev_context = gimplify_ctxp;
161 c->temp_htab = htab_create (1000, gimple_tree_hash, gimple_tree_eq, free);
166 /* Tear down a context for the gimplifier. If BODY is non-null, then
167 put the temporaries into the outer BIND_EXPR. Otherwise, put them
168 in the unexpanded_var_list. */
171 pop_gimplify_context (tree body)
173 struct gimplify_ctx *c = gimplify_ctxp;
176 gcc_assert (c && !c->current_bind_expr);
177 gimplify_ctxp = c->prev_context;
179 for (t = c->temps; t ; t = TREE_CHAIN (t))
180 DECL_GIMPLE_FORMAL_TEMP_P (t) = 0;
183 declare_vars (c->temps, body, false);
185 record_vars (c->temps);
188 htab_delete (c->temp_htab);
193 gimple_push_bind_expr (tree bind)
195 TREE_CHAIN (bind) = gimplify_ctxp->current_bind_expr;
196 gimplify_ctxp->current_bind_expr = bind;
200 gimple_pop_bind_expr (void)
202 gimplify_ctxp->current_bind_expr
203 = TREE_CHAIN (gimplify_ctxp->current_bind_expr);
207 gimple_current_bind_expr (void)
209 return gimplify_ctxp->current_bind_expr;
212 /* Returns true iff there is a COND_EXPR between us and the innermost
213 CLEANUP_POINT_EXPR. This info is used by gimple_push_cleanup. */
216 gimple_conditional_context (void)
218 return gimplify_ctxp->conditions > 0;
221 /* Note that we've entered a COND_EXPR. */
224 gimple_push_condition (void)
226 #ifdef ENABLE_CHECKING
227 if (gimplify_ctxp->conditions == 0)
228 gcc_assert (!gimplify_ctxp->conditional_cleanups);
230 ++(gimplify_ctxp->conditions);
233 /* Note that we've left a COND_EXPR. If we're back at unconditional scope
234 now, add any conditional cleanups we've seen to the prequeue. */
237 gimple_pop_condition (tree *pre_p)
239 int conds = --(gimplify_ctxp->conditions);
241 gcc_assert (conds >= 0);
244 append_to_statement_list (gimplify_ctxp->conditional_cleanups, pre_p);
245 gimplify_ctxp->conditional_cleanups = NULL_TREE;
249 /* A stable comparison routine for use with splay trees and DECLs. */
252 splay_tree_compare_decl_uid (splay_tree_key xa, splay_tree_key xb)
257 return DECL_UID (a) - DECL_UID (b);
260 /* Create a new omp construct that deals with variable remapping. */
262 static struct gimplify_omp_ctx *
263 new_omp_context (bool is_parallel, bool is_combined_parallel)
265 struct gimplify_omp_ctx *c;
267 c = XCNEW (struct gimplify_omp_ctx);
268 c->outer_context = gimplify_omp_ctxp;
269 c->variables = splay_tree_new (splay_tree_compare_decl_uid, 0, 0);
270 c->privatized_types = pointer_set_create ();
271 c->location = input_location;
272 c->is_parallel = is_parallel;
273 c->is_combined_parallel = is_combined_parallel;
274 c->default_kind = OMP_CLAUSE_DEFAULT_SHARED;
279 /* Destroy an omp construct that deals with variable remapping. */
282 delete_omp_context (struct gimplify_omp_ctx *c)
284 splay_tree_delete (c->variables);
285 pointer_set_destroy (c->privatized_types);
289 static void omp_add_variable (struct gimplify_omp_ctx *, tree, unsigned int);
290 static bool omp_notice_variable (struct gimplify_omp_ctx *, tree, bool);
292 /* A subroutine of append_to_statement_list{,_force}. T is not NULL. */
295 append_to_statement_list_1 (tree t, tree *list_p)
298 tree_stmt_iterator i;
302 if (t && TREE_CODE (t) == STATEMENT_LIST)
307 *list_p = list = alloc_stmt_list ();
311 tsi_link_after (&i, t, TSI_CONTINUE_LINKING);
314 /* Add T to the end of the list container pointed to by LIST_P.
315 If T is an expression with no effects, it is ignored. */
318 append_to_statement_list (tree t, tree *list_p)
320 if (t && TREE_SIDE_EFFECTS (t))
321 append_to_statement_list_1 (t, list_p);
324 /* Similar, but the statement is always added, regardless of side effects. */
327 append_to_statement_list_force (tree t, tree *list_p)
330 append_to_statement_list_1 (t, list_p);
333 /* Both gimplify the statement T and append it to LIST_P. */
336 gimplify_and_add (tree t, tree *list_p)
339 append_to_statement_list (t, list_p);
342 /* Strip off a legitimate source ending from the input string NAME of
343 length LEN. Rather than having to know the names used by all of
344 our front ends, we strip off an ending of a period followed by
345 up to five characters. (Java uses ".class".) */
348 remove_suffix (char *name, int len)
352 for (i = 2; i < 8 && len > i; i++)
354 if (name[len - i] == '.')
356 name[len - i] = '\0';
362 /* Create a nameless artificial label and put it in the current function
363 context. Returns the newly created label. */
366 create_artificial_label (void)
368 tree lab = build_decl (LABEL_DECL, NULL_TREE, void_type_node);
370 DECL_ARTIFICIAL (lab) = 1;
371 DECL_IGNORED_P (lab) = 1;
372 DECL_CONTEXT (lab) = current_function_decl;
376 /* Subroutine for find_single_pointer_decl. */
379 find_single_pointer_decl_1 (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
382 tree *pdecl = (tree *) data;
384 if (DECL_P (*tp) && POINTER_TYPE_P (TREE_TYPE (*tp)))
388 /* We already found a pointer decl; return anything other
389 than NULL_TREE to unwind from walk_tree signalling that
390 we have a duplicate. */
399 /* Find the single DECL of pointer type in the tree T and return it.
400 If there are zero or more than one such DECLs, return NULL. */
403 find_single_pointer_decl (tree t)
405 tree decl = NULL_TREE;
407 if (walk_tree (&t, find_single_pointer_decl_1, &decl, NULL))
409 /* find_single_pointer_decl_1 returns a nonzero value, causing
410 walk_tree to return a nonzero value, to indicate that it
411 found more than one pointer DECL. */
418 /* Create a new temporary name with PREFIX. Returns an identifier. */
420 static GTY(()) unsigned int tmp_var_id_num;
423 create_tmp_var_name (const char *prefix)
429 char *preftmp = ASTRDUP (prefix);
431 remove_suffix (preftmp, strlen (preftmp));
435 ASM_FORMAT_PRIVATE_NAME (tmp_name, prefix ? prefix : "T", tmp_var_id_num++);
436 return get_identifier (tmp_name);
440 /* Create a new temporary variable declaration of type TYPE.
441 Does NOT push it into the current binding. */
444 create_tmp_var_raw (tree type, const char *prefix)
449 /* Make the type of the variable writable. */
450 new_type = build_type_variant (type, 0, 0);
451 TYPE_ATTRIBUTES (new_type) = TYPE_ATTRIBUTES (type);
453 tmp_var = build_decl (VAR_DECL, prefix ? create_tmp_var_name (prefix) : NULL,
456 /* The variable was declared by the compiler. */
457 DECL_ARTIFICIAL (tmp_var) = 1;
458 /* And we don't want debug info for it. */
459 DECL_IGNORED_P (tmp_var) = 1;
461 /* Make the variable writable. */
462 TREE_READONLY (tmp_var) = 0;
464 DECL_EXTERNAL (tmp_var) = 0;
465 TREE_STATIC (tmp_var) = 0;
466 TREE_USED (tmp_var) = 1;
471 /* Create a new temporary variable declaration of type TYPE. DOES push the
472 variable into the current binding. Further, assume that this is called
473 only from gimplification or optimization, at which point the creation of
474 certain types are bugs. */
477 create_tmp_var (tree type, const char *prefix)
481 /* We don't allow types that are addressable (meaning we can't make copies),
482 incomplete, or of variable size. */
483 gcc_assert (!TREE_ADDRESSABLE (type)
484 && COMPLETE_TYPE_P (type)
485 && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST);
487 tmp_var = create_tmp_var_raw (type, prefix);
488 gimple_add_tmp_var (tmp_var);
492 /* Given a tree, try to return a useful variable name that we can use
493 to prefix a temporary that is being assigned the value of the tree.
494 I.E. given <temp> = &A, return A. */
502 STRIP_NOPS (stripped_decl);
503 if (DECL_P (stripped_decl) && DECL_NAME (stripped_decl))
504 return IDENTIFIER_POINTER (DECL_NAME (stripped_decl));
507 switch (TREE_CODE (stripped_decl))
510 return get_name (TREE_OPERAND (stripped_decl, 0));
518 /* Create a temporary with a name derived from VAL. Subroutine of
519 lookup_tmp_var; nobody else should call this function. */
522 create_tmp_from_val (tree val)
524 return create_tmp_var (TYPE_MAIN_VARIANT (TREE_TYPE (val)), get_name (val));
527 /* Create a temporary to hold the value of VAL. If IS_FORMAL, try to reuse
528 an existing expression temporary. */
531 lookup_tmp_var (tree val, bool is_formal)
535 /* If not optimizing, never really reuse a temporary. local-alloc
536 won't allocate any variable that is used in more than one basic
537 block, which means it will go into memory, causing much extra
538 work in reload and final and poorer code generation, outweighing
539 the extra memory allocation here. */
540 if (!optimize || !is_formal || TREE_SIDE_EFFECTS (val))
541 ret = create_tmp_from_val (val);
548 slot = htab_find_slot (gimplify_ctxp->temp_htab, (void *)&elt, INSERT);
551 elt_p = XNEW (elt_t);
553 elt_p->temp = ret = create_tmp_from_val (val);
554 *slot = (void *) elt_p;
558 elt_p = (elt_t *) *slot;
564 DECL_GIMPLE_FORMAL_TEMP_P (ret) = 1;
569 /* Returns a formal temporary variable initialized with VAL. PRE_P is as
570 in gimplify_expr. Only use this function if:
572 1) The value of the unfactored expression represented by VAL will not
573 change between the initialization and use of the temporary, and
574 2) The temporary will not be otherwise modified.
576 For instance, #1 means that this is inappropriate for SAVE_EXPR temps,
577 and #2 means it is inappropriate for && temps.
579 For other cases, use get_initialized_tmp_var instead. */
582 internal_get_tmp_var (tree val, tree *pre_p, tree *post_p, bool is_formal)
586 gimplify_expr (&val, pre_p, post_p, is_gimple_formal_tmp_rhs, fb_rvalue);
588 t = lookup_tmp_var (val, is_formal);
592 tree u = find_single_pointer_decl (val);
594 if (u && TREE_CODE (u) == VAR_DECL && DECL_BASED_ON_RESTRICT_P (u))
595 u = DECL_GET_RESTRICT_BASE (u);
596 if (u && TYPE_RESTRICT (TREE_TYPE (u)))
598 if (DECL_BASED_ON_RESTRICT_P (t))
599 gcc_assert (u == DECL_GET_RESTRICT_BASE (t));
602 DECL_BASED_ON_RESTRICT_P (t) = 1;
603 SET_DECL_RESTRICT_BASE (t, u);
608 if (TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE)
609 DECL_COMPLEX_GIMPLE_REG_P (t) = 1;
611 mod = build2 (INIT_EXPR, TREE_TYPE (t), t, val);
613 if (EXPR_HAS_LOCATION (val))
614 SET_EXPR_LOCUS (mod, EXPR_LOCUS (val));
616 SET_EXPR_LOCATION (mod, input_location);
618 /* gimplify_modify_expr might want to reduce this further. */
619 gimplify_and_add (mod, pre_p);
621 /* If we're gimplifying into ssa, gimplify_modify_expr will have
622 given our temporary an ssa name. Find and return it. */
623 if (gimplify_ctxp->into_ssa)
624 t = TREE_OPERAND (mod, 0);
629 /* Returns a formal temporary variable initialized with VAL. PRE_P
630 points to a statement list where side-effects needed to compute VAL
634 get_formal_tmp_var (tree val, tree *pre_p)
636 return internal_get_tmp_var (val, pre_p, NULL, true);
639 /* Returns a temporary variable initialized with VAL. PRE_P and POST_P
640 are as in gimplify_expr. */
643 get_initialized_tmp_var (tree val, tree *pre_p, tree *post_p)
645 return internal_get_tmp_var (val, pre_p, post_p, false);
648 /* Declares all the variables in VARS in SCOPE. If DEBUG_INFO is
649 true, generate debug info for them; otherwise don't. */
652 declare_vars (tree vars, tree scope, bool debug_info)
659 /* C99 mode puts the default 'return 0;' for main outside the outer
660 braces. So drill down until we find an actual scope. */
661 while (TREE_CODE (scope) == COMPOUND_EXPR)
662 scope = TREE_OPERAND (scope, 0);
664 gcc_assert (TREE_CODE (scope) == BIND_EXPR);
666 temps = nreverse (last);
668 block = BIND_EXPR_BLOCK (scope);
669 if (!block || !debug_info)
671 TREE_CHAIN (last) = BIND_EXPR_VARS (scope);
672 BIND_EXPR_VARS (scope) = temps;
676 /* We need to attach the nodes both to the BIND_EXPR and to its
677 associated BLOCK for debugging purposes. The key point here
678 is that the BLOCK_VARS of the BIND_EXPR_BLOCK of a BIND_EXPR
679 is a subchain of the BIND_EXPR_VARS of the BIND_EXPR. */
680 if (BLOCK_VARS (block))
681 BLOCK_VARS (block) = chainon (BLOCK_VARS (block), temps);
684 BIND_EXPR_VARS (scope) = chainon (BIND_EXPR_VARS (scope), temps);
685 BLOCK_VARS (block) = temps;
692 gimple_add_tmp_var (tree tmp)
694 gcc_assert (!TREE_CHAIN (tmp) && !DECL_SEEN_IN_BIND_EXPR_P (tmp));
696 DECL_CONTEXT (tmp) = current_function_decl;
697 DECL_SEEN_IN_BIND_EXPR_P (tmp) = 1;
701 TREE_CHAIN (tmp) = gimplify_ctxp->temps;
702 gimplify_ctxp->temps = tmp;
704 /* Mark temporaries local within the nearest enclosing parallel. */
705 if (gimplify_omp_ctxp)
707 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
708 while (ctx && !ctx->is_parallel)
709 ctx = ctx->outer_context;
711 omp_add_variable (ctx, tmp, GOVD_LOCAL | GOVD_SEEN);
717 declare_vars (tmp, DECL_SAVED_TREE (current_function_decl), false);
720 /* Determines whether to assign a locus to the statement STMT. */
723 should_carry_locus_p (tree stmt)
725 /* Don't emit a line note for a label. We particularly don't want to
726 emit one for the break label, since it doesn't actually correspond
727 to the beginning of the loop/switch. */
728 if (TREE_CODE (stmt) == LABEL_EXPR)
731 /* Do not annotate empty statements, since it confuses gcov. */
732 if (!TREE_SIDE_EFFECTS (stmt))
739 annotate_one_with_locus (tree t, location_t locus)
741 if (EXPR_P (t) && ! EXPR_HAS_LOCATION (t) && should_carry_locus_p (t))
742 SET_EXPR_LOCATION (t, locus);
746 annotate_all_with_locus (tree *stmt_p, location_t locus)
748 tree_stmt_iterator i;
753 for (i = tsi_start (*stmt_p); !tsi_end_p (i); tsi_next (&i))
755 tree t = tsi_stmt (i);
757 /* Assuming we've already been gimplified, we shouldn't
758 see nested chaining constructs anymore. */
759 gcc_assert (TREE_CODE (t) != STATEMENT_LIST
760 && TREE_CODE (t) != COMPOUND_EXPR);
762 annotate_one_with_locus (t, locus);
766 /* Similar to copy_tree_r() but do not copy SAVE_EXPR or TARGET_EXPR nodes.
767 These nodes model computations that should only be done once. If we
768 were to unshare something like SAVE_EXPR(i++), the gimplification
769 process would create wrong code. */
772 mostly_copy_tree_r (tree *tp, int *walk_subtrees, void *data)
774 enum tree_code code = TREE_CODE (*tp);
775 /* Don't unshare types, decls, constants and SAVE_EXPR nodes. */
776 if (TREE_CODE_CLASS (code) == tcc_type
777 || TREE_CODE_CLASS (code) == tcc_declaration
778 || TREE_CODE_CLASS (code) == tcc_constant
779 || code == SAVE_EXPR || code == TARGET_EXPR
780 /* We can't do anything sensible with a BLOCK used as an expression,
781 but we also can't just die when we see it because of non-expression
782 uses. So just avert our eyes and cross our fingers. Silly Java. */
787 gcc_assert (code != BIND_EXPR);
788 copy_tree_r (tp, walk_subtrees, data);
794 /* Callback for walk_tree to unshare most of the shared trees rooted at
795 *TP. If *TP has been visited already (i.e., TREE_VISITED (*TP) == 1),
796 then *TP is deep copied by calling copy_tree_r.
798 This unshares the same trees as copy_tree_r with the exception of
799 SAVE_EXPR nodes. These nodes model computations that should only be
800 done once. If we were to unshare something like SAVE_EXPR(i++), the
801 gimplification process would create wrong code. */
804 copy_if_shared_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
805 void *data ATTRIBUTE_UNUSED)
808 enum tree_code code = TREE_CODE (t);
810 /* Skip types, decls, and constants. But we do want to look at their
811 types and the bounds of types. Mark them as visited so we properly
812 unmark their subtrees on the unmark pass. If we've already seen them,
813 don't look down further. */
814 if (TREE_CODE_CLASS (code) == tcc_type
815 || TREE_CODE_CLASS (code) == tcc_declaration
816 || TREE_CODE_CLASS (code) == tcc_constant)
818 if (TREE_VISITED (t))
821 TREE_VISITED (t) = 1;
824 /* If this node has been visited already, unshare it and don't look
826 else if (TREE_VISITED (t))
828 walk_tree (tp, mostly_copy_tree_r, NULL, NULL);
832 /* Otherwise, mark the tree as visited and keep looking. */
834 TREE_VISITED (t) = 1;
840 unmark_visited_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
841 void *data ATTRIBUTE_UNUSED)
843 if (TREE_VISITED (*tp))
844 TREE_VISITED (*tp) = 0;
851 /* Unshare all the trees in BODY_P, a pointer into the body of FNDECL, and the
852 bodies of any nested functions if we are unsharing the entire body of
856 unshare_body (tree *body_p, tree fndecl)
858 struct cgraph_node *cgn = cgraph_node (fndecl);
860 walk_tree (body_p, copy_if_shared_r, NULL, NULL);
861 if (body_p == &DECL_SAVED_TREE (fndecl))
862 for (cgn = cgn->nested; cgn; cgn = cgn->next_nested)
863 unshare_body (&DECL_SAVED_TREE (cgn->decl), cgn->decl);
866 /* Likewise, but mark all trees as not visited. */
869 unvisit_body (tree *body_p, tree fndecl)
871 struct cgraph_node *cgn = cgraph_node (fndecl);
873 walk_tree (body_p, unmark_visited_r, NULL, NULL);
874 if (body_p == &DECL_SAVED_TREE (fndecl))
875 for (cgn = cgn->nested; cgn; cgn = cgn->next_nested)
876 unvisit_body (&DECL_SAVED_TREE (cgn->decl), cgn->decl);
879 /* Unshare T and all the trees reached from T via TREE_CHAIN. */
882 unshare_all_trees (tree t)
884 walk_tree (&t, copy_if_shared_r, NULL, NULL);
885 walk_tree (&t, unmark_visited_r, NULL, NULL);
888 /* Unconditionally make an unshared copy of EXPR. This is used when using
889 stored expressions which span multiple functions, such as BINFO_VTABLE,
890 as the normal unsharing process can't tell that they're shared. */
893 unshare_expr (tree expr)
895 walk_tree (&expr, mostly_copy_tree_r, NULL, NULL);
899 /* A terser interface for building a representation of an exception
903 gimple_build_eh_filter (tree body, tree allowed, tree failure)
907 /* FIXME should the allowed types go in TREE_TYPE? */
908 t = build2 (EH_FILTER_EXPR, void_type_node, allowed, NULL_TREE);
909 append_to_statement_list (failure, &EH_FILTER_FAILURE (t));
911 t = build2 (TRY_CATCH_EXPR, void_type_node, NULL_TREE, t);
912 append_to_statement_list (body, &TREE_OPERAND (t, 0));
918 /* WRAPPER is a code such as BIND_EXPR or CLEANUP_POINT_EXPR which can both
919 contain statements and have a value. Assign its value to a temporary
920 and give it void_type_node. Returns the temporary, or NULL_TREE if
921 WRAPPER was already void. */
924 voidify_wrapper_expr (tree wrapper, tree temp)
926 if (!VOID_TYPE_P (TREE_TYPE (wrapper)))
928 tree *p, sub = wrapper;
931 /* Set p to point to the body of the wrapper. */
932 switch (TREE_CODE (sub))
935 /* For a BIND_EXPR, the body is operand 1. */
936 p = &BIND_EXPR_BODY (sub);
940 p = &TREE_OPERAND (sub, 0);
944 /* Advance to the last statement. Set all container types to void. */
945 if (TREE_CODE (*p) == STATEMENT_LIST)
947 tree_stmt_iterator i = tsi_last (*p);
948 p = tsi_end_p (i) ? NULL : tsi_stmt_ptr (i);
952 for (; TREE_CODE (*p) == COMPOUND_EXPR; p = &TREE_OPERAND (*p, 1))
954 TREE_SIDE_EFFECTS (*p) = 1;
955 TREE_TYPE (*p) = void_type_node;
959 if (p == NULL || IS_EMPTY_STMT (*p))
961 /* Look through exception handling. */
962 else if (TREE_CODE (*p) == TRY_FINALLY_EXPR
963 || TREE_CODE (*p) == TRY_CATCH_EXPR)
968 /* The C++ frontend already did this for us. */
969 else if (TREE_CODE (*p) == INIT_EXPR
970 || TREE_CODE (*p) == TARGET_EXPR)
971 temp = TREE_OPERAND (*p, 0);
972 /* If we're returning a dereference, move the dereference
973 outside the wrapper. */
974 else if (TREE_CODE (*p) == INDIRECT_REF)
976 tree ptr = TREE_OPERAND (*p, 0);
977 temp = create_tmp_var (TREE_TYPE (ptr), "retval");
978 *p = build2 (MODIFY_EXPR, TREE_TYPE (ptr), temp, ptr);
979 temp = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (temp)), temp);
980 /* If this is a BIND_EXPR for a const inline function, it might not
981 have TREE_SIDE_EFFECTS set. That is no longer accurate. */
982 TREE_SIDE_EFFECTS (wrapper) = 1;
987 temp = create_tmp_var (TREE_TYPE (wrapper), "retval");
988 *p = build2 (MODIFY_EXPR, TREE_TYPE (temp), temp, *p);
989 TREE_SIDE_EFFECTS (wrapper) = 1;
992 TREE_TYPE (wrapper) = void_type_node;
999 /* Prepare calls to builtins to SAVE and RESTORE the stack as well as
1000 a temporary through which they communicate. */
1003 build_stack_save_restore (tree *save, tree *restore)
1005 tree save_call, tmp_var;
1008 build_function_call_expr (implicit_built_in_decls[BUILT_IN_STACK_SAVE],
1010 tmp_var = create_tmp_var (ptr_type_node, "saved_stack");
1012 *save = build2 (MODIFY_EXPR, ptr_type_node, tmp_var, save_call);
1014 build_function_call_expr (implicit_built_in_decls[BUILT_IN_STACK_RESTORE],
1015 tree_cons (NULL_TREE, tmp_var, NULL_TREE));
1018 /* Gimplify a BIND_EXPR. Just voidify and recurse. */
1020 static enum gimplify_status
1021 gimplify_bind_expr (tree *expr_p, tree temp, tree *pre_p)
1023 tree bind_expr = *expr_p;
1024 bool old_save_stack = gimplify_ctxp->save_stack;
1027 temp = voidify_wrapper_expr (bind_expr, temp);
1029 /* Mark variables seen in this bind expr. */
1030 for (t = BIND_EXPR_VARS (bind_expr); t ; t = TREE_CHAIN (t))
1032 if (TREE_CODE (t) == VAR_DECL)
1034 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
1036 /* Mark variable as local. */
1037 if (ctx && !is_global_var (t)
1038 && (! DECL_SEEN_IN_BIND_EXPR_P (t)
1039 || splay_tree_lookup (ctx->variables,
1040 (splay_tree_key) t) == NULL))
1041 omp_add_variable (gimplify_omp_ctxp, t, GOVD_LOCAL | GOVD_SEEN);
1043 DECL_SEEN_IN_BIND_EXPR_P (t) = 1;
1046 /* Preliminarily mark non-addressed complex variables as eligible
1047 for promotion to gimple registers. We'll transform their uses
1049 if (TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE
1050 && !TREE_THIS_VOLATILE (t)
1051 && (TREE_CODE (t) == VAR_DECL && !DECL_HARD_REGISTER (t))
1052 && !needs_to_live_in_memory (t))
1053 DECL_COMPLEX_GIMPLE_REG_P (t) = 1;
1056 gimple_push_bind_expr (bind_expr);
1057 gimplify_ctxp->save_stack = false;
1059 gimplify_to_stmt_list (&BIND_EXPR_BODY (bind_expr));
1061 if (gimplify_ctxp->save_stack)
1063 tree stack_save, stack_restore;
1065 /* Save stack on entry and restore it on exit. Add a try_finally
1066 block to achieve this. Note that mudflap depends on the
1067 format of the emitted code: see mx_register_decls(). */
1068 build_stack_save_restore (&stack_save, &stack_restore);
1070 t = build2 (TRY_FINALLY_EXPR, void_type_node,
1071 BIND_EXPR_BODY (bind_expr), NULL_TREE);
1072 append_to_statement_list (stack_restore, &TREE_OPERAND (t, 1));
1074 BIND_EXPR_BODY (bind_expr) = NULL_TREE;
1075 append_to_statement_list (stack_save, &BIND_EXPR_BODY (bind_expr));
1076 append_to_statement_list (t, &BIND_EXPR_BODY (bind_expr));
1079 gimplify_ctxp->save_stack = old_save_stack;
1080 gimple_pop_bind_expr ();
1085 append_to_statement_list (bind_expr, pre_p);
1092 /* Gimplify a RETURN_EXPR. If the expression to be returned is not a
1093 GIMPLE value, it is assigned to a new temporary and the statement is
1094 re-written to return the temporary.
1096 PRE_P points to the list where side effects that must happen before
1097 STMT should be stored. */
1099 static enum gimplify_status
1100 gimplify_return_expr (tree stmt, tree *pre_p)
1102 tree ret_expr = TREE_OPERAND (stmt, 0);
1103 tree result_decl, result;
1105 if (!ret_expr || TREE_CODE (ret_expr) == RESULT_DECL
1106 || ret_expr == error_mark_node)
1109 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl))))
1110 result_decl = NULL_TREE;
1113 result_decl = TREE_OPERAND (ret_expr, 0);
1114 if (TREE_CODE (result_decl) == INDIRECT_REF)
1115 /* See through a return by reference. */
1116 result_decl = TREE_OPERAND (result_decl, 0);
1118 gcc_assert ((TREE_CODE (ret_expr) == MODIFY_EXPR
1119 || TREE_CODE (ret_expr) == INIT_EXPR)
1120 && TREE_CODE (result_decl) == RESULT_DECL);
1123 /* If aggregate_value_p is true, then we can return the bare RESULT_DECL.
1124 Recall that aggregate_value_p is FALSE for any aggregate type that is
1125 returned in registers. If we're returning values in registers, then
1126 we don't want to extend the lifetime of the RESULT_DECL, particularly
1127 across another call. In addition, for those aggregates for which
1128 hard_function_value generates a PARALLEL, we'll die during normal
1129 expansion of structure assignments; there's special code in expand_return
1130 to handle this case that does not exist in expand_expr. */
1132 || aggregate_value_p (result_decl, TREE_TYPE (current_function_decl)))
1133 result = result_decl;
1134 else if (gimplify_ctxp->return_temp)
1135 result = gimplify_ctxp->return_temp;
1138 result = create_tmp_var (TREE_TYPE (result_decl), NULL);
1140 /* ??? With complex control flow (usually involving abnormal edges),
1141 we can wind up warning about an uninitialized value for this. Due
1142 to how this variable is constructed and initialized, this is never
1143 true. Give up and never warn. */
1144 TREE_NO_WARNING (result) = 1;
1146 gimplify_ctxp->return_temp = result;
1149 /* Smash the lhs of the MODIFY_EXPR to the temporary we plan to use.
1150 Then gimplify the whole thing. */
1151 if (result != result_decl)
1152 TREE_OPERAND (ret_expr, 0) = result;
1154 gimplify_and_add (TREE_OPERAND (stmt, 0), pre_p);
1156 /* If we didn't use a temporary, then the result is just the result_decl.
1157 Otherwise we need a simple copy. This should already be gimple. */
1158 if (result == result_decl)
1161 ret_expr = build2 (MODIFY_EXPR, TREE_TYPE (result), result_decl, result);
1162 TREE_OPERAND (stmt, 0) = ret_expr;
1167 /* Gimplifies a DECL_EXPR node *STMT_P by making any necessary allocation
1168 and initialization explicit. */
1170 static enum gimplify_status
1171 gimplify_decl_expr (tree *stmt_p)
1173 tree stmt = *stmt_p;
1174 tree decl = DECL_EXPR_DECL (stmt);
1176 *stmt_p = NULL_TREE;
1178 if (TREE_TYPE (decl) == error_mark_node)
1181 if ((TREE_CODE (decl) == TYPE_DECL
1182 || TREE_CODE (decl) == VAR_DECL)
1183 && !TYPE_SIZES_GIMPLIFIED (TREE_TYPE (decl)))
1184 gimplify_type_sizes (TREE_TYPE (decl), stmt_p);
1186 if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl))
1188 tree init = DECL_INITIAL (decl);
1190 if (!TREE_CONSTANT (DECL_SIZE (decl)))
1192 /* This is a variable-sized decl. Simplify its size and mark it
1193 for deferred expansion. Note that mudflap depends on the format
1194 of the emitted code: see mx_register_decls(). */
1195 tree t, args, addr, ptr_type;
1197 gimplify_one_sizepos (&DECL_SIZE (decl), stmt_p);
1198 gimplify_one_sizepos (&DECL_SIZE_UNIT (decl), stmt_p);
1200 /* All occurrences of this decl in final gimplified code will be
1201 replaced by indirection. Setting DECL_VALUE_EXPR does two
1202 things: First, it lets the rest of the gimplifier know what
1203 replacement to use. Second, it lets the debug info know
1204 where to find the value. */
1205 ptr_type = build_pointer_type (TREE_TYPE (decl));
1206 addr = create_tmp_var (ptr_type, get_name (decl));
1207 DECL_IGNORED_P (addr) = 0;
1208 t = build_fold_indirect_ref (addr);
1209 SET_DECL_VALUE_EXPR (decl, t);
1210 DECL_HAS_VALUE_EXPR_P (decl) = 1;
1212 args = tree_cons (NULL, DECL_SIZE_UNIT (decl), NULL);
1213 t = built_in_decls[BUILT_IN_ALLOCA];
1214 t = build_function_call_expr (t, args);
1215 t = fold_convert (ptr_type, t);
1216 t = build2 (MODIFY_EXPR, void_type_node, addr, t);
1218 gimplify_and_add (t, stmt_p);
1220 /* Indicate that we need to restore the stack level when the
1221 enclosing BIND_EXPR is exited. */
1222 gimplify_ctxp->save_stack = true;
1225 if (init && init != error_mark_node)
1227 if (!TREE_STATIC (decl))
1229 DECL_INITIAL (decl) = NULL_TREE;
1230 init = build2 (INIT_EXPR, void_type_node, decl, init);
1231 gimplify_and_add (init, stmt_p);
1234 /* We must still examine initializers for static variables
1235 as they may contain a label address. */
1236 walk_tree (&init, force_labels_r, NULL, NULL);
1239 /* Some front ends do not explicitly declare all anonymous
1240 artificial variables. We compensate here by declaring the
1241 variables, though it would be better if the front ends would
1242 explicitly declare them. */
1243 if (!DECL_SEEN_IN_BIND_EXPR_P (decl)
1244 && DECL_ARTIFICIAL (decl) && DECL_NAME (decl) == NULL_TREE)
1245 gimple_add_tmp_var (decl);
1251 /* Gimplify a LOOP_EXPR. Normally this just involves gimplifying the body
1252 and replacing the LOOP_EXPR with goto, but if the loop contains an
1253 EXIT_EXPR, we need to append a label for it to jump to. */
1255 static enum gimplify_status
1256 gimplify_loop_expr (tree *expr_p, tree *pre_p)
1258 tree saved_label = gimplify_ctxp->exit_label;
1259 tree start_label = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
1260 tree jump_stmt = build_and_jump (&LABEL_EXPR_LABEL (start_label));
1262 append_to_statement_list (start_label, pre_p);
1264 gimplify_ctxp->exit_label = NULL_TREE;
1266 gimplify_and_add (LOOP_EXPR_BODY (*expr_p), pre_p);
1268 if (gimplify_ctxp->exit_label)
1270 append_to_statement_list (jump_stmt, pre_p);
1271 *expr_p = build1 (LABEL_EXPR, void_type_node, gimplify_ctxp->exit_label);
1274 *expr_p = jump_stmt;
1276 gimplify_ctxp->exit_label = saved_label;
1281 /* Compare two case labels. Because the front end should already have
1282 made sure that case ranges do not overlap, it is enough to only compare
1283 the CASE_LOW values of each case label. */
1286 compare_case_labels (const void *p1, const void *p2)
1288 tree case1 = *(tree *)p1;
1289 tree case2 = *(tree *)p2;
1291 return tree_int_cst_compare (CASE_LOW (case1), CASE_LOW (case2));
1294 /* Sort the case labels in LABEL_VEC in place in ascending order. */
1297 sort_case_labels (tree label_vec)
1299 size_t len = TREE_VEC_LENGTH (label_vec);
1300 tree default_case = TREE_VEC_ELT (label_vec, len - 1);
1302 if (CASE_LOW (default_case))
1306 /* The last label in the vector should be the default case
1308 for (i = 0; i < len; ++i)
1310 tree t = TREE_VEC_ELT (label_vec, i);
1314 TREE_VEC_ELT (label_vec, i) = TREE_VEC_ELT (label_vec, len - 1);
1315 TREE_VEC_ELT (label_vec, len - 1) = default_case;
1321 qsort (&TREE_VEC_ELT (label_vec, 0), len - 1, sizeof (tree),
1322 compare_case_labels);
1325 /* Gimplify a SWITCH_EXPR, and collect a TREE_VEC of the labels it can
1328 static enum gimplify_status
1329 gimplify_switch_expr (tree *expr_p, tree *pre_p)
1331 tree switch_expr = *expr_p;
1332 enum gimplify_status ret;
1334 ret = gimplify_expr (&SWITCH_COND (switch_expr), pre_p, NULL,
1335 is_gimple_val, fb_rvalue);
1337 if (SWITCH_BODY (switch_expr))
1339 VEC(tree,heap) *labels, *saved_labels;
1340 tree label_vec, default_case = NULL_TREE;
1343 /* If someone can be bothered to fill in the labels, they can
1344 be bothered to null out the body too. */
1345 gcc_assert (!SWITCH_LABELS (switch_expr));
1347 saved_labels = gimplify_ctxp->case_labels;
1348 gimplify_ctxp->case_labels = VEC_alloc (tree, heap, 8);
1350 gimplify_to_stmt_list (&SWITCH_BODY (switch_expr));
1352 labels = gimplify_ctxp->case_labels;
1353 gimplify_ctxp->case_labels = saved_labels;
1356 while (i < VEC_length (tree, labels))
1358 tree elt = VEC_index (tree, labels, i);
1359 tree low = CASE_LOW (elt);
1360 bool remove_element = FALSE;
1364 /* Discard empty ranges. */
1365 tree high = CASE_HIGH (elt);
1366 if (high && INT_CST_LT (high, low))
1367 remove_element = TRUE;
1371 /* The default case must be the last label in the list. */
1372 gcc_assert (!default_case);
1374 remove_element = TRUE;
1378 VEC_ordered_remove (tree, labels, i);
1384 label_vec = make_tree_vec (len + 1);
1385 SWITCH_LABELS (*expr_p) = label_vec;
1386 append_to_statement_list (switch_expr, pre_p);
1390 /* If the switch has no default label, add one, so that we jump
1391 around the switch body. */
1392 default_case = build3 (CASE_LABEL_EXPR, void_type_node, NULL_TREE,
1393 NULL_TREE, create_artificial_label ());
1394 append_to_statement_list (SWITCH_BODY (switch_expr), pre_p);
1395 *expr_p = build1 (LABEL_EXPR, void_type_node,
1396 CASE_LABEL (default_case));
1399 *expr_p = SWITCH_BODY (switch_expr);
1401 for (i = 0; i < len; ++i)
1402 TREE_VEC_ELT (label_vec, i) = VEC_index (tree, labels, i);
1403 TREE_VEC_ELT (label_vec, len) = default_case;
1405 VEC_free (tree, heap, labels);
1407 sort_case_labels (label_vec);
1409 SWITCH_BODY (switch_expr) = NULL;
1412 gcc_assert (SWITCH_LABELS (switch_expr));
1417 static enum gimplify_status
1418 gimplify_case_label_expr (tree *expr_p)
1420 tree expr = *expr_p;
1421 struct gimplify_ctx *ctxp;
1423 /* Invalid OpenMP programs can play Duff's Device type games with
1424 #pragma omp parallel. At least in the C front end, we don't
1425 detect such invalid branches until after gimplification. */
1426 for (ctxp = gimplify_ctxp; ; ctxp = ctxp->prev_context)
1427 if (ctxp->case_labels)
1430 VEC_safe_push (tree, heap, ctxp->case_labels, expr);
1431 *expr_p = build1 (LABEL_EXPR, void_type_node, CASE_LABEL (expr));
1435 /* Build a GOTO to the LABEL_DECL pointed to by LABEL_P, building it first
1439 build_and_jump (tree *label_p)
1441 if (label_p == NULL)
1442 /* If there's nowhere to jump, just fall through. */
1445 if (*label_p == NULL_TREE)
1447 tree label = create_artificial_label ();
1451 return build1 (GOTO_EXPR, void_type_node, *label_p);
1454 /* Gimplify an EXIT_EXPR by converting to a GOTO_EXPR inside a COND_EXPR.
1455 This also involves building a label to jump to and communicating it to
1456 gimplify_loop_expr through gimplify_ctxp->exit_label. */
1458 static enum gimplify_status
1459 gimplify_exit_expr (tree *expr_p)
1461 tree cond = TREE_OPERAND (*expr_p, 0);
1464 expr = build_and_jump (&gimplify_ctxp->exit_label);
1465 expr = build3 (COND_EXPR, void_type_node, cond, expr, NULL_TREE);
1471 /* A helper function to be called via walk_tree. Mark all labels under *TP
1472 as being forced. To be called for DECL_INITIAL of static variables. */
1475 force_labels_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
1479 if (TREE_CODE (*tp) == LABEL_DECL)
1480 FORCED_LABEL (*tp) = 1;
1485 /* *EXPR_P is a COMPONENT_REF being used as an rvalue. If its type is
1486 different from its canonical type, wrap the whole thing inside a
1487 NOP_EXPR and force the type of the COMPONENT_REF to be the canonical
1490 The canonical type of a COMPONENT_REF is the type of the field being
1491 referenced--unless the field is a bit-field which can be read directly
1492 in a smaller mode, in which case the canonical type is the
1493 sign-appropriate type corresponding to that mode. */
1496 canonicalize_component_ref (tree *expr_p)
1498 tree expr = *expr_p;
1501 gcc_assert (TREE_CODE (expr) == COMPONENT_REF);
1503 if (INTEGRAL_TYPE_P (TREE_TYPE (expr)))
1504 type = TREE_TYPE (get_unwidened (expr, NULL_TREE));
1506 type = TREE_TYPE (TREE_OPERAND (expr, 1));
1508 if (TREE_TYPE (expr) != type)
1510 tree old_type = TREE_TYPE (expr);
1512 /* Set the type of the COMPONENT_REF to the underlying type. */
1513 TREE_TYPE (expr) = type;
1515 /* And wrap the whole thing inside a NOP_EXPR. */
1516 expr = build1 (NOP_EXPR, old_type, expr);
1522 /* If a NOP conversion is changing a pointer to array of foo to a pointer
1523 to foo, embed that change in the ADDR_EXPR by converting
1528 where L is the lower bound. For simplicity, only do this for constant
1532 canonicalize_addr_expr (tree *expr_p)
1534 tree expr = *expr_p;
1535 tree ctype = TREE_TYPE (expr);
1536 tree addr_expr = TREE_OPERAND (expr, 0);
1537 tree atype = TREE_TYPE (addr_expr);
1538 tree dctype, datype, ddatype, otype, obj_expr;
1540 /* Both cast and addr_expr types should be pointers. */
1541 if (!POINTER_TYPE_P (ctype) || !POINTER_TYPE_P (atype))
1544 /* The addr_expr type should be a pointer to an array. */
1545 datype = TREE_TYPE (atype);
1546 if (TREE_CODE (datype) != ARRAY_TYPE)
1549 /* Both cast and addr_expr types should address the same object type. */
1550 dctype = TREE_TYPE (ctype);
1551 ddatype = TREE_TYPE (datype);
1552 if (!lang_hooks.types_compatible_p (ddatype, dctype))
1555 /* The addr_expr and the object type should match. */
1556 obj_expr = TREE_OPERAND (addr_expr, 0);
1557 otype = TREE_TYPE (obj_expr);
1558 if (!lang_hooks.types_compatible_p (otype, datype))
1561 /* The lower bound and element sizes must be constant. */
1562 if (!TYPE_SIZE_UNIT (dctype)
1563 || TREE_CODE (TYPE_SIZE_UNIT (dctype)) != INTEGER_CST
1564 || !TYPE_DOMAIN (datype) || !TYPE_MIN_VALUE (TYPE_DOMAIN (datype))
1565 || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (datype))) != INTEGER_CST)
1568 /* All checks succeeded. Build a new node to merge the cast. */
1569 *expr_p = build4 (ARRAY_REF, dctype, obj_expr,
1570 TYPE_MIN_VALUE (TYPE_DOMAIN (datype)),
1571 TYPE_MIN_VALUE (TYPE_DOMAIN (datype)),
1572 size_binop (EXACT_DIV_EXPR, TYPE_SIZE_UNIT (dctype),
1573 size_int (TYPE_ALIGN_UNIT (dctype))));
1574 *expr_p = build1 (ADDR_EXPR, ctype, *expr_p);
1577 /* *EXPR_P is a NOP_EXPR or CONVERT_EXPR. Remove it and/or other conversions
1578 underneath as appropriate. */
1580 static enum gimplify_status
1581 gimplify_conversion (tree *expr_p)
1583 gcc_assert (TREE_CODE (*expr_p) == NOP_EXPR
1584 || TREE_CODE (*expr_p) == CONVERT_EXPR);
1586 /* Then strip away all but the outermost conversion. */
1587 STRIP_SIGN_NOPS (TREE_OPERAND (*expr_p, 0));
1589 /* And remove the outermost conversion if it's useless. */
1590 if (tree_ssa_useless_type_conversion (*expr_p))
1591 *expr_p = TREE_OPERAND (*expr_p, 0);
1593 /* If we still have a conversion at the toplevel,
1594 then canonicalize some constructs. */
1595 if (TREE_CODE (*expr_p) == NOP_EXPR || TREE_CODE (*expr_p) == CONVERT_EXPR)
1597 tree sub = TREE_OPERAND (*expr_p, 0);
1599 /* If a NOP conversion is changing the type of a COMPONENT_REF
1600 expression, then canonicalize its type now in order to expose more
1601 redundant conversions. */
1602 if (TREE_CODE (sub) == COMPONENT_REF)
1603 canonicalize_component_ref (&TREE_OPERAND (*expr_p, 0));
1605 /* If a NOP conversion is changing a pointer to array of foo
1606 to a pointer to foo, embed that change in the ADDR_EXPR. */
1607 else if (TREE_CODE (sub) == ADDR_EXPR)
1608 canonicalize_addr_expr (expr_p);
1614 /* Gimplify a VAR_DECL or PARM_DECL. Returns GS_OK if we expanded a
1615 DECL_VALUE_EXPR, and it's worth re-examining things. */
1617 static enum gimplify_status
1618 gimplify_var_or_parm_decl (tree *expr_p)
1620 tree decl = *expr_p;
1622 /* ??? If this is a local variable, and it has not been seen in any
1623 outer BIND_EXPR, then it's probably the result of a duplicate
1624 declaration, for which we've already issued an error. It would
1625 be really nice if the front end wouldn't leak these at all.
1626 Currently the only known culprit is C++ destructors, as seen
1627 in g++.old-deja/g++.jason/binding.C. */
1628 if (TREE_CODE (decl) == VAR_DECL
1629 && !DECL_SEEN_IN_BIND_EXPR_P (decl)
1630 && !TREE_STATIC (decl) && !DECL_EXTERNAL (decl)
1631 && decl_function_context (decl) == current_function_decl)
1633 gcc_assert (errorcount || sorrycount);
1637 /* When within an OpenMP context, notice uses of variables. */
1638 if (gimplify_omp_ctxp && omp_notice_variable (gimplify_omp_ctxp, decl, true))
1641 /* If the decl is an alias for another expression, substitute it now. */
1642 if (DECL_HAS_VALUE_EXPR_P (decl))
1644 *expr_p = unshare_expr (DECL_VALUE_EXPR (decl));
1652 /* Gimplify the COMPONENT_REF, ARRAY_REF, REALPART_EXPR or IMAGPART_EXPR
1653 node pointed to by EXPR_P.
1656 : min_lval '[' val ']'
1658 | compound_lval '[' val ']'
1659 | compound_lval '.' ID
1661 This is not part of the original SIMPLE definition, which separates
1662 array and member references, but it seems reasonable to handle them
1663 together. Also, this way we don't run into problems with union
1664 aliasing; gcc requires that for accesses through a union to alias, the
1665 union reference must be explicit, which was not always the case when we
1666 were splitting up array and member refs.
1668 PRE_P points to the list where side effects that must happen before
1669 *EXPR_P should be stored.
1671 POST_P points to the list where side effects that must happen after
1672 *EXPR_P should be stored. */
1674 static enum gimplify_status
1675 gimplify_compound_lval (tree *expr_p, tree *pre_p,
1676 tree *post_p, fallback_t fallback)
1679 VEC(tree,heap) *stack;
1680 enum gimplify_status ret = GS_OK, tret;
1683 /* Create a stack of the subexpressions so later we can walk them in
1684 order from inner to outer. */
1685 stack = VEC_alloc (tree, heap, 10);
1687 /* We can handle anything that get_inner_reference can deal with. */
1688 for (p = expr_p; ; p = &TREE_OPERAND (*p, 0))
1691 /* Fold INDIRECT_REFs now to turn them into ARRAY_REFs. */
1692 if (TREE_CODE (*p) == INDIRECT_REF)
1693 *p = fold_indirect_ref (*p);
1695 if (handled_component_p (*p))
1697 /* Expand DECL_VALUE_EXPR now. In some cases that may expose
1698 additional COMPONENT_REFs. */
1699 else if ((TREE_CODE (*p) == VAR_DECL || TREE_CODE (*p) == PARM_DECL)
1700 && gimplify_var_or_parm_decl (p) == GS_OK)
1705 VEC_safe_push (tree, heap, stack, *p);
1708 gcc_assert (VEC_length (tree, stack));
1710 /* Now STACK is a stack of pointers to all the refs we've walked through
1711 and P points to the innermost expression.
1713 Java requires that we elaborated nodes in source order. That
1714 means we must gimplify the inner expression followed by each of
1715 the indices, in order. But we can't gimplify the inner
1716 expression until we deal with any variable bounds, sizes, or
1717 positions in order to deal with PLACEHOLDER_EXPRs.
1719 So we do this in three steps. First we deal with the annotations
1720 for any variables in the components, then we gimplify the base,
1721 then we gimplify any indices, from left to right. */
1722 for (i = VEC_length (tree, stack) - 1; i >= 0; i--)
1724 tree t = VEC_index (tree, stack, i);
1726 if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
1728 /* Gimplify the low bound and element type size and put them into
1729 the ARRAY_REF. If these values are set, they have already been
1731 if (!TREE_OPERAND (t, 2))
1733 tree low = unshare_expr (array_ref_low_bound (t));
1734 if (!is_gimple_min_invariant (low))
1736 TREE_OPERAND (t, 2) = low;
1737 tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p,
1738 is_gimple_formal_tmp_reg, fb_rvalue);
1739 ret = MIN (ret, tret);
1743 if (!TREE_OPERAND (t, 3))
1745 tree elmt_type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (t, 0)));
1746 tree elmt_size = unshare_expr (array_ref_element_size (t));
1747 tree factor = size_int (TYPE_ALIGN_UNIT (elmt_type));
1749 /* Divide the element size by the alignment of the element
1751 elmt_size = size_binop (EXACT_DIV_EXPR, elmt_size, factor);
1753 if (!is_gimple_min_invariant (elmt_size))
1755 TREE_OPERAND (t, 3) = elmt_size;
1756 tret = gimplify_expr (&TREE_OPERAND (t, 3), pre_p, post_p,
1757 is_gimple_formal_tmp_reg, fb_rvalue);
1758 ret = MIN (ret, tret);
1762 else if (TREE_CODE (t) == COMPONENT_REF)
1764 /* Set the field offset into T and gimplify it. */
1765 if (!TREE_OPERAND (t, 2))
1767 tree offset = unshare_expr (component_ref_field_offset (t));
1768 tree field = TREE_OPERAND (t, 1);
1770 = size_int (DECL_OFFSET_ALIGN (field) / BITS_PER_UNIT);
1772 /* Divide the offset by its alignment. */
1773 offset = size_binop (EXACT_DIV_EXPR, offset, factor);
1775 if (!is_gimple_min_invariant (offset))
1777 TREE_OPERAND (t, 2) = offset;
1778 tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p,
1779 is_gimple_formal_tmp_reg, fb_rvalue);
1780 ret = MIN (ret, tret);
1786 /* Step 2 is to gimplify the base expression. Make sure lvalue is set
1787 so as to match the min_lval predicate. Failure to do so may result
1788 in the creation of large aggregate temporaries. */
1789 tret = gimplify_expr (p, pre_p, post_p, is_gimple_min_lval,
1790 fallback | fb_lvalue);
1791 ret = MIN (ret, tret);
1793 /* And finally, the indices and operands to BIT_FIELD_REF. During this
1794 loop we also remove any useless conversions. */
1795 for (; VEC_length (tree, stack) > 0; )
1797 tree t = VEC_pop (tree, stack);
1799 if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
1801 /* Gimplify the dimension.
1802 Temporary fix for gcc.c-torture/execute/20040313-1.c.
1803 Gimplify non-constant array indices into a temporary
1805 FIXME - The real fix is to gimplify post-modify
1806 expressions into a minimal gimple lvalue. However, that
1807 exposes bugs in alias analysis. The alias analyzer does
1808 not handle &PTR->FIELD very well. Will fix after the
1809 branch is merged into mainline (dnovillo 2004-05-03). */
1810 if (!is_gimple_min_invariant (TREE_OPERAND (t, 1)))
1812 tret = gimplify_expr (&TREE_OPERAND (t, 1), pre_p, post_p,
1813 is_gimple_formal_tmp_reg, fb_rvalue);
1814 ret = MIN (ret, tret);
1817 else if (TREE_CODE (t) == BIT_FIELD_REF)
1819 tret = gimplify_expr (&TREE_OPERAND (t, 1), pre_p, post_p,
1820 is_gimple_val, fb_rvalue);
1821 ret = MIN (ret, tret);
1822 tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p,
1823 is_gimple_val, fb_rvalue);
1824 ret = MIN (ret, tret);
1827 STRIP_USELESS_TYPE_CONVERSION (TREE_OPERAND (t, 0));
1829 /* The innermost expression P may have originally had TREE_SIDE_EFFECTS
1830 set which would have caused all the outer expressions in EXPR_P
1831 leading to P to also have had TREE_SIDE_EFFECTS set. */
1832 recalculate_side_effects (t);
1835 tret = gimplify_expr (p, pre_p, post_p, is_gimple_min_lval, fallback);
1836 ret = MIN (ret, tret);
1838 /* If the outermost expression is a COMPONENT_REF, canonicalize its type. */
1839 if ((fallback & fb_rvalue) && TREE_CODE (*expr_p) == COMPONENT_REF)
1841 canonicalize_component_ref (expr_p);
1842 ret = MIN (ret, GS_OK);
1845 VEC_free (tree, heap, stack);
1850 /* Gimplify the self modifying expression pointed to by EXPR_P
1853 PRE_P points to the list where side effects that must happen before
1854 *EXPR_P should be stored.
1856 POST_P points to the list where side effects that must happen after
1857 *EXPR_P should be stored.
1859 WANT_VALUE is nonzero iff we want to use the value of this expression
1860 in another expression. */
1862 static enum gimplify_status
1863 gimplify_self_mod_expr (tree *expr_p, tree *pre_p, tree *post_p,
1866 enum tree_code code;
1867 tree lhs, lvalue, rhs, t1;
1869 enum tree_code arith_code;
1870 enum gimplify_status ret;
1872 code = TREE_CODE (*expr_p);
1874 gcc_assert (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR
1875 || code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR);
1877 /* Prefix or postfix? */
1878 if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
1879 /* Faster to treat as prefix if result is not used. */
1880 postfix = want_value;
1884 /* Add or subtract? */
1885 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
1886 arith_code = PLUS_EXPR;
1888 arith_code = MINUS_EXPR;
1890 /* Gimplify the LHS into a GIMPLE lvalue. */
1891 lvalue = TREE_OPERAND (*expr_p, 0);
1892 ret = gimplify_expr (&lvalue, pre_p, post_p, is_gimple_lvalue, fb_lvalue);
1893 if (ret == GS_ERROR)
1896 /* Extract the operands to the arithmetic operation. */
1898 rhs = TREE_OPERAND (*expr_p, 1);
1900 /* For postfix operator, we evaluate the LHS to an rvalue and then use
1901 that as the result value and in the postqueue operation. */
1904 ret = gimplify_expr (&lhs, pre_p, post_p, is_gimple_val, fb_rvalue);
1905 if (ret == GS_ERROR)
1909 t1 = build2 (arith_code, TREE_TYPE (*expr_p), lhs, rhs);
1910 t1 = build2 (MODIFY_EXPR, TREE_TYPE (lvalue), lvalue, t1);
1914 gimplify_and_add (t1, post_p);
1925 /* If *EXPR_P has a variable sized type, wrap it in a WITH_SIZE_EXPR. */
1928 maybe_with_size_expr (tree *expr_p)
1930 tree expr = *expr_p;
1931 tree type = TREE_TYPE (expr);
1934 /* If we've already wrapped this or the type is error_mark_node, we can't do
1936 if (TREE_CODE (expr) == WITH_SIZE_EXPR
1937 || type == error_mark_node)
1940 /* If the size isn't known or is a constant, we have nothing to do. */
1941 size = TYPE_SIZE_UNIT (type);
1942 if (!size || TREE_CODE (size) == INTEGER_CST)
1945 /* Otherwise, make a WITH_SIZE_EXPR. */
1946 size = unshare_expr (size);
1947 size = SUBSTITUTE_PLACEHOLDER_IN_EXPR (size, expr);
1948 *expr_p = build2 (WITH_SIZE_EXPR, type, expr, size);
1951 /* Subroutine of gimplify_call_expr: Gimplify a single argument. */
1953 static enum gimplify_status
1954 gimplify_arg (tree *expr_p, tree *pre_p)
1956 bool (*test) (tree);
1959 /* In general, we allow lvalues for function arguments to avoid
1960 extra overhead of copying large aggregates out of even larger
1961 aggregates into temporaries only to copy the temporaries to
1962 the argument list. Make optimizers happy by pulling out to
1963 temporaries those types that fit in registers. */
1964 if (is_gimple_reg_type (TREE_TYPE (*expr_p)))
1965 test = is_gimple_val, fb = fb_rvalue;
1967 test = is_gimple_lvalue, fb = fb_either;
1969 /* If this is a variable sized type, we must remember the size. */
1970 maybe_with_size_expr (expr_p);
1972 /* There is a sequence point before a function call. Side effects in
1973 the argument list must occur before the actual call. So, when
1974 gimplifying arguments, force gimplify_expr to use an internal
1975 post queue which is then appended to the end of PRE_P. */
1976 return gimplify_expr (expr_p, pre_p, NULL, test, fb);
1979 /* Gimplify the CALL_EXPR node pointed to by EXPR_P. PRE_P points to the
1980 list where side effects that must happen before *EXPR_P should be stored.
1981 WANT_VALUE is true if the result of the call is desired. */
1983 static enum gimplify_status
1984 gimplify_call_expr (tree *expr_p, tree *pre_p, bool want_value)
1988 enum gimplify_status ret;
1990 gcc_assert (TREE_CODE (*expr_p) == CALL_EXPR);
1992 /* For reliable diagnostics during inlining, it is necessary that
1993 every call_expr be annotated with file and line. */
1994 if (! EXPR_HAS_LOCATION (*expr_p))
1995 SET_EXPR_LOCATION (*expr_p, input_location);
1997 /* This may be a call to a builtin function.
1999 Builtin function calls may be transformed into different
2000 (and more efficient) builtin function calls under certain
2001 circumstances. Unfortunately, gimplification can muck things
2002 up enough that the builtin expanders are not aware that certain
2003 transformations are still valid.
2005 So we attempt transformation/gimplification of the call before
2006 we gimplify the CALL_EXPR. At this time we do not manage to
2007 transform all calls in the same manner as the expanders do, but
2008 we do transform most of them. */
2009 decl = get_callee_fndecl (*expr_p);
2010 if (decl && DECL_BUILT_IN (decl))
2012 tree arglist = TREE_OPERAND (*expr_p, 1);
2013 tree new = fold_builtin (decl, arglist, !want_value);
2015 if (new && new != *expr_p)
2017 /* There was a transformation of this call which computes the
2018 same value, but in a more efficient way. Return and try
2024 if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
2025 && DECL_FUNCTION_CODE (decl) == BUILT_IN_VA_START)
2027 if (!arglist || !TREE_CHAIN (arglist))
2029 error ("too few arguments to function %<va_start%>");
2030 *expr_p = build_empty_stmt ();
2034 if (fold_builtin_next_arg (TREE_CHAIN (arglist)))
2036 *expr_p = build_empty_stmt ();
2039 /* Avoid gimplifying the second argument to va_start, which needs
2040 to be the plain PARM_DECL. */
2041 return gimplify_arg (&TREE_VALUE (TREE_OPERAND (*expr_p, 1)), pre_p);
2045 /* There is a sequence point before the call, so any side effects in
2046 the calling expression must occur before the actual call. Force
2047 gimplify_expr to use an internal post queue. */
2048 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, NULL,
2049 is_gimple_call_addr, fb_rvalue);
2051 if (PUSH_ARGS_REVERSED)
2052 TREE_OPERAND (*expr_p, 1) = nreverse (TREE_OPERAND (*expr_p, 1));
2053 for (arglist = TREE_OPERAND (*expr_p, 1); arglist;
2054 arglist = TREE_CHAIN (arglist))
2056 enum gimplify_status t;
2058 t = gimplify_arg (&TREE_VALUE (arglist), pre_p);
2063 if (PUSH_ARGS_REVERSED)
2064 TREE_OPERAND (*expr_p, 1) = nreverse (TREE_OPERAND (*expr_p, 1));
2066 /* Try this again in case gimplification exposed something. */
2067 if (ret != GS_ERROR)
2069 decl = get_callee_fndecl (*expr_p);
2070 if (decl && DECL_BUILT_IN (decl))
2072 tree arglist = TREE_OPERAND (*expr_p, 1);
2073 tree new = fold_builtin (decl, arglist, !want_value);
2075 if (new && new != *expr_p)
2077 /* There was a transformation of this call which computes the
2078 same value, but in a more efficient way. Return and try
2086 /* If the function is "const" or "pure", then clear TREE_SIDE_EFFECTS on its
2087 decl. This allows us to eliminate redundant or useless
2088 calls to "const" functions. */
2089 if (TREE_CODE (*expr_p) == CALL_EXPR
2090 && (call_expr_flags (*expr_p) & (ECF_CONST | ECF_PURE)))
2091 TREE_SIDE_EFFECTS (*expr_p) = 0;
2096 /* Handle shortcut semantics in the predicate operand of a COND_EXPR by
2097 rewriting it into multiple COND_EXPRs, and possibly GOTO_EXPRs.
2099 TRUE_LABEL_P and FALSE_LABEL_P point to the labels to jump to if the
2100 condition is true or false, respectively. If null, we should generate
2101 our own to skip over the evaluation of this specific expression.
2103 This function is the tree equivalent of do_jump.
2105 shortcut_cond_r should only be called by shortcut_cond_expr. */
2108 shortcut_cond_r (tree pred, tree *true_label_p, tree *false_label_p)
2110 tree local_label = NULL_TREE;
2111 tree t, expr = NULL;
2113 /* OK, it's not a simple case; we need to pull apart the COND_EXPR to
2114 retain the shortcut semantics. Just insert the gotos here;
2115 shortcut_cond_expr will append the real blocks later. */
2116 if (TREE_CODE (pred) == TRUTH_ANDIF_EXPR)
2118 /* Turn if (a && b) into
2120 if (a); else goto no;
2121 if (b) goto yes; else goto no;
2124 if (false_label_p == NULL)
2125 false_label_p = &local_label;
2127 t = shortcut_cond_r (TREE_OPERAND (pred, 0), NULL, false_label_p);
2128 append_to_statement_list (t, &expr);
2130 t = shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p,
2132 append_to_statement_list (t, &expr);
2134 else if (TREE_CODE (pred) == TRUTH_ORIF_EXPR)
2136 /* Turn if (a || b) into
2139 if (b) goto yes; else goto no;
2142 if (true_label_p == NULL)
2143 true_label_p = &local_label;
2145 t = shortcut_cond_r (TREE_OPERAND (pred, 0), true_label_p, NULL);
2146 append_to_statement_list (t, &expr);
2148 t = shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p,
2150 append_to_statement_list (t, &expr);
2152 else if (TREE_CODE (pred) == COND_EXPR)
2154 /* As long as we're messing with gotos, turn if (a ? b : c) into
2156 if (b) goto yes; else goto no;
2158 if (c) goto yes; else goto no; */
2159 expr = build3 (COND_EXPR, void_type_node, TREE_OPERAND (pred, 0),
2160 shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p,
2162 shortcut_cond_r (TREE_OPERAND (pred, 2), true_label_p,
2167 expr = build3 (COND_EXPR, void_type_node, pred,
2168 build_and_jump (true_label_p),
2169 build_and_jump (false_label_p));
2174 t = build1 (LABEL_EXPR, void_type_node, local_label);
2175 append_to_statement_list (t, &expr);
2182 shortcut_cond_expr (tree expr)
2184 tree pred = TREE_OPERAND (expr, 0);
2185 tree then_ = TREE_OPERAND (expr, 1);
2186 tree else_ = TREE_OPERAND (expr, 2);
2187 tree true_label, false_label, end_label, t;
2189 tree *false_label_p;
2190 bool emit_end, emit_false, jump_over_else;
2191 bool then_se = then_ && TREE_SIDE_EFFECTS (then_);
2192 bool else_se = else_ && TREE_SIDE_EFFECTS (else_);
2194 /* First do simple transformations. */
2197 /* If there is no 'else', turn (a && b) into if (a) if (b). */
2198 while (TREE_CODE (pred) == TRUTH_ANDIF_EXPR)
2200 TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1);
2201 then_ = shortcut_cond_expr (expr);
2202 then_se = then_ && TREE_SIDE_EFFECTS (then_);
2203 pred = TREE_OPERAND (pred, 0);
2204 expr = build3 (COND_EXPR, void_type_node, pred, then_, NULL_TREE);
2209 /* If there is no 'then', turn
2212 if (a); else if (b); else d. */
2213 while (TREE_CODE (pred) == TRUTH_ORIF_EXPR)
2215 TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1);
2216 else_ = shortcut_cond_expr (expr);
2217 else_se = else_ && TREE_SIDE_EFFECTS (else_);
2218 pred = TREE_OPERAND (pred, 0);
2219 expr = build3 (COND_EXPR, void_type_node, pred, NULL_TREE, else_);
2223 /* If we're done, great. */
2224 if (TREE_CODE (pred) != TRUTH_ANDIF_EXPR
2225 && TREE_CODE (pred) != TRUTH_ORIF_EXPR)
2228 /* Otherwise we need to mess with gotos. Change
2231 if (a); else goto no;
2234 and recursively gimplify the condition. */
2236 true_label = false_label = end_label = NULL_TREE;
2238 /* If our arms just jump somewhere, hijack those labels so we don't
2239 generate jumps to jumps. */
2242 && TREE_CODE (then_) == GOTO_EXPR
2243 && TREE_CODE (GOTO_DESTINATION (then_)) == LABEL_DECL)
2245 true_label = GOTO_DESTINATION (then_);
2251 && TREE_CODE (else_) == GOTO_EXPR
2252 && TREE_CODE (GOTO_DESTINATION (else_)) == LABEL_DECL)
2254 false_label = GOTO_DESTINATION (else_);
2259 /* If we aren't hijacking a label for the 'then' branch, it falls through. */
2261 true_label_p = &true_label;
2263 true_label_p = NULL;
2265 /* The 'else' branch also needs a label if it contains interesting code. */
2266 if (false_label || else_se)
2267 false_label_p = &false_label;
2269 false_label_p = NULL;
2271 /* If there was nothing else in our arms, just forward the label(s). */
2272 if (!then_se && !else_se)
2273 return shortcut_cond_r (pred, true_label_p, false_label_p);
2275 /* If our last subexpression already has a terminal label, reuse it. */
2277 expr = expr_last (else_);
2279 expr = expr_last (then_);
2282 if (expr && TREE_CODE (expr) == LABEL_EXPR)
2283 end_label = LABEL_EXPR_LABEL (expr);
2285 /* If we don't care about jumping to the 'else' branch, jump to the end
2286 if the condition is false. */
2288 false_label_p = &end_label;
2290 /* We only want to emit these labels if we aren't hijacking them. */
2291 emit_end = (end_label == NULL_TREE);
2292 emit_false = (false_label == NULL_TREE);
2294 /* We only emit the jump over the else clause if we have to--if the
2295 then clause may fall through. Otherwise we can wind up with a
2296 useless jump and a useless label at the end of gimplified code,
2297 which will cause us to think that this conditional as a whole
2298 falls through even if it doesn't. If we then inline a function
2299 which ends with such a condition, that can cause us to issue an
2300 inappropriate warning about control reaching the end of a
2301 non-void function. */
2302 jump_over_else = block_may_fallthru (then_);
2304 pred = shortcut_cond_r (pred, true_label_p, false_label_p);
2307 append_to_statement_list (pred, &expr);
2309 append_to_statement_list (then_, &expr);
2314 t = build_and_jump (&end_label);
2315 append_to_statement_list (t, &expr);
2319 t = build1 (LABEL_EXPR, void_type_node, false_label);
2320 append_to_statement_list (t, &expr);
2322 append_to_statement_list (else_, &expr);
2324 if (emit_end && end_label)
2326 t = build1 (LABEL_EXPR, void_type_node, end_label);
2327 append_to_statement_list (t, &expr);
2333 /* EXPR is used in a boolean context; make sure it has BOOLEAN_TYPE. */
2336 gimple_boolify (tree expr)
2338 tree type = TREE_TYPE (expr);
2340 if (TREE_CODE (type) == BOOLEAN_TYPE)
2343 switch (TREE_CODE (expr))
2345 case TRUTH_AND_EXPR:
2347 case TRUTH_XOR_EXPR:
2348 case TRUTH_ANDIF_EXPR:
2349 case TRUTH_ORIF_EXPR:
2350 /* Also boolify the arguments of truth exprs. */
2351 TREE_OPERAND (expr, 1) = gimple_boolify (TREE_OPERAND (expr, 1));
2354 case TRUTH_NOT_EXPR:
2355 TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0));
2358 case EQ_EXPR: case NE_EXPR:
2359 case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
2360 /* These expressions always produce boolean results. */
2361 TREE_TYPE (expr) = boolean_type_node;
2365 /* Other expressions that get here must have boolean values, but
2366 might need to be converted to the appropriate mode. */
2367 return fold_convert (boolean_type_node, expr);
2371 /* Convert the conditional expression pointed to by EXPR_P '(p) ? a : b;'
2380 The second form is used when *EXPR_P is of type void.
2382 TARGET is the tree for T1 above.
2384 PRE_P points to the list where side effects that must happen before
2385 *EXPR_P should be stored. */
2387 static enum gimplify_status
2388 gimplify_cond_expr (tree *expr_p, tree *pre_p, fallback_t fallback)
2390 tree expr = *expr_p;
2391 tree tmp, tmp2, type;
2392 enum gimplify_status ret;
2394 type = TREE_TYPE (expr);
2396 /* If this COND_EXPR has a value, copy the values into a temporary within
2398 if (! VOID_TYPE_P (type))
2402 if ((fallback & fb_lvalue) == 0)
2404 result = tmp2 = tmp = create_tmp_var (TREE_TYPE (expr), "iftmp");
2409 tree type = build_pointer_type (TREE_TYPE (expr));
2411 if (TREE_TYPE (TREE_OPERAND (expr, 1)) != void_type_node)
2412 TREE_OPERAND (expr, 1) =
2413 build_fold_addr_expr (TREE_OPERAND (expr, 1));
2415 if (TREE_TYPE (TREE_OPERAND (expr, 2)) != void_type_node)
2416 TREE_OPERAND (expr, 2) =
2417 build_fold_addr_expr (TREE_OPERAND (expr, 2));
2419 tmp2 = tmp = create_tmp_var (type, "iftmp");
2421 expr = build3 (COND_EXPR, void_type_node, TREE_OPERAND (expr, 0),
2422 TREE_OPERAND (expr, 1), TREE_OPERAND (expr, 2));
2424 result = build_fold_indirect_ref (tmp);
2428 /* Build the then clause, 't1 = a;'. But don't build an assignment
2429 if this branch is void; in C++ it can be, if it's a throw. */
2430 if (TREE_TYPE (TREE_OPERAND (expr, 1)) != void_type_node)
2431 TREE_OPERAND (expr, 1)
2432 = build2 (MODIFY_EXPR, void_type_node, tmp, TREE_OPERAND (expr, 1));
2434 /* Build the else clause, 't1 = b;'. */
2435 if (TREE_TYPE (TREE_OPERAND (expr, 2)) != void_type_node)
2436 TREE_OPERAND (expr, 2)
2437 = build2 (MODIFY_EXPR, void_type_node, tmp2, TREE_OPERAND (expr, 2));
2439 TREE_TYPE (expr) = void_type_node;
2440 recalculate_side_effects (expr);
2442 /* Move the COND_EXPR to the prequeue. */
2443 gimplify_and_add (expr, pre_p);
2449 /* Make sure the condition has BOOLEAN_TYPE. */
2450 TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0));
2452 /* Break apart && and || conditions. */
2453 if (TREE_CODE (TREE_OPERAND (expr, 0)) == TRUTH_ANDIF_EXPR
2454 || TREE_CODE (TREE_OPERAND (expr, 0)) == TRUTH_ORIF_EXPR)
2456 expr = shortcut_cond_expr (expr);
2458 if (expr != *expr_p)
2462 /* We can't rely on gimplify_expr to re-gimplify the expanded
2463 form properly, as cleanups might cause the target labels to be
2464 wrapped in a TRY_FINALLY_EXPR. To prevent that, we need to
2465 set up a conditional context. */
2466 gimple_push_condition ();
2467 gimplify_stmt (expr_p);
2468 gimple_pop_condition (pre_p);
2474 /* Now do the normal gimplification. */
2475 ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, NULL,
2476 is_gimple_condexpr, fb_rvalue);
2478 gimple_push_condition ();
2480 gimplify_to_stmt_list (&TREE_OPERAND (expr, 1));
2481 gimplify_to_stmt_list (&TREE_OPERAND (expr, 2));
2482 recalculate_side_effects (expr);
2484 gimple_pop_condition (pre_p);
2486 if (ret == GS_ERROR)
2488 else if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2490 else if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 2)))
2491 /* Rewrite "if (a); else b" to "if (!a) b" */
2493 TREE_OPERAND (expr, 0) = invert_truthvalue (TREE_OPERAND (expr, 0));
2494 ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, NULL,
2495 is_gimple_condexpr, fb_rvalue);
2497 tmp = TREE_OPERAND (expr, 1);
2498 TREE_OPERAND (expr, 1) = TREE_OPERAND (expr, 2);
2499 TREE_OPERAND (expr, 2) = tmp;
2502 /* Both arms are empty; replace the COND_EXPR with its predicate. */
2503 expr = TREE_OPERAND (expr, 0);
2509 /* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with
2510 a call to __builtin_memcpy. */
2512 static enum gimplify_status
2513 gimplify_modify_expr_to_memcpy (tree *expr_p, tree size, bool want_value)
2515 tree args, t, to, to_ptr, from;
2517 to = TREE_OPERAND (*expr_p, 0);
2518 from = TREE_OPERAND (*expr_p, 1);
2520 args = tree_cons (NULL, size, NULL);
2522 t = build_fold_addr_expr (from);
2523 args = tree_cons (NULL, t, args);
2525 to_ptr = build_fold_addr_expr (to);
2526 args = tree_cons (NULL, to_ptr, args);
2527 t = implicit_built_in_decls[BUILT_IN_MEMCPY];
2528 t = build_function_call_expr (t, args);
2532 t = build1 (NOP_EXPR, TREE_TYPE (to_ptr), t);
2533 t = build1 (INDIRECT_REF, TREE_TYPE (to), t);
2540 /* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with
2541 a call to __builtin_memset. In this case we know that the RHS is
2542 a CONSTRUCTOR with an empty element list. */
2544 static enum gimplify_status
2545 gimplify_modify_expr_to_memset (tree *expr_p, tree size, bool want_value)
2547 tree args, t, to, to_ptr;
2549 to = TREE_OPERAND (*expr_p, 0);
2551 args = tree_cons (NULL, size, NULL);
2553 args = tree_cons (NULL, integer_zero_node, args);
2555 to_ptr = build_fold_addr_expr (to);
2556 args = tree_cons (NULL, to_ptr, args);
2557 t = implicit_built_in_decls[BUILT_IN_MEMSET];
2558 t = build_function_call_expr (t, args);
2562 t = build1 (NOP_EXPR, TREE_TYPE (to_ptr), t);
2563 t = build1 (INDIRECT_REF, TREE_TYPE (to), t);
2570 /* A subroutine of gimplify_init_ctor_preeval. Called via walk_tree,
2571 determine, cautiously, if a CONSTRUCTOR overlaps the lhs of an
2572 assignment. Returns non-null if we detect a potential overlap. */
2574 struct gimplify_init_ctor_preeval_data
2576 /* The base decl of the lhs object. May be NULL, in which case we
2577 have to assume the lhs is indirect. */
2580 /* The alias set of the lhs object. */
2585 gimplify_init_ctor_preeval_1 (tree *tp, int *walk_subtrees, void *xdata)
2587 struct gimplify_init_ctor_preeval_data *data
2588 = (struct gimplify_init_ctor_preeval_data *) xdata;
2591 /* If we find the base object, obviously we have overlap. */
2592 if (data->lhs_base_decl == t)
2595 /* If the constructor component is indirect, determine if we have a
2596 potential overlap with the lhs. The only bits of information we
2597 have to go on at this point are addressability and alias sets. */
2598 if (TREE_CODE (t) == INDIRECT_REF
2599 && (!data->lhs_base_decl || TREE_ADDRESSABLE (data->lhs_base_decl))
2600 && alias_sets_conflict_p (data->lhs_alias_set, get_alias_set (t)))
2603 if (IS_TYPE_OR_DECL_P (t))
2608 /* A subroutine of gimplify_init_constructor. Pre-evaluate *EXPR_P,
2609 force values that overlap with the lhs (as described by *DATA)
2610 into temporaries. */
2613 gimplify_init_ctor_preeval (tree *expr_p, tree *pre_p, tree *post_p,
2614 struct gimplify_init_ctor_preeval_data *data)
2616 enum gimplify_status one;
2618 /* If the value is invariant, then there's nothing to pre-evaluate.
2619 But ensure it doesn't have any side-effects since a SAVE_EXPR is
2620 invariant but has side effects and might contain a reference to
2621 the object we're initializing. */
2622 if (TREE_INVARIANT (*expr_p) && !TREE_SIDE_EFFECTS (*expr_p))
2625 /* If the type has non-trivial constructors, we can't pre-evaluate. */
2626 if (TREE_ADDRESSABLE (TREE_TYPE (*expr_p)))
2629 /* Recurse for nested constructors. */
2630 if (TREE_CODE (*expr_p) == CONSTRUCTOR)
2632 unsigned HOST_WIDE_INT ix;
2633 constructor_elt *ce;
2634 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (*expr_p);
2636 for (ix = 0; VEC_iterate (constructor_elt, v, ix, ce); ix++)
2637 gimplify_init_ctor_preeval (&ce->value, pre_p, post_p, data);
2641 /* We can't preevaluate if the type contains a placeholder. */
2642 if (type_contains_placeholder_p (TREE_TYPE (*expr_p)))
2645 /* Gimplify the constructor element to something appropriate for the rhs
2646 of a MODIFY_EXPR. Given that we know the lhs is an aggregate, we know
2647 the gimplifier will consider this a store to memory. Doing this
2648 gimplification now means that we won't have to deal with complicated
2649 language-specific trees, nor trees like SAVE_EXPR that can induce
2650 exponential search behavior. */
2651 one = gimplify_expr (expr_p, pre_p, post_p, is_gimple_mem_rhs, fb_rvalue);
2652 if (one == GS_ERROR)
2658 /* If we gimplified to a bare decl, we can be sure that it doesn't overlap
2659 with the lhs, since "a = { .x=a }" doesn't make sense. This will
2660 always be true for all scalars, since is_gimple_mem_rhs insists on a
2661 temporary variable for them. */
2662 if (DECL_P (*expr_p))
2665 /* If this is of variable size, we have no choice but to assume it doesn't
2666 overlap since we can't make a temporary for it. */
2667 if (!TREE_CONSTANT (TYPE_SIZE (TREE_TYPE (*expr_p))))
2670 /* Otherwise, we must search for overlap ... */
2671 if (!walk_tree (expr_p, gimplify_init_ctor_preeval_1, data, NULL))
2674 /* ... and if found, force the value into a temporary. */
2675 *expr_p = get_formal_tmp_var (*expr_p, pre_p);
2678 /* A subroutine of gimplify_init_ctor_eval. Create a loop for
2679 a RANGE_EXPR in a CONSTRUCTOR for an array.
2683 object[var] = value;
2690 We increment var _after_ the loop exit check because we might otherwise
2691 fail if upper == TYPE_MAX_VALUE (type for upper).
2693 Note that we never have to deal with SAVE_EXPRs here, because this has
2694 already been taken care of for us, in gimplify_init_ctor_preeval(). */
2696 static void gimplify_init_ctor_eval (tree, VEC(constructor_elt,gc) *,
2700 gimplify_init_ctor_eval_range (tree object, tree lower, tree upper,
2701 tree value, tree array_elt_type,
2702 tree *pre_p, bool cleared)
2704 tree loop_entry_label, loop_exit_label;
2705 tree var, var_type, cref;
2707 loop_entry_label = create_artificial_label ();
2708 loop_exit_label = create_artificial_label ();
2710 /* Create and initialize the index variable. */
2711 var_type = TREE_TYPE (upper);
2712 var = create_tmp_var (var_type, NULL);
2713 append_to_statement_list (build2 (MODIFY_EXPR, var_type, var, lower), pre_p);
2715 /* Add the loop entry label. */
2716 append_to_statement_list (build1 (LABEL_EXPR,
2721 /* Build the reference. */
2722 cref = build4 (ARRAY_REF, array_elt_type, unshare_expr (object),
2723 var, NULL_TREE, NULL_TREE);
2725 /* If we are a constructor, just call gimplify_init_ctor_eval to do
2726 the store. Otherwise just assign value to the reference. */
2728 if (TREE_CODE (value) == CONSTRUCTOR)
2729 /* NB we might have to call ourself recursively through
2730 gimplify_init_ctor_eval if the value is a constructor. */
2731 gimplify_init_ctor_eval (cref, CONSTRUCTOR_ELTS (value),
2734 append_to_statement_list (build2 (MODIFY_EXPR, TREE_TYPE (cref),
2738 /* We exit the loop when the index var is equal to the upper bound. */
2739 gimplify_and_add (build3 (COND_EXPR, void_type_node,
2740 build2 (EQ_EXPR, boolean_type_node,
2748 /* Otherwise, increment the index var... */
2749 append_to_statement_list (build2 (MODIFY_EXPR, var_type, var,
2750 build2 (PLUS_EXPR, var_type, var,
2751 fold_convert (var_type,
2752 integer_one_node))),
2755 /* ...and jump back to the loop entry. */
2756 append_to_statement_list (build1 (GOTO_EXPR,
2761 /* Add the loop exit label. */
2762 append_to_statement_list (build1 (LABEL_EXPR,
2768 /* Return true if FDECL is accessing a field that is zero sized. */
2771 zero_sized_field_decl (tree fdecl)
2773 if (TREE_CODE (fdecl) == FIELD_DECL && DECL_SIZE (fdecl)
2774 && integer_zerop (DECL_SIZE (fdecl)))
2779 /* Return true if TYPE is zero sized. */
2782 zero_sized_type (tree type)
2784 if (AGGREGATE_TYPE_P (type) && TYPE_SIZE (type)
2785 && integer_zerop (TYPE_SIZE (type)))
2790 /* A subroutine of gimplify_init_constructor. Generate individual
2791 MODIFY_EXPRs for a CONSTRUCTOR. OBJECT is the LHS against which the
2792 assignments should happen. ELTS is the CONSTRUCTOR_ELTS of the
2793 CONSTRUCTOR. CLEARED is true if the entire LHS object has been
2797 gimplify_init_ctor_eval (tree object, VEC(constructor_elt,gc) *elts,
2798 tree *pre_p, bool cleared)
2800 tree array_elt_type = NULL;
2801 unsigned HOST_WIDE_INT ix;
2802 tree purpose, value;
2804 if (TREE_CODE (TREE_TYPE (object)) == ARRAY_TYPE)
2805 array_elt_type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (object)));
2807 FOR_EACH_CONSTRUCTOR_ELT (elts, ix, purpose, value)
2811 /* NULL values are created above for gimplification errors. */
2815 if (cleared && initializer_zerop (value))
2818 /* ??? Here's to hoping the front end fills in all of the indices,
2819 so we don't have to figure out what's missing ourselves. */
2820 gcc_assert (purpose);
2822 /* Skip zero-sized fields, unless value has side-effects. This can
2823 happen with calls to functions returning a zero-sized type, which
2824 we shouldn't discard. As a number of downstream passes don't
2825 expect sets of zero-sized fields, we rely on the gimplification of
2826 the MODIFY_EXPR we make below to drop the assignment statement. */
2827 if (! TREE_SIDE_EFFECTS (value) && zero_sized_field_decl (purpose))
2830 /* If we have a RANGE_EXPR, we have to build a loop to assign the
2832 if (TREE_CODE (purpose) == RANGE_EXPR)
2834 tree lower = TREE_OPERAND (purpose, 0);
2835 tree upper = TREE_OPERAND (purpose, 1);
2837 /* If the lower bound is equal to upper, just treat it as if
2838 upper was the index. */
2839 if (simple_cst_equal (lower, upper))
2843 gimplify_init_ctor_eval_range (object, lower, upper, value,
2844 array_elt_type, pre_p, cleared);
2851 cref = build4 (ARRAY_REF, array_elt_type, unshare_expr (object),
2852 purpose, NULL_TREE, NULL_TREE);
2856 gcc_assert (TREE_CODE (purpose) == FIELD_DECL);
2857 cref = build3 (COMPONENT_REF, TREE_TYPE (purpose),
2858 unshare_expr (object), purpose, NULL_TREE);
2861 if (TREE_CODE (value) == CONSTRUCTOR
2862 && TREE_CODE (TREE_TYPE (value)) != VECTOR_TYPE)
2863 gimplify_init_ctor_eval (cref, CONSTRUCTOR_ELTS (value),
2867 init = build2 (INIT_EXPR, TREE_TYPE (cref), cref, value);
2868 gimplify_and_add (init, pre_p);
2873 /* A subroutine of gimplify_modify_expr. Break out elements of a
2874 CONSTRUCTOR used as an initializer into separate MODIFY_EXPRs.
2876 Note that we still need to clear any elements that don't have explicit
2877 initializers, so if not all elements are initialized we keep the
2878 original MODIFY_EXPR, we just remove all of the constructor elements. */
2880 static enum gimplify_status
2881 gimplify_init_constructor (tree *expr_p, tree *pre_p,
2882 tree *post_p, bool want_value)
2885 tree ctor = TREE_OPERAND (*expr_p, 1);
2886 tree type = TREE_TYPE (ctor);
2887 enum gimplify_status ret;
2888 VEC(constructor_elt,gc) *elts;
2890 if (TREE_CODE (ctor) != CONSTRUCTOR)
2891 return GS_UNHANDLED;
2893 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
2894 is_gimple_lvalue, fb_lvalue);
2895 if (ret == GS_ERROR)
2897 object = TREE_OPERAND (*expr_p, 0);
2899 elts = CONSTRUCTOR_ELTS (ctor);
2902 switch (TREE_CODE (type))
2906 case QUAL_UNION_TYPE:
2909 struct gimplify_init_ctor_preeval_data preeval_data;
2910 HOST_WIDE_INT num_type_elements, num_ctor_elements;
2911 HOST_WIDE_INT num_nonzero_elements, num_nonconstant_elements;
2914 /* Aggregate types must lower constructors to initialization of
2915 individual elements. The exception is that a CONSTRUCTOR node
2916 with no elements indicates zero-initialization of the whole. */
2917 if (VEC_empty (constructor_elt, elts))
2920 categorize_ctor_elements (ctor, &num_nonzero_elements,
2921 &num_nonconstant_elements,
2922 &num_ctor_elements, &cleared);
2924 /* If a const aggregate variable is being initialized, then it
2925 should never be a lose to promote the variable to be static. */
2926 if (num_nonconstant_elements == 0
2927 && num_nonzero_elements > 1
2928 && TREE_READONLY (object)
2929 && TREE_CODE (object) == VAR_DECL)
2931 DECL_INITIAL (object) = ctor;
2932 TREE_STATIC (object) = 1;
2933 if (!DECL_NAME (object))
2934 DECL_NAME (object) = create_tmp_var_name ("C");
2935 walk_tree (&DECL_INITIAL (object), force_labels_r, NULL, NULL);
2937 /* ??? C++ doesn't automatically append a .<number> to the
2938 assembler name, and even when it does, it looks a FE private
2939 data structures to figure out what that number should be,
2940 which are not set for this variable. I suppose this is
2941 important for local statics for inline functions, which aren't
2942 "local" in the object file sense. So in order to get a unique
2943 TU-local symbol, we must invoke the lhd version now. */
2944 lhd_set_decl_assembler_name (object);
2946 *expr_p = NULL_TREE;
2950 /* If there are "lots" of initialized elements, even discounting
2951 those that are not address constants (and thus *must* be
2952 computed at runtime), then partition the constructor into
2953 constant and non-constant parts. Block copy the constant
2954 parts in, then generate code for the non-constant parts. */
2955 /* TODO. There's code in cp/typeck.c to do this. */
2957 num_type_elements = count_type_elements (type, true);
2959 /* If count_type_elements could not determine number of type elements
2960 for a constant-sized object, assume clearing is needed.
2961 Don't do this for variable-sized objects, as store_constructor
2962 will ignore the clearing of variable-sized objects. */
2963 if (num_type_elements < 0 && int_size_in_bytes (type) >= 0)
2965 /* If there are "lots" of zeros, then block clear the object first. */
2966 else if (num_type_elements - num_nonzero_elements > CLEAR_RATIO
2967 && num_nonzero_elements < num_type_elements/4)
2969 /* ??? This bit ought not be needed. For any element not present
2970 in the initializer, we should simply set them to zero. Except
2971 we'd need to *find* the elements that are not present, and that
2972 requires trickery to avoid quadratic compile-time behavior in
2973 large cases or excessive memory use in small cases. */
2974 else if (num_ctor_elements < num_type_elements)
2977 /* If there are "lots" of initialized elements, and all of them
2978 are valid address constants, then the entire initializer can
2979 be dropped to memory, and then memcpy'd out. Don't do this
2980 for sparse arrays, though, as it's more efficient to follow
2981 the standard CONSTRUCTOR behavior of memset followed by
2982 individual element initialization. */
2983 if (num_nonconstant_elements == 0 && !cleared)
2985 HOST_WIDE_INT size = int_size_in_bytes (type);
2988 /* ??? We can still get unbounded array types, at least
2989 from the C++ front end. This seems wrong, but attempt
2990 to work around it for now. */
2993 size = int_size_in_bytes (TREE_TYPE (object));
2995 TREE_TYPE (ctor) = type = TREE_TYPE (object);
2998 /* Find the maximum alignment we can assume for the object. */
2999 /* ??? Make use of DECL_OFFSET_ALIGN. */
3000 if (DECL_P (object))
3001 align = DECL_ALIGN (object);
3003 align = TYPE_ALIGN (type);
3005 if (size > 0 && !can_move_by_pieces (size, align))
3007 tree new = create_tmp_var_raw (type, "C");
3009 gimple_add_tmp_var (new);
3010 TREE_STATIC (new) = 1;
3011 TREE_READONLY (new) = 1;
3012 DECL_INITIAL (new) = ctor;
3013 if (align > DECL_ALIGN (new))
3015 DECL_ALIGN (new) = align;
3016 DECL_USER_ALIGN (new) = 1;
3018 walk_tree (&DECL_INITIAL (new), force_labels_r, NULL, NULL);
3020 TREE_OPERAND (*expr_p, 1) = new;
3022 /* This is no longer an assignment of a CONSTRUCTOR, but
3023 we still may have processing to do on the LHS. So
3024 pretend we didn't do anything here to let that happen. */
3025 return GS_UNHANDLED;
3031 /* Zap the CONSTRUCTOR element list, which simplifies this case.
3032 Note that we still have to gimplify, in order to handle the
3033 case of variable sized types. Avoid shared tree structures. */
3034 CONSTRUCTOR_ELTS (ctor) = NULL;
3035 object = unshare_expr (object);
3036 gimplify_stmt (expr_p);
3037 append_to_statement_list (*expr_p, pre_p);
3040 /* If we have not block cleared the object, or if there are nonzero
3041 elements in the constructor, add assignments to the individual
3042 scalar fields of the object. */
3043 if (!cleared || num_nonzero_elements > 0)
3045 preeval_data.lhs_base_decl = get_base_address (object);
3046 if (!DECL_P (preeval_data.lhs_base_decl))
3047 preeval_data.lhs_base_decl = NULL;
3048 preeval_data.lhs_alias_set = get_alias_set (object);
3050 gimplify_init_ctor_preeval (&TREE_OPERAND (*expr_p, 1),
3051 pre_p, post_p, &preeval_data);
3052 gimplify_init_ctor_eval (object, elts, pre_p, cleared);
3055 *expr_p = NULL_TREE;
3063 /* Extract the real and imaginary parts out of the ctor. */
3064 gcc_assert (VEC_length (constructor_elt, elts) == 2);
3065 r = VEC_index (constructor_elt, elts, 0)->value;
3066 i = VEC_index (constructor_elt, elts, 1)->value;
3067 if (r == NULL || i == NULL)
3069 tree zero = fold_convert (TREE_TYPE (type), integer_zero_node);
3076 /* Complex types have either COMPLEX_CST or COMPLEX_EXPR to
3077 represent creation of a complex value. */
3078 if (TREE_CONSTANT (r) && TREE_CONSTANT (i))
3080 ctor = build_complex (type, r, i);
3081 TREE_OPERAND (*expr_p, 1) = ctor;
3085 ctor = build2 (COMPLEX_EXPR, type, r, i);
3086 TREE_OPERAND (*expr_p, 1) = ctor;
3087 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p,
3088 rhs_predicate_for (TREE_OPERAND (*expr_p, 0)),
3096 unsigned HOST_WIDE_INT ix;
3097 constructor_elt *ce;
3099 /* Go ahead and simplify constant constructors to VECTOR_CST. */
3100 if (TREE_CONSTANT (ctor))
3102 bool constant_p = true;
3105 /* Even when ctor is constant, it might contain non-*_CST
3106 elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't
3107 belong into VECTOR_CST nodes. */
3108 FOR_EACH_CONSTRUCTOR_VALUE (elts, ix, value)
3109 if (!CONSTANT_CLASS_P (value))
3117 TREE_OPERAND (*expr_p, 1) = build_vector_from_ctor (type, elts);
3122 /* Vector types use CONSTRUCTOR all the way through gimple
3123 compilation as a general initializer. */
3124 for (ix = 0; VEC_iterate (constructor_elt, elts, ix, ce); ix++)
3126 enum gimplify_status tret;
3127 tret = gimplify_expr (&ce->value, pre_p, post_p,
3128 is_gimple_val, fb_rvalue);
3129 if (tret == GS_ERROR)
3136 /* So how did we get a CONSTRUCTOR for a scalar type? */
3140 if (ret == GS_ERROR)
3142 else if (want_value)
3144 append_to_statement_list (*expr_p, pre_p);
3152 /* Given a pointer value OP0, return a simplified version of an
3153 indirection through OP0, or NULL_TREE if no simplification is
3154 possible. This may only be applied to a rhs of an expression.
3155 Note that the resulting type may be different from the type pointed
3156 to in the sense that it is still compatible from the langhooks
3160 fold_indirect_ref_rhs (tree t)
3162 tree type = TREE_TYPE (TREE_TYPE (t));
3167 subtype = TREE_TYPE (sub);
3168 if (!POINTER_TYPE_P (subtype))
3171 if (TREE_CODE (sub) == ADDR_EXPR)
3173 tree op = TREE_OPERAND (sub, 0);
3174 tree optype = TREE_TYPE (op);
3176 if (lang_hooks.types_compatible_p (type, optype))
3178 /* *(foo *)&fooarray => fooarray[0] */
3179 else if (TREE_CODE (optype) == ARRAY_TYPE
3180 && lang_hooks.types_compatible_p (type, TREE_TYPE (optype)))
3182 tree type_domain = TYPE_DOMAIN (optype);
3183 tree min_val = size_zero_node;
3184 if (type_domain && TYPE_MIN_VALUE (type_domain))
3185 min_val = TYPE_MIN_VALUE (type_domain);
3186 return build4 (ARRAY_REF, type, op, min_val, NULL_TREE, NULL_TREE);
3190 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
3191 if (TREE_CODE (TREE_TYPE (subtype)) == ARRAY_TYPE
3192 && lang_hooks.types_compatible_p (type, TREE_TYPE (TREE_TYPE (subtype))))
3195 tree min_val = size_zero_node;
3197 sub = fold_indirect_ref_rhs (sub);
3199 sub = build1 (INDIRECT_REF, TREE_TYPE (subtype), osub);
3200 type_domain = TYPE_DOMAIN (TREE_TYPE (sub));
3201 if (type_domain && TYPE_MIN_VALUE (type_domain))
3202 min_val = TYPE_MIN_VALUE (type_domain);
3203 return build4 (ARRAY_REF, type, sub, min_val, NULL_TREE, NULL_TREE);
3209 /* Subroutine of gimplify_modify_expr to do simplifications of MODIFY_EXPRs
3210 based on the code of the RHS. We loop for as long as something changes. */
3212 static enum gimplify_status
3213 gimplify_modify_expr_rhs (tree *expr_p, tree *from_p, tree *to_p, tree *pre_p,
3214 tree *post_p, bool want_value)
3216 enum gimplify_status ret = GS_OK;
3218 while (ret != GS_UNHANDLED)
3219 switch (TREE_CODE (*from_p))
3223 /* If we have code like
3227 where the type of "x" is a (possibly cv-qualified variant
3228 of "A"), treat the entire expression as identical to "x".
3229 This kind of code arises in C++ when an object is bound
3230 to a const reference, and if "x" is a TARGET_EXPR we want
3231 to take advantage of the optimization below. */
3232 tree t = fold_indirect_ref_rhs (TREE_OPERAND (*from_p, 0));
3245 /* If we are initializing something from a TARGET_EXPR, strip the
3246 TARGET_EXPR and initialize it directly, if possible. This can't
3247 be done if the initializer is void, since that implies that the
3248 temporary is set in some non-trivial way.
3250 ??? What about code that pulls out the temp and uses it
3251 elsewhere? I think that such code never uses the TARGET_EXPR as
3252 an initializer. If I'm wrong, we'll die because the temp won't
3253 have any RTL. In that case, I guess we'll need to replace
3254 references somehow. */
3255 tree init = TARGET_EXPR_INITIAL (*from_p);
3257 if (!VOID_TYPE_P (TREE_TYPE (init)))
3268 /* Remove any COMPOUND_EXPR in the RHS so the following cases will be
3270 gimplify_compound_expr (from_p, pre_p, true);
3275 /* If we're initializing from a CONSTRUCTOR, break this into
3276 individual MODIFY_EXPRs. */
3277 return gimplify_init_constructor (expr_p, pre_p, post_p, want_value);
3280 /* If we're assigning to a non-register type, push the assignment
3281 down into the branches. This is mandatory for ADDRESSABLE types,
3282 since we cannot generate temporaries for such, but it saves a
3283 copy in other cases as well. */
3284 if (!is_gimple_reg_type (TREE_TYPE (*from_p)))
3286 /* This code should mirror the code in gimplify_cond_expr. */
3287 enum tree_code code = TREE_CODE (*expr_p);
3288 tree cond = *from_p;
3289 tree result = *to_p;
3291 ret = gimplify_expr (&result, pre_p, post_p,
3292 is_gimple_min_lval, fb_lvalue);
3293 if (ret != GS_ERROR)
3296 if (TREE_TYPE (TREE_OPERAND (cond, 1)) != void_type_node)
3297 TREE_OPERAND (cond, 1)
3298 = build2 (code, void_type_node, result,
3299 TREE_OPERAND (cond, 1));
3300 if (TREE_TYPE (TREE_OPERAND (cond, 2)) != void_type_node)
3301 TREE_OPERAND (cond, 2)
3302 = build2 (code, void_type_node, unshare_expr (result),
3303 TREE_OPERAND (cond, 2));
3305 TREE_TYPE (cond) = void_type_node;
3306 recalculate_side_effects (cond);
3310 gimplify_and_add (cond, pre_p);
3311 *expr_p = unshare_expr (result);
3322 /* For calls that return in memory, give *to_p as the CALL_EXPR's
3323 return slot so that we don't generate a temporary. */
3324 if (!CALL_EXPR_RETURN_SLOT_OPT (*from_p)
3325 && aggregate_value_p (*from_p, *from_p))
3329 if (!(rhs_predicate_for (*to_p))(*from_p))
3330 /* If we need a temporary, *to_p isn't accurate. */
3332 else if (TREE_CODE (*to_p) == RESULT_DECL
3333 && DECL_NAME (*to_p) == NULL_TREE
3334 && needs_to_live_in_memory (*to_p))
3335 /* It's OK to use the return slot directly unless it's an NRV. */
3337 else if (is_gimple_reg_type (TREE_TYPE (*to_p))
3338 || (DECL_P (*to_p) && DECL_REGISTER (*to_p)))
3339 /* Don't force regs into memory. */
3341 else if (TREE_CODE (*to_p) == VAR_DECL
3342 && DECL_GIMPLE_FORMAL_TEMP_P (*to_p))
3343 /* Don't use the original target if it's a formal temp; we
3344 don't want to take their addresses. */
3346 else if (TREE_CODE (*expr_p) == INIT_EXPR)
3347 /* It's OK to use the target directly if it's being
3350 else if (!is_gimple_non_addressable (*to_p))
3351 /* Don't use the original target if it's already addressable;
3352 if its address escapes, and the called function uses the
3353 NRV optimization, a conforming program could see *to_p
3354 change before the called function returns; see c++/19317.
3355 When optimizing, the return_slot pass marks more functions
3356 as safe after we have escape info. */
3363 CALL_EXPR_RETURN_SLOT_OPT (*from_p) = 1;
3364 lang_hooks.mark_addressable (*to_p);
3379 /* Promote partial stores to COMPLEX variables to total stores. *EXPR_P is
3380 a MODIFY_EXPR with a lhs of a REAL/IMAGPART_EXPR of a variable with
3381 DECL_COMPLEX_GIMPLE_REG_P set. */
3383 static enum gimplify_status
3384 gimplify_modify_expr_complex_part (tree *expr_p, tree *pre_p, bool want_value)
3386 enum tree_code code, ocode;
3387 tree lhs, rhs, new_rhs, other, realpart, imagpart;
3389 lhs = TREE_OPERAND (*expr_p, 0);
3390 rhs = TREE_OPERAND (*expr_p, 1);
3391 code = TREE_CODE (lhs);
3392 lhs = TREE_OPERAND (lhs, 0);
3394 ocode = code == REALPART_EXPR ? IMAGPART_EXPR : REALPART_EXPR;
3395 other = build1 (ocode, TREE_TYPE (rhs), lhs);
3396 other = get_formal_tmp_var (other, pre_p);
3398 realpart = code == REALPART_EXPR ? rhs : other;
3399 imagpart = code == REALPART_EXPR ? other : rhs;
3401 if (TREE_CONSTANT (realpart) && TREE_CONSTANT (imagpart))
3402 new_rhs = build_complex (TREE_TYPE (lhs), realpart, imagpart);
3404 new_rhs = build2 (COMPLEX_EXPR, TREE_TYPE (lhs), realpart, imagpart);
3406 TREE_OPERAND (*expr_p, 0) = lhs;
3407 TREE_OPERAND (*expr_p, 1) = new_rhs;
3411 append_to_statement_list (*expr_p, pre_p);
3418 /* Gimplify the MODIFY_EXPR node pointed to by EXPR_P.
3424 PRE_P points to the list where side effects that must happen before
3425 *EXPR_P should be stored.
3427 POST_P points to the list where side effects that must happen after
3428 *EXPR_P should be stored.
3430 WANT_VALUE is nonzero iff we want to use the value of this expression
3431 in another expression. */
3433 static enum gimplify_status
3434 gimplify_modify_expr (tree *expr_p, tree *pre_p, tree *post_p, bool want_value)
3436 tree *from_p = &TREE_OPERAND (*expr_p, 1);
3437 tree *to_p = &TREE_OPERAND (*expr_p, 0);
3438 enum gimplify_status ret = GS_UNHANDLED;
3440 gcc_assert (TREE_CODE (*expr_p) == MODIFY_EXPR
3441 || TREE_CODE (*expr_p) == INIT_EXPR);
3443 /* For zero sized types only gimplify the left hand side and right hand side
3444 as statements and throw away the assignment. */
3445 if (zero_sized_type (TREE_TYPE (*from_p)))
3447 gimplify_stmt (from_p);
3448 gimplify_stmt (to_p);
3449 append_to_statement_list (*from_p, pre_p);
3450 append_to_statement_list (*to_p, pre_p);
3451 *expr_p = NULL_TREE;
3455 /* See if any simplifications can be done based on what the RHS is. */
3456 ret = gimplify_modify_expr_rhs (expr_p, from_p, to_p, pre_p, post_p,
3458 if (ret != GS_UNHANDLED)
3461 /* If the value being copied is of variable width, compute the length
3462 of the copy into a WITH_SIZE_EXPR. Note that we need to do this
3463 before gimplifying any of the operands so that we can resolve any
3464 PLACEHOLDER_EXPRs in the size. Also note that the RTL expander uses
3465 the size of the expression to be copied, not of the destination, so
3466 that is what we must here. */
3467 maybe_with_size_expr (from_p);
3469 ret = gimplify_expr (to_p, pre_p, post_p, is_gimple_lvalue, fb_lvalue);
3470 if (ret == GS_ERROR)
3473 ret = gimplify_expr (from_p, pre_p, post_p,
3474 rhs_predicate_for (*to_p), fb_rvalue);
3475 if (ret == GS_ERROR)
3478 /* Now see if the above changed *from_p to something we handle specially. */
3479 ret = gimplify_modify_expr_rhs (expr_p, from_p, to_p, pre_p, post_p,
3481 if (ret != GS_UNHANDLED)
3484 /* If we've got a variable sized assignment between two lvalues (i.e. does
3485 not involve a call), then we can make things a bit more straightforward
3486 by converting the assignment to memcpy or memset. */
3487 if (TREE_CODE (*from_p) == WITH_SIZE_EXPR)
3489 tree from = TREE_OPERAND (*from_p, 0);
3490 tree size = TREE_OPERAND (*from_p, 1);
3492 if (TREE_CODE (from) == CONSTRUCTOR)
3493 return gimplify_modify_expr_to_memset (expr_p, size, want_value);
3494 if (is_gimple_addressable (from))
3497 return gimplify_modify_expr_to_memcpy (expr_p, size, want_value);
3501 /* Transform partial stores to non-addressable complex variables into
3502 total stores. This allows us to use real instead of virtual operands
3503 for these variables, which improves optimization. */
3504 if ((TREE_CODE (*to_p) == REALPART_EXPR
3505 || TREE_CODE (*to_p) == IMAGPART_EXPR)
3506 && is_gimple_reg (TREE_OPERAND (*to_p, 0)))
3507 return gimplify_modify_expr_complex_part (expr_p, pre_p, want_value);
3509 if (gimplify_ctxp->into_ssa && is_gimple_reg (*to_p))
3511 /* If we've somehow already got an SSA_NAME on the LHS, then
3512 we're probably modified it twice. Not good. */
3513 gcc_assert (TREE_CODE (*to_p) != SSA_NAME);
3514 *to_p = make_ssa_name (*to_p, *expr_p);
3519 append_to_statement_list (*expr_p, pre_p);
3527 /* Gimplify a comparison between two variable-sized objects. Do this
3528 with a call to BUILT_IN_MEMCMP. */
3530 static enum gimplify_status
3531 gimplify_variable_sized_compare (tree *expr_p)
3533 tree op0 = TREE_OPERAND (*expr_p, 0);
3534 tree op1 = TREE_OPERAND (*expr_p, 1);
3537 t = TYPE_SIZE_UNIT (TREE_TYPE (op0));
3538 t = unshare_expr (t);
3539 t = SUBSTITUTE_PLACEHOLDER_IN_EXPR (t, op0);
3540 args = tree_cons (NULL, t, NULL);
3541 t = build_fold_addr_expr (op1);
3542 args = tree_cons (NULL, t, args);
3543 dest = build_fold_addr_expr (op0);
3544 args = tree_cons (NULL, dest, args);
3545 t = implicit_built_in_decls[BUILT_IN_MEMCMP];
3546 t = build_function_call_expr (t, args);
3548 = build2 (TREE_CODE (*expr_p), TREE_TYPE (*expr_p), t, integer_zero_node);
3553 /* Gimplify TRUTH_ANDIF_EXPR and TRUTH_ORIF_EXPR expressions. EXPR_P
3554 points to the expression to gimplify.
3556 Expressions of the form 'a && b' are gimplified to:
3558 a && b ? true : false
3560 gimplify_cond_expr will do the rest.
3562 PRE_P points to the list where side effects that must happen before
3563 *EXPR_P should be stored. */
3565 static enum gimplify_status
3566 gimplify_boolean_expr (tree *expr_p)
3568 /* Preserve the original type of the expression. */
3569 tree type = TREE_TYPE (*expr_p);
3571 *expr_p = build3 (COND_EXPR, type, *expr_p,
3572 fold_convert (type, boolean_true_node),
3573 fold_convert (type, boolean_false_node));
3578 /* Gimplifies an expression sequence. This function gimplifies each
3579 expression and re-writes the original expression with the last
3580 expression of the sequence in GIMPLE form.
3582 PRE_P points to the list where the side effects for all the
3583 expressions in the sequence will be emitted.
3585 WANT_VALUE is true when the result of the last COMPOUND_EXPR is used. */
3586 /* ??? Should rearrange to share the pre-queue with all the indirect
3587 invocations of gimplify_expr. Would probably save on creations
3588 of statement_list nodes. */
3590 static enum gimplify_status
3591 gimplify_compound_expr (tree *expr_p, tree *pre_p, bool want_value)
3597 tree *sub_p = &TREE_OPERAND (t, 0);
3599 if (TREE_CODE (*sub_p) == COMPOUND_EXPR)
3600 gimplify_compound_expr (sub_p, pre_p, false);
3602 gimplify_stmt (sub_p);
3603 append_to_statement_list (*sub_p, pre_p);
3605 t = TREE_OPERAND (t, 1);
3607 while (TREE_CODE (t) == COMPOUND_EXPR);
3614 gimplify_stmt (expr_p);
3619 /* Gimplifies a statement list. These may be created either by an
3620 enlightened front-end, or by shortcut_cond_expr. */
3622 static enum gimplify_status
3623 gimplify_statement_list (tree *expr_p)
3625 tree_stmt_iterator i = tsi_start (*expr_p);
3627 while (!tsi_end_p (i))
3631 gimplify_stmt (tsi_stmt_ptr (i));
3636 else if (TREE_CODE (t) == STATEMENT_LIST)
3638 tsi_link_before (&i, t, TSI_SAME_STMT);
3648 /* Gimplify a SAVE_EXPR node. EXPR_P points to the expression to
3649 gimplify. After gimplification, EXPR_P will point to a new temporary
3650 that holds the original value of the SAVE_EXPR node.
3652 PRE_P points to the list where side effects that must happen before
3653 *EXPR_P should be stored. */
3655 static enum gimplify_status
3656 gimplify_save_expr (tree *expr_p, tree *pre_p, tree *post_p)
3658 enum gimplify_status ret = GS_ALL_DONE;
3661 gcc_assert (TREE_CODE (*expr_p) == SAVE_EXPR);
3662 val = TREE_OPERAND (*expr_p, 0);
3664 /* If the SAVE_EXPR has not been resolved, then evaluate it once. */
3665 if (!SAVE_EXPR_RESOLVED_P (*expr_p))
3667 /* The operand may be a void-valued expression such as SAVE_EXPRs
3668 generated by the Java frontend for class initialization. It is
3669 being executed only for its side-effects. */
3670 if (TREE_TYPE (val) == void_type_node)
3672 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
3673 is_gimple_stmt, fb_none);
3674 append_to_statement_list (TREE_OPERAND (*expr_p, 0), pre_p);
3678 val = get_initialized_tmp_var (val, pre_p, post_p);
3680 TREE_OPERAND (*expr_p, 0) = val;
3681 SAVE_EXPR_RESOLVED_P (*expr_p) = 1;
3689 /* Re-write the ADDR_EXPR node pointed to by EXPR_P
3696 PRE_P points to the list where side effects that must happen before
3697 *EXPR_P should be stored.
3699 POST_P points to the list where side effects that must happen after
3700 *EXPR_P should be stored. */
3702 static enum gimplify_status
3703 gimplify_addr_expr (tree *expr_p, tree *pre_p, tree *post_p)
3705 tree expr = *expr_p;
3706 tree op0 = TREE_OPERAND (expr, 0);
3707 enum gimplify_status ret;
3709 switch (TREE_CODE (op0))
3712 case MISALIGNED_INDIRECT_REF:
3714 /* Check if we are dealing with an expression of the form '&*ptr'.
3715 While the front end folds away '&*ptr' into 'ptr', these
3716 expressions may be generated internally by the compiler (e.g.,
3717 builtins like __builtin_va_end). */
3718 /* Caution: the silent array decomposition semantics we allow for
3719 ADDR_EXPR means we can't always discard the pair. */
3720 /* Gimplification of the ADDR_EXPR operand may drop
3721 cv-qualification conversions, so make sure we add them if
3724 tree op00 = TREE_OPERAND (op0, 0);
3725 tree t_expr = TREE_TYPE (expr);
3726 tree t_op00 = TREE_TYPE (op00);
3728 if (!lang_hooks.types_compatible_p (t_expr, t_op00))
3730 #ifdef ENABLE_CHECKING
3731 tree t_op0 = TREE_TYPE (op0);
3732 gcc_assert (POINTER_TYPE_P (t_expr)
3733 && cpt_same_type (TREE_CODE (t_op0) == ARRAY_TYPE
3734 ? TREE_TYPE (t_op0) : t_op0,
3736 && POINTER_TYPE_P (t_op00)
3737 && cpt_same_type (t_op0, TREE_TYPE (t_op00)));
3739 op00 = fold_convert (TREE_TYPE (expr), op00);
3746 case VIEW_CONVERT_EXPR:
3747 /* Take the address of our operand and then convert it to the type of
3750 ??? The interactions of VIEW_CONVERT_EXPR and aliasing is not at
3751 all clear. The impact of this transformation is even less clear. */
3753 /* If the operand is a useless conversion, look through it. Doing so
3754 guarantees that the ADDR_EXPR and its operand will remain of the
3756 if (tree_ssa_useless_type_conversion (TREE_OPERAND (op0, 0)))
3757 op0 = TREE_OPERAND (op0, 0);
3759 *expr_p = fold_convert (TREE_TYPE (expr),
3760 build_fold_addr_expr (TREE_OPERAND (op0, 0)));
3765 /* We use fb_either here because the C frontend sometimes takes
3766 the address of a call that returns a struct; see
3767 gcc.dg/c99-array-lval-1.c. The gimplifier will correctly make
3768 the implied temporary explicit. */
3769 ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, post_p,
3770 is_gimple_addressable, fb_either);
3771 if (ret != GS_ERROR)
3773 op0 = TREE_OPERAND (expr, 0);
3775 /* For various reasons, the gimplification of the expression
3776 may have made a new INDIRECT_REF. */
3777 if (TREE_CODE (op0) == INDIRECT_REF)
3778 goto do_indirect_ref;
3780 /* Make sure TREE_INVARIANT, TREE_CONSTANT, and TREE_SIDE_EFFECTS
3782 recompute_tree_invariant_for_addr_expr (expr);
3784 /* Mark the RHS addressable. */
3785 lang_hooks.mark_addressable (TREE_OPERAND (expr, 0));
3793 /* Gimplify the operands of an ASM_EXPR. Input operands should be a gimple
3794 value; output operands should be a gimple lvalue. */
3796 static enum gimplify_status
3797 gimplify_asm_expr (tree *expr_p, tree *pre_p, tree *post_p)
3799 tree expr = *expr_p;
3800 int noutputs = list_length (ASM_OUTPUTS (expr));
3801 const char **oconstraints
3802 = (const char **) alloca ((noutputs) * sizeof (const char *));
3805 const char *constraint;
3806 bool allows_mem, allows_reg, is_inout;
3807 enum gimplify_status ret, tret;
3810 for (i = 0, link = ASM_OUTPUTS (expr); link; ++i, link = TREE_CHAIN (link))
3812 size_t constraint_len;
3813 oconstraints[i] = constraint
3814 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
3815 constraint_len = strlen (constraint);
3816 if (constraint_len == 0)
3819 parse_output_constraint (&constraint, i, 0, 0,
3820 &allows_mem, &allows_reg, &is_inout);
3822 if (!allows_reg && allows_mem)
3823 lang_hooks.mark_addressable (TREE_VALUE (link));
3825 tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
3826 is_inout ? is_gimple_min_lval : is_gimple_lvalue,
3827 fb_lvalue | fb_mayfail);
3828 if (tret == GS_ERROR)
3830 error ("invalid lvalue in asm output %d", i);
3836 /* An input/output operand. To give the optimizers more
3837 flexibility, split it into separate input and output
3842 /* Turn the in/out constraint into an output constraint. */
3843 char *p = xstrdup (constraint);
3845 TREE_VALUE (TREE_PURPOSE (link)) = build_string (constraint_len, p);
3847 /* And add a matching input constraint. */
3850 sprintf (buf, "%d", i);
3852 /* If there are multiple alternatives in the constraint,
3853 handle each of them individually. Those that allow register
3854 will be replaced with operand number, the others will stay
3856 if (strchr (p, ',') != NULL)
3858 size_t len = 0, buflen = strlen (buf);
3859 char *beg, *end, *str, *dst;
3863 end = strchr (beg, ',');
3865 end = strchr (beg, '\0');
3866 if ((size_t) (end - beg) < buflen)
3869 len += end - beg + 1;
3876 str = (char *) alloca (len);
3877 for (beg = p + 1, dst = str;;)
3880 bool mem_p, reg_p, inout_p;
3882 end = strchr (beg, ',');
3887 parse_output_constraint (&tem, i, 0, 0,
3888 &mem_p, ®_p, &inout_p);
3893 memcpy (dst, buf, buflen);
3902 memcpy (dst, beg, len);
3911 input = build_string (dst - str, str);
3914 input = build_string (strlen (buf), buf);
3917 input = build_string (constraint_len - 1, constraint + 1);
3921 input = build_tree_list (build_tree_list (NULL_TREE, input),
3922 unshare_expr (TREE_VALUE (link)));
3923 ASM_INPUTS (expr) = chainon (ASM_INPUTS (expr), input);
3927 for (link = ASM_INPUTS (expr); link; ++i, link = TREE_CHAIN (link))
3930 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
3931 parse_input_constraint (&constraint, 0, 0, noutputs, 0,
3932 oconstraints, &allows_mem, &allows_reg);
3934 /* If the operand is a memory input, it should be an lvalue. */
3935 if (!allows_reg && allows_mem)
3937 lang_hooks.mark_addressable (TREE_VALUE (link));
3938 tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
3939 is_gimple_lvalue, fb_lvalue | fb_mayfail);
3940 if (tret == GS_ERROR)
3942 error ("memory input %d is not directly addressable", i);
3948 tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
3949 is_gimple_asm_val, fb_rvalue);
3950 if (tret == GS_ERROR)
3958 /* Gimplify a CLEANUP_POINT_EXPR. Currently this works by adding
3959 WITH_CLEANUP_EXPRs to the prequeue as we encounter cleanups while
3960 gimplifying the body, and converting them to TRY_FINALLY_EXPRs when we
3961 return to this function.
3963 FIXME should we complexify the prequeue handling instead? Or use flags
3964 for all the cleanups and let the optimizer tighten them up? The current
3965 code seems pretty fragile; it will break on a cleanup within any
3966 non-conditional nesting. But any such nesting would be broken, anyway;
3967 we can't write a TRY_FINALLY_EXPR that starts inside a nesting construct
3968 and continues out of it. We can do that at the RTL level, though, so
3969 having an optimizer to tighten up try/finally regions would be a Good
3972 static enum gimplify_status
3973 gimplify_cleanup_point_expr (tree *expr_p, tree *pre_p)
3975 tree_stmt_iterator iter;
3978 tree temp = voidify_wrapper_expr (*expr_p, NULL);
3980 /* We only care about the number of conditions between the innermost
3981 CLEANUP_POINT_EXPR and the cleanup. So save and reset the count and
3982 any cleanups collected outside the CLEANUP_POINT_EXPR. */
3983 int old_conds = gimplify_ctxp->conditions;
3984 tree old_cleanups = gimplify_ctxp->conditional_cleanups;
3985 gimplify_ctxp->conditions = 0;
3986 gimplify_ctxp->conditional_cleanups = NULL_TREE;
3988 body = TREE_OPERAND (*expr_p, 0);
3989 gimplify_to_stmt_list (&body);
3991 gimplify_ctxp->conditions = old_conds;
3992 gimplify_ctxp->conditional_cleanups = old_cleanups;
3994 for (iter = tsi_start (body); !tsi_end_p (iter); )
3996 tree *wce_p = tsi_stmt_ptr (iter);
3999 if (TREE_CODE (wce) == WITH_CLEANUP_EXPR)
4001 if (tsi_one_before_end_p (iter))
4003 tsi_link_before (&iter, TREE_OPERAND (wce, 0), TSI_SAME_STMT);
4010 enum tree_code code;
4012 if (CLEANUP_EH_ONLY (wce))
4013 code = TRY_CATCH_EXPR;
4015 code = TRY_FINALLY_EXPR;
4017 sl = tsi_split_statement_list_after (&iter);
4018 tfe = build2 (code, void_type_node, sl, NULL_TREE);
4019 append_to_statement_list (TREE_OPERAND (wce, 0),
4020 &TREE_OPERAND (tfe, 1));
4022 iter = tsi_start (sl);
4032 append_to_statement_list (body, pre_p);
4042 /* Insert a cleanup marker for gimplify_cleanup_point_expr. CLEANUP
4043 is the cleanup action required. */
4046 gimple_push_cleanup (tree var, tree cleanup, bool eh_only, tree *pre_p)
4050 /* Errors can result in improperly nested cleanups. Which results in
4051 confusion when trying to resolve the WITH_CLEANUP_EXPR. */
4052 if (errorcount || sorrycount)
4055 if (gimple_conditional_context ())
4057 /* If we're in a conditional context, this is more complex. We only
4058 want to run the cleanup if we actually ran the initialization that
4059 necessitates it, but we want to run it after the end of the
4060 conditional context. So we wrap the try/finally around the
4061 condition and use a flag to determine whether or not to actually
4062 run the destructor. Thus
4066 becomes (approximately)
4070 if (test) { A::A(temp); flag = 1; val = f(temp); }
4073 if (flag) A::~A(temp);
4078 tree flag = create_tmp_var (boolean_type_node, "cleanup");
4079 tree ffalse = build2 (MODIFY_EXPR, void_type_node, flag,
4080 boolean_false_node);
4081 tree ftrue = build2 (MODIFY_EXPR, void_type_node, flag,
4083 cleanup = build3 (COND_EXPR, void_type_node, flag, cleanup, NULL);
4084 wce = build1 (WITH_CLEANUP_EXPR, void_type_node, cleanup);
4085 append_to_statement_list (ffalse, &gimplify_ctxp->conditional_cleanups);
4086 append_to_statement_list (wce, &gimplify_ctxp->conditional_cleanups);
4087 append_to_statement_list (ftrue, pre_p);
4089 /* Because of this manipulation, and the EH edges that jump
4090 threading cannot redirect, the temporary (VAR) will appear
4091 to be used uninitialized. Don't warn. */
4092 TREE_NO_WARNING (var) = 1;
4096 wce = build1 (WITH_CLEANUP_EXPR, void_type_node, cleanup);
4097 CLEANUP_EH_ONLY (wce) = eh_only;
4098 append_to_statement_list (wce, pre_p);
4101 gimplify_stmt (&TREE_OPERAND (wce, 0));
4104 /* Gimplify a TARGET_EXPR which doesn't appear on the rhs of an INIT_EXPR. */
4106 static enum gimplify_status
4107 gimplify_target_expr (tree *expr_p, tree *pre_p, tree *post_p)
4109 tree targ = *expr_p;
4110 tree temp = TARGET_EXPR_SLOT (targ);
4111 tree init = TARGET_EXPR_INITIAL (targ);
4112 enum gimplify_status ret;
4116 /* TARGET_EXPR temps aren't part of the enclosing block, so add it
4117 to the temps list. */
4118 gimple_add_tmp_var (temp);
4120 /* If TARGET_EXPR_INITIAL is void, then the mere evaluation of the
4121 expression is supposed to initialize the slot. */
4122 if (VOID_TYPE_P (TREE_TYPE (init)))
4123 ret = gimplify_expr (&init, pre_p, post_p, is_gimple_stmt, fb_none);
4126 /* Special handling for BIND_EXPR can result in fewer temps. */
4128 if (TREE_CODE (init) == BIND_EXPR)
4129 gimplify_bind_expr (&init, temp, pre_p);
4132 init = build2 (INIT_EXPR, void_type_node, temp, init);
4133 ret = gimplify_expr (&init, pre_p, post_p, is_gimple_stmt,
4137 if (ret == GS_ERROR)
4139 append_to_statement_list (init, pre_p);
4141 /* If needed, push the cleanup for the temp. */
4142 if (TARGET_EXPR_CLEANUP (targ))
4144 gimplify_stmt (&TARGET_EXPR_CLEANUP (targ));
4145 gimple_push_cleanup (temp, TARGET_EXPR_CLEANUP (targ),
4146 CLEANUP_EH_ONLY (targ), pre_p);
4149 /* Only expand this once. */
4150 TREE_OPERAND (targ, 3) = init;
4151 TARGET_EXPR_INITIAL (targ) = NULL_TREE;
4154 /* We should have expanded this before. */
4155 gcc_assert (DECL_SEEN_IN_BIND_EXPR_P (temp));
4161 /* Gimplification of expression trees. */
4163 /* Gimplify an expression which appears at statement context; usually, this
4164 means replacing it with a suitably gimple STATEMENT_LIST. */
4167 gimplify_stmt (tree *stmt_p)
4169 gimplify_expr (stmt_p, NULL, NULL, is_gimple_stmt, fb_none);
4172 /* Similarly, but force the result to be a STATEMENT_LIST. */
4175 gimplify_to_stmt_list (tree *stmt_p)
4177 gimplify_stmt (stmt_p);
4179 *stmt_p = alloc_stmt_list ();
4180 else if (TREE_CODE (*stmt_p) != STATEMENT_LIST)
4183 *stmt_p = alloc_stmt_list ();
4184 append_to_statement_list (t, stmt_p);
4189 /* Add FIRSTPRIVATE entries for DECL in the OpenMP the surrounding parallels
4190 to CTX. If entries already exist, force them to be some flavor of private.
4191 If there is no enclosing parallel, do nothing. */
4194 omp_firstprivatize_variable (struct gimplify_omp_ctx *ctx, tree decl)
4198 if (decl == NULL || !DECL_P (decl))
4203 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
4206 if (n->value & GOVD_SHARED)
4207 n->value = GOVD_FIRSTPRIVATE | (n->value & GOVD_SEEN);
4211 else if (ctx->is_parallel)
4212 omp_add_variable (ctx, decl, GOVD_FIRSTPRIVATE);
4214 ctx = ctx->outer_context;
4219 /* Similarly for each of the type sizes of TYPE. */
4222 omp_firstprivatize_type_sizes (struct gimplify_omp_ctx *ctx, tree type)
4224 if (type == NULL || type == error_mark_node)
4226 type = TYPE_MAIN_VARIANT (type);
4228 if (pointer_set_insert (ctx->privatized_types, type))
4231 switch (TREE_CODE (type))
4237 omp_firstprivatize_variable (ctx, TYPE_MIN_VALUE (type));
4238 omp_firstprivatize_variable (ctx, TYPE_MAX_VALUE (type));
4242 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (type));
4243 omp_firstprivatize_type_sizes (ctx, TYPE_DOMAIN (type));
4248 case QUAL_UNION_TYPE:
4251 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
4252 if (TREE_CODE (field) == FIELD_DECL)
4254 omp_firstprivatize_variable (ctx, DECL_FIELD_OFFSET (field));
4255 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (field));
4261 case REFERENCE_TYPE:
4262 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (type));
4269 omp_firstprivatize_variable (ctx, TYPE_SIZE (type));
4270 omp_firstprivatize_variable (ctx, TYPE_SIZE_UNIT (type));
4271 lang_hooks.types.omp_firstprivatize_type_sizes (ctx, type);
4274 /* Add an entry for DECL in the OpenMP context CTX with FLAGS. */
4277 omp_add_variable (struct gimplify_omp_ctx *ctx, tree decl, unsigned int flags)
4280 unsigned int nflags;
4283 if (decl == error_mark_node || TREE_TYPE (decl) == error_mark_node)
4286 /* Never elide decls whose type has TREE_ADDRESSABLE set. This means
4287 there are constructors involved somewhere. */
4288 if (TREE_ADDRESSABLE (TREE_TYPE (decl))
4289 || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
4292 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
4295 /* We shouldn't be re-adding the decl with the same data
4297 gcc_assert ((n->value & GOVD_DATA_SHARE_CLASS & flags) == 0);
4298 /* The only combination of data sharing classes we should see is
4299 FIRSTPRIVATE and LASTPRIVATE. */
4300 nflags = n->value | flags;
4301 gcc_assert ((nflags & GOVD_DATA_SHARE_CLASS)
4302 == (GOVD_FIRSTPRIVATE | GOVD_LASTPRIVATE));
4307 /* When adding a variable-sized variable, we have to handle all sorts
4308 of additional bits of data: the pointer replacement variable, and
4309 the parameters of the type. */
4310 if (DECL_SIZE (decl) && !TREE_CONSTANT (DECL_SIZE (decl)))
4312 /* Add the pointer replacement variable as PRIVATE if the variable
4313 replacement is private, else FIRSTPRIVATE since we'll need the
4314 address of the original variable either for SHARED, or for the
4315 copy into or out of the context. */
4316 if (!(flags & GOVD_LOCAL))
4318 nflags = flags & GOVD_PRIVATE ? GOVD_PRIVATE : GOVD_FIRSTPRIVATE;
4319 nflags |= flags & GOVD_SEEN;
4320 t = DECL_VALUE_EXPR (decl);
4321 gcc_assert (TREE_CODE (t) == INDIRECT_REF);
4322 t = TREE_OPERAND (t, 0);
4323 gcc_assert (DECL_P (t));
4324 omp_add_variable (ctx, t, nflags);
4327 /* Add all of the variable and type parameters (which should have
4328 been gimplified to a formal temporary) as FIRSTPRIVATE. */
4329 omp_firstprivatize_variable (ctx, DECL_SIZE_UNIT (decl));
4330 omp_firstprivatize_variable (ctx, DECL_SIZE (decl));
4331 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (decl));
4333 /* The variable-sized variable itself is never SHARED, only some form
4334 of PRIVATE. The sharing would take place via the pointer variable
4335 which we remapped above. */
4336 if (flags & GOVD_SHARED)
4337 flags = GOVD_PRIVATE | GOVD_DEBUG_PRIVATE
4338 | (flags & (GOVD_SEEN | GOVD_EXPLICIT));
4340 /* We're going to make use of the TYPE_SIZE_UNIT at least in the
4341 alloca statement we generate for the variable, so make sure it
4342 is available. This isn't automatically needed for the SHARED
4343 case, since we won't be allocating local storage then. */
4345 omp_notice_variable (ctx, TYPE_SIZE_UNIT (TREE_TYPE (decl)), true);
4347 else if (lang_hooks.decls.omp_privatize_by_reference (decl))
4349 gcc_assert ((flags & GOVD_LOCAL) == 0);
4350 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (decl));
4352 /* Similar to the direct variable sized case above, we'll need the
4353 size of references being privatized. */
4354 if ((flags & GOVD_SHARED) == 0)
4356 t = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl)));
4357 if (!TREE_CONSTANT (t))
4358 omp_notice_variable (ctx, t, true);
4362 splay_tree_insert (ctx->variables, (splay_tree_key)decl, flags);
4365 /* Record the fact that DECL was used within the OpenMP context CTX.
4366 IN_CODE is true when real code uses DECL, and false when we should
4367 merely emit default(none) errors. Return true if DECL is going to
4368 be remapped and thus DECL shouldn't be gimplified into its
4369 DECL_VALUE_EXPR (if any). */
4372 omp_notice_variable (struct gimplify_omp_ctx *ctx, tree decl, bool in_code)
4375 unsigned flags = in_code ? GOVD_SEEN : 0;
4376 bool ret = false, shared;
4378 if (decl == error_mark_node || TREE_TYPE (decl) == error_mark_node)
4381 /* Threadprivate variables are predetermined. */
4382 if (is_global_var (decl))
4384 if (DECL_THREAD_LOCAL_P (decl))
4387 if (DECL_HAS_VALUE_EXPR_P (decl))
4389 tree value = get_base_address (DECL_VALUE_EXPR (decl));
4391 if (value && DECL_P (value) && DECL_THREAD_LOCAL_P (value))
4396 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
4399 enum omp_clause_default_kind default_kind, kind;
4401 if (!ctx->is_parallel)
4404 /* ??? Some compiler-generated variables (like SAVE_EXPRs) could be
4405 remapped firstprivate instead of shared. To some extent this is
4406 addressed in omp_firstprivatize_type_sizes, but not effectively. */
4407 default_kind = ctx->default_kind;
4408 kind = lang_hooks.decls.omp_predetermined_sharing (decl);
4409 if (kind != OMP_CLAUSE_DEFAULT_UNSPECIFIED)
4410 default_kind = kind;
4412 switch (default_kind)
4414 case OMP_CLAUSE_DEFAULT_NONE:
4415 error ("%qs not specified in enclosing parallel",
4416 IDENTIFIER_POINTER (DECL_NAME (decl)));
4417 error ("%Henclosing parallel", &ctx->location);
4419 case OMP_CLAUSE_DEFAULT_SHARED:
4420 flags |= GOVD_SHARED;
4422 case OMP_CLAUSE_DEFAULT_PRIVATE:
4423 flags |= GOVD_PRIVATE;
4429 omp_add_variable (ctx, decl, flags);
4431 shared = (flags & GOVD_SHARED) != 0;
4432 ret = lang_hooks.decls.omp_disregard_value_expr (decl, shared);
4436 shared = ((flags | n->value) & GOVD_SHARED) != 0;
4437 ret = lang_hooks.decls.omp_disregard_value_expr (decl, shared);
4439 /* If nothing changed, there's nothing left to do. */
4440 if ((n->value & flags) == flags)
4446 /* If the variable is private in the current context, then we don't
4447 need to propagate anything to an outer context. */
4448 if (flags & GOVD_PRIVATE)
4450 if (ctx->outer_context
4451 && omp_notice_variable (ctx->outer_context, decl, in_code))
4456 /* Verify that DECL is private within CTX. If there's specific information
4457 to the contrary in the innermost scope, generate an error. */
4460 omp_is_private (struct gimplify_omp_ctx *ctx, tree decl)
4464 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
4467 if (n->value & GOVD_SHARED)
4469 if (ctx == gimplify_omp_ctxp)
4471 error ("iteration variable %qs should be private",
4472 IDENTIFIER_POINTER (DECL_NAME (decl)));
4473 n->value = GOVD_PRIVATE;
4479 else if ((n->value & GOVD_EXPLICIT) != 0
4480 && (ctx == gimplify_omp_ctxp
4481 || (ctx->is_combined_parallel
4482 && gimplify_omp_ctxp->outer_context == ctx)))
4484 if ((n->value & GOVD_FIRSTPRIVATE) != 0)
4485 error ("iteration variable %qs should not be firstprivate",
4486 IDENTIFIER_POINTER (DECL_NAME (decl)));
4487 else if ((n->value & GOVD_REDUCTION) != 0)
4488 error ("iteration variable %qs should not be reduction",
4489 IDENTIFIER_POINTER (DECL_NAME (decl)));
4494 if (ctx->is_parallel)
4496 else if (ctx->outer_context)
4497 return omp_is_private (ctx->outer_context, decl);
4499 return !is_global_var (decl);
4502 /* Scan the OpenMP clauses in *LIST_P, installing mappings into a new
4503 and previous omp contexts. */
4506 gimplify_scan_omp_clauses (tree *list_p, tree *pre_p, bool in_parallel,
4507 bool in_combined_parallel)
4509 struct gimplify_omp_ctx *ctx, *outer_ctx;
4512 ctx = new_omp_context (in_parallel, in_combined_parallel);
4513 outer_ctx = ctx->outer_context;
4515 while ((c = *list_p) != NULL)
4517 enum gimplify_status gs;
4518 bool remove = false;
4519 bool notice_outer = true;
4523 switch (OMP_CLAUSE_CODE (c))
4525 case OMP_CLAUSE_PRIVATE:
4526 flags = GOVD_PRIVATE | GOVD_EXPLICIT;
4527 notice_outer = false;
4529 case OMP_CLAUSE_SHARED:
4530 flags = GOVD_SHARED | GOVD_EXPLICIT;
4532 case OMP_CLAUSE_FIRSTPRIVATE:
4533 flags = GOVD_FIRSTPRIVATE | GOVD_EXPLICIT;
4535 case OMP_CLAUSE_LASTPRIVATE:
4536 flags = GOVD_LASTPRIVATE | GOVD_SEEN | GOVD_EXPLICIT;
4538 case OMP_CLAUSE_REDUCTION:
4539 flags = GOVD_REDUCTION | GOVD_SEEN | GOVD_EXPLICIT;
4543 decl = OMP_CLAUSE_DECL (c);
4544 if (decl == error_mark_node || TREE_TYPE (decl) == error_mark_node)
4549 /* Handle NRV results passed by reference. */
4550 if (TREE_CODE (decl) == INDIRECT_REF
4551 && TREE_CODE (TREE_OPERAND (decl, 0)) == RESULT_DECL
4552 && DECL_BY_REFERENCE (TREE_OPERAND (decl, 0)))
4553 OMP_CLAUSE_DECL (c) = decl = TREE_OPERAND (decl, 0);
4554 omp_add_variable (ctx, decl, flags);
4555 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION
4556 && OMP_CLAUSE_REDUCTION_PLACEHOLDER (c))
4558 omp_add_variable (ctx, OMP_CLAUSE_REDUCTION_PLACEHOLDER (c),
4559 GOVD_LOCAL | GOVD_SEEN);
4560 gimplify_omp_ctxp = ctx;
4561 push_gimplify_context ();
4562 gimplify_stmt (&OMP_CLAUSE_REDUCTION_INIT (c));
4563 pop_gimplify_context (OMP_CLAUSE_REDUCTION_INIT (c));
4564 push_gimplify_context ();
4565 gimplify_stmt (&OMP_CLAUSE_REDUCTION_MERGE (c));
4566 pop_gimplify_context (OMP_CLAUSE_REDUCTION_MERGE (c));
4567 gimplify_omp_ctxp = outer_ctx;
4573 case OMP_CLAUSE_COPYIN:
4574 case OMP_CLAUSE_COPYPRIVATE:
4575 decl = OMP_CLAUSE_DECL (c);
4576 if (decl == error_mark_node || TREE_TYPE (decl) == error_mark_node)
4581 /* Handle NRV results passed by reference. */
4582 if (TREE_CODE (decl) == INDIRECT_REF
4583 && TREE_CODE (TREE_OPERAND (decl, 0)) == RESULT_DECL
4584 && DECL_BY_REFERENCE (TREE_OPERAND (decl, 0)))
4585 OMP_CLAUSE_DECL (c) = decl = TREE_OPERAND (decl, 0);
4588 omp_notice_variable (outer_ctx, decl, true);
4592 OMP_CLAUSE_OPERAND (c, 0)
4593 = gimple_boolify (OMP_CLAUSE_OPERAND (c, 0));
4596 case OMP_CLAUSE_SCHEDULE:
4597 case OMP_CLAUSE_NUM_THREADS:
4598 gs = gimplify_expr (&OMP_CLAUSE_OPERAND (c, 0), pre_p, NULL,
4599 is_gimple_val, fb_rvalue);
4604 case OMP_CLAUSE_NOWAIT:
4605 case OMP_CLAUSE_ORDERED:
4608 case OMP_CLAUSE_DEFAULT:
4609 ctx->default_kind = OMP_CLAUSE_DEFAULT_KIND (c);
4617 *list_p = OMP_CLAUSE_CHAIN (c);
4619 list_p = &OMP_CLAUSE_CHAIN (c);
4622 gimplify_omp_ctxp = ctx;
4625 /* For all variables that were not actually used within the context,
4626 remove PRIVATE, SHARED, and FIRSTPRIVATE clauses. */
4629 gimplify_adjust_omp_clauses_1 (splay_tree_node n, void *data)
4631 tree *list_p = (tree *) data;
4632 tree decl = (tree) n->key;
4633 unsigned flags = n->value;
4634 enum omp_clause_code code;
4638 if (flags & (GOVD_EXPLICIT | GOVD_LOCAL))
4640 if ((flags & GOVD_SEEN) == 0)
4642 if (flags & GOVD_DEBUG_PRIVATE)
4644 gcc_assert ((flags & GOVD_DATA_SHARE_CLASS) == GOVD_PRIVATE);
4645 private_debug = true;
4649 = lang_hooks.decls.omp_private_debug_clause (decl,
4650 !!(flags & GOVD_SHARED));
4652 code = OMP_CLAUSE_PRIVATE;
4653 else if (flags & GOVD_SHARED)
4655 if (is_global_var (decl))
4657 code = OMP_CLAUSE_SHARED;
4659 else if (flags & GOVD_PRIVATE)
4660 code = OMP_CLAUSE_PRIVATE;
4661 else if (flags & GOVD_FIRSTPRIVATE)
4662 code = OMP_CLAUSE_FIRSTPRIVATE;
4666 clause = build_omp_clause (code);
4667 OMP_CLAUSE_DECL (clause) = decl;
4668 OMP_CLAUSE_CHAIN (clause) = *list_p;
4670 OMP_CLAUSE_PRIVATE_DEBUG (clause) = 1;
4677 gimplify_adjust_omp_clauses (tree *list_p)
4679 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
4682 while ((c = *list_p) != NULL)
4685 bool remove = false;
4687 switch (OMP_CLAUSE_CODE (c))
4689 case OMP_CLAUSE_PRIVATE:
4690 case OMP_CLAUSE_SHARED:
4691 case OMP_CLAUSE_FIRSTPRIVATE:
4692 decl = OMP_CLAUSE_DECL (c);
4693 n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
4694 remove = !(n->value & GOVD_SEEN);
4697 bool shared = OMP_CLAUSE_CODE (c) == OMP_CLAUSE_SHARED;
4698 if ((n->value & GOVD_DEBUG_PRIVATE)
4699 || lang_hooks.decls.omp_private_debug_clause (decl, shared))
4701 gcc_assert ((n->value & GOVD_DEBUG_PRIVATE) == 0
4702 || ((n->value & GOVD_DATA_SHARE_CLASS)
4704 OMP_CLAUSE_SET_CODE (c, OMP_CLAUSE_PRIVATE);
4705 OMP_CLAUSE_PRIVATE_DEBUG (c) = 1;
4710 case OMP_CLAUSE_LASTPRIVATE:
4711 /* Make sure OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE is set to
4712 accurately reflect the presence of a FIRSTPRIVATE clause. */
4713 decl = OMP_CLAUSE_DECL (c);
4714 n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
4715 OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c)
4716 = (n->value & GOVD_FIRSTPRIVATE) != 0;
4719 case OMP_CLAUSE_REDUCTION:
4720 case OMP_CLAUSE_COPYIN:
4721 case OMP_CLAUSE_COPYPRIVATE:
4723 case OMP_CLAUSE_NUM_THREADS:
4724 case OMP_CLAUSE_SCHEDULE:
4725 case OMP_CLAUSE_NOWAIT:
4726 case OMP_CLAUSE_ORDERED:
4727 case OMP_CLAUSE_DEFAULT:
4735 *list_p = OMP_CLAUSE_CHAIN (c);
4737 list_p = &OMP_CLAUSE_CHAIN (c);
4740 /* Add in any implicit data sharing. */
4741 splay_tree_foreach (ctx->variables, gimplify_adjust_omp_clauses_1, list_p);
4743 gimplify_omp_ctxp = ctx->outer_context;
4744 delete_omp_context (ctx);
4747 /* Gimplify the contents of an OMP_PARALLEL statement. This involves
4748 gimplification of the body, as well as scanning the body for used
4749 variables. We need to do this scan now, because variable-sized
4750 decls will be decomposed during gimplification. */
4752 static enum gimplify_status
4753 gimplify_omp_parallel (tree *expr_p, tree *pre_p)
4755 tree expr = *expr_p;
4757 gimplify_scan_omp_clauses (&OMP_PARALLEL_CLAUSES (expr), pre_p, true,
4758 OMP_PARALLEL_COMBINED (expr));
4760 push_gimplify_context ();
4762 gimplify_stmt (&OMP_PARALLEL_BODY (expr));
4764 if (TREE_CODE (OMP_PARALLEL_BODY (expr)) == BIND_EXPR)
4765 pop_gimplify_context (OMP_PARALLEL_BODY (expr));
4767 pop_gimplify_context (NULL_TREE);
4769 gimplify_adjust_omp_clauses (&OMP_PARALLEL_CLAUSES (expr));
4774 /* Gimplify the gross structure of an OMP_FOR statement. */
4776 static enum gimplify_status
4777 gimplify_omp_for (tree *expr_p, tree *pre_p)
4779 tree for_stmt, decl, t;
4780 enum gimplify_status ret = 0;
4784 gimplify_scan_omp_clauses (&OMP_FOR_CLAUSES (for_stmt), pre_p, false, false);
4786 t = OMP_FOR_INIT (for_stmt);
4787 gcc_assert (TREE_CODE (t) == MODIFY_EXPR);
4788 decl = TREE_OPERAND (t, 0);
4789 gcc_assert (DECL_P (decl));
4790 gcc_assert (INTEGRAL_TYPE_P (TREE_TYPE (decl)));
4792 /* Make sure the iteration variable is private. */
4793 if (omp_is_private (gimplify_omp_ctxp, decl))
4794 omp_notice_variable (gimplify_omp_ctxp, decl, true);
4796 omp_add_variable (gimplify_omp_ctxp, decl, GOVD_PRIVATE | GOVD_SEEN);
4798 ret |= gimplify_expr (&TREE_OPERAND (t, 1), &OMP_FOR_PRE_BODY (for_stmt),
4799 NULL, is_gimple_val, fb_rvalue);
4801 t = OMP_FOR_COND (for_stmt);
4802 gcc_assert (COMPARISON_CLASS_P (t));
4803 gcc_assert (TREE_OPERAND (t, 0) == decl);
4805 ret |= gimplify_expr (&TREE_OPERAND (t, 1), &OMP_FOR_PRE_BODY (for_stmt),
4806 NULL, is_gimple_val, fb_rvalue);
4808 t = OMP_FOR_INCR (for_stmt);
4809 switch (TREE_CODE (t))
4811 case PREINCREMENT_EXPR:
4812 case POSTINCREMENT_EXPR:
4813 t = build_int_cst (TREE_TYPE (decl), 1);
4815 case PREDECREMENT_EXPR:
4816 case POSTDECREMENT_EXPR:
4817 t = build_int_cst (TREE_TYPE (decl), -1);
4820 t = build2 (PLUS_EXPR, TREE_TYPE (decl), decl, t);
4821 t = build2 (MODIFY_EXPR, void_type_node, decl, t);
4822 OMP_FOR_INCR (for_stmt) = t;
4826 gcc_assert (TREE_OPERAND (t, 0) == decl);
4827 t = TREE_OPERAND (t, 1);
4828 switch (TREE_CODE (t))
4831 if (TREE_OPERAND (t, 1) == decl)
4833 TREE_OPERAND (t, 1) = TREE_OPERAND (t, 0);
4834 TREE_OPERAND (t, 0) = decl;
4838 gcc_assert (TREE_OPERAND (t, 0) == decl);
4844 ret |= gimplify_expr (&TREE_OPERAND (t, 1), &OMP_FOR_PRE_BODY (for_stmt),
4845 NULL, is_gimple_val, fb_rvalue);
4852 gimplify_to_stmt_list (&OMP_FOR_BODY (for_stmt));
4853 gimplify_adjust_omp_clauses (&OMP_FOR_CLAUSES (for_stmt));
4855 return ret == GS_ALL_DONE ? GS_ALL_DONE : GS_ERROR;
4858 /* Gimplify the gross structure of other OpenMP worksharing constructs.
4859 In particular, OMP_SECTIONS and OMP_SINGLE. */
4861 static enum gimplify_status
4862 gimplify_omp_workshare (tree *expr_p, tree *pre_p)
4864 tree stmt = *expr_p;
4866 gimplify_scan_omp_clauses (&OMP_CLAUSES (stmt), pre_p, false, false);
4867 gimplify_to_stmt_list (&OMP_BODY (stmt));
4868 gimplify_adjust_omp_clauses (&OMP_CLAUSES (stmt));
4873 /* A subroutine of gimplify_omp_atomic. The front end is supposed to have
4874 stabilized the lhs of the atomic operation as *ADDR. Return true if
4875 EXPR is this stabilized form. */
4878 goa_lhs_expr_p (tree expr, tree addr)
4880 /* Also include casts to other type variants. The C front end is fond
4881 of adding these for e.g. volatile variables. This is like
4882 STRIP_TYPE_NOPS but includes the main variant lookup. */
4883 while ((TREE_CODE (expr) == NOP_EXPR
4884 || TREE_CODE (expr) == CONVERT_EXPR
4885 || TREE_CODE (expr) == NON_LVALUE_EXPR)
4886 && TREE_OPERAND (expr, 0) != error_mark_node
4887 && (TYPE_MAIN_VARIANT (TREE_TYPE (expr))
4888 == TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (expr, 0)))))
4889 expr = TREE_OPERAND (expr, 0);
4891 if (TREE_CODE (expr) == INDIRECT_REF && TREE_OPERAND (expr, 0) == addr)
4893 if (TREE_CODE (addr) == ADDR_EXPR && expr == TREE_OPERAND (addr, 0))
4898 /* A subroutine of gimplify_omp_atomic. Attempt to implement the atomic
4899 operation as a __sync_fetch_and_op builtin. INDEX is log2 of the
4900 size of the data type, and thus usable to find the index of the builtin
4901 decl. Returns GS_UNHANDLED if the expression is not of the proper form. */
4903 static enum gimplify_status
4904 gimplify_omp_atomic_fetch_op (tree *expr_p, tree addr, tree rhs, int index)
4906 enum built_in_function base;
4907 tree decl, args, itype;
4908 enum insn_code *optab;
4910 /* Check for one of the supported fetch-op operations. */
4911 switch (TREE_CODE (rhs))
4914 base = BUILT_IN_FETCH_AND_ADD_N;
4915 optab = sync_add_optab;
4918 base = BUILT_IN_FETCH_AND_SUB_N;
4919 optab = sync_add_optab;
4922 base = BUILT_IN_FETCH_AND_AND_N;
4923 optab = sync_and_optab;
4926 base = BUILT_IN_FETCH_AND_OR_N;
4927 optab = sync_ior_optab;
4930 base = BUILT_IN_FETCH_AND_XOR_N;
4931 optab = sync_xor_optab;
4934 return GS_UNHANDLED;
4937 /* Make sure the expression is of the proper form. */
4938 if (goa_lhs_expr_p (TREE_OPERAND (rhs, 0), addr))
4939 rhs = TREE_OPERAND (rhs, 1);
4940 else if (commutative_tree_code (TREE_CODE (rhs))
4941 && goa_lhs_expr_p (TREE_OPERAND (rhs, 1), addr))
4942 rhs = TREE_OPERAND (rhs, 0);
4944 return GS_UNHANDLED;
4946 decl = built_in_decls[base + index + 1];
4947 itype = TREE_TYPE (TREE_TYPE (decl));
4949 if (optab[TYPE_MODE (itype)] == CODE_FOR_nothing)
4950 return GS_UNHANDLED;
4952 args = tree_cons (NULL, fold_convert (itype, rhs), NULL);
4953 args = tree_cons (NULL, addr, args);
4954 *expr_p = build_function_call_expr (decl, args);
4958 /* A subroutine of gimplify_omp_atomic_pipeline. Walk *EXPR_P and replace
4959 appearances of *LHS_ADDR with LHS_VAR. If an expression does not involve
4960 the lhs, evaluate it into a temporary. Return 1 if the lhs appeared as
4961 a subexpression, 0 if it did not, or -1 if an error was encountered. */
4964 goa_stabilize_expr (tree *expr_p, tree *pre_p, tree lhs_addr, tree lhs_var)
4966 tree expr = *expr_p;
4969 if (goa_lhs_expr_p (expr, lhs_addr))
4974 if (is_gimple_val (expr))
4978 switch (TREE_CODE_CLASS (TREE_CODE (expr)))
4981 saw_lhs |= goa_stabilize_expr (&TREE_OPERAND (expr, 1), pre_p,
4984 saw_lhs |= goa_stabilize_expr (&TREE_OPERAND (expr, 0), pre_p,
4993 enum gimplify_status gs;
4994 gs = gimplify_expr (expr_p, pre_p, NULL, is_gimple_val, fb_rvalue);
4995 if (gs != GS_ALL_DONE)
5002 /* A subroutine of gimplify_omp_atomic. Implement the atomic operation as:
5006 newval = rhs; // with oldval replacing *addr in rhs
5007 oldval = __sync_val_compare_and_swap (addr, oldval, newval);
5008 if (oldval != newval)
5011 INDEX is log2 of the size of the data type, and thus usable to find the
5012 index of the builtin decl. */
5014 static enum gimplify_status
5015 gimplify_omp_atomic_pipeline (tree *expr_p, tree *pre_p, tree addr,
5016 tree rhs, int index)
5018 tree oldval, oldival, oldival2, newval, newival, label;
5019 tree type, itype, cmpxchg, args, x, iaddr;
5021 cmpxchg = built_in_decls[BUILT_IN_VAL_COMPARE_AND_SWAP_N + index + 1];
5022 type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (addr)));
5023 itype = TREE_TYPE (TREE_TYPE (cmpxchg));
5025 if (sync_compare_and_swap[TYPE_MODE (itype)] == CODE_FOR_nothing)
5026 return GS_UNHANDLED;
5028 oldval = create_tmp_var (type, NULL);
5029 newval = create_tmp_var (type, NULL);
5031 /* Precompute as much of RHS as possible. In the same walk, replace
5032 occurrences of the lhs value with our temporary. */
5033 if (goa_stabilize_expr (&rhs, pre_p, addr, oldval) < 0)
5036 x = build_fold_indirect_ref (addr);
5037 x = build2 (MODIFY_EXPR, void_type_node, oldval, x);
5038 gimplify_and_add (x, pre_p);
5040 /* For floating-point values, we'll need to view-convert them to integers
5041 so that we can perform the atomic compare and swap. Simplify the
5042 following code by always setting up the "i"ntegral variables. */
5043 if (INTEGRAL_TYPE_P (type) || POINTER_TYPE_P (type))
5051 oldival = create_tmp_var (itype, NULL);
5052 newival = create_tmp_var (itype, NULL);
5054 x = build1 (VIEW_CONVERT_EXPR, itype, oldval);
5055 x = build2 (MODIFY_EXPR, void_type_node, oldival, x);
5056 gimplify_and_add (x, pre_p);
5057 iaddr = fold_convert (build_pointer_type (itype), addr);
5060 oldival2 = create_tmp_var (itype, NULL);
5062 label = create_artificial_label ();
5063 x = build1 (LABEL_EXPR, void_type_node, label);
5064 gimplify_and_add (x, pre_p);
5066 x = build2 (MODIFY_EXPR, void_type_node, newval, rhs);
5067 gimplify_and_add (x, pre_p);
5069 if (newval != newival)
5071 x = build1 (VIEW_CONVERT_EXPR, itype, newval);
5072 x = build2 (MODIFY_EXPR, void_type_node, newival, x);
5073 gimplify_and_add (x, pre_p);
5076 x = build2 (MODIFY_EXPR, void_type_node, oldival2, oldival);
5077 gimplify_and_add (x, pre_p);
5079 args = tree_cons (NULL, fold_convert (itype, newival), NULL);
5080 args = tree_cons (NULL, fold_convert (itype, oldival), args);
5081 args = tree_cons (NULL, iaddr, args);
5082 x = build_function_call_expr (cmpxchg, args);
5083 if (oldval == oldival)
5084 x = fold_convert (type, x);
5085 x = build2 (MODIFY_EXPR, void_type_node, oldival, x);
5086 gimplify_and_add (x, pre_p);
5088 /* For floating point, be prepared for the loop backedge. */
5089 if (oldval != oldival)
5091 x = build1 (VIEW_CONVERT_EXPR, type, oldival);
5092 x = build2 (MODIFY_EXPR, void_type_node, oldval, x);
5093 gimplify_and_add (x, pre_p);
5096 /* Note that we always perform the comparison as an integer, even for
5097 floating point. This allows the atomic operation to properly
5098 succeed even with NaNs and -0.0. */
5099 x = build3 (COND_EXPR, void_type_node,
5100 build2 (NE_EXPR, boolean_type_node, oldival, oldival2),
5101 build1 (GOTO_EXPR, void_type_node, label), NULL);
5102 gimplify_and_add (x, pre_p);
5108 /* A subroutine of gimplify_omp_atomic. Implement the atomic operation as:
5110 GOMP_atomic_start ();
5114 The result is not globally atomic, but works so long as all parallel
5115 references are within #pragma omp atomic directives. According to
5116 responses received from omp@openmp.org, appears to be within spec.
5117 Which makes sense, since that's how several other compilers handle
5118 this situation as well. */
5120 static enum gimplify_status
5121 gimplify_omp_atomic_mutex (tree *expr_p, tree *pre_p, tree addr, tree rhs)
5125 t = built_in_decls[BUILT_IN_GOMP_ATOMIC_START];
5126 t = build_function_call_expr (t, NULL);
5127 gimplify_and_add (t, pre_p);
5129 t = build_fold_indirect_ref (addr);
5130 t = build2 (MODIFY_EXPR, void_type_node, t, rhs);
5131 gimplify_and_add (t, pre_p);
5133 t = built_in_decls[BUILT_IN_GOMP_ATOMIC_END];
5134 t = build_function_call_expr (t, NULL);
5135 gimplify_and_add (t, pre_p);
5141 /* Gimplify an OMP_ATOMIC statement. */
5143 static enum gimplify_status
5144 gimplify_omp_atomic (tree *expr_p, tree *pre_p)
5146 tree addr = TREE_OPERAND (*expr_p, 0);
5147 tree rhs = TREE_OPERAND (*expr_p, 1);
5148 tree type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (addr)));
5149 HOST_WIDE_INT index;
5151 /* Make sure the type is one of the supported sizes. */
5152 index = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
5153 index = exact_log2 (index);
5154 if (index >= 0 && index <= 4)
5156 enum gimplify_status gs;
5159 if (DECL_P (TREE_OPERAND (addr, 0)))
5160 align = DECL_ALIGN_UNIT (TREE_OPERAND (addr, 0));
5161 else if (TREE_CODE (TREE_OPERAND (addr, 0)) == COMPONENT_REF
5162 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (addr, 0), 1))
5164 align = DECL_ALIGN_UNIT (TREE_OPERAND (TREE_OPERAND (addr, 0), 1));
5166 align = TYPE_ALIGN_UNIT (type);
5168 /* __sync builtins require strict data alignment. */
5169 if (exact_log2 (align) >= index)
5171 /* When possible, use specialized atomic update functions. */
5172 if (INTEGRAL_TYPE_P (type) || POINTER_TYPE_P (type))
5174 gs = gimplify_omp_atomic_fetch_op (expr_p, addr, rhs, index);
5175 if (gs != GS_UNHANDLED)
5179 /* If we don't have specialized __sync builtins, try and implement
5180 as a compare and swap loop. */
5181 gs = gimplify_omp_atomic_pipeline (expr_p, pre_p, addr, rhs, index);
5182 if (gs != GS_UNHANDLED)
5187 /* The ultimate fallback is wrapping the operation in a mutex. */
5188 return gimplify_omp_atomic_mutex (expr_p, pre_p, addr, rhs);
5191 /* Gimplifies the expression tree pointed to by EXPR_P. Return 0 if
5192 gimplification failed.
5194 PRE_P points to the list where side effects that must happen before
5195 EXPR should be stored.
5197 POST_P points to the list where side effects that must happen after
5198 EXPR should be stored, or NULL if there is no suitable list. In
5199 that case, we copy the result to a temporary, emit the
5200 post-effects, and then return the temporary.
5202 GIMPLE_TEST_F points to a function that takes a tree T and
5203 returns nonzero if T is in the GIMPLE form requested by the
5204 caller. The GIMPLE predicates are in tree-gimple.c.
5206 This test is used twice. Before gimplification, the test is
5207 invoked to determine whether *EXPR_P is already gimple enough. If
5208 that fails, *EXPR_P is gimplified according to its code and
5209 GIMPLE_TEST_F is called again. If the test still fails, then a new
5210 temporary variable is created and assigned the value of the
5211 gimplified expression.
5213 FALLBACK tells the function what sort of a temporary we want. If the 1
5214 bit is set, an rvalue is OK. If the 2 bit is set, an lvalue is OK.
5215 If both are set, either is OK, but an lvalue is preferable.
5217 The return value is either GS_ERROR or GS_ALL_DONE, since this function
5218 iterates until solution. */
5220 enum gimplify_status
5221 gimplify_expr (tree *expr_p, tree *pre_p, tree *post_p,
5222 bool (* gimple_test_f) (tree), fallback_t fallback)
5225 tree internal_pre = NULL_TREE;
5226 tree internal_post = NULL_TREE;
5228 int is_statement = (pre_p == NULL);
5229 location_t saved_location;
5230 enum gimplify_status ret;
5232 save_expr = *expr_p;
5233 if (save_expr == NULL_TREE)
5236 /* We used to check the predicate here and return immediately if it
5237 succeeds. This is wrong; the design is for gimplification to be
5238 idempotent, and for the predicates to only test for valid forms, not
5239 whether they are fully simplified. */
5241 /* Set up our internal queues if needed. */
5243 pre_p = &internal_pre;
5245 post_p = &internal_post;
5247 saved_location = input_location;
5248 if (save_expr != error_mark_node
5249 && EXPR_HAS_LOCATION (*expr_p))
5250 input_location = EXPR_LOCATION (*expr_p);
5252 /* Loop over the specific gimplifiers until the toplevel node
5253 remains the same. */
5256 /* Strip away as many useless type conversions as possible
5258 STRIP_USELESS_TYPE_CONVERSION (*expr_p);
5260 /* Remember the expr. */
5261 save_expr = *expr_p;
5263 /* Die, die, die, my darling. */
5264 if (save_expr == error_mark_node
5265 || (TREE_TYPE (save_expr)
5266 && TREE_TYPE (save_expr) == error_mark_node))
5272 /* Do any language-specific gimplification. */
5273 ret = lang_hooks.gimplify_expr (expr_p, pre_p, post_p);
5276 if (*expr_p == NULL_TREE)
5278 if (*expr_p != save_expr)
5281 else if (ret != GS_UNHANDLED)
5285 switch (TREE_CODE (*expr_p))
5287 /* First deal with the special cases. */
5289 case POSTINCREMENT_EXPR:
5290 case POSTDECREMENT_EXPR:
5291 case PREINCREMENT_EXPR:
5292 case PREDECREMENT_EXPR:
5293 ret = gimplify_self_mod_expr (expr_p, pre_p, post_p,
5294 fallback != fb_none);
5298 case ARRAY_RANGE_REF:
5302 case VIEW_CONVERT_EXPR:
5303 ret = gimplify_compound_lval (expr_p, pre_p, post_p,
5304 fallback ? fallback : fb_rvalue);
5308 ret = gimplify_cond_expr (expr_p, pre_p, fallback);
5309 /* C99 code may assign to an array in a structure value of a
5310 conditional expression, and this has undefined behavior
5311 only on execution, so create a temporary if an lvalue is
5313 if (fallback == fb_lvalue)
5315 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
5316 lang_hooks.mark_addressable (*expr_p);
5321 ret = gimplify_call_expr (expr_p, pre_p, fallback != fb_none);
5322 /* C99 code may assign to an array in a structure returned
5323 from a function, and this has undefined behavior only on
5324 execution, so create a temporary if an lvalue is
5326 if (fallback == fb_lvalue)
5328 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
5329 lang_hooks.mark_addressable (*expr_p);
5337 ret = gimplify_compound_expr (expr_p, pre_p, fallback != fb_none);
5342 ret = gimplify_modify_expr (expr_p, pre_p, post_p,
5343 fallback != fb_none);
5345 /* The distinction between MODIFY_EXPR and INIT_EXPR is no longer
5347 if (*expr_p && TREE_CODE (*expr_p) == INIT_EXPR)
5348 TREE_SET_CODE (*expr_p, MODIFY_EXPR);
5351 case TRUTH_ANDIF_EXPR:
5352 case TRUTH_ORIF_EXPR:
5353 ret = gimplify_boolean_expr (expr_p);
5356 case TRUTH_NOT_EXPR:
5357 TREE_OPERAND (*expr_p, 0)
5358 = gimple_boolify (TREE_OPERAND (*expr_p, 0));
5359 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
5360 is_gimple_val, fb_rvalue);
5361 recalculate_side_effects (*expr_p);
5365 ret = gimplify_addr_expr (expr_p, pre_p, post_p);
5369 ret = gimplify_va_arg_expr (expr_p, pre_p, post_p);
5374 if (IS_EMPTY_STMT (*expr_p))
5380 if (VOID_TYPE_P (TREE_TYPE (*expr_p))
5381 || fallback == fb_none)
5383 /* Just strip a conversion to void (or in void context) and
5385 *expr_p = TREE_OPERAND (*expr_p, 0);
5389 ret = gimplify_conversion (expr_p);
5390 if (ret == GS_ERROR)
5392 if (*expr_p != save_expr)
5396 case FIX_TRUNC_EXPR:
5398 case FIX_FLOOR_EXPR:
5399 case FIX_ROUND_EXPR:
5400 /* unary_expr: ... | '(' cast ')' val | ... */
5401 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
5402 is_gimple_val, fb_rvalue);
5403 recalculate_side_effects (*expr_p);
5407 *expr_p = fold_indirect_ref (*expr_p);
5408 if (*expr_p != save_expr)
5410 /* else fall through. */
5411 case ALIGN_INDIRECT_REF:
5412 case MISALIGNED_INDIRECT_REF:
5413 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
5414 is_gimple_reg, fb_rvalue);
5415 recalculate_side_effects (*expr_p);
5418 /* Constants need not be gimplified. */
5428 /* If we require an lvalue, such as for ADDR_EXPR, retain the
5429 CONST_DECL node. Otherwise the decl is replaceable by its
5431 /* ??? Should be == fb_lvalue, but ADDR_EXPR passes fb_either. */
5432 if (fallback & fb_lvalue)
5435 *expr_p = DECL_INITIAL (*expr_p);
5439 ret = gimplify_decl_expr (expr_p);
5443 /* FIXME make this a decl. */
5448 ret = gimplify_bind_expr (expr_p, NULL, pre_p);
5452 ret = gimplify_loop_expr (expr_p, pre_p);
5456 ret = gimplify_switch_expr (expr_p, pre_p);
5460 ret = gimplify_exit_expr (expr_p);
5464 /* If the target is not LABEL, then it is a computed jump
5465 and the target needs to be gimplified. */
5466 if (TREE_CODE (GOTO_DESTINATION (*expr_p)) != LABEL_DECL)
5467 ret = gimplify_expr (&GOTO_DESTINATION (*expr_p), pre_p,
5468 NULL, is_gimple_val, fb_rvalue);
5473 gcc_assert (decl_function_context (LABEL_EXPR_LABEL (*expr_p))
5474 == current_function_decl);
5477 case CASE_LABEL_EXPR:
5478 ret = gimplify_case_label_expr (expr_p);
5482 ret = gimplify_return_expr (*expr_p, pre_p);
5486 /* Don't reduce this in place; let gimplify_init_constructor work its
5487 magic. Buf if we're just elaborating this for side effects, just
5488 gimplify any element that has side-effects. */
5489 if (fallback == fb_none)
5491 unsigned HOST_WIDE_INT ix;
5492 constructor_elt *ce;
5493 tree temp = NULL_TREE;
5495 VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (*expr_p),
5498 if (TREE_SIDE_EFFECTS (ce->value))
5499 append_to_statement_list (ce->value, &temp);
5504 /* C99 code may assign to an array in a constructed
5505 structure or union, and this has undefined behavior only
5506 on execution, so create a temporary if an lvalue is
5508 else if (fallback == fb_lvalue)
5510 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
5511 lang_hooks.mark_addressable (*expr_p);
5517 /* The following are special cases that are not handled by the
5518 original GIMPLE grammar. */
5520 /* SAVE_EXPR nodes are converted into a GIMPLE identifier and
5523 ret = gimplify_save_expr (expr_p, pre_p, post_p);
5528 enum gimplify_status r0, r1, r2;
5530 r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
5531 is_gimple_lvalue, fb_either);
5532 r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p,
5533 is_gimple_val, fb_rvalue);
5534 r2 = gimplify_expr (&TREE_OPERAND (*expr_p, 2), pre_p, post_p,
5535 is_gimple_val, fb_rvalue);
5536 recalculate_side_effects (*expr_p);
5538 ret = MIN (r0, MIN (r1, r2));
5542 case NON_LVALUE_EXPR:
5543 /* This should have been stripped above. */
5547 ret = gimplify_asm_expr (expr_p, pre_p, post_p);
5550 case TRY_FINALLY_EXPR:
5551 case TRY_CATCH_EXPR:
5552 gimplify_to_stmt_list (&TREE_OPERAND (*expr_p, 0));
5553 gimplify_to_stmt_list (&TREE_OPERAND (*expr_p, 1));
5557 case CLEANUP_POINT_EXPR:
5558 ret = gimplify_cleanup_point_expr (expr_p, pre_p);
5562 ret = gimplify_target_expr (expr_p, pre_p, post_p);
5566 gimplify_to_stmt_list (&CATCH_BODY (*expr_p));
5570 case EH_FILTER_EXPR:
5571 gimplify_to_stmt_list (&EH_FILTER_FAILURE (*expr_p));
5577 enum gimplify_status r0, r1;
5578 r0 = gimplify_expr (&OBJ_TYPE_REF_OBJECT (*expr_p), pre_p, post_p,
5579 is_gimple_val, fb_rvalue);
5580 r1 = gimplify_expr (&OBJ_TYPE_REF_EXPR (*expr_p), pre_p, post_p,
5581 is_gimple_val, fb_rvalue);
5587 /* We get here when taking the address of a label. We mark
5588 the label as "forced"; meaning it can never be removed and
5589 it is a potential target for any computed goto. */
5590 FORCED_LABEL (*expr_p) = 1;
5594 case STATEMENT_LIST:
5595 ret = gimplify_statement_list (expr_p);
5598 case WITH_SIZE_EXPR:
5600 gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
5601 post_p == &internal_post ? NULL : post_p,
5602 gimple_test_f, fallback);
5603 gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p,
5604 is_gimple_val, fb_rvalue);
5610 ret = gimplify_var_or_parm_decl (expr_p);
5614 /* When within an OpenMP context, notice uses of variables. */
5615 if (gimplify_omp_ctxp)
5616 omp_notice_variable (gimplify_omp_ctxp, *expr_p, true);
5621 /* Allow callbacks into the gimplifier during optimization. */
5626 ret = gimplify_omp_parallel (expr_p, pre_p);
5630 ret = gimplify_omp_for (expr_p, pre_p);
5635 ret = gimplify_omp_workshare (expr_p, pre_p);
5642 gimplify_to_stmt_list (&OMP_BODY (*expr_p));
5646 ret = gimplify_omp_atomic (expr_p, pre_p);
5655 switch (TREE_CODE_CLASS (TREE_CODE (*expr_p)))
5657 case tcc_comparison:
5658 /* If this is a comparison of objects of aggregate type,
5659 handle it specially (by converting to a call to
5660 memcmp). It would be nice to only have to do this
5661 for variable-sized objects, but then we'd have to
5662 allow the same nest of reference nodes we allow for
5663 MODIFY_EXPR and that's too complex. */
5664 if (!AGGREGATE_TYPE_P (TREE_TYPE (TREE_OPERAND (*expr_p, 1))))
5666 ret = gimplify_variable_sized_compare (expr_p);
5669 /* If *EXPR_P does not need to be special-cased, handle it
5670 according to its class. */
5672 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
5673 post_p, is_gimple_val, fb_rvalue);
5679 enum gimplify_status r0, r1;
5681 r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
5682 post_p, is_gimple_val, fb_rvalue);
5683 r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p,
5684 post_p, is_gimple_val, fb_rvalue);
5690 case tcc_declaration:
5693 goto dont_recalculate;
5696 gcc_assert (TREE_CODE (*expr_p) == TRUTH_AND_EXPR
5697 || TREE_CODE (*expr_p) == TRUTH_OR_EXPR
5698 || TREE_CODE (*expr_p) == TRUTH_XOR_EXPR);
5702 recalculate_side_effects (*expr_p);
5707 /* If we replaced *expr_p, gimplify again. */
5708 if (ret == GS_OK && (*expr_p == NULL || *expr_p == save_expr))
5711 while (ret == GS_OK);
5713 /* If we encountered an error_mark somewhere nested inside, either
5714 stub out the statement or propagate the error back out. */
5715 if (ret == GS_ERROR)
5722 /* This was only valid as a return value from the langhook, which
5723 we handled. Make sure it doesn't escape from any other context. */
5724 gcc_assert (ret != GS_UNHANDLED);
5726 if (fallback == fb_none && *expr_p && !is_gimple_stmt (*expr_p))
5728 /* We aren't looking for a value, and we don't have a valid
5729 statement. If it doesn't have side-effects, throw it away. */
5730 if (!TREE_SIDE_EFFECTS (*expr_p))
5732 else if (!TREE_THIS_VOLATILE (*expr_p))
5734 /* This is probably a _REF that contains something nested that
5735 has side effects. Recurse through the operands to find it. */
5736 enum tree_code code = TREE_CODE (*expr_p);
5743 case VIEW_CONVERT_EXPR:
5744 gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
5745 gimple_test_f, fallback);
5748 case ARRAY_REF: case ARRAY_RANGE_REF:
5749 gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
5750 gimple_test_f, fallback);
5751 gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p,
5752 gimple_test_f, fallback);
5756 /* Anything else with side-effects must be converted to
5757 a valid statement before we get here. */
5763 else if (COMPLETE_TYPE_P (TREE_TYPE (*expr_p)))
5765 /* Historically, the compiler has treated a bare
5766 reference to a volatile lvalue as forcing a load. */
5767 tree type = TYPE_MAIN_VARIANT (TREE_TYPE (*expr_p));
5768 /* Normally, we do not want to create a temporary for a
5769 TREE_ADDRESSABLE type because such a type should not be
5770 copied by bitwise-assignment. However, we make an
5771 exception here, as all we are doing here is ensuring that
5772 we read the bytes that make up the type. We use
5773 create_tmp_var_raw because create_tmp_var will abort when
5774 given a TREE_ADDRESSABLE type. */
5775 tree tmp = create_tmp_var_raw (type, "vol");
5776 gimple_add_tmp_var (tmp);
5777 *expr_p = build2 (MODIFY_EXPR, type, tmp, *expr_p);
5780 /* We can't do anything useful with a volatile reference to
5781 incomplete type, so just throw it away. */
5785 /* If we are gimplifying at the statement level, we're done. Tack
5786 everything together and replace the original statement with the
5788 if (fallback == fb_none || is_statement)
5790 if (internal_pre || internal_post)
5792 append_to_statement_list (*expr_p, &internal_pre);
5793 append_to_statement_list (internal_post, &internal_pre);
5794 annotate_all_with_locus (&internal_pre, input_location);
5795 *expr_p = internal_pre;
5799 else if (TREE_CODE (*expr_p) == STATEMENT_LIST)
5800 annotate_all_with_locus (expr_p, input_location);
5802 annotate_one_with_locus (*expr_p, input_location);
5806 /* Otherwise we're gimplifying a subexpression, so the resulting value is
5809 /* If it's sufficiently simple already, we're done. Unless we are
5810 handling some post-effects internally; if that's the case, we need to
5811 copy into a temp before adding the post-effects to the tree. */
5812 if (!internal_post && (*gimple_test_f) (*expr_p))
5815 /* Otherwise, we need to create a new temporary for the gimplified
5818 /* We can't return an lvalue if we have an internal postqueue. The
5819 object the lvalue refers to would (probably) be modified by the
5820 postqueue; we need to copy the value out first, which means an
5822 if ((fallback & fb_lvalue) && !internal_post
5823 && is_gimple_addressable (*expr_p))
5825 /* An lvalue will do. Take the address of the expression, store it
5826 in a temporary, and replace the expression with an INDIRECT_REF of
5828 tmp = build_fold_addr_expr (*expr_p);
5829 gimplify_expr (&tmp, pre_p, post_p, is_gimple_reg, fb_rvalue);
5830 *expr_p = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (tmp)), tmp);
5832 else if ((fallback & fb_rvalue) && is_gimple_formal_tmp_rhs (*expr_p))
5834 gcc_assert (!VOID_TYPE_P (TREE_TYPE (*expr_p)));
5836 /* An rvalue will do. Assign the gimplified expression into a new
5837 temporary TMP and replace the original expression with TMP. */
5839 if (internal_post || (fallback & fb_lvalue))
5840 /* The postqueue might change the value of the expression between
5841 the initialization and use of the temporary, so we can't use a
5842 formal temp. FIXME do we care? */
5843 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
5845 *expr_p = get_formal_tmp_var (*expr_p, pre_p);
5847 if (TREE_CODE (*expr_p) != SSA_NAME)
5848 DECL_GIMPLE_FORMAL_TEMP_P (*expr_p) = 1;
5852 #ifdef ENABLE_CHECKING
5853 if (!(fallback & fb_mayfail))
5855 fprintf (stderr, "gimplification failed:\n");
5856 print_generic_expr (stderr, *expr_p, 0);
5857 debug_tree (*expr_p);
5858 internal_error ("gimplification failed");
5861 gcc_assert (fallback & fb_mayfail);
5862 /* If this is an asm statement, and the user asked for the
5863 impossible, don't die. Fail and let gimplify_asm_expr
5869 /* Make sure the temporary matches our predicate. */
5870 gcc_assert ((*gimple_test_f) (*expr_p));
5874 annotate_all_with_locus (&internal_post, input_location);
5875 append_to_statement_list (internal_post, pre_p);
5879 input_location = saved_location;
5883 /* Look through TYPE for variable-sized objects and gimplify each such
5884 size that we find. Add to LIST_P any statements generated. */
5887 gimplify_type_sizes (tree type, tree *list_p)
5891 if (type == NULL || type == error_mark_node)
5894 /* We first do the main variant, then copy into any other variants. */
5895 type = TYPE_MAIN_VARIANT (type);
5897 /* Avoid infinite recursion. */
5898 if (TYPE_SIZES_GIMPLIFIED (type))
5901 TYPE_SIZES_GIMPLIFIED (type) = 1;
5903 switch (TREE_CODE (type))
5909 gimplify_one_sizepos (&TYPE_MIN_VALUE (type), list_p);
5910 gimplify_one_sizepos (&TYPE_MAX_VALUE (type), list_p);
5912 for (t = TYPE_NEXT_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
5914 TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (type);
5915 TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (type);
5920 /* These types may not have declarations, so handle them here. */
5921 gimplify_type_sizes (TREE_TYPE (type), list_p);
5922 gimplify_type_sizes (TYPE_DOMAIN (type), list_p);
5927 case QUAL_UNION_TYPE:
5928 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
5929 if (TREE_CODE (field) == FIELD_DECL)
5931 gimplify_one_sizepos (&DECL_FIELD_OFFSET (field), list_p);
5932 gimplify_type_sizes (TREE_TYPE (field), list_p);
5937 case REFERENCE_TYPE:
5938 gimplify_type_sizes (TREE_TYPE (type), list_p);
5945 gimplify_one_sizepos (&TYPE_SIZE (type), list_p);
5946 gimplify_one_sizepos (&TYPE_SIZE_UNIT (type), list_p);
5948 for (t = TYPE_NEXT_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
5950 TYPE_SIZE (t) = TYPE_SIZE (type);
5951 TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (type);
5952 TYPE_SIZES_GIMPLIFIED (t) = 1;
5956 /* A subroutine of gimplify_type_sizes to make sure that *EXPR_P,
5957 a size or position, has had all of its SAVE_EXPRs evaluated.
5958 We add any required statements to STMT_P. */
5961 gimplify_one_sizepos (tree *expr_p, tree *stmt_p)
5963 tree type, expr = *expr_p;
5965 /* We don't do anything if the value isn't there, is constant, or contains
5966 A PLACEHOLDER_EXPR. We also don't want to do anything if it's already
5967 a VAR_DECL. If it's a VAR_DECL from another function, the gimplifier
5968 will want to replace it with a new variable, but that will cause problems
5969 if this type is from outside the function. It's OK to have that here. */
5970 if (expr == NULL_TREE || TREE_CONSTANT (expr)
5971 || TREE_CODE (expr) == VAR_DECL
5972 || CONTAINS_PLACEHOLDER_P (expr))
5975 type = TREE_TYPE (expr);
5976 *expr_p = unshare_expr (expr);
5978 gimplify_expr (expr_p, stmt_p, NULL, is_gimple_val, fb_rvalue);
5981 /* Verify that we've an exact type match with the original expression.
5982 In particular, we do not wish to drop a "sizetype" in favour of a
5983 type of similar dimensions. We don't want to pollute the generic
5984 type-stripping code with this knowledge because it doesn't matter
5985 for the bulk of GENERIC/GIMPLE. It only matters that TYPE_SIZE_UNIT
5986 and friends retain their "sizetype-ness". */
5987 if (TREE_TYPE (expr) != type
5988 && TREE_CODE (type) == INTEGER_TYPE
5989 && TYPE_IS_SIZETYPE (type))
5993 *expr_p = create_tmp_var (type, NULL);
5994 tmp = build1 (NOP_EXPR, type, expr);
5995 tmp = build2 (MODIFY_EXPR, type, *expr_p, tmp);
5996 if (EXPR_HAS_LOCATION (expr))
5997 SET_EXPR_LOCUS (tmp, EXPR_LOCUS (expr));
5999 SET_EXPR_LOCATION (tmp, input_location);
6001 gimplify_and_add (tmp, stmt_p);
6005 #ifdef ENABLE_CHECKING
6006 /* Compare types A and B for a "close enough" match. */
6009 cpt_same_type (tree a, tree b)
6011 if (lang_hooks.types_compatible_p (a, b))
6014 /* ??? The C++ FE decomposes METHOD_TYPES to FUNCTION_TYPES and doesn't
6015 link them together. This routine is intended to catch type errors
6016 that will affect the optimizers, and the optimizers don't add new
6017 dereferences of function pointers, so ignore it. */
6018 if ((TREE_CODE (a) == FUNCTION_TYPE || TREE_CODE (a) == METHOD_TYPE)
6019 && (TREE_CODE (b) == FUNCTION_TYPE || TREE_CODE (b) == METHOD_TYPE))
6022 /* ??? The C FE pushes type qualifiers after the fact into the type of
6023 the element from the type of the array. See build_unary_op's handling
6024 of ADDR_EXPR. This seems wrong -- if we were going to do this, we
6025 should have done it when creating the variable in the first place.
6026 Alternately, why aren't the two array types made variants? */
6027 if (TREE_CODE (a) == ARRAY_TYPE && TREE_CODE (b) == ARRAY_TYPE)
6028 return cpt_same_type (TREE_TYPE (a), TREE_TYPE (b));
6030 /* And because of those, we have to recurse down through pointers. */
6031 if (POINTER_TYPE_P (a) && POINTER_TYPE_P (b))
6032 return cpt_same_type (TREE_TYPE (a), TREE_TYPE (b));
6037 /* Check for some cases of the front end missing cast expressions.
6038 The type of a dereference should correspond to the pointer type;
6039 similarly the type of an address should match its object. */
6042 check_pointer_types_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
6043 void *data ATTRIBUTE_UNUSED)
6046 tree ptype, otype, dtype;
6048 switch (TREE_CODE (t))
6052 otype = TREE_TYPE (t);
6053 ptype = TREE_TYPE (TREE_OPERAND (t, 0));
6054 dtype = TREE_TYPE (ptype);
6055 gcc_assert (cpt_same_type (otype, dtype));
6059 ptype = TREE_TYPE (t);
6060 otype = TREE_TYPE (TREE_OPERAND (t, 0));
6061 dtype = TREE_TYPE (ptype);
6062 if (!cpt_same_type (otype, dtype))
6064 /* &array is allowed to produce a pointer to the element, rather than
6065 a pointer to the array type. We must allow this in order to
6066 properly represent assigning the address of an array in C into
6067 pointer to the element type. */
6068 gcc_assert (TREE_CODE (otype) == ARRAY_TYPE
6069 && POINTER_TYPE_P (ptype)
6070 && cpt_same_type (TREE_TYPE (otype), dtype));
6084 /* Gimplify the body of statements pointed to by BODY_P. FNDECL is the
6085 function decl containing BODY. */
6088 gimplify_body (tree *body_p, tree fndecl, bool do_parms)
6090 location_t saved_location = input_location;
6091 tree body, parm_stmts;
6093 timevar_push (TV_TREE_GIMPLIFY);
6095 gcc_assert (gimplify_ctxp == NULL);
6096 push_gimplify_context ();
6098 /* Unshare most shared trees in the body and in that of any nested functions.
6099 It would seem we don't have to do this for nested functions because
6100 they are supposed to be output and then the outer function gimplified
6101 first, but the g++ front end doesn't always do it that way. */
6102 unshare_body (body_p, fndecl);
6103 unvisit_body (body_p, fndecl);
6105 /* Make sure input_location isn't set to something wierd. */
6106 input_location = DECL_SOURCE_LOCATION (fndecl);
6108 /* Resolve callee-copies. This has to be done before processing
6109 the body so that DECL_VALUE_EXPR gets processed correctly. */
6110 parm_stmts = do_parms ? gimplify_parameters () : NULL;
6112 /* Gimplify the function's body. */
6113 gimplify_stmt (body_p);
6117 body = alloc_stmt_list ();
6118 else if (TREE_CODE (body) == STATEMENT_LIST)
6120 tree t = expr_only (*body_p);
6125 /* If there isn't an outer BIND_EXPR, add one. */
6126 if (TREE_CODE (body) != BIND_EXPR)
6128 tree b = build3 (BIND_EXPR, void_type_node, NULL_TREE,
6129 NULL_TREE, NULL_TREE);
6130 TREE_SIDE_EFFECTS (b) = 1;
6131 append_to_statement_list_force (body, &BIND_EXPR_BODY (b));
6135 /* If we had callee-copies statements, insert them at the beginning
6139 append_to_statement_list_force (BIND_EXPR_BODY (body), &parm_stmts);
6140 BIND_EXPR_BODY (body) = parm_stmts;
6143 /* Unshare again, in case gimplification was sloppy. */
6144 unshare_all_trees (body);
6148 pop_gimplify_context (body);
6149 gcc_assert (gimplify_ctxp == NULL);
6151 #ifdef ENABLE_CHECKING
6152 walk_tree (body_p, check_pointer_types_r, NULL, NULL);
6155 timevar_pop (TV_TREE_GIMPLIFY);
6156 input_location = saved_location;
6159 /* Entry point to the gimplification pass. FNDECL is the FUNCTION_DECL
6160 node for the function we want to gimplify. */
6163 gimplify_function_tree (tree fndecl)
6165 tree oldfn, parm, ret;
6167 oldfn = current_function_decl;
6168 current_function_decl = fndecl;
6169 cfun = DECL_STRUCT_FUNCTION (fndecl);
6171 allocate_struct_function (fndecl);
6173 for (parm = DECL_ARGUMENTS (fndecl); parm ; parm = TREE_CHAIN (parm))
6175 /* Preliminarily mark non-addressed complex variables as eligible
6176 for promotion to gimple registers. We'll transform their uses
6178 if (TREE_CODE (TREE_TYPE (parm)) == COMPLEX_TYPE
6179 && !TREE_THIS_VOLATILE (parm)
6180 && !needs_to_live_in_memory (parm))
6181 DECL_COMPLEX_GIMPLE_REG_P (parm) = 1;
6184 ret = DECL_RESULT (fndecl);
6185 if (TREE_CODE (TREE_TYPE (ret)) == COMPLEX_TYPE
6186 && !needs_to_live_in_memory (ret))
6187 DECL_COMPLEX_GIMPLE_REG_P (ret) = 1;
6189 gimplify_body (&DECL_SAVED_TREE (fndecl), fndecl, true);
6191 /* If we're instrumenting function entry/exit, then prepend the call to
6192 the entry hook and wrap the whole function in a TRY_FINALLY_EXPR to
6193 catch the exit hook. */
6194 /* ??? Add some way to ignore exceptions for this TFE. */
6195 if (flag_instrument_function_entry_exit
6196 && ! DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (fndecl))
6200 tf = build2 (TRY_FINALLY_EXPR, void_type_node, NULL, NULL);
6201 TREE_SIDE_EFFECTS (tf) = 1;
6202 x = DECL_SAVED_TREE (fndecl);
6203 append_to_statement_list (x, &TREE_OPERAND (tf, 0));
6204 x = implicit_built_in_decls[BUILT_IN_PROFILE_FUNC_EXIT];
6205 x = build_function_call_expr (x, NULL);
6206 append_to_statement_list (x, &TREE_OPERAND (tf, 1));
6208 bind = build3 (BIND_EXPR, void_type_node, NULL, NULL, NULL);
6209 TREE_SIDE_EFFECTS (bind) = 1;
6210 x = implicit_built_in_decls[BUILT_IN_PROFILE_FUNC_ENTER];
6211 x = build_function_call_expr (x, NULL);
6212 append_to_statement_list (x, &BIND_EXPR_BODY (bind));
6213 append_to_statement_list (tf, &BIND_EXPR_BODY (bind));
6215 DECL_SAVED_TREE (fndecl) = bind;
6218 current_function_decl = oldfn;
6219 cfun = oldfn ? DECL_STRUCT_FUNCTION (oldfn) : NULL;
6223 /* Expands EXPR to list of gimple statements STMTS. If SIMPLE is true,
6224 force the result to be either ssa_name or an invariant, otherwise
6225 just force it to be a rhs expression. If VAR is not NULL, make the
6226 base variable of the final destination be VAR if suitable. */
6229 force_gimple_operand (tree expr, tree *stmts, bool simple, tree var)
6232 enum gimplify_status ret;
6233 gimple_predicate gimple_test_f;
6237 if (is_gimple_val (expr))
6240 gimple_test_f = simple ? is_gimple_val : is_gimple_reg_rhs;
6242 push_gimplify_context ();
6243 gimplify_ctxp->into_ssa = in_ssa_p;
6246 expr = build2 (MODIFY_EXPR, TREE_TYPE (var), var, expr);
6248 ret = gimplify_expr (&expr, stmts, NULL,
6249 gimple_test_f, fb_rvalue);
6250 gcc_assert (ret != GS_ERROR);
6252 if (referenced_vars)
6254 for (t = gimplify_ctxp->temps; t ; t = TREE_CHAIN (t))
6255 add_referenced_var (t);
6258 pop_gimplify_context (NULL);
6263 /* Invokes force_gimple_operand for EXPR with parameters SIMPLE_P and VAR. If
6264 some statements are produced, emits them before BSI. */
6267 force_gimple_operand_bsi (block_stmt_iterator *bsi, tree expr,
6268 bool simple_p, tree var)
6272 expr = force_gimple_operand (expr, &stmts, simple_p, var);
6274 bsi_insert_before (bsi, stmts, BSI_SAME_STMT);
6279 #include "gt-gimplify.h"