X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FVerifier.cpp;h=034a0628fbaeeba1fd182070cedf77a466fd86e1;hb=cad208b8bc1458c42ca93430fcccbc18e1a5d4ab;hp=4ff2447621e158979e934c7801e55e0b7395065e;hpb=78f39da1e8586a0ab80e4c8d1139b36a5f17fa49;p=oota-llvm.git diff --git a/lib/VMCore/Verifier.cpp b/lib/VMCore/Verifier.cpp index 4ff2447621e..034a0628fba 100644 --- a/lib/VMCore/Verifier.cpp +++ b/lib/VMCore/Verifier.cpp @@ -198,23 +198,22 @@ namespace { /// 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; } @@ -225,6 +224,10 @@ namespace { 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); @@ -259,7 +262,8 @@ namespace { 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); void VerifyIntrinsicPrototype(Intrinsic::ID ID, Function *F, @@ -279,7 +283,7 @@ namespace { } } - void WriteType(const Type* T ) { + void WriteType(const Type *T) { if ( !T ) return; WriteTypeSymbolic(msgs, T, Mod ); } @@ -326,11 +330,19 @@ static RegisterPass X("verify", "Module Verifier"); 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())), "Global is external, but doesn't have external or dllimport or weak linkage!", @@ -402,23 +414,34 @@ void Verifier::VerifyAttrs(ParameterAttributes Attrs, const Type *Ty, if (isReturnValue) { ParameterAttributes RetI = Attrs & ParamAttr::ParameterOnly; Assert1(!RetI, "Attribute " + ParamAttr::getAsString(RetI) + - "does not apply to return values!", V); + " does not apply to return values!", V); } else { ParameterAttributes ParmI = Attrs & ParamAttr::ReturnOnly; Assert1(!ParmI, "Attribute " + ParamAttr::getAsString(ParmI) + - "only applies to return values!", V); + " only applies to return values!", V); } for (unsigned i = 0; i < array_lengthof(ParamAttr::MutuallyIncompatible); ++i) { ParameterAttributes MutI = Attrs & ParamAttr::MutuallyIncompatible[i]; Assert1(!(MutI & (MutI - 1)), "Attributes " + - ParamAttr::getAsString(MutI) + "are incompatible!", V); + ParamAttr::getAsString(MutI) + " are incompatible!", V); } ParameterAttributes TypeI = Attrs & ParamAttr::typeIncompatible(Ty); Assert1(!TypeI, "Wrong type for attribute " + ParamAttr::getAsString(TypeI), V); + + ParameterAttributes ByValI = Attrs & ParamAttr::ByVal; + if (const PointerType *PTy = dyn_cast(Ty)) { + Assert1(!ByValI || PTy->getElementType()->isSized(), + "Attribute " + ParamAttr::getAsString(ByValI) + + " does not support unsized types!", V); + } else { + Assert1(!ByValI, + "Attribute " + ParamAttr::getAsString(ByValI) + + " only applies to parameters with pointer type!", V); + } } // VerifyFunctionAttrs - Check parameter attributes against a function type. @@ -486,6 +509,7 @@ void Verifier::visitFunction(Function &F) { default: break; case CallingConv::C: + case CallingConv::X86_SSECall: break; case CallingConv::Fast: case CallingConv::Cold: @@ -502,14 +526,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 @@ -662,8 +685,8 @@ 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(SrcBitSize > DestBitSize,"DestTy too big for Trunc", &I); visitInstruction(I); @@ -675,8 +698,8 @@ 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); unsigned SrcBitSize = SrcTy->getPrimitiveSizeInBits(); unsigned DestBitSize = DestTy->getPrimitiveSizeInBits(); @@ -694,8 +717,8 @@ 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(SrcBitSize < DestBitSize,"Type too small for SExt", &I); visitInstruction(I); @@ -709,8 +732,8 @@ 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(SrcBitSize > DestBitSize,"DestTy too big for FPTrunc", &I); visitInstruction(I); @@ -725,8 +748,8 @@ 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(SrcBitSize < DestBitSize,"DestTy too small for FPExt", &I); visitInstruction(I); @@ -929,7 +952,7 @@ void Verifier::VerifyCallSite(CallSite CS) { ParameterAttributes VArgI = Attr & ParamAttr::VarArgsIncompatible; Assert1(!VArgI, "Attribute " + ParamAttr::getAsString(VArgI) + - "cannot be used for vararg call arguments!", I); + " cannot be used for vararg call arguments!", I); } visitInstruction(*I); @@ -971,8 +994,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 */ @@ -1039,9 +1064,13 @@ void Verifier::visitShuffleVectorInst(ShuffleVectorInst &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(MV->getNumOperands()*2), + "Invalid shufflevector shuffle mask!", &SV); + } else { + Assert1(isa(MV->getOperand(i)), + "Invalid shufflevector shuffle mask!", &SV); + } } } else { Assert1(isa(SV.getOperand(2)) || @@ -1090,18 +1119,23 @@ void Verifier::visitAllocationInst(AllocationInst &AI) { visitInstruction(AI); } -void Verifier::visitGetResultInst(GetResultInst &GRI) { - Assert1(GetResultInst::isValidOperands(GRI.getAggregateValue(), - GRI.getIndex()), - "Invalid GetResultInst operands!", &GRI); - Assert1(isa(GRI.getAggregateValue()) || - isa(GRI.getAggregateValue()) || - isa(GRI.getAggregateValue()), - "GetResultInst operand must be a call/invoke/undef!", &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(GRI); + 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. /// @@ -1151,20 +1185,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))) { @@ -1239,7 +1260,7 @@ void Verifier::visitInstruction(Instruction &I) { } // Definition must dominate use unless use is unreachable! - Assert2(DT->dominates(Op, &I) || + Assert2(InstsInThisBlock.count(Op) || DT->dominates(Op, &I) || !DT->dominates(&BB->getParent()->getEntryBlock(), BB), "Instruction does not dominate all uses!", Op, &I); } else { @@ -1272,45 +1293,29 @@ 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: + 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(CI.getOperand(1)->stripPointerCasts()), - "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) { + Assert1(isa(CI.getOperand(1)->stripPointerCasts()), + "llvm.gcroot parameter #1 must be an 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(CI.getOperand(2)->stripPointerCasts()), "llvm.init_trampoline parameter #2 must resolve to a function.", @@ -1327,7 +1332,6 @@ void Verifier::VerifyIntrinsicPrototype(Intrinsic::ID ID, unsigned Count, ...) { va_list VA; va_start(VA, Count); - const FunctionType *FTy = F->getFunctionType(); // For overloaded intrinsics, the Suffix of the function name must match the @@ -1423,6 +1427,21 @@ void Verifier::VerifyIntrinsicPrototype(Intrinsic::ID ID, 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(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()) { @@ -1456,17 +1475,21 @@ void Verifier::VerifyIntrinsicPrototype(Intrinsic::ID ID, 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.