25#include "llvm/Config/llvm-config.h"
60 const std::optional<unsigned> &NumElemsArg) {
62 "Attempting to pack a reserved value");
68static std::pair<unsigned, std::optional<unsigned>>
70 unsigned NumElems = Num & std::numeric_limits<unsigned>::max();
71 unsigned ElemSizeArg = Num >> 32;
73 std::optional<unsigned> NumElemsArg;
75 NumElemsArg = NumElems;
76 return std::make_pair(ElemSizeArg, NumElemsArg);
80 std::optional<unsigned> MaxValue) {
81 return uint64_t(MinValue) << 32 | MaxValue.value_or(0);
84static std::pair<unsigned, std::optional<unsigned>>
86 unsigned MaxValue =
Value & std::numeric_limits<unsigned>::max();
87 unsigned MinValue =
Value >> 32;
89 return std::make_pair(MinValue,
90 MaxValue > 0 ? MaxValue : std::optional<unsigned>());
97 "Not an enum or int attribute");
105 assert(Val == 0 &&
"Value must be zero for enum attributes");
117 pImpl->
AttrsSet.InsertNode(PA, InsertPoint);
128 if (!Val.
empty())
ID.AddString(Val);
140 pImpl->
AttrsSet.InsertNode(PA, InsertPoint);
162 pImpl->
AttrsSet.InsertNode(PA, InsertPoint);
172 "Not a ConstantRange attribute");
187 pImpl->
AttrsSet.InsertNode(PA, InsertPoint);
200 assert(
A <= 0x100 &&
"Alignment too large.");
206 assert(Bytes &&
"Bytes must be non-zero.");
212 assert(Bytes &&
"Bytes must be non-zero.");
213 return get(
Context, DereferenceableOrNull, Bytes);
253 const std::optional<unsigned> &NumElemsArg) {
254 assert(!(ElemSizeArg == 0 && NumElemsArg && *NumElemsArg == 0) &&
255 "Invalid allocsize arguments -- given allocsize(0, 0)");
267#define GET_ATTR_NAMES
268#define ATTRIBUTE_ENUM(ENUM_NAME, DISPLAY_NAME) \
269 .Case(#DISPLAY_NAME, Attribute::ENUM_NAME)
270#include "llvm/IR/Attributes.inc"
276#define GET_ATTR_NAMES
277#define ATTRIBUTE_ENUM(ENUM_NAME, DISPLAY_NAME) \
278 case Attribute::ENUM_NAME: \
279 return #DISPLAY_NAME;
280#include "llvm/IR/Attributes.inc"
290#define GET_ATTR_NAMES
291#define ATTRIBUTE_ALL(ENUM_NAME, DISPLAY_NAME) .Case(#DISPLAY_NAME, true)
292#include "llvm/IR/Attributes.inc"
321 if (!pImpl)
return None;
324 "Invalid attribute type to get the kind as an enum!");
329 if (!pImpl)
return 0;
331 "Expected the attribute to be an integer attribute!");
336 if (!pImpl)
return false;
338 "Expected the attribute to be a string attribute!");
343 if (!pImpl)
return {};
345 "Invalid attribute type to get the kind as a string!");
350 if (!pImpl)
return {};
352 "Invalid attribute type to get the value as a string!");
357 if (!pImpl)
return {};
359 "Invalid attribute type to get the value as a type!");
365 "Invalid attribute type to get the value as a ConstantRange!");
380 "Trying to get alignment from non-alignment attribute!");
386 "Trying to get alignment from non-alignment attribute!");
392 "Trying to get dereferenceable bytes from "
393 "non-dereferenceable attribute!");
399 "Trying to get dereferenceable bytes from "
400 "non-dereferenceable attribute!");
404std::pair<unsigned, std::optional<unsigned>>
407 "Trying to get allocsize args from non-allocsize attribute");
413 "Trying to get vscale args from non-vscale attribute");
419 "Trying to get vscale args from non-vscale attribute");
425 "Trying to get unwind table kind from non-uwtable attribute");
431 "Trying to get allockind value from non-allockind attribute");
437 "Can only call getMemoryEffects() on memory attribute");
443 "Can only call getNoFPClass() on nofpclass attribute");
449 "Trying to get range args from non-range attribute");
468 if (!pImpl)
return {};
493 auto AttrWithBytesToString = [&](
const char *
Name) {
500 return AttrWithBytesToString(
"alignstack");
503 return AttrWithBytesToString(
"dereferenceable");
506 return AttrWithBytesToString(
"dereferenceable_or_null");
510 std::optional<unsigned> NumElems;
514 ?
"allocsize(" +
Twine(ElemSize) +
"," +
Twine(*NumElems) +
")"
515 :
"allocsize(" +
Twine(ElemSize) +
")")
522 return (
"vscale_range(" +
Twine(MinValue) +
"," +
523 Twine(MaxValue.value_or(0)) +
")")
553 return (
"allockind(\"" +
588 OS <<
"inaccessiblemem: ";
601 std::string Result =
"nofpclass";
634 if (!AttrVal.empty()) {
636 printEscapedString(AttrVal,
OS);
647 assert(
isValid() &&
"invalid Attribute doesn't refer to any context");
651 return C.pImpl->AttrsSet.FindNodeOrInsertPos(
ID, Unused) == pImpl;
655 if (!pImpl && !
A.pImpl)
return false;
656 if (!pImpl)
return true;
657 if (!
A.pImpl)
return false;
658 return *pImpl < *
A.pImpl;
662 ID.AddPointer(pImpl);
671#define GET_ATTR_PROP_TABLE
672#include "llvm/IR/Attributes.inc"
676 unsigned Index = Kind - 1;
677 assert(
Index < std::size(AttrPropTable) &&
"Invalid attribute kind");
678 return AttrPropTable[
Index] & Prop;
741 ->getConstantRangeValue();
786 B.addAttribute(Kind);
793 B.addAttribute(Kind,
Value);
814 B.removeAttribute(Kind);
822 B.removeAttribute(Kind);
830 if (!
B.overlaps(Attrs))
858 return SetNode ? SetNode->
getAlignment() : std::nullopt;
886 return SetNode ? SetNode->
getAttributeType(Attribute::Preallocated) :
nullptr;
894 return SetNode ? SetNode->
getAttributeType(Attribute::ElementType) :
nullptr;
897std::optional<std::pair<unsigned, std::optional<unsigned>>>
929 return SetNode ? SetNode->
getAsString(InAttrGrp) :
"";
937 return C.pImpl->AttrsSetNodes.FindNodeOrInsertPos(
ID, Unused) == SetNode;
941 return SetNode ? SetNode->
begin() :
nullptr;
945 return SetNode ? SetNode->
end() :
nullptr;
948#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
961 : NumAttrs(Attrs.
size()) {
963 llvm::copy(Attrs, getTrailingObjects<Attribute>());
965 for (
const auto &
I : *
this) {
966 if (
I.isStringAttribute())
967 StringAttrs.insert({
I.getKindAsString(),
I });
969 AvailableAttrs.addAttribute(
I.getKindAsEnum());
977 return getSorted(
C, SortedAttrs);
982 if (SortedAttrs.
empty())
990 for (
const auto &Attr : SortedAttrs)
1001 void *Mem = ::operator
new(totalSizeToAlloc<Attribute>(SortedAttrs.size()));
1011 return getSorted(
C,
B.attrs());
1015 return StringAttrs.count(Kind);
1018std::optional<Attribute>
1022 return std::nullopt;
1027 std::lower_bound(
begin(),
end() - StringAttrs.size(), Kind,
1029 return A.getKindAsEnum() < Kind;
1031 assert(
I !=
end() &&
I->hasAttribute(Kind) &&
"Presence check failed?");
1036 if (
auto A = findEnumAttribute(Kind))
1042 return StringAttrs.lookup(Kind);
1046 if (
auto A = findEnumAttribute(Attribute::Alignment))
1047 return A->getAlignment();
1048 return std::nullopt;
1052 if (
auto A = findEnumAttribute(Attribute::StackAlignment))
1053 return A->getStackAlignment();
1054 return std::nullopt;
1058 if (
auto A = findEnumAttribute(Kind))
1059 return A->getValueAsType();
1064 if (
auto A = findEnumAttribute(Attribute::Dereferenceable))
1065 return A->getDereferenceableBytes();
1070 if (
auto A = findEnumAttribute(Attribute::DereferenceableOrNull))
1071 return A->getDereferenceableOrNullBytes();
1075std::optional<std::pair<unsigned, std::optional<unsigned>>>
1077 if (
auto A = findEnumAttribute(Attribute::AllocSize))
1078 return A->getAllocSizeArgs();
1079 return std::nullopt;
1083 if (
auto A = findEnumAttribute(Attribute::VScaleRange))
1084 return A->getVScaleRangeMin();
1089 if (
auto A = findEnumAttribute(Attribute::VScaleRange))
1090 return A->getVScaleRangeMax();
1091 return std::nullopt;
1095 if (
auto A = findEnumAttribute(Attribute::UWTable))
1096 return A->getUWTableKind();
1101 if (
auto A = findEnumAttribute(Attribute::AllocKind))
1102 return A->getAllocKind();
1107 if (
auto A = findEnumAttribute(Attribute::Memory))
1108 return A->getMemoryEffects();
1113 if (
auto A = findEnumAttribute(Attribute::NoFPClass))
1114 return A->getNoFPClass();
1123 Str +=
I->getAsString(InAttrGrp);
1139 : NumAttrSets(Sets.
size()) {
1140 assert(!Sets.
empty() &&
"pointless AttributeListImpl");
1143 llvm::copy(Sets, getTrailingObjects<AttributeSet>());
1148 if (!
I.isStringAttribute())
1151 for (
const auto &Set : Sets)
1152 for (
const auto &
I : Set)
1153 if (!
I.isStringAttribute())
1163 for (
const auto &Set : Sets)
1164 ID.AddPointer(Set.SetNode);
1168 unsigned *
Index)
const {
1173 for (
unsigned I = 0, E = NumAttrSets;
I != E; ++
I) {
1174 if (
begin()[
I].hasAttribute(Kind)) {
1185#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
1197 assert(!AttrSets.
empty() &&
"pointless AttributeListImpl");
1205 pImpl->
AttrsLists.FindNodeOrInsertPos(
ID, InsertPoint);
1212 AttributeListImpl::totalSizeToAlloc<AttributeSet>(AttrSets.
size()),
1215 pImpl->
AttrsLists.InsertNode(PA, InsertPoint);
1224 ArrayRef<std::pair<unsigned, Attribute>> Attrs) {
1230 "Misordered Attributes list!");
1232 [](
const std::pair<unsigned, Attribute> &Pair) {
1233 return Pair.second.isValid();
1235 "Pointless attribute!");
1241 E = Attrs.end();
I != E; ) {
1242 unsigned Index =
I->first;
1244 while (
I != E &&
I->first ==
Index) {
1252 return get(
C, AttrPairVec);
1257 ArrayRef<std::pair<unsigned, AttributeSet>> Attrs) {
1263 "Misordered Attributes list!");
1265 [](
const std::pair<unsigned, AttributeSet> &Pair) {
1266 return !Pair.second.hasAttributes();
1268 "Pointless attribute!");
1270 unsigned MaxIndex = Attrs.back().first;
1274 MaxIndex = Attrs[Attrs.size() - 2].first;
1277 for (
const auto &Pair : Attrs)
1280 return getImpl(
C, AttrVec);
1289 unsigned NumSets = 0;
1290 for (
size_t I = ArgAttrs.
size();
I != 0; --
I) {
1291 if (ArgAttrs[
I - 1].hasAttributes()) {
1321 return getImpl(
C, AttrSets);
1326 if (!Attrs.hasAttributes())
1330 AttrSets[
Index] = Attrs;
1331 return getImpl(
C, AttrSets);
1342 for (
const auto K : Kinds)
1344 return get(
C, Attrs);
1350 assert(Kinds.
size() == Values.
size() &&
"Mismatched attribute values.");
1352 auto VI = Values.
begin();
1353 for (
const auto K : Kinds)
1355 return get(
C, Attrs);
1361 for (
const auto &K : Kinds)
1363 return get(
C, Attrs);
1370 if (Attrs.size() == 1)
1373 unsigned MaxSize = 0;
1374 for (
const auto &
List : Attrs)
1375 MaxSize = std::max(MaxSize,
List.getNumAttrSets());
1382 for (
unsigned I = 0;
I < MaxSize; ++
I) {
1384 for (
const auto &
List : Attrs)
1389 return getImpl(
C, NewAttrSets);
1396 if (Attrs.hasAttribute(Kind))
1408 B.addAttribute(Kind,
Value);
1424 if (Index >= AttrSets.
size())
1425 AttrSets.resize(
Index + 1);
1426 AttrSets[
Index] = Attrs;
1429 while (!AttrSets.
empty() && !AttrSets.
back().hasAttributes())
1430 AttrSets.pop_back();
1431 if (AttrSets.
empty())
1433 return AttributeList::getImpl(
C, AttrSets);
1439 if (!
B.hasAttributes())
1457 if (MaxIndex >= AttrSets.
size())
1458 AttrSets.
resize(MaxIndex + 1);
1460 for (
unsigned ArgNo : ArgNos) {
1467 return getImpl(
C, AttrSets);
1475 if (Attrs == NewAttrs)
1477 return setAttributesAtIndex(
C,
Index, NewAttrs);
1485 if (Attrs == NewAttrs)
1487 return setAttributesAtIndex(
C,
Index, NewAttrs);
1493 AttributeSet NewAttrs = Attrs.removeAttributes(
C, AttrsToRemove);
1495 if (Attrs == NewAttrs)
1497 return setAttributesAtIndex(
C,
Index, NewAttrs);
1502 unsigned WithoutIndex)
const {
1507 return setAttributesAtIndex(
C, WithoutIndex,
AttributeSet());
1513 B.addDereferenceableAttr(Bytes);
1521 B.addDereferenceableAttr(Bytes);
1529 B.addDereferenceableOrNullAttr(Bytes);
1542 const std::optional<unsigned> &NumElemsArg) {
1544 B.addAllocSizeAttr(ElemSizeArg, NumElemsArg);
1578 return pImpl && pImpl->hasFnAttribute(Kind);
1586 unsigned *
Index)
const {
1587 return pImpl && pImpl->hasAttrSomewhere(Attr,
Index);
1689 return pImpl->begin()[
Index];
1693 assert(!
isEmpty() &&
"an empty attribute list has no parent context");
1697 return C.pImpl->AttrsLists.FindNodeOrInsertPos(
ID, Unused) == pImpl;
1701 return pImpl ? pImpl->begin() :
nullptr;
1705 return pImpl ? pImpl->end() :
nullptr;
1713 return pImpl ? pImpl->NumAttrSets : 0;
1717 O <<
"AttributeList[\n";
1719 for (
unsigned i :
indexes()) {
1739#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
1782template <
typename K>
1786 if (It != Attrs.end() && It->hasAttribute(Kind))
1789 Attrs.insert(It, Attr);
1813 if (It != Attrs.end() && It->hasAttribute(Val))
1820 if (It != Attrs.end() && It->hasAttribute(
A))
1825std::optional<uint64_t>
1830 return A.getValueAsInt();
1831 return std::nullopt;
1839std::optional<std::pair<unsigned, std::optional<unsigned>>>
1843 return A.getAllocSizeArgs();
1844 return std::nullopt;
1860 assert(*
Align <= 0x100 &&
"Alignment too large.");
1865 if (Bytes == 0)
return *
this;
1874 return addRawIntAttr(Attribute::DereferenceableOrNull, Bytes);
1879 const std::optional<unsigned> &NumElems) {
1885 assert(RawArgs &&
"Invalid allocsize arguments -- given allocsize(0, 0)");
1890 std::optional<unsigned> MaxValue) {
1926 return A.isValid() ?
A.getValueAsType() :
nullptr;
1964 for (
const auto &
I :
B.attrs())
1982 if (It != Attrs.end() && It->hasAttribute(
A))
1989 if (It != Attrs.end() && It->hasAttribute(
A))
2003 return Attrs ==
B.Attrs;
2015 while (
ArrayType *ArrTy = dyn_cast<ArrayType>(Ty))
2016 Ty = ArrTy->getElementType();
2080 return Incompatible;
2114 DenormalMode CallerModeF32 = Caller.getDenormalModeF32Raw();
2115 DenormalMode CalleeModeF32 = Callee.getDenormalModeF32Raw();
2117 CallerModeF32 = CallerMode;
2119 CalleeModeF32 = CalleeMode;
2129 return !Callee.getAttributes().hasFnAttr(Attribute::StrictFP) ||
2130 Caller.getAttributes().hasFnAttr(Attribute::StrictFP);
2133template<
typename AttrClass>
2135 return Caller.getFnAttribute(AttrClass::getKind()) ==
2136 Callee.getFnAttribute(AttrClass::getKind());
2141 return Caller.getFnAttribute(AttrName) == Callee.getFnAttribute(AttrName);
2149template<
typename AttrClass>
2151 if (AttrClass::isSet(Caller, AttrClass::getKind()) &&
2152 !AttrClass::isSet(Callee, AttrClass::getKind()))
2153 AttrClass::set(Caller, AttrClass::getKind(),
false);
2161template<
typename AttrClass>
2163 if (!AttrClass::isSet(Caller, AttrClass::getKind()) &&
2164 AttrClass::isSet(Callee, AttrClass::getKind()))
2165 AttrClass::set(Caller, AttrClass::getKind(),
true);
2174 if (!Caller.hasStackProtectorFnAttr())
2185 if (Callee.hasFnAttribute(Attribute::StackProtectReq)) {
2186 Caller.removeFnAttrs(OldSSPAttr);
2187 Caller.addFnAttr(Attribute::StackProtectReq);
2188 }
else if (Callee.hasFnAttribute(Attribute::StackProtectStrong) &&
2189 !Caller.hasFnAttribute(Attribute::StackProtectReq)) {
2190 Caller.removeFnAttrs(OldSSPAttr);
2191 Caller.addFnAttr(Attribute::StackProtectStrong);
2192 }
else if (Callee.hasFnAttribute(Attribute::StackProtect) &&
2193 !Caller.hasFnAttribute(Attribute::StackProtectReq) &&
2194 !Caller.hasFnAttribute(Attribute::StackProtectStrong))
2195 Caller.addFnAttr(Attribute::StackProtect);
2201 if (!Caller.hasFnAttribute(
"probe-stack") &&
2202 Callee.hasFnAttribute(
"probe-stack")) {
2203 Caller.addFnAttr(Callee.getFnAttribute(
"probe-stack"));
2212 Attribute CalleeAttr = Callee.getFnAttribute(
"stack-probe-size");
2214 Attribute CallerAttr = Caller.getFnAttribute(
"stack-probe-size");
2216 uint64_t CallerStackProbeSize, CalleeStackProbeSize;
2220 if (CallerStackProbeSize > CalleeStackProbeSize) {
2221 Caller.addFnAttr(CalleeAttr);
2224 Caller.addFnAttr(CalleeAttr);
2240 Attribute CallerAttr = Caller.getFnAttribute(
"min-legal-vector-width");
2242 Attribute CalleeAttr = Callee.getFnAttribute(
"min-legal-vector-width");
2244 uint64_t CallerVectorWidth, CalleeVectorWidth;
2247 if (CallerVectorWidth < CalleeVectorWidth)
2248 Caller.addFnAttr(CalleeAttr);
2252 Caller.removeFnAttr(
"min-legal-vector-width");
2261 if (Callee.nullPointerIsDefined() && !Caller.nullPointerIsDefined()) {
2262 Caller.addFnAttr(Attribute::NullPointerIsValid);
2285 return A.getValueAsString() ==
"true";
2290 Fn.
addFnAttr(Kind, Val ?
"true" :
"false");
2294#define GET_ATTR_NAMES
2295#define ATTRIBUTE_ENUM(ENUM_NAME, DISPLAY_NAME) \
2296 struct ENUM_NAME##Attr : EnumAttr { \
2297 static enum Attribute::AttrKind getKind() { \
2298 return llvm::Attribute::ENUM_NAME; \
2301#define ATTRIBUTE_STRBOOL(ENUM_NAME, DISPLAY_NAME) \
2302 struct ENUM_NAME##Attr : StrBoolAttr { \
2303 static StringRef getKind() { return #DISPLAY_NAME; } \
2305#include "llvm/IR/Attributes.inc"
2307#define GET_ATTR_COMPAT_FUNC
2308#include "llvm/IR/Attributes.inc"
2312 return hasCompatibleFnAttrs(Caller, Callee);
2317 return hasCompatibleFnAttrs(
A,
B);
2322 mergeFnAttrs(Caller, Callee);
2335 mergeFnAttrs(
Base, ToMerge);
2344 if (Width > OldWidth)
2345 Fn.
addFnAttr(
"min-legal-vector-width", llvm::utostr(Width));
This file defines various helper methods and classes used by LLVMContextImpl for creating and managin...
static void addAttributeImpl(SmallVectorImpl< Attribute > &Attrs, K Kind, Attribute Attr)
static void setAND(Function &Caller, const Function &Callee)
Compute the logical AND of the attributes of the caller and the callee.
static void adjustCallerStackProbes(Function &Caller, const Function &Callee)
If the inlined function required stack probes, then ensure that the calling function has those too.
static std::pair< unsigned, std::optional< unsigned > > unpackVScaleRangeArgs(uint64_t Value)
static void adjustMinLegalVectorWidth(Function &Caller, const Function &Callee)
If the inlined function defines a min legal vector width, then ensure the calling function has the sa...
static void adjustCallerStackProbeSize(Function &Caller, const Function &Callee)
If the inlined function defines the size of guard region on the stack, then ensure that the calling f...
static void adjustCallerSSPLevel(Function &Caller, const Function &Callee)
If the inlined function had a higher stack protection level than the calling function,...
static bool checkStrictFP(const Function &Caller, const Function &Callee)
static uint64_t packAllocSizeArgs(unsigned ElemSizeArg, const std::optional< unsigned > &NumElemsArg)
static uint64_t packVScaleRangeArgs(unsigned MinValue, std::optional< unsigned > MaxValue)
static unsigned attrIdxToArrayIdx(unsigned Index)
Map from AttributeList index to the internal array index.
static bool denormModeCompatible(DenormalMode CallerMode, DenormalMode CalleeMode)
Callees with dynamic denormal modes are compatible with any caller mode.
static void adjustNullPointerValidAttr(Function &Caller, const Function &Callee)
If the inlined function has null_pointer_is_valid attribute, set this attribute in the caller post in...
static const unsigned AllocSizeNumElemsNotPresent
static std::pair< unsigned, std::optional< unsigned > > unpackAllocSizeArgs(uint64_t Num)
static bool checkDenormMode(const Function &Caller, const Function &Callee)
static void setOR(Function &Caller, const Function &Callee)
Compute the logical OR of the attributes of the caller and the callee.
static bool hasAttributeProperty(Attribute::AttrKind Kind, AttributeProperty Prop)
static const char * getModRefStr(ModRefInfo MR)
This file contains the simple types necessary to represent the attributes associated with functions a...
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
#define LLVM_DUMP_METHOD
Mark debug helper function definitions like dump() that should not be stripped from debug builds.
This file defines a hash set that can be used to remove duplication of nodes in a graph.
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file defines the SmallVector class.
This file implements the StringSwitch template, which mimics a switch() statement whose cases are str...
void Profile(FoldingSetNodeID &id) const
Used to insert APInt objects, or objects that contain APInt objects, into FoldingSets.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
const T & back() const
back - Get the last element.
ArrayRef< T > take_front(size_t N=1) const
Return a copy of *this with only the first N elements.
size_t size() const
size - Get the array size.
bool empty() const
empty - Check if the array is empty.
Class to represent array types.
AttrBuilder & addStructRetAttr(Type *Ty)
This turns a sret type into the form used internally in Attribute.
AttrBuilder & addAlignmentAttr(MaybeAlign Align)
This turns an alignment into the form used internally in Attribute.
AttrBuilder & addVScaleRangeAttrFromRawRepr(uint64_t RawVScaleRangeRepr)
Add a vscale_range attribute, using the representation returned by Attribute.getIntValue().
std::optional< uint64_t > getRawIntAttr(Attribute::AttrKind Kind) const
Return raw (possibly packed/encoded) value of integer attribute or std::nullopt if not set.
AttrBuilder & addAllocKindAttr(AllocFnKind Kind)
Attribute getAttribute(Attribute::AttrKind Kind) const
Return Attribute with the given Kind.
AttrBuilder & addByRefAttr(Type *Ty)
This turns a byref type into the form used internally in Attribute.
AttrBuilder & addNoFPClassAttr(FPClassTest NoFPClassMask)
bool overlaps(const AttributeMask &AM) const
Return true if the builder has any attribute that's in the specified builder.
AttrBuilder & merge(const AttrBuilder &B)
Add the attributes from the builder.
AttrBuilder & addVScaleRangeAttr(unsigned MinValue, std::optional< unsigned > MaxValue)
This turns two ints into the form used internally in Attribute.
AttrBuilder(LLVMContext &Ctx)
AttrBuilder & addRawIntAttr(Attribute::AttrKind Kind, uint64_t Value)
Add integer attribute with raw value (packed/encoded if necessary).
AttrBuilder & addAttribute(Attribute::AttrKind Val)
Add an attribute to the builder.
AttrBuilder & addByValAttr(Type *Ty)
This turns a byval type into the form used internally in Attribute.
AttrBuilder & addDereferenceableAttr(uint64_t Bytes)
This turns the number of dereferenceable bytes into the form used internally in Attribute.
bool contains(Attribute::AttrKind A) const
Return true if the builder has the specified attribute.
AttrBuilder & addMemoryAttr(MemoryEffects ME)
Add memory effect attribute.
AttrBuilder & addConstantRangeAttr(Attribute::AttrKind Kind, const ConstantRange &CR)
Add a ConstantRange attribute with the given range.
AttrBuilder & addAllocSizeAttrFromRawRepr(uint64_t RawAllocSizeRepr)
Add an allocsize attribute, using the representation returned by Attribute.getIntValue().
AttrBuilder & addPreallocatedAttr(Type *Ty)
This turns a preallocated type into the form used internally in Attribute.
AttrBuilder & addStackAlignmentAttr(MaybeAlign Align)
This turns a stack alignment into the form used internally in Attribute.
AttrBuilder & addInAllocaAttr(Type *Ty)
This turns an inalloca type into the form used internally in Attribute.
AttrBuilder & removeAttribute(Attribute::AttrKind Val)
Remove an attribute from the builder.
bool operator==(const AttrBuilder &B) const
Type * getTypeAttr(Attribute::AttrKind Kind) const
Retrieve type for the given type attribute.
AttrBuilder & remove(const AttributeMask &AM)
Remove the attributes from the builder.
AttrBuilder & addDereferenceableOrNullAttr(uint64_t Bytes)
This turns the number of dereferenceable_or_null bytes into the form used internally in Attribute.
AttrBuilder & addTypeAttr(Attribute::AttrKind Kind, Type *Ty)
Add a type attribute with the given type.
std::optional< std::pair< unsigned, std::optional< unsigned > > > getAllocSizeArgs() const
Retrieve the allocsize args, or std::nullopt if the attribute does not exist.
AttrBuilder & addAllocSizeAttr(unsigned ElemSizeArg, const std::optional< unsigned > &NumElemsArg)
This turns one (or two) ints into the form used internally in Attribute.
AttrBuilder & addRangeAttr(const ConstantRange &CR)
Add range attribute.
AttrBuilder & addUWTableAttr(UWTableKind Kind)
This turns the unwind table kind into the form used internally in Attribute.
void addAttribute(Attribute::AttrKind Kind)
bool hasAttribute(Attribute::AttrKind Kind) const
bool isConstantRangeAttribute() const
bool hasAttribute(Attribute::AttrKind A) const
void Profile(FoldingSetNodeID &ID) const
Type * getValueAsType() const
Attribute::AttrKind getKindAsEnum() const
bool operator<(const AttributeImpl &AI) const
Used when sorting the attributes.
uint64_t getValueAsInt() const
bool isIntAttribute() const
bool isTypeAttribute() const
bool getValueAsBool() const
StringRef getKindAsString() const
StringRef getValueAsString() const
bool isEnumAttribute() const
bool isStringAttribute() const
const ConstantRange & getValueAsConstantRange() const
bool hasAttrSomewhere(Attribute::AttrKind Kind, unsigned *Index=nullptr) const
Return true if the specified attribute is set for at least one parameter or for the return value.
void Profile(FoldingSetNodeID &ID) const
AttributeListImpl(ArrayRef< AttributeSet > Sets)
friend class AttributeList
bool hasAttributeAtIndex(unsigned Index, Attribute::AttrKind Kind) const
Return true if the attribute exists at the given index.
Type * getParamStructRetType(unsigned ArgNo) const
Return the sret type for the specified function parameter.
AttributeList addDereferenceableParamAttr(LLVMContext &C, unsigned ArgNo, uint64_t Bytes) const
Add the dereferenceable attribute to the attribute set at the given arg index.
AttributeList removeAttributeAtIndex(LLVMContext &C, unsigned Index, Attribute::AttrKind Kind) const
Remove the specified attribute at the specified index from this attribute list.
AttributeList addRangeRetAttr(LLVMContext &C, const ConstantRange &CR) const
Add the range attribute to the attribute set at the return value index.
bool hasAttributesAtIndex(unsigned Index) const
Return true if attribute exists at the given index.
friend class AttributeListImpl
AttributeSet getFnAttrs() const
The function attributes are returned.
index_iterator indexes() const
Use this to iterate over the valid attribute indexes.
AttributeList removeAttributesAtIndex(LLVMContext &C, unsigned Index, const AttributeMask &AttrsToRemove) const
Remove the specified attributes at the specified index from this attribute list.
friend class AttributeSet
AttributeList addAllocSizeParamAttr(LLVMContext &C, unsigned ArgNo, unsigned ElemSizeArg, const std::optional< unsigned > &NumElemsArg)
Add the allocsize attribute to the attribute set at the given arg index.
MaybeAlign getRetStackAlignment() const
Get the stack alignment of the return value.
AttributeList addRetAttributes(LLVMContext &C, const AttrBuilder &B) const
Add a return value attribute to the list.
void print(raw_ostream &O) const
AttributeList addDereferenceableRetAttr(LLVMContext &C, uint64_t Bytes) const
Add the dereferenceable attribute to the attribute set at the given index.
static AttributeList get(LLVMContext &C, ArrayRef< std::pair< unsigned, Attribute > > Attrs)
Create an AttributeList with the specified parameters in it.
AllocFnKind getAllocKind() const
bool isEmpty() const
Return true if there are no attributes.
AttributeSet getRetAttrs() const
The attributes for the ret value are returned.
bool hasFnAttr(Attribute::AttrKind Kind) const
Return true if the attribute exists for the function.
uint64_t getParamDereferenceableBytes(unsigned Index) const
Get the number of dereferenceable bytes (or zero if unknown) of an arg.
MaybeAlign getParamAlignment(unsigned ArgNo) const
Return the alignment for the specified function parameter.
bool hasAttrSomewhere(Attribute::AttrKind Kind, unsigned *Index=nullptr) const
Return true if the specified attribute is set for at least one parameter or for the return value.
Type * getParamInAllocaType(unsigned ArgNo) const
Return the inalloca type for the specified function parameter.
unsigned getNumAttrSets() const
FPClassTest getRetNoFPClass() const
Get the disallowed floating-point classes of the return value.
std::string getAsString(unsigned Index, bool InAttrGrp=false) const
Return the attributes at the index as a string.
UWTableKind getUWTableKind() const
Get the unwind table kind requested for the function.
MaybeAlign getRetAlignment() const
Return the alignment of the return value.
Type * getParamElementType(unsigned ArgNo) const
Return the elementtype type for the specified function parameter.
Attribute getAttributeAtIndex(unsigned Index, Attribute::AttrKind Kind) const
Return the attribute object that exists at the given index.
Type * getParamPreallocatedType(unsigned ArgNo) const
Return the preallocated type for the specified function parameter.
bool hasParentContext(LLVMContext &C) const
Return true if this attribute list belongs to the LLVMContext.
const AttributeSet * iterator
MaybeAlign getFnStackAlignment() const
Get the stack alignment of the function.
AttributeList addAttributesAtIndex(LLVMContext &C, unsigned Index, const AttrBuilder &B) const
Add attributes to the attribute set at the given index.
Type * getParamByValType(unsigned ArgNo) const
Return the byval type for the specified function parameter.
MaybeAlign getParamStackAlignment(unsigned ArgNo) const
Return the stack alignment for the specified function parameter.
uint64_t getRetDereferenceableBytes() const
Get the number of dereferenceable bytes (or zero if unknown) of the return value.
uint64_t getParamDereferenceableOrNullBytes(unsigned ArgNo) const
Get the number of dereferenceable_or_null bytes (or zero if unknown) of an arg.
AttributeList addDereferenceableOrNullParamAttr(LLVMContext &C, unsigned ArgNo, uint64_t Bytes) const
Add the dereferenceable_or_null attribute to the attribute set at the given arg index.
AttributeSet getAttributes(unsigned Index) const
The attributes for the specified index are returned.
FPClassTest getParamNoFPClass(unsigned ArgNo) const
Get the disallowed floating-point classes of the argument value.
Type * getParamByRefType(unsigned ArgNo) const
Return the byref type for the specified function parameter.
AttributeList addAttributeAtIndex(LLVMContext &C, unsigned Index, Attribute::AttrKind Kind) const
Add an attribute to the attribute set at the given index.
AttributeSet getParamAttrs(unsigned ArgNo) const
The attributes for the argument or parameter at the given index are returned.
AttributeList addParamAttributes(LLVMContext &C, unsigned ArgNo, const AttrBuilder &B) const
Add an argument attribute to the list.
uint64_t getRetDereferenceableOrNullBytes() const
Get the number of dereferenceable_or_null bytes (or zero if unknown) of the return value.
AttributeList addParamAttribute(LLVMContext &C, unsigned ArgNo, Attribute::AttrKind Kind) const
Add an argument attribute to the list.
MemoryEffects getMemoryEffects() const
Returns memory effects of the function.
AttributeMask & addAttribute(Attribute::AttrKind Val)
Add an attribute to the mask.
bool contains(Attribute::AttrKind A) const
Return true if the builder has the specified attribute.
MaybeAlign getStackAlignment() const
uint64_t getDereferenceableOrNullBytes() const
std::optional< unsigned > getVScaleRangeMax() const
bool hasAttribute(Attribute::AttrKind Kind) const
Type * getAttributeType(Attribute::AttrKind Kind) const
AllocFnKind getAllocKind() const
unsigned getVScaleRangeMin() const
MaybeAlign getAlignment() const
MemoryEffects getMemoryEffects() const
UWTableKind getUWTableKind() const
std::optional< std::pair< unsigned, std::optional< unsigned > > > getAllocSizeArgs() const
uint64_t getDereferenceableBytes() const
unsigned getNumAttributes() const
Return the number of attributes this AttributeList contains.
void Profile(FoldingSetNodeID &ID) const
std::string getAsString(bool InAttrGrp) const
static AttributeSetNode * get(LLVMContext &C, const AttrBuilder &B)
FPClassTest getNoFPClass() const
Attribute getAttribute(Attribute::AttrKind Kind) const
AllocFnKind getAllocKind() const
bool hasAttributes() const
Return true if attributes exists in this set.
AttributeSet removeAttribute(LLVMContext &C, Attribute::AttrKind Kind) const
Remove the specified attribute from this set.
Type * getInAllocaType() const
Type * getByValType() const
AttributeSet addAttributes(LLVMContext &C, AttributeSet AS) const
Add attributes to the attribute set.
MemoryEffects getMemoryEffects() const
bool hasAttribute(Attribute::AttrKind Kind) const
Return true if the attribute exists in this set.
Type * getStructRetType() const
std::string getAsString(bool InAttrGrp=false) const
unsigned getVScaleRangeMin() const
std::optional< std::pair< unsigned, std::optional< unsigned > > > getAllocSizeArgs() const
UWTableKind getUWTableKind() const
bool hasParentContext(LLVMContext &C) const
Return true if this attribute set belongs to the LLVMContext.
AttributeSet removeAttributes(LLVMContext &C, const AttributeMask &AttrsToRemove) const
Remove the specified attributes from this set.
std::optional< unsigned > getVScaleRangeMax() const
MaybeAlign getStackAlignment() const
Attribute getAttribute(Attribute::AttrKind Kind) const
Return the attribute object.
Type * getPreallocatedType() const
uint64_t getDereferenceableBytes() const
MaybeAlign getAlignment() const
FPClassTest getNoFPClass() const
Type * getElementType() const
Type * getByRefType() const
AttributeSet()=default
AttributeSet is a trivially copyable value type.
static AttributeSet get(LLVMContext &C, const AttrBuilder &B)
uint64_t getDereferenceableOrNullBytes() const
unsigned getNumAttributes() const
Return the number of attributes in this set.
AttributeSet addAttribute(LLVMContext &C, Attribute::AttrKind Kind) const
Add an argument attribute.
bool isStringAttribute() const
Return true if the attribute is a string (target-dependent) attribute.
static Attribute getWithStructRetType(LLVMContext &Context, Type *Ty)
static Attribute::AttrKind getAttrKindFromName(StringRef AttrName)
bool isEnumAttribute() const
Return true if the attribute is an Attribute::AttrKind type.
static Attribute getWithStackAlignment(LLVMContext &Context, Align Alignment)
const ConstantRange & getRange() const
Returns the value of the range attribute.
bool isIntAttribute() const
Return true if the attribute is an integer attribute.
static Attribute getWithByRefType(LLVMContext &Context, Type *Ty)
std::optional< unsigned > getVScaleRangeMax() const
Returns the maximum value for the vscale_range attribute or std::nullopt when unknown.
uint64_t getValueAsInt() const
Return the attribute's value as an integer.
unsigned getVScaleRangeMin() const
Returns the minimum value for the vscale_range attribute.
AllocFnKind getAllocKind() const
bool isConstantRangeAttribute() const
Return true if the attribute is a ConstantRange attribute.
StringRef getKindAsString() const
Return the attribute's kind as a string.
static Attribute getWithPreallocatedType(LLVMContext &Context, Type *Ty)
static Attribute get(LLVMContext &Context, AttrKind Kind, uint64_t Val=0)
Return a uniquified Attribute object.
static bool canUseAsRetAttr(AttrKind Kind)
static bool isTypeAttrKind(AttrKind Kind)
std::string getAsString(bool InAttrGrp=false) const
The Attribute is converted to a string of equivalent mnemonic.
uint64_t getDereferenceableOrNullBytes() const
Returns the number of dereferenceable_or_null bytes from the dereferenceable_or_null attribute.
static Attribute getWithDereferenceableBytes(LLVMContext &Context, uint64_t Bytes)
std::pair< unsigned, std::optional< unsigned > > getAllocSizeArgs() const
Returns the argument numbers for the allocsize attribute.
static Attribute getWithUWTableKind(LLVMContext &Context, UWTableKind Kind)
FPClassTest getNoFPClass() const
Return the FPClassTest for nofpclass.
static Attribute getWithAllocSizeArgs(LLVMContext &Context, unsigned ElemSizeArg, const std::optional< unsigned > &NumElemsArg)
Attribute::AttrKind getKindAsEnum() const
Return the attribute's kind as an enum (Attribute::AttrKind).
bool getValueAsBool() const
Return the attribute's value as a boolean.
const ConstantRange & getValueAsConstantRange() const
Return the attribute's value as a ConstantRange.
uint64_t getDereferenceableBytes() const
Returns the number of dereferenceable bytes from the dereferenceable attribute.
static Attribute getWithVScaleRangeArgs(LLVMContext &Context, unsigned MinValue, unsigned MaxValue)
MemoryEffects getMemoryEffects() const
Returns memory effects.
void Profile(FoldingSetNodeID &ID) const
UWTableKind getUWTableKind() const
static Attribute getWithDereferenceableOrNullBytes(LLVMContext &Context, uint64_t Bytes)
StringRef getValueAsString() const
Return the attribute's value as a string.
static bool isExistingAttribute(StringRef Name)
Return true if the provided string matches the IR name of an attribute.
static StringRef getNameFromAttrKind(Attribute::AttrKind AttrKind)
static bool canUseAsFnAttr(AttrKind Kind)
static Attribute getWithNoFPClass(LLVMContext &Context, FPClassTest Mask)
AttrKind
This enumeration lists the attributes that can be associated with parameters, function results,...
@ None
No attributes have been set.
@ EndAttrKinds
Sentinel value useful for loops.
static bool isConstantRangeAttrKind(AttrKind Kind)
bool hasParentContext(LLVMContext &C) const
Return true if this attribute belongs to the LLVMContext.
bool isTypeAttribute() const
Return true if the attribute is a type attribute.
static Attribute getWithInAllocaType(LLVMContext &Context, Type *Ty)
static bool isIntAttrKind(AttrKind Kind)
static Attribute getWithByValType(LLVMContext &Context, Type *Ty)
bool hasAttribute(AttrKind Val) const
Return true if the attribute is present.
static bool isEnumAttrKind(AttrKind Kind)
static Attribute getWithMemoryEffects(LLVMContext &Context, MemoryEffects ME)
static bool canUseAsParamAttr(AttrKind Kind)
bool isValid() const
Return true if the attribute is any kind of attribute.
MaybeAlign getStackAlignment() const
Returns the stack alignment field of an attribute as a byte alignment value.
MaybeAlign getAlignment() const
Returns the alignment field of an attribute as a byte alignment value.
bool operator<(Attribute A) const
Less-than operator. Useful for sorting the attributes list.
static Attribute getWithAlignment(LLVMContext &Context, Align Alignment)
Return a uniquified Attribute object that has the specific alignment set.
Type * getValueAsType() const
Return the attribute's value as a Type.
LLVM_ATTRIBUTE_RETURNS_NONNULL void * Allocate(size_t Size, Align Alignment)
Allocate space at the specified alignment.
This class represents a range of values.
const APInt & getLower() const
Return the lower value for this range.
const APInt & getUpper() const
Return the upper value for this range.
uint32_t getBitWidth() const
Get the bit width of this ConstantRange.
FoldingSetNodeID - This class is used to gather all the unique data bits of a node.
void addFnAttr(Attribute::AttrKind Kind)
Add function attributes to this function.
Attribute getFnAttribute(Attribute::AttrKind Kind) const
Return the attribute for the given attribute kind.
void removeFnAttr(Attribute::AttrKind Kind)
Remove function attributes from this function.
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
FoldingSet< AttributeImpl > AttrsSet
FoldingSet< AttributeSetNode > AttrsSetNodes
FoldingSet< AttributeListImpl > AttrsLists
SpecificBumpPtrAllocator< ConstantRangeAttributeImpl > ConstantRangeAttributeAlloc
This is an important class for using LLVM in a threaded context.
LLVMContextImpl *const pImpl
ModRefInfo getModRef(Location Loc) const
Get ModRefInfo for the given Location.
static MemoryEffectsBase createFromIntValue(uint32_t Data)
Create MemoryEffectsBase from an encoded integer value (used by memory attribute).
static auto locations()
Returns iterator over all supported location kinds.
uint32_t toIntValue() const
Convert MemoryEffectsBase into an encoded integer value (used by memory attribute).
static MemoryEffectsBase unknown()
Create MemoryEffectsBase that can read and write any memory.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
reference emplace_back(ArgTypes &&... Args)
void reserve(size_type N)
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
static size_t totalSizeToAlloc(StringRef Kind, StringRef Val)
StringRef - Represent a constant reference to a string, i.e.
bool getAsInteger(unsigned Radix, T &Result) const
Parse the current string as an integer of the specified radix.
std::string str() const
str - Get the contents as an std::string.
constexpr bool empty() const
empty - Check if the string is empty.
A switch()-like statement whose cases are string literals.
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
The instances of the Type class are immutable: once they are created, they are never changed.
bool isIntOrIntVectorTy() const
Return true if this is an integer type or a vector of integer types.
bool isPointerTy() const
True if this is an instance of PointerType.
void print(raw_ostream &O, bool IsForDebug=false, bool NoDetails=false) const
Print the current type.
bool isPtrOrPtrVectorTy() const
Return true if this is a pointer type or a vector of pointer types.
bool isIntegerTy() const
True if this is an instance of IntegerType.
bool isFPOrFPVectorTy() const
Return true if this is a FP type or a vector of FP.
bool isVoidTy() const
Return true if this is 'void'.
LLVM Value Representation.
static constexpr uint64_t MaximumAlignment
This class implements an extremely fast bulk output stream that can only output to a stream.
A raw_ostream that writes to an std::string.
This class provides various memory handling functions that manipulate MemoryBlock instances.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
bool areInlineCompatible(const Function &Caller, const Function &Callee)
AttributeMask getUBImplyingAttributes()
Get param/return attributes which imply immediate undefined behavior if an invalid value is passed.
bool isNoFPClassCompatibleType(Type *Ty)
Returns true if this is a type legal for the 'nofpclass' attribute.
bool areOutlineCompatible(const Function &A, const Function &B)
Checks if there are any incompatible function attributes between A and B.
void updateMinLegalVectorWidthAttr(Function &Fn, uint64_t Width)
Update min-legal-vector-width if it is in Attribute and less than Width.
void mergeAttributesForOutlining(Function &Base, const Function &ToMerge)
Merges the functions attributes from ToMerge into function Base.
void mergeAttributesForInlining(Function &Caller, const Function &Callee)
Merge caller's and callee's attributes.
AttributeMask typeIncompatible(Type *Ty, AttributeSafetyKind ASK=ASK_ALL)
Which attributes cannot be applied to a type.
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
@ C
The default llvm calling convention, compatible with C.
This is an optimization pass for GlobalISel generic memory operations.
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
bool isEqual(const GCNRPTracker::LiveRegSet &S1, const GCNRPTracker::LiveRegSet &S2)
auto size(R &&Range, std::enable_if_t< std::is_base_of< std::random_access_iterator_tag, typename std::iterator_traits< decltype(Range.begin())>::iterator_category >::value, void > *=nullptr)
Get the size of a range.
void append_range(Container &C, Range &&R)
Wrapper function to append range R to container C.
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
@ None
No unwind table requested.
@ Sync
"Synchronous" unwind tables
void sort(IteratorTy Start, IteratorTy End)
FPClassTest
Floating-point class tests, supported by 'is_fpclass' intrinsic.
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
bool none_of(R &&Range, UnaryPredicate P)
Provide wrappers to std::none_of which take ranges instead of having to pass begin/end explicitly.
bool is_sorted(R &&Range, Compare C)
Wrapper function around std::is_sorted to check if elements in a range R are sorted with respect to a...
ModRefInfo
Flags indicating whether a memory access modifies or references memory.
@ Ref
The access may reference the value stored in memory.
@ ModRef
The access may reference and may modify the value stored in memory.
@ Mod
The access may modify the value stored in memory.
@ NoModRef
The access neither references nor modifies the value stored in memory.
@ ArgMem
Access to memory via argument pointers.
@ First
Helpers to iterate all locations in the MemoryEffectsBase class.
@ InaccessibleMem
Memory that is inaccessible via LLVM IR.
auto lower_bound(R &&Range, T &&Value)
Provide wrappers to std::lower_bound which take ranges instead of having to pass begin/end explicitly...
OutputIt copy(R &&Range, OutputIt Out)
void erase_if(Container &C, UnaryPredicate P)
Provide a container algorithm similar to C++ Library Fundamentals v2's erase_if which is equivalent t...
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
Attribute comparator that only compares attribute keys.
bool operator()(Attribute A0, StringRef Kind) const
bool operator()(Attribute A0, Attribute A1) const
bool operator()(Attribute A0, Attribute::AttrKind Kind) const
static void set(Function &Fn, Attribute::AttrKind Kind, bool Val)
static bool isSet(const Function &Fn, Attribute::AttrKind Kind)
static bool isSet(const Function &Fn, StringRef Kind)
static void set(Function &Fn, StringRef Kind, bool Val)
This struct is a compact representation of a valid (non-zero power of two) alignment.
uint64_t value() const
This is a hole in the type system and should not be abused.
Represent subnormal handling kind for floating point instruction inputs and outputs.
DenormalModeKind Input
Denormal treatment kind for floating point instruction inputs in the default floating-point environme...
@ Dynamic
Denormals have unknown treatment.
static constexpr DenormalMode getInvalid()
DenormalModeKind Output
Denormal flushing mode for floating point instruction results in the default floating point environme...
static constexpr DenormalMode getDynamic()
This struct is a compact representation of a valid (power of two) or undefined (0) alignment.
Function object to check whether the first component of a container supported by std::get (like std::...