1 //===-- DataLayout.cpp - Data size & alignment routines --------------------==//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines layout properties related to datatype size/offset/alignment
13 // This structure should be created once, filled in if the defaults are not
14 // correct and then passed around by const&. None of the members functions
15 // require modification to the object.
17 //===----------------------------------------------------------------------===//
19 #include "llvm/IR/DataLayout.h"
20 #include "llvm/ADT/DenseMap.h"
21 #include "llvm/ADT/STLExtras.h"
22 #include "llvm/ADT/Triple.h"
23 #include "llvm/IR/Constants.h"
24 #include "llvm/IR/DerivedTypes.h"
25 #include "llvm/IR/GetElementPtrTypeIterator.h"
26 #include "llvm/IR/Module.h"
27 #include "llvm/Support/ErrorHandling.h"
28 #include "llvm/Support/ManagedStatic.h"
29 #include "llvm/Support/MathExtras.h"
30 #include "llvm/Support/Mutex.h"
31 #include "llvm/Support/raw_ostream.h"
36 // Handle the Pass registration stuff necessary to use DataLayout's.
38 INITIALIZE_PASS(DataLayoutPass, "datalayout", "Data Layout", false, true)
39 char DataLayoutPass::ID = 0;
41 //===----------------------------------------------------------------------===//
42 // Support for StructLayout
43 //===----------------------------------------------------------------------===//
45 StructLayout::StructLayout(StructType *ST, const DataLayout &DL) {
46 assert(!ST->isOpaque() && "Cannot get layout of opaque structs");
49 NumElements = ST->getNumElements();
51 // Loop over each of the elements, placing them in memory.
52 for (unsigned i = 0, e = NumElements; i != e; ++i) {
53 Type *Ty = ST->getElementType(i);
54 unsigned TyAlign = ST->isPacked() ? 1 : DL.getABITypeAlignment(Ty);
56 // Add padding if necessary to align the data element properly.
57 if ((StructSize & (TyAlign-1)) != 0)
58 StructSize = RoundUpToAlignment(StructSize, TyAlign);
60 // Keep track of maximum alignment constraint.
61 StructAlignment = std::max(TyAlign, StructAlignment);
63 MemberOffsets[i] = StructSize;
64 StructSize += DL.getTypeAllocSize(Ty); // Consume space for this data item
67 // Empty structures have alignment of 1 byte.
68 if (StructAlignment == 0) StructAlignment = 1;
70 // Add padding to the end of the struct so that it could be put in an array
71 // and all array elements would be aligned correctly.
72 if ((StructSize & (StructAlignment-1)) != 0)
73 StructSize = RoundUpToAlignment(StructSize, StructAlignment);
77 /// getElementContainingOffset - Given a valid offset into the structure,
78 /// return the structure index that contains it.
79 unsigned StructLayout::getElementContainingOffset(uint64_t Offset) const {
81 std::upper_bound(&MemberOffsets[0], &MemberOffsets[NumElements], Offset);
82 assert(SI != &MemberOffsets[0] && "Offset not in structure type!");
84 assert(*SI <= Offset && "upper_bound didn't work");
85 assert((SI == &MemberOffsets[0] || *(SI-1) <= Offset) &&
86 (SI+1 == &MemberOffsets[NumElements] || *(SI+1) > Offset) &&
87 "Upper bound didn't work!");
89 // Multiple fields can have the same offset if any of them are zero sized.
90 // For example, in { i32, [0 x i32], i32 }, searching for offset 4 will stop
91 // at the i32 element, because it is the last element at that offset. This is
92 // the right one to return, because anything after it will have a higher
93 // offset, implying that this element is non-empty.
94 return SI-&MemberOffsets[0];
97 //===----------------------------------------------------------------------===//
98 // LayoutAlignElem, LayoutAlign support
99 //===----------------------------------------------------------------------===//
102 LayoutAlignElem::get(AlignTypeEnum align_type, unsigned abi_align,
103 unsigned pref_align, uint32_t bit_width) {
104 assert(abi_align <= pref_align && "Preferred alignment worse than ABI!");
105 LayoutAlignElem retval;
106 retval.AlignType = align_type;
107 retval.ABIAlign = abi_align;
108 retval.PrefAlign = pref_align;
109 retval.TypeBitWidth = bit_width;
114 LayoutAlignElem::operator==(const LayoutAlignElem &rhs) const {
115 return (AlignType == rhs.AlignType
116 && ABIAlign == rhs.ABIAlign
117 && PrefAlign == rhs.PrefAlign
118 && TypeBitWidth == rhs.TypeBitWidth);
121 const LayoutAlignElem
122 DataLayout::InvalidAlignmentElem = { INVALID_ALIGN, 0, 0, 0 };
124 //===----------------------------------------------------------------------===//
125 // PointerAlignElem, PointerAlign support
126 //===----------------------------------------------------------------------===//
129 PointerAlignElem::get(uint32_t AddressSpace, unsigned ABIAlign,
130 unsigned PrefAlign, uint32_t TypeByteWidth) {
131 assert(ABIAlign <= PrefAlign && "Preferred alignment worse than ABI!");
132 PointerAlignElem retval;
133 retval.AddressSpace = AddressSpace;
134 retval.ABIAlign = ABIAlign;
135 retval.PrefAlign = PrefAlign;
136 retval.TypeByteWidth = TypeByteWidth;
141 PointerAlignElem::operator==(const PointerAlignElem &rhs) const {
142 return (ABIAlign == rhs.ABIAlign
143 && AddressSpace == rhs.AddressSpace
144 && PrefAlign == rhs.PrefAlign
145 && TypeByteWidth == rhs.TypeByteWidth);
148 const PointerAlignElem
149 DataLayout::InvalidPointerElem = { 0U, 0U, 0U, ~0U };
151 //===----------------------------------------------------------------------===//
152 // DataLayout Class Implementation
153 //===----------------------------------------------------------------------===//
155 const char *DataLayout::getManglingComponent(const Triple &T) {
156 if (T.isOSBinFormatMachO())
158 if (T.isOSWindows() && T.getArch() == Triple::x86 && T.isOSBinFormatCOFF())
163 static const LayoutAlignElem DefaultAlignments[] = {
164 { INTEGER_ALIGN, 1, 1, 1 }, // i1
165 { INTEGER_ALIGN, 8, 1, 1 }, // i8
166 { INTEGER_ALIGN, 16, 2, 2 }, // i16
167 { INTEGER_ALIGN, 32, 4, 4 }, // i32
168 { INTEGER_ALIGN, 64, 4, 8 }, // i64
169 { FLOAT_ALIGN, 16, 2, 2 }, // half
170 { FLOAT_ALIGN, 32, 4, 4 }, // float
171 { FLOAT_ALIGN, 64, 8, 8 }, // double
172 { FLOAT_ALIGN, 128, 16, 16 }, // ppcf128, quad, ...
173 { VECTOR_ALIGN, 64, 8, 8 }, // v2i32, v1i64, ...
174 { VECTOR_ALIGN, 128, 16, 16 }, // v16i8, v8i16, v4i32, ...
175 { AGGREGATE_ALIGN, 0, 0, 8 } // struct
178 void DataLayout::reset(StringRef Desc) {
183 StackNaturalAlign = 0;
184 ManglingMode = MM_None;
186 // Default alignments
187 for (const LayoutAlignElem &E : DefaultAlignments) {
188 setAlignment((AlignTypeEnum)E.AlignType, E.ABIAlign, E.PrefAlign,
191 setPointerAlignment(0, 8, 8, 8);
193 parseSpecifier(Desc);
196 /// Checked version of split, to ensure mandatory subparts.
197 static std::pair<StringRef, StringRef> split(StringRef Str, char Separator) {
198 assert(!Str.empty() && "parse error, string can't be empty here");
199 std::pair<StringRef, StringRef> Split = Str.split(Separator);
200 if (Split.second.empty() && Split.first != Str)
201 report_fatal_error("Trailing separator in datalayout string");
202 if (!Split.second.empty() && Split.first.empty())
203 report_fatal_error("Expected token before separator in datalayout string");
207 /// Get an unsigned integer, including error checks.
208 static unsigned getInt(StringRef R) {
210 bool error = R.getAsInteger(10, Result); (void)error;
212 report_fatal_error("not a number, or does not fit in an unsigned int");
216 /// Convert bits into bytes. Assert if not a byte width multiple.
217 static unsigned inBytes(unsigned Bits) {
219 report_fatal_error("number of bits must be a byte width multiple");
223 void DataLayout::parseSpecifier(StringRef Desc) {
224 while (!Desc.empty()) {
226 std::pair<StringRef, StringRef> Split = split(Desc, '-');
230 Split = split(Split.first, ':');
232 // Aliases used below.
233 StringRef &Tok = Split.first; // Current token.
234 StringRef &Rest = Split.second; // The rest of the string.
236 char Specifier = Tok.front();
241 // Ignored for backward compatibility.
242 // FIXME: remove this on LLVM 4.0.
252 unsigned AddrSpace = Tok.empty() ? 0 : getInt(Tok);
253 if (!isUInt<24>(AddrSpace))
254 report_fatal_error("Invalid address space, must be a 24bit integer");
259 "Missing size specification for pointer in datalayout string");
260 Split = split(Rest, ':');
261 unsigned PointerMemSize = inBytes(getInt(Tok));
266 "Missing alignment specification for pointer in datalayout string");
267 Split = split(Rest, ':');
268 unsigned PointerABIAlign = inBytes(getInt(Tok));
270 // Preferred alignment.
271 unsigned PointerPrefAlign = PointerABIAlign;
273 Split = split(Rest, ':');
274 PointerPrefAlign = inBytes(getInt(Tok));
277 setPointerAlignment(AddrSpace, PointerABIAlign, PointerPrefAlign,
285 AlignTypeEnum AlignType;
288 case 'i': AlignType = INTEGER_ALIGN; break;
289 case 'v': AlignType = VECTOR_ALIGN; break;
290 case 'f': AlignType = FLOAT_ALIGN; break;
291 case 'a': AlignType = AGGREGATE_ALIGN; break;
295 unsigned Size = Tok.empty() ? 0 : getInt(Tok);
297 if (AlignType == AGGREGATE_ALIGN && Size != 0)
299 "Sized aggregate specification in datalayout string");
304 "Missing alignment specification in datalayout string");
305 Split = split(Rest, ':');
306 unsigned ABIAlign = inBytes(getInt(Tok));
308 // Preferred alignment.
309 unsigned PrefAlign = ABIAlign;
311 Split = split(Rest, ':');
312 PrefAlign = inBytes(getInt(Tok));
315 setAlignment(AlignType, ABIAlign, PrefAlign, Size);
319 case 'n': // Native integer types.
321 unsigned Width = getInt(Tok);
324 "Zero width native integer type in datalayout string");
325 LegalIntWidths.push_back(Width);
328 Split = split(Rest, ':');
331 case 'S': { // Stack natural alignment.
332 StackNaturalAlign = inBytes(getInt(Tok));
337 report_fatal_error("Unexpected trailing characters after mangling specifier in datalayout string");
339 report_fatal_error("Expected mangling specifier in datalayout string");
341 report_fatal_error("Unknown mangling specifier in datalayout string");
344 report_fatal_error("Unknown mangling in datalayout string");
346 ManglingMode = MM_ELF;
349 ManglingMode = MM_MachO;
352 ManglingMode = MM_Mips;
355 ManglingMode = MM_WINCOFF;
360 report_fatal_error("Unknown specifier in datalayout string");
366 DataLayout::DataLayout(const Module *M) : LayoutMap(nullptr) {
370 void DataLayout::init(const Module *M) {
371 const DataLayout *Other = M->getDataLayout();
378 bool DataLayout::operator==(const DataLayout &Other) const {
379 bool Ret = BigEndian == Other.BigEndian &&
380 StackNaturalAlign == Other.StackNaturalAlign &&
381 ManglingMode == Other.ManglingMode &&
382 LegalIntWidths == Other.LegalIntWidths &&
383 Alignments == Other.Alignments && Pointers == Other.Pointers;
384 assert(Ret == (getStringRepresentation() == Other.getStringRepresentation()));
389 DataLayout::setAlignment(AlignTypeEnum align_type, unsigned abi_align,
390 unsigned pref_align, uint32_t bit_width) {
391 assert(abi_align <= pref_align && "Preferred alignment worse than ABI!");
392 assert(pref_align < (1 << 16) && "Alignment doesn't fit in bitfield");
393 assert(bit_width < (1 << 24) && "Bit width doesn't fit in bitfield");
394 for (LayoutAlignElem &Elem : Alignments) {
395 if (Elem.AlignType == (unsigned)align_type &&
396 Elem.TypeBitWidth == bit_width) {
397 // Update the abi, preferred alignments.
398 Elem.ABIAlign = abi_align;
399 Elem.PrefAlign = pref_align;
404 Alignments.push_back(LayoutAlignElem::get(align_type, abi_align,
405 pref_align, bit_width));
408 DataLayout::PointersTy::iterator
409 DataLayout::findPointerLowerBound(uint32_t AddressSpace) {
410 return std::lower_bound(Pointers.begin(), Pointers.end(), AddressSpace,
411 [](const PointerAlignElem &A, uint32_t AddressSpace) {
412 return A.AddressSpace < AddressSpace;
416 void DataLayout::setPointerAlignment(uint32_t AddrSpace, unsigned ABIAlign,
418 uint32_t TypeByteWidth) {
419 assert(ABIAlign <= PrefAlign && "Preferred alignment worse than ABI!");
420 PointersTy::iterator I = findPointerLowerBound(AddrSpace);
421 if (I == Pointers.end() || I->AddressSpace != AddrSpace) {
422 Pointers.insert(I, PointerAlignElem::get(AddrSpace, ABIAlign, PrefAlign,
425 I->ABIAlign = ABIAlign;
426 I->PrefAlign = PrefAlign;
427 I->TypeByteWidth = TypeByteWidth;
431 /// getAlignmentInfo - Return the alignment (either ABI if ABIInfo = true or
432 /// preferred if ABIInfo = false) the layout wants for the specified datatype.
433 unsigned DataLayout::getAlignmentInfo(AlignTypeEnum AlignType,
434 uint32_t BitWidth, bool ABIInfo,
436 // Check to see if we have an exact match and remember the best match we see.
437 int BestMatchIdx = -1;
439 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
440 if (Alignments[i].AlignType == (unsigned)AlignType &&
441 Alignments[i].TypeBitWidth == BitWidth)
442 return ABIInfo ? Alignments[i].ABIAlign : Alignments[i].PrefAlign;
444 // The best match so far depends on what we're looking for.
445 if (AlignType == INTEGER_ALIGN &&
446 Alignments[i].AlignType == INTEGER_ALIGN) {
447 // The "best match" for integers is the smallest size that is larger than
448 // the BitWidth requested.
449 if (Alignments[i].TypeBitWidth > BitWidth && (BestMatchIdx == -1 ||
450 Alignments[i].TypeBitWidth < Alignments[BestMatchIdx].TypeBitWidth))
452 // However, if there isn't one that's larger, then we must use the
453 // largest one we have (see below)
454 if (LargestInt == -1 ||
455 Alignments[i].TypeBitWidth > Alignments[LargestInt].TypeBitWidth)
460 // Okay, we didn't find an exact solution. Fall back here depending on what
461 // is being looked for.
462 if (BestMatchIdx == -1) {
463 // If we didn't find an integer alignment, fall back on most conservative.
464 if (AlignType == INTEGER_ALIGN) {
465 BestMatchIdx = LargestInt;
467 assert(AlignType == VECTOR_ALIGN && "Unknown alignment type!");
469 // By default, use natural alignment for vector types. This is consistent
470 // with what clang and llvm-gcc do.
471 unsigned Align = getTypeAllocSize(cast<VectorType>(Ty)->getElementType());
472 Align *= cast<VectorType>(Ty)->getNumElements();
473 // If the alignment is not a power of 2, round up to the next power of 2.
474 // This happens for non-power-of-2 length vectors.
475 if (Align & (Align-1))
476 Align = NextPowerOf2(Align);
481 // Since we got a "best match" index, just return it.
482 return ABIInfo ? Alignments[BestMatchIdx].ABIAlign
483 : Alignments[BestMatchIdx].PrefAlign;
488 class StructLayoutMap {
489 typedef DenseMap<StructType*, StructLayout*> LayoutInfoTy;
490 LayoutInfoTy LayoutInfo;
494 // Remove any layouts.
495 for (const auto &I : LayoutInfo) {
496 StructLayout *Value = I.second;
497 Value->~StructLayout();
502 StructLayout *&operator[](StructType *STy) {
503 return LayoutInfo[STy];
507 } // end anonymous namespace
509 void DataLayout::clear() {
510 LegalIntWidths.clear();
513 delete static_cast<StructLayoutMap *>(LayoutMap);
517 DataLayout::~DataLayout() {
521 const StructLayout *DataLayout::getStructLayout(StructType *Ty) const {
523 LayoutMap = new StructLayoutMap();
525 StructLayoutMap *STM = static_cast<StructLayoutMap*>(LayoutMap);
526 StructLayout *&SL = (*STM)[Ty];
529 // Otherwise, create the struct layout. Because it is variable length, we
530 // malloc it, then use placement new.
531 int NumElts = Ty->getNumElements();
533 (StructLayout *)malloc(sizeof(StructLayout)+(NumElts-1) * sizeof(uint64_t));
535 // Set SL before calling StructLayout's ctor. The ctor could cause other
536 // entries to be added to TheMap, invalidating our reference.
539 new (L) StructLayout(Ty, *this);
544 std::string DataLayout::getStringRepresentation() const {
546 raw_string_ostream OS(Result);
548 OS << (BigEndian ? "E" : "e");
550 switch (ManglingMode) {
567 for (const PointerAlignElem &PI : Pointers) {
569 if (PI.AddressSpace == 0 && PI.ABIAlign == 8 && PI.PrefAlign == 8 &&
570 PI.TypeByteWidth == 8)
574 if (PI.AddressSpace) {
575 OS << PI.AddressSpace;
577 OS << ":" << PI.TypeByteWidth*8 << ':' << PI.ABIAlign*8;
578 if (PI.PrefAlign != PI.ABIAlign)
579 OS << ':' << PI.PrefAlign*8;
582 for (const LayoutAlignElem &AI : Alignments) {
583 if (std::find(std::begin(DefaultAlignments), std::end(DefaultAlignments),
584 AI) != std::end(DefaultAlignments))
586 OS << '-' << (char)AI.AlignType;
588 OS << AI.TypeBitWidth;
589 OS << ':' << AI.ABIAlign*8;
590 if (AI.ABIAlign != AI.PrefAlign)
591 OS << ':' << AI.PrefAlign*8;
594 if (!LegalIntWidths.empty()) {
595 OS << "-n" << (unsigned)LegalIntWidths[0];
597 for (unsigned i = 1, e = LegalIntWidths.size(); i != e; ++i)
598 OS << ':' << (unsigned)LegalIntWidths[i];
601 if (StackNaturalAlign)
602 OS << "-S" << StackNaturalAlign*8;
607 unsigned DataLayout::getPointerABIAlignment(unsigned AS) const {
608 PointersTy::const_iterator I = findPointerLowerBound(AS);
609 if (I == Pointers.end() || I->AddressSpace != AS) {
610 I = findPointerLowerBound(0);
611 assert(I->AddressSpace == 0);
616 unsigned DataLayout::getPointerPrefAlignment(unsigned AS) const {
617 PointersTy::const_iterator I = findPointerLowerBound(AS);
618 if (I == Pointers.end() || I->AddressSpace != AS) {
619 I = findPointerLowerBound(0);
620 assert(I->AddressSpace == 0);
625 unsigned DataLayout::getPointerSize(unsigned AS) const {
626 PointersTy::const_iterator I = findPointerLowerBound(AS);
627 if (I == Pointers.end() || I->AddressSpace != AS) {
628 I = findPointerLowerBound(0);
629 assert(I->AddressSpace == 0);
631 return I->TypeByteWidth;
634 unsigned DataLayout::getPointerTypeSizeInBits(Type *Ty) const {
635 assert(Ty->isPtrOrPtrVectorTy() &&
636 "This should only be called with a pointer or pointer vector type");
638 if (Ty->isPointerTy())
639 return getTypeSizeInBits(Ty);
641 return getTypeSizeInBits(Ty->getScalarType());
645 \param abi_or_pref Flag that determines which alignment is returned. true
646 returns the ABI alignment, false returns the preferred alignment.
647 \param Ty The underlying type for which alignment is determined.
649 Get the ABI (\a abi_or_pref == true) or preferred alignment (\a abi_or_pref
650 == false) for the requested type \a Ty.
652 unsigned DataLayout::getAlignment(Type *Ty, bool abi_or_pref) const {
655 assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
656 switch (Ty->getTypeID()) {
657 // Early escape for the non-numeric types.
658 case Type::LabelTyID:
660 ? getPointerABIAlignment(0)
661 : getPointerPrefAlignment(0));
662 case Type::PointerTyID: {
663 unsigned AS = cast<PointerType>(Ty)->getAddressSpace();
665 ? getPointerABIAlignment(AS)
666 : getPointerPrefAlignment(AS));
668 case Type::ArrayTyID:
669 return getAlignment(cast<ArrayType>(Ty)->getElementType(), abi_or_pref);
671 case Type::StructTyID: {
672 // Packed structure types always have an ABI alignment of one.
673 if (cast<StructType>(Ty)->isPacked() && abi_or_pref)
676 // Get the layout annotation... which is lazily created on demand.
677 const StructLayout *Layout = getStructLayout(cast<StructType>(Ty));
678 unsigned Align = getAlignmentInfo(AGGREGATE_ALIGN, 0, abi_or_pref, Ty);
679 return std::max(Align, Layout->getAlignment());
681 case Type::IntegerTyID:
682 AlignType = INTEGER_ALIGN;
685 case Type::FloatTyID:
686 case Type::DoubleTyID:
687 // PPC_FP128TyID and FP128TyID have different data contents, but the
688 // same size and alignment, so they look the same here.
689 case Type::PPC_FP128TyID:
690 case Type::FP128TyID:
691 case Type::X86_FP80TyID:
692 AlignType = FLOAT_ALIGN;
694 case Type::X86_MMXTyID:
695 case Type::VectorTyID:
696 AlignType = VECTOR_ALIGN;
699 llvm_unreachable("Bad type for getAlignment!!!");
702 return getAlignmentInfo((AlignTypeEnum)AlignType, getTypeSizeInBits(Ty),
706 unsigned DataLayout::getABITypeAlignment(Type *Ty) const {
707 return getAlignment(Ty, true);
710 /// getABIIntegerTypeAlignment - Return the minimum ABI-required alignment for
711 /// an integer type of the specified bitwidth.
712 unsigned DataLayout::getABIIntegerTypeAlignment(unsigned BitWidth) const {
713 return getAlignmentInfo(INTEGER_ALIGN, BitWidth, true, nullptr);
716 unsigned DataLayout::getPrefTypeAlignment(Type *Ty) const {
717 return getAlignment(Ty, false);
720 unsigned DataLayout::getPreferredTypeAlignmentShift(Type *Ty) const {
721 unsigned Align = getPrefTypeAlignment(Ty);
722 assert(!(Align & (Align-1)) && "Alignment is not a power of two!");
723 return Log2_32(Align);
726 IntegerType *DataLayout::getIntPtrType(LLVMContext &C,
727 unsigned AddressSpace) const {
728 return IntegerType::get(C, getPointerSizeInBits(AddressSpace));
731 Type *DataLayout::getIntPtrType(Type *Ty) const {
732 assert(Ty->isPtrOrPtrVectorTy() &&
733 "Expected a pointer or pointer vector type.");
734 unsigned NumBits = getPointerTypeSizeInBits(Ty);
735 IntegerType *IntTy = IntegerType::get(Ty->getContext(), NumBits);
736 if (VectorType *VecTy = dyn_cast<VectorType>(Ty))
737 return VectorType::get(IntTy, VecTy->getNumElements());
741 Type *DataLayout::getSmallestLegalIntType(LLVMContext &C, unsigned Width) const {
742 for (unsigned LegalIntWidth : LegalIntWidths)
743 if (Width <= LegalIntWidth)
744 return Type::getIntNTy(C, LegalIntWidth);
748 unsigned DataLayout::getLargestLegalIntTypeSize() const {
749 auto Max = std::max_element(LegalIntWidths.begin(), LegalIntWidths.end());
750 return Max != LegalIntWidths.end() ? *Max : 0;
753 uint64_t DataLayout::getIndexedOffset(Type *ptrTy,
754 ArrayRef<Value *> Indices) const {
756 assert(Ty->isPointerTy() && "Illegal argument for getIndexedOffset()");
759 generic_gep_type_iterator<Value* const*>
760 TI = gep_type_begin(ptrTy, Indices);
761 for (unsigned CurIDX = 0, EndIDX = Indices.size(); CurIDX != EndIDX;
763 if (StructType *STy = dyn_cast<StructType>(*TI)) {
764 assert(Indices[CurIDX]->getType() ==
765 Type::getInt32Ty(ptrTy->getContext()) &&
766 "Illegal struct idx");
767 unsigned FieldNo = cast<ConstantInt>(Indices[CurIDX])->getZExtValue();
769 // Get structure layout information...
770 const StructLayout *Layout = getStructLayout(STy);
772 // Add in the offset, as calculated by the structure layout info...
773 Result += Layout->getElementOffset(FieldNo);
775 // Update Ty to refer to current element
776 Ty = STy->getElementType(FieldNo);
778 // Update Ty to refer to current element
779 Ty = cast<SequentialType>(Ty)->getElementType();
781 // Get the array index and the size of each array element.
782 if (int64_t arrayIdx = cast<ConstantInt>(Indices[CurIDX])->getSExtValue())
783 Result += (uint64_t)arrayIdx * getTypeAllocSize(Ty);
790 /// getPreferredAlignment - Return the preferred alignment of the specified
791 /// global. This includes an explicitly requested alignment (if the global
793 unsigned DataLayout::getPreferredAlignment(const GlobalVariable *GV) const {
794 Type *ElemType = GV->getType()->getElementType();
795 unsigned Alignment = getPrefTypeAlignment(ElemType);
796 unsigned GVAlignment = GV->getAlignment();
797 if (GVAlignment >= Alignment) {
798 Alignment = GVAlignment;
799 } else if (GVAlignment != 0) {
800 Alignment = std::max(GVAlignment, getABITypeAlignment(ElemType));
803 if (GV->hasInitializer() && GVAlignment == 0) {
804 if (Alignment < 16) {
805 // If the global is not external, see if it is large. If so, give it a
807 if (getTypeSizeInBits(ElemType) > 128)
808 Alignment = 16; // 16-byte alignment.
814 /// getPreferredAlignmentLog - Return the preferred alignment of the
815 /// specified global, returned in log form. This includes an explicitly
816 /// requested alignment (if the global has one).
817 unsigned DataLayout::getPreferredAlignmentLog(const GlobalVariable *GV) const {
818 return Log2_32(getPreferredAlignment(GV));
821 DataLayoutPass::DataLayoutPass() : ImmutablePass(ID), DL("") {
822 initializeDataLayoutPassPass(*PassRegistry::getPassRegistry());
825 DataLayoutPass::~DataLayoutPass() {}
827 bool DataLayoutPass::doInitialization(Module &M) {
832 bool DataLayoutPass::doFinalization(Module &M) {