Line data Source code
1 : /* Support routines for vrange storage.
2 : Copyright (C) 2022-2026 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 "tree.h"
26 : #include "gimple.h"
27 : #include "ssa.h"
28 : #include "tree-pretty-print.h"
29 : #include "fold-const.h"
30 : #include "gimple-range.h"
31 : #include "value-range-storage.h"
32 :
33 : // Generic memory allocator to share one interface between GC and
34 : // obstack allocators.
35 :
36 : class vrange_internal_alloc
37 : {
38 : public:
39 111879433 : vrange_internal_alloc () { }
40 111879421 : virtual ~vrange_internal_alloc () { }
41 : virtual void *alloc (size_t size) = 0;
42 : virtual void free (void *) = 0;
43 : private:
44 : DISABLE_COPY_AND_ASSIGN (vrange_internal_alloc);
45 : };
46 :
47 : class vrange_obstack_alloc final: public vrange_internal_alloc
48 : {
49 : public:
50 111591797 : vrange_obstack_alloc ()
51 111591797 : {
52 111591797 : obstack_init (&m_obstack);
53 111591797 : }
54 111591785 : virtual ~vrange_obstack_alloc () final override
55 111591785 : {
56 111591785 : obstack_free (&m_obstack, NULL);
57 111591785 : }
58 382788684 : virtual void *alloc (size_t size) final override
59 : {
60 382788684 : return obstack_alloc (&m_obstack, size);
61 : }
62 0 : virtual void free (void *) final override { }
63 : private:
64 : obstack m_obstack;
65 : };
66 :
67 : class vrange_ggc_alloc final: public vrange_internal_alloc
68 : {
69 : public:
70 287636 : vrange_ggc_alloc () { }
71 287636 : virtual ~vrange_ggc_alloc () final override { }
72 17943327 : virtual void *alloc (size_t size) final override
73 : {
74 17943327 : return ggc_internal_alloc (size);
75 : }
76 0 : virtual void free (void *p) final override
77 : {
78 0 : return ggc_free (p);
79 : }
80 : };
81 :
82 111879433 : vrange_allocator::vrange_allocator (bool gc)
83 : {
84 111879433 : if (gc)
85 287636 : m_alloc = new vrange_ggc_alloc;
86 : else
87 111591797 : m_alloc = new vrange_obstack_alloc;
88 111879433 : }
89 :
90 111879421 : vrange_allocator::~vrange_allocator ()
91 : {
92 111879421 : delete m_alloc;
93 111879421 : }
94 :
95 : void *
96 55661813 : vrange_allocator::alloc (size_t size)
97 : {
98 55661813 : return m_alloc->alloc (size);
99 : }
100 :
101 : void
102 0 : vrange_allocator::free (void *p)
103 : {
104 0 : m_alloc->free (p);
105 0 : }
106 :
107 : // Allocate a new vrange_storage object initialized to R and return
108 : // it.
109 :
110 : vrange_storage *
111 289418701 : vrange_allocator::clone (const vrange &r)
112 : {
113 289418701 : return vrange_storage::alloc (*m_alloc, r);
114 : }
115 :
116 : vrange_storage *
117 27868024 : vrange_allocator::clone_varying (tree type)
118 : {
119 27868024 : if (irange::supports_p (type))
120 17787555 : return irange_storage::alloc (*m_alloc, int_range <1> (type));
121 10080469 : if (prange::supports_p (type))
122 9623382 : return prange_storage::alloc (*m_alloc, prange (type));
123 457087 : if (frange::supports_p (type))
124 457087 : return frange_storage::alloc (*m_alloc, frange (type));
125 : return NULL;
126 : }
127 :
128 : vrange_storage *
129 27783473 : vrange_allocator::clone_undefined (tree type)
130 : {
131 27783473 : if (irange::supports_p (type))
132 17708356 : return irange_storage::alloc (*m_alloc, int_range<1> ());
133 10075117 : if (prange::supports_p (type))
134 9622194 : return prange_storage::alloc (*m_alloc, prange ());
135 452923 : if (frange::supports_p (type))
136 452923 : return frange_storage::alloc (*m_alloc, frange ());
137 : return NULL;
138 : }
139 :
140 : // Allocate a new vrange_storage object initialized to R and return
141 : // it. Return NULL if R is unsupported.
142 :
143 : vrange_storage *
144 289418701 : vrange_storage::alloc (vrange_internal_alloc &allocator, const vrange &r)
145 : {
146 289418701 : if (is_a <irange> (r))
147 203882783 : return irange_storage::alloc (allocator, as_a <irange> (r));
148 85535918 : if (is_a <prange> (r))
149 74258194 : return prange_storage::alloc (allocator, as_a <prange> (r));
150 11277724 : if (is_a <frange> (r))
151 11277724 : return frange_storage::alloc (allocator, as_a <frange> (r));
152 : return NULL;
153 : }
154 :
155 : // Set storage to R.
156 :
157 : void
158 24845176 : vrange_storage::set_vrange (const vrange &r)
159 : {
160 24845176 : if (is_a <irange> (r))
161 : {
162 21088225 : irange_storage *s = static_cast <irange_storage *> (this);
163 21088225 : gcc_checking_assert (s->fits_p (as_a <irange> (r)));
164 21088225 : s->set_irange (as_a <irange> (r));
165 : }
166 3756951 : else if (is_a <prange> (r))
167 : {
168 3137753 : prange_storage *s = static_cast <prange_storage *> (this);
169 3137753 : gcc_checking_assert (s->fits_p (as_a <prange> (r)));
170 3137753 : s->set_prange (as_a <prange> (r));
171 : }
172 619198 : else if (is_a <frange> (r))
173 : {
174 619198 : frange_storage *s = static_cast <frange_storage *> (this);
175 619198 : gcc_checking_assert (s->fits_p (as_a <frange> (r)));
176 619198 : s->set_frange (as_a <frange> (r));
177 : }
178 : else
179 0 : gcc_unreachable ();
180 :
181 : // Verify that reading back from the cache didn't drop bits.
182 24845176 : if (flag_checking
183 : // FIXME: Avoid checking frange, as it currently pessimizes some ranges:
184 : //
185 : // gfortran.dg/pr49472.f90 pessimizes [0.0, 1.0] into [-0.0, 1.0].
186 24845103 : && !is_a <frange> (r)
187 49071081 : && !r.undefined_p ())
188 : {
189 24113025 : value_range tmp (r);
190 24113025 : get_vrange (tmp, r.type ());
191 24113025 : gcc_checking_assert (tmp == r);
192 24113025 : }
193 24845176 : }
194 :
195 : // Restore R from storage.
196 :
197 : void
198 1687391537 : vrange_storage::get_vrange (vrange &r, tree type) const
199 : {
200 1687391537 : if (is_a <irange> (r))
201 : {
202 1299675472 : const irange_storage *s = static_cast <const irange_storage *> (this);
203 1299675472 : s->get_irange (as_a <irange> (r), type);
204 : }
205 387716065 : else if (is_a <prange> (r))
206 : {
207 342065345 : const prange_storage *s = static_cast <const prange_storage *> (this);
208 342065345 : s->get_prange (as_a <prange> (r), type);
209 : }
210 45650720 : else if (is_a <frange> (r))
211 : {
212 45650720 : const frange_storage *s = static_cast <const frange_storage *> (this);
213 45650720 : s->get_frange (as_a <frange> (r), type);
214 : }
215 : else
216 0 : gcc_unreachable ();
217 1687391537 : }
218 :
219 : // Return TRUE if storage can fit R.
220 :
221 : bool
222 28864975 : vrange_storage::fits_p (const vrange &r) const
223 : {
224 28864975 : if (is_a <irange> (r))
225 : {
226 25118045 : const irange_storage *s = static_cast <const irange_storage *> (this);
227 25118045 : return s->fits_p (as_a <irange> (r));
228 : }
229 3746930 : if (is_a <prange> (r))
230 : {
231 3128151 : const prange_storage *s = static_cast <const prange_storage *> (this);
232 3128151 : return s->fits_p (as_a <prange> (r));
233 : }
234 618779 : if (is_a <frange> (r))
235 : {
236 618779 : const frange_storage *s = static_cast <const frange_storage *> (this);
237 618779 : return s->fits_p (as_a <frange> (r));
238 : }
239 0 : gcc_unreachable ();
240 : return false;
241 : }
242 :
243 : // Return TRUE if the range in storage is equal to R. It is the
244 : // caller's responsibility to verify that the type of the range in
245 : // storage matches that of R.
246 :
247 : bool
248 9663870 : vrange_storage::equal_p (const vrange &r) const
249 : {
250 9663870 : if (is_a <irange> (r))
251 : {
252 4628792 : const irange_storage *s = static_cast <const irange_storage *> (this);
253 4628792 : return s->equal_p (as_a <irange> (r));
254 : }
255 5035078 : if (is_a <prange> (r))
256 : {
257 5015866 : const prange_storage *s = static_cast <const prange_storage *> (this);
258 5015866 : return s->equal_p (as_a <prange> (r));
259 : }
260 19212 : if (is_a <frange> (r))
261 : {
262 19212 : const frange_storage *s = static_cast <const frange_storage *> (this);
263 19212 : return s->equal_p (as_a <frange> (r));
264 : }
265 0 : gcc_unreachable ();
266 : }
267 :
268 : //============================================================================
269 : // irange_storage implementation
270 : //============================================================================
271 :
272 : unsigned short *
273 1040412441 : irange_storage::write_lengths_address ()
274 : {
275 1040412441 : return (unsigned short *)&m_val[(m_num_ranges * 2 + 2)
276 1040412441 : * WIDE_INT_MAX_HWIS (m_precision)];
277 : }
278 :
279 : const unsigned short *
280 906880982 : irange_storage::lengths_address () const
281 : {
282 906880982 : return const_cast <irange_storage *> (this)->write_lengths_address ();
283 : }
284 :
285 : // Allocate a new irange_storage object initialized to R.
286 :
287 : irange_storage *
288 239378694 : irange_storage::alloc (vrange_internal_alloc &allocator, const irange &r)
289 : {
290 239378694 : size_t size = irange_storage::size (r);
291 239378694 : irange_storage *p = static_cast <irange_storage *> (allocator.alloc (size));
292 239378694 : new (p) irange_storage (r);
293 239378694 : return p;
294 : }
295 :
296 : // Initialize the storage with R.
297 :
298 239378694 : irange_storage::irange_storage (const irange &r)
299 239378694 : : m_max_ranges (r.num_pairs ())
300 : {
301 239378694 : m_num_ranges = m_max_ranges;
302 239378694 : set_irange (r);
303 239378694 : }
304 :
305 : static inline void
306 640234188 : write_wide_int (HOST_WIDE_INT *&val, unsigned short *&len, const wide_int &w)
307 : {
308 640234188 : *len = w.get_len ();
309 1281332372 : for (unsigned i = 0; i < *len; ++i)
310 641098184 : *val++ = w.elt (i);
311 640234188 : ++len;
312 640234188 : }
313 :
314 : // Store R into the current storage.
315 :
316 : void
317 260466919 : irange_storage::set_irange (const irange &r)
318 : {
319 260466919 : gcc_checking_assert (fits_p (r));
320 :
321 260466919 : if (r.undefined_p ())
322 : {
323 18081279 : m_kind = VR_UNDEFINED;
324 126935460 : return;
325 : }
326 242385640 : if (r.varying_p ())
327 : {
328 108854181 : m_kind = VR_VARYING;
329 108854181 : return;
330 : }
331 :
332 133531459 : m_precision = TYPE_PRECISION (r.type ());
333 133531459 : m_num_ranges = r.num_pairs ();
334 133531459 : m_kind = VR_RANGE;
335 :
336 133531459 : HOST_WIDE_INT *val = &m_val[0];
337 133531459 : unsigned short *len = write_lengths_address ();
338 :
339 320117094 : for (unsigned i = 0; i < r.num_pairs (); ++i)
340 : {
341 186585635 : write_wide_int (val, len, r.lower_bound (i));
342 186588057 : write_wide_int (val, len, r.upper_bound (i));
343 : }
344 :
345 : // TODO: We could avoid streaming out the value if the mask is -1.
346 133531459 : irange_bitmask bm = r.m_bitmask;
347 133531459 : write_wide_int (val, len, bm.value ());
348 133531459 : write_wide_int (val, len, bm.mask ());
349 133531459 : }
350 :
351 : static inline void
352 4370845840 : read_wide_int (wide_int &w,
353 : const HOST_WIDE_INT *val, unsigned short len, unsigned prec)
354 : {
355 4370845840 : trailing_wide_int_storage stow (prec, &len,
356 1088028835 : const_cast <HOST_WIDE_INT *> (val));
357 3282817005 : w = trailing_wide_int (stow);
358 : }
359 :
360 : // Restore a range of TYPE from storage into R.
361 :
362 : void
363 1303891285 : irange_storage::get_irange (irange &r, tree type) const
364 : {
365 1303891285 : if (m_kind == VR_UNDEFINED)
366 : {
367 10301961 : r.set_undefined ();
368 407312264 : return;
369 : }
370 1293589324 : if (m_kind == VR_VARYING)
371 : {
372 386708342 : r.set_varying (type);
373 386708342 : return;
374 : }
375 :
376 906880982 : gcc_checking_assert (TYPE_PRECISION (type) == m_precision);
377 906880982 : const HOST_WIDE_INT *val = &m_val[0];
378 906880982 : const unsigned short *len = lengths_address ();
379 :
380 : // Handle the common case where R can fit the new range.
381 906880982 : if (r.m_max_ranges >= m_num_ranges)
382 : {
383 875700395 : r.m_kind = VR_RANGE;
384 875700395 : r.m_num_ranges = m_num_ranges;
385 875700395 : r.m_type = type;
386 3070488565 : for (unsigned i = 0; i < m_num_ranges * 2; ++i)
387 : {
388 2194788170 : read_wide_int (r.m_base[i], val, *len, m_precision);
389 2194788170 : val += *len++;
390 : }
391 : }
392 : // Otherwise build the range piecewise.
393 : else
394 : {
395 31180587 : r.set_undefined ();
396 212328440 : for (unsigned i = 0; i < m_num_ranges; ++i)
397 : {
398 181147853 : wide_int lb, ub;
399 181147853 : read_wide_int (lb, val, *len, m_precision);
400 181147853 : val += *len++;
401 181147853 : read_wide_int (ub, val, *len, m_precision);
402 181147853 : val += *len++;
403 181147853 : int_range<1> tmp (type, lb, ub);
404 181147853 : r.union_ (tmp);
405 181147853 : }
406 : }
407 :
408 906880982 : wide_int bits_value, bits_mask;
409 906880982 : read_wide_int (bits_value, val, *len, m_precision);
410 906880982 : val += *len++;
411 906880982 : read_wide_int (bits_mask, val, *len, m_precision);
412 906880982 : r.m_bitmask = irange_bitmask (bits_value, bits_mask);
413 906880982 : if (r.m_kind == VR_VARYING)
414 0 : r.m_kind = VR_RANGE;
415 :
416 906880982 : if (flag_checking)
417 906877449 : r.verify_range ();
418 906888002 : }
419 :
420 : bool
421 4628792 : irange_storage::equal_p (const irange &r) const
422 : {
423 4628792 : if (m_kind == VR_UNDEFINED || r.undefined_p ())
424 0 : return m_kind == r.m_kind;
425 4628792 : if (m_kind == VR_VARYING || r.varying_p ())
426 412979 : return m_kind == r.m_kind;
427 :
428 : // ?? We could make this faster by doing the comparison in place,
429 : // without going through get_irange.
430 4215813 : int_range_max tmp;
431 4215813 : get_irange (tmp, r.type ());
432 4215813 : return tmp == r;
433 4215813 : }
434 :
435 : // Return the size in bytes to allocate storage that can hold R.
436 :
437 : size_t
438 239378694 : irange_storage::size (const irange &r)
439 : {
440 239378694 : if (r.undefined_p ())
441 : return sizeof (irange_storage);
442 :
443 221404677 : unsigned prec = TYPE_PRECISION (r.type ());
444 221404677 : unsigned n = r.num_pairs () * 2 + 2;
445 221404677 : unsigned hwi_size = ((n * WIDE_INT_MAX_HWIS (prec) - 1)
446 : * sizeof (HOST_WIDE_INT));
447 221404677 : unsigned len_size = n * sizeof (unsigned short);
448 221404677 : return sizeof (irange_storage) + hwi_size + len_size;
449 : }
450 :
451 : // Return TRUE if R fits in the current storage.
452 :
453 : bool
454 306673189 : irange_storage::fits_p (const irange &r) const
455 : {
456 306673189 : return m_max_ranges >= r.num_pairs ();
457 : }
458 :
459 : void
460 0 : irange_storage::dump () const
461 : {
462 0 : fprintf (stderr, "irange_storage (prec=%d, ranges=%d):\n",
463 0 : m_precision, m_num_ranges);
464 :
465 0 : if (m_num_ranges == 0)
466 : return;
467 :
468 0 : const HOST_WIDE_INT *val = &m_val[0];
469 0 : const unsigned short *len = lengths_address ();
470 0 : int i, j;
471 :
472 0 : fprintf (stderr, " lengths = [ ");
473 0 : for (i = 0; i < m_num_ranges * 2 + 2; ++i)
474 0 : fprintf (stderr, "%d ", len[i]);
475 0 : fprintf (stderr, "]\n");
476 :
477 0 : for (i = 0; i < m_num_ranges; ++i)
478 : {
479 0 : for (j = 0; j < *len; ++j)
480 0 : fprintf (stderr, " [PAIR %d] LB " HOST_WIDE_INT_PRINT_DEC "\n", i,
481 0 : *val++);
482 0 : ++len;
483 0 : for (j = 0; j < *len; ++j)
484 0 : fprintf (stderr, " [PAIR %d] UB " HOST_WIDE_INT_PRINT_DEC "\n", i,
485 0 : *val++);
486 0 : ++len;
487 : }
488 :
489 : // Dump value/mask pair.
490 0 : for (j = 0; j < *len; ++j)
491 0 : fprintf (stderr, " [VALUE] " HOST_WIDE_INT_PRINT_DEC "\n", *val++);
492 0 : ++len;
493 0 : for (j = 0; j < *len; ++j)
494 0 : fprintf (stderr, " [MASK] " HOST_WIDE_INT_PRINT_DEC "\n", *val++);
495 : }
496 :
497 : DEBUG_FUNCTION void
498 0 : debug (const irange_storage &storage)
499 : {
500 0 : storage.dump ();
501 0 : fprintf (stderr, "\n");
502 0 : }
503 :
504 : //============================================================================
505 : // frange_storage implementation
506 : //============================================================================
507 :
508 : // Allocate a new frange_storage object initialized to R.
509 :
510 : frange_storage *
511 12187734 : frange_storage::alloc (vrange_internal_alloc &allocator, const frange &r)
512 : {
513 12187734 : size_t size = sizeof (frange_storage);
514 12187734 : frange_storage *p = static_cast <frange_storage *> (allocator.alloc (size));
515 12187734 : new (p) frange_storage (r);
516 12187734 : return p;
517 : }
518 :
519 : void
520 12806932 : frange_storage::set_frange (const frange &r)
521 : {
522 12806932 : gcc_checking_assert (fits_p (r));
523 :
524 12806932 : m_kind = r.m_kind;
525 12806932 : m_min = r.m_min;
526 12806932 : m_max = r.m_max;
527 12806932 : m_pos_nan = r.m_pos_nan;
528 12806932 : m_neg_nan = r.m_neg_nan;
529 12806932 : }
530 :
531 : void
532 45669932 : frange_storage::get_frange (frange &r, tree type) const
533 : {
534 45669932 : gcc_checking_assert (r.supports_type_p (type));
535 :
536 : // Handle explicit NANs.
537 45669932 : if (m_kind == VR_NAN)
538 : {
539 105605 : if (HONOR_NANS (type))
540 : {
541 105605 : if (m_pos_nan && m_neg_nan)
542 100069 : r.set_nan (type);
543 : else
544 5536 : r.set_nan (type, m_neg_nan);
545 : }
546 : else
547 0 : r.set_undefined ();
548 105605 : return;
549 : }
550 45564327 : if (m_kind == VR_UNDEFINED)
551 : {
552 67661 : r.set_undefined ();
553 67661 : return;
554 : }
555 :
556 : // We use the constructor to create the new range instead of writing
557 : // out the bits into the frange directly, because the global range
558 : // being read may be being inlined into a function with different
559 : // restrictions as when it was originally written. We want to make
560 : // sure the resulting range is canonicalized correctly for the new
561 : // consumer.
562 45496666 : r = frange (type, m_min, m_max, m_kind);
563 :
564 : // The constructor will set the NAN bits for HONOR_NANS, but we must
565 : // make sure to set the NAN sign if known.
566 45496666 : if (HONOR_NANS (type) && (m_pos_nan ^ m_neg_nan) == 1)
567 1258674 : r.update_nan (m_neg_nan);
568 44237992 : else if (!m_pos_nan && !m_neg_nan)
569 11820158 : r.clear_nan ();
570 : }
571 :
572 : bool
573 19212 : frange_storage::equal_p (const frange &r) const
574 : {
575 19212 : if (r.undefined_p ())
576 0 : return m_kind == VR_UNDEFINED;
577 :
578 19212 : frange tmp;
579 19212 : get_frange (tmp, r.type ());
580 19212 : return tmp == r;
581 19212 : }
582 :
583 : bool
584 14044909 : frange_storage::fits_p (const frange &) const
585 : {
586 14044909 : return true;
587 : }
588 :
589 : //============================================================================
590 : // prange_storage implementation
591 : //============================================================================
592 :
593 : prange_storage *
594 93503770 : prange_storage::alloc (vrange_internal_alloc &allocator, const prange &r)
595 : {
596 93503770 : prange_format format (r);
597 93503770 : size_t size = sizeof (prange_storage) + format.extra_size;
598 93503770 : prange_storage *p = static_cast <prange_storage *> (allocator.alloc (size));
599 93503770 : new (p) prange_storage (r);
600 93503770 : return p;
601 : }
602 :
603 : // Initialize the storage with R.
604 :
605 93503770 : prange_storage::prange_storage (const prange &r)
606 : {
607 93503770 : prange_format format (r);
608 93503770 : m_trailing_ints.set_precision (format.precision, format.num_words);
609 93503770 : set_prange (r);
610 93503770 : }
611 :
612 : // FIll the format structure for range R.
613 :
614 289903697 : prange_storage::prange_format::prange_format (const prange &r)
615 : {
616 289903697 : kind = PR_UNDEFINED;
617 289903697 : has_bitmask = 0;
618 289903697 : extra_size = 0;
619 289903697 : precision = 0;
620 289903697 : num_words = 0;
621 :
622 289903697 : if (r.undefined_p ())
623 : return;
624 :
625 260930113 : if (r.varying_p ())
626 : {
627 141618462 : kind = PR_VARYING;
628 141618462 : return;
629 : }
630 :
631 119311651 : if (r.zero_p ())
632 : {
633 710478 : kind = PR_ZERO;
634 710478 : return;
635 : }
636 :
637 118601173 : if (r.nonzero_p ())
638 116075785 : kind = PR_NONZERO;
639 : else
640 : {
641 2525388 : prange tmp (r.type ());
642 5050776 : if (r.lower_bound () == tmp.lower_bound ()
643 3613860 : && r.upper_bound () == tmp.upper_bound ())
644 65581 : kind = PR_FULL;
645 : else
646 : {
647 : // PR_OTHER requires words of storage for the end points.
648 2459807 : kind = PR_OTHER;
649 2459807 : num_words += 2;
650 : }
651 2525388 : }
652 118601173 : precision = TYPE_PRECISION (r.type ());
653 118601173 : has_bitmask = !r.get_bitmask ().unknown_p ();
654 :
655 : // Bitmasks require 2 words of storage.
656 118601173 : if (has_bitmask)
657 1431544 : num_words += 2;
658 :
659 118601173 : if (num_words != 0)
660 3467739 : extra_size = trailing_wide_ints<NINTS>::extra_size (precision, num_words);
661 :
662 : // PR_FULL must have a bitmask, or it should be PR_VARYING.
663 118601173 : gcc_checking_assert (kind != PR_FULL || has_bitmask);
664 : }
665 :
666 : void
667 96641523 : prange_storage::set_prange (const prange &r)
668 : {
669 96641523 : prange_format format (r);
670 96641523 : m_kind = format.kind;
671 96641523 : m_has_bitmask = format.has_bitmask;
672 96641523 : unsigned index = 0;
673 :
674 96641523 : switch (m_kind)
675 : {
676 57105842 : case PR_UNDEFINED:
677 57105842 : case PR_VARYING:
678 57105842 : case PR_ZERO:
679 57105842 : return;
680 : case PR_NONZERO:
681 : case PR_FULL:
682 : break;
683 761423 : case PR_OTHER:
684 761423 : set_word (index++, r.lower_bound (), r.type ());
685 761423 : set_word (index++, r.upper_bound (), r.type ());
686 761423 : break;
687 0 : default:
688 0 : gcc_unreachable ();
689 : }
690 :
691 39535681 : if (m_has_bitmask)
692 : {
693 485437 : irange_bitmask bm = r.m_bitmask;
694 485437 : set_word (index++, r.m_bitmask.value (), r.type ());
695 485437 : set_word (index++, r.m_bitmask.mask (), r.type ());
696 485437 : }
697 39535681 : gcc_checking_assert (index == format.num_words);
698 : }
699 :
700 : void
701 347081211 : prange_storage::get_prange (prange &r, tree type) const
702 : {
703 347081211 : gcc_checking_assert (r.supports_type_p (type));
704 347081211 : unsigned index = 0;
705 347081211 : switch (m_kind)
706 : {
707 988163 : case PR_UNDEFINED:
708 988163 : r.set_undefined ();
709 988163 : return;
710 :
711 196906809 : case PR_VARYING:
712 196906809 : r.set_varying (type);
713 196906809 : return;
714 :
715 1415080 : case PR_ZERO:
716 1415080 : r.set_zero (type);
717 1415080 : return;
718 :
719 144940826 : case PR_NONZERO:
720 144940826 : r.set_nonzero (type);
721 144940826 : break;
722 :
723 236881 : case PR_FULL:
724 236881 : {
725 236881 : r.m_kind = VR_RANGE;
726 236881 : r.m_type = type;
727 236881 : prange tmp (type);
728 236881 : r.m_min = tmp.lower_bound ();
729 236881 : r.m_max = tmp.upper_bound ();
730 236881 : break;
731 236881 : }
732 :
733 2593452 : case PR_OTHER:
734 2593452 : {
735 2593452 : gcc_checking_assert (m_kind == PR_OTHER);
736 2593452 : r.m_kind = VR_RANGE;
737 2593452 : r.m_type = type;
738 2593452 : r.m_min = get_word (index++, type);
739 2593452 : r.m_max = get_word (index++, type);
740 2593452 : break;
741 : }
742 0 : default:
743 0 : gcc_unreachable ();
744 : }
745 :
746 147771159 : if (m_has_bitmask)
747 : {
748 10979237 : wide_int value = get_word (index++, type);
749 10979237 : wide_int mask = get_word (index++, type);
750 10979237 : r.m_bitmask = irange_bitmask (value, mask);
751 10979237 : }
752 : else
753 136791922 : r.m_bitmask.set_unknown (TYPE_PRECISION (type));
754 :
755 147771159 : if (flag_checking)
756 147771021 : r.verify_range ();
757 : }
758 :
759 : bool
760 5015866 : prange_storage::equal_p (const prange &r) const
761 : {
762 5015866 : if (r.undefined_p ())
763 0 : return m_kind == PR_UNDEFINED;
764 :
765 5015866 : prange tmp;
766 5015866 : get_prange (tmp, r.type ());
767 5015866 : return tmp == r;
768 5015866 : }
769 :
770 : bool
771 6265904 : prange_storage::fits_p (const prange &r) const
772 : {
773 : // Undefined ranges always fit, because they don't store anything in
774 : // the trailing wide ints.
775 6265904 : if (r.undefined_p ())
776 : return true;
777 :
778 6254634 : prange_format f (r);
779 6254634 : unsigned prec = m_trailing_ints.get_precision ();
780 6254634 : unsigned num = m_trailing_ints.num_elements ();
781 6254634 : size_t curr = num ? trailing_wide_ints<NINTS>::extra_size (prec, num) : 0;
782 6254634 : return f.extra_size <= curr;
783 : }
784 :
785 :
786 : static vrange_allocator ggc_vrange_allocator (true);
787 :
788 0 : vrange_storage *ggc_alloc_vrange_storage (tree type)
789 : {
790 0 : return ggc_vrange_allocator.clone_varying (type);
791 : }
792 :
793 17943327 : vrange_storage *ggc_alloc_vrange_storage (const vrange &r)
794 : {
795 17943327 : return ggc_vrange_allocator.clone (r);
796 : }
|
