Line data Source code
1 : /* Unit-safe concrete ranges of values (e.g. "bits 16-31", "bytes 0-1023").
2 : Copyright (C) 2019-2026 Free Software Foundation, Inc.
3 : Contributed by David Malcolm <dmalcolm@redhat.com>.
4 :
5 : This file is part of GCC.
6 :
7 : GCC is free software; you can redistribute it and/or modify it
8 : 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, but
13 : WITHOUT ANY WARRANTY; without even the implied warranty of
14 : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 : 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 "analyzer/common.h"
22 :
23 : #include "selftest.h"
24 :
25 : #include "diagnostics/markup.h"
26 :
27 : #include "analyzer/concrete-ranges.h"
28 :
29 : #if ENABLE_ANALYZER
30 :
31 : namespace ana {
32 :
33 : template <typename ConcreteValueType>
34 : static void
35 : dump_any_singular_name (pretty_printer *);
36 :
37 : template <>
38 : void
39 0 : dump_any_singular_name<integer> (pretty_printer *)
40 : {
41 : // no-op
42 0 : }
43 :
44 : template <>
45 : void
46 0 : dump_any_singular_name<integer_with_unit<units::bit>> (pretty_printer *pp)
47 : {
48 0 : pp_string (pp, "bit ");
49 0 : }
50 :
51 : template <>
52 : void
53 144 : dump_any_singular_name<integer_with_unit<units::byte>> (pretty_printer *pp)
54 : {
55 144 : pp_string (pp, "byte ");
56 0 : }
57 :
58 : template <typename ConcreteValueType>
59 : static void
60 : dump_any_plural_name (pretty_printer *);
61 :
62 : template <>
63 : void
64 0 : dump_any_plural_name<integer> (pretty_printer *)
65 : {
66 : // no-op
67 0 : }
68 :
69 : template <>
70 : void
71 276 : dump_any_plural_name<integer_with_unit<units::bit>> (pretty_printer *pp)
72 : {
73 276 : pp_string (pp, "bits ");
74 0 : }
75 :
76 : template <>
77 : void
78 1422 : dump_any_plural_name<integer_with_unit<units::byte>> (pretty_printer *pp)
79 : {
80 1422 : pp_string (pp, "bytes ");
81 0 : }
82 :
83 : template<typename ConcreteValueType>
84 : void
85 1842 : concrete::range<ConcreteValueType>::dump_to_pp (pretty_printer *pp) const
86 : {
87 1842 : pp_character (pp, '[');
88 1842 : if (m_size.get_integer () == 0)
89 : {
90 0 : pp_character (pp, ']');
91 0 : return;
92 : }
93 1842 : if (m_size.get_integer () == 1)
94 : {
95 144 : dump_any_singular_name<ConcreteValueType> (pp);
96 144 : m_start_offset.dump_to_pp (pp);
97 144 : pp_character (pp, ']');
98 144 : return;
99 : }
100 1698 : dump_any_plural_name<ConcreteValueType> (pp);
101 1698 : m_start_offset.dump_to_pp (pp);
102 1698 : pp_string (pp, "..");
103 1698 : get_next_offset ().dump_to_pp (pp);
104 1698 : pp_character (pp, ')');
105 : }
106 :
107 : /* "_pretty" variant. Same for bytes */
108 :
109 : template<>
110 : void
111 0 : concrete_byte_range::dump_to_pp_pretty (pretty_printer *pp) const
112 : {
113 0 : dump_to_pp (pp);
114 0 : }
115 :
116 : // ...but for bits, try to express as bytes if possible:
117 :
118 : template<>
119 : void
120 1570 : concrete_bit_range::dump_to_pp_pretty (pretty_printer *pp) const
121 : {
122 1570 : concrete::range<integer_with_unit<units::byte>> byte_range;
123 3140 : if (maybe_bytes_from_bits (*this, &byte_range))
124 1566 : byte_range.dump_to_pp (pp);
125 : else
126 4 : dump_to_pp (pp);
127 1570 : }
128 :
129 : template<>
130 : DEBUG_FUNCTION void
131 0 : concrete_bit_range::dump () const
132 : {
133 0 : pretty_printer pp;
134 0 : pp.set_output_stream (stderr);
135 0 : dump_to_pp_pretty (&pp);
136 0 : pp_newline (&pp);
137 0 : pp_flush (&pp);
138 0 : }
139 :
140 : template<>
141 : DEBUG_FUNCTION void
142 0 : concrete_byte_range::dump () const
143 : {
144 0 : pretty_printer pp;
145 0 : pp.set_output_stream (stderr);
146 0 : dump_to_pp_pretty (&pp);
147 0 : pp_newline (&pp);
148 0 : pp_flush (&pp);
149 0 : }
150 :
151 : template<typename ConcreteValueType>
152 : int
153 2133150 : concrete::range<ConcreteValueType>::cmp (const range &lhs,
154 : const range &rhs)
155 : {
156 2133150 : if (int c = ConcreteValueType::cmp (lhs.get_start_offset (),
157 4266300 : rhs.get_start_offset ()))
158 : return c;
159 1503761 : return ConcreteValueType::cmp (lhs.get_size (),
160 3007522 : rhs.get_size ());
161 : }
162 :
163 : template<typename ConcreteValueType>
164 : bool
165 2552068 : concrete::range<ConcreteValueType>::intersects_p (const range &other,
166 : range *out) const
167 : {
168 2552068 : if (get_start_offset () >= other.get_next_offset ())
169 : return false;
170 2352604 : if (get_next_offset () <= other.get_start_offset ())
171 : return false;
172 2193563 : if (out)
173 : {
174 4386894 : ConcreteValueType overlap_start
175 4386894 : = std::max (get_start_offset (),
176 2193447 : other.get_start_offset ());
177 4386894 : ConcreteValueType overlap_next
178 4386894 : = std::min (get_next_offset (),
179 4386894 : other.get_next_offset ());
180 2193447 : gcc_assert (overlap_next > overlap_start);
181 6580341 : *out = range<ConcreteValueType> (overlap_start, overlap_next - overlap_start);
182 2193447 : }
183 : return true;
184 : }
185 :
186 : template
187 : bool concrete_bit_range::intersects_p (const concrete_bit_range &other,
188 : concrete_bit_range *out) const;
189 :
190 : /* Return true if any part of THIS is >= OFFSET, and write the overhanging
191 : range to *OUT. */
192 :
193 : template<typename ConcreteValueType>
194 : bool
195 616755 : concrete::range<ConcreteValueType>::
196 : exceeds_p (ConcreteValueType offset,
197 : range<ConcreteValueType> *out) const
198 : {
199 616755 : ConcreteValueType next_offset = get_next_offset ();
200 616755 : if (next_offset > offset)
201 : {
202 : /* THIS exceeds OFFSET. */
203 637 : auto start = std::max (get_start_offset (), offset);
204 509 : auto size = next_offset - start;
205 1527 : *out = range<ConcreteValueType> (start, size);
206 509 : return true;
207 509 : }
208 : return false;
209 616755 : }
210 :
211 : template
212 : bool concrete_bit_range::exceeds_p (integer_with_unit<units::bit>,
213 : concrete_bit_range *) const;
214 :
215 : /* Return true if any part of this THIS < OFFSET and write the
216 : bit range fallen short to *OUT. */
217 :
218 : template<typename ConcreteValueType>
219 : bool
220 622369 : concrete::range<ConcreteValueType>::
221 : falls_short_of_p (ConcreteValueType offset,
222 : range<ConcreteValueType> *out) const
223 : {
224 622369 : ConcreteValueType start_offset = get_start_offset ();
225 622369 : if (start_offset < offset)
226 : {
227 : /* THIS falls short of OFFSET. */
228 225 : auto start = start_offset;
229 357 : auto size = std::min (offset, get_next_offset ()) - start;
230 675 : *out = range<ConcreteValueType> (start, size);
231 225 : return true;
232 225 : }
233 : return false;
234 622369 : }
235 :
236 : template
237 : bool concrete_bit_range::falls_short_of_p (integer_with_unit<units::bit>,
238 : concrete_bit_range *) const;
239 :
240 : template<typename ConcreteValueType>
241 : std::unique_ptr<json::object>
242 88 : concrete::range<ConcreteValueType>::to_json () const
243 : {
244 88 : auto obj = std::make_unique<json::object> ();
245 88 : obj->set ("start_offset", m_start_offset.to_json ());
246 88 : obj->set ("size", m_size.to_json ());
247 88 : return obj;
248 : }
249 :
250 : template
251 : std::unique_ptr<json::object>
252 : concrete_bit_range::to_json () const;
253 :
254 : template<typename ConcreteValueType>
255 : std::unique_ptr<diagnostics::markup::node>
256 8 : concrete::range<ConcreteValueType>::
257 : make_markup_node () const
258 : {
259 : return std::make_unique<diagnostics::markup::math::half_open_interval>
260 8 : (m_start_offset.make_markup_node (),
261 24 : get_next_offset ().make_markup_node ());
262 : }
263 :
264 : template
265 : std::unique_ptr<diagnostics::markup::node>
266 : concrete_bit_range::make_markup_node () const;
267 :
268 : bool
269 7856 : maybe_bytes_from_bits (concrete::range<integer_with_unit<units::bit>> bits,
270 : concrete::range<integer_with_unit<units::byte>> *out)
271 : {
272 7856 : integer_with_unit<units::byte> start_byte_offset;
273 7856 : if (!maybe_bytes_from_bits (bits.get_start_offset (),
274 : &start_byte_offset))
275 : return false;
276 7856 : integer_with_unit<units::byte> byte_size;
277 7856 : if (!maybe_bytes_from_bits (bits.get_size (),
278 : &byte_size))
279 : return false;
280 15640 : *out = concrete::range<integer_with_unit<units::byte>> (start_byte_offset,
281 23460 : byte_size);
282 7820 : return true;
283 7856 : }
284 :
285 : /* If MASK is a contiguous range of set bits, write them
286 : to *OUT and return true.
287 : Otherwise return false. */
288 :
289 : bool
290 88 : concrete_bit_range_from_mask (unsigned HOST_WIDE_INT mask,
291 : concrete_bit_range *out)
292 : {
293 88 : concrete_bit_offset iter_bit_idx = 0_bits;
294 88 : unsigned HOST_WIDE_INT iter_bit_mask = 1;
295 :
296 88 : concrete_bit_size host_bits_per_wide_int (HOST_BITS_PER_WIDE_INT);
297 :
298 : /* Find the first contiguous run of set bits in MASK. */
299 :
300 : /* Find first set bit in MASK. */
301 644 : while (iter_bit_idx < host_bits_per_wide_int)
302 : {
303 552 : if (mask & iter_bit_mask)
304 : break;
305 468 : iter_bit_idx += 1_bit;
306 468 : iter_bit_mask <<= 1;
307 : }
308 88 : if (iter_bit_idx == host_bits_per_wide_int)
309 : /* MASK is zero. */
310 : return false;
311 :
312 84 : concrete_bit_offset first_set_iter_bit_idx (iter_bit_idx);
313 84 : concrete_bit_size num_set_bits = 1_bit;
314 84 : iter_bit_idx += 1_bit;
315 84 : iter_bit_mask <<= 1;
316 :
317 : /* Find next unset bit in MASK. */
318 284 : while (iter_bit_idx < host_bits_per_wide_int)
319 : {
320 284 : if (!(mask & iter_bit_mask))
321 : break;
322 200 : num_set_bits += 1_bit;
323 200 : iter_bit_idx += 1_bit;
324 200 : iter_bit_mask <<= 1;
325 : }
326 84 : if (iter_bit_idx == host_bits_per_wide_int)
327 : {
328 0 : *out = concrete_bit_range (first_set_iter_bit_idx, num_set_bits);
329 0 : return true;
330 : }
331 :
332 : /* We now have the first contiguous run of set bits in MASK.
333 : Fail if any other bits are set. */
334 4532 : while (iter_bit_idx < host_bits_per_wide_int)
335 : {
336 4456 : if (mask & iter_bit_mask)
337 : return false;
338 4448 : iter_bit_idx += 1_bit;
339 4448 : iter_bit_mask <<= 1;
340 : }
341 :
342 228 : *out = concrete_bit_range (first_set_iter_bit_idx, num_set_bits);
343 76 : return true;
344 172 : }
345 :
346 : void
347 13994 : get_smallest_enclosing_byte_range (const concrete_bit_range &in_bit_range,
348 : concrete_byte_range *out_byte_range,
349 : concrete_bit_offset *out_bit_offset)
350 : {
351 41982 : auto round_bit_to_lowest_byte = [](concrete_bit_offset bit_offset)
352 : -> concrete_byte_offset
353 : {
354 27988 : return concrete_byte_offset
355 27988 : (bit_offset.get_integer ().floor_div (BITS_PER_UNIT));
356 : };
357 27988 : auto bit_within_byte = [](concrete_bit_offset bit_offset)
358 : -> concrete_bit_offset
359 : {
360 13994 : return concrete_bit_offset
361 13994 : (bit_offset.get_integer ().floor_mod (BITS_PER_UNIT));
362 : };
363 :
364 27988 : *out_byte_range = concrete_byte_range
365 27988 : (round_bit_to_lowest_byte (in_bit_range.get_start_offset ()),
366 41982 : round_bit_to_lowest_byte (in_bit_range.get_size () + 7_bits));
367 13994 : *out_bit_offset = bit_within_byte (in_bit_range.get_start_offset ());
368 13994 : }
369 :
370 : #if CHECKING_P
371 :
372 : namespace selftest {
373 :
374 : /* Implementation detail of ASSERT_OVERLAP. */
375 :
376 : template<typename Unit>
377 : static void
378 112 : assert_overlap (const ::selftest::location &loc,
379 : const concrete::range<Unit> &r1,
380 : const concrete::range<Unit> &r2,
381 : const concrete::range<Unit> &expected_overlap)
382 : {
383 : // Test both ways round
384 : {
385 112 : concrete::range<Unit> actual_overlap;
386 112 : ASSERT_TRUE_AT (loc, r1.intersects_p (r2, &actual_overlap));
387 112 : ASSERT_EQ_AT (loc, actual_overlap, expected_overlap);
388 112 : }
389 : {
390 112 : concrete::range<Unit> actual_overlap;
391 112 : ASSERT_TRUE_AT (loc, r2.intersects_p (r1, &actual_overlap));
392 112 : ASSERT_EQ_AT (loc, actual_overlap, expected_overlap);
393 112 : }
394 112 : }
395 :
396 : /* Implementation detail of ASSERT_DISJOINT. */
397 :
398 : template<typename Unit>
399 : static void
400 40 : assert_disjoint (const ::selftest::location &loc,
401 : const concrete::range<Unit> &r1,
402 : const concrete::range<Unit> &r2)
403 : {
404 : // Test both ways round
405 40 : ASSERT_FALSE_AT (loc, r1.intersects_p (r2));
406 40 : ASSERT_FALSE_AT (loc, r2.intersects_p (r1));
407 40 : }
408 :
409 : /* Assert that R1 and R2 overlap, checking both ways. */
410 :
411 : #define ASSERT_OVERLAP(R1, R2, EXPECTED_OVERLAP) \
412 : SELFTEST_BEGIN_STMT \
413 : assert_overlap (SELFTEST_LOCATION, (R1), (R2), (EXPECTED_OVERLAP)); \
414 : SELFTEST_END_STMT
415 :
416 : /* Assert that R1 and R2 do not overlap, checking both ways. */
417 :
418 : #define ASSERT_DISJOINT(R1, R2) \
419 : SELFTEST_BEGIN_STMT \
420 : assert_disjoint (SELFTEST_LOCATION, (R1), (R2)); \
421 : SELFTEST_END_STMT
422 :
423 : template<typename ConcreteValueType>
424 : static void
425 8 : test_intersections ()
426 : {
427 64 : auto make_range = [] (int start, int size)
428 : {
429 128 : return concrete::range<ConcreteValueType> (ConcreteValueType(start),
430 128 : ConcreteValueType(size));
431 : };
432 :
433 : /* Various size 8 ranges. */
434 8 : concrete::range<ConcreteValueType> r0_7 = make_range (0, 8);
435 8 : concrete::range<ConcreteValueType> r8_15 = make_range (8, 8);
436 8 : concrete::range<ConcreteValueType> r16_23 = make_range (16, 8);
437 8 : concrete::range<ConcreteValueType> r24_31 = make_range (24, 8);
438 :
439 : /* Various size 16 ranges. */
440 8 : concrete::range<ConcreteValueType> r0_15 = make_range (0, 16);
441 8 : concrete::range<ConcreteValueType> r8_23 = make_range (8, 16);
442 8 : concrete::range<ConcreteValueType> r16_31 = make_range (16, 16);
443 :
444 : /* Size 32 range. */
445 8 : concrete::range<ConcreteValueType> r0_31 = make_range (0, 32);
446 :
447 : /* Everything should self-overlap. */
448 8 : ASSERT_OVERLAP (r0_7, r0_7, r0_7);
449 8 : ASSERT_OVERLAP (r8_15, r8_15, r8_15);
450 8 : ASSERT_OVERLAP (r16_23, r16_23, r16_23);
451 8 : ASSERT_OVERLAP (r24_31, r24_31, r24_31);
452 8 : ASSERT_OVERLAP (r0_15, r0_15, r0_15);
453 8 : ASSERT_OVERLAP (r8_23, r8_23, r8_23);
454 8 : ASSERT_OVERLAP (r16_31, r16_31, r16_31);
455 8 : ASSERT_OVERLAP (r0_31, r0_31, r0_31);
456 :
457 : /* Verify the 8-bit bindings that don't overlap each other. */
458 8 : ASSERT_DISJOINT (r0_7, r8_15);
459 8 : ASSERT_DISJOINT (r8_15, r16_23);
460 :
461 : /* Check for overlap of differently-sized bindings. */
462 8 : ASSERT_OVERLAP (r0_7, r0_31, r0_7);
463 : /* ...and with differing start points. */
464 8 : ASSERT_OVERLAP (r8_15, r0_31, r8_15);
465 8 : ASSERT_DISJOINT (r8_15, r16_31);
466 8 : ASSERT_OVERLAP (r16_23, r0_31, r16_23);
467 8 : ASSERT_OVERLAP (r16_31, r0_31, r16_31);
468 :
469 8 : ASSERT_DISJOINT (r0_7, r8_23);
470 8 : ASSERT_OVERLAP (r8_23, r16_23, r16_23);
471 8 : ASSERT_OVERLAP (r8_23, r16_31, r16_23);
472 8 : ASSERT_DISJOINT (r8_23, r24_31);
473 56 : }
474 :
475 : template<typename ConcreteValueType>
476 : static void
477 4 : test_falls_short_of_p ()
478 : {
479 : using concrete_range_type = concrete::range<ConcreteValueType>;
480 12 : auto make_range = [] (int start, int size)
481 : {
482 24 : return concrete_range_type (ConcreteValueType(start),
483 24 : ConcreteValueType(size));
484 : };
485 :
486 4 : concrete_range_type rm4_m1 = make_range (-4, 4);
487 4 : concrete_range_type r0_3 = make_range (0, 4);
488 4 : concrete_range_type r10 = make_range (10, 1);
489 :
490 : /* [0, 4) is fully after 0. */
491 : {
492 4 : concrete_range_type out;
493 4 : ASSERT_FALSE (r0_3.falls_short_of_p (ConcreteValueType (0),
494 : &out));
495 4 : }
496 :
497 : /* [0, 4) is not fully after 10; it's fully before. */
498 : {
499 4 : concrete_range_type out;
500 4 : ASSERT_TRUE (r0_3.falls_short_of_p (ConcreteValueType (10),
501 : &out));
502 4 : ASSERT_EQ (out.get_start_offset (), ConcreteValueType (0));
503 4 : ASSERT_EQ (out.get_size (), ConcreteValueType (4));
504 4 : ASSERT_EQ (out.get_next_offset (), ConcreteValueType (4));
505 4 : }
506 :
507 : /* [0, 4) is not fully after 2. */
508 : {
509 4 : concrete_range_type out;
510 4 : ASSERT_TRUE (r0_3.falls_short_of_p (ConcreteValueType (2),
511 : &out));
512 4 : ASSERT_EQ (out.get_start_offset (), ConcreteValueType (0));
513 4 : ASSERT_EQ (out.get_size (), ConcreteValueType (2));
514 4 : ASSERT_EQ (out.get_next_offset (), ConcreteValueType (2));
515 4 : }
516 :
517 : {
518 4 : concrete_range_type out;
519 4 : ASSERT_TRUE (rm4_m1.falls_short_of_p (ConcreteValueType (0),
520 : &out));
521 4 : ASSERT_EQ (out.get_start_offset (), ConcreteValueType (-4));
522 4 : ASSERT_EQ (out.get_size (), ConcreteValueType (4));
523 4 : ASSERT_EQ (out.get_next_offset (), ConcreteValueType (0));
524 4 : }
525 :
526 : {
527 4 : concrete_range_type out;
528 4 : ASSERT_TRUE (r10.falls_short_of_p (ConcreteValueType (15),
529 : &out));
530 4 : ASSERT_EQ (out.get_start_offset (), ConcreteValueType (10));
531 4 : ASSERT_EQ (out.get_size (), ConcreteValueType (1));
532 4 : ASSERT_EQ (out.get_next_offset (), ConcreteValueType (11));
533 4 : }
534 12 : }
535 :
536 : template<typename ConcreteValueType>
537 : static void
538 4 : test_exceeds_p ()
539 : {
540 : using concrete_range_type = concrete::range<ConcreteValueType>;
541 8 : auto make_range = [] (int start, int size)
542 : {
543 16 : return concrete_range_type (ConcreteValueType(start),
544 16 : ConcreteValueType(size));
545 : };
546 :
547 4 : concrete_range_type r0_3 = make_range (0, 4);
548 4 : concrete_range_type r10 = make_range (10, 1);
549 :
550 : /* [0, 4) is fully before 4. */
551 : {
552 4 : concrete_range_type out;
553 4 : ASSERT_FALSE (r0_3.exceeds_p (ConcreteValueType (4),
554 : &out));
555 4 : }
556 :
557 : /* [0, 4) is not fully before 3: the overlap is {3}. */
558 : {
559 4 : concrete_range_type out;
560 4 : ASSERT_TRUE (r0_3.exceeds_p (ConcreteValueType (3),
561 : &out));
562 4 : ASSERT_EQ (out.get_start_offset (), ConcreteValueType (3));
563 4 : ASSERT_EQ (out.get_size (), ConcreteValueType (1));
564 4 : ASSERT_EQ (out.get_next_offset (), ConcreteValueType (4));
565 4 : }
566 :
567 : /* [0, 4) is not fully before 2: the overlap is {2, 3}. */
568 : {
569 4 : concrete_range_type out;
570 4 : ASSERT_TRUE (r0_3.exceeds_p (ConcreteValueType (2),
571 : &out));
572 4 : ASSERT_EQ (out.get_start_offset (), ConcreteValueType (2));
573 4 : ASSERT_EQ (out.get_size (), ConcreteValueType (2));
574 4 : ASSERT_EQ (out.get_next_offset (), ConcreteValueType (4));
575 4 : }
576 :
577 : /* {10} is not fully before 5: the overlap is {10}. */
578 : {
579 4 : concrete_range_type out;
580 4 : ASSERT_TRUE (r10.exceeds_p (ConcreteValueType (5),
581 : &out));
582 4 : ASSERT_EQ (out.get_start_offset (), ConcreteValueType (10));
583 4 : ASSERT_EQ (out.get_size (), ConcreteValueType (1));
584 4 : ASSERT_EQ (out.get_next_offset (), ConcreteValueType (11));
585 4 : }
586 8 : }
587 :
588 : /* Implementation detail of ASSERT_BIT_RANGE_FROM_MASK_EQ. */
589 :
590 : static void
591 76 : assert_bit_range_from_mask_eq (const ::selftest::location &loc,
592 : unsigned HOST_WIDE_INT mask,
593 : const concrete_bit_range &expected)
594 : {
595 76 : concrete_bit_range actual;
596 76 : bool ok = concrete_bit_range_from_mask (mask, &actual);
597 76 : ASSERT_TRUE_AT (loc, ok);
598 76 : ASSERT_EQ_AT (loc, actual, expected);
599 76 : }
600 :
601 : /* Assert that concrete_bit_range_from_mask (MASK) returns true, and writes
602 : out EXPECTED_BIT_RANGE. */
603 :
604 : #define ASSERT_BIT_RANGE_FROM_MASK_EQ(MASK, EXPECTED_BIT_RANGE) \
605 : SELFTEST_BEGIN_STMT \
606 : assert_bit_range_from_mask_eq (SELFTEST_LOCATION, MASK, \
607 : EXPECTED_BIT_RANGE); \
608 : SELFTEST_END_STMT
609 :
610 : /* Implementation detail of ASSERT_NO_BIT_RANGE_FROM_MASK. */
611 :
612 : static void
613 12 : assert_no_bit_range_from_mask_eq (const ::selftest::location &loc,
614 : unsigned HOST_WIDE_INT mask)
615 : {
616 12 : concrete_bit_range actual;
617 12 : bool ok = concrete_bit_range_from_mask (mask, &actual);
618 12 : ASSERT_FALSE_AT (loc, ok);
619 12 : }
620 :
621 : /* Assert that concrete_bit_range_from_mask (MASK) returns false. */
622 :
623 : #define ASSERT_NO_BIT_RANGE_FROM_MASK(MASK) \
624 : SELFTEST_BEGIN_STMT \
625 : assert_no_bit_range_from_mask_eq (SELFTEST_LOCATION, MASK); \
626 : SELFTEST_END_STMT
627 :
628 : /* Verify that concrete_bit_range_from_mask works as expected. */
629 :
630 : static void
631 4 : test_bit_range_from_mask ()
632 : {
633 : /* Should fail on zero. */
634 4 : ASSERT_NO_BIT_RANGE_FROM_MASK (0);
635 :
636 : /* Verify 1-bit masks. */
637 12 : ASSERT_BIT_RANGE_FROM_MASK_EQ (1, concrete_bit_range (0_bits, 1_bit));
638 12 : ASSERT_BIT_RANGE_FROM_MASK_EQ (2, concrete_bit_range (1_bit, 1_bit));
639 12 : ASSERT_BIT_RANGE_FROM_MASK_EQ (4, concrete_bit_range (2_bits, 1_bit));
640 12 : ASSERT_BIT_RANGE_FROM_MASK_EQ (8, concrete_bit_range (3_bits, 1_bit));
641 12 : ASSERT_BIT_RANGE_FROM_MASK_EQ (16, concrete_bit_range (4_bits, 1_bit));
642 12 : ASSERT_BIT_RANGE_FROM_MASK_EQ (32, concrete_bit_range (5_bits, 1_bit));
643 12 : ASSERT_BIT_RANGE_FROM_MASK_EQ (64, concrete_bit_range (6_bits, 1_bit));
644 12 : ASSERT_BIT_RANGE_FROM_MASK_EQ (128, concrete_bit_range (7_bits, 1_bit));
645 :
646 : /* Verify N-bit masks starting at bit 0. */
647 12 : ASSERT_BIT_RANGE_FROM_MASK_EQ (3, concrete_bit_range (0_bits, 2_bits));
648 12 : ASSERT_BIT_RANGE_FROM_MASK_EQ (7, concrete_bit_range (0_bits, 3_bits));
649 12 : ASSERT_BIT_RANGE_FROM_MASK_EQ (15, concrete_bit_range (0_bits, 4_bits));
650 12 : ASSERT_BIT_RANGE_FROM_MASK_EQ (31, concrete_bit_range (0_bits, 5_bits));
651 12 : ASSERT_BIT_RANGE_FROM_MASK_EQ (63, concrete_bit_range (0_bits, 6_bits));
652 12 : ASSERT_BIT_RANGE_FROM_MASK_EQ (127, concrete_bit_range (0_bits, 7_bits));
653 12 : ASSERT_BIT_RANGE_FROM_MASK_EQ (255, concrete_bit_range (0_bits, 8_bits));
654 12 : ASSERT_BIT_RANGE_FROM_MASK_EQ (0xffff, concrete_bit_range (0_bits, 16_bits));
655 :
656 : /* Various other tests. */
657 12 : ASSERT_BIT_RANGE_FROM_MASK_EQ (0x30, concrete_bit_range (4_bits, 2_bits));
658 12 : ASSERT_BIT_RANGE_FROM_MASK_EQ (0x700, concrete_bit_range (8_bits, 3_bits));
659 12 : ASSERT_BIT_RANGE_FROM_MASK_EQ (0x600, concrete_bit_range (9_bits, 2_bits));
660 :
661 : /* Multiple ranges of set bits should fail. */
662 4 : ASSERT_NO_BIT_RANGE_FROM_MASK (0x101);
663 4 : ASSERT_NO_BIT_RANGE_FROM_MASK (0xf0f0f0f0);
664 4 : }
665 :
666 : static void
667 4 : test_get_smallest_enclosing_byte_range ()
668 : {
669 : // bit 0 should be bit 0 of byte 0
670 4 : {
671 4 : concrete_byte_range out_byte_range;
672 4 : concrete_bit_offset out_bit_offset;
673 4 : get_smallest_enclosing_byte_range
674 12 : (concrete_bit_range (0_bits, 1_bit),
675 : &out_byte_range,
676 : &out_bit_offset);
677 12 : ASSERT_EQ (out_byte_range, concrete_byte_range (0_bytes, 1_byte));
678 4 : ASSERT_EQ (out_bit_offset, 0_bits);
679 4 : }
680 :
681 : // bits 1-3 should be bits 1-3 of byte 0
682 4 : {
683 4 : concrete_byte_range out_byte_range;
684 4 : concrete_bit_offset out_bit_offset;
685 4 : get_smallest_enclosing_byte_range
686 12 : (concrete_bit_range (1_bit, 1_bit),
687 : &out_byte_range,
688 : &out_bit_offset);
689 12 : ASSERT_EQ (out_byte_range, concrete_byte_range (0_bytes, 1_byte));
690 4 : ASSERT_EQ (out_bit_offset, 1_bit);
691 4 : }
692 :
693 : // bits [16, 24) should be all of byte 2
694 4 : {
695 4 : concrete_byte_range out_byte_range;
696 4 : concrete_bit_offset out_bit_offset;
697 4 : get_smallest_enclosing_byte_range
698 12 : (concrete_bit_range (16_bits, 8_bits),
699 : &out_byte_range,
700 : &out_bit_offset);
701 12 : ASSERT_EQ (out_byte_range, concrete_byte_range (2_bytes, 1_byte));
702 4 : ASSERT_EQ (out_bit_offset, 0_bits);
703 4 : }
704 :
705 : // bits 17-18 should be bits 1-2 of byte 2
706 4 : {
707 4 : concrete_byte_range out_byte_range;
708 4 : concrete_bit_offset out_bit_offset;
709 4 : get_smallest_enclosing_byte_range
710 12 : (concrete_bit_range (17_bits, 2_bits),
711 : &out_byte_range,
712 : &out_bit_offset);
713 12 : ASSERT_EQ (out_byte_range, concrete_byte_range (2_bytes, 1_byte));
714 4 : ASSERT_EQ (out_bit_offset, 1_bit);
715 4 : }
716 4 : }
717 :
718 : /* Run all of the selftests within this file. */
719 :
720 : void
721 4 : analyzer_concrete_ranges_cc_tests ()
722 : {
723 8 : concrete_bit_range bits_16_to_23 (16_bits, 8_bits);
724 4 : ASSERT_EQ (bits_16_to_23.get_start_offset (), 16_bits);
725 4 : ASSERT_EQ (bits_16_to_23.get_size (), 8_bits);
726 4 : ASSERT_EQ (bits_16_to_23.get_last_offset (), 23_bits);
727 4 : ASSERT_EQ (bits_16_to_23.get_next_offset (), 24_bits);
728 4 : bits_16_to_23.to_json ();
729 4 : ASSERT_MARKUP_TEXT_EQ (*bits_16_to_23.make_markup_node (),
730 : diagnostics::selftest::get_ascii_markup_opts (),
731 : "[16, 24)");
732 :
733 8 : concrete_byte_range bytes_16_to_23 (16_bytes, 8_bytes);
734 4 : ASSERT_EQ (bytes_16_to_23.get_start_offset (), 16_bytes);
735 4 : ASSERT_EQ (bytes_16_to_23.get_size (), 8_bytes);
736 4 : ASSERT_EQ (bytes_16_to_23.get_last_offset (), 23_bytes);
737 4 : ASSERT_EQ (bytes_16_to_23.get_next_offset (), 24_bytes);
738 4 : bytes_16_to_23.to_json ();
739 :
740 4 : test_intersections<integer_with_unit<units::bit>> ();
741 4 : test_intersections<integer_with_unit<units::byte>> ();
742 4 : test_falls_short_of_p<integer_with_unit<units::bit>> ();
743 4 : test_exceeds_p<integer_with_unit<units::bit>> ();
744 :
745 4 : test_bit_range_from_mask ();
746 4 : test_get_smallest_enclosing_byte_range ();
747 8 : }
748 :
749 : } // namespace selftest
750 :
751 : #endif /* CHECKING_P */
752 :
753 : } // namespace ana
754 :
755 : /* Ensure we instantiate these. */
756 :
757 : template
758 : void
759 : ana::concrete_bit_range::dump_to_pp (pretty_printer *pp) const;
760 :
761 : template
762 : void
763 : ana::concrete_byte_range::dump_to_pp (pretty_printer *pp) const;
764 :
765 : template
766 : int
767 : ana::concrete_bit_range::cmp (const ana::concrete_bit_range &lhs,
768 : const ana::concrete_bit_range &rhs);
769 :
770 : #endif /* #if ENABLE_ANALYZER */
|