X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FVerifier.cpp;h=99a5b92e5ffbbfd6c1249e16722102b30ff0f0a4;hb=d24479730a8790d82c4859dc477bc2416d7a6bda;hp=9c755d6c5e084e1fdd965d75a323edc7bf33f572;hpb=a6ce05f82a5145beab06521a729c529b7efe2d6d;p=oota-llvm.git diff --git a/lib/VMCore/Verifier.cpp b/lib/VMCore/Verifier.cpp index 9c755d6c5e0..99a5b92e5ff 100644 --- a/lib/VMCore/Verifier.cpp +++ b/lib/VMCore/Verifier.cpp @@ -72,6 +72,10 @@ namespace { // Anonymous namespace for class 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) { @@ -269,7 +273,7 @@ namespace { 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, @@ -346,7 +350,7 @@ void Verifier::visitGlobalValue(GlobalValue &GV) { 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); @@ -380,7 +384,7 @@ 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(), @@ -639,7 +643,7 @@ void Verifier::visitReturnInst(ReturnInst &RI) { 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. @@ -683,23 +687,10 @@ void Verifier::visitSwitchInst(SwitchInst &SI) { } void Verifier::visitSelectInst(SelectInst &SI) { - if (const VectorType* vt - = dyn_cast(SI.getCondition()->getType())) { - Assert1( vt->getElementType() == Type::Int1Ty, - "Select condition type must be vector of bool!", &SI); - if (const VectorType* val_vt - = dyn_cast(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); @@ -724,6 +715,8 @@ void Verifier::visitTruncInst(TruncInst &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); @@ -737,6 +730,8 @@ void Verifier::visitZExtInst(ZExtInst &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(SrcTy) == isa(DestTy), + "zext source and destination must both be a vector or neither", &I); unsigned SrcBitSize = SrcTy->getPrimitiveSizeInBits(); unsigned DestBitSize = DestTy->getPrimitiveSizeInBits(); @@ -756,6 +751,8 @@ void Verifier::visitSExtInst(SExtInst &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); @@ -771,6 +768,8 @@ void Verifier::visitFPTruncInst(FPTruncInst &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); @@ -787,6 +786,8 @@ void Verifier::visitFPExtInst(FPExtInst &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); @@ -1003,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) { @@ -1322,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) { @@ -1336,12 +1341,14 @@ 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(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); @@ -1374,43 +1381,94 @@ void Verifier::visitIntrinsicFunctionCall(Intrinsic::ID ID, CallInst &CI) { "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; - if (const VectorType *VTy = dyn_cast(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; - if (Match == 0) { - if (Ty != FTy->getReturnType()) { - CheckFailed("Intrinsic parameter #" + utostr(ArgNo - 1) + " does not " + + // 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("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; } @@ -1426,17 +1484,16 @@ bool Verifier::PerformTypeCheck(Intrinsic::ID ID, Function *F, const Type *Ty, 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; } @@ -1448,12 +1505,9 @@ bool Verifier::PerformTypeCheck(Intrinsic::ID ID, Function *F, const Type *Ty, Suffix += MVT::getMVT(EltTy).getMVTString(); } 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); + 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) @@ -1463,12 +1517,8 @@ bool Verifier::PerformTypeCheck(Intrinsic::ID ID, Function *F, const Type *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); + CheckFailed(IntrinsicParam(ArgNo, NumRets) + " is not a " + "pointer and a pointer is required.", F); return false; } } else if (MVT((MVT::SimpleValueType)VT).isVector()) { @@ -1486,19 +1536,12 @@ bool Verifier::PerformTypeCheck(Intrinsic::ID ID, Function *F, const Type *Ty, 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; @@ -1507,11 +1550,11 @@ bool Verifier::PerformTypeCheck(Intrinsic::ID ID, Function *F, const Type *Ty, /// 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 @@ -1519,13 +1562,31 @@ 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) { + 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) { @@ -1534,10 +1595,8 @@ void Verifier::VerifyIntrinsicPrototype(Intrinsic::ID ID, break; } - const Type *Ty = (ArgNo == 0) ? - FTy->getReturnType() : FTy->getParamType(ArgNo - 1); - - if (!PerformTypeCheck(ID, F, Ty, VT, ArgNo, Suffix)) + if (!PerformTypeCheck(ID, F, FTy->getParamType(ArgNo), VT, ArgNo + RetNum, + Suffix)) break; }