|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
References
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 {
189 ::new ((void *)std::addressof(value)) T(std::forward<Args>(args)...);
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) && {
282 bool operator==(const Optional<T> &X, const Optional<U> &Y) {
282 bool operator==(const Optional<T> &X, const Optional<U> &Y) {
289 bool operator!=(const Optional<T> &X, const Optional<U> &Y) {
289 bool operator!=(const Optional<T> &X, const Optional<U> &Y) {
294 bool operator<(const Optional<T> &X, const Optional<U> &Y) {
294 bool operator<(const Optional<T> &X, const Optional<U> &Y) {
301 bool operator<=(const Optional<T> &X, const Optional<U> &Y) {
301 bool operator<=(const Optional<T> &X, const Optional<U> &Y) {
306 bool operator>(const Optional<T> &X, const Optional<U> &Y) {
306 bool operator>(const Optional<T> &X, const Optional<U> &Y) {
311 bool operator>=(const Optional<T> &X, const Optional<U> &Y) {
311 bool operator>=(const Optional<T> &X, const Optional<U> &Y) {
316 bool operator==(const Optional<T> &X, NoneType) {
321 bool operator==(NoneType, const Optional<T> &X) {
326 bool operator!=(const Optional<T> &X, NoneType) {
331 bool operator!=(NoneType, const Optional<T> &X) {
335 template <typename T> bool operator<(const Optional<T> &X, NoneType) {
339 template <typename T> bool operator<(NoneType, const Optional<T> &X) {
343 template <typename T> bool operator<=(const Optional<T> &X, NoneType) {
347 template <typename T> bool operator<=(NoneType, const Optional<T> &X) {
351 template <typename T> bool operator>(const Optional<T> &X, NoneType) {
355 template <typename T> bool operator>(NoneType, const Optional<T> &X) {
359 template <typename T> bool operator>=(const Optional<T> &X, NoneType) {
363 template <typename T> bool operator>=(NoneType, const Optional<T> &X) {
367 template <typename T> bool operator==(const Optional<T> &X, const T &Y) {
367 template <typename T> bool operator==(const Optional<T> &X, const T &Y) {
371 template <typename T> bool operator==(const T &X, const Optional<T> &Y) {
371 template <typename T> bool operator==(const T &X, const Optional<T> &Y) {
379 template <typename T> bool operator!=(const T &X, const Optional<T> &Y) {
379 template <typename T> bool operator!=(const T &X, const Optional<T> &Y) {
387 template <typename T> bool operator<(const T &X, const Optional<T> &Y) {
387 template <typename T> bool operator<(const T &X, const Optional<T> &Y) {
395 template <typename T> bool operator<=(const T &X, const Optional<T> &Y) {
395 template <typename T> bool operator<=(const T &X, const Optional<T> &Y) {
403 template <typename T> bool operator>(const T &X, const Optional<T> &Y) {
403 template <typename T> bool operator>(const T &X, const Optional<T> &Y) {
411 template <typename T> bool operator>=(const T &X, const Optional<T> &Y) {
411 template <typename T> bool operator>=(const T &X, const Optional<T> &Y) {
include/llvm/Analysis/Loads.h 49 bool isDereferenceableAndAlignedPointer(const Value *V, Align Alignment,
include/llvm/Analysis/TargetTransformInfo.h 583 bool isLegalNTStore(Type *DataType, Align Alignment) const;
585 bool isLegalNTLoad(Type *DataType, Align Alignment) const;
1215 virtual bool isLegalNTStore(Type *DataType, Align Alignment) = 0;
1216 virtual bool isLegalNTLoad(Type *DataType, Align Alignment) = 0;
1506 bool isLegalNTStore(Type *DataType, Align Alignment) override {
1509 bool isLegalNTLoad(Type *DataType, Align Alignment) override {
include/llvm/Analysis/TargetTransformInfoImpl.h 250 bool isLegalNTStore(Type *DataType, Align Alignment) {
257 bool isLegalNTLoad(Type *DataType, Align Alignment) {
include/llvm/Analysis/VectorUtils.h 63 Align Alignment = Align(); // Optional aligment in bytes, defaulted to 1.
384 InterleaveGroup(uint32_t Factor, bool Reverse, Align Alignment)
388 InterleaveGroup(InstTy *Instr, int32_t Stride, Align Alignment)
407 bool insertMember(InstTy *Instr, int32_t Index, Align NewAlign) {
498 Align Alignment;
615 Align Alignment)
628 Align Alignment;
639 createInterleaveGroup(Instruction *Instr, int Stride, Align Alignment) {
include/llvm/CodeGen/AsmPrinter.h 354 void EmitAlignment(Align Alignment, const GlobalObject *GV = nullptr) const;
647 static Align getGVAlignment(const GlobalValue *GV, const DataLayout &DL,
648 Align InAlign = Align::None());
648 Align InAlign = Align::None());
include/llvm/CodeGen/CallingConvLower.h 202 Align MaxStackArgAlign;
427 const Align CheckedAlignment(Alignment);
436 void ensureMaxAlignment(Align Alignment) {
include/llvm/CodeGen/GlobalISel/GISelKnownBits.h 66 static Align inferAlignmentForFrameIdx(int FrameIdx, int Offset,
include/llvm/CodeGen/MachineBasicBlock.h 108 Align Alignment;
376 Align getAlignment() const { return Alignment; }
379 void setAlignment(Align A) { Alignment = A; }
include/llvm/CodeGen/MachineFrameInfo.h 133 Align Alignment;
184 StackObject(uint64_t Size, Align Alignment, int64_t SPOffset,
193 Align StackAlignment;
263 Align MaxAlignment;
307 Align LocalFrameMaxAlign;
422 void setLocalFrameMaxAlign(Align Alignment) {
427 Align getLocalFrameMaxAlign() const { return LocalFrameMaxAlign; }
569 void ensureMaxAlignment(Align Alignment);
737 int CreateStackObject(uint64_t Size, Align Alignment, bool isSpillSlot,
750 int CreateSpillStackObject(uint64_t Size, Align Alignment);
765 int CreateVariableSizedObject(Align Alignment, const AllocaInst *Alloca);
include/llvm/CodeGen/MachineFunction.h 281 Align Alignment;
524 Align getAlignment() const { return Alignment; }
527 void setAlignment(Align A) { Alignment = A; }
530 void ensureAlignment(Align A) {
include/llvm/CodeGen/TargetCallingConv.h 132 void setByValAlign(Align A) {
141 void setOrigAlign(Align A) {
include/llvm/CodeGen/TargetFrameLowering.h 57 Align StackAlignment;
58 Align TransientStackAlignment;
62 TargetFrameLowering(StackDirection D, Align StackAl, int LAO,
63 Align TransAl = Align::None(), bool StackReal = true)
63 Align TransAl = Align::None(), bool StackReal = true)
include/llvm/CodeGen/TargetLowering.h 843 MaybeAlign align = Align::None(); // alignment
1361 virtual Align getABIAlignmentForCallingConv(Type *ArgTy,
1605 Align getMinStackArgumentAlignment() const {
1610 Align getMinFunctionAlignment() const { return MinFunctionAlignment; }
1613 Align getPrefFunctionAlignment() const { return PrefFunctionAlignment; }
1616 virtual Align getPrefLoopAlignment(MachineLoop *ML = nullptr) const {
2129 void setMinFunctionAlignment(Align Alignment) {
2135 void setPrefFunctionAlignment(Align Alignment) {
2142 void setPrefLoopAlignment(Align Alignment) { PrefLoopAlignment = Alignment; }
2145 void setMinStackArgumentAlignment(Align Alignment) {
2714 Align MinStackArgumentAlignment;
2718 Align MinFunctionAlignment;
2722 Align PrefFunctionAlignment;
2725 Align PrefLoopAlignment;
include/llvm/IR/Attributes.h 98 static Attribute getWithAlignment(LLVMContext &Context, Align Alignment);
99 static Attribute getWithStackAlignment(LLVMContext &Context, Align Alignment);
include/llvm/IR/DataLayout.h 75 Align ABIAlign;
76 Align PrefAlign;
78 static LayoutAlignElem get(AlignTypeEnum align_type, Align abi_align,
79 Align pref_align, uint32_t bit_width);
91 Align ABIAlign;
92 Align PrefAlign;
98 static PointerAlignElem get(uint32_t AddressSpace, Align ABIAlign,
99 Align PrefAlign, uint32_t TypeByteWidth,
176 void setAlignment(AlignTypeEnum align_type, Align abi_align, Align pref_align,
176 void setAlignment(AlignTypeEnum align_type, Align abi_align, Align pref_align,
178 Align getAlignmentInfo(AlignTypeEnum align_type, uint32_t bit_width,
180 void setPointerAlignment(uint32_t AddrSpace, Align ABIAlign, Align PrefAlign,
180 void setPointerAlignment(uint32_t AddrSpace, Align ABIAlign, Align PrefAlign,
184 Align getAlignment(Type *Ty, bool abi_or_pref) const;
264 bool exceedsNaturalStackAlignment(Align Alignment) const {
268 Align getStackAlignment() const {
351 Align getPointerABIAlignment(unsigned AS) const;
356 Align getPointerPrefAlignment(unsigned AS = 0) const;
508 inline Align getValueOrABITypeAlignment(MaybeAlign Alignment,
515 Align getABIIntegerTypeAlignment(unsigned BitWidth) const;
587 Align StructAlignment;
597 Align getAlignment() const { return StructAlignment; }
include/llvm/MC/MCSection.h 62 Align Alignment;
122 void setAlignment(Align Value) { Alignment = Value; }
include/llvm/Support/Alignment.h 46 friend unsigned Log2(Align);
47 friend bool operator==(Align Lhs, Align Rhs);
47 friend bool operator==(Align Lhs, Align Rhs);
48 friend bool operator!=(Align Lhs, Align Rhs);
48 friend bool operator!=(Align Lhs, Align Rhs);
49 friend bool operator<=(Align Lhs, Align Rhs);
49 friend bool operator<=(Align Lhs, Align Rhs);
50 friend bool operator>=(Align Lhs, Align Rhs);
50 friend bool operator>=(Align Lhs, Align Rhs);
51 friend bool operator<(Align Lhs, Align Rhs);
51 friend bool operator<(Align Lhs, Align Rhs);
52 friend bool operator>(Align Lhs, Align Rhs);
52 friend bool operator>(Align Lhs, Align Rhs);
72 constexpr Align(const Align &Other) = default;
73 constexpr Align(Align &&Other) = default;
74 Align &operator=(const Align &Other) = default;
74 Align &operator=(const Align &Other) = default;
75 Align &operator=(Align &&Other) = default;
75 Align &operator=(Align &&Other) = default;
93 constexpr static const Align None() { return Align(); }
111 inline Align assumeAligned(uint64_t Value) {
117 struct MaybeAlign : public llvm::Optional<Align> {
119 using UP = llvm::Optional<Align>;
132 using UP::UP;
142 Align valueOrOne() const { return hasValue() ? getValue() : Align(); }
146 inline bool isAligned(Align Lhs, uint64_t SizeInBytes) {
158 inline bool isAddrAligned(Align Lhs, const void *Addr) {
163 inline uint64_t alignTo(uint64_t Size, Align A) {
184 inline uintptr_t alignAddr(const void *Addr, Align Alignment) {
193 inline uint64_t offsetToAlignment(uint64_t Value, Align Alignment) {
199 inline uint64_t offsetToAlignedAddr(const void *Addr, Align Alignment) {
204 inline unsigned Log2(Align A) { return A.ShiftValue; }
215 inline Align commonAlignment(Align A, Align B) { return std::min(A, B); }
215 inline Align commonAlignment(Align A, Align B) { return std::min(A, B); }
215 inline Align commonAlignment(Align A, Align B) { return std::min(A, B); }
219 inline Align commonAlignment(Align A, uint64_t Offset) {
219 inline Align commonAlignment(Align A, uint64_t Offset) {
242 Align Out;
249 inline unsigned encode(Align A) { return encode(MaybeAlign(A)); }
252 inline bool operator==(Align Lhs, uint64_t Rhs) {
256 inline bool operator!=(Align Lhs, uint64_t Rhs) {
260 inline bool operator<=(Align Lhs, uint64_t Rhs) {
264 inline bool operator>=(Align Lhs, uint64_t Rhs) {
268 inline bool operator<(Align Lhs, uint64_t Rhs) {
272 inline bool operator>(Align Lhs, uint64_t Rhs) {
306 inline bool operator==(Align Lhs, Align Rhs) {
306 inline bool operator==(Align Lhs, Align Rhs) {
309 inline bool operator!=(Align Lhs, Align Rhs) {
309 inline bool operator!=(Align Lhs, Align Rhs) {
312 inline bool operator<=(Align Lhs, Align Rhs) {
312 inline bool operator<=(Align Lhs, Align Rhs) {
315 inline bool operator>=(Align Lhs, Align Rhs) {
315 inline bool operator>=(Align Lhs, Align Rhs) {
318 inline bool operator<(Align Lhs, Align Rhs) {
318 inline bool operator<(Align Lhs, Align Rhs) {
321 inline bool operator>(Align Lhs, Align Rhs) {
321 inline bool operator>(Align Lhs, Align Rhs) {
326 inline bool operator==(Align Lhs, MaybeAlign Rhs) {
330 inline bool operator!=(Align Lhs, MaybeAlign Rhs) {
334 inline bool operator<=(Align Lhs, MaybeAlign Rhs) {
338 inline bool operator>=(Align Lhs, MaybeAlign Rhs) {
342 inline bool operator<(Align Lhs, MaybeAlign Rhs) {
346 inline bool operator>(Align Lhs, MaybeAlign Rhs) {
352 inline bool operator==(MaybeAlign Lhs, Align Rhs) {
356 inline bool operator!=(MaybeAlign Lhs, Align Rhs) {
360 inline bool operator<=(MaybeAlign Lhs, Align Rhs) {
364 inline bool operator>=(MaybeAlign Lhs, Align Rhs) {
368 inline bool operator<(MaybeAlign Lhs, Align Rhs) {
372 inline bool operator>(MaybeAlign Lhs, Align Rhs) {
377 inline Align operator/(Align Lhs, uint64_t Divisor) {
377 inline Align operator/(Align Lhs, uint64_t Divisor) {
390 inline Align max(MaybeAlign Lhs, Align Rhs) {
390 inline Align max(MaybeAlign Lhs, Align Rhs) {
394 inline Align max(Align Lhs, MaybeAlign Rhs) {
394 inline Align max(Align Lhs, MaybeAlign Rhs) {
include/llvm/Support/Allocator.h 215 Allocate(size_t Size, Align Alignment) {
478 char *Begin = (char *)alignAddr(*I, Align::Of<T>());
488 DestroyElements((char *)alignAddr(Ptr, Align::Of<T>()),
include/llvm/Support/TrailingObjects.h 171 alignAddr(Ptr, Align::Of<NextTy>()));
185 return reinterpret_cast<NextTy *>(alignAddr(Ptr, Align::Of<NextTy>()));
include/llvm/Support/type_traits.h 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;
181 static_assert(value == std::is_trivially_copyable<T>::value,
lib/Analysis/Loads.cpp 39 static bool isAligned(const Value *Base, const APInt &Offset, Align Alignment,
53 const Value *V, Align Alignment, const APInt &Size, const DataLayout &DL,
123 bool llvm::isDereferenceableAndAlignedPointer(const Value *V, Align Alignment,
152 const Align Alignment = DL.getValueOrABITypeAlignment(MA, Ty);
163 return isDereferenceableAndAlignedPointer(V, Ty, Align::None(), DL, CtxI, DT);
205 const Align Alignment = DL.getValueOrABITypeAlignment(
267 const Align Alignment =
324 const Align AccessedAlign =
lib/Analysis/TargetTransformInfo.cpp 302 Align Alignment) const {
306 bool TargetTransformInfo::isLegalNTLoad(Type *DataType, Align Alignment) const {
lib/Analysis/VFABIDemangling.cpp 267 ParseRet tryParseAlign(StringRef &ParseString, Align &Alignment) {
329 Align Alignment;
lib/CodeGen/AsmPrinter/AsmPrinter.cpp 161 Align AsmPrinter::getGVAlignment(const GlobalValue *GV, const DataLayout &DL,
162 Align InAlign) {
163 Align Alignment;
505 const Align Alignment = getGVAlignment(GV, DL);
2024 const Align Align = DL.getPointerPrefAlignment();
2148 void AsmPrinter::EmitAlignment(Align Alignment, const GlobalObject *GV) const {
2152 if (Alignment == Align::None())
2930 const Align Alignment = MBB.getAlignment();
2931 if (Alignment != Align::None())
lib/CodeGen/BranchRelaxation.cpp 68 const Align Alignment = MBB.getAlignment();
72 const Align ParentAlign = MBB.getParent()->getAlignment();
lib/CodeGen/CallingConvLower.cpp 46 Align MinAlign(MinAlignment);
47 Align Alignment(ArgFlags.getByValAlign());
202 Align SavedMaxStackArgAlign = MaxStackArgAlign;
lib/CodeGen/GlobalISel/CallLowering.cpp 238 Flags.setOrigAlign(Align::None());
271 Flags.setOrigAlign(Align::None());
lib/CodeGen/GlobalISel/GISelKnownBits.cpp 36 Align GISelKnownBits::inferAlignmentForFrameIdx(int FrameIdx, int Offset,
lib/CodeGen/GlobalMerge.cpp 459 Align MaxAlign;
465 Align Alignment(DL.getPreferredAlignment(Globals[j]));
lib/CodeGen/LowerEmuTLS.cpp 158 Align MaxAlignment(std::max(DL.getABITypeAlignment(WordType),
lib/CodeGen/MIRPrinter.cpp 632 if (MBB.getAlignment() != Align::None()) {
lib/CodeGen/MachineBasicBlock.cpp 329 if (getAlignment() != Align::None()) {
lib/CodeGen/MachineBlockPlacement.cpp 2767 const Align Align = TLI->getPrefLoopAlignment(L);
lib/CodeGen/MachineFrameInfo.cpp 31 void MachineFrameInfo::ensureMaxAlignment(Align Alignment) {
40 static inline Align clampStackAlignment(bool ShouldClamp, Align Alignment,
40 static inline Align clampStackAlignment(bool ShouldClamp, Align Alignment,
41 Align StackAlignment) {
50 int MachineFrameInfo::CreateStackObject(uint64_t Size, Align Alignment,
65 int MachineFrameInfo::CreateSpillStackObject(uint64_t Size, Align Alignment) {
73 int MachineFrameInfo::CreateVariableSizedObject(Align Alignment,
91 Align Alignment =
92 commonAlignment(ForcedRealign ? Align::None() : StackAlignment, SPOffset);
104 Align Alignment =
105 commonAlignment(ForcedRealign ? Align::None() : StackAlignment, SPOffset);
lib/CodeGen/MachineOperand.cpp 982 BasePtr, Align::None(), APInt(DL.getPointerSizeInBits(), Offset + Size),
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp 9131 const Align OriginalAlignment(getABIAlignmentForCallingConv(ArgTy, DL));
9244 MyFlags.Flags.setOrigAlign(Align::None());
9631 const Align OriginalAlignment(
9715 MyFlags.Flags.setOrigAlign(Align::None());
lib/CodeGen/SjLjEHPrepare.cpp 178 const Align Alignment(DL.getPrefTypeAlignment(FunctionContextTy));
lib/ExecutionEngine/Orc/Speculation.cpp 99 SpeculatorGuard->setAlignment(Align::None());
lib/IR/Attributes.cpp 145 Attribute Attribute::getWithAlignment(LLVMContext &Context, Align A) {
150 Attribute Attribute::getWithStackAlignment(LLVMContext &Context, Align A) {
lib/IR/DataLayout.cpp 55 const Align TyAlign(ST->isPacked() ? 1 : DL.getABITypeAlignment(Ty));
102 LayoutAlignElem LayoutAlignElem::get(AlignTypeEnum align_type, Align abi_align,
103 Align pref_align, uint32_t bit_width) {
125 PointerAlignElem PointerAlignElem::get(uint32_t AddressSpace, Align ABIAlign,
126 Align PrefAlign, uint32_t TypeByteWidth,
485 void DataLayout::setAlignment(AlignTypeEnum align_type, Align abi_align,
486 Align pref_align, uint32_t bit_width) {
519 void DataLayout::setPointerAlignment(uint32_t AddrSpace, Align ABIAlign,
520 Align PrefAlign, uint32_t TypeByteWidth,
540 Align DataLayout::getAlignmentInfo(AlignTypeEnum AlignType, uint32_t BitWidth,
636 Align DataLayout::getPointerABIAlignment(unsigned AS) const {
645 Align DataLayout::getPointerPrefAlignment(unsigned AS) const {
702 Align DataLayout::getAlignment(Type *Ty, bool abi_or_pref) const {
721 return Align::None();
725 const Align Align = getAlignmentInfo(AGGREGATE_ALIGN, 0, abi_or_pref, Ty);
761 Align DataLayout::getABIIntegerTypeAlignment(unsigned BitWidth) const {
lib/IR/IRBuilder.cpp 52 GV->setAlignment(Align::None());
lib/Object/ArchiveWriter.cpp 311 const Align Alignment(isBSDLike(Kind) ? 8 : 2);
lib/Support/Unix/Memory.inc 179 static const Align PageSize = Align(Process::getPageSizeEstimate());
lib/Target/AArch64/AArch64CallingConvention.cpp 43 const Align StackAlign =
45 const Align OrigAlign(ArgFlags.getOrigAlign());
46 const Align Align = std::min(OrigAlign, StackAlign);
lib/Target/AArch64/AArch64StackTagging.cpp 66 static const Align kTagGranuleSize = Align(16);
462 const Align NewAlignment =
lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp 1264 Align MaxKernArgAlign;
lib/Target/AMDGPU/AMDGPUFrameLowering.cpp 16 AMDGPUFrameLowering::AMDGPUFrameLowering(StackDirection D, Align StackAl,
17 int LAO, Align TransAl)
lib/Target/AMDGPU/AMDGPUFrameLowering.h 28 AMDGPUFrameLowering(StackDirection D, Align StackAl, int LAO,
29 Align TransAl = Align::None());
29 Align TransAl = Align::None());
lib/Target/AMDGPU/AMDGPUHSAMetadataStreamer.cpp 221 Align MaxKernArgAlign;
887 Align MaxKernArgAlign;
lib/Target/AMDGPU/AMDGPUISelLowering.cpp 4179 const Align Alignment = ST.getAlignmentForImplicitArgPtr();
lib/Target/AMDGPU/AMDGPULowerKernelArguments.cpp 75 const Align KernArgBaseAlign(16); // FIXME: Increase if necessary
78 Align MaxAlign;
131 Align AdjustedAlign = commonAlignment(
lib/Target/AMDGPU/AMDGPUMachineFunction.h 26 Align MaxKernArgAlign; // Cache for this.
lib/Target/AMDGPU/AMDGPUSubtarget.cpp 495 Align &MaxAlign) const {
501 MaxAlign = Align::None();
506 const Align Alignment(DL.getABITypeAlignment(ArgTy));
516 Align &MaxAlign) const {
524 const Align Alignment = getAlignmentForImplicitArgPtr();
lib/Target/AMDGPU/AMDGPUSubtarget.h 199 Align getAlignmentForImplicitArgPtr() const {
241 uint64_t getExplicitKernArgSize(const Function &F, Align &MaxAlign) const;
242 unsigned getKernArgSegmentSize(const Function &F, Align &MaxAlign) const;
869 Align getStackAlignment() const { return Align(16); }
1258 Align getStackAlignment() const { return Align(4); }
lib/Target/AMDGPU/R600FrameLowering.h 18 R600FrameLowering(StackDirection D, Align StackAl, int LAO,
19 Align TransAl = Align::None())
19 Align TransAl = Align::None())
lib/Target/AMDGPU/SIFrameLowering.h 23 SIFrameLowering(StackDirection D, Align StackAl, int LAO,
24 Align TransAl = Align::None())
24 Align TransAl = Align::None())
lib/Target/AMDGPU/SIISelLowering.cpp10741 Align SITargetLowering::getPrefLoopAlignment(MachineLoop *ML) const {
10742 const Align PrefAlign = TargetLowering::getPrefLoopAlignment(ML);
10743 const Align CacheLineAlign = Align(64);
lib/Target/AMDGPU/SIISelLowering.h 403 Align getPrefLoopAlignment(MachineLoop *ML) const override;
lib/Target/ARM/ARMBasicBlockInfo.cpp 52 BBI.PostAlign = Align::None();
131 const Align Align = MF.getBlockNumbered(i)->getAlignment();
lib/Target/ARM/ARMBasicBlockInfo.h 33 inline unsigned UnknownPadding(Align Alignment, unsigned KnownBits) {
71 Align PostAlign;
90 unsigned postOffset(Align Alignment = Align::None()) const {
90 unsigned postOffset(Align Alignment = Align::None()) const {
92 const Align PA = std::max(PostAlign, Alignment);
93 if (PA == Align::None())
104 unsigned postKnownBits(Align Align = Align::None()) const {
104 unsigned postKnownBits(Align Align = Align::None()) const {
lib/Target/ARM/ARMConstantIslandPass.cpp 250 Align getCPEAlign(const MachineInstr *CPEMI);
497 const Align MaxAlign(MCP->getConstantPoolAlignment());
653 Align ARMConstantIslands::getCPEAlign(const MachineInstr *CPEMI) {
1024 const Align CPEAlign = getCPEAlign(U.CPEMI);
1027 Align NextBlockAlignment;
1217 const Align CPEAlign = getCPEAlign(U.CPEMI);
1271 const Align CPEAlign = getCPEAlign(CPEMI);
1326 const Align Align = MF->getAlignment();
1504 const Align Alignment = isThumb ? Align(2) : Align(4);
1569 CPEBB->setAlignment(Align::None());
lib/Target/ARM/ARMISelLowering.cpp17046 Align ARMTargetLowering::getABIAlignmentForCallingConv(Type *ArgTy,
17048 const Align ABITypeAlign(DL.getABITypeAlignment(ArgTy));
lib/Target/ARM/ARMISelLowering.h 620 Align getABIAlignmentForCallingConv(Type *ArgTy,
lib/Target/ARM/ARMSubtarget.h 452 Align stackAlignment = Align(4);
825 Align getStackAlignment() const { return stackAlignment; }
lib/Target/AVR/AVRFrameLowering.cpp 33 : TargetFrameLowering(TargetFrameLowering::StackGrowsDown, Align::None(),
lib/Target/Hexagon/HexagonBranchRelaxation.cpp 108 if (B.getAlignment() != Align::None()) {
lib/Target/Hexagon/HexagonFixupHwLoops.cpp 117 if (MBB.getAlignment() != Align::None()) {
lib/Target/Hexagon/HexagonFrameLowering.cpp 1380 Align A = MFI.getLocalFrameMaxAlign();
lib/Target/Hexagon/HexagonFrameLowering.h 33 : TargetFrameLowering(StackGrowsDown, Align(8), 0, Align::None(), true) {}
lib/Target/Hexagon/HexagonTargetTransformInfo.cpp 172 const Align RegAlign(RegWidth / 8);
187 const Align BoundAlignment = std::min(Alignment.valueOrOne(), Align(8));
lib/Target/Mips/MCTargetDesc/MipsMCNaCl.h 18 static const Align MIPS_NACL_BUNDLE_ALIGN = Align(16);
lib/Target/Mips/MipsCallLowering.cpp 693 Flags.setOrigAlign(Align::None());
lib/Target/Mips/MipsConstantIslandPass.cpp 374 Align getCPEAlign(const MachineInstr &CPEMI);
532 const Align MaxAlign(MCP->getConstantPoolAlignment());
622 Align MipsConstantIslands::getCPEAlign(const MachineInstr &CPEMI) {
939 Align NextBlockAlignment;
943 NextBlockAlignment = Align::None();
1254 const Align Align = MF->getAlignment();
lib/Target/Mips/MipsFrameLowering.h 27 explicit MipsFrameLowering(const MipsSubtarget &sti, Align Alignment)
lib/Target/Mips/MipsISelLowering.cpp 2150 const Align Align =
lib/Target/Mips/MipsISelLowering.h 307 Align getABIAlignmentForCallingConv(Type *ArgTy,
309 const Align ABIAlign(DL.getABITypeAlignment(ArgTy));
lib/Target/Mips/MipsSEISelDAGToDAG.cpp 295 const Align Alignment(1ULL << ShiftAmount);
lib/Target/Mips/MipsSERegisterInfo.cpp 215 const Align OffsetAlign(getLoadStoreOffsetAlign(MI.getOpcode()));
lib/Target/Mips/MipsSubtarget.h 197 Align stackAlignment;
352 Align getStackAlignment() const { return stackAlignment; }
lib/Target/NVPTX/NVPTXAsmPrinter.cpp 1476 const Align align = DL.getValueOrABITypeAlignment(
1561 Align align =
lib/Target/PowerPC/PPCBranchSelector.cpp 84 const Align Alignment = MBB.getAlignment();
85 if (Alignment == Align::None())
88 const Align ParentAlign = MBB.getParent()->getAlignment();
181 Align MaxAlign = Align(4);
lib/Target/PowerPC/PPCISelLowering.cpp14167 Align PPCTargetLowering::getPrefLoopAlignment(MachineLoop *ML) const {
14678 Info.align = Align::None();
14712 Info.align = Align::None();
14764 Info.align = Align::None();
14797 Info.align = Align::None();
lib/Target/PowerPC/PPCISelLowering.h 748 Align getPrefLoopAlignment(MachineLoop *ML) const override;
lib/Target/PowerPC/PPCSubtarget.h 81 Align StackAlignment;
169 Align getStackAlignment() const { return StackAlignment; }
284 Align getPlatformStackAlignment() const {
lib/Target/RISCV/RISCVISelLowering.cpp 209 const Align FunctionAlignment(Subtarget.hasStdExtC() ? 2 : 4);
lib/Target/SystemZ/SystemZLongBranch.cpp 90 Align Alignment;
lib/Target/X86/X86ISelLowering.cpp 4811 Info.align = Align::None();
4824 Info.align = Align::None();
4836 Info.align = Align::None();
lib/Target/X86/X86Subtarget.h 435 Align stackAlignment = Align(4);
527 Align getStackAlignment() const { return stackAlignment; }
lib/Target/X86/X86TargetTransformInfo.cpp 3289 bool X86TTIImpl::isLegalNTLoad(Type *DataType, Align Alignment) {
3300 bool X86TTIImpl::isLegalNTStore(Type *DataType, Align Alignment) {
lib/Target/X86/X86TargetTransformInfo.h 191 bool isLegalNTLoad(Type *DataType, Align Alignment);
192 bool isLegalNTStore(Type *DataType, Align Alignment);
lib/Target/XCore/XCoreAsmPrinter.cpp 118 const Align Alignment(DL.getPrefTypeAlignment(C->getType()));
lib/Transforms/IPO/GlobalOpt.cpp 500 Align NewAlign(MinAlign(StartAlignment, FieldOffset));
516 Align EltAlign(DL.getABITypeAlignment(ElTy));
535 Align NewAlign(MinAlign(StartAlignment, EltSize * i));
lib/Transforms/IPO/LowerTypeTests.cpp 825 Align MaxAlign;
lib/Transforms/InstCombine/InstCombineCalls.cpp 251 const Align Alignment = assumeAligned(MI->getDestAlignment());
2346 return new LoadInst(II->getType(), Ptr, Twine(""), false, Align::None());
2364 return new StoreInst(II->getArgOperand(0), Ptr, false, Align::None());
lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp 1359 const Align KnownAlign = Align(getOrEnforceKnownAlignment(
1362 const Align EffectiveStoreAlign =
lib/Transforms/Instrumentation/AddressSanitizer.cpp 2362 ODRIndicatorSym->setAlignment(Align::None());
lib/Transforms/Instrumentation/InstrProfiling.cpp 934 NamesVar->setAlignment(Align::None());
lib/Transforms/Instrumentation/Instrumentation.cpp 71 GV->setAlignment(Align::None()); // Strings may not be merged w/o setting
lib/Transforms/Scalar/SROA.cpp 4158 const Align Alignment = commonAlignment(
lib/Transforms/Utils/InlineFunction.cpp 1296 Align Alignment(DL.getPrefTypeAlignment(AggTy));
lib/Transforms/Utils/SimplifyLibCalls.cpp 180 if (!isDereferenceableAndAlignedPointer(Str, Align::None(), APInt(64, Len),
lib/Transforms/Vectorize/LoopVectorize.cpp 2366 const Align Alignment =
tools/clang/include/clang/AST/CharUnits.h 183 llvm::Align getAsAlign() const { return llvm::Align(Quantity); }
tools/clang/lib/CodeGen/CGBuiltin.cpp11356 SI->setAlignment(llvm::Align::None());
tools/clang/lib/CodeGen/CGObjCMac.cpp 2021 GV->setAlignment(llvm::Align::None());
tools/llvm-exegesis/lib/Assembler.cpp 33 static const Align kFunctionAlignment(4096);
tools/polly/lib/CodeGen/LoopGeneratorsKMP.cpp 471 StrVar->setAlignment(llvm::Align::None());
unittests/Support/AlignmentTest.cpp 42 constexpr Align kConstantAlign = Align::Of<uint64_t>();
42 constexpr Align kConstantAlign = Align::Of<uint64_t>();
168 Align Actual(Value);
169 Align Expected = decodeMaybeAlign(encode(Actual)).getValue();
225 const Align A(T.alignment);
236 const Align A(ValidAlignments[I - 1]);
237 const Align B(ValidAlignments[I]);
unittests/Support/AllocatorTest.cpp 148 Align Alignment(4096);
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/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
136 inline _GLIBCXX17_CONSTEXPR _Tp*
137 addressof(_Tp& __r) noexcept
143 const _Tp* addressof(const _Tp&&) = delete;
143 const _Tp* addressof(const _Tp&&) = delete;
usr/include/c++/7.4.0/tuple 125 constexpr _Head_base(const _Head& __h)
132 constexpr _Head_base(_UHead&& __h)
159 static constexpr _Head&
162 static constexpr const _Head&
210 constexpr _Tuple_impl(const _Head& __head, const _Tail&... __tail)
216 constexpr _Tuple_impl(_UHead&& __head, _UTail&&... __tail)
242 _Tuple_impl(allocator_arg_t __tag, const _Alloc& __a)
248 const _Head& __head, const _Tail&... __tail)
350 static constexpr _Head&
353 static constexpr const _Head&
360 constexpr _Tuple_impl(const _Head& __head)
365 constexpr _Tuple_impl(_UHead&& __head)
390 const _Head& __head)
473 return __and_<is_constructible<_Elements, const _UElements&>...>::value;
479 return __and_<is_convertible<const _UElements&, _Elements>...>::value;
485 return __and_<is_constructible<_Elements, _UElements&&>...>::value;
491 return __and_<is_convertible<_UElements&&, _Elements>...>::value;
608 constexpr tuple(const _Elements&... __elements)
619 explicit constexpr tuple(const _Elements&... __elements)
646 constexpr tuple(_UElements&&... __elements)
730 const _Elements&... __elements)
741 const _Elements&... __elements)
1302 constexpr _Head&
1307 constexpr const _Head&
1313 constexpr __tuple_element_t<__i, tuple<_Elements...>>&
1319 constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
1325 constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
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
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
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>
1246 : public is_nothrow_constructible<_Tp, _Tp&&>
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; };
1659 { typedef _Tp&& type; };
1955 { typedef _Tp type; };
utils/unittest/googletest/include/gtest/gtest-printers.h 140 static void PrintValue(const T& value, ::std::ostream* os) {
205 ::std::basic_ostream<Char, CharTraits>& os, const T& x) {
206 TypeWithoutFormatter<T,
207 (internal::IsAProtocolMessage<T>::value ? kProtobuf :
208 internal::ImplicitlyConvertible<const T&, internal::BiggestInt>::value ?
223 void DefaultPrintNonContainerTo(const T& value, ::std::ostream* os) {
276 static ::std::string Format(const ToPrint& value) {
351 const T1& value, const T2& /* other_operand */) {
351 const T1& value, const T2& /* other_operand */) {
352 return FormatForComparison<T1, T2>::Format(value);
352 return FormatForComparison<T1, T2>::Format(value);
366 void UniversalPrint(const T& value, ::std::ostream* os);
373 const C& container, ::std::ostream* os) {
439 const T& value, ::std::ostream* os) {
455 void PrintTo(const T& value, ::std::ostream* os) {
478 DefaultPrintTo(IsContainerTest<T>(0), is_pointer<T>(), value, os);
699 static void Print(const T& value, ::std::ostream* os) {
784 static void Print(const T& value, ::std::ostream* os) {
856 typedef T T1;
983 internal::UniversalTersePrinter<T>::Print(value, &ss);
utils/unittest/googletest/include/gtest/gtest.h 1377 const T1& lhs, const T2& rhs) {
1377 const T1& lhs, const T2& rhs) {
1389 const T1& lhs,
1390 const T2& rhs) {
1419 const T1& lhs,
1420 const T2& rhs) {
1487 const T1& val1, const T2& val2,
1487 const T1& val1, const T2& val2,
utils/unittest/googletest/include/gtest/internal/custom/raw-ostream.h 29 static const T& printable(const T& V) { return V; }
29 static const T& printable(const T& V) { return V; }
35 auto printable(const T &V) -> decltype(StreamSwitch<T>::printable(V)) {
35 auto printable(const T &V) -> decltype(StreamSwitch<T>::printable(V)) {
37 return StreamSwitch<T>::printable(V);
utils/unittest/googletest/include/gtest/internal/gtest-internal.h 94 ::std::string PrintToString(const T& value);