TargetData.cpp revision bedb8c1d35e420165fca7455d4025bf82913a38f
1//===-- TargetData.cpp - Data size & alignment routines --------------------==// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file defines target properties related to datatype size/offset/alignment 11// information. 12// 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 19#include "llvm/Target/TargetData.h" 20#include "llvm/Module.h" 21#include "llvm/DerivedTypes.h" 22#include "llvm/Constants.h" 23#include "llvm/Support/GetElementPtrTypeIterator.h" 24#include "llvm/Support/MathExtras.h" 25#include "llvm/Support/ManagedStatic.h" 26#include "llvm/ADT/DenseMap.h" 27#include "llvm/ADT/StringExtras.h" 28#include <algorithm> 29#include <cstdlib> 30using namespace llvm; 31 32// Handle the Pass registration stuff necessary to use TargetData's. 33 34// Register the default SparcV9 implementation... 35static RegisterPass<TargetData> X("targetdata", "Target Data Layout", false, 36 true); 37char TargetData::ID = 0; 38 39//===----------------------------------------------------------------------===// 40// Support for StructLayout 41//===----------------------------------------------------------------------===// 42 43StructLayout::StructLayout(const StructType *ST, const TargetData &TD) { 44 StructAlignment = 0; 45 StructSize = 0; 46 NumElements = ST->getNumElements(); 47 48 // Loop over each of the elements, placing them in memory. 49 for (unsigned i = 0, e = NumElements; i != e; ++i) { 50 const Type *Ty = ST->getElementType(i); 51 unsigned TyAlign = ST->isPacked() ? 1 : TD.getABITypeAlignment(Ty); 52 53 // Add padding if necessary to align the data element properly. 54 if (StructSize & TyAlign-1) 55 StructSize = TargetData::RoundUpAlignment(StructSize, TyAlign); 56 57 // Keep track of maximum alignment constraint. 58 StructAlignment = std::max(TyAlign, StructAlignment); 59 60 MemberOffsets[i] = StructSize; 61 StructSize += TD.getABITypeSize(Ty); // Consume space for this data item 62 } 63 64 // Empty structures have alignment of 1 byte. 65 if (StructAlignment == 0) StructAlignment = 1; 66 67 // Add padding to the end of the struct so that it could be put in an array 68 // and all array elements would be aligned correctly. 69 if (StructSize & (StructAlignment-1) != 0) 70 StructSize = TargetData::RoundUpAlignment(StructSize, StructAlignment); 71} 72 73 74/// getElementContainingOffset - Given a valid offset into the structure, 75/// return the structure index that contains it. 76unsigned StructLayout::getElementContainingOffset(uint64_t Offset) const { 77 const uint64_t *SI = 78 std::upper_bound(&MemberOffsets[0], &MemberOffsets[NumElements], Offset); 79 assert(SI != &MemberOffsets[0] && "Offset not in structure type!"); 80 --SI; 81 assert(*SI <= Offset && "upper_bound didn't work"); 82 assert((SI == &MemberOffsets[0] || *(SI-1) <= Offset) && 83 (SI+1 == &MemberOffsets[NumElements] || *(SI+1) > Offset) && 84 "Upper bound didn't work!"); 85 86 // Multiple fields can have the same offset if any of them are zero sized. 87 // For example, in { i32, [0 x i32], i32 }, searching for offset 4 will stop 88 // at the i32 element, because it is the last element at that offset. This is 89 // the right one to return, because anything after it will have a higher 90 // offset, implying that this element is non-empty. 91 return SI-&MemberOffsets[0]; 92} 93 94//===----------------------------------------------------------------------===// 95// TargetAlignElem, TargetAlign support 96//===----------------------------------------------------------------------===// 97 98TargetAlignElem 99TargetAlignElem::get(AlignTypeEnum align_type, unsigned char abi_align, 100 unsigned char pref_align, uint32_t bit_width) { 101 assert(abi_align <= pref_align && "Preferred alignment worse than ABI!"); 102 TargetAlignElem retval; 103 retval.AlignType = align_type; 104 retval.ABIAlign = abi_align; 105 retval.PrefAlign = pref_align; 106 retval.TypeBitWidth = bit_width; 107 return retval; 108} 109 110bool 111TargetAlignElem::operator==(const TargetAlignElem &rhs) const { 112 return (AlignType == rhs.AlignType 113 && ABIAlign == rhs.ABIAlign 114 && PrefAlign == rhs.PrefAlign 115 && TypeBitWidth == rhs.TypeBitWidth); 116} 117 118std::ostream & 119TargetAlignElem::dump(std::ostream &os) const { 120 return os << AlignType 121 << TypeBitWidth 122 << ":" << (int) (ABIAlign * 8) 123 << ":" << (int) (PrefAlign * 8); 124} 125 126const TargetAlignElem TargetData::InvalidAlignmentElem = 127 TargetAlignElem::get((AlignTypeEnum) -1, 0, 0, 0); 128 129//===----------------------------------------------------------------------===// 130// TargetData Class Implementation 131//===----------------------------------------------------------------------===// 132 133/*! 134 A TargetDescription string consists of a sequence of hyphen-delimited 135 specifiers for target endianness, pointer size and alignments, and various 136 primitive type sizes and alignments. A typical string looks something like: 137 <br><br> 138 "E-p:32:32:32-i1:8:8-i8:8:8-i32:32:32-i64:32:64-f32:32:32-f64:32:64" 139 <br><br> 140 (note: this string is not fully specified and is only an example.) 141 \p 142 Alignments come in two flavors: ABI and preferred. ABI alignment (abi_align, 143 below) dictates how a type will be aligned within an aggregate and when used 144 as an argument. Preferred alignment (pref_align, below) determines a type's 145 alignment when emitted as a global. 146 \p 147 Specifier string details: 148 <br><br> 149 <i>[E|e]</i>: Endianness. "E" specifies a big-endian target data model, "e" 150 specifies a little-endian target data model. 151 <br><br> 152 <i>p:@verbatim<size>:<abi_align>:<pref_align>@endverbatim</i>: Pointer size, 153 ABI and preferred alignment. 154 <br><br> 155 <i>@verbatim<type><size>:<abi_align>:<pref_align>@endverbatim</i>: Numeric type 156 alignment. Type is 157 one of <i>i|f|v|a</i>, corresponding to integer, floating point, vector (aka 158 packed) or aggregate. Size indicates the size, e.g., 32 or 64 bits. 159 \p 160 The default string, fully specified is: 161 <br><br> 162 "E-p:64:64:64-a0:0:0-f32:32:32-f64:0:64" 163 "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:0:64" 164 "-v64:64:64-v128:128:128" 165 <br><br> 166 Note that in the case of aggregates, 0 is the default ABI and preferred 167 alignment. This is a special case, where the aggregate's computed worst-case 168 alignment will be used. 169 */ 170void TargetData::init(const std::string &TargetDescription) { 171 std::string temp = TargetDescription; 172 173 LittleEndian = false; 174 PointerMemSize = 8; 175 PointerABIAlign = 8; 176 PointerPrefAlign = PointerABIAlign; 177 178 // Default alignments 179 setAlignment(INTEGER_ALIGN, 1, 1, 1); // Bool 180 setAlignment(INTEGER_ALIGN, 1, 1, 8); // Byte 181 setAlignment(INTEGER_ALIGN, 2, 2, 16); // short 182 setAlignment(INTEGER_ALIGN, 4, 4, 32); // int 183 setAlignment(INTEGER_ALIGN, 4, 8, 64); // long 184 setAlignment(FLOAT_ALIGN, 4, 4, 32); // float 185 setAlignment(FLOAT_ALIGN, 8, 8, 64); // double 186 setAlignment(VECTOR_ALIGN, 8, 8, 64); // v2i32 187 setAlignment(VECTOR_ALIGN, 16, 16, 128); // v16i8, v8i16, v4i32, ... 188 setAlignment(AGGREGATE_ALIGN, 0, 8, 0); // struct, union, class, ... 189 190 while (!temp.empty()) { 191 std::string token = getToken(temp, "-"); 192 std::string arg0 = getToken(token, ":"); 193 const char *p = arg0.c_str(); 194 switch(*p) { 195 case 'E': 196 LittleEndian = false; 197 break; 198 case 'e': 199 LittleEndian = true; 200 break; 201 case 'p': 202 PointerMemSize = atoi(getToken(token,":").c_str()) / 8; 203 PointerABIAlign = atoi(getToken(token,":").c_str()) / 8; 204 PointerPrefAlign = atoi(getToken(token,":").c_str()) / 8; 205 if (PointerPrefAlign == 0) 206 PointerPrefAlign = PointerABIAlign; 207 break; 208 case 'i': 209 case 'v': 210 case 'f': 211 case 'a': 212 case 's': { 213 AlignTypeEnum align_type = STACK_ALIGN; // Dummy init, silence warning 214 switch(*p) { 215 case 'i': align_type = INTEGER_ALIGN; break; 216 case 'v': align_type = VECTOR_ALIGN; break; 217 case 'f': align_type = FLOAT_ALIGN; break; 218 case 'a': align_type = AGGREGATE_ALIGN; break; 219 case 's': align_type = STACK_ALIGN; break; 220 } 221 uint32_t size = (uint32_t) atoi(++p); 222 unsigned char abi_align = atoi(getToken(token, ":").c_str()) / 8; 223 unsigned char pref_align = atoi(getToken(token, ":").c_str()) / 8; 224 if (pref_align == 0) 225 pref_align = abi_align; 226 setAlignment(align_type, abi_align, pref_align, size); 227 break; 228 } 229 default: 230 break; 231 } 232 } 233} 234 235TargetData::TargetData(const Module *M) 236 : ImmutablePass(&ID) { 237 init(M->getDataLayout()); 238} 239 240void 241TargetData::setAlignment(AlignTypeEnum align_type, unsigned char abi_align, 242 unsigned char pref_align, uint32_t bit_width) { 243 assert(abi_align <= pref_align && "Preferred alignment worse than ABI!"); 244 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) { 245 if (Alignments[i].AlignType == align_type && 246 Alignments[i].TypeBitWidth == bit_width) { 247 // Update the abi, preferred alignments. 248 Alignments[i].ABIAlign = abi_align; 249 Alignments[i].PrefAlign = pref_align; 250 return; 251 } 252 } 253 254 Alignments.push_back(TargetAlignElem::get(align_type, abi_align, 255 pref_align, bit_width)); 256} 257 258/// getAlignmentInfo - Return the alignment (either ABI if ABIInfo = true or 259/// preferred if ABIInfo = false) the target wants for the specified datatype. 260unsigned TargetData::getAlignmentInfo(AlignTypeEnum AlignType, 261 uint32_t BitWidth, bool ABIInfo, 262 const Type *Ty) const { 263 // Check to see if we have an exact match and remember the best match we see. 264 int BestMatchIdx = -1; 265 int LargestInt = -1; 266 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) { 267 if (Alignments[i].AlignType == AlignType && 268 Alignments[i].TypeBitWidth == BitWidth) 269 return ABIInfo ? Alignments[i].ABIAlign : Alignments[i].PrefAlign; 270 271 // The best match so far depends on what we're looking for. 272 if (AlignType == VECTOR_ALIGN && Alignments[i].AlignType == VECTOR_ALIGN) { 273 // If this is a specification for a smaller vector type, we will fall back 274 // to it. This happens because <128 x double> can be implemented in terms 275 // of 64 <2 x double>. 276 if (Alignments[i].TypeBitWidth < BitWidth) { 277 // Verify that we pick the biggest of the fallbacks. 278 if (BestMatchIdx == -1 || 279 Alignments[BestMatchIdx].TypeBitWidth < Alignments[i].TypeBitWidth) 280 BestMatchIdx = i; 281 } 282 } else if (AlignType == INTEGER_ALIGN && 283 Alignments[i].AlignType == INTEGER_ALIGN) { 284 // The "best match" for integers is the smallest size that is larger than 285 // the BitWidth requested. 286 if (Alignments[i].TypeBitWidth > BitWidth && (BestMatchIdx == -1 || 287 Alignments[i].TypeBitWidth < Alignments[BestMatchIdx].TypeBitWidth)) 288 BestMatchIdx = i; 289 // However, if there isn't one that's larger, then we must use the 290 // largest one we have (see below) 291 if (LargestInt == -1 || 292 Alignments[i].TypeBitWidth > Alignments[LargestInt].TypeBitWidth) 293 LargestInt = i; 294 } 295 } 296 297 // Okay, we didn't find an exact solution. Fall back here depending on what 298 // is being looked for. 299 if (BestMatchIdx == -1) { 300 // If we didn't find an integer alignment, fall back on most conservative. 301 if (AlignType == INTEGER_ALIGN) { 302 BestMatchIdx = LargestInt; 303 } else { 304 assert(AlignType == VECTOR_ALIGN && "Unknown alignment type!"); 305 306 // If we didn't find a vector size that is smaller or equal to this type, 307 // then we will end up scalarizing this to its element type. Just return 308 // the alignment of the element. 309 return getAlignment(cast<VectorType>(Ty)->getElementType(), ABIInfo); 310 } 311 } 312 313 // Since we got a "best match" index, just return it. 314 return ABIInfo ? Alignments[BestMatchIdx].ABIAlign 315 : Alignments[BestMatchIdx].PrefAlign; 316} 317 318namespace { 319 320/// LayoutInfo - The lazy cache of structure layout information maintained by 321/// TargetData. Note that the struct types must have been free'd before 322/// llvm_shutdown is called (and thus this is deallocated) because all the 323/// targets with cached elements should have been destroyed. 324/// 325typedef std::pair<const TargetData*,const StructType*> LayoutKey; 326 327struct DenseMapLayoutKeyInfo { 328 static inline LayoutKey getEmptyKey() { return LayoutKey(0, 0); } 329 static inline LayoutKey getTombstoneKey() { 330 return LayoutKey((TargetData*)(intptr_t)-1, 0); 331 } 332 static unsigned getHashValue(const LayoutKey &Val) { 333 return DenseMapInfo<void*>::getHashValue(Val.first) ^ 334 DenseMapInfo<void*>::getHashValue(Val.second); 335 } 336 static bool isEqual(const LayoutKey &LHS, const LayoutKey &RHS) { 337 return LHS == RHS; 338 } 339 340 static bool isPod() { return true; } 341}; 342 343typedef DenseMap<LayoutKey, StructLayout*, DenseMapLayoutKeyInfo> LayoutInfoTy; 344 345} 346 347static ManagedStatic<LayoutInfoTy> LayoutInfo; 348 349TargetData::~TargetData() { 350 if (!LayoutInfo.isConstructed()) 351 return; 352 353 // Remove any layouts for this TD. 354 LayoutInfoTy &TheMap = *LayoutInfo; 355 for (LayoutInfoTy::iterator I = TheMap.begin(), E = TheMap.end(); I != E; ) { 356 if (I->first.first == this) { 357 I->second->~StructLayout(); 358 free(I->second); 359 TheMap.erase(I++); 360 } else { 361 ++I; 362 } 363 } 364} 365 366const StructLayout *TargetData::getStructLayout(const StructType *Ty) const { 367 LayoutInfoTy &TheMap = *LayoutInfo; 368 369 StructLayout *&SL = TheMap[LayoutKey(this, Ty)]; 370 if (SL) return SL; 371 372 // Otherwise, create the struct layout. Because it is variable length, we 373 // malloc it, then use placement new. 374 int NumElts = Ty->getNumElements(); 375 StructLayout *L = 376 (StructLayout *)malloc(sizeof(StructLayout)+(NumElts-1)*sizeof(uint64_t)); 377 378 // Set SL before calling StructLayout's ctor. The ctor could cause other 379 // entries to be added to TheMap, invalidating our reference. 380 SL = L; 381 382 new (L) StructLayout(Ty, *this); 383 return L; 384} 385 386/// InvalidateStructLayoutInfo - TargetData speculatively caches StructLayout 387/// objects. If a TargetData object is alive when types are being refined and 388/// removed, this method must be called whenever a StructType is removed to 389/// avoid a dangling pointer in this cache. 390void TargetData::InvalidateStructLayoutInfo(const StructType *Ty) const { 391 if (!LayoutInfo.isConstructed()) return; // No cache. 392 393 LayoutInfoTy::iterator I = LayoutInfo->find(LayoutKey(this, Ty)); 394 if (I == LayoutInfo->end()) return; 395 396 I->second->~StructLayout(); 397 free(I->second); 398 LayoutInfo->erase(I); 399} 400 401 402std::string TargetData::getStringRepresentation() const { 403 std::string repr; 404 repr.append(LittleEndian ? "e" : "E"); 405 repr.append("-p:").append(itostr((int64_t) (PointerMemSize * 8))). 406 append(":").append(itostr((int64_t) (PointerABIAlign * 8))). 407 append(":").append(itostr((int64_t) (PointerPrefAlign * 8))); 408 for (align_const_iterator I = Alignments.begin(); 409 I != Alignments.end(); 410 ++I) { 411 repr.append("-").append(1, (char) I->AlignType). 412 append(utostr((int64_t) I->TypeBitWidth)). 413 append(":").append(utostr((uint64_t) (I->ABIAlign * 8))). 414 append(":").append(utostr((uint64_t) (I->PrefAlign * 8))); 415 } 416 return repr; 417} 418 419 420uint64_t TargetData::getTypeSizeInBits(const Type *Ty) const { 421 assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!"); 422 switch (Ty->getTypeID()) { 423 case Type::LabelTyID: 424 case Type::PointerTyID: 425 return getPointerSizeInBits(); 426 case Type::ArrayTyID: { 427 const ArrayType *ATy = cast<ArrayType>(Ty); 428 return getABITypeSizeInBits(ATy->getElementType())*ATy->getNumElements(); 429 } 430 case Type::StructTyID: 431 // Get the layout annotation... which is lazily created on demand. 432 return getStructLayout(cast<StructType>(Ty))->getSizeInBits(); 433 case Type::IntegerTyID: 434 return cast<IntegerType>(Ty)->getBitWidth(); 435 case Type::VoidTyID: 436 return 8; 437 case Type::FloatTyID: 438 return 32; 439 case Type::DoubleTyID: 440 return 64; 441 case Type::PPC_FP128TyID: 442 case Type::FP128TyID: 443 return 128; 444 // In memory objects this is always aligned to a higher boundary, but 445 // only 80 bits contain information. 446 case Type::X86_FP80TyID: 447 return 80; 448 case Type::VectorTyID: 449 return cast<VectorType>(Ty)->getBitWidth(); 450 default: 451 assert(0 && "TargetData::getTypeSizeInBits(): Unsupported type"); 452 break; 453 } 454 return 0; 455} 456 457/*! 458 \param abi_or_pref Flag that determines which alignment is returned. true 459 returns the ABI alignment, false returns the preferred alignment. 460 \param Ty The underlying type for which alignment is determined. 461 462 Get the ABI (\a abi_or_pref == true) or preferred alignment (\a abi_or_pref 463 == false) for the requested type \a Ty. 464 */ 465unsigned char TargetData::getAlignment(const Type *Ty, bool abi_or_pref) const { 466 int AlignType = -1; 467 468 assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!"); 469 switch (Ty->getTypeID()) { 470 // Early escape for the non-numeric types. 471 case Type::LabelTyID: 472 case Type::PointerTyID: 473 return (abi_or_pref 474 ? getPointerABIAlignment() 475 : getPointerPrefAlignment()); 476 case Type::ArrayTyID: 477 return getAlignment(cast<ArrayType>(Ty)->getElementType(), abi_or_pref); 478 479 case Type::StructTyID: { 480 // Packed structure types always have an ABI alignment of one. 481 if (cast<StructType>(Ty)->isPacked() && abi_or_pref) 482 return 1; 483 484 // Get the layout annotation... which is lazily created on demand. 485 const StructLayout *Layout = getStructLayout(cast<StructType>(Ty)); 486 unsigned Align = getAlignmentInfo(AGGREGATE_ALIGN, 0, abi_or_pref, Ty); 487 return std::max(Align, (unsigned)Layout->getAlignment()); 488 } 489 case Type::IntegerTyID: 490 case Type::VoidTyID: 491 AlignType = INTEGER_ALIGN; 492 break; 493 case Type::FloatTyID: 494 case Type::DoubleTyID: 495 // PPC_FP128TyID and FP128TyID have different data contents, but the 496 // same size and alignment, so they look the same here. 497 case Type::PPC_FP128TyID: 498 case Type::FP128TyID: 499 case Type::X86_FP80TyID: 500 AlignType = FLOAT_ALIGN; 501 break; 502 case Type::VectorTyID: 503 AlignType = VECTOR_ALIGN; 504 break; 505 default: 506 assert(0 && "Bad type for getAlignment!!!"); 507 break; 508 } 509 510 return getAlignmentInfo((AlignTypeEnum)AlignType, getTypeSizeInBits(Ty), 511 abi_or_pref, Ty); 512} 513 514unsigned char TargetData::getABITypeAlignment(const Type *Ty) const { 515 return getAlignment(Ty, true); 516} 517 518unsigned char TargetData::getCallFrameTypeAlignment(const Type *Ty) const { 519 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) 520 if (Alignments[i].AlignType == STACK_ALIGN) 521 return Alignments[i].ABIAlign; 522 523 return getABITypeAlignment(Ty); 524} 525 526unsigned char TargetData::getPrefTypeAlignment(const Type *Ty) const { 527 return getAlignment(Ty, false); 528} 529 530unsigned char TargetData::getPreferredTypeAlignmentShift(const Type *Ty) const { 531 unsigned Align = (unsigned) getPrefTypeAlignment(Ty); 532 assert(!(Align & (Align-1)) && "Alignment is not a power of two!"); 533 return Log2_32(Align); 534} 535 536/// getIntPtrType - Return an unsigned integer type that is the same size or 537/// greater to the host pointer size. 538const Type *TargetData::getIntPtrType() const { 539 return IntegerType::get(getPointerSizeInBits()); 540} 541 542 543uint64_t TargetData::getIndexedOffset(const Type *ptrTy, Value* const* Indices, 544 unsigned NumIndices) const { 545 const Type *Ty = ptrTy; 546 assert(isa<PointerType>(Ty) && "Illegal argument for getIndexedOffset()"); 547 uint64_t Result = 0; 548 549 generic_gep_type_iterator<Value* const*> 550 TI = gep_type_begin(ptrTy, Indices, Indices+NumIndices); 551 for (unsigned CurIDX = 0; CurIDX != NumIndices; ++CurIDX, ++TI) { 552 if (const StructType *STy = dyn_cast<StructType>(*TI)) { 553 assert(Indices[CurIDX]->getType() == Type::Int32Ty && 554 "Illegal struct idx"); 555 unsigned FieldNo = cast<ConstantInt>(Indices[CurIDX])->getZExtValue(); 556 557 // Get structure layout information... 558 const StructLayout *Layout = getStructLayout(STy); 559 560 // Add in the offset, as calculated by the structure layout info... 561 Result += Layout->getElementOffset(FieldNo); 562 563 // Update Ty to refer to current element 564 Ty = STy->getElementType(FieldNo); 565 } else { 566 // Update Ty to refer to current element 567 Ty = cast<SequentialType>(Ty)->getElementType(); 568 569 // Get the array index and the size of each array element. 570 int64_t arrayIdx = cast<ConstantInt>(Indices[CurIDX])->getSExtValue(); 571 Result += arrayIdx * (int64_t)getABITypeSize(Ty); 572 } 573 } 574 575 return Result; 576} 577 578/// getPreferredAlignment - Return the preferred alignment of the specified 579/// global. This includes an explicitly requested alignment (if the global 580/// has one). 581unsigned TargetData::getPreferredAlignment(const GlobalVariable *GV) const { 582 const Type *ElemType = GV->getType()->getElementType(); 583 unsigned Alignment = getPrefTypeAlignment(ElemType); 584 if (GV->getAlignment() > Alignment) 585 Alignment = GV->getAlignment(); 586 587 if (GV->hasInitializer()) { 588 if (Alignment < 16) { 589 // If the global is not external, see if it is large. If so, give it a 590 // larger alignment. 591 if (getTypeSizeInBits(ElemType) > 128) 592 Alignment = 16; // 16-byte alignment. 593 } 594 } 595 return Alignment; 596} 597 598/// getPreferredAlignmentLog - Return the preferred alignment of the 599/// specified global, returned in log form. This includes an explicitly 600/// requested alignment (if the global has one). 601unsigned TargetData::getPreferredAlignmentLog(const GlobalVariable *GV) const { 602 return Log2_32(getPreferredAlignment(GV)); 603} 604