1/* Code for GIMPLE range op related routines.
2 Copyright (C) 2019-2024 Free Software Foundation, Inc.
3 Contributed by Andrew MacLeod <amacleod@redhat.com>
4 and Aldy Hernandez <aldyh@redhat.com>.
5
6This file is part of GCC.
7
8GCC is free software; you can redistribute it and/or modify
9it under the terms of the GNU General Public License as published by
10the Free Software Foundation; either version 3, or (at your option)
11any later version.
12
13GCC is distributed in the hope that it will be useful,
14but WITHOUT ANY WARRANTY; without even the implied warranty of
15MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16GNU General Public License for more details.
17
18You should have received a copy of the GNU General Public License
19along with GCC; see the file COPYING3. If not see
20<http://www.gnu.org/licenses/>. */
21
22#include "config.h"
23#include "system.h"
24#include "coretypes.h"
25#include "backend.h"
26#include "insn-codes.h"
27#include "tree.h"
28#include "gimple.h"
29#include "ssa.h"
30#include "gimple-pretty-print.h"
31#include "optabs-tree.h"
32#include "gimple-iterator.h"
33#include "gimple-fold.h"
34#include "wide-int.h"
35#include "fold-const.h"
36#include "case-cfn-macros.h"
37#include "omp-general.h"
38#include "cfgloop.h"
39#include "tree-ssa-loop.h"
40#include "tree-scalar-evolution.h"
41#include "langhooks.h"
42#include "vr-values.h"
43#include "range.h"
44#include "value-query.h"
45#include "gimple-range.h"
46#include "attr-fnspec.h"
47#include "realmpfr.h"
48
49// Given stmt S, fill VEC, up to VEC_SIZE elements, with relevant ssa-names
50// on the statement. For efficiency, it is an error to not pass in enough
51// elements for the vector. Return the number of ssa-names.
52
53unsigned
54gimple_range_ssa_names (tree *vec, unsigned vec_size, gimple *stmt)
55{
56 tree ssa;
57 int count = 0;
58
59 gimple_range_op_handler handler (stmt);
60 if (handler)
61 {
62 gcc_checking_assert (vec_size >= 2);
63 if ((ssa = gimple_range_ssa_p (exp: handler.operand1 ())))
64 vec[count++] = ssa;
65 if ((ssa = gimple_range_ssa_p (exp: handler.operand2 ())))
66 vec[count++] = ssa;
67 }
68 else if (is_a<gassign *> (p: stmt)
69 && gimple_assign_rhs_code (gs: stmt) == COND_EXPR)
70 {
71 gcc_checking_assert (vec_size >= 3);
72 gassign *st = as_a<gassign *> (p: stmt);
73 if ((ssa = gimple_range_ssa_p (exp: gimple_assign_rhs1 (gs: st))))
74 vec[count++] = ssa;
75 if ((ssa = gimple_range_ssa_p (exp: gimple_assign_rhs2 (gs: st))))
76 vec[count++] = ssa;
77 if ((ssa = gimple_range_ssa_p (exp: gimple_assign_rhs3 (gs: st))))
78 vec[count++] = ssa;
79 }
80 return count;
81}
82
83// Return the base of the RHS of an assignment.
84
85static tree
86gimple_range_base_of_assignment (const gimple *stmt)
87{
88 gcc_checking_assert (gimple_code (stmt) == GIMPLE_ASSIGN);
89 tree op1 = gimple_assign_rhs1 (gs: stmt);
90 if (gimple_assign_rhs_code (gs: stmt) == ADDR_EXPR)
91 return get_base_address (TREE_OPERAND (op1, 0));
92 return op1;
93}
94
95// If statement is supported by range-ops, set the CODE and return the TYPE.
96
97static inline enum tree_code
98get_code (gimple *s)
99{
100 if (const gassign *ass = dyn_cast<const gassign *> (p: s))
101 return gimple_assign_rhs_code (gs: ass);
102 if (const gcond *cond = dyn_cast<const gcond *> (p: s))
103 return gimple_cond_code (gs: cond);
104 return ERROR_MARK;
105}
106
107// If statement S has a supported range_op handler return TRUE.
108
109bool
110gimple_range_op_handler::supported_p (gimple *s)
111{
112 enum tree_code code = get_code (s);
113 if (range_op_handler (code))
114 return true;
115 if (is_a <gcall *> (p: s) && gimple_range_op_handler (s))
116 return true;
117 return false;
118}
119
120// Construct a handler object for statement S.
121
122gimple_range_op_handler::gimple_range_op_handler (gimple *s)
123{
124 range_op_handler oper (get_code (s));
125 m_stmt = s;
126 m_op1 = NULL_TREE;
127 m_op2 = NULL_TREE;
128
129 if (oper)
130 switch (gimple_code (g: m_stmt))
131 {
132 case GIMPLE_COND:
133 m_op1 = gimple_cond_lhs (gs: m_stmt);
134 m_op2 = gimple_cond_rhs (gs: m_stmt);
135 // Check that operands are supported types. One check is enough.
136 if (Value_Range::supports_type_p (TREE_TYPE (m_op1)))
137 m_operator = oper.range_op ();
138 gcc_checking_assert (m_operator);
139 return;
140 case GIMPLE_ASSIGN:
141 m_op1 = gimple_range_base_of_assignment (stmt: m_stmt);
142 if (m_op1 && TREE_CODE (m_op1) == MEM_REF)
143 {
144 // If the base address is an SSA_NAME, we return it
145 // here. This allows processing of the range of that
146 // name, while the rest of the expression is simply
147 // ignored. The code in range_ops will see the
148 // ADDR_EXPR and do the right thing.
149 tree ssa = TREE_OPERAND (m_op1, 0);
150 if (TREE_CODE (ssa) == SSA_NAME)
151 m_op1 = ssa;
152 }
153 if (gimple_num_ops (gs: m_stmt) >= 3)
154 m_op2 = gimple_assign_rhs2 (gs: m_stmt);
155 // Check that operands are supported types. One check is enough.
156 if ((m_op1 && !Value_Range::supports_type_p (TREE_TYPE (m_op1))))
157 return;
158 m_operator = oper.range_op ();
159 gcc_checking_assert (m_operator);
160 return;
161 default:
162 gcc_unreachable ();
163 return;
164 }
165 // If no range-op table entry handled this stmt, check for other supported
166 // statements.
167 if (is_a <gcall *> (p: m_stmt))
168 maybe_builtin_call ();
169 else
170 maybe_non_standard ();
171 gcc_checking_assert (m_operator);
172}
173
174// Calculate what we can determine of the range of this unary
175// statement's operand if the lhs of the expression has the range
176// LHS_RANGE. Return false if nothing can be determined.
177
178bool
179gimple_range_op_handler::calc_op1 (vrange &r, const vrange &lhs_range)
180{
181 gcc_checking_assert (gimple_num_ops (m_stmt) < 3);
182 // Give up on empty ranges.
183 if (lhs_range.undefined_p ())
184 return false;
185
186 // Unary operations require the type of the first operand in the
187 // second range position.
188 tree type = TREE_TYPE (operand1 ());
189 Value_Range type_range (type);
190 type_range.set_varying (type);
191 return op1_range (r, type, lhs: lhs_range, op2: type_range);
192}
193
194// Calculate what we can determine of the range of this statement's
195// first operand if the lhs of the expression has the range LHS_RANGE
196// and the second operand has the range OP2_RANGE. Return false if
197// nothing can be determined.
198
199bool
200gimple_range_op_handler::calc_op1 (vrange &r, const vrange &lhs_range,
201 const vrange &op2_range, relation_trio k)
202{
203 // Give up on empty ranges.
204 if (lhs_range.undefined_p ())
205 return false;
206
207 // Unary operation are allowed to pass a range in for second operand
208 // as there are often additional restrictions beyond the type which
209 // can be imposed. See operator_cast::op1_range().
210 tree type = TREE_TYPE (operand1 ());
211 // If op2 is undefined, solve as if it is varying.
212 if (op2_range.undefined_p ())
213 {
214 if (gimple_num_ops (gs: m_stmt) < 3)
215 return false;
216 tree op2_type;
217 // This is sometimes invoked on single operand stmts.
218 if (operand2 ())
219 op2_type = TREE_TYPE (operand2 ());
220 else
221 op2_type = TREE_TYPE (operand1 ());
222 Value_Range trange (op2_type);
223 trange.set_varying (op2_type);
224 return op1_range (r, type, lhs: lhs_range, op2: trange, k);
225 }
226 return op1_range (r, type, lhs: lhs_range, op2: op2_range, k);
227}
228
229// Calculate what we can determine of the range of this statement's
230// second operand if the lhs of the expression has the range LHS_RANGE
231// and the first operand has the range OP1_RANGE. Return false if
232// nothing can be determined.
233
234bool
235gimple_range_op_handler::calc_op2 (vrange &r, const vrange &lhs_range,
236 const vrange &op1_range, relation_trio k)
237{
238 // Give up on empty ranges.
239 if (lhs_range.undefined_p ())
240 return false;
241
242 tree type = TREE_TYPE (operand2 ());
243 // If op1 is undefined, solve as if it is varying.
244 if (op1_range.undefined_p ())
245 {
246 tree op1_type = TREE_TYPE (operand1 ());
247 Value_Range trange (op1_type);
248 trange.set_varying (op1_type);
249 return op2_range (r, type, lhs: lhs_range, op1: trange, k);
250 }
251 return op2_range (r, type, lhs: lhs_range, op1: op1_range, k);
252}
253
254// --------------------------------------------------------------------
255
256// Implement range operator for float CFN_BUILT_IN_CONSTANT_P.
257class cfn_constant_float_p : public range_operator
258{
259public:
260 using range_operator::fold_range;
261 virtual bool fold_range (irange &r, tree type, const frange &lh,
262 const irange &, relation_trio) const
263 {
264 if (lh.singleton_p ())
265 {
266 wide_int one = wi::one (TYPE_PRECISION (type));
267 r.set (type, one, one);
268 return true;
269 }
270 if (cfun->after_inlining)
271 {
272 r.set_zero (type);
273 return true;
274 }
275 return false;
276 }
277} op_cfn_constant_float_p;
278
279// Implement range operator for integral CFN_BUILT_IN_CONSTANT_P.
280class cfn_constant_p : public range_operator
281{
282public:
283 using range_operator::fold_range;
284 virtual bool fold_range (irange &r, tree type, const irange &lh,
285 const irange &, relation_trio) const
286 {
287 if (lh.singleton_p ())
288 {
289 wide_int one = wi::one (TYPE_PRECISION (type));
290 r.set (type, one, one);
291 return true;
292 }
293 if (cfun->after_inlining)
294 {
295 r.set_zero (type);
296 return true;
297 }
298 return false;
299 }
300} op_cfn_constant_p;
301
302// Implement range operator for integral/pointer functions returning
303// the first argument.
304class cfn_pass_through_arg1 : public range_operator
305{
306public:
307 using range_operator::fold_range;
308 using range_operator::op1_range;
309 virtual bool fold_range (irange &r, tree, const irange &lh,
310 const irange &, relation_trio) const
311 {
312 r = lh;
313 return true;
314 }
315 virtual bool op1_range (irange &r, tree, const irange &lhs,
316 const irange &, relation_trio) const
317 {
318 r = lhs;
319 return true;
320 }
321} op_cfn_pass_through_arg1;
322
323// Implement range operator for CFN_BUILT_IN_SIGNBIT.
324class cfn_signbit : public range_operator
325{
326public:
327 using range_operator::fold_range;
328 using range_operator::op1_range;
329 virtual bool fold_range (irange &r, tree type, const frange &lh,
330 const irange &, relation_trio) const override
331 {
332 bool signbit;
333 if (lh.signbit_p (signbit))
334 {
335 if (signbit)
336 r.set_nonzero (type);
337 else
338 r.set_zero (type);
339 return true;
340 }
341 return false;
342 }
343 virtual bool op1_range (frange &r, tree type, const irange &lhs,
344 const frange &, relation_trio) const override
345 {
346 if (lhs.zero_p ())
347 {
348 r.set (type, dconst0, frange_val_max (type));
349 r.update_nan (sign: false);
350 return true;
351 }
352 if (!lhs.contains_p (wi::zero (TYPE_PRECISION (lhs.type ()))))
353 {
354 r.set (type, frange_val_min (type), dconstm0);
355 r.update_nan (sign: true);
356 return true;
357 }
358 return false;
359 }
360} op_cfn_signbit;
361
362// Implement range operator for CFN_BUILT_IN_COPYSIGN
363class cfn_copysign : public range_operator
364{
365public:
366 using range_operator::fold_range;
367 virtual bool fold_range (frange &r, tree type, const frange &lh,
368 const frange &rh, relation_trio) const override
369 {
370 frange neg;
371 if (!range_op_handler (ABS_EXPR).fold_range (r, type, lh, rh: frange (type)))
372 return false;
373 if (!range_op_handler (NEGATE_EXPR).fold_range (r&: neg, type, lh: r,
374 rh: frange (type)))
375 return false;
376
377 bool signbit;
378 if (rh.signbit_p (signbit))
379 {
380 // If the sign is negative, flip the result from ABS,
381 // otherwise leave things positive.
382 if (signbit)
383 r = neg;
384 }
385 else
386 // If the sign is unknown, keep the positive and negative
387 // alternatives.
388 r.union_ (neg);
389 return true;
390 }
391} op_cfn_copysign;
392
393/* Compute FUNC (ARG) where FUNC is a mpfr function. If RES_LOW is non-NULL,
394 set it to low bound of possible range if the function is expected to have
395 ULPS precision and similarly if RES_HIGH is non-NULL, set it to high bound.
396 If the function returns false, the results weren't set. */
397
398static bool
399frange_mpfr_arg1 (REAL_VALUE_TYPE *res_low, REAL_VALUE_TYPE *res_high,
400 int (*func) (mpfr_ptr, mpfr_srcptr, mpfr_rnd_t),
401 const REAL_VALUE_TYPE &arg, tree type, unsigned ulps)
402{
403 if (ulps == ~0U || !real_isfinite (&arg))
404 return false;
405 machine_mode mode = TYPE_MODE (type);
406 const real_format *format = REAL_MODE_FORMAT (mode);
407 auto_mpfr m (format->p);
408 mpfr_from_real (m, &arg, MPFR_RNDN);
409 mpfr_clear_flags ();
410 bool inexact = func (m, m, MPFR_RNDN);
411 if (!mpfr_number_p (m) || mpfr_overflow_p () || mpfr_underflow_p ())
412 return false;
413
414 REAL_VALUE_TYPE value, result;
415 real_from_mpfr (&value, m, format, MPFR_RNDN);
416 if (!real_isfinite (&value))
417 return false;
418 if ((value.cl == rvc_zero) != (mpfr_zero_p (m) != 0))
419 inexact = true;
420
421 real_convert (&result, format, &value);
422 if (!real_isfinite (&result))
423 return false;
424 bool round_low = false;
425 bool round_high = false;
426 if (!ulps && flag_rounding_math)
427 ++ulps;
428 if (inexact || !real_identical (&result, &value))
429 {
430 if (MODE_COMPOSITE_P (mode))
431 round_low = round_high = true;
432 else
433 {
434 round_low = !real_less (&result, &value);
435 round_high = !real_less (&value, &result);
436 }
437 }
438 if (res_low)
439 {
440 *res_low = result;
441 for (unsigned int i = 0; i < ulps + round_low; ++i)
442 frange_nextafter (mode, *res_low, dconstninf);
443 }
444 if (res_high)
445 {
446 *res_high = result;
447 for (unsigned int i = 0; i < ulps + round_high; ++i)
448 frange_nextafter (mode, *res_high, dconstinf);
449 }
450 return true;
451}
452
453class cfn_sqrt : public range_operator
454{
455public:
456 using range_operator::fold_range;
457 using range_operator::op1_range;
458 virtual bool fold_range (frange &r, tree type,
459 const frange &lh, const frange &,
460 relation_trio) const final override
461 {
462 if (lh.undefined_p ())
463 return false;
464 if (lh.known_isnan () || real_less (&lh.upper_bound (), &dconstm0))
465 {
466 r.set_nan (type);
467 return true;
468 }
469 unsigned bulps
470 = targetm.libm_function_max_error (CFN_SQRT, TYPE_MODE (type), true);
471 if (bulps == ~0U)
472 r.set_varying (type);
473 else if (bulps == 0)
474 r.set (type, dconstm0, dconstinf);
475 else
476 {
477 REAL_VALUE_TYPE boundmin = dconstm0;
478 while (bulps--)
479 frange_nextafter (TYPE_MODE (type), boundmin, dconstninf);
480 r.set (type, boundmin, dconstinf);
481 }
482 if (!lh.maybe_isnan () && !real_less (&lh.lower_bound (), &dconst0))
483 r.clear_nan ();
484
485 unsigned ulps
486 = targetm.libm_function_max_error (CFN_SQRT, TYPE_MODE (type), false);
487 if (ulps == ~0U)
488 return true;
489 REAL_VALUE_TYPE lb = lh.lower_bound ();
490 REAL_VALUE_TYPE ub = lh.upper_bound ();
491 if (!frange_mpfr_arg1 (res_low: &lb, NULL, func: mpfr_sqrt, arg: lb, type, ulps))
492 lb = dconstninf;
493 if (!frange_mpfr_arg1 (NULL, res_high: &ub, func: mpfr_sqrt, arg: ub, type, ulps))
494 ub = dconstinf;
495 frange r2;
496 r2.set (type, lb, ub);
497 r2.flush_denormals_to_zero ();
498 r.intersect (r2);
499 return true;
500 }
501 virtual bool op1_range (frange &r, tree type,
502 const frange &lhs, const frange &,
503 relation_trio) const final override
504 {
505 if (lhs.undefined_p ())
506 return false;
507
508 // A known NAN means the input is [-INF,-0.) U +-NAN.
509 if (lhs.known_isnan ())
510 {
511 known_nan:
512 REAL_VALUE_TYPE ub = dconstm0;
513 frange_nextafter (TYPE_MODE (type), ub, dconstninf);
514 r.set (type, dconstninf, ub);
515 // No r.flush_denormals_to_zero (); here - it is a reverse op.
516 return true;
517 }
518
519 // Results outside of [-0.0, +Inf] are impossible.
520 unsigned bulps
521 = targetm.libm_function_max_error (CFN_SQRT, TYPE_MODE (type), true);
522 if (bulps != ~0U)
523 {
524 const REAL_VALUE_TYPE &ub = lhs.upper_bound ();
525 REAL_VALUE_TYPE m0 = dconstm0;
526 while (bulps--)
527 frange_nextafter (TYPE_MODE (type), m0, dconstninf);
528 if (real_less (&ub, &m0))
529 {
530 if (!lhs.maybe_isnan ())
531 r.set_undefined ();
532 else
533 // If lhs could be NAN and finite result is impossible,
534 // the range is like lhs.known_isnan () above.
535 goto known_nan;
536 return true;
537 }
538 }
539
540 if (!lhs.maybe_isnan ())
541 // If NAN is not valid result, the input cannot include either
542 // a NAN nor values smaller than -0.
543 r.set (type, dconstm0, dconstinf, nan_state (false, false));
544 else
545 r.set_varying (type);
546
547 unsigned ulps
548 = targetm.libm_function_max_error (CFN_SQRT, TYPE_MODE (type), false);
549 if (ulps == ~0U)
550 return true;
551 REAL_VALUE_TYPE lb = lhs.lower_bound ();
552 REAL_VALUE_TYPE ub = lhs.upper_bound ();
553 if (!lhs.maybe_isnan () && real_less (&dconst0, &lb))
554 {
555 for (unsigned i = 0; i < ulps; ++i)
556 frange_nextafter (TYPE_MODE (type), lb, dconstninf);
557 if (real_less (&dconst0, &lb))
558 {
559 REAL_VALUE_TYPE op = lb;
560 frange_arithmetic (MULT_EXPR, type, lb, op, op, dconstninf);
561 }
562 else
563 lb = dconstninf;
564 }
565 else
566 lb = dconstninf;
567 if (real_isfinite (&ub) && real_less (&dconst0, &ub))
568 {
569 for (unsigned i = 0; i < ulps; ++i)
570 frange_nextafter (TYPE_MODE (type), ub, dconstinf);
571 if (real_isfinite (&ub))
572 {
573 REAL_VALUE_TYPE op = ub;
574 frange_arithmetic (MULT_EXPR, type, ub, op, op, dconstinf);
575 }
576 else
577 ub = dconstinf;
578 }
579 else
580 ub = dconstinf;
581 frange r2;
582 r2.set (type, lb, ub);
583 r.intersect (r2);
584 return true;
585 }
586} op_cfn_sqrt;
587
588class cfn_sincos : public range_operator
589{
590public:
591 using range_operator::fold_range;
592 using range_operator::op1_range;
593 cfn_sincos (combined_fn cfn) { m_cfn = cfn; }
594 virtual bool fold_range (frange &r, tree type,
595 const frange &lh, const frange &,
596 relation_trio) const final override
597 {
598 if (lh.undefined_p ())
599 return false;
600 if (lh.known_isnan () || lh.known_isinf ())
601 {
602 r.set_nan (type);
603 return true;
604 }
605 unsigned bulps = targetm.libm_function_max_error (m_cfn, TYPE_MODE (type),
606 true);
607 if (bulps == ~0U)
608 r.set_varying (type);
609 else if (bulps == 0)
610 r.set (type, dconstm1, dconst1);
611 else
612 {
613 REAL_VALUE_TYPE boundmin, boundmax;
614 boundmax = dconst1;
615 while (bulps--)
616 frange_nextafter (TYPE_MODE (type), boundmax, dconstinf);
617 real_arithmetic (&boundmin, NEGATE_EXPR, &boundmax, NULL);
618 r.set (type, boundmin, boundmax);
619 }
620 if (!lh.maybe_isnan () && !lh.maybe_isinf ())
621 r.clear_nan ();
622
623 unsigned ulps
624 = targetm.libm_function_max_error (m_cfn, TYPE_MODE (type), false);
625 if (ulps == ~0U)
626 return true;
627 REAL_VALUE_TYPE lb = lh.lower_bound ();
628 REAL_VALUE_TYPE ub = lh.upper_bound ();
629 REAL_VALUE_TYPE diff;
630 real_arithmetic (&diff, MINUS_EXPR, &ub, &lb);
631 if (!real_isfinite (&diff))
632 return true;
633 REAL_VALUE_TYPE pi = dconst_pi ();
634 REAL_VALUE_TYPE pix2;
635 real_arithmetic (&pix2, PLUS_EXPR, &pi, &pi);
636 // We can only try to narrow the range further if ub-lb < 2*pi.
637 if (!real_less (&diff, &pix2))
638 return true;
639 REAL_VALUE_TYPE lb_lo, lb_hi, ub_lo, ub_hi;
640 REAL_VALUE_TYPE lb_deriv_lo, lb_deriv_hi, ub_deriv_lo, ub_deriv_hi;
641 if (!frange_mpfr_arg1 (res_low: &lb_lo, res_high: &lb_hi,
642 func: m_cfn == CFN_SIN ? mpfr_sin : mpfr_cos, arg: lb,
643 type, ulps)
644 || !frange_mpfr_arg1 (res_low: &ub_lo, res_high: &ub_hi,
645 func: m_cfn == CFN_SIN ? mpfr_sin : mpfr_cos, arg: ub,
646 type, ulps)
647 || !frange_mpfr_arg1 (res_low: &lb_deriv_lo, res_high: &lb_deriv_hi,
648 func: m_cfn == CFN_SIN ? mpfr_cos : mpfr_sin, arg: lb,
649 type, ulps: 0)
650 || !frange_mpfr_arg1 (res_low: &ub_deriv_lo, res_high: &ub_deriv_hi,
651 func: m_cfn == CFN_SIN ? mpfr_cos : mpfr_sin, arg: ub,
652 type, ulps: 0))
653 return true;
654 if (m_cfn == CFN_COS)
655 {
656 // Derivative of cos is -sin, so negate.
657 lb_deriv_lo.sign ^= 1;
658 lb_deriv_hi.sign ^= 1;
659 ub_deriv_lo.sign ^= 1;
660 ub_deriv_hi.sign ^= 1;
661 }
662
663 if (real_less (&lb_lo, &ub_lo))
664 lb = lb_lo;
665 else
666 lb = ub_lo;
667 if (real_less (&lb_hi, &ub_hi))
668 ub = ub_hi;
669 else
670 ub = lb_hi;
671
672 // The range between the function result on the boundaries may need
673 // to be extended to +1 (+Inf) or -1 (-Inf) or both depending on the
674 // derivative or length of the argument range (diff).
675
676 // First handle special case, where the derivative has different signs,
677 // so the bound must be roughly -1 or +1.
678 if (real_isneg (&lb_deriv_lo) != real_isneg (&lb_deriv_hi))
679 {
680 if (real_isneg (&lb_lo))
681 lb = dconstninf;
682 else
683 ub = dconstinf;
684 }
685 if (real_isneg (&ub_deriv_lo) != real_isneg (&ub_deriv_hi))
686 {
687 if (real_isneg (&ub_lo))
688 lb = dconstninf;
689 else
690 ub = dconstinf;
691 }
692
693 // If derivative at lower_bound and upper_bound have the same sign,
694 // the function grows or declines on the whole range if diff < pi, so
695 // [lb, ub] is correct, and if diff >= pi the result range must include
696 // both the minimum and maximum.
697 if (real_isneg (&lb_deriv_lo) == real_isneg (&ub_deriv_lo))
698 {
699 if (!real_less (&diff, &pi))
700 return true;
701 }
702 // If function declines at lower_bound and grows at upper_bound,
703 // the result range must include the minimum, so set lb to -Inf.
704 else if (real_isneg (&lb_deriv_lo))
705 lb = dconstninf;
706 // If function grows at lower_bound and declines at upper_bound,
707 // the result range must include the maximum, so set ub to +Inf.
708 else
709 ub = dconstinf;
710 frange r2;
711 r2.set (type, lb, ub);
712 r2.flush_denormals_to_zero ();
713 r.intersect (r2);
714 return true;
715 }
716 virtual bool op1_range (frange &r, tree type,
717 const frange &lhs, const frange &,
718 relation_trio) const final override
719 {
720 if (lhs.undefined_p ())
721 return false;
722
723 // A known NAN means the input is [-INF,-INF][+INF,+INF] U +-NAN,
724 // which we can't currently represent.
725 if (lhs.known_isnan ())
726 {
727 r.set_varying (type);
728 return true;
729 }
730
731 // Results outside of [-1.0, +1.0] are impossible.
732 unsigned bulps
733 = targetm.libm_function_max_error (m_cfn, TYPE_MODE (type), true);
734 if (bulps != ~0U)
735 {
736 const REAL_VALUE_TYPE &lb = lhs.lower_bound ();
737 const REAL_VALUE_TYPE &ub = lhs.upper_bound ();
738 REAL_VALUE_TYPE m1 = dconstm1;
739 REAL_VALUE_TYPE p1 = dconst1;
740 while (bulps--)
741 {
742 frange_nextafter (TYPE_MODE (type), m1, dconstninf);
743 frange_nextafter (TYPE_MODE (type), p1, dconstinf);
744 }
745 if (real_less (&ub, &m1) || real_less (&p1, &lb))
746 {
747 if (!lhs.maybe_isnan ())
748 r.set_undefined ();
749 else
750 /* If lhs could be NAN and finite result is impossible,
751 the range is like lhs.known_isnan () above,
752 [-INF,-INF][+INF,+INF] U +-NAN. */
753 r.set_varying (type);
754 return true;
755 }
756 }
757
758 if (!lhs.maybe_isnan ())
759 {
760 // If NAN is not valid result, the input cannot include either
761 // a NAN nor a +-INF.
762 REAL_VALUE_TYPE lb = real_min_representable (type);
763 REAL_VALUE_TYPE ub = real_max_representable (type);
764 r.set (type, lb, ub, nan_state (false, false));
765 }
766 else
767 r.set_varying (type);
768 return true;
769 }
770private:
771 combined_fn m_cfn;
772} op_cfn_sin (CFN_SIN), op_cfn_cos (CFN_COS);
773
774// Implement range operator for CFN_BUILT_IN_TOUPPER and CFN_BUILT_IN_TOLOWER.
775class cfn_toupper_tolower : public range_operator
776{
777public:
778 using range_operator::fold_range;
779 cfn_toupper_tolower (bool toupper) { m_toupper = toupper; }
780 virtual bool fold_range (irange &r, tree type, const irange &lh,
781 const irange &, relation_trio) const;
782private:
783 bool get_letter_range (tree type, irange &lowers, irange &uppers) const;
784 bool m_toupper;
785} op_cfn_toupper (true), op_cfn_tolower (false);
786
787// Return TRUE if we recognize the target character set and return the
788// range for lower case and upper case letters.
789
790bool
791cfn_toupper_tolower::get_letter_range (tree type, irange &lowers,
792 irange &uppers) const
793{
794 // ASCII
795 int a = lang_hooks.to_target_charset ('a');
796 int z = lang_hooks.to_target_charset ('z');
797 int A = lang_hooks.to_target_charset ('A');
798 int Z = lang_hooks.to_target_charset ('Z');
799
800 if ((z - a == 25) && (Z - A == 25))
801 {
802 lowers = int_range<2> (type,
803 wi::shwi (val: a, TYPE_PRECISION (type)),
804 wi::shwi (val: z, TYPE_PRECISION (type)));
805 uppers = int_range<2> (type,
806 wi::shwi (val: A, TYPE_PRECISION (type)),
807 wi::shwi (val: Z, TYPE_PRECISION (type)));
808 return true;
809 }
810 // Unknown character set.
811 return false;
812}
813
814bool
815cfn_toupper_tolower::fold_range (irange &r, tree type, const irange &lh,
816 const irange &, relation_trio) const
817{
818 int_range<3> lowers;
819 int_range<3> uppers;
820 if (!get_letter_range (type, lowers, uppers))
821 return false;
822
823 r = lh;
824 if (m_toupper)
825 {
826 // Return the range passed in without any lower case characters,
827 // but including all the upper case ones.
828 lowers.invert ();
829 r.intersect (lowers);
830 r.union_ (uppers);
831 }
832 else
833 {
834 // Return the range passed in without any lower case characters,
835 // but including all the upper case ones.
836 uppers.invert ();
837 r.intersect (uppers);
838 r.union_ (lowers);
839 }
840 return true;
841}
842
843// Implement range operator for CFN_BUILT_IN_FFS.
844class cfn_ffs : public range_operator
845{
846public:
847 using range_operator::fold_range;
848 virtual bool fold_range (irange &r, tree type, const irange &lh,
849 const irange &, relation_trio) const
850 {
851 if (lh.undefined_p ())
852 return false;
853 // __builtin_ffs* and __builtin_popcount* return [0, prec].
854 int prec = TYPE_PRECISION (lh.type ());
855 // If arg is non-zero, then ffs or popcount are non-zero.
856 int mini = range_includes_zero_p (vr: &lh) ? 0 : 1;
857 int maxi = prec;
858
859 // If some high bits are known to be zero, decrease the maximum.
860 int_range_max tmp = lh;
861 if (TYPE_SIGN (tmp.type ()) == SIGNED)
862 range_cast (r&: tmp, type: unsigned_type_for (tmp.type ()));
863 wide_int max = tmp.upper_bound ();
864 maxi = wi::floor_log2 (max) + 1;
865 r.set (type,
866 wi::shwi (val: mini, TYPE_PRECISION (type)),
867 wi::shwi (val: maxi, TYPE_PRECISION (type)));
868 return true;
869 }
870} op_cfn_ffs;
871
872// Implement range operator for CFN_BUILT_IN_POPCOUNT.
873class cfn_popcount : public cfn_ffs
874{
875public:
876 using range_operator::fold_range;
877 virtual bool fold_range (irange &r, tree type, const irange &lh,
878 const irange &rh, relation_trio rel) const
879 {
880 if (lh.undefined_p ())
881 return false;
882 unsigned prec = TYPE_PRECISION (type);
883 irange_bitmask bm = lh.get_bitmask ();
884 wide_int nz = bm.get_nonzero_bits ();
885 wide_int high = wi::shwi (val: wi::popcount (nz), precision: prec);
886 // Calculating the popcount of a singleton is trivial.
887 if (lh.singleton_p ())
888 {
889 r.set (type, high, high);
890 return true;
891 }
892 if (cfn_ffs::fold_range (r, type, lh, rh, rel))
893 {
894 wide_int known_ones = ~bm.mask () & bm.value ();
895 wide_int low = wi::shwi (val: wi::popcount (known_ones), precision: prec);
896 int_range<2> tmp (type, low, high);
897 r.intersect (tmp);
898 return true;
899 }
900 return false;
901 }
902} op_cfn_popcount;
903
904// Implement range operator for CFN_BUILT_IN_CLZ
905class cfn_clz : public range_operator
906{
907public:
908 cfn_clz (bool internal) { m_gimple_call_internal_p = internal; }
909 using range_operator::fold_range;
910 virtual bool fold_range (irange &r, tree type, const irange &lh,
911 const irange &rh, relation_trio) const;
912private:
913 bool m_gimple_call_internal_p;
914} op_cfn_clz (false), op_cfn_clz_internal (true);
915
916bool
917cfn_clz::fold_range (irange &r, tree type, const irange &lh,
918 const irange &rh, relation_trio) const
919{
920 // __builtin_c[lt]z* return [0, prec-1], except when the
921 // argument is 0, but that is undefined behavior.
922 //
923 // For __builtin_c[lt]z* consider argument of 0 always undefined
924 // behavior, for internal fns likewise, unless it has 2 arguments,
925 // then the second argument is the value at zero.
926 if (lh.undefined_p ())
927 return false;
928 int prec = TYPE_PRECISION (lh.type ());
929 int mini = 0;
930 int maxi = prec - 1;
931 if (m_gimple_call_internal_p)
932 {
933 // Only handle the single common value.
934 if (rh.lower_bound () == prec)
935 maxi = prec;
936 else
937 // Magic value to give up, unless we can prove arg is non-zero.
938 mini = -2;
939 }
940
941 // From clz of minimum we can compute result maximum.
942 if (wi::gt_p (x: lh.lower_bound (), y: 0, TYPE_SIGN (lh.type ())))
943 {
944 maxi = prec - 1 - wi::floor_log2 (lh.lower_bound ());
945 if (mini == -2)
946 mini = 0;
947 }
948 else if (!range_includes_zero_p (vr: &lh))
949 {
950 mini = 0;
951 maxi = prec - 1;
952 }
953 if (mini == -2)
954 return false;
955 // From clz of maximum we can compute result minimum.
956 wide_int max = lh.upper_bound ();
957 int newmini = prec - 1 - wi::floor_log2 (max);
958 if (max == 0)
959 {
960 // If CLZ_DEFINED_VALUE_AT_ZERO is 2 with VALUE of prec,
961 // return [prec, prec], otherwise ignore the range.
962 if (maxi == prec)
963 mini = prec;
964 }
965 else
966 mini = newmini;
967
968 if (mini == -2)
969 return false;
970 r.set (type,
971 wi::shwi (val: mini, TYPE_PRECISION (type)),
972 wi::shwi (val: maxi, TYPE_PRECISION (type)));
973 return true;
974}
975
976// Implement range operator for CFN_BUILT_IN_CTZ
977class cfn_ctz : public range_operator
978{
979public:
980 cfn_ctz (bool internal) { m_gimple_call_internal_p = internal; }
981 using range_operator::fold_range;
982 virtual bool fold_range (irange &r, tree type, const irange &lh,
983 const irange &rh, relation_trio) const;
984private:
985 bool m_gimple_call_internal_p;
986} op_cfn_ctz (false), op_cfn_ctz_internal (true);
987
988bool
989cfn_ctz::fold_range (irange &r, tree type, const irange &lh,
990 const irange &rh, relation_trio) const
991{
992 if (lh.undefined_p ())
993 return false;
994 int prec = TYPE_PRECISION (lh.type ());
995 int mini = 0;
996 int maxi = prec - 1;
997
998 if (m_gimple_call_internal_p)
999 {
1000 // Handle only the two common values.
1001 if (rh.lower_bound () == -1)
1002 mini = -1;
1003 else if (rh.lower_bound () == prec)
1004 maxi = prec;
1005 else
1006 // Magic value to give up, unless we can prove arg is non-zero.
1007 mini = -2;
1008 }
1009 // If arg is non-zero, then use [0, prec - 1].
1010 if (!range_includes_zero_p (vr: &lh))
1011 {
1012 mini = 0;
1013 maxi = prec - 1;
1014 }
1015 // If some high bits are known to be zero, we can decrease
1016 // the maximum.
1017 wide_int max = lh.upper_bound ();
1018 if (max == 0)
1019 {
1020 // Argument is [0, 0]. If CTZ_DEFINED_VALUE_AT_ZERO
1021 // is 2 with value -1 or prec, return [-1, -1] or [prec, prec].
1022 // Otherwise ignore the range.
1023 if (mini == -1)
1024 maxi = -1;
1025 else if (maxi == prec)
1026 mini = prec;
1027 }
1028 // If value at zero is prec and 0 is in the range, we can't lower
1029 // the upper bound. We could create two separate ranges though,
1030 // [0,floor_log2(max)][prec,prec] though.
1031 else if (maxi != prec)
1032 maxi = wi::floor_log2 (max);
1033
1034 if (mini == -2)
1035 return false;
1036 r.set (type,
1037 wi::shwi (val: mini, TYPE_PRECISION (type)),
1038 wi::shwi (val: maxi, TYPE_PRECISION (type)));
1039 return true;
1040}
1041
1042
1043// Implement range operator for CFN_BUILT_IN_
1044class cfn_clrsb : public range_operator
1045{
1046public:
1047 using range_operator::fold_range;
1048 virtual bool fold_range (irange &r, tree type, const irange &lh,
1049 const irange &, relation_trio) const
1050 {
1051 if (lh.undefined_p ())
1052 return false;
1053 int prec = TYPE_PRECISION (lh.type ());
1054 r.set (type,
1055 wi::zero (TYPE_PRECISION (type)),
1056 wi::shwi (val: prec - 1, TYPE_PRECISION (type)));
1057 return true;
1058 }
1059} op_cfn_clrsb;
1060
1061
1062// Implement range operator for CFN_BUILT_IN_
1063class cfn_ubsan : public range_operator
1064{
1065public:
1066 cfn_ubsan (enum tree_code code) { m_code = code; }
1067 using range_operator::fold_range;
1068 virtual bool fold_range (irange &r, tree type, const irange &lh,
1069 const irange &rh, relation_trio rel) const
1070 {
1071 bool saved_flag_wrapv = flag_wrapv;
1072 // Pretend the arithmetic is wrapping. If there is any overflow,
1073 // we'll complain, but will actually do wrapping operation.
1074 flag_wrapv = 1;
1075 bool result = range_op_handler (m_code).fold_range (r, type, lh, rh, rel);
1076 flag_wrapv = saved_flag_wrapv;
1077
1078 // If for both arguments vrp_valueize returned non-NULL, this should
1079 // have been already folded and if not, it wasn't folded because of
1080 // overflow. Avoid removing the UBSAN_CHECK_* calls in that case.
1081 if (result && r.singleton_p ())
1082 r.set_varying (type);
1083 return result;
1084 }
1085private:
1086 enum tree_code m_code;
1087};
1088
1089cfn_ubsan op_cfn_ubsan_add (PLUS_EXPR);
1090cfn_ubsan op_cfn_ubsan_sub (MINUS_EXPR);
1091cfn_ubsan op_cfn_ubsan_mul (MULT_EXPR);
1092
1093
1094// Implement range operator for CFN_BUILT_IN_STRLEN
1095class cfn_strlen : public range_operator
1096{
1097public:
1098 using range_operator::fold_range;
1099 virtual bool fold_range (irange &r, tree type, const irange &,
1100 const irange &, relation_trio) const
1101 {
1102 wide_int max = irange_val_max (ptrdiff_type_node);
1103 // To account for the terminating NULL, the maximum length
1104 // is one less than the maximum array size, which in turn
1105 // is one less than PTRDIFF_MAX (or SIZE_MAX where it's
1106 // smaller than the former type).
1107 // FIXME: Use max_object_size() - 1 here.
1108 r.set (type, wi::zero (TYPE_PRECISION (type)), max - 2);
1109 return true;
1110 }
1111} op_cfn_strlen;
1112
1113
1114// Implement range operator for CFN_BUILT_IN_GOACC_DIM
1115class cfn_goacc_dim : public range_operator
1116{
1117public:
1118 cfn_goacc_dim (bool is_pos) { m_is_pos = is_pos; }
1119 using range_operator::fold_range;
1120 virtual bool fold_range (irange &r, tree type, const irange &lh,
1121 const irange &, relation_trio) const
1122 {
1123 tree axis_tree;
1124 if (!lh.singleton_p (result: &axis_tree))
1125 return false;
1126 HOST_WIDE_INT axis = TREE_INT_CST_LOW (axis_tree);
1127 int size = oacc_get_fn_dim_size (fn: current_function_decl, axis);
1128 if (!size)
1129 // If it's dynamic, the backend might know a hardware limitation.
1130 size = targetm.goacc.dim_limit (axis);
1131
1132 r.set (type,
1133 wi::shwi (val: m_is_pos ? 0 : 1, TYPE_PRECISION (type)),
1134 size
1135 ? wi::shwi (val: size - m_is_pos, TYPE_PRECISION (type))
1136 : irange_val_max (type));
1137 return true;
1138 }
1139private:
1140 bool m_is_pos;
1141} op_cfn_goacc_dim_size (false), op_cfn_goacc_dim_pos (true);
1142
1143
1144// Implement range operator for CFN_BUILT_IN_
1145class cfn_parity : public range_operator
1146{
1147public:
1148 using range_operator::fold_range;
1149 virtual bool fold_range (irange &r, tree type, const irange &,
1150 const irange &, relation_trio) const
1151 {
1152 r = range_true_and_false (type);
1153 return true;
1154 }
1155} op_cfn_parity;
1156
1157// Set up a gimple_range_op_handler for any nonstandard function which can be
1158// supported via range-ops.
1159
1160void
1161gimple_range_op_handler::maybe_non_standard ()
1162{
1163 range_op_handler signed_op (OP_WIDEN_MULT_SIGNED);
1164 gcc_checking_assert (signed_op);
1165 range_op_handler unsigned_op (OP_WIDEN_MULT_UNSIGNED);
1166 gcc_checking_assert (unsigned_op);
1167
1168 if (gimple_code (g: m_stmt) == GIMPLE_ASSIGN)
1169 switch (gimple_assign_rhs_code (gs: m_stmt))
1170 {
1171 case WIDEN_MULT_EXPR:
1172 {
1173 m_op1 = gimple_assign_rhs1 (gs: m_stmt);
1174 m_op2 = gimple_assign_rhs2 (gs: m_stmt);
1175 tree ret = gimple_assign_lhs (gs: m_stmt);
1176 bool signed1 = TYPE_SIGN (TREE_TYPE (m_op1)) == SIGNED;
1177 bool signed2 = TYPE_SIGN (TREE_TYPE (m_op2)) == SIGNED;
1178 bool signed_ret = TYPE_SIGN (TREE_TYPE (ret)) == SIGNED;
1179
1180 /* Normally these operands should all have the same sign, but
1181 some passes and violate this by taking mismatched sign args. At
1182 the moment the only one that's possible is mismatch inputs and
1183 unsigned output. Once ranger supports signs for the operands we
1184 can properly fix it, for now only accept the case we can do
1185 correctly. */
1186 if ((signed1 ^ signed2) && signed_ret)
1187 return;
1188
1189 if (signed2 && !signed1)
1190 std::swap (a&: m_op1, b&: m_op2);
1191
1192 if (signed1 || signed2)
1193 m_operator = signed_op.range_op ();
1194 else
1195 m_operator = unsigned_op.range_op ();
1196 break;
1197 }
1198 default:
1199 break;
1200 }
1201}
1202
1203// Set up a gimple_range_op_handler for any built in function which can be
1204// supported via range-ops.
1205
1206void
1207gimple_range_op_handler::maybe_builtin_call ()
1208{
1209 gcc_checking_assert (is_a <gcall *> (m_stmt));
1210
1211 gcall *call = as_a <gcall *> (p: m_stmt);
1212 combined_fn func = gimple_call_combined_fn (call);
1213 if (func == CFN_LAST)
1214 return;
1215 tree type = gimple_range_type (s: call);
1216 gcc_checking_assert (type);
1217 if (!Value_Range::supports_type_p (type))
1218 return;
1219
1220 switch (func)
1221 {
1222 case CFN_BUILT_IN_CONSTANT_P:
1223 m_op1 = gimple_call_arg (gs: call, index: 0);
1224 if (irange::supports_p (TREE_TYPE (m_op1)))
1225 m_operator = &op_cfn_constant_p;
1226 else if (frange::supports_p (TREE_TYPE (m_op1)))
1227 m_operator = &op_cfn_constant_float_p;
1228 break;
1229
1230 CASE_FLT_FN (CFN_BUILT_IN_SIGNBIT):
1231 m_op1 = gimple_call_arg (gs: call, index: 0);
1232 m_operator = &op_cfn_signbit;
1233 break;
1234
1235 CASE_CFN_COPYSIGN_ALL:
1236 m_op1 = gimple_call_arg (gs: call, index: 0);
1237 m_op2 = gimple_call_arg (gs: call, index: 1);
1238 m_operator = &op_cfn_copysign;
1239 break;
1240
1241 CASE_CFN_SQRT:
1242 CASE_CFN_SQRT_FN:
1243 m_op1 = gimple_call_arg (gs: call, index: 0);
1244 m_operator = &op_cfn_sqrt;
1245 break;
1246
1247 CASE_CFN_SIN:
1248 CASE_CFN_SIN_FN:
1249 m_op1 = gimple_call_arg (gs: call, index: 0);
1250 m_operator = &op_cfn_sin;
1251 break;
1252
1253 CASE_CFN_COS:
1254 CASE_CFN_COS_FN:
1255 m_op1 = gimple_call_arg (gs: call, index: 0);
1256 m_operator = &op_cfn_cos;
1257 break;
1258
1259 case CFN_BUILT_IN_TOUPPER:
1260 case CFN_BUILT_IN_TOLOWER:
1261 // Only proceed If the argument is compatible with the LHS.
1262 m_op1 = gimple_call_arg (gs: call, index: 0);
1263 if (range_compatible_p (type1: type, TREE_TYPE (m_op1)))
1264 m_operator = (func == CFN_BUILT_IN_TOLOWER) ? &op_cfn_tolower
1265 : &op_cfn_toupper;
1266 break;
1267
1268 CASE_CFN_FFS:
1269 m_op1 = gimple_call_arg (gs: call, index: 0);
1270 m_operator = &op_cfn_ffs;
1271 break;
1272
1273 CASE_CFN_POPCOUNT:
1274 m_op1 = gimple_call_arg (gs: call, index: 0);
1275 m_operator = &op_cfn_popcount;
1276 break;
1277
1278 CASE_CFN_CLZ:
1279 m_op1 = gimple_call_arg (gs: call, index: 0);
1280 if (gimple_call_internal_p (gs: call)
1281 && gimple_call_num_args (gs: call) == 2)
1282 {
1283 m_op2 = gimple_call_arg (gs: call, index: 1);
1284 m_operator = &op_cfn_clz_internal;
1285 }
1286 else
1287 m_operator = &op_cfn_clz;
1288 break;
1289
1290 CASE_CFN_CTZ:
1291 m_op1 = gimple_call_arg (gs: call, index: 0);
1292 if (gimple_call_internal_p (gs: call)
1293 && gimple_call_num_args (gs: call) == 2)
1294 {
1295 m_op2 = gimple_call_arg (gs: call, index: 1);
1296 m_operator = &op_cfn_ctz_internal;
1297 }
1298 else
1299 m_operator = &op_cfn_ctz;
1300 break;
1301
1302 CASE_CFN_CLRSB:
1303 m_op1 = gimple_call_arg (gs: call, index: 0);
1304 m_operator = &op_cfn_clrsb;
1305 break;
1306
1307 case CFN_UBSAN_CHECK_ADD:
1308 m_op1 = gimple_call_arg (gs: call, index: 0);
1309 m_op2 = gimple_call_arg (gs: call, index: 1);
1310 m_operator = &op_cfn_ubsan_add;
1311 break;
1312
1313 case CFN_UBSAN_CHECK_SUB:
1314 m_op1 = gimple_call_arg (gs: call, index: 0);
1315 m_op2 = gimple_call_arg (gs: call, index: 1);
1316 m_operator = &op_cfn_ubsan_sub;
1317 break;
1318
1319 case CFN_UBSAN_CHECK_MUL:
1320 m_op1 = gimple_call_arg (gs: call, index: 0);
1321 m_op2 = gimple_call_arg (gs: call, index: 1);
1322 m_operator = &op_cfn_ubsan_mul;
1323 break;
1324
1325 case CFN_BUILT_IN_STRLEN:
1326 {
1327 tree lhs = gimple_call_lhs (gs: call);
1328 if (lhs && ptrdiff_type_node && (TYPE_PRECISION (ptrdiff_type_node)
1329 == TYPE_PRECISION (TREE_TYPE (lhs))))
1330 {
1331 m_op1 = gimple_call_arg (gs: call, index: 0);
1332 m_operator = &op_cfn_strlen;
1333 }
1334 break;
1335 }
1336
1337 // Optimizing these two internal functions helps the loop
1338 // optimizer eliminate outer comparisons. Size is [1,N]
1339 // and pos is [0,N-1].
1340 case CFN_GOACC_DIM_SIZE:
1341 // This call will ensure all the asserts are triggered.
1342 oacc_get_ifn_dim_arg (stmt: call);
1343 m_op1 = gimple_call_arg (gs: call, index: 0);
1344 m_operator = &op_cfn_goacc_dim_size;
1345 break;
1346
1347 case CFN_GOACC_DIM_POS:
1348 // This call will ensure all the asserts are triggered.
1349 oacc_get_ifn_dim_arg (stmt: call);
1350 m_op1 = gimple_call_arg (gs: call, index: 0);
1351 m_operator = &op_cfn_goacc_dim_pos;
1352 break;
1353
1354 CASE_CFN_PARITY:
1355 m_operator = &op_cfn_parity;
1356 break;
1357
1358 default:
1359 {
1360 unsigned arg;
1361 if (gimple_call_fnspec (stmt: call).returns_arg (arg_no: &arg) && arg == 0)
1362 {
1363 m_op1 = gimple_call_arg (gs: call, index: 0);
1364 m_operator = &op_cfn_pass_through_arg1;
1365 }
1366 break;
1367 }
1368 }
1369}
1370

source code of gcc/gimple-range-op.cc