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, 4, 4, 32); // float
151 setAlignment(FLOAT_ALIGN, 8, 8, 64); // double
152 setAlignment(VECTOR_ALIGN, 8, 8, 64); // v2i32, v1i64, ...
153 setAlignment(VECTOR_ALIGN, 16, 16, 128); // v16i8, v8i16, v4i32, ...
154 setAlignment(AGGREGATE_ALIGN, 0, 8, 0); // struct
157 std::string TargetData::parseSpecifier(StringRef Desc, TargetData *td) {
162 while (!Desc.empty()) {
163 std::pair<StringRef, StringRef> Split = Desc.split('-');
164 StringRef Token = Split.first;
170 Split = Token.split(':');
171 StringRef Specifier = Split.first;
172 Token = Split.second;
174 assert(!Specifier.empty() && "Can't be empty here");
176 switch (Specifier[0]) {
179 td->LittleEndian = false;
183 td->LittleEndian = true;
187 Split = Token.split(':');
188 int PointerMemSizeBits = getInt(Split.first);
189 if (PointerMemSizeBits < 0 || PointerMemSizeBits % 8 != 0)
190 return "invalid pointer size, must be a positive 8-bit multiple";
192 td->PointerMemSize = PointerMemSizeBits / 8;
194 // Pointer ABI alignment.
195 Split = Split.second.split(':');
196 int PointerABIAlignBits = getInt(Split.first);
197 if (PointerABIAlignBits < 0 || PointerABIAlignBits % 8 != 0) {
198 return "invalid pointer ABI alignment, "
199 "must be a positive 8-bit multiple";
202 td->PointerABIAlign = PointerABIAlignBits / 8;
204 // Pointer preferred alignment.
205 Split = Split.second.split(':');
206 int PointerPrefAlignBits = getInt(Split.first);
207 if (PointerPrefAlignBits < 0 || PointerPrefAlignBits % 8 != 0) {
208 return "invalid pointer preferred alignment, "
209 "must be a positive 8-bit multiple";
212 td->PointerPrefAlign = PointerPrefAlignBits / 8;
213 if (td->PointerPrefAlign == 0)
214 td->PointerPrefAlign = td->PointerABIAlign;
223 AlignTypeEnum AlignType;
224 char field = Specifier[0];
227 case 'i': AlignType = INTEGER_ALIGN; break;
228 case 'v': AlignType = VECTOR_ALIGN; break;
229 case 'f': AlignType = FLOAT_ALIGN; break;
230 case 'a': AlignType = AGGREGATE_ALIGN; break;
231 case 's': AlignType = STACK_ALIGN; break;
233 int Size = getInt(Specifier.substr(1));
235 return std::string("invalid ") + field + "-size field, "
239 Split = Token.split(':');
240 int ABIAlignBits = getInt(Split.first);
241 if (ABIAlignBits < 0 || ABIAlignBits % 8 != 0) {
242 return std::string("invalid ") + field +"-abi-alignment field, "
243 "must be a positive 8-bit multiple";
245 unsigned ABIAlign = ABIAlignBits / 8;
247 Split = Split.second.split(':');
249 int PrefAlignBits = getInt(Split.first);
250 if (PrefAlignBits < 0 || PrefAlignBits % 8 != 0) {
251 return std::string("invalid ") + field +"-preferred-alignment field, "
252 "must be a positive 8-bit multiple";
254 unsigned PrefAlign = PrefAlignBits / 8;
256 PrefAlign = ABIAlign;
259 td->setAlignment(AlignType, ABIAlign, PrefAlign, Size);
262 case 'n': // Native integer types.
263 Specifier = Specifier.substr(1);
265 int Width = getInt(Specifier);
267 return std::string("invalid native integer size \'") + Specifier.str() +
268 "\', must be a positive integer.";
270 if (td && Width != 0)
271 td->LegalIntWidths.push_back(Width);
272 Split = Token.split(':');
273 Specifier = Split.first;
274 Token = Split.second;
275 } while (!Specifier.empty() || !Token.empty());
277 case 'S': { // Stack natural alignment.
278 int StackNaturalAlignBits = getInt(Specifier.substr(1));
279 if (StackNaturalAlignBits < 0 || StackNaturalAlignBits % 8 != 0) {
280 return "invalid natural stack alignment (S-field), "
281 "must be a positive 8-bit multiple";
284 td->StackNaturalAlign = StackNaturalAlignBits / 8;
297 /// @note This has to exist, because this is a pass, but it should never be
299 TargetData::TargetData() : ImmutablePass(ID) {
300 report_fatal_error("Bad TargetData ctor used. "
301 "Tool did not specify a TargetData to use?");
304 TargetData::TargetData(const Module *M)
305 : ImmutablePass(ID) {
306 std::string errMsg = parseSpecifier(M->getDataLayout(), this);
307 assert(errMsg == "" && "Module M has malformed target data layout string.");
312 TargetData::setAlignment(AlignTypeEnum align_type, unsigned abi_align,
313 unsigned pref_align, uint32_t bit_width) {
314 assert(abi_align <= pref_align && "Preferred alignment worse than ABI!");
315 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
316 if (Alignments[i].AlignType == align_type &&
317 Alignments[i].TypeBitWidth == bit_width) {
318 // Update the abi, preferred alignments.
319 Alignments[i].ABIAlign = abi_align;
320 Alignments[i].PrefAlign = pref_align;
325 Alignments.push_back(TargetAlignElem::get(align_type, abi_align,
326 pref_align, bit_width));
329 /// getAlignmentInfo - Return the alignment (either ABI if ABIInfo = true or
330 /// preferred if ABIInfo = false) the target wants for the specified datatype.
331 unsigned TargetData::getAlignmentInfo(AlignTypeEnum AlignType,
332 uint32_t BitWidth, bool ABIInfo,
334 // Check to see if we have an exact match and remember the best match we see.
335 int BestMatchIdx = -1;
337 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
338 if (Alignments[i].AlignType == AlignType &&
339 Alignments[i].TypeBitWidth == BitWidth)
340 return ABIInfo ? Alignments[i].ABIAlign : Alignments[i].PrefAlign;
342 // The best match so far depends on what we're looking for.
343 if (AlignType == INTEGER_ALIGN &&
344 Alignments[i].AlignType == INTEGER_ALIGN) {
345 // The "best match" for integers is the smallest size that is larger than
346 // the BitWidth requested.
347 if (Alignments[i].TypeBitWidth > BitWidth && (BestMatchIdx == -1 ||
348 Alignments[i].TypeBitWidth < Alignments[BestMatchIdx].TypeBitWidth))
350 // However, if there isn't one that's larger, then we must use the
351 // largest one we have (see below)
352 if (LargestInt == -1 ||
353 Alignments[i].TypeBitWidth > Alignments[LargestInt].TypeBitWidth)
358 // Okay, we didn't find an exact solution. Fall back here depending on what
359 // is being looked for.
360 if (BestMatchIdx == -1) {
361 // If we didn't find an integer alignment, fall back on most conservative.
362 if (AlignType == INTEGER_ALIGN) {
363 BestMatchIdx = LargestInt;
365 assert(AlignType == VECTOR_ALIGN && "Unknown alignment type!");
367 // By default, use natural alignment for vector types. This is consistent
368 // with what clang and llvm-gcc do.
369 unsigned Align = getTypeAllocSize(cast<VectorType>(Ty)->getElementType());
370 Align *= cast<VectorType>(Ty)->getNumElements();
371 // If the alignment is not a power of 2, round up to the next power of 2.
372 // This happens for non-power-of-2 length vectors.
373 if (Align & (Align-1))
374 Align = llvm::NextPowerOf2(Align);
379 // Since we got a "best match" index, just return it.
380 return ABIInfo ? Alignments[BestMatchIdx].ABIAlign
381 : Alignments[BestMatchIdx].PrefAlign;
386 class StructLayoutMap {
387 typedef DenseMap<StructType*, StructLayout*> LayoutInfoTy;
388 LayoutInfoTy LayoutInfo;
391 virtual ~StructLayoutMap() {
392 // Remove any layouts.
393 for (LayoutInfoTy::iterator I = LayoutInfo.begin(), E = LayoutInfo.end();
395 StructLayout *Value = I->second;
396 Value->~StructLayout();
401 StructLayout *&operator[](StructType *STy) {
402 return LayoutInfo[STy];
406 virtual void dump() const {}
409 } // end anonymous namespace
411 TargetData::~TargetData() {
412 delete static_cast<StructLayoutMap*>(LayoutMap);
415 const StructLayout *TargetData::getStructLayout(StructType *Ty) const {
417 LayoutMap = new StructLayoutMap();
419 StructLayoutMap *STM = static_cast<StructLayoutMap*>(LayoutMap);
420 StructLayout *&SL = (*STM)[Ty];
423 // Otherwise, create the struct layout. Because it is variable length, we
424 // malloc it, then use placement new.
425 int NumElts = Ty->getNumElements();
427 (StructLayout *)malloc(sizeof(StructLayout)+(NumElts-1) * sizeof(uint64_t));
429 // Set SL before calling StructLayout's ctor. The ctor could cause other
430 // entries to be added to TheMap, invalidating our reference.
433 new (L) StructLayout(Ty, *this);
438 std::string TargetData::getStringRepresentation() const {
440 raw_string_ostream OS(Result);
442 OS << (LittleEndian ? "e" : "E")
443 << "-p:" << PointerMemSize*8 << ':' << PointerABIAlign*8
444 << ':' << PointerPrefAlign*8
445 << "-S" << StackNaturalAlign*8;
447 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
448 const TargetAlignElem &AI = Alignments[i];
449 OS << '-' << (char)AI.AlignType << AI.TypeBitWidth << ':'
450 << AI.ABIAlign*8 << ':' << AI.PrefAlign*8;
453 if (!LegalIntWidths.empty()) {
454 OS << "-n" << (unsigned)LegalIntWidths[0];
456 for (unsigned i = 1, e = LegalIntWidths.size(); i != e; ++i)
457 OS << ':' << (unsigned)LegalIntWidths[i];
463 uint64_t TargetData::getTypeSizeInBits(Type *Ty) const {
464 assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
465 switch (Ty->getTypeID()) {
466 case Type::LabelTyID:
467 case Type::PointerTyID:
468 return getPointerSizeInBits();
469 case Type::ArrayTyID: {
470 ArrayType *ATy = cast<ArrayType>(Ty);
471 return getTypeAllocSizeInBits(ATy->getElementType())*ATy->getNumElements();
473 case Type::StructTyID:
474 // Get the layout annotation... which is lazily created on demand.
475 return getStructLayout(cast<StructType>(Ty))->getSizeInBits();
476 case Type::IntegerTyID:
477 return cast<IntegerType>(Ty)->getBitWidth();
480 case Type::FloatTyID:
482 case Type::DoubleTyID:
483 case Type::X86_MMXTyID:
485 case Type::PPC_FP128TyID:
486 case Type::FP128TyID:
488 // In memory objects this is always aligned to a higher boundary, but
489 // only 80 bits contain information.
490 case Type::X86_FP80TyID:
492 case Type::VectorTyID:
493 return cast<VectorType>(Ty)->getBitWidth();
495 llvm_unreachable("TargetData::getTypeSizeInBits(): Unsupported type");
502 \param abi_or_pref Flag that determines which alignment is returned. true
503 returns the ABI alignment, false returns the preferred alignment.
504 \param Ty The underlying type for which alignment is determined.
506 Get the ABI (\a abi_or_pref == true) or preferred alignment (\a abi_or_pref
507 == false) for the requested type \a Ty.
509 unsigned TargetData::getAlignment(Type *Ty, bool abi_or_pref) const {
512 assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
513 switch (Ty->getTypeID()) {
514 // Early escape for the non-numeric types.
515 case Type::LabelTyID:
516 case Type::PointerTyID:
518 ? getPointerABIAlignment()
519 : getPointerPrefAlignment());
520 case Type::ArrayTyID:
521 return getAlignment(cast<ArrayType>(Ty)->getElementType(), abi_or_pref);
523 case Type::StructTyID: {
524 // Packed structure types always have an ABI alignment of one.
525 if (cast<StructType>(Ty)->isPacked() && abi_or_pref)
528 // Get the layout annotation... which is lazily created on demand.
529 const StructLayout *Layout = getStructLayout(cast<StructType>(Ty));
530 unsigned Align = getAlignmentInfo(AGGREGATE_ALIGN, 0, abi_or_pref, Ty);
531 return std::max(Align, Layout->getAlignment());
533 case Type::IntegerTyID:
535 AlignType = INTEGER_ALIGN;
537 case Type::FloatTyID:
538 case Type::DoubleTyID:
539 // PPC_FP128TyID and FP128TyID have different data contents, but the
540 // same size and alignment, so they look the same here.
541 case Type::PPC_FP128TyID:
542 case Type::FP128TyID:
543 case Type::X86_FP80TyID:
544 AlignType = FLOAT_ALIGN;
546 case Type::X86_MMXTyID:
547 case Type::VectorTyID:
548 AlignType = VECTOR_ALIGN;
551 llvm_unreachable("Bad type for getAlignment!!!");
555 return getAlignmentInfo((AlignTypeEnum)AlignType, getTypeSizeInBits(Ty),
559 unsigned TargetData::getABITypeAlignment(Type *Ty) const {
560 return getAlignment(Ty, true);
563 /// getABIIntegerTypeAlignment - Return the minimum ABI-required alignment for
564 /// an integer type of the specified bitwidth.
565 unsigned TargetData::getABIIntegerTypeAlignment(unsigned BitWidth) const {
566 return getAlignmentInfo(INTEGER_ALIGN, BitWidth, true, 0);
570 unsigned TargetData::getCallFrameTypeAlignment(Type *Ty) const {
571 for (unsigned i = 0, e = Alignments.size(); i != e; ++i)
572 if (Alignments[i].AlignType == STACK_ALIGN)
573 return Alignments[i].ABIAlign;
575 return getABITypeAlignment(Ty);
578 unsigned TargetData::getPrefTypeAlignment(Type *Ty) const {
579 return getAlignment(Ty, false);
582 unsigned TargetData::getPreferredTypeAlignmentShift(Type *Ty) const {
583 unsigned Align = getPrefTypeAlignment(Ty);
584 assert(!(Align & (Align-1)) && "Alignment is not a power of two!");
585 return Log2_32(Align);
588 /// getIntPtrType - Return an unsigned integer type that is the same size or
589 /// greater to the host pointer size.
590 IntegerType *TargetData::getIntPtrType(LLVMContext &C) const {
591 return IntegerType::get(C, getPointerSizeInBits());
595 uint64_t TargetData::getIndexedOffset(Type *ptrTy,
596 ArrayRef<Value *> Indices) const {
598 assert(Ty->isPointerTy() && "Illegal argument for getIndexedOffset()");
601 generic_gep_type_iterator<Value* const*>
602 TI = gep_type_begin(ptrTy, Indices);
603 for (unsigned CurIDX = 0, EndIDX = Indices.size(); CurIDX != EndIDX;
605 if (StructType *STy = dyn_cast<StructType>(*TI)) {
606 assert(Indices[CurIDX]->getType() ==
607 Type::getInt32Ty(ptrTy->getContext()) &&
608 "Illegal struct idx");
609 unsigned FieldNo = cast<ConstantInt>(Indices[CurIDX])->getZExtValue();
611 // Get structure layout information...
612 const StructLayout *Layout = getStructLayout(STy);
614 // Add in the offset, as calculated by the structure layout info...
615 Result += Layout->getElementOffset(FieldNo);
617 // Update Ty to refer to current element
618 Ty = STy->getElementType(FieldNo);
620 // Update Ty to refer to current element
621 Ty = cast<SequentialType>(Ty)->getElementType();
623 // Get the array index and the size of each array element.
624 if (int64_t arrayIdx = cast<ConstantInt>(Indices[CurIDX])->getSExtValue())
625 Result += (uint64_t)arrayIdx * getTypeAllocSize(Ty);
632 /// getPreferredAlignment - Return the preferred alignment of the specified
633 /// global. This includes an explicitly requested alignment (if the global
635 unsigned TargetData::getPreferredAlignment(const GlobalVariable *GV) const {
636 Type *ElemType = GV->getType()->getElementType();
637 unsigned Alignment = getPrefTypeAlignment(ElemType);
638 unsigned GVAlignment = GV->getAlignment();
639 if (GVAlignment >= Alignment) {
640 Alignment = GVAlignment;
641 } else if (GVAlignment != 0) {
642 Alignment = std::max(GVAlignment, getABITypeAlignment(ElemType));
645 if (GV->hasInitializer() && GVAlignment == 0) {
646 if (Alignment < 16) {
647 // If the global is not external, see if it is large. If so, give it a
649 if (getTypeSizeInBits(ElemType) > 128)
650 Alignment = 16; // 16-byte alignment.
656 /// getPreferredAlignmentLog - Return the preferred alignment of the
657 /// specified global, returned in log form. This includes an explicitly
658 /// requested alignment (if the global has one).
659 unsigned TargetData::getPreferredAlignmentLog(const GlobalVariable *GV) const {
660 return Log2_32(getPreferredAlignment(GV));