X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Ftree-dfa.c;h=d5a56e5e29918ce84c3b9139042360fc4cf5ece6;hb=4597997f9368ad5db8a2d4c04c1101dd309cd220;hp=f66a50c5a65c253ab3fdd7d94afe01b11de4c1d3;hpb=8ca26bddc3c40df69f7b9446b99e6a3aa9404ed8;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/tree-dfa.c b/gcc/tree-dfa.c index f66a50c5a65..d5a56e5e299 100644 --- a/gcc/tree-dfa.c +++ b/gcc/tree-dfa.c @@ -1,5 +1,6 @@ /* Data flow functions for trees. - Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007 Free Software Foundation, Inc. + Copyright (C) 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009 + Free Software Foundation, Inc. Contributed by Diego Novillo This file is part of GCC. @@ -38,7 +39,7 @@ along with GCC; see the file COPYING3. If not see #include "function.h" #include "diagnostic.h" #include "tree-dump.h" -#include "tree-gimple.h" +#include "gimple.h" #include "tree-flow.h" #include "tree-inline.h" #include "tree-pass.h" @@ -51,13 +52,12 @@ along with GCC; see the file COPYING3. If not see /* Counters used to display DFA and SSA statistics. */ struct dfa_stats_d { - long num_stmt_anns; long num_var_anns; long num_defs; long num_uses; long num_phis; long num_phi_args; - int max_num_phi_args; + size_t max_num_phi_args; long num_vdefs; long num_vuses; }; @@ -65,7 +65,6 @@ struct dfa_stats_d /* Local functions. */ static void collect_dfa_stats (struct dfa_stats_d *); -static tree collect_dfa_stats_r (tree *, int *, void *); static tree find_vars_r (tree *, int *, void *); @@ -84,21 +83,30 @@ static unsigned int find_referenced_vars (void) { basic_block bb; - block_stmt_iterator si; + gimple_stmt_iterator si; FOR_EACH_BB (bb) - for (si = bsi_start (bb); !bsi_end_p (si); bsi_next (&si)) - { - tree *stmt_p = bsi_stmt_ptr (si); - walk_tree (stmt_p, find_vars_r, NULL, NULL); - } + { + for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si)) + { + gimple stmt = gsi_stmt (si); + if (is_gimple_debug (stmt)) + continue; + find_referenced_vars_in (gsi_stmt (si)); + } + + for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si)) + find_referenced_vars_in (gsi_stmt (si)); + } return 0; } -struct tree_opt_pass pass_referenced_vars = +struct gimple_opt_pass pass_referenced_vars = { - NULL, /* name */ + { + GIMPLE_PASS, + "*referenced_vars", /* name */ NULL, /* gate */ find_referenced_vars, /* execute */ NULL, /* sub */ @@ -108,9 +116,9 @@ struct tree_opt_pass pass_referenced_vars = PROP_gimple_leh | PROP_cfg, /* properties_required */ PROP_referenced_vars, /* properties_provided */ 0, /* properties_destroyed */ - 0, /* todo_flags_start */ - 0, /* todo_flags_finish */ - 0 /* letter */ + TODO_dump_func, /* todo_flags_start */ + TODO_dump_func /* todo_flags_finish */ + } }; @@ -123,96 +131,61 @@ var_ann_t create_var_ann (tree t) { var_ann_t ann; - struct static_var_ann_d *sann = NULL; - - gcc_assert (t); - gcc_assert (DECL_P (t)); - gcc_assert (!t->base.ann || t->base.ann->common.type == VAR_ANN); - - if (!MTAG_P (t) && (TREE_STATIC (t) || DECL_EXTERNAL (t))) - { - sann = GGC_CNEW (struct static_var_ann_d); - ann = &sann->ann; - } - else - ann = GGC_CNEW (struct var_ann_d); - - ann->common.type = VAR_ANN; - - if (!MTAG_P (t) && (TREE_STATIC (t) || DECL_EXTERNAL (t))) - { - void **slot; - sann->uid = DECL_UID (t); - slot = htab_find_slot_with_hash (gimple_var_anns (cfun), - t, DECL_UID (t), INSERT); - gcc_assert (!*slot); - *slot = sann; - } - else - t->base.ann = (tree_ann_t) ann; - - return ann; -} - -/* Create a new annotation for a FUNCTION_DECL node T. */ - -function_ann_t -create_function_ann (tree t) -{ - function_ann_t ann; gcc_assert (t); - gcc_assert (TREE_CODE (t) == FUNCTION_DECL); - gcc_assert (!t->base.ann || t->base.ann->common.type == FUNCTION_ANN); - - ann = ggc_alloc (sizeof (*ann)); - memset ((void *) ann, 0, sizeof (*ann)); - - ann->common.type = FUNCTION_ANN; + gcc_assert (TREE_CODE (t) == VAR_DECL + || TREE_CODE (t) == PARM_DECL + || TREE_CODE (t) == RESULT_DECL); - t->base.ann = (tree_ann_t) ann; + ann = GGC_CNEW (struct var_ann_d); + *DECL_VAR_ANN_PTR (t) = ann; return ann; } -/* Create a new annotation for a statement node T. */ +/* Renumber all of the gimple stmt uids. */ -stmt_ann_t -create_stmt_ann (tree t) +void +renumber_gimple_stmt_uids (void) { - stmt_ann_t ann; - - gcc_assert (is_gimple_stmt (t)); - gcc_assert (!t->base.ann || t->base.ann->common.type == STMT_ANN); - - ann = GGC_CNEW (struct stmt_ann_d); - - ann->common.type = STMT_ANN; - - /* Since we just created the annotation, mark the statement modified. */ - ann->modified = true; - - t->base.ann = (tree_ann_t) ann; + basic_block bb; - return ann; + set_gimple_stmt_max_uid (cfun, 0); + FOR_ALL_BB (bb) + { + gimple_stmt_iterator bsi; + for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi)) + { + gimple stmt = gsi_stmt (bsi); + gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun)); + } + } } -/* Create a new annotation for a tree T. */ +/* Like renumber_gimple_stmt_uids, but only do work on the basic blocks + in BLOCKS, of which there are N_BLOCKS. Also renumbers PHIs. */ -tree_ann_common_t -create_tree_common_ann (tree t) +void +renumber_gimple_stmt_uids_in_blocks (basic_block *blocks, int n_blocks) { - tree_ann_common_t ann; + int i; - gcc_assert (t); - gcc_assert (!t->base.ann || t->base.ann->common.type == TREE_ANN_COMMON); - - ann = GGC_CNEW (struct tree_ann_common_d); - - ann->type = TREE_ANN_COMMON; - t->base.ann = (tree_ann_t) ann; - - return ann; + set_gimple_stmt_max_uid (cfun, 0); + for (i = 0; i < n_blocks; i++) + { + basic_block bb = blocks[i]; + gimple_stmt_iterator bsi; + for (bsi = gsi_start_phis (bb); !gsi_end_p (bsi); gsi_next (&bsi)) + { + gimple stmt = gsi_stmt (bsi); + gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun)); + } + for (bsi = gsi_start_bb (bb); !gsi_end_p (bsi); gsi_next (&bsi)) + { + gimple stmt = gsi_stmt (bsi); + gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun)); + } + } } /* Build a temporary. Make sure and register it to be renamed. */ @@ -220,11 +193,7 @@ create_tree_common_ann (tree t) tree make_rename_temp (tree type, const char *prefix) { - tree t = create_tmp_var (type, prefix); - - if (TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE - || TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE) - DECL_GIMPLE_REG_P (t) = 1; + tree t = create_tmp_reg (type, prefix); if (gimple_referenced_vars (cfun)) { @@ -248,16 +217,17 @@ dump_referenced_vars (FILE *file) { tree var; referenced_var_iterator rvi; - + fprintf (file, "\nReferenced variables in %s: %u\n\n", get_name (current_function_decl), (unsigned) num_referenced_vars); - + FOR_EACH_REFERENCED_VAR (var, rvi) { fprintf (file, "Variable: "); dump_variable (file, var); - fprintf (file, "\n"); } + + fprintf (file, "\n"); } @@ -270,42 +240,6 @@ debug_referenced_vars (void) } -/* Dump sub-variables for VAR to FILE. */ - -void -dump_subvars_for (FILE *file, tree var) -{ - subvar_t sv = get_subvars_for_var (var); - tree subvar; - unsigned int i; - - if (!sv) - return; - - fprintf (file, "{ "); - - for (i = 0; VEC_iterate (tree, sv, i, subvar); ++i) - { - print_generic_expr (file, subvar, dump_flags); - fprintf (file, "@" HOST_WIDE_INT_PRINT_UNSIGNED, SFT_OFFSET (subvar)); - if (SFT_BASE_FOR_COMPONENTS_P (subvar)) - fprintf (file, "[B]"); - fprintf (file, " "); - } - - fprintf (file, "}"); -} - - -/* Dumb sub-variables for VAR to stderr. */ - -void -debug_subvars_for (tree var) -{ - dump_subvars_for (stderr, var); -} - - /* Dump variable VAR and its may-aliases to FILE. */ void @@ -331,105 +265,39 @@ dump_variable (FILE *file, tree var) ann = var_ann (var); fprintf (file, ", UID D.%u", (unsigned) DECL_UID (var)); + if (DECL_PT_UID (var) != DECL_UID (var)) + fprintf (file, ", PT-UID D.%u", (unsigned) DECL_PT_UID (var)); fprintf (file, ", "); print_generic_expr (file, TREE_TYPE (var), dump_flags); - if (ann && ann->symbol_mem_tag) - { - fprintf (file, ", symbol memory tag: "); - print_generic_expr (file, ann->symbol_mem_tag, dump_flags); - } - if (TREE_ADDRESSABLE (var)) fprintf (file, ", is addressable"); - + if (is_global_var (var)) fprintf (file, ", is global"); if (TREE_THIS_VOLATILE (var)) fprintf (file, ", is volatile"); - dump_mem_sym_stats_for_var (file, var); - - if (is_call_clobbered (var)) - { - const char *s = ""; - var_ann_t va = var_ann (var); - unsigned int escape_mask = va->escape_mask; - - fprintf (file, ", call clobbered"); - fprintf (file, " ("); - if (escape_mask & ESCAPE_STORED_IN_GLOBAL) - { fprintf (file, "%sstored in global", s); s = ", "; } - if (escape_mask & ESCAPE_TO_ASM) - { fprintf (file, "%sgoes through ASM", s); s = ", "; } - if (escape_mask & ESCAPE_TO_CALL) - { fprintf (file, "%spassed to call", s); s = ", "; } - if (escape_mask & ESCAPE_BAD_CAST) - { fprintf (file, "%sbad cast", s); s = ", "; } - if (escape_mask & ESCAPE_TO_RETURN) - { fprintf (file, "%sreturned from func", s); s = ", "; } - if (escape_mask & ESCAPE_TO_PURE_CONST) - { fprintf (file, "%spassed to pure/const", s); s = ", "; } - if (escape_mask & ESCAPE_IS_GLOBAL) - { fprintf (file, "%sis global var", s); s = ", "; } - if (escape_mask & ESCAPE_IS_PARM) - { fprintf (file, "%sis incoming pointer", s); s = ", "; } - if (escape_mask & ESCAPE_UNKNOWN) - { fprintf (file, "%sunknown escape", s); s = ", "; } - fprintf (file, ")"); - } - - if (ann->noalias_state == NO_ALIAS) + if (ann && ann->noalias_state == NO_ALIAS) fprintf (file, ", NO_ALIAS (does not alias other NO_ALIAS symbols)"); - else if (ann->noalias_state == NO_ALIAS_GLOBAL) + else if (ann && ann->noalias_state == NO_ALIAS_GLOBAL) fprintf (file, ", NO_ALIAS_GLOBAL (does not alias other NO_ALIAS symbols" " and global vars)"); - else if (ann->noalias_state == NO_ALIAS_ANYTHING) + else if (ann && ann->noalias_state == NO_ALIAS_ANYTHING) fprintf (file, ", NO_ALIAS_ANYTHING (does not alias any other symbols)"); - if (gimple_default_def (cfun, var)) + if (cfun && gimple_default_def (cfun, var)) { fprintf (file, ", default def: "); print_generic_expr (file, gimple_default_def (cfun, var), dump_flags); } - if (MTAG_P (var) && may_aliases (var)) - { - fprintf (file, ", may aliases: "); - dump_may_aliases_for (file, var); - } - - if (get_subvars_for_var (var)) - { - fprintf (file, ", sub-vars: "); - dump_subvars_for (file, var); - } - - if (!is_gimple_reg (var)) + if (DECL_INITIAL (var)) { - if (memory_partition (var)) - { - fprintf (file, ", belongs to partition: "); - print_generic_expr (file, memory_partition (var), dump_flags); - } - - if (TREE_CODE (var) == MEMORY_PARTITION_TAG) - { - fprintf (file, ", partition symbols: "); - dump_decl_set (file, MPT_SYMBOLS (var)); - } - - if (TREE_CODE (var) == STRUCT_FIELD_TAG) - { - fprintf (file, ", offset: " HOST_WIDE_INT_PRINT_UNSIGNED, - SFT_OFFSET (var)); - fprintf (file, ", base for components: %s", - SFT_BASE_FOR_COMPONENTS_P (var) ? "NO" : "YES"); - fprintf (file, ", partitionable: %s", - SFT_UNPARTITIONABLE_P (var) ? "NO" : "YES"); - } + fprintf (file, ", initial: "); + print_generic_expr (file, DECL_INITIAL (var), dump_flags); } fprintf (file, "\n"); @@ -473,11 +341,6 @@ dump_dfa_stats (FILE *file) fprintf (file, fmt_str_1, "Referenced variables", (unsigned long)num_referenced_vars, SCALE (size), LABEL (size)); - size = dfa_stats.num_stmt_anns * sizeof (struct stmt_ann_d); - total += size; - fprintf (file, fmt_str_1, "Statements annotated", dfa_stats.num_stmt_anns, - SCALE (size), LABEL (size)); - size = dfa_stats.num_var_anns * sizeof (struct var_ann_d); total += size; fprintf (file, fmt_str_1, "Variables annotated", dfa_stats.num_var_anns, @@ -503,7 +366,7 @@ dump_dfa_stats (FILE *file) fprintf (file, fmt_str_1, "VDEF operands", dfa_stats.num_vdefs, SCALE (size), LABEL (size)); - size = dfa_stats.num_phis * sizeof (struct tree_phi_node); + size = dfa_stats.num_phis * sizeof (struct gimple_statement_phi); total += size; fprintf (file, fmt_str_1, "PHI nodes", dfa_stats.num_phis, SCALE (size), LABEL (size)); @@ -520,9 +383,9 @@ dump_dfa_stats (FILE *file) fprintf (file, "\n"); if (dfa_stats.num_phis) - fprintf (file, "Average number of arguments per PHI node: %.1f (max: %d)\n", + fprintf (file, "Average number of arguments per PHI node: %.1f (max: %ld)\n", (float) dfa_stats.num_phi_args / (float) dfa_stats.num_phis, - dfa_stats.max_num_phi_args); + (long) dfa_stats.max_num_phi_args); fprintf (file, "\n"); } @@ -541,75 +404,44 @@ debug_dfa_stats (void) DFA_STATS_P. */ static void -collect_dfa_stats (struct dfa_stats_d *dfa_stats_p) +collect_dfa_stats (struct dfa_stats_d *dfa_stats_p ATTRIBUTE_UNUSED) { - struct pointer_set_t *pset; basic_block bb; - block_stmt_iterator i; + referenced_var_iterator vi; + tree var; gcc_assert (dfa_stats_p); memset ((void *)dfa_stats_p, 0, sizeof (struct dfa_stats_d)); - /* Walk all the trees in the function counting references. Start at - basic block NUM_FIXED_BLOCKS, but don't stop at block boundaries. */ - pset = pointer_set_create (); - - for (i = bsi_start (BASIC_BLOCK (NUM_FIXED_BLOCKS)); - !bsi_end_p (i); bsi_next (&i)) - walk_tree (bsi_stmt_ptr (i), collect_dfa_stats_r, (void *) dfa_stats_p, - pset); - - pointer_set_destroy (pset); + /* Count all the variable annotations. */ + FOR_EACH_REFERENCED_VAR (var, vi) + if (var_ann (var)) + dfa_stats_p->num_var_anns++; + /* Walk all the statements in the function counting references. */ FOR_EACH_BB (bb) { - tree phi; - for (phi = phi_nodes (bb); phi; phi = PHI_CHAIN (phi)) + gimple_stmt_iterator si; + + for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si)) { + gimple phi = gsi_stmt (si); dfa_stats_p->num_phis++; - dfa_stats_p->num_phi_args += PHI_NUM_ARGS (phi); - if (PHI_NUM_ARGS (phi) > dfa_stats_p->max_num_phi_args) - dfa_stats_p->max_num_phi_args = PHI_NUM_ARGS (phi); + dfa_stats_p->num_phi_args += gimple_phi_num_args (phi); + if (gimple_phi_num_args (phi) > dfa_stats_p->max_num_phi_args) + dfa_stats_p->max_num_phi_args = gimple_phi_num_args (phi); } - } -} - - -/* Callback for walk_tree to collect DFA statistics for a tree and its - children. */ -static tree -collect_dfa_stats_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, - void *data) -{ - tree t = *tp; - struct dfa_stats_d *dfa_stats_p = (struct dfa_stats_d *)data; - - if (t->base.ann) - { - switch (ann_type (t->base.ann)) + for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si)) { - case STMT_ANN: - { - dfa_stats_p->num_stmt_anns++; - dfa_stats_p->num_defs += NUM_SSA_OPERANDS (t, SSA_OP_DEF); - dfa_stats_p->num_uses += NUM_SSA_OPERANDS (t, SSA_OP_USE); - dfa_stats_p->num_vdefs += NUM_SSA_OPERANDS (t, SSA_OP_VDEF); - dfa_stats_p->num_vuses += NUM_SSA_OPERANDS (t, SSA_OP_VUSE); - break; - } - - case VAR_ANN: - dfa_stats_p->num_var_anns++; - break; - - default: - break; + gimple stmt = gsi_stmt (si); + dfa_stats_p->num_defs += NUM_SSA_OPERANDS (stmt, SSA_OP_DEF); + dfa_stats_p->num_uses += NUM_SSA_OPERANDS (stmt, SSA_OP_USE); + dfa_stats_p->num_vdefs += gimple_vdef (stmt) ? 1 : 0; + dfa_stats_p->num_vuses += gimple_vuse (stmt) ? 1 : 0; } } - - return NULL; } @@ -622,9 +454,14 @@ collect_dfa_stats_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED, static tree find_vars_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED) { + /* If we are reading the lto info back in, we need to rescan the + referenced vars. */ + if (TREE_CODE (*tp) == SSA_NAME) + add_referenced_var (SSA_NAME_VAR (*tp)); + /* If T is a regular variable that the optimizers are interested in, add it to the list of variables. */ - if (SSA_VAR_P (*tp)) + else if (SSA_VAR_P (*tp)) add_referenced_var (*tp); /* Type, _DECL and constant nodes have no interesting children. @@ -635,44 +472,77 @@ find_vars_r (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED) return NULL_TREE; } +/* Find referenced variables in STMT. In contrast with + find_new_referenced_vars, this function will not mark newly found + variables for renaming. */ + +void +find_referenced_vars_in (gimple stmt) +{ + size_t i; + + if (gimple_code (stmt) != GIMPLE_PHI) + { + for (i = 0; i < gimple_num_ops (stmt); i++) + walk_tree (gimple_op_ptr (stmt, i), find_vars_r, NULL, NULL); + } + else + { + walk_tree (gimple_phi_result_ptr (stmt), find_vars_r, NULL, NULL); + + for (i = 0; i < gimple_phi_num_args (stmt); i++) + { + tree arg = gimple_phi_arg_def (stmt, i); + walk_tree (&arg, find_vars_r, NULL, NULL); + } + } +} + + /* Lookup UID in the referenced_vars hashtable and return the associated variable. */ -tree +tree referenced_var_lookup (unsigned int uid) { - tree var; - - gcc_assert (bitmap_bit_p (gimple_referenced_vars (cfun), uid)); - - /* For now also assert that the variable is really referenced. - Otherwise callers need to deal with the result from this function - being NULL. */ - var = lookup_decl_from_uid (uid); - gcc_assert (var); - return var; + tree h; + struct tree_decl_minimal in; + in.uid = uid; + h = (tree) htab_find_with_hash (gimple_referenced_vars (cfun), &in, uid); + gcc_assert (h || uid == 0); + return h; } -/* Check if TO is in the referenced_vars hash table and insert it if not. +/* Check if TO is in the referenced_vars hash table and insert it if not. Return true if it required insertion. */ bool referenced_var_check_and_insert (tree to) -{ +{ + tree h, *loc; + struct tree_decl_minimal in; unsigned int uid = DECL_UID (to); - if (bitmap_bit_p (gimple_referenced_vars (cfun), uid)) - return false; - - bitmap_set_bit (gimple_referenced_vars (cfun), uid); + in.uid = uid; + h = (tree) htab_find_with_hash (gimple_referenced_vars (cfun), &in, uid); + if (h) + { + /* DECL_UID has already been entered in the table. Verify that it is + the same entry as TO. See PR 27793. */ + gcc_assert (h == to); + return false; + } + loc = (tree *) htab_find_slot_with_hash (gimple_referenced_vars (cfun), + &in, uid, INSERT); + *loc = to; return true; } /* Lookup VAR UID in the default_defs hashtable and return the associated variable. */ -tree +tree gimple_default_def (struct function *fn, tree var) { struct tree_decl_minimal ind; @@ -687,7 +557,7 @@ gimple_default_def (struct function *fn, tree var) void set_default_def (tree var, tree def) -{ +{ struct tree_decl_minimal ind; struct tree_ssa_name in; void **loc; @@ -718,35 +588,28 @@ set_default_def (tree var, tree def) /* Add VAR to the list of referenced variables if it isn't already there. */ -void +bool add_referenced_var (tree var) { - var_ann_t v_ann; - - v_ann = get_var_ann (var); + get_var_ann (var); gcc_assert (DECL_P (var)); - + /* Insert VAR into the referenced_vars has table if it isn't present. */ if (referenced_var_check_and_insert (var)) { - /* This is the first time we found this variable, annotate it with - attributes that are intrinsic to the variable. */ - - /* Tag's don't have DECL_INITIAL. */ - if (MTAG_P (var)) - return; - /* Scan DECL_INITIAL for pointer variables as they may contain address arithmetic referencing the address of other - variables. - Even non-constant intializers need to be walked, because - IPA passes might prove that their are invariant later on. */ + variables. As we are only interested in directly referenced + globals or referenced locals restrict this to initializers + than can refer to local variables. */ if (DECL_INITIAL (var) - /* Initializers of external variables are not useful to the - optimizers. */ - && !DECL_EXTERNAL (var)) + && DECL_CONTEXT (var) == current_function_decl) walk_tree (&DECL_INITIAL (var), find_vars_r, NULL, 0); + + return true; } + + return false; } /* Remove VAR from the list. */ @@ -755,26 +618,22 @@ void remove_referenced_var (tree var) { var_ann_t v_ann; + struct tree_decl_minimal in; + void **loc; unsigned int uid = DECL_UID (var); - subvar_t sv; - /* If we remove a var, we should also remove its subvars, as we kill - their parent var and its annotation. */ - if (var_can_have_subvars (var) - && (sv = get_subvars_for_var (var))) + /* Preserve var_anns of globals. */ + if (!is_global_var (var) + && (v_ann = var_ann (var))) { - unsigned int i; - tree subvar; - for (i = 0; VEC_iterate (tree, sv, i, subvar); ++i) - remove_referenced_var (subvar); + ggc_free (v_ann); + *DECL_VAR_ANN_PTR (var) = NULL; } - - clear_call_clobbered (var); - if ((v_ann = var_ann (var))) - ggc_free (v_ann); - var->base.ann = NULL; gcc_assert (DECL_P (var)); - bitmap_clear_bit (gimple_referenced_vars (cfun), uid); + in.uid = uid; + loc = htab_find_slot_with_hash (gimple_referenced_vars (cfun), &in, uid, + NO_INSERT); + htab_clear_slot (gimple_referenced_vars (cfun), loc); } @@ -801,14 +660,10 @@ get_virtual_var (tree var) return var; } -/* Mark all the naked symbols in STMT for SSA renaming. - - NOTE: This function should only be used for brand new statements. - If the caller is modifying an existing statement, it should use the - combination push_stmt_changes/pop_stmt_changes. */ +/* Mark all the naked symbols in STMT for SSA renaming. */ void -mark_symbols_for_renaming (tree stmt) +mark_symbols_for_renaming (gimple stmt) { tree op; ssa_op_iter iter; @@ -822,8 +677,9 @@ mark_symbols_for_renaming (tree stmt) } -/* Find all variables within the gimplified statement that were not previously - visible to the function and add them to the referenced variables list. */ +/* Find all variables within the gimplified statement that were not + previously visible to the function and add them to the referenced + variables list. */ static tree find_new_referenced_vars_1 (tree *tp, int *walk_subtrees, @@ -843,10 +699,13 @@ find_new_referenced_vars_1 (tree *tp, int *walk_subtrees, return NULL; } + +/* Find any new referenced variables in STMT. */ + void -find_new_referenced_vars (tree *stmt_p) +find_new_referenced_vars (gimple stmt) { - walk_tree (stmt_p, find_new_referenced_vars_1, NULL, NULL); + walk_gimple_op (stmt, find_new_referenced_vars_1, NULL); } @@ -867,14 +726,12 @@ get_ref_base_and_extent (tree exp, HOST_WIDE_INT *poffset, HOST_WIDE_INT bit_offset = 0; bool seen_variable_array_ref = false; - gcc_assert (!SSA_VAR_P (exp)); - /* First get the final access size from just the outermost expression. */ if (TREE_CODE (exp) == COMPONENT_REF) size_tree = DECL_SIZE (TREE_OPERAND (exp, 1)); else if (TREE_CODE (exp) == BIT_FIELD_REF) size_tree = TREE_OPERAND (exp, 1); - else + else if (!VOID_TYPE_P (TREE_TYPE (exp))) { enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp)); if (mode == BLKmode) @@ -901,7 +758,7 @@ get_ref_base_and_extent (tree exp, HOST_WIDE_INT *poffset, switch (TREE_CODE (exp)) { case BIT_FIELD_REF: - bit_offset += tree_low_cst (TREE_OPERAND (exp, 2), 0); + bit_offset += TREE_INT_CST_LOW (TREE_OPERAND (exp, 2)); break; case COMPONENT_REF: @@ -909,19 +766,47 @@ get_ref_base_and_extent (tree exp, HOST_WIDE_INT *poffset, tree field = TREE_OPERAND (exp, 1); tree this_offset = component_ref_field_offset (exp); - if (this_offset && TREE_CODE (this_offset) == INTEGER_CST) + if (this_offset + && TREE_CODE (this_offset) == INTEGER_CST + && host_integerp (this_offset, 0)) { - HOST_WIDE_INT hthis_offset = tree_low_cst (this_offset, 0); - + HOST_WIDE_INT hthis_offset = TREE_INT_CST_LOW (this_offset); hthis_offset *= BITS_PER_UNIT; + hthis_offset + += TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (field)); bit_offset += hthis_offset; - bit_offset += tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 0); + + /* If we had seen a variable array ref already and we just + referenced the last field of a struct or a union member + then we have to adjust maxsize by the padding at the end + of our field. */ + if (seen_variable_array_ref + && maxsize != -1) + { + tree stype = TREE_TYPE (TREE_OPERAND (exp, 0)); + tree next = TREE_CHAIN (field); + while (next && TREE_CODE (next) != FIELD_DECL) + next = TREE_CHAIN (next); + if (!next + || TREE_CODE (stype) != RECORD_TYPE) + { + tree fsize = DECL_SIZE_UNIT (field); + tree ssize = TYPE_SIZE_UNIT (stype); + if (host_integerp (fsize, 0) + && host_integerp (ssize, 0)) + maxsize += ((TREE_INT_CST_LOW (ssize) + - TREE_INT_CST_LOW (fsize)) + * BITS_PER_UNIT - hthis_offset); + else + maxsize = -1; + } + } } else { tree csize = TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp, 0))); /* We need to adjust maxsize to the whole structure bitsize. - But we can subtract any constant offset seen sofar, + But we can subtract any constant offset seen so far, because that would get us out of the structure otherwise. */ if (maxsize != -1 && csize && host_integerp (csize, 1)) maxsize = TREE_INT_CST_LOW (csize) - bit_offset; @@ -935,18 +820,20 @@ get_ref_base_and_extent (tree exp, HOST_WIDE_INT *poffset, case ARRAY_RANGE_REF: { tree index = TREE_OPERAND (exp, 1); - tree low_bound = array_ref_low_bound (exp); - tree unit_size = array_ref_element_size (exp); + tree low_bound, unit_size; /* If the resulting bit-offset is constant, track it. */ - if (host_integerp (index, 0) - && host_integerp (low_bound, 0) - && host_integerp (unit_size, 1)) + if (TREE_CODE (index) == INTEGER_CST + && host_integerp (index, 0) + && (low_bound = array_ref_low_bound (exp), + host_integerp (low_bound, 0)) + && (unit_size = array_ref_element_size (exp), + host_integerp (unit_size, 1))) { - HOST_WIDE_INT hindex = tree_low_cst (index, 0); + HOST_WIDE_INT hindex = TREE_INT_CST_LOW (index); - hindex -= tree_low_cst (low_bound, 0); - hindex *= tree_low_cst (unit_size, 1); + hindex -= TREE_INT_CST_LOW (low_bound); + hindex *= TREE_INT_CST_LOW (unit_size); hindex *= BITS_PER_UNIT; bit_offset += hindex; @@ -959,7 +846,7 @@ get_ref_base_and_extent (tree exp, HOST_WIDE_INT *poffset, { tree asize = TYPE_SIZE (TREE_TYPE (TREE_OPERAND (exp, 0))); /* We need to adjust maxsize to the whole array bitsize. - But we can subtract any constant offset seen sofar, + But we can subtract any constant offset seen so far, because that would get us outside of the array otherwise. */ if (maxsize != -1 && asize && host_integerp (asize, 1)) maxsize = TREE_INT_CST_LOW (asize) - bit_offset; @@ -981,7 +868,6 @@ get_ref_base_and_extent (tree exp, HOST_WIDE_INT *poffset, break; case VIEW_CONVERT_EXPR: - /* ??? We probably should give up here and bail out. */ break; default: @@ -996,15 +882,28 @@ get_ref_base_and_extent (tree exp, HOST_WIDE_INT *poffset, struct { int length; int a[1]; } x; x.a[d] struct { struct { int a; int b; } a[1]; } x; x.a[d].a struct { struct { int a[1]; } a[1]; } x; x.a[0][d], x.a[d][0] + struct { int len; union { int a[1]; struct X x; } u; } x; x.u.a[d] where we do not know maxsize for variable index accesses to the array. The simplest way to conservatively deal with this is to punt in the case that offset + maxsize reaches the - base type boundary. */ - if (seen_variable_array_ref - && maxsize != -1 - && host_integerp (TYPE_SIZE (TREE_TYPE (exp)), 1) - && bit_offset + maxsize - == (signed)TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (exp)))) + base type boundary. This needs to include possible trailing padding + that is there for alignment purposes. + + That is of course only true if the base object is not a decl. */ + + if (DECL_P (exp)) + { + /* If maxsize is unknown adjust it according to the size of the + base decl. */ + if (maxsize == -1 + && host_integerp (DECL_SIZE (exp), 1)) + maxsize = TREE_INT_CST_LOW (DECL_SIZE (exp)) - bit_offset; + } + else if (seen_variable_array_ref + && maxsize != -1 + && (!host_integerp (TYPE_SIZE (TREE_TYPE (exp)), 1) + || (bit_offset + maxsize + == (signed) TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (exp)))))) maxsize = -1; /* ??? Due to negative offsets in ARRAY_REF we can end up with @@ -1021,7 +920,7 @@ get_ref_base_and_extent (tree exp, HOST_WIDE_INT *poffset, SSA_NAME_OCCURS_IN_ABNORMAL_PHI set, otherwise false. */ bool -stmt_references_abnormal_ssa_name (tree stmt) +stmt_references_abnormal_ssa_name (gimple stmt) { ssa_op_iter oi; use_operand_p use_p;