1 //===-- TargetData.cpp - Data size & alignment routines --------------------==//
3 // The LLVM Compiler Infrastructure
5 // This file was developed by the LLVM research group and is distributed under
6 // the University of Illinois Open Source 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/Module.h"
21 #include "llvm/DerivedTypes.h"
22 #include "llvm/Constants.h"
23 #include "llvm/Support/GetElementPtrTypeIterator.h"
24 #include "llvm/Support/MathExtras.h"
25 #include "llvm/Support/ManagedStatic.h"
26 #include "llvm/ADT/DenseMap.h"
27 #include "llvm/ADT/StringExtras.h"
33 // Handle the Pass registration stuff necessary to use TargetData's.
35 // Register the default SparcV9 implementation...
36 RegisterPass<TargetData> X("targetdata", "Target Data Layout");
38 char TargetData::ID = 0;
40 //===----------------------------------------------------------------------===//
41 // Support for StructLayout
42 //===----------------------------------------------------------------------===//
44 StructLayout::StructLayout(const StructType *ST, const TargetData &TD) {
47 NumElements = ST->getNumElements();
49 // Loop over each of the elements, placing them in memory...
50 for (unsigned i = 0, e = NumElements; i != e; ++i) {
51 const Type *Ty = ST->getElementType(i);
54 TyAlign = (ST->isPacked() ? 1 : TD.getABITypeAlignment(Ty));
55 TySize = TD.getTypeSize(Ty);
57 // Add padding if necessary to make the data element aligned properly...
58 if (StructSize % TyAlign != 0)
59 StructSize = (StructSize/TyAlign + 1) * TyAlign; // Add padding...
61 // Keep track of maximum alignment constraint
62 StructAlignment = std::max(TyAlign, StructAlignment);
64 MemberOffsets[i] = StructSize;
65 StructSize += TySize; // Consume space for this data item
68 // Empty structures have alignment of 1 byte.
69 if (StructAlignment == 0) StructAlignment = 1;
71 // Add padding to the end of the struct so that it could be put in an array
72 // and all array elements would be aligned correctly.
73 if (StructSize % StructAlignment != 0)
74 StructSize = (StructSize/StructAlignment + 1) * StructAlignment;
78 /// getElementContainingOffset - Given a valid offset into the structure,
79 /// return the structure index that contains it.
80 unsigned StructLayout::getElementContainingOffset(uint64_t Offset) const {
82 std::upper_bound(&MemberOffsets[0], &MemberOffsets[NumElements], Offset);
83 assert(SI != &MemberOffsets[0] && "Offset not in structure type!");
85 assert(*SI <= Offset && "upper_bound didn't work");
86 assert((SI == &MemberOffsets[0] || *(SI-1) < Offset) &&
87 (SI+1 == &MemberOffsets[NumElements] || *(SI+1) > Offset) &&
88 "Upper bound didn't work!");
89 return SI-&MemberOffsets[0];
92 //===----------------------------------------------------------------------===//
93 // TargetAlignElem, TargetAlign support
94 //===----------------------------------------------------------------------===//
97 TargetAlignElem::get(AlignTypeEnum align_type, unsigned char abi_align,
98 unsigned char pref_align, uint32_t bit_width) {
99 TargetAlignElem retval;
100 retval.AlignType = align_type;
101 retval.ABIAlign = abi_align;
102 retval.PrefAlign = pref_align;
103 retval.TypeBitWidth = bit_width;
108 TargetAlignElem::operator==(const TargetAlignElem &rhs) const {
109 return (AlignType == rhs.AlignType
110 && ABIAlign == rhs.ABIAlign
111 && PrefAlign == rhs.PrefAlign
112 && TypeBitWidth == rhs.TypeBitWidth);
116 TargetAlignElem::dump(std::ostream &os) const {
117 return os << AlignType
119 << ":" << (int) (ABIAlign * 8)
120 << ":" << (int) (PrefAlign * 8);
123 const TargetAlignElem TargetData::InvalidAlignmentElem =
124 TargetAlignElem::get((AlignTypeEnum) -1, 0, 0, 0);
126 //===----------------------------------------------------------------------===//
127 // TargetData Class Implementation
128 //===----------------------------------------------------------------------===//
131 A TargetDescription string consists of a sequence of hyphen-delimited
132 specifiers for target endianness, pointer size and alignments, and various
133 primitive type sizes and alignments. A typical string looks something like:
135 "E-p:32:32:32-i1:8:8-i8:8:8-i32:32:32-i64:32:64-f32:32:32-f64:32:64"
137 (note: this string is not fully specified and is only an example.)
139 Alignments come in two flavors: ABI and preferred. ABI alignment (abi_align,
140 below) dictates how a type will be aligned within an aggregate and when used
141 as an argument. Preferred alignment (pref_align, below) determines a type's
142 alignment when emitted as a global.
144 Specifier string details:
146 <i>[E|e]</i>: Endianness. "E" specifies a big-endian target data model, "e"
147 specifies a little-endian target data model.
149 <i>p:@verbatim<size>:<abi_align>:<pref_align>@endverbatim</i>: Pointer size,
150 ABI and preferred alignment.
152 <i>@verbatim<type><size>:<abi_align>:<pref_align>@endverbatim</i>: Numeric type alignment. Type is
153 one of <i>i|f|v|a</i>, corresponding to integer, floating point, vector (aka
154 packed) or aggregate. Size indicates the size, e.g., 32 or 64 bits.
156 The default string, fully specified is:
158 "E-p:64:64:64-a0:0:0-f32:32:32-f64:0:64"
159 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:0:64"
160 "-v64:64:64-v128:128:128"
162 Note that in the case of aggregates, 0 is the default ABI and preferred
163 alignment. This is a special case, where the aggregate's computed worst-case
164 alignment will be used.
166 void TargetData::init(const std::string &TargetDescription) {
167 std::string temp = TargetDescription;
169 LittleEndian = false;
172 PointerPrefAlign = PointerABIAlign;
174 // Default alignments
175 setAlignment(INTEGER_ALIGN, 1, 1, 1); // Bool
176 setAlignment(INTEGER_ALIGN, 1, 1, 8); // Byte
177 setAlignment(INTEGER_ALIGN, 2, 2, 16); // short
178 setAlignment(INTEGER_ALIGN, 4, 4, 32); // int
179 setAlignment(INTEGER_ALIGN, 4, 8, 64); // long
180 setAlignment(FLOAT_ALIGN, 4, 4, 32); // float
181 setAlignment(FLOAT_ALIGN, 8, 8, 64); // double
182 setAlignment(VECTOR_ALIGN, 8, 8, 64); // v2i32
183 setAlignment(VECTOR_ALIGN, 16, 16, 128); // v16i8, v8i16, v4i32, ...
184 setAlignment(AGGREGATE_ALIGN, 0, 8, 0); // struct, union, class, ...
186 while (!temp.empty()) {
187 std::string token = getToken(temp, "-");
188 std::string arg0 = getToken(token, ":");
189 const char *p = arg0.c_str();
192 LittleEndian = false;
198 PointerMemSize = atoi(getToken(token,":").c_str()) / 8;
199 PointerABIAlign = atoi(getToken(token,":").c_str()) / 8;
200 PointerPrefAlign = atoi(getToken(token,":").c_str()) / 8;
201 if (PointerPrefAlign == 0)
202 PointerPrefAlign = PointerABIAlign;
208 AlignTypeEnum align_type =
209 (*p == 'i' ? INTEGER_ALIGN : (*p == 'f' ? FLOAT_ALIGN :
210 (*p == 'v' ? VECTOR_ALIGN : AGGREGATE_ALIGN)));
211 uint32_t size = (uint32_t) atoi(++p);
212 unsigned char abi_align = atoi(getToken(token, ":").c_str()) / 8;
213 unsigned char pref_align = atoi(getToken(token, ":").c_str()) / 8;
215 pref_align = abi_align;
216 setAlignment(align_type, abi_align, pref_align, size);
225 TargetData::TargetData(const Module *M)
226 : ImmutablePass((intptr_t)&ID) {
227 init(M->getDataLayout());
231 TargetData::setAlignment(AlignTypeEnum align_type, unsigned char abi_align,
232 unsigned char pref_align, uint32_t bit_width) {
233 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
234 if (Alignments[i].AlignType == align_type &&
235 Alignments[i].TypeBitWidth == bit_width) {
236 // Update the abi, preferred alignments.
237 Alignments[i].ABIAlign = abi_align;
238 Alignments[i].PrefAlign = pref_align;
243 Alignments.push_back(TargetAlignElem::get(align_type, abi_align,
244 pref_align, bit_width));
247 /// getAlignmentInfo - Return the alignment (either ABI if ABIInfo = true or
248 /// preferred if ABIInfo = false) the target wants for the specified datatype.
249 unsigned TargetData::getAlignmentInfo(AlignTypeEnum AlignType,
250 uint32_t BitWidth, bool ABIInfo) const {
251 // Check to see if we have an exact match and remember the best match we see.
252 int BestMatchIdx = -1;
254 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
255 if (Alignments[i].AlignType == AlignType &&
256 Alignments[i].TypeBitWidth == BitWidth)
257 return ABIInfo ? Alignments[i].ABIAlign : Alignments[i].PrefAlign;
259 // The best match so far depends on what we're looking for.
260 if (AlignType == VECTOR_ALIGN) {
261 // If this is a specification for a smaller vector type, we will fall back
262 // to it. This happens because <128 x double> can be implemented in terms
263 // of 64 <2 x double>.
264 if (Alignments[i].AlignType == VECTOR_ALIGN &&
265 Alignments[i].TypeBitWidth < BitWidth) {
266 // Verify that we pick the biggest of the fallbacks.
267 if (BestMatchIdx == -1 ||
268 Alignments[BestMatchIdx].TypeBitWidth < BitWidth)
271 } else if (AlignType == INTEGER_ALIGN &&
272 Alignments[i].AlignType == INTEGER_ALIGN) {
273 // The "best match" for integers is the smallest size that is larger than
274 // the BitWidth requested.
275 if (Alignments[i].TypeBitWidth > BitWidth && (BestMatchIdx == -1 ||
276 Alignments[i].TypeBitWidth < Alignments[BestMatchIdx].TypeBitWidth))
278 // However, if there isn't one that's larger, then we must use the
279 // largest one we have (see below)
280 if (LargestInt == -1 ||
281 Alignments[i].TypeBitWidth > Alignments[LargestInt].TypeBitWidth)
286 // For integers, if we didn't find a best match, use the largest one found.
287 if (BestMatchIdx == -1)
288 BestMatchIdx = LargestInt;
290 // Okay, we didn't find an exact solution. Fall back here depending on what
291 // is being looked for.
292 assert(BestMatchIdx != -1 && "Didn't find alignment info for this datatype!");
294 // Since we got a "best match" index, just return it.
295 return ABIInfo ? Alignments[BestMatchIdx].ABIAlign
296 : Alignments[BestMatchIdx].PrefAlign;
299 /// LayoutInfo - The lazy cache of structure layout information maintained by
300 /// TargetData. Note that the struct types must have been free'd before
301 /// llvm_shutdown is called (and thus this is deallocated) because all the
302 /// targets with cached elements should have been destroyed.
304 typedef std::pair<const TargetData*,const StructType*> LayoutKey;
306 struct DenseMapLayoutKeyInfo {
307 static inline LayoutKey getEmptyKey() { return LayoutKey(0, 0); }
308 static inline LayoutKey getTombstoneKey() {
309 return LayoutKey((TargetData*)(intptr_t)-1, 0);
311 static unsigned getHashValue(const LayoutKey &Val) {
312 return DenseMapKeyInfo<void*>::getHashValue(Val.first) ^
313 DenseMapKeyInfo<void*>::getHashValue(Val.second);
315 static bool isPod() { return true; }
318 typedef DenseMap<LayoutKey, StructLayout*, DenseMapLayoutKeyInfo> LayoutInfoTy;
319 static ManagedStatic<LayoutInfoTy> LayoutInfo;
322 TargetData::~TargetData() {
323 if (LayoutInfo.isConstructed()) {
324 // Remove any layouts for this TD.
325 LayoutInfoTy &TheMap = *LayoutInfo;
326 for (LayoutInfoTy::iterator I = TheMap.begin(), E = TheMap.end();
328 if (I->first.first == this) {
329 I->second->~StructLayout();
339 const StructLayout *TargetData::getStructLayout(const StructType *Ty) const {
340 LayoutInfoTy &TheMap = *LayoutInfo;
342 StructLayout *&SL = TheMap[LayoutKey(this, Ty)];
345 // Otherwise, create the struct layout. Because it is variable length, we
346 // malloc it, then use placement new.
347 int NumElts = Ty->getNumElements();
349 (StructLayout *)malloc(sizeof(StructLayout)+(NumElts-1)*sizeof(uint64_t));
351 // Set SL before calling StructLayout's ctor. The ctor could cause other
352 // entries to be added to TheMap, invalidating our reference.
355 new (L) StructLayout(Ty, *this);
359 /// InvalidateStructLayoutInfo - TargetData speculatively caches StructLayout
360 /// objects. If a TargetData object is alive when types are being refined and
361 /// removed, this method must be called whenever a StructType is removed to
362 /// avoid a dangling pointer in this cache.
363 void TargetData::InvalidateStructLayoutInfo(const StructType *Ty) const {
364 if (!LayoutInfo.isConstructed()) return; // No cache.
366 LayoutInfoTy::iterator I = LayoutInfo->find(LayoutKey(this, Ty));
367 if (I != LayoutInfo->end()) {
368 I->second->~StructLayout();
370 LayoutInfo->erase(I);
375 std::string TargetData::getStringRepresentation() const {
377 repr.append(LittleEndian ? "e" : "E");
378 repr.append("-p:").append(itostr((int64_t) (PointerMemSize * 8))).
379 append(":").append(itostr((int64_t) (PointerABIAlign * 8))).
380 append(":").append(itostr((int64_t) (PointerPrefAlign * 8)));
381 for (align_const_iterator I = Alignments.begin();
382 I != Alignments.end();
384 repr.append("-").append(1, (char) I->AlignType).
385 append(utostr((int64_t) I->TypeBitWidth)).
386 append(":").append(utostr((uint64_t) (I->ABIAlign * 8))).
387 append(":").append(utostr((uint64_t) (I->PrefAlign * 8)));
393 uint64_t TargetData::getTypeSize(const Type *Ty) const {
394 assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
395 switch (Ty->getTypeID()) {
396 case Type::LabelTyID:
397 case Type::PointerTyID:
398 return getPointerSize();
399 case Type::ArrayTyID: {
400 const ArrayType *ATy = cast<ArrayType>(Ty);
402 unsigned char Alignment;
403 Size = getTypeSize(ATy->getElementType());
404 Alignment = getABITypeAlignment(ATy->getElementType());
405 uint64_t AlignedSize = (Size + Alignment - 1)/Alignment*Alignment;
406 return AlignedSize*ATy->getNumElements();
408 case Type::StructTyID: {
409 // Get the layout annotation... which is lazily created on demand.
410 const StructLayout *Layout = getStructLayout(cast<StructType>(Ty));
411 return Layout->getSizeInBytes();
413 case Type::IntegerTyID: {
414 unsigned BitWidth = cast<IntegerType>(Ty)->getBitWidth();
417 } else if (BitWidth <= 16) {
419 } else if (BitWidth <= 32) {
421 } else if (BitWidth <= 64) {
424 // The size of this > 64 bit type is chosen as a multiple of the
425 // preferred alignment of the largest "native" size the target supports.
426 // We first obtain the the alignment info for this type and then compute
427 // the next largest multiple of that size.
428 uint64_t size = getAlignmentInfo(INTEGER_ALIGN, BitWidth, false) * 8;
429 return (((BitWidth / (size)) + (BitWidth % size != 0)) * size) / 8;
435 case Type::FloatTyID:
437 case Type::DoubleTyID:
439 case Type::PPC_FP128TyID:
440 case Type::FP128TyID:
442 // In memory objects this is always aligned to a higher boundary, but
443 // only 10 bytes contain information.
444 case Type::X86_FP80TyID:
446 case Type::VectorTyID: {
447 const VectorType *PTy = cast<VectorType>(Ty);
448 return PTy->getBitWidth() / 8;
451 assert(0 && "TargetData::getTypeSize(): Unsupported type");
457 uint64_t TargetData::getTypeSizeInBits(const Type *Ty) const {
459 return cast<IntegerType>(Ty)->getBitWidth();
461 return getTypeSize(Ty) * 8;
466 \param abi_or_pref Flag that determines which alignment is returned. true
467 returns the ABI alignment, false returns the preferred alignment.
468 \param Ty The underlying type for which alignment is determined.
470 Get the ABI (\a abi_or_pref == true) or preferred alignment (\a abi_or_pref
471 == false) for the requested type \a Ty.
473 unsigned char TargetData::getAlignment(const Type *Ty, bool abi_or_pref) const {
476 assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
477 switch (Ty->getTypeID()) {
478 /* Early escape for the non-numeric types */
479 case Type::LabelTyID:
480 case Type::PointerTyID:
482 ? getPointerABIAlignment()
483 : getPointerPrefAlignment());
484 case Type::ArrayTyID:
485 return getAlignment(cast<ArrayType>(Ty)->getElementType(), abi_or_pref);
487 case Type::StructTyID: {
488 // Packed structure types always have an ABI alignment of one.
489 if (cast<StructType>(Ty)->isPacked() && abi_or_pref)
492 // Get the layout annotation... which is lazily created on demand.
493 const StructLayout *Layout = getStructLayout(cast<StructType>(Ty));
494 unsigned Align = getAlignmentInfo(AGGREGATE_ALIGN, 0, abi_or_pref);
495 return std::max(Align, (unsigned)Layout->getAlignment());
497 case Type::IntegerTyID:
499 AlignType = INTEGER_ALIGN;
501 case Type::FloatTyID:
502 case Type::DoubleTyID:
503 // PPC_FP128TyID and FP128TyID have different data contents, but the
504 // same size and alignment, so they look the same here.
505 case Type::PPC_FP128TyID:
506 case Type::FP128TyID:
507 case Type::X86_FP80TyID:
508 AlignType = FLOAT_ALIGN;
510 case Type::VectorTyID: {
511 const VectorType *VTy = cast<VectorType>(Ty);
512 // Degenerate vectors are assumed to be scalar-ized
513 if (VTy->getNumElements() == 1)
514 return getAlignment(VTy->getElementType(), abi_or_pref);
516 AlignType = VECTOR_ALIGN;
520 assert(0 && "Bad type for getAlignment!!!");
524 return getAlignmentInfo((AlignTypeEnum)AlignType, getTypeSize(Ty) * 8,
528 unsigned char TargetData::getABITypeAlignment(const Type *Ty) const {
529 return getAlignment(Ty, true);
532 unsigned char TargetData::getPrefTypeAlignment(const Type *Ty) const {
533 return getAlignment(Ty, false);
536 unsigned char TargetData::getPreferredTypeAlignmentShift(const Type *Ty) const {
537 unsigned Align = (unsigned) getPrefTypeAlignment(Ty);
538 assert(!(Align & (Align-1)) && "Alignment is not a power of two!");
539 return Log2_32(Align);
542 /// getIntPtrType - Return an unsigned integer type that is the same size or
543 /// greater to the host pointer size.
544 const Type *TargetData::getIntPtrType() const {
545 switch (getPointerSize()) {
546 default: assert(0 && "Unknown pointer size!");
547 case 2: return Type::Int16Ty;
548 case 4: return Type::Int32Ty;
549 case 8: return Type::Int64Ty;
554 uint64_t TargetData::getIndexedOffset(const Type *ptrTy, Value* const* Indices,
555 unsigned NumIndices) const {
556 const Type *Ty = ptrTy;
557 assert(isa<PointerType>(Ty) && "Illegal argument for getIndexedOffset()");
560 generic_gep_type_iterator<Value* const*>
561 TI = gep_type_begin(ptrTy, Indices, Indices+NumIndices);
562 for (unsigned CurIDX = 0; CurIDX != NumIndices; ++CurIDX, ++TI) {
563 if (const StructType *STy = dyn_cast<StructType>(*TI)) {
564 assert(Indices[CurIDX]->getType() == Type::Int32Ty &&
565 "Illegal struct idx");
566 unsigned FieldNo = cast<ConstantInt>(Indices[CurIDX])->getZExtValue();
568 // Get structure layout information...
569 const StructLayout *Layout = getStructLayout(STy);
571 // Add in the offset, as calculated by the structure layout info...
572 Result += Layout->getElementOffset(FieldNo);
574 // Update Ty to refer to current element
575 Ty = STy->getElementType(FieldNo);
577 // Update Ty to refer to current element
578 Ty = cast<SequentialType>(Ty)->getElementType();
580 // Get the array index and the size of each array element.
581 int64_t arrayIdx = cast<ConstantInt>(Indices[CurIDX])->getSExtValue();
582 Result += arrayIdx * (int64_t)getTypeSize(Ty);
589 /// getPreferredAlignmentLog - Return the preferred alignment of the
590 /// specified global, returned in log form. This includes an explicitly
591 /// requested alignment (if the global has one).
592 unsigned TargetData::getPreferredAlignmentLog(const GlobalVariable *GV) const {
593 const Type *ElemType = GV->getType()->getElementType();
594 unsigned Alignment = getPreferredTypeAlignmentShift(ElemType);
595 if (GV->getAlignment() > (1U << Alignment))
596 Alignment = Log2_32(GV->getAlignment());
598 if (GV->hasInitializer()) {
600 // If the global is not external, see if it is large. If so, give it a
602 if (getTypeSize(ElemType) > 128)
603 Alignment = 4; // 16-byte alignment.