Line data    Source code

       1             : /* Operation with 128 bit bitmask.
       2             :    Copyright (C) 2013-2023 Free Software Foundation, Inc.
       3             : 
       4             : This file is part of GCC.
       5             : 
       6             : GCC is free software; you can redistribute it and/or modify it under
       7             : the terms of the GNU General Public License as published by the Free
       8             : Software Foundation; either version 3, or (at your option) any later
       9             : version.
      10             : 
      11             : GCC is distributed in the hope that it will be useful, but WITHOUT ANY
      12             : WARRANTY; without even the implied warranty of MERCHANTABILITY or
      13             : FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
      14             : for more details.
      15             : 
      16             : You should have received a copy of the GNU General Public License
      17             : along with GCC; see the file COPYING3.  If not see
      18             : <http://www.gnu.org/licenses/>.  */
      19             : 
      20             : #ifndef GCC_WIDE_INT_BITMASK_H
      21             : #define GCC_WIDE_INT_BITMASK_H
      22             : 
      23             : class wide_int_bitmask
      24             : {
      25             : public:
      26             :   constexpr wide_int_bitmask ();
      27             :   constexpr wide_int_bitmask (uint64_t l);
      28             :   constexpr wide_int_bitmask (uint64_t l, uint64_t h);
      29             :   inline wide_int_bitmask &operator &= (wide_int_bitmask);
      30             :   inline wide_int_bitmask &operator |= (wide_int_bitmask);
      31             :   constexpr wide_int_bitmask operator ~ () const;
      32             :   constexpr wide_int_bitmask operator & (wide_int_bitmask) const;
      33             :   constexpr wide_int_bitmask operator | (wide_int_bitmask) const;
      34             :   inline wide_int_bitmask operator >> (int);
      35             :   inline wide_int_bitmask operator << (int);
      36             :   inline bool operator == (wide_int_bitmask) const;
      37             :   inline bool operator != (wide_int_bitmask) const;
      38             :   uint64_t low, high;
      39             : };
      40             : 
      41             : constexpr
      42             : wide_int_bitmask::wide_int_bitmask ()
      43             : : low (0), high (0)
      44             : {
      45             : }
      46             : 
      47             : constexpr
      48       17321 : wide_int_bitmask::wide_int_bitmask (uint64_t l)
      49         633 : : low (l), high (0)
      50             : {
      51             : }
      52             : 
      53             : constexpr
      54      202208 : wide_int_bitmask::wide_int_bitmask (uint64_t l, uint64_t h)
      55             : : low (l), high (h)
      56             : {
      57             : }
      58             : 
      59             : inline wide_int_bitmask &
      60       10584 : wide_int_bitmask::operator &= (wide_int_bitmask b)
      61             : {
      62       10584 :   low &= b.low;
      63       10584 :   high &= b.high;
      64       10584 :   return *this;
      65             : }
      66             : 
      67             : inline wide_int_bitmask &
      68       42099 : wide_int_bitmask::operator |= (wide_int_bitmask b)
      69             : {
      70       42099 :   low |= b.low;
      71       42099 :   high |= b.high;
      72       42099 :   return *this;
      73             : }
      74             : 
      75             : constexpr wide_int_bitmask
      76       10584 : wide_int_bitmask::operator ~ () const
      77             : {
      78       10584 :   return wide_int_bitmask (~low, ~high);
      79             : }
      80             : 
      81             : constexpr wide_int_bitmask
      82       67432 : wide_int_bitmask::operator | (wide_int_bitmask b) const
      83             : {
      84         744 :   return wide_int_bitmask (low | b.low, high | b.high);
      85             : }
      86             : 
      87             : constexpr wide_int_bitmask
      88      134348 : wide_int_bitmask::operator & (wide_int_bitmask b) const
      89             : {
      90      134348 :   return wide_int_bitmask (low & b.low, high & b.high);
      91             : }
      92             : 
      93             : inline wide_int_bitmask
      94         599 : wide_int_bitmask::operator << (int amount)
      95             : {
      96      126232 :   wide_int_bitmask ret;
      97         599 :   if (amount >= 64)
      98             :     {
      99        1177 :       ret.low = 0;
     100             :       ret.high = low << (amount - 64);
     101             :     }
     102         599 :   else if (amount == 0)
     103             :     ret = *this;
     104             :   else
     105             :     {
     106       76711 :       ret.low = low << amount;
     107         599 :       ret.high = (low >> (64 - amount)) | (high << amount);
     108             :     }
     109         599 :   return ret;
     110             : }
     111             : 
     112             : inline wide_int_bitmask
     113       76835 : wide_int_bitmask::operator >> (int amount)
     114             : {
     115       76835 :   wide_int_bitmask ret;
     116       69620 :   if (amount >= 64)
     117             :     {
     118       11191 :       ret.low = high >> (amount - 64);
     119       11191 :       ret.high = 0;
     120             :     }
     121       58429 :   else if (amount == 0)
     122           0 :     ret = *this;
     123             :   else
     124             :     {
     125       65644 :       ret.low = (high << (64 - amount)) | (low >> amount);
     126       58429 :       ret.high = high >> amount;
     127             :     }
     128       76835 :   return ret;
     129             : }
     130             : 
     131             : inline bool
     132       82158 : wide_int_bitmask::operator == (wide_int_bitmask b) const
     133             : {
     134       82158 :   return low == b.low && high == b.high;
     135             : }
     136             : 
     137             : inline bool
     138       52190 : wide_int_bitmask::operator != (wide_int_bitmask b) const
     139             : {
     140       52190 :   return low != b.low || high != b.high;
     141             : }
     142             : 
     143             : #endif /* ! GCC_WIDE_INT_BITMASK_H */