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/System/Mutex.h"
27 #include "llvm/ADT/DenseMap.h"
28 #include "llvm/ADT/StringExtras.h"
33 // Handle the Pass registration stuff necessary to use TargetData's.
35 // Register the default SparcV9 implementation...
36 static RegisterPass<TargetData> X("targetdata", "Target Data Layout", false,
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() ? 1 : TD.getABITypeAlignment(Ty);
54 // Add padding if necessary to align the data element properly.
55 if ((StructSize & (TyAlign-1)) != 0)
56 StructSize = TargetData::RoundUpAlignment(StructSize, TyAlign);
58 // Keep track of maximum alignment constraint.
59 StructAlignment = std::max(TyAlign, StructAlignment);
61 MemberOffsets[i] = StructSize;
62 StructSize += TD.getTypeAllocSize(Ty); // Consume space for this data item
65 // Empty structures have alignment of 1 byte.
66 if (StructAlignment == 0) StructAlignment = 1;
68 // Add padding to the end of the struct so that it could be put in an array
69 // and all array elements would be aligned correctly.
70 if ((StructSize & (StructAlignment-1)) != 0)
71 StructSize = TargetData::RoundUpAlignment(StructSize, StructAlignment);
75 /// getElementContainingOffset - Given a valid offset into the structure,
76 /// return the structure index that contains it.
77 unsigned StructLayout::getElementContainingOffset(uint64_t Offset) const {
79 std::upper_bound(&MemberOffsets[0], &MemberOffsets[NumElements], Offset);
80 assert(SI != &MemberOffsets[0] && "Offset not in structure type!");
82 assert(*SI <= Offset && "upper_bound didn't work");
83 assert((SI == &MemberOffsets[0] || *(SI-1) <= Offset) &&
84 (SI+1 == &MemberOffsets[NumElements] || *(SI+1) > Offset) &&
85 "Upper bound didn't work!");
87 // Multiple fields can have the same offset if any of them are zero sized.
88 // For example, in { i32, [0 x i32], i32 }, searching for offset 4 will stop
89 // at the i32 element, because it is the last element at that offset. This is
90 // the right one to return, because anything after it will have a higher
91 // offset, implying that this element is non-empty.
92 return SI-&MemberOffsets[0];
95 //===----------------------------------------------------------------------===//
96 // TargetAlignElem, TargetAlign support
97 //===----------------------------------------------------------------------===//
100 TargetAlignElem::get(AlignTypeEnum align_type, unsigned char abi_align,
101 unsigned char pref_align, uint32_t bit_width) {
102 assert(abi_align <= pref_align && "Preferred alignment worse than ABI!");
103 TargetAlignElem retval;
104 retval.AlignType = align_type;
105 retval.ABIAlign = abi_align;
106 retval.PrefAlign = pref_align;
107 retval.TypeBitWidth = bit_width;
112 TargetAlignElem::operator==(const TargetAlignElem &rhs) const {
113 return (AlignType == rhs.AlignType
114 && ABIAlign == rhs.ABIAlign
115 && PrefAlign == rhs.PrefAlign
116 && TypeBitWidth == rhs.TypeBitWidth);
120 TargetAlignElem::dump(std::ostream &os) const {
121 return os << AlignType
123 << ":" << (int) (ABIAlign * 8)
124 << ":" << (int) (PrefAlign * 8);
127 const TargetAlignElem TargetData::InvalidAlignmentElem =
128 TargetAlignElem::get((AlignTypeEnum) -1, 0, 0, 0);
130 //===----------------------------------------------------------------------===//
131 // TargetData Class Implementation
132 //===----------------------------------------------------------------------===//
135 A TargetDescription string consists of a sequence of hyphen-delimited
136 specifiers for target endianness, pointer size and alignments, and various
137 primitive type sizes and alignments. A typical string looks something like:
139 "E-p:32:32:32-i1:8:8-i8:8:8-i32:32:32-i64:32:64-f32:32:32-f64:32:64"
141 (note: this string is not fully specified and is only an example.)
143 Alignments come in two flavors: ABI and preferred. ABI alignment (abi_align,
144 below) dictates how a type will be aligned within an aggregate and when used
145 as an argument. Preferred alignment (pref_align, below) determines a type's
146 alignment when emitted as a global.
148 Specifier string details:
150 <i>[E|e]</i>: Endianness. "E" specifies a big-endian target data model, "e"
151 specifies a little-endian target data model.
153 <i>p:@verbatim<size>:<abi_align>:<pref_align>@endverbatim</i>: Pointer size,
154 ABI and preferred alignment.
156 <i>@verbatim<type><size>:<abi_align>:<pref_align>@endverbatim</i>: Numeric type
158 one of <i>i|f|v|a</i>, corresponding to integer, floating point, vector (aka
159 packed) or aggregate. Size indicates the size, e.g., 32 or 64 bits.
161 The default string, fully specified is:
163 "E-p:64:64:64-a0:0:0-f32:32:32-f64:0:64"
164 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:0:64"
165 "-v64:64:64-v128:128:128"
167 Note that in the case of aggregates, 0 is the default ABI and preferred
168 alignment. This is a special case, where the aggregate's computed worst-case
169 alignment will be used.
171 void TargetData::init(const std::string &TargetDescription) {
172 std::string temp = TargetDescription;
174 LittleEndian = false;
177 PointerPrefAlign = PointerABIAlign;
179 // Default alignments
180 setAlignment(INTEGER_ALIGN, 1, 1, 1); // i1
181 setAlignment(INTEGER_ALIGN, 1, 1, 8); // i8
182 setAlignment(INTEGER_ALIGN, 2, 2, 16); // i16
183 setAlignment(INTEGER_ALIGN, 4, 4, 32); // i32
184 setAlignment(INTEGER_ALIGN, 4, 8, 64); // i64
185 setAlignment(FLOAT_ALIGN, 4, 4, 32); // float
186 setAlignment(FLOAT_ALIGN, 8, 8, 64); // double
187 setAlignment(VECTOR_ALIGN, 8, 8, 64); // v2i32
188 setAlignment(VECTOR_ALIGN, 16, 16, 128); // v16i8, v8i16, v4i32, ...
189 setAlignment(AGGREGATE_ALIGN, 0, 8, 0); // struct, union, class, ...
191 while (!temp.empty()) {
192 std::string token = getToken(temp, "-");
193 std::string arg0 = getToken(token, ":");
194 const char *p = arg0.c_str();
197 LittleEndian = false;
203 PointerMemSize = atoi(getToken(token,":").c_str()) / 8;
204 PointerABIAlign = atoi(getToken(token,":").c_str()) / 8;
205 PointerPrefAlign = atoi(getToken(token,":").c_str()) / 8;
206 if (PointerPrefAlign == 0)
207 PointerPrefAlign = PointerABIAlign;
214 AlignTypeEnum align_type = STACK_ALIGN; // Dummy init, silence warning
216 case 'i': align_type = INTEGER_ALIGN; break;
217 case 'v': align_type = VECTOR_ALIGN; break;
218 case 'f': align_type = FLOAT_ALIGN; break;
219 case 'a': align_type = AGGREGATE_ALIGN; break;
220 case 's': align_type = STACK_ALIGN; break;
222 uint32_t size = (uint32_t) atoi(++p);
223 unsigned char abi_align = atoi(getToken(token, ":").c_str()) / 8;
224 unsigned char pref_align = atoi(getToken(token, ":").c_str()) / 8;
226 pref_align = abi_align;
227 setAlignment(align_type, abi_align, pref_align, size);
236 TargetData::TargetData(const Module *M)
237 : ImmutablePass(&ID) {
238 init(M->getDataLayout());
242 TargetData::setAlignment(AlignTypeEnum align_type, unsigned char abi_align,
243 unsigned char pref_align, uint32_t bit_width) {
244 assert(abi_align <= pref_align && "Preferred alignment worse than ABI!");
245 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
246 if (Alignments[i].AlignType == align_type &&
247 Alignments[i].TypeBitWidth == bit_width) {
248 // Update the abi, preferred alignments.
249 Alignments[i].ABIAlign = abi_align;
250 Alignments[i].PrefAlign = pref_align;
255 Alignments.push_back(TargetAlignElem::get(align_type, abi_align,
256 pref_align, bit_width));
259 /// getAlignmentInfo - Return the alignment (either ABI if ABIInfo = true or
260 /// preferred if ABIInfo = false) the target wants for the specified datatype.
261 unsigned TargetData::getAlignmentInfo(AlignTypeEnum AlignType,
262 uint32_t BitWidth, bool ABIInfo,
263 const Type *Ty) const {
264 // Check to see if we have an exact match and remember the best match we see.
265 int BestMatchIdx = -1;
267 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
268 if (Alignments[i].AlignType == AlignType &&
269 Alignments[i].TypeBitWidth == BitWidth)
270 return ABIInfo ? Alignments[i].ABIAlign : Alignments[i].PrefAlign;
272 // The best match so far depends on what we're looking for.
273 if (AlignType == VECTOR_ALIGN && Alignments[i].AlignType == VECTOR_ALIGN) {
274 // If this is a specification for a smaller vector type, we will fall back
275 // to it. This happens because <128 x double> can be implemented in terms
276 // of 64 <2 x double>.
277 if (Alignments[i].TypeBitWidth < BitWidth) {
278 // Verify that we pick the biggest of the fallbacks.
279 if (BestMatchIdx == -1 ||
280 Alignments[BestMatchIdx].TypeBitWidth < Alignments[i].TypeBitWidth)
283 } else if (AlignType == INTEGER_ALIGN &&
284 Alignments[i].AlignType == INTEGER_ALIGN) {
285 // The "best match" for integers is the smallest size that is larger than
286 // the BitWidth requested.
287 if (Alignments[i].TypeBitWidth > BitWidth && (BestMatchIdx == -1 ||
288 Alignments[i].TypeBitWidth < Alignments[BestMatchIdx].TypeBitWidth))
290 // However, if there isn't one that's larger, then we must use the
291 // largest one we have (see below)
292 if (LargestInt == -1 ||
293 Alignments[i].TypeBitWidth > Alignments[LargestInt].TypeBitWidth)
298 // Okay, we didn't find an exact solution. Fall back here depending on what
299 // is being looked for.
300 if (BestMatchIdx == -1) {
301 // If we didn't find an integer alignment, fall back on most conservative.
302 if (AlignType == INTEGER_ALIGN) {
303 BestMatchIdx = LargestInt;
305 assert(AlignType == VECTOR_ALIGN && "Unknown alignment type!");
307 // If we didn't find a vector size that is smaller or equal to this type,
308 // then we will end up scalarizing this to its element type. Just return
309 // the alignment of the element.
310 return getAlignment(cast<VectorType>(Ty)->getElementType(), ABIInfo);
314 // Since we got a "best match" index, just return it.
315 return ABIInfo ? Alignments[BestMatchIdx].ABIAlign
316 : 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;
348 static ManagedStatic<LayoutInfoTy> LayoutInfo;
349 static ManagedStatic<sys::SmartMutex<true> > LayoutLock;
351 TargetData::~TargetData() {
352 if (!LayoutInfo.isConstructed())
355 sys::SmartScopedLock<true> Lock(&*LayoutLock);
356 // Remove any layouts for this TD.
357 LayoutInfoTy &TheMap = *LayoutInfo;
358 for (LayoutInfoTy::iterator I = TheMap.begin(), E = TheMap.end(); I != E; ) {
359 if (I->first.first == this) {
360 I->second->~StructLayout();
369 const StructLayout *TargetData::getStructLayout(const StructType *Ty) const {
370 LayoutInfoTy &TheMap = *LayoutInfo;
372 sys::SmartScopedLock<true> Lock(&*LayoutLock);
373 StructLayout *&SL = TheMap[LayoutKey(this, Ty)];
376 // Otherwise, create the struct layout. Because it is variable length, we
377 // malloc it, then use placement new.
378 int NumElts = Ty->getNumElements();
380 (StructLayout *)malloc(sizeof(StructLayout)+(NumElts-1)*sizeof(uint64_t));
382 // Set SL before calling StructLayout's ctor. The ctor could cause other
383 // entries to be added to TheMap, invalidating our reference.
386 new (L) StructLayout(Ty, *this);
390 /// InvalidateStructLayoutInfo - TargetData speculatively caches StructLayout
391 /// objects. If a TargetData object is alive when types are being refined and
392 /// removed, this method must be called whenever a StructType is removed to
393 /// avoid a dangling pointer in this cache.
394 void TargetData::InvalidateStructLayoutInfo(const StructType *Ty) const {
395 if (!LayoutInfo.isConstructed()) return; // No cache.
397 sys::SmartScopedLock<true> Lock(&*LayoutLock);
398 LayoutInfoTy::iterator I = LayoutInfo->find(LayoutKey(this, Ty));
399 if (I == LayoutInfo->end()) return;
401 I->second->~StructLayout();
403 LayoutInfo->erase(I);
407 std::string TargetData::getStringRepresentation() const {
409 repr.append(LittleEndian ? "e" : "E");
410 repr.append("-p:").append(itostr((int64_t) (PointerMemSize * 8))).
411 append(":").append(itostr((int64_t) (PointerABIAlign * 8))).
412 append(":").append(itostr((int64_t) (PointerPrefAlign * 8)));
413 for (align_const_iterator I = Alignments.begin();
414 I != Alignments.end();
416 repr.append("-").append(1, (char) I->AlignType).
417 append(utostr((int64_t) I->TypeBitWidth)).
418 append(":").append(utostr((uint64_t) (I->ABIAlign * 8))).
419 append(":").append(utostr((uint64_t) (I->PrefAlign * 8)));
425 uint64_t TargetData::getTypeSizeInBits(const Type *Ty) const {
426 assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
427 switch (Ty->getTypeID()) {
428 case Type::LabelTyID:
429 case Type::PointerTyID:
430 return getPointerSizeInBits();
431 case Type::ArrayTyID: {
432 const ArrayType *ATy = cast<ArrayType>(Ty);
433 return getTypeAllocSizeInBits(ATy->getElementType())*ATy->getNumElements();
435 case Type::StructTyID:
436 // Get the layout annotation... which is lazily created on demand.
437 return getStructLayout(cast<StructType>(Ty))->getSizeInBits();
438 case Type::IntegerTyID:
439 return cast<IntegerType>(Ty)->getBitWidth();
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 80 bits contain information.
451 case Type::X86_FP80TyID:
453 case Type::VectorTyID:
454 return cast<VectorType>(Ty)->getBitWidth();
456 assert(0 && "TargetData::getTypeSizeInBits(): Unsupported type");
463 \param abi_or_pref Flag that determines which alignment is returned. true
464 returns the ABI alignment, false returns the preferred alignment.
465 \param Ty The underlying type for which alignment is determined.
467 Get the ABI (\a abi_or_pref == true) or preferred alignment (\a abi_or_pref
468 == false) for the requested type \a Ty.
470 unsigned char TargetData::getAlignment(const Type *Ty, bool abi_or_pref) const {
473 assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
474 switch (Ty->getTypeID()) {
475 // Early escape for the non-numeric types.
476 case Type::LabelTyID:
477 case Type::PointerTyID:
479 ? getPointerABIAlignment()
480 : getPointerPrefAlignment());
481 case Type::ArrayTyID:
482 return getAlignment(cast<ArrayType>(Ty)->getElementType(), abi_or_pref);
484 case Type::StructTyID: {
485 // Packed structure types always have an ABI alignment of one.
486 if (cast<StructType>(Ty)->isPacked() && abi_or_pref)
489 // Get the layout annotation... which is lazily created on demand.
490 const StructLayout *Layout = getStructLayout(cast<StructType>(Ty));
491 unsigned Align = getAlignmentInfo(AGGREGATE_ALIGN, 0, abi_or_pref, Ty);
492 return std::max(Align, (unsigned)Layout->getAlignment());
494 case Type::IntegerTyID:
496 AlignType = INTEGER_ALIGN;
498 case Type::FloatTyID:
499 case Type::DoubleTyID:
500 // PPC_FP128TyID and FP128TyID have different data contents, but the
501 // same size and alignment, so they look the same here.
502 case Type::PPC_FP128TyID:
503 case Type::FP128TyID:
504 case Type::X86_FP80TyID:
505 AlignType = FLOAT_ALIGN;
507 case Type::VectorTyID:
508 AlignType = VECTOR_ALIGN;
511 assert(0 && "Bad type for getAlignment!!!");
515 return getAlignmentInfo((AlignTypeEnum)AlignType, getTypeSizeInBits(Ty),
519 unsigned char TargetData::getABITypeAlignment(const Type *Ty) const {
520 return getAlignment(Ty, true);
523 unsigned char TargetData::getCallFrameTypeAlignment(const Type *Ty) const {
524 for (unsigned i = 0, e = Alignments.size(); i != e; ++i)
525 if (Alignments[i].AlignType == STACK_ALIGN)
526 return Alignments[i].ABIAlign;
528 return getABITypeAlignment(Ty);
531 unsigned char TargetData::getPrefTypeAlignment(const Type *Ty) const {
532 return getAlignment(Ty, false);
535 unsigned char TargetData::getPreferredTypeAlignmentShift(const Type *Ty) const {
536 unsigned Align = (unsigned) getPrefTypeAlignment(Ty);
537 assert(!(Align & (Align-1)) && "Alignment is not a power of two!");
538 return Log2_32(Align);
541 /// getIntPtrType - Return an unsigned integer type that is the same size or
542 /// greater to the host pointer size.
543 const IntegerType *TargetData::getIntPtrType() const {
544 return IntegerType::get(getPointerSizeInBits());
548 uint64_t TargetData::getIndexedOffset(const Type *ptrTy, Value* const* Indices,
549 unsigned NumIndices) const {
550 const Type *Ty = ptrTy;
551 assert(isa<PointerType>(Ty) && "Illegal argument for getIndexedOffset()");
554 generic_gep_type_iterator<Value* const*>
555 TI = gep_type_begin(ptrTy, Indices, Indices+NumIndices);
556 for (unsigned CurIDX = 0; CurIDX != NumIndices; ++CurIDX, ++TI) {
557 if (const StructType *STy = dyn_cast<StructType>(*TI)) {
558 assert(Indices[CurIDX]->getType() == Type::Int32Ty &&
559 "Illegal struct idx");
560 unsigned FieldNo = cast<ConstantInt>(Indices[CurIDX])->getZExtValue();
562 // Get structure layout information...
563 const StructLayout *Layout = getStructLayout(STy);
565 // Add in the offset, as calculated by the structure layout info...
566 Result += Layout->getElementOffset(FieldNo);
568 // Update Ty to refer to current element
569 Ty = STy->getElementType(FieldNo);
571 // Update Ty to refer to current element
572 Ty = cast<SequentialType>(Ty)->getElementType();
574 // Get the array index and the size of each array element.
575 int64_t arrayIdx = cast<ConstantInt>(Indices[CurIDX])->getSExtValue();
576 Result += arrayIdx * (int64_t)getTypeAllocSize(Ty);
583 /// getPreferredAlignment - Return the preferred alignment of the specified
584 /// global. This includes an explicitly requested alignment (if the global
586 unsigned TargetData::getPreferredAlignment(const GlobalVariable *GV) const {
587 const Type *ElemType = GV->getType()->getElementType();
588 unsigned Alignment = getPrefTypeAlignment(ElemType);
589 if (GV->getAlignment() > Alignment)
590 Alignment = GV->getAlignment();
592 if (GV->hasInitializer()) {
593 if (Alignment < 16) {
594 // If the global is not external, see if it is large. If so, give it a
596 if (getTypeSizeInBits(ElemType) > 128)
597 Alignment = 16; // 16-byte alignment.
603 /// getPreferredAlignmentLog - Return the preferred alignment of the
604 /// specified global, returned in log form. This includes an explicitly
605 /// requested alignment (if the global has one).
606 unsigned TargetData::getPreferredAlignmentLog(const GlobalVariable *GV) const {
607 return Log2_32(getPreferredAlignment(GV));