procyberian/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Remove type from range_op_handler table selection

Browse source 
With the unified table complete, we no loonger need to specify a type
to choose a table when setting a range_op_handler.

	* gimple-range-gori.cc (gori_compute::condexpr_adjust): Do not
	pass type.
	* gimple-range-op.cc (get_code): Rename from get_code_and_type
	and simplify.
	(gimple_range_op_handler::supported_p): No need for type.
	(gimple_range_op_handler::gimple_range_op_handler): Ditto.
	(cfn_copysign::fold_range): Ditto.
	(cfn_ubsan::fold_range): Ditto.
	* ipa-cp.cc (ipa_vr_operation_and_type_effects): Ditto.
	* ipa-fnsummary.cc (evaluate_conditions_for_known_args): Ditto.
	* range-op-float.cc (operator_plus::op1_range): Ditto.
	(operator_mult::op1_range): Ditto.
	(range_op_float_tests): Ditto.
	* range-op.cc (get_op_handler): Remove.
	(range_op_handler::set_op_handler): Remove.
	(operator_plus::op1_range): No need for type.
	(operator_minus::op1_range): Ditto.
	(operator_mult::op1_range): Ditto.
	(operator_exact_divide::op1_range): Ditto.
	(operator_cast::op1_range): Ditto.
	(perator_bitwise_not::fold_range): Ditto.
	(operator_negate::fold_range): Ditto.
	* range-op.h (range_op_handler::range_op_handler): Remove type param.
	(range_cast): No need for type.
	(range_op_table::operator[]): Check for enum_code >= 0.
	* tree-data-ref.cc (compute_distributive_range): No need for type.
	* tree-ssa-loop-unswitch.cc (unswitch_predicate): Ditto.
	* value-query.cc (range_query::get_tree_range): Ditto.
	* value-relation.cc (relation_oracle::validate_relation): Ditto.
	* vr-values.cc (range_of_var_in_loop): Ditto.
	(simplify_using_ranges::fold_cond_with_ops): Ditto.
This commit is contained in:
Andrew MacLeod 2023-06-12 10:50:30 -04:00
parent 110c1f8d30
commit 2eb50117ca
12 changed files with 43 additions and 87 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
gcc/gimple-range-gori.cc
View file

@ -1478,7 +1478,7 @@ gori_compute::condexpr_adjust (vrange &r1, vrange &r2, gimple *, tree cond,
tree type = TREE_TYPE (gimple_assign_rhs1 (cond_def));
if (!range_compatible_p (type, TREE_TYPE (gimple_assign_rhs2 (cond_def))))
return false;
range_op_handler hand (gimple_assign_rhs_code (cond_def), type);
range_op_handler hand (gimple_assign_rhs_code (cond_def));
if (!hand)
return false;

42
gcc/gimple-range-op.cc
View file

@ -94,28 +94,14 @@ gimple_range_base_of_assignment (const gimple *stmt)
// If statement is supported by range-ops, set the CODE and return the TYPE.
static tree
get_code_and_type (gimple *s, enum tree_code &code)
static inline enum tree_code
get_code (gimple *s)
{
tree type = NULL_TREE;
code = NOP_EXPR;
if (const gassign *ass = dyn_cast<const gassign *> (s))
{
code = gimple_assign_rhs_code (ass);
// The LHS of a comparison is always an int, so we must look at
// the operands.
if (TREE_CODE_CLASS (code) == tcc_comparison)
type = TREE_TYPE (gimple_assign_rhs1 (ass));
else
type = TREE_TYPE (gimple_assign_lhs (ass));
}
else if (const gcond *cond = dyn_cast<const gcond *> (s))
{
code = gimple_cond_code (cond);
type = TREE_TYPE (gimple_cond_lhs (cond));
}
return type;
return gimple_assign_rhs_code (ass);
if (const gcond *cond = dyn_cast<const gcond *> (s))
return gimple_cond_code (cond);
return ERROR_MARK;
}
// If statement S has a supported range_op handler return TRUE.
@ -123,9 +109,8 @@ get_code_and_type (gimple *s, enum tree_code &code)
bool
gimple_range_op_handler::supported_p (gimple *s)
{
enum tree_code code;
tree type = get_code_and_type (s, code);
if (type && range_op_handler (code, type))
enum tree_code code = get_code (s);
if (range_op_handler (code))
return true;
if (is_a <gcall *> (s) && gimple_range_op_handler (s))
return true;
@ -135,14 +120,11 @@ gimple_range_op_handler::supported_p (gimple *s)
// Construct a handler object for statement S.
gimple_range_op_handler::gimple_range_op_handler (gimple *s)
: range_op_handler (get_code (s))
{
enum tree_code code;
tree type = get_code_and_type (s, code);
m_stmt = s;
m_op1 = NULL_TREE;
m_op2 = NULL_TREE;
if (type)
set_op_handler (code, type);
if (m_operator)
switch (gimple_code (m_stmt))
@ -382,8 +364,8 @@ public:
const frange &rh, relation_trio) const override
{
frange neg;
range_op_handler abs_op (ABS_EXPR, type);
range_op_handler neg_op (NEGATE_EXPR, type);
range_op_handler abs_op (ABS_EXPR);
range_op_handler neg_op (NEGATE_EXPR);
if (!abs_op || !abs_op.fold_range (r, type, lh, frange (type)))
return false;
if (!neg_op || !neg_op.fold_range (neg, type, r, frange (type)))
@ -1091,7 +1073,7 @@ public:
virtual bool fold_range (irange &r, tree type, const irange &lh,
const irange &rh, relation_trio rel) const
{
range_op_handler handler (m_code, type);
range_op_handler handler (m_code);
gcc_checking_assert (handler);
bool saved_flag_wrapv = flag_wrapv;

6
gcc/ipa-cp.cc
View file

@ -1924,7 +1924,7 @@ ipa_vr_operation_and_type_effects (vrange &dst_vr,
if (!irange::supports_p (dst_type) || !irange::supports_p (src_type))
return false;
range_op_handler handler (operation, dst_type);
range_op_handler handler (operation);
if (!handler)
return false;
@ -1990,7 +1990,7 @@ ipa_value_range_from_jfunc (vrange &vr,
Value_Range res (vr_type);
tree op = ipa_get_jf_pass_through_operand (jfunc);
Value_Range op_vr (vr_type);
range_op_handler handler (operation, vr_type);
range_op_handler handler (operation);
ipa_range_set_and_normalize (op_vr, op);
@ -2786,7 +2786,7 @@ propagate_vr_across_jump_function (cgraph_edge *cs, ipa_jump_func *jfunc,
tree op = ipa_get_jf_pass_through_operand (jfunc);
Value_Range op_vr (TREE_TYPE (op));
Value_Range op_res (operand_type);
range_op_handler handler (operation, operand_type);
range_op_handler handler (operation);
ipa_range_set_and_normalize (op_vr, op);

6
gcc/ipa-fnsummary.cc
View file

@ -491,7 +491,7 @@ evaluate_conditions_for_known_args (struct cgraph_node *node,
value_range res;
if (!op->val[0])
{
range_op_handler handler (op->code, op->type);
range_op_handler handler (op->code);
if (!handler
|| !res.supports_type_p (op->type)
|| !handler.fold_range (res, op->type, vr,
@ -501,7 +501,7 @@ evaluate_conditions_for_known_args (struct cgraph_node *node,
else if (!op->val[1])
{
value_range op0;
range_op_handler handler (op->code, op->type);
range_op_handler handler (op->code);
ipa_range_set_and_normalize (op0, op->val[0]);
@ -520,7 +520,7 @@ evaluate_conditions_for_known_args (struct cgraph_node *node,
{
value_range res;
value_range val_vr;
range_op_handler handler (c->code, boolean_type_node);
range_op_handler handler (c->code);
ipa_range_set_and_normalize (val_vr, c->val);

6
gcc/range-op-float.cc
View file

@ -2244,7 +2244,7 @@ operator_plus::op1_range (frange &r, tree type, const frange &lhs,
{
if (lhs.undefined_p ())
return false;
range_op_handler minus (MINUS_EXPR, type);
range_op_handler minus (MINUS_EXPR);
if (!minus)
return false;
frange wlhs = float_widen_lhs_range (type, lhs);
@ -2361,7 +2361,7 @@ operator_mult::op1_range (frange &r, tree type,
{
if (lhs.undefined_p ())
return false;
range_op_handler rdiv (RDIV_EXPR, type);
range_op_handler rdiv (RDIV_EXPR);
if (!rdiv)
return false;
frange wlhs = float_widen_lhs_range (type, lhs);
@ -2716,7 +2716,7 @@ range_op_float_tests ()
ASSERT_EQ (r, r1);
// [-INF,+INF] + [-INF,+INF] could be a NAN.
range_op_handler plus (PLUS_EXPR, float_type_node);
range_op_handler plus (PLUS_EXPR);
r0.set_varying (float_type_node);
r1.set_varying (float_type_node);
r0.clear_nan ();

39
gcc/range-op.cc
View file

@ -125,30 +125,11 @@ unified_table::unified_table ()
// set (MAX_EXPR, op_max);
}
// The tables are hidden and accessed via a simple extern function.
range_operator *
get_op_handler (enum tree_code code, tree)
{
return unified_tree_table[code];
}
range_op_handler::range_op_handler ()
{
m_operator = NULL;
}
void
range_op_handler::set_op_handler (tree_code code, tree type)
{
m_operator = get_op_handler (code, type);
}
range_op_handler::range_op_handler (tree_code code, tree type)
{
set_op_handler (code, type);
}
// Constructing without a type must come from the unified table.
range_op_handler::range_op_handler (tree_code code)
@ -1692,7 +1673,7 @@ operator_plus::op1_range (irange &r, tree type,
if (lhs.undefined_p ())
return false;
// Start with the default operation.
range_op_handler minus (MINUS_EXPR, type);
range_op_handler minus (MINUS_EXPR);
if (!minus)
return false;
bool res = minus.fold_range (r, type, lhs, op2);
@ -1908,7 +1889,7 @@ operator_minus::op1_range (irange &r, tree type,
if (lhs.undefined_p ())
return false;
// Start with the default operation.
range_op_handler minus (PLUS_EXPR, type);
range_op_handler minus (PLUS_EXPR);
if (!minus)
return false;
bool res = minus.fold_range (r, type, lhs, op2);
@ -2046,8 +2027,7 @@ operator_mult::op1_range (irange &r, tree type,
wide_int offset;
if (op2.singleton_p (offset) && offset != 0)
return range_op_handler (TRUNC_DIV_EXPR, type).fold_range (r, type,
lhs, op2);
return range_op_handler (TRUNC_DIV_EXPR).fold_range (r, type, lhs, op2);
return false;
}
@ -2375,7 +2355,7 @@ operator_exact_divide::op1_range (irange &r, tree type,
// the time however.
// If op2 is a multiple of 2, we would be able to set some non-zero bits.
if (op2.singleton_p (offset) && offset != 0)
return range_op_handler (MULT_EXPR, type).fold_range (r, type, lhs, op2);
return range_op_handler (MULT_EXPR).fold_range (r, type, lhs, op2);
return false;
}
@ -2946,9 +2926,8 @@ operator_cast::op1_range (irange &r, tree type,
// Add this to the unsigned LHS range(s).
int_range_max lim_range (type, lim, lim);
int_range_max lhs_neg;
range_op_handler (PLUS_EXPR, type).fold_range (lhs_neg, type,
converted_lhs,
lim_range);
range_op_handler (PLUS_EXPR).fold_range (lhs_neg, type,
converted_lhs, lim_range);
// lhs_neg now has all the negative versions of the LHS.
// Now union in all the values from SIGNED MIN (0x80000) to
// lim-1 in order to fill in all the ranges with the upper
@ -3987,7 +3966,7 @@ operator_bitwise_not::fold_range (irange &r, tree type,
// ~X is simply -1 - X.
int_range<1> minusone (type, wi::minus_one (TYPE_PRECISION (type)),
wi::minus_one (TYPE_PRECISION (type)));
return range_op_handler (MINUS_EXPR, type).fold_range (r, type, minusone, lh);
return range_op_handler (MINUS_EXPR).fold_range (r, type, minusone, lh);
}
bool
@ -4233,8 +4212,8 @@ operator_negate::fold_range (irange &r, tree type,
if (empty_range_varying (r, type, lh, rh))
return true;
// -X is simply 0 - X.
return range_op_handler (MINUS_EXPR, type).fold_range (r, type,
range_zero (type), lh);
return range_op_handler (MINUS_EXPR).fold_range (r, type,
range_zero (type), lh);
}
bool

10
gcc/range-op.h
View file

@ -185,7 +185,6 @@ class range_op_handler
{
public:
range_op_handler ();
range_op_handler (enum tree_code code, tree type);
range_op_handler (enum tree_code code);
inline operator bool () const { return m_operator != NULL; }
@ -213,7 +212,6 @@ public:
protected:
unsigned dispatch_kind (const vrange &lhs, const vrange &op1,
const vrange& op2) const;
void set_op_handler (enum tree_code code, tree type);
range_operator *m_operator;
};
@ -226,9 +224,8 @@ range_cast (vrange &r, tree type)
Value_Range tmp (r);
Value_Range varying (type);
varying.set_varying (type);
range_op_handler op (CONVERT_EXPR, type);
// Call op_convert, if it fails, the result is varying.
if (!op || !op.fold_range (r, type, tmp, varying))
if (!range_op_handler (CONVERT_EXPR).fold_range (r, type, tmp, varying))
{
r.set_varying (type);
return false;
@ -249,9 +246,8 @@ range_cast (Value_Range &r, tree type)
// Ensure we are in the correct mode for the call to fold.
r.set_type (type);
range_op_handler op (CONVERT_EXPR, type);
// Call op_convert, if it fails, the result is varying.
if (!op || !op.fold_range (r, type, tmp, varying))
if (!range_op_handler (CONVERT_EXPR).fold_range (r, type, tmp, varying))
{
r.set_varying (type);
return false;
@ -286,7 +282,7 @@ protected:
inline range_operator *
range_op_table::operator[] (enum tree_code code)
{
gcc_checking_assert (code > 0 && code < MAX_TREE_CODES);
gcc_checking_assert (code >= 0 && code < MAX_TREE_CODES);
return m_range_tree[code];
}

4
gcc/tree-data-ref.cc
View file

@ -593,7 +593,7 @@ compute_distributive_range (tree type, value_range &op0_range,
gcc_assert (INTEGRAL_TYPE_P (type) && !TYPE_OVERFLOW_TRAPS (type));
if (result_range)
{
range_op_handler op (code, type);
range_op_handler op (code);
if (!op.fold_range (*result_range, type, op0_range, op1_range))
result_range->set_varying (type);
}
@ -640,7 +640,7 @@ compute_distributive_range (tree type, value_range &op0_range,
range_cast (op0_range, ssizetype);
range_cast (op1_range, ssizetype);
value_range wide_range;
range_op_handler op (code, ssizetype);
range_op_handler op (code);
bool saved_flag_wrapv = flag_wrapv;
flag_wrapv = 1;
if (!op.fold_range (wide_range, ssizetype, op0_range, op1_range))

2
gcc/tree-ssa-loop-unswitch.cc
View file

@ -139,7 +139,7 @@ struct unswitch_predicate
count = EDGE_SUCC (bb, 0)->count ().max (EDGE_SUCC (bb, 1)->count ());
if (irange::supports_p (TREE_TYPE (lhs)))
{
auto range_op = range_op_handler (code, TREE_TYPE (lhs));
auto range_op = range_op_handler (code);
int_range<2> rhs_range (TREE_TYPE (rhs));
if (CONSTANT_CLASS_P (rhs))
{

5
gcc/value-query.cc
View file

@ -228,8 +228,7 @@ range_query::get_tree_range (vrange &r, tree expr, gimple *stmt)
if (COMPARISON_CLASS_P (expr)
&& !Value_Range::supports_type_p (TREE_TYPE (op0)))
return false;
range_op_handler op (TREE_CODE (expr),
BINARY_CLASS_P (expr) ? type : TREE_TYPE (op0));
range_op_handler op (TREE_CODE (expr));
if (op)
{
Value_Range r0 (TREE_TYPE (op0));
@ -245,7 +244,7 @@ range_query::get_tree_range (vrange &r, tree expr, gimple *stmt)
}
if (UNARY_CLASS_P (expr))
{
range_op_handler op (TREE_CODE (expr), type);
range_op_handler op (TREE_CODE (expr));
tree op0_type = TREE_TYPE (TREE_OPERAND (expr, 0));
if (op && Value_Range::supports_type_p (op0_type))
{

2
gcc/value-relation.cc
View file

@ -218,7 +218,7 @@ relation_oracle::validate_relation (relation_kind rel, vrange &op1, vrange &op2)
return VREL_VARYING;
// If there is no handler, leave the relation as is.
range_op_handler handler (code, t1);
range_op_handler handler (code);
if (!handler)
return rel;

6
gcc/vr-values.cc
View file

@ -292,8 +292,8 @@ range_of_var_in_loop (vrange &v, tree name, class loop *l, gimple *stmt,
wide_int w = wide_int::from (nit, TYPE_PRECISION (type), TYPE_SIGN (type));
int_range<1> niter (type, w, w);
int_range_max max_step;
range_op_handler mult_handler (MULT_EXPR, type);
range_op_handler plus_handler (PLUS_EXPR, type);
range_op_handler mult_handler (MULT_EXPR);
range_op_handler plus_handler (PLUS_EXPR);
if (!mult_handler.fold_range (max_step, type, niter, rstep)
|| !plus_handler.fold_range (max_init, type, rinit, max_step))
return false;
@ -317,7 +317,7 @@ simplify_using_ranges::fold_cond_with_ops (enum tree_code code,
tree type = TREE_TYPE (op0);
int_range<1> res;
range_op_handler handler (code, type);
range_op_handler handler (code);
if (handler && handler.fold_range (res, type, r0, r1))
{
if (res == range_true (type))