diff options
Diffstat (limited to 'llvm/lib/Transforms')
| -rw-r--r-- | llvm/lib/Transforms/IPO/ArgumentPromotion.cpp | 43 | ||||
| -rw-r--r-- | llvm/lib/Transforms/IPO/DeadArgumentElimination.cpp | 85 | ||||
| -rw-r--r-- | llvm/lib/Transforms/IPO/MergeFunctions.cpp | 3 | ||||
| -rw-r--r-- | llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp | 49 | ||||
| -rw-r--r-- | llvm/lib/Transforms/Scalar/RewriteStatepointsForGC.cpp | 15 | ||||
| -rw-r--r-- | llvm/lib/Transforms/Utils/CloneFunction.cpp | 22 | ||||
| -rw-r--r-- | llvm/lib/Transforms/Utils/CodeExtractor.cpp | 3 |
7 files changed, 128 insertions, 92 deletions
diff --git a/llvm/lib/Transforms/IPO/ArgumentPromotion.cpp b/llvm/lib/Transforms/IPO/ArgumentPromotion.cpp index b8f92f26b33..cc525ce6e36 100644 --- a/llvm/lib/Transforms/IPO/ArgumentPromotion.cpp +++ b/llvm/lib/Transforms/IPO/ArgumentPromotion.cpp @@ -42,7 +42,6 @@ #include "llvm/Analysis/LazyCallGraph.h" #include "llvm/Analysis/Loads.h" #include "llvm/Analysis/TargetLibraryInfo.h" -#include "llvm/IR/AttributeSetNode.h" #include "llvm/IR/CFG.h" #include "llvm/IR/CallSite.h" #include "llvm/IR/Constants.h" @@ -103,11 +102,13 @@ doPromotion(Function *F, SmallPtrSetImpl<Argument *> &ArgsToPromote, // Attribute - Keep track of the parameter attributes for the arguments // that we are *not* promoting. For the ones that we do promote, the parameter // attributes are lost - SmallVector<AttributeSetNode *, 8> AttributesVec; + SmallVector<AttributeList, 8> AttributesVec; const AttributeList &PAL = F->getAttributes(); // Add any return attributes. - AttributesVec.push_back(PAL.getRetAttributes()); + if (PAL.hasAttributes(AttributeList::ReturnIndex)) + AttributesVec.push_back( + AttributeList::get(F->getContext(), PAL.getRetAttributes())); // First, determine the new argument list unsigned ArgIndex = 1; @@ -118,12 +119,16 @@ doPromotion(Function *F, SmallPtrSetImpl<Argument *> &ArgsToPromote, Type *AgTy = cast<PointerType>(I->getType())->getElementType(); StructType *STy = cast<StructType>(AgTy); Params.insert(Params.end(), STy->element_begin(), STy->element_end()); - AttributesVec.insert(AttributesVec.end(), STy->getNumElements(), nullptr); ++NumByValArgsPromoted; } else if (!ArgsToPromote.count(&*I)) { // Unchanged argument Params.push_back(I->getType()); - AttributesVec.push_back(PAL.getParamAttributes(ArgIndex)); + AttributeList attrs = PAL.getParamAttributes(ArgIndex); + if (attrs.hasAttributes(ArgIndex)) { + AttrBuilder B(attrs, ArgIndex); + AttributesVec.push_back( + AttributeList::get(F->getContext(), Params.size(), B)); + } } else if (I->use_empty()) { // Dead argument (which are always marked as promotable) ++NumArgumentsDead; @@ -168,7 +173,6 @@ doPromotion(Function *F, SmallPtrSetImpl<Argument *> &ArgsToPromote, Params.push_back(GetElementPtrInst::getIndexedType( cast<PointerType>(I->getType()->getScalarType())->getElementType(), ArgIndex.second)); - AttributesVec.push_back(nullptr); assert(Params.back()); } @@ -180,7 +184,9 @@ doPromotion(Function *F, SmallPtrSetImpl<Argument *> &ArgsToPromote, } // Add any function attributes. - AttributesVec.push_back(PAL.getFnAttributes()); + if (PAL.hasAttributes(AttributeList::FunctionIndex)) + AttributesVec.push_back( + AttributeList::get(FTy->getContext(), PAL.getFnAttributes())); Type *RetTy = FTy->getReturnType(); @@ -217,7 +223,9 @@ doPromotion(Function *F, SmallPtrSetImpl<Argument *> &ArgsToPromote, const AttributeList &CallPAL = CS.getAttributes(); // Add any return attributes. - AttributesVec.push_back(CallPAL.getRetAttributes()); + if (CallPAL.hasAttributes(AttributeList::ReturnIndex)) + AttributesVec.push_back( + AttributeList::get(F->getContext(), CallPAL.getRetAttributes())); // Loop over the operands, inserting GEP and loads in the caller as // appropriate. @@ -227,7 +235,12 @@ doPromotion(Function *F, SmallPtrSetImpl<Argument *> &ArgsToPromote, ++I, ++AI, ++ArgIndex) if (!ArgsToPromote.count(&*I) && !ByValArgsToTransform.count(&*I)) { Args.push_back(*AI); // Unmodified argument - AttributesVec.push_back(CallPAL.getAttributes(ArgIndex)); + + if (CallPAL.hasAttributes(ArgIndex)) { + AttrBuilder B(CallPAL, ArgIndex); + AttributesVec.push_back( + AttributeList::get(F->getContext(), Args.size(), B)); + } } else if (ByValArgsToTransform.count(&*I)) { // Emit a GEP and load for each element of the struct. Type *AgTy = cast<PointerType>(I->getType())->getElementType(); @@ -240,7 +253,6 @@ doPromotion(Function *F, SmallPtrSetImpl<Argument *> &ArgsToPromote, STy, *AI, Idxs, (*AI)->getName() + "." + Twine(i), Call); // TODO: Tell AA about the new values? Args.push_back(new LoadInst(Idx, Idx->getName() + ".val", Call)); - AttributesVec.push_back(nullptr); } } else if (!I->use_empty()) { // Non-dead argument: insert GEPs and loads as appropriate. @@ -283,18 +295,23 @@ doPromotion(Function *F, SmallPtrSetImpl<Argument *> &ArgsToPromote, newLoad->setAAMetadata(AAInfo); Args.push_back(newLoad); - AttributesVec.push_back(nullptr); } } // Push any varargs arguments on the list. for (; AI != CS.arg_end(); ++AI, ++ArgIndex) { Args.push_back(*AI); - AttributesVec.push_back(CallPAL.getAttributes(ArgIndex)); + if (CallPAL.hasAttributes(ArgIndex)) { + AttrBuilder B(CallPAL, ArgIndex); + AttributesVec.push_back( + AttributeList::get(F->getContext(), Args.size(), B)); + } } // Add any function attributes. - AttributesVec.push_back(CallPAL.getFnAttributes()); + if (CallPAL.hasAttributes(AttributeList::FunctionIndex)) + AttributesVec.push_back( + AttributeList::get(Call->getContext(), CallPAL.getFnAttributes())); SmallVector<OperandBundleDef, 1> OpBundles; CS.getOperandBundlesAsDefs(OpBundles); diff --git a/llvm/lib/Transforms/IPO/DeadArgumentElimination.cpp b/llvm/lib/Transforms/IPO/DeadArgumentElimination.cpp index c7138bfbc8b..fe79efce290 100644 --- a/llvm/lib/Transforms/IPO/DeadArgumentElimination.cpp +++ b/llvm/lib/Transforms/IPO/DeadArgumentElimination.cpp @@ -21,7 +21,6 @@ #include "llvm/ADT/SmallVector.h" #include "llvm/ADT/Statistic.h" #include "llvm/ADT/StringExtras.h" -#include "llvm/IR/AttributeSetNode.h" #include "llvm/IR/CallSite.h" #include "llvm/IR/CallingConv.h" #include "llvm/IR/Constant.h" @@ -173,9 +172,8 @@ bool DeadArgumentEliminationPass::DeleteDeadVarargs(Function &Fn) { for (unsigned i = 0; PAL.getSlotIndex(i) <= NumArgs; ++i) AttributesVec.push_back(PAL.getSlotAttributes(i)); if (PAL.hasAttributes(AttributeList::FunctionIndex)) - AttributesVec.push_back(AttributeList::get(Fn.getContext(), - AttributeList::FunctionIndex, - PAL.getFnAttributes())); + AttributesVec.push_back( + AttributeList::get(Fn.getContext(), PAL.getFnAttributes())); PAL = AttributeList::get(Fn.getContext(), AttributesVec); } @@ -686,13 +684,9 @@ bool DeadArgumentEliminationPass::RemoveDeadStuffFromFunction(Function *F) { bool HasLiveReturnedArg = false; // Set up to build a new list of parameter attributes. - SmallVector<AttributeSetNode *, 8> AttributesVec; + SmallVector<AttributeList, 8> AttributesVec; const AttributeList &PAL = F->getAttributes(); - // Reserve an empty slot for the return value attributes, which we will - // compute last. - AttributesVec.push_back(nullptr); - // Remember which arguments are still alive. SmallVector<bool, 10> ArgAlive(FTy->getNumParams(), false); // Construct the new parameter list from non-dead arguments. Also construct @@ -705,8 +699,16 @@ bool DeadArgumentEliminationPass::RemoveDeadStuffFromFunction(Function *F) { if (LiveValues.erase(Arg)) { Params.push_back(I->getType()); ArgAlive[i] = true; - AttributesVec.push_back(PAL.getParamAttributes(i + 1)); - HasLiveReturnedArg |= PAL.hasAttribute(i + 1, Attribute::Returned); + + // Get the original parameter attributes (skipping the first one, that is + // for the return value. + if (PAL.hasAttributes(i + 1)) { + AttrBuilder B(PAL, i + 1); + if (B.contains(Attribute::Returned)) + HasLiveReturnedArg = true; + AttributesVec.push_back( + AttributeList::get(F->getContext(), Params.size(), B)); + } } else { ++NumArgumentsEliminated; DEBUG(dbgs() << "DeadArgumentEliminationPass - Removing argument " << i @@ -780,25 +782,29 @@ bool DeadArgumentEliminationPass::RemoveDeadStuffFromFunction(Function *F) { assert(NRetTy && "No new return type found?"); // The existing function return attributes. - AttrBuilder RAttrs(PAL.getRetAttributes()); + AttributeList RAttrs = PAL.getRetAttributes(); // Remove any incompatible attributes, but only if we removed all return // values. Otherwise, ensure that we don't have any conflicting attributes // here. Currently, this should not be possible, but special handling might be // required when new return value attributes are added. if (NRetTy->isVoidTy()) - RAttrs.remove(AttributeFuncs::typeIncompatible(NRetTy)); + RAttrs = RAttrs.removeAttributes(NRetTy->getContext(), + AttributeList::ReturnIndex, + AttributeFuncs::typeIncompatible(NRetTy)); else - assert(!RAttrs.overlaps(AttributeFuncs::typeIncompatible(NRetTy)) && + assert(!AttrBuilder(RAttrs, AttributeList::ReturnIndex) + .overlaps(AttributeFuncs::typeIncompatible(NRetTy)) && "Return attributes no longer compatible?"); - AttributesVec[0] = AttributeSetNode::get(F->getContext(), RAttrs); + if (RAttrs.hasAttributes(AttributeList::ReturnIndex)) + AttributesVec.push_back(AttributeList::get(NRetTy->getContext(), RAttrs)); - // Transfer the function attributes, if any. - AttributesVec.push_back(PAL.getFnAttributes()); + if (PAL.hasAttributes(AttributeList::FunctionIndex)) + AttributesVec.push_back( + AttributeList::get(F->getContext(), PAL.getFnAttributes())); // Reconstruct the AttributesList based on the vector we constructed. - assert(AttributesVec.size() == Params.size() + 2); AttributeList NewPAL = AttributeList::get(F->getContext(), AttributesVec); // Create the new function type based on the recomputed parameters. @@ -829,11 +835,15 @@ bool DeadArgumentEliminationPass::RemoveDeadStuffFromFunction(Function *F) { AttributesVec.clear(); const AttributeList &CallPAL = CS.getAttributes(); - // Adjust the call return attributes in case the function was changed to - // return void. - AttrBuilder RAttrs(CallPAL.getRetAttributes()); - RAttrs.remove(AttributeFuncs::typeIncompatible(NRetTy)); - AttributesVec.push_back(AttributeSetNode::get(F->getContext(), RAttrs)); + // The call return attributes. + AttributeList RAttrs = CallPAL.getRetAttributes(); + + // Adjust in case the function was changed to return void. + RAttrs = RAttrs.removeAttributes( + NRetTy->getContext(), AttributeList::ReturnIndex, + AttributeFuncs::typeIncompatible(NF->getReturnType())); + if (RAttrs.hasAttributes(AttributeList::ReturnIndex)) + AttributesVec.push_back(AttributeList::get(NF->getContext(), RAttrs)); // Declare these outside of the loops, so we can reuse them for the second // loop, which loops the varargs. @@ -845,30 +855,33 @@ bool DeadArgumentEliminationPass::RemoveDeadStuffFromFunction(Function *F) { if (ArgAlive[i]) { Args.push_back(*I); // Get original parameter attributes, but skip return attributes. - AttributeSetNode *Attrs = CallPAL.getParamAttributes(i + 1); - if (NRetTy != RetTy && Attrs && - Attrs->hasAttribute(Attribute::Returned)) { + if (CallPAL.hasAttributes(i + 1)) { + AttrBuilder B(CallPAL, i + 1); // If the return type has changed, then get rid of 'returned' on the // call site. The alternative is to make all 'returned' attributes on // call sites keep the return value alive just like 'returned' - // attributes on function declaration but it's less clearly a win and - // this is not an expected case anyway - AttributesVec.push_back(AttributeSetNode::get( - F->getContext(), - AttrBuilder(Attrs).removeAttribute(Attribute::Returned))); - } else { - // Otherwise, use the original attributes. - AttributesVec.push_back(Attrs); + // attributes on function declaration but it's less clearly a win + // and this is not an expected case anyway + if (NRetTy != RetTy && B.contains(Attribute::Returned)) + B.removeAttribute(Attribute::Returned); + AttributesVec.push_back( + AttributeList::get(F->getContext(), Args.size(), B)); } } // Push any varargs arguments on the list. Don't forget their attributes. for (CallSite::arg_iterator E = CS.arg_end(); I != E; ++I, ++i) { Args.push_back(*I); - AttributesVec.push_back(CallPAL.getParamAttributes(i + 1)); + if (CallPAL.hasAttributes(i + 1)) { + AttrBuilder B(CallPAL, i + 1); + AttributesVec.push_back( + AttributeList::get(F->getContext(), Args.size(), B)); + } } - AttributesVec.push_back(CallPAL.getFnAttributes()); + if (CallPAL.hasAttributes(AttributeList::FunctionIndex)) + AttributesVec.push_back( + AttributeList::get(Call->getContext(), CallPAL.getFnAttributes())); // Reconstruct the AttributesList based on the vector we constructed. AttributeList NewCallPAL = diff --git a/llvm/lib/Transforms/IPO/MergeFunctions.cpp b/llvm/lib/Transforms/IPO/MergeFunctions.cpp index 5d41ca9f9fc..dc7390232c5 100644 --- a/llvm/lib/Transforms/IPO/MergeFunctions.cpp +++ b/llvm/lib/Transforms/IPO/MergeFunctions.cpp @@ -439,7 +439,8 @@ void MergeFunctions::replaceDirectCallers(Function *Old, Function *New) { Context, AttributeList::ReturnIndex, NewFuncAttrs.getRetAttributes()); for (unsigned argIdx = 0; argIdx < CS.arg_size(); argIdx++) { - if (AttributeSetNode *Attrs = NewFuncAttrs.getParamAttributes(argIdx)) + AttributeList Attrs = NewFuncAttrs.getParamAttributes(argIdx); + if (Attrs.getNumSlots()) CallSiteAttrs = CallSiteAttrs.addAttributes(Context, argIdx, Attrs); } diff --git a/llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp b/llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp index c850e2e7393..af4c9ac7537 100644 --- a/llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp +++ b/llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp @@ -23,7 +23,6 @@ #include "llvm/Analysis/InstructionSimplify.h" #include "llvm/Analysis/MemoryBuiltins.h" #include "llvm/Analysis/ValueTracking.h" -#include "llvm/IR/AttributeSetNode.h" #include "llvm/IR/BasicBlock.h" #include "llvm/IR/CallSite.h" #include "llvm/IR/Constant.h" @@ -3993,7 +3992,7 @@ bool InstCombiner::transformConstExprCastCall(CallSite CS) { if (!CastInst::isBitOrNoopPointerCastable(ActTy, ParamTy, DL)) return false; // Cannot transform this parameter value. - if (AttrBuilder(CallerPAL.getParamAttributes(i + 1)). + if (AttrBuilder(CallerPAL.getParamAttributes(i + 1), i + 1). overlaps(AttributeFuncs::typeIncompatible(ParamTy))) return false; // Attribute not compatible with transformed value. @@ -4002,7 +4001,9 @@ bool InstCombiner::transformConstExprCastCall(CallSite CS) { // 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.hasAttribute(i + 1, Attribute::ByVal)) { + if (ParamTy != ActTy && + CallerPAL.getParamAttributes(i + 1).hasAttribute(i + 1, + Attribute::ByVal)) { PointerType *ParamPTy = dyn_cast<PointerType>(ParamTy); if (!ParamPTy || !ParamPTy->getElementType()->isSized()) return false; @@ -4083,7 +4084,7 @@ bool InstCombiner::transformConstExprCastCall(CallSite CS) { } // Add any parameter attributes. - AttrBuilder PAttrs(CallerPAL.getParamAttributes(i + 1)); + AttrBuilder PAttrs(CallerPAL.getParamAttributes(i + 1), i + 1); if (PAttrs.hasAttributes()) attrVec.push_back( AttributeList::get(Caller->getContext(), i + 1, PAttrs)); @@ -4111,7 +4112,7 @@ bool InstCombiner::transformConstExprCastCall(CallSite CS) { } // Add any parameter attributes. - AttrBuilder PAttrs(CallerPAL.getParamAttributes(i + 1)); + AttrBuilder PAttrs(CallerPAL.getParamAttributes(i + 1), i + 1); if (PAttrs.hasAttributes()) attrVec.push_back( AttributeList::get(FT->getContext(), i + 1, PAttrs)); @@ -4119,11 +4120,9 @@ bool InstCombiner::transformConstExprCastCall(CallSite CS) { } } - AttributeSetNode *FnAttrs = CallerPAL.getFnAttributes(); + AttributeList FnAttrs = CallerPAL.getFnAttributes(); if (CallerPAL.hasAttributes(AttributeList::FunctionIndex)) - attrVec.push_back(AttributeList::get(Callee->getContext(), - AttributeList::FunctionIndex, - AttrBuilder(FnAttrs))); + attrVec.push_back(AttributeList::get(Callee->getContext(), FnAttrs)); if (NewRetTy->isVoidTy()) Caller->setName(""); // Void type should not have a name. @@ -4201,7 +4200,7 @@ InstCombiner::transformCallThroughTrampoline(CallSite CS, Value *Callee = CS.getCalledValue(); PointerType *PTy = cast<PointerType>(Callee->getType()); FunctionType *FTy = cast<FunctionType>(PTy->getElementType()); - AttributeList Attrs = CS.getAttributes(); + const AttributeList &Attrs = CS.getAttributes(); // If the call already has the 'nest' attribute somewhere then give up - // otherwise 'nest' would occur twice after splicing in the chain. @@ -4214,11 +4213,11 @@ InstCombiner::transformCallThroughTrampoline(CallSite CS, Function *NestF =cast<Function>(Tramp->getArgOperand(1)->stripPointerCasts()); FunctionType *NestFTy = cast<FunctionType>(NestF->getValueType()); - AttributeList NestAttrs = NestF->getAttributes(); + const AttributeList &NestAttrs = NestF->getAttributes(); if (!NestAttrs.isEmpty()) { unsigned NestIdx = 1; Type *NestTy = nullptr; - AttributeSetNode *NestAttr; + AttributeList NestAttr; // Look for a parameter marked with the 'nest' attribute. for (FunctionType::param_iterator I = NestFTy->param_begin(), @@ -4233,15 +4232,18 @@ InstCombiner::transformCallThroughTrampoline(CallSite CS, if (NestTy) { Instruction *Caller = CS.getInstruction(); std::vector<Value*> NewArgs; - std::vector<AttributeSetNode *> NewAttrs; NewArgs.reserve(CS.arg_size() + 1); - NewAttrs.reserve(CS.arg_size() + 2); + + SmallVector<AttributeList, 8> NewAttrs; + NewAttrs.reserve(Attrs.getNumSlots() + 1); // Insert the nest argument into the call argument list, which may // mean appending it. Likewise for attributes. // Add any result attributes. - NewAttrs.push_back(Attrs.getRetAttributes()); + if (Attrs.hasAttributes(AttributeList::ReturnIndex)) + NewAttrs.push_back( + AttributeList::get(Caller->getContext(), Attrs.getRetAttributes())); { unsigned Idx = 1; @@ -4253,7 +4255,8 @@ InstCombiner::transformCallThroughTrampoline(CallSite CS, if (NestVal->getType() != NestTy) NestVal = Builder->CreateBitCast(NestVal, NestTy, "nest"); NewArgs.push_back(NestVal); - NewAttrs.push_back(NestAttr); + NewAttrs.push_back( + AttributeList::get(Caller->getContext(), NestAttr)); } if (I == E) @@ -4261,7 +4264,12 @@ InstCombiner::transformCallThroughTrampoline(CallSite CS, // Add the original argument and attributes. NewArgs.push_back(*I); - NewAttrs.push_back(Attrs.getParamAttributes(Idx)); + AttributeList Attr = Attrs.getParamAttributes(Idx); + if (Attr.hasAttributes(Idx)) { + AttrBuilder B(Attr, Idx); + NewAttrs.push_back(AttributeList::get(Caller->getContext(), + Idx + (Idx >= NestIdx), B)); + } ++Idx; ++I; @@ -4269,7 +4277,9 @@ InstCombiner::transformCallThroughTrampoline(CallSite CS, } // Add any function attributes. - NewAttrs.push_back(Attrs.getFnAttributes()); + if (Attrs.hasAttributes(AttributeList::FunctionIndex)) + NewAttrs.push_back( + AttributeList::get(FTy->getContext(), Attrs.getFnAttributes())); // The trampoline may have been bitcast to a bogus type (FTy). // Handle this by synthesizing a new function type, equal to FTy @@ -4309,7 +4319,8 @@ InstCombiner::transformCallThroughTrampoline(CallSite CS, NestF->getType() == PointerType::getUnqual(NewFTy) ? NestF : ConstantExpr::getBitCast(NestF, PointerType::getUnqual(NewFTy)); - AttributeList NewPAL = AttributeList::get(FTy->getContext(), NewAttrs); + const AttributeList &NewPAL = + AttributeList::get(FTy->getContext(), NewAttrs); SmallVector<OperandBundleDef, 1> OpBundles; CS.getOperandBundlesAsDefs(OpBundles); diff --git a/llvm/lib/Transforms/Scalar/RewriteStatepointsForGC.cpp b/llvm/lib/Transforms/Scalar/RewriteStatepointsForGC.cpp index 84f76b6d1b5..95e598a17b1 100644 --- a/llvm/lib/Transforms/Scalar/RewriteStatepointsForGC.cpp +++ b/llvm/lib/Transforms/Scalar/RewriteStatepointsForGC.cpp @@ -1392,6 +1392,7 @@ makeStatepointExplicitImpl(const CallSite CS, /* to replace */ // Create the statepoint given all the arguments Instruction *Token = nullptr; + AttributeList ReturnAttrs; if (CS.isCall()) { CallInst *ToReplace = cast<CallInst>(CS.getInstruction()); CallInst *Call = Builder.CreateGCStatepointCall( @@ -1406,9 +1407,8 @@ makeStatepointExplicitImpl(const CallSite CS, /* to replace */ AttributeList NewAttrs = legalizeCallAttributes(ToReplace->getAttributes()); // In case if we can handle this set of attributes - set up function attrs // directly on statepoint and return attrs later for gc_result intrinsic. - Call->setAttributes(AttributeList::get(Call->getContext(), - AttributeList::FunctionIndex, - NewAttrs.getFnAttributes())); + Call->setAttributes(NewAttrs.getFnAttributes()); + ReturnAttrs = NewAttrs.getRetAttributes(); Token = Call; @@ -1435,9 +1435,8 @@ makeStatepointExplicitImpl(const CallSite CS, /* to replace */ AttributeList NewAttrs = legalizeCallAttributes(ToReplace->getAttributes()); // In case if we can handle this set of attributes - set up function attrs // directly on statepoint and return attrs later for gc_result intrinsic. - Invoke->setAttributes(AttributeList::get(Invoke->getContext(), - AttributeList::FunctionIndex, - NewAttrs.getFnAttributes())); + Invoke->setAttributes(NewAttrs.getFnAttributes()); + ReturnAttrs = NewAttrs.getRetAttributes(); Token = Invoke; @@ -1483,9 +1482,7 @@ makeStatepointExplicitImpl(const CallSite CS, /* to replace */ StringRef Name = CS.getInstruction()->hasName() ? CS.getInstruction()->getName() : ""; CallInst *GCResult = Builder.CreateGCResult(Token, CS.getType(), Name); - GCResult->setAttributes( - AttributeList::get(GCResult->getContext(), AttributeList::ReturnIndex, - CS.getAttributes().getRetAttributes())); + GCResult->setAttributes(CS.getAttributes().getRetAttributes()); // We cannot RAUW or delete CS.getInstruction() because it could be in the // live set of some other safepoint, in which case that safepoint's diff --git a/llvm/lib/Transforms/Utils/CloneFunction.cpp b/llvm/lib/Transforms/Utils/CloneFunction.cpp index f4803028f3c..60b988e880b 100644 --- a/llvm/lib/Transforms/Utils/CloneFunction.cpp +++ b/llvm/lib/Transforms/Utils/CloneFunction.cpp @@ -103,25 +103,21 @@ void llvm::CloneFunctionInto(Function *NewFunc, const Function *OldFunc, ModuleLevelChanges ? RF_None : RF_NoModuleLevelChanges, TypeMapper, Materializer)); - SmallVector<std::pair<unsigned, AttributeSetNode*>, 4> AttrVec; AttributeList OldAttrs = OldFunc->getAttributes(); - - // Copy the return attributes. - if (auto *RetAttrs = OldAttrs.getRetAttributes()) - AttrVec.emplace_back(AttributeList::ReturnIndex, RetAttrs); - // Clone any argument attributes that are present in the VMap. for (const Argument &OldArg : OldFunc->args()) if (Argument *NewArg = dyn_cast<Argument>(VMap[&OldArg])) { - if (auto *ParmAttrs = OldAttrs.getParamAttributes(OldArg.getArgNo() + 1)) - AttrVec.emplace_back(NewArg->getArgNo() + 1, ParmAttrs); + AttributeList attrs = OldAttrs.getParamAttributes(OldArg.getArgNo() + 1); + if (attrs.getNumSlots() > 0) + NewArg->addAttr(attrs); } - // Copy any function attributes. - if (auto *FnAttrs = OldAttrs.getFnAttributes()) - AttrVec.emplace_back(AttributeList::FunctionIndex, FnAttrs); - - NewFunc->setAttributes(AttributeList::get(NewFunc->getContext(), AttrVec)); + NewFunc->setAttributes( + NewFunc->getAttributes() + .addAttributes(NewFunc->getContext(), AttributeList::ReturnIndex, + OldAttrs.getRetAttributes()) + .addAttributes(NewFunc->getContext(), AttributeList::FunctionIndex, + OldAttrs.getFnAttributes())); SmallVector<std::pair<unsigned, MDNode *>, 1> MDs; OldFunc->getAllMetadata(MDs); diff --git a/llvm/lib/Transforms/Utils/CodeExtractor.cpp b/llvm/lib/Transforms/Utils/CodeExtractor.cpp index 3bc33d0c666..755427cace2 100644 --- a/llvm/lib/Transforms/Utils/CodeExtractor.cpp +++ b/llvm/lib/Transforms/Utils/CodeExtractor.cpp @@ -362,7 +362,8 @@ Function *CodeExtractor::constructFunction(const ValueSet &inputs, // "target-features" attribute allowing it to be lowered. // FIXME: This should be changed to check to see if a specific // attribute can not be inherited. - AttrBuilder AB(oldFunction->getAttributes().getFnAttributes()); + AttributeList OldFnAttrs = oldFunction->getAttributes().getFnAttributes(); + AttrBuilder AB(OldFnAttrs, AttributeList::FunctionIndex); for (const auto &Attr : AB.td_attrs()) newFunction->addFnAttr(Attr.first, Attr.second); |
