From 28d65722d6f283b327b5815914382077fe9c0ab4 Mon Sep 17 00:00:00 2001 From: Bill Wendling Date: Wed, 23 Jan 2013 06:14:59 +0000 Subject: [PATCH] Remove the last of uses that use the Attribute object as a collection of attributes. Collections of attributes are handled via the AttributeSet class now. This finally frees us up to make significant changes to how attributes are structured. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@173228 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/IR/Argument.h | 4 +-- include/llvm/IR/Attributes.h | 6 ++-- lib/IR/Attributes.cpp | 13 +++++++ lib/IR/Core.cpp | 8 ++--- lib/IR/Function.cpp | 19 ++++------- lib/Transforms/IPO/ArgumentPromotion.cpp | 29 ++++++++++------ .../IPO/DeadArgumentElimination.cpp | 27 ++++++++++----- lib/Transforms/IPO/FunctionAttrs.cpp | 10 +++--- .../InstCombine/InstCombineCalls.cpp | 34 ++++++++++++------- lib/Transforms/Utils/CloneFunction.cpp | 2 +- 10 files changed, 93 insertions(+), 59 deletions(-) diff --git a/include/llvm/IR/Argument.h b/include/llvm/IR/Argument.h index b8bc083e063..ef4e4fc7aa6 100644 --- a/include/llvm/IR/Argument.h +++ b/include/llvm/IR/Argument.h @@ -79,10 +79,10 @@ public: bool hasStructRetAttr() const; /// \brief Add a Attribute to an argument. - void addAttr(Attribute); + void addAttr(AttributeSet AS); /// \brief Remove a Attribute from an argument. - void removeAttr(Attribute); + void removeAttr(AttributeSet AS); /// \brief Method for support type inquiry through isa, cast, and /// dyn_cast. diff --git a/include/llvm/IR/Attributes.h b/include/llvm/IR/Attributes.h index ab989106295..de214d17c6d 100644 --- a/include/llvm/IR/Attributes.h +++ b/include/llvm/IR/Attributes.h @@ -234,6 +234,8 @@ public: /// \brief Return an AttributeSet with the specified parameters in it. static AttributeSet get(LLVMContext &C, ArrayRef Attrs); + static AttributeSet get(LLVMContext &C, unsigned Idx, + Attribute::AttrKind Kind); static AttributeSet get(LLVMContext &C, unsigned Idx, AttrBuilder &B); /// \brief Add an attribute to the attribute set at the given index. Since @@ -275,9 +277,7 @@ public: //===--------------------------------------------------------------------===// /// \brief The attributes for the specified index are returned. - Attribute getParamAttributes(unsigned Idx) const { - return getAttributes(Idx); - } + AttributeSet getParamAttributes(unsigned Idx) const; /// \brief The attributes for the ret value are returned. AttributeSet getRetAttributes() const; diff --git a/lib/IR/Attributes.cpp b/lib/IR/Attributes.cpp index a3abd36fc0d..4bd2391dfdb 100644 --- a/lib/IR/Attributes.cpp +++ b/lib/IR/Attributes.cpp @@ -541,6 +541,14 @@ AttributeWithIndex AttributeWithIndex::get(LLVMContext &C, unsigned Idx, // AttributeSetImpl Definition //===----------------------------------------------------------------------===// +AttributeSet AttributeSet::getParamAttributes(unsigned Idx) const { + // FIXME: Remove. + return AttrList && hasAttributes(Idx) ? + AttributeSet::get(AttrList->getContext(), + AttributeWithIndex::get(Idx, getAttributes(Idx))) : + AttributeSet(); +} + AttributeSet AttributeSet::getRetAttributes() const { // FIXME: Remove. return AttrList && hasAttributes(ReturnIndex) ? @@ -601,6 +609,11 @@ AttributeSet AttributeSet::get(LLVMContext &C, unsigned Idx, AttrBuilder &B) { return get(C, AttributeWithIndex::get(Idx, Attribute::get(C, B))); } +AttributeSet AttributeSet::get(LLVMContext &C, unsigned Idx, + Attribute::AttrKind Kind) { + return get(C, AttributeWithIndex::get(Idx, Attribute::get(C, Kind))); +} + //===----------------------------------------------------------------------===// // AttributeSet Method Implementations //===----------------------------------------------------------------------===// diff --git a/lib/IR/Core.cpp b/lib/IR/Core.cpp index 0e425367897..1e3258f6aa1 100644 --- a/lib/IR/Core.cpp +++ b/lib/IR/Core.cpp @@ -1467,13 +1467,13 @@ LLVMValueRef LLVMGetPreviousParam(LLVMValueRef Arg) { void LLVMAddAttribute(LLVMValueRef Arg, LLVMAttribute PA) { Argument *A = unwrap(Arg); AttrBuilder B(PA); - A->addAttr(Attribute::get(A->getContext(), B)); + A->addAttr(AttributeSet::get(A->getContext(), A->getArgNo() + 1, B)); } void LLVMRemoveAttribute(LLVMValueRef Arg, LLVMAttribute PA) { Argument *A = unwrap(Arg); AttrBuilder B(PA); - A->removeAttr(Attribute::get(A->getContext(), B)); + A->removeAttr(AttributeSet::get(A->getContext(), A->getArgNo() + 1, B)); } LLVMAttribute LLVMGetAttribute(LLVMValueRef Arg) { @@ -1484,10 +1484,10 @@ LLVMAttribute LLVMGetAttribute(LLVMValueRef Arg) { void LLVMSetParamAlignment(LLVMValueRef Arg, unsigned align) { + Argument *A = unwrap(Arg); AttrBuilder B; B.addAlignmentAttr(align); - unwrap(Arg)->addAttr(Attribute:: - get(unwrap(Arg)->getContext(), B)); + A->addAttr(AttributeSet::get(A->getContext(),A->getArgNo() + 1, B)); } /*--.. Operations on basic blocks ..........................................--*/ diff --git a/lib/IR/Function.cpp b/lib/IR/Function.cpp index f2f3ec9aab4..839e496f92b 100644 --- a/lib/IR/Function.cpp +++ b/lib/IR/Function.cpp @@ -123,23 +123,16 @@ bool Argument::hasStructRetAttr() const { hasAttribute(1, Attribute::StructRet); } -/// addAttr - Add a Attribute to an argument -void Argument::addAttr(Attribute attr) { - AttrBuilder B(attr); - getParent()->addAttributes(getArgNo() + 1, - AttributeSet::get(getParent()->getContext(), - getArgNo() + 1, B)); +/// addAttr - Add attributes to an argument. +void Argument::addAttr(AttributeSet AS) { + getParent()->addAttributes(getArgNo() + 1, AS); } -/// removeAttr - Remove a Attribute from an argument -void Argument::removeAttr(Attribute attr) { - AttrBuilder B(attr); - getParent()->removeAttributes(getArgNo() + 1, - AttributeSet::get(getParent()->getContext(), - getArgNo() + 1, B)); +/// removeAttr - Remove attributes from an argument. +void Argument::removeAttr(AttributeSet AS) { + getParent()->removeAttributes(getArgNo() + 1, AS); } - //===----------------------------------------------------------------------===// // Helper Methods in Function //===----------------------------------------------------------------------===// diff --git a/lib/Transforms/IPO/ArgumentPromotion.cpp b/lib/Transforms/IPO/ArgumentPromotion.cpp index 39062e676c1..627012f9fc3 100644 --- a/lib/Transforms/IPO/ArgumentPromotion.cpp +++ b/lib/Transforms/IPO/ArgumentPromotion.cpp @@ -537,9 +537,13 @@ CallGraphNode *ArgPromotion::DoPromotion(Function *F, } else if (!ArgsToPromote.count(I)) { // Unchanged argument Params.push_back(I->getType()); - Attribute attrs = PAL.getParamAttributes(ArgIndex); - if (attrs.hasAttributes()) - AttributesVec.push_back(AttributeWithIndex::get(Params.size(), attrs)); + AttributeSet attrs = PAL.getParamAttributes(ArgIndex); + if (attrs.hasAttributes(ArgIndex)) { + AttributesVec. + push_back(AttributeWithIndex::get(F->getContext(), + ArgIndex, attrs)); + AttributesVec.back().Index = Params.size(); + } } else if (I->use_empty()) { // Dead argument (which are always marked as promotable) ++NumArgumentsDead; @@ -653,10 +657,12 @@ CallGraphNode *ArgPromotion::DoPromotion(Function *F, if (!ArgsToPromote.count(I) && !ByValArgsToTransform.count(I)) { Args.push_back(*AI); // Unmodified argument - Attribute Attrs = CallPAL.getParamAttributes(ArgIndex); - if (Attrs.hasAttributes()) - AttributesVec.push_back(AttributeWithIndex::get(Args.size(), Attrs)); - + if (CallPAL.hasAttributes(ArgIndex)) { + AttributesVec. + push_back(AttributeWithIndex::get(F->getContext(), ArgIndex, + CallPAL.getParamAttributes(ArgIndex))); + AttributesVec.back().Index = Args.size(); + } } else if (ByValArgsToTransform.count(I)) { // Emit a GEP and load for each element of the struct. Type *AgTy = cast(I->getType())->getElementType(); @@ -715,9 +721,12 @@ CallGraphNode *ArgPromotion::DoPromotion(Function *F, // Push any varargs arguments on the list. for (; AI != CS.arg_end(); ++AI, ++ArgIndex) { Args.push_back(*AI); - Attribute Attrs = CallPAL.getParamAttributes(ArgIndex); - if (Attrs.hasAttributes()) - AttributesVec.push_back(AttributeWithIndex::get(Args.size(), Attrs)); + if (CallPAL.hasAttributes(ArgIndex)) { + AttributesVec. + push_back(AttributeWithIndex::get(F->getContext(), ArgIndex, + CallPAL.getParamAttributes(ArgIndex))); + AttributesVec.back().Index = Args.size(); + } } // Add any function attributes. diff --git a/lib/Transforms/IPO/DeadArgumentElimination.cpp b/lib/Transforms/IPO/DeadArgumentElimination.cpp index 5204248c1fa..3a38ca4bb8c 100644 --- a/lib/Transforms/IPO/DeadArgumentElimination.cpp +++ b/lib/Transforms/IPO/DeadArgumentElimination.cpp @@ -791,9 +791,12 @@ bool DAE::RemoveDeadStuffFromFunction(Function *F) { // Get the original parameter attributes (skipping the first one, that is // for the return value. - Attribute Attrs = PAL.getParamAttributes(i + 1); - if (Attrs.hasAttributes()) - AttributesVec.push_back(AttributeWithIndex::get(Params.size(), Attrs)); + if (PAL.hasAttributes(i + 1)) { + AttributesVec. + push_back(AttributeWithIndex::get(F->getContext(), i + 1, + PAL.getParamAttributes(i + 1))); + AttributesVec.back().Index = Params.size(); + } } else { ++NumArgumentsEliminated; DEBUG(dbgs() << "DAE - Removing argument " << i << " (" << I->getName() @@ -859,17 +862,23 @@ bool DAE::RemoveDeadStuffFromFunction(Function *F) { if (ArgAlive[i]) { Args.push_back(*I); // Get original parameter attributes, but skip return attributes. - Attribute Attrs = CallPAL.getParamAttributes(i + 1); - if (Attrs.hasAttributes()) - AttributesVec.push_back(AttributeWithIndex::get(Args.size(), Attrs)); + if (CallPAL.hasAttributes(i + 1)) { + AttributesVec. + push_back(AttributeWithIndex::get(F->getContext(), i + 1, + CallPAL.getParamAttributes(i + 1))); + AttributesVec.back().Index = Args.size(); + } } // 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); - Attribute Attrs = CallPAL.getParamAttributes(i + 1); - if (Attrs.hasAttributes()) - AttributesVec.push_back(AttributeWithIndex::get(Args.size(), Attrs)); + if (CallPAL.hasAttributes(i + 1)) { + AttributesVec. + push_back(AttributeWithIndex::get(F->getContext(), i + 1, + CallPAL.getParamAttributes(i + 1))); + AttributesVec.back().Index = Args.size(); + } } if (CallPAL.hasAttributes(AttributeSet::FunctionIndex)) diff --git a/lib/Transforms/IPO/FunctionAttrs.cpp b/lib/Transforms/IPO/FunctionAttrs.cpp index 7e46dcb4296..a75212a386c 100644 --- a/lib/Transforms/IPO/FunctionAttrs.cpp +++ b/lib/Transforms/IPO/FunctionAttrs.cpp @@ -380,7 +380,7 @@ bool FunctionAttrs::AddNoCaptureAttrs(const CallGraphSCC &SCC) { for (Function::arg_iterator A = F->arg_begin(), E = F->arg_end(); A != E; ++A) { if (A->getType()->isPointerTy() && !A->hasNoCaptureAttr()) { - A->addAttr(Attribute::get(F->getContext(), B)); + A->addAttr(AttributeSet::get(F->getContext(), A->getArgNo() + 1, B)); ++NumNoCapture; Changed = true; } @@ -395,7 +395,7 @@ bool FunctionAttrs::AddNoCaptureAttrs(const CallGraphSCC &SCC) { if (!Tracker.Captured) { if (Tracker.Uses.empty()) { // If it's trivially not captured, mark it nocapture now. - A->addAttr(Attribute::get(F->getContext(), B)); + A->addAttr(AttributeSet::get(F->getContext(), A->getArgNo()+1, B)); ++NumNoCapture; Changed = true; } else { @@ -430,7 +430,9 @@ bool FunctionAttrs::AddNoCaptureAttrs(const CallGraphSCC &SCC) { ArgumentSCC[0]->Uses[0] == ArgumentSCC[0]) { ArgumentSCC[0]-> Definition-> - addAttr(Attribute::get(ArgumentSCC[0]->Definition->getContext(), B)); + addAttr(AttributeSet::get(ArgumentSCC[0]->Definition->getContext(), + ArgumentSCC[0]->Definition->getArgNo() + 1, + B)); ++NumNoCapture; Changed = true; } @@ -472,7 +474,7 @@ bool FunctionAttrs::AddNoCaptureAttrs(const CallGraphSCC &SCC) { for (unsigned i = 0, e = ArgumentSCC.size(); i != e; ++i) { Argument *A = ArgumentSCC[i]->Definition; - A->addAttr(Attribute::get(A->getContext(), B)); + A->addAttr(AttributeSet::get(A->getContext(), A->getArgNo() + 1, B)); ++NumNoCapture; Changed = true; } diff --git a/lib/Transforms/InstCombine/InstCombineCalls.cpp b/lib/Transforms/InstCombine/InstCombineCalls.cpp index 6d4f1883b69..2fd35494b38 100644 --- a/lib/Transforms/InstCombine/InstCombineCalls.cpp +++ b/lib/Transforms/InstCombine/InstCombineCalls.cpp @@ -1044,14 +1044,15 @@ bool InstCombiner::transformConstExprCastCall(CallSite CS) { if (!CastInst::isCastable(ActTy, ParamTy)) return false; // Cannot transform this parameter value. - Attribute Attrs = CallerPAL.getParamAttributes(i + 1); - if (AttrBuilder(Attrs). + if (AttrBuilder(CallerPAL.getParamAttributes(i + 1), i + 1). hasAttributes(Attribute::typeIncompatible(ParamTy))) return false; // Attribute not compatible with transformed value. // 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 && Attrs.hasAttribute(Attribute::ByVal)) { + if (ParamTy != ActTy && + CallerPAL.getParamAttributes(i + 1).hasAttribute(i + 1, + Attribute::ByVal)) { PointerType *ParamPTy = dyn_cast(ParamTy); if (ParamPTy == 0 || !ParamPTy->getElementType()->isSized() || TD == 0) return false; @@ -1141,9 +1142,11 @@ bool InstCombiner::transformConstExprCastCall(CallSite CS) { } // Add any parameter attributes. - Attribute PAttrs = CallerPAL.getParamAttributes(i + 1); + AttrBuilder PAttrs(CallerPAL.getParamAttributes(i + 1), i + 1); if (PAttrs.hasAttributes()) - attrVec.push_back(AttributeWithIndex::get(i + 1, PAttrs)); + attrVec.push_back( + AttributeWithIndex::get(i + 1, + Attribute::get(FT->getContext(), PAttrs))); } // If the function takes more arguments than the call was taking, add them @@ -1168,9 +1171,11 @@ bool InstCombiner::transformConstExprCastCall(CallSite CS) { } // Add any parameter attributes. - Attribute PAttrs = CallerPAL.getParamAttributes(i + 1); + AttrBuilder PAttrs(CallerPAL.getParamAttributes(i + 1), i + 1); if (PAttrs.hasAttributes()) - attrVec.push_back(AttributeWithIndex::get(i + 1, PAttrs)); + attrVec.push_back( + AttributeWithIndex::get(i + 1, + Attribute::get(FT->getContext(), PAttrs))); } } } @@ -1263,12 +1268,12 @@ InstCombiner::transformCallThroughTrampoline(CallSite CS, if (!NestAttrs.isEmpty()) { unsigned NestIdx = 1; Type *NestTy = 0; - Attribute NestAttr; + AttributeSet NestAttr; // Look for a parameter marked with the 'nest' attribute. for (FunctionType::param_iterator I = NestFTy->param_begin(), E = NestFTy->param_end(); I != E; ++NestIdx, ++I) - if (NestAttrs.getParamAttributes(NestIdx).hasAttribute(Attribute::Nest)){ + if (NestAttrs.hasAttribute(NestIdx, Attribute::Nest)) { // Record the parameter type and any other attributes. NestTy = *I; NestAttr = NestAttrs.getParamAttributes(NestIdx); @@ -1302,7 +1307,8 @@ InstCombiner::transformCallThroughTrampoline(CallSite CS, if (NestVal->getType() != NestTy) NestVal = Builder->CreateBitCast(NestVal, NestTy, "nest"); NewArgs.push_back(NestVal); - NewAttrs.push_back(AttributeWithIndex::get(NestIdx, NestAttr)); + NewAttrs.push_back(AttributeWithIndex::get(Caller->getContext(), + NestIdx, NestAttr)); } if (I == E) @@ -1310,10 +1316,12 @@ InstCombiner::transformCallThroughTrampoline(CallSite CS, // Add the original argument and attributes. NewArgs.push_back(*I); - Attribute Attr = Attrs.getParamAttributes(Idx); - if (Attr.hasAttributes()) + AttributeSet Attr = Attrs.getParamAttributes(Idx); + if (Attr.hasAttributes(Idx)) { NewAttrs.push_back - (AttributeWithIndex::get(Idx + (Idx >= NestIdx), Attr)); + (AttributeWithIndex::get(Caller->getContext(), Idx, Attr)); + NewAttrs.back().Index = Idx + (Idx >= NestIdx); + } ++Idx, ++I; } while (1); diff --git a/lib/Transforms/Utils/CloneFunction.cpp b/lib/Transforms/Utils/CloneFunction.cpp index 1ba332bac78..12311c39a0e 100644 --- a/lib/Transforms/Utils/CloneFunction.cpp +++ b/lib/Transforms/Utils/CloneFunction.cpp @@ -95,7 +95,7 @@ void llvm::CloneFunctionInto(Function *NewFunc, const Function *OldFunc, for (Function::const_arg_iterator I = OldFunc->arg_begin(), E = OldFunc->arg_end(); I != E; ++I) if (Argument* Anew = dyn_cast(VMap[I])) - Anew->addAttr( OldFunc->getAttributes() + Anew->addAttr(OldFunc->getAttributes() .getParamAttributes(I->getArgNo() + 1)); NewFunc->setAttributes(NewFunc->getAttributes() .addRetAttributes(NewFunc->getContext(), -- 2.34.1