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/ADT/StringExtras.h"
31 // Handle the Pass registration stuff necessary to use TargetData's.
33 // Register the default SparcV9 implementation...
34 RegisterPass<TargetData> X("targetdata", "Target Data Layout");
37 static inline void getTypeInfo(const Type *Ty, const TargetData *TD,
38 uint64_t &Size, unsigned char &Alignment);
40 //===----------------------------------------------------------------------===//
41 // Support for StructLayout
42 //===----------------------------------------------------------------------===//
44 StructLayout::StructLayout(const StructType *ST, const TargetData &TD) {
48 // Loop over each of the elements, placing them in memory...
49 for (StructType::element_iterator TI = ST->element_begin(),
50 TE = ST->element_end(); TI != TE; ++TI) {
55 getTypeInfo(Ty, &TD, TySize, A);
58 // Add padding if necessary to make the data element aligned properly...
59 if (StructSize % TyAlign != 0)
60 StructSize = (StructSize/TyAlign + 1) * TyAlign; // Add padding...
62 // Keep track of maximum alignment constraint
63 StructAlignment = std::max(TyAlign, StructAlignment);
65 MemberOffsets.push_back(StructSize);
66 StructSize += TySize; // Consume space for this data item
69 // Empty structures have alignment of 1 byte.
70 if (StructAlignment == 0) StructAlignment = 1;
72 // Add padding to the end of the struct so that it could be put in an array
73 // and all array elements would be aligned correctly.
74 if (StructSize % StructAlignment != 0)
75 StructSize = (StructSize/StructAlignment + 1) * StructAlignment;
79 /// getElementContainingOffset - Given a valid offset into the structure,
80 /// return the structure index that contains it.
81 unsigned StructLayout::getElementContainingOffset(uint64_t Offset) const {
82 std::vector<uint64_t>::const_iterator SI =
83 std::upper_bound(MemberOffsets.begin(), MemberOffsets.end(),
85 assert(SI != MemberOffsets.begin() && "Offset not in structure type!");
87 assert(*SI <= Offset && "upper_bound didn't work");
88 assert((SI == MemberOffsets.begin() || *(SI-1) < Offset) &&
89 (SI+1 == MemberOffsets.end() || *(SI+1) > Offset) &&
90 "Upper bound didn't work!");
91 return SI-MemberOffsets.begin();
94 //===----------------------------------------------------------------------===//
95 // TargetData Class Implementation
96 //===----------------------------------------------------------------------===//
98 void TargetData::init(const std::string &TargetDescription) {
99 std::string temp = TargetDescription;
101 LittleEndian = false;
103 PointerAlignment = 8;
112 while (!temp.empty()) {
113 std::string token = getToken(temp, "-");
115 char signal = getToken(token, ":")[0];
119 LittleEndian = false;
125 PointerSize = atoi(getToken(token,":").c_str()) / 8;
126 PointerAlignment = atoi(getToken(token,":").c_str()) / 8;
129 DoubleAlignment = atoi(getToken(token,":").c_str()) / 8;
132 FloatAlignment = atoi(getToken(token, ":").c_str()) / 8;
135 LongAlignment = atoi(getToken(token, ":").c_str()) / 8;
138 IntAlignment = atoi(getToken(token, ":").c_str()) / 8;
141 ShortAlignment = atoi(getToken(token, ":").c_str()) / 8;
144 ByteAlignment = atoi(getToken(token, ":").c_str()) / 8;
147 BoolAlignment = atoi(getToken(token, ":").c_str()) / 8;
155 TargetData::TargetData(const Module *M) {
156 LittleEndian = M->getEndianness() != Module::BigEndian;
157 PointerSize = M->getPointerSize() != Module::Pointer64 ? 4 : 8;
158 PointerAlignment = PointerSize;
159 DoubleAlignment = PointerSize;
161 LongAlignment = PointerSize;
168 /// Layouts - The lazy cache of structure layout information maintained by
171 static std::map<std::pair<const TargetData*,const StructType*>,
172 StructLayout> *Layouts = 0;
175 TargetData::~TargetData() {
177 // Remove any layouts for this TD.
178 std::map<std::pair<const TargetData*,
179 const StructType*>, StructLayout>::iterator
180 I = Layouts->lower_bound(std::make_pair(this, (const StructType*)0));
181 while (I != Layouts->end() && I->first.first == this)
183 if (Layouts->empty()) {
190 std::string TargetData::getStringRepresentation() const {
191 std::stringstream repr;
198 repr << "-p:" << (PointerSize * 8) << ":" << (PointerAlignment * 8);
199 repr << "-d:64:" << (DoubleAlignment * 8);
200 repr << "-f:32:" << (FloatAlignment * 8);
201 repr << "-l:64:" << (LongAlignment * 8);
202 repr << "-i:32:" << (IntAlignment * 8);
203 repr << "-s:16:" << (ShortAlignment * 8);
204 repr << "-b:8:" << (ByteAlignment * 8);
205 repr << "-B:8:" << (BoolAlignment * 8);
210 const StructLayout *TargetData::getStructLayout(const StructType *Ty) const {
212 Layouts = new std::map<std::pair<const TargetData*,const StructType*>,
214 std::map<std::pair<const TargetData*,const StructType*>,
215 StructLayout>::iterator
216 I = Layouts->lower_bound(std::make_pair(this, Ty));
217 if (I != Layouts->end() && I->first.first == this && I->first.second == Ty)
220 return &Layouts->insert(I, std::make_pair(std::make_pair(this, Ty),
221 StructLayout(Ty, *this)))->second;
225 /// InvalidateStructLayoutInfo - TargetData speculatively caches StructLayout
226 /// objects. If a TargetData object is alive when types are being refined and
227 /// removed, this method must be called whenever a StructType is removed to
228 /// avoid a dangling pointer in this cache.
229 void TargetData::InvalidateStructLayoutInfo(const StructType *Ty) const {
230 if (!Layouts) return; // No cache.
232 std::map<std::pair<const TargetData*,const StructType*>,
233 StructLayout>::iterator I = Layouts->find(std::make_pair(this, Ty));
234 if (I != Layouts->end())
240 static inline void getTypeInfo(const Type *Ty, const TargetData *TD,
241 uint64_t &Size, unsigned char &Alignment) {
242 assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
243 switch (Ty->getTypeID()) {
244 case Type::BoolTyID: Size = 1; Alignment = TD->getBoolAlignment(); return;
246 case Type::UByteTyID:
247 case Type::SByteTyID: Size = 1; Alignment = TD->getByteAlignment(); return;
248 case Type::UShortTyID:
249 case Type::ShortTyID: Size = 2; Alignment = TD->getShortAlignment(); return;
251 case Type::IntTyID: Size = 4; Alignment = TD->getIntAlignment(); return;
252 case Type::ULongTyID:
253 case Type::LongTyID: Size = 8; Alignment = TD->getLongAlignment(); return;
254 case Type::FloatTyID: Size = 4; Alignment = TD->getFloatAlignment(); return;
255 case Type::DoubleTyID: Size = 8; Alignment = TD->getDoubleAlignment(); return;
256 case Type::LabelTyID:
257 case Type::PointerTyID:
258 Size = TD->getPointerSize(); Alignment = TD->getPointerAlignment();
260 case Type::ArrayTyID: {
261 const ArrayType *ATy = cast<ArrayType>(Ty);
262 getTypeInfo(ATy->getElementType(), TD, Size, Alignment);
263 unsigned AlignedSize = (Size + Alignment - 1)/Alignment*Alignment;
264 Size = AlignedSize*ATy->getNumElements();
267 case Type::PackedTyID: {
268 const PackedType *PTy = cast<PackedType>(Ty);
269 getTypeInfo(PTy->getElementType(), TD, Size, Alignment);
270 unsigned AlignedSize = (Size + Alignment - 1)/Alignment*Alignment;
271 Size = AlignedSize*PTy->getNumElements();
272 // FIXME: The alignments of specific packed types are target dependent.
273 // For now, just set it to be equal to Size.
277 case Type::StructTyID: {
278 // Get the layout annotation... which is lazily created on demand.
279 const StructLayout *Layout = TD->getStructLayout(cast<StructType>(Ty));
280 Size = Layout->StructSize; Alignment = Layout->StructAlignment;
285 assert(0 && "Bad type for getTypeInfo!!!");
290 uint64_t TargetData::getTypeSize(const Type *Ty) const {
293 getTypeInfo(Ty, this, Size, Align);
297 unsigned char TargetData::getTypeAlignment(const Type *Ty) const {
300 getTypeInfo(Ty, this, Size, Align);
304 unsigned char TargetData::getTypeAlignmentShift(const Type *Ty) const {
305 unsigned Align = getTypeAlignment(Ty);
306 assert(!(Align & (Align-1)) && "Alignment is not a power of two!");
307 return Log2_32(Align);
310 /// getIntPtrType - Return an unsigned integer type that is the same size or
311 /// greater to the host pointer size.
312 const Type *TargetData::getIntPtrType() const {
313 switch (getPointerSize()) {
314 default: assert(0 && "Unknown pointer size!");
315 case 2: return Type::UShortTy;
316 case 4: return Type::UIntTy;
317 case 8: return Type::ULongTy;
322 uint64_t TargetData::getIndexedOffset(const Type *ptrTy,
323 const std::vector<Value*> &Idx) const {
324 const Type *Ty = ptrTy;
325 assert(isa<PointerType>(Ty) && "Illegal argument for getIndexedOffset()");
328 generic_gep_type_iterator<std::vector<Value*>::const_iterator>
329 TI = gep_type_begin(ptrTy, Idx.begin(), Idx.end());
330 for (unsigned CurIDX = 0; CurIDX != Idx.size(); ++CurIDX, ++TI) {
331 if (const StructType *STy = dyn_cast<StructType>(*TI)) {
332 assert(Idx[CurIDX]->getType() == Type::UIntTy && "Illegal struct idx");
333 unsigned FieldNo = cast<ConstantUInt>(Idx[CurIDX])->getValue();
335 // Get structure layout information...
336 const StructLayout *Layout = getStructLayout(STy);
338 // Add in the offset, as calculated by the structure layout info...
339 assert(FieldNo < Layout->MemberOffsets.size() &&"FieldNo out of range!");
340 Result += Layout->MemberOffsets[FieldNo];
342 // Update Ty to refer to current element
343 Ty = STy->getElementType(FieldNo);
345 // Update Ty to refer to current element
346 Ty = cast<SequentialType>(Ty)->getElementType();
348 // Get the array index and the size of each array element.
349 int64_t arrayIdx = cast<ConstantInt>(Idx[CurIDX])->getRawValue();
350 Result += arrayIdx * (int64_t)getTypeSize(Ty);