maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

[NFC] More get/removeAttribute() cleanup

This commit is contained in:
Arthur Eubanks 2021-08-17 20:25:16 -07:00
parent de0ae9e89e
commit 3f4d00bc3b
30 changed files with 131 additions and 153 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
clang/lib/CodeGen/CGBuiltin.cpp
View File

@ -15924,11 +15924,9 @@ Value *EmitAMDGPUDispatchPtr(CodeGenFunction &CGF,
const CallExpr *E = nullptr) {
auto *F = CGF.CGM.getIntrinsic(Intrinsic::amdgcn_dispatch_ptr);
auto *Call = CGF.Builder.CreateCall(F);
Call->addAttribute(
AttributeList::ReturnIndex,
Call->addRetAttr(
Attribute::getWithDereferenceableBytes(Call->getContext(), 64));
Call->addAttribute(AttributeList::ReturnIndex,
Attribute::getWithAlignment(Call->getContext(), Align(4)));
Call->addRetAttr(Attribute::getWithAlignment(Call->getContext(), Align(4)));
if (!E)
return Call;
QualType BuiltinRetType = E->getType();

3
clang/lib/CodeGen/CGCall.cpp
View File

@ -5334,8 +5334,7 @@ RValue CodeGenFunction::EmitCall(const CGFunctionInfo &CallInfo,
// attributes of the called function.
if (auto *F = CI->getCalledFunction())
F->removeFnAttr(llvm::Attribute::NoReturn);
CI->removeAttribute(llvm::AttributeList::FunctionIndex,
llvm::Attribute::NoReturn);
CI->removeFnAttr(llvm::Attribute::NoReturn);
// Avoid incompatibility with ASan which relies on the `noreturn`
// attribute to insert handler calls.

4
clang/lib/CodeGen/CGExpr.cpp
View File

@ -3498,7 +3498,7 @@ void CodeGenFunction::EmitTrapCheck(llvm::Value *Checked,
if (!CGM.getCodeGenOpts().TrapFuncName.empty()) {
auto A = llvm::Attribute::get(getLLVMContext(), "trap-func-name",
CGM.getCodeGenOpts().TrapFuncName);
TrapCall->addAttribute(llvm::AttributeList::FunctionIndex, A);
TrapCall->addFnAttr(A);
}
TrapCall->setDoesNotReturn();
TrapCall->setDoesNotThrow();
@ -3522,7 +3522,7 @@ llvm::CallInst *CodeGenFunction::EmitTrapCall(llvm::Intrinsic::ID IntrID) {
if (!CGM.getCodeGenOpts().TrapFuncName.empty()) {
auto A = llvm::Attribute::get(getLLVMContext(), "trap-func-name",
CGM.getCodeGenOpts().TrapFuncName);
TrapCall->addAttribute(llvm::AttributeList::FunctionIndex, A);
TrapCall->addFnAttr(A);
}
return TrapCall;

3
clang/lib/CodeGen/CGExprCXX.cpp
View File

@ -1323,8 +1323,7 @@ static RValue EmitNewDeleteCall(CodeGenFunction &CGF,
llvm::Function *Fn = dyn_cast<llvm::Function>(CalleePtr);
if (CalleeDecl->isReplaceableGlobalAllocationFunction() &&
Fn && Fn->hasFnAttribute(llvm::Attribute::NoBuiltin)) {
CallOrInvoke->addAttribute(llvm::AttributeList::FunctionIndex,
llvm::Attribute::Builtin);
CallOrInvoke->addFnAttr(llvm::Attribute::Builtin);
}
return RV;

15
clang/lib/CodeGen/CGStmt.cpp
View File

@ -2188,20 +2188,16 @@ static void UpdateAsmCallInst(llvm::CallBase &Result, bool HasSideEffect,
CodeGenFunction &CGF,
std::vector<llvm::Value *> &RegResults) {
if (!HasUnwindClobber)
Result.addAttribute(llvm::AttributeList::FunctionIndex,
llvm::Attribute::NoUnwind);
Result.addFnAttr(llvm::Attribute::NoUnwind);
if (NoMerge)
Result.addAttribute(llvm::AttributeList::FunctionIndex,
llvm::Attribute::NoMerge);
Result.addFnAttr(llvm::Attribute::NoMerge);
// Attach readnone and readonly attributes.
if (!HasSideEffect) {
if (ReadNone)
Result.addAttribute(llvm::AttributeList::FunctionIndex,
llvm::Attribute::ReadNone);
Result.addFnAttr(llvm::Attribute::ReadNone);
else if (ReadOnly)
Result.addAttribute(llvm::AttributeList::FunctionIndex,
llvm::Attribute::ReadOnly);
Result.addFnAttr(llvm::Attribute::ReadOnly);
}
// Slap the source location of the inline asm into a !srcloc metadata on the
@ -2223,8 +2219,7 @@ static void UpdateAsmCallInst(llvm::CallBase &Result, bool HasSideEffect,
// convergent (meaning, they may call an intrinsically convergent op, such
// as bar.sync, and so can't have certain optimizations applied around
// them).
Result.addAttribute(llvm::AttributeList::FunctionIndex,
llvm::Attribute::Convergent);
Result.addFnAttr(llvm::Attribute::Convergent);
// Extract all of the register value results from the asm.
if (ResultRegTypes.size() == 1) {
RegResults.push_back(&Result);

2
llvm/include/llvm/IR/IRBuilder.h
View File

@ -351,7 +351,7 @@ public:
}
void setConstrainedFPCallAttr(CallBase *I) {
I->addAttribute(AttributeList::FunctionIndex, Attribute::StrictFP);
I->addFnAttr(Attribute::StrictFP);
}
void setDefaultOperandBundles(ArrayRef<OperandBundleDef> OpBundles) {

95
llvm/include/llvm/IR/InstrTypes.h
View File

@ -1499,6 +1499,26 @@ public:
setAttributes(PAL);
}
/// Adds the attribute to the function.
void addFnAttr(Attribute::AttrKind Kind) {
Attrs = Attrs.addFnAttribute(getContext(), Kind);
}
/// Adds the attribute to the function.
void addFnAttr(Attribute Attr) {
Attrs = Attrs.addFnAttribute(getContext(), Attr);
}
/// Adds the attribute to the return value.
void addRetAttr(Attribute::AttrKind Kind) {
Attrs = Attrs.addRetAttribute(getContext(), Kind);
}
/// Adds the attribute to the return value.
void addRetAttr(Attribute Attr) {
Attrs = Attrs.addRetAttribute(getContext(), Attr);
}
/// Adds the attribute to the indicated argument
void addParamAttr(unsigned ArgNo, Attribute::AttrKind Kind) {
assert(ArgNo < getNumArgOperands() && "Out of bounds");
@ -1529,9 +1549,31 @@ public:
setAttributes(PAL);
}
void removeAttributes(unsigned i, const AttrBuilder &Attrs) {
/// Removes the attributes from the function
void removeFnAttrs(const AttrBuilder &Attrs) {
AttributeList PAL = getAttributes();
PAL = PAL.removeAttributes(getContext(), i, Attrs);
PAL = PAL.removeFnAttributes(getContext(), Attrs);
setAttributes(PAL);
}
/// Removes the attribute from the function
void removeFnAttr(Attribute::AttrKind Kind) {
AttributeList PAL = getAttributes();
PAL = PAL.removeFnAttribute(getContext(), Kind);
setAttributes(PAL);
}
/// Removes the attribute from the return value
void removeRetAttr(Attribute::AttrKind Kind) {
AttributeList PAL = getAttributes();
PAL = PAL.removeRetAttribute(getContext(), Kind);
setAttributes(PAL);
}
/// Removes the attributes from the return value
void removeRetAttrs(const AttrBuilder &Attrs) {
AttributeList PAL = getAttributes();
PAL = PAL.removeRetAttributes(getContext(), Attrs);
setAttributes(PAL);
}
@ -1779,40 +1821,30 @@ public:
/// Return true if the call should not be inlined.
bool isNoInline() const { return hasFnAttr(Attribute::NoInline); }
void setIsNoInline() {
addAttribute(AttributeList::FunctionIndex, Attribute::NoInline);
}
void setIsNoInline() { addFnAttr(Attribute::NoInline); }
/// Determine if the call does not access memory.
bool doesNotAccessMemory() const { return hasFnAttr(Attribute::ReadNone); }
void setDoesNotAccessMemory() {
addAttribute(AttributeList::FunctionIndex, Attribute::ReadNone);
}
void setDoesNotAccessMemory() { addFnAttr(Attribute::ReadNone); }
/// Determine if the call does not access or only reads memory.
bool onlyReadsMemory() const {
return doesNotAccessMemory() || hasFnAttr(Attribute::ReadOnly);
}
void setOnlyReadsMemory() {
addAttribute(AttributeList::FunctionIndex, Attribute::ReadOnly);
}
void setOnlyReadsMemory() { addFnAttr(Attribute::ReadOnly); }
/// Determine if the call does not access or only writes memory.
bool doesNotReadMemory() const {
return doesNotAccessMemory() || hasFnAttr(Attribute::WriteOnly);
}
void setDoesNotReadMemory() {
addAttribute(AttributeList::FunctionIndex, Attribute::WriteOnly);
}
void setDoesNotReadMemory() { addFnAttr(Attribute::WriteOnly); }
/// Determine if the call can access memmory only using pointers based
/// on its arguments.
bool onlyAccessesArgMemory() const {
return hasFnAttr(Attribute::ArgMemOnly);
}
void setOnlyAccessesArgMemory() {
addAttribute(AttributeList::FunctionIndex, Attribute::ArgMemOnly);
}
void setOnlyAccessesArgMemory() { addFnAttr(Attribute::ArgMemOnly); }
/// Determine if the function may only access memory that is
/// inaccessible from the IR.
@ -1820,7 +1852,7 @@ public:
return hasFnAttr(Attribute::InaccessibleMemOnly);
}
void setOnlyAccessesInaccessibleMemory() {
addAttribute(AttributeList::FunctionIndex, Attribute::InaccessibleMemOnly);
addFnAttr(Attribute::InaccessibleMemOnly);
}
/// Determine if the function may only access memory that is
@ -1829,44 +1861,31 @@ public:
return hasFnAttr(Attribute::InaccessibleMemOrArgMemOnly);
}
void setOnlyAccessesInaccessibleMemOrArgMem() {
addAttribute(AttributeList::FunctionIndex,
Attribute::InaccessibleMemOrArgMemOnly);
addFnAttr(Attribute::InaccessibleMemOrArgMemOnly);
}
/// Determine if the call cannot return.
bool doesNotReturn() const { return hasFnAttr(Attribute::NoReturn); }
void setDoesNotReturn() {
addAttribute(AttributeList::FunctionIndex, Attribute::NoReturn);
}
void setDoesNotReturn() { addFnAttr(Attribute::NoReturn); }
/// Determine if the call should not perform indirect branch tracking.
bool doesNoCfCheck() const { return hasFnAttr(Attribute::NoCfCheck); }
/// Determine if the call cannot unwind.
bool doesNotThrow() const { return hasFnAttr(Attribute::NoUnwind); }
void setDoesNotThrow() {
addAttribute(AttributeList::FunctionIndex, Attribute::NoUnwind);
}
void setDoesNotThrow() { addFnAttr(Attribute::NoUnwind); }
/// Determine if the invoke cannot be duplicated.
bool cannotDuplicate() const { return hasFnAttr(Attribute::NoDuplicate); }
void setCannotDuplicate() {
addAttribute(AttributeList::FunctionIndex, Attribute::NoDuplicate);
}
void setCannotDuplicate() { addFnAttr(Attribute::NoDuplicate); }
/// Determine if the call cannot be tail merged.
bool cannotMerge() const { return hasFnAttr(Attribute::NoMerge); }
void setCannotMerge() {
addAttribute(AttributeList::FunctionIndex, Attribute::NoMerge);
}
void setCannotMerge() { addFnAttr(Attribute::NoMerge); }
/// Determine if the invoke is convergent
bool isConvergent() const { return hasFnAttr(Attribute::Convergent); }
void setConvergent() {
addAttribute(AttributeList::FunctionIndex, Attribute::Convergent);
}
void setNotConvergent() {
removeAttribute(AttributeList::FunctionIndex, Attribute::Convergent);
}
void setConvergent() { addFnAttr(Attribute::Convergent); }
void setNotConvergent() { removeFnAttr(Attribute::Convergent); }
/// Determine if the call returns a structure through first
/// pointer argument.

4
llvm/include/llvm/IR/Instructions.h
View File

@ -1685,9 +1685,7 @@ public:
/// Return true if the call can return twice
bool canReturnTwice() const { return hasFnAttr(Attribute::ReturnsTwice); }
void setCanReturnTwice() {
addAttribute(AttributeList::FunctionIndex, Attribute::ReturnsTwice);
}
void setCanReturnTwice() { addFnAttr(Attribute::ReturnsTwice); }
// Methods for support type inquiry through isa, cast, and dyn_cast:
static bool classof(const Instruction *I) {

4
llvm/include/llvm/IR/MatrixBuilder.h
View File

@ -82,7 +82,7 @@ public:
CallInst *Call = B.CreateCall(TheFn->getFunctionType(), TheFn, Ops, Name);
Attribute AlignAttr =
Attribute::getWithAlignment(Call->getContext(), Alignment);
Call->addAttribute(1, AlignAttr);
Call->addParamAttr(0, AlignAttr);
return Call;
}
@ -105,7 +105,7 @@ public:
CallInst *Call = B.CreateCall(TheFn->getFunctionType(), TheFn, Ops, Name);
Attribute AlignAttr =
Attribute::getWithAlignment(Call->getContext(), Alignment);
Call->addAttribute(2, AlignAttr);
Call->addParamAttr(1, AlignAttr);
return Call;
}

2
llvm/lib/Analysis/ConstantFolding.cpp
View File

@ -1880,7 +1880,7 @@ static bool mayFoldConstrained(ConstrainedFPIntrinsic *CI,
// know that its evaluation does not raise exceptions, so side effect
// is absent. To allow removing the call, mark it as not accessing memory.
if (EB && *EB != fp::ExceptionBehavior::ebIgnore)
CI->addAttribute(AttributeList::FunctionIndex, Attribute::ReadNone);
CI->addFnAttr(Attribute::ReadNone);
return true;
}

2
llvm/lib/Analysis/InlineAdvisor.cpp
View File

@ -313,7 +313,7 @@ void llvm::setInlineRemark(CallBase &CB, StringRef Message) {
return;
Attribute Attr = Attribute::get(CB.getContext(), "inline-remark", Message);
CB.addAttribute(AttributeList::FunctionIndex, Attr);
CB.addFnAttr(Attr);
}
/// Return the cost only if the inliner should attempt to inline at the given

5
llvm/lib/Bitcode/Reader/BitcodeReader.cpp
View File

@ -5567,9 +5567,8 @@ Error BitcodeReader::materialize(GlobalValue *GV) {
// Remove incompatible attributes on function calls.
if (auto *CI = dyn_cast<CallBase>(&I)) {
CI->removeAttributes(AttributeList::ReturnIndex,
AttributeFuncs::typeIncompatible(
CI->getFunctionType()->getReturnType()));
CI->removeRetAttrs(AttributeFuncs::typeIncompatible(
CI->getFunctionType()->getReturnType()));
for (unsigned ArgNo = 0; ArgNo < CI->arg_size(); ++ArgNo)
CI->removeParamAttrs(ArgNo, AttributeFuncs::typeIncompatible(

3
llvm/lib/CodeGen/CommandFlags.cpp
View File

@ -672,8 +672,7 @@ void codegen::setFunctionAttributes(StringRef CPU, StringRef Features,
if (const auto *F = Call->getCalledFunction())
if (F->getIntrinsicID() == Intrinsic::debugtrap ||
F->getIntrinsicID() == Intrinsic::trap)
Call->addAttribute(
AttributeList::FunctionIndex,
Call->addFnAttr(
Attribute::get(Ctx, "trap-func-name", getTrapFuncName()));
// Let NewAttrs override Attrs.

4
llvm/lib/IR/AutoUpgrade.cpp
View File

@ -4361,8 +4361,8 @@ struct StrictFPUpgradeVisitor : public InstVisitor<StrictFPUpgradeVisitor> {
return;
// If we get here, the caller doesn't have the strictfp attribute
// but this callsite does. Replace the strictfp attribute with nobuiltin.
Call.removeAttribute(AttributeList::FunctionIndex, Attribute::StrictFP);
Call.addAttribute(AttributeList::FunctionIndex, Attribute::NoBuiltin);
Call.removeFnAttr(Attribute::StrictFP);
Call.addFnAttr(Attribute::NoBuiltin);
}
};
} // namespace

2
llvm/lib/IR/Instruction.cpp
View File

@ -180,7 +180,7 @@ void Instruction::dropUndefImplyingAttrsAndUnknownMetadata(
AttrBuilder UBImplyingAttributes = AttributeFuncs::getUBImplyingAttributes();
for (unsigned ArgNo = 0; ArgNo < CB->getNumArgOperands(); ArgNo++)
CB->removeParamAttrs(ArgNo, UBImplyingAttributes);
CB->removeAttributes(AttributeList::ReturnIndex, UBImplyingAttributes);
CB->removeRetAttrs(UBImplyingAttributes);
}
bool Instruction::isExact() const {

6
llvm/lib/Target/AMDGPU/AMDGPUInstCombineIntrinsic.cpp
View File

@ -586,8 +586,7 @@ GCNTTIImpl::instCombineIntrinsic(InstCombiner &IC, IntrinsicInst &II) const {
MDNode *MD = MDNode::get(II.getContext(), MDArgs);
Value *Args[] = {MetadataAsValue::get(II.getContext(), MD)};
CallInst *NewCall = IC.Builder.CreateCall(NewF, Args);
NewCall->addAttribute(AttributeList::FunctionIndex,
Attribute::Convergent);
NewCall->addFnAttr(Attribute::Convergent);
NewCall->takeName(&II);
return IC.replaceInstUsesWith(II, NewCall);
}
@ -712,8 +711,7 @@ GCNTTIImpl::instCombineIntrinsic(InstCombiner &IC, IntrinsicInst &II) const {
MDNode *MD = MDNode::get(II.getContext(), MDArgs);
Value *Args[] = {MetadataAsValue::get(II.getContext(), MD)};
CallInst *NewCall = IC.Builder.CreateCall(NewF, Args);
NewCall->addAttribute(AttributeList::FunctionIndex,
Attribute::Convergent);
NewCall->addFnAttr(Attribute::Convergent);
NewCall->takeName(&II);
return IC.replaceInstUsesWith(II, NewCall);
}

9
llvm/lib/Target/AMDGPU/AMDGPULowerKernelArguments.cpp
View File

@ -82,9 +82,9 @@ bool AMDGPULowerKernelArguments::runOnFunction(Function &F) {
Builder.CreateIntrinsic(Intrinsic::amdgcn_kernarg_segment_ptr, {}, {},
nullptr, F.getName() + ".kernarg.segment");
KernArgSegment->addAttribute(AttributeList::ReturnIndex, Attribute::NonNull);
KernArgSegment->addAttribute(AttributeList::ReturnIndex,
Attribute::getWithDereferenceableBytes(Ctx, TotalKernArgSize));
KernArgSegment->addRetAttr(Attribute::NonNull);
KernArgSegment->addRetAttr(
Attribute::getWithDereferenceableBytes(Ctx, TotalKernArgSize));
unsigned AS = KernArgSegment->getType()->getPointerAddressSpace();
uint64_t ExplicitArgOffset = 0;
@ -232,8 +232,7 @@ bool AMDGPULowerKernelArguments::runOnFunction(Function &F) {
}
}
KernArgSegment->addAttribute(
AttributeList::ReturnIndex,
KernArgSegment->addRetAttr(
Attribute::getWithAlignment(Ctx, std::max(KernArgBaseAlign, MaxAlign)));
return true;

4
llvm/lib/Target/AMDGPU/AMDGPUPromoteAlloca.cpp
View File

@ -256,8 +256,8 @@ AMDGPUPromoteAllocaImpl::getLocalSizeYZ(IRBuilder<> &Builder) {
= Intrinsic::getDeclaration(Mod, Intrinsic::amdgcn_dispatch_ptr);
CallInst *DispatchPtr = Builder.CreateCall(DispatchPtrFn, {});
DispatchPtr->addAttribute(AttributeList::ReturnIndex, Attribute::NoAlias);
DispatchPtr->addAttribute(AttributeList::ReturnIndex, Attribute::NonNull);
DispatchPtr->addRetAttr(Attribute::NoAlias);
DispatchPtr->addRetAttr(Attribute::NonNull);
// Size of the dispatch packet struct.
DispatchPtr->addDereferenceableAttr(AttributeList::ReturnIndex, 64);

2
llvm/lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp
View File

@ -420,7 +420,7 @@ Value *WebAssemblyLowerEmscriptenEHSjLj::wrapInvoke(CallBase *CI) {
if (CI->doesNotReturn()) {
if (auto *F = CI->getCalledFunction())
F->removeFnAttr(Attribute::NoReturn);
CI->removeAttribute(AttributeList::FunctionIndex, Attribute::NoReturn);
CI->removeFnAttr(Attribute::NoReturn);
}
IRBuilder<> IRB(C);

7
llvm/lib/Transforms/Coroutines/Coroutines.cpp
View File

@ -311,10 +311,9 @@ void coro::Shape::buildFrom(Function &F) {
if (CoroBegin)
report_fatal_error(
"coroutine should have exactly one defining @llvm.coro.begin");
CB->addAttribute(AttributeList::ReturnIndex, Attribute::NonNull);
CB->addAttribute(AttributeList::ReturnIndex, Attribute::NoAlias);
CB->removeAttribute(AttributeList::FunctionIndex,
Attribute::NoDuplicate);
CB->addRetAttr(Attribute::NonNull);
CB->addRetAttr(Attribute::NoAlias);
CB->removeFnAttr(Attribute::NoDuplicate);
CoroBegin = CB;
break;
}

2
llvm/lib/Transforms/IPO/Attributor.cpp
View File

@ -1922,7 +1922,7 @@ void Attributor::createShallowWrapper(Function &F) {
CallInst *CI = CallInst::Create(&F, Args, "", EntryBB);
CI->setTailCall(true);
CI->addAttribute(AttributeList::FunctionIndex, Attribute::NoInline);
CI->addFnAttr(Attribute::NoInline);
ReturnInst::Create(Ctx, CI->getType()->isVoidTy() ? nullptr : CI, EntryBB);
NumFnShallowWrappersCreated++;

45
llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp
View File

@ -2436,55 +2436,46 @@ void InstCombinerImpl::annotateAnyAllocSite(CallBase &Call, const TargetLibraryI
if (isMallocLikeFn(&Call, TLI) && Op0C) {
if (isOpNewLikeFn(&Call, TLI))
Call.addAttribute(AttributeList::ReturnIndex,
Attribute::getWithDereferenceableBytes(
Call.getContext(), Op0C->getZExtValue()));
Call.addRetAttr(Attribute::getWithDereferenceableBytes(
Call.getContext(), Op0C->getZExtValue()));
else
Call.addAttribute(AttributeList::ReturnIndex,
Attribute::getWithDereferenceableOrNullBytes(
Call.getContext(), Op0C->getZExtValue()));
Call.addRetAttr(Attribute::getWithDereferenceableOrNullBytes(
Call.getContext(), Op0C->getZExtValue()));
} else if (isAlignedAllocLikeFn(&Call, TLI)) {
if (Op1C)
Call.addAttribute(AttributeList::ReturnIndex,
Attribute::getWithDereferenceableOrNullBytes(
Call.getContext(), Op1C->getZExtValue()));
Call.addRetAttr(Attribute::getWithDereferenceableOrNullBytes(
Call.getContext(), Op1C->getZExtValue()));
// Add alignment attribute if alignment is a power of two constant.
if (Op0C && Op0C->getValue().ult(llvm::Value::MaximumAlignment) &&
isKnownNonZero(Call.getOperand(1), DL, 0, &AC, &Call, &DT)) {
uint64_t AlignmentVal = Op0C->getZExtValue();
if (llvm::isPowerOf2_64(AlignmentVal)) {
Call.removeAttribute(AttributeList::ReturnIndex, Attribute::Alignment);
Call.addAttribute(AttributeList::ReturnIndex,
Attribute::getWithAlignment(Call.getContext(),
Align(AlignmentVal)));
Call.removeRetAttr(Attribute::Alignment);
Call.addRetAttr(Attribute::getWithAlignment(Call.getContext(),
Align(AlignmentVal)));
}
}
} else if (isReallocLikeFn(&Call, TLI) && Op1C) {
Call.addAttribute(AttributeList::ReturnIndex,
Attribute::getWithDereferenceableOrNullBytes(
Call.getContext(), Op1C->getZExtValue()));
Call.addRetAttr(Attribute::getWithDereferenceableOrNullBytes(
Call.getContext(), Op1C->getZExtValue()));
} else if (isCallocLikeFn(&Call, TLI) && Op0C && Op1C) {
bool Overflow;
const APInt &N = Op0C->getValue();
APInt Size = N.umul_ov(Op1C->getValue(), Overflow);
if (!Overflow)
Call.addAttribute(AttributeList::ReturnIndex,
Attribute::getWithDereferenceableOrNullBytes(
Call.getContext(), Size.getZExtValue()));
Call.addRetAttr(Attribute::getWithDereferenceableOrNullBytes(
Call.getContext(), Size.getZExtValue()));
} else if (isStrdupLikeFn(&Call, TLI)) {
uint64_t Len = GetStringLength(Call.getOperand(0));
if (Len) {
// strdup
if (NumArgs == 1)
Call.addAttribute(AttributeList::ReturnIndex,
Attribute::getWithDereferenceableOrNullBytes(
Call.getContext(), Len));
Call.addRetAttr(Attribute::getWithDereferenceableOrNullBytes(
Call.getContext(), Len));
// strndup
else if (NumArgs == 2 && Op1C)
Call.addAttribute(
AttributeList::ReturnIndex,
Attribute::getWithDereferenceableOrNullBytes(
Call.getContext(), std::min(Len, Op1C->getZExtValue() + 1)));
Call.addRetAttr(Attribute::getWithDereferenceableOrNullBytes(
Call.getContext(), std::min(Len, Op1C->getZExtValue() + 1)));
}
}
}
@ -2686,7 +2677,7 @@ Instruction *InstCombinerImpl::visitCallBase(CallBase &Call) {
// isKnownNonNull -> nonnull attribute
if (!GCR.hasRetAttr(Attribute::NonNull) &&
isKnownNonZero(DerivedPtr, DL, 0, &AC, &Call, &DT)) {
GCR.addAttribute(AttributeList::ReturnIndex, Attribute::NonNull);
GCR.addRetAttr(Attribute::NonNull);
// We discovered new fact, re-check users.
Worklist.pushUsersToWorkList(GCR);
}

4
llvm/lib/Transforms/Instrumentation/DataFlowSanitizer.cpp
View File

@ -2113,7 +2113,7 @@ std::pair<Value *, Value *> DFSanFunction::loadShadowOriginSansLoadTracking(
IRB.CreateCall(DFS.DFSanLoadLabelAndOriginFn,
{IRB.CreatePointerCast(Addr, IRB.getInt8PtrTy()),
ConstantInt::get(DFS.IntptrTy, Size)});
Call->addAttribute(AttributeList::ReturnIndex, Attribute::ZExt);
Call->addRetAttr(Attribute::ZExt);
return {IRB.CreateTrunc(IRB.CreateLShr(Call, DFS.OriginWidthBits),
DFS.PrimitiveShadowTy),
IRB.CreateTrunc(Call, DFS.OriginTy)};
@ -2160,7 +2160,7 @@ std::pair<Value *, Value *> DFSanFunction::loadShadowOriginSansLoadTracking(
IRBuilder<> IRB(Pos);
CallInst *FallbackCall = IRB.CreateCall(
DFS.DFSanUnionLoadFn, {ShadowAddr, ConstantInt::get(DFS.IntptrTy, Size)});
FallbackCall->addAttribute(AttributeList::ReturnIndex, Attribute::ZExt);
FallbackCall->addRetAttr(Attribute::ZExt);
return {FallbackCall, Origin};
}

2
llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp
View File

@ -3653,7 +3653,7 @@ struct MemorySanitizerVisitor : public InstVisitor<MemorySanitizerVisitor> {
.addAttribute(Attribute::ArgMemOnly)
.addAttribute(Attribute::Speculatable);
Call->removeAttributes(AttributeList::FunctionIndex, B);
Call->removeFnAttrs(B);
if (Function *Func = Call->getCalledFunction()) {
Func->removeFnAttrs(B);
}

2
llvm/lib/Transforms/Scalar/PartiallyInlineLibCalls.cpp
View File

@ -82,7 +82,7 @@ static bool optimizeSQRT(CallInst *Call, Function *CalledFunc,
// Add attribute "readnone" so that backend can use a native sqrt instruction
// for this call.
Call->addAttribute(AttributeList::FunctionIndex, Attribute::ReadNone);
Call->addFnAttr(Attribute::ReadNone);
// Insert a FP compare instruction and use it as the CurrBB branch condition.
Builder.SetInsertPoint(CurrBBTerm);

3
llvm/lib/Transforms/Scalar/SCCP.cpp
View File

@ -497,8 +497,7 @@ bool llvm::runIPSCCP(
if (!CB || CB->getCalledFunction() != &F)
continue;
CB->removeAttributes(AttributeList::FunctionIndex,
AttributesToRemove);
CB->removeFnAttrs(AttributesToRemove);
}
}
}

2
llvm/lib/Transforms/Utils/Local.cpp
View File

@ -3247,7 +3247,7 @@ void llvm::maybeMarkSanitizerLibraryCallNoBuiltin(
if (F && !F->hasLocalLinkage() && F->hasName() &&
TLI->getLibFunc(F->getName(), Func) && TLI->hasOptimizedCodeGen(Func) &&
!F->doesNotAccessMemory())
CI->addAttribute(AttributeList::FunctionIndex, Attribute::NoBuiltin);
CI->addFnAttr(Attribute::NoBuiltin);
}
bool llvm::canReplaceOperandWithVariable(const Instruction *I, unsigned OpIdx) {

3
llvm/lib/Transforms/Utils/ModuleUtils.cpp
View File

@ -297,7 +297,6 @@ void VFABI::setVectorVariantNames(
"vector function declaration is missing.");
}
#endif
CI->addAttribute(
AttributeList::FunctionIndex,
CI->addFnAttr(
Attribute::get(M->getContext(), MappingsAttrName, Buffer.str()));
}

36
llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp
View File

@ -512,8 +512,7 @@ Value *LibCallSimplifier::optimizeStrCpy(CallInst *CI, IRBuilderBase &B) {
B.CreateMemCpy(Dst, Align(1), Src, Align(1),
ConstantInt::get(DL.getIntPtrType(CI->getContext()), Len));
NewCI->setAttributes(CI->getAttributes());
NewCI->removeAttributes(AttributeList::ReturnIndex,
AttributeFuncs::typeIncompatible(NewCI->getType()));
NewCI->removeRetAttrs(AttributeFuncs::typeIncompatible(NewCI->getType()));
return Dst;
}
@ -541,8 +540,7 @@ Value *LibCallSimplifier::optimizeStpCpy(CallInst *CI, IRBuilderBase &B) {
// copy for us. Make a memcpy to copy the nul byte with align = 1.
CallInst *NewCI = B.CreateMemCpy(Dst, Align(1), Src, Align(1), LenV);
NewCI->setAttributes(CI->getAttributes());
NewCI->removeAttributes(AttributeList::ReturnIndex,
AttributeFuncs::typeIncompatible(NewCI->getType()));
NewCI->removeRetAttrs(AttributeFuncs::typeIncompatible(NewCI->getType()));
return DstEnd;
}
@ -604,8 +602,7 @@ Value *LibCallSimplifier::optimizeStrNCpy(CallInst *CI, IRBuilderBase &B) {
CallInst *NewCI = B.CreateMemCpy(Dst, Align(1), Src, Align(1),
ConstantInt::get(DL.getIntPtrType(PT), Len));
NewCI->setAttributes(CI->getAttributes());
NewCI->removeAttributes(AttributeList::ReturnIndex,
AttributeFuncs::typeIncompatible(NewCI->getType()));
NewCI->removeRetAttrs(AttributeFuncs::typeIncompatible(NewCI->getType()));
return Dst;
}
@ -1082,8 +1079,7 @@ Value *LibCallSimplifier::optimizeMemCpy(CallInst *CI, IRBuilderBase &B) {
CallInst *NewCI = B.CreateMemCpy(CI->getArgOperand(0), Align(1),
CI->getArgOperand(1), Align(1), Size);
NewCI->setAttributes(CI->getAttributes());
NewCI->removeAttributes(AttributeList::ReturnIndex,
AttributeFuncs::typeIncompatible(NewCI->getType()));
NewCI->removeRetAttrs(AttributeFuncs::typeIncompatible(NewCI->getType()));
return CI->getArgOperand(0);
}
@ -1136,8 +1132,7 @@ Value *LibCallSimplifier::optimizeMemPCpy(CallInst *CI, IRBuilderBase &B) {
// any return attributes are compliant.
// TODO: Attach return value attributes to the 1st operand to preserve them?
NewCI->setAttributes(CI->getAttributes());
NewCI->removeAttributes(AttributeList::ReturnIndex,
AttributeFuncs::typeIncompatible(NewCI->getType()));
NewCI->removeRetAttrs(AttributeFuncs::typeIncompatible(NewCI->getType()));
return B.CreateInBoundsGEP(B.getInt8Ty(), Dst, N);
}
@ -1151,8 +1146,7 @@ Value *LibCallSimplifier::optimizeMemMove(CallInst *CI, IRBuilderBase &B) {
CallInst *NewCI = B.CreateMemMove(CI->getArgOperand(0), Align(1),
CI->getArgOperand(1), Align(1), Size);
NewCI->setAttributes(CI->getAttributes());
NewCI->removeAttributes(AttributeList::ReturnIndex,
AttributeFuncs::typeIncompatible(NewCI->getType()));
NewCI->removeRetAttrs(AttributeFuncs::typeIncompatible(NewCI->getType()));
return CI->getArgOperand(0);
}
@ -1166,8 +1160,7 @@ Value *LibCallSimplifier::optimizeMemSet(CallInst *CI, IRBuilderBase &B) {
Value *Val = B.CreateIntCast(CI->getArgOperand(1), B.getInt8Ty(), false);
CallInst *NewCI = B.CreateMemSet(CI->getArgOperand(0), Val, Size, Align(1));
NewCI->setAttributes(CI->getAttributes());
NewCI->removeAttributes(AttributeList::ReturnIndex,
AttributeFuncs::typeIncompatible(NewCI->getType()));
NewCI->removeRetAttrs(AttributeFuncs::typeIncompatible(NewCI->getType()));
return CI->getArgOperand(0);
}
@ -2286,7 +2279,7 @@ Value *LibCallSimplifier::optimizeErrorReporting(CallInst *CI, IRBuilderBase &B,
// Proceedings of PACT'98, Oct. 1998, IEEE
if (!CI->hasFnAttr(Attribute::Cold) &&
isReportingError(Callee, CI, StreamArg)) {
CI->addAttribute(AttributeList::FunctionIndex, Attribute::Cold);
CI->addFnAttr(Attribute::Cold);
}
return nullptr;
@ -3218,8 +3211,7 @@ Value *FortifiedLibCallSimplifier::optimizeMemCpyChk(CallInst *CI,
B.CreateMemCpy(CI->getArgOperand(0), Align(1), CI->getArgOperand(1),
Align(1), CI->getArgOperand(2));
NewCI->setAttributes(CI->getAttributes());
NewCI->removeAttributes(AttributeList::ReturnIndex,
AttributeFuncs::typeIncompatible(NewCI->getType()));
NewCI->removeRetAttrs(AttributeFuncs::typeIncompatible(NewCI->getType()));
return CI->getArgOperand(0);
}
return nullptr;
@ -3232,8 +3224,7 @@ Value *FortifiedLibCallSimplifier::optimizeMemMoveChk(CallInst *CI,
B.CreateMemMove(CI->getArgOperand(0), Align(1), CI->getArgOperand(1),
Align(1), CI->getArgOperand(2));
NewCI->setAttributes(CI->getAttributes());
NewCI->removeAttributes(AttributeList::ReturnIndex,
AttributeFuncs::typeIncompatible(NewCI->getType()));
NewCI->removeRetAttrs(AttributeFuncs::typeIncompatible(NewCI->getType()));
return CI->getArgOperand(0);
}
return nullptr;
@ -3246,8 +3237,7 @@ Value *FortifiedLibCallSimplifier::optimizeMemSetChk(CallInst *CI,
CallInst *NewCI = B.CreateMemSet(CI->getArgOperand(0), Val,
CI->getArgOperand(2), Align(1));
NewCI->setAttributes(CI->getAttributes());
NewCI->removeAttributes(AttributeList::ReturnIndex,
AttributeFuncs::typeIncompatible(NewCI->getType()));
NewCI->removeRetAttrs(AttributeFuncs::typeIncompatible(NewCI->getType()));
return CI->getArgOperand(0);
}
return nullptr;
@ -3261,9 +3251,7 @@ Value *FortifiedLibCallSimplifier::optimizeMemPCpyChk(CallInst *CI,
CI->getArgOperand(2), B, DL, TLI)) {
CallInst *NewCI = cast<CallInst>(Call);
NewCI->setAttributes(CI->getAttributes());
NewCI->removeAttributes(
AttributeList::ReturnIndex,
AttributeFuncs::typeIncompatible(NewCI->getType()));
NewCI->removeRetAttrs(AttributeFuncs::typeIncompatible(NewCI->getType()));
return NewCI;
}
return nullptr;

3
llvm/unittests/IR/InstructionsTest.cpp
View File

@ -95,8 +95,7 @@ TEST_F(ModuleWithFunctionTest, CallInst) {
Idx++;
}
Call->addAttribute(llvm::AttributeList::ReturnIndex,
Attribute::get(Call->getContext(), "test-str-attr"));
Call->addRetAttr(Attribute::get(Call->getContext(), "test-str-attr"));
EXPECT_TRUE(Call->hasRetAttr("test-str-attr"));
EXPECT_FALSE(Call->hasRetAttr("not-on-call"));
}