DataLayout.cpp revision 251662
133965Sjdp//===-- DataLayout.cpp - Data size & alignment routines --------------------==// 2218822Sdim// 377298Sobrien// The LLVM Compiler Infrastructure 433965Sjdp// 533965Sjdp// This file is distributed under the University of Illinois Open Source 633965Sjdp// License. See LICENSE.TXT for details. 733965Sjdp// 833965Sjdp//===----------------------------------------------------------------------===// 933965Sjdp// 1033965Sjdp// This file defines layout properties related to datatype size/offset/alignment 1133965Sjdp// information. 1233965Sjdp// 1333965Sjdp// This structure should be created once, filled in if the defaults are not 1433965Sjdp// correct and then passed around by const&. None of the members functions 1533965Sjdp// require modification to the object. 1633965Sjdp// 1733965Sjdp//===----------------------------------------------------------------------===// 1860484Sobrien 19218822Sdim#include "llvm/IR/DataLayout.h" 20218822Sdim#include "llvm/ADT/DenseMap.h" 2133965Sjdp#include "llvm/IR/Constants.h" 2233965Sjdp#include "llvm/IR/DerivedTypes.h" 2333965Sjdp#include "llvm/IR/Module.h" 2433965Sjdp#include "llvm/Support/ErrorHandling.h" 2560484Sobrien#include "llvm/Support/GetElementPtrTypeIterator.h" 2660484Sobrien#include "llvm/Support/ManagedStatic.h" 2760484Sobrien#include "llvm/Support/MathExtras.h" 2833965Sjdp#include "llvm/Support/Mutex.h" 2933965Sjdp#include "llvm/Support/raw_ostream.h" 3033965Sjdp#include <algorithm> 3160484Sobrien#include <cstdlib> 3260484Sobrienusing namespace llvm; 3333965Sjdp 3433965Sjdp// Handle the Pass registration stuff necessary to use DataLayout's. 3533965Sjdp 3633965Sjdp// Register the default SparcV9 implementation... 3733965SjdpINITIALIZE_PASS(DataLayout, "datalayout", "Data Layout", false, true) 3833965Sjdpchar DataLayout::ID = 0; 3933965Sjdp 4033965Sjdp//===----------------------------------------------------------------------===// 4133965Sjdp// Support for StructLayout 4233965Sjdp//===----------------------------------------------------------------------===// 4333965Sjdp 4433965SjdpStructLayout::StructLayout(StructType *ST, const DataLayout &DL) { 4533965Sjdp assert(!ST->isOpaque() && "Cannot get layout of opaque structs"); 4633965Sjdp StructAlignment = 0; 4733965Sjdp StructSize = 0; 4833965Sjdp NumElements = ST->getNumElements(); 4933965Sjdp 5033965Sjdp // Loop over each of the elements, placing them in memory. 5133965Sjdp for (unsigned i = 0, e = NumElements; i != e; ++i) { 5233965Sjdp Type *Ty = ST->getElementType(i); 5333965Sjdp unsigned TyAlign = ST->isPacked() ? 1 : DL.getABITypeAlignment(Ty); 5433965Sjdp 5533965Sjdp // Add padding if necessary to align the data element properly. 5633965Sjdp if ((StructSize & (TyAlign-1)) != 0) 5777298Sobrien StructSize = DataLayout::RoundUpAlignment(StructSize, TyAlign); 5833965Sjdp 5933965Sjdp // Keep track of maximum alignment constraint. 6033965Sjdp StructAlignment = std::max(TyAlign, StructAlignment); 6133965Sjdp 6233965Sjdp MemberOffsets[i] = StructSize; 63218822Sdim StructSize += DL.getTypeAllocSize(Ty); // Consume space for this data item 64218822Sdim } 65218822Sdim 66218822Sdim // Empty structures have alignment of 1 byte. 67218822Sdim if (StructAlignment == 0) StructAlignment = 1; 68218822Sdim 6933965Sjdp // Add padding to the end of the struct so that it could be put in an array 7033965Sjdp // and all array elements would be aligned correctly. 7133965Sjdp if ((StructSize & (StructAlignment-1)) != 0) 7233965Sjdp StructSize = DataLayout::RoundUpAlignment(StructSize, StructAlignment); 7333965Sjdp} 7433965Sjdp 75218822Sdim 76218822Sdim/// getElementContainingOffset - Given a valid offset into the structure, 77218822Sdim/// return the structure index that contains it. 78218822Sdimunsigned StructLayout::getElementContainingOffset(uint64_t Offset) const { 79218822Sdim const uint64_t *SI = 80218822Sdim std::upper_bound(&MemberOffsets[0], &MemberOffsets[NumElements], Offset); 81218822Sdim assert(SI != &MemberOffsets[0] && "Offset not in structure type!"); 82218822Sdim --SI; 83218822Sdim assert(*SI <= Offset && "upper_bound didn't work"); 8433965Sjdp assert((SI == &MemberOffsets[0] || *(SI-1) <= Offset) && 8533965Sjdp (SI+1 == &MemberOffsets[NumElements] || *(SI+1) > Offset) && 8633965Sjdp "Upper bound didn't work!"); 8733965Sjdp 8833965Sjdp // Multiple fields can have the same offset if any of them are zero sized. 8933965Sjdp // For example, in { i32, [0 x i32], i32 }, searching for offset 4 will stop 9033965Sjdp // at the i32 element, because it is the last element at that offset. This is 9177298Sobrien // the right one to return, because anything after it will have a higher 9277298Sobrien // offset, implying that this element is non-empty. 9377298Sobrien return SI-&MemberOffsets[0]; 9477298Sobrien} 9533965Sjdp 9633965Sjdp//===----------------------------------------------------------------------===// 9760484Sobrien// LayoutAlignElem, LayoutAlign support 9860484Sobrien//===----------------------------------------------------------------------===// 9960484Sobrien 10060484SobrienLayoutAlignElem 10133965SjdpLayoutAlignElem::get(AlignTypeEnum align_type, unsigned abi_align, 10260484Sobrien unsigned pref_align, uint32_t bit_width) { 10360484Sobrien assert(abi_align <= pref_align && "Preferred alignment worse than ABI!"); 10460484Sobrien LayoutAlignElem retval; 10560484Sobrien retval.AlignType = align_type; 10660484Sobrien retval.ABIAlign = abi_align; 10733965Sjdp retval.PrefAlign = pref_align; 10860484Sobrien retval.TypeBitWidth = bit_width; 10960484Sobrien return retval; 11060484Sobrien} 11160484Sobrien 11260484Sobrienbool 11333965SjdpLayoutAlignElem::operator==(const LayoutAlignElem &rhs) const { 11460484Sobrien return (AlignType == rhs.AlignType 11560484Sobrien && ABIAlign == rhs.ABIAlign 11689857Sobrien && PrefAlign == rhs.PrefAlign 11760484Sobrien && TypeBitWidth == rhs.TypeBitWidth); 11833965Sjdp} 11960484Sobrien 12060484Sobrienconst LayoutAlignElem 12133965SjdpDataLayout::InvalidAlignmentElem = LayoutAlignElem::get(INVALID_ALIGN, 0, 0, 0); 12260484Sobrien 12389857Sobrien//===----------------------------------------------------------------------===// 12460484Sobrien// PointerAlignElem, PointerAlign support 12560484Sobrien//===----------------------------------------------------------------------===// 12660484Sobrien 12760484SobrienPointerAlignElem 12860484SobrienPointerAlignElem::get(uint32_t addr_space, unsigned abi_align, 12960484Sobrien unsigned pref_align, uint32_t bit_width) { 13033965Sjdp assert(abi_align <= pref_align && "Preferred alignment worse than ABI!"); 13189857Sobrien PointerAlignElem retval; 13289857Sobrien retval.AddressSpace = addr_space; 13389857Sobrien retval.ABIAlign = abi_align; 13489857Sobrien retval.PrefAlign = pref_align; 13589857Sobrien retval.TypeBitWidth = bit_width; 13689857Sobrien return retval; 13760484Sobrien} 13833965Sjdp 13960484Sobrienbool 14060484SobrienPointerAlignElem::operator==(const PointerAlignElem &rhs) const { 14160484Sobrien return (ABIAlign == rhs.ABIAlign 14260484Sobrien && AddressSpace == rhs.AddressSpace 14360484Sobrien && PrefAlign == rhs.PrefAlign 14460484Sobrien && TypeBitWidth == rhs.TypeBitWidth); 14560484Sobrien} 14660484Sobrien 14733965Sjdpconst PointerAlignElem 14833965SjdpDataLayout::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 441bool DataLayout::doFinalization(Module &M) { 442 delete static_cast<StructLayoutMap*>(LayoutMap); 443 LayoutMap = 0; 444 return false; 445} 446 447const StructLayout *DataLayout::getStructLayout(StructType *Ty) const { 448 if (!LayoutMap) 449 LayoutMap = new StructLayoutMap(); 450 451 StructLayoutMap *STM = static_cast<StructLayoutMap*>(LayoutMap); 452 StructLayout *&SL = (*STM)[Ty]; 453 if (SL) return SL; 454 455 // Otherwise, create the struct layout. Because it is variable length, we 456 // malloc it, then use placement new. 457 int NumElts = Ty->getNumElements(); 458 StructLayout *L = 459 (StructLayout *)malloc(sizeof(StructLayout)+(NumElts-1) * sizeof(uint64_t)); 460 461 // Set SL before calling StructLayout's ctor. The ctor could cause other 462 // entries to be added to TheMap, invalidating our reference. 463 SL = L; 464 465 new (L) StructLayout(Ty, *this); 466 467 return L; 468} 469 470std::string DataLayout::getStringRepresentation() const { 471 std::string Result; 472 raw_string_ostream OS(Result); 473 474 OS << (LittleEndian ? "e" : "E"); 475 SmallVector<unsigned, 8> addrSpaces; 476 // Lets get all of the known address spaces and sort them 477 // into increasing order so that we can emit the string 478 // in a cleaner format. 479 for (DenseMap<unsigned, PointerAlignElem>::const_iterator 480 pib = Pointers.begin(), pie = Pointers.end(); 481 pib != pie; ++pib) { 482 addrSpaces.push_back(pib->first); 483 } 484 std::sort(addrSpaces.begin(), addrSpaces.end()); 485 for (SmallVector<unsigned, 8>::iterator asb = addrSpaces.begin(), 486 ase = addrSpaces.end(); asb != ase; ++asb) { 487 const PointerAlignElem &PI = Pointers.find(*asb)->second; 488 OS << "-p"; 489 if (PI.AddressSpace) { 490 OS << PI.AddressSpace; 491 } 492 OS << ":" << PI.TypeBitWidth*8 << ':' << PI.ABIAlign*8 493 << ':' << PI.PrefAlign*8; 494 } 495 OS << "-S" << StackNaturalAlign*8; 496 497 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) { 498 const LayoutAlignElem &AI = Alignments[i]; 499 OS << '-' << (char)AI.AlignType << AI.TypeBitWidth << ':' 500 << AI.ABIAlign*8 << ':' << AI.PrefAlign*8; 501 } 502 503 if (!LegalIntWidths.empty()) { 504 OS << "-n" << (unsigned)LegalIntWidths[0]; 505 506 for (unsigned i = 1, e = LegalIntWidths.size(); i != e; ++i) 507 OS << ':' << (unsigned)LegalIntWidths[i]; 508 } 509 return OS.str(); 510} 511 512 513/*! 514 \param abi_or_pref Flag that determines which alignment is returned. true 515 returns the ABI alignment, false returns the preferred alignment. 516 \param Ty The underlying type for which alignment is determined. 517 518 Get the ABI (\a abi_or_pref == true) or preferred alignment (\a abi_or_pref 519 == false) for the requested type \a Ty. 520 */ 521unsigned DataLayout::getAlignment(Type *Ty, bool abi_or_pref) const { 522 int AlignType = -1; 523 524 assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!"); 525 switch (Ty->getTypeID()) { 526 // Early escape for the non-numeric types. 527 case Type::LabelTyID: 528 return (abi_or_pref 529 ? getPointerABIAlignment(0) 530 : getPointerPrefAlignment(0)); 531 case Type::PointerTyID: { 532 unsigned AS = dyn_cast<PointerType>(Ty)->getAddressSpace(); 533 return (abi_or_pref 534 ? getPointerABIAlignment(AS) 535 : getPointerPrefAlignment(AS)); 536 } 537 case Type::ArrayTyID: 538 return getAlignment(cast<ArrayType>(Ty)->getElementType(), abi_or_pref); 539 540 case Type::StructTyID: { 541 // Packed structure types always have an ABI alignment of one. 542 if (cast<StructType>(Ty)->isPacked() && abi_or_pref) 543 return 1; 544 545 // Get the layout annotation... which is lazily created on demand. 546 const StructLayout *Layout = getStructLayout(cast<StructType>(Ty)); 547 unsigned Align = getAlignmentInfo(AGGREGATE_ALIGN, 0, abi_or_pref, Ty); 548 return std::max(Align, Layout->getAlignment()); 549 } 550 case Type::IntegerTyID: 551 AlignType = INTEGER_ALIGN; 552 break; 553 case Type::HalfTyID: 554 case Type::FloatTyID: 555 case Type::DoubleTyID: 556 // PPC_FP128TyID and FP128TyID have different data contents, but the 557 // same size and alignment, so they look the same here. 558 case Type::PPC_FP128TyID: 559 case Type::FP128TyID: 560 case Type::X86_FP80TyID: 561 AlignType = FLOAT_ALIGN; 562 break; 563 case Type::X86_MMXTyID: 564 case Type::VectorTyID: 565 AlignType = VECTOR_ALIGN; 566 break; 567 default: 568 llvm_unreachable("Bad type for getAlignment!!!"); 569 } 570 571 return getAlignmentInfo((AlignTypeEnum)AlignType, getTypeSizeInBits(Ty), 572 abi_or_pref, Ty); 573} 574 575unsigned DataLayout::getABITypeAlignment(Type *Ty) const { 576 return getAlignment(Ty, true); 577} 578 579/// getABIIntegerTypeAlignment - Return the minimum ABI-required alignment for 580/// an integer type of the specified bitwidth. 581unsigned DataLayout::getABIIntegerTypeAlignment(unsigned BitWidth) const { 582 return getAlignmentInfo(INTEGER_ALIGN, BitWidth, true, 0); 583} 584 585 586unsigned DataLayout::getCallFrameTypeAlignment(Type *Ty) const { 587 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) 588 if (Alignments[i].AlignType == STACK_ALIGN) 589 return Alignments[i].ABIAlign; 590 591 return getABITypeAlignment(Ty); 592} 593 594unsigned DataLayout::getPrefTypeAlignment(Type *Ty) const { 595 return getAlignment(Ty, false); 596} 597 598unsigned DataLayout::getPreferredTypeAlignmentShift(Type *Ty) const { 599 unsigned Align = getPrefTypeAlignment(Ty); 600 assert(!(Align & (Align-1)) && "Alignment is not a power of two!"); 601 return Log2_32(Align); 602} 603 604/// getIntPtrType - Return an integer type with size at least as big as that 605/// of a pointer in the given address space. 606IntegerType *DataLayout::getIntPtrType(LLVMContext &C, 607 unsigned AddressSpace) const { 608 return IntegerType::get(C, getPointerSizeInBits(AddressSpace)); 609} 610 611/// getIntPtrType - Return an integer (vector of integer) type with size at 612/// least as big as that of a pointer of the given pointer (vector of pointer) 613/// type. 614Type *DataLayout::getIntPtrType(Type *Ty) const { 615 assert(Ty->isPtrOrPtrVectorTy() && 616 "Expected a pointer or pointer vector type."); 617 unsigned NumBits = getTypeSizeInBits(Ty->getScalarType()); 618 IntegerType *IntTy = IntegerType::get(Ty->getContext(), NumBits); 619 if (VectorType *VecTy = dyn_cast<VectorType>(Ty)) 620 return VectorType::get(IntTy, VecTy->getNumElements()); 621 return IntTy; 622} 623 624Type *DataLayout::getSmallestLegalIntType(LLVMContext &C, unsigned Width) const { 625 for (unsigned i = 0, e = (unsigned)LegalIntWidths.size(); i != e; ++i) 626 if (Width <= LegalIntWidths[i]) 627 return Type::getIntNTy(C, LegalIntWidths[i]); 628 return 0; 629} 630 631uint64_t DataLayout::getIndexedOffset(Type *ptrTy, 632 ArrayRef<Value *> Indices) const { 633 Type *Ty = ptrTy; 634 assert(Ty->isPointerTy() && "Illegal argument for getIndexedOffset()"); 635 uint64_t Result = 0; 636 637 generic_gep_type_iterator<Value* const*> 638 TI = gep_type_begin(ptrTy, Indices); 639 for (unsigned CurIDX = 0, EndIDX = Indices.size(); CurIDX != EndIDX; 640 ++CurIDX, ++TI) { 641 if (StructType *STy = dyn_cast<StructType>(*TI)) { 642 assert(Indices[CurIDX]->getType() == 643 Type::getInt32Ty(ptrTy->getContext()) && 644 "Illegal struct idx"); 645 unsigned FieldNo = cast<ConstantInt>(Indices[CurIDX])->getZExtValue(); 646 647 // Get structure layout information... 648 const StructLayout *Layout = getStructLayout(STy); 649 650 // Add in the offset, as calculated by the structure layout info... 651 Result += Layout->getElementOffset(FieldNo); 652 653 // Update Ty to refer to current element 654 Ty = STy->getElementType(FieldNo); 655 } else { 656 // Update Ty to refer to current element 657 Ty = cast<SequentialType>(Ty)->getElementType(); 658 659 // Get the array index and the size of each array element. 660 if (int64_t arrayIdx = cast<ConstantInt>(Indices[CurIDX])->getSExtValue()) 661 Result += (uint64_t)arrayIdx * getTypeAllocSize(Ty); 662 } 663 } 664 665 return Result; 666} 667 668/// getPreferredAlignment - Return the preferred alignment of the specified 669/// global. This includes an explicitly requested alignment (if the global 670/// has one). 671unsigned DataLayout::getPreferredAlignment(const GlobalVariable *GV) const { 672 Type *ElemType = GV->getType()->getElementType(); 673 unsigned Alignment = getPrefTypeAlignment(ElemType); 674 unsigned GVAlignment = GV->getAlignment(); 675 if (GVAlignment >= Alignment) { 676 Alignment = GVAlignment; 677 } else if (GVAlignment != 0) { 678 Alignment = std::max(GVAlignment, getABITypeAlignment(ElemType)); 679 } 680 681 if (GV->hasInitializer() && GVAlignment == 0) { 682 if (Alignment < 16) { 683 // If the global is not external, see if it is large. If so, give it a 684 // larger alignment. 685 if (getTypeSizeInBits(ElemType) > 128) 686 Alignment = 16; // 16-byte alignment. 687 } 688 } 689 return Alignment; 690} 691 692/// getPreferredAlignmentLog - Return the preferred alignment of the 693/// specified global, returned in log form. This includes an explicitly 694/// requested alignment (if the global has one). 695unsigned DataLayout::getPreferredAlignmentLog(const GlobalVariable *GV) const { 696 return Log2_32(getPreferredAlignment(GV)); 697} 698