Line data    Source code

       1              : /* Operation with 128 bit bitmask.
       2              :    Copyright (C) 2013-2026 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              : wide_int_bitmask::wide_int_bitmask (uint64_t l)
      49              : : low (l), high (0)
      50              : {
      51              : }
      52              : 
      53              : constexpr
      54   5529248948 : 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        18306 : wide_int_bitmask::operator &= (wide_int_bitmask b)
      61              : {
      62        18306 :   low &= b.low;
      63        18306 :   high &= b.high;
      64        18306 :   return *this;
      65              : }
      66              : 
      67              : inline wide_int_bitmask &
      68        65596 : wide_int_bitmask::operator |= (wide_int_bitmask b)
      69              : {
      70        65596 :   low |= b.low;
      71        65596 :   high |= b.high;
      72          417 :   return *this;
      73              : }
      74              : 
      75              : constexpr wide_int_bitmask
      76        18306 : wide_int_bitmask::operator ~ () const
      77              : {
      78        18306 :   return wide_int_bitmask (~low, ~high);
      79              : }
      80              : 
      81              : constexpr wide_int_bitmask
      82       126608 : wide_int_bitmask::operator | (wide_int_bitmask b) const
      83              : {
      84       126608 :   return wide_int_bitmask (low | b.low, high | b.high);
      85              : }
      86              : 
      87              : constexpr wide_int_bitmask
      88   5480601046 : wide_int_bitmask::operator & (wide_int_bitmask b) const
      89              : {
      90    243092770 :   return wide_int_bitmask (low & b.low, high & b.high);
      91              : }
      92              : 
      93              : inline wide_int_bitmask
      94          447 : wide_int_bitmask::operator << (int amount)
      95              : {
      96          447 :   wide_int_bitmask ret;
      97          447 :   if (amount >= 64)
      98              :     {
      99              :       ret.low = 0;
     100              :       ret.high = low << (amount - 64);
     101              :     }
     102          447 :   else if (amount == 0)
     103              :     ret = *this;
     104              :   else
     105              :     {
     106          447 :       ret.low = low << amount;
     107          447 :       ret.high = (low >> (64 - amount)) | (high << amount);
     108              :     }
     109          447 :   return ret;
     110              : }
     111              : 
     112              : inline wide_int_bitmask
     113       110192 : wide_int_bitmask::operator >> (int amount)
     114              : {
     115       110192 :   wide_int_bitmask ret;
     116       101025 :   if (amount >= 64)
     117              :     {
     118        20188 :       ret.low = high >> (amount - 64);
     119        18697 :       ret.high = 0;
     120              :     }
     121        82328 :   else if (amount == 0)
     122            0 :     ret = *this;
     123              :   else
     124              :     {
     125        90004 :       ret.low = (high << (64 - amount)) | (low >> amount);
     126        82328 :       ret.high = high >> amount;
     127              :     }
     128       110192 :   return ret;
     129              : }
     130              : 
     131              : inline bool
     132     97295585 : wide_int_bitmask::operator == (wide_int_bitmask b) const
     133              : {
     134     97256587 :   return low == b.low && high == b.high;
     135              : }
     136              : 
     137              : inline bool
     138   5431844253 : wide_int_bitmask::operator != (wide_int_bitmask b) const
     139              : {
     140    546083942 :   return low != b.low || high != b.high;
     141              : }
     142              : 
     143              : #endif /* ! GCC_WIDE_INT_BITMASK_H */