mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-07-18 12:29:27 +00:00
* Update to work with Megapatch
* 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 git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@2773 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner
parent
9234d03373
commit
24e845fa95
@ -19,7 +19,8 @@
|
||||
// or to return one. [except constant arrays!]
|
||||
// * 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.
|
||||
// . 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
|
||||
// * All Instructions must be embeded into a basic block
|
||||
// . Verify that none of the Value getType()'s are null.
|
||||
@ -43,7 +44,6 @@
|
||||
#include "llvm/iTerminators.h"
|
||||
#include "llvm/iOther.h"
|
||||
#include "llvm/iMemory.h"
|
||||
#include "llvm/Argument.h"
|
||||
#include "llvm/SymbolTable.h"
|
||||
#include "llvm/Support/CFG.h"
|
||||
#include "llvm/Support/InstVisitor.h"
|
||||
@ -59,21 +59,21 @@ namespace { // Anonymous namespace for class
|
||||
|
||||
virtual const char *getPassName() const { return "Module Verifier"; }
|
||||
|
||||
bool doInitialization(Module *M) {
|
||||
verifySymbolTable(M->getSymbolTable());
|
||||
bool doInitialization(Module &M) {
|
||||
verifySymbolTable(M.getSymbolTable());
|
||||
return false;
|
||||
}
|
||||
|
||||
bool runOnFunction(Function *F) {
|
||||
bool runOnFunction(Function &F) {
|
||||
visit(F);
|
||||
return false;
|
||||
}
|
||||
|
||||
bool doFinalization(Module *M) {
|
||||
bool doFinalization(Module &M) {
|
||||
// Scan through, checking all of the external function's linkage now...
|
||||
for (Module::iterator I = M->begin(), E = M->end(); I != E; ++I)
|
||||
if ((*I)->isExternal() && (*I)->hasInternalLinkage())
|
||||
CheckFailed("Function Declaration has Internal Linkage!", (*I));
|
||||
for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I)
|
||||
if (I->isExternal() && I->hasInternalLinkage())
|
||||
CheckFailed("Function Declaration has Internal Linkage!", I);
|
||||
|
||||
if (Broken) {
|
||||
cerr << "Broken module found, compilation aborted!\n";
|
||||
@ -88,25 +88,30 @@ namespace { // Anonymous namespace for class
|
||||
|
||||
// Verification methods...
|
||||
void verifySymbolTable(SymbolTable *ST);
|
||||
void visitFunction(Function *F);
|
||||
void visitBasicBlock(BasicBlock *BB);
|
||||
void visitPHINode(PHINode *PN);
|
||||
void visitBinaryOperator(BinaryOperator *B);
|
||||
void visitCallInst(CallInst *CI);
|
||||
void visitGetElementPtrInst(GetElementPtrInst *GEP);
|
||||
void visitLoadInst(LoadInst *LI);
|
||||
void visitStoreInst(StoreInst *SI);
|
||||
void visitInstruction(Instruction *I);
|
||||
void visitFunction(Function &F);
|
||||
void visitBasicBlock(BasicBlock &BB);
|
||||
void visitPHINode(PHINode &PN);
|
||||
void visitBinaryOperator(BinaryOperator &B);
|
||||
void visitCallInst(CallInst &CI);
|
||||
void visitGetElementPtrInst(GetElementPtrInst &GEP);
|
||||
void visitLoadInst(LoadInst &LI);
|
||||
void visitStoreInst(StoreInst &SI);
|
||||
void visitInstruction(Instruction &I);
|
||||
void visitTerminatorInst(TerminatorInst &I);
|
||||
void visitReturnInst(ReturnInst &RI);
|
||||
|
||||
// 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
|
||||
// to see why something is not correct.
|
||||
//
|
||||
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";
|
||||
if (V1) { std::cerr << V1 << "\n"; }
|
||||
if (V2) { std::cerr << V2 << "\n"; }
|
||||
if (V1) std::cerr << *V1 << "\n";
|
||||
if (V2) std::cerr << *V2 << "\n";
|
||||
if (V3) std::cerr << *V3 << "\n";
|
||||
if (V4) std::cerr << *V4 << "\n";
|
||||
Broken = true;
|
||||
}
|
||||
};
|
||||
@ -119,6 +124,10 @@ namespace { // Anonymous namespace for class
|
||||
do { if (!(C)) { CheckFailed(M, V1); return; } } while (0)
|
||||
#define Assert2(C, M, V1, V2) \
|
||||
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
|
||||
@ -143,30 +152,31 @@ void Verifier::verifySymbolTable(SymbolTable *ST) {
|
||||
|
||||
// visitFunction - Verify that a function is ok.
|
||||
//
|
||||
void Verifier::visitFunction(Function *F) {
|
||||
if (F->isExternal()) return;
|
||||
void Verifier::visitFunction(Function &F) {
|
||||
if (F.isExternal()) return;
|
||||
|
||||
verifySymbolTable(F->getSymbolTable());
|
||||
verifySymbolTable(F.getSymbolTable());
|
||||
|
||||
// Check function arguments...
|
||||
const FunctionType *FT = F->getFunctionType();
|
||||
const Function::ArgumentListType &ArgList = F->getArgumentList();
|
||||
const FunctionType *FT = F.getFunctionType();
|
||||
unsigned NumArgs = F.getArgumentList().size();
|
||||
|
||||
Assert2(!FT->isVarArg(), "Cannot define varargs functions in LLVM!", F, FT);
|
||||
Assert2(FT->getParamTypes().size() == ArgList.size(),
|
||||
Assert2(!FT->isVarArg(), "Cannot define varargs functions in LLVM!", &F, FT);
|
||||
Assert2(FT->getParamTypes().size() == NumArgs,
|
||||
"# 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...
|
||||
if (FT->getParamTypes().size() == ArgList.size()) {
|
||||
for (unsigned i = 0, e = ArgList.size(); i != e; ++i)
|
||||
Assert2(ArgList[i]->getType() == FT->getParamType(i),
|
||||
if (FT->getParamTypes().size() == NumArgs) {
|
||||
unsigned i = 0;
|
||||
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!",
|
||||
ArgList[i], FT->getParamType(i));
|
||||
I, FT->getParamType(i));
|
||||
}
|
||||
|
||||
// Check the entry node
|
||||
BasicBlock *Entry = F->getEntryNode();
|
||||
BasicBlock *Entry = &F.getEntryNode();
|
||||
Assert1(pred_begin(Entry) == pred_end(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...
|
||||
//
|
||||
void Verifier::visitBasicBlock(BasicBlock *BB) {
|
||||
Assert1(BB->getTerminator(), "Basic Block does not have terminator!", BB);
|
||||
void Verifier::visitBasicBlock(BasicBlock &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...
|
||||
if (isa<ReturnInst>(BB->getTerminator())) {
|
||||
Instruction *I = BB->getTerminator();
|
||||
Function *F = I->getParent()->getParent();
|
||||
if (I->getNumOperands() == 0)
|
||||
Assert1(F->getReturnType() == Type::VoidTy,
|
||||
"Function returns no value, but ret instruction found that does!",
|
||||
I);
|
||||
else
|
||||
Assert2(F->getReturnType() == I->getOperand(0)->getType(),
|
||||
"Function return type does not match operand "
|
||||
"type of return inst!", I, F->getReturnType());
|
||||
}
|
||||
void Verifier::visitTerminatorInst(TerminatorInst &I) {
|
||||
// Ensure that terminators only exist at the end of the basic block.
|
||||
Assert1(&I == I.getParent()->getTerminator(),
|
||||
"Terminator found in the middle of a basic block!", I.getParent());
|
||||
}
|
||||
|
||||
void Verifier::visitReturnInst(ReturnInst &RI) {
|
||||
Function *F = RI.getParent()->getParent();
|
||||
if (RI.getNumOperands() == 0)
|
||||
Assert1(F->getReturnType() == Type::VoidTy,
|
||||
"Function returns no value, but ret instruction found that does!",
|
||||
&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.
|
||||
void Verifier::visitPHINode(PHINode *PN) {
|
||||
std::vector<BasicBlock*> Preds(pred_begin(PN->getParent()),
|
||||
pred_end(PN->getParent()));
|
||||
void Verifier::visitPHINode(PHINode &PN) {
|
||||
// Ensure that the PHI nodes are all grouped together at the top of the block.
|
||||
// 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
|
||||
// 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...
|
||||
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!",
|
||||
PN, PN->getIncomingValue(i));
|
||||
&PN, PN.getIncomingValue(i));
|
||||
|
||||
BasicBlock *BB = PN->getIncomingBlock(i);
|
||||
BasicBlock *BB = PN.getIncomingBlock(i);
|
||||
std::vector<BasicBlock*>::iterator PI =
|
||||
find(Preds.begin(), Preds.end(), BB);
|
||||
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);
|
||||
}
|
||||
|
||||
@ -218,101 +245,122 @@ void Verifier::visitPHINode(PHINode *PN) {
|
||||
for (std::vector<BasicBlock*>::iterator I = Preds.begin(),
|
||||
E = Preds.end(); I != E; ++I)
|
||||
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);
|
||||
}
|
||||
|
||||
void Verifier::visitCallInst(CallInst *CI) {
|
||||
Assert1(isa<PointerType>(CI->getOperand(0)->getType()),
|
||||
"Called function must be a pointer!", CI);
|
||||
PointerType *FPTy = cast<PointerType>(CI->getOperand(0)->getType());
|
||||
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());
|
||||
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
|
||||
if (FTy->isVarArg())
|
||||
Assert1(CI->getNumOperands()-1 >= FTy->getNumParams(),
|
||||
"Called function requires more parameters than were provided!", CI);
|
||||
Assert1(CI.getNumOperands()-1 >= FTy->getNumParams(),
|
||||
"Called function requires more parameters than were provided!",&CI);
|
||||
else
|
||||
Assert1(CI->getNumOperands()-1 == FTy->getNumParams(),
|
||||
"Incorrect number of arguments passed to called function!", CI);
|
||||
Assert1(CI.getNumOperands()-1 == FTy->getNumParams(),
|
||||
"Incorrect number of arguments passed to called function!", &CI);
|
||||
|
||||
// Verify that all arguments to the call match the function type...
|
||||
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!",
|
||||
CI->getOperand(i+1), FTy->getParamType(i));
|
||||
CI.getOperand(i+1), FTy->getParamType(i));
|
||||
}
|
||||
|
||||
// visitBinaryOperator - Check that both arguments to the binary operator are
|
||||
// of the same type!
|
||||
//
|
||||
void Verifier::visitBinaryOperator(BinaryOperator *B) {
|
||||
Assert2(B->getOperand(0)->getType() == B->getOperand(1)->getType(),
|
||||
void Verifier::visitBinaryOperator(BinaryOperator &B) {
|
||||
Assert2(B.getOperand(0)->getType() == B.getOperand(1)->getType(),
|
||||
"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);
|
||||
}
|
||||
|
||||
void Verifier::visitGetElementPtrInst(GetElementPtrInst *GEP) {
|
||||
const Type *ElTy =MemAccessInst::getIndexedType(GEP->getOperand(0)->getType(),
|
||||
GEP->copyIndices(), true);
|
||||
Assert1(ElTy, "Invalid indices for GEP pointer type!", GEP);
|
||||
Assert2(PointerType::get(ElTy) == GEP->getType(),
|
||||
"GEP is not of right type for indices!", GEP, ElTy);
|
||||
void Verifier::visitGetElementPtrInst(GetElementPtrInst &GEP) {
|
||||
const Type *ElTy = MemAccessInst::getIndexedType(GEP.getOperand(0)->getType(),
|
||||
GEP.copyIndices(), true);
|
||||
Assert1(ElTy, "Invalid indices for GEP pointer type!", &GEP);
|
||||
Assert2(PointerType::get(ElTy) == GEP.getType(),
|
||||
"GEP is not of right type for indices!", &GEP, ElTy);
|
||||
visitInstruction(GEP);
|
||||
}
|
||||
|
||||
void Verifier::visitLoadInst(LoadInst *LI) {
|
||||
const Type *ElTy = LoadInst::getIndexedType(LI->getOperand(0)->getType(),
|
||||
LI->copyIndices());
|
||||
Assert1(ElTy, "Invalid indices for load pointer type!", LI);
|
||||
Assert2(ElTy == LI->getType(),
|
||||
"Load is not of right type for indices!", LI, ElTy);
|
||||
void Verifier::visitLoadInst(LoadInst &LI) {
|
||||
const Type *ElTy = LoadInst::getIndexedType(LI.getOperand(0)->getType(),
|
||||
LI.copyIndices());
|
||||
Assert1(ElTy, "Invalid indices for load pointer type!", &LI);
|
||||
Assert2(ElTy == LI.getType(),
|
||||
"Load is not of right type for indices!", &LI, ElTy);
|
||||
visitInstruction(LI);
|
||||
}
|
||||
|
||||
void Verifier::visitStoreInst(StoreInst *SI) {
|
||||
const Type *ElTy = StoreInst::getIndexedType(SI->getOperand(1)->getType(),
|
||||
SI->copyIndices());
|
||||
Assert1(ElTy, "Invalid indices for store pointer type!", SI);
|
||||
Assert2(ElTy == SI->getOperand(0)->getType(),
|
||||
"Stored value is not of right type for indices!", SI, ElTy);
|
||||
void Verifier::visitStoreInst(StoreInst &SI) {
|
||||
const Type *ElTy = StoreInst::getIndexedType(SI.getOperand(1)->getType(),
|
||||
SI.copyIndices());
|
||||
Assert1(ElTy, "Invalid indices for store pointer type!", &SI);
|
||||
Assert2(ElTy == SI.getOperand(0)->getType(),
|
||||
"Stored value is not of right type for indices!", &SI, ElTy);
|
||||
visitInstruction(SI);
|
||||
}
|
||||
|
||||
|
||||
// verifyInstruction - Verify that a non-terminator instruction is well formed.
|
||||
//
|
||||
void Verifier::visitInstruction(Instruction *I) {
|
||||
assert(I->getParent() && "Instruction not embedded in basic block!");
|
||||
void Verifier::visitInstruction(Instruction &I) {
|
||||
Assert1(I.getParent(), "Instruction not embedded in basic block!", &I);
|
||||
|
||||
// Check that all uses of the instruction, if they are instructions
|
||||
// themselves, actually have parent basic blocks. If the use is not an
|
||||
// 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) {
|
||||
Assert1(isa<Instruction>(*UI), "Use of instruction is not an instruction!",
|
||||
*UI);
|
||||
Instruction *Used = cast<Instruction>(*UI);
|
||||
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
|
||||
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)
|
||||
Assert1(*UI != (User*)I,
|
||||
"Only PHI nodes may reference their own value!", I);
|
||||
Assert1(*UI != (User*)&I,
|
||||
"Only PHI nodes may reference their own value!", &I);
|
||||
}
|
||||
|
||||
Assert1(I->getType() != Type::VoidTy || !I->hasName(),
|
||||
"Instruction has a name, but provides a void value!", I);
|
||||
Assert1(I.getType() != Type::VoidTy || !I.hasName(),
|
||||
"Instruction has a name, but provides a void value!", &I);
|
||||
}
|
||||
|
||||
|
||||
@ -324,17 +372,17 @@ Pass *createVerifierPass() {
|
||||
return new Verifier();
|
||||
}
|
||||
|
||||
bool verifyFunction(const Function *F) {
|
||||
bool verifyFunction(const Function &F) {
|
||||
Verifier V;
|
||||
V.visit((Function*)F);
|
||||
V.visit((Function&)F);
|
||||
return V.Broken;
|
||||
}
|
||||
|
||||
// verifyModule - Check a module for errors, printing messages on stderr.
|
||||
// Return true if the module is corrupt.
|
||||
//
|
||||
bool verifyModule(const Module *M) {
|
||||
bool verifyModule(const Module &M) {
|
||||
Verifier V;
|
||||
V.run((Module*)M);
|
||||
V.run((Module&)M);
|
||||
return V.Broken;
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user