Author: Arthur Eubanks Date: 2021-08-17T21:05:41-07:00 New Revision: 3f4d00bc3b514d3218089fce15457457fc3312c3
URL: https://github.com/llvm/llvm-project/commit/3f4d00bc3b514d3218089fce15457457fc3312c3 DIFF: https://github.com/llvm/llvm-project/commit/3f4d00bc3b514d3218089fce15457457fc3312c3.diff LOG: [NFC] More get/removeAttribute() cleanup Added: Modified: clang/lib/CodeGen/CGBuiltin.cpp clang/lib/CodeGen/CGCall.cpp clang/lib/CodeGen/CGExpr.cpp clang/lib/CodeGen/CGExprCXX.cpp clang/lib/CodeGen/CGStmt.cpp llvm/include/llvm/IR/IRBuilder.h llvm/include/llvm/IR/InstrTypes.h llvm/include/llvm/IR/Instructions.h llvm/include/llvm/IR/MatrixBuilder.h llvm/lib/Analysis/ConstantFolding.cpp llvm/lib/Analysis/InlineAdvisor.cpp llvm/lib/Bitcode/Reader/BitcodeReader.cpp llvm/lib/CodeGen/CommandFlags.cpp llvm/lib/IR/AutoUpgrade.cpp llvm/lib/IR/Instruction.cpp llvm/lib/Target/AMDGPU/AMDGPUInstCombineIntrinsic.cpp llvm/lib/Target/AMDGPU/AMDGPULowerKernelArguments.cpp llvm/lib/Target/AMDGPU/AMDGPUPromoteAlloca.cpp llvm/lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp llvm/lib/Transforms/Coroutines/Coroutines.cpp llvm/lib/Transforms/IPO/Attributor.cpp llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp llvm/lib/Transforms/Instrumentation/DataFlowSanitizer.cpp llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp llvm/lib/Transforms/Scalar/PartiallyInlineLibCalls.cpp llvm/lib/Transforms/Scalar/SCCP.cpp llvm/lib/Transforms/Utils/Local.cpp llvm/lib/Transforms/Utils/ModuleUtils.cpp llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp llvm/unittests/IR/InstructionsTest.cpp Removed: ################################################################################ diff --git a/clang/lib/CodeGen/CGBuiltin.cpp b/clang/lib/CodeGen/CGBuiltin.cpp index 08f4f644eb10d..e172fc493a25e 100644 --- a/clang/lib/CodeGen/CGBuiltin.cpp +++ b/clang/lib/CodeGen/CGBuiltin.cpp @@ -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(); diff --git a/clang/lib/CodeGen/CGCall.cpp b/clang/lib/CodeGen/CGCall.cpp index c9dc1c8e8c62a..50c1e180f5740 100644 --- a/clang/lib/CodeGen/CGCall.cpp +++ b/clang/lib/CodeGen/CGCall.cpp @@ -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. diff --git a/clang/lib/CodeGen/CGExpr.cpp b/clang/lib/CodeGen/CGExpr.cpp index bf514aab88515..83f5f42431e01 100644 --- a/clang/lib/CodeGen/CGExpr.cpp +++ b/clang/lib/CodeGen/CGExpr.cpp @@ -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; diff --git a/clang/lib/CodeGen/CGExprCXX.cpp b/clang/lib/CodeGen/CGExprCXX.cpp index 96cf977ca2901..d86ae7ad17d68 100644 --- a/clang/lib/CodeGen/CGExprCXX.cpp +++ b/clang/lib/CodeGen/CGExprCXX.cpp @@ -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; diff --git a/clang/lib/CodeGen/CGStmt.cpp b/clang/lib/CodeGen/CGStmt.cpp index 0a3a722fa6533..4ff1f7b3a85b9 100644 --- a/clang/lib/CodeGen/CGStmt.cpp +++ b/clang/lib/CodeGen/CGStmt.cpp @@ -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); diff --git a/llvm/include/llvm/IR/IRBuilder.h b/llvm/include/llvm/IR/IRBuilder.h index 8f57d47eda89e..2c07f431b5703 100644 --- a/llvm/include/llvm/IR/IRBuilder.h +++ b/llvm/include/llvm/IR/IRBuilder.h @@ -351,7 +351,7 @@ class IRBuilderBase { } void setConstrainedFPCallAttr(CallBase *I) { - I->addAttribute(AttributeList::FunctionIndex, Attribute::StrictFP); + I->addFnAttr(Attribute::StrictFP); } void setDefaultOperandBundles(ArrayRef<OperandBundleDef> OpBundles) { diff --git a/llvm/include/llvm/IR/InstrTypes.h b/llvm/include/llvm/IR/InstrTypes.h index 142e1f29a641c..60e8c090fb83e 100644 --- a/llvm/include/llvm/IR/InstrTypes.h +++ b/llvm/include/llvm/IR/InstrTypes.h @@ -1499,6 +1499,26 @@ class CallBase : public Instruction { 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 @@ class CallBase : public Instruction { 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.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.removeAttributes(getContext(), i, Attrs); + 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 @@ class CallBase : public Instruction { /// 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 @@ class CallBase : public Instruction { 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 @@ class CallBase : public Instruction { 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. diff --git a/llvm/include/llvm/IR/Instructions.h b/llvm/include/llvm/IR/Instructions.h index 4d3f512b03ed6..fac6b108fd6a8 100644 --- a/llvm/include/llvm/IR/Instructions.h +++ b/llvm/include/llvm/IR/Instructions.h @@ -1685,9 +1685,7 @@ class CallInst : public CallBase { /// 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) { diff --git a/llvm/include/llvm/IR/MatrixBuilder.h b/llvm/include/llvm/IR/MatrixBuilder.h index 136de14ba2c1a..d5fc2d1fce71f 100644 --- a/llvm/include/llvm/IR/MatrixBuilder.h +++ b/llvm/include/llvm/IR/MatrixBuilder.h @@ -82,7 +82,7 @@ template <class IRBuilderTy> class MatrixBuilder { 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 @@ template <class IRBuilderTy> class MatrixBuilder { 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; } diff --git a/llvm/lib/Analysis/ConstantFolding.cpp b/llvm/lib/Analysis/ConstantFolding.cpp index 4a943a1b7325b..758c0a01f2101 100644 --- a/llvm/lib/Analysis/ConstantFolding.cpp +++ b/llvm/lib/Analysis/ConstantFolding.cpp @@ -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; } diff --git a/llvm/lib/Analysis/InlineAdvisor.cpp b/llvm/lib/Analysis/InlineAdvisor.cpp index 363b81a55060e..d2a7168404545 100644 --- a/llvm/lib/Analysis/InlineAdvisor.cpp +++ b/llvm/lib/Analysis/InlineAdvisor.cpp @@ -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 diff --git a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp index bc967f60db896..eb6a7f39b9341 100644 --- a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp +++ b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp @@ -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( diff --git a/llvm/lib/CodeGen/CommandFlags.cpp b/llvm/lib/CodeGen/CommandFlags.cpp index 19f395943e494..c30e1c3fb564c 100644 --- a/llvm/lib/CodeGen/CommandFlags.cpp +++ b/llvm/lib/CodeGen/CommandFlags.cpp @@ -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. diff --git a/llvm/lib/IR/AutoUpgrade.cpp b/llvm/lib/IR/AutoUpgrade.cpp index 95a776eab9e07..8e9d0c6c81f51 100644 --- a/llvm/lib/IR/AutoUpgrade.cpp +++ b/llvm/lib/IR/AutoUpgrade.cpp @@ -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 diff --git a/llvm/lib/IR/Instruction.cpp b/llvm/lib/IR/Instruction.cpp index 937dc69578063..e91fc1d71c34f 100644 --- a/llvm/lib/IR/Instruction.cpp +++ b/llvm/lib/IR/Instruction.cpp @@ -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 { diff --git a/llvm/lib/Target/AMDGPU/AMDGPUInstCombineIntrinsic.cpp b/llvm/lib/Target/AMDGPU/AMDGPUInstCombineIntrinsic.cpp index 06aa0055e4bb5..1a89b85c798d2 100644 --- a/llvm/lib/Target/AMDGPU/AMDGPUInstCombineIntrinsic.cpp +++ b/llvm/lib/Target/AMDGPU/AMDGPUInstCombineIntrinsic.cpp @@ -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); } diff --git a/llvm/lib/Target/AMDGPU/AMDGPULowerKernelArguments.cpp b/llvm/lib/Target/AMDGPU/AMDGPULowerKernelArguments.cpp index 0f157e53c3db3..c34c12ab9fecb 100644 --- a/llvm/lib/Target/AMDGPU/AMDGPULowerKernelArguments.cpp +++ b/llvm/lib/Target/AMDGPU/AMDGPULowerKernelArguments.cpp @@ -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; diff --git a/llvm/lib/Target/AMDGPU/AMDGPUPromoteAlloca.cpp b/llvm/lib/Target/AMDGPU/AMDGPUPromoteAlloca.cpp index 3f1f21a33f7ea..f8af9dbe73546 100644 --- a/llvm/lib/Target/AMDGPU/AMDGPUPromoteAlloca.cpp +++ b/llvm/lib/Target/AMDGPU/AMDGPUPromoteAlloca.cpp @@ -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); diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp index c224c10b3f081..daf5114a54059 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp +++ b/llvm/lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp @@ -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); diff --git a/llvm/lib/Transforms/Coroutines/Coroutines.cpp b/llvm/lib/Transforms/Coroutines/Coroutines.cpp index c131e29300e61..66e47ef03bf93 100644 --- a/llvm/lib/Transforms/Coroutines/Coroutines.cpp +++ b/llvm/lib/Transforms/Coroutines/Coroutines.cpp @@ -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; } diff --git a/llvm/lib/Transforms/IPO/Attributor.cpp b/llvm/lib/Transforms/IPO/Attributor.cpp index 0585d2c716400..1b30157e19522 100644 --- a/llvm/lib/Transforms/IPO/Attributor.cpp +++ b/llvm/lib/Transforms/IPO/Attributor.cpp @@ -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++; diff --git a/llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp b/llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp index 9e4dd754be078..238d4cc5f069c 100644 --- a/llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp +++ b/llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp @@ -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); } diff --git a/llvm/lib/Transforms/Instrumentation/DataFlowSanitizer.cpp b/llvm/lib/Transforms/Instrumentation/DataFlowSanitizer.cpp index 988224c3edf3f..6a62f5e9ad774 100644 --- a/llvm/lib/Transforms/Instrumentation/DataFlowSanitizer.cpp +++ b/llvm/lib/Transforms/Instrumentation/DataFlowSanitizer.cpp @@ -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}; } diff --git a/llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp b/llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp index 6fe330123d8c7..7e6709be4bbff 100644 --- a/llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp +++ b/llvm/lib/Transforms/Instrumentation/MemorySanitizer.cpp @@ -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); } diff --git a/llvm/lib/Transforms/Scalar/PartiallyInlineLibCalls.cpp b/llvm/lib/Transforms/Scalar/PartiallyInlineLibCalls.cpp index 7872c553b412c..44027ccd92ca2 100644 --- a/llvm/lib/Transforms/Scalar/PartiallyInlineLibCalls.cpp +++ b/llvm/lib/Transforms/Scalar/PartiallyInlineLibCalls.cpp @@ -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); diff --git a/llvm/lib/Transforms/Scalar/SCCP.cpp b/llvm/lib/Transforms/Scalar/SCCP.cpp index 402ebfb9da35a..f547e5f1a0086 100644 --- a/llvm/lib/Transforms/Scalar/SCCP.cpp +++ b/llvm/lib/Transforms/Scalar/SCCP.cpp @@ -497,8 +497,7 @@ bool llvm::runIPSCCP( if (!CB || CB->getCalledFunction() != &F) continue; - CB->removeAttributes(AttributeList::FunctionIndex, - AttributesToRemove); + CB->removeFnAttrs(AttributesToRemove); } } } diff --git a/llvm/lib/Transforms/Utils/Local.cpp b/llvm/lib/Transforms/Utils/Local.cpp index 8e19a4829710c..862e3c3e881fc 100644 --- a/llvm/lib/Transforms/Utils/Local.cpp +++ b/llvm/lib/Transforms/Utils/Local.cpp @@ -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) { diff --git a/llvm/lib/Transforms/Utils/ModuleUtils.cpp b/llvm/lib/Transforms/Utils/ModuleUtils.cpp index aa95204229ff8..ab85879243e2a 100644 --- a/llvm/lib/Transforms/Utils/ModuleUtils.cpp +++ b/llvm/lib/Transforms/Utils/ModuleUtils.cpp @@ -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())); } diff --git a/llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp b/llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp index ddcb55984861f..1e03c8dbd0371 100644 --- a/llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp +++ b/llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp @@ -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; diff --git a/llvm/unittests/IR/InstructionsTest.cpp b/llvm/unittests/IR/InstructionsTest.cpp index c9d6d846cbab7..81299b9f97782 100644 --- a/llvm/unittests/IR/InstructionsTest.cpp +++ b/llvm/unittests/IR/InstructionsTest.cpp @@ -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")); } _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
