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/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);
52 unsigned TyAlign = ST->isPacked() ?
53 1 : TD.getABITypeAlignment(Ty);
54 uint64_t TySize = ST->isPacked() ?
55 TD.getTypeStoreSize(Ty) : TD.getABITypeSize(Ty);
57 // Add padding if necessary to align the data element properly...
58 StructSize = (StructSize + TyAlign - 1)/TyAlign * TyAlign;
60 // Keep track of maximum alignment constraint
61 StructAlignment = std::max(TyAlign, StructAlignment);
63 MemberOffsets[i] = StructSize;
64 StructSize += TySize; // Consume space for this data item
67 // Empty structures have alignment of 1 byte.
68 if (StructAlignment == 0) StructAlignment = 1;
70 // Add padding to the end of the struct so that it could be put in an array
71 // and all array elements would be aligned correctly.
72 if (StructSize % StructAlignment != 0)
73 StructSize = (StructSize/StructAlignment + 1) * StructAlignment;
77 /// getElementContainingOffset - Given a valid offset into the structure,
78 /// return the structure index that contains it.
79 unsigned StructLayout::getElementContainingOffset(uint64_t Offset) const {
81 std::upper_bound(&MemberOffsets[0], &MemberOffsets[NumElements], Offset);
82 assert(SI != &MemberOffsets[0] && "Offset not in structure type!");
84 assert(*SI <= Offset && "upper_bound didn't work");
85 assert((SI == &MemberOffsets[0] || *(SI-1) <= Offset) &&
86 (SI+1 == &MemberOffsets[NumElements] || *(SI+1) > Offset) &&
87 "Upper bound didn't work!");
89 // Multiple fields can have the same offset if any of them are zero sized.
90 // For example, in { i32, [0 x i32], i32 }, searching for offset 4 will stop
91 // at the i32 element, because it is the last element at that offset. This is
92 // the right one to return, because anything after it will have a higher
93 // offset, implying that this element is non-empty.
94 return SI-&MemberOffsets[0];
97 //===----------------------------------------------------------------------===//
98 // TargetAlignElem, TargetAlign support
99 //===----------------------------------------------------------------------===//
102 TargetAlignElem::get(AlignTypeEnum align_type, unsigned char abi_align,
103 unsigned char pref_align, uint32_t bit_width) {
104 assert(abi_align <= pref_align && "Preferred alignment worse than ABI!");
105 TargetAlignElem retval;
106 retval.AlignType = align_type;
107 retval.ABIAlign = abi_align;
108 retval.PrefAlign = pref_align;
109 retval.TypeBitWidth = bit_width;
114 TargetAlignElem::operator==(const TargetAlignElem &rhs) const {
115 return (AlignType == rhs.AlignType
116 && ABIAlign == rhs.ABIAlign
117 && PrefAlign == rhs.PrefAlign
118 && TypeBitWidth == rhs.TypeBitWidth);
122 TargetAlignElem::dump(std::ostream &os) const {
123 return os << AlignType
125 << ":" << (int) (ABIAlign * 8)
126 << ":" << (int) (PrefAlign * 8);
129 const TargetAlignElem TargetData::InvalidAlignmentElem =
130 TargetAlignElem::get((AlignTypeEnum) -1, 0, 0, 0);
132 //===----------------------------------------------------------------------===//
133 // TargetData Class Implementation
134 //===----------------------------------------------------------------------===//
137 A TargetDescription string consists of a sequence of hyphen-delimited
138 specifiers for target endianness, pointer size and alignments, and various
139 primitive type sizes and alignments. A typical string looks something like:
141 "E-p:32:32:32-i1:8:8-i8:8:8-i32:32:32-i64:32:64-f32:32:32-f64:32:64"
143 (note: this string is not fully specified and is only an example.)
145 Alignments come in two flavors: ABI and preferred. ABI alignment (abi_align,
146 below) dictates how a type will be aligned within an aggregate and when used
147 as an argument. Preferred alignment (pref_align, below) determines a type's
148 alignment when emitted as a global.
150 Specifier string details:
152 <i>[E|e]</i>: Endianness. "E" specifies a big-endian target data model, "e"
153 specifies a little-endian target data model.
155 <i>p:@verbatim<size>:<abi_align>:<pref_align>@endverbatim</i>: Pointer size,
156 ABI and preferred alignment.
158 <i>@verbatim<type><size>:<abi_align>:<pref_align>@endverbatim</i>: Numeric type
160 one of <i>i|f|v|a</i>, corresponding to integer, floating point, vector (aka
161 packed) or aggregate. Size indicates the size, e.g., 32 or 64 bits.
163 The default string, fully specified is:
165 "E-p:64:64:64-a0:0:0-f32:32:32-f64:0:64"
166 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:0:64"
167 "-v64:64:64-v128:128:128"
169 Note that in the case of aggregates, 0 is the default ABI and preferred
170 alignment. This is a special case, where the aggregate's computed worst-case
171 alignment will be used.
173 void TargetData::init(const std::string &TargetDescription) {
174 std::string temp = TargetDescription;
176 LittleEndian = false;
179 PointerPrefAlign = PointerABIAlign;
181 // Default alignments
182 setAlignment(INTEGER_ALIGN, 1, 1, 1); // Bool
183 setAlignment(INTEGER_ALIGN, 1, 1, 8); // Byte
184 setAlignment(INTEGER_ALIGN, 2, 2, 16); // short
185 setAlignment(INTEGER_ALIGN, 4, 4, 32); // int
186 setAlignment(INTEGER_ALIGN, 4, 8, 64); // long
187 setAlignment(FLOAT_ALIGN, 4, 4, 32); // float
188 setAlignment(FLOAT_ALIGN, 8, 8, 64); // double
189 setAlignment(VECTOR_ALIGN, 8, 8, 64); // v2i32
190 setAlignment(VECTOR_ALIGN, 16, 16, 128); // v16i8, v8i16, v4i32, ...
191 setAlignment(AGGREGATE_ALIGN, 0, 8, 0); // struct, union, class, ...
193 while (!temp.empty()) {
194 std::string token = getToken(temp, "-");
195 std::string arg0 = getToken(token, ":");
196 const char *p = arg0.c_str();
199 LittleEndian = false;
205 PointerMemSize = atoi(getToken(token,":").c_str()) / 8;
206 PointerABIAlign = atoi(getToken(token,":").c_str()) / 8;
207 PointerPrefAlign = atoi(getToken(token,":").c_str()) / 8;
208 if (PointerPrefAlign == 0)
209 PointerPrefAlign = PointerABIAlign;
216 AlignTypeEnum align_type = STACK_ALIGN; // Dummy init, silence warning
218 case 'i': align_type = INTEGER_ALIGN; break;
219 case 'v': align_type = VECTOR_ALIGN; break;
220 case 'f': align_type = FLOAT_ALIGN; break;
221 case 'a': align_type = AGGREGATE_ALIGN; break;
222 case 's': align_type = STACK_ALIGN; break;
224 uint32_t size = (uint32_t) atoi(++p);
225 unsigned char abi_align = atoi(getToken(token, ":").c_str()) / 8;
226 unsigned char pref_align = atoi(getToken(token, ":").c_str()) / 8;
228 pref_align = abi_align;
229 setAlignment(align_type, abi_align, pref_align, size);
238 TargetData::TargetData(const Module *M)
239 : ImmutablePass((intptr_t)&ID) {
240 init(M->getDataLayout());
244 TargetData::setAlignment(AlignTypeEnum align_type, unsigned char abi_align,
245 unsigned char pref_align, uint32_t bit_width) {
246 assert(abi_align <= pref_align && "Preferred alignment worse than ABI!");
247 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
248 if (Alignments[i].AlignType == align_type &&
249 Alignments[i].TypeBitWidth == bit_width) {
250 // Update the abi, preferred alignments.
251 Alignments[i].ABIAlign = abi_align;
252 Alignments[i].PrefAlign = pref_align;
257 Alignments.push_back(TargetAlignElem::get(align_type, abi_align,
258 pref_align, bit_width));
261 /// getAlignmentInfo - Return the alignment (either ABI if ABIInfo = true or
262 /// preferred if ABIInfo = false) the target wants for the specified datatype.
263 unsigned TargetData::getAlignmentInfo(AlignTypeEnum AlignType,
264 uint32_t BitWidth, bool ABIInfo,
265 const Type *Ty) const {
266 // Check to see if we have an exact match and remember the best match we see.
267 int BestMatchIdx = -1;
269 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
270 if (Alignments[i].AlignType == AlignType &&
271 Alignments[i].TypeBitWidth == BitWidth)
272 return ABIInfo ? Alignments[i].ABIAlign : Alignments[i].PrefAlign;
274 // The best match so far depends on what we're looking for.
275 if (AlignType == VECTOR_ALIGN && Alignments[i].AlignType == VECTOR_ALIGN) {
276 // If this is a specification for a smaller vector type, we will fall back
277 // to it. This happens because <128 x double> can be implemented in terms
278 // of 64 <2 x double>.
279 if (Alignments[i].TypeBitWidth < BitWidth) {
280 // Verify that we pick the biggest of the fallbacks.
281 if (BestMatchIdx == -1 ||
282 Alignments[BestMatchIdx].TypeBitWidth < Alignments[i].TypeBitWidth)
285 } else if (AlignType == INTEGER_ALIGN &&
286 Alignments[i].AlignType == INTEGER_ALIGN) {
287 // The "best match" for integers is the smallest size that is larger than
288 // the BitWidth requested.
289 if (Alignments[i].TypeBitWidth > BitWidth && (BestMatchIdx == -1 ||
290 Alignments[i].TypeBitWidth < Alignments[BestMatchIdx].TypeBitWidth))
292 // However, if there isn't one that's larger, then we must use the
293 // largest one we have (see below)
294 if (LargestInt == -1 ||
295 Alignments[i].TypeBitWidth > Alignments[LargestInt].TypeBitWidth)
300 // Okay, we didn't find an exact solution. Fall back here depending on what
301 // is being looked for.
302 if (BestMatchIdx == -1) {
303 // If we didn't find an integer alignment, fall back on most conservative.
304 if (AlignType == INTEGER_ALIGN) {
305 BestMatchIdx = LargestInt;
307 assert(AlignType == VECTOR_ALIGN && "Unknown alignment type!");
309 // If we didn't find a vector size that is smaller or equal to this type,
310 // then we will end up scalarizing this to its element type. Just return
311 // the alignment of the element.
312 return getAlignment(cast<VectorType>(Ty)->getElementType(), ABIInfo);
316 // Since we got a "best match" index, just return it.
317 return ABIInfo ? Alignments[BestMatchIdx].ABIAlign
318 : Alignments[BestMatchIdx].PrefAlign;
321 /// LayoutInfo - The lazy cache of structure layout information maintained by
322 /// TargetData. Note that the struct types must have been free'd before
323 /// llvm_shutdown is called (and thus this is deallocated) because all the
324 /// targets with cached elements should have been destroyed.
326 typedef std::pair<const TargetData*,const StructType*> LayoutKey;
328 struct DenseMapLayoutKeyInfo {
329 static inline LayoutKey getEmptyKey() { return LayoutKey(0, 0); }
330 static inline LayoutKey getTombstoneKey() {
331 return LayoutKey((TargetData*)(intptr_t)-1, 0);
333 static unsigned getHashValue(const LayoutKey &Val) {
334 return DenseMapInfo<void*>::getHashValue(Val.first) ^
335 DenseMapInfo<void*>::getHashValue(Val.second);
337 static bool isEqual(const LayoutKey &LHS, const LayoutKey &RHS) {
341 static bool isPod() { return true; }
344 typedef DenseMap<LayoutKey, StructLayout*, DenseMapLayoutKeyInfo> LayoutInfoTy;
345 static ManagedStatic<LayoutInfoTy> LayoutInfo;
348 TargetData::~TargetData() {
349 if (LayoutInfo.isConstructed()) {
350 // Remove any layouts for this TD.
351 LayoutInfoTy &TheMap = *LayoutInfo;
352 for (LayoutInfoTy::iterator I = TheMap.begin(), E = TheMap.end();
354 if (I->first.first == this) {
355 I->second->~StructLayout();
365 const StructLayout *TargetData::getStructLayout(const StructType *Ty) const {
366 LayoutInfoTy &TheMap = *LayoutInfo;
368 StructLayout *&SL = TheMap[LayoutKey(this, Ty)];
371 // Otherwise, create the struct layout. Because it is variable length, we
372 // malloc it, then use placement new.
373 int NumElts = Ty->getNumElements();
375 (StructLayout *)malloc(sizeof(StructLayout)+(NumElts-1)*sizeof(uint64_t));
377 // Set SL before calling StructLayout's ctor. The ctor could cause other
378 // entries to be added to TheMap, invalidating our reference.
381 new (L) StructLayout(Ty, *this);
385 /// InvalidateStructLayoutInfo - TargetData speculatively caches StructLayout
386 /// objects. If a TargetData object is alive when types are being refined and
387 /// removed, this method must be called whenever a StructType is removed to
388 /// avoid a dangling pointer in this cache.
389 void TargetData::InvalidateStructLayoutInfo(const StructType *Ty) const {
390 if (!LayoutInfo.isConstructed()) return; // No cache.
392 LayoutInfoTy::iterator I = LayoutInfo->find(LayoutKey(this, Ty));
393 if (I != LayoutInfo->end()) {
394 I->second->~StructLayout();
396 LayoutInfo->erase(I);
401 std::string TargetData::getStringRepresentation() const {
403 repr.append(LittleEndian ? "e" : "E");
404 repr.append("-p:").append(itostr((int64_t) (PointerMemSize * 8))).
405 append(":").append(itostr((int64_t) (PointerABIAlign * 8))).
406 append(":").append(itostr((int64_t) (PointerPrefAlign * 8)));
407 for (align_const_iterator I = Alignments.begin();
408 I != Alignments.end();
410 repr.append("-").append(1, (char) I->AlignType).
411 append(utostr((int64_t) I->TypeBitWidth)).
412 append(":").append(utostr((uint64_t) (I->ABIAlign * 8))).
413 append(":").append(utostr((uint64_t) (I->PrefAlign * 8)));
419 uint64_t TargetData::getTypeSizeInBits(const Type *Ty) const {
420 assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
421 switch (Ty->getTypeID()) {
422 case Type::LabelTyID:
423 case Type::PointerTyID:
424 return getPointerSizeInBits();
425 case Type::ArrayTyID: {
426 const ArrayType *ATy = cast<ArrayType>(Ty);
427 return getABITypeSizeInBits(ATy->getElementType())*ATy->getNumElements();
429 case Type::StructTyID: {
430 // Get the layout annotation... which is lazily created on demand.
431 const StructLayout *Layout = getStructLayout(cast<StructType>(Ty));
432 return Layout->getSizeInBits();
434 case Type::IntegerTyID:
435 return cast<IntegerType>(Ty)->getBitWidth();
438 case Type::FloatTyID:
440 case Type::DoubleTyID:
442 case Type::PPC_FP128TyID:
443 case Type::FP128TyID:
445 // In memory objects this is always aligned to a higher boundary, but
446 // only 80 bits contain information.
447 case Type::X86_FP80TyID:
449 case Type::VectorTyID: {
450 const VectorType *PTy = cast<VectorType>(Ty);
451 return PTy->getBitWidth();
454 assert(0 && "TargetData::getTypeSizeInBits(): Unsupported type");
461 \param abi_or_pref Flag that determines which alignment is returned. true
462 returns the ABI alignment, false returns the preferred alignment.
463 \param Ty The underlying type for which alignment is determined.
465 Get the ABI (\a abi_or_pref == true) or preferred alignment (\a abi_or_pref
466 == false) for the requested type \a Ty.
468 unsigned char TargetData::getAlignment(const Type *Ty, bool abi_or_pref) const {
471 assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
472 switch (Ty->getTypeID()) {
473 /* Early escape for the non-numeric types */
474 case Type::LabelTyID:
475 case Type::PointerTyID:
477 ? getPointerABIAlignment()
478 : getPointerPrefAlignment());
479 case Type::ArrayTyID:
480 return getAlignment(cast<ArrayType>(Ty)->getElementType(), abi_or_pref);
482 case Type::StructTyID: {
483 // Packed structure types always have an ABI alignment of one.
484 if (cast<StructType>(Ty)->isPacked() && abi_or_pref)
487 // Get the layout annotation... which is lazily created on demand.
488 const StructLayout *Layout = getStructLayout(cast<StructType>(Ty));
489 unsigned Align = getAlignmentInfo(AGGREGATE_ALIGN, 0, abi_or_pref, Ty);
490 return std::max(Align, (unsigned)Layout->getAlignment());
492 case Type::IntegerTyID:
494 AlignType = INTEGER_ALIGN;
496 case Type::FloatTyID:
497 case Type::DoubleTyID:
498 // PPC_FP128TyID and FP128TyID have different data contents, but the
499 // same size and alignment, so they look the same here.
500 case Type::PPC_FP128TyID:
501 case Type::FP128TyID:
502 case Type::X86_FP80TyID:
503 AlignType = FLOAT_ALIGN;
505 case Type::VectorTyID:
506 AlignType = VECTOR_ALIGN;
509 assert(0 && "Bad type for getAlignment!!!");
513 return getAlignmentInfo((AlignTypeEnum)AlignType, getTypeSizeInBits(Ty),
517 unsigned char TargetData::getABITypeAlignment(const Type *Ty) const {
518 return getAlignment(Ty, true);
521 unsigned char TargetData::getCallFrameTypeAlignment(const Type *Ty) const {
522 for (unsigned i = 0, e = Alignments.size(); i != e; ++i)
523 if (Alignments[i].AlignType == STACK_ALIGN)
524 return Alignments[i].ABIAlign;
526 return getABITypeAlignment(Ty);
529 unsigned char TargetData::getPrefTypeAlignment(const Type *Ty) const {
530 return getAlignment(Ty, false);
533 unsigned char TargetData::getPreferredTypeAlignmentShift(const Type *Ty) const {
534 unsigned Align = (unsigned) getPrefTypeAlignment(Ty);
535 assert(!(Align & (Align-1)) && "Alignment is not a power of two!");
536 return Log2_32(Align);
539 /// getIntPtrType - Return an unsigned integer type that is the same size or
540 /// greater to the host pointer size.
541 const Type *TargetData::getIntPtrType() const {
542 return IntegerType::get(getPointerSizeInBits());
546 uint64_t TargetData::getIndexedOffset(const Type *ptrTy, Value* const* Indices,
547 unsigned NumIndices) const {
548 const Type *Ty = ptrTy;
549 assert(isa<PointerType>(Ty) && "Illegal argument for getIndexedOffset()");
552 generic_gep_type_iterator<Value* const*>
553 TI = gep_type_begin(ptrTy, Indices, Indices+NumIndices);
554 for (unsigned CurIDX = 0; CurIDX != NumIndices; ++CurIDX, ++TI) {
555 if (const StructType *STy = dyn_cast<StructType>(*TI)) {
556 assert(Indices[CurIDX]->getType() == Type::Int32Ty &&
557 "Illegal struct idx");
558 unsigned FieldNo = cast<ConstantInt>(Indices[CurIDX])->getZExtValue();
560 // Get structure layout information...
561 const StructLayout *Layout = getStructLayout(STy);
563 // Add in the offset, as calculated by the structure layout info...
564 Result += Layout->getElementOffset(FieldNo);
566 // Update Ty to refer to current element
567 Ty = STy->getElementType(FieldNo);
569 // Update Ty to refer to current element
570 Ty = cast<SequentialType>(Ty)->getElementType();
572 // Get the array index and the size of each array element.
573 int64_t arrayIdx = cast<ConstantInt>(Indices[CurIDX])->getSExtValue();
574 Result += arrayIdx * (int64_t)getABITypeSize(Ty);
581 /// getPreferredAlignment - Return the preferred alignment of the specified
582 /// global. This includes an explicitly requested alignment (if the global
584 unsigned TargetData::getPreferredAlignment(const GlobalVariable *GV) const {
585 const Type *ElemType = GV->getType()->getElementType();
586 unsigned Alignment = getPrefTypeAlignment(ElemType);
587 if (GV->getAlignment() > Alignment)
588 Alignment = GV->getAlignment();
590 if (GV->hasInitializer()) {
591 if (Alignment < 16) {
592 // If the global is not external, see if it is large. If so, give it a
594 if (getTypeSizeInBits(ElemType) > 128)
595 Alignment = 16; // 16-byte alignment.
601 /// getPreferredAlignmentLog - Return the preferred alignment of the
602 /// specified global, returned in log form. This includes an explicitly
603 /// requested alignment (if the global has one).
604 unsigned TargetData::getPreferredAlignmentLog(const GlobalVariable *GV) const {
605 return Log2_32(getPreferredAlignment(GV));