git
/
gcc
mirror of git://gcc.gnu.org/git/gcc.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

revert: ipa-cp.c (ipa_get_jf_pass_through_result): Handle unary expressions. 

2016-11-10  Kugan Vivekanandarajah  <kuganv@linaro.org>

	Revert
	2016-11-09  Kugan Vivekanandarajah  <kuganv@linaro.org>

	* ipa-cp.c (ipa_get_jf_pass_through_result): Handle unary expressions.
	(propagate_vr_accross_jump_function): Likewise.
	* ipa-prop.c (ipa_set_jf_unary_pass_through): New.
	(load_from_param_1): New.
	(load_from_unmodified_param): Factor common part into load_from_param_1.
	(load_from_param): New.
	(compute_complex_assign_jump_func): Handle unary expressions.
	(ipa_write_jump_function): Likewise.
	(ipa_read_jump_function): Likewise.

From-SVN: r242032
This commit is contained in:
Kugan Vivekanandarajah 2016-11-10 07:13:39 +00:00 committed by Kugan Vivekanandarajah
parent a62436c0a5
commit e32d2c92d9
3 changed files with 33 additions and 108 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
gcc/ChangeLog
View File

@ -1,3 +1,18 @@
2016-11-10 Kugan Vivekanandarajah <kuganv@linaro.org>
Revert
2016-11-09 Kugan Vivekanandarajah <kuganv@linaro.org>
* ipa-cp.c (ipa_get_jf_pass_through_result): Handle unary expressions.
(propagate_vr_accross_jump_function): Likewise.
* ipa-prop.c (ipa_set_jf_unary_pass_through): New.
(load_from_param_1): New.
(load_from_unmodified_param): Factor common part into load_from_param_1.
(load_from_param): New.
(compute_complex_assign_jump_func): Handle unary expressions.
(ipa_write_jump_function): Likewise.
(ipa_read_jump_function): Likewise.
2016-11-09 Segher Boessenkool <segher@kernel.crashing.org>
* simplify-rtx.c (simplify_binary_operation_1): Simplify

37
gcc/ipa-cp.c
View File

@ -1219,19 +1219,13 @@ ipa_get_jf_pass_through_result (struct ipa_jump_func *jfunc, tree input)
return NULL_TREE;
if (TREE_CODE_CLASS (ipa_get_jf_pass_through_operation (jfunc))
== tcc_unary)
res = fold_unary (ipa_get_jf_pass_through_operation (jfunc),
TREE_TYPE (input), input);
== tcc_comparison)
restype = boolean_type_node;
else
{
if (TREE_CODE_CLASS (ipa_get_jf_pass_through_operation (jfunc))
== tcc_comparison)
restype = boolean_type_node;
else
restype = TREE_TYPE (input);
res = fold_binary (ipa_get_jf_pass_through_operation (jfunc), restype,
input, ipa_get_jf_pass_through_operand (jfunc));
}
restype = TREE_TYPE (input);
res = fold_binary (ipa_get_jf_pass_through_operation (jfunc), restype,
input, ipa_get_jf_pass_through_operand (jfunc));
if (res && !is_gimple_ip_invariant (res))
return NULL_TREE;
@ -1870,25 +1864,6 @@ propagate_vr_accross_jump_function (cgraph_edge *cs,
if (ipa_get_jf_pass_through_operation (jfunc) == NOP_EXPR)
return dest_lat->meet_with (src_lats->m_value_range);
else if (param_type
&& (TREE_CODE_CLASS (ipa_get_jf_pass_through_operation (jfunc))
== tcc_unary))
{
value_range vr;
memset (&vr, 0, sizeof (vr));
tree operand_type = ipa_get_type (caller_info, src_idx);
enum tree_code operation = ipa_get_jf_pass_through_operation (jfunc);
if (src_lats->m_value_range.bottom_p ())
return false;
extract_range_from_unary_expr (&vr,
operation,
param_type,
&src_lats->m_value_range.m_vr,
operand_type);
return dest_lat->meet_with (&vr);
}
}
else if (jfunc->type == IPA_JF_CONST)
{

89
gcc/ipa-prop.c
View File

@ -446,18 +446,6 @@ ipa_set_jf_simple_pass_through (struct ipa_jump_func *jfunc, int formal_id,
jfunc->value.pass_through.agg_preserved = agg_preserved;
}
/* Set JFUNC to be an unary pass through jump function. */
static void
ipa_set_jf_unary_pass_through (struct ipa_jump_func *jfunc, int formal_id,
enum tree_code operation)
{
jfunc->type = IPA_JF_PASS_THROUGH;
jfunc->value.pass_through.operand = NULL_TREE;
jfunc->value.pass_through.formal_id = formal_id;
jfunc->value.pass_through.operation = operation;
jfunc->value.pass_through.agg_preserved = false;
}
/* Set JFUNC to be an arithmetic pass through jump function. */
static void
@ -861,19 +849,21 @@ parm_preserved_before_stmt_p (struct ipa_func_body_info *fbi, int index,
return !modified;
}
/* Main worker for load_from_unmodified_param and load_from_param.
If STMT is an assignment that loads a value from an parameter declaration,
return the index of the parameter in ipa_node_params. Otherwise return -1. */
/* If STMT is an assignment that loads a value from an parameter declaration,
return the index of the parameter in ipa_node_params which has not been
modified. Otherwise return -1. */
static int
load_from_param_1 (struct ipa_func_body_info *fbi,
vec<ipa_param_descriptor> descriptors,
gimple *stmt)
load_from_unmodified_param (struct ipa_func_body_info *fbi,
vec<ipa_param_descriptor> descriptors,
gimple *stmt)
{
int index;
tree op1;
gcc_checking_assert (is_gimple_assign (stmt));
if (!gimple_assign_single_p (stmt))
return -1;
op1 = gimple_assign_rhs1 (stmt);
if (TREE_CODE (op1) != PARM_DECL)
return -1;
@ -886,40 +876,6 @@ load_from_param_1 (struct ipa_func_body_info *fbi,
return index;
}
/* If STMT is an assignment that loads a value from an parameter declaration,
return the index of the parameter in ipa_node_params which has not been
modified. Otherwise return -1. */
static int
load_from_unmodified_param (struct ipa_func_body_info *fbi,
vec<ipa_param_descriptor> descriptors,
gimple *stmt)
{
if (!gimple_assign_single_p (stmt))
return -1;
return load_from_param_1 (fbi, descriptors, stmt);
}
/* If STMT is an assignment that loads a value from an parameter declaration,
return the index of the parameter in ipa_node_params. Otherwise return -1. */
static int
load_from_param (struct ipa_func_body_info *fbi,
vec<ipa_param_descriptor> descriptors,
gimple *stmt)
{
if (!is_gimple_assign (stmt))
return -1;
enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
if ((get_gimple_rhs_class (rhs_code) != GIMPLE_SINGLE_RHS)
&& (get_gimple_rhs_class (rhs_code) != GIMPLE_UNARY_RHS))
return -1;
return load_from_param_1 (fbi, descriptors, stmt);
}
/* Return true if memory reference REF (which must be a load through parameter
with INDEX) loads data that are known to be unmodified in this function
before reaching statement STMT. */
@ -1153,7 +1109,6 @@ compute_complex_assign_jump_func (struct ipa_func_body_info *fbi,
tree op1, tc_ssa, base, ssa;
bool reverse;
int index;
gimple *stmt2 = stmt;
op1 = gimple_assign_rhs1 (stmt);
@ -1162,16 +1117,13 @@ compute_complex_assign_jump_func (struct ipa_func_body_info *fbi,
if (SSA_NAME_IS_DEFAULT_DEF (op1))
index = ipa_get_param_decl_index (info, SSA_NAME_VAR (op1));
else
{
index = load_from_param (fbi, info->descriptors,
SSA_NAME_DEF_STMT (op1));
stmt2 = SSA_NAME_DEF_STMT (op1);
}
index = load_from_unmodified_param (fbi, info->descriptors,
SSA_NAME_DEF_STMT (op1));
tc_ssa = op1;
}
else
{
index = load_from_param (fbi, info->descriptors, stmt);
index = load_from_unmodified_param (fbi, info->descriptors, stmt);
tc_ssa = gimple_assign_lhs (stmt);
}
@ -1195,13 +1147,6 @@ compute_complex_assign_jump_func (struct ipa_func_body_info *fbi,
bool agg_p = parm_ref_data_pass_through_p (fbi, index, call, tc_ssa);
ipa_set_jf_simple_pass_through (jfunc, index, agg_p);
}
else if (is_gimple_assign (stmt2)
&& (gimple_expr_code (stmt2) != NOP_EXPR)
&& (TREE_CODE_CLASS (gimple_expr_code (stmt2)) == tcc_unary))
{
ipa_set_jf_unary_pass_through (jfunc, index,
gimple_assign_rhs_code (stmt2));
}
return;
}
@ -4721,11 +4666,6 @@ ipa_write_jump_function (struct output_block *ob,
bp_pack_value (&bp, jump_func->value.pass_through.agg_preserved, 1);
streamer_write_bitpack (&bp);
}
else if (TREE_CODE_CLASS (jump_func->value.pass_through.operation)
== tcc_unary)
{
streamer_write_uhwi (ob, jump_func->value.pass_through.formal_id);
}
else
{
stream_write_tree (ob, jump_func->value.pass_through.operand, true);
@ -4805,11 +4745,6 @@ ipa_read_jump_function (struct lto_input_block *ib,
bool agg_preserved = bp_unpack_value (&bp, 1);
ipa_set_jf_simple_pass_through (jump_func, formal_id, agg_preserved);
}
else if (TREE_CODE_CLASS (operation) == tcc_unary)
{
int formal_id = streamer_read_uhwi (ib);
ipa_set_jf_unary_pass_through (jump_func, formal_id, operation);
}
else
{
tree operand = stream_read_tree (ib, data_in);