LCOV - code coverage report
Current view: top level - include/llvm/ADT - PackedVector.h (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 34 34 100.0 %
Date: 2017-09-14 15:23:50 Functions: 7 7 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===- llvm/ADT/PackedVector.h - Packed values vector -----------*- C++ -*-===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : //
      10             : // This file implements the PackedVector class.
      11             : //
      12             : //===----------------------------------------------------------------------===//
      13             : 
      14             : #ifndef LLVM_ADT_PACKEDVECTOR_H
      15             : #define LLVM_ADT_PACKEDVECTOR_H
      16             : 
      17             : #include "llvm/ADT/BitVector.h"
      18             : #include <cassert>
      19             : #include <limits>
      20             : 
      21             : namespace llvm {
      22             : 
      23             : template <typename T, unsigned BitNum, typename BitVectorTy, bool isSigned>
      24             : class PackedVectorBase;
      25             : 
      26             : // This won't be necessary if we can specialize members without specializing
      27             : // the parent template.
      28             : template <typename T, unsigned BitNum, typename BitVectorTy>
      29             : class PackedVectorBase<T, BitNum, BitVectorTy, false> {
      30             : protected:
      31       40913 :   static T getValue(const BitVectorTy &Bits, unsigned Idx) {
      32       40918 :     T val = T();
      33      122754 :     for (unsigned i = 0; i != BitNum; ++i)
      34       81846 :       val = T(val | ((Bits[(Idx << (BitNum-1)) + i] ? 1UL : 0UL) << i));
      35       40913 :     return val;
      36             :   }
      37             : 
      38       59503 :   static void setValue(BitVectorTy &Bits, unsigned Idx, T val) {
      39             :     assert((val >> BitNum) == 0 && "value is too big");
      40      178511 :     for (unsigned i = 0; i != BitNum; ++i)
      41      238050 :       Bits[(Idx << (BitNum-1)) + i] = val & (T(1) << i);
      42       59503 :   }
      43             : };
      44             : 
      45             : template <typename T, unsigned BitNum, typename BitVectorTy>
      46             : class PackedVectorBase<T, BitNum, BitVectorTy, true> {
      47             : protected:
      48             :   static T getValue(const BitVectorTy &Bits, unsigned Idx) {
      49             :     T val = T();
      50             :     for (unsigned i = 0; i != BitNum-1; ++i)
      51             :       val = T(val | ((Bits[(Idx << (BitNum-1)) + i] ? 1UL : 0UL) << i));
      52             :     if (Bits[(Idx << (BitNum-1)) + BitNum-1])
      53             :       val = ~val;
      54             :     return val;
      55             :   }
      56             : 
      57          10 :   static void setValue(BitVectorTy &Bits, unsigned Idx, T val) {
      58          10 :     if (val < 0) {
      59           5 :       val = ~val;
      60           5 :       Bits.set((Idx << (BitNum-1)) + BitNum-1);
      61             :     }
      62             :     assert((val >> (BitNum-1)) == 0 && "value is too big");
      63          22 :     for (unsigned i = 0; i != BitNum-1; ++i)
      64          36 :       Bits[(Idx << (BitNum-1)) + i] = val & (T(1) << i);
      65          10 :   }
      66             : };
      67             : 
      68             : /// \brief Store a vector of values using a specific number of bits for each
      69             : /// value. Both signed and unsigned types can be used, e.g
      70             : /// @code
      71             : ///   PackedVector<signed, 2> vec;
      72             : /// @endcode
      73             : /// will create a vector accepting values -2, -1, 0, 1. Any other value will hit
      74             : /// an assertion.
      75             : template <typename T, unsigned BitNum, typename BitVectorTy = BitVector>
      76      378427 : class PackedVector : public PackedVectorBase<T, BitNum, BitVectorTy,
      77             :                                             std::numeric_limits<T>::is_signed> {
      78             :   BitVectorTy Bits;
      79             :   using base = PackedVectorBase<T, BitNum, BitVectorTy,
      80             :                                 std::numeric_limits<T>::is_signed>;
      81             : 
      82             : public:
      83             :   class reference {
      84             :     PackedVector &Vec;
      85             :     const unsigned Idx;
      86             : 
      87             :   public:
      88             :     reference() = delete;
      89             :     reference(PackedVector &vec, unsigned idx) : Vec(vec), Idx(idx) {}
      90             : 
      91             :     reference &operator=(T val) {
      92       59513 :       Vec.setValue(Vec.Bits, Idx, val);
      93             :       return *this;
      94             :     }
      95             : 
      96             :     operator T() const {
      97       40923 :       return Vec.getValue(Vec.Bits, Idx);
      98             :     }
      99             :   };
     100             : 
     101      470564 :   PackedVector() = default;
     102           5 :   explicit PackedVector(unsigned size) : Bits(size << (BitNum-1)) {}
     103             : 
     104           5 :   bool empty() const { return Bits.empty(); }
     105             : 
     106          61 :   unsigned size() const { return Bits.size() >> (BitNum - 1); }
     107             : 
     108           1 :   void clear() { Bits.clear(); }
     109             : 
     110      199634 :   void resize(unsigned N) { Bits.resize(N << (BitNum - 1)); }
     111             : 
     112             :   void reserve(unsigned N) { Bits.reserve(N << (BitNum-1)); }
     113             : 
     114             :   PackedVector &reset() {
     115       74371 :     Bits.reset();
     116             :     return *this;
     117             :   }
     118             : 
     119           4 :   void push_back(T val) {
     120           8 :     resize(size()+1);
     121          12 :     (*this)[size()-1] = val;
     122           4 :   }
     123             : 
     124             :   reference operator[](unsigned Idx) {
     125      100431 :     return reference(*this, Idx);
     126             :   }
     127             : 
     128             :   T operator[](unsigned Idx) const {
     129             :     return base::getValue(Bits, Idx);
     130             :   }
     131             : 
     132             :   bool operator==(const PackedVector &RHS) const {
     133           2 :     return Bits == RHS.Bits;
     134             :   }
     135             : 
     136             :   bool operator!=(const PackedVector &RHS) const {
     137      148746 :     return Bits != RHS.Bits;
     138             :   }
     139             : 
     140             :   PackedVector &operator|=(const PackedVector &RHS) {
     141       19745 :     Bits |= RHS.Bits;
     142             :     return *this;
     143             :   }
     144             : };
     145             : 
     146             : // Leave BitNum=0 undefined.
     147             : template <typename T> class PackedVector<T, 0>;
     148             : 
     149             : } // end namespace llvm
     150             : 
     151             : #endif // LLVM_ADT_PACKEDVECTOR_H

Generated by: LCOV version 1.13