]> git.ipfire.org Git - thirdparty/gcc.git/blame - gcc/range-op.h
Ada: Reapply tweaks to delay statements in ACATS 3&4 testsuites
[thirdparty/gcc.git] / gcc / range-op.h
CommitLineData
38a73435 1/* Header file for range operator class.
6441eb6d 2 Copyright (C) 2017-2025 Free Software Foundation, Inc.
38a73435
AH
3 Contributed by Andrew MacLeod <amacleod@redhat.com>
4 and Aldy Hernandez <aldyh@redhat.com>.
5
6This file is part of GCC.
7
8GCC is free software; you can redistribute it and/or modify it under
9the terms of the GNU General Public License as published by the Free
10Software Foundation; either version 3, or (at your option) any later
11version.
12
13GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14WARRANTY; without even the implied warranty of MERCHANTABILITY or
15FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 for more details.
17
18You should have received a copy of the GNU General Public License
19along with GCC; see the file COPYING3. If not see
20<http://www.gnu.org/licenses/>. */
21
22#ifndef GCC_RANGE_OP_H
23#define GCC_RANGE_OP_H
24
31377eed
AH
25enum range_op_dispatch_type
26{
27 DISPATCH_FOLD_RANGE,
28 DISPATCH_OP1_RANGE,
29 DISPATCH_OP2_RANGE,
30 DISPATCH_LHS_OP1_RELATION,
31 DISPATCH_LHS_OP2_RELATION,
32 DISPATCH_OP1_OP2_RELATION
33};
34
38a73435
AH
35// This class is implemented for each kind of operator supported by
36// the range generator. It serves various purposes.
37//
38// 1 - Generates range information for the specific operation between
39// two ranges. This provides the ability to fold ranges for an
40// expression.
41//
42// 2 - Performs range algebra on the expression such that a range can be
43// adjusted in terms of one of the operands:
44//
45// def = op1 + op2
46//
47// Given a range for def, we can adjust the range so that it is in
48// terms of either operand.
49//
50// op1_range (def_range, op2) will adjust the range in place so it
51// is in terms of op1. Since op1 = def - op2, it will subtract
52// op2 from each element of the range.
53//
54// 3 - Creates a range for an operand based on whether the result is 0 or
55// non-zero. This is mostly for logical true false, but can serve other
56// purposes.
57// ie 0 = op1 - op2 implies op2 has the same range as op1.
9c0fed50
AM
58//
59// 4 - All supported range combinations are explicitly specified.
60// Any desired combinations should be implemented for each operator.
61// When new range classes are added, new matching prototypes should be
62// added.
38a73435
AH
63
64class range_operator
65{
17586bdc 66 friend class range_op_table;
38a73435
AH
67public:
68 // Perform an operation between 2 ranges and return it.
4ba9fb0a
AH
69 virtual bool fold_range (irange &r, tree type,
70 const irange &lh,
80dd13f5 71 const irange &rh,
b565ac19 72 relation_trio = TRIO_VARYING) const;
9c0fed50
AM
73 virtual bool fold_range (frange &r, tree type,
74 const frange &lh,
75 const frange &rh,
76 relation_trio = TRIO_VARYING) const;
77 virtual bool fold_range (irange &r, tree type,
78 const frange &lh,
79 const irange &rh,
80 relation_trio = TRIO_VARYING) const;
81 virtual bool fold_range (irange &r, tree type,
82 const frange &lh,
83 const frange &rh,
84 relation_trio = TRIO_VARYING) const;
0ddc8c78
AM
85 virtual bool fold_range (frange &r, tree type,
86 const irange &lh,
87 const irange &rh,
88 relation_trio = TRIO_VARYING) const;
6f375445
AM
89 virtual bool fold_range (frange &r, tree type,
90 const irange &lh,
91 const frange &rh,
92 relation_trio = TRIO_VARYING) const;
31377eed
AH
93 virtual bool fold_range (prange &r, tree type,
94 const prange &lh,
95 const prange &rh,
96 relation_trio = TRIO_VARYING) const;
97 virtual bool fold_range (prange &r, tree type,
98 const prange &lh,
99 const irange &rh,
100 relation_trio = TRIO_VARYING) const;
101 virtual bool fold_range (irange &r, tree type,
102 const prange &lh,
103 const prange &rh,
104 relation_trio = TRIO_VARYING) const;
105 virtual bool fold_range (prange &r, tree type,
106 const irange &lh,
107 const prange &rh,
108 relation_trio = TRIO_VARYING) const;
109 virtual bool fold_range (irange &r, tree type,
110 const prange &lh,
111 const irange &rh,
112 relation_trio = TRIO_VARYING) const;
38a73435
AH
113
114 // Return the range for op[12] in the general case. LHS is the range for
115 // the LHS of the expression, OP[12]is the range for the other
116 //
117 // The operand and the result is returned in R.
118 //
119 // TYPE is the expected type of the range.
120 //
121 // Return TRUE if the operation is performed and a valid range is available.
122 //
123 // i.e. [LHS] = ??? + OP2
124 // is re-formed as R = [LHS] - OP2.
4ba9fb0a
AH
125 virtual bool op1_range (irange &r, tree type,
126 const irange &lhs,
80dd13f5 127 const irange &op2,
b565ac19 128 relation_trio = TRIO_VARYING) const;
31377eed
AH
129 virtual bool op1_range (prange &r, tree type,
130 const prange &lhs,
131 const prange &op2,
132 relation_trio = TRIO_VARYING) const;
133 virtual bool op1_range (prange &r, tree type,
134 const irange &lhs,
135 const prange &op2,
136 relation_trio = TRIO_VARYING) const;
137 virtual bool op1_range (prange &r, tree type,
138 const prange &lhs,
139 const irange &op2,
140 relation_trio = TRIO_VARYING) const;
141 virtual bool op1_range (irange &r, tree type,
142 const prange &lhs,
143 const irange &op2,
144 relation_trio = TRIO_VARYING) const;
9c0fed50
AM
145 virtual bool op1_range (frange &r, tree type,
146 const frange &lhs,
147 const frange &op2,
148 relation_trio = TRIO_VARYING) const;
149 virtual bool op1_range (frange &r, tree type,
150 const irange &lhs,
151 const frange &op2,
152 relation_trio = TRIO_VARYING) const;
6f375445
AM
153 virtual bool op1_range (irange &r, tree type,
154 const frange &lhs,
6f375445
AM
155 const irange &op2,
156 relation_trio = TRIO_VARYING) const;
9c0fed50 157
4ba9fb0a
AH
158 virtual bool op2_range (irange &r, tree type,
159 const irange &lhs,
80dd13f5 160 const irange &op1,
b565ac19 161 relation_trio = TRIO_VARYING) const;
31377eed
AH
162 virtual bool op2_range (prange &r, tree type,
163 const irange &lhs,
164 const prange &op1,
165 relation_trio = TRIO_VARYING) const;
166 virtual bool op2_range (irange &r, tree type,
167 const prange &lhs,
168 const prange &op1,
169 relation_trio = TRIO_VARYING) const;
9c0fed50
AM
170 virtual bool op2_range (frange &r, tree type,
171 const frange &lhs,
172 const frange &op1,
173 relation_trio = TRIO_VARYING) const;
174 virtual bool op2_range (frange &r, tree type,
175 const irange &lhs,
176 const frange &op1,
177 relation_trio = TRIO_VARYING) const;
38a73435 178
80dd13f5
AM
179 // The following routines are used to represent relations between the
180 // various operations. If the caller knows where the symbolics are,
181 // it can query for relationships between them given known ranges.
cf2141a0 182 // the optional relation passed in is the relation between op1 and op2.
ade5531c
AM
183 virtual relation_kind lhs_op1_relation (const irange &lhs,
184 const irange &op1,
185 const irange &op2,
186 relation_kind = VREL_VARYING) const;
31377eed
AH
187 virtual relation_kind lhs_op1_relation (const prange &lhs,
188 const prange &op1,
189 const prange &op2,
190 relation_kind = VREL_VARYING) const;
191 virtual relation_kind lhs_op1_relation (const prange &lhs,
192 const irange &op1,
193 const irange &op2,
194 relation_kind = VREL_VARYING) const;
195 virtual relation_kind lhs_op1_relation (const irange &lhs,
196 const prange &op1,
197 const prange &op2,
198 relation_kind = VREL_VARYING) const;
a76b2602
AM
199 virtual relation_kind lhs_op1_relation (const prange &lhs,
200 const prange &op1,
201 const irange &op2,
202 relation_kind = VREL_VARYING) const;
9c0fed50
AM
203 virtual relation_kind lhs_op1_relation (const frange &lhs,
204 const frange &op1,
205 const frange &op2,
206 relation_kind = VREL_VARYING) const;
207 virtual relation_kind lhs_op1_relation (const irange &lhs,
208 const frange &op1,
209 const frange &op2,
210 relation_kind = VREL_VARYING) const;
211
ade5531c
AM
212 virtual relation_kind lhs_op2_relation (const irange &lhs,
213 const irange &op1,
214 const irange &op2,
215 relation_kind = VREL_VARYING) const;
9c0fed50
AM
216 virtual relation_kind lhs_op2_relation (const frange &lhs,
217 const frange &op1,
218 const frange &op2,
219 relation_kind = VREL_VARYING) const;
220 virtual relation_kind lhs_op2_relation (const irange &lhs,
221 const frange &op1,
222 const frange &op2,
223 relation_kind = VREL_VARYING) const;
224
9fedc3c0
AM
225 virtual relation_kind op1_op2_relation (const irange &lhs,
226 const irange &op1,
227 const irange &op2) const;
31377eed
AH
228 virtual relation_kind op1_op2_relation (const irange &lhs,
229 const prange &op1,
230 const prange &op2) const;
9fedc3c0
AM
231 virtual relation_kind op1_op2_relation (const irange &lhs,
232 const frange &op1,
233 const frange &op2) const;
234 virtual relation_kind op1_op2_relation (const frange &lhs,
235 const frange &op1,
236 const frange &op2) const;
97442a08
JG
237
238 virtual bool overflow_free_p (const irange &lh, const irange &rh,
239 relation_trio = TRIO_VARYING) const;
ea19de92
AM
240
241 // Compatability check for operands.
242 virtual bool operand_check_p (tree, tree, tree) const;
243
38a73435 244protected:
f674b4a7 245 // Perform an integral operation between 2 sub-ranges and return it.
4ba9fb0a 246 virtual void wi_fold (irange &r, tree type,
bb74ef9e
AM
247 const wide_int &lh_lb,
248 const wide_int &lh_ub,
249 const wide_int &rh_lb,
250 const wide_int &rh_ub) const;
156d7d8d 251 // Effect of relation for generic fold_range clients.
80dd13f5
AM
252 virtual bool op1_op2_relation_effect (irange &lhs_range, tree type,
253 const irange &op1_range,
254 const irange &op2_range,
255 relation_kind rel) const;
31377eed
AH
256 virtual bool op1_op2_relation_effect (prange &lhs_range, tree type,
257 const prange &op1_range,
258 const prange &op2_range,
259 relation_kind rel) const;
260 virtual bool op1_op2_relation_effect (prange &lhs_range, tree type,
261 const prange &op1_range,
262 const irange &op2_range,
263 relation_kind rel) const;
264 virtual bool op1_op2_relation_effect (irange &lhs_range, tree type,
265 const prange &op1_range,
266 const prange &op2_range,
267 relation_kind rel) const;
268 virtual bool op1_op2_relation_effect (prange &lhs_range, tree type,
269 const irange &op1_range,
270 const prange &op2_range,
271 relation_kind rel) const;
272 virtual bool op1_op2_relation_effect (irange &lhs_range, tree type,
273 const prange &op1_range,
274 const irange &op2_range,
275 relation_kind rel) const;
704e8a82
AM
276 // Called by fold range to split small subranges into parts.
277 void wi_fold_in_parts (irange &r, tree type,
278 const wide_int &lh_lb,
279 const wide_int &lh_ub,
280 const wide_int &rh_lb,
281 const wide_int &rh_ub) const;
809d661a
AM
282
283 // Called by fold range to split small subranges into parts when op1 == op2
284 void wi_fold_in_parts_equiv (irange &r, tree type,
285 const wide_int &lb,
286 const wide_int &ub,
287 unsigned limit) const;
cd4b7e8b
AM
288 // Apply any bitmasks implied by these ranges.
289 virtual void update_bitmask (irange &, const irange &, const irange &) const;
31377eed 290 virtual void update_bitmask (irange &, const prange &, const prange &) const;
a6efab5f 291
9c0fed50 292 // Perform an float operation between 2 ranges and return it.
24e97ac4 293 virtual void rv_fold (frange &r, tree type,
0ef5649e
AH
294 const REAL_VALUE_TYPE &lh_lb,
295 const REAL_VALUE_TYPE &lh_ub,
296 const REAL_VALUE_TYPE &rh_lb,
2f7f9edd
JJ
297 const REAL_VALUE_TYPE &rh_ub,
298 relation_kind) const;
a6efab5f
AH
299};
300
cf5bea76
AH
301class range_op_handler
302{
303public:
51ce0638 304 range_op_handler ();
5410b07a 305 range_op_handler (unsigned);
1b1de36a
AM
306 operator bool () const;
307 range_operator *range_op () const;
cf5bea76
AH
308
309 bool fold_range (vrange &r, tree type,
310 const vrange &lh,
311 const vrange &rh,
b565ac19 312 relation_trio = TRIO_VARYING) const;
cf5bea76
AH
313 bool op1_range (vrange &r, tree type,
314 const vrange &lhs,
315 const vrange &op2,
b565ac19 316 relation_trio = TRIO_VARYING) const;
cf5bea76
AH
317 bool op2_range (vrange &r, tree type,
318 const vrange &lhs,
319 const vrange &op1,
b565ac19 320 relation_trio = TRIO_VARYING) const;
cf5bea76
AH
321 relation_kind lhs_op1_relation (const vrange &lhs,
322 const vrange &op1,
323 const vrange &op2,
324 relation_kind = VREL_VARYING) const;
325 relation_kind lhs_op2_relation (const vrange &lhs,
326 const vrange &op1,
327 const vrange &op2,
328 relation_kind = VREL_VARYING) const;
9fedc3c0
AM
329 relation_kind op1_op2_relation (const vrange &lhs,
330 const vrange &op1,
331 const vrange &op2) const;
97442a08
JG
332 bool overflow_free_p (const vrange &lh, const vrange &rh,
333 relation_trio = TRIO_VARYING) const;
ea19de92 334 bool operand_check_p (tree, tree, tree) const;
51ce0638 335protected:
cd9c7f89
AM
336 unsigned dispatch_kind (const vrange &lhs, const vrange &op1,
337 const vrange& op2) const;
31377eed
AH
338 void discriminator_fail (const vrange &,
339 const vrange &,
340 const vrange &) const;
cd9c7f89 341 range_operator *m_operator;
cf5bea76
AH
342};
343
c570818b
AM
344// Cast the range in R to TYPE if R supports TYPE.
345
346inline bool
347range_cast (vrange &r, tree type)
348{
349 gcc_checking_assert (r.supports_type_p (type));
3dedfad5
AH
350 value_range tmp (r);
351 value_range varying (type);
c570818b 352 varying.set_varying (type);
c570818b 353 // Call op_convert, if it fails, the result is varying.
2eb50117 354 if (!range_op_handler (CONVERT_EXPR).fold_range (r, type, tmp, varying))
c570818b
AM
355 {
356 r.set_varying (type);
357 return false;
358 }
359 return true;
360}
361
362// Range cast which is capable of switching range kinds.
363// ie for float to int.
364
365inline bool
3dedfad5 366range_cast (value_range &r, tree type)
c570818b 367{
3dedfad5
AH
368 value_range tmp (r);
369 value_range varying (type);
c570818b
AM
370 varying.set_varying (type);
371
372 // Ensure we are in the correct mode for the call to fold.
373 r.set_type (type);
374
c570818b 375 // Call op_convert, if it fails, the result is varying.
2eb50117 376 if (!range_op_handler (CONVERT_EXPR).fold_range (r, type, tmp, varying))
c570818b
AM
377 {
378 r.set_varying (type);
379 return false;
380 }
381 return true;
382}
383
384
8f119c55
AH
385extern void wi_set_zero_nonzero_bits (tree type,
386 const wide_int &, const wide_int &,
387 wide_int &maybe_nonzero,
388 wide_int &mustbe_nonzero);
38a73435 389
5410b07a
AM
390// These are extra operators that do not fit in the normal scheme of things.
391// Add them to the end of the tree-code vector, and provide a name for
392// each allowing for easy access when required.
393
394#define OP_WIDEN_MULT_SIGNED ((unsigned) MAX_TREE_CODES)
395#define OP_WIDEN_MULT_UNSIGNED ((unsigned) MAX_TREE_CODES + 1)
396#define OP_WIDEN_PLUS_SIGNED ((unsigned) MAX_TREE_CODES + 2)
397#define OP_WIDEN_PLUS_UNSIGNED ((unsigned) MAX_TREE_CODES + 3)
398#define RANGE_OP_TABLE_SIZE ((unsigned) MAX_TREE_CODES + 4)
399
9eb38e88
AH
400// This implements the range operator tables as local objects.
401
402class range_op_table
403{
404public:
1c0aae69 405 range_op_table ();
5410b07a 406 inline range_operator *operator[] (unsigned code)
1c0aae69 407 {
5410b07a 408 gcc_checking_assert (code < RANGE_OP_TABLE_SIZE);
1c0aae69
AM
409 return m_range_tree[code];
410 }
07767389 411protected:
5410b07a 412 inline void set (unsigned code, range_operator &op)
1c0aae69 413 {
5410b07a 414 gcc_checking_assert (code < RANGE_OP_TABLE_SIZE);
1c0aae69
AM
415 gcc_checking_assert (m_range_tree[code] == NULL);
416 m_range_tree[code] = &op;
417 }
5410b07a 418 range_operator *m_range_tree[RANGE_OP_TABLE_SIZE];
07767389
AM
419 void initialize_integral_ops ();
420 void initialize_pointer_ops ();
421 void initialize_float_ops ();
9eb38e88 422};
31377eed 423
38a73435 424#endif // GCC_RANGE_OP_H