RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-22 18:54:02 +01:00
Code Issues Projects Releases Wiki Activity

Use the attribute enums to query if a parameter has an attribute.

Browse Source 
llvm-svn: 165550
This commit is contained in:
Bill Wendling 2012-10-09 21:38:14 +00:00
parent 9a38b18e2d
commit 04e6cf2045
10 changed files with 44 additions and 196 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
include/llvm/Attributes.h
View File

@ -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.");

22
include/llvm/Instructions.h
View File

@ -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.

36
include/llvm/Support/CallSite.h
View File

@ -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

6
include/llvm/Target/TargetLowering.h
View File

@ -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()),

2
lib/Analysis/AliasAnalysis.cpp
View File

@ -503,7 +503,7 @@ bool AliasAnalysis::canInstructionRangeModify(const Instruction &I1,
bool llvm::isNoAliasCall(const Value *V) {
if (isa<CallInst>(V) || isa<InvokeInst>(V))
return ImmutableCallSite(cast<Instruction>(V))
.paramHasNoAliasAttr(0);
.paramHasAttr(0, Attributes::NoAlias);
return false;
}

12
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
View File

@ -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);
}

12
lib/Target/ARM/ARMFastISel.cpp
View File

@ -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();

20
lib/Target/X86/X86FastISel.cpp
View File

@ -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<PointerType>(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);
}

2
lib/Transforms/IPO/FunctionAttrs.cpp
View File

@ -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()))

124
lib/VMCore/Instructions.cpp
View File

@ -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;
}