X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FVerifier.cpp;h=99a5b92e5ffbbfd6c1249e16722102b30ff0f0a4;hb=d24479730a8790d82c4859dc477bc2416d7a6bda;hp=3d6832475f6d78f9156e881fee26113d994f5113;hpb=d15d5e3bbe94702101f747326f3035e7409d2a7f;p=oota-llvm.git diff --git a/lib/VMCore/Verifier.cpp b/lib/VMCore/Verifier.cpp index 3d6832475f6..99a5b92e5ff 100644 --- a/lib/VMCore/Verifier.cpp +++ b/lib/VMCore/Verifier.cpp @@ -21,7 +21,7 @@ // * The code is in valid SSA form // * It should be illegal to put a label into any other type (like a structure) // or to return one. [except constant arrays!] -// * Only phi nodes can be self referential: 'add int %0, %0 ; :0' is bad +// * Only phi nodes can be self referential: 'add i32 %0, %0 ; :0' is bad // * PHI nodes must have an entry for each predecessor, with no extras. // * PHI nodes must be the first thing in a basic block, all grouped together // * PHI nodes must have at least one entry @@ -40,18 +40,17 @@ //===----------------------------------------------------------------------===// #include "llvm/Analysis/Verifier.h" -#include "llvm/Assembly/Writer.h" #include "llvm/CallingConv.h" #include "llvm/Constants.h" -#include "llvm/Pass.h" -#include "llvm/Module.h" -#include "llvm/ModuleProvider.h" -#include "llvm/ParamAttrsList.h" #include "llvm/DerivedTypes.h" #include "llvm/InlineAsm.h" #include "llvm/IntrinsicInst.h" +#include "llvm/Module.h" +#include "llvm/ModuleProvider.h" +#include "llvm/Pass.h" #include "llvm/PassManager.h" #include "llvm/Analysis/Dominators.h" +#include "llvm/Assembly/Writer.h" #include "llvm/CodeGen/ValueTypes.h" #include "llvm/Support/CallSite.h" #include "llvm/Support/CFG.h" @@ -71,7 +70,11 @@ namespace { // Anonymous namespace for class struct VISIBILITY_HIDDEN PreVerifier : public FunctionPass { static char ID; // Pass ID, replacement for typeid - PreVerifier() : FunctionPass((intptr_t)&ID) { } + PreVerifier() : FunctionPass(&ID) { } + + virtual void getAnalysisUsage(AnalysisUsage &AU) const { + AU.setPreservesAll(); + } // Check that the prerequisites for successful DominatorTree construction // are satisfied. @@ -93,11 +96,14 @@ namespace { // Anonymous namespace for class return false; } }; +} - char PreVerifier::ID = 0; - RegisterPass PreVer("preverify", "Preliminary module verification"); - const PassInfo *PreVerifyID = PreVer.getPassInfo(); +char PreVerifier::ID = 0; +static RegisterPass +PreVer("preverify", "Preliminary module verification"); +static const PassInfo *const PreVerifyID = &PreVer; +namespace { struct VISIBILITY_HIDDEN Verifier : public FunctionPass, InstVisitor { static char ID; // Pass ID, replacement for typeid @@ -116,20 +122,20 @@ namespace { // Anonymous namespace for class SmallPtrSet InstsInThisBlock; Verifier() - : FunctionPass((intptr_t)&ID), + : FunctionPass(&ID), Broken(false), RealPass(true), action(AbortProcessAction), DT(0), msgs( std::ios::app | std::ios::out ) {} - Verifier( VerifierFailureAction ctn ) - : FunctionPass((intptr_t)&ID), + explicit Verifier(VerifierFailureAction ctn) + : FunctionPass(&ID), Broken(false), RealPass(true), action(ctn), DT(0), msgs( std::ios::app | std::ios::out ) {} - Verifier(bool AB ) - : FunctionPass((intptr_t)&ID), + explicit Verifier(bool AB) + : FunctionPass(&ID), Broken(false), RealPass(true), action( AB ? AbortProcessAction : PrintMessageAction), DT(0), msgs( std::ios::app | std::ios::out ) {} - Verifier(DominatorTree &dt) - : FunctionPass((intptr_t)&ID), + explicit Verifier(DominatorTree &dt) + : FunctionPass(&ID), Broken(false), RealPass(false), action(PrintMessageAction), DT(&dt), msgs( std::ios::app | std::ios::out ) {} @@ -196,23 +202,22 @@ namespace { // Anonymous namespace for class /// this condition, do so. /// bool abortIfBroken() { - if (Broken) { - msgs << "Broken module found, "; - switch (action) { - case AbortProcessAction: - msgs << "compilation aborted!\n"; - cerr << msgs.str(); - abort(); - case PrintMessageAction: - msgs << "verification continues.\n"; - cerr << msgs.str(); - return false; - case ReturnStatusAction: - msgs << "compilation terminated.\n"; - return Broken; - } + if (!Broken) return false; + msgs << "Broken module found, "; + switch (action) { + default: assert(0 && "Unknown action"); + case AbortProcessAction: + msgs << "compilation aborted!\n"; + cerr << msgs.str(); + abort(); + case PrintMessageAction: + msgs << "verification continues.\n"; + cerr << msgs.str(); + return false; + case ReturnStatusAction: + msgs << "compilation terminated.\n"; + return Broken; } - return false; } @@ -223,6 +228,10 @@ namespace { // Anonymous namespace for class void visitGlobalAlias(GlobalAlias &GA); void visitFunction(Function &F); void visitBasicBlock(BasicBlock &BB); + using InstVisitor::visit; + + void visit(Instruction &I); + void visitTruncInst(TruncInst &I); void visitZExtInst(ZExtInst &I); void visitSExtInst(SExtInst &I); @@ -257,14 +266,17 @@ namespace { // Anonymous namespace for class void visitUserOp2(Instruction &I) { visitUserOp1(I); } void visitIntrinsicFunctionCall(Intrinsic::ID ID, CallInst &CI); void visitAllocationInst(AllocationInst &AI); - void visitGetResultInst(GetResultInst &GRI); + void visitExtractValueInst(ExtractValueInst &EVI); + 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, ...); - void VerifyAttrs(ParameterAttributes Attrs, const Type *Ty, + unsigned RetNum, unsigned ParamNum, ...); + void VerifyAttrs(Attributes Attrs, const Type *Ty, bool isReturnValue, const Value *V); - void VerifyFunctionAttrs(const FunctionType *FT, const ParamAttrsList *Attrs, + void VerifyFunctionAttrs(const FunctionType *FT, const AttrListPtr &Attrs, const Value *V); void WriteValue(const Value *V) { @@ -277,7 +289,7 @@ namespace { // Anonymous namespace for class } } - void WriteType(const Type* T ) { + void WriteType(const Type *T) { if ( !T ) return; WriteTypeSymbolic(msgs, T, Mod ); } @@ -306,11 +318,10 @@ namespace { // Anonymous namespace for class Broken = true; } }; - - char Verifier::ID = 0; - RegisterPass X("verify", "Module Verifier"); } // End anonymous namespace +char Verifier::ID = 0; +static RegisterPass X("verify", "Module Verifier"); // Assert - We know that cond should be true, if not print an error message. #define Assert(C, M) \ @@ -325,13 +336,21 @@ namespace { // Anonymous namespace for class do { if (!(C)) { CheckFailed(M, V1, V2, V3, V4); return; } } while (0) +void Verifier::visit(Instruction &I) { + for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i) + Assert1(I.getOperand(i) != 0, "Operand is null", &I); + InstVisitor::visit(I); +} + + void Verifier::visitGlobalValue(GlobalValue &GV) { Assert1(!GV.isDeclaration() || GV.hasExternalLinkage() || GV.hasDLLImportLinkage() || GV.hasExternalWeakLinkage() || + GV.hasGhostLinkage() || (isa(GV) && - (GV.hasInternalLinkage() || GV.hasWeakLinkage())), + (GV.hasLocalLinkage() || GV.hasWeakLinkage())), "Global is external, but doesn't have external or dllimport or weak linkage!", &GV); @@ -365,12 +384,14 @@ void Verifier::visitGlobalVariable(GlobalVariable &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(), + "Aliasee cannot be NULL!", &GA); Assert1(GA.getType() == GA.getAliasee()->getType(), "Alias and aliasee types should match!", &GA); - + if (!isa(GA.getAliasee())) { const ConstantExpr *CE = dyn_cast(GA.getAliasee()); Assert1(CE && CE->getOpcode() == Instruction::BitCast && @@ -378,7 +399,11 @@ void Verifier::visitGlobalAlias(GlobalAlias &GA) { "Aliasee should be either GlobalValue or bitcast of GlobalValue", &GA); } - + + const GlobalValue* Aliasee = GA.resolveAliasedGlobal(/*stopOnWeak*/ false); + Assert1(Aliasee, + "Aliasing chain should end with function or global variable", &GA); + visitGlobalValue(GA); } @@ -387,59 +412,101 @@ void Verifier::verifyTypeSymbolTable(TypeSymbolTable &ST) { // VerifyAttrs - Check the given parameter attributes for an argument or return // value of the specified type. The value V is printed in error messages. -void Verifier::VerifyAttrs(ParameterAttributes Attrs, const Type *Ty, +void Verifier::VerifyAttrs(Attributes Attrs, const Type *Ty, bool isReturnValue, const Value *V) { - if (Attrs == ParamAttr::None) + if (Attrs == Attribute::None) return; if (isReturnValue) { - ParameterAttributes RetI = Attrs & ParamAttr::ParameterOnly; - Assert1(!RetI, "Attribute " + ParamAttrsList::getParamAttrsText(RetI) + - "does not apply to return values!", V); - } else { - ParameterAttributes ParmI = Attrs & ParamAttr::ReturnOnly; - Assert1(!ParmI, "Attribute " + ParamAttrsList::getParamAttrsText(ParmI) + - "only applies to return values!", V); + Attributes RetI = Attrs & Attribute::ParameterOnly; + Assert1(!RetI, "Attribute " + Attribute::getAsString(RetI) + + " does not apply to return values!", V); } - + Attributes FnCheckAttr = Attrs & Attribute::FunctionOnly; + Assert1(!FnCheckAttr, "Attribute " + Attribute::getAsString(FnCheckAttr) + + " only applies to functions!", V); + for (unsigned i = 0; - i < array_lengthof(ParamAttr::MutuallyIncompatible); ++i) { - ParameterAttributes MutI = Attrs & ParamAttr::MutuallyIncompatible[i]; + i < array_lengthof(Attribute::MutuallyIncompatible); ++i) { + Attributes MutI = Attrs & Attribute::MutuallyIncompatible[i]; Assert1(!(MutI & (MutI - 1)), "Attributes " + - ParamAttrsList::getParamAttrsText(MutI) + "are incompatible!", V); + Attribute::getAsString(MutI) + " are incompatible!", V); } - ParameterAttributes TypeI = Attrs & ParamAttr::typeIncompatible(Ty); + Attributes TypeI = Attrs & Attribute::typeIncompatible(Ty); Assert1(!TypeI, "Wrong type for attribute " + - ParamAttrsList::getParamAttrsText(TypeI), V); + Attribute::getAsString(TypeI), V); + + Attributes ByValI = Attrs & Attribute::ByVal; + if (const PointerType *PTy = dyn_cast(Ty)) { + Assert1(!ByValI || PTy->getElementType()->isSized(), + "Attribute " + Attribute::getAsString(ByValI) + + " does not support unsized types!", V); + } else { + Assert1(!ByValI, + "Attribute " + Attribute::getAsString(ByValI) + + " only applies to parameters with pointer type!", V); + } } // VerifyFunctionAttrs - Check parameter attributes against a function type. // The value V is printed in error messages. void Verifier::VerifyFunctionAttrs(const FunctionType *FT, - const ParamAttrsList *Attrs, + const AttrListPtr &Attrs, const Value *V) { - if (!Attrs) + if (Attrs.isEmpty()) return; bool SawNest = false; - for (unsigned Idx = 0; Idx <= FT->getNumParams(); ++Idx) { - ParameterAttributes Attr = Attrs->getParamAttrs(Idx); + for (unsigned i = 0, e = Attrs.getNumSlots(); i != e; ++i) { + const AttributeWithIndex &Attr = Attrs.getSlot(i); - VerifyAttrs(Attr, FT->getParamType(Idx-1), !Idx, V); + const Type *Ty; + if (Attr.Index == 0) + Ty = FT->getReturnType(); + else if (Attr.Index-1 < FT->getNumParams()) + Ty = FT->getParamType(Attr.Index-1); + else + break; // VarArgs attributes, don't verify. + + VerifyAttrs(Attr.Attrs, Ty, Attr.Index == 0, V); - if (Attr & ParamAttr::Nest) { + if (Attr.Attrs & Attribute::Nest) { Assert1(!SawNest, "More than one parameter has attribute nest!", V); SawNest = true; } - if (Attr & ParamAttr::StructRet) { - Assert1(Idx == 1, "Attribute sret not on first parameter!", V); - } + if (Attr.Attrs & Attribute::StructRet) + Assert1(Attr.Index == 1, "Attribute sret not on first parameter!", V); + } + + Attributes FAttrs = Attrs.getFnAttributes(); + Assert1(!(FAttrs & (~Attribute::FunctionOnly)), + "Attribute " + Attribute::getAsString(FAttrs) + + " does not apply to function!", V); + + for (unsigned i = 0; + i < array_lengthof(Attribute::MutuallyIncompatible); ++i) { + Attributes MutI = FAttrs & Attribute::MutuallyIncompatible[i]; + Assert1(!(MutI & (MutI - 1)), "Attributes " + + Attribute::getAsString(MutI) + " are incompatible!", V); } } +static bool VerifyAttributeCount(const AttrListPtr &Attrs, unsigned Params) { + if (Attrs.isEmpty()) + return true; + + unsigned LastSlot = Attrs.getNumSlots() - 1; + unsigned LastIndex = Attrs.getSlot(LastSlot).Index; + if (LastIndex <= Params + || (LastIndex == (unsigned)~0 + && (LastSlot == 0 || Attrs.getSlot(LastSlot - 1).Index <= Params))) + return true; + + return false; +} // visitFunction - Verify that a function is ok. // void Verifier::visitFunction(Function &F) { @@ -455,11 +522,12 @@ void Verifier::visitFunction(Function &F) { isa(F.getReturnType()), "Functions cannot return aggregate values!", &F); - const ParamAttrsList *Attrs = F.getParamAttrs(); + Assert1(!F.hasStructRetAttr() || F.getReturnType() == Type::VoidTy, + "Invalid struct return type!", &F); + + const AttrListPtr &Attrs = F.getAttributes(); - Assert1(!Attrs || - (Attrs->size() && - Attrs->getParamIndex(Attrs->size()-1) <= FT->getNumParams()), + Assert1(VerifyAttributeCount(Attrs, FT->getNumParams()), "Attributes after last parameter!", &F); // Check function attributes. @@ -486,14 +554,13 @@ void Verifier::visitFunction(Function &F) { Assert2(I->getType() == FT->getParamType(i), "Argument value does not match function argument type!", I, FT->getParamType(i)); - // Make sure no aggregates are passed by value. Assert1(I->getType()->isFirstClassType(), - "Functions cannot take aggregates as arguments by value!", I); - } + "Function arguments must have first-class types!", I); + } if (F.isDeclaration()) { Assert1(F.hasExternalLinkage() || F.hasDLLImportLinkage() || - F.hasExternalWeakLinkage(), + F.hasExternalWeakLinkage() || F.hasGhostLinkage(), "invalid linkage type for function declaration", &F); } else { // Verify that this function (which has a body) is not named "llvm.*". It @@ -574,22 +641,35 @@ void Verifier::visitTerminatorInst(TerminatorInst &I) { void Verifier::visitReturnInst(ReturnInst &RI) { Function *F = RI.getParent()->getParent(); unsigned N = RI.getNumOperands(); - if (N == 0) - Assert2(F->getReturnType() == Type::VoidTy, - "Found return instr that returns void in Function of non-void " + if (F->getReturnType() == Type::VoidTy) + Assert2(N == 0, + "Found return instr that returns non-void in Function of void " "return type!", &RI, F->getReturnType()); - else if (N == 1) - Assert2(F->getReturnType() == RI.getOperand(0)->getType(), - "Function return type does not match operand " - "type of return inst!", &RI, F->getReturnType()); - else if (const StructType *STy = dyn_cast(F->getReturnType())) { - for (unsigned i = 0; i < N; i++) + else if (N == 1 && F->getReturnType() == RI.getOperand(0)->getType()) { + // Exactly one return value and it matches the return type. Good. + } else if (const StructType *STy = dyn_cast(F->getReturnType())) { + // The return type is a struct; check for multiple return values. + Assert2(STy->getNumElements() == N, + "Incorrect number of return values in ret instruction!", + &RI, F->getReturnType()); + for (unsigned i = 0; i != N; ++i) Assert2(STy->getElementType(i) == RI.getOperand(i)->getType(), "Function return type does not match operand " "type of return inst!", &RI, F->getReturnType()); - } else - Assert1(0, "Invalid return type!", &RI); - + } else if (const ArrayType *ATy = dyn_cast(F->getReturnType())) { + // The return type is an array; check for multiple return values. + Assert2(ATy->getNumElements() == N, + "Incorrect number of return values in ret instruction!", + &RI, F->getReturnType()); + for (unsigned i = 0; i != N; ++i) + Assert2(ATy->getElementType() == RI.getOperand(i)->getType(), + "Function return type does not match operand " + "type of return inst!", &RI, F->getReturnType()); + } else { + CheckFailed("Function return type does not match operand " + "type of return inst!", &RI, F->getReturnType()); + } + // Check to make sure that the return value has necessary properties for // terminators... visitTerminatorInst(RI); @@ -607,10 +687,10 @@ void Verifier::visitSwitchInst(SwitchInst &SI) { } void Verifier::visitSelectInst(SelectInst &SI) { - 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); @@ -633,8 +713,10 @@ void Verifier::visitTruncInst(TruncInst &I) { unsigned SrcBitSize = SrcTy->getPrimitiveSizeInBits(); unsigned DestBitSize = DestTy->getPrimitiveSizeInBits(); - Assert1(SrcTy->isInteger(), "Trunc only operates on integer", &I); - Assert1(DestTy->isInteger(), "Trunc only produces integer", &I); + Assert1(SrcTy->isIntOrIntVector(), "Trunc only operates on integer", &I); + Assert1(DestTy->isIntOrIntVector(), "Trunc only produces integer", &I); + Assert1(isa(SrcTy) == isa(DestTy), + "trunc source and destination must both be a vector or neither", &I); Assert1(SrcBitSize > DestBitSize,"DestTy too big for Trunc", &I); visitInstruction(I); @@ -646,8 +728,10 @@ void Verifier::visitZExtInst(ZExtInst &I) { const Type *DestTy = I.getType(); // Get the size of the types in bits, we'll need this later - Assert1(SrcTy->isInteger(), "ZExt only operates on integer", &I); - Assert1(DestTy->isInteger(), "ZExt only produces an integer", &I); + Assert1(SrcTy->isIntOrIntVector(), "ZExt only operates on integer", &I); + Assert1(DestTy->isIntOrIntVector(), "ZExt only produces an integer", &I); + Assert1(isa(SrcTy) == isa(DestTy), + "zext source and destination must both be a vector or neither", &I); unsigned SrcBitSize = SrcTy->getPrimitiveSizeInBits(); unsigned DestBitSize = DestTy->getPrimitiveSizeInBits(); @@ -665,8 +749,10 @@ void Verifier::visitSExtInst(SExtInst &I) { unsigned SrcBitSize = SrcTy->getPrimitiveSizeInBits(); unsigned DestBitSize = DestTy->getPrimitiveSizeInBits(); - Assert1(SrcTy->isInteger(), "SExt only operates on integer", &I); - Assert1(DestTy->isInteger(), "SExt only produces an integer", &I); + Assert1(SrcTy->isIntOrIntVector(), "SExt only operates on integer", &I); + Assert1(DestTy->isIntOrIntVector(), "SExt only produces an integer", &I); + Assert1(isa(SrcTy) == isa(DestTy), + "sext source and destination must both be a vector or neither", &I); Assert1(SrcBitSize < DestBitSize,"Type too small for SExt", &I); visitInstruction(I); @@ -680,8 +766,10 @@ void Verifier::visitFPTruncInst(FPTruncInst &I) { unsigned SrcBitSize = SrcTy->getPrimitiveSizeInBits(); unsigned DestBitSize = DestTy->getPrimitiveSizeInBits(); - Assert1(SrcTy->isFloatingPoint(),"FPTrunc only operates on FP", &I); - Assert1(DestTy->isFloatingPoint(),"FPTrunc only produces an FP", &I); + Assert1(SrcTy->isFPOrFPVector(),"FPTrunc only operates on FP", &I); + Assert1(DestTy->isFPOrFPVector(),"FPTrunc only produces an FP", &I); + Assert1(isa(SrcTy) == isa(DestTy), + "fptrunc source and destination must both be a vector or neither",&I); Assert1(SrcBitSize > DestBitSize,"DestTy too big for FPTrunc", &I); visitInstruction(I); @@ -696,8 +784,10 @@ void Verifier::visitFPExtInst(FPExtInst &I) { unsigned SrcBitSize = SrcTy->getPrimitiveSizeInBits(); unsigned DestBitSize = DestTy->getPrimitiveSizeInBits(); - Assert1(SrcTy->isFloatingPoint(),"FPExt only operates on FP", &I); - Assert1(DestTy->isFloatingPoint(),"FPExt only produces an FP", &I); + Assert1(SrcTy->isFPOrFPVector(),"FPExt only operates on FP", &I); + Assert1(DestTy->isFPOrFPVector(),"FPExt only produces an FP", &I); + Assert1(isa(SrcTy) == isa(DestTy), + "fpext source and destination must both be a vector or neither", &I); Assert1(SrcBitSize < DestBitSize,"DestTy too small for FPExt", &I); visitInstruction(I); @@ -708,15 +798,19 @@ void Verifier::visitUIToFPInst(UIToFPInst &I) { const Type *SrcTy = I.getOperand(0)->getType(); const Type *DestTy = I.getType(); - bool SrcVec = SrcTy->getTypeID() == Type::VectorTyID; - bool DstVec = DestTy->getTypeID() == Type::VectorTyID; + bool SrcVec = isa(SrcTy); + bool DstVec = isa(DestTy); - Assert1(SrcVec == DstVec,"UIToFP source and dest must both be vector or scalar", &I); - Assert1(SrcTy->isIntOrIntVector(),"UIToFP source must be integer or integer vector", &I); - Assert1(DestTy->isFPOrFPVector(),"UIToFP result must be FP or FP vector", &I); + Assert1(SrcVec == DstVec, + "UIToFP source and dest must both be vector or scalar", &I); + Assert1(SrcTy->isIntOrIntVector(), + "UIToFP source must be integer or integer vector", &I); + Assert1(DestTy->isFPOrFPVector(), + "UIToFP result must be FP or FP vector", &I); if (SrcVec && DstVec) - Assert1(cast(SrcTy)->getNumElements() == cast(DestTy)->getNumElements(), + Assert1(cast(SrcTy)->getNumElements() == + cast(DestTy)->getNumElements(), "UIToFP source and dest vector length mismatch", &I); visitInstruction(I); @@ -730,12 +824,16 @@ void Verifier::visitSIToFPInst(SIToFPInst &I) { bool SrcVec = SrcTy->getTypeID() == Type::VectorTyID; bool DstVec = DestTy->getTypeID() == Type::VectorTyID; - Assert1(SrcVec == DstVec,"SIToFP source and dest must both be vector or scalar", &I); - Assert1(SrcTy->isIntOrIntVector(),"SIToFP source must be integer or integer vector", &I); - Assert1(DestTy->isFPOrFPVector(),"SIToFP result must be FP or FP vector", &I); + Assert1(SrcVec == DstVec, + "SIToFP source and dest must both be vector or scalar", &I); + Assert1(SrcTy->isIntOrIntVector(), + "SIToFP source must be integer or integer vector", &I); + Assert1(DestTy->isFPOrFPVector(), + "SIToFP result must be FP or FP vector", &I); if (SrcVec && DstVec) - Assert1(cast(SrcTy)->getNumElements() == cast(DestTy)->getNumElements(), + Assert1(cast(SrcTy)->getNumElements() == + cast(DestTy)->getNumElements(), "SIToFP source and dest vector length mismatch", &I); visitInstruction(I); @@ -746,15 +844,18 @@ void Verifier::visitFPToUIInst(FPToUIInst &I) { const Type *SrcTy = I.getOperand(0)->getType(); const Type *DestTy = I.getType(); - bool SrcVec = SrcTy->getTypeID() == Type::VectorTyID; - bool DstVec = DestTy->getTypeID() == Type::VectorTyID; + bool SrcVec = isa(SrcTy); + bool DstVec = isa(DestTy); - Assert1(SrcVec == DstVec,"FPToUI source and dest must both be vector or scalar", &I); - Assert1(SrcTy->isFPOrFPVector(),"FPToUI source must be FP or FP vector", &I); - Assert1(DestTy->isIntOrIntVector(),"FPToUI result must be integer or integer vector", &I); + Assert1(SrcVec == DstVec, + "FPToUI source and dest must both be vector or scalar", &I); + Assert1(SrcTy->isFPOrFPVector(), "FPToUI source must be FP or FP vector", &I); + Assert1(DestTy->isIntOrIntVector(), + "FPToUI result must be integer or integer vector", &I); if (SrcVec && DstVec) - Assert1(cast(SrcTy)->getNumElements() == cast(DestTy)->getNumElements(), + Assert1(cast(SrcTy)->getNumElements() == + cast(DestTy)->getNumElements(), "FPToUI source and dest vector length mismatch", &I); visitInstruction(I); @@ -765,15 +866,19 @@ void Verifier::visitFPToSIInst(FPToSIInst &I) { const Type *SrcTy = I.getOperand(0)->getType(); const Type *DestTy = I.getType(); - bool SrcVec = SrcTy->getTypeID() == Type::VectorTyID; - bool DstVec = DestTy->getTypeID() == Type::VectorTyID; + bool SrcVec = isa(SrcTy); + bool DstVec = isa(DestTy); - Assert1(SrcVec == DstVec,"FPToSI source and dest must both be vector or scalar", &I); - Assert1(SrcTy->isFPOrFPVector(),"FPToSI source must be FP or FP vector", &I); - Assert1(DestTy->isIntOrIntVector(),"FPToSI result must be integer or integer vector", &I); + Assert1(SrcVec == DstVec, + "FPToSI source and dest must both be vector or scalar", &I); + Assert1(SrcTy->isFPOrFPVector(), + "FPToSI source must be FP or FP vector", &I); + Assert1(DestTy->isIntOrIntVector(), + "FPToSI result must be integer or integer vector", &I); if (SrcVec && DstVec) - Assert1(cast(SrcTy)->getNumElements() == cast(DestTy)->getNumElements(), + Assert1(cast(SrcTy)->getNumElements() == + cast(DestTy)->getNumElements(), "FPToSI source and dest vector length mismatch", &I); visitInstruction(I); @@ -816,6 +921,12 @@ void Verifier::visitBitCastInst(BitCastInst &I) { "Bitcast requires both operands to be pointer or neither", &I); Assert1(SrcBitSize == DestBitSize, "Bitcast requies types of same width", &I); + // Disallow aggregates. + Assert1(!SrcTy->isAggregateType(), + "Bitcast operand must not be aggregate", &I); + Assert1(!DestTy->isAggregateType(), + "Bitcast type must not be aggregate", &I); + visitInstruction(I); } @@ -867,26 +978,24 @@ void Verifier::VerifyCallSite(CallSite CS) { "Call parameter type does not match function signature!", CS.getArgument(i), FTy->getParamType(i), I); - const ParamAttrsList *Attrs = CS.getParamAttrs(); + const AttrListPtr &Attrs = CS.getAttributes(); - Assert1(!Attrs || - (Attrs->size() && - Attrs->getParamIndex(Attrs->size()-1) <= CS.arg_size()), - "Attributes after last argument!", I); + Assert1(VerifyAttributeCount(Attrs, CS.arg_size()), + "Attributes after last parameter!", I); // Verify call attributes. VerifyFunctionAttrs(FTy, Attrs, I); - if (Attrs && FTy->isVarArg()) + if (FTy->isVarArg()) // Check attributes on the varargs part. for (unsigned Idx = 1 + FTy->getNumParams(); Idx <= CS.arg_size(); ++Idx) { - ParameterAttributes Attr = Attrs->getParamAttrs(Idx); + Attributes Attr = Attrs.getParamAttributes(Idx); VerifyAttrs(Attr, CS.getArgument(Idx-1)->getType(), false, I); - ParameterAttributes VArgI = Attr & ParamAttr::VarArgsIncompatible; - Assert1(!VArgI, "Attribute " + ParamAttrsList::getParamAttrsText(VArgI) + - "cannot be used for vararg call arguments!", I); + Attributes VArgI = Attr & Attribute::VarArgsIncompatible; + Assert1(!VArgI, "Attribute " + Attribute::getAsString(VArgI) + + " cannot be used for vararg call arguments!", I); } visitInstruction(*I); @@ -895,10 +1004,9 @@ void Verifier::VerifyCallSite(CallSite CS) { 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) { @@ -928,8 +1036,10 @@ void Verifier::visitBinaryOperator(BinaryOperator &B) { case Instruction::Shl: case Instruction::LShr: case Instruction::AShr: - Assert1(B.getType()->isInteger(), - "Shift must return an integer result!", &B); + Assert1(B.getType()->isInteger() || + (isa(B.getType()) && + cast(B.getType())->getElementType()->isInteger()), + "Shifts only work with integral types!", &B); Assert1(B.getType() == B.getOperand(0)->getType(), "Shift return type must be same as operands!", &B); /* FALL THROUGH */ @@ -954,7 +1064,7 @@ void Verifier::visitICmpInst(ICmpInst& IC) { Assert1(Op0Ty == Op1Ty, "Both operands to ICmp instruction are not of the same type!", &IC); // Check that the operands are the right type - Assert1(Op0Ty->isInteger() || isa(Op0Ty), + Assert1(Op0Ty->isIntOrIntVector() || isa(Op0Ty), "Invalid operand types for ICmp instruction", &IC); visitInstruction(IC); } @@ -966,7 +1076,7 @@ void Verifier::visitFCmpInst(FCmpInst& FC) { Assert1(Op0Ty == Op1Ty, "Both operands to FCmp instruction are not of the same type!", &FC); // Check that the operands are the right type - Assert1(Op0Ty->isFloatingPoint(), + Assert1(Op0Ty->isFPOrFPVector(), "Invalid operand types for FCmp instruction", &FC); visitInstruction(FC); } @@ -990,22 +1100,27 @@ void Verifier::visitShuffleVectorInst(ShuffleVectorInst &SV) { Assert1(ShuffleVectorInst::isValidOperands(SV.getOperand(0), SV.getOperand(1), SV.getOperand(2)), "Invalid shufflevector operands!", &SV); - Assert1(SV.getType() == SV.getOperand(0)->getType(), - "Result of shufflevector must match first operand type!", &SV); - + + const VectorType *VTy = dyn_cast(SV.getOperand(0)->getType()); + Assert1(VTy, "Operands are not a vector type", &SV); + // Check to see if Mask is valid. if (const ConstantVector *MV = dyn_cast(SV.getOperand(2))) { for (unsigned i = 0, e = MV->getNumOperands(); i != e; ++i) { - Assert1(isa(MV->getOperand(i)) || - isa(MV->getOperand(i)), - "Invalid shufflevector shuffle mask!", &SV); + if (ConstantInt* CI = dyn_cast(MV->getOperand(i))) { + Assert1(!CI->uge(VTy->getNumElements()*2), + "Invalid shufflevector shuffle mask!", &SV); + } else { + Assert1(isa(MV->getOperand(i)), + "Invalid shufflevector shuffle mask!", &SV); + } } } else { Assert1(isa(SV.getOperand(2)) || isa(SV.getOperand(2)), "Invalid shufflevector shuffle mask!", &SV); } - + visitInstruction(SV); } @@ -1013,7 +1128,7 @@ void Verifier::visitGetElementPtrInst(GetElementPtrInst &GEP) { SmallVector Idxs(GEP.idx_begin(), GEP.idx_end()); const Type *ElTy = GetElementPtrInst::getIndexedType(GEP.getOperand(0)->getType(), - Idxs.begin(), Idxs.end(), true); + Idxs.begin(), Idxs.end()); Assert1(ElTy, "Invalid indices for GEP pointer type!", &GEP); Assert2(isa(GEP.getType()) && cast(GEP.getType())->getElementType() == ElTy, @@ -1047,12 +1162,23 @@ void Verifier::visitAllocationInst(AllocationInst &AI) { visitInstruction(AI); } -void Verifier::visitGetResultInst(GetResultInst &GRI) { - Assert1(GRI.isValidOperands(GRI.getAggregateValue(), GRI.getIndex()), - "Invalid GetResultInst operands!", &GRI); - visitInstruction(GRI); +void Verifier::visitExtractValueInst(ExtractValueInst &EVI) { + Assert1(ExtractValueInst::getIndexedType(EVI.getAggregateOperand()->getType(), + EVI.idx_begin(), EVI.idx_end()) == + EVI.getType(), + "Invalid ExtractValueInst operands!", &EVI); + + visitInstruction(EVI); } +void Verifier::visitInsertValueInst(InsertValueInst &IVI) { + Assert1(ExtractValueInst::getIndexedType(IVI.getAggregateOperand()->getType(), + IVI.idx_begin(), IVI.idx_end()) == + IVI.getOperand(1)->getType(), + "Invalid InsertValueInst operands!", &IVI); + + visitInstruction(IVI); +} /// verifyInstruction - Verify that an instruction is well formed. /// @@ -1102,20 +1228,7 @@ void Verifier::visitInstruction(Instruction &I) { // Check to make sure that only first-class-values are operands to // instructions. if (!I.getOperand(i)->getType()->isFirstClassType()) { - if (isa(I) || isa(I)) - Assert1(isa(I.getOperand(i)->getType()), - "Invalid ReturnInst operands!", &I); - else if (isa(I) || isa(I)) { - if (const PointerType *PT = dyn_cast - (I.getOperand(i)->getType())) { - const Type *ETy = PT->getElementType(); - Assert1(isa(ETy), "Invalid CallInst operands!", &I); - } - else - Assert1(0, "Invalid CallInst operands!", &I); - } - else - Assert1(0, "Instruction operands must be first-class values!", &I); + Assert1(0, "Instruction operands must be first-class values!", &I); } if (Function *F = dyn_cast(I.getOperand(i))) { @@ -1190,7 +1303,7 @@ void Verifier::visitInstruction(Instruction &I) { } // Definition must dominate use unless use is unreachable! - Assert2(DT->dominates(OpBlock, BB) || + Assert2(InstsInThisBlock.count(Op) || DT->dominates(Op, &I) || !DT->dominates(&BB->getParent()->getEntryBlock(), BB), "Instruction does not dominate all uses!", Op, &I); } else { @@ -1209,6 +1322,11 @@ void Verifier::visitInstruction(Instruction &I) { 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) { @@ -1223,63 +1341,220 @@ void Verifier::visitIntrinsicFunctionCall(Intrinsic::ID ID, CallInst &CI) { switch (ID) { default: break; + case Intrinsic::dbg_declare: // llvm.dbg.declare + if (Constant *C = dyn_cast(CI.getOperand(1))) + Assert1(C && !isa(C), + "invalid llvm.dbg.declare intrinsic call", &CI); + break; + case Intrinsic::memcpy: + case Intrinsic::memmove: + case Intrinsic::memset: + Assert1(isa(CI.getOperand(4)), + "alignment argument of memory intrinsics must be a constant int", + &CI); + break; case Intrinsic::gcroot: case Intrinsic::gcwrite: - case Intrinsic::gcread: { - Type *PtrTy = PointerType::getUnqual(Type::Int8Ty), - *PtrPtrTy = PointerType::getUnqual(PtrTy); - - switch (ID) { - default: - break; - case Intrinsic::gcroot: - Assert1(CI.getOperand(1)->getType() == PtrPtrTy, - "Intrinsic parameter #1 is not i8**.", &CI); - Assert1(CI.getOperand(2)->getType() == PtrTy, - "Intrinsic parameter #2 is not i8*.", &CI); - Assert1(isa( - IntrinsicInst::StripPointerCasts(CI.getOperand(1))), - "llvm.gcroot parameter #1 must be an alloca.", &CI); - Assert1(isa(CI.getOperand(2)), - "llvm.gcroot parameter #2 must be a constant.", &CI); - break; - case Intrinsic::gcwrite: - Assert1(CI.getOperand(1)->getType() == PtrTy, - "Intrinsic parameter #1 is not a i8*.", &CI); - Assert1(CI.getOperand(2)->getType() == PtrTy, - "Intrinsic parameter #2 is not a i8*.", &CI); - Assert1(CI.getOperand(3)->getType() == PtrPtrTy, - "Intrinsic parameter #3 is not a i8**.", &CI); - break; - case Intrinsic::gcread: - Assert1(CI.getOperand(1)->getType() == PtrTy, - "Intrinsic parameter #1 is not a i8*.", &CI); - Assert1(CI.getOperand(2)->getType() == PtrPtrTy, - "Intrinsic parameter #2 is not a i8**.", &CI); - break; - } + case Intrinsic::gcread: + if (ID == Intrinsic::gcroot) { + AllocaInst *AI = + dyn_cast(CI.getOperand(1)->stripPointerCasts()); + Assert1(AI && isa(AI->getType()->getElementType()), + "llvm.gcroot parameter #1 must be a pointer alloca.", &CI); + Assert1(isa(CI.getOperand(2)), + "llvm.gcroot parameter #2 must be a constant.", &CI); + } - Assert1(CI.getParent()->getParent()->hasCollector(), - "Enclosing function does not specify a collector algorithm.", - &CI); - } break; + Assert1(CI.getParent()->getParent()->hasGC(), + "Enclosing function does not use GC.", &CI); + break; case Intrinsic::init_trampoline: - Assert1(isa(IntrinsicInst::StripPointerCasts(CI.getOperand(2))), + Assert1(isa(CI.getOperand(2)->stripPointerCasts()), "llvm.init_trampoline parameter #2 must resolve to a function.", &CI); break; + case Intrinsic::prefetch: + Assert1(isa(CI.getOperand(2)) && + isa(CI.getOperand(3)) && + cast(CI.getOperand(2))->getZExtValue() < 2 && + cast(CI.getOperand(3))->getZExtValue() < 4, + "invalid arguments to llvm.prefetch", + &CI); + break; + case Intrinsic::stackprotector: + Assert1(isa(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(Ty); + if (VTy) { + EltTy = VTy->getElementType(); + NumElts = VTy->getNumElements(); + } + + const Type *RetTy = FTy->getReturnType(); + const StructType *ST = dyn_cast(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(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(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(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(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(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 @@ -1287,14 +1562,32 @@ void Verifier::VerifyIntrinsicPrototype(Intrinsic::ID ID, // 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) { - MVT::ValueType VT = va_arg(VA, MVT::ValueType); + const Type *Ty = FTy->getReturnType(); + const StructType *ST = dyn_cast(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) { if (!FTy->isVarArg()) @@ -1302,123 +1595,33 @@ void Verifier::VerifyIntrinsicPrototype(Intrinsic::ID ID, 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(Ty)) { - EltTy = VTy->getElementType(); - NumElts = VTy->getNumElements(); - } - - if ((int)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(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::getValueTypeString(MVT::getValueType(EltTy)); - } else if (VT == MVT::iPTR) { - if (!isa(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); - break; - } - } else if (MVT::isVector(VT)) { - // If this is a vector argument, verify the number and type of elements. - if (MVT::getVectorElementType(VT) != MVT::getValueType(EltTy)) { - CheckFailed("Intrinsic prototype has incorrect vector element type!", - F); - break; - } - if (MVT::getVectorNumElements(VT) != NumElts) { - CheckFailed("Intrinsic prototype has incorrect number of " - "vector elements!",F); - break; - } - } else if (MVT::getTypeForValueType(VT) != 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); - // If we computed a Suffix then the intrinsic is overloaded and we need to - // make sure that the name of the function is correct. We add the suffix to - // the name of the intrinsic and compare against the given function name. If - // they are not the same, the function name is invalid. This ensures that - // overloading of intrinsics uses a sane and consistent naming convention. + // For intrinsics without pointer arguments, if we computed a Suffix then the + // intrinsic is overloaded and we need to make sure that the name of the + // function is correct. We add the suffix to the name of the intrinsic and + // compare against the given function name. If they are not the same, the + // function name is invalid. This ensures that overloading of intrinsics + // uses a sane and consistent naming convention. Note that intrinsics with + // pointer argument may or may not be overloaded so we will check assuming it + // has a suffix and not. if (!Suffix.empty()) { std::string Name(Intrinsic::getName(ID)); - if (Name + Suffix != F->getName()) + if (Name + Suffix != F->getName()) { CheckFailed("Overloaded intrinsic has incorrect suffix: '" + F->getName().substr(Name.length()) + "'. It should be '" + Suffix + "'", F); + } } + + // Check parameter attributes. + Assert1(F->getAttributes() == Intrinsic::getAttributes(ID), + "Intrinsic has wrong parameter attributes!", F); } @@ -1436,10 +1639,12 @@ bool llvm::verifyFunction(const Function &f, VerifierFailureAction action) { Function &F = const_cast(f); assert(!F.isDeclaration() && "Cannot verify external functions"); - FunctionPassManager FPM(new ExistingModuleProvider(F.getParent())); + ExistingModuleProvider MP(F.getParent()); + FunctionPassManager FPM(&MP); Verifier *V = new Verifier(action); FPM.add(V); FPM.run(F); + MP.releaseModule(); return V->Broken; } @@ -1451,7 +1656,7 @@ bool llvm::verifyModule(const Module &M, VerifierFailureAction action, PassManager PM; Verifier *V = new Verifier(action); PM.add(V); - PM.run((Module&)M); + PM.run(const_cast(M)); if (ErrorInfo && V->Broken) *ErrorInfo = V->msgs.str();