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.
40using LLVMTargetDataRef = struct LLVMOpaqueTargetData *;
41
42namespace llvm {
43
44class GlobalVariable;
45class LLVMContext;
46class Module;
47class StructLayout;
48class Triple;
49class Value;
50
51/// Enum used to categorize the alignment types stored by LayoutAlignElem
52enum 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.
72struct 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.
91struct 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.
112class DataLayout {
113public:
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 };
120private:
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
197public:
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
594inline DataLayout *unwrap(LLVMTargetDataRef P) {
595 return reinterpret_cast<DataLayout *>(P);
596}
597
598inline 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.
604class StructLayout final : public TrailingObjects<StructLayout, uint64_t> {
605 uint64_t StructSize;
606 Align StructAlignment;
607 unsigned IsPadded : 1;
608 unsigned NumElements : 31;
609
610public:
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
643private:
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.
655inline 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