1 //===- llvm/DataLayout.h - Data size & alignment info -----------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file defines layout properties related to datatype size/offset/alignment 10 // information. It uses lazy annotations to cache information about how 11 // structure types are laid out and used. 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 #ifndef LLVM_IR_DATALAYOUT_H 20 #define LLVM_IR_DATALAYOUT_H 21 22 #include "llvm/ADT/ArrayRef.h" 23 #include "llvm/ADT/STLExtras.h" 24 #include "llvm/ADT/SmallVector.h" 25 #include "llvm/ADT/StringRef.h" 26 #include "llvm/IR/DerivedTypes.h" 27 #include "llvm/IR/Type.h" 28 #include "llvm/Support/Casting.h" 29 #include "llvm/Support/ErrorHandling.h" 30 #include "llvm/Support/MathExtras.h" 31 #include "llvm/Support/Alignment.h" 32 #include "llvm/Support/TrailingObjects.h" 33 #include "llvm/Support/TypeSize.h" 34 #include <cassert> 35 #include <cstdint> 36 #include <string> 37 38 // This needs to be outside of the namespace, to avoid conflict with llvm-c 39 // decl. 40 using LLVMTargetDataRef = struct LLVMOpaqueTargetData *; 41 42 namespace llvm { 43 44 class GlobalVariable; 45 class LLVMContext; 46 class Module; 47 class StructLayout; 48 class Triple; 49 class Value; 50 51 /// Enum used to categorize the alignment types stored by LayoutAlignElem 52 enum AlignTypeEnum { 53 INVALID_ALIGN = 0, 54 INTEGER_ALIGN = 'i', 55 VECTOR_ALIGN = 'v', 56 FLOAT_ALIGN = 'f', 57 AGGREGATE_ALIGN = 'a' 58 }; 59 60 // FIXME: Currently the DataLayout string carries a "preferred alignment" 61 // for types. As the DataLayout is module/global, this should likely be 62 // sunk down to an FTTI element that is queried rather than a global 63 // preference. 64 65 /// Layout alignment element. 66 /// 67 /// Stores the alignment data associated with a given alignment type (integer, 68 /// vector, float) and type bit width. 69 /// 70 /// \note The unusual order of elements in the structure attempts to reduce 71 /// padding and make the structure slightly more cache friendly. 72 struct LayoutAlignElem { 73 /// Alignment type from \c AlignTypeEnum 74 unsigned AlignType : 8; 75 unsigned TypeBitWidth : 24; 76 Align ABIAlign; 77 Align PrefAlign; 78 79 static LayoutAlignElem get(AlignTypeEnum align_type, Align abi_align, 80 Align pref_align, uint32_t bit_width); 81 82 bool operator==(const LayoutAlignElem &rhs) const; 83 }; 84 85 /// Layout pointer alignment element. 86 /// 87 /// Stores the alignment data associated with a given pointer and address space. 88 /// 89 /// \note The unusual order of elements in the structure attempts to reduce 90 /// padding and make the structure slightly more cache friendly. 91 struct PointerAlignElem { 92 Align ABIAlign; 93 Align PrefAlign; 94 uint32_t TypeByteWidth; 95 uint32_t AddressSpace; 96 uint32_t IndexWidth; 97 98 /// Initializer 99 static PointerAlignElem get(uint32_t AddressSpace, Align ABIAlign, 100 Align PrefAlign, uint32_t TypeByteWidth, 101 uint32_t IndexWidth); 102 103 bool operator==(const PointerAlignElem &rhs) const; 104 }; 105 106 /// A parsed version of the target data layout string in and methods for 107 /// querying it. 108 /// 109 /// The target data layout string is specified *by the target* - a frontend 110 /// generating LLVM IR is required to generate the right target data for the 111 /// target being codegen'd to. 112 class DataLayout { 113 public: 114 enum class FunctionPtrAlignType { 115 /// The function pointer alignment is independent of the function alignment. 116 Independent, 117 /// The function pointer alignment is a multiple of the function alignment. 118 MultipleOfFunctionAlign, 119 }; 120 private: 121 /// Defaults to false. 122 bool BigEndian; 123 124 unsigned AllocaAddrSpace; 125 MaybeAlign StackNaturalAlign; 126 unsigned ProgramAddrSpace; 127 unsigned DefaultGlobalsAddrSpace; 128 129 MaybeAlign FunctionPtrAlign; 130 FunctionPtrAlignType TheFunctionPtrAlignType; 131 132 enum ManglingModeT { 133 MM_None, 134 MM_ELF, 135 MM_MachO, 136 MM_WinCOFF, 137 MM_WinCOFFX86, 138 MM_Mips, 139 MM_XCOFF 140 }; 141 ManglingModeT ManglingMode; 142 143 SmallVector<unsigned char, 8> LegalIntWidths; 144 145 /// Primitive type alignment data. This is sorted by type and bit 146 /// width during construction. 147 using AlignmentsTy = SmallVector<LayoutAlignElem, 16>; 148 AlignmentsTy Alignments; 149 150 AlignmentsTy::const_iterator 151 findAlignmentLowerBound(AlignTypeEnum AlignType, uint32_t BitWidth) const { 152 return const_cast<DataLayout *>(this)->findAlignmentLowerBound(AlignType, 153 BitWidth); 154 } 155 156 AlignmentsTy::iterator 157 findAlignmentLowerBound(AlignTypeEnum AlignType, uint32_t BitWidth); 158 159 /// The string representation used to create this DataLayout 160 std::string StringRepresentation; 161 162 using PointersTy = SmallVector<PointerAlignElem, 8>; 163 PointersTy Pointers; 164 165 const PointerAlignElem &getPointerAlignElem(uint32_t AddressSpace) const; 166 167 // The StructType -> StructLayout map. 168 mutable void *LayoutMap = nullptr; 169 170 /// Pointers in these address spaces are non-integral, and don't have a 171 /// well-defined bitwise representation. 172 SmallVector<unsigned, 8> NonIntegralAddressSpaces; 173 174 /// Attempts to set the alignment of the given type. Returns an error 175 /// description on failure. 176 Error setAlignment(AlignTypeEnum align_type, Align abi_align, 177 Align pref_align, uint32_t bit_width); 178 179 /// Attempts to set the alignment of a pointer in the given address space. 180 /// Returns an error description on failure. 181 Error setPointerAlignment(uint32_t AddrSpace, Align ABIAlign, Align PrefAlign, 182 uint32_t TypeByteWidth, uint32_t IndexWidth); 183 184 /// Internal helper to get alignment for integer of given bitwidth. 185 Align getIntegerAlignment(uint32_t BitWidth, bool abi_or_pref) const; 186 187 /// Internal helper method that returns requested alignment for type. 188 Align getAlignment(Type *Ty, bool abi_or_pref) const; 189 190 /// Attempts to parse a target data specification string and reports an error 191 /// if the string is malformed. 192 Error parseSpecifier(StringRef Desc); 193 194 // Free all internal data structures. 195 void clear(); 196 197 public: 198 /// Constructs a DataLayout from a specification string. See reset(). 199 explicit DataLayout(StringRef LayoutDescription) { 200 reset(LayoutDescription); 201 } 202 203 /// Initialize target data from properties stored in the module. 204 explicit DataLayout(const Module *M); 205 206 DataLayout(const DataLayout &DL) { *this = DL; } 207 208 ~DataLayout(); // Not virtual, do not subclass this class 209 210 DataLayout &operator=(const DataLayout &DL) { 211 clear(); 212 StringRepresentation = DL.StringRepresentation; 213 BigEndian = DL.isBigEndian(); 214 AllocaAddrSpace = DL.AllocaAddrSpace; 215 StackNaturalAlign = DL.StackNaturalAlign; 216 FunctionPtrAlign = DL.FunctionPtrAlign; 217 TheFunctionPtrAlignType = DL.TheFunctionPtrAlignType; 218 ProgramAddrSpace = DL.ProgramAddrSpace; 219 DefaultGlobalsAddrSpace = DL.DefaultGlobalsAddrSpace; 220 ManglingMode = DL.ManglingMode; 221 LegalIntWidths = DL.LegalIntWidths; 222 Alignments = DL.Alignments; 223 Pointers = DL.Pointers; 224 NonIntegralAddressSpaces = DL.NonIntegralAddressSpaces; 225 return *this; 226 } 227 228 bool operator==(const DataLayout &Other) const; 229 bool operator!=(const DataLayout &Other) const { return !(*this == Other); } 230 231 void init(const Module *M); 232 233 /// Parse a data layout string (with fallback to default values). 234 void reset(StringRef LayoutDescription); 235 236 /// Parse a data layout string and return the layout. Return an error 237 /// description on failure. 238 static Expected<DataLayout> parse(StringRef LayoutDescription); 239 240 /// Layout endianness... 241 bool isLittleEndian() const { return !BigEndian; } 242 bool isBigEndian() const { return BigEndian; } 243 244 /// Returns the string representation of the DataLayout. 245 /// 246 /// This representation is in the same format accepted by the string 247 /// constructor above. This should not be used to compare two DataLayout as 248 /// different string can represent the same layout. 249 const std::string &getStringRepresentation() const { 250 return StringRepresentation; 251 } 252 253 /// Test if the DataLayout was constructed from an empty string. 254 bool isDefault() const { return StringRepresentation.empty(); } 255 256 /// Returns true if the specified type is known to be a native integer 257 /// type supported by the CPU. 258 /// 259 /// For example, i64 is not native on most 32-bit CPUs and i37 is not native 260 /// on any known one. This returns false if the integer width is not legal. 261 /// 262 /// The width is specified in bits. 263 bool isLegalInteger(uint64_t Width) const { 264 return llvm::is_contained(LegalIntWidths, Width); 265 } 266 267 bool isIllegalInteger(uint64_t Width) const { return !isLegalInteger(Width); } 268 269 /// Returns true if the given alignment exceeds the natural stack alignment. 270 bool exceedsNaturalStackAlignment(Align Alignment) const { 271 return StackNaturalAlign && (Alignment > *StackNaturalAlign); 272 } 273 274 Align getStackAlignment() const { 275 assert(StackNaturalAlign && "StackNaturalAlign must be defined"); 276 return *StackNaturalAlign; 277 } 278 279 unsigned getAllocaAddrSpace() const { return AllocaAddrSpace; } 280 281 /// Returns the alignment of function pointers, which may or may not be 282 /// related to the alignment of functions. 283 /// \see getFunctionPtrAlignType 284 MaybeAlign getFunctionPtrAlign() const { return FunctionPtrAlign; } 285 286 /// Return the type of function pointer alignment. 287 /// \see getFunctionPtrAlign 288 FunctionPtrAlignType getFunctionPtrAlignType() const { 289 return TheFunctionPtrAlignType; 290 } 291 292 unsigned getProgramAddressSpace() const { return ProgramAddrSpace; } 293 unsigned getDefaultGlobalsAddressSpace() const { 294 return DefaultGlobalsAddrSpace; 295 } 296 297 bool hasMicrosoftFastStdCallMangling() const { 298 return ManglingMode == MM_WinCOFFX86; 299 } 300 301 /// Returns true if symbols with leading question marks should not receive IR 302 /// mangling. True for Windows mangling modes. 303 bool doNotMangleLeadingQuestionMark() const { 304 return ManglingMode == MM_WinCOFF || ManglingMode == MM_WinCOFFX86; 305 } 306 307 bool hasLinkerPrivateGlobalPrefix() const { return ManglingMode == MM_MachO; } 308 309 StringRef getLinkerPrivateGlobalPrefix() const { 310 if (ManglingMode == MM_MachO) 311 return "l"; 312 return ""; 313 } 314 315 char getGlobalPrefix() const { 316 switch (ManglingMode) { 317 case MM_None: 318 case MM_ELF: 319 case MM_Mips: 320 case MM_WinCOFF: 321 case MM_XCOFF: 322 return '\0'; 323 case MM_MachO: 324 case MM_WinCOFFX86: 325 return '_'; 326 } 327 llvm_unreachable("invalid mangling mode"); 328 } 329 330 StringRef getPrivateGlobalPrefix() const { 331 switch (ManglingMode) { 332 case MM_None: 333 return ""; 334 case MM_ELF: 335 case MM_WinCOFF: 336 return ".L"; 337 case MM_Mips: 338 return "$"; 339 case MM_MachO: 340 case MM_WinCOFFX86: 341 return "L"; 342 case MM_XCOFF: 343 return "L.."; 344 } 345 llvm_unreachable("invalid mangling mode"); 346 } 347 348 static const char *getManglingComponent(const Triple &T); 349 350 /// Returns true if the specified type fits in a native integer type 351 /// supported by the CPU. 352 /// 353 /// For example, if the CPU only supports i32 as a native integer type, then 354 /// i27 fits in a legal integer type but i45 does not. 355 bool fitsInLegalInteger(unsigned Width) const { 356 for (unsigned LegalIntWidth : LegalIntWidths) 357 if (Width <= LegalIntWidth) 358 return true; 359 return false; 360 } 361 362 /// Layout pointer alignment 363 Align getPointerABIAlignment(unsigned AS) const; 364 365 /// Return target's alignment for stack-based pointers 366 /// FIXME: The defaults need to be removed once all of 367 /// the backends/clients are updated. 368 Align getPointerPrefAlignment(unsigned AS = 0) const; 369 370 /// Layout pointer size 371 /// FIXME: The defaults need to be removed once all of 372 /// the backends/clients are updated. 373 unsigned getPointerSize(unsigned AS = 0) const; 374 375 /// Returns the maximum pointer size over all address spaces. 376 unsigned getMaxPointerSize() const; 377 378 // Index size used for address calculation. 379 unsigned getIndexSize(unsigned AS) const; 380 381 /// Return the address spaces containing non-integral pointers. Pointers in 382 /// this address space don't have a well-defined bitwise representation. 383 ArrayRef<unsigned> getNonIntegralAddressSpaces() const { 384 return NonIntegralAddressSpaces; 385 } 386 387 bool isNonIntegralAddressSpace(unsigned AddrSpace) const { 388 ArrayRef<unsigned> NonIntegralSpaces = getNonIntegralAddressSpaces(); 389 return is_contained(NonIntegralSpaces, AddrSpace); 390 } 391 392 bool isNonIntegralPointerType(PointerType *PT) const { 393 return isNonIntegralAddressSpace(PT->getAddressSpace()); 394 } 395 396 bool isNonIntegralPointerType(Type *Ty) const { 397 auto *PTy = dyn_cast<PointerType>(Ty); 398 return PTy && isNonIntegralPointerType(PTy); 399 } 400 401 /// Layout pointer size, in bits 402 /// FIXME: The defaults need to be removed once all of 403 /// the backends/clients are updated. 404 unsigned getPointerSizeInBits(unsigned AS = 0) const { 405 return getPointerSize(AS) * 8; 406 } 407 408 /// Returns the maximum pointer size over all address spaces. 409 unsigned getMaxPointerSizeInBits() const { 410 return getMaxPointerSize() * 8; 411 } 412 413 /// Size in bits of index used for address calculation in getelementptr. 414 unsigned getIndexSizeInBits(unsigned AS) const { 415 return getIndexSize(AS) * 8; 416 } 417 418 /// Layout pointer size, in bits, based on the type. If this function is 419 /// called with a pointer type, then the type size of the pointer is returned. 420 /// If this function is called with a vector of pointers, then the type size 421 /// of the pointer is returned. This should only be called with a pointer or 422 /// vector of pointers. 423 unsigned getPointerTypeSizeInBits(Type *) const; 424 425 /// Layout size of the index used in GEP calculation. 426 /// The function should be called with pointer or vector of pointers type. 427 unsigned getIndexTypeSizeInBits(Type *Ty) const; 428 429 unsigned getPointerTypeSize(Type *Ty) const { 430 return getPointerTypeSizeInBits(Ty) / 8; 431 } 432 433 /// Size examples: 434 /// 435 /// Type SizeInBits StoreSizeInBits AllocSizeInBits[*] 436 /// ---- ---------- --------------- --------------- 437 /// i1 1 8 8 438 /// i8 8 8 8 439 /// i19 19 24 32 440 /// i32 32 32 32 441 /// i100 100 104 128 442 /// i128 128 128 128 443 /// Float 32 32 32 444 /// Double 64 64 64 445 /// X86_FP80 80 80 96 446 /// 447 /// [*] The alloc size depends on the alignment, and thus on the target. 448 /// These values are for x86-32 linux. 449 450 /// Returns the number of bits necessary to hold the specified type. 451 /// 452 /// If Ty is a scalable vector type, the scalable property will be set and 453 /// the runtime size will be a positive integer multiple of the base size. 454 /// 455 /// For example, returns 36 for i36 and 80 for x86_fp80. The type passed must 456 /// have a size (Type::isSized() must return true). 457 TypeSize getTypeSizeInBits(Type *Ty) const; 458 459 /// Returns the maximum number of bytes that may be overwritten by 460 /// storing the specified type. 461 /// 462 /// If Ty is a scalable vector type, the scalable property will be set and 463 /// the runtime size will be a positive integer multiple of the base size. 464 /// 465 /// For example, returns 5 for i36 and 10 for x86_fp80. 466 TypeSize getTypeStoreSize(Type *Ty) const { 467 TypeSize BaseSize = getTypeSizeInBits(Ty); 468 return { (BaseSize.getKnownMinSize() + 7) / 8, BaseSize.isScalable() }; 469 } 470 471 /// Returns the maximum number of bits that may be overwritten by 472 /// storing the specified type; always a multiple of 8. 473 /// 474 /// If Ty is a scalable vector type, the scalable property will be set and 475 /// the runtime size will be a positive integer multiple of the base size. 476 /// 477 /// For example, returns 40 for i36 and 80 for x86_fp80. 478 TypeSize getTypeStoreSizeInBits(Type *Ty) const { 479 return 8 * getTypeStoreSize(Ty); 480 } 481 482 /// Returns true if no extra padding bits are needed when storing the 483 /// specified type. 484 /// 485 /// For example, returns false for i19 that has a 24-bit store size. 486 bool typeSizeEqualsStoreSize(Type *Ty) const { 487 return getTypeSizeInBits(Ty) == getTypeStoreSizeInBits(Ty); 488 } 489 490 /// Returns the offset in bytes between successive objects of the 491 /// specified type, including alignment padding. 492 /// 493 /// If Ty is a scalable vector type, the scalable property will be set and 494 /// the runtime size will be a positive integer multiple of the base size. 495 /// 496 /// This is the amount that alloca reserves for this type. For example, 497 /// returns 12 or 16 for x86_fp80, depending on alignment. 498 TypeSize getTypeAllocSize(Type *Ty) const { 499 // Round up to the next alignment boundary. 500 return alignTo(getTypeStoreSize(Ty), getABITypeAlignment(Ty)); 501 } 502 503 /// Returns the offset in bits between successive objects of the 504 /// specified type, including alignment padding; always a multiple of 8. 505 /// 506 /// If Ty is a scalable vector type, the scalable property will be set and 507 /// the runtime size will be a positive integer multiple of the base size. 508 /// 509 /// This is the amount that alloca reserves for this type. For example, 510 /// returns 96 or 128 for x86_fp80, depending on alignment. 511 TypeSize getTypeAllocSizeInBits(Type *Ty) const { 512 return 8 * getTypeAllocSize(Ty); 513 } 514 515 /// Returns the minimum ABI-required alignment for the specified type. 516 /// FIXME: Deprecate this function once migration to Align is over. 517 unsigned getABITypeAlignment(Type *Ty) const; 518 519 /// Returns the minimum ABI-required alignment for the specified type. 520 Align getABITypeAlign(Type *Ty) const; 521 522 /// Helper function to return `Alignment` if it's set or the result of 523 /// `getABITypeAlignment(Ty)`, in any case the result is a valid alignment. 524 inline Align getValueOrABITypeAlignment(MaybeAlign Alignment, 525 Type *Ty) const { 526 return Alignment ? *Alignment : getABITypeAlign(Ty); 527 } 528 529 /// Returns the minimum ABI-required alignment for an integer type of 530 /// the specified bitwidth. 531 Align getABIIntegerTypeAlignment(unsigned BitWidth) const { 532 return getIntegerAlignment(BitWidth, /* abi_or_pref */ true); 533 } 534 535 /// Returns the preferred stack/global alignment for the specified 536 /// type. 537 /// 538 /// This is always at least as good as the ABI alignment. 539 /// FIXME: Deprecate this function once migration to Align is over. 540 unsigned getPrefTypeAlignment(Type *Ty) const; 541 542 /// Returns the preferred stack/global alignment for the specified 543 /// type. 544 /// 545 /// This is always at least as good as the ABI alignment. 546 Align getPrefTypeAlign(Type *Ty) const; 547 548 /// Returns an integer type with size at least as big as that of a 549 /// pointer in the given address space. 550 IntegerType *getIntPtrType(LLVMContext &C, unsigned AddressSpace = 0) const; 551 552 /// Returns an integer (vector of integer) type with size at least as 553 /// big as that of a pointer of the given pointer (vector of pointer) type. 554 Type *getIntPtrType(Type *) const; 555 556 /// Returns the smallest integer type with size at least as big as 557 /// Width bits. 558 Type *getSmallestLegalIntType(LLVMContext &C, unsigned Width = 0) const; 559 560 /// Returns the largest legal integer type, or null if none are set. 561 Type *getLargestLegalIntType(LLVMContext &C) const { 562 unsigned LargestSize = getLargestLegalIntTypeSizeInBits(); 563 return (LargestSize == 0) ? nullptr : Type::getIntNTy(C, LargestSize); 564 } 565 566 /// Returns the size of largest legal integer type size, or 0 if none 567 /// are set. 568 unsigned getLargestLegalIntTypeSizeInBits() const; 569 570 /// Returns the type of a GEP index. 571 /// If it was not specified explicitly, it will be the integer type of the 572 /// pointer width - IntPtrType. 573 Type *getIndexType(Type *PtrTy) const; 574 575 /// Returns the offset from the beginning of the type for the specified 576 /// indices. 577 /// 578 /// Note that this takes the element type, not the pointer type. 579 /// This is used to implement getelementptr. 580 int64_t getIndexedOffsetInType(Type *ElemTy, ArrayRef<Value *> Indices) const; 581 582 /// Returns a StructLayout object, indicating the alignment of the 583 /// struct, its size, and the offsets of its fields. 584 /// 585 /// Note that this information is lazily cached. 586 const StructLayout *getStructLayout(StructType *Ty) const; 587 588 /// Returns the preferred alignment of the specified global. 589 /// 590 /// This includes an explicitly requested alignment (if the global has one). 591 Align getPreferredAlign(const GlobalVariable *GV) const; 592 }; 593 594 inline DataLayout *unwrap(LLVMTargetDataRef P) { 595 return reinterpret_cast<DataLayout *>(P); 596 } 597 598 inline LLVMTargetDataRef wrap(const DataLayout *P) { 599 return reinterpret_cast<LLVMTargetDataRef>(const_cast<DataLayout *>(P)); 600 } 601 602 /// Used to lazily calculate structure layout information for a target machine, 603 /// based on the DataLayout structure. 604 class StructLayout final : public TrailingObjects<StructLayout, uint64_t> { 605 uint64_t StructSize; 606 Align StructAlignment; 607 unsigned IsPadded : 1; 608 unsigned NumElements : 31; 609 610 public: 611 uint64_t getSizeInBytes() const { return StructSize; } 612 613 uint64_t getSizeInBits() const { return 8 * StructSize; } 614 615 Align getAlignment() const { return StructAlignment; } 616 617 /// Returns whether the struct has padding or not between its fields. 618 /// NB: Padding in nested element is not taken into account. 619 bool hasPadding() const { return IsPadded; } 620 621 /// Given a valid byte offset into the structure, returns the structure 622 /// index that contains it. 623 unsigned getElementContainingOffset(uint64_t Offset) const; 624 625 MutableArrayRef<uint64_t> getMemberOffsets() { 626 return llvm::makeMutableArrayRef(getTrailingObjects<uint64_t>(), 627 NumElements); 628 } 629 630 ArrayRef<uint64_t> getMemberOffsets() const { 631 return llvm::makeArrayRef(getTrailingObjects<uint64_t>(), NumElements); 632 } 633 634 uint64_t getElementOffset(unsigned Idx) const { 635 assert(Idx < NumElements && "Invalid element idx!"); 636 return getMemberOffsets()[Idx]; 637 } 638 639 uint64_t getElementOffsetInBits(unsigned Idx) const { 640 return getElementOffset(Idx) * 8; 641 } 642 643 private: 644 friend class DataLayout; // Only DataLayout can create this class 645 646 StructLayout(StructType *ST, const DataLayout &DL); 647 648 size_t numTrailingObjects(OverloadToken<uint64_t>) const { 649 return NumElements; 650 } 651 }; 652 653 // The implementation of this method is provided inline as it is particularly 654 // well suited to constant folding when called on a specific Type subclass. 655 inline TypeSize DataLayout::getTypeSizeInBits(Type *Ty) const { 656 assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!"); 657 switch (Ty->getTypeID()) { 658 case Type::LabelTyID: 659 return TypeSize::Fixed(getPointerSizeInBits(0)); 660 case Type::PointerTyID: 661 return TypeSize::Fixed(getPointerSizeInBits(Ty->getPointerAddressSpace())); 662 case Type::ArrayTyID: { 663 ArrayType *ATy = cast<ArrayType>(Ty); 664 return ATy->getNumElements() * 665 getTypeAllocSizeInBits(ATy->getElementType()); 666 } 667 case Type::StructTyID: 668 // Get the layout annotation... which is lazily created on demand. 669 return TypeSize::Fixed( 670 getStructLayout(cast<StructType>(Ty))->getSizeInBits()); 671 case Type::IntegerTyID: 672 return TypeSize::Fixed(Ty->getIntegerBitWidth()); 673 case Type::HalfTyID: 674 case Type::BFloatTyID: 675 return TypeSize::Fixed(16); 676 case Type::FloatTyID: 677 return TypeSize::Fixed(32); 678 case Type::DoubleTyID: 679 case Type::X86_MMXTyID: 680 return TypeSize::Fixed(64); 681 case Type::PPC_FP128TyID: 682 case Type::FP128TyID: 683 return TypeSize::Fixed(128); 684 case Type::X86_AMXTyID: 685 return TypeSize::Fixed(8192); 686 // In memory objects this is always aligned to a higher boundary, but 687 // only 80 bits contain information. 688 case Type::X86_FP80TyID: 689 return TypeSize::Fixed(80); 690 case Type::FixedVectorTyID: 691 case Type::ScalableVectorTyID: { 692 VectorType *VTy = cast<VectorType>(Ty); 693 auto EltCnt = VTy->getElementCount(); 694 uint64_t MinBits = EltCnt.getKnownMinValue() * 695 getTypeSizeInBits(VTy->getElementType()).getFixedSize(); 696 return TypeSize(MinBits, EltCnt.isScalable()); 697 } 698 default: 699 llvm_unreachable("DataLayout::getTypeSizeInBits(): Unsupported type"); 700 } 701 } 702 703 } // end namespace llvm 704 705 #endif // LLVM_IR_DATALAYOUT_H 706