14#ifndef LLVM_ADT_SMALLVECTOR_H
15#define LLVM_ADT_SMALLVECTOR_H
26#include <initializer_list>
40template <
class Iterator>
42 typename std::iterator_traits<Iterator>::iterator_category,
43 std::input_iterator_tag>::value>;
60 return std::numeric_limits<Size_T>::max();
91 Size =
static_cast<Size_T
>(
N);
107 std::conditional_t<
sizeof(
T) < 4 &&
sizeof(
void *) >= 8,
uint64_t,
120template <
typename T,
typename =
void>
130 return const_cast<void *
>(
reinterpret_cast<const void *
>(
131 reinterpret_cast<const char *
>(
this) +
155 std::less<> LessThan;
156 return !LessThan(V,
First) && LessThan(V,
Last);
168 std::less<> LessThan;
170 !LessThan(this->
end(), Last);
181 if (NewSize <= this->
size())
182 return Elt < this->
begin() + NewSize;
191 "Attempting to reference an element of the vector in an operation "
192 "that invalidates it");
202 template <
class ItTy>
204 if constexpr (std::is_pointer_v<ItTy> &&
206 std::remove_const_t<std::remove_pointer_t<ItTy>>,
207 std::remove_const_t<T>>) {
217 if constexpr (std::is_pointer_v<ItTy> &&
218 std::is_same_v<std::remove_cv_t<std::remove_pointer_t<ItTy>>,
234 size_t NewSize = This->size() +
N;
238 bool ReferencesStorage =
false;
240 if (!U::TakesParamByValue) {
242 ReferencesStorage =
true;
243 Index = &Elt - This->begin();
247 return ReferencesStorage ? This->begin() + Index : &Elt;
329template <
typename T,
bool = (std::is_trivially_copy_constructible<T>::value) &&
330 (std::is_trivially_move_constructible<T>::value) &&
331 std::is_trivially_destructible<T>::value>
350 template<
typename It1,
typename It2>
352 std::uninitialized_move(
I,
E, Dest);
357 template<
typename It1,
typename It2>
359 std::uninitialized_copy(
I,
E, Dest);
387 return const_cast<T *
>(
398 std::uninitialized_fill_n(NewElts, NumElts, Elt);
408 ::new ((
void *)(NewElts + this->
size()))
T(std::forward<ArgTypes>(Args)...);
418 ::new ((
void *)this->
end())
T(*EltPtr);
424 ::new ((
void *)this->
end())
T(::std::move(*EltPtr));
435template <
typename T,
bool TriviallyCopyable>
443template <
typename T,
bool TriviallyCopyable>
445 size_t MinSize,
size_t &NewCapacity) {
446 return static_cast<T *
>(
448 this->
getFirstEl(), MinSize,
sizeof(
T), NewCapacity));
452template <
typename T,
bool TriviallyCopyable>
463template <
typename T,
bool TriviallyCopyable>
465 T *NewElts,
size_t NewCapacity) {
488 using ValueParamT = std::conditional_t<TakesParamByValue, T, const T &>;
497 template<
typename It1,
typename It2>
505 template<
typename It1,
typename It2>
508 std::uninitialized_copy(
I,
E, Dest);
513 template <
typename T1,
typename T2>
516 std::enable_if_t<std::is_same<std::remove_const_t<T1>, T2>::value> * =
523 std::memcpy(
reinterpret_cast<void *
>(Dest),
I, (
E -
I) *
sizeof(
T));
539 return const_cast<T *
>(
551 std::uninitialized_fill_n(this->
begin(), NumElts, Elt);
559 push_back(
T(std::forward<ArgTypes>(Args)...));
566 std::memcpy(
reinterpret_cast<void *
>(this->
end()), EltPtr,
sizeof(
T));
622 template <
bool ForOverwrite>
void resizeImpl(size_type
N) {
623 if (
N == this->
size())
632 for (
auto I = this->
end(),
E = this->
begin() + N;
I !=
E; ++
I)
648 assert(this->
size() >= N &&
"Cannot increase size with truncate");
654 if (
N == this->
size())
677 T Result = ::std::move(this->
back());
685 template <
typename ItTy,
typename = EnableIfConvertibleToInputIterator<ItTy>>
688 size_type NumInputs = std::distance(in_start, in_end);
697 std::uninitialized_fill_n(this->
end(), NumInputs, *EltPtr);
701 void append(std::initializer_list<T> IL) {
702 append(IL.begin(), IL.end());
715 std::fill_n(this->
begin(), std::min(NumElts, this->
size()), Elt);
716 if (NumElts > this->
size())
717 std::uninitialized_fill_n(this->
end(), NumElts - this->
size(), Elt);
718 else if (NumElts < this->
size())
726 template <
typename ItTy,
typename = EnableIfConvertibleToInputIterator<ItTy>>
733 void assign(std::initializer_list<T> IL) {
748 std::move(
I+1, this->
end(), I);
774 std::is_same<std::remove_const_t<std::remove_reference_t<ArgType>>,
776 "ArgType must be derived from T!");
778 if (
I == this->
end()) {
779 this->
push_back(::std::forward<ArgType>(Elt));
780 return this->
end()-1;
786 size_t Index =
I - this->
begin();
787 std::remove_reference_t<ArgType> *EltPtr =
789 I = this->
begin() + Index;
793 std::move_backward(
I, this->
end()-1, this->
end());
799 "ArgType must be 'T' when taking by value!");
803 *
I = ::
std::forward<ArgType>(*EltPtr);
818 size_t InsertElt =
I - this->
begin();
820 if (I == this->
end()) {
822 return this->
begin()+InsertElt;
832 I = this->
begin()+InsertElt;
838 if (
size_t(this->
end()-I) >= NumToInsert) {
839 T *OldEnd = this->
end();
840 append(std::move_iterator<iterator>(this->
end() - NumToInsert),
841 std::move_iterator<iterator>(this->
end()));
844 std::move_backward(
I, OldEnd-NumToInsert, OldEnd);
849 EltPtr += NumToInsert;
851 std::fill_n(
I, NumToInsert, *EltPtr);
859 T *OldEnd = this->
end();
861 size_t NumOverwritten = OldEnd-
I;
867 EltPtr += NumToInsert;
870 std::fill_n(
I, NumOverwritten, *EltPtr);
873 std::uninitialized_fill_n(OldEnd, NumToInsert - NumOverwritten, *EltPtr);
877 template <
typename ItTy,
typename = EnableIfConvertibleToInputIterator<ItTy>>
880 size_t InsertElt =
I - this->
begin();
882 if (I == this->
end()) {
884 return this->
begin()+InsertElt;
892 size_t NumToInsert = std::distance(From, To);
898 I = this->
begin()+InsertElt;
904 if (
size_t(this->
end()-I) >= NumToInsert) {
905 T *OldEnd = this->
end();
906 append(std::move_iterator<iterator>(this->
end() - NumToInsert),
907 std::move_iterator<iterator>(this->
end()));
910 std::move_backward(
I, OldEnd-NumToInsert, OldEnd);
912 std::copy(From, To,
I);
920 T *OldEnd = this->
end();
922 size_t NumOverwritten = OldEnd-
I;
926 for (
T *J =
I; NumOverwritten > 0; --NumOverwritten) {
937 insert(
I, IL.begin(), IL.end());
944 ::new ((
void *)this->
end())
T(std::forward<ArgTypes>(Args)...);
954 if (this->
size() != RHS.
size())
return false;
958 return !(*
this ==
RHS);
962 return std::lexicographical_compare(this->
begin(), this->
end(),
972 if (
this == &
RHS)
return;
985 size_t NumShared = this->
size();
986 if (NumShared >
RHS.size()) NumShared =
RHS.size();
987 for (
size_type i = 0; i != NumShared; ++i)
992 size_t EltDiff = this->
size() - RHS.
size();
994 RHS.set_size(
RHS.size() + EltDiff);
997 }
else if (
RHS.size() > this->size()) {
998 size_t EltDiff =
RHS.size() - this->
size();
1002 RHS.set_size(NumShared);
1006template <
typename T>
1010 if (
this == &
RHS)
return *
this;
1014 size_t RHSSize =
RHS.size();
1015 size_t CurSize = this->
size();
1016 if (CurSize >= RHSSize) {
1020 NewEnd = std::copy(
RHS.begin(),
RHS.begin()+RHSSize, this->begin());
1022 NewEnd = this->
begin();
1039 this->
grow(RHSSize);
1040 }
else if (CurSize) {
1042 std::copy(
RHS.begin(),
RHS.begin()+CurSize, this->begin());
1047 this->begin()+CurSize);
1054template <
typename T>
1057 if (
this == &
RHS)
return *
this;
1060 if (!
RHS.isSmall()) {
1067 size_t RHSSize =
RHS.size();
1068 size_t CurSize = this->
size();
1069 if (CurSize >= RHSSize) {
1073 NewEnd = std::move(
RHS.begin(),
RHS.end(), NewEnd);
1093 this->
grow(RHSSize);
1094 }
else if (CurSize) {
1096 std::move(
RHS.begin(),
RHS.begin()+CurSize, this->begin());
1101 this->begin()+CurSize);
1112template <
typename T,
unsigned N>
1166 "You are trying to use a default number of inlined elements for "
1167 "`SmallVector<T>` but `sizeof(T)` is really big! Please use an "
1168 "explicit number of inlined elements with `SmallVector<T, N>` to make "
1169 "sure you really want that much inline storage.");
1196template <
typename T,
1218 template <
typename ItTy,
typename = EnableIfConvertibleToInputIterator<ItTy>>
1223 template <
typename RangeTy>
1226 this->
append(R.begin(), R.end());
1233 template <
typename U,
1234 typename = std::enable_if_t<std::is_convertible<U, T>::value>>
1288template <
typename T,
unsigned N>
1290 return X.capacity_in_bytes();
1293template <
typename RangeType>
1295 std::remove_const_t<std::remove_reference_t<
decltype(*std::begin(
1296 std::declval<RangeType &>()))>>;
1301template <
unsigned Size,
typename R>
1305template <
typename R>
1310template <
typename Out,
unsigned Size,
typename R>
1321#if SIZE_MAX > UINT32_MAX
1350 template<
typename T>
1357 template<
typename T,
unsigned N>
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
#define LLVM_UNLIKELY(EXPR)
#define LLVM_GSL_OWNER
LLVM_GSL_OWNER - Apply this to owning classes like SmallVector to enable lifetime warnings.
#define LLVM_LIKELY(EXPR)
This file defines DenseMapInfo traits for DenseMap.
#define offsetof(TYPE, MEMBER)
ConstantRange Range(APInt(BitWidth, Low), APInt(BitWidth, High))
static TableGen::Emitter::OptClass< SkeletonEmitter > X("gen-skeleton-class", "Generate example skeleton class")
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
This is all the stuff common to all SmallVectors.
LLVM_ABI void grow_pod(void *FirstEl, size_t MinSize, size_t TSize)
This is an implementation of the grow() method which only works on POD-like data types and is out of ...
LLVM_ABI void * mallocForGrow(void *FirstEl, size_t MinSize, size_t TSize, size_t &NewCapacity)
This is a helper for grow() that's out of line to reduce code duplication.
void set_allocation_range(void *Begin, size_t N)
Set the array data pointer to Begin and capacity to N.
SmallVectorSizeType< T > Capacity
SmallVectorSizeType< T > Size
SmallVectorBase(void *FirstEl, size_t TotalCapacity)
void set_size(size_t N)
Set the array size to N, which the current array must have enough capacity for.
static constexpr size_t SizeTypeMax()
The maximum value of the Size_T used.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
void resize_for_overwrite(size_type N)
Like resize, but T is POD, the new values won't be initialized.
void append(const SmallVectorImpl &RHS)
void pop_back_n(size_type NumItems)
void assign(const SmallVectorImpl &RHS)
SmallVectorImpl(const SmallVectorImpl &)=delete
void assign(size_type NumElts, ValueParamT Elt)
reference emplace_back(ArgTypes &&... Args)
bool operator==(const SmallVectorImpl &RHS) const
void reserve(size_type N)
typename SuperClass::reference reference
iterator insert(iterator I, size_type NumToInsert, ValueParamT Elt)
iterator erase(const_iterator CI)
iterator insert(iterator I, ItTy From, ItTy To)
typename SuperClass::const_iterator const_iterator
void assignRemote(SmallVectorImpl &&RHS)
void append(ItTy in_start, ItTy in_end)
Add the specified range to the end of the SmallVector.
void resize(size_type N, ValueParamT NV)
iterator insert(iterator I, MemoryLocation &&Elt)
bool operator>(const SmallVectorImpl &RHS) const
bool operator<(const SmallVectorImpl &RHS) const
iterator erase(const_iterator CS, const_iterator CE)
bool operator!=(const SmallVectorImpl &RHS) const
void truncate(size_type N)
Like resize, but requires that N is less than size().
void assign(ItTy in_start, ItTy in_end)
void assign(std::initializer_list< T > IL)
SmallVectorImpl(unsigned N)
void swap(SmallVectorImpl &RHS)
typename SuperClass::iterator iterator
bool operator<=(const SmallVectorImpl &RHS) const
typename SuperClass::size_type size_type
void append(std::initializer_list< T > IL)
void append(size_type NumInputs, ValueParamT Elt)
Append NumInputs copies of Elt to the end.
SmallVectorImpl & operator=(const SmallVectorImpl &RHS)
void insert(iterator I, std::initializer_list< T > IL)
SmallVectorImpl & operator=(SmallVectorImpl &&RHS)
typename SuperClass::ValueParamT ValueParamT
bool operator>=(const SmallVectorImpl &RHS) const
iterator insert(iterator I, const T &Elt)
static void uninitialized_copy(It1 I, It1 E, It2 Dest)
Copy the range [I, E) onto the uninitialized memory starting with "Dest", constructing elements into ...
static void uninitialized_move(It1 I, It1 E, It2 Dest)
Move the range [I, E) onto the uninitialized memory starting with "Dest", constructing elements into ...
std::conditional_t< TakesParamByValue, T, const T & > ValueParamT
Either const T& or T, depending on whether it's cheap enough to take parameters by value.
SmallVectorTemplateBase(size_t Size)
const T * reserveForParamAndGetAddress(const T &Elt, size_t N=1)
Reserve enough space to add one element, and return the updated element pointer in case it was a refe...
void push_back(ValueParamT Elt)
static void destroy_range(T *, T *)
T * reserveForParamAndGetAddress(T &Elt, size_t N=1)
Reserve enough space to add one element, and return the updated element pointer in case it was a refe...
static ValueParamT forward_value_param(ValueParamT V)
Copy V or return a reference, depending on ValueParamT.
T & growAndEmplaceBack(ArgTypes &&... Args)
static void uninitialized_copy(T1 *I, T1 *E, T2 *Dest, std::enable_if_t< std::is_same< std::remove_const_t< T1 >, T2 >::value > *=nullptr)
Copy the range [I, E) onto the uninitialized memory starting with "Dest", constructing elements into ...
static constexpr bool TakesParamByValue
True if it's cheap enough to take parameters by value.
void growAndAssign(size_t NumElts, T Elt)
void grow(size_t MinSize=0)
Double the size of the allocated memory, guaranteeing space for at least one more element or MinSize ...
void moveElementsForGrow(T *NewElts)
Move existing elements over to the new allocation NewElts, the middle section of grow().
static void uninitialized_copy(It1 I, It1 E, It2 Dest)
Copy the range [I, E) onto the uninitialized memory starting with "Dest", constructing elements as ne...
static T && forward_value_param(T &&V)
static void destroy_range(T *S, T *E)
T * mallocForGrow(size_t MinSize, size_t &NewCapacity)
Create a new allocation big enough for MinSize and pass back its size in NewCapacity.
static constexpr bool TakesParamByValue
SmallVectorTemplateBase(size_t Size)
T * reserveForParamAndGetAddress(T &Elt, size_t N=1)
Reserve enough space to add one element, and return the updated element pointer in case it was a refe...
void takeAllocationForGrow(T *NewElts, size_t NewCapacity)
Transfer ownership of the allocation, finishing up grow().
void growAndAssign(size_t NumElts, const T &Elt)
static const T & forward_value_param(const T &V)
static void uninitialized_move(It1 I, It1 E, It2 Dest)
Move the range [I, E) into the uninitialized memory starting with "Dest", constructing elements as ne...
void grow(size_t MinSize=0)
Grow the allocated memory (without initializing new elements), doubling the size of the allocated mem...
const T * reserveForParamAndGetAddress(const T &Elt, size_t N=1)
Reserve enough space to add one element, and return the updated element pointer in case it was a refe...
T & growAndEmplaceBack(ArgTypes &&... Args)
void push_back(const T &Elt)
bool isSmall() const
Return true if this is a smallvector which has not had dynamic memory allocated for it.
const_iterator end() const
reverse_iterator rbegin()
static const T * reserveForParamAndGetAddressImpl(U *This, const T &Elt, size_t N)
Reserve enough space to add one element, and return the updated element pointer in case it was a refe...
const T & const_reference
SmallVectorTemplateCommon(size_t Size)
const_reference operator[](size_type idx) const
void resetToSmall()
Put this vector in a state of being small.
bool isSafeToReferenceAfterResize(const void *Elt, size_t NewSize)
Return true unless Elt will be invalidated by resizing the vector to NewSize.
std::reverse_iterator< const_iterator > const_reverse_iterator
pointer data()
Return a pointer to the vector's buffer, even if empty().
bool isReferenceToRange(const void *V, const void *First, const void *Last) const
Return true if V is an internal reference to the given range.
void grow_pod(size_t MinSize, size_t TSize)
const_reverse_iterator rbegin() const
const_iterator begin() const
reference operator[](size_type idx)
size_t capacity_in_bytes() const
size_type size_in_bytes() const
ptrdiff_t difference_type
size_type max_size() const
bool isReferenceToStorage(const void *V) const
Return true if V is an internal reference to this vector.
const_reference back() const
bool isRangeInStorage(const void *First, const void *Last) const
Return true if First and Last form a valid (possibly empty) range in this vector's storage.
const_reference front() const
void assertSafeToAdd(const void *Elt, size_t N=1)
Check whether Elt will be invalidated by increasing the size of the vector by N.
void assertSafeToReferenceAfterResize(const void *Elt, size_t NewSize)
Check whether Elt will be invalidated by resizing the vector to NewSize.
void assertSafeToAddRange(ItTy From, ItTy To)
Check whether any part of the range will be invalidated by growing.
std::reverse_iterator< iterator > reverse_iterator
void assertSafeToReferenceAfterClear(ItTy From, ItTy To)
Check whether any part of the range will be invalidated by clearing.
const_reverse_iterator rend() const
const_pointer data() const
Return a pointer to the vector's buffer, even if empty().
void * getFirstEl() const
Find the address of the first element.
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
SmallVector(std::initializer_list< T > IL)
SmallVector(SmallVectorImpl< T > &&RHS)
SmallVector(ArrayRef< U > A)
SmallVector(size_t Size, const T &Value)
SmallVector & operator=(const SmallVector &RHS)
SmallVector(const iterator_range< RangeTy > &R)
SmallVector & operator=(std::initializer_list< T > IL)
SmallVector(ItTy S, ItTy E)
SmallVector(SmallVector &&RHS)
SmallVector & operator=(SmallVector &&RHS)
SmallVector(const SmallVector &RHS)
SmallVector & operator=(SmallVectorImpl< T > &&RHS)
LLVM Value Representation.
A range adaptor for a pair of iterators.
This is an optimization pass for GlobalISel generic memory operations.
std::enable_if_t< std::is_convertible< typename std::iterator_traits< Iterator >::iterator_category, std::input_iterator_tag >::value > EnableIfConvertibleToInputIterator
BitVector::size_type capacity_in_bytes(const BitVector &X)
std::remove_const_t< std::remove_reference_t< decltype(*std::begin( std::declval< RangeType & >()))> > ValueTypeFromRangeType
SmallVector< ValueTypeFromRangeType< R >, Size > to_vector(R &&Range)
Given a range of type R, iterate the entire range and return a SmallVector with elements of the vecto...
std::conditional_t< sizeof(T)< 4 &&sizeof(void *) >=8, uint64_t, uint32_t > SmallVectorSizeType
@ First
Helpers to iterate all locations in the MemoryEffectsBase class.
OutputIt move(R &&Range, OutputIt Out)
Provide wrappers to std::move which take ranges instead of having to pass begin/end explicitly.
SmallVector< Out, Size > to_vector_of(R &&Range)
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last)
Compute a hash_code for a sequence of values.
Implement std::hash so that hash_code can be used in STL containers.
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
Helper class for calculating the default number of inline elements for SmallVector<T>.
static constexpr size_t kPreferredSmallVectorSizeof
static constexpr size_t value
static constexpr size_t NumElementsThatFit
static constexpr size_t PreferredInlineBytes
static bool isEqual(const SmallVector< T, N > &LHS, const SmallVector< T, N > &RHS)
static SmallVector< T, N > getTombstoneKey()
static SmallVector< T, N > getEmptyKey()
static unsigned getHashValue(const SmallVector< T, N > &V)
An information struct used to provide DenseMap with the various necessary components for a given valu...
Figure out the offset of the first element.
char Base[sizeof(SmallVectorBase< SmallVectorSizeType< T > >)]
Storage for the SmallVector elements.
char InlineElts[N *sizeof(T)]