#include "llvm/Pass.h"
#include "llvm/Module.h"
#include "llvm/ModuleProvider.h"
+#include "llvm/ParameterAttributes.h"
#include "llvm/DerivedTypes.h"
#include "llvm/InlineAsm.h"
#include "llvm/Instructions.h"
struct VISIBILITY_HIDDEN
Verifier : public FunctionPass, InstVisitor<Verifier> {
+ static char ID; // Pass ID, replacement for typeid
bool Broken; // Is this module found to be broken?
bool RealPass; // Are we not being run by a PassManager?
VerifierFailureAction action;
// What to do if verification fails.
Module *Mod; // Module we are verifying right now
- ETForest *EF; // ET-Forest, caution can be null!
+ DominatorTree *DT; // Dominator Tree, caution can be null!
std::stringstream msgs; // A stringstream to collect messages
/// InstInThisBlock - when verifying a basic block, keep track of all of the
SmallPtrSet<Instruction*, 16> InstsInThisBlock;
Verifier()
- : Broken(false), RealPass(true), action(AbortProcessAction),
- EF(0), msgs( std::ios::app | std::ios::out ) {}
+ : FunctionPass((intptr_t)&ID),
+ Broken(false), RealPass(true), action(AbortProcessAction),
+ DT(0), msgs( std::ios::app | std::ios::out ) {}
Verifier( VerifierFailureAction ctn )
- : Broken(false), RealPass(true), action(ctn), EF(0),
- msgs( std::ios::app | std::ios::out ) {}
+ : FunctionPass((intptr_t)&ID),
+ Broken(false), RealPass(true), action(ctn), DT(0),
+ msgs( std::ios::app | std::ios::out ) {}
Verifier(bool AB )
- : Broken(false), RealPass(true),
- action( AB ? AbortProcessAction : PrintMessageAction), EF(0),
- msgs( std::ios::app | std::ios::out ) {}
- Verifier(ETForest &ef)
- : Broken(false), RealPass(false), action(PrintMessageAction),
- EF(&ef), msgs( std::ios::app | std::ios::out ) {}
+ : FunctionPass((intptr_t)&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),
+ Broken(false), RealPass(false), action(PrintMessageAction),
+ DT(&dt), msgs( std::ios::app | std::ios::out ) {}
bool doInitialization(Module &M) {
bool runOnFunction(Function &F) {
// Get dominator information if we are being run by PassManager
- if (RealPass) EF = &getAnalysis<ETForest>();
-
+ if (RealPass) DT = &getAnalysis<DominatorTree>();
+
+ Mod = F.getParent();
+
visit(F);
InstsInThisBlock.clear();
I != E; ++I)
visitGlobalVariable(*I);
+ for (Module::alias_iterator I = M.alias_begin(), E = M.alias_end();
+ I != E; ++I)
+ visitGlobalAlias(*I);
+
// If the module is broken, abort at this time.
return abortIfBroken();
}
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
AU.setPreservesAll();
if (RealPass)
- AU.addRequired<ETForest>();
+ AU.addRequired<DominatorTree>();
}
/// abortIfBroken - If the module is broken and we are supposed to abort on
void verifyTypeSymbolTable(TypeSymbolTable &ST);
void visitGlobalValue(GlobalValue &GV);
void visitGlobalVariable(GlobalVariable &GV);
+ void visitGlobalAlias(GlobalAlias &GA);
void visitFunction(Function &F);
void visitBasicBlock(BasicBlock &BB);
void visitTruncInst(TruncInst &I);
}
};
+ char Verifier::ID = 0;
RegisterPass<Verifier> X("verify", "Module Verifier");
} // End anonymous namespace
Assert1(!GV.isDeclaration() ||
GV.hasExternalLinkage() ||
GV.hasDLLImportLinkage() ||
- GV.hasExternalWeakLinkage(),
+ GV.hasExternalWeakLinkage() ||
+ (isa<GlobalAlias>(GV) &&
+ (GV.hasInternalLinkage() || GV.hasWeakLinkage())),
"Global is external, but doesn't have external or dllimport or weak linkage!",
&GV);
visitGlobalValue(GV);
}
+void Verifier::visitGlobalAlias(GlobalAlias &GA) {
+ Assert1(!GA.getName().empty(),
+ "Alias name cannot be empty!", &GA);
+ Assert1(GA.hasExternalLinkage() || GA.hasInternalLinkage() ||
+ GA.hasWeakLinkage(),
+ "Alias should have external or external weak linkage!", &GA);
+ Assert1(GA.getType() == GA.getAliasee()->getType(),
+ "Alias and aliasee types should match!", &GA);
+
+ if (!isa<GlobalValue>(GA.getAliasee())) {
+ const ConstantExpr *CE = dyn_cast<ConstantExpr>(GA.getAliasee());
+ Assert1(CE && CE->getOpcode() == Instruction::BitCast &&
+ isa<GlobalValue>(CE->getOperand(0)),
+ "Aliasee should be either GlobalValue or bitcast of GlobalValue",
+ &GA);
+ }
+
+ visitGlobalValue(GA);
+}
+
void Verifier::verifyTypeSymbolTable(TypeSymbolTable &ST) {
}
FT->getNumParams() > 0 && isa<PointerType>(FT->getParamType(0))),
"Invalid struct-return function!", &F);
+ if (const ParamAttrsList *Attrs = FT->getParamAttrs()) {
+ unsigned Idx = 1;
+
+ Assert1(!Attrs->paramHasAttr(0, ParamAttr::ByVal),
+ "Attribute ByVal should not apply to functions!", &F);
+ Assert1(!Attrs->paramHasAttr(0, ParamAttr::StructRet),
+ "Attribute SRet should not apply to functions!", &F);
+ Assert1(!Attrs->paramHasAttr(0, ParamAttr::InReg),
+ "Attribute InReg should not apply to functions!", &F);
+
+ for (FunctionType::param_iterator I = FT->param_begin(),
+ E = FT->param_end(); I != E; ++I, ++Idx) {
+ if (Attrs->paramHasAttr(Idx, ParamAttr::ZExt) ||
+ Attrs->paramHasAttr(Idx, ParamAttr::SExt))
+ Assert1(FT->getParamType(Idx-1)->isInteger(),
+ "Attribute ZExt should only apply to Integer type!", &F);
+ if (Attrs->paramHasAttr(Idx, ParamAttr::NoAlias))
+ Assert1(isa<PointerType>(FT->getParamType(Idx-1)),
+ "Attribute NoAlias should only apply to Pointer type!", &F);
+ if (Attrs->paramHasAttr(Idx, ParamAttr::ByVal)) {
+ Assert1(isa<PointerType>(FT->getParamType(Idx-1)),
+ "Attribute ByVal should only apply to pointer to structs!", &F);
+
+ Assert1(!Attrs->paramHasAttr(Idx, ParamAttr::StructRet),
+ "Attributes ByVal and StructRet are incompatible!", &F);
+
+ const PointerType *Ty =
+ cast<PointerType>(FT->getParamType(Idx-1));
+ Assert1(isa<StructType>(Ty->getElementType()),
+ "Attribute ByVal should only apply to pointer to structs!", &F);
+ }
+
+ Assert1(!Attrs->paramHasAttr(Idx, ParamAttr::NoReturn),
+ "Attribute NoReturn should only be applied to function", &F);
+ Assert1(!Attrs->paramHasAttr(Idx, ParamAttr::NoUnwind),
+ "Attribute NoUnwind should only be applied to function", &F);
+ }
+ }
+
// Check that this function meets the restrictions on this calling convention.
switch (F.getCallingConv()) {
default:
for (Value::use_iterator UI = I.use_begin(), UE = I.use_end();
UI != UE; ++UI)
Assert1(*UI != (User*)&I ||
- !EF->dominates(&BB->getParent()->getEntryBlock(), BB),
+ !DT->dominates(&BB->getParent()->getEntryBlock(), BB),
"Only PHI nodes may reference their own value!", &I);
}
// dominates all of it's predecessors (other than the invoke) or if
// the invoke value is only used by a phi in the successor.
if (!OpBlock->getSinglePredecessor() &&
- EF->dominates(&BB->getParent()->getEntryBlock(), BB)) {
+ DT->dominates(&BB->getParent()->getEntryBlock(), BB)) {
// The first case we allow is if the use is a PHI operand in the
// normal block, and if that PHI operand corresponds to the invoke's
// block.
Bad = false;
for (pred_iterator PI = pred_begin(OpBlock),
E = pred_end(OpBlock); PI != E; ++PI) {
- if (*PI != II->getParent() && !EF->dominates(OpBlock, *PI)) {
+ if (*PI != II->getParent() && !DT->dominates(OpBlock, *PI)) {
Bad = true;
break;
}
// If they are in the same basic block, make sure that the definition
// comes before the use.
Assert2(InstsInThisBlock.count(Op) ||
- !EF->dominates(&BB->getParent()->getEntryBlock(), BB),
+ !DT->dominates(&BB->getParent()->getEntryBlock(), BB),
"Instruction does not dominate all uses!", Op, &I);
}
// Definition must dominate use unless use is unreachable!
- Assert2(EF->dominates(OpBlock, BB) ||
- !EF->dominates(&BB->getParent()->getEntryBlock(), BB),
+ Assert2(DT->dominates(OpBlock, BB) ||
+ !DT->dominates(&BB->getParent()->getEntryBlock(), BB),
"Instruction does not dominate all uses!", Op, &I);
} else {
// PHI nodes are more difficult than other nodes because they actually
// "use" the value in the predecessor basic blocks they correspond to.
BasicBlock *PredBB = cast<BasicBlock>(I.getOperand(i+1));
- Assert2(EF->dominates(OpBlock, PredBB) ||
- !EF->dominates(&BB->getParent()->getEntryBlock(), PredBB),
+ Assert2(DT->dominates(OpBlock, PredBB) ||
+ !DT->dominates(&BB->getParent()->getEntryBlock(), PredBB),
"Instruction does not dominate all uses!", Op, &I);
}
} else if (isa<InlineAsm>(I.getOperand(i))) {
break;
}
} else if (TypeID == Type::VectorTyID) {
- // If this is a packed argument, verify the number and type of elements.
+ // If this is a vector argument, verify the number and type of elements.
const VectorType *PTy = cast<VectorType>(Ty);
int ElemTy = va_arg(VA, int);
if (ElemTy != PTy->getElementType()->getTypeID()) {