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/Module.h"
26 #include "llvm/Support/ErrorHandling.h"
27 #include "llvm/Support/GetElementPtrTypeIterator.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();
358 DataLayout::setAlignment(AlignTypeEnum align_type, unsigned abi_align,
359 unsigned pref_align, uint32_t bit_width) {
360 assert(abi_align <= pref_align && "Preferred alignment worse than ABI!");
361 assert(pref_align < (1 << 16) && "Alignment doesn't fit in bitfield");
362 assert(bit_width < (1 << 24) && "Bit width doesn't fit in bitfield");
363 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
364 if (Alignments[i].AlignType == (unsigned)align_type &&
365 Alignments[i].TypeBitWidth == bit_width) {
366 // Update the abi, preferred alignments.
367 Alignments[i].ABIAlign = abi_align;
368 Alignments[i].PrefAlign = pref_align;
373 Alignments.push_back(LayoutAlignElem::get(align_type, abi_align,
374 pref_align, bit_width));
377 void DataLayout::setPointerAlignment(uint32_t AddrSpace, unsigned ABIAlign,
379 uint32_t TypeByteWidth) {
380 assert(ABIAlign <= PrefAlign && "Preferred alignment worse than ABI!");
381 DenseMap<unsigned,PointerAlignElem>::iterator val = Pointers.find(AddrSpace);
382 if (val == Pointers.end()) {
383 Pointers[AddrSpace] =
384 PointerAlignElem::get(AddrSpace, ABIAlign, PrefAlign, TypeByteWidth);
386 val->second.ABIAlign = ABIAlign;
387 val->second.PrefAlign = PrefAlign;
388 val->second.TypeByteWidth = TypeByteWidth;
392 /// getAlignmentInfo - Return the alignment (either ABI if ABIInfo = true or
393 /// preferred if ABIInfo = false) the layout wants for the specified datatype.
394 unsigned DataLayout::getAlignmentInfo(AlignTypeEnum AlignType,
395 uint32_t BitWidth, bool ABIInfo,
397 // Check to see if we have an exact match and remember the best match we see.
398 int BestMatchIdx = -1;
400 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
401 if (Alignments[i].AlignType == (unsigned)AlignType &&
402 Alignments[i].TypeBitWidth == BitWidth)
403 return ABIInfo ? Alignments[i].ABIAlign : Alignments[i].PrefAlign;
405 // The best match so far depends on what we're looking for.
406 if (AlignType == INTEGER_ALIGN &&
407 Alignments[i].AlignType == INTEGER_ALIGN) {
408 // The "best match" for integers is the smallest size that is larger than
409 // the BitWidth requested.
410 if (Alignments[i].TypeBitWidth > BitWidth && (BestMatchIdx == -1 ||
411 Alignments[i].TypeBitWidth < Alignments[BestMatchIdx].TypeBitWidth))
413 // However, if there isn't one that's larger, then we must use the
414 // largest one we have (see below)
415 if (LargestInt == -1 ||
416 Alignments[i].TypeBitWidth > Alignments[LargestInt].TypeBitWidth)
421 // Okay, we didn't find an exact solution. Fall back here depending on what
422 // is being looked for.
423 if (BestMatchIdx == -1) {
424 // If we didn't find an integer alignment, fall back on most conservative.
425 if (AlignType == INTEGER_ALIGN) {
426 BestMatchIdx = LargestInt;
428 assert(AlignType == VECTOR_ALIGN && "Unknown alignment type!");
430 // By default, use natural alignment for vector types. This is consistent
431 // with what clang and llvm-gcc do.
432 unsigned Align = getTypeAllocSize(cast<VectorType>(Ty)->getElementType());
433 Align *= cast<VectorType>(Ty)->getNumElements();
434 // If the alignment is not a power of 2, round up to the next power of 2.
435 // This happens for non-power-of-2 length vectors.
436 if (Align & (Align-1))
437 Align = NextPowerOf2(Align);
442 // Since we got a "best match" index, just return it.
443 return ABIInfo ? Alignments[BestMatchIdx].ABIAlign
444 : Alignments[BestMatchIdx].PrefAlign;
449 class StructLayoutMap {
450 typedef DenseMap<StructType*, StructLayout*> LayoutInfoTy;
451 LayoutInfoTy LayoutInfo;
454 virtual ~StructLayoutMap() {
455 // Remove any layouts.
456 for (LayoutInfoTy::iterator I = LayoutInfo.begin(), E = LayoutInfo.end();
458 StructLayout *Value = I->second;
459 Value->~StructLayout();
464 StructLayout *&operator[](StructType *STy) {
465 return LayoutInfo[STy];
469 virtual void dump() const {}
472 } // end anonymous namespace
474 void DataLayout::clear() {
475 LegalIntWidths.clear();
478 delete static_cast<StructLayoutMap *>(LayoutMap);
482 DataLayout::~DataLayout() {
486 const StructLayout *DataLayout::getStructLayout(StructType *Ty) const {
488 LayoutMap = new StructLayoutMap();
490 StructLayoutMap *STM = static_cast<StructLayoutMap*>(LayoutMap);
491 StructLayout *&SL = (*STM)[Ty];
494 // Otherwise, create the struct layout. Because it is variable length, we
495 // malloc it, then use placement new.
496 int NumElts = Ty->getNumElements();
498 (StructLayout *)malloc(sizeof(StructLayout)+(NumElts-1) * sizeof(uint64_t));
500 // Set SL before calling StructLayout's ctor. The ctor could cause other
501 // entries to be added to TheMap, invalidating our reference.
504 new (L) StructLayout(Ty, *this);
509 std::string DataLayout::getStringRepresentation() const {
511 raw_string_ostream OS(Result);
513 OS << (LittleEndian ? "e" : "E");
515 switch (ManglingMode) {
532 SmallVector<unsigned, 8> addrSpaces;
533 // Lets get all of the known address spaces and sort them
534 // into increasing order so that we can emit the string
535 // in a cleaner format.
536 for (DenseMap<unsigned, PointerAlignElem>::const_iterator
537 pib = Pointers.begin(), pie = Pointers.end();
539 addrSpaces.push_back(pib->first);
541 std::sort(addrSpaces.begin(), addrSpaces.end());
542 for (SmallVectorImpl<unsigned>::iterator asb = addrSpaces.begin(),
543 ase = addrSpaces.end(); asb != ase; ++asb) {
544 const PointerAlignElem &PI = Pointers.find(*asb)->second;
547 if (PI.AddressSpace == 0 && PI.ABIAlign == 8 && PI.PrefAlign == 8 &&
548 PI.TypeByteWidth == 8)
552 if (PI.AddressSpace) {
553 OS << PI.AddressSpace;
555 OS << ":" << PI.TypeByteWidth*8 << ':' << PI.ABIAlign*8;
556 if (PI.PrefAlign != PI.ABIAlign)
557 OS << ':' << PI.PrefAlign*8;
560 const LayoutAlignElem *DefaultStart = DefaultAlignments;
561 const LayoutAlignElem *DefaultEnd =
562 DefaultStart + array_lengthof(DefaultAlignments);
563 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
564 const LayoutAlignElem &AI = Alignments[i];
565 if (std::find(DefaultStart, DefaultEnd, AI) != DefaultEnd)
567 OS << '-' << (char)AI.AlignType;
569 OS << AI.TypeBitWidth;
570 OS << ':' << AI.ABIAlign*8;
571 if (AI.ABIAlign != AI.PrefAlign)
572 OS << ':' << AI.PrefAlign*8;
575 if (!LegalIntWidths.empty()) {
576 OS << "-n" << (unsigned)LegalIntWidths[0];
578 for (unsigned i = 1, e = LegalIntWidths.size(); i != e; ++i)
579 OS << ':' << (unsigned)LegalIntWidths[i];
582 if (StackNaturalAlign)
583 OS << "-S" << StackNaturalAlign*8;
588 unsigned DataLayout::getPointerTypeSizeInBits(Type *Ty) const {
589 assert(Ty->isPtrOrPtrVectorTy() &&
590 "This should only be called with a pointer or pointer vector type");
592 if (Ty->isPointerTy())
593 return getTypeSizeInBits(Ty);
595 return getTypeSizeInBits(Ty->getScalarType());
599 \param abi_or_pref Flag that determines which alignment is returned. true
600 returns the ABI alignment, false returns the preferred alignment.
601 \param Ty The underlying type for which alignment is determined.
603 Get the ABI (\a abi_or_pref == true) or preferred alignment (\a abi_or_pref
604 == false) for the requested type \a Ty.
606 unsigned DataLayout::getAlignment(Type *Ty, bool abi_or_pref) const {
609 assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
610 switch (Ty->getTypeID()) {
611 // Early escape for the non-numeric types.
612 case Type::LabelTyID:
614 ? getPointerABIAlignment(0)
615 : getPointerPrefAlignment(0));
616 case Type::PointerTyID: {
617 unsigned AS = dyn_cast<PointerType>(Ty)->getAddressSpace();
619 ? getPointerABIAlignment(AS)
620 : getPointerPrefAlignment(AS));
622 case Type::ArrayTyID:
623 return getAlignment(cast<ArrayType>(Ty)->getElementType(), abi_or_pref);
625 case Type::StructTyID: {
626 // Packed structure types always have an ABI alignment of one.
627 if (cast<StructType>(Ty)->isPacked() && abi_or_pref)
630 // Get the layout annotation... which is lazily created on demand.
631 const StructLayout *Layout = getStructLayout(cast<StructType>(Ty));
632 unsigned Align = getAlignmentInfo(AGGREGATE_ALIGN, 0, abi_or_pref, Ty);
633 return std::max(Align, Layout->getAlignment());
635 case Type::IntegerTyID:
636 AlignType = INTEGER_ALIGN;
639 case Type::FloatTyID:
640 case Type::DoubleTyID:
641 // PPC_FP128TyID and FP128TyID have different data contents, but the
642 // same size and alignment, so they look the same here.
643 case Type::PPC_FP128TyID:
644 case Type::FP128TyID:
645 case Type::X86_FP80TyID:
646 AlignType = FLOAT_ALIGN;
648 case Type::X86_MMXTyID:
649 case Type::VectorTyID:
650 AlignType = VECTOR_ALIGN;
653 llvm_unreachable("Bad type for getAlignment!!!");
656 return getAlignmentInfo((AlignTypeEnum)AlignType, getTypeSizeInBits(Ty),
660 unsigned DataLayout::getABITypeAlignment(Type *Ty) const {
661 return getAlignment(Ty, true);
664 /// getABIIntegerTypeAlignment - Return the minimum ABI-required alignment for
665 /// an integer type of the specified bitwidth.
666 unsigned DataLayout::getABIIntegerTypeAlignment(unsigned BitWidth) const {
667 return getAlignmentInfo(INTEGER_ALIGN, BitWidth, true, 0);
670 unsigned DataLayout::getPrefTypeAlignment(Type *Ty) const {
671 return getAlignment(Ty, false);
674 unsigned DataLayout::getPreferredTypeAlignmentShift(Type *Ty) const {
675 unsigned Align = getPrefTypeAlignment(Ty);
676 assert(!(Align & (Align-1)) && "Alignment is not a power of two!");
677 return Log2_32(Align);
680 IntegerType *DataLayout::getIntPtrType(LLVMContext &C,
681 unsigned AddressSpace) const {
682 return IntegerType::get(C, getPointerSizeInBits(AddressSpace));
685 Type *DataLayout::getIntPtrType(Type *Ty) const {
686 assert(Ty->isPtrOrPtrVectorTy() &&
687 "Expected a pointer or pointer vector type.");
688 unsigned NumBits = getTypeSizeInBits(Ty->getScalarType());
689 IntegerType *IntTy = IntegerType::get(Ty->getContext(), NumBits);
690 if (VectorType *VecTy = dyn_cast<VectorType>(Ty))
691 return VectorType::get(IntTy, VecTy->getNumElements());
695 Type *DataLayout::getSmallestLegalIntType(LLVMContext &C, unsigned Width) const {
696 for (unsigned i = 0, e = (unsigned)LegalIntWidths.size(); i != e; ++i)
697 if (Width <= LegalIntWidths[i])
698 return Type::getIntNTy(C, LegalIntWidths[i]);
702 unsigned DataLayout::getLargestLegalIntTypeSize() const {
703 unsigned MaxWidth = 0;
704 for (unsigned i = 0, e = (unsigned)LegalIntWidths.size(); i != e; ++i)
705 MaxWidth = std::max<unsigned>(MaxWidth, LegalIntWidths[i]);
709 uint64_t DataLayout::getIndexedOffset(Type *ptrTy,
710 ArrayRef<Value *> Indices) const {
712 assert(Ty->isPointerTy() && "Illegal argument for getIndexedOffset()");
715 generic_gep_type_iterator<Value* const*>
716 TI = gep_type_begin(ptrTy, Indices);
717 for (unsigned CurIDX = 0, EndIDX = Indices.size(); CurIDX != EndIDX;
719 if (StructType *STy = dyn_cast<StructType>(*TI)) {
720 assert(Indices[CurIDX]->getType() ==
721 Type::getInt32Ty(ptrTy->getContext()) &&
722 "Illegal struct idx");
723 unsigned FieldNo = cast<ConstantInt>(Indices[CurIDX])->getZExtValue();
725 // Get structure layout information...
726 const StructLayout *Layout = getStructLayout(STy);
728 // Add in the offset, as calculated by the structure layout info...
729 Result += Layout->getElementOffset(FieldNo);
731 // Update Ty to refer to current element
732 Ty = STy->getElementType(FieldNo);
734 // Update Ty to refer to current element
735 Ty = cast<SequentialType>(Ty)->getElementType();
737 // Get the array index and the size of each array element.
738 if (int64_t arrayIdx = cast<ConstantInt>(Indices[CurIDX])->getSExtValue())
739 Result += (uint64_t)arrayIdx * getTypeAllocSize(Ty);
746 /// getPreferredAlignment - Return the preferred alignment of the specified
747 /// global. This includes an explicitly requested alignment (if the global
749 unsigned DataLayout::getPreferredAlignment(const GlobalVariable *GV) const {
750 Type *ElemType = GV->getType()->getElementType();
751 unsigned Alignment = getPrefTypeAlignment(ElemType);
752 unsigned GVAlignment = GV->getAlignment();
753 if (GVAlignment >= Alignment) {
754 Alignment = GVAlignment;
755 } else if (GVAlignment != 0) {
756 Alignment = std::max(GVAlignment, getABITypeAlignment(ElemType));
759 if (GV->hasInitializer() && GVAlignment == 0) {
760 if (Alignment < 16) {
761 // If the global is not external, see if it is large. If so, give it a
763 if (getTypeSizeInBits(ElemType) > 128)
764 Alignment = 16; // 16-byte alignment.
770 /// getPreferredAlignmentLog - Return the preferred alignment of the
771 /// specified global, returned in log form. This includes an explicitly
772 /// requested alignment (if the global has one).
773 unsigned DataLayout::getPreferredAlignmentLog(const GlobalVariable *GV) const {
774 return Log2_32(getPreferredAlignment(GV));
777 DataLayoutPass::DataLayoutPass() : ImmutablePass(ID), DL("") {
778 report_fatal_error("Bad DataLayoutPass ctor used. Tool did not specify a "
779 "DataLayout to use?");
782 DataLayoutPass::~DataLayoutPass() {}
784 DataLayoutPass::DataLayoutPass(const DataLayout &DL)
785 : ImmutablePass(ID), DL(DL) {
786 initializeDataLayoutPassPass(*PassRegistry::getPassRegistry());
789 DataLayoutPass::DataLayoutPass(const Module *M) : ImmutablePass(ID), DL(M) {
790 initializeDataLayoutPassPass(*PassRegistry::getPassRegistry());