Lines Matching +full:align +full:- +full:end
1 //===- DataLayout.cpp - Data size & alignment routines ---------------------==//
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //===----------------------------------------------------------------------===//
16 //===----------------------------------------------------------------------===//
44 //===----------------------------------------------------------------------===//
46 //===----------------------------------------------------------------------===//
50 assert(!ST->isOpaque() && "Cannot get layout of opaque structs"); in StructLayout()
52 NumElements = ST->getNumElements(); in StructLayout()
56 Type *Ty = ST->getElementType(i); in StructLayout()
57 if (i == 0 && Ty->isScalableTy()) in StructLayout()
60 const Align TyAlign = ST->isPacked() ? Align(1) : DL.getABITypeAlign(Ty); in StructLayout()
62 // Add padding if necessary to align the data element properly. in StructLayout()
82 // Add padding to the end of the struct so that it could be put in an array in StructLayout()
90 /// getElementContainingOffset - Given a valid offset into the structure,
100 std::upper_bound(MemberOffsets.begin(), MemberOffsets.end(), Offset, in getElementContainingOffset()
101 [](TypeSize LHS, TypeSize RHS) -> bool { in getElementContainingOffset()
105 --SI; in getElementContainingOffset()
108 (SI == MemberOffsets.begin() || TypeSize::isKnownLE(*(SI - 1), Offset)) && in getElementContainingOffset()
109 (SI + 1 == MemberOffsets.end() || in getElementContainingOffset()
117 // offset, implying that this element is non-empty. in getElementContainingOffset()
118 return SI - MemberOffsets.begin(); in getElementContainingOffset()
121 //===----------------------------------------------------------------------===//
123 //===----------------------------------------------------------------------===//
125 LayoutAlignElem LayoutAlignElem::get(Align ABIAlign, Align PrefAlign, in get()
140 //===----------------------------------------------------------------------===//
142 //===----------------------------------------------------------------------===//
145 Align ABIAlign, Align PrefAlign, in getInBits()
165 //===----------------------------------------------------------------------===//
167 //===----------------------------------------------------------------------===//
171 return "-m:l"; in getManglingComponent()
173 return "-m:o"; in getManglingComponent()
175 return T.getArch() == Triple::x86 ? "-m:x" : "-m:w"; in getManglingComponent()
177 return "-m:a"; in getManglingComponent()
178 return "-m:e"; in getManglingComponent()
182 {INTEGER_ALIGN, {1, Align(1), Align(1)}}, // i1
183 {INTEGER_ALIGN, {8, Align(1), Align(1)}}, // i8
184 {INTEGER_ALIGN, {16, Align(2), Align(2)}}, // i16
185 {INTEGER_ALIGN, {32, Align(4), Align(4)}}, // i32
186 {INTEGER_ALIGN, {64, Align(4), Align(8)}}, // i64
187 {FLOAT_ALIGN, {16, Align(2), Align(2)}}, // half, bfloat
188 {FLOAT_ALIGN, {32, Align(4), Align(4)}}, // float
189 {FLOAT_ALIGN, {64, Align(8), Align(8)}}, // double
190 {FLOAT_ALIGN, {128, Align(16), Align(16)}}, // ppcf128, quad, ...
191 {VECTOR_ALIGN, {64, Align(8), Align(8)}}, // v2i32, v1i64, ...
192 {VECTOR_ALIGN, {128, Align(16), Align(16)}}, // v16i8, v8i16, v4i32, ...
208 StructAlignment = LayoutAlignElem::get(Align(1), Align(8), 0); in reset()
216 if (Error Err = setPointerAlignmentInBits(0, Align(8), Align(8), 64, 64)) in reset()
270 return reportError("Invalid address space, must be a 24-bit integer"); in getAddrSpace()
277 // Split at '-'. in parseSpecifier()
279 if (Error Err = ::split(Desc, '-', Split)) in parseSpecifier()
300 return reportError("Address space 0 can never be non-integral"); in parseSpecifier()
328 return reportError("Invalid address space, must be a 24-bit integer"); in parseSpecifier()
419 "ABI alignment specification must be >0 for non-aggregate types"); in parseSpecifier()
557 void DataLayout::init(const Module *M) { *this = M->getDataLayout(); } in init()
586 Error DataLayout::setAlignment(AlignTypeEnum AlignType, Align ABIAlign, in setAlignment()
587 Align PrefAlign, uint32_t BitWidth) { in setAlignment()
594 return reportError("Invalid bit width, must be a 24-bit integer"); in setAlignment()
619 if (I != Alignments->end() && I->TypeBitWidth == BitWidth) { in setAlignment()
621 I->ABIAlign = ABIAlign; in setAlignment()
622 I->PrefAlign = PrefAlign; in setAlignment()
625 Alignments->insert(I, LayoutAlignElem::get(ABIAlign, PrefAlign, BitWidth)); in setAlignment()
637 if (I != Pointers.end() && I->AddressSpace == AddressSpace) in getPointerAlignElem()
645 Error DataLayout::setPointerAlignmentInBits(uint32_t AddrSpace, Align ABIAlign, in setPointerAlignmentInBits()
646 Align PrefAlign, in setPointerAlignmentInBits()
659 if (I == Pointers.end() || I->AddressSpace != AddrSpace) { in setPointerAlignmentInBits()
664 I->ABIAlign = ABIAlign; in setPointerAlignmentInBits()
665 I->PrefAlign = PrefAlign; in setPointerAlignmentInBits()
666 I->TypeBitWidth = TypeBitWidth; in setPointerAlignmentInBits()
667 I->IndexBitWidth = IndexBitWidth; in setPointerAlignmentInBits()
672 Align DataLayout::getIntegerAlignment(uint32_t BitWidth, in getIntegerAlignment()
678 if (I == IntAlignments.end()) in getIntegerAlignment()
679 --I; in getIntegerAlignment()
680 return abi_or_pref ? I->ABIAlign : I->PrefAlign; in getIntegerAlignment()
694 Value->~StructLayout(); in ~StructLayoutMap()
704 } // end anonymous namespace
731 StructLayout::totalSizeToAlloc<TypeSize>(Ty->getNumElements())); in getStructLayout()
742 Align DataLayout::getPointerABIAlignment(unsigned AS) const { in getPointerABIAlignment()
746 Align DataLayout::getPointerPrefAlignment(unsigned AS) const { in getPointerPrefAlignment()
764 assert(Ty->isPtrOrPtrVectorTy() && in getPointerTypeSizeInBits()
766 Ty = Ty->getScalarType(); in getPointerTypeSizeInBits()
767 return getPointerSizeInBits(cast<PointerType>(Ty)->getAddressSpace()); in getPointerTypeSizeInBits()
775 assert(Ty->isPtrOrPtrVectorTy() && in getIndexTypeSizeInBits()
777 Ty = Ty->getScalarType(); in getIndexTypeSizeInBits()
778 return getIndexSizeInBits(cast<PointerType>(Ty)->getAddressSpace()); in getIndexTypeSizeInBits()
789 Align DataLayout::getAlignment(Type *Ty, bool abi_or_pref) const { in getAlignment()
790 assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!"); in getAlignment()
791 switch (Ty->getTypeID()) { in getAlignment()
792 // Early escape for the non-numeric types. in getAlignment()
796 unsigned AS = cast<PointerType>(Ty)->getAddressSpace(); in getAlignment()
801 return getAlignment(cast<ArrayType>(Ty)->getElementType(), abi_or_pref); in getAlignment()
805 if (cast<StructType>(Ty)->isPacked() && abi_or_pref) in getAlignment()
806 return Align(1); in getAlignment()
810 const Align Align = in getAlignment() local
812 return std::max(Align, Layout->getAlignment()); in getAlignment()
815 return getIntegerAlignment(Ty->getIntegerBitWidth(), abi_or_pref); in getAlignment()
827 if (I != FloatAlignments.end() && I->TypeBitWidth == BitWidth) in getAlignment()
828 return abi_or_pref ? I->ABIAlign : I->PrefAlign; in getAlignment()
832 // greater-or-equal to the store size of the type. This is a reasonable in getAlignment()
836 return Align(PowerOf2Ceil(BitWidth / 8)); in getAlignment()
843 if (I != VectorAlignments.end() && I->TypeBitWidth == BitWidth) in getAlignment()
844 return abi_or_pref ? I->ABIAlign : I->PrefAlign; in getAlignment()
847 // with what clang and llvm-gcc do. in getAlignment()
852 return Align(PowerOf2Ceil(getTypeStoreSize(Ty).getKnownMinValue())); in getAlignment()
855 return Align(64); in getAlignment()
857 Type *LayoutTy = cast<TargetExtType>(Ty)->getLayoutType(); in getAlignment()
865 Align DataLayout::getABITypeAlign(Type *Ty) const { in getABITypeAlign()
869 /// TODO: Remove this function once the transition to Align is over.
874 Align DataLayout::getPrefTypeAlign(Type *Ty) const { in getPrefTypeAlign()
884 assert(Ty->isPtrOrPtrVectorTy() && in getIntPtrType()
887 IntegerType *IntTy = IntegerType::get(Ty->getContext(), NumBits); in getIntPtrType()
902 return Max != LegalIntWidths.end() ? *Max : 0; in getLargestLegalIntTypeSizeInBits()
911 assert(Ty->isPtrOrPtrVectorTy() && in getIndexType()
914 IntegerType *IntTy = IntegerType::get(Ty->getContext(), NumBits); in getIndexType()
930 assert(Idx->getType()->isIntegerTy(32) && "Illegal struct idx"); in getIndexedOffsetInType()
931 unsigned FieldNo = cast<ConstantInt>(Idx)->getZExtValue(); in getIndexedOffsetInType()
937 Result += Layout->getElementOffset(FieldNo); in getIndexedOffsetInType()
939 if (int64_t ArrayIdx = cast<ConstantInt>(Idx)->getSExtValue()) in getIndexedOffsetInType()
953 !isUIntN(BitWidth - 1, ElemSize)) { in getElementIndex()
958 Offset -= Index * ElemSize; in getElementIndex()
961 --Index; in getElementIndex()
971 ElemTy = ArrTy->getElementType(); in getGEPIndexForOffset()
985 if (IntOffset >= SL->getSizeInBytes()) in getGEPIndexForOffset()
988 unsigned Index = SL->getElementContainingOffset(IntOffset); in getGEPIndexForOffset()
989 Offset -= SL->getElementOffset(Index); in getGEPIndexForOffset()
990 ElemTy = STy->getElementType(Index); in getGEPIndexForOffset()
994 // Non-aggregate type. in getGEPIndexForOffset()
1000 assert(ElemTy->isSized() && "Element type must be sized"); in getGEPIndicesForOffset()
1013 /// getPreferredAlign - Return the preferred alignment of the specified global.
1015 Align DataLayout::getPreferredAlign(const GlobalVariable *GV) const { in getPreferredAlign()
1016 MaybeAlign GVAlignment = GV->getAlign(); in getPreferredAlign()
1019 if (GVAlignment && GV->hasSection()) in getPreferredAlign()
1028 Type *ElemType = GV->getValueType(); in getPreferredAlign()
1029 Align Alignment = getPrefTypeAlign(ElemType); in getPreferredAlign()
1040 if (GV->hasInitializer() && !GVAlignment) { in getPreferredAlign()
1041 if (Alignment < Align(16)) { in getPreferredAlign()
1045 Alignment = Align(16); // 16-byte alignment. in getPreferredAlign()