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 // Register the default SparcV9 implementation...
39 INITIALIZE_PASS(DataLayout, "datalayout", "Data Layout", false, true)
40 char DataLayout::ID = 0;
42 //===----------------------------------------------------------------------===//
43 // Support for StructLayout
44 //===----------------------------------------------------------------------===//
46 StructLayout::StructLayout(StructType *ST, const DataLayout &DL) {
47 assert(!ST->isOpaque() && "Cannot get layout of opaque structs");
50 NumElements = ST->getNumElements();
52 // Loop over each of the elements, placing them in memory.
53 for (unsigned i = 0, e = NumElements; i != e; ++i) {
54 Type *Ty = ST->getElementType(i);
55 unsigned TyAlign = ST->isPacked() ? 1 : DL.getABITypeAlignment(Ty);
57 // Add padding if necessary to align the data element properly.
58 if ((StructSize & (TyAlign-1)) != 0)
59 StructSize = DataLayout::RoundUpAlignment(StructSize, TyAlign);
61 // Keep track of maximum alignment constraint.
62 StructAlignment = std::max(TyAlign, StructAlignment);
64 MemberOffsets[i] = StructSize;
65 StructSize += DL.getTypeAllocSize(Ty); // Consume space for this data item
68 // Empty structures have alignment of 1 byte.
69 if (StructAlignment == 0) StructAlignment = 1;
71 // Add padding to the end of the struct so that it could be put in an array
72 // and all array elements would be aligned correctly.
73 if ((StructSize & (StructAlignment-1)) != 0)
74 StructSize = DataLayout::RoundUpAlignment(StructSize, StructAlignment);
78 /// getElementContainingOffset - Given a valid offset into the structure,
79 /// return the structure index that contains it.
80 unsigned StructLayout::getElementContainingOffset(uint64_t Offset) const {
82 std::upper_bound(&MemberOffsets[0], &MemberOffsets[NumElements], Offset);
83 assert(SI != &MemberOffsets[0] && "Offset not in structure type!");
85 assert(*SI <= Offset && "upper_bound didn't work");
86 assert((SI == &MemberOffsets[0] || *(SI-1) <= Offset) &&
87 (SI+1 == &MemberOffsets[NumElements] || *(SI+1) > Offset) &&
88 "Upper bound didn't work!");
90 // Multiple fields can have the same offset if any of them are zero sized.
91 // For example, in { i32, [0 x i32], i32 }, searching for offset 4 will stop
92 // at the i32 element, because it is the last element at that offset. This is
93 // the right one to return, because anything after it will have a higher
94 // offset, implying that this element is non-empty.
95 return SI-&MemberOffsets[0];
98 //===----------------------------------------------------------------------===//
99 // LayoutAlignElem, LayoutAlign support
100 //===----------------------------------------------------------------------===//
103 LayoutAlignElem::get(AlignTypeEnum align_type, unsigned abi_align,
104 unsigned pref_align, uint32_t bit_width) {
105 assert(abi_align <= pref_align && "Preferred alignment worse than ABI!");
106 LayoutAlignElem retval;
107 retval.AlignType = align_type;
108 retval.ABIAlign = abi_align;
109 retval.PrefAlign = pref_align;
110 retval.TypeBitWidth = bit_width;
115 LayoutAlignElem::operator==(const LayoutAlignElem &rhs) const {
116 return (AlignType == rhs.AlignType
117 && ABIAlign == rhs.ABIAlign
118 && PrefAlign == rhs.PrefAlign
119 && TypeBitWidth == rhs.TypeBitWidth);
122 const LayoutAlignElem
123 DataLayout::InvalidAlignmentElem = { INVALID_ALIGN, 0, 0, 0 };
125 //===----------------------------------------------------------------------===//
126 // PointerAlignElem, PointerAlign support
127 //===----------------------------------------------------------------------===//
130 PointerAlignElem::get(uint32_t AddressSpace, unsigned ABIAlign,
131 unsigned PrefAlign, uint32_t TypeByteWidth) {
132 assert(ABIAlign <= PrefAlign && "Preferred alignment worse than ABI!");
133 PointerAlignElem retval;
134 retval.AddressSpace = AddressSpace;
135 retval.ABIAlign = ABIAlign;
136 retval.PrefAlign = PrefAlign;
137 retval.TypeByteWidth = TypeByteWidth;
142 PointerAlignElem::operator==(const PointerAlignElem &rhs) const {
143 return (ABIAlign == rhs.ABIAlign
144 && AddressSpace == rhs.AddressSpace
145 && PrefAlign == rhs.PrefAlign
146 && TypeByteWidth == rhs.TypeByteWidth);
149 const PointerAlignElem
150 DataLayout::InvalidPointerElem = { 0U, 0U, 0U, ~0U };
152 //===----------------------------------------------------------------------===//
153 // DataLayout Class Implementation
154 //===----------------------------------------------------------------------===//
156 const char *DataLayout::getManglingComponent(const Triple &T) {
157 if (T.isOSBinFormatMachO())
159 if (T.isOSBinFormatELF() || T.isArch64Bit())
161 assert(T.isOSBinFormatCOFF());
165 static const LayoutAlignElem DefaultAlignments[] = {
166 { INTEGER_ALIGN, 1, 1, 1 }, // i1
167 { INTEGER_ALIGN, 8, 1, 1 }, // i8
168 { INTEGER_ALIGN, 16, 2, 2 }, // i16
169 { INTEGER_ALIGN, 32, 4, 4 }, // i32
170 { INTEGER_ALIGN, 64, 4, 8 }, // i64
171 { FLOAT_ALIGN, 16, 2, 2 }, // half
172 { FLOAT_ALIGN, 32, 4, 4 }, // float
173 { FLOAT_ALIGN, 64, 8, 8 }, // double
174 { FLOAT_ALIGN, 128, 16, 16 }, // ppcf128, quad, ...
175 { VECTOR_ALIGN, 64, 8, 8 }, // v2i32, v1i64, ...
176 { VECTOR_ALIGN, 128, 16, 16 }, // v16i8, v8i16, v4i32, ...
177 { AGGREGATE_ALIGN, 0, 0, 8 } // struct
180 void DataLayout::init(StringRef Desc) {
181 initializeDataLayoutPass(*PassRegistry::getPassRegistry());
184 LittleEndian = false;
185 StackNaturalAlign = 0;
186 ManglingMode = MM_None;
188 // Default alignments
189 for (int I = 0, N = array_lengthof(DefaultAlignments); I < N; ++I) {
190 const LayoutAlignElem &E = DefaultAlignments[I];
191 setAlignment((AlignTypeEnum)E.AlignType, E.ABIAlign, E.PrefAlign,
194 setPointerAlignment(0, 8, 8, 8);
196 parseSpecifier(Desc);
199 /// Checked version of split, to ensure mandatory subparts.
200 static std::pair<StringRef, StringRef> split(StringRef Str, char Separator) {
201 assert(!Str.empty() && "parse error, string can't be empty here");
202 std::pair<StringRef, StringRef> Split = Str.split(Separator);
203 assert((!Split.second.empty() || Split.first == Str) &&
204 "a trailing separator is not allowed");
208 /// Get an unsigned integer, including error checks.
209 static unsigned getInt(StringRef R) {
211 bool error = R.getAsInteger(10, Result); (void)error;
213 report_fatal_error("not a number, or does not fit in an unsigned int");
217 /// Convert bits into bytes. Assert if not a byte width multiple.
218 static unsigned inBytes(unsigned Bits) {
219 assert(Bits % 8 == 0 && "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.
245 LittleEndian = false;
252 unsigned AddrSpace = Tok.empty() ? 0 : getInt(Tok);
253 assert(AddrSpace < 1 << 24 &&
254 "Invalid address space, must be a 24bit integer");
257 Split = split(Rest, ':');
258 unsigned PointerMemSize = inBytes(getInt(Tok));
261 Split = split(Rest, ':');
262 unsigned PointerABIAlign = inBytes(getInt(Tok));
264 // Preferred alignment.
265 unsigned PointerPrefAlign = PointerABIAlign;
267 Split = split(Rest, ':');
268 PointerPrefAlign = inBytes(getInt(Tok));
271 setPointerAlignment(AddrSpace, PointerABIAlign, PointerPrefAlign,
279 AlignTypeEnum AlignType;
282 case 'i': AlignType = INTEGER_ALIGN; break;
283 case 'v': AlignType = VECTOR_ALIGN; break;
284 case 'f': AlignType = FLOAT_ALIGN; break;
285 case 'a': AlignType = AGGREGATE_ALIGN; break;
289 unsigned Size = Tok.empty() ? 0 : getInt(Tok);
291 assert((AlignType != AGGREGATE_ALIGN || Size == 0) &&
292 "These specifications don't have a size");
295 Split = split(Rest, ':');
296 unsigned ABIAlign = inBytes(getInt(Tok));
298 // Preferred alignment.
299 unsigned PrefAlign = ABIAlign;
301 Split = split(Rest, ':');
302 PrefAlign = inBytes(getInt(Tok));
305 setAlignment(AlignType, ABIAlign, PrefAlign, Size);
309 case 'n': // Native integer types.
311 unsigned Width = getInt(Tok);
312 assert(Width != 0 && "width must be non-zero");
313 LegalIntWidths.push_back(Width);
316 Split = split(Rest, ':');
319 case 'S': { // Stack natural alignment.
320 StackNaturalAlign = inBytes(getInt(Tok));
325 assert(Rest.size() == 1);
328 llvm_unreachable("Unknown mangling in datalayout string");
330 ManglingMode = MM_ELF;
333 ManglingMode = MM_MachO;
336 ManglingMode = MM_Mips;
339 ManglingMode = MM_WINCOFF;
344 llvm_unreachable("Unknown specifier in datalayout string");
352 /// @note This has to exist, because this is a pass, but it should never be
354 DataLayout::DataLayout() : ImmutablePass(ID) {
355 report_fatal_error("Bad DataLayout ctor used. "
356 "Tool did not specify a DataLayout to use?");
359 DataLayout::DataLayout(const Module *M)
360 : ImmutablePass(ID) {
361 init(M->getDataLayout());
365 DataLayout::setAlignment(AlignTypeEnum align_type, unsigned abi_align,
366 unsigned pref_align, uint32_t bit_width) {
367 assert(abi_align <= pref_align && "Preferred alignment worse than ABI!");
368 assert(pref_align < (1 << 16) && "Alignment doesn't fit in bitfield");
369 assert(bit_width < (1 << 24) && "Bit width doesn't fit in bitfield");
370 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
371 if (Alignments[i].AlignType == (unsigned)align_type &&
372 Alignments[i].TypeBitWidth == bit_width) {
373 // Update the abi, preferred alignments.
374 Alignments[i].ABIAlign = abi_align;
375 Alignments[i].PrefAlign = pref_align;
380 Alignments.push_back(LayoutAlignElem::get(align_type, abi_align,
381 pref_align, bit_width));
384 void DataLayout::setPointerAlignment(uint32_t AddrSpace, unsigned ABIAlign,
386 uint32_t TypeByteWidth) {
387 assert(ABIAlign <= PrefAlign && "Preferred alignment worse than ABI!");
388 DenseMap<unsigned,PointerAlignElem>::iterator val = Pointers.find(AddrSpace);
389 if (val == Pointers.end()) {
390 Pointers[AddrSpace] =
391 PointerAlignElem::get(AddrSpace, ABIAlign, PrefAlign, TypeByteWidth);
393 val->second.ABIAlign = ABIAlign;
394 val->second.PrefAlign = PrefAlign;
395 val->second.TypeByteWidth = TypeByteWidth;
399 /// getAlignmentInfo - Return the alignment (either ABI if ABIInfo = true or
400 /// preferred if ABIInfo = false) the layout wants for the specified datatype.
401 unsigned DataLayout::getAlignmentInfo(AlignTypeEnum AlignType,
402 uint32_t BitWidth, bool ABIInfo,
404 // Check to see if we have an exact match and remember the best match we see.
405 int BestMatchIdx = -1;
407 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
408 if (Alignments[i].AlignType == (unsigned)AlignType &&
409 Alignments[i].TypeBitWidth == BitWidth)
410 return ABIInfo ? Alignments[i].ABIAlign : Alignments[i].PrefAlign;
412 // The best match so far depends on what we're looking for.
413 if (AlignType == INTEGER_ALIGN &&
414 Alignments[i].AlignType == INTEGER_ALIGN) {
415 // The "best match" for integers is the smallest size that is larger than
416 // the BitWidth requested.
417 if (Alignments[i].TypeBitWidth > BitWidth && (BestMatchIdx == -1 ||
418 Alignments[i].TypeBitWidth < Alignments[BestMatchIdx].TypeBitWidth))
420 // However, if there isn't one that's larger, then we must use the
421 // largest one we have (see below)
422 if (LargestInt == -1 ||
423 Alignments[i].TypeBitWidth > Alignments[LargestInt].TypeBitWidth)
428 // Okay, we didn't find an exact solution. Fall back here depending on what
429 // is being looked for.
430 if (BestMatchIdx == -1) {
431 // If we didn't find an integer alignment, fall back on most conservative.
432 if (AlignType == INTEGER_ALIGN) {
433 BestMatchIdx = LargestInt;
435 assert(AlignType == VECTOR_ALIGN && "Unknown alignment type!");
437 // By default, use natural alignment for vector types. This is consistent
438 // with what clang and llvm-gcc do.
439 unsigned Align = getTypeAllocSize(cast<VectorType>(Ty)->getElementType());
440 Align *= cast<VectorType>(Ty)->getNumElements();
441 // If the alignment is not a power of 2, round up to the next power of 2.
442 // This happens for non-power-of-2 length vectors.
443 if (Align & (Align-1))
444 Align = NextPowerOf2(Align);
449 // Since we got a "best match" index, just return it.
450 return ABIInfo ? Alignments[BestMatchIdx].ABIAlign
451 : Alignments[BestMatchIdx].PrefAlign;
456 class StructLayoutMap {
457 typedef DenseMap<StructType*, StructLayout*> LayoutInfoTy;
458 LayoutInfoTy LayoutInfo;
461 virtual ~StructLayoutMap() {
462 // Remove any layouts.
463 for (LayoutInfoTy::iterator I = LayoutInfo.begin(), E = LayoutInfo.end();
465 StructLayout *Value = I->second;
466 Value->~StructLayout();
471 StructLayout *&operator[](StructType *STy) {
472 return LayoutInfo[STy];
476 virtual void dump() const {}
479 } // end anonymous namespace
481 DataLayout::~DataLayout() {
482 delete static_cast<StructLayoutMap*>(LayoutMap);
485 bool DataLayout::doFinalization(Module &M) {
486 delete static_cast<StructLayoutMap*>(LayoutMap);
491 const StructLayout *DataLayout::getStructLayout(StructType *Ty) const {
493 LayoutMap = new StructLayoutMap();
495 StructLayoutMap *STM = static_cast<StructLayoutMap*>(LayoutMap);
496 StructLayout *&SL = (*STM)[Ty];
499 // Otherwise, create the struct layout. Because it is variable length, we
500 // malloc it, then use placement new.
501 int NumElts = Ty->getNumElements();
503 (StructLayout *)malloc(sizeof(StructLayout)+(NumElts-1) * sizeof(uint64_t));
505 // Set SL before calling StructLayout's ctor. The ctor could cause other
506 // entries to be added to TheMap, invalidating our reference.
509 new (L) StructLayout(Ty, *this);
514 std::string DataLayout::getStringRepresentation() const {
516 raw_string_ostream OS(Result);
518 OS << (LittleEndian ? "e" : "E");
520 switch (ManglingMode) {
537 SmallVector<unsigned, 8> addrSpaces;
538 // Lets get all of the known address spaces and sort them
539 // into increasing order so that we can emit the string
540 // in a cleaner format.
541 for (DenseMap<unsigned, PointerAlignElem>::const_iterator
542 pib = Pointers.begin(), pie = Pointers.end();
544 addrSpaces.push_back(pib->first);
546 std::sort(addrSpaces.begin(), addrSpaces.end());
547 for (SmallVectorImpl<unsigned>::iterator asb = addrSpaces.begin(),
548 ase = addrSpaces.end(); asb != ase; ++asb) {
549 const PointerAlignElem &PI = Pointers.find(*asb)->second;
552 if (PI.AddressSpace == 0 && PI.ABIAlign == 8 && PI.PrefAlign == 8 &&
553 PI.TypeByteWidth == 8)
557 if (PI.AddressSpace) {
558 OS << PI.AddressSpace;
560 OS << ":" << PI.TypeByteWidth*8 << ':' << PI.ABIAlign*8;
561 if (PI.PrefAlign != PI.ABIAlign)
562 OS << ':' << PI.PrefAlign*8;
565 const LayoutAlignElem *DefaultStart = DefaultAlignments;
566 const LayoutAlignElem *DefaultEnd =
567 DefaultStart + array_lengthof(DefaultAlignments);
568 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
569 const LayoutAlignElem &AI = Alignments[i];
570 if (std::find(DefaultStart, DefaultEnd, AI) != DefaultEnd)
572 OS << '-' << (char)AI.AlignType;
574 OS << AI.TypeBitWidth;
575 OS << ':' << AI.ABIAlign*8;
576 if (AI.ABIAlign != AI.PrefAlign)
577 OS << ':' << AI.PrefAlign*8;
580 if (!LegalIntWidths.empty()) {
581 OS << "-n" << (unsigned)LegalIntWidths[0];
583 for (unsigned i = 1, e = LegalIntWidths.size(); i != e; ++i)
584 OS << ':' << (unsigned)LegalIntWidths[i];
587 if (StackNaturalAlign)
588 OS << "-S" << StackNaturalAlign*8;
593 unsigned DataLayout::getPointerTypeSizeInBits(Type *Ty) const {
594 assert(Ty->isPtrOrPtrVectorTy() &&
595 "This should only be called with a pointer or pointer vector type");
597 if (Ty->isPointerTy())
598 return getTypeSizeInBits(Ty);
600 return getTypeSizeInBits(Ty->getScalarType());
604 \param abi_or_pref Flag that determines which alignment is returned. true
605 returns the ABI alignment, false returns the preferred alignment.
606 \param Ty The underlying type for which alignment is determined.
608 Get the ABI (\a abi_or_pref == true) or preferred alignment (\a abi_or_pref
609 == false) for the requested type \a Ty.
611 unsigned DataLayout::getAlignment(Type *Ty, bool abi_or_pref) const {
614 assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
615 switch (Ty->getTypeID()) {
616 // Early escape for the non-numeric types.
617 case Type::LabelTyID:
619 ? getPointerABIAlignment(0)
620 : getPointerPrefAlignment(0));
621 case Type::PointerTyID: {
622 unsigned AS = dyn_cast<PointerType>(Ty)->getAddressSpace();
624 ? getPointerABIAlignment(AS)
625 : getPointerPrefAlignment(AS));
627 case Type::ArrayTyID:
628 return getAlignment(cast<ArrayType>(Ty)->getElementType(), abi_or_pref);
630 case Type::StructTyID: {
631 // Packed structure types always have an ABI alignment of one.
632 if (cast<StructType>(Ty)->isPacked() && abi_or_pref)
635 // Get the layout annotation... which is lazily created on demand.
636 const StructLayout *Layout = getStructLayout(cast<StructType>(Ty));
637 unsigned Align = getAlignmentInfo(AGGREGATE_ALIGN, 0, abi_or_pref, Ty);
638 return std::max(Align, Layout->getAlignment());
640 case Type::IntegerTyID:
641 AlignType = INTEGER_ALIGN;
644 case Type::FloatTyID:
645 case Type::DoubleTyID:
646 // PPC_FP128TyID and FP128TyID have different data contents, but the
647 // same size and alignment, so they look the same here.
648 case Type::PPC_FP128TyID:
649 case Type::FP128TyID:
650 case Type::X86_FP80TyID:
651 AlignType = FLOAT_ALIGN;
653 case Type::X86_MMXTyID:
654 case Type::VectorTyID:
655 AlignType = VECTOR_ALIGN;
658 llvm_unreachable("Bad type for getAlignment!!!");
661 return getAlignmentInfo((AlignTypeEnum)AlignType, getTypeSizeInBits(Ty),
665 unsigned DataLayout::getABITypeAlignment(Type *Ty) const {
666 return getAlignment(Ty, true);
669 /// getABIIntegerTypeAlignment - Return the minimum ABI-required alignment for
670 /// an integer type of the specified bitwidth.
671 unsigned DataLayout::getABIIntegerTypeAlignment(unsigned BitWidth) const {
672 return getAlignmentInfo(INTEGER_ALIGN, BitWidth, true, 0);
675 unsigned DataLayout::getPrefTypeAlignment(Type *Ty) const {
676 return getAlignment(Ty, false);
679 unsigned DataLayout::getPreferredTypeAlignmentShift(Type *Ty) const {
680 unsigned Align = getPrefTypeAlignment(Ty);
681 assert(!(Align & (Align-1)) && "Alignment is not a power of two!");
682 return Log2_32(Align);
685 IntegerType *DataLayout::getIntPtrType(LLVMContext &C,
686 unsigned AddressSpace) const {
687 return IntegerType::get(C, getPointerSizeInBits(AddressSpace));
690 Type *DataLayout::getIntPtrType(Type *Ty) const {
691 assert(Ty->isPtrOrPtrVectorTy() &&
692 "Expected a pointer or pointer vector type.");
693 unsigned NumBits = getTypeSizeInBits(Ty->getScalarType());
694 IntegerType *IntTy = IntegerType::get(Ty->getContext(), NumBits);
695 if (VectorType *VecTy = dyn_cast<VectorType>(Ty))
696 return VectorType::get(IntTy, VecTy->getNumElements());
700 Type *DataLayout::getSmallestLegalIntType(LLVMContext &C, unsigned Width) const {
701 for (unsigned i = 0, e = (unsigned)LegalIntWidths.size(); i != e; ++i)
702 if (Width <= LegalIntWidths[i])
703 return Type::getIntNTy(C, LegalIntWidths[i]);
707 unsigned DataLayout::getLargestLegalIntTypeSize() const {
708 unsigned MaxWidth = 0;
709 for (unsigned i = 0, e = (unsigned)LegalIntWidths.size(); i != e; ++i)
710 MaxWidth = std::max<unsigned>(MaxWidth, LegalIntWidths[i]);
714 uint64_t DataLayout::getIndexedOffset(Type *ptrTy,
715 ArrayRef<Value *> Indices) const {
717 assert(Ty->isPointerTy() && "Illegal argument for getIndexedOffset()");
720 generic_gep_type_iterator<Value* const*>
721 TI = gep_type_begin(ptrTy, Indices);
722 for (unsigned CurIDX = 0, EndIDX = Indices.size(); CurIDX != EndIDX;
724 if (StructType *STy = dyn_cast<StructType>(*TI)) {
725 assert(Indices[CurIDX]->getType() ==
726 Type::getInt32Ty(ptrTy->getContext()) &&
727 "Illegal struct idx");
728 unsigned FieldNo = cast<ConstantInt>(Indices[CurIDX])->getZExtValue();
730 // Get structure layout information...
731 const StructLayout *Layout = getStructLayout(STy);
733 // Add in the offset, as calculated by the structure layout info...
734 Result += Layout->getElementOffset(FieldNo);
736 // Update Ty to refer to current element
737 Ty = STy->getElementType(FieldNo);
739 // Update Ty to refer to current element
740 Ty = cast<SequentialType>(Ty)->getElementType();
742 // Get the array index and the size of each array element.
743 if (int64_t arrayIdx = cast<ConstantInt>(Indices[CurIDX])->getSExtValue())
744 Result += (uint64_t)arrayIdx * getTypeAllocSize(Ty);
751 /// getPreferredAlignment - Return the preferred alignment of the specified
752 /// global. This includes an explicitly requested alignment (if the global
754 unsigned DataLayout::getPreferredAlignment(const GlobalVariable *GV) const {
755 Type *ElemType = GV->getType()->getElementType();
756 unsigned Alignment = getPrefTypeAlignment(ElemType);
757 unsigned GVAlignment = GV->getAlignment();
758 if (GVAlignment >= Alignment) {
759 Alignment = GVAlignment;
760 } else if (GVAlignment != 0) {
761 Alignment = std::max(GVAlignment, getABITypeAlignment(ElemType));
764 if (GV->hasInitializer() && GVAlignment == 0) {
765 if (Alignment < 16) {
766 // If the global is not external, see if it is large. If so, give it a
768 if (getTypeSizeInBits(ElemType) > 128)
769 Alignment = 16; // 16-byte alignment.
775 /// getPreferredAlignmentLog - Return the preferred alignment of the
776 /// specified global, returned in log form. This includes an explicitly
777 /// requested alignment (if the global has one).
778 unsigned DataLayout::getPreferredAlignmentLog(const GlobalVariable *GV) const {
779 return Log2_32(getPreferredAlignment(GV));