gcc/ChangeLog:
* range-op-float.cc (fop_unordered): Make static and const.
(fop_ordered): Likewise.
(fop_unordered_lt): Likewise.
(fop_unordered_le): Likewise.
(fop_unordered_gt): Likewise.
(fop_unordered_ge): Likewise.
(fop_unordered_equal): Likewise.
(fop_ltgt): Likewise.
(fop_div): Likewise.
* range-op-ptr.cc (op_pointer_plus): Likewise.
(op_pointer_diff): Likewise.
* range-op.cc (op_equal): Likewise.
(op_not_equal): Likewise.
(op_lt): Likewise.
(op_le): Likewise.
(op_gt): Likewise.
(op_ge): Likewise.
(op_ident): Likewise.
(op_cst): Likewise.
(op_cast): Likewise.
(op_view): Likewise.
(op_plus): Likewise.
(op_abs): Likewise.
(op_minus): Likewise.
(op_negate): Likewise.
(op_mult): Likewise.
(op_addr): Likewise.
(op_bitwise_not): Likewise.
(op_bitwise_xor): Likewise.
(op_bitwise_and): Likewise.
(op_bitwise_or): Likewise.
(op_min): Likewise.
(op_max): Likewise.
(operator_table): Make static. Fix typo in comment.
(range_op_handler::range_op_handler): Fix typo in leading comment.
(range_op_handler::range_op): Make returned ptr const. Use
nullptr.
(RO_III): Make static.
(RO_IFI): Likewise.
(RO_IFF): Likewise.
(RO_FFF): Likewise.
(RO_FIF): Likewise.
(RO_FII): Likewise.
(RO_PPP): Likewise.
(RO_PPI): Likewise.
(RO_IPP): Likewise.
(RO_IPI): Likewise.
(RO_PIP): Likewise.
(RO_PII): Likewise.
(op_trunc_div): Make const.
(op_floor_div): Likewise.
(op_round_div): Likewise.
(op_ceil_div): Likewise.
* range-op.h (range_op_handler::range_op): Make returned ptr
const.
(range_op_handler::m_operator): Make const.
(range_op_table::operator[]): Make const. Make returned ptr
const.
(range_op_table::set): Make range_operator const.
(range_op_table::m_range_tree): Make ptrs const.
Signed-off-by: David Malcolm <[email protected]>
---
gcc/range-op-float.cc | 27 ++++++++-----
gcc/range-op-ptr.cc | 6 ++-
gcc/range-op.cc | 90 +++++++++++++++++++++----------------------
gcc/range-op.h | 10 ++---
4 files changed, 72 insertions(+), 61 deletions(-)
diff --git a/gcc/range-op-float.cc b/gcc/range-op-float.cc
index 9e825f6b3ef..5d1273732b9 100644
--- a/gcc/range-op-float.cc
+++ b/gcc/range-op-float.cc
@@ -1356,7 +1356,8 @@ public:
{
return op1_range (r, type, lhs, op1, rel.swap_op1_op2 ());
}
-} fop_unordered;
+};
+static const foperator_unordered fop_unordered;
bool
foperator_unordered::fold_range (irange &r, tree type,
@@ -1430,7 +1431,8 @@ public:
{
return op1_range (r, type, lhs, op1, rel.swap_op1_op2 ());
}
-} fop_ordered;
+};
+static const foperator_ordered fop_ordered;
bool
foperator_ordered::fold_range (irange &r, tree type,
@@ -1652,7 +1654,8 @@ public:
const irange &lhs,
const frange &op1,
relation_trio trio) const final override;
-} fop_unordered_lt;
+};
+static const foperator_unordered_lt fop_unordered_lt;
bool
foperator_unordered_lt::op1_range (frange &r, tree type,
@@ -1762,7 +1765,8 @@ public:
bool op2_range (frange &r, tree type,
const irange &lhs, const frange &op1,
relation_trio = TRIO_VARYING) const final override;
-} fop_unordered_le;
+};
+static const foperator_unordered_le fop_unordered_le;
bool
foperator_unordered_le::op1_range (frange &r, tree type,
@@ -1870,7 +1874,8 @@ public:
bool op2_range (frange &r, tree type,
const irange &lhs, const frange &op1,
relation_trio = TRIO_VARYING) const final override;
-} fop_unordered_gt;
+};
+static const foperator_unordered_gt fop_unordered_gt;
bool
foperator_unordered_gt::op1_range (frange &r,
@@ -1982,7 +1987,8 @@ public:
bool op2_range (frange &r, tree type,
const irange &lhs, const frange &op1,
relation_trio = TRIO_VARYING) const final override;
-} fop_unordered_ge;
+};
+static const foperator_unordered_ge fop_unordered_ge;
bool
foperator_unordered_ge::op1_range (frange &r,
@@ -2096,7 +2102,8 @@ public:
{
return op1_range (r, type, lhs, op1, rel.swap_op1_op2 ());
}
-} fop_unordered_equal;
+};
+static const foperator_unordered_equal fop_unordered_equal;
bool
foperator_unordered_equal::op1_range (frange &r, tree type,
@@ -2178,7 +2185,8 @@ public:
{
return op1_range (r, type, lhs, op1, rel.swap_op1_op2 ());
}
-} fop_ltgt;
+};
+static const foperator_ltgt fop_ltgt;
bool
foperator_ltgt::op1_range (frange &r, tree type,
@@ -2900,7 +2908,8 @@ private:
gcc_checking_assert (!real_isnan (&ub));
r.set (type, lb, ub, nan_state (maybe_nan));
}
-} fop_div;
+};
+static const foperator_div fop_div;
bool
operator_cast::fold_range (frange &r, tree type, const frange &op1,
diff --git a/gcc/range-op-ptr.cc b/gcc/range-op-ptr.cc
index ce23db08827..6461530a9a3 100644
--- a/gcc/range-op-ptr.cc
+++ b/gcc/range-op-ptr.cc
@@ -318,7 +318,8 @@ public:
relation_kind) const final override;
void update_bitmask (prange &r, const prange &lh, const irange &rh) const
{ update_known_bitmask (r, POINTER_PLUS_EXPR, lh, rh); }
-} op_pointer_plus;
+};
+static const pointer_plus_operator op_pointer_plus;
bool
pointer_plus_operator::fold_range (prange &r, tree type,
@@ -475,7 +476,8 @@ class operator_pointer_diff : public range_operator
void update_bitmask (irange &r,
const prange &lh, const prange &rh) const final override
{ update_known_bitmask (r, POINTER_DIFF_EXPR, lh, rh); }
-} op_pointer_diff;
+};
+static const operator_pointer_diff op_pointer_diff;
bool
operator_pointer_diff::fold_range (irange &r, tree type,
diff --git a/gcc/range-op.cc b/gcc/range-op.cc
index 49738c792cf..40c62c3a2d6 100644
--- a/gcc/range-op.cc
+++ b/gcc/range-op.cc
@@ -51,31 +51,31 @@ along with GCC; see the file COPYING3. If not see
// Instantiate the operators which apply to multiple types here.
-operator_equal op_equal;
-operator_not_equal op_not_equal;
-operator_lt op_lt;
-operator_le op_le;
-operator_gt op_gt;
-operator_ge op_ge;
-operator_identity op_ident;
-operator_cst op_cst;
-operator_cast op_cast;
-operator_view op_view;
-operator_plus op_plus;
-operator_abs op_abs;
-operator_minus op_minus;
-operator_negate op_negate;
-operator_mult op_mult;
-operator_addr_expr op_addr;
-operator_bitwise_not op_bitwise_not;
-operator_bitwise_xor op_bitwise_xor;
-operator_bitwise_and op_bitwise_and;
-operator_bitwise_or op_bitwise_or;
-operator_min op_min;
-operator_max op_max;
-
-// Instantaite a range operator table.
-range_op_table operator_table;
+static const operator_equal op_equal;
+static const operator_not_equal op_not_equal;
+static const operator_lt op_lt;
+static const operator_le op_le;
+static const operator_gt op_gt;
+static const operator_ge op_ge;
+static const operator_identity op_ident;
+static const operator_cst op_cst;
+static const operator_cast op_cast;
+static const operator_view op_view;
+static const operator_plus op_plus;
+static const operator_abs op_abs;
+static const operator_minus op_minus;
+static const operator_negate op_negate;
+static const operator_mult op_mult;
+static const operator_addr_expr op_addr;
+static const operator_bitwise_not op_bitwise_not;
+static const operator_bitwise_xor op_bitwise_xor;
+static const operator_bitwise_and op_bitwise_and;
+static const operator_bitwise_or op_bitwise_or;
+static const operator_min op_min;
+static const operator_max op_max;
+
+// Instantiate a range operator table.
+static range_op_table operator_table;
// Invoke the initialization routines for each class of range.
@@ -126,7 +126,7 @@ range_op_handler::range_op_handler ()
m_operator = &default_operator;
}
-// Create a range_op_handler for CODE. Use a default operatoer if CODE
+// Create a range_op_handler for CODE. Use a default operator if CODE
// does not have an entry.
range_op_handler::range_op_handler (unsigned code)
@@ -144,15 +144,15 @@ range_op_handler::operator bool () const
}
// Return a pointer to the range operator assocaited with this handler.
-// If it is a default operator, return NULL.
+// If it is a default operator, return nullptr.
// This is the equivalent of indexing the range table.
-range_operator *
+const range_operator *
range_op_handler::range_op () const
{
if (m_operator != &default_operator)
return m_operator;
- return NULL;
+ return nullptr;
}
// Create a dispatch pattern for value range discriminators LHS, OP1, and OP2.
@@ -171,18 +171,18 @@ dispatch_trio (unsigned lhs, unsigned op1, unsigned op2)
// Reminder, single operand instructions use the LHS type for op2, even if
// unused. So FLOAT = INT would be RO_FIF.
-const unsigned RO_III = dispatch_trio (VR_IRANGE, VR_IRANGE, VR_IRANGE);
-const unsigned RO_IFI = dispatch_trio (VR_IRANGE, VR_FRANGE, VR_IRANGE);
-const unsigned RO_IFF = dispatch_trio (VR_IRANGE, VR_FRANGE, VR_FRANGE);
-const unsigned RO_FFF = dispatch_trio (VR_FRANGE, VR_FRANGE, VR_FRANGE);
-const unsigned RO_FIF = dispatch_trio (VR_FRANGE, VR_IRANGE, VR_FRANGE);
-const unsigned RO_FII = dispatch_trio (VR_FRANGE, VR_IRANGE, VR_IRANGE);
-const unsigned RO_PPP = dispatch_trio (VR_PRANGE, VR_PRANGE, VR_PRANGE);
-const unsigned RO_PPI = dispatch_trio (VR_PRANGE, VR_PRANGE, VR_IRANGE);
-const unsigned RO_IPP = dispatch_trio (VR_IRANGE, VR_PRANGE, VR_PRANGE);
-const unsigned RO_IPI = dispatch_trio (VR_IRANGE, VR_PRANGE, VR_IRANGE);
-const unsigned RO_PIP = dispatch_trio (VR_PRANGE, VR_IRANGE, VR_PRANGE);
-const unsigned RO_PII = dispatch_trio (VR_PRANGE, VR_IRANGE, VR_IRANGE);
+static const unsigned RO_III = dispatch_trio (VR_IRANGE, VR_IRANGE, VR_IRANGE);
+static const unsigned RO_IFI = dispatch_trio (VR_IRANGE, VR_FRANGE, VR_IRANGE);
+static const unsigned RO_IFF = dispatch_trio (VR_IRANGE, VR_FRANGE, VR_FRANGE);
+static const unsigned RO_FFF = dispatch_trio (VR_FRANGE, VR_FRANGE, VR_FRANGE);
+static const unsigned RO_FIF = dispatch_trio (VR_FRANGE, VR_IRANGE, VR_FRANGE);
+static const unsigned RO_FII = dispatch_trio (VR_FRANGE, VR_IRANGE, VR_IRANGE);
+static const unsigned RO_PPP = dispatch_trio (VR_PRANGE, VR_PRANGE, VR_PRANGE);
+static const unsigned RO_PPI = dispatch_trio (VR_PRANGE, VR_PRANGE, VR_IRANGE);
+static const unsigned RO_IPP = dispatch_trio (VR_IRANGE, VR_PRANGE, VR_PRANGE);
+static const unsigned RO_IPI = dispatch_trio (VR_IRANGE, VR_PRANGE, VR_IRANGE);
+static const unsigned RO_PIP = dispatch_trio (VR_PRANGE, VR_IRANGE, VR_PRANGE);
+static const unsigned RO_PII = dispatch_trio (VR_PRANGE, VR_IRANGE, VR_IRANGE);
// Return a dispatch value for parameter types LHS, OP1 and OP2.
@@ -2497,10 +2497,10 @@ protected:
tree_code m_code;
};
-static operator_div op_trunc_div (TRUNC_DIV_EXPR);
-static operator_div op_floor_div (FLOOR_DIV_EXPR);
-static operator_div op_round_div (ROUND_DIV_EXPR);
-static operator_div op_ceil_div (CEIL_DIV_EXPR);
+static const operator_div op_trunc_div (TRUNC_DIV_EXPR);
+static const operator_div op_floor_div (FLOOR_DIV_EXPR);
+static const operator_div op_round_div (ROUND_DIV_EXPR);
+static const operator_div op_ceil_div (CEIL_DIV_EXPR);
// Set OP2 to non-zero if the LHS isn't UNDEFINED.
bool
diff --git a/gcc/range-op.h b/gcc/range-op.h
index 1fd84ca0713..36e99a6f912 100644
--- a/gcc/range-op.h
+++ b/gcc/range-op.h
@@ -304,7 +304,7 @@ public:
range_op_handler ();
range_op_handler (unsigned);
operator bool () const;
- range_operator *range_op () const;
+ const range_operator *range_op () const;
bool fold_range (vrange &r, tree type,
const vrange &lh,
@@ -338,7 +338,7 @@ protected:
void discriminator_fail (const vrange &,
const vrange &,
const vrange &) const;
- range_operator *m_operator;
+ const range_operator *m_operator;
};
// Cast the range in R to TYPE if R supports TYPE.
@@ -404,19 +404,19 @@ class range_op_table
{
public:
range_op_table ();
- inline range_operator *operator[] (unsigned code)
+ inline const range_operator *operator[] (unsigned code) const
{
gcc_checking_assert (code < RANGE_OP_TABLE_SIZE);
return m_range_tree[code];
}
protected:
- inline void set (unsigned code, range_operator &op)
+ inline void set (unsigned code, const range_operator &op)
{
gcc_checking_assert (code < RANGE_OP_TABLE_SIZE);
gcc_checking_assert (m_range_tree[code] == NULL);
m_range_tree[code] = &op;
}
- range_operator *m_range_tree[RANGE_OP_TABLE_SIZE];
+ const range_operator *m_range_tree[RANGE_OP_TABLE_SIZE];
void initialize_integral_ops ();
void initialize_pointer_ops ();
void initialize_float_ops ();
