#include "llvm/ParameterAttributes.h"
#include "llvm/DerivedTypes.h"
#include "llvm/InlineAsm.h"
-#include "llvm/Instructions.h"
-#include "llvm/Intrinsics.h"
+#include "llvm/IntrinsicInst.h"
#include "llvm/PassManager.h"
#include "llvm/Analysis/Dominators.h"
#include "llvm/CodeGen/ValueTypes.h"
using namespace llvm;
namespace { // Anonymous namespace for class
+ 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> {
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
AU.setPreservesAll();
+ AU.addRequiredID(PreVerifyID);
if (RealPass)
AU.addRequired<DominatorTree>();
}
}
void Verifier::visitGlobalVariable(GlobalVariable &GV) {
- if (GV.hasInitializer())
+ if (GV.hasInitializer()) {
Assert1(GV.getInitializer()->getType() == GV.getType()->getElementType(),
"Global variable initializer type does not match global "
"variable type!", &GV);
+ } else {
+ Assert1(GV.hasExternalLinkage() || GV.hasDLLImportLinkage() ||
+ GV.hasExternalWeakLinkage(),
+ "invalid linkage type for global declaration", &GV);
+ }
visitGlobalValue(GV);
}
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);
+ if (const ParamAttrsList *Attrs = F.getParamAttrs()) {
+ Assert1(Attrs->size() &&
+ Attrs->getParamIndex(Attrs->size()-1) <= FT->getNumParams(),
+ "Function has excess attributes!", &F);
- for (FunctionType::param_iterator I = FT->param_begin(),
- E = FT->param_end(); I != E; ++I, ++Idx) {
+ bool SawNest = false;
+ for (unsigned Idx = 0; Idx <= FT->getNumParams(); ++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);
+ if (!Idx) {
+ uint16_t RetI = Attr & ParamAttr::ParameterOnly;
+ Assert1(!RetI, "Attribute " + Attrs->getParamAttrsText(RetI) +
+ "should not apply to functions!", &F);
+ } else {
+ uint16_t ParmI = Attr & ParamAttr::ReturnOnly;
+ 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);
+ for (unsigned i = 0;
+ i < array_lengthof(ParamAttr::MutuallyIncompatible); ++i) {
+ uint16_t MutI = Attr & ParamAttr::MutuallyIncompatible[i];
+ Assert1(!(MutI & (MutI - 1)), "Attributes " +
+ Attrs->getParamAttrsText(MutI) + "are incompatible!", &F);
+ }
- uint16_t IType = Attr & IntegerTypeOnly;
+ uint16_t IType = Attr & ParamAttr::IntegerTypeOnly;
Assert1(!IType || FT->getParamType(Idx-1)->isInteger(),
"Attribute " + Attrs->getParamAttrsText(IType) +
"should only apply to Integer type!", &F);
- uint16_t PType = Attr & PointerTypeOnly;
+ uint16_t PType = Attr & ParamAttr::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)) {
+ if (Attr & 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)) {
+ if (Attr & ParamAttr::Nest) {
Assert1(!SawNest, "More than one parameter has attribute nest!", &F);
SawNest = true;
}
- if (Attrs->paramHasAttr(Idx, ParamAttr::StructRet)) {
+ if (Attr & ParamAttr::StructRet) {
SawSRet = true;
Assert1(Idx == 1, "Attribute sret not on first parameter!", &F);
}
}
}
- Assert1(SawSRet == FT->isStructReturn(),
+ Assert1(SawSRet == F.isStructReturn(),
"StructReturn function with no sret attribute!", &F);
// Check that this function meets the restrictions on this calling convention.
"Functions cannot take aggregates as arguments by value!", I);
}
- if (!F.isDeclaration()) {
+ if (F.isDeclaration()) {
+ Assert1(F.hasExternalLinkage() || F.hasDLLImportLinkage() ||
+ F.hasExternalWeakLinkage(),
+ "invalid linkage type for function declaration", &F);
+ } else {
// Verify that this function (which has a body) is not named "llvm.*". It
// is not legal to define intrinsics.
if (F.getName().size() >= 5)
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);
}
"Call parameter type does not match function signature!",
CI.getOperand(i+1), FTy->getParamType(i), &CI);
- if (Function *F = CI.getCalledFunction())
+ if (Function *F = CI.getCalledFunction()) {
if (Intrinsic::ID ID = (Intrinsic::ID)F->getIntrinsicID())
visitIntrinsicFunctionCall(ID, CI);
-
+ }
+
visitInstruction(CI);
}
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) {
#define GET_INTRINSIC_VERIFIER
#include "llvm/Intrinsics.gen"
#undef GET_INTRINSIC_VERIFIER
+
+ switch (ID) {
+ 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::init_trampoline:
+ Assert1(isa<Function>(IntrinsicInst::StripPointerCasts(CI.getOperand(2))),
+ "llvm.init_trampoline parameter #2 must resolve to a function.",
+ &CI);
+ }
}
/// VerifyIntrinsicPrototype - TableGen emits calls to this function into