RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-11-24 19:52:54 +01:00
Code Issues Projects Releases Wiki Activity

* Update to work with Megapatch

Browse Source 
* Add two new checks:
  * PHI nodes must be the first thing in a basic block, all grouped together
  * All basic blocks should only end with terminator insts, not contain them

llvm-svn: 2773
This commit is contained in:
Chris Lattner 2002-06-25 15:56:27 +00:00
parent 8e1476c302
commit 12075bfedd
1 changed files with 152 additions and 104 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

256
lib/VMCore/Verifier.cpp
View File

@ -19,7 +19,8 @@
// or to return one. [except constant arrays!] // or to return one. [except constant arrays!]
// * Only phi nodes can be self referential: 'add int %0, %0 ; <int>:0' is bad // * Only phi nodes can be self referential: 'add int %0, %0 ; <int>:0' is bad
// * PHI nodes must have an entry for each predecessor, with no extras. // * PHI nodes must have an entry for each predecessor, with no extras.
// . All basic blocks should only end with terminator insts, not contain them // * PHI nodes must be the first thing in a basic block, all grouped together
// * All basic blocks should only end with terminator insts, not contain them
// * The entry node to a function must not have predecessors // * The entry node to a function must not have predecessors
// * All Instructions must be embeded into a basic block // * All Instructions must be embeded into a basic block
// . Verify that none of the Value getType()'s are null. // . Verify that none of the Value getType()'s are null.
@ -43,7 +44,6 @@
#include "llvm/iTerminators.h" #include "llvm/iTerminators.h"
#include "llvm/iOther.h" #include "llvm/iOther.h"
#include "llvm/iMemory.h" #include "llvm/iMemory.h"
#include "llvm/Argument.h"
#include "llvm/SymbolTable.h" #include "llvm/SymbolTable.h"
#include "llvm/Support/CFG.h" #include "llvm/Support/CFG.h"
#include "llvm/Support/InstVisitor.h" #include "llvm/Support/InstVisitor.h"
@ -59,21 +59,21 @@ namespace { // Anonymous namespace for class
virtual const char *getPassName() const { return "Module Verifier"; } virtual const char *getPassName() const { return "Module Verifier"; }
bool doInitialization(Module *M) { bool doInitialization(Module &M) {
verifySymbolTable(M->getSymbolTable()); verifySymbolTable(M.getSymbolTable());
return false; return false;
} }
bool runOnFunction(Function *F) { bool runOnFunction(Function &F) {
visit(F); visit(F);
return false; return false;
} }
bool doFinalization(Module *M) { bool doFinalization(Module &M) {
// Scan through, checking all of the external function's linkage now... // Scan through, checking all of the external function's linkage now...
for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I) for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I)
if ((*I)->isExternal() && (*I)->hasInternalLinkage()) if (I->isExternal() && I->hasInternalLinkage())
CheckFailed("Function Declaration has Internal Linkage!", (*I)); CheckFailed("Function Declaration has Internal Linkage!", I);
if (Broken) { if (Broken) {
cerr << "Broken module found, compilation aborted!\n"; cerr << "Broken module found, compilation aborted!\n";
@ -88,25 +88,30 @@ namespace { // Anonymous namespace for class
// Verification methods... // Verification methods...
void verifySymbolTable(SymbolTable *ST); void verifySymbolTable(SymbolTable *ST);
void visitFunction(Function *F); void visitFunction(Function &F);
void visitBasicBlock(BasicBlock *BB); void visitBasicBlock(BasicBlock &BB);
void visitPHINode(PHINode *PN); void visitPHINode(PHINode &PN);
void visitBinaryOperator(BinaryOperator *B); void visitBinaryOperator(BinaryOperator &B);
void visitCallInst(CallInst *CI); void visitCallInst(CallInst &CI);
void visitGetElementPtrInst(GetElementPtrInst *GEP); void visitGetElementPtrInst(GetElementPtrInst &GEP);
void visitLoadInst(LoadInst *LI); void visitLoadInst(LoadInst &LI);
void visitStoreInst(StoreInst *SI); void visitStoreInst(StoreInst &SI);
void visitInstruction(Instruction *I); void visitInstruction(Instruction &I);
void visitTerminatorInst(TerminatorInst &I);
void visitReturnInst(ReturnInst &RI);
// CheckFailed - A check failed, so print out the condition and the message // CheckFailed - A check failed, so print out the condition and the message
// that failed. This provides a nice place to put a breakpoint if you want // that failed. This provides a nice place to put a breakpoint if you want
// to see why something is not correct. // to see why something is not correct.
// //
inline void CheckFailed(const std::string &Message, inline void CheckFailed(const std::string &Message,
const Value *V1 = 0, const Value *V2 = 0) { const Value *V1 = 0, const Value *V2 = 0,
const Value *V3 = 0, const Value *V4 = 0) {
std::cerr << Message << "\n"; std::cerr << Message << "\n";
if (V1) { std::cerr << V1 << "\n"; } if (V1) std::cerr << *V1 << "\n";
if (V2) { std::cerr << V2 << "\n"; } if (V2) std::cerr << *V2 << "\n";
if (V3) std::cerr << *V3 << "\n";
if (V4) std::cerr << *V4 << "\n";
Broken = true; Broken = true;
} }
}; };
@ -119,6 +124,10 @@ namespace { // Anonymous namespace for class
do { if (!(C)) { CheckFailed(M, V1); return; } } while (0) do { if (!(C)) { CheckFailed(M, V1); return; } } while (0)
#define Assert2(C, M, V1, V2) \ #define Assert2(C, M, V1, V2) \
do { if (!(C)) { CheckFailed(M, V1, V2); return; } } while (0) do { if (!(C)) { CheckFailed(M, V1, V2); return; } } while (0)
#define Assert3(C, M, V1, V2, V3) \
do { if (!(C)) { CheckFailed(M, V1, V2, V3); return; } } while (0)
#define Assert4(C, M, V1, V2, V3, V4) \
do { if (!(C)) { CheckFailed(M, V1, V2, V3, V4); return; } } while (0)
// verifySymbolTable - Verify that a function or module symbol table is ok // verifySymbolTable - Verify that a function or module symbol table is ok
@ -143,30 +152,31 @@ void Verifier::verifySymbolTable(SymbolTable *ST) {
// visitFunction - Verify that a function is ok. // visitFunction - Verify that a function is ok.
// //
void Verifier::visitFunction(Function *F) { void Verifier::visitFunction(Function &F) {
if (F->isExternal()) return; if (F.isExternal()) return;
verifySymbolTable(F->getSymbolTable()); verifySymbolTable(F.getSymbolTable());
// Check function arguments... // Check function arguments...
const FunctionType *FT = F->getFunctionType(); const FunctionType *FT = F.getFunctionType();
const Function::ArgumentListType &ArgList = F->getArgumentList(); unsigned NumArgs = F.getArgumentList().size();
Assert2(!FT->isVarArg(), "Cannot define varargs functions in LLVM!", F, FT); Assert2(!FT->isVarArg(), "Cannot define varargs functions in LLVM!", &F, FT);
Assert2(FT->getParamTypes().size() == ArgList.size(), Assert2(FT->getParamTypes().size() == NumArgs,
"# formal arguments must match # of arguments for function type!", "# formal arguments must match # of arguments for function type!",
F, FT); &F, FT);
// Check that the argument values match the function type for this function... // Check that the argument values match the function type for this function...
if (FT->getParamTypes().size() == ArgList.size()) { if (FT->getParamTypes().size() == NumArgs) {
for (unsigned i = 0, e = ArgList.size(); i != e; ++i) unsigned i = 0;
Assert2(ArgList[i]->getType() == FT->getParamType(i), for (Function::aiterator I = F.abegin(), E = F.aend(); I != E; ++I, ++i)
Assert2(I->getType() == FT->getParamType(i),
"Argument value does not match function argument type!", "Argument value does not match function argument type!",
ArgList[i], FT->getParamType(i)); I, FT->getParamType(i));
} }
// Check the entry node // Check the entry node
BasicBlock *Entry = F->getEntryNode(); BasicBlock *Entry = &F.getEntryNode();
Assert1(pred_begin(Entry) == pred_end(Entry), Assert1(pred_begin(Entry) == pred_end(Entry),
"Entry block to function must not have predecessors!", Entry); "Entry block to function must not have predecessors!", Entry);
} }
@ -174,43 +184,60 @@ void Verifier::visitFunction(Function *F) {
// verifyBasicBlock - Verify that a basic block is well formed... // verifyBasicBlock - Verify that a basic block is well formed...
// //
void Verifier::visitBasicBlock(BasicBlock *BB) { void Verifier::visitBasicBlock(BasicBlock &BB) {
Assert1(BB->getTerminator(), "Basic Block does not have terminator!", BB); // Ensure that basic blocks have terminators!
Assert1(BB.getTerminator(), "Basic Block does not have terminator!", &BB);
}
// Check that the terminator is ok as well... void Verifier::visitTerminatorInst(TerminatorInst &I) {
if (isa<ReturnInst>(BB->getTerminator())) { // Ensure that terminators only exist at the end of the basic block.
Instruction *I = BB->getTerminator(); Assert1(&I == I.getParent()->getTerminator(),
Function *F = I->getParent()->getParent(); "Terminator found in the middle of a basic block!", I.getParent());
if (I->getNumOperands() == 0) }
Assert1(F->getReturnType() == Type::VoidTy,
"Function returns no value, but ret instruction found that does!", void Verifier::visitReturnInst(ReturnInst &RI) {
I); Function *F = RI.getParent()->getParent();
else if (RI.getNumOperands() == 0)
Assert2(F->getReturnType() == I->getOperand(0)->getType(), Assert1(F->getReturnType() == Type::VoidTy,
"Function return type does not match operand " "Function returns no value, but ret instruction found that does!",
"type of return inst!", I, F->getReturnType()); &RI);
} else
Assert2(F->getReturnType() == RI.getOperand(0)->getType(),
"Function return type does not match operand "
"type of return inst!", &RI, F->getReturnType());
// Check to make sure that the return value has neccesary properties for
// terminators...
visitTerminatorInst(RI);
} }
// visitPHINode - Ensure that a PHI node is well formed. // visitPHINode - Ensure that a PHI node is well formed.
void Verifier::visitPHINode(PHINode *PN) { void Verifier::visitPHINode(PHINode &PN) {
std::vector<BasicBlock*> Preds(pred_begin(PN->getParent()), // Ensure that the PHI nodes are all grouped together at the top of the block.
pred_end(PN->getParent())); // This can be tested by checking whether the instruction before this is
// either nonexistant (because this is begin()) or is a PHI node. If not,
// then there is some other instruction before a PHI.
Assert2(PN.getPrev() == 0 || isa<PHINode>(PN.getPrev()),
"PHI nodes not grouped at top of basic block!",
&PN, PN.getParent());
std::vector<BasicBlock*> Preds(pred_begin(PN.getParent()),
pred_end(PN.getParent()));
// Loop over all of the incoming values, make sure that there are // Loop over all of the incoming values, make sure that there are
// predecessors for each one... // predecessors for each one...
// //
for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) { for (unsigned i = 0, e = PN.getNumIncomingValues(); i != e; ++i) {
// Make sure all of the incoming values are the right types... // Make sure all of the incoming values are the right types...
Assert2(PN->getType() == PN->getIncomingValue(i)->getType(), Assert2(PN.getType() == PN.getIncomingValue(i)->getType(),
"PHI node argument type does not agree with PHI node type!", "PHI node argument type does not agree with PHI node type!",
PN, PN->getIncomingValue(i)); &PN, PN.getIncomingValue(i));
BasicBlock *BB = PN->getIncomingBlock(i); BasicBlock *BB = PN.getIncomingBlock(i);
std::vector<BasicBlock*>::iterator PI = std::vector<BasicBlock*>::iterator PI =
find(Preds.begin(), Preds.end(), BB); find(Preds.begin(), Preds.end(), BB);
Assert2(PI != Preds.end(), "PHI node has entry for basic block that" Assert2(PI != Preds.end(), "PHI node has entry for basic block that"
" is not a predecessor!", PN, BB); " is not a predecessor!", &PN, BB);
Preds.erase(PI); Preds.erase(PI);
} }
@ -218,101 +245,122 @@ void Verifier::visitPHINode(PHINode *PN) {
for (std::vector<BasicBlock*>::iterator I = Preds.begin(), for (std::vector<BasicBlock*>::iterator I = Preds.begin(),
E = Preds.end(); I != E; ++I) E = Preds.end(); I != E; ++I)
Assert2(0, "PHI node does not have entry for a predecessor basic block!", Assert2(0, "PHI node does not have entry for a predecessor basic block!",
PN, *I); &PN, *I);
// Now we go through and check to make sure that if there is more than one
// entry for a particular basic block in this PHI node, that the incoming
// values are all identical.
//
std::vector<std::pair<BasicBlock*, Value*> > Values;
Values.reserve(PN.getNumIncomingValues());
for (unsigned i = 0, e = PN.getNumIncomingValues(); i != e; ++i)
Values.push_back(std::make_pair(PN.getIncomingBlock(i),
PN.getIncomingValue(i)));
// Sort the Values vector so that identical basic block entries are adjacent.
std::sort(Values.begin(), Values.end());
// Check for identical basic blocks with differing incoming values...
for (unsigned i = 1, e = PN.getNumIncomingValues(); i < e; ++i)
Assert4(Values[i].first != Values[i-1].first ||
Values[i].second == Values[i-1].second,
"PHI node has multiple entries for the same basic block with "
"different incoming values!", &PN, Values[i].first,
Values[i].second, Values[i-1].second);
visitInstruction(PN); visitInstruction(PN);
} }
void Verifier::visitCallInst(CallInst *CI) { void Verifier::visitCallInst(CallInst &CI) {
Assert1(isa<PointerType>(CI->getOperand(0)->getType()), Assert1(isa<PointerType>(CI.getOperand(0)->getType()),
"Called function must be a pointer!", CI); "Called function must be a pointer!", &CI);
PointerType *FPTy = cast<PointerType>(CI->getOperand(0)->getType()); const PointerType *FPTy = cast<PointerType>(CI.getOperand(0)->getType());
Assert1(isa<FunctionType>(FPTy->getElementType()), Assert1(isa<FunctionType>(FPTy->getElementType()),
"Called function is not pointer to function type!", CI); "Called function is not pointer to function type!", &CI);
FunctionType *FTy = cast<FunctionType>(FPTy->getElementType()); const FunctionType *FTy = cast<FunctionType>(FPTy->getElementType());
// Verify that the correct number of arguments are being passed // Verify that the correct number of arguments are being passed
if (FTy->isVarArg()) if (FTy->isVarArg())
Assert1(CI->getNumOperands()-1 >= FTy->getNumParams(), Assert1(CI.getNumOperands()-1 >= FTy->getNumParams(),
"Called function requires more parameters than were provided!", CI); "Called function requires more parameters than were provided!",&CI);
else else
Assert1(CI->getNumOperands()-1 == FTy->getNumParams(), Assert1(CI.getNumOperands()-1 == FTy->getNumParams(),
"Incorrect number of arguments passed to called function!", CI); "Incorrect number of arguments passed to called function!", &CI);
// Verify that all arguments to the call match the function type... // Verify that all arguments to the call match the function type...
for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i) for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i)
Assert2(CI->getOperand(i+1)->getType() == FTy->getParamType(i), Assert2(CI.getOperand(i+1)->getType() == FTy->getParamType(i),
"Call parameter type does not match function signature!", "Call parameter type does not match function signature!",
CI->getOperand(i+1), FTy->getParamType(i)); CI.getOperand(i+1), FTy->getParamType(i));
} }
// visitBinaryOperator - Check that both arguments to the binary operator are // visitBinaryOperator - Check that both arguments to the binary operator are
// of the same type! // of the same type!
// //
void Verifier::visitBinaryOperator(BinaryOperator *B) { void Verifier::visitBinaryOperator(BinaryOperator &B) {
Assert2(B->getOperand(0)->getType() == B->getOperand(1)->getType(), Assert2(B.getOperand(0)->getType() == B.getOperand(1)->getType(),
"Both operands to a binary operator are not of the same type!", "Both operands to a binary operator are not of the same type!",
B->getOperand(0), B->getOperand(1)); B.getOperand(0), B.getOperand(1));
visitInstruction(B); visitInstruction(B);
} }
void Verifier::visitGetElementPtrInst(GetElementPtrInst *GEP) { void Verifier::visitGetElementPtrInst(GetElementPtrInst &GEP) {
const Type *ElTy =MemAccessInst::getIndexedType(GEP->getOperand(0)->getType(), const Type *ElTy = MemAccessInst::getIndexedType(GEP.getOperand(0)->getType(),
GEP->copyIndices(), true); GEP.copyIndices(), true);
Assert1(ElTy, "Invalid indices for GEP pointer type!", GEP); Assert1(ElTy, "Invalid indices for GEP pointer type!", &GEP);
Assert2(PointerType::get(ElTy) == GEP->getType(), Assert2(PointerType::get(ElTy) == GEP.getType(),
"GEP is not of right type for indices!", GEP, ElTy); "GEP is not of right type for indices!", &GEP, ElTy);
visitInstruction(GEP); visitInstruction(GEP);
} }
void Verifier::visitLoadInst(LoadInst *LI) { void Verifier::visitLoadInst(LoadInst &LI) {
const Type *ElTy = LoadInst::getIndexedType(LI->getOperand(0)->getType(), const Type *ElTy = LoadInst::getIndexedType(LI.getOperand(0)->getType(),
LI->copyIndices()); LI.copyIndices());
Assert1(ElTy, "Invalid indices for load pointer type!", LI); Assert1(ElTy, "Invalid indices for load pointer type!", &LI);
Assert2(ElTy == LI->getType(), Assert2(ElTy == LI.getType(),
"Load is not of right type for indices!", LI, ElTy); "Load is not of right type for indices!", &LI, ElTy);
visitInstruction(LI); visitInstruction(LI);
} }
void Verifier::visitStoreInst(StoreInst *SI) { void Verifier::visitStoreInst(StoreInst &SI) {
const Type *ElTy = StoreInst::getIndexedType(SI->getOperand(1)->getType(), const Type *ElTy = StoreInst::getIndexedType(SI.getOperand(1)->getType(),
SI->copyIndices()); SI.copyIndices());
Assert1(ElTy, "Invalid indices for store pointer type!", SI); Assert1(ElTy, "Invalid indices for store pointer type!", &SI);
Assert2(ElTy == SI->getOperand(0)->getType(), Assert2(ElTy == SI.getOperand(0)->getType(),
"Stored value is not of right type for indices!", SI, ElTy); "Stored value is not of right type for indices!", &SI, ElTy);
visitInstruction(SI); visitInstruction(SI);
} }
// verifyInstruction - Verify that a non-terminator instruction is well formed. // verifyInstruction - Verify that a non-terminator instruction is well formed.
// //
void Verifier::visitInstruction(Instruction *I) { void Verifier::visitInstruction(Instruction &I) {
assert(I->getParent() && "Instruction not embedded in basic block!"); Assert1(I.getParent(), "Instruction not embedded in basic block!", &I);
// Check that all uses of the instruction, if they are instructions // Check that all uses of the instruction, if they are instructions
// themselves, actually have parent basic blocks. If the use is not an // themselves, actually have parent basic blocks. If the use is not an
// instruction, it is an error! // instruction, it is an error!
// //
for (User::use_iterator UI = I->use_begin(), UE = I->use_end(); for (User::use_iterator UI = I.use_begin(), UE = I.use_end();
UI != UE; ++UI) { UI != UE; ++UI) {
Assert1(isa<Instruction>(*UI), "Use of instruction is not an instruction!", Assert1(isa<Instruction>(*UI), "Use of instruction is not an instruction!",
*UI); *UI);
Instruction *Used = cast<Instruction>(*UI); Instruction *Used = cast<Instruction>(*UI);
Assert2(Used->getParent() != 0, "Instruction referencing instruction not" Assert2(Used->getParent() != 0, "Instruction referencing instruction not"
" embeded in a basic block!", I, Used); " embeded in a basic block!", &I, Used);
} }
if (!isa<PHINode>(I)) { // Check that non-phi nodes are not self referential if (!isa<PHINode>(I)) { // Check that non-phi nodes are not self referential
for (Value::use_iterator UI = I->use_begin(), UE = I->use_end(); for (Value::use_iterator UI = I.use_begin(), UE = I.use_end();
UI != UE; ++UI) UI != UE; ++UI)
Assert1(*UI != (User*)I, Assert1(*UI != (User*)&I,
"Only PHI nodes may reference their own value!", I); "Only PHI nodes may reference their own value!", &I);
} }
Assert1(I->getType() != Type::VoidTy || !I->hasName(), Assert1(I.getType() != Type::VoidTy || !I.hasName(),
"Instruction has a name, but provides a void value!", I); "Instruction has a name, but provides a void value!", &I);
} }
@ -324,17 +372,17 @@ Pass *createVerifierPass() {
return new Verifier(); return new Verifier();
} }
bool verifyFunction(const Function *F) { bool verifyFunction(const Function &F) {
Verifier V; Verifier V;
V.visit((Function*)F); V.visit((Function&)F);
return V.Broken; return V.Broken;
} }
// verifyModule - Check a module for errors, printing messages on stderr. // verifyModule - Check a module for errors, printing messages on stderr.
// Return true if the module is corrupt. // Return true if the module is corrupt.
// //
bool verifyModule(const Module *M) { bool verifyModule(const Module &M) {
Verifier V; Verifier V;
V.run((Module*)M); V.run((Module&)M);
return V.Broken; return V.Broken;
} }