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, ...
185 setAlignment(STACK_ALIGN, 0, 8, 0); // objects on the stack
187 while (!temp.empty()) {
188 std::string token = getToken(temp, "-");
189 std::string arg0 = getToken(token, ":");
190 const char *p = arg0.c_str();
193 LittleEndian = false;
199 PointerMemSize = atoi(getToken(token,":").c_str()) / 8;
200 PointerABIAlign = atoi(getToken(token,":").c_str()) / 8;
201 PointerPrefAlign = atoi(getToken(token,":").c_str()) / 8;
202 if (PointerPrefAlign == 0)
203 PointerPrefAlign = PointerABIAlign;
210 AlignTypeEnum align_type;
212 case 'i': align_type = INTEGER_ALIGN; break;
213 case 'v': align_type = VECTOR_ALIGN; break;
214 case 'f': align_type = FLOAT_ALIGN; break;
215 case 'a': align_type = AGGREGATE_ALIGN; break;
216 case 's': align_type = STACK_ALIGN; break;
218 uint32_t size = (uint32_t) atoi(++p);
219 unsigned char abi_align = atoi(getToken(token, ":").c_str()) / 8;
220 unsigned char pref_align = atoi(getToken(token, ":").c_str()) / 8;
222 pref_align = abi_align;
223 setAlignment(align_type, abi_align, pref_align, size);
232 TargetData::TargetData(const Module *M)
233 : ImmutablePass((intptr_t)&ID) {
234 init(M->getDataLayout());
238 TargetData::setAlignment(AlignTypeEnum align_type, unsigned char abi_align,
239 unsigned char pref_align, uint32_t bit_width) {
240 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
241 if (Alignments[i].AlignType == align_type &&
242 Alignments[i].TypeBitWidth == bit_width) {
243 // Update the abi, preferred alignments.
244 Alignments[i].ABIAlign = abi_align;
245 Alignments[i].PrefAlign = pref_align;
250 Alignments.push_back(TargetAlignElem::get(align_type, abi_align,
251 pref_align, bit_width));
254 /// getAlignmentInfo - Return the alignment (either ABI if ABIInfo = true or
255 /// preferred if ABIInfo = false) the target wants for the specified datatype.
256 unsigned TargetData::getAlignmentInfo(AlignTypeEnum AlignType,
257 uint32_t BitWidth, bool ABIInfo) const {
258 // Check to see if we have an exact match and remember the best match we see.
259 int BestMatchIdx = -1;
261 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
262 if (Alignments[i].AlignType == AlignType &&
263 Alignments[i].TypeBitWidth == BitWidth)
264 return ABIInfo ? Alignments[i].ABIAlign : Alignments[i].PrefAlign;
266 // The best match so far depends on what we're looking for.
267 if (AlignType == VECTOR_ALIGN) {
268 // If this is a specification for a smaller vector type, we will fall back
269 // to it. This happens because <128 x double> can be implemented in terms
270 // of 64 <2 x double>.
271 if (Alignments[i].AlignType == VECTOR_ALIGN &&
272 Alignments[i].TypeBitWidth < BitWidth) {
273 // Verify that we pick the biggest of the fallbacks.
274 if (BestMatchIdx == -1 ||
275 Alignments[BestMatchIdx].TypeBitWidth < BitWidth)
278 } else if (AlignType == INTEGER_ALIGN &&
279 Alignments[i].AlignType == INTEGER_ALIGN) {
280 // The "best match" for integers is the smallest size that is larger than
281 // the BitWidth requested.
282 if (Alignments[i].TypeBitWidth > BitWidth && (BestMatchIdx == -1 ||
283 Alignments[i].TypeBitWidth < Alignments[BestMatchIdx].TypeBitWidth))
285 // However, if there isn't one that's larger, then we must use the
286 // largest one we have (see below)
287 if (LargestInt == -1 ||
288 Alignments[i].TypeBitWidth > Alignments[LargestInt].TypeBitWidth)
293 // For integers, if we didn't find a best match, use the largest one found.
294 if (BestMatchIdx == -1)
295 BestMatchIdx = LargestInt;
297 // Okay, we didn't find an exact solution. Fall back here depending on what
298 // is being looked for.
299 assert(BestMatchIdx != -1 && "Didn't find alignment info for this datatype!");
301 // Since we got a "best match" index, just return it.
302 return ABIInfo ? Alignments[BestMatchIdx].ABIAlign
303 : Alignments[BestMatchIdx].PrefAlign;
306 /// LayoutInfo - The lazy cache of structure layout information maintained by
307 /// TargetData. Note that the struct types must have been free'd before
308 /// llvm_shutdown is called (and thus this is deallocated) because all the
309 /// targets with cached elements should have been destroyed.
311 typedef std::pair<const TargetData*,const StructType*> LayoutKey;
313 struct DenseMapLayoutKeyInfo {
314 static inline LayoutKey getEmptyKey() { return LayoutKey(0, 0); }
315 static inline LayoutKey getTombstoneKey() {
316 return LayoutKey((TargetData*)(intptr_t)-1, 0);
318 static unsigned getHashValue(const LayoutKey &Val) {
319 return DenseMapKeyInfo<void*>::getHashValue(Val.first) ^
320 DenseMapKeyInfo<void*>::getHashValue(Val.second);
322 static bool isPod() { return true; }
325 typedef DenseMap<LayoutKey, StructLayout*, DenseMapLayoutKeyInfo> LayoutInfoTy;
326 static ManagedStatic<LayoutInfoTy> LayoutInfo;
329 TargetData::~TargetData() {
330 if (LayoutInfo.isConstructed()) {
331 // Remove any layouts for this TD.
332 LayoutInfoTy &TheMap = *LayoutInfo;
333 for (LayoutInfoTy::iterator I = TheMap.begin(), E = TheMap.end();
335 if (I->first.first == this) {
336 I->second->~StructLayout();
346 const StructLayout *TargetData::getStructLayout(const StructType *Ty) const {
347 LayoutInfoTy &TheMap = *LayoutInfo;
349 StructLayout *&SL = TheMap[LayoutKey(this, Ty)];
352 // Otherwise, create the struct layout. Because it is variable length, we
353 // malloc it, then use placement new.
354 int NumElts = Ty->getNumElements();
356 (StructLayout *)malloc(sizeof(StructLayout)+(NumElts-1)*sizeof(uint64_t));
358 // Set SL before calling StructLayout's ctor. The ctor could cause other
359 // entries to be added to TheMap, invalidating our reference.
362 new (L) StructLayout(Ty, *this);
366 /// InvalidateStructLayoutInfo - TargetData speculatively caches StructLayout
367 /// objects. If a TargetData object is alive when types are being refined and
368 /// removed, this method must be called whenever a StructType is removed to
369 /// avoid a dangling pointer in this cache.
370 void TargetData::InvalidateStructLayoutInfo(const StructType *Ty) const {
371 if (!LayoutInfo.isConstructed()) return; // No cache.
373 LayoutInfoTy::iterator I = LayoutInfo->find(LayoutKey(this, Ty));
374 if (I != LayoutInfo->end()) {
375 I->second->~StructLayout();
377 LayoutInfo->erase(I);
382 std::string TargetData::getStringRepresentation() const {
384 repr.append(LittleEndian ? "e" : "E");
385 repr.append("-p:").append(itostr((int64_t) (PointerMemSize * 8))).
386 append(":").append(itostr((int64_t) (PointerABIAlign * 8))).
387 append(":").append(itostr((int64_t) (PointerPrefAlign * 8)));
388 for (align_const_iterator I = Alignments.begin();
389 I != Alignments.end();
391 repr.append("-").append(1, (char) I->AlignType).
392 append(utostr((int64_t) I->TypeBitWidth)).
393 append(":").append(utostr((uint64_t) (I->ABIAlign * 8))).
394 append(":").append(utostr((uint64_t) (I->PrefAlign * 8)));
400 uint64_t TargetData::getTypeSize(const Type *Ty) const {
401 assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
402 switch (Ty->getTypeID()) {
403 case Type::LabelTyID:
404 case Type::PointerTyID:
405 return getPointerSize();
406 case Type::ArrayTyID: {
407 const ArrayType *ATy = cast<ArrayType>(Ty);
409 unsigned char Alignment;
410 Size = getTypeSize(ATy->getElementType());
411 Alignment = getABITypeAlignment(ATy->getElementType());
412 uint64_t AlignedSize = (Size + Alignment - 1)/Alignment*Alignment;
413 return AlignedSize*ATy->getNumElements();
415 case Type::StructTyID: {
416 // Get the layout annotation... which is lazily created on demand.
417 const StructLayout *Layout = getStructLayout(cast<StructType>(Ty));
418 return Layout->getSizeInBytes();
420 case Type::IntegerTyID: {
421 unsigned BitWidth = cast<IntegerType>(Ty)->getBitWidth();
424 } else if (BitWidth <= 16) {
426 } else if (BitWidth <= 32) {
428 } else if (BitWidth <= 64) {
431 // The size of this > 64 bit type is chosen as a multiple of the
432 // preferred alignment of the largest "native" size the target supports.
433 // We first obtain the the alignment info for this type and then compute
434 // the next largest multiple of that size.
435 uint64_t size = getAlignmentInfo(INTEGER_ALIGN, BitWidth, false) * 8;
436 return (((BitWidth / (size)) + (BitWidth % size != 0)) * size) / 8;
442 case Type::FloatTyID:
444 case Type::DoubleTyID:
446 case Type::PPC_FP128TyID:
447 case Type::FP128TyID:
449 // In memory objects this is always aligned to a higher boundary, but
450 // only 10 bytes contain information.
451 case Type::X86_FP80TyID:
453 case Type::VectorTyID: {
454 const VectorType *PTy = cast<VectorType>(Ty);
455 return PTy->getBitWidth() / 8;
458 assert(0 && "TargetData::getTypeSize(): Unsupported type");
464 uint64_t TargetData::getTypeSizeInBits(const Type *Ty) const {
466 return cast<IntegerType>(Ty)->getBitWidth();
468 return getTypeSize(Ty) * 8;
473 \param abi_or_pref Flag that determines which alignment is returned. true
474 returns the ABI alignment, false returns the preferred alignment.
475 \param Ty The underlying type for which alignment is determined.
477 Get the ABI (\a abi_or_pref == true) or preferred alignment (\a abi_or_pref
478 == false) for the requested type \a Ty.
480 unsigned char TargetData::getAlignment(const Type *Ty, bool abi_or_pref) const {
483 assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
484 switch (Ty->getTypeID()) {
485 /* Early escape for the non-numeric types */
486 case Type::LabelTyID:
487 case Type::PointerTyID:
489 ? getPointerABIAlignment()
490 : getPointerPrefAlignment());
491 case Type::ArrayTyID:
492 return getAlignment(cast<ArrayType>(Ty)->getElementType(), abi_or_pref);
494 case Type::StructTyID: {
495 // Packed structure types always have an ABI alignment of one.
496 if (cast<StructType>(Ty)->isPacked() && abi_or_pref)
499 // Get the layout annotation... which is lazily created on demand.
500 const StructLayout *Layout = getStructLayout(cast<StructType>(Ty));
501 unsigned Align = getAlignmentInfo(AGGREGATE_ALIGN, 0, abi_or_pref);
502 return std::max(Align, (unsigned)Layout->getAlignment());
504 case Type::IntegerTyID:
506 AlignType = INTEGER_ALIGN;
508 case Type::FloatTyID:
509 case Type::DoubleTyID:
510 // PPC_FP128TyID and FP128TyID have different data contents, but the
511 // same size and alignment, so they look the same here.
512 case Type::PPC_FP128TyID:
513 case Type::FP128TyID:
514 case Type::X86_FP80TyID:
515 AlignType = FLOAT_ALIGN;
517 case Type::VectorTyID: {
518 const VectorType *VTy = cast<VectorType>(Ty);
519 // Degenerate vectors are assumed to be scalar-ized
520 if (VTy->getNumElements() == 1)
521 return getAlignment(VTy->getElementType(), abi_or_pref);
523 AlignType = VECTOR_ALIGN;
527 assert(0 && "Bad type for getAlignment!!!");
531 return getAlignmentInfo((AlignTypeEnum)AlignType, getTypeSize(Ty) * 8,
535 unsigned char TargetData::getABITypeAlignment(const Type *Ty) const {
536 return getAlignment(Ty, true);
539 unsigned char TargetData::getCallFrameTypeAlignment(const Type *Ty) const {
540 for (unsigned i = 0, e = Alignments.size(); i != e; ++i)
541 if (Alignments[i].AlignType == STACK_ALIGN)
542 return Alignments[i].ABIAlign;
544 return getABITypeAlignment(Ty);
547 unsigned char TargetData::getPrefTypeAlignment(const Type *Ty) const {
548 return getAlignment(Ty, false);
551 unsigned char TargetData::getPreferredTypeAlignmentShift(const Type *Ty) const {
552 unsigned Align = (unsigned) getPrefTypeAlignment(Ty);
553 assert(!(Align & (Align-1)) && "Alignment is not a power of two!");
554 return Log2_32(Align);
557 /// getIntPtrType - Return an unsigned integer type that is the same size or
558 /// greater to the host pointer size.
559 const Type *TargetData::getIntPtrType() const {
560 switch (getPointerSize()) {
561 default: assert(0 && "Unknown pointer size!");
562 case 2: return Type::Int16Ty;
563 case 4: return Type::Int32Ty;
564 case 8: return Type::Int64Ty;
569 uint64_t TargetData::getIndexedOffset(const Type *ptrTy, Value* const* Indices,
570 unsigned NumIndices) const {
571 const Type *Ty = ptrTy;
572 assert(isa<PointerType>(Ty) && "Illegal argument for getIndexedOffset()");
575 generic_gep_type_iterator<Value* const*>
576 TI = gep_type_begin(ptrTy, Indices, Indices+NumIndices);
577 for (unsigned CurIDX = 0; CurIDX != NumIndices; ++CurIDX, ++TI) {
578 if (const StructType *STy = dyn_cast<StructType>(*TI)) {
579 assert(Indices[CurIDX]->getType() == Type::Int32Ty &&
580 "Illegal struct idx");
581 unsigned FieldNo = cast<ConstantInt>(Indices[CurIDX])->getZExtValue();
583 // Get structure layout information...
584 const StructLayout *Layout = getStructLayout(STy);
586 // Add in the offset, as calculated by the structure layout info...
587 Result += Layout->getElementOffset(FieldNo);
589 // Update Ty to refer to current element
590 Ty = STy->getElementType(FieldNo);
592 // Update Ty to refer to current element
593 Ty = cast<SequentialType>(Ty)->getElementType();
595 // Get the array index and the size of each array element.
596 int64_t arrayIdx = cast<ConstantInt>(Indices[CurIDX])->getSExtValue();
597 Result += arrayIdx * (int64_t)getTypeSize(Ty);
604 /// getPreferredAlignmentLog - Return the preferred alignment of the
605 /// specified global, returned in log form. This includes an explicitly
606 /// requested alignment (if the global has one).
607 unsigned TargetData::getPreferredAlignmentLog(const GlobalVariable *GV) const {
608 const Type *ElemType = GV->getType()->getElementType();
609 unsigned Alignment = getPreferredTypeAlignmentShift(ElemType);
610 if (GV->getAlignment() > (1U << Alignment))
611 Alignment = Log2_32(GV->getAlignment());
613 if (GV->hasInitializer()) {
615 // If the global is not external, see if it is large. If so, give it a
617 if (getTypeSize(ElemType) > 128)
618 Alignment = 4; // 16-byte alignment.