Coverage Report

Created: 2019-02-21 13:17

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