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"
32 // Handle the Pass registration stuff necessary to use TargetData's.
34 // Register the default SparcV9 implementation...
35 static RegisterPass<TargetData> X("targetdata", "Target Data Layout", false,
37 char TargetData::ID = 0;
39 //===----------------------------------------------------------------------===//
40 // Support for StructLayout
41 //===----------------------------------------------------------------------===//
43 StructLayout::StructLayout(const StructType *ST, const TargetData &TD) {
46 NumElements = ST->getNumElements();
48 // Loop over each of the elements, placing them in memory...
49 for (unsigned i = 0, e = NumElements; i != e; ++i) {
50 const Type *Ty = ST->getElementType(i);
51 unsigned TyAlign = ST->isPacked() ? 1 : TD.getABITypeAlignment(Ty);
53 // Add padding if necessary to align the data element properly...
54 StructSize = (StructSize + TyAlign - 1)/TyAlign * TyAlign;
56 // Keep track of maximum alignment constraint
57 StructAlignment = std::max(TyAlign, StructAlignment);
59 MemberOffsets[i] = StructSize;
60 StructSize += TD.getABITypeSize(Ty); // Consume space for this data item
63 // Empty structures have alignment of 1 byte.
64 if (StructAlignment == 0) StructAlignment = 1;
66 // Add padding to the end of the struct so that it could be put in an array
67 // and all array elements would be aligned correctly.
68 if (StructSize % StructAlignment != 0)
69 StructSize = (StructSize/StructAlignment + 1) * StructAlignment;
73 /// getElementContainingOffset - Given a valid offset into the structure,
74 /// return the structure index that contains it.
75 unsigned StructLayout::getElementContainingOffset(uint64_t Offset) const {
77 std::upper_bound(&MemberOffsets[0], &MemberOffsets[NumElements], Offset);
78 assert(SI != &MemberOffsets[0] && "Offset not in structure type!");
80 assert(*SI <= Offset && "upper_bound didn't work");
81 assert((SI == &MemberOffsets[0] || *(SI-1) <= Offset) &&
82 (SI+1 == &MemberOffsets[NumElements] || *(SI+1) > Offset) &&
83 "Upper bound didn't work!");
85 // Multiple fields can have the same offset if any of them are zero sized.
86 // For example, in { i32, [0 x i32], i32 }, searching for offset 4 will stop
87 // at the i32 element, because it is the last element at that offset. This is
88 // the right one to return, because anything after it will have a higher
89 // offset, implying that this element is non-empty.
90 return SI-&MemberOffsets[0];
93 //===----------------------------------------------------------------------===//
94 // TargetAlignElem, TargetAlign support
95 //===----------------------------------------------------------------------===//
98 TargetAlignElem::get(AlignTypeEnum align_type, unsigned char abi_align,
99 unsigned char pref_align, uint32_t bit_width) {
100 assert(abi_align <= pref_align && "Preferred alignment worse than ABI!");
101 TargetAlignElem retval;
102 retval.AlignType = align_type;
103 retval.ABIAlign = abi_align;
104 retval.PrefAlign = pref_align;
105 retval.TypeBitWidth = bit_width;
110 TargetAlignElem::operator==(const TargetAlignElem &rhs) const {
111 return (AlignType == rhs.AlignType
112 && ABIAlign == rhs.ABIAlign
113 && PrefAlign == rhs.PrefAlign
114 && TypeBitWidth == rhs.TypeBitWidth);
118 TargetAlignElem::dump(std::ostream &os) const {
119 return os << AlignType
121 << ":" << (int) (ABIAlign * 8)
122 << ":" << (int) (PrefAlign * 8);
125 const TargetAlignElem TargetData::InvalidAlignmentElem =
126 TargetAlignElem::get((AlignTypeEnum) -1, 0, 0, 0);
128 //===----------------------------------------------------------------------===//
129 // TargetData Class Implementation
130 //===----------------------------------------------------------------------===//
133 A TargetDescription string consists of a sequence of hyphen-delimited
134 specifiers for target endianness, pointer size and alignments, and various
135 primitive type sizes and alignments. A typical string looks something like:
137 "E-p:32:32:32-i1:8:8-i8:8:8-i32:32:32-i64:32:64-f32:32:32-f64:32:64"
139 (note: this string is not fully specified and is only an example.)
141 Alignments come in two flavors: ABI and preferred. ABI alignment (abi_align,
142 below) dictates how a type will be aligned within an aggregate and when used
143 as an argument. Preferred alignment (pref_align, below) determines a type's
144 alignment when emitted as a global.
146 Specifier string details:
148 <i>[E|e]</i>: Endianness. "E" specifies a big-endian target data model, "e"
149 specifies a little-endian target data model.
151 <i>p:@verbatim<size>:<abi_align>:<pref_align>@endverbatim</i>: Pointer size,
152 ABI and preferred alignment.
154 <i>@verbatim<type><size>:<abi_align>:<pref_align>@endverbatim</i>: Numeric type
156 one of <i>i|f|v|a</i>, corresponding to integer, floating point, vector (aka
157 packed) or aggregate. Size indicates the size, e.g., 32 or 64 bits.
159 The default string, fully specified is:
161 "E-p:64:64:64-a0:0:0-f32:32:32-f64:0:64"
162 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:0:64"
163 "-v64:64:64-v128:128:128"
165 Note that in the case of aggregates, 0 is the default ABI and preferred
166 alignment. This is a special case, where the aggregate's computed worst-case
167 alignment will be used.
169 void TargetData::init(const std::string &TargetDescription) {
170 std::string temp = TargetDescription;
172 LittleEndian = false;
175 PointerPrefAlign = PointerABIAlign;
177 // Default alignments
178 setAlignment(INTEGER_ALIGN, 1, 1, 1); // Bool
179 setAlignment(INTEGER_ALIGN, 1, 1, 8); // Byte
180 setAlignment(INTEGER_ALIGN, 2, 2, 16); // short
181 setAlignment(INTEGER_ALIGN, 4, 4, 32); // int
182 setAlignment(INTEGER_ALIGN, 4, 8, 64); // long
183 setAlignment(FLOAT_ALIGN, 4, 4, 32); // float
184 setAlignment(FLOAT_ALIGN, 8, 8, 64); // double
185 setAlignment(VECTOR_ALIGN, 8, 8, 64); // v2i32
186 setAlignment(VECTOR_ALIGN, 16, 16, 128); // v16i8, v8i16, v4i32, ...
187 setAlignment(AGGREGATE_ALIGN, 0, 8, 0); // struct, union, class, ...
189 while (!temp.empty()) {
190 std::string token = getToken(temp, "-");
191 std::string arg0 = getToken(token, ":");
192 const char *p = arg0.c_str();
195 LittleEndian = false;
201 PointerMemSize = atoi(getToken(token,":").c_str()) / 8;
202 PointerABIAlign = atoi(getToken(token,":").c_str()) / 8;
203 PointerPrefAlign = atoi(getToken(token,":").c_str()) / 8;
204 if (PointerPrefAlign == 0)
205 PointerPrefAlign = PointerABIAlign;
212 AlignTypeEnum align_type = STACK_ALIGN; // Dummy init, silence warning
214 case 'i': align_type = INTEGER_ALIGN; break;
215 case 'v': align_type = VECTOR_ALIGN; break;
216 case 'f': align_type = FLOAT_ALIGN; break;
217 case 'a': align_type = AGGREGATE_ALIGN; break;
218 case 's': align_type = STACK_ALIGN; break;
220 uint32_t size = (uint32_t) atoi(++p);
221 unsigned char abi_align = atoi(getToken(token, ":").c_str()) / 8;
222 unsigned char pref_align = atoi(getToken(token, ":").c_str()) / 8;
224 pref_align = abi_align;
225 setAlignment(align_type, abi_align, pref_align, size);
234 TargetData::TargetData(const Module *M)
235 : ImmutablePass(&ID) {
236 init(M->getDataLayout());
240 TargetData::setAlignment(AlignTypeEnum align_type, unsigned char abi_align,
241 unsigned char pref_align, uint32_t bit_width) {
242 assert(abi_align <= pref_align && "Preferred alignment worse than ABI!");
243 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
244 if (Alignments[i].AlignType == align_type &&
245 Alignments[i].TypeBitWidth == bit_width) {
246 // Update the abi, preferred alignments.
247 Alignments[i].ABIAlign = abi_align;
248 Alignments[i].PrefAlign = pref_align;
253 Alignments.push_back(TargetAlignElem::get(align_type, abi_align,
254 pref_align, bit_width));
257 /// getAlignmentInfo - Return the alignment (either ABI if ABIInfo = true or
258 /// preferred if ABIInfo = false) the target wants for the specified datatype.
259 unsigned TargetData::getAlignmentInfo(AlignTypeEnum AlignType,
260 uint32_t BitWidth, bool ABIInfo,
261 const Type *Ty) const {
262 // Check to see if we have an exact match and remember the best match we see.
263 int BestMatchIdx = -1;
265 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
266 if (Alignments[i].AlignType == AlignType &&
267 Alignments[i].TypeBitWidth == BitWidth)
268 return ABIInfo ? Alignments[i].ABIAlign : Alignments[i].PrefAlign;
270 // The best match so far depends on what we're looking for.
271 if (AlignType == VECTOR_ALIGN && Alignments[i].AlignType == VECTOR_ALIGN) {
272 // If this is a specification for a smaller vector type, we will fall back
273 // to it. This happens because <128 x double> can be implemented in terms
274 // of 64 <2 x double>.
275 if (Alignments[i].TypeBitWidth < BitWidth) {
276 // Verify that we pick the biggest of the fallbacks.
277 if (BestMatchIdx == -1 ||
278 Alignments[BestMatchIdx].TypeBitWidth < Alignments[i].TypeBitWidth)
281 } else if (AlignType == INTEGER_ALIGN &&
282 Alignments[i].AlignType == INTEGER_ALIGN) {
283 // The "best match" for integers is the smallest size that is larger than
284 // the BitWidth requested.
285 if (Alignments[i].TypeBitWidth > BitWidth && (BestMatchIdx == -1 ||
286 Alignments[i].TypeBitWidth < Alignments[BestMatchIdx].TypeBitWidth))
288 // However, if there isn't one that's larger, then we must use the
289 // largest one we have (see below)
290 if (LargestInt == -1 ||
291 Alignments[i].TypeBitWidth > Alignments[LargestInt].TypeBitWidth)
296 // Okay, we didn't find an exact solution. Fall back here depending on what
297 // is being looked for.
298 if (BestMatchIdx == -1) {
299 // If we didn't find an integer alignment, fall back on most conservative.
300 if (AlignType == INTEGER_ALIGN) {
301 BestMatchIdx = LargestInt;
303 assert(AlignType == VECTOR_ALIGN && "Unknown alignment type!");
305 // If we didn't find a vector size that is smaller or equal to this type,
306 // then we will end up scalarizing this to its element type. Just return
307 // the alignment of the element.
308 return getAlignment(cast<VectorType>(Ty)->getElementType(), ABIInfo);
312 // Since we got a "best match" index, just return it.
313 return ABIInfo ? Alignments[BestMatchIdx].ABIAlign
314 : Alignments[BestMatchIdx].PrefAlign;
319 /// LayoutInfo - The lazy cache of structure layout information maintained by
320 /// TargetData. Note that the struct types must have been free'd before
321 /// llvm_shutdown is called (and thus this is deallocated) because all the
322 /// targets with cached elements should have been destroyed.
324 typedef std::pair<const TargetData*,const StructType*> LayoutKey;
326 struct DenseMapLayoutKeyInfo {
327 static inline LayoutKey getEmptyKey() { return LayoutKey(0, 0); }
328 static inline LayoutKey getTombstoneKey() {
329 return LayoutKey((TargetData*)(intptr_t)-1, 0);
331 static unsigned getHashValue(const LayoutKey &Val) {
332 return DenseMapInfo<void*>::getHashValue(Val.first) ^
333 DenseMapInfo<void*>::getHashValue(Val.second);
335 static bool isEqual(const LayoutKey &LHS, const LayoutKey &RHS) {
339 static bool isPod() { return true; }
342 typedef DenseMap<LayoutKey, StructLayout*, DenseMapLayoutKeyInfo> LayoutInfoTy;
346 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));