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