14 #ifndef LLVM_CLANG_ANALYSIS_ANALYSES_THREADSAFETYUTIL_H
15 #define LLVM_CLANG_ANALYSIS_ANALYSES_THREADSAFETYUTIL_H
18 #include "llvm/ADT/StringRef.h"
19 #include "llvm/Support/AlignOf.h"
20 #include "llvm/Support/Allocator.h"
21 #include "llvm/Support/Compiler.h"
29 namespace threadSafety {
48 return Allocator->Allocate(Sz, llvm::AlignOf<AlignmentType>::Alignment);
51 template <
typename T> T *
allocateT() {
return Allocator->Allocate<T>(); }
53 template <
typename T> T *
allocateT(
size_t NumElems) {
54 return Allocator->Allocate<T>(NumElems);
58 llvm::BumpPtrAllocator *Allocator;
67 inline void *
operator new(
size_t Sz,
69 return R.allocate(Sz);
74 namespace threadSafety {
78 using llvm::StringRef;
90 : Data(Dat), Size(Sz), Capacity(Cp) {}
92 : Data(Cp == 0 ? nullptr : A.allocateT<T>(Cp)), Size(0), 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);
126 reserve(u_max(InitialCapacity, N), A);
127 else if (Size + N < Capacity)
128 reserve(u_max(Size + N, Capacity * 2), A);
136 size_t size()
const {
return Size; }
140 assert(i < Size &&
"Array index out of bounds.");
144 assert(i < Size &&
"Array index out of bounds.");
148 assert(Size &&
"No elements in the array.");
149 return Data[Size - 1];
152 assert(Size &&
"No elements in the array.");
153 return Data[Size - 1];
176 assert(Size < Capacity);
187 assert(Sz <= Capacity);
189 for (
unsigned i = 0; i < Sz; ++i) {
194 template <
class Iter>
unsigned append(Iter I, Iter E) {
197 for (; J < Capacity && I != E; ++J, ++I)
203 llvm::iterator_range<reverse_iterator>
reverse() {
206 llvm::iterator_range<const_reverse_iterator>
reverse()
const {
213 size_t u_max(
size_t i,
size_t j) {
return (i < j) ? j : i; }
215 static const size_t InitialCapacity = 4;
238 VectorData() : NumRefs(1) { }
239 VectorData(
const VectorData &VD) : NumRefs(1), Vect(VD.Vect) { }
258 bool writable()
const {
return Data && Data->NumRefs == 1; }
263 Data =
new VectorData();
271 if (Data->NumRefs <= 1)
281 Data =
new VectorData();
284 if (Data->NumRefs == 1)
287 Data =
new VectorData(*Data);
302 const std::vector<T> &
elements()
const {
return Data->Vect; }
316 assert(
writable() &&
"Vector is not writable!");
322 assert(
writable() &&
"Vector is not writable!");
323 Data->Vect.push_back(Elem);
329 assert(
writable() &&
"Vector is not writable!");
330 return Data->Vect[i];
335 assert(
writable() &&
"Vector is not writable!");
336 Data->Vect.erase(Data->Vect.begin() + i, Data->Vect.end());
350 inline std::ostream&
operator<<(std::ostream& ss,
const StringRef str) {
351 return ss.write(str.data(), str.size());
358 #endif // LLVM_CLANG_THREAD_SAFETY_UTIL_H
SimpleArray(T *Dat, size_t Cp, size_t Sz=0)
void push_back(const T &Elem)
Defines the clang::Expr interface and subclasses for C++ expressions.
const T & operator[](unsigned i) const
void push_back(const T &Elem)
std::vector< T >::const_iterator const_iterator
T * allocateT(size_t NumElems)
void downsize(unsigned i)
llvm::iterator_range< const_reverse_iterator > reverse() const
llvm::iterator_range< reverse_iterator > reverse()
const_iterator end() const
std::reverse_iterator< const_iterator > const_reverse_iterator
CopyOnWriteVector clone()
const_iterator begin() const
std::reverse_iterator< iterator > reverse_iterator
reverse_iterator rbegin()
T & operator[](unsigned i)
Encodes a location in the source. The SourceManager can decode this to get at the full include stack...
const std::vector< T > & elements() const
std::ostream & operator<<(std::ostream &ss, const StringRef str)
CopyOnWriteVector & operator=(CopyOnWriteVector &&V)
bool sameAs(const CopyOnWriteVector &V) const
std::string getSourceLiteralString(const clang::Expr *CE)
void reserveCheck(size_t N, MemRegionRef A)
const_iterator cend() const
const_iterator cbegin() const
static __inline__ uint32_t volatile uint32_t * p
SimpleArray(SimpleArray< T > &&A)
const_reverse_iterator rend() const
unsigned append(Iter I, Iter E)
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)
const_reverse_iterator rbegin() const
const T & operator[](unsigned i) const
CopyOnWriteVector(CopyOnWriteVector &&V)
const_iterator begin() const
const_iterator end() const