From 3e2d76c946ba753c2b11af192a52e25b6f9b46ff Mon Sep 17 00:00:00 2001 From: Bill Wendling Date: Tue, 9 Oct 2012 21:38:14 +0000 Subject: [PATCH] Use the attribute enums to query if a parameter has an attribute. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@165550 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/Attributes.h | 4 +- include/llvm/Instructions.h | 22 +--- include/llvm/Support/CallSite.h | 36 +---- include/llvm/Target/TargetLowering.h | 6 +- lib/Analysis/AliasAnalysis.cpp | 2 +- .../SelectionDAG/SelectionDAGBuilder.cpp | 12 +- lib/Target/ARM/ARMFastISel.cpp | 12 +- lib/Target/X86/X86FastISel.cpp | 20 +-- lib/Transforms/IPO/FunctionAttrs.cpp | 2 +- lib/VMCore/Instructions.cpp | 124 +----------------- 10 files changed, 44 insertions(+), 196 deletions(-) diff --git a/include/llvm/Attributes.h b/include/llvm/Attributes.h index 2933defe96c..1c2770995c2 100644 --- a/include/llvm/Attributes.h +++ b/include/llvm/Attributes.h @@ -295,7 +295,7 @@ public: static Attributes constructAlignmentFromInt(unsigned i) { // Default alignment, allow the target to define how to align it. if (i == 0) - return Attribute::None; + return Attributes(); assert(isPowerOf2_32(i) && "Alignment must be a power of two."); assert(i <= 0x40000000 && "Alignment too large."); @@ -307,7 +307,7 @@ public: static Attributes constructStackAlignmentFromInt(unsigned i) { // Default alignment, allow the target to define how to align it. if (i == 0) - return Attribute::None; + return Attributes(); assert(isPowerOf2_32(i) && "Alignment must be a power of two."); assert(i <= 0x100 && "Alignment too large."); diff --git a/include/llvm/Instructions.h b/include/llvm/Instructions.h index 597eca5aa46..ea3aaae9c6f 100644 --- a/include/llvm/Instructions.h +++ b/include/llvm/Instructions.h @@ -1277,14 +1277,7 @@ public: bool fnHasReturnsTwiceAttr() const; /// @brief Determine whether the call or the callee has the given attributes. - bool paramHasByValAttr(unsigned i) const; - bool paramHasInRegAttr(unsigned i) const; - bool paramHasNestAttr(unsigned i) const; - bool paramHasNoAliasAttr(unsigned i) const; - bool paramHasNoCaptureAttr(unsigned i) const; - bool paramHasSExtAttr(unsigned i) const; - bool paramHasStructRetAttr(unsigned i) const; - bool paramHasZExtAttr(unsigned i) const; + bool paramHasAttr(unsigned i, Attributes::AttrVal A) const; /// @brief Extract the alignment for a call or parameter (0=unknown). unsigned getParamAlignment(unsigned i) const { @@ -1343,7 +1336,7 @@ public: /// pointer argument. bool hasStructRetAttr() const { // Be friendly and also check the callee. - return paramHasStructRetAttr(1); + return paramHasAttr(1, Attributes::StructRet); } /// @brief Determine if any call argument is an aggregate passed by value. @@ -3053,14 +3046,7 @@ public: bool fnHasReturnsTwiceAttr() const; /// @brief Determine whether the call or the callee has the given attributes. - bool paramHasSExtAttr(unsigned i) const; - bool paramHasZExtAttr(unsigned i) const; - bool paramHasInRegAttr(unsigned i) const; - bool paramHasStructRetAttr(unsigned i) const; - bool paramHasNestAttr(unsigned i) const; - bool paramHasByValAttr(unsigned i) const; - bool paramHasNoAliasAttr(unsigned i) const; - bool paramHasNoCaptureAttr(unsigned i) const; + bool paramHasAttr(unsigned i, Attributes::AttrVal A) const; /// @brief Extract the alignment for a call or parameter (0=unknown). unsigned getParamAlignment(unsigned i) const { @@ -3110,7 +3096,7 @@ public: /// pointer argument. bool hasStructRetAttr() const { // Be friendly and also check the callee. - return paramHasStructRetAttr(1); + return paramHasAttr(1, Attributes::StructRet); } /// @brief Determine if any call argument is an aggregate passed by value. diff --git a/include/llvm/Support/CallSite.h b/include/llvm/Support/CallSite.h index bbbec6d46c6..c15326ee95f 100644 --- a/include/llvm/Support/CallSite.h +++ b/include/llvm/Support/CallSite.h @@ -210,35 +210,9 @@ public: CALLSITE_DELEGATE_GETTER(hasFnAttr(N)); } - /// paramHas*Attr - whether the call or the callee has the given attribute. - bool paramHasSExtAttr(unsigned i) const { - CALLSITE_DELEGATE_GETTER(paramHasSExtAttr(i)); - } - bool paramHasZExtAttr(unsigned i) const { - CALLSITE_DELEGATE_GETTER(paramHasZExtAttr(i)); - } - bool paramHasInRegAttr(unsigned i) const { - CALLSITE_DELEGATE_GETTER(paramHasInRegAttr(i)); - } - bool paramHasStructRetAttr(unsigned i) const { - CALLSITE_DELEGATE_GETTER(paramHasStructRetAttr(i)); - } - bool paramHasNestAttr(unsigned i) const { - CALLSITE_DELEGATE_GETTER(paramHasNestAttr(i)); - } - bool paramHasByValAttr(unsigned i) const { - CALLSITE_DELEGATE_GETTER(paramHasByValAttr(i)); - } - bool paramHasNoAliasAttr(unsigned i) const { - CALLSITE_DELEGATE_GETTER(paramHasNoAliasAttr(i)); - } - bool paramHasNoCaptureAttr(unsigned i) const { - CALLSITE_DELEGATE_GETTER(paramHasNoCaptureAttr(i)); - } - - /// paramHasAttr - whether the call or the callee has the given attribute. - bool paramHasAttr(uint16_t i, Attributes attr) const { - CALLSITE_DELEGATE_GETTER(paramHasAttr(i, attr)); + /// \brief Return true if the call or the callee has the given attribute. + bool paramHasAttr(unsigned i, Attributes::AttrVal A) const { + CALLSITE_DELEGATE_GETTER(paramHasAttr(i, A)); } /// @brief Extract the alignment for a call or parameter (0=unknown). @@ -291,12 +265,12 @@ public: /// @brief Determine whether this argument is not captured. bool doesNotCapture(unsigned ArgNo) const { - return paramHasNoCaptureAttr(ArgNo + 1); + return paramHasAttr(ArgNo + 1, Attributes::NoCapture); } /// @brief Determine whether this argument is passed by value. bool isByValArgument(unsigned ArgNo) const { - return paramHasByValAttr(ArgNo + 1); + return paramHasAttr(ArgNo + 1, Attributes::ByVal); } /// hasArgument - Returns true if this CallSite passes the given Value* as an diff --git a/include/llvm/Target/TargetLowering.h b/include/llvm/Target/TargetLowering.h index 6f57e0a831c..b3149e960a8 100644 --- a/include/llvm/Target/TargetLowering.h +++ b/include/llvm/Target/TargetLowering.h @@ -1323,9 +1323,9 @@ public: FunctionType *FTy, bool isTailCall, SDValue callee, ArgListTy &args, SelectionDAG &dag, DebugLoc dl, ImmutableCallSite &cs) - : Chain(chain), RetTy(retTy), RetSExt(cs.paramHasSExtAttr(0)), - RetZExt(cs.paramHasZExtAttr(0)), IsVarArg(FTy->isVarArg()), - IsInReg(cs.paramHasInRegAttr(0)), + : Chain(chain), RetTy(retTy), RetSExt(cs.paramHasAttr(0, Attributes::SExt)), + RetZExt(cs.paramHasAttr(0, Attributes::ZExt)), IsVarArg(FTy->isVarArg()), + IsInReg(cs.paramHasAttr(0, Attributes::InReg)), DoesNotReturn(cs.doesNotReturn()), IsReturnValueUsed(!cs.getInstruction()->use_empty()), IsTailCall(isTailCall), NumFixedArgs(FTy->getNumParams()), diff --git a/lib/Analysis/AliasAnalysis.cpp b/lib/Analysis/AliasAnalysis.cpp index ec334a75a0e..752edd52b45 100644 --- a/lib/Analysis/AliasAnalysis.cpp +++ b/lib/Analysis/AliasAnalysis.cpp @@ -503,7 +503,7 @@ bool AliasAnalysis::canInstructionRangeModify(const Instruction &I1, bool llvm::isNoAliasCall(const Value *V) { if (isa(V) || isa(V)) return ImmutableCallSite(cast(V)) - .paramHasNoAliasAttr(0); + .paramHasAttr(0, Attributes::NoAlias); return false; } diff --git a/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp b/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp index c81db1e76fa..dccc2fcf25b 100644 --- a/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp +++ b/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp @@ -5342,12 +5342,12 @@ void SelectionDAGBuilder::LowerCallTo(ImmutableCallSite CS, SDValue Callee, Entry.Node = ArgNode; Entry.Ty = V->getType(); unsigned attrInd = i - CS.arg_begin() + 1; - Entry.isSExt = CS.paramHasSExtAttr(attrInd); - Entry.isZExt = CS.paramHasZExtAttr(attrInd); - Entry.isInReg = CS.paramHasInRegAttr(attrInd); - Entry.isSRet = CS.paramHasStructRetAttr(attrInd); - Entry.isNest = CS.paramHasNestAttr(attrInd); - Entry.isByVal = CS.paramHasByValAttr(attrInd); + Entry.isSExt = CS.paramHasAttr(attrInd, Attributes::SExt); + Entry.isZExt = CS.paramHasAttr(attrInd, Attributes::ZExt); + Entry.isInReg = CS.paramHasAttr(attrInd, Attributes::InReg); + Entry.isSRet = CS.paramHasAttr(attrInd, Attributes::StructRet); + Entry.isNest = CS.paramHasAttr(attrInd, Attributes::Nest); + Entry.isByVal = CS.paramHasAttr(attrInd, Attributes::ByVal); Entry.Alignment = CS.getParamAlignment(attrInd); Args.push_back(Entry); } diff --git a/lib/Target/ARM/ARMFastISel.cpp b/lib/Target/ARM/ARMFastISel.cpp index 405c2f441d1..92248f53178 100644 --- a/lib/Target/ARM/ARMFastISel.cpp +++ b/lib/Target/ARM/ARMFastISel.cpp @@ -2320,16 +2320,16 @@ bool ARMFastISel::SelectCall(const Instruction *I, ISD::ArgFlagsTy Flags; unsigned AttrInd = i - CS.arg_begin() + 1; - if (CS.paramHasSExtAttr(AttrInd)) + if (CS.paramHasAttr(AttrInd, Attributes::SExt)) Flags.setSExt(); - if (CS.paramHasZExtAttr(AttrInd)) + if (CS.paramHasAttr(AttrInd, Attributes::ZExt)) Flags.setZExt(); // FIXME: Only handle *easy* calls for now. - if (CS.paramHasInRegAttr(AttrInd) || - CS.paramHasStructRetAttr(AttrInd) || - CS.paramHasNestAttr(AttrInd) || - CS.paramHasByValAttr(AttrInd)) + if (CS.paramHasAttr(AttrInd, Attributes::InReg) || + CS.paramHasAttr(AttrInd, Attributes::StructRet) || + CS.paramHasAttr(AttrInd, Attributes::Nest) || + CS.paramHasAttr(AttrInd, Attributes::ByVal)) return false; Type *ArgTy = (*i)->getType(); diff --git a/lib/Target/X86/X86FastISel.cpp b/lib/Target/X86/X86FastISel.cpp index cf14fe05212..dbae608352c 100644 --- a/lib/Target/X86/X86FastISel.cpp +++ b/lib/Target/X86/X86FastISel.cpp @@ -1541,9 +1541,9 @@ static unsigned computeBytesPoppedByCallee(const X86Subtarget &Subtarget, CallingConv::ID CC = CS.getCallingConv(); if (CC == CallingConv::Fast || CC == CallingConv::GHC) return 0; - if (!CS.paramHasStructRetAttr(1)) + if (!CS.paramHasAttr(1, Attributes::StructRet)) return 0; - if (CS.paramHasInRegAttr(1)) + if (CS.paramHasAttr(1, Attributes::InReg)) return 0; return 4; } @@ -1622,12 +1622,12 @@ bool X86FastISel::DoSelectCall(const Instruction *I, const char *MemIntName) { Value *ArgVal = *i; ISD::ArgFlagsTy Flags; unsigned AttrInd = i - CS.arg_begin() + 1; - if (CS.paramHasSExtAttr(AttrInd)) + if (CS.paramHasAttr(AttrInd, Attributes::SExt)) Flags.setSExt(); - if (CS.paramHasZExtAttr(AttrInd)) + if (CS.paramHasAttr(AttrInd, Attributes::ZExt)) Flags.setZExt(); - if (CS.paramHasByValAttr(AttrInd)) { + if (CS.paramHasAttr(AttrInd, Attributes::ByVal)) { PointerType *Ty = cast(ArgVal->getType()); Type *ElementTy = Ty->getElementType(); unsigned FrameSize = TD.getTypeAllocSize(ElementTy); @@ -1641,9 +1641,9 @@ bool X86FastISel::DoSelectCall(const Instruction *I, const char *MemIntName) { return false; } - if (CS.paramHasInRegAttr(AttrInd)) + if (CS.paramHasAttr(AttrInd, Attributes::InReg)) Flags.setInReg(); - if (CS.paramHasNestAttr(AttrInd)) + if (CS.paramHasAttr(AttrInd, Attributes::Nest)) Flags.setNest(); // If this is an i1/i8/i16 argument, promote to i32 to avoid an extra @@ -1911,11 +1911,11 @@ bool X86FastISel::DoSelectCall(const Instruction *I, const char *MemIntName) { ISD::InputArg MyFlags; MyFlags.VT = RegisterVT.getSimpleVT(); MyFlags.Used = !CS.getInstruction()->use_empty(); - if (CS.paramHasSExtAttr(0)) + if (CS.paramHasAttr(0, Attributes::SExt)) MyFlags.Flags.setSExt(); - if (CS.paramHasZExtAttr(0)) + if (CS.paramHasAttr(0, Attributes::ZExt)) MyFlags.Flags.setZExt(); - if (CS.paramHasInRegAttr(0)) + if (CS.paramHasAttr(0, Attributes::InReg)) MyFlags.Flags.setInReg(); Ins.push_back(MyFlags); } diff --git a/lib/Transforms/IPO/FunctionAttrs.cpp b/lib/Transforms/IPO/FunctionAttrs.cpp index 0e16589ecec..e0deb433112 100644 --- a/lib/Transforms/IPO/FunctionAttrs.cpp +++ b/lib/Transforms/IPO/FunctionAttrs.cpp @@ -518,7 +518,7 @@ bool FunctionAttrs::IsFunctionMallocLike(Function *F, case Instruction::Call: case Instruction::Invoke: { CallSite CS(RVI); - if (CS.paramHasNoAliasAttr(0)) + if (CS.paramHasAttr(0, Attributes::NoAlias)) break; if (CS.getCalledFunction() && SCCNodes.count(CS.getCalledFunction())) diff --git a/lib/VMCore/Instructions.cpp b/lib/VMCore/Instructions.cpp index f7bb4b264ed..0a097b8be20 100644 --- a/lib/VMCore/Instructions.cpp +++ b/lib/VMCore/Instructions.cpp @@ -393,67 +393,11 @@ bool CallInst::fnHasReturnsTwiceAttr() const { return false; } -bool CallInst::paramHasSExtAttr(unsigned i) const { - if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::SExt)) +bool CallInst::paramHasAttr(unsigned i, Attributes::AttrVal A) const { + if (AttributeList.getParamAttributes(i).hasAttribute(A)) return true; if (const Function *F = getCalledFunction()) - return F->getParamAttributes(i).hasAttribute(Attributes::SExt); - return false; -} - -bool CallInst::paramHasZExtAttr(unsigned i) const { - if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::ZExt)) - return true; - if (const Function *F = getCalledFunction()) - return F->getParamAttributes(i).hasAttribute(Attributes::ZExt); - return false; -} - -bool CallInst::paramHasInRegAttr(unsigned i) const { - if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::InReg)) - return true; - if (const Function *F = getCalledFunction()) - return F->getParamAttributes(i).hasAttribute(Attributes::InReg); - return false; -} - -bool CallInst::paramHasStructRetAttr(unsigned i) const { - if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::StructRet)) - return true; - if (const Function *F = getCalledFunction()) - return F->getParamAttributes(i).hasAttribute(Attributes::StructRet); - return false; -} - -bool CallInst::paramHasNestAttr(unsigned i) const { - if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::Nest)) - return true; - if (const Function *F = getCalledFunction()) - return F->getParamAttributes(i).hasAttribute(Attributes::Nest); - return false; -} - -bool CallInst::paramHasByValAttr(unsigned i) const { - if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::ByVal)) - return true; - if (const Function *F = getCalledFunction()) - return F->getParamAttributes(i).hasAttribute(Attributes::ByVal); - return false; -} - -bool CallInst::paramHasNoAliasAttr(unsigned i) const { - if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::NoAlias)) - return true; - if (const Function *F = getCalledFunction()) - return F->getParamAttributes(i).hasAttribute(Attributes::NoAlias); - return false; -} - -bool CallInst::paramHasNoCaptureAttr(unsigned i) const { - if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::NoCapture)) - return true; - if (const Function *F = getCalledFunction()) - return F->getParamAttributes(i).hasAttribute(Attributes::NoCapture); + return F->getParamAttributes(i).hasAttribute(A); return false; } @@ -720,67 +664,11 @@ bool InvokeInst::fnHasReturnsTwiceAttr() const { return false; } -bool InvokeInst::paramHasSExtAttr(unsigned i) const { - if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::SExt)) +bool InvokeInst::paramHasAttr(unsigned i, Attributes::AttrVal A) const { + if (AttributeList.getParamAttributes(i).hasAttribute(A)) return true; if (const Function *F = getCalledFunction()) - return F->getParamAttributes(i).hasAttribute(Attributes::SExt); - return false; -} - -bool InvokeInst::paramHasZExtAttr(unsigned i) const { - if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::ZExt)) - return true; - if (const Function *F = getCalledFunction()) - return F->getParamAttributes(i).hasAttribute(Attributes::ZExt); - return false; -} - -bool InvokeInst::paramHasInRegAttr(unsigned i) const { - if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::InReg)) - return true; - if (const Function *F = getCalledFunction()) - return F->getParamAttributes(i).hasAttribute(Attributes::InReg); - return false; -} - -bool InvokeInst::paramHasStructRetAttr(unsigned i) const { - if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::StructRet)) - return true; - if (const Function *F = getCalledFunction()) - return F->getParamAttributes(i).hasAttribute(Attributes::StructRet); - return false; -} - -bool InvokeInst::paramHasNestAttr(unsigned i) const { - if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::Nest)) - return true; - if (const Function *F = getCalledFunction()) - return F->getParamAttributes(i).hasAttribute(Attributes::Nest); - return false; -} - -bool InvokeInst::paramHasByValAttr(unsigned i) const { - if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::ByVal)) - return true; - if (const Function *F = getCalledFunction()) - return F->getParamAttributes(i).hasAttribute(Attributes::ByVal); - return false; -} - -bool InvokeInst::paramHasNoAliasAttr(unsigned i) const { - if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::NoAlias)) - return true; - if (const Function *F = getCalledFunction()) - return F->getParamAttributes(i).hasAttribute(Attributes::NoAlias); - return false; -} - -bool InvokeInst::paramHasNoCaptureAttr(unsigned i) const { - if (AttributeList.getParamAttributes(i).hasAttribute(Attributes::NoCapture)) - return true; - if (const Function *F = getCalledFunction()) - return F->getParamAttributes(i).hasAttribute(Attributes::NoCapture); + return F->getParamAttributes(i).hasAttribute(A); return false; }