|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
Declarations
tools/clang/include/clang/AST/APValue.h 26 class CharUnits;
tools/clang/include/clang/AST/ASTContext.h 91 class CharUnits;
tools/clang/lib/CodeGen/CodeGenModule.h 62 class CharUnits;
tools/lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.h 19 class CharUnits;
References
include/llvm/ADT/ArrayRef.h 43 using iterator = const T *;
44 using const_iterator = const T *;
50 const T *Data = nullptr;
66 /*implicit*/ ArrayRef(const T &OneElt)
70 /*implicit*/ ArrayRef(const T *data, size_t length)
74 ArrayRef(const T *begin, const T *end)
74 ArrayRef(const T *begin, const T *end)
81 /*implicit*/ ArrayRef(const SmallVectorTemplateCommon<T, U> &Vec)
87 /*implicit*/ ArrayRef(const std::vector<T, A> &Vec)
92 /*implicit*/ constexpr ArrayRef(const std::array<T, N> &Arr)
97 /*implicit*/ constexpr ArrayRef(const T (&Arr)[N]) : Data(Arr), Length(N) {}
100 /*implicit*/ ArrayRef(const std::initializer_list<T> &Vec)
145 const T *data() const { return Data; }
151 const T &front() const {
157 const T &back() const {
163 template <typename Allocator> ArrayRef<T> copy(Allocator &A) {
178 ArrayRef<T> slice(size_t N, size_t M) const {
184 ArrayRef<T> slice(size_t N) const { return slice(N, size() - N); }
187 ArrayRef<T> drop_front(size_t N = 1) const {
193 ArrayRef<T> drop_back(size_t N = 1) const {
200 template <class PredicateT> ArrayRef<T> drop_while(PredicateT Pred) const {
206 template <class PredicateT> ArrayRef<T> drop_until(PredicateT Pred) const {
211 ArrayRef<T> take_front(size_t N = 1) const {
218 ArrayRef<T> take_back(size_t N = 1) const {
226 template <class PredicateT> ArrayRef<T> take_while(PredicateT Pred) const {
232 template <class PredicateT> ArrayRef<T> take_until(PredicateT Pred) const {
239 const T &operator[](size_t Index) const {
249 typename std::enable_if<std::is_same<U, T>::value, ArrayRef<T>>::type &
257 typename std::enable_if<std::is_same<U, T>::value, ArrayRef<T>>::type &
263 std::vector<T> vec() const {
270 operator std::vector<T>() const {
468 ArrayRef<T> makeArrayRef(const SmallVectorImpl<T> &Vec) {
468 ArrayRef<T> makeArrayRef(const SmallVectorImpl<T> &Vec) {
474 ArrayRef<T> makeArrayRef(const SmallVector<T, N> &Vec) {
474 ArrayRef<T> makeArrayRef(const SmallVector<T, N> &Vec) {
include/llvm/ADT/DenseMap.h 40 struct DenseMapPair : public std::pair<KeyT, ValueT> {
40 struct DenseMapPair : public std::pair<KeyT, ValueT> {
43 KeyT &getFirst() { return std::pair<KeyT, ValueT>::first; }
44 const KeyT &getFirst() const { return std::pair<KeyT, ValueT>::first; }
45 ValueT &getSecond() { return std::pair<KeyT, ValueT>::second; }
46 const ValueT &getSecond() const { return std::pair<KeyT, ValueT>::second; }
65 using key_type = KeyT;
66 using mapped_type = ValueT;
69 using iterator = DenseMapIterator<KeyT, ValueT, KeyInfoT, BucketT>;
69 using iterator = DenseMapIterator<KeyT, ValueT, KeyInfoT, BucketT>;
71 DenseMapIterator<KeyT, ValueT, KeyInfoT, BucketT, true>;
71 DenseMapIterator<KeyT, ValueT, KeyInfoT, BucketT, true>;
123 is_trivially_copyable<ValueT>::value) {
145 size_type count(const_arg_type_t<KeyT> Val) const {
150 iterator find(const_arg_type_t<KeyT> Val) {
156 const_iterator find(const_arg_type_t<KeyT> Val) const {
185 ValueT lookup(const_arg_type_t<KeyT> Val) const {
185 ValueT lookup(const_arg_type_t<KeyT> Val) const {
195 std::pair<iterator, bool> insert(const std::pair<KeyT, ValueT> &KV) {
195 std::pair<iterator, bool> insert(const std::pair<KeyT, ValueT> &KV) {
202 std::pair<iterator, bool> insert(std::pair<KeyT, ValueT> &&KV) {
202 std::pair<iterator, bool> insert(std::pair<KeyT, ValueT> &&KV) {
210 std::pair<iterator, bool> try_emplace(KeyT &&Key, Ts &&... Args) {
219 InsertIntoBucket(TheBucket, std::move(Key), std::forward<Ts>(Args)...);
229 std::pair<iterator, bool> try_emplace(const KeyT &Key, Ts &&... Args) {
249 std::pair<iterator, bool> insert_as(std::pair<KeyT, ValueT> &&KV,
249 std::pair<iterator, bool> insert_as(std::pair<KeyT, ValueT> &&KV,
272 bool erase(const KeyT &Val) {
291 value_type& FindAndConstruct(const KeyT &Key) {
299 ValueT &operator[](const KeyT &Key) {
299 ValueT &operator[](const KeyT &Key) {
303 value_type& FindAndConstruct(KeyT &&Key) {
311 ValueT &operator[](KeyT &&Key) {
311 ValueT &operator[](KeyT &&Key) {
334 const KeyT EmptyKey = getEmptyKey(), TombstoneKey = getTombstoneKey();
349 const KeyT EmptyKey = getEmptyKey();
351 ::new (&B->getFirst()) KeyT(EmptyKey);
369 const KeyT EmptyKey = getEmptyKey();
370 const KeyT TombstoneKey = getTombstoneKey();
380 ::new (&DestBucket->getSecond()) ValueT(std::move(B->getSecond()));
392 const DenseMapBase<OtherBaseT, KeyT, ValueT, KeyInfoT, BucketT> &other) {
392 const DenseMapBase<OtherBaseT, KeyT, ValueT, KeyInfoT, BucketT> &other) {
400 is_trivially_copyable<ValueT>::value)
410 ValueT(other.getBuckets()[i].getSecond());
414 static unsigned getHashValue(const KeyT &Val) {
419 static unsigned getHashValue(const LookupKeyT &Val) {
423 static const KeyT getEmptyKey() {
429 static const KeyT getTombstoneKey() {
447 if (shouldReverseIterate<KeyT>()) {
515 BucketT *InsertIntoBucket(BucketT *TheBucket, KeyArg &&Key,
516 ValueArgs &&... Values) {
520 ::new (&TheBucket->getSecond()) ValueT(std::forward<ValueArgs>(Values)...);
520 ::new (&TheBucket->getSecond()) ValueT(std::forward<ValueArgs>(Values)...);
525 BucketT *InsertIntoBucketWithLookup(BucketT *TheBucket, KeyT &&Key,
526 ValueT &&Value, LookupKeyT &Lookup) {
535 BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
535 BucketT *InsertIntoBucketImpl(const KeyT &Key, const LookupKeyT &Lookup,
566 const KeyT EmptyKey = getEmptyKey();
578 bool LookupBucketFor(const LookupKeyT &Val,
590 const KeyT EmptyKey = getEmptyKey();
591 const KeyT TombstoneKey = getTombstoneKey();
629 bool LookupBucketFor(const LookupKeyT &Val, BucketT *&FoundBucket) {
684 class DenseMap : public DenseMapBase<DenseMap<KeyT, ValueT, KeyInfoT, BucketT>,
684 class DenseMap : public DenseMapBase<DenseMap<KeyT, ValueT, KeyInfoT, BucketT>,
685 KeyT, ValueT, KeyInfoT, BucketT> {
685 KeyT, ValueT, KeyInfoT, BucketT> {
690 using BaseT = DenseMapBase<DenseMap, KeyT, ValueT, KeyInfoT, BucketT>;
690 using BaseT = DenseMapBase<DenseMap, KeyT, ValueT, KeyInfoT, BucketT>;
1163 using ConstIterator = DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, true>;
1163 using ConstIterator = DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, true>;
1186 if (shouldReverseIterate<KeyT>()) {
1199 const DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, IsConstSrc> &I)
1199 const DenseMapIterator<KeyT, ValueT, KeyInfoT, Bucket, IsConstSrc> &I)
1210 if (shouldReverseIterate<KeyT>())
1249 const KeyT Empty = KeyInfoT::getEmptyKey();
1250 const KeyT Tombstone = KeyInfoT::getTombstoneKey();
1259 const KeyT Empty = KeyInfoT::getEmptyKey();
1260 const KeyT Tombstone = KeyInfoT::getTombstoneKey();
include/llvm/ADT/DenseMapInfo.h 186 using Pair = std::pair<T, U>;
188 using SecondInfo = DenseMapInfo<U>;
include/llvm/ADT/Optional.h 144 T value;
160 explicit OptionalStorage(in_place_t, Args &&... args)
161 : value(std::forward<Args>(args)...), hasVal(true) {}
172 T &getValue() LLVM_LVALUE_FUNCTION noexcept {
176 T const &getValue() const LLVM_LVALUE_FUNCTION noexcept {
181 T &&getValue() && noexcept {
216 optional_detail::OptionalStorage<T> Storage;
219 using value_type = T;
224 Optional(const T &y) : Storage(optional_detail::in_place_t{}, y) {}
227 Optional(T &&y) : Storage(optional_detail::in_place_t{}, std::move(y)) {}
230 Optional &operator=(T &&y) {
241 static inline Optional create(const T *y) {
245 Optional &operator=(const T &y) {
253 const T *getPointer() const { return &Storage.getValue(); }
254 T *getPointer() { return &Storage.getValue(); }
255 const T &getValue() const LLVM_LVALUE_FUNCTION { return Storage.getValue(); }
256 T &getValue() LLVM_LVALUE_FUNCTION { return Storage.getValue(); }
260 const T *operator->() const { return getPointer(); }
261 T *operator->() { return getPointer(); }
262 const T &operator*() const LLVM_LVALUE_FUNCTION { return getValue(); }
263 T &operator*() LLVM_LVALUE_FUNCTION { return getValue(); }
266 constexpr T getValueOr(U &&value) const LLVM_LVALUE_FUNCTION {
271 T &&getValue() && { return std::move(Storage.getValue()); }
272 T &&operator*() && { return std::move(Storage.getValue()); }
275 T getValueOr(U &&value) && {
include/llvm/ADT/STLExtras.h 108 Ret (*callback)(intptr_t callable, Params ...params) = nullptr;
112 static Ret callback_fn(intptr_t callable, Params ...params) {
114 std::forward<Params>(params)...);
129 Ret operator()(Params ...params) const {
130 return callback(callable, std::forward<Params>(params)...);
211 typename std::remove_reference<FuncReturnTy>::type> {
218 FuncReturnTy operator*() { return F(*this->I); }
1042 inline int (*get_array_pod_sort_comparator(const T &))
1044 return array_pod_sort_comparator<T>;
include/llvm/ADT/SmallVector.h 75 AlignedCharArrayUnion<T> FirstEl;
114 using value_type = T;
115 using iterator = T *;
116 using const_iterator = const T *;
121 using reference = T &;
122 using const_reference = const T &;
123 using pointer = T *;
124 using const_pointer = const T *;
259 class SmallVectorTemplateBase<T, true> : public SmallVectorTemplateCommon<T> {
264 static void destroy_range(T *, T *) {}
264 static void destroy_range(T *, T *) {}
286 T1 *I, T1 *E, T2 *Dest,
286 T1 *I, T1 *E, T2 *Dest,
286 T1 *I, T1 *E, T2 *Dest,
287 typename std::enable_if<std::is_same<typename std::remove_const<T1>::type,
288 T2>::value>::type * = nullptr) {
294 memcpy(reinterpret_cast<void *>(Dest), I, (E - I) * sizeof(T));
299 void grow(size_t MinSize = 0) { this->grow_pod(MinSize, sizeof(T)); }
302 void push_back(const T &Elt) {
305 memcpy(reinterpret_cast<void *>(this->end()), &Elt, sizeof(T));
315 class SmallVectorImpl : public SmallVectorTemplateBase<T> {
316 using SuperClass = SmallVectorTemplateBase<T>;
357 void resize(size_type N, const T &NV) {
374 LLVM_NODISCARD T pop_back_val() {
397 void append(size_type NumInputs, const T &Elt) {
405 void append(std::initializer_list<T> IL) {
412 void assign(size_type NumElts, const T &Elt) {
429 void assign(std::initializer_list<T> IL) {
467 iterator insert(iterator I, T &&Elt) {
497 iterator insert(iterator I, const T &Elt) {
526 iterator insert(iterator I, size_type NumToInsert, const T &Elt) {
606 T *OldEnd = this->end();
621 T *OldEnd = this->end();
627 for (T *J = I; NumOverwritten > 0; --NumOverwritten) {
637 void insert(iterator I, std::initializer_list<T> IL) {
641 template <typename... ArgTypes> reference emplace_back(ArgTypes &&... Args) {
644 ::new ((void *)this->end()) T(std::forward<ArgTypes>(Args)...);
820 AlignedCharArrayUnion<T> InlineElts[N];
837 class SmallVector : public SmallVectorImpl<T>, SmallVectorStorage<T, N> {
837 class SmallVector : public SmallVectorImpl<T>, SmallVectorStorage<T, N> {
846 explicit SmallVector(size_t Size, const T &Value = T())
865 SmallVector(std::initializer_list<T> IL) : SmallVectorImpl<T>(N) {
884 SmallVector(SmallVectorImpl<T> &&RHS) : SmallVectorImpl<T>(N) {
include/llvm/ADT/StringMap.h 134 StringMapEntryStorage(size_t strLen, InitTy &&... InitVals)
160 using StringMapEntryStorage<ValueTy>::StringMapEntryStorage;
179 InitTy &&... InitVals) {
204 static StringMapEntry *Create(StringRef Key, InitType &&... InitVal) {
432 std::pair<iterator, bool> try_emplace(StringRef Key, ArgsTy &&... Args) {
include/llvm/ADT/iterator.h 68 : public std::iterator<IteratorCategoryT, T, DifferenceTypeT, PointerT,
206 : public iterator_facade_base<DerivedT, IteratorCategoryT, T,
include/llvm/Support/AlignOf.h 30 T t;
39 template <typename T> union SizerImpl<T> { char arr[sizeof(T)]; };
50 llvm::detail::SizerImpl<T, Ts...>)];
include/llvm/Support/type_traits.h 65 using type = const T &;
91 T t;
122 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{});
122 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{});
122 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<const F &>(), std::true_type{});
130 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
130 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
130 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
145 std::is_copy_constructible<detail::trivial_helper<T>>::value;
147 !std::is_copy_constructible<T>::value;
151 std::is_move_constructible<detail::trivial_helper<T>>::value;
153 !std::is_move_constructible<T>::value;
157 is_copy_assignable<detail::trivial_helper<T>>::value;
159 !is_copy_assignable<T>::value;
163 is_move_assignable<detail::trivial_helper<T>>::value;
165 !is_move_assignable<T>::value;
169 std::is_destructible<detail::trivial_helper<T>>::value;
tools/clang/include/clang/AST/APValue.h 306 APValue(LValueBase B, const CharUnits &O, NoLValuePath N,
311 APValue(LValueBase B, const CharUnits &O, ArrayRef<LValuePathEntry> Path,
443 CharUnits &getLValueOffset();
444 const CharUnits &getLValueOffset() const {
576 void setLValue(LValueBase B, const CharUnits &O, NoLValuePath,
578 void setLValue(LValueBase B, const CharUnits &O,
tools/clang/include/clang/AST/ASTContext.h 1848 CharUnits getObjCEncodingTypeSize(QualType T) const;
2097 CharUnits toCharUnitsFromBits(int64_t BitSize) const;
2100 int64_t toBits(CharUnits CharSize) const;
2104 CharUnits getTypeSizeInChars(QualType T) const;
2105 CharUnits getTypeSizeInChars(const Type *T) const;
2107 Optional<CharUnits> getTypeSizeInCharsIfKnown(QualType Ty) const {
2113 Optional<CharUnits> getTypeSizeInCharsIfKnown(const Type *Ty) const {
2139 CharUnits getTypeAlignInChars(QualType T) const;
2140 CharUnits getTypeAlignInChars(const Type *T) const;
2145 CharUnits getTypeUnadjustedAlignInChars(QualType T) const;
2146 CharUnits getTypeUnadjustedAlignInChars(const Type *T) const;
2150 std::pair<CharUnits, CharUnits> getTypeInfoDataSizeInChars(QualType T) const;
2150 std::pair<CharUnits, CharUnits> getTypeInfoDataSizeInChars(QualType T) const;
2152 std::pair<CharUnits, CharUnits> getTypeInfoInChars(const Type *T) const;
2152 std::pair<CharUnits, CharUnits> getTypeInfoInChars(const Type *T) const;
2153 std::pair<CharUnits, CharUnits> getTypeInfoInChars(QualType T) const;
2153 std::pair<CharUnits, CharUnits> getTypeInfoInChars(QualType T) const;
2177 CharUnits getAlignOfGlobalVarInChars(QualType T) const;
2189 CharUnits getDeclAlign(const Decl *D, bool ForAlignof = false) const;
2194 CharUnits getExnObjectAlignment() const {
2249 CharUnits getOffsetOfBaseWithVBPtr(const CXXRecordDecl *RD) const;
tools/clang/include/clang/AST/BaseSubobject.h 35 CharUnits BaseOffset;
39 BaseSubobject(const CXXRecordDecl *Base, CharUnits BaseOffset)
46 CharUnits getBaseOffset() const { return BaseOffset; }
61 clang::CharUnits::fromQuantity(DenseMapInfo<int64_t>::getEmptyKey()));
67 clang::CharUnits::fromQuantity(DenseMapInfo<int64_t>::getTombstoneKey()));
71 using PairTy = std::pair<const clang::CXXRecordDecl *, clang::CharUnits>;
tools/clang/include/clang/AST/CharUnits.h 53 static CharUnits Zero() {
58 static CharUnits One() {
63 static CharUnits fromQuantity(QuantityType Quantity) {
68 CharUnits& operator+= (const CharUnits &Other) {
68 CharUnits& operator+= (const CharUnits &Other) {
72 CharUnits& operator++ () {
76 CharUnits operator++ (int) {
79 CharUnits& operator-= (const CharUnits &Other) {
79 CharUnits& operator-= (const CharUnits &Other) {
83 CharUnits& operator-- () {
87 CharUnits operator-- (int) {
92 bool operator== (const CharUnits &Other) const {
95 bool operator!= (const CharUnits &Other) const {
100 bool operator< (const CharUnits &Other) const {
103 bool operator<= (const CharUnits &Other) const {
106 bool operator> (const CharUnits &Other) const {
109 bool operator>= (const CharUnits &Other) const {
137 bool isMultipleOf(CharUnits N) const {
142 CharUnits operator* (QuantityType N) const {
145 CharUnits &operator*= (QuantityType N) {
149 CharUnits operator/ (QuantityType N) const {
152 CharUnits &operator/= (QuantityType N) {
156 QuantityType operator/ (const CharUnits &Other) const {
159 CharUnits operator% (QuantityType N) const {
162 QuantityType operator% (const CharUnits &Other) const {
165 CharUnits operator+ (const CharUnits &Other) const {
165 CharUnits operator+ (const CharUnits &Other) const {
168 CharUnits operator- (const CharUnits &Other) const {
168 CharUnits operator- (const CharUnits &Other) const {
171 CharUnits operator- () const {
188 CharUnits alignTo(const CharUnits &Align) const {
188 CharUnits alignTo(const CharUnits &Align) const {
194 CharUnits alignmentAtOffset(CharUnits offset) const {
194 CharUnits alignmentAtOffset(CharUnits offset) const {
201 CharUnits alignmentOfArrayElement(CharUnits elementSize) const {
201 CharUnits alignmentOfArrayElement(CharUnits elementSize) const {
212 inline clang::CharUnits operator* (clang::CharUnits::QuantityType Scale,
212 inline clang::CharUnits operator* (clang::CharUnits::QuantityType Scale,
213 const clang::CharUnits &CU) {
220 static clang::CharUnits getEmptyKey() {
221 clang::CharUnits::QuantityType Quantity =
222 DenseMapInfo<clang::CharUnits::QuantityType>::getEmptyKey();
224 return clang::CharUnits::fromQuantity(Quantity);
227 static clang::CharUnits getTombstoneKey() {
228 clang::CharUnits::QuantityType Quantity =
229 DenseMapInfo<clang::CharUnits::QuantityType>::getTombstoneKey();
231 return clang::CharUnits::fromQuantity(Quantity);
234 static unsigned getHashValue(const clang::CharUnits &CU) {
235 clang::CharUnits::QuantityType Quantity = CU.getQuantity();
236 return DenseMapInfo<clang::CharUnits::QuantityType>::getHashValue(Quantity);
239 static bool isEqual(const clang::CharUnits &LHS,
240 const clang::CharUnits &RHS) {
tools/clang/include/clang/AST/ExternalASTSource.h 303 llvm::DenseMap<const CXXRecordDecl *, CharUnits> &BaseOffsets,
304 llvm::DenseMap<const CXXRecordDecl *, CharUnits> &VirtualBaseOffsets);
tools/clang/include/clang/AST/NonTrivialTypeVisitor.h 22 template <class... Ts> RetTy visit(QualType FT, Ts &&... Args) {
29 Ts &&... Args) {
51 template <class... Ts> RetTy visit(QualType FT, Ts &&... Args) {
54 std::forward<Ts>(Args)...);
59 QualType FT, Ts &&... Args) {
79 template <class... Ts> RetTy visit(QualType FT, Ts &&... Args) {
88 Ts &&... Args) {
tools/clang/include/clang/AST/OSLog.h 74 CharUnits ConstValue;
75 CharUnits Size; // size of the data, not including the header bytes
80 OSLogBufferItem(Kind kind, const Expr *expr, CharUnits size, unsigned flags,
89 OSLogBufferItem(ASTContext &Ctx, CharUnits value, unsigned flags)
105 CharUnits getConstValue() const { return ConstValue; }
106 CharUnits size() const { return Size; }
117 CharUnits size() const {
118 CharUnits result;
119 result += CharUnits::fromQuantity(2); // summary byte, num-args byte
122 result += item.size() + CharUnits::fromQuantity(2);
tools/clang/include/clang/AST/RecordLayout.h 43 CharUnits VBaseOffset;
53 VBaseInfo(CharUnits VBaseOffset, bool hasVtorDisp)
65 CharUnits Size;
68 CharUnits DataSize;
71 CharUnits Alignment;
75 CharUnits UnadjustedAlignment;
79 CharUnits RequiredAlignment;
88 CharUnits NonVirtualSize;
92 CharUnits NonVirtualAlignment;
97 CharUnits SizeOfLargestEmptySubobject;
100 CharUnits VBPtrOffset;
128 using BaseOffsetsMapTy = llvm::DenseMap<const CXXRecordDecl *, CharUnits>;
141 ASTRecordLayout(const ASTContext &Ctx, CharUnits size, CharUnits alignment,
141 ASTRecordLayout(const ASTContext &Ctx, CharUnits size, CharUnits alignment,
142 CharUnits unadjustedAlignment,
143 CharUnits requiredAlignment, CharUnits datasize,
143 CharUnits requiredAlignment, CharUnits datasize,
150 CharUnits size, CharUnits alignment,
150 CharUnits size, CharUnits alignment,
151 CharUnits unadjustedAlignment,
152 CharUnits requiredAlignment,
154 CharUnits vbptroffset,
155 CharUnits datasize,
157 CharUnits nonvirtualsize, CharUnits nonvirtualalignment,
157 CharUnits nonvirtualsize, CharUnits nonvirtualalignment,
158 CharUnits SizeOfLargestEmptySubobject,
176 CharUnits getAlignment() const { return Alignment; }
180 CharUnits getUnadjustedAlignment() const { return UnadjustedAlignment; }
183 CharUnits getSize() const { return Size; }
196 CharUnits getDataSize() const {
202 CharUnits getNonVirtualSize() const {
210 CharUnits getNonVirtualAlignment() const {
232 CharUnits getBaseClassOffset(const CXXRecordDecl *Base) const {
240 CharUnits getVBaseClassOffset(const CXXRecordDecl *VBase) const {
247 CharUnits getSizeOfLargestEmptySubobject() const {
290 CharUnits getRequiredAlignment() const {
305 CharUnits getVBPtrOffset() const {
tools/clang/include/clang/AST/VTTBuilder.h 34 CharUnits BaseOffset;
38 VTTVTable(const CXXRecordDecl *Base, CharUnits BaseOffset, bool BaseIsVirtual)
48 CharUnits getBaseOffset() const {
tools/clang/include/clang/AST/VTableBuilder.h 54 static VTableComponent MakeVCallOffset(CharUnits Offset) {
58 static VTableComponent MakeVBaseOffset(CharUnits Offset) {
62 static VTableComponent MakeOffsetToTop(CharUnits Offset) {
100 CharUnits getVCallOffset() const {
106 CharUnits getVBaseOffset() const {
112 CharUnits getOffsetToTop() const {
191 VTableComponent(Kind ComponentKind, CharUnits Offset) {
210 CharUnits getOffset() const {
214 return CharUnits::fromQuantity(Value >> 3);
367 typedef llvm::DenseMap<ClassPairTy, CharUnits>
385 const CXXRecordDecl *MostDerivedClass, CharUnits MostDerivedClassOffset,
399 CharUnits getVirtualBaseOffsetOffset(const CXXRecordDecl *RD,
427 CharUnits NonVirtualOffset;
451 CharUnits FullOffsetInMDC;
484 CharUnits VFPtrOffset;
490 : VBTableIndex(0), VBase(nullptr), VFPtrOffset(CharUnits::Zero()),
494 CharUnits VFPtrOffset, uint64_t Index)
522 typedef std::pair<const CXXRecordDecl *, CharUnits> VFTableIdTy;
553 CharUnits VFPtrOffset);
tools/clang/include/clang/CodeGen/CGFunctionInfo.h 172 static ABIArgInfo getIndirect(CharUnits Alignment, bool ByVal = true,
183 static ABIArgInfo getIndirectInReg(CharUnits Alignment, bool ByVal = true,
339 CharUnits getIndirectAlign() const {
341 return CharUnits::fromQuantity(IndirectAlign);
343 void setIndirectAlign(CharUnits IA) {
652 CharUnits getArgStructAlignment() const {
653 return CharUnits::fromQuantity(ArgStructAlign);
655 void setArgStruct(llvm::StructType *Ty, CharUnits Align) {
tools/clang/include/clang/CodeGen/CodeGenABITypes.h 92 CharUnits DstAlignment,
101 CharUnits DstAlignment,
102 CharUnits SrcAlignment,
111 CharUnits DstAlignment,
112 CharUnits SrcAlignment,
121 CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment,
121 CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment,
129 CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment,
129 CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment,
137 CharUnits DstAlignment,
tools/clang/include/clang/CodeGen/ConstantInitBuilder.h 79 CharUnits alignment,
106 mutable CharUnits CachedOffsetFromGlobal;
194 void addSize(CharUnits size);
249 CharUnits getNextOffsetFromGlobal() const {
322 CharUnits getOffsetFromGlobalTo(size_t index) const;
369 llvm::GlobalVariable *finishAndCreateGlobal(As &&...args) {
372 std::forward<As>(args)...);
tools/clang/include/clang/CodeGen/SwiftCallingConv.h 45 CharUnits Begin;
46 CharUnits End;
49 CharUnits getWidth() const {
59 void addOpaqueData(CharUnits begin, CharUnits end) {
59 void addOpaqueData(CharUnits begin, CharUnits end) {
63 void addTypedData(QualType type, CharUnits begin);
64 void addTypedData(const RecordDecl *record, CharUnits begin);
65 void addTypedData(const RecordDecl *record, CharUnits begin,
67 void addTypedData(llvm::Type *type, CharUnits begin);
68 void addTypedData(llvm::Type *type, CharUnits begin, CharUnits end);
68 void addTypedData(llvm::Type *type, CharUnits begin, CharUnits end);
92 llvm::function_ref<void(CharUnits offset, CharUnits end, llvm::Type *type)>;
92 llvm::function_ref<void(CharUnits offset, CharUnits end, llvm::Type *type)>;
111 void addBitFieldData(const FieldDecl *field, CharUnits begin,
113 void addLegalTypedData(llvm::Type *type, CharUnits begin, CharUnits end);
113 void addLegalTypedData(llvm::Type *type, CharUnits begin, CharUnits end);
114 void addEntry(llvm::Type *type, CharUnits begin, CharUnits end);
114 void addEntry(llvm::Type *type, CharUnits begin, CharUnits end);
118 CharUnits chunkSize);
128 CharUnits getMaximumVoluntaryIntegerSize(CodeGenModule &CGM);
131 CharUnits getNaturalAlignment(CodeGenModule &CGM, llvm::Type *type);
139 bool isLegalVectorType(CodeGenModule &CGM, CharUnits vectorSize,
141 bool isLegalVectorType(CodeGenModule &CGM, CharUnits vectorSize,
146 splitLegalVectorType(CodeGenModule &CGM, CharUnits vectorSize,
153 void legalizeVectorType(CodeGenModule &CGM, CharUnits vectorSize,
tools/clang/include/clang/Frontend/LayoutOverrideSource.h 53 llvm::DenseMap<const CXXRecordDecl *, CharUnits> &BaseOffsets,
55 CharUnits> &VirtualBaseOffsets) override;
tools/clang/include/clang/Sema/MultiplexExternalSemaSource.h 187 llvm::DenseMap<const CXXRecordDecl *, CharUnits> &BaseOffsets,
189 CharUnits> &VirtualBaseOffsets) override;
tools/clang/include/clang/Sema/Sema.h11580 CharUnits Alignment;
11584 CharUnits Alignment)
11597 CharUnits Alignment);
11617 llvm::function_ref<void(Expr *, RecordDecl *, FieldDecl *, CharUnits)>
tools/clang/include/clang/StaticAnalyzer/Core/PathSensitive/MemRegion.h 1068 CharUnits Offset;
1070 RegionRawOffset(const MemRegion* reg, CharUnits offset = CharUnits::Zero())
1070 RegionRawOffset(const MemRegion* reg, CharUnits offset = CharUnits::Zero())
1075 CharUnits getOffset() const { return Offset; }
tools/clang/lib/AST/APValue.cpp 95 CharUnits Offset;
535 CharUnits O = getLValueOffset();
536 CharUnits S = Ctx.getTypeSizeInChars(InnerTy);
542 S = CharUnits::One();
743 CharUnits &APValue::getLValueOffset() {
774 void APValue::setLValue(LValueBase B, const CharUnits &O, NoLValuePath,
785 void APValue::setLValue(LValueBase B, const CharUnits &O,
tools/clang/lib/AST/ASTContext.cpp 1598 CharUnits ASTContext::getDeclAlign(const Decl *D, bool ForAlignof) const {
1698 std::pair<CharUnits, CharUnits>
1698 std::pair<CharUnits, CharUnits>
1700 std::pair<CharUnits, CharUnits> sizeAndAlign = getTypeInfoInChars(T);
1700 std::pair<CharUnits, CharUnits> sizeAndAlign = getTypeInfoInChars(T);
1717 std::pair<CharUnits, CharUnits>
1717 std::pair<CharUnits, CharUnits>
1720 std::pair<CharUnits, CharUnits> EltInfo =
1720 std::pair<CharUnits, CharUnits> EltInfo =
1731 return std::make_pair(CharUnits::fromQuantity(Width),
1732 CharUnits::fromQuantity(Align));
1735 std::pair<CharUnits, CharUnits>
1735 std::pair<CharUnits, CharUnits>
1744 std::pair<CharUnits, CharUnits>
1744 std::pair<CharUnits, CharUnits>
2246 CharUnits ASTContext::toCharUnitsFromBits(int64_t BitSize) const {
2247 return CharUnits::fromQuantity(BitSize / getCharWidth());
2251 int64_t ASTContext::toBits(CharUnits CharSize) const {
2257 CharUnits ASTContext::getTypeSizeInChars(QualType T) const {
2260 CharUnits ASTContext::getTypeSizeInChars(const Type *T) const {
2266 CharUnits ASTContext::getTypeAlignInChars(QualType T) const {
2269 CharUnits ASTContext::getTypeAlignInChars(const Type *T) const {
2276 CharUnits ASTContext::getTypeUnadjustedAlignInChars(QualType T) const {
2279 CharUnits ASTContext::getTypeUnadjustedAlignInChars(const Type *T) const {
2332 CharUnits ASTContext::getAlignOfGlobalVarInChars(QualType T) const {
2336 CharUnits ASTContext::getOffsetOfBaseWithVBPtr(const CXXRecordDecl *RD) const {
2337 CharUnits Offset = CharUnits::Zero();
2337 CharUnits Offset = CharUnits::Zero();
2405 CharUnits UnionSize = Context.getTypeSizeInChars(RD->getTypeForDecl());
2410 CharUnits FieldSize = Context.getTypeSizeInChars(Field->getType());
6272 CharUnits ASTContext::getObjCEncodingTypeSize(QualType type) const {
6274 return CharUnits::Zero();
6276 CharUnits sz = getTypeSizeInChars(type);
6315 static std::string charUnitsToString(const CharUnits &CU) {
6337 CharUnits PtrSize = getTypeSizeInChars(VoidPtrTy);
6338 CharUnits ParmOffset = PtrSize;
6341 CharUnits sz = getObjCEncodingTypeSize(PType);
6381 CharUnits ParmOffset;
6385 CharUnits sz = getObjCEncodingTypeSize(PType);
6394 ParmOffset = CharUnits::Zero();
6445 CharUnits PtrSize = getTypeSizeInChars(VoidPtrTy);
6448 CharUnits ParmOffset = 2 * PtrSize;
6452 CharUnits sz = getObjCEncodingTypeSize(PType);
7187 CharUnits size;
10377 CharUnits sizeChars = getTypeSizeInChars(AtomicTy);
10379 CharUnits alignChars = getTypeAlignInChars(AtomicTy);
tools/clang/lib/AST/Expr.cpp 2195 return APValue(Res, CharUnits::Zero(), Path, /*OnePastTheEnd=*/false);
tools/clang/lib/AST/ExprConstant.cpp 1464 CharUnits Offset;
1470 CharUnits &getLValueOffset() { return Offset; }
1471 const CharUnits &getLValueOffset() const { return Offset; }
1508 Offset = CharUnits::fromQuantity(0);
1517 CharUnits::fromQuantity(Ctx.getTargetNullPointerValue(PointerTy));
1599 const APSInt &Index, CharUnits ElementSize) {
1611 Offset = CharUnits::fromQuantity(Offset64 + ElemSize64 * Index64);
1617 void adjustOffset(CharUnits N) {
2748 QualType Type, CharUnits &Size) {
2752 Size = CharUnits::One();
2781 CharUnits SizeOfPointee;
2805 CharUnits SizeOfComponent;
5991 CharUnits ElemSize;
6139 BitCastBuffer(CharUnits Width, bool TargetIsLittleEndian)
6144 bool readObject(CharUnits Offset, CharUnits Width,
6144 bool readObject(CharUnits Offset, CharUnits Width,
6146 for (CharUnits I = Offset, E = Offset + Width; I != E; ++I) {
6158 void writeObject(CharUnits Offset, SmallVectorImpl<unsigned char> &Input) {
6180 APValueToBufferConverter(EvalInfo &Info, CharUnits ObjectWidth,
6187 return visit(Val, Ty, CharUnits::fromQuantity(0));
6191 bool visit(const APValue &Val, QualType Ty, CharUnits Offset) {
6234 bool visitRecord(const APValue &Val, QualType Ty, CharUnits Offset) {
6263 CharUnits FieldOffset =
6274 bool visitArray(const APValue &Val, QualType Ty, CharUnits Offset) {
6280 CharUnits ElemWidth = Info.Ctx.getTypeSizeInChars(CAT->getElementType());
6302 bool visitInt(const APSInt &Val, QualType Ty, CharUnits Offset) {
6303 CharUnits Width = Info.Ctx.getTypeSizeInChars(Ty);
6310 bool visitFloat(const APFloat &Val, QualType Ty, CharUnits Offset) {
6318 CharUnits DstSize = Info.Ctx.getTypeSizeInChars(BCE->getType());
6346 Optional<APValue> visit(const BuiltinType *T, CharUnits Offset,
6351 /*Offset=*/CharUnits::fromQuantity(NullValue),
6355 CharUnits SizeOf = Info.Ctx.getTypeSizeInChars(T);
6392 Optional<APValue> visit(const RecordType *RTy, CharUnits Offset) {
6434 CharUnits FieldOffset =
6435 CharUnits::fromQuantity(FieldOffsetBits / Info.Ctx.getCharWidth()) +
6448 Optional<APValue> visit(const EnumType *Ty, CharUnits Offset) {
6459 Optional<APValue> visit(const ConstantArrayType *Ty, CharUnits Offset) {
6461 CharUnits ElementWidth = Info.Ctx.getTypeSizeInChars(Ty->getElementType());
6475 Optional<APValue> visit(const Type *Ty, CharUnits Offset) {
6479 Optional<APValue> visitType(QualType Ty, CharUnits Offset) {
6507 return Converter.visitType(BCE->getType(), CharUnits::fromQuantity(0));
8013 Result.Offset = CharUnits::fromQuantity(N);
8064 static CharUnits GetAlignOfType(EvalInfo &Info, QualType T,
8073 return CharUnits::One();
8091 static CharUnits GetAlignOfExpr(EvalInfo &Info, const Expr *E,
8152 CharUnits Align = CharUnits::fromQuantity(Alignment.getZExtValue());
8152 CharUnits Align = CharUnits::fromQuantity(Alignment.getZExtValue());
8160 OffsetResult.Offset += CharUnits::fromQuantity(AdditionalOffset);
8165 CharUnits BaseAlignment;
8257 if (IsRawByte && Info.Ctx.getTypeSizeInChars(CharTy) != CharUnits::One())
9689 bool Success(CharUnits Size, const Expr *E) {
10348 CharUnits &Result) {
10349 auto CharUnitsMax = std::numeric_limits<CharUnits::QuantityType>::max();
10352 Result = CharUnits::fromQuantity(Int.getZExtValue());
10364 CharUnits &EndOffset) {
10418 CharUnits BytesPerElem;
10474 CharUnits EndOffset;
10831 CharUnits CharTy1Size = Info.Ctx.toCharUnitsFromBits(CharTy1Width);
10920 CharUnits Size = CharUnits::fromQuantity(SizeVal.getZExtValue());
10920 CharUnits Size = CharUnits::fromQuantity(SizeVal.getZExtValue());
10927 Size == CharUnits::One() ||
11093 auto Size = Ctx.getTypeSizeInChars(Ty);
11261 CharUnits &Offset = LVal.getLValueOffset();
11264 Offset = CharUnits::fromQuantity(IsSub ? Offset64 - Index64
11605 const CharUnits &LHSOffset = LHSValue.getLValueOffset();
11606 const CharUnits &RHSOffset = RHSValue.getLValueOffset();
11679 CharUnits Size = Info.Ctx.getTypeSizeInChars(BaseTy);
11841 const CharUnits &LHSOffset = LHSValue.getLValueOffset();
11842 const CharUnits &RHSOffset = RHSValue.getLValueOffset();
11859 CharUnits ElementSize;
11934 CharUnits Sizeof;
11952 CharUnits Result;
11969 CharUnits ElementSize = Info.Ctx.getTypeSizeInChars(CurrentType);
tools/clang/lib/AST/ExternalASTSource.cpp 77 llvm::DenseMap<const CXXRecordDecl *, CharUnits> &BaseOffsets,
78 llvm::DenseMap<const CXXRecordDecl *, CharUnits> &VirtualBaseOffsets) {
tools/clang/lib/AST/Interp/Pointer.cpp 78 CharUnits Offset;
86 Offset = CharUnits::Zero();
102 Offset = CharUnits::Zero();
105 Offset = CharUnits::Zero();
tools/clang/lib/AST/ItaniumCXXABI.cpp 223 CharUnits PointerSize =
tools/clang/lib/AST/MicrosoftMangle.cpp 704 CharUnits PointerWidth = getASTContext().toCharUnitsFromBits(
tools/clang/lib/AST/OSLog.cpp 139 CharUnits Size = CharUnits::fromQuantity(8);
139 CharUnits Size = CharUnits::fromQuantity(8);
145 CharUnits Size = Ctx.getTypeSizeInChars((*Data.FieldWidth)->getType());
150 CharUnits Size = Ctx.getTypeSizeInChars((*Data.Precision)->getType());
156 CharUnits Size = Ctx.getTypeSizeInChars((*Data.Count)->getType());
161 Layout.Items.emplace_back(Ctx, CharUnits::fromQuantity(*Data.Size),
164 CharUnits Size;
166 Size = CharUnits::Zero();
171 auto Size = Ctx.getTypeSizeInChars(Data.E->getType());
tools/clang/lib/AST/RecordLayout.cpp 30 ASTRecordLayout::ASTRecordLayout(const ASTContext &Ctx, CharUnits size,
31 CharUnits alignment,
32 CharUnits unadjustedAlignment,
33 CharUnits requiredAlignment,
34 CharUnits datasize,
44 CharUnits size, CharUnits alignment,
44 CharUnits size, CharUnits alignment,
45 CharUnits unadjustedAlignment,
46 CharUnits requiredAlignment,
48 CharUnits vbptroffset,
49 CharUnits datasize,
51 CharUnits nonvirtualsize,
52 CharUnits nonvirtualalignment,
53 CharUnits SizeOfLargestEmptySubobject,
tools/clang/lib/AST/RecordLayoutBuilder.cpp 72 llvm::DenseMap<const CXXRecordDecl *, CharUnits> BaseOffsets;
75 llvm::DenseMap<const CXXRecordDecl *, CharUnits> VirtualBaseOffsets;
85 bool getExternalNVBaseOffset(const CXXRecordDecl *RD, CharUnits &BaseOffset) {
93 bool getExternalVBaseOffset(const CXXRecordDecl *RD, CharUnits &BaseOffset) {
113 typedef llvm::DenseMap<CharUnits, ClassVectorTy> EmptyClassOffsetsMapTy;
118 CharUnits MaxEmptyClassOffset;
124 void AddSubobjectAtOffset(const CXXRecordDecl *RD, CharUnits Offset);
127 CharUnits Offset, bool PlacingEmptyBase);
130 const CXXRecordDecl *Class, CharUnits Offset,
132 void UpdateEmptyFieldSubobjects(const FieldDecl *FD, CharUnits Offset,
137 bool AnyEmptySubobjectsBeyondOffset(CharUnits Offset) const {
141 CharUnits
152 CharUnits Offset) const;
155 CharUnits Offset);
159 CharUnits Offset) const;
161 CharUnits Offset) const;
167 CharUnits SizeOfLargestEmptySubobject;
179 CharUnits Offset);
183 bool CanPlaceFieldAtOffset(const FieldDecl *FD, CharUnits Offset);
191 CharUnits EmptySize;
214 CharUnits EmptySize;
232 CharUnits Offset) const {
250 CharUnits Offset) {
270 CharUnits Offset) {
285 CharUnits BaseOffset = Offset + Layout.getBaseClassOffset(Base->Class);
307 CharUnits FieldOffset = Offset + getFieldOffset(Layout, FieldNo);
316 CharUnits Offset,
335 CharUnits BaseOffset = Offset + Layout.getBaseClassOffset(Base->Class);
354 CharUnits FieldOffset = Offset + getFieldOffset(Layout, FieldNo);
360 CharUnits Offset) {
378 CharUnits Offset) const {
396 CharUnits BaseOffset = Offset + Layout.getBaseClassOffset(BaseDecl);
406 CharUnits VBaseOffset = Offset + Layout.getVBaseClassOffset(VBaseDecl);
419 CharUnits FieldOffset = Offset + getFieldOffset(Layout, FieldNo);
430 CharUnits Offset) const {
451 CharUnits ElementOffset = Offset;
470 CharUnits Offset) {
481 const CXXRecordDecl *RD, const CXXRecordDecl *Class, CharUnits Offset,
507 CharUnits BaseOffset = Offset + Layout.getBaseClassOffset(BaseDecl);
517 CharUnits VBaseOffset = Offset + Layout.getVBaseClassOffset(VBaseDecl);
530 CharUnits FieldOffset = Offset + getFieldOffset(Layout, FieldNo);
537 const FieldDecl *FD, CharUnits Offset, bool PlacingOverlappingField) {
555 CharUnits ElementOffset = Offset;
589 CharUnits Alignment;
592 CharUnits UnpackedAlignment;
595 CharUnits UnadjustedAlignment;
627 CharUnits MaxFieldAlignment;
632 CharUnits NonVirtualSize;
633 CharUnits NonVirtualAlignment;
637 CharUnits PaddedFieldSize;
654 typedef llvm::DenseMap<const CXXRecordDecl *, CharUnits> BaseOffsetsMapTy;
680 Alignment(CharUnits::One()), UnpackedAlignment(CharUnits::One()),
680 Alignment(CharUnits::One()), UnpackedAlignment(CharUnits::One()),
681 UnadjustedAlignment(CharUnits::One()),
685 MaxFieldAlignment(CharUnits::Zero()), DataSize(0),
686 NonVirtualSize(CharUnits::Zero()),
687 NonVirtualAlignment(CharUnits::One()),
688 PaddedFieldSize(CharUnits::Zero()), PrimaryBase(nullptr),
735 void EnsureVTablePointerAlignment(CharUnits UnpackedBaseAlign);
745 CharUnits Offset);
756 CharUnits LayoutBase(const BaseSubobjectInfo *Base);
765 void UpdateAlignment(CharUnits NewAlignment, CharUnits UnpackedNewAlignment);
765 void UpdateAlignment(CharUnits NewAlignment, CharUnits UnpackedNewAlignment);
766 void UpdateAlignment(CharUnits NewAlignment) {
784 CharUnits getSize() const {
790 void setSize(CharUnits NewSize) { Size = Context.toBits(NewSize); }
793 CharUnits getAligment() const { return Alignment; }
795 CharUnits getDataSize() const {
801 void setDataSize(CharUnits NewSize) { DataSize = Context.toBits(NewSize); }
987 CharUnits UnpackedBaseAlign) {
988 CharUnits BaseAlign = Packed ? CharUnits::One() : UnpackedBaseAlign;
988 CharUnits BaseAlign = Packed ? CharUnits::One() : UnpackedBaseAlign;
1040 CharUnits PtrWidth =
1042 CharUnits PtrAlign =
1076 CharUnits Offset = LayoutBase(Base);
1086 const BaseSubobjectInfo *Info, CharUnits Offset) {
1113 CharUnits BaseOffset = Offset + Layout.getBaseClassOffset(Base->Class);
1169 CharUnits Offset = LayoutBase(Base);
1179 CharUnits
1184 CharUnits Offset;
1198 CharUnits UnpackedBaseAlign = Layout.getNonVirtualAlignment();
1199 CharUnits BaseAlign =
1203 ? CharUnits::One()
1208 (!HasExternalLayout || Offset == CharUnits::Zero()) &&
1209 EmptySubobjects->CanPlaceBaseAtOffset(Base, CharUnits::Zero())) {
1213 return CharUnits::Zero();
1237 Alignment = CharUnits::One();
1266 MaxFieldAlignment = CharUnits::fromQuantity(DefaultMaxFieldAlignment);
1275 MaxFieldAlignment = CharUnits::fromQuantity(2);
1276 Alignment = CharUnits::fromQuantity(2);
1423 CharUnits TypeAlign = Context.getTypeAlignInChars(Type);
1752 CharUnits FieldOffset = (IsUnion || IsOverlappingEmptyField)
1753 ? CharUnits::Zero()
1755 CharUnits FieldSize;
1756 CharUnits FieldAlign;
1760 CharUnits EffectiveFieldSize;
1767 EffectiveFieldSize = FieldSize = CharUnits::Zero();
1777 std::pair<CharUnits, CharUnits> FieldInfo =
1777 std::pair<CharUnits, CharUnits> FieldInfo =
1798 CharUnits TypeSize = Context.getTypeSizeInChars(BTy);
1834 CharUnits UnpackedFieldAlign = FieldAlign;
1835 CharUnits UnpackedFieldOffset = FieldOffset;
1838 FieldAlign = CharUnits::One();
1839 CharUnits MaxAlignmentInChars =
1870 if (FieldOffset == CharUnits::Zero() &&
1871 getDataSize() != CharUnits::Zero())
1888 CharUnits ASanAlignment = CharUnits::fromQuantity(8);
1888 CharUnits ASanAlignment = CharUnits::fromQuantity(8);
1889 CharUnits ExtraSizeForAsan = ASanAlignment;
1892 ASanAlignment - CharUnits::fromQuantity(FieldSize % ASanAlignment);
1924 setSize(CharUnits::One());
1927 setSize(CharUnits::One());
1947 Alignment = CharUnits::One();
1984 CharUnits NewAlignment, CharUnits UnpackedNewAlignment) {
1984 CharUnits NewAlignment, CharUnits UnpackedNewAlignment) {
2011 Alignment = CharUnits::One();
2299 CharUnits Size;
2300 CharUnits Alignment;
2302 typedef llvm::DenseMap<const CXXRecordDecl *, CharUnits> BaseOffsetsMapTy;
2341 void placeFieldAtOffset(CharUnits FieldOffset) {
2354 CharUnits Size;
2356 CharUnits NonVirtualSize;
2358 CharUnits DataSize;
2360 CharUnits Alignment;
2362 CharUnits MaxFieldAlignment;
2365 CharUnits RequiredAlignment;
2369 CharUnits CurrentBitfieldSize;
2371 CharUnits VBPtrOffset;
2373 CharUnits MinEmptyStructSize;
2444 CharUnits FieldRequiredAlignment =
2470 Info.Alignment = CharUnits::One();
2477 MinEmptyStructSize = CharUnits::fromQuantity(4);
2488 MinEmptyStructSize = CharUnits::One();
2497 auto RoundingAlignment = Alignment;
2511 Size = CharUnits::Zero();
2512 Alignment = CharUnits::One();
2517 ? CharUnits::One()
2518 : CharUnits::Zero();
2520 MaxFieldAlignment = CharUnits::Zero();
2523 MaxFieldAlignment = CharUnits::fromQuantity(DefaultMaxFieldAlignment);
2533 MaxFieldAlignment = CharUnits::One();
2628 VBPtrOffset = CharUnits::fromQuantity(-1);
2663 CharUnits BaseOffset;
2678 BaseOffset = CharUnits::Zero();
2703 CharUnits FieldOffset;
2708 FieldOffset = CharUnits::Zero();
2740 auto NewSize = Context.toCharUnitsFromBits(
2746 placeFieldAtOffset(CharUnits::Zero());
2751 CharUnits FieldOffset = Size.alignTo(Info.Alignment);
2764 placeFieldAtOffset(IsUnion ? CharUnits::Zero() : Size);
2772 placeFieldAtOffset(CharUnits::Zero());
2777 CharUnits FieldOffset = Size.alignTo(Info.Alignment);
2788 CharUnits InjectionSite = VBPtrOffset;
2792 CharUnits FieldStart = VBPtrOffset + PointerInfo.Size;
2804 CharUnits Offset = (FieldStart - InjectionSite)
2819 CharUnits Offset =
2849 CharUnits VtorDispSize = CharUnits::fromQuantity(4);
2849 CharUnits VtorDispSize = CharUnits::fromQuantity(4);
2850 CharUnits VtorDispAlignment = VtorDispSize;
2886 CharUnits BaseOffset;
2910 auto RoundingAlignment = Alignment;
3054 Builder.NonVirtualSize, Builder.Alignment, CharUnits::Zero(),
3078 CharUnits DataSize =
3080 CharUnits NonVirtualSize =
3086 CharUnits::fromQuantity(-1), DataSize, Builder.FieldOffsets,
3262 CharUnits Offset, unsigned IndentLevel) {
3267 static void PrintBitFieldOffset(raw_ostream &OS, CharUnits Offset,
3292 CharUnits Offset,
3343 CharUnits BaseOffset = Offset + Layout.getBaseClassOffset(Base);
3363 CharUnits FieldOffset =
3395 CharUnits VBaseOffset = Offset + Layout.getVBaseClassOffset(VBase);
3398 PrintOffset(OS, VBaseOffset - CharUnits::fromQuantity(4), IndentLevel);
tools/clang/lib/AST/VTTBuilder.cpp 38 LayoutVTT(BaseSubobject(MostDerivedClass, CharUnits::Zero()),
71 CharUnits BaseOffset = Base.getBaseOffset() +
108 CharUnits BaseOffset;
166 CharUnits BaseOffset =
tools/clang/lib/AST/VTableBuilder.cpp 47 CharUnits NonVirtualOffset;
50 NonVirtualOffset(CharUnits::Zero()) { }
52 const CXXRecordDecl *VirtualBase, CharUnits NonVirtualOffset)
73 CharUnits Offset;
76 Offset(CharUnits::Zero()) { }
87 const CharUnits MostDerivedClassOffset;
101 typedef std::pair<const CXXMethodDecl *, CharUnits> MethodBaseOffsetPairTy;
114 CharUnits> SubobjectOffsetMapTy;
121 CharUnits OffsetInLayoutClass,
135 CharUnits MostDerivedClassOffset,
141 CharUnits BaseOffset) const {
151 dump(llvm::errs(), BaseSubobject(MostDerivedClass, CharUnits::Zero()),
158 CharUnits MostDerivedClassOffset,
169 ComputeBaseOffsets(BaseSubobject(MostDerivedClass, CharUnits::Zero()),
189 CharUnits BaseOffset = SubobjectOffsets[std::make_pair(MD->getParent(),
199 CharUnits OverriderOffset =
221 CharUnits NonVirtualOffset = CharUnits::Zero();
221 CharUnits NonVirtualOffset = CharUnits::Zero();
325 CharUnits OffsetInLayoutClass,
349 CharUnits BaseOffset;
350 CharUnits BaseOffsetInLayoutClass;
364 CharUnits Offset = Layout.getBaseClassOffset(BaseDecl);
389 CharUnits BaseOffset;
444 typedef std::pair<const CXXMethodDecl *, CharUnits> MethodAndOffsetPairTy;
459 bool AddVCallOffset(const CXXMethodDecl *MD, CharUnits OffsetOffset);
463 CharUnits getVCallOffsetOffset(const CXXMethodDecl *MD);
509 CharUnits OffsetOffset) {
521 CharUnits VCallOffsetMap::getVCallOffsetOffset(const CXXMethodDecl *MD) {
534 typedef llvm::DenseMap<const CXXRecordDecl *, CharUnits>
572 CharUnits RealBaseOffset);
575 void AddVCallOffsets(BaseSubobject Base, CharUnits VBaseOffset);
579 CharUnits OffsetInLayoutClass);
583 CharUnits getCurrentOffsetOffset() const;
590 CharUnits OffsetInLayoutClass)
612 CharUnits RealBaseOffset) {
627 CharUnits PrimaryBaseOffset;
658 CharUnits VCallAndVBaseOffsetBuilder::getCurrentOffsetOffset() const {
665 CharUnits PointerWidth =
667 CharUnits OffsetOffset = PointerWidth * OffsetIndex;
672 CharUnits VBaseOffset) {
696 CharUnits OffsetOffset = getCurrentOffsetOffset();
703 CharUnits Offset = CharUnits::Zero();
703 CharUnits Offset = CharUnits::Zero();
729 CharUnits BaseOffset = Base.getBaseOffset() +
739 CharUnits OffsetInLayoutClass) {
749 CharUnits Offset =
756 CharUnits VBaseOffsetOffset = getCurrentOffsetOffset();
777 typedef llvm::DenseMap<const CXXRecordDecl *, CharUnits>
794 const CharUnits MostDerivedClassOffset;
829 const CharUnits BaseOffset;
833 const CharUnits BaseOffsetInLayoutClass;
839 MethodInfo(CharUnits BaseOffset, CharUnits BaseOffsetInLayoutClass,
839 MethodInfo(CharUnits BaseOffset, CharUnits BaseOffsetInLayoutClass,
846 : BaseOffset(CharUnits::Zero()),
847 BaseOffsetInLayoutClass(CharUnits::Zero()),
903 CharUnits BaseOffsetInLayoutClass,
930 CharUnits BaseOffsetInLayoutClass,
932 CharUnits FirstBaseOffsetInLayoutClass) const;
937 void AddMethods(BaseSubobject Base, CharUnits BaseOffsetInLayoutClass,
939 CharUnits FirstBaseOffsetInLayoutClass,
957 CharUnits OffsetInLayoutClass);
965 CharUnits OffsetInLayoutClass);
970 CharUnits OffsetInLayoutClass,
991 CharUnits MostDerivedClassOffset,
1216 CharUnits OffsetToBaseSubobject = Offset.NonVirtualOffset;
1247 const CXXMethodDecl *MD, CharUnits BaseOffsetInLayoutClass,
1277 CharUnits::Zero()),
1280 CharUnits::Zero());
1341 const CXXMethodDecl *Overrider, CharUnits BaseOffsetInLayoutClass,
1343 CharUnits FirstBaseOffsetInLayoutClass) const {
1427 BaseSubobject Base, CharUnits BaseOffsetInLayoutClass,
1429 CharUnits FirstBaseOffsetInLayoutClass,
1444 CharUnits PrimaryBaseOffset;
1445 CharUnits PrimaryBaseOffsetInLayoutClass;
1603 CharUnits::Zero()),
1620 Components.push_back(VTableComponent::MakeVCallOffset(CharUnits::Zero()));
1625 bool BaseIsVirtualInLayoutClass, CharUnits OffsetInLayoutClass) {
1651 CharUnits OffsetToTop = MostDerivedClassOffset - OffsetInLayoutClass;
1722 CharUnits OffsetInLayoutClass) {
1754 CharUnits RelativeBaseOffset = Layout.getBaseClassOffset(BaseDecl);
1755 CharUnits BaseOffset = Base.getBaseOffset() + RelativeBaseOffset;
1757 CharUnits BaseOffsetInLayoutClass =
1778 const CXXRecordDecl *RD, CharUnits OffsetInLayoutClass,
1795 CharUnits PrimaryBaseOffsetInLayoutClass =
1813 CharUnits BaseOffsetInLayoutClass;
1849 CharUnits BaseOffset =
1854 CharUnits BaseOffsetInLayoutClass =
2041 CharUnits BaseOffset =
2071 std::map<std::string, CharUnits> ClassNamesAndOffsets;
2074 CharUnits OffsetOffset = I.second;
2238 CharUnits
2249 BaseSubobject(RD, CharUnits::Zero()),
2251 /*OffsetInLayoutClass=*/CharUnits::Zero());
2284 ItaniumVTableBuilder Builder(*this, RD, CharUnits::Zero(),
2316 const CXXRecordDecl *MostDerivedClass, CharUnits MostDerivedClassOffset,
2462 CharUnits ComputeThisOffset(FinalOverriders::OverriderInfo Overrider);
2465 CharUnits ThisOffset, ThisAdjustment &TA);
2495 AddMethods(BaseSubobject(MostDerivedClass, CharUnits::Zero()), 0, nullptr,
2623 CharUnits
2657 CharUnits Ret;
2663 CharUnits ThisOffset = Overrider.Offset;
2664 CharUnits LastVBaseOffset;
2815 FinalOverriders::OverriderInfo Overrider, CharUnits ThisOffset,
2831 CharUnits OffsetOfVBaseWithVFPtr = VBaseMapEntry->second.VBaseOffset;
2906 CharUnits NextBaseOffset;
2951 CharUnits ThisOffset = ComputeThisOffset(FinalOverrider);
3379 const CXXRecordDecl *RD, CharUnits Offset,
3392 CharUnits NewOffset = BS.isVirtual()
3418 static CharUnits getOffsetOfFullPath(ASTContext &Context,
3423 CharUnits Offset = CharUnits::fromQuantity(-1);
3423 CharUnits Offset = CharUnits::fromQuantity(-1);
3429 Offset = CharUnits::Zero();
3469 CharUnits BaseOffset =
3471 FinalOverriders Overriders(TopLevelRD, CharUnits::Zero(), TopLevelRD);
3528 Context, MostDerivedLayout, RD, CharUnits::Zero(),
3545 CharUnits L = LHS.VFPtrOffset;
3546 CharUnits R = RHS.VFPtrOffset;
3635 CharUnits LastVFPtrOffset = CharUnits::fromQuantity(-1);
3635 CharUnits LastVFPtrOffset = CharUnits::fromQuantity(-1);
3638 CharUnits VFPtrOffset = I.first.VFPtrOffset;
3722 CharUnits VFPtrOffset) {
tools/clang/lib/CodeGen/ABIInfo.h 132 virtual bool isLegalVectorTypeForSwift(CharUnits totalSize,
tools/clang/lib/CodeGen/Address.h 26 CharUnits Alignment;
28 Address(llvm::Value *pointer, CharUnits alignment)
66 CharUnits getAlignment() const {
76 ConstantAddress(llvm::Constant *pointer, CharUnits alignment)
tools/clang/lib/CodeGen/CGAtomic.cpp 36 CharUnits AtomicAlign;
37 CharUnits ValueAlign;
84 auto OffsetInChars =
134 CharUnits getAtomicAlignment() const { return AtomicAlign; }
171 CharUnits size = CGF.getContext().toCharUnitsFromBits(AtomicSizeInBits);
724 SourceLocation Loc, CharUnits SizeInChars) {
727 CharUnits Align = CGF.getContext().getTypeAlignInChars(ValTy);
765 CharUnits sizeChars, alignChars;
834 CharUnits PointeeIncAmt =
tools/clang/lib/CodeGen/CGBlocks.cpp 118 CharUnits BlockAlignment,
340 CharUnits Alignment;
341 CharUnits Size;
347 BlockLayoutChunk(CharUnits align, CharUnits size,
347 BlockLayoutChunk(CharUnits align, CharUnits size,
355 void setIndex(CGBlockInfo &info, unsigned index, CharUnits offset) {
443 static CharUnits getLowBit(CharUnits v) {
443 static CharUnits getLowBit(CharUnits v) {
444 return CharUnits::fromQuantity(v.getQuantity() & (~v.getQuantity() + 1));
456 auto GenPtrAlign =
457 CharUnits::fromQuantity(CGM.getTarget().getPointerAlign(GenericAS) / 8);
458 auto GenPtrSize =
459 CharUnits::fromQuantity(CGM.getTarget().getPointerWidth(GenericAS) / 8);
484 info.BlockAlign = CharUnits::fromQuantity(BlockAlign);
485 info.BlockSize = CharUnits::fromQuantity(Offset);
548 CharUnits maxFieldAlign;
559 std::pair<CharUnits,CharUnits> tinfo
559 std::pair<CharUnits,CharUnits> tinfo
577 CharUnits align = CGM.getPointerAlign();
651 CharUnits size = C.getTypeSizeInChars(VT);
652 CharUnits align = C.getDeclAlign(variable);
678 info.BlockHeaderForcedGapSize = CharUnits::Zero();
680 CharUnits &blockSize = info.BlockSize;
685 CharUnits endAlign = getLowBit(blockSize);
734 CharUnits newBlockSize = blockSize.alignTo(maxFieldAlign);
735 CharUnits padding = newBlockSize - blockSize;
760 CharUnits padding = li->Alignment - endAlign;
929 auto GenVoidPtrSize = CharUnits::fromQuantity(
929 auto GenVoidPtrSize = CharUnits::fromQuantity(
990 CharUnits offset;
1020 CharUnits::fromQuantity(
1622 CharUnits align = getContext().getDeclAlign(variable);
1811 CharUnits BlockAlignment,
1880 CharUnits Alignment =
1907 CharUnits BlockAlignment, CaptureStrKind StrKind, CodeGenModule &CGM) {
2269 ObjectByrefHelpers(CharUnits alignment, BlockFieldFlags flags)
2303 ARCWeakByrefHelpers(CharUnits alignment) : BlockByrefHelpers(alignment) {}
2324 ARCStrongByrefHelpers(CharUnits alignment) : BlockByrefHelpers(alignment) {}
2360 ARCStrongBlockByrefHelpers(CharUnits alignment)
2390 CXXByrefHelpers(CharUnits alignment, QualType type,
2418 NonTrivialCStructByrefHelpers(CharUnits alignment, QualType type)
2619 CharUnits valueAlignment =
2741 CharUnits size;
2754 size += CharUnits::fromQuantity(4);
2758 size += CharUnits::fromQuantity(4);
2778 size += CharUnits::fromQuantity(PointerSizeInBytes);
2785 CharUnits varAlign = getContext().getDeclAlign(D);
2786 CharUnits varOffset = size.alignTo(varAlign);
2827 CharUnits nextHeaderOffset;
2907 CharUnits byrefSize = CGM.GetTargetTypeStoreSize(byrefType);
tools/clang/lib/CodeGen/CGBlocks.h 147 CharUnits ByrefAlignment;
148 CharUnits FieldOffset;
163 CharUnits::QuantityType Offset;
178 CharUnits getOffset() const {
180 return CharUnits::fromQuantity(Offset);
200 static Capture makeIndex(unsigned index, CharUnits offset,
248 CharUnits BlockSize;
249 CharUnits BlockAlign;
250 CharUnits CXXThisOffset;
255 CharUnits BlockHeaderForcedGapOffset;
258 CharUnits BlockHeaderForcedGapSize;
tools/clang/lib/CodeGen/CGBuilder.h 60 llvm::ConstantInt *getSize(CharUnits N) {
90 llvm::LoadInst *CreateAlignedLoad(llvm::Value *Addr, CharUnits Align,
94 llvm::LoadInst *CreateAlignedLoad(llvm::Value *Addr, CharUnits Align,
99 CharUnits Align,
115 CharUnits Align, bool IsVolatile = false) {
131 return CreateAlignedLoad(getInt1Ty(), Addr, CharUnits::One(), Name);
137 return CreateAlignedStore(getInt1(Value), Addr, CharUnits::One());
183 auto Offset = CharUnits::fromQuantity(Layout->getElementOffset(Index));
183 auto Offset = CharUnits::fromQuantity(Layout->getElementOffset(Index));
202 CharUnits EltSize =
203 CharUnits::fromQuantity(DL.getTypeAllocSize(ElTy->getElementType()));
207 {getSize(CharUnits::Zero()), getSize(Index)}, Name),
220 CharUnits EltSize = CharUnits::fromQuantity(DL.getTypeAllocSize(ElTy));
220 CharUnits EltSize = CharUnits::fromQuantity(DL.getTypeAllocSize(ElTy));
235 CharUnits EltSize =
236 CharUnits::fromQuantity(DL.getTypeAllocSize(Addr.getElementType()));
244 Address CreateConstInBoundsByteGEP(Address Addr, CharUnits Offset,
250 Address CreateConstByteGEP(Address Addr, CharUnits Offset,
270 CharUnits::fromQuantity(Offset.getSExtValue())));
310 auto Offset = CharUnits::fromQuantity(Layout->getElementOffset(Index));
310 auto Offset = CharUnits::fromQuantity(Layout->getElementOffset(Index));
tools/clang/lib/CodeGen/CGBuiltin.cpp 325 CharUnits LoadSize = CGF.getContext().getTypeSizeInChars(ElTy);
339 CharUnits StoreSize = CGF.getContext().getTypeSizeInChars(ElTy);
765 CharUnits::One());
1120 CharUnits BufferAlignment) {
1189 CharUnits Offset;
1206 CharUnits Size = Item.size();
1397 Value *&RecordPtr, CharUnits Align,
1853 CharUnits Arg0Align = EmitPointerWithAlignment(E->getArg(0)).getAlignment();
2520 CharUnits WCharAlign =
2842 CharUnits StoreSize = getContext().getTypeSizeInChars(ElTy);
7512 CharUnits::fromQuantity(16));
9126 auto Alignment = CharUnits::fromQuantity(
9126 auto Alignment = CharUnits::fromQuantity(
9140 auto Alignment = CharUnits::fromQuantity(
9140 auto Alignment = CharUnits::fromQuantity(
9151 auto Alignment = CharUnits::fromQuantity(
9151 auto Alignment = CharUnits::fromQuantity(
10060 CpuValue = Builder.CreateAlignedLoad(CpuValue, CharUnits::fromQuantity(4));
10118 Builder.CreateAlignedLoad(CpuFeatures, CharUnits::fromQuantity(4));
10133 Builder.CreateAlignedLoad(CpuFeatures2, CharUnits::fromQuantity(4));
13619 clang::CharUnits Align =
13926 CharUnits::fromQuantity(4));
13934 CharUnits::fromQuantity(4));
13969 CharUnits::fromQuantity(4));
14029 CharUnits::fromQuantity(4));
14038 CharUnits::fromQuantity(4));
14048 CharUnits::fromQuantity(4));
14057 CharUnits::fromQuantity(4));
tools/clang/lib/CodeGen/CGCUDANV.cpp 256 VoidPtrTy, CharUnits::fromQuantity(16), "kernel_args",
295 CGF.CreateMemTemp(Dim3Ty, CharUnits::fromQuantity(8), "grid_dim");
297 CGF.CreateMemTemp(Dim3Ty, CharUnits::fromQuantity(8), "block_dim");
350 CharUnits Offset = CharUnits::Zero();
350 CharUnits Offset = CharUnits::Zero();
352 CharUnits TyWidth, TyAlign;
637 CharUnits::fromQuantity(GpuBinaryHandle->getAlignment()));
772 Address GpuBinaryAddr(GpuBinaryHandle, CharUnits::fromQuantity(
tools/clang/lib/CodeGen/CGCXX.cpp 260 VTLayout.getAddressPoint(BaseSubobject(RD, CharUnits::Zero()));
tools/clang/lib/CodeGen/CGCXXABI.cpp 108 CharUnits offset) {
161 CharUnits CGCXXABI::GetArrayCookieSize(const CXXNewExpr *expr) {
163 return CharUnits::Zero();
167 CharUnits CGCXXABI::getArrayCookieSizeImpl(QualType elementType) {
169 return CharUnits::Zero();
204 llvm::Value *&allocPtr, CharUnits &cookieSize) {
212 cookieSize = CharUnits::Zero();
225 CharUnits cookieSize) {
251 CharUnits CGCXXABI::getMemberPointerPathAdjustment(const APValue &MP) {
255 CharUnits ThisAdjustment = CharUnits::Zero();
255 CharUnits ThisAdjustment = CharUnits::Zero();
312 std::vector<CharUnits> CGCXXABI::getVBPtrOffsets(const CXXRecordDecl *RD) {
tools/clang/lib/CodeGen/CGCXXABI.h 193 CharUnits offset);
224 CharUnits getMemberPointerPathAdjustment(const APValue &MP);
361 virtual CharUnits getVirtualFunctionPrologueThisAdjustment(GlobalDecl GD) {
362 return CharUnits::Zero();
416 CharUnits VPtrOffset) = 0;
462 virtual std::vector<CharUnits> getVBPtrOffsets(const CXXRecordDecl *RD);
481 virtual CharUnits GetArrayCookieSize(const CXXNewExpr *expr);
514 llvm::Value *&AllocPtr, CharUnits &CookieSize);
523 virtual CharUnits getArrayCookieSizeImpl(QualType elementType);
535 CharUnits cookieSize);
tools/clang/lib/CodeGen/CGCall.cpp 919 CharUnits UnionSize = CharUnits::Zero();
919 CharUnits UnionSize = CharUnits::Zero();
926 CharUnits FieldSize = Context.getTypeSizeInChars(FD->getType());
1005 CharUnits EltSize = CGF.getContext().getTypeSizeInChars(CAE->EltTy);
1006 CharUnits EltAlign =
1114 CharUnits MinAlign) {
1117 CharUnits Align = std::max(MinAlign, CharUnits::fromQuantity(PrefAlign));
1117 CharUnits Align = std::max(MinAlign, CharUnits::fromQuantity(PrefAlign));
1348 CharUnits::fromQuantity(offset));
2063 CharUnits Align = AI.getIndirectAlign();
2328 CharUnits Size = getContext().getTypeSizeInChars(Ty);
3043 CharUnits Align = CharUnits::fromQuantity(4);
3043 CharUnits Align = CharUnits::fromQuantity(4);
3843 auto Align = CallInfo.getArgStructAlignment();
3958 CharUnits Align = ArgInfo.getIndirectAlign();
4154 CharUnits::fromQuantity(std::max(
tools/clang/lib/CodeGen/CGCall.h 365 CharUnits Alignment;
378 Alignment(Addr.isValid() ? Addr.getAlignment() : CharUnits::Zero()) {}
tools/clang/lib/CodeGen/CGClass.cpp 36 CharUnits CodeGenModule::getClassPointerAlignment(const CXXRecordDecl *RD) {
38 return CharUnits::One(); // Hopefully won't be used anywhere.
55 CharUnits CodeGenModule::getVBaseAlignment(CharUnits actualDerivedAlign,
55 CharUnits CodeGenModule::getVBaseAlignment(CharUnits actualDerivedAlign,
63 CharUnits expectedVBaseAlign = baseLayout.getNonVirtualAlignment();
69 CharUnits
70 CodeGenModule::getDynamicOffsetAlignment(CharUnits actualBaseAlign,
72 CharUnits expectedTargetAlign) {
79 CharUnits expectedBaseAlign = baseLayout.getNonVirtualAlignment();
140 CharUnits memberAlign = getNaturalTypeAlignment(memberType, BaseInfo,
149 CharUnits CodeGenModule::computeNonVirtualBaseClassOffset(
152 CharUnits Offset = CharUnits::Zero();
152 CharUnits Offset = CharUnits::Zero();
182 CharUnits Offset =
207 CharUnits Offset;
228 CharUnits nonVirtualOffset,
255 CharUnits alignment;
291 CharUnits NonVirtualOffset = CGM.computeNonVirtualBaseClassOffset(
299 CharUnits vBaseOffset = layout.getVBaseClassOffset(VBase);
310 CharUnits DerivedAlign = CGM.getClassPointerAlignment(Derived);
462 CharUnits BaseOffset = ForVirtualBase ?
782 std::pair<CharUnits, CharUnits> FieldInfo =
782 std::pair<CharUnits, CharUnits> FieldInfo =
784 CharUnits FieldSize = FieldInfo.first;
923 CharUnits getMemcpySize(uint64_t FirstByteOffset) const {
932 CharUnits MemcpySize = Ctx.toCharUnitsFromBits(MemcpySizeBits);
955 CharUnits MemcpySize = getMemcpySize(FirstByteOffset);
979 void emitMemcpyIR(Address DestPtr, Address SrcPtr, CharUnits Size) {
1636 CharUnits::QuantityType PoisonSize) {
1720 CharUnits::QuantityType PoisonSize;
1754 CharUnits::QuantityType PoisonSize =
1962 CharUnits eltAlignment =
2116 getContext().getRecordType(ClassDecl), CharUnits::Zero());
2279 CharUnits NonVirtualOffset = Vptr.Base.getBaseOffset();
2466 CharUnits NonVirtualOffset = CharUnits::Zero();
2466 CharUnits NonVirtualOffset = CharUnits::Zero();
2509 getVTablePointers(BaseSubobject(VTableClass, CharUnits::Zero()),
2511 /*OffsetFromNearestVBase=*/CharUnits::Zero(),
2519 CharUnits OffsetFromNearestVBase,
2543 CharUnits BaseOffset;
2544 CharUnits BaseOffsetFromNearestVBase;
2556 BaseOffsetFromNearestVBase = CharUnits::Zero();
tools/clang/lib/CodeGen/CGCleanup.cpp 79 return Address(value, CharUnits::fromQuantity(alignment));
87 return RValue::getAggregate(Address(Value, CharUnits::fromQuantity(Align)));
90 return RValue::getAggregate(Address(addr, CharUnits::fromQuantity(Align)));
280 Builder.getInt1Ty(), CharUnits::One(), "cleanup.cond");
1205 var = CGF.CreateTempAlloca(CGF.Builder.getInt1Ty(), CharUnits::One(),
tools/clang/lib/CodeGen/CGCleanup.h 325 return Address(ActiveFlag, CharUnits::One());
tools/clang/lib/CodeGen/CGCoroutine.cpp 498 CGF.CreateTempAlloca(Builder.getInt1Ty(), CharUnits::One(), "gro.active");
tools/clang/lib/CodeGen/CGDebugInfo.cpp 1794 CharUnits chars =
1996 CGM.getMicrosoftVTableContext().getVFTableLayout(RD, CharUnits::Zero());
3870 CharUnits Align = CGM.getContext().getDeclAlign(VD);
3873 CharUnits FieldOffsetInBytes =
3875 CharUnits AlignedOffsetInBytes = FieldOffsetInBytes.alignTo(Align);
3876 CharUnits NumPaddingBytes = AlignedOffsetInBytes - FieldOffsetInBytes;
3966 CharUnits offset = CharUnits::fromQuantity(32);
3966 CharUnits offset = CharUnits::fromQuantity(32);
4119 CharUnits offset = CharUnits::fromQuantity(
4119 CharUnits offset = CharUnits::fromQuantity(
tools/clang/lib/CodeGen/CGDecl.cpp 383 CharUnits alignment = getContext().getDeclAlign(&D);
1079 CharUnits Align) {
1131 CharUnits Align) {
1386 CharUnits alignment = getContext().getDeclAlign(&D);
1462 CreateTempAlloca(Zero->getType(), CharUnits::One(), "nrvo");
1472 CharUnits allocaAlignment;
1665 CharUnits Size = getContext().getTypeSizeInChars(type);
1691 CharUnits EltSize = getContext().getTypeSizeInChars(VlaSize.Type);
1707 CharUnits ConstantAlign = getContext().getTypeAlignInChars(VlaSize.Type);
1727 CharUnits CurAlign = Loc.getAlignment().alignmentOfArrayElement(EltSize);
2110 CharUnits elementAlign =
2143 CharUnits elementAlign,
2195 QualType type, CharUnits elementAlign,
2230 CharUnits ElementAlign;
2233 QualType elementType, CharUnits elementAlign,
2253 CharUnits ElementAlign;
2258 CharUnits elementAlign,
2281 CharUnits elementAlign,
2298 CharUnits elementAlign,
tools/clang/lib/CodeGen/CGDeclCXX.cpp 154 void CodeGenFunction::EmitInvariantStart(llvm::Constant *Addr, CharUnits Size) {
699 CharUnits::fromQuantity(
tools/clang/lib/CodeGen/CGException.cpp 412 return Address(EHSelectorSlot, CharUnits::fromQuantity(4));
tools/clang/lib/CodeGen/CGExpr.cpp 65 CharUnits Align,
75 Address CodeGenFunction::CreateTempAlloca(llvm::Type *Ty, CharUnits Align,
121 CharUnits Align =
122 CharUnits::fromQuantity(CGM.getDataLayout().getABITypeAlignment(Ty));
135 CharUnits Align = getContext().getTypeAlignInChars(Ty);
145 Address CodeGenFunction::CreateMemTemp(QualType Ty, CharUnits Align,
151 Address CodeGenFunction::CreateMemTempWithoutCast(QualType Ty, CharUnits Align,
394 CharUnits alignment = CGF.getContext().getTypeAlignInChars(Ty);
655 CharUnits Alignment,
1069 CharUnits Align = getNaturalPointeeTypeAlignment(E->getType(),
1139 CharUnits Align = getNaturalPointeeTypeAlignment(E->getType(), BaseInfo,
1180 return MakeAddrLValue(Address(llvm::UndefValue::get(Ty), CharUnits::One()),
2327 CharUnits Align = getNaturalTypeAlignment(RefLVal.getType()->getPointeeType(),
2379 CharUnits Alignment = CGF.getContext().getDeclAlign(VD);
2423 CharUnits Alignment = CGF.getContext().getDeclAlign(FD);
2456 CharUnits Alignment = CGM.getContext().getDeclAlign(VD);
2551 CharUnits Alignment =
3381 static CharUnits getArrayElementAlign(CharUnits arrayAlign,
3381 static CharUnits getArrayElementAlign(CharUnits arrayAlign,
3383 CharUnits eltSize) {
3387 CharUnits offset = constantIdx->getZExtValue() * eltSize;
3425 CharUnits eltSize = CGF.getContext().getTypeSizeInChars(eltType);
3426 CharUnits eltAlign =
3540 CharUnits InterfaceSize = getContext().getTypeSizeInChars(OIT);
3554 CharUnits EltAlign =
3582 *this, ArrayLV.getAddress(), {CGM.getSize(CharUnits::Zero()), Idx},
3637 CharUnits Align = CGF.getNaturalTypeAlignment(ElTy, &TypeBaseInfo,
3782 *this, ArrayLV.getAddress(), {CGM.getSize(CharUnits::Zero()), Idx},
3878 /*Alignment=*/CharUnits::Zero(), SkippedChecks);
3928 CharUnits Offset = CGF.getContext().toCharUnitsFromBits(
tools/clang/lib/CodeGen/CGExprAgg.cpp 362 CharUnits sz = dest.getPreferredSize(CGF.getContext(), type);
486 CharUnits elementSize = CGF.getContext().getTypeSizeInChars(elementType);
487 CharUnits elementAlign =
506 CharUnits Align = CGM.getContext().getTypeAlignInChars(ArrayQTy);
1321 CharUnits::One()); // placeholder
1506 CharUnits::One());
1662 CharUnits elementSize = CGF.getContext().getTypeSizeInChars(elementType);
1663 CharUnits elementAlign =
1746 static CharUnits GetNumNonZeroBytesInInit(const Expr *E, CodeGenFunction &CGF) {
1750 if (isSimpleZero(E, CGF)) return CharUnits::Zero();
1766 CharUnits NumNonZeroBytes = CharUnits::Zero();
1766 CharUnits NumNonZeroBytes = CharUnits::Zero();
1797 CharUnits NumNonZeroBytes = CharUnits::Zero();
1797 CharUnits NumNonZeroBytes = CharUnits::Zero();
1823 CharUnits Size = Slot.getPreferredSize(CGF.getContext(), E->getType());
1824 if (Size <= CharUnits::fromQuantity(16))
1829 CharUnits NumNonZeroBytes = GetNumNonZeroBytesInInit(E, CGF);
1952 std::pair<CharUnits, CharUnits> TypeInfo;
1952 std::pair<CharUnits, CharUnits> TypeInfo;
tools/clang/lib/CodeGen/CGExprCXX.cpp 333 /*Alignment=*/CharUnits::Zero(), SkippedChecks);
487 CharUnits NVSize = Layout.getNonVirtualSize();
492 SmallVector<std::pair<CharUnits, CharUnits>, 1> Stores;
492 SmallVector<std::pair<CharUnits, CharUnits>, 1> Stores;
493 Stores.emplace_back(CharUnits::Zero(), NVSize);
496 CharUnits VBPtrWidth = CGF.getPointerSize();
497 std::vector<CharUnits> VBPtrOffsets =
499 for (CharUnits VBPtrOffset : VBPtrOffsets) {
503 std::pair<CharUnits, CharUnits> LastStore = Stores.pop_back_val();
503 std::pair<CharUnits, CharUnits> LastStore = Stores.pop_back_val();
504 CharUnits LastStoreOffset = LastStore.first;
505 CharUnits LastStoreSize = LastStore.second;
507 CharUnits SplitBeforeOffset = LastStoreOffset;
508 CharUnits SplitBeforeSize = VBPtrOffset - SplitBeforeOffset;
513 CharUnits SplitAfterOffset = VBPtrOffset + VBPtrWidth;
514 CharUnits SplitAfterSize = LastStoreSize - SplitAfterOffset;
533 CharUnits Align = std::max(Layout.getNonVirtualAlignment(),
540 for (std::pair<CharUnits, CharUnits> Store : Stores) {
540 for (std::pair<CharUnits, CharUnits> Store : Stores) {
541 CharUnits StoreOffset = Store.first;
542 CharUnits StoreSize = Store.second;
554 for (std::pair<CharUnits, CharUnits> Store : Stores) {
554 for (std::pair<CharUnits, CharUnits> Store : Stores) {
555 CharUnits StoreOffset = Store.first;
556 CharUnits StoreSize = Store.second;
660 static CharUnits CalculateCookiePadding(CodeGenFunction &CGF,
663 return CharUnits::Zero();
668 return CharUnits::Zero();
681 CharUnits typeSize = CGF.getContext().getTypeSizeInChars(type);
723 CharUnits typeSize = CGF.getContext().getTypeSizeInChars(type);
982 CharUnits ElementSize = getContext().getTypeSizeInChars(ElementType);
983 CharUnits ElementAlign =
1078 CharUnits StartAlign = CurPtr.getAlignment();
1389 CharUnits AllocAlign;
1403 CharUnits AllocAlign)
1470 CharUnits AllocAlign,
1558 CharUnits allocAlign = getContext().getTypeAlignInChars(allocType);
1596 CharUnits cookieAlign = getSizeAlign(); // FIXME: Ask the ABI.
1630 CharUnits allocationAlign = allocAlign;
1754 CharUnits CookieSize) {
1782 CharUnits DeleteTypeSize = getContext().getTypeSizeInChars(DeleteTy);
1801 CharUnits DeleteTypeAlign = getContext().toCharUnitsFromBits(
1952 CharUnits CookieSize;
1958 CharUnits CookieSize)
1976 CharUnits cookieSize;
1993 CharUnits elementSize = CGF.getContext().getTypeSizeInChars(elementType);
1994 CharUnits elementAlign =
tools/clang/lib/CodeGen/CGExprConstant.cpp 46 CharUnits getAlignment(const llvm::Constant *C) const {
47 return CharUnits::fromQuantity(
51 CharUnits getSize(llvm::Type *Ty) const {
52 return CharUnits::fromQuantity(CGM.getDataLayout().getTypeAllocSize(Ty));
55 CharUnits getSize(const llvm::Constant *C) const {
59 llvm::Constant *getPadding(CharUnits PadSize) const {
61 if (PadSize > CharUnits::One())
66 llvm::Constant *getZeroes(CharUnits ZeroSize) const {
84 llvm::SmallVector<CharUnits, 32> Offsets;
89 CharUnits Size = CharUnits::Zero();
89 CharUnits Size = CharUnits::Zero();
95 bool split(size_t Index, CharUnits Hint);
96 Optional<size_t> splitAt(CharUnits Pos);
100 ArrayRef<CharUnits> Offsets,
101 CharUnits StartOffset, CharUnits Size,
101 CharUnits StartOffset, CharUnits Size,
114 bool add(llvm::Constant *C, CharUnits Offset, bool AllowOverwrite);
121 void condense(CharUnits Offset, llvm::Type *DesiredTy);
129 return buildFrom(CGM, Elems, Offsets, CharUnits::Zero(), Size,
141 bool ConstantAggregateBuilder::add(llvm::Constant *C, CharUnits Offset,
145 CharUnits Align = getAlignment(C);
146 CharUnits AlignedSize = Size.alignTo(Align);
164 CharUnits CSize = getSize(C);
190 for (CharUnits OffsetInChars =
228 splitAt(OffsetInChars + CharUnits::One());
286 Optional<size_t> ConstantAggregateBuilder::splitAt(CharUnits Pos) {
314 bool ConstantAggregateBuilder::split(size_t Index, CharUnits Hint) {
317 CharUnits Offset = Offsets[Index];
325 CharUnits ElemSize = getSize(Seq->getElementType());
338 return Offset + CharUnits::fromQuantity(
347 CharUnits ElemSize = getSize(CDS->getElementType());
361 CharUnits ElemSize = getSize(C);
390 ArrayRef<CharUnits> Offsets, CharUnits StartOffset, CharUnits Size,
390 ArrayRef<CharUnits> Offsets, CharUnits StartOffset, CharUnits Size,
390 ArrayRef<CharUnits> Offsets, CharUnits StartOffset, CharUnits Size,
407 CharUnits ElemSize = Utils.getSize(ATy->getElementType());
432 CharUnits DesiredSize = Utils.getSize(DesiredTy);
433 CharUnits Align = CharUnits::One();
433 CharUnits Align = CharUnits::One();
436 CharUnits AlignedSize = Size.alignTo(Align);
458 CharUnits SizeSoFar = CharUnits::Zero();
458 CharUnits SizeSoFar = CharUnits::Zero();
460 CharUnits Align = Utils.getAlignment(Elems[I]);
461 CharUnits NaturalOffset = SizeSoFar.alignTo(Align);
462 CharUnits DesiredOffset = Offset(I);
495 void ConstantAggregateBuilder::condense(CharUnits Offset,
497 CharUnits Size = getSize(DesiredTy);
540 CharUnits StartOffset;
548 ConstantAggregateBuilder &Const, CharUnits Offset,
553 ConstantAggregateBuilder &Builder, CharUnits StartOffset)
560 bool AppendBytes(CharUnits FieldOffsetInChars, llvm::Constant *InitCst,
568 const CXXRecordDecl *VTableClass, CharUnits BaseOffset);
577 CharUnits FieldOffsetInChars = Context.toCharUnitsFromBits(FieldOffset);
582 bool ConstStructBuilder::AppendBytes(CharUnits FieldOffsetInChars,
612 CharUnits Offset, QualType Type,
621 CharUnits ElemSize = Emitter.CGM.getContext().getTypeSizeInChars(ElemType);
701 CharUnits Offset = CGM.getContext().toCharUnitsFromBits(
748 BaseInfo(const CXXRecordDecl *Decl, CharUnits Offset, unsigned Index)
753 CharUnits Offset;
763 CharUnits Offset) {
785 CharUnits BaseOffset = Layout.getBaseClassOffset(BD);
851 ConstStructBuilder Builder(Emitter, Const, CharUnits::Zero());
863 ConstStructBuilder Builder(Emitter, Const, CharUnits::Zero());
867 if (!Builder.Build(Val, RD, false, CD, CharUnits::Zero()))
875 CharUnits Offset, InitListExpr *Updater) {
887 CharUnits Align = CGM.getContext().getTypeAlignInChars(E->getType());
1254 Const.add(C, CharUnits::Zero(), false);
1256 if (!EmitDesignatedInitUpdater(Emitter, Const, CharUnits::Zero(), destType,
2183 CharUnits chars = getContext().toCharUnitsFromBits((int64_t) fieldOffset);
tools/clang/lib/CodeGen/CGExprScalar.cpp 2545 CharUnits size = CGF.getContext().getTypeSizeInChars(OPT->getObjectType());
2716 CharUnits OffsetInt = RL.getBaseClassOffset(BaseRD);
2748 CharUnits eltSize = CGF.getContext().getTypeSizeInChars(VlaSize.Type);
3552 CharUnits eltSize = CGF.getContext().getTypeSizeInChars(elementType);
3560 CharUnits elementSize;
3564 elementSize = CharUnits::One();
tools/clang/lib/CodeGen/CGNonTrivialStruct.cpp 40 void visitStructFields(QualType QT, CharUnits CurStructOffset, Ts... Args) {
53 template <class... Ts> void visitTrivial(Ts... Args) {}
55 template <class... Ts> void visitCXXDestructor(Ts... Args) {
67 CharUnits getFieldOffset(const FieldDecl *FD) {
87 const FieldDecl *FD, CharUnits CurStructOffset, Ts &&... Args) {
94 const FieldDecl *FD, CharUnits CurStructOffset,
107 void visitTrivial(QualType FT, const FieldDecl *FD, CharUnits CurStructOffset,
127 CharUnits Start = CharUnits::Zero(), End = CharUnits::Zero();
127 CharUnits Start = CharUnits::Zero(), End = CharUnits::Zero();
127 CharUnits Start = CharUnits::Zero(), End = CharUnits::Zero();
151 std::string getVolatileOffsetStr(bool IsVolatile, CharUnits Offset) {
160 CharUnits CurStructOffset) {
164 CharUnits FieldOffset = CurStructOffset + asDerived().getFieldOffset(FD);
169 CharUnits CurStructOffset) {
171 CharUnits FieldOffset = CurStructOffset + asDerived().getFieldOffset(FD);
176 CharUnits CurStructOffset) {
177 CharUnits FieldOffset = CurStructOffset + asDerived().getFieldOffset(FD);
184 const FieldDecl *FD, CharUnits CurStructOffset) {
191 CharUnits FieldOffset = CurStructOffset + asDerived().getFieldOffset(FD);
196 CharUnits EltSize = Ctx.getTypeSizeInChars(EltTy);
209 asDerived().visitStructFields(QT, CharUnits::Zero());
220 GenUnaryFuncName(StringRef Prefix, CharUnits DstAlignment, ASTContext &Ctx)
237 GenBinaryFuncName(StringRef Prefix, CharUnits DstAlignment,
238 CharUnits SrcAlignment, ASTContext &Ctx)
252 this->Start = this->End = CharUnits::Zero();
256 CharUnits CurStructOffset) {
270 GenDefaultInitializeFuncName(CharUnits DstAlignment, ASTContext &Ctx)
274 const FieldDecl *FD, CharUnits CurStructOffset) {
287 GenDestructorFuncName(const char *Prefix, CharUnits DstAlignment,
291 const FieldDecl *FD, CharUnits CurStructOffset) {
324 void visitStruct(QualType FT, const FieldDecl *FD, CharUnits CurStructOffset,
332 const FieldDecl *FD, CharUnits CurStructOffset,
385 CharUnits EltSize = Ctx.getTypeSizeInChars(EltQT);
393 this->asDerived().visitWithKind(FK, EltQT, nullptr, CharUnits::Zero(),
411 Address getAddrWithOffset(Address Addr, CharUnits Offset) {
420 Address getAddrWithOffset(Address Addr, CharUnits StructFieldOffset,
429 std::array<CharUnits, N> Alignments, CodeGenModule &CGM) {
475 asDerived().visitStructFields(QT, CharUnits::Zero(), Addrs);
483 std::array<CharUnits, N> Alignments;
511 CharUnits Size = this->End - this->Start;
538 this->Start = this->End = CharUnits::Zero();
542 void visitVolatileTrivial(QualType FT, const FieldDecl *FD, CharUnits Offset,
576 const FieldDecl *FD, CharUnits CurStructOffset,
587 CharUnits CurStructOffset, std::array<Address, 1> Addrs) {
592 void visitARCWeak(QualType QT, const FieldDecl *FD, CharUnits CurStructOffset,
598 void callSpecialFunction(QualType FT, CharUnits Offset,
616 const FieldDecl *FD, CharUnits CurStructOffset,
628 CharUnits CurStructOffset, std::array<Address, 1> Addrs) {
633 void visitARCWeak(QualType QT, const FieldDecl *FD, CharUnits CurStructOffset,
641 const FieldDecl *FD, CharUnits CurStructOffset,
647 CharUnits Size = Ctx.getTypeSizeInChars(QualType(AT, 0));
650 if (Size < CharUnits::fromQuantity(16) || EltTy->getAs<RecordType>()) {
662 void callSpecialFunction(QualType FT, CharUnits Offset,
674 CharUnits CurStructOffset, std::array<Address, 2> Addrs) {
683 void visitARCWeak(QualType QT, const FieldDecl *FD, CharUnits CurStructOffset,
690 void callSpecialFunction(QualType FT, CharUnits Offset,
704 CharUnits CurStructOffset, std::array<Address, 2> Addrs) {
715 void visitARCWeak(QualType QT, const FieldDecl *FD, CharUnits CurStructOffset,
722 void callSpecialFunction(QualType FT, CharUnits Offset,
736 CharUnits CurStructOffset, std::array<Address, 2> Addrs) {
745 void visitARCWeak(QualType QT, const FieldDecl *FD, CharUnits CurStructOffset,
752 void callSpecialFunction(QualType FT, CharUnits Offset,
767 CharUnits CurStructOffset, std::array<Address, 2> Addrs) {
781 void visitARCWeak(QualType QT, const FieldDecl *FD, CharUnits CurStructOffset,
788 void callSpecialFunction(QualType FT, CharUnits Offset,
813 Gen.visit(QT, nullptr, CharUnits::Zero(), std::array<Address, 1>({{DstPtr}}));
829 return std::array<Address, 1>({{Address(nullptr, CharUnits::Zero())}});
833 return std::array<Address, 2>({{Address(nullptr, CharUnits::Zero()),
834 Address(nullptr, CharUnits::Zero())}});
840 std::array<CharUnits, N> Alignments, CodeGenModule &CGM) {
861 QualType QT, CharUnits Alignment, bool IsVolatile, ASTContext &Ctx) {
867 CharUnits Alignment,
936 CodeGenModule &CGM, CharUnits DstAlignment, bool IsVolatile, QualType QT) {
945 CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment,
945 CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment,
957 CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment,
957 CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment,
969 CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment,
969 CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment,
981 CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment,
981 CodeGenModule &CGM, CharUnits DstAlignment, CharUnits SrcAlignment,
993 CodeGenModule &CGM, CharUnits DstAlignment, bool IsVolatile, QualType QT) {
tools/clang/lib/CodeGen/CGObjC.cpp 744 CharUnits size = CGF.getContext().getTypeSizeInChars(ivar->getType());
766 static CharUnits getMaxAtomicAccessSize(CodeGenModule &CGM,
773 return CharUnits::fromQuantity(CGM.PointerSizeInBytes);
805 CharUnits getIvarSize() const { return IvarSize; }
806 CharUnits getIvarAlignment() const { return IvarAlignment; }
817 CharUnits IvarSize;
818 CharUnits IvarAlignment;
2311 dst.getAlignment() >= CharUnits::fromQuantity(PointerAlignInBytes))) {
3656 CharUnits Alignment
tools/clang/lib/CodeGen/CGObjCGNU.cpp 970 CharUnits Align = CGM.getPointerAlign();
1681 CharUnits Align = CGM.getIntAlign();
2454 CharUnits Align = CGM.getPointerAlign();
3214 fields.finishAndCreateGlobal("", CharUnits::fromQuantity(4));
4080 CharUnits::fromQuantity(4)),
4084 CharUnits Align = CGM.getIntAlign();
tools/clang/lib/CodeGen/CGObjCMac.cpp 829 CharUnits block_var_bytepos;
830 CharUnits block_var_size;
832 CharUnits BytePos = CharUnits::Zero(),
832 CharUnits BytePos = CharUnits::Zero(),
833 CharUnits Size = CharUnits::Zero())
833 CharUnits Size = CharUnits::Zero())
964 CharUnits beginOffset,
965 CharUnits endOffset,
970 CharUnits beginOffset,
971 CharUnits endOffset) {
976 CharUnits beginOffset,
977 CharUnits endOffset,
986 CharUnits FieldOffset,
987 CharUnits FieldSize);
990 CharUnits BytePos, bool &HasUnion,
996 CharUnits BytePos, bool &HasUnion,
1052 StringRef Section, CharUnits Align,
1056 StringRef Section, CharUnits Align,
1231 CharUnits instanceSize,
1988 return ConstantAddress(C, CharUnits::fromQuantity(C->getAlignment()));
2028 CharUnits Alignment = CGM.getPointerAlign();
2290 CharUnits Offset;
2292 IvarInfo(CharUnits offset, uint64_t sizeInWords)
2307 CharUnits InstanceBegin;
2310 CharUnits InstanceEnd;
2321 IvarLayoutBuilder(CodeGenModule &CGM, CharUnits instanceBegin,
2322 CharUnits instanceEnd, bool forStrongLayout)
2327 void visitRecord(const RecordType *RT, CharUnits offset);
2331 CharUnits aggrOffset,
2334 void visitField(const FieldDecl *field, CharUnits offset);
2364 IvarLayoutBuilder builder(CGM, CharUnits::Zero(), blockInfo.BlockSize,
2385 IvarsInfo.push_back(IvarInfo(CharUnits::Zero(), 1));
2392 CharUnits lastFieldOffset;
2404 CharUnits fieldOffset = capture.getOffset();
2456 CharUnits FieldOffset,
2457 CharUnits FieldSize) {
2480 CharUnits BytePos, bool &HasUnion,
2483 CharUnits MaxUnionSize = CharUnits::Zero();
2483 CharUnits MaxUnionSize = CharUnits::Zero();
2486 CharUnits MaxFieldOffset = CharUnits::Zero();
2486 CharUnits MaxFieldOffset = CharUnits::Zero();
2487 CharUnits LastBitfieldOrUnnamedOffset = CharUnits::Zero();
2487 CharUnits LastBitfieldOrUnnamedOffset = CharUnits::Zero();
2498 CharUnits FieldOffset =
2539 CharUnits Size = CGM.getContext().getTypeSizeInChars(RT);
2549 CharUnits FieldSize = CGM.getContext().getTypeSizeInChars(Field->getType());
2551 CharUnits UnionIvarSize = FieldSize;
2572 CharUnits Size = CharUnits::fromQuantity(UnsSize);
2572 CharUnits Size = CharUnits::fromQuantity(UnsSize);
2582 CharUnits FieldSize
2600 CharUnits BytePos,
2734 CharUnits start_byte_pos = RunSkipBlockVars[i].block_var_bytepos;
2735 CharUnits end_byte_pos = start_byte_pos;
2745 CharUnits size_in_bytes =
2748 CharUnits gap =
2753 CharUnits residue_in_bytes = CharUnits::Zero();
2753 CharUnits residue_in_bytes = CharUnits::Zero();
2774 if (residue_in_bytes > CharUnits::Zero()) {
2920 if (blockInfo.BlockHeaderForcedGapSize != CharUnits::Zero())
2934 CharUnits fieldOffset =
2935 CharUnits::fromQuantity(layout->getElementOffset(capture.getIndex()));
2943 CharUnits fieldSize;
2945 fieldSize = CharUnits::fromQuantity(WordSizeInBytes);
2971 CharUnits fieldOffset;
3543 CharUnits Size =
3596 values.add(BuildStrongIvarLayout(ID, CharUnits::Zero(), Size));
3660 values.add(EmitClassExtension(ID, CharUnits::Zero(), false/*hasMRCWeak*/,
3732 CharUnits InstanceSize, bool hasMRCWeakIvars,
3739 layout = BuildWeakIvarLayout(ID, CharUnits::Zero(), InstanceSize,
3992 CharUnits Align,
4008 CharUnits Align,
4065 GV->setAlignment(CharUnits::One().getAsAlign());
4493 CharUnits::One(),
5125 CharUnits Align = CGF.getPointerAlign();
5165 CharUnits offset) {
5185 CharUnits aggregateOffset,
5196 CharUnits fieldOffset = aggregateOffset + getOffset(field);
5204 CharUnits fieldOffset) {
5234 CharUnits eltSize = CGM.getContext().getTypeSizeInChars(recType);
5338 const CharUnits WordSize = CGM.getPointerSize();
5342 CharUnits beginOfScan = request.Offset - InstanceBegin;
5388 (InstanceEnd - InstanceBegin + WordSize - CharUnits::One()) / WordSize;
5420 CharUnits beginOffset, CharUnits endOffset,
5420 CharUnits beginOffset, CharUnits endOffset,
5443 CharUnits baseOffset;
5453 CharUnits::fromQuantity(ComputeIvarBaseOffset(CGM, OMD, ivars[0]));
5455 baseOffset = CharUnits::Zero();
5463 baseOffset = CharUnits::Zero();
5471 builder.visitAggregate(ivars.begin(), ivars.end(), CharUnits::Zero(),
5473 return CharUnits::fromQuantity(ComputeIvarBaseOffset(CGM, OMD, ivar));
6207 CharUnits beginInstance = CharUnits::fromQuantity(InstanceStart);
6207 CharUnits beginInstance = CharUnits::fromQuantity(InstanceStart);
6208 CharUnits endInstance = CharUnits::fromQuantity(InstanceSize);
6208 CharUnits endInstance = CharUnits::fromQuantity(InstanceSize);
6518 CharUnits Align = CGF.getPointerAlign();
7186 CharUnits::fromQuantity(16),
7313 CharUnits Align = CGF.getPointerAlign();
7393 CharUnits Align = CGF.getPointerAlign();
7489 CharUnits Align = CGF.getPointerAlign();
tools/clang/lib/CodeGen/CGObjCRuntime.cpp 93 CharUnits StorageSize = CGF.CGM.getContext().toCharUnitsFromBits(
95 CharUnits Alignment = CGF.CGM.getContext().toCharUnitsFromBits(AlignmentBits);
106 CharUnits::fromQuantity(0)));
tools/clang/lib/CodeGen/CGOpenMPRuntime.cpp 893 CharUnits ElementSize = CGF.getContext().getTypeSizeInChars(ElementTy);
1125 llvm::Type *BaseLVType, CharUnits BaseLVAlignment,
1568 CharUnits Align = CGM.getContext().getTypeAlignInChars(IdentQTy);
1636 CharUnits Align = CGM.getContext().getTypeAlignInChars(IdentQTy);
3970 CharUnits VarSize,
4391 typedef std::pair<CharUnits /*Align*/, PrivateHelpersTy> PrivateDataTy;
5497 CharUnits ElementSize = CGF.getContext().getTypeSizeInChars(ElementTy);
7630 CharUnits TypeSize = CGF.getContext().getTypeSizeInChars(
8842 CharUnits ElementSize = C.getTypeSizeInChars(Ty);
9090 CharUnits ElementSize, llvm::BasicBlock *ExitBB, bool IsInit) {
9670 CharUnits VarSize = CGM.getContext().getTypeSizeInChars(Ty);
9697 CharUnits VarSize;
9708 VarSize = CharUnits::Zero();
10980 CharUnits Align = CGM.getContext().getDeclAlign(CVD);
10985 Size, CGM.getSize(Align - CharUnits::fromQuantity(1)));
10989 CharUnits Sz = CGM.getContext().getTypeSizeInChars(CVD->getType());
tools/clang/lib/CodeGen/CGOpenMPRuntime.h 577 CharUnits VarSize;
587 unsigned Order, llvm::Constant *Addr, CharUnits VarSize,
595 CharUnits getVarSize() const { return VarSize; }
596 void setVarSize(CharUnits Size) { VarSize = Size; }
612 CharUnits VarSize,
763 llvm::Value *MapType, CharUnits ElementSize,
tools/clang/lib/CodeGen/CGOpenMPRuntimeNVPTX.cpp 234 using VarsDataTy = std::pair<CharUnits /*Align*/, const ValueDecl *>;
240 CharUnits::fromQuantity(std::max(
2159 CharUnits::fromQuantity(Alignment));
2364 CharUnits Align = CGM.getContext().getDeclAlign(VD);
2845 CharUnits Size = CGF.getContext().getTypeSizeInChars(ElemType);
2871 CharUnits Size = CGF.getContext().getTypeSizeInChars(ElemType);
2887 if (Size < CharUnits::fromQuantity(IntSize))
2890 CGF.getContext().toBits(CharUnits::fromQuantity(IntSize)),
3252 C.toBits(CharUnits::fromQuantity(TySize)), /*Signed=*/1);
3254 CharUnits Align = CharUnits::fromQuantity(TySize);
3254 CharUnits Align = CharUnits::fromQuantity(TySize);
4758 CharUnits Align = CGM.getContext().getDeclAlign(VD);
4770 CharUnits Align = CGM.getContext().getDeclAlign(VD);
4781 CharUnits Align = CGM.getContext().getDeclAlign(VD);
tools/clang/lib/CodeGen/CGRecordLayout.h 81 CharUnits StorageOffset;
87 unsigned StorageSize, CharUnits StorageOffset)
101 CharUnits StorageOffset);
tools/clang/lib/CodeGen/CGRecordLayoutBuilder.cpp 78 CharUnits Offset;
85 MemberInfo(CharUnits Offset, InfoKind Kind, llvm::Type *Data,
88 MemberInfo(CharUnits Offset, InfoKind Kind, llvm::Type *Data,
98 MemberInfo StorageInfo(CharUnits Offset, llvm::Type *Data) {
126 llvm::Type *getByteArrayType(CharUnits NumBytes) {
129 return NumBytes == CharUnits::One() ? Type :
145 CharUnits bitsToCharUnits(uint64_t BitOffset) {
148 CharUnits getSize(llvm::Type *Type) {
149 return CharUnits::fromQuantity(DataLayout.getTypeAllocSize(Type));
151 CharUnits getAlignment(llvm::Type *Type) {
152 return CharUnits::fromQuantity(DataLayout.getABITypeAlignment(Type));
160 void appendPaddingBytes(CharUnits Size) {
168 void setBitFieldInfo(const FieldDecl *FD, CharUnits StartOffset,
225 const FieldDecl *FD, CharUnits StartOffset, llvm::Type *StorageType) {
263 CharUnits Size = NVBaseType ? Layout.getNonVirtualSize() : Layout.getSize();
287 CharUnits LayoutSize = Layout.getSize();
302 setBitFieldInfo(Field, CharUnits::Zero(), FieldType);
485 Members.push_back(MemberInfo(CharUnits::Zero(), MemberInfo::Base,
505 Members.push_back(MemberInfo(CharUnits::Zero(), MemberInfo::VFPtr,
514 CharUnits ScissorOffset = Layout.getNonVirtualSize();
537 CharUnits Offset = Layout.getVBaseClassOffset(BaseDecl);
549 Members.push_back(StorageInfo(Offset - CharUnits::fromQuantity(4),
588 CharUnits Tail = getSize(Prior->Data);
617 CharUnits Alignment = CharUnits::One();
617 CharUnits Alignment = CharUnits::One();
618 CharUnits NVAlignment = CharUnits::One();
618 CharUnits NVAlignment = CharUnits::One();
619 CharUnits NVSize =
620 !NVBaseType && RD ? Layout.getNonVirtualSize() : CharUnits::Zero();
649 std::vector<std::pair<CharUnits, CharUnits> > Padding;
649 std::vector<std::pair<CharUnits, CharUnits> > Padding;
650 CharUnits Size = CharUnits::Zero();
650 CharUnits Size = CharUnits::Zero();
656 CharUnits Offset = Member->Offset;
660 Size.alignTo(Packed ? CharUnits::One() : getAlignment(Member->Data)))
667 for (std::vector<std::pair<CharUnits, CharUnits> >::const_iterator
667 for (std::vector<std::pair<CharUnits, CharUnits> >::const_iterator
697 CharUnits StorageOffset) {
702 CharUnits TypeSizeInBytes =
703 CharUnits::fromQuantity(Types.getDataLayout().getTypeAllocSize(Ty));
791 CharUnits NonVirtualSize = Layout.getNonVirtualSize();
tools/clang/lib/CodeGen/CGStmtOpenMP.cpp 268 auto SizeInChars = C.getTypeSizeInChars(Ty);
665 CharUnits ElementSize = getContext().getTypeSizeInChars(ElementTy);
tools/clang/lib/CodeGen/CGVTables.cpp 91 auto ClassAlign = CGF.CGM.getClassPointerAlignment(ClassDecl);
1072 CharUnits PointerWidth =
tools/clang/lib/CodeGen/CGValue.h 73 return Address(V1.getPointer(), CharUnits::fromQuantity(align));
227 void Initialize(QualType Type, Qualifiers Quals, CharUnits Alignment,
315 CharUnits getAlignment() const { return CharUnits::fromQuantity(Alignment); }
315 CharUnits getAlignment() const { return CharUnits::fromQuantity(Alignment); }
316 void setAlignment(CharUnits A) { Alignment = A.getQuantity(); }
590 CharUnits getAlignment() const {
591 return CharUnits::fromQuantity(Alignment);
622 CharUnits getPreferredSize(ASTContext &Ctx, QualType Type) const {
tools/clang/lib/CodeGen/CodeGenFunction.cpp 105 CharUnits CodeGenFunction::getNaturalPointeeTypeAlignment(QualType T,
112 CharUnits CodeGenFunction::getNaturalTypeAlignment(QualType T,
133 CharUnits Alignment;
135 Alignment = CharUnits::One(); // Shouldn't be used, but pessimistic is best.
146 Alignment = CharUnits::One();
154 Alignment = CharUnits::fromQuantity(MaxAlign);
163 CharUnits Alignment = getNaturalTypeAlignment(T, &BaseInfo, &TBAAInfo);
174 CharUnits Align = getNaturalTypeAlignment(T, &BaseInfo, &TBAAInfo,
1579 CharUnits baseSize = CGF.getContext().getTypeSizeInChars(baseType);
1599 CharUnits curAlign =
1633 CharUnits size = getContext().getTypeSizeInChars(Ty);
1646 CharUnits eltSize = getContext().getTypeSizeInChars(VlaSize.Type);
1673 CharUnits NullAlign = DestPtr.getAlignment();
tools/clang/lib/CodeGen/CodeGenFunction.h 176 CharUnits Alignment;
563 typename DominatingValue<T>::saved_type saveValueInCond(T value) {
563 typename DominatingValue<T>::saved_type saveValueInCond(T value) {
564 return DominatingValue<T>::save(*this, value);
607 void pushFullExprCleanup(CleanupKind kind, As... A) {
617 typedef EHScopeStack::ConditionalCleanup<T, As...> CleanupType;
1449 CharUnits OldCXXThisAlignment;
1523 CharUnits OldCXXABIThisAlignment;
1524 CharUnits OldCXXThisAlignment;
1536 CharUnits CXXABIThisAlignment;
1537 CharUnits CXXThisAlignment;
1674 CharUnits elementAlignment,
1679 CharUnits elementAlignment,
1702 QualType elementType, CharUnits elementAlign,
1905 CharUnits OffsetFromNearestVBase;
1918 CharUnits OffsetFromNearestVBase,
2134 LValue MakeAddrLValue(llvm::Value *V, QualType T, CharUnits Alignment,
2140 LValue MakeAddrLValue(llvm::Value *V, QualType T, CharUnits Alignment,
2148 CharUnits getNaturalTypeAlignment(QualType T,
2152 CharUnits getNaturalPointeeTypeAlignment(QualType T,
2201 Address CreateTempAlloca(llvm::Type *Ty, CharUnits align,
2205 Address CreateTempAllocaWithoutCast(llvm::Type *Ty, CharUnits align,
2246 Address CreateMemTemp(QualType T, CharUnits Align, const Twine &Name = "tmp",
2252 Address CreateMemTempWithoutCast(QualType T, CharUnits Align,
2577 CharUnits CookieSize = CharUnits());
2638 QualType Type, CharUnits Alignment = CharUnits::Zero(),
2638 QualType Type, CharUnits Alignment = CharUnits::Zero(),
2800 return Address(Value, CharUnits::fromQuantity(Alignment));
3654 CharUnits Alignment,
3660 CharUnits Alignment,
3723 CharUnits BufferAlignment);
3941 void EmitInvariantStart(llvm::Constant *Addr, CharUnits Size);
4377 auto align = CharUnits::fromQuantity(
4377 auto align = CharUnits::fromQuantity(
tools/clang/lib/CodeGen/CodeGenModule.cpp 752 llvm::ConstantInt *CodeGenModule::getSize(CharUnits size) {
2365 CharUnits Alignment = CharUnits::fromQuantity(PointerAlignInBytes);
2365 CharUnits Alignment = CharUnits::fromQuantity(PointerAlignInBytes);
2387 CharUnits Alignment = getContext().getDeclAlign(VD);
3716 CharUnits CodeGenModule::GetTargetTypeStoreSize(llvm::Type *Ty) const {
4169 Context.toBits(CharUnits::fromQuantity(32)))
4625 return ConstantAddress(C, CharUnits::fromQuantity(C->getAlignment()));
4741 CharUnits Align = isUTF16 ? Context.getTypeAlignInChars(Context.ShortTy)
4780 CharUnits Alignment =
4887 CharUnits Alignment) {
4912 CharUnits Alignment = getContext().getAlignOfGlobalVarInChars(S->getType());
4971 CharUnits Alignment =
5014 CharUnits Align = getContext().getTypeAlignInChars(MaterializedType);
5846 CharUnits Offset,
tools/clang/lib/CodeGen/CodeGenModule.h 255 CharUnits Alignment;
257 BlockByrefHelpers(CharUnits alignment)
631 CharUnits Align);
764 llvm::ConstantInt *getSize(CharUnits numChars);
862 CharUnits getClassPointerAlignment(const CXXRecordDecl *CD);
865 CharUnits getVBaseAlignment(CharUnits DerivedAlign,
865 CharUnits getVBaseAlignment(CharUnits DerivedAlign,
872 CharUnits getDynamicOffsetAlignment(CharUnits ActualAlign,
872 CharUnits getDynamicOffsetAlignment(CharUnits ActualAlign,
874 CharUnits ExpectedTargetAlign);
876 CharUnits
1191 CharUnits GetTargetTypeStoreSize(llvm::Type *Ty) const;
1331 void AddVTableTypeMetadata(llvm::GlobalVariable *VTable, CharUnits Offset,
tools/clang/lib/CodeGen/CodeGenTypeCache.h 75 CharUnits getIntSize() const {
76 return CharUnits::fromQuantity(IntSizeInBytes);
78 CharUnits getIntAlign() const {
79 return CharUnits::fromQuantity(IntAlignInBytes);
99 CharUnits getSizeSize() const {
100 return CharUnits::fromQuantity(SizeSizeInBytes);
102 CharUnits getSizeAlign() const {
103 return CharUnits::fromQuantity(SizeAlignInBytes);
105 CharUnits getPointerSize() const {
106 return CharUnits::fromQuantity(PointerSizeInBytes);
108 CharUnits getPointerAlign() const {
109 return CharUnits::fromQuantity(PointerAlignInBytes);
tools/clang/lib/CodeGen/ConstantInitBuilder.cpp 69 CharUnits alignment,
124 void ConstantAggregateBuilderBase::addSize(CharUnits size) {
184 CharUnits offset = getNextOffsetFromGlobal();
192 offset = offset.alignTo(CharUnits::fromQuantity(
194 offset += CharUnits::fromQuantity(layout.getTypeStoreSize(type));
202 CharUnits ConstantAggregateBuilderBase::getOffsetFromGlobalTo(size_t end) const{
213 CharUnits offset;
232 offset = offset.alignTo(CharUnits::fromQuantity(
234 offset += CharUnits::fromQuantity(layout.getTypeStoreSize(elementType));
tools/clang/lib/CodeGen/EHScopeStack.h 56 typedef T type;
57 typedef T saved_type;
65 template <class T> struct DominatingValue : InvariantValue<T> {};
205 return T{DominatingValue<As>::restore(CGF, std::get<Is>(Saved))...};
272 template <class T, class... As> void pushCleanup(CleanupKind Kind, As... A) {
304 T *pushCleanupWithExtra(CleanupKind Kind, size_t N, As... A) {
tools/clang/lib/CodeGen/ItaniumCXXABI.cpp 143 CharUnits offset) override;
146 CharUnits ThisAdjustment);
261 CharUnits VPtrOffset) override;
304 CharUnits getArrayCookieSizeImpl(QualType elementType) override;
312 CharUnits cookieSize) override;
470 CharUnits getArrayCookieSizeImpl(QualType elementType) override;
477 CharUnits cookieSize) override;
631 CharUnits VTablePtrAlign =
948 CharUnits offset) {
957 return BuildMemberPointer(MD, CharUnits::Zero());
961 CharUnits ThisAdjustment) {
972 CharUnits PointerWidth =
1025 CharUnits ThisAdjustment = getMemberPointerPathAdjustment(MP);
1030 CharUnits FieldOffset =
1154 auto Align = CGM.getContext().getTypeAlignInChars(FI.getReturnType());
1255 CharUnits ExnAlign = CGF.getContext().getExnObjectAlignment();
1310 static CharUnits computeOffsetHint(ASTContext &Context,
1319 return CharUnits::fromQuantity(-2ULL);
1322 CharUnits Offset;
1335 return CharUnits::fromQuantity(-1ULL);
1349 return CharUnits::fromQuantity(-2ULL);
1353 return CharUnits::fromQuantity(-3ULL);
1484 CharUnits VBaseOffsetOffset =
1741 CharUnits VPtrOffset) {
1919 CharUnits::fromQuantity(NonVirtualAdjustment));
1986 CharUnits ItaniumCXXABI::getArrayCookieSizeImpl(QualType elementType) {
1989 return std::max(CharUnits::fromQuantity(CGM.SizeSizeInBytes),
2003 CharUnits SizeSize = CGF.getSizeSize();
2006 CharUnits CookieSize =
2012 CharUnits CookieOffset = CookieSize - SizeSize;
2041 CharUnits cookieSize) {
2044 CharUnits numElementsOffset = cookieSize - CGF.getSizeSize();
2065 CharUnits ARMCXXABI::getArrayCookieSizeImpl(QualType elementType) {
2074 return std::max(CharUnits::fromQuantity(2 * CGM.SizeSizeInBytes),
2100 CharUnits cookieSize = ARMCXXABI::getArrayCookieSizeImpl(elementType);
2106 CharUnits cookieSize) {
2193 CharUnits guardAlignment;
2196 guardAlignment = CharUnits::One();
2205 guardAlignment = CharUnits::fromQuantity(
2584 CharUnits GuardAlign = CharUnits::One();
2584 CharUnits GuardAlign = CharUnits::One();
2706 CharUnits Align = CGM.getContext().getDeclAlign(VD);
2867 auto Align = CGM.getContext().getTypeAlignInChars(CGM.getContext().CharTy);
3515 CharUnits Align =
3710 CharUnits Offset;
4214 CharUnits caughtExnAlignment = CGF.CGM.getClassPointerAlignment(catchRD);
tools/clang/lib/CodeGen/MicrosoftCXXABI.cpp 92 std::vector<CharUnits> getVBPtrOffsets(const CXXRecordDecl *RD) override {
93 std::vector<CharUnits> VBPtrOffsets;
101 CharUnits Offs = VBT->NonVirtualOffset;
292 CharUnits VPtrOffset) override;
428 CharUnits getArrayCookieSizeImpl(QualType type) override;
436 CharUnits cookieSize) override;
564 CharUnits getVirtualFunctionPrologueThisAdjustment(GlobalDecl GD) override;
606 CharUnits NonVirtualBaseAdjustment,
635 CharUnits offset) override;
763 typedef std::pair<const CXXRecordDecl *, CharUnits> VFTableIdTy;
920 CharUnits VBaseAlign =
1028 CharUnits IntSize = Context.getTypeSizeInChars(Context.IntTy);
1029 CharUnits VBTableChars =
1097 CharUnits Align = CGM.getContext().getTypeAlignInChars(FI.getReturnType());
1204 CharUnits::fromQuantity(4));
1246 CharUnits Offs = VBT->NonVirtualOffset;
1344 CharUnits
1361 CharUnits Adjustment = ML.VFPtrOffset;
1368 Adjustment = CharUnits::Zero();
1385 CharUnits Adjustment = getVirtualFunctionPrologueThisAdjustment(GD);
1410 CharUnits StaticOffset = ML.VFPtrOffset;
1416 StaticOffset = CharUnits::Zero();
1428 CharUnits VBaseAlign =
1497 CharUnits Adjustment = getVirtualFunctionPrologueThisAdjustment(CGF.CurGD);
1615 CharUnits AddressPoint =
1619 : CharUnits::Zero();
1638 CharUnits Offset;
1720 CharUnits VPtrOffset) {
2060 CharUnits Alignment =
2093 CharUnits VBPtrOffset = BaseLayout.getVBPtrOffset();
2099 CharUnits Offset = DerivedLayout.getVBaseClassOffset(VBase);
2103 CharUnits CompleteVBPtrOffset = VBT.NonVirtualOffset + VBPtrOffset;
2142 CharUnits::fromQuantity(TA.Virtual.Microsoft.VtordispOffset));
2218 CharUnits MicrosoftCXXABI::getArrayCookieSizeImpl(QualType type) {
2228 CharUnits cookieSize) {
2242 CharUnits cookieSize = getArrayCookieSizeImpl(elementType);
2350 CharUnits Align = CGM.getIntAlign();
2451 CharUnits GuardAlign = CharUnits::fromQuantity(4);
2451 CharUnits GuardAlign = CharUnits::fromQuantity(4);
2672 CharUnits NonVirtualBaseAdjustment,
2689 CharUnits Offs = CharUnits::Zero();
2689 CharUnits Offs = CharUnits::Zero();
2704 CharUnits offset) {
2712 CharUnits::Zero(), /*VBTableIndex=*/0);
2729 CharUnits FieldOffset = Ctx.toCharUnitsFromBits(Ctx.getFieldOffset(MPD));
2773 CharUnits NonVirtualBaseAdjustment = CharUnits::Zero();
2773 CharUnits NonVirtualBaseAdjustment = CharUnits::Zero();
2953 CharUnits VBPtrAlign;
2956 CharUnits::fromQuantity(CI->getSExtValue()));
2971 return Builder.CreateAlignedLoad(VBaseOffs, CharUnits::fromQuantity(4),
3004 CharUnits offs = CharUnits::Zero();
3004 CharUnits offs = CharUnits::Zero();
3235 CharUnits::fromQuantity(4));
tools/clang/lib/CodeGen/SwiftCallingConv.cpp 55 static CharUnits getTypeStoreSize(CodeGenModule &CGM, llvm::Type *type) {
56 return CharUnits::fromQuantity(CGM.getDataLayout().getTypeStoreSize(type));
59 static CharUnits getTypeAllocSize(CodeGenModule &CGM, llvm::Type *type) {
60 return CharUnits::fromQuantity(CGM.getDataLayout().getTypeAllocSize(type));
63 void SwiftAggLowering::addTypedData(QualType type, CharUnits begin) {
78 auto eltSize = CGM.getContext().getTypeSizeInChars(eltType);
86 auto eltSize = CGM.getContext().getTypeSizeInChars(eltType);
105 void SwiftAggLowering::addTypedData(const RecordDecl *record, CharUnits begin) {
109 void SwiftAggLowering::addTypedData(const RecordDecl *record, CharUnits begin,
171 CharUnits recordBegin,
181 CharUnits bitfieldByteBegin = ctx.toCharUnitsFromBits(bitfieldBitBegin);
187 CharUnits bitfieldByteEnd =
188 ctx.toCharUnitsFromBits(bitfieldBitLast) + CharUnits::One();
193 void SwiftAggLowering::addTypedData(llvm::Type *type, CharUnits begin) {
199 CharUnits begin, CharUnits end) {
199 CharUnits begin, CharUnits end) {
212 auto componentSize = getTypeStoreSize(CGM, componentTy);
232 CharUnits begin, CharUnits end) {
232 CharUnits begin, CharUnits end) {
242 auto eltSize = (end - begin) / numElts;
259 CharUnits begin, CharUnits end) {
259 CharUnits begin, CharUnits end) {
323 CharUnits eltSize = (end - begin) / vecTy->getNumElements();
388 CharUnits eltSize = getTypeStoreSize(CGM, eltTy);
392 CharUnits begin = Entries[index].Begin;
405 static CharUnits getOffsetAtStartOfUnit(CharUnits offset, CharUnits unitSize) {
405 static CharUnits getOffsetAtStartOfUnit(CharUnits offset, CharUnits unitSize) {
405 static CharUnits getOffsetAtStartOfUnit(CharUnits offset, CharUnits unitSize) {
408 return CharUnits::fromQuantity(offset.getQuantity() & unitMask);
411 static bool areBytesInSameUnit(CharUnits first, CharUnits second,
411 static bool areBytesInSameUnit(CharUnits first, CharUnits second,
412 CharUnits chunkSize) {
439 CharUnits chunkSize) {
443 if (!areBytesInSameUnit(first.End - CharUnits::One(), second.Begin,
459 const CharUnits chunkSize = getMaximumVoluntaryIntegerSize(CGM);
498 auto begin = orig[i].Begin;
499 auto end = orig[i].End;
512 CharUnits localBegin = begin;
513 CharUnits chunkBegin = getOffsetAtStartOfUnit(localBegin, chunkSize);
514 CharUnits chunkEnd = chunkBegin + chunkSize;
515 CharUnits localEnd = std::min(end, chunkEnd);
518 CharUnits unitSize = CharUnits::One();
518 CharUnits unitSize = CharUnits::One();
519 CharUnits unitBegin, unitEnd;
562 CharUnits lastEnd = CharUnits::Zero();
562 CharUnits lastEnd = CharUnits::Zero();
567 auto paddingSize = entry.Begin - lastEnd;
577 CharUnits::fromQuantity(
638 CharUnits swiftcall::getMaximumVoluntaryIntegerSize(CodeGenModule &CGM) {
644 CharUnits swiftcall::getNaturalAlignment(CodeGenModule &CGM, llvm::Type *type) {
652 return CharUnits::fromQuantity(size);
675 bool swiftcall::isLegalVectorType(CodeGenModule &CGM, CharUnits vectorSize,
681 bool swiftcall::isLegalVectorType(CodeGenModule &CGM, CharUnits vectorSize,
689 swiftcall::splitLegalVectorType(CodeGenModule &CGM, CharUnits vectorSize,
703 void swiftcall::legalizeVectorType(CodeGenModule &CGM, CharUnits origVectorSize,
729 CharUnits eltSize = (origVectorSize / numElts);
730 CharUnits candidateSize = eltSize * candidateNumElts;
786 CharUnits alignmentForIndirect) {
807 lowering.addTypedData(recordType->getDecl(), CharUnits::Zero(), layout);
822 lowering.addTypedData(type, CharUnits::Zero());
825 CharUnits alignment = CGM.getContext().getTypeAlignInChars(type);
tools/clang/lib/CodeGen/TargetInfo.cpp 70 Builder.CreateAlignedStore(Value, Cell, CharUnits::One());
131 bool SwiftABIInfo::isLegalVectorTypeForSwift(CharUnits vectorSize,
259 CharUnits Align) {
290 CharUnits DirectSize,
291 CharUnits DirectAlign,
292 CharUnits SlotSize,
311 CharUnits FullDirectSize = DirectSize.alignTo(SlotSize);
342 std::pair<CharUnits, CharUnits> ValueInfo,
342 std::pair<CharUnits, CharUnits> ValueInfo,
343 CharUnits SlotSizeAndAlign,
346 CharUnits DirectSize, DirectAlign;
381 CharUnits Align = std::min(Addr1.getAlignment(), Addr2.getAlignment());
628 CharUnits TyAlignForABI = TyInfo.second;
841 CharUnits::fromQuantity(4),
1065 CharUnits &StackOffset, ABIArgInfo &Info,
1529 return ABIArgInfo::getIndirect(CharUnits::fromQuantity(4), /*ByVal=*/true);
1534 return ABIArgInfo::getIndirect(CharUnits::fromQuantity(StackAlign),
1846 CharUnits &StackOffset, ABIArgInfo &Info,
1849 CharUnits FieldAlign = CharUnits::fromQuantity(4);
1849 CharUnits FieldAlign = CharUnits::fromQuantity(4);
1857 CharUnits FieldEnd = StackOffset;
1860 CharUnits NumBytes = StackOffset - FieldEnd;
1898 CharUnits StackAlign = CharUnits::fromQuantity(4);
1898 CharUnits StackAlign = CharUnits::fromQuantity(4);
1900 CharUnits StackOffset;
1945 TypeInfo.second = CharUnits::fromQuantity(
1949 TypeInfo, CharUnits::fromQuantity(4),
2020 CharUnits::One());
2991 return ABIArgInfo::getIndirect(CharUnits::fromQuantity(Align));
3691 CharUnits Align = CGF.getContext().getTypeAlignInChars(Ty);
3692 if (Align > CharUnits::fromQuantity(8)) {
3815 CharUnits::fromQuantity(getDataLayout().getABITypeAlignment(TyLo)));
3821 CharUnits::fromQuantity(getDataLayout().getABITypeAlignment(TyHi)));
3827 CharUnits::fromQuantity(8));
3831 std::pair<CharUnits, CharUnits> SizeAlign =
3831 std::pair<CharUnits, CharUnits> SizeAlign =
3834 CharUnits TyAlign = SizeAlign.second;
3846 CharUnits::fromQuantity(16));
3857 CharUnits::fromQuantity(16));
3860 CharUnits::fromQuantity(16));
3909 CharUnits::fromQuantity(8),
3940 CharUnits Align = getContext().toCharUnitsFromBits(Info.Align);
4120 CharUnits::fromQuantity(8),
4130 CharUnits getParamTypeAlignment(QualType Ty) const;
4155 CharUnits PPC32_SVR4_ABIInfo::getParamTypeAlignment(QualType Ty) const {
4161 return CharUnits::fromQuantity(getContext().getTypeSize(Ty) == 128 ? 16
4175 return CharUnits::fromQuantity(AlignTy->isVectorType() ? 16 : 4);
4176 return CharUnits::fromQuantity(4);
4187 CharUnits SlotSize = CharUnits::fromQuantity(4);
4187 CharUnits SlotSize = CharUnits::fromQuantity(4);
4254 CharUnits::fromQuantity(8));
4260 CharUnits::fromQuantity(32));
4265 CharUnits RegSize = CharUnits::fromQuantity((isInt || IsSoftFloatABI) ? 4 : 8);
4265 CharUnits RegSize = CharUnits::fromQuantity((isInt || IsSoftFloatABI) ? 4 : 8);
4290 CharUnits OverflowAreaAlign = CharUnits::fromQuantity(4);
4290 CharUnits OverflowAreaAlign = CharUnits::fromQuantity(4);
4292 CharUnits Size;
4304 CharUnits Align = CGF.getContext().getTypeAlignInChars(Ty);
4427 CharUnits getParamTypeAlignment(QualType Ty) const;
4538 CharUnits PPC64_SVR4_ABIInfo::getParamTypeAlignment(QualType Ty) const {
4547 return CharUnits::fromQuantity(32);
4549 return CharUnits::fromQuantity(16);
4551 return CharUnits::fromQuantity(getContext().getTypeSize(Ty) == 128 ? 16 : 8);
4576 return CharUnits::fromQuantity(32);
4578 return CharUnits::fromQuantity(16);
4580 return CharUnits::fromQuantity(AlignAsType->isVectorType() ? 16 : 8);
4587 return CharUnits::fromQuantity(32);
4588 return CharUnits::fromQuantity(16);
4591 return CharUnits::fromQuantity(8);
4793 return ABIArgInfo::getIndirect(CharUnits::fromQuantity(ABIAlign),
4863 CharUnits SlotSize = CharUnits::fromQuantity(8);
4863 CharUnits SlotSize = CharUnits::fromQuantity(8);
4872 CharUnits EltSize = TypeInfo.first / 2;
5034 bool isLegalVectorTypeForSwift(CharUnits totalSize, llvm::Type *eltTy,
5267 bool AArch64ABIInfo::isLegalVectorTypeForSwift(CharUnits totalSize,
5334 CharUnits TySize = getContext().getTypeSizeInChars(Ty);
5335 CharUnits TyAlign = getContext().getTypeUnadjustedAlignInChars(Ty);
5417 CharUnits::fromQuantity(IsFPR ? 16 : 8));
5449 CharUnits BaseOffset = CharUnits::fromQuantity(16 * i + Offset);
5449 CharUnits BaseOffset = CharUnits::fromQuantity(16 * i + Offset);
5465 CharUnits SlotSize = BaseAddr.getAlignment();
5469 CharUnits Offset = SlotSize - TySize;
5503 std::max(CharUnits::fromQuantity(8), TyAlign));
5506 CharUnits StackSlotSize = CharUnits::fromQuantity(8);
5506 CharUnits StackSlotSize = CharUnits::fromQuantity(8);
5507 CharUnits StackSize;
5522 CharUnits Offset = StackSlotSize - TySize;
5553 CharUnits SlotSize = CharUnits::fromQuantity(8);
5553 CharUnits SlotSize = CharUnits::fromQuantity(8);
5583 CharUnits::fromQuantity(8),
5672 bool isLegalVectorTypeForSwift(CharUnits totalSize, llvm::Type *eltTy,
5929 getContext().getTypeSizeInChars(Ty) > CharUnits::fromQuantity(16)) {
5934 CharUnits::fromQuantity(getContext().getTypeAlign(Ty) / 8), false);
5950 if (getContext().getTypeSizeInChars(Ty) > CharUnits::fromQuantity(64)) {
5952 return ABIArgInfo::getIndirect(CharUnits::fromQuantity(ABIAlign),
6240 bool ARMABIInfo::isLegalVectorTypeForSwift(CharUnits vectorSize,
6287 CharUnits SlotSize = CharUnits::fromQuantity(4);
6287 CharUnits SlotSize = CharUnits::fromQuantity(4);
6296 CharUnits TySize = getContext().getTypeSizeInChars(Ty);
6297 CharUnits TyAlignForABI = getContext().getTypeUnadjustedAlignInChars(Ty);
6303 if (TySize > CharUnits::fromQuantity(16) && isIllegalVectorType(Ty)) {
6308 } else if (TySize > CharUnits::fromQuantity(16) &&
6319 TyAlignForABI = std::max(TyAlignForABI, CharUnits::fromQuantity(4));
6320 TyAlignForABI = std::min(TyAlignForABI, CharUnits::fromQuantity(8));
6323 TyAlignForABI = std::max(TyAlignForABI, CharUnits::fromQuantity(4));
6324 TyAlignForABI = std::min(TyAlignForABI, CharUnits::fromQuantity(16));
6326 TyAlignForABI = CharUnits::fromQuantity(4);
6329 std::pair<CharUnits, CharUnits> TyInfo = { TySize, TyAlignForABI };
6329 std::pair<CharUnits, CharUnits> TyInfo = { TySize, TyAlignForABI };
6695 CharUnits UnpaddedSize;
6696 CharUnits DirectAlign;
6699 UnpaddedSize = DirectAlign = CharUnits::fromQuantity(8);
6708 CharUnits PaddedSize = CharUnits::fromQuantity(8);
6708 CharUnits PaddedSize = CharUnits::fromQuantity(8);
6710 PaddedSize = CharUnits::fromQuantity(16);
6713 CharUnits Padding = (PaddedSize - UnpaddedSize);
6743 CharUnits RegPadding;
7269 std::min(TyInfo.second, CharUnits::fromQuantity(StackAlignInBytes));
7272 CharUnits ArgSlotSize = CharUnits::fromQuantity(MinABIStackAlignInBytes);
7272 CharUnits ArgSlotSize = CharUnits::fromQuantity(MinABIStackAlignInBytes);
7542 CharUnits::fromQuantity(4),
7608 return ABIArgInfo::getIndirect(CharUnits::fromQuantity(4), /*ByVal=*/true,
8358 CharUnits SlotSize = CharUnits::fromQuantity(8);
8358 CharUnits SlotSize = CharUnits::fromQuantity(8);
8367 CharUnits Stride;
8376 CharUnits Offset = SlotSize - TypeInfo.first;
8383 Stride = CharUnits::fromQuantity(AllocSize).alignTo(SlotSize);
8522 return ABIArgInfo::getIndirect(CharUnits::fromQuantity(4), /*ByVal=*/true,
8530 CharUnits::fromQuantity(4), true);
8716 CharUnits SlotSize = CharUnits::fromQuantity(4);
8716 CharUnits SlotSize = CharUnits::fromQuantity(4);
8721 CharUnits TypeAlign = getContext().getTypeAlignInChars(Ty);
8728 CharUnits ArgSize = CharUnits::Zero();
8728 CharUnits ArgSize = CharUnits::Zero();
8736 ArgSize = CharUnits::Zero();
8741 ArgSize = CharUnits::fromQuantity(
9254 bool detectFPCCEligibleStructHelper(QualType Ty, CharUnits CurOff,
9256 CharUnits &Field1Off,
9258 CharUnits &Field2Off) const;
9278 CharUnits &Field1Off, llvm::Type *&Field2Ty,
9279 CharUnits &Field2Off, int &NeededArgGPRs,
9282 CharUnits Field1Off,
9284 CharUnits Field2Off) const;
9322 bool RISCVABIInfo::detectFPCCEligibleStructHelper(QualType Ty, CharUnits CurOff,
9324 CharUnits &Field1Off,
9326 CharUnits &Field2Off) const {
9373 CharUnits EltSize = getContext().getTypeSizeInChars(EltTy);
9435 CharUnits &Field1Off,
9437 CharUnits &Field2Off,
9445 Ty, CharUnits::Zero(), Field1Ty, Field1Off, Field2Ty, Field2Off);
9466 llvm::Type *Field1Ty, CharUnits Field1Off, llvm::Type *Field2Ty,
9467 CharUnits Field2Off) const {
9483 CharUnits Field2Align =
9484 CharUnits::fromQuantity(getDataLayout().getABITypeAlignment(Field2Ty));
9485 CharUnits Field1Size =
9486 CharUnits::fromQuantity(getDataLayout().getTypeStoreSize(Field1Ty));
9487 CharUnits Field2OffNoPadNoPack = Field1Size.alignTo(Field2Align);
9489 CharUnits Padding = CharUnits::Zero();
9489 CharUnits Padding = CharUnits::Zero();
9552 CharUnits Field1Off = CharUnits::Zero();
9552 CharUnits Field1Off = CharUnits::Zero();
9553 CharUnits Field2Off = CharUnits::Zero();
9553 CharUnits Field2Off = CharUnits::Zero();
9636 CharUnits SlotSize = CharUnits::fromQuantity(XLen / 8);
9636 CharUnits SlotSize = CharUnits::fromQuantity(XLen / 8);
9645 std::pair<CharUnits, CharUnits> SizeAndAlign =
9645 std::pair<CharUnits, CharUnits> SizeAndAlign =
tools/clang/lib/Frontend/LayoutOverrideSource.cpp 158 llvm::DenseMap<const CXXRecordDecl *, CharUnits> &BaseOffsets,
159 llvm::DenseMap<const CXXRecordDecl *, CharUnits> &VirtualBaseOffsets)
tools/clang/lib/Frontend/Rewrite/RewriteModernObjC.cpp 6823 CharUnits Size = Context->getTypeSizeInChars(IVQT);
tools/clang/lib/Sema/MultiplexExternalSemaSource.cpp 184 llvm::DenseMap<const CXXRecordDecl *, CharUnits> &BaseOffsets,
185 llvm::DenseMap<const CXXRecordDecl *, CharUnits> &VirtualBaseOffsets){
tools/clang/lib/Sema/SemaCast.cpp 924 CharUnits Offset = CharUnits::Zero();
924 CharUnits Offset = CharUnits::Zero();
2816 CharUnits DestSize = Self.Context.getTypeSizeInChars(DestType);
2817 CharUnits SourceSize = Self.Context.getTypeSizeInChars(SrcType);
tools/clang/lib/Sema/SemaChecking.cpp 6145 CharUnits ArgSize = Context.getTypeSizeInChars(Arg.get()->getType());
13121 static CharUnits getDeclAlign(Expr *E, CharUnits TypeAlign,
13121 static CharUnits getDeclAlign(Expr *E, CharUnits TypeAlign,
13151 CharUnits DestAlign = Context.getTypeAlignInChars(DestPointee);
13165 CharUnits SrcAlign = Context.getTypeAlignInChars(SrcPointee);
14630 CharUnits Alignment) {
14668 llvm::function_ref<void(Expr *, RecordDecl *, FieldDecl *, CharUnits)>
14719 CharUnits ExpectedAlignment = Context.getTypeAlignInChars(E->getType());
14726 CharUnits Offset;
14733 CharUnits CompleteObjectAlignment = Context.getTypeAlignInChars(
14759 CharUnits Alignment;
tools/clang/lib/Sema/SemaDecl.cpp12661 CharUnits MaxAlignChars = Context.toCharUnitsFromBits(MaxAlign);
tools/clang/lib/Sema/SemaDeclAttr.cpp 3792 CharUnits RequestedAlign = Context.toCharUnitsFromBits(Align);
3793 CharUnits NaturalAlign = Context.getTypeAlignInChars(UnderlyingTy);
tools/clang/lib/Sema/SemaExpr.cpp 5304 Optional<CharUnits> ArgSize =
5306 Optional<CharUnits> ParmSize = getASTContext().getTypeSizeInCharsIfKnown(CAT);
9769 CharUnits ElementSize = Context.getTypeSizeInChars(rpointee);
tools/clang/lib/Sema/SemaExprCXX.cpp 957 CharUnits TypeAlign = Context.getTypeAlignInChars(Ty);
958 CharUnits ExnObjAlign = Context.getExnObjectAlignment();
tools/clang/lib/Sema/SemaStmtAsm.cpp 827 CharUnits Result = Context.toCharUnitsFromBits(RL.getFieldOffset(i));
tools/clang/lib/StaticAnalyzer/Checkers/ArrayBoundCheckerV2.cpp 284 NonLoc baseVal, CharUnits scaling,
tools/clang/lib/StaticAnalyzer/Checkers/CastSizeChecker.cpp 48 static bool evenFlexibleArraySize(ASTContext &Ctx, CharUnits RegionSize,
49 CharUnits TypeSize, QualType ToPointeeTy) {
63 CharUnits FlexSize;
80 CharUnits Left = RegionSize - TypeSize;
117 CharUnits regionSize = CharUnits::fromQuantity(extentInt->getSExtValue());
117 CharUnits regionSize = CharUnits::fromQuantity(extentInt->getSExtValue());
118 CharUnits typeSize = C.getASTContext().getTypeSizeInChars(ToPointeeTy);
tools/clang/lib/StaticAnalyzer/Checkers/MallocChecker.cpp 1402 CharUnits TypeSize = AstContext.getTypeSizeInChars(ElementType);
tools/clang/lib/StaticAnalyzer/Checkers/PaddingChecker.cpp 94 CharUnits BaselinePad = calculateBaselinePad(RD, ASTContext, RL);
98 CharUnits OptimalPad;
103 CharUnits DiffPad = PadMultiplier * (BaselinePad - OptimalPad);
190 static CharUnits calculateBaselinePad(const RecordDecl *RD,
193 CharUnits PaddingSum;
194 CharUnits Offset = ASTContext.toCharUnitsFromBits(RL.getFieldOffset(0));
200 CharUnits FieldSize = ASTContext.getTypeSizeInChars(FD->getType());
202 CharUnits FieldOffset = ASTContext.toCharUnitsFromBits(FieldOffsetBits);
226 static std::pair<CharUnits, SmallVector<const FieldDecl *, 20>>
230 CharUnits Align;
231 CharUnits Size;
265 CharUnits NewOffset = ASTContext.toCharUnitsFromBits(RL.getFieldOffset(0));
266 CharUnits NewPad;
275 CharUnits CurAlignment = CharUnits::fromQuantity(CurAlignmentBits);
275 CharUnits CurAlignment = CharUnits::fromQuantity(CurAlignmentBits);
276 FieldInfo InsertPoint = {CurAlignment, CharUnits::Zero(), nullptr};
293 CharUnits NextOffset = NewOffset.alignTo(Fields[0].Align);
299 CharUnits NewSize = NewOffset.alignTo(RL.getAlignment());
305 const RecordDecl *RD, CharUnits BaselinePad, CharUnits OptimalPad,
305 const RecordDecl *RD, CharUnits BaselinePad, CharUnits OptimalPad,
tools/clang/lib/StaticAnalyzer/Checkers/VLASizeChecker.cpp 161 CharUnits EleSize = Ctx.getTypeSizeInChars(VLA->getElementType());
tools/clang/lib/StaticAnalyzer/Core/ExprEngineC.cpp 895 CharUnits amt = CharUnits::fromQuantity(Value.getZExtValue());
895 CharUnits amt = CharUnits::fromQuantity(Value.getZExtValue());
tools/clang/lib/StaticAnalyzer/Core/MemRegion.cpp 175 CharUnits size = Ctx.getTypeSizeInChars(T);
1276 return RegionRawOffset(superR, CharUnits::fromQuantity(offset));
1381 CharUnits BaseOffset;
tools/clang/lib/StaticAnalyzer/Core/RegionStore.cpp 1402 CharUnits RegionSize = CharUnits::fromQuantity(SizeInt->getSExtValue());
1402 CharUnits RegionSize = CharUnits::fromQuantity(SizeInt->getSExtValue());
1411 CharUnits EleSize = Ctx.getTypeSizeInChars(EleTy);
tools/clang/lib/StaticAnalyzer/Core/Store.cpp 172 CharUnits off = rawOff.getOffset();
202 CharUnits pointeeTySize = Ctx.getTypeSizeInChars(PointeeTy);
tools/clang/tools/extra/clang-tidy/bugprone/SizeofExpressionCheck.cpp 51 CharUnits getSizeOfType(const ASTContext &Ctx, const Type *Ty) {
54 return CharUnits::Zero();
288 CharUnits NumeratorSize = getSizeOfType(Ctx, NumTy);
289 CharUnits DenominatorSize = getSizeOfType(Ctx, DenomTy);
290 CharUnits ElementSize = getSizeOfType(Ctx, ElementTy);
292 if (DenominatorSize > CharUnits::Zero() &&
296 } else if (ElementSize > CharUnits::Zero() &&
297 DenominatorSize > CharUnits::Zero() &&
tools/clang/tools/extra/clang-tidy/cppcoreguidelines/SlicingCheck.cpp 124 const CharUnits StateSize =
tools/lldb/include/lldb/Symbol/ClangASTContext.h 445 llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
447 llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
tools/lldb/include/lldb/Symbol/ClangASTImporter.h 93 llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> base_offsets;
94 llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
127 llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
129 llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
tools/lldb/include/lldb/Symbol/ClangExternalASTSourceCallbacks.h 36 llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
38 llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
99 llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
101 llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
tools/lldb/source/Plugins/ExpressionParser/Clang/ASTUtils.h 123 llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
125 llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
416 llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
418 llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
tools/lldb/source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp 1655 typedef llvm::DenseMap<const CXXRecordDecl *, CharUnits> BaseOffsetMap;
1658 static bool ImportOffsetMap(llvm::DenseMap<const D *, O> &destination_map,
1659 llvm::DenseMap<const D *, O> &source_map,
1666 typedef llvm::DenseMap<const D *, O> MapType;
1718 CharUnits base_offset;
tools/lldb/source/Plugins/ExpressionParser/Clang/ClangASTSource.h 137 llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
139 llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
240 llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
242 llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
tools/lldb/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCDeclVendor.cpp 135 llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
137 llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
tools/lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp 2133 clang::CharUnits>::const_iterator base_pos,
2147 clang::CharUnits>::const_iterator vbase_pos,
3055 clang::CharUnits::fromQuantity(member_byte_offset)));
tools/lldb/source/Plugins/SymbolFile/NativePDB/UdtRecordCompleter.cpp 97 auto offset = clang::CharUnits::fromQuantity(base.getBaseOffset());
97 auto offset = clang::CharUnits::fromQuantity(base.getBaseOffset());
tools/lldb/source/Plugins/SymbolFile/PDB/PDBASTParser.cpp 1324 auto offset = clang::CharUnits::fromQuantity(base->getOffset());
1324 auto offset = clang::CharUnits::fromQuantity(base->getOffset());
tools/lldb/source/Symbol/ClangASTContext.cpp 291 clang::CharUnits base_offset_offset =
9865 llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
9867 llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
tools/lldb/source/Symbol/ClangASTImporter.cpp 574 llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
576 llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
tools/lldb/source/Symbol/ClangExternalASTSourceCallbacks.cpp 78 llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> &BaseOffsets,
79 llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits>
usr/include/c++/7.4.0/array 50 typedef _Tp _Type[_Nm];
51 typedef __is_swappable<_Tp> _Is_swappable;
52 typedef __is_nothrow_swappable<_Tp> _Is_nothrow_swappable;
54 static constexpr _Tp&
58 static constexpr _Tp*
96 typedef _Tp value_type;
109 typedef _GLIBCXX_STD_C::__array_traits<_Tp, _Nm> _AT_Type;
usr/include/c++/7.4.0/bits/algorithmfwd.h 369 const _Tp&
370 max(const _Tp&, const _Tp&);
370 max(const _Tp&, const _Tp&);
382 const _Tp&
383 min(const _Tp&, const _Tp&);
383 min(const _Tp&, const _Tp&);
usr/include/c++/7.4.0/bits/alloc_traits.h 387 using allocator_type = allocator<_Tp>;
389 using value_type = _Tp;
392 using pointer = _Tp*;
395 using const_pointer = const _Tp*;
474 construct(allocator_type& __a, _Up* __p, _Args&&... __args)
474 construct(allocator_type& __a, _Up* __p, _Args&&... __args)
486 destroy(allocator_type& __a, _Up* __p)
usr/include/c++/7.4.0/bits/allocator.h 108 class allocator: public __allocator_base<_Tp>
113 typedef _Tp* pointer;
114 typedef const _Tp* const_pointer;
115 typedef _Tp& reference;
116 typedef const _Tp& const_reference;
117 typedef _Tp value_type;
137 allocator(const allocator<_Tp1>&) throw() { }
usr/include/c++/7.4.0/bits/invoke.h 66 { return (__invfwd<_Tp>(__t).*__f)(std::forward<_Args>(__args)...); }
96 std::forward<_Args>(__args)...);
usr/include/c++/7.4.0/bits/move.h 46 inline _GLIBCXX_CONSTEXPR _Tp*
47 __addressof(_Tp& __r) _GLIBCXX_NOEXCEPT
72 constexpr _Tp&&
73 forward(typename std::remove_reference<_Tp>::type& __t) noexcept
83 constexpr _Tp&&
84 forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
98 move(_Tp&& __t) noexcept
104 : public __and_<__not_<is_nothrow_move_constructible<_Tp>>,
105 is_copy_constructible<_Tp>>::type { };
198 _Tp __tmp = _GLIBCXX_MOVE(__a);
usr/include/c++/7.4.0/bits/stl_algo.h 2040 const _Tp& __val, _Compare __comp)
2078 const _Tp& __val)
usr/include/c++/7.4.0/bits/stl_construct.h 74 _Construct(_T1* __p, _Args&&... __args)
74 _Construct(_T1* __p, _Args&&... __args)
75 { ::new(static_cast<void*>(__p)) _T1(std::forward<_Args>(__args)...); }
75 { ::new(static_cast<void*>(__p)) _T1(std::forward<_Args>(__args)...); }
204 allocator<_Tp>&)
usr/include/c++/7.4.0/bits/stl_function.h 121 typedef _Arg1 first_argument_type;
124 typedef _Arg2 second_argument_type;
381 struct less : public binary_function<_Tp, _Tp, bool>
381 struct less : public binary_function<_Tp, _Tp, bool>
385 operator()(const _Tp& __x, const _Tp& __y) const
385 operator()(const _Tp& __x, const _Tp& __y) const
usr/include/c++/7.4.0/bits/stl_iterator.h 1224 __make_move_if_noexcept_iterator(_Tp* __i)
usr/include/c++/7.4.0/bits/stl_iterator_base_types.h 123 typedef _Tp value_type;
181 typedef _Tp value_type;
183 typedef _Tp* pointer;
184 typedef _Tp& reference;
192 typedef _Tp value_type;
194 typedef const _Tp* pointer;
195 typedef const _Tp& reference;
usr/include/c++/7.4.0/bits/stl_map.h 103 typedef _Tp mapped_type;
104 typedef std::pair<const _Key, _Tp> value_type;
usr/include/c++/7.4.0/bits/stl_pair.h 100 return __and_<is_constructible<_T1, const _U1&>,
100 return __and_<is_constructible<_T1, const _U1&>,
101 is_constructible<_T2, const _U2&>>::value;
101 is_constructible<_T2, const _U2&>>::value;
107 return __and_<is_convertible<const _U1&, _T1>,
107 return __and_<is_convertible<const _U1&, _T1>,
108 is_convertible<const _U2&, _T2>>::value;
108 is_convertible<const _U2&, _T2>>::value;
114 return __and_<is_constructible<_T1, _U1&&>,
114 return __and_<is_constructible<_T1, _U1&&>,
115 is_constructible<_T2, _U2&&>>::value;
115 is_constructible<_T2, _U2&&>>::value;
121 return __and_<is_convertible<_U1&&, _T1>,
121 return __and_<is_convertible<_U1&&, _T1>,
122 is_convertible<_U2&&, _T2>>::value;
122 is_convertible<_U2&&, _T2>>::value;
128 using __do_converts = __and_<is_convertible<const _U1&, _T1>,
128 using __do_converts = __and_<is_convertible<const _U1&, _T1>,
129 is_convertible<_U2&&, _T2>>;
129 is_convertible<_U2&&, _T2>>;
133 return __and_<is_constructible<_T1, const _U1&>,
133 return __and_<is_constructible<_T1, const _U1&>,
134 is_constructible<_T2, _U2&&>,
134 is_constructible<_T2, _U2&&>,
142 using __do_converts = __and_<is_convertible<_U1&&, _T1>,
142 using __do_converts = __and_<is_convertible<_U1&&, _T1>,
143 is_convertible<const _U2&, _T2>>;
143 is_convertible<const _U2&, _T2>>;
147 return __and_<is_constructible<_T1, _U1&&>,
147 return __and_<is_constructible<_T1, _U1&&>,
148 is_constructible<_T2, const _U2&&>,
148 is_constructible<_T2, const _U2&&>,
209 : private __pair_base<_T1, _T2>
209 : private __pair_base<_T1, _T2>
211 typedef _T1 first_type; /// @c first_type is the first bound type
212 typedef _T2 second_type; /// @c second_type is the second bound type
214 _T1 first; /// @c first is a copy of the first object
215 _T2 second; /// @c second is a copy of the second object
252 using _PCCP = _PCC<true, _T1, _T2>;
252 using _PCCP = _PCC<true, _T1, _T2>;
260 constexpr pair(const _T1& __a, const _T2& __b)
260 constexpr pair(const _T1& __a, const _T2& __b)
269 explicit constexpr pair(const _T1& __a, const _T2& __b)
269 explicit constexpr pair(const _T1& __a, const _T2& __b)
283 _T1, _T2>;
283 _T1, _T2>;
291 constexpr pair(const pair<_U1, _U2>& __p)
311 constexpr pair(_U1&& __x, const _T2& __y)
311 constexpr pair(_U1&& __x, const _T2& __y)
318 explicit constexpr pair(_U1&& __x, const _T2& __y)
325 constexpr pair(const _T1& __x, _U2&& __y)
325 constexpr pair(const _T1& __x, _U2&& __y)
332 explicit pair(const _T1& __x, _U2&& __y)
341 constexpr pair(_U1&& __x, _U2&& __y)
341 constexpr pair(_U1&& __x, _U2&& __y)
342 : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
342 : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y)) { }
360 constexpr pair(pair<_U1, _U2>&& __p)
362 second(std::forward<_U2>(__p.second)) { }
379 __and_<is_copy_assignable<_T1>,
380 is_copy_assignable<_T2>>::value,
390 __and_<is_move_assignable<_T1>,
391 is_move_assignable<_T2>>::value,
402 typename enable_if<__and_<is_assignable<_T1&, const _U1&>,
402 typename enable_if<__and_<is_assignable<_T1&, const _U1&>,
403 is_assignable<_T2&, const _U2&>>::value,
403 is_assignable<_T2&, const _U2&>>::value,
405 operator=(const pair<_U1, _U2>& __p)
405 operator=(const pair<_U1, _U2>& __p)
413 typename enable_if<__and_<is_assignable<_T1&, _U1&&>,
413 typename enable_if<__and_<is_assignable<_T1&, _U1&&>,
414 is_assignable<_T2&, _U2&&>>::value,
414 is_assignable<_T2&, _U2&&>>::value,
416 operator=(pair<_U1, _U2>&& __p)
416 operator=(pair<_U1, _U2>&& __p)
495 swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
495 swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
495 swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
495 swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
522 constexpr pair<typename __decay_and_strip<_T1>::__type,
523 typename __decay_and_strip<_T2>::__type>
524 make_pair(_T1&& __x, _T2&& __y)
524 make_pair(_T1&& __x, _T2&& __y)
526 typedef typename __decay_and_strip<_T1>::__type __ds_type1;
527 typedef typename __decay_and_strip<_T2>::__type __ds_type2;
529 return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y));
529 return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y));
usr/include/c++/7.4.0/bits/stl_uninitialized.h 288 _ForwardIterator __result, allocator<_Tp>&)
usr/include/c++/7.4.0/bits/stl_vector.h 77 rebind<_Tp>::other _Tp_alloc_type;
216 class vector : protected _Vector_base<_Tp, _Alloc>
227 typedef _Vector_base<_Tp, _Alloc> _Base;
232 typedef _Tp value_type;
919 _Tp*
923 const _Tp*
1483 _M_realloc_insert(iterator __position, _Args&&... __args);
usr/include/c++/7.4.0/ext/alloc_traits.h 117 { typedef typename _Base_type::template rebind_alloc<_Tp> other; };
usr/include/c++/7.4.0/ext/new_allocator.h 63 typedef _Tp* pointer;
64 typedef const _Tp* const_pointer;
65 typedef _Tp& reference;
66 typedef const _Tp& const_reference;
67 typedef _Tp value_type;
84 new_allocator(const new_allocator<_Tp1>&) _GLIBCXX_USE_NOEXCEPT { }
111 return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp)));
130 { return size_t(-1) / sizeof(_Tp); }
135 construct(_Up* __p, _Args&&... __args)
135 construct(_Up* __p, _Args&&... __args)
136 { ::new((void *)__p) _Up(std::forward<_Args>(__args)...); }
140 destroy(_Up* __p) { __p->~_Up(); }
usr/include/c++/7.4.0/functional 110 = _Maybe_unary_or_binary_function<_Res, _Class*, _ArgTypes...>;
411 _Safe_tuple_element_t<(is_placeholder<_Arg>::value - 1), _Tuple>&&
411 _Safe_tuple_element_t<(is_placeholder<_Arg>::value - 1), _Tuple>&&
547 operator()(_Args&&... __args)
550 std::forward_as_tuple(std::forward<_Args>(__args)...),
558 operator()(_Args&&... __args) const
576 operator()(_Args&&... __args) volatile
588 operator()(_Args&&... __args) const volatile
usr/include/c++/7.4.0/initializer_list 50 typedef _E value_type;
51 typedef const _E& reference;
52 typedef const _E& const_reference;
54 typedef const _E* iterator;
55 typedef const _E* const_iterator;
usr/include/c++/7.4.0/tuple 56 struct __is_empty_non_tuple : is_empty<_Tp> { };
125 constexpr _Head_base(const _Head& __h)
132 constexpr _Head_base(_UHead&& __h)
133 : _M_head_impl(std::forward<_UHead>(__h)) { }
159 static constexpr _Head&
162 static constexpr const _Head&
165 _Head _M_head_impl;
186 : public _Tuple_impl<_Idx + 1, _Tail...>,
187 private _Head_base<_Idx, _Head>
191 typedef _Tuple_impl<_Idx + 1, _Tail...> _Inherited;
192 typedef _Head_base<_Idx, _Head> _Base;
194 static constexpr _Head&
197 static constexpr const _Head&
210 constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail)
210 constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail)
216 constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail)
216 constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail)
217 : _Inherited(std::forward<_UTail>(__tail)...),
218 _Base(std::forward<_UHead>(__head)) { }
227 _Base(std::forward<_Head>(_M_head(__in))) { }
230 constexpr _Tuple_impl(const _Tuple_impl<_Idx, _UElements...>& __in)
235 constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
235 constexpr _Tuple_impl(_Tuple_impl<_Idx, _UHead, _UTails...>&& __in)
242 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
248 const _Head& __head, const _Tail&... __tail)
248 const _Head& __head, const _Tail&... __tail)
262 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
268 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a,
350 static constexpr _Head&
353 static constexpr const _Head&
360 constexpr _Tuple_impl(const _Head& __head)
365 constexpr _Tuple_impl(_UHead&& __head)
366 : _Base(std::forward<_UHead>(__head)) { }
390 const _Head& __head)
473 return __and_<is_constructible<_Elements, const _UElements&>...>::value;
473 return __and_<is_constructible<_Elements, const _UElements&>...>::value;
479 return __and_<is_convertible<const _UElements&, _Elements>...>::value;
479 return __and_<is_convertible<const _UElements&, _Elements>...>::value;
485 return __and_<is_constructible<_Elements, _UElements&&>...>::value;
485 return __and_<is_constructible<_Elements, _UElements&&>...>::value;
491 return __and_<is_convertible<_UElements&&, _Elements>...>::value;
491 return __and_<is_convertible<_UElements&&, _Elements>...>::value;
508 return __not_<is_same<tuple<_Elements...>,
556 class tuple : public _Tuple_impl<0, _Elements...>
558 typedef _Tuple_impl<0, _Elements...> _Inherited;
598 _Elements...>;
608 constexpr tuple(const _Elements&... __elements)
619 explicit constexpr tuple(const _Elements&... __elements)
628 _Elements...>;
636 _Elements...>;
646 constexpr tuple(_UElements&&... __elements)
647 : _Inherited(std::forward<_UElements>(__elements)...) { }
668 _Elements...>;
730 const _Elements&... __elements)
741 const _Elements&... __elements)
767 tuple(allocator_arg_t __tag, const _Alloc& __a, const tuple& __in)
771 tuple(allocator_arg_t __tag, const _Alloc& __a, tuple&& __in)
947 constexpr tuple(const _T1& __a1, const _T2& __a2)
947 constexpr tuple(const _T1& __a1, const _T2& __a2)
956 explicit constexpr tuple(const _T1& __a1, const _T2& __a2)
956 explicit constexpr tuple(const _T1& __a1, const _T2& __a2)
971 constexpr tuple(_U1&& __a1, _U2&& __a2)
971 constexpr tuple(_U1&& __a1, _U2&& __a2)
1066 tuple(allocator_arg_t __tag, const _Alloc& __a)
1078 const _T1& __a1, const _T2& __a2)
1078 const _T1& __a1, const _T2& __a2)
1090 const _T1& __a1, const _T2& __a2)
1090 const _T1& __a1, const _T2& __a2)
1241 operator=(const pair<_U1, _U2>& __in)
1241 operator=(const pair<_U1, _U2>& __in)
1250 operator=(pair<_U1, _U2>&& __in)
1250 operator=(pair<_U1, _U2>&& __in)
1252 this->_M_head(*this) = std::forward<_U1>(__in.first);
1253 this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__in.second);
1280 : tuple_element<__i - 1, tuple<_Tail...> > { };
1288 typedef _Head type;
1302 constexpr _Head&
1303 __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
1303 __get_helper(_Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
1304 { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
1304 { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
1307 constexpr const _Head&
1308 __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
1308 __get_helper(const _Tuple_impl<__i, _Head, _Tail...>& __t) noexcept
1309 { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
1309 { return _Tuple_impl<__i, _Head, _Tail...>::_M_head(__t); }
1313 constexpr __tuple_element_t<__i, tuple<_Elements...>>&
1313 constexpr __tuple_element_t<__i, tuple<_Elements...>>&
1313 constexpr __tuple_element_t<__i, tuple<_Elements...>>&
1314 get(tuple<_Elements...>& __t) noexcept
1319 constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
1319 constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
1319 constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
1320 get(const tuple<_Elements...>& __t) noexcept
1325 constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
1325 constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
1325 constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
1326 get(tuple<_Elements...>&& __t) noexcept
1329 return std::forward<__element_type&&>(std::get<__i>(__t));
1410 operator<(const tuple<_TElements...>& __t,
1411 const tuple<_UElements...>& __u)
1415 using __compare = __tuple_compare<tuple<_TElements...>,
1416 tuple<_UElements...>,
1447 constexpr tuple<typename __decay_and_strip<_Elements>::__type...>
1448 make_tuple(_Elements&&... __args)
1450 typedef tuple<typename __decay_and_strip<_Elements>::__type...>
1452 return __result_type(std::forward<_Elements>(__args)...);
1458 constexpr tuple<_Elements&&...>
1459 forward_as_tuple(_Elements&&... __args) noexcept
1460 { return tuple<_Elements&&...>(std::forward<_Elements>(__args)...); }
1588 constexpr tuple<_Elements&...>
1589 tie(_Elements&... __args) noexcept
usr/include/c++/7.4.0/type_traits 215 : public __is_void_helper<typename remove_cv<_Tp>::type>::type
326 : public __is_integral_helper<typename remove_cv<_Tp>::type>::type
354 : public __is_floating_point_helper<typename remove_cv<_Tp>::type>::type
381 : public __is_pointer_helper<typename remove_cv<_Tp>::type>::type
567 : public __is_null_pointer_helper<typename remove_cv<_Tp>::type>::type
581 : public __or_<is_lvalue_reference<_Tp>,
582 is_rvalue_reference<_Tp>>::type
588 : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
588 : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
601 : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
601 : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
602 is_void<_Tp>>>::type
611 : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
611 : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
611 : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
612 is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
612 is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
631 : public __is_member_pointer_helper<typename remove_cv<_Tp>::type>::type
638 : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
638 : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
762 typename add_rvalue_reference<_Tp>::type declval() noexcept;
777 : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
777 : public __and_<is_array<_Tp>, __not_<extent<_Tp>>>
798 typedef decltype(__test<_Tp>(0)) type;
811 remove_all_extents<_Tp>::type>::type
825 : public __is_destructible_safe<_Tp>::type
889 typedef decltype(__test<_Tp>(0)) type;
894 : public __and_<__not_<is_void<_Tp>>,
895 __is_default_constructible_impl<_Tp>>
915 : public __is_default_constructible_atom<_Tp>::type
921 : public __is_default_constructible_safe<_Tp>::type
984 typedef decltype(__test<_Tp, _Arg>(0)) type;
989 : public __and_<is_destructible<_Tp>,
990 __is_direct_constructible_impl<_Tp, _Arg>>
1072 __is_direct_constructible_ref_cast<_Tp, _Arg>,
1073 __is_direct_constructible_new_safe<_Tp, _Arg>
1079 : public __is_direct_constructible_new<_Tp, _Arg>::type
1119 : public __is_direct_constructible<_Tp, _Arg>
1130 : public __is_constructible_impl<_Tp, _Args...>::type
1142 : public is_constructible<_Tp, const _Tp&>
1142 : public is_constructible<_Tp, const _Tp&>
1148 : public __is_copy_constructible_impl<_Tp>
1160 : public is_constructible<_Tp, _Tp&&>
1160 : public is_constructible<_Tp, _Tp&&>
1166 : public __is_move_constructible_impl<_Tp>
1215 : public __and_<is_constructible<_Tp, _Args...>,
1216 __is_nt_constructible_impl<_Tp, _Args...>>
1246 : public is_nothrow_constructible<_Tp, _Tp&&>
1246 : public is_nothrow_constructible<_Tp, _Tp&&>
1252 : public __is_nothrow_move_constructible_impl<_Tp>
1286 : public is_assignable<_Tp&, const _Tp&>
1286 : public is_assignable<_Tp&, const _Tp&>
1292 : public __is_copy_assignable_impl<_Tp>
1304 : public is_assignable<_Tp&, _Tp&&>
1304 : public is_assignable<_Tp&, _Tp&&>
1310 : public __is_move_assignable_impl<_Tp>
1352 : public is_nothrow_assignable<_Tp&, _Tp&&>
1352 : public is_nothrow_assignable<_Tp&, _Tp&&>
1358 : public __is_nt_move_assignable_impl<_Tp>
1377 static void __helper(const _Tp&);
1380 static true_type __test(const _Tp&,
1381 decltype(__helper<const _Tp&>({}))* = 0);
1390 typedef decltype(__test(declval<_Tp>())) type;
1395 : public __is_implicitly_default_constructible_impl<_Tp>::type
1400 : public __and_<is_default_constructible<_Tp>,
1401 __is_implicitly_default_constructible_safe<_Tp>>
1526 static void __test_aux(_To1);
1538 typedef decltype(__test<_From, _To>(0)) type;
1545 : public __is_convertible_helper<_From, _To>::type
1554 { typedef _Tp type; };
1558 { typedef _Tp type; };
1563 { typedef _Tp type; };
1574 remove_const<typename remove_volatile<_Tp>::type>::type type;
1629 { typedef _Tp type; };
1633 { typedef _Tp type; };
1637 { typedef _Tp type; };
1659 { typedef _Tp&& type; };
1664 : public __add_rvalue_reference_helper<_Tp>
1955 { typedef _Tp type; };
2104 { typedef typename remove_cv<_Up>::type __type; };
2118 typedef typename remove_reference<_Tp>::type __remove_type;
2131 typedef _Tp __type;
2144 typename decay<_Tp>::type>::__type __type;
2253 inline typename add_rvalue_reference<_Tp>::type
2285 (std::declval<_Tp1>().*std::declval<_Fp>())(std::declval<_Args>()...)
2296 typedef decltype(_S_test<_MemPtr, _Arg, _Args...>(0)) type;
2574 typename remove_reference<_Tp>::type>::type>::type
2579 typename enable_if<__and_<__not_<__is_tuple_like<_Tp>>,
2580 is_move_constructible<_Tp>,
2581 is_move_assignable<_Tp>>::value>::type
2582 swap(_Tp&, _Tp&)
2582 swap(_Tp&, _Tp&)
2609 noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))
2609 noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))
2629 typedef decltype(__test<_Tp>(0)) type;
2639 : public __is_nothrow_swappable_impl<_Tp>::type
2776 std::declval<_Args>()...));