/* Struct-reorg optimization.
- Copyright (C) 2007, 2008, 2009 Free Software Foundation, Inc.
+ Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
Contributed by Olga Golovanevsky <olga@il.ibm.com>
(Initial version of this code was developed
by Caroline Tice and Mostafa Hagog.)
#include "target.h"
#include "cgraph.h"
#include "diagnostic.h"
+#include "tree-pretty-print.h"
+#include "gimple-pretty-print.h"
#include "timevar.h"
#include "params.h"
#include "fibheap.h"
{
if (!var)
return NULL;
-
+
if (TREE_CODE (var) == PARM_DECL)
return DECL_ARG_TYPE (var);
- else
+ else
return TREE_TYPE (var);
}
-/* Set of actions we do for each newly generated STMT. */
+/* Set of actions we do for each newly generated STMT. */
static inline void
finalize_stmt (gimple stmt)
finalize_stmt (stmt);
}
-/* Given structure type SRT_TYPE and field FIELD,
- this function is looking for a field with the same name
+/* This function returns true if two fields FIELD1 and FIELD2 are
+ semantically equal, and false otherwise. */
+
+static bool
+compare_fields (tree field1, tree field2)
+{
+ if (DECL_NAME (field1) && DECL_NAME (field2))
+ {
+ const char *name1 = IDENTIFIER_POINTER (DECL_NAME (field1));
+ const char *name2 = IDENTIFIER_POINTER (DECL_NAME (field2));
+
+ gcc_assert (name1 && name2);
+
+ if (strcmp (name1, name2))
+ return false;
+
+ }
+ else if (DECL_NAME (field1) || DECL_NAME (field2))
+ return false;
+
+ if (!is_equal_types (TREE_TYPE (field1), TREE_TYPE (field2)))
+ return false;
+
+ return true;
+}
+
+/* Given structure type SRT_TYPE and field FIELD,
+ this function is looking for a field with the same name
and type as FIELD in STR_TYPE. It returns it if found,
or NULL_TREE otherwise. */
{
tree str_field;
- for (str_field = TYPE_FIELDS (str_type); str_field;
+ if (!DECL_NAME (field))
+ return NULL;
+
+ for (str_field = TYPE_FIELDS (str_type); str_field;
str_field = TREE_CHAIN (str_field))
{
- const char * str_field_name;
- const char * field_name;
- str_field_name = IDENTIFIER_POINTER (DECL_NAME (str_field));
- field_name = IDENTIFIER_POINTER (DECL_NAME (field));
-
- gcc_assert (str_field_name);
- gcc_assert (field_name);
+ if (!DECL_NAME (str_field))
+ continue;
- if (!strcmp (str_field_name, field_name))
- {
- /* Check field types. */
- if (is_equal_types (TREE_TYPE (str_field), TREE_TYPE (field)))
- return str_field;
- }
+ if (compare_fields (field, str_field))
+ return str_field;
}
return NULL_TREE;
}
-/* Given a field declaration FIELD_DECL, this function
+/* Given a field declaration FIELD_DECL, this function
returns corresponding field entry in structure STR. */
static struct field_entry *
find_field_in_struct (d_str str, tree field_decl)
{
int i;
-
+
tree field = find_field_in_struct_1 (str->decl, field_decl);
for (i = 0; i < str->num_fields; i++)
return NULL;
}
-/* This function checks whether ARG is a result of multiplication
- of some number by STRUCT_SIZE. If yes, the function returns true
+/* This function checks whether ARG is a result of multiplication
+ of some number by STRUCT_SIZE. If yes, the function returns true
and this number is filled into NUM. */
static bool
tree lhs = gimple_assign_lhs (size_def_stmt);
/* We expect temporary here. */
- if (!is_gimple_reg (lhs))
+ if (!is_gimple_reg (lhs))
return false;
if (gimple_assign_rhs_code (size_def_stmt) == MULT_EXPR)
/* This function returns true if access ACC corresponds to the pattern
- generated by compiler when an address of element i of an array
- of structures STR_DECL (pointed by p) is calculated (p[i]). If this
+ generated by compiler when an address of element i of an array
+ of structures STR_DECL (pointed by p) is calculated (p[i]). If this
pattern is recognized correctly, this function returns true
and fills missing fields in ACC. Otherwise it returns false. */
tree struct_size, op0, op1;
tree before_cast;
enum tree_code rhs_code;
-
+
ref_var = TREE_OPERAND (acc->ref, 0);
if (TREE_CODE (ref_var) != SSA_NAME)
op0 = gimple_assign_rhs1 (acc->ref_def_stmt);
op1 = gimple_assign_rhs2 (acc->ref_def_stmt);
- if (!is_array_access_through_pointer_and_index (rhs_code, op0, op1,
- &acc->base, &acc->offset,
+ if (!is_array_access_through_pointer_and_index (rhs_code, op0, op1,
+ &acc->base, &acc->offset,
&acc->cast_stmt))
return false;
if (SSA_NAME_IS_DEFAULT_DEF (before_cast))
- return false;
+ return false;
struct_size = TYPE_SIZE_UNIT (str_decl);
if (!is_result_of_mult (before_cast, &acc->num, struct_size))
return false;
+ /* ??? Add TREE_OPERAND (acc->ref, 1) to acc->offset. */
+ if (!integer_zerop (TREE_OPERAND (acc->ref, 1)))
+ return false;
+
return true;
}
-/* This function checks whether the access ACC of structure type STR
+/* This function checks whether the access ACC of structure type STR
is of the form suitable for transformation. If yes, it returns true.
False otherwise. */
{
gcc_assert (acc->ref);
- if (TREE_CODE (acc->ref) == INDIRECT_REF)
+ if (TREE_CODE (acc->ref) == MEM_REF)
return decompose_indirect_ref_acc (str_decl, acc);
else if (TREE_CODE (acc->ref) == ARRAY_REF)
return true;
static inline struct field_access_site *
make_field_acc_node (void)
{
- int size = sizeof (struct field_access_site);
-
- return (struct field_access_site *) xcalloc (1, size);
+ return XCNEW (struct field_access_site);
}
/* This function returns the structure field access, defined by STMT,
static struct field_access_site *
is_in_field_accs (gimple stmt, htab_t f_accs)
{
- return (struct field_access_site *)
+ return (struct field_access_site *)
htab_find_with_hash (f_accs, stmt, htab_hash_pointer (stmt));
}
-/* This function adds an access ACC to the hashtable
+/* This function adds an access ACC to the hashtable
F_ACCS of field accesses. */
static void
-add_field_acc_to_acc_sites (struct field_access_site *acc,
+add_field_acc_to_acc_sites (struct field_access_site *acc,
htab_t f_accs)
{
void **slot;
-
+
gcc_assert (!is_in_field_accs (acc->stmt, f_accs));
slot = htab_find_slot_with_hash (f_accs, acc->stmt,
- htab_hash_pointer (acc->stmt),
+ htab_hash_pointer (acc->stmt),
INSERT);
- *slot = acc;
+ *slot = acc;
}
-/* This function adds the VAR to vector of variables of
- an access site defined by statement STMT. If access entry
- with statement STMT does not exist in hashtable of
- accesses ACCS, this function creates it. */
+/* This function adds the VAR to vector of variables of
+ an access site defined by statement STMT. If access entry
+ with statement STMT does not exist in hashtable of
+ accesses ACCS, this function creates it. */
static void
add_access_to_acc_sites (gimple stmt, tree var, htab_t accs)
{
struct access_site *acc;
- acc = (struct access_site *)
+ acc = (struct access_site *)
htab_find_with_hash (accs, stmt, htab_hash_pointer (stmt));
if (!acc)
{
void **slot;
- acc = (struct access_site *) xmalloc (sizeof (struct access_site));
+ acc = XNEW (struct access_site);
acc->stmt = stmt;
- acc->vars = VEC_alloc (tree, heap, 10);
+ if (!is_gimple_debug (stmt))
+ acc->vars = VEC_alloc (tree, heap, 10);
+ else
+ acc->vars = NULL;
slot = htab_find_slot_with_hash (accs, stmt,
htab_hash_pointer (stmt), INSERT);
*slot = acc;
-
- }
- VEC_safe_push (tree, heap, acc->vars, var);
+ }
+ if (!is_gimple_debug (stmt))
+ VEC_safe_push (tree, heap, acc->vars, var);
}
-/* This function adds NEW_DECL to function
+/* This function adds NEW_DECL to function
referenced vars, and marks it for renaming. */
static void
finalize_var_creation (tree new_decl)
{
- add_referenced_var (new_decl);
- mark_sym_for_renaming (new_decl);
+ add_referenced_var (new_decl);
+ mark_sym_for_renaming (new_decl);
}
/* This function finalizes VAR creation if it is a global VAR_DECL. */
varpool_finalize_decl (new_decl);
}
-/* This function finalizes the creation of new variables,
- defined by *SLOT->new_vars. */
+/* This function finalizes the creation of new variables,
+ defined by *SLOT->new_vars. */
static int
finalize_new_vars_creation (void **slot, void *data ATTRIBUTE_UNUSED)
{
tree type = strip_type(get_type_of_var (n_var));
gcc_assert (type);
-
+
if (type == new_type)
return n_var;
}
}
/* This function returns new_var node, the orig_var of which is DECL.
- It looks for new_var's in NEW_VARS_HTAB. If not found,
+ It looks for new_var's in NEW_VARS_HTAB. If not found,
the function returns NULL. */
static new_var
is_in_new_vars_htab (tree decl, htab_t new_vars_htab)
{
return (new_var) htab_find_with_hash (new_vars_htab, decl,
- htab_hash_pointer (decl));
+ DECL_UID (decl));
}
/* Given original variable ORIG_VAR, this function returns
else
{
tree C = build_int_cst (TREE_TYPE (num), exact_log2 (struct_size_int));
-
+
new_stmt = gimple_build_assign (*res, fold_build2 (LSHIFT_EXPR,
TREE_TYPE (num),
num, C));
return new_stmt;
}
-/* This function generates and returns a statement, that cast variable
- BEFORE_CAST to NEW_TYPE. The cast result variable is stored
+/* This function generates and returns a statement, that cast variable
+ BEFORE_CAST to NEW_TYPE. The cast result variable is stored
into RES_P. ORIG_CAST_STMT is the original cast statement. */
static gimple
edge new_e;
tree arg;
gimple_stmt_iterator si;
-
+
new_e = make_edge (bb, e->dest, e->flags);
for (si = gsi_start_phis (new_e->dest); !gsi_end_p (si); gsi_next (&si))
{
gimple phi = gsi_stmt (si);
arg = PHI_ARG_DEF_FROM_EDGE (phi, e);
- add_phi_arg (phi, arg, new_e);
+ add_phi_arg (phi, arg, new_e, gimple_phi_arg_location_from_edge (phi, e));
}
return new_e;
if (!stmt || !new_stmt)
return;
- bsi = gsi_for_stmt (stmt);
- gsi_insert_before (&bsi, new_stmt, GSI_SAME_STMT);
+ bsi = gsi_for_stmt (stmt);
+ gsi_insert_before (&bsi, new_stmt, GSI_SAME_STMT);
}
/* Insert NEW_STMTS after STMT. */
if (!stmt || !new_stmts)
return;
- bsi = gsi_for_stmt (stmt);
- gsi_insert_seq_after (&bsi, new_stmts, GSI_SAME_STMT);
+ bsi = gsi_for_stmt (stmt);
+ gsi_insert_seq_after (&bsi, new_stmts, GSI_SAME_STMT);
}
/* Insert NEW_STMT after STMT. */
if (!stmt || !new_stmt)
return;
- bsi = gsi_for_stmt (stmt);
- gsi_insert_after (&bsi, new_stmt, GSI_SAME_STMT);
+ bsi = gsi_for_stmt (stmt);
+ gsi_insert_after (&bsi, new_stmt, GSI_SAME_STMT);
}
/* This function returns vector of allocation sites
static fallocs_t
get_fallocs (tree fn_decl)
-{
+{
return (fallocs_t) htab_find_with_hash (alloc_sites, fn_decl,
htab_hash_pointer (fn_decl));
}
/* If ALLOC_STMT is D.2225_7 = <alloc_func> (D.2224_6);
and it is a part of allocation of a structure,
- then it is usually followed by a cast stmt
+ then it is usually followed by a cast stmt
p_8 = (struct str_t *) D.2225_7;
which is returned by this function. */
if (!alloc_stmt)
return NULL;
-
+
if (!is_gimple_call (alloc_stmt))
return NULL;
return final_stmt;
}
-/* This function returns true if STMT is one of allocation
+/* This function returns true if STMT is one of allocation
sites of function FN_DECL. It returns false otherwise. */
static bool
is_part_of_malloc (gimple stmt, tree fn_decl)
{
fallocs_t fallocs = get_fallocs (fn_decl);
-
+
if (fallocs)
{
alloc_site_t *call;
gimple stmt;
};
-/* This function looks for DATA->stmt among
- the statements involved in the field access,
+/* This function looks for DATA->stmt among
+ the statements involved in the field access,
defined by SLOT. It stops when it's found. */
static int
d_str str;
};
-/* This function returns component_ref with the BASE and
+/* This function returns component_ref with the BASE and
field named FIELD_ID from structure TYPE. */
static inline tree
{
tree field;
bool found = false;
-
+
/* Find field of structure type with the same name as field_id. */
for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
}
-/* This struct represent data used for walk_tree
+/* This struct represent data used for walk_tree
called from function find_pos_in_stmt.
- - ref is a tree to be found,
+ - ref is a tree to be found,
- and pos is a pointer that points to ref in stmt. */
struct ref_pos
{
tree *pos;
tree ref;
+ tree container;
};
-/* This is a callback function for walk_tree, called from
+/* This is a callback function for walk_tree, called from
collect_accesses_in_bb function. DATA is a pointer to ref_pos structure.
When *TP is equal to DATA->ref, the walk_tree stops,
and found position, equal to TP, is assigned to DATA->pos. */
return t;
}
- *walk_subtrees = 1;
+ r_pos->container = t;
+ *walk_subtrees = 1;
return NULL_TREE;
}
It returns it, if found, and NULL otherwise. */
static tree *
-find_pos_in_stmt (gimple stmt, tree ref)
+find_pos_in_stmt (gimple stmt, tree ref, struct ref_pos * r_pos)
{
- struct ref_pos r_pos;
struct walk_stmt_info wi;
- r_pos.ref = ref;
- r_pos.pos = NULL;
+ r_pos->ref = ref;
+ r_pos->pos = NULL;
+ r_pos->container = NULL_TREE;
memset (&wi, 0, sizeof (wi));
- wi.info = &r_pos;
+ wi.info = r_pos;
walk_gimple_op (stmt, find_pos_in_stmt_1, &wi);
- return r_pos.pos;
+ return r_pos->pos;
}
-/* This structure is used to represent array
+/* This structure is used to represent array
or pointer-to wrappers of structure type.
- For example, if type1 is structure type,
- then for type1 ** we generate two type_wrapper
- structures with wrap = 0 each one.
- It's used to unwind the original type up to
- structure type, replace it with the new structure type
+ For example, if type1 is structure type,
+ then for type1 ** we generate two type_wrapper
+ structures with wrap = 0 each one.
+ It's used to unwind the original type up to
+ structure type, replace it with the new structure type
and wrap it back in the opposite order. */
typedef struct type_wrapper
bool wrap;
/* Relevant for arrays as domain or index. */
- tree domain;
+ tree domain;
}type_wrapper_t;
DEF_VEC_O (type_wrapper_t);
DEF_VEC_ALLOC_O (type_wrapper_t, heap);
-/* This function replace field access ACC by the new
+/* This function replace field access ACC by the new
field access of structure type NEW_TYPE. */
static void
tree field_id = DECL_NAME (acc->field_decl);
VEC (type_wrapper_t, heap) *wrapper = VEC_alloc (type_wrapper_t, heap, 10);
type_wrapper_t *wr_p = NULL;
-
- while (TREE_CODE (ref_var) == INDIRECT_REF
+ struct ref_pos r_pos;
+
+ while (TREE_CODE (ref_var) == MEM_REF
|| TREE_CODE (ref_var) == ARRAY_REF)
{
type_wrapper_t wr;
- if ( TREE_CODE (ref_var) == INDIRECT_REF)
+ if (TREE_CODE (ref_var) == MEM_REF)
{
wr.wrap = 0;
wr.domain = 0;
{
tree type = TREE_TYPE (TREE_TYPE (new_ref));
- wr_p = VEC_last (type_wrapper_t, wrapper);
+ wr_p = VEC_last (type_wrapper_t, wrapper);
if (wr_p->wrap) /* Array. */
- new_ref = build4 (ARRAY_REF, type, new_ref,
+ new_ref = build4 (ARRAY_REF, type, new_ref,
wr_p->domain, NULL_TREE, NULL_TREE);
else /* Pointer. */
- new_ref = build1 (INDIRECT_REF, type, new_ref);
+ new_ref = build_simple_mem_ref (new_ref);
VEC_pop (type_wrapper_t, wrapper);
}
new_acc = build_comp_ref (new_ref, field_id, new_type);
- VEC_free (type_wrapper_t, heap, wrapper);
+ VEC_free (type_wrapper_t, heap, wrapper);
if (is_gimple_assign (acc->stmt))
- {
+ {
lhs = gimple_assign_lhs (acc->stmt);
rhs = gimple_assign_rhs1 (acc->stmt);
gimple_assign_set_rhs1 (acc->stmt, new_acc);
else
{
- pos = find_pos_in_stmt (acc->stmt, acc->comp_ref);
+ pos = find_pos_in_stmt (acc->stmt, acc->comp_ref, &r_pos);
gcc_assert (pos);
*pos = new_acc;
}
}
else
{
- pos = find_pos_in_stmt (acc->stmt, acc->comp_ref);
+ pos = find_pos_in_stmt (acc->stmt, acc->comp_ref, &r_pos);
gcc_assert (pos);
*pos = new_acc;
}
-
+
finalize_stmt (acc->stmt);
}
-/* This function replace field access ACC by a new field access
+/* This function replace field access ACC by a new field access
of structure type NEW_TYPE. */
static void
replace_field_access_stmt (struct field_access_site *acc, tree new_type)
{
- if (TREE_CODE (acc->ref) == INDIRECT_REF
+ if (TREE_CODE (acc->ref) == MEM_REF
||TREE_CODE (acc->ref) == ARRAY_REF
||TREE_CODE (acc->ref) == VAR_DECL)
replace_field_acc (acc, new_type);
gcc_unreachable ();
}
-/* This function looks for d_str, represented by TYPE, in the structures
- vector. If found, it returns an index of found structure. Otherwise
+/* This function looks for d_str, represented by TYPE, in the structures
+ vector. If found, it returns an index of found structure. Otherwise
it returns a length of the structures vector. */
-
+
static unsigned
find_structure (tree type)
{
}
/* In this function we create new statements that have the same
- form as ORIG_STMT, but of type NEW_TYPE. The statements
- treated by this function are simple assignments,
- like assignments: p.8_7 = p; or statements with rhs of
+ form as ORIG_STMT, but of type NEW_TYPE. The statements
+ treated by this function are simple assignments,
+ like assignments: p.8_7 = p; or statements with rhs of
tree codes PLUS_EXPR and MINUS_EXPR. */
static gimple
gcc_assert (TREE_CODE (lhs) == VAR_DECL
|| TREE_CODE (lhs) == SSA_NAME);
-
+
new_lhs = find_new_var_of_type (lhs, new_type);
gcc_assert (new_lhs);
finalize_var_creation (new_lhs);
tree op1 = gimple_assign_rhs2 (orig_stmt);
unsigned str0, str1;
unsigned length = VEC_length (structure, structures);
-
- str0 = find_structure (strip_type (get_type_of_var (op0)));
+
+ str0 = find_structure (strip_type (get_type_of_var (op0)));
str1 = find_structure (strip_type (get_type_of_var (op1)));
gcc_assert ((str0 != length) || (str1 != length));
-
+
if (str0 != length)
new_op0 = find_new_var_of_type (op0, new_type);
if (str1 != length)
default:
gcc_unreachable();
}
-
+
new_stmt = gimple_build_assign_with_ops (gimple_assign_rhs_code (orig_stmt),
new_lhs, new_op0, new_op1);
finalize_stmt (new_stmt);
return new_stmt;
}
-/* Given a field access F_ACC of the FIELD, this function
+/* Given a field access F_ACC of the FIELD, this function
replaces it by the new field access. */
static void
gimple mult_stmt;
gimple cast_stmt;
tree cast_res = NULL;
-
+
if (f_acc->num)
{
mult_stmt = gen_size (f_acc->num, new_type, &size_res);
if (f_acc->cast_stmt)
{
- cast_stmt = gen_cast_stmt (size_res, new_type,
+ cast_stmt = gen_cast_stmt (size_res, new_type,
f_acc->cast_stmt, &cast_res);
insert_after_stmt (f_acc->cast_stmt, cast_stmt);
}
else
offset = size_res;
- new_stmt = create_base_plus_offset (f_acc->ref_def_stmt,
+ new_stmt = create_base_plus_offset (f_acc->ref_def_stmt,
new_type, offset);
insert_after_stmt (f_acc->ref_def_stmt, new_stmt);
}
replace_field_access_stmt (f_acc, new_type);
}
-/* This function creates a new condition statement
+/* This function creates a new condition statement
corresponding to the original COND_STMT, adds new basic block
- and redirects condition edges. NEW_VAR is a new condition
+ and redirects condition edges. NEW_VAR is a new condition
variable located in the condition statement at the position POS. */
static void
/* Create false and true edges from new_bb. */
make_edge_and_fix_phis_of_dest (new_bb, true_e);
make_edge_and_fix_phis_of_dest (new_bb, false_e);
-
+
/* Redirect one of original edges to point to new_bb. */
if (gimple_cond_code (cond_stmt) == NE_EXPR)
redirect_edge_succ (true_e, new_bb);
redirect_edge_succ (false_e, new_bb);
}
-/* This function creates new condition statements corresponding
- to original condition STMT, one for each new type, and
+/* This function creates new condition statements corresponding
+ to original condition STMT, one for each new type, and
recursively redirect edges to newly generated basic blocks. */
static void
gcc_assert (s0 || s1);
/* For now we allow only comparison with 0 or NULL. */
gcc_assert (integer_zerop (arg0) || integer_zerop (arg1));
-
+
str = integer_zerop (arg0) ?
- VEC_index (structure, structures, str1):
+ VEC_index (structure, structures, str1):
VEC_index (structure, structures, str0);
arg = integer_zerop (arg0) ? arg1 : arg0;
pos = integer_zerop (arg0) ? 1 : 0;
-
+
for (i = 0; VEC_iterate (tree, str->new_types, i, type); i++)
{
tree new_arg;
}
}
+/* This function looks for VAR in STMT, and replace it with NEW_VAR.
+ If needed, it wraps NEW_VAR in pointers and indirect references
+ before insertion. */
+
+static void
+insert_new_var_in_stmt (gimple stmt, tree var, tree new_var)
+{
+ struct ref_pos r_pos;
+ tree *pos;
+
+ pos = find_pos_in_stmt (stmt, var, &r_pos);
+ gcc_assert (pos);
+
+ while (r_pos.container && (TREE_CODE(r_pos.container) == MEM_REF
+ || TREE_CODE(r_pos.container) == ADDR_EXPR))
+ {
+ if (TREE_CODE(r_pos.container) == MEM_REF)
+ new_var = build_simple_mem_ref (new_var);
+ else
+ new_var = build_fold_addr_expr (new_var);
+ pos = find_pos_in_stmt (stmt, r_pos.container, &r_pos);
+ }
+
+ *pos = new_var;
+}
+
+
/* Create a new general access to replace original access ACC
for structure type NEW_TYPE. */
for (i = 0; VEC_iterate (tree, acc->vars, i, var); i++)
{
- tree *pos;
tree new_var = find_new_var_of_type (var, new_type);
tree lhs, rhs = NULL_TREE;
if (is_gimple_assign (new_stmt))
{
lhs = gimple_assign_lhs (new_stmt);
-
+
if (TREE_CODE (lhs) == SSA_NAME)
lhs = SSA_NAME_VAR (lhs);
if (gimple_assign_rhs_code (new_stmt) == SSA_NAME)
if (gimple_assign_rhs_code (new_stmt) == CONSTRUCTOR)
{
/* Dealing only with empty constructors right now. */
- gcc_assert (VEC_empty (constructor_elt,
+ gcc_assert (VEC_empty (constructor_elt,
CONSTRUCTOR_ELTS (rhs)));
rhs = build_constructor (new_type, 0);
gimple_assign_set_rhs1 (new_stmt, rhs);
}
-
+
if (lhs == var)
gimple_assign_set_lhs (new_stmt, new_var);
else if (rhs == var)
gimple_assign_set_rhs1 (new_stmt, new_var);
else
- {
- pos = find_pos_in_stmt (new_stmt, var);
- gcc_assert (pos);
- /* ??? This misses adjustments to the type of the
- INDIRECT_REF we possibly replace the operand of. */
- *pos = new_var;
- }
+ insert_new_var_in_stmt (new_stmt, var, new_var);
}
else
- {
- pos = find_pos_in_stmt (new_stmt, var);
- gcc_assert (pos);
- *pos = new_var;
- }
+ insert_new_var_in_stmt (new_stmt, var, new_var);
}
finalize_stmt (new_stmt);
}
}
-/* This function creates a new general access of structure STR
+/* This function creates a new general access of structure STR
to replace the access ACC. */
static void
create_new_stmts_for_cond_expr (stmt);
break;
+ case GIMPLE_DEBUG:
+ /* It is very hard to maintain usable debug info after struct peeling,
+ for now just reset all debug stmts referencing objects that have
+ been peeled. */
+ gimple_debug_bind_reset_value (stmt);
+ update_stmt (stmt);
+ break;
+
default:
create_new_stmts_for_general_acc (acc, str);
}
return 1;
}
-/* This function creates new accesses for the structure
+/* This function creates new accesses for the structure
type STR in basic block BB. */
static void
dt.str = str;
dt.bb = bb;
dt.field_index = -1;
-
+
for (i = 0; i < str->num_fields; i++)
{
dt.field_index = i;
if (str->fields[i].acc_sites)
- htab_traverse (str->fields[i].acc_sites,
+ htab_traverse (str->fields[i].acc_sites,
create_new_field_acc, &dt);
- }
+ }
if (str->accs)
htab_traverse (str->accs, create_new_acc, &dt);
}
-/* This function inserts new variables from new_var,
- defined by SLOT, into varpool. */
+/* This function inserts new variables from new_var,
+ defined by SLOT, into varpool. */
static int
update_varpool_with_new_var (void **slot, void *data ATTRIBUTE_UNUSED)
return 1;
}
-/* This function prints a field access site, defined by SLOT. */
+/* This function prints a field access site, defined by SLOT. */
static int
dump_field_acc (void **slot, void *data ATTRIBUTE_UNUSED)
return htab_hash_pointer (((const_fallocs_t)x)->func);
}
-/* This function returns nonzero if function of func_alloc_sites' X
+/* This function returns nonzero if function of func_alloc_sites' X
is equal to Y. */
static int
return 1;
}
-/* This is a callback function for traversal over field accesses.
+/* This is a callback function for traversal over field accesses.
It frees a field access represented by SLOT. */
static int
return 1;
}
-/* This function inserts TYPE into vector of UNSUITABLE_TYPES,
+/* This function inserts TYPE into vector of UNSUITABLE_TYPES,
if it is not there yet. */
static void
for (i = 0; VEC_iterate (tree, *unsuitable_types, i, t); i++)
if (is_equal_types (t, type))
break;
-
+
if (i == VEC_length (tree, *unsuitable_types))
VEC_safe_push (tree, heap, *unsuitable_types, type);
}
/* This function is a temporary hack to overcome the types problem.
When several compilation units are compiled together
- with -combine, the TYPE_MAIN_VARIANT of the same type
+ with -combine, the TYPE_MAIN_VARIANT of the same type
can appear differently in different compilation units.
Therefore this function first compares type names.
- If there are no names, structure bodies are recursively
+ If there are no names, structure bodies are recursively
compared. */
static bool
name1 = get_type_name (type1);
name2 = get_type_name (type2);
-
- if (name1 && name2 && !strcmp (name1, name2))
- return true;
- if (name1 && name2 && strcmp (name1, name2))
- return false;
-
+ if (name1 && name2)
+ return strcmp (name1, name2) == 0;
+
switch (TREE_CODE (type1))
{
case POINTER_TYPE:
case QUAL_UNION_TYPE:
case ENUMERAL_TYPE:
{
- tree field1;
+ tree field1, field2;
+
/* Compare fields of structure. */
- for (field1 = TYPE_FIELDS (type1); field1;
- field1 = TREE_CHAIN (field1))
+ for (field1 = TYPE_FIELDS (type1), field2 = TYPE_FIELDS (type2);
+ field1 && field2;
+ field1 = TREE_CHAIN (field1), field2 = TREE_CHAIN (field2))
{
- tree field2 = find_field_in_struct_1 (type2, field1);
- if (!field2)
+ if (!compare_fields (field1, field2))
return false;
}
- return true;
+ if (field1 || field2)
+ return false;
+ else
+ return true;
}
break;
free_accesses (htab_t accs)
{
if (accs)
- htab_traverse (accs, free_accs, NULL);
+ htab_traverse (accs, free_accs, NULL);
htab_delete (accs);
}
free_field_accesses (htab_t f_accs)
{
if (f_accs)
- htab_traverse (f_accs, free_field_accs, NULL);
+ htab_traverse (f_accs, free_field_accs, NULL);
htab_delete (f_accs);
}
return;
malloc_fn_decl = gimple_call_fndecl (malloc_stmt);
-
+
src = cgraph_node (context);
dest = cgraph_node (malloc_fn_decl);
- cgraph_create_edge (src, dest, malloc_stmt,
- 0, 0, gimple_bb (malloc_stmt)->loop_depth);
+ cgraph_create_edge (src, dest, malloc_stmt,
+ gimple_bb (malloc_stmt)->count,
+ compute_call_stmt_bb_frequency
+ (context, gimple_bb (malloc_stmt)),
+ gimple_bb (malloc_stmt)->loop_depth);
}
-/* This function generates set of statements required
+/* This function generates set of statements required
to allocate number NUM of structures of type NEW_TYPE.
The statements are stored in NEW_STMTS. The statement that contain
call to malloc is returned. MALLOC_STMT is an original call to malloc. */
gcc_assert (num && malloc_stmt && new_type);
*new_stmts = gimple_seq_alloc ();
- /* Generate argument to malloc as multiplication of num
+ /* Generate argument to malloc as multiplication of num
and size of new_type. */
new_stmt = gen_size (num, new_type, &new_malloc_size);
gimple_seq_add_stmt (new_stmts, new_stmt);
add_referenced_var (malloc_res);
malloc_fn_decl = gimple_call_fndecl (malloc_stmt);
- call_stmt = gimple_build_call (malloc_fn_decl, 1, new_malloc_size);
+ call_stmt = gimple_build_call (malloc_fn_decl, 1, new_malloc_size);
gimple_call_set_lhs (call_stmt, malloc_res);
finalize_stmt_and_append (new_stmts, call_stmt);
gcc_assert (final_stmt);
new_stmt = gen_cast_stmt (malloc_res, new_type, final_stmt, &cast_res);
gimple_seq_add_stmt (new_stmts, new_stmt);
-
- return call_stmt;
+
+ return call_stmt;
}
-/* This function returns a tree representing
- the number of instances of structure STR_DECL allocated
+/* This function returns a tree representing
+ the number of instances of structure STR_DECL allocated
by allocation STMT. If new statements are generated,
they are filled into NEW_STMTS_P. */
-static tree
+static tree
gen_num_of_structs_in_malloc (gimple stmt, tree str_decl,
gimple_seq *new_stmts_p)
{
if (TREE_CODE (arg) != SSA_NAME
&& !TREE_CONSTANT (arg))
return NULL_TREE;
-
+
struct_size = TYPE_SIZE_UNIT (str_decl);
struct_size_int = TREE_INT_CST_LOW (struct_size);
-
+
gcc_assert (struct_size);
if (TREE_CODE (arg) == SSA_NAME)
gimple div_stmt;
if (is_result_of_mult (arg, &num, struct_size))
- return num;
+ return num;
num = create_tmp_var (integer_type_node, NULL);
else
{
tree C = build_int_cst (integer_type_node,
- exact_log2 (struct_size_int));
+ exact_log2 (struct_size_int));
- div_stmt = gimple_build_assign_with_ops (RSHIFT_EXPR, num, arg, C);
+ div_stmt = gimple_build_assign_with_ops (RSHIFT_EXPR, num, arg, C);
}
gimple_seq_add_stmt (new_stmts_p, div_stmt);
finalize_stmt (div_stmt);
}
if (CONSTANT_CLASS_P (arg)
- && multiple_of_p (TREE_TYPE (struct_size), arg, struct_size))
+ && multiple_of_p (TREE_TYPE (struct_size), arg, struct_size))
return int_const_binop (TRUNC_DIV_EXPR, arg, struct_size, 0);
- return NULL_TREE;
+ return NULL_TREE;
}
/* This function is a callback for traversal on new_var's hashtable.
- SLOT is a pointer to new_var. This function prints to dump_file
- an original variable and all new variables from the new_var
- pointed by *SLOT. */
+ SLOT is a pointer to new_var. This function prints to dump_file
+ an original variable and all new variables from the new_var
+ pointed by *SLOT. */
static int
dump_new_var (void **slot, void *data ATTRIBUTE_UNUSED)
for (i = 0;
VEC_iterate (tree, n_var->new_vars, i, var); i++)
- {
+ {
var_type = get_type_of_var (var);
-
+
fprintf (dump_file, " ");
print_generic_expr (dump_file, var, 0);
fprintf (dump_file, " of type ");
/* This function copies attributes form ORIG_DECL to NEW_DECL. */
-static inline void
+static inline void
copy_decl_attributes (tree new_decl, tree orig_decl)
{
DECL_CONTEXT (new_decl) = DECL_CONTEXT (orig_decl);
TREE_THIS_VOLATILE (new_decl) = TREE_THIS_VOLATILE (orig_decl);
TREE_ADDRESSABLE (new_decl) = TREE_ADDRESSABLE (orig_decl);
-
+
if (TREE_CODE (orig_decl) == VAR_DECL)
{
TREE_READONLY (new_decl) = TREE_READONLY (orig_decl);
}
}
-/* This function wraps NEW_STR_TYPE in pointers or arrays wrapper
- the same way as a structure type is wrapped in DECL.
+/* This function wraps NEW_STR_TYPE in pointers or arrays wrapper
+ the same way as a structure type is wrapped in DECL.
It returns the generated type. */
static inline tree
VEC (type_wrapper_t, heap) *wrapper = VEC_alloc (type_wrapper_t, heap, 10);
type_wrapper_t wr;
type_wrapper_t *wr_p;
-
+
while (POINTER_TYPE_P (type_orig)
|| TREE_CODE (type_orig) == ARRAY_TYPE)
- {
+ {
if (POINTER_TYPE_P (type_orig))
{
wr.wrap = 0;
while (VEC_length (type_wrapper_t, wrapper) != 0)
{
- wr_p = VEC_last (type_wrapper_t, wrapper);
+ wr_p = VEC_last (type_wrapper_t, wrapper);
if (wr_p->wrap) /* Array. */
new_type = build_array_type (new_type, wr_p->domain);
else /* Pointer. */
new_type = build_pointer_type (new_type);
-
+
VEC_pop (type_wrapper_t, wrapper);
}
- VEC_free (type_wrapper_t, heap, wrapper);
+ VEC_free (type_wrapper_t, heap, wrapper);
return new_type;
}
|| !IDENTIFIER_POINTER (DECL_NAME (orig_decl)))
return NULL;
- /* If the original variable has a name, create an
+ /* If the original variable has a name, create an
appropriate new name for the new variable. */
old_name = IDENTIFIER_POINTER (DECL_NAME (orig_decl));
void **slot;
slot = htab_find_slot_with_hash (new_vars_htab, new_node->orig_var,
- htab_hash_pointer (new_node->orig_var),
+ DECL_UID (new_node->orig_var),
INSERT);
*slot = new_node;
}
-/* This function creates and returns new_var_data node
+/* This function creates and returns new_var_data node
with empty new_vars and orig_var equal to VAR. */
static new_var
{
new_var node;
- node = (new_var) xmalloc (sizeof (struct new_var_data));
+ node = XNEW (struct new_var_data);
node->orig_var = var;
node->new_vars = VEC_alloc (tree, heap, VEC_length (tree, str->new_types));
return node;
if (TREE_CODE (var) == VAR_DECL
&& DECL_INITIAL (var) != NULL_TREE)
initialized = true;
-
+
type = get_type_of_var (var);
if (type)
{
type = TYPE_MAIN_VARIANT (strip_type (type));
if (TREE_CODE (type) != RECORD_TYPE)
- return false;
+ return false;
else
{
if (initialized && unsuitable_types && *unsuitable_types)
{
fprintf (dump_file, "The type ");
print_generic_expr (dump_file, type, 0);
- fprintf (dump_file, " is initialized...Excluded.");
+ fprintf (dump_file, " is initialized...Excluded.");
}
add_unsuitable_type (unsuitable_types, type);
}
return htab_hash_pointer (((const struct field_access_site *)x)->stmt);
}
-/* This function returns nonzero if stmt of field_access_site X
+/* This function returns nonzero if stmt of field_access_site X
is equal to Y. */
static int
return ((const struct field_access_site *)x)->stmt == (const_gimple)y;
}
-/* This function prints an access site, defined by SLOT. */
+/* This function prints an access site, defined by SLOT. */
static int
dump_acc (void **slot, void *data ATTRIBUTE_UNUSED)
for (i = 0; VEC_iterate (tree, acc->vars, i, var); i++)
{
print_generic_expr (dump_file, var, 0);
- fprintf(dump_file, ", ");
+ fprintf(dump_file, ", ");
}
return 1;
}
if (cluster)
{
if (cluster->fields_in_cluster)
- sbitmap_free (cluster->fields_in_cluster);
+ sbitmap_free (cluster->fields_in_cluster);
if (cluster->sibling)
free_struct_cluster (cluster->sibling);
free (cluster);
if (!d_node)
return;
-
+
if (dump_file)
{
fprintf (dump_file, "\nRemoving data structure \"");
- print_generic_expr (dump_file, d_node->decl, 0);
+ print_generic_expr (dump_file, d_node->decl, 0);
fprintf (dump_file, "\" from data_struct_list.");
}
{
alloc_site_t *call;
unsigned j;
-
+
for (j = 0; VEC_iterate (alloc_site_t, m_data->allocs, j, call); j++)
{
gimple stmt = call->stmt;
insert_seq_after_stmt (last_stmt, new_stmts);
last_stmt = last_stmt_tmp;
}
-
- /* Generate an allocation sites for each new structure type. */
- for (i = 0; VEC_iterate (tree, str->new_types, i, type); i++)
+
+ /* Generate an allocation sites for each new structure type. */
+ for (i = 0; VEC_iterate (tree, str->new_types, i, type); i++)
{
gimple new_malloc_stmt = NULL;
gimple last_stmt_tmp = NULL;
}
}
-/* This function prints new variables from hashtable
+/* This function prints new variables from hashtable
NEW_VARS_HTAB to dump_file. */
static void
}
/* Given an original variable ORIG_DECL of structure type STR,
- this function generates new variables of the types defined
+ this function generates new variables of the types defined
by STR->new_type. Generated types are saved in new_var node NODE.
ORIG_DECL should has VAR_DECL tree_code. */
unsigned i;
tree type;
- for (i = 0;
+ for (i = 0;
VEC_iterate (tree, str->new_types, i, type); i++)
{
tree new_decl = NULL;
tree new_name;
new_name = gen_var_name (orig_decl, i);
- type = gen_struct_type (orig_decl, type);
+ type = gen_struct_type (orig_decl, type);
if (is_global_var (orig_decl))
new_decl = build_decl (DECL_SOURCE_LOCATION (orig_decl),
- VAR_DECL, new_name, type);
+ VAR_DECL, new_name, type);
else
{
const char *name = new_name ? IDENTIFIER_POINTER (new_name) : NULL;
- new_decl = create_tmp_var (type, name);
+ new_decl = create_tmp_var (type, name);
}
-
+
copy_decl_attributes (new_decl, orig_decl);
VEC_safe_push (tree, heap, node->new_vars, new_decl);
}
}
-/* This function creates new variables to
- substitute the original variable VAR_DECL and adds
+/* This function creates new variables to
+ substitute the original variable VAR_DECL and adds
them to the new_var's hashtable NEW_VARS_HTAB. */
static void
if (!is_candidate (var_decl, &type, NULL))
return;
-
+
i = find_structure (type);
if (i == VEC_length (structure, structures))
return;
static hashval_t
new_var_hash (const void *x)
{
- return htab_hash_pointer (((const_new_var)x)->orig_var);
+ return DECL_UID (((const_new_var)x)->orig_var);
}
-/* This function returns nonzero if orig_var of new_var X is equal to Y. */
+/* This function returns nonzero if orig_var of new_var X
+ and tree Y have equal UIDs. */
static int
new_var_eq (const void *x, const void *y)
{
- return ((const_new_var)x)->orig_var == (const_tree)y;
+ if (DECL_P ((const_tree)y))
+ return DECL_UID (((const_new_var)x)->orig_var) == DECL_UID ((const_tree)y);
+ else
+ return 0;
}
-/* This function check whether a structure type represented by STR
- escapes due to ipa-type-escape analysis. If yes, this type is added
- to UNSUITABLE_TYPES vector. */
+/* This function check whether a structure type represented by STR
+ escapes due to ipa-type-escape analysis. If yes, this type is added
+ to UNSUITABLE_TYPES vector. */
static void
check_type_escape (d_str str, VEC (tree, heap) **unsuitable_types)
return ((const struct access_site *)x)->stmt == (const_gimple)y;
}
-/* Given a structure declaration STRUCT_DECL, and number of fields
- in the structure NUM_FIELDS, this function creates and returns
+/* Given a structure declaration STRUCT_DECL, and number of fields
+ in the structure NUM_FIELDS, this function creates and returns
corresponding field_entry's. */
static struct field_entry *
tree t = TYPE_FIELDS (struct_decl);
int idx = 0;
- list =
- (struct field_entry *) xmalloc (num_fields * sizeof (struct field_entry));
+ list = XNEWVEC (struct field_entry, num_fields);
for (idx = 0 ; t; t = TREE_CHAIN (t), idx++)
if (TREE_CODE (t) == FIELD_DECL)
{
list[idx].index = idx;
list[idx].decl = t;
- list[idx].acc_sites =
+ list[idx].acc_sites =
htab_create (32, field_acc_hash, field_acc_eq, NULL);
list[idx].count = 0;
list[idx].field_mapping = NULL_TREE;
htab_traverse (accs, dump_acc, NULL);
}
-/* This function is a callback for alloc_sites hashtable
+/* This function is a callback for alloc_sites hashtable
traversal. SLOT is a pointer to fallocs_t. This function
removes all allocations of the structure defined by DATA. */
/* This function removes the structure with index I from structures vector. */
-static void
+static void
remove_structure (unsigned i)
-{
+{
d_str str;
if (i >= VEC_length (structure, structures))
return;
str = VEC_index (structure, structures, i);
-
+
/* Before removing the structure str, we have to remove its
allocations from alloc_sites hashtable. */
remove_str_allocs (str);
if (gimple_cond_code (cond_stmt) != EQ_EXPR
&& gimple_cond_code (cond_stmt) != NE_EXPR)
return false;
-
+
arg0 = gimple_cond_lhs (cond_stmt);
arg1 = gimple_cond_rhs (cond_stmt);
s0 = (str0 != length) ? true : false;
s1 = (str1 != length) ? true : false;
-
+
if (!s0 && !s1)
return false;
return true;
}
-/* This function excludes statements, that are
+/* This function excludes statements, that are
part of allocation sites or field accesses, from the
- hashtable of general accesses. SLOT represents general
- access that will be checked. DATA is a pointer to
+ hashtable of general accesses. SLOT represents general
+ access that will be checked. DATA is a pointer to
exclude_data structure. */
static int
return 1;
}
-/* Callback function for walk_tree called from collect_accesses_in_bb
+/* Callback function for walk_tree called from collect_accesses_in_bb
function. DATA is the statement which is analyzed. */
static tree
if (i != VEC_length (structure, structures))
{
+ if (is_gimple_debug (stmt))
+ {
+ d_str str;
+
+ str = VEC_index (structure, structures, i);
+ add_access_to_acc_sites (stmt, NULL, str->accs);
+ *walk_subtrees = 0;
+ break;
+ }
if (dump_file)
{
fprintf (dump_file, "\nThe type ");
print_generic_expr (dump_file, type, 0);
fprintf (dump_file, " has bitfield.");
- }
+ }
remove_structure (i);
}
}
tree field_decl = TREE_OPERAND (t, 1);
- if ((TREE_CODE (ref) == INDIRECT_REF
+ if ((TREE_CODE (ref) == MEM_REF
|| TREE_CODE (ref) == ARRAY_REF
|| TREE_CODE (ref) == VAR_DECL)
&& TREE_CODE (field_decl) == FIELD_DECL)
if (i != VEC_length (structure, structures))
{
d_str str = VEC_index (structure, structures, i);
- struct field_entry * field =
+ struct field_entry * field =
find_field_in_struct (str, field_decl);
+ if (is_gimple_debug (stmt))
+ {
+ add_access_to_acc_sites (stmt, NULL, str->accs);
+ *walk_subtrees = 0;
+ break;
+ }
+
if (field)
{
struct field_access_site *acc = make_field_acc_node ();
acc->ref = ref;
acc->field_decl = field_decl;
- /* Check whether the access is of the form
+ /* Check whether the access is of the form
we can deal with. */
if (!decompose_access (str->decl, acc))
{
{
fprintf (dump_file, "\nThe type ");
print_generic_expr (dump_file, type, 0);
- fprintf (dump_file,
+ fprintf (dump_file,
" has complicate access in statement ");
print_gimple_stmt (dump_file, stmt, 0, 0);
}
-
+
remove_structure (i);
free (acc);
}
}
*walk_subtrees = 0;
}
- }
+ }
}
}
break;
*walk_subtrees = 1;
walk_tree (&t, get_stmt_accesses, data, NULL);
}
- *walk_subtrees = 0;
+ *walk_subtrees = 0;
}
break;
}
/* This function is a callback for traversal over new_var's hashtable.
- SLOT is a pointer to new_var. This function frees memory allocated
+ SLOT is a pointer to new_var. This function frees memory allocated
for new_var and pointed by *SLOT. */
static int
free_new_vars_htab (htab_t new_vars_htab)
{
if (new_vars_htab)
- htab_traverse (new_vars_htab, free_new_var, NULL);
+ htab_traverse (new_vars_htab, free_new_var, NULL);
htab_delete (new_vars_htab);
new_vars_htab = NULL;
}
{
tree var;
referenced_var_iterator rvi;
-
- new_local_vars = htab_create (num_referenced_vars,
+
+ new_local_vars = htab_create (num_referenced_vars,
new_var_hash, new_var_eq, NULL);
FOR_EACH_REFERENCED_VAR (var, rvi)
}
if (new_local_vars)
- htab_traverse (new_local_vars, finalize_new_vars_creation, NULL);
+ htab_traverse (new_local_vars, finalize_new_vars_creation, NULL);
dump_new_vars (new_local_vars);
}
unsigned HOST_WIDE_INT sh = shift;
while (sh--)
- fprintf (dump_file, " ");
+ fprintf (dump_file, " ");
}
/* This function updates field_mapping of FIELDS in CLUSTER with NEW_TYPE. */
for (i = 0; i < num_fields; i++)
if (TEST_BIT (cluster->fields_in_cluster, i))
- fields[i].field_mapping = new_type;
+ fields[i].field_mapping = new_type;
}
-/* This functions builds structure with FIELDS,
- NAME and attributes similar to ORIG_STRUCT.
+/* This functions builds structure with FIELDS,
+ NAME and attributes similar to ORIG_STRUCT.
It returns the newly created structure. */
static tree
attributes = unshare_expr (TYPE_ATTRIBUTES (orig_struct));
ref = make_node (RECORD_TYPE);
TYPE_SIZE (ref) = 0;
- decl_attributes (&ref, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
+ decl_attributes (&ref, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE);
TYPE_PACKED (ref) = TYPE_PACKED (orig_struct);
for (x = fields; x; x = TREE_CHAIN (x))
{
return ref;
}
-/* This function copies FIELDS from CLUSTER into TREE_CHAIN as part
- of preparation for new structure building. NUM_FIELDS is a total
- number of fields in the structure. The function returns newly
+/* This function copies FIELDS from CLUSTER into TREE_CHAIN as part
+ of preparation for new structure building. NUM_FIELDS is a total
+ number of fields in the structure. The function returns newly
generated fields. */
static tree
-create_fields (struct field_cluster * cluster,
+create_fields (struct field_cluster * cluster,
struct field_entry * fields, int num_fields)
{
int i;
}
-/* This function creates a cluster name. The name is based on
+/* This function creates a cluster name. The name is based on
the original structure name, if it is present. It has a form:
-
+
<original_struct_name>_sub.<CLUST_NUM>
The original structure name is taken from the type of DECL.
char * prefix;
char * new_name;
size_t len;
-
+
if (!orig_name)
ASM_FORMAT_PRIVATE_NAME(tmp_name, "struct", str_num);
len = strlen (tmp_name ? tmp_name : orig_name) + strlen ("_sub");
prefix = XALLOCAVEC (char, len + 1);
- memcpy (prefix, tmp_name ? tmp_name : orig_name,
+ memcpy (prefix, tmp_name ? tmp_name : orig_name,
strlen (tmp_name ? tmp_name : orig_name));
- strcpy (prefix + strlen (tmp_name ? tmp_name : orig_name), "_sub");
-
+ strcpy (prefix + strlen (tmp_name ? tmp_name : orig_name), "_sub");
+
ASM_FORMAT_PRIVATE_NAME (new_name, prefix, clust_num);
return get_identifier (new_name);
}
}
}
-/* This function adds to UNSUITABLE_TYPES those types that escape
+/* This function adds to UNSUITABLE_TYPES those types that escape
due to results of ipa-type-escape analysis. See ipa-type-escape.[c,h]. */
static void
}
}
-/* This function looks for parameters of local functions
- which are of structure types, or derived from them (arrays
+/* This function looks for parameters of local functions
+ which are of structure types, or derived from them (arrays
of structures, pointers to structures, or their combinations).
We are not handling peeling of such structures right now.
The found structures types are added to UNSUITABLE_TYPES vector. */
{
tree fn = c_node->decl;
tree arg;
-
- for (arg = DECL_ARGUMENTS (fn); arg; arg = TREE_CHAIN (arg))
+
+ for (arg = DECL_ARGUMENTS (fn); arg; arg = DECL_CHAIN (arg))
{
tree type = TREE_TYPE (arg);
type = strip_type (type);
if (TREE_CODE (type) == RECORD_TYPE)
{
- add_unsuitable_type (unsuitable_types,
+ add_unsuitable_type (unsuitable_types,
TYPE_MAIN_VARIANT (type));
if (dump_file)
{
fprintf (dump_file, "\nPointer to type \"");
print_generic_expr (dump_file, type, 0);
- fprintf (dump_file,
- "\" is passed to local function...Excluded.");
+ fprintf (dump_file,
+ "\" is passed to local function...Excluded.");
}
}
}
}
}
-/* This function analyzes structure form of structures
+/* This function analyzes structure form of structures
potential for transformation. If we are not capable to transform
structure of some form, we remove it from the structures hashtable.
- Right now we cannot handle nested structs, when nesting is
- through any level of pointers or arrays.
+ Right now we cannot handle nested structs, when nesting is
+ through any level of pointers or arrays.
TBD: release these constrains in future.
- Note, that in this function we suppose that all structures
- in the program are members of the structures hashtable right now,
+ Note, that in this function we suppose that all structures
+ in the program are members of the structures hashtable right now,
without excluding escaping types. */
static void
for (i = 0; i < str->num_fields; i++)
{
tree f_type = strip_type(TREE_TYPE (str->fields[i].decl));
-
+
if (TREE_CODE (f_type) == RECORD_TYPE)
{
add_unsuitable_type (unsuitable_types, TYPE_MAIN_VARIANT (f_type));
if (dump_file)
{
fprintf (dump_file, "\nAdding data structure \"");
- print_generic_expr (dump_file, type, 0);
+ print_generic_expr (dump_file, type, 0);
fprintf (dump_file, "\" to data_struct_list.");
}
}
/* This function adds an allocation site to alloc_sites hashtable.
- The allocation site appears in STMT of function FN_DECL and
+ The allocation site appears in STMT of function FN_DECL and
allocates the structure represented by STR. */
static void
m_call.stmt = stmt;
m_call.str = str;
- fallocs =
+ fallocs =
(fallocs_t) htab_find_with_hash (alloc_sites,
fn_decl, htab_hash_pointer (fn_decl));
{
void **slot;
- fallocs = (fallocs_t)
- xmalloc (sizeof (struct func_alloc_sites));
+ fallocs = XNEW (struct func_alloc_sites);
fallocs->func = fn_decl;
fallocs->allocs = VEC_alloc (alloc_site_t, heap, 1);
slot = htab_find_slot_with_hash (alloc_sites, fn_decl,
htab_hash_pointer (fn_decl), INSERT);
*slot = fallocs;
}
- VEC_safe_push (alloc_site_t, heap,
+ VEC_safe_push (alloc_site_t, heap,
fallocs->allocs, &m_call);
-
+
if (dump_file)
{
fprintf (dump_file, "\nAdding stmt ");
/* This function returns true if the result of STMT, that contains a call
to an allocation function, is cast to one of the structure types.
STMT should be of the form: T.2 = <alloc_func> (T.1);
- If true, I_P contains an index of an allocated structure.
+ If true, I_P contains an index of an allocated structure.
Otherwise I_P contains the length of the vector of structures. */
static bool
lhs = gimple_assign_lhs (final_stmt);
type = get_type_of_var (lhs);
-
+
if (!type)
return false;
return true;
}
-/* This function prints non-field and field accesses
- of the structure STR. */
+/* This function prints non-field and field accesses
+ of the structure STR. */
static void
dump_accs (d_str str)
{
fprintf (dump_file, "\nAccess site of field ");
print_generic_expr (dump_file, str->fields[i].decl, 0);
- dump_field_acc_sites (str->fields[i].acc_sites);
+ dump_field_acc_sites (str->fields[i].acc_sites);
fprintf (dump_file, ":\n");
}
fprintf (dump_file, "\nGeneral access sites\n");
- dump_access_sites (str->accs);
+ dump_access_sites (str->accs);
}
/* This function checks whether an access statement, pointed by SLOT,
is a condition we are capable to transform. It returns false if not,
setting bool *DATA to false. */
-
+
static int
safe_cond_expr_check (void **slot, void *data)
{
dt.fn_decl = node->decl;
if (dt.str->accs)
- htab_traverse (dt.str->accs, exclude_from_accs, &dt);
+ htab_traverse (dt.str->accs, exclude_from_accs, &dt);
}
/* Collect accesses to the structure types that appear in basic block BB. */
static void
gen_cluster (sbitmap fields, d_str str)
{
- struct field_cluster *crr_cluster = NULL;
+ struct field_cluster *crr_cluster = XCNEW (struct field_cluster);
- crr_cluster =
- (struct field_cluster *) xcalloc (1, sizeof (struct field_cluster));
crr_cluster->sibling = str->struct_clustering;
str->struct_clustering = crr_cluster;
crr_cluster->fields_in_cluster = fields;
static void
peel_field (int i, d_str ds)
{
- struct field_cluster *crr_cluster = NULL;
+ struct field_cluster *crr_cluster = XCNEW (struct field_cluster);
- crr_cluster =
- (struct field_cluster *) xcalloc (1, sizeof (struct field_cluster));
crr_cluster->sibling = ds->struct_clustering;
ds->struct_clustering = crr_cluster;
crr_cluster->fields_in_cluster =
sbitmap_alloc ((unsigned int) ds->num_fields);
sbitmap_zero (crr_cluster->fields_in_cluster);
- SET_BIT (crr_cluster->fields_in_cluster, i);
+ SET_BIT (crr_cluster->fields_in_cluster, i);
}
-/* This function calculates maximum field count in
+/* This function calculates maximum field count in
the structure STR. */
static gcov_type
for (i = 0; i < str->num_fields; i++)
if (str->fields[i].count > max)
- max = str->fields[i].count;
+ max = str->fields[i].count;
return max;
}
-/* Do struct-reorg transformation for individual function
- represented by NODE. All structure types relevant
+/* Do struct-reorg transformation for individual function
+ represented by NODE. All structure types relevant
for this function are transformed. */
static void
do_reorg_for_func (struct cgraph_node *node)
{
- create_new_local_vars ();
+ create_new_local_vars ();
create_new_alloc_sites_for_func (node);
create_new_accesses_for_func ();
update_ssa (TODO_update_ssa);
cleanup_tree_cfg ();
+ cgraph_rebuild_references ();
/* Free auxiliary data representing local variables. */
- free_new_vars_htab (new_local_vars);
+ free_new_vars_htab (new_local_vars);
}
/* Print structure TYPE, its name, if it exists, and body.
- INDENT defines the level of indentation (similar
- to the option -i of indent command). SHIFT parameter
- defines a number of spaces by which a structure will
+ INDENT defines the level of indentation (similar
+ to the option -i of indent command). SHIFT parameter
+ defines a number of spaces by which a structure will
be shifted right. */
static void
print_generic_expr (dump_file, type, 0);
return;
}
-
+
print_shift (shift);
- struct_name = get_type_name (type);
+ struct_name = get_type_name (type);
fprintf (dump_file, "struct ");
- if (struct_name)
+ if (struct_name)
fprintf (dump_file, "%s\n",struct_name);
print_shift (shift);
fprintf (dump_file, "{\n");
-
- for (field = TYPE_FIELDS (type); field;
+
+ for (field = TYPE_FIELDS (type); field;
field = TREE_CHAIN (field))
{
unsigned HOST_WIDE_INT s = indent;
tree f_type = TREE_TYPE (field);
-
+
print_shift (shift);
while (s--)
fprintf (dump_file, " ");
fprintf (dump_file, "}\n");
}
-/* This function creates new structure types to replace original type,
- indicated by STR->decl. The names of the new structure types are
- derived from the original structure type. If the original structure
+/* This function creates new structure types to replace original type,
+ indicated by STR->decl. The names of the new structure types are
+ derived from the original structure type. If the original structure
type has no name, we assume that its name is 'struct.<STR_NUM>'. */
static void
struct field_cluster *cluster = str->struct_clustering;
while (cluster)
- {
- tree name = gen_cluster_name (str->decl, cluster_num,
+ {
+ tree name = gen_cluster_name (str->decl, cluster_num,
*str_num);
tree fields;
tree new_type;
cluster_num++;
-
- fields = create_fields (cluster, str->fields,
+
+ fields = create_fields (cluster, str->fields,
str->num_fields);
new_type = build_basic_struct (fields, name, str->decl);
-
- update_fields_mapping (cluster, new_type,
+
+ update_fields_mapping (cluster, new_type,
str->fields, str->num_fields);
VEC_safe_push (tree, heap, str->new_types, new_type);
- cluster = cluster->sibling;
+ cluster = cluster->sibling;
}
(*str_num)++;
}
-/* This function is a callback for alloc_sites hashtable
- traversal. SLOT is a pointer to fallocs_t.
+/* This function is a callback for alloc_sites hashtable
+ traversal. SLOT is a pointer to fallocs_t.
This function frees memory pointed by *SLOT. */
static int
}
/* Exclude structure types with bitfields.
- We would not want to interfere with other optimizations
- that can be done in this case. The structure types with
+ We would not want to interfere with other optimizations
+ that can be done in this case. The structure types with
bitfields are added to UNSUITABLE_TYPES vector. */
static void
1. if it's a type of parameter of a local function.
2. if it's a type of function return value.
- 3. if it escapes as a result of ipa-type-escape analysis.
+ 3. if it escapes as a result of ipa-type-escape analysis.
The escaping structure types are added to UNSUITABLE_TYPES vector. */
exclude_escaping_types_1 (unsuitable_types);
}
-/* This function analyzes whether the form of
- structure is such that we are capable to transform it.
+/* This function analyzes whether the form of
+ structure is such that we are capable to transform it.
Nested structures are checked here. Unsuitable structure
types are added to UNSUITABLE_TYPE vector. */
check_struct_form (str, unsuitable_types);
}
-/* This function looks for structure types instantiated in the program.
- The candidate types are added to the structures vector.
+/* This function looks for structure types instantiated in the program.
+ The candidate types are added to the structures vector.
Unsuitable types are collected into UNSUITABLE_TYPES vector. */
static void
build_data_structure (VEC (tree, heap) **unsuitable_types)
{
tree var, type;
- tree var_list;
struct varpool_node *current_varpool;
struct cgraph_node *c_node;
- /* Check global variables. */
+ /* Check global variables. */
FOR_EACH_STATIC_VARIABLE (current_varpool)
{
var = current_varpool->decl;
add_structure (type);
}
- /* Now add structures that are types of function parameters and
+ /* Now add structures that are types of function parameters and
local variables. */
for (c_node = cgraph_nodes; c_node; c_node = c_node->next)
{
- enum availability avail =
+ enum availability avail =
cgraph_function_body_availability (c_node);
/* We need AVAIL_AVAILABLE for main function. */
if (avail == AVAIL_LOCAL || avail == AVAIL_AVAILABLE)
{
struct function *fn = DECL_STRUCT_FUNCTION (c_node->decl);
+ unsigned ix;
- for (var = DECL_ARGUMENTS (c_node->decl); var;
+ for (var = DECL_ARGUMENTS (c_node->decl); var;
var = TREE_CHAIN (var))
if (is_candidate (var, &type, unsuitable_types))
add_structure (type);
- /* Check function local variables. */
- for (var_list = fn->local_decls; var_list;
- var_list = TREE_CHAIN (var_list))
+ if (fn == NULL)
{
- var = TREE_VALUE (var_list);
-
- if (is_candidate (var, &type, unsuitable_types))
- add_structure (type);
+ /* Skip cones that haven't been materialized yet. */
+ gcc_assert (c_node->clone_of
+ && c_node->clone_of->decl != c_node->decl);
+ continue;
}
+
+ /* Check function local variables. */
+ FOR_EACH_LOCAL_DECL (fn, ix, var)
+ if (is_candidate (var, &type, unsuitable_types))
+ add_structure (type);
}
}
}
-/* This function returns true if the program contains
+/* This function returns true if the program contains
a call to user defined allocation function, or other
functions that can interfere with struct-reorg optimizations. */
struct cgraph_node *c_node;
struct cgraph_node *c_node2;
struct cgraph_edge *c_edge;
- tree fndecl;
tree fndecl2;
-
+
for (c_node = cgraph_nodes; c_node; c_node = c_node->next)
{
- fndecl = c_node->decl;
-
for (c_edge = c_node->callees; c_edge; c_edge = c_edge->next_callee)
{
c_node2 = c_edge->callee;
if (DECL_FUNCTION_CODE (fndecl2) == BUILT_IN_OBJECT_SIZE
|| !strcmp (fname, "__builtin_offsetof")
|| !strcmp (fname, "realloc"))
- return true;
+ return true;
}
}
}
-
+
return false;
}
-/* In this function we assume that an allocation statement
+/* In this function we assume that an allocation statement
var = (type_cast) malloc (size);
-
+
is converted into the following set of statements:
T.1 = size;
T.3 = (type_cast) T.2;
var = T.3;
- In this function we collect into alloc_sites the allocation
- sites of variables of structure types that are present
+ In this function we collect into alloc_sites the allocation
+ sites of variables of structure types that are present
in structures vector. */
static void
tree decl;
if (is_gimple_call (stmt)
- && (decl = gimple_call_fndecl (stmt))
+ && (decl = gimple_call_fndecl (stmt))
&& gimple_call_lhs (stmt))
{
unsigned i;
if (DECL_FUNCTION_CODE (decl) == BUILT_IN_MALLOC)
{
d_str str;
-
+
str = VEC_index (structure, structures, i);
add_alloc_site (node->decl, stmt, str);
}
{
if (dump_file)
{
- fprintf (dump_file,
+ fprintf (dump_file,
"\nUnsupported allocation function ");
print_gimple_stmt (dump_file, stmt, 0, 0);
}
- remove_structure (i);
+ remove_structure (i);
}
}
}
- }
+ }
}
}
}
dump_accs (str);
}
-/* This function checks whether the accesses of structures in condition
- expressions are of the kind we are capable to transform.
+/* This function checks whether the accesses of structures in condition
+ expressions are of the kind we are capable to transform.
If not, such structures are removed from the vector of structures. */
static void
}
}
-/* We exclude from non-field accesses of the structure
- all statements that will be treated as part of the structure
+/* We exclude from non-field accesses of the structure
+ all statements that will be treated as part of the structure
allocation sites or field accesses. */
static void
exclude_alloc_and_field_accs_1 (str, node);
}
-/* This function collects accesses of the fields of the structures
+/* This function collects accesses of the fields of the structures
that appear at function FN. */
static void
sum_counts (d_str str, gcov_type *hottest)
{
int i;
-
+
str->count = 0;
for (i = 0; i < str->num_fields; i++)
{
{
fprintf (dump_file, "\nCounter of field \"");
print_generic_expr (dump_file, str->fields[i].decl, 0);
- fprintf (dump_file, "\" is " HOST_WIDEST_INT_PRINT_DEC,
+ fprintf (dump_file, "\" is " HOST_WIDEST_INT_PRINT_DEC,
str->fields[i].count);
}
str->count += str->fields[i].count;
}
/* This function peels the field into separate structure if it's
- sufficiently hot, i.e. if its count provides at least 90% of
+ sufficiently hot, i.e. if its count provides at least 90% of
the maximum field count in the structure. */
static void
int i;
sbitmap_ones (fields_left);
- max_field_count =
+ max_field_count =
(gcov_type) (get_max_field_count (str)/100)*90;
str->struct_clustering = NULL;
{
if (str->count >= max_field_count)
{
- RESET_BIT (fields_left, i);
+ RESET_BIT (fields_left, i);
peel_field (i, str);
}
}
gen_cluster (fields_left, str);
else
sbitmap_free (fields_left);
-}
+}
-/* This function is a helper for do_reorg. It goes over
- functions in call graph and performs actual transformation
+/* This function is a helper for do_reorg. It goes over
+ functions in call graph and performs actual transformation
on them. */
static void
}
/* This function creates new global struct variables.
- For each original variable, the set of new variables
- is created with the new structure types corresponding
- to the structure type of original variable.
+ For each original variable, the set of new variables
+ is created with the new structure types corresponding
+ to the structure type of original variable.
Only VAR_DECL variables are treated by this function. */
-static void
+static void
create_new_global_vars (void)
{
struct varpool_node *current_varpool;
for (i = 0; i < 2; i++)
{
if (i)
- new_global_vars = htab_create (varpool_size,
+ new_global_vars = htab_create (varpool_size,
new_var_hash, new_var_eq, NULL);
FOR_EACH_STATIC_VARIABLE(current_varpool)
{
dump_struct_type (str->decl, 2, 0);
fprintf (dump_file, "\nthe number of new types is %d\n",
VEC_length (tree, str->new_types));
- }
+ }
for (j = 0; VEC_iterate (tree, str->new_types, j, type); j++)
- dump_struct_type (type, 2, 0);
+ dump_struct_type (type, 2, 0);
}
}
free_alloc_sites (void)
{
if (alloc_sites)
- htab_traverse (alloc_sites, free_falloc_sites, NULL);
+ htab_traverse (alloc_sites, free_falloc_sites, NULL);
htab_delete (alloc_sites);
alloc_sites = NULL;
}
-/* This function collects structures potential
- for peeling transformation, and inserts
+/* This function collects structures potential
+ for peeling transformation, and inserts
them into structures hashtable. */
-static void
+static void
collect_structures (void)
{
VEC (tree, heap) *unsuitable_types = VEC_alloc (tree, heap, 32);
structures = VEC_alloc (structure, heap, 32);
-
+
/* If program contains user defined mallocs, we give up. */
if (program_redefines_malloc_p ())
- return;
+ return;
- /* Build data structures hashtable of all data structures
+ /* Build data structures hashtable of all data structures
in the program. */
build_data_structure (&unsuitable_types);
- /* This function analyzes whether the form of
- structure is such that we are capable to transform it.
+ /* This function analyzes whether the form of
+ structure is such that we are capable to transform it.
Nested structures are checked here. */
analyze_struct_form (&unsuitable_types);
- /* This function excludes those structure types
+ /* This function excludes those structure types
that escape compilation unit. */
exclude_escaping_types (&unsuitable_types);
collect_alloc_sites ();
}
-/* This function collects data accesses for the
- structures to be transformed. For each structure
+/* This function collects data accesses for the
+ structures to be transformed. For each structure
field it updates the count field in field_entry. */
-static void
+static void
collect_data_accesses (void)
{
struct cgraph_node *c_node;
}
/* We do not bother to transform cold structures.
- Coldness of the structure is defined relatively
- to the highest structure count among the structures
+ Coldness of the structure is defined relatively
+ to the highest structure count among the structures
to be transformed. It's triggered by the compiler parameter
--param struct-reorg-cold-struct-ratio=<value>
i++;
}
-/* This function decomposes original structure into substructures,
+/* This function decomposes original structure into substructures,
i.e.clusters. */
static void
/* Create new global variables. */
create_new_global_vars ();
- dump_new_vars (new_global_vars);
+ dump_new_vars (new_global_vars);
/* Decompose structures for each function separately. */
do_reorg_1 ();
/* Free auxiliary data collected for global variables. */
- free_new_vars_htab (new_global_vars);
+ free_new_vars_htab (new_global_vars);
}
/* Free all auxiliary data used by this optimization. */
free_data_structs (void)
{
free_structures ();
- free_alloc_sites ();
+ free_alloc_sites ();
}
/* Perform structure decomposition (peeling). */
reorg_structs (void)
{
- /* Stage1. */
+ /* Stage1. */
/* Collect structure types. */
collect_structures ();
/* Collect structure allocation sites. */
- collect_allocation_sites ();
+ collect_allocation_sites ();
/* Collect structure accesses. */
- collect_data_accesses ();
+ collect_data_accesses ();
/* We transform only hot structures. */
exclude_cold_structs ();
/* Decompose structures into substructures, i.e. clusters. */
peel_structs ();
- /* Stage3. */
+ /* Stage3. */
/* Do the actual transformation for each structure
from the structures hashtable. */
do_reorg ();
/* Free all auxiliary data used by this optimization. */
- free_data_structs ();
+ free_data_structs ();
}
/* Struct-reorg optimization entry point function. */
static unsigned int
reorg_structs_drive (void)
{
- reorg_structs ();
+ /* IPA struct-reorg is completely broken - its analysis phase is
+ non-conservative (which is not the only reason it is broken). */
+ if (0)
+ reorg_structs ();
return 0;
}
struct_reorg_gate (void)
{
return flag_ipa_struct_reorg
- && flag_whole_program
+ && flag_whole_program
&& (optimize > 0);
}
-struct simple_ipa_opt_pass pass_ipa_struct_reorg =
+struct simple_ipa_opt_pass pass_ipa_struct_reorg =
{
{
SIMPLE_IPA_PASS,