[PATCH][mem-ref2] Fixup matrix-reorg
Richard Guenther
rguenther@suse.de
Mon Jun 7 12:30:00 GMT 2010
Ugh. Well - at least all fails are gone now.
matrix.exp-tested on x86_64-unknown-linux-gnu, applied to the branch.
Richard.
2010-06-07 Richard Guenther <rguenther@suse.de>
* matrix-reorg.c (may_flatten_matrices_1): Sanitize.
(ssa_accessed_in_tree): Handle MEM_REF.
(ssa_accessed_in_assign_rhs): Likewise.
(update_type_size): Likewise.
(analyze_accesses_for_call_stmt): Likewise.
(analyze_accesses_for_assign_stmt): Likewise.
(transform_access_sites): Likewise.
(transform_allocation_sites): Likewise.
Index: gcc/matrix-reorg.c
===================================================================
*** gcc/matrix-reorg.c (revision 160359)
--- gcc/matrix-reorg.c (working copy)
*************** collect_data_for_malloc_call (gimple stm
*** 218,224 ****
initial address and index of each dimension. */
struct access_site_info
{
! /* The statement (INDIRECT_REF or POINTER_PLUS_EXPR). */
gimple stmt;
/* In case of POINTER_PLUS_EXPR, what is the offset. */
--- 218,224 ----
initial address and index of each dimension. */
struct access_site_info
{
! /* The statement (MEM_REF or POINTER_PLUS_EXPR). */
gimple stmt;
/* In case of POINTER_PLUS_EXPR, what is the offset. */
*************** struct ssa_acc_in_tree
*** 334,340 ****
/* The variable whose accesses in the tree we are looking for. */
tree ssa_var;
/* The tree and code inside it the ssa_var is accessed, currently
! it could be an INDIRECT_REF or CALL_EXPR. */
enum tree_code t_code;
tree t_tree;
/* The place in the containing tree. */
--- 334,340 ----
/* The variable whose accesses in the tree we are looking for. */
tree ssa_var;
/* The tree and code inside it the ssa_var is accessed, currently
! it could be an MEM_REF or CALL_EXPR. */
enum tree_code t_code;
tree t_tree;
/* The place in the containing tree. */
*************** mtt_info_eq (const void *mtt1, const voi
*** 413,445 ****
static bool
may_flatten_matrices_1 (gimple stmt)
{
- tree t;
-
switch (gimple_code (stmt))
{
case GIMPLE_ASSIGN:
! if (!gimple_assign_cast_p (stmt))
return true;
!
! t = gimple_assign_rhs1 (stmt);
! while (CONVERT_EXPR_P (t))
{
! if (TREE_TYPE (t) && POINTER_TYPE_P (TREE_TYPE (t)))
! {
! tree pointee;
!
! pointee = TREE_TYPE (t);
! while (POINTER_TYPE_P (pointee))
! pointee = TREE_TYPE (pointee);
! if (TREE_CODE (pointee) == VECTOR_TYPE)
! {
! if (dump_file)
! fprintf (dump_file,
! "Found vector type, don't flatten matrix\n");
! return false;
! }
! }
! t = TREE_OPERAND (t, 0);
}
break;
case GIMPLE_ASM:
--- 413,430 ----
static bool
may_flatten_matrices_1 (gimple stmt)
{
switch (gimple_code (stmt))
{
case GIMPLE_ASSIGN:
! case GIMPLE_CALL:
! if (!gimple_has_lhs (stmt))
return true;
! if (TREE_CODE (TREE_TYPE (gimple_get_lhs (stmt))) == VECTOR_TYPE)
{
! if (dump_file)
! fprintf (dump_file,
! "Found vector type, don't flatten matrix\n");
! return false;
}
break;
case GIMPLE_ASM:
*************** mark_min_matrix_escape_level (struct mat
*** 602,608 ****
/* Find if the SSA variable is accessed inside the
tree and record the tree containing it.
The only relevant uses are the case of SSA_NAME, or SSA inside
! INDIRECT_REF, PLUS_EXPR, POINTER_PLUS_EXPR, MULT_EXPR. */
static void
ssa_accessed_in_tree (tree t, struct ssa_acc_in_tree *a)
{
--- 587,593 ----
/* Find if the SSA variable is accessed inside the
tree and record the tree containing it.
The only relevant uses are the case of SSA_NAME, or SSA inside
! MEM_REF, PLUS_EXPR, POINTER_PLUS_EXPR, MULT_EXPR. */
static void
ssa_accessed_in_tree (tree t, struct ssa_acc_in_tree *a)
{
*************** ssa_accessed_in_tree (tree t, struct ssa
*** 613,619 ****
if (t == a->ssa_var)
a->var_found = true;
break;
! case INDIRECT_REF:
if (SSA_VAR_P (TREE_OPERAND (t, 0))
&& TREE_OPERAND (t, 0) == a->ssa_var)
a->var_found = true;
--- 598,604 ----
if (t == a->ssa_var)
a->var_found = true;
break;
! case MEM_REF:
if (SSA_VAR_P (TREE_OPERAND (t, 0))
&& TREE_OPERAND (t, 0) == a->ssa_var)
a->var_found = true;
*************** ssa_accessed_in_assign_rhs (gimple stmt,
*** 660,666 ****
tree op1, op2;
case SSA_NAME:
! case INDIRECT_REF:
CASE_CONVERT:
case VIEW_CONVERT_EXPR:
ssa_accessed_in_tree (gimple_assign_rhs1 (stmt), a);
--- 645,651 ----
tree op1, op2;
case SSA_NAME:
! case MEM_REF:
CASE_CONVERT:
case VIEW_CONVERT_EXPR:
ssa_accessed_in_tree (gimple_assign_rhs1 (stmt), a);
*************** get_index_from_offset (tree offset, gimp
*** 984,990 ****
/* update MI->dimension_type_size[CURRENT_INDIRECT_LEVEL] with the size
of the type related to the SSA_VAR, or the type related to the
! lhs of STMT, in the case that it is an INDIRECT_REF. */
static void
update_type_size (struct matrix_info *mi, gimple stmt, tree ssa_var,
int current_indirect_level)
--- 969,975 ----
/* update MI->dimension_type_size[CURRENT_INDIRECT_LEVEL] with the size
of the type related to the SSA_VAR, or the type related to the
! lhs of STMT, in the case that it is an MEM_REF. */
static void
update_type_size (struct matrix_info *mi, gimple stmt, tree ssa_var,
int current_indirect_level)
*************** update_type_size (struct matrix_info *mi
*** 992,1000 ****
tree lhs;
HOST_WIDE_INT type_size;
! /* Update type according to the type of the INDIRECT_REF expr. */
if (is_gimple_assign (stmt)
! && TREE_CODE (gimple_assign_lhs (stmt)) == INDIRECT_REF)
{
lhs = gimple_assign_lhs (stmt);
gcc_assert (POINTER_TYPE_P
--- 977,985 ----
tree lhs;
HOST_WIDE_INT type_size;
! /* Update type according to the type of the MEM_REF expr. */
if (is_gimple_assign (stmt)
! && TREE_CODE (gimple_assign_lhs (stmt)) == MEM_REF)
{
lhs = gimple_assign_lhs (stmt);
gcc_assert (POINTER_TYPE_P
*************** analyze_accesses_for_call_stmt (struct m
*** 1073,1079 ****
at this level because in this case we cannot calculate the
address correctly. */
if ((lhs_acc.var_found && rhs_acc.var_found
! && lhs_acc.t_code == INDIRECT_REF)
|| (!rhs_acc.var_found && !lhs_acc.var_found))
{
mark_min_matrix_escape_level (mi, current_indirect_level, use_stmt);
--- 1058,1064 ----
at this level because in this case we cannot calculate the
address correctly. */
if ((lhs_acc.var_found && rhs_acc.var_found
! && lhs_acc.t_code == MEM_REF)
|| (!rhs_acc.var_found && !lhs_acc.var_found))
{
mark_min_matrix_escape_level (mi, current_indirect_level, use_stmt);
*************** analyze_accesses_for_call_stmt (struct m
*** 1087,1093 ****
{
int l = current_indirect_level + 1;
! gcc_assert (lhs_acc.t_code == INDIRECT_REF);
mark_min_matrix_escape_level (mi, l, use_stmt);
return current_indirect_level;
}
--- 1072,1078 ----
{
int l = current_indirect_level + 1;
! gcc_assert (lhs_acc.t_code == MEM_REF);
mark_min_matrix_escape_level (mi, l, use_stmt);
return current_indirect_level;
}
*************** analyze_accesses_for_assign_stmt (struct
*** 1213,1219 ****
at this level because in this case we cannot calculate the
address correctly. */
if ((lhs_acc.var_found && rhs_acc.var_found
! && lhs_acc.t_code == INDIRECT_REF)
|| (!rhs_acc.var_found && !lhs_acc.var_found))
{
mark_min_matrix_escape_level (mi, current_indirect_level, use_stmt);
--- 1198,1204 ----
at this level because in this case we cannot calculate the
address correctly. */
if ((lhs_acc.var_found && rhs_acc.var_found
! && lhs_acc.t_code == MEM_REF)
|| (!rhs_acc.var_found && !lhs_acc.var_found))
{
mark_min_matrix_escape_level (mi, current_indirect_level, use_stmt);
*************** analyze_accesses_for_assign_stmt (struct
*** 1227,1233 ****
{
int l = current_indirect_level + 1;
! gcc_assert (lhs_acc.t_code == INDIRECT_REF);
if (!(gimple_assign_copy_p (use_stmt)
|| gimple_assign_cast_p (use_stmt))
--- 1212,1218 ----
{
int l = current_indirect_level + 1;
! gcc_assert (lhs_acc.t_code == MEM_REF);
if (!(gimple_assign_copy_p (use_stmt)
|| gimple_assign_cast_p (use_stmt))
*************** analyze_accesses_for_assign_stmt (struct
*** 1248,1254 ****
is used. */
if (rhs_acc.var_found)
{
! if (rhs_acc.t_code != INDIRECT_REF
&& rhs_acc.t_code != POINTER_PLUS_EXPR && rhs_acc.t_code != SSA_NAME)
{
mark_min_matrix_escape_level (mi, current_indirect_level, use_stmt);
--- 1233,1239 ----
is used. */
if (rhs_acc.var_found)
{
! if (rhs_acc.t_code != MEM_REF
&& rhs_acc.t_code != POINTER_PLUS_EXPR && rhs_acc.t_code != SSA_NAME)
{
mark_min_matrix_escape_level (mi, current_indirect_level, use_stmt);
*************** analyze_accesses_for_assign_stmt (struct
*** 1256,1262 ****
}
/* If the access in the RHS has an indirection increase the
indirection level. */
! if (rhs_acc.t_code == INDIRECT_REF)
{
if (record_accesses)
record_access_alloc_site_info (mi, use_stmt, NULL_TREE,
--- 1241,1247 ----
}
/* If the access in the RHS has an indirection increase the
indirection level. */
! if (rhs_acc.t_code == MEM_REF)
{
if (record_accesses)
record_access_alloc_site_info (mi, use_stmt, NULL_TREE,
*************** analyze_accesses_for_assign_stmt (struct
*** 1309,1315 ****
}
/* If we are storing this level of indirection mark it as
escaping. */
! if (lhs_acc.t_code == INDIRECT_REF || TREE_CODE (lhs) != SSA_NAME)
{
int l = current_indirect_level;
--- 1294,1300 ----
}
/* If we are storing this level of indirection mark it as
escaping. */
! if (lhs_acc.t_code == MEM_REF || TREE_CODE (lhs) != SSA_NAME)
{
int l = current_indirect_level;
*************** analyze_matrix_accesses (struct matrix_i
*** 1369,1376 ****
return;
/* Now go over the uses of the SSA_NAME and check how it is used in
! each one of them. We are mainly looking for the pattern INDIRECT_REF,
! then a POINTER_PLUS_EXPR, then INDIRECT_REF etc. while in between there could
be any number of copies and casts. */
gcc_assert (TREE_CODE (ssa_var) == SSA_NAME);
--- 1354,1361 ----
return;
/* Now go over the uses of the SSA_NAME and check how it is used in
! each one of them. We are mainly looking for the pattern MEM_REF,
! then a POINTER_PLUS_EXPR, then MEM_REF etc. while in between there could
be any number of copies and casts. */
gcc_assert (TREE_CODE (ssa_var) == SSA_NAME);
*************** transform_access_sites (void **slot, voi
*** 1856,1862 ****
gimple new_stmt;
gcc_assert (gimple_assign_rhs_code (acc_info->stmt)
! == INDIRECT_REF);
/* Emit convert statement to convert to type of use. */
tmp = create_tmp_var (TREE_TYPE (lhs), "new");
add_referenced_var (tmp);
--- 1841,1847 ----
gimple new_stmt;
gcc_assert (gimple_assign_rhs_code (acc_info->stmt)
! == MEM_REF);
/* Emit convert statement to convert to type of use. */
tmp = create_tmp_var (TREE_TYPE (lhs), "new");
add_referenced_var (tmp);
*************** transform_access_sites (void **slot, voi
*** 1878,1887 ****
continue;
}
code = gimple_assign_rhs_code (acc_info->stmt);
! if (code == INDIRECT_REF
&& acc_info->level < min_escape_l - 1)
{
! /* Replace the INDIRECT_REF with NOP (cast) usually we are casting
from "pointer to type" to "type". */
tree t =
build1 (NOP_EXPR, TREE_TYPE (gimple_assign_rhs1 (acc_info->stmt)),
--- 1863,1872 ----
continue;
}
code = gimple_assign_rhs_code (acc_info->stmt);
! if (code == MEM_REF
&& acc_info->level < min_escape_l - 1)
{
! /* Replace the MEM_REF with NOP (cast) usually we are casting
from "pointer to type" to "type". */
tree t =
build1 (NOP_EXPR, TREE_TYPE (gimple_assign_rhs1 (acc_info->stmt)),
*************** transform_allocation_sites (void **slot,
*** 2216,2232 ****
gsi = gsi_for_stmt (call_stmt);
/* Remove the call stmt. */
gsi_remove (&gsi, true);
- /* remove the type cast stmt. */
- FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter,
- gimple_call_lhs (call_stmt))
- {
- use_stmt1 = use_stmt;
- gsi = gsi_for_stmt (use_stmt);
- gsi_remove (&gsi, true);
- }
/* Remove the assignment of the allocated area. */
FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter,
! gimple_get_lhs (use_stmt1))
{
gsi = gsi_for_stmt (use_stmt);
gsi_remove (&gsi, true);
--- 2201,2209 ----
gsi = gsi_for_stmt (call_stmt);
/* Remove the call stmt. */
gsi_remove (&gsi, true);
/* Remove the assignment of the allocated area. */
FOR_EACH_IMM_USE_STMT (use_stmt, imm_iter,
! gimple_call_lhs (call_stmt))
{
gsi = gsi_for_stmt (use_stmt);
gsi_remove (&gsi, true);
More information about the Gcc-patches
mailing list