blob: ff60e0b29c74d3c19dc89b9fdace0b3814acdff2 [file] [log] [blame]
Chris Lattnere7fb3602001-08-27 16:00:15 +00001//===-- TargetData.cpp - Data size & alignment routines --------------------==//
Misha Brukmanf976c852005-04-21 22:55:34 +00002//
John Criswellb576c942003-10-20 19:43:21 +00003// The LLVM Compiler Infrastructure
4//
Chris Lattner4ee451d2007-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 Brukmanf976c852005-04-21 22:55:34 +00007//
John Criswellb576c942003-10-20 19:43:21 +00008//===----------------------------------------------------------------------===//
Chris Lattnere7fb3602001-08-27 16:00:15 +00009//
10// This file defines target properties related to datatype size/offset/alignment
Chris Lattner0e7ac162004-02-26 08:02:17 +000011// information.
Chris Lattnere7fb3602001-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. Adve0799fc42001-09-18 12:58:33 +000019#include "llvm/Target/TargetData.h"
Chris Lattner31bcdb82002-04-28 19:55:58 +000020#include "llvm/Constants.h"
Bill Wendling5eea3422009-11-18 01:03:56 +000021#include "llvm/DerivedTypes.h"
22#include "llvm/Module.h"
Chris Lattner28977af2004-04-05 01:30:19 +000023#include "llvm/Support/GetElementPtrTypeIterator.h"
Reid Spencer551ccae2004-09-01 22:55:40 +000024#include "llvm/Support/MathExtras.h"
Chris Lattnerec6478b2007-02-10 19:43:18 +000025#include "llvm/Support/ManagedStatic.h"
Torok Edwinc25e7582009-07-11 20:10:48 +000026#include "llvm/Support/ErrorHandling.h"
Chris Lattnerb7aadfa2009-11-07 09:13:23 +000027#include "llvm/Support/raw_ostream.h"
Michael J. Spencer1f6efa32010-11-29 18:16:10 +000028#include "llvm/Support/Mutex.h"
Chris Lattnerf6ca09a2007-02-10 20:26:17 +000029#include "llvm/ADT/DenseMap.h"
Chris Lattnere7ea48c2005-03-13 19:04:41 +000030#include <algorithm>
Owen Anderson8f60c562006-05-12 05:49:47 +000031#include <cstdlib>
Chris Lattnerf0453282003-12-22 05:01:15 +000032using namespace llvm;
Brian Gaeked0fde302003-11-11 22:41:34 +000033
Misha Brukman5560c9d2003-08-18 14:43:39 +000034// Handle the Pass registration stuff necessary to use TargetData's.
Dan Gohman844731a2008-05-13 00:00:25 +000035
36// Register the default SparcV9 implementation...
Owen Andersonce665bd2010-10-07 22:25:06 +000037INITIALIZE_PASS(TargetData, "targetdata", "Target Data Layout", false, true)
Devang Patel19974732007-05-03 01:11:54 +000038char TargetData::ID = 0;
Chris Lattneraa31ad02002-09-25 23:46:55 +000039
Chris Lattnere7fb3602001-08-27 16:00:15 +000040//===----------------------------------------------------------------------===//
Chris Lattner0e7ac162004-02-26 08:02:17 +000041// Support for StructLayout
Chris Lattnere7fb3602001-08-27 16:00:15 +000042//===----------------------------------------------------------------------===//
43
Chris Lattnerdb125cf2011-07-18 04:54:35 +000044StructLayout::StructLayout(StructType *ST, const TargetData &TD) {
Chris Lattner1afcace2011-07-09 17:41:24 +000045 assert(!ST->isOpaque() && "Cannot get layout of opaque structs");
Chris Lattnere7fb3602001-08-27 16:00:15 +000046 StructAlignment = 0;
47 StructSize = 0;
Chris Lattner9182e3f2007-02-10 20:15:41 +000048 NumElements = ST->getNumElements();
Chris Lattnere7fb3602001-08-27 16:00:15 +000049
Chris Lattnerbedb8c12008-12-08 07:11:56 +000050 // Loop over each of the elements, placing them in memory.
Chris Lattner9182e3f2007-02-10 20:15:41 +000051 for (unsigned i = 0, e = NumElements; i != e; ++i) {
Chris Lattnerdb125cf2011-07-18 04:54:35 +000052 Type *Ty = ST->getElementType(i);
Duncan Sandsa0fcc082008-06-04 08:21:45 +000053 unsigned TyAlign = ST->isPacked() ? 1 : TD.getABITypeAlignment(Ty);
Chris Lattnere7fb3602001-08-27 16:00:15 +000054
Chris Lattnerbedb8c12008-12-08 07:11:56 +000055 // Add padding if necessary to align the data element properly.
Duncan Sands677a7ec2008-12-09 09:58:11 +000056 if ((StructSize & (TyAlign-1)) != 0)
Chris Lattnerbedb8c12008-12-08 07:11:56 +000057 StructSize = TargetData::RoundUpAlignment(StructSize, TyAlign);
Chris Lattnere7fb3602001-08-27 16:00:15 +000058
Chris Lattnerbedb8c12008-12-08 07:11:56 +000059 // Keep track of maximum alignment constraint.
Chris Lattner697954c2002-01-20 22:54:45 +000060 StructAlignment = std::max(TyAlign, StructAlignment);
Chris Lattnere7fb3602001-08-27 16:00:15 +000061
Chris Lattner9182e3f2007-02-10 20:15:41 +000062 MemberOffsets[i] = StructSize;
Duncan Sands777d2302009-05-09 07:06:46 +000063 StructSize += TD.getTypeAllocSize(Ty); // Consume space for this data item
Chris Lattnere7fb3602001-08-27 16:00:15 +000064 }
65
Chris Lattner4e840d42003-05-21 18:08:44 +000066 // Empty structures have alignment of 1 byte.
67 if (StructAlignment == 0) StructAlignment = 1;
68
Chris Lattnere7fb3602001-08-27 16:00:15 +000069 // Add padding to the end of the struct so that it could be put in an array
70 // and all array elements would be aligned correctly.
Chris Lattner59779c52008-12-08 07:21:39 +000071 if ((StructSize & (StructAlignment-1)) != 0)
Chris Lattnerbedb8c12008-12-08 07:11:56 +000072 StructSize = TargetData::RoundUpAlignment(StructSize, StructAlignment);
Chris Lattnere7fb3602001-08-27 16:00:15 +000073}
74
Chris Lattnere7ea48c2005-03-13 19:04:41 +000075
76/// getElementContainingOffset - Given a valid offset into the structure,
77/// return the structure index that contains it.
78unsigned StructLayout::getElementContainingOffset(uint64_t Offset) const {
Chris Lattner9182e3f2007-02-10 20:15:41 +000079 const uint64_t *SI =
80 std::upper_bound(&MemberOffsets[0], &MemberOffsets[NumElements], Offset);
81 assert(SI != &MemberOffsets[0] && "Offset not in structure type!");
Chris Lattnere7ea48c2005-03-13 19:04:41 +000082 --SI;
83 assert(*SI <= Offset && "upper_bound didn't work");
Chris Lattnerb361ec32007-10-29 02:40:02 +000084 assert((SI == &MemberOffsets[0] || *(SI-1) <= Offset) &&
Chris Lattner9182e3f2007-02-10 20:15:41 +000085 (SI+1 == &MemberOffsets[NumElements] || *(SI+1) > Offset) &&
Chris Lattnere7ea48c2005-03-13 19:04:41 +000086 "Upper bound didn't work!");
Michael J. Spencer87b86652010-10-19 07:32:42 +000087
Chris Lattnerb361ec32007-10-29 02:40:02 +000088 // Multiple fields can have the same offset if any of them are zero sized.
89 // For example, in { i32, [0 x i32], i32 }, searching for offset 4 will stop
90 // at the i32 element, because it is the last element at that offset. This is
91 // the right one to return, because anything after it will have a higher
92 // offset, implying that this element is non-empty.
Chris Lattner9182e3f2007-02-10 20:15:41 +000093 return SI-&MemberOffsets[0];
Chris Lattnere7ea48c2005-03-13 19:04:41 +000094}
95
Chris Lattnere7fb3602001-08-27 16:00:15 +000096//===----------------------------------------------------------------------===//
Chris Lattnerd2b7cec2007-02-14 05:52:17 +000097// TargetAlignElem, TargetAlign support
98//===----------------------------------------------------------------------===//
99
100TargetAlignElem
Dan Gohmanb68f2742010-08-11 18:15:01 +0000101TargetAlignElem::get(AlignTypeEnum align_type, unsigned abi_align,
102 unsigned pref_align, uint32_t bit_width) {
Duncan Sandsd1025932008-01-29 06:23:44 +0000103 assert(abi_align <= pref_align && "Preferred alignment worse than ABI!");
Chris Lattnerd2b7cec2007-02-14 05:52:17 +0000104 TargetAlignElem retval;
105 retval.AlignType = align_type;
106 retval.ABIAlign = abi_align;
107 retval.PrefAlign = pref_align;
108 retval.TypeBitWidth = bit_width;
109 return retval;
110}
111
112bool
Reid Spencerb7d61102007-02-15 02:11:06 +0000113TargetAlignElem::operator==(const TargetAlignElem &rhs) const {
Chris Lattnerd2b7cec2007-02-14 05:52:17 +0000114 return (AlignType == rhs.AlignType
115 && ABIAlign == rhs.ABIAlign
116 && PrefAlign == rhs.PrefAlign
117 && TypeBitWidth == rhs.TypeBitWidth);
118}
119
Chris Lattnerd2b7cec2007-02-14 05:52:17 +0000120const TargetAlignElem TargetData::InvalidAlignmentElem =
121 TargetAlignElem::get((AlignTypeEnum) -1, 0, 0, 0);
122
123//===----------------------------------------------------------------------===//
Chris Lattnere7fb3602001-08-27 16:00:15 +0000124// TargetData Class Implementation
125//===----------------------------------------------------------------------===//
126
Chris Lattnerb7aadfa2009-11-07 09:13:23 +0000127/// getInt - Get an integer ignoring errors.
Lang Hames1dda3d52011-10-20 19:24:44 +0000128static int getInt(StringRef R) {
129 int Result = 0;
Chris Lattnerb7aadfa2009-11-07 09:13:23 +0000130 R.getAsInteger(10, Result);
131 return Result;
132}
133
Lang Hames1dda3d52011-10-20 19:24:44 +0000134void TargetData::init() {
Owen Anderson081c34b2010-10-19 17:21:58 +0000135 initializeTargetDataPass(*PassRegistry::getPassRegistry());
Lang Hames1dda3d52011-10-20 19:24:44 +0000136
Owen Anderson90857502009-08-21 19:59:12 +0000137 LayoutMap = 0;
Owen Anderson8f60c562006-05-12 05:49:47 +0000138 LittleEndian = false;
Chris Lattner58092e32007-01-20 22:35:55 +0000139 PointerMemSize = 8;
Chris Lattnerb7aadfa2009-11-07 09:13:23 +0000140 PointerABIAlign = 8;
Chris Lattnerd2b7cec2007-02-14 05:52:17 +0000141 PointerPrefAlign = PointerABIAlign;
Lang Hamesbb5b3f32011-10-10 23:42:08 +0000142 StackNaturalAlign = 0;
Chris Lattnerd2b7cec2007-02-14 05:52:17 +0000143
144 // Default alignments
Dan Gohman77c5b0d2009-04-01 18:10:16 +0000145 setAlignment(INTEGER_ALIGN, 1, 1, 1); // i1
146 setAlignment(INTEGER_ALIGN, 1, 1, 8); // i8
147 setAlignment(INTEGER_ALIGN, 2, 2, 16); // i16
148 setAlignment(INTEGER_ALIGN, 4, 4, 32); // i32
149 setAlignment(INTEGER_ALIGN, 4, 8, 64); // i64
Reid Spencerb7d61102007-02-15 02:11:06 +0000150 setAlignment(FLOAT_ALIGN, 4, 4, 32); // float
151 setAlignment(FLOAT_ALIGN, 8, 8, 64); // double
Dan Gohmand35626e2009-08-20 16:27:10 +0000152 setAlignment(VECTOR_ALIGN, 8, 8, 64); // v2i32, v1i64, ...
Reid Spencer1f437872007-02-15 22:07:05 +0000153 setAlignment(VECTOR_ALIGN, 16, 16, 128); // v16i8, v8i16, v4i32, ...
Dan Gohmand35626e2009-08-20 16:27:10 +0000154 setAlignment(AGGREGATE_ALIGN, 0, 8, 0); // struct
Lang Hames1dda3d52011-10-20 19:24:44 +0000155}
156
157std::string TargetData::parseSpecifier(StringRef Desc, TargetData *td) {
158
159 if (td)
160 td->init();
Rafael Espindola588af2f2007-09-07 14:52:14 +0000161
Chris Lattnerb7aadfa2009-11-07 09:13:23 +0000162 while (!Desc.empty()) {
163 std::pair<StringRef, StringRef> Split = Desc.split('-');
164 StringRef Token = Split.first;
165 Desc = Split.second;
Michael J. Spencer87b86652010-10-19 07:32:42 +0000166
Chris Lattnerb7aadfa2009-11-07 09:13:23 +0000167 if (Token.empty())
168 continue;
Michael J. Spencer87b86652010-10-19 07:32:42 +0000169
Chris Lattnerb7aadfa2009-11-07 09:13:23 +0000170 Split = Token.split(':');
171 StringRef Specifier = Split.first;
172 Token = Split.second;
Michael J. Spencer87b86652010-10-19 07:32:42 +0000173
Chris Lattnerb7aadfa2009-11-07 09:13:23 +0000174 assert(!Specifier.empty() && "Can't be empty here");
Michael J. Spencer87b86652010-10-19 07:32:42 +0000175
Chris Lattnere82bdc42009-11-07 09:35:34 +0000176 switch (Specifier[0]) {
Owen Anderson8f60c562006-05-12 05:49:47 +0000177 case 'E':
Lang Hames1dda3d52011-10-20 19:24:44 +0000178 if (td)
179 td->LittleEndian = false;
Owen Anderson571a13f2006-05-12 06:06:55 +0000180 break;
Owen Anderson8f60c562006-05-12 05:49:47 +0000181 case 'e':
Lang Hames1dda3d52011-10-20 19:24:44 +0000182 if (td)
183 td->LittleEndian = true;
Owen Anderson571a13f2006-05-12 06:06:55 +0000184 break;
Lang Hames1dda3d52011-10-20 19:24:44 +0000185 case 'p': {
186 // Pointer size.
Chris Lattnerb7aadfa2009-11-07 09:13:23 +0000187 Split = Token.split(':');
Lang Hames1dda3d52011-10-20 19:24:44 +0000188 int PointerMemSizeBits = getInt(Split.first);
189 if (PointerMemSizeBits < 0 || PointerMemSizeBits % 8 != 0)
190 return "invalid pointer size, must be a positive 8-bit multiple";
191 if (td)
192 td->PointerMemSize = PointerMemSizeBits / 8;
193
194 // Pointer ABI alignment.
Chris Lattnerb7aadfa2009-11-07 09:13:23 +0000195 Split = Split.second.split(':');
Lang Hames1dda3d52011-10-20 19:24:44 +0000196 int PointerABIAlignBits = getInt(Split.first);
197 if (PointerABIAlignBits < 0 || PointerABIAlignBits % 8 != 0) {
198 return "invalid pointer ABI alignment, "
199 "must be a positive 8-bit multiple";
200 }
201 if (td)
202 td->PointerABIAlign = PointerABIAlignBits / 8;
203
204 // Pointer preferred alignment.
Chris Lattnerb7aadfa2009-11-07 09:13:23 +0000205 Split = Split.second.split(':');
Lang Hames1dda3d52011-10-20 19:24:44 +0000206 int PointerPrefAlignBits = getInt(Split.first);
207 if (PointerPrefAlignBits < 0 || PointerPrefAlignBits % 8 != 0) {
208 return "invalid pointer preferred alignment, "
209 "must be a positive 8-bit multiple";
210 }
211 if (td) {
212 td->PointerPrefAlign = PointerPrefAlignBits / 8;
213 if (td->PointerPrefAlign == 0)
214 td->PointerPrefAlign = td->PointerABIAlign;
215 }
Owen Anderson571a13f2006-05-12 06:06:55 +0000216 break;
Lang Hames1dda3d52011-10-20 19:24:44 +0000217 }
Owen Anderson8f60c562006-05-12 05:49:47 +0000218 case 'i':
Chris Lattnerd2b7cec2007-02-14 05:52:17 +0000219 case 'v':
220 case 'f':
Rafael Espindola588af2f2007-09-07 14:52:14 +0000221 case 'a':
222 case 's': {
Chris Lattnerb7aadfa2009-11-07 09:13:23 +0000223 AlignTypeEnum AlignType;
Lang Hames1dda3d52011-10-20 19:24:44 +0000224 char field = Specifier[0];
225 switch (field) {
Chris Lattnerb7aadfa2009-11-07 09:13:23 +0000226 default:
227 case 'i': AlignType = INTEGER_ALIGN; break;
228 case 'v': AlignType = VECTOR_ALIGN; break;
229 case 'f': AlignType = FLOAT_ALIGN; break;
230 case 'a': AlignType = AGGREGATE_ALIGN; break;
231 case 's': AlignType = STACK_ALIGN; break;
Rafael Espindola588af2f2007-09-07 14:52:14 +0000232 }
Lang Hames1dda3d52011-10-20 19:24:44 +0000233 int Size = getInt(Specifier.substr(1));
234 if (Size < 0) {
235 return std::string("invalid ") + field + "-size field, "
236 "must be positive";
237 }
238
Chris Lattnerb7aadfa2009-11-07 09:13:23 +0000239 Split = Token.split(':');
Lang Hames1dda3d52011-10-20 19:24:44 +0000240 int ABIAlignBits = getInt(Split.first);
241 if (ABIAlignBits < 0 || ABIAlignBits % 8 != 0) {
242 return std::string("invalid ") + field +"-abi-alignment field, "
243 "must be a positive 8-bit multiple";
244 }
245 unsigned ABIAlign = ABIAlignBits / 8;
Michael J. Spencer87b86652010-10-19 07:32:42 +0000246
Chris Lattnerb7aadfa2009-11-07 09:13:23 +0000247 Split = Split.second.split(':');
Lang Hames1dda3d52011-10-20 19:24:44 +0000248
249 int PrefAlignBits = getInt(Split.first);
250 if (PrefAlignBits < 0 || PrefAlignBits % 8 != 0) {
251 return std::string("invalid ") + field +"-preferred-alignment field, "
252 "must be a positive 8-bit multiple";
253 }
254 unsigned PrefAlign = PrefAlignBits / 8;
Chris Lattnerb7aadfa2009-11-07 09:13:23 +0000255 if (PrefAlign == 0)
256 PrefAlign = ABIAlign;
Lang Hames1dda3d52011-10-20 19:24:44 +0000257
258 if (td)
259 td->setAlignment(AlignType, ABIAlign, PrefAlign, Size);
Owen Anderson571a13f2006-05-12 06:06:55 +0000260 break;
Chris Lattnerd2b7cec2007-02-14 05:52:17 +0000261 }
Chris Lattnere82bdc42009-11-07 09:35:34 +0000262 case 'n': // Native integer types.
263 Specifier = Specifier.substr(1);
264 do {
Lang Hames1dda3d52011-10-20 19:24:44 +0000265 int Width = getInt(Specifier);
266 if (Width <= 0) {
267 return std::string("invalid native integer size \'") + Specifier.str() +
268 "\', must be a positive integer.";
269 }
270 if (td && Width != 0)
271 td->LegalIntWidths.push_back(Width);
Chris Lattnere82bdc42009-11-07 09:35:34 +0000272 Split = Token.split(':');
273 Specifier = Split.first;
274 Token = Split.second;
275 } while (!Specifier.empty() || !Token.empty());
276 break;
Lang Hames1dda3d52011-10-20 19:24:44 +0000277 case 'S': { // Stack natural alignment.
278 int StackNaturalAlignBits = getInt(Specifier.substr(1));
279 if (StackNaturalAlignBits < 0 || StackNaturalAlignBits % 8 != 0) {
280 return "invalid natural stack alignment (S-field), "
281 "must be a positive 8-bit multiple";
282 }
283 if (td)
284 td->StackNaturalAlign = StackNaturalAlignBits / 8;
Lang Hamesbb5b3f32011-10-10 23:42:08 +0000285 break;
Lang Hames1dda3d52011-10-20 19:24:44 +0000286 }
Owen Anderson8f60c562006-05-12 05:49:47 +0000287 default:
Owen Anderson571a13f2006-05-12 06:06:55 +0000288 break;
Owen Anderson8f60c562006-05-12 05:49:47 +0000289 }
290 }
Lang Hames1dda3d52011-10-20 19:24:44 +0000291
292 return "";
Owen Anderson8f60c562006-05-12 05:49:47 +0000293}
294
Chris Lattner2e074942009-11-07 09:23:04 +0000295/// Default ctor.
296///
297/// @note This has to exist, because this is a pass, but it should never be
298/// used.
Owen Anderson90c579d2010-08-06 18:33:48 +0000299TargetData::TargetData() : ImmutablePass(ID) {
Chris Lattner75361b62010-04-07 22:58:41 +0000300 report_fatal_error("Bad TargetData ctor used. "
Chris Lattner2e074942009-11-07 09:23:04 +0000301 "Tool did not specify a TargetData to use?");
302}
303
Michael J. Spencer87b86652010-10-19 07:32:42 +0000304TargetData::TargetData(const Module *M)
Owen Anderson90c579d2010-08-06 18:33:48 +0000305 : ImmutablePass(ID) {
Lang Hames1dda3d52011-10-20 19:24:44 +0000306 std::string errMsg = parseSpecifier(M->getDataLayout(), this);
307 assert(errMsg == "" && "Module M has malformed target data layout string.");
308 (void)errMsg;
Chris Lattner53a0c382003-04-24 19:09:05 +0000309}
310
Chris Lattnerd2b7cec2007-02-14 05:52:17 +0000311void
Dan Gohmanb68f2742010-08-11 18:15:01 +0000312TargetData::setAlignment(AlignTypeEnum align_type, unsigned abi_align,
313 unsigned pref_align, uint32_t bit_width) {
Duncan Sandsd1025932008-01-29 06:23:44 +0000314 assert(abi_align <= pref_align && "Preferred alignment worse than ABI!");
Chris Lattneraffeb562007-02-17 00:41:42 +0000315 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
316 if (Alignments[i].AlignType == align_type &&
317 Alignments[i].TypeBitWidth == bit_width) {
318 // Update the abi, preferred alignments.
319 Alignments[i].ABIAlign = abi_align;
320 Alignments[i].PrefAlign = pref_align;
321 return;
322 }
323 }
Michael J. Spencer87b86652010-10-19 07:32:42 +0000324
Chris Lattneraffeb562007-02-17 00:41:42 +0000325 Alignments.push_back(TargetAlignElem::get(align_type, abi_align,
326 pref_align, bit_width));
Chris Lattnerd2b7cec2007-02-14 05:52:17 +0000327}
328
Michael J. Spencer87b86652010-10-19 07:32:42 +0000329/// getAlignmentInfo - Return the alignment (either ABI if ABIInfo = true or
Chris Lattneraffeb562007-02-17 00:41:42 +0000330/// preferred if ABIInfo = false) the target wants for the specified datatype.
Michael J. Spencer87b86652010-10-19 07:32:42 +0000331unsigned TargetData::getAlignmentInfo(AlignTypeEnum AlignType,
Chris Lattner9c4428b2008-01-10 00:30:57 +0000332 uint32_t BitWidth, bool ABIInfo,
Chris Lattnerdb125cf2011-07-18 04:54:35 +0000333 Type *Ty) const {
Chris Lattneraffeb562007-02-17 00:41:42 +0000334 // Check to see if we have an exact match and remember the best match we see.
335 int BestMatchIdx = -1;
Reid Spencerf734ea22007-02-19 22:35:00 +0000336 int LargestInt = -1;
Chris Lattneraffeb562007-02-17 00:41:42 +0000337 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
338 if (Alignments[i].AlignType == AlignType &&
339 Alignments[i].TypeBitWidth == BitWidth)
340 return ABIInfo ? Alignments[i].ABIAlign : Alignments[i].PrefAlign;
Michael J. Spencer87b86652010-10-19 07:32:42 +0000341
Chris Lattneraffeb562007-02-17 00:41:42 +0000342 // The best match so far depends on what we're looking for.
Michael J. Spencer87b86652010-10-19 07:32:42 +0000343 if (AlignType == INTEGER_ALIGN &&
Dan Gohman6e8fd902010-04-23 19:41:15 +0000344 Alignments[i].AlignType == INTEGER_ALIGN) {
Reid Spencerf734ea22007-02-19 22:35:00 +0000345 // The "best match" for integers is the smallest size that is larger than
346 // the BitWidth requested.
Michael J. Spencer87b86652010-10-19 07:32:42 +0000347 if (Alignments[i].TypeBitWidth > BitWidth && (BestMatchIdx == -1 ||
Reid Spencerf734ea22007-02-19 22:35:00 +0000348 Alignments[i].TypeBitWidth < Alignments[BestMatchIdx].TypeBitWidth))
349 BestMatchIdx = i;
350 // However, if there isn't one that's larger, then we must use the
351 // largest one we have (see below)
Michael J. Spencer87b86652010-10-19 07:32:42 +0000352 if (LargestInt == -1 ||
Reid Spencerf734ea22007-02-19 22:35:00 +0000353 Alignments[i].TypeBitWidth > Alignments[LargestInt].TypeBitWidth)
354 LargestInt = i;
Chris Lattneraffeb562007-02-17 00:41:42 +0000355 }
Chris Lattneraffeb562007-02-17 00:41:42 +0000356 }
Chris Lattnerd2b7cec2007-02-14 05:52:17 +0000357
Chris Lattneraffeb562007-02-17 00:41:42 +0000358 // Okay, we didn't find an exact solution. Fall back here depending on what
359 // is being looked for.
Chris Lattner9c4428b2008-01-10 00:30:57 +0000360 if (BestMatchIdx == -1) {
361 // If we didn't find an integer alignment, fall back on most conservative.
362 if (AlignType == INTEGER_ALIGN) {
363 BestMatchIdx = LargestInt;
364 } else {
365 assert(AlignType == VECTOR_ALIGN && "Unknown alignment type!");
Dan Gohman9fbb52d2009-02-16 23:14:14 +0000366
Dan Gohman6e8fd902010-04-23 19:41:15 +0000367 // By default, use natural alignment for vector types. This is consistent
368 // with what clang and llvm-gcc do.
369 unsigned Align = getTypeAllocSize(cast<VectorType>(Ty)->getElementType());
370 Align *= cast<VectorType>(Ty)->getNumElements();
371 // If the alignment is not a power of 2, round up to the next power of 2.
372 // This happens for non-power-of-2 length vectors.
373 if (Align & (Align-1))
374 Align = llvm::NextPowerOf2(Align);
375 return Align;
Dan Gohman9fbb52d2009-02-16 23:14:14 +0000376 }
Chris Lattner9c4428b2008-01-10 00:30:57 +0000377 }
Dan Gohman9fbb52d2009-02-16 23:14:14 +0000378
Reid Spencerf734ea22007-02-19 22:35:00 +0000379 // Since we got a "best match" index, just return it.
Chris Lattneraffeb562007-02-17 00:41:42 +0000380 return ABIInfo ? Alignments[BestMatchIdx].ABIAlign
381 : Alignments[BestMatchIdx].PrefAlign;
Chris Lattnerd2b7cec2007-02-14 05:52:17 +0000382}
383
Bill Wendlingdd5eb022009-12-03 00:17:12 +0000384namespace {
Bill Wendling5eea3422009-11-18 01:03:56 +0000385
Chris Lattner1afcace2011-07-09 17:41:24 +0000386class StructLayoutMap {
Chris Lattnerdb125cf2011-07-18 04:54:35 +0000387 typedef DenseMap<StructType*, StructLayout*> LayoutInfoTy;
Bill Wendling5eea3422009-11-18 01:03:56 +0000388 LayoutInfoTy LayoutInfo;
389
Bill Wendling5eea3422009-11-18 01:03:56 +0000390public:
391 virtual ~StructLayoutMap() {
392 // Remove any layouts.
Chris Lattner1afcace2011-07-09 17:41:24 +0000393 for (LayoutInfoTy::iterator I = LayoutInfo.begin(), E = LayoutInfo.end();
394 I != E; ++I) {
Bill Wendlingdd5eb022009-12-03 00:17:12 +0000395 StructLayout *Value = I->second;
Bill Wendling1500c4f2009-12-04 21:03:02 +0000396 Value->~StructLayout();
397 free(Value);
Bill Wendlingdd5eb022009-12-03 00:17:12 +0000398 }
Bill Wendling5eea3422009-11-18 01:03:56 +0000399 }
400
Chris Lattnerdb125cf2011-07-18 04:54:35 +0000401 StructLayout *&operator[](StructType *STy) {
Bill Wendling5eea3422009-11-18 01:03:56 +0000402 return LayoutInfo[STy];
403 }
404
405 // for debugging...
406 virtual void dump() const {}
407};
408
Bill Wendling1500c4f2009-12-04 21:03:02 +0000409} // end anonymous namespace
Owen Anderson2ea20152009-08-20 23:51:44 +0000410
411TargetData::~TargetData() {
Bill Wendlingdd5eb022009-12-03 00:17:12 +0000412 delete static_cast<StructLayoutMap*>(LayoutMap);
Chris Lattner0e7ac162004-02-26 08:02:17 +0000413}
414
Chris Lattnerdb125cf2011-07-18 04:54:35 +0000415const StructLayout *TargetData::getStructLayout(StructType *Ty) const {
Owen Anderson90857502009-08-21 19:59:12 +0000416 if (!LayoutMap)
Bill Wendling5eea3422009-11-18 01:03:56 +0000417 LayoutMap = new StructLayoutMap();
Michael J. Spencer87b86652010-10-19 07:32:42 +0000418
Bill Wendlingdd5eb022009-12-03 00:17:12 +0000419 StructLayoutMap *STM = static_cast<StructLayoutMap*>(LayoutMap);
420 StructLayout *&SL = (*STM)[Ty];
Chris Lattnerf6ca09a2007-02-10 20:26:17 +0000421 if (SL) return SL;
Chris Lattner9182e3f2007-02-10 20:15:41 +0000422
Michael J. Spencer87b86652010-10-19 07:32:42 +0000423 // Otherwise, create the struct layout. Because it is variable length, we
Chris Lattner9182e3f2007-02-10 20:15:41 +0000424 // malloc it, then use placement new.
Jeff Cohen44f5fb42007-04-09 19:26:30 +0000425 int NumElts = Ty->getNumElements();
Chris Lattner9182e3f2007-02-10 20:15:41 +0000426 StructLayout *L =
Bill Wendling5eea3422009-11-18 01:03:56 +0000427 (StructLayout *)malloc(sizeof(StructLayout)+(NumElts-1) * sizeof(uint64_t));
Michael J. Spencer87b86652010-10-19 07:32:42 +0000428
Chris Lattnerf6ca09a2007-02-10 20:26:17 +0000429 // Set SL before calling StructLayout's ctor. The ctor could cause other
430 // entries to be added to TheMap, invalidating our reference.
431 SL = L;
Michael J. Spencer87b86652010-10-19 07:32:42 +0000432
Chris Lattner9182e3f2007-02-10 20:15:41 +0000433 new (L) StructLayout(Ty, *this);
Bill Wendlingdd5eb022009-12-03 00:17:12 +0000434
Chris Lattner9182e3f2007-02-10 20:15:41 +0000435 return L;
436}
437
Owen Anderson2577c222006-05-12 07:01:44 +0000438std::string TargetData::getStringRepresentation() const {
Chris Lattnerb7aadfa2009-11-07 09:13:23 +0000439 std::string Result;
440 raw_string_ostream OS(Result);
Michael J. Spencer87b86652010-10-19 07:32:42 +0000441
Chris Lattnerb7aadfa2009-11-07 09:13:23 +0000442 OS << (LittleEndian ? "e" : "E")
443 << "-p:" << PointerMemSize*8 << ':' << PointerABIAlign*8
Lang Hamesbb5b3f32011-10-10 23:42:08 +0000444 << ':' << PointerPrefAlign*8
445 << "-S" << StackNaturalAlign*8;
446
Chris Lattner2e074942009-11-07 09:23:04 +0000447 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
448 const TargetAlignElem &AI = Alignments[i];
449 OS << '-' << (char)AI.AlignType << AI.TypeBitWidth << ':'
450 << AI.ABIAlign*8 << ':' << AI.PrefAlign*8;
451 }
Michael J. Spencer87b86652010-10-19 07:32:42 +0000452
Chris Lattner7e897382009-11-08 02:32:01 +0000453 if (!LegalIntWidths.empty()) {
454 OS << "-n" << (unsigned)LegalIntWidths[0];
Michael J. Spencer87b86652010-10-19 07:32:42 +0000455
Chris Lattner7e897382009-11-08 02:32:01 +0000456 for (unsigned i = 1, e = LegalIntWidths.size(); i != e; ++i)
457 OS << ':' << (unsigned)LegalIntWidths[i];
458 }
Chris Lattnerb7aadfa2009-11-07 09:13:23 +0000459 return OS.str();
Owen Anderson2577c222006-05-12 07:01:44 +0000460}
461
Chris Lattner8dff24f2006-01-14 00:07:34 +0000462
Chris Lattnerdb125cf2011-07-18 04:54:35 +0000463uint64_t TargetData::getTypeSizeInBits(Type *Ty) const {
Chris Lattnerf59ce922001-12-13 00:46:11 +0000464 assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
Chris Lattnerf70c22b2004-06-17 18:19:28 +0000465 switch (Ty->getTypeID()) {
Chris Lattnere7fb3602001-08-27 16:00:15 +0000466 case Type::LabelTyID:
467 case Type::PointerTyID:
Duncan Sands514ab342007-11-01 20:53:16 +0000468 return getPointerSizeInBits();
Chris Lattnere7fb3602001-08-27 16:00:15 +0000469 case Type::ArrayTyID: {
Chris Lattnerdb125cf2011-07-18 04:54:35 +0000470 ArrayType *ATy = cast<ArrayType>(Ty);
Dan Gohmanaa9d8542010-02-25 15:20:39 +0000471 return getTypeAllocSizeInBits(ATy->getElementType())*ATy->getNumElements();
Chris Lattner527efc62004-12-01 17:14:28 +0000472 }
Chris Lattnerbedb8c12008-12-08 07:11:56 +0000473 case Type::StructTyID:
Chris Lattnere7fb3602001-08-27 16:00:15 +0000474 // Get the layout annotation... which is lazily created on demand.
Chris Lattnerbedb8c12008-12-08 07:11:56 +0000475 return getStructLayout(cast<StructType>(Ty))->getSizeInBits();
Duncan Sands514ab342007-11-01 20:53:16 +0000476 case Type::IntegerTyID:
477 return cast<IntegerType>(Ty)->getBitWidth();
Chris Lattner58092e32007-01-20 22:35:55 +0000478 case Type::VoidTyID:
Chris Lattnerd2b7cec2007-02-14 05:52:17 +0000479 return 8;
Duncan Sands514ab342007-11-01 20:53:16 +0000480 case Type::FloatTyID:
481 return 32;
482 case Type::DoubleTyID:
Dale Johannesenbb811a22010-09-10 20:55:01 +0000483 case Type::X86_MMXTyID:
Duncan Sands514ab342007-11-01 20:53:16 +0000484 return 64;
Dale Johannesen8c1e6a12007-08-03 20:20:50 +0000485 case Type::PPC_FP128TyID:
486 case Type::FP128TyID:
Duncan Sands514ab342007-11-01 20:53:16 +0000487 return 128;
Dale Johannesen8c1e6a12007-08-03 20:20:50 +0000488 // In memory objects this is always aligned to a higher boundary, but
Duncan Sands514ab342007-11-01 20:53:16 +0000489 // only 80 bits contain information.
Dale Johannesen8c1e6a12007-08-03 20:20:50 +0000490 case Type::X86_FP80TyID:
Duncan Sands514ab342007-11-01 20:53:16 +0000491 return 80;
Chris Lattnerbedb8c12008-12-08 07:11:56 +0000492 case Type::VectorTyID:
493 return cast<VectorType>(Ty)->getBitWidth();
Chris Lattner58092e32007-01-20 22:35:55 +0000494 default:
Torok Edwinc23197a2009-07-14 16:55:14 +0000495 llvm_unreachable("TargetData::getTypeSizeInBits(): Unsupported type");
Chris Lattnerd2b7cec2007-02-14 05:52:17 +0000496 break;
Chris Lattner58092e32007-01-20 22:35:55 +0000497 }
Chris Lattnerd2b7cec2007-02-14 05:52:17 +0000498 return 0;
Chris Lattnere7fb3602001-08-27 16:00:15 +0000499}
500
Chris Lattnerd2b7cec2007-02-14 05:52:17 +0000501/*!
502 \param abi_or_pref Flag that determines which alignment is returned. true
503 returns the ABI alignment, false returns the preferred alignment.
504 \param Ty The underlying type for which alignment is determined.
505
506 Get the ABI (\a abi_or_pref == true) or preferred alignment (\a abi_or_pref
507 == false) for the requested type \a Ty.
508 */
Chris Lattnerdb125cf2011-07-18 04:54:35 +0000509unsigned TargetData::getAlignment(Type *Ty, bool abi_or_pref) const {
Chris Lattnerd2b7cec2007-02-14 05:52:17 +0000510 int AlignType = -1;
511
512 assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
513 switch (Ty->getTypeID()) {
Chris Lattnerbedb8c12008-12-08 07:11:56 +0000514 // Early escape for the non-numeric types.
Chris Lattnerd2b7cec2007-02-14 05:52:17 +0000515 case Type::LabelTyID:
516 case Type::PointerTyID:
517 return (abi_or_pref
518 ? getPointerABIAlignment()
519 : getPointerPrefAlignment());
Chris Lattnerae6f1fa2007-02-16 22:25:34 +0000520 case Type::ArrayTyID:
521 return getAlignment(cast<ArrayType>(Ty)->getElementType(), abi_or_pref);
Dan Gohman9fbb52d2009-02-16 23:14:14 +0000522
Chris Lattnerd2b7cec2007-02-14 05:52:17 +0000523 case Type::StructTyID: {
Chris Lattnerae6f1fa2007-02-16 22:25:34 +0000524 // Packed structure types always have an ABI alignment of one.
Chris Lattner3ebb2e02007-02-16 23:11:51 +0000525 if (cast<StructType>(Ty)->isPacked() && abi_or_pref)
Chris Lattnerae6f1fa2007-02-16 22:25:34 +0000526 return 1;
Dan Gohman9fbb52d2009-02-16 23:14:14 +0000527
Chris Lattnerae6f1fa2007-02-16 22:25:34 +0000528 // Get the layout annotation... which is lazily created on demand.
Chris Lattnerd2b7cec2007-02-14 05:52:17 +0000529 const StructLayout *Layout = getStructLayout(cast<StructType>(Ty));
Chris Lattner9c4428b2008-01-10 00:30:57 +0000530 unsigned Align = getAlignmentInfo(AGGREGATE_ALIGN, 0, abi_or_pref, Ty);
Dan Gohmanb68f2742010-08-11 18:15:01 +0000531 return std::max(Align, Layout->getAlignment());
Chris Lattnerd2b7cec2007-02-14 05:52:17 +0000532 }
533 case Type::IntegerTyID:
534 case Type::VoidTyID:
535 AlignType = INTEGER_ALIGN;
536 break;
537 case Type::FloatTyID:
538 case Type::DoubleTyID:
Dale Johannesen8c1e6a12007-08-03 20:20:50 +0000539 // PPC_FP128TyID and FP128TyID have different data contents, but the
540 // same size and alignment, so they look the same here.
541 case Type::PPC_FP128TyID:
542 case Type::FP128TyID:
543 case Type::X86_FP80TyID:
Chris Lattnerd2b7cec2007-02-14 05:52:17 +0000544 AlignType = FLOAT_ALIGN;
545 break;
Dale Johannesen29fc6f32010-09-15 00:52:23 +0000546 case Type::X86_MMXTyID:
Chris Lattner9c4428b2008-01-10 00:30:57 +0000547 case Type::VectorTyID:
548 AlignType = VECTOR_ALIGN;
Chris Lattnerd2b7cec2007-02-14 05:52:17 +0000549 break;
550 default:
Torok Edwinc23197a2009-07-14 16:55:14 +0000551 llvm_unreachable("Bad type for getAlignment!!!");
Chris Lattnerd2b7cec2007-02-14 05:52:17 +0000552 break;
553 }
554
Duncan Sands514ab342007-11-01 20:53:16 +0000555 return getAlignmentInfo((AlignTypeEnum)AlignType, getTypeSizeInBits(Ty),
Chris Lattner9c4428b2008-01-10 00:30:57 +0000556 abi_or_pref, Ty);
Chris Lattner58092e32007-01-20 22:35:55 +0000557}
558
Chris Lattnerdb125cf2011-07-18 04:54:35 +0000559unsigned TargetData::getABITypeAlignment(Type *Ty) const {
Chris Lattnerd2b7cec2007-02-14 05:52:17 +0000560 return getAlignment(Ty, true);
561}
562
Chris Lattnerda63b3a2010-01-25 23:18:11 +0000563/// getABIIntegerTypeAlignment - Return the minimum ABI-required alignment for
564/// an integer type of the specified bitwidth.
Dan Gohmanb68f2742010-08-11 18:15:01 +0000565unsigned TargetData::getABIIntegerTypeAlignment(unsigned BitWidth) const {
Chris Lattnerda63b3a2010-01-25 23:18:11 +0000566 return getAlignmentInfo(INTEGER_ALIGN, BitWidth, true, 0);
567}
568
569
Chris Lattnerdb125cf2011-07-18 04:54:35 +0000570unsigned TargetData::getCallFrameTypeAlignment(Type *Ty) const {
Rafael Espindola588af2f2007-09-07 14:52:14 +0000571 for (unsigned i = 0, e = Alignments.size(); i != e; ++i)
572 if (Alignments[i].AlignType == STACK_ALIGN)
573 return Alignments[i].ABIAlign;
574
575 return getABITypeAlignment(Ty);
576}
577
Chris Lattnerdb125cf2011-07-18 04:54:35 +0000578unsigned TargetData::getPrefTypeAlignment(Type *Ty) const {
Chris Lattnerd2b7cec2007-02-14 05:52:17 +0000579 return getAlignment(Ty, false);
Chris Lattnere7fb3602001-08-27 16:00:15 +0000580}
581
Chris Lattnerdb125cf2011-07-18 04:54:35 +0000582unsigned TargetData::getPreferredTypeAlignmentShift(Type *Ty) const {
Dan Gohmanb68f2742010-08-11 18:15:01 +0000583 unsigned Align = getPrefTypeAlignment(Ty);
Chris Lattnerd2b0bb42004-08-17 19:13:00 +0000584 assert(!(Align & (Align-1)) && "Alignment is not a power of two!");
Chris Lattner0561b3f2005-08-02 19:26:06 +0000585 return Log2_32(Align);
Chris Lattnerd2b0bb42004-08-17 19:13:00 +0000586}
587
Chris Lattnerf0453282003-12-22 05:01:15 +0000588/// getIntPtrType - Return an unsigned integer type that is the same size or
589/// greater to the host pointer size.
Tobias Grossere3f5ae72011-07-12 11:36:58 +0000590IntegerType *TargetData::getIntPtrType(LLVMContext &C) const {
Owen Anderson1d0be152009-08-13 21:58:54 +0000591 return IntegerType::get(C, getPointerSizeInBits());
Chris Lattnerf0453282003-12-22 05:01:15 +0000592}
593
594
Jay Foad8fbbb392011-07-19 14:01:37 +0000595uint64_t TargetData::getIndexedOffset(Type *ptrTy,
596 ArrayRef<Value *> Indices) const {
Chris Lattnerdb125cf2011-07-18 04:54:35 +0000597 Type *Ty = ptrTy;
Duncan Sands1df98592010-02-16 11:11:14 +0000598 assert(Ty->isPointerTy() && "Illegal argument for getIndexedOffset()");
Vikram S. Advef66723f2002-05-19 15:28:02 +0000599 uint64_t Result = 0;
Chris Lattnere7fb3602001-08-27 16:00:15 +0000600
Chris Lattnerddce8d22007-02-10 19:33:15 +0000601 generic_gep_type_iterator<Value* const*>
Jay Foadca12a212011-07-19 14:42:50 +0000602 TI = gep_type_begin(ptrTy, Indices);
Jay Foad8fbbb392011-07-19 14:01:37 +0000603 for (unsigned CurIDX = 0, EndIDX = Indices.size(); CurIDX != EndIDX;
604 ++CurIDX, ++TI) {
Chris Lattnerdb125cf2011-07-18 04:54:35 +0000605 if (StructType *STy = dyn_cast<StructType>(*TI)) {
Owen Anderson1d0be152009-08-13 21:58:54 +0000606 assert(Indices[CurIDX]->getType() ==
607 Type::getInt32Ty(ptrTy->getContext()) &&
Reid Spencer1ede29c2007-03-01 19:48:16 +0000608 "Illegal struct idx");
Chris Lattnerddce8d22007-02-10 19:33:15 +0000609 unsigned FieldNo = cast<ConstantInt>(Indices[CurIDX])->getZExtValue();
Chris Lattnere7fb3602001-08-27 16:00:15 +0000610
611 // Get structure layout information...
612 const StructLayout *Layout = getStructLayout(STy);
613
614 // Add in the offset, as calculated by the structure layout info...
Chris Lattnerb1919e22007-02-10 19:55:17 +0000615 Result += Layout->getElementOffset(FieldNo);
Vikram S. Adveed0030e2002-08-04 20:52:39 +0000616
Chris Lattnere7fb3602001-08-27 16:00:15 +0000617 // Update Ty to refer to current element
Chris Lattnerd21cd802004-02-09 04:37:31 +0000618 Ty = STy->getElementType(FieldNo);
Chris Lattner28977af2004-04-05 01:30:19 +0000619 } else {
620 // Update Ty to refer to current element
621 Ty = cast<SequentialType>(Ty)->getElementType();
622
623 // Get the array index and the size of each array element.
Chris Lattner34e9d172010-04-17 19:02:33 +0000624 if (int64_t arrayIdx = cast<ConstantInt>(Indices[CurIDX])->getSExtValue())
Dan Gohman67d04982010-07-28 17:11:36 +0000625 Result += (uint64_t)arrayIdx * getTypeAllocSize(Ty);
Chris Lattnere7fb3602001-08-27 16:00:15 +0000626 }
627 }
628
629 return Result;
630}
Brian Gaeked0fde302003-11-11 22:41:34 +0000631
Duncan Sandsd1025932008-01-29 06:23:44 +0000632/// getPreferredAlignment - Return the preferred alignment of the specified
633/// global. This includes an explicitly requested alignment (if the global
634/// has one).
635unsigned TargetData::getPreferredAlignment(const GlobalVariable *GV) const {
Chris Lattnerdb125cf2011-07-18 04:54:35 +0000636 Type *ElemType = GV->getType()->getElementType();
Duncan Sandsd1025932008-01-29 06:23:44 +0000637 unsigned Alignment = getPrefTypeAlignment(ElemType);
Cameron Zwarichd8b88d82011-04-13 06:03:16 +0000638 unsigned GVAlignment = GV->getAlignment();
639 if (GVAlignment >= Alignment) {
640 Alignment = GVAlignment;
641 } else if (GVAlignment != 0) {
Cameron Zwaricheb04a332011-04-13 09:02:43 +0000642 Alignment = std::max(GVAlignment, getABITypeAlignment(ElemType));
Cameron Zwarichd8b88d82011-04-13 06:03:16 +0000643 }
Duncan Sandsd1025932008-01-29 06:23:44 +0000644
Cameron Zwarich13350222011-04-13 20:36:04 +0000645 if (GV->hasInitializer() && GVAlignment == 0) {
Duncan Sandsd1025932008-01-29 06:23:44 +0000646 if (Alignment < 16) {
647 // If the global is not external, see if it is large. If so, give it a
648 // larger alignment.
Dan Gohmanf860db22010-04-02 03:04:37 +0000649 if (getTypeSizeInBits(ElemType) > 128)
Duncan Sandsd1025932008-01-29 06:23:44 +0000650 Alignment = 16; // 16-byte alignment.
651 }
652 }
653 return Alignment;
654}
655
Devang Patelf9c197e2006-10-24 20:32:14 +0000656/// getPreferredAlignmentLog - Return the preferred alignment of the
657/// specified global, returned in log form. This includes an explicitly
658/// requested alignment (if the global has one).
659unsigned TargetData::getPreferredAlignmentLog(const GlobalVariable *GV) const {
Duncan Sandsd1025932008-01-29 06:23:44 +0000660 return Log2_32(getPreferredAlignment(GV));
Devang Patelf9c197e2006-10-24 20:32:14 +0000661}