LLVM: lib/IR/DataLayout.cpp Source File

LLVM 22.0.0git
DataLayout.cpp
Go to the documentation of this file.
1//===- DataLayout.cpp - Data size & alignment routines ---------------------==//
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.
11//
12// This structure should be created once, filled in if the defaults are not
13// correct and then passed around by const&. None of the members functions
14// require modification to the object.
15//
16//===----------------------------------------------------------------------===//
17
18#include "llvm/IR/DataLayout.h"
19#include "llvm/ADT/DenseMap.h"
20#include "llvm/ADT/StringExtras.h"
21#include "llvm/ADT/StringRef.h"
22#include "llvm/IR/Constants.h"
23#include "llvm/IR/DerivedTypes.h"
24#include "llvm/IR/GetElementPtrTypeIterator.h"
25#include "llvm/IR/GlobalVariable.h"
26#include "llvm/IR/Type.h"
27#include "llvm/IR/Value.h"
28#include "llvm/Support/Casting.h"
29#include "llvm/Support/Error.h"
30#include "llvm/Support/ErrorHandling.h"
31#include "llvm/Support/MathExtras.h"
32#include "llvm/Support/MemAlloc.h"
33#include "llvm/Support/TypeSize.h"
34#include "llvm/TargetParser/Triple.h"
35#include <algorithm>
36#include <cassert>
37#include <cstdint>
38#include <cstdlib>
39#include <new>
40#include <utility>
41
42using namespace llvm;
43
44//===----------------------------------------------------------------------===//
45// Support for StructLayout
46//===----------------------------------------------------------------------===//
47
48StructLayout::StructLayout(StructType *ST, const DataLayout &DL)
49 : StructSize(TypeSize::getFixed(0)) {
50 assert(!ST->isOpaque() && "Cannot get layout of opaque structs");
51 IsPadded = false;
52 NumElements = ST->getNumElements();
53
54 // Loop over each of the elements, placing them in memory.
55 for (unsigned i = 0, e = NumElements; i != e; ++i) {
56 Type *Ty = ST->getElementType(i);
57 if (i == 0 && Ty->isScalableTy())
58 StructSize = TypeSize::getScalable(0);
59
60 const Align TyAlign = ST->isPacked() ? Align(1) : DL.getABITypeAlign(Ty);
61
62 // Add padding if necessary to align the data element properly.
63 // Currently the only structure with scalable size will be the homogeneous
64 // scalable vector types. Homogeneous scalable vector types have members of
65 // the same data type so no alignment issue will happen. The condition here
66 // assumes so and needs to be adjusted if this assumption changes (e.g. we
67 // support structures with arbitrary scalable data type, or structure that
68 // contains both fixed size and scalable size data type members).
69 if (!StructSize.isScalable() && !isAligned(TyAlign, StructSize)) {
70 IsPadded = true;
71 StructSize = TypeSize::getFixed(alignTo(StructSize, TyAlign));
72 }
73
74 // Keep track of maximum alignment constraint.
75 StructAlignment = std::max(TyAlign, StructAlignment);
76
77 getMemberOffsets()[i] = StructSize;
78 // Consume space for this data item
79 StructSize += DL.getTypeAllocSize(Ty);
80 }
81
82 // Add padding to the end of the struct so that it could be put in an array
83 // and all array elements would be aligned correctly.
84 if (!StructSize.isScalable() && !isAligned(StructAlignment, StructSize)) {
85 IsPadded = true;
86 StructSize = TypeSize::getFixed(alignTo(StructSize, StructAlignment));
87 }
88}
89
90/// getElementContainingOffset - Given a valid offset into the structure,
91/// return the structure index that contains it.
93 assert(!StructSize.isScalable() &&
94 "Cannot get element at offset for structure containing scalable "
95 "vector types");
96 TypeSize Offset = TypeSize::getFixed(FixedOffset);
97 ArrayRef<TypeSize> MemberOffsets = getMemberOffsets();
98
99 const auto *SI = llvm::upper_bound(MemberOffsets, Offset,
100 [](TypeSize LHS, TypeSize RHS) -> bool {
101 return TypeSize::isKnownLT(LHS, RHS);
102 });
103 assert(SI != MemberOffsets.begin() && "Offset not in structure type!");
104 --SI;
105 assert(TypeSize::isKnownLE(*SI, Offset) && "upper_bound didn't work");
106 assert(
107 (SI == MemberOffsets.begin() || TypeSize::isKnownLE(*(SI - 1), Offset)) &&
108 (SI + 1 == MemberOffsets.end() ||
109 TypeSize::isKnownGT(*(SI + 1), Offset)) &&
110 "Upper bound didn't work!");
111
112 // Multiple fields can have the same offset if any of them are zero sized.
113 // For example, in { i32, [0 x i32], i32 }, searching for offset 4 will stop
114 // at the i32 element, because it is the last element at that offset. This is
115 // the right one to return, because anything after it will have a higher
116 // offset, implying that this element is non-empty.
117 return SI - MemberOffsets.begin();
118}
119
120namespace {
121
122class StructLayoutMap {
123 using LayoutInfoTy = DenseMap<StructType *, StructLayout *>;
124 LayoutInfoTy LayoutInfo;
125
126public:
127 ~StructLayoutMap() {
128 // Remove any layouts.
129 for (const auto &I : LayoutInfo) {
130 StructLayout *Value = I.second;
131 Value->~StructLayout();
132 free(Value);
133 }
134 }
135
136 StructLayout *&operator[](StructType *STy) { return LayoutInfo[STy]; }
137};
138
139} // end anonymous namespace
140
141//===----------------------------------------------------------------------===//
142// DataLayout Class Implementation
143//===----------------------------------------------------------------------===//
144
146 return BitWidth == Other.BitWidth && ABIAlign == Other.ABIAlign &&
147 PrefAlign == Other.PrefAlign;
148}
149
151 return AddrSpace == Other.AddrSpace && BitWidth == Other.BitWidth &&
152 ABIAlign == Other.ABIAlign && PrefAlign == Other.PrefAlign &&
153 IndexBitWidth == Other.IndexBitWidth &&
154 HasUnstableRepresentation == Other.HasUnstableRepresentation &&
155 HasExternalState == Other.HasExternalState;
156}
157
158namespace {
159/// Predicate to sort primitive specs by bit width.
160struct LessPrimitiveBitWidth {
161 bool operator()(const DataLayout::PrimitiveSpec &LHS,
162 unsigned RHSBitWidth) const {
163 return LHS.BitWidth < RHSBitWidth;
164 }
165};
166
167/// Predicate to sort pointer specs by address space number.
168struct LessPointerAddrSpace {
169 bool operator()(const DataLayout::PointerSpec &LHS,
170 unsigned RHSAddrSpace) const {
171 return LHS.AddrSpace < RHSAddrSpace;
172 }
173};
174} // namespace
175
176// Default primitive type specifications.
177// NOTE: These arrays must be sorted by type bit width.
179 {8, Align::Constant<1>(), Align::Constant<1>()}, // i8:8:8
180 {16, Align::Constant<2>(), Align::Constant<2>()}, // i16:16:16
181 {32, Align::Constant<4>(), Align::Constant<4>()}, // i32:32:32
182 {64, Align::Constant<4>(), Align::Constant<8>()}, // i64:32:64
183};
185 {16, Align::Constant<2>(), Align::Constant<2>()}, // f16:16:16
186 {32, Align::Constant<4>(), Align::Constant<4>()}, // f32:32:32
187 {64, Align::Constant<8>(), Align::Constant<8>()}, // f64:64:64
188 {128, Align::Constant<16>(), Align::Constant<16>()}, // f128:128:128
189};
191 {64, Align::Constant<8>(), Align::Constant<8>()}, // v64:64:64
192 {128, Align::Constant<16>(), Align::Constant<16>()}, // v128:128:128
193};
194
195// Default pointer type specifications.
197 // p0:64:64:64:64
198 {0, 64, Align::Constant<8>(), Align::Constant<8>(), 64, false, false},
199};
200
202 : IntSpecs(ArrayRef(DefaultIntSpecs)),
203 FloatSpecs(ArrayRef(DefaultFloatSpecs)),
204 VectorSpecs(ArrayRef(DefaultVectorSpecs)),
205 PointerSpecs(ArrayRef(DefaultPointerSpecs)) {}
206
208 if (Error Err = parseLayoutString(LayoutString))
209 report_fatal_error(std::move(Err));
210}
211
213 delete static_cast<StructLayoutMap *>(LayoutMap);
214 LayoutMap = nullptr;
215 StringRepresentation = Other.StringRepresentation;
216 BigEndian = Other.BigEndian;
217 AllocaAddrSpace = Other.AllocaAddrSpace;
218 ProgramAddrSpace = Other.ProgramAddrSpace;
219 DefaultGlobalsAddrSpace = Other.DefaultGlobalsAddrSpace;
220 StackNaturalAlign = Other.StackNaturalAlign;
221 FunctionPtrAlign = Other.FunctionPtrAlign;
222 TheFunctionPtrAlignType = Other.TheFunctionPtrAlignType;
223 ManglingMode = Other.ManglingMode;
224 LegalIntWidths = Other.LegalIntWidths;
225 IntSpecs = Other.IntSpecs;
226 FloatSpecs = Other.FloatSpecs;
227 VectorSpecs = Other.VectorSpecs;
228 PointerSpecs = Other.PointerSpecs;
229 StructABIAlignment = Other.StructABIAlignment;
230 StructPrefAlignment = Other.StructPrefAlignment;
231 return *this;
232}
233
235 // NOTE: StringRepresentation might differ, it is not canonicalized.
236 return BigEndian == Other.BigEndian &&
237 AllocaAddrSpace == Other.AllocaAddrSpace &&
238 ProgramAddrSpace == Other.ProgramAddrSpace &&
239 DefaultGlobalsAddrSpace == Other.DefaultGlobalsAddrSpace &&
240 StackNaturalAlign == Other.StackNaturalAlign &&
241 FunctionPtrAlign == Other.FunctionPtrAlign &&
242 TheFunctionPtrAlignType == Other.TheFunctionPtrAlignType &&
243 ManglingMode == Other.ManglingMode &&
244 LegalIntWidths == Other.LegalIntWidths && IntSpecs == Other.IntSpecs &&
245 FloatSpecs == Other.FloatSpecs && VectorSpecs == Other.VectorSpecs &&
246 PointerSpecs == Other.PointerSpecs &&
247 StructABIAlignment == Other.StructABIAlignment &&
248 StructPrefAlignment == Other.StructPrefAlignment;
249}
250
252 DataLayout Layout;
253 if (Error Err = Layout.parseLayoutString(LayoutString))
254 return std::move(Err);
255 return Layout;
256}
257
259 return createStringError("malformed specification, must be of the form \"" +
260 Format + "\"");
261}
262
263/// Attempts to parse an address space component of a specification.
264 static Error parseAddrSpace(StringRef Str, unsigned &AddrSpace) {
265 if (Str.empty())
266 return createStringError("address space component cannot be empty");
267
268 if (!to_integer(Str, AddrSpace, 10) || !isUInt<24>(AddrSpace))
269 return createStringError("address space must be a 24-bit integer");
270
271 return Error::success();
272}
273
274/// Attempts to parse a size component of a specification.
275 static Error parseSize(StringRef Str, unsigned &BitWidth,
276 StringRef Name = "size") {
277 if (Str.empty())
278 return createStringError(Name + " component cannot be empty");
279
280 if (!to_integer(Str, BitWidth, 10) || BitWidth == 0 || !isUInt<24>(BitWidth))
281 return createStringError(Name + " must be a non-zero 24-bit integer");
282
283 return Error::success();
284}
285
286/// Attempts to parse an alignment component of a specification.
287///
288/// On success, returns the value converted to byte amount in \p Alignment.
289/// If the value is zero and \p AllowZero is true, \p Alignment is set to one.
290///
291/// Return an error in a number of cases:
292/// - \p Str is empty or contains characters other than decimal digits;
293/// - the value is zero and \p AllowZero is false;
294/// - the value is too large;
295/// - the value is not a multiple of the byte width;
296/// - the value converted to byte amount is not not a power of two.
297 static Error parseAlignment(StringRef Str, Align &Alignment, StringRef Name,
298 bool AllowZero = false) {
299 if (Str.empty())
300 return createStringError(Name + " alignment component cannot be empty");
301
302 unsigned Value;
303 if (!to_integer(Str, Value, 10) || !isUInt<16>(Value))
304 return createStringError(Name + " alignment must be a 16-bit integer");
305
306 if (Value == 0) {
307 if (!AllowZero)
308 return createStringError(Name + " alignment must be non-zero");
309 Alignment = Align(1);
310 return Error::success();
311 }
312
313 constexpr unsigned ByteWidth = 8;
314 if (Value % ByteWidth || !isPowerOf2_32(Value / ByteWidth))
315 return createStringError(
316 Name + " alignment must be a power of two times the byte width");
317
318 Alignment = Align(Value / ByteWidth);
319 return Error::success();
320}
321
322Error DataLayout::parsePrimitiveSpec(StringRef Spec) {
323 // [ifv]<size>:<abi>[:<pref>]
324 SmallVector<StringRef, 3> Components;
325 char Specifier = Spec.front();
326 assert(Specifier == 'i' || Specifier == 'f' || Specifier == 'v');
327 Spec.drop_front().split(Components, ':');
328
329 if (Components.size() < 2 || Components.size() > 3)
330 return createSpecFormatError(Twine(Specifier) + "<size>:<abi>[:<pref>]");
331
332 // Size. Required, cannot be zero.
333 unsigned BitWidth;
334 if (Error Err = parseSize(Components[0], BitWidth))
335 return Err;
336
337 // ABI alignment.
338 Align ABIAlign;
339 if (Error Err = parseAlignment(Components[1], ABIAlign, "ABI"))
340 return Err;
341
342 if (Specifier == 'i' && BitWidth == 8 && ABIAlign != 1)
343 return createStringError("i8 must be 8-bit aligned");
344
345 // Preferred alignment. Optional, defaults to the ABI alignment.
346 Align PrefAlign = ABIAlign;
347 if (Components.size() > 2)
348 if (Error Err = parseAlignment(Components[2], PrefAlign, "preferred"))
349 return Err;
350
351 if (PrefAlign < ABIAlign)
352 return createStringError(
353 "preferred alignment cannot be less than the ABI alignment");
354
355 setPrimitiveSpec(Specifier, BitWidth, ABIAlign, PrefAlign);
356 return Error::success();
357}
358
359Error DataLayout::parseAggregateSpec(StringRef Spec) {
360 // a<size>:<abi>[:<pref>]
361 SmallVector<StringRef, 3> Components;
362 assert(Spec.front() == 'a');
363 Spec.drop_front().split(Components, ':');
364
365 if (Components.size() < 2 || Components.size() > 3)
366 return createSpecFormatError("a:<abi>[:<pref>]");
367
368 // According to LangRef, <size> component must be absent altogether.
369 // For backward compatibility, allow it to be specified, but require
370 // it to be zero.
371 if (!Components[0].empty()) {
372 unsigned BitWidth;
373 if (!to_integer(Components[0], BitWidth, 10) || BitWidth != 0)
374 return createStringError("size must be zero");
375 }
376
377 // ABI alignment. Required. Can be zero, meaning use one byte alignment.
378 Align ABIAlign;
379 if (Error Err =
380 parseAlignment(Components[1], ABIAlign, "ABI", /*AllowZero=*/true))
381 return Err;
382
383 // Preferred alignment. Optional, defaults to the ABI alignment.
384 Align PrefAlign = ABIAlign;
385 if (Components.size() > 2)
386 if (Error Err = parseAlignment(Components[2], PrefAlign, "preferred"))
387 return Err;
388
389 if (PrefAlign < ABIAlign)
390 return createStringError(
391 "preferred alignment cannot be less than the ABI alignment");
392
393 StructABIAlignment = ABIAlign;
394 StructPrefAlignment = PrefAlign;
395 return Error::success();
396}
397
398Error DataLayout::parsePointerSpec(StringRef Spec) {
399 // p[<n>]:<size>:<abi>[:<pref>[:<idx>]]
400 SmallVector<StringRef, 5> Components;
401 assert(Spec.front() == 'p');
402 Spec.drop_front().split(Components, ':');
403
404 if (Components.size() < 3 || Components.size() > 5)
405 return createSpecFormatError("p[<n>]:<size>:<abi>[:<pref>[:<idx>]]");
406
407 // Address space. Optional, defaults to 0.
408 unsigned AddrSpace = 0;
409 bool ExternalState = false;
410 bool UnstableRepr = false;
411 StringRef AddrSpaceStr = Components[0];
412 while (!AddrSpaceStr.empty()) {
413 char C = AddrSpaceStr.front();
414 if (C == 'e') {
415 ExternalState = true;
416 } else if (C == 'u') {
417 UnstableRepr = true;
418 } else if (isAlpha(C)) {
419 return createStringError("'%c' is not a valid pointer specification flag",
420 C);
421 } else {
422 break; // not a valid flag, remaining must be the address space number.
423 }
424 AddrSpaceStr = AddrSpaceStr.drop_front(1);
425 }
426 if (!AddrSpaceStr.empty())
427 if (Error Err = parseAddrSpace(AddrSpaceStr, AddrSpace))
428 return Err; // Failed to parse the remaining characters as a number
429 if (AddrSpace == 0 && (ExternalState || UnstableRepr))
430 return createStringError(
431 "address space 0 cannot be unstable or have external state");
432
433 // Size. Required, cannot be zero.
434 unsigned BitWidth;
435 if (Error Err = parseSize(Components[1], BitWidth, "pointer size"))
436 return Err;
437
438 // ABI alignment. Required, cannot be zero.
439 Align ABIAlign;
440 if (Error Err = parseAlignment(Components[2], ABIAlign, "ABI"))
441 return Err;
442
443 // Preferred alignment. Optional, defaults to the ABI alignment.
444 // Cannot be zero.
445 Align PrefAlign = ABIAlign;
446 if (Components.size() > 3)
447 if (Error Err = parseAlignment(Components[3], PrefAlign, "preferred"))
448 return Err;
449
450 if (PrefAlign < ABIAlign)
451 return createStringError(
452 "preferred alignment cannot be less than the ABI alignment");
453
454 // Index size. Optional, defaults to pointer size. Cannot be zero.
455 unsigned IndexBitWidth = BitWidth;
456 if (Components.size() > 4)
457 if (Error Err = parseSize(Components[4], IndexBitWidth, "index size"))
458 return Err;
459
460 if (IndexBitWidth > BitWidth)
461 return createStringError(
462 "index size cannot be larger than the pointer size");
463
464 setPointerSpec(AddrSpace, BitWidth, ABIAlign, PrefAlign, IndexBitWidth,
465 UnstableRepr, ExternalState);
466 return Error::success();
467}
468
469Error DataLayout::parseSpecification(
470 StringRef Spec, SmallVectorImpl<unsigned> &NonIntegralAddressSpaces) {
471 // The "ni" specifier is the only two-character specifier. Handle it first.
472 if (Spec.starts_with("ni")) {
473 // ni:<address space>[:<address space>]...
474 StringRef Rest = Spec.drop_front(2);
475
476 // Drop the first ':', then split the rest of the string the usual way.
477 if (!Rest.consume_front(":"))
478 return createSpecFormatError("ni:<address space>[:<address space>]...");
479
480 for (StringRef Str : split(Rest, ':')) {
481 unsigned AddrSpace;
482 if (Error Err = parseAddrSpace(Str, AddrSpace))
483 return Err;
484 if (AddrSpace == 0)
485 return createStringError("address space 0 cannot be non-integral");
486 NonIntegralAddressSpaces.push_back(AddrSpace);
487 }
488 return Error::success();
489 }
490
491 // The rest of the specifiers are single-character.
492 assert(!Spec.empty() && "Empty specification is handled by the caller");
493 char Specifier = Spec.front();
494
495 if (Specifier == 'i' || Specifier == 'f' || Specifier == 'v')
496 return parsePrimitiveSpec(Spec);
497
498 if (Specifier == 'a')
499 return parseAggregateSpec(Spec);
500
501 if (Specifier == 'p')
502 return parsePointerSpec(Spec);
503
504 StringRef Rest = Spec.drop_front();
505 switch (Specifier) {
506 case 's':
507 // Deprecated, but ignoring here to preserve loading older textual llvm
508 // ASM file
509 break;
510 case 'e':
511 case 'E':
512 if (!Rest.empty())
513 return createStringError(
514 "malformed specification, must be just 'e' or 'E'");
515 BigEndian = Specifier == 'E';
516 break;
517 case 'n': // Native integer types.
518 // n<size>[:<size>]...
519 for (StringRef Str : split(Rest, ':')) {
520 unsigned BitWidth;
521 if (Error Err = parseSize(Str, BitWidth))
522 return Err;
523 LegalIntWidths.push_back(BitWidth);
524 }
525 break;
526 case 'S': { // Stack natural alignment.
527 // S<size>
528 if (Rest.empty())
529 return createSpecFormatError("S<size>");
530 Align Alignment;
531 if (Error Err = parseAlignment(Rest, Alignment, "stack natural"))
532 return Err;
533 StackNaturalAlign = Alignment;
534 break;
535 }
536 case 'F': {
537 // F<type><abi>
538 if (Rest.empty())
539 return createSpecFormatError("F<type><abi>");
540 char Type = Rest.front();
541 Rest = Rest.drop_front();
542 switch (Type) {
543 case 'i':
544 TheFunctionPtrAlignType = FunctionPtrAlignType::Independent;
545 break;
546 case 'n':
547 TheFunctionPtrAlignType = FunctionPtrAlignType::MultipleOfFunctionAlign;
548 break;
549 default:
550 return createStringError("unknown function pointer alignment type '" +
551 Twine(Type) + "'");
552 }
553 Align Alignment;
554 if (Error Err = parseAlignment(Rest, Alignment, "ABI"))
555 return Err;
556 FunctionPtrAlign = Alignment;
557 break;
558 }
559 case 'P': { // Function address space.
560 if (Rest.empty())
561 return createSpecFormatError("P<address space>");
562 if (Error Err = parseAddrSpace(Rest, ProgramAddrSpace))
563 return Err;
564 break;
565 }
566 case 'A': { // Default stack/alloca address space.
567 if (Rest.empty())
568 return createSpecFormatError("A<address space>");
569 if (Error Err = parseAddrSpace(Rest, AllocaAddrSpace))
570 return Err;
571 break;
572 }
573 case 'G': { // Default address space for global variables.
574 if (Rest.empty())
575 return createSpecFormatError("G<address space>");
576 if (Error Err = parseAddrSpace(Rest, DefaultGlobalsAddrSpace))
577 return Err;
578 break;
579 }
580 case 'm':
581 if (!Rest.consume_front(":") || Rest.empty())
582 return createSpecFormatError("m:<mangling>");
583 if (Rest.size() > 1)
584 return createStringError("unknown mangling mode");
585 switch (Rest[0]) {
586 default:
587 return createStringError("unknown mangling mode");
588 case 'e':
589 ManglingMode = MM_ELF;
590 break;
591 case 'l':
592 ManglingMode = MM_GOFF;
593 break;
594 case 'o':
595 ManglingMode = MM_MachO;
596 break;
597 case 'm':
598 ManglingMode = MM_Mips;
599 break;
600 case 'w':
601 ManglingMode = MM_WinCOFF;
602 break;
603 case 'x':
604 ManglingMode = MM_WinCOFFX86;
605 break;
606 case 'a':
607 ManglingMode = MM_XCOFF;
608 break;
609 }
610 break;
611 default:
612 return createStringError("unknown specifier '" + Twine(Specifier) + "'");
613 }
614
615 return Error::success();
616}
617
618Error DataLayout::parseLayoutString(StringRef LayoutString) {
619 StringRepresentation = std::string(LayoutString);
620
621 if (LayoutString.empty())
622 return Error::success();
623
624 // Split the data layout string into specifications separated by '-' and
625 // parse each specification individually, updating internal data structures.
626 SmallVector<unsigned, 8> NonIntegralAddressSpaces;
627 for (StringRef Spec : split(LayoutString, '-')) {
628 if (Spec.empty())
629 return createStringError("empty specification is not allowed");
630 if (Error Err = parseSpecification(Spec, NonIntegralAddressSpaces))
631 return Err;
632 }
633 // Mark all address spaces that were qualified as non-integral now. This has
634 // to be done later since the non-integral property is not part of the data
635 // layout pointer specification.
636 for (unsigned AS : NonIntegralAddressSpaces) {
637 // If there is no special spec for a given AS, getPointerSpec(AS) returns
638 // the spec for AS0, and we then update that to mark it non-integral.
639 const PointerSpec &PS = getPointerSpec(AS);
640 setPointerSpec(AS, PS.BitWidth, PS.ABIAlign, PS.PrefAlign, PS.IndexBitWidth,
641 /*HasUnstableRepr=*/true, /*HasExternalState=*/false);
642 }
643
644 return Error::success();
645}
646
647void DataLayout::setPrimitiveSpec(char Specifier, uint32_t BitWidth,
648 Align ABIAlign, Align PrefAlign) {
649 SmallVectorImpl<PrimitiveSpec> *Specs;
650 switch (Specifier) {
651 default:
652 llvm_unreachable("Unexpected specifier");
653 case 'i':
654 Specs = &IntSpecs;
655 break;
656 case 'f':
657 Specs = &FloatSpecs;
658 break;
659 case 'v':
660 Specs = &VectorSpecs;
661 break;
662 }
663
664 auto I = lower_bound(*Specs, BitWidth, LessPrimitiveBitWidth());
665 if (I != Specs->end() && I->BitWidth == BitWidth) {
666 // Update the abi, preferred alignments.
667 I->ABIAlign = ABIAlign;
668 I->PrefAlign = PrefAlign;
669 } else {
670 // Insert before I to keep the vector sorted.
671 Specs->insert(I, PrimitiveSpec{BitWidth, ABIAlign, PrefAlign});
672 }
673}
674
675const DataLayout::PointerSpec &
676DataLayout::getPointerSpec(uint32_t AddrSpace) const {
677 if (AddrSpace != 0) {
678 auto I = lower_bound(PointerSpecs, AddrSpace, LessPointerAddrSpace());
679 if (I != PointerSpecs.end() && I->AddrSpace == AddrSpace)
680 return *I;
681 }
682
683 assert(PointerSpecs[0].AddrSpace == 0);
684 return PointerSpecs[0];
685}
686
687void DataLayout::setPointerSpec(uint32_t AddrSpace, uint32_t BitWidth,
688 Align ABIAlign, Align PrefAlign,
689 uint32_t IndexBitWidth, bool HasUnstableRepr,
690 bool HasExternalState) {
691 auto I = lower_bound(PointerSpecs, AddrSpace, LessPointerAddrSpace());
692 if (I == PointerSpecs.end() || I->AddrSpace != AddrSpace) {
693 PointerSpecs.insert(I, PointerSpec{AddrSpace, BitWidth, ABIAlign, PrefAlign,
694 IndexBitWidth, HasUnstableRepr,
695 HasExternalState});
696 } else {
697 I->BitWidth = BitWidth;
698 I->ABIAlign = ABIAlign;
699 I->PrefAlign = PrefAlign;
700 I->IndexBitWidth = IndexBitWidth;
701 I->HasUnstableRepresentation = HasUnstableRepr;
702 I->HasExternalState = HasExternalState;
703 }
704}
705
706Align DataLayout::getIntegerAlignment(uint32_t BitWidth,
707 bool abi_or_pref) const {
708 auto I = IntSpecs.begin();
709 for (; I != IntSpecs.end(); ++I) {
710 if (I->BitWidth >= BitWidth)
711 break;
712 }
713
714 // If we don't have an exact match, use alignment of next larger integer
715 // type. If there is none, use alignment of largest integer type by going
716 // back one element.
717 if (I == IntSpecs.end())
718 --I;
719 return abi_or_pref ? I->ABIAlign : I->PrefAlign;
720}
721
722 DataLayout::~DataLayout() { delete static_cast<StructLayoutMap *>(LayoutMap); }
723
725 if (!LayoutMap)
726 LayoutMap = new StructLayoutMap();
727
728 StructLayoutMap *STM = static_cast<StructLayoutMap*>(LayoutMap);
729 StructLayout *&SL = (*STM)[Ty];
730 if (SL) return SL;
731
732 // Otherwise, create the struct layout. Because it is variable length, we
733 // malloc it, then use placement new.
735 StructLayout::totalSizeToAlloc<TypeSize>(Ty->getNumElements()));
736
737 // Set SL before calling StructLayout's ctor. The ctor could cause other
738 // entries to be added to TheMap, invalidating our reference.
739 SL = L;
740
741 new (L) StructLayout(Ty, *this);
742
743 return L;
744}
745
747 return getPointerSpec(AS).ABIAlign;
748}
749
751 return getPointerSpec(AS).PrefAlign;
752}
753
754 unsigned DataLayout::getPointerSize(unsigned AS) const {
755 return divideCeil(getPointerSpec(AS).BitWidth, 8);
756}
757
759 assert(Ty->isPtrOrPtrVectorTy() &&
760 "This should only be called with a pointer or pointer vector type");
761 Ty = Ty->getScalarType();
763}
764
765 unsigned DataLayout::getIndexSize(unsigned AS) const {
766 return divideCeil(getPointerSpec(AS).IndexBitWidth, 8);
767}
768
770 assert(Ty->isPtrOrPtrVectorTy() &&
771 "This should only be called with a pointer or pointer vector type");
772 Ty = Ty->getScalarType();
774}
775
776/*!
777 \param abi_or_pref Flag that determines which alignment is returned. true
778 returns the ABI alignment, false returns the preferred alignment.
779 \param Ty The underlying type for which alignment is determined.
780
781 Get the ABI (\a abi_or_pref == true) or preferred alignment (\a abi_or_pref
782 == false) for the requested type \a Ty.
783 */
784Align DataLayout::getAlignment(Type *Ty, bool abi_or_pref) const {
785 assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
786 switch (Ty->getTypeID()) {
787 // Early escape for the non-numeric types.
788 case Type::LabelTyID:
789 return abi_or_pref ? getPointerABIAlignment(0) : getPointerPrefAlignment(0);
790 case Type::PointerTyID: {
791 unsigned AS = cast<PointerType>(Ty)->getAddressSpace();
792 return abi_or_pref ? getPointerABIAlignment(AS)
793 : getPointerPrefAlignment(AS);
794 }
795 case Type::ArrayTyID:
796 return getAlignment(cast<ArrayType>(Ty)->getElementType(), abi_or_pref);
797
798 case Type::StructTyID: {
799 // Packed structure types always have an ABI alignment of one.
800 if (cast<StructType>(Ty)->isPacked() && abi_or_pref)
801 return Align(1);
802
803 // Get the layout annotation... which is lazily created on demand.
804 const StructLayout *Layout = getStructLayout(cast<StructType>(Ty));
805 const Align Align = abi_or_pref ? StructABIAlignment : StructPrefAlignment;
806 return std::max(Align, Layout->getAlignment());
807 }
808 case Type::IntegerTyID:
809 return getIntegerAlignment(Ty->getIntegerBitWidth(), abi_or_pref);
810 case Type::HalfTyID:
811 case Type::BFloatTyID:
812 case Type::FloatTyID:
813 case Type::DoubleTyID:
814 // PPC_FP128TyID and FP128TyID have different data contents, but the
815 // same size and alignment, so they look the same here.
816 case Type::PPC_FP128TyID:
817 case Type::FP128TyID:
818 case Type::X86_FP80TyID: {
819 unsigned BitWidth = getTypeSizeInBits(Ty).getFixedValue();
820 auto I = lower_bound(FloatSpecs, BitWidth, LessPrimitiveBitWidth());
821 if (I != FloatSpecs.end() && I->BitWidth == BitWidth)
822 return abi_or_pref ? I->ABIAlign : I->PrefAlign;
823
824 // If we still couldn't find a reasonable default alignment, fall back
825 // to a simple heuristic that the alignment is the first power of two
826 // greater-or-equal to the store size of the type. This is a reasonable
827 // approximation of reality, and if the user wanted something less
828 // less conservative, they should have specified it explicitly in the data
829 // layout.
830 return Align(PowerOf2Ceil(BitWidth / 8));
831 }
832 case Type::FixedVectorTyID:
833 case Type::ScalableVectorTyID: {
834 unsigned BitWidth = getTypeSizeInBits(Ty).getKnownMinValue();
835 auto I = lower_bound(VectorSpecs, BitWidth, LessPrimitiveBitWidth());
836 if (I != VectorSpecs.end() && I->BitWidth == BitWidth)
837 return abi_or_pref ? I->ABIAlign : I->PrefAlign;
838
839 // By default, use natural alignment for vector types. This is consistent
840 // with what clang and llvm-gcc do.
841 //
842 // We're only calculating a natural alignment, so it doesn't have to be
843 // based on the full size for scalable vectors. Using the minimum element
844 // count should be enough here.
845 return Align(PowerOf2Ceil(getTypeStoreSize(Ty).getKnownMinValue()));
846 }
847 case Type::X86_AMXTyID:
848 return Align(64);
849 case Type::TargetExtTyID: {
850 Type *LayoutTy = cast<TargetExtType>(Ty)->getLayoutType();
851 return getAlignment(LayoutTy, abi_or_pref);
852 }
853 default:
854 llvm_unreachable("Bad type for getAlignment!!!");
855 }
856}
857
859 switch (Ty->getTypeID()) {
860 case Type::ArrayTyID: {
861 // The alignment of the array is the alignment of the element, so there
862 // is no need for further adjustment.
863 auto *ATy = cast<ArrayType>(Ty);
864 return ATy->getNumElements() * getTypeAllocSize(ATy->getElementType());
865 }
866 case Type::StructTyID: {
867 const StructLayout *Layout = getStructLayout(cast<StructType>(Ty));
868 TypeSize Size = Layout->getSizeInBytes();
869
870 if (cast<StructType>(Ty)->isPacked())
871 return Size;
872
873 Align A = std::max(StructABIAlignment, Layout->getAlignment());
874 return alignTo(Size, A.value());
875 }
876 case Type::IntegerTyID: {
877 unsigned BitWidth = Ty->getIntegerBitWidth();
879 Align A = getIntegerAlignment(BitWidth, /*ABI=*/true);
880 return alignTo(Size, A.value());
881 }
882 case Type::PointerTyID: {
883 unsigned AS = Ty->getPointerAddressSpace();
885 return alignTo(Size, getPointerABIAlignment(AS).value());
886 }
887 case Type::TargetExtTyID: {
888 Type *LayoutTy = cast<TargetExtType>(Ty)->getLayoutType();
889 return getTypeAllocSize(LayoutTy);
890 }
891 default:
892 return alignTo(getTypeStoreSize(Ty), getABITypeAlign(Ty).value());
893 }
894}
895
897 return getAlignment(Ty, true);
898}
899
901 return getAlignment(Ty, false);
902}
903
908
910 assert(Ty->isPtrOrPtrVectorTy() &&
911 "Expected a pointer or pointer vector type.");
912 unsigned NumBits = getPointerTypeSizeInBits(Ty);
913 IntegerType *IntTy = IntegerType::get(Ty->getContext(), NumBits);
914 if (VectorType *VecTy = dyn_cast<VectorType>(Ty))
915 return VectorType::get(IntTy, VecTy);
916 return IntTy;
917}
918
920 for (unsigned LegalIntWidth : LegalIntWidths)
921 if (Width <= LegalIntWidth)
922 return Type::getIntNTy(C, LegalIntWidth);
923 return nullptr;
924}
925
927 auto Max = llvm::max_element(LegalIntWidths);
928 return Max != LegalIntWidths.end() ? *Max : 0;
929}
930
935
937 assert(Ty->isPtrOrPtrVectorTy() &&
938 "Expected a pointer or pointer vector type.");
939 unsigned NumBits = getIndexTypeSizeInBits(Ty);
940 IntegerType *IntTy = IntegerType::get(Ty->getContext(), NumBits);
941 if (VectorType *VecTy = dyn_cast<VectorType>(Ty))
942 return VectorType::get(IntTy, VecTy);
943 return IntTy;
944}
945
947 ArrayRef<Value *> Indices) const {
948 int64_t Result = 0;
949
951 GTI = gep_type_begin(ElemTy, Indices),
952 GTE = gep_type_end(ElemTy, Indices);
953 for (; GTI != GTE; ++GTI) {
954 Value *Idx = GTI.getOperand();
955 if (StructType *STy = GTI.getStructTypeOrNull()) {
956 assert(Idx->getType()->isIntegerTy(32) && "Illegal struct idx");
957 unsigned FieldNo = cast<ConstantInt>(Idx)->getZExtValue();
958
959 // Get structure layout information...
960 const StructLayout *Layout = getStructLayout(STy);
961
962 // Add in the offset, as calculated by the structure layout info...
963 Result += Layout->getElementOffset(FieldNo);
964 } else {
965 if (int64_t ArrayIdx = cast<ConstantInt>(Idx)->getSExtValue())
966 Result += ArrayIdx * GTI.getSequentialElementStride(*this);
967 }
968 }
969
970 return Result;
971}
972
974 // Skip over scalable or zero size elements. Also skip element sizes larger
975 // than the positive index space, because the arithmetic below may not be
976 // correct in that case.
977 unsigned BitWidth = Offset.getBitWidth();
978 if (ElemSize.isScalable() || ElemSize == 0 ||
979 !isUIntN(BitWidth - 1, ElemSize)) {
980 return APInt::getZero(BitWidth);
981 }
982
983 uint64_t FixedElemSize = ElemSize.getFixedValue();
984 APInt Index = Offset.sdiv(FixedElemSize);
985 Offset -= Index * FixedElemSize;
986 if (Offset.isNegative()) {
987 // Prefer a positive remaining offset to allow struct indexing.
988 --Index;
989 Offset += FixedElemSize;
990 assert(Offset.isNonNegative() && "Remaining offset shouldn't be negative");
991 }
992 return Index;
993}
994
995 std::optional<APInt> DataLayout::getGEPIndexForOffset(Type *&ElemTy,
996 APInt &Offset) const {
997 if (auto *ArrTy = dyn_cast<ArrayType>(ElemTy)) {
998 ElemTy = ArrTy->getElementType();
999 return getElementIndex(getTypeAllocSize(ElemTy), Offset);
1000 }
1001
1002 if (isa<VectorType>(ElemTy)) {
1003 // Vector GEPs are partially broken (e.g. for overaligned element types),
1004 // and may be forbidden in the future, so avoid generating GEPs into
1005 // vectors. See https://discourse.llvm.org/t/67497
1006 return std::nullopt;
1007 }
1008
1009 if (auto *STy = dyn_cast<StructType>(ElemTy)) {
1010 const StructLayout *SL = getStructLayout(STy);
1011 uint64_t IntOffset = Offset.getZExtValue();
1012 if (IntOffset >= SL->getSizeInBytes())
1013 return std::nullopt;
1014
1015 unsigned Index = SL->getElementContainingOffset(IntOffset);
1016 Offset -= SL->getElementOffset(Index);
1017 ElemTy = STy->getElementType(Index);
1018 return APInt(32, Index);
1019 }
1020
1021 // Non-aggregate type.
1022 return std::nullopt;
1023}
1024
1026 APInt &Offset) const {
1027 assert(ElemTy->isSized() && "Element type must be sized");
1028 SmallVector<APInt> Indices;
1030 while (Offset != 0) {
1031 std::optional<APInt> Index = getGEPIndexForOffset(ElemTy, Offset);
1032 if (!Index)
1033 break;
1034 Indices.push_back(*Index);
1035 }
1036
1037 return Indices;
1038}
1039
1040/// getPreferredAlign - Return the preferred alignment of the specified global.
1041/// This includes an explicitly requested alignment (if the global has one).
1043 MaybeAlign GVAlignment = GV->getAlign();
1044 // If a section is specified, always precisely honor explicit alignment,
1045 // so we don't insert padding into a section we don't control.
1046 if (GVAlignment && GV->hasSection())
1047 return *GVAlignment;
1048
1049 // If no explicit alignment is specified, compute the alignment based on
1050 // the IR type. If an alignment is specified, increase it to match the ABI
1051 // alignment of the IR type.
1052 //
1053 // FIXME: Not sure it makes sense to use the alignment of the type if
1054 // there's already an explicit alignment specification.
1055 Type *ElemType = GV->getValueType();
1056 Align Alignment = getPrefTypeAlign(ElemType);
1057 if (GVAlignment) {
1058 if (*GVAlignment >= Alignment)
1059 Alignment = *GVAlignment;
1060 else
1061 Alignment = std::max(*GVAlignment, getABITypeAlign(ElemType));
1062 }
1063
1064 // If no explicit alignment is specified, and the global is large, increase
1065 // the alignment to 16.
1066 // FIXME: Why 16, specifically?
1067 if (GV->hasInitializer() && !GVAlignment) {
1068 if (Alignment < Align(16)) {
1069 // If the global is not external, see if it is large. If so, give it a
1070 // larger alignment.
1071 if (getTypeSizeInBits(ElemType) > 128)
1072 Alignment = Align(16); // 16-byte alignment.
1073 }
1074 }
1075 return Alignment;
1076}
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
A
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
This file contains the declarations for the subclasses of Constant, which represent the different fla...
static Error parseSize(StringRef Str, unsigned &BitWidth, StringRef Name="size")
Attempts to parse a size component of a specification.
Definition DataLayout.cpp:275
static APInt getElementIndex(TypeSize ElemSize, APInt &Offset)
Definition DataLayout.cpp:973
static Error parseAddrSpace(StringRef Str, unsigned &AddrSpace)
Attempts to parse an address space component of a specification.
Definition DataLayout.cpp:264
static Error createSpecFormatError(Twine Format)
Definition DataLayout.cpp:258
static Error parseAlignment(StringRef Str, Align &Alignment, StringRef Name, bool AllowZero=false)
Attempts to parse an alignment component of a specification.
Definition DataLayout.cpp:297
constexpr DataLayout::PrimitiveSpec DefaultFloatSpecs[]
Definition DataLayout.cpp:184
constexpr DataLayout::PrimitiveSpec DefaultVectorSpecs[]
Definition DataLayout.cpp:190
constexpr DataLayout::PointerSpec DefaultPointerSpecs[]
Definition DataLayout.cpp:196
constexpr DataLayout::PrimitiveSpec DefaultIntSpecs[]
Definition DataLayout.cpp:178
This file defines the DenseMap class.
I
#define I(x, y, z)
Definition MD5.cpp:58
This file defines counterparts of C library allocation functions defined in the namespace 'std'.
static unsigned getAddressSpace(const Value *V, unsigned MaxLookup)
This file contains some functions that are useful when dealing with strings.
static uint32_t getAlignment(const MCSectionCOFF &Sec)
Value * LHS
Class for arbitrary precision integers.
Definition APInt.h:78
static APInt getZero(unsigned numBits)
Get the '0' value for the specified bit-width.
Definition APInt.h:201
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition ArrayRef.h:41
iterator end() const
Definition ArrayRef.h:132
iterator begin() const
Definition ArrayRef.h:131
A parsed version of the target data layout string in and methods for querying it.
Definition DataLayout.h:63
unsigned getPointerSizeInBits(unsigned AS=0) const
The size in bits of the pointer representation in a given address space.
Definition DataLayout.h:479
@ MultipleOfFunctionAlign
The function pointer alignment is a multiple of the function alignment.
Definition DataLayout.h:102
@ Independent
The function pointer alignment is independent of the function alignment.
Definition DataLayout.h:100
LLVM_ABI SmallVector< APInt > getGEPIndicesForOffset(Type *&ElemTy, APInt &Offset) const
Get GEP indices to access Offset inside ElemTy.
LLVM_ABI unsigned getLargestLegalIntTypeSizeInBits() const
Returns the size of largest legal integer type size, or 0 if none are set.
Definition DataLayout.cpp:926
LLVM_ABI unsigned getIndexSize(unsigned AS) const
The index size in bytes used for address calculation, rounded up to a whole number of bytes.
Definition DataLayout.cpp:765
LLVM_ABI 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:724
LLVM_ABI DataLayout()
Constructs a DataLayout with default values.
Definition DataLayout.cpp:201
LLVM_ABI 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:904
LLVM_ABI Align getABITypeAlign(Type *Ty) const
Returns the minimum ABI-required alignment for the specified type.
Definition DataLayout.cpp:896
LLVM_ABI unsigned getIndexTypeSizeInBits(Type *Ty) const
The size in bits of the index used in GEP calculation for this type.
Definition DataLayout.cpp:769
LLVM_ABI unsigned getPointerTypeSizeInBits(Type *) const
The pointer representation size in bits for this type.
Definition DataLayout.cpp:758
LLVM_ABI DataLayout & operator=(const DataLayout &Other)
Definition DataLayout.cpp:212
LLVM_ABI IntegerType * getIndexType(LLVMContext &C, unsigned AddressSpace) const
Returns the type of a GEP index in AddressSpace.
Definition DataLayout.cpp:931
LLVM_ABI TypeSize getTypeAllocSize(Type *Ty) const
Returns the offset in bytes between successive objects of the specified type, including alignment pad...
Definition DataLayout.cpp:858
LLVM_ABI std::optional< APInt > getGEPIndexForOffset(Type *&ElemTy, APInt &Offset) const
Get single GEP index to access Offset inside ElemTy.
Definition DataLayout.cpp:995
LLVM_ABI 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:919
LLVM_ABI Align getPreferredAlign(const GlobalVariable *GV) const
Returns the preferred alignment of the specified global.
LLVM_ABI ~DataLayout()
Definition DataLayout.cpp:722
LLVM_ABI unsigned getPointerSize(unsigned AS=0) const
The pointer representation size in bytes, rounded up to a whole number of bytes.
Definition DataLayout.cpp:754
LLVM_ABI 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:750
unsigned getIndexSizeInBits(unsigned AS) const
The size in bits of indices used for address calculation in getelementptr and for addresses in the gi...
Definition DataLayout.h:487
TypeSize getTypeSizeInBits(Type *Ty) const
Size examples:
Definition DataLayout.h:760
TypeSize getTypeStoreSize(Type *Ty) const
Returns the maximum number of bytes that may be overwritten by storing the specified type.
Definition DataLayout.h:557
LLVM_ABI bool operator==(const DataLayout &Other) const
Definition DataLayout.cpp:234
LLVM_ABI 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:946
LLVM_ABI Align getPointerABIAlignment(unsigned AS) const
Layout pointer alignment.
Definition DataLayout.cpp:746
LLVM_ABI Align getPrefTypeAlign(Type *Ty) const
Returns the preferred stack/global alignment for the specified type.
Definition DataLayout.cpp:900
static LLVM_ABI Expected< DataLayout > parse(StringRef LayoutString)
Parse a data layout string and return the layout.
Definition DataLayout.cpp:251
Lightweight error class with error context and mandatory checking.
Definition Error.h:159
static ErrorSuccess success()
Create a success value.
Definition Error.h:336
Tagged union holding either a T or a Error.
Definition Error.h:485
bool hasSection() const
Check if this global has a custom object file section.
Definition GlobalObject.h:106
Type * getValueType() const
Definition GlobalValue.h:298
bool hasInitializer() const
Definitions have initializers, declarations don't.
MaybeAlign getAlign() const
Returns the alignment of the given variable.
Class to represent integer types.
Definition DerivedTypes.h:42
static LLVM_ABI IntegerType * get(LLVMContext &C, unsigned NumBits)
This static method is the primary way of constructing an IntegerType.
Definition Type.cpp:319
This is an important class for using LLVM in a threaded context.
Definition LLVMContext.h:68
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition SmallVector.h:574
iterator insert(iterator I, T &&Elt)
Definition SmallVector.h:812
void push_back(const T &Elt)
Definition SmallVector.h:417
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition SmallVector.h:1203
StringRef - Represent a constant reference to a string, i.e.
Definition StringRef.h:55
std::pair< StringRef, StringRef > split(char Separator) const
Split into two substrings around the first occurrence of a separator character.
Definition StringRef.h:702
bool starts_with(StringRef Prefix) const
Check if this string starts with the given Prefix.
Definition StringRef.h:261
constexpr bool empty() const
empty - Check if the string is empty.
Definition StringRef.h:143
StringRef drop_front(size_t N=1) const
Return a StringRef equal to 'this' but with the first N elements dropped.
Definition StringRef.h:611
constexpr size_t size() const
size - Get the string size.
Definition StringRef.h:146
char front() const
front - Get the first character in the string.
Definition StringRef.h:149
bool consume_front(StringRef Prefix)
Returns true if this StringRef has the given prefix and removes that prefix.
Definition StringRef.h:637
Used to lazily calculate structure layout information for a target machine, based on the DataLayout s...
Definition DataLayout.h:712
TypeSize getSizeInBytes() const
Definition DataLayout.h:721
MutableArrayRef< TypeSize > getMemberOffsets()
Definition DataLayout.h:735
LLVM_ABI unsigned getElementContainingOffset(uint64_t FixedOffset) const
Given a valid byte offset into the structure, returns the structure index that contains it.
Definition DataLayout.cpp:92
TypeSize getElementOffset(unsigned Idx) const
Definition DataLayout.h:743
Align getAlignment() const
Definition DataLayout.h:725
Class to represent struct types.
Definition DerivedTypes.h:218
static constexpr std::enable_if_t< std::is_same_v< Foo< TrailingTys... >, Foo< Tys... > >, size_t > totalSizeToAlloc(typename trailing_objects_internal::ExtractSecondType< TrailingTys, size_t >::type... Counts)
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition Twine.h:82
static constexpr TypeSize getFixed(ScalarTy ExactSize)
Definition TypeSize.h:344
static constexpr TypeSize getScalable(ScalarTy MinimumSize)
Definition TypeSize.h:347
The instances of the Type class are immutable: once they are created, they are never changed.
Definition Type.h:45
LLVM_ABI unsigned getIntegerBitWidth() const
Definition DerivedTypes.h:99
@ X86_AMXTyID
AMX vectors (8192 bits, X86 specific)
Definition Type.h:66
@ ArrayTyID
Arrays.
Definition Type.h:74
@ HalfTyID
16-bit floating point type
Definition Type.h:56
@ TargetExtTyID
Target extension type.
Definition Type.h:78
@ ScalableVectorTyID
Scalable SIMD vector type.
Definition Type.h:76
@ LabelTyID
Labels.
Definition Type.h:64
@ FloatTyID
32-bit floating point type
Definition Type.h:58
@ StructTyID
Structures.
Definition Type.h:73
@ IntegerTyID
Arbitrary bit width integers.
Definition Type.h:70
@ FixedVectorTyID
Fixed width SIMD vector type.
Definition Type.h:75
@ BFloatTyID
16-bit floating point type (7-bit significand)
Definition Type.h:57
@ DoubleTyID
64-bit floating point type
Definition Type.h:59
@ X86_FP80TyID
80-bit floating point type (X87)
Definition Type.h:60
@ PPC_FP128TyID
128-bit floating point type (two 64-bits, PowerPC)
Definition Type.h:62
@ PointerTyID
Pointers.
Definition Type.h:72
@ FP128TyID
128-bit floating point type (112-bit significand)
Definition Type.h:61
bool isIntegerTy() const
True if this is an instance of IntegerType.
Definition Type.h:240
static LLVM_ABI IntegerType * getIntNTy(LLVMContext &C, unsigned N)
Definition Type.cpp:301
LLVM Value Representation.
Definition Value.h:75
Type * getType() const
All values are typed, get the type of this value.
Definition Value.h:256
Base class of all SIMD vector types.
Definition DerivedTypes.h:430
static LLVM_ABI VectorType * get(Type *ElementType, ElementCount EC)
This static method is the primary way to construct an VectorType.
constexpr ScalarTy getFixedValue() const
Definition TypeSize.h:201
static constexpr bool isKnownLE(const FixedOrScalableQuantity &LHS, const FixedOrScalableQuantity &RHS)
Definition TypeSize.h:231
static constexpr bool isKnownLT(const FixedOrScalableQuantity &LHS, const FixedOrScalableQuantity &RHS)
Definition TypeSize.h:217
constexpr bool isScalable() const
Returns whether the quantity is scaled by a runtime quantity (vscale).
Definition TypeSize.h:169
constexpr ScalarTy getKnownMinValue() const
Returns the minimum value this quantity can represent.
Definition TypeSize.h:166
static constexpr bool isKnownGT(const FixedOrScalableQuantity &LHS, const FixedOrScalableQuantity &RHS)
Definition TypeSize.h:224
StructType * getStructTypeOrNull() const
TypeSize getSequentialElementStride(const DataLayout &DL) const
Value * getOperand() const
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
constexpr char Align[]
Key for Kernel::Arg::Metadata::mAlign.
@ ST
Definition ARMBaseInfo.h:73
@ C
The default llvm calling convention, compatible with C.
Definition CallingConv.h:34
constexpr double e
bool empty() const
Definition BasicBlock.h:101
This is an optimization pass for GlobalISel generic memory operations.
Definition AddressRanges.h:18
@ Offset
Definition DWP.cpp:477
decltype(auto) dyn_cast(const From &Val)
dyn_cast<X> - Return the argument parameter cast to the specified type.
Definition Casting.h:643
bool isAligned(Align Lhs, uint64_t SizeInBytes)
Checks that SizeInBytes is a multiple of the alignment.
Definition Alignment.h:134
constexpr bool isUIntN(unsigned N, uint64_t x)
Checks if an unsigned integer fits into the given (dynamic) bit width.
Definition MathExtras.h:243
gep_type_iterator gep_type_end(const User *GEP)
auto upper_bound(R &&Range, T &&Value)
Provide wrappers to std::upper_bound which take ranges instead of having to pass begin/end explicitly...
Definition STLExtras.h:2007
Error createStringError(std::error_code EC, char const *Fmt, const Ts &... Vals)
Create formatted StringError object.
Definition Error.h:1305
uint64_t PowerOf2Ceil(uint64_t A)
Returns the power of two which is greater than or equal to the given value.
Definition MathExtras.h:385
bool isAlpha(char C)
Checks if character C is a valid letter as classified by "C" locale.
Definition StringExtras.h:118
constexpr bool isPowerOf2_32(uint32_t Value)
Return true if the argument is a power of two > 0.
Definition MathExtras.h:279
LLVM_ABI void report_fatal_error(Error Err, bool gen_crash_diag=true)
Definition Error.cpp:167
constexpr bool isUInt(uint64_t x)
Checks if an unsigned integer fits into the given bit width.
Definition MathExtras.h:189
LLVM_ATTRIBUTE_RETURNS_NONNULL void * safe_malloc(size_t Sz)
Definition MemAlloc.h:25
iterator_range< SplittingIterator > split(StringRef Str, StringRef Separator)
Split the specified string over a separator and return a range-compatible iterable over its partition...
Definition StringExtras.h:613
class LLVM_GSL_OWNER SmallVector
Forward declaration of SmallVector so that calculateSmallVectorDefaultInlinedElements can reference s...
Definition SmallVector.h:1129
bool isa(const From &Val)
isa<X> - Return true if the parameter to the template is an instance of one of the template type argu...
Definition Casting.h:547
constexpr T divideCeil(U Numerator, V Denominator)
Returns the integer ceil(Numerator / Denominator).
Definition MathExtras.h:394
@ Other
Any other memory.
Definition ModRef.h:68
auto lower_bound(R &&Range, T &&Value)
Provide wrappers to std::lower_bound which take ranges instead of having to pass begin/end explicitly...
Definition STLExtras.h:1994
uint64_t alignTo(uint64_t Size, Align A)
Returns a multiple of A needed to store Size bytes.
Definition Alignment.h:144
auto max_element(R &&Range)
Provide wrappers to std::max_element which take ranges instead of having to pass begin/end explicitly...
Definition STLExtras.h:2030
constexpr unsigned BitWidth
Definition BitmaskEnum.h:220
decltype(auto) cast(const From &Val)
cast<X> - Return the argument parameter cast to the specified type.
Definition Casting.h:559
gep_type_iterator gep_type_begin(const User *GEP)
bool to_integer(StringRef S, N &Num, unsigned Base=0)
Convert the string S to an integer of the specified type using the radix Base. If Base is 0,...
Definition StringExtras.h:292
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition Alignment.h:39
static constexpr Align Constant()
Allow constructions of constexpr Align.
Definition Alignment.h:88
Pointer type specification.
Definition DataLayout.h:75
bool HasUnstableRepresentation
Pointers in this address space don't have a well-defined bitwise representation (e....
Definition DataLayout.h:89
LLVM_ABI bool operator==(const PointerSpec &Other) const
Definition DataLayout.cpp:150
bool HasExternalState
Pointers in this address space have additional state bits that are located at a target-defined locati...
Definition DataLayout.h:94
uint32_t IndexBitWidth
The index bit width also defines the address size in this address space.
Definition DataLayout.h:85
Primitive type specification.
Definition DataLayout.h:66
LLVM_ABI bool operator==(const PrimitiveSpec &Other) const
Definition DataLayout.cpp:145
This struct is a compact representation of a valid (power of two) or undefined (0) alignment.
Definition Alignment.h:106
Generated on for LLVM by doxygen 1.14.0

AltStyle によって変換されたページ (->オリジナル) /