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", false,
39 char TargetData::ID = 0;
41 //===----------------------------------------------------------------------===//
42 // Support for StructLayout
43 //===----------------------------------------------------------------------===//
45 StructLayout::StructLayout(const StructType *ST, const TargetData &TD) {
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 const Type *Ty = ST->getElementType(i);
53 unsigned TyAlign = ST->isPacked() ?
54 1 : TD.getABITypeAlignment(Ty);
55 uint64_t TySize = ST->isPacked() ?
56 TD.getTypeStoreSize(Ty) : TD.getABITypeSize(Ty);
58 // Add padding if necessary to align the data element properly...
59 StructSize = (StructSize + TyAlign - 1)/TyAlign * TyAlign;
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!");
90 // Multiple fields can have the same offset if any of them are zero sized.
91 // For example, in { i32, [0 x i32], i32 }, searching for offset 4 will stop
92 // at the i32 element, because it is the last element at that offset. This is
93 // the right one to return, because anything after it will have a higher
94 // offset, implying that this element is non-empty.
95 return SI-&MemberOffsets[0];
98 //===----------------------------------------------------------------------===//
99 // TargetAlignElem, TargetAlign support
100 //===----------------------------------------------------------------------===//
103 TargetAlignElem::get(AlignTypeEnum align_type, unsigned char abi_align,
104 unsigned char pref_align, uint32_t bit_width) {
105 assert(abi_align <= pref_align && "Preferred alignment worse than ABI!");
106 TargetAlignElem retval;
107 retval.AlignType = align_type;
108 retval.ABIAlign = abi_align;
109 retval.PrefAlign = pref_align;
110 retval.TypeBitWidth = bit_width;
115 TargetAlignElem::operator==(const TargetAlignElem &rhs) const {
116 return (AlignType == rhs.AlignType
117 && ABIAlign == rhs.ABIAlign
118 && PrefAlign == rhs.PrefAlign
119 && TypeBitWidth == rhs.TypeBitWidth);
123 TargetAlignElem::dump(std::ostream &os) const {
124 return os << AlignType
126 << ":" << (int) (ABIAlign * 8)
127 << ":" << (int) (PrefAlign * 8);
130 const TargetAlignElem TargetData::InvalidAlignmentElem =
131 TargetAlignElem::get((AlignTypeEnum) -1, 0, 0, 0);
133 //===----------------------------------------------------------------------===//
134 // TargetData Class Implementation
135 //===----------------------------------------------------------------------===//
138 A TargetDescription string consists of a sequence of hyphen-delimited
139 specifiers for target endianness, pointer size and alignments, and various
140 primitive type sizes and alignments. A typical string looks something like:
142 "E-p:32:32:32-i1:8:8-i8:8:8-i32:32:32-i64:32:64-f32:32:32-f64:32:64"
144 (note: this string is not fully specified and is only an example.)
146 Alignments come in two flavors: ABI and preferred. ABI alignment (abi_align,
147 below) dictates how a type will be aligned within an aggregate and when used
148 as an argument. Preferred alignment (pref_align, below) determines a type's
149 alignment when emitted as a global.
151 Specifier string details:
153 <i>[E|e]</i>: Endianness. "E" specifies a big-endian target data model, "e"
154 specifies a little-endian target data model.
156 <i>p:@verbatim<size>:<abi_align>:<pref_align>@endverbatim</i>: Pointer size,
157 ABI and preferred alignment.
159 <i>@verbatim<type><size>:<abi_align>:<pref_align>@endverbatim</i>: Numeric type
161 one of <i>i|f|v|a</i>, corresponding to integer, floating point, vector (aka
162 packed) or aggregate. Size indicates the size, e.g., 32 or 64 bits.
164 The default string, fully specified is:
166 "E-p:64:64:64-a0:0:0-f32:32:32-f64:0:64"
167 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:0:64"
168 "-v64:64:64-v128:128:128"
170 Note that in the case of aggregates, 0 is the default ABI and preferred
171 alignment. This is a special case, where the aggregate's computed worst-case
172 alignment will be used.
174 void TargetData::init(const std::string &TargetDescription) {
175 std::string temp = TargetDescription;
177 LittleEndian = false;
180 PointerPrefAlign = PointerABIAlign;
182 // Default alignments
183 setAlignment(INTEGER_ALIGN, 1, 1, 1); // Bool
184 setAlignment(INTEGER_ALIGN, 1, 1, 8); // Byte
185 setAlignment(INTEGER_ALIGN, 2, 2, 16); // short
186 setAlignment(INTEGER_ALIGN, 4, 4, 32); // int
187 setAlignment(INTEGER_ALIGN, 4, 8, 64); // long
188 setAlignment(FLOAT_ALIGN, 4, 4, 32); // float
189 setAlignment(FLOAT_ALIGN, 8, 8, 64); // double
190 setAlignment(VECTOR_ALIGN, 8, 8, 64); // v2i32
191 setAlignment(VECTOR_ALIGN, 16, 16, 128); // v16i8, v8i16, v4i32, ...
192 setAlignment(AGGREGATE_ALIGN, 0, 8, 0); // struct, union, class, ...
194 while (!temp.empty()) {
195 std::string token = getToken(temp, "-");
196 std::string arg0 = getToken(token, ":");
197 const char *p = arg0.c_str();
200 LittleEndian = false;
206 PointerMemSize = atoi(getToken(token,":").c_str()) / 8;
207 PointerABIAlign = atoi(getToken(token,":").c_str()) / 8;
208 PointerPrefAlign = atoi(getToken(token,":").c_str()) / 8;
209 if (PointerPrefAlign == 0)
210 PointerPrefAlign = PointerABIAlign;
217 AlignTypeEnum align_type = STACK_ALIGN; // Dummy init, silence warning
219 case 'i': align_type = INTEGER_ALIGN; break;
220 case 'v': align_type = VECTOR_ALIGN; break;
221 case 'f': align_type = FLOAT_ALIGN; break;
222 case 'a': align_type = AGGREGATE_ALIGN; break;
223 case 's': align_type = STACK_ALIGN; break;
225 uint32_t size = (uint32_t) atoi(++p);
226 unsigned char abi_align = atoi(getToken(token, ":").c_str()) / 8;
227 unsigned char pref_align = atoi(getToken(token, ":").c_str()) / 8;
229 pref_align = abi_align;
230 setAlignment(align_type, abi_align, pref_align, size);
239 TargetData::TargetData(const Module *M)
240 : ImmutablePass((intptr_t)&ID) {
241 init(M->getDataLayout());
245 TargetData::setAlignment(AlignTypeEnum align_type, unsigned char abi_align,
246 unsigned char pref_align, uint32_t bit_width) {
247 assert(abi_align <= pref_align && "Preferred alignment worse than ABI!");
248 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
249 if (Alignments[i].AlignType == align_type &&
250 Alignments[i].TypeBitWidth == bit_width) {
251 // Update the abi, preferred alignments.
252 Alignments[i].ABIAlign = abi_align;
253 Alignments[i].PrefAlign = pref_align;
258 Alignments.push_back(TargetAlignElem::get(align_type, abi_align,
259 pref_align, bit_width));
262 /// getAlignmentInfo - Return the alignment (either ABI if ABIInfo = true or
263 /// preferred if ABIInfo = false) the target wants for the specified datatype.
264 unsigned TargetData::getAlignmentInfo(AlignTypeEnum AlignType,
265 uint32_t BitWidth, bool ABIInfo,
266 const Type *Ty) const {
267 // Check to see if we have an exact match and remember the best match we see.
268 int BestMatchIdx = -1;
270 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
271 if (Alignments[i].AlignType == AlignType &&
272 Alignments[i].TypeBitWidth == BitWidth)
273 return ABIInfo ? Alignments[i].ABIAlign : Alignments[i].PrefAlign;
275 // The best match so far depends on what we're looking for.
276 if (AlignType == VECTOR_ALIGN && Alignments[i].AlignType == VECTOR_ALIGN) {
277 // If this is a specification for a smaller vector type, we will fall back
278 // to it. This happens because <128 x double> can be implemented in terms
279 // of 64 <2 x double>.
280 if (Alignments[i].TypeBitWidth < BitWidth) {
281 // Verify that we pick the biggest of the fallbacks.
282 if (BestMatchIdx == -1 ||
283 Alignments[BestMatchIdx].TypeBitWidth < Alignments[i].TypeBitWidth)
286 } else if (AlignType == INTEGER_ALIGN &&
287 Alignments[i].AlignType == INTEGER_ALIGN) {
288 // The "best match" for integers is the smallest size that is larger than
289 // the BitWidth requested.
290 if (Alignments[i].TypeBitWidth > BitWidth && (BestMatchIdx == -1 ||
291 Alignments[i].TypeBitWidth < Alignments[BestMatchIdx].TypeBitWidth))
293 // However, if there isn't one that's larger, then we must use the
294 // largest one we have (see below)
295 if (LargestInt == -1 ||
296 Alignments[i].TypeBitWidth > Alignments[LargestInt].TypeBitWidth)
301 // Okay, we didn't find an exact solution. Fall back here depending on what
302 // is being looked for.
303 if (BestMatchIdx == -1) {
304 // If we didn't find an integer alignment, fall back on most conservative.
305 if (AlignType == INTEGER_ALIGN) {
306 BestMatchIdx = LargestInt;
308 assert(AlignType == VECTOR_ALIGN && "Unknown alignment type!");
310 // If we didn't find a vector size that is smaller or equal to this type,
311 // then we will end up scalarizing this to its element type. Just return
312 // the alignment of the element.
313 return getAlignment(cast<VectorType>(Ty)->getElementType(), ABIInfo);
317 // Since we got a "best match" index, just return it.
318 return ABIInfo ? Alignments[BestMatchIdx].ABIAlign
319 : Alignments[BestMatchIdx].PrefAlign;
322 /// LayoutInfo - The lazy cache of structure layout information maintained by
323 /// TargetData. Note that the struct types must have been free'd before
324 /// llvm_shutdown is called (and thus this is deallocated) because all the
325 /// targets with cached elements should have been destroyed.
327 typedef std::pair<const TargetData*,const StructType*> LayoutKey;
329 struct DenseMapLayoutKeyInfo {
330 static inline LayoutKey getEmptyKey() { return LayoutKey(0, 0); }
331 static inline LayoutKey getTombstoneKey() {
332 return LayoutKey((TargetData*)(intptr_t)-1, 0);
334 static unsigned getHashValue(const LayoutKey &Val) {
335 return DenseMapInfo<void*>::getHashValue(Val.first) ^
336 DenseMapInfo<void*>::getHashValue(Val.second);
338 static bool isEqual(const LayoutKey &LHS, const LayoutKey &RHS) {
342 static bool isPod() { return true; }
345 typedef DenseMap<LayoutKey, StructLayout*, DenseMapLayoutKeyInfo> LayoutInfoTy;
346 static ManagedStatic<LayoutInfoTy> LayoutInfo;
349 TargetData::~TargetData() {
350 if (LayoutInfo.isConstructed()) {
351 // Remove any layouts for this TD.
352 LayoutInfoTy &TheMap = *LayoutInfo;
353 for (LayoutInfoTy::iterator I = TheMap.begin(), E = TheMap.end();
355 if (I->first.first == this) {
356 I->second->~StructLayout();
366 const StructLayout *TargetData::getStructLayout(const StructType *Ty) const {
367 LayoutInfoTy &TheMap = *LayoutInfo;
369 StructLayout *&SL = TheMap[LayoutKey(this, Ty)];
372 // Otherwise, create the struct layout. Because it is variable length, we
373 // malloc it, then use placement new.
374 int NumElts = Ty->getNumElements();
376 (StructLayout *)malloc(sizeof(StructLayout)+(NumElts-1)*sizeof(uint64_t));
378 // Set SL before calling StructLayout's ctor. The ctor could cause other
379 // entries to be added to TheMap, invalidating our reference.
382 new (L) StructLayout(Ty, *this);
386 /// InvalidateStructLayoutInfo - TargetData speculatively caches StructLayout
387 /// objects. If a TargetData object is alive when types are being refined and
388 /// removed, this method must be called whenever a StructType is removed to
389 /// avoid a dangling pointer in this cache.
390 void TargetData::InvalidateStructLayoutInfo(const StructType *Ty) const {
391 if (!LayoutInfo.isConstructed()) return; // No cache.
393 LayoutInfoTy::iterator I = LayoutInfo->find(LayoutKey(this, Ty));
394 if (I != LayoutInfo->end()) {
395 I->second->~StructLayout();
397 LayoutInfo->erase(I);
402 std::string TargetData::getStringRepresentation() const {
404 repr.append(LittleEndian ? "e" : "E");
405 repr.append("-p:").append(itostr((int64_t) (PointerMemSize * 8))).
406 append(":").append(itostr((int64_t) (PointerABIAlign * 8))).
407 append(":").append(itostr((int64_t) (PointerPrefAlign * 8)));
408 for (align_const_iterator I = Alignments.begin();
409 I != Alignments.end();
411 repr.append("-").append(1, (char) I->AlignType).
412 append(utostr((int64_t) I->TypeBitWidth)).
413 append(":").append(utostr((uint64_t) (I->ABIAlign * 8))).
414 append(":").append(utostr((uint64_t) (I->PrefAlign * 8)));
420 uint64_t TargetData::getTypeSizeInBits(const Type *Ty) const {
421 assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
422 switch (Ty->getTypeID()) {
423 case Type::LabelTyID:
424 case Type::PointerTyID:
425 return getPointerSizeInBits();
426 case Type::ArrayTyID: {
427 const ArrayType *ATy = cast<ArrayType>(Ty);
428 return getABITypeSizeInBits(ATy->getElementType())*ATy->getNumElements();
430 case Type::StructTyID: {
431 // Get the layout annotation... which is lazily created on demand.
432 const StructLayout *Layout = getStructLayout(cast<StructType>(Ty));
433 return Layout->getSizeInBits();
435 case Type::IntegerTyID:
436 return cast<IntegerType>(Ty)->getBitWidth();
439 case Type::FloatTyID:
441 case Type::DoubleTyID:
443 case Type::PPC_FP128TyID:
444 case Type::FP128TyID:
446 // In memory objects this is always aligned to a higher boundary, but
447 // only 80 bits contain information.
448 case Type::X86_FP80TyID:
450 case Type::VectorTyID: {
451 const VectorType *PTy = cast<VectorType>(Ty);
452 return PTy->getBitWidth();
455 assert(0 && "TargetData::getTypeSizeInBits(): Unsupported type");
462 \param abi_or_pref Flag that determines which alignment is returned. true
463 returns the ABI alignment, false returns the preferred alignment.
464 \param Ty The underlying type for which alignment is determined.
466 Get the ABI (\a abi_or_pref == true) or preferred alignment (\a abi_or_pref
467 == false) for the requested type \a Ty.
469 unsigned char TargetData::getAlignment(const Type *Ty, bool abi_or_pref) const {
472 assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
473 switch (Ty->getTypeID()) {
474 /* Early escape for the non-numeric types */
475 case Type::LabelTyID:
476 case Type::PointerTyID:
478 ? getPointerABIAlignment()
479 : getPointerPrefAlignment());
480 case Type::ArrayTyID:
481 return getAlignment(cast<ArrayType>(Ty)->getElementType(), abi_or_pref);
483 case Type::StructTyID: {
484 // Packed structure types always have an ABI alignment of one.
485 if (cast<StructType>(Ty)->isPacked() && abi_or_pref)
488 // Get the layout annotation... which is lazily created on demand.
489 const StructLayout *Layout = getStructLayout(cast<StructType>(Ty));
490 unsigned Align = getAlignmentInfo(AGGREGATE_ALIGN, 0, abi_or_pref, Ty);
491 return std::max(Align, (unsigned)Layout->getAlignment());
493 case Type::IntegerTyID:
495 AlignType = INTEGER_ALIGN;
497 case Type::FloatTyID:
498 case Type::DoubleTyID:
499 // PPC_FP128TyID and FP128TyID have different data contents, but the
500 // same size and alignment, so they look the same here.
501 case Type::PPC_FP128TyID:
502 case Type::FP128TyID:
503 case Type::X86_FP80TyID:
504 AlignType = FLOAT_ALIGN;
506 case Type::VectorTyID:
507 AlignType = VECTOR_ALIGN;
510 assert(0 && "Bad type for getAlignment!!!");
514 return getAlignmentInfo((AlignTypeEnum)AlignType, getTypeSizeInBits(Ty),
518 unsigned char TargetData::getABITypeAlignment(const Type *Ty) const {
519 return getAlignment(Ty, true);
522 unsigned char TargetData::getCallFrameTypeAlignment(const Type *Ty) const {
523 for (unsigned i = 0, e = Alignments.size(); i != e; ++i)
524 if (Alignments[i].AlignType == STACK_ALIGN)
525 return Alignments[i].ABIAlign;
527 return getABITypeAlignment(Ty);
530 unsigned char TargetData::getPrefTypeAlignment(const Type *Ty) const {
531 return getAlignment(Ty, false);
534 unsigned char TargetData::getPreferredTypeAlignmentShift(const Type *Ty) const {
535 unsigned Align = (unsigned) getPrefTypeAlignment(Ty);
536 assert(!(Align & (Align-1)) && "Alignment is not a power of two!");
537 return Log2_32(Align);
540 /// getIntPtrType - Return an unsigned integer type that is the same size or
541 /// greater to the host pointer size.
542 const Type *TargetData::getIntPtrType() const {
543 return IntegerType::get(getPointerSizeInBits());
547 uint64_t TargetData::getIndexedOffset(const Type *ptrTy, Value* const* Indices,
548 unsigned NumIndices) const {
549 const Type *Ty = ptrTy;
550 assert(isa<PointerType>(Ty) && "Illegal argument for getIndexedOffset()");
553 generic_gep_type_iterator<Value* const*>
554 TI = gep_type_begin(ptrTy, Indices, Indices+NumIndices);
555 for (unsigned CurIDX = 0; CurIDX != NumIndices; ++CurIDX, ++TI) {
556 if (const StructType *STy = dyn_cast<StructType>(*TI)) {
557 assert(Indices[CurIDX]->getType() == Type::Int32Ty &&
558 "Illegal struct idx");
559 unsigned FieldNo = cast<ConstantInt>(Indices[CurIDX])->getZExtValue();
561 // Get structure layout information...
562 const StructLayout *Layout = getStructLayout(STy);
564 // Add in the offset, as calculated by the structure layout info...
565 Result += Layout->getElementOffset(FieldNo);
567 // Update Ty to refer to current element
568 Ty = STy->getElementType(FieldNo);
570 // Update Ty to refer to current element
571 Ty = cast<SequentialType>(Ty)->getElementType();
573 // Get the array index and the size of each array element.
574 int64_t arrayIdx = cast<ConstantInt>(Indices[CurIDX])->getSExtValue();
575 Result += arrayIdx * (int64_t)getABITypeSize(Ty);
582 /// getPreferredAlignment - Return the preferred alignment of the specified
583 /// global. This includes an explicitly requested alignment (if the global
585 unsigned TargetData::getPreferredAlignment(const GlobalVariable *GV) const {
586 const Type *ElemType = GV->getType()->getElementType();
587 unsigned Alignment = getPrefTypeAlignment(ElemType);
588 if (GV->getAlignment() > Alignment)
589 Alignment = GV->getAlignment();
591 if (GV->hasInitializer()) {
592 if (Alignment < 16) {
593 // If the global is not external, see if it is large. If so, give it a
595 if (getTypeSizeInBits(ElemType) > 128)
596 Alignment = 16; // 16-byte alignment.
602 /// getPreferredAlignmentLog - Return the preferred alignment of the
603 /// specified global, returned in log form. This includes an explicitly
604 /// requested alignment (if the global has one).
605 unsigned TargetData::getPreferredAlignmentLog(const GlobalVariable *GV) const {
606 return Log2_32(getPreferredAlignment(GV));