diff options
| -rw-r--r-- | gcc/ChangeLog | 11 | ||||
| -rw-r--r-- | gcc/gimple-low.c | 1 | ||||
| -rw-r--r-- | gcc/tree-dfa.c | 96 | ||||
| -rw-r--r-- | gcc/tree-flow-inline.h | 18 | ||||
| -rw-r--r-- | gcc/tree-flow.h | 13 | ||||
| -rw-r--r-- | gcc/tree-ssa-alias.c | 11 | ||||
| -rw-r--r-- | gcc/tree-ssa-copyrename.c | 10 | ||||
| -rw-r--r-- | gcc/tree-ssa-operands.c | 12 |
8 files changed, 18 insertions, 154 deletions
diff --git a/gcc/ChangeLog b/gcc/ChangeLog index c579dd5..85b7b7f 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,5 +1,16 @@ 2004-07-16 Richard Henderson <rth@redhat.com> + * tree-flow.h (struct var_ann_d): Remove has_hidden_use. + * gimple-low.c (expand_var_p): Don't check it. + * tree-ssa-alias.c (setup_pointers_and_addressables): Likewise. + * tree-ssa-copyrename.c (rename_ssa_copies): Likewise. + * tree-ssa-operands.c (add_stmt_operand): Likewise. + * tree-dfa.c (find_hidden_use_vars, find_hidden_use_vars_r): Kill. + (find_referenced_vars): Don't call them. + * tree-flow-inline.h (has_hidden_use, set_has_hidden_use): Kill. + +2004-07-16 Richard Henderson <rth@redhat.com> + * function.c (pass_by_reference): True for all variable sized types. 2004-07-16 Sebastian Pop <pop@cri.ensmp.fr> diff --git a/gcc/gimple-low.c b/gcc/gimple-low.c index c29f591..b3b6af7 100644 --- a/gcc/gimple-low.c +++ b/gcc/gimple-low.c @@ -482,7 +482,6 @@ expand_var_p (tree var) if (ann && ! ann->may_aliases && ! ann->used - && ! ann->has_hidden_use && ! TREE_ADDRESSABLE (var) && ! TREE_THIS_VOLATILE (var) && (DECL_ARTIFICIAL (var) || optimize >= 2)) diff --git a/gcc/tree-dfa.c b/gcc/tree-dfa.c index 568e951..91d7ecd 100644 --- a/gcc/tree-dfa.c +++ b/gcc/tree-dfa.c @@ -81,8 +81,6 @@ static tree find_vars_r (tree *, int *, void *); static void add_referenced_var (tree, struct walk_state *); static void compute_immediate_uses_for_phi (tree, bool (*)(tree)); static void compute_immediate_uses_for_stmt (tree, int, bool (*)(tree)); -static void find_hidden_use_vars (tree); -static tree find_hidden_use_vars_r (tree *, int *, void *); /* Global declarations. */ @@ -109,21 +107,6 @@ find_referenced_vars (void) basic_block bb; block_stmt_iterator si; struct walk_state walk_state; - tree block; - - /* Walk the lexical blocks in the function looking for variables that may - have been used to declare VLAs and for nested functions. Both - constructs create hidden uses of variables. - - Note that at this point we may have multiple blocks hung off - DECL_INITIAL chained through the BLOCK_CHAIN field due to - how inlining works. Egad. */ - block = DECL_INITIAL (current_function_decl); - while (block) - { - find_hidden_use_vars (block); - block = BLOCK_CHAIN (block); - } vars_found = htab_create (50, htab_hash_pointer, htab_eq_pointer, NULL); memset (&walk_state, 0, sizeof (walk_state)); @@ -570,9 +553,6 @@ dump_variable (FILE *file, tree var) fprintf (file, ", UID %u", (unsigned) ann->uid); - if (ann->has_hidden_use) - fprintf (file, ", has hidden uses"); - if (ann->type_mem_tag) { fprintf (file, ", type memory tag: "); @@ -958,82 +938,6 @@ get_virtual_var (tree var) return var; } - -/* Mark variables in BLOCK that have hidden uses. A hidden use can - occur due to VLA declarations or nested functions. */ - -static void -find_hidden_use_vars (tree block) -{ - tree sub, decl, tem; - - /* Check all the arrays declared in the block for VLAs. - While scanning the block's variables, also see if there is - a nested function at this scope. */ - for (decl = BLOCK_VARS (block); decl; decl = TREE_CHAIN (decl)) - { - int inside_vla = 0; - walk_tree (&decl, find_hidden_use_vars_r, &inside_vla, NULL); - } - - /* Now repeat the search in any sub-blocks. */ - for (sub = BLOCK_SUBBLOCKS (block); sub; sub = TREE_CHAIN (sub)) - find_hidden_use_vars (sub); - - /* A VLA parameter may use a variable which as set from another - parameter to declare the size of the VLA. We need to mark the - variable as having a hidden use since it is used to declare the - VLA parameter and that declaration is not seen by the SSA code. - - Note get_pending_sizes clears the PENDING_SIZES chain, so we - must restore it. */ - tem = get_pending_sizes (); - put_pending_sizes (tem); - for (; tem; tem = TREE_CHAIN (tem)) - { - int inside_vla = 1; - walk_tree (&TREE_VALUE (tem), find_hidden_use_vars_r, &inside_vla, NULL); - } -} - - -/* Callback for walk_tree used by find_hidden_use_vars to analyze each - variable in a lexical block. If the variable's size has a variable - size, then mark all objects needed to compute the variable's size - as having hidden uses. */ - -static tree -find_hidden_use_vars_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, - void *data ATTRIBUTE_UNUSED) -{ - int *inside_vla = (int *) data; - - /* We need to look for hidden uses due to VLAs in variable - definitions. We originally used to look for these hidden - uses in the variable's type, but that's unreliable if the - type's size contains a SAVE_EXPR for a different function - context than the variable is used within. */ - if (SSA_VAR_P (*tp) - && ((DECL_SIZE (*tp) - && ! really_constant_p (DECL_SIZE (*tp))) - || (DECL_SIZE_UNIT (*tp) - && ! really_constant_p (DECL_SIZE_UNIT (*tp))))) - { - int save = *inside_vla; - - *inside_vla = 1; - walk_tree (&DECL_SIZE (*tp), find_hidden_use_vars_r, inside_vla, NULL); - walk_tree (&DECL_SIZE_UNIT (*tp), find_hidden_use_vars_r, - inside_vla, NULL); - *inside_vla = save; - } - else if (*inside_vla && SSA_VAR_P (*tp)) - set_has_hidden_use (*tp); - - return NULL_TREE; -} - - /* Add a temporary variable to REFERENCED_VARS. This is similar to add_referenced_var, but is used by passes that need to add new temps to the REFERENCED_VARS array after the program has been scanned for diff --git a/gcc/tree-flow-inline.h b/gcc/tree-flow-inline.h index b6f81bc..08dc0ef 100644 --- a/gcc/tree-flow-inline.h +++ b/gcc/tree-flow-inline.h @@ -97,24 +97,6 @@ may_aliases (tree var) return ann ? ann->may_aliases : NULL; } -/* Return true if VAR has a hidden use, false if it does not. */ -static inline bool -has_hidden_use (tree var) -{ - var_ann_t ann = var_ann (var); - return ann ? ann->has_hidden_use : false; -} - -/* Set the hidden use flag on VAR. */ -static inline void -set_has_hidden_use (tree var) -{ - var_ann_t ann = var_ann (var); - if (ann == NULL) - ann = create_var_ann (var); - ann->has_hidden_use = 1; -} - /* Return the line number for EXPR, or return -1 if we have no line number information for it. */ static inline int diff --git a/gcc/tree-flow.h b/gcc/tree-flow.h index 5e3edde..5bd9f94 100644 --- a/gcc/tree-flow.h +++ b/gcc/tree-flow.h @@ -138,17 +138,6 @@ struct var_ann_d GTY(()) { struct tree_ann_common_d common; - /* Nonzero if this variable has uses which may not appear - in the IL. This can happen in the following cases: - - 1. If the variable is used in a variable length - array declaration. - - 2. If the variable is the return value in a C++ - function where the named return value optimization - has been performed. */ - unsigned has_hidden_use : 1; - /* Used by the out of SSA pass to determine whether this variable has been seen yet or not. */ unsigned out_of_ssa_tag : 1; @@ -334,8 +323,6 @@ static inline bitmap addresses_taken (tree); static inline int num_immediate_uses (dataflow_t); static inline tree immediate_use (dataflow_t, int); static inline dataflow_t get_immediate_uses (tree); -static inline bool has_hidden_use (tree); -static inline void set_has_hidden_use (tree); static inline void set_default_def (tree, tree); static inline tree default_def (tree); static inline bool may_be_aliased (tree); diff --git a/gcc/tree-ssa-alias.c b/gcc/tree-ssa-alias.c index 9da0167..0d96b16 100644 --- a/gcc/tree-ssa-alias.c +++ b/gcc/tree-ssa-alias.c @@ -1219,12 +1219,10 @@ setup_pointers_and_addressables (struct alias_info *ai) if (POINTER_TYPE_P (TREE_TYPE (var))) { - /* Since we don't keep track of volatile variables nor - variables with hidden uses, assume that these pointers - are used in indirect store operations. */ - var_ann_t ann = var_ann (var); - if (TREE_THIS_VOLATILE (var) || ann->has_hidden_use) - bitmap_set_bit (ai->dereferenced_ptrs_store, ann->uid); + /* Since we don't keep track of volatile variables, assume that + these pointers are used in indirect store operations. */ + if (TREE_THIS_VOLATILE (var)) + bitmap_set_bit (ai->dereferenced_ptrs_store, var_ann (var)->uid); num_pointers++; } @@ -1266,7 +1264,6 @@ setup_pointers_and_addressables (struct alias_info *ai) if (TREE_ADDRESSABLE (var)) { if (!bitmap_bit_p (ai->addresses_needed, v_ann->uid) - && !v_ann->has_hidden_use && v_ann->mem_tag_kind == NOT_A_TAG && !needs_to_live_in_memory (var)) { diff --git a/gcc/tree-ssa-copyrename.c b/gcc/tree-ssa-copyrename.c index a355b2d..c65b828 100644 --- a/gcc/tree-ssa-copyrename.c +++ b/gcc/tree-ssa-copyrename.c @@ -309,9 +309,7 @@ rename_ssa_copies (void) tree lhs = TREE_OPERAND (stmt, 0); tree rhs = TREE_OPERAND (stmt, 1); - if (TREE_CODE (lhs) == SSA_NAME - && !has_hidden_use (SSA_NAME_VAR (lhs)) - && TREE_CODE (rhs) == SSA_NAME) + if (TREE_CODE (lhs) == SSA_NAME && TREE_CODE (rhs) == SSA_NAME) copy_rename_partition_coalesce (map, lhs, rhs, debug); } } @@ -325,10 +323,8 @@ rename_ssa_copies (void) int i; tree res = PHI_RESULT (phi); - /* Do not process virtual SSA_NAMES or variables which have - hidden uses. */ - if (!is_gimple_reg (SSA_NAME_VAR (res)) - || has_hidden_use (SSA_NAME_VAR (res))) + /* Do not process virtual SSA_NAMES. */ + if (!is_gimple_reg (SSA_NAME_VAR (res))) continue; for (i = 0; i < PHI_NUM_ARGS (phi); i++) diff --git a/gcc/tree-ssa-operands.c b/gcc/tree-ssa-operands.c index c032c9e..af21f12 100644 --- a/gcc/tree-ssa-operands.c +++ b/gcc/tree-ssa-operands.c @@ -1298,18 +1298,6 @@ add_stmt_operand (tree *var_p, tree stmt, int flags, voperands_t prev_vops) sym = (TREE_CODE (var) == SSA_NAME ? SSA_NAME_VAR (var) : var); v_ann = var_ann (sym); - /* FIXME: We currently refuse to optimize variables that have hidden uses - (variables used in VLA declarations, MD builtin calls and variables - from the parent function in nested functions). This is because not - all uses of these variables are exposed in the IL or the statements - that reference them are not in GIMPLE form. If that's the case, mark - the statement as having volatile operands and return. */ - if (v_ann->has_hidden_use) - { - s_ann->has_volatile_ops = true; - return; - } - /* Don't expose volatile variables to the optimizers. */ if (TREE_THIS_VOLATILE (sym)) { |