blob: 43f0ac8a94d282f9819709513774364671b5a30c [file] [log] [blame]
Chris Lattner53bbf072001-08-27 16:00:15 +00001//===-- TargetData.cpp - Data size & alignment routines --------------------==//
Misha Brukman10468d82005-04-21 22:55:34 +00002//
John Criswell482202a2003-10-20 19:43:21 +00003// The LLVM Compiler Infrastructure
4//
Chris Lattnerf3ebc3f2007-12-29 20:36:04 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Misha Brukman10468d82005-04-21 22:55:34 +00007//
John Criswell482202a2003-10-20 19:43:21 +00008//===----------------------------------------------------------------------===//
Chris Lattner53bbf072001-08-27 16:00:15 +00009//
10// This file defines target properties related to datatype size/offset/alignment
Chris Lattner7140e462004-02-26 08:02:17 +000011// information.
Chris Lattner53bbf072001-08-27 16:00:15 +000012//
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.
16//
17//===----------------------------------------------------------------------===//
18
Vikram S. Adve6cefc702001-09-18 12:58:33 +000019#include "llvm/Target/TargetData.h"
Chris Lattner42516ba2003-04-24 19:09:05 +000020#include "llvm/Module.h"
Chris Lattner53bbf072001-08-27 16:00:15 +000021#include "llvm/DerivedTypes.h"
Chris Lattnerca142372002-04-28 19:55:58 +000022#include "llvm/Constants.h"
Chris Lattner69193f92004-04-05 01:30:19 +000023#include "llvm/Support/GetElementPtrTypeIterator.h"
Reid Spencer7c16caa2004-09-01 22:55:40 +000024#include "llvm/Support/MathExtras.h"
Chris Lattner1e692e82007-02-10 19:43:18 +000025#include "llvm/Support/ManagedStatic.h"
Torok Edwin56d06592009-07-11 20:10:48 +000026#include "llvm/Support/ErrorHandling.h"
Chris Lattnerfed6f0e2007-02-10 20:26:17 +000027#include "llvm/ADT/DenseMap.h"
Owen Anderson8d7774c2006-05-12 05:49:47 +000028#include "llvm/ADT/StringExtras.h"
Chris Lattner34340042005-03-13 19:04:41 +000029#include <algorithm>
Owen Anderson8d7774c2006-05-12 05:49:47 +000030#include <cstdlib>
Chris Lattnerbb661c12003-12-22 05:01:15 +000031using namespace llvm;
Brian Gaeke960707c2003-11-11 22:41:34 +000032
Misha Brukman7eb05a12003-08-18 14:43:39 +000033// Handle the Pass registration stuff necessary to use TargetData's.
Dan Gohmand78c4002008-05-13 00:00:25 +000034
35// Register the default SparcV9 implementation...
36static RegisterPass<TargetData> X("targetdata", "Target Data Layout", false,
37 true);
Devang Patel8c78a0b2007-05-03 01:11:54 +000038char TargetData::ID = 0;
Chris Lattner09cfdcb2002-09-25 23:46:55 +000039
Chris Lattner53bbf072001-08-27 16:00:15 +000040//===----------------------------------------------------------------------===//
Chris Lattner7140e462004-02-26 08:02:17 +000041// Support for StructLayout
Chris Lattner53bbf072001-08-27 16:00:15 +000042//===----------------------------------------------------------------------===//
43
Chris Lattner7140e462004-02-26 08:02:17 +000044StructLayout::StructLayout(const StructType *ST, const TargetData &TD) {
Chris Lattner53bbf072001-08-27 16:00:15 +000045 StructAlignment = 0;
46 StructSize = 0;
Chris Lattnere472f9c2007-02-10 20:15:41 +000047 NumElements = ST->getNumElements();
Chris Lattner53bbf072001-08-27 16:00:15 +000048
Chris Lattnere50d8352008-12-08 07:11:56 +000049 // Loop over each of the elements, placing them in memory.
Chris Lattnere472f9c2007-02-10 20:15:41 +000050 for (unsigned i = 0, e = NumElements; i != e; ++i) {
51 const Type *Ty = ST->getElementType(i);
Duncan Sandsfc3c4892008-06-04 08:21:45 +000052 unsigned TyAlign = ST->isPacked() ? 1 : TD.getABITypeAlignment(Ty);
Chris Lattner53bbf072001-08-27 16:00:15 +000053
Chris Lattnere50d8352008-12-08 07:11:56 +000054 // Add padding if necessary to align the data element properly.
Duncan Sands3812542a2008-12-09 09:58:11 +000055 if ((StructSize & (TyAlign-1)) != 0)
Chris Lattnere50d8352008-12-08 07:11:56 +000056 StructSize = TargetData::RoundUpAlignment(StructSize, TyAlign);
Chris Lattner53bbf072001-08-27 16:00:15 +000057
Chris Lattnere50d8352008-12-08 07:11:56 +000058 // Keep track of maximum alignment constraint.
Chris Lattner7f74a562002-01-20 22:54:45 +000059 StructAlignment = std::max(TyAlign, StructAlignment);
Chris Lattner53bbf072001-08-27 16:00:15 +000060
Chris Lattnere472f9c2007-02-10 20:15:41 +000061 MemberOffsets[i] = StructSize;
Duncan Sandsaf9eaa82009-05-09 07:06:46 +000062 StructSize += TD.getTypeAllocSize(Ty); // Consume space for this data item
Chris Lattner53bbf072001-08-27 16:00:15 +000063 }
64
Chris Lattner6532e422003-05-21 18:08:44 +000065 // Empty structures have alignment of 1 byte.
66 if (StructAlignment == 0) StructAlignment = 1;
67
Chris Lattner53bbf072001-08-27 16:00:15 +000068 // 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.
Chris Lattner911c4342008-12-08 07:21:39 +000070 if ((StructSize & (StructAlignment-1)) != 0)
Chris Lattnere50d8352008-12-08 07:11:56 +000071 StructSize = TargetData::RoundUpAlignment(StructSize, StructAlignment);
Chris Lattner53bbf072001-08-27 16:00:15 +000072}
73
Chris Lattner34340042005-03-13 19:04:41 +000074
75/// getElementContainingOffset - Given a valid offset into the structure,
76/// return the structure index that contains it.
77unsigned StructLayout::getElementContainingOffset(uint64_t Offset) const {
Chris Lattnere472f9c2007-02-10 20:15:41 +000078 const uint64_t *SI =
79 std::upper_bound(&MemberOffsets[0], &MemberOffsets[NumElements], Offset);
80 assert(SI != &MemberOffsets[0] && "Offset not in structure type!");
Chris Lattner34340042005-03-13 19:04:41 +000081 --SI;
82 assert(*SI <= Offset && "upper_bound didn't work");
Chris Lattner9a641512007-10-29 02:40:02 +000083 assert((SI == &MemberOffsets[0] || *(SI-1) <= Offset) &&
Chris Lattnere472f9c2007-02-10 20:15:41 +000084 (SI+1 == &MemberOffsets[NumElements] || *(SI+1) > Offset) &&
Chris Lattner34340042005-03-13 19:04:41 +000085 "Upper bound didn't work!");
Chris Lattner9a641512007-10-29 02:40:02 +000086
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.
Chris Lattnere472f9c2007-02-10 20:15:41 +000092 return SI-&MemberOffsets[0];
Chris Lattner34340042005-03-13 19:04:41 +000093}
94
Chris Lattner53bbf072001-08-27 16:00:15 +000095//===----------------------------------------------------------------------===//
Chris Lattner945e4372007-02-14 05:52:17 +000096// TargetAlignElem, TargetAlign support
97//===----------------------------------------------------------------------===//
98
99TargetAlignElem
100TargetAlignElem::get(AlignTypeEnum align_type, unsigned char abi_align,
Reid Spencer421bad02007-02-19 22:35:00 +0000101 unsigned char pref_align, uint32_t bit_width) {
Duncan Sands05837ed2008-01-29 06:23:44 +0000102 assert(abi_align <= pref_align && "Preferred alignment worse than ABI!");
Chris Lattner945e4372007-02-14 05:52:17 +0000103 TargetAlignElem retval;
104 retval.AlignType = align_type;
105 retval.ABIAlign = abi_align;
106 retval.PrefAlign = pref_align;
107 retval.TypeBitWidth = bit_width;
108 return retval;
109}
110
111bool
Reid Spencerdad84a72007-02-15 02:11:06 +0000112TargetAlignElem::operator==(const TargetAlignElem &rhs) const {
Chris Lattner945e4372007-02-14 05:52:17 +0000113 return (AlignType == rhs.AlignType
114 && ABIAlign == rhs.ABIAlign
115 && PrefAlign == rhs.PrefAlign
116 && TypeBitWidth == rhs.TypeBitWidth);
117}
118
119std::ostream &
Reid Spencerdad84a72007-02-15 02:11:06 +0000120TargetAlignElem::dump(std::ostream &os) const {
Chris Lattner945e4372007-02-14 05:52:17 +0000121 return os << AlignType
122 << TypeBitWidth
123 << ":" << (int) (ABIAlign * 8)
124 << ":" << (int) (PrefAlign * 8);
125}
126
Chris Lattner945e4372007-02-14 05:52:17 +0000127const TargetAlignElem TargetData::InvalidAlignmentElem =
128 TargetAlignElem::get((AlignTypeEnum) -1, 0, 0, 0);
129
130//===----------------------------------------------------------------------===//
Chris Lattner53bbf072001-08-27 16:00:15 +0000131// TargetData Class Implementation
132//===----------------------------------------------------------------------===//
133
Owen Anderson9ca906e2009-08-20 23:14:20 +0000134typedef DenseMap<const StructType*, StructLayout*> LayoutInfoTy;
135
Chris Lattner945e4372007-02-14 05:52:17 +0000136/*!
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:
Reid Spencerdad84a72007-02-15 02:11:06 +0000140 <br><br>
Chris Lattner945e4372007-02-14 05:52:17 +0000141 "E-p:32:32:32-i1:8:8-i8:8:8-i32:32:32-i64:32:64-f32:32:32-f64:32:64"
Reid Spencerdad84a72007-02-15 02:11:06 +0000142 <br><br>
Chris Lattner945e4372007-02-14 05:52:17 +0000143 (note: this string is not fully specified and is only an example.)
144 \p
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.
149 \p
150 Specifier string details:
151 <br><br>
152 <i>[E|e]</i>: Endianness. "E" specifies a big-endian target data model, "e"
153 specifies a little-endian target data model.
154 <br><br>
Reid Spencer446282a2007-08-05 20:06:04 +0000155 <i>p:@verbatim<size>:<abi_align>:<pref_align>@endverbatim</i>: Pointer size,
156 ABI and preferred alignment.
Chris Lattner945e4372007-02-14 05:52:17 +0000157 <br><br>
Chris Lattnerec79bba2008-01-10 00:30:57 +0000158 <i>@verbatim<type><size>:<abi_align>:<pref_align>@endverbatim</i>: Numeric type
159 alignment. Type is
Dan Gohmanf91a9922009-08-20 16:27:10 +0000160 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.
Chris Lattner945e4372007-02-14 05:52:17 +0000162 \p
Dan Gohmanf91a9922009-08-20 16:27:10 +0000163 The default string, fully specified, is:
Chris Lattner945e4372007-02-14 05:52:17 +0000164 <br><br>
Dan Gohmanf91a9922009-08-20 16:27:10 +0000165 "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"
Chris Lattner945e4372007-02-14 05:52:17 +0000167 "-v64:64:64-v128:128:128"
168 <br><br>
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.
172 */
Chris Lattner7f043b52006-06-16 18:11:26 +0000173void TargetData::init(const std::string &TargetDescription) {
Owen Anderson9ca906e2009-08-20 23:14:20 +0000174 LayoutMap = static_cast<void*>(new LayoutInfoTy());
Owen Anderson8d7774c2006-05-12 05:49:47 +0000175 std::string temp = TargetDescription;
176
177 LittleEndian = false;
Chris Lattner50ee0e42007-01-20 22:35:55 +0000178 PointerMemSize = 8;
Chris Lattner945e4372007-02-14 05:52:17 +0000179 PointerABIAlign = 8;
180 PointerPrefAlign = PointerABIAlign;
181
182 // Default alignments
Dan Gohman01704022009-04-01 18:10:16 +0000183 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
Reid Spencerdad84a72007-02-15 02:11:06 +0000188 setAlignment(FLOAT_ALIGN, 4, 4, 32); // float
189 setAlignment(FLOAT_ALIGN, 8, 8, 64); // double
Dan Gohmanf91a9922009-08-20 16:27:10 +0000190 setAlignment(VECTOR_ALIGN, 8, 8, 64); // v2i32, v1i64, ...
Reid Spencer03d4a8a2007-02-15 22:07:05 +0000191 setAlignment(VECTOR_ALIGN, 16, 16, 128); // v16i8, v8i16, v4i32, ...
Dan Gohmanf91a9922009-08-20 16:27:10 +0000192 setAlignment(AGGREGATE_ALIGN, 0, 8, 0); // struct
Rafael Espindola1de0c862007-09-07 14:52:14 +0000193
Owen Anderson88812b52006-05-20 00:24:56 +0000194 while (!temp.empty()) {
Owen Anderson8d7774c2006-05-12 05:49:47 +0000195 std::string token = getToken(temp, "-");
Chris Lattner945e4372007-02-14 05:52:17 +0000196 std::string arg0 = getToken(token, ":");
197 const char *p = arg0.c_str();
Chris Lattner945e4372007-02-14 05:52:17 +0000198 switch(*p) {
Owen Anderson8d7774c2006-05-12 05:49:47 +0000199 case 'E':
Owen Andersond7c77b82006-05-12 06:06:55 +0000200 LittleEndian = false;
201 break;
Owen Anderson8d7774c2006-05-12 05:49:47 +0000202 case 'e':
Owen Andersond7c77b82006-05-12 06:06:55 +0000203 LittleEndian = true;
204 break;
Owen Anderson8d7774c2006-05-12 05:49:47 +0000205 case 'p':
Chris Lattner50ee0e42007-01-20 22:35:55 +0000206 PointerMemSize = atoi(getToken(token,":").c_str()) / 8;
Chris Lattner945e4372007-02-14 05:52:17 +0000207 PointerABIAlign = atoi(getToken(token,":").c_str()) / 8;
208 PointerPrefAlign = atoi(getToken(token,":").c_str()) / 8;
209 if (PointerPrefAlign == 0)
210 PointerPrefAlign = PointerABIAlign;
Owen Andersond7c77b82006-05-12 06:06:55 +0000211 break;
Owen Anderson8d7774c2006-05-12 05:49:47 +0000212 case 'i':
Chris Lattner945e4372007-02-14 05:52:17 +0000213 case 'v':
214 case 'f':
Rafael Espindola1de0c862007-09-07 14:52:14 +0000215 case 'a':
216 case 's': {
Anton Korobeynikov5db5e352007-11-09 19:06:14 +0000217 AlignTypeEnum align_type = STACK_ALIGN; // Dummy init, silence warning
Rafael Espindola1de0c862007-09-07 14:52:14 +0000218 switch(*p) {
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;
224 }
Reid Spencerb6d01ca2007-02-19 23:30:10 +0000225 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;
Chris Lattner945e4372007-02-14 05:52:17 +0000228 if (pref_align == 0)
229 pref_align = abi_align;
230 setAlignment(align_type, abi_align, pref_align, size);
Owen Andersond7c77b82006-05-12 06:06:55 +0000231 break;
Chris Lattner945e4372007-02-14 05:52:17 +0000232 }
Owen Anderson8d7774c2006-05-12 05:49:47 +0000233 default:
Owen Andersond7c77b82006-05-12 06:06:55 +0000234 break;
Owen Anderson8d7774c2006-05-12 05:49:47 +0000235 }
236 }
237}
238
Owen Anderson9ca906e2009-08-20 23:14:20 +0000239TargetData::TargetData(const std::string &TargetDescription)
240 : ImmutablePass(&ID) {
241 init(TargetDescription);
242}
243
Devang Patel09f162c2007-05-01 21:15:47 +0000244TargetData::TargetData(const Module *M)
Dan Gohmana79db302008-09-04 17:05:41 +0000245 : ImmutablePass(&ID) {
Reid Spencer3ac38e92007-01-26 08:11:39 +0000246 init(M->getDataLayout());
Chris Lattner42516ba2003-04-24 19:09:05 +0000247}
248
Owen Anderson9ca906e2009-08-20 23:14:20 +0000249TargetData::TargetData(const TargetData &TD) :
250 ImmutablePass(&ID),
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));
258}
259
260
Chris Lattner945e4372007-02-14 05:52:17 +0000261void
262TargetData::setAlignment(AlignTypeEnum align_type, unsigned char abi_align,
Reid Spencer421bad02007-02-19 22:35:00 +0000263 unsigned char pref_align, uint32_t bit_width) {
Duncan Sands05837ed2008-01-29 06:23:44 +0000264 assert(abi_align <= pref_align && "Preferred alignment worse than ABI!");
Chris Lattner04eb16b2007-02-17 00:41:42 +0000265 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;
271 return;
272 }
273 }
274
275 Alignments.push_back(TargetAlignElem::get(align_type, abi_align,
276 pref_align, bit_width));
Chris Lattner945e4372007-02-14 05:52:17 +0000277}
278
Chris Lattner04eb16b2007-02-17 00:41:42 +0000279/// getAlignmentInfo - Return the alignment (either ABI if ABIInfo = true or
280/// preferred if ABIInfo = false) the target wants for the specified datatype.
Reid Spencer421bad02007-02-19 22:35:00 +0000281unsigned TargetData::getAlignmentInfo(AlignTypeEnum AlignType,
Chris Lattnerec79bba2008-01-10 00:30:57 +0000282 uint32_t BitWidth, bool ABIInfo,
283 const Type *Ty) const {
Chris Lattner04eb16b2007-02-17 00:41:42 +0000284 // Check to see if we have an exact match and remember the best match we see.
285 int BestMatchIdx = -1;
Reid Spencer421bad02007-02-19 22:35:00 +0000286 int LargestInt = -1;
Chris Lattner04eb16b2007-02-17 00:41:42 +0000287 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;
291
292 // The best match so far depends on what we're looking for.
Duncan Sands85f26f22007-12-21 20:18:41 +0000293 if (AlignType == VECTOR_ALIGN && Alignments[i].AlignType == VECTOR_ALIGN) {
Chris Lattner04eb16b2007-02-17 00:41:42 +0000294 // 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>.
Duncan Sands85f26f22007-12-21 20:18:41 +0000297 if (Alignments[i].TypeBitWidth < BitWidth) {
Chris Lattner04eb16b2007-02-17 00:41:42 +0000298 // Verify that we pick the biggest of the fallbacks.
299 if (BestMatchIdx == -1 ||
Duncan Sands85f26f22007-12-21 20:18:41 +0000300 Alignments[BestMatchIdx].TypeBitWidth < Alignments[i].TypeBitWidth)
Chris Lattner04eb16b2007-02-17 00:41:42 +0000301 BestMatchIdx = i;
302 }
Reid Spencer421bad02007-02-19 22:35:00 +0000303 } 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))
309 BestMatchIdx = i;
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)
314 LargestInt = i;
Chris Lattner04eb16b2007-02-17 00:41:42 +0000315 }
Chris Lattner04eb16b2007-02-17 00:41:42 +0000316 }
Chris Lattner945e4372007-02-14 05:52:17 +0000317
Chris Lattner04eb16b2007-02-17 00:41:42 +0000318 // Okay, we didn't find an exact solution. Fall back here depending on what
319 // is being looked for.
Chris Lattnerec79bba2008-01-10 00:30:57 +0000320 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;
324 } else {
325 assert(AlignType == VECTOR_ALIGN && "Unknown alignment type!");
Dan Gohman2a4553b2009-02-16 23:14:14 +0000326
Chris Lattnerec79bba2008-01-10 00:30:57 +0000327 // 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);
Dan Gohman2a4553b2009-02-16 23:14:14 +0000331 }
Chris Lattnerec79bba2008-01-10 00:30:57 +0000332 }
Dan Gohman2a4553b2009-02-16 23:14:14 +0000333
Reid Spencer421bad02007-02-19 22:35:00 +0000334 // Since we got a "best match" index, just return it.
Chris Lattner04eb16b2007-02-17 00:41:42 +0000335 return ABIInfo ? Alignments[BestMatchIdx].ABIAlign
336 : Alignments[BestMatchIdx].PrefAlign;
Chris Lattner945e4372007-02-14 05:52:17 +0000337}
338
Bill Wendlinge3836f92009-08-20 22:04:42 +0000339TargetData::~TargetData() {
Owen Anderson9ca906e2009-08-20 23:14:20 +0000340 assert(LayoutMap && "LayoutMap not initialized?");
341 LayoutInfoTy &TheMap = *static_cast<LayoutInfoTy*>(LayoutMap);
342
Bill Wendlinge3836f92009-08-20 22:04:42 +0000343 // Remove any layouts for this TD.
Bill Wendlinge3836f92009-08-20 22:04:42 +0000344 for (LayoutInfoTy::iterator I = TheMap.begin(), E = TheMap.end(); I != E; ) {
Owen Anderson9ca906e2009-08-20 23:14:20 +0000345 I->second->~StructLayout();
346 free(I->second);
347 TheMap.erase(I++);
Bill Wendlinge3836f92009-08-20 22:04:42 +0000348 }
Owen Anderson9ca906e2009-08-20 23:14:20 +0000349
350 delete static_cast<LayoutInfoTy*>(LayoutMap);
351 LayoutMap = 0;
Chris Lattner7140e462004-02-26 08:02:17 +0000352}
353
Chris Lattnere472f9c2007-02-10 20:15:41 +0000354const StructLayout *TargetData::getStructLayout(const StructType *Ty) const {
Owen Anderson9ca906e2009-08-20 23:14:20 +0000355 assert(LayoutMap && "LayoutMap not initialized?");
356 LayoutInfoTy &TheMap = *static_cast<LayoutInfoTy*>(LayoutMap);
Chris Lattnere472f9c2007-02-10 20:15:41 +0000357
Owen Anderson9ca906e2009-08-20 23:14:20 +0000358 StructLayout *&SL = TheMap[Ty];
Chris Lattnerfed6f0e2007-02-10 20:26:17 +0000359 if (SL) return SL;
Chris Lattnere472f9c2007-02-10 20:15:41 +0000360
361 // Otherwise, create the struct layout. Because it is variable length, we
362 // malloc it, then use placement new.
Jeff Cohen43973632007-04-09 19:26:30 +0000363 int NumElts = Ty->getNumElements();
Chris Lattnere472f9c2007-02-10 20:15:41 +0000364 StructLayout *L =
365 (StructLayout *)malloc(sizeof(StructLayout)+(NumElts-1)*sizeof(uint64_t));
Chris Lattnerfed6f0e2007-02-10 20:26:17 +0000366
367 // Set SL before calling StructLayout's ctor. The ctor could cause other
368 // entries to be added to TheMap, invalidating our reference.
369 SL = L;
370
Chris Lattnere472f9c2007-02-10 20:15:41 +0000371 new (L) StructLayout(Ty, *this);
Chris Lattnere472f9c2007-02-10 20:15:41 +0000372 return L;
373}
374
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.
379void TargetData::InvalidateStructLayoutInfo(const StructType *Ty) const {
Owen Anderson9ca906e2009-08-20 23:14:20 +0000380 assert(LayoutMap && "LayoutMap not initialized?");
381 LayoutInfoTy *LayoutInfo = static_cast<LayoutInfoTy*>(LayoutMap);
382 LayoutInfoTy::iterator I = LayoutInfo->find(Ty);
Chris Lattnere50d8352008-12-08 07:11:56 +0000383 if (I == LayoutInfo->end()) return;
384
385 I->second->~StructLayout();
386 free(I->second);
387 LayoutInfo->erase(I);
Chris Lattnere472f9c2007-02-10 20:15:41 +0000388}
389
390
Owen Anderson5fea9f02006-05-12 07:01:44 +0000391std::string TargetData::getStringRepresentation() const {
Reid Spencerdad84a72007-02-15 02:11:06 +0000392 std::string repr;
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();
399 ++I) {
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)));
404 }
405 return repr;
Owen Anderson5fea9f02006-05-12 07:01:44 +0000406}
407
Chris Lattnera4de9ba2006-01-14 00:07:34 +0000408
Duncan Sands44b87212007-11-01 20:53:16 +0000409uint64_t TargetData::getTypeSizeInBits(const Type *Ty) const {
Chris Lattner6650d182001-12-13 00:46:11 +0000410 assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
Chris Lattner6b727592004-06-17 18:19:28 +0000411 switch (Ty->getTypeID()) {
Chris Lattner53bbf072001-08-27 16:00:15 +0000412 case Type::LabelTyID:
413 case Type::PointerTyID:
Duncan Sands44b87212007-11-01 20:53:16 +0000414 return getPointerSizeInBits();
Chris Lattner53bbf072001-08-27 16:00:15 +0000415 case Type::ArrayTyID: {
Chris Lattner18a08e72004-07-01 17:32:59 +0000416 const ArrayType *ATy = cast<ArrayType>(Ty);
Duncan Sandsaf9eaa82009-05-09 07:06:46 +0000417 return getTypeAllocSizeInBits(ATy->getElementType())*ATy->getNumElements();
Chris Lattnere58bf092004-12-01 17:14:28 +0000418 }
Chris Lattnere50d8352008-12-08 07:11:56 +0000419 case Type::StructTyID:
Chris Lattner53bbf072001-08-27 16:00:15 +0000420 // Get the layout annotation... which is lazily created on demand.
Chris Lattnere50d8352008-12-08 07:11:56 +0000421 return getStructLayout(cast<StructType>(Ty))->getSizeInBits();
Duncan Sands44b87212007-11-01 20:53:16 +0000422 case Type::IntegerTyID:
423 return cast<IntegerType>(Ty)->getBitWidth();
Chris Lattner50ee0e42007-01-20 22:35:55 +0000424 case Type::VoidTyID:
Chris Lattner945e4372007-02-14 05:52:17 +0000425 return 8;
Duncan Sands44b87212007-11-01 20:53:16 +0000426 case Type::FloatTyID:
427 return 32;
428 case Type::DoubleTyID:
429 return 64;
Dale Johannesenc5283ec2007-08-03 20:20:50 +0000430 case Type::PPC_FP128TyID:
431 case Type::FP128TyID:
Duncan Sands44b87212007-11-01 20:53:16 +0000432 return 128;
Dale Johannesenc5283ec2007-08-03 20:20:50 +0000433 // In memory objects this is always aligned to a higher boundary, but
Duncan Sands44b87212007-11-01 20:53:16 +0000434 // only 80 bits contain information.
Dale Johannesenc5283ec2007-08-03 20:20:50 +0000435 case Type::X86_FP80TyID:
Duncan Sands44b87212007-11-01 20:53:16 +0000436 return 80;
Chris Lattnere50d8352008-12-08 07:11:56 +0000437 case Type::VectorTyID:
438 return cast<VectorType>(Ty)->getBitWidth();
Chris Lattner50ee0e42007-01-20 22:35:55 +0000439 default:
Torok Edwinfbcc6632009-07-14 16:55:14 +0000440 llvm_unreachable("TargetData::getTypeSizeInBits(): Unsupported type");
Chris Lattner945e4372007-02-14 05:52:17 +0000441 break;
Chris Lattner50ee0e42007-01-20 22:35:55 +0000442 }
Chris Lattner945e4372007-02-14 05:52:17 +0000443 return 0;
Chris Lattner53bbf072001-08-27 16:00:15 +0000444}
445
Chris Lattner945e4372007-02-14 05:52:17 +0000446/*!
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.
450
451 Get the ABI (\a abi_or_pref == true) or preferred alignment (\a abi_or_pref
452 == false) for the requested type \a Ty.
453 */
Chris Lattnerf9122c42007-02-16 22:25:34 +0000454unsigned char TargetData::getAlignment(const Type *Ty, bool abi_or_pref) const {
Chris Lattner945e4372007-02-14 05:52:17 +0000455 int AlignType = -1;
456
457 assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
458 switch (Ty->getTypeID()) {
Chris Lattnere50d8352008-12-08 07:11:56 +0000459 // Early escape for the non-numeric types.
Chris Lattner945e4372007-02-14 05:52:17 +0000460 case Type::LabelTyID:
461 case Type::PointerTyID:
462 return (abi_or_pref
463 ? getPointerABIAlignment()
464 : getPointerPrefAlignment());
Chris Lattnerf9122c42007-02-16 22:25:34 +0000465 case Type::ArrayTyID:
466 return getAlignment(cast<ArrayType>(Ty)->getElementType(), abi_or_pref);
Dan Gohman2a4553b2009-02-16 23:14:14 +0000467
Chris Lattner945e4372007-02-14 05:52:17 +0000468 case Type::StructTyID: {
Chris Lattnerf9122c42007-02-16 22:25:34 +0000469 // Packed structure types always have an ABI alignment of one.
Chris Lattnerdc64b9d2007-02-16 23:11:51 +0000470 if (cast<StructType>(Ty)->isPacked() && abi_or_pref)
Chris Lattnerf9122c42007-02-16 22:25:34 +0000471 return 1;
Dan Gohman2a4553b2009-02-16 23:14:14 +0000472
Chris Lattnerf9122c42007-02-16 22:25:34 +0000473 // Get the layout annotation... which is lazily created on demand.
Chris Lattner945e4372007-02-14 05:52:17 +0000474 const StructLayout *Layout = getStructLayout(cast<StructType>(Ty));
Chris Lattnerec79bba2008-01-10 00:30:57 +0000475 unsigned Align = getAlignmentInfo(AGGREGATE_ALIGN, 0, abi_or_pref, Ty);
Chris Lattner04eb16b2007-02-17 00:41:42 +0000476 return std::max(Align, (unsigned)Layout->getAlignment());
Chris Lattner945e4372007-02-14 05:52:17 +0000477 }
478 case Type::IntegerTyID:
479 case Type::VoidTyID:
480 AlignType = INTEGER_ALIGN;
481 break;
482 case Type::FloatTyID:
483 case Type::DoubleTyID:
Dale Johannesenc5283ec2007-08-03 20:20:50 +0000484 // 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:
Chris Lattner945e4372007-02-14 05:52:17 +0000489 AlignType = FLOAT_ALIGN;
490 break;
Chris Lattnerec79bba2008-01-10 00:30:57 +0000491 case Type::VectorTyID:
492 AlignType = VECTOR_ALIGN;
Chris Lattner945e4372007-02-14 05:52:17 +0000493 break;
494 default:
Torok Edwinfbcc6632009-07-14 16:55:14 +0000495 llvm_unreachable("Bad type for getAlignment!!!");
Chris Lattner945e4372007-02-14 05:52:17 +0000496 break;
497 }
498
Duncan Sands44b87212007-11-01 20:53:16 +0000499 return getAlignmentInfo((AlignTypeEnum)AlignType, getTypeSizeInBits(Ty),
Chris Lattnerec79bba2008-01-10 00:30:57 +0000500 abi_or_pref, Ty);
Chris Lattner50ee0e42007-01-20 22:35:55 +0000501}
502
Chris Lattner945e4372007-02-14 05:52:17 +0000503unsigned char TargetData::getABITypeAlignment(const Type *Ty) const {
504 return getAlignment(Ty, true);
505}
506
Rafael Espindola1de0c862007-09-07 14:52:14 +0000507unsigned 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;
511
512 return getABITypeAlignment(Ty);
513}
514
Chris Lattner945e4372007-02-14 05:52:17 +0000515unsigned char TargetData::getPrefTypeAlignment(const Type *Ty) const {
516 return getAlignment(Ty, false);
Chris Lattner53bbf072001-08-27 16:00:15 +0000517}
518
Evan Chengf5c96fa2007-01-24 07:03:39 +0000519unsigned char TargetData::getPreferredTypeAlignmentShift(const Type *Ty) const {
Chris Lattner945e4372007-02-14 05:52:17 +0000520 unsigned Align = (unsigned) getPrefTypeAlignment(Ty);
Chris Lattner0c2ab8a2004-08-17 19:13:00 +0000521 assert(!(Align & (Align-1)) && "Alignment is not a power of two!");
Chris Lattner6667bdb2005-08-02 19:26:06 +0000522 return Log2_32(Align);
Chris Lattner0c2ab8a2004-08-17 19:13:00 +0000523}
524
Chris Lattnerbb661c12003-12-22 05:01:15 +0000525/// getIntPtrType - Return an unsigned integer type that is the same size or
526/// greater to the host pointer size.
Owen Anderson55f1c092009-08-13 21:58:54 +0000527const IntegerType *TargetData::getIntPtrType(LLVMContext &C) const {
528 return IntegerType::get(C, getPointerSizeInBits());
Chris Lattnerbb661c12003-12-22 05:01:15 +0000529}
530
531
Chris Lattner336e3962007-02-10 19:33:15 +0000532uint64_t TargetData::getIndexedOffset(const Type *ptrTy, Value* const* Indices,
533 unsigned NumIndices) const {
Vikram S. Adve71895b22002-08-04 20:52:39 +0000534 const Type *Ty = ptrTy;
535 assert(isa<PointerType>(Ty) && "Illegal argument for getIndexedOffset()");
Vikram S. Adve8b831742002-05-19 15:28:02 +0000536 uint64_t Result = 0;
Chris Lattner53bbf072001-08-27 16:00:15 +0000537
Chris Lattner336e3962007-02-10 19:33:15 +0000538 generic_gep_type_iterator<Value* const*>
539 TI = gep_type_begin(ptrTy, Indices, Indices+NumIndices);
540 for (unsigned CurIDX = 0; CurIDX != NumIndices; ++CurIDX, ++TI) {
Chris Lattner69193f92004-04-05 01:30:19 +0000541 if (const StructType *STy = dyn_cast<StructType>(*TI)) {
Owen Anderson55f1c092009-08-13 21:58:54 +0000542 assert(Indices[CurIDX]->getType() ==
543 Type::getInt32Ty(ptrTy->getContext()) &&
Reid Spencerdf30e2a2007-03-01 19:48:16 +0000544 "Illegal struct idx");
Chris Lattner336e3962007-02-10 19:33:15 +0000545 unsigned FieldNo = cast<ConstantInt>(Indices[CurIDX])->getZExtValue();
Chris Lattner53bbf072001-08-27 16:00:15 +0000546
547 // Get structure layout information...
548 const StructLayout *Layout = getStructLayout(STy);
549
550 // Add in the offset, as calculated by the structure layout info...
Chris Lattnerc473d8e2007-02-10 19:55:17 +0000551 Result += Layout->getElementOffset(FieldNo);
Vikram S. Adve71895b22002-08-04 20:52:39 +0000552
Chris Lattner53bbf072001-08-27 16:00:15 +0000553 // Update Ty to refer to current element
Chris Lattnerac6db752004-02-09 04:37:31 +0000554 Ty = STy->getElementType(FieldNo);
Chris Lattner69193f92004-04-05 01:30:19 +0000555 } else {
556 // Update Ty to refer to current element
557 Ty = cast<SequentialType>(Ty)->getElementType();
558
559 // Get the array index and the size of each array element.
Chris Lattner336e3962007-02-10 19:33:15 +0000560 int64_t arrayIdx = cast<ConstantInt>(Indices[CurIDX])->getSExtValue();
Duncan Sandsaf9eaa82009-05-09 07:06:46 +0000561 Result += arrayIdx * (int64_t)getTypeAllocSize(Ty);
Chris Lattner53bbf072001-08-27 16:00:15 +0000562 }
563 }
564
565 return Result;
566}
Brian Gaeke960707c2003-11-11 22:41:34 +0000567
Duncan Sands05837ed2008-01-29 06:23:44 +0000568/// getPreferredAlignment - Return the preferred alignment of the specified
569/// global. This includes an explicitly requested alignment (if the global
570/// has one).
571unsigned 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();
576
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
580 // larger alignment.
581 if (getTypeSizeInBits(ElemType) > 128)
582 Alignment = 16; // 16-byte alignment.
583 }
584 }
585 return Alignment;
586}
587
Devang Patel71b99292006-10-24 20:32:14 +0000588/// 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).
591unsigned TargetData::getPreferredAlignmentLog(const GlobalVariable *GV) const {
Duncan Sands05837ed2008-01-29 06:23:44 +0000592 return Log2_32(getPreferredAlignment(GV));
Devang Patel71b99292006-10-24 20:32:14 +0000593}