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 | |