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. */
+the Free Software Foundation, 51 Franklin Street, Fifth Floor,
+Boston, MA 02110-1301, USA. */
#include "config.h"
#include "system.h"
#include "flags.h"
#include "function.h"
#include "diagnostic.h"
-#include "errors.h"
#include "tree-flow.h"
#include "tree-inline.h"
#include "tree-pass.h"
#include "ggc.h"
#include "timevar.h"
-
+#include "toplev.h"
#include "langhooks.h"
/* This file contains the code required to manage the operands cache of the
VUSE for 'b'. */
#define opf_no_vops (1 << 2)
+/* Operand is a "non-specific" kill for call-clobbers and such. This is used
+ to distinguish "reset the world" events from explicit MODIFY_EXPRs. */
+#define opf_non_specific (1 << 3)
+
/* This structure maintain a sorted list of operands which is created by
parse_ssa_operand. */
struct opbuild_list_d GTY (())
bool ssa_ro_call_cache_valid;
/* These arrays are the cached operand vectors for call clobbered calls. */
-static GTY (()) varray_type clobbered_v_may_defs;
-static GTY (()) varray_type clobbered_vuses;
-static GTY (()) varray_type ro_call_vuses;
+static VEC(tree,heap) *clobbered_v_may_defs;
+static VEC(tree,heap) *clobbered_vuses;
+static VEC(tree,heap) *ro_call_vuses;
static bool clobbered_aliased_loads;
static bool clobbered_aliased_stores;
static bool ro_call_aliased_loads;
static GTY (()) struct ssa_operand_memory_d *operand_memory = NULL;
static unsigned operand_memory_index;
-static void note_addressable (tree, stmt_ann_t);
static void get_expr_operands (tree, tree *, int);
static void get_asm_expr_operands (tree);
static void get_indirect_ref_operands (tree, tree, int);
+static void get_tmr_operands (tree, tree, int);
static void get_call_expr_operands (tree, tree);
static inline void append_def (tree *);
static inline void append_use (tree *);
ggc_free (ptr);
}
- if (clobbered_v_may_defs)
- {
- ggc_free (clobbered_v_may_defs);
- ggc_free (clobbered_vuses);
- clobbered_v_may_defs = NULL;
- clobbered_vuses = NULL;
- }
- if (ro_call_vuses)
- {
- ggc_free (ro_call_vuses);
- ro_call_vuses = NULL;
- }
+ VEC_free (tree, heap, clobbered_v_may_defs);
+ VEC_free (tree, heap, clobbered_vuses);
+ VEC_free (tree, heap, ro_call_vuses);
ops_active = false;
}
if (TREE_CODE (lhs) == VIEW_CONVERT_EXPR)
lhs = TREE_OPERAND (lhs, 0);
- if (TREE_CODE (lhs) != ARRAY_REF && TREE_CODE (lhs) != ARRAY_RANGE_REF
+ if (TREE_CODE (lhs) != ARRAY_REF
+ && TREE_CODE (lhs) != ARRAY_RANGE_REF
&& TREE_CODE (lhs) != BIT_FIELD_REF
&& TREE_CODE (lhs) != REALPART_EXPR
&& TREE_CODE (lhs) != IMAGPART_EXPR)
/* Free any operands vectors in OPS. */
-#if 0
-static void
+void
free_ssa_operands (stmt_operands_p ops)
{
ops->def_ops = NULL;
ops->maydef_ops = NULL;
ops->mustdef_ops = NULL;
ops->vuse_ops = NULL;
- while (ops->memory.next != NULL)
- {
- operand_memory_p tmp = ops->memory.next;
- ops->memory.next = tmp->next;
- ggc_free (tmp);
- }
}
-#endif
/* Get the operands of statement STMT. Note that repeated calls to
get_indirect_ref_operands (stmt, expr, flags);
return;
+ case TARGET_MEM_REF:
+ get_tmr_operands (stmt, expr, flags);
+ return;
+
case ARRAY_REF:
case ARRAY_RANGE_REF:
/* Treat array references as references to the virtual variable
case IMAGPART_EXPR:
{
tree ref;
- HOST_WIDE_INT offset, size;
+ unsigned HOST_WIDE_INT offset, size;
/* This component ref becomes an access to all of the subvariables
it can touch, if we can determine that, but *NOT* the real one.
If we can't determine which fields we could touch, the recursion
bool exact;
if (overlap_subvar (offset, size, sv, &exact))
{
- if (exact)
- flags &= ~opf_kill_def;
- add_stmt_operand (&sv->var, s_ann, flags);
+ bool subvar_flags = flags;
+ if (!exact)
+ subvar_flags &= ~opf_kill_def;
+ add_stmt_operand (&sv->var, s_ann, subvar_flags);
}
}
}
flags & ~opf_kill_def);
if (code == COMPONENT_REF)
- get_expr_operands (stmt, &TREE_OPERAND (expr, 2), opf_none);
+ {
+ if (s_ann && TREE_THIS_VOLATILE (TREE_OPERAND (expr, 1)))
+ s_ann->has_volatile_ops = true;
+ get_expr_operands (stmt, &TREE_OPERAND (expr, 2), opf_none);
+ }
return;
}
case WITH_SIZE_EXPR:
if (!allows_reg && allows_mem)
{
tree t = get_base_address (TREE_VALUE (link));
- if (t && DECL_P (t))
- note_addressable (t, s_ann);
+ if (t && DECL_P (t) && s_ann)
+ add_to_addressable_set (t, &s_ann->addresses_taken);
}
get_expr_operands (stmt, &TREE_VALUE (link), opf_is_def);
if (!allows_reg && allows_mem)
{
tree t = get_base_address (TREE_VALUE (link));
- if (t && DECL_P (t))
- note_addressable (t, s_ann);
+ if (t && DECL_P (t) && s_ann)
+ add_to_addressable_set (t, &s_ann->addresses_taken);
}
get_expr_operands (stmt, &TREE_VALUE (link), 0);
add_stmt_operand (&global_var, s_ann, opf_is_def);
else
EXECUTE_IF_SET_IN_BITMAP (call_clobbered_vars, 0, i, bi)
- {
- tree var = referenced_var (i);
- add_stmt_operand (&var, s_ann, opf_is_def);
- }
+ {
+ tree var = referenced_var (i);
+ add_stmt_operand (&var, s_ann, opf_is_def | opf_non_specific);
+ }
/* Now clobber all addressables. */
EXECUTE_IF_SET_IN_BITMAP (addressable_vars, 0, i, bi)
&& get_subvars_for_var (var) != NULL)
continue;
- add_stmt_operand (&var, s_ann, opf_is_def);
+ add_stmt_operand (&var, s_ann, opf_is_def | opf_non_specific);
}
break;
get_expr_operands (stmt, pptr, opf_none);
}
+/* A subroutine of get_expr_operands to handle TARGET_MEM_REF. */
+
+static void
+get_tmr_operands (tree stmt, tree expr, int flags)
+{
+ tree tag = TMR_TAG (expr);
+
+ /* First record the real operands. */
+ get_expr_operands (stmt, &TMR_BASE (expr), opf_none);
+ get_expr_operands (stmt, &TMR_INDEX (expr), opf_none);
+
+ /* MEM_REFs should never be killing. */
+ flags &= ~opf_kill_def;
+
+ if (TMR_SYMBOL (expr))
+ {
+ stmt_ann_t ann = stmt_ann (stmt);
+ add_to_addressable_set (TMR_SYMBOL (expr), &ann->addresses_taken);
+ }
+
+ if (tag)
+ add_stmt_operand (&tag, stmt_ann (stmt), flags);
+ else
+ /* Something weird, so ensure that we will be careful. */
+ stmt_ann (stmt)->has_volatile_ops = true;
+}
+
/* A subroutine of get_expr_operands to handle CALL_EXPR. */
static void
/* If the operand is an ADDR_EXPR, add its operand to the list of
variables that have had their address taken in this statement. */
- if (TREE_CODE (var) == ADDR_EXPR)
+ if (TREE_CODE (var) == ADDR_EXPR && s_ann)
{
- note_addressable (TREE_OPERAND (var, 0), s_ann);
+ add_to_addressable_set (TREE_OPERAND (var, 0), &s_ann->addresses_taken);
return;
}
/* If the variable cannot be modified and this is a V_MAY_DEF change
it into a VUSE. This happens when read-only variables are marked
- call-clobbered and/or aliased to writeable variables. So we only
- check that this only happens on stores, and not writes to GIMPLE
- registers.
-
- FIXME: The C++ FE is emitting assignments in the IL stream for
- read-only globals. This is wrong, but for the time being disable
- this transformation on V_MUST_DEF operands (otherwise, we
- mis-optimize SPEC2000's eon). */
- if ((flags & opf_is_def)
- && !(flags & opf_kill_def)
- && unmodifiable_var_p (var))
+ call-clobbered and/or aliased to writable variables. So we only
+ check that this only happens on non-specific stores.
+
+ Note that if this is a specific store, i.e. associated with a
+ modify_expr, then we can't suppress the V_DEF, lest we run into
+ validation problems.
+
+ This can happen when programs cast away const, leaving us with a
+ store to read-only memory. If the statement is actually executed
+ at runtime, then the program is ill formed. If the statement is
+ not executed then all is well. At the very least, we cannot ICE. */
+ if ((flags & opf_non_specific) && unmodifiable_var_p (var))
{
gcc_assert (!is_real_op);
- flags &= ~opf_is_def;
+ flags &= ~(opf_is_def | opf_kill_def);
}
if (is_real_op)
if (flags & opf_is_def)
{
- bool added_may_defs_p = false;
-
/* If the variable is also an alias tag, add a virtual
operand for it, otherwise we will miss representing
references to the members of the variable's alias set.
This fixes the bug in gcc.c-torture/execute/20020503-1.c. */
if (v_ann->is_alias_tag)
- {
- added_may_defs_p = true;
- append_v_may_def (var);
- }
+ append_v_may_def (var);
for (i = 0; i < VARRAY_ACTIVE_SIZE (aliases); i++)
- {
- /* While VAR may be modifiable, some of its aliases
- may not be. If that's the case, we don't really
- need to add them a V_MAY_DEF for them. */
- tree alias = VARRAY_TREE (aliases, i);
-
- if (unmodifiable_var_p (alias))
- append_vuse (alias);
- else
- {
- append_v_may_def (alias);
- added_may_defs_p = true;
- }
- }
+ append_v_may_def (VARRAY_TREE (aliases, i));
- if (s_ann && added_may_defs_p)
+ if (s_ann)
s_ann->makes_aliased_stores = 1;
}
else
}
-/* Record that VAR had its address taken in the statement with annotations
- S_ANN. */
+/* Add the base address of REF to the set *ADDRESSES_TAKEN. If
+ *ADDRESSES_TAKEN is NULL, a new set is created. REF may be
+ a single variable whose address has been taken or any other valid
+ GIMPLE memory reference (structure reference, array, etc). If the
+ base address of REF is a decl that has sub-variables, also add all
+ of its sub-variables. */
-static void
-note_addressable (tree var, stmt_ann_t s_ann)
+void
+add_to_addressable_set (tree ref, bitmap *addresses_taken)
{
- tree ref;
+ tree var;
subvar_t svars;
- HOST_WIDE_INT offset;
- HOST_WIDE_INT size;
- if (!s_ann)
- return;
-
- /* If this is a COMPONENT_REF, and we know exactly what it touches, we only
- take the address of the subvariables it will touch.
- Otherwise, we take the address of all the subvariables, plus the real
- ones. */
+ gcc_assert (addresses_taken);
- if (var && TREE_CODE (var) == COMPONENT_REF
- && (ref = okay_component_ref_for_subvars (var, &offset, &size)))
- {
- subvar_t sv;
- svars = get_subvars_for_var (ref);
-
- if (s_ann->addresses_taken == NULL)
- s_ann->addresses_taken = BITMAP_GGC_ALLOC ();
-
- for (sv = svars; sv; sv = sv->next)
- {
- if (overlap_subvar (offset, size, sv, NULL))
- bitmap_set_bit (s_ann->addresses_taken, var_ann (sv->var)->uid);
- }
- return;
- }
-
- var = get_base_address (var);
+ /* Note that it is *NOT OKAY* to use the target of a COMPONENT_REF
+ as the only thing we take the address of. If VAR is a structure,
+ taking the address of a field means that the whole structure may
+ be referenced using pointer arithmetic. See PR 21407 and the
+ ensuing mailing list discussion. */
+ var = get_base_address (ref);
if (var && SSA_VAR_P (var))
{
- if (s_ann->addresses_taken == NULL)
- s_ann->addresses_taken = BITMAP_GGC_ALLOC ();
+ if (*addresses_taken == NULL)
+ *addresses_taken = BITMAP_GGC_ALLOC ();
-
if (var_can_have_subvars (var)
&& (svars = get_subvars_for_var (var)))
{
subvar_t sv;
for (sv = svars; sv; sv = sv->next)
- bitmap_set_bit (s_ann->addresses_taken, var_ann (sv->var)->uid);
+ {
+ bitmap_set_bit (*addresses_taken, DECL_UID (sv->var));
+ TREE_ADDRESSABLE (sv->var) = 1;
+ }
}
else
- bitmap_set_bit (s_ann->addresses_taken, var_ann (var)->uid);
+ {
+ bitmap_set_bit (*addresses_taken, DECL_UID (var));
+ TREE_ADDRESSABLE (var) = 1;
+ }
}
}
+
/* Add clobbering definitions for .GLOBAL_VAR or for each of the call
clobbered variables in the function. */
{
/* Process the caches in reverse order so we are always inserting at
the head of the list. */
- for (i = VARRAY_ACTIVE_SIZE (clobbered_vuses) - 1; i >=0; i--)
+ for (i = VEC_length (tree, clobbered_vuses) - 1; i >=0; i--)
{
- t = VARRAY_TREE (clobbered_vuses, i);
+ t = VEC_index (tree, clobbered_vuses, i);
gcc_assert (TREE_CODE (t) != SSA_NAME);
var_ann (t)->in_vuse_list = 1;
opbuild_append_virtual (&build_vuses, t);
}
- for (i = VARRAY_ACTIVE_SIZE (clobbered_v_may_defs) - 1; i >= 0; i--)
+ for (i = VEC_length (tree, clobbered_v_may_defs) - 1; i >= 0; i--)
{
- t = VARRAY_TREE (clobbered_v_may_defs, i);
+ t = VEC_index (tree, clobbered_v_may_defs, i);
gcc_assert (TREE_CODE (t) != SSA_NAME);
var_ann (t)->in_v_may_def_list = 1;
opbuild_append_virtual (&build_v_may_defs, t);
if (unmodifiable_var_p (var))
add_stmt_operand (&var, &empty_ann, opf_none);
else
- add_stmt_operand (&var, &empty_ann, opf_is_def);
+ add_stmt_operand (&var, &empty_ann, opf_is_def | opf_non_specific);
}
clobbered_aliased_loads = empty_ann.makes_aliased_loads;
}
/* Prepare empty cache vectors. */
- if (clobbered_v_may_defs)
- {
- VARRAY_POP_ALL (clobbered_vuses);
- VARRAY_POP_ALL (clobbered_v_may_defs);
- }
- else
- {
- VARRAY_TREE_INIT (clobbered_v_may_defs, 10, "clobbered_v_may_defs");
- VARRAY_TREE_INIT (clobbered_vuses, 10, "clobbered_vuses");
- }
+ VEC_truncate (tree, clobbered_vuses, 0);
+ VEC_truncate (tree, clobbered_v_may_defs, 0);
/* Now fill the clobbered cache with the values that have been found. */
for (i = opbuild_first (&build_vuses);
i != OPBUILD_LAST;
i = opbuild_next (&build_vuses, i))
- VARRAY_PUSH_TREE (clobbered_vuses, opbuild_elem_virtual (&build_vuses, i));
+ VEC_safe_push (tree, heap, clobbered_vuses,
+ opbuild_elem_virtual (&build_vuses, i));
gcc_assert (opbuild_num_elems (&build_vuses)
- == VARRAY_ACTIVE_SIZE (clobbered_vuses));
+ == VEC_length (tree, clobbered_vuses));
for (i = opbuild_first (&build_v_may_defs);
i != OPBUILD_LAST;
i = opbuild_next (&build_v_may_defs, i))
- VARRAY_PUSH_TREE (clobbered_v_may_defs,
- opbuild_elem_virtual (&build_v_may_defs, i));
+ VEC_safe_push (tree, heap, clobbered_v_may_defs,
+ opbuild_elem_virtual (&build_v_may_defs, i));
gcc_assert (opbuild_num_elems (&build_v_may_defs)
- == VARRAY_ACTIVE_SIZE (clobbered_v_may_defs));
+ == VEC_length (tree, clobbered_v_may_defs));
ssa_call_clobbered_cache_valid = true;
}
/* If cache is valid, copy the elements into the build vector. */
if (ssa_ro_call_cache_valid)
{
- for (i = VARRAY_ACTIVE_SIZE (ro_call_vuses) - 1; i >=0 ; i--)
+ for (i = VEC_length (tree, ro_call_vuses) - 1; i >=0 ; i--)
{
/* Process the caches in reverse order so we are always inserting at
the head of the list. */
- t = VARRAY_TREE (ro_call_vuses, i);
+ t = VEC_index (tree, ro_call_vuses, i);
gcc_assert (TREE_CODE (t) != SSA_NAME);
var_ann (t)->in_vuse_list = 1;
opbuild_append_virtual (&build_vuses, t);
EXECUTE_IF_SET_IN_BITMAP (call_clobbered_vars, 0, u, bi)
{
tree var = referenced_var (u);
- add_stmt_operand (&var, &empty_ann, opf_none);
+ add_stmt_operand (&var, &empty_ann, opf_none | opf_non_specific);
}
ro_call_aliased_loads = empty_ann.makes_aliased_loads;
s_ann->makes_aliased_loads = empty_ann.makes_aliased_loads;
/* Prepare empty cache vectors. */
- if (ro_call_vuses)
- VARRAY_POP_ALL (ro_call_vuses);
- else
- VARRAY_TREE_INIT (ro_call_vuses, 10, "ro_call_vuses");
-
+ VEC_truncate (tree, ro_call_vuses, 0);
/* Now fill the clobbered cache with the values that have been found. */
for (i = opbuild_first (&build_vuses);
i != OPBUILD_LAST;
i = opbuild_next (&build_vuses, i))
- VARRAY_PUSH_TREE (ro_call_vuses, opbuild_elem_virtual (&build_vuses, i));
+ VEC_safe_push (tree, heap, ro_call_vuses,
+ opbuild_elem_virtual (&build_vuses, i));
gcc_assert (opbuild_num_elems (&build_vuses)
- == VARRAY_ACTIVE_SIZE (ro_call_vuses));
+ == VEC_length (tree, ro_call_vuses));
ssa_ro_call_cache_valid = true;
}
OSDN Git Service
