DataLayout.cpp revision f578c89dc6ca3e79667c2aa9d0ac4fe409da7773
1//===-- DataLayout.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 layout 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/IR/DataLayout.h" 20#include "llvm/ADT/DenseMap.h" 21#include "llvm/IR/Constants.h" 22#include "llvm/IR/DerivedTypes.h" 23#include "llvm/IR/Module.h" 24#include "llvm/Support/ErrorHandling.h" 25#include "llvm/Support/GetElementPtrTypeIterator.h" 26#include "llvm/Support/ManagedStatic.h" 27#include "llvm/Support/MathExtras.h" 28#include "llvm/Support/Mutex.h" 29#include "llvm/Support/raw_ostream.h" 30#include <algorithm> 31#include <cstdlib> 32using namespace llvm; 33 34// Handle the Pass registration stuff necessary to use DataLayout's. 35 36// Register the default SparcV9 implementation... 37INITIALIZE_PASS(DataLayout, "datalayout", "Data Layout", false, true) 38char DataLayout::ID = 0; 39 40//===----------------------------------------------------------------------===// 41// Support for StructLayout 42//===----------------------------------------------------------------------===// 43 44StructLayout::StructLayout(StructType *ST, const DataLayout &TD) { 45 assert(!ST->isOpaque() && "Cannot get layout of opaque structs"); 46 StructAlignment = 0; 47 StructSize = 0; 48 NumElements = ST->getNumElements(); 49 50 // Loop over each of the elements, placing them in memory. 51 for (unsigned i = 0, e = NumElements; i != e; ++i) { 52 Type *Ty = ST->getElementType(i); 53 unsigned TyAlign = ST->isPacked() ? 1 : TD.getABITypeAlignment(Ty); 54 55 // Add padding if necessary to align the data element properly. 56 if ((StructSize & (TyAlign-1)) != 0) 57 StructSize = DataLayout::RoundUpAlignment(StructSize, TyAlign); 58 59 // Keep track of maximum alignment constraint. 60 StructAlignment = std::max(TyAlign, StructAlignment); 61 62 MemberOffsets[i] = StructSize; 63 StructSize += TD.getTypeAllocSize(Ty); // Consume space for this data item 64 } 65 66 // Empty structures have alignment of 1 byte. 67 if (StructAlignment == 0) StructAlignment = 1; 68 69 // 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. 71 if ((StructSize & (StructAlignment-1)) != 0) 72 StructSize = DataLayout::RoundUpAlignment(StructSize, StructAlignment); 73} 74 75 76/// getElementContainingOffset - Given a valid offset into the structure, 77/// return the structure index that contains it. 78unsigned StructLayout::getElementContainingOffset(uint64_t Offset) const { 79 const uint64_t *SI = 80 std::upper_bound(&MemberOffsets[0], &MemberOffsets[NumElements], Offset); 81 assert(SI != &MemberOffsets[0] && "Offset not in structure type!"); 82 --SI; 83 assert(*SI <= Offset && "upper_bound didn't work"); 84 assert((SI == &MemberOffsets[0] || *(SI-1) <= Offset) && 85 (SI+1 == &MemberOffsets[NumElements] || *(SI+1) > Offset) && 86 "Upper bound didn't work!"); 87 88 // 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. 93 return SI-&MemberOffsets[0]; 94} 95 96//===----------------------------------------------------------------------===// 97// LayoutAlignElem, LayoutAlign support 98//===----------------------------------------------------------------------===// 99 100LayoutAlignElem 101LayoutAlignElem::get(AlignTypeEnum align_type, unsigned abi_align, 102 unsigned pref_align, uint32_t bit_width) { 103 assert(abi_align <= pref_align && "Preferred alignment worse than ABI!"); 104 LayoutAlignElem 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 113LayoutAlignElem::operator==(const LayoutAlignElem &rhs) const { 114 return (AlignType == rhs.AlignType 115 && ABIAlign == rhs.ABIAlign 116 && PrefAlign == rhs.PrefAlign 117 && TypeBitWidth == rhs.TypeBitWidth); 118} 119 120const LayoutAlignElem 121DataLayout::InvalidAlignmentElem = LayoutAlignElem::get(INVALID_ALIGN, 0, 0, 0); 122 123//===----------------------------------------------------------------------===// 124// PointerAlignElem, PointerAlign support 125//===----------------------------------------------------------------------===// 126 127PointerAlignElem 128PointerAlignElem::get(uint32_t addr_space, unsigned abi_align, 129 unsigned pref_align, uint32_t bit_width) { 130 assert(abi_align <= pref_align && "Preferred alignment worse than ABI!"); 131 PointerAlignElem retval; 132 retval.AddressSpace = addr_space; 133 retval.ABIAlign = abi_align; 134 retval.PrefAlign = pref_align; 135 retval.TypeBitWidth = bit_width; 136 return retval; 137} 138 139bool 140PointerAlignElem::operator==(const PointerAlignElem &rhs) const { 141 return (ABIAlign == rhs.ABIAlign 142 && AddressSpace == rhs.AddressSpace 143 && PrefAlign == rhs.PrefAlign 144 && TypeBitWidth == rhs.TypeBitWidth); 145} 146 147const PointerAlignElem 148DataLayout::InvalidPointerElem = PointerAlignElem::get(~0U, 0U, 0U, 0U); 149 150//===----------------------------------------------------------------------===// 151// DataLayout Class Implementation 152//===----------------------------------------------------------------------===// 153 154void DataLayout::init(StringRef Desc) { 155 initializeDataLayoutPass(*PassRegistry::getPassRegistry()); 156 157 LayoutMap = 0; 158 LittleEndian = false; 159 StackNaturalAlign = 0; 160 161 // Default alignments 162 setAlignment(INTEGER_ALIGN, 1, 1, 1); // i1 163 setAlignment(INTEGER_ALIGN, 1, 1, 8); // i8 164 setAlignment(INTEGER_ALIGN, 2, 2, 16); // i16 165 setAlignment(INTEGER_ALIGN, 4, 4, 32); // i32 166 setAlignment(INTEGER_ALIGN, 4, 8, 64); // i64 167 setAlignment(FLOAT_ALIGN, 2, 2, 16); // half 168 setAlignment(FLOAT_ALIGN, 4, 4, 32); // float 169 setAlignment(FLOAT_ALIGN, 8, 8, 64); // double 170 setAlignment(FLOAT_ALIGN, 16, 16, 128); // ppcf128, quad, ... 171 setAlignment(VECTOR_ALIGN, 8, 8, 64); // v2i32, v1i64, ... 172 setAlignment(VECTOR_ALIGN, 16, 16, 128); // v16i8, v8i16, v4i32, ... 173 setAlignment(AGGREGATE_ALIGN, 0, 8, 0); // struct 174 setPointerAlignment(0, 8, 8, 8); 175 176 parseSpecifier(Desc); 177} 178 179/// Checked version of split, to ensure mandatory subparts. 180static std::pair<StringRef, StringRef> split(StringRef Str, char Separator) { 181 assert(!Str.empty() && "parse error, string can't be empty here"); 182 std::pair<StringRef, StringRef> Split = Str.split(Separator); 183 assert((!Split.second.empty() || Split.first == Str) && 184 "a trailing separator is not allowed"); 185 return Split; 186} 187 188/// Get an unsinged integer, including error checks. 189static unsigned getInt(StringRef R) { 190 unsigned Result; 191 bool error = R.getAsInteger(10, Result); (void)error; 192 assert(!error && "not a number, or does not fit in an unsigned int"); 193 return Result; 194} 195 196/// Convert bits into bytes. Assert if not a byte width multiple. 197static unsigned inBytes(unsigned Bits) { 198 assert(Bits % 8 == 0 && "number of bits must be a byte width multiple"); 199 return Bits / 8; 200} 201 202void DataLayout::parseSpecifier(StringRef Desc) { 203 204 while (!Desc.empty()) { 205 206 // Split at '-'. 207 std::pair<StringRef, StringRef> Split = split(Desc, '-'); 208 Desc = Split.second; 209 210 // Split at ':'. 211 Split = split(Split.first, ':'); 212 213 // Aliases used below. 214 StringRef &Tok = Split.first; // Current token. 215 StringRef &Rest = Split.second; // The rest of the string. 216 217 char Specifier = Tok.front(); 218 Tok = Tok.substr(1); 219 220 switch (Specifier) { 221 case 'E': 222 LittleEndian = false; 223 break; 224 case 'e': 225 LittleEndian = true; 226 break; 227 case 'p': { 228 // Address space. 229 unsigned AddrSpace = Tok.empty() ? 0 : getInt(Tok); 230 assert(AddrSpace < 1 << 24 && 231 "Invalid address space, must be a 24bit integer"); 232 233 // Size. 234 Split = split(Rest, ':'); 235 unsigned PointerMemSize = inBytes(getInt(Tok)); 236 237 // ABI alignment. 238 Split = split(Rest, ':'); 239 unsigned PointerABIAlign = inBytes(getInt(Tok)); 240 241 // Preferred alignment. 242 unsigned PointerPrefAlign = PointerABIAlign; 243 if (!Rest.empty()) { 244 Split = split(Rest, ':'); 245 PointerPrefAlign = inBytes(getInt(Tok)); 246 } 247 248 setPointerAlignment(AddrSpace, PointerABIAlign, PointerPrefAlign, 249 PointerMemSize); 250 break; 251 } 252 case 'i': 253 case 'v': 254 case 'f': 255 case 'a': 256 case 's': { 257 AlignTypeEnum AlignType; 258 switch (Specifier) { 259 default: 260 case 'i': AlignType = INTEGER_ALIGN; break; 261 case 'v': AlignType = VECTOR_ALIGN; break; 262 case 'f': AlignType = FLOAT_ALIGN; break; 263 case 'a': AlignType = AGGREGATE_ALIGN; break; 264 case 's': AlignType = STACK_ALIGN; break; 265 } 266 267 // Bit size. 268 unsigned Size = Tok.empty() ? 0 : getInt(Tok); 269 270 // ABI alignment. 271 Split = split(Rest, ':'); 272 unsigned ABIAlign = inBytes(getInt(Tok)); 273 274 // Preferred alignment. 275 unsigned PrefAlign = ABIAlign; 276 if (!Rest.empty()) { 277 Split = split(Rest, ':'); 278 PrefAlign = inBytes(getInt(Tok)); 279 } 280 281 setAlignment(AlignType, ABIAlign, PrefAlign, Size); 282 283 break; 284 } 285 case 'n': // Native integer types. 286 for (;;) { 287 unsigned Width = getInt(Tok); 288 assert(Width != 0 && "width must be non-zero"); 289 LegalIntWidths.push_back(Width); 290 if (Rest.empty()) 291 break; 292 Split = split(Rest, ':'); 293 } 294 break; 295 case 'S': { // Stack natural alignment. 296 StackNaturalAlign = inBytes(getInt(Tok)); 297 break; 298 } 299 default: 300 llvm_unreachable("Unknown specifier in datalayout string"); 301 break; 302 } 303 } 304} 305 306/// Default ctor. 307/// 308/// @note This has to exist, because this is a pass, but it should never be 309/// used. 310DataLayout::DataLayout() : ImmutablePass(ID) { 311 report_fatal_error("Bad DataLayout ctor used. " 312 "Tool did not specify a DataLayout to use?"); 313} 314 315DataLayout::DataLayout(const Module *M) 316 : ImmutablePass(ID) { 317 init(M->getDataLayout()); 318} 319 320void 321DataLayout::setAlignment(AlignTypeEnum align_type, unsigned abi_align, 322 unsigned pref_align, uint32_t bit_width) { 323 assert(abi_align <= pref_align && "Preferred alignment worse than ABI!"); 324 assert(pref_align < (1 << 16) && "Alignment doesn't fit in bitfield"); 325 assert(bit_width < (1 << 24) && "Bit width doesn't fit in bitfield"); 326 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) { 327 if (Alignments[i].AlignType == (unsigned)align_type && 328 Alignments[i].TypeBitWidth == bit_width) { 329 // Update the abi, preferred alignments. 330 Alignments[i].ABIAlign = abi_align; 331 Alignments[i].PrefAlign = pref_align; 332 return; 333 } 334 } 335 336 Alignments.push_back(LayoutAlignElem::get(align_type, abi_align, 337 pref_align, bit_width)); 338} 339 340void 341DataLayout::setPointerAlignment(uint32_t addr_space, unsigned abi_align, 342 unsigned pref_align, uint32_t bit_width) { 343 assert(abi_align <= pref_align && "Preferred alignment worse than ABI!"); 344 DenseMap<unsigned,PointerAlignElem>::iterator val = Pointers.find(addr_space); 345 if (val == Pointers.end()) { 346 Pointers[addr_space] = PointerAlignElem::get(addr_space, 347 abi_align, pref_align, bit_width); 348 } else { 349 val->second.ABIAlign = abi_align; 350 val->second.PrefAlign = pref_align; 351 val->second.TypeBitWidth = bit_width; 352 } 353} 354 355/// getAlignmentInfo - Return the alignment (either ABI if ABIInfo = true or 356/// preferred if ABIInfo = false) the layout wants for the specified datatype. 357unsigned DataLayout::getAlignmentInfo(AlignTypeEnum AlignType, 358 uint32_t BitWidth, bool ABIInfo, 359 Type *Ty) const { 360 // Check to see if we have an exact match and remember the best match we see. 361 int BestMatchIdx = -1; 362 int LargestInt = -1; 363 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) { 364 if (Alignments[i].AlignType == (unsigned)AlignType && 365 Alignments[i].TypeBitWidth == BitWidth) 366 return ABIInfo ? Alignments[i].ABIAlign : Alignments[i].PrefAlign; 367 368 // The best match so far depends on what we're looking for. 369 if (AlignType == INTEGER_ALIGN && 370 Alignments[i].AlignType == INTEGER_ALIGN) { 371 // The "best match" for integers is the smallest size that is larger than 372 // the BitWidth requested. 373 if (Alignments[i].TypeBitWidth > BitWidth && (BestMatchIdx == -1 || 374 Alignments[i].TypeBitWidth < Alignments[BestMatchIdx].TypeBitWidth)) 375 BestMatchIdx = i; 376 // However, if there isn't one that's larger, then we must use the 377 // largest one we have (see below) 378 if (LargestInt == -1 || 379 Alignments[i].TypeBitWidth > Alignments[LargestInt].TypeBitWidth) 380 LargestInt = i; 381 } 382 } 383 384 // Okay, we didn't find an exact solution. Fall back here depending on what 385 // is being looked for. 386 if (BestMatchIdx == -1) { 387 // If we didn't find an integer alignment, fall back on most conservative. 388 if (AlignType == INTEGER_ALIGN) { 389 BestMatchIdx = LargestInt; 390 } else { 391 assert(AlignType == VECTOR_ALIGN && "Unknown alignment type!"); 392 393 // By default, use natural alignment for vector types. This is consistent 394 // with what clang and llvm-gcc do. 395 unsigned Align = getTypeAllocSize(cast<VectorType>(Ty)->getElementType()); 396 Align *= cast<VectorType>(Ty)->getNumElements(); 397 // If the alignment is not a power of 2, round up to the next power of 2. 398 // This happens for non-power-of-2 length vectors. 399 if (Align & (Align-1)) 400 Align = NextPowerOf2(Align); 401 return Align; 402 } 403 } 404 405 // Since we got a "best match" index, just return it. 406 return ABIInfo ? Alignments[BestMatchIdx].ABIAlign 407 : Alignments[BestMatchIdx].PrefAlign; 408} 409 410namespace { 411 412class StructLayoutMap { 413 typedef DenseMap<StructType*, StructLayout*> LayoutInfoTy; 414 LayoutInfoTy LayoutInfo; 415 416public: 417 virtual ~StructLayoutMap() { 418 // Remove any layouts. 419 for (LayoutInfoTy::iterator I = LayoutInfo.begin(), E = LayoutInfo.end(); 420 I != E; ++I) { 421 StructLayout *Value = I->second; 422 Value->~StructLayout(); 423 free(Value); 424 } 425 } 426 427 StructLayout *&operator[](StructType *STy) { 428 return LayoutInfo[STy]; 429 } 430 431 // for debugging... 432 virtual void dump() const {} 433}; 434 435} // end anonymous namespace 436 437DataLayout::~DataLayout() { 438 delete static_cast<StructLayoutMap*>(LayoutMap); 439} 440 441const StructLayout *DataLayout::getStructLayout(StructType *Ty) const { 442 if (!LayoutMap) 443 LayoutMap = new StructLayoutMap(); 444 445 StructLayoutMap *STM = static_cast<StructLayoutMap*>(LayoutMap); 446 StructLayout *&SL = (*STM)[Ty]; 447 if (SL) return SL; 448 449 // Otherwise, create the struct layout. Because it is variable length, we 450 // malloc it, then use placement new. 451 int NumElts = Ty->getNumElements(); 452 StructLayout *L = 453 (StructLayout *)malloc(sizeof(StructLayout)+(NumElts-1) * sizeof(uint64_t)); 454 455 // Set SL before calling StructLayout's ctor. The ctor could cause other 456 // entries to be added to TheMap, invalidating our reference. 457 SL = L; 458 459 new (L) StructLayout(Ty, *this); 460 461 return L; 462} 463 464std::string DataLayout::getStringRepresentation() const { 465 std::string Result; 466 raw_string_ostream OS(Result); 467 468 OS << (LittleEndian ? "e" : "E"); 469 SmallVector<unsigned, 8> addrSpaces; 470 // Lets get all of the known address spaces and sort them 471 // into increasing order so that we can emit the string 472 // in a cleaner format. 473 for (DenseMap<unsigned, PointerAlignElem>::const_iterator 474 pib = Pointers.begin(), pie = Pointers.end(); 475 pib != pie; ++pib) { 476 addrSpaces.push_back(pib->first); 477 } 478 std::sort(addrSpaces.begin(), addrSpaces.end()); 479 for (SmallVector<unsigned, 8>::iterator asb = addrSpaces.begin(), 480 ase = addrSpaces.end(); asb != ase; ++asb) { 481 const PointerAlignElem &PI = Pointers.find(*asb)->second; 482 OS << "-p"; 483 if (PI.AddressSpace) { 484 OS << PI.AddressSpace; 485 } 486 OS << ":" << PI.TypeBitWidth*8 << ':' << PI.ABIAlign*8 487 << ':' << PI.PrefAlign*8; 488 } 489 OS << "-S" << StackNaturalAlign*8; 490 491 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) { 492 const LayoutAlignElem &AI = Alignments[i]; 493 OS << '-' << (char)AI.AlignType << AI.TypeBitWidth << ':' 494 << AI.ABIAlign*8 << ':' << AI.PrefAlign*8; 495 } 496 497 if (!LegalIntWidths.empty()) { 498 OS << "-n" << (unsigned)LegalIntWidths[0]; 499 500 for (unsigned i = 1, e = LegalIntWidths.size(); i != e; ++i) 501 OS << ':' << (unsigned)LegalIntWidths[i]; 502 } 503 return OS.str(); 504} 505 506 507uint64_t DataLayout::getTypeSizeInBits(Type *Ty) const { 508 assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!"); 509 switch (Ty->getTypeID()) { 510 case Type::LabelTyID: 511 return getPointerSizeInBits(0); 512 case Type::PointerTyID: { 513 unsigned AS = dyn_cast<PointerType>(Ty)->getAddressSpace(); 514 return getPointerSizeInBits(AS); 515 } 516 case Type::ArrayTyID: { 517 ArrayType *ATy = cast<ArrayType>(Ty); 518 return getTypeAllocSizeInBits(ATy->getElementType())*ATy->getNumElements(); 519 } 520 case Type::StructTyID: 521 // Get the layout annotation... which is lazily created on demand. 522 return getStructLayout(cast<StructType>(Ty))->getSizeInBits(); 523 case Type::IntegerTyID: 524 return cast<IntegerType>(Ty)->getBitWidth(); 525 case Type::HalfTyID: 526 return 16; 527 case Type::FloatTyID: 528 return 32; 529 case Type::DoubleTyID: 530 case Type::X86_MMXTyID: 531 return 64; 532 case Type::PPC_FP128TyID: 533 case Type::FP128TyID: 534 return 128; 535 // In memory objects this is always aligned to a higher boundary, but 536 // only 80 bits contain information. 537 case Type::X86_FP80TyID: 538 return 80; 539 case Type::VectorTyID: { 540 VectorType *VTy = cast<VectorType>(Ty); 541 return VTy->getNumElements()*getTypeSizeInBits(VTy->getElementType()); 542 } 543 default: 544 llvm_unreachable("DataLayout::getTypeSizeInBits(): Unsupported type"); 545 } 546} 547 548/*! 549 \param abi_or_pref Flag that determines which alignment is returned. true 550 returns the ABI alignment, false returns the preferred alignment. 551 \param Ty The underlying type for which alignment is determined. 552 553 Get the ABI (\a abi_or_pref == true) or preferred alignment (\a abi_or_pref 554 == false) for the requested type \a Ty. 555 */ 556unsigned DataLayout::getAlignment(Type *Ty, bool abi_or_pref) const { 557 int AlignType = -1; 558 559 assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!"); 560 switch (Ty->getTypeID()) { 561 // Early escape for the non-numeric types. 562 case Type::LabelTyID: 563 return (abi_or_pref 564 ? getPointerABIAlignment(0) 565 : getPointerPrefAlignment(0)); 566 case Type::PointerTyID: { 567 unsigned AS = dyn_cast<PointerType>(Ty)->getAddressSpace(); 568 return (abi_or_pref 569 ? getPointerABIAlignment(AS) 570 : getPointerPrefAlignment(AS)); 571 } 572 case Type::ArrayTyID: 573 return getAlignment(cast<ArrayType>(Ty)->getElementType(), abi_or_pref); 574 575 case Type::StructTyID: { 576 // Packed structure types always have an ABI alignment of one. 577 if (cast<StructType>(Ty)->isPacked() && abi_or_pref) 578 return 1; 579 580 // Get the layout annotation... which is lazily created on demand. 581 const StructLayout *Layout = getStructLayout(cast<StructType>(Ty)); 582 unsigned Align = getAlignmentInfo(AGGREGATE_ALIGN, 0, abi_or_pref, Ty); 583 return std::max(Align, Layout->getAlignment()); 584 } 585 case Type::IntegerTyID: 586 AlignType = INTEGER_ALIGN; 587 break; 588 case Type::HalfTyID: 589 case Type::FloatTyID: 590 case Type::DoubleTyID: 591 // PPC_FP128TyID and FP128TyID have different data contents, but the 592 // same size and alignment, so they look the same here. 593 case Type::PPC_FP128TyID: 594 case Type::FP128TyID: 595 case Type::X86_FP80TyID: 596 AlignType = FLOAT_ALIGN; 597 break; 598 case Type::X86_MMXTyID: 599 case Type::VectorTyID: 600 AlignType = VECTOR_ALIGN; 601 break; 602 default: 603 llvm_unreachable("Bad type for getAlignment!!!"); 604 } 605 606 return getAlignmentInfo((AlignTypeEnum)AlignType, getTypeSizeInBits(Ty), 607 abi_or_pref, Ty); 608} 609 610unsigned DataLayout::getABITypeAlignment(Type *Ty) const { 611 return getAlignment(Ty, true); 612} 613 614/// getABIIntegerTypeAlignment - Return the minimum ABI-required alignment for 615/// an integer type of the specified bitwidth. 616unsigned DataLayout::getABIIntegerTypeAlignment(unsigned BitWidth) const { 617 return getAlignmentInfo(INTEGER_ALIGN, BitWidth, true, 0); 618} 619 620 621unsigned DataLayout::getCallFrameTypeAlignment(Type *Ty) const { 622 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) 623 if (Alignments[i].AlignType == STACK_ALIGN) 624 return Alignments[i].ABIAlign; 625 626 return getABITypeAlignment(Ty); 627} 628 629unsigned DataLayout::getPrefTypeAlignment(Type *Ty) const { 630 return getAlignment(Ty, false); 631} 632 633unsigned DataLayout::getPreferredTypeAlignmentShift(Type *Ty) const { 634 unsigned Align = getPrefTypeAlignment(Ty); 635 assert(!(Align & (Align-1)) && "Alignment is not a power of two!"); 636 return Log2_32(Align); 637} 638 639/// getIntPtrType - Return an integer type with size at least as big as that 640/// of a pointer in the given address space. 641IntegerType *DataLayout::getIntPtrType(LLVMContext &C, 642 unsigned AddressSpace) const { 643 return IntegerType::get(C, getPointerSizeInBits(AddressSpace)); 644} 645 646/// getIntPtrType - Return an integer (vector of integer) type with size at 647/// least as big as that of a pointer of the given pointer (vector of pointer) 648/// type. 649Type *DataLayout::getIntPtrType(Type *Ty) const { 650 assert(Ty->isPtrOrPtrVectorTy() && 651 "Expected a pointer or pointer vector type."); 652 unsigned NumBits = getTypeSizeInBits(Ty->getScalarType()); 653 IntegerType *IntTy = IntegerType::get(Ty->getContext(), NumBits); 654 if (VectorType *VecTy = dyn_cast<VectorType>(Ty)) 655 return VectorType::get(IntTy, VecTy->getNumElements()); 656 return IntTy; 657} 658 659uint64_t DataLayout::getIndexedOffset(Type *ptrTy, 660 ArrayRef<Value *> Indices) const { 661 Type *Ty = ptrTy; 662 assert(Ty->isPointerTy() && "Illegal argument for getIndexedOffset()"); 663 uint64_t Result = 0; 664 665 generic_gep_type_iterator<Value* const*> 666 TI = gep_type_begin(ptrTy, Indices); 667 for (unsigned CurIDX = 0, EndIDX = Indices.size(); CurIDX != EndIDX; 668 ++CurIDX, ++TI) { 669 if (StructType *STy = dyn_cast<StructType>(*TI)) { 670 assert(Indices[CurIDX]->getType() == 671 Type::getInt32Ty(ptrTy->getContext()) && 672 "Illegal struct idx"); 673 unsigned FieldNo = cast<ConstantInt>(Indices[CurIDX])->getZExtValue(); 674 675 // Get structure layout information... 676 const StructLayout *Layout = getStructLayout(STy); 677 678 // Add in the offset, as calculated by the structure layout info... 679 Result += Layout->getElementOffset(FieldNo); 680 681 // Update Ty to refer to current element 682 Ty = STy->getElementType(FieldNo); 683 } else { 684 // Update Ty to refer to current element 685 Ty = cast<SequentialType>(Ty)->getElementType(); 686 687 // Get the array index and the size of each array element. 688 if (int64_t arrayIdx = cast<ConstantInt>(Indices[CurIDX])->getSExtValue()) 689 Result += (uint64_t)arrayIdx * getTypeAllocSize(Ty); 690 } 691 } 692 693 return Result; 694} 695 696/// getPreferredAlignment - Return the preferred alignment of the specified 697/// global. This includes an explicitly requested alignment (if the global 698/// has one). 699unsigned DataLayout::getPreferredAlignment(const GlobalVariable *GV) const { 700 Type *ElemType = GV->getType()->getElementType(); 701 unsigned Alignment = getPrefTypeAlignment(ElemType); 702 unsigned GVAlignment = GV->getAlignment(); 703 if (GVAlignment >= Alignment) { 704 Alignment = GVAlignment; 705 } else if (GVAlignment != 0) { 706 Alignment = std::max(GVAlignment, getABITypeAlignment(ElemType)); 707 } 708 709 if (GV->hasInitializer() && GVAlignment == 0) { 710 if (Alignment < 16) { 711 // If the global is not external, see if it is large. If so, give it a 712 // larger alignment. 713 if (getTypeSizeInBits(ElemType) > 128) 714 Alignment = 16; // 16-byte alignment. 715 } 716 } 717 return Alignment; 718} 719 720/// getPreferredAlignmentLog - Return the preferred alignment of the 721/// specified global, returned in log form. This includes an explicitly 722/// requested alignment (if the global has one). 723unsigned DataLayout::getPreferredAlignmentLog(const GlobalVariable *GV) const { 724 return Log2_32(getPreferredAlignment(GV)); 725} 726