13 #ifndef LLVM_CLANG_ANALYSIS_ANALYSES_THREADSAFETYUTIL_H 14 #define LLVM_CLANG_ANALYSIS_ANALYSES_THREADSAFETYUTIL_H 18 #include "llvm/ADT/StringRef.h" 19 #include "llvm/ADT/iterator_range.h" 20 #include "llvm/Support/Allocator.h" 33 namespace threadSafety {
52 return Allocator->Allocate(Sz,
alignof(AlignmentType));
55 template <
typename T> T *
allocateT() {
return Allocator->Allocate<T>(); }
57 template <
typename T> T *
allocateT(
size_t NumElems) {
58 return Allocator->Allocate<T>(NumElems);
62 llvm::BumpPtrAllocator *Allocator =
nullptr;
70 inline void *
operator new(
size_t Sz,
72 return R.allocate(Sz);
76 namespace threadSafety {
88 : Data(Dat), Size(Sz), Capacity(Cp) {}
90 : Data(Cp == 0 ? nullptr : A.
allocateT<T>(Cp)), Capacity(Cp) {}
94 : Data(A.Data), Size(A.Size), Capacity(A.Capacity) {
104 Capacity = RHS.Capacity;
107 RHS.Size = RHS.Capacity = 0;
119 memcpy(Data, Odata,
sizeof(T) * Size);
125 reserve(u_max(InitialCapacity, N), A);
126 else if (Size + N < Capacity)
127 reserve(u_max(Size + N, Capacity * 2), A);
135 size_t size()
const {
return Size; }
139 assert(i < Size &&
"Array index out of bounds.");
144 assert(i < Size &&
"Array index out of bounds.");
149 assert(Size &&
"No elements in the array.");
150 return Data[Size - 1];
154 assert(Size &&
"No elements in the array.");
155 return Data[Size - 1];
179 assert(Size < Capacity);
190 assert(Sz <= Capacity);
192 for (
unsigned i = 0;
i < Sz; ++
i) {
197 template <
class Iter>
unsigned append(Iter I, Iter E) {
200 for (; J < Capacity && I != E; ++J, ++I)
206 llvm::iterator_range<reverse_iterator>
reverse() {
207 return llvm::make_range(rbegin(), rend());
210 llvm::iterator_range<const_reverse_iterator>
reverse()
const {
211 return llvm::make_range(rbegin(), rend());
217 size_t u_max(
size_t i,
size_t j) {
return (i < j) ? j :
i; }
219 static const size_t InitialCapacity = 4;
238 unsigned NumRefs = 1;
241 VectorData() =
default;
242 VectorData(
const VectorData &VD) : Vect(VD.Vect) {}
266 bool writable()
const {
return Data && Data->NumRefs == 1; }
271 Data =
new VectorData();
279 if (Data->NumRefs <= 1)
289 Data =
new VectorData();
292 if (Data->NumRefs == 1)
295 Data =
new VectorData(*Data);
303 const std::vector<T> &
elements()
const {
return Data->Vect; }
310 unsigned size()
const {
return Data ? elements().size() : 0; }
317 assert(writable() &&
"Vector is not writable!");
323 assert(writable() &&
"Vector is not writable!");
324 Data->Vect.push_back(Elem);
330 assert(writable() &&
"Vector is not writable!");
331 return Data->Vect[
i];
336 assert(writable() &&
"Vector is not writable!");
337 Data->Vect.erase(Data->Vect.begin() +
i, Data->Vect.end());
347 VectorData *Data =
nullptr;
350 inline std::ostream&
operator<<(std::ostream& ss,
const StringRef str) {
351 return ss.write(str.data(), str.size());
357 #endif // LLVM_CLANG_THREAD_SAFETY_UTIL_H
SimpleArray(T *Dat, size_t Cp, size_t Sz=0)
void push_back(const T &Elem)
const_reverse_iterator rbegin() const
std::string getSourceLiteralString(const Expr *CE)
typename std::vector< NameVarPair >::const_iterator const_iterator
void push_back(const T &Elem)
const_iterator cbegin() const
T * allocateT(size_t NumElems)
const_iterator cend() const
Forward-declares and imports various common LLVM datatypes that clang wants to use unqualified...
void downsize(unsigned i)
A basic block is part of an SCFG.
const_iterator begin() const
llvm::iterator_range< reverse_iterator > reverse()
CopyOnWriteVector clone()
std::reverse_iterator< iterator > reverse_iterator
const_iterator end() const
reverse_iterator rbegin()
const_iterator begin() const
const T & operator[](unsigned i) const
T & operator[](unsigned i)
std::ostream & operator<<(std::ostream &ss, const StringRef str)
CopyOnWriteVector & operator=(CopyOnWriteVector &&V)
llvm::iterator_range< const_reverse_iterator > reverse() const
__DEVICE__ void * memcpy(void *__a, const void *__b, size_t __c)
bool sameAs(const CopyOnWriteVector &V) const
void reserveCheck(size_t N, MemRegionRef A)
const_reverse_iterator rend() const
Dataflow Directional Tag Classes.
const_iterator end() const
SimpleArray(SimpleArray< T > &&A)
unsigned append(Iter I, Iter E)
const std::vector< T > & elements() const
MemRegionRef(llvm::BumpPtrAllocator *A)
void setValues(unsigned Sz, const T &C)
void reserve(size_t Ncp, MemRegionRef A)
SimpleArray(MemRegionRef A, size_t Cp)
SimpleArray & operator=(SimpleArray &&RHS)
void * allocate(size_t Sz)
CopyOnWriteVector(CopyOnWriteVector &&V)
const T & operator[](unsigned i) const
std::reverse_iterator< const_iterator > const_reverse_iterator