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/Casting.h" |
30 | #include "llvm/Support/ErrorHandling.h" |
31 | #include "llvm/Support/MathExtras.h" |
32 | #include "llvm/Support/Alignment.h" |
33 | #include "llvm/Support/TrailingObjects.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 |
53 | enum AlignTypeEnum { |
54 | INVALID_ALIGN = 0, |
55 | INTEGER_ALIGN = 'i', |
56 | VECTOR_ALIGN = 'v', |
57 | FLOAT_ALIGN = 'f', |
58 | AGGREGATE_ALIGN = 'a' |
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. |
73 | struct LayoutAlignElem { |
74 | /// Alignment type from \c AlignTypeEnum |
75 | unsigned AlignType : 8; |
76 | unsigned TypeBitWidth : 24; |
77 | Align ABIAlign; |
78 | Align PrefAlign; |
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. |
92 | struct PointerAlignElem { |
93 | Align ABIAlign; |
94 | Align PrefAlign; |
95 | uint32_t TypeBitWidth; |
96 | uint32_t AddressSpace; |
97 | uint32_t IndexBitWidth; |
98 | |
99 | /// Initializer |
100 | static PointerAlignElem getInBits(uint32_t AddressSpace, Align ABIAlign, |
101 | Align PrefAlign, uint32_t TypeBitWidth, |
102 | uint32_t IndexBitWidth); |
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. |
119 | MultipleOfFunctionAlign, |
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 | |
152 | AlignmentsTy::const_iterator |
153 | findAlignmentLowerBound(AlignTypeEnum AlignType, uint32_t BitWidth) const { |
154 | return const_cast<DataLayout *>(this)->findAlignmentLowerBound(AlignType, |
155 | BitWidth); |
156 | } |
157 | |
158 | AlignmentsTy::iterator |
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 | |
213 | DataLayout &operator=(const DataLayout &DL) { |
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. |
266 | bool isLegalInteger(uint64_t Width) const { |
267 | return llvm::is_contained(LegalIntWidths, Width); |
268 | } |
269 | |
270 | bool isIllegalInteger(uint64_t Width) const { return !isLegalInteger(Width); } |
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 | |
277 | Align getStackAlignment() const { |
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 |
291 | FunctionPtrAlignType getFunctionPtrAlignType() const { |
292 | return TheFunctionPtrAlignType; |
293 | } |
294 | |
295 | unsigned getProgramAddressSpace() const { return ProgramAddrSpace; } |
296 | unsigned getDefaultGlobalsAddressSpace() const { |
297 | return DefaultGlobalsAddrSpace; |
298 | } |
299 | |
300 | bool hasMicrosoftFastStdCallMangling() const { |
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. |
306 | bool doNotMangleLeadingQuestionMark() const { |
307 | return ManglingMode == MM_WinCOFF || ManglingMode == MM_WinCOFFX86; |
308 | } |
309 | |
310 | bool hasLinkerPrivateGlobalPrefix() const { return ManglingMode == MM_MachO; } |
311 | |
312 | StringRef getLinkerPrivateGlobalPrefix() const { |
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 | |
334 | StringRef getPrivateGlobalPrefix() const { |
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. |
391 | ArrayRef<unsigned> getNonIntegralAddressSpaces() const { |
392 | return NonIntegralAddressSpaces; |
393 | } |
394 | |
395 | bool isNonIntegralAddressSpace(unsigned AddrSpace) const { |
396 | ArrayRef<unsigned> NonIntegralSpaces = getNonIntegralAddressSpaces(); |
397 | return is_contained(NonIntegralSpaces, AddrSpace); |
398 | } |
399 | |
400 | bool isNonIntegralPointerType(PointerType *PT) const { |
401 | return isNonIntegralAddressSpace(PT->getAddressSpace()); |
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. |
474 | TypeSize getTypeStoreSize(Type *Ty) const { |
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. |
486 | TypeSize getTypeStoreSizeInBits(Type *Ty) const { |
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. |
506 | TypeSize getTypeAllocSize(Type *Ty) const { |
507 | // Round up to the next alignment boundary. |
508 | return alignTo(getTypeStoreSize(Ty), getABITypeAlignment(Ty)); |
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. |
519 | TypeSize getTypeAllocSizeInBits(Type *Ty) const { |
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. |
532 | inline Align getValueOrABITypeAlignment(MaybeAlign 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. |
539 | Align getABIIntegerTypeAlignment(unsigned BitWidth) const { |
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. |
548 | uint64_t getPrefTypeAlignment(Type *Ty) const; |
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. |
569 | Type *getLargestLegalIntType(LLVMContext &C) const { |
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 | |
612 | inline DataLayout *unwrap(LLVMTargetDataRef P) { |
613 | return reinterpret_cast<DataLayout *>(P); |
614 | } |
615 | |
616 | inline LLVMTargetDataRef wrap(const DataLayout *P) { |
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 | |
643 | MutableArrayRef<uint64_t> getMemberOffsets() { |
644 | return llvm::makeMutableArrayRef(getTrailingObjects<uint64_t>(), |
645 | NumElements); |
646 | } |
647 | |
648 | ArrayRef<uint64_t> getMemberOffsets() const { |
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 | |
664 | StructLayout(StructType *ST, const DataLayout &DL); |
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. |
673 | inline TypeSize DataLayout::getTypeSizeInBits(Type *Ty) const { |
674 | assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!" ); |
675 | switch (Ty->getTypeID()) { |
676 | case Type::LabelTyID: |
677 | return TypeSize::Fixed(getPointerSizeInBits(0)); |
678 | case Type::PointerTyID: |
679 | return TypeSize::Fixed(getPointerSizeInBits(Ty->getPointerAddressSpace())); |
680 | case Type::ArrayTyID: { |
681 | ArrayType *ATy = cast<ArrayType>(Ty); |
682 | return ATy->getNumElements() * |
683 | getTypeAllocSizeInBits(ATy->getElementType()); |
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); |
708 | case Type::FixedVectorTyID: |
709 | case Type::ScalableVectorTyID: { |
710 | VectorType *VTy = cast<VectorType>(Ty); |
711 | auto EltCnt = VTy->getElementCount(); |
712 | uint64_t MinBits = EltCnt.getKnownMinValue() * |
713 | getTypeSizeInBits(VTy->getElementType()).getFixedSize(); |
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 |
724 | |