| /* Tree lowering pass. This pass converts the GENERIC functions-as-trees |
| tree representation into the GIMPLE form. |
| Copyright (C) 2002, 2003, 2004, 2005 Free Software Foundation, Inc. |
| Major work done by Sebastian Pop <s.pop@laposte.net>, |
| Diego Novillo <dnovillo@redhat.com> and Jason Merrill <jason@redhat.com>. |
| |
| This file is part of GCC. |
| |
| GCC is free software; you can redistribute it and/or modify it under |
| the terms of the GNU General Public License as published by the Free |
| Software Foundation; either version 2, or (at your option) any later |
| version. |
| |
| GCC is distributed in the hope that it will be useful, but WITHOUT ANY |
| WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| for more details. |
| |
| You should have received a copy of the GNU General Public License |
| along with GCC; see the file COPYING. If not, write to the Free |
| Software Foundation, 59 Temple Place - Suite 330, Boston, MA |
| 02111-1307, USA. */ |
| |
| #include "config.h" |
| #include "system.h" |
| #include "coretypes.h" |
| #include "tm.h" |
| #include "tree.h" |
| #include "rtl.h" |
| #include "errors.h" |
| #include "varray.h" |
| #include "tree-gimple.h" |
| #include "tree-inline.h" |
| #include "diagnostic.h" |
| #include "langhooks.h" |
| #include "langhooks-def.h" |
| #include "tree-flow.h" |
| #include "cgraph.h" |
| #include "timevar.h" |
| #include "except.h" |
| #include "hashtab.h" |
| #include "flags.h" |
| #include "real.h" |
| #include "function.h" |
| #include "output.h" |
| #include "expr.h" |
| #include "ggc.h" |
| #include "target.h" |
| |
| static struct gimplify_ctx |
| { |
| tree current_bind_expr; |
| tree temps; |
| tree conditional_cleanups; |
| tree exit_label; |
| tree return_temp; |
| varray_type case_labels; |
| /* The formal temporary table. Should this be persistent? */ |
| htab_t temp_htab; |
| int conditions; |
| bool save_stack; |
| bool into_ssa; |
| } *gimplify_ctxp; |
| |
| |
| /* Formal (expression) temporary table handling: Multiple occurrences of |
| the same scalar expression are evaluated into the same temporary. */ |
| |
| typedef struct gimple_temp_hash_elt |
| { |
| tree val; /* Key */ |
| tree temp; /* Value */ |
| } elt_t; |
| |
| /* Forward declarations. */ |
| static enum gimplify_status gimplify_compound_expr (tree *, tree *, bool); |
| #ifdef ENABLE_CHECKING |
| static bool cpt_same_type (tree a, tree b); |
| #endif |
| |
| |
| /* Return a hash value for a formal temporary table entry. */ |
| |
| static hashval_t |
| gimple_tree_hash (const void *p) |
| { |
| tree t = ((const elt_t *) p)->val; |
| return iterative_hash_expr (t, 0); |
| } |
| |
| /* Compare two formal temporary table entries. */ |
| |
| static int |
| gimple_tree_eq (const void *p1, const void *p2) |
| { |
| tree t1 = ((const elt_t *) p1)->val; |
| tree t2 = ((const elt_t *) p2)->val; |
| enum tree_code code = TREE_CODE (t1); |
| |
| if (TREE_CODE (t2) != code |
| || TREE_TYPE (t1) != TREE_TYPE (t2)) |
| return 0; |
| |
| if (!operand_equal_p (t1, t2, 0)) |
| return 0; |
| |
| /* Only allow them to compare equal if they also hash equal; otherwise |
| results are nondeterminate, and we fail bootstrap comparison. */ |
| gcc_assert (gimple_tree_hash (p1) == gimple_tree_hash (p2)); |
| |
| return 1; |
| } |
| |
| /* Set up a context for the gimplifier. */ |
| |
| void |
| push_gimplify_context (void) |
| { |
| gcc_assert (!gimplify_ctxp); |
| gimplify_ctxp |
| = (struct gimplify_ctx *) xcalloc (1, sizeof (struct gimplify_ctx)); |
| if (optimize) |
| gimplify_ctxp->temp_htab |
| = htab_create (1000, gimple_tree_hash, gimple_tree_eq, free); |
| else |
| gimplify_ctxp->temp_htab = NULL; |
| } |
| |
| /* Tear down a context for the gimplifier. If BODY is non-null, then |
| put the temporaries into the outer BIND_EXPR. Otherwise, put them |
| in the unexpanded_var_list. */ |
| |
| void |
| pop_gimplify_context (tree body) |
| { |
| tree t; |
| |
| gcc_assert (gimplify_ctxp && !gimplify_ctxp->current_bind_expr); |
| |
| /* APPLE LOCAL begin LLVM */ |
| #ifndef ENABLE_LLVM |
| /* LLVM wants to know about gimple formal temps. */ |
| for (t = gimplify_ctxp->temps; t ; t = TREE_CHAIN (t)) |
| DECL_GIMPLE_FORMAL_TEMP_P (t) = 0; |
| #else |
| t = 0; |
| #endif |
| /* APPLE LOCAL end LLVM */ |
| |
| if (body) |
| declare_tmp_vars (gimplify_ctxp->temps, body); |
| else |
| record_vars (gimplify_ctxp->temps); |
| |
| #if 0 |
| if (!quiet_flag && optimize) |
| fprintf (stderr, " collisions: %f ", |
| htab_collisions (gimplify_ctxp->temp_htab)); |
| #endif |
| |
| if (optimize) |
| htab_delete (gimplify_ctxp->temp_htab); |
| free (gimplify_ctxp); |
| gimplify_ctxp = NULL; |
| } |
| |
| void |
| gimple_push_bind_expr (tree bind) |
| { |
| TREE_CHAIN (bind) = gimplify_ctxp->current_bind_expr; |
| gimplify_ctxp->current_bind_expr = bind; |
| } |
| |
| void |
| gimple_pop_bind_expr (void) |
| { |
| gimplify_ctxp->current_bind_expr |
| = TREE_CHAIN (gimplify_ctxp->current_bind_expr); |
| } |
| |
| tree |
| gimple_current_bind_expr (void) |
| { |
| return gimplify_ctxp->current_bind_expr; |
| } |
| |
| /* Returns true iff there is a COND_EXPR between us and the innermost |
| CLEANUP_POINT_EXPR. This info is used by gimple_push_cleanup. */ |
| |
| static bool |
| gimple_conditional_context (void) |
| { |
| return gimplify_ctxp->conditions > 0; |
| } |
| |
| /* Note that we've entered a COND_EXPR. */ |
| |
| static void |
| gimple_push_condition (void) |
| { |
| #ifdef ENABLE_CHECKING |
| if (gimplify_ctxp->conditions == 0) |
| gcc_assert (!gimplify_ctxp->conditional_cleanups); |
| #endif |
| ++(gimplify_ctxp->conditions); |
| } |
| |
| /* Note that we've left a COND_EXPR. If we're back at unconditional scope |
| now, add any conditional cleanups we've seen to the prequeue. */ |
| |
| static void |
| gimple_pop_condition (tree *pre_p) |
| { |
| int conds = --(gimplify_ctxp->conditions); |
| |
| gcc_assert (conds >= 0); |
| if (conds == 0) |
| { |
| append_to_statement_list (gimplify_ctxp->conditional_cleanups, pre_p); |
| gimplify_ctxp->conditional_cleanups = NULL_TREE; |
| } |
| } |
| |
| /* A subroutine of append_to_statement_list{,_force}. T is not NULL. */ |
| |
| static void |
| append_to_statement_list_1 (tree t, tree *list_p) |
| { |
| tree list = *list_p; |
| tree_stmt_iterator i; |
| |
| if (!list) |
| { |
| if (t && TREE_CODE (t) == STATEMENT_LIST) |
| { |
| *list_p = t; |
| return; |
| } |
| *list_p = list = alloc_stmt_list (); |
| } |
| |
| i = tsi_last (list); |
| tsi_link_after (&i, t, TSI_CONTINUE_LINKING); |
| } |
| |
| /* Add T to the end of the list container pointed by LIST_P. |
| If T is an expression with no effects, it is ignored. */ |
| |
| void |
| append_to_statement_list (tree t, tree *list_p) |
| { |
| if (t && TREE_SIDE_EFFECTS (t)) |
| append_to_statement_list_1 (t, list_p); |
| } |
| |
| /* Similar, but the statement is always added, regardless of side effects. */ |
| |
| void |
| append_to_statement_list_force (tree t, tree *list_p) |
| { |
| if (t != NULL_TREE) |
| append_to_statement_list_1 (t, list_p); |
| } |
| |
| /* Both gimplify the statement T and append it to LIST_P. */ |
| |
| void |
| gimplify_and_add (tree t, tree *list_p) |
| { |
| gimplify_stmt (&t); |
| append_to_statement_list (t, list_p); |
| } |
| |
| /* Strip off a legitimate source ending from the input string NAME of |
| length LEN. Rather than having to know the names used by all of |
| our front ends, we strip off an ending of a period followed by |
| up to five characters. (Java uses ".class".) */ |
| |
| static inline void |
| remove_suffix (char *name, int len) |
| { |
| int i; |
| |
| for (i = 2; i < 8 && len > i; i++) |
| { |
| if (name[len - i] == '.') |
| { |
| name[len - i] = '\0'; |
| break; |
| } |
| } |
| } |
| |
| /* Create a nameless artificial label and put it in the current function |
| context. Returns the newly created label. */ |
| |
| tree |
| create_artificial_label (void) |
| { |
| tree lab = build_decl (LABEL_DECL, NULL_TREE, void_type_node); |
| |
| DECL_ARTIFICIAL (lab) = 1; |
| DECL_IGNORED_P (lab) = 1; |
| DECL_CONTEXT (lab) = current_function_decl; |
| return lab; |
| } |
| |
| /* Create a new temporary name with PREFIX. Returns an identifier. */ |
| |
| static GTY(()) unsigned int tmp_var_id_num; |
| |
| tree |
| create_tmp_var_name (const char *prefix) |
| { |
| char *tmp_name; |
| |
| if (prefix) |
| { |
| char *preftmp = ASTRDUP (prefix); |
| |
| remove_suffix (preftmp, strlen (preftmp)); |
| prefix = preftmp; |
| } |
| |
| ASM_FORMAT_PRIVATE_NAME (tmp_name, prefix ? prefix : "T", tmp_var_id_num++); |
| return get_identifier (tmp_name); |
| } |
| |
| |
| /* Create a new temporary variable declaration of type TYPE. |
| Does NOT push it into the current binding. */ |
| |
| tree |
| create_tmp_var_raw (tree type, const char *prefix) |
| { |
| tree tmp_var; |
| tree new_type; |
| |
| /* Make the type of the variable writable. */ |
| new_type = build_type_variant (type, 0, 0); |
| TYPE_ATTRIBUTES (new_type) = TYPE_ATTRIBUTES (type); |
| |
| tmp_var = build_decl (VAR_DECL, prefix ? create_tmp_var_name (prefix) : NULL, |
| type); |
| |
| /* The variable was declared by the compiler. */ |
| DECL_ARTIFICIAL (tmp_var) = 1; |
| /* And we don't want debug info for it. */ |
| DECL_IGNORED_P (tmp_var) = 1; |
| |
| /* Make the variable writable. */ |
| TREE_READONLY (tmp_var) = 0; |
| |
| DECL_EXTERNAL (tmp_var) = 0; |
| TREE_STATIC (tmp_var) = 0; |
| TREE_USED (tmp_var) = 1; |
| |
| return tmp_var; |
| } |
| |
| /* Create a new temporary variable declaration of type TYPE. DOES push the |
| variable into the current binding. Further, assume that this is called |
| only from gimplification or optimization, at which point the creation of |
| certain types are bugs. */ |
| |
| tree |
| create_tmp_var (tree type, const char *prefix) |
| { |
| tree tmp_var; |
| |
| /* We don't allow types that are addressable (meaning we can't make copies), |
| incomplete, or of variable size. */ |
| gcc_assert (!TREE_ADDRESSABLE (type) |
| && COMPLETE_TYPE_P (type) |
| && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST); |
| |
| tmp_var = create_tmp_var_raw (type, prefix); |
| gimple_add_tmp_var (tmp_var); |
| return tmp_var; |
| } |
| |
| /* Given a tree, try to return a useful variable name that we can use |
| to prefix a temporary that is being assigned the value of the tree. |
| I.E. given <temp> = &A, return A. */ |
| |
| const char * |
| get_name (tree t) |
| { |
| tree stripped_decl; |
| |
| stripped_decl = t; |
| STRIP_NOPS (stripped_decl); |
| if (DECL_P (stripped_decl) && DECL_NAME (stripped_decl)) |
| return IDENTIFIER_POINTER (DECL_NAME (stripped_decl)); |
| else |
| { |
| switch (TREE_CODE (stripped_decl)) |
| { |
| case ADDR_EXPR: |
| return get_name (TREE_OPERAND (stripped_decl, 0)); |
| break; |
| default: |
| return NULL; |
| } |
| } |
| } |
| |
| /* Create a temporary with a name derived from VAL. Subroutine of |
| lookup_tmp_var; nobody else should call this function. */ |
| |
| static inline tree |
| create_tmp_from_val (tree val) |
| { |
| return create_tmp_var (TREE_TYPE (val), get_name (val)); |
| } |
| |
| /* Create a temporary to hold the value of VAL. If IS_FORMAL, try to reuse |
| an existing expression temporary. */ |
| |
| static tree |
| lookup_tmp_var (tree val, bool is_formal) |
| { |
| tree ret; |
| |
| /* If not optimizing, never really reuse a temporary. local-alloc |
| won't allocate any variable that is used in more than one basic |
| block, which means it will go into memory, causing much extra |
| work in reload and final and poorer code generation, outweighing |
| the extra memory allocation here. */ |
| /* APPLE LOCAL begin LLVM */ |
| #ifdef ENABLE_LLVM |
| if (1) /* LLVM wants temporaries created in SSA form, never reuse one. */ |
| #else |
| if (!optimize || !is_formal || TREE_SIDE_EFFECTS (val)) |
| #endif |
| /* APPLE LOCAL end LLVM */ |
| ret = create_tmp_from_val (val); |
| else |
| { |
| elt_t elt, *elt_p; |
| void **slot; |
| |
| elt.val = val; |
| slot = htab_find_slot (gimplify_ctxp->temp_htab, (void *)&elt, INSERT); |
| if (*slot == NULL) |
| { |
| elt_p = xmalloc (sizeof (*elt_p)); |
| elt_p->val = val; |
| elt_p->temp = ret = create_tmp_from_val (val); |
| *slot = (void *) elt_p; |
| } |
| else |
| { |
| elt_p = (elt_t *) *slot; |
| ret = elt_p->temp; |
| } |
| } |
| |
| if (is_formal) |
| DECL_GIMPLE_FORMAL_TEMP_P (ret) = 1; |
| |
| return ret; |
| } |
| |
| /* Returns a formal temporary variable initialized with VAL. PRE_P is as |
| in gimplify_expr. Only use this function if: |
| |
| 1) The value of the unfactored expression represented by VAL will not |
| change between the initialization and use of the temporary, and |
| 2) The temporary will not be otherwise modified. |
| |
| For instance, #1 means that this is inappropriate for SAVE_EXPR temps, |
| and #2 means it is inappropriate for && temps. |
| |
| For other cases, use get_initialized_tmp_var instead. */ |
| |
| static tree |
| internal_get_tmp_var (tree val, tree *pre_p, tree *post_p, bool is_formal) |
| { |
| tree t, mod; |
| |
| gimplify_expr (&val, pre_p, post_p, is_gimple_formal_tmp_rhs, fb_rvalue); |
| |
| t = lookup_tmp_var (val, is_formal); |
| |
| mod = build (MODIFY_EXPR, TREE_TYPE (t), t, val); |
| |
| if (EXPR_HAS_LOCATION (val)) |
| SET_EXPR_LOCUS (mod, EXPR_LOCUS (val)); |
| else |
| SET_EXPR_LOCATION (mod, input_location); |
| |
| /* gimplify_modify_expr might want to reduce this further. */ |
| gimplify_and_add (mod, pre_p); |
| |
| /* If we're gimplifying into ssa, gimplify_modify_expr will have |
| given our temporary an ssa name. Find and return it. */ |
| if (gimplify_ctxp->into_ssa) |
| t = TREE_OPERAND (mod, 0); |
| |
| return t; |
| } |
| |
| tree |
| get_formal_tmp_var (tree val, tree *pre_p) |
| { |
| return internal_get_tmp_var (val, pre_p, NULL, true); |
| } |
| |
| /* Returns a temporary variable initialized with VAL. PRE_P and POST_P |
| are as in gimplify_expr. */ |
| |
| tree |
| get_initialized_tmp_var (tree val, tree *pre_p, tree *post_p) |
| { |
| return internal_get_tmp_var (val, pre_p, post_p, false); |
| } |
| |
| /* Declares all the variables in VARS in SCOPE. */ |
| |
| void |
| declare_tmp_vars (tree vars, tree scope) |
| { |
| tree last = vars; |
| if (last) |
| { |
| tree temps; |
| |
| /* C99 mode puts the default 'return 0;' for main outside the outer |
| braces. So drill down until we find an actual scope. */ |
| while (TREE_CODE (scope) == COMPOUND_EXPR) |
| scope = TREE_OPERAND (scope, 0); |
| |
| gcc_assert (TREE_CODE (scope) == BIND_EXPR); |
| |
| temps = nreverse (last); |
| TREE_CHAIN (last) = BIND_EXPR_VARS (scope); |
| BIND_EXPR_VARS (scope) = temps; |
| } |
| } |
| |
| void |
| gimple_add_tmp_var (tree tmp) |
| { |
| gcc_assert (!TREE_CHAIN (tmp) && !DECL_SEEN_IN_BIND_EXPR_P (tmp)); |
| |
| DECL_CONTEXT (tmp) = current_function_decl; |
| DECL_SEEN_IN_BIND_EXPR_P (tmp) = 1; |
| |
| if (gimplify_ctxp) |
| { |
| TREE_CHAIN (tmp) = gimplify_ctxp->temps; |
| gimplify_ctxp->temps = tmp; |
| } |
| else if (cfun) |
| record_vars (tmp); |
| else |
| declare_tmp_vars (tmp, DECL_SAVED_TREE (current_function_decl)); |
| } |
| |
| /* Determines whether to assign a locus to the statement STMT. */ |
| |
| static bool |
| should_carry_locus_p (tree stmt) |
| { |
| /* Don't emit a line note for a label. We particularly don't want to |
| emit one for the break label, since it doesn't actually correspond |
| to the beginning of the loop/switch. */ |
| if (TREE_CODE (stmt) == LABEL_EXPR) |
| return false; |
| |
| /* Do not annotate empty statements, since it confuses gcov. */ |
| if (!TREE_SIDE_EFFECTS (stmt)) |
| return false; |
| |
| return true; |
| } |
| |
| static void |
| annotate_one_with_locus (tree t, location_t locus) |
| { |
| if (EXPR_P (t) && ! EXPR_HAS_LOCATION (t) && should_carry_locus_p (t)) |
| SET_EXPR_LOCATION (t, locus); |
| } |
| |
| void |
| annotate_all_with_locus (tree *stmt_p, location_t locus) |
| { |
| tree_stmt_iterator i; |
| |
| if (!*stmt_p) |
| return; |
| |
| for (i = tsi_start (*stmt_p); !tsi_end_p (i); tsi_next (&i)) |
| { |
| tree t = tsi_stmt (i); |
| |
| /* Assuming we've already been gimplified, we shouldn't |
| see nested chaining constructs anymore. */ |
| gcc_assert (TREE_CODE (t) != STATEMENT_LIST |
| && TREE_CODE (t) != COMPOUND_EXPR); |
| |
| annotate_one_with_locus (t, locus); |
| } |
| } |
| |
| /* Similar to copy_tree_r() but do not copy SAVE_EXPR or TARGET_EXPR nodes. |
| These nodes model computations that should only be done once. If we |
| were to unshare something like SAVE_EXPR(i++), the gimplification |
| process would create wrong code. */ |
| |
| static tree |
| mostly_copy_tree_r (tree *tp, int *walk_subtrees, void *data) |
| { |
| enum tree_code code = TREE_CODE (*tp); |
| /* Don't unshare types, decls, constants and SAVE_EXPR nodes. */ |
| if (TREE_CODE_CLASS (code) == tcc_type |
| || TREE_CODE_CLASS (code) == tcc_declaration |
| || TREE_CODE_CLASS (code) == tcc_constant |
| || code == SAVE_EXPR || code == TARGET_EXPR |
| /* We can't do anything sensible with a BLOCK used as an expression, |
| but we also can't abort when we see it because of non-expression |
| uses. So just avert our eyes and cross our fingers. Silly Java. */ |
| || code == BLOCK) |
| *walk_subtrees = 0; |
| else |
| { |
| gcc_assert (code != BIND_EXPR); |
| copy_tree_r (tp, walk_subtrees, data); |
| } |
| |
| return NULL_TREE; |
| } |
| |
| /* APPLE LOCAL begin PR 14498, etc --bowdidge */ |
| /* This routine was deleted from FSF mainline and lno-branch; however, |
| we're still using it in the next routine. Keep a local copy until |
| we can rewrite that other stuff. The FIXME on this worries me. */ |
| |
| /* Mark all the _DECL nodes under *TP as volatile. FIXME: This must die |
| after VA_ARG_EXPRs are properly lowered. */ |
| |
| static tree |
| mark_decls_volatile_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, |
| void *data ATTRIBUTE_UNUSED) |
| { |
| if (SSA_VAR_P (*tp)) |
| TREE_THIS_VOLATILE (*tp) = 1; |
| |
| return NULL_TREE; |
| } |
| /* APPLE LOCAL end PR 14498, etc --bowdidge */ |
| |
| /* Callback for walk_tree to unshare most of the shared trees rooted at |
| *TP. If *TP has been visited already (i.e., TREE_VISITED (*TP) == 1), |
| then *TP is deep copied by calling copy_tree_r. |
| |
| This unshares the same trees as copy_tree_r with the exception of |
| SAVE_EXPR nodes. These nodes model computations that should only be |
| done once. If we were to unshare something like SAVE_EXPR(i++), the |
| gimplification process would create wrong code. */ |
| |
| static tree |
| copy_if_shared_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, |
| void *data ATTRIBUTE_UNUSED) |
| { |
| tree t = *tp; |
| enum tree_code code = TREE_CODE (t); |
| |
| /* Skip types, decls, and constants. But we do want to look at their |
| types and the bounds of types. Mark them as visited so we properly |
| unmark their subtrees on the unmark pass. If we've already seen them, |
| don't look down further. */ |
| if (TREE_CODE_CLASS (code) == tcc_type |
| || TREE_CODE_CLASS (code) == tcc_declaration |
| || TREE_CODE_CLASS (code) == tcc_constant) |
| { |
| if (TREE_VISITED (t)) |
| *walk_subtrees = 0; |
| else |
| TREE_VISITED (t) = 1; |
| } |
| |
| /* If this node has been visited already, unshare it and don't look |
| any deeper. */ |
| else if (TREE_VISITED (t)) |
| { |
| walk_tree (tp, mostly_copy_tree_r, NULL, NULL); |
| *walk_subtrees = 0; |
| } |
| |
| /* Otherwise, mark the tree as visited and keep looking. */ |
| else |
| /* APPLE LOCAL begin PR 14498, etc. --dbj */ |
| /* History is complicated, this was in mainline prior to merge, |
| temporarily and erroneously removed at merge snapshot, |
| later put back, still later replaced by different mechanism. */ |
| { |
| TREE_VISITED (t) = 1; |
| if (TREE_CODE (*tp) == VA_ARG_EXPR) |
| { |
| /* Mark any _DECL inside the operand as volatile to avoid |
| the optimizers messing around with it. We have to do this |
| early, otherwise we might mark a variable as volatile |
| after we gimplify other statements that use the variable |
| assuming it's not volatile. */ |
| walk_tree (&TREE_OPERAND (*tp, 0), mark_decls_volatile_r, |
| NULL, NULL); |
| } |
| } |
| /* APPLE LOCAL end PR 14498, etc. */ |
| |
| return NULL_TREE; |
| } |
| |
| static tree |
| unmark_visited_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, |
| void *data ATTRIBUTE_UNUSED) |
| { |
| if (TREE_VISITED (*tp)) |
| TREE_VISITED (*tp) = 0; |
| else |
| *walk_subtrees = 0; |
| |
| return NULL_TREE; |
| } |
| |
| /* Unshare all the trees in BODY_P, a pointer into the body of FNDECL, and the |
| bodies of any nested functions if we are unsharing the entire body of |
| FNDECL. */ |
| |
| static void |
| unshare_body (tree *body_p, tree fndecl) |
| { |
| struct cgraph_node *cgn = cgraph_node (fndecl); |
| |
| walk_tree (body_p, copy_if_shared_r, NULL, NULL); |
| if (body_p == &DECL_SAVED_TREE (fndecl)) |
| for (cgn = cgn->nested; cgn; cgn = cgn->next_nested) |
| unshare_body (&DECL_SAVED_TREE (cgn->decl), cgn->decl); |
| } |
| |
| /* Likewise, but mark all trees as not visited. */ |
| |
| static void |
| unvisit_body (tree *body_p, tree fndecl) |
| { |
| struct cgraph_node *cgn = cgraph_node (fndecl); |
| |
| walk_tree (body_p, unmark_visited_r, NULL, NULL); |
| if (body_p == &DECL_SAVED_TREE (fndecl)) |
| for (cgn = cgn->nested; cgn; cgn = cgn->next_nested) |
| unvisit_body (&DECL_SAVED_TREE (cgn->decl), cgn->decl); |
| } |
| |
| /* Unshare T and all the trees reached from T via TREE_CHAIN. */ |
| |
| void |
| unshare_all_trees (tree t) |
| { |
| walk_tree (&t, copy_if_shared_r, NULL, NULL); |
| walk_tree (&t, unmark_visited_r, NULL, NULL); |
| } |
| |
| /* Unconditionally make an unshared copy of EXPR. This is used when using |
| stored expressions which span multiple functions, such as BINFO_VTABLE, |
| as the normal unsharing process can't tell that they're shared. */ |
| |
| tree |
| unshare_expr (tree expr) |
| { |
| walk_tree (&expr, mostly_copy_tree_r, NULL, NULL); |
| return expr; |
| } |
| |
| /* A terser interface for building a representation of an exception |
| specification. */ |
| |
| tree |
| gimple_build_eh_filter (tree body, tree allowed, tree failure) |
| { |
| tree t; |
| |
| /* FIXME should the allowed types go in TREE_TYPE? */ |
| t = build (EH_FILTER_EXPR, void_type_node, allowed, NULL_TREE); |
| append_to_statement_list (failure, &EH_FILTER_FAILURE (t)); |
| |
| t = build (TRY_CATCH_EXPR, void_type_node, NULL_TREE, t); |
| append_to_statement_list (body, &TREE_OPERAND (t, 0)); |
| |
| return t; |
| } |
| |
| |
| /* WRAPPER is a code such as BIND_EXPR or CLEANUP_POINT_EXPR which can both |
| contain statements and have a value. Assign its value to a temporary |
| and give it void_type_node. Returns the temporary, or NULL_TREE if |
| WRAPPER was already void. */ |
| |
| tree |
| voidify_wrapper_expr (tree wrapper, tree temp) |
| { |
| if (!VOID_TYPE_P (TREE_TYPE (wrapper))) |
| { |
| tree *p, sub = wrapper; |
| |
| restart: |
| /* Set p to point to the body of the wrapper. */ |
| switch (TREE_CODE (sub)) |
| { |
| case BIND_EXPR: |
| /* For a BIND_EXPR, the body is operand 1. */ |
| p = &BIND_EXPR_BODY (sub); |
| break; |
| |
| default: |
| p = &TREE_OPERAND (sub, 0); |
| break; |
| } |
| |
| /* Advance to the last statement. Set all container types to void. */ |
| if (TREE_CODE (*p) == STATEMENT_LIST) |
| { |
| tree_stmt_iterator i = tsi_last (*p); |
| p = tsi_end_p (i) ? NULL : tsi_stmt_ptr (i); |
| } |
| else |
| { |
| for (; TREE_CODE (*p) == COMPOUND_EXPR; p = &TREE_OPERAND (*p, 1)) |
| { |
| TREE_SIDE_EFFECTS (*p) = 1; |
| TREE_TYPE (*p) = void_type_node; |
| } |
| } |
| |
| if (p == NULL || IS_EMPTY_STMT (*p)) |
| ; |
| /* Look through exception handling. */ |
| else if (TREE_CODE (*p) == TRY_FINALLY_EXPR |
| || TREE_CODE (*p) == TRY_CATCH_EXPR) |
| { |
| sub = *p; |
| goto restart; |
| } |
| /* The C++ frontend already did this for us. */ |
| else if (TREE_CODE (*p) == INIT_EXPR |
| || TREE_CODE (*p) == TARGET_EXPR) |
| temp = TREE_OPERAND (*p, 0); |
| /* If we're returning a dereference, move the dereference |
| outside the wrapper. */ |
| else if (TREE_CODE (*p) == INDIRECT_REF) |
| { |
| tree ptr = TREE_OPERAND (*p, 0); |
| temp = create_tmp_var (TREE_TYPE (ptr), "retval"); |
| *p = build (MODIFY_EXPR, TREE_TYPE (ptr), temp, ptr); |
| temp = build1 (INDIRECT_REF, TREE_TYPE (TREE_TYPE (temp)), temp); |
| /* If this is a BIND_EXPR for a const inline function, it might not |
| have TREE_SIDE_EFFECTS set. That is no longer accurate. */ |
| TREE_SIDE_EFFECTS (wrapper) = 1; |
| } |
| else |
| { |
| if (!temp) |
| temp = create_tmp_var (TREE_TYPE (wrapper), "retval"); |
| *p = build (MODIFY_EXPR, TREE_TYPE (temp), temp, *p); |
| TREE_SIDE_EFFECTS (wrapper) = 1; |
| } |
| |
| TREE_TYPE (wrapper) = void_type_node; |
| return temp; |
| } |
| |
| return NULL_TREE; |
| } |
| |
| /* Prepare calls to builtins to SAVE and RESTORE the stack as well as |
| a temporary through which they communicate. */ |
| |
| static void |
| build_stack_save_restore (tree *save, tree *restore) |
| { |
| tree save_call, tmp_var; |
| |
| save_call = |
| build_function_call_expr (implicit_built_in_decls[BUILT_IN_STACK_SAVE], |
| NULL_TREE); |
| tmp_var = create_tmp_var (ptr_type_node, "saved_stack"); |
| |
| *save = build (MODIFY_EXPR, ptr_type_node, tmp_var, save_call); |
| *restore = |
| build_function_call_expr (implicit_built_in_decls[BUILT_IN_STACK_RESTORE], |
| tree_cons (NULL_TREE, tmp_var, NULL_TREE)); |
| } |
| |
| /* Gimplify a BIND_EXPR. Just voidify and recurse. */ |
| |
| static enum gimplify_status |
| gimplify_bind_expr (tree *expr_p, tree temp, tree *pre_p) |
| { |
| tree bind_expr = *expr_p; |
| bool old_save_stack = gimplify_ctxp->save_stack; |
| tree t; |
| |
| temp = voidify_wrapper_expr (bind_expr, temp); |
| |
| /* Mark variables seen in this bind expr. */ |
| for (t = BIND_EXPR_VARS (bind_expr); t ; t = TREE_CHAIN (t)) |
| DECL_SEEN_IN_BIND_EXPR_P (t) = 1; |
| |
| gimple_push_bind_expr (bind_expr); |
| gimplify_ctxp->save_stack = false; |
| |
| gimplify_to_stmt_list (&BIND_EXPR_BODY (bind_expr)); |
| |
| if (gimplify_ctxp->save_stack) |
| { |
| tree stack_save, stack_restore; |
| |
| /* Save stack on entry and restore it on exit. Add a try_finally |
| block to achieve this. Note that mudflap depends on the |
| format of the emitted code: see mx_register_decls(). */ |
| build_stack_save_restore (&stack_save, &stack_restore); |
| |
| t = build (TRY_FINALLY_EXPR, void_type_node, |
| BIND_EXPR_BODY (bind_expr), NULL_TREE); |
| append_to_statement_list (stack_restore, &TREE_OPERAND (t, 1)); |
| |
| BIND_EXPR_BODY (bind_expr) = NULL_TREE; |
| append_to_statement_list (stack_save, &BIND_EXPR_BODY (bind_expr)); |
| append_to_statement_list (t, &BIND_EXPR_BODY (bind_expr)); |
| } |
| |
| gimplify_ctxp->save_stack = old_save_stack; |
| gimple_pop_bind_expr (); |
| |
| if (temp) |
| { |
| *expr_p = temp; |
| append_to_statement_list (bind_expr, pre_p); |
| return GS_OK; |
| } |
| else |
| return GS_ALL_DONE; |
| } |
| |
| /* Gimplify a RETURN_EXPR. If the expression to be returned is not a |
| GIMPLE value, it is assigned to a new temporary and the statement is |
| re-written to return the temporary. |
| |
| PRE_P points to the list where side effects that must happen before |
| STMT should be stored. */ |
| |
| static enum gimplify_status |
| gimplify_return_expr (tree stmt, tree *pre_p) |
| { |
| tree ret_expr = TREE_OPERAND (stmt, 0); |
| tree result_decl, result; |
| |
| if (!ret_expr || TREE_CODE (ret_expr) == RESULT_DECL |
| || ret_expr == error_mark_node) |
| return GS_ALL_DONE; |
| |
| if (VOID_TYPE_P (TREE_TYPE (TREE_TYPE (current_function_decl)))) |
| result_decl = NULL_TREE; |
| else |
| { |
| result_decl = TREE_OPERAND (ret_expr, 0); |
| if (TREE_CODE (result_decl) == INDIRECT_REF) |
| /* See through a return by reference. */ |
| result_decl = TREE_OPERAND (result_decl, 0); |
| |
| gcc_assert ((TREE_CODE (ret_expr) == MODIFY_EXPR |
| || TREE_CODE (ret_expr) == INIT_EXPR) |
| && TREE_CODE (result_decl) == RESULT_DECL); |
| } |
| |
| /* If aggregate_value_p is true, then we can return the bare RESULT_DECL. |
| Recall that aggregate_value_p is FALSE for any aggregate type that is |
| returned in registers. If we're returning values in registers, then |
| we don't want to extend the lifetime of the RESULT_DECL, particularly |
| across another call. In addition, for those aggregates for which |
| hard_function_value generates a PARALLEL, we'll abort during normal |
| expansion of structure assignments; there's special code in expand_return |
| to handle this case that does not exist in expand_expr. */ |
| if (!result_decl |
| || aggregate_value_p (result_decl, TREE_TYPE (current_function_decl))) |
| result = result_decl; |
| else if (gimplify_ctxp->return_temp) |
| result = gimplify_ctxp->return_temp; |
| else |
| { |
| result = create_tmp_var (TREE_TYPE (result_decl), NULL); |
| |
| /* ??? With complex control flow (usually involving abnormal edges), |
| we can wind up warning about an uninitialized value for this. Due |
| to how this variable is constructed and initialized, this is never |
| true. Give up and never warn. */ |
| TREE_NO_WARNING (result) = 1; |
| |
| gimplify_ctxp->return_temp = result; |
| } |
| |
| /* Smash the lhs of the MODIFY_EXPR to the temporary we plan to use. |
| Then gimplify the whole thing. */ |
| if (result != result_decl) |
| TREE_OPERAND (ret_expr, 0) = result; |
| |
| gimplify_and_add (TREE_OPERAND (stmt, 0), pre_p); |
| |
| /* If we didn't use a temporary, then the result is just the result_decl. |
| Otherwise we need a simple copy. This should already be gimple. */ |
| if (result == result_decl) |
| ret_expr = result; |
| else |
| ret_expr = build (MODIFY_EXPR, TREE_TYPE (result), result_decl, result); |
| TREE_OPERAND (stmt, 0) = ret_expr; |
| |
| return GS_ALL_DONE; |
| } |
| |
| /* Gimplifies a DECL_EXPR node *STMT_P by making any necessary allocation |
| and initialization explicit. */ |
| |
| static enum gimplify_status |
| gimplify_decl_expr (tree *stmt_p) |
| { |
| tree stmt = *stmt_p; |
| tree decl = DECL_EXPR_DECL (stmt); |
| |
| *stmt_p = NULL_TREE; |
| |
| if (TREE_TYPE (decl) == error_mark_node) |
| return GS_ERROR; |
| |
| if ((TREE_CODE (decl) == TYPE_DECL |
| || TREE_CODE (decl) == VAR_DECL) |
| && !TYPE_SIZES_GIMPLIFIED (TREE_TYPE (decl))) |
| gimplify_type_sizes (TREE_TYPE (decl), stmt_p); |
| |
| if (TREE_CODE (decl) == VAR_DECL && !DECL_EXTERNAL (decl)) |
| { |
| tree init = DECL_INITIAL (decl); |
| |
| if (!TREE_CONSTANT (DECL_SIZE (decl))) |
| { |
| /* This is a variable-sized decl. Simplify its size and mark it |
| for deferred expansion. Note that mudflap depends on the format |
| of the emitted code: see mx_register_decls(). */ |
| tree t, args, addr, ptr_type; |
| |
| gimplify_one_sizepos (&DECL_SIZE (decl), stmt_p); |
| gimplify_one_sizepos (&DECL_SIZE_UNIT (decl), stmt_p); |
| |
| /* All occurrences of this decl in final gimplified code will be |
| replaced by indirection. Setting DECL_VALUE_EXPR does two |
| things: First, it lets the rest of the gimplifier know what |
| replacement to use. Second, it lets the debug info know |
| where to find the value. */ |
| ptr_type = build_pointer_type (TREE_TYPE (decl)); |
| addr = create_tmp_var (ptr_type, get_name (decl)); |
| DECL_IGNORED_P (addr) = 0; |
| t = build_fold_indirect_ref (addr); |
| DECL_VALUE_EXPR (decl) = t; |
| |
| args = tree_cons (NULL, DECL_SIZE_UNIT (decl), NULL); |
| t = built_in_decls[BUILT_IN_ALLOCA]; |
| t = build_function_call_expr (t, args); |
| t = fold_convert (ptr_type, t); |
| t = build2 (MODIFY_EXPR, void_type_node, addr, t); |
| |
| gimplify_and_add (t, stmt_p); |
| |
| /* Indicate that we need to restore the stack level when the |
| enclosing BIND_EXPR is exited. */ |
| gimplify_ctxp->save_stack = true; |
| } |
| |
| if (init && init != error_mark_node) |
| { |
| if (!TREE_STATIC (decl)) |
| { |
| DECL_INITIAL (decl) = NULL_TREE; |
| init = build (MODIFY_EXPR, void_type_node, decl, init); |
| gimplify_and_add (init, stmt_p); |
| } |
| else |
| /* We must still examine initializers for static variables |
| as they may contain a label address. */ |
| walk_tree (&init, force_labels_r, NULL, NULL); |
| } |
| |
| /* This decl isn't mentioned in the enclosing block, so add it to the |
| list of temps. FIXME it seems a bit of a kludge to say that |
| anonymous artificial vars aren't pushed, but everything else is. */ |
| if (DECL_ARTIFICIAL (decl) && DECL_NAME (decl) == NULL_TREE) |
| gimple_add_tmp_var (decl); |
| } |
| |
| return GS_ALL_DONE; |
| } |
| |
| /* Gimplify a LOOP_EXPR. Normally this just involves gimplifying the body |
| and replacing the LOOP_EXPR with goto, but if the loop contains an |
| EXIT_EXPR, we need to append a label for it to jump to. */ |
| |
| static enum gimplify_status |
| gimplify_loop_expr (tree *expr_p, tree *pre_p) |
| { |
| tree saved_label = gimplify_ctxp->exit_label; |
| tree start_label = build1 (LABEL_EXPR, void_type_node, NULL_TREE); |
| tree jump_stmt = build_and_jump (&LABEL_EXPR_LABEL (start_label)); |
| |
| append_to_statement_list (start_label, pre_p); |
| |
| gimplify_ctxp->exit_label = NULL_TREE; |
| |
| gimplify_and_add (LOOP_EXPR_BODY (*expr_p), pre_p); |
| |
| if (gimplify_ctxp->exit_label) |
| { |
| append_to_statement_list (jump_stmt, pre_p); |
| *expr_p = build1 (LABEL_EXPR, void_type_node, gimplify_ctxp->exit_label); |
| } |
| else |
| *expr_p = jump_stmt; |
| |
| gimplify_ctxp->exit_label = saved_label; |
| |
| return GS_ALL_DONE; |
| } |
| |
| /* Compare two case labels. Because the front end should already have |
| made sure that case ranges do not overlap, it is enough to only compare |
| the CASE_LOW values of each case label. */ |
| |
| static int |
| compare_case_labels (const void *p1, const void *p2) |
| { |
| tree case1 = *(tree *)p1; |
| tree case2 = *(tree *)p2; |
| |
| return tree_int_cst_compare (CASE_LOW (case1), CASE_LOW (case2)); |
| } |
| |
| /* Sort the case labels in LABEL_VEC in place in ascending order. */ |
| |
| void |
| sort_case_labels (tree label_vec) |
| { |
| size_t len = TREE_VEC_LENGTH (label_vec); |
| tree default_case = TREE_VEC_ELT (label_vec, len - 1); |
| |
| if (CASE_LOW (default_case)) |
| { |
| size_t i; |
| |
| /* The last label in the vector should be the default case |
| but it is not. */ |
| for (i = 0; i < len; ++i) |
| { |
| tree t = TREE_VEC_ELT (label_vec, i); |
| if (!CASE_LOW (t)) |
| { |
| default_case = t; |
| TREE_VEC_ELT (label_vec, i) = TREE_VEC_ELT (label_vec, len - 1); |
| TREE_VEC_ELT (label_vec, len - 1) = default_case; |
| break; |
| } |
| } |
| } |
| |
| qsort (&TREE_VEC_ELT (label_vec, 0), len - 1, sizeof (tree), |
| compare_case_labels); |
| } |
| |
| /* Gimplify a SWITCH_EXPR, and collect a TREE_VEC of the labels it can |
| branch to. */ |
| |
| static enum gimplify_status |
| gimplify_switch_expr (tree *expr_p, tree *pre_p) |
| { |
| tree switch_expr = *expr_p; |
| enum gimplify_status ret; |
| |
| ret = gimplify_expr (&SWITCH_COND (switch_expr), pre_p, NULL, |
| is_gimple_val, fb_rvalue); |
| |
| if (SWITCH_BODY (switch_expr)) |
| { |
| varray_type labels, saved_labels; |
| tree label_vec, default_case = NULL_TREE; |
| size_t i, len; |
| |
| /* If someone can be bothered to fill in the labels, they can |
| be bothered to null out the body too. */ |
| gcc_assert (!SWITCH_LABELS (switch_expr)); |
| |
| saved_labels = gimplify_ctxp->case_labels; |
| VARRAY_TREE_INIT (gimplify_ctxp->case_labels, 8, "case_labels"); |
| |
| gimplify_to_stmt_list (&SWITCH_BODY (switch_expr)); |
| |
| labels = gimplify_ctxp->case_labels; |
| gimplify_ctxp->case_labels = saved_labels; |
| |
| len = VARRAY_ACTIVE_SIZE (labels); |
| |
| for (i = 0; i < len; ++i) |
| { |
| tree t = VARRAY_TREE (labels, i); |
| if (!CASE_LOW (t)) |
| { |
| /* The default case must be the last label in the list. */ |
| default_case = t; |
| VARRAY_TREE (labels, i) = VARRAY_TREE (labels, len - 1); |
| len--; |
| break; |
| } |
| } |
| |
| label_vec = make_tree_vec (len + 1); |
| SWITCH_LABELS (*expr_p) = label_vec; |
| append_to_statement_list (switch_expr, pre_p); |
| |
| if (! default_case) |
| { |
| /* If the switch has no default label, add one, so that we jump |
| around the switch body. */ |
| default_case = build (CASE_LABEL_EXPR, void_type_node, NULL_TREE, |
| NULL_TREE, create_artificial_label ()); |
| append_to_statement_list (SWITCH_BODY (switch_expr), pre_p); |
| *expr_p = build (LABEL_EXPR, void_type_node, |
| CASE_LABEL (default_case)); |
| } |
| else |
| *expr_p = SWITCH_BODY (switch_expr); |
| |
| for (i = 0; i < len; ++i) |
| TREE_VEC_ELT (label_vec, i) = VARRAY_TREE (labels, i); |
| TREE_VEC_ELT (label_vec, len) = default_case; |
| |
| sort_case_labels (label_vec); |
| |
| SWITCH_BODY (switch_expr) = NULL; |
| } |
| else |
| gcc_assert (SWITCH_LABELS (switch_expr)); |
| |
| return ret; |
| } |
| |
| static enum gimplify_status |
| gimplify_case_label_expr (tree *expr_p) |
| { |
| tree expr = *expr_p; |
| |
| gcc_assert (gimplify_ctxp->case_labels); |
| VARRAY_PUSH_TREE (gimplify_ctxp->case_labels, expr); |
| *expr_p = build (LABEL_EXPR, void_type_node, CASE_LABEL (expr)); |
| return GS_ALL_DONE; |
| } |
| |
| /* Build a GOTO to the LABEL_DECL pointed to by LABEL_P, building it first |
| if necessary. */ |
| |
| tree |
| build_and_jump (tree *label_p) |
| { |
| if (label_p == NULL) |
| /* If there's nowhere to jump, just fall through. */ |
| return NULL_TREE; |
| |
| if (*label_p == NULL_TREE) |
| { |
| tree label = create_artificial_label (); |
| *label_p = label; |
| } |
| |
| return build1 (GOTO_EXPR, void_type_node, *label_p); |
| } |
| |
| /* Gimplify an EXIT_EXPR by converting to a GOTO_EXPR inside a COND_EXPR. |
| This also involves building a label to jump to and communicating it to |
| gimplify_loop_expr through gimplify_ctxp->exit_label. */ |
| |
| static enum gimplify_status |
| gimplify_exit_expr (tree *expr_p) |
| { |
| tree cond = TREE_OPERAND (*expr_p, 0); |
| tree expr; |
| |
| expr = build_and_jump (&gimplify_ctxp->exit_label); |
| expr = build (COND_EXPR, void_type_node, cond, expr, NULL_TREE); |
| *expr_p = expr; |
| |
| return GS_OK; |
| } |
| |
| /* A helper function to be called via walk_tree. Mark all labels under *TP |
| as being forced. To be called for DECL_INITIAL of static variables. */ |
| |
| tree |
| force_labels_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED) |
| { |
| if (TYPE_P (*tp)) |
| *walk_subtrees = 0; |
| if (TREE_CODE (*tp) == LABEL_DECL) |
| FORCED_LABEL (*tp) = 1; |
| |
| return NULL_TREE; |
| } |
| |
| /* *EXPR_P is a COMPONENT_REF being used as an rvalue. If its type is |
| different from its canonical type, wrap the whole thing inside a |
| NOP_EXPR and force the type of the COMPONENT_REF to be the canonical |
| type. |
| |
| The canonical type of a COMPONENT_REF is the type of the field being |
| referenced--unless the field is a bit-field which can be read directly |
| in a smaller mode, in which case the canonical type is the |
| sign-appropriate type corresponding to that mode. */ |
| |
| static void |
| canonicalize_component_ref (tree *expr_p) |
| { |
| tree expr = *expr_p; |
| tree type; |
| |
| gcc_assert (TREE_CODE (expr) == COMPONENT_REF); |
| |
| if (INTEGRAL_TYPE_P (TREE_TYPE (expr))) |
| type = TREE_TYPE (get_unwidened (expr, NULL_TREE)); |
| else |
| type = TREE_TYPE (TREE_OPERAND (expr, 1)); |
| |
| if (TREE_TYPE (expr) != type) |
| { |
| tree old_type = TREE_TYPE (expr); |
| |
| /* Set the type of the COMPONENT_REF to the underlying type. */ |
| TREE_TYPE (expr) = type; |
| |
| /* And wrap the whole thing inside a NOP_EXPR. */ |
| expr = build1 (NOP_EXPR, old_type, expr); |
| |
| *expr_p = expr; |
| } |
| } |
| |
| /* If a NOP conversion is changing a pointer to array of foo to a pointer |
| to foo, embed that change in the ADDR_EXPR by converting |
| T array[U]; |
| (T *)&array |
| ==> |
| &array[L] |
| where L is the lower bound. For simplicity, only do this for constant |
| lower bound. */ |
| |
| static void |
| canonicalize_addr_expr (tree *expr_p) |
| { |
| tree expr = *expr_p; |
| tree ctype = TREE_TYPE (expr); |
| tree addr_expr = TREE_OPERAND (expr, 0); |
| tree atype = TREE_TYPE (addr_expr); |
| tree dctype, datype, ddatype, otype, obj_expr; |
| |
| /* Both cast and addr_expr types should be pointers. */ |
| if (!POINTER_TYPE_P (ctype) || !POINTER_TYPE_P (atype)) |
| return; |
| |
| /* The addr_expr type should be a pointer to an array. */ |
| datype = TREE_TYPE (atype); |
| if (TREE_CODE (datype) != ARRAY_TYPE) |
| return; |
| |
| /* Both cast and addr_expr types should address the same object type. */ |
| dctype = TREE_TYPE (ctype); |
| ddatype = TREE_TYPE (datype); |
| if (!lang_hooks.types_compatible_p (ddatype, dctype)) |
| return; |
| |
| /* The addr_expr and the object type should match. */ |
| obj_expr = TREE_OPERAND (addr_expr, 0); |
| otype = TREE_TYPE (obj_expr); |
| if (!lang_hooks.types_compatible_p (otype, datype)) |
| return; |
| |
| /* The lower bound and element sizes must be constant. */ |
| if (!TYPE_SIZE_UNIT (dctype) |
| || TREE_CODE (TYPE_SIZE_UNIT (dctype)) != INTEGER_CST |
| || !TYPE_DOMAIN (datype) || !TYPE_MIN_VALUE (TYPE_DOMAIN (datype)) |
| || TREE_CODE (TYPE_MIN_VALUE (TYPE_DOMAIN (datype))) != INTEGER_CST) |
| return; |
| |
| /* All checks succeeded. Build a new node to merge the cast. */ |
| *expr_p = build4 (ARRAY_REF, dctype, obj_expr, |
| TYPE_MIN_VALUE (TYPE_DOMAIN (datype)), |
| TYPE_MIN_VALUE (TYPE_DOMAIN (datype)), |
| size_binop (EXACT_DIV_EXPR, TYPE_SIZE_UNIT (dctype), |
| size_int (TYPE_ALIGN_UNIT (dctype)))); |
| *expr_p = build1 (ADDR_EXPR, ctype, *expr_p); |
| } |
| |
| /* *EXPR_P is a NOP_EXPR or CONVERT_EXPR. Remove it and/or other conversions |
| underneath as appropriate. */ |
| |
| static enum gimplify_status |
| gimplify_conversion (tree *expr_p) |
| { |
| gcc_assert (TREE_CODE (*expr_p) == NOP_EXPR |
| || TREE_CODE (*expr_p) == CONVERT_EXPR); |
| |
| /* Then strip away all but the outermost conversion. */ |
| STRIP_SIGN_NOPS (TREE_OPERAND (*expr_p, 0)); |
| |
| /* And remove the outermost conversion if it's useless. */ |
| if (tree_ssa_useless_type_conversion (*expr_p)) |
| *expr_p = TREE_OPERAND (*expr_p, 0); |
| |
| /* If we still have a conversion at the toplevel, |
| then canonicalize some constructs. */ |
| if (TREE_CODE (*expr_p) == NOP_EXPR || TREE_CODE (*expr_p) == CONVERT_EXPR) |
| { |
| tree sub = TREE_OPERAND (*expr_p, 0); |
| |
| /* If a NOP conversion is changing the type of a COMPONENT_REF |
| expression, then canonicalize its type now in order to expose more |
| redundant conversions. */ |
| if (TREE_CODE (sub) == COMPONENT_REF) |
| canonicalize_component_ref (&TREE_OPERAND (*expr_p, 0)); |
| |
| /* If a NOP conversion is changing a pointer to array of foo |
| to a pointer to foo, embed that change in the ADDR_EXPR. */ |
| else if (TREE_CODE (sub) == ADDR_EXPR) |
| canonicalize_addr_expr (expr_p); |
| } |
| |
| return GS_OK; |
| } |
| |
| /* Gimplify the COMPONENT_REF, ARRAY_REF, REALPART_EXPR or IMAGPART_EXPR |
| node pointed by EXPR_P. |
| |
| compound_lval |
| : min_lval '[' val ']' |
| | min_lval '.' ID |
| | compound_lval '[' val ']' |
| | compound_lval '.' ID |
| |
| This is not part of the original SIMPLE definition, which separates |
| array and member references, but it seems reasonable to handle them |
| together. Also, this way we don't run into problems with union |
| aliasing; gcc requires that for accesses through a union to alias, the |
| union reference must be explicit, which was not always the case when we |
| were splitting up array and member refs. |
| |
| PRE_P points to the list where side effects that must happen before |
| *EXPR_P should be stored. |
| |
| POST_P points to the list where side effects that must happen after |
| *EXPR_P should be stored. */ |
| |
| static enum gimplify_status |
| gimplify_compound_lval (tree *expr_p, tree *pre_p, |
| tree *post_p, fallback_t fallback) |
| { |
| tree *p; |
| varray_type stack; |
| enum gimplify_status ret = GS_OK, tret; |
| int i; |
| |
| /* Create a stack of the subexpressions so later we can walk them in |
| order from inner to outer. |
| |
| This array is very memory consuming. Don't even think of making |
| it VARRAY_TREE. */ |
| VARRAY_GENERIC_PTR_NOGC_INIT (stack, 10, "stack"); |
| |
| /* We can handle anything that get_inner_reference can deal with. */ |
| for (p = expr_p; ; p = &TREE_OPERAND (*p, 0)) |
| { |
| /* Fold INDIRECT_REFs now to turn them into ARRAY_REFs. */ |
| if (TREE_CODE (*p) == INDIRECT_REF) |
| *p = fold_indirect_ref (*p); |
| if (!handled_component_p (*p)) |
| break; |
| VARRAY_PUSH_GENERIC_PTR_NOGC (stack, *p); |
| } |
| |
| gcc_assert (VARRAY_ACTIVE_SIZE (stack)); |
| |
| /* Now STACK is a stack of pointers to all the refs we've walked through |
| and P points to the innermost expression. |
| |
| Java requires that we elaborated nodes in source order. That |
| means we must gimplify the inner expression followed by each of |
| the indices, in order. But we can't gimplify the inner |
| expression until we deal with any variable bounds, sizes, or |
| positions in order to deal with PLACEHOLDER_EXPRs. |
| |
| So we do this in three steps. First we deal with the annotations |
| for any variables in the components, then we gimplify the base, |
| then we gimplify any indices, from left to right. */ |
| for (i = VARRAY_ACTIVE_SIZE (stack) - 1; i >= 0; i--) |
| { |
| tree t = VARRAY_GENERIC_PTR_NOGC (stack, i); |
| |
| if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF) |
| { |
| /* Gimplify the low bound and element type size and put them into |
| the ARRAY_REF. If these values are set, they have already been |
| gimplified. */ |
| /* APPLE LOCAL begin LLVM */ |
| /* Handle the LLVM extension that allows: (ARRAY_REF ptr, idx) */ |
| if (!TREE_OPERAND (t, 2) && |
| TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == ARRAY_TYPE) |
| /* APPLE LOCAL end LLVM */ |
| { |
| tree low = unshare_expr (array_ref_low_bound (t)); |
| if (!is_gimple_min_invariant (low)) |
| { |
| TREE_OPERAND (t, 2) = low; |
| tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p, |
| is_gimple_formal_tmp_reg, fb_rvalue); |
| ret = MIN (ret, tret); |
| } |
| } |
| |
| /* APPLE LOCAL begin LLVM */ |
| /* Handle the LLVM extension that allows: (ARRAY_REF ptr, idx) */ |
| if (!TREE_OPERAND (t, 3) && |
| TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == ARRAY_TYPE) |
| /* APPLE LOCAL end LLVM */ |
| { |
| tree elmt_type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (t, 0))); |
| tree elmt_size = unshare_expr (array_ref_element_size (t)); |
| tree factor = size_int (TYPE_ALIGN_UNIT (elmt_type)); |
| |
| /* Divide the element size by the alignment of the element |
| type (above). */ |
| elmt_size = size_binop (EXACT_DIV_EXPR, elmt_size, factor); |
| |
| if (!is_gimple_min_invariant (elmt_size)) |
| { |
| TREE_OPERAND (t, 3) = elmt_size; |
| tret = gimplify_expr (&TREE_OPERAND (t, 3), pre_p, post_p, |
| is_gimple_formal_tmp_reg, fb_rvalue); |
| ret = MIN (ret, tret); |
| } |
| } |
| } |
| else if (TREE_CODE (t) == COMPONENT_REF) |
| { |
| /* Set the field offset into T and gimplify it. */ |
| if (!TREE_OPERAND (t, 2)) |
| { |
| tree offset = unshare_expr (component_ref_field_offset (t)); |
| tree field = TREE_OPERAND (t, 1); |
| tree factor |
| = size_int (DECL_OFFSET_ALIGN (field) / BITS_PER_UNIT); |
| |
| /* Divide the offset by its alignment. */ |
| offset = size_binop (EXACT_DIV_EXPR, offset, factor); |
| |
| if (!is_gimple_min_invariant (offset)) |
| { |
| TREE_OPERAND (t, 2) = offset; |
| tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p, |
| is_gimple_formal_tmp_reg, fb_rvalue); |
| ret = MIN (ret, tret); |
| } |
| } |
| } |
| } |
| |
| /* APPLE LOCAL begin mainline LLVM */ |
| /* Step 2 is to gimplify the base expression. Make sure lvalue is set |
| so as to match the min_lval predicate. Failure to do so may result |
| in the creation of large aggregate temporaries. */ |
| tret = gimplify_expr (p, pre_p, post_p, is_gimple_min_lval, |
| fallback | fb_lvalue); |
| /* APPLE LOCAL end mainline LLVM */ |
| ret = MIN (ret, tret); |
| |
| /* And finally, the indices and operands to BIT_FIELD_REF. During this |
| loop we also remove any useless conversions. */ |
| for (; VARRAY_ACTIVE_SIZE (stack) > 0; ) |
| { |
| tree t = VARRAY_TOP_TREE (stack); |
| |
| if (TREE_CODE (t) == ARRAY_REF || TREE_CODE (t) == ARRAY_RANGE_REF) |
| { |
| /* Gimplify the dimension. |
| Temporary fix for gcc.c-torture/execute/20040313-1.c. |
| Gimplify non-constant array indices into a temporary |
| variable. |
| FIXME - The real fix is to gimplify post-modify |
| expressions into a minimal gimple lvalue. However, that |
| exposes bugs in alias analysis. The alias analyzer does |
| not handle &PTR->FIELD very well. Will fix after the |
| branch is merged into mainline (dnovillo 2004-05-03). */ |
| if (!is_gimple_min_invariant (TREE_OPERAND (t, 1))) |
| { |
| tret = gimplify_expr (&TREE_OPERAND (t, 1), pre_p, post_p, |
| is_gimple_formal_tmp_reg, fb_rvalue); |
| ret = MIN (ret, tret); |
| } |
| } |
| else if (TREE_CODE (t) == BIT_FIELD_REF) |
| { |
| tret = gimplify_expr (&TREE_OPERAND (t, 1), pre_p, post_p, |
| is_gimple_val, fb_rvalue); |
| ret = MIN (ret, tret); |
| tret = gimplify_expr (&TREE_OPERAND (t, 2), pre_p, post_p, |
| is_gimple_val, fb_rvalue); |
| ret = MIN (ret, tret); |
| } |
| |
| STRIP_USELESS_TYPE_CONVERSION (TREE_OPERAND (t, 0)); |
| |
| /* The innermost expression P may have originally had TREE_SIDE_EFFECTS |
| set which would have caused all the outer expressions in EXPR_P |
| leading to P to also have had TREE_SIDE_EFFECTS set. */ |
| recalculate_side_effects (t); |
| VARRAY_POP (stack); |
| } |
| |
| tret = gimplify_expr (p, pre_p, post_p, is_gimple_min_lval, fallback); |
| ret = MIN (ret, tret); |
| |
| /* If the outermost expression is a COMPONENT_REF, canonicalize its type. */ |
| if ((fallback & fb_rvalue) && TREE_CODE (*expr_p) == COMPONENT_REF) |
| { |
| canonicalize_component_ref (expr_p); |
| ret = MIN (ret, GS_OK); |
| } |
| |
| VARRAY_FREE (stack); |
| |
| return ret; |
| } |
| |
| /* Gimplify the self modifying expression pointed by EXPR_P (++, --, +=, -=). |
| |
| PRE_P points to the list where side effects that must happen before |
| *EXPR_P should be stored. |
| |
| POST_P points to the list where side effects that must happen after |
| *EXPR_P should be stored. |
| |
| WANT_VALUE is nonzero iff we want to use the value of this expression |
| in another expression. */ |
| |
| static enum gimplify_status |
| gimplify_self_mod_expr (tree *expr_p, tree *pre_p, tree *post_p, |
| bool want_value) |
| { |
| enum tree_code code; |
| tree lhs, lvalue, rhs, t1; |
| bool postfix; |
| enum tree_code arith_code; |
| enum gimplify_status ret; |
| |
| code = TREE_CODE (*expr_p); |
| |
| gcc_assert (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR |
| || code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR); |
| |
| /* Prefix or postfix? */ |
| if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR) |
| /* Faster to treat as prefix if result is not used. */ |
| postfix = want_value; |
| else |
| postfix = false; |
| |
| /* Add or subtract? */ |
| if (code == PREINCREMENT_EXPR || code == POSTINCREMENT_EXPR) |
| arith_code = PLUS_EXPR; |
| else |
| arith_code = MINUS_EXPR; |
| |
| /* Gimplify the LHS into a GIMPLE lvalue. */ |
| lvalue = TREE_OPERAND (*expr_p, 0); |
| ret = gimplify_expr (&lvalue, pre_p, post_p, is_gimple_lvalue, fb_lvalue); |
| if (ret == GS_ERROR) |
| return ret; |
| |
| /* Extract the operands to the arithmetic operation. */ |
| lhs = lvalue; |
| rhs = TREE_OPERAND (*expr_p, 1); |
| |
| /* For postfix operator, we evaluate the LHS to an rvalue and then use |
| that as the result value and in the postqueue operation. */ |
| if (postfix) |
| { |
| ret = gimplify_expr (&lhs, pre_p, post_p, is_gimple_val, fb_rvalue); |
| if (ret == GS_ERROR) |
| return ret; |
| } |
| |
| t1 = build (arith_code, TREE_TYPE (*expr_p), lhs, rhs); |
| t1 = build (MODIFY_EXPR, TREE_TYPE (lvalue), lvalue, t1); |
| |
| if (postfix) |
| { |
| gimplify_and_add (t1, post_p); |
| *expr_p = lhs; |
| return GS_ALL_DONE; |
| } |
| else |
| { |
| *expr_p = t1; |
| return GS_OK; |
| } |
| } |
| |
| /* If *EXPR_P has a variable sized type, wrap it in a WITH_SIZE_EXPR. */ |
| |
| static void |
| maybe_with_size_expr (tree *expr_p) |
| { |
| tree expr = *expr_p; |
| tree type = TREE_TYPE (expr); |
| tree size; |
| |
| /* If we've already wrapped this or the type is error_mark_node, we can't do |
| anything. */ |
| if (TREE_CODE (expr) == WITH_SIZE_EXPR |
| || type == error_mark_node) |
| return; |
| |
| /* If the size isn't known or is a constant, we have nothing to do. */ |
| size = TYPE_SIZE_UNIT (type); |
| if (!size || TREE_CODE (size) == INTEGER_CST) |
| return; |
| |
| /* Otherwise, make a WITH_SIZE_EXPR. */ |
| size = unshare_expr (size); |
| size = SUBSTITUTE_PLACEHOLDER_IN_EXPR (size, expr); |
| *expr_p = build2 (WITH_SIZE_EXPR, type, expr, size); |
| } |
| |
| /* Subroutine of gimplify_call_expr: Gimplify a single argument. */ |
| |
| static enum gimplify_status |
| gimplify_arg (tree *expr_p, tree *pre_p) |
| { |
| bool (*test) (tree); |
| fallback_t fb; |
| |
| /* In general, we allow lvalues for function arguments to avoid |
| extra overhead of copying large aggregates out of even larger |
| aggregates into temporaries only to copy the temporaries to |
| the argument list. Make optimizers happy by pulling out to |
| temporaries those types that fit in registers. */ |
| if (is_gimple_reg_type (TREE_TYPE (*expr_p))) |
| test = is_gimple_val, fb = fb_rvalue; |
| else |
| test = is_gimple_lvalue, fb = fb_either; |
| |
| /* If this is a variable sized type, we must remember the size. */ |
| maybe_with_size_expr (expr_p); |
| |
| /* There is a sequence point before a function call. Side effects in |
| the argument list must occur before the actual call. So, when |
| gimplifying arguments, force gimplify_expr to use an internal |
| post queue which is then appended to the end of PRE_P. */ |
| return gimplify_expr (expr_p, pre_p, NULL, test, fb); |
| } |
| |
| /* Gimplify the CALL_EXPR node pointed by EXPR_P. PRE_P points to the |
| list where side effects that must happen before *EXPR_P should be stored. |
| WANT_VALUE is true if the result of the call is desired. */ |
| |
| static enum gimplify_status |
| gimplify_call_expr (tree *expr_p, tree *pre_p, bool want_value) |
| { |
| tree decl; |
| tree arglist; |
| enum gimplify_status ret; |
| |
| gcc_assert (TREE_CODE (*expr_p) == CALL_EXPR); |
| |
| /* For reliable diagnostics during inlining, it is necessary that |
| every call_expr be annotated with file and line. */ |
| if (! EXPR_HAS_LOCATION (*expr_p)) |
| SET_EXPR_LOCATION (*expr_p, input_location); |
| |
| /* This may be a call to a builtin function. |
| |
| Builtin function calls may be transformed into different |
| (and more efficient) builtin function calls under certain |
| circumstances. Unfortunately, gimplification can muck things |
| up enough that the builtin expanders are not aware that certain |
| transformations are still valid. |
| |
| So we attempt transformation/gimplification of the call before |
| we gimplify the CALL_EXPR. At this time we do not manage to |
| transform all calls in the same manner as the expanders do, but |
| we do transform most of them. */ |
| decl = get_callee_fndecl (*expr_p); |
| if (decl && DECL_BUILT_IN (decl)) |
| { |
| tree new = fold_builtin (*expr_p, !want_value); |
| |
| if (new && new != *expr_p) |
| { |
| /* There was a transformation of this call which computes the |
| same value, but in a more efficient way. Return and try |
| again. */ |
| *expr_p = new; |
| return GS_OK; |
| } |
| |
| if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL |
| && DECL_FUNCTION_CODE (decl) == BUILT_IN_VA_START) |
| { |
| tree arglist = TREE_OPERAND (*expr_p, 1); |
| |
| if (!arglist || !TREE_CHAIN (arglist)) |
| { |
| error ("too few arguments to function %<va_start%>"); |
| *expr_p = build_empty_stmt (); |
| return GS_OK; |
| } |
| |
| if (fold_builtin_next_arg (TREE_CHAIN (arglist))) |
| { |
| *expr_p = build_empty_stmt (); |
| return GS_OK; |
| } |
| /* Avoid gimplifying the second argument to va_start, which needs |
| to be the plain PARM_DECL. */ |
| return gimplify_arg (&TREE_VALUE (TREE_OPERAND (*expr_p, 1)), pre_p); |
| } |
| } |
| |
| /* There is a sequence point before the call, so any side effects in |
| the calling expression must occur before the actual call. Force |
| gimplify_expr to use an internal post queue. */ |
| ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, NULL, |
| is_gimple_call_addr, fb_rvalue); |
| |
| if (PUSH_ARGS_REVERSED) |
| TREE_OPERAND (*expr_p, 1) = nreverse (TREE_OPERAND (*expr_p, 1)); |
| for (arglist = TREE_OPERAND (*expr_p, 1); arglist; |
| arglist = TREE_CHAIN (arglist)) |
| { |
| enum gimplify_status t; |
| |
| t = gimplify_arg (&TREE_VALUE (arglist), pre_p); |
| |
| if (t == GS_ERROR) |
| ret = GS_ERROR; |
| } |
| if (PUSH_ARGS_REVERSED) |
| TREE_OPERAND (*expr_p, 1) = nreverse (TREE_OPERAND (*expr_p, 1)); |
| |
| /* Try this again in case gimplification exposed something. */ |
| if (ret != GS_ERROR && decl && DECL_BUILT_IN (decl)) |
| { |
| tree new = fold_builtin (*expr_p, !want_value); |
| |
| if (new && new != *expr_p) |
| { |
| /* There was a transformation of this call which computes the |
| same value, but in a more efficient way. Return and try |
| again. */ |
| *expr_p = new; |
| return GS_OK; |
| } |
| } |
| |
| /* If the function is "const" or "pure", then clear TREE_SIDE_EFFECTS on its |
| decl. This allows us to eliminate redundant or useless |
| calls to "const" functions. */ |
| if (TREE_CODE (*expr_p) == CALL_EXPR |
| && (call_expr_flags (*expr_p) & (ECF_CONST | ECF_PURE))) |
| TREE_SIDE_EFFECTS (*expr_p) = 0; |
| |
| return ret; |
| } |
| |
| /* Handle shortcut semantics in the predicate operand of a COND_EXPR by |
| rewriting it into multiple COND_EXPRs, and possibly GOTO_EXPRs. |
| |
| TRUE_LABEL_P and FALSE_LABEL_P point to the labels to jump to if the |
| condition is true or false, respectively. If null, we should generate |
| our own to skip over the evaluation of this specific expression. |
| |
| This function is the tree equivalent of do_jump. |
| |
| shortcut_cond_r should only be called by shortcut_cond_expr. */ |
| |
| static tree |
| shortcut_cond_r (tree pred, tree *true_label_p, tree *false_label_p) |
| { |
| tree local_label = NULL_TREE; |
| tree t, expr = NULL; |
| |
| /* OK, it's not a simple case; we need to pull apart the COND_EXPR to |
| retain the shortcut semantics. Just insert the gotos here; |
| shortcut_cond_expr will append the real blocks later. */ |
| if (TREE_CODE (pred) == TRUTH_ANDIF_EXPR) |
| { |
| /* Turn if (a && b) into |
| |
| if (a); else goto no; |
| if (b) goto yes; else goto no; |
| (no:) */ |
| |
| if (false_label_p == NULL) |
| false_label_p = &local_label; |
| |
| t = shortcut_cond_r (TREE_OPERAND (pred, 0), NULL, false_label_p); |
| append_to_statement_list (t, &expr); |
| |
| t = shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p, |
| false_label_p); |
| append_to_statement_list (t, &expr); |
| } |
| else if (TREE_CODE (pred) == TRUTH_ORIF_EXPR) |
| { |
| /* Turn if (a || b) into |
| |
| if (a) goto yes; |
| if (b) goto yes; else goto no; |
| (yes:) */ |
| |
| if (true_label_p == NULL) |
| true_label_p = &local_label; |
| |
| t = shortcut_cond_r (TREE_OPERAND (pred, 0), true_label_p, NULL); |
| append_to_statement_list (t, &expr); |
| |
| t = shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p, |
| false_label_p); |
| append_to_statement_list (t, &expr); |
| } |
| else if (TREE_CODE (pred) == COND_EXPR) |
| { |
| /* As long as we're messing with gotos, turn if (a ? b : c) into |
| if (a) |
| if (b) goto yes; else goto no; |
| else |
| if (c) goto yes; else goto no; */ |
| expr = build (COND_EXPR, void_type_node, TREE_OPERAND (pred, 0), |
| shortcut_cond_r (TREE_OPERAND (pred, 1), true_label_p, |
| false_label_p), |
| shortcut_cond_r (TREE_OPERAND (pred, 2), true_label_p, |
| false_label_p)); |
| } |
| else |
| { |
| expr = build (COND_EXPR, void_type_node, pred, |
| build_and_jump (true_label_p), |
| build_and_jump (false_label_p)); |
| } |
| |
| if (local_label) |
| { |
| t = build1 (LABEL_EXPR, void_type_node, local_label); |
| append_to_statement_list (t, &expr); |
| } |
| |
| return expr; |
| } |
| |
| static tree |
| shortcut_cond_expr (tree expr) |
| { |
| tree pred = TREE_OPERAND (expr, 0); |
| tree then_ = TREE_OPERAND (expr, 1); |
| tree else_ = TREE_OPERAND (expr, 2); |
| tree true_label, false_label, end_label, t; |
| tree *true_label_p; |
| tree *false_label_p; |
| bool emit_end, emit_false, jump_over_else; |
| bool then_se = then_ && TREE_SIDE_EFFECTS (then_); |
| bool else_se = else_ && TREE_SIDE_EFFECTS (else_); |
| |
| /* First do simple transformations. */ |
| if (!else_se) |
| { |
| /* If there is no 'else', turn (a && b) into if (a) if (b). */ |
| while (TREE_CODE (pred) == TRUTH_ANDIF_EXPR) |
| { |
| TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1); |
| then_ = shortcut_cond_expr (expr); |
| then_se = then_ && TREE_SIDE_EFFECTS (then_); |
| pred = TREE_OPERAND (pred, 0); |
| expr = build (COND_EXPR, void_type_node, pred, then_, NULL_TREE); |
| } |
| } |
| if (!then_se) |
| { |
| /* If there is no 'then', turn |
| if (a || b); else d |
| into |
| if (a); else if (b); else d. */ |
| while (TREE_CODE (pred) == TRUTH_ORIF_EXPR) |
| { |
| TREE_OPERAND (expr, 0) = TREE_OPERAND (pred, 1); |
| else_ = shortcut_cond_expr (expr); |
| else_se = else_ && TREE_SIDE_EFFECTS (else_); |
| pred = TREE_OPERAND (pred, 0); |
| expr = build (COND_EXPR, void_type_node, pred, NULL_TREE, else_); |
| } |
| } |
| |
| /* If we're done, great. */ |
| if (TREE_CODE (pred) != TRUTH_ANDIF_EXPR |
| && TREE_CODE (pred) != TRUTH_ORIF_EXPR) |
| return expr; |
| |
| /* Otherwise we need to mess with gotos. Change |
| if (a) c; else d; |
| to |
| if (a); else goto no; |
| c; goto end; |
| no: d; end: |
| and recursively gimplify the condition. */ |
| |
| true_label = false_label = end_label = NULL_TREE; |
| |
| /* If our arms just jump somewhere, hijack those labels so we don't |
| generate jumps to jumps. */ |
| |
| if (then_ |
| && TREE_CODE (then_) == GOTO_EXPR |
| && TREE_CODE (GOTO_DESTINATION (then_)) == LABEL_DECL) |
| { |
| true_label = GOTO_DESTINATION (then_); |
| then_ = NULL; |
| then_se = false; |
| } |
| |
| if (else_ |
| && TREE_CODE (else_) == GOTO_EXPR |
| && TREE_CODE (GOTO_DESTINATION (else_)) == LABEL_DECL) |
| { |
| false_label = GOTO_DESTINATION (else_); |
| else_ = NULL; |
| else_se = false; |
| } |
| |
| /* If we aren't hijacking a label for the 'then' branch, it falls through. */ |
| if (true_label) |
| true_label_p = &true_label; |
| else |
| true_label_p = NULL; |
| |
| /* The 'else' branch also needs a label if it contains interesting code. */ |
| if (false_label || else_se) |
| false_label_p = &false_label; |
| else |
| false_label_p = NULL; |
| |
| /* If there was nothing else in our arms, just forward the label(s). */ |
| if (!then_se && !else_se) |
| return shortcut_cond_r (pred, true_label_p, false_label_p); |
| |
| /* If our last subexpression already has a terminal label, reuse it. */ |
| if (else_se) |
| expr = expr_last (else_); |
| else if (then_se) |
| expr = expr_last (then_); |
| else |
| expr = NULL; |
| if (expr && TREE_CODE (expr) == LABEL_EXPR) |
| end_label = LABEL_EXPR_LABEL (expr); |
| |
| /* If we don't care about jumping to the 'else' branch, jump to the end |
| if the condition is false. */ |
| if (!false_label_p) |
| false_label_p = &end_label; |
| |
| /* We only want to emit these labels if we aren't hijacking them. */ |
| emit_end = (end_label == NULL_TREE); |
| emit_false = (false_label == NULL_TREE); |
| |
| /* We only emit the jump over the else clause if we have to--if the |
| then clause may fall through. Otherwise we can wind up with a |
| useless jump and a useless label at the end of gimplified code, |
| which will cause us to think that this conditional as a whole |
| falls through even if it doesn't. If we then inline a function |
| which ends with such a condition, that can cause us to issue an |
| inappropriate warning about control reaching the end of a |
| non-void function. */ |
| jump_over_else = block_may_fallthru (then_); |
| |
| pred = shortcut_cond_r (pred, true_label_p, false_label_p); |
| |
| expr = NULL; |
| append_to_statement_list (pred, &expr); |
| |
| append_to_statement_list (then_, &expr); |
| if (else_se) |
| { |
| if (jump_over_else) |
| { |
| t = build_and_jump (&end_label); |
| append_to_statement_list (t, &expr); |
| } |
| if (emit_false) |
| { |
| t = build1 (LABEL_EXPR, void_type_node, false_label); |
| append_to_statement_list (t, &expr); |
| } |
| append_to_statement_list (else_, &expr); |
| } |
| if (emit_end && end_label) |
| { |
| t = build1 (LABEL_EXPR, void_type_node, end_label); |
| append_to_statement_list (t, &expr); |
| } |
| |
| return expr; |
| } |
| |
| /* EXPR is used in a boolean context; make sure it has BOOLEAN_TYPE. */ |
| |
| static tree |
| gimple_boolify (tree expr) |
| { |
| tree type = TREE_TYPE (expr); |
| |
| if (TREE_CODE (type) == BOOLEAN_TYPE) |
| return expr; |
| |
| /* If this is the predicate of a COND_EXPR, it might not even be a |
| truthvalue yet. */ |
| expr = lang_hooks.truthvalue_conversion (expr); |
| |
| switch (TREE_CODE (expr)) |
| { |
| case TRUTH_AND_EXPR: |
| case TRUTH_OR_EXPR: |
| case TRUTH_XOR_EXPR: |
| case TRUTH_ANDIF_EXPR: |
| case TRUTH_ORIF_EXPR: |
| /* Also boolify the arguments of truth exprs. */ |
| TREE_OPERAND (expr, 1) = gimple_boolify (TREE_OPERAND (expr, 1)); |
| /* FALLTHRU */ |
| |
| case TRUTH_NOT_EXPR: |
| TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0)); |
| /* FALLTHRU */ |
| |
| case EQ_EXPR: case NE_EXPR: |
| case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR: |
| /* These expressions always produce boolean results. */ |
| TREE_TYPE (expr) = boolean_type_node; |
| return expr; |
| |
| default: |
| /* Other expressions that get here must have boolean values, but |
| might need to be converted to the appropriate mode. */ |
| return convert (boolean_type_node, expr); |
| } |
| } |
| |
| /* Convert the conditional expression pointed by EXPR_P '(p) ? a : b;' |
| into |
| |
| if (p) if (p) |
| t1 = a; a; |
| else or else |
| t1 = b; b; |
| t1; |
| |
| The second form is used when *EXPR_P is of type void. |
| |
| TARGET is the tree for T1 above. |
| |
| PRE_P points to the list where side effects that must happen before |
| *EXPR_P should be stored. |
| |
| POST_P points to the list where side effects that must happen after |
| *EXPR_P should be stored. */ |
| |
| static enum gimplify_status |
| gimplify_cond_expr (tree *expr_p, tree *pre_p, tree *post_p, tree target, |
| fallback_t fallback) |
| { |
| tree expr = *expr_p; |
| tree tmp, tmp2, type; |
| enum gimplify_status ret; |
| |
| type = TREE_TYPE (expr); |
| if (!type) |
| TREE_TYPE (expr) = void_type_node; |
| |
| /* If this COND_EXPR has a value, copy the values into a temporary within |
| the arms. */ |
| else if (! VOID_TYPE_P (type)) |
| { |
| tree result; |
| |
| if (target) |
| { |
| ret = gimplify_expr (&target, pre_p, post_p, |
| is_gimple_min_lval, fb_lvalue); |
| if (ret != GS_ERROR) |
| ret = GS_OK; |
| result = tmp = target; |
| tmp2 = unshare_expr (target); |
| } |
| else if ((fallback & fb_lvalue) == 0) |
| { |
| result = tmp2 = tmp = create_tmp_var (TREE_TYPE (expr), "iftmp"); |
| ret = GS_ALL_DONE; |
| } |
| else |
| { |
| tree type = build_pointer_type (TREE_TYPE (expr)); |
| |
| if (TREE_TYPE (TREE_OPERAND (expr, 1)) != void_type_node) |
| TREE_OPERAND (expr, 1) = |
| build_fold_addr_expr (TREE_OPERAND (expr, 1)); |
| |
| if (TREE_TYPE (TREE_OPERAND (expr, 2)) != void_type_node) |
| TREE_OPERAND (expr, 2) = |
| build_fold_addr_expr (TREE_OPERAND (expr, 2)); |
| |
| tmp2 = tmp = create_tmp_var (type, "iftmp"); |
| |
| expr = build (COND_EXPR, void_type_node, TREE_OPERAND (expr, 0), |
| TREE_OPERAND (expr, 1), TREE_OPERAND (expr, 2)); |
| |
| result = build_fold_indirect_ref (tmp); |
| ret = GS_ALL_DONE; |
| } |
| |
| /* Build the then clause, 't1 = a;'. But don't build an assignment |
| if this branch is void; in C++ it can be, if it's a throw. */ |
| if (TREE_TYPE (TREE_OPERAND (expr, 1)) != void_type_node) |
| TREE_OPERAND (expr, 1) |
| = build (MODIFY_EXPR, void_type_node, tmp, TREE_OPERAND (expr, 1)); |
| |
| /* Build the else clause, 't1 = b;'. */ |
| if (TREE_TYPE (TREE_OPERAND (expr, 2)) != void_type_node) |
| TREE_OPERAND (expr, 2) |
| = build (MODIFY_EXPR, void_type_node, tmp2, TREE_OPERAND (expr, 2)); |
| |
| TREE_TYPE (expr) = void_type_node; |
| recalculate_side_effects (expr); |
| |
| /* Move the COND_EXPR to the prequeue. */ |
| gimplify_and_add (expr, pre_p); |
| |
| *expr_p = result; |
| return ret; |
| } |
| |
| /* Make sure the condition has BOOLEAN_TYPE. */ |
| TREE_OPERAND (expr, 0) = gimple_boolify (TREE_OPERAND (expr, 0)); |
| |
| /* Break apart && and || conditions. */ |
| if (TREE_CODE (TREE_OPERAND (expr, 0)) == TRUTH_ANDIF_EXPR |
| || TREE_CODE (TREE_OPERAND (expr, 0)) == TRUTH_ORIF_EXPR) |
| { |
| expr = shortcut_cond_expr (expr); |
| |
| if (expr != *expr_p) |
| { |
| *expr_p = expr; |
| |
| /* We can't rely on gimplify_expr to re-gimplify the expanded |
| form properly, as cleanups might cause the target labels to be |
| wrapped in a TRY_FINALLY_EXPR. To prevent that, we need to |
| set up a conditional context. */ |
| gimple_push_condition (); |
| gimplify_stmt (expr_p); |
| gimple_pop_condition (pre_p); |
| |
| return GS_ALL_DONE; |
| } |
| } |
| |
| /* Now do the normal gimplification. */ |
| ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, NULL, |
| is_gimple_condexpr, fb_rvalue); |
| |
| gimple_push_condition (); |
| |
| gimplify_to_stmt_list (&TREE_OPERAND (expr, 1)); |
| gimplify_to_stmt_list (&TREE_OPERAND (expr, 2)); |
| recalculate_side_effects (expr); |
| |
| gimple_pop_condition (pre_p); |
| |
| if (ret == GS_ERROR) |
| ; |
| else if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))) |
| ret = GS_ALL_DONE; |
| else if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 2))) |
| /* Rewrite "if (a); else b" to "if (!a) b" */ |
| { |
| TREE_OPERAND (expr, 0) = invert_truthvalue (TREE_OPERAND (expr, 0)); |
| ret = gimplify_expr (&TREE_OPERAND (expr, 0), pre_p, NULL, |
| is_gimple_condexpr, fb_rvalue); |
| |
| tmp = TREE_OPERAND (expr, 1); |
| TREE_OPERAND (expr, 1) = TREE_OPERAND (expr, 2); |
| TREE_OPERAND (expr, 2) = tmp; |
| } |
| else |
| /* Both arms are empty; replace the COND_EXPR with its predicate. */ |
| expr = TREE_OPERAND (expr, 0); |
| |
| *expr_p = expr; |
| return ret; |
| } |
| |
| /* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with |
| a call to __builtin_memcpy. */ |
| |
| static enum gimplify_status |
| gimplify_modify_expr_to_memcpy (tree *expr_p, tree size, bool want_value) |
| { |
| tree args, t, to, to_ptr, from; |
| |
| to = TREE_OPERAND (*expr_p, 0); |
| from = TREE_OPERAND (*expr_p, 1); |
| |
| args = tree_cons (NULL, size, NULL); |
| |
| t = build_fold_addr_expr (from); |
| args = tree_cons (NULL, t, args); |
| |
| to_ptr = build_fold_addr_expr (to); |
| args = tree_cons (NULL, to_ptr, args); |
| t = implicit_built_in_decls[BUILT_IN_MEMCPY]; |
| t = build_function_call_expr (t, args); |
| |
| if (want_value) |
| { |
| t = build1 (NOP_EXPR, TREE_TYPE (to_ptr), t); |
| t = build1 (INDIRECT_REF, TREE_TYPE (to), t); |
| } |
| |
| *expr_p = t; |
| return GS_OK; |
| } |
| |
| /* A subroutine of gimplify_modify_expr. Replace a MODIFY_EXPR with |
| a call to __builtin_memset. In this case we know that the RHS is |
| a CONSTRUCTOR with an empty element list. */ |
| |
| static enum gimplify_status |
| gimplify_modify_expr_to_memset (tree *expr_p, tree size, bool want_value) |
| { |
| tree args, t, to, to_ptr; |
| |
| to = TREE_OPERAND (*expr_p, 0); |
| |
| args = tree_cons (NULL, size, NULL); |
| |
| args = tree_cons (NULL, integer_zero_node, args); |
| |
| to_ptr = build_fold_addr_expr (to); |
| args = tree_cons (NULL, to_ptr, args); |
| t = implicit_built_in_decls[BUILT_IN_MEMSET]; |
| t = build_function_call_expr (t, args); |
| |
| if (want_value) |
| { |
| t = build1 (NOP_EXPR, TREE_TYPE (to_ptr), t); |
| t = build1 (INDIRECT_REF, TREE_TYPE (to), t); |
| } |
| |
| *expr_p = t; |
| return GS_OK; |
| } |
| |
| /* A subroutine of gimplify_init_ctor_preeval. Called via walk_tree, |
| determine, cautiously, if a CONSTRUCTOR overlaps the lhs of an |
| assignment. Returns non-null if we detect a potential overlap. */ |
| |
| struct gimplify_init_ctor_preeval_data |
| { |
| /* The base decl of the lhs object. May be NULL, in which case we |
| have to assume the lhs is indirect. */ |
| tree lhs_base_decl; |
| |
| /* The alias set of the lhs object. */ |
| int lhs_alias_set; |
| }; |
| |
| static tree |
| gimplify_init_ctor_preeval_1 (tree *tp, int *walk_subtrees, void *xdata) |
| { |
| struct gimplify_init_ctor_preeval_data *data |
| = (struct gimplify_init_ctor_preeval_data *) xdata; |
| tree t = *tp; |
| |
| /* If we find the base object, obviously we have overlap. */ |
| if (data->lhs_base_decl == t) |
| return t; |
| |
| /* If the constructor component is indirect, determine if we have a |
| potential overlap with the lhs. The only bits of information we |
| have to go on at this point are addressability and alias sets. */ |
| if (TREE_CODE (t) == INDIRECT_REF |
| && (!data->lhs_base_decl || TREE_ADDRESSABLE (data->lhs_base_decl)) |
| && alias_sets_conflict_p (data->lhs_alias_set, get_alias_set (t))) |
| return t; |
| |
| if (IS_TYPE_OR_DECL_P (t)) |
| *walk_subtrees = 0; |
| return NULL; |
| } |
| |
| /* A subroutine of gimplify_init_constructor. Pre-evaluate *EXPR_P, |
| force values that overlap with the lhs (as described by *DATA) |
| into temporaries. */ |
| |
| static void |
| gimplify_init_ctor_preeval (tree *expr_p, tree *pre_p, tree *post_p, |
| struct gimplify_init_ctor_preeval_data *data) |
| { |
| enum gimplify_status one; |
| |
| /* If the value is invariant, then there's nothing to pre-evaluate. |
| But ensure it doesn't have any side-effects since a SAVE_EXPR is |
| invariant but has side effects and might contain a reference to |
| the object we're initializing. */ |
| if (TREE_INVARIANT (*expr_p) && !TREE_SIDE_EFFECTS (*expr_p)) |
| return; |
| |
| /* If the type has non-trivial constructors, we can't pre-evaluate. */ |
| if (TREE_ADDRESSABLE (TREE_TYPE (*expr_p))) |
| return; |
| |
| /* Recurse for nested constructors. */ |
| if (TREE_CODE (*expr_p) == CONSTRUCTOR) |
| { |
| tree list; |
| for (list = CONSTRUCTOR_ELTS (*expr_p); list ; list = TREE_CHAIN (list)) |
| gimplify_init_ctor_preeval (&TREE_VALUE (list), pre_p, post_p, data); |
| return; |
| } |
| |
| /* We can't preevaluate if the type contains a placeholder. */ |
| if (type_contains_placeholder_p (TREE_TYPE (*expr_p))) |
| return; |
| |
| /* Gimplify the constructor element to something appropriate for the rhs |
| of a MODIFY_EXPR. Given that we know the lhs is an aggregate, we know |
| the gimplifier will consider this a store to memory. Doing this |
| gimplification now means that we won't have to deal with complicated |
| language-specific trees, nor trees like SAVE_EXPR that can induce |
| exponential search behavior. */ |
| one = gimplify_expr (expr_p, pre_p, post_p, is_gimple_mem_rhs, fb_rvalue); |
| if (one == GS_ERROR) |
| { |
| *expr_p = NULL; |
| return; |
| } |
| |
| /* If we gimplified to a bare decl, we can be sure that it doesn't overlap |
| with the lhs, since "a = { .x=a }" doesn't make sense. This will |
| always be true for all scalars, since is_gimple_mem_rhs insists on a |
| temporary variable for them. */ |
| if (DECL_P (*expr_p)) |
| return; |
| |
| /* If this is of variable size, we have no choice but to assume it doesn't |
| overlap since we can't make a temporary for it. */ |
| if (!TREE_CONSTANT (TYPE_SIZE (TREE_TYPE (*expr_p)))) |
| return; |
| |
| /* Otherwise, we must search for overlap ... */ |
| if (!walk_tree (expr_p, gimplify_init_ctor_preeval_1, data, NULL)) |
| return; |
| |
| /* ... and if found, force the value into a temporary. */ |
| *expr_p = get_formal_tmp_var (*expr_p, pre_p); |
| } |
| |
| /* A subroutine of gimplify_init_ctor_eval. Create a loop for |
| a RANGE_EXPR in a CONSTRUCTOR for an array. |
| |
| var = lower; |
| loop_entry: |
| object[var] = value; |
| if (var == upper) |
| goto loop_exit; |
| var = var + 1; |
| goto loop_entry; |
| loop_exit: |
| |
| We increment var _after_ the loop exit check because we might otherwise |
| fail if upper == TYPE_MAX_VALUE (type for upper). |
| |
| Note that we never have to deal with SAVE_EXPRs here, because this has |
| already been taken care of for us, in gimplify_init_ctor_preeval(). */ |
| |
| static void gimplify_init_ctor_eval (tree, tree, tree *, bool); |
| |
| static void |
| gimplify_init_ctor_eval_range (tree object, tree lower, tree upper, |
| tree value, tree array_elt_type, |
| tree *pre_p, bool cleared) |
| { |
| tree loop_entry_label, loop_exit_label; |
| tree var, var_type, cref; |
| |
| loop_entry_label = create_artificial_label (); |
| loop_exit_label = create_artificial_label (); |
| |
| /* Create and initialize the index variable. */ |
| var_type = TREE_TYPE (upper); |
| var = create_tmp_var (var_type, NULL); |
| append_to_statement_list (build2 (MODIFY_EXPR, var_type, var, lower), pre_p); |
| |
| /* Add the loop entry label. */ |
| append_to_statement_list (build1 (LABEL_EXPR, |
| void_type_node, |
| loop_entry_label), |
| pre_p); |
| |
| /* Build the reference. */ |
| cref = build4 (ARRAY_REF, array_elt_type, unshare_expr (object), |
| var, NULL_TREE, NULL_TREE); |
| |
| /* If we are a constructor, just call gimplify_init_ctor_eval to do |
| the store. Otherwise just assign value to the reference. */ |
| |
| if (TREE_CODE (value) == CONSTRUCTOR) |
| /* NB we might have to call ourself recursively through |
| gimplify_init_ctor_eval if the value is a constructor. */ |
| gimplify_init_ctor_eval (cref, CONSTRUCTOR_ELTS (value), |
| pre_p, cleared); |
| else |
| append_to_statement_list (build2 (MODIFY_EXPR, TREE_TYPE (cref), |
| cref, value), |
| pre_p); |
| |
| /* We exit the loop when the index var is equal to the upper bound. */ |
| gimplify_and_add (build3 (COND_EXPR, void_type_node, |
| build2 (EQ_EXPR, boolean_type_node, |
| var, upper), |
| build1 (GOTO_EXPR, |
| void_type_node, |
| loop_exit_label), |
| NULL_TREE), |
| pre_p); |
| |
| /* Otherwise, increment the index var... */ |
| append_to_statement_list (build2 (MODIFY_EXPR, var_type, var, |
| build2 (PLUS_EXPR, var_type, var, |
| fold_convert (var_type, |
| integer_one_node))), |
| pre_p); |
| |
| /* ...and jump back to the loop entry. */ |
| append_to_statement_list (build1 (GOTO_EXPR, |
| void_type_node, |
| loop_entry_label), |
| pre_p); |
| |
| /* Add the loop exit label. */ |
| append_to_statement_list (build1 (LABEL_EXPR, |
| void_type_node, |
| loop_exit_label), |
| pre_p); |
| } |
| |
| /* A subroutine of gimplify_init_constructor. Generate individual |
| MODIFY_EXPRs for a CONSTRUCTOR. OBJECT is the LHS against which the |
| assignments should happen. LIST is the CONSTRUCTOR_ELTS of the |
| CONSTRUCTOR. CLEARED is true if the entire LHS object has been |
| zeroed first. */ |
| |
| static void |
| gimplify_init_ctor_eval (tree object, tree list, tree *pre_p, bool cleared) |
| { |
| tree array_elt_type = NULL; |
| |
| if (TREE_CODE (TREE_TYPE (object)) == ARRAY_TYPE) |
| array_elt_type = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (object))); |
| |
| for (; list; list = TREE_CHAIN (list)) |
| { |
| tree purpose, value, cref, init; |
| |
| purpose = TREE_PURPOSE (list); |
| value = TREE_VALUE (list); |
| |
| /* NULL values are created above for gimplification errors. */ |
| if (value == NULL) |
| continue; |
| |
| if (cleared && initializer_zerop (value)) |
| continue; |
| |
| /* ??? Here's to hoping the front end fills in all of the indices, |
| so we don't have to figure out what's missing ourselves. */ |
| gcc_assert (purpose); |
| |
| /* If we have a RANGE_EXPR, we have to build a loop to assign the |
| whole range. */ |
| if (TREE_CODE (purpose) == RANGE_EXPR) |
| { |
| tree lower = TREE_OPERAND (purpose, 0); |
| tree upper = TREE_OPERAND (purpose, 1); |
| |
| /* If the lower bound is equal to upper, just treat it as if |
| upper was the index. */ |
| if (simple_cst_equal (lower, upper)) |
| purpose = upper; |
| else |
| { |
| gimplify_init_ctor_eval_range (object, lower, upper, value, |
| array_elt_type, pre_p, cleared); |
| continue; |
| } |
| } |
| |
| if (array_elt_type) |
| { |
| cref = build (ARRAY_REF, array_elt_type, unshare_expr (object), |
| purpose, NULL_TREE, NULL_TREE); |
| } |
| else |
| cref = build (COMPONENT_REF, TREE_TYPE (purpose), |
| unshare_expr (object), purpose, NULL_TREE); |
| |
| /* APPLE LOCAL begin mainline 5119788 */ |
| if (TREE_CODE (value) == CONSTRUCTOR |
| && TREE_CODE (TREE_TYPE (value)) != VECTOR_TYPE) |
| /* APPLE LOCAL end mainline 5119788 */ |
| gimplify_init_ctor_eval (cref, CONSTRUCTOR_ELTS (value), |
| pre_p, cleared); |
| else |
| { |
| init = build (MODIFY_EXPR, TREE_TYPE (cref), cref, value); |
| gimplify_and_add (init, pre_p); |
| } |
| } |
| } |
| |
| /* A subroutine of gimplify_modify_expr. Break out elements of a |
| CONSTRUCTOR used as an initializer into separate MODIFY_EXPRs. |
| |
| Note that we still need to clear any elements that don't have explicit |
| initializers, so if not all elements are initialized we keep the |
| original MODIFY_EXPR, we just remove all of the constructor elements. */ |
| |
| static enum gimplify_status |
| gimplify_init_constructor (tree *expr_p, tree *pre_p, |
| tree *post_p, bool want_value) |
| { |
| tree object; |
| tree ctor = TREE_OPERAND (*expr_p, 1); |
| tree type = TREE_TYPE (ctor); |
| enum gimplify_status ret; |
| tree elt_list; |
| |
| if (TREE_CODE (ctor) != CONSTRUCTOR) |
| return GS_UNHANDLED; |
| |
| ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p, |
| is_gimple_lvalue, fb_lvalue); |
| if (ret == GS_ERROR) |
| return ret; |
| object = TREE_OPERAND (*expr_p, 0); |
| |
| elt_list = CONSTRUCTOR_ELTS (ctor); |
| |
| ret = GS_ALL_DONE; |
| switch (TREE_CODE (type)) |
| { |
| case RECORD_TYPE: |
| case UNION_TYPE: |
| case QUAL_UNION_TYPE: |
| case ARRAY_TYPE: |
| { |
| struct gimplify_init_ctor_preeval_data preeval_data; |
| HOST_WIDE_INT num_type_elements, num_ctor_elements; |
| HOST_WIDE_INT num_nonzero_elements, num_nonconstant_elements; |
| bool cleared; |
| |
| /* Aggregate types must lower constructors to initialization of |
| individual elements. The exception is that a CONSTRUCTOR node |
| with no elements indicates zero-initialization of the whole. */ |
| if (elt_list == NULL) |
| break; |
| |
| categorize_ctor_elements (ctor, &num_nonzero_elements, |
| &num_nonconstant_elements, |
| &num_ctor_elements, &cleared); |
| |
| /* If a const aggregate variable is being initialized, then it |
| should never be a lose to promote the variable to be static. */ |
| if (num_nonconstant_elements == 0 |
| && num_nonzero_elements > 1 |
| && TREE_READONLY (object) |
| /* APPLE LOCAL begin CW asm blocks */ |
| && TREE_CODE (object) == VAR_DECL |
| && !DECL_IASM_DONT_PROMOTE_TO_STATIC (object)) |
| /* APPLE LOCAL end CW asm blocks */ |
| { |
| DECL_INITIAL (object) = ctor; |
| TREE_STATIC (object) = 1; |
| if (!DECL_NAME (object)) |
| DECL_NAME (object) = create_tmp_var_name ("C"); |
| walk_tree (&DECL_INITIAL (object), force_labels_r, NULL, NULL); |
| |
| /* ??? C++ doesn't automatically append a .<number> to the |
| assembler name, and even when it does, it looks a FE private |
| data structures to figure out what that number should be, |
| which are not set for this variable. I suppose this is |
| important for local statics for inline functions, which aren't |
| "local" in the object file sense. So in order to get a unique |
| TU-local symbol, we must invoke the lhd version now. */ |
| lhd_set_decl_assembler_name (object); |
| |
| *expr_p = NULL_TREE; |
| break; |
| } |
| |
| /* If there are "lots" of initialized elements, and all of them |
| are valid address constants, then the entire initializer can |
| be dropped to memory, and then memcpy'd out. */ |
| if (num_nonconstant_elements == 0) |
| { |
| HOST_WIDE_INT size = int_size_in_bytes (type); |
| unsigned int align; |
| |
| /* ??? We can still get unbounded array types, at least |
| from the C++ front end. This seems wrong, but attempt |
| to work around it for now. */ |
| if (size < 0) |
| { |
| size = int_size_in_bytes (TREE_TYPE (object)); |
| if (size >= 0) |
| TREE_TYPE (ctor) = type = TREE_TYPE (object); |
| } |
| |
| /* Find the maximum alignment we can assume for the object. */ |
| /* ??? Make use of DECL_OFFSET_ALIGN. */ |
| if (DECL_P (object)) |
| align = DECL_ALIGN (object); |
| else |
| align = TYPE_ALIGN (type); |
| |
| if (size > 0 && !can_move_by_pieces (size, align)) |
| { |
| tree new = create_tmp_var_raw (type, "C"); |
| |
| gimple_add_tmp_var (new); |
| TREE_STATIC (new) = 1; |
| TREE_READONLY (new) = 1; |
| DECL_INITIAL (new) = ctor; |
| if (align > DECL_ALIGN (new)) |
| { |
| DECL_ALIGN (new) = align; |
| DECL_USER_ALIGN (new) = 1; |
| } |
| walk_tree (&DECL_INITIAL (new), force_labels_r, NULL, NULL); |
| |
| TREE_OPERAND (*expr_p, 1) = new; |
| |
| /* This is no longer an assignment of a CONSTRUCTOR, but |
| we still may have processing to do on the LHS. So |
| pretend we didn't do anything here to let that happen. */ |
| return GS_UNHANDLED; |
| } |
| } |
| |
| /* If there are "lots" of initialized elements, even discounting |
| those that are not address constants (and thus *must* be |
| computed at runtime), then partition the constructor into |
| constant and non-constant parts. Block copy the constant |
| parts in, then generate code for the non-constant parts. */ |
| /* TODO. There's code in cp/typeck.c to do this. */ |
| |
| num_type_elements = count_type_elements (type); |
| |
| /* If count_type_elements could not determine number of type elements |
| for a constant-sized object, assume clearing is needed. |
| Don't do this for variable-sized objects, as store_constructor |
| will ignore the clearing of variable-sized objects. */ |
| if (num_type_elements < 0 && int_size_in_bytes (type) >= 0) |
| cleared = true; |
| /* If there are "lots" of zeros, then block clear the object first. */ |
| else if (num_type_elements - num_nonzero_elements > CLEAR_RATIO |
| && num_nonzero_elements < num_type_elements/4) |
| cleared = true; |
| /* ??? This bit ought not be needed. For any element not present |
| in the initializer, we should simply set them to zero. Except |
| we'd need to *find* the elements that are not present, and that |
| requires trickery to avoid quadratic compile-time behavior in |
| large cases or excessive memory use in small cases. */ |
| else if (num_ctor_elements < num_type_elements) |
| cleared = true; |
| |
| if (cleared) |
| { |
| /* Zap the CONSTRUCTOR element list, which simplifies this case. |
| Note that we still have to gimplify, in order to handle the |
| case of variable sized types. Avoid shared tree structures. */ |
| CONSTRUCTOR_ELTS (ctor) = NULL_TREE; |
| object = unshare_expr (object); |
| gimplify_stmt (expr_p); |
| append_to_statement_list (*expr_p, pre_p); |
| } |
| |
| /* If we have not block cleared the object, or if there are nonzero |
| elements in the constructor, add assignments to the individual |
| scalar fields of the object. */ |
| if (!cleared || num_nonzero_elements > 0) |
| { |
| preeval_data.lhs_base_decl = get_base_address (object); |
| if (!DECL_P (preeval_data.lhs_base_decl)) |
| preeval_data.lhs_base_decl = NULL; |
| preeval_data.lhs_alias_set = get_alias_set (object); |
| |
| gimplify_init_ctor_preeval (&TREE_OPERAND (*expr_p, 1), |
| pre_p, post_p, &preeval_data); |
| gimplify_init_ctor_eval (object, elt_list, pre_p, cleared); |
| } |
| |
| *expr_p = NULL_TREE; |
| } |
| break; |
| |
| case COMPLEX_TYPE: |
| { |
| tree r, i; |
| |
| /* Extract the real and imaginary parts out of the ctor. */ |
| r = i = NULL_TREE; |
| if (elt_list) |
| { |
| r = TREE_VALUE (elt_list); |
| elt_list = TREE_CHAIN (elt_list); |
| if (elt_list) |
| { |
| i = TREE_VALUE (elt_list); |
| gcc_assert (!TREE_CHAIN (elt_list)); |
| } |
| } |
| if (r == NULL || i == NULL) |
| { |
| tree zero = convert (TREE_TYPE (type), integer_zero_node); |
| if (r == NULL) |
| r = zero; |
| if (i == NULL) |
| i = zero; |
| } |
| |
| /* Complex types have either COMPLEX_CST or COMPLEX_EXPR to |
| represent creation of a complex value. */ |
| if (TREE_CONSTANT (r) && TREE_CONSTANT (i)) |
| { |
| ctor = build_complex (type, r, i); |
| TREE_OPERAND (*expr_p, 1) = ctor; |
| } |
| else |
| { |
| ctor = build (COMPLEX_EXPR, type, r, i); |
| TREE_OPERAND (*expr_p, 1) = ctor; |
| ret = gimplify_expr (&TREE_OPERAND (*expr_p, 1), pre_p, post_p, |
| rhs_predicate_for (TREE_OPERAND (*expr_p, 0)), |
| fb_rvalue); |
| } |
| } |
| break; |
| |
| case VECTOR_TYPE: |
| /* Go ahead and simplify constant constructors to VECTOR_CST. */ |
| if (TREE_CONSTANT (ctor)) |
| { |
| tree tem; |
| |
| /* Even when ctor is constant, it might contain non-*_CST |
| elements (e.g. { 1.0/0.0 - 1.0/0.0, 0.0 }) and those don't |
| belong into VECTOR_CST nodes. */ |
| for (tem = elt_list; tem; tem = TREE_CHAIN (tem)) |
| if (! CONSTANT_CLASS_P (TREE_VALUE (tem))) |
| break; |
| |
| if (! tem) |
| { |
| TREE_OPERAND (*expr_p, 1) = build_vector (type, elt_list); |
| break; |
| } |
| } |
| |
| /* Vector types use CONSTRUCTOR all the way through gimple |
| compilation as a general initializer. */ |
| for (; elt_list; elt_list = TREE_CHAIN (elt_list)) |
| { |
| enum gimplify_status tret; |
| tret = gimplify_expr (&TREE_VALUE (elt_list), pre_p, post_p, |
| is_gimple_val, fb_rvalue); |
| if (tret == GS_ERROR) |
| ret = GS_ERROR; |
| } |
| break; |
| |
| default: |
| /* So how did we get a CONSTRUCTOR for a scalar type? */ |
| gcc_unreachable (); |
| } |
| |
| if (ret == GS_ERROR) |
| return GS_ERROR; |
| else if (want_value) |
| { |
| append_to_statement_list (*expr_p, pre_p); |
| *expr_p = object; |
| return GS_OK; |
| } |
| else |
| return GS_ALL_DONE; |
| } |
| |
| /* Subroutine of gimplify_modify_expr to do simplifications of MODIFY_EXPRs |
| based on the code of the RHS. We loop for as long as something changes. */ |
| |
| static enum gimplify_status |
| gimplify_modify_expr_rhs (tree *expr_p, tree *from_p, tree *to_p, tree *pre_p, |
| tree *post_p, bool want_value) |
| { |
| enum gimplify_status ret = GS_OK; |
| |
| while (ret != GS_UNHANDLED) |
| switch (TREE_CODE (*from_p)) |
| { |
| case INDIRECT_REF: |
| { |
| /* If we have code like |
| |
| *(const A*)(A*)&x |
| |
| where the type of "x" is a (possibly cv-qualified variant |
| of "A"), treat the entire expression as identical to "x". |
| This kind of code arises in C++ when an object is bound |
| to a const reference, and if "x" is a TARGET_EXPR we want |
| to take advantage of the optimization below. */ |
| tree t = fold_indirect_ref (*from_p); |
| if (t != *from_p) |
| { |
| *from_p = t; |
| ret = GS_OK; |
| } |
| else |
| ret = GS_UNHANDLED; |
| break; |
| } |
| |
| case TARGET_EXPR: |
| { |
| /* If we are initializing something from a TARGET_EXPR, strip the |
| TARGET_EXPR and initialize it directly, if possible. This can't |
| be done if the initializer is void, since that implies that the |
| temporary is set in some non-trivial way. |
| |
| ??? What about code that pulls out the temp and uses it |
| elsewhere? I think that such code never uses the TARGET_EXPR as |
| an initializer. If I'm wrong, we'll abort because the temp won't |
| have any RTL. In that case, I guess we'll need to replace |
| references somehow. */ |
| tree init = TARGET_EXPR_INITIAL (*from_p); |
| |
| if (!VOID_TYPE_P (TREE_TYPE (init))) |
| { |
| *from_p = init; |
| ret = GS_OK; |
| } |
| else |
| ret = GS_UNHANDLED; |
| } |
| break; |
| |
| case COMPOUND_EXPR: |
| /* Remove any COMPOUND_EXPR in the RHS so the following cases will be |
| caught. */ |
| gimplify_compound_expr (from_p, pre_p, true); |
| ret = GS_OK; |
| break; |
| |
| case CONSTRUCTOR: |
| /* If we're initializing from a CONSTRUCTOR, break this into |
| individual MODIFY_EXPRs. */ |
| return gimplify_init_constructor (expr_p, pre_p, post_p, want_value); |
| |
| case COND_EXPR: |
| /* If we're assigning to a non-register type, push the assignment |
| down into the branches. This is mandatory for ADDRESSABLE types, |
| since we cannot generate temporaries for such, but it saves a |
| copy in other cases as well. */ |
| if (!is_gimple_reg_type (TREE_TYPE (*from_p))) |
| { |
| *expr_p = *from_p; |
| return gimplify_cond_expr (expr_p, pre_p, post_p, *to_p, |
| fb_rvalue); |
| } |
| else |
| ret = GS_UNHANDLED; |
| break; |
| |
| default: |
| ret = GS_UNHANDLED; |
| break; |
| } |
| |
| return ret; |
| } |
| |
| /* Gimplify the MODIFY_EXPR node pointed by EXPR_P. |
| |
| modify_expr |
| : varname '=' rhs |
| | '*' ID '=' rhs |
| |
| PRE_P points to the list where side effects that must happen before |
| *EXPR_P should be stored. |
| |
| POST_P points to the list where side effects that must happen after |
| *EXPR_P should be stored. |
| |
| WANT_VALUE is nonzero iff we want to use the value of this expression |
| in another expression. */ |
| |
| static enum gimplify_status |
| gimplify_modify_expr (tree *expr_p, tree *pre_p, tree *post_p, bool want_value) |
| { |
| tree *from_p = &TREE_OPERAND (*expr_p, 1); |
| tree *to_p = &TREE_OPERAND (*expr_p, 0); |
| enum gimplify_status ret = GS_UNHANDLED; |
| |
| gcc_assert (TREE_CODE (*expr_p) == MODIFY_EXPR |
| || TREE_CODE (*expr_p) == INIT_EXPR); |
| |
| /* The distinction between MODIFY_EXPR and INIT_EXPR is no longer useful. */ |
| if (TREE_CODE (*expr_p) == INIT_EXPR) |
| TREE_SET_CODE (*expr_p, MODIFY_EXPR); |
| |
| /* See if any simplifications can be done based on what the RHS is. */ |
| ret = gimplify_modify_expr_rhs (expr_p, from_p, to_p, pre_p, post_p, |
| want_value); |
| if (ret != GS_UNHANDLED) |
| return ret; |
| |
| /* If the value being copied is of variable width, compute the length |
| of the copy into a WITH_SIZE_EXPR. Note that we need to do this |
| before gimplifying any of the operands so that we can resolve any |
| PLACEHOLDER_EXPRs in the size. Also note that the RTL expander uses |
| the size of the expression to be copied, not of the destination, so |
| that is what we must here. */ |
| maybe_with_size_expr (from_p); |
| |
| /* APPLE LOCAL begin 4228828 */ |
| /* For stores to a pointer, keep computation of the address close to the |
| pointer. Later optimizations should do this; the 'sink' pass in 4.2 |
| does it, but that's not in 4.0. Temporary. */ |
| if (TREE_CODE (*to_p) != INDIRECT_REF) |
| { |
| ret = gimplify_expr (to_p, pre_p, post_p, is_gimple_lvalue, fb_lvalue); |
| if (ret == GS_ERROR) |
| return ret; |
| } |
| /* APPLE LOCAL end 4228828 */ |
| |
| ret = gimplify_expr (from_p, pre_p, post_p, |
| rhs_predicate_for (*to_p), fb_rvalue); |
| if (ret == GS_ERROR) |
| return ret; |
| |
| /* Now see if the above changed *from_p to something we handle specially. */ |
| ret = gimplify_modify_expr_rhs (expr_p, from_p, to_p, pre_p, post_p, |
| want_value); |
| if (ret != GS_UNHANDLED) |
| return ret; |
| |
| /* APPLE LOCAL begin 4228828 */ |
| if (TREE_CODE (*to_p) == INDIRECT_REF) |
| { |
| ret = gimplify_expr (to_p, pre_p, post_p, is_gimple_lvalue, fb_lvalue); |
| if (ret == GS_ERROR) |
| return ret; |
| } |
| /* APPLE LOCAL end 4228828 */ |
| |
| /* If we've got a variable sized assignment between two lvalues (i.e. does |
| not involve a call), then we can make things a bit more straightforward |
| by converting the assignment to memcpy or memset. */ |
| if (TREE_CODE (*from_p) == WITH_SIZE_EXPR) |
| { |
| tree from = TREE_OPERAND (*from_p, 0); |
| tree size = TREE_OPERAND (*from_p, 1); |
| |
| if (TREE_CODE (from) == CONSTRUCTOR) |
| return gimplify_modify_expr_to_memset (expr_p, size, want_value); |
| if (is_gimple_addressable (from)) |
| { |
| *from_p = from; |
| return gimplify_modify_expr_to_memcpy (expr_p, size, want_value); |
| } |
| } |
| |
| if (gimplify_ctxp->into_ssa && is_gimple_reg (*to_p)) |
| { |
| /* If we've somehow already got an SSA_NAME on the LHS, then |
| we're probably modifying it twice. Not good. */ |
| gcc_assert (TREE_CODE (*to_p) != SSA_NAME); |
| *to_p = make_ssa_name (*to_p, *expr_p); |
| } |
| |
| if (want_value) |
| { |
| append_to_statement_list (*expr_p, pre_p); |
| *expr_p = *to_p; |
| return GS_OK; |
| } |
| |
| return GS_ALL_DONE; |
| } |
| |
| /* Gimplify a comparison between two variable-sized objects. Do this |
| with a call to BUILT_IN_MEMCMP. */ |
| |
| static enum gimplify_status |
| gimplify_variable_sized_compare (tree *expr_p) |
| { |
| tree op0 = TREE_OPERAND (*expr_p, 0); |
| tree op1 = TREE_OPERAND (*expr_p, 1); |
| tree args, t, dest; |
| |
| t = TYPE_SIZE_UNIT (TREE_TYPE (op0)); |
| t = unshare_expr (t); |
| t = SUBSTITUTE_PLACEHOLDER_IN_EXPR (t, op0); |
| args = tree_cons (NULL, t, NULL); |
| t = build_fold_addr_expr (op1); |
| args = tree_cons (NULL, t, args); |
| dest = build_fold_addr_expr (op0); |
| args = tree_cons (NULL, dest, args); |
| t = implicit_built_in_decls[BUILT_IN_MEMCMP]; |
| t = build_function_call_expr (t, args); |
| *expr_p |
| = build (TREE_CODE (*expr_p), TREE_TYPE (*expr_p), t, integer_zero_node); |
| |
| return GS_OK; |
| } |
| |
| /* Gimplify TRUTH_ANDIF_EXPR and TRUTH_ORIF_EXPR expressions. EXPR_P |
| points to the expression to gimplify. |
| |
| Expressions of the form 'a && b' are gimplified to: |
| |
| a && b ? true : false |
| |
| gimplify_cond_expr will do the rest. |
| |
| PRE_P points to the list where side effects that must happen before |
| *EXPR_P should be stored. */ |
| |
| static enum gimplify_status |
| gimplify_boolean_expr (tree *expr_p) |
| { |
| /* Preserve the original type of the expression. */ |
| tree type = TREE_TYPE (*expr_p); |
| |
| *expr_p = build (COND_EXPR, type, *expr_p, |
| convert (type, boolean_true_node), |
| convert (type, boolean_false_node)); |
| |
| return GS_OK; |
| } |
| |
| /* Gimplifies an expression sequence. This function gimplifies each |
| expression and re-writes the original expression with the last |
| expression of the sequence in GIMPLE form. |
| |
| PRE_P points to the list where the side effects for all the |
| expressions in the sequence will be emitted. |
| |
| WANT_VALUE is true when the result of the last COMPOUND_EXPR is used. */ |
| /* ??? Should rearrange to share the pre-queue with all the indirect |
| invocations of gimplify_expr. Would probably save on creations |
| of statement_list nodes. */ |
| |
| static enum gimplify_status |
| gimplify_compound_expr (tree *expr_p, tree *pre_p, bool want_value) |
| { |
| tree t = *expr_p; |
| |
| do |
| { |
| tree *sub_p = &TREE_OPERAND (t, 0); |
| |
| if (TREE_CODE (*sub_p) == COMPOUND_EXPR) |
| gimplify_compound_expr (sub_p, pre_p, false); |
| else |
| gimplify_stmt (sub_p); |
| append_to_statement_list (*sub_p, pre_p); |
| |
| t = TREE_OPERAND (t, 1); |
| } |
| while (TREE_CODE (t) == COMPOUND_EXPR); |
| |
| *expr_p = t; |
| if (want_value) |
| return GS_OK; |
| else |
| { |
| gimplify_stmt (expr_p); |
| return GS_ALL_DONE; |
| } |
| } |
| |
| /* Gimplifies a statement list. These may be created either by an |
| enlightened front-end, or by shortcut_cond_expr. */ |
| |
| static enum gimplify_status |
| gimplify_statement_list (tree *expr_p) |
| { |
| tree_stmt_iterator i = tsi_start (*expr_p); |
| |
| while (!tsi_end_p (i)) |
| { |
| tree t; |
| |
| gimplify_stmt (tsi_stmt_ptr (i)); |
| |
| t = tsi_stmt (i); |
| if (t == NULL) |
| tsi_delink (&i); |
| else if (TREE_CODE (t) == STATEMENT_LIST) |
| { |
| tsi_link_before (&i, t, TSI_SAME_STMT); |
| tsi_delink (&i); |
| } |
| else |
| tsi_next (&i); |
| } |
| |
| return GS_ALL_DONE; |
| } |
| |
| /* Gimplify a SAVE_EXPR node. EXPR_P points to the expression to |
| gimplify. After gimplification, EXPR_P will point to a new temporary |
| that holds the original value of the SAVE_EXPR node. |
| |
| PRE_P points to the list where side effects that must happen before |
| *EXPR_P should be stored. */ |
| |
| static enum gimplify_status |
| gimplify_save_expr (tree *expr_p, tree *pre_p, tree *post_p) |
| { |
| enum gimplify_status ret = GS_ALL_DONE; |
| tree val; |
| |
| gcc_assert (TREE_CODE (*expr_p) == SAVE_EXPR); |
| val = TREE_OPERAND (*expr_p, 0); |
| |
| /* If the SAVE_EXPR has not been resolved, then evaluate it once. */ |
| if (!SAVE_EXPR_RESOLVED_P (*expr_p)) |
| { |
| /* The operand may be a void-valued expression such as SAVE_EXPRs |
| generated by the Java frontend for class initialization. It is |
| being executed only for its side-effects. */ |
| if (TREE_TYPE (val) == void_type_node) |
| { |
| ret = gimplify_expr (&TREE_OPERAND (*expr_p, 0), pre_p, post_p, |
| is_gimple_stmt, fb_none); |
| append_to_statement_list (TREE_OPERAND (*expr_p, 0), pre_p); |
| val = NULL; |
| } |
| else |
| val = get_initialized_tmp_var (val, pre_p, post_p); |
| |
| TREE_OPERAND (*expr_p, 0) = val; |
| SAVE_EXPR_RESOLVED_P (*expr_p) = 1; |
| } |
| |
| *expr_p = val; |
| |
| return ret; |
| } |
| |
| /* Re-write the ADDR_EXPR node pointed by EXPR_P |
| |
| unary_expr |
| : ... |
| | '&' varname |
| ... |
| |
| PRE_P points to the list where side effects that must happen before |
| *EXPR_P should be stored. |
| |
| POST_P points to the list where side effects that must happen after |
| *EXPR_P should be stored. */ |
| |
| static enum gimplify_status |
| gimplify_addr_expr (tree *expr_p, tree *pre_p, tree *post_p) |
|