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");
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);
53 TyAlign = (ST->isPacked() ? 1 : TD.getABITypeAlignment(Ty));
54 TySize = TD.getTypeSize(Ty);
56 // Add padding if necessary to make the data element aligned properly...
57 if (StructSize % TyAlign != 0)
58 StructSize = (StructSize/TyAlign + 1) * TyAlign; // Add padding...
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!");
88 return SI-&MemberOffsets[0];
91 //===----------------------------------------------------------------------===//
92 // TargetAlignElem, TargetAlign support
93 //===----------------------------------------------------------------------===//
96 TargetAlignElem::get(AlignTypeEnum align_type, unsigned char abi_align,
97 unsigned char pref_align, uint32_t bit_width) {
98 TargetAlignElem retval;
99 retval.AlignType = align_type;
100 retval.ABIAlign = abi_align;
101 retval.PrefAlign = pref_align;
102 retval.TypeBitWidth = bit_width;
107 TargetAlignElem::operator==(const TargetAlignElem &rhs) const {
108 return (AlignType == rhs.AlignType
109 && ABIAlign == rhs.ABIAlign
110 && PrefAlign == rhs.PrefAlign
111 && TypeBitWidth == rhs.TypeBitWidth);
115 TargetAlignElem::dump(std::ostream &os) const {
116 return os << AlignType
118 << ":" << (int) (ABIAlign * 8)
119 << ":" << (int) (PrefAlign * 8);
122 const TargetAlignElem TargetData::InvalidAlignmentElem =
123 TargetAlignElem::get((AlignTypeEnum) -1, 0, 0, 0);
125 //===----------------------------------------------------------------------===//
126 // TargetData Class Implementation
127 //===----------------------------------------------------------------------===//
130 A TargetDescription string consists of a sequence of hyphen-delimited
131 specifiers for target endianness, pointer size and alignments, and various
132 primitive type sizes and alignments. A typical string looks something like:
134 "E-p:32:32:32-i1:8:8-i8:8:8-i32:32:32-i64:32:64-f32:32:32-f64:32:64"
136 (note: this string is not fully specified and is only an example.)
138 Alignments come in two flavors: ABI and preferred. ABI alignment (abi_align,
139 below) dictates how a type will be aligned within an aggregate and when used
140 as an argument. Preferred alignment (pref_align, below) determines a type's
141 alignment when emitted as a global.
143 Specifier string details:
145 <i>[E|e]</i>: Endianness. "E" specifies a big-endian target data model, "e"
146 specifies a little-endian target data model.
148 <i>p:<size>:<abi_align>:<pref_align></i>: Pointer size, ABI and preferred
151 <i><type><size>:<abi_align>:<pref_align></i>: Numeric type alignment. Type is
152 one of <i>i|f|v|a</i>, corresponding to integer, floating point, vector (aka
153 packed) or aggregate. Size indicates the size, e.g., 32 or 64 bits.
155 The default string, fully specified is:
157 "E-p:64:64:64-a0:0:0-f32:32:32-f64:0:64"
158 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:0:64"
159 "-v64:64:64-v128:128:128"
161 Note that in the case of aggregates, 0 is the default ABI and preferred
162 alignment. This is a special case, where the aggregate's computed worst-case
163 alignment will be used.
165 void TargetData::init(const std::string &TargetDescription) {
166 std::string temp = TargetDescription;
168 LittleEndian = false;
171 PointerPrefAlign = PointerABIAlign;
173 // Default alignments
174 setAlignment(INTEGER_ALIGN, 1, 1, 1); // Bool
175 setAlignment(INTEGER_ALIGN, 1, 1, 8); // Byte
176 setAlignment(INTEGER_ALIGN, 2, 2, 16); // short
177 setAlignment(INTEGER_ALIGN, 4, 4, 32); // int
178 setAlignment(INTEGER_ALIGN, 4, 8, 64); // long
179 setAlignment(FLOAT_ALIGN, 4, 4, 32); // float
180 setAlignment(FLOAT_ALIGN, 8, 8, 64); // double
181 setAlignment(VECTOR_ALIGN, 8, 8, 64); // v2i32
182 setAlignment(VECTOR_ALIGN, 16, 16, 128); // v16i8, v8i16, v4i32, ...
183 setAlignment(AGGREGATE_ALIGN, 0, 8, 0); // struct, union, class, ...
185 while (!temp.empty()) {
186 std::string token = getToken(temp, "-");
187 std::string arg0 = getToken(token, ":");
188 const char *p = arg0.c_str();
191 LittleEndian = false;
197 PointerMemSize = atoi(getToken(token,":").c_str()) / 8;
198 PointerABIAlign = atoi(getToken(token,":").c_str()) / 8;
199 PointerPrefAlign = atoi(getToken(token,":").c_str()) / 8;
200 if (PointerPrefAlign == 0)
201 PointerPrefAlign = PointerABIAlign;
207 AlignTypeEnum align_type =
208 (*p == 'i' ? INTEGER_ALIGN : (*p == 'f' ? FLOAT_ALIGN :
209 (*p == 'v' ? VECTOR_ALIGN : AGGREGATE_ALIGN)));
210 uint32_t size = (uint32_t) atoi(++p);
211 unsigned char abi_align = atoi(getToken(token, ":").c_str()) / 8;
212 unsigned char pref_align = atoi(getToken(token, ":").c_str()) / 8;
214 pref_align = abi_align;
215 setAlignment(align_type, abi_align, pref_align, size);
224 TargetData::TargetData(const Module *M) {
225 init(M->getDataLayout());
229 TargetData::setAlignment(AlignTypeEnum align_type, unsigned char abi_align,
230 unsigned char pref_align, uint32_t bit_width) {
231 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
232 if (Alignments[i].AlignType == align_type &&
233 Alignments[i].TypeBitWidth == bit_width) {
234 // Update the abi, preferred alignments.
235 Alignments[i].ABIAlign = abi_align;
236 Alignments[i].PrefAlign = pref_align;
241 Alignments.push_back(TargetAlignElem::get(align_type, abi_align,
242 pref_align, bit_width));
245 /// getAlignmentInfo - Return the alignment (either ABI if ABIInfo = true or
246 /// preferred if ABIInfo = false) the target wants for the specified datatype.
247 unsigned TargetData::getAlignmentInfo(AlignTypeEnum AlignType,
248 uint32_t BitWidth, bool ABIInfo) const {
249 // Check to see if we have an exact match and remember the best match we see.
250 int BestMatchIdx = -1;
252 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
253 if (Alignments[i].AlignType == AlignType &&
254 Alignments[i].TypeBitWidth == BitWidth)
255 return ABIInfo ? Alignments[i].ABIAlign : Alignments[i].PrefAlign;
257 // The best match so far depends on what we're looking for.
258 if (AlignType == VECTOR_ALIGN) {
259 // If this is a specification for a smaller vector type, we will fall back
260 // to it. This happens because <128 x double> can be implemented in terms
261 // of 64 <2 x double>.
262 if (Alignments[i].AlignType == VECTOR_ALIGN &&
263 Alignments[i].TypeBitWidth < BitWidth) {
264 // Verify that we pick the biggest of the fallbacks.
265 if (BestMatchIdx == -1 ||
266 Alignments[BestMatchIdx].TypeBitWidth < BitWidth)
269 } else if (AlignType == INTEGER_ALIGN &&
270 Alignments[i].AlignType == INTEGER_ALIGN) {
271 // The "best match" for integers is the smallest size that is larger than
272 // the BitWidth requested.
273 if (Alignments[i].TypeBitWidth > BitWidth && (BestMatchIdx == -1 ||
274 Alignments[i].TypeBitWidth < Alignments[BestMatchIdx].TypeBitWidth))
276 // However, if there isn't one that's larger, then we must use the
277 // largest one we have (see below)
278 if (LargestInt == -1 ||
279 Alignments[i].TypeBitWidth > Alignments[LargestInt].TypeBitWidth)
284 // For integers, if we didn't find a best match, use the largest one found.
285 if (BestMatchIdx == -1)
286 BestMatchIdx = LargestInt;
288 // Okay, we didn't find an exact solution. Fall back here depending on what
289 // is being looked for.
290 assert(BestMatchIdx != -1 && "Didn't find alignment info for this datatype!");
292 // Since we got a "best match" index, just return it.
293 return ABIInfo ? Alignments[BestMatchIdx].ABIAlign
294 : Alignments[BestMatchIdx].PrefAlign;
297 /// LayoutInfo - The lazy cache of structure layout information maintained by
298 /// TargetData. Note that the struct types must have been free'd before
299 /// llvm_shutdown is called (and thus this is deallocated) because all the
300 /// targets with cached elements should have been destroyed.
302 typedef std::pair<const TargetData*,const StructType*> LayoutKey;
304 struct DenseMapLayoutKeyInfo {
305 static inline LayoutKey getEmptyKey() { return LayoutKey(0, 0); }
306 static inline LayoutKey getTombstoneKey() {
307 return LayoutKey((TargetData*)(intptr_t)-1, 0);
309 static unsigned getHashValue(const LayoutKey &Val) {
310 return DenseMapKeyInfo<void*>::getHashValue(Val.first) ^
311 DenseMapKeyInfo<void*>::getHashValue(Val.second);
313 static bool isPod() { return true; }
316 typedef DenseMap<LayoutKey, StructLayout*, DenseMapLayoutKeyInfo> LayoutInfoTy;
317 static ManagedStatic<LayoutInfoTy> LayoutInfo;
320 TargetData::~TargetData() {
321 if (LayoutInfo.isConstructed()) {
322 // Remove any layouts for this TD.
323 LayoutInfoTy &TheMap = *LayoutInfo;
324 for (LayoutInfoTy::iterator I = TheMap.begin(), E = TheMap.end();
326 if (I->first.first == this) {
327 I->second->~StructLayout();
337 const StructLayout *TargetData::getStructLayout(const StructType *Ty) const {
338 LayoutInfoTy &TheMap = *LayoutInfo;
340 StructLayout *&SL = TheMap[LayoutKey(this, Ty)];
343 // Otherwise, create the struct layout. Because it is variable length, we
344 // malloc it, then use placement new.
345 int NumElts = Ty->getNumElements();
347 (StructLayout *)malloc(sizeof(StructLayout)+(NumElts-1)*sizeof(uint64_t));
349 // Set SL before calling StructLayout's ctor. The ctor could cause other
350 // entries to be added to TheMap, invalidating our reference.
353 new (L) StructLayout(Ty, *this);
357 /// InvalidateStructLayoutInfo - TargetData speculatively caches StructLayout
358 /// objects. If a TargetData object is alive when types are being refined and
359 /// removed, this method must be called whenever a StructType is removed to
360 /// avoid a dangling pointer in this cache.
361 void TargetData::InvalidateStructLayoutInfo(const StructType *Ty) const {
362 if (!LayoutInfo.isConstructed()) return; // No cache.
364 LayoutInfoTy::iterator I = LayoutInfo->find(LayoutKey(this, Ty));
365 if (I != LayoutInfo->end()) {
366 I->second->~StructLayout();
368 LayoutInfo->erase(I);
373 std::string TargetData::getStringRepresentation() const {
375 repr.append(LittleEndian ? "e" : "E");
376 repr.append("-p:").append(itostr((int64_t) (PointerMemSize * 8))).
377 append(":").append(itostr((int64_t) (PointerABIAlign * 8))).
378 append(":").append(itostr((int64_t) (PointerPrefAlign * 8)));
379 for (align_const_iterator I = Alignments.begin();
380 I != Alignments.end();
382 repr.append("-").append(1, (char) I->AlignType).
383 append(utostr((int64_t) I->TypeBitWidth)).
384 append(":").append(utostr((uint64_t) (I->ABIAlign * 8))).
385 append(":").append(utostr((uint64_t) (I->PrefAlign * 8)));
391 uint64_t TargetData::getTypeSize(const Type *Ty) const {
392 assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
393 switch (Ty->getTypeID()) {
394 case Type::LabelTyID:
395 case Type::PointerTyID:
396 return getPointerSize();
397 case Type::ArrayTyID: {
398 const ArrayType *ATy = cast<ArrayType>(Ty);
400 unsigned char Alignment;
401 Size = getTypeSize(ATy->getElementType());
402 Alignment = getABITypeAlignment(ATy->getElementType());
403 uint64_t AlignedSize = (Size + Alignment - 1)/Alignment*Alignment;
404 return AlignedSize*ATy->getNumElements();
406 case Type::StructTyID: {
407 // Get the layout annotation... which is lazily created on demand.
408 const StructLayout *Layout = getStructLayout(cast<StructType>(Ty));
409 return Layout->getSizeInBytes();
411 case Type::IntegerTyID: {
412 unsigned BitWidth = cast<IntegerType>(Ty)->getBitWidth();
415 } else if (BitWidth <= 16) {
417 } else if (BitWidth <= 32) {
419 } else if (BitWidth <= 64) {
422 // The size of this > 64 bit type is chosen as a multiple of the
423 // preferred alignment of the largest "native" size the target supports.
424 // We first obtain the the alignment info for this type and then compute
425 // the next largest multiple of that size.
426 uint64_t size = getAlignmentInfo(INTEGER_ALIGN, BitWidth, false) * 8;
427 return (((BitWidth / (size)) + (BitWidth % size != 0)) * size) / 8;
433 case Type::FloatTyID:
435 case Type::DoubleTyID:
437 case Type::VectorTyID: {
438 const VectorType *PTy = cast<VectorType>(Ty);
439 return PTy->getBitWidth() / 8;
442 assert(0 && "TargetData::getTypeSize(): Unsupported type");
448 uint64_t TargetData::getTypeSizeInBits(const Type *Ty) const {
450 return cast<IntegerType>(Ty)->getBitWidth();
452 return getTypeSize(Ty) * 8;
457 \param abi_or_pref Flag that determines which alignment is returned. true
458 returns the ABI alignment, false returns the preferred alignment.
459 \param Ty The underlying type for which alignment is determined.
461 Get the ABI (\a abi_or_pref == true) or preferred alignment (\a abi_or_pref
462 == false) for the requested type \a Ty.
464 unsigned char TargetData::getAlignment(const Type *Ty, bool abi_or_pref) const {
467 assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
468 switch (Ty->getTypeID()) {
469 /* Early escape for the non-numeric types */
470 case Type::LabelTyID:
471 case Type::PointerTyID:
473 ? getPointerABIAlignment()
474 : getPointerPrefAlignment());
475 case Type::ArrayTyID:
476 return getAlignment(cast<ArrayType>(Ty)->getElementType(), abi_or_pref);
478 case Type::StructTyID: {
479 // Packed structure types always have an ABI alignment of one.
480 if (cast<StructType>(Ty)->isPacked() && abi_or_pref)
483 // Get the layout annotation... which is lazily created on demand.
484 const StructLayout *Layout = getStructLayout(cast<StructType>(Ty));
485 unsigned Align = getAlignmentInfo(AGGREGATE_ALIGN, 0, abi_or_pref);
486 return std::max(Align, (unsigned)Layout->getAlignment());
488 case Type::IntegerTyID:
490 AlignType = INTEGER_ALIGN;
492 case Type::FloatTyID:
493 case Type::DoubleTyID:
494 AlignType = FLOAT_ALIGN;
496 case Type::VectorTyID:
497 AlignType = VECTOR_ALIGN;
500 assert(0 && "Bad type for getAlignment!!!");
504 return getAlignmentInfo((AlignTypeEnum)AlignType, getTypeSize(Ty) * 8,
508 unsigned char TargetData::getABITypeAlignment(const Type *Ty) const {
509 return getAlignment(Ty, true);
512 unsigned char TargetData::getPrefTypeAlignment(const Type *Ty) const {
513 return getAlignment(Ty, false);
516 unsigned char TargetData::getPreferredTypeAlignmentShift(const Type *Ty) const {
517 unsigned Align = (unsigned) getPrefTypeAlignment(Ty);
518 assert(!(Align & (Align-1)) && "Alignment is not a power of two!");
519 return Log2_32(Align);
522 /// getIntPtrType - Return an unsigned integer type that is the same size or
523 /// greater to the host pointer size.
524 const Type *TargetData::getIntPtrType() const {
525 switch (getPointerSize()) {
526 default: assert(0 && "Unknown pointer size!");
527 case 2: return Type::Int16Ty;
528 case 4: return Type::Int32Ty;
529 case 8: return Type::Int64Ty;
534 uint64_t TargetData::getIndexedOffset(const Type *ptrTy, Value* const* Indices,
535 unsigned NumIndices) const {
536 const Type *Ty = ptrTy;
537 assert(isa<PointerType>(Ty) && "Illegal argument for getIndexedOffset()");
540 generic_gep_type_iterator<Value* const*>
541 TI = gep_type_begin(ptrTy, Indices, Indices+NumIndices);
542 for (unsigned CurIDX = 0; CurIDX != NumIndices; ++CurIDX, ++TI) {
543 if (const StructType *STy = dyn_cast<StructType>(*TI)) {
544 assert(Indices[CurIDX]->getType() == Type::Int32Ty &&
545 "Illegal struct idx");
546 unsigned FieldNo = cast<ConstantInt>(Indices[CurIDX])->getZExtValue();
548 // Get structure layout information...
549 const StructLayout *Layout = getStructLayout(STy);
551 // Add in the offset, as calculated by the structure layout info...
552 Result += Layout->getElementOffset(FieldNo);
554 // Update Ty to refer to current element
555 Ty = STy->getElementType(FieldNo);
557 // Update Ty to refer to current element
558 Ty = cast<SequentialType>(Ty)->getElementType();
560 // Get the array index and the size of each array element.
561 int64_t arrayIdx = cast<ConstantInt>(Indices[CurIDX])->getSExtValue();
562 Result += arrayIdx * (int64_t)getTypeSize(Ty);
569 /// getPreferredAlignmentLog - Return the preferred alignment of the
570 /// specified global, returned in log form. This includes an explicitly
571 /// requested alignment (if the global has one).
572 unsigned TargetData::getPreferredAlignmentLog(const GlobalVariable *GV) const {
573 const Type *ElemType = GV->getType()->getElementType();
574 unsigned Alignment = getPreferredTypeAlignmentShift(ElemType);
575 if (GV->getAlignment() > (1U << Alignment))
576 Alignment = Log2_32(GV->getAlignment());
578 if (GV->hasInitializer()) {
580 // If the global is not external, see if it is large. If so, give it a
582 if (getTypeSize(ElemType) > 128)
583 Alignment = 4; // 16-byte alignment.