1 /* Tree lowering pass. This pass converts the GENERIC functions-as-trees
2 tree representation into the GIMPLE form.
3 Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007
4 Free Software Foundation, Inc.
5 Major work done by Sebastian Pop <s.pop@laposte.net>,
6 Diego Novillo <dnovillo@redhat.com> and Jason Merrill <jason@redhat.com>.
8 This file is part of GCC.
10 GCC is free software; you can redistribute it and/or modify it under
11 the terms of the GNU General Public License as published by the Free
12 Software Foundation; either version 2, or (at your option) any later
15 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
16 WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
20 You should have received a copy of the GNU General Public License
21 along with GCC; see the file COPYING. If not, write to the Free
22 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
27 #include "coretypes.h"
32 #include "tree-gimple.h"
33 #include "tree-inline.h"
34 #include "diagnostic.h"
35 #include "langhooks.h"
36 #include "langhooks-def.h"
37 #include "tree-flow.h"
51 #include "pointer-set.h"
54 enum gimplify_omp_var_data
60 GOVD_FIRSTPRIVATE = 16,
61 GOVD_LASTPRIVATE = 32,
64 GOVD_DEBUG_PRIVATE = 256,
65 GOVD_DATA_SHARE_CLASS = (GOVD_SHARED | GOVD_PRIVATE | GOVD_FIRSTPRIVATE
66 | GOVD_LASTPRIVATE | GOVD_REDUCTION | GOVD_LOCAL)
69 struct gimplify_omp_ctx
71 struct gimplify_omp_ctx *outer_context;
73 struct pointer_set_t *privatized_types;
75 enum omp_clause_default_kind default_kind;
77 bool is_combined_parallel;
82 struct gimplify_ctx *prev_context;
84 tree current_bind_expr;
86 tree conditional_cleanups;
90 VEC(tree,heap) *case_labels;
91 /* The formal temporary table. Should this be persistent? */
99 static struct gimplify_ctx *gimplify_ctxp;
100 static struct gimplify_omp_ctx *gimplify_omp_ctxp;
104 /* Formal (expression) temporary table handling: Multiple occurrences of
105 the same scalar expression are evaluated into the same temporary. */
107 typedef struct gimple_temp_hash_elt
110 tree temp; /* Value */
113 /* Forward declarations. */
114 static enum gimplify_status gimplify_compound_expr (tree *, tree *, bool);
115 #ifdef ENABLE_CHECKING
116 static bool cpt_same_type (tree a, tree b);
120 /* Return a hash value for a formal temporary table entry. */
123 gimple_tree_hash (const void *p)
125 tree t = ((const elt_t *) p)->val;
126 return iterative_hash_expr (t, 0);
129 /* Compare two formal temporary table entries. */
132 gimple_tree_eq (const void *p1, const void *p2)
134 tree t1 = ((const elt_t *) p1)->val;
135 tree t2 = ((const elt_t *) p2)->val;
136 enum tree_code code = TREE_CODE (t1);
138 if (TREE_CODE (t2) != code
139 || TREE_TYPE (t1) != TREE_TYPE (t2))
142 if (!operand_equal_p (t1, t2, 0))
145 /* Only allow them to compare equal if they also hash equal; otherwise
146 results are nondeterminate, and we fail bootstrap comparison. */
147 gcc_assert (gimple_tree_hash (p1) == gimple_tree_hash (p2));
152 /* Set up a context for the gimplifier. */
155 push_gimplify_context (void)
157 struct gimplify_ctx *c;
159 c = (struct gimplify_ctx *) xcalloc (1, sizeof (struct gimplify_ctx));
160 c->prev_context = gimplify_ctxp;
162 c->temp_htab = htab_create (1000, gimple_tree_hash, gimple_tree_eq, free);
167 /* Tear down a context for the gimplifier. If BODY is non-null, then
168 put the temporaries into the outer BIND_EXPR. Otherwise, put them
169 in the unexpanded_var_list. */
172 pop_gimplify_context (tree body)
174 struct gimplify_ctx *c = gimplify_ctxp;
177 gcc_assert (c && !c->current_bind_expr);
178 gimplify_ctxp = c->prev_context;
180 for (t = c->temps; t ; t = TREE_CHAIN (t))
181 DECL_GIMPLE_FORMAL_TEMP_P (t) = 0;
184 declare_vars (c->temps, body, false);
186 record_vars (c->temps);
189 htab_delete (c->temp_htab);
194 gimple_push_bind_expr (tree bind)
196 TREE_CHAIN (bind) = gimplify_ctxp->current_bind_expr;
197 gimplify_ctxp->current_bind_expr = bind;
201 gimple_pop_bind_expr (void)
203 gimplify_ctxp->current_bind_expr
204 = TREE_CHAIN (gimplify_ctxp->current_bind_expr);
208 gimple_current_bind_expr (void)
210 return gimplify_ctxp->current_bind_expr;
213 /* Returns true iff there is a COND_EXPR between us and the innermost
214 CLEANUP_POINT_EXPR. This info is used by gimple_push_cleanup. */
217 gimple_conditional_context (void)
219 return gimplify_ctxp->conditions > 0;
222 /* Note that we've entered a COND_EXPR. */
225 gimple_push_condition (void)
227 #ifdef ENABLE_CHECKING
228 if (gimplify_ctxp->conditions == 0)
229 gcc_assert (!gimplify_ctxp->conditional_cleanups);
231 ++(gimplify_ctxp->conditions);
234 /* Note that we've left a COND_EXPR. If we're back at unconditional scope
235 now, add any conditional cleanups we've seen to the prequeue. */
238 gimple_pop_condition (tree *pre_p)
240 int conds = --(gimplify_ctxp->conditions);
242 gcc_assert (conds >= 0);
245 append_to_statement_list (gimplify_ctxp->conditional_cleanups, pre_p);
246 gimplify_ctxp->conditional_cleanups = NULL_TREE;
250 /* A stable comparison routine for use with splay trees and DECLs. */
253 splay_tree_compare_decl_uid (splay_tree_key xa, splay_tree_key xb)
258 return DECL_UID (a) - DECL_UID (b);
261 /* Create a new omp construct that deals with variable remapping. */
263 static struct gimplify_omp_ctx *
264 new_omp_context (bool is_parallel, bool is_combined_parallel)
266 struct gimplify_omp_ctx *c;
268 c = XCNEW (struct gimplify_omp_ctx);
269 c->outer_context = gimplify_omp_ctxp;
270 c->variables = splay_tree_new (splay_tree_compare_decl_uid, 0, 0);
271 c->privatized_types = pointer_set_create ();
272 c->location = input_location;
273 c->is_parallel = is_parallel;
274 c->is_combined_parallel = is_combined_parallel;
275 c->default_kind = OMP_CLAUSE_DEFAULT_SHARED;
280 /* Destroy an omp construct that deals with variable remapping. */
283 delete_omp_context (struct gimplify_omp_ctx *c)
285 splay_tree_delete (c->variables);
286 pointer_set_destroy (c->privatized_types);
290 static void omp_add_variable (struct gimplify_omp_ctx *, tree, unsigned int);
291 static bool omp_notice_variable (struct gimplify_omp_ctx *, tree, bool);
293 /* A subroutine of append_to_statement_list{,_force}. T is not NULL. */
296 append_to_statement_list_1 (tree t, tree *list_p)
299 tree_stmt_iterator i;
303 if (t && TREE_CODE (t) == STATEMENT_LIST)
308 *list_p = list = alloc_stmt_list ();
312 tsi_link_after (&i, t, TSI_CONTINUE_LINKING);
315 /* Add T to the end of the list container pointed to by LIST_P.
316 If T is an expression with no effects, it is ignored. */
319 append_to_statement_list (tree t, tree *list_p)
321 if (t && TREE_SIDE_EFFECTS (t))
322 append_to_statement_list_1 (t, list_p);
325 /* Similar, but the statement is always added, regardless of side effects. */
328 append_to_statement_list_force (tree t, tree *list_p)
331 append_to_statement_list_1 (t, list_p);
334 /* Both gimplify the statement T and append it to LIST_P. */
337 gimplify_and_add (tree t, tree *list_p)
340 append_to_statement_list (t, list_p);
343 /* Strip off a legitimate source ending from the input string NAME of
344 length LEN. Rather than having to know the names used by all of
345 our front ends, we strip off an ending of a period followed by
346 up to five characters. (Java uses ".class".) */
349 remove_suffix (char *name, int len)
353 for (i = 2; i < 8 && len > i; i++)
355 if (name[len - i] == '.')
357 name[len - i] = '\0';
363 /* Create a nameless artificial label and put it in the current function
364 context. Returns the newly created label. */
367 create_artificial_label (void)
369 tree lab = build_decl (LABEL_DECL, NULL_TREE, void_type_node);
371 DECL_ARTIFICIAL (lab) = 1;
372 DECL_IGNORED_P (lab) = 1;
373 DECL_CONTEXT (lab) = current_function_decl;
377 /* Subroutine for find_single_pointer_decl. */
380 find_single_pointer_decl_1 (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
383 tree *pdecl = (tree *) data;
385 if (DECL_P (*tp) && POINTER_TYPE_P (TREE_TYPE (*tp)))
389 /* We already found a pointer decl; return anything other
390 than NULL_TREE to unwind from walk_tree signalling that
391 we have a duplicate. */
400 /* Find the single DECL of pointer type in the tree T and return it.
401 If there are zero or more than one such DECLs, return NULL. */
404 find_single_pointer_decl (tree t)
406 tree decl = NULL_TREE;
408 if (walk_tree (&t, find_single_pointer_decl_1, &decl, NULL))
410 /* find_single_pointer_decl_1 returns a nonzero value, causing
411 walk_tree to return a nonzero value, to indicate that it
412 found more than one pointer DECL. */
419 /* Create a new temporary name with PREFIX. Returns an identifier. */
421 static GTY(()) unsigned int tmp_var_id_num;
424 create_tmp_var_name (const char *prefix)
430 char *preftmp = ASTRDUP (prefix);
432 remove_suffix (preftmp, strlen (preftmp));
436 ASM_FORMAT_PRIVATE_NAME (tmp_name, prefix ? prefix : "T", tmp_var_id_num++);
437 return get_identifier (tmp_name);
441 /* Create a new temporary variable declaration of type TYPE.
442 Does NOT push it into the current binding. */
445 create_tmp_var_raw (tree type, const char *prefix)
450 /* Make the type of the variable writable. */
451 new_type = build_type_variant (type, 0, 0);
452 TYPE_ATTRIBUTES (new_type) = TYPE_ATTRIBUTES (type);
454 tmp_var = build_decl (VAR_DECL, prefix ? create_tmp_var_name (prefix) : NULL,
457 /* The variable was declared by the compiler. */
458 DECL_ARTIFICIAL (tmp_var) = 1;
459 /* And we don't want debug info for it. */
460 DECL_IGNORED_P (tmp_var) = 1;
462 /* Make the variable writable. */
463 TREE_READONLY (tmp_var) = 0;
465 DECL_EXTERNAL (tmp_var) = 0;
466 TREE_STATIC (tmp_var) = 0;
467 TREE_USED (tmp_var) = 1;
472 /* Create a new temporary variable declaration of type TYPE. DOES push the
473 variable into the current binding. Further, assume that this is called
474 only from gimplification or optimization, at which point the creation of
475 certain types are bugs. */
478 create_tmp_var (tree type, const char *prefix)
482 /* We don't allow types that are addressable (meaning we can't make copies),
483 or incomplete. We also used to reject every variable size objects here,
484 but now support those for which a constant upper bound can be obtained.
485 The processing for variable sizes is performed in gimple_add_tmp_var,
486 point at which it really matters and possibly reached via paths not going
487 through this function, e.g. after direct calls to create_tmp_var_raw. */
488 gcc_assert (!TREE_ADDRESSABLE (type) && COMPLETE_TYPE_P (type));
490 tmp_var = create_tmp_var_raw (type, prefix);
491 gimple_add_tmp_var (tmp_var);
495 /* Given a tree, try to return a useful variable name that we can use
496 to prefix a temporary that is being assigned the value of the tree.
497 I.E. given <temp> = &A, return A. */
505 STRIP_NOPS (stripped_decl);
506 if (DECL_P (stripped_decl) && DECL_NAME (stripped_decl))
507 return IDENTIFIER_POINTER (DECL_NAME (stripped_decl));
510 switch (TREE_CODE (stripped_decl))
513 return get_name (TREE_OPERAND (stripped_decl, 0));
520 /* Create a temporary with a name derived from VAL. Subroutine of
521 lookup_tmp_var; nobody else should call this function. */
524 create_tmp_from_val (tree val)
526 return create_tmp_var (TYPE_MAIN_VARIANT (TREE_TYPE (val)), get_name (val));
529 /* Create a temporary to hold the value of VAL. If IS_FORMAL, try to reuse
530 an existing expression temporary. */
533 lookup_tmp_var (tree val, bool is_formal)
537 /* If not optimizing, never really reuse a temporary. local-alloc
538 won't allocate any variable that is used in more than one basic
539 block, which means it will go into memory, causing much extra
540 work in reload and final and poorer code generation, outweighing
541 the extra memory allocation here. */
542 if (!optimize || !is_formal || TREE_SIDE_EFFECTS (val))
543 ret = create_tmp_from_val (val);
550 slot = htab_find_slot (gimplify_ctxp->temp_htab, (void *)&elt, INSERT);
553 elt_p = XNEW (elt_t);
555 elt_p->temp = ret = create_tmp_from_val (val);
556 *slot = (void *) elt_p;
560 elt_p = (elt_t *) *slot;
566 DECL_GIMPLE_FORMAL_TEMP_P (ret) = 1;
571 /* Returns a formal temporary variable initialized with VAL. PRE_P is as
572 in gimplify_expr. Only use this function if:
574 1) The value of the unfactored expression represented by VAL will not
575 change between the initialization and use of the temporary, and
576 2) The temporary will not be otherwise modified.
578 For instance, #1 means that this is inappropriate for SAVE_EXPR temps,
579 and #2 means it is inappropriate for && temps.
581 For other cases, use get_initialized_tmp_var instead. */
584 internal_get_tmp_var (tree val, tree *pre_p, tree *post_p, bool is_formal)
588 gimplify_expr (&val, pre_p, post_p, is_gimple_formal_tmp_rhs, fb_rvalue);
590 t = lookup_tmp_var (val, is_formal);
594 tree u = find_single_pointer_decl (val);
596 if (u && TREE_CODE (u) == VAR_DECL && DECL_BASED_ON_RESTRICT_P (u))
597 u = DECL_GET_RESTRICT_BASE (u);
598 if (u && TYPE_RESTRICT (TREE_TYPE (u)))
600 if (DECL_BASED_ON_RESTRICT_P (t))
601 gcc_assert (u == DECL_GET_RESTRICT_BASE (t));
604 DECL_BASED_ON_RESTRICT_P (t) = 1;
605 SET_DECL_RESTRICT_BASE (t, u);
610 if (TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE
611 || TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
612 DECL_GIMPLE_REG_P (t) = 1;
614 mod = build2 (INIT_EXPR, TREE_TYPE (t), t, unshare_expr (val));
616 if (EXPR_HAS_LOCATION (val))
617 SET_EXPR_LOCUS (mod, EXPR_LOCUS (val));
619 SET_EXPR_LOCATION (mod, input_location);
621 /* gimplify_modify_expr might want to reduce this further. */
622 gimplify_and_add (mod, pre_p);
624 /* If we're gimplifying into ssa, gimplify_modify_expr will have
625 given our temporary an ssa name. Find and return it. */
626 if (gimplify_ctxp->into_ssa)
627 t = TREE_OPERAND (mod, 0);
632 /* Returns a formal temporary variable initialized with VAL. PRE_P
633 points to a statement list where side-effects needed to compute VAL
637 get_formal_tmp_var (tree val, tree *pre_p)
639 return internal_get_tmp_var (val, pre_p, NULL, true);
642 /* Returns a temporary variable initialized with VAL. PRE_P and POST_P
643 are as in gimplify_expr. */
646 get_initialized_tmp_var (tree val, tree *pre_p, tree *post_p)
648 return internal_get_tmp_var (val, pre_p, post_p, false);
651 /* Declares all the variables in VARS in SCOPE. If DEBUG_INFO is
652 true, generate debug info for them; otherwise don't. */
655 declare_vars (tree vars, tree scope, bool debug_info)
662 /* C99 mode puts the default 'return 0;' for main outside the outer
663 braces. So drill down until we find an actual scope. */
664 while (TREE_CODE (scope) == COMPOUND_EXPR)
665 scope = TREE_OPERAND (scope, 0);
667 gcc_assert (TREE_CODE (scope) == BIND_EXPR);
669 temps = nreverse (last);
671 block = BIND_EXPR_BLOCK (scope);
672 if (!block || !debug_info)
674 TREE_CHAIN (last) = BIND_EXPR_VARS (scope);
675 BIND_EXPR_VARS (scope) = temps;
679 /* We need to attach the nodes both to the BIND_EXPR and to its
680 associated BLOCK for debugging purposes. The key point here
681 is that the BLOCK_VARS of the BIND_EXPR_BLOCK of a BIND_EXPR
682 is a subchain of the BIND_EXPR_VARS of the BIND_EXPR. */
683 if (BLOCK_VARS (block))
684 BLOCK_VARS (block) = chainon (BLOCK_VARS (block), temps);
687 BIND_EXPR_VARS (scope) = chainon (BIND_EXPR_VARS (scope), temps);
688 BLOCK_VARS (block) = temps;
694 /* For VAR a VAR_DECL of variable size, try to find a constant upper bound
695 for the size and adjust DECL_SIZE/DECL_SIZE_UNIT accordingly. Abort if
696 no such upper bound can be obtained. */
699 force_constant_size (tree var)
701 /* The only attempt we make is by querying the maximum size of objects
702 of the variable's type. */
704 HOST_WIDE_INT max_size;
706 gcc_assert (TREE_CODE (var) == VAR_DECL);
708 max_size = max_int_size_in_bytes (TREE_TYPE (var));
710 gcc_assert (max_size >= 0);
713 = build_int_cst (TREE_TYPE (DECL_SIZE_UNIT (var)), max_size);
715 = build_int_cst (TREE_TYPE (DECL_SIZE (var)), max_size * BITS_PER_UNIT);
719 gimple_add_tmp_var (tree tmp)
721 gcc_assert (!TREE_CHAIN (tmp) && !DECL_SEEN_IN_BIND_EXPR_P (tmp));
723 /* Later processing assumes that the object size is constant, which might
724 not be true at this point. Force the use of a constant upper bound in
726 if (!host_integerp (DECL_SIZE_UNIT (tmp), 1))
727 force_constant_size (tmp);
729 DECL_CONTEXT (tmp) = current_function_decl;
730 DECL_SEEN_IN_BIND_EXPR_P (tmp) = 1;
734 TREE_CHAIN (tmp) = gimplify_ctxp->temps;
735 gimplify_ctxp->temps = tmp;
737 /* Mark temporaries local within the nearest enclosing parallel. */
738 if (gimplify_omp_ctxp)
740 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
741 while (ctx && !ctx->is_parallel)
742 ctx = ctx->outer_context;
744 omp_add_variable (ctx, tmp, GOVD_LOCAL | GOVD_SEEN);
750 declare_vars (tmp, DECL_SAVED_TREE (current_function_decl), false);
753 /* Determines whether to assign a locus to the statement STMT. */
756 should_carry_locus_p (tree stmt)
758 /* Don't emit a line note for a label. We particularly don't want to
759 emit one for the break label, since it doesn't actually correspond
760 to the beginning of the loop/switch. */
761 if (TREE_CODE (stmt) == LABEL_EXPR)
764 /* Do not annotate empty statements, since it confuses gcov. */
765 if (!TREE_SIDE_EFFECTS (stmt))
772 annotate_one_with_locus (tree t, location_t locus)
774 if (CAN_HAVE_LOCATION_P (t)
775 && ! EXPR_HAS_LOCATION (t) && should_carry_locus_p (t))
776 SET_EXPR_LOCATION (t, locus);
780 annotate_all_with_locus (tree *stmt_p, location_t locus)
782 tree_stmt_iterator i;
787 for (i = tsi_start (*stmt_p); !tsi_end_p (i); tsi_next (&i))
789 tree t = tsi_stmt (i);
791 /* Assuming we've already been gimplified, we shouldn't
792 see nested chaining constructs anymore. */
793 gcc_assert (TREE_CODE (t) != STATEMENT_LIST
794 && TREE_CODE (t) != COMPOUND_EXPR);
796 annotate_one_with_locus (t, locus);
800 /* Similar to copy_tree_r() but do not copy SAVE_EXPR or TARGET_EXPR nodes.
801 These nodes model computations that should only be done once. If we
802 were to unshare something like SAVE_EXPR(i++), the gimplification
803 process would create wrong code. */
806 mostly_copy_tree_r (tree *tp, int *walk_subtrees, void *data)
808 enum tree_code code = TREE_CODE (*tp);
809 /* Don't unshare types, decls, constants and SAVE_EXPR nodes. */
810 if (TREE_CODE_CLASS (code) == tcc_type
811 || TREE_CODE_CLASS (code) == tcc_declaration
812 || TREE_CODE_CLASS (code) == tcc_constant
813 || code == SAVE_EXPR || code == TARGET_EXPR
814 /* We can't do anything sensible with a BLOCK used as an expression,
815 but we also can't just die when we see it because of non-expression
816 uses. So just avert our eyes and cross our fingers. Silly Java. */
821 gcc_assert (code != BIND_EXPR);
822 copy_tree_r (tp, walk_subtrees, data);
828 /* Callback for walk_tree to unshare most of the shared trees rooted at
829 *TP. If *TP has been visited already (i.e., TREE_VISITED (*TP) == 1),
830 then *TP is deep copied by calling copy_tree_r.
832 This unshares the same trees as copy_tree_r with the exception of
833 SAVE_EXPR nodes. These nodes model computations that should only be
834 done once. If we were to unshare something like SAVE_EXPR(i++), the
835 gimplification process would create wrong code. */
838 copy_if_shared_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
839 void *data ATTRIBUTE_UNUSED)
842 enum tree_code code = TREE_CODE (t);
844 /* Skip types, decls, and constants. But we do want to look at their
845 types and the bounds of types. Mark them as visited so we properly
846 unmark their subtrees on the unmark pass. If we've already seen them,
847 don't look down further. */
848 if (TREE_CODE_CLASS (code) == tcc_type
849 || TREE_CODE_CLASS (code) == tcc_declaration
850 || TREE_CODE_CLASS (code) == tcc_constant)
852 if (TREE_VISITED (t))
855 TREE_VISITED (t) = 1;
858 /* If this node has been visited already, unshare it and don't look
860 else if (TREE_VISITED (t))
862 walk_tree (tp, mostly_copy_tree_r, NULL, NULL);
866 /* Otherwise, mark the tree as visited and keep looking. */
868 TREE_VISITED (t) = 1;
874 unmark_visited_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
875 void *data ATTRIBUTE_UNUSED)
877 if (TREE_VISITED (*tp))
878 TREE_VISITED (*tp) = 0;
885 /* Unshare all the trees in BODY_P, a pointer into the body of FNDECL, and the
886 bodies of any nested functions if we are unsharing the entire body of
890 unshare_body (tree *body_p, tree fndecl)
892 struct cgraph_node *cgn = cgraph_node (fndecl);
894 walk_tree (body_p, copy_if_shared_r, NULL, NULL);
895 if (body_p == &DECL_SAVED_TREE (fndecl))
896 for (cgn = cgn->nested; cgn; cgn = cgn->next_nested)
897 unshare_body (&DECL_SAVED_TREE (cgn->decl), cgn->decl);
900 /* Likewise, but mark all trees as not visited. */
903 unvisit_body (tree *body_p, tree fndecl)
905 struct cgraph_node *cgn = cgraph_node (fndecl);
907 walk_tree (body_p, unmark_visited_r, NULL, NULL);
908 if (body_p == &DECL_SAVED_TREE (fndecl))
909 for (cgn = cgn->nested; cgn; cgn = cgn->next_nested)
910 unvisit_body (&DECL_SAVED_TREE (cgn->decl), cgn->decl);
913 /* Unshare T and all the trees reached from T via TREE_CHAIN. */
916 unshare_all_trees (tree t)
918 walk_tree (&t, copy_if_shared_r, NULL, NULL);
919 walk_tree (&t, unmark_visited_r, NULL, NULL);
922 /* Unconditionally make an unshared copy of EXPR. This is used when using
923 stored expressions which span multiple functions, such as BINFO_VTABLE,
924 as the normal unsharing process can't tell that they're shared. */
927 unshare_expr (tree expr)
929 walk_tree (&expr, mostly_copy_tree_r, NULL, NULL);
933 /* A terser interface for building a representation of an exception
937 gimple_build_eh_filter (tree body, tree allowed, tree failure)
941 /* FIXME should the allowed types go in TREE_TYPE? */
942 t = build2 (EH_FILTER_EXPR, void_type_node, allowed, NULL_TREE);
943 append_to_statement_list (failure, &EH_FILTER_FAILURE (t));
945 t = build2 (TRY_CATCH_EXPR, void_type_node, NULL_TREE, t);
946 append_to_statement_list (body, &TREE_OPERAND (t, 0));
952 /* WRAPPER is a code such as BIND_EXPR or CLEANUP_POINT_EXPR which can both
953 contain statements and have a value. Assign its value to a temporary
954 and give it void_type_node. Returns the temporary, or NULL_TREE if
955 WRAPPER was already void. */
958 voidify_wrapper_expr (tree wrapper, tree temp)
960 tree type = TREE_TYPE (wrapper);
961 if (type && !VOID_TYPE_P (type))
965 /* Set p to point to the body of the wrapper. Loop until we find
966 something that isn't a wrapper. */
967 for (p = &wrapper; p && *p; )
969 switch (TREE_CODE (*p))
972 TREE_SIDE_EFFECTS (*p) = 1;
973 TREE_TYPE (*p) = void_type_node;
974 /* For a BIND_EXPR, the body is operand 1. */
975 p = &BIND_EXPR_BODY (*p);
978 case CLEANUP_POINT_EXPR:
979 case TRY_FINALLY_EXPR:
981 TREE_SIDE_EFFECTS (*p) = 1;
982 TREE_TYPE (*p) = void_type_node;
983 p = &TREE_OPERAND (*p, 0);
988 tree_stmt_iterator i = tsi_last (*p);
989 TREE_SIDE_EFFECTS (*p) = 1;
990 TREE_TYPE (*p) = void_type_node;
991 p = tsi_end_p (i) ? NULL : tsi_stmt_ptr (i);
996 /* Advance to the last statement. Set all container types to void. */
997 for (; TREE_CODE (*p) == COMPOUND_EXPR; p = &TREE_OPERAND (*p, 1))
999 TREE_SIDE_EFFECTS (*p) = 1;
1000 TREE_TYPE (*p) = void_type_node;
1010 if (p == NULL || IS_EMPTY_STMT (*p))
1014 /* The wrapper is on the RHS of an assignment that we're pushing
1016 gcc_assert (TREE_CODE (temp) == INIT_EXPR
1017 || TREE_CODE (temp) == GIMPLE_MODIFY_STMT
1018 || TREE_CODE (temp) == MODIFY_EXPR);
1019 GENERIC_TREE_OPERAND (temp, 1) = *p;
1024 temp = create_tmp_var (type, "retval");
1025 *p = build2 (INIT_EXPR, type, temp, *p);
1034 /* Prepare calls to builtins to SAVE and RESTORE the stack as well as
1035 a temporary through which they communicate. */
1038 build_stack_save_restore (tree *save, tree *restore)
1040 tree save_call, tmp_var;
1043 build_call_expr (implicit_built_in_decls[BUILT_IN_STACK_SAVE], 0);
1044 tmp_var = create_tmp_var (ptr_type_node, "saved_stack");
1046 *save = build_gimple_modify_stmt (tmp_var, save_call);
1048 build_call_expr (implicit_built_in_decls[BUILT_IN_STACK_RESTORE],
1052 /* Gimplify a BIND_EXPR. Just voidify and recurse. */
1054 static enum gimplify_status
1055 gimplify_bind_expr (tree *expr_p, tree *pre_p)
1057 tree bind_expr = *expr_p;
1058 bool old_save_stack = gimplify_ctxp->save_stack;
1061 tree temp = voidify_wrapper_expr (bind_expr, NULL);
1063 /* Mark variables seen in this bind expr. */
1064 for (t = BIND_EXPR_VARS (bind_expr); t ; t = TREE_CHAIN (t))
1066 if (TREE_CODE (t) == VAR_DECL)
1068 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
1070 /* Mark variable as local. */
1071 if (ctx && !is_global_var (t)
1072 && (! DECL_SEEN_IN_BIND_EXPR_P (t)
1073 || splay_tree_lookup (ctx->variables,
1074 (splay_tree_key) t) == NULL))
1075 omp_add_variable (gimplify_omp_ctxp, t, GOVD_LOCAL | GOVD_SEEN);
1077 DECL_SEEN_IN_BIND_EXPR_P (t) = 1;
1080 /* Preliminarily mark non-addressed complex variables as eligible
1081 for promotion to gimple registers. We'll transform their uses
1083 if ((TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE
1084 || TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
1085 && !TREE_THIS_VOLATILE (t)
1086 && (TREE_CODE (t) == VAR_DECL && !DECL_HARD_REGISTER (t))
1087 && !needs_to_live_in_memory (t))
1088 DECL_GIMPLE_REG_P (t) = 1;
1091 gimple_push_bind_expr (bind_expr);
1092 gimplify_ctxp->save_stack = false;
1094 gimplify_to_stmt_list (&BIND_EXPR_BODY (bind_expr));
1096 if (gimplify_ctxp->save_stack)
1098 tree stack_save, stack_restore;
1100 /* Save stack on entry and restore it on exit. Add a try_finally
1101 block to achieve this. Note that mudflap depends on the
1102 format of the emitted code: see mx_register_decls(). */
1103 build_stack_save_restore (&stack_save, &stack_restore);
1105 t = build2 (TRY_FINALLY_EXPR, void_type_node,
1106 BIND_EXPR_BODY (bind_expr), NULL_TREE);
1107 append_to_statement_list (stack_restore, &TREE_OPERAND (t, 1));
1109 BIND_EXPR_BODY (bind_expr) = NULL_TREE;
1110 append_to_statement_list (stack_save, &BIND_EXPR_BODY (bind_expr));
1111 append_to_statement_list (t, &BIND_EXPR_BODY (bind_expr));
1114 gimplify_ctxp->save_stack = old_save_stack;
1115 gimple_pop_bind_expr ();
1120 append_to_statement_list (bind_expr, pre_p);
1127 /* Gimplify a RETURN_EXPR. If the expression to be returned is not a
1128 GIMPLE value, it is assigned to a new temporary and the statement is
1129 re-written to return the temporary.
1131 PRE_P points to the list where side effects that must happen before
1132 STMT should be stored. */
1134 static enum gimplify_status
1135 gimplify_return_expr (tree stmt, tree *pre_p)
1137 tree ret_expr = TREE_OPERAND (stmt, 0);
1138 tree result_decl, result;
1140 if (!ret_expr || TREE_CODE (ret_expr) == RESULT_DECL
1141 || ret_expr == error_mark_node)
1144 if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl))))
1145 result_decl = NULL_TREE;
1148 result_decl = GENERIC_TREE_OPERAND (ret_expr, 0);
1149 if (TREE_CODE (result_decl) == INDIRECT_REF)
1150 /* See through a return by reference. */
1151 result_decl = TREE_OPERAND (result_decl, 0);
1153 gcc_assert ((TREE_CODE (ret_expr) == MODIFY_EXPR
1154 || TREE_CODE (ret_expr) == GIMPLE_MODIFY_STMT
1155 || TREE_CODE (ret_expr) == INIT_EXPR)
1156 && TREE_CODE (result_decl) == RESULT_DECL);
1159 /* If aggregate_value_p is true, then we can return the bare RESULT_DECL.
1160 Recall that aggregate_value_p is FALSE for any aggregate type that is
1161 returned in registers. If we're returning values in registers, then
1162 we don't want to extend the lifetime of the RESULT_DECL, particularly
1163 across another call. In addition, for those aggregates for which
1164 hard_function_value generates a PARALLEL, we'll die during normal
1165 expansion of structure assignments; there's special code in expand_return
1166 to handle this case that does not exist in expand_expr. */
1168 || aggregate_value_p (result_decl, TREE_TYPE (current_function_decl)))
1169 result = result_decl;
1170 else if (gimplify_ctxp->return_temp)
1171 result = gimplify_ctxp->return_temp;
1174 result = create_tmp_var (TREE_TYPE (result_decl), NULL);
1175 if (TREE_CODE (TREE_TYPE (result)) == COMPLEX_TYPE
1176 || TREE_CODE (TREE_TYPE (result)) == VECTOR_TYPE)
1177 DECL_GIMPLE_REG_P (result) = 1;
1179 /* ??? With complex control flow (usually involving abnormal edges),
1180 we can wind up warning about an uninitialized value for this. Due
1181 to how this variable is constructed and initialized, this is never
1182 true. Give up and never warn. */
1183 TREE_NO_WARNING (result) = 1;
1185 gimplify_ctxp->return_temp = result;
1188 /* Smash the lhs of the GIMPLE_MODIFY_STMT to the temporary we plan to use.
1189 Then gimplify the whole thing. */
1190 if (result != result_decl)
1191 GENERIC_TREE_OPERAND (ret_expr, 0) = result;
1193 gimplify_and_add (TREE_OPERAND (stmt, 0), pre_p);
1195 /* If we didn't use a temporary, then the result is just the result_decl.
1196 Otherwise we need a simple copy. This should already be gimple. */
1197 if (result == result_decl)
1200 ret_expr = build_gimple_modify_stmt (result_decl, result);
1201 TREE_OPERAND (stmt, 0) = ret_expr;
1206 /* Gimplifies a DECL_EXPR node *STMT_P by making any necessary allocation
1207 and initialization explicit. */
1209 static enum gimplify_status
1210 gimplify_decl_expr (tree *stmt_p)
1212 tree stmt = *stmt_p;
1213 tree decl = DECL_EXPR_DECL (stmt);
1215 *stmt_p = NULL_TREE;
1217 if (TREE_TYPE (decl) == error_mark_node)
1220 if ((TREE_CODE (decl) == TYPE_DECL
1221 || TREE_CODE (decl) == VAR_DECL)
1222 && !TYPE_SIZES_GIMPLIFIED (TREE_TYPE (decl)))
1223 gimplify_type_sizes (TREE_TYPE (decl), stmt_p);
1225 if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl))
1227 tree init = DECL_INITIAL (decl);
1229 if (TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
1231 /* This is a variable-sized decl. Simplify its size and mark it
1232 for deferred expansion. Note that mudflap depends on the format
1233 of the emitted code: see mx_register_decls(). */
1234 tree t, addr, ptr_type;
1236 gimplify_one_sizepos (&DECL_SIZE (decl), stmt_p);
1237 gimplify_one_sizepos (&DECL_SIZE_UNIT (decl), stmt_p);
1239 /* All occurrences of this decl in final gimplified code will be
1240 replaced by indirection. Setting DECL_VALUE_EXPR does two
1241 things: First, it lets the rest of the gimplifier know what
1242 replacement to use. Second, it lets the debug info know
1243 where to find the value. */
1244 ptr_type = build_pointer_type (TREE_TYPE (decl));
1245 addr = create_tmp_var (ptr_type, get_name (decl));
1246 DECL_IGNORED_P (addr) = 0;
1247 t = build_fold_indirect_ref (addr);
1248 SET_DECL_VALUE_EXPR (decl, t);
1249 DECL_HAS_VALUE_EXPR_P (decl) = 1;
1251 t = built_in_decls[BUILT_IN_ALLOCA];
1252 t = build_call_expr (t, 1, DECL_SIZE_UNIT (decl));
1253 t = fold_convert (ptr_type, t);
1254 t = build_gimple_modify_stmt (addr, t);
1256 gimplify_and_add (t, stmt_p);
1258 /* Indicate that we need to restore the stack level when the
1259 enclosing BIND_EXPR is exited. */
1260 gimplify_ctxp->save_stack = true;
1263 if (init && init != error_mark_node)
1265 if (!TREE_STATIC (decl))
1267 DECL_INITIAL (decl) = NULL_TREE;
1268 init = build2 (INIT_EXPR, void_type_node, decl, init);
1269 gimplify_and_add (init, stmt_p);
1272 /* We must still examine initializers for static variables
1273 as they may contain a label address. */
1274 walk_tree (&init, force_labels_r, NULL, NULL);
1277 /* Some front ends do not explicitly declare all anonymous
1278 artificial variables. We compensate here by declaring the
1279 variables, though it would be better if the front ends would
1280 explicitly declare them. */
1281 if (!DECL_SEEN_IN_BIND_EXPR_P (decl)
1282 && DECL_ARTIFICIAL (decl) && DECL_NAME (decl) == NULL_TREE)
1283 gimple_add_tmp_var (decl);
1289 /* Gimplify a LOOP_EXPR. Normally this just involves gimplifying the body
1290 and replacing the LOOP_EXPR with goto, but if the loop contains an
1291 EXIT_EXPR, we need to append a label for it to jump to. */
1293 static enum gimplify_status
1294 gimplify_loop_expr (tree *expr_p, tree *pre_p)
1296 tree saved_label = gimplify_ctxp->exit_label;
1297 tree start_label = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
1298 tree jump_stmt = build_and_jump (&LABEL_EXPR_LABEL (start_label));
1300 append_to_statement_list (start_label, pre_p);
1302 gimplify_ctxp->exit_label = NULL_TREE;
1304 gimplify_and_add (LOOP_EXPR_BODY (*expr_p), pre_p);
1306 if (gimplify_ctxp->exit_label)
1308 append_to_statement_list (jump_stmt, pre_p);
1309 *expr_p = build1 (LABEL_EXPR, void_type_node, gimplify_ctxp->exit_label);
1312 *expr_p = jump_stmt;
1314 gimplify_ctxp->exit_label = saved_label;
1319 /* Compare two case labels. Because the front end should already have
1320 made sure that case ranges do not overlap, it is enough to only compare
1321 the CASE_LOW values of each case label. */
1324 compare_case_labels (const void *p1, const void *p2)
1326 tree case1 = *(tree *)p1;
1327 tree case2 = *(tree *)p2;
1329 return tree_int_cst_compare (CASE_LOW (case1), CASE_LOW (case2));
1332 /* Sort the case labels in LABEL_VEC in place in ascending order. */
1335 sort_case_labels (tree label_vec)
1337 size_t len = TREE_VEC_LENGTH (label_vec);
1338 tree default_case = TREE_VEC_ELT (label_vec, len - 1);
1340 if (CASE_LOW (default_case))
1344 /* The last label in the vector should be the default case
1346 for (i = 0; i < len; ++i)
1348 tree t = TREE_VEC_ELT (label_vec, i);
1352 TREE_VEC_ELT (label_vec, i) = TREE_VEC_ELT (label_vec, len - 1);
1353 TREE_VEC_ELT (label_vec, len - 1) = default_case;
1359 qsort (&TREE_VEC_ELT (label_vec, 0), len - 1, sizeof (tree),
1360 compare_case_labels);
1363 /* Gimplify a SWITCH_EXPR, and collect a TREE_VEC of the labels it can
1366 static enum gimplify_status
1367 gimplify_switch_expr (tree *expr_p, tree *pre_p)
1369 tree switch_expr = *expr_p;
1370 enum gimplify_status ret;
1372 ret = gimplify_expr (&SWITCH_COND (switch_expr), pre_p, NULL,
1373 is_gimple_val, fb_rvalue);
1375 if (SWITCH_BODY (switch_expr))
1377 VEC(tree,heap) *labels, *saved_labels;
1378 tree label_vec, default_case = NULL_TREE;
1381 /* If someone can be bothered to fill in the labels, they can
1382 be bothered to null out the body too. */
1383 gcc_assert (!SWITCH_LABELS (switch_expr));
1385 saved_labels = gimplify_ctxp->case_labels;
1386 gimplify_ctxp->case_labels = VEC_alloc (tree, heap, 8);
1388 gimplify_to_stmt_list (&SWITCH_BODY (switch_expr));
1390 labels = gimplify_ctxp->case_labels;
1391 gimplify_ctxp->case_labels = saved_labels;
1394 while (i < VEC_length (tree, labels))
1396 tree elt = VEC_index (tree, labels, i);
1397 tree low = CASE_LOW (elt);
1398 bool remove_element = FALSE;
1402 /* Discard empty ranges. */
1403 tree high = CASE_HIGH (elt);
1404 if (high && INT_CST_LT (high, low))
1405 remove_element = TRUE;
1409 /* The default case must be the last label in the list. */
1410 gcc_assert (!default_case);
1412 remove_element = TRUE;
1416 VEC_ordered_remove (tree, labels, i);
1422 label_vec = make_tree_vec (len + 1);
1423 SWITCH_LABELS (*expr_p) = label_vec;
1424 append_to_statement_list (switch_expr, pre_p);
1428 /* If the switch has no default label, add one, so that we jump
1429 around the switch body. */
1430 default_case = build3 (CASE_LABEL_EXPR, void_type_node, NULL_TREE,
1431 NULL_TREE, create_artificial_label ());
1432 append_to_statement_list (SWITCH_BODY (switch_expr), pre_p);
1433 *expr_p = build1 (LABEL_EXPR, void_type_node,
1434 CASE_LABEL (default_case));
1437 *expr_p = SWITCH_BODY (switch_expr);
1439 for (i = 0; i < len; ++i)
1440 TREE_VEC_ELT (label_vec, i) = VEC_index (tree, labels, i);
1441 TREE_VEC_ELT (label_vec, len) = default_case;
1443 VEC_free (tree, heap, labels);
1445 sort_case_labels (label_vec);
1447 SWITCH_BODY (switch_expr) = NULL;
1450 gcc_assert (SWITCH_LABELS (switch_expr));
1455 static enum gimplify_status
1456 gimplify_case_label_expr (tree *expr_p)
1458 tree expr = *expr_p;
1459 struct gimplify_ctx *ctxp;
1461 /* Invalid OpenMP programs can play Duff's Device type games with
1462 #pragma omp parallel. At least in the C front end, we don't
1463 detect such invalid branches until after gimplification. */
1464 for (ctxp = gimplify_ctxp; ; ctxp = ctxp->prev_context)
1465 if (ctxp->case_labels)
1468 VEC_safe_push (tree, heap, ctxp->case_labels, expr);
1469 *expr_p = build1 (LABEL_EXPR, void_type_node, CASE_LABEL (expr));
1473 /* Build a GOTO to the LABEL_DECL pointed to by LABEL_P, building it first
1477 build_and_jump (tree *label_p)
1479 if (label_p == NULL)
1480 /* If there's nowhere to jump, just fall through. */
1483 if (*label_p == NULL_TREE)
1485 tree label = create_artificial_label ();
1489 return build1 (GOTO_EXPR, void_type_node, *label_p);
1492 /* Gimplify an EXIT_EXPR by converting to a GOTO_EXPR inside a COND_EXPR.
1493 This also involves building a label to jump to and communicating it to
1494 gimplify_loop_expr through gimplify_ctxp->exit_label. */
1496 static enum gimplify_status
1497 gimplify_exit_expr (tree *expr_p)
1499 tree cond = TREE_OPERAND (*expr_p, 0);
1502 expr = build_and_jump (&gimplify_ctxp->exit_label);
1503 expr = build3 (COND_EXPR, void_type_node, cond, expr, NULL_TREE);
1509 /* A helper function to be called via walk_tree. Mark all labels under *TP
1510 as being forced. To be called for DECL_INITIAL of static variables. */
1513 force_labels_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
1517 if (TREE_CODE (*tp) == LABEL_DECL)
1518 FORCED_LABEL (*tp) = 1;
1523 /* *EXPR_P is a COMPONENT_REF being used as an rvalue. If its type is
1524 different from its canonical type, wrap the whole thing inside a
1525 NOP_EXPR and force the type of the COMPONENT_REF to be the canonical
1528 The canonical type of a COMPONENT_REF is the type of the field being
1529 referenced--unless the field is a bit-field which can be read directly
1530 in a smaller mode, in which case the canonical type is the
1531 sign-appropriate type corresponding to that mode. */
1534 canonicalize_component_ref (tree *expr_p)
1536 tree expr = *expr_p;
1539 gcc_assert (TREE_CODE (expr) == COMPONENT_REF);
1541 if (INTEGRAL_TYPE_P (TREE_TYPE (expr)))
1542 type = TREE_TYPE (get_unwidened (expr, NULL_TREE));
1544 type = TREE_TYPE (TREE_OPERAND (expr, 1));
1546 if (TREE_TYPE (expr) != type)
1548 tree old_type = TREE_TYPE (expr);
1550 /* Set the type of the COMPONENT_REF to the underlying type. */
1551 TREE_TYPE (expr) = type;
1553 /* And wrap the whole thing inside a NOP_EXPR. */
1554 expr = build1 (NOP_EXPR, old_type, expr);
1560 /* If a NOP conversion is changing a pointer to array of foo to a pointer
1561 to foo, embed that change in the ADDR_EXPR by converting
1566 where L is the lower bound. For simplicity, only do this for constant
1570 canonicalize_addr_expr (tree *expr_p)
1572 tree expr = *expr_p;
1573 tree ctype = TREE_TYPE (expr);
1574 tree addr_expr = TREE_OPERAND (expr, 0);
1575 tree atype = TREE_TYPE (addr_expr);
1576 tree dctype, datype, ddatype, otype, obj_expr;
1578 /* Both cast and addr_expr types should be pointers. */
1579 if (!POINTER_TYPE_P (ctype) || !POINTER_TYPE_P (atype))
1582 /* The addr_expr type should be a pointer to an array. */
1583 datype = TREE_TYPE (atype);
1584 if (TREE_CODE (datype) != ARRAY_TYPE)
1587 /* Both cast and addr_expr types should address the same object type. */
1588 dctype = TREE_TYPE (ctype);
1589 ddatype = TREE_TYPE (datype);
1590 if (!lang_hooks.types_compatible_p (ddatype, dctype))
1593 /* The addr_expr and the object type should match. */
1594 obj_expr = TREE_OPERAND (addr_expr, 0);
1595 otype = TREE_TYPE (obj_expr);
1596 if (!lang_hooks.types_compatible_p (otype, datype))
1599 /* The lower bound and element sizes must be constant. */
1600 if (!TYPE_SIZE_UNIT (dctype)
1601 || TREE_CODE (TYPE_SIZE_UNIT (dctype)) != INTEGER_CST
1602 || !TYPE_DOMAIN (datype) || !TYPE_MIN_VALUE (TYPE_DOMAIN (datype))
1603 || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (datype))) != INTEGER_CST)
1606 /* All checks succeeded. Build a new node to merge the cast. */
1607 *expr_p = build4 (ARRAY_REF, dctype, obj_expr,
1608 TYPE_MIN_VALUE (TYPE_DOMAIN (datype)),
1609 TYPE_MIN_VALUE (TYPE_DOMAIN (datype)),
1610 size_binop (EXACT_DIV_EXPR, TYPE_SIZE_UNIT (dctype),
1611 size_int (TYPE_ALIGN_UNIT (dctype))));
1612 *expr_p = build1 (ADDR_EXPR, ctype, *expr_p);
1615 /* *EXPR_P is a NOP_EXPR or CONVERT_EXPR. Remove it and/or other conversions
1616 underneath as appropriate. */
1618 static enum gimplify_status
1619 gimplify_conversion (tree *expr_p)
1621 gcc_assert (TREE_CODE (*expr_p) == NOP_EXPR
1622 || TREE_CODE (*expr_p) == CONVERT_EXPR);
1624 /* Then strip away all but the outermost conversion. */
1625 STRIP_SIGN_NOPS (TREE_OPERAND (*expr_p, 0));
1627 /* And remove the outermost conversion if it's useless. */
1628 if (tree_ssa_useless_type_conversion (*expr_p))
1629 *expr_p = TREE_OPERAND (*expr_p, 0);
1631 /* If we still have a conversion at the toplevel,
1632 then canonicalize some constructs. */
1633 if (TREE_CODE (*expr_p) == NOP_EXPR || TREE_CODE (*expr_p) == CONVERT_EXPR)
1635 tree sub = TREE_OPERAND (*expr_p, 0);
1637 /* If a NOP conversion is changing the type of a COMPONENT_REF
1638 expression, then canonicalize its type now in order to expose more
1639 redundant conversions. */
1640 if (TREE_CODE (sub) == COMPONENT_REF)
1641 canonicalize_component_ref (&TREE_OPERAND (*expr_p, 0));
1643 /* If a NOP conversion is changing a pointer to array of foo
1644 to a pointer to foo, embed that change in the ADDR_EXPR. */
1645 else if (TREE_CODE (sub) == ADDR_EXPR)
1646 canonicalize_addr_expr (expr_p);
1652 /* Gimplify a VAR_DECL or PARM_DECL. Returns GS_OK if we expanded a
1653 DECL_VALUE_EXPR, and it's worth re-examining things. */
1655 static enum gimplify_status
1656 gimplify_var_or_parm_decl (tree *expr_p)
1658 tree decl = *expr_p;
1660 /* ??? If this is a local variable, and it has not been seen in any
1661 outer BIND_EXPR, then it's probably the result of a duplicate
1662 declaration, for which we've already issued an error. It would
1663 be really nice if the front end wouldn't leak these at all.
1664 Currently the only known culprit is C++ destructors, as seen
1665 in g++.old-deja/g++.jason/binding.C. */
1666 if (TREE_CODE (decl) == VAR_DECL
1667 && !DECL_SEEN_IN_BIND_EXPR_P (decl)
1668 && !TREE_STATIC (decl) && !DECL_EXTERNAL (decl)
1669 && decl_function_context (decl) == current_function_decl)
1671 gcc_assert (errorcount || sorrycount);
1675 /* When within an OpenMP context, notice uses of variables. */
1676 if (gimplify_omp_ctxp && omp_notice_variable (gimplify_omp_ctxp, decl, true))
1679 /* If the decl is an alias for another expression, substitute it now. */
1680 if (DECL_HAS_VALUE_EXPR_P (decl))
1682 *expr_p = unshare_expr (DECL_VALUE_EXPR (decl));
1690 /* Gimplify the COMPONENT_REF, ARRAY_REF, REALPART_EXPR or IMAGPART_EXPR
1691 node pointed to by EXPR_P.
1694 : min_lval '[' val ']'
1696 | compound_lval '[' val ']'
1697 | compound_lval '.' ID
1699 This is not part of the original SIMPLE definition, which separates
1700 array and member references, but it seems reasonable to handle them
1701 together. Also, this way we don't run into problems with union
1702 aliasing; gcc requires that for accesses through a union to alias, the
1703 union reference must be explicit, which was not always the case when we
1704 were splitting up array and member refs.
1706 PRE_P points to the list where side effects that must happen before
1707 *EXPR_P should be stored.
1709 POST_P points to the list where side effects that must happen after
1710 *EXPR_P should be stored. */
1712 static enum gimplify_status
1713 gimplify_compound_lval (tree *expr_p, tree *pre_p,
1714 tree *post_p, fallback_t fallback)
1717 VEC(tree,heap) *stack;
1718 enum gimplify_status ret = GS_OK, tret;
1721 /* Create a stack of the subexpressions so later we can walk them in
1722 order from inner to outer. */
1723 stack = VEC_alloc (tree, heap, 10);
1725 /* We can handle anything that get_inner_reference can deal with. */
1726 for (p = expr_p; ; p = &TREE_OPERAND (*p, 0))
1729 /* Fold INDIRECT_REFs now to turn them into ARRAY_REFs. */
1730 if (TREE_CODE (*p) == INDIRECT_REF)
1731 *p = fold_indirect_ref (*p);
1733 if (handled_component_p (*p))
1735 /* Expand DECL_VALUE_EXPR now. In some cases that may expose
1736 additional COMPONENT_REFs. */
1737 else if ((TREE_CODE (*p) == VAR_DECL || TREE_CODE (*p) == PARM_DECL)
1738 && gimplify_var_or_parm_decl (p) == GS_OK)
1743 VEC_safe_push (tree, heap, stack, *p);
1746 gcc_assert (VEC_length (tree, stack));
1748 /* Now STACK is a stack of pointers to all the refs we've walked through
1749 and P points to the innermost expression.
1751 Java requires that we elaborated nodes in source order. That
1752 means we must gimplify the inner expression followed by each of
1753 the indices, in order. But we can't gimplify the inner
1754 expression until we deal with any variable bounds, sizes, or
1755 positions in order to deal with PLACEHOLDER_EXPRs.
1757 So we do this in three steps. First we deal with the annotations
1758 for any variables in the components, then we gimplify the base,
1759 then we gimplify any indices, from left to right. */
1760 for (i = VEC_length (tree, stack) - 1; i >= 0; i--)
1762 tree t = VEC_index (tree, stack, i);
1764 if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
1766 /* Gimplify the low bound and element type size and put them into
1767 the ARRAY_REF. If these values are set, they have already been
1769 if (!TREE_OPERAND (t, 2))
1771 tree low = unshare_expr (array_ref_low_bound (t));
1772 if (!is_gimple_min_invariant (low))
1774 TREE_OPERAND (t, 2) = low;
1775 tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p,
1776 is_gimple_formal_tmp_reg, fb_rvalue);
1777 ret = MIN (ret, tret);
1781 if (!TREE_OPERAND (t, 3))
1783 tree elmt_type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (t, 0)));
1784 tree elmt_size = unshare_expr (array_ref_element_size (t));
1785 tree factor = size_int (TYPE_ALIGN_UNIT (elmt_type));
1787 /* Divide the element size by the alignment of the element
1789 elmt_size = size_binop (EXACT_DIV_EXPR, elmt_size, factor);
1791 if (!is_gimple_min_invariant (elmt_size))
1793 TREE_OPERAND (t, 3) = elmt_size;
1794 tret = gimplify_expr (&TREE_OPERAND (t, 3), pre_p, post_p,
1795 is_gimple_formal_tmp_reg, fb_rvalue);
1796 ret = MIN (ret, tret);
1800 else if (TREE_CODE (t) == COMPONENT_REF)
1802 /* Set the field offset into T and gimplify it. */
1803 if (!TREE_OPERAND (t, 2))
1805 tree offset = unshare_expr (component_ref_field_offset (t));
1806 tree field = TREE_OPERAND (t, 1);
1808 = size_int (DECL_OFFSET_ALIGN (field) / BITS_PER_UNIT);
1810 /* Divide the offset by its alignment. */
1811 offset = size_binop (EXACT_DIV_EXPR, offset, factor);
1813 if (!is_gimple_min_invariant (offset))
1815 TREE_OPERAND (t, 2) = offset;
1816 tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p,
1817 is_gimple_formal_tmp_reg, fb_rvalue);
1818 ret = MIN (ret, tret);
1824 /* Step 2 is to gimplify the base expression. Make sure lvalue is set
1825 so as to match the min_lval predicate. Failure to do so may result
1826 in the creation of large aggregate temporaries. */
1827 tret = gimplify_expr (p, pre_p, post_p, is_gimple_min_lval,
1828 fallback | fb_lvalue);
1829 ret = MIN (ret, tret);
1831 /* And finally, the indices and operands to BIT_FIELD_REF. During this
1832 loop we also remove any useless conversions. */
1833 for (; VEC_length (tree, stack) > 0; )
1835 tree t = VEC_pop (tree, stack);
1837 if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF)
1839 /* Gimplify the dimension.
1840 Temporary fix for gcc.c-torture/execute/20040313-1.c.
1841 Gimplify non-constant array indices into a temporary
1843 FIXME - The real fix is to gimplify post-modify
1844 expressions into a minimal gimple lvalue. However, that
1845 exposes bugs in alias analysis. The alias analyzer does
1846 not handle &PTR->FIELD very well. Will fix after the
1847 branch is merged into mainline (dnovillo 2004-05-03). */
1848 if (!is_gimple_min_invariant (TREE_OPERAND (t, 1)))
1850 tret = gimplify_expr (&TREE_OPERAND (t, 1), pre_p, post_p,
1851 is_gimple_formal_tmp_reg, fb_rvalue);
1852 ret = MIN (ret, tret);
1855 else if (TREE_CODE (t) == BIT_FIELD_REF)
1857 tret = gimplify_expr (&TREE_OPERAND (t, 1), pre_p, post_p,
1858 is_gimple_val, fb_rvalue);
1859 ret = MIN (ret, tret);
1860 tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p,
1861 is_gimple_val, fb_rvalue);
1862 ret = MIN (ret, tret);
1865 STRIP_USELESS_TYPE_CONVERSION (TREE_OPERAND (t, 0));
1867 /* The innermost expression P may have originally had TREE_SIDE_EFFECTS
1868 set which would have caused all the outer expressions in EXPR_P
1869 leading to P to also have had TREE_SIDE_EFFECTS set. */
1870 recalculate_side_effects (t);
1873 tret = gimplify_expr (p, pre_p, post_p, is_gimple_min_lval, fallback);
1874 ret = MIN (ret, tret);
1876 /* If the outermost expression is a COMPONENT_REF, canonicalize its type. */
1877 if ((fallback & fb_rvalue) && TREE_CODE (*expr_p) == COMPONENT_REF)
1879 canonicalize_component_ref (expr_p);
1880 ret = MIN (ret, GS_OK);
1883 VEC_free (tree, heap, stack);
1888 /* Gimplify the self modifying expression pointed to by EXPR_P
1891 PRE_P points to the list where side effects that must happen before
1892 *EXPR_P should be stored.
1894 POST_P points to the list where side effects that must happen after
1895 *EXPR_P should be stored.
1897 WANT_VALUE is nonzero iff we want to use the value of this expression
1898 in another expression. */
1900 static enum gimplify_status
1901 gimplify_self_mod_expr (tree *expr_p, tree *pre_p, tree *post_p,
1904 enum tree_code code;
1905 tree lhs, lvalue, rhs, t1, post = NULL, *orig_post_p = post_p;
1907 enum tree_code arith_code;
1908 enum gimplify_status ret;
1910 code = TREE_CODE (*expr_p);
1912 gcc_assert (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR
1913 || code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR);
1915 /* Prefix or postfix? */
1916 if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
1917 /* Faster to treat as prefix if result is not used. */
1918 postfix = want_value;
1922 /* For postfix, make sure the inner expression's post side effects
1923 are executed after side effects from this expression. */
1927 /* Add or subtract? */
1928 if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR)
1929 arith_code = PLUS_EXPR;
1931 arith_code = MINUS_EXPR;
1933 /* Gimplify the LHS into a GIMPLE lvalue. */
1934 lvalue = TREE_OPERAND (*expr_p, 0);
1935 ret = gimplify_expr (&lvalue, pre_p, post_p, is_gimple_lvalue, fb_lvalue);
1936 if (ret == GS_ERROR)
1939 /* Extract the operands to the arithmetic operation. */
1941 rhs = TREE_OPERAND (*expr_p, 1);
1943 /* For postfix operator, we evaluate the LHS to an rvalue and then use
1944 that as the result value and in the postqueue operation. */
1947 ret = gimplify_expr (&lhs, pre_p, post_p, is_gimple_val, fb_rvalue);
1948 if (ret == GS_ERROR)
1952 t1 = build2 (arith_code, TREE_TYPE (*expr_p), lhs, rhs);
1953 t1 = build_gimple_modify_stmt (lvalue, t1);
1957 gimplify_and_add (t1, orig_post_p);
1958 append_to_statement_list (post, orig_post_p);
1969 /* If *EXPR_P has a variable sized type, wrap it in a WITH_SIZE_EXPR. */
1972 maybe_with_size_expr (tree *expr_p)
1974 tree expr = *expr_p;
1975 tree type = TREE_TYPE (expr);
1978 /* If we've already wrapped this or the type is error_mark_node, we can't do
1980 if (TREE_CODE (expr) == WITH_SIZE_EXPR
1981 || type == error_mark_node)
1984 /* If the size isn't known or is a constant, we have nothing to do. */
1985 size = TYPE_SIZE_UNIT (type);
1986 if (!size || TREE_CODE (size) == INTEGER_CST)
1989 /* Otherwise, make a WITH_SIZE_EXPR. */
1990 size = unshare_expr (size);
1991 size = SUBSTITUTE_PLACEHOLDER_IN_EXPR (size, expr);
1992 *expr_p = build2 (WITH_SIZE_EXPR, type, expr, size);
1995 /* Subroutine of gimplify_call_expr: Gimplify a single argument. */
1997 static enum gimplify_status
1998 gimplify_arg (tree *expr_p, tree *pre_p)
2000 bool (*test) (tree);
2003 /* In general, we allow lvalues for function arguments to avoid
2004 extra overhead of copying large aggregates out of even larger
2005 aggregates into temporaries only to copy the temporaries to
2006 the argument list. Make optimizers happy by pulling out to
2007 temporaries those types that fit in registers. */
2008 if (is_gimple_reg_type (TREE_TYPE (*expr_p)))
2009 test = is_gimple_val, fb = fb_rvalue;
2011 test = is_gimple_lvalue, fb = fb_either;
2013 /* If this is a variable sized type, we must remember the size. */
2014 maybe_with_size_expr (expr_p);
2016 /* There is a sequence point before a function call. Side effects in
2017 the argument list must occur before the actual call. So, when
2018 gimplifying arguments, force gimplify_expr to use an internal
2019 post queue which is then appended to the end of PRE_P. */
2020 return gimplify_expr (expr_p, pre_p, NULL, test, fb);
2023 /* Gimplify the CALL_EXPR node pointed to by EXPR_P. PRE_P points to the
2024 list where side effects that must happen before *EXPR_P should be stored.
2025 WANT_VALUE is true if the result of the call is desired. */
2027 static enum gimplify_status
2028 gimplify_call_expr (tree *expr_p, tree *pre_p, bool want_value)
2031 enum gimplify_status ret;
2034 gcc_assert (TREE_CODE (*expr_p) == CALL_EXPR);
2036 /* For reliable diagnostics during inlining, it is necessary that
2037 every call_expr be annotated with file and line. */
2038 if (! EXPR_HAS_LOCATION (*expr_p))
2039 SET_EXPR_LOCATION (*expr_p, input_location);
2041 /* This may be a call to a builtin function.
2043 Builtin function calls may be transformed into different
2044 (and more efficient) builtin function calls under certain
2045 circumstances. Unfortunately, gimplification can muck things
2046 up enough that the builtin expanders are not aware that certain
2047 transformations are still valid.
2049 So we attempt transformation/gimplification of the call before
2050 we gimplify the CALL_EXPR. At this time we do not manage to
2051 transform all calls in the same manner as the expanders do, but
2052 we do transform most of them. */
2053 decl = get_callee_fndecl (*expr_p);
2054 if (decl && DECL_BUILT_IN (decl))
2056 tree new = fold_call_expr (*expr_p, !want_value);
2058 if (new && new != *expr_p)
2060 /* There was a transformation of this call which computes the
2061 same value, but in a more efficient way. Return and try
2067 if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
2068 && DECL_FUNCTION_CODE (decl) == BUILT_IN_VA_START)
2070 if (call_expr_nargs (*expr_p) < 2)
2072 error ("too few arguments to function %<va_start%>");
2073 *expr_p = build_empty_stmt ();
2077 if (fold_builtin_next_arg (*expr_p, true))
2079 *expr_p = build_empty_stmt ();
2082 /* Avoid gimplifying the second argument to va_start, which needs
2083 to be the plain PARM_DECL. */
2084 return gimplify_arg (&CALL_EXPR_ARG (*expr_p, 0), pre_p);
2088 /* There is a sequence point before the call, so any side effects in
2089 the calling expression must occur before the actual call. Force
2090 gimplify_expr to use an internal post queue. */
2091 ret = gimplify_expr (&CALL_EXPR_FN (*expr_p), pre_p, NULL,
2092 is_gimple_call_addr, fb_rvalue);
2094 nargs = call_expr_nargs (*expr_p);
2096 for (i = (PUSH_ARGS_REVERSED ? nargs - 1 : 0);
2097 PUSH_ARGS_REVERSED ? i >= 0 : i < nargs;
2098 PUSH_ARGS_REVERSED ? i-- : i++)
2100 enum gimplify_status t;
2102 t = gimplify_arg (&CALL_EXPR_ARG (*expr_p, i), pre_p);
2108 /* Try this again in case gimplification exposed something. */
2109 if (ret != GS_ERROR)
2111 tree new = fold_call_expr (*expr_p, !want_value);
2113 if (new && new != *expr_p)
2115 /* There was a transformation of this call which computes the
2116 same value, but in a more efficient way. Return and try
2123 /* If the function is "const" or "pure", then clear TREE_SIDE_EFFECTS on its
2124 decl. This allows us to eliminate redundant or useless
2125 calls to "const" functions. */
2126 if (TREE_CODE (*expr_p) == CALL_EXPR
2127 && (call_expr_flags (*expr_p) & (ECF_CONST | ECF_PURE)))
2128 TREE_SIDE_EFFECTS (*expr_p) = 0;
2133 /* Handle shortcut semantics in the predicate operand of a COND_EXPR by
2134 rewriting it into multiple COND_EXPRs, and possibly GOTO_EXPRs.
2136 TRUE_LABEL_P and FALSE_LABEL_P point to the labels to jump to if the
2137 condition is true or false, respectively. If null, we should generate
2138 our own to skip over the evaluation of this specific expression.
2140 This function is the tree equivalent of do_jump.
2142 shortcut_cond_r should only be called by shortcut_cond_expr. */
2145 shortcut_cond_r (tree pred, tree *true_label_p, tree *false_label_p)
2147 tree local_label = NULL_TREE;
2148 tree t, expr = NULL;
2150 /* OK, it's not a simple case; we need to pull apart the COND_EXPR to
2151 retain the shortcut semantics. Just insert the gotos here;
2152 shortcut_cond_expr will append the real blocks later. */
2153 if (TREE_CODE (pred) == TRUTH_ANDIF_EXPR)
2155 /* Turn if (a && b) into
2157 if (a); else goto no;
2158 if (b) goto yes; else goto no;
2161 if (false_label_p == NULL)
2162 false_label_p = &local_label;
2164 t = shortcut_cond_r (TREE_OPERAND (pred, 0), NULL, false_label_p);
2165 append_to_statement_list (t, &expr);
2167 t = shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p,
2169 append_to_statement_list (t, &expr);
2171 else if (TREE_CODE (pred) == TRUTH_ORIF_EXPR)
2173 /* Turn if (a || b) into
2176 if (b) goto yes; else goto no;
2179 if (true_label_p == NULL)
2180 true_label_p = &local_label;
2182 t = shortcut_cond_r (TREE_OPERAND (pred, 0), true_label_p, NULL);
2183 append_to_statement_list (t, &expr);
2185 t = shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p,
2187 append_to_statement_list (t, &expr);
2189 else if (TREE_CODE (pred) == COND_EXPR)
2191 /* As long as we're messing with gotos, turn if (a ? b : c) into
2193 if (b) goto yes; else goto no;
2195 if (c) goto yes; else goto no; */
2196 expr = build3 (COND_EXPR, void_type_node, TREE_OPERAND (pred, 0),
2197 shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p,
2199 shortcut_cond_r (TREE_OPERAND (pred, 2), true_label_p,
2204 expr = build3 (COND_EXPR, void_type_node, pred,
2205 build_and_jump (true_label_p),
2206 build_and_jump (false_label_p));
2211 t = build1 (LABEL_EXPR, void_type_node, local_label);
2212 append_to_statement_list (t, &expr);
2219 shortcut_cond_expr (tree expr)
2221 tree pred = TREE_OPERAND (expr, 0);
2222 tree then_ = TREE_OPERAND (expr, 1);
2223 tree else_ = TREE_OPERAND (expr, 2);
2224 tree true_label, false_label, end_label, t;
2226 tree *false_label_p;
2227 bool emit_end, emit_false, jump_over_else;
2228 bool then_se = then_ && TREE_SIDE_EFFECTS (then_);
2229 bool else_se = else_ && TREE_SIDE_EFFECTS (else_);
2231 /* First do simple transformations. */
2234 /* If there is no 'else', turn (a && b) into if (a) if (b). */
2235 while (TREE_CODE (pred) == TRUTH_ANDIF_EXPR)
2237 TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1);
2238 then_ = shortcut_cond_expr (expr);
2239 then_se = then_ && TREE_SIDE_EFFECTS (then_);
2240 pred = TREE_OPERAND (pred, 0);
2241 expr = build3 (COND_EXPR, void_type_node, pred, then_, NULL_TREE);
2246 /* If there is no 'then', turn
2249 if (a); else if (b); else d. */
2250 while (TREE_CODE (pred) == TRUTH_ORIF_EXPR)
2252 TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1);
2253 else_ = shortcut_cond_expr (expr);
2254 else_se = else_ && TREE_SIDE_EFFECTS (else_);
2255 pred = TREE_OPERAND (pred, 0);
2256 expr = build3 (COND_EXPR, void_type_node, pred, NULL_TREE, else_);
2260 /* If we're done, great. */
2261 if (TREE_CODE (pred) != TRUTH_ANDIF_EXPR
2262 && TREE_CODE (pred) != TRUTH_ORIF_EXPR)
2265 /* Otherwise we need to mess with gotos. Change
2268 if (a); else goto no;
2271 and recursively gimplify the condition. */
2273 true_label = false_label = end_label = NULL_TREE;
2275 /* If our arms just jump somewhere, hijack those labels so we don't
2276 generate jumps to jumps. */
2279 && TREE_CODE (then_) == GOTO_EXPR
2280 && TREE_CODE (GOTO_DESTINATION (then_)) == LABEL_DECL)
2282 true_label = GOTO_DESTINATION (then_);
2288 && TREE_CODE (else_) == GOTO_EXPR
2289 && TREE_CODE (GOTO_DESTINATION (else_)) == LABEL_DECL)
2291 false_label = GOTO_DESTINATION (else_);
2296 /* If we aren't hijacking a label for the 'then' branch, it falls through. */
2298 true_label_p = &true_label;
2300 true_label_p = NULL;
2302 /* The 'else' branch also needs a label if it contains interesting code. */
2303 if (false_label || else_se)
2304 false_label_p = &false_label;
2306 false_label_p = NULL;
2308 /* If there was nothing else in our arms, just forward the label(s). */
2309 if (!then_se && !else_se)
2310 return shortcut_cond_r (pred, true_label_p, false_label_p);
2312 /* If our last subexpression already has a terminal label, reuse it. */
2314 expr = expr_last (else_);
2316 expr = expr_last (then_);
2319 if (expr && TREE_CODE (expr) == LABEL_EXPR)
2320 end_label = LABEL_EXPR_LABEL (expr);
2322 /* If we don't care about jumping to the 'else' branch, jump to the end
2323 if the condition is false. */
2325 false_label_p = &end_label;
2327 /* We only want to emit these labels if we aren't hijacking them. */
2328 emit_end = (end_label == NULL_TREE);
2329 emit_false = (false_label == NULL_TREE);
2331 /* We only emit the jump over the else clause if we have to--if the
2332 then clause may fall through. Otherwise we can wind up with a
2333 useless jump and a useless label at the end of gimplified code,
2334 which will cause us to think that this conditional as a whole
2335 falls through even if it doesn't. If we then inline a function
2336 which ends with such a condition, that can cause us to issue an
2337 inappropriate warning about control reaching the end of a
2338 non-void function. */
2339 jump_over_else = block_may_fallthru (then_);
2341 pred = shortcut_cond_r (pred, true_label_p, false_label_p);
2344 append_to_statement_list (pred, &expr);
2346 append_to_statement_list (then_, &expr);
2351 t = build_and_jump (&end_label);
2352 append_to_statement_list (t, &expr);
2356 t = build1 (LABEL_EXPR, void_type_node, false_label);
2357 append_to_statement_list (t, &expr);
2359 append_to_statement_list (else_, &expr);
2361 if (emit_end && end_label)
2363 t = build1 (LABEL_EXPR, void_type_node, end_label);
2364 append_to_statement_list (t, &expr);
2370 /* EXPR is used in a boolean context; make sure it has BOOLEAN_TYPE. */
2373 gimple_boolify (tree expr)
2375 tree type = TREE_TYPE (expr);
2377 if (TREE_CODE (type) == BOOLEAN_TYPE)
2380 switch (TREE_CODE (expr))
2382 case TRUTH_AND_EXPR:
2384 case TRUTH_XOR_EXPR:
2385 case TRUTH_ANDIF_EXPR:
2386 case TRUTH_ORIF_EXPR:
2387 /* Also boolify the arguments of truth exprs. */
2388 TREE_OPERAND (expr, 1) = gimple_boolify (TREE_OPERAND (expr, 1));
2391 case TRUTH_NOT_EXPR:
2392 TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0));
2395 case EQ_EXPR: case NE_EXPR:
2396 case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
2397 /* These expressions always produce boolean results. */
2398 TREE_TYPE (expr) = boolean_type_node;
2402 /* Other expressions that get here must have boolean values, but
2403 might need to be converted to the appropriate mode. */
2404 return fold_convert (boolean_type_node, expr);
2408 /* Convert the conditional expression pointed to by EXPR_P '(p) ? a : b;'
2417 The second form is used when *EXPR_P is of type void.
2419 TARGET is the tree for T1 above.
2421 PRE_P points to the list where side effects that must happen before
2422 *EXPR_P should be stored. */
2424 static enum gimplify_status
2425 gimplify_cond_expr (tree *expr_p, tree *pre_p, fallback_t fallback)
2427 tree expr = *expr_p;
2428 tree tmp, tmp2, type;
2429 enum gimplify_status ret;
2431 type = TREE_TYPE (expr);
2433 /* If this COND_EXPR has a value, copy the values into a temporary within
2435 if (! VOID_TYPE_P (type))
2439 if ((fallback & fb_lvalue) == 0)
2441 result = tmp2 = tmp = create_tmp_var (TREE_TYPE (expr), "iftmp");
2446 tree type = build_pointer_type (TREE_TYPE (expr));
2448 if (TREE_TYPE (TREE_OPERAND (expr, 1)) != void_type_node)
2449 TREE_OPERAND (expr, 1) =
2450 build_fold_addr_expr (TREE_OPERAND (expr, 1));
2452 if (TREE_TYPE (TREE_OPERAND (expr, 2)) != void_type_node)
2453 TREE_OPERAND (expr, 2) =
2454 build_fold_addr_expr (TREE_OPERAND (expr, 2));
2456 tmp2 = tmp = create_tmp_var (type, "iftmp");
2458 expr = build3 (COND_EXPR, void_type_node, TREE_OPERAND (expr, 0),
2459 TREE_OPERAND (expr, 1), TREE_OPERAND (expr, 2));
2461 result = build_fold_indirect_ref (tmp);
2465 /* Build the then clause, 't1 = a;'. But don't build an assignment
2466 if this branch is void; in C++ it can be, if it's a throw. */
2467 if (TREE_TYPE (TREE_OPERAND (expr, 1)) != void_type_node)
2468 TREE_OPERAND (expr, 1)
2469 = build_gimple_modify_stmt (tmp, TREE_OPERAND (expr, 1));
2471 /* Build the else clause, 't1 = b;'. */
2472 if (TREE_TYPE (TREE_OPERAND (expr, 2)) != void_type_node)
2473 TREE_OPERAND (expr, 2)
2474 = build_gimple_modify_stmt (tmp2, TREE_OPERAND (expr, 2));
2476 TREE_TYPE (expr) = void_type_node;
2477 recalculate_side_effects (expr);
2479 /* Move the COND_EXPR to the prequeue. */
2480 gimplify_and_add (expr, pre_p);
2486 /* Make sure the condition has BOOLEAN_TYPE. */
2487 TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0));
2489 /* Break apart && and || conditions. */
2490 if (TREE_CODE (TREE_OPERAND (expr, 0)) == TRUTH_ANDIF_EXPR
2491 || TREE_CODE (TREE_OPERAND (expr, 0)) == TRUTH_ORIF_EXPR)
2493 expr = shortcut_cond_expr (expr);
2495 if (expr != *expr_p)
2499 /* We can't rely on gimplify_expr to re-gimplify the expanded
2500 form properly, as cleanups might cause the target labels to be
2501 wrapped in a TRY_FINALLY_EXPR. To prevent that, we need to
2502 set up a conditional context. */
2503 gimple_push_condition ();
2504 gimplify_stmt (expr_p);
2505 gimple_pop_condition (pre_p);
2511 /* Now do the normal gimplification. */
2512 ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, NULL,
2513 is_gimple_condexpr, fb_rvalue);
2515 gimple_push_condition ();
2517 gimplify_to_stmt_list (&TREE_OPERAND (expr, 1));
2518 gimplify_to_stmt_list (&TREE_OPERAND (expr, 2));
2519 recalculate_side_effects (expr);
2521 gimple_pop_condition (pre_p);
2523 if (ret == GS_ERROR)
2525 else if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2527 else if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 2)))
2528 /* Rewrite "if (a); else b" to "if (!a) b" */
2530 TREE_OPERAND (expr, 0) = invert_truthvalue (TREE_OPERAND (expr, 0));
2531 ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, NULL,
2532 is_gimple_condexpr, fb_rvalue);
2534 tmp = TREE_OPERAND (expr, 1);
2535 TREE_OPERAND (expr, 1) = TREE_OPERAND (expr, 2);
2536 TREE_OPERAND (expr, 2) = tmp;
2539 /* Both arms are empty; replace the COND_EXPR with its predicate. */
2540 expr = TREE_OPERAND (expr, 0);
2546 /* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with
2547 a call to __builtin_memcpy. */
2549 static enum gimplify_status
2550 gimplify_modify_expr_to_memcpy (tree *expr_p, tree size, bool want_value)
2552 tree t, to, to_ptr, from, from_ptr;
2554 to = GENERIC_TREE_OPERAND (*expr_p, 0);
2555 from = GENERIC_TREE_OPERAND (*expr_p, 1);
2557 from_ptr = build_fold_addr_expr (from);
2559 to_ptr = build_fold_addr_expr (to);
2560 t = implicit_built_in_decls[BUILT_IN_MEMCPY];
2561 t = build_call_expr (t, 3, to_ptr, from_ptr, size);
2565 t = build1 (NOP_EXPR, TREE_TYPE (to_ptr), t);
2566 t = build1 (INDIRECT_REF, TREE_TYPE (to), t);
2573 /* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with
2574 a call to __builtin_memset. In this case we know that the RHS is
2575 a CONSTRUCTOR with an empty element list. */
2577 static enum gimplify_status
2578 gimplify_modify_expr_to_memset (tree *expr_p, tree size, bool want_value)
2582 to = GENERIC_TREE_OPERAND (*expr_p, 0);
2584 to_ptr = build_fold_addr_expr (to);
2585 t = implicit_built_in_decls[BUILT_IN_MEMSET];
2586 t = build_call_expr (t, 3, to_ptr, integer_zero_node, size);
2590 t = build1 (NOP_EXPR, TREE_TYPE (to_ptr), t);
2591 t = build1 (INDIRECT_REF, TREE_TYPE (to), t);
2598 /* A subroutine of gimplify_init_ctor_preeval. Called via walk_tree,
2599 determine, cautiously, if a CONSTRUCTOR overlaps the lhs of an
2600 assignment. Returns non-null if we detect a potential overlap. */
2602 struct gimplify_init_ctor_preeval_data
2604 /* The base decl of the lhs object. May be NULL, in which case we
2605 have to assume the lhs is indirect. */
2608 /* The alias set of the lhs object. */
2613 gimplify_init_ctor_preeval_1 (tree *tp, int *walk_subtrees, void *xdata)
2615 struct gimplify_init_ctor_preeval_data *data
2616 = (struct gimplify_init_ctor_preeval_data *) xdata;
2619 /* If we find the base object, obviously we have overlap. */
2620 if (data->lhs_base_decl == t)
2623 /* If the constructor component is indirect, determine if we have a
2624 potential overlap with the lhs. The only bits of information we
2625 have to go on at this point are addressability and alias sets. */
2626 if (TREE_CODE (t) == INDIRECT_REF
2627 && (!data->lhs_base_decl || TREE_ADDRESSABLE (data->lhs_base_decl))
2628 && alias_sets_conflict_p (data->lhs_alias_set, get_alias_set (t)))
2631 if (IS_TYPE_OR_DECL_P (t))
2636 /* A subroutine of gimplify_init_constructor. Pre-evaluate *EXPR_P,
2637 force values that overlap with the lhs (as described by *DATA)
2638 into temporaries. */
2641 gimplify_init_ctor_preeval (tree *expr_p, tree *pre_p, tree *post_p,
2642 struct gimplify_init_ctor_preeval_data *data)
2644 enum gimplify_status one;
2646 /* If the value is invariant, then there's nothing to pre-evaluate.
2647 But ensure it doesn't have any side-effects since a SAVE_EXPR is
2648 invariant but has side effects and might contain a reference to
2649 the object we're initializing. */
2650 if (TREE_INVARIANT (*expr_p) && !TREE_SIDE_EFFECTS (*expr_p))
2653 /* If the type has non-trivial constructors, we can't pre-evaluate. */
2654 if (TREE_ADDRESSABLE (TREE_TYPE (*expr_p)))
2657 /* Recurse for nested constructors. */
2658 if (TREE_CODE (*expr_p) == CONSTRUCTOR)
2660 unsigned HOST_WIDE_INT ix;
2661 constructor_elt *ce;
2662 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (*expr_p);
2664 for (ix = 0; VEC_iterate (constructor_elt, v, ix, ce); ix++)
2665 gimplify_init_ctor_preeval (&ce->value, pre_p, post_p, data);
2669 /* If this is a variable sized type, we must remember the size. */
2670 maybe_with_size_expr (expr_p);
2672 /* Gimplify the constructor element to something appropriate for the rhs
2673 of a MODIFY_EXPR. Given that we know the lhs is an aggregate, we know
2674 the gimplifier will consider this a store to memory. Doing this
2675 gimplification now means that we won't have to deal with complicated
2676 language-specific trees, nor trees like SAVE_EXPR that can induce
2677 exponential search behavior. */
2678 one = gimplify_expr (expr_p, pre_p, post_p, is_gimple_mem_rhs, fb_rvalue);
2679 if (one == GS_ERROR)
2685 /* If we gimplified to a bare decl, we can be sure that it doesn't overlap
2686 with the lhs, since "a = { .x=a }" doesn't make sense. This will
2687 always be true for all scalars, since is_gimple_mem_rhs insists on a
2688 temporary variable for them. */
2689 if (DECL_P (*expr_p))
2692 /* If this is of variable size, we have no choice but to assume it doesn't
2693 overlap since we can't make a temporary for it. */
2694 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (*expr_p))) != INTEGER_CST)
2697 /* Otherwise, we must search for overlap ... */
2698 if (!walk_tree (expr_p, gimplify_init_ctor_preeval_1, data, NULL))
2701 /* ... and if found, force the value into a temporary. */
2702 *expr_p = get_formal_tmp_var (*expr_p, pre_p);
2705 /* A subroutine of gimplify_init_ctor_eval. Create a loop for
2706 a RANGE_EXPR in a CONSTRUCTOR for an array.
2710 object[var] = value;
2717 We increment var _after_ the loop exit check because we might otherwise
2718 fail if upper == TYPE_MAX_VALUE (type for upper).
2720 Note that we never have to deal with SAVE_EXPRs here, because this has
2721 already been taken care of for us, in gimplify_init_ctor_preeval(). */
2723 static void gimplify_init_ctor_eval (tree, VEC(constructor_elt,gc) *,
2727 gimplify_init_ctor_eval_range (tree object, tree lower, tree upper,
2728 tree value, tree array_elt_type,
2729 tree *pre_p, bool cleared)
2731 tree loop_entry_label, loop_exit_label;
2732 tree var, var_type, cref, tmp;
2734 loop_entry_label = create_artificial_label ();
2735 loop_exit_label = create_artificial_label ();
2737 /* Create and initialize the index variable. */
2738 var_type = TREE_TYPE (upper);
2739 var = create_tmp_var (var_type, NULL);
2740 append_to_statement_list (build_gimple_modify_stmt (var, lower), pre_p);
2742 /* Add the loop entry label. */
2743 append_to_statement_list (build1 (LABEL_EXPR,
2748 /* Build the reference. */
2749 cref = build4 (ARRAY_REF, array_elt_type, unshare_expr (object),
2750 var, NULL_TREE, NULL_TREE);
2752 /* If we are a constructor, just call gimplify_init_ctor_eval to do
2753 the store. Otherwise just assign value to the reference. */
2755 if (TREE_CODE (value) == CONSTRUCTOR)
2756 /* NB we might have to call ourself recursively through
2757 gimplify_init_ctor_eval if the value is a constructor. */
2758 gimplify_init_ctor_eval (cref, CONSTRUCTOR_ELTS (value),
2761 append_to_statement_list (build_gimple_modify_stmt (cref, value), pre_p);
2763 /* We exit the loop when the index var is equal to the upper bound. */
2764 gimplify_and_add (build3 (COND_EXPR, void_type_node,
2765 build2 (EQ_EXPR, boolean_type_node,
2773 /* Otherwise, increment the index var... */
2774 tmp = build2 (PLUS_EXPR, var_type, var,
2775 fold_convert (var_type, integer_one_node));
2776 append_to_statement_list (build_gimple_modify_stmt (var, tmp), pre_p);
2778 /* ...and jump back to the loop entry. */
2779 append_to_statement_list (build1 (GOTO_EXPR,
2784 /* Add the loop exit label. */
2785 append_to_statement_list (build1 (LABEL_EXPR,
2791 /* Return true if FDECL is accessing a field that is zero sized. */
2794 zero_sized_field_decl (tree fdecl)
2796 if (TREE_CODE (fdecl) == FIELD_DECL && DECL_SIZE (fdecl)
2797 && integer_zerop (DECL_SIZE (fdecl)))
2802 /* Return true if TYPE is zero sized. */
2805 zero_sized_type (tree type)
2807 if (AGGREGATE_TYPE_P (type) && TYPE_SIZE (type)
2808 && integer_zerop (TYPE_SIZE (type)))
2813 /* A subroutine of gimplify_init_constructor. Generate individual
2814 MODIFY_EXPRs for a CONSTRUCTOR. OBJECT is the LHS against which the
2815 assignments should happen. ELTS is the CONSTRUCTOR_ELTS of the
2816 CONSTRUCTOR. CLEARED is true if the entire LHS object has been
2820 gimplify_init_ctor_eval (tree object, VEC(constructor_elt,gc) *elts,
2821 tree *pre_p, bool cleared)
2823 tree array_elt_type = NULL;
2824 unsigned HOST_WIDE_INT ix;
2825 tree purpose, value;
2827 if (TREE_CODE (TREE_TYPE (object)) == ARRAY_TYPE)
2828 array_elt_type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (object)));
2830 FOR_EACH_CONSTRUCTOR_ELT (elts, ix, purpose, value)
2834 /* NULL values are created above for gimplification errors. */
2838 if (cleared && initializer_zerop (value))
2841 /* ??? Here's to hoping the front end fills in all of the indices,
2842 so we don't have to figure out what's missing ourselves. */
2843 gcc_assert (purpose);
2845 /* Skip zero-sized fields, unless value has side-effects. This can
2846 happen with calls to functions returning a zero-sized type, which
2847 we shouldn't discard. As a number of downstream passes don't
2848 expect sets of zero-sized fields, we rely on the gimplification of
2849 the MODIFY_EXPR we make below to drop the assignment statement. */
2850 if (! TREE_SIDE_EFFECTS (value) && zero_sized_field_decl (purpose))
2853 /* If we have a RANGE_EXPR, we have to build a loop to assign the
2855 if (TREE_CODE (purpose) == RANGE_EXPR)
2857 tree lower = TREE_OPERAND (purpose, 0);
2858 tree upper = TREE_OPERAND (purpose, 1);
2860 /* If the lower bound is equal to upper, just treat it as if
2861 upper was the index. */
2862 if (simple_cst_equal (lower, upper))
2866 gimplify_init_ctor_eval_range (object, lower, upper, value,
2867 array_elt_type, pre_p, cleared);
2874 cref = build4 (ARRAY_REF, array_elt_type, unshare_expr (object),
2875 purpose, NULL_TREE, NULL_TREE);
2879 gcc_assert (TREE_CODE (purpose) == FIELD_DECL);
2880 cref = build3 (COMPONENT_REF, TREE_TYPE (purpose),
2881 unshare_expr (object), purpose, NULL_TREE);
2884 if (TREE_CODE (value) == CONSTRUCTOR
2885 && TREE_CODE (TREE_TYPE (value)) != VECTOR_TYPE)
2886 gimplify_init_ctor_eval (cref, CONSTRUCTOR_ELTS (value),
2890 init = build2 (INIT_EXPR, TREE_TYPE (cref), cref, value);
2891 gimplify_and_add (init, pre_p);
2896 /* A subroutine of gimplify_modify_expr. Break out elements of a
2897 CONSTRUCTOR used as an initializer into separate MODIFY_EXPRs.
2899 Note that we still need to clear any elements that don't have explicit
2900 initializers, so if not all elements are initialized we keep the
2901 original MODIFY_EXPR, we just remove all of the constructor elements. */
2903 static enum gimplify_status
2904 gimplify_init_constructor (tree *expr_p, tree *pre_p,
2905 tree *post_p, bool want_value)
2908 tree ctor = GENERIC_TREE_OPERAND (*expr_p, 1);
2909 tree type = TREE_TYPE (ctor);
2910 enum gimplify_status ret;
2911 VEC(constructor_elt,gc) *elts;
2913 if (TREE_CODE (ctor) != CONSTRUCTOR)
2914 return GS_UNHANDLED;
2916 ret = gimplify_expr (&GENERIC_TREE_OPERAND (*expr_p, 0), pre_p, post_p,
2917 is_gimple_lvalue, fb_lvalue);
2918 if (ret == GS_ERROR)
2920 object = GENERIC_TREE_OPERAND (*expr_p, 0);
2922 elts = CONSTRUCTOR_ELTS (ctor);
2925 switch (TREE_CODE (type))
2929 case QUAL_UNION_TYPE:
2932 struct gimplify_init_ctor_preeval_data preeval_data;
2933 HOST_WIDE_INT num_type_elements, num_ctor_elements;
2934 HOST_WIDE_INT num_nonzero_elements;
2935 bool cleared, valid_const_initializer;
2937 /* Aggregate types must lower constructors to initialization of
2938 individual elements. The exception is that a CONSTRUCTOR node
2939 with no elements indicates zero-initialization of the whole. */
2940 if (VEC_empty (constructor_elt, elts))
2943 /* Fetch information about the constructor to direct later processing.
2944 We might want to make static versions of it in various cases, and
2945 can only do so if it known to be a valid constant initializer. */
2946 valid_const_initializer
2947 = categorize_ctor_elements (ctor, &num_nonzero_elements,
2948 &num_ctor_elements, &cleared);
2950 /* If a const aggregate variable is being initialized, then it
2951 should never be a lose to promote the variable to be static. */
2952 if (valid_const_initializer
2953 && num_nonzero_elements > 1
2954 && TREE_READONLY (object)
2955 && TREE_CODE (object) == VAR_DECL)
2957 DECL_INITIAL (object) = ctor;
2958 TREE_STATIC (object) = 1;
2959 if (!DECL_NAME (object))
2960 DECL_NAME (object) = create_tmp_var_name ("C");
2961 walk_tree (&DECL_INITIAL (object), force_labels_r, NULL, NULL);
2963 /* ??? C++ doesn't automatically append a .<number> to the
2964 assembler name, and even when it does, it looks a FE private
2965 data structures to figure out what that number should be,
2966 which are not set for this variable. I suppose this is
2967 important for local statics for inline functions, which aren't
2968 "local" in the object file sense. So in order to get a unique
2969 TU-local symbol, we must invoke the lhd version now. */
2970 lhd_set_decl_assembler_name (object);
2972 *expr_p = NULL_TREE;
2976 /* If there are "lots" of initialized elements, even discounting
2977 those that are not address constants (and thus *must* be
2978 computed at runtime), then partition the constructor into
2979 constant and non-constant parts. Block copy the constant
2980 parts in, then generate code for the non-constant parts. */
2981 /* TODO. There's code in cp/typeck.c to do this. */
2983 num_type_elements = count_type_elements (type, true);
2985 /* If count_type_elements could not determine number of type elements
2986 for a constant-sized object, assume clearing is needed.
2987 Don't do this for variable-sized objects, as store_constructor
2988 will ignore the clearing of variable-sized objects. */
2989 if (num_type_elements < 0 && int_size_in_bytes (type) >= 0)
2991 /* If there are "lots" of zeros, then block clear the object first. */
2992 else if (num_type_elements - num_nonzero_elements > CLEAR_RATIO
2993 && num_nonzero_elements < num_type_elements/4)
2995 /* ??? This bit ought not be needed. For any element not present
2996 in the initializer, we should simply set them to zero. Except
2997 we'd need to *find* the elements that are not present, and that
2998 requires trickery to avoid quadratic compile-time behavior in
2999 large cases or excessive memory use in small cases. */
3000 else if (num_ctor_elements < num_type_elements)
3003 /* If there are "lots" of initialized elements, and all of them
3004 are valid address constants, then the entire initializer can
3005 be dropped to memory, and then memcpy'd out. Don't do this
3006 for sparse arrays, though, as it's more efficient to follow
3007 the standard CONSTRUCTOR behavior of memset followed by
3008 individual element initialization. */
3009 if (valid_const_initializer && !cleared)
3011 HOST_WIDE_INT size = int_size_in_bytes (type);
3014 /* ??? We can still get unbounded array types, at least
3015 from the C++ front end. This seems wrong, but attempt
3016 to work around it for now. */
3019 size = int_size_in_bytes (TREE_TYPE (object));
3021 TREE_TYPE (ctor) = type = TREE_TYPE (object);
3024 /* Find the maximum alignment we can assume for the object. */
3025 /* ??? Make use of DECL_OFFSET_ALIGN. */
3026 if (DECL_P (object))
3027 align = DECL_ALIGN (object);
3029 align = TYPE_ALIGN (type);
3031 if (size > 0 && !can_move_by_pieces (size, align))
3033 tree new = create_tmp_var_raw (type, "C");
3035 gimple_add_tmp_var (new);
3036 TREE_STATIC (new) = 1;
3037 TREE_READONLY (new) = 1;
3038 DECL_INITIAL (new) = ctor;
3039 if (align > DECL_ALIGN (new))
3041 DECL_ALIGN (new) = align;
3042 DECL_USER_ALIGN (new) = 1;
3044 walk_tree (&DECL_INITIAL (new), force_labels_r, NULL, NULL);
3046 GENERIC_TREE_OPERAND (*expr_p, 1) = new;
3048 /* This is no longer an assignment of a CONSTRUCTOR, but
3049 we still may have processing to do on the LHS. So
3050 pretend we didn't do anything here to let that happen. */
3051 return GS_UNHANDLED;
3055 /* If there are nonzero elements, pre-evaluate to capture elements
3056 overlapping with the lhs into temporaries. We must do this before
3057 clearing to fetch the values before they are zeroed-out. */
3058 if (num_nonzero_elements > 0)
3060 preeval_data.lhs_base_decl = get_base_address (object);
3061 if (!DECL_P (preeval_data.lhs_base_decl))
3062 preeval_data.lhs_base_decl = NULL;
3063 preeval_data.lhs_alias_set = get_alias_set (object);
3065 gimplify_init_ctor_preeval (&GENERIC_TREE_OPERAND (*expr_p, 1),
3066 pre_p, post_p, &preeval_data);
3071 /* Zap the CONSTRUCTOR element list, which simplifies this case.
3072 Note that we still have to gimplify, in order to handle the
3073 case of variable sized types. Avoid shared tree structures. */
3074 CONSTRUCTOR_ELTS (ctor) = NULL;
3075 object = unshare_expr (object);
3076 gimplify_stmt (expr_p);
3077 append_to_statement_list (*expr_p, pre_p);
3080 /* If we have not block cleared the object, or if there are nonzero
3081 elements in the constructor, add assignments to the individual
3082 scalar fields of the object. */
3083 if (!cleared || num_nonzero_elements > 0)
3084 gimplify_init_ctor_eval (object, elts, pre_p, cleared);
3086 *expr_p = NULL_TREE;
3094 /* Extract the real and imaginary parts out of the ctor. */
3095 gcc_assert (VEC_length (constructor_elt, elts) == 2);
3096 r = VEC_index (constructor_elt, elts, 0)->value;
3097 i = VEC_index (constructor_elt, elts, 1)->value;
3098 if (r == NULL || i == NULL)
3100 tree zero = fold_convert (TREE_TYPE (type), integer_zero_node);
3107 /* Complex types have either COMPLEX_CST or COMPLEX_EXPR to
3108 represent creation of a complex value. */
3109 if (TREE_CONSTANT (r) && TREE_CONSTANT (i))
3111 ctor = build_complex (type, r, i);
3112 TREE_OPERAND (*expr_p, 1) = ctor;
3116 ctor = build2 (COMPLEX_EXPR, type, r, i);
3117 TREE_OPERAND (*expr_p, 1) = ctor;
3118 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p,
3119 rhs_predicate_for (TREE_OPERAND (*expr_p, 0)),
3127 unsigned HOST_WIDE_INT ix;
3128 constructor_elt *ce;
3130 /* Go ahead and simplify constant constructors to VECTOR_CST. */
3131 if (TREE_CONSTANT (ctor))
3133 bool constant_p = true;
3136 /* Even when ctor is constant, it might contain non-*_CST
3137 elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't
3138 belong into VECTOR_CST nodes. */
3139 FOR_EACH_CONSTRUCTOR_VALUE (elts, ix, value)
3140 if (!CONSTANT_CLASS_P (value))
3148 TREE_OPERAND (*expr_p, 1) = build_vector_from_ctor (type, elts);
3152 /* Don't reduce a TREE_CONSTANT vector ctor even if we can't
3153 make a VECTOR_CST. It won't do anything for us, and it'll
3154 prevent us from representing it as a single constant. */
3158 /* Vector types use CONSTRUCTOR all the way through gimple
3159 compilation as a general initializer. */
3160 for (ix = 0; VEC_iterate (constructor_elt, elts, ix, ce); ix++)
3162 enum gimplify_status tret;
3163 tret = gimplify_expr (&ce->value, pre_p, post_p,
3164 is_gimple_val, fb_rvalue);
3165 if (tret == GS_ERROR)
3168 if (!is_gimple_reg (GENERIC_TREE_OPERAND (*expr_p, 0)))
3169 GENERIC_TREE_OPERAND (*expr_p, 1) = get_formal_tmp_var (ctor, pre_p);
3174 /* So how did we get a CONSTRUCTOR for a scalar type? */
3178 if (ret == GS_ERROR)
3180 else if (want_value)
3182 append_to_statement_list (*expr_p, pre_p);
3190 /* Given a pointer value OP0, return a simplified version of an
3191 indirection through OP0, or NULL_TREE if no simplification is
3192 possible. This may only be applied to a rhs of an expression.
3193 Note that the resulting type may be different from the type pointed
3194 to in the sense that it is still compatible from the langhooks
3198 fold_indirect_ref_rhs (tree t)
3200 tree type = TREE_TYPE (TREE_TYPE (t));
3204 STRIP_USELESS_TYPE_CONVERSION (sub);
3205 subtype = TREE_TYPE (sub);
3206 if (!POINTER_TYPE_P (subtype))
3209 if (TREE_CODE (sub) == ADDR_EXPR)
3211 tree op = TREE_OPERAND (sub, 0);
3212 tree optype = TREE_TYPE (op);
3214 if (lang_hooks.types_compatible_p (type, optype))
3216 /* *(foo *)&fooarray => fooarray[0] */
3217 else if (TREE_CODE (optype) == ARRAY_TYPE
3218 && lang_hooks.types_compatible_p (type, TREE_TYPE (optype)))
3220 tree type_domain = TYPE_DOMAIN (optype);
3221 tree min_val = size_zero_node;
3222 if (type_domain && TYPE_MIN_VALUE (type_domain))
3223 min_val = TYPE_MIN_VALUE (type_domain);
3224 return build4 (ARRAY_REF, type, op, min_val, NULL_TREE, NULL_TREE);
3228 /* *(foo *)fooarrptr => (*fooarrptr)[0] */
3229 if (TREE_CODE (TREE_TYPE (subtype)) == ARRAY_TYPE
3230 && lang_hooks.types_compatible_p (type, TREE_TYPE (TREE_TYPE (subtype))))
3233 tree min_val = size_zero_node;
3235 sub = fold_indirect_ref_rhs (sub);
3237 sub = build1 (INDIRECT_REF, TREE_TYPE (subtype), osub);
3238 type_domain = TYPE_DOMAIN (TREE_TYPE (sub));
3239 if (type_domain && TYPE_MIN_VALUE (type_domain))
3240 min_val = TYPE_MIN_VALUE (type_domain);
3241 return build4 (ARRAY_REF, type, sub, min_val, NULL_TREE, NULL_TREE);
3247 /* Subroutine of gimplify_modify_expr to do simplifications of MODIFY_EXPRs
3248 based on the code of the RHS. We loop for as long as something changes. */
3250 static enum gimplify_status
3251 gimplify_modify_expr_rhs (tree *expr_p, tree *from_p, tree *to_p, tree *pre_p,
3252 tree *post_p, bool want_value)
3254 enum gimplify_status ret = GS_OK;
3256 while (ret != GS_UNHANDLED)
3257 switch (TREE_CODE (*from_p))
3261 /* If we have code like
3265 where the type of "x" is a (possibly cv-qualified variant
3266 of "A"), treat the entire expression as identical to "x".
3267 This kind of code arises in C++ when an object is bound
3268 to a const reference, and if "x" is a TARGET_EXPR we want
3269 to take advantage of the optimization below. */
3270 tree t = fold_indirect_ref_rhs (TREE_OPERAND (*from_p, 0));
3283 /* If we are initializing something from a TARGET_EXPR, strip the
3284 TARGET_EXPR and initialize it directly, if possible. This can't
3285 be done if the initializer is void, since that implies that the
3286 temporary is set in some non-trivial way.
3288 ??? What about code that pulls out the temp and uses it
3289 elsewhere? I think that such code never uses the TARGET_EXPR as
3290 an initializer. If I'm wrong, we'll die because the temp won't
3291 have any RTL. In that case, I guess we'll need to replace
3292 references somehow. */
3293 tree init = TARGET_EXPR_INITIAL (*from_p);
3295 if (!VOID_TYPE_P (TREE_TYPE (init)))
3306 /* Remove any COMPOUND_EXPR in the RHS so the following cases will be
3308 gimplify_compound_expr (from_p, pre_p, true);
3313 /* If we're initializing from a CONSTRUCTOR, break this into
3314 individual MODIFY_EXPRs. */
3315 return gimplify_init_constructor (expr_p, pre_p, post_p, want_value);
3318 /* If we're assigning to a non-register type, push the assignment
3319 down into the branches. This is mandatory for ADDRESSABLE types,
3320 since we cannot generate temporaries for such, but it saves a
3321 copy in other cases as well. */
3322 if (!is_gimple_reg_type (TREE_TYPE (*from_p)))
3324 /* This code should mirror the code in gimplify_cond_expr. */
3325 enum tree_code code = TREE_CODE (*expr_p);
3326 tree cond = *from_p;
3327 tree result = *to_p;
3329 ret = gimplify_expr (&result, pre_p, post_p,
3330 is_gimple_min_lval, fb_lvalue);
3331 if (ret != GS_ERROR)
3334 if (TREE_TYPE (TREE_OPERAND (cond, 1)) != void_type_node)
3335 TREE_OPERAND (cond, 1)
3336 = build2 (code, void_type_node, result,
3337 TREE_OPERAND (cond, 1));
3338 if (TREE_TYPE (TREE_OPERAND (cond, 2)) != void_type_node)
3339 TREE_OPERAND (cond, 2)
3340 = build2 (code, void_type_node, unshare_expr (result),
3341 TREE_OPERAND (cond, 2));
3343 TREE_TYPE (cond) = void_type_node;
3344 recalculate_side_effects (cond);
3348 gimplify_and_add (cond, pre_p);
3349 *expr_p = unshare_expr (result);
3360 /* For calls that return in memory, give *to_p as the CALL_EXPR's
3361 return slot so that we don't generate a temporary. */
3362 if (!CALL_EXPR_RETURN_SLOT_OPT (*from_p)
3363 && aggregate_value_p (*from_p, *from_p))
3367 if (!(rhs_predicate_for (*to_p))(*from_p))
3368 /* If we need a temporary, *to_p isn't accurate. */
3370 else if (TREE_CODE (*to_p) == RESULT_DECL
3371 && DECL_NAME (*to_p) == NULL_TREE
3372 && needs_to_live_in_memory (*to_p))
3373 /* It's OK to use the return slot directly unless it's an NRV. */
3375 else if (is_gimple_reg_type (TREE_TYPE (*to_p))
3376 || (DECL_P (*to_p) && DECL_REGISTER (*to_p)))
3377 /* Don't force regs into memory. */
3379 else if (TREE_CODE (*to_p) == VAR_DECL
3380 && DECL_GIMPLE_FORMAL_TEMP_P (*to_p))
3381 /* Don't use the original target if it's a formal temp; we
3382 don't want to take their addresses. */
3384 else if (TREE_CODE (*expr_p) == INIT_EXPR)
3385 /* It's OK to use the target directly if it's being
3388 else if (!is_gimple_non_addressable (*to_p))
3389 /* Don't use the original target if it's already addressable;
3390 if its address escapes, and the called function uses the
3391 NRV optimization, a conforming program could see *to_p
3392 change before the called function returns; see c++/19317.
3393 When optimizing, the return_slot pass marks more functions
3394 as safe after we have escape info. */
3401 CALL_EXPR_RETURN_SLOT_OPT (*from_p) = 1;
3402 lang_hooks.mark_addressable (*to_p);
3409 /* If we're initializing from a container, push the initialization
3411 case CLEANUP_POINT_EXPR:
3413 case STATEMENT_LIST:
3415 tree wrap = *from_p;
3418 ret = gimplify_expr (to_p, pre_p, post_p,
3419 is_gimple_min_lval, fb_lvalue);
3420 if (ret != GS_ERROR)
3423 t = voidify_wrapper_expr (wrap, *expr_p);
3424 gcc_assert (t == *expr_p);
3428 gimplify_and_add (wrap, pre_p);
3429 *expr_p = unshare_expr (*to_p);
3444 /* Destructively convert the TREE pointer in TP into a gimple tuple if
3448 tree_to_gimple_tuple (tree *tp)
3451 switch (TREE_CODE (*tp))
3453 case GIMPLE_MODIFY_STMT:
3457 struct gimple_stmt *gs;
3458 tree lhs = TREE_OPERAND (*tp, 0);
3459 bool def_stmt_self_p = false;
3461 if (TREE_CODE (lhs) == SSA_NAME)
3463 if (SSA_NAME_DEF_STMT (lhs) == *tp)
3464 def_stmt_self_p = true;
3467 gs = &make_node (GIMPLE_MODIFY_STMT)->gstmt;
3468 gs->base = (*tp)->base;
3469 /* The set to base above overwrites the CODE. */
3470 TREE_SET_CODE ((tree) gs, GIMPLE_MODIFY_STMT);
3472 gs->locus = EXPR_LOCUS (*tp);
3473 gs->operands[0] = TREE_OPERAND (*tp, 0);
3474 gs->operands[1] = TREE_OPERAND (*tp, 1);
3475 gs->block = TREE_BLOCK (*tp);
3478 /* If we re-gimplify a set to an SSA_NAME, we must change the
3479 SSA name's DEF_STMT link. */
3480 if (def_stmt_self_p)
3481 SSA_NAME_DEF_STMT (GIMPLE_STMT_OPERAND (*tp, 0)) = *tp;
3490 /* Promote partial stores to COMPLEX variables to total stores. *EXPR_P is
3491 a MODIFY_EXPR with a lhs of a REAL/IMAGPART_EXPR of a variable with
3492 DECL_GIMPLE_REG_P set. */
3494 static enum gimplify_status
3495 gimplify_modify_expr_complex_part (tree *expr_p, tree *pre_p, bool want_value)
3497 enum tree_code code, ocode;
3498 tree lhs, rhs, new_rhs, other, realpart, imagpart;
3500 lhs = GENERIC_TREE_OPERAND (*expr_p, 0);
3501 rhs = GENERIC_TREE_OPERAND (*expr_p, 1);
3502 code = TREE_CODE (lhs);
3503 lhs = TREE_OPERAND (lhs, 0);
3505 ocode = code == REALPART_EXPR ? IMAGPART_EXPR : REALPART_EXPR;
3506 other = build1 (ocode, TREE_TYPE (rhs), lhs);
3507 other = get_formal_tmp_var (other, pre_p);
3509 realpart = code == REALPART_EXPR ? rhs : other;
3510 imagpart = code == REALPART_EXPR ? other : rhs;
3512 if (TREE_CONSTANT (realpart) && TREE_CONSTANT (imagpart))
3513 new_rhs = build_complex (TREE_TYPE (lhs), realpart, imagpart);
3515 new_rhs = build2 (COMPLEX_EXPR, TREE_TYPE (lhs), realpart, imagpart);
3517 GENERIC_TREE_OPERAND (*expr_p, 0) = lhs;
3518 GENERIC_TREE_OPERAND (*expr_p, 1) = new_rhs;
3522 tree_to_gimple_tuple (expr_p);
3524 append_to_statement_list (*expr_p, pre_p);
3531 /* Gimplify the MODIFY_EXPR node pointed to by EXPR_P.
3537 PRE_P points to the list where side effects that must happen before
3538 *EXPR_P should be stored.
3540 POST_P points to the list where side effects that must happen after
3541 *EXPR_P should be stored.
3543 WANT_VALUE is nonzero iff we want to use the value of this expression
3544 in another expression. */
3546 static enum gimplify_status
3547 gimplify_modify_expr (tree *expr_p, tree *pre_p, tree *post_p, bool want_value)
3549 tree *from_p = &GENERIC_TREE_OPERAND (*expr_p, 1);
3550 tree *to_p = &GENERIC_TREE_OPERAND (*expr_p, 0);
3551 enum gimplify_status ret = GS_UNHANDLED;
3553 gcc_assert (TREE_CODE (*expr_p) == MODIFY_EXPR
3554 || TREE_CODE (*expr_p) == GIMPLE_MODIFY_STMT
3555 || TREE_CODE (*expr_p) == INIT_EXPR);
3557 /* For zero sized types only gimplify the left hand side and right hand side
3558 as statements and throw away the assignment. */
3559 if (zero_sized_type (TREE_TYPE (*from_p)))
3561 gimplify_stmt (from_p);
3562 gimplify_stmt (to_p);
3563 append_to_statement_list (*from_p, pre_p);
3564 append_to_statement_list (*to_p, pre_p);
3565 *expr_p = NULL_TREE;
3569 /* See if any simplifications can be done based on what the RHS is. */
3570 ret = gimplify_modify_expr_rhs (expr_p, from_p, to_p, pre_p, post_p,
3572 if (ret != GS_UNHANDLED)
3575 /* If the value being copied is of variable width, compute the length
3576 of the copy into a WITH_SIZE_EXPR. Note that we need to do this
3577 before gimplifying any of the operands so that we can resolve any
3578 PLACEHOLDER_EXPRs in the size. Also note that the RTL expander uses
3579 the size of the expression to be copied, not of the destination, so
3580 that is what we must here. */
3581 maybe_with_size_expr (from_p);
3583 ret = gimplify_expr (to_p, pre_p, post_p, is_gimple_lvalue, fb_lvalue);
3584 if (ret == GS_ERROR)
3587 ret = gimplify_expr (from_p, pre_p, post_p,
3588 rhs_predicate_for (*to_p), fb_rvalue);
3589 if (ret == GS_ERROR)
3592 /* Now see if the above changed *from_p to something we handle specially. */
3593 ret = gimplify_modify_expr_rhs (expr_p, from_p, to_p, pre_p, post_p,
3595 if (ret != GS_UNHANDLED)
3598 /* If we've got a variable sized assignment between two lvalues (i.e. does
3599 not involve a call), then we can make things a bit more straightforward
3600 by converting the assignment to memcpy or memset. */
3601 if (TREE_CODE (*from_p) == WITH_SIZE_EXPR)
3603 tree from = TREE_OPERAND (*from_p, 0);
3604 tree size = TREE_OPERAND (*from_p, 1);
3606 if (TREE_CODE (from) == CONSTRUCTOR)
3607 return gimplify_modify_expr_to_memset (expr_p, size, want_value);
3608 if (is_gimple_addressable (from))
3611 return gimplify_modify_expr_to_memcpy (expr_p, size, want_value);
3615 /* Transform partial stores to non-addressable complex variables into
3616 total stores. This allows us to use real instead of virtual operands
3617 for these variables, which improves optimization. */
3618 if ((TREE_CODE (*to_p) == REALPART_EXPR
3619 || TREE_CODE (*to_p) == IMAGPART_EXPR)
3620 && is_gimple_reg (TREE_OPERAND (*to_p, 0)))
3621 return gimplify_modify_expr_complex_part (expr_p, pre_p, want_value);
3623 if (gimplify_ctxp->into_ssa && is_gimple_reg (*to_p))
3625 /* If we've somehow already got an SSA_NAME on the LHS, then
3626 we're probably modified it twice. Not good. */
3627 gcc_assert (TREE_CODE (*to_p) != SSA_NAME);
3628 *to_p = make_ssa_name (*to_p, *expr_p);
3631 /* Try to alleviate the effects of the gimplification creating artificial
3632 temporaries (see for example is_gimple_reg_rhs) on the debug info. */
3633 if (!gimplify_ctxp->into_ssa
3634 && DECL_P (*from_p) && DECL_IGNORED_P (*from_p)
3635 && DECL_P (*to_p) && !DECL_IGNORED_P (*to_p))
3637 if (!DECL_NAME (*from_p) && DECL_NAME (*to_p))
3639 = create_tmp_var_name (IDENTIFIER_POINTER (DECL_NAME (*to_p)));
3640 DECL_DEBUG_EXPR_IS_FROM (*from_p) = 1;
3641 SET_DECL_DEBUG_EXPR (*from_p, *to_p);
3646 tree_to_gimple_tuple (expr_p);
3648 append_to_statement_list (*expr_p, pre_p);
3656 /* Gimplify a comparison between two variable-sized objects. Do this
3657 with a call to BUILT_IN_MEMCMP. */
3659 static enum gimplify_status
3660 gimplify_variable_sized_compare (tree *expr_p)
3662 tree op0 = TREE_OPERAND (*expr_p, 0);
3663 tree op1 = TREE_OPERAND (*expr_p, 1);
3664 tree t, arg, dest, src;
3666 arg = TYPE_SIZE_UNIT (TREE_TYPE (op0));
3667 arg = unshare_expr (arg);
3668 arg = SUBSTITUTE_PLACEHOLDER_IN_EXPR (arg, op0);
3669 src = build_fold_addr_expr (op1);
3670 dest = build_fold_addr_expr (op0);
3671 t = implicit_built_in_decls[BUILT_IN_MEMCMP];
3672 t = build_call_expr (t, 3, dest, src, arg);
3674 = build2 (TREE_CODE (*expr_p), TREE_TYPE (*expr_p), t, integer_zero_node);
3679 /* Gimplify a comparison between two aggregate objects of integral scalar
3680 mode as a comparison between the bitwise equivalent scalar values. */
3682 static enum gimplify_status
3683 gimplify_scalar_mode_aggregate_compare (tree *expr_p)
3685 tree op0 = TREE_OPERAND (*expr_p, 0);
3686 tree op1 = TREE_OPERAND (*expr_p, 1);
3688 tree type = TREE_TYPE (op0);
3689 tree scalar_type = lang_hooks.types.type_for_mode (TYPE_MODE (type), 1);
3691 op0 = fold_build1 (VIEW_CONVERT_EXPR, scalar_type, op0);
3692 op1 = fold_build1 (VIEW_CONVERT_EXPR, scalar_type, op1);
3695 = fold_build2 (TREE_CODE (*expr_p), TREE_TYPE (*expr_p), op0, op1);
3700 /* Gimplify TRUTH_ANDIF_EXPR and TRUTH_ORIF_EXPR expressions. EXPR_P
3701 points to the expression to gimplify.
3703 Expressions of the form 'a && b' are gimplified to:
3705 a && b ? true : false
3707 gimplify_cond_expr will do the rest.
3709 PRE_P points to the list where side effects that must happen before
3710 *EXPR_P should be stored. */
3712 static enum gimplify_status
3713 gimplify_boolean_expr (tree *expr_p)
3715 /* Preserve the original type of the expression. */
3716 tree type = TREE_TYPE (*expr_p);
3718 *expr_p = build3 (COND_EXPR, type, *expr_p,
3719 fold_convert (type, boolean_true_node),
3720 fold_convert (type, boolean_false_node));
3725 /* Gimplifies an expression sequence. This function gimplifies each
3726 expression and re-writes the original expression with the last
3727 expression of the sequence in GIMPLE form.
3729 PRE_P points to the list where the side effects for all the
3730 expressions in the sequence will be emitted.
3732 WANT_VALUE is true when the result of the last COMPOUND_EXPR is used. */
3733 /* ??? Should rearrange to share the pre-queue with all the indirect
3734 invocations of gimplify_expr. Would probably save on creations
3735 of statement_list nodes. */
3737 static enum gimplify_status
3738 gimplify_compound_expr (tree *expr_p, tree *pre_p, bool want_value)
3744 tree *sub_p = &TREE_OPERAND (t, 0);
3746 if (TREE_CODE (*sub_p) == COMPOUND_EXPR)
3747 gimplify_compound_expr (sub_p, pre_p, false);
3749 gimplify_stmt (sub_p);
3750 append_to_statement_list (*sub_p, pre_p);
3752 t = TREE_OPERAND (t, 1);
3754 while (TREE_CODE (t) == COMPOUND_EXPR);
3761 gimplify_stmt (expr_p);
3766 /* Gimplifies a statement list. These may be created either by an
3767 enlightened front-end, or by shortcut_cond_expr. */
3769 static enum gimplify_status
3770 gimplify_statement_list (tree *expr_p, tree *pre_p)
3772 tree temp = voidify_wrapper_expr (*expr_p, NULL);
3774 tree_stmt_iterator i = tsi_start (*expr_p);
3776 while (!tsi_end_p (i))
3780 gimplify_stmt (tsi_stmt_ptr (i));
3785 else if (TREE_CODE (t) == STATEMENT_LIST)
3787 tsi_link_before (&i, t, TSI_SAME_STMT);
3796 append_to_statement_list (*expr_p, pre_p);
3804 /* Gimplify a SAVE_EXPR node. EXPR_P points to the expression to
3805 gimplify. After gimplification, EXPR_P will point to a new temporary
3806 that holds the original value of the SAVE_EXPR node.
3808 PRE_P points to the list where side effects that must happen before
3809 *EXPR_P should be stored. */
3811 static enum gimplify_status
3812 gimplify_save_expr (tree *expr_p, tree *pre_p, tree *post_p)
3814 enum gimplify_status ret = GS_ALL_DONE;
3817 gcc_assert (TREE_CODE (*expr_p) == SAVE_EXPR);
3818 val = TREE_OPERAND (*expr_p, 0);
3820 /* If the SAVE_EXPR has not been resolved, then evaluate it once. */
3821 if (!SAVE_EXPR_RESOLVED_P (*expr_p))
3823 /* The operand may be a void-valued expression such as SAVE_EXPRs
3824 generated by the Java frontend for class initialization. It is
3825 being executed only for its side-effects. */
3826 if (TREE_TYPE (val) == void_type_node)
3828 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
3829 is_gimple_stmt, fb_none);
3830 append_to_statement_list (TREE_OPERAND (*expr_p, 0), pre_p);
3834 val = get_initialized_tmp_var (val, pre_p, post_p);
3836 TREE_OPERAND (*expr_p, 0) = val;
3837 SAVE_EXPR_RESOLVED_P (*expr_p) = 1;
3845 /* Re-write the ADDR_EXPR node pointed to by EXPR_P
3852 PRE_P points to the list where side effects that must happen before
3853 *EXPR_P should be stored.
3855 POST_P points to the list where side effects that must happen after
3856 *EXPR_P should be stored. */
3858 static enum gimplify_status
3859 gimplify_addr_expr (tree *expr_p, tree *pre_p, tree *post_p)
3861 tree expr = *expr_p;
3862 tree op0 = TREE_OPERAND (expr, 0);
3863 enum gimplify_status ret;
3865 switch (TREE_CODE (op0))
3868 case MISALIGNED_INDIRECT_REF:
3870 /* Check if we are dealing with an expression of the form '&*ptr'.
3871 While the front end folds away '&*ptr' into 'ptr', these
3872 expressions may be generated internally by the compiler (e.g.,
3873 builtins like __builtin_va_end). */
3874 /* Caution: the silent array decomposition semantics we allow for
3875 ADDR_EXPR means we can't always discard the pair. */
3876 /* Gimplification of the ADDR_EXPR operand may drop
3877 cv-qualification conversions, so make sure we add them if
3880 tree op00 = TREE_OPERAND (op0, 0);
3881 tree t_expr = TREE_TYPE (expr);
3882 tree t_op00 = TREE_TYPE (op00);
3884 if (!lang_hooks.types_compatible_p (t_expr, t_op00))
3886 #ifdef ENABLE_CHECKING
3887 tree t_op0 = TREE_TYPE (op0);
3888 gcc_assert (POINTER_TYPE_P (t_expr)
3889 && cpt_same_type (TREE_CODE (t_op0) == ARRAY_TYPE
3890 ? TREE_TYPE (t_op0) : t_op0,
3892 && POINTER_TYPE_P (t_op00)
3893 && cpt_same_type (t_op0, TREE_TYPE (t_op00)));
3895 op00 = fold_convert (TREE_TYPE (expr), op00);
3902 case VIEW_CONVERT_EXPR:
3903 /* Take the address of our operand and then convert it to the type of
3906 ??? The interactions of VIEW_CONVERT_EXPR and aliasing is not at
3907 all clear. The impact of this transformation is even less clear. */
3909 /* If the operand is a useless conversion, look through it. Doing so
3910 guarantees that the ADDR_EXPR and its operand will remain of the
3912 if (tree_ssa_useless_type_conversion (TREE_OPERAND (op0, 0)))
3913 op0 = TREE_OPERAND (op0, 0);
3915 *expr_p = fold_convert (TREE_TYPE (expr),
3916 build_fold_addr_expr (TREE_OPERAND (op0, 0)));
3921 /* We use fb_either here because the C frontend sometimes takes
3922 the address of a call that returns a struct; see
3923 gcc.dg/c99-array-lval-1.c. The gimplifier will correctly make
3924 the implied temporary explicit. */
3925 ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, post_p,
3926 is_gimple_addressable, fb_either);
3927 if (ret != GS_ERROR)
3929 op0 = TREE_OPERAND (expr, 0);
3931 /* For various reasons, the gimplification of the expression
3932 may have made a new INDIRECT_REF. */
3933 if (TREE_CODE (op0) == INDIRECT_REF)
3934 goto do_indirect_ref;
3936 /* Make sure TREE_INVARIANT, TREE_CONSTANT, and TREE_SIDE_EFFECTS
3938 recompute_tree_invariant_for_addr_expr (expr);
3940 /* Mark the RHS addressable. */
3941 lang_hooks.mark_addressable (TREE_OPERAND (expr, 0));
3949 /* Gimplify the operands of an ASM_EXPR. Input operands should be a gimple
3950 value; output operands should be a gimple lvalue. */
3952 static enum gimplify_status
3953 gimplify_asm_expr (tree *expr_p, tree *pre_p, tree *post_p)
3955 tree expr = *expr_p;
3956 int noutputs = list_length (ASM_OUTPUTS (expr));
3957 const char **oconstraints
3958 = (const char **) alloca ((noutputs) * sizeof (const char *));
3961 const char *constraint;
3962 bool allows_mem, allows_reg, is_inout;
3963 enum gimplify_status ret, tret;
3966 for (i = 0, link = ASM_OUTPUTS (expr); link; ++i, link = TREE_CHAIN (link))
3968 size_t constraint_len;
3969 oconstraints[i] = constraint
3970 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
3971 constraint_len = strlen (constraint);
3972 if (constraint_len == 0)
3975 parse_output_constraint (&constraint, i, 0, 0,
3976 &allows_mem, &allows_reg, &is_inout);
3978 if (!allows_reg && allows_mem)
3979 lang_hooks.mark_addressable (TREE_VALUE (link));
3981 tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
3982 is_inout ? is_gimple_min_lval : is_gimple_lvalue,
3983 fb_lvalue | fb_mayfail);
3984 if (tret == GS_ERROR)
3986 error ("invalid lvalue in asm output %d", i);
3992 /* An input/output operand. To give the optimizers more
3993 flexibility, split it into separate input and output
3998 /* Turn the in/out constraint into an output constraint. */
3999 char *p = xstrdup (constraint);
4001 TREE_VALUE (TREE_PURPOSE (link)) = build_string (constraint_len, p);
4003 /* And add a matching input constraint. */
4006 sprintf (buf, "%d", i);
4008 /* If there are multiple alternatives in the constraint,
4009 handle each of them individually. Those that allow register
4010 will be replaced with operand number, the others will stay
4012 if (strchr (p, ',') != NULL)
4014 size_t len = 0, buflen = strlen (buf);
4015 char *beg, *end, *str, *dst;
4019 end = strchr (beg, ',');
4021 end = strchr (beg, '\0');
4022 if ((size_t) (end - beg) < buflen)
4025 len += end - beg + 1;
4032 str = (char *) alloca (len);
4033 for (beg = p + 1, dst = str;;)
4036 bool mem_p, reg_p, inout_p;
4038 end = strchr (beg, ',');
4043 parse_output_constraint (&tem, i, 0, 0,
4044 &mem_p, ®_p, &inout_p);
4049 memcpy (dst, buf, buflen);
4058 memcpy (dst, beg, len);
4067 input = build_string (dst - str, str);
4070 input = build_string (strlen (buf), buf);
4073 input = build_string (constraint_len - 1, constraint + 1);
4077 input = build_tree_list (build_tree_list (NULL_TREE, input),
4078 unshare_expr (TREE_VALUE (link)));
4079 ASM_INPUTS (expr) = chainon (ASM_INPUTS (expr), input);
4083 for (link = ASM_INPUTS (expr); link; ++i, link = TREE_CHAIN (link))
4086 = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (link)));
4087 parse_input_constraint (&constraint, 0, 0, noutputs, 0,
4088 oconstraints, &allows_mem, &allows_reg);
4090 /* If the operand is a memory input, it should be an lvalue. */
4091 if (!allows_reg && allows_mem)
4093 tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
4094 is_gimple_lvalue, fb_lvalue | fb_mayfail);
4095 lang_hooks.mark_addressable (TREE_VALUE (link));
4096 if (tret == GS_ERROR)
4098 error ("memory input %d is not directly addressable", i);
4104 tret = gimplify_expr (&TREE_VALUE (link), pre_p, post_p,
4105 is_gimple_asm_val, fb_rvalue);
4106 if (tret == GS_ERROR)
4114 /* Gimplify a CLEANUP_POINT_EXPR. Currently this works by adding
4115 WITH_CLEANUP_EXPRs to the prequeue as we encounter cleanups while
4116 gimplifying the body, and converting them to TRY_FINALLY_EXPRs when we
4117 return to this function.
4119 FIXME should we complexify the prequeue handling instead? Or use flags
4120 for all the cleanups and let the optimizer tighten them up? The current
4121 code seems pretty fragile; it will break on a cleanup within any
4122 non-conditional nesting. But any such nesting would be broken, anyway;
4123 we can't write a TRY_FINALLY_EXPR that starts inside a nesting construct
4124 and continues out of it. We can do that at the RTL level, though, so
4125 having an optimizer to tighten up try/finally regions would be a Good
4128 static enum gimplify_status
4129 gimplify_cleanup_point_expr (tree *expr_p, tree *pre_p)
4131 tree_stmt_iterator iter;
4134 tree temp = voidify_wrapper_expr (*expr_p, NULL);
4136 /* We only care about the number of conditions between the innermost
4137 CLEANUP_POINT_EXPR and the cleanup. So save and reset the count and
4138 any cleanups collected outside the CLEANUP_POINT_EXPR. */
4139 int old_conds = gimplify_ctxp->conditions;
4140 tree old_cleanups = gimplify_ctxp->conditional_cleanups;
4141 gimplify_ctxp->conditions = 0;
4142 gimplify_ctxp->conditional_cleanups = NULL_TREE;
4144 body = TREE_OPERAND (*expr_p, 0);
4145 gimplify_to_stmt_list (&body);
4147 gimplify_ctxp->conditions = old_conds;
4148 gimplify_ctxp->conditional_cleanups = old_cleanups;
4150 for (iter = tsi_start (body); !tsi_end_p (iter); )
4152 tree *wce_p = tsi_stmt_ptr (iter);
4155 if (TREE_CODE (wce) == WITH_CLEANUP_EXPR)
4157 if (tsi_one_before_end_p (iter))
4159 tsi_link_before (&iter, TREE_OPERAND (wce, 0), TSI_SAME_STMT);
4166 enum tree_code code;
4168 if (CLEANUP_EH_ONLY (wce))
4169 code = TRY_CATCH_EXPR;
4171 code = TRY_FINALLY_EXPR;
4173 sl = tsi_split_statement_list_after (&iter);
4174 tfe = build2 (code, void_type_node, sl, NULL_TREE);
4175 append_to_statement_list (TREE_OPERAND (wce, 0),
4176 &TREE_OPERAND (tfe, 1));
4178 iter = tsi_start (sl);
4188 append_to_statement_list (body, pre_p);
4198 /* Insert a cleanup marker for gimplify_cleanup_point_expr. CLEANUP
4199 is the cleanup action required. */
4202 gimple_push_cleanup (tree var, tree cleanup, bool eh_only, tree *pre_p)
4206 /* Errors can result in improperly nested cleanups. Which results in
4207 confusion when trying to resolve the WITH_CLEANUP_EXPR. */
4208 if (errorcount || sorrycount)
4211 if (gimple_conditional_context ())
4213 /* If we're in a conditional context, this is more complex. We only
4214 want to run the cleanup if we actually ran the initialization that
4215 necessitates it, but we want to run it after the end of the
4216 conditional context. So we wrap the try/finally around the
4217 condition and use a flag to determine whether or not to actually
4218 run the destructor. Thus
4222 becomes (approximately)
4226 if (test) { A::A(temp); flag = 1; val = f(temp); }
4229 if (flag) A::~A(temp);
4234 tree flag = create_tmp_var (boolean_type_node, "cleanup");
4235 tree ffalse = build_gimple_modify_stmt (flag, boolean_false_node);
4236 tree ftrue = build_gimple_modify_stmt (flag, boolean_true_node);
4237 cleanup = build3 (COND_EXPR, void_type_node, flag, cleanup, NULL);
4238 wce = build1 (WITH_CLEANUP_EXPR, void_type_node, cleanup);
4239 append_to_statement_list (ffalse, &gimplify_ctxp->conditional_cleanups);
4240 append_to_statement_list (wce, &gimplify_ctxp->conditional_cleanups);
4241 append_to_statement_list (ftrue, pre_p);
4243 /* Because of this manipulation, and the EH edges that jump
4244 threading cannot redirect, the temporary (VAR) will appear
4245 to be used uninitialized. Don't warn. */
4246 TREE_NO_WARNING (var) = 1;
4250 wce = build1 (WITH_CLEANUP_EXPR, void_type_node, cleanup);
4251 CLEANUP_EH_ONLY (wce) = eh_only;
4252 append_to_statement_list (wce, pre_p);
4255 gimplify_stmt (&TREE_OPERAND (wce, 0));
4258 /* Gimplify a TARGET_EXPR which doesn't appear on the rhs of an INIT_EXPR. */
4260 static enum gimplify_status
4261 gimplify_target_expr (tree *expr_p, tree *pre_p, tree *post_p)
4263 tree targ = *expr_p;
4264 tree temp = TARGET_EXPR_SLOT (targ);
4265 tree init = TARGET_EXPR_INITIAL (targ);
4266 enum gimplify_status ret;
4270 /* TARGET_EXPR temps aren't part of the enclosing block, so add it
4271 to the temps list. */
4272 gimple_add_tmp_var (temp);
4274 /* If TARGET_EXPR_INITIAL is void, then the mere evaluation of the
4275 expression is supposed to initialize the slot. */
4276 if (VOID_TYPE_P (TREE_TYPE (init)))
4277 ret = gimplify_expr (&init, pre_p, post_p, is_gimple_stmt, fb_none);
4280 init = build2 (INIT_EXPR, void_type_node, temp, init);
4281 ret = gimplify_expr (&init, pre_p, post_p, is_gimple_stmt,
4284 if (ret == GS_ERROR)
4286 /* PR c++/28266 Make sure this is expanded only once. */
4287 TARGET_EXPR_INITIAL (targ) = NULL_TREE;
4290 append_to_statement_list (init, pre_p);
4292 /* If needed, push the cleanup for the temp. */
4293 if (TARGET_EXPR_CLEANUP (targ))
4295 gimplify_stmt (&TARGET_EXPR_CLEANUP (targ));
4296 gimple_push_cleanup (temp, TARGET_EXPR_CLEANUP (targ),
4297 CLEANUP_EH_ONLY (targ), pre_p);
4300 /* Only expand this once. */
4301 TREE_OPERAND (targ, 3) = init;
4302 TARGET_EXPR_INITIAL (targ) = NULL_TREE;
4305 /* We should have expanded this before. */
4306 gcc_assert (DECL_SEEN_IN_BIND_EXPR_P (temp));
4312 /* Gimplification of expression trees. */
4314 /* Gimplify an expression which appears at statement context; usually, this
4315 means replacing it with a suitably gimple STATEMENT_LIST. */
4318 gimplify_stmt (tree *stmt_p)
4320 gimplify_expr (stmt_p, NULL, NULL, is_gimple_stmt, fb_none);
4323 /* Similarly, but force the result to be a STATEMENT_LIST. */
4326 gimplify_to_stmt_list (tree *stmt_p)
4328 gimplify_stmt (stmt_p);
4330 *stmt_p = alloc_stmt_list ();
4331 else if (TREE_CODE (*stmt_p) != STATEMENT_LIST)
4334 *stmt_p = alloc_stmt_list ();
4335 append_to_statement_list (t, stmt_p);
4340 /* Add FIRSTPRIVATE entries for DECL in the OpenMP the surrounding parallels
4341 to CTX. If entries already exist, force them to be some flavor of private.
4342 If there is no enclosing parallel, do nothing. */
4345 omp_firstprivatize_variable (struct gimplify_omp_ctx *ctx, tree decl)
4349 if (decl == NULL || !DECL_P (decl))
4354 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
4357 if (n->value & GOVD_SHARED)
4358 n->value = GOVD_FIRSTPRIVATE | (n->value & GOVD_SEEN);
4362 else if (ctx->is_parallel)
4363 omp_add_variable (ctx, decl, GOVD_FIRSTPRIVATE);
4365 ctx = ctx->outer_context;
4370 /* Similarly for each of the type sizes of TYPE. */
4373 omp_firstprivatize_type_sizes (struct gimplify_omp_ctx *ctx, tree type)
4375 if (type == NULL || type == error_mark_node)
4377 type = TYPE_MAIN_VARIANT (type);
4379 if (pointer_set_insert (ctx->privatized_types, type))
4382 switch (TREE_CODE (type))
4388 omp_firstprivatize_variable (ctx, TYPE_MIN_VALUE (type));
4389 omp_firstprivatize_variable (ctx, TYPE_MAX_VALUE (type));
4393 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (type));
4394 omp_firstprivatize_type_sizes (ctx, TYPE_DOMAIN (type));
4399 case QUAL_UNION_TYPE:
4402 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
4403 if (TREE_CODE (field) == FIELD_DECL)
4405 omp_firstprivatize_variable (ctx, DECL_FIELD_OFFSET (field));
4406 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (field));
4412 case REFERENCE_TYPE:
4413 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (type));
4420 omp_firstprivatize_variable (ctx, TYPE_SIZE (type));
4421 omp_firstprivatize_variable (ctx, TYPE_SIZE_UNIT (type));
4422 lang_hooks.types.omp_firstprivatize_type_sizes (ctx, type);
4425 /* Add an entry for DECL in the OpenMP context CTX with FLAGS. */
4428 omp_add_variable (struct gimplify_omp_ctx *ctx, tree decl, unsigned int flags)
4431 unsigned int nflags;
4434 if (decl == error_mark_node || TREE_TYPE (decl) == error_mark_node)
4437 /* Never elide decls whose type has TREE_ADDRESSABLE set. This means
4438 there are constructors involved somewhere. */
4439 if (TREE_ADDRESSABLE (TREE_TYPE (decl))
4440 || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (decl)))
4443 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
4446 /* We shouldn't be re-adding the decl with the same data
4448 gcc_assert ((n->value & GOVD_DATA_SHARE_CLASS & flags) == 0);
4449 /* The only combination of data sharing classes we should see is
4450 FIRSTPRIVATE and LASTPRIVATE. */
4451 nflags = n->value | flags;
4452 gcc_assert ((nflags & GOVD_DATA_SHARE_CLASS)
4453 == (GOVD_FIRSTPRIVATE | GOVD_LASTPRIVATE));
4458 /* When adding a variable-sized variable, we have to handle all sorts
4459 of additional bits of data: the pointer replacement variable, and
4460 the parameters of the type. */
4461 if (DECL_SIZE (decl) && TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
4463 /* Add the pointer replacement variable as PRIVATE if the variable
4464 replacement is private, else FIRSTPRIVATE since we'll need the
4465 address of the original variable either for SHARED, or for the
4466 copy into or out of the context. */
4467 if (!(flags & GOVD_LOCAL))
4469 nflags = flags & GOVD_PRIVATE ? GOVD_PRIVATE : GOVD_FIRSTPRIVATE;
4470 nflags |= flags & GOVD_SEEN;
4471 t = DECL_VALUE_EXPR (decl);
4472 gcc_assert (TREE_CODE (t) == INDIRECT_REF);
4473 t = TREE_OPERAND (t, 0);
4474 gcc_assert (DECL_P (t));
4475 omp_add_variable (ctx, t, nflags);
4478 /* Add all of the variable and type parameters (which should have
4479 been gimplified to a formal temporary) as FIRSTPRIVATE. */
4480 omp_firstprivatize_variable (ctx, DECL_SIZE_UNIT (decl));
4481 omp_firstprivatize_variable (ctx, DECL_SIZE (decl));
4482 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (decl));
4484 /* The variable-sized variable itself is never SHARED, only some form
4485 of PRIVATE. The sharing would take place via the pointer variable
4486 which we remapped above. */
4487 if (flags & GOVD_SHARED)
4488 flags = GOVD_PRIVATE | GOVD_DEBUG_PRIVATE
4489 | (flags & (GOVD_SEEN | GOVD_EXPLICIT));
4491 /* We're going to make use of the TYPE_SIZE_UNIT at least in the
4492 alloca statement we generate for the variable, so make sure it
4493 is available. This isn't automatically needed for the SHARED
4494 case, since we won't be allocating local storage then.
4495 For local variables TYPE_SIZE_UNIT might not be gimplified yet,
4496 in this case omp_notice_variable will be called later
4497 on when it is gimplified. */
4498 else if (! (flags & GOVD_LOCAL))
4499 omp_notice_variable (ctx, TYPE_SIZE_UNIT (TREE_TYPE (decl)), true);
4501 else if (lang_hooks.decls.omp_privatize_by_reference (decl))
4503 gcc_assert ((flags & GOVD_LOCAL) == 0);
4504 omp_firstprivatize_type_sizes (ctx, TREE_TYPE (decl));
4506 /* Similar to the direct variable sized case above, we'll need the
4507 size of references being privatized. */
4508 if ((flags & GOVD_SHARED) == 0)
4510 t = TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (decl)));
4511 if (TREE_CODE (t) != INTEGER_CST)
4512 omp_notice_variable (ctx, t, true);
4516 splay_tree_insert (ctx->variables, (splay_tree_key)decl, flags);
4519 /* Record the fact that DECL was used within the OpenMP context CTX.
4520 IN_CODE is true when real code uses DECL, and false when we should
4521 merely emit default(none) errors. Return true if DECL is going to
4522 be remapped and thus DECL shouldn't be gimplified into its
4523 DECL_VALUE_EXPR (if any). */
4526 omp_notice_variable (struct gimplify_omp_ctx *ctx, tree decl, bool in_code)
4529 unsigned flags = in_code ? GOVD_SEEN : 0;
4530 bool ret = false, shared;
4532 if (decl == error_mark_node || TREE_TYPE (decl) == error_mark_node)
4535 /* Threadprivate variables are predetermined. */
4536 if (is_global_var (decl))
4538 if (DECL_THREAD_LOCAL_P (decl))
4541 if (DECL_HAS_VALUE_EXPR_P (decl))
4543 tree value = get_base_address (DECL_VALUE_EXPR (decl));
4545 if (value && DECL_P (value) && DECL_THREAD_LOCAL_P (value))
4550 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
4553 enum omp_clause_default_kind default_kind, kind;
4555 if (!ctx->is_parallel)
4558 /* ??? Some compiler-generated variables (like SAVE_EXPRs) could be
4559 remapped firstprivate instead of shared. To some extent this is
4560 addressed in omp_firstprivatize_type_sizes, but not effectively. */
4561 default_kind = ctx->default_kind;
4562 kind = lang_hooks.decls.omp_predetermined_sharing (decl);
4563 if (kind != OMP_CLAUSE_DEFAULT_UNSPECIFIED)
4564 default_kind = kind;
4566 switch (default_kind)
4568 case OMP_CLAUSE_DEFAULT_NONE:
4569 error ("%qs not specified in enclosing parallel",
4570 IDENTIFIER_POINTER (DECL_NAME (decl)));
4571 error ("%Henclosing parallel", &ctx->location);
4573 case OMP_CLAUSE_DEFAULT_SHARED:
4574 flags |= GOVD_SHARED;
4576 case OMP_CLAUSE_DEFAULT_PRIVATE:
4577 flags |= GOVD_PRIVATE;
4583 omp_add_variable (ctx, decl, flags);
4585 shared = (flags & GOVD_SHARED) != 0;
4586 ret = lang_hooks.decls.omp_disregard_value_expr (decl, shared);
4590 shared = ((flags | n->value) & GOVD_SHARED) != 0;
4591 ret = lang_hooks.decls.omp_disregard_value_expr (decl, shared);
4593 /* If nothing changed, there's nothing left to do. */
4594 if ((n->value & flags) == flags)
4600 /* If the variable is private in the current context, then we don't
4601 need to propagate anything to an outer context. */
4602 if (flags & GOVD_PRIVATE)
4604 if (ctx->outer_context
4605 && omp_notice_variable (ctx->outer_context, decl, in_code))
4610 /* Verify that DECL is private within CTX. If there's specific information
4611 to the contrary in the innermost scope, generate an error. */
4614 omp_is_private (struct gimplify_omp_ctx *ctx, tree decl)
4618 n = splay_tree_lookup (ctx->variables, (splay_tree_key)decl);
4621 if (n->value & GOVD_SHARED)
4623 if (ctx == gimplify_omp_ctxp)
4625 error ("iteration variable %qs should be private",
4626 IDENTIFIER_POINTER (DECL_NAME (decl)));
4627 n->value = GOVD_PRIVATE;
4633 else if ((n->value & GOVD_EXPLICIT) != 0
4634 && (ctx == gimplify_omp_ctxp
4635 || (ctx->is_combined_parallel
4636 && gimplify_omp_ctxp->outer_context == ctx)))
4638 if ((n->value & GOVD_FIRSTPRIVATE) != 0)
4639 error ("iteration variable %qs should not be firstprivate",
4640 IDENTIFIER_POINTER (DECL_NAME (decl)));
4641 else if ((n->value & GOVD_REDUCTION) != 0)
4642 error ("iteration variable %qs should not be reduction",
4643 IDENTIFIER_POINTER (DECL_NAME (decl)));
4648 if (ctx->is_parallel)
4650 else if (ctx->outer_context)
4651 return omp_is_private (ctx->outer_context, decl);
4653 return !is_global_var (decl);
4656 /* Return true if DECL is private within a parallel region
4657 that binds to the current construct's context or in parallel
4658 region's REDUCTION clause. */
4661 omp_check_private (struct gimplify_omp_ctx *ctx, tree decl)
4667 ctx = ctx->outer_context;
4669 return !(is_global_var (decl)
4670 /* References might be private, but might be shared too. */
4671 || lang_hooks.decls.omp_privatize_by_reference (decl));
4673 n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
4675 return (n->value & GOVD_SHARED) == 0;
4677 while (!ctx->is_parallel);
4681 /* Scan the OpenMP clauses in *LIST_P, installing mappings into a new
4682 and previous omp contexts. */
4685 gimplify_scan_omp_clauses (tree *list_p, tree *pre_p, bool in_parallel,
4686 bool in_combined_parallel)
4688 struct gimplify_omp_ctx *ctx, *outer_ctx;
4691 ctx = new_omp_context (in_parallel, in_combined_parallel);
4692 outer_ctx = ctx->outer_context;
4694 while ((c = *list_p) != NULL)
4696 enum gimplify_status gs;
4697 bool remove = false;
4698 bool notice_outer = true;
4699 const char *check_non_private = NULL;
4703 switch (OMP_CLAUSE_CODE (c))
4705 case OMP_CLAUSE_PRIVATE:
4706 flags = GOVD_PRIVATE | GOVD_EXPLICIT;
4707 notice_outer = false;
4709 case OMP_CLAUSE_SHARED:
4710 flags = GOVD_SHARED | GOVD_EXPLICIT;
4712 case OMP_CLAUSE_FIRSTPRIVATE:
4713 flags = GOVD_FIRSTPRIVATE | GOVD_EXPLICIT;
4714 check_non_private = "firstprivate";
4716 case OMP_CLAUSE_LASTPRIVATE:
4717 flags = GOVD_LASTPRIVATE | GOVD_SEEN | GOVD_EXPLICIT;
4718 check_non_private = "lastprivate";
4720 case OMP_CLAUSE_REDUCTION:
4721 flags = GOVD_REDUCTION | GOVD_SEEN | GOVD_EXPLICIT;
4722 check_non_private = "reduction";
4726 decl = OMP_CLAUSE_DECL (c);
4727 if (decl == error_mark_node || TREE_TYPE (decl) == error_mark_node)
4732 omp_add_variable (ctx, decl, flags);
4733 if (OMP_CLAUSE_CODE (c) == OMP_CLAUSE_REDUCTION
4734 && OMP_CLAUSE_REDUCTION_PLACEHOLDER (c))
4736 omp_add_variable (ctx, OMP_CLAUSE_REDUCTION_PLACEHOLDER (c),
4737 GOVD_LOCAL | GOVD_SEEN);
4738 gimplify_omp_ctxp = ctx;
4739 push_gimplify_context ();
4740 gimplify_stmt (&OMP_CLAUSE_REDUCTION_INIT (c));
4741 pop_gimplify_context (OMP_CLAUSE_REDUCTION_INIT (c));
4742 push_gimplify_context ();
4743 gimplify_stmt (&OMP_CLAUSE_REDUCTION_MERGE (c));
4744 pop_gimplify_context (OMP_CLAUSE_REDUCTION_MERGE (c));
4745 gimplify_omp_ctxp = outer_ctx;
4751 case OMP_CLAUSE_COPYIN:
4752 case OMP_CLAUSE_COPYPRIVATE:
4753 decl = OMP_CLAUSE_DECL (c);
4754 if (decl == error_mark_node || TREE_TYPE (decl) == error_mark_node)
4761 omp_notice_variable (outer_ctx, decl, true);
4762 if (check_non_private
4764 && omp_check_private (ctx, decl))
4766 error ("%s variable %qs is private in outer context",
4767 check_non_private, IDENTIFIER_POINTER (DECL_NAME (decl)));
4773 OMP_CLAUSE_OPERAND (c, 0)
4774 = gimple_boolify (OMP_CLAUSE_OPERAND (c, 0));
4777 case OMP_CLAUSE_SCHEDULE:
4778 case OMP_CLAUSE_NUM_THREADS:
4779 gs = gimplify_expr (&OMP_CLAUSE_OPERAND (c, 0), pre_p, NULL,
4780 is_gimple_val, fb_rvalue);
4785 case OMP_CLAUSE_NOWAIT:
4786 case OMP_CLAUSE_ORDERED:
4789 case OMP_CLAUSE_DEFAULT:
4790 ctx->default_kind = OMP_CLAUSE_DEFAULT_KIND (c);
4798 *list_p = OMP_CLAUSE_CHAIN (c);
4800 list_p = &OMP_CLAUSE_CHAIN (c);
4803 gimplify_omp_ctxp = ctx;
4806 /* For all variables that were not actually used within the context,
4807 remove PRIVATE, SHARED, and FIRSTPRIVATE clauses. */
4810 gimplify_adjust_omp_clauses_1 (splay_tree_node n, void *data)
4812 tree *list_p = (tree *) data;
4813 tree decl = (tree) n->key;
4814 unsigned flags = n->value;
4815 enum omp_clause_code code;
4819 if (flags & (GOVD_EXPLICIT | GOVD_LOCAL))
4821 if ((flags & GOVD_SEEN) == 0)
4823 if (flags & GOVD_DEBUG_PRIVATE)
4825 gcc_assert ((flags & GOVD_DATA_SHARE_CLASS) == GOVD_PRIVATE);
4826 private_debug = true;
4830 = lang_hooks.decls.omp_private_debug_clause (decl,
4831 !!(flags & GOVD_SHARED));
4833 code = OMP_CLAUSE_PRIVATE;
4834 else if (flags & GOVD_SHARED)
4836 if (is_global_var (decl))
4838 code = OMP_CLAUSE_SHARED;
4840 else if (flags & GOVD_PRIVATE)
4841 code = OMP_CLAUSE_PRIVATE;
4842 else if (flags & GOVD_FIRSTPRIVATE)
4843 code = OMP_CLAUSE_FIRSTPRIVATE;
4847 clause = build_omp_clause (code);
4848 OMP_CLAUSE_DECL (clause) = decl;
4849 OMP_CLAUSE_CHAIN (clause) = *list_p;
4851 OMP_CLAUSE_PRIVATE_DEBUG (clause) = 1;
4858 gimplify_adjust_omp_clauses (tree *list_p)
4860 struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
4863 while ((c = *list_p) != NULL)
4866 bool remove = false;
4868 switch (OMP_CLAUSE_CODE (c))
4870 case OMP_CLAUSE_PRIVATE:
4871 case OMP_CLAUSE_SHARED:
4872 case OMP_CLAUSE_FIRSTPRIVATE:
4873 decl = OMP_CLAUSE_DECL (c);
4874 n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
4875 remove = !(n->value & GOVD_SEEN);
4878 bool shared = OMP_CLAUSE_CODE (c) == OMP_CLAUSE_SHARED;
4879 if ((n->value & GOVD_DEBUG_PRIVATE)
4880 || lang_hooks.decls.omp_private_debug_clause (decl, shared))
4882 gcc_assert ((n->value & GOVD_DEBUG_PRIVATE) == 0
4883 || ((n->value & GOVD_DATA_SHARE_CLASS)
4885 OMP_CLAUSE_SET_CODE (c, OMP_CLAUSE_PRIVATE);
4886 OMP_CLAUSE_PRIVATE_DEBUG (c) = 1;
4891 case OMP_CLAUSE_LASTPRIVATE:
4892 /* Make sure OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE is set to
4893 accurately reflect the presence of a FIRSTPRIVATE clause. */
4894 decl = OMP_CLAUSE_DECL (c);
4895 n = splay_tree_lookup (ctx->variables, (splay_tree_key) decl);
4896 OMP_CLAUSE_LASTPRIVATE_FIRSTPRIVATE (c)
4897 = (n->value & GOVD_FIRSTPRIVATE) != 0;
4900 case OMP_CLAUSE_REDUCTION:
4901 case OMP_CLAUSE_COPYIN:
4902 case OMP_CLAUSE_COPYPRIVATE:
4904 case OMP_CLAUSE_NUM_THREADS:
4905 case OMP_CLAUSE_SCHEDULE:
4906 case OMP_CLAUSE_NOWAIT:
4907 case OMP_CLAUSE_ORDERED:
4908 case OMP_CLAUSE_DEFAULT:
4916 *list_p = OMP_CLAUSE_CHAIN (c);
4918 list_p = &OMP_CLAUSE_CHAIN (c);
4921 /* Add in any implicit data sharing. */
4922 splay_tree_foreach (ctx->variables, gimplify_adjust_omp_clauses_1, list_p);
4924 gimplify_omp_ctxp = ctx->outer_context;
4925 delete_omp_context (ctx);
4928 /* Gimplify the contents of an OMP_PARALLEL statement. This involves
4929 gimplification of the body, as well as scanning the body for used
4930 variables. We need to do this scan now, because variable-sized
4931 decls will be decomposed during gimplification. */
4933 static enum gimplify_status
4934 gimplify_omp_parallel (tree *expr_p, tree *pre_p)
4936 tree expr = *expr_p;
4938 gimplify_scan_omp_clauses (&OMP_PARALLEL_CLAUSES (expr), pre_p, true,
4939 OMP_PARALLEL_COMBINED (expr));
4941 push_gimplify_context ();
4943 gimplify_stmt (&OMP_PARALLEL_BODY (expr));
4945 if (TREE_CODE (OMP_PARALLEL_BODY (expr)) == BIND_EXPR)
4946 pop_gimplify_context (OMP_PARALLEL_BODY (expr));
4948 pop_gimplify_context (NULL_TREE);
4950 gimplify_adjust_omp_clauses (&OMP_PARALLEL_CLAUSES (expr));
4955 /* Gimplify the gross structure of an OMP_FOR statement. */
4957 static enum gimplify_status
4958 gimplify_omp_for (tree *expr_p, tree *pre_p)
4960 tree for_stmt, decl, t;
4961 enum gimplify_status ret = GS_OK;
4965 gimplify_scan_omp_clauses (&OMP_FOR_CLAUSES (for_stmt), pre_p, false, false);
4967 t = OMP_FOR_INIT (for_stmt);
4968 gcc_assert (TREE_CODE (t) == MODIFY_EXPR
4969 || TREE_CODE (t) == GIMPLE_MODIFY_STMT);
4970 decl = GENERIC_TREE_OPERAND (t, 0);
4971 gcc_assert (DECL_P (decl));
4972 gcc_assert (INTEGRAL_TYPE_P (TREE_TYPE (decl)));
4974 /* Make sure the iteration variable is private. */
4975 if (omp_is_private (gimplify_omp_ctxp, decl))
4976 omp_notice_variable (gimplify_omp_ctxp, decl, true);
4978 omp_add_variable (gimplify_omp_ctxp, decl, GOVD_PRIVATE | GOVD_SEEN);
4980 ret |= gimplify_expr (&GENERIC_TREE_OPERAND (t, 1),
4981 &OMP_FOR_PRE_BODY (for_stmt),
4982 NULL, is_gimple_val, fb_rvalue);
4984 tree_to_gimple_tuple (&OMP_FOR_INIT (for_stmt));
4986 t = OMP_FOR_COND (for_stmt);
4987 gcc_assert (COMPARISON_CLASS_P (t));
4988 gcc_assert (GENERIC_TREE_OPERAND (t, 0) == decl);
4990 ret |= gimplify_expr (&GENERIC_TREE_OPERAND (t, 1),
4991 &OMP_FOR_PRE_BODY (for_stmt),
4992 NULL, is_gimple_val, fb_rvalue);
4994 tree_to_gimple_tuple (&OMP_FOR_INCR (for_stmt));
4995 t = OMP_FOR_INCR (for_stmt);
4996 switch (TREE_CODE (t))
4998 case PREINCREMENT_EXPR:
4999 case POSTINCREMENT_EXPR:
5000 t = build_int_cst (TREE_TYPE (decl), 1);
5001 t = build2 (PLUS_EXPR, TREE_TYPE (decl), decl, t);
5002 t = build_gimple_modify_stmt (decl, t);
5003 OMP_FOR_INCR (for_stmt) = t;
5006 case PREDECREMENT_EXPR:
5007 case POSTDECREMENT_EXPR:
5008 t = build_int_cst (TREE_TYPE (decl), -1);
5009 t = build2 (PLUS_EXPR, TREE_TYPE (decl), decl, t);
5010 t = build_gimple_modify_stmt (decl, t);
5011 OMP_FOR_INCR (for_stmt) = t;
5014 case GIMPLE_MODIFY_STMT:
5015 gcc_assert (GIMPLE_STMT_OPERAND (t, 0) == decl);
5016 t = GIMPLE_STMT_OPERAND (t, 1);
5017 switch (TREE_CODE (t))
5020 if (TREE_OPERAND (t, 1) == decl)
5022 TREE_OPERAND (t, 1) = TREE_OPERAND (t, 0);
5023 TREE_OPERAND (t, 0) = decl;
5027 gcc_assert (TREE_OPERAND (t, 0) == decl);
5033 ret |= gimplify_expr (&TREE_OPERAND (t, 1), &OMP_FOR_PRE_BODY (for_stmt),
5034 NULL, is_gimple_val, fb_rvalue);
5041 gimplify_to_stmt_list (&OMP_FOR_BODY (for_stmt));
5042 gimplify_adjust_omp_clauses (&OMP_FOR_CLAUSES (for_stmt));
5044 return ret == GS_ALL_DONE ? GS_ALL_DONE : GS_ERROR;
5047 /* Gimplify the gross structure of other OpenMP worksharing constructs.
5048 In particular, OMP_SECTIONS and OMP_SINGLE. */
5050 static enum gimplify_status
5051 gimplify_omp_workshare (tree *expr_p, tree *pre_p)
5053 tree stmt = *expr_p;
5055 gimplify_scan_omp_clauses (&OMP_CLAUSES (stmt), pre_p, false, false);
5056 gimplify_to_stmt_list (&OMP_BODY (stmt));
5057 gimplify_adjust_omp_clauses (&OMP_CLAUSES (stmt));
5062 /* A subroutine of gimplify_omp_atomic. The front end is supposed to have
5063 stabilized the lhs of the atomic operation as *ADDR. Return true if
5064 EXPR is this stabilized form. */
5067 goa_lhs_expr_p (tree expr, tree addr)
5069 /* Also include casts to other type variants. The C front end is fond
5070 of adding these for e.g. volatile variables. This is like
5071 STRIP_TYPE_NOPS but includes the main variant lookup. */
5072 while ((TREE_CODE (expr) == NOP_EXPR
5073 || TREE_CODE (expr) == CONVERT_EXPR
5074 || TREE_CODE (expr) == NON_LVALUE_EXPR)
5075 && TREE_OPERAND (expr, 0) != error_mark_node
5076 && (TYPE_MAIN_VARIANT (TREE_TYPE (expr))
5077 == TYPE_MAIN_VARIANT (TREE_TYPE (TREE_OPERAND (expr, 0)))))
5078 expr = TREE_OPERAND (expr, 0);
5080 if (TREE_CODE (expr) == INDIRECT_REF && TREE_OPERAND (expr, 0) == addr)
5082 if (TREE_CODE (addr) == ADDR_EXPR && expr == TREE_OPERAND (addr, 0))
5087 /* A subroutine of gimplify_omp_atomic. Attempt to implement the atomic
5088 operation as a __sync_fetch_and_op builtin. INDEX is log2 of the
5089 size of the data type, and thus usable to find the index of the builtin
5090 decl. Returns GS_UNHANDLED if the expression is not of the proper form. */
5092 static enum gimplify_status
5093 gimplify_omp_atomic_fetch_op (tree *expr_p, tree addr, tree rhs, int index)
5095 enum built_in_function base;
5097 enum insn_code *optab;
5099 /* Check for one of the supported fetch-op operations. */
5100 switch (TREE_CODE (rhs))
5103 base = BUILT_IN_FETCH_AND_ADD_N;
5104 optab = sync_add_optab;
5107 base = BUILT_IN_FETCH_AND_SUB_N;
5108 optab = sync_add_optab;
5111 base = BUILT_IN_FETCH_AND_AND_N;
5112 optab = sync_and_optab;
5115 base = BUILT_IN_FETCH_AND_OR_N;
5116 optab = sync_ior_optab;
5119 base = BUILT_IN_FETCH_AND_XOR_N;
5120 optab = sync_xor_optab;
5123 return GS_UNHANDLED;
5126 /* Make sure the expression is of the proper form. */
5127 if (goa_lhs_expr_p (TREE_OPERAND (rhs, 0), addr))
5128 rhs = TREE_OPERAND (rhs, 1);
5129 else if (commutative_tree_code (TREE_CODE (rhs))
5130 && goa_lhs_expr_p (TREE_OPERAND (rhs, 1), addr))
5131 rhs = TREE_OPERAND (rhs, 0);
5133 return GS_UNHANDLED;
5135 decl = built_in_decls[base + index + 1];
5136 itype = TREE_TYPE (TREE_TYPE (decl));
5138 if (optab[TYPE_MODE (itype)] == CODE_FOR_nothing)
5139 return GS_UNHANDLED;
5141 *expr_p = build_call_expr (decl, 2, addr, fold_convert (itype, rhs));
5145 /* A subroutine of gimplify_omp_atomic_pipeline. Walk *EXPR_P and replace
5146 appearances of *LHS_ADDR with LHS_VAR. If an expression does not involve
5147 the lhs, evaluate it into a temporary. Return 1 if the lhs appeared as
5148 a subexpression, 0 if it did not, or -1 if an error was encountered. */
5151 goa_stabilize_expr (tree *expr_p, tree *pre_p, tree lhs_addr, tree lhs_var)
5153 tree expr = *expr_p;
5156 if (goa_lhs_expr_p (expr, lhs_addr))
5161 if (is_gimple_val (expr))
5165 switch (TREE_CODE_CLASS (TREE_CODE (expr)))
5168 saw_lhs |= goa_stabilize_expr (&TREE_OPERAND (expr, 1), pre_p,
5171 saw_lhs |= goa_stabilize_expr (&TREE_OPERAND (expr, 0), pre_p,
5180 enum gimplify_status gs;
5181 gs = gimplify_expr (expr_p, pre_p, NULL, is_gimple_val, fb_rvalue);
5182 if (gs != GS_ALL_DONE)
5189 /* A subroutine of gimplify_omp_atomic. Implement the atomic operation as:
5193 newval = rhs; // with oldval replacing *addr in rhs
5194 oldval = __sync_val_compare_and_swap (addr, oldval, newval);
5195 if (oldval != newval)
5198 INDEX is log2 of the size of the data type, and thus usable to find the
5199 index of the builtin decl. */
5201 static enum gimplify_status
5202 gimplify_omp_atomic_pipeline (tree *expr_p, tree *pre_p, tree addr,
5203 tree rhs, int index)
5205 tree oldval, oldival, oldival2, newval, newival, label;
5206 tree type, itype, cmpxchg, x, iaddr;
5208 cmpxchg = built_in_decls[BUILT_IN_VAL_COMPARE_AND_SWAP_N + index + 1];
5209 type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (addr)));
5210 itype = TREE_TYPE (TREE_TYPE (cmpxchg));
5212 if (sync_compare_and_swap[TYPE_MODE (itype)] == CODE_FOR_nothing)
5213 return GS_UNHANDLED;
5215 oldval = create_tmp_var (type, NULL);
5216 newval = create_tmp_var (type, NULL);
5218 /* Precompute as much of RHS as possible. In the same walk, replace
5219 occurrences of the lhs value with our temporary. */
5220 if (goa_stabilize_expr (&rhs, pre_p, addr, oldval) < 0)
5223 x = build_fold_indirect_ref (addr);
5224 x = build_gimple_modify_stmt (oldval, x);
5225 gimplify_and_add (x, pre_p);
5227 /* For floating-point values, we'll need to view-convert them to integers
5228 so that we can perform the atomic compare and swap. Simplify the
5229 following code by always setting up the "i"ntegral variables. */
5230 if (INTEGRAL_TYPE_P (type) || POINTER_TYPE_P (type))
5238 oldival = create_tmp_var (itype, NULL);
5239 newival = create_tmp_var (itype, NULL);
5241 x = build1 (VIEW_CONVERT_EXPR, itype, oldval);
5242 x = build_gimple_modify_stmt (oldival, x);
5243 gimplify_and_add (x, pre_p);
5244 iaddr = fold_convert (build_pointer_type (itype), addr);
5247 oldival2 = create_tmp_var (itype, NULL);
5249 label = create_artificial_label ();
5250 x = build1 (LABEL_EXPR, void_type_node, label);
5251 gimplify_and_add (x, pre_p);
5253 x = build_gimple_modify_stmt (newval, rhs);
5254 gimplify_and_add (x, pre_p);
5256 if (newval != newival)
5258 x = build1 (VIEW_CONVERT_EXPR, itype, newval);
5259 x = build_gimple_modify_stmt (newival, x);
5260 gimplify_and_add (x, pre_p);
5263 x = build_gimple_modify_stmt (oldival2, fold_convert (itype, oldival));
5264 gimplify_and_add (x, pre_p);
5266 x = build_call_expr (cmpxchg, 3, iaddr, fold_convert (itype, oldival),
5267 fold_convert (itype, newival));
5268 if (oldval == oldival)
5269 x = fold_convert (type, x);
5270 x = build_gimple_modify_stmt (oldival, x);
5271 gimplify_and_add (x, pre_p);
5273 /* For floating point, be prepared for the loop backedge. */
5274 if (oldval != oldival)
5276 x = build1 (VIEW_CONVERT_EXPR, type, oldival);
5277 x = build_gimple_modify_stmt (oldval, x);
5278 gimplify_and_add (x, pre_p);
5281 /* Note that we always perform the comparison as an integer, even for
5282 floating point. This allows the atomic operation to properly
5283 succeed even with NaNs and -0.0. */
5284 x = build3 (COND_EXPR, void_type_node,
5285 build2 (NE_EXPR, boolean_type_node, oldival, oldival2),
5286 build1 (GOTO_EXPR, void_type_node, label), NULL);
5287 gimplify_and_add (x, pre_p);
5293 /* A subroutine of gimplify_omp_atomic. Implement the atomic operation as:
5295 GOMP_atomic_start ();
5299 The result is not globally atomic, but works so long as all parallel
5300 references are within #pragma omp atomic directives. According to
5301 responses received from omp@openmp.org, appears to be within spec.
5302 Which makes sense, since that's how several other compilers handle
5303 this situation as well. */
5305 static enum gimplify_status
5306 gimplify_omp_atomic_mutex (tree *expr_p, tree *pre_p, tree addr, tree rhs)
5310 t = built_in_decls[BUILT_IN_GOMP_ATOMIC_START];
5311 t = build_call_expr (t, 0);
5312 gimplify_and_add (t, pre_p);
5314 t = build_fold_indirect_ref (addr);
5315 t = build_gimple_modify_stmt (t, rhs);
5316 gimplify_and_add (t, pre_p);
5318 t = built_in_decls[BUILT_IN_GOMP_ATOMIC_END];
5319 t = build_call_expr (t, 0);
5320 gimplify_and_add (t, pre_p);
5326 /* Gimplify an OMP_ATOMIC statement. */
5328 static enum gimplify_status
5329 gimplify_omp_atomic (tree *expr_p, tree *pre_p)
5331 tree addr = TREE_OPERAND (*expr_p, 0);
5332 tree rhs = TREE_OPERAND (*expr_p, 1);
5333 tree type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (addr)));
5334 HOST_WIDE_INT index;
5336 /* Make sure the type is one of the supported sizes. */
5337 index = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
5338 index = exact_log2 (index);
5339 if (index >= 0 && index <= 4)
5341 enum gimplify_status gs;
5344 if (DECL_P (TREE_OPERAND (addr, 0)))
5345 align = DECL_ALIGN_UNIT (TREE_OPERAND (addr, 0));
5346 else if (TREE_CODE (TREE_OPERAND (addr, 0)) == COMPONENT_REF
5347 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (addr, 0), 1))
5349 align = DECL_ALIGN_UNIT (TREE_OPERAND (TREE_OPERAND (addr, 0), 1));
5351 align = TYPE_ALIGN_UNIT (type);
5353 /* __sync builtins require strict data alignment. */
5354 if (exact_log2 (align) >= index)
5356 /* When possible, use specialized atomic update functions. */
5357 if (INTEGRAL_TYPE_P (type) || POINTER_TYPE_P (type))
5359 gs = gimplify_omp_atomic_fetch_op (expr_p, addr, rhs, index);
5360 if (gs != GS_UNHANDLED)
5364 /* If we don't have specialized __sync builtins, try and implement
5365 as a compare and swap loop. */
5366 gs = gimplify_omp_atomic_pipeline (expr_p, pre_p, addr, rhs, index);
5367 if (gs != GS_UNHANDLED)
5372 /* The ultimate fallback is wrapping the operation in a mutex. */
5373 return gimplify_omp_atomic_mutex (expr_p, pre_p, addr, rhs);
5376 /* Gimplifies the expression tree pointed to by EXPR_P. Return 0 if
5377 gimplification failed.
5379 PRE_P points to the list where side effects that must happen before
5380 EXPR should be stored.
5382 POST_P points to the list where side effects that must happen after
5383 EXPR should be stored, or NULL if there is no suitable list. In
5384 that case, we copy the result to a temporary, emit the
5385 post-effects, and then return the temporary.
5387 GIMPLE_TEST_F points to a function that takes a tree T and
5388 returns nonzero if T is in the GIMPLE form requested by the
5389 caller. The GIMPLE predicates are in tree-gimple.c.
5391 This test is used twice. Before gimplification, the test is
5392 invoked to determine whether *EXPR_P is already gimple enough. If
5393 that fails, *EXPR_P is gimplified according to its code and
5394 GIMPLE_TEST_F is called again. If the test still fails, then a new
5395 temporary variable is created and assigned the value of the
5396 gimplified expression.
5398 FALLBACK tells the function what sort of a temporary we want. If the 1
5399 bit is set, an rvalue is OK. If the 2 bit is set, an lvalue is OK.
5400 If both are set, either is OK, but an lvalue is preferable.
5402 The return value is either GS_ERROR or GS_ALL_DONE, since this function
5403 iterates until solution. */
5405 enum gimplify_status
5406 gimplify_expr (tree *expr_p, tree *pre_p, tree *post_p,
5407 bool (* gimple_test_f) (tree), fallback_t fallback)
5410 tree internal_pre = NULL_TREE;
5411 tree internal_post = NULL_TREE;
5413 int is_statement = (pre_p == NULL);
5414 location_t saved_location;
5415 enum gimplify_status ret;
5417 save_expr = *expr_p;
5418 if (save_expr == NULL_TREE)
5421 /* We used to check the predicate here and return immediately if it
5422 succeeds. This is wrong; the design is for gimplification to be
5423 idempotent, and for the predicates to only test for valid forms, not
5424 whether they are fully simplified. */
5426 /* Set up our internal queues if needed. */
5428 pre_p = &internal_pre;
5430 post_p = &internal_post;
5432 saved_location = input_location;
5433 if (save_expr != error_mark_node
5434 && EXPR_HAS_LOCATION (*expr_p))
5435 input_location = EXPR_LOCATION (*expr_p);
5437 /* Loop over the specific gimplifiers until the toplevel node
5438 remains the same. */
5441 /* Strip away as many useless type conversions as possible
5443 STRIP_USELESS_TYPE_CONVERSION (*expr_p);
5445 /* Remember the expr. */
5446 save_expr = *expr_p;
5448 /* Die, die, die, my darling. */
5449 if (save_expr == error_mark_node
5450 || (!GIMPLE_STMT_P (save_expr)
5451 && TREE_TYPE (save_expr)
5452 && TREE_TYPE (save_expr) == error_mark_node))
5458 /* Do any language-specific gimplification. */
5459 ret = lang_hooks.gimplify_expr (expr_p, pre_p, post_p);
5462 if (*expr_p == NULL_TREE)
5464 if (*expr_p != save_expr)
5467 else if (ret != GS_UNHANDLED)
5471 switch (TREE_CODE (*expr_p))
5473 /* First deal with the special cases. */
5475 case POSTINCREMENT_EXPR:
5476 case POSTDECREMENT_EXPR:
5477 case PREINCREMENT_EXPR:
5478 case PREDECREMENT_EXPR:
5479 ret = gimplify_self_mod_expr (expr_p, pre_p, post_p,
5480 fallback != fb_none);
5484 case ARRAY_RANGE_REF:
5488 case VIEW_CONVERT_EXPR:
5489 ret = gimplify_compound_lval (expr_p, pre_p, post_p,
5490 fallback ? fallback : fb_rvalue);
5494 ret = gimplify_cond_expr (expr_p, pre_p, fallback);
5495 /* C99 code may assign to an array in a structure value of a
5496 conditional expression, and this has undefined behavior
5497 only on execution, so create a temporary if an lvalue is
5499 if (fallback == fb_lvalue)
5501 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
5502 lang_hooks.mark_addressable (*expr_p);
5507 ret = gimplify_call_expr (expr_p, pre_p, fallback != fb_none);
5508 /* C99 code may assign to an array in a structure returned
5509 from a function, and this has undefined behavior only on
5510 execution, so create a temporary if an lvalue is
5512 if (fallback == fb_lvalue)
5514 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
5515 lang_hooks.mark_addressable (*expr_p);
5523 ret = gimplify_compound_expr (expr_p, pre_p, fallback != fb_none);
5527 case GIMPLE_MODIFY_STMT:
5529 ret = gimplify_modify_expr (expr_p, pre_p, post_p,
5530 fallback != fb_none);
5534 /* The distinction between MODIFY_EXPR and INIT_EXPR is no longer
5536 if (TREE_CODE (*expr_p) == INIT_EXPR)
5537 TREE_SET_CODE (*expr_p, MODIFY_EXPR);
5539 /* Convert MODIFY_EXPR to GIMPLE_MODIFY_STMT. */
5540 if (TREE_CODE (*expr_p) == MODIFY_EXPR)
5541 tree_to_gimple_tuple (expr_p);
5546 case TRUTH_ANDIF_EXPR:
5547 case TRUTH_ORIF_EXPR:
5548 ret = gimplify_boolean_expr (expr_p);
5551 case TRUTH_NOT_EXPR:
5552 TREE_OPERAND (*expr_p, 0)
5553 = gimple_boolify (TREE_OPERAND (*expr_p, 0));
5554 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
5555 is_gimple_val, fb_rvalue);
5556 recalculate_side_effects (*expr_p);
5560 ret = gimplify_addr_expr (expr_p, pre_p, post_p);
5564 ret = gimplify_va_arg_expr (expr_p, pre_p, post_p);
5569 if (IS_EMPTY_STMT (*expr_p))
5575 if (VOID_TYPE_P (TREE_TYPE (*expr_p))
5576 || fallback == fb_none)
5578 /* Just strip a conversion to void (or in void context) and
5580 *expr_p = TREE_OPERAND (*expr_p, 0);
5584 ret = gimplify_conversion (expr_p);
5585 if (ret == GS_ERROR)
5587 if (*expr_p != save_expr)
5591 case FIX_TRUNC_EXPR:
5592 /* unary_expr: ... | '(' cast ')' val | ... */
5593 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
5594 is_gimple_val, fb_rvalue);
5595 recalculate_side_effects (*expr_p);
5599 *expr_p = fold_indirect_ref (*expr_p);
5600 if (*expr_p != save_expr)
5602 /* else fall through. */
5603 case ALIGN_INDIRECT_REF:
5604 case MISALIGNED_INDIRECT_REF:
5605 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
5606 is_gimple_reg, fb_rvalue);
5607 recalculate_side_effects (*expr_p);
5610 /* Constants need not be gimplified. */
5620 /* If we require an lvalue, such as for ADDR_EXPR, retain the
5621 CONST_DECL node. Otherwise the decl is replaceable by its
5623 /* ??? Should be == fb_lvalue, but ADDR_EXPR passes fb_either. */
5624 if (fallback & fb_lvalue)
5627 *expr_p = DECL_INITIAL (*expr_p);
5631 ret = gimplify_decl_expr (expr_p);
5635 /* FIXME make this a decl. */
5640 ret = gimplify_bind_expr (expr_p, pre_p);
5644 ret = gimplify_loop_expr (expr_p, pre_p);
5648 ret = gimplify_switch_expr (expr_p, pre_p);
5652 ret = gimplify_exit_expr (expr_p);
5656 /* If the target is not LABEL, then it is a computed jump
5657 and the target needs to be gimplified. */
5658 if (TREE_CODE (GOTO_DESTINATION (*expr_p)) != LABEL_DECL)
5659 ret = gimplify_expr (&GOTO_DESTINATION (*expr_p), pre_p,
5660 NULL, is_gimple_val, fb_rvalue);
5665 gcc_assert (decl_function_context (LABEL_EXPR_LABEL (*expr_p))
5666 == current_function_decl);
5669 case CASE_LABEL_EXPR:
5670 ret = gimplify_case_label_expr (expr_p);
5674 ret = gimplify_return_expr (*expr_p, pre_p);
5678 /* Don't reduce this in place; let gimplify_init_constructor work its
5679 magic. Buf if we're just elaborating this for side effects, just
5680 gimplify any element that has side-effects. */
5681 if (fallback == fb_none)
5683 unsigned HOST_WIDE_INT ix;
5684 constructor_elt *ce;
5685 tree temp = NULL_TREE;
5687 VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (*expr_p),
5690 if (TREE_SIDE_EFFECTS (ce->value))
5691 append_to_statement_list (ce->value, &temp);
5696 /* C99 code may assign to an array in a constructed
5697 structure or union, and this has undefined behavior only
5698 on execution, so create a temporary if an lvalue is
5700 else if (fallback == fb_lvalue)
5702 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
5703 lang_hooks.mark_addressable (*expr_p);
5709 /* The following are special cases that are not handled by the
5710 original GIMPLE grammar. */
5712 /* SAVE_EXPR nodes are converted into a GIMPLE identifier and
5715 ret = gimplify_save_expr (expr_p, pre_p, post_p);
5720 enum gimplify_status r0, r1, r2;
5722 r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
5723 is_gimple_lvalue, fb_either);
5724 r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p,
5725 is_gimple_val, fb_rvalue);
5726 r2 = gimplify_expr (&TREE_OPERAND (*expr_p, 2), pre_p, post_p,
5727 is_gimple_val, fb_rvalue);
5728 recalculate_side_effects (*expr_p);
5730 ret = MIN (r0, MIN (r1, r2));
5734 case NON_LVALUE_EXPR:
5735 /* This should have been stripped above. */
5739 ret = gimplify_asm_expr (expr_p, pre_p, post_p);
5742 case TRY_FINALLY_EXPR:
5743 case TRY_CATCH_EXPR:
5744 gimplify_to_stmt_list (&TREE_OPERAND (*expr_p, 0));
5745 gimplify_to_stmt_list (&TREE_OPERAND (*expr_p, 1));
5749 case CLEANUP_POINT_EXPR:
5750 ret = gimplify_cleanup_point_expr (expr_p, pre_p);
5754 ret = gimplify_target_expr (expr_p, pre_p, post_p);
5758 gimplify_to_stmt_list (&CATCH_BODY (*expr_p));
5762 case EH_FILTER_EXPR:
5763 gimplify_to_stmt_list (&EH_FILTER_FAILURE (*expr_p));
5769 enum gimplify_status r0, r1;
5770 r0 = gimplify_expr (&OBJ_TYPE_REF_OBJECT (*expr_p), pre_p, post_p,
5771 is_gimple_val, fb_rvalue);
5772 r1 = gimplify_expr (&OBJ_TYPE_REF_EXPR (*expr_p), pre_p, post_p,
5773 is_gimple_val, fb_rvalue);
5779 /* We get here when taking the address of a label. We mark
5780 the label as "forced"; meaning it can never be removed and
5781 it is a potential target for any computed goto. */
5782 FORCED_LABEL (*expr_p) = 1;
5786 case STATEMENT_LIST:
5787 ret = gimplify_statement_list (expr_p, pre_p);
5790 case WITH_SIZE_EXPR:
5792 gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
5793 post_p == &internal_post ? NULL : post_p,
5794 gimple_test_f, fallback);
5795 gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p,
5796 is_gimple_val, fb_rvalue);
5802 ret = gimplify_var_or_parm_decl (expr_p);
5806 /* When within an OpenMP context, notice uses of variables. */
5807 if (gimplify_omp_ctxp)
5808 omp_notice_variable (gimplify_omp_ctxp, *expr_p, true);
5813 /* Allow callbacks into the gimplifier during optimization. */
5818 ret = gimplify_omp_parallel (expr_p, pre_p);
5822 ret = gimplify_omp_for (expr_p, pre_p);
5827 ret = gimplify_omp_workshare (expr_p, pre_p);
5834 gimplify_to_stmt_list (&OMP_BODY (*expr_p));
5838 ret = gimplify_omp_atomic (expr_p, pre_p);
5847 switch (TREE_CODE_CLASS (TREE_CODE (*expr_p)))
5849 case tcc_comparison:
5850 /* Handle comparison of objects of non scalar mode aggregates
5851 with a call to memcmp. It would be nice to only have to do
5852 this for variable-sized objects, but then we'd have to allow
5853 the same nest of reference nodes we allow for MODIFY_EXPR and
5856 Compare scalar mode aggregates as scalar mode values. Using
5857 memcmp for them would be very inefficient at best, and is
5858 plain wrong if bitfields are involved. */
5861 tree type = TREE_TYPE (TREE_OPERAND (*expr_p, 1));
5863 if (!AGGREGATE_TYPE_P (type))
5865 else if (TYPE_MODE (type) != BLKmode)
5866 ret = gimplify_scalar_mode_aggregate_compare (expr_p);
5868 ret = gimplify_variable_sized_compare (expr_p);
5873 /* If *EXPR_P does not need to be special-cased, handle it
5874 according to its class. */
5876 ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
5877 post_p, is_gimple_val, fb_rvalue);
5883 enum gimplify_status r0, r1;
5885 r0 = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p,
5886 post_p, is_gimple_val, fb_rvalue);
5887 r1 = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p,
5888 post_p, is_gimple_val, fb_rvalue);
5894 case tcc_declaration:
5897 goto dont_recalculate;
5900 gcc_assert (TREE_CODE (*expr_p) == TRUTH_AND_EXPR
5901 || TREE_CODE (*expr_p) == TRUTH_OR_EXPR
5902 || TREE_CODE (*expr_p) == TRUTH_XOR_EXPR);
5906 recalculate_side_effects (*expr_p);
5911 /* If we replaced *expr_p, gimplify again. */
5912 if (ret == GS_OK && (*expr_p == NULL || *expr_p == save_expr))
5915 while (ret == GS_OK);
5917 /* If we encountered an error_mark somewhere nested inside, either
5918 stub out the statement or propagate the error back out. */
5919 if (ret == GS_ERROR)
5926 /* This was only valid as a return value from the langhook, which
5927 we handled. Make sure it doesn't escape from any other context. */
5928 gcc_assert (ret != GS_UNHANDLED);
5930 if (fallback == fb_none && *expr_p && !is_gimple_stmt (*expr_p))
5932 /* We aren't looking for a value, and we don't have a valid
5933 statement. If it doesn't have side-effects, throw it away. */
5934 if (!TREE_SIDE_EFFECTS (*expr_p))
5936 else if (!TREE_THIS_VOLATILE (*expr_p))
5938 /* This is probably a _REF that contains something nested that
5939 has side effects. Recurse through the operands to find it. */
5940 enum tree_code code = TREE_CODE (*expr_p);
5947 case VIEW_CONVERT_EXPR:
5948 gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
5949 gimple_test_f, fallback);
5953 case ARRAY_RANGE_REF:
5954 gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p,
5955 gimple_test_f, fallback);
5956 gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p,
5957 gimple_test_f, fallback);
5961 /* Anything else with side-effects must be converted to
5962 a valid statement before we get here. */
5968 else if (COMPLETE_TYPE_P (TREE_TYPE (*expr_p))
5969 && TYPE_MODE (TREE_TYPE (*expr_p)) != BLKmode)
5971 /* Historically, the compiler has treated a bare reference
5972 to a non-BLKmode volatile lvalue as forcing a load. */
5973 tree type = TYPE_MAIN_VARIANT (TREE_TYPE (*expr_p));
5974 /* Normally, we do not want to create a temporary for a
5975 TREE_ADDRESSABLE type because such a type should not be
5976 copied by bitwise-assignment. However, we make an
5977 exception here, as all we are doing here is ensuring that
5978 we read the bytes that make up the type. We use
5979 create_tmp_var_raw because create_tmp_var will abort when
5980 given a TREE_ADDRESSABLE type. */
5981 tree tmp = create_tmp_var_raw (type, "vol");
5982 gimple_add_tmp_var (tmp);
5983 *expr_p = build_gimple_modify_stmt (tmp, *expr_p);
5986 /* We can't do anything useful with a volatile reference to
5987 an incomplete type, so just throw it away. Likewise for
5988 a BLKmode type, since any implicit inner load should
5989 already have been turned into an explicit one by the
5990 gimplification process. */
5994 /* If we are gimplifying at the statement level, we're done. Tack
5995 everything together and replace the original statement with the
5997 if (fallback == fb_none || is_statement)
5999 if (internal_pre || internal_post)
6001 append_to_statement_list (*expr_p, &internal_pre);
6002 append_to_statement_list (internal_post, &internal_pre);
6003 annotate_all_with_locus (&internal_pre, input_location);
6004 *expr_p = internal_pre;
6008 else if (TREE_CODE (*expr_p) == STATEMENT_LIST)
6009 annotate_all_with_locus (expr_p, input_location);
6011 annotate_one_with_locus (*expr_p, input_location);
6015 /* Otherwise we're gimplifying a subexpression, so the resulting value is
6018 /* If it's sufficiently simple already, we're done. Unless we are
6019 handling some post-effects internally; if that's the case, we need to
6020 copy into a temp before adding the post-effects to the tree. */
6021 if (!internal_post && (*gimple_test_f) (*expr_p))
6024 /* Otherwise, we need to create a new temporary for the gimplified
6027 /* We can't return an lvalue if we have an internal postqueue. The
6028 object the lvalue refers to would (probably) be modified by the
6029 postqueue; we need to copy the value out first, which means an
6031 if ((fallback & fb_lvalue) && !internal_post
6032 && is_gimple_addressable (*expr_p))
6034 /* An lvalue will do. Take the address of the expression, store it
6035 in a temporary, and replace the expression with an INDIRECT_REF of
6037 tmp = build_fold_addr_expr (*expr_p);
6038 gimplify_expr (&tmp, pre_p, post_p, is_gimple_reg, fb_rvalue);
6039 *expr_p = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (tmp)), tmp);
6041 else if ((fallback & fb_rvalue) && is_gimple_formal_tmp_rhs (*expr_p))
6043 gcc_assert (!VOID_TYPE_P (TREE_TYPE (*expr_p)));
6045 /* An rvalue will do. Assign the gimplified expression into a new
6046 temporary TMP and replace the original expression with TMP. */
6048 if (internal_post || (fallback & fb_lvalue))
6049 /* The postqueue might change the value of the expression between
6050 the initialization and use of the temporary, so we can't use a
6051 formal temp. FIXME do we care? */
6052 *expr_p = get_initialized_tmp_var (*expr_p, pre_p, post_p);
6054 *expr_p = get_formal_tmp_var (*expr_p, pre_p);
6056 if (TREE_CODE (*expr_p) != SSA_NAME)
6057 DECL_GIMPLE_FORMAL_TEMP_P (*expr_p) = 1;
6061 #ifdef ENABLE_CHECKING
6062 if (!(fallback & fb_mayfail))
6064 fprintf (stderr, "gimplification failed:\n");
6065 print_generic_expr (stderr, *expr_p, 0);
6066 debug_tree (*expr_p);
6067 internal_error ("gimplification failed");
6070 gcc_assert (fallback & fb_mayfail);
6071 /* If this is an asm statement, and the user asked for the
6072 impossible, don't die. Fail and let gimplify_asm_expr
6078 /* Make sure the temporary matches our predicate. */
6079 gcc_assert ((*gimple_test_f) (*expr_p));
6083 annotate_all_with_locus (&internal_post, input_location);
6084 append_to_statement_list (internal_post, pre_p);
6088 input_location = saved_location;
6092 /* Look through TYPE for variable-sized objects and gimplify each such
6093 size that we find. Add to LIST_P any statements generated. */
6096 gimplify_type_sizes (tree type, tree *list_p)
6100 if (type == NULL || type == error_mark_node)
6103 /* We first do the main variant, then copy into any other variants. */
6104 type = TYPE_MAIN_VARIANT (type);
6106 /* Avoid infinite recursion. */
6107 if (TYPE_SIZES_GIMPLIFIED (type))
6110 TYPE_SIZES_GIMPLIFIED (type) = 1;
6112 switch (TREE_CODE (type))
6118 gimplify_one_sizepos (&TYPE_MIN_VALUE (type), list_p);
6119 gimplify_one_sizepos (&TYPE_MAX_VALUE (type), list_p);
6121 for (t = TYPE_NEXT_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
6123 TYPE_MIN_VALUE (t) = TYPE_MIN_VALUE (type);
6124 TYPE_MAX_VALUE (t) = TYPE_MAX_VALUE (type);
6129 /* These types may not have declarations, so handle them here. */
6130 gimplify_type_sizes (TREE_TYPE (type), list_p);
6131 gimplify_type_sizes (TYPE_DOMAIN (type), list_p);
6136 case QUAL_UNION_TYPE:
6137 for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
6138 if (TREE_CODE (field) == FIELD_DECL)
6140 gimplify_one_sizepos (&DECL_FIELD_OFFSET (field), list_p);
6141 gimplify_type_sizes (TREE_TYPE (field), list_p);
6146 case REFERENCE_TYPE:
6147 /* We used to recurse on the pointed-to type here, which turned out to
6148 be incorrect because its definition might refer to variables not
6149 yet initialized at this point if a forward declaration is involved.
6151 It was actually useful for anonymous pointed-to types to ensure
6152 that the sizes evaluation dominates every possible later use of the
6153 values. Restricting to such types here would be safe since there
6154 is no possible forward declaration around, but would introduce an
6155 undesirable middle-end semantic to anonymity. We then defer to
6156 front-ends the responsibility of ensuring that the sizes are
6157 evaluated both early and late enough, e.g. by attaching artificial
6158 type declarations to the tree. */
6165 gimplify_one_sizepos (&TYPE_SIZE (type), list_p);
6166 gimplify_one_sizepos (&TYPE_SIZE_UNIT (type), list_p);
6168 for (t = TYPE_NEXT_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
6170 TYPE_SIZE (t) = TYPE_SIZE (type);
6171 TYPE_SIZE_UNIT (t) = TYPE_SIZE_UNIT (type);
6172 TYPE_SIZES_GIMPLIFIED (t) = 1;
6176 /* A subroutine of gimplify_type_sizes to make sure that *EXPR_P,
6177 a size or position, has had all of its SAVE_EXPRs evaluated.
6178 We add any required statements to STMT_P. */
6181 gimplify_one_sizepos (tree *expr_p, tree *stmt_p)
6183 tree type, expr = *expr_p;
6185 /* We don't do anything if the value isn't there, is constant, or contains
6186 A PLACEHOLDER_EXPR. We also don't want to do anything if it's already
6187 a VAR_DECL. If it's a VAR_DECL from another function, the gimplifier
6188 will want to replace it with a new variable, but that will cause problems
6189 if this type is from outside the function. It's OK to have that here. */
6190 if (expr == NULL_TREE || TREE_CONSTANT (expr)
6191 || TREE_CODE (expr) == VAR_DECL
6192 || CONTAINS_PLACEHOLDER_P (expr))
6195 type = TREE_TYPE (expr);
6196 *expr_p = unshare_expr (expr);
6198 gimplify_expr (expr_p, stmt_p, NULL, is_gimple_val, fb_rvalue);
6201 /* Verify that we've an exact type match with the original expression.
6202 In particular, we do not wish to drop a "sizetype" in favour of a
6203 type of similar dimensions. We don't want to pollute the generic
6204 type-stripping code with this knowledge because it doesn't matter
6205 for the bulk of GENERIC/GIMPLE. It only matters that TYPE_SIZE_UNIT
6206 and friends retain their "sizetype-ness". */
6207 if (TREE_TYPE (expr) != type
6208 && TREE_CODE (type) == INTEGER_TYPE
6209 && TYPE_IS_SIZETYPE (type))
6213 *expr_p = create_tmp_var (type, NULL);
6214 tmp = build1 (NOP_EXPR, type, expr);
6215 tmp = build_gimple_modify_stmt (*expr_p, tmp);
6216 if (EXPR_HAS_LOCATION (expr))
6217 SET_EXPR_LOCUS (tmp, EXPR_LOCUS (expr));
6219 SET_EXPR_LOCATION (tmp, input_location);
6221 gimplify_and_add (tmp, stmt_p);
6225 #ifdef ENABLE_CHECKING
6226 /* Compare types A and B for a "close enough" match. */
6229 cpt_same_type (tree a, tree b)
6231 if (lang_hooks.types_compatible_p (a, b))
6234 /* ??? The C++ FE decomposes METHOD_TYPES to FUNCTION_TYPES and doesn't
6235 link them together. This routine is intended to catch type errors
6236 that will affect the optimizers, and the optimizers don't add new
6237 dereferences of function pointers, so ignore it. */
6238 if ((TREE_CODE (a) == FUNCTION_TYPE || TREE_CODE (a) == METHOD_TYPE)
6239 && (TREE_CODE (b) == FUNCTION_TYPE || TREE_CODE (b) == METHOD_TYPE))
6242 /* ??? The C FE pushes type qualifiers after the fact into the type of
6243 the element from the type of the array. See build_unary_op's handling
6244 of ADDR_EXPR. This seems wrong -- if we were going to do this, we
6245 should have done it when creating the variable in the first place.
6246 Alternately, why aren't the two array types made variants? */
6247 if (TREE_CODE (a) == ARRAY_TYPE && TREE_CODE (b) == ARRAY_TYPE)
6248 return cpt_same_type (TREE_TYPE (a), TREE_TYPE (b));
6250 /* And because of those, we have to recurse down through pointers. */
6251 if (POINTER_TYPE_P (a) && POINTER_TYPE_P (b))
6252 return cpt_same_type (TREE_TYPE (a), TREE_TYPE (b));
6257 /* Check for some cases of the front end missing cast expressions.
6258 The type of a dereference should correspond to the pointer type;
6259 similarly the type of an address should match its object. */
6262 check_pointer_types_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
6263 void *data ATTRIBUTE_UNUSED)
6266 tree ptype, otype, dtype;
6268 switch (TREE_CODE (t))
6272 otype = TREE_TYPE (t);
6273 ptype = TREE_TYPE (TREE_OPERAND (t, 0));
6274 dtype = TREE_TYPE (ptype);
6275 gcc_assert (cpt_same_type (otype, dtype));
6279 ptype = TREE_TYPE (t);
6280 otype = TREE_TYPE (TREE_OPERAND (t, 0));
6281 dtype = TREE_TYPE (ptype);
6282 if (!cpt_same_type (otype, dtype))
6284 /* &array is allowed to produce a pointer to the element, rather than
6285 a pointer to the array type. We must allow this in order to
6286 properly represent assigning the address of an array in C into
6287 pointer to the element type. */
6288 gcc_assert (TREE_CODE (otype) == ARRAY_TYPE
6289 && POINTER_TYPE_P (ptype)
6290 && cpt_same_type (TREE_TYPE (otype), dtype));
6304 /* Gimplify the body of statements pointed to by BODY_P. FNDECL is the
6305 function decl containing BODY. */
6308 gimplify_body (tree *body_p, tree fndecl, bool do_parms)
6310 location_t saved_location = input_location;
6311 tree body, parm_stmts;
6313 timevar_push (TV_TREE_GIMPLIFY);
6315 gcc_assert (gimplify_ctxp == NULL);
6316 push_gimplify_context ();
6318 /* Unshare most shared trees in the body and in that of any nested functions.
6319 It would seem we don't have to do this for nested functions because
6320 they are supposed to be output and then the outer function gimplified
6321 first, but the g++ front end doesn't always do it that way. */
6322 unshare_body (body_p, fndecl);
6323 unvisit_body (body_p, fndecl);
6325 /* Make sure input_location isn't set to something wierd. */
6326 input_location = DECL_SOURCE_LOCATION (fndecl);
6328 /* Resolve callee-copies. This has to be done before processing
6329 the body so that DECL_VALUE_EXPR gets processed correctly. */
6330 parm_stmts = do_parms ? gimplify_parameters () : NULL;
6332 /* Gimplify the function's body. */
6333 gimplify_stmt (body_p);
6337 body = alloc_stmt_list ();
6338 else if (TREE_CODE (body) == STATEMENT_LIST)
6340 tree t = expr_only (*body_p);
6345 /* If there isn't an outer BIND_EXPR, add one. */
6346 if (TREE_CODE (body) != BIND_EXPR)
6348 tree b = build3 (BIND_EXPR, void_type_node, NULL_TREE,
6349 NULL_TREE, NULL_TREE);
6350 TREE_SIDE_EFFECTS (b) = 1;
6351 append_to_statement_list_force (body, &BIND_EXPR_BODY (b));
6355 /* If we had callee-copies statements, insert them at the beginning
6359 append_to_statement_list_force (BIND_EXPR_BODY (body), &parm_stmts);
6360 BIND_EXPR_BODY (body) = parm_stmts;
6363 /* Unshare again, in case gimplification was sloppy. */
6364 unshare_all_trees (body);
6368 pop_gimplify_context (body);
6369 gcc_assert (gimplify_ctxp == NULL);
6371 #ifdef ENABLE_CHECKING
6372 walk_tree (body_p, check_pointer_types_r, NULL, NULL);
6375 timevar_pop (TV_TREE_GIMPLIFY);
6376 input_location = saved_location;
6379 /* Entry point to the gimplification pass. FNDECL is the FUNCTION_DECL
6380 node for the function we want to gimplify. */
6383 gimplify_function_tree (tree fndecl)
6385 tree oldfn, parm, ret;
6387 oldfn = current_function_decl;
6388 current_function_decl = fndecl;
6389 cfun = DECL_STRUCT_FUNCTION (fndecl);
6391 allocate_struct_function (fndecl);
6393 for (parm = DECL_ARGUMENTS (fndecl); parm ; parm = TREE_CHAIN (parm))
6395 /* Preliminarily mark non-addressed complex variables as eligible
6396 for promotion to gimple registers. We'll transform their uses
6398 if ((TREE_CODE (TREE_TYPE (parm)) == COMPLEX_TYPE
6399 || TREE_CODE (TREE_TYPE (parm)) == VECTOR_TYPE)
6400 && !TREE_THIS_VOLATILE (parm)
6401 && !needs_to_live_in_memory (parm))
6402 DECL_GIMPLE_REG_P (parm) = 1;
6405 ret = DECL_RESULT (fndecl);
6406 if ((TREE_CODE (TREE_TYPE (ret)) == COMPLEX_TYPE
6407 || TREE_CODE (TREE_TYPE (ret)) == VECTOR_TYPE)
6408 && !needs_to_live_in_memory (ret))
6409 DECL_GIMPLE_REG_P (ret) = 1;
6411 gimplify_body (&DECL_SAVED_TREE (fndecl), fndecl, true);
6413 /* If we're instrumenting function entry/exit, then prepend the call to
6414 the entry hook and wrap the whole function in a TRY_FINALLY_EXPR to
6415 catch the exit hook. */
6416 /* ??? Add some way to ignore exceptions for this TFE. */
6417 if (flag_instrument_function_entry_exit
6418 && ! DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (fndecl))
6422 tf = build2 (TRY_FINALLY_EXPR, void_type_node, NULL, NULL);
6423 TREE_SIDE_EFFECTS (tf) = 1;
6424 x = DECL_SAVED_TREE (fndecl);
6425 append_to_statement_list (x, &TREE_OPERAND (tf, 0));
6426 x = implicit_built_in_decls[BUILT_IN_PROFILE_FUNC_EXIT];
6427 x = build_call_expr (x, 0);
6428 append_to_statement_list (x, &TREE_OPERAND (tf, 1));
6430 bind = build3 (BIND_EXPR, void_type_node, NULL, NULL, NULL);
6431 TREE_SIDE_EFFECTS (bind) = 1;
6432 x = implicit_built_in_decls[BUILT_IN_PROFILE_FUNC_ENTER];
6433 x = build_call_expr (x, 0);
6434 append_to_statement_list (x, &BIND_EXPR_BODY (bind));
6435 append_to_statement_list (tf, &BIND_EXPR_BODY (bind));
6437 DECL_SAVED_TREE (fndecl) = bind;
6440 cfun->gimplified = true;
6441 current_function_decl = oldfn;
6442 cfun = oldfn ? DECL_STRUCT_FUNCTION (oldfn) : NULL;
6445 /* Expands EXPR to list of gimple statements STMTS. If SIMPLE is true,
6446 force the result to be either ssa_name or an invariant, otherwise
6447 just force it to be a rhs expression. If VAR is not NULL, make the
6448 base variable of the final destination be VAR if suitable. */
6451 force_gimple_operand (tree expr, tree *stmts, bool simple, tree var)
6454 enum gimplify_status ret;
6455 gimple_predicate gimple_test_f;
6459 if (is_gimple_val (expr))
6462 gimple_test_f = simple ? is_gimple_val : is_gimple_reg_rhs;
6464 push_gimplify_context ();
6465 gimplify_ctxp->into_ssa = gimple_in_ssa_p (cfun);
6468 expr = build_gimple_modify_stmt (var, expr);
6470 ret = gimplify_expr (&expr, stmts, NULL,
6471 gimple_test_f, fb_rvalue);
6472 gcc_assert (ret != GS_ERROR);
6474 if (gimple_referenced_vars (cfun))
6476 for (t = gimplify_ctxp->temps; t ; t = TREE_CHAIN (t))
6477 add_referenced_var (t);
6480 pop_gimplify_context (NULL);
6485 /* Invokes force_gimple_operand for EXPR with parameters SIMPLE_P and VAR. If
6486 some statements are produced, emits them before BSI. */
6489 force_gimple_operand_bsi (block_stmt_iterator *bsi, tree expr,
6490 bool simple_p, tree var)
6494 expr = force_gimple_operand (expr, &stmts, simple_p, var);
6496 bsi_insert_before (bsi, stmts, BSI_SAME_STMT);
6501 #include "gt-gimplify.h"