GCC Middle and Back End API Reference
range-op-mixed.h
Go to the documentation of this file.
1/* Header file for mixed range operator class.
2 Copyright (C) 2017-2026 Free Software Foundation, Inc.
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_MIXED_H
23#define GCC_RANGE_OP_MIXED_H
24
25void update_known_bitmask (vrange &, tree_code, const vrange &, const vrange &);
26bool minus_op1_op2_relation_effect (irange &lhs_range, tree type,
27 const irange &, const irange &,
28 relation_kind rel);
29
30
31// Return TRUE if 0 is within [WMIN, WMAX].
32
33inline bool
34wi_includes_zero_p (tree type, const wide_int &wmin, const wide_int &wmax)
35{
36 signop sign = TYPE_SIGN (type);
37 return wi::le_p (wmin, 0, sign) && wi::ge_p (wmax, 0, sign);
38}
39
40// Return TRUE if [WMIN, WMAX] is the singleton 0.
41
42inline bool
43wi_zero_p (tree type, const wide_int &wmin, const wide_int &wmax)
44{
45 unsigned prec = TYPE_PRECISION (type);
46 return wmin == wmax && wi::eq_p (wmin, wi::zero (prec));
47}
48
49
50enum bool_range_state { BRS_FALSE, BRS_TRUE, BRS_EMPTY, BRS_FULL };
51bool_range_state get_bool_state (vrange &r, const vrange &lhs, tree val_type);
52
53// If the range of either op1 or op2 is undefined, set the result to
54// varying and return TRUE. If the caller truly cares about a result,
55// they should pass in a varying if it has an undefined that it wants
56// treated as a varying.
57
58inline bool
59empty_range_varying (vrange &r, tree type,
60 const vrange &op1, const vrange & op2)
61{
62 if (op1.undefined_p () || op2.undefined_p ())
63 {
64 r.set_varying (type);
65 return true;
66 }
67 else
68 return false;
69}
70
71// For relation opcodes, first try to see if the supplied relation
72// forces a true or false result, and return that.
73// Then check for undefined operands. If none of this applies,
74// return false.
75
76inline bool
77relop_early_resolve (irange &r, tree type, const vrange &op1,
78 const vrange &op2, relation_trio trio,
79 relation_kind my_rel)
80{
81 relation_kind rel = trio.op1_op2 ();
82 // If known relation is a complete subset of this relation, always true.
83 if (relation_union (rel, my_rel) == my_rel)
84 {
85 r = range_true (type);
86 return true;
87 }
88
89 // If known relation has no subset of this relation, always false.
90 if (relation_intersect (rel, my_rel) == VREL_UNDEFINED)
91 {
92 r = range_false (type);
93 return true;
94 }
95
96 // If either operand is undefined, return VARYING.
97 if (empty_range_varying (r, type, op1, op2))
98 return true;
99
100 return false;
101}
102
103// ----------------------------------------------------------------------
104// Mixed Mode Operators.
105// ----------------------------------------------------------------------
106
107class operator_equal : public range_operator
108{
109public:
110 using range_operator::fold_range;
111 using range_operator::op1_range;
112 using range_operator::op2_range;
113 using range_operator::op1_op2_relation;
114 using range_operator::update_bitmask;
115 bool fold_range (irange &r, tree type,
116 const irange &op1, const irange &op2,
117 relation_trio = TRIO_VARYING) const final override;
118 bool fold_range (irange &r, tree type,
119 const prange &op1, const prange &op2,
120 relation_trio = TRIO_VARYING) const final override;
121 bool fold_range (irange &r, tree type,
122 const frange &op1, const frange &op2,
123 relation_trio = TRIO_VARYING) const final override;
124
125 bool op1_range (irange &r, tree type,
126 const irange &lhs, const irange &val,
127 relation_trio = TRIO_VARYING) const final override;
128 bool op1_range (prange &r, tree type,
129 const irange &lhs, const prange &val,
130 relation_trio = TRIO_VARYING) const final override;
131 bool op1_range (frange &r, tree type,
132 const irange &lhs, const frange &op2,
133 relation_trio = TRIO_VARYING) const final override;
134
135 bool op2_range (irange &r, tree type,
136 const irange &lhs, const irange &val,
137 relation_trio = TRIO_VARYING) const final override;
138 bool op2_range (prange &r, tree type,
139 const irange &lhs, const prange &val,
140 relation_trio = TRIO_VARYING) const final override;
141 bool op2_range (frange &r, tree type,
142 const irange &lhs, const frange &op1,
143 relation_trio rel = TRIO_VARYING) const final override;
144
145 relation_kind op1_op2_relation (const irange &lhs, const irange &,
146 const irange &) const final override;
147 relation_kind op1_op2_relation (const irange &lhs, const prange &,
148 const prange &) const final override;
149 relation_kind op1_op2_relation (const irange &lhs, const frange &,
150 const frange &) const final override;
151 void update_bitmask (irange &r, const irange &lh,
152 const irange &rh) const final override;
153 // Check op1 and op2 for compatibility.
154 bool operand_check_p (tree t1, tree t2, tree t3) const final override
155 { return range_compatible_p (t2, t3) && INTEGRAL_TYPE_P (t1); }
156};
157
158class operator_not_equal : public range_operator
159{
160public:
161 using range_operator::fold_range;
162 using range_operator::op1_range;
163 using range_operator::op2_range;
164 using range_operator::op1_op2_relation;
165 using range_operator::update_bitmask;
166 bool fold_range (irange &r, tree type,
167 const irange &op1, const irange &op2,
168 relation_trio = TRIO_VARYING) const final override;
169 bool fold_range (irange &r, tree type,
170 const prange &op1, const prange &op2,
171 relation_trio rel = TRIO_VARYING) const final override;
172 bool fold_range (irange &r, tree type,
173 const frange &op1, const frange &op2,
174 relation_trio rel = TRIO_VARYING) const final override;
175
176 bool op1_range (irange &r, tree type,
177 const irange &lhs, const irange &op2,
178 relation_trio = TRIO_VARYING) const final override;
179 bool op1_range (prange &r, tree type,
180 const irange &lhs, const prange &op2,
181 relation_trio = TRIO_VARYING) const final override;
182 bool op1_range (frange &r, tree type,
183 const irange &lhs, const frange &op2,
184 relation_trio = TRIO_VARYING) const final override;
185
186 bool op2_range (irange &r, tree type,
187 const irange &lhs, const irange &op1,
188 relation_trio = TRIO_VARYING) const final override;
189 bool op2_range (prange &r, tree type,
190 const irange &lhs, const prange &op1,
191 relation_trio = TRIO_VARYING) const final override;
192 bool op2_range (frange &r, tree type,
193 const irange &lhs, const frange &op1,
194 relation_trio = TRIO_VARYING) const final override;
195
196 relation_kind op1_op2_relation (const irange &lhs, const irange &,
197 const irange &) const final override;
198 relation_kind op1_op2_relation (const irange &lhs, const prange &,
199 const prange &) const final override;
200 relation_kind op1_op2_relation (const irange &lhs, const frange &,
201 const frange &) const final override;
202 void update_bitmask (irange &r, const irange &lh,
203 const irange &rh) const final override;
204 // Check op1 and op2 for compatibility.
205 bool operand_check_p (tree t0, tree t1, tree t2) const final override
206 { return range_compatible_p (t1, t2) && INTEGRAL_TYPE_P (t0); }
207};
208
209class operator_lt : public range_operator
210{
211public:
212 using range_operator::fold_range;
213 using range_operator::op1_range;
214 using range_operator::op2_range;
215 using range_operator::op1_op2_relation;
216 using range_operator::update_bitmask;
217 bool fold_range (irange &r, tree type,
218 const irange &op1, const irange &op2,
219 relation_trio = TRIO_VARYING) const final override;
220 bool fold_range (irange &r, tree type,
221 const prange &op1, const prange &op2,
222 relation_trio = TRIO_VARYING) const final override;
223 bool fold_range (irange &r, tree type,
224 const frange &op1, const frange &op2,
225 relation_trio = TRIO_VARYING) const final override;
226 bool op1_range (irange &r, tree type,
227 const irange &lhs, const irange &op2,
228 relation_trio = TRIO_VARYING) const final override;
229 bool op1_range (prange &r, tree type,
230 const irange &lhs, const prange &op2,
231 relation_trio = TRIO_VARYING) const final override;
232 bool op1_range (frange &r, tree type,
233 const irange &lhs, const frange &op2,
234 relation_trio = TRIO_VARYING) const final override;
235 bool op2_range (irange &r, tree type,
236 const irange &lhs, const irange &op1,
237 relation_trio = TRIO_VARYING) const final override;
238 bool op2_range (prange &r, tree type,
239 const irange &lhs, const prange &op1,
240 relation_trio = TRIO_VARYING) const final override;
241 bool op2_range (frange &r, tree type,
242 const irange &lhs, const frange &op1,
243 relation_trio = TRIO_VARYING) const final override;
244 relation_kind op1_op2_relation (const irange &lhs, const irange &,
245 const irange &) const final override;
246 relation_kind op1_op2_relation (const irange &lhs, const prange &,
247 const prange &) const final override;
248 relation_kind op1_op2_relation (const irange &lhs, const frange &,
249 const frange &) const final override;
250 void update_bitmask (irange &r, const irange &lh,
251 const irange &rh) const final override;
252 // Check op1 and op2 for compatibility.
253 bool operand_check_p (tree t1, tree t2, tree t3) const final override
254 { return range_compatible_p (t2, t3) && INTEGRAL_TYPE_P (t1); }
255};
256
257class operator_le : public range_operator
258{
259public:
260 using range_operator::fold_range;
261 using range_operator::op1_range;
262 using range_operator::op2_range;
263 using range_operator::op1_op2_relation;
264 using range_operator::update_bitmask;
265 bool fold_range (irange &r, tree type,
266 const irange &op1, const irange &op2,
267 relation_trio = TRIO_VARYING) const final override;
268 bool fold_range (irange &r, tree type,
269 const prange &op1, const prange &op2,
270 relation_trio = TRIO_VARYING) const final override;
271 bool fold_range (irange &r, tree type,
272 const frange &op1, const frange &op2,
273 relation_trio rel = TRIO_VARYING) const final override;
274
275 bool op1_range (irange &r, tree type,
276 const irange &lhs, const irange &op2,
277 relation_trio = TRIO_VARYING) const final override;
278 bool op1_range (prange &r, tree type,
279 const irange &lhs, const prange &op2,
280 relation_trio = TRIO_VARYING) const final override;
281 bool op1_range (frange &r, tree type,
282 const irange &lhs, const frange &op2,
283 relation_trio rel = TRIO_VARYING) const final override;
284
285 bool op2_range (irange &r, tree type,
286 const irange &lhs, const irange &op1,
287 relation_trio = TRIO_VARYING) const final override;
288 bool op2_range (prange &r, tree type,
289 const irange &lhs, const prange &op1,
290 relation_trio = TRIO_VARYING) const final override;
291 bool op2_range (frange &r, tree type,
292 const irange &lhs, const frange &op1,
293 relation_trio rel = TRIO_VARYING) const final override;
294
295 relation_kind op1_op2_relation (const irange &lhs, const irange &,
296 const irange &) const final override;
297 relation_kind op1_op2_relation (const irange &lhs, const prange &,
298 const prange &) const final override;
299 relation_kind op1_op2_relation (const irange &lhs, const frange &,
300 const frange &) const final override;
301 void update_bitmask (irange &r, const irange &lh,
302 const irange &rh) const final override;
303 // Check op1 and op2 for compatibility.
304 bool operand_check_p (tree t1, tree t2, tree t3) const final override
305 { return range_compatible_p (t2, t3) && INTEGRAL_TYPE_P (t1); }
306};
307
308class operator_gt : public range_operator
309{
310public:
311 using range_operator::fold_range;
312 using range_operator::op1_range;
313 using range_operator::op2_range;
314 using range_operator::op1_op2_relation;
315 using range_operator::update_bitmask;
316 bool fold_range (irange &r, tree type,
317 const irange &op1, const irange &op2,
318 relation_trio = TRIO_VARYING) const final override;
319 bool fold_range (irange &r, tree type,
320 const prange &op1, const prange &op2,
321 relation_trio = TRIO_VARYING) const final override;
322 bool fold_range (irange &r, tree type,
323 const frange &op1, const frange &op2,
324 relation_trio = TRIO_VARYING) const final override;
325
326 bool op1_range (irange &r, tree type,
327 const irange &lhs, const irange &op2,
328 relation_trio = TRIO_VARYING) const final override;
329 bool op1_range (prange &r, tree type,
330 const irange &lhs, const prange &op2,
331 relation_trio = TRIO_VARYING) const final override;
332 bool op1_range (frange &r, tree type,
333 const irange &lhs, const frange &op2,
334 relation_trio = TRIO_VARYING) const final override;
335
336 bool op2_range (irange &r, tree type,
337 const irange &lhs, const irange &op1,
338 relation_trio = TRIO_VARYING) const final override;
339 bool op2_range (prange &r, tree type,
340 const irange &lhs, const prange &op1,
341 relation_trio = TRIO_VARYING) const final override;
342 bool op2_range (frange &r, tree type,
343 const irange &lhs, const frange &op1,
344 relation_trio = TRIO_VARYING) const final override;
345 relation_kind op1_op2_relation (const irange &lhs, const irange &,
346 const irange &) const final override;
347 relation_kind op1_op2_relation (const irange &lhs, const prange &,
348 const prange &) const final override;
349 relation_kind op1_op2_relation (const irange &lhs, const frange &,
350 const frange &) const final override;
351 void update_bitmask (irange &r, const irange &lh,
352 const irange &rh) const final override;
353 // Check op1 and op2 for compatibility.
354 bool operand_check_p (tree t1, tree t2, tree t3) const final override
355 { return range_compatible_p (t2, t3) && INTEGRAL_TYPE_P (t1); }
356};
357
358class operator_ge : public range_operator
359{
360public:
361 using range_operator::fold_range;
362 using range_operator::op1_range;
363 using range_operator::op2_range;
364 using range_operator::op1_op2_relation;
365 using range_operator::update_bitmask;
366 bool fold_range (irange &r, tree type,
367 const irange &op1, const irange &op2,
368 relation_trio = TRIO_VARYING) const final override;
369 bool fold_range (irange &r, tree type,
370 const prange &op1, const prange &op2,
371 relation_trio = TRIO_VARYING) const final override;
372 bool fold_range (irange &r, tree type,
373 const frange &op1, const frange &op2,
374 relation_trio = TRIO_VARYING) const final override;
375
376 bool op1_range (irange &r, tree type,
377 const irange &lhs, const irange &op2,
378 relation_trio = TRIO_VARYING) const final override;
379 bool op1_range (prange &r, tree type,
380 const irange &lhs, const prange &op2,
381 relation_trio = TRIO_VARYING) const final override;
382 bool op1_range (frange &r, tree type,
383 const irange &lhs, const frange &op2,
384 relation_trio = TRIO_VARYING) const final override;
385
386 bool op2_range (irange &r, tree type,
387 const irange &lhs, const irange &op1,
388 relation_trio = TRIO_VARYING) const final override;
389 bool op2_range (prange &r, tree type,
390 const irange &lhs, const prange &op1,
391 relation_trio = TRIO_VARYING) const final override;
392 bool op2_range (frange &r, tree type,
393 const irange &lhs, const frange &op1,
394 relation_trio = TRIO_VARYING) const final override;
395
396 relation_kind op1_op2_relation (const irange &lhs, const irange &,
397 const irange &) const final override;
398 relation_kind op1_op2_relation (const irange &lhs, const prange &,
399 const prange &) const final override;
400 relation_kind op1_op2_relation (const irange &lhs, const frange &,
401 const frange &) const final override;
402 void update_bitmask (irange &r, const irange &lh,
403 const irange &rh) const final override;
404 // Check op1 and op2 for compatibility.
405 bool operand_check_p (tree t1, tree t2, tree t3) const final override
406 { return range_compatible_p (t2, t3) && INTEGRAL_TYPE_P (t1); }
407};
408
409class operator_identity : public range_operator
410{
411public:
412 using range_operator::fold_range;
413 using range_operator::op1_range;
414 using range_operator::lhs_op1_relation;
415 bool fold_range (irange &r, tree type,
416 const irange &op1, const irange &op2,
417 relation_trio rel = TRIO_VARYING) const final override;
418 bool fold_range (prange &r, tree type,
419 const prange &op1, const prange &op2,
420 relation_trio rel = TRIO_VARYING) const final override;
421 bool fold_range (frange &r, tree type ATTRIBUTE_UNUSED,
422 const frange &op1, const frange &op2 ATTRIBUTE_UNUSED,
423 relation_trio = TRIO_VARYING) const final override;
424 bool op1_range (irange &r, tree type,
425 const irange &lhs, const irange &op2,
426 relation_trio rel = TRIO_VARYING) const final override;
427 bool op1_range (prange &r, tree type,
428 const prange &lhs, const prange &op2,
429 relation_trio rel = TRIO_VARYING) const final override;
430 bool op1_range (frange &r, tree type ATTRIBUTE_UNUSED,
431 const frange &lhs, const frange &op2 ATTRIBUTE_UNUSED,
432 relation_trio = TRIO_VARYING) const final override;
433 relation_kind lhs_op1_relation (const irange &lhs,
434 const irange &op1, const irange &op2,
435 relation_kind rel) const final override;
436 relation_kind lhs_op1_relation (const prange &lhs,
437 const prange &op1, const prange &op2,
438 relation_kind rel) const final override;
439};
440
441class operator_cst : public range_operator
442{
443public:
444 using range_operator::fold_range;
445 bool fold_range (irange &r, tree type,
446 const irange &op1, const irange &op2,
447 relation_trio rel = TRIO_VARYING) const final override;
448 bool fold_range (prange &r, tree type,
449 const prange &op1, const prange &op2,
450 relation_trio rel = TRIO_VARYING) const final override;
451 bool fold_range (frange &r, tree type,
452 const frange &op1, const frange &op2,
453 relation_trio = TRIO_VARYING) const final override;
454};
455
456
457class operator_cast: public range_operator
458{
459public:
460 using range_operator::fold_range;
461 using range_operator::op1_range;
462 using range_operator::lhs_op1_relation;
463 using range_operator::update_bitmask;
464 bool fold_range (irange &r, tree type,
465 const irange &op1, const irange &op2,
466 relation_trio rel = TRIO_VARYING) const final override;
467 bool fold_range (prange &r, tree type,
468 const prange &op1, const prange &op2,
469 relation_trio rel = TRIO_VARYING) const final override;
470 bool fold_range (irange &r, tree type,
471 const prange &op1, const irange &op2,
472 relation_trio rel = TRIO_VARYING) const final override;
473 bool fold_range (prange &r, tree type,
474 const irange &op1, const prange &op2,
475 relation_trio rel = TRIO_VARYING) const final override;
476 bool fold_range (frange &r, tree type,
477 const frange &op1, const frange &op2,
478 relation_trio = TRIO_VARYING) const final override;
479 bool fold_range (irange &r, tree type,
480 const frange &op1, const irange &op2,
481 relation_trio = TRIO_VARYING) const final override;
482 bool fold_range (frange &r, tree type,
483 const irange &op1, const frange &op2,
484 relation_trio = TRIO_VARYING) const final override;
485
486 bool op1_range (irange &r, tree type,
487 const irange &lhs, const irange &op2,
488 relation_trio rel = TRIO_VARYING) const final override;
489 bool op1_range (prange &r, tree type,
490 const prange &lhs, const prange &op2,
491 relation_trio rel = TRIO_VARYING) const final override;
492 bool op1_range (irange &r, tree type,
493 const prange &lhs, const irange &op2,
494 relation_trio rel = TRIO_VARYING) const final override;
495 bool op1_range (prange &r, tree type,
496 const irange &lhs, const prange &op2,
497 relation_trio rel = TRIO_VARYING) const final override;
498 bool op1_range (frange &r, tree type,
499 const frange &lhs, const frange &op2,
500 relation_trio = TRIO_VARYING) const final override;
501 bool op1_range (frange &r, tree type,
502 const irange &lhs, const frange &op2,
503 relation_trio = TRIO_VARYING) const final override;
504 bool op1_range (irange &r, tree type,
505 const frange &lhs, const irange &op2,
506 relation_trio = TRIO_VARYING) const final override;
507
508 relation_kind lhs_op1_relation (const irange &lhs,
509 const irange &op1, const irange &op2,
510 relation_kind) const final override;
511 relation_kind lhs_op1_relation (const prange &lhs,
512 const prange &op1, const prange &op2,
513 relation_kind) const final override;
514 relation_kind lhs_op1_relation (const prange &lhs,
515 const irange &op1, const irange &op2,
516 relation_kind) const final override;
517 relation_kind lhs_op1_relation (const irange &lhs,
518 const prange &op1, const prange &op2,
519 relation_kind) const final override;
520 void update_bitmask (irange &r, const irange &lh,
521 const irange &rh) const final override;
522private:
523 bool truncating_cast_p (const irange &inner, const irange &outer) const;
524 bool inside_domain_p (const wide_int &min, const wide_int &max,
525 const irange &outer) const;
526 void fold_pair (irange &r, unsigned index, const irange &inner,
527 const irange &outer) const;
528};
529
530
531class operator_view : public range_operator
532{
533public:
534 using range_operator::fold_range;
535 using range_operator::op1_range;
536 using range_operator::update_bitmask;
537 bool fold_range (irange &r, tree type,
538 const irange &op1, const irange &op2,
539 relation_trio rel = TRIO_VARYING) const override;
540 bool fold_range (prange &r, tree type,
541 const prange &op1, const prange &op2,
542 relation_trio rel = TRIO_VARYING) const final override;
543 bool fold_range (irange &r, tree type,
544 const prange &op1, const irange &op2,
545 relation_trio rel = TRIO_VARYING) const final override;
546 bool fold_range (prange &r, tree type,
547 const irange &op1, const prange &op2,
548 relation_trio rel = TRIO_VARYING) const final override;
549
550 bool op1_range (irange &r, tree type,
551 const irange &lhs, const irange &op2,
552 relation_trio rel = TRIO_VARYING) const override;
553 bool op1_range (prange &r, tree type,
554 const prange &lhs, const prange &op2,
555 relation_trio rel = TRIO_VARYING) const final override;
556 bool op1_range (irange &r, tree type,
557 const prange &lhs, const irange &op2,
558 relation_trio rel = TRIO_VARYING) const final override;
559 bool op1_range (prange &r, tree type,
560 const irange &lhs, const prange &op2,
561 relation_trio rel = TRIO_VARYING) const final override;
562
563 void update_bitmask (irange &r, const irange &lh,
564 const irange &) const final override;
565private:
566// VIEW_CONVERT_EXPR works much like a cast between integral values, so use
567// the cast operator. Non-integrals are not handled as yet.
568 operator_cast m_cast;
569};
570
571class operator_plus : public range_operator
572{
573public:
574 using range_operator::op1_range;
575 using range_operator::op2_range;
576 using range_operator::lhs_op1_relation;
577 using range_operator::lhs_op2_relation;
578 using range_operator::update_bitmask;
579 bool op1_range (irange &r, tree type,
580 const irange &lhs, const irange &op2,
581 relation_trio) const final override;
582 bool op1_range (frange &r, tree type,
583 const frange &lhs, const frange &op2,
584 relation_trio = TRIO_VARYING) const final override;
585
586 bool op2_range (irange &r, tree type,
587 const irange &lhs, const irange &op1,
588 relation_trio) const final override;
589 bool op2_range (frange &r, tree type,
590 const frange &lhs, const frange &op1,
591 relation_trio = TRIO_VARYING) const final override;
592
593 relation_kind lhs_op1_relation (const irange &lhs, const irange &op1,
594 const irange &op2,
595 relation_kind rel) const final override;
596 relation_kind lhs_op2_relation (const irange &lhs, const irange &op1,
597 const irange &op2,
598 relation_kind rel) const final override;
599 void update_bitmask (irange &r, const irange &lh,
600 const irange &rh) const final override;
601
602 bool overflow_free_p (const irange &lh, const irange &rh,
603 relation_trio = TRIO_VARYING) const final override;
604 // Check compatibility of all operands.
605 bool operand_check_p (tree t1, tree t2, tree t3) const final override
606 { return range_compatible_p (t1, t2) && range_compatible_p (t1, t3); }
607private:
608 void wi_fold (irange &r, tree type, const wide_int &lh_lb,
609 const wide_int &lh_ub, const wide_int &rh_lb,
610 const wide_int &rh_ub) const final override;
611 void rv_fold (frange &r, tree type,
612 const REAL_VALUE_TYPE &lh_lb, const REAL_VALUE_TYPE &lh_ub,
613 const REAL_VALUE_TYPE &rh_lb, const REAL_VALUE_TYPE &rh_ub,
614 relation_kind) const final override;
615};
616
617class operator_abs : public range_operator
618{
619 public:
620 using range_operator::fold_range;
621 using range_operator::op1_range;
622 using range_operator::update_bitmask;
623 bool fold_range (frange &r, tree type,
624 const frange &op1, const frange &,
625 relation_trio = TRIO_VARYING) const final override;
626
627 bool op1_range (irange &r, tree type, const irange &lhs,
628 const irange &op2, relation_trio) const final override;
629 bool op1_range (frange &r, tree type,
630 const frange &lhs, const frange &op2,
631 relation_trio rel = TRIO_VARYING) const final override;
632 void update_bitmask (irange &r, const irange &lh,
633 const irange &rh) const final override;
634 // Check compatibility of LHS and op1.
635 bool operand_check_p (tree t1, tree t2, tree) const final override
636 { return range_compatible_p (t1, t2); }
637private:
638 void wi_fold (irange &r, tree type, const wide_int &lh_lb,
639 const wide_int &lh_ub, const wide_int &rh_lb,
640 const wide_int &rh_ub) const final override;
641
642};
643
644class operator_minus : public range_operator
645{
646public:
647 using range_operator::fold_range;
648 using range_operator::op1_range;
649 using range_operator::op2_range;
650 using range_operator::lhs_op1_relation;
651 using range_operator::op1_op2_relation;
652 using range_operator::op1_op2_relation_effect;
653 using range_operator::update_bitmask;
654 bool op1_range (irange &r, tree type,
655 const irange &lhs, const irange &op2,
656 relation_trio) const final override;
657 bool op1_range (frange &r, tree type,
658 const frange &lhs, const frange &op2,
659 relation_trio = TRIO_VARYING) const final override;
660
661 bool op2_range (irange &r, tree type,
662 const irange &lhs, const irange &op1,
663 relation_trio) const final override;
664 bool op2_range (frange &r, tree type,
665 const frange &lhs,
666 const frange &op1,
667 relation_trio = TRIO_VARYING) const final override;
668
669 relation_kind lhs_op1_relation (const irange &lhs,
670 const irange &op1, const irange &op2,
671 relation_kind rel) const final override;
672 relation_kind op1_op2_relation (const irange &lhs, const irange &,
673 const irange &) const final override;
674 bool op1_op2_relation_effect (irange &lhs_range, tree type,
675 const irange &op1_range,
676 const irange &op2_range,
677 relation_kind rel) const final override;
678 void update_bitmask (irange &r, const irange &lh,
679 const irange &rh) const final override;
680
681 bool overflow_free_p (const irange &lh, const irange &rh,
682 relation_trio = TRIO_VARYING) const final override;
683 // Check compatibility of all operands.
684 bool operand_check_p (tree t1, tree t2, tree t3) const final override
685 { return range_compatible_p (t1, t2) && range_compatible_p (t1, t3); }
686private:
687 void wi_fold (irange &r, tree type, const wide_int &lh_lb,
688 const wide_int &lh_ub, const wide_int &rh_lb,
689 const wide_int &rh_ub) const final override;
690 void rv_fold (frange &r, tree type,
691 const REAL_VALUE_TYPE &lh_lb, const REAL_VALUE_TYPE &lh_ub,
692 const REAL_VALUE_TYPE &rh_lb, const REAL_VALUE_TYPE &rh_ub,
693 relation_kind) const final override;
694};
695
696class operator_negate : public range_operator
697{
698 public:
699 using range_operator::fold_range;
700 using range_operator::op1_range;
701 bool fold_range (irange &r, tree type,
702 const irange &op1, const irange &op2,
703 relation_trio rel = TRIO_VARYING) const final override;
704 bool fold_range (frange &r, tree type,
705 const frange &op1, const frange &op2,
706 relation_trio = TRIO_VARYING) const final override;
707
708 bool op1_range (irange &r, tree type,
709 const irange &lhs, const irange &op2,
710 relation_trio rel = TRIO_VARYING) const final override;
711 bool op1_range (frange &r, tree type,
712 const frange &lhs, const frange &op2,
713 relation_trio rel = TRIO_VARYING) const final override;
714 // Check compatibility of LHS and op1.
715 bool operand_check_p (tree t1, tree t2, tree) const final override
716 { return range_compatible_p (t1, t2); }
717};
718
719
720class cross_product_operator : public range_operator
721{
722public:
723 virtual bool wi_op_overflows (wide_int &r,
724 tree type,
725 const wide_int &,
726 const wide_int &) const = 0;
727 void wi_cross_product (irange &r, tree type,
728 const wide_int &lh_lb,
729 const wide_int &lh_ub,
730 const wide_int &rh_lb,
731 const wide_int &rh_ub) const;
732};
733
734class operator_mult : public cross_product_operator
735{
736public:
737 using range_operator::op1_range;
738 using range_operator::op2_range;
739 using range_operator::update_bitmask;
740 using range_operator::op1_op2_relation_effect;
741 bool op1_range (irange &r, tree type,
742 const irange &lhs, const irange &op2,
743 relation_trio) const final override;
744 bool op1_range (frange &r, tree type,
745 const frange &lhs, const frange &op2,
746 relation_trio = TRIO_VARYING) const final override;
747
748 bool op2_range (irange &r, tree type,
749 const irange &lhs, const irange &op1,
750 relation_trio) const final override;
751 bool op2_range (frange &r, tree type,
752 const frange &lhs, const frange &op1,
753 relation_trio = TRIO_VARYING) const final override;
754
755 void update_bitmask (irange &r, const irange &lh,
756 const irange &rh) const final override;
757
758 void wi_fold (irange &r, tree type, const wide_int &lh_lb,
759 const wide_int &lh_ub, const wide_int &rh_lb,
760 const wide_int &rh_ub) const final override;
761 bool wi_op_overflows (wide_int &res, tree type, const wide_int &w0,
762 const wide_int &w1) const final override;
763 bool op1_op2_relation_effect (irange &lhs_range, tree type,
764 const irange &op1_range,
765 const irange &op2_range,
766 relation_kind rel) const final override;
767
768 void rv_fold (frange &r, tree type,
769 const REAL_VALUE_TYPE &lh_lb, const REAL_VALUE_TYPE &lh_ub,
770 const REAL_VALUE_TYPE &rh_lb, const REAL_VALUE_TYPE &rh_ub,
771 relation_kind kind) const final override;
772 bool overflow_free_p (const irange &lh, const irange &rh,
773 relation_trio = TRIO_VARYING) const final override;
774 // Check compatibility of all operands.
775 bool operand_check_p (tree t1, tree t2, tree t3) const final override
776 { return range_compatible_p (t1, t2) && range_compatible_p (t1, t3); }
777};
778
779class operator_addr_expr : public range_operator
780{
781public:
782 using range_operator::fold_range;
783 using range_operator::op1_range;
784 bool fold_range (irange &r, tree type,
785 const irange &op1, const irange &op2,
786 relation_trio rel = TRIO_VARYING) const final override;
787 bool op1_range (irange &r, tree type,
788 const irange &lhs, const irange &op2,
789 relation_trio rel = TRIO_VARYING) const final override;
790 bool op1_range (prange &r, tree type,
791 const prange &lhs, const prange &op2,
792 relation_trio rel = TRIO_VARYING) const final override;
793};
794
795class operator_bitwise_not : public range_operator
796{
797public:
798 using range_operator::fold_range;
799 using range_operator::op1_range;
800 using range_operator::update_bitmask;
801 bool fold_range (irange &r, tree type,
802 const irange &lh, const irange &rh,
803 relation_trio rel = TRIO_VARYING) const final override;
804 bool op1_range (irange &r, tree type,
805 const irange &lhs, const irange &op2,
806 relation_trio rel = TRIO_VARYING) const final override;
807 void update_bitmask (irange &r, const irange &lh,
808 const irange &rh) const final override;
809 // Check compatibility of all operands.
810 bool operand_check_p (tree t1, tree t2, tree t3) const final override
811 { return range_compatible_p (t1, t2) && range_compatible_p (t1, t3); }
812};
813
814class operator_bitwise_and : public range_operator
815{
816public:
817 using range_operator::fold_range;
818 using range_operator::op1_range;
819 using range_operator::op2_range;
820 using range_operator::lhs_op1_relation;
821 using range_operator::update_bitmask;
822 bool fold_range (prange &r, tree type,
823 const prange &op1,
824 const prange &op2,
825 relation_trio) const final override;
826 bool op1_range (irange &r, tree type,
827 const irange &lhs, const irange &op2,
828 relation_trio rel = TRIO_VARYING) const override;
829 bool op2_range (irange &r, tree type,
830 const irange &lhs, const irange &op1,
831 relation_trio rel = TRIO_VARYING) const override;
832 relation_kind lhs_op1_relation (const irange &lhs,
833 const irange &op1, const irange &op2,
834 relation_kind) const override;
835 void update_bitmask (irange &r, const irange &lh,
836 const irange &rh) const override;
837 // Check compatibility of all operands.
838 bool operand_check_p (tree t1, tree t2, tree t3) const final override
839 { return range_compatible_p (t1, t2) && range_compatible_p (t1, t3); }
840protected:
841 void wi_fold (irange &r, tree type, const wide_int &lh_lb,
842 const wide_int &lh_ub, const wide_int &rh_lb,
843 const wide_int &rh_ub) const override;
844 void simple_op1_range_solver (irange &r, tree type,
845 const irange &lhs,
846 const irange &op2) const;
847};
848
849class operator_bitwise_or : public range_operator
850{
851public:
852 using range_operator::fold_range;
853 using range_operator::op1_range;
854 using range_operator::op2_range;
855 using range_operator::lhs_op1_relation;
856 using range_operator::op1_op2_relation_effect;
857 using range_operator::update_bitmask;
858 relation_kind lhs_op1_relation (const irange &lhs,
859 const irange &op1, const irange &op2,
860 relation_kind) const final override;
861
862 bool fold_range (prange &r, tree type,
863 const prange &op1,
864 const prange &op2,
865 relation_trio) const final override;
866 bool op1_range (irange &r, tree type,
867 const irange &lhs, const irange &op2,
868 relation_trio rel = TRIO_VARYING) const override;
869 bool op2_range (irange &r, tree type,
870 const irange &lhs, const irange &op1,
871 relation_trio rel = TRIO_VARYING) const override;
872 bool op1_op2_relation_effect (irange &lhs_range,
873 tree type,
874 const irange &op1_range,
875 const irange &op2_range,
876 relation_kind rel) const final override;
877 void update_bitmask (irange &r, const irange &lh,
878 const irange &rh) const override;
879 // Check compatibility of all operands.
880 bool operand_check_p (tree t1, tree t2, tree t3) const final override
881 { return range_compatible_p (t1, t2) && range_compatible_p (t1, t3); }
882protected:
883 void wi_fold (irange &r, tree type, const wide_int &lh_lb,
884 const wide_int &lh_ub, const wide_int &rh_lb,
885 const wide_int &rh_ub) const override;
886};
887
888class operator_bitwise_xor : public range_operator
889{
890public:
891 using range_operator::fold_range;
892 using range_operator::op1_range;
893 using range_operator::op2_range;
894 using range_operator::op1_op2_relation_effect;
895 using range_operator::update_bitmask;
896 bool fold_range (irange &r, tree type,
897 const irange &lh, const irange &rh,
898 relation_trio rel = TRIO_VARYING) const final override;
899 bool op1_range (irange &r, tree type,
900 const irange &lhs, const irange &op2,
901 relation_trio rel = TRIO_VARYING) const final override;
902 bool op2_range (irange &r, tree type,
903 const irange &lhs, const irange &op1,
904 relation_trio rel = TRIO_VARYING) const final override;
905 bool op1_op2_relation_effect (irange &lhs_range,
906 tree type,
907 const irange &op1_range,
908 const irange &op2_range,
909 relation_kind rel) const final override;
910 void update_bitmask (irange &r, const irange &lh,
911 const irange &rh) const final override;
912 // Check compatibility of all operands.
913 bool operand_check_p (tree t1, tree t2, tree t3) const final override
914 { return range_compatible_p (t1, t2) && range_compatible_p (t1, t3); }
915private:
916 void wi_fold (irange &r, tree type, const wide_int &lh_lb,
917 const wide_int &lh_ub, const wide_int &rh_lb,
918 const wide_int &rh_ub) const final override;
919 class operator_bitwise_and m_and;
920 class operator_bitwise_or m_or;
921 class operator_bitwise_not m_not;
922};
923
924
925class operator_min : public range_operator
926{
927public:
928 using range_operator::fold_range;
929 using range_operator::lhs_op1_relation;
930 using range_operator::lhs_op2_relation;
931 using range_operator::update_bitmask;
932 relation_kind lhs_op1_relation (const irange &lhs,
933 const irange &op1, const irange &op2,
934 relation_kind) const final override;
935 relation_kind lhs_op2_relation (const irange &lhs,
936 const irange &op1, const irange &op2,
937 relation_kind) const final override;
938 bool fold_range (prange &r, tree type,
939 const prange &op1,
940 const prange &op2,
941 relation_trio) const final override;
942 void update_bitmask (irange &r, const irange &lh,
943 const irange &rh) const override;
944 // Check compatibility of all operands.
945 bool operand_check_p (tree t1, tree t2, tree t3) const final override
946 { return range_compatible_p (t1, t2) && range_compatible_p (t1, t3); }
947protected:
948 void wi_fold (irange &r, tree type, const wide_int &lh_lb,
949 const wide_int &lh_ub, const wide_int &rh_lb,
950 const wide_int &rh_ub) const override;
951};
952
953class operator_max : public range_operator
954{
955public:
956 using range_operator::fold_range;
957 using range_operator::lhs_op1_relation;
958 using range_operator::lhs_op2_relation;
959 using range_operator::update_bitmask;
960 relation_kind lhs_op1_relation (const irange &lhs,
961 const irange &op1, const irange &op2,
962 relation_kind) const final override;
963 relation_kind lhs_op2_relation (const irange &lhs,
964 const irange &op1, const irange &op2,
965 relation_kind) const final override;
966 bool fold_range (prange &r, tree type,
967 const prange &op1,
968 const prange &op2,
969 relation_trio) const final override;
970 void update_bitmask (irange &r, const irange &lh,
971 const irange &rh) const override;
972 // Check compatibility of all operands.
973 bool operand_check_p (tree t1, tree t2, tree t3) const final override
974 { return range_compatible_p (t1, t2) && range_compatible_p (t1, t3); }
975protected:
976 void wi_fold (irange &r, tree type, const wide_int &lh_lb,
977 const wide_int &lh_ub, const wide_int &rh_lb,
978 const wide_int &rh_ub) const override;
979};
980#endif // GCC_RANGE_OP_MIXED_H
cross_product_operator
Definition range-op-mixed.h:721
cross_product_operator::wi_cross_product
void wi_cross_product(irange &r, tree type, const wide_int &lh_lb, const wide_int &lh_ub, const wide_int &rh_lb, const wide_int &rh_ub) const
Definition range-op.cc:2277
cross_product_operator::wi_op_overflows
virtual bool wi_op_overflows(wide_int &r, tree type, const wide_int &, const wide_int &) const =0
frange
Definition value-range.h:603
irange
Definition value-range.h:291
operator_abs
Definition range-op-mixed.h:618
operator_abs::update_bitmask
void update_bitmask(irange &r, const irange &lh, const irange &rh) const final override
Definition range-op.cc:4990
operator_abs::fold_range
bool fold_range(frange &r, tree type, const frange &op1, const frange &, relation_trio=TRIO_VARYING) const final override
Definition range-op-float.cc:1566
operator_abs::operand_check_p
bool operand_check_p(tree t1, tree t2, tree) const final override
Definition range-op-mixed.h:635
operator_abs::op1_range
bool op1_range(irange &r, tree type, const irange &lhs, const irange &op2, relation_trio) const final override
Definition range-op.cc:4958
operator_abs::wi_fold
void wi_fold(irange &r, tree type, const wide_int &lh_lb, const wide_int &lh_ub, const wide_int &rh_lb, const wide_int &rh_ub) const final override
Definition range-op.cc:4884
operator_addr_expr
Definition range-op-mixed.h:780
operator_addr_expr::fold_range
bool fold_range(irange &r, tree type, const irange &op1, const irange &op2, relation_trio rel=TRIO_VARYING) const final override
Definition range-op.cc:5078
operator_addr_expr::op1_range
bool op1_range(irange &r, tree type, const irange &lhs, const irange &op2, relation_trio rel=TRIO_VARYING) const final override
Definition range-op.cc:5097
operator_bitwise_and
Definition range-op-mixed.h:815
operator_bitwise_and::update_bitmask
void update_bitmask(irange &r, const irange &lh, const irange &rh) const override
Definition range-op.cc:3596
operator_bitwise_and::op2_range
bool op2_range(irange &r, tree type, const irange &lhs, const irange &op1, relation_trio rel=TRIO_VARYING) const override
Definition range-op.cc:4050
operator_bitwise_and::op1_range
bool op1_range(irange &r, tree type, const irange &lhs, const irange &op2, relation_trio rel=TRIO_VARYING) const override
Definition range-op.cc:3984
operator_bitwise_and::operand_check_p
bool operand_check_p(tree t1, tree t2, tree t3) const final override
Definition range-op-mixed.h:838
operator_bitwise_and::fold_range
bool fold_range(prange &r, tree type, const prange &op1, const prange &op2, relation_trio) const final override
Definition range-op-ptr.cc:873
operator_bitwise_and::lhs_op1_relation
relation_kind lhs_op1_relation(const irange &lhs, const irange &op1, const irange &op2, relation_kind) const override
Definition range-op.cc:3628
operator_bitwise_and::wi_fold
void wi_fold(irange &r, tree type, const wide_int &lh_lb, const wide_int &lh_ub, const wide_int &rh_lb, const wide_int &rh_ub) const override
Definition range-op.cc:3784
operator_bitwise_and::simple_op1_range_solver
void simple_op1_range_solver(irange &r, tree type, const irange &lhs, const irange &op2) const
Definition range-op.cc:3905
operator_bitwise_not
Definition range-op-mixed.h:796
operator_bitwise_not::fold_range
bool fold_range(irange &r, tree type, const irange &lh, const irange &rh, relation_trio rel=TRIO_VARYING) const final override
Definition range-op.cc:4776
operator_bitwise_not::operand_check_p
bool operand_check_p(tree t1, tree t2, tree t3) const final override
Definition range-op-mixed.h:810
operator_bitwise_not::op1_range
bool op1_range(irange &r, tree type, const irange &lhs, const irange &op2, relation_trio rel=TRIO_VARYING) const final override
Definition range-op.cc:4794
operator_bitwise_not::update_bitmask
void update_bitmask(irange &r, const irange &lh, const irange &rh) const final override
Definition range-op.cc:4809
operator_bitwise_or
Definition range-op-mixed.h:850
operator_bitwise_or::op2_range
bool op2_range(irange &r, tree type, const irange &lhs, const irange &op1, relation_trio rel=TRIO_VARYING) const override
Definition range-op.cc:4275
operator_bitwise_or::op1_op2_relation_effect
bool op1_op2_relation_effect(irange &lhs_range, tree type, const irange &op1_range, const irange &op2_range, relation_kind rel) const final override
Definition range-op.cc:4216
operator_bitwise_or::fold_range
bool fold_range(prange &r, tree type, const prange &op1, const prange &op2, relation_trio) const final override
Definition range-op-ptr.cc:448
operator_bitwise_or::op1_range
bool op1_range(irange &r, tree type, const irange &lhs, const irange &op2, relation_trio rel=TRIO_VARYING) const override
Definition range-op.cc:4241
operator_bitwise_or::update_bitmask
void update_bitmask(irange &r, const irange &lh, const irange &rh) const override
Definition range-op.cc:4138
operator_bitwise_or::lhs_op1_relation
relation_kind lhs_op1_relation(const irange &lhs, const irange &op1, const irange &op2, relation_kind) const final override
Definition range-op.cc:4203
operator_bitwise_or::operand_check_p
bool operand_check_p(tree t1, tree t2, tree t3) const final override
Definition range-op-mixed.h:880
operator_bitwise_or::wi_fold
void wi_fold(irange &r, tree type, const wide_int &lh_lb, const wide_int &lh_ub, const wide_int &rh_lb, const wide_int &rh_ub) const override
Definition range-op.cc:4145
operator_bitwise_xor
Definition range-op-mixed.h:889
operator_bitwise_xor::op1_op2_relation_effect
bool op1_op2_relation_effect(irange &lhs_range, tree type, const irange &op1_range, const irange &op2_range, relation_kind rel) const final override
Definition range-op.cc:4414
operator_bitwise_xor::update_bitmask
void update_bitmask(irange &r, const irange &lh, const irange &rh) const final override
Definition range-op.cc:4284
operator_bitwise_xor::m_or
class operator_bitwise_or m_or
Definition range-op-mixed.h:920
operator_bitwise_xor::m_and
class operator_bitwise_and m_and
Definition range-op-mixed.h:919
operator_bitwise_xor::op1_range
bool op1_range(irange &r, tree type, const irange &lhs, const irange &op2, relation_trio rel=TRIO_VARYING) const final override
Definition range-op.cc:4442
operator_bitwise_xor::operand_check_p
bool operand_check_p(tree t1, tree t2, tree t3) const final override
Definition range-op-mixed.h:913
operator_bitwise_xor::wi_fold
void wi_fold(irange &r, tree type, const wide_int &lh_lb, const wide_int &lh_ub, const wide_int &rh_lb, const wide_int &rh_ub) const final override
Definition range-op.cc:4368
operator_bitwise_xor::op2_range
bool op2_range(irange &r, tree type, const irange &lhs, const irange &op1, relation_trio rel=TRIO_VARYING) const final override
Definition range-op.cc:4480
operator_bitwise_xor::fold_range
bool fold_range(irange &r, tree type, const irange &lh, const irange &rh, relation_trio rel=TRIO_VARYING) const final override
Definition range-op.cc:4291
operator_bitwise_xor::m_not
class operator_bitwise_not m_not
Definition range-op-mixed.h:921
operator_cast
Definition range-op-mixed.h:458
operator_cast::op1_range
bool op1_range(irange &r, tree type, const irange &lhs, const irange &op2, relation_trio rel=TRIO_VARYING) const final override
Definition range-op.cc:3302
operator_cast::inside_domain_p
bool inside_domain_p(const wide_int &min, const wide_int &max, const irange &outer) const
Definition range-op.cc:3210
operator_cast::fold_pair
void fold_pair(irange &r, unsigned index, const irange &inner, const irange &outer) const
Definition range-op.cc:3227
operator_cast::fold_range
bool fold_range(irange &r, tree type, const irange &op1, const irange &op2, relation_trio rel=TRIO_VARYING) const final override
Definition range-op.cc:3265
operator_cast::truncating_cast_p
bool truncating_cast_p(const irange &inner, const irange &outer) const
Definition range-op.cc:3201
operator_cast::lhs_op1_relation
relation_kind lhs_op1_relation(const irange &lhs, const irange &op1, const irange &op2, relation_kind) const final override
Definition range-op.cc:3172
operator_cast::update_bitmask
void update_bitmask(irange &r, const irange &lh, const irange &rh) const final override
Definition range-op.cc:3295
operator_cst
Definition range-op-mixed.h:442
operator_cst::fold_range
bool fold_range(irange &r, tree type, const irange &op1, const irange &op2, relation_trio rel=TRIO_VARYING) const final override
Definition range-op.cc:4817
operator_equal
Definition range-op-mixed.h:108
operator_equal::operand_check_p
bool operand_check_p(tree t1, tree t2, tree t3) const final override
Definition range-op-mixed.h:154
operator_equal::op2_range
bool op2_range(irange &r, tree type, const irange &lhs, const irange &val, relation_trio=TRIO_VARYING) const final override
Definition range-op.cc:1141
operator_equal::op1_op2_relation
relation_kind op1_op2_relation(const irange &lhs, const irange &, const irange &) const final override
Definition range-op.cc:1052
operator_equal::update_bitmask
void update_bitmask(irange &r, const irange &lh, const irange &rh) const final override
Definition range-op.cc:1043
operator_equal::fold_range
bool fold_range(irange &r, tree type, const irange &op1, const irange &op2, relation_trio=TRIO_VARYING) const final override
Definition range-op.cc:1069
operator_equal::op1_range
bool op1_range(irange &r, tree type, const irange &lhs, const irange &val, relation_trio=TRIO_VARYING) const final override
Definition range-op.cc:1108
operator_ge
Definition range-op-mixed.h:359
operator_ge::op1_range
bool op1_range(irange &r, tree type, const irange &lhs, const irange &op2, relation_trio=TRIO_VARYING) const final override
Definition range-op.cc:1662
operator_ge::operand_check_p
bool operand_check_p(tree t1, tree t2, tree t3) const final override
Definition range-op-mixed.h:405
operator_ge::fold_range
bool fold_range(irange &r, tree type, const irange &op1, const irange &op2, relation_trio=TRIO_VARYING) const final override
Definition range-op.cc:1641
operator_ge::op1_op2_relation
relation_kind op1_op2_relation(const irange &lhs, const irange &, const irange &) const final override
Definition range-op.cc:1624
operator_ge::op2_range
bool op2_range(irange &r, tree type, const irange &lhs, const irange &op1, relation_trio=TRIO_VARYING) const final override
Definition range-op.cc:1687
operator_ge::update_bitmask
void update_bitmask(irange &r, const irange &lh, const irange &rh) const final override
Definition range-op.cc:1615
operator_gt
Definition range-op-mixed.h:309
operator_gt::op1_op2_relation
relation_kind op1_op2_relation(const irange &lhs, const irange &, const irange &) const final override
Definition range-op.cc:1528
operator_gt::update_bitmask
void update_bitmask(irange &r, const irange &lh, const irange &rh) const final override
Definition range-op.cc:1519
operator_gt::fold_range
bool fold_range(irange &r, tree type, const irange &op1, const irange &op2, relation_trio=TRIO_VARYING) const final override
Definition range-op.cc:1545
operator_gt::operand_check_p
bool operand_check_p(tree t1, tree t2, tree t3) const final override
Definition range-op-mixed.h:354
operator_gt::op2_range
bool op2_range(irange &r, tree type, const irange &lhs, const irange &op1, relation_trio=TRIO_VARYING) const final override
Definition range-op.cc:1589
operator_gt::op1_range
bool op1_range(irange &r, tree type, const irange &lhs, const irange &op2, relation_trio=TRIO_VARYING) const final override
Definition range-op.cc:1565
operator_identity
Definition range-op-mixed.h:410
operator_identity::lhs_op1_relation
relation_kind lhs_op1_relation(const irange &lhs, const irange &op1, const irange &op2, relation_kind rel) const final override
Definition range-op.cc:4830
operator_identity::fold_range
bool fold_range(irange &r, tree type, const irange &op1, const irange &op2, relation_trio rel=TRIO_VARYING) const final override
Definition range-op.cc:4842
operator_identity::op1_range
bool op1_range(irange &r, tree type, const irange &lhs, const irange &op2, relation_trio rel=TRIO_VARYING) const final override
Definition range-op.cc:4852
operator_le
Definition range-op-mixed.h:258
operator_le::op2_range
bool op2_range(irange &r, tree type, const irange &lhs, const irange &op1, relation_trio=TRIO_VARYING) const final override
Definition range-op.cc:1493
operator_le::update_bitmask
void update_bitmask(irange &r, const irange &lh, const irange &rh) const final override
Definition range-op.cc:1421
operator_le::fold_range
bool fold_range(irange &r, tree type, const irange &op1, const irange &op2, relation_trio=TRIO_VARYING) const final override
Definition range-op.cc:1447
operator_le::op1_range
bool op1_range(irange &r, tree type, const irange &lhs, const irange &op2, relation_trio=TRIO_VARYING) const final override
Definition range-op.cc:1468
operator_le::operand_check_p
bool operand_check_p(tree t1, tree t2, tree t3) const final override
Definition range-op-mixed.h:304
operator_le::op1_op2_relation
relation_kind op1_op2_relation(const irange &lhs, const irange &, const irange &) const final override
Definition range-op.cc:1430
operator_lt
Definition range-op-mixed.h:210
operator_lt::operand_check_p
bool operand_check_p(tree t1, tree t2, tree t3) const final override
Definition range-op-mixed.h:253
operator_lt::op1_range
bool op1_range(irange &r, tree type, const irange &lhs, const irange &op2, relation_trio=TRIO_VARYING) const final override
Definition range-op.cc:1370
operator_lt::op2_range
bool op2_range(irange &r, tree type, const irange &lhs, const irange &op1, relation_trio=TRIO_VARYING) const final override
Definition range-op.cc:1395
operator_lt::update_bitmask
void update_bitmask(irange &r, const irange &lh, const irange &rh) const final override
Definition range-op.cc:1320
operator_lt::fold_range
bool fold_range(irange &r, tree type, const irange &op1, const irange &op2, relation_trio=TRIO_VARYING) const final override
Definition range-op.cc:1346
operator_lt::op1_op2_relation
relation_kind op1_op2_relation(const irange &lhs, const irange &, const irange &) const final override
Definition range-op.cc:1329
operator_max
Definition range-op-mixed.h:954
operator_max::lhs_op2_relation
relation_kind lhs_op2_relation(const irange &lhs, const irange &op1, const irange &op2, relation_kind) const final override
Definition range-op.cc:2250
operator_max::lhs_op1_relation
relation_kind lhs_op1_relation(const irange &lhs, const irange &op1, const irange &op2, relation_kind) const final override
Definition range-op.cc:2235
operator_max::operand_check_p
bool operand_check_p(tree t1, tree t2, tree t3) const final override
Definition range-op-mixed.h:973
operator_max::update_bitmask
void update_bitmask(irange &r, const irange &lh, const irange &rh) const override
Definition range-op.cc:2215
operator_max::wi_fold
void wi_fold(irange &r, tree type, const wide_int &lh_lb, const wide_int &lh_ub, const wide_int &rh_lb, const wide_int &rh_ub) const override
Definition range-op.cc:2222
operator_max::fold_range
bool fold_range(prange &r, tree type, const prange &op1, const prange &op2, relation_trio) const final override
Definition range-op-ptr.cc:830
operator_min
Definition range-op-mixed.h:926
operator_min::fold_range
bool fold_range(prange &r, tree type, const prange &op1, const prange &op2, relation_trio) const final override
Definition range-op-ptr.cc:808
operator_min::operand_check_p
bool operand_check_p(tree t1, tree t2, tree t3) const final override
Definition range-op-mixed.h:945
operator_min::wi_fold
void wi_fold(irange &r, tree type, const wide_int &lh_lb, const wide_int &lh_ub, const wide_int &rh_lb, const wide_int &rh_ub) const override
Definition range-op.cc:2173
operator_min::lhs_op2_relation
relation_kind lhs_op2_relation(const irange &lhs, const irange &op1, const irange &op2, relation_kind) const final override
Definition range-op.cc:2201
operator_min::lhs_op1_relation
relation_kind lhs_op1_relation(const irange &lhs, const irange &op1, const irange &op2, relation_kind) const final override
Definition range-op.cc:2186
operator_min::update_bitmask
void update_bitmask(irange &r, const irange &lh, const irange &rh) const override
Definition range-op.cc:2166
operator_minus
Definition range-op-mixed.h:645
operator_minus::operand_check_p
bool operand_check_p(tree t1, tree t2, tree t3) const final override
Definition range-op-mixed.h:684
operator_minus::op1_op2_relation
relation_kind op1_op2_relation(const irange &lhs, const irange &, const irange &) const final override
Definition range-op.cc:2109
operator_minus::lhs_op1_relation
relation_kind lhs_op1_relation(const irange &lhs, const irange &op1, const irange &op2, relation_kind rel) const final override
Definition range-op.cc:2020
operator_minus::op1_op2_relation_effect
bool op1_op2_relation_effect(irange &lhs_range, tree type, const irange &op1_range, const irange &op2_range, relation_kind rel) const final override
Definition range-op.cc:2125
operator_minus::wi_fold
void wi_fold(irange &r, tree type, const wide_int &lh_lb, const wide_int &lh_ub, const wide_int &rh_lb, const wide_int &rh_ub) const final override
Definition range-op.cc:2004
operator_minus::op1_range
bool op1_range(irange &r, tree type, const irange &lhs, const irange &op2, relation_trio) const final override
Definition range-op.cc:2135
operator_minus::rv_fold
void rv_fold(frange &r, tree type, const REAL_VALUE_TYPE &lh_lb, const REAL_VALUE_TYPE &lh_ub, const REAL_VALUE_TYPE &rh_lb, const REAL_VALUE_TYPE &rh_ub, relation_kind) const final override
Definition range-op-float.cc:2497
operator_minus::update_bitmask
void update_bitmask(irange &r, const irange &lh, const irange &rh) const final override
Definition range-op.cc:1997
operator_minus::op2_range
bool op2_range(irange &r, tree type, const irange &lhs, const irange &op1, relation_trio) const final override
Definition range-op.cc:2155
operator_minus::overflow_free_p
bool overflow_free_p(const irange &lh, const irange &rh, relation_trio=TRIO_VARYING) const final override
Definition range-op.cc:5174
operator_mult
Definition range-op-mixed.h:735
operator_mult::op2_range
bool op2_range(irange &r, tree type, const irange &lhs, const irange &op1, relation_trio) const final override
Definition range-op.cc:2353
operator_mult::update_bitmask
void update_bitmask(irange &r, const irange &lh, const irange &rh) const final override
Definition range-op.cc:2319
operator_mult::operand_check_p
bool operand_check_p(tree t1, tree t2, tree t3) const final override
Definition range-op-mixed.h:775
operator_mult::wi_fold
void wi_fold(irange &r, tree type, const wide_int &lh_lb, const wide_int &lh_ub, const wide_int &rh_lb, const wide_int &rh_ub) const final override
Definition range-op.cc:2381
operator_mult::overflow_free_p
bool overflow_free_p(const irange &lh, const irange &rh, relation_trio=TRIO_VARYING) const final override
Definition range-op.cc:5205
operator_mult::op1_range
bool op1_range(irange &r, tree type, const irange &lhs, const irange &op2, relation_trio) const final override
Definition range-op.cc:2326
operator_mult::rv_fold
void rv_fold(frange &r, tree type, const REAL_VALUE_TYPE &lh_lb, const REAL_VALUE_TYPE &lh_ub, const REAL_VALUE_TYPE &rh_lb, const REAL_VALUE_TYPE &rh_ub, relation_kind kind) const final override
Definition range-op-float.cc:2606
operator_mult::wi_op_overflows
bool wi_op_overflows(wide_int &res, tree type, const wide_int &w0, const wide_int &w1) const final override
Definition range-op.cc:2361
operator_mult::op1_op2_relation_effect
bool op1_op2_relation_effect(irange &lhs_range, tree type, const irange &op1_range, const irange &op2_range, relation_kind rel) const final override
Definition range-op.cc:2472
operator_negate
Definition range-op-mixed.h:697
operator_negate::operand_check_p
bool operand_check_p(tree t1, tree t2, tree) const final override
Definition range-op-mixed.h:715
operator_negate::fold_range
bool fold_range(irange &r, tree type, const irange &op1, const irange &op2, relation_trio rel=TRIO_VARYING) const final override
Definition range-op.cc:5052
operator_negate::op1_range
bool op1_range(irange &r, tree type, const irange &lhs, const irange &op2, relation_trio rel=TRIO_VARYING) const final override
Definition range-op.cc:5067
operator_not_equal
Definition range-op-mixed.h:159
operator_not_equal::op1_range
bool op1_range(irange &r, tree type, const irange &lhs, const irange &op2, relation_trio=TRIO_VARYING) const final override
Definition range-op.cc:1217
operator_not_equal::operand_check_p
bool operand_check_p(tree t0, tree t1, tree t2) const final override
Definition range-op-mixed.h:205
operator_not_equal::update_bitmask
void update_bitmask(irange &r, const irange &lh, const irange &rh) const final override
Definition range-op.cc:1152
operator_not_equal::op2_range
bool op2_range(irange &r, tree type, const irange &lhs, const irange &op1, relation_trio=TRIO_VARYING) const final override
Definition range-op.cc:1251
operator_not_equal::fold_range
bool fold_range(irange &r, tree type, const irange &op1, const irange &op2, relation_trio=TRIO_VARYING) const final override
Definition range-op.cc:1178
operator_not_equal::op1_op2_relation
relation_kind op1_op2_relation(const irange &lhs, const irange &, const irange &) const final override
Definition range-op.cc:1161
operator_plus
Definition range-op-mixed.h:572
operator_plus::op2_range
bool op2_range(irange &r, tree type, const irange &lhs, const irange &op1, relation_trio) const final override
Definition range-op.cc:1922
operator_plus::operand_check_p
bool operand_check_p(tree t1, tree t2, tree t3) const final override
Definition range-op-mixed.h:605
operator_plus::rv_fold
void rv_fold(frange &r, tree type, const REAL_VALUE_TYPE &lh_lb, const REAL_VALUE_TYPE &lh_ub, const REAL_VALUE_TYPE &rh_lb, const REAL_VALUE_TYPE &rh_ub, relation_kind) const final override
Definition range-op-float.cc:2432
operator_plus::overflow_free_p
bool overflow_free_p(const irange &lh, const irange &rh, relation_trio=TRIO_VARYING) const final override
Definition range-op.cc:5143
operator_plus::lhs_op1_relation
relation_kind lhs_op1_relation(const irange &lhs, const irange &op1, const irange &op2, relation_kind rel) const final override
Definition range-op.cc:1723
operator_plus::op1_range
bool op1_range(irange &r, tree type, const irange &lhs, const irange &op2, relation_trio) const final override
Definition range-op.cc:1902
operator_plus::wi_fold
void wi_fold(irange &r, tree type, const wide_int &lh_lb, const wide_int &lh_ub, const wide_int &rh_lb, const wide_int &rh_ub) const final override
Definition range-op.cc:1797
operator_plus::lhs_op2_relation
relation_kind lhs_op2_relation(const irange &lhs, const irange &op1, const irange &op2, relation_kind rel) const final override
Definition range-op.cc:1790
operator_plus::update_bitmask
void update_bitmask(irange &r, const irange &lh, const irange &rh) const final override
Definition range-op.cc:1713
operator_view
Definition range-op-mixed.h:532
operator_view::op1_range
bool op1_range(irange &r, tree type, const irange &lhs, const irange &op2, relation_trio rel=TRIO_VARYING) const override
Definition range-op.cc:3465
operator_view::update_bitmask
void update_bitmask(irange &r, const irange &lh, const irange &) const final override
Definition range-op.cc:3497
operator_view::fold_range
bool fold_range(irange &r, tree type, const irange &op1, const irange &op2, relation_trio rel=TRIO_VARYING) const override
Definition range-op.cc:3434
operator_view::m_cast
operator_cast m_cast
Definition range-op-mixed.h:568
prange
Definition value-range.h:405
range_operator
Definition range-op.h:65
range_operator::op1_range
virtual bool op1_range(irange &r, tree type, const irange &lhs, const irange &op2, relation_trio=TRIO_VARYING) const
Definition range-op.cc:798
range_operator::op2_range
virtual bool op2_range(irange &r, tree type, const irange &lhs, const irange &op1, relation_trio=TRIO_VARYING) const
Definition range-op.cc:810
range_operator::fold_range
virtual bool fold_range(irange &r, tree type, const irange &lh, const irange &rh, relation_trio=TRIO_VARYING) const
Definition range-op.cc:708
range_operator::update_bitmask
virtual void update_bitmask(irange &, const irange &, const irange &) const
Definition range-op.cc:872
range_operator::lhs_op2_relation
virtual relation_kind lhs_op2_relation(const irange &lhs, const irange &op1, const irange &op2, relation_kind=VREL_VARYING) const
Definition range-op.cc:831
range_operator::lhs_op1_relation
virtual relation_kind lhs_op1_relation(const irange &lhs, const irange &op1, const irange &op2, relation_kind=VREL_VARYING) const
Definition range-op.cc:822
range_operator::op1_op2_relation
virtual relation_kind op1_op2_relation(const irange &lhs, const irange &op1, const irange &op2) const
Definition range-op.cc:840
range_operator::op1_op2_relation_effect
virtual bool op1_op2_relation_effect(irange &lhs_range, tree type, const irange &op1_range, const irange &op2_range, relation_kind rel) const
Definition range-op.cc:850
relation_trio
Definition value-relation.h:427
relation_trio::op1_op2
relation_kind op1_op2()
Definition value-relation.h:501
vrange
Definition value-range.h:88
vrange::undefined_p
bool undefined_p() const
Definition value-range.h:1121
tree
union tree_node * tree
Definition coretypes.h:97
tree_code
tree_code
Definition genmatch.cc:1011
wi::le_p
BINARY_PREDICATE le_p(const T1 &, const T2 &, signop)
wi::zero
hwi_with_prec zero(unsigned int)
Definition wide-int.h:2018
wi::ge_p
BINARY_PREDICATE ge_p(const T1 &, const T2 &, signop)
wi::eq_p
BINARY_PREDICATE eq_p(const T1 &, const T2 &)
r
poly_int< N, C > r
Definition poly-int.h:774
wi_includes_zero_p
bool wi_includes_zero_p(tree type, const wide_int &wmin, const wide_int &wmax)
Definition range-op-mixed.h:34
empty_range_varying
bool empty_range_varying(vrange &r, tree type, const vrange &op1, const vrange &op2)
Definition range-op-mixed.h:59
wi_zero_p
bool wi_zero_p(tree type, const wide_int &wmin, const wide_int &wmax)
Definition range-op-mixed.h:43
get_bool_state
bool_range_state get_bool_state(vrange &r, const vrange &lhs, tree val_type)
Definition range-op.cc:1017
update_known_bitmask
void update_known_bitmask(vrange &, tree_code, const vrange &, const vrange &)
Definition range-op.cc:516
relop_early_resolve
bool relop_early_resolve(irange &r, tree type, const vrange &op1, const vrange &op2, relation_trio trio, relation_kind my_rel)
Definition range-op-mixed.h:77
minus_op1_op2_relation_effect
bool minus_op1_op2_relation_effect(irange &lhs_range, tree type, const irange &, const irange &, relation_kind rel)
Definition range-op.cc:2040
bool_range_state
bool_range_state
Definition range-op-mixed.h:50
BRS_FALSE
@ BRS_FALSE
Definition range-op-mixed.h:50
BRS_EMPTY
@ BRS_EMPTY
Definition range-op-mixed.h:50
BRS_FULL
@ BRS_FULL
Definition range-op-mixed.h:50
BRS_TRUE
@ BRS_TRUE
Definition range-op-mixed.h:50
range_false
int_range< 1 > range_false(tree type=boolean_type_node)
Definition range.h:39
range_true
int_range< 1 > range_true(tree type=boolean_type_node)
Definition range.h:30
REAL_VALUE_TYPE
#define REAL_VALUE_TYPE
Definition real.h:68
signop
signop
Definition signop.h:28
type
Definition gengtype.h:252
TYPE_PRECISION
#define TYPE_PRECISION(NODE)
Definition tree.h:2446
TYPE_SIGN
#define TYPE_SIGN(NODE)
Definition tree.h:983
INTEGRAL_TYPE_P
#define INTEGRAL_TYPE_P(TYPE)
Definition tree.h:614
range_compatible_p
bool range_compatible_p(tree type1, tree type2)
Definition value-range.h:2008
relation_intersect
relation_kind relation_intersect(relation_kind r1, relation_kind r2)
Definition value-relation.cc:133
relation_union
relation_kind relation_union(relation_kind r1, relation_kind r2)
Definition value-relation.cc:192
relation_kind
enum relation_kind_t relation_kind
VREL_UNDEFINED
@ VREL_UNDEFINED
Definition value-relation.h:66
TRIO_VARYING
#define TRIO_VARYING
Definition value-relation.h:446
wide_int
generic_wide_int< wide_int_storage > wide_int
Definition wide-int.h:343