2009-04-16 Richard Guenther <rguenther@suse.de>
+ * gimple.c (gimple_copy): Do not clear addresses_taken bitmap.
+ (gimple_ior_addresses_taken_1): New function.
+ (gimple_ior_addresses_taken): Likewise.
+ * gimple.h (struct gimple_statement_with_ops_base): Remove
+ addresses_taken member.
+ (gimple_ior_addresses_taken): Declare.
+ (gimple_addresses_taken, gimple_addresses_taken_ptr,
+ gimple_set_addresses_taken): Remove.
+ * ipa-reference.c (mark_address): New function.
+ (scan_stmt_for_static_refs): Use it for marking addresses taken.
+ * tree-ssa-operands.c (add_to_addressable_set): Rename to ...
+ (mark_address_taken): ... this. Just set TREE_ADDRESSABLE.
+ (gimple_add_to_addresses_taken): Remove.
+ (get_tmr_operands): Call mark_address_taken.
+ (get_asm_expr_operands): Likewise.
+ (get_expr_operands): Likewise.
+ (build_ssa_operands): Do not clear the addresses_taken bitmap.
+ (free_stmt_operands): Do not free it.
+ * tree-ssa.c (delete_tree_ssa): Likewise.
+ (execute_update_addresses_taken): Use gimple_ior_addresses_taken.
+
+2009-04-16 Richard Guenther <rguenther@suse.de>
+
* gimple.h (walk_stmt_load_store_addr_ops): Declare.
(walk_stmt_load_store_ops): Likewise.
* gimple.c (get_base_loadstore): New function.
for (i = 0; i < num_ops; i++)
gimple_set_op (copy, i, unshare_expr (gimple_op (stmt, i)));
- /* Clear out SSA operand vectors on COPY. Note that we cannot
- call the API functions for setting addresses_taken, stores
- and loads. These functions free the previous values, and we
- cannot do that on COPY as it will affect the original
- statement. */
+ /* Clear out SSA operand vectors on COPY. */
if (gimple_has_ops (stmt))
{
gimple_set_def_ops (copy, NULL);
gimple_set_use_ops (copy, NULL);
- copy->gsops.opbase.addresses_taken = NULL;
}
if (gimple_has_mem_ops (stmt))
visit_load, visit_store, NULL);
}
+/* Helper for gimple_ior_addresses_taken_1. */
+
+static bool
+gimple_ior_addresses_taken_1 (gimple stmt ATTRIBUTE_UNUSED,
+ tree addr, void *data)
+{
+ bitmap addresses_taken = (bitmap)data;
+ while (handled_component_p (addr))
+ addr = TREE_OPERAND (addr, 0);
+ if (DECL_P (addr))
+ {
+ bitmap_set_bit (addresses_taken, DECL_UID (addr));
+ return true;
+ }
+ return false;
+}
+
+/* Set the bit for the uid of all decls that have their address taken
+ in STMT in the ADDRESSES_TAKEN bitmap. Returns true if there
+ were any in this stmt. */
+
+bool
+gimple_ior_addresses_taken (bitmap addresses_taken, gimple stmt)
+{
+ return walk_stmt_load_store_addr_ops (stmt, addresses_taken, NULL, NULL,
+ gimple_ior_addresses_taken_1);
+}
+
#include "gt-gimple.h"
struct gimple_statement_with_ops_base GTY(())
{
- /* [ WORD 1-4 ] */
+ /* [ WORD 1-4 ] */
struct gimple_statement_base gsbase;
- /* [ WORD 5 ]
- Symbols whose addresses are taken by this statement (i.e., they
- appear inside ADDR_EXPR nodes). */
- bitmap GTY((skip (""))) addresses_taken;
-
- /* [ WORD 6-7 ]
+ /* [ WORD 5-6 ]
SSA operand vectors. NOTE: It should be possible to
amalgamate these vectors with the operand vector OP. However,
the SSA operand vectors are organized differently and contain
struct gimple_statement_with_ops GTY(())
{
- /* [ WORD 1-7 ] */
+ /* [ WORD 1-6 ] */
struct gimple_statement_with_ops_base opbase;
- /* [ WORD 8 ]
+ /* [ WORD 7 ]
Operand vector. NOTE! This must always be the last field
of this structure. In particular, this means that this
structure cannot be embedded inside another one. */
struct gimple_statement_with_memory_ops_base GTY(())
{
- /* [ WORD 1-7 ] */
+ /* [ WORD 1-6 ] */
struct gimple_statement_with_ops_base opbase;
- /* [ WORD 8-9 ]
+ /* [ WORD 7-8 ]
Virtual operands for this statement. The GC will pick them
up via the ssa_names array. */
tree GTY((skip (""))) vdef;
struct gimple_statement_with_memory_ops GTY(())
{
- /* [ WORD 1-9 ] */
+ /* [ WORD 1-8 ] */
struct gimple_statement_with_memory_ops_base membase;
- /* [ WORD 10 ]
+ /* [ WORD 9 ]
Operand vector. NOTE! This must always be the last field
of this structure. In particular, this means that this
structure cannot be embedded inside another one. */
struct gimple_statement_asm GTY(())
{
- /* [ WORD 1-9 ] */
+ /* [ WORD 1-8 ] */
struct gimple_statement_with_memory_ops_base membase;
- /* [ WORD 10 ]
+ /* [ WORD 9 ]
__asm__ statement. */
const char *string;
- /* [ WORD 11 ]
+ /* [ WORD 10 ]
Number of inputs, outputs and clobbers. */
unsigned char ni;
unsigned char no;
unsigned short nc;
- /* [ WORD 12 ]
+ /* [ WORD 11 ]
Operand vector. NOTE! This must always be the last field
of this structure. In particular, this means that this
structure cannot be embedded inside another one. */
extern bool walk_stmt_load_store_ops (gimple, void *,
bool (*)(gimple, tree, void *),
bool (*)(gimple, tree, void *));
+extern bool gimple_ior_addresses_taken (bitmap, gimple);
/* In gimplify.c */
extern tree create_tmp_var_raw (tree, const char *);
return gimple_code (g) >= GIMPLE_ASSIGN && gimple_code (g) <= GIMPLE_RETURN;
}
-/* Return the set of addresses taken by statement G. */
-
-static inline bitmap
-gimple_addresses_taken (const_gimple g)
-{
- if (gimple_has_ops (g))
- return g->gsops.opbase.addresses_taken;
- else
- return NULL;
-}
-
-
-/* Return a pointer to the set of addresses taken by statement G. */
-
-static inline bitmap *
-gimple_addresses_taken_ptr (gimple g)
-{
- if (gimple_has_ops (g))
- return &g->gsops.opbase.addresses_taken;
- else
- return NULL;
-}
-
-
-/* Set B to be the set of addresses taken by statement G. The
- previous set is freed. */
-
-static inline void
-gimple_set_addresses_taken (gimple g, bitmap b)
-{
- gcc_assert (gimple_has_ops (g));
- BITMAP_FREE (g->gsops.opbase.addresses_taken);
- g->gsops.opbase.addresses_taken = b;
-}
-
/* Return the set of DEF operands for statement G. */
bitmap_set_bit (module_statics_escape, DECL_UID (x));
}
+/* Wrapper around mark_address_taken for the stmt walker. */
+
+static bool
+mark_address (gimple stmt ATTRIBUTE_UNUSED, tree addr,
+ void *data ATTRIBUTE_UNUSED)
+{
+ while (handled_component_p (addr))
+ addr = TREE_OPERAND (addr, 0);
+ mark_address_taken (addr);
+ return false;
+}
+
/* Mark load of T. */
static bool
{
gimple stmt = gsi_stmt (*gsip);
ipa_reference_local_vars_info_t local = NULL;
- unsigned int i;
- bitmap_iterator bi;
if (fn)
local = get_reference_vars_info (fn)->local;
/* Look for direct loads and stores. */
- walk_stmt_load_store_addr_ops (stmt, local, mark_load, mark_store, NULL);
+ walk_stmt_load_store_addr_ops (stmt, local, mark_load, mark_store,
+ mark_address);
if (is_gimple_call (stmt))
check_call (local, stmt);
else if (gimple_code (stmt) == GIMPLE_ASM)
check_asm_memory_clobber (local, stmt);
-
- if (gimple_addresses_taken (stmt))
- EXECUTE_IF_SET_IN_BITMAP (gimple_addresses_taken (stmt), 0, i, bi)
- mark_address_taken (referenced_var_lookup (i));
return NULL;
}
add_virtual_operand (stmt, flags);
}
-/* Add the base address of REF to SET. */
+/* Mark the base address of REF as having its address taken.
+ REF may be a single variable whose address has been taken or any
+ other valid GIMPLE memory reference (structure reference, array,
+ etc). */
static void
-add_to_addressable_set (tree ref, bitmap *set)
+mark_address_taken (tree ref)
{
tree var;
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 (*set == NULL)
- *set = BITMAP_ALLOC (&operands_bitmap_obstack);
-
- bitmap_set_bit (*set, DECL_UID (var));
- TREE_ADDRESSABLE (var) = 1;
- }
-}
-
-/* Add the base address of REF to the set of addresses taken by STMT.
- 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
-gimple_add_to_addresses_taken (gimple stmt, tree ref)
-{
- gcc_assert (gimple_has_ops (stmt));
- add_to_addressable_set (ref, gimple_addresses_taken_ptr (stmt));
+ if (var && DECL_P (var))
+ TREE_ADDRESSABLE (var) = 1;
}
get_expr_operands (stmt, &TMR_INDEX (expr), opf_use);
if (TMR_SYMBOL (expr))
- gimple_add_to_addresses_taken (stmt, TMR_SYMBOL (expr));
+ mark_address_taken (TMR_SYMBOL (expr));
add_virtual_operand (stmt, flags);
}
{
tree t = get_base_address (TREE_VALUE (link));
if (t && DECL_P (t))
- gimple_add_to_addresses_taken (stmt, t);
+ mark_address_taken (t);
}
get_expr_operands (stmt, &TREE_VALUE (link), opf_def);
{
tree t = get_base_address (TREE_VALUE (link));
if (t && DECL_P (t))
- gimple_add_to_addresses_taken (stmt, t);
+ mark_address_taken (t);
}
get_expr_operands (stmt, &TREE_VALUE (link), 0);
reference to it, but the fact that the statement takes its
address will be of interest to some passes (e.g. alias
resolution). */
- gimple_add_to_addresses_taken (stmt, TREE_OPERAND (expr, 0));
+ mark_address_taken (TREE_OPERAND (expr, 0));
/* If the address is invariant, there may be no interesting
variable references inside. */
static void
build_ssa_operands (gimple stmt)
{
- /* Initially assume that the statement has no volatile operands and
- makes no memory references. */
+ /* Initially assume that the statement has no volatile operands. */
gimple_set_has_volatile_ops (stmt, false);
- /* Just clear the bitmap so we don't end up reallocating it over and over. */
- if (gimple_addresses_taken (stmt))
- bitmap_clear (gimple_addresses_taken (stmt));
-
start_ssa_stmt_operands ();
parse_ssa_operands (stmt);
finalize_ssa_stmt_operands (stmt);
gimple_set_use_ops (stmt, NULL);
}
- if (gimple_has_ops (stmt))
- gimple_set_addresses_taken (stmt, NULL);
-
if (gimple_has_mem_ops (stmt))
{
gimple_set_vuse (stmt, NULL_TREE);
{
gimple_set_def_ops (stmt, NULL);
gimple_set_use_ops (stmt, NULL);
- gimple_set_addresses_taken (stmt, NULL);
}
if (gimple_has_mem_ops (stmt))
{
for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
{
- const_gimple stmt = gsi_stmt (gsi);
+ gimple stmt = gsi_stmt (gsi);
enum gimple_code code = gimple_code (stmt);
- bitmap taken = gimple_addresses_taken (stmt);
-
- if (taken)
- bitmap_ior_into (addresses_taken, taken);
-
+
+ /* Note all addresses taken by the stmt. */
+ gimple_ior_addresses_taken (addresses_taken, stmt);
+
/* If we have a call or an assignment, see if the lhs contains
a local decl that requires not to be a gimple register. */
if (code == GIMPLE_ASSIGN || code == GIMPLE_CALL)