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, short 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 || (AlignType == rhs.AlignType && TypeBitWidth < rhs.TypeBitWidth));
113 TargetAlignElem::operator==(const TargetAlignElem &rhs) const {
114 return (AlignType == rhs.AlignType
115 && ABIAlign == rhs.ABIAlign
116 && PrefAlign == rhs.PrefAlign
117 && TypeBitWidth == rhs.TypeBitWidth);
121 TargetAlignElem::dump(std::ostream &os) const {
122 return os << AlignType
124 << ":" << (int) (ABIAlign * 8)
125 << ":" << (int) (PrefAlign * 8);
128 const TargetAlignElem TargetData::InvalidAlignmentElem =
129 TargetAlignElem::get((AlignTypeEnum) -1, 0, 0, 0);
131 //===----------------------------------------------------------------------===//
132 // TargetData Class Implementation
133 //===----------------------------------------------------------------------===//
136 A TargetDescription string consists of a sequence of hyphen-delimited
137 specifiers for target endianness, pointer size and alignments, and various
138 primitive type sizes and alignments. A typical string looks something like:
140 "E-p:32:32:32-i1:8:8-i8:8:8-i32:32:32-i64:32:64-f32:32:32-f64:32:64"
142 (note: this string is not fully specified and is only an example.)
144 Alignments come in two flavors: ABI and preferred. ABI alignment (abi_align,
145 below) dictates how a type will be aligned within an aggregate and when used
146 as an argument. Preferred alignment (pref_align, below) determines a type's
147 alignment when emitted as a global.
149 Specifier string details:
151 <i>[E|e]</i>: Endianness. "E" specifies a big-endian target data model, "e"
152 specifies a little-endian target data model.
154 <i>p:<size>:<abi_align>:<pref_align></i>: Pointer size, ABI and preferred
157 <i><type><size>:<abi_align>:<pref_align></i>: Numeric type alignment. Type is
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); // Bool
181 setAlignment(INTEGER_ALIGN, 1, 1, 8); // Byte
182 setAlignment(INTEGER_ALIGN, 2, 2, 16); // short
183 setAlignment(INTEGER_ALIGN, 4, 4, 32); // int
184 setAlignment(INTEGER_ALIGN, 4, 8, 64); // long
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, 0, 0); // struct, union, class, ...
191 while (!temp.empty()) {
192 std::string token = getToken(temp, "-");
194 std::string arg0 = getToken(token, ":");
195 const char *p = arg0.c_str();
196 AlignTypeEnum align_type;
198 unsigned char abi_align;
199 unsigned char pref_align;
203 LittleEndian = false;
209 PointerMemSize = atoi(getToken(token,":").c_str()) / 8;
210 PointerABIAlign = atoi(getToken(token,":").c_str()) / 8;
211 PointerPrefAlign = atoi(getToken(token,":").c_str()) / 8;
212 if (PointerPrefAlign == 0)
213 PointerPrefAlign = PointerABIAlign;
219 align_type = (*p == 'i' ? INTEGER_ALIGN :
220 (*p == 'f' ? FLOAT_ALIGN :
221 (*p == 'v' ? VECTOR_ALIGN : AGGREGATE_ALIGN)));
222 size = (short) atoi(++p);
223 abi_align = atoi(getToken(token, ":").c_str()) / 8;
224 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 init(M->getDataLayout());
241 TargetData::setAlignment(AlignTypeEnum align_type, unsigned char abi_align,
242 unsigned char pref_align, short bit_width) {
243 TargetAlignElem elt = TargetAlignElem::get(align_type, abi_align,
244 pref_align, bit_width);
245 std::pair<align_iterator, align_iterator> ins_result =
246 std::equal_range(Alignments.begin(), Alignments.end(), elt);
247 align_iterator I = ins_result.first;
248 if (I != Alignments.end() && I->AlignType == align_type &&
249 I->TypeBitWidth == bit_width) {
250 // Update the abi, preferred alignments.
251 I->ABIAlign = abi_align;
252 I->PrefAlign = pref_align;
254 Alignments.insert(I, elt);
257 // Keep around for debugging and testing...
258 align_iterator E = ins_result.second;
260 cerr << "setAlignment(" << elt << ")\n";
261 cerr << "I = " << (I - Alignments.begin())
262 << ", E = " << (E - Alignments.begin()) << "\n";
263 std::copy(Alignments.begin(), Alignments.end(),
264 std::ostream_iterator<TargetAlignElem>(*cerr, "\n"));
269 const TargetAlignElem &
270 TargetData::getAlignment(AlignTypeEnum align_type, short bit_width) const
272 std::pair<align_const_iterator, align_const_iterator> find_result =
273 std::equal_range(Alignments.begin(), Alignments.end(),
274 TargetAlignElem::get(align_type, 0, 0,
276 align_const_iterator I = find_result.first;
278 // Note: This may not be reasonable if variable-width integer sizes are
279 // passed, at which point, more sophisticated searching will need to be done.
283 /// LayoutInfo - The lazy cache of structure layout information maintained by
284 /// TargetData. Note that the struct types must have been free'd before
285 /// llvm_shutdown is called (and thus this is deallocated) because all the
286 /// targets with cached elements should have been destroyed.
288 typedef std::pair<const TargetData*,const StructType*> LayoutKey;
290 struct DenseMapLayoutKeyInfo {
291 static inline LayoutKey getEmptyKey() { return LayoutKey(0, 0); }
292 static inline LayoutKey getTombstoneKey() {
293 return LayoutKey((TargetData*)(intptr_t)-1, 0);
295 static unsigned getHashValue(const LayoutKey &Val) {
296 return DenseMapKeyInfo<void*>::getHashValue(Val.first) ^
297 DenseMapKeyInfo<void*>::getHashValue(Val.second);
299 static bool isPod() { return true; }
302 typedef DenseMap<LayoutKey, StructLayout*, DenseMapLayoutKeyInfo> LayoutInfoTy;
303 static ManagedStatic<LayoutInfoTy> LayoutInfo;
306 TargetData::~TargetData() {
307 if (LayoutInfo.isConstructed()) {
308 // Remove any layouts for this TD.
309 LayoutInfoTy &TheMap = *LayoutInfo;
310 for (LayoutInfoTy::iterator I = TheMap.begin(), E = TheMap.end();
312 if (I->first.first == this) {
313 I->second->~StructLayout();
323 const StructLayout *TargetData::getStructLayout(const StructType *Ty) const {
324 LayoutInfoTy &TheMap = *LayoutInfo;
326 StructLayout *&SL = TheMap[LayoutKey(this, Ty)];
329 // Otherwise, create the struct layout. Because it is variable length, we
330 // malloc it, then use placement new.
331 unsigned NumElts = Ty->getNumElements();
333 (StructLayout *)malloc(sizeof(StructLayout)+(NumElts-1)*sizeof(uint64_t));
335 // Set SL before calling StructLayout's ctor. The ctor could cause other
336 // entries to be added to TheMap, invalidating our reference.
339 new (L) StructLayout(Ty, *this);
344 /// InvalidateStructLayoutInfo - TargetData speculatively caches StructLayout
345 /// objects. If a TargetData object is alive when types are being refined and
346 /// removed, this method must be called whenever a StructType is removed to
347 /// avoid a dangling pointer in this cache.
348 void TargetData::InvalidateStructLayoutInfo(const StructType *Ty) const {
349 if (!LayoutInfo.isConstructed()) return; // No cache.
351 LayoutInfoTy::iterator I = LayoutInfo->find(LayoutKey(this, Ty));
352 if (I != LayoutInfo->end()) {
353 I->second->~StructLayout();
355 LayoutInfo->erase(I);
360 std::string TargetData::getStringRepresentation() const {
362 repr.append(LittleEndian ? "e" : "E");
363 repr.append("-p:").append(itostr((int64_t) (PointerMemSize * 8))).
364 append(":").append(itostr((int64_t) (PointerABIAlign * 8))).
365 append(":").append(itostr((int64_t) (PointerPrefAlign * 8)));
366 for (align_const_iterator I = Alignments.begin();
367 I != Alignments.end();
369 repr.append("-").append(1, (char) I->AlignType).
370 append(utostr((int64_t) I->TypeBitWidth)).
371 append(":").append(utostr((uint64_t) (I->ABIAlign * 8))).
372 append(":").append(utostr((uint64_t) (I->PrefAlign * 8)));
378 uint64_t TargetData::getTypeSize(const Type *Ty) const {
379 assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
380 switch (Ty->getTypeID()) {
381 case Type::LabelTyID:
382 case Type::PointerTyID:
383 return getPointerSize();
384 case Type::ArrayTyID: {
385 const ArrayType *ATy = cast<ArrayType>(Ty);
387 unsigned char Alignment;
388 Size = getTypeSize(ATy->getElementType());
389 Alignment = getABITypeAlignment(ATy->getElementType());
390 unsigned AlignedSize = (Size + Alignment - 1)/Alignment*Alignment;
391 return AlignedSize*ATy->getNumElements();
393 case Type::StructTyID: {
394 // Get the layout annotation... which is lazily created on demand.
395 const StructLayout *Layout = getStructLayout(cast<StructType>(Ty));
396 return Layout->getSizeInBytes();
398 case Type::IntegerTyID: {
399 unsigned BitWidth = cast<IntegerType>(Ty)->getBitWidth();
402 } else if (BitWidth <= 16) {
404 } else if (BitWidth <= 32) {
406 } else if (BitWidth <= 64) {
409 assert(0 && "Integer types > 64 bits not supported.");
414 case Type::FloatTyID:
416 case Type::DoubleTyID:
418 case Type::VectorTyID: {
419 const VectorType *PTy = cast<VectorType>(Ty);
420 return PTy->getBitWidth() / 8;
423 assert(0 && "TargetData::getTypeSize(): Unsupported type");
429 uint64_t TargetData::getTypeSizeInBits(const Type *Ty) const {
431 return cast<IntegerType>(Ty)->getBitWidth();
433 return getTypeSize(Ty) * 8;
438 \param abi_or_pref Flag that determines which alignment is returned. true
439 returns the ABI alignment, false returns the preferred alignment.
440 \param Ty The underlying type for which alignment is determined.
442 Get the ABI (\a abi_or_pref == true) or preferred alignment (\a abi_or_pref
443 == false) for the requested type \a Ty.
445 unsigned char TargetData::getAlignment(const Type *Ty, bool abi_or_pref) const {
448 assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
449 switch (Ty->getTypeID()) {
450 /* Early escape for the non-numeric types */
451 case Type::LabelTyID:
452 case Type::PointerTyID:
454 ? getPointerABIAlignment()
455 : getPointerPrefAlignment());
456 case Type::ArrayTyID:
457 return getAlignment(cast<ArrayType>(Ty)->getElementType(), abi_or_pref);
459 case Type::StructTyID: {
460 // Packed structure types always have an ABI alignment of one.
461 if (cast<StructType>(Ty)->isPacked())
464 // Get the layout annotation... which is lazily created on demand.
465 const StructLayout *Layout = getStructLayout(cast<StructType>(Ty));
466 const TargetAlignElem &elem = getAlignment(AGGREGATE_ALIGN, 0);
467 assert(validAlignment(elem)
468 && "Aggregate alignment return invalid in getAlignment");
469 unsigned Align = abi_or_pref ? elem.ABIAlign : elem.PrefAlign;
470 return Align < Layout->getAlignment() ? Layout->StructAlignment : Align;
472 case Type::IntegerTyID:
474 AlignType = INTEGER_ALIGN;
476 case Type::FloatTyID:
477 case Type::DoubleTyID:
478 AlignType = FLOAT_ALIGN;
480 case Type::VectorTyID:
481 AlignType = VECTOR_ALIGN;
484 assert(0 && "Bad type for getAlignment!!!");
488 const TargetAlignElem &elem = getAlignment((AlignTypeEnum) AlignType,
489 getTypeSize(Ty) * 8);
490 if (validAlignment(elem))
491 return (abi_or_pref ? elem.ABIAlign : elem.PrefAlign);
493 cerr << "TargetData::getAlignment: align type " << AlignType
494 << " size " << getTypeSize(Ty) << " not found in Alignments.\n";
501 unsigned char TargetData::getABITypeAlignment(const Type *Ty) const {
502 return getAlignment(Ty, true);
505 unsigned char TargetData::getPrefTypeAlignment(const Type *Ty) const {
506 return getAlignment(Ty, false);
509 unsigned char TargetData::getPreferredTypeAlignmentShift(const Type *Ty) const {
510 unsigned Align = (unsigned) getPrefTypeAlignment(Ty);
511 assert(!(Align & (Align-1)) && "Alignment is not a power of two!");
512 return Log2_32(Align);
515 /// getIntPtrType - Return an unsigned integer type that is the same size or
516 /// greater to the host pointer size.
517 const Type *TargetData::getIntPtrType() const {
518 switch (getPointerSize()) {
519 default: assert(0 && "Unknown pointer size!");
520 case 2: return Type::Int16Ty;
521 case 4: return Type::Int32Ty;
522 case 8: return Type::Int64Ty;
527 uint64_t TargetData::getIndexedOffset(const Type *ptrTy, Value* const* Indices,
528 unsigned NumIndices) const {
529 const Type *Ty = ptrTy;
530 assert(isa<PointerType>(Ty) && "Illegal argument for getIndexedOffset()");
533 generic_gep_type_iterator<Value* const*>
534 TI = gep_type_begin(ptrTy, Indices, Indices+NumIndices);
535 for (unsigned CurIDX = 0; CurIDX != NumIndices; ++CurIDX, ++TI) {
536 if (const StructType *STy = dyn_cast<StructType>(*TI)) {
537 assert(Indices[CurIDX]->getType() == Type::Int32Ty &&"Illegal struct idx");
538 unsigned FieldNo = cast<ConstantInt>(Indices[CurIDX])->getZExtValue();
540 // Get structure layout information...
541 const StructLayout *Layout = getStructLayout(STy);
543 // Add in the offset, as calculated by the structure layout info...
544 Result += Layout->getElementOffset(FieldNo);
546 // Update Ty to refer to current element
547 Ty = STy->getElementType(FieldNo);
549 // Update Ty to refer to current element
550 Ty = cast<SequentialType>(Ty)->getElementType();
552 // Get the array index and the size of each array element.
553 int64_t arrayIdx = cast<ConstantInt>(Indices[CurIDX])->getSExtValue();
554 Result += arrayIdx * (int64_t)getTypeSize(Ty);
561 /// getPreferredAlignmentLog - Return the preferred alignment of the
562 /// specified global, returned in log form. This includes an explicitly
563 /// requested alignment (if the global has one).
564 unsigned TargetData::getPreferredAlignmentLog(const GlobalVariable *GV) const {
565 const Type *ElemType = GV->getType()->getElementType();
566 unsigned Alignment = getPreferredTypeAlignmentShift(ElemType);
567 if (GV->getAlignment() > (1U << Alignment))
568 Alignment = Log2_32(GV->getAlignment());
570 if (GV->hasInitializer()) {
572 // If the global is not external, see if it is large. If so, give it a
574 if (getTypeSize(ElemType) > 128)
575 Alignment = 4; // 16-byte alignment.