1 /* Header file for range operator class.
2 Copyright (C) 2017-2023 Free Software Foundation, Inc.
3 Contributed by Andrew MacLeod <amacleod@redhat.com>
4 and Aldy Hernandez <aldyh@redhat.com>.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
22 #ifndef GCC_RANGE_OP_H
23 #define GCC_RANGE_OP_H
25 // This class is implemented for each kind of operator supported by
26 // the range generator. It serves various purposes.
28 // 1 - Generates range information for the specific operation between
29 // two ranges. This provides the ability to fold ranges for an
32 // 2 - Performs range algebra on the expression such that a range can be
33 // adjusted in terms of one of the operands:
37 // Given a range for def, we can adjust the range so that it is in
38 // terms of either operand.
40 // op1_range (def_range, op2) will adjust the range in place so it
41 // is in terms of op1. Since op1 = def - op2, it will subtract
42 // op2 from each element of the range.
44 // 3 - Creates a range for an operand based on whether the result is 0 or
45 // non-zero. This is mostly for logical true false, but can serve other
47 // ie 0 = op1 - op2 implies op2 has the same range as op1.
49 // 4 - All supported range combinations are explicitly specified.
50 // Any desired combinations should be implemented for each operator.
51 // When new range classes are added, new matching prototypes should be
56 friend class range_op_table
;
58 // Perform an operation between 2 ranges and return it.
59 virtual bool fold_range (irange
&r
, tree type
,
62 relation_trio
= TRIO_VARYING
) const;
63 virtual bool fold_range (frange
&r
, tree type
,
66 relation_trio
= TRIO_VARYING
) const;
67 virtual bool fold_range (irange
&r
, tree type
,
70 relation_trio
= TRIO_VARYING
) const;
71 virtual bool fold_range (irange
&r
, tree type
,
74 relation_trio
= TRIO_VARYING
) const;
75 virtual bool fold_range (frange
&r
, tree type
,
78 relation_trio
= TRIO_VARYING
) const;
80 // Return the range for op[12] in the general case. LHS is the range for
81 // the LHS of the expression, OP[12]is the range for the other
83 // The operand and the result is returned in R.
85 // TYPE is the expected type of the range.
87 // Return TRUE if the operation is performed and a valid range is available.
89 // i.e. [LHS] = ??? + OP2
90 // is re-formed as R = [LHS] - OP2.
91 virtual bool op1_range (irange
&r
, tree type
,
94 relation_trio
= TRIO_VARYING
) const;
95 virtual bool op1_range (frange
&r
, tree type
,
98 relation_trio
= TRIO_VARYING
) const;
99 virtual bool op1_range (frange
&r
, tree type
,
102 relation_trio
= TRIO_VARYING
) const;
105 virtual bool op2_range (irange
&r
, tree type
,
108 relation_trio
= TRIO_VARYING
) const;
109 virtual bool op2_range (frange
&r
, tree type
,
112 relation_trio
= TRIO_VARYING
) const;
113 virtual bool op2_range (frange
&r
, tree type
,
116 relation_trio
= TRIO_VARYING
) const;
118 // The following routines are used to represent relations between the
119 // various operations. If the caller knows where the symbolics are,
120 // it can query for relationships between them given known ranges.
121 // the optional relation passed in is the relation between op1 and op2.
122 virtual relation_kind
lhs_op1_relation (const irange
&lhs
,
125 relation_kind
= VREL_VARYING
) const;
126 virtual relation_kind
lhs_op1_relation (const frange
&lhs
,
129 relation_kind
= VREL_VARYING
) const;
130 virtual relation_kind
lhs_op1_relation (const irange
&lhs
,
133 relation_kind
= VREL_VARYING
) const;
135 virtual relation_kind
lhs_op2_relation (const irange
&lhs
,
138 relation_kind
= VREL_VARYING
) const;
139 virtual relation_kind
lhs_op2_relation (const frange
&lhs
,
142 relation_kind
= VREL_VARYING
) const;
143 virtual relation_kind
lhs_op2_relation (const irange
&lhs
,
146 relation_kind
= VREL_VARYING
) const;
148 virtual relation_kind
op1_op2_relation (const irange
&lhs
,
150 const irange
&op2
) const;
151 virtual relation_kind
op1_op2_relation (const irange
&lhs
,
153 const frange
&op2
) const;
154 virtual relation_kind
op1_op2_relation (const frange
&lhs
,
156 const frange
&op2
) const;
158 virtual bool overflow_free_p (const irange
&lh
, const irange
&rh
,
159 relation_trio
= TRIO_VARYING
) const;
161 // Perform an integral operation between 2 sub-ranges and return it.
162 virtual void wi_fold (irange
&r
, tree type
,
163 const wide_int
&lh_lb
,
164 const wide_int
&lh_ub
,
165 const wide_int
&rh_lb
,
166 const wide_int
&rh_ub
) const;
167 // Effect of relation for generic fold_range clients.
168 virtual bool op1_op2_relation_effect (irange
&lhs_range
, tree type
,
169 const irange
&op1_range
,
170 const irange
&op2_range
,
171 relation_kind rel
) const;
172 // Called by fold range to split small subranges into parts.
173 void wi_fold_in_parts (irange
&r
, tree type
,
174 const wide_int
&lh_lb
,
175 const wide_int
&lh_ub
,
176 const wide_int
&rh_lb
,
177 const wide_int
&rh_ub
) const;
179 // Called by fold range to split small subranges into parts when op1 == op2
180 void wi_fold_in_parts_equiv (irange
&r
, tree type
,
183 unsigned limit
) const;
184 // Apply any bitmasks implied by these ranges.
185 virtual void update_bitmask (irange
&, const irange
&, const irange
&) const;
187 // Perform an float operation between 2 ranges and return it.
188 virtual void rv_fold (REAL_VALUE_TYPE
&lb
, REAL_VALUE_TYPE
&ub
,
191 const REAL_VALUE_TYPE
&lh_lb
,
192 const REAL_VALUE_TYPE
&lh_ub
,
193 const REAL_VALUE_TYPE
&rh_lb
,
194 const REAL_VALUE_TYPE
&rh_ub
,
195 relation_kind
) const;
198 class range_op_handler
202 range_op_handler (unsigned);
203 operator bool () const;
204 range_operator
*range_op () const;
206 bool fold_range (vrange
&r
, tree type
,
209 relation_trio
= TRIO_VARYING
) const;
210 bool op1_range (vrange
&r
, tree type
,
213 relation_trio
= TRIO_VARYING
) const;
214 bool op2_range (vrange
&r
, tree type
,
217 relation_trio
= TRIO_VARYING
) const;
218 relation_kind
lhs_op1_relation (const vrange
&lhs
,
221 relation_kind
= VREL_VARYING
) const;
222 relation_kind
lhs_op2_relation (const vrange
&lhs
,
225 relation_kind
= VREL_VARYING
) const;
226 relation_kind
op1_op2_relation (const vrange
&lhs
,
228 const vrange
&op2
) const;
229 bool overflow_free_p (const vrange
&lh
, const vrange
&rh
,
230 relation_trio
= TRIO_VARYING
) const;
232 unsigned dispatch_kind (const vrange
&lhs
, const vrange
&op1
,
233 const vrange
& op2
) const;
234 range_operator
*m_operator
;
237 // Cast the range in R to TYPE if R supports TYPE.
240 range_cast (vrange
&r
, tree type
)
242 gcc_checking_assert (r
.supports_type_p (type
));
244 Value_Range
varying (type
);
245 varying
.set_varying (type
);
246 // Call op_convert, if it fails, the result is varying.
247 if (!range_op_handler (CONVERT_EXPR
).fold_range (r
, type
, tmp
, varying
))
249 r
.set_varying (type
);
255 // Range cast which is capable of switching range kinds.
256 // ie for float to int.
259 range_cast (Value_Range
&r
, tree type
)
262 Value_Range
varying (type
);
263 varying
.set_varying (type
);
265 // Ensure we are in the correct mode for the call to fold.
268 // Call op_convert, if it fails, the result is varying.
269 if (!range_op_handler (CONVERT_EXPR
).fold_range (r
, type
, tmp
, varying
))
271 r
.set_varying (type
);
278 extern void wi_set_zero_nonzero_bits (tree type
,
279 const wide_int
&, const wide_int
&,
280 wide_int
&maybe_nonzero
,
281 wide_int
&mustbe_nonzero
);
283 // These are extra operators that do not fit in the normal scheme of things.
284 // Add them to the end of the tree-code vector, and provide a name for
285 // each allowing for easy access when required.
287 #define OP_WIDEN_MULT_SIGNED ((unsigned) MAX_TREE_CODES)
288 #define OP_WIDEN_MULT_UNSIGNED ((unsigned) MAX_TREE_CODES + 1)
289 #define OP_WIDEN_PLUS_SIGNED ((unsigned) MAX_TREE_CODES + 2)
290 #define OP_WIDEN_PLUS_UNSIGNED ((unsigned) MAX_TREE_CODES + 3)
291 #define RANGE_OP_TABLE_SIZE ((unsigned) MAX_TREE_CODES + 4)
293 // This implements the range operator tables as local objects.
299 inline range_operator
*operator[] (unsigned code
)
301 gcc_checking_assert (code
< RANGE_OP_TABLE_SIZE
);
302 return m_range_tree
[code
];
305 inline void set (unsigned code
, range_operator
&op
)
307 gcc_checking_assert (code
< RANGE_OP_TABLE_SIZE
);
308 gcc_checking_assert (m_range_tree
[code
] == NULL
);
309 m_range_tree
[code
] = &op
;
311 range_operator
*m_range_tree
[RANGE_OP_TABLE_SIZE
];
312 void initialize_integral_ops ();
313 void initialize_pointer_ops ();
314 void initialize_float_ops ();
316 #endif // GCC_RANGE_OP_H