6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-12-13 20:32:21 +00:00
Code Issues Projects Releases Wiki Activity

Fix failure messages in Verifier::PerformTypeCheck. The argument numbers

Browse Source 
passed in to this function changed to support multiple return values,
leading to some incorrect argument numbers in the failure messages.
With this change, the ArgNo values used for return values and parameters are
disjoint, and the new IntrinsicParam function translates those ArgNo values
to strings that can be used in the messages.  This also fixes a few places
where PerformTypeCheck did not return false following calls to CheckFailed.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@61903 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Bob Wilson 2009-01-08 01:56:06 +00:00
parent ba811e5d6c
commit 86e34fb20c
1 changed files with 42 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

89
lib/VMCore/Verifier.cpp
View File

@ -1375,6 +1375,20 @@ void Verifier::visitIntrinsicFunctionCall(Intrinsic::ID ID, CallInst &CI) {
} }
} }
/// Produce a string to identify an intrinsic parameter or return value.
/// The ArgNo value numbers the return values from 0 to NumRets-1 and the
/// parameters beginning with NumRets.
///
static std::string IntrinsicParam(unsigned ArgNo, unsigned NumRets) {
if (ArgNo < NumRets) {
if (NumRets == 1)
return "Intrinsic result type";
else
return "Intrinsic result type #" + utostr(ArgNo);
} else
return "Intrinsic parameter #" + utostr(ArgNo - NumRets);
}
bool Verifier::PerformTypeCheck(Intrinsic::ID ID, Function *F, const Type *Ty, bool Verifier::PerformTypeCheck(Intrinsic::ID ID, Function *F, const Type *Ty,
int VT, unsigned ArgNo, std::string &Suffix) { int VT, unsigned ArgNo, std::string &Suffix) {
const FunctionType *FTy = F->getFunctionType(); const FunctionType *FTy = F->getFunctionType();
@ -1387,6 +1401,12 @@ bool Verifier::PerformTypeCheck(Intrinsic::ID ID, Function *F, const Type *Ty,
NumElts = VTy->getNumElements(); NumElts = VTy->getNumElements();
} }
const Type *RetTy = FTy->getReturnType();
const StructType *ST = dyn_cast<StructType>(RetTy);
unsigned NumRets = 1;
if (ST)
NumRets = ST->getNumElements();
if (VT < 0) { if (VT < 0) {
int Match = ~VT; int Match = ~VT;
@ -1397,7 +1417,7 @@ bool Verifier::PerformTypeCheck(Intrinsic::ID ID, Function *F, const Type *Ty,
TruncatedElementVectorType)) != 0) { TruncatedElementVectorType)) != 0) {
const IntegerType *IEltTy = dyn_cast<IntegerType>(EltTy); const IntegerType *IEltTy = dyn_cast<IntegerType>(EltTy);
if (!VTy || !IEltTy) { if (!VTy || !IEltTy) {
CheckFailed("Intrinsic parameter #" + utostr(ArgNo - 1) + " is not " CheckFailed(IntrinsicParam(ArgNo, NumRets) + " is not "
"an integral vector type.", F); "an integral vector type.", F);
return false; return false;
} }
@ -1405,7 +1425,7 @@ bool Verifier::PerformTypeCheck(Intrinsic::ID ID, Function *F, const Type *Ty,
// the type being matched against. // the type being matched against.
if ((Match & ExtendedElementVectorType) != 0) { if ((Match & ExtendedElementVectorType) != 0) {
if ((IEltTy->getBitWidth() & 1) != 0) { if ((IEltTy->getBitWidth() & 1) != 0) {
CheckFailed("Intrinsic parameter #" + utostr(ArgNo - 1) + " vector " CheckFailed(IntrinsicParam(ArgNo, NumRets) + " vector "
"element bit-width is odd.", F); "element bit-width is odd.", F);
return false; return false;
} }
@ -1415,37 +1435,26 @@ bool Verifier::PerformTypeCheck(Intrinsic::ID ID, Function *F, const Type *Ty,
Match &= ~(ExtendedElementVectorType | TruncatedElementVectorType); Match &= ~(ExtendedElementVectorType | TruncatedElementVectorType);
} }
const Type *RetTy = FTy->getReturnType();
const StructType *ST = dyn_cast<StructType>(RetTy);
unsigned NumRets = 1;
if (ST)
NumRets = ST->getNumElements();
if (Match <= static_cast<int>(NumRets - 1)) { if (Match <= static_cast<int>(NumRets - 1)) {
if (ST) if (ST)
RetTy = ST->getElementType(Match); RetTy = ST->getElementType(Match);
if (Ty != RetTy) { if (Ty != RetTy) {
CheckFailed("Intrinsic parameter #" + utostr(ArgNo - 1) + " does not " CheckFailed(IntrinsicParam(ArgNo, NumRets) + " does not "
"match return type.", F); "match return type.", F);
return false; return false;
} }
} else { } else {
if (Ty != FTy->getParamType(Match - 1)) { if (Ty != FTy->getParamType(Match - 1)) {
CheckFailed("Intrinsic parameter #" + utostr(ArgNo - 1) + " does not " CheckFailed(IntrinsicParam(ArgNo, NumRets) + " does not "
"match parameter %" + utostr(Match - 1) + ".", F); "match parameter %" + utostr(Match - 1) + ".", F);
return false; return false;
} }
} }
} else if (VT == MVT::iAny) { } else if (VT == MVT::iAny) {
if (!EltTy->isInteger()) { if (!EltTy->isInteger()) {
if (ArgNo == 0) CheckFailed(IntrinsicParam(ArgNo, NumRets) + " is not "
CheckFailed("Intrinsic result type is not an integer type.", F); "an integer type.", F);
else
CheckFailed("Intrinsic parameter #" + utostr(ArgNo - 1) + " is not "
"an integer type.", F);
return false; return false;
} }
@ -1461,17 +1470,16 @@ bool Verifier::PerformTypeCheck(Intrinsic::ID ID, Function *F, const Type *Ty,
switch (ID) { switch (ID) {
default: break; // Not everything needs to be checked. default: break; // Not everything needs to be checked.
case Intrinsic::bswap: case Intrinsic::bswap:
if (GotBits < 16 || GotBits % 16 != 0) if (GotBits < 16 || GotBits % 16 != 0) {
CheckFailed("Intrinsic requires even byte width argument", F); CheckFailed("Intrinsic requires even byte width argument", F);
return false;
}
break; break;
} }
} else if (VT == MVT::fAny) { } else if (VT == MVT::fAny) {
if (!EltTy->isFloatingPoint()) { if (!EltTy->isFloatingPoint()) {
if (ArgNo == 0) CheckFailed(IntrinsicParam(ArgNo, NumRets) + " is not "
CheckFailed("Intrinsic result type is not a floating-point type.", F); "a floating-point type.", F);
else
CheckFailed("Intrinsic parameter #" + utostr(ArgNo - 1) + " is not "
"a floating-point type.", F);
return false; return false;
} }
@ -1483,12 +1491,9 @@ bool Verifier::PerformTypeCheck(Intrinsic::ID ID, Function *F, const Type *Ty,
Suffix += MVT::getMVT(EltTy).getMVTString(); Suffix += MVT::getMVT(EltTy).getMVTString();
} else if (VT == MVT::iPTR) { } else if (VT == MVT::iPTR) {
if (!isa<PointerType>(Ty)) { if (!isa<PointerType>(Ty)) {
if (ArgNo == 0) CheckFailed(IntrinsicParam(ArgNo, NumRets) + " is not a "
CheckFailed("Intrinsic result type is not a " "pointer and a pointer is required.", F);
"pointer and a pointer is required.", F); return false;
else
CheckFailed("Intrinsic parameter #" + utostr(ArgNo - 1) + " is not a "
"pointer and a pointer is required.", F);
} }
} else if (VT == MVT::iPTRAny) { } else if (VT == MVT::iPTRAny) {
// Outside of TableGen, we don't distinguish iPTRAny (to any address space) // Outside of TableGen, we don't distinguish iPTRAny (to any address space)
@ -1498,12 +1503,8 @@ bool Verifier::PerformTypeCheck(Intrinsic::ID ID, Function *F, const Type *Ty,
Suffix += ".p" + utostr(PTyp->getAddressSpace()) + Suffix += ".p" + utostr(PTyp->getAddressSpace()) +
MVT::getMVT(PTyp->getElementType()).getMVTString(); MVT::getMVT(PTyp->getElementType()).getMVTString();
} else { } else {
if (ArgNo == 0) CheckFailed(IntrinsicParam(ArgNo, NumRets) + " is not a "
CheckFailed("Intrinsic result type is not a " "pointer and a pointer is required.", F);
"pointer and a pointer is required.", F);
else
CheckFailed("Intrinsic parameter #" + utostr(ArgNo-1) + " is not a "
"pointer and a pointer is required.", F);
return false; return false;
} }
} else if (MVT((MVT::SimpleValueType)VT).isVector()) { } else if (MVT((MVT::SimpleValueType)VT).isVector()) {
@ -1521,19 +1522,12 @@ bool Verifier::PerformTypeCheck(Intrinsic::ID ID, Function *F, const Type *Ty,
return false; return false;
} }
} else if (MVT((MVT::SimpleValueType)VT).getTypeForMVT() != EltTy) { } else if (MVT((MVT::SimpleValueType)VT).getTypeForMVT() != EltTy) {
if (ArgNo == 0) CheckFailed(IntrinsicParam(ArgNo, NumRets) + " is wrong!", F);
CheckFailed("Intrinsic prototype has incorrect result type!", F);
else
CheckFailed("Intrinsic parameter #" + utostr(ArgNo-1) + " is wrong!",F);
return false; return false;
} else if (EltTy != Ty) { } else if (EltTy != Ty) {
if (ArgNo == 0) CheckFailed(IntrinsicParam(ArgNo, NumRets) + " is a vector "
CheckFailed("Intrinsic result type is vector " "and a scalar is required.", F);
"and a scalar is required.", F); return false;
else
CheckFailed("Intrinsic parameter #" + utostr(ArgNo-1) + " is vector "
"and a scalar is required.", F);
} }
return true; return true;
@ -1587,7 +1581,8 @@ void Verifier::VerifyIntrinsicPrototype(Intrinsic::ID ID, Function *F,
break; break;
} }
if (!PerformTypeCheck(ID, F, FTy->getParamType(ArgNo), VT, ArgNo, Suffix)) if (!PerformTypeCheck(ID, F, FTy->getParamType(ArgNo), VT, ArgNo + RetNum,
Suffix))
break; break;
} }