| /src/external/apache2/llvm/dist/llvm/include/llvm/Support/ |
| AllocatorBase.h | 12 /// and alignment, and a Deallocate accepting a pointer and size. Further, the
14 /// setting size and alignment based on the final type. These overloads are
35 /// Allocate \a Size bytes of \a Alignment aligned memory. This method
37 void *Allocate(size_t Size, size_t Alignment) {
46 return static_cast<DerivedT *>(this)->Allocate(Size, Alignment);
51 void Deallocate(const void *Ptr, size_t Size, size_t Alignment) {
61 return static_cast<DerivedT *>(this)->Deallocate(Ptr, Size, Alignment);
84 LLVM_ATTRIBUTE_RETURNS_NONNULL void *Allocate(size_t Size, size_t Alignment) {
85 return allocate_buffer(Size, Alignment);
91 void Deallocate(const void *Ptr, size_t Size, size_t Alignment) {
[all...] |
| OptimizedStructLayout.h | 38 #include "llvm/Support/Alignment.h"
50 OptimizedStructLayoutField(const void *Id, uint64_t Size, Align Alignment,
52 : Offset(FixedOffset), Size(Size), Id(Id), Alignment(Alignment) {
62 /// a multiple of Alignment. Must be non-zero.
72 /// The required alignment of this field.
73 Align Alignment;
93 /// than the well-known "sort by decreasing alignment" solution:
103 /// greater than, the field's required alignment. The only constraint
113 /// - every field's size is a multiple of its required alignment an
[all...] |
| TrailingObjects.h | 19 /// are all allocated at their required alignment. Additionally, it
50 #include "llvm/Support/Alignment.h"
60 /// Helper template to calculate the max alignment requirement for a set of
66 RestAlignment = AlignmentCalcHelper<Rest...>::Alignment,
71 Alignment = FirstAlignment > RestAlignment ? FirstAlignment : RestAlignment
77 enum { Alignment = alignof(First) };
214 TrailingTys...>::Alignment,
224 trailing_objects_internal::AlignmentCalcHelper<TrailingTys...>::Alignment,
|
| /src/external/apache2/llvm/dist/llvm/lib/Target/XCore/ |
| XCoreMachineFunctionInfo.cpp | 73 Align Alignment = TRI.getSpillAlign(RC);
74 EHSpillSlot[0] = MFI.CreateStackObject(Size, Alignment, true);
75 EHSpillSlot[1] = MFI.CreateStackObject(Size, Alignment, true);
|
| /src/external/apache2/llvm/dist/clang/lib/Frontend/ |
| LayoutOverrideSource.cpp | 88 // Check for the alignment of the type.
89 Pos = LineStr.find("Alignment:");
91 // Skip past the "Alignment:" prefix.
92 LineStr = LineStr.substr(Pos + strlen("Alignment:"));
94 unsigned long long Alignment = 0;
95 (void)LineStr.getAsInteger(10, Alignment);
96 CurrentLayout.Align = Alignment;
100 // Check for the size/alignment of the type.
116 // Parse alignment.
117 unsigned long long Alignment = 0
[all...] |
| /src/external/apache2/llvm/dist/llvm/include/llvm/Transforms/Instrumentation/ |
| AddressSanitizerCommon.h | 28 MaybeAlign Alignment;
33 class Type *OpType, MaybeAlign Alignment,
35 : IsWrite(IsWrite), OpType(OpType), Alignment(Alignment),
|
| /src/external/apache2/llvm/dist/llvm/lib/Target/AMDGPU/ |
| AMDGPUMachineFunction.cpp | 47 Align Alignment =
50 /// TODO: We should sort these to minimize wasted space due to alignment
53 unsigned Offset = StaticLDSSize = alignTo(StaticLDSSize, Alignment);
81 Align Alignment =
83 if (Alignment <= DynLDSAlign)
86 LDSSize = alignTo(StaticLDSSize, Alignment);
87 DynLDSAlign = Alignment;
|
| /src/external/apache2/llvm/dist/llvm/include/llvm/ExecutionEngine/JITLink/ |
| JITLinkMemoryManager.h | 40 SegmentRequest(uint64_t Alignment, size_t ContentSize,
42 : Alignment(Alignment), ContentSize(ContentSize),
44 assert(isPowerOf2_32(Alignment) && "Alignment must be power of 2");
46 uint64_t getAlignment() const { return Alignment; }
50 uint64_t Alignment = 0;
|
| /src/external/apache2/llvm/dist/llvm/include/llvm/Transforms/Utils/ |
| ASanStackFrameLayout.h | 36 size_t Alignment; // Alignment of the variable (power of 2).
46 size_t FrameAlignment; // Alignment for the entire frame.
|
| /src/external/apache2/llvm/dist/clang/lib/CodeGen/ |
| Address.h | 10 // alignment.
26 CharUnits Alignment;
28 Address(llvm::Value *pointer, CharUnits alignment)
29 : Pointer(pointer), Alignment(alignment) {
30 assert((!alignment.isZero() || pointer == nullptr) &&
31 "creating valid address with invalid alignment");
65 /// Return the alignment of this pointer.
68 return Alignment;
76 ConstantAddress(llvm::Constant *pointer, CharUnits alignment)
[all...] |
| /src/external/apache2/llvm/dist/llvm/include/llvm/ADT/ |
| FunctionExtras.h | 119 /// A struct to hold a single trivial callback with sufficient alignment for
147 size_t Alignment;
205 return StorageUnion.OutOfLineStorage.Alignment;
208 void setOutOfLineStorage(void *Ptr, size_t Size, size_t Alignment) {
209 StorageUnion.OutOfLineStorage = {Ptr, Size, Alignment};
263 // Allocate out-of-line storage. FIXME: Use an explicit alignment
266 auto Alignment = alignof(CallableT);
267 CallableAddr = allocate_buffer(Size, Alignment);
268 setOutOfLineStorage(CallableAddr, Size, Alignment);
|
| /src/external/apache2/llvm/dist/llvm/include/llvm/CodeGen/ |
| MachineConstantPool.h | 20 #include "llvm/Support/Alignment.h"
49 Align Alignment) = 0;
75 /// The required alignment for this entry.
76 Align Alignment;
81 : Alignment(A), IsMachineConstantPoolEntry(false) {
86 : Alignment(A), IsMachineConstantPoolEntry(true) {
95 Align getAlign() const { return Alignment; }
118 Align PoolAlignment; ///< The alignment for the pool.
132 /// Return the alignment required by the whole constant pool, of which the
137 /// an existing one. User must specify the minimum required alignment fo
[all...] |
| /src/external/apache2/llvm/dist/llvm/include/llvm/MC/ |
| StringTableBuilder.h | 41 unsigned Alignment;
48 StringTableBuilder(Kind K, unsigned Alignment = 1);
|
| /src/external/apache2/llvm/dist/llvm/lib/CodeGen/ |
| CallingConvLower.cpp | 42 /// The size and alignment information of the argument is encoded in
47 Align Alignment = ArgFlags.getNonZeroByValAlign();
51 if (MinAlign > Alignment)
52 Alignment = MinAlign;
53 ensureMaxAlignment(Alignment);
54 MF.getSubtarget().getTargetLowering()->HandleByVal(this, Size, Alignment);
56 unsigned Offset = AllocateStack(Size, Alignment);
193 void CCState::ensureMaxAlignment(Align Alignment) {
195 MF.getFrameInfo().ensureMaxAlignment(Alignment);
|
| SafeStackLayout.h | 42 unsigned Size, Alignment;
58 void addObject(const Value *V, unsigned Size, unsigned Alignment,
67 /// Returns the alignment of the object
73 /// Returns the alignment of the frame.
|
| MachineFrameInfo.cpp | 31 void MachineFrameInfo::ensureMaxAlignment(Align Alignment) {
33 assert(Alignment <= StackAlignment &&
34 "For targets without stack realignment, Alignment is out of limit!");
35 if (MaxAlignment < Alignment)
36 MaxAlignment = Alignment;
39 /// Clamp the alignment if requested and emit a warning.
40 static inline Align clampStackAlignment(bool ShouldClamp, Align Alignment,
42 if (!ShouldClamp || Alignment <= StackAlignment)
43 return Alignment;
44 LLVM_DEBUG(dbgs() << "Warning: requested alignment " << DebugStr(Alignment
[all...] |
| /src/external/apache2/llvm/dist/llvm/lib/Support/ |
| OptimizedStructLayout.cpp | 27 assert(isAligned(Field.Alignment, Field.Offset) &&
32 assert(Field.Alignment <= MaxAlign &&
34 ComputedMaxAlign = std::max(Field.Alignment, MaxAlign);
71 MaxAlign = std::max(MaxAlign, FirstFlexible->Alignment);
96 MaxAlign = std::max(MaxAlign, I->Alignment);
100 // Sort the flexible elements in order of decreasing alignment,
107 // Decreasing alignment.
108 if (lhs->Alignment != rhs->Alignment)
109 return (lhs->Alignment < rhs->Alignment ? 1 : -1)
[all...] |
| /src/external/apache2/llvm/dist/llvm/lib/Target/AArch64/ |
| AArch64CompressJumpTables.cpp | 23 #include "llvm/Support/Alignment.h"
93 const Align Alignment = MBB.getAlignment();
95 if (Alignment == Align(1))
98 AlignedOffset = alignTo(Offset, Alignment);
|
| /src/external/apache2/llvm/dist/llvm/lib/Target/BPF/ |
| BPFInstrInfo.cpp | 49 uint64_t Alignment = MI->getOperand(3).getImm();
55 switch (Alignment) {
73 llvm_unreachable("unsupported memcpy alignment");
76 unsigned IterationNum = CopyLen >> Log2_64(Alignment);
80 .addImm(I * Alignment);
83 .addImm(I * Alignment);
86 unsigned BytesLeft = CopyLen & (Alignment - 1);
87 unsigned Offset = IterationNum * Alignment;
|
| /src/external/apache2/llvm/dist/llvm/lib/Target/X86/ |
| X86LowerTileCopy.cpp | 93 Align Alignment = TRI->getSpillAlign(X86::TILERegClass);
94 int TileSS = MF.getFrameInfo().CreateSpillStackObject(Size, Alignment);
97 Alignment = TRI->getSpillAlign(X86::GR64RegClass);
98 int StrideSS = MF.getFrameInfo().CreateSpillStackObject(Size, Alignment);
|
| /src/external/apache2/llvm/dist/llvm/lib/Transforms/Utils/ |
| ASanStackFrameLayout.cpp | 22 // We sort the stack variables by alignment (largest first) to minimize
23 // unnecessary large gaps due to alignment.
31 return a.Alignment > b.Alignment;
34 // We also force minimal alignment for all vars to kMinAlignment so that vars
35 // with e.g. alignment 1 and alignment 16 do not get reordered by CompareVars.
40 // The resulting frame size is a multiple of Alignment.
42 size_t Alignment) {
50 return alignTo(std::max(Res, 2 * Granularity), Alignment);
[all...] |
| /src/external/apache2/llvm/dist/llvm/include/llvm/ObjectYAML/ |
| COFFYAML.h | 71 unsigned Alignment = 0;
|
| /src/external/apache2/llvm/dist/llvm/lib/IR/ |
| DataLayout.cpp | 1 //===- DataLayout.cpp - Data size & alignment routines ---------------------==//
9 // This file defines layout properties related to datatype size/offset/alignment
64 // Keep track of maximum alignment constraint.
106 assert(abi_align <= pref_align && "Preferred alignment worse than ABI!");
130 assert(ABIAlign <= PrefAlign && "Preferred alignment worse than ABI!");
324 // ABI alignment.
327 "Missing alignment specification for pointer in datalayout string");
334 return reportError("Pointer ABI alignment must be a power of 2");
340 // Preferred alignment.
349 "Pointer preferred alignment must be a power of 2")
[all...] |
| /src/external/apache2/llvm/dist/llvm/lib/Target/ARM/ |
| ARMCallingConv.cpp | 181 // aggregate. Store the type's required alignment as extra info for later: in
195 Align Alignment = std::min(FirstMemberAlign, StackAlign);
205 unsigned RegAlign = alignTo(Alignment.value(), 4) / 4;
268 // Clamp the alignment between 4 and 8.
270 Alignment = ArgFlags.getNonZeroMemAlign() <= 4 ? Align(4) : Align(8);
276 It.convertToMem(State.AllocateStack(Size, Alignment));
278 Alignment = Align(1);
|
| /src/external/apache2/llvm/dist/llvm/lib/Target/NVPTX/ |
| NVPTXPrologEpilogPass.cpp | 117 Align Alignment = MFI.getObjectAlign(FrameIdx);
119 // If the alignment of this object is greater than that of the stack, then
120 // increase the stack alignment to match.
121 MaxAlign = std::max(MaxAlign, Alignment);
123 // Adjust to alignment boundary.
124 Offset = alignTo(Offset, Alignment);
190 Align Alignment = MFI.getLocalFrameMaxAlign();
192 // Adjust to alignment boundary.
193 Offset = alignTo(Offset, Alignment);
208 MaxAlign = std::max(Alignment, MaxAlign)
[all...] |
