1 //===-- TargetData.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 target 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/Target/TargetData.h"
20 #include "llvm/Constants.h"
21 #include "llvm/DerivedTypes.h"
22 #include "llvm/Module.h"
23 #include "llvm/Support/GetElementPtrTypeIterator.h"
24 #include "llvm/Support/MathExtras.h"
25 #include "llvm/Support/ManagedStatic.h"
26 #include "llvm/Support/ErrorHandling.h"
27 #include "llvm/Support/raw_ostream.h"
28 #include "llvm/Support/Mutex.h"
29 #include "llvm/ADT/DenseMap.h"
34 // Handle the Pass registration stuff necessary to use TargetData's.
36 // Register the default SparcV9 implementation...
37 INITIALIZE_PASS(TargetData, "targetdata", "Target Data Layout", false, true)
38 char TargetData::ID = 0;
40 //===----------------------------------------------------------------------===//
41 // Support for StructLayout
42 //===----------------------------------------------------------------------===//
44 StructLayout::StructLayout(StructType *ST, const TargetData &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 = TargetData::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 = TargetData::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 // TargetAlignElem, TargetAlign support
98 //===----------------------------------------------------------------------===//
101 TargetAlignElem::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 TargetAlignElem retval;
105 retval.AlignType = align_type;
106 retval.ABIAlign = abi_align;
107 retval.PrefAlign = pref_align;
108 retval.TypeBitWidth = bit_width;
113 TargetAlignElem::operator==(const TargetAlignElem &rhs) const {
114 return (AlignType == rhs.AlignType
115 && ABIAlign == rhs.ABIAlign
116 && PrefAlign == rhs.PrefAlign
117 && TypeBitWidth == rhs.TypeBitWidth);
120 const TargetAlignElem TargetData::InvalidAlignmentElem =
121 TargetAlignElem::get((AlignTypeEnum) -1, 0, 0, 0);
123 //===----------------------------------------------------------------------===//
124 // TargetData Class Implementation
125 //===----------------------------------------------------------------------===//
127 /// getInt - Get an integer ignoring errors.
128 static int getInt(StringRef R) {
130 R.getAsInteger(10, Result);
134 void TargetData::init() {
135 initializeTargetDataPass(*PassRegistry::getPassRegistry());
138 LittleEndian = false;
141 PointerPrefAlign = PointerABIAlign;
142 StackNaturalAlign = 0;
144 // Default alignments
145 setAlignment(INTEGER_ALIGN, 1, 1, 1); // i1
146 setAlignment(INTEGER_ALIGN, 1, 1, 8); // i8
147 setAlignment(INTEGER_ALIGN, 2, 2, 16); // i16
148 setAlignment(INTEGER_ALIGN, 4, 4, 32); // i32
149 setAlignment(INTEGER_ALIGN, 4, 8, 64); // i64
150 setAlignment(FLOAT_ALIGN, 2, 2, 16); // half
151 setAlignment(FLOAT_ALIGN, 4, 4, 32); // float
152 setAlignment(FLOAT_ALIGN, 8, 8, 64); // double
153 setAlignment(VECTOR_ALIGN, 8, 8, 64); // v2i32, v1i64, ...
154 setAlignment(VECTOR_ALIGN, 16, 16, 128); // v16i8, v8i16, v4i32, ...
155 setAlignment(AGGREGATE_ALIGN, 0, 8, 0); // struct
158 std::string TargetData::parseSpecifier(StringRef Desc, TargetData *td) {
163 while (!Desc.empty()) {
164 std::pair<StringRef, StringRef> Split = Desc.split('-');
165 StringRef Token = Split.first;
171 Split = Token.split(':');
172 StringRef Specifier = Split.first;
173 Token = Split.second;
175 assert(!Specifier.empty() && "Can't be empty here");
177 switch (Specifier[0]) {
180 td->LittleEndian = false;
184 td->LittleEndian = true;
188 Split = Token.split(':');
189 int PointerMemSizeBits = getInt(Split.first);
190 if (PointerMemSizeBits < 0 || PointerMemSizeBits % 8 != 0)
191 return "invalid pointer size, must be a positive 8-bit multiple";
193 td->PointerMemSize = PointerMemSizeBits / 8;
195 // Pointer ABI alignment.
196 Split = Split.second.split(':');
197 int PointerABIAlignBits = getInt(Split.first);
198 if (PointerABIAlignBits < 0 || PointerABIAlignBits % 8 != 0) {
199 return "invalid pointer ABI alignment, "
200 "must be a positive 8-bit multiple";
203 td->PointerABIAlign = PointerABIAlignBits / 8;
205 // Pointer preferred alignment.
206 Split = Split.second.split(':');
207 int PointerPrefAlignBits = getInt(Split.first);
208 if (PointerPrefAlignBits < 0 || PointerPrefAlignBits % 8 != 0) {
209 return "invalid pointer preferred alignment, "
210 "must be a positive 8-bit multiple";
213 td->PointerPrefAlign = PointerPrefAlignBits / 8;
214 if (td->PointerPrefAlign == 0)
215 td->PointerPrefAlign = td->PointerABIAlign;
224 AlignTypeEnum AlignType;
225 char field = Specifier[0];
228 case 'i': AlignType = INTEGER_ALIGN; break;
229 case 'v': AlignType = VECTOR_ALIGN; break;
230 case 'f': AlignType = FLOAT_ALIGN; break;
231 case 'a': AlignType = AGGREGATE_ALIGN; break;
232 case 's': AlignType = STACK_ALIGN; break;
234 int Size = getInt(Specifier.substr(1));
236 return std::string("invalid ") + field + "-size field, "
240 Split = Token.split(':');
241 int ABIAlignBits = getInt(Split.first);
242 if (ABIAlignBits < 0 || ABIAlignBits % 8 != 0) {
243 return std::string("invalid ") + field +"-abi-alignment field, "
244 "must be a positive 8-bit multiple";
246 unsigned ABIAlign = ABIAlignBits / 8;
248 Split = Split.second.split(':');
250 int PrefAlignBits = getInt(Split.first);
251 if (PrefAlignBits < 0 || PrefAlignBits % 8 != 0) {
252 return std::string("invalid ") + field +"-preferred-alignment field, "
253 "must be a positive 8-bit multiple";
255 unsigned PrefAlign = PrefAlignBits / 8;
257 PrefAlign = ABIAlign;
260 td->setAlignment(AlignType, ABIAlign, PrefAlign, Size);
263 case 'n': // Native integer types.
264 Specifier = Specifier.substr(1);
266 int Width = getInt(Specifier);
268 return std::string("invalid native integer size \'") + Specifier.str() +
269 "\', must be a positive integer.";
271 if (td && Width != 0)
272 td->LegalIntWidths.push_back(Width);
273 Split = Token.split(':');
274 Specifier = Split.first;
275 Token = Split.second;
276 } while (!Specifier.empty() || !Token.empty());
278 case 'S': { // Stack natural alignment.
279 int StackNaturalAlignBits = getInt(Specifier.substr(1));
280 if (StackNaturalAlignBits < 0 || StackNaturalAlignBits % 8 != 0) {
281 return "invalid natural stack alignment (S-field), "
282 "must be a positive 8-bit multiple";
285 td->StackNaturalAlign = StackNaturalAlignBits / 8;
298 /// @note This has to exist, because this is a pass, but it should never be
300 TargetData::TargetData() : ImmutablePass(ID) {
301 report_fatal_error("Bad TargetData ctor used. "
302 "Tool did not specify a TargetData to use?");
305 TargetData::TargetData(const Module *M)
306 : ImmutablePass(ID) {
307 std::string errMsg = parseSpecifier(M->getDataLayout(), this);
308 assert(errMsg == "" && "Module M has malformed target data layout string.");
313 TargetData::setAlignment(AlignTypeEnum align_type, unsigned abi_align,
314 unsigned pref_align, uint32_t bit_width) {
315 assert(abi_align <= pref_align && "Preferred alignment worse than ABI!");
316 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
317 if (Alignments[i].AlignType == align_type &&
318 Alignments[i].TypeBitWidth == bit_width) {
319 // Update the abi, preferred alignments.
320 Alignments[i].ABIAlign = abi_align;
321 Alignments[i].PrefAlign = pref_align;
326 Alignments.push_back(TargetAlignElem::get(align_type, abi_align,
327 pref_align, bit_width));
330 /// getAlignmentInfo - Return the alignment (either ABI if ABIInfo = true or
331 /// preferred if ABIInfo = false) the target wants for the specified datatype.
332 unsigned TargetData::getAlignmentInfo(AlignTypeEnum AlignType,
333 uint32_t BitWidth, bool ABIInfo,
335 // Check to see if we have an exact match and remember the best match we see.
336 int BestMatchIdx = -1;
338 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
339 if (Alignments[i].AlignType == AlignType &&
340 Alignments[i].TypeBitWidth == BitWidth)
341 return ABIInfo ? Alignments[i].ABIAlign : Alignments[i].PrefAlign;
343 // The best match so far depends on what we're looking for.
344 if (AlignType == INTEGER_ALIGN &&
345 Alignments[i].AlignType == INTEGER_ALIGN) {
346 // The "best match" for integers is the smallest size that is larger than
347 // the BitWidth requested.
348 if (Alignments[i].TypeBitWidth > BitWidth && (BestMatchIdx == -1 ||
349 Alignments[i].TypeBitWidth < Alignments[BestMatchIdx].TypeBitWidth))
351 // However, if there isn't one that's larger, then we must use the
352 // largest one we have (see below)
353 if (LargestInt == -1 ||
354 Alignments[i].TypeBitWidth > Alignments[LargestInt].TypeBitWidth)
359 // Okay, we didn't find an exact solution. Fall back here depending on what
360 // is being looked for.
361 if (BestMatchIdx == -1) {
362 // If we didn't find an integer alignment, fall back on most conservative.
363 if (AlignType == INTEGER_ALIGN) {
364 BestMatchIdx = LargestInt;
366 assert(AlignType == VECTOR_ALIGN && "Unknown alignment type!");
368 // By default, use natural alignment for vector types. This is consistent
369 // with what clang and llvm-gcc do.
370 unsigned Align = getTypeAllocSize(cast<VectorType>(Ty)->getElementType());
371 Align *= cast<VectorType>(Ty)->getNumElements();
372 // If the alignment is not a power of 2, round up to the next power of 2.
373 // This happens for non-power-of-2 length vectors.
374 if (Align & (Align-1))
375 Align = llvm::NextPowerOf2(Align);
380 // Since we got a "best match" index, just return it.
381 return ABIInfo ? Alignments[BestMatchIdx].ABIAlign
382 : Alignments[BestMatchIdx].PrefAlign;
387 class StructLayoutMap {
388 typedef DenseMap<StructType*, StructLayout*> LayoutInfoTy;
389 LayoutInfoTy LayoutInfo;
392 virtual ~StructLayoutMap() {
393 // Remove any layouts.
394 for (LayoutInfoTy::iterator I = LayoutInfo.begin(), E = LayoutInfo.end();
396 StructLayout *Value = I->second;
397 Value->~StructLayout();
402 StructLayout *&operator[](StructType *STy) {
403 return LayoutInfo[STy];
407 virtual void dump() const {}
410 } // end anonymous namespace
412 TargetData::~TargetData() {
413 delete static_cast<StructLayoutMap*>(LayoutMap);
416 const StructLayout *TargetData::getStructLayout(StructType *Ty) const {
418 LayoutMap = new StructLayoutMap();
420 StructLayoutMap *STM = static_cast<StructLayoutMap*>(LayoutMap);
421 StructLayout *&SL = (*STM)[Ty];
424 // Otherwise, create the struct layout. Because it is variable length, we
425 // malloc it, then use placement new.
426 int NumElts = Ty->getNumElements();
428 (StructLayout *)malloc(sizeof(StructLayout)+(NumElts-1) * sizeof(uint64_t));
430 // Set SL before calling StructLayout's ctor. The ctor could cause other
431 // entries to be added to TheMap, invalidating our reference.
434 new (L) StructLayout(Ty, *this);
439 std::string TargetData::getStringRepresentation() const {
441 raw_string_ostream OS(Result);
443 OS << (LittleEndian ? "e" : "E")
444 << "-p:" << PointerMemSize*8 << ':' << PointerABIAlign*8
445 << ':' << PointerPrefAlign*8
446 << "-S" << StackNaturalAlign*8;
448 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
449 const TargetAlignElem &AI = Alignments[i];
450 OS << '-' << (char)AI.AlignType << AI.TypeBitWidth << ':'
451 << AI.ABIAlign*8 << ':' << AI.PrefAlign*8;
454 if (!LegalIntWidths.empty()) {
455 OS << "-n" << (unsigned)LegalIntWidths[0];
457 for (unsigned i = 1, e = LegalIntWidths.size(); i != e; ++i)
458 OS << ':' << (unsigned)LegalIntWidths[i];
464 uint64_t TargetData::getTypeSizeInBits(Type *Ty) const {
465 assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
466 switch (Ty->getTypeID()) {
467 case Type::LabelTyID:
468 case Type::PointerTyID:
469 return getPointerSizeInBits();
470 case Type::ArrayTyID: {
471 ArrayType *ATy = cast<ArrayType>(Ty);
472 return getTypeAllocSizeInBits(ATy->getElementType())*ATy->getNumElements();
474 case Type::StructTyID:
475 // Get the layout annotation... which is lazily created on demand.
476 return getStructLayout(cast<StructType>(Ty))->getSizeInBits();
477 case Type::IntegerTyID:
478 return cast<IntegerType>(Ty)->getBitWidth();
483 case Type::FloatTyID:
485 case Type::DoubleTyID:
486 case Type::X86_MMXTyID:
488 case Type::PPC_FP128TyID:
489 case Type::FP128TyID:
491 // In memory objects this is always aligned to a higher boundary, but
492 // only 80 bits contain information.
493 case Type::X86_FP80TyID:
495 case Type::VectorTyID:
496 return cast<VectorType>(Ty)->getBitWidth();
498 llvm_unreachable("TargetData::getTypeSizeInBits(): Unsupported type");
505 \param abi_or_pref Flag that determines which alignment is returned. true
506 returns the ABI alignment, false returns the preferred alignment.
507 \param Ty The underlying type for which alignment is determined.
509 Get the ABI (\a abi_or_pref == true) or preferred alignment (\a abi_or_pref
510 == false) for the requested type \a Ty.
512 unsigned TargetData::getAlignment(Type *Ty, bool abi_or_pref) const {
515 assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
516 switch (Ty->getTypeID()) {
517 // Early escape for the non-numeric types.
518 case Type::LabelTyID:
519 case Type::PointerTyID:
521 ? getPointerABIAlignment()
522 : getPointerPrefAlignment());
523 case Type::ArrayTyID:
524 return getAlignment(cast<ArrayType>(Ty)->getElementType(), abi_or_pref);
526 case Type::StructTyID: {
527 // Packed structure types always have an ABI alignment of one.
528 if (cast<StructType>(Ty)->isPacked() && abi_or_pref)
531 // Get the layout annotation... which is lazily created on demand.
532 const StructLayout *Layout = getStructLayout(cast<StructType>(Ty));
533 unsigned Align = getAlignmentInfo(AGGREGATE_ALIGN, 0, abi_or_pref, Ty);
534 return std::max(Align, Layout->getAlignment());
536 case Type::IntegerTyID:
538 AlignType = INTEGER_ALIGN;
541 case Type::FloatTyID:
542 case Type::DoubleTyID:
543 // PPC_FP128TyID and FP128TyID have different data contents, but the
544 // same size and alignment, so they look the same here.
545 case Type::PPC_FP128TyID:
546 case Type::FP128TyID:
547 case Type::X86_FP80TyID:
548 AlignType = FLOAT_ALIGN;
550 case Type::X86_MMXTyID:
551 case Type::VectorTyID:
552 AlignType = VECTOR_ALIGN;
555 llvm_unreachable("Bad type for getAlignment!!!");
559 return getAlignmentInfo((AlignTypeEnum)AlignType, getTypeSizeInBits(Ty),
563 unsigned TargetData::getABITypeAlignment(Type *Ty) const {
564 return getAlignment(Ty, true);
567 /// getABIIntegerTypeAlignment - Return the minimum ABI-required alignment for
568 /// an integer type of the specified bitwidth.
569 unsigned TargetData::getABIIntegerTypeAlignment(unsigned BitWidth) const {
570 return getAlignmentInfo(INTEGER_ALIGN, BitWidth, true, 0);
574 unsigned TargetData::getCallFrameTypeAlignment(Type *Ty) const {
575 for (unsigned i = 0, e = Alignments.size(); i != e; ++i)
576 if (Alignments[i].AlignType == STACK_ALIGN)
577 return Alignments[i].ABIAlign;
579 return getABITypeAlignment(Ty);
582 unsigned TargetData::getPrefTypeAlignment(Type *Ty) const {
583 return getAlignment(Ty, false);
586 unsigned TargetData::getPreferredTypeAlignmentShift(Type *Ty) const {
587 unsigned Align = getPrefTypeAlignment(Ty);
588 assert(!(Align & (Align-1)) && "Alignment is not a power of two!");
589 return Log2_32(Align);
592 /// getIntPtrType - Return an unsigned integer type that is the same size or
593 /// greater to the host pointer size.
594 IntegerType *TargetData::getIntPtrType(LLVMContext &C) const {
595 return IntegerType::get(C, getPointerSizeInBits());
599 uint64_t TargetData::getIndexedOffset(Type *ptrTy,
600 ArrayRef<Value *> Indices) const {
602 assert(Ty->isPointerTy() && "Illegal argument for getIndexedOffset()");
605 generic_gep_type_iterator<Value* const*>
606 TI = gep_type_begin(ptrTy, Indices);
607 for (unsigned CurIDX = 0, EndIDX = Indices.size(); CurIDX != EndIDX;
609 if (StructType *STy = dyn_cast<StructType>(*TI)) {
610 assert(Indices[CurIDX]->getType() ==
611 Type::getInt32Ty(ptrTy->getContext()) &&
612 "Illegal struct idx");
613 unsigned FieldNo = cast<ConstantInt>(Indices[CurIDX])->getZExtValue();
615 // Get structure layout information...
616 const StructLayout *Layout = getStructLayout(STy);
618 // Add in the offset, as calculated by the structure layout info...
619 Result += Layout->getElementOffset(FieldNo);
621 // Update Ty to refer to current element
622 Ty = STy->getElementType(FieldNo);
624 // Update Ty to refer to current element
625 Ty = cast<SequentialType>(Ty)->getElementType();
627 // Get the array index and the size of each array element.
628 if (int64_t arrayIdx = cast<ConstantInt>(Indices[CurIDX])->getSExtValue())
629 Result += (uint64_t)arrayIdx * getTypeAllocSize(Ty);
636 /// getPreferredAlignment - Return the preferred alignment of the specified
637 /// global. This includes an explicitly requested alignment (if the global
639 unsigned TargetData::getPreferredAlignment(const GlobalVariable *GV) const {
640 Type *ElemType = GV->getType()->getElementType();
641 unsigned Alignment = getPrefTypeAlignment(ElemType);
642 unsigned GVAlignment = GV->getAlignment();
643 if (GVAlignment >= Alignment) {
644 Alignment = GVAlignment;
645 } else if (GVAlignment != 0) {
646 Alignment = std::max(GVAlignment, getABITypeAlignment(ElemType));
649 if (GV->hasInitializer() && GVAlignment == 0) {
650 if (Alignment < 16) {
651 // If the global is not external, see if it is large. If so, give it a
653 if (getTypeSizeInBits(ElemType) > 128)
654 Alignment = 16; // 16-byte alignment.
660 /// getPreferredAlignmentLog - Return the preferred alignment of the
661 /// specified global, returned in log form. This includes an explicitly
662 /// requested alignment (if the global has one).
663 unsigned TargetData::getPreferredAlignmentLog(const GlobalVariable *GV) const {
664 return Log2_32(getPreferredAlignment(GV));