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/Support/ErrorHandling.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 //===----------------------------------------------------------------------===//
134 typedef DenseMap<const StructType*, StructLayout*> LayoutInfoTy;
137 A TargetDescription string consists of a sequence of hyphen-delimited
138 specifiers for target endianness, pointer size and alignments, and various
139 primitive type sizes and alignments. A typical string looks something like:
141 "E-p:32:32:32-i1:8:8-i8:8:8-i32:32:32-i64:32:64-f32:32:32-f64:32:64"
143 (note: this string is not fully specified and is only an example.)
145 Alignments come in two flavors: ABI and preferred. ABI alignment (abi_align,
146 below) dictates how a type will be aligned within an aggregate and when used
147 as an argument. Preferred alignment (pref_align, below) determines a type's
148 alignment when emitted as a global.
150 Specifier string details:
152 <i>[E|e]</i>: Endianness. "E" specifies a big-endian target data model, "e"
153 specifies a little-endian target data model.
155 <i>p:@verbatim<size>:<abi_align>:<pref_align>@endverbatim</i>: Pointer size,
156 ABI and preferred alignment.
158 <i>@verbatim<type><size>:<abi_align>:<pref_align>@endverbatim</i>: Numeric type
160 one of <i>i|f|v|a</i>, corresponding to integer, floating point, vector, or
161 aggregate. Size indicates the size, e.g., 32 or 64 bits.
163 The default string, fully specified, is:
165 "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64"
166 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64"
167 "-v64:64:64-v128:128:128"
169 Note that in the case of aggregates, 0 is the default ABI and preferred
170 alignment. This is a special case, where the aggregate's computed worst-case
171 alignment will be used.
173 void TargetData::init(const std::string &TargetDescription) {
174 LayoutMap = static_cast<void*>(new LayoutInfoTy());
175 std::string temp = TargetDescription;
177 LittleEndian = false;
180 PointerPrefAlign = PointerABIAlign;
182 // Default alignments
183 setAlignment(INTEGER_ALIGN, 1, 1, 1); // i1
184 setAlignment(INTEGER_ALIGN, 1, 1, 8); // i8
185 setAlignment(INTEGER_ALIGN, 2, 2, 16); // i16
186 setAlignment(INTEGER_ALIGN, 4, 4, 32); // i32
187 setAlignment(INTEGER_ALIGN, 4, 8, 64); // i64
188 setAlignment(FLOAT_ALIGN, 4, 4, 32); // float
189 setAlignment(FLOAT_ALIGN, 8, 8, 64); // double
190 setAlignment(VECTOR_ALIGN, 8, 8, 64); // v2i32, v1i64, ...
191 setAlignment(VECTOR_ALIGN, 16, 16, 128); // v16i8, v8i16, v4i32, ...
192 setAlignment(AGGREGATE_ALIGN, 0, 8, 0); // struct
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 std::string &TargetDescription)
240 : ImmutablePass(&ID) {
241 init(TargetDescription);
244 TargetData::TargetData(const Module *M)
245 : ImmutablePass(&ID) {
246 init(M->getDataLayout());
249 TargetData::TargetData(const TargetData &TD) :
251 LittleEndian(TD.isLittleEndian()),
252 PointerMemSize(TD.PointerMemSize),
253 PointerABIAlign(TD.PointerABIAlign),
254 PointerPrefAlign(TD.PointerPrefAlign),
255 Alignments(TD.Alignments) {
256 LayoutInfoTy *Other = static_cast<LayoutInfoTy*>(TD.LayoutMap);
257 LayoutMap = static_cast<void*>(new LayoutInfoTy(*Other));
262 TargetData::setAlignment(AlignTypeEnum align_type, unsigned char abi_align,
263 unsigned char pref_align, uint32_t bit_width) {
264 assert(abi_align <= pref_align && "Preferred alignment worse than ABI!");
265 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
266 if (Alignments[i].AlignType == align_type &&
267 Alignments[i].TypeBitWidth == bit_width) {
268 // Update the abi, preferred alignments.
269 Alignments[i].ABIAlign = abi_align;
270 Alignments[i].PrefAlign = pref_align;
275 Alignments.push_back(TargetAlignElem::get(align_type, abi_align,
276 pref_align, bit_width));
279 /// getAlignmentInfo - Return the alignment (either ABI if ABIInfo = true or
280 /// preferred if ABIInfo = false) the target wants for the specified datatype.
281 unsigned TargetData::getAlignmentInfo(AlignTypeEnum AlignType,
282 uint32_t BitWidth, bool ABIInfo,
283 const Type *Ty) const {
284 // Check to see if we have an exact match and remember the best match we see.
285 int BestMatchIdx = -1;
287 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
288 if (Alignments[i].AlignType == AlignType &&
289 Alignments[i].TypeBitWidth == BitWidth)
290 return ABIInfo ? Alignments[i].ABIAlign : Alignments[i].PrefAlign;
292 // The best match so far depends on what we're looking for.
293 if (AlignType == VECTOR_ALIGN && Alignments[i].AlignType == VECTOR_ALIGN) {
294 // If this is a specification for a smaller vector type, we will fall back
295 // to it. This happens because <128 x double> can be implemented in terms
296 // of 64 <2 x double>.
297 if (Alignments[i].TypeBitWidth < BitWidth) {
298 // Verify that we pick the biggest of the fallbacks.
299 if (BestMatchIdx == -1 ||
300 Alignments[BestMatchIdx].TypeBitWidth < Alignments[i].TypeBitWidth)
303 } else if (AlignType == INTEGER_ALIGN &&
304 Alignments[i].AlignType == INTEGER_ALIGN) {
305 // The "best match" for integers is the smallest size that is larger than
306 // the BitWidth requested.
307 if (Alignments[i].TypeBitWidth > BitWidth && (BestMatchIdx == -1 ||
308 Alignments[i].TypeBitWidth < Alignments[BestMatchIdx].TypeBitWidth))
310 // However, if there isn't one that's larger, then we must use the
311 // largest one we have (see below)
312 if (LargestInt == -1 ||
313 Alignments[i].TypeBitWidth > Alignments[LargestInt].TypeBitWidth)
318 // Okay, we didn't find an exact solution. Fall back here depending on what
319 // is being looked for.
320 if (BestMatchIdx == -1) {
321 // If we didn't find an integer alignment, fall back on most conservative.
322 if (AlignType == INTEGER_ALIGN) {
323 BestMatchIdx = LargestInt;
325 assert(AlignType == VECTOR_ALIGN && "Unknown alignment type!");
327 // If we didn't find a vector size that is smaller or equal to this type,
328 // then we will end up scalarizing this to its element type. Just return
329 // the alignment of the element.
330 return getAlignment(cast<VectorType>(Ty)->getElementType(), ABIInfo);
334 // Since we got a "best match" index, just return it.
335 return ABIInfo ? Alignments[BestMatchIdx].ABIAlign
336 : Alignments[BestMatchIdx].PrefAlign;
339 TargetData::~TargetData() {
340 assert(LayoutMap && "LayoutMap not initialized?");
341 LayoutInfoTy &TheMap = *static_cast<LayoutInfoTy*>(LayoutMap);
343 // Remove any layouts for this TD.
344 for (LayoutInfoTy::iterator I = TheMap.begin(), E = TheMap.end(); I != E; ) {
345 I->second->~StructLayout();
350 delete static_cast<LayoutInfoTy*>(LayoutMap);
354 const StructLayout *TargetData::getStructLayout(const StructType *Ty) const {
355 assert(LayoutMap && "LayoutMap not initialized?");
356 LayoutInfoTy &TheMap = *static_cast<LayoutInfoTy*>(LayoutMap);
358 StructLayout *&SL = TheMap[Ty];
361 // Otherwise, create the struct layout. Because it is variable length, we
362 // malloc it, then use placement new.
363 int NumElts = Ty->getNumElements();
365 (StructLayout *)malloc(sizeof(StructLayout)+(NumElts-1)*sizeof(uint64_t));
367 // Set SL before calling StructLayout's ctor. The ctor could cause other
368 // entries to be added to TheMap, invalidating our reference.
371 new (L) StructLayout(Ty, *this);
375 /// InvalidateStructLayoutInfo - TargetData speculatively caches StructLayout
376 /// objects. If a TargetData object is alive when types are being refined and
377 /// removed, this method must be called whenever a StructType is removed to
378 /// avoid a dangling pointer in this cache.
379 void TargetData::InvalidateStructLayoutInfo(const StructType *Ty) const {
380 assert(LayoutMap && "LayoutMap not initialized?");
381 LayoutInfoTy *LayoutInfo = static_cast<LayoutInfoTy*>(LayoutMap);
382 LayoutInfoTy::iterator I = LayoutInfo->find(Ty);
383 if (I == LayoutInfo->end()) return;
385 I->second->~StructLayout();
387 LayoutInfo->erase(I);
391 std::string TargetData::getStringRepresentation() const {
393 repr.append(LittleEndian ? "e" : "E");
394 repr.append("-p:").append(itostr((int64_t) (PointerMemSize * 8))).
395 append(":").append(itostr((int64_t) (PointerABIAlign * 8))).
396 append(":").append(itostr((int64_t) (PointerPrefAlign * 8)));
397 for (align_const_iterator I = Alignments.begin();
398 I != Alignments.end();
400 repr.append("-").append(1, (char) I->AlignType).
401 append(utostr((int64_t) I->TypeBitWidth)).
402 append(":").append(utostr((uint64_t) (I->ABIAlign * 8))).
403 append(":").append(utostr((uint64_t) (I->PrefAlign * 8)));
409 uint64_t TargetData::getTypeSizeInBits(const Type *Ty) const {
410 assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
411 switch (Ty->getTypeID()) {
412 case Type::LabelTyID:
413 case Type::PointerTyID:
414 return getPointerSizeInBits();
415 case Type::ArrayTyID: {
416 const ArrayType *ATy = cast<ArrayType>(Ty);
417 return getTypeAllocSizeInBits(ATy->getElementType())*ATy->getNumElements();
419 case Type::StructTyID:
420 // Get the layout annotation... which is lazily created on demand.
421 return getStructLayout(cast<StructType>(Ty))->getSizeInBits();
422 case Type::IntegerTyID:
423 return cast<IntegerType>(Ty)->getBitWidth();
426 case Type::FloatTyID:
428 case Type::DoubleTyID:
430 case Type::PPC_FP128TyID:
431 case Type::FP128TyID:
433 // In memory objects this is always aligned to a higher boundary, but
434 // only 80 bits contain information.
435 case Type::X86_FP80TyID:
437 case Type::VectorTyID:
438 return cast<VectorType>(Ty)->getBitWidth();
440 llvm_unreachable("TargetData::getTypeSizeInBits(): Unsupported type");
447 \param abi_or_pref Flag that determines which alignment is returned. true
448 returns the ABI alignment, false returns the preferred alignment.
449 \param Ty The underlying type for which alignment is determined.
451 Get the ABI (\a abi_or_pref == true) or preferred alignment (\a abi_or_pref
452 == false) for the requested type \a Ty.
454 unsigned char TargetData::getAlignment(const Type *Ty, bool abi_or_pref) const {
457 assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
458 switch (Ty->getTypeID()) {
459 // Early escape for the non-numeric types.
460 case Type::LabelTyID:
461 case Type::PointerTyID:
463 ? getPointerABIAlignment()
464 : getPointerPrefAlignment());
465 case Type::ArrayTyID:
466 return getAlignment(cast<ArrayType>(Ty)->getElementType(), abi_or_pref);
468 case Type::StructTyID: {
469 // Packed structure types always have an ABI alignment of one.
470 if (cast<StructType>(Ty)->isPacked() && abi_or_pref)
473 // Get the layout annotation... which is lazily created on demand.
474 const StructLayout *Layout = getStructLayout(cast<StructType>(Ty));
475 unsigned Align = getAlignmentInfo(AGGREGATE_ALIGN, 0, abi_or_pref, Ty);
476 return std::max(Align, (unsigned)Layout->getAlignment());
478 case Type::IntegerTyID:
480 AlignType = INTEGER_ALIGN;
482 case Type::FloatTyID:
483 case Type::DoubleTyID:
484 // PPC_FP128TyID and FP128TyID have different data contents, but the
485 // same size and alignment, so they look the same here.
486 case Type::PPC_FP128TyID:
487 case Type::FP128TyID:
488 case Type::X86_FP80TyID:
489 AlignType = FLOAT_ALIGN;
491 case Type::VectorTyID:
492 AlignType = VECTOR_ALIGN;
495 llvm_unreachable("Bad type for getAlignment!!!");
499 return getAlignmentInfo((AlignTypeEnum)AlignType, getTypeSizeInBits(Ty),
503 unsigned char TargetData::getABITypeAlignment(const Type *Ty) const {
504 return getAlignment(Ty, true);
507 unsigned char TargetData::getCallFrameTypeAlignment(const Type *Ty) const {
508 for (unsigned i = 0, e = Alignments.size(); i != e; ++i)
509 if (Alignments[i].AlignType == STACK_ALIGN)
510 return Alignments[i].ABIAlign;
512 return getABITypeAlignment(Ty);
515 unsigned char TargetData::getPrefTypeAlignment(const Type *Ty) const {
516 return getAlignment(Ty, false);
519 unsigned char TargetData::getPreferredTypeAlignmentShift(const Type *Ty) const {
520 unsigned Align = (unsigned) getPrefTypeAlignment(Ty);
521 assert(!(Align & (Align-1)) && "Alignment is not a power of two!");
522 return Log2_32(Align);
525 /// getIntPtrType - Return an unsigned integer type that is the same size or
526 /// greater to the host pointer size.
527 const IntegerType *TargetData::getIntPtrType(LLVMContext &C) const {
528 return IntegerType::get(C, getPointerSizeInBits());
532 uint64_t TargetData::getIndexedOffset(const Type *ptrTy, Value* const* Indices,
533 unsigned NumIndices) const {
534 const Type *Ty = ptrTy;
535 assert(isa<PointerType>(Ty) && "Illegal argument for getIndexedOffset()");
538 generic_gep_type_iterator<Value* const*>
539 TI = gep_type_begin(ptrTy, Indices, Indices+NumIndices);
540 for (unsigned CurIDX = 0; CurIDX != NumIndices; ++CurIDX, ++TI) {
541 if (const StructType *STy = dyn_cast<StructType>(*TI)) {
542 assert(Indices[CurIDX]->getType() ==
543 Type::getInt32Ty(ptrTy->getContext()) &&
544 "Illegal struct idx");
545 unsigned FieldNo = cast<ConstantInt>(Indices[CurIDX])->getZExtValue();
547 // Get structure layout information...
548 const StructLayout *Layout = getStructLayout(STy);
550 // Add in the offset, as calculated by the structure layout info...
551 Result += Layout->getElementOffset(FieldNo);
553 // Update Ty to refer to current element
554 Ty = STy->getElementType(FieldNo);
556 // Update Ty to refer to current element
557 Ty = cast<SequentialType>(Ty)->getElementType();
559 // Get the array index and the size of each array element.
560 int64_t arrayIdx = cast<ConstantInt>(Indices[CurIDX])->getSExtValue();
561 Result += arrayIdx * (int64_t)getTypeAllocSize(Ty);
568 /// getPreferredAlignment - Return the preferred alignment of the specified
569 /// global. This includes an explicitly requested alignment (if the global
571 unsigned TargetData::getPreferredAlignment(const GlobalVariable *GV) const {
572 const Type *ElemType = GV->getType()->getElementType();
573 unsigned Alignment = getPrefTypeAlignment(ElemType);
574 if (GV->getAlignment() > Alignment)
575 Alignment = GV->getAlignment();
577 if (GV->hasInitializer()) {
578 if (Alignment < 16) {
579 // If the global is not external, see if it is large. If so, give it a
581 if (getTypeSizeInBits(ElemType) > 128)
582 Alignment = 16; // 16-byte alignment.
588 /// getPreferredAlignmentLog - Return the preferred alignment of the
589 /// specified global, returned in log form. This includes an explicitly
590 /// requested alignment (if the global has one).
591 unsigned TargetData::getPreferredAlignmentLog(const GlobalVariable *GV) const {
592 return Log2_32(getPreferredAlignment(GV));