LCOV - code coverage report
Current view: top level - gcc/analyzer - concrete-ranges.cc (source / functions) Coverage Total Hit
Test: gcc.info Lines: 91.0 % 346 315
Test Date: 2026-11-14 16:39:50 Functions: 85.7 % 42 36
Legend: Lines:     hit not hit

            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 */
        

Generated by: LCOV version 2.5.0-beta

LCOV profile is generated on x86_64 machine using following configure options: configure --disable-bootstrap --enable-coverage=opt --enable-languages=c,c++,fortran,go,jit,lto,rust,m2 --enable-host-shared. GCC test suite is run with the built compiler.