Line data Source code
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 :
6 : This file is part of GCC.
7 :
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
11 : version.
12 :
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
16 : for more details.
17 :
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/>. */
21 :
22 : #ifndef GCC_RANGE_OP_MIXED_H
23 : #define GCC_RANGE_OP_MIXED_H
24 :
25 : void update_known_bitmask (vrange &, tree_code, const vrange &, const vrange &);
26 : bool 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 :
33 : inline bool
34 20050956 : wi_includes_zero_p (tree type, const wide_int &wmin, const wide_int &wmax)
35 : {
36 20050956 : signop sign = TYPE_SIGN (type);
37 20050956 : 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 :
42 : inline bool
43 2276096 : wi_zero_p (tree type, const wide_int &wmin, const wide_int &wmax)
44 : {
45 2276096 : unsigned prec = TYPE_PRECISION (type);
46 2654031 : return wmin == wmax && wi::eq_p (wmin, wi::zero (prec));
47 : }
48 :
49 :
50 : enum bool_range_state { BRS_FALSE, BRS_TRUE, BRS_EMPTY, BRS_FULL };
51 : bool_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 :
58 : inline bool
59 349282172 : empty_range_varying (vrange &r, tree type,
60 : const vrange &op1, const vrange & op2)
61 : {
62 349175673 : if (op1.undefined_p () || op2.undefined_p ())
63 : {
64 6629250 : r.set_varying (type);
65 6508602 : 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 :
76 : inline bool
77 90777936 : relop_early_resolve (irange &r, tree type, const vrange &op1,
78 : const vrange &op2, relation_trio trio,
79 : relation_kind my_rel)
80 : {
81 90777936 : relation_kind rel = trio.op1_op2 ();
82 : // If known relation is a complete subset of this relation, always true.
83 90777936 : if (relation_union (rel, my_rel) == my_rel)
84 : {
85 60551 : r = range_true (type);
86 60551 : return true;
87 : }
88 :
89 : // If known relation has no subset of this relation, always false.
90 90717385 : if (relation_intersect (rel, my_rel) == VREL_UNDEFINED)
91 : {
92 72094 : r = range_false (type);
93 72094 : return true;
94 : }
95 :
96 : // If either operand is undefined, return VARYING.
97 90645291 : if (empty_range_varying (r, type, op1, op2))
98 120648 : return true;
99 :
100 : return false;
101 : }
102 :
103 : // ----------------------------------------------------------------------
104 : // Mixed Mode Operators.
105 : // ----------------------------------------------------------------------
106 :
107 : class operator_equal : public range_operator
108 : {
109 : public:
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 46453411 : bool operand_check_p (tree t1, tree t2, tree t3) const final override
155 46453411 : { return range_compatible_p (t2, t3) && INTEGRAL_TYPE_P (t1); }
156 : };
157 :
158 : class operator_not_equal : public range_operator
159 : {
160 : public:
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 75493400 : bool operand_check_p (tree t0, tree t1, tree t2) const final override
206 75493400 : { return range_compatible_p (t1, t2) && INTEGRAL_TYPE_P (t0); }
207 : };
208 :
209 : class operator_lt : public range_operator
210 : {
211 : public:
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 23204322 : bool operand_check_p (tree t1, tree t2, tree t3) const final override
254 23204322 : { return range_compatible_p (t2, t3) && INTEGRAL_TYPE_P (t1); }
255 : };
256 :
257 : class operator_le : public range_operator
258 : {
259 : public:
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 18365003 : bool operand_check_p (tree t1, tree t2, tree t3) const final override
305 18365003 : { return range_compatible_p (t2, t3) && INTEGRAL_TYPE_P (t1); }
306 : };
307 :
308 : class operator_gt : public range_operator
309 : {
310 : public:
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 37504214 : bool operand_check_p (tree t1, tree t2, tree t3) const final override
355 37504214 : { return range_compatible_p (t2, t3) && INTEGRAL_TYPE_P (t1); }
356 : };
357 :
358 : class operator_ge : public range_operator
359 : {
360 : public:
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 11499986 : bool operand_check_p (tree t1, tree t2, tree t3) const final override
406 11499986 : { return range_compatible_p (t2, t3) && INTEGRAL_TYPE_P (t1); }
407 : };
408 :
409 : class operator_identity : public range_operator
410 : {
411 : public:
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 :
441 : class operator_cst : public range_operator
442 : {
443 : public:
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 :
457 : class operator_cast: public range_operator
458 : {
459 : public:
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;
522 : private:
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 :
531 : class operator_view : public range_operator
532 : {
533 : public:
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;
565 : private:
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 :
571 : class operator_plus : public range_operator
572 : {
573 : public:
574 : using range_operator::op1_range;
575 : using range_operator::op2_range;
576 : using range_operator::fold_range;
577 : bool fold_range (irange &r, tree type,
578 : const irange &lh, const irange &rh,
579 : relation_trio = TRIO_VARYING) const final override;
580 : using range_operator::lhs_op1_relation;
581 : using range_operator::lhs_op2_relation;
582 : using range_operator::update_bitmask;
583 : bool op1_range (irange &r, tree type,
584 : const irange &lhs, const irange &op2,
585 : relation_trio) const final override;
586 : bool op1_range (frange &r, tree type,
587 : const frange &lhs, const frange &op2,
588 : relation_trio = TRIO_VARYING) const final override;
589 :
590 : bool op2_range (irange &r, tree type,
591 : const irange &lhs, const irange &op1,
592 : relation_trio) const final override;
593 : bool op2_range (frange &r, tree type,
594 : const frange &lhs, const frange &op1,
595 : relation_trio = TRIO_VARYING) const final override;
596 :
597 : relation_kind lhs_op1_relation (const irange &lhs, const irange &op1,
598 : const irange &op2,
599 : relation_kind rel) const final override;
600 : relation_kind lhs_op2_relation (const irange &lhs, const irange &op1,
601 : const irange &op2,
602 : relation_kind rel) const final override;
603 : void update_bitmask (irange &r, const irange &lh,
604 : const irange &rh) const final override;
605 :
606 : bool overflow_free_p (const irange &lh, const irange &rh,
607 : relation_trio = TRIO_VARYING) const final override;
608 : // Check compatibility of all operands.
609 81192629 : bool operand_check_p (tree t1, tree t2, tree t3) const final override
610 81192629 : { return range_compatible_p (t1, t2) && range_compatible_p (t1, t3); }
611 : private:
612 : void wi_fold (irange &r, tree type, const wide_int &lh_lb,
613 : const wide_int &lh_ub, const wide_int &rh_lb,
614 : const wide_int &rh_ub) const final override;
615 : void rv_fold (frange &r, tree type,
616 : const REAL_VALUE_TYPE &lh_lb, const REAL_VALUE_TYPE &lh_ub,
617 : const REAL_VALUE_TYPE &rh_lb, const REAL_VALUE_TYPE &rh_ub,
618 : relation_kind) const final override;
619 : };
620 :
621 : class operator_abs : public range_operator
622 : {
623 : public:
624 : using range_operator::fold_range;
625 : using range_operator::op1_range;
626 : using range_operator::update_bitmask;
627 : bool fold_range (frange &r, tree type,
628 : const frange &op1, const frange &,
629 : relation_trio = TRIO_VARYING) const final override;
630 :
631 : bool op1_range (irange &r, tree type, const irange &lhs,
632 : const irange &op2, relation_trio) const final override;
633 : bool op1_range (frange &r, tree type,
634 : const frange &lhs, const frange &op2,
635 : relation_trio rel = TRIO_VARYING) const final override;
636 : void update_bitmask (irange &r, const irange &lh,
637 : const irange &rh) const final override;
638 : // Check compatibility of LHS and op1.
639 1221217 : bool operand_check_p (tree t1, tree t2, tree) const final override
640 1221217 : { return range_compatible_p (t1, t2); }
641 : private:
642 : void wi_fold (irange &r, tree type, const wide_int &lh_lb,
643 : const wide_int &lh_ub, const wide_int &rh_lb,
644 : const wide_int &rh_ub) const final override;
645 :
646 : };
647 :
648 : class operator_minus : public range_operator
649 : {
650 : public:
651 : using range_operator::fold_range;
652 : using range_operator::op1_range;
653 : using range_operator::op2_range;
654 : using range_operator::lhs_op1_relation;
655 : using range_operator::op1_op2_relation;
656 : using range_operator::op1_op2_relation_effect;
657 : using range_operator::update_bitmask;
658 : bool op1_range (irange &r, tree type,
659 : const irange &lhs, const irange &op2,
660 : relation_trio) const final override;
661 : bool op1_range (frange &r, tree type,
662 : const frange &lhs, const frange &op2,
663 : relation_trio = TRIO_VARYING) const final override;
664 :
665 : bool op2_range (irange &r, tree type,
666 : const irange &lhs, const irange &op1,
667 : relation_trio) const final override;
668 : bool op2_range (frange &r, tree type,
669 : const frange &lhs,
670 : const frange &op1,
671 : relation_trio = TRIO_VARYING) const final override;
672 :
673 : relation_kind lhs_op1_relation (const irange &lhs,
674 : const irange &op1, const irange &op2,
675 : relation_kind rel) const final override;
676 : relation_kind op1_op2_relation (const irange &lhs, const irange &,
677 : const irange &) const final override;
678 : bool op1_op2_relation_effect (irange &lhs_range, tree type,
679 : const irange &op1_range,
680 : const irange &op2_range,
681 : relation_kind rel) const final override;
682 : void update_bitmask (irange &r, const irange &lh,
683 : const irange &rh) const final override;
684 :
685 : bool overflow_free_p (const irange &lh, const irange &rh,
686 : relation_trio = TRIO_VARYING) const final override;
687 : // Check compatibility of all operands.
688 39731593 : bool operand_check_p (tree t1, tree t2, tree t3) const final override
689 39731593 : { return range_compatible_p (t1, t2) && range_compatible_p (t1, t3); }
690 : private:
691 : void wi_fold (irange &r, tree type, const wide_int &lh_lb,
692 : const wide_int &lh_ub, const wide_int &rh_lb,
693 : const wide_int &rh_ub) const final override;
694 : void rv_fold (frange &r, tree type,
695 : const REAL_VALUE_TYPE &lh_lb, const REAL_VALUE_TYPE &lh_ub,
696 : const REAL_VALUE_TYPE &rh_lb, const REAL_VALUE_TYPE &rh_ub,
697 : relation_kind) const final override;
698 : };
699 :
700 : class operator_negate : public range_operator
701 : {
702 : public:
703 : using range_operator::fold_range;
704 : using range_operator::op1_range;
705 : bool fold_range (irange &r, tree type,
706 : const irange &op1, const irange &op2,
707 : relation_trio rel = TRIO_VARYING) const final override;
708 : bool fold_range (frange &r, tree type,
709 : const frange &op1, const frange &op2,
710 : relation_trio = TRIO_VARYING) const final override;
711 :
712 : bool op1_range (irange &r, tree type,
713 : const irange &lhs, const irange &op2,
714 : relation_trio rel = TRIO_VARYING) const final override;
715 : bool op1_range (frange &r, tree type,
716 : const frange &lhs, const frange &op2,
717 : relation_trio rel = TRIO_VARYING) const final override;
718 : // Check compatibility of LHS and op1.
719 895772 : bool operand_check_p (tree t1, tree t2, tree) const final override
720 895772 : { return range_compatible_p (t1, t2); }
721 : };
722 :
723 :
724 : class cross_product_operator : public range_operator
725 : {
726 : public:
727 : virtual bool wi_op_overflows (wide_int &r,
728 : tree type,
729 : const wide_int &,
730 : const wide_int &) const = 0;
731 : void wi_cross_product (irange &r, tree type,
732 : const wide_int &lh_lb,
733 : const wide_int &lh_ub,
734 : const wide_int &rh_lb,
735 : const wide_int &rh_ub) const;
736 : };
737 :
738 : class operator_mult : public cross_product_operator
739 : {
740 : public:
741 : using range_operator::op1_range;
742 : using range_operator::op2_range;
743 : using range_operator::update_bitmask;
744 : using range_operator::op1_op2_relation_effect;
745 : bool op1_range (irange &r, tree type,
746 : const irange &lhs, const irange &op2,
747 : relation_trio) const final override;
748 : bool op1_range (frange &r, tree type,
749 : const frange &lhs, const frange &op2,
750 : relation_trio = TRIO_VARYING) const final override;
751 :
752 : bool op2_range (irange &r, tree type,
753 : const irange &lhs, const irange &op1,
754 : relation_trio) const final override;
755 : bool op2_range (frange &r, tree type,
756 : const frange &lhs, const frange &op1,
757 : relation_trio = TRIO_VARYING) const final override;
758 :
759 : void update_bitmask (irange &r, const irange &lh,
760 : const irange &rh) const final override;
761 :
762 : void wi_fold (irange &r, tree type, const wide_int &lh_lb,
763 : const wide_int &lh_ub, const wide_int &rh_lb,
764 : const wide_int &rh_ub) const final override;
765 : bool wi_op_overflows (wide_int &res, tree type, const wide_int &w0,
766 : const wide_int &w1) const final override;
767 : bool op1_op2_relation_effect (irange &lhs_range, tree type,
768 : const irange &op1_range,
769 : const irange &op2_range,
770 : relation_kind rel) const final override;
771 :
772 : void rv_fold (frange &r, tree type,
773 : const REAL_VALUE_TYPE &lh_lb, const REAL_VALUE_TYPE &lh_ub,
774 : const REAL_VALUE_TYPE &rh_lb, const REAL_VALUE_TYPE &rh_ub,
775 : relation_kind kind) const final override;
776 : bool overflow_free_p (const irange &lh, const irange &rh,
777 : relation_trio = TRIO_VARYING) const final override;
778 : // Check compatibility of all operands.
779 19665184 : bool operand_check_p (tree t1, tree t2, tree t3) const final override
780 19665184 : { return range_compatible_p (t1, t2) && range_compatible_p (t1, t3); }
781 : };
782 :
783 : class operator_addr_expr : public range_operator
784 : {
785 : public:
786 : using range_operator::fold_range;
787 : using range_operator::op1_range;
788 : bool fold_range (irange &r, tree type,
789 : const irange &op1, const irange &op2,
790 : relation_trio rel = TRIO_VARYING) const final override;
791 : bool op1_range (irange &r, tree type,
792 : const irange &lhs, const irange &op2,
793 : relation_trio rel = TRIO_VARYING) const final override;
794 : bool op1_range (prange &r, tree type,
795 : const prange &lhs, const prange &op2,
796 : relation_trio rel = TRIO_VARYING) const final override;
797 : };
798 :
799 : class operator_bitwise_not : public range_operator
800 : {
801 : public:
802 : using range_operator::fold_range;
803 : using range_operator::op1_range;
804 : using range_operator::update_bitmask;
805 : bool fold_range (irange &r, tree type,
806 : const irange &lh, const irange &rh,
807 : relation_trio rel = TRIO_VARYING) const final override;
808 : bool op1_range (irange &r, tree type,
809 : const irange &lhs, const irange &op2,
810 : relation_trio rel = TRIO_VARYING) const final override;
811 : void update_bitmask (irange &r, const irange &lh,
812 : const irange &rh) const final override;
813 : // Check compatibility of all operands.
814 595233 : bool operand_check_p (tree t1, tree t2, tree t3) const final override
815 595233 : { return range_compatible_p (t1, t2) && range_compatible_p (t1, t3); }
816 : };
817 :
818 : class operator_bitwise_and : public range_operator
819 : {
820 : public:
821 : using range_operator::fold_range;
822 : using range_operator::op1_range;
823 : using range_operator::op2_range;
824 : using range_operator::lhs_op1_relation;
825 : using range_operator::update_bitmask;
826 : bool fold_range (prange &r, tree type,
827 : const prange &op1,
828 : const prange &op2,
829 : relation_trio) const final override;
830 : bool op1_range (irange &r, tree type,
831 : const irange &lhs, const irange &op2,
832 : relation_trio rel = TRIO_VARYING) const override;
833 : bool op2_range (irange &r, tree type,
834 : const irange &lhs, const irange &op1,
835 : relation_trio rel = TRIO_VARYING) const override;
836 : relation_kind lhs_op1_relation (const irange &lhs,
837 : const irange &op1, const irange &op2,
838 : relation_kind) const override;
839 : void update_bitmask (irange &r, const irange &lh,
840 : const irange &rh) const override;
841 : // Check compatibility of all operands.
842 15034243 : bool operand_check_p (tree t1, tree t2, tree t3) const final override
843 15034243 : { return range_compatible_p (t1, t2) && range_compatible_p (t1, t3); }
844 : protected:
845 : void wi_fold (irange &r, tree type, const wide_int &lh_lb,
846 : const wide_int &lh_ub, const wide_int &rh_lb,
847 : const wide_int &rh_ub) const override;
848 : void simple_op1_range_solver (irange &r, tree type,
849 : const irange &lhs,
850 : const irange &op2) const;
851 : };
852 :
853 : class operator_bitwise_or : public range_operator
854 : {
855 : public:
856 : using range_operator::fold_range;
857 : using range_operator::op1_range;
858 : using range_operator::op2_range;
859 : using range_operator::lhs_op1_relation;
860 : using range_operator::op1_op2_relation_effect;
861 : using range_operator::update_bitmask;
862 : relation_kind lhs_op1_relation (const irange &lhs,
863 : const irange &op1, const irange &op2,
864 : relation_kind) const final override;
865 :
866 : bool fold_range (prange &r, tree type,
867 : const prange &op1,
868 : const prange &op2,
869 : relation_trio) const final override;
870 : bool op1_range (irange &r, tree type,
871 : const irange &lhs, const irange &op2,
872 : relation_trio rel = TRIO_VARYING) const override;
873 : bool op2_range (irange &r, tree type,
874 : const irange &lhs, const irange &op1,
875 : relation_trio rel = TRIO_VARYING) const override;
876 : bool op1_op2_relation_effect (irange &lhs_range,
877 : tree type,
878 : const irange &op1_range,
879 : const irange &op2_range,
880 : relation_kind rel) const final override;
881 : void update_bitmask (irange &r, const irange &lh,
882 : const irange &rh) const override;
883 : // Check compatibility of all operands.
884 4910608 : bool operand_check_p (tree t1, tree t2, tree t3) const final override
885 4910608 : { return range_compatible_p (t1, t2) && range_compatible_p (t1, t3); }
886 : protected:
887 : void wi_fold (irange &r, tree type, const wide_int &lh_lb,
888 : const wide_int &lh_ub, const wide_int &rh_lb,
889 : const wide_int &rh_ub) const override;
890 : };
891 :
892 : class operator_bitwise_xor : public range_operator
893 : {
894 : public:
895 : using range_operator::fold_range;
896 : using range_operator::op1_range;
897 : using range_operator::op2_range;
898 : using range_operator::op1_op2_relation_effect;
899 : using range_operator::update_bitmask;
900 : bool fold_range (irange &r, tree type,
901 : const irange &lh, const irange &rh,
902 : relation_trio rel = TRIO_VARYING) const final override;
903 : bool op1_range (irange &r, tree type,
904 : const irange &lhs, const irange &op2,
905 : relation_trio rel = TRIO_VARYING) const final override;
906 : bool op2_range (irange &r, tree type,
907 : const irange &lhs, const irange &op1,
908 : relation_trio rel = TRIO_VARYING) const final override;
909 : bool op1_op2_relation_effect (irange &lhs_range,
910 : tree type,
911 : const irange &op1_range,
912 : const irange &op2_range,
913 : relation_kind rel) const final override;
914 : void update_bitmask (irange &r, const irange &lh,
915 : const irange &rh) const final override;
916 : // Check compatibility of all operands.
917 559037 : bool operand_check_p (tree t1, tree t2, tree t3) const final override
918 559037 : { return range_compatible_p (t1, t2) && range_compatible_p (t1, t3); }
919 : private:
920 : void wi_fold (irange &r, tree type, const wide_int &lh_lb,
921 : const wide_int &lh_ub, const wide_int &rh_lb,
922 : const wide_int &rh_ub) const final override;
923 : class operator_bitwise_and m_and;
924 : class operator_bitwise_or m_or;
925 : class operator_bitwise_not m_not;
926 : };
927 :
928 :
929 : class operator_min : public range_operator
930 : {
931 : public:
932 : using range_operator::fold_range;
933 : using range_operator::lhs_op1_relation;
934 : using range_operator::lhs_op2_relation;
935 : using range_operator::update_bitmask;
936 : relation_kind lhs_op1_relation (const irange &lhs,
937 : const irange &op1, const irange &op2,
938 : relation_kind) const final override;
939 : relation_kind lhs_op2_relation (const irange &lhs,
940 : const irange &op1, const irange &op2,
941 : relation_kind) const final override;
942 : bool fold_range (prange &r, tree type,
943 : const prange &op1,
944 : const prange &op2,
945 : relation_trio) const final override;
946 : void update_bitmask (irange &r, const irange &lh,
947 : const irange &rh) const override;
948 : // Check compatibility of all operands.
949 2457876 : bool operand_check_p (tree t1, tree t2, tree t3) const final override
950 2457876 : { return range_compatible_p (t1, t2) && range_compatible_p (t1, t3); }
951 : protected:
952 : void wi_fold (irange &r, tree type, const wide_int &lh_lb,
953 : const wide_int &lh_ub, const wide_int &rh_lb,
954 : const wide_int &rh_ub) const override;
955 : };
956 :
957 : class operator_max : public range_operator
958 : {
959 : public:
960 : using range_operator::fold_range;
961 : using range_operator::lhs_op1_relation;
962 : using range_operator::lhs_op2_relation;
963 : using range_operator::update_bitmask;
964 : relation_kind lhs_op1_relation (const irange &lhs,
965 : const irange &op1, const irange &op2,
966 : relation_kind) const final override;
967 : relation_kind lhs_op2_relation (const irange &lhs,
968 : const irange &op1, const irange &op2,
969 : relation_kind) const final override;
970 : bool fold_range (prange &r, tree type,
971 : const prange &op1,
972 : const prange &op2,
973 : relation_trio) const final override;
974 : void update_bitmask (irange &r, const irange &lh,
975 : const irange &rh) const override;
976 : // Check compatibility of all operands.
977 1182193 : bool operand_check_p (tree t1, tree t2, tree t3) const final override
978 1182193 : { return range_compatible_p (t1, t2) && range_compatible_p (t1, t3); }
979 : protected:
980 : void wi_fold (irange &r, tree type, const wide_int &lh_lb,
981 : const wide_int &lh_ub, const wide_int &rh_lb,
982 : const wide_int &rh_ub) const override;
983 : };
984 : #endif // GCC_RANGE_OP_MIXED_H
|