Branch data Line data Source code
1 : : /* Floating point range operators.
2 : : Copyright (C) 2022-2025 Free Software Foundation, Inc.
3 : : Contributed by Aldy Hernandez <aldyh@redhat.com>.
4 : :
5 : : This file is part of GCC.
6 : :
7 : : GCC is free software; you can redistribute it and/or modify
8 : : it under the terms of the GNU General Public License as published by
9 : : the Free Software Foundation; either version 3, or (at your option)
10 : : any later version.
11 : :
12 : : GCC is distributed in the hope that it will be useful,
13 : : but WITHOUT ANY WARRANTY; without even the implied warranty of
14 : : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 : : GNU General Public License for more details.
16 : :
17 : : You should have received a copy of the GNU General Public License
18 : : along with GCC; see the file COPYING3. If not see
19 : : <http://www.gnu.org/licenses/>. */
20 : :
21 : : #include "config.h"
22 : : #include "system.h"
23 : : #include "coretypes.h"
24 : : #include "backend.h"
25 : : #include "insn-codes.h"
26 : : #include "rtl.h"
27 : : #include "tree.h"
28 : : #include "gimple.h"
29 : : #include "cfghooks.h"
30 : : #include "tree-pass.h"
31 : : #include "ssa.h"
32 : : #include "optabs-tree.h"
33 : : #include "gimple-pretty-print.h"
34 : : #include "diagnostic-core.h"
35 : : #include "flags.h"
36 : : #include "fold-const.h"
37 : : #include "stor-layout.h"
38 : : #include "calls.h"
39 : : #include "cfganal.h"
40 : : #include "gimple-iterator.h"
41 : : #include "gimple-fold.h"
42 : : #include "tree-eh.h"
43 : : #include "gimple-walk.h"
44 : : #include "tree-cfg.h"
45 : : #include "wide-int.h"
46 : : #include "value-relation.h"
47 : : #include "range-op.h"
48 : : #include "range-op-mixed.h"
49 : :
50 : : // Default definitions for floating point operators.
51 : :
52 : : bool
53 : 5765307 : range_operator::fold_range (frange &r, tree type,
54 : : const frange &op1, const frange &op2,
55 : : relation_trio trio) const
56 : : {
57 : 5765307 : if (empty_range_varying (r, type, op1, op2))
58 : 6532 : return true;
59 : 5758775 : if (op1.known_isnan () || op2.known_isnan ())
60 : : {
61 : 7258 : r.set_nan (type);
62 : 7258 : return true;
63 : : }
64 : :
65 : 5751517 : rv_fold (r, type,
66 : : op1.lower_bound (), op1.upper_bound (),
67 : : op2.lower_bound (), op2.upper_bound (), trio.op1_op2 ());
68 : :
69 : 5751517 : if (r.known_isnan ())
70 : : return true;
71 : 9329150 : if (op1.maybe_isnan () || op2.maybe_isnan ())
72 : 4134542 : r.update_nan ();
73 : :
74 : : // If the result has overflowed and flag_trapping_math, folding this
75 : : // operation could elide an overflow or division by zero exception.
76 : : // Avoid returning a singleton +-INF, to keep the propagators (DOM
77 : : // and substitute_and_fold_engine) from folding. See PR107608.
78 : 5750889 : if (flag_trapping_math
79 : 27186587 : && MODE_HAS_INFINITIES (TYPE_MODE (type))
80 : 11110200 : && r.known_isinf () && !op1.known_isinf () && !op2.known_isinf ())
81 : : {
82 : 1546 : REAL_VALUE_TYPE inf = r.lower_bound ();
83 : 1546 : if (real_isneg (&inf))
84 : : {
85 : 96 : REAL_VALUE_TYPE min = real_min_representable (type);
86 : 96 : r.set (type, inf, min);
87 : : }
88 : : else
89 : : {
90 : 1450 : REAL_VALUE_TYPE max = real_max_representable (type);
91 : 1450 : r.set (type, max, inf);
92 : : }
93 : : }
94 : :
95 : 5750889 : r.flush_denormals_to_zero ();
96 : :
97 : 5750889 : return true;
98 : : }
99 : :
100 : : // For a given operation, fold two sets of ranges into [lb, ub].
101 : : // MAYBE_NAN is set to TRUE if, in addition to any result in LB or
102 : : // UB, the final range has the possibility of a NAN.
103 : : void
104 : 502453 : range_operator::rv_fold (frange &r, tree type,
105 : : const REAL_VALUE_TYPE &,
106 : : const REAL_VALUE_TYPE &,
107 : : const REAL_VALUE_TYPE &,
108 : : const REAL_VALUE_TYPE &, relation_kind) const
109 : : {
110 : 502453 : r.set (type, dconstninf, dconstinf, nan_state (true));
111 : 502453 : }
112 : :
113 : : bool
114 : 0 : range_operator::fold_range (irange &r ATTRIBUTE_UNUSED,
115 : : tree type ATTRIBUTE_UNUSED,
116 : : const frange &lh ATTRIBUTE_UNUSED,
117 : : const irange &rh ATTRIBUTE_UNUSED,
118 : : relation_trio) const
119 : : {
120 : 0 : return false;
121 : : }
122 : :
123 : : bool
124 : 0 : range_operator::fold_range (irange &r ATTRIBUTE_UNUSED,
125 : : tree type ATTRIBUTE_UNUSED,
126 : : const frange &lh ATTRIBUTE_UNUSED,
127 : : const frange &rh ATTRIBUTE_UNUSED,
128 : : relation_trio) const
129 : : {
130 : 0 : return false;
131 : : }
132 : :
133 : : bool
134 : 0 : range_operator::fold_range (frange &r ATTRIBUTE_UNUSED,
135 : : tree type ATTRIBUTE_UNUSED,
136 : : const irange &lh ATTRIBUTE_UNUSED,
137 : : const irange &rh ATTRIBUTE_UNUSED,
138 : : relation_trio) const
139 : : {
140 : 0 : return false;
141 : : }
142 : :
143 : : bool
144 : 731 : range_operator::op1_range (frange &r ATTRIBUTE_UNUSED,
145 : : tree type ATTRIBUTE_UNUSED,
146 : : const frange &lhs ATTRIBUTE_UNUSED,
147 : : const frange &op2 ATTRIBUTE_UNUSED,
148 : : relation_trio) const
149 : : {
150 : 731 : return false;
151 : : }
152 : :
153 : : bool
154 : 0 : range_operator::op1_range (frange &r ATTRIBUTE_UNUSED,
155 : : tree type ATTRIBUTE_UNUSED,
156 : : const irange &lhs ATTRIBUTE_UNUSED,
157 : : const frange &op2 ATTRIBUTE_UNUSED,
158 : : relation_trio) const
159 : : {
160 : 0 : return false;
161 : : }
162 : :
163 : : bool
164 : 2344 : range_operator::op2_range (frange &r ATTRIBUTE_UNUSED,
165 : : tree type ATTRIBUTE_UNUSED,
166 : : const frange &lhs ATTRIBUTE_UNUSED,
167 : : const frange &op1 ATTRIBUTE_UNUSED,
168 : : relation_trio) const
169 : : {
170 : 2344 : return false;
171 : : }
172 : :
173 : : bool
174 : 0 : range_operator::op2_range (frange &r ATTRIBUTE_UNUSED,
175 : : tree type ATTRIBUTE_UNUSED,
176 : : const irange &lhs ATTRIBUTE_UNUSED,
177 : : const frange &op1 ATTRIBUTE_UNUSED,
178 : : relation_trio) const
179 : : {
180 : 0 : return false;
181 : : }
182 : :
183 : : relation_kind
184 : 5719160 : range_operator::lhs_op1_relation (const frange &lhs ATTRIBUTE_UNUSED,
185 : : const frange &op1 ATTRIBUTE_UNUSED,
186 : : const frange &op2 ATTRIBUTE_UNUSED,
187 : : relation_kind) const
188 : : {
189 : 5719160 : return VREL_VARYING;
190 : : }
191 : :
192 : : relation_kind
193 : 926853 : range_operator::lhs_op1_relation (const irange &lhs ATTRIBUTE_UNUSED,
194 : : const frange &op1 ATTRIBUTE_UNUSED,
195 : : const frange &op2 ATTRIBUTE_UNUSED,
196 : : relation_kind) const
197 : : {
198 : 926853 : return VREL_VARYING;
199 : : }
200 : :
201 : : relation_kind
202 : 157263 : range_operator::lhs_op2_relation (const irange &lhs ATTRIBUTE_UNUSED,
203 : : const frange &op1 ATTRIBUTE_UNUSED,
204 : : const frange &op2 ATTRIBUTE_UNUSED,
205 : : relation_kind) const
206 : : {
207 : 157263 : return VREL_VARYING;
208 : : }
209 : :
210 : : relation_kind
211 : 3602410 : range_operator::lhs_op2_relation (const frange &lhs ATTRIBUTE_UNUSED,
212 : : const frange &op1 ATTRIBUTE_UNUSED,
213 : : const frange &op2 ATTRIBUTE_UNUSED,
214 : : relation_kind) const
215 : : {
216 : 3602410 : return VREL_VARYING;
217 : : }
218 : :
219 : : relation_kind
220 : 346626 : range_operator::op1_op2_relation (const irange &,
221 : : const frange &,
222 : : const frange &) const
223 : : {
224 : 346626 : return VREL_VARYING;
225 : : }
226 : :
227 : :
228 : : relation_kind
229 : 640747 : range_operator::op1_op2_relation (const frange &,
230 : : const frange &,
231 : : const frange &) const
232 : : {
233 : 640747 : return VREL_VARYING;
234 : : }
235 : :
236 : : // Return TRUE if OP1 and OP2 may be a NAN.
237 : :
238 : : static inline bool
239 : 3547022 : maybe_isnan (const frange &op1, const frange &op2)
240 : : {
241 : 6205474 : return op1.maybe_isnan () || op2.maybe_isnan ();
242 : : }
243 : :
244 : : // Floating point version of relop_early_resolve that takes NANs into
245 : : // account.
246 : : //
247 : : // For relation opcodes, first try to see if the supplied relation
248 : : // forces a true or false result, and return that.
249 : : // Then check for undefined operands. If none of this applies,
250 : : // return false.
251 : : //
252 : : // TRIO are the relations between operands as they appear in the IL.
253 : : // MY_REL is the relation that corresponds to the operator being
254 : : // folded. For example, when attempting to fold x_3 == y_5, MY_REL is
255 : : // VREL_EQ, and if the statement is dominated by x_3 > y_5, then
256 : : // TRIO.op1_op2() is VREL_GT.
257 : :
258 : : static inline bool
259 : 2039185 : frelop_early_resolve (irange &r, tree type,
260 : : const frange &op1, const frange &op2,
261 : : relation_trio trio, relation_kind my_rel)
262 : : {
263 : 2039185 : relation_kind rel = trio.op1_op2 ();
264 : :
265 : : // If known relation is a complete subset of this relation, always
266 : : // return true. However, avoid doing this when NAN is a possibility
267 : : // as we'll incorrectly fold conditions:
268 : : //
269 : : // if (x_3 >= y_5)
270 : : // ;
271 : : // else
272 : : // ;; With NANs the relation here is basically VREL_UNLT, so we
273 : : // ;; can't fold the following:
274 : : // if (x_3 < y_5)
275 : 2039185 : if (!maybe_isnan (op1, op2) && relation_union (rel, my_rel) == my_rel)
276 : : {
277 : 606 : r = range_true (type);
278 : 606 : return true;
279 : : }
280 : :
281 : : // If known relation has no subset of this relation, always false.
282 : 2038579 : if (relation_intersect (rel, my_rel) == VREL_UNDEFINED)
283 : : {
284 : 871 : r = range_false (type);
285 : 871 : return true;
286 : : }
287 : :
288 : : // If either operand is undefined, return VARYING.
289 : 2037708 : if (empty_range_varying (r, type, op1, op2))
290 : 2274 : return true;
291 : :
292 : : return false;
293 : : }
294 : :
295 : : // Set VALUE to its next real value, or INF if the operation overflows.
296 : :
297 : : void
298 : 3815743 : frange_nextafter (enum machine_mode mode,
299 : : REAL_VALUE_TYPE &value,
300 : : const REAL_VALUE_TYPE &inf)
301 : : {
302 : 26710201 : if (MODE_COMPOSITE_P (mode)
303 : 0 : && (real_isdenormal (&value, mode) || real_iszero (&value)))
304 : : {
305 : : // IBM extended denormals only have DFmode precision.
306 : 0 : REAL_VALUE_TYPE tmp, tmp2;
307 : 0 : real_convert (&tmp2, DFmode, &value);
308 : 0 : real_nextafter (&tmp, REAL_MODE_FORMAT (DFmode), &tmp2, &inf);
309 : 0 : real_convert (&value, mode, &tmp);
310 : : }
311 : : else
312 : : {
313 : 3815743 : REAL_VALUE_TYPE tmp;
314 : 3815743 : real_nextafter (&tmp, REAL_MODE_FORMAT (mode), &value, &inf);
315 : 3815743 : value = tmp;
316 : : }
317 : 3815743 : }
318 : :
319 : : // Like real_arithmetic, but round the result to INF if the operation
320 : : // produced inexact results.
321 : : //
322 : : // ?? There is still one problematic case, i387. With
323 : : // -fexcess-precision=standard we perform most SF/DFmode arithmetic in
324 : : // XFmode (long_double_type_node), so that case is OK. But without
325 : : // -mfpmath=sse, all the SF/DFmode computations are in XFmode
326 : : // precision (64-bit mantissa) and only occasionally rounded to
327 : : // SF/DFmode (when storing into memory from the 387 stack). Maybe
328 : : // this is ok as well though it is just occasionally more precise. ??
329 : :
330 : : void
331 : 15452098 : frange_arithmetic (enum tree_code code, tree type,
332 : : REAL_VALUE_TYPE &result,
333 : : const REAL_VALUE_TYPE &op1,
334 : : const REAL_VALUE_TYPE &op2,
335 : : const REAL_VALUE_TYPE &inf)
336 : : {
337 : 15452098 : REAL_VALUE_TYPE value;
338 : 15452098 : enum machine_mode mode = TYPE_MODE (type);
339 : 108164686 : bool mode_composite = MODE_COMPOSITE_P (mode);
340 : :
341 : 15452098 : bool inexact = real_arithmetic (&value, code, &op1, &op2);
342 : 15452098 : real_convert (&result, mode, &value);
343 : :
344 : : /* When rounding towards negative infinity, x + (-x) and
345 : : x - x is -0 rather than +0 real_arithmetic computes.
346 : : So, when we are looking for lower bound (inf is negative),
347 : : use -0 rather than +0. */
348 : 15452098 : if (flag_rounding_math
349 : 16360 : && (code == PLUS_EXPR || code == MINUS_EXPR)
350 : 4692 : && !inexact
351 : 4692 : && real_iszero (&result)
352 : 66 : && !real_isneg (&result)
353 : 15452164 : && real_isneg (&inf))
354 : : {
355 : 36 : REAL_VALUE_TYPE op2a = op2;
356 : 36 : if (code == PLUS_EXPR)
357 : 30 : op2a.sign ^= 1;
358 : 36 : if (real_isneg (&op1) == real_isneg (&op2a) && real_equal (&op1, &op2a))
359 : 36 : result.sign = 1;
360 : : }
361 : :
362 : : // Be extra careful if there may be discrepancies between the
363 : : // compile and runtime results.
364 : 15452098 : bool round = false;
365 : 15452098 : if (mode_composite)
366 : : round = true;
367 : : else
368 : : {
369 : 15452098 : bool low = real_isneg (&inf);
370 : 15452098 : round = (low ? !real_less (&result, &value)
371 : 7726126 : : !real_less (&value, &result));
372 : 15452098 : if (real_isinf (&result, !low)
373 : 1510905 : && !real_isinf (&value)
374 : 15822120 : && !flag_rounding_math)
375 : : {
376 : : // Use just [+INF, +INF] rather than [MAX, +INF]
377 : : // even if value is larger than MAX and rounds to
378 : : // nearest to +INF. Similarly just [-INF, -INF]
379 : : // rather than [-INF, +MAX] even if value is smaller
380 : : // than -MAX and rounds to nearest to -INF.
381 : : // Unless INEXACT is true, in that case we need some
382 : : // extra buffer.
383 : 368121 : if (!inexact)
384 : : round = false;
385 : : else
386 : : {
387 : 56688 : REAL_VALUE_TYPE tmp = result, tmp2;
388 : 56688 : frange_nextafter (mode, tmp, inf);
389 : : // TMP is at this point the maximum representable
390 : : // number.
391 : 56688 : real_arithmetic (&tmp2, MINUS_EXPR, &value, &tmp);
392 : 56688 : if (real_isneg (&tmp2) != low
393 : 56688 : && (REAL_EXP (&tmp2) - REAL_EXP (&tmp)
394 : 56688 : >= 2 - REAL_MODE_FORMAT (mode)->p))
395 : 56688 : round = false;
396 : : }
397 : : }
398 : : }
399 : 15140665 : if (round && (inexact || !real_identical (&result, &value)))
400 : : {
401 : 1464141 : if (mode_composite
402 : 1464141 : && (real_isdenormal (&result, mode) || real_iszero (&result)))
403 : : {
404 : : // IBM extended denormals only have DFmode precision.
405 : 0 : REAL_VALUE_TYPE tmp, tmp2;
406 : 0 : real_convert (&tmp2, DFmode, &value);
407 : 0 : real_nextafter (&tmp, REAL_MODE_FORMAT (DFmode), &tmp2, &inf);
408 : 0 : real_convert (&result, mode, &tmp);
409 : : }
410 : : else
411 : 1464141 : frange_nextafter (mode, result, inf);
412 : : }
413 : 15452098 : if (mode_composite)
414 : 0 : switch (code)
415 : : {
416 : 0 : case PLUS_EXPR:
417 : 0 : case MINUS_EXPR:
418 : : // ibm-ldouble-format documents 1ulp for + and -.
419 : 0 : frange_nextafter (mode, result, inf);
420 : 0 : break;
421 : 0 : case MULT_EXPR:
422 : : // ibm-ldouble-format documents 2ulps for *.
423 : 0 : frange_nextafter (mode, result, inf);
424 : 0 : frange_nextafter (mode, result, inf);
425 : 0 : break;
426 : 0 : case RDIV_EXPR:
427 : : // ibm-ldouble-format documents 3ulps for /.
428 : 0 : frange_nextafter (mode, result, inf);
429 : 0 : frange_nextafter (mode, result, inf);
430 : 0 : frange_nextafter (mode, result, inf);
431 : 0 : break;
432 : : default:
433 : : break;
434 : : }
435 : 15452098 : }
436 : :
437 : : // Crop R to [-INF, MAX] where MAX is the maximum representable number
438 : : // for TYPE.
439 : :
440 : : static inline void
441 : 167965 : frange_drop_inf (frange &r, tree type)
442 : : {
443 : 167965 : REAL_VALUE_TYPE max = real_max_representable (type);
444 : 167965 : frange tmp (type, r.lower_bound (), max);
445 : 167965 : r.intersect (tmp);
446 : 167965 : }
447 : :
448 : : // Crop R to [MIN, +INF] where MIN is the minimum representable number
449 : : // for TYPE.
450 : :
451 : : static inline void
452 : 87445 : frange_drop_ninf (frange &r, tree type)
453 : : {
454 : 87445 : REAL_VALUE_TYPE min = real_min_representable (type);
455 : 87445 : frange tmp (type, min, r.upper_bound ());
456 : 87445 : r.intersect (tmp);
457 : 87445 : }
458 : :
459 : : // Crop R to [MIN, MAX] where MAX is the maximum representable number
460 : : // for TYPE and MIN the minimum representable number for TYPE.
461 : :
462 : : static inline void
463 : 1379158 : frange_drop_infs (frange &r, tree type)
464 : : {
465 : 1379158 : REAL_VALUE_TYPE max = real_max_representable (type);
466 : 1379158 : REAL_VALUE_TYPE min = real_min_representable (type);
467 : 1379158 : frange tmp (type, min, max);
468 : 1379158 : r.intersect (tmp);
469 : 1379158 : }
470 : :
471 : : // If zero is in R, make sure both -0.0 and +0.0 are in the range.
472 : :
473 : : static inline void
474 : 926712 : frange_add_zeros (frange &r, tree type)
475 : : {
476 : 926712 : if (r.undefined_p () || r.known_isnan ())
477 : : return;
478 : :
479 : 926712 : if (HONOR_SIGNED_ZEROS (type)
480 : 926712 : && (real_iszero (&r.lower_bound ()) || real_iszero (&r.upper_bound ())))
481 : : {
482 : 143080 : frange zero;
483 : 143080 : zero.set_zero (type);
484 : 143080 : r.union_ (zero);
485 : 143080 : }
486 : : }
487 : :
488 : : // Build a range that is <= VAL and store it in R. Return TRUE if
489 : : // further changes may be needed for R, or FALSE if R is in its final
490 : : // form.
491 : :
492 : : static bool
493 : 241191 : build_le (frange &r, tree type, const frange &val)
494 : : {
495 : 241191 : gcc_checking_assert (!val.known_isnan ());
496 : :
497 : 241191 : REAL_VALUE_TYPE ninf = frange_val_min (type);
498 : 241191 : r.set (type, ninf, val.upper_bound ());
499 : :
500 : : // Add both zeros if there's the possibility of zero equality.
501 : 241191 : frange_add_zeros (r, type);
502 : :
503 : 241191 : return true;
504 : : }
505 : :
506 : : // Build a range that is < VAL and store it in R. Return TRUE if
507 : : // further changes may be needed for R, or FALSE if R is in its final
508 : : // form.
509 : :
510 : : static bool
511 : 295434 : build_lt (frange &r, tree type, const frange &val)
512 : : {
513 : 295434 : gcc_checking_assert (!val.known_isnan ());
514 : :
515 : : // < -INF is outside the range.
516 : 295434 : if (real_isinf (&val.upper_bound (), 1))
517 : : {
518 : 1086 : if (HONOR_NANS (type))
519 : 1086 : r.set_nan (type);
520 : : else
521 : 0 : r.set_undefined ();
522 : 1086 : return false;
523 : : }
524 : :
525 : 294348 : REAL_VALUE_TYPE ninf = frange_val_min (type);
526 : 294348 : REAL_VALUE_TYPE prev = val.upper_bound ();
527 : 294348 : machine_mode mode = TYPE_MODE (type);
528 : : // Default to the conservatively correct closed ranges for
529 : : // MODE_COMPOSITE_P, otherwise use nextafter. Note that for
530 : : // !HONOR_INFINITIES, nextafter will yield -INF, but frange::set()
531 : : // will crop the range appropriately.
532 : 2060436 : if (!MODE_COMPOSITE_P (mode))
533 : 294348 : frange_nextafter (mode, prev, ninf);
534 : 294348 : r.set (type, ninf, prev);
535 : 294348 : return true;
536 : : }
537 : :
538 : : // Build a range that is >= VAL and store it in R. Return TRUE if
539 : : // further changes may be needed for R, or FALSE if R is in its final
540 : : // form.
541 : :
542 : : static bool
543 : 367229 : build_ge (frange &r, tree type, const frange &val)
544 : : {
545 : 367229 : gcc_checking_assert (!val.known_isnan ());
546 : :
547 : 367229 : REAL_VALUE_TYPE inf = frange_val_max (type);
548 : 367229 : r.set (type, val.lower_bound (), inf);
549 : :
550 : : // Add both zeros if there's the possibility of zero equality.
551 : 367229 : frange_add_zeros (r, type);
552 : :
553 : 367229 : return true;
554 : : }
555 : :
556 : : // Build a range that is > VAL and store it in R. Return TRUE if
557 : : // further changes may be needed for R, or FALSE if R is in its final
558 : : // form.
559 : :
560 : : static bool
561 : 192247 : build_gt (frange &r, tree type, const frange &val)
562 : : {
563 : 192247 : gcc_checking_assert (!val.known_isnan ());
564 : :
565 : : // > +INF is outside the range.
566 : 192247 : if (real_isinf (&val.lower_bound (), 0))
567 : : {
568 : 2467 : if (HONOR_NANS (type))
569 : 2467 : r.set_nan (type);
570 : : else
571 : 0 : r.set_undefined ();
572 : 2467 : return false;
573 : : }
574 : :
575 : 189780 : REAL_VALUE_TYPE inf = frange_val_max (type);
576 : 189780 : REAL_VALUE_TYPE next = val.lower_bound ();
577 : 189780 : machine_mode mode = TYPE_MODE (type);
578 : : // Default to the conservatively correct closed ranges for
579 : : // MODE_COMPOSITE_P, otherwise use nextafter. Note that for
580 : : // !HONOR_INFINITIES, nextafter will yield +INF, but frange::set()
581 : : // will crop the range appropriately.
582 : 1328460 : if (!MODE_COMPOSITE_P (mode))
583 : 189780 : frange_nextafter (mode, next, inf);
584 : 189780 : r.set (type, next, inf);
585 : 189780 : return true;
586 : : }
587 : :
588 : :
589 : : bool
590 : 53605 : operator_identity::fold_range (frange &r, tree, const frange &op1,
591 : : const frange &, relation_trio) const
592 : : {
593 : 53605 : r = op1;
594 : 53605 : return true;
595 : : }
596 : :
597 : : bool
598 : 16364 : operator_identity::op1_range (frange &r, tree, const frange &lhs,
599 : : const frange &, relation_trio) const
600 : : {
601 : 16364 : r = lhs;
602 : 16364 : return true;
603 : : }
604 : :
605 : : bool
606 : 1110 : operator_cst::fold_range (frange &r, tree, const frange &op1,
607 : : const frange &, relation_trio) const
608 : : {
609 : 1110 : r = op1;
610 : 1110 : return true;
611 : : }
612 : :
613 : : bool
614 : 24648 : operator_equal::op2_range (frange &r, tree type,
615 : : const irange &lhs, const frange &op1,
616 : : relation_trio rel) const
617 : : {
618 : 24648 : return op1_range (r, type, lhs, op1, rel.swap_op1_op2 ());
619 : : }
620 : :
621 : : bool
622 : 136515 : operator_equal::fold_range (irange &r, tree type,
623 : : const frange &op1, const frange &op2,
624 : : relation_trio rel) const
625 : : {
626 : 136515 : if (frelop_early_resolve (r, type, op1, op2, rel, VREL_EQ))
627 : : return true;
628 : :
629 : 136107 : if (op1.known_isnan () || op2.known_isnan ())
630 : 301 : r = range_false (type);
631 : : // We can be sure the values are always equal or not if both ranges
632 : : // consist of a single value, and then compare them.
633 : 135806 : else if (op1.singleton_p () && op2.singleton_p ())
634 : : {
635 : 476 : if (op1 == op2)
636 : 144 : r = range_true (type);
637 : : // If one operand is -0.0 and other 0.0, they are still equal.
638 : 332 : else if (real_iszero (&op1.lower_bound ())
639 : 332 : && real_iszero (&op2.lower_bound ()))
640 : 30 : r = range_true (type);
641 : : else
642 : 302 : r = range_false (type);
643 : : }
644 : 135330 : else if (real_iszero (&op1.lower_bound ())
645 : 5122 : && real_iszero (&op1.upper_bound ())
646 : 718 : && real_iszero (&op2.lower_bound ())
647 : 298 : && real_iszero (&op2.upper_bound ())
648 : 135628 : && !maybe_isnan (op1, op2))
649 : : // [-0.0, 0.0] == [-0.0, 0.0] or similar.
650 : 155 : r = range_true (type);
651 : : else
652 : : {
653 : : // If ranges do not intersect, we know the range is not equal,
654 : : // otherwise we don't know anything for sure.
655 : 135175 : frange tmp = op1;
656 : 135175 : tmp.intersect (op2);
657 : 135175 : if (tmp.undefined_p ())
658 : : {
659 : : // If one range is [whatever, -0.0] and another
660 : : // [0.0, whatever2], we don't know anything either,
661 : : // because -0.0 == 0.0.
662 : 639 : if ((real_iszero (&op1.upper_bound ())
663 : 59 : && real_iszero (&op2.lower_bound ()))
664 : 642 : || (real_iszero (&op1.lower_bound ())
665 : 39 : && real_iszero (&op2.upper_bound ())))
666 : 56 : r = range_true_and_false (type);
667 : : else
668 : 583 : r = range_false (type);
669 : : }
670 : : else
671 : 134536 : r = range_true_and_false (type);
672 : 135175 : }
673 : : return true;
674 : : }
675 : :
676 : : bool
677 : 118271 : operator_equal::op1_range (frange &r, tree type,
678 : : const irange &lhs,
679 : : const frange &op2,
680 : : relation_trio trio) const
681 : : {
682 : 118271 : relation_kind rel = trio.op1_op2 ();
683 : 118271 : switch (get_bool_state (r, lhs, type))
684 : : {
685 : 28005 : case BRS_TRUE:
686 : : // The TRUE side of x == NAN is unreachable.
687 : 28005 : if (op2.known_isnan ())
688 : 0 : r.set_undefined ();
689 : : else
690 : : {
691 : : // If it's true, the result is the same as OP2.
692 : 28005 : r = op2;
693 : : // Add both zeros if there's the possibility of zero equality.
694 : 28005 : frange_add_zeros (r, type);
695 : : // The TRUE side of op1 == op2 implies op1 is !NAN.
696 : 28005 : r.clear_nan ();
697 : : }
698 : : break;
699 : :
700 : 88620 : case BRS_FALSE:
701 : : // The FALSE side of op1 == op1 implies op1 is a NAN.
702 : 88620 : if (rel == VREL_EQ)
703 : 1424 : r.set_nan (type);
704 : : // On the FALSE side of x == NAN, we know nothing about x.
705 : 87196 : else if (op2.known_isnan ())
706 : 0 : r.set_varying (type);
707 : : // If the result is false, the only time we know anything is
708 : : // if OP2 is a constant.
709 : 87196 : else if (op2.singleton_p ()
710 : 96446 : || (!op2.maybe_isnan () && op2.zero_p ()))
711 : : {
712 : 55284 : REAL_VALUE_TYPE tmp = op2.lower_bound ();
713 : 55284 : r.set (type, tmp, tmp, VR_ANTI_RANGE);
714 : : }
715 : : else
716 : 31912 : r.set_varying (type);
717 : : break;
718 : :
719 : : default:
720 : : break;
721 : : }
722 : 118271 : return true;
723 : : }
724 : :
725 : : // Check if the LHS range indicates a relation between OP1 and OP2.
726 : :
727 : : relation_kind
728 : 107801 : operator_equal::op1_op2_relation (const irange &lhs, const frange &,
729 : : const frange &) const
730 : : {
731 : 107801 : if (lhs.undefined_p ())
732 : : return VREL_UNDEFINED;
733 : :
734 : : // FALSE = op1 == op2 indicates NE_EXPR.
735 : 107801 : if (lhs.zero_p ())
736 : : return VREL_NE;
737 : :
738 : : // TRUE = op1 == op2 indicates EQ_EXPR.
739 : 46186 : if (!contains_zero_p (lhs))
740 : 44754 : return VREL_EQ;
741 : : return VREL_VARYING;
742 : : }
743 : :
744 : : bool
745 : 848133 : operator_not_equal::fold_range (irange &r, tree type,
746 : : const frange &op1, const frange &op2,
747 : : relation_trio trio) const
748 : : {
749 : 848133 : relation_kind rel = trio.op1_op2 ();
750 : :
751 : : // VREL_NE & NE_EXPR is always true, even with NANs.
752 : 848133 : if (rel == VREL_NE)
753 : : {
754 : 30 : r = range_true (type);
755 : 30 : return true;
756 : : }
757 : 848103 : if (rel == VREL_EQ && maybe_isnan (op1, op2))
758 : : {
759 : : // Avoid frelop_early_resolve() below as it could fold to FALSE
760 : : // without regards to NANs. This would be incorrect if trying
761 : : // to fold x_5 != x_5 without prior knowledge of NANs.
762 : : }
763 : 830096 : else if (frelop_early_resolve (r, type, op1, op2, trio, VREL_NE))
764 : : return true;
765 : :
766 : : // x != NAN is always TRUE.
767 : 846938 : if (op1.known_isnan () || op2.known_isnan ())
768 : 1055 : r = range_true (type);
769 : : // We can be sure the values are always equal or not if both ranges
770 : : // consist of a single value, and then compare them.
771 : 845883 : else if (op1.singleton_p () && op2.singleton_p ())
772 : : {
773 : 1365 : if (op1 == op2)
774 : 854 : r = range_false (type);
775 : : // If one operand is -0.0 and other 0.0, they are still equal.
776 : 511 : else if (real_iszero (&op1.lower_bound ())
777 : 511 : && real_iszero (&op2.lower_bound ()))
778 : 0 : r = range_false (type);
779 : : else
780 : 511 : r = range_true (type);
781 : : }
782 : 844518 : else if (real_iszero (&op1.lower_bound ())
783 : 7521 : && real_iszero (&op1.upper_bound ())
784 : 353 : && real_iszero (&op2.lower_bound ())
785 : 228 : && real_iszero (&op2.upper_bound ())
786 : 844746 : && !maybe_isnan (op1, op2))
787 : : // [-0.0, 0.0] != [-0.0, 0.0] or similar.
788 : 131 : r = range_false (type);
789 : : else
790 : : {
791 : : // If ranges do not intersect, we know the range is not equal,
792 : : // otherwise we don't know anything for sure.
793 : 844387 : frange tmp = op1;
794 : 844387 : tmp.intersect (op2);
795 : 844387 : if (tmp.undefined_p ())
796 : : {
797 : : // If one range is [whatever, -0.0] and another
798 : : // [0.0, whatever2], we don't know anything either,
799 : : // because -0.0 == 0.0.
800 : 562 : if ((real_iszero (&op1.upper_bound ())
801 : 3 : && real_iszero (&op2.lower_bound ()))
802 : 565 : || (real_iszero (&op1.lower_bound ())
803 : 7 : && real_iszero (&op2.upper_bound ())))
804 : 0 : r = range_true_and_false (type);
805 : : else
806 : 562 : r = range_true (type);
807 : : }
808 : : else
809 : 843825 : r = range_true_and_false (type);
810 : 844387 : }
811 : : return true;
812 : : }
813 : :
814 : : bool
815 : 331982 : operator_not_equal::op1_range (frange &r, tree type,
816 : : const irange &lhs,
817 : : const frange &op2,
818 : : relation_trio trio) const
819 : : {
820 : 331982 : relation_kind rel = trio.op1_op2 ();
821 : 331982 : switch (get_bool_state (r, lhs, type))
822 : : {
823 : 40219 : case BRS_TRUE:
824 : : // If the result is true, the only time we know anything is if
825 : : // OP2 is a constant.
826 : 40219 : if (op2.singleton_p ())
827 : : {
828 : : // This is correct even if op1 is NAN, because the following
829 : : // range would be ~[tmp, tmp] with the NAN property set to
830 : : // maybe (VARYING).
831 : 22384 : REAL_VALUE_TYPE tmp = op2.lower_bound ();
832 : 22384 : r.set (type, tmp, tmp, VR_ANTI_RANGE);
833 : : }
834 : : // The TRUE side of op1 != op1 implies op1 is NAN.
835 : 17835 : else if (rel == VREL_EQ)
836 : 1442 : r.set_nan (type);
837 : : else
838 : 16393 : r.set_varying (type);
839 : : break;
840 : :
841 : 290283 : case BRS_FALSE:
842 : : // The FALSE side of x != NAN is impossible.
843 : 290283 : if (op2.known_isnan ())
844 : 9 : r.set_undefined ();
845 : : else
846 : : {
847 : : // If it's false, the result is the same as OP2.
848 : 290274 : r = op2;
849 : : // Add both zeros if there's the possibility of zero equality.
850 : 290274 : frange_add_zeros (r, type);
851 : : // The FALSE side of op1 != op2 implies op1 is !NAN.
852 : 290274 : r.clear_nan ();
853 : : }
854 : : break;
855 : :
856 : : default:
857 : : break;
858 : : }
859 : 331982 : return true;
860 : : }
861 : :
862 : : bool
863 : 237051 : operator_not_equal::op2_range (frange &r, tree type,
864 : : const irange &lhs,
865 : : const frange &op1,
866 : : relation_trio trio) const
867 : : {
868 : 237051 : return op1_range (r, type, lhs, op1, trio);
869 : : }
870 : :
871 : : // Check if the LHS range indicates a relation between OP1 and OP2.
872 : :
873 : : relation_kind
874 : 674256 : operator_not_equal::op1_op2_relation (const irange &lhs, const frange &,
875 : : const frange &) const
876 : : {
877 : 674256 : if (lhs.undefined_p ())
878 : : return VREL_UNDEFINED;
879 : :
880 : : // FALSE = op1 != op2 indicates EQ_EXPR.
881 : 674256 : if (lhs.zero_p ())
882 : : return VREL_EQ;
883 : :
884 : : // TRUE = op1 != op2 indicates NE_EXPR.
885 : 98136 : if (!contains_zero_p (lhs))
886 : 96685 : return VREL_NE;
887 : : return VREL_VARYING;
888 : : }
889 : :
890 : : bool
891 : 259515 : operator_lt::fold_range (irange &r, tree type,
892 : : const frange &op1, const frange &op2,
893 : : relation_trio trio) const
894 : : {
895 : 259515 : if (frelop_early_resolve (r, type, op1, op2, trio, VREL_LT))
896 : : return true;
897 : :
898 : 258888 : if (op1.known_isnan ()
899 : 258426 : || op2.known_isnan ()
900 : 517021 : || !real_less (&op1.lower_bound (), &op2.upper_bound ()))
901 : 2724 : r = range_false (type);
902 : 256164 : else if (!maybe_isnan (op1, op2)
903 : 256164 : && real_less (&op1.upper_bound (), &op2.lower_bound ()))
904 : 1074 : r = range_true (type);
905 : : else
906 : 255090 : r = range_true_and_false (type);
907 : : return true;
908 : : }
909 : :
910 : : bool
911 : 411550 : operator_lt::op1_range (frange &r,
912 : : tree type,
913 : : const irange &lhs,
914 : : const frange &op2,
915 : : relation_trio) const
916 : : {
917 : 411550 : switch (get_bool_state (r, lhs, type))
918 : : {
919 : 142570 : case BRS_TRUE:
920 : : // The TRUE side of x < NAN is unreachable.
921 : 142570 : if (op2.known_isnan ())
922 : 50 : r.set_undefined ();
923 : 142520 : else if (op2.undefined_p ())
924 : : return false;
925 : 142520 : else if (build_lt (r, type, op2))
926 : : {
927 : 142520 : r.clear_nan ();
928 : : // x < y implies x is not +INF.
929 : 142520 : frange_drop_inf (r, type);
930 : : }
931 : : break;
932 : :
933 : 268431 : case BRS_FALSE:
934 : : // On the FALSE side of x < NAN, we know nothing about x.
935 : 509030 : if (op2.maybe_isnan ())
936 : 27832 : r.set_varying (type);
937 : : else
938 : 240599 : build_ge (r, type, op2);
939 : : break;
940 : :
941 : : default:
942 : : break;
943 : : }
944 : : return true;
945 : : }
946 : :
947 : : bool
948 : 60245 : operator_lt::op2_range (frange &r,
949 : : tree type,
950 : : const irange &lhs,
951 : : const frange &op1,
952 : : relation_trio) const
953 : : {
954 : 60245 : switch (get_bool_state (r, lhs, type))
955 : : {
956 : 24962 : case BRS_TRUE:
957 : : // The TRUE side of NAN < x is unreachable.
958 : 24962 : if (op1.known_isnan ())
959 : 40 : r.set_undefined ();
960 : 24922 : else if (op1.undefined_p ())
961 : : return false;
962 : 24922 : else if (build_gt (r, type, op1))
963 : : {
964 : 24922 : r.clear_nan ();
965 : : // x < y implies y is not -INF.
966 : 24922 : frange_drop_ninf (r, type);
967 : : }
968 : : break;
969 : :
970 : 34913 : case BRS_FALSE:
971 : : // On the FALSE side of NAN < x, we know nothing about x.
972 : 36818 : if (op1.maybe_isnan ())
973 : 33008 : r.set_varying (type);
974 : : else
975 : 1905 : build_le (r, type, op1);
976 : : break;
977 : :
978 : : default:
979 : : break;
980 : : }
981 : : return true;
982 : : }
983 : :
984 : :
985 : : // Check if the LHS range indicates a relation between OP1 and OP2.
986 : :
987 : : relation_kind
988 : 237904 : operator_lt::op1_op2_relation (const irange &lhs, const frange &,
989 : : const frange &) const
990 : : {
991 : 237904 : if (lhs.undefined_p ())
992 : : return VREL_UNDEFINED;
993 : :
994 : : // FALSE = op1 < op2 indicates GE_EXPR.
995 : 237904 : if (lhs.zero_p ())
996 : : return VREL_GE;
997 : :
998 : : // TRUE = op1 < op2 indicates LT_EXPR.
999 : 110779 : if (!contains_zero_p (lhs))
1000 : 110079 : return VREL_LT;
1001 : : return VREL_VARYING;
1002 : : }
1003 : :
1004 : : bool
1005 : 269201 : operator_le::fold_range (irange &r, tree type,
1006 : : const frange &op1, const frange &op2,
1007 : : relation_trio rel) const
1008 : : {
1009 : 269201 : if (frelop_early_resolve (r, type, op1, op2, rel, VREL_LE))
1010 : : return true;
1011 : :
1012 : 268745 : if (op1.known_isnan ()
1013 : 267856 : || op2.known_isnan ()
1014 : 536571 : || !real_compare (LE_EXPR, &op1.lower_bound (), &op2.upper_bound ()))
1015 : 2412 : r = range_false (type);
1016 : 266333 : else if (!maybe_isnan (op1, op2)
1017 : 266333 : && real_compare (LE_EXPR, &op1.upper_bound (), &op2.lower_bound ()))
1018 : 805 : r = range_true (type);
1019 : : else
1020 : 265528 : r = range_true_and_false (type);
1021 : : return true;
1022 : : }
1023 : :
1024 : : bool
1025 : 97404 : operator_le::op1_range (frange &r,
1026 : : tree type,
1027 : : const irange &lhs,
1028 : : const frange &op2,
1029 : : relation_trio) const
1030 : : {
1031 : 97404 : switch (get_bool_state (r, lhs, type))
1032 : : {
1033 : 67295 : case BRS_TRUE:
1034 : : // The TRUE side of x <= NAN is unreachable.
1035 : 67295 : if (op2.known_isnan ())
1036 : 0 : r.set_undefined ();
1037 : 67295 : else if (op2.undefined_p ())
1038 : : return false;
1039 : 67295 : else if (build_le (r, type, op2))
1040 : 67295 : r.clear_nan ();
1041 : : break;
1042 : :
1043 : 29811 : case BRS_FALSE:
1044 : : // On the FALSE side of x <= NAN, we know nothing about x.
1045 : 54198 : if (op2.maybe_isnan ())
1046 : 5424 : r.set_varying (type);
1047 : : else
1048 : 24387 : build_gt (r, type, op2);
1049 : : break;
1050 : :
1051 : : default:
1052 : : break;
1053 : : }
1054 : : return true;
1055 : : }
1056 : :
1057 : : bool
1058 : 15036 : operator_le::op2_range (frange &r,
1059 : : tree type,
1060 : : const irange &lhs,
1061 : : const frange &op1,
1062 : : relation_trio) const
1063 : : {
1064 : 15036 : switch (get_bool_state (r, lhs, type))
1065 : : {
1066 : 4395 : case BRS_TRUE:
1067 : : // The TRUE side of NAN <= x is unreachable.
1068 : 4395 : if (op1.known_isnan ())
1069 : 0 : r.set_undefined ();
1070 : 4395 : else if (op1.undefined_p ())
1071 : : return false;
1072 : 4395 : else if (build_ge (r, type, op1))
1073 : 4395 : r.clear_nan ();
1074 : : break;
1075 : :
1076 : 10375 : case BRS_FALSE:
1077 : : // On the FALSE side of NAN <= x, we know nothing about x.
1078 : 11101 : if (op1.maybe_isnan ())
1079 : 9649 : r.set_varying (type);
1080 : 726 : else if (op1.undefined_p ())
1081 : : return false;
1082 : : else
1083 : 726 : build_lt (r, type, op1);
1084 : : break;
1085 : :
1086 : : default:
1087 : : break;
1088 : : }
1089 : : return true;
1090 : : }
1091 : :
1092 : : // Check if the LHS range indicates a relation between OP1 and OP2.
1093 : :
1094 : : relation_kind
1095 : 62829 : operator_le::op1_op2_relation (const irange &lhs, const frange &,
1096 : : const frange &) const
1097 : : {
1098 : 62829 : if (lhs.undefined_p ())
1099 : : return VREL_UNDEFINED;
1100 : :
1101 : : // FALSE = op1 <= op2 indicates GT_EXPR.
1102 : 62829 : if (lhs.zero_p ())
1103 : : return VREL_GT;
1104 : :
1105 : : // TRUE = op1 <= op2 indicates LE_EXPR.
1106 : 31464 : if (!contains_zero_p (lhs))
1107 : 30932 : return VREL_LE;
1108 : : return VREL_VARYING;
1109 : : }
1110 : :
1111 : : bool
1112 : 275725 : operator_gt::fold_range (irange &r, tree type,
1113 : : const frange &op1, const frange &op2,
1114 : : relation_trio trio) const
1115 : : {
1116 : 275725 : if (frelop_early_resolve (r, type, op1, op2, trio, VREL_GT))
1117 : : return true;
1118 : :
1119 : 275014 : if (op1.known_isnan ()
1120 : 274632 : || op2.known_isnan ()
1121 : 549338 : || !real_compare (GT_EXPR, &op1.upper_bound (), &op2.lower_bound ()))
1122 : 4361 : r = range_false (type);
1123 : 270653 : else if (!maybe_isnan (op1, op2)
1124 : 270653 : && real_compare (GT_EXPR, &op1.lower_bound (), &op2.upper_bound ()))
1125 : 721 : r = range_true (type);
1126 : : else
1127 : 269932 : r = range_true_and_false (type);
1128 : : return true;
1129 : : }
1130 : :
1131 : : bool
1132 : 156277 : operator_gt::op1_range (frange &r,
1133 : : tree type,
1134 : : const irange &lhs,
1135 : : const frange &op2,
1136 : : relation_trio) const
1137 : : {
1138 : 156277 : switch (get_bool_state (r, lhs, type))
1139 : : {
1140 : 62533 : case BRS_TRUE:
1141 : : // The TRUE side of x > NAN is unreachable.
1142 : 62533 : if (op2.known_isnan ())
1143 : 10 : r.set_undefined ();
1144 : 62523 : else if (op2.undefined_p ())
1145 : : return false;
1146 : 62523 : else if (build_gt (r, type, op2))
1147 : : {
1148 : 62523 : r.clear_nan ();
1149 : : // x > y implies x is not -INF.
1150 : 62523 : frange_drop_ninf (r, type);
1151 : : }
1152 : : break;
1153 : :
1154 : 93054 : case BRS_FALSE:
1155 : : // On the FALSE side of x > NAN, we know nothing about x.
1156 : 161491 : if (op2.maybe_isnan ())
1157 : 24617 : r.set_varying (type);
1158 : 68437 : else if (op2.undefined_p ())
1159 : : return false;
1160 : : else
1161 : 68437 : build_le (r, type, op2);
1162 : : break;
1163 : :
1164 : : default:
1165 : : break;
1166 : : }
1167 : : return true;
1168 : : }
1169 : :
1170 : : bool
1171 : 64209 : operator_gt::op2_range (frange &r,
1172 : : tree type,
1173 : : const irange &lhs,
1174 : : const frange &op1,
1175 : : relation_trio) const
1176 : : {
1177 : 64209 : switch (get_bool_state (r, lhs, type))
1178 : : {
1179 : 25485 : case BRS_TRUE:
1180 : : // The TRUE side of NAN > x is unreachable.
1181 : 25485 : if (op1.known_isnan ())
1182 : 40 : r.set_undefined ();
1183 : 25445 : else if (op1.undefined_p ())
1184 : : return false;
1185 : 25445 : else if (build_lt (r, type, op1))
1186 : : {
1187 : 25445 : r.clear_nan ();
1188 : : // x > y implies y is not +INF.
1189 : 25445 : frange_drop_inf (r, type);
1190 : : }
1191 : : break;
1192 : :
1193 : 38338 : case BRS_FALSE:
1194 : : // On The FALSE side of NAN > x, we know nothing about x.
1195 : 39858 : if (op1.maybe_isnan ())
1196 : 36818 : r.set_varying (type);
1197 : 1520 : else if (op1.undefined_p ())
1198 : : return false;
1199 : : else
1200 : 1520 : build_ge (r, type, op1);
1201 : : break;
1202 : :
1203 : : default:
1204 : : break;
1205 : : }
1206 : : return true;
1207 : : }
1208 : :
1209 : : // Check if the LHS range indicates a relation between OP1 and OP2.
1210 : :
1211 : : relation_kind
1212 : 244805 : operator_gt::op1_op2_relation (const irange &lhs, const frange &,
1213 : : const frange &) const
1214 : : {
1215 : 244805 : if (lhs.undefined_p ())
1216 : : return VREL_UNDEFINED;
1217 : :
1218 : : // FALSE = op1 > op2 indicates LE_EXPR.
1219 : 244805 : if (lhs.zero_p ())
1220 : : return VREL_LE;
1221 : :
1222 : : // TRUE = op1 > op2 indicates GT_EXPR.
1223 : 111101 : if (!contains_zero_p (lhs))
1224 : 110297 : return VREL_GT;
1225 : : return VREL_VARYING;
1226 : : }
1227 : :
1228 : : bool
1229 : 268133 : operator_ge::fold_range (irange &r, tree type,
1230 : : const frange &op1, const frange &op2,
1231 : : relation_trio rel) const
1232 : : {
1233 : 268133 : if (frelop_early_resolve (r, type, op1, op2, rel, VREL_GE))
1234 : : return true;
1235 : :
1236 : 267749 : if (op1.known_isnan ()
1237 : 267074 : || op2.known_isnan ()
1238 : 534797 : || !real_compare (GE_EXPR, &op1.upper_bound (), &op2.lower_bound ()))
1239 : 1350 : r = range_false (type);
1240 : 266399 : else if (!maybe_isnan (op1, op2)
1241 : 266399 : && real_compare (GE_EXPR, &op1.lower_bound (), &op2.upper_bound ()))
1242 : 2515 : r = range_true (type);
1243 : : else
1244 : 263884 : r = range_true_and_false (type);
1245 : : return true;
1246 : : }
1247 : :
1248 : : bool
1249 : 111426 : operator_ge::op1_range (frange &r,
1250 : : tree type,
1251 : : const irange &lhs,
1252 : : const frange &op2,
1253 : : relation_trio) const
1254 : : {
1255 : 111426 : switch (get_bool_state (r, lhs, type))
1256 : : {
1257 : 61243 : case BRS_TRUE:
1258 : : // The TRUE side of x >= NAN is unreachable.
1259 : 61243 : if (op2.known_isnan ())
1260 : 0 : r.set_undefined ();
1261 : 61243 : else if (op2.undefined_p ())
1262 : : return false;
1263 : 61243 : else if (build_ge (r, type, op2))
1264 : 61243 : r.clear_nan ();
1265 : : break;
1266 : :
1267 : 49885 : case BRS_FALSE:
1268 : : // On the FALSE side of x >= NAN, we know nothing about x.
1269 : 92634 : if (op2.maybe_isnan ())
1270 : 7136 : r.set_varying (type);
1271 : 42749 : else if (op2.undefined_p ())
1272 : : return false;
1273 : : else
1274 : 42749 : build_lt (r, type, op2);
1275 : : break;
1276 : :
1277 : : default:
1278 : : break;
1279 : : }
1280 : : return true;
1281 : : }
1282 : :
1283 : : bool
1284 : 13683 : operator_ge::op2_range (frange &r, tree type,
1285 : : const irange &lhs,
1286 : : const frange &op1,
1287 : : relation_trio) const
1288 : : {
1289 : 13683 : switch (get_bool_state (r, lhs, type))
1290 : : {
1291 : 5604 : case BRS_TRUE:
1292 : : // The TRUE side of NAN >= x is unreachable.
1293 : 5604 : if (op1.known_isnan ())
1294 : 0 : r.set_undefined ();
1295 : 5604 : else if (op1.undefined_p ())
1296 : : return false;
1297 : 5604 : else if (build_le (r, type, op1))
1298 : 5604 : r.clear_nan ();
1299 : : break;
1300 : :
1301 : 7813 : case BRS_FALSE:
1302 : : // On the FALSE side of NAN >= x, we know nothing about x.
1303 : 8365 : if (op1.maybe_isnan ())
1304 : 7261 : r.set_varying (type);
1305 : 552 : else if (op1.undefined_p ())
1306 : : return false;
1307 : : else
1308 : 552 : build_gt (r, type, op1);
1309 : : break;
1310 : :
1311 : : default:
1312 : : break;
1313 : : }
1314 : : return true;
1315 : : }
1316 : :
1317 : : // Check if the LHS range indicates a relation between OP1 and OP2.
1318 : :
1319 : : relation_kind
1320 : 60267 : operator_ge::op1_op2_relation (const irange &lhs, const frange &,
1321 : : const frange &) const
1322 : : {
1323 : 60267 : if (lhs.undefined_p ())
1324 : : return VREL_UNDEFINED;
1325 : :
1326 : : // FALSE = op1 >= op2 indicates LT_EXPR.
1327 : 60267 : if (lhs.zero_p ())
1328 : : return VREL_LT;
1329 : :
1330 : : // TRUE = op1 >= op2 indicates GE_EXPR.
1331 : 31096 : if (!contains_zero_p (lhs))
1332 : 30564 : return VREL_GE;
1333 : : return VREL_VARYING;
1334 : : }
1335 : :
1336 : : // UNORDERED_EXPR comparison.
1337 : :
1338 : : class foperator_unordered : public range_operator
1339 : : {
1340 : : using range_operator::fold_range;
1341 : : using range_operator::op1_range;
1342 : : using range_operator::op2_range;
1343 : : public:
1344 : : bool fold_range (irange &r, tree type,
1345 : : const frange &op1, const frange &op2,
1346 : : relation_trio = TRIO_VARYING) const final override;
1347 : : bool op1_range (frange &r, tree type,
1348 : : const irange &lhs, const frange &op2,
1349 : : relation_trio = TRIO_VARYING) const final override;
1350 : 56280 : bool op2_range (frange &r, tree type,
1351 : : const irange &lhs, const frange &op1,
1352 : : relation_trio rel = TRIO_VARYING) const final override
1353 : : {
1354 : 56280 : return op1_range (r, type, lhs, op1, rel.swap_op1_op2 ());
1355 : : }
1356 : : } fop_unordered;
1357 : :
1358 : : bool
1359 : 50131 : foperator_unordered::fold_range (irange &r, tree type,
1360 : : const frange &op1, const frange &op2,
1361 : : relation_trio) const
1362 : : {
1363 : : // UNORDERED is TRUE if either operand is a NAN.
1364 : 50131 : if (op1.known_isnan () || op2.known_isnan ())
1365 : 42 : r = range_true (type);
1366 : : // UNORDERED is FALSE if neither operand is a NAN.
1367 : 52311 : else if (!op1.maybe_isnan () && !op2.maybe_isnan ())
1368 : 1113 : r = range_false (type);
1369 : : else
1370 : 48976 : r = range_true_and_false (type);
1371 : 50131 : return true;
1372 : : }
1373 : :
1374 : : bool
1375 : 100539 : foperator_unordered::op1_range (frange &r, tree type,
1376 : : const irange &lhs,
1377 : : const frange &op2,
1378 : : relation_trio trio) const
1379 : : {
1380 : 100539 : relation_kind rel = trio.op1_op2 ();
1381 : 100539 : switch (get_bool_state (r, lhs, type))
1382 : : {
1383 : 36615 : case BRS_TRUE:
1384 : : // Since at least one operand must be NAN, if one of them is
1385 : : // not, the other must be.
1386 : 36615 : if (rel == VREL_EQ || !op2.maybe_isnan ())
1387 : 8392 : r.set_nan (type);
1388 : : else
1389 : 28223 : r.set_varying (type);
1390 : : break;
1391 : :
1392 : 56196 : case BRS_FALSE:
1393 : : // A false UNORDERED means both operands are !NAN, so it's
1394 : : // impossible for op2 to be a NAN.
1395 : 56196 : if (op2.known_isnan ())
1396 : 0 : r.set_undefined ();
1397 : : else
1398 : : {
1399 : 56196 : r.set_varying (type);
1400 : 56196 : r.clear_nan ();
1401 : : }
1402 : : break;
1403 : :
1404 : : default:
1405 : : break;
1406 : : }
1407 : 100539 : return true;
1408 : : }
1409 : :
1410 : : // ORDERED_EXPR comparison.
1411 : :
1412 : : class foperator_ordered : public range_operator
1413 : : {
1414 : : using range_operator::fold_range;
1415 : : using range_operator::op1_range;
1416 : : using range_operator::op2_range;
1417 : : public:
1418 : : bool fold_range (irange &r, tree type,
1419 : : const frange &op1, const frange &op2,
1420 : : relation_trio = TRIO_VARYING) const final override;
1421 : : bool op1_range (frange &r, tree type,
1422 : : const irange &lhs, const frange &op2,
1423 : : relation_trio = TRIO_VARYING) const final override;
1424 : 29560 : bool op2_range (frange &r, tree type,
1425 : : const irange &lhs, const frange &op1,
1426 : : relation_trio rel = TRIO_VARYING) const final override
1427 : : {
1428 : 29560 : return op1_range (r, type, lhs, op1, rel.swap_op1_op2 ());
1429 : : }
1430 : : } fop_ordered;
1431 : :
1432 : : bool
1433 : 34924 : foperator_ordered::fold_range (irange &r, tree type,
1434 : : const frange &op1, const frange &op2,
1435 : : relation_trio) const
1436 : : {
1437 : 34924 : if (op1.known_isnan () || op2.known_isnan ())
1438 : 369 : r = range_false (type);
1439 : 37379 : else if (!op1.maybe_isnan () && !op2.maybe_isnan ())
1440 : 1409 : r = range_true (type);
1441 : : else
1442 : 33146 : r = range_true_and_false (type);
1443 : 34924 : return true;
1444 : : }
1445 : :
1446 : : bool
1447 : 63310 : foperator_ordered::op1_range (frange &r, tree type,
1448 : : const irange &lhs,
1449 : : const frange &op2,
1450 : : relation_trio trio) const
1451 : : {
1452 : 63310 : relation_kind rel = trio.op1_op2 ();
1453 : 63310 : switch (get_bool_state (r, lhs, type))
1454 : : {
1455 : 56713 : case BRS_TRUE:
1456 : : // The TRUE side of ORDERED means both operands are !NAN, so
1457 : : // it's impossible for op2 to be a NAN.
1458 : 56713 : if (op2.known_isnan ())
1459 : 10 : r.set_undefined ();
1460 : : else
1461 : : {
1462 : 56703 : r.set_varying (type);
1463 : 56703 : r.clear_nan ();
1464 : : }
1465 : : break;
1466 : :
1467 : 4654 : case BRS_FALSE:
1468 : : // The FALSE side of op1 ORDERED op1 implies op1 is NAN.
1469 : 4654 : if (rel == VREL_EQ)
1470 : 2171 : r.set_nan (type);
1471 : : else
1472 : 2483 : r.set_varying (type);
1473 : : break;
1474 : :
1475 : : default:
1476 : : break;
1477 : : }
1478 : 63310 : return true;
1479 : : }
1480 : :
1481 : : bool
1482 : 239533 : operator_negate::fold_range (frange &r, tree type,
1483 : : const frange &op1, const frange &op2,
1484 : : relation_trio) const
1485 : : {
1486 : 239533 : if (empty_range_varying (r, type, op1, op2))
1487 : 193 : return true;
1488 : 239340 : if (op1.known_isnan ())
1489 : : {
1490 : 356 : bool sign;
1491 : 356 : if (op1.nan_signbit_p (sign))
1492 : 38 : r.set_nan (type, !sign);
1493 : : else
1494 : 318 : r.set_nan (type);
1495 : 356 : return true;
1496 : : }
1497 : :
1498 : 238984 : REAL_VALUE_TYPE lh_lb = op1.lower_bound ();
1499 : 238984 : REAL_VALUE_TYPE lh_ub = op1.upper_bound ();
1500 : 238984 : lh_lb = real_value_negate (&lh_lb);
1501 : 238984 : lh_ub = real_value_negate (&lh_ub);
1502 : 238984 : r.set (type, lh_ub, lh_lb);
1503 : 426775 : if (op1.maybe_isnan ())
1504 : : {
1505 : 51197 : bool sign;
1506 : 51197 : if (op1.nan_signbit_p (sign))
1507 : 2382 : r.update_nan (!sign);
1508 : : else
1509 : 48815 : r.update_nan ();
1510 : : }
1511 : : else
1512 : 187787 : r.clear_nan ();
1513 : : return true;
1514 : : }
1515 : :
1516 : : bool
1517 : 3082 : operator_negate::op1_range (frange &r, tree type,
1518 : : const frange &lhs, const frange &op2,
1519 : : relation_trio rel) const
1520 : : {
1521 : 3082 : return fold_range (r, type, lhs, op2, rel);
1522 : : }
1523 : :
1524 : : bool
1525 : 558650 : operator_abs::fold_range (frange &r, tree type,
1526 : : const frange &op1, const frange &op2,
1527 : : relation_trio) const
1528 : : {
1529 : 558650 : if (empty_range_varying (r, type, op1, op2))
1530 : 57 : return true;
1531 : 558593 : if (op1.known_isnan ())
1532 : : {
1533 : 582 : r.set_nan (type, /*sign=*/false);
1534 : 582 : return true;
1535 : : }
1536 : :
1537 : 558011 : const REAL_VALUE_TYPE lh_lb = op1.lower_bound ();
1538 : 558011 : const REAL_VALUE_TYPE lh_ub = op1.upper_bound ();
1539 : : // Handle the easy case where everything is positive.
1540 : 558011 : if (real_compare (GE_EXPR, &lh_lb, &dconst0)
1541 : 162980 : && !real_iszero (&lh_lb, /*sign=*/true)
1542 : 718445 : && !op1.maybe_isnan (/*sign=*/true))
1543 : : {
1544 : 160069 : r = op1;
1545 : 160069 : return true;
1546 : : }
1547 : :
1548 : 397942 : REAL_VALUE_TYPE min = real_value_abs (&lh_lb);
1549 : 397942 : REAL_VALUE_TYPE max = real_value_abs (&lh_ub);
1550 : : // If the range contains zero then we know that the minimum value in the
1551 : : // range will be zero.
1552 : 397942 : if (real_compare (LE_EXPR, &lh_lb, &dconst0)
1553 : 397942 : && real_compare (GE_EXPR, &lh_ub, &dconst0))
1554 : : {
1555 : 397096 : if (real_compare (GT_EXPR, &min, &max))
1556 : 6039 : max = min;
1557 : 397096 : min = dconst0;
1558 : : }
1559 : : else
1560 : : {
1561 : : // If the range was reversed, swap MIN and MAX.
1562 : 846 : if (real_compare (GT_EXPR, &min, &max))
1563 : 767 : std::swap (min, max);
1564 : : }
1565 : :
1566 : 397942 : r.set (type, min, max);
1567 : 416389 : if (op1.maybe_isnan ())
1568 : 382156 : r.update_nan (/*sign=*/false);
1569 : : else
1570 : 15786 : r.clear_nan ();
1571 : : return true;
1572 : : }
1573 : :
1574 : : bool
1575 : 296441 : operator_abs::op1_range (frange &r, tree type,
1576 : : const frange &lhs, const frange &op2,
1577 : : relation_trio) const
1578 : : {
1579 : 296441 : if (empty_range_varying (r, type, lhs, op2))
1580 : 0 : return true;
1581 : 296441 : if (lhs.known_isnan ())
1582 : : {
1583 : 2751 : r.set_nan (type);
1584 : 2751 : return true;
1585 : : }
1586 : :
1587 : : // Start with the positives because negatives are an impossible result.
1588 : 293690 : frange positives (type, dconst0, frange_val_max (type));
1589 : 293690 : positives.update_nan (/*sign=*/false);
1590 : 293690 : positives.intersect (lhs);
1591 : 293690 : r = positives;
1592 : : // Add -NAN if relevant.
1593 : 439919 : if (r.maybe_isnan ())
1594 : : {
1595 : 147401 : frange neg_nan;
1596 : 147401 : neg_nan.set_nan (type, true);
1597 : 147401 : r.union_ (neg_nan);
1598 : 147401 : }
1599 : 293690 : if (r.known_isnan () || r.undefined_p ())
1600 : : return true;
1601 : : // Then add the negative of each pair:
1602 : : // ABS(op1) = [5,20] would yield op1 => [-20,-5][5,20].
1603 : 293618 : frange negatives (type, real_value_negate (&positives.upper_bound ()),
1604 : 293618 : real_value_negate (&positives.lower_bound ()));
1605 : 293618 : negatives.clear_nan ();
1606 : 293618 : r.union_ (negatives);
1607 : 293618 : return true;
1608 : 587308 : }
1609 : :
1610 : : class foperator_unordered_lt : public range_operator
1611 : : {
1612 : : using range_operator::fold_range;
1613 : : using range_operator::op1_range;
1614 : : using range_operator::op2_range;
1615 : : public:
1616 : 11072 : bool fold_range (irange &r, tree type,
1617 : : const frange &op1, const frange &op2,
1618 : : relation_trio trio = TRIO_VARYING) const final override
1619 : : {
1620 : 11072 : if (op1.known_isnan () || op2.known_isnan ())
1621 : : {
1622 : 33 : r = range_true (type);
1623 : 33 : return true;
1624 : : }
1625 : 11039 : frange op1_no_nan = op1;
1626 : 11039 : frange op2_no_nan = op2;
1627 : 13676 : if (op1.maybe_isnan ())
1628 : 8386 : op1_no_nan.clear_nan ();
1629 : 18516 : if (op2.maybe_isnan ())
1630 : 3562 : op2_no_nan.clear_nan ();
1631 : 11039 : if (!range_op_handler (LT_EXPR).fold_range (r, type, op1_no_nan,
1632 : : op2_no_nan, trio))
1633 : : return false;
1634 : : // The result is the same as the ordered version when the
1635 : : // comparison is true or when the operands cannot be NANs.
1636 : 11039 : if (!maybe_isnan (op1, op2) || r == range_true (type))
1637 : : return true;
1638 : : else
1639 : : {
1640 : 8278 : r = range_true_and_false (type);
1641 : 8278 : return true;
1642 : : }
1643 : 11039 : }
1644 : : bool op1_range (frange &r, tree type,
1645 : : const irange &lhs,
1646 : : const frange &op2,
1647 : : relation_trio trio) const final override;
1648 : : bool op2_range (frange &r, tree type,
1649 : : const irange &lhs,
1650 : : const frange &op1,
1651 : : relation_trio trio) const final override;
1652 : : } fop_unordered_lt;
1653 : :
1654 : : bool
1655 : 3532 : foperator_unordered_lt::op1_range (frange &r, tree type,
1656 : : const irange &lhs,
1657 : : const frange &op2,
1658 : : relation_trio) const
1659 : : {
1660 : 3532 : switch (get_bool_state (r, lhs, type))
1661 : : {
1662 : 1688 : case BRS_TRUE:
1663 : 3320 : if (op2.maybe_isnan ())
1664 : 56 : r.set_varying (type);
1665 : 1632 : else if (op2.undefined_p ())
1666 : : return false;
1667 : : else
1668 : 1632 : build_lt (r, type, op2);
1669 : : break;
1670 : :
1671 : 1224 : case BRS_FALSE:
1672 : : // A false UNORDERED_LT means both operands are !NAN, so it's
1673 : : // impossible for op2 to be a NAN.
1674 : 1224 : if (op2.known_isnan ())
1675 : 0 : r.set_undefined ();
1676 : 1224 : else if (op2.undefined_p ())
1677 : : return false;
1678 : 1224 : else if (build_ge (r, type, op2))
1679 : 1224 : r.clear_nan ();
1680 : : break;
1681 : :
1682 : : default:
1683 : : break;
1684 : : }
1685 : : return true;
1686 : : }
1687 : :
1688 : : bool
1689 : 676 : foperator_unordered_lt::op2_range (frange &r, tree type,
1690 : : const irange &lhs,
1691 : : const frange &op1,
1692 : : relation_trio) const
1693 : : {
1694 : 676 : switch (get_bool_state (r, lhs, type))
1695 : : {
1696 : 56 : case BRS_TRUE:
1697 : 56 : if (op1.maybe_isnan ())
1698 : 56 : r.set_varying (type);
1699 : 0 : else if (op1.undefined_p ())
1700 : : return false;
1701 : : else
1702 : 0 : build_gt (r, type, op1);
1703 : : break;
1704 : :
1705 : 0 : case BRS_FALSE:
1706 : : // A false UNORDERED_LT means both operands are !NAN, so it's
1707 : : // impossible for op1 to be a NAN.
1708 : 0 : if (op1.known_isnan ())
1709 : 0 : r.set_undefined ();
1710 : 0 : else if (op1.undefined_p ())
1711 : : return false;
1712 : 0 : else if (build_le (r, type, op1))
1713 : 0 : r.clear_nan ();
1714 : : break;
1715 : :
1716 : : default:
1717 : : break;
1718 : : }
1719 : : return true;
1720 : : }
1721 : :
1722 : : class foperator_unordered_le : public range_operator
1723 : : {
1724 : : using range_operator::fold_range;
1725 : : using range_operator::op1_range;
1726 : : using range_operator::op2_range;
1727 : : public:
1728 : 179836 : bool fold_range (irange &r, tree type,
1729 : : const frange &op1, const frange &op2,
1730 : : relation_trio trio = TRIO_VARYING) const final override
1731 : : {
1732 : 179836 : if (op1.known_isnan () || op2.known_isnan ())
1733 : : {
1734 : 99 : r = range_true (type);
1735 : 99 : return true;
1736 : : }
1737 : 179737 : frange op1_no_nan = op1;
1738 : 179737 : frange op2_no_nan = op2;
1739 : 205748 : if (op1.maybe_isnan ())
1740 : 153700 : op1_no_nan.clear_nan ();
1741 : 352313 : if (op2.maybe_isnan ())
1742 : 7155 : op2_no_nan.clear_nan ();
1743 : 179737 : if (!range_op_handler (LE_EXPR).fold_range (r, type, op1_no_nan,
1744 : : op2_no_nan, trio))
1745 : : return false;
1746 : : // The result is the same as the ordered version when the
1747 : : // comparison is true or when the operands cannot be NANs.
1748 : 179737 : if (!maybe_isnan (op1, op2) || r == range_true (type))
1749 : : return true;
1750 : : else
1751 : : {
1752 : 155464 : r = range_true_and_false (type);
1753 : 155464 : return true;
1754 : : }
1755 : 179737 : }
1756 : : bool op1_range (frange &r, tree type,
1757 : : const irange &lhs, const frange &op2,
1758 : : relation_trio = TRIO_VARYING) const final override;
1759 : : bool op2_range (frange &r, tree type,
1760 : : const irange &lhs, const frange &op1,
1761 : : relation_trio = TRIO_VARYING) const final override;
1762 : : } fop_unordered_le;
1763 : :
1764 : : bool
1765 : 158967 : foperator_unordered_le::op1_range (frange &r, tree type,
1766 : : const irange &lhs, const frange &op2,
1767 : : relation_trio) const
1768 : : {
1769 : 158967 : switch (get_bool_state (r, lhs, type))
1770 : : {
1771 : 88030 : case BRS_TRUE:
1772 : 170943 : if (op2.maybe_isnan ())
1773 : 5117 : r.set_varying (type);
1774 : 82913 : else if (op2.undefined_p ())
1775 : : return false;
1776 : : else
1777 : 82913 : build_le (r, type, op2);
1778 : : break;
1779 : :
1780 : 70303 : case BRS_FALSE:
1781 : : // A false UNORDERED_LE means both operands are !NAN, so it's
1782 : : // impossible for op2 to be a NAN.
1783 : 70303 : if (op2.known_isnan ())
1784 : 0 : r.set_undefined ();
1785 : 70303 : else if (build_gt (r, type, op2))
1786 : 70301 : r.clear_nan ();
1787 : : break;
1788 : :
1789 : : default:
1790 : : break;
1791 : : }
1792 : : return true;
1793 : : }
1794 : :
1795 : : bool
1796 : 14086 : foperator_unordered_le::op2_range (frange &r,
1797 : : tree type,
1798 : : const irange &lhs,
1799 : : const frange &op1,
1800 : : relation_trio) const
1801 : : {
1802 : 14086 : switch (get_bool_state (r, lhs, type))
1803 : : {
1804 : 9851 : case BRS_TRUE:
1805 : 14857 : if (op1.maybe_isnan ())
1806 : 4845 : r.set_varying (type);
1807 : 5006 : else if (op1.undefined_p ())
1808 : : return false;
1809 : : else
1810 : 5006 : build_ge (r, type, op1);
1811 : : break;
1812 : :
1813 : 3601 : case BRS_FALSE:
1814 : : // A false UNORDERED_LE means both operands are !NAN, so it's
1815 : : // impossible for op1 to be a NAN.
1816 : 3601 : if (op1.known_isnan ())
1817 : 0 : r.set_undefined ();
1818 : 3601 : else if (op1.undefined_p ())
1819 : : return false;
1820 : 3601 : else if (build_lt (r, type, op1))
1821 : 3601 : r.clear_nan ();
1822 : : break;
1823 : :
1824 : : default:
1825 : : break;
1826 : : }
1827 : : return true;
1828 : : }
1829 : :
1830 : : class foperator_unordered_gt : public range_operator
1831 : : {
1832 : : using range_operator::fold_range;
1833 : : using range_operator::op1_range;
1834 : : using range_operator::op2_range;
1835 : : public:
1836 : 59485 : bool fold_range (irange &r, tree type,
1837 : : const frange &op1, const frange &op2,
1838 : : relation_trio trio = TRIO_VARYING) const final override
1839 : : {
1840 : 59485 : if (op1.known_isnan () || op2.known_isnan ())
1841 : : {
1842 : 157 : r = range_true (type);
1843 : 157 : return true;
1844 : : }
1845 : 59328 : frange op1_no_nan = op1;
1846 : 59328 : frange op2_no_nan = op2;
1847 : 63447 : if (op1.maybe_isnan ())
1848 : 55190 : op1_no_nan.clear_nan ();
1849 : 114992 : if (op2.maybe_isnan ())
1850 : 3664 : op2_no_nan.clear_nan ();
1851 : 59328 : if (!range_op_handler (GT_EXPR).fold_range (r, type, op1_no_nan,
1852 : : op2_no_nan, trio))
1853 : : return false;
1854 : : // The result is the same as the ordered version when the
1855 : : // comparison is true or when the operands cannot be NANs.
1856 : 59328 : if (!maybe_isnan (op1, op2) || r == range_true (type))
1857 : : return true;
1858 : : else
1859 : : {
1860 : 55083 : r = range_true_and_false (type);
1861 : 55083 : return true;
1862 : : }
1863 : 59328 : }
1864 : : bool op1_range (frange &r, tree type,
1865 : : const irange &lhs, const frange &op2,
1866 : : relation_trio = TRIO_VARYING) const final override;
1867 : : bool op2_range (frange &r, tree type,
1868 : : const irange &lhs, const frange &op1,
1869 : : relation_trio = TRIO_VARYING) const final override;
1870 : : } fop_unordered_gt;
1871 : :
1872 : : bool
1873 : 15505 : foperator_unordered_gt::op1_range (frange &r,
1874 : : tree type,
1875 : : const irange &lhs,
1876 : : const frange &op2,
1877 : : relation_trio) const
1878 : : {
1879 : 15505 : switch (get_bool_state (r, lhs, type))
1880 : : {
1881 : 4252 : case BRS_TRUE:
1882 : 8428 : if (op2.maybe_isnan ())
1883 : 76 : r.set_varying (type);
1884 : 4176 : else if (op2.undefined_p ())
1885 : : return false;
1886 : : else
1887 : 4176 : build_gt (r, type, op2);
1888 : : break;
1889 : :
1890 : 10663 : case BRS_FALSE:
1891 : : // A false UNORDERED_GT means both operands are !NAN, so it's
1892 : : // impossible for op2 to be a NAN.
1893 : 10663 : if (op2.known_isnan ())
1894 : 0 : r.set_undefined ();
1895 : 10663 : else if (op2.undefined_p ())
1896 : : return false;
1897 : 10663 : else if (build_le (r, type, op2))
1898 : 10663 : r.clear_nan ();
1899 : : break;
1900 : :
1901 : : default:
1902 : : break;
1903 : : }
1904 : : return true;
1905 : : }
1906 : :
1907 : : bool
1908 : 666 : foperator_unordered_gt::op2_range (frange &r,
1909 : : tree type,
1910 : : const irange &lhs,
1911 : : const frange &op1,
1912 : : relation_trio) const
1913 : : {
1914 : 666 : switch (get_bool_state (r, lhs, type))
1915 : : {
1916 : 76 : case BRS_TRUE:
1917 : 76 : if (op1.maybe_isnan ())
1918 : 76 : r.set_varying (type);
1919 : 0 : else if (op1.undefined_p ())
1920 : : return false;
1921 : : else
1922 : 0 : build_lt (r, type, op1);
1923 : : break;
1924 : :
1925 : 0 : case BRS_FALSE:
1926 : : // A false UNORDERED_GT means both operands are !NAN, so it's
1927 : : // impossible for op1 to be a NAN.
1928 : 0 : if (op1.known_isnan ())
1929 : 0 : r.set_undefined ();
1930 : 0 : else if (op1.undefined_p ())
1931 : : return false;
1932 : 0 : else if (build_ge (r, type, op1))
1933 : 0 : r.clear_nan ();
1934 : : break;
1935 : :
1936 : : default:
1937 : : break;
1938 : : }
1939 : : return true;
1940 : : }
1941 : :
1942 : : class foperator_unordered_ge : public range_operator
1943 : : {
1944 : : using range_operator::fold_range;
1945 : : using range_operator::op1_range;
1946 : : using range_operator::op2_range;
1947 : : public:
1948 : 173526 : bool fold_range (irange &r, tree type,
1949 : : const frange &op1, const frange &op2,
1950 : : relation_trio trio = TRIO_VARYING) const final override
1951 : : {
1952 : 173526 : if (op1.known_isnan () || op2.known_isnan ())
1953 : : {
1954 : 45 : r = range_true (type);
1955 : 45 : return true;
1956 : : }
1957 : 173481 : frange op1_no_nan = op1;
1958 : 173481 : frange op2_no_nan = op2;
1959 : 186883 : if (op1.maybe_isnan ())
1960 : 160017 : op1_no_nan.clear_nan ();
1961 : 339887 : if (op2.maybe_isnan ())
1962 : 7069 : op2_no_nan.clear_nan ();
1963 : 173481 : if (!range_op_handler (GE_EXPR).fold_range (r, type, op1_no_nan,
1964 : : op2_no_nan, trio))
1965 : : return false;
1966 : : // The result is the same as the ordered version when the
1967 : : // comparison is true or when the operands cannot be NANs.
1968 : 173481 : if (!maybe_isnan (op1, op2) || r == range_true (type))
1969 : : return true;
1970 : : else
1971 : : {
1972 : 160136 : r = range_true_and_false (type);
1973 : 160136 : return true;
1974 : : }
1975 : 173481 : }
1976 : : bool op1_range (frange &r, tree type,
1977 : : const irange &lhs, const frange &op2,
1978 : : relation_trio = TRIO_VARYING) const final override;
1979 : : bool op2_range (frange &r, tree type,
1980 : : const irange &lhs, const frange &op1,
1981 : : relation_trio = TRIO_VARYING) const final override;
1982 : : } fop_unordered_ge;
1983 : :
1984 : : bool
1985 : 137312 : foperator_unordered_ge::op1_range (frange &r,
1986 : : tree type,
1987 : : const irange &lhs,
1988 : : const frange &op2,
1989 : : relation_trio) const
1990 : : {
1991 : 137312 : switch (get_bool_state (r, lhs, type))
1992 : : {
1993 : 57887 : case BRS_TRUE:
1994 : 111129 : if (op2.maybe_isnan ())
1995 : 4645 : r.set_varying (type);
1996 : 53242 : else if (op2.undefined_p ())
1997 : : return false;
1998 : : else
1999 : 53242 : build_ge (r, type, op2);
2000 : : break;
2001 : :
2002 : 78761 : case BRS_FALSE:
2003 : : // A false UNORDERED_GE means both operands are !NAN, so it's
2004 : : // impossible for op2 to be a NAN.
2005 : 78761 : if (op2.known_isnan ())
2006 : 0 : r.set_undefined ();
2007 : 78761 : else if (op2.undefined_p ())
2008 : : return false;
2009 : 78761 : else if (build_lt (r, type, op2))
2010 : 78757 : r.clear_nan ();
2011 : : break;
2012 : :
2013 : : default:
2014 : : break;
2015 : : }
2016 : : return true;
2017 : : }
2018 : :
2019 : : bool
2020 : 14821 : foperator_unordered_ge::op2_range (frange &r, tree type,
2021 : : const irange &lhs,
2022 : : const frange &op1,
2023 : : relation_trio) const
2024 : : {
2025 : 14821 : switch (get_bool_state (r, lhs, type))
2026 : : {
2027 : 8861 : case BRS_TRUE:
2028 : 13235 : if (op1.maybe_isnan ())
2029 : 4487 : r.set_varying (type);
2030 : 4374 : else if (op1.undefined_p ())
2031 : : return false;
2032 : : else
2033 : 4374 : build_le (r, type, op1);
2034 : : break;
2035 : :
2036 : 5384 : case BRS_FALSE:
2037 : : // A false UNORDERED_GE means both operands are !NAN, so it's
2038 : : // impossible for op1 to be a NAN.
2039 : 5384 : if (op1.known_isnan ())
2040 : 0 : r.set_undefined ();
2041 : 5384 : else if (op1.undefined_p ())
2042 : : return false;
2043 : 5384 : else if (build_gt (r, type, op1))
2044 : 5384 : r.clear_nan ();
2045 : : break;
2046 : :
2047 : : default:
2048 : : break;
2049 : : }
2050 : : return true;
2051 : : }
2052 : :
2053 : : class foperator_unordered_equal : public range_operator
2054 : : {
2055 : : using range_operator::fold_range;
2056 : : using range_operator::op1_range;
2057 : : using range_operator::op2_range;
2058 : : public:
2059 : 3621 : bool fold_range (irange &r, tree type,
2060 : : const frange &op1, const frange &op2,
2061 : : relation_trio trio = TRIO_VARYING) const final override
2062 : : {
2063 : 3621 : if (op1.known_isnan () || op2.known_isnan ())
2064 : : {
2065 : 0 : r = range_true (type);
2066 : 0 : return true;
2067 : : }
2068 : 3621 : frange op1_no_nan = op1;
2069 : 3621 : frange op2_no_nan = op2;
2070 : 3941 : if (op1.maybe_isnan ())
2071 : 3301 : op1_no_nan.clear_nan ();
2072 : 4042 : if (op2.maybe_isnan ())
2073 : 3200 : op2_no_nan.clear_nan ();
2074 : 3621 : if (!range_op_handler (EQ_EXPR).fold_range (r, type, op1_no_nan,
2075 : : op2_no_nan, trio))
2076 : : return false;
2077 : : // The result is the same as the ordered version when the
2078 : : // comparison is true or when the operands cannot be NANs.
2079 : 3621 : if (!maybe_isnan (op1, op2) || r == range_true (type))
2080 : : return true;
2081 : : else
2082 : : {
2083 : 3300 : r = range_true_and_false (type);
2084 : 3300 : return true;
2085 : : }
2086 : 3621 : }
2087 : : bool op1_range (frange &r, tree type,
2088 : : const irange &lhs, const frange &op2,
2089 : : relation_trio = TRIO_VARYING) const final override;
2090 : 622 : bool op2_range (frange &r, tree type,
2091 : : const irange &lhs, const frange &op1,
2092 : : relation_trio rel = TRIO_VARYING) const final override
2093 : : {
2094 : 622 : return op1_range (r, type, lhs, op1, rel.swap_op1_op2 ());
2095 : : }
2096 : : } fop_unordered_equal;
2097 : :
2098 : : bool
2099 : 1247 : foperator_unordered_equal::op1_range (frange &r, tree type,
2100 : : const irange &lhs,
2101 : : const frange &op2,
2102 : : relation_trio) const
2103 : : {
2104 : 1247 : switch (get_bool_state (r, lhs, type))
2105 : : {
2106 : 3 : case BRS_TRUE:
2107 : : // If it's true, the result is the same as OP2 plus a NAN.
2108 : 3 : r = op2;
2109 : : // Add both zeros if there's the possibility of zero equality.
2110 : 3 : frange_add_zeros (r, type);
2111 : : // Add the possibility of a NAN.
2112 : 3 : r.update_nan ();
2113 : 3 : break;
2114 : :
2115 : 0 : case BRS_FALSE:
2116 : : // A false UNORDERED_EQ means both operands are !NAN, so it's
2117 : : // impossible for op2 to be a NAN.
2118 : 0 : if (op2.known_isnan ())
2119 : 0 : r.set_undefined ();
2120 : : else
2121 : : {
2122 : : // The false side indicates !NAN and not equal. We can at least
2123 : : // represent !NAN.
2124 : 0 : r.set_varying (type);
2125 : 0 : r.clear_nan ();
2126 : : }
2127 : : break;
2128 : :
2129 : : default:
2130 : : break;
2131 : : }
2132 : 1247 : return true;
2133 : : }
2134 : :
2135 : : class foperator_ltgt : public range_operator
2136 : : {
2137 : : using range_operator::fold_range;
2138 : : using range_operator::op1_range;
2139 : : using range_operator::op2_range;
2140 : : public:
2141 : 2107 : bool fold_range (irange &r, tree type,
2142 : : const frange &op1, const frange &op2,
2143 : : relation_trio trio = TRIO_VARYING) const final override
2144 : : {
2145 : 2107 : if (op1.known_isnan () || op2.known_isnan ())
2146 : : {
2147 : 0 : r = range_false (type);
2148 : 0 : return true;
2149 : : }
2150 : 2107 : frange op1_no_nan = op1;
2151 : 2107 : frange op2_no_nan = op2;
2152 : 2427 : if (op1.maybe_isnan ())
2153 : 1771 : op1_no_nan.clear_nan ();
2154 : 2427 : if (op2.maybe_isnan ())
2155 : 1771 : op2_no_nan.clear_nan ();
2156 : 2107 : if (!range_op_handler (NE_EXPR).fold_range (r, type, op1_no_nan,
2157 : : op2_no_nan, trio))
2158 : : return false;
2159 : : // The result is the same as the ordered version when the
2160 : : // comparison is true or when the operands cannot be NANs.
2161 : 2107 : if (!maybe_isnan (op1, op2) || r == range_false (type))
2162 : : return true;
2163 : : else
2164 : : {
2165 : 1771 : r = range_true_and_false (type);
2166 : 1771 : return true;
2167 : : }
2168 : 2107 : }
2169 : : bool op1_range (frange &r, tree type,
2170 : : const irange &lhs, const frange &op2,
2171 : : relation_trio = TRIO_VARYING) const final override;
2172 : 788 : bool op2_range (frange &r, tree type,
2173 : : const irange &lhs, const frange &op1,
2174 : : relation_trio rel = TRIO_VARYING) const final override
2175 : : {
2176 : 788 : return op1_range (r, type, lhs, op1, rel.swap_op1_op2 ());
2177 : : }
2178 : : } fop_ltgt;
2179 : :
2180 : : bool
2181 : 1566 : foperator_ltgt::op1_range (frange &r, tree type,
2182 : : const irange &lhs,
2183 : : const frange &op2,
2184 : : relation_trio) const
2185 : : {
2186 : 1566 : switch (get_bool_state (r, lhs, type))
2187 : : {
2188 : 0 : case BRS_TRUE:
2189 : : // A true LTGT means both operands are !NAN, so it's
2190 : : // impossible for op2 to be a NAN.
2191 : 0 : if (op2.known_isnan ())
2192 : 0 : r.set_undefined ();
2193 : : else
2194 : : {
2195 : : // The true side indicates !NAN and not equal. We can at least
2196 : : // represent !NAN.
2197 : 0 : r.set_varying (type);
2198 : 0 : r.clear_nan ();
2199 : : }
2200 : : break;
2201 : :
2202 : 10 : case BRS_FALSE:
2203 : : // If it's false, the result is the same as OP2 plus a NAN.
2204 : 10 : r = op2;
2205 : : // Add both zeros if there's the possibility of zero equality.
2206 : 10 : frange_add_zeros (r, type);
2207 : : // Add the possibility of a NAN.
2208 : 10 : r.update_nan ();
2209 : 10 : break;
2210 : :
2211 : : default:
2212 : : break;
2213 : : }
2214 : 1566 : return true;
2215 : : }
2216 : :
2217 : : // Final tweaks for float binary op op1_range/op2_range.
2218 : : // Return TRUE if the operation is performed and a valid range is available.
2219 : :
2220 : : static bool
2221 : 913289 : float_binary_op_range_finish (bool ret, frange &r, tree type,
2222 : : const frange &lhs, bool div_op2 = false)
2223 : : {
2224 : 913289 : if (!ret)
2225 : : return false;
2226 : :
2227 : : // If we get a known NAN from reverse op, it means either that
2228 : : // the other operand was known NAN (in that case we know nothing),
2229 : : // or the reverse operation introduced a known NAN.
2230 : : // Say for lhs = op1 * op2 if lhs is [-0, +0] and op2 is too,
2231 : : // 0 / 0 is known NAN. Just punt in that case.
2232 : : // If NANs aren't honored, we get for 0 / 0 UNDEFINED, so punt as well.
2233 : : // Or if lhs is a known NAN, we also don't know anything.
2234 : 913289 : if (r.known_isnan () || lhs.known_isnan () || r.undefined_p ())
2235 : : {
2236 : 6971 : r.set_varying (type);
2237 : 6971 : return true;
2238 : : }
2239 : :
2240 : : // If lhs isn't NAN, then neither operand could be NAN,
2241 : : // even if the reverse operation does introduce a maybe_nan.
2242 : 1647797 : if (!lhs.maybe_isnan ())
2243 : : {
2244 : 741479 : r.clear_nan ();
2245 : 741479 : if (div_op2
2246 : 765451 : ? !(real_compare (LE_EXPR, &lhs.lower_bound (), &dconst0)
2247 : 23972 : && real_compare (GE_EXPR, &lhs.upper_bound (), &dconst0))
2248 : 1296754 : : !(real_isinf (&lhs.lower_bound ())
2249 : 586690 : || real_isinf (&lhs.upper_bound ())))
2250 : : // For reverse + or - or * or op1 of /, if result is finite, then
2251 : : // r must be finite too, as X + INF or X - INF or X * INF or
2252 : : // INF / X is always +-INF or NAN. For op2 of /, if result is
2253 : : // non-zero and not NAN, r must be finite, as X / INF is always
2254 : : // 0 or NAN.
2255 : 565646 : frange_drop_infs (r, type);
2256 : : }
2257 : : // If lhs is a maybe or known NAN, the operand could be
2258 : : // NAN.
2259 : : else
2260 : 164839 : r.update_nan ();
2261 : : return true;
2262 : : }
2263 : :
2264 : : // True if [lb, ub] is [+-0, +-0].
2265 : : static bool
2266 : 5087639 : zero_p (const REAL_VALUE_TYPE &lb, const REAL_VALUE_TYPE &ub)
2267 : : {
2268 : 5087639 : return real_iszero (&lb) && real_iszero (&ub);
2269 : : }
2270 : :
2271 : : // True if +0 or -0 is in [lb, ub] range.
2272 : : static bool
2273 : 4210543 : contains_zero_p (const REAL_VALUE_TYPE &lb, const REAL_VALUE_TYPE &ub)
2274 : : {
2275 : 4210543 : return (real_compare (LE_EXPR, &lb, &dconst0)
2276 : 4210543 : && real_compare (GE_EXPR, &ub, &dconst0));
2277 : : }
2278 : :
2279 : : // True if [lb, ub] is [-INF, -INF] or [+INF, +INF].
2280 : : static bool
2281 : 2892940 : singleton_inf_p (const REAL_VALUE_TYPE &lb, const REAL_VALUE_TYPE &ub)
2282 : : {
2283 : 2892940 : return real_isinf (&lb) && real_isinf (&ub, real_isneg (&lb));
2284 : : }
2285 : :
2286 : : // Return -1 if binary op result must have sign bit set,
2287 : : // 1 if binary op result must have sign bit clear,
2288 : : // 0 otherwise.
2289 : : // Sign bit of binary op result is exclusive or of the
2290 : : // operand's sign bits.
2291 : : static int
2292 : 1279882 : signbit_known_p (const REAL_VALUE_TYPE &lh_lb, const REAL_VALUE_TYPE &lh_ub,
2293 : : const REAL_VALUE_TYPE &rh_lb, const REAL_VALUE_TYPE &rh_ub)
2294 : : {
2295 : 1279882 : if (real_isneg (&lh_lb) == real_isneg (&lh_ub)
2296 : 1279882 : && real_isneg (&rh_lb) == real_isneg (&rh_ub))
2297 : : {
2298 : 109463 : if (real_isneg (&lh_lb) == real_isneg (&rh_ub))
2299 : : return 1;
2300 : : else
2301 : 6516 : return -1;
2302 : : }
2303 : : return 0;
2304 : : }
2305 : :
2306 : : // Set [lb, ub] to [-0, -0], [-0, +0] or [+0, +0] depending on
2307 : : // signbit_known.
2308 : : static void
2309 : 6099 : zero_range (REAL_VALUE_TYPE &lb, REAL_VALUE_TYPE &ub, int signbit_known)
2310 : : {
2311 : 6099 : ub = lb = dconst0;
2312 : 6099 : if (signbit_known <= 0)
2313 : 6025 : lb = dconstm0;
2314 : 6025 : if (signbit_known < 0)
2315 : 42 : ub = lb;
2316 : 6099 : }
2317 : :
2318 : : // Set [lb, ub] to [-INF, -INF], [-INF, +INF] or [+INF, +INF] depending on
2319 : : // signbit_known.
2320 : : static void
2321 : 4037 : inf_range (REAL_VALUE_TYPE &lb, REAL_VALUE_TYPE &ub, int signbit_known)
2322 : : {
2323 : 4037 : if (signbit_known > 0)
2324 : 887 : ub = lb = dconstinf;
2325 : 3150 : else if (signbit_known < 0)
2326 : 96 : ub = lb = dconstninf;
2327 : : else
2328 : : {
2329 : 3054 : lb = dconstninf;
2330 : 3054 : ub = dconstinf;
2331 : : }
2332 : 4037 : }
2333 : :
2334 : : // Set [lb, ub] to [-INF, -0], [-INF, +INF] or [+0, +INF] depending on
2335 : : // signbit_known.
2336 : : static void
2337 : 898892 : zero_to_inf_range (REAL_VALUE_TYPE &lb, REAL_VALUE_TYPE &ub, int signbit_known)
2338 : : {
2339 : 898892 : if (signbit_known > 0)
2340 : : {
2341 : 10106 : lb = dconst0;
2342 : 10106 : ub = dconstinf;
2343 : : }
2344 : 888786 : else if (signbit_known < 0)
2345 : : {
2346 : 222 : lb = dconstninf;
2347 : 222 : ub = dconstm0;
2348 : : }
2349 : : else
2350 : : {
2351 : 888564 : lb = dconstninf;
2352 : 888564 : ub = dconstinf;
2353 : : }
2354 : 898892 : }
2355 : :
2356 : : /* Extend the LHS range by 1ulp in each direction. For op1_range
2357 : : or op2_range of binary operations just computing the inverse
2358 : : operation on ranges isn't sufficient. Consider e.g.
2359 : : [1., 1.] = op1 + [1., 1.]. op1's range is not [0., 0.], but
2360 : : [-0x1.0p-54, 0x1.0p-53] (when not -frounding-math), any value for
2361 : : which adding 1. to it results in 1. after rounding to nearest.
2362 : : So, for op1_range/op2_range extend the lhs range by 1ulp (or 0.5ulp)
2363 : : in each direction. See PR109008 for more details. */
2364 : :
2365 : : static frange
2366 : 886933 : float_widen_lhs_range (tree type, const frange &lhs)
2367 : : {
2368 : 886933 : frange ret = lhs;
2369 : 886933 : if (lhs.known_isnan ())
2370 : : return ret;
2371 : 879963 : REAL_VALUE_TYPE lb = lhs.lower_bound ();
2372 : 879963 : REAL_VALUE_TYPE ub = lhs.upper_bound ();
2373 : 879963 : if (real_isfinite (&lb))
2374 : : {
2375 : 696404 : frange_nextafter (TYPE_MODE (type), lb, dconstninf);
2376 : 696404 : if (real_isinf (&lb))
2377 : : {
2378 : : /* For -DBL_MAX, instead of -Inf use
2379 : : nexttoward (-DBL_MAX, -LDBL_MAX) in a hypothetical
2380 : : wider type with the same mantissa precision but larger
2381 : : exponent range; it is outside of range of double values,
2382 : : but makes it clear it is just one ulp larger rather than
2383 : : infinite amount larger. */
2384 : 54215 : lb = dconstm1;
2385 : 216860 : SET_REAL_EXP (&lb, FLOAT_MODE_FORMAT (TYPE_MODE (type))->emax + 1);
2386 : : }
2387 : 4874828 : if (!flag_rounding_math && !MODE_COMPOSITE_P (TYPE_MODE (type)))
2388 : : {
2389 : : /* If not -frounding-math nor IBM double double, actually widen
2390 : : just by 0.5ulp rather than 1ulp. */
2391 : 696404 : REAL_VALUE_TYPE tem;
2392 : 696404 : real_arithmetic (&tem, PLUS_EXPR, &lhs.lower_bound (), &lb);
2393 : 696404 : real_arithmetic (&lb, RDIV_EXPR, &tem, &dconst2);
2394 : : }
2395 : : }
2396 : 879963 : if (real_isfinite (&ub))
2397 : : {
2398 : 626458 : frange_nextafter (TYPE_MODE (type), ub, dconstinf);
2399 : 626458 : if (real_isinf (&ub))
2400 : : {
2401 : : /* For DBL_MAX similarly. */
2402 : 53944 : ub = dconst1;
2403 : 215776 : SET_REAL_EXP (&ub, FLOAT_MODE_FORMAT (TYPE_MODE (type))->emax + 1);
2404 : : }
2405 : 4385206 : if (!flag_rounding_math && !MODE_COMPOSITE_P (TYPE_MODE (type)))
2406 : : {
2407 : : /* If not -frounding-math nor IBM double double, actually widen
2408 : : just by 0.5ulp rather than 1ulp. */
2409 : 626458 : REAL_VALUE_TYPE tem;
2410 : 626458 : real_arithmetic (&tem, PLUS_EXPR, &lhs.upper_bound (), &ub);
2411 : 626458 : real_arithmetic (&ub, RDIV_EXPR, &tem, &dconst2);
2412 : : }
2413 : : }
2414 : : /* Temporarily disable -ffinite-math-only, so that frange::set doesn't
2415 : : reduce the range back to real_min_representable (type) as lower bound
2416 : : or real_max_representable (type) as upper bound. */
2417 : 879963 : bool save_flag_finite_math_only = flag_finite_math_only;
2418 : 879963 : flag_finite_math_only = false;
2419 : 879963 : ret.set (type, lb, ub, lhs.get_nan_state ());
2420 : 879963 : flag_finite_math_only = save_flag_finite_math_only;
2421 : 879963 : return ret;
2422 : : }
2423 : :
2424 : : bool
2425 : 167153 : operator_plus::op1_range (frange &r, tree type, const frange &lhs,
2426 : : const frange &op2, relation_trio) const
2427 : : {
2428 : 167153 : if (lhs.undefined_p ())
2429 : : return false;
2430 : 167153 : range_op_handler minus (MINUS_EXPR);
2431 : 167153 : if (!minus)
2432 : : return false;
2433 : 167153 : frange wlhs = float_widen_lhs_range (type, lhs);
2434 : 167153 : return float_binary_op_range_finish (minus.fold_range (r, type, wlhs, op2),
2435 : : r, type, wlhs);
2436 : 167153 : }
2437 : :
2438 : : bool
2439 : 73693 : operator_plus::op2_range (frange &r, tree type,
2440 : : const frange &lhs, const frange &op1,
2441 : : relation_trio) const
2442 : : {
2443 : 73693 : return op1_range (r, type, lhs, op1);
2444 : : }
2445 : :
2446 : : void
2447 : 2450100 : operator_plus::rv_fold (frange &r, tree type,
2448 : : const REAL_VALUE_TYPE &lh_lb,
2449 : : const REAL_VALUE_TYPE &lh_ub,
2450 : : const REAL_VALUE_TYPE &rh_lb,
2451 : : const REAL_VALUE_TYPE &rh_ub,
2452 : : relation_kind) const
2453 : : {
2454 : 2450100 : REAL_VALUE_TYPE lb, ub;
2455 : 2450100 : bool maybe_nan = false;
2456 : :
2457 : 2450100 : frange_arithmetic (PLUS_EXPR, type, lb, lh_lb, rh_lb, dconstninf);
2458 : 2450100 : frange_arithmetic (PLUS_EXPR, type, ub, lh_ub, rh_ub, dconstinf);
2459 : :
2460 : : // [-INF] + [+INF] = NAN
2461 : 2450100 : if (real_isinf (&lh_lb, true) && real_isinf (&rh_ub, false))
2462 : : maybe_nan = true;
2463 : : // [+INF] + [-INF] = NAN
2464 : 792412 : else if (real_isinf (&lh_ub, false) && real_isinf (&rh_lb, true))
2465 : : maybe_nan = true;
2466 : :
2467 : : // Handle possible NANs by saturating to the appropriate INF if only
2468 : : // one end is a NAN. If both ends are a NAN, just return a NAN.
2469 : 2450100 : bool lb_nan = real_isnan (&lb);
2470 : 2450100 : bool ub_nan = real_isnan (&ub);
2471 : 2450100 : if (lb_nan && ub_nan)
2472 : : {
2473 : 0 : r.set_nan (type);
2474 : 0 : return;
2475 : : }
2476 : 2450100 : if (lb_nan)
2477 : 306 : lb = dconstninf;
2478 : 2449794 : else if (ub_nan)
2479 : 0 : ub = dconstinf;
2480 : 2450100 : r.set (type, lb, ub, nan_state (maybe_nan));
2481 : : }
2482 : :
2483 : :
2484 : : bool
2485 : 92263 : operator_minus::op1_range (frange &r, tree type,
2486 : : const frange &lhs, const frange &op2,
2487 : : relation_trio) const
2488 : : {
2489 : 92263 : if (lhs.undefined_p ())
2490 : : return false;
2491 : 92263 : frange wlhs = float_widen_lhs_range (type, lhs);
2492 : 92263 : return float_binary_op_range_finish (
2493 : 184526 : range_op_handler (PLUS_EXPR).fold_range (r, type, wlhs, op2),
2494 : : r, type, wlhs);
2495 : 92263 : }
2496 : :
2497 : : bool
2498 : 177372 : operator_minus::op2_range (frange &r, tree type,
2499 : : const frange &lhs, const frange &op1,
2500 : : relation_trio) const
2501 : : {
2502 : 177372 : if (lhs.undefined_p ())
2503 : : return false;
2504 : 177372 : frange wlhs = float_widen_lhs_range (type, lhs);
2505 : 177372 : return float_binary_op_range_finish (fold_range (r, type, op1, wlhs),
2506 : : r, type, wlhs);
2507 : 177372 : }
2508 : :
2509 : : void
2510 : 974801 : operator_minus::rv_fold (frange &r, tree type,
2511 : : const REAL_VALUE_TYPE &lh_lb,
2512 : : const REAL_VALUE_TYPE &lh_ub,
2513 : : const REAL_VALUE_TYPE &rh_lb,
2514 : : const REAL_VALUE_TYPE &rh_ub,
2515 : : relation_kind) const
2516 : : {
2517 : 974801 : REAL_VALUE_TYPE lb, ub;
2518 : 974801 : bool maybe_nan = false;
2519 : :
2520 : 974801 : frange_arithmetic (MINUS_EXPR, type, lb, lh_lb, rh_ub, dconstninf);
2521 : 974801 : frange_arithmetic (MINUS_EXPR, type, ub, lh_ub, rh_lb, dconstinf);
2522 : :
2523 : : // [+INF] - [+INF] = NAN
2524 : 974801 : if (real_isinf (&lh_ub, false) && real_isinf (&rh_ub, false))
2525 : : maybe_nan = true;
2526 : : // [-INF] - [-INF] = NAN
2527 : 689370 : else if (real_isinf (&lh_lb, true) && real_isinf (&rh_lb, true))
2528 : : maybe_nan = true;
2529 : :
2530 : : // Handle possible NANs by saturating to the appropriate INF if only
2531 : : // one end is a NAN. If both ends are a NAN, just return a NAN.
2532 : 974801 : bool lb_nan = real_isnan (&lb);
2533 : 974801 : bool ub_nan = real_isnan (&ub);
2534 : 974801 : if (lb_nan && ub_nan)
2535 : : {
2536 : 0 : r.set_nan (type);
2537 : 0 : return;
2538 : : }
2539 : 974801 : if (lb_nan)
2540 : 182 : lb = dconstninf;
2541 : 974619 : else if (ub_nan)
2542 : 259 : ub = dconstinf;
2543 : 974801 : r.set (type, lb, ub, nan_state (maybe_nan));
2544 : : }
2545 : :
2546 : :
2547 : : // Given CP[0] to CP[3] floating point values rounded to -INF,
2548 : : // set LB to the smallest of them (treating -0 as smaller to +0).
2549 : : // Given CP[4] to CP[7] floating point values rounded to +INF,
2550 : : // set UB to the largest of them (treating -0 as smaller to +0).
2551 : :
2552 : : static void
2553 : 1093893 : find_range (REAL_VALUE_TYPE &lb, REAL_VALUE_TYPE &ub,
2554 : : const REAL_VALUE_TYPE (&cp)[8])
2555 : : {
2556 : 1093893 : lb = cp[0];
2557 : 1093893 : ub = cp[4];
2558 : 4375572 : for (int i = 1; i < 4; ++i)
2559 : : {
2560 : 3281679 : if (real_less (&cp[i], &lb)
2561 : 3281679 : || (real_iszero (&lb) && real_isnegzero (&cp[i])))
2562 : 326114 : lb = cp[i];
2563 : 3281679 : if (real_less (&ub, &cp[i + 4])
2564 : 3281679 : || (real_isnegzero (&ub) && real_iszero (&cp[i + 4])))
2565 : 1077350 : ub = cp[i + 4];
2566 : : }
2567 : 1093893 : }
2568 : :
2569 : :
2570 : : bool
2571 : 349990 : operator_mult::op1_range (frange &r, tree type,
2572 : : const frange &lhs, const frange &op2,
2573 : : relation_trio) const
2574 : : {
2575 : 349990 : if (lhs.undefined_p ())
2576 : : return false;
2577 : 349990 : range_op_handler rdiv (RDIV_EXPR);
2578 : 349990 : if (!rdiv)
2579 : : return false;
2580 : 349990 : frange wlhs = float_widen_lhs_range (type, lhs);
2581 : 349990 : bool ret = rdiv.fold_range (r, type, wlhs, op2);
2582 : 349990 : if (ret == false)
2583 : : return false;
2584 : 349990 : if (wlhs.known_isnan () || op2.known_isnan () || op2.undefined_p ())
2585 : 16 : return float_binary_op_range_finish (ret, r, type, wlhs);
2586 : 349974 : const REAL_VALUE_TYPE &lhs_lb = wlhs.lower_bound ();
2587 : 349974 : const REAL_VALUE_TYPE &lhs_ub = wlhs.upper_bound ();
2588 : 349974 : const REAL_VALUE_TYPE &op2_lb = op2.lower_bound ();
2589 : 349974 : const REAL_VALUE_TYPE &op2_ub = op2.upper_bound ();
2590 : 655140 : if ((contains_zero_p (lhs_lb, lhs_ub) && contains_zero_p (op2_lb, op2_ub))
2591 : 533068 : || ((real_isinf (&lhs_lb) || real_isinf (&lhs_ub))
2592 : 40411 : && (real_isinf (&op2_lb) || real_isinf (&op2_ub))))
2593 : : {
2594 : : // If both lhs and op2 could be zeros or both could be infinities,
2595 : : // we don't know anything about op1 except maybe for the sign
2596 : : // and perhaps if it can be NAN or not.
2597 : 129316 : REAL_VALUE_TYPE lb, ub;
2598 : 129316 : int signbit_known = signbit_known_p (lhs_lb, lhs_ub, op2_lb, op2_ub);
2599 : 129316 : zero_to_inf_range (lb, ub, signbit_known);
2600 : 129316 : r.set (type, lb, ub);
2601 : : }
2602 : : // Otherwise, if op2 is a singleton INF and lhs doesn't include INF,
2603 : : // or if lhs must be zero and op2 doesn't include zero, it would be
2604 : : // UNDEFINED, while rdiv.fold_range computes a zero or singleton INF
2605 : : // range. Those are supersets of UNDEFINED, so let's keep that way.
2606 : 349974 : return float_binary_op_range_finish (ret, r, type, wlhs);
2607 : 349990 : }
2608 : :
2609 : : bool
2610 : 71592 : operator_mult::op2_range (frange &r, tree type,
2611 : : const frange &lhs, const frange &op1,
2612 : : relation_trio) const
2613 : : {
2614 : 71592 : return op1_range (r, type, lhs, op1);
2615 : : }
2616 : :
2617 : : void
2618 : 1138868 : operator_mult::rv_fold (frange &r, tree type,
2619 : : const REAL_VALUE_TYPE &lh_lb,
2620 : : const REAL_VALUE_TYPE &lh_ub,
2621 : : const REAL_VALUE_TYPE &rh_lb,
2622 : : const REAL_VALUE_TYPE &rh_ub,
2623 : : relation_kind kind) const
2624 : : {
2625 : 1138868 : bool is_square
2626 : : = (kind == VREL_EQ
2627 : 37315 : && real_equal (&lh_lb, &rh_lb)
2628 : 37315 : && real_equal (&lh_ub, &rh_ub)
2629 : 37315 : && real_isneg (&lh_lb) == real_isneg (&rh_lb)
2630 : 1176183 : && real_isneg (&lh_ub) == real_isneg (&rh_ub));
2631 : 1101553 : REAL_VALUE_TYPE lb, ub;
2632 : 1824592 : bool maybe_nan = false;
2633 : : // x * x never produces a new NAN and we only multiply the same
2634 : : // values, so the 0 * INF problematic cases never appear there.
2635 : 1101553 : if (!is_square)
2636 : : {
2637 : : // [+-0, +-0] * [+INF,+INF] (or [-INF,-INF] or swapped is a known NAN.
2638 : 1106842 : if ((zero_p (lh_lb, lh_ub) && singleton_inf_p (rh_lb, rh_ub))
2639 : 1106830 : || (zero_p (rh_lb, rh_ub) && singleton_inf_p (lh_lb, lh_ub)))
2640 : : {
2641 : 43 : r.set_nan (type);
2642 : 415829 : return;
2643 : : }
2644 : :
2645 : : // Otherwise, if one range includes zero and the other ends with +-INF,
2646 : : // it is a maybe NAN.
2647 : 1101510 : if ((contains_zero_p (lh_lb, lh_ub)
2648 : 1003157 : && (real_isinf (&rh_lb) || real_isinf (&rh_ub)))
2649 : 1715310 : || (contains_zero_p (rh_lb, rh_ub)
2650 : 178416 : && (real_isinf (&lh_lb) || real_isinf (&lh_ub))))
2651 : : {
2652 : 415786 : maybe_nan = true;
2653 : :
2654 : 415786 : int signbit_known = signbit_known_p (lh_lb, lh_ub, rh_lb, rh_ub);
2655 : :
2656 : : // If one of the ranges that includes INF is singleton
2657 : : // and the other range includes zero, the resulting
2658 : : // range is INF and NAN, because the 0 * INF boundary
2659 : : // case will be NAN, but already nextafter (0, 1) * INF
2660 : : // is INF.
2661 : 415786 : if (singleton_inf_p (lh_lb, lh_ub)
2662 : 415786 : || singleton_inf_p (rh_lb, rh_ub))
2663 : : {
2664 : 937 : inf_range (lb, ub, signbit_known);
2665 : 937 : r.set (type, lb, ub, nan_state (true));
2666 : 937 : return;
2667 : : }
2668 : :
2669 : : // If one of the multiplicands must be zero, the resulting
2670 : : // range is +-0 and NAN.
2671 : 414849 : if (zero_p (lh_lb, lh_ub) || zero_p (rh_lb, rh_ub))
2672 : : {
2673 : 5570 : zero_range (lb, ub, signbit_known);
2674 : 5570 : r.set (type, lb, ub, nan_state (true));
2675 : 5570 : return;
2676 : : }
2677 : :
2678 : : // Otherwise one of the multiplicands could be
2679 : : // [0.0, nextafter (0.0, 1.0)] and the [DBL_MAX, INF]
2680 : : // or similarly with different signs. 0.0 * DBL_MAX
2681 : : // is still 0.0, nextafter (0.0, 1.0) * INF is still INF,
2682 : : // so if the signs are always the same or always different,
2683 : : // result is [+0.0, +INF] or [-INF, -0.0], otherwise VARYING.
2684 : 409279 : zero_to_inf_range (lb, ub, signbit_known);
2685 : 409279 : r.set (type, lb, ub, nan_state (true));
2686 : 409279 : return;
2687 : : }
2688 : : }
2689 : :
2690 : 723039 : REAL_VALUE_TYPE cp[8];
2691 : : // Do a cross-product. At this point none of the multiplications
2692 : : // should produce a NAN.
2693 : 723039 : frange_arithmetic (MULT_EXPR, type, cp[0], lh_lb, rh_lb, dconstninf);
2694 : 723039 : frange_arithmetic (MULT_EXPR, type, cp[4], lh_lb, rh_lb, dconstinf);
2695 : 723039 : if (is_square)
2696 : : {
2697 : : // For x * x we can just do max (lh_lb * lh_lb, lh_ub * lh_ub)
2698 : : // as maximum and -0.0 as minimum if 0.0 is in the range,
2699 : : // otherwise min (lh_lb * lh_lb, lh_ub * lh_ub).
2700 : : // -0.0 rather than 0.0 because VREL_EQ doesn't prove that
2701 : : // x and y are bitwise equal, just that they compare equal.
2702 : 37315 : if (contains_zero_p (lh_lb, lh_ub))
2703 : : {
2704 : 34291 : if (real_isneg (&lh_lb) == real_isneg (&lh_ub))
2705 : 1134 : cp[1] = dconst0;
2706 : : else
2707 : 33157 : cp[1] = dconstm0;
2708 : : }
2709 : : else
2710 : 3024 : cp[1] = cp[0];
2711 : 37315 : cp[2] = cp[0];
2712 : 37315 : cp[5] = cp[4];
2713 : 37315 : cp[6] = cp[4];
2714 : : }
2715 : : else
2716 : : {
2717 : 685724 : frange_arithmetic (MULT_EXPR, type, cp[1], lh_lb, rh_ub, dconstninf);
2718 : 685724 : frange_arithmetic (MULT_EXPR, type, cp[5], lh_lb, rh_ub, dconstinf);
2719 : 685724 : frange_arithmetic (MULT_EXPR, type, cp[2], lh_ub, rh_lb, dconstninf);
2720 : 685724 : frange_arithmetic (MULT_EXPR, type, cp[6], lh_ub, rh_lb, dconstinf);
2721 : : }
2722 : 723039 : frange_arithmetic (MULT_EXPR, type, cp[3], lh_ub, rh_ub, dconstninf);
2723 : 723039 : frange_arithmetic (MULT_EXPR, type, cp[7], lh_ub, rh_ub, dconstinf);
2724 : :
2725 : 723039 : find_range (lb, ub, cp);
2726 : :
2727 : 723039 : gcc_checking_assert (!real_isnan (&lb));
2728 : 723039 : gcc_checking_assert (!real_isnan (&ub));
2729 : 723039 : r.set (type, lb, ub, nan_state (maybe_nan));
2730 : : }
2731 : :
2732 : :
2733 : : class foperator_div : public range_operator
2734 : : {
2735 : : using range_operator::op1_range;
2736 : : using range_operator::op2_range;
2737 : : public:
2738 : 25850 : virtual bool op1_range (frange &r, tree type,
2739 : : const frange &lhs,
2740 : : const frange &op2,
2741 : : relation_trio = TRIO_VARYING) const final override
2742 : : {
2743 : 25850 : if (lhs.undefined_p ())
2744 : : return false;
2745 : 25850 : frange wlhs = float_widen_lhs_range (type, lhs);
2746 : 25850 : bool ret = range_op_handler (MULT_EXPR).fold_range (r, type, wlhs, op2);
2747 : 25850 : if (!ret)
2748 : : return ret;
2749 : 25850 : if (wlhs.known_isnan () || op2.known_isnan () || op2.undefined_p ())
2750 : 5 : return float_binary_op_range_finish (ret, r, type, wlhs);
2751 : 25845 : const REAL_VALUE_TYPE &lhs_lb = wlhs.lower_bound ();
2752 : 25845 : const REAL_VALUE_TYPE &lhs_ub = wlhs.upper_bound ();
2753 : 25845 : const REAL_VALUE_TYPE &op2_lb = op2.lower_bound ();
2754 : 25845 : const REAL_VALUE_TYPE &op2_ub = op2.upper_bound ();
2755 : 25845 : if ((contains_zero_p (lhs_lb, lhs_ub)
2756 : 17807 : && (real_isinf (&op2_lb) || real_isinf (&op2_ub)))
2757 : 32923 : || ((contains_zero_p (op2_lb, op2_ub))
2758 : 8020 : && (real_isinf (&lhs_lb) || real_isinf (&lhs_ub))))
2759 : : {
2760 : : // If both lhs could be zero and op2 infinity or vice versa,
2761 : : // we don't know anything about op1 except maybe for the sign
2762 : : // and perhaps if it can be NAN or not.
2763 : 18318 : REAL_VALUE_TYPE lb, ub;
2764 : 18318 : int signbit_known = signbit_known_p (lhs_lb, lhs_ub, op2_lb, op2_ub);
2765 : 18318 : zero_to_inf_range (lb, ub, signbit_known);
2766 : 18318 : r.set (type, lb, ub);
2767 : : }
2768 : 25845 : return float_binary_op_range_finish (ret, r, type, wlhs);
2769 : 25850 : }
2770 : 40819 : virtual bool op2_range (frange &r, tree type,
2771 : : const frange &lhs,
2772 : : const frange &op1,
2773 : : relation_trio = TRIO_VARYING) const final override
2774 : : {
2775 : 40819 : if (lhs.undefined_p ())
2776 : : return false;
2777 : 40819 : frange wlhs = float_widen_lhs_range (type, lhs);
2778 : 40819 : bool ret = fold_range (r, type, op1, wlhs);
2779 : 40819 : if (!ret)
2780 : : return ret;
2781 : 40819 : if (wlhs.known_isnan () || op1.known_isnan () || op1.undefined_p ())
2782 : 21 : return float_binary_op_range_finish (ret, r, type, wlhs, true);
2783 : 40798 : const REAL_VALUE_TYPE &lhs_lb = wlhs.lower_bound ();
2784 : 40798 : const REAL_VALUE_TYPE &lhs_ub = wlhs.upper_bound ();
2785 : 40798 : const REAL_VALUE_TYPE &op1_lb = op1.lower_bound ();
2786 : 40798 : const REAL_VALUE_TYPE &op1_ub = op1.upper_bound ();
2787 : 71756 : if ((contains_zero_p (lhs_lb, lhs_ub) && contains_zero_p (op1_lb, op1_ub))
2788 : 44253 : || ((real_isinf (&lhs_lb) || real_isinf (&lhs_ub))
2789 : 7539 : && (real_isinf (&op1_lb) || real_isinf (&op1_ub))))
2790 : : {
2791 : : // If both lhs and op1 could be zeros or both could be infinities,
2792 : : // we don't know anything about op2 except maybe for the sign
2793 : : // and perhaps if it can be NAN or not.
2794 : 31752 : REAL_VALUE_TYPE lb, ub;
2795 : 31752 : int signbit_known = signbit_known_p (lhs_lb, lhs_ub, op1_lb, op1_ub);
2796 : 31752 : zero_to_inf_range (lb, ub, signbit_known);
2797 : 31752 : r.set (type, lb, ub);
2798 : : }
2799 : 40798 : return float_binary_op_range_finish (ret, r, type, wlhs, true);
2800 : 40819 : }
2801 : : private:
2802 : 685295 : void rv_fold (frange &r, tree type,
2803 : : const REAL_VALUE_TYPE &lh_lb,
2804 : : const REAL_VALUE_TYPE &lh_ub,
2805 : : const REAL_VALUE_TYPE &rh_lb,
2806 : : const REAL_VALUE_TYPE &rh_ub,
2807 : : relation_kind) const final override
2808 : : {
2809 : : // +-0.0 / +-0.0 or +-INF / +-INF is a known NAN.
2810 : 686401 : if ((zero_p (lh_lb, lh_ub) && zero_p (rh_lb, rh_ub))
2811 : 685822 : || (singleton_inf_p (lh_lb, lh_ub) && singleton_inf_p (rh_lb, rh_ub)))
2812 : : {
2813 : 585 : r.set_nan (type);
2814 : 314441 : return;
2815 : : }
2816 : :
2817 : 684710 : REAL_VALUE_TYPE lb, ub;
2818 : 684710 : bool maybe_nan = false;
2819 : : // If +-0.0 is in both ranges, it is a maybe NAN.
2820 : 684710 : if (contains_zero_p (lh_lb, lh_ub) && contains_zero_p (rh_lb, rh_ub))
2821 : : maybe_nan = true;
2822 : : // If +-INF is in both ranges, it is a maybe NAN.
2823 : 717590 : else if ((real_isinf (&lh_lb) || real_isinf (&lh_ub))
2824 : 416224 : && (real_isinf (&rh_lb) || real_isinf (&rh_ub)))
2825 : : maybe_nan = true;
2826 : :
2827 : 684710 : int signbit_known = signbit_known_p (lh_lb, lh_ub, rh_lb, rh_ub);
2828 : :
2829 : : // If dividend must be zero, the range is just +-0
2830 : : // (including if the divisor is +-INF).
2831 : : // If divisor must be +-INF, the range is just +-0
2832 : : // (including if the dividend is zero).
2833 : 684710 : if (zero_p (lh_lb, lh_ub) || singleton_inf_p (rh_lb, rh_ub))
2834 : : {
2835 : 529 : zero_range (lb, ub, signbit_known);
2836 : 529 : r.set (type, lb, ub, nan_state (maybe_nan));
2837 : 529 : return;
2838 : : }
2839 : :
2840 : : // If divisor must be zero, the range is just +-INF
2841 : : // (including if the dividend is +-INF).
2842 : : // If dividend must be +-INF, the range is just +-INF
2843 : : // (including if the dividend is zero).
2844 : 684181 : if (zero_p (rh_lb, rh_ub) || singleton_inf_p (lh_lb, lh_ub))
2845 : : {
2846 : 3100 : inf_range (lb, ub, signbit_known);
2847 : 3100 : r.set (type, lb, ub, nan_state (maybe_nan));
2848 : 3100 : return;
2849 : : }
2850 : :
2851 : : // Otherwise if both operands may be zero, divisor could be
2852 : : // nextafter(0.0, +-1.0) and dividend +-0.0
2853 : : // in which case result is going to INF or vice versa and
2854 : : // result +0.0. So, all we can say for that case is if the
2855 : : // signs of divisor and dividend are always the same we have
2856 : : // [+0.0, +INF], if they are always different we have
2857 : : // [-INF, -0.0]. If they vary, VARYING.
2858 : : // If both may be +-INF, divisor could be INF and dividend FLT_MAX,
2859 : : // in which case result is going to INF or vice versa and
2860 : : // result +0.0. So, all we can say for that case is if the
2861 : : // signs of divisor and dividend are always the same we have
2862 : : // [+0.0, +INF], if they are always different we have
2863 : : // [-INF, -0.0]. If they vary, VARYING.
2864 : 681081 : if (maybe_nan)
2865 : : {
2866 : 310227 : zero_to_inf_range (lb, ub, signbit_known);
2867 : 310227 : r.set (type, lb, ub, nan_state (maybe_nan));
2868 : 310227 : return;
2869 : : }
2870 : :
2871 : 370854 : REAL_VALUE_TYPE cp[8];
2872 : : // Do a cross-division. At this point none of the divisions should
2873 : : // produce a NAN.
2874 : 370854 : frange_arithmetic (RDIV_EXPR, type, cp[0], lh_lb, rh_lb, dconstninf);
2875 : 370854 : frange_arithmetic (RDIV_EXPR, type, cp[1], lh_lb, rh_ub, dconstninf);
2876 : 370854 : frange_arithmetic (RDIV_EXPR, type, cp[2], lh_ub, rh_lb, dconstninf);
2877 : 370854 : frange_arithmetic (RDIV_EXPR, type, cp[3], lh_ub, rh_ub, dconstninf);
2878 : 370854 : frange_arithmetic (RDIV_EXPR, type, cp[4], lh_lb, rh_lb, dconstinf);
2879 : 370854 : frange_arithmetic (RDIV_EXPR, type, cp[5], lh_lb, rh_ub, dconstinf);
2880 : 370854 : frange_arithmetic (RDIV_EXPR, type, cp[6], lh_ub, rh_lb, dconstinf);
2881 : 370854 : frange_arithmetic (RDIV_EXPR, type, cp[7], lh_ub, rh_ub, dconstinf);
2882 : :
2883 : 370854 : find_range (lb, ub, cp);
2884 : :
2885 : : // If divisor may be zero (but is not known to be only zero),
2886 : : // and dividend can't be zero, the range can go up to -INF or +INF
2887 : : // depending on the signs.
2888 : 370854 : if (contains_zero_p (rh_lb, rh_ub))
2889 : : {
2890 : 50417 : if (signbit_known <= 0)
2891 : 48149 : real_inf (&lb, true);
2892 : 48149 : if (signbit_known >= 0)
2893 : 50381 : real_inf (&ub, false);
2894 : : }
2895 : :
2896 : 370854 : gcc_checking_assert (!real_isnan (&lb));
2897 : 370854 : gcc_checking_assert (!real_isnan (&ub));
2898 : 370854 : r.set (type, lb, ub, nan_state (maybe_nan));
2899 : : }
2900 : : } fop_div;
2901 : :
2902 : : bool
2903 : 937086 : operator_cast::fold_range (frange &r, tree type, const frange &op1,
2904 : : const frange &, relation_trio) const
2905 : : {
2906 : 937086 : REAL_VALUE_TYPE lb, ub;
2907 : 937086 : enum machine_mode mode = TYPE_MODE (type);
2908 : 6559602 : bool mode_composite = MODE_COMPOSITE_P (mode);
2909 : :
2910 : 937086 : if (empty_range_varying (r, type, op1, op1))
2911 : 816 : return true;
2912 : 3745080 : if (!MODE_HAS_NANS (mode) && op1.maybe_isnan ())
2913 : : {
2914 : 0 : r.set_varying (type);
2915 : 0 : return true;
2916 : : }
2917 : 936270 : if (op1.known_isnan ())
2918 : : {
2919 : 2927 : r.set_nan (type);
2920 : 2927 : return true;
2921 : : }
2922 : :
2923 : 933343 : const REAL_VALUE_TYPE &lh_lb = op1.lower_bound ();
2924 : 933343 : const REAL_VALUE_TYPE &lh_ub = op1.upper_bound ();
2925 : 933343 : real_convert (&lb, mode, &lh_lb);
2926 : 933343 : real_convert (&ub, mode, &lh_ub);
2927 : :
2928 : 933343 : if (flag_rounding_math)
2929 : : {
2930 : 30890 : if (real_less (&lh_lb, &lb))
2931 : : {
2932 : 2656 : if (mode_composite
2933 : 2656 : && (real_isdenormal (&lb, mode) || real_iszero (&lb)))
2934 : : {
2935 : : // IBM extended denormals only have DFmode precision.
2936 : 0 : REAL_VALUE_TYPE tmp, tmp2;
2937 : 0 : real_convert (&tmp2, DFmode, &lh_lb);
2938 : 0 : real_nextafter (&tmp, REAL_MODE_FORMAT (DFmode), &tmp2,
2939 : : &dconstninf);
2940 : 0 : real_convert (&lb, mode, &tmp);
2941 : : }
2942 : : else
2943 : 2656 : frange_nextafter (mode, lb, dconstninf);
2944 : : }
2945 : 30890 : if (real_less (&ub, &lh_ub))
2946 : : {
2947 : 1066 : if (mode_composite
2948 : 1066 : && (real_isdenormal (&ub, mode) || real_iszero (&ub)))
2949 : : {
2950 : : // IBM extended denormals only have DFmode precision.
2951 : 0 : REAL_VALUE_TYPE tmp, tmp2;
2952 : 0 : real_convert (&tmp2, DFmode, &lh_ub);
2953 : 0 : real_nextafter (&tmp, REAL_MODE_FORMAT (DFmode), &tmp2,
2954 : : &dconstinf);
2955 : 0 : real_convert (&ub, mode, &tmp);
2956 : : }
2957 : : else
2958 : 1066 : frange_nextafter (mode, ub, dconstinf);
2959 : : }
2960 : : }
2961 : :
2962 : 933343 : r.set (type, lb, ub, op1.get_nan_state ());
2963 : :
2964 : 933343 : if (flag_trapping_math
2965 : 4223234 : && MODE_HAS_INFINITIES (TYPE_MODE (type))
2966 : 822473 : && r.known_isinf ()
2967 : 933413 : && !op1.known_isinf ())
2968 : : {
2969 : 1 : REAL_VALUE_TYPE inf = r.lower_bound ();
2970 : 1 : if (real_isneg (&inf))
2971 : : {
2972 : 0 : REAL_VALUE_TYPE min = real_min_representable (type);
2973 : 0 : r.set (type, inf, min);
2974 : : }
2975 : : else
2976 : : {
2977 : 1 : REAL_VALUE_TYPE max = real_max_representable (type);
2978 : 1 : r.set (type, max, inf);
2979 : : }
2980 : : }
2981 : :
2982 : 933343 : r.flush_denormals_to_zero ();
2983 : 933343 : return true;
2984 : : }
2985 : :
2986 : : // Implement fold for a cast from float to another float.
2987 : : bool
2988 : 59842 : operator_cast::op1_range (frange &r, tree type, const frange &lhs,
2989 : : const frange &op2, relation_trio) const
2990 : : {
2991 : 59842 : if (lhs.undefined_p ())
2992 : : return false;
2993 : 59842 : tree lhs_type = lhs.type ();
2994 : 59842 : enum machine_mode mode = TYPE_MODE (type);
2995 : 59842 : enum machine_mode lhs_mode = TYPE_MODE (lhs_type);
2996 : 59842 : frange wlhs;
2997 : 59842 : bool rm;
2998 : 59842 : if (REAL_MODE_FORMAT (mode)->ieee_bits
2999 : 55496 : && REAL_MODE_FORMAT (lhs_mode)->ieee_bits
3000 : 52274 : && (REAL_MODE_FORMAT (lhs_mode)->ieee_bits
3001 : : >= REAL_MODE_FORMAT (mode)->ieee_bits)
3002 : 86198 : && pow2p_hwi (REAL_MODE_FORMAT (mode)->ieee_bits))
3003 : : {
3004 : : /* If the cast is widening from IEEE exchange mode to
3005 : : wider exchange mode or extended mode, no need to extend
3006 : : the range on reverse operation. */
3007 : 26356 : rm = false;
3008 : 26356 : wlhs = lhs;
3009 : : }
3010 : : else
3011 : : {
3012 : 33486 : rm = true;
3013 : 33486 : wlhs = float_widen_lhs_range (lhs_type, lhs);
3014 : : }
3015 : 59842 : auto save_flag_rounding_math = flag_rounding_math;
3016 : 59842 : flag_rounding_math = rm;
3017 : 59842 : bool ret = float_binary_op_range_finish (fold_range (r, type, wlhs, op2),
3018 : : r, type, lhs);
3019 : 59842 : flag_rounding_math = save_flag_rounding_math;
3020 : 59842 : return ret;
3021 : 59842 : }
3022 : :
3023 : : // Implement fold for a cast from float to an int.
3024 : : bool
3025 : 204479 : operator_cast::fold_range (irange &r, tree type, const frange &op1,
3026 : : const irange &, relation_trio) const
3027 : : {
3028 : 204479 : if (empty_range_varying (r, type, op1, op1))
3029 : 495 : return true;
3030 : 203984 : if (op1.maybe_isnan () || op1.maybe_isinf ())
3031 : : {
3032 : 177938 : r.set_varying (type);
3033 : 177938 : return true;
3034 : : }
3035 : 26046 : REAL_VALUE_TYPE lb, ub;
3036 : 26046 : real_trunc (&lb, VOIDmode, &op1.lower_bound ());
3037 : 26046 : real_trunc (&ub, VOIDmode, &op1.upper_bound ());
3038 : 26046 : REAL_VALUE_TYPE l, u;
3039 : 26046 : l = real_value_from_int_cst (NULL_TREE, TYPE_MIN_VALUE (type));
3040 : 26046 : if (real_less (&lb, &l))
3041 : : {
3042 : 9605 : r.set_varying (type);
3043 : 9605 : return true;
3044 : : }
3045 : 16441 : u = real_value_from_int_cst (NULL_TREE, TYPE_MAX_VALUE (type));
3046 : 16441 : if (real_less (&u, &ub))
3047 : : {
3048 : 7991 : r.set_varying (type);
3049 : 7991 : return true;
3050 : : }
3051 : 8450 : bool fail = false;
3052 : 8450 : wide_int wlb = real_to_integer (&lb, &fail, TYPE_PRECISION (type));
3053 : 8450 : wide_int wub = real_to_integer (&ub, &fail, TYPE_PRECISION (type));
3054 : 8450 : if (fail)
3055 : : {
3056 : 0 : r.set_varying (type);
3057 : 0 : return true;
3058 : : }
3059 : 8450 : r.set (type, wlb, wub);
3060 : 8450 : return true;
3061 : 8450 : }
3062 : :
3063 : : // Implement op1_range for a cast from float to an int.
3064 : : bool
3065 : 6766 : operator_cast::op1_range (frange &r, tree type, const irange &lhs,
3066 : : const frange &, relation_trio) const
3067 : : {
3068 : 6766 : if (lhs.undefined_p ())
3069 : : return false;
3070 : 6766 : REAL_VALUE_TYPE lb, lbo, ub, ubo;
3071 : 6766 : wide_int lhs_lb = lhs.lower_bound ();
3072 : 6766 : wide_int lhs_ub = lhs.upper_bound ();
3073 : 6766 : tree lhs_type = lhs.type ();
3074 : 6766 : enum machine_mode mode = TYPE_MODE (type);
3075 : 6766 : real_from_integer (&lbo, VOIDmode, lhs_lb, TYPE_SIGN (lhs_type));
3076 : 6766 : real_from_integer (&ubo, VOIDmode, lhs_ub, TYPE_SIGN (lhs_type));
3077 : 6766 : real_convert (&lb, mode, &lbo);
3078 : 6766 : real_convert (&ub, mode, &ubo);
3079 : 6766 : if (real_identical (&lb, &lbo))
3080 : : {
3081 : : /* If low bound is exactly representable in type,
3082 : : use nextafter (lb - 1., +inf). */
3083 : 6708 : real_arithmetic (&lb, PLUS_EXPR, &lbo, &dconstm1);
3084 : 6708 : real_convert (&lb, mode, &lb);
3085 : 6708 : if (!real_identical (&lb, &lbo))
3086 : 5586 : frange_nextafter (mode, lb, dconstinf);
3087 : 6708 : if (real_identical (&lb, &lbo))
3088 : 1122 : frange_nextafter (mode, lb, dconstninf);
3089 : : }
3090 : 58 : else if (real_less (&lbo, &lb))
3091 : 13 : frange_nextafter (mode, lb, dconstninf);
3092 : 6766 : if (real_identical (&ub, &ubo))
3093 : : {
3094 : : /* If upper bound is exactly representable in type,
3095 : : use nextafter (ub + 1., -inf). */
3096 : 5102 : real_arithmetic (&ub, PLUS_EXPR, &ubo, &dconst1);
3097 : 5102 : real_convert (&ub, mode, &ub);
3098 : 5102 : if (!real_identical (&ub, &ubo))
3099 : 5042 : frange_nextafter (mode, ub, dconstninf);
3100 : 5102 : if (real_identical (&ub, &ubo))
3101 : 60 : frange_nextafter (mode, ub, dconstinf);
3102 : : }
3103 : 1664 : else if (real_less (&ub, &ubo))
3104 : 0 : frange_nextafter (mode, ub, dconstinf);
3105 : 6766 : r.set (type, lb, ub, nan_state (false));
3106 : 6766 : return true;
3107 : 6766 : }
3108 : :
3109 : : // Implement fold for a cast from int to a float.
3110 : : bool
3111 : 814954 : operator_cast::fold_range (frange &r, tree type, const irange &op1,
3112 : : const frange &, relation_trio) const
3113 : : {
3114 : 814954 : if (empty_range_varying (r, type, op1, op1))
3115 : 1442 : return true;
3116 : 813512 : REAL_VALUE_TYPE lb, ub;
3117 : 813512 : wide_int op1_lb = op1.lower_bound ();
3118 : 813512 : wide_int op1_ub = op1.upper_bound ();
3119 : 813512 : tree op1_type = op1.type ();
3120 : 813512 : enum machine_mode mode = flag_rounding_math ? VOIDmode : TYPE_MODE (type);
3121 : 813512 : real_from_integer (&lb, mode, op1_lb, TYPE_SIGN (op1_type));
3122 : 813512 : real_from_integer (&ub, mode, op1_ub, TYPE_SIGN (op1_type));
3123 : 813512 : if (flag_rounding_math)
3124 : : {
3125 : 1123 : REAL_VALUE_TYPE lbo = lb, ubo = ub;
3126 : 1123 : mode = TYPE_MODE (type);
3127 : 1123 : real_convert (&lb, mode, &lb);
3128 : 1123 : real_convert (&ub, mode, &ub);
3129 : 1123 : if (real_less (&lbo, &lb))
3130 : 320 : frange_nextafter (mode, lb, dconstninf);
3131 : 1123 : if (real_less (&ub, &ubo))
3132 : 192 : frange_nextafter (mode, ub, dconstinf);
3133 : : }
3134 : 813512 : r.set (type, lb, ub, nan_state (false));
3135 : 813512 : frange_drop_infs (r, type);
3136 : 813512 : if (r.undefined_p ())
3137 : 4 : r.set_varying (type);
3138 : 813512 : return true;
3139 : 813524 : }
3140 : :
3141 : : // Implement op1_range for a cast from int to a float.
3142 : : bool
3143 : 231670 : operator_cast::op1_range (irange &r, tree type, const frange &lhs,
3144 : : const irange &, relation_trio) const
3145 : : {
3146 : 231670 : if (lhs.undefined_p ())
3147 : : return false;
3148 : 231670 : if (lhs.known_isnan ())
3149 : : {
3150 : 0 : r.set_varying (type);
3151 : 0 : return true;
3152 : : }
3153 : 231670 : REAL_VALUE_TYPE lb = lhs.lower_bound ();
3154 : 231670 : REAL_VALUE_TYPE ub = lhs.upper_bound ();
3155 : 231670 : enum machine_mode mode = TYPE_MODE (lhs.type ());
3156 : 231670 : frange_nextafter (mode, lb, dconstninf);
3157 : 231670 : frange_nextafter (mode, ub, dconstinf);
3158 : 231670 : if (flag_rounding_math)
3159 : : {
3160 : 37 : real_floor (&lb, mode, &lb);
3161 : 37 : real_ceil (&ub, mode, &ub);
3162 : : }
3163 : : else
3164 : : {
3165 : 231633 : real_trunc (&lb, mode, &lb);
3166 : 231633 : real_trunc (&ub, mode, &ub);
3167 : : }
3168 : 231670 : REAL_VALUE_TYPE l, u;
3169 : 231670 : wide_int wlb, wub;
3170 : 231670 : l = real_value_from_int_cst (NULL_TREE, TYPE_MIN_VALUE (type));
3171 : 231670 : if (real_less (&lb, &l))
3172 : 23628 : wlb = wi::min_value (TYPE_PRECISION (type), TYPE_SIGN (type));
3173 : : else
3174 : : {
3175 : 208042 : bool fail = false;
3176 : 208042 : wlb = real_to_integer (&lb, &fail, TYPE_PRECISION (type));
3177 : 208042 : if (fail)
3178 : 0 : wlb = wi::min_value (TYPE_PRECISION (type), TYPE_SIGN (type));
3179 : : }
3180 : 231670 : u = real_value_from_int_cst (NULL_TREE, TYPE_MAX_VALUE (type));
3181 : 231670 : if (real_less (&u, &ub))
3182 : 34287 : wub = wi::max_value (TYPE_PRECISION (type), TYPE_SIGN (type));
3183 : : else
3184 : : {
3185 : 197383 : bool fail = false;
3186 : 197383 : wub = real_to_integer (&ub, &fail, TYPE_PRECISION (type));
3187 : 197383 : if (fail)
3188 : 0 : wub = wi::max_value (TYPE_PRECISION (type), TYPE_SIGN (type));
3189 : : }
3190 : 231670 : r.set (type, wlb, wub);
3191 : 231670 : return true;
3192 : 231670 : }
3193 : :
3194 : : // Initialize any float operators to the primary table
3195 : :
3196 : : void
3197 : 285621 : range_op_table::initialize_float_ops ()
3198 : : {
3199 : 285621 : set (UNLE_EXPR, fop_unordered_le);
3200 : 285621 : set (UNLT_EXPR, fop_unordered_lt);
3201 : 285621 : set (UNGE_EXPR, fop_unordered_ge);
3202 : 285621 : set (UNGT_EXPR, fop_unordered_gt);
3203 : 285621 : set (UNEQ_EXPR, fop_unordered_equal);
3204 : 285621 : set (ORDERED_EXPR, fop_ordered);
3205 : 285621 : set (UNORDERED_EXPR, fop_unordered);
3206 : 285621 : set (LTGT_EXPR, fop_ltgt);
3207 : 285621 : set (RDIV_EXPR, fop_div);
3208 : 285621 : }
3209 : :
3210 : : #if CHECKING_P
3211 : : #include "selftest.h"
3212 : :
3213 : : namespace selftest
3214 : : {
3215 : :
3216 : : // Build an frange from string endpoints.
3217 : :
3218 : : static inline frange
3219 : 16 : frange_float (const char *lb, const char *ub, tree type = float_type_node)
3220 : : {
3221 : 16 : REAL_VALUE_TYPE min, max;
3222 : 16 : gcc_assert (real_from_string (&min, lb) == 0);
3223 : 16 : gcc_assert (real_from_string (&max, ub) == 0);
3224 : 16 : return frange (type, min, max);
3225 : : }
3226 : :
3227 : : void
3228 : 4 : range_op_float_tests ()
3229 : : {
3230 : 4 : frange r, r0, r1;
3231 : 4 : frange trange (float_type_node);
3232 : :
3233 : : // negate([-5, +10]) => [-10, 5]
3234 : 4 : r0 = frange_float ("-5", "10");
3235 : 4 : range_op_handler (NEGATE_EXPR).fold_range (r, float_type_node, r0, trange);
3236 : 4 : ASSERT_EQ (r, frange_float ("-10", "5"));
3237 : :
3238 : : // negate([0, 1] -NAN) => [-1, -0] +NAN
3239 : 4 : r0 = frange_float ("0", "1");
3240 : 4 : r0.update_nan (true);
3241 : 4 : range_op_handler (NEGATE_EXPR).fold_range (r, float_type_node, r0, trange);
3242 : 4 : r1 = frange_float ("-1", "-0");
3243 : 4 : r1.update_nan (false);
3244 : 4 : ASSERT_EQ (r, r1);
3245 : :
3246 : : // [-INF,+INF] + [-INF,+INF] could be a NAN.
3247 : 4 : range_op_handler plus (PLUS_EXPR);
3248 : 4 : r0.set_varying (float_type_node);
3249 : 4 : r1.set_varying (float_type_node);
3250 : 4 : r0.clear_nan ();
3251 : 4 : r1.clear_nan ();
3252 : 4 : plus.fold_range (r, float_type_node, r0, r1);
3253 : 4 : if (HONOR_NANS (float_type_node))
3254 : 8 : ASSERT_TRUE (r.maybe_isnan ());
3255 : 4 : }
3256 : :
3257 : : } // namespace selftest
3258 : :
3259 : : #endif // CHECKING_P
|
