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 //===----------------------------------------------------------------------===//
37 // Support for StructLayout
38 //===----------------------------------------------------------------------===//
40 StructLayout::StructLayout(StructType *ST, const DataLayout &DL) {
41 assert(!ST->isOpaque() && "Cannot get layout of opaque structs");
45 NumElements = ST->getNumElements();
47 // Loop over each of the elements, placing them in memory.
48 for (unsigned i = 0, e = NumElements; i != e; ++i) {
49 Type *Ty = ST->getElementType(i);
50 unsigned TyAlign = ST->isPacked() ? 1 : DL.getABITypeAlignment(Ty);
52 // Add padding if necessary to align the data element properly.
53 if ((StructSize & (TyAlign-1)) != 0) {
55 StructSize = alignTo(StructSize, TyAlign);
58 // Keep track of maximum alignment constraint.
59 StructAlignment = std::max(TyAlign, StructAlignment);
61 MemberOffsets[i] = StructSize;
62 StructSize += DL.getTypeAllocSize(Ty); // Consume space for this data item
65 // Empty structures have alignment of 1 byte.
66 if (StructAlignment == 0) StructAlignment = 1;
68 // Add padding to the end of the struct so that it could be put in an array
69 // and all array elements would be aligned correctly.
70 if ((StructSize & (StructAlignment-1)) != 0) {
72 StructSize = alignTo(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.isOSBinFormatCOFF())
159 return T.getArch() == Triple::x86 ? "-m:x" : "-m:w";
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;
185 NonIntegralAddressSpaces.clear();
187 // Default alignments
188 for (const LayoutAlignElem &E : DefaultAlignments) {
189 setAlignment((AlignTypeEnum)E.AlignType, E.ABIAlign, E.PrefAlign,
192 setPointerAlignment(0, 8, 8, 8);
194 parseSpecifier(Desc);
197 /// Checked version of split, to ensure mandatory subparts.
198 static std::pair<StringRef, StringRef> split(StringRef Str, char Separator) {
199 assert(!Str.empty() && "parse error, string can't be empty here");
200 std::pair<StringRef, StringRef> Split = Str.split(Separator);
201 if (Split.second.empty() && Split.first != Str)
202 report_fatal_error("Trailing separator in datalayout string");
203 if (!Split.second.empty() && Split.first.empty())
204 report_fatal_error("Expected token before separator in datalayout string");
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) {
220 report_fatal_error("number of bits must be a byte width multiple");
224 void DataLayout::parseSpecifier(StringRef Desc) {
225 StringRepresentation = Desc;
226 while (!Desc.empty()) {
228 std::pair<StringRef, StringRef> Split = split(Desc, '-');
232 Split = split(Split.first, ':');
234 // Aliases used below.
235 StringRef &Tok = Split.first; // Current token.
236 StringRef &Rest = Split.second; // The rest of the string.
240 Split = split(Rest, ':');
242 unsigned AS = getInt(Split.first);
244 report_fatal_error("Address space 0 can never be non-integral");
245 NonIntegralAddressSpaces.push_back(AS);
246 } while (!Rest.empty());
251 char Specifier = Tok.front();
256 // Ignored for backward compatibility.
257 // FIXME: remove this on LLVM 4.0.
267 unsigned AddrSpace = Tok.empty() ? 0 : getInt(Tok);
268 if (!isUInt<24>(AddrSpace))
269 report_fatal_error("Invalid address space, must be a 24bit integer");
274 "Missing size specification for pointer in datalayout string");
275 Split = split(Rest, ':');
276 unsigned PointerMemSize = inBytes(getInt(Tok));
278 report_fatal_error("Invalid pointer size of 0 bytes");
283 "Missing alignment specification for pointer in datalayout string");
284 Split = split(Rest, ':');
285 unsigned PointerABIAlign = inBytes(getInt(Tok));
286 if (!isPowerOf2_64(PointerABIAlign))
288 "Pointer ABI alignment must be a power of 2");
290 // Preferred alignment.
291 unsigned PointerPrefAlign = PointerABIAlign;
293 Split = split(Rest, ':');
294 PointerPrefAlign = inBytes(getInt(Tok));
295 if (!isPowerOf2_64(PointerPrefAlign))
297 "Pointer preferred alignment must be a power of 2");
300 setPointerAlignment(AddrSpace, PointerABIAlign, PointerPrefAlign,
308 AlignTypeEnum AlignType;
311 case 'i': AlignType = INTEGER_ALIGN; break;
312 case 'v': AlignType = VECTOR_ALIGN; break;
313 case 'f': AlignType = FLOAT_ALIGN; break;
314 case 'a': AlignType = AGGREGATE_ALIGN; break;
318 unsigned Size = Tok.empty() ? 0 : getInt(Tok);
320 if (AlignType == AGGREGATE_ALIGN && Size != 0)
322 "Sized aggregate specification in datalayout string");
327 "Missing alignment specification in datalayout string");
328 Split = split(Rest, ':');
329 unsigned ABIAlign = inBytes(getInt(Tok));
330 if (AlignType != AGGREGATE_ALIGN && !ABIAlign)
332 "ABI alignment specification must be >0 for non-aggregate types");
334 // Preferred alignment.
335 unsigned PrefAlign = ABIAlign;
337 Split = split(Rest, ':');
338 PrefAlign = inBytes(getInt(Tok));
341 setAlignment(AlignType, ABIAlign, PrefAlign, Size);
345 case 'n': // Native integer types.
347 unsigned Width = getInt(Tok);
350 "Zero width native integer type in datalayout string");
351 LegalIntWidths.push_back(Width);
354 Split = split(Rest, ':');
357 case 'S': { // Stack natural alignment.
358 StackNaturalAlign = inBytes(getInt(Tok));
363 report_fatal_error("Unexpected trailing characters after mangling specifier in datalayout string");
365 report_fatal_error("Expected mangling specifier in datalayout string");
367 report_fatal_error("Unknown mangling specifier in datalayout string");
370 report_fatal_error("Unknown mangling in datalayout string");
372 ManglingMode = MM_ELF;
375 ManglingMode = MM_MachO;
378 ManglingMode = MM_Mips;
381 ManglingMode = MM_WinCOFF;
384 ManglingMode = MM_WinCOFFX86;
389 report_fatal_error("Unknown specifier in datalayout string");
395 DataLayout::DataLayout(const Module *M) : LayoutMap(nullptr) {
399 void DataLayout::init(const Module *M) { *this = M->getDataLayout(); }
401 bool DataLayout::operator==(const DataLayout &Other) const {
402 bool Ret = BigEndian == Other.BigEndian &&
403 StackNaturalAlign == Other.StackNaturalAlign &&
404 ManglingMode == Other.ManglingMode &&
405 LegalIntWidths == Other.LegalIntWidths &&
406 Alignments == Other.Alignments && Pointers == Other.Pointers;
407 // Note: getStringRepresentation() might differs, it is not canonicalized
412 DataLayout::setAlignment(AlignTypeEnum align_type, unsigned abi_align,
413 unsigned pref_align, uint32_t bit_width) {
414 if (!isUInt<24>(bit_width))
415 report_fatal_error("Invalid bit width, must be a 24bit integer");
416 if (!isUInt<16>(abi_align))
417 report_fatal_error("Invalid ABI alignment, must be a 16bit integer");
418 if (!isUInt<16>(pref_align))
419 report_fatal_error("Invalid preferred alignment, must be a 16bit integer");
420 if (abi_align != 0 && !isPowerOf2_64(abi_align))
421 report_fatal_error("Invalid ABI alignment, must be a power of 2");
422 if (pref_align != 0 && !isPowerOf2_64(pref_align))
423 report_fatal_error("Invalid preferred alignment, must be a power of 2");
425 if (pref_align < abi_align)
427 "Preferred alignment cannot be less than the ABI alignment");
429 for (LayoutAlignElem &Elem : Alignments) {
430 if (Elem.AlignType == (unsigned)align_type &&
431 Elem.TypeBitWidth == bit_width) {
432 // Update the abi, preferred alignments.
433 Elem.ABIAlign = abi_align;
434 Elem.PrefAlign = pref_align;
439 Alignments.push_back(LayoutAlignElem::get(align_type, abi_align,
440 pref_align, bit_width));
443 DataLayout::PointersTy::iterator
444 DataLayout::findPointerLowerBound(uint32_t AddressSpace) {
445 return std::lower_bound(Pointers.begin(), Pointers.end(), AddressSpace,
446 [](const PointerAlignElem &A, uint32_t AddressSpace) {
447 return A.AddressSpace < AddressSpace;
451 void DataLayout::setPointerAlignment(uint32_t AddrSpace, unsigned ABIAlign,
453 uint32_t TypeByteWidth) {
454 if (PrefAlign < ABIAlign)
456 "Preferred alignment cannot be less than the ABI alignment");
458 PointersTy::iterator I = findPointerLowerBound(AddrSpace);
459 if (I == Pointers.end() || I->AddressSpace != AddrSpace) {
460 Pointers.insert(I, PointerAlignElem::get(AddrSpace, ABIAlign, PrefAlign,
463 I->ABIAlign = ABIAlign;
464 I->PrefAlign = PrefAlign;
465 I->TypeByteWidth = TypeByteWidth;
469 /// getAlignmentInfo - Return the alignment (either ABI if ABIInfo = true or
470 /// preferred if ABIInfo = false) the layout wants for the specified datatype.
471 unsigned DataLayout::getAlignmentInfo(AlignTypeEnum AlignType,
472 uint32_t BitWidth, bool ABIInfo,
474 // Check to see if we have an exact match and remember the best match we see.
475 int BestMatchIdx = -1;
477 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
478 if (Alignments[i].AlignType == (unsigned)AlignType &&
479 Alignments[i].TypeBitWidth == BitWidth)
480 return ABIInfo ? Alignments[i].ABIAlign : Alignments[i].PrefAlign;
482 // The best match so far depends on what we're looking for.
483 if (AlignType == INTEGER_ALIGN &&
484 Alignments[i].AlignType == INTEGER_ALIGN) {
485 // The "best match" for integers is the smallest size that is larger than
486 // the BitWidth requested.
487 if (Alignments[i].TypeBitWidth > BitWidth && (BestMatchIdx == -1 ||
488 Alignments[i].TypeBitWidth < Alignments[BestMatchIdx].TypeBitWidth))
490 // However, if there isn't one that's larger, then we must use the
491 // largest one we have (see below)
492 if (LargestInt == -1 ||
493 Alignments[i].TypeBitWidth > Alignments[LargestInt].TypeBitWidth)
498 // Okay, we didn't find an exact solution. Fall back here depending on what
499 // is being looked for.
500 if (BestMatchIdx == -1) {
501 // If we didn't find an integer alignment, fall back on most conservative.
502 if (AlignType == INTEGER_ALIGN) {
503 BestMatchIdx = LargestInt;
504 } else if (AlignType == VECTOR_ALIGN) {
505 // By default, use natural alignment for vector types. This is consistent
506 // with what clang and llvm-gcc do.
507 unsigned Align = getTypeAllocSize(cast<VectorType>(Ty)->getElementType());
508 Align *= cast<VectorType>(Ty)->getNumElements();
509 Align = PowerOf2Ceil(Align);
514 // If we still couldn't find a reasonable default alignment, fall back
515 // to a simple heuristic that the alignment is the first power of two
516 // greater-or-equal to the store size of the type. This is a reasonable
517 // approximation of reality, and if the user wanted something less
518 // less conservative, they should have specified it explicitly in the data
520 if (BestMatchIdx == -1) {
521 unsigned Align = getTypeStoreSize(Ty);
522 Align = PowerOf2Ceil(Align);
526 // Since we got a "best match" index, just return it.
527 return ABIInfo ? Alignments[BestMatchIdx].ABIAlign
528 : Alignments[BestMatchIdx].PrefAlign;
533 class StructLayoutMap {
534 typedef DenseMap<StructType*, StructLayout*> LayoutInfoTy;
535 LayoutInfoTy LayoutInfo;
539 // Remove any layouts.
540 for (const auto &I : LayoutInfo) {
541 StructLayout *Value = I.second;
542 Value->~StructLayout();
547 StructLayout *&operator[](StructType *STy) {
548 return LayoutInfo[STy];
552 } // end anonymous namespace
554 void DataLayout::clear() {
555 LegalIntWidths.clear();
558 delete static_cast<StructLayoutMap *>(LayoutMap);
562 DataLayout::~DataLayout() {
566 const StructLayout *DataLayout::getStructLayout(StructType *Ty) const {
568 LayoutMap = new StructLayoutMap();
570 StructLayoutMap *STM = static_cast<StructLayoutMap*>(LayoutMap);
571 StructLayout *&SL = (*STM)[Ty];
574 // Otherwise, create the struct layout. Because it is variable length, we
575 // malloc it, then use placement new.
576 int NumElts = Ty->getNumElements();
578 (StructLayout *)malloc(sizeof(StructLayout)+(NumElts-1) * sizeof(uint64_t));
580 // Set SL before calling StructLayout's ctor. The ctor could cause other
581 // entries to be added to TheMap, invalidating our reference.
584 new (L) StructLayout(Ty, *this);
590 unsigned DataLayout::getPointerABIAlignment(unsigned AS) const {
591 PointersTy::const_iterator I = findPointerLowerBound(AS);
592 if (I == Pointers.end() || I->AddressSpace != AS) {
593 I = findPointerLowerBound(0);
594 assert(I->AddressSpace == 0);
599 unsigned DataLayout::getPointerPrefAlignment(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::getPointerSize(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);
614 return I->TypeByteWidth;
617 unsigned DataLayout::getPointerTypeSizeInBits(Type *Ty) const {
618 assert(Ty->isPtrOrPtrVectorTy() &&
619 "This should only be called with a pointer or pointer vector type");
621 if (Ty->isPointerTy())
622 return getTypeSizeInBits(Ty);
624 return getTypeSizeInBits(Ty->getScalarType());
628 \param abi_or_pref Flag that determines which alignment is returned. true
629 returns the ABI alignment, false returns the preferred alignment.
630 \param Ty The underlying type for which alignment is determined.
632 Get the ABI (\a abi_or_pref == true) or preferred alignment (\a abi_or_pref
633 == false) for the requested type \a Ty.
635 unsigned DataLayout::getAlignment(Type *Ty, bool abi_or_pref) const {
638 assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
639 switch (Ty->getTypeID()) {
640 // Early escape for the non-numeric types.
641 case Type::LabelTyID:
643 ? getPointerABIAlignment(0)
644 : getPointerPrefAlignment(0));
645 case Type::PointerTyID: {
646 unsigned AS = cast<PointerType>(Ty)->getAddressSpace();
648 ? getPointerABIAlignment(AS)
649 : getPointerPrefAlignment(AS));
651 case Type::ArrayTyID:
652 return getAlignment(cast<ArrayType>(Ty)->getElementType(), abi_or_pref);
654 case Type::StructTyID: {
655 // Packed structure types always have an ABI alignment of one.
656 if (cast<StructType>(Ty)->isPacked() && abi_or_pref)
659 // Get the layout annotation... which is lazily created on demand.
660 const StructLayout *Layout = getStructLayout(cast<StructType>(Ty));
661 unsigned Align = getAlignmentInfo(AGGREGATE_ALIGN, 0, abi_or_pref, Ty);
662 return std::max(Align, Layout->getAlignment());
664 case Type::IntegerTyID:
665 AlignType = INTEGER_ALIGN;
668 case Type::FloatTyID:
669 case Type::DoubleTyID:
670 // PPC_FP128TyID and FP128TyID have different data contents, but the
671 // same size and alignment, so they look the same here.
672 case Type::PPC_FP128TyID:
673 case Type::FP128TyID:
674 case Type::X86_FP80TyID:
675 AlignType = FLOAT_ALIGN;
677 case Type::X86_MMXTyID:
678 case Type::VectorTyID:
679 AlignType = VECTOR_ALIGN;
682 llvm_unreachable("Bad type for getAlignment!!!");
685 return getAlignmentInfo((AlignTypeEnum)AlignType, getTypeSizeInBits(Ty),
689 unsigned DataLayout::getABITypeAlignment(Type *Ty) const {
690 return getAlignment(Ty, true);
693 /// getABIIntegerTypeAlignment - Return the minimum ABI-required alignment for
694 /// an integer type of the specified bitwidth.
695 unsigned DataLayout::getABIIntegerTypeAlignment(unsigned BitWidth) const {
696 return getAlignmentInfo(INTEGER_ALIGN, BitWidth, true, nullptr);
699 unsigned DataLayout::getPrefTypeAlignment(Type *Ty) const {
700 return getAlignment(Ty, false);
703 unsigned DataLayout::getPreferredTypeAlignmentShift(Type *Ty) const {
704 unsigned Align = getPrefTypeAlignment(Ty);
705 assert(!(Align & (Align-1)) && "Alignment is not a power of two!");
706 return Log2_32(Align);
709 IntegerType *DataLayout::getIntPtrType(LLVMContext &C,
710 unsigned AddressSpace) const {
711 return IntegerType::get(C, getPointerSizeInBits(AddressSpace));
714 Type *DataLayout::getIntPtrType(Type *Ty) const {
715 assert(Ty->isPtrOrPtrVectorTy() &&
716 "Expected a pointer or pointer vector type.");
717 unsigned NumBits = getPointerTypeSizeInBits(Ty);
718 IntegerType *IntTy = IntegerType::get(Ty->getContext(), NumBits);
719 if (VectorType *VecTy = dyn_cast<VectorType>(Ty))
720 return VectorType::get(IntTy, VecTy->getNumElements());
724 Type *DataLayout::getSmallestLegalIntType(LLVMContext &C, unsigned Width) const {
725 for (unsigned LegalIntWidth : LegalIntWidths)
726 if (Width <= LegalIntWidth)
727 return Type::getIntNTy(C, LegalIntWidth);
731 unsigned DataLayout::getLargestLegalIntTypeSizeInBits() const {
732 auto Max = std::max_element(LegalIntWidths.begin(), LegalIntWidths.end());
733 return Max != LegalIntWidths.end() ? *Max : 0;
736 int64_t DataLayout::getIndexedOffsetInType(Type *ElemTy,
737 ArrayRef<Value *> Indices) const {
740 generic_gep_type_iterator<Value* const*>
741 GTI = gep_type_begin(ElemTy, Indices),
742 GTE = gep_type_end(ElemTy, Indices);
743 for (; GTI != GTE; ++GTI) {
744 Value *Idx = GTI.getOperand();
745 if (StructType *STy = GTI.getStructTypeOrNull()) {
746 assert(Idx->getType()->isIntegerTy(32) && "Illegal struct idx");
747 unsigned FieldNo = cast<ConstantInt>(Idx)->getZExtValue();
749 // Get structure layout information...
750 const StructLayout *Layout = getStructLayout(STy);
752 // Add in the offset, as calculated by the structure layout info...
753 Result += Layout->getElementOffset(FieldNo);
755 // Get the array index and the size of each array element.
756 if (int64_t arrayIdx = cast<ConstantInt>(Idx)->getSExtValue())
757 Result += arrayIdx * getTypeAllocSize(GTI.getIndexedType());
764 /// getPreferredAlignment - Return the preferred alignment of the specified
765 /// global. This includes an explicitly requested alignment (if the global
767 unsigned DataLayout::getPreferredAlignment(const GlobalVariable *GV) const {
768 Type *ElemType = GV->getValueType();
769 unsigned Alignment = getPrefTypeAlignment(ElemType);
770 unsigned GVAlignment = GV->getAlignment();
771 if (GVAlignment >= Alignment) {
772 Alignment = GVAlignment;
773 } else if (GVAlignment != 0) {
774 Alignment = std::max(GVAlignment, getABITypeAlignment(ElemType));
777 if (GV->hasInitializer() && GVAlignment == 0) {
778 if (Alignment < 16) {
779 // If the global is not external, see if it is large. If so, give it a
781 if (getTypeSizeInBits(ElemType) > 128)
782 Alignment = 16; // 16-byte alignment.
788 /// getPreferredAlignmentLog - Return the preferred alignment of the
789 /// specified global, returned in log form. This includes an explicitly
790 /// requested alignment (if the global has one).
791 unsigned DataLayout::getPreferredAlignmentLog(const GlobalVariable *GV) const {
792 return Log2_32(getPreferredAlignment(GV));