aeubanks created this revision.
Herald added subscribers: ormris, foad, dexonsmith, lxfind, okura, jdoerfert,
kuter, kerbowa, pengfei, Jim, hiraditya, jgravelle-google, sbc100, nhaehnle,
jvesely, dylanmckay, dschuff, arsenm, jholewinski.
aeubanks added reviewers: rnk, efriedma.
aeubanks published this revision for review.
Herald added subscribers: llvm-commits, cfe-commits, aheejin.
Herald added a reviewer: jdoerfert.
Herald added a reviewer: sstefan1.
Herald added a reviewer: baziotis.
Herald added projects: clang, LLVM.
I've been bitten by AttributeList::getAttribute() multiple times now,
thinking that it's getParamAttribute(). Renaming it makes it clearer
that callers should use the param/fn/ret version so they don't have to
worry about the somewhat horrifying implementation details of the
attribute indexes.
I couldn't quite manage to make the methods private since some callers
need larger cleanups. Also, the C API directly uses the indexes. Perhaps
we can clean things up in the future.
Currently the naming is inconsistent (Attribute vs Attr), I'll clean
that in in a followup change.
This doesn't touch addAttribute(), I'll also clean that up in a followup
change since this change is already large enough.
Repository:
rG LLVM Github Monorepo
https://reviews.llvm.org/D108013
Files:
clang/lib/CodeGen/CodeGenModule.cpp
llvm/include/llvm/IR/Attributes.h
llvm/include/llvm/IR/Function.h
llvm/include/llvm/IR/InstrTypes.h
llvm/lib/Analysis/Lint.cpp
llvm/lib/Analysis/VectorUtils.cpp
llvm/lib/AsmParser/LLParser.cpp
llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
llvm/lib/Bitcode/Writer/ValueEnumerator.cpp
llvm/lib/CodeGen/GlobalISel/CallLowering.cpp
llvm/lib/CodeGen/GlobalISel/LegalizerHelper.cpp
llvm/lib/CodeGen/MachinePipeliner.cpp
llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
llvm/lib/CodeGen/TargetLoweringBase.cpp
llvm/lib/IR/AsmWriter.cpp
llvm/lib/IR/Attributes.cpp
llvm/lib/IR/Core.cpp
llvm/lib/IR/Function.cpp
llvm/lib/IR/Instructions.cpp
llvm/lib/IR/Statepoint.cpp
llvm/lib/IR/Verifier.cpp
llvm/lib/Linker/IRMover.cpp
llvm/lib/Target/AArch64/GISel/AArch64CallLowering.cpp
llvm/lib/Target/AMDGPU/Utils/AMDGPUBaseInfo.cpp
llvm/lib/Target/AVR/AVRISelLowering.cpp
llvm/lib/Target/Hexagon/HexagonOptimizeSZextends.cpp
llvm/lib/Target/Hexagon/HexagonTargetMachine.cpp
llvm/lib/Target/NVPTX/NVPTXAsmPrinter.cpp
llvm/lib/Target/NVPTX/NVPTXISelLowering.cpp
llvm/lib/Target/WebAssembly/WebAssemblyFastISel.cpp
llvm/lib/Target/X86/X86ISelLowering.cpp
llvm/lib/Transforms/Coroutines/CoroSplit.cpp
llvm/lib/Transforms/IPO/Attributor.cpp
llvm/lib/Transforms/IPO/DeadArgumentElimination.cpp
llvm/lib/Transforms/IPO/FunctionAttrs.cpp
llvm/lib/Transforms/IPO/GlobalOpt.cpp
llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp
llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp
llvm/lib/Transforms/Scalar/RewriteStatepointsForGC.cpp
llvm/lib/Transforms/Utils/AssumeBundleBuilder.cpp
llvm/lib/Transforms/Utils/BuildLibCalls.cpp
llvm/lib/Transforms/Utils/FunctionComparator.cpp
llvm/lib/Transforms/Utils/ValueMapper.cpp
llvm/tools/llvm-reduce/deltas/ReduceAttributes.cpp
llvm/unittests/IR/AttributesTest.cpp
llvm/unittests/Transforms/Utils/VFABIUtils.cpp
Index: llvm/unittests/Transforms/Utils/VFABIUtils.cpp
===================================================================
--- llvm/unittests/Transforms/Utils/VFABIUtils.cpp
+++ llvm/unittests/Transforms/Utils/VFABIUtils.cpp
@@ -46,8 +46,7 @@
Mappings.push_back("_ZGVnN8v_g");
Mappings.push_back("_ZGVnN2v_g(custom_vg)");
VFABI::setVectorVariantNames(CI, Mappings);
- const StringRef S = CI->getAttribute(AttributeList::FunctionIndex,
- "vector-function-abi-variant")
- .getValueAsString();
+ const StringRef S =
+ CI->getFnAttr("vector-function-abi-variant").getValueAsString();
EXPECT_EQ(S, "_ZGVnN8v_g,_ZGVnN2v_g(custom_vg)");
}
Index: llvm/unittests/IR/AttributesTest.cpp
===================================================================
--- llvm/unittests/IR/AttributesTest.cpp
+++ llvm/unittests/IR/AttributesTest.cpp
@@ -54,7 +54,8 @@
AttributeList::get(C, 1, Attribute::SExt)};
AttributeList SetA = AttributeList::get(C, ASs);
- AttributeList SetB = SetA.removeAttributes(C, 1, ASs[1].getAttributes(1));
+ AttributeList SetB =
+ SetA.removeAttributes(C, 1, ASs[1].getParamAttributes(0));
EXPECT_NE(SetA, SetB);
}
@@ -68,7 +69,7 @@
B.clear();
B.addAttribute(Attribute::SExt);
AL = AL.addAttributes(C, AttributeList::ReturnIndex, B);
- EXPECT_TRUE(AL.hasAttribute(AttributeList::ReturnIndex, Attribute::SExt));
+ EXPECT_TRUE(AL.hasRetAttr(Attribute::SExt));
EXPECT_TRUE(AL.hasFnAttribute(Attribute::NoReturn));
}
@@ -102,9 +103,9 @@
AttributeList AL;
AL = AL.addParamAttributes(C, 0, B_align_readonly);
AL = AL.addAttributes(C, 0, B_stackalign_optnone);
- EXPECT_TRUE(AL.hasAttributes(0));
- EXPECT_TRUE(AL.hasAttribute(0, Attribute::StackAlignment));
- EXPECT_TRUE(AL.hasAttribute(0, Attribute::OptimizeNone));
+ EXPECT_TRUE(AL.hasRetAttributes());
+ EXPECT_TRUE(AL.hasRetAttr(Attribute::StackAlignment));
+ EXPECT_TRUE(AL.hasRetAttr(Attribute::OptimizeNone));
EXPECT_TRUE(AL.getStackAlignment(0) == 32);
EXPECT_TRUE(AL.hasParamAttrs(0));
EXPECT_TRUE(AL.hasParamAttr(0, Attribute::Alignment));
@@ -114,15 +115,15 @@
AL = AL.removeParamAttribute(C, 0, Attribute::Alignment);
EXPECT_FALSE(AL.hasParamAttr(0, Attribute::Alignment));
EXPECT_TRUE(AL.hasParamAttr(0, Attribute::ReadOnly));
- EXPECT_TRUE(AL.hasAttribute(0, Attribute::StackAlignment));
- EXPECT_TRUE(AL.hasAttribute(0, Attribute::OptimizeNone));
+ EXPECT_TRUE(AL.hasRetAttr(Attribute::StackAlignment));
+ EXPECT_TRUE(AL.hasRetAttr(Attribute::OptimizeNone));
EXPECT_TRUE(AL.getStackAlignment(0) == 32);
AL = AL.removeAttribute(C, 0, Attribute::StackAlignment);
EXPECT_FALSE(AL.hasParamAttr(0, Attribute::Alignment));
EXPECT_TRUE(AL.hasParamAttr(0, Attribute::ReadOnly));
- EXPECT_FALSE(AL.hasAttribute(0, Attribute::StackAlignment));
- EXPECT_TRUE(AL.hasAttribute(0, Attribute::OptimizeNone));
+ EXPECT_FALSE(AL.hasRetAttr(Attribute::StackAlignment));
+ EXPECT_TRUE(AL.hasRetAttr(Attribute::OptimizeNone));
AttributeList AL2;
AL2 = AL2.addParamAttributes(C, 0, B_align_readonly);
@@ -131,15 +132,15 @@
AL2 = AL2.removeParamAttributes(C, 0, B_align);
EXPECT_FALSE(AL2.hasParamAttr(0, Attribute::Alignment));
EXPECT_TRUE(AL2.hasParamAttr(0, Attribute::ReadOnly));
- EXPECT_TRUE(AL2.hasAttribute(0, Attribute::StackAlignment));
- EXPECT_TRUE(AL2.hasAttribute(0, Attribute::OptimizeNone));
+ EXPECT_TRUE(AL2.hasRetAttr(Attribute::StackAlignment));
+ EXPECT_TRUE(AL2.hasRetAttr(Attribute::OptimizeNone));
EXPECT_TRUE(AL2.getStackAlignment(0) == 32);
AL2 = AL2.removeAttributes(C, 0, B_stackalign);
EXPECT_FALSE(AL2.hasParamAttr(0, Attribute::Alignment));
EXPECT_TRUE(AL2.hasParamAttr(0, Attribute::ReadOnly));
- EXPECT_FALSE(AL2.hasAttribute(0, Attribute::StackAlignment));
- EXPECT_TRUE(AL2.hasAttribute(0, Attribute::OptimizeNone));
+ EXPECT_FALSE(AL2.hasRetAttr(Attribute::StackAlignment));
+ EXPECT_TRUE(AL2.hasRetAttr(Attribute::OptimizeNone));
}
TEST(Attributes, AddMatchingAlignAttr) {
@@ -158,7 +159,7 @@
AL = AL.addAttributes(C, AttributeList::FirstArgIndex, B);
EXPECT_EQ(Align(8), AL.getParamAlignment(0));
EXPECT_EQ(Align(32), AL.getParamAlignment(1));
- EXPECT_TRUE(AL.hasParamAttribute(0, Attribute::NonNull));
+ EXPECT_TRUE(AL.hasParamAttr(0, Attribute::NonNull));
}
TEST(Attributes, EmptyGet) {
Index: llvm/tools/llvm-reduce/deltas/ReduceAttributes.cpp
===================================================================
--- llvm/tools/llvm-reduce/deltas/ReduceAttributes.cpp
+++ llvm/tools/llvm-reduce/deltas/ReduceAttributes.cpp
@@ -88,7 +88,7 @@
SetIdx != SetEndIdx; ++SetIdx) {
AttrPtrIdxVecVecTy AttributesToPreserve;
AttributesToPreserve.first = SetIdx;
- visitAttributeSet(AL.getAttributes(AttributesToPreserve.first),
+ visitAttributeSet(AL.getAttributesImpl(AttributesToPreserve.first),
AttributesToPreserve.second);
if (!AttributesToPreserve.second.empty())
AttributeSetsToPreserve.emplace_back(std::move(AttributesToPreserve));
Index: llvm/lib/Transforms/Utils/ValueMapper.cpp
===================================================================
--- llvm/lib/Transforms/Utils/ValueMapper.cpp
+++ llvm/lib/Transforms/Utils/ValueMapper.cpp
@@ -947,7 +947,7 @@
for (Attribute::AttrKind TypedAttr :
{Attribute::ByVal, Attribute::StructRet, Attribute::ByRef,
Attribute::InAlloca}) {
- if (Type *Ty = Attrs.getAttribute(i, TypedAttr).getValueAsType()) {
+ if (Type *Ty = Attrs.getAttributeImpl(i, TypedAttr).getValueAsType()) {
Attrs = Attrs.replaceAttributeType(C, i, TypedAttr,
TypeMapper->remapType(Ty));
break;
Index: llvm/lib/Transforms/Utils/FunctionComparator.cpp
===================================================================
--- llvm/lib/Transforms/Utils/FunctionComparator.cpp
+++ llvm/lib/Transforms/Utils/FunctionComparator.cpp
@@ -111,8 +111,8 @@
return Res;
for (unsigned i = L.index_begin(), e = L.index_end(); i != e; ++i) {
- AttributeSet LAS = L.getAttributes(i);
- AttributeSet RAS = R.getAttributes(i);
+ AttributeSet LAS = L.getAttributesImpl(i);
+ AttributeSet RAS = R.getAttributesImpl(i);
AttributeSet::iterator LI = LAS.begin(), LE = LAS.end();
AttributeSet::iterator RI = RAS.begin(), RE = RAS.end();
for (; LI != LE && RI != RE; ++LI, ++RI) {
Index: llvm/lib/Transforms/Utils/BuildLibCalls.cpp
===================================================================
--- llvm/lib/Transforms/Utils/BuildLibCalls.cpp
+++ llvm/lib/Transforms/Utils/BuildLibCalls.cpp
@@ -96,7 +96,7 @@
}
static bool setRetDoesNotAlias(Function &F) {
- if (F.hasAttribute(AttributeList::ReturnIndex, Attribute::NoAlias))
+ if (F.hasRetAttribute(Attribute::NoAlias))
return false;
F.addAttribute(AttributeList::ReturnIndex, Attribute::NoAlias);
++NumNoAlias;
@@ -145,7 +145,7 @@
static bool setRetNoUndef(Function &F) {
if (!F.getReturnType()->isVoidTy() &&
- !F.hasAttribute(AttributeList::ReturnIndex, Attribute::NoUndef)) {
+ !F.hasRetAttribute(Attribute::NoUndef)) {
F.addAttribute(AttributeList::ReturnIndex, Attribute::NoUndef);
++NumNoUndef;
return true;
Index: llvm/lib/Transforms/Utils/AssumeBundleBuilder.cpp
===================================================================
--- llvm/lib/Transforms/Utils/AssumeBundleBuilder.cpp
+++ llvm/lib/Transforms/Utils/AssumeBundleBuilder.cpp
@@ -206,7 +206,7 @@
auto addAttrList = [&](AttributeList AttrList) {
for (unsigned Idx = AttributeList::FirstArgIndex;
Idx < AttrList.getNumAttrSets(); Idx++)
- for (Attribute Attr : AttrList.getAttributes(Idx)) {
+ for (Attribute Attr : AttrList.getAttributesImpl(Idx)) {
bool IsPoisonAttr = Attr.hasAttribute(Attribute::NonNull) ||
Attr.hasAttribute(Attribute::Alignment);
if (!IsPoisonAttr || Call->isPassingUndefUB(Idx - 1))
Index: llvm/lib/Transforms/Scalar/RewriteStatepointsForGC.cpp
===================================================================
--- llvm/lib/Transforms/Scalar/RewriteStatepointsForGC.cpp
+++ llvm/lib/Transforms/Scalar/RewriteStatepointsForGC.cpp
@@ -1533,9 +1533,8 @@
// FIXME: Calls have a *really* confusing interface around attributes
// with values.
const AttributeList &CSAS = Call->getAttributes();
- if (CSAS.hasAttribute(AttributeList::FunctionIndex, DeoptLowering))
- return CSAS.getAttribute(AttributeList::FunctionIndex, DeoptLowering)
- .getValueAsString();
+ if (CSAS.hasFnAttribute(DeoptLowering))
+ return CSAS.getFnAttr(DeoptLowering).getValueAsString();
Function *F = Call->getCalledFunction();
assert(F && F->hasFnAttribute(DeoptLowering));
return F->getFnAttribute(DeoptLowering).getValueAsString();
@@ -2663,7 +2662,7 @@
R.addAttribute(Attribute::get(Ctx, Attribute::DereferenceableOrNull,
AH.getDereferenceableOrNullBytes(Index)));
for (auto Attr : ParamAttrsToStrip)
- if (AH.getAttributes().hasAttribute(Index, Attr))
+ if (AH.getAttributes().hasAttributeImpl(Index, Attr))
R.addAttribute(Attr);
if (!R.empty())
Index: llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp
===================================================================
--- llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp
+++ llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp
@@ -3806,8 +3806,7 @@
// Don't emit the epilogue for musttail call returns.
if (isAMustTailRetVal(RetVal)) return;
Value *ShadowPtr = getShadowPtrForRetval(RetVal, IRB);
- bool HasNoUndef =
- F.hasAttribute(AttributeList::ReturnIndex, Attribute::NoUndef);
+ bool HasNoUndef = F.hasRetAttribute(Attribute::NoUndef);
bool StoreShadow = !(ClEagerChecks && HasNoUndef);
// FIXME: Consider using SpecialCaseList to specify a list of functions that
// must always return fully initialized values. For now, we hardcode "main".
Index: llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp
===================================================================
--- llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp
+++ llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp
@@ -2836,12 +2836,12 @@
if (Call.isInAllocaArgument(i))
return false; // Cannot transform to and from inalloca.
- if (CallerPAL.hasParamAttribute(i, Attribute::SwiftError))
+ if (CallerPAL.hasParamAttr(i, Attribute::SwiftError))
return false;
// If the parameter is passed as a byval argument, then we have to have a
// sized type and the sized type has to have the same size as the old type.
- if (ParamTy != ActTy && CallerPAL.hasParamAttribute(i, Attribute::ByVal)) {
+ if (ParamTy != ActTy && CallerPAL.hasParamAttr(i, Attribute::ByVal)) {
PointerType *ParamPTy = dyn_cast<PointerType>(ParamTy);
if (!ParamPTy || !ParamPTy->getElementType()->isSized())
return false;
@@ -2911,7 +2911,7 @@
Args.push_back(NewArg);
// Add any parameter attributes.
- if (CallerPAL.hasParamAttribute(i, Attribute::ByVal)) {
+ if (CallerPAL.hasParamAttr(i, Attribute::ByVal)) {
AttrBuilder AB(CallerPAL.getParamAttributes(i));
AB.addByValAttr(NewArg->getType()->getPointerElementType());
ArgAttrs.push_back(AttributeSet::get(Ctx, AB));
Index: llvm/lib/Transforms/IPO/GlobalOpt.cpp
===================================================================
--- llvm/lib/Transforms/IPO/GlobalOpt.cpp
+++ llvm/lib/Transforms/IPO/GlobalOpt.cpp
@@ -1914,10 +1914,8 @@
Value *AllocaReplacement = ArgAllocas[AllocArgIndex];
if (!AllocaReplacement) {
auto AddressSpace = UseCall->getType()->getPointerAddressSpace();
- auto *ArgType = UseCall
- ->getAttribute(AttributeList::FunctionIndex,
- Attribute::Preallocated)
- .getValueAsType();
+ auto *ArgType =
+ UseCall->getFnAttr(Attribute::Preallocated).getValueAsType();
auto *InsertBefore = PreallocatedSetup->getNextNonDebugInstruction();
Builder.SetInsertPoint(InsertBefore);
auto *Alloca =
Index: llvm/lib/Transforms/IPO/FunctionAttrs.cpp
===================================================================
--- llvm/lib/Transforms/IPO/FunctionAttrs.cpp
+++ llvm/lib/Transforms/IPO/FunctionAttrs.cpp
@@ -1055,8 +1055,7 @@
// pointers.
for (Function *F : SCCNodes) {
// Already nonnull.
- if (F->getAttributes().hasAttribute(AttributeList::ReturnIndex,
- Attribute::NonNull))
+ if (F->getAttributes().hasRetAttr(Attribute::NonNull))
continue;
// We can infer and propagate function attributes only when we know that the
@@ -1090,8 +1089,7 @@
if (SCCReturnsNonNull) {
for (Function *F : SCCNodes) {
- if (F->getAttributes().hasAttribute(AttributeList::ReturnIndex,
- Attribute::NonNull) ||
+ if (F->getAttributes().hasRetAttr(Attribute::NonNull) ||
!F->getReturnType()->isPointerTy())
continue;
Index: llvm/lib/Transforms/IPO/DeadArgumentElimination.cpp
===================================================================
--- llvm/lib/Transforms/IPO/DeadArgumentElimination.cpp
+++ llvm/lib/Transforms/IPO/DeadArgumentElimination.cpp
@@ -763,7 +763,7 @@
Params.push_back(I->getType());
ArgAlive[ArgI] = true;
ArgAttrVec.push_back(PAL.getParamAttributes(ArgI));
- HasLiveReturnedArg |= PAL.hasParamAttribute(ArgI, Attribute::Returned);
+ HasLiveReturnedArg |= PAL.hasParamAttr(ArgI, Attribute::Returned);
} else {
++NumArgumentsEliminated;
LLVM_DEBUG(dbgs() << "DeadArgumentEliminationPass - Removing argument "
Index: llvm/lib/Transforms/IPO/Attributor.cpp
===================================================================
--- llvm/lib/Transforms/IPO/Attributor.cpp
+++ llvm/lib/Transforms/IPO/Attributor.cpp
@@ -382,27 +382,27 @@
if (Attr.isEnumAttribute()) {
Attribute::AttrKind Kind = Attr.getKindAsEnum();
- if (Attrs.hasAttribute(AttrIdx, Kind))
+ if (Attrs.hasAttributeImpl(AttrIdx, Kind))
if (!ForceReplace &&
- isEqualOrWorse(Attr, Attrs.getAttribute(AttrIdx, Kind)))
+ isEqualOrWorse(Attr, Attrs.getAttributeImpl(AttrIdx, Kind)))
return false;
Attrs = Attrs.addAttribute(Ctx, AttrIdx, Attr);
return true;
}
if (Attr.isStringAttribute()) {
StringRef Kind = Attr.getKindAsString();
- if (Attrs.hasAttribute(AttrIdx, Kind))
+ if (Attrs.hasAttributeImpl(AttrIdx, Kind))
if (!ForceReplace &&
- isEqualOrWorse(Attr, Attrs.getAttribute(AttrIdx, Kind)))
+ isEqualOrWorse(Attr, Attrs.getAttributeImpl(AttrIdx, Kind)))
return false;
Attrs = Attrs.addAttribute(Ctx, AttrIdx, Attr);
return true;
}
if (Attr.isIntAttribute()) {
Attribute::AttrKind Kind = Attr.getKindAsEnum();
- if (Attrs.hasAttribute(AttrIdx, Kind))
+ if (Attrs.hasAttributeImpl(AttrIdx, Kind))
if (!ForceReplace &&
- isEqualOrWorse(Attr, Attrs.getAttribute(AttrIdx, Kind)))
+ isEqualOrWorse(Attr, Attrs.getAttributeImpl(AttrIdx, Kind)))
return false;
Attrs = Attrs.removeAttribute(Ctx, AttrIdx, Kind);
Attrs = Attrs.addAttribute(Ctx, AttrIdx, Attr);
@@ -658,9 +658,9 @@
else
AttrList = getAssociatedFunction()->getAttributes();
- bool HasAttr = AttrList.hasAttribute(getAttrIdx(), AK);
+ bool HasAttr = AttrList.hasAttributeImpl(getAttrIdx(), AK);
if (HasAttr)
- Attrs.push_back(AttrList.getAttribute(getAttrIdx(), AK));
+ Attrs.push_back(AttrList.getAttributeImpl(getAttrIdx(), AK));
return HasAttr;
}
Index: llvm/lib/Transforms/Coroutines/CoroSplit.cpp
===================================================================
--- llvm/lib/Transforms/Coroutines/CoroSplit.cpp
+++ llvm/lib/Transforms/Coroutines/CoroSplit.cpp
@@ -1262,7 +1262,7 @@
Attribute::SwiftSelf, Attribute::SwiftError};
AttributeList Attrs = CI.getAttributes();
for (auto AK : ABIAttrs)
- if (Attrs.hasParamAttribute(0, AK))
+ if (Attrs.hasParamAttr(0, AK))
return false;
return true;
Index: llvm/lib/Target/X86/X86ISelLowering.cpp
===================================================================
--- llvm/lib/Target/X86/X86ISelLowering.cpp
+++ llvm/lib/Target/X86/X86ISelLowering.cpp
@@ -27235,11 +27235,11 @@
if (!Attrs.isEmpty() && !Func->isVarArg()) {
unsigned InRegCount = 0;
- unsigned Idx = 1;
+ unsigned Idx = 0;
for (FunctionType::param_iterator I = FTy->param_begin(),
E = FTy->param_end(); I != E; ++I, ++Idx)
- if (Attrs.hasAttribute(Idx, Attribute::InReg)) {
+ if (Attrs.hasParamAttr(Idx, Attribute::InReg)) {
const DataLayout &DL = DAG.getDataLayout();
// FIXME: should only count parameters that are lowered to integers.
InRegCount += (DL.getTypeSizeInBits(*I) + 31) / 32;
Index: llvm/lib/Target/WebAssembly/WebAssemblyFastISel.cpp
===================================================================
--- llvm/lib/Target/WebAssembly/WebAssemblyFastISel.cpp
+++ llvm/lib/Target/WebAssembly/WebAssemblyFastISel.cpp
@@ -648,11 +648,11 @@
unsigned I = 0;
for (auto const &Arg : F->args()) {
const AttributeList &Attrs = F->getAttributes();
- if (Attrs.hasParamAttribute(I, Attribute::ByVal) ||
- Attrs.hasParamAttribute(I, Attribute::SwiftSelf) ||
- Attrs.hasParamAttribute(I, Attribute::SwiftError) ||
- Attrs.hasParamAttribute(I, Attribute::InAlloca) ||
- Attrs.hasParamAttribute(I, Attribute::Nest))
+ if (Attrs.hasParamAttr(I, Attribute::ByVal) ||
+ Attrs.hasParamAttr(I, Attribute::SwiftSelf) ||
+ Attrs.hasParamAttr(I, Attribute::SwiftError) ||
+ Attrs.hasParamAttr(I, Attribute::InAlloca) ||
+ Attrs.hasParamAttr(I, Attribute::Nest))
return false;
Type *ArgTy = Arg.getType();
@@ -832,18 +832,18 @@
return false;
const AttributeList &Attrs = Call->getAttributes();
- if (Attrs.hasParamAttribute(I, Attribute::ByVal) ||
- Attrs.hasParamAttribute(I, Attribute::SwiftSelf) ||
- Attrs.hasParamAttribute(I, Attribute::SwiftError) ||
- Attrs.hasParamAttribute(I, Attribute::InAlloca) ||
- Attrs.hasParamAttribute(I, Attribute::Nest))
+ if (Attrs.hasParamAttr(I, Attribute::ByVal) ||
+ Attrs.hasParamAttr(I, Attribute::SwiftSelf) ||
+ Attrs.hasParamAttr(I, Attribute::SwiftError) ||
+ Attrs.hasParamAttr(I, Attribute::InAlloca) ||
+ Attrs.hasParamAttr(I, Attribute::Nest))
return false;
unsigned Reg;
- if (Attrs.hasParamAttribute(I, Attribute::SExt))
+ if (Attrs.hasParamAttr(I, Attribute::SExt))
Reg = getRegForSignedValue(V);
- else if (Attrs.hasParamAttribute(I, Attribute::ZExt))
+ else if (Attrs.hasParamAttr(I, Attribute::ZExt))
Reg = getRegForUnsignedValue(V);
else
Reg = getRegForValue(V);
@@ -1370,9 +1370,9 @@
}
unsigned Reg;
- if (FuncInfo.Fn->getAttributes().hasAttribute(0, Attribute::SExt))
+ if (FuncInfo.Fn->getAttributes().hasRetAttr(Attribute::SExt))
Reg = getRegForSignedValue(RV);
- else if (FuncInfo.Fn->getAttributes().hasAttribute(0, Attribute::ZExt))
+ else if (FuncInfo.Fn->getAttributes().hasRetAttr(Attribute::ZExt))
Reg = getRegForUnsignedValue(RV);
else
Reg = getRegForValue(RV);
Index: llvm/lib/Target/NVPTX/NVPTXISelLowering.cpp
===================================================================
--- llvm/lib/Target/NVPTX/NVPTXISelLowering.cpp
+++ llvm/lib/Target/NVPTX/NVPTXISelLowering.cpp
@@ -2530,7 +2530,7 @@
// to newly created nodes. The SDNodes for params have to
// appear in the same order as their order of appearance
// in the original function. "idx+1" holds that order.
- if (!PAL.hasParamAttribute(i, Attribute::ByVal)) {
+ if (!PAL.hasParamAttr(i, Attribute::ByVal)) {
bool aggregateIsPacked = false;
if (StructType *STy = dyn_cast<StructType>(Ty))
aggregateIsPacked = STy->isPacked();
Index: llvm/lib/Target/NVPTX/NVPTXAsmPrinter.cpp
===================================================================
--- llvm/lib/Target/NVPTX/NVPTXAsmPrinter.cpp
+++ llvm/lib/Target/NVPTX/NVPTXAsmPrinter.cpp
@@ -1457,7 +1457,7 @@
}
}
- if (!PAL.hasParamAttribute(paramIndex, Attribute::ByVal)) {
+ if (!PAL.hasParamAttr(paramIndex, Attribute::ByVal)) {
if (Ty->isAggregateType() || Ty->isVectorTy() || Ty->isIntegerTy(128)) {
// Just print .param .align <a> .b8 .param[size];
// <a> = PAL.getparamalignment
Index: llvm/lib/Target/Hexagon/HexagonTargetMachine.cpp
===================================================================
--- llvm/lib/Target/Hexagon/HexagonTargetMachine.cpp
+++ llvm/lib/Target/Hexagon/HexagonTargetMachine.cpp
@@ -237,10 +237,8 @@
const HexagonSubtarget *
HexagonTargetMachine::getSubtargetImpl(const Function &F) const {
AttributeList FnAttrs = F.getAttributes();
- Attribute CPUAttr =
- FnAttrs.getAttribute(AttributeList::FunctionIndex, "target-cpu");
- Attribute FSAttr =
- FnAttrs.getAttribute(AttributeList::FunctionIndex, "target-features");
+ Attribute CPUAttr = FnAttrs.getFnAttr("target-cpu");
+ Attribute FSAttr = FnAttrs.getFnAttr("target-features");
std::string CPU =
CPUAttr.isValid() ? CPUAttr.getValueAsString().str() : TargetCPU;
Index: llvm/lib/Target/Hexagon/HexagonOptimizeSZextends.cpp
===================================================================
--- llvm/lib/Target/Hexagon/HexagonOptimizeSZextends.cpp
+++ llvm/lib/Target/Hexagon/HexagonOptimizeSZextends.cpp
@@ -67,12 +67,12 @@
if (skipFunction(F))
return false;
- unsigned Idx = 1;
+ unsigned Idx = 0;
// Try to optimize sign extends in formal parameters. It's relying on
// callee already sign extending the values. I'm not sure if our ABI
// requires callee to sign extend though.
for (auto &Arg : F.args()) {
- if (F.getAttributes().hasAttribute(Idx, Attribute::SExt)) {
+ if (F.getAttributes().hasParamAttr(Idx, Attribute::SExt)) {
if (!isa<PointerType>(Arg.getType())) {
for (auto UI = Arg.use_begin(); UI != Arg.use_end();) {
if (isa<SExtInst>(*UI)) {
Index: llvm/lib/Target/AVR/AVRISelLowering.cpp
===================================================================
--- llvm/lib/Target/AVR/AVRISelLowering.cpp
+++ llvm/lib/Target/AVR/AVRISelLowering.cpp
@@ -1488,8 +1488,7 @@
// Don't emit the ret/reti instruction when the naked attribute is present in
// the function being compiled.
- if (MF.getFunction().getAttributes().hasAttribute(
- AttributeList::FunctionIndex, Attribute::Naked)) {
+ if (MF.getFunction().getAttributes().hasFnAttribute(Attribute::Naked)) {
return Chain;
}
Index: llvm/lib/Target/AMDGPU/Utils/AMDGPUBaseInfo.cpp
===================================================================
--- llvm/lib/Target/AMDGPU/Utils/AMDGPUBaseInfo.cpp
+++ llvm/lib/Target/AMDGPU/Utils/AMDGPUBaseInfo.cpp
@@ -1825,8 +1825,8 @@
case CallingConv::AMDGPU_Gfx:
// For non-compute shaders, SGPR inputs are marked with either inreg or byval.
// Everything else is in VGPRs.
- return F->getAttributes().hasParamAttribute(A->getArgNo(), Attribute::InReg) ||
- F->getAttributes().hasParamAttribute(A->getArgNo(), Attribute::ByVal);
+ return F->getAttributes().hasParamAttr(A->getArgNo(), Attribute::InReg) ||
+ F->getAttributes().hasParamAttr(A->getArgNo(), Attribute::ByVal);
default:
// TODO: Should calls support inreg for SGPR inputs?
return false;
Index: llvm/lib/Target/AArch64/GISel/AArch64CallLowering.cpp
===================================================================
--- llvm/lib/Target/AArch64/GISel/AArch64CallLowering.cpp
+++ llvm/lib/Target/AArch64/GISel/AArch64CallLowering.cpp
@@ -387,11 +387,9 @@
MVT NewVT = TLI.getRegisterTypeForCallingConv(Ctx, CC, SplitEVTs[i]);
if (EVT(NewVT) != SplitEVTs[i]) {
unsigned ExtendOp = TargetOpcode::G_ANYEXT;
- if (F.getAttributes().hasAttribute(AttributeList::ReturnIndex,
- Attribute::SExt))
+ if (F.getAttributes().hasRetAttr(Attribute::SExt))
ExtendOp = TargetOpcode::G_SEXT;
- else if (F.getAttributes().hasAttribute(AttributeList::ReturnIndex,
- Attribute::ZExt))
+ else if (F.getAttributes().hasRetAttr(Attribute::ZExt))
ExtendOp = TargetOpcode::G_ZEXT;
LLT NewLLT(NewVT);
Index: llvm/lib/Linker/IRMover.cpp
===================================================================
--- llvm/lib/Linker/IRMover.cpp
+++ llvm/lib/Linker/IRMover.cpp
@@ -651,8 +651,8 @@
for (Attribute::AttrKind TypedAttr :
{Attribute::ByVal, Attribute::StructRet, Attribute::ByRef,
Attribute::InAlloca}) {
- if (Attrs.hasAttribute(i, TypedAttr)) {
- if (Type *Ty = Attrs.getAttribute(i, TypedAttr).getValueAsType()) {
+ if (Attrs.hasAttributeImpl(i, TypedAttr)) {
+ if (Type *Ty = Attrs.getAttributeImpl(i, TypedAttr).getValueAsType()) {
Attrs = Attrs.replaceAttributeType(C, i, TypedAttr, TypeMap.get(Ty));
break;
}
Index: llvm/lib/IR/Verifier.cpp
===================================================================
--- llvm/lib/IR/Verifier.cpp
+++ llvm/lib/IR/Verifier.cpp
@@ -1825,8 +1825,7 @@
void Verifier::checkUnsignedBaseTenFuncAttr(AttributeList Attrs, StringRef Attr,
const Value *V) {
if (Attrs.hasFnAttribute(Attr)) {
- StringRef S = Attrs.getAttribute(AttributeList::FunctionIndex, Attr)
- .getValueAsString();
+ StringRef S = Attrs.getFnAttr(Attr).getValueAsString();
unsigned N;
if (S.getAsInteger(10, N))
CheckFailed("\"" + Attr + "\" takes an unsigned integer: " + S, V);
@@ -1928,7 +1927,7 @@
}
}
- if (!Attrs.hasAttributes(AttributeList::FunctionIndex))
+ if (!Attrs.hasFnAttributes())
return;
verifyAttributeTypes(Attrs.getFnAttributes(), V);
@@ -2018,8 +2017,7 @@
}
if (Attrs.hasFnAttribute("frame-pointer")) {
- StringRef FP = Attrs.getAttribute(AttributeList::FunctionIndex,
- "frame-pointer").getValueAsString();
+ StringRef FP = Attrs.getFnAttr("frame-pointer").getValueAsString();
if (FP != "all" && FP != "non-leaf" && FP != "none")
CheckFailed("invalid value for 'frame-pointer' attribute: " + FP, V);
}
@@ -2348,7 +2346,7 @@
case CallingConv::C:
break;
case CallingConv::X86_INTR: {
- Assert(F.arg_empty() || Attrs.hasParamAttribute(0, Attribute::ByVal),
+ Assert(F.arg_empty() || Attrs.hasParamAttr(0, Attribute::ByVal),
"Calling convention parameter requires byval", &F);
break;
}
@@ -2368,14 +2366,14 @@
const unsigned StackAS = DL.getAllocaAddrSpace();
unsigned i = 0;
for (const Argument &Arg : F.args()) {
- Assert(!Attrs.hasParamAttribute(i, Attribute::ByVal),
+ Assert(!Attrs.hasParamAttr(i, Attribute::ByVal),
"Calling convention disallows byval", &F);
- Assert(!Attrs.hasParamAttribute(i, Attribute::Preallocated),
+ Assert(!Attrs.hasParamAttr(i, Attribute::Preallocated),
"Calling convention disallows preallocated", &F);
- Assert(!Attrs.hasParamAttribute(i, Attribute::InAlloca),
+ Assert(!Attrs.hasParamAttr(i, Attribute::InAlloca),
"Calling convention disallows inalloca", &F);
- if (Attrs.hasParamAttribute(i, Attribute::ByRef)) {
+ if (Attrs.hasParamAttr(i, Attribute::ByRef)) {
// FIXME: Should also disallow LDS and GDS, but we don't have the enum
// value here.
Assert(Arg.getType()->getPointerAddressSpace() != StackAS,
@@ -2416,7 +2414,7 @@
}
// Check that swifterror argument is only used by loads and stores.
- if (Attrs.hasParamAttribute(i, Attribute::SwiftError)) {
+ if (Attrs.hasParamAttr(i, Attribute::SwiftError)) {
verifySwiftErrorValue(&Arg);
}
++i;
@@ -3118,7 +3116,7 @@
Call);
}
- if (Attrs.hasParamAttribute(i, Attribute::ImmArg)) {
+ if (Attrs.hasParamAttr(i, Attribute::ImmArg)) {
// Don't allow immarg on call sites, unless the underlying declaration
// also has the matching immarg.
Assert(Callee && Callee->hasParamAttribute(i, Attribute::ImmArg),
@@ -3150,9 +3148,9 @@
bool SawReturned = false;
for (unsigned Idx = 0; Idx < FTy->getNumParams(); ++Idx) {
- if (Attrs.hasParamAttribute(Idx, Attribute::Nest))
+ if (Attrs.hasParamAttr(Idx, Attribute::Nest))
SawNest = true;
- if (Attrs.hasParamAttribute(Idx, Attribute::Returned))
+ if (Attrs.hasParamAttr(Idx, Attribute::Returned))
SawReturned = true;
}
@@ -3329,9 +3327,9 @@
}
// `align` is ABI-affecting only in combination with `byval` or `byref`.
- if (Attrs.hasParamAttribute(I, Attribute::Alignment) &&
- (Attrs.hasParamAttribute(I, Attribute::ByVal) ||
- Attrs.hasParamAttribute(I, Attribute::ByRef)))
+ if (Attrs.hasParamAttr(I, Attribute::Alignment) &&
+ (Attrs.hasParamAttr(I, Attribute::ByVal) ||
+ Attrs.hasParamAttr(I, Attribute::ByRef)))
Copy.addAlignmentAttr(Attrs.getParamAlignment(I));
return Copy;
}
Index: llvm/lib/IR/Statepoint.cpp
===================================================================
--- llvm/lib/IR/Statepoint.cpp
+++ llvm/lib/IR/Statepoint.cpp
@@ -26,16 +26,14 @@
llvm::parseStatepointDirectivesFromAttrs(AttributeList AS) {
StatepointDirectives Result;
- Attribute AttrID =
- AS.getAttribute(AttributeList::FunctionIndex, "statepoint-id");
+ Attribute AttrID = AS.getFnAttr("statepoint-id");
uint64_t StatepointID;
if (AttrID.isStringAttribute())
if (!AttrID.getValueAsString().getAsInteger(10, StatepointID))
Result.StatepointID = StatepointID;
uint32_t NumPatchBytes;
- Attribute AttrNumPatchBytes = AS.getAttribute(AttributeList::FunctionIndex,
- "statepoint-num-patch-bytes");
+ Attribute AttrNumPatchBytes = AS.getFnAttr("statepoint-num-patch-bytes");
if (AttrNumPatchBytes.isStringAttribute())
if (!AttrNumPatchBytes.getValueAsString().getAsInteger(10, NumPatchBytes))
Result.NumPatchBytes = NumPatchBytes;
Index: llvm/lib/IR/Instructions.cpp
===================================================================
--- llvm/lib/IR/Instructions.cpp
+++ llvm/lib/IR/Instructions.cpp
@@ -343,10 +343,10 @@
bool CallBase::paramHasAttr(unsigned ArgNo, Attribute::AttrKind Kind) const {
assert(ArgNo < getNumArgOperands() && "Param index out of bounds!");
- if (Attrs.hasParamAttribute(ArgNo, Kind))
+ if (Attrs.hasParamAttr(ArgNo, Kind))
return true;
if (const Function *F = getCalledFunction())
- return F->getAttributes().hasParamAttribute(ArgNo, Kind);
+ return F->getAttributes().hasParamAttr(ArgNo, Kind);
return false;
}
Index: llvm/lib/IR/Function.cpp
===================================================================
--- llvm/lib/IR/Function.cpp
+++ llvm/lib/IR/Function.cpp
@@ -140,20 +140,20 @@
bool Argument::hasPassPointeeByValueCopyAttr() const {
if (!getType()->isPointerTy()) return false;
AttributeList Attrs = getParent()->getAttributes();
- return Attrs.hasParamAttribute(getArgNo(), Attribute::ByVal) ||
- Attrs.hasParamAttribute(getArgNo(), Attribute::InAlloca) ||
- Attrs.hasParamAttribute(getArgNo(), Attribute::Preallocated);
+ return Attrs.hasParamAttr(getArgNo(), Attribute::ByVal) ||
+ Attrs.hasParamAttr(getArgNo(), Attribute::InAlloca) ||
+ Attrs.hasParamAttr(getArgNo(), Attribute::Preallocated);
}
bool Argument::hasPointeeInMemoryValueAttr() const {
if (!getType()->isPointerTy())
return false;
AttributeList Attrs = getParent()->getAttributes();
- return Attrs.hasParamAttribute(getArgNo(), Attribute::ByVal) ||
- Attrs.hasParamAttribute(getArgNo(), Attribute::StructRet) ||
- Attrs.hasParamAttribute(getArgNo(), Attribute::InAlloca) ||
- Attrs.hasParamAttribute(getArgNo(), Attribute::Preallocated) ||
- Attrs.hasParamAttribute(getArgNo(), Attribute::ByRef);
+ return Attrs.hasParamAttr(getArgNo(), Attribute::ByVal) ||
+ Attrs.hasParamAttr(getArgNo(), Attribute::StructRet) ||
+ Attrs.hasParamAttr(getArgNo(), Attribute::InAlloca) ||
+ Attrs.hasParamAttr(getArgNo(), Attribute::Preallocated) ||
+ Attrs.hasParamAttr(getArgNo(), Attribute::ByRef);
}
/// For a byval, sret, inalloca, or preallocated parameter, get the in-memory
@@ -278,8 +278,8 @@
bool Argument::onlyReadsMemory() const {
AttributeList Attrs = getParent()->getAttributes();
- return Attrs.hasParamAttribute(getArgNo(), Attribute::ReadOnly) ||
- Attrs.hasParamAttribute(getArgNo(), Attribute::ReadNone);
+ return Attrs.hasParamAttr(getArgNo(), Attribute::ReadOnly) ||
+ Attrs.hasParamAttr(getArgNo(), Attribute::ReadNone);
}
void Argument::addAttrs(AttrBuilder &B) {
Index: llvm/lib/IR/Core.cpp
===================================================================
--- llvm/lib/IR/Core.cpp
+++ llvm/lib/IR/Core.cpp
@@ -2464,13 +2464,13 @@
}
unsigned LLVMGetAttributeCountAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx) {
- auto AS = unwrap<Function>(F)->getAttributes().getAttributes(Idx);
+ auto AS = unwrap<Function>(F)->getAttributes().getAttributesImpl(Idx);
return AS.getNumAttributes();
}
void LLVMGetAttributesAtIndex(LLVMValueRef F, LLVMAttributeIndex Idx,
LLVMAttributeRef *Attrs) {
- auto AS = unwrap<Function>(F)->getAttributes().getAttributes(Idx);
+ auto AS = unwrap<Function>(F)->getAttributes().getAttributesImpl(Idx);
for (auto A : AS)
*Attrs++ = wrap(A);
}
@@ -2478,8 +2478,8 @@
LLVMAttributeRef LLVMGetEnumAttributeAtIndex(LLVMValueRef F,
LLVMAttributeIndex Idx,
unsigned KindID) {
- return wrap(unwrap<Function>(F)->getAttribute(Idx,
- (Attribute::AttrKind)KindID));
+ return wrap(
+ unwrap<Function>(F)->getAttributeImpl(Idx, (Attribute::AttrKind)KindID));
}
LLVMAttributeRef LLVMGetStringAttributeAtIndex(LLVMValueRef F,
@@ -2873,14 +2873,14 @@
unsigned LLVMGetCallSiteAttributeCount(LLVMValueRef C,
LLVMAttributeIndex Idx) {
auto *Call = unwrap<CallBase>(C);
- auto AS = Call->getAttributes().getAttributes(Idx);
+ auto AS = Call->getAttributes().getAttributesImpl(Idx);
return AS.getNumAttributes();
}
void LLVMGetCallSiteAttributes(LLVMValueRef C, LLVMAttributeIndex Idx,
LLVMAttributeRef *Attrs) {
auto *Call = unwrap<CallBase>(C);
- auto AS = Call->getAttributes().getAttributes(Idx);
+ auto AS = Call->getAttributes().getAttributesImpl(Idx);
for (auto A : AS)
*Attrs++ = wrap(A);
}
@@ -2889,13 +2889,13 @@
LLVMAttributeIndex Idx,
unsigned KindID) {
return wrap(
- unwrap<CallBase>(C)->getAttribute(Idx, (Attribute::AttrKind)KindID));
+ unwrap<CallBase>(C)->getAttrImpl(Idx, (Attribute::AttrKind)KindID));
}
LLVMAttributeRef LLVMGetCallSiteStringAttribute(LLVMValueRef C,
LLVMAttributeIndex Idx,
const char *K, unsigned KLen) {
- return wrap(unwrap<CallBase>(C)->getAttribute(Idx, StringRef(K, KLen)));
+ return wrap(unwrap<CallBase>(C)->getAttrImpl(Idx, StringRef(K, KLen)));
}
void LLVMRemoveCallSiteEnumAttribute(LLVMValueRef C, LLVMAttributeIndex Idx,
Index: llvm/lib/IR/Attributes.cpp
===================================================================
--- llvm/lib/IR/Attributes.cpp
+++ llvm/lib/IR/Attributes.cpp
@@ -1202,7 +1202,7 @@
for (unsigned I = 0; I < MaxSize; ++I) {
AttrBuilder CurBuilder;
for (const auto &List : Attrs)
- CurBuilder.merge(List.getAttributes(I - 1));
+ CurBuilder.merge(List.getAttributesImpl(I - 1));
NewAttrSets[I] = AttributeSet::get(C, CurBuilder);
}
@@ -1211,8 +1211,9 @@
AttributeList AttributeList::addAttribute(LLVMContext &C, unsigned Index,
Attribute::AttrKind Kind) const {
- if (hasAttribute(Index, Kind)) return *this;
- AttributeSet Attrs = getAttributes(Index);
+ if (hasAttributeImpl(Index, Kind))
+ return *this;
+ AttributeSet Attrs = getAttributesImpl(Index);
// TODO: Insert at correct position and avoid sort.
SmallVector<Attribute, 8> NewAttrs(Attrs.begin(), Attrs.end());
NewAttrs.push_back(Attribute::get(C, Kind));
@@ -1255,13 +1256,13 @@
#ifndef NDEBUG
// FIXME it is not obvious how this should work for alignment. For now, say
// we can't change a known alignment.
- const MaybeAlign OldAlign = getAttributes(Index).getAlignment();
+ const MaybeAlign OldAlign = getAttributesImpl(Index).getAlignment();
const MaybeAlign NewAlign = B.getAlignment();
assert((!OldAlign || !NewAlign || OldAlign == NewAlign) &&
"Attempt to change alignment!");
#endif
- AttrBuilder Merged(getAttributes(Index));
+ AttrBuilder Merged(getAttributesImpl(Index));
Merged.merge(B);
return setAttributes(C, Index, AttributeSet::get(C, Merged));
}
@@ -1288,7 +1289,8 @@
AttributeList AttributeList::removeAttribute(LLVMContext &C, unsigned Index,
Attribute::AttrKind Kind) const {
- if (!hasAttribute(Index, Kind)) return *this;
+ if (!hasAttributeImpl(Index, Kind))
+ return *this;
Index = attrIdxToArrayIdx(Index);
SmallVector<AttributeSet, 4> AttrSets(this->begin(), this->end());
@@ -1301,7 +1303,8 @@
AttributeList AttributeList::removeAttribute(LLVMContext &C, unsigned Index,
StringRef Kind) const {
- if (!hasAttribute(Index, Kind)) return *this;
+ if (!hasAttributeImpl(Index, Kind))
+ return *this;
Index = attrIdxToArrayIdx(Index);
SmallVector<AttributeSet, 4> AttrSets(this->begin(), this->end());
@@ -1315,7 +1318,7 @@
AttributeList
AttributeList::removeAttributes(LLVMContext &C, unsigned Index,
const AttrBuilder &AttrsToRemove) const {
- AttributeSet Attrs = getAttributes(Index);
+ AttributeSet Attrs = getAttributesImpl(Index);
AttributeSet NewAttrs = Attrs.removeAttributes(C, AttrsToRemove);
// If nothing was removed, return the original list.
if (Attrs == NewAttrs)
@@ -1373,28 +1376,28 @@
//===----------------------------------------------------------------------===//
AttributeSet AttributeList::getParamAttributes(unsigned ArgNo) const {
- return getAttributes(ArgNo + FirstArgIndex);
+ return getAttributesImpl(ArgNo + FirstArgIndex);
}
AttributeSet AttributeList::getRetAttributes() const {
- return getAttributes(ReturnIndex);
+ return getAttributesImpl(ReturnIndex);
}
AttributeSet AttributeList::getFnAttributes() const {
- return getAttributes(FunctionIndex);
+ return getAttributesImpl(FunctionIndex);
}
-bool AttributeList::hasAttribute(unsigned Index,
- Attribute::AttrKind Kind) const {
- return getAttributes(Index).hasAttribute(Kind);
+bool AttributeList::hasAttributeImpl(unsigned Index,
+ Attribute::AttrKind Kind) const {
+ return getAttributesImpl(Index).hasAttribute(Kind);
}
-bool AttributeList::hasAttribute(unsigned Index, StringRef Kind) const {
- return getAttributes(Index).hasAttribute(Kind);
+bool AttributeList::hasAttributeImpl(unsigned Index, StringRef Kind) const {
+ return getAttributesImpl(Index).hasAttribute(Kind);
}
-bool AttributeList::hasAttributes(unsigned Index) const {
- return getAttributes(Index).hasAttributes();
+bool AttributeList::hasAttributesImpl(unsigned Index) const {
+ return getAttributesImpl(Index).hasAttributes();
}
bool AttributeList::hasFnAttribute(Attribute::AttrKind Kind) const {
@@ -1402,12 +1405,7 @@
}
bool AttributeList::hasFnAttribute(StringRef Kind) const {
- return hasAttribute(AttributeList::FunctionIndex, Kind);
-}
-
-bool AttributeList::hasParamAttribute(unsigned ArgNo,
- Attribute::AttrKind Kind) const {
- return hasAttribute(ArgNo + FirstArgIndex, Kind);
+ return hasAttributeImpl(AttributeList::FunctionIndex, Kind);
}
bool AttributeList::hasAttrSomewhere(Attribute::AttrKind Attr,
@@ -1415,78 +1413,79 @@
return pImpl && pImpl->hasAttrSomewhere(Attr, Index);
}
-Attribute AttributeList::getAttribute(unsigned Index,
- Attribute::AttrKind Kind) const {
- return getAttributes(Index).getAttribute(Kind);
+Attribute AttributeList::getAttributeImpl(unsigned Index,
+ Attribute::AttrKind Kind) const {
+ return getAttributesImpl(Index).getAttribute(Kind);
}
-Attribute AttributeList::getAttribute(unsigned Index, StringRef Kind) const {
- return getAttributes(Index).getAttribute(Kind);
+Attribute AttributeList::getAttributeImpl(unsigned Index,
+ StringRef Kind) const {
+ return getAttributesImpl(Index).getAttribute(Kind);
}
MaybeAlign AttributeList::getRetAlignment() const {
- return getAttributes(ReturnIndex).getAlignment();
+ return getAttributesImpl(ReturnIndex).getAlignment();
}
MaybeAlign AttributeList::getParamAlignment(unsigned ArgNo) const {
- return getAttributes(ArgNo + FirstArgIndex).getAlignment();
+ return getAttributesImpl(ArgNo + FirstArgIndex).getAlignment();
}
MaybeAlign AttributeList::getParamStackAlignment(unsigned ArgNo) const {
- return getAttributes(ArgNo + FirstArgIndex).getStackAlignment();
+ return getAttributesImpl(ArgNo + FirstArgIndex).getStackAlignment();
}
Type *AttributeList::getParamByValType(unsigned Index) const {
- return getAttributes(Index+FirstArgIndex).getByValType();
+ return getAttributesImpl(Index + FirstArgIndex).getByValType();
}
Type *AttributeList::getParamStructRetType(unsigned Index) const {
- return getAttributes(Index + FirstArgIndex).getStructRetType();
+ return getAttributesImpl(Index + FirstArgIndex).getStructRetType();
}
Type *AttributeList::getParamByRefType(unsigned Index) const {
- return getAttributes(Index + FirstArgIndex).getByRefType();
+ return getAttributesImpl(Index + FirstArgIndex).getByRefType();
}
Type *AttributeList::getParamPreallocatedType(unsigned Index) const {
- return getAttributes(Index + FirstArgIndex).getPreallocatedType();
+ return getAttributesImpl(Index + FirstArgIndex).getPreallocatedType();
}
Type *AttributeList::getParamInAllocaType(unsigned Index) const {
- return getAttributes(Index + FirstArgIndex).getInAllocaType();
+ return getAttributesImpl(Index + FirstArgIndex).getInAllocaType();
}
Type *AttributeList::getParamElementType(unsigned Index) const {
- return getAttributes(Index + FirstArgIndex).getElementType();
+ return getAttributesImpl(Index + FirstArgIndex).getElementType();
}
MaybeAlign AttributeList::getStackAlignment(unsigned Index) const {
- return getAttributes(Index).getStackAlignment();
+ return getAttributesImpl(Index).getStackAlignment();
}
uint64_t AttributeList::getDereferenceableBytes(unsigned Index) const {
- return getAttributes(Index).getDereferenceableBytes();
+ return getAttributesImpl(Index).getDereferenceableBytes();
}
uint64_t AttributeList::getDereferenceableOrNullBytes(unsigned Index) const {
- return getAttributes(Index).getDereferenceableOrNullBytes();
+ return getAttributesImpl(Index).getDereferenceableOrNullBytes();
}
std::pair<unsigned, Optional<unsigned>>
AttributeList::getAllocSizeArgs(unsigned Index) const {
- return getAttributes(Index).getAllocSizeArgs();
+ return getAttributesImpl(Index).getAllocSizeArgs();
}
std::pair<unsigned, unsigned>
AttributeList::getVScaleRangeArgs(unsigned Index) const {
- return getAttributes(Index).getVScaleRangeArgs();
+ return getAttributesImpl(Index).getVScaleRangeArgs();
}
std::string AttributeList::getAsString(unsigned Index, bool InAttrGrp) const {
- return getAttributes(Index).getAsString(InAttrGrp);
+ return getAttributesImpl(Index).getAsString(InAttrGrp);
}
-AttributeSet AttributeList::getAttributes(unsigned Index) const {
+AttributeSet AttributeList::getAttributesImpl(unsigned Index) const {
Index = attrIdxToArrayIdx(Index);
if (!pImpl || Index >= getNumAttrSets())
return {};
@@ -1521,7 +1520,7 @@
O << "AttributeList[\n";
for (unsigned i = index_begin(), e = index_end(); i != e; ++i) {
- if (!getAttributes(i).hasAttributes())
+ if (!getAttributesImpl(i).hasAttributes())
continue;
O << " { ";
switch (i) {
@@ -1550,7 +1549,7 @@
// FIXME: Remove this ctor, use AttributeSet.
AttrBuilder::AttrBuilder(AttributeList AL, unsigned Index) {
- AttributeSet AS = AL.getAttributes(Index);
+ AttributeSet AS = AL.getAttributesImpl(Index);
for (const auto &A : AS)
addAttribute(A);
}
@@ -1633,7 +1632,7 @@
}
AttrBuilder &AttrBuilder::removeAttributes(AttributeList A, uint64_t Index) {
- remove(A.getAttributes(Index));
+ remove(A.getAttributesImpl(Index));
return *this;
}
@@ -1845,7 +1844,7 @@
}
bool AttrBuilder::hasAttributes(AttributeList AL, uint64_t Index) const {
- AttributeSet AS = AL.getAttributes(Index);
+ AttributeSet AS = AL.getAttributesImpl(Index);
for (const auto &Attr : AS) {
if (Attr.isEnumAttribute() || Attr.isIntAttribute()) {
Index: llvm/lib/IR/AsmWriter.cpp
===================================================================
--- llvm/lib/IR/AsmWriter.cpp
+++ llvm/lib/IR/AsmWriter.cpp
@@ -3683,7 +3683,7 @@
Out << "; Materializable\n";
const AttributeList &Attrs = F->getAttributes();
- if (Attrs.hasAttributes(AttributeList::FunctionIndex)) {
+ if (Attrs.hasFnAttributes()) {
AttributeSet AS = Attrs.getFnAttributes();
std::string AttrStr;
@@ -3721,8 +3721,8 @@
}
FunctionType *FT = F->getFunctionType();
- if (Attrs.hasAttributes(AttributeList::ReturnIndex))
- Out << Attrs.getAsString(AttributeList::ReturnIndex) << ' ';
+ if (Attrs.hasRetAttributes())
+ Out << Attrs.getRetAttrsAsString() << ' ';
TypePrinter.print(F->getReturnType(), Out);
Out << ' ';
WriteAsOperandInternal(Out, F, &TypePrinter, &Machine, F->getParent());
@@ -3770,7 +3770,7 @@
if (F->getAddressSpace() != 0 || !Mod ||
Mod->getDataLayout().getProgramAddressSpace() != 0)
Out << " addrspace(" << F->getAddressSpace() << ")";
- if (Attrs.hasAttributes(AttributeList::FunctionIndex))
+ if (Attrs.hasFnAttributes())
Out << " #" << Machine.getAttributeGroupSlot(Attrs.getFnAttributes());
if (F->hasSection()) {
Out << " section \"";
@@ -4127,8 +4127,8 @@
Type *RetTy = FTy->getReturnType();
const AttributeList &PAL = CI->getAttributes();
- if (PAL.hasAttributes(AttributeList::ReturnIndex))
- Out << ' ' << PAL.getAsString(AttributeList::ReturnIndex);
+ if (PAL.hasRetAttributes())
+ Out << ' ' << PAL.getRetAttrsAsString();
// Only print addrspace(N) if necessary:
maybePrintCallAddrSpace(Operand, &I, Out);
@@ -4156,7 +4156,7 @@
Out << ", ...";
Out << ')';
- if (PAL.hasAttributes(AttributeList::FunctionIndex))
+ if (PAL.hasFnAttributes())
Out << " #" << Machine.getAttributeGroupSlot(PAL.getFnAttributes());
writeOperandBundles(CI);
@@ -4172,8 +4172,8 @@
PrintCallingConv(II->getCallingConv(), Out);
}
- if (PAL.hasAttributes(AttributeList::ReturnIndex))
- Out << ' ' << PAL.getAsString(AttributeList::ReturnIndex);
+ if (PAL.hasRetAttributes())
+ Out << ' ' << PAL.getRetAttrsAsString();
// Only print addrspace(N) if necessary:
maybePrintCallAddrSpace(Operand, &I, Out);
@@ -4194,7 +4194,7 @@
}
Out << ')';
- if (PAL.hasAttributes(AttributeList::FunctionIndex))
+ if (PAL.hasFnAttributes())
Out << " #" << Machine.getAttributeGroupSlot(PAL.getFnAttributes());
writeOperandBundles(II);
@@ -4215,8 +4215,8 @@
PrintCallingConv(CBI->getCallingConv(), Out);
}
- if (PAL.hasAttributes(AttributeList::ReturnIndex))
- Out << ' ' << PAL.getAsString(AttributeList::ReturnIndex);
+ if (PAL.hasRetAttributes())
+ Out << ' ' << PAL.getRetAttrsAsString();
// If possible, print out the short form of the callbr instruction. We can
// only do this if the first argument is a pointer to a nonvararg function,
@@ -4234,7 +4234,7 @@
}
Out << ')';
- if (PAL.hasAttributes(AttributeList::FunctionIndex))
+ if (PAL.hasFnAttributes())
Out << " #" << Machine.getAttributeGroupSlot(PAL.getFnAttributes());
writeOperandBundles(CBI);
Index: llvm/lib/CodeGen/TargetLoweringBase.cpp
===================================================================
--- llvm/lib/CodeGen/TargetLoweringBase.cpp
+++ llvm/lib/CodeGen/TargetLoweringBase.cpp
@@ -1657,9 +1657,9 @@
EVT VT = ValueVTs[j];
ISD::NodeType ExtendKind = ISD::ANY_EXTEND;
- if (attr.hasAttribute(AttributeList::ReturnIndex, Attribute::SExt))
+ if (attr.hasRetAttr(Attribute::SExt))
ExtendKind = ISD::SIGN_EXTEND;
- else if (attr.hasAttribute(AttributeList::ReturnIndex, Attribute::ZExt))
+ else if (attr.hasRetAttr(Attribute::ZExt))
ExtendKind = ISD::ZERO_EXTEND;
// FIXME: C calling convention requires the return type to be promoted to
@@ -1679,13 +1679,13 @@
// 'inreg' on function refers to return value
ISD::ArgFlagsTy Flags = ISD::ArgFlagsTy();
- if (attr.hasAttribute(AttributeList::ReturnIndex, Attribute::InReg))
+ if (attr.hasRetAttr(Attribute::InReg))
Flags.setInReg();
// Propagate extension type if any
- if (attr.hasAttribute(AttributeList::ReturnIndex, Attribute::SExt))
+ if (attr.hasRetAttr(Attribute::SExt))
Flags.setSExt();
- else if (attr.hasAttribute(AttributeList::ReturnIndex, Attribute::ZExt))
+ else if (attr.hasRetAttr(Attribute::ZExt))
Flags.setZExt();
for (unsigned i = 0; i < NumParts; ++i)
Index: llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
===================================================================
--- llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
+++ llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
@@ -1953,16 +1953,13 @@
/*IsVarArg*/ false, DL);
ISD::NodeType ExtendKind = ISD::ANY_EXTEND;
- if (F->getAttributes().hasAttribute(AttributeList::ReturnIndex,
- Attribute::SExt))
+ if (F->getAttributes().hasRetAttr(Attribute::SExt))
ExtendKind = ISD::SIGN_EXTEND;
- else if (F->getAttributes().hasAttribute(AttributeList::ReturnIndex,
- Attribute::ZExt))
+ else if (F->getAttributes().hasRetAttr(Attribute::ZExt))
ExtendKind = ISD::ZERO_EXTEND;
LLVMContext &Context = F->getContext();
- bool RetInReg = F->getAttributes().hasAttribute(
- AttributeList::ReturnIndex, Attribute::InReg);
+ bool RetInReg = F->getAttributes().hasRetAttr(Attribute::InReg);
for (unsigned j = 0; j != NumValues; ++j) {
EVT VT = ValueVTs[j];
@@ -2671,7 +2668,7 @@
TargetLowering::ArgListEntry Entry;
Entry.Node = GuardVal;
Entry.Ty = FnTy->getParamType(0);
- if (GuardCheckFn->hasAttribute(1, Attribute::AttrKind::InReg))
+ if (GuardCheckFn->hasParamAttribute(0, Attribute::AttrKind::InReg))
Entry.IsInReg = true;
Args.push_back(Entry);
@@ -6738,9 +6735,7 @@
case Intrinsic::debugtrap:
case Intrinsic::trap: {
StringRef TrapFuncName =
- I.getAttributes()
- .getAttribute(AttributeList::FunctionIndex, "trap-func-name")
- .getValueAsString();
+ I.getAttributes().getFnAttr("trap-func-name").getValueAsString();
if (TrapFuncName.empty()) {
switch (Intrinsic) {
case Intrinsic::trap:
Index: llvm/lib/CodeGen/MachinePipeliner.cpp
===================================================================
--- llvm/lib/CodeGen/MachinePipeliner.cpp
+++ llvm/lib/CodeGen/MachinePipeliner.cpp
@@ -200,8 +200,8 @@
if (!EnableSWP)
return false;
- if (mf.getFunction().getAttributes().hasAttribute(
- AttributeList::FunctionIndex, Attribute::OptimizeForSize) &&
+ if (mf.getFunction().getAttributes().hasFnAttribute(
+ Attribute::OptimizeForSize) &&
!EnableSWPOptSize.getPosition())
return false;
Index: llvm/lib/CodeGen/GlobalISel/LegalizerHelper.cpp
===================================================================
--- llvm/lib/CodeGen/GlobalISel/LegalizerHelper.cpp
+++ llvm/lib/CodeGen/GlobalISel/LegalizerHelper.cpp
@@ -497,8 +497,8 @@
return false;
// It's not safe to eliminate the sign / zero extension of the return value.
- if (CallerAttrs.hasAttribute(AttributeList::ReturnIndex, Attribute::ZExt) ||
- CallerAttrs.hasAttribute(AttributeList::ReturnIndex, Attribute::SExt))
+ if (CallerAttrs.hasRetAttr(Attribute::ZExt) ||
+ CallerAttrs.hasRetAttr(Attribute::SExt))
return false;
// Only tail call if the following instruction is a standard return or if we
Index: llvm/lib/CodeGen/GlobalISel/CallLowering.cpp
===================================================================
--- llvm/lib/CodeGen/GlobalISel/CallLowering.cpp
+++ llvm/lib/CodeGen/GlobalISel/CallLowering.cpp
@@ -73,7 +73,7 @@
const AttributeList &Attrs,
unsigned OpIdx) const {
addFlagsUsingAttrFn(Flags, [&Attrs, &OpIdx](Attribute::AttrKind Attr) {
- return Attrs.hasAttribute(OpIdx, Attr);
+ return Attrs.hasAttributeImpl(OpIdx, Attr);
});
}
@@ -167,7 +167,7 @@
assert(OpIdx >= AttributeList::FirstArgIndex);
Type *ElementTy = PtrTy->getElementType();
- auto Ty = Attrs.getAttribute(OpIdx, Attribute::ByVal).getValueAsType();
+ auto Ty = Attrs.getAttributeImpl(OpIdx, Attribute::ByVal).getValueAsType();
Flags.setByValSize(DL.getTypeAllocSize(Ty ? Ty : ElementTy));
// For ByVal, alignment should be passed from FE. BE will guess if
Index: llvm/lib/Bitcode/Writer/ValueEnumerator.cpp
===================================================================
--- llvm/lib/Bitcode/Writer/ValueEnumerator.cpp
+++ llvm/lib/Bitcode/Writer/ValueEnumerator.cpp
@@ -1037,7 +1037,7 @@
// Do lookups for all attribute groups.
for (unsigned i = PAL.index_begin(), e = PAL.index_end(); i != e; ++i) {
- AttributeSet AS = PAL.getAttributes(i);
+ AttributeSet AS = PAL.getAttributesImpl(i);
if (!AS.hasAttributes())
continue;
IndexAndAttrSet Pair = {i, AS};
Index: llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
===================================================================
--- llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
+++ llvm/lib/Bitcode/Writer/BitcodeWriter.cpp
@@ -836,7 +836,7 @@
for (unsigned i = 0, e = Attrs.size(); i != e; ++i) {
AttributeList AL = Attrs[i];
for (unsigned i = AL.index_begin(), e = AL.index_end(); i != e; ++i) {
- AttributeSet AS = AL.getAttributes(i);
+ AttributeSet AS = AL.getAttributesImpl(i);
if (AS.hasAttributes())
Record.push_back(VE.getAttributeGroupID({i, AS}));
}
Index: llvm/lib/AsmParser/LLParser.cpp
===================================================================
--- llvm/lib/AsmParser/LLParser.cpp
+++ llvm/lib/AsmParser/LLParser.cpp
@@ -5571,7 +5571,7 @@
AttributeList::get(Context, AttributeSet::get(Context, FuncAttrs),
AttributeSet::get(Context, RetAttrs), Attrs);
- if (PAL.hasAttribute(1, Attribute::StructRet) && !RetType->isVoidTy())
+ if (PAL.hasParamAttr(0, Attribute::StructRet) && !RetType->isVoidTy())
return error(RetTypeLoc, "functions with 'sret' argument must return void");
FunctionType *FT = FunctionType::get(RetType, ParamTypeList, IsVarArg);
Index: llvm/lib/Analysis/VectorUtils.cpp
===================================================================
--- llvm/lib/Analysis/VectorUtils.cpp
+++ llvm/lib/Analysis/VectorUtils.cpp
@@ -1352,9 +1352,7 @@
void VFABI::getVectorVariantNames(
const CallInst &CI, SmallVectorImpl<std::string> &VariantMappings) {
- const StringRef S =
- CI.getAttribute(AttributeList::FunctionIndex, VFABI::MappingsAttrName)
- .getValueAsString();
+ const StringRef S = CI.getFnAttr(VFABI::MappingsAttrName).getValueAsString();
if (S.empty())
return;
Index: llvm/lib/Analysis/Lint.cpp
===================================================================
--- llvm/lib/Analysis/Lint.cpp
+++ llvm/lib/Analysis/Lint.cpp
@@ -235,7 +235,7 @@
for (auto BI = I.arg_begin(); BI != AE; ++BI, ++ArgNo) {
// Skip ByVal arguments since they will be memcpy'd to the callee's
// stack so we're not really passing the pointer anyway.
- if (PAL.hasParamAttribute(ArgNo, Attribute::ByVal))
+ if (PAL.hasParamAttr(ArgNo, Attribute::ByVal))
continue;
// If both arguments are readonly, they have no dependence.
if (Formal->onlyReadsMemory() && I.onlyReadsMemory(ArgNo))
@@ -268,7 +268,7 @@
for (Value *Arg : I.args()) {
// Skip ByVal arguments since they will be memcpy'd to the callee's
// stack anyway.
- if (PAL.hasParamAttribute(ArgNo++, Attribute::ByVal))
+ if (PAL.hasParamAttr(ArgNo++, Attribute::ByVal))
continue;
Value *Obj = findValue(Arg, /*OffsetOk=*/true);
Assert(!isa<AllocaInst>(Obj),
Index: llvm/include/llvm/IR/InstrTypes.h
===================================================================
--- llvm/include/llvm/IR/InstrTypes.h
+++ llvm/include/llvm/IR/InstrTypes.h
@@ -1584,13 +1584,23 @@
bool paramHasAttr(unsigned ArgNo, Attribute::AttrKind Kind) const;
/// Get the attribute of a given kind at a position.
- Attribute getAttribute(unsigned i, Attribute::AttrKind Kind) const {
- return getAttributes().getAttribute(i, Kind);
+ Attribute getAttrImpl(unsigned ArgNo, Attribute::AttrKind Kind) const {
+ return getAttributes().getAttributeImpl(ArgNo, Kind);
}
/// Get the attribute of a given kind at a position.
- Attribute getAttribute(unsigned i, StringRef Kind) const {
- return getAttributes().getAttribute(i, Kind);
+ Attribute getAttrImpl(unsigned ArgNo, StringRef Kind) const {
+ return getAttributes().getAttributeImpl(ArgNo, Kind);
+ }
+
+ /// Get the attribute of a given kind at a position.
+ Attribute getFnAttr(Attribute::AttrKind Kind) const {
+ return getAttributes().getFnAttr(Kind);
+ }
+
+ /// Get the attribute of a given kind at a position.
+ Attribute getFnAttr(StringRef Kind) const {
+ return getAttributes().getFnAttr(Kind);
}
/// Get the attribute of a given kind from a given arg
@@ -1760,7 +1770,7 @@
/// Determine if the return value is marked with NoAlias attribute.
bool returnDoesNotAlias() const {
- return Attrs.hasAttribute(AttributeList::ReturnIndex, Attribute::NoAlias);
+ return Attrs.hasRetAttr(Attribute::NoAlias);
}
/// If one of the arguments has the 'returned' attribute, returns its
@@ -2272,12 +2282,12 @@
/// Determine whether the return value has the given attribute. Supports
/// Attribute::AttrKind and StringRef as \p AttrKind types.
template <typename AttrKind> bool hasRetAttrImpl(AttrKind Kind) const {
- if (Attrs.hasAttribute(AttributeList::ReturnIndex, Kind))
+ if (Attrs.hasRetAttr(Kind))
return true;
// Look at the callee, if available.
if (const Function *F = getCalledFunction())
- return F->getAttributes().hasAttribute(AttributeList::ReturnIndex, Kind);
+ return F->getAttributes().hasRetAttr(Kind);
return false;
}
};
Index: llvm/include/llvm/IR/Function.h
===================================================================
--- llvm/include/llvm/IR/Function.h
+++ llvm/include/llvm/IR/Function.h
@@ -363,12 +363,12 @@
/// Return the attribute for the given attribute kind.
Attribute getFnAttribute(Attribute::AttrKind Kind) const {
- return getAttribute(AttributeList::FunctionIndex, Kind);
+ return getAttributes().getFnAttr(Kind);
}
/// Return the attribute for the given attribute kind.
Attribute getFnAttribute(StringRef Kind) const {
- return getAttribute(AttributeList::FunctionIndex, Kind);
+ return getAttributes().getFnAttr(Kind);
}
/// Return the stack alignment for the function.
@@ -441,13 +441,13 @@
void removeParamUndefImplyingAttrs(unsigned ArgNo);
/// check if an attributes is in the list of attributes.
- bool hasAttribute(unsigned i, Attribute::AttrKind Kind) const {
- return getAttributes().hasAttribute(i, Kind);
+ bool hasRetAttribute(Attribute::AttrKind Kind) const {
+ return getAttributes().hasRetAttr(Kind);
}
/// check if an attributes is in the list of attributes.
bool hasParamAttribute(unsigned ArgNo, Attribute::AttrKind Kind) const {
- return getAttributes().hasParamAttribute(ArgNo, Kind);
+ return getAttributes().hasParamAttr(ArgNo, Kind);
}
/// gets the specified attribute from the list of attributes.
@@ -456,13 +456,13 @@
}
/// gets the attribute from the list of attributes.
- Attribute getAttribute(unsigned i, Attribute::AttrKind Kind) const {
- return AttributeSets.getAttribute(i, Kind);
+ Attribute getAttributeImpl(unsigned i, Attribute::AttrKind Kind) const {
+ return AttributeSets.getAttributeImpl(i, Kind);
}
/// gets the attribute from the list of attributes.
Attribute getAttribute(unsigned i, StringRef Kind) const {
- return AttributeSets.getAttribute(i, Kind);
+ return AttributeSets.getAttributeImpl(i, Kind);
}
/// adds the dereferenceable attribute to the list of attributes.
@@ -692,15 +692,14 @@
/// Determine if the function returns a structure through first
/// or second pointer argument.
bool hasStructRetAttr() const {
- return AttributeSets.hasParamAttribute(0, Attribute::StructRet) ||
- AttributeSets.hasParamAttribute(1, Attribute::StructRet);
+ return AttributeSets.hasParamAttr(0, Attribute::StructRet) ||
+ AttributeSets.hasParamAttr(1, Attribute::StructRet);
}
/// Determine if the parameter or return value is marked with NoAlias
/// attribute.
bool returnDoesNotAlias() const {
- return AttributeSets.hasAttribute(AttributeList::ReturnIndex,
- Attribute::NoAlias);
+ return AttributeSets.hasRetAttr(Attribute::NoAlias);
}
void setReturnDoesNotAlias() {
addAttribute(AttributeList::ReturnIndex, Attribute::NoAlias);
Index: llvm/include/llvm/IR/Attributes.h
===================================================================
--- llvm/include/llvm/IR/Attributes.h
+++ llvm/include/llvm/IR/Attributes.h
@@ -559,7 +559,7 @@
unsigned ArgNo,
Attribute::AttrKind Kind,
Type *ReplacementTy) const {
- Attribute Attr = getAttribute(ArgNo, Kind);
+ Attribute Attr = getAttributeImpl(ArgNo, Kind);
auto Attrs = removeAttribute(C, ArgNo, Kind);
return Attrs.addAttribute(C, ArgNo, Attr.getWithNewType(C, ReplacementTy));
}
@@ -616,7 +616,7 @@
//===--------------------------------------------------------------------===//
/// The attributes for the specified index are returned.
- AttributeSet getAttributes(unsigned Index) const;
+ AttributeSet getAttributesImpl(unsigned Index) const;
/// The attributes for the argument or parameter at the given index are
/// returned.
@@ -629,39 +629,50 @@
AttributeSet getFnAttributes() const;
/// Return true if the attribute exists at the given index.
- bool hasAttribute(unsigned Index, Attribute::AttrKind Kind) const;
+ bool hasAttributeImpl(unsigned Index, Attribute::AttrKind Kind) const;
/// Return true if the attribute exists at the given index.
- bool hasAttribute(unsigned Index, StringRef Kind) const;
+ bool hasAttributeImpl(unsigned Index, StringRef Kind) const;
/// Return true if attribute exists at the given index.
- bool hasAttributes(unsigned Index) const;
+ bool hasAttributesImpl(unsigned Index) const;
- /// Return true if the attribute exists for the given argument
+ /// Return true if the attribute exists for the return value.
+ bool hasRetAttr(Attribute::AttrKind Kind) const {
+ return hasAttributeImpl(ReturnIndex, Kind);
+ }
+
+ /// Return true if the attribute exists for the return value.
+ bool hasRetAttr(StringRef Kind) const {
+ return hasAttributeImpl(ReturnIndex, Kind);
+ }
+
+ /// Return true if the attribute exists for the given argument.
bool hasParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) const {
- return hasAttribute(ArgNo + FirstArgIndex, Kind);
+ return hasAttributeImpl(ArgNo + FirstArgIndex, Kind);
}
- /// Return true if the attribute exists for the given argument
+ /// Return true if the attribute exists for the given argument.
bool hasParamAttr(unsigned ArgNo, StringRef Kind) const {
- return hasAttribute(ArgNo + FirstArgIndex, Kind);
+ return hasAttributeImpl(ArgNo + FirstArgIndex, Kind);
}
- /// Return true if attributes exists for the given argument
+ /// Return true if attributes exists for the given argument.
bool hasParamAttrs(unsigned ArgNo) const {
- return hasAttributes(ArgNo + FirstArgIndex);
+ return hasAttributesImpl(ArgNo + FirstArgIndex);
}
- /// Equivalent to hasAttribute(AttributeList::FunctionIndex, Kind) but
- /// may be faster.
+ /// Return true if the attribute exists for the function.
bool hasFnAttribute(Attribute::AttrKind Kind) const;
- /// Equivalent to hasAttribute(AttributeList::FunctionIndex, Kind) but
- /// may be faster.
+ /// Return true if the attribute exists for the function.
bool hasFnAttribute(StringRef Kind) const;
- /// Equivalent to hasAttribute(ArgNo + FirstArgIndex, Kind).
- bool hasParamAttribute(unsigned ArgNo, Attribute::AttrKind Kind) const;
+ /// Return true if attributes exists for the function.
+ bool hasFnAttributes() const { return hasAttributesImpl(FunctionIndex); }
+
+ /// Return true if attributes exists for the return value.
+ bool hasRetAttributes() const { return hasAttributesImpl(ReturnIndex); }
/// Return true if the specified attribute is set for at least one
/// parameter or for the return value. If Index is not nullptr, the index
@@ -670,19 +681,29 @@
unsigned *Index = nullptr) const;
/// Return the attribute object that exists at the given index.
- Attribute getAttribute(unsigned Index, Attribute::AttrKind Kind) const;
+ Attribute getAttributeImpl(unsigned Index, Attribute::AttrKind Kind) const;
/// Return the attribute object that exists at the given index.
- Attribute getAttribute(unsigned Index, StringRef Kind) const;
+ Attribute getAttributeImpl(unsigned Index, StringRef Kind) const;
/// Return the attribute object that exists at the arg index.
Attribute getParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) const {
- return getAttribute(ArgNo + FirstArgIndex, Kind);
+ return getAttributeImpl(ArgNo + FirstArgIndex, Kind);
}
/// Return the attribute object that exists at the given index.
Attribute getParamAttr(unsigned ArgNo, StringRef Kind) const {
- return getAttribute(ArgNo + FirstArgIndex, Kind);
+ return getAttributeImpl(ArgNo + FirstArgIndex, Kind);
+ }
+
+ /// Return the attribute object that exists at the arg index.
+ Attribute getFnAttr(Attribute::AttrKind Kind) const {
+ return getAttributeImpl(FunctionIndex, Kind);
+ }
+
+ /// Return the attribute object that exists at the given index.
+ Attribute getFnAttr(StringRef Kind) const {
+ return getAttributeImpl(FunctionIndex, Kind);
}
/// Return the alignment of the return value.
@@ -741,9 +762,16 @@
/// Get the vscale_range argument numbers (or pair(0, 0) if unknown).
std::pair<unsigned, unsigned> getVScaleRangeArgs(unsigned Index) const;
+ /// Return the return value attributes as a string.
+ std::string getRetAttrsAsString(bool InAttrGrp = false) const {
+ return getAsString(ReturnIndex, InAttrGrp);
+ }
+
+private:
/// Return the attributes at the index as a string.
std::string getAsString(unsigned Index, bool InAttrGrp = false) const;
+public:
/// Return true if this attribute list belongs to the LLVMContext.
bool hasParentContext(LLVMContext &C) const;
Index: clang/lib/CodeGen/CodeGenModule.cpp
===================================================================
--- clang/lib/CodeGen/CodeGenModule.cpp
+++ clang/lib/CodeGen/CodeGenModule.cpp
@@ -3613,7 +3613,7 @@
assert(F->getName() == MangledName && "name was uniqued!");
if (D)
SetFunctionAttributes(GD, F, IsIncompleteFunction, IsThunk);
- if (ExtraAttrs.hasAttributes(llvm::AttributeList::FunctionIndex)) {
+ if (ExtraAttrs.hasFnAttributes()) {
llvm::AttrBuilder B(ExtraAttrs, llvm::AttributeList::FunctionIndex);
F->addAttributes(llvm::AttributeList::FunctionIndex, B);
}
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
