Reland "[IR] Make AttributeSetNode public, avoid temporary AttributeList copies"
This re-lands r299875.
I introduced a bug in Clang code responsible for replacing K&R, no
prototype declarations with a real function definition with a prototype.
The bug was here:
// Collect any return attributes from the call.
- if (oldAttrs.hasAttributes(llvm::AttributeList::ReturnIndex))
- newAttrs.push_back(llvm::AttributeList::get(newFn->getContext(),
- oldAttrs.getRetAttributes()));
+ newAttrs.push_back(oldAttrs.getRetAttributes());
Previously getRetAttributes() carried AttributeList::ReturnIndex in its
AttributeList. Now that we return the AttributeSetNode* directly, it no
longer carries that index, and we call this overload with a single node:
AttributeList::get(LLVMContext&, ArrayRef<AttributeSetNode*>)
That aborted with an assertion on x86_32 targets. I added an explicit
triple to the test and added CHECKs to help find issues like this in the
future sooner.
llvm-svn: 299899
diff --git a/llvm/lib/Transforms/IPO/ArgumentPromotion.cpp b/llvm/lib/Transforms/IPO/ArgumentPromotion.cpp
index b7fe2d6f..1646237 100644
--- a/llvm/lib/Transforms/IPO/ArgumentPromotion.cpp
+++ b/llvm/lib/Transforms/IPO/ArgumentPromotion.cpp
@@ -42,6 +42,7 @@
#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"
@@ -102,13 +103,11 @@
// 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<AttributeList, 8> AttributesVec;
+ SmallVector<AttributeSetNode *, 8> AttributesVec;
const AttributeList &PAL = F->getAttributes();
// Add any return attributes.
- if (PAL.hasAttributes(AttributeList::ReturnIndex))
- AttributesVec.push_back(
- AttributeList::get(F->getContext(), PAL.getRetAttributes()));
+ AttributesVec.push_back(PAL.getRetAttributes());
// First, determine the new argument list
unsigned ArgIndex = 1;
@@ -119,16 +118,12 @@
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());
- AttributeList attrs = PAL.getParamAttributes(ArgIndex);
- if (attrs.hasAttributes(ArgIndex)) {
- AttrBuilder B(attrs, ArgIndex);
- AttributesVec.push_back(
- AttributeList::get(F->getContext(), Params.size(), B));
- }
+ AttributesVec.push_back(PAL.getParamAttributes(ArgIndex));
} else if (I->use_empty()) {
// Dead argument (which are always marked as promotable)
++NumArgumentsDead;
@@ -173,6 +168,7 @@
Params.push_back(GetElementPtrInst::getIndexedType(
cast<PointerType>(I->getType()->getScalarType())->getElementType(),
ArgIndex.second));
+ AttributesVec.push_back(nullptr);
assert(Params.back());
}
@@ -184,9 +180,7 @@
}
// Add any function attributes.
- if (PAL.hasAttributes(AttributeList::FunctionIndex))
- AttributesVec.push_back(
- AttributeList::get(FTy->getContext(), PAL.getFnAttributes()));
+ AttributesVec.push_back(PAL.getFnAttributes());
Type *RetTy = FTy->getReturnType();
@@ -223,9 +217,7 @@
const AttributeList &CallPAL = CS.getAttributes();
// Add any return attributes.
- if (CallPAL.hasAttributes(AttributeList::ReturnIndex))
- AttributesVec.push_back(
- AttributeList::get(F->getContext(), CallPAL.getRetAttributes()));
+ AttributesVec.push_back(CallPAL.getRetAttributes());
// Loop over the operands, inserting GEP and loads in the caller as
// appropriate.
@@ -235,12 +227,7 @@
++I, ++AI, ++ArgIndex)
if (!ArgsToPromote.count(&*I) && !ByValArgsToTransform.count(&*I)) {
Args.push_back(*AI); // Unmodified argument
-
- if (CallPAL.hasAttributes(ArgIndex)) {
- AttrBuilder B(CallPAL, ArgIndex);
- AttributesVec.push_back(
- AttributeList::get(F->getContext(), Args.size(), B));
- }
+ AttributesVec.push_back(CallPAL.getAttributes(ArgIndex));
} else if (ByValArgsToTransform.count(&*I)) {
// Emit a GEP and load for each element of the struct.
Type *AgTy = cast<PointerType>(I->getType())->getElementType();
@@ -253,6 +240,7 @@
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.
@@ -295,23 +283,18 @@
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);
- if (CallPAL.hasAttributes(ArgIndex)) {
- AttrBuilder B(CallPAL, ArgIndex);
- AttributesVec.push_back(
- AttributeList::get(F->getContext(), Args.size(), B));
- }
+ AttributesVec.push_back(CallPAL.getAttributes(ArgIndex));
}
// Add any function attributes.
- if (CallPAL.hasAttributes(AttributeList::FunctionIndex))
- AttributesVec.push_back(
- AttributeList::get(Call->getContext(), CallPAL.getFnAttributes()));
+ AttributesVec.push_back(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 fe79efc..c7138bf 100644
--- a/llvm/lib/Transforms/IPO/DeadArgumentElimination.cpp
+++ b/llvm/lib/Transforms/IPO/DeadArgumentElimination.cpp
@@ -21,6 +21,7 @@
#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"
@@ -172,8 +173,9 @@
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(), PAL.getFnAttributes()));
+ AttributesVec.push_back(AttributeList::get(Fn.getContext(),
+ AttributeList::FunctionIndex,
+ PAL.getFnAttributes()));
PAL = AttributeList::get(Fn.getContext(), AttributesVec);
}
@@ -684,9 +686,13 @@
bool HasLiveReturnedArg = false;
// Set up to build a new list of parameter attributes.
- SmallVector<AttributeList, 8> AttributesVec;
+ SmallVector<AttributeSetNode *, 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
@@ -699,16 +705,8 @@
if (LiveValues.erase(Arg)) {
Params.push_back(I->getType());
ArgAlive[i] = true;
-
- // 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));
- }
+ AttributesVec.push_back(PAL.getParamAttributes(i + 1));
+ HasLiveReturnedArg |= PAL.hasAttribute(i + 1, Attribute::Returned);
} else {
++NumArgumentsEliminated;
DEBUG(dbgs() << "DeadArgumentEliminationPass - Removing argument " << i
@@ -782,29 +780,25 @@
assert(NRetTy && "No new return type found?");
// The existing function return attributes.
- AttributeList RAttrs = PAL.getRetAttributes();
+ AttrBuilder 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 = RAttrs.removeAttributes(NRetTy->getContext(),
- AttributeList::ReturnIndex,
- AttributeFuncs::typeIncompatible(NRetTy));
+ RAttrs.remove(AttributeFuncs::typeIncompatible(NRetTy));
else
- assert(!AttrBuilder(RAttrs, AttributeList::ReturnIndex)
- .overlaps(AttributeFuncs::typeIncompatible(NRetTy)) &&
+ assert(!RAttrs.overlaps(AttributeFuncs::typeIncompatible(NRetTy)) &&
"Return attributes no longer compatible?");
- if (RAttrs.hasAttributes(AttributeList::ReturnIndex))
- AttributesVec.push_back(AttributeList::get(NRetTy->getContext(), RAttrs));
+ AttributesVec[0] = AttributeSetNode::get(F->getContext(), RAttrs);
- if (PAL.hasAttributes(AttributeList::FunctionIndex))
- AttributesVec.push_back(
- AttributeList::get(F->getContext(), PAL.getFnAttributes()));
+ // Transfer the function attributes, if any.
+ AttributesVec.push_back(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.
@@ -835,15 +829,11 @@
AttributesVec.clear();
const AttributeList &CallPAL = CS.getAttributes();
- // 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));
+ // 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));
// Declare these outside of the loops, so we can reuse them for the second
// loop, which loops the varargs.
@@ -855,33 +845,30 @@
if (ArgAlive[i]) {
Args.push_back(*I);
// Get original parameter attributes, but skip return attributes.
- if (CallPAL.hasAttributes(i + 1)) {
- AttrBuilder B(CallPAL, i + 1);
+ AttributeSetNode *Attrs = CallPAL.getParamAttributes(i + 1);
+ if (NRetTy != RetTy && Attrs &&
+ Attrs->hasAttribute(Attribute::Returned)) {
// 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
- if (NRetTy != RetTy && B.contains(Attribute::Returned))
- B.removeAttribute(Attribute::Returned);
- AttributesVec.push_back(
- AttributeList::get(F->getContext(), Args.size(), B));
+ // 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);
}
}
// 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);
- if (CallPAL.hasAttributes(i + 1)) {
- AttrBuilder B(CallPAL, i + 1);
- AttributesVec.push_back(
- AttributeList::get(F->getContext(), Args.size(), B));
- }
+ AttributesVec.push_back(CallPAL.getParamAttributes(i + 1));
}
- if (CallPAL.hasAttributes(AttributeList::FunctionIndex))
- AttributesVec.push_back(
- AttributeList::get(Call->getContext(), CallPAL.getFnAttributes()));
+ AttributesVec.push_back(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 dc73902..5d41ca9 100644
--- a/llvm/lib/Transforms/IPO/MergeFunctions.cpp
+++ b/llvm/lib/Transforms/IPO/MergeFunctions.cpp
@@ -439,8 +439,7 @@
Context, AttributeList::ReturnIndex, NewFuncAttrs.getRetAttributes());
for (unsigned argIdx = 0; argIdx < CS.arg_size(); argIdx++) {
- AttributeList Attrs = NewFuncAttrs.getParamAttributes(argIdx);
- if (Attrs.getNumSlots())
+ if (AttributeSetNode *Attrs = NewFuncAttrs.getParamAttributes(argIdx))
CallSiteAttrs = CallSiteAttrs.addAttributes(Context, argIdx, Attrs);
}
diff --git a/llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp b/llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp
index af4c9ac..c850e2e 100644
--- a/llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp
+++ b/llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp
@@ -23,6 +23,7 @@
#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"
@@ -3992,7 +3993,7 @@
if (!CastInst::isBitOrNoopPointerCastable(ActTy, ParamTy, DL))
return false; // Cannot transform this parameter value.
- if (AttrBuilder(CallerPAL.getParamAttributes(i + 1), i + 1).
+ if (AttrBuilder(CallerPAL.getParamAttributes(i + 1)).
overlaps(AttributeFuncs::typeIncompatible(ParamTy)))
return false; // Attribute not compatible with transformed value.
@@ -4001,9 +4002,7 @@
// 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.getParamAttributes(i + 1).hasAttribute(i + 1,
- Attribute::ByVal)) {
+ if (ParamTy != ActTy && CallerPAL.hasAttribute(i + 1, Attribute::ByVal)) {
PointerType *ParamPTy = dyn_cast<PointerType>(ParamTy);
if (!ParamPTy || !ParamPTy->getElementType()->isSized())
return false;
@@ -4084,7 +4083,7 @@
}
// Add any parameter attributes.
- AttrBuilder PAttrs(CallerPAL.getParamAttributes(i + 1), i + 1);
+ AttrBuilder PAttrs(CallerPAL.getParamAttributes(i + 1));
if (PAttrs.hasAttributes())
attrVec.push_back(
AttributeList::get(Caller->getContext(), i + 1, PAttrs));
@@ -4112,7 +4111,7 @@
}
// Add any parameter attributes.
- AttrBuilder PAttrs(CallerPAL.getParamAttributes(i + 1), i + 1);
+ AttrBuilder PAttrs(CallerPAL.getParamAttributes(i + 1));
if (PAttrs.hasAttributes())
attrVec.push_back(
AttributeList::get(FT->getContext(), i + 1, PAttrs));
@@ -4120,9 +4119,11 @@
}
}
- AttributeList FnAttrs = CallerPAL.getFnAttributes();
+ AttributeSetNode *FnAttrs = CallerPAL.getFnAttributes();
if (CallerPAL.hasAttributes(AttributeList::FunctionIndex))
- attrVec.push_back(AttributeList::get(Callee->getContext(), FnAttrs));
+ attrVec.push_back(AttributeList::get(Callee->getContext(),
+ AttributeList::FunctionIndex,
+ AttrBuilder(FnAttrs)));
if (NewRetTy->isVoidTy())
Caller->setName(""); // Void type should not have a name.
@@ -4200,7 +4201,7 @@
Value *Callee = CS.getCalledValue();
PointerType *PTy = cast<PointerType>(Callee->getType());
FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
- const AttributeList &Attrs = CS.getAttributes();
+ 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.
@@ -4213,11 +4214,11 @@
Function *NestF =cast<Function>(Tramp->getArgOperand(1)->stripPointerCasts());
FunctionType *NestFTy = cast<FunctionType>(NestF->getValueType());
- const AttributeList &NestAttrs = NestF->getAttributes();
+ AttributeList NestAttrs = NestF->getAttributes();
if (!NestAttrs.isEmpty()) {
unsigned NestIdx = 1;
Type *NestTy = nullptr;
- AttributeList NestAttr;
+ AttributeSetNode *NestAttr;
// Look for a parameter marked with the 'nest' attribute.
for (FunctionType::param_iterator I = NestFTy->param_begin(),
@@ -4232,18 +4233,15 @@
if (NestTy) {
Instruction *Caller = CS.getInstruction();
std::vector<Value*> NewArgs;
+ std::vector<AttributeSetNode *> NewAttrs;
NewArgs.reserve(CS.arg_size() + 1);
-
- SmallVector<AttributeList, 8> NewAttrs;
- NewAttrs.reserve(Attrs.getNumSlots() + 1);
+ NewAttrs.reserve(CS.arg_size() + 2);
// Insert the nest argument into the call argument list, which may
// mean appending it. Likewise for attributes.
// Add any result attributes.
- if (Attrs.hasAttributes(AttributeList::ReturnIndex))
- NewAttrs.push_back(
- AttributeList::get(Caller->getContext(), Attrs.getRetAttributes()));
+ NewAttrs.push_back(Attrs.getRetAttributes());
{
unsigned Idx = 1;
@@ -4255,8 +4253,7 @@
if (NestVal->getType() != NestTy)
NestVal = Builder->CreateBitCast(NestVal, NestTy, "nest");
NewArgs.push_back(NestVal);
- NewAttrs.push_back(
- AttributeList::get(Caller->getContext(), NestAttr));
+ NewAttrs.push_back(NestAttr);
}
if (I == E)
@@ -4264,12 +4261,7 @@
// Add the original argument and attributes.
NewArgs.push_back(*I);
- AttributeList Attr = Attrs.getParamAttributes(Idx);
- if (Attr.hasAttributes(Idx)) {
- AttrBuilder B(Attr, Idx);
- NewAttrs.push_back(AttributeList::get(Caller->getContext(),
- Idx + (Idx >= NestIdx), B));
- }
+ NewAttrs.push_back(Attrs.getParamAttributes(Idx));
++Idx;
++I;
@@ -4277,9 +4269,7 @@
}
// Add any function attributes.
- if (Attrs.hasAttributes(AttributeList::FunctionIndex))
- NewAttrs.push_back(
- AttributeList::get(FTy->getContext(), Attrs.getFnAttributes()));
+ NewAttrs.push_back(Attrs.getFnAttributes());
// The trampoline may have been bitcast to a bogus type (FTy).
// Handle this by synthesizing a new function type, equal to FTy
@@ -4319,8 +4309,7 @@
NestF->getType() == PointerType::getUnqual(NewFTy) ?
NestF : ConstantExpr::getBitCast(NestF,
PointerType::getUnqual(NewFTy));
- const AttributeList &NewPAL =
- AttributeList::get(FTy->getContext(), NewAttrs);
+ 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 e87edc8..7223370 100644
--- a/llvm/lib/Transforms/Scalar/RewriteStatepointsForGC.cpp
+++ b/llvm/lib/Transforms/Scalar/RewriteStatepointsForGC.cpp
@@ -1392,7 +1392,6 @@
// 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(
@@ -1407,8 +1406,9 @@
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(NewAttrs.getFnAttributes());
- ReturnAttrs = NewAttrs.getRetAttributes();
+ Call->setAttributes(AttributeList::get(Call->getContext(),
+ AttributeList::FunctionIndex,
+ NewAttrs.getFnAttributes()));
Token = Call;
@@ -1435,8 +1435,9 @@
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(NewAttrs.getFnAttributes());
- ReturnAttrs = NewAttrs.getRetAttributes();
+ Invoke->setAttributes(AttributeList::get(Invoke->getContext(),
+ AttributeList::FunctionIndex,
+ NewAttrs.getFnAttributes()));
Token = Invoke;
@@ -1482,7 +1483,9 @@
StringRef Name =
CS.getInstruction()->hasName() ? CS.getInstruction()->getName() : "";
CallInst *GCResult = Builder.CreateGCResult(Token, CS.getType(), Name);
- GCResult->setAttributes(CS.getAttributes().getRetAttributes());
+ GCResult->setAttributes(
+ AttributeList::get(GCResult->getContext(), AttributeList::ReturnIndex,
+ 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 60b988e..f480302 100644
--- a/llvm/lib/Transforms/Utils/CloneFunction.cpp
+++ b/llvm/lib/Transforms/Utils/CloneFunction.cpp
@@ -103,21 +103,25 @@
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])) {
- AttributeList attrs = OldAttrs.getParamAttributes(OldArg.getArgNo() + 1);
- if (attrs.getNumSlots() > 0)
- NewArg->addAttr(attrs);
+ if (auto *ParmAttrs = OldAttrs.getParamAttributes(OldArg.getArgNo() + 1))
+ AttrVec.emplace_back(NewArg->getArgNo() + 1, ParmAttrs);
}
- NewFunc->setAttributes(
- NewFunc->getAttributes()
- .addAttributes(NewFunc->getContext(), AttributeList::ReturnIndex,
- OldAttrs.getRetAttributes())
- .addAttributes(NewFunc->getContext(), AttributeList::FunctionIndex,
- OldAttrs.getFnAttributes()));
+ // Copy any function attributes.
+ if (auto *FnAttrs = OldAttrs.getFnAttributes())
+ AttrVec.emplace_back(AttributeList::FunctionIndex, FnAttrs);
+
+ NewFunc->setAttributes(AttributeList::get(NewFunc->getContext(), AttrVec));
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 a7f7993..644d93b 100644
--- a/llvm/lib/Transforms/Utils/CodeExtractor.cpp
+++ b/llvm/lib/Transforms/Utils/CodeExtractor.cpp
@@ -362,8 +362,7 @@
// "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.
- AttributeList OldFnAttrs = oldFunction->getAttributes().getFnAttributes();
- AttrBuilder AB(OldFnAttrs, AttributeList::FunctionIndex);
+ AttrBuilder AB(oldFunction->getAttributes().getFnAttributes());
for (const auto &Attr : AB.td_attrs())
newFunction->addFnAttr(Attr.first, Attr.second);