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/IR/Constants.h"
22 #include "llvm/IR/DerivedTypes.h"
23 #include "llvm/IR/Module.h"
24 #include "llvm/Support/ErrorHandling.h"
25 #include "llvm/Support/GetElementPtrTypeIterator.h"
26 #include "llvm/Support/ManagedStatic.h"
27 #include "llvm/Support/MathExtras.h"
28 #include "llvm/Support/Mutex.h"
29 #include "llvm/Support/raw_ostream.h"
34 // Handle the Pass registration stuff necessary to use DataLayout's.
36 // Register the default SparcV9 implementation...
37 INITIALIZE_PASS(DataLayout, "datalayout", "Data Layout", false, true)
38 char DataLayout::ID = 0;
40 //===----------------------------------------------------------------------===//
41 // Support for StructLayout
42 //===----------------------------------------------------------------------===//
44 StructLayout::StructLayout(StructType *ST, const DataLayout &TD) {
45 assert(!ST->isOpaque() && "Cannot get layout of opaque structs");
48 NumElements = ST->getNumElements();
50 // Loop over each of the elements, placing them in memory.
51 for (unsigned i = 0, e = NumElements; i != e; ++i) {
52 Type *Ty = ST->getElementType(i);
53 unsigned TyAlign = ST->isPacked() ? 1 : TD.getABITypeAlignment(Ty);
55 // Add padding if necessary to align the data element properly.
56 if ((StructSize & (TyAlign-1)) != 0)
57 StructSize = DataLayout::RoundUpAlignment(StructSize, TyAlign);
59 // Keep track of maximum alignment constraint.
60 StructAlignment = std::max(TyAlign, StructAlignment);
62 MemberOffsets[i] = StructSize;
63 StructSize += TD.getTypeAllocSize(Ty); // Consume space for this data item
66 // Empty structures have alignment of 1 byte.
67 if (StructAlignment == 0) StructAlignment = 1;
69 // Add padding to the end of the struct so that it could be put in an array
70 // and all array elements would be aligned correctly.
71 if ((StructSize & (StructAlignment-1)) != 0)
72 StructSize = DataLayout::RoundUpAlignment(StructSize, StructAlignment);
76 /// getElementContainingOffset - Given a valid offset into the structure,
77 /// return the structure index that contains it.
78 unsigned StructLayout::getElementContainingOffset(uint64_t Offset) const {
80 std::upper_bound(&MemberOffsets[0], &MemberOffsets[NumElements], Offset);
81 assert(SI != &MemberOffsets[0] && "Offset not in structure type!");
83 assert(*SI <= Offset && "upper_bound didn't work");
84 assert((SI == &MemberOffsets[0] || *(SI-1) <= Offset) &&
85 (SI+1 == &MemberOffsets[NumElements] || *(SI+1) > Offset) &&
86 "Upper bound didn't work!");
88 // Multiple fields can have the same offset if any of them are zero sized.
89 // For example, in { i32, [0 x i32], i32 }, searching for offset 4 will stop
90 // at the i32 element, because it is the last element at that offset. This is
91 // the right one to return, because anything after it will have a higher
92 // offset, implying that this element is non-empty.
93 return SI-&MemberOffsets[0];
96 //===----------------------------------------------------------------------===//
97 // LayoutAlignElem, LayoutAlign support
98 //===----------------------------------------------------------------------===//
101 LayoutAlignElem::get(AlignTypeEnum align_type, unsigned abi_align,
102 unsigned pref_align, uint32_t bit_width) {
103 assert(abi_align <= pref_align && "Preferred alignment worse than ABI!");
104 LayoutAlignElem retval;
105 retval.AlignType = align_type;
106 retval.ABIAlign = abi_align;
107 retval.PrefAlign = pref_align;
108 retval.TypeBitWidth = bit_width;
113 LayoutAlignElem::operator==(const LayoutAlignElem &rhs) const {
114 return (AlignType == rhs.AlignType
115 && ABIAlign == rhs.ABIAlign
116 && PrefAlign == rhs.PrefAlign
117 && TypeBitWidth == rhs.TypeBitWidth);
120 const LayoutAlignElem
121 DataLayout::InvalidAlignmentElem = LayoutAlignElem::get(INVALID_ALIGN, 0, 0, 0);
123 //===----------------------------------------------------------------------===//
124 // PointerAlignElem, PointerAlign support
125 //===----------------------------------------------------------------------===//
128 PointerAlignElem::get(uint32_t addr_space, unsigned abi_align,
129 unsigned pref_align, uint32_t bit_width) {
130 assert(abi_align <= pref_align && "Preferred alignment worse than ABI!");
131 PointerAlignElem retval;
132 retval.AddressSpace = addr_space;
133 retval.ABIAlign = abi_align;
134 retval.PrefAlign = pref_align;
135 retval.TypeBitWidth = bit_width;
140 PointerAlignElem::operator==(const PointerAlignElem &rhs) const {
141 return (ABIAlign == rhs.ABIAlign
142 && AddressSpace == rhs.AddressSpace
143 && PrefAlign == rhs.PrefAlign
144 && TypeBitWidth == rhs.TypeBitWidth);
147 const PointerAlignElem
148 DataLayout::InvalidPointerElem = PointerAlignElem::get(~0U, 0U, 0U, 0U);
150 //===----------------------------------------------------------------------===//
151 // DataLayout Class Implementation
152 //===----------------------------------------------------------------------===//
154 void DataLayout::init(StringRef Desc) {
155 initializeDataLayoutPass(*PassRegistry::getPassRegistry());
158 LittleEndian = false;
159 StackNaturalAlign = 0;
161 // Default alignments
162 setAlignment(INTEGER_ALIGN, 1, 1, 1); // i1
163 setAlignment(INTEGER_ALIGN, 1, 1, 8); // i8
164 setAlignment(INTEGER_ALIGN, 2, 2, 16); // i16
165 setAlignment(INTEGER_ALIGN, 4, 4, 32); // i32
166 setAlignment(INTEGER_ALIGN, 4, 8, 64); // i64
167 setAlignment(FLOAT_ALIGN, 2, 2, 16); // half
168 setAlignment(FLOAT_ALIGN, 4, 4, 32); // float
169 setAlignment(FLOAT_ALIGN, 8, 8, 64); // double
170 setAlignment(FLOAT_ALIGN, 16, 16, 128); // ppcf128, quad, ...
171 setAlignment(VECTOR_ALIGN, 8, 8, 64); // v2i32, v1i64, ...
172 setAlignment(VECTOR_ALIGN, 16, 16, 128); // v16i8, v8i16, v4i32, ...
173 setAlignment(AGGREGATE_ALIGN, 0, 8, 0); // struct
174 setPointerAlignment(0, 8, 8, 8);
176 parseSpecifier(Desc);
179 /// Checked version of split, to ensure mandatory subparts.
180 static std::pair<StringRef, StringRef> split(StringRef Str, char Separator) {
181 assert(!Str.empty() && "parse error, string can't be empty here");
182 std::pair<StringRef, StringRef> Split = Str.split(Separator);
183 assert((!Split.second.empty() || Split.first == Str) &&
184 "a trailing separator is not allowed");
188 /// Get an unsinged integer, including error checks.
189 static unsigned getInt(StringRef R) {
191 bool error = R.getAsInteger(10, Result); (void)error;
192 assert(!error && "not a number, or does not fit in an unsigned int");
196 /// Convert bits into bytes. Assert if not a byte width multiple.
197 static unsigned inBytes(unsigned Bits) {
198 assert(Bits % 8 == 0 && "number of bits must be a byte width multiple");
202 void DataLayout::parseSpecifier(StringRef Desc) {
204 while (!Desc.empty()) {
207 std::pair<StringRef, StringRef> Split = split(Desc, '-');
211 Split = split(Split.first, ':');
213 // Aliases used below.
214 StringRef &Tok = Split.first; // Current token.
215 StringRef &Rest = Split.second; // The rest of the string.
217 char Specifier = Tok.front();
222 LittleEndian = false;
229 unsigned AddrSpace = Tok.empty() ? 0 : getInt(Tok);
230 assert(AddrSpace < 1 << 24 &&
231 "Invalid address space, must be a 24bit integer");
234 Split = split(Rest, ':');
235 unsigned PointerMemSize = inBytes(getInt(Tok));
238 Split = split(Rest, ':');
239 unsigned PointerABIAlign = inBytes(getInt(Tok));
241 // Preferred alignment.
242 unsigned PointerPrefAlign = PointerABIAlign;
244 Split = split(Rest, ':');
245 PointerPrefAlign = inBytes(getInt(Tok));
248 setPointerAlignment(AddrSpace, PointerABIAlign, PointerPrefAlign,
257 AlignTypeEnum AlignType;
260 case 'i': AlignType = INTEGER_ALIGN; break;
261 case 'v': AlignType = VECTOR_ALIGN; break;
262 case 'f': AlignType = FLOAT_ALIGN; break;
263 case 'a': AlignType = AGGREGATE_ALIGN; break;
264 case 's': AlignType = STACK_ALIGN; break;
268 unsigned Size = Tok.empty() ? 0 : getInt(Tok);
271 Split = split(Rest, ':');
272 unsigned ABIAlign = inBytes(getInt(Tok));
274 // Preferred alignment.
275 unsigned PrefAlign = ABIAlign;
277 Split = split(Rest, ':');
278 PrefAlign = inBytes(getInt(Tok));
281 setAlignment(AlignType, ABIAlign, PrefAlign, Size);
285 case 'n': // Native integer types.
287 unsigned Width = getInt(Tok);
288 assert(Width != 0 && "width must be non-zero");
289 LegalIntWidths.push_back(Width);
292 Split = split(Rest, ':');
295 case 'S': { // Stack natural alignment.
296 StackNaturalAlign = inBytes(getInt(Tok));
300 llvm_unreachable("Unknown specifier in datalayout string");
308 /// @note This has to exist, because this is a pass, but it should never be
310 DataLayout::DataLayout() : ImmutablePass(ID) {
311 report_fatal_error("Bad DataLayout ctor used. "
312 "Tool did not specify a DataLayout to use?");
315 DataLayout::DataLayout(const Module *M)
316 : ImmutablePass(ID) {
317 init(M->getDataLayout());
321 DataLayout::setAlignment(AlignTypeEnum align_type, unsigned abi_align,
322 unsigned pref_align, uint32_t bit_width) {
323 assert(abi_align <= pref_align && "Preferred alignment worse than ABI!");
324 assert(pref_align < (1 << 16) && "Alignment doesn't fit in bitfield");
325 assert(bit_width < (1 << 24) && "Bit width doesn't fit in bitfield");
326 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
327 if (Alignments[i].AlignType == (unsigned)align_type &&
328 Alignments[i].TypeBitWidth == bit_width) {
329 // Update the abi, preferred alignments.
330 Alignments[i].ABIAlign = abi_align;
331 Alignments[i].PrefAlign = pref_align;
336 Alignments.push_back(LayoutAlignElem::get(align_type, abi_align,
337 pref_align, bit_width));
341 DataLayout::setPointerAlignment(uint32_t addr_space, unsigned abi_align,
342 unsigned pref_align, uint32_t bit_width) {
343 assert(abi_align <= pref_align && "Preferred alignment worse than ABI!");
344 DenseMap<unsigned,PointerAlignElem>::iterator val = Pointers.find(addr_space);
345 if (val == Pointers.end()) {
346 Pointers[addr_space] = PointerAlignElem::get(addr_space,
347 abi_align, pref_align, bit_width);
349 val->second.ABIAlign = abi_align;
350 val->second.PrefAlign = pref_align;
351 val->second.TypeBitWidth = bit_width;
355 /// getAlignmentInfo - Return the alignment (either ABI if ABIInfo = true or
356 /// preferred if ABIInfo = false) the layout wants for the specified datatype.
357 unsigned DataLayout::getAlignmentInfo(AlignTypeEnum AlignType,
358 uint32_t BitWidth, bool ABIInfo,
360 // Check to see if we have an exact match and remember the best match we see.
361 int BestMatchIdx = -1;
363 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
364 if (Alignments[i].AlignType == (unsigned)AlignType &&
365 Alignments[i].TypeBitWidth == BitWidth)
366 return ABIInfo ? Alignments[i].ABIAlign : Alignments[i].PrefAlign;
368 // The best match so far depends on what we're looking for.
369 if (AlignType == INTEGER_ALIGN &&
370 Alignments[i].AlignType == INTEGER_ALIGN) {
371 // The "best match" for integers is the smallest size that is larger than
372 // the BitWidth requested.
373 if (Alignments[i].TypeBitWidth > BitWidth && (BestMatchIdx == -1 ||
374 Alignments[i].TypeBitWidth < Alignments[BestMatchIdx].TypeBitWidth))
376 // However, if there isn't one that's larger, then we must use the
377 // largest one we have (see below)
378 if (LargestInt == -1 ||
379 Alignments[i].TypeBitWidth > Alignments[LargestInt].TypeBitWidth)
384 // Okay, we didn't find an exact solution. Fall back here depending on what
385 // is being looked for.
386 if (BestMatchIdx == -1) {
387 // If we didn't find an integer alignment, fall back on most conservative.
388 if (AlignType == INTEGER_ALIGN) {
389 BestMatchIdx = LargestInt;
391 assert(AlignType == VECTOR_ALIGN && "Unknown alignment type!");
393 // By default, use natural alignment for vector types. This is consistent
394 // with what clang and llvm-gcc do.
395 unsigned Align = getTypeAllocSize(cast<VectorType>(Ty)->getElementType());
396 Align *= cast<VectorType>(Ty)->getNumElements();
397 // If the alignment is not a power of 2, round up to the next power of 2.
398 // This happens for non-power-of-2 length vectors.
399 if (Align & (Align-1))
400 Align = NextPowerOf2(Align);
405 // Since we got a "best match" index, just return it.
406 return ABIInfo ? Alignments[BestMatchIdx].ABIAlign
407 : Alignments[BestMatchIdx].PrefAlign;
412 class StructLayoutMap {
413 typedef DenseMap<StructType*, StructLayout*> LayoutInfoTy;
414 LayoutInfoTy LayoutInfo;
417 virtual ~StructLayoutMap() {
418 // Remove any layouts.
419 for (LayoutInfoTy::iterator I = LayoutInfo.begin(), E = LayoutInfo.end();
421 StructLayout *Value = I->second;
422 Value->~StructLayout();
427 StructLayout *&operator[](StructType *STy) {
428 return LayoutInfo[STy];
432 virtual void dump() const {}
435 } // end anonymous namespace
437 DataLayout::~DataLayout() {
438 delete static_cast<StructLayoutMap*>(LayoutMap);
441 const StructLayout *DataLayout::getStructLayout(StructType *Ty) const {
443 LayoutMap = new StructLayoutMap();
445 StructLayoutMap *STM = static_cast<StructLayoutMap*>(LayoutMap);
446 StructLayout *&SL = (*STM)[Ty];
449 // Otherwise, create the struct layout. Because it is variable length, we
450 // malloc it, then use placement new.
451 int NumElts = Ty->getNumElements();
453 (StructLayout *)malloc(sizeof(StructLayout)+(NumElts-1) * sizeof(uint64_t));
455 // Set SL before calling StructLayout's ctor. The ctor could cause other
456 // entries to be added to TheMap, invalidating our reference.
459 new (L) StructLayout(Ty, *this);
464 std::string DataLayout::getStringRepresentation() const {
466 raw_string_ostream OS(Result);
468 OS << (LittleEndian ? "e" : "E");
469 SmallVector<unsigned, 8> addrSpaces;
470 // Lets get all of the known address spaces and sort them
471 // into increasing order so that we can emit the string
472 // in a cleaner format.
473 for (DenseMap<unsigned, PointerAlignElem>::const_iterator
474 pib = Pointers.begin(), pie = Pointers.end();
476 addrSpaces.push_back(pib->first);
478 std::sort(addrSpaces.begin(), addrSpaces.end());
479 for (SmallVector<unsigned, 8>::iterator asb = addrSpaces.begin(),
480 ase = addrSpaces.end(); asb != ase; ++asb) {
481 const PointerAlignElem &PI = Pointers.find(*asb)->second;
483 if (PI.AddressSpace) {
484 OS << PI.AddressSpace;
486 OS << ":" << PI.TypeBitWidth*8 << ':' << PI.ABIAlign*8
487 << ':' << PI.PrefAlign*8;
489 OS << "-S" << StackNaturalAlign*8;
491 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
492 const LayoutAlignElem &AI = Alignments[i];
493 OS << '-' << (char)AI.AlignType << AI.TypeBitWidth << ':'
494 << AI.ABIAlign*8 << ':' << AI.PrefAlign*8;
497 if (!LegalIntWidths.empty()) {
498 OS << "-n" << (unsigned)LegalIntWidths[0];
500 for (unsigned i = 1, e = LegalIntWidths.size(); i != e; ++i)
501 OS << ':' << (unsigned)LegalIntWidths[i];
507 uint64_t DataLayout::getTypeSizeInBits(Type *Ty) const {
508 assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
509 switch (Ty->getTypeID()) {
510 case Type::LabelTyID:
511 return getPointerSizeInBits(0);
512 case Type::PointerTyID: {
513 unsigned AS = dyn_cast<PointerType>(Ty)->getAddressSpace();
514 return getPointerSizeInBits(AS);
516 case Type::ArrayTyID: {
517 ArrayType *ATy = cast<ArrayType>(Ty);
518 return getTypeAllocSizeInBits(ATy->getElementType())*ATy->getNumElements();
520 case Type::StructTyID:
521 // Get the layout annotation... which is lazily created on demand.
522 return getStructLayout(cast<StructType>(Ty))->getSizeInBits();
523 case Type::IntegerTyID:
524 return cast<IntegerType>(Ty)->getBitWidth();
527 case Type::FloatTyID:
529 case Type::DoubleTyID:
530 case Type::X86_MMXTyID:
532 case Type::PPC_FP128TyID:
533 case Type::FP128TyID:
535 // In memory objects this is always aligned to a higher boundary, but
536 // only 80 bits contain information.
537 case Type::X86_FP80TyID:
539 case Type::VectorTyID: {
540 VectorType *VTy = cast<VectorType>(Ty);
541 return VTy->getNumElements()*getTypeSizeInBits(VTy->getElementType());
544 llvm_unreachable("DataLayout::getTypeSizeInBits(): Unsupported type");
549 \param abi_or_pref Flag that determines which alignment is returned. true
550 returns the ABI alignment, false returns the preferred alignment.
551 \param Ty The underlying type for which alignment is determined.
553 Get the ABI (\a abi_or_pref == true) or preferred alignment (\a abi_or_pref
554 == false) for the requested type \a Ty.
556 unsigned DataLayout::getAlignment(Type *Ty, bool abi_or_pref) const {
559 assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
560 switch (Ty->getTypeID()) {
561 // Early escape for the non-numeric types.
562 case Type::LabelTyID:
564 ? getPointerABIAlignment(0)
565 : getPointerPrefAlignment(0));
566 case Type::PointerTyID: {
567 unsigned AS = dyn_cast<PointerType>(Ty)->getAddressSpace();
569 ? getPointerABIAlignment(AS)
570 : getPointerPrefAlignment(AS));
572 case Type::ArrayTyID:
573 return getAlignment(cast<ArrayType>(Ty)->getElementType(), abi_or_pref);
575 case Type::StructTyID: {
576 // Packed structure types always have an ABI alignment of one.
577 if (cast<StructType>(Ty)->isPacked() && abi_or_pref)
580 // Get the layout annotation... which is lazily created on demand.
581 const StructLayout *Layout = getStructLayout(cast<StructType>(Ty));
582 unsigned Align = getAlignmentInfo(AGGREGATE_ALIGN, 0, abi_or_pref, Ty);
583 return std::max(Align, Layout->getAlignment());
585 case Type::IntegerTyID:
586 AlignType = INTEGER_ALIGN;
589 case Type::FloatTyID:
590 case Type::DoubleTyID:
591 // PPC_FP128TyID and FP128TyID have different data contents, but the
592 // same size and alignment, so they look the same here.
593 case Type::PPC_FP128TyID:
594 case Type::FP128TyID:
595 case Type::X86_FP80TyID:
596 AlignType = FLOAT_ALIGN;
598 case Type::X86_MMXTyID:
599 case Type::VectorTyID:
600 AlignType = VECTOR_ALIGN;
603 llvm_unreachable("Bad type for getAlignment!!!");
606 return getAlignmentInfo((AlignTypeEnum)AlignType, getTypeSizeInBits(Ty),
610 unsigned DataLayout::getABITypeAlignment(Type *Ty) const {
611 return getAlignment(Ty, true);
614 /// getABIIntegerTypeAlignment - Return the minimum ABI-required alignment for
615 /// an integer type of the specified bitwidth.
616 unsigned DataLayout::getABIIntegerTypeAlignment(unsigned BitWidth) const {
617 return getAlignmentInfo(INTEGER_ALIGN, BitWidth, true, 0);
621 unsigned DataLayout::getCallFrameTypeAlignment(Type *Ty) const {
622 for (unsigned i = 0, e = Alignments.size(); i != e; ++i)
623 if (Alignments[i].AlignType == STACK_ALIGN)
624 return Alignments[i].ABIAlign;
626 return getABITypeAlignment(Ty);
629 unsigned DataLayout::getPrefTypeAlignment(Type *Ty) const {
630 return getAlignment(Ty, false);
633 unsigned DataLayout::getPreferredTypeAlignmentShift(Type *Ty) const {
634 unsigned Align = getPrefTypeAlignment(Ty);
635 assert(!(Align & (Align-1)) && "Alignment is not a power of two!");
636 return Log2_32(Align);
639 /// getIntPtrType - Return an integer type with size at least as big as that
640 /// of a pointer in the given address space.
641 IntegerType *DataLayout::getIntPtrType(LLVMContext &C,
642 unsigned AddressSpace) const {
643 return IntegerType::get(C, getPointerSizeInBits(AddressSpace));
646 /// getIntPtrType - Return an integer (vector of integer) type with size at
647 /// least as big as that of a pointer of the given pointer (vector of pointer)
649 Type *DataLayout::getIntPtrType(Type *Ty) const {
650 assert(Ty->isPtrOrPtrVectorTy() &&
651 "Expected a pointer or pointer vector type.");
652 unsigned NumBits = getTypeSizeInBits(Ty->getScalarType());
653 IntegerType *IntTy = IntegerType::get(Ty->getContext(), NumBits);
654 if (VectorType *VecTy = dyn_cast<VectorType>(Ty))
655 return VectorType::get(IntTy, VecTy->getNumElements());
659 uint64_t DataLayout::getIndexedOffset(Type *ptrTy,
660 ArrayRef<Value *> Indices) const {
662 assert(Ty->isPointerTy() && "Illegal argument for getIndexedOffset()");
665 generic_gep_type_iterator<Value* const*>
666 TI = gep_type_begin(ptrTy, Indices);
667 for (unsigned CurIDX = 0, EndIDX = Indices.size(); CurIDX != EndIDX;
669 if (StructType *STy = dyn_cast<StructType>(*TI)) {
670 assert(Indices[CurIDX]->getType() ==
671 Type::getInt32Ty(ptrTy->getContext()) &&
672 "Illegal struct idx");
673 unsigned FieldNo = cast<ConstantInt>(Indices[CurIDX])->getZExtValue();
675 // Get structure layout information...
676 const StructLayout *Layout = getStructLayout(STy);
678 // Add in the offset, as calculated by the structure layout info...
679 Result += Layout->getElementOffset(FieldNo);
681 // Update Ty to refer to current element
682 Ty = STy->getElementType(FieldNo);
684 // Update Ty to refer to current element
685 Ty = cast<SequentialType>(Ty)->getElementType();
687 // Get the array index and the size of each array element.
688 if (int64_t arrayIdx = cast<ConstantInt>(Indices[CurIDX])->getSExtValue())
689 Result += (uint64_t)arrayIdx * getTypeAllocSize(Ty);
696 /// getPreferredAlignment - Return the preferred alignment of the specified
697 /// global. This includes an explicitly requested alignment (if the global
699 unsigned DataLayout::getPreferredAlignment(const GlobalVariable *GV) const {
700 Type *ElemType = GV->getType()->getElementType();
701 unsigned Alignment = getPrefTypeAlignment(ElemType);
702 unsigned GVAlignment = GV->getAlignment();
703 if (GVAlignment >= Alignment) {
704 Alignment = GVAlignment;
705 } else if (GVAlignment != 0) {
706 Alignment = std::max(GVAlignment, getABITypeAlignment(ElemType));
709 if (GV->hasInitializer() && GVAlignment == 0) {
710 if (Alignment < 16) {
711 // If the global is not external, see if it is large. If so, give it a
713 if (getTypeSizeInBits(ElemType) > 128)
714 Alignment = 16; // 16-byte alignment.
720 /// getPreferredAlignmentLog - Return the preferred alignment of the
721 /// specified global, returned in log form. This includes an explicitly
722 /// requested alignment (if the global has one).
723 unsigned DataLayout::getPreferredAlignmentLog(const GlobalVariable *GV) const {
724 return Log2_32(getPreferredAlignment(GV));