25#include "llvm/Config/llvm-config.h"
59 const std::optional<unsigned> &NumElemsArg) {
61 "Attempting to pack a reserved value");
67static std::pair<unsigned, std::optional<unsigned>>
69 unsigned NumElems = Num & std::numeric_limits<unsigned>::max();
70 unsigned ElemSizeArg = Num >> 32;
72 std::optional<unsigned> NumElemsArg;
74 NumElemsArg = NumElems;
75 return std::make_pair(ElemSizeArg, NumElemsArg);
79 std::optional<unsigned> MaxValue) {
80 return uint64_t(MinValue) << 32 | MaxValue.value_or(0);
83static std::pair<unsigned, std::optional<unsigned>>
85 unsigned MaxValue =
Value & std::numeric_limits<unsigned>::max();
86 unsigned MinValue =
Value >> 32;
88 return std::make_pair(MinValue,
89 MaxValue > 0 ? MaxValue : std::optional<unsigned>());
96 "Not an enum or int attribute");
104 assert(Val == 0 &&
"Value must be zero for enum attributes");
116 pImpl->
AttrsSet.InsertNode(PA, InsertPoint);
127 if (!Val.
empty())
ID.AddString(Val);
139 pImpl->
AttrsSet.InsertNode(PA, InsertPoint);
161 pImpl->
AttrsSet.InsertNode(PA, InsertPoint);
174 assert(
A <= 0x100 &&
"Alignment too large.");
180 assert(Bytes &&
"Bytes must be non-zero.");
186 assert(Bytes &&
"Bytes must be non-zero.");
187 return get(
Context, DereferenceableOrNull, Bytes);
227 const std::optional<unsigned> &NumElemsArg) {
228 assert(!(ElemSizeArg == 0 && NumElemsArg && *NumElemsArg == 0) &&
229 "Invalid allocsize arguments -- given allocsize(0, 0)");
241#define GET_ATTR_NAMES
242#define ATTRIBUTE_ENUM(ENUM_NAME, DISPLAY_NAME) \
243 .Case(#DISPLAY_NAME, Attribute::ENUM_NAME)
244#include "llvm/IR/Attributes.inc"
250#define GET_ATTR_NAMES
251#define ATTRIBUTE_ENUM(ENUM_NAME, DISPLAY_NAME) \
252 case Attribute::ENUM_NAME: \
253 return #DISPLAY_NAME;
254#include "llvm/IR/Attributes.inc"
264#define GET_ATTR_NAMES
265#define ATTRIBUTE_ALL(ENUM_NAME, DISPLAY_NAME) .Case(#DISPLAY_NAME, true)
266#include "llvm/IR/Attributes.inc"
291 if (!pImpl)
return None;
293 "Invalid attribute type to get the kind as an enum!");
298 if (!pImpl)
return 0;
300 "Expected the attribute to be an integer attribute!");
305 if (!pImpl)
return false;
307 "Expected the attribute to be a string attribute!");
312 if (!pImpl)
return {};
314 "Invalid attribute type to get the kind as a string!");
319 if (!pImpl)
return {};
321 "Invalid attribute type to get the value as a string!");
326 if (!pImpl)
return {};
328 "Invalid attribute type to get the value as a type!");
344 "Trying to get alignment from non-alignment attribute!");
350 "Trying to get alignment from non-alignment attribute!");
356 "Trying to get dereferenceable bytes from "
357 "non-dereferenceable attribute!");
363 "Trying to get dereferenceable bytes from "
364 "non-dereferenceable attribute!");
368std::pair<unsigned, std::optional<unsigned>>
371 "Trying to get allocsize args from non-allocsize attribute");
377 "Trying to get vscale args from non-vscale attribute");
383 "Trying to get vscale args from non-vscale attribute");
389 "Trying to get unwind table kind from non-uwtable attribute");
395 "Trying to get allockind value from non-allockind attribute");
401 "Can only call getMemoryEffects() on memory attribute");
407 "Can only call getNoFPClass() on nofpclass attribute");
426 if (!pImpl)
return {};
451 auto AttrWithBytesToString = [&](
const char *
Name) {
458 return AttrWithBytesToString(
"alignstack");
461 return AttrWithBytesToString(
"dereferenceable");
464 return AttrWithBytesToString(
"dereferenceable_or_null");
468 std::optional<unsigned> NumElems;
472 ?
"allocsize(" +
Twine(ElemSize) +
"," +
Twine(*NumElems) +
")"
473 :
"allocsize(" +
Twine(ElemSize) +
")")
480 return (
"vscale_range(" +
Twine(MinValue) +
"," +
481 Twine(MaxValue.value_or(0)) +
")")
511 return (
"allockind(\"" +
546 OS <<
"inaccessiblemem: ";
559 std::string Result =
"nofpclass";
580 if (!AttrVal.empty()) {
582 printEscapedString(AttrVal,
OS);
593 assert(
isValid() &&
"invalid Attribute doesn't refer to any context");
597 return C.pImpl->AttrsSet.FindNodeOrInsertPos(
ID, Unused) == pImpl;
601 if (!pImpl && !
A.pImpl)
return false;
602 if (!pImpl)
return true;
603 if (!
A.pImpl)
return false;
604 return *pImpl < *
A.pImpl;
608 ID.AddPointer(pImpl);
617#define GET_ATTR_PROP_TABLE
618#include "llvm/IR/Attributes.inc"
622 unsigned Index = Kind - 1;
623 assert(
Index < std::size(AttrPropTable) &&
"Invalid attribute kind");
624 return AttrPropTable[
Index] & Prop;
724 B.addAttribute(Kind);
731 B.addAttribute(Kind,
Value);
752 B.removeAttribute(Kind);
760 B.removeAttribute(Kind);
768 if (!
B.overlaps(Attrs))
796 return SetNode ? SetNode->
getAlignment() : std::nullopt;
824 return SetNode ? SetNode->
getAttributeType(Attribute::Preallocated) :
nullptr;
832 return SetNode ? SetNode->
getAttributeType(Attribute::ElementType) :
nullptr;
835std::optional<std::pair<unsigned, std::optional<unsigned>>>
867 return SetNode ? SetNode->
getAsString(InAttrGrp) :
"";
875 return C.pImpl->AttrsSetNodes.FindNodeOrInsertPos(
ID, Unused) == SetNode;
879 return SetNode ? SetNode->
begin() :
nullptr;
883 return SetNode ? SetNode->
end() :
nullptr;
886#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
899 : NumAttrs(Attrs.
size()) {
901 llvm::copy(Attrs, getTrailingObjects<Attribute>());
903 for (
const auto &
I : *
this) {
904 if (
I.isStringAttribute())
905 StringAttrs.insert({
I.getKindAsString(),
I });
907 AvailableAttrs.addAttribute(
I.getKindAsEnum());
915 return getSorted(
C, SortedAttrs);
920 if (SortedAttrs.
empty())
928 for (
const auto &Attr : SortedAttrs)
939 void *Mem = ::operator
new(totalSizeToAlloc<Attribute>(SortedAttrs.size()));
949 return getSorted(
C,
B.attrs());
953 return StringAttrs.count(Kind);
956std::optional<Attribute>
965 std::lower_bound(
begin(),
end() - StringAttrs.size(), Kind,
967 return A.getKindAsEnum() < Kind;
969 assert(
I !=
end() &&
I->hasAttribute(Kind) &&
"Presence check failed?");
974 if (
auto A = findEnumAttribute(Kind))
980 return StringAttrs.lookup(Kind);
984 if (
auto A = findEnumAttribute(Attribute::Alignment))
985 return A->getAlignment();
990 if (
auto A = findEnumAttribute(Attribute::StackAlignment))
991 return A->getStackAlignment();
996 if (
auto A = findEnumAttribute(Kind))
997 return A->getValueAsType();
1002 if (
auto A = findEnumAttribute(Attribute::Dereferenceable))
1003 return A->getDereferenceableBytes();
1008 if (
auto A = findEnumAttribute(Attribute::DereferenceableOrNull))
1009 return A->getDereferenceableOrNullBytes();
1013std::optional<std::pair<unsigned, std::optional<unsigned>>>
1015 if (
auto A = findEnumAttribute(Attribute::AllocSize))
1016 return A->getAllocSizeArgs();
1017 return std::nullopt;
1021 if (
auto A = findEnumAttribute(Attribute::VScaleRange))
1022 return A->getVScaleRangeMin();
1027 if (
auto A = findEnumAttribute(Attribute::VScaleRange))
1028 return A->getVScaleRangeMax();
1029 return std::nullopt;
1033 if (
auto A = findEnumAttribute(Attribute::UWTable))
1034 return A->getUWTableKind();
1039 if (
auto A = findEnumAttribute(Attribute::AllocKind))
1040 return A->getAllocKind();
1045 if (
auto A = findEnumAttribute(Attribute::Memory))
1046 return A->getMemoryEffects();
1051 if (
auto A = findEnumAttribute(Attribute::NoFPClass))
1052 return A->getNoFPClass();
1061 Str +=
I->getAsString(InAttrGrp);
1077 : NumAttrSets(Sets.
size()) {
1078 assert(!Sets.
empty() &&
"pointless AttributeListImpl");
1081 llvm::copy(Sets, getTrailingObjects<AttributeSet>());
1086 if (!
I.isStringAttribute())
1089 for (
const auto &Set : Sets)
1090 for (
const auto &
I : Set)
1091 if (!
I.isStringAttribute())
1101 for (
const auto &Set : Sets)
1102 ID.AddPointer(Set.SetNode);
1106 unsigned *
Index)
const {
1111 for (
unsigned I = 0,
E = NumAttrSets;
I !=
E; ++
I) {
1112 if (
begin()[
I].hasAttribute(Kind)) {
1123#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
1135 assert(!AttrSets.
empty() &&
"pointless AttributeListImpl");
1143 pImpl->
AttrsLists.FindNodeOrInsertPos(
ID, InsertPoint);
1150 AttributeListImpl::totalSizeToAlloc<AttributeSet>(AttrSets.
size()),
1153 pImpl->
AttrsLists.InsertNode(PA, InsertPoint);
1162 ArrayRef<std::pair<unsigned, Attribute>> Attrs) {
1168 "Misordered Attributes list!");
1170 [](
const std::pair<unsigned, Attribute> &Pair) {
1171 return Pair.second.isValid();
1173 "Pointless attribute!");
1179 E = Attrs.end();
I !=
E; ) {
1180 unsigned Index =
I->first;
1182 while (
I !=
E &&
I->first ==
Index) {
1190 return get(
C, AttrPairVec);
1195 ArrayRef<std::pair<unsigned, AttributeSet>> Attrs) {
1201 "Misordered Attributes list!");
1203 [](
const std::pair<unsigned, AttributeSet> &Pair) {
1204 return !Pair.second.hasAttributes();
1206 "Pointless attribute!");
1208 unsigned MaxIndex = Attrs.back().first;
1212 MaxIndex = Attrs[Attrs.size() - 2].first;
1215 for (
const auto &Pair : Attrs)
1218 return getImpl(
C, AttrVec);
1227 unsigned NumSets = 0;
1228 for (
size_t I = ArgAttrs.
size();
I != 0; --
I) {
1229 if (ArgAttrs[
I - 1].hasAttributes()) {
1259 return getImpl(
C, AttrSets);
1264 if (!Attrs.hasAttributes())
1268 AttrSets[
Index] = Attrs;
1269 return getImpl(
C, AttrSets);
1280 for (
const auto K : Kinds)
1282 return get(
C, Attrs);
1288 assert(Kinds.
size() == Values.
size() &&
"Mismatched attribute values.");
1290 auto VI = Values.
begin();
1291 for (
const auto K : Kinds)
1293 return get(
C, Attrs);
1299 for (
const auto &K : Kinds)
1301 return get(
C, Attrs);
1308 if (Attrs.size() == 1)
1311 unsigned MaxSize = 0;
1312 for (
const auto &
List : Attrs)
1313 MaxSize = std::max(MaxSize,
List.getNumAttrSets());
1320 for (
unsigned I = 0;
I < MaxSize; ++
I) {
1322 for (
const auto &
List : Attrs)
1327 return getImpl(
C, NewAttrSets);
1334 if (Attrs.hasAttribute(Kind))
1346 B.addAttribute(Kind,
Value);
1362 if (Index >= AttrSets.
size())
1363 AttrSets.resize(
Index + 1);
1364 AttrSets[
Index] = Attrs;
1367 while (!AttrSets.
empty() && !AttrSets.
back().hasAttributes())
1368 AttrSets.pop_back();
1369 if (AttrSets.
empty())
1371 return AttributeList::getImpl(
C, AttrSets);
1377 if (!
B.hasAttributes())
1395 if (MaxIndex >= AttrSets.
size())
1396 AttrSets.
resize(MaxIndex + 1);
1398 for (
unsigned ArgNo : ArgNos) {
1405 return getImpl(
C, AttrSets);
1413 if (Attrs == NewAttrs)
1415 return setAttributesAtIndex(
C,
Index, NewAttrs);
1423 if (Attrs == NewAttrs)
1425 return setAttributesAtIndex(
C,
Index, NewAttrs);
1431 AttributeSet NewAttrs = Attrs.removeAttributes(
C, AttrsToRemove);
1433 if (Attrs == NewAttrs)
1435 return setAttributesAtIndex(
C,
Index, NewAttrs);
1440 unsigned WithoutIndex)
const {
1445 return setAttributesAtIndex(
C, WithoutIndex,
AttributeSet());
1451 B.addDereferenceableAttr(Bytes);
1459 B.addDereferenceableAttr(Bytes);
1467 B.addDereferenceableOrNullAttr(Bytes);
1473 const std::optional<unsigned> &NumElemsArg) {
1475 B.addAllocSizeAttr(ElemSizeArg, NumElemsArg);
1509 return pImpl && pImpl->hasFnAttribute(Kind);
1517 unsigned *
Index)
const {
1518 return pImpl && pImpl->hasAttrSomewhere(Attr,
Index);
1620 return pImpl->begin()[
Index];
1624 assert(!
isEmpty() &&
"an empty attribute list has no parent context");
1628 return C.pImpl->AttrsLists.FindNodeOrInsertPos(
ID, Unused) == pImpl;
1632 return pImpl ? pImpl->begin() :
nullptr;
1636 return pImpl ? pImpl->end() :
nullptr;
1644 return pImpl ? pImpl->NumAttrSets : 0;
1648 O <<
"AttributeList[\n";
1650 for (
unsigned i :
indexes()) {
1670#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
1713template <
typename K>
1717 if (It != Attrs.end() && It->hasAttribute(Kind))
1720 Attrs.insert(It, Attr);
1744 if (It != Attrs.end() && It->hasAttribute(Val))
1751 if (It != Attrs.end() && It->hasAttribute(
A))
1756std::optional<uint64_t>
1761 return A.getValueAsInt();
1762 return std::nullopt;
1770std::optional<std::pair<unsigned, std::optional<unsigned>>>
1774 return A.getAllocSizeArgs();
1775 return std::nullopt;
1791 assert(*
Align <= 0x100 &&
"Alignment too large.");
1796 if (Bytes == 0)
return *
this;
1805 return addRawIntAttr(Attribute::DereferenceableOrNull, Bytes);
1810 const std::optional<unsigned> &NumElems) {
1816 assert(RawArgs &&
"Invalid allocsize arguments -- given allocsize(0, 0)");
1821 std::optional<unsigned> MaxValue) {
1857 return A.isValid() ?
A.getValueAsType() :
nullptr;
1886 for (
const auto &
I :
B.attrs())
1904 if (It != Attrs.end() && It->hasAttribute(
A))
1911 if (It != Attrs.end() && It->hasAttribute(
A))
1925 return Attrs ==
B.Attrs;
1937 while (
ArrayType *ArrTy = dyn_cast<ArrayType>(Ty))
1938 Ty = ArrTy->getElementType();
1995 return Incompatible;
2029 DenormalMode CallerModeF32 = Caller.getDenormalModeF32Raw();
2030 DenormalMode CalleeModeF32 = Callee.getDenormalModeF32Raw();
2032 CallerModeF32 = CallerMode;
2034 CalleeModeF32 = CalleeMode;
2041template<
typename AttrClass>
2043 return Caller.getFnAttribute(AttrClass::getKind()) ==
2044 Callee.getFnAttribute(AttrClass::getKind());
2052template<
typename AttrClass>
2054 if (AttrClass::isSet(Caller, AttrClass::getKind()) &&
2055 !AttrClass::isSet(Callee, AttrClass::getKind()))
2056 AttrClass::set(Caller, AttrClass::getKind(),
false);
2064template<
typename AttrClass>
2066 if (!AttrClass::isSet(Caller, AttrClass::getKind()) &&
2067 AttrClass::isSet(Callee, AttrClass::getKind()))
2068 AttrClass::set(Caller, AttrClass::getKind(),
true);
2077 if (!Caller.hasStackProtectorFnAttr())
2088 if (Callee.hasFnAttribute(Attribute::StackProtectReq)) {
2089 Caller.removeFnAttrs(OldSSPAttr);
2090 Caller.addFnAttr(Attribute::StackProtectReq);
2091 }
else if (Callee.hasFnAttribute(Attribute::StackProtectStrong) &&
2092 !Caller.hasFnAttribute(Attribute::StackProtectReq)) {
2093 Caller.removeFnAttrs(OldSSPAttr);
2094 Caller.addFnAttr(Attribute::StackProtectStrong);
2095 }
else if (Callee.hasFnAttribute(Attribute::StackProtect) &&
2096 !Caller.hasFnAttribute(Attribute::StackProtectReq) &&
2097 !Caller.hasFnAttribute(Attribute::StackProtectStrong))
2098 Caller.addFnAttr(Attribute::StackProtect);
2104 if (!Caller.hasFnAttribute(
"probe-stack") &&
2105 Callee.hasFnAttribute(
"probe-stack")) {
2106 Caller.addFnAttr(Callee.getFnAttribute(
"probe-stack"));
2115 Attribute CalleeAttr = Callee.getFnAttribute(
"stack-probe-size");
2117 Attribute CallerAttr = Caller.getFnAttribute(
"stack-probe-size");
2119 uint64_t CallerStackProbeSize, CalleeStackProbeSize;
2123 if (CallerStackProbeSize > CalleeStackProbeSize) {
2124 Caller.addFnAttr(CalleeAttr);
2127 Caller.addFnAttr(CalleeAttr);
2143 Attribute CallerAttr = Caller.getFnAttribute(
"min-legal-vector-width");
2145 Attribute CalleeAttr = Callee.getFnAttribute(
"min-legal-vector-width");
2147 uint64_t CallerVectorWidth, CalleeVectorWidth;
2150 if (CallerVectorWidth < CalleeVectorWidth)
2151 Caller.addFnAttr(CalleeAttr);
2155 Caller.removeFnAttr(
"min-legal-vector-width");
2164 if (Callee.nullPointerIsDefined() && !Caller.nullPointerIsDefined()) {
2165 Caller.addFnAttr(Attribute::NullPointerIsValid);
2188 return A.getValueAsString().equals(
"true");
2193 Fn.
addFnAttr(Kind, Val ?
"true" :
"false");
2197#define GET_ATTR_NAMES
2198#define ATTRIBUTE_ENUM(ENUM_NAME, DISPLAY_NAME) \
2199 struct ENUM_NAME##Attr : EnumAttr { \
2200 static enum Attribute::AttrKind getKind() { \
2201 return llvm::Attribute::ENUM_NAME; \
2204#define ATTRIBUTE_STRBOOL(ENUM_NAME, DISPLAY_NAME) \
2205 struct ENUM_NAME##Attr : StrBoolAttr { \
2206 static StringRef getKind() { return #DISPLAY_NAME; } \
2208#include "llvm/IR/Attributes.inc"
2210#define GET_ATTR_COMPAT_FUNC
2211#include "llvm/IR/Attributes.inc"
2215 return hasCompatibleFnAttrs(Caller, Callee);
2220 return hasCompatibleFnAttrs(
A,
B);
2225 mergeFnAttrs(Caller, Callee);
2238 mergeFnAttrs(
Base, ToMerge);
2247 if (Width > OldWidth)
2248 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 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")
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
#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...
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 & 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 & 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 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
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.
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)
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
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.
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
Sentinal value useful for loops.
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.
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
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 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::...