LLVM: include/llvm/ADT/PackedVector.h Source File (original) (raw)
1
2
3
4
5
6
7
8
9
10
11
12
13
14#ifndef LLVM_ADT_PACKEDVECTOR_H
15#define LLVM_ADT_PACKEDVECTOR_H
16
18#include
19#include
20
21namespace llvm {
22
23
24
25
26
27
28
29
30template <typename T, unsigned BitNum, typename BitVectorTy = BitVector>
32 static_assert(BitNum > 0, "BitNum must be > 0");
33
34 BitVectorTy Bits;
35
36
37
38 unsigned NumElements = 0;
39
40 static T getValue(const BitVectorTy &Bits, unsigned Idx) {
41 if constexpr (std::numeric_limits::is_signed) {
43 for (unsigned i = 0; i != BitNum - 1; ++i)
44 val = T(val | ((Bits[(Idx * BitNum) + i] ? 1UL : 0UL) << i));
45 if (Bits[(Idx * BitNum) + BitNum - 1])
46 val = ~val;
47 return val;
48 } else {
50 for (unsigned i = 0; i != BitNum; ++i)
51 val = T(val | ((Bits[(Idx * BitNum) + i] ? 1UL : 0UL) << i));
52 return val;
53 }
54 }
55
56 static void setValue(BitVectorTy &Bits, unsigned Idx, T val) {
57 if constexpr (std::numeric_limits::is_signed) {
58 if (val < 0) {
59 val = ~val;
60 Bits.set((Idx * BitNum) + BitNum - 1);
61 } else {
62 Bits.reset((Idx * BitNum) + BitNum - 1);
63 }
64 assert((val >> (BitNum - 1)) == 0 && "value is too big");
65 for (unsigned i = 0; i != BitNum - 1; ++i)
66 Bits[(Idx * BitNum) + i] = val & (T(1) << i);
67 } else {
68 assert((val >> BitNum) == 0 && "value is too big");
69 for (unsigned i = 0; i != BitNum; ++i)
70 Bits[(Idx * BitNum) + i] = val & (T(1) << i);
71 }
72 }
73
74public:
77 const unsigned Idx;
78
79 public:
82
84 Vec.setValue(Vec.Bits, Idx, val);
85 return *this;
86 }
87
88 operator T() const { return Vec.getValue(Vec.Bits, Idx); }
89 };
90
93 : Bits(size * BitNum), NumElements(size) {}
94
95 bool empty() const { return NumElements == 0; }
96
97 unsigned size() const { return NumElements; }
98
100 Bits.clear();
101 NumElements = 0;
102 }
103
105 Bits.resize(N * BitNum);
106 NumElements = N;
107 }
108
109 void reserve(unsigned N) { Bits.reserve(N * BitNum); }
110
115
118 (*this)[size() - 1] = val;
119 }
120
121 reference operator[](unsigned Idx) { return reference(*this, Idx); }
122
123 T operator[](unsigned Idx) const { return getValue(Bits, Idx); }
124
126
128
130 Bits |= RHS.Bits;
131 return *this;
132 }
133
134 const BitVectorTy &raw_bits() const { return Bits; }
136};
137
138}
139
140#endif
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
This file implements the BitVector class.
reference(PackedVector &vec, unsigned idx)
Definition PackedVector.h:81
reference & operator=(T val)
Definition PackedVector.h:83
void resize(unsigned N)
Definition PackedVector.h:104
const BitVectorTy & raw_bits() const
Definition PackedVector.h:134
PackedVector & reset()
Definition PackedVector.h:111
bool empty() const
Definition PackedVector.h:95
unsigned size() const
Definition PackedVector.h:97
T operator[](unsigned Idx) const
Definition PackedVector.h:123
PackedVector(unsigned size)
Definition PackedVector.h:92
void clear()
Definition PackedVector.h:99
void push_back(T val)
Definition PackedVector.h:116
BitVectorTy & raw_bits()
Definition PackedVector.h:135
PackedVector & operator|=(const PackedVector &RHS)
Definition PackedVector.h:129
bool operator!=(const PackedVector &RHS) const
Definition PackedVector.h:127
void reserve(unsigned N)
Definition PackedVector.h:109
bool operator==(const PackedVector &RHS) const
Definition PackedVector.h:125
reference operator[](unsigned Idx)
Definition PackedVector.h:121
This is an optimization pass for GlobalISel generic memory operations.