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 = DataLayout::RoundUpAlignment(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 = DataLayout::RoundUpAlignment(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.isOSBinFormatELF() || T.isArch64Bit())
160 assert(T.isOSBinFormatCOFF());
164 static const LayoutAlignElem DefaultAlignments[] = {
165 { INTEGER_ALIGN, 1, 1, 1 }, // i1
166 { INTEGER_ALIGN, 8, 1, 1 }, // i8
167 { INTEGER_ALIGN, 16, 2, 2 }, // i16
168 { INTEGER_ALIGN, 32, 4, 4 }, // i32
169 { INTEGER_ALIGN, 64, 4, 8 }, // i64
170 { FLOAT_ALIGN, 16, 2, 2 }, // half
171 { FLOAT_ALIGN, 32, 4, 4 }, // float
172 { FLOAT_ALIGN, 64, 8, 8 }, // double
173 { FLOAT_ALIGN, 128, 16, 16 }, // ppcf128, quad, ...
174 { VECTOR_ALIGN, 64, 8, 8 }, // v2i32, v1i64, ...
175 { VECTOR_ALIGN, 128, 16, 16 }, // v16i8, v8i16, v4i32, ...
176 { AGGREGATE_ALIGN, 0, 0, 8 } // struct
179 void DataLayout::reset(StringRef Desc) {
183 LittleEndian = false;
184 StackNaturalAlign = 0;
185 ManglingMode = MM_None;
187 // Default alignments
188 for (int I = 0, N = array_lengthof(DefaultAlignments); I < N; ++I) {
189 const LayoutAlignElem &E = DefaultAlignments[I];
190 setAlignment((AlignTypeEnum)E.AlignType, E.ABIAlign, E.PrefAlign,
193 setPointerAlignment(0, 8, 8, 8);
195 parseSpecifier(Desc);
198 /// Checked version of split, to ensure mandatory subparts.
199 static std::pair<StringRef, StringRef> split(StringRef Str, char Separator) {
200 assert(!Str.empty() && "parse error, string can't be empty here");
201 std::pair<StringRef, StringRef> Split = Str.split(Separator);
202 assert((!Split.second.empty() || Split.first == Str) &&
203 "a trailing separator is not allowed");
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) {
218 assert(Bits % 8 == 0 && "number of bits must be a byte width multiple");
222 void DataLayout::parseSpecifier(StringRef Desc) {
223 while (!Desc.empty()) {
225 std::pair<StringRef, StringRef> Split = split(Desc, '-');
229 Split = split(Split.first, ':');
231 // Aliases used below.
232 StringRef &Tok = Split.first; // Current token.
233 StringRef &Rest = Split.second; // The rest of the string.
235 char Specifier = Tok.front();
240 // Ignored for backward compatibility.
241 // FIXME: remove this on LLVM 4.0.
244 LittleEndian = false;
251 unsigned AddrSpace = Tok.empty() ? 0 : getInt(Tok);
252 assert(AddrSpace < 1 << 24 &&
253 "Invalid address space, must be a 24bit integer");
256 Split = split(Rest, ':');
257 unsigned PointerMemSize = inBytes(getInt(Tok));
260 Split = split(Rest, ':');
261 unsigned PointerABIAlign = inBytes(getInt(Tok));
263 // Preferred alignment.
264 unsigned PointerPrefAlign = PointerABIAlign;
266 Split = split(Rest, ':');
267 PointerPrefAlign = inBytes(getInt(Tok));
270 setPointerAlignment(AddrSpace, PointerABIAlign, PointerPrefAlign,
278 AlignTypeEnum AlignType;
281 case 'i': AlignType = INTEGER_ALIGN; break;
282 case 'v': AlignType = VECTOR_ALIGN; break;
283 case 'f': AlignType = FLOAT_ALIGN; break;
284 case 'a': AlignType = AGGREGATE_ALIGN; break;
288 unsigned Size = Tok.empty() ? 0 : getInt(Tok);
290 assert((AlignType != AGGREGATE_ALIGN || Size == 0) &&
291 "These specifications don't have a size");
294 Split = split(Rest, ':');
295 unsigned ABIAlign = inBytes(getInt(Tok));
297 // Preferred alignment.
298 unsigned PrefAlign = ABIAlign;
300 Split = split(Rest, ':');
301 PrefAlign = inBytes(getInt(Tok));
304 setAlignment(AlignType, ABIAlign, PrefAlign, Size);
308 case 'n': // Native integer types.
310 unsigned Width = getInt(Tok);
311 assert(Width != 0 && "width must be non-zero");
312 LegalIntWidths.push_back(Width);
315 Split = split(Rest, ':');
318 case 'S': { // Stack natural alignment.
319 StackNaturalAlign = inBytes(getInt(Tok));
324 assert(Rest.size() == 1);
327 llvm_unreachable("Unknown mangling in datalayout string");
329 ManglingMode = MM_ELF;
332 ManglingMode = MM_MachO;
335 ManglingMode = MM_Mips;
338 ManglingMode = MM_WINCOFF;
343 llvm_unreachable("Unknown specifier in datalayout string");
349 DataLayout::DataLayout(const Module *M) : LayoutMap(0) {
350 const DataLayout *Other = M->getDataLayout();
357 bool DataLayout::operator==(const DataLayout &Other) const {
358 bool Ret = LittleEndian == Other.LittleEndian &&
359 StackNaturalAlign == Other.StackNaturalAlign &&
360 ManglingMode == Other.ManglingMode &&
361 LegalIntWidths == Other.LegalIntWidths &&
362 Alignments == Other.Alignments && Pointers == Pointers;
363 assert(Ret == (getStringRepresentation() == Other.getStringRepresentation()));
368 DataLayout::setAlignment(AlignTypeEnum align_type, unsigned abi_align,
369 unsigned pref_align, uint32_t bit_width) {
370 assert(abi_align <= pref_align && "Preferred alignment worse than ABI!");
371 assert(pref_align < (1 << 16) && "Alignment doesn't fit in bitfield");
372 assert(bit_width < (1 << 24) && "Bit width doesn't fit in bitfield");
373 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
374 if (Alignments[i].AlignType == (unsigned)align_type &&
375 Alignments[i].TypeBitWidth == bit_width) {
376 // Update the abi, preferred alignments.
377 Alignments[i].ABIAlign = abi_align;
378 Alignments[i].PrefAlign = pref_align;
383 Alignments.push_back(LayoutAlignElem::get(align_type, abi_align,
384 pref_align, bit_width));
387 static bool comparePointerAlignElem(const PointerAlignElem &A,
388 uint32_t AddressSpace) {
389 return A.AddressSpace < AddressSpace;
392 DataLayout::PointersTy::iterator
393 DataLayout::findPointerLowerBound(uint32_t AddressSpace) {
394 return std::lower_bound(Pointers.begin(), Pointers.end(), AddressSpace,
395 comparePointerAlignElem);
398 void DataLayout::setPointerAlignment(uint32_t AddrSpace, unsigned ABIAlign,
400 uint32_t TypeByteWidth) {
401 assert(ABIAlign <= PrefAlign && "Preferred alignment worse than ABI!");
402 PointersTy::iterator I = findPointerLowerBound(AddrSpace);
403 if (I == Pointers.end() || I->AddressSpace != AddrSpace) {
404 Pointers.insert(I, PointerAlignElem::get(AddrSpace, ABIAlign, PrefAlign,
407 I->ABIAlign = ABIAlign;
408 I->PrefAlign = PrefAlign;
409 I->TypeByteWidth = TypeByteWidth;
413 /// getAlignmentInfo - Return the alignment (either ABI if ABIInfo = true or
414 /// preferred if ABIInfo = false) the layout wants for the specified datatype.
415 unsigned DataLayout::getAlignmentInfo(AlignTypeEnum AlignType,
416 uint32_t BitWidth, bool ABIInfo,
418 // Check to see if we have an exact match and remember the best match we see.
419 int BestMatchIdx = -1;
421 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
422 if (Alignments[i].AlignType == (unsigned)AlignType &&
423 Alignments[i].TypeBitWidth == BitWidth)
424 return ABIInfo ? Alignments[i].ABIAlign : Alignments[i].PrefAlign;
426 // The best match so far depends on what we're looking for.
427 if (AlignType == INTEGER_ALIGN &&
428 Alignments[i].AlignType == INTEGER_ALIGN) {
429 // The "best match" for integers is the smallest size that is larger than
430 // the BitWidth requested.
431 if (Alignments[i].TypeBitWidth > BitWidth && (BestMatchIdx == -1 ||
432 Alignments[i].TypeBitWidth < Alignments[BestMatchIdx].TypeBitWidth))
434 // However, if there isn't one that's larger, then we must use the
435 // largest one we have (see below)
436 if (LargestInt == -1 ||
437 Alignments[i].TypeBitWidth > Alignments[LargestInt].TypeBitWidth)
442 // Okay, we didn't find an exact solution. Fall back here depending on what
443 // is being looked for.
444 if (BestMatchIdx == -1) {
445 // If we didn't find an integer alignment, fall back on most conservative.
446 if (AlignType == INTEGER_ALIGN) {
447 BestMatchIdx = LargestInt;
449 assert(AlignType == VECTOR_ALIGN && "Unknown alignment type!");
451 // By default, use natural alignment for vector types. This is consistent
452 // with what clang and llvm-gcc do.
453 unsigned Align = getTypeAllocSize(cast<VectorType>(Ty)->getElementType());
454 Align *= cast<VectorType>(Ty)->getNumElements();
455 // If the alignment is not a power of 2, round up to the next power of 2.
456 // This happens for non-power-of-2 length vectors.
457 if (Align & (Align-1))
458 Align = NextPowerOf2(Align);
463 // Since we got a "best match" index, just return it.
464 return ABIInfo ? Alignments[BestMatchIdx].ABIAlign
465 : Alignments[BestMatchIdx].PrefAlign;
470 class StructLayoutMap {
471 typedef DenseMap<StructType*, StructLayout*> LayoutInfoTy;
472 LayoutInfoTy LayoutInfo;
475 virtual ~StructLayoutMap() {
476 // Remove any layouts.
477 for (LayoutInfoTy::iterator I = LayoutInfo.begin(), E = LayoutInfo.end();
479 StructLayout *Value = I->second;
480 Value->~StructLayout();
485 StructLayout *&operator[](StructType *STy) {
486 return LayoutInfo[STy];
490 virtual void dump() const {}
493 } // end anonymous namespace
495 void DataLayout::clear() {
496 LegalIntWidths.clear();
499 delete static_cast<StructLayoutMap *>(LayoutMap);
503 DataLayout::~DataLayout() {
507 const StructLayout *DataLayout::getStructLayout(StructType *Ty) const {
509 LayoutMap = new StructLayoutMap();
511 StructLayoutMap *STM = static_cast<StructLayoutMap*>(LayoutMap);
512 StructLayout *&SL = (*STM)[Ty];
515 // Otherwise, create the struct layout. Because it is variable length, we
516 // malloc it, then use placement new.
517 int NumElts = Ty->getNumElements();
519 (StructLayout *)malloc(sizeof(StructLayout)+(NumElts-1) * sizeof(uint64_t));
521 // Set SL before calling StructLayout's ctor. The ctor could cause other
522 // entries to be added to TheMap, invalidating our reference.
525 new (L) StructLayout(Ty, *this);
530 std::string DataLayout::getStringRepresentation() const {
532 raw_string_ostream OS(Result);
534 OS << (LittleEndian ? "e" : "E");
536 switch (ManglingMode) {
553 for (PointersTy::const_iterator I = Pointers.begin(), E = Pointers.end();
555 const PointerAlignElem &PI = *I;
558 if (PI.AddressSpace == 0 && PI.ABIAlign == 8 && PI.PrefAlign == 8 &&
559 PI.TypeByteWidth == 8)
563 if (PI.AddressSpace) {
564 OS << PI.AddressSpace;
566 OS << ":" << PI.TypeByteWidth*8 << ':' << PI.ABIAlign*8;
567 if (PI.PrefAlign != PI.ABIAlign)
568 OS << ':' << PI.PrefAlign*8;
571 const LayoutAlignElem *DefaultStart = DefaultAlignments;
572 const LayoutAlignElem *DefaultEnd =
573 DefaultStart + array_lengthof(DefaultAlignments);
574 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
575 const LayoutAlignElem &AI = Alignments[i];
576 if (std::find(DefaultStart, DefaultEnd, AI) != DefaultEnd)
578 OS << '-' << (char)AI.AlignType;
580 OS << AI.TypeBitWidth;
581 OS << ':' << AI.ABIAlign*8;
582 if (AI.ABIAlign != AI.PrefAlign)
583 OS << ':' << AI.PrefAlign*8;
586 if (!LegalIntWidths.empty()) {
587 OS << "-n" << (unsigned)LegalIntWidths[0];
589 for (unsigned i = 1, e = LegalIntWidths.size(); i != e; ++i)
590 OS << ':' << (unsigned)LegalIntWidths[i];
593 if (StackNaturalAlign)
594 OS << "-S" << StackNaturalAlign*8;
599 unsigned DataLayout::getPointerABIAlignment(unsigned AS) const {
600 PointersTy::const_iterator I = findPointerLowerBound(AS);
601 if (I == Pointers.end() || I->AddressSpace != AS) {
602 I = findPointerLowerBound(0);
603 assert(I->AddressSpace == 0);
608 unsigned DataLayout::getPointerPrefAlignment(unsigned AS) const {
609 PointersTy::const_iterator I = findPointerLowerBound(AS);
610 if (I == Pointers.end() || I->AddressSpace != AS) {
611 I = findPointerLowerBound(0);
612 assert(I->AddressSpace == 0);
617 unsigned DataLayout::getPointerSize(unsigned AS) const {
618 PointersTy::const_iterator I = findPointerLowerBound(AS);
619 if (I == Pointers.end() || I->AddressSpace != AS) {
620 I = findPointerLowerBound(0);
621 assert(I->AddressSpace == 0);
623 return I->TypeByteWidth;
626 unsigned DataLayout::getPointerTypeSizeInBits(Type *Ty) const {
627 assert(Ty->isPtrOrPtrVectorTy() &&
628 "This should only be called with a pointer or pointer vector type");
630 if (Ty->isPointerTy())
631 return getTypeSizeInBits(Ty);
633 return getTypeSizeInBits(Ty->getScalarType());
637 \param abi_or_pref Flag that determines which alignment is returned. true
638 returns the ABI alignment, false returns the preferred alignment.
639 \param Ty The underlying type for which alignment is determined.
641 Get the ABI (\a abi_or_pref == true) or preferred alignment (\a abi_or_pref
642 == false) for the requested type \a Ty.
644 unsigned DataLayout::getAlignment(Type *Ty, bool abi_or_pref) const {
647 assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
648 switch (Ty->getTypeID()) {
649 // Early escape for the non-numeric types.
650 case Type::LabelTyID:
652 ? getPointerABIAlignment(0)
653 : getPointerPrefAlignment(0));
654 case Type::PointerTyID: {
655 unsigned AS = dyn_cast<PointerType>(Ty)->getAddressSpace();
657 ? getPointerABIAlignment(AS)
658 : getPointerPrefAlignment(AS));
660 case Type::ArrayTyID:
661 return getAlignment(cast<ArrayType>(Ty)->getElementType(), abi_or_pref);
663 case Type::StructTyID: {
664 // Packed structure types always have an ABI alignment of one.
665 if (cast<StructType>(Ty)->isPacked() && abi_or_pref)
668 // Get the layout annotation... which is lazily created on demand.
669 const StructLayout *Layout = getStructLayout(cast<StructType>(Ty));
670 unsigned Align = getAlignmentInfo(AGGREGATE_ALIGN, 0, abi_or_pref, Ty);
671 return std::max(Align, Layout->getAlignment());
673 case Type::IntegerTyID:
674 AlignType = INTEGER_ALIGN;
677 case Type::FloatTyID:
678 case Type::DoubleTyID:
679 // PPC_FP128TyID and FP128TyID have different data contents, but the
680 // same size and alignment, so they look the same here.
681 case Type::PPC_FP128TyID:
682 case Type::FP128TyID:
683 case Type::X86_FP80TyID:
684 AlignType = FLOAT_ALIGN;
686 case Type::X86_MMXTyID:
687 case Type::VectorTyID:
688 AlignType = VECTOR_ALIGN;
691 llvm_unreachable("Bad type for getAlignment!!!");
694 return getAlignmentInfo((AlignTypeEnum)AlignType, getTypeSizeInBits(Ty),
698 unsigned DataLayout::getABITypeAlignment(Type *Ty) const {
699 return getAlignment(Ty, true);
702 /// getABIIntegerTypeAlignment - Return the minimum ABI-required alignment for
703 /// an integer type of the specified bitwidth.
704 unsigned DataLayout::getABIIntegerTypeAlignment(unsigned BitWidth) const {
705 return getAlignmentInfo(INTEGER_ALIGN, BitWidth, true, 0);
708 unsigned DataLayout::getPrefTypeAlignment(Type *Ty) const {
709 return getAlignment(Ty, false);
712 unsigned DataLayout::getPreferredTypeAlignmentShift(Type *Ty) const {
713 unsigned Align = getPrefTypeAlignment(Ty);
714 assert(!(Align & (Align-1)) && "Alignment is not a power of two!");
715 return Log2_32(Align);
718 IntegerType *DataLayout::getIntPtrType(LLVMContext &C,
719 unsigned AddressSpace) const {
720 return IntegerType::get(C, getPointerSizeInBits(AddressSpace));
723 Type *DataLayout::getIntPtrType(Type *Ty) const {
724 assert(Ty->isPtrOrPtrVectorTy() &&
725 "Expected a pointer or pointer vector type.");
726 unsigned NumBits = getTypeSizeInBits(Ty->getScalarType());
727 IntegerType *IntTy = IntegerType::get(Ty->getContext(), NumBits);
728 if (VectorType *VecTy = dyn_cast<VectorType>(Ty))
729 return VectorType::get(IntTy, VecTy->getNumElements());
733 Type *DataLayout::getSmallestLegalIntType(LLVMContext &C, unsigned Width) const {
734 for (unsigned i = 0, e = (unsigned)LegalIntWidths.size(); i != e; ++i)
735 if (Width <= LegalIntWidths[i])
736 return Type::getIntNTy(C, LegalIntWidths[i]);
740 unsigned DataLayout::getLargestLegalIntTypeSize() const {
741 unsigned MaxWidth = 0;
742 for (unsigned i = 0, e = (unsigned)LegalIntWidths.size(); i != e; ++i)
743 MaxWidth = std::max<unsigned>(MaxWidth, LegalIntWidths[i]);
747 uint64_t DataLayout::getIndexedOffset(Type *ptrTy,
748 ArrayRef<Value *> Indices) const {
750 assert(Ty->isPointerTy() && "Illegal argument for getIndexedOffset()");
753 generic_gep_type_iterator<Value* const*>
754 TI = gep_type_begin(ptrTy, Indices);
755 for (unsigned CurIDX = 0, EndIDX = Indices.size(); CurIDX != EndIDX;
757 if (StructType *STy = dyn_cast<StructType>(*TI)) {
758 assert(Indices[CurIDX]->getType() ==
759 Type::getInt32Ty(ptrTy->getContext()) &&
760 "Illegal struct idx");
761 unsigned FieldNo = cast<ConstantInt>(Indices[CurIDX])->getZExtValue();
763 // Get structure layout information...
764 const StructLayout *Layout = getStructLayout(STy);
766 // Add in the offset, as calculated by the structure layout info...
767 Result += Layout->getElementOffset(FieldNo);
769 // Update Ty to refer to current element
770 Ty = STy->getElementType(FieldNo);
772 // Update Ty to refer to current element
773 Ty = cast<SequentialType>(Ty)->getElementType();
775 // Get the array index and the size of each array element.
776 if (int64_t arrayIdx = cast<ConstantInt>(Indices[CurIDX])->getSExtValue())
777 Result += (uint64_t)arrayIdx * getTypeAllocSize(Ty);
784 /// getPreferredAlignment - Return the preferred alignment of the specified
785 /// global. This includes an explicitly requested alignment (if the global
787 unsigned DataLayout::getPreferredAlignment(const GlobalVariable *GV) const {
788 Type *ElemType = GV->getType()->getElementType();
789 unsigned Alignment = getPrefTypeAlignment(ElemType);
790 unsigned GVAlignment = GV->getAlignment();
791 if (GVAlignment >= Alignment) {
792 Alignment = GVAlignment;
793 } else if (GVAlignment != 0) {
794 Alignment = std::max(GVAlignment, getABITypeAlignment(ElemType));
797 if (GV->hasInitializer() && GVAlignment == 0) {
798 if (Alignment < 16) {
799 // If the global is not external, see if it is large. If so, give it a
801 if (getTypeSizeInBits(ElemType) > 128)
802 Alignment = 16; // 16-byte alignment.
808 /// getPreferredAlignmentLog - Return the preferred alignment of the
809 /// specified global, returned in log form. This includes an explicitly
810 /// requested alignment (if the global has one).
811 unsigned DataLayout::getPreferredAlignmentLog(const GlobalVariable *GV) const {
812 return Log2_32(getPreferredAlignment(GV));
815 DataLayoutPass::DataLayoutPass() : ImmutablePass(ID), DL("") {
816 report_fatal_error("Bad DataLayoutPass ctor used. Tool did not specify a "
817 "DataLayout to use?");
820 DataLayoutPass::~DataLayoutPass() {}
822 DataLayoutPass::DataLayoutPass(const DataLayout &DL)
823 : ImmutablePass(ID), DL(DL) {
824 initializeDataLayoutPassPass(*PassRegistry::getPassRegistry());
827 DataLayoutPass::DataLayoutPass(const Module *M) : ImmutablePass(ID), DL(M) {
828 initializeDataLayoutPassPass(*PassRegistry::getPassRegistry());