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::init(StringRef Desc) {
181 LittleEndian = false;
182 StackNaturalAlign = 0;
183 ManglingMode = MM_None;
185 // Default alignments
186 for (int I = 0, N = array_lengthof(DefaultAlignments); I < N; ++I) {
187 const LayoutAlignElem &E = DefaultAlignments[I];
188 setAlignment((AlignTypeEnum)E.AlignType, E.ABIAlign, E.PrefAlign,
191 setPointerAlignment(0, 8, 8, 8);
193 parseSpecifier(Desc);
196 /// Checked version of split, to ensure mandatory subparts.
197 static std::pair<StringRef, StringRef> split(StringRef Str, char Separator) {
198 assert(!Str.empty() && "parse error, string can't be empty here");
199 std::pair<StringRef, StringRef> Split = Str.split(Separator);
200 assert((!Split.second.empty() || Split.first == Str) &&
201 "a trailing separator is not allowed");
205 /// Get an unsigned integer, including error checks.
206 static unsigned getInt(StringRef R) {
208 bool error = R.getAsInteger(10, Result); (void)error;
210 report_fatal_error("not a number, or does not fit in an unsigned int");
214 /// Convert bits into bytes. Assert if not a byte width multiple.
215 static unsigned inBytes(unsigned Bits) {
216 assert(Bits % 8 == 0 && "number of bits must be a byte width multiple");
220 void DataLayout::parseSpecifier(StringRef Desc) {
221 while (!Desc.empty()) {
223 std::pair<StringRef, StringRef> Split = split(Desc, '-');
227 Split = split(Split.first, ':');
229 // Aliases used below.
230 StringRef &Tok = Split.first; // Current token.
231 StringRef &Rest = Split.second; // The rest of the string.
233 char Specifier = Tok.front();
238 // Ignored for backward compatibility.
239 // FIXME: remove this on LLVM 4.0.
242 LittleEndian = false;
249 unsigned AddrSpace = Tok.empty() ? 0 : getInt(Tok);
250 assert(AddrSpace < 1 << 24 &&
251 "Invalid address space, must be a 24bit integer");
254 Split = split(Rest, ':');
255 unsigned PointerMemSize = inBytes(getInt(Tok));
258 Split = split(Rest, ':');
259 unsigned PointerABIAlign = inBytes(getInt(Tok));
261 // Preferred alignment.
262 unsigned PointerPrefAlign = PointerABIAlign;
264 Split = split(Rest, ':');
265 PointerPrefAlign = inBytes(getInt(Tok));
268 setPointerAlignment(AddrSpace, PointerABIAlign, PointerPrefAlign,
276 AlignTypeEnum AlignType;
279 case 'i': AlignType = INTEGER_ALIGN; break;
280 case 'v': AlignType = VECTOR_ALIGN; break;
281 case 'f': AlignType = FLOAT_ALIGN; break;
282 case 'a': AlignType = AGGREGATE_ALIGN; break;
286 unsigned Size = Tok.empty() ? 0 : getInt(Tok);
288 assert((AlignType != AGGREGATE_ALIGN || Size == 0) &&
289 "These specifications don't have a size");
292 Split = split(Rest, ':');
293 unsigned ABIAlign = inBytes(getInt(Tok));
295 // Preferred alignment.
296 unsigned PrefAlign = ABIAlign;
298 Split = split(Rest, ':');
299 PrefAlign = inBytes(getInt(Tok));
302 setAlignment(AlignType, ABIAlign, PrefAlign, Size);
306 case 'n': // Native integer types.
308 unsigned Width = getInt(Tok);
309 assert(Width != 0 && "width must be non-zero");
310 LegalIntWidths.push_back(Width);
313 Split = split(Rest, ':');
316 case 'S': { // Stack natural alignment.
317 StackNaturalAlign = inBytes(getInt(Tok));
322 assert(Rest.size() == 1);
325 llvm_unreachable("Unknown mangling in datalayout string");
327 ManglingMode = MM_ELF;
330 ManglingMode = MM_MachO;
333 ManglingMode = MM_Mips;
336 ManglingMode = MM_WINCOFF;
341 llvm_unreachable("Unknown specifier in datalayout string");
347 DataLayout::DataLayout(const Module *M) { init(M->getDataLayout()); }
350 DataLayout::setAlignment(AlignTypeEnum align_type, unsigned abi_align,
351 unsigned pref_align, uint32_t bit_width) {
352 assert(abi_align <= pref_align && "Preferred alignment worse than ABI!");
353 assert(pref_align < (1 << 16) && "Alignment doesn't fit in bitfield");
354 assert(bit_width < (1 << 24) && "Bit width doesn't fit in bitfield");
355 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
356 if (Alignments[i].AlignType == (unsigned)align_type &&
357 Alignments[i].TypeBitWidth == bit_width) {
358 // Update the abi, preferred alignments.
359 Alignments[i].ABIAlign = abi_align;
360 Alignments[i].PrefAlign = pref_align;
365 Alignments.push_back(LayoutAlignElem::get(align_type, abi_align,
366 pref_align, bit_width));
369 void DataLayout::setPointerAlignment(uint32_t AddrSpace, unsigned ABIAlign,
371 uint32_t TypeByteWidth) {
372 assert(ABIAlign <= PrefAlign && "Preferred alignment worse than ABI!");
373 DenseMap<unsigned,PointerAlignElem>::iterator val = Pointers.find(AddrSpace);
374 if (val == Pointers.end()) {
375 Pointers[AddrSpace] =
376 PointerAlignElem::get(AddrSpace, ABIAlign, PrefAlign, TypeByteWidth);
378 val->second.ABIAlign = ABIAlign;
379 val->second.PrefAlign = PrefAlign;
380 val->second.TypeByteWidth = TypeByteWidth;
384 /// getAlignmentInfo - Return the alignment (either ABI if ABIInfo = true or
385 /// preferred if ABIInfo = false) the layout wants for the specified datatype.
386 unsigned DataLayout::getAlignmentInfo(AlignTypeEnum AlignType,
387 uint32_t BitWidth, bool ABIInfo,
389 // Check to see if we have an exact match and remember the best match we see.
390 int BestMatchIdx = -1;
392 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
393 if (Alignments[i].AlignType == (unsigned)AlignType &&
394 Alignments[i].TypeBitWidth == BitWidth)
395 return ABIInfo ? Alignments[i].ABIAlign : Alignments[i].PrefAlign;
397 // The best match so far depends on what we're looking for.
398 if (AlignType == INTEGER_ALIGN &&
399 Alignments[i].AlignType == INTEGER_ALIGN) {
400 // The "best match" for integers is the smallest size that is larger than
401 // the BitWidth requested.
402 if (Alignments[i].TypeBitWidth > BitWidth && (BestMatchIdx == -1 ||
403 Alignments[i].TypeBitWidth < Alignments[BestMatchIdx].TypeBitWidth))
405 // However, if there isn't one that's larger, then we must use the
406 // largest one we have (see below)
407 if (LargestInt == -1 ||
408 Alignments[i].TypeBitWidth > Alignments[LargestInt].TypeBitWidth)
413 // Okay, we didn't find an exact solution. Fall back here depending on what
414 // is being looked for.
415 if (BestMatchIdx == -1) {
416 // If we didn't find an integer alignment, fall back on most conservative.
417 if (AlignType == INTEGER_ALIGN) {
418 BestMatchIdx = LargestInt;
420 assert(AlignType == VECTOR_ALIGN && "Unknown alignment type!");
422 // By default, use natural alignment for vector types. This is consistent
423 // with what clang and llvm-gcc do.
424 unsigned Align = getTypeAllocSize(cast<VectorType>(Ty)->getElementType());
425 Align *= cast<VectorType>(Ty)->getNumElements();
426 // If the alignment is not a power of 2, round up to the next power of 2.
427 // This happens for non-power-of-2 length vectors.
428 if (Align & (Align-1))
429 Align = NextPowerOf2(Align);
434 // Since we got a "best match" index, just return it.
435 return ABIInfo ? Alignments[BestMatchIdx].ABIAlign
436 : Alignments[BestMatchIdx].PrefAlign;
441 class StructLayoutMap {
442 typedef DenseMap<StructType*, StructLayout*> LayoutInfoTy;
443 LayoutInfoTy LayoutInfo;
446 virtual ~StructLayoutMap() {
447 // Remove any layouts.
448 for (LayoutInfoTy::iterator I = LayoutInfo.begin(), E = LayoutInfo.end();
450 StructLayout *Value = I->second;
451 Value->~StructLayout();
456 StructLayout *&operator[](StructType *STy) {
457 return LayoutInfo[STy];
461 virtual void dump() const {}
464 } // end anonymous namespace
466 DataLayout::~DataLayout() {
467 delete static_cast<StructLayoutMap*>(LayoutMap);
470 const StructLayout *DataLayout::getStructLayout(StructType *Ty) const {
472 LayoutMap = new StructLayoutMap();
474 StructLayoutMap *STM = static_cast<StructLayoutMap*>(LayoutMap);
475 StructLayout *&SL = (*STM)[Ty];
478 // Otherwise, create the struct layout. Because it is variable length, we
479 // malloc it, then use placement new.
480 int NumElts = Ty->getNumElements();
482 (StructLayout *)malloc(sizeof(StructLayout)+(NumElts-1) * sizeof(uint64_t));
484 // Set SL before calling StructLayout's ctor. The ctor could cause other
485 // entries to be added to TheMap, invalidating our reference.
488 new (L) StructLayout(Ty, *this);
493 std::string DataLayout::getStringRepresentation() const {
495 raw_string_ostream OS(Result);
497 OS << (LittleEndian ? "e" : "E");
499 switch (ManglingMode) {
516 SmallVector<unsigned, 8> addrSpaces;
517 // Lets get all of the known address spaces and sort them
518 // into increasing order so that we can emit the string
519 // in a cleaner format.
520 for (DenseMap<unsigned, PointerAlignElem>::const_iterator
521 pib = Pointers.begin(), pie = Pointers.end();
523 addrSpaces.push_back(pib->first);
525 std::sort(addrSpaces.begin(), addrSpaces.end());
526 for (SmallVectorImpl<unsigned>::iterator asb = addrSpaces.begin(),
527 ase = addrSpaces.end(); asb != ase; ++asb) {
528 const PointerAlignElem &PI = Pointers.find(*asb)->second;
531 if (PI.AddressSpace == 0 && PI.ABIAlign == 8 && PI.PrefAlign == 8 &&
532 PI.TypeByteWidth == 8)
536 if (PI.AddressSpace) {
537 OS << PI.AddressSpace;
539 OS << ":" << PI.TypeByteWidth*8 << ':' << PI.ABIAlign*8;
540 if (PI.PrefAlign != PI.ABIAlign)
541 OS << ':' << PI.PrefAlign*8;
544 const LayoutAlignElem *DefaultStart = DefaultAlignments;
545 const LayoutAlignElem *DefaultEnd =
546 DefaultStart + array_lengthof(DefaultAlignments);
547 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
548 const LayoutAlignElem &AI = Alignments[i];
549 if (std::find(DefaultStart, DefaultEnd, AI) != DefaultEnd)
551 OS << '-' << (char)AI.AlignType;
553 OS << AI.TypeBitWidth;
554 OS << ':' << AI.ABIAlign*8;
555 if (AI.ABIAlign != AI.PrefAlign)
556 OS << ':' << AI.PrefAlign*8;
559 if (!LegalIntWidths.empty()) {
560 OS << "-n" << (unsigned)LegalIntWidths[0];
562 for (unsigned i = 1, e = LegalIntWidths.size(); i != e; ++i)
563 OS << ':' << (unsigned)LegalIntWidths[i];
566 if (StackNaturalAlign)
567 OS << "-S" << StackNaturalAlign*8;
572 unsigned DataLayout::getPointerTypeSizeInBits(Type *Ty) const {
573 assert(Ty->isPtrOrPtrVectorTy() &&
574 "This should only be called with a pointer or pointer vector type");
576 if (Ty->isPointerTy())
577 return getTypeSizeInBits(Ty);
579 return getTypeSizeInBits(Ty->getScalarType());
583 \param abi_or_pref Flag that determines which alignment is returned. true
584 returns the ABI alignment, false returns the preferred alignment.
585 \param Ty The underlying type for which alignment is determined.
587 Get the ABI (\a abi_or_pref == true) or preferred alignment (\a abi_or_pref
588 == false) for the requested type \a Ty.
590 unsigned DataLayout::getAlignment(Type *Ty, bool abi_or_pref) const {
593 assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
594 switch (Ty->getTypeID()) {
595 // Early escape for the non-numeric types.
596 case Type::LabelTyID:
598 ? getPointerABIAlignment(0)
599 : getPointerPrefAlignment(0));
600 case Type::PointerTyID: {
601 unsigned AS = dyn_cast<PointerType>(Ty)->getAddressSpace();
603 ? getPointerABIAlignment(AS)
604 : getPointerPrefAlignment(AS));
606 case Type::ArrayTyID:
607 return getAlignment(cast<ArrayType>(Ty)->getElementType(), abi_or_pref);
609 case Type::StructTyID: {
610 // Packed structure types always have an ABI alignment of one.
611 if (cast<StructType>(Ty)->isPacked() && abi_or_pref)
614 // Get the layout annotation... which is lazily created on demand.
615 const StructLayout *Layout = getStructLayout(cast<StructType>(Ty));
616 unsigned Align = getAlignmentInfo(AGGREGATE_ALIGN, 0, abi_or_pref, Ty);
617 return std::max(Align, Layout->getAlignment());
619 case Type::IntegerTyID:
620 AlignType = INTEGER_ALIGN;
623 case Type::FloatTyID:
624 case Type::DoubleTyID:
625 // PPC_FP128TyID and FP128TyID have different data contents, but the
626 // same size and alignment, so they look the same here.
627 case Type::PPC_FP128TyID:
628 case Type::FP128TyID:
629 case Type::X86_FP80TyID:
630 AlignType = FLOAT_ALIGN;
632 case Type::X86_MMXTyID:
633 case Type::VectorTyID:
634 AlignType = VECTOR_ALIGN;
637 llvm_unreachable("Bad type for getAlignment!!!");
640 return getAlignmentInfo((AlignTypeEnum)AlignType, getTypeSizeInBits(Ty),
644 unsigned DataLayout::getABITypeAlignment(Type *Ty) const {
645 return getAlignment(Ty, true);
648 /// getABIIntegerTypeAlignment - Return the minimum ABI-required alignment for
649 /// an integer type of the specified bitwidth.
650 unsigned DataLayout::getABIIntegerTypeAlignment(unsigned BitWidth) const {
651 return getAlignmentInfo(INTEGER_ALIGN, BitWidth, true, 0);
654 unsigned DataLayout::getPrefTypeAlignment(Type *Ty) const {
655 return getAlignment(Ty, false);
658 unsigned DataLayout::getPreferredTypeAlignmentShift(Type *Ty) const {
659 unsigned Align = getPrefTypeAlignment(Ty);
660 assert(!(Align & (Align-1)) && "Alignment is not a power of two!");
661 return Log2_32(Align);
664 IntegerType *DataLayout::getIntPtrType(LLVMContext &C,
665 unsigned AddressSpace) const {
666 return IntegerType::get(C, getPointerSizeInBits(AddressSpace));
669 Type *DataLayout::getIntPtrType(Type *Ty) const {
670 assert(Ty->isPtrOrPtrVectorTy() &&
671 "Expected a pointer or pointer vector type.");
672 unsigned NumBits = getTypeSizeInBits(Ty->getScalarType());
673 IntegerType *IntTy = IntegerType::get(Ty->getContext(), NumBits);
674 if (VectorType *VecTy = dyn_cast<VectorType>(Ty))
675 return VectorType::get(IntTy, VecTy->getNumElements());
679 Type *DataLayout::getSmallestLegalIntType(LLVMContext &C, unsigned Width) const {
680 for (unsigned i = 0, e = (unsigned)LegalIntWidths.size(); i != e; ++i)
681 if (Width <= LegalIntWidths[i])
682 return Type::getIntNTy(C, LegalIntWidths[i]);
686 unsigned DataLayout::getLargestLegalIntTypeSize() const {
687 unsigned MaxWidth = 0;
688 for (unsigned i = 0, e = (unsigned)LegalIntWidths.size(); i != e; ++i)
689 MaxWidth = std::max<unsigned>(MaxWidth, LegalIntWidths[i]);
693 uint64_t DataLayout::getIndexedOffset(Type *ptrTy,
694 ArrayRef<Value *> Indices) const {
696 assert(Ty->isPointerTy() && "Illegal argument for getIndexedOffset()");
699 generic_gep_type_iterator<Value* const*>
700 TI = gep_type_begin(ptrTy, Indices);
701 for (unsigned CurIDX = 0, EndIDX = Indices.size(); CurIDX != EndIDX;
703 if (StructType *STy = dyn_cast<StructType>(*TI)) {
704 assert(Indices[CurIDX]->getType() ==
705 Type::getInt32Ty(ptrTy->getContext()) &&
706 "Illegal struct idx");
707 unsigned FieldNo = cast<ConstantInt>(Indices[CurIDX])->getZExtValue();
709 // Get structure layout information...
710 const StructLayout *Layout = getStructLayout(STy);
712 // Add in the offset, as calculated by the structure layout info...
713 Result += Layout->getElementOffset(FieldNo);
715 // Update Ty to refer to current element
716 Ty = STy->getElementType(FieldNo);
718 // Update Ty to refer to current element
719 Ty = cast<SequentialType>(Ty)->getElementType();
721 // Get the array index and the size of each array element.
722 if (int64_t arrayIdx = cast<ConstantInt>(Indices[CurIDX])->getSExtValue())
723 Result += (uint64_t)arrayIdx * getTypeAllocSize(Ty);
730 /// getPreferredAlignment - Return the preferred alignment of the specified
731 /// global. This includes an explicitly requested alignment (if the global
733 unsigned DataLayout::getPreferredAlignment(const GlobalVariable *GV) const {
734 Type *ElemType = GV->getType()->getElementType();
735 unsigned Alignment = getPrefTypeAlignment(ElemType);
736 unsigned GVAlignment = GV->getAlignment();
737 if (GVAlignment >= Alignment) {
738 Alignment = GVAlignment;
739 } else if (GVAlignment != 0) {
740 Alignment = std::max(GVAlignment, getABITypeAlignment(ElemType));
743 if (GV->hasInitializer() && GVAlignment == 0) {
744 if (Alignment < 16) {
745 // If the global is not external, see if it is large. If so, give it a
747 if (getTypeSizeInBits(ElemType) > 128)
748 Alignment = 16; // 16-byte alignment.
754 /// getPreferredAlignmentLog - Return the preferred alignment of the
755 /// specified global, returned in log form. This includes an explicitly
756 /// requested alignment (if the global has one).
757 unsigned DataLayout::getPreferredAlignmentLog(const GlobalVariable *GV) const {
758 return Log2_32(getPreferredAlignment(GV));
761 DataLayoutPass::DataLayoutPass() : ImmutablePass(ID), DL("") {
762 report_fatal_error("Bad DataLayoutPass ctor used. Tool did not specify a "
763 "DataLayout to use?");
766 DataLayoutPass::~DataLayoutPass() {}
768 DataLayoutPass::DataLayoutPass(const DataLayout &DL)
769 : ImmutablePass(ID), DL(DL) {
770 initializeDataLayoutPassPass(*PassRegistry::getPassRegistry());
773 DataLayoutPass::DataLayoutPass(StringRef Str) : ImmutablePass(ID), DL(Str) {
774 initializeDataLayoutPassPass(*PassRegistry::getPassRegistry());
777 DataLayoutPass::DataLayoutPass(const Module *M) : ImmutablePass(ID), DL(M) {
778 initializeDataLayoutPassPass(*PassRegistry::getPassRegistry());