#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/STLExtras.h"
#include "llvm/Support/Compiler.h"
+#include "llvm/Support/raw_ostream.h"
#include <algorithm>
#include <sstream>
#include <cstdarg>
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 visitInsertValueInst(InsertValueInst &IVI);
void VerifyCallSite(CallSite CS);
+ bool PerformTypeCheck(Intrinsic::ID ID, Function *F, const Type *Ty,
+ int VT, unsigned ArgNo, std::string &Suffix);
void VerifyIntrinsicPrototype(Intrinsic::ID ID, Function *F,
- unsigned Count, ...);
+ unsigned RetNum, unsigned ParamNum, ...);
void VerifyAttrs(Attributes Attrs, const Type *Ty,
bool isReturnValue, const Value *V);
void VerifyFunctionAttrs(const FunctionType *FT, const AttrListPtr &Attrs,
}
void WriteType(const Type *T) {
- if ( !T ) return;
- WriteTypeSymbolic(msgs, T, Mod );
+ if (!T) return;
+ raw_os_ostream RO(msgs);
+ RO << ' ';
+ WriteTypeSymbolic(RO, T, Mod);
}
GV.hasExternalWeakLinkage() ||
GV.hasGhostLinkage() ||
(isa<GlobalAlias>(GV) &&
- (GV.hasInternalLinkage() || GV.hasWeakLinkage())),
+ (GV.hasLocalLinkage() || GV.hasWeakLinkage())),
"Global is external, but doesn't have external or dllimport or weak linkage!",
&GV);
void Verifier::visitGlobalAlias(GlobalAlias &GA) {
Assert1(!GA.getName().empty(),
"Alias name cannot be empty!", &GA);
- Assert1(GA.hasExternalLinkage() || GA.hasInternalLinkage() ||
+ Assert1(GA.hasExternalLinkage() || GA.hasLocalLinkage() ||
GA.hasWeakLinkage(),
"Alias should have external or external weak linkage!", &GA);
Assert1(GA.getAliasee(),
unsigned N = RI.getNumOperands();
if (F->getReturnType() == Type::VoidTy)
Assert2(N == 0,
- "Found return instr that returns void in Function of non-void "
+ "Found return instr that returns non-void in Function of void "
"return type!", &RI, F->getReturnType());
else if (N == 1 && F->getReturnType() == RI.getOperand(0)->getType()) {
// Exactly one return value and it matches the return type. Good.
}
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);
Assert1(SrcTy->isIntOrIntVector(), "Trunc only operates on integer", &I);
Assert1(DestTy->isIntOrIntVector(), "Trunc only produces integer", &I);
+ Assert1(isa<VectorType>(SrcTy) == isa<VectorType>(DestTy),
+ "trunc source and destination must both be a vector or neither", &I);
Assert1(SrcBitSize > DestBitSize,"DestTy too big for Trunc", &I);
visitInstruction(I);
// Get the size of the types in bits, we'll need this later
Assert1(SrcTy->isIntOrIntVector(), "ZExt only operates on integer", &I);
Assert1(DestTy->isIntOrIntVector(), "ZExt only produces an integer", &I);
+ Assert1(isa<VectorType>(SrcTy) == isa<VectorType>(DestTy),
+ "zext source and destination must both be a vector or neither", &I);
unsigned SrcBitSize = SrcTy->getPrimitiveSizeInBits();
unsigned DestBitSize = DestTy->getPrimitiveSizeInBits();
Assert1(SrcTy->isIntOrIntVector(), "SExt only operates on integer", &I);
Assert1(DestTy->isIntOrIntVector(), "SExt only produces an integer", &I);
+ Assert1(isa<VectorType>(SrcTy) == isa<VectorType>(DestTy),
+ "sext source and destination must both be a vector or neither", &I);
Assert1(SrcBitSize < DestBitSize,"Type too small for SExt", &I);
visitInstruction(I);
Assert1(SrcTy->isFPOrFPVector(),"FPTrunc only operates on FP", &I);
Assert1(DestTy->isFPOrFPVector(),"FPTrunc only produces an FP", &I);
+ Assert1(isa<VectorType>(SrcTy) == isa<VectorType>(DestTy),
+ "fptrunc source and destination must both be a vector or neither",&I);
Assert1(SrcBitSize > DestBitSize,"DestTy too big for FPTrunc", &I);
visitInstruction(I);
Assert1(SrcTy->isFPOrFPVector(),"FPExt only operates on FP", &I);
Assert1(DestTy->isFPOrFPVector(),"FPExt only produces an FP", &I);
+ Assert1(isa<VectorType>(SrcTy) == isa<VectorType>(DestTy),
+ "fpext source and destination must both be a vector or neither", &I);
Assert1(SrcBitSize < DestBitSize,"DestTy too small for FPExt", &I);
visitInstruction(I);
void Verifier::visitCallInst(CallInst &CI) {
VerifyCallSite(&CI);
- if (Function *F = CI.getCalledFunction()) {
+ if (Function *F = CI.getCalledFunction())
if (Intrinsic::ID ID = (Intrinsic::ID)F->getIntrinsicID())
visitIntrinsicFunctionCall(ID, CI);
- }
}
void Verifier::visitInvokeInst(InvokeInst &II) {
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) {
switch (ID) {
default:
break;
- case Intrinsic::memcpy_i32:
- case Intrinsic::memcpy_i64:
- case Intrinsic::memmove_i32:
- case Intrinsic::memmove_i64:
- case Intrinsic::memset_i32:
- case Intrinsic::memset_i64:
+ case Intrinsic::dbg_declare: // llvm.dbg.declare
+ if (Constant *C = dyn_cast<Constant>(CI.getOperand(1)))
+ Assert1(C && !isa<ConstantPointerNull>(C),
+ "invalid llvm.dbg.declare intrinsic call", &CI);
+ break;
+ case Intrinsic::memcpy:
+ case Intrinsic::memmove:
+ case Intrinsic::memset:
Assert1(isa<ConstantInt>(CI.getOperand(4)),
"alignment argument of memory intrinsics must be a constant int",
&CI);
"invalid arguments to llvm.prefetch",
&CI);
break;
+ case Intrinsic::stackprotector:
+ Assert1(isa<AllocaInst>(CI.getOperand(2)->stripPointerCasts()),
+ "llvm.stackprotector parameter #2 must resolve to an alloca.",
+ &CI);
+ break;
}
}
+/// 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;
+ 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;
+
+ // 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(IntrinsicParam(ArgNo, NumRets) + " does not "
+ "match return type.", F);
+ return false;
+ }
+ } else {
+ if (Ty != FTy->getParamType(Match - 1)) {
+ CheckFailed(IntrinsicParam(ArgNo, NumRets) + " does not "
+ "match parameter %" + utostr(Match - 1) + ".", F);
+ return false;
+ }
+ }
+ } else if (VT == MVT::iAny) {
+ if (!EltTy->isInteger()) {
+ CheckFailed(IntrinsicParam(ArgNo, NumRets) + " is not "
+ "an integer type.", F);
+ return false;
+ }
+
+ unsigned GotBits = cast<IntegerType>(EltTy)->getBitWidth();
+ Suffix += ".";
+
+ if (EltTy != Ty)
+ Suffix += "v" + utostr(NumElts);
+
+ Suffix += "i" + utostr(GotBits);;
+
+ // Check some constraints on various intrinsics.
+ switch (ID) {
+ default: break; // Not everything needs to be checked.
+ case Intrinsic::bswap:
+ 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()) {
+ CheckFailed(IntrinsicParam(ArgNo, NumRets) + " is not "
+ "a floating-point type.", F);
+ return false;
+ }
+
+ Suffix += ".";
+
+ if (EltTy != Ty)
+ Suffix += "v" + utostr(NumElts);
+
+ Suffix += MVT::getMVT(EltTy).getMVTString();
+ } else if (VT == MVT::iPTR) {
+ if (!isa<PointerType>(Ty)) {
+ 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)
+ // and iPTR. In the verifier, we can not distinguish which case we have so
+ // allow either case to be legal.
+ if (const PointerType* PTyp = dyn_cast<PointerType>(Ty)) {
+ Suffix += ".p" + utostr(PTyp->getAddressSpace()) +
+ MVT::getMVT(PTyp->getElementType()).getMVTString();
+ } else {
+ CheckFailed(IntrinsicParam(ArgNo, NumRets) + " is not a "
+ "pointer and a pointer is required.", F);
+ return false;
+ }
+ } else if (MVT((MVT::SimpleValueType)VT).isVector()) {
+ MVT VVT = MVT((MVT::SimpleValueType)VT);
+
+ // If this is a vector argument, verify the number and type of elements.
+ if (VVT.getVectorElementType() != MVT::getMVT(EltTy)) {
+ CheckFailed("Intrinsic prototype has incorrect vector element type!", F);
+ return false;
+ }
+
+ if (VVT.getVectorNumElements() != NumElts) {
+ CheckFailed("Intrinsic prototype has incorrect number of "
+ "vector elements!", F);
+ return false;
+ }
+ } else if (MVT((MVT::SimpleValueType)VT).getTypeForMVT() != EltTy) {
+ CheckFailed(IntrinsicParam(ArgNo, NumRets) + " is wrong!", F);
+ return false;
+ } else if (EltTy != Ty) {
+ CheckFailed(IntrinsicParam(ArgNo, NumRets) + " is a vector "
+ "and a scalar is required.", F);
+ return false;
+ }
+
+ return true;
+}
+
/// VerifyIntrinsicPrototype - TableGen emits calls to this function into
/// Intrinsics.gen. This implements a little state machine that verifies the
/// prototype of intrinsics.
-void Verifier::VerifyIntrinsicPrototype(Intrinsic::ID ID,
- Function *F,
- unsigned Count, ...) {
+void Verifier::VerifyIntrinsicPrototype(Intrinsic::ID ID, Function *F,
+ unsigned RetNum,
+ unsigned ParamNum, ...) {
va_list VA;
- va_start(VA, Count);
+ va_start(VA, ParamNum);
const FunctionType *FTy = F->getFunctionType();
// For overloaded intrinsics, the Suffix of the function name must match the
// suffix, to be checked at the end.
std::string Suffix;
- if (FTy->getNumParams() + FTy->isVarArg() != Count - 1) {
+ if (FTy->getNumParams() + FTy->isVarArg() != ParamNum) {
CheckFailed("Intrinsic prototype has incorrect number of arguments!", F);
return;
}
- // Note that "arg#0" is the return type.
- for (unsigned ArgNo = 0; ArgNo < Count; ++ArgNo) {
+ const Type *Ty = FTy->getReturnType();
+ const StructType *ST = dyn_cast<StructType>(Ty);
+
+ // Verify the return types.
+ if (ST && ST->getNumElements() != RetNum) {
+ CheckFailed("Intrinsic prototype has incorrect number of return types!", F);
+ return;
+ }
+
+ for (unsigned ArgNo = 0; ArgNo < RetNum; ++ArgNo) {
+ int VT = va_arg(VA, int); // An MVT::SimpleValueType when non-negative.
+
+ if (ST) Ty = ST->getElementType(ArgNo);
+
+ if (!PerformTypeCheck(ID, F, Ty, VT, ArgNo, Suffix))
+ break;
+ }
+
+ // Verify the parameter types.
+ for (unsigned ArgNo = 0; ArgNo < ParamNum; ++ArgNo) {
int VT = va_arg(VA, int); // An MVT::SimpleValueType when non-negative.
if (VT == MVT::isVoid && ArgNo > 0) {
break;
}
- const Type *Ty;
- if (ArgNo == 0)
- Ty = FTy->getReturnType();
- else
- Ty = FTy->getParamType(ArgNo-1);
-
- unsigned NumElts = 0;
- const Type *EltTy = Ty;
- if (const VectorType *VTy = dyn_cast<VectorType>(Ty)) {
- EltTy = VTy->getElementType();
- NumElts = VTy->getNumElements();
- }
-
- if (VT < 0) {
- int Match = ~VT;
- if (Match == 0) {
- if (Ty != FTy->getReturnType()) {
- CheckFailed("Intrinsic parameter #" + utostr(ArgNo-1) + " does not "
- "match return type.", F);
- break;
- }
- } else {
- if (Ty != FTy->getParamType(Match-1)) {
- CheckFailed("Intrinsic parameter #" + utostr(ArgNo-1) + " does not "
- "match parameter %" + utostr(Match-1) + ".", F);
- break;
- }
- }
- } 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);
- break;
- }
- unsigned GotBits = cast<IntegerType>(EltTy)->getBitWidth();
- Suffix += ".";
- if (EltTy != Ty)
- Suffix += "v" + utostr(NumElts);
- Suffix += "i" + utostr(GotBits);;
- // Check some constraints on various intrinsics.
- switch (ID) {
- default: break; // Not everything needs to be checked.
- case Intrinsic::bswap:
- if (GotBits < 16 || GotBits % 16 != 0)
- CheckFailed("Intrinsic requires even byte width argument", F);
- 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);
- break;
- }
- Suffix += ".";
- if (EltTy != Ty)
- Suffix += "v" + utostr(NumElts);
- 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);
- }
- } else if (VT == MVT::iPTRAny) {
- // Outside of TableGen, we don't distinguish iPTRAny (to any address
- // space) and iPTR. In the verifier, we can not distinguish which case
- // we have so allow either case to be legal.
- if (const PointerType* PTyp = dyn_cast<PointerType>(Ty)) {
- 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);
- break;
- }
- } else if (MVT((MVT::SimpleValueType)VT).isVector()) {
- MVT VVT = MVT((MVT::SimpleValueType)VT);
- // If this is a vector argument, verify the number and type of elements.
- if (VVT.getVectorElementType() != MVT::getMVT(EltTy)) {
- CheckFailed("Intrinsic prototype has incorrect vector element type!",
- F);
- break;
- }
- if (VVT.getVectorNumElements() != NumElts) {
- CheckFailed("Intrinsic prototype has incorrect number of "
- "vector elements!",F);
- break;
- }
- } 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);
+ if (!PerformTypeCheck(ID, F, FTy->getParamType(ArgNo), VT, ArgNo + RetNum,
+ Suffix))
break;
- } 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);
- }
}
va_end(VA);
projects / oota-llvm.git / blobdiff