#include "langhooks.h"
#include "pointer-set.h"
#include "hashtab.h"
-#include "toplev.h"
#include "flags.h"
#include "debug.h"
#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 (!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;
}
{
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,
{
void **slot;
- acc = (struct access_site *) xmalloc (sizeof (struct access_site));
+ acc = XNEW (struct access_site);
acc->stmt = stmt;
if (!is_gimple_debug (stmt))
acc->vars = VEC_alloc (tree, heap, 10);
unsigned i;
tree var;
- for (i = 0; VEC_iterate (tree, n_var->new_vars, i, var); i++)
+ FOR_EACH_VEC_ELT (tree, n_var->new_vars, i, var)
finalize_var_creation (var);
return 1;
}
tree n_var;
unsigned i;
- for (i = 0; VEC_iterate (tree, var->new_vars, i, n_var); i++)
+ FOR_EACH_VEC_ELT (tree, var->new_vars, i, n_var)
{
tree type = strip_type(get_type_of_var (n_var));
gcc_assert (type);
alloc_site_t *call;
unsigned i;
- for (i = 0; VEC_iterate (alloc_site_t, fallocs->allocs, i, call); i++)
+ FOR_EACH_VEC_ELT (alloc_site_t, fallocs->allocs, i, call)
if (call->stmt == stmt
|| get_final_alloc_stmt (call->stmt) == stmt)
return true;
type_wrapper_t *wr_p = NULL;
struct ref_pos r_pos;
- while (TREE_CODE (ref_var) == INDIRECT_REF
+ 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;
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);
}
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);
type = TYPE_MAIN_VARIANT (type);
- for (i = 0; VEC_iterate (structure, structures, i, str); i++)
+ FOR_EACH_VEC_ELT (structure, structures, i, str)
if (is_equal_types (str->decl, type))
return i;
arg = integer_zerop (arg0) ? arg1 : arg0;
pos = integer_zerop (arg0) ? 1 : 0;
- for (i = 0; VEC_iterate (tree, str->new_types, i, type); i++)
+ FOR_EACH_VEC_ELT (tree, str->new_types, i, type)
{
tree new_arg;
pos = find_pos_in_stmt (stmt, var, &r_pos);
gcc_assert (pos);
- while (r_pos.container && (TREE_CODE(r_pos.container) == INDIRECT_REF
+ while (r_pos.container && (TREE_CODE(r_pos.container) == MEM_REF
|| TREE_CODE(r_pos.container) == ADDR_EXPR))
{
- tree type = TREE_TYPE (TREE_TYPE (new_var));
-
- if (TREE_CODE(r_pos.container) == INDIRECT_REF)
- new_var = build1 (INDIRECT_REF, type, new_var);
+ 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);
gimple_set_vdef (new_stmt, NULL_TREE);
}
- for (i = 0; VEC_iterate (tree, acc->vars, i, var); i++)
+ FOR_EACH_VEC_ELT (tree, acc->vars, i, var)
{
tree new_var = find_new_var_of_type (var, new_type);
tree lhs, rhs = NULL_TREE;
gimple stmt = acc->stmt;
unsigned i;
- for (i = 0; VEC_iterate (tree, str->new_types, i, type); i++)
+ FOR_EACH_VEC_ELT (tree, str->new_types, i, type)
{
gimple new_stmt;
for now just reset all debug stmts referencing objects that have
been peeled. */
gimple_debug_bind_reset_value (stmt);
+ update_stmt (stmt);
break;
default:
tree var;
unsigned i;
- for (i = 0; VEC_iterate (tree, n_var->new_vars, i, var); i++)
+ FOR_EACH_VEC_ELT (tree, n_var->new_vars, i, var)
insert_global_to_varpool (var);
return 1;
}
type = TYPE_MAIN_VARIANT (type);
- for (i = 0; VEC_iterate (tree, *unsuitable_types, i, t); i++)
+ FOR_EACH_VEC_ELT (tree, *unsuitable_types, i, t)
if (is_equal_types (t, type))
break;
{
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;
print_gimple_stmt (dump_file, acc->stmt, 0, 0);
fprintf(dump_file, " : ");
- for (i = 0; VEC_iterate (tree, acc->vars, i, var); i++)
+ FOR_EACH_VEC_ELT (tree, acc->vars, i, var)
{
print_generic_expr (dump_file, var, 0);
fprintf(dump_file, ", ");
d_str str;
unsigned i;
- for (i = 0; VEC_iterate (structure, structures, i, str); i++)
+ FOR_EACH_VEC_ELT (structure, structures, i, str)
create_new_accs_for_struct (str, bb);
}
alloc_site_t *call;
unsigned j;
- for (j = 0; VEC_iterate (alloc_site_t, m_data->allocs, j, call); j++)
+ FOR_EACH_VEC_ELT (alloc_site_t, m_data->allocs, j, call)
{
gimple stmt = call->stmt;
d_str str = call->str;
}
/* Generate an allocation sites for each new structure type. */
- for (i = 0; VEC_iterate (tree, str->new_types, i, type); i++)
+ FOR_EACH_VEC_ELT (tree, str->new_types, i, type)
{
gimple new_malloc_stmt = NULL;
gimple last_stmt_tmp = NULL;
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)
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)
d_str str;
unsigned i;
- for (i = 0; VEC_iterate (structure, structures, i, str); i++)
+ FOR_EACH_VEC_ELT (structure, structures, i, str)
free_data_struct (str);
VEC_free (structure, heap, structures);
d_str str;
unsigned i;
- for (i = 0; VEC_iterate (structure, structures, i, str); i++)
+ FOR_EACH_VEC_ELT (structure, structures, i, str)
check_type_escape (str, unsuitable_types);
}
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);
{
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,
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 =
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);
tree type;
unsigned i, j;
- for (j = 0; VEC_iterate (tree, unsuitable_types, j, type); j++)
- for (i = 0; VEC_iterate (structure, structures, i, str); i++)
+ FOR_EACH_VEC_ELT (tree, unsuitable_types, j, type)
+ FOR_EACH_VEC_ELT (structure, structures, i, str)
if (is_equal_types (str->decl, type))
{
remove_structure (i);
d_str str;
unsigned i;
- for (i = 0; VEC_iterate (structure, structures, i, str); i++)
+ FOR_EACH_VEC_ELT (structure, structures, i, str)
check_bitfields (str, unsuitable_types);
}
d_str str;
unsigned i;
- for (i = 0; VEC_iterate (structure, structures, i, str); i++)
+ FOR_EACH_VEC_ELT (structure, structures, i, str)
check_struct_form (str, unsuitable_types);
}
build_data_structure (VEC (tree, heap) **unsuitable_types)
{
tree var, type;
- tree var_list;
struct varpool_node *current_varpool;
struct cgraph_node *c_node;
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;
var = TREE_CHAIN (var))
}
/* Check function local variables. */
- for (var_list = fn->local_decls; var_list;
- var_list = TREE_CHAIN (var_list))
- {
- var = TREE_VALUE (var_list);
-
- if (is_candidate (var, &type, unsuitable_types))
- add_structure (type);
- }
+ FOR_EACH_LOCAL_DECL (fn, ix, var)
+ if (is_candidate (var, &type, unsuitable_types))
+ add_structure (type);
}
}
}
if (!dump_file)
return;
- for (i = 0; VEC_iterate (structure, structures, i, str); i++)
+ FOR_EACH_VEC_ELT (structure, structures, i, str)
dump_accs (str);
}
d_str str;
unsigned i;
- for (i = 0; VEC_iterate (structure, structures, i, str); i++)
+ FOR_EACH_VEC_ELT (structure, structures, i, str)
exclude_alloc_and_field_accs_1 (str, node);
}
fprintf (dump_file, "\nThe following are the new types generated by"
" this optimization:\n");
- for (i = 0; VEC_iterate (structure, structures, i, str); i++)
+ FOR_EACH_VEC_ELT (structure, structures, i, str)
{
if (dump_file)
{
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++)
+ FOR_EACH_VEC_ELT (tree, str->new_types, j, type)
dump_struct_type (type, 2, 0);
}
}
unsigned i;
int str_num = 0;
- for (i = 0; VEC_iterate (structure, structures, i, str); i++)
+ FOR_EACH_VEC_ELT (structure, structures, i, str)
create_new_type (str, &str_num);
}
d_str str;
/* We summarize counts of fields of a structure into the structure count. */
- for (i = 0; VEC_iterate (structure, structures, i, str); i++)
+ FOR_EACH_VEC_ELT (structure, structures, i, str)
sum_counts (str, &hottest);
/* Remove cold structures from structures vector. */
d_str str;
unsigned i;
- for (i = 0; VEC_iterate (structure, structures, i, str); i++)
+ FOR_EACH_VEC_ELT (structure, structures, i, str)
peel_hot_fields (str);
}
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;
}
OSDN Git Service
