//
// The LLVM Compiler Infrastructure
//
-// This file was developed by the LLVM research group and is distributed under
-// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
#include "llvm/PassManager.h"
#include "llvm/Analysis/Dominators.h"
#include "llvm/CodeGen/ValueTypes.h"
+#include "llvm/Support/CallSite.h"
#include "llvm/Support/CFG.h"
#include "llvm/Support/InstVisitor.h"
#include "llvm/Support/Streams.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/STLExtras.h"
-#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Compiler.h"
#include <algorithm>
#include <sstream>
using namespace llvm;
namespace { // Anonymous namespace for class
- cl::opt<bool>
- Pedantic("verify-pedantic",
- cl::desc("Reject code with undefined behaviour"));
-
+ struct VISIBILITY_HIDDEN PreVerifier : public FunctionPass {
+ static char ID; // Pass ID, replacement for typeid
+
+ PreVerifier() : FunctionPass((intptr_t)&ID) { }
+
+ // Check that the prerequisites for successful DominatorTree construction
+ // are satisfied.
+ bool runOnFunction(Function &F) {
+ bool Broken = false;
+
+ for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I) {
+ if (I->empty() || !I->back().isTerminator()) {
+ cerr << "Basic Block does not have terminator!\n";
+ WriteAsOperand(*cerr, I, true);
+ cerr << "\n";
+ Broken = true;
+ }
+ }
+
+ if (Broken)
+ abort();
+
+ return false;
+ }
+ };
+
+ char PreVerifier::ID = 0;
+ RegisterPass<PreVerifier> PreVer("preverify", "Preliminary module verification");
+ const PassInfo *PreVerifyID = PreVer.getPassInfo();
+
struct VISIBILITY_HIDDEN
Verifier : public FunctionPass, InstVisitor<Verifier> {
static char ID; // Pass ID, replacement for typeid
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
AU.setPreservesAll();
+ AU.addRequiredID(PreVerifyID);
if (RealPass)
AU.addRequired<DominatorTree>();
}
void visitShuffleVectorInst(ShuffleVectorInst &EI);
void visitVAArgInst(VAArgInst &VAA) { visitInstruction(VAA); }
void visitCallInst(CallInst &CI);
+ void visitInvokeInst(InvokeInst &II);
void visitGetElementPtrInst(GetElementPtrInst &GEP);
void visitLoadInst(LoadInst &LI);
void visitStoreInst(StoreInst &SI);
void visitUserOp1(Instruction &I);
void visitUserOp2(Instruction &I) { visitUserOp1(I); }
void visitIntrinsicFunctionCall(Intrinsic::ID ID, CallInst &CI);
+ void visitAllocationInst(AllocationInst &AI);
+ void VerifyCallSite(CallSite CS);
void VerifyIntrinsicPrototype(Intrinsic::ID ID, Function *F,
unsigned Count, ...);
+ void VerifyAttrs(uint16_t Attrs, const Type *Ty, bool isReturnValue,
+ const Value *V);
+ void VerifyFunctionAttrs(const FunctionType *FT, const ParamAttrsList *Attrs,
+ const Value *V);
void WriteValue(const Value *V) {
if (!V) return;
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(uint16_t Attrs, const Type *Ty, bool isReturnValue,
+ const Value *V) {
+ if (Attrs == ParamAttr::None)
+ return;
+
+ if (isReturnValue) {
+ uint16_t RetI = Attrs & ParamAttr::ParameterOnly;
+ Assert1(!RetI, "Attribute " + ParamAttrsList::getParamAttrsText(RetI) +
+ "does not apply to return values!", V);
+ } else {
+ uint16_t ParmI = Attrs & ParamAttr::ReturnOnly;
+ Assert1(!ParmI, "Attribute " + ParamAttrsList::getParamAttrsText(ParmI) +
+ "only applies to return values!", V);
+ }
+
+ for (unsigned i = 0;
+ i < array_lengthof(ParamAttr::MutuallyIncompatible); ++i) {
+ uint16_t MutI = Attrs & ParamAttr::MutuallyIncompatible[i];
+ Assert1(!(MutI & (MutI - 1)), "Attributes " +
+ ParamAttrsList::getParamAttrsText(MutI) + "are incompatible!", V);
+ }
+
+ uint16_t TypeI = Attrs & ParamAttr::typeIncompatible(Ty);
+ Assert1(!TypeI, "Wrong type for attribute " +
+ ParamAttrsList::getParamAttrsText(TypeI), 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 Value *V) {
+ if (!Attrs)
+ return;
+
+ bool SawNest = false;
+
+ for (unsigned Idx = 0; Idx <= FT->getNumParams(); ++Idx) {
+ uint16_t Attr = Attrs->getParamAttrs(Idx);
+
+ VerifyAttrs(Attr, FT->getParamType(Idx-1), !Idx, V);
+
+ if (Attr & ParamAttr::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);
+ }
+ }
+}
+
// visitFunction - Verify that a function is ok.
//
void Verifier::visitFunction(Function &F) {
F.getReturnType() == Type::VoidTy,
"Functions cannot return aggregate values!", &F);
- Assert1(!FT->isStructReturn() || FT->getReturnType() == Type::VoidTy,
+ Assert1(!F.isStructReturn() || FT->getReturnType() == Type::VoidTy,
"Invalid struct-return function!", &F);
- const uint16_t ReturnIncompatible =
- ParamAttr::ByVal | ParamAttr::InReg |
- ParamAttr::Nest | ParamAttr::StructRet;
-
- const uint16_t ParameterIncompatible =
- ParamAttr::NoReturn | ParamAttr::NoUnwind;
-
- const uint16_t MutuallyIncompatible =
- ParamAttr::ByVal | ParamAttr::InReg |
- ParamAttr::Nest | ParamAttr::StructRet;
-
- const uint16_t MutuallyIncompatible2 =
- ParamAttr::ZExt | ParamAttr::SExt;
-
- const uint16_t IntegerTypeOnly =
- ParamAttr::SExt | ParamAttr::ZExt;
-
- const uint16_t PointerTypeOnly =
- ParamAttr::ByVal | ParamAttr::Nest |
- ParamAttr::NoAlias | ParamAttr::StructRet;
-
- bool SawSRet = false;
-
- if (const ParamAttrsList *Attrs = FT->getParamAttrs()) {
- unsigned Idx = 1;
- bool SawNest = false;
-
- uint16_t RetI = Attrs->getParamAttrs(0) & ReturnIncompatible;
- Assert1(!RetI, "Attribute " + Attrs->getParamAttrsText(RetI) +
- "should not apply to functions!", &F);
- uint16_t MutI = Attrs->getParamAttrs(0) & MutuallyIncompatible2;
- Assert1(MutI != MutuallyIncompatible2, "Attributes" +
- Attrs->getParamAttrsText(MutI) + "are incompatible!", &F);
-
- for (FunctionType::param_iterator I = FT->param_begin(),
- E = FT->param_end(); I != E; ++I, ++Idx) {
-
- uint16_t Attr = Attrs->getParamAttrs(Idx);
-
- uint16_t ParmI = Attr & ParameterIncompatible;
- Assert1(!ParmI, "Attribute " + Attrs->getParamAttrsText(ParmI) +
- "should only be applied to function!", &F);
-
- uint16_t MutI = Attr & MutuallyIncompatible;
- Assert1(!(MutI & (MutI - 1)), "Attributes " +
- Attrs->getParamAttrsText(MutI) + "are incompatible!", &F);
-
- uint16_t MutI2 = Attr & MutuallyIncompatible2;
- Assert1(MutI2 != MutuallyIncompatible2, "Attributes" +
- Attrs->getParamAttrsText(MutI2) + "are incompatible!", &F);
-
- uint16_t IType = Attr & IntegerTypeOnly;
- Assert1(!IType || FT->getParamType(Idx-1)->isInteger(),
- "Attribute " + Attrs->getParamAttrsText(IType) +
- "should only apply to Integer type!", &F);
-
- uint16_t PType = Attr & PointerTypeOnly;
- Assert1(!PType || isa<PointerType>(FT->getParamType(Idx-1)),
- "Attribute " + Attrs->getParamAttrsText(PType) +
- "should only apply to Pointer type!", &F);
-
- if (Attrs->paramHasAttr(Idx, ParamAttr::ByVal)) {
- const PointerType *Ty =
- dyn_cast<PointerType>(FT->getParamType(Idx-1));
- Assert1(!Ty || isa<StructType>(Ty->getElementType()),
- "Attribute byval should only apply to pointer to structs!", &F);
- }
-
- if (Attrs->paramHasAttr(Idx, ParamAttr::Nest)) {
- Assert1(!SawNest, "More than one parameter has attribute nest!", &F);
- SawNest = true;
- }
+ const ParamAttrsList *Attrs = F.getParamAttrs();
- if (Attrs->paramHasAttr(Idx, ParamAttr::StructRet)) {
- SawSRet = true;
- Assert1(Idx == 1, "Attribute sret not on first parameter!", &F);
- }
- }
- }
+ Assert1(!Attrs ||
+ (Attrs->size() &&
+ Attrs->getParamIndex(Attrs->size()-1) <= FT->getNumParams()),
+ "Attributes after last parameter!", &F);
- Assert1(SawSRet == FT->isStructReturn(),
- "StructReturn function with no sret attribute!", &F);
+ // Check function attributes.
+ VerifyFunctionAttrs(FT, Attrs, &F);
// Check that this function meets the restrictions on this calling convention.
switch (F.getCallingConv()) {
const Type *SrcTy = I.getOperand(0)->getType();
const Type *DestTy = I.getType();
- Assert1(SrcTy->isInteger(),"UInt2FP source must be integral", &I);
- Assert1(DestTy->isFloatingPoint(),"UInt2FP result must be FP", &I);
+ bool SrcVec = SrcTy->getTypeID() == Type::VectorTyID;
+ bool DstVec = DestTy->getTypeID() == Type::VectorTyID;
+
+ 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<VectorType>(SrcTy)->getNumElements() == cast<VectorType>(DestTy)->getNumElements(),
+ "UIToFP source and dest vector length mismatch", &I);
visitInstruction(I);
}
const Type *SrcTy = I.getOperand(0)->getType();
const Type *DestTy = I.getType();
- Assert1(SrcTy->isInteger(),"SInt2FP source must be integral", &I);
- Assert1(DestTy->isFloatingPoint(),"SInt2FP result must be FP", &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);
+
+ if (SrcVec && DstVec)
+ Assert1(cast<VectorType>(SrcTy)->getNumElements() == cast<VectorType>(DestTy)->getNumElements(),
+ "SIToFP source and dest vector length mismatch", &I);
visitInstruction(I);
}
const Type *SrcTy = I.getOperand(0)->getType();
const Type *DestTy = I.getType();
- Assert1(SrcTy->isFloatingPoint(),"FP2UInt source must be FP", &I);
- Assert1(DestTy->isInteger(),"FP2UInt result must be integral", &I);
+ bool SrcVec = SrcTy->getTypeID() == Type::VectorTyID;
+ bool DstVec = DestTy->getTypeID() == Type::VectorTyID;
+
+ 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<VectorType>(SrcTy)->getNumElements() == cast<VectorType>(DestTy)->getNumElements(),
+ "FPToUI source and dest vector length mismatch", &I);
visitInstruction(I);
}
const Type *SrcTy = I.getOperand(0)->getType();
const Type *DestTy = I.getType();
- Assert1(SrcTy->isFloatingPoint(),"FPToSI source must be FP", &I);
- Assert1(DestTy->isInteger(),"FP2ToI result must be integral", &I);
+ bool SrcVec = SrcTy->getTypeID() == Type::VectorTyID;
+ bool DstVec = DestTy->getTypeID() == Type::VectorTyID;
+
+ 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<VectorType>(SrcTy)->getNumElements() == cast<VectorType>(DestTy)->getNumElements(),
+ "FPToSI source and dest vector length mismatch", &I);
visitInstruction(I);
}
visitInstruction(PN);
}
-void Verifier::visitCallInst(CallInst &CI) {
- Assert1(isa<PointerType>(CI.getOperand(0)->getType()),
- "Called function must be a pointer!", &CI);
- const PointerType *FPTy = cast<PointerType>(CI.getOperand(0)->getType());
+void Verifier::VerifyCallSite(CallSite CS) {
+ Instruction *I = CS.getInstruction();
+
+ Assert1(isa<PointerType>(CS.getCalledValue()->getType()),
+ "Called function must be a pointer!", I);
+ const PointerType *FPTy = cast<PointerType>(CS.getCalledValue()->getType());
Assert1(isa<FunctionType>(FPTy->getElementType()),
- "Called function is not pointer to function type!", &CI);
+ "Called function is not pointer to function type!", I);
const FunctionType *FTy = cast<FunctionType>(FPTy->getElementType());
// Verify that the correct number of arguments are being passed
if (FTy->isVarArg())
- Assert1(CI.getNumOperands()-1 >= FTy->getNumParams(),
- "Called function requires more parameters than were provided!",&CI);
+ Assert1(CS.arg_size() >= FTy->getNumParams(),
+ "Called function requires more parameters than were provided!",I);
else
- Assert1(CI.getNumOperands()-1 == FTy->getNumParams(),
- "Incorrect number of arguments passed to called function!", &CI);
+ Assert1(CS.arg_size() == FTy->getNumParams(),
+ "Incorrect number of arguments passed to called function!", I);
// Verify that all arguments to the call match the function type...
for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i)
- Assert3(CI.getOperand(i+1)->getType() == FTy->getParamType(i),
+ Assert3(CS.getArgument(i)->getType() == FTy->getParamType(i),
"Call parameter type does not match function signature!",
- CI.getOperand(i+1), FTy->getParamType(i), &CI);
+ CS.getArgument(i), FTy->getParamType(i), I);
- if (Function *F = CI.getCalledFunction()) {
- if (Pedantic) {
- // Verify that calling convention of Function and CallInst match
- Assert1(F->getCallingConv() == CI.getCallingConv(),
- "Call uses different calling convention than function", &CI);
+ const ParamAttrsList *Attrs = CS.getParamAttrs();
+
+ Assert1(!Attrs ||
+ (Attrs->size() &&
+ Attrs->getParamIndex(Attrs->size()-1) <= CS.arg_size()),
+ "Attributes after last argument!", I);
+
+ // Verify call attributes.
+ VerifyFunctionAttrs(FTy, Attrs, I);
+
+ if (Attrs && FTy->isVarArg())
+ // Check attributes on the varargs part.
+ for (unsigned Idx = 1 + FTy->getNumParams(); Idx <= CS.arg_size(); ++Idx) {
+ uint16_t Attr = Attrs->getParamAttrs(Idx);
+
+ VerifyAttrs(Attr, CS.getArgument(Idx-1)->getType(), false, I);
+
+ uint16_t VArgI = Attr & ParamAttr::VarArgsIncompatible;
+ Assert1(!VArgI, "Attribute " + ParamAttrsList::getParamAttrsText(VArgI) +
+ "cannot be used for vararg call arguments!", I);
}
-
+
+ visitInstruction(*I);
+}
+
+void Verifier::visitCallInst(CallInst &CI) {
+ VerifyCallSite(&CI);
+
+ if (Function *F = CI.getCalledFunction()) {
if (Intrinsic::ID ID = (Intrinsic::ID)F->getIntrinsicID())
visitIntrinsicFunctionCall(ID, CI);
}
-
- visitInstruction(CI);
+}
+
+void Verifier::visitInvokeInst(InvokeInst &II) {
+ VerifyCallSite(&II);
}
/// visitBinaryOperator - Check that both arguments to the binary operator are
visitInstruction(SI);
}
+void Verifier::visitAllocationInst(AllocationInst &AI) {
+ const PointerType *Ptr = AI.getType();
+ Assert(Ptr->getAddressSpace() == 0,
+ "Allocation instruction pointer not in the generic address space!");
+ visitInstruction(AI);
+}
+
/// verifyInstruction - Verify that an instruction is well formed.
///
"Instruction does not dominate all uses!", Op, &I);
}
} else if (isa<InlineAsm>(I.getOperand(i))) {
- Assert1(i == 0 && isa<CallInst>(I),
+ Assert1(i == 0 && (isa<CallInst>(I) || isa<InvokeInst>(I)),
"Cannot take the address of an inline asm!", &I);
}
}
InstsInThisBlock.insert(&I);
}
-static bool HasPtrPtrType(Value *Val) {
- if (const PointerType *PtrTy = dyn_cast<PointerType>(Val->getType()))
- return isa<PointerType>(PtrTy->getElementType());
- return false;
-}
-
/// visitIntrinsicFunction - Allow intrinsics to be verified in different ways.
///
void Verifier::visitIntrinsicFunctionCall(Intrinsic::ID ID, CallInst &CI) {
default:
break;
case Intrinsic::gcroot:
- Assert1(HasPtrPtrType(CI.getOperand(1)),
- "llvm.gcroot parameter #1 must be a pointer to a pointer.", &CI);
- Assert1(isa<AllocaInst>(IntrinsicInst::StripPointerCasts(CI.getOperand(1))),
- "llvm.gcroot parameter #1 must be an alloca (or a bitcast of one).",
- &CI);
- Assert1(isa<Constant>(CI.getOperand(2)),
- "llvm.gcroot parameter #2 must be a constant.", &CI);
- break;
case Intrinsic::gcwrite:
- Assert1(CI.getOperand(3)->getType()
- == PointerType::get(CI.getOperand(1)->getType()),
- "Call to llvm.gcwrite must be with type 'void (%ty*, %ty2*, %ty**)'.",
- &CI);
- break;
- case Intrinsic::gcread:
- Assert1(CI.getOperand(2)->getType() == PointerType::get(CI.getType()),
- "Call to llvm.gcread must be with type '%ty* (%ty2*, %ty**).'",
- &CI);
- break;
+ 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<AllocaInst>(
+ IntrinsicInst::StripPointerCasts(CI.getOperand(1))),
+ "llvm.gcroot parameter #1 must be an alloca.", &CI);
+ Assert1(isa<Constant>(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;
+ }
+
+ Assert1(CI.getParent()->getParent()->hasCollector(),
+ "Enclosing function does not specify a collector algorithm.",
+ &CI);
+ } break;
case Intrinsic::init_trampoline:
Assert1(isa<Function>(IntrinsicInst::StripPointerCasts(CI.getOperand(2))),
"llvm.init_trampoline parameter #2 must resolve to a function.",
&CI);
+ break;
}
}