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