2001-06-06 20:29:01 +00:00
|
|
|
//===-- Verifier.cpp - Implement the Module Verifier -------------*- C++ -*-==//
|
2005-04-21 23:48:37 +00:00
|
|
|
//
|
2003-10-20 19:43:21 +00:00
|
|
|
// 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.
|
2005-04-21 23:48:37 +00:00
|
|
|
//
|
2003-10-20 19:43:21 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2001-06-06 20:29:01 +00:00
|
|
|
//
|
2002-03-29 19:06:18 +00:00
|
|
|
// This file defines the function verifier interface, that can be used for some
|
2001-06-06 20:29:01 +00:00
|
|
|
// sanity checking of input to the system.
|
|
|
|
//
|
2004-06-24 21:47:35 +00:00
|
|
|
// Note that this does not provide full `Java style' security and verifications,
|
|
|
|
// instead it just tries to ensure that code is well-formed.
|
2001-06-06 20:29:01 +00:00
|
|
|
//
|
2004-06-24 21:47:35 +00:00
|
|
|
// * Both of a binary operator's parameters are of the same type
|
2002-04-24 19:12:21 +00:00
|
|
|
// * Verify that the indices of mem access instructions match other operands
|
2004-06-24 21:47:35 +00:00
|
|
|
// * Verify that arithmetic and other things are only performed on first-class
|
2002-08-02 17:37:08 +00:00
|
|
|
// types. Verify that shifts & logicals only happen on integrals f.e.
|
2004-06-24 21:47:35 +00:00
|
|
|
// * All of the constants in a switch statement are of the correct type
|
2002-08-02 17:37:08 +00:00
|
|
|
// * The code is in valid SSA form
|
2004-06-24 21:47:35 +00:00
|
|
|
// * It should be illegal to put a label into any other type (like a structure)
|
2001-06-06 20:29:01 +00:00
|
|
|
// or to return one. [except constant arrays!]
|
2002-03-14 16:53:48 +00:00
|
|
|
// * Only phi nodes can be self referential: 'add int %0, %0 ; <int>:0' is bad
|
2002-02-20 17:55:43 +00:00
|
|
|
// * PHI nodes must have an entry for each predecessor, with no extras.
|
2002-06-25 15:56:27 +00:00
|
|
|
// * PHI nodes must be the first thing in a basic block, all grouped together
|
2002-10-06 21:00:31 +00:00
|
|
|
// * PHI nodes must have at least one entry
|
2002-06-25 15:56:27 +00:00
|
|
|
// * All basic blocks should only end with terminator insts, not contain them
|
2002-03-29 19:06:18 +00:00
|
|
|
// * The entry node to a function must not have predecessors
|
2003-10-10 17:54:14 +00:00
|
|
|
// * All Instructions must be embedded into a basic block
|
2004-06-24 21:47:35 +00:00
|
|
|
// * Functions cannot take a void-typed parameter
|
2002-04-13 22:48:46 +00:00
|
|
|
// * Verify that a function's argument list agrees with it's declared type.
|
2002-03-15 20:25:09 +00:00
|
|
|
// * It is illegal to specify a name for a void value.
|
2003-10-10 17:54:14 +00:00
|
|
|
// * It is illegal to have a internal global value with no initializer
|
2002-04-12 18:20:49 +00:00
|
|
|
// * It is illegal to have a ret instruction that returns a value that does not
|
|
|
|
// agree with the function return value type.
|
2002-05-08 19:49:50 +00:00
|
|
|
// * Function call argument types match the function prototype
|
2002-04-24 19:12:21 +00:00
|
|
|
// * All other things that are tested by asserts spread about the code...
|
2001-06-06 20:29:01 +00:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "llvm/Analysis/Verifier.h"
|
2003-11-16 23:07:42 +00:00
|
|
|
#include "llvm/Assembly/Writer.h"
|
2005-05-08 22:27:09 +00:00
|
|
|
#include "llvm/CallingConv.h"
|
2004-02-14 02:47:17 +00:00
|
|
|
#include "llvm/Constants.h"
|
2002-02-20 17:55:43 +00:00
|
|
|
#include "llvm/Pass.h"
|
2001-06-06 20:29:01 +00:00
|
|
|
#include "llvm/Module.h"
|
2004-03-14 03:16:15 +00:00
|
|
|
#include "llvm/ModuleProvider.h"
|
2002-04-13 22:48:46 +00:00
|
|
|
#include "llvm/DerivedTypes.h"
|
2006-01-26 00:08:45 +00:00
|
|
|
#include "llvm/InlineAsm.h"
|
2004-02-14 02:47:17 +00:00
|
|
|
#include "llvm/Instructions.h"
|
2003-05-08 03:47:33 +00:00
|
|
|
#include "llvm/Intrinsics.h"
|
2004-02-14 02:47:17 +00:00
|
|
|
#include "llvm/PassManager.h"
|
2002-08-02 17:37:08 +00:00
|
|
|
#include "llvm/Analysis/Dominators.h"
|
2002-02-20 17:55:43 +00:00
|
|
|
#include "llvm/Support/CFG.h"
|
2002-04-18 20:37:37 +00:00
|
|
|
#include "llvm/Support/InstVisitor.h"
|
2006-11-28 02:09:03 +00:00
|
|
|
#include "llvm/Support/Streams.h"
|
2007-02-10 08:19:44 +00:00
|
|
|
#include "llvm/ADT/SmallPtrSet.h"
|
2007-02-10 08:30:29 +00:00
|
|
|
#include "llvm/ADT/SmallVector.h"
|
2006-03-31 04:46:47 +00:00
|
|
|
#include "llvm/ADT/StringExtras.h"
|
2004-09-01 22:55:40 +00:00
|
|
|
#include "llvm/ADT/STLExtras.h"
|
2006-08-27 12:54:02 +00:00
|
|
|
#include "llvm/Support/Compiler.h"
|
2002-02-20 17:55:43 +00:00
|
|
|
#include <algorithm>
|
2006-12-07 23:41:45 +00:00
|
|
|
#include <sstream>
|
2006-03-31 07:22:05 +00:00
|
|
|
#include <cstdarg>
|
2003-11-21 20:23:48 +00:00
|
|
|
using namespace llvm;
|
2003-11-11 22:41:34 +00:00
|
|
|
|
2002-04-18 20:37:37 +00:00
|
|
|
namespace { // Anonymous namespace for class
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2006-06-28 21:38:54 +00:00
|
|
|
struct VISIBILITY_HIDDEN
|
|
|
|
Verifier : public FunctionPass, InstVisitor<Verifier> {
|
2002-08-02 17:37:08 +00:00
|
|
|
bool Broken; // Is this module found to be broken?
|
|
|
|
bool RealPass; // Are we not being run by a PassManager?
|
2004-04-02 15:45:08 +00:00
|
|
|
VerifierFailureAction action;
|
2004-05-25 08:53:29 +00:00
|
|
|
// What to do if verification fails.
|
2004-03-02 00:22:19 +00:00
|
|
|
Module *Mod; // Module we are verifying right now
|
2006-01-12 06:17:59 +00:00
|
|
|
ETForest *EF; // ET-Forest, caution can be null!
|
2004-04-02 15:45:08 +00:00
|
|
|
std::stringstream msgs; // A stringstream to collect messages
|
|
|
|
|
2004-09-29 20:07:45 +00:00
|
|
|
/// InstInThisBlock - when verifying a basic block, keep track of all of the
|
|
|
|
/// instructions we have seen so far. This allows us to do efficient
|
|
|
|
/// dominance checks for the case when an instruction has an operand that is
|
|
|
|
/// an instruction in the same block.
|
2007-02-10 08:19:44 +00:00
|
|
|
SmallPtrSet<Instruction*, 16> InstsInThisBlock;
|
2004-09-29 20:07:45 +00:00
|
|
|
|
2005-04-21 23:48:37 +00:00
|
|
|
Verifier()
|
2004-05-25 08:53:29 +00:00
|
|
|
: Broken(false), RealPass(true), action(AbortProcessAction),
|
2006-01-12 06:17:59 +00:00
|
|
|
EF(0), msgs( std::ios::app | std::ios::out ) {}
|
2004-04-02 15:45:08 +00:00
|
|
|
Verifier( VerifierFailureAction ctn )
|
2006-01-12 06:17:59 +00:00
|
|
|
: Broken(false), RealPass(true), action(ctn), EF(0),
|
2005-01-22 17:36:17 +00:00
|
|
|
msgs( std::ios::app | std::ios::out ) {}
|
2005-04-21 23:48:37 +00:00
|
|
|
Verifier(bool AB )
|
|
|
|
: Broken(false), RealPass(true),
|
2006-01-12 06:17:59 +00:00
|
|
|
action( AB ? AbortProcessAction : PrintMessageAction), EF(0),
|
2005-01-22 17:36:17 +00:00
|
|
|
msgs( std::ios::app | std::ios::out ) {}
|
2006-01-12 06:17:59 +00:00
|
|
|
Verifier(ETForest &ef)
|
2004-04-02 15:45:08 +00:00
|
|
|
: Broken(false), RealPass(false), action(PrintMessageAction),
|
2006-01-12 06:17:59 +00:00
|
|
|
EF(&ef), msgs( std::ios::app | std::ios::out ) {}
|
2002-02-20 17:55:43 +00:00
|
|
|
|
|
|
|
|
2002-06-25 15:56:27 +00:00
|
|
|
bool doInitialization(Module &M) {
|
2003-11-16 23:07:42 +00:00
|
|
|
Mod = &M;
|
2007-01-06 07:24:44 +00:00
|
|
|
verifyTypeSymbolTable(M.getTypeSymbolTable());
|
2002-09-19 16:12:19 +00:00
|
|
|
|
|
|
|
// If this is a real pass, in a pass manager, we must abort before
|
|
|
|
// returning back to the pass manager, or else the pass manager may try to
|
|
|
|
// run other passes on the broken module.
|
|
|
|
if (RealPass)
|
2006-07-26 16:18:00 +00:00
|
|
|
return abortIfBroken();
|
2002-04-18 20:37:37 +00:00
|
|
|
return false;
|
|
|
|
}
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2002-06-25 15:56:27 +00:00
|
|
|
bool runOnFunction(Function &F) {
|
2002-08-02 17:37:08 +00:00
|
|
|
// Get dominator information if we are being run by PassManager
|
2006-01-12 06:17:59 +00:00
|
|
|
if (RealPass) EF = &getAnalysis<ETForest>();
|
2006-12-13 04:30:37 +00:00
|
|
|
|
2002-04-18 20:37:37 +00:00
|
|
|
visit(F);
|
2004-09-29 20:07:45 +00:00
|
|
|
InstsInThisBlock.clear();
|
2002-09-19 16:12:19 +00:00
|
|
|
|
|
|
|
// If this is a real pass, in a pass manager, we must abort before
|
|
|
|
// returning back to the pass manager, or else the pass manager may try to
|
|
|
|
// run other passes on the broken module.
|
|
|
|
if (RealPass)
|
2006-07-26 16:18:00 +00:00
|
|
|
return abortIfBroken();
|
2002-09-19 16:12:19 +00:00
|
|
|
|
2002-04-18 20:37:37 +00:00
|
|
|
return false;
|
|
|
|
}
|
2002-02-20 17:55:43 +00:00
|
|
|
|
2002-06-25 15:56:27 +00:00
|
|
|
bool doFinalization(Module &M) {
|
2002-04-28 16:04:26 +00:00
|
|
|
// Scan through, checking all of the external function's linkage now...
|
2004-06-03 06:38:43 +00:00
|
|
|
for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) {
|
2003-04-16 20:42:40 +00:00
|
|
|
visitGlobalValue(*I);
|
2002-04-28 16:04:26 +00:00
|
|
|
|
2004-06-03 06:38:43 +00:00
|
|
|
// Check to make sure function prototypes are okay.
|
2007-01-30 20:08:39 +00:00
|
|
|
if (I->isDeclaration()) visitFunction(*I);
|
2004-06-03 06:38:43 +00:00
|
|
|
}
|
|
|
|
|
For PR411:
This patch is an incremental step towards supporting a flat symbol table.
It de-overloads the intrinsic functions by providing type-specific intrinsics
and arranging for automatically upgrading from the old overloaded name to
the new non-overloaded name. Specifically:
llvm.isunordered -> llvm.isunordered.f32, llvm.isunordered.f64
llvm.sqrt -> llvm.sqrt.f32, llvm.sqrt.f64
llvm.ctpop -> llvm.ctpop.i8, llvm.ctpop.i16, llvm.ctpop.i32, llvm.ctpop.i64
llvm.ctlz -> llvm.ctlz.i8, llvm.ctlz.i16, llvm.ctlz.i32, llvm.ctlz.i64
llvm.cttz -> llvm.cttz.i8, llvm.cttz.i16, llvm.cttz.i32, llvm.cttz.i64
New code should not use the overloaded intrinsic names. Warnings will be
emitted if they are used.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@25366 91177308-0d34-0410-b5e6-96231b3b80d8
2006-01-16 21:12:35 +00:00
|
|
|
for (Module::global_iterator I = M.global_begin(), E = M.global_end();
|
|
|
|
I != E; ++I)
|
2004-12-15 20:23:49 +00:00
|
|
|
visitGlobalVariable(*I);
|
2002-10-06 22:47:32 +00:00
|
|
|
|
2002-09-19 16:12:19 +00:00
|
|
|
// If the module is broken, abort at this time.
|
2006-07-26 16:18:00 +00:00
|
|
|
return abortIfBroken();
|
2002-04-24 19:12:21 +00:00
|
|
|
}
|
|
|
|
|
2002-04-28 21:27:06 +00:00
|
|
|
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
|
|
|
|
AU.setPreservesAll();
|
2002-08-02 17:37:08 +00:00
|
|
|
if (RealPass)
|
2006-01-17 20:07:22 +00:00
|
|
|
AU.addRequired<ETForest>();
|
2002-04-28 21:27:06 +00:00
|
|
|
}
|
|
|
|
|
2004-03-02 00:22:19 +00:00
|
|
|
/// abortIfBroken - If the module is broken and we are supposed to abort on
|
|
|
|
/// this condition, do so.
|
|
|
|
///
|
2006-07-26 16:18:00 +00:00
|
|
|
bool abortIfBroken() {
|
2006-07-06 18:02:27 +00:00
|
|
|
if (Broken) {
|
2004-04-02 15:45:08 +00:00
|
|
|
msgs << "Broken module found, ";
|
2006-07-06 18:02:27 +00:00
|
|
|
switch (action) {
|
2004-05-04 21:46:05 +00:00
|
|
|
case AbortProcessAction:
|
|
|
|
msgs << "compilation aborted!\n";
|
2006-12-07 01:30:32 +00:00
|
|
|
cerr << msgs.str();
|
2004-05-04 21:46:05 +00:00
|
|
|
abort();
|
|
|
|
case PrintMessageAction:
|
|
|
|
msgs << "verification continues.\n";
|
2006-12-07 01:30:32 +00:00
|
|
|
cerr << msgs.str();
|
2006-07-26 16:18:00 +00:00
|
|
|
return false;
|
2004-05-04 21:46:05 +00:00
|
|
|
case ReturnStatusAction:
|
2006-07-26 16:18:00 +00:00
|
|
|
msgs << "compilation terminated.\n";
|
|
|
|
return Broken;
|
2004-05-04 21:46:05 +00:00
|
|
|
}
|
2002-09-19 16:12:19 +00:00
|
|
|
}
|
2006-07-26 16:18:00 +00:00
|
|
|
return false;
|
2002-09-19 16:12:19 +00:00
|
|
|
}
|
|
|
|
|
2003-04-16 20:42:40 +00:00
|
|
|
|
2002-04-18 20:37:37 +00:00
|
|
|
// Verification methods...
|
2007-01-06 07:24:44 +00:00
|
|
|
void verifyTypeSymbolTable(TypeSymbolTable &ST);
|
2003-04-16 20:42:40 +00:00
|
|
|
void visitGlobalValue(GlobalValue &GV);
|
2004-12-15 20:23:49 +00:00
|
|
|
void visitGlobalVariable(GlobalVariable &GV);
|
2002-06-25 15:56:27 +00:00
|
|
|
void visitFunction(Function &F);
|
|
|
|
void visitBasicBlock(BasicBlock &BB);
|
2006-11-27 01:05:10 +00:00
|
|
|
void visitTruncInst(TruncInst &I);
|
|
|
|
void visitZExtInst(ZExtInst &I);
|
|
|
|
void visitSExtInst(SExtInst &I);
|
|
|
|
void visitFPTruncInst(FPTruncInst &I);
|
|
|
|
void visitFPExtInst(FPExtInst &I);
|
|
|
|
void visitFPToUIInst(FPToUIInst &I);
|
|
|
|
void visitFPToSIInst(FPToSIInst &I);
|
|
|
|
void visitUIToFPInst(UIToFPInst &I);
|
|
|
|
void visitSIToFPInst(SIToFPInst &I);
|
|
|
|
void visitIntToPtrInst(IntToPtrInst &I);
|
|
|
|
void visitPtrToIntInst(PtrToIntInst &I);
|
|
|
|
void visitBitCastInst(BitCastInst &I);
|
2002-06-25 15:56:27 +00:00
|
|
|
void visitPHINode(PHINode &PN);
|
|
|
|
void visitBinaryOperator(BinaryOperator &B);
|
2006-11-20 01:22:35 +00:00
|
|
|
void visitICmpInst(ICmpInst &IC);
|
|
|
|
void visitFCmpInst(FCmpInst &FC);
|
2006-01-10 19:05:34 +00:00
|
|
|
void visitExtractElementInst(ExtractElementInst &EI);
|
2006-01-17 20:07:22 +00:00
|
|
|
void visitInsertElementInst(InsertElementInst &EI);
|
2006-04-08 01:18:18 +00:00
|
|
|
void visitShuffleVectorInst(ShuffleVectorInst &EI);
|
2003-10-18 05:57:43 +00:00
|
|
|
void visitVAArgInst(VAArgInst &VAA) { visitInstruction(VAA); }
|
2002-06-25 15:56:27 +00:00
|
|
|
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);
|
2004-05-21 16:47:21 +00:00
|
|
|
void visitSwitchInst(SwitchInst &SI);
|
2004-03-12 05:54:31 +00:00
|
|
|
void visitSelectInst(SelectInst &SI);
|
2002-11-21 16:54:22 +00:00
|
|
|
void visitUserOp1(Instruction &I);
|
|
|
|
void visitUserOp2(Instruction &I) { visitUserOp1(I); }
|
2003-11-11 22:41:34 +00:00
|
|
|
void visitIntrinsicFunctionCall(Intrinsic::ID ID, CallInst &CI);
|
2002-04-18 20:37:37 +00:00
|
|
|
|
2006-03-31 04:46:47 +00:00
|
|
|
void VerifyIntrinsicPrototype(Function *F, ...);
|
2003-11-21 17:35:51 +00:00
|
|
|
|
|
|
|
void WriteValue(const Value *V) {
|
|
|
|
if (!V) return;
|
2003-11-21 20:23:48 +00:00
|
|
|
if (isa<Instruction>(V)) {
|
2004-04-02 15:45:08 +00:00
|
|
|
msgs << *V;
|
2003-11-21 20:23:48 +00:00
|
|
|
} else {
|
2006-12-06 06:16:21 +00:00
|
|
|
WriteAsOperand(msgs, V, true, Mod);
|
2004-04-02 15:45:08 +00:00
|
|
|
msgs << "\n";
|
2003-11-21 17:35:51 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-05-25 08:53:29 +00:00
|
|
|
void WriteType(const Type* T ) {
|
|
|
|
if ( !T ) return;
|
|
|
|
WriteTypeSymbolic(msgs, T, Mod );
|
|
|
|
}
|
|
|
|
|
2003-11-21 17:35:51 +00:00
|
|
|
|
2002-04-18 20:37:37 +00:00
|
|
|
// 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.
|
2003-11-21 17:35:51 +00:00
|
|
|
void CheckFailed(const std::string &Message,
|
|
|
|
const Value *V1 = 0, const Value *V2 = 0,
|
|
|
|
const Value *V3 = 0, const Value *V4 = 0) {
|
2004-04-02 15:45:08 +00:00
|
|
|
msgs << Message << "\n";
|
2003-11-21 17:35:51 +00:00
|
|
|
WriteValue(V1);
|
|
|
|
WriteValue(V2);
|
|
|
|
WriteValue(V3);
|
|
|
|
WriteValue(V4);
|
2002-04-18 20:37:37 +00:00
|
|
|
Broken = true;
|
2002-02-20 17:55:43 +00:00
|
|
|
}
|
2004-05-25 08:53:29 +00:00
|
|
|
|
2005-04-21 23:48:37 +00:00
|
|
|
void CheckFailed( const std::string& Message, const Value* V1,
|
2004-05-25 08:53:29 +00:00
|
|
|
const Type* T2, const Value* V3 = 0 ) {
|
|
|
|
msgs << Message << "\n";
|
|
|
|
WriteValue(V1);
|
|
|
|
WriteType(T2);
|
|
|
|
WriteValue(V3);
|
2004-05-27 21:58:13 +00:00
|
|
|
Broken = true;
|
2004-05-25 08:53:29 +00:00
|
|
|
}
|
2002-04-18 20:37:37 +00:00
|
|
|
};
|
2002-07-23 18:08:17 +00:00
|
|
|
|
2006-08-27 22:42:52 +00:00
|
|
|
RegisterPass<Verifier> X("verify", "Module Verifier");
|
2003-11-21 20:23:48 +00:00
|
|
|
} // End anonymous namespace
|
|
|
|
|
2002-02-20 17:55:43 +00:00
|
|
|
|
2002-04-18 20:37:37 +00:00
|
|
|
// Assert - We know that cond should be true, if not print an error message.
|
|
|
|
#define Assert(C, M) \
|
2002-04-28 16:06:24 +00:00
|
|
|
do { if (!(C)) { CheckFailed(M); return; } } while (0)
|
2002-04-18 20:37:37 +00:00
|
|
|
#define Assert1(C, M, V1) \
|
2002-04-28 16:06:24 +00:00
|
|
|
do { if (!(C)) { CheckFailed(M, V1); return; } } while (0)
|
2002-04-18 20:37:37 +00:00
|
|
|
#define Assert2(C, M, V1, V2) \
|
2002-04-28 16:06:24 +00:00
|
|
|
do { if (!(C)) { CheckFailed(M, V1, V2); return; } } while (0)
|
2002-06-25 15:56:27 +00:00
|
|
|
#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)
|
2002-02-20 17:55:43 +00:00
|
|
|
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2003-04-16 20:42:40 +00:00
|
|
|
void Verifier::visitGlobalValue(GlobalValue &GV) {
|
2007-01-30 20:08:39 +00:00
|
|
|
Assert1(!GV.isDeclaration() ||
|
2006-09-14 18:23:27 +00:00
|
|
|
GV.hasExternalLinkage() ||
|
|
|
|
GV.hasDLLImportLinkage() ||
|
|
|
|
GV.hasExternalWeakLinkage(),
|
|
|
|
"Global is external, but doesn't have external or dllimport or weak linkage!",
|
|
|
|
&GV);
|
|
|
|
|
2007-01-30 20:08:39 +00:00
|
|
|
Assert1(!GV.hasDLLImportLinkage() || GV.isDeclaration(),
|
2006-09-14 18:23:27 +00:00
|
|
|
"Global is marked as dllimport, but not external", &GV);
|
|
|
|
|
2003-04-16 20:42:40 +00:00
|
|
|
Assert1(!GV.hasAppendingLinkage() || isa<GlobalVariable>(GV),
|
|
|
|
"Only global variables can have appending linkage!", &GV);
|
|
|
|
|
|
|
|
if (GV.hasAppendingLinkage()) {
|
|
|
|
GlobalVariable &GVar = cast<GlobalVariable>(GV);
|
|
|
|
Assert1(isa<ArrayType>(GVar.getType()->getElementType()),
|
|
|
|
"Only global arrays can have appending linkage!", &GV);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-12-15 20:23:49 +00:00
|
|
|
void Verifier::visitGlobalVariable(GlobalVariable &GV) {
|
2005-04-21 23:48:37 +00:00
|
|
|
if (GV.hasInitializer())
|
2004-12-15 20:23:49 +00:00
|
|
|
Assert1(GV.getInitializer()->getType() == GV.getType()->getElementType(),
|
|
|
|
"Global variable initializer type does not match global "
|
|
|
|
"variable type!", &GV);
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2004-12-15 20:23:49 +00:00
|
|
|
visitGlobalValue(GV);
|
|
|
|
}
|
|
|
|
|
2007-01-06 07:24:44 +00:00
|
|
|
void Verifier::verifyTypeSymbolTable(TypeSymbolTable &ST) {
|
|
|
|
}
|
2004-12-15 20:23:49 +00:00
|
|
|
|
2002-04-18 20:37:37 +00:00
|
|
|
// visitFunction - Verify that a function is ok.
|
2002-02-20 17:55:43 +00:00
|
|
|
//
|
2002-06-25 15:56:27 +00:00
|
|
|
void Verifier::visitFunction(Function &F) {
|
2005-05-08 22:27:09 +00:00
|
|
|
// Check function arguments.
|
2002-06-25 15:56:27 +00:00
|
|
|
const FunctionType *FT = F.getFunctionType();
|
|
|
|
unsigned NumArgs = F.getArgumentList().size();
|
2002-04-13 22:48:46 +00:00
|
|
|
|
2002-10-13 20:57:00 +00:00
|
|
|
Assert2(FT->getNumParams() == NumArgs,
|
2002-04-13 22:48:46 +00:00
|
|
|
"# formal arguments must match # of arguments for function type!",
|
2002-06-25 15:56:27 +00:00
|
|
|
&F, FT);
|
2003-11-21 22:32:23 +00:00
|
|
|
Assert1(F.getReturnType()->isFirstClassType() ||
|
|
|
|
F.getReturnType() == Type::VoidTy,
|
|
|
|
"Functions cannot return aggregate values!", &F);
|
2002-04-13 22:48:46 +00:00
|
|
|
|
2007-01-28 13:31:35 +00:00
|
|
|
Assert1(!FT->isStructReturn() ||
|
|
|
|
(FT->getReturnType() == Type::VoidTy &&
|
|
|
|
FT->getNumParams() > 0 && isa<PointerType>(FT->getParamType(0))),
|
|
|
|
"Invalid struct-return function!", &F);
|
|
|
|
|
2006-05-19 21:25:17 +00:00
|
|
|
// Check that this function meets the restrictions on this calling convention.
|
|
|
|
switch (F.getCallingConv()) {
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
case CallingConv::C:
|
|
|
|
break;
|
|
|
|
case CallingConv::Fast:
|
|
|
|
case CallingConv::Cold:
|
2006-09-17 20:25:45 +00:00
|
|
|
case CallingConv::X86_FastCall:
|
2006-05-19 21:25:17 +00:00
|
|
|
Assert1(!F.isVarArg(),
|
|
|
|
"Varargs functions must have C calling conventions!", &F);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2002-04-13 22:48:46 +00:00
|
|
|
// Check that the argument values match the function type for this function...
|
2002-10-13 20:57:00 +00:00
|
|
|
unsigned i = 0;
|
2006-12-16 02:25:35 +00:00
|
|
|
for (Function::arg_iterator I = F.arg_begin(), E = F.arg_end();
|
|
|
|
I != E; ++I, ++i) {
|
2002-10-13 20:57:00 +00:00
|
|
|
Assert2(I->getType() == FT->getParamType(i),
|
|
|
|
"Argument value does not match function argument type!",
|
|
|
|
I, FT->getParamType(i));
|
2004-06-03 06:38:43 +00:00
|
|
|
// Make sure no aggregates are passed by value.
|
2005-04-21 23:48:37 +00:00
|
|
|
Assert1(I->getType()->isFirstClassType(),
|
2004-06-03 06:38:43 +00:00
|
|
|
"Functions cannot take aggregates as arguments by value!", I);
|
|
|
|
}
|
2002-10-13 20:57:00 +00:00
|
|
|
|
2007-01-30 20:08:39 +00:00
|
|
|
if (!F.isDeclaration()) {
|
2006-12-13 04:45:46 +00:00
|
|
|
// Verify that this function (which has a body) is not named "llvm.*". It
|
|
|
|
// is not legal to define intrinsics.
|
|
|
|
if (F.getName().size() >= 5)
|
|
|
|
Assert1(F.getName().substr(0, 5) != "llvm.",
|
|
|
|
"llvm intrinsics cannot be defined!", &F);
|
|
|
|
|
2002-10-13 20:57:00 +00:00
|
|
|
// Check the entry node
|
2003-09-20 14:39:18 +00:00
|
|
|
BasicBlock *Entry = &F.getEntryBlock();
|
2002-10-13 20:57:00 +00:00
|
|
|
Assert1(pred_begin(Entry) == pred_end(Entry),
|
|
|
|
"Entry block to function must not have predecessors!", Entry);
|
2002-04-13 22:48:46 +00:00
|
|
|
}
|
2002-04-18 20:37:37 +00:00
|
|
|
}
|
|
|
|
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2002-04-18 20:37:37 +00:00
|
|
|
// verifyBasicBlock - Verify that a basic block is well formed...
|
|
|
|
//
|
2002-06-25 15:56:27 +00:00
|
|
|
void Verifier::visitBasicBlock(BasicBlock &BB) {
|
2004-09-29 20:07:45 +00:00
|
|
|
InstsInThisBlock.clear();
|
|
|
|
|
2004-12-04 02:30:42 +00:00
|
|
|
// Ensure that basic blocks have terminators!
|
|
|
|
Assert1(BB.getTerminator(), "Basic Block does not have terminator!", &BB);
|
|
|
|
|
2003-10-05 17:44:18 +00:00
|
|
|
// Check constraints that this basic block imposes on all of the PHI nodes in
|
|
|
|
// it.
|
|
|
|
if (isa<PHINode>(BB.front())) {
|
2007-02-10 08:33:11 +00:00
|
|
|
SmallVector<BasicBlock*, 8> Preds(pred_begin(&BB), pred_end(&BB));
|
|
|
|
SmallVector<std::pair<BasicBlock*, Value*>, 8> Values;
|
2003-10-05 17:44:18 +00:00
|
|
|
std::sort(Preds.begin(), Preds.end());
|
2005-04-21 23:48:37 +00:00
|
|
|
PHINode *PN;
|
2004-06-05 17:44:48 +00:00
|
|
|
for (BasicBlock::iterator I = BB.begin(); (PN = dyn_cast<PHINode>(I));++I) {
|
2003-10-05 17:44:18 +00:00
|
|
|
|
|
|
|
// Ensure that PHI nodes have at least one entry!
|
|
|
|
Assert1(PN->getNumIncomingValues() != 0,
|
|
|
|
"PHI nodes must have at least one entry. If the block is dead, "
|
|
|
|
"the PHI should be removed!", PN);
|
2004-05-17 21:15:18 +00:00
|
|
|
Assert1(PN->getNumIncomingValues() == Preds.size(),
|
|
|
|
"PHINode should have one entry for each predecessor of its "
|
|
|
|
"parent basic block!", PN);
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2003-10-05 17:44:18 +00:00
|
|
|
// Get and sort all incoming values in the PHI node...
|
2007-02-10 08:33:11 +00:00
|
|
|
Values.clear();
|
2003-10-05 17:44:18 +00:00
|
|
|
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)));
|
|
|
|
std::sort(Values.begin(), Values.end());
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2003-10-05 17:44:18 +00:00
|
|
|
for (unsigned i = 0, e = Values.size(); i != e; ++i) {
|
|
|
|
// 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.
|
|
|
|
//
|
|
|
|
Assert4(i == 0 || 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);
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2003-10-05 17:44:18 +00:00
|
|
|
// Check to make sure that the predecessors and PHI node entries are
|
|
|
|
// matched up.
|
|
|
|
Assert3(Values[i].first == Preds[i],
|
|
|
|
"PHI node entries do not match predecessors!", PN,
|
2005-04-21 23:48:37 +00:00
|
|
|
Values[i].first, Preds[i]);
|
2003-10-05 17:44:18 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2002-06-25 15:56:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
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());
|
2002-07-18 00:13:42 +00:00
|
|
|
visitInstruction(I);
|
2002-06-25 15:56:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitReturnInst(ReturnInst &RI) {
|
|
|
|
Function *F = RI.getParent()->getParent();
|
|
|
|
if (RI.getNumOperands() == 0)
|
2004-12-04 01:25:06 +00:00
|
|
|
Assert2(F->getReturnType() == Type::VoidTy,
|
|
|
|
"Found return instr that returns void in Function of non-void "
|
|
|
|
"return type!", &RI, F->getReturnType());
|
2002-06-25 15:56:27 +00:00
|
|
|
else
|
|
|
|
Assert2(F->getReturnType() == RI.getOperand(0)->getType(),
|
|
|
|
"Function return type does not match operand "
|
|
|
|
"type of return inst!", &RI, F->getReturnType());
|
|
|
|
|
2003-08-18 14:43:39 +00:00
|
|
|
// Check to make sure that the return value has necessary properties for
|
2002-06-25 15:56:27 +00:00
|
|
|
// terminators...
|
|
|
|
visitTerminatorInst(RI);
|
2001-06-06 20:29:01 +00:00
|
|
|
}
|
|
|
|
|
2004-05-21 16:47:21 +00:00
|
|
|
void Verifier::visitSwitchInst(SwitchInst &SI) {
|
|
|
|
// Check to make sure that all of the constants in the switch instruction
|
|
|
|
// have the same type as the switched-on value.
|
|
|
|
const Type *SwitchTy = SI.getCondition()->getType();
|
|
|
|
for (unsigned i = 1, e = SI.getNumCases(); i != e; ++i)
|
|
|
|
Assert1(SI.getCaseValue(i)->getType() == SwitchTy,
|
|
|
|
"Switch constants must all be same type as switch value!", &SI);
|
|
|
|
|
|
|
|
visitTerminatorInst(SI);
|
|
|
|
}
|
|
|
|
|
2004-03-12 05:54:31 +00:00
|
|
|
void Verifier::visitSelectInst(SelectInst &SI) {
|
2007-01-11 18:21:29 +00:00
|
|
|
Assert1(SI.getCondition()->getType() == Type::Int1Ty,
|
2004-03-12 05:54:31 +00:00
|
|
|
"Select condition type must be bool!", &SI);
|
|
|
|
Assert1(SI.getTrueValue()->getType() == SI.getFalseValue()->getType(),
|
|
|
|
"Select values must have identical types!", &SI);
|
|
|
|
Assert1(SI.getTrueValue()->getType() == SI.getType(),
|
|
|
|
"Select values must have same type as select instruction!", &SI);
|
2004-09-29 21:19:28 +00:00
|
|
|
visitInstruction(SI);
|
2004-03-12 05:54:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2004-03-02 00:22:19 +00:00
|
|
|
/// visitUserOp1 - User defined operators shouldn't live beyond the lifetime of
|
|
|
|
/// a pass, if any exist, it's an error.
|
|
|
|
///
|
2002-11-21 16:54:22 +00:00
|
|
|
void Verifier::visitUserOp1(Instruction &I) {
|
2006-03-31 04:46:47 +00:00
|
|
|
Assert1(0, "User-defined operators should not live outside of a pass!", &I);
|
2002-11-21 16:54:22 +00:00
|
|
|
}
|
2001-06-06 20:29:01 +00:00
|
|
|
|
2006-11-27 01:05:10 +00:00
|
|
|
void Verifier::visitTruncInst(TruncInst &I) {
|
|
|
|
// Get the source and destination types
|
|
|
|
const Type *SrcTy = I.getOperand(0)->getType();
|
|
|
|
const Type *DestTy = I.getType();
|
|
|
|
|
|
|
|
// Get the size of the types in bits, we'll need this later
|
|
|
|
unsigned SrcBitSize = SrcTy->getPrimitiveSizeInBits();
|
|
|
|
unsigned DestBitSize = DestTy->getPrimitiveSizeInBits();
|
|
|
|
|
2007-01-15 02:27:26 +00:00
|
|
|
Assert1(SrcTy->isInteger(), "Trunc only operates on integer", &I);
|
|
|
|
Assert1(DestTy->isInteger(), "Trunc only produces integer", &I);
|
2006-11-27 01:05:10 +00:00
|
|
|
Assert1(SrcBitSize > DestBitSize,"DestTy too big for Trunc", &I);
|
|
|
|
|
|
|
|
visitInstruction(I);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitZExtInst(ZExtInst &I) {
|
|
|
|
// Get the source and destination types
|
|
|
|
const Type *SrcTy = I.getOperand(0)->getType();
|
|
|
|
const Type *DestTy = I.getType();
|
|
|
|
|
|
|
|
// Get the size of the types in bits, we'll need this later
|
2007-01-15 02:27:26 +00:00
|
|
|
Assert1(SrcTy->isInteger(), "ZExt only operates on integer", &I);
|
|
|
|
Assert1(DestTy->isInteger(), "ZExt only produces an integer", &I);
|
2006-11-27 01:05:10 +00:00
|
|
|
unsigned SrcBitSize = SrcTy->getPrimitiveSizeInBits();
|
|
|
|
unsigned DestBitSize = DestTy->getPrimitiveSizeInBits();
|
|
|
|
|
|
|
|
Assert1(SrcBitSize < DestBitSize,"Type too small for ZExt", &I);
|
|
|
|
|
|
|
|
visitInstruction(I);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitSExtInst(SExtInst &I) {
|
|
|
|
// Get the source and destination types
|
|
|
|
const Type *SrcTy = I.getOperand(0)->getType();
|
|
|
|
const Type *DestTy = I.getType();
|
|
|
|
|
|
|
|
// Get the size of the types in bits, we'll need this later
|
|
|
|
unsigned SrcBitSize = SrcTy->getPrimitiveSizeInBits();
|
|
|
|
unsigned DestBitSize = DestTy->getPrimitiveSizeInBits();
|
|
|
|
|
2007-01-15 02:27:26 +00:00
|
|
|
Assert1(SrcTy->isInteger(), "SExt only operates on integer", &I);
|
|
|
|
Assert1(DestTy->isInteger(), "SExt only produces an integer", &I);
|
2006-11-27 01:05:10 +00:00
|
|
|
Assert1(SrcBitSize < DestBitSize,"Type too small for SExt", &I);
|
|
|
|
|
|
|
|
visitInstruction(I);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitFPTruncInst(FPTruncInst &I) {
|
|
|
|
// Get the source and destination types
|
|
|
|
const Type *SrcTy = I.getOperand(0)->getType();
|
|
|
|
const Type *DestTy = I.getType();
|
|
|
|
// Get the size of the types in bits, we'll need this later
|
|
|
|
unsigned SrcBitSize = SrcTy->getPrimitiveSizeInBits();
|
|
|
|
unsigned DestBitSize = DestTy->getPrimitiveSizeInBits();
|
|
|
|
|
|
|
|
Assert1(SrcTy->isFloatingPoint(),"FPTrunc only operates on FP", &I);
|
|
|
|
Assert1(DestTy->isFloatingPoint(),"FPTrunc only produces an FP", &I);
|
|
|
|
Assert1(SrcBitSize > DestBitSize,"DestTy too big for FPTrunc", &I);
|
|
|
|
|
|
|
|
visitInstruction(I);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitFPExtInst(FPExtInst &I) {
|
|
|
|
// Get the source and destination types
|
|
|
|
const Type *SrcTy = I.getOperand(0)->getType();
|
|
|
|
const Type *DestTy = I.getType();
|
|
|
|
|
|
|
|
// Get the size of the types in bits, we'll need this later
|
|
|
|
unsigned SrcBitSize = SrcTy->getPrimitiveSizeInBits();
|
|
|
|
unsigned DestBitSize = DestTy->getPrimitiveSizeInBits();
|
|
|
|
|
|
|
|
Assert1(SrcTy->isFloatingPoint(),"FPExt only operates on FP", &I);
|
|
|
|
Assert1(DestTy->isFloatingPoint(),"FPExt only produces an FP", &I);
|
|
|
|
Assert1(SrcBitSize < DestBitSize,"DestTy too small for FPExt", &I);
|
|
|
|
|
|
|
|
visitInstruction(I);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitUIToFPInst(UIToFPInst &I) {
|
|
|
|
// Get the source and destination types
|
|
|
|
const Type *SrcTy = I.getOperand(0)->getType();
|
|
|
|
const Type *DestTy = I.getType();
|
|
|
|
|
2007-01-15 02:27:26 +00:00
|
|
|
Assert1(SrcTy->isInteger(),"UInt2FP source must be integral", &I);
|
2006-11-27 01:05:10 +00:00
|
|
|
Assert1(DestTy->isFloatingPoint(),"UInt2FP result must be FP", &I);
|
|
|
|
|
|
|
|
visitInstruction(I);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitSIToFPInst(SIToFPInst &I) {
|
|
|
|
// Get the source and destination types
|
|
|
|
const Type *SrcTy = I.getOperand(0)->getType();
|
|
|
|
const Type *DestTy = I.getType();
|
|
|
|
|
2007-01-15 02:27:26 +00:00
|
|
|
Assert1(SrcTy->isInteger(),"SInt2FP source must be integral", &I);
|
2006-11-27 01:05:10 +00:00
|
|
|
Assert1(DestTy->isFloatingPoint(),"SInt2FP result must be FP", &I);
|
|
|
|
|
|
|
|
visitInstruction(I);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitFPToUIInst(FPToUIInst &I) {
|
|
|
|
// Get the source and destination types
|
|
|
|
const Type *SrcTy = I.getOperand(0)->getType();
|
|
|
|
const Type *DestTy = I.getType();
|
|
|
|
|
|
|
|
Assert1(SrcTy->isFloatingPoint(),"FP2UInt source must be FP", &I);
|
2007-01-15 02:27:26 +00:00
|
|
|
Assert1(DestTy->isInteger(),"FP2UInt result must be integral", &I);
|
2006-11-27 01:05:10 +00:00
|
|
|
|
|
|
|
visitInstruction(I);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitFPToSIInst(FPToSIInst &I) {
|
|
|
|
// Get the source and destination types
|
|
|
|
const Type *SrcTy = I.getOperand(0)->getType();
|
|
|
|
const Type *DestTy = I.getType();
|
|
|
|
|
|
|
|
Assert1(SrcTy->isFloatingPoint(),"FPToSI source must be FP", &I);
|
2007-01-15 02:27:26 +00:00
|
|
|
Assert1(DestTy->isInteger(),"FP2ToI result must be integral", &I);
|
2006-11-27 01:05:10 +00:00
|
|
|
|
|
|
|
visitInstruction(I);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitPtrToIntInst(PtrToIntInst &I) {
|
|
|
|
// Get the source and destination types
|
|
|
|
const Type *SrcTy = I.getOperand(0)->getType();
|
|
|
|
const Type *DestTy = I.getType();
|
|
|
|
|
|
|
|
Assert1(isa<PointerType>(SrcTy), "PtrToInt source must be pointer", &I);
|
2007-01-15 02:27:26 +00:00
|
|
|
Assert1(DestTy->isInteger(), "PtrToInt result must be integral", &I);
|
2006-11-27 01:05:10 +00:00
|
|
|
|
|
|
|
visitInstruction(I);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitIntToPtrInst(IntToPtrInst &I) {
|
|
|
|
// Get the source and destination types
|
|
|
|
const Type *SrcTy = I.getOperand(0)->getType();
|
|
|
|
const Type *DestTy = I.getType();
|
|
|
|
|
2007-01-15 02:27:26 +00:00
|
|
|
Assert1(SrcTy->isInteger(), "IntToPtr source must be an integral", &I);
|
2006-11-27 01:05:10 +00:00
|
|
|
Assert1(isa<PointerType>(DestTy), "IntToPtr result must be a pointer",&I);
|
|
|
|
|
|
|
|
visitInstruction(I);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitBitCastInst(BitCastInst &I) {
|
|
|
|
// Get the source and destination types
|
|
|
|
const Type *SrcTy = I.getOperand(0)->getType();
|
|
|
|
const Type *DestTy = I.getType();
|
|
|
|
|
|
|
|
// Get the size of the types in bits, we'll need this later
|
|
|
|
unsigned SrcBitSize = SrcTy->getPrimitiveSizeInBits();
|
|
|
|
unsigned DestBitSize = DestTy->getPrimitiveSizeInBits();
|
|
|
|
|
|
|
|
// BitCast implies a no-op cast of type only. No bits change.
|
|
|
|
// However, you can't cast pointers to anything but pointers.
|
|
|
|
Assert1(isa<PointerType>(DestTy) == isa<PointerType>(DestTy),
|
|
|
|
"Bitcast requires both operands to be pointer or neither", &I);
|
|
|
|
Assert1(SrcBitSize == DestBitSize, "Bitcast requies types of same width", &I);
|
|
|
|
|
|
|
|
visitInstruction(I);
|
|
|
|
}
|
|
|
|
|
2004-03-02 00:22:19 +00:00
|
|
|
/// visitPHINode - Ensure that a PHI node is well formed.
|
|
|
|
///
|
2002-06-25 15:56:27 +00:00
|
|
|
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
|
2003-10-10 17:54:14 +00:00
|
|
|
// either nonexistent (because this is begin()) or is a PHI node. If not,
|
2002-06-25 15:56:27 +00:00
|
|
|
// then there is some other instruction before a PHI.
|
2003-10-05 17:44:18 +00:00
|
|
|
Assert2(&PN.getParent()->front() == &PN || isa<PHINode>(PN.getPrev()),
|
2002-06-25 15:56:27 +00:00
|
|
|
"PHI nodes not grouped at top of basic block!",
|
|
|
|
&PN, PN.getParent());
|
|
|
|
|
2003-11-12 07:13:37 +00:00
|
|
|
// Check that all of the operands of the PHI node have the same type as the
|
|
|
|
// result.
|
|
|
|
for (unsigned i = 0, e = PN.getNumIncomingValues(); i != e; ++i)
|
|
|
|
Assert1(PN.getType() == PN.getIncomingValue(i)->getType(),
|
|
|
|
"PHI node operands are not the same type as the result!", &PN);
|
|
|
|
|
2003-10-05 17:44:18 +00:00
|
|
|
// All other PHI node constraints are checked in the visitBasicBlock method.
|
2002-04-18 20:37:37 +00:00
|
|
|
|
|
|
|
visitInstruction(PN);
|
|
|
|
}
|
2002-03-15 20:25:09 +00:00
|
|
|
|
2002-06-25 15:56:27 +00:00
|
|
|
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());
|
2002-04-18 22:11:52 +00:00
|
|
|
Assert1(isa<FunctionType>(FPTy->getElementType()),
|
2002-06-25 15:56:27 +00:00
|
|
|
"Called function is not pointer to function type!", &CI);
|
2002-05-08 19:49:50 +00:00
|
|
|
|
2002-06-25 15:56:27 +00:00
|
|
|
const FunctionType *FTy = cast<FunctionType>(FPTy->getElementType());
|
2002-05-08 19:49:50 +00:00
|
|
|
|
|
|
|
// Verify that the correct number of arguments are being passed
|
|
|
|
if (FTy->isVarArg())
|
2002-06-25 15:56:27 +00:00
|
|
|
Assert1(CI.getNumOperands()-1 >= FTy->getNumParams(),
|
|
|
|
"Called function requires more parameters than were provided!",&CI);
|
2002-05-08 19:49:50 +00:00
|
|
|
else
|
2002-06-25 15:56:27 +00:00
|
|
|
Assert1(CI.getNumOperands()-1 == FTy->getNumParams(),
|
|
|
|
"Incorrect number of arguments passed to called function!", &CI);
|
2002-05-08 19:49:50 +00:00
|
|
|
|
|
|
|
// Verify that all arguments to the call match the function type...
|
|
|
|
for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i)
|
2004-02-24 22:06:07 +00:00
|
|
|
Assert3(CI.getOperand(i+1)->getType() == FTy->getParamType(i),
|
2002-05-08 19:49:50 +00:00
|
|
|
"Call parameter type does not match function signature!",
|
2004-02-24 22:06:07 +00:00
|
|
|
CI.getOperand(i+1), FTy->getParamType(i), &CI);
|
2002-07-18 00:13:42 +00:00
|
|
|
|
2003-05-08 03:47:33 +00:00
|
|
|
if (Function *F = CI.getCalledFunction())
|
2003-11-11 22:41:34 +00:00
|
|
|
if (Intrinsic::ID ID = (Intrinsic::ID)F->getIntrinsicID())
|
2003-05-08 03:47:33 +00:00
|
|
|
visitIntrinsicFunctionCall(ID, CI);
|
|
|
|
|
2002-07-18 00:13:42 +00:00
|
|
|
visitInstruction(CI);
|
2002-04-18 22:11:52 +00:00
|
|
|
}
|
2002-04-18 20:37:37 +00:00
|
|
|
|
2004-03-02 00:22:19 +00:00
|
|
|
/// visitBinaryOperator - Check that both arguments to the binary operator are
|
|
|
|
/// of the same type!
|
|
|
|
///
|
2002-06-25 15:56:27 +00:00
|
|
|
void Verifier::visitBinaryOperator(BinaryOperator &B) {
|
2002-09-09 20:26:04 +00:00
|
|
|
Assert1(B.getOperand(0)->getType() == B.getOperand(1)->getType(),
|
|
|
|
"Both operands to a binary operator are not of the same type!", &B);
|
|
|
|
|
2007-02-02 02:16:23 +00:00
|
|
|
switch (B.getOpcode()) {
|
2002-09-09 20:26:04 +00:00
|
|
|
// Check that logical operators are only used with integral operands.
|
2007-02-02 02:16:23 +00:00
|
|
|
case Instruction::And:
|
|
|
|
case Instruction::Or:
|
|
|
|
case Instruction::Xor:
|
2007-01-15 02:27:26 +00:00
|
|
|
Assert1(B.getType()->isInteger() ||
|
2007-02-15 02:26:10 +00:00
|
|
|
(isa<VectorType>(B.getType()) &&
|
|
|
|
cast<VectorType>(B.getType())->getElementType()->isInteger()),
|
2002-09-09 20:26:04 +00:00
|
|
|
"Logical operators only work with integral types!", &B);
|
|
|
|
Assert1(B.getType() == B.getOperand(0)->getType(),
|
|
|
|
"Logical operators must have same type for operands and result!",
|
|
|
|
&B);
|
2007-02-02 02:16:23 +00:00
|
|
|
break;
|
|
|
|
case Instruction::Shl:
|
|
|
|
case Instruction::LShr:
|
|
|
|
case Instruction::AShr:
|
|
|
|
Assert1(B.getType()->isInteger(),
|
|
|
|
"Shift must return an integer result!", &B);
|
|
|
|
Assert1(B.getType() == B.getOperand(0)->getType(),
|
|
|
|
"Shift return type must be same as operands!", &B);
|
|
|
|
/* FALL THROUGH */
|
|
|
|
default:
|
2002-09-09 20:26:04 +00:00
|
|
|
// Arithmetic operators only work on integer or fp values
|
|
|
|
Assert1(B.getType() == B.getOperand(0)->getType(),
|
|
|
|
"Arithmetic operators must have same type for operands and result!",
|
|
|
|
&B);
|
2007-01-15 02:27:26 +00:00
|
|
|
Assert1(B.getType()->isInteger() || B.getType()->isFloatingPoint() ||
|
2007-02-15 02:26:10 +00:00
|
|
|
isa<VectorType>(B.getType()),
|
2007-02-15 03:39:18 +00:00
|
|
|
"Arithmetic operators must have integer, fp, or vector type!", &B);
|
2007-02-02 02:16:23 +00:00
|
|
|
break;
|
2002-09-09 20:26:04 +00:00
|
|
|
}
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2002-04-18 20:37:37 +00:00
|
|
|
visitInstruction(B);
|
2002-02-20 17:55:43 +00:00
|
|
|
}
|
|
|
|
|
2006-11-20 01:22:35 +00:00
|
|
|
void Verifier::visitICmpInst(ICmpInst& IC) {
|
|
|
|
// Check that the operands are the same type
|
|
|
|
const Type* Op0Ty = IC.getOperand(0)->getType();
|
|
|
|
const Type* Op1Ty = IC.getOperand(1)->getType();
|
|
|
|
Assert1(Op0Ty == Op1Ty,
|
|
|
|
"Both operands to ICmp instruction are not of the same type!", &IC);
|
|
|
|
// Check that the operands are the right type
|
2007-01-15 02:27:26 +00:00
|
|
|
Assert1(Op0Ty->isInteger() || isa<PointerType>(Op0Ty),
|
2006-11-20 01:22:35 +00:00
|
|
|
"Invalid operand types for ICmp instruction", &IC);
|
|
|
|
visitInstruction(IC);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitFCmpInst(FCmpInst& FC) {
|
|
|
|
// Check that the operands are the same type
|
|
|
|
const Type* Op0Ty = FC.getOperand(0)->getType();
|
|
|
|
const Type* Op1Ty = FC.getOperand(1)->getType();
|
|
|
|
Assert1(Op0Ty == Op1Ty,
|
|
|
|
"Both operands to FCmp instruction are not of the same type!", &FC);
|
|
|
|
// Check that the operands are the right type
|
2007-01-04 05:22:18 +00:00
|
|
|
Assert1(Op0Ty->isFloatingPoint(),
|
2006-11-20 01:22:35 +00:00
|
|
|
"Invalid operand types for FCmp instruction", &FC);
|
|
|
|
visitInstruction(FC);
|
|
|
|
}
|
|
|
|
|
2006-01-10 19:05:34 +00:00
|
|
|
void Verifier::visitExtractElementInst(ExtractElementInst &EI) {
|
2006-04-08 04:07:52 +00:00
|
|
|
Assert1(ExtractElementInst::isValidOperands(EI.getOperand(0),
|
|
|
|
EI.getOperand(1)),
|
|
|
|
"Invalid extractelement operands!", &EI);
|
2006-01-10 19:05:34 +00:00
|
|
|
visitInstruction(EI);
|
|
|
|
}
|
|
|
|
|
2006-01-17 20:07:22 +00:00
|
|
|
void Verifier::visitInsertElementInst(InsertElementInst &IE) {
|
2006-04-08 04:07:52 +00:00
|
|
|
Assert1(InsertElementInst::isValidOperands(IE.getOperand(0),
|
|
|
|
IE.getOperand(1),
|
|
|
|
IE.getOperand(2)),
|
|
|
|
"Invalid insertelement operands!", &IE);
|
2006-01-17 20:07:22 +00:00
|
|
|
visitInstruction(IE);
|
|
|
|
}
|
|
|
|
|
2006-04-08 01:18:18 +00:00
|
|
|
void Verifier::visitShuffleVectorInst(ShuffleVectorInst &SV) {
|
|
|
|
Assert1(ShuffleVectorInst::isValidOperands(SV.getOperand(0), SV.getOperand(1),
|
|
|
|
SV.getOperand(2)),
|
|
|
|
"Invalid shufflevector operands!", &SV);
|
|
|
|
Assert1(SV.getType() == SV.getOperand(0)->getType(),
|
|
|
|
"Result of shufflevector must match first operand type!", &SV);
|
|
|
|
|
|
|
|
// Check to see if Mask is valid.
|
2007-02-15 02:26:10 +00:00
|
|
|
if (const ConstantVector *MV = dyn_cast<ConstantVector>(SV.getOperand(2))) {
|
2006-04-08 01:18:18 +00:00
|
|
|
for (unsigned i = 0, e = MV->getNumOperands(); i != e; ++i) {
|
2006-10-20 07:07:24 +00:00
|
|
|
Assert1(isa<ConstantInt>(MV->getOperand(i)) ||
|
2006-04-08 01:18:18 +00:00
|
|
|
isa<UndefValue>(MV->getOperand(i)),
|
|
|
|
"Invalid shufflevector shuffle mask!", &SV);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
Assert1(isa<UndefValue>(SV.getOperand(2)) ||
|
|
|
|
isa<ConstantAggregateZero>(SV.getOperand(2)),
|
|
|
|
"Invalid shufflevector shuffle mask!", &SV);
|
|
|
|
}
|
|
|
|
|
|
|
|
visitInstruction(SV);
|
|
|
|
}
|
|
|
|
|
2002-06-25 15:56:27 +00:00
|
|
|
void Verifier::visitGetElementPtrInst(GetElementPtrInst &GEP) {
|
2007-02-10 08:30:29 +00:00
|
|
|
SmallVector<Value*, 16> Idxs(GEP.idx_begin(), GEP.idx_end());
|
2002-08-22 23:37:20 +00:00
|
|
|
const Type *ElTy =
|
|
|
|
GetElementPtrInst::getIndexedType(GEP.getOperand(0)->getType(),
|
2007-02-10 08:30:29 +00:00
|
|
|
&Idxs[0], Idxs.size(), true);
|
2002-06-25 15:56:27 +00:00
|
|
|
Assert1(ElTy, "Invalid indices for GEP pointer type!", &GEP);
|
2007-02-10 08:30:29 +00:00
|
|
|
Assert2(isa<PointerType>(GEP.getType()) &&
|
|
|
|
cast<PointerType>(GEP.getType())->getElementType() == ElTy,
|
2002-06-25 15:56:27 +00:00
|
|
|
"GEP is not of right type for indices!", &GEP, ElTy);
|
2002-04-24 19:12:21 +00:00
|
|
|
visitInstruction(GEP);
|
|
|
|
}
|
|
|
|
|
2002-06-25 15:56:27 +00:00
|
|
|
void Verifier::visitLoadInst(LoadInst &LI) {
|
2002-08-22 22:49:05 +00:00
|
|
|
const Type *ElTy =
|
|
|
|
cast<PointerType>(LI.getOperand(0)->getType())->getElementType();
|
2002-06-25 15:56:27 +00:00
|
|
|
Assert2(ElTy == LI.getType(),
|
2003-11-21 17:06:29 +00:00
|
|
|
"Load result type does not match pointer operand type!", &LI, ElTy);
|
2002-04-24 19:12:21 +00:00
|
|
|
visitInstruction(LI);
|
|
|
|
}
|
|
|
|
|
2002-06-25 15:56:27 +00:00
|
|
|
void Verifier::visitStoreInst(StoreInst &SI) {
|
2002-08-22 22:49:05 +00:00
|
|
|
const Type *ElTy =
|
|
|
|
cast<PointerType>(SI.getOperand(1)->getType())->getElementType();
|
2002-06-25 15:56:27 +00:00
|
|
|
Assert2(ElTy == SI.getOperand(0)->getType(),
|
2003-11-21 17:06:29 +00:00
|
|
|
"Stored value type does not match pointer operand type!", &SI, ElTy);
|
2002-04-24 19:12:21 +00:00
|
|
|
visitInstruction(SI);
|
|
|
|
}
|
|
|
|
|
2002-04-18 20:37:37 +00:00
|
|
|
|
2004-03-02 00:22:19 +00:00
|
|
|
/// verifyInstruction - Verify that an instruction is well formed.
|
|
|
|
///
|
2002-06-25 15:56:27 +00:00
|
|
|
void Verifier::visitInstruction(Instruction &I) {
|
2005-04-21 23:48:37 +00:00
|
|
|
BasicBlock *BB = I.getParent();
|
2002-09-09 20:26:04 +00:00
|
|
|
Assert1(BB, "Instruction not embedded in basic block!", &I);
|
2002-04-18 20:37:37 +00:00
|
|
|
|
|
|
|
if (!isa<PHINode>(I)) { // Check that non-phi nodes are not self referential
|
2002-06-25 15:56:27 +00:00
|
|
|
for (Value::use_iterator UI = I.use_begin(), UE = I.use_end();
|
2002-04-18 20:37:37 +00:00
|
|
|
UI != UE; ++UI)
|
2004-02-27 17:28:25 +00:00
|
|
|
Assert1(*UI != (User*)&I ||
|
2006-01-12 06:17:59 +00:00
|
|
|
!EF->dominates(&BB->getParent()->getEntryBlock(), BB),
|
2002-06-25 15:56:27 +00:00
|
|
|
"Only PHI nodes may reference their own value!", &I);
|
2002-04-18 20:37:37 +00:00
|
|
|
}
|
|
|
|
|
2002-07-18 00:13:42 +00:00
|
|
|
// Check that void typed values don't have names
|
2002-06-25 15:56:27 +00:00
|
|
|
Assert1(I.getType() != Type::VoidTy || !I.hasName(),
|
|
|
|
"Instruction has a name, but provides a void value!", &I);
|
2002-07-18 00:13:42 +00:00
|
|
|
|
2004-03-29 00:29:36 +00:00
|
|
|
// Check that the return value of the instruction is either void or a legal
|
|
|
|
// value type.
|
|
|
|
Assert1(I.getType() == Type::VoidTy || I.getType()->isFirstClassType(),
|
|
|
|
"Instruction returns a non-scalar type!", &I);
|
|
|
|
|
2003-10-05 17:44:18 +00:00
|
|
|
// 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!
|
2002-07-18 00:13:42 +00:00
|
|
|
for (User::use_iterator UI = I.use_begin(), UE = I.use_end();
|
|
|
|
UI != UE; ++UI) {
|
2003-10-05 17:44:18 +00:00
|
|
|
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);
|
2002-07-18 00:13:42 +00:00
|
|
|
}
|
2003-05-08 03:47:33 +00:00
|
|
|
|
2003-10-05 17:44:18 +00:00
|
|
|
for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i) {
|
2005-02-24 16:58:29 +00:00
|
|
|
Assert1(I.getOperand(i) != 0, "Instruction has null operand!", &I);
|
2006-07-11 20:29:49 +00:00
|
|
|
|
|
|
|
// Check to make sure that only first-class-values are operands to
|
|
|
|
// instructions.
|
|
|
|
Assert1(I.getOperand(i)->getType()->isFirstClassType(),
|
|
|
|
"Instruction operands must be first-class values!", &I);
|
|
|
|
|
2004-03-14 03:23:54 +00:00
|
|
|
if (Function *F = dyn_cast<Function>(I.getOperand(i))) {
|
2006-07-11 20:29:49 +00:00
|
|
|
// Check to make sure that the "address of" an intrinsic function is never
|
|
|
|
// taken.
|
2003-05-08 03:47:33 +00:00
|
|
|
Assert1(!F->isIntrinsic() || (i == 0 && isa<CallInst>(I)),
|
|
|
|
"Cannot take the address of an intrinsic!", &I);
|
2004-03-14 03:23:54 +00:00
|
|
|
} else if (BasicBlock *OpBB = dyn_cast<BasicBlock>(I.getOperand(i))) {
|
|
|
|
Assert1(OpBB->getParent() == BB->getParent(),
|
|
|
|
"Referring to a basic block in another function!", &I);
|
|
|
|
} else if (Argument *OpArg = dyn_cast<Argument>(I.getOperand(i))) {
|
|
|
|
Assert1(OpArg->getParent() == BB->getParent(),
|
|
|
|
"Referring to an argument in another function!", &I);
|
|
|
|
} else if (Instruction *Op = dyn_cast<Instruction>(I.getOperand(i))) {
|
2004-01-14 04:25:59 +00:00
|
|
|
BasicBlock *OpBlock = Op->getParent();
|
|
|
|
|
2003-10-05 17:44:18 +00:00
|
|
|
// Check that a definition dominates all of its uses.
|
|
|
|
if (!isa<PHINode>(I)) {
|
2004-01-14 05:42:52 +00:00
|
|
|
// Invoke results are only usable in the normal destination, not in the
|
|
|
|
// exceptional destination.
|
2006-12-16 02:25:35 +00:00
|
|
|
if (InvokeInst *II = dyn_cast<InvokeInst>(Op)) {
|
2004-01-14 05:42:52 +00:00
|
|
|
OpBlock = II->getNormalDest();
|
2006-12-16 02:25:35 +00:00
|
|
|
|
2006-12-20 21:20:13 +00:00
|
|
|
Assert2(OpBlock != II->getUnwindDest(),
|
|
|
|
"No uses of invoke possible due to dominance structure!",
|
|
|
|
Op, II);
|
|
|
|
|
2006-12-16 02:25:35 +00:00
|
|
|
// If the normal successor of an invoke instruction has multiple
|
|
|
|
// predecessors, then the normal edge from the invoke is critical, so
|
|
|
|
// the invoke value can only be live if the destination block
|
|
|
|
// 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)) {
|
|
|
|
// 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.
|
|
|
|
bool Bad = true;
|
|
|
|
if (PHINode *PN = dyn_cast<PHINode>(&I))
|
|
|
|
if (PN->getParent() == OpBlock &&
|
|
|
|
PN->getIncomingBlock(i/2) == Op->getParent())
|
|
|
|
Bad = false;
|
|
|
|
|
|
|
|
// If it is used by something non-phi, then the other case is that
|
|
|
|
// 'OpBlock' dominates all of its predecessors other than the
|
|
|
|
// invoke. In this case, the invoke value can still be used.
|
2006-12-20 19:50:15 +00:00
|
|
|
if (Bad) {
|
|
|
|
Bad = false;
|
2006-12-16 02:25:35 +00:00
|
|
|
for (pred_iterator PI = pred_begin(OpBlock),
|
|
|
|
E = pred_end(OpBlock); PI != E; ++PI) {
|
|
|
|
if (*PI != II->getParent() && !EF->dominates(OpBlock, *PI)) {
|
|
|
|
Bad = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2006-12-20 21:20:13 +00:00
|
|
|
Assert2(!Bad,
|
|
|
|
"Invoke value defined on critical edge but not dead!", &I,
|
|
|
|
Op);
|
2006-12-16 02:25:35 +00:00
|
|
|
}
|
|
|
|
} else if (OpBlock == BB) {
|
2004-04-16 05:51:47 +00:00
|
|
|
// If they are in the same basic block, make sure that the definition
|
|
|
|
// comes before the use.
|
2004-09-29 20:07:45 +00:00
|
|
|
Assert2(InstsInThisBlock.count(Op) ||
|
2006-01-12 06:17:59 +00:00
|
|
|
!EF->dominates(&BB->getParent()->getEntryBlock(), BB),
|
2004-04-16 05:51:47 +00:00
|
|
|
"Instruction does not dominate all uses!", Op, &I);
|
|
|
|
}
|
2004-01-14 05:42:52 +00:00
|
|
|
|
2003-10-05 17:44:18 +00:00
|
|
|
// Definition must dominate use unless use is unreachable!
|
2006-01-12 06:17:59 +00:00
|
|
|
Assert2(EF->dominates(OpBlock, BB) ||
|
|
|
|
!EF->dominates(&BB->getParent()->getEntryBlock(), BB),
|
2003-10-05 17:44:18 +00:00
|
|
|
"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));
|
2006-01-12 06:17:59 +00:00
|
|
|
Assert2(EF->dominates(OpBlock, PredBB) ||
|
|
|
|
!EF->dominates(&BB->getParent()->getEntryBlock(), PredBB),
|
2003-10-05 17:44:18 +00:00
|
|
|
"Instruction does not dominate all uses!", Op, &I);
|
|
|
|
}
|
2006-01-26 00:08:45 +00:00
|
|
|
} else if (isa<InlineAsm>(I.getOperand(i))) {
|
|
|
|
Assert1(i == 0 && isa<CallInst>(I),
|
|
|
|
"Cannot take the address of an inline asm!", &I);
|
2003-10-05 17:44:18 +00:00
|
|
|
}
|
|
|
|
}
|
2004-09-29 20:07:45 +00:00
|
|
|
InstsInThisBlock.insert(&I);
|
2003-05-08 03:47:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/// visitIntrinsicFunction - Allow intrinsics to be verified in different ways.
|
2004-03-02 00:22:19 +00:00
|
|
|
///
|
2003-11-11 22:41:34 +00:00
|
|
|
void Verifier::visitIntrinsicFunctionCall(Intrinsic::ID ID, CallInst &CI) {
|
2003-05-08 03:47:33 +00:00
|
|
|
Function *IF = CI.getCalledFunction();
|
2007-01-30 20:08:39 +00:00
|
|
|
Assert1(IF->isDeclaration(), "Intrinsic functions should never be defined!", IF);
|
2006-03-09 22:06:04 +00:00
|
|
|
|
|
|
|
#define GET_INTRINSIC_VERIFIER
|
|
|
|
#include "llvm/Intrinsics.gen"
|
|
|
|
#undef GET_INTRINSIC_VERIFIER
|
2002-04-18 20:37:37 +00:00
|
|
|
}
|
|
|
|
|
2006-03-31 04:46:47 +00:00
|
|
|
/// VerifyIntrinsicPrototype - TableGen emits calls to this function into
|
|
|
|
/// Intrinsics.gen. This implements a little state machine that verifies the
|
|
|
|
/// prototype of intrinsics.
|
|
|
|
void Verifier::VerifyIntrinsicPrototype(Function *F, ...) {
|
|
|
|
va_list VA;
|
|
|
|
va_start(VA, F);
|
|
|
|
|
|
|
|
const FunctionType *FTy = F->getFunctionType();
|
|
|
|
|
|
|
|
// Note that "arg#0" is the return type.
|
|
|
|
for (unsigned ArgNo = 0; 1; ++ArgNo) {
|
|
|
|
int TypeID = va_arg(VA, int);
|
|
|
|
|
2007-02-06 18:02:54 +00:00
|
|
|
if (TypeID == -2) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2006-03-31 04:46:47 +00:00
|
|
|
if (TypeID == -1) {
|
|
|
|
if (ArgNo != FTy->getNumParams()+1)
|
|
|
|
CheckFailed("Intrinsic prototype has too many arguments!", F);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ArgNo == FTy->getNumParams()+1) {
|
|
|
|
CheckFailed("Intrinsic prototype has too few arguments!", F);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
const Type *Ty;
|
|
|
|
if (ArgNo == 0)
|
|
|
|
Ty = FTy->getReturnType();
|
|
|
|
else
|
|
|
|
Ty = FTy->getParamType(ArgNo-1);
|
|
|
|
|
For PR1064:
Implement the arbitrary bit-width integer feature. The feature allows
integers of any bitwidth (up to 64) to be defined instead of just 1, 8,
16, 32, and 64 bit integers.
This change does several things:
1. Introduces a new Derived Type, IntegerType, to represent the number of
bits in an integer. The Type classes SubclassData field is used to
store the number of bits. This allows 2^23 bits in an integer type.
2. Removes the five integer Type::TypeID values for the 1, 8, 16, 32 and
64-bit integers. These are replaced with just IntegerType which is not
a primitive any more.
3. Adjust the rest of LLVM to account for this change.
Note that while this incremental change lays the foundation for arbitrary
bit-width integers, LLVM has not yet been converted to actually deal with
them in any significant way. Most optimization passes, for example, will
still only deal with the byte-width integer types. Future increments
will rectify this situation.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@33113 91177308-0d34-0410-b5e6-96231b3b80d8
2007-01-12 07:05:14 +00:00
|
|
|
if (TypeID != Ty->getTypeID()) {
|
2006-03-31 04:46:47 +00:00
|
|
|
if (ArgNo == 0)
|
|
|
|
CheckFailed("Intrinsic prototype has incorrect result type!", F);
|
|
|
|
else
|
|
|
|
CheckFailed("Intrinsic parameter #" + utostr(ArgNo-1) + " is wrong!",F);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
For PR1064:
Implement the arbitrary bit-width integer feature. The feature allows
integers of any bitwidth (up to 64) to be defined instead of just 1, 8,
16, 32, and 64 bit integers.
This change does several things:
1. Introduces a new Derived Type, IntegerType, to represent the number of
bits in an integer. The Type classes SubclassData field is used to
store the number of bits. This allows 2^23 bits in an integer type.
2. Removes the five integer Type::TypeID values for the 1, 8, 16, 32 and
64-bit integers. These are replaced with just IntegerType which is not
a primitive any more.
3. Adjust the rest of LLVM to account for this change.
Note that while this incremental change lays the foundation for arbitrary
bit-width integers, LLVM has not yet been converted to actually deal with
them in any significant way. Most optimization passes, for example, will
still only deal with the byte-width integer types. Future increments
will rectify this situation.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@33113 91177308-0d34-0410-b5e6-96231b3b80d8
2007-01-12 07:05:14 +00:00
|
|
|
if (TypeID == Type::IntegerTyID) {
|
|
|
|
unsigned GotBits = (unsigned) va_arg(VA, int);
|
|
|
|
unsigned ExpectBits = cast<IntegerType>(Ty)->getBitWidth();
|
|
|
|
if (GotBits != ExpectBits) {
|
|
|
|
std::string bitmsg = " Expecting " + utostr(ExpectBits) + " but got " +
|
|
|
|
utostr(GotBits) + " bits.";
|
|
|
|
if (ArgNo == 0)
|
|
|
|
CheckFailed("Intrinsic prototype has incorrect integer result width!"
|
|
|
|
+ bitmsg, F);
|
|
|
|
else
|
|
|
|
CheckFailed("Intrinsic parameter #" + utostr(ArgNo-1) + " has "
|
|
|
|
"incorrect integer width!" + bitmsg, F);
|
|
|
|
break;
|
|
|
|
}
|
2007-02-15 02:26:10 +00:00
|
|
|
} else if (TypeID == Type::VectorTyID) {
|
For PR1064:
Implement the arbitrary bit-width integer feature. The feature allows
integers of any bitwidth (up to 64) to be defined instead of just 1, 8,
16, 32, and 64 bit integers.
This change does several things:
1. Introduces a new Derived Type, IntegerType, to represent the number of
bits in an integer. The Type classes SubclassData field is used to
store the number of bits. This allows 2^23 bits in an integer type.
2. Removes the five integer Type::TypeID values for the 1, 8, 16, 32 and
64-bit integers. These are replaced with just IntegerType which is not
a primitive any more.
3. Adjust the rest of LLVM to account for this change.
Note that while this incremental change lays the foundation for arbitrary
bit-width integers, LLVM has not yet been converted to actually deal with
them in any significant way. Most optimization passes, for example, will
still only deal with the byte-width integer types. Future increments
will rectify this situation.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@33113 91177308-0d34-0410-b5e6-96231b3b80d8
2007-01-12 07:05:14 +00:00
|
|
|
// If this is a packed argument, verify the number and type of elements.
|
2007-02-15 02:26:10 +00:00
|
|
|
const VectorType *PTy = cast<VectorType>(Ty);
|
For PR1064:
Implement the arbitrary bit-width integer feature. The feature allows
integers of any bitwidth (up to 64) to be defined instead of just 1, 8,
16, 32, and 64 bit integers.
This change does several things:
1. Introduces a new Derived Type, IntegerType, to represent the number of
bits in an integer. The Type classes SubclassData field is used to
store the number of bits. This allows 2^23 bits in an integer type.
2. Removes the five integer Type::TypeID values for the 1, 8, 16, 32 and
64-bit integers. These are replaced with just IntegerType which is not
a primitive any more.
3. Adjust the rest of LLVM to account for this change.
Note that while this incremental change lays the foundation for arbitrary
bit-width integers, LLVM has not yet been converted to actually deal with
them in any significant way. Most optimization passes, for example, will
still only deal with the byte-width integer types. Future increments
will rectify this situation.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@33113 91177308-0d34-0410-b5e6-96231b3b80d8
2007-01-12 07:05:14 +00:00
|
|
|
int ElemTy = va_arg(VA, int);
|
|
|
|
if (ElemTy != PTy->getElementType()->getTypeID()) {
|
|
|
|
CheckFailed("Intrinsic prototype has incorrect vector element type!",
|
|
|
|
F);
|
2006-03-31 04:46:47 +00:00
|
|
|
break;
|
|
|
|
}
|
For PR1064:
Implement the arbitrary bit-width integer feature. The feature allows
integers of any bitwidth (up to 64) to be defined instead of just 1, 8,
16, 32, and 64 bit integers.
This change does several things:
1. Introduces a new Derived Type, IntegerType, to represent the number of
bits in an integer. The Type classes SubclassData field is used to
store the number of bits. This allows 2^23 bits in an integer type.
2. Removes the five integer Type::TypeID values for the 1, 8, 16, 32 and
64-bit integers. These are replaced with just IntegerType which is not
a primitive any more.
3. Adjust the rest of LLVM to account for this change.
Note that while this incremental change lays the foundation for arbitrary
bit-width integers, LLVM has not yet been converted to actually deal with
them in any significant way. Most optimization passes, for example, will
still only deal with the byte-width integer types. Future increments
will rectify this situation.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@33113 91177308-0d34-0410-b5e6-96231b3b80d8
2007-01-12 07:05:14 +00:00
|
|
|
if (ElemTy == Type::IntegerTyID) {
|
|
|
|
unsigned NumBits = (unsigned)va_arg(VA, int);
|
|
|
|
unsigned ExpectedBits =
|
|
|
|
cast<IntegerType>(PTy->getElementType())->getBitWidth();
|
|
|
|
if (NumBits != ExpectedBits) {
|
|
|
|
CheckFailed("Intrinsic prototype has incorrect vector element type!",
|
|
|
|
F);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2006-03-31 04:46:47 +00:00
|
|
|
if ((unsigned)va_arg(VA, int) != PTy->getNumElements()) {
|
|
|
|
CheckFailed("Intrinsic prototype has incorrect number of "
|
|
|
|
"vector elements!",F);
|
For PR1064:
Implement the arbitrary bit-width integer feature. The feature allows
integers of any bitwidth (up to 64) to be defined instead of just 1, 8,
16, 32, and 64 bit integers.
This change does several things:
1. Introduces a new Derived Type, IntegerType, to represent the number of
bits in an integer. The Type classes SubclassData field is used to
store the number of bits. This allows 2^23 bits in an integer type.
2. Removes the five integer Type::TypeID values for the 1, 8, 16, 32 and
64-bit integers. These are replaced with just IntegerType which is not
a primitive any more.
3. Adjust the rest of LLVM to account for this change.
Note that while this incremental change lays the foundation for arbitrary
bit-width integers, LLVM has not yet been converted to actually deal with
them in any significant way. Most optimization passes, for example, will
still only deal with the byte-width integer types. Future increments
will rectify this situation.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@33113 91177308-0d34-0410-b5e6-96231b3b80d8
2007-01-12 07:05:14 +00:00
|
|
|
break;
|
2006-03-31 04:46:47 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
va_end(VA);
|
|
|
|
}
|
|
|
|
|
2002-04-18 20:37:37 +00:00
|
|
|
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// Implement the public interfaces to this file...
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2004-04-02 15:45:08 +00:00
|
|
|
FunctionPass *llvm::createVerifierPass(VerifierFailureAction action) {
|
|
|
|
return new Verifier(action);
|
2002-04-18 20:37:37 +00:00
|
|
|
}
|
|
|
|
|
2002-08-02 17:37:08 +00:00
|
|
|
|
2005-04-21 23:48:37 +00:00
|
|
|
// verifyFunction - Create
|
2004-04-02 15:45:08 +00:00
|
|
|
bool llvm::verifyFunction(const Function &f, VerifierFailureAction action) {
|
2004-03-14 03:16:15 +00:00
|
|
|
Function &F = const_cast<Function&>(f);
|
2007-01-30 20:08:39 +00:00
|
|
|
assert(!F.isDeclaration() && "Cannot verify external functions");
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2004-03-14 03:16:15 +00:00
|
|
|
FunctionPassManager FPM(new ExistingModuleProvider(F.getParent()));
|
2004-04-02 15:45:08 +00:00
|
|
|
Verifier *V = new Verifier(action);
|
2004-03-14 03:16:15 +00:00
|
|
|
FPM.add(V);
|
|
|
|
FPM.run(F);
|
|
|
|
return V->Broken;
|
2002-02-20 17:55:43 +00:00
|
|
|
}
|
|
|
|
|
2004-03-02 00:22:19 +00:00
|
|
|
/// verifyModule - Check a module for errors, printing messages on stderr.
|
|
|
|
/// Return true if the module is corrupt.
|
|
|
|
///
|
2006-07-06 18:02:27 +00:00
|
|
|
bool llvm::verifyModule(const Module &M, VerifierFailureAction action,
|
|
|
|
std::string *ErrorInfo) {
|
2002-08-02 17:37:08 +00:00
|
|
|
PassManager PM;
|
2004-04-02 15:45:08 +00:00
|
|
|
Verifier *V = new Verifier(action);
|
2002-08-02 17:37:08 +00:00
|
|
|
PM.add(V);
|
|
|
|
PM.run((Module&)M);
|
2006-07-06 18:02:27 +00:00
|
|
|
|
|
|
|
if (ErrorInfo && V->Broken)
|
|
|
|
*ErrorInfo = V->msgs.str();
|
2002-08-02 17:37:08 +00:00
|
|
|
return V->Broken;
|
2001-06-06 20:29:01 +00:00
|
|
|
}
|
2004-05-25 08:53:29 +00:00
|
|
|
|
|
|
|
// vim: sw=2
|