From 6d5ec6f8d3a4782393733d95b0d52a688568bdf5 Mon Sep 17 00:00:00 2001 From: rguenth Date: Thu, 16 Apr 2009 13:23:13 +0000 Subject: [PATCH] 2009-04-16 Richard Guenther * 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. git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@146191 138bc75d-0d04-0410-961f-82ee72b054a4 --- gcc/ChangeLog | 23 +++++++++++++++++ gcc/gimple.c | 35 +++++++++++++++++++++----- gcc/gimple.h | 65 ++++++++++--------------------------------------- gcc/ipa-reference.c | 21 ++++++++++------ gcc/tree-ssa-operands.c | 48 +++++++++--------------------------- gcc/tree-ssa.c | 12 ++++----- 6 files changed, 96 insertions(+), 108 deletions(-) diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 7bcff75da26..b442ef00f41 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,5 +1,28 @@ 2009-04-16 Richard Guenther + * 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 + * gimple.h (walk_stmt_load_store_addr_ops): Declare. (walk_stmt_load_store_ops): Likewise. * gimple.c (get_base_loadstore): New function. diff --git a/gcc/gimple.c b/gcc/gimple.c index 29692782aed..a91e83a99d4 100644 --- a/gcc/gimple.c +++ b/gcc/gimple.c @@ -2195,16 +2195,11 @@ gimple_copy (gimple stmt) 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)) @@ -3392,4 +3387,32 @@ walk_stmt_load_store_ops (gimple stmt, void *data, 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" diff --git a/gcc/gimple.h b/gcc/gimple.h index bf09039a5e9..2d5ee0fd9b4 100644 --- a/gcc/gimple.h +++ b/gcc/gimple.h @@ -327,15 +327,10 @@ struct gimple_statement_base GTY(()) 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 @@ -349,10 +344,10 @@ struct gimple_statement_with_ops_base GTY(()) 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. */ @@ -364,10 +359,10 @@ struct gimple_statement_with_ops GTY(()) 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; @@ -379,10 +374,10 @@ struct gimple_statement_with_memory_ops_base GTY(()) 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. */ @@ -545,20 +540,20 @@ struct gimple_statement_wce GTY(()) 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. */ @@ -916,6 +911,7 @@ extern bool walk_stmt_load_store_addr_ops (gimple, void *, 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 *); @@ -1242,41 +1238,6 @@ gimple_has_mem_ops (const_gimple g) 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. */ diff --git a/gcc/ipa-reference.c b/gcc/ipa-reference.c index d2c20c08d16..6f5c751e05b 100644 --- a/gcc/ipa-reference.c +++ b/gcc/ipa-reference.c @@ -334,6 +334,18 @@ mark_address_taken (tree x) 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 @@ -429,23 +441,18 @@ scan_stmt_for_static_refs (gimple_stmt_iterator *gsip, { 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; } diff --git a/gcc/tree-ssa-operands.c b/gcc/tree-ssa-operands.c index c9473a8f9b1..7d588f8eb96 100644 --- a/gcc/tree-ssa-operands.c +++ b/gcc/tree-ssa-operands.c @@ -686,10 +686,13 @@ add_stmt_operand (tree *var_p, gimple stmt, int flags) 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; @@ -699,27 +702,8 @@ add_to_addressable_set (tree ref, bitmap *set) 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; } @@ -763,7 +747,7 @@ get_tmr_operands (gimple stmt, tree expr, int flags) 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); } @@ -824,7 +808,7 @@ get_asm_expr_operands (gimple stmt) { 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); @@ -844,7 +828,7 @@ get_asm_expr_operands (gimple stmt) { 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); @@ -887,7 +871,7 @@ get_expr_operands (gimple stmt, tree *expr_p, int flags) 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. */ @@ -1091,14 +1075,9 @@ parse_ssa_operands (gimple stmt) 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); @@ -1133,9 +1112,6 @@ free_stmt_operands (gimple 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); diff --git a/gcc/tree-ssa.c b/gcc/tree-ssa.c index ba0c6ab720d..a36794166f5 100644 --- a/gcc/tree-ssa.c +++ b/gcc/tree-ssa.c @@ -834,7 +834,6 @@ delete_tree_ssa (void) { gimple_set_def_ops (stmt, NULL); gimple_set_use_ops (stmt, NULL); - gimple_set_addresses_taken (stmt, NULL); } if (gimple_has_mem_ops (stmt)) @@ -1504,13 +1503,12 @@ execute_update_addresses_taken (bool do_optimize) { 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) -- 2.11.0