PreVerifier() : FunctionPass(&ID) { }
+ virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+ AU.setPreservesAll();
+ }
+
// Check that the prerequisites for successful DominatorTree construction
// are satisfied.
bool runOnFunction(Function &F) {
}
void Verifier::visitSelectInst(SelectInst &SI) {
- if (const VectorType* vt
- = dyn_cast<VectorType>(SI.getCondition()->getType())) {
- Assert1( vt->getElementType() == Type::Int1Ty,
- "Select condition type must be vector of bool!", &SI);
- if (const VectorType* val_vt
- = dyn_cast<VectorType>(SI.getTrueValue()->getType())) {
- Assert1( vt->getNumElements() == val_vt->getNumElements(),
- "Select vector size != value vector size", &SI);
- } else {
- Assert1(0, "Vector select values must have vector types", &SI);
- }
- } else {
- Assert1(SI.getCondition()->getType() == Type::Int1Ty,
- "Select condition type must be bool!", &SI);
- }
- Assert1(SI.getTrueValue()->getType() == SI.getFalseValue()->getType(),
- "Select values must have identical types!", &SI);
+ Assert1(!SelectInst::areInvalidOperands(SI.getOperand(0), SI.getOperand(1),
+ SI.getOperand(2)),
+ "Invalid operands for select instruction!", &SI);
+
Assert1(SI.getTrueValue()->getType() == SI.getType(),
"Select values must have same type as select instruction!", &SI);
visitInstruction(SI);
InstsInThisBlock.insert(&I);
}
+// Flags used by TableGen to mark intrinsic parameters with the
+// LLVMExtendedElementVectorType and LLVMTruncatedElementVectorType classes.
+static const unsigned ExtendedElementVectorType = 0x40000000;
+static const unsigned TruncatedElementVectorType = 0x20000000;
+
/// visitIntrinsicFunction - Allow intrinsics to be verified in different ways.
///
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,
int VT, unsigned ArgNo, std::string &Suffix) {
const FunctionType *FTy = F->getFunctionType();
unsigned NumElts = 0;
const Type *EltTy = Ty;
- if (const VectorType *VTy = dyn_cast<VectorType>(Ty)) {
+ const VectorType *VTy = dyn_cast<VectorType>(Ty);
+ if (VTy) {
EltTy = VTy->getElementType();
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) {
int Match = ~VT;
- const Type *RetTy = FTy->getReturnType();
- const StructType *ST = dyn_cast<StructType>(RetTy);
- unsigned NumRets = 1;
- if (ST)
- NumRets = ST->getNumElements();
+ // Check flags that indicate a type that is an integral vector type with
+ // elements that are larger or smaller than the elements of the matched
+ // type.
+ if ((Match & (ExtendedElementVectorType |
+ TruncatedElementVectorType)) != 0) {
+ const IntegerType *IEltTy = dyn_cast<IntegerType>(EltTy);
+ if (!VTy || !IEltTy) {
+ CheckFailed(IntrinsicParam(ArgNo, NumRets) + " is not "
+ "an integral vector type.", F);
+ return false;
+ }
+ // Adjust the current Ty (in the opposite direction) rather than
+ // the type being matched against.
+ if ((Match & ExtendedElementVectorType) != 0) {
+ if ((IEltTy->getBitWidth() & 1) != 0) {
+ CheckFailed(IntrinsicParam(ArgNo, NumRets) + " vector "
+ "element bit-width is odd.", F);
+ return false;
+ }
+ Ty = VectorType::getTruncatedElementVectorType(VTy);
+ } else
+ Ty = VectorType::getExtendedElementVectorType(VTy);
+ Match &= ~(ExtendedElementVectorType | TruncatedElementVectorType);
+ }
if (Match <= static_cast<int>(NumRets - 1)) {
if (ST)
RetTy = ST->getElementType(Match);
if (Ty != RetTy) {
- CheckFailed("Intrinsic parameter #" + utostr(ArgNo - 1) + " does not "
+ CheckFailed(IntrinsicParam(ArgNo, NumRets) + " does not "
"match return type.", F);
return false;
}
} else {
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);
return false;
}
}
} else if (VT == MVT::iAny) {
if (!EltTy->isInteger()) {
- if (ArgNo == 0)
- CheckFailed("Intrinsic result type is not an integer type.", F);
- else
- CheckFailed("Intrinsic parameter #" + utostr(ArgNo - 1) + " is not "
- "an integer type.", F);
-
+ CheckFailed(IntrinsicParam(ArgNo, NumRets) + " is not "
+ "an integer type.", F);
return false;
}
switch (ID) {
default: break; // Not everything needs to be checked.
case Intrinsic::bswap:
- if (GotBits < 16 || GotBits % 16 != 0)
+ if (GotBits < 16 || GotBits % 16 != 0) {
CheckFailed("Intrinsic requires even byte width argument", F);
+ return false;
+ }
break;
}
} else if (VT == MVT::fAny) {
if (!EltTy->isFloatingPoint()) {
- if (ArgNo == 0)
- CheckFailed("Intrinsic result type is not a floating-point type.", F);
- else
- CheckFailed("Intrinsic parameter #" + utostr(ArgNo - 1) + " is not "
- "a floating-point type.", F);
+ CheckFailed(IntrinsicParam(ArgNo, NumRets) + " is not "
+ "a floating-point type.", F);
return false;
}
Suffix += MVT::getMVT(EltTy).getMVTString();
} else if (VT == MVT::iPTR) {
if (!isa<PointerType>(Ty)) {
- if (ArgNo == 0)
- CheckFailed("Intrinsic result type is not a "
- "pointer and a pointer is required.", F);
- else
- CheckFailed("Intrinsic parameter #" + utostr(ArgNo - 1) + " is not a "
- "pointer and a pointer is required.", F);
+ CheckFailed(IntrinsicParam(ArgNo, NumRets) + " is not a "
+ "pointer and a pointer is required.", F);
+ return false;
}
} else if (VT == MVT::iPTRAny) {
// Outside of TableGen, we don't distinguish iPTRAny (to any address space)
Suffix += ".p" + utostr(PTyp->getAddressSpace()) +
MVT::getMVT(PTyp->getElementType()).getMVTString();
} else {
- if (ArgNo == 0)
- CheckFailed("Intrinsic result type is not a "
- "pointer and a pointer is required.", F);
- else
- CheckFailed("Intrinsic parameter #" + utostr(ArgNo-1) + " is not a "
- "pointer and a pointer is required.", F);
+ CheckFailed(IntrinsicParam(ArgNo, NumRets) + " is not a "
+ "pointer and a pointer is required.", F);
return false;
}
} else if (MVT((MVT::SimpleValueType)VT).isVector()) {
return false;
}
} else if (MVT((MVT::SimpleValueType)VT).getTypeForMVT() != EltTy) {
- if (ArgNo == 0)
- CheckFailed("Intrinsic prototype has incorrect result type!", F);
- else
- CheckFailed("Intrinsic parameter #" + utostr(ArgNo-1) + " is wrong!",F);
-
+ CheckFailed(IntrinsicParam(ArgNo, NumRets) + " is wrong!", F);
return false;
} else if (EltTy != Ty) {
- if (ArgNo == 0)
- CheckFailed("Intrinsic result type is vector "
- "and a scalar is required.", F);
- else
- CheckFailed("Intrinsic parameter #" + utostr(ArgNo-1) + " is vector "
- "and a scalar is required.", F);
+ CheckFailed(IntrinsicParam(ArgNo, NumRets) + " is a vector "
+ "and a scalar is required.", F);
+ return false;
}
return true;
break;
}
- if (!PerformTypeCheck(ID, F, FTy->getParamType(ArgNo), VT, ArgNo, Suffix))
+ if (!PerformTypeCheck(ID, F, FTy->getParamType(ArgNo), VT, ArgNo + RetNum,
+ Suffix))
break;
}
projects / oota-llvm.git / blobdiff