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
|
|
|
|
//
|
2007-12-29 20:36:04 +00:00
|
|
|
// This file 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!]
|
2008-03-28 06:46:51 +00:00
|
|
|
// * Only phi nodes can be self referential: 'add i32 %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
|
2011-08-12 20:24:12 +00:00
|
|
|
// * A landing pad is defined by a landingpad instruction, and can be jumped to
|
|
|
|
// only by the unwind edge of an invoke instruction.
|
|
|
|
// * A landingpad instruction must be the first non-PHI instruction in the
|
|
|
|
// block.
|
|
|
|
// * All landingpad instructions must use the same personality function with
|
|
|
|
// the same function.
|
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"
|
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-04-13 22:48:46 +00:00
|
|
|
#include "llvm/DerivedTypes.h"
|
2006-01-26 00:08:45 +00:00
|
|
|
#include "llvm/InlineAsm.h"
|
2007-09-18 10:14:30 +00:00
|
|
|
#include "llvm/IntrinsicInst.h"
|
2009-07-28 21:49:47 +00:00
|
|
|
#include "llvm/Metadata.h"
|
2008-03-12 17:45:29 +00:00
|
|
|
#include "llvm/Module.h"
|
|
|
|
#include "llvm/Pass.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"
|
2008-03-12 17:45:29 +00:00
|
|
|
#include "llvm/Assembly/Writer.h"
|
2007-08-04 01:51:18 +00:00
|
|
|
#include "llvm/CodeGen/ValueTypes.h"
|
2007-12-21 19:19:01 +00:00
|
|
|
#include "llvm/Support/CallSite.h"
|
2002-02-20 17:55:43 +00:00
|
|
|
#include "llvm/Support/CFG.h"
|
2010-01-05 01:29:14 +00:00
|
|
|
#include "llvm/Support/Debug.h"
|
2002-04-18 20:37:37 +00:00
|
|
|
#include "llvm/Support/InstVisitor.h"
|
2009-09-14 00:36:52 +00:00
|
|
|
#include "llvm/ADT/SetVector.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"
|
2009-07-08 18:01:40 +00:00
|
|
|
#include "llvm/Support/ErrorHandling.h"
|
2009-02-28 21:05:51 +00:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2002-02-20 17:55:43 +00:00
|
|
|
#include <algorithm>
|
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
|
2009-10-25 06:33:48 +00:00
|
|
|
struct PreVerifier : public FunctionPass {
|
2007-11-01 03:54:23 +00:00
|
|
|
static char ID; // Pass ID, replacement for typeid
|
2007-11-01 10:50:26 +00:00
|
|
|
|
2010-10-19 17:21:58 +00:00
|
|
|
PreVerifier() : FunctionPass(ID) {
|
|
|
|
initializePreVerifierPass(*PassRegistry::getPassRegistry());
|
|
|
|
}
|
2007-11-01 10:50:26 +00:00
|
|
|
|
2008-12-01 03:58:38 +00:00
|
|
|
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
|
|
|
|
AU.setPreservesAll();
|
|
|
|
}
|
|
|
|
|
2007-11-01 10:50:26 +00:00
|
|
|
// Check that the prerequisites for successful DominatorTree construction
|
|
|
|
// are satisfied.
|
2007-11-01 03:54:23 +00:00
|
|
|
bool runOnFunction(Function &F) {
|
2007-11-01 10:50:26 +00:00
|
|
|
bool Broken = false;
|
|
|
|
|
|
|
|
for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I) {
|
|
|
|
if (I->empty() || !I->back().isTerminator()) {
|
2010-06-12 15:50:24 +00:00
|
|
|
dbgs() << "Basic Block in function '" << F.getName()
|
|
|
|
<< "' does not have terminator!\n";
|
2010-01-05 01:29:14 +00:00
|
|
|
WriteAsOperand(dbgs(), I, true);
|
|
|
|
dbgs() << "\n";
|
2007-11-01 10:50:26 +00:00
|
|
|
Broken = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Broken)
|
2010-04-07 22:58:41 +00:00
|
|
|
report_fatal_error("Broken module, no Basic Block terminator!");
|
2007-11-01 10:50:26 +00:00
|
|
|
|
|
|
|
return false;
|
2007-11-01 03:54:23 +00:00
|
|
|
}
|
2007-10-31 21:04:18 +00:00
|
|
|
};
|
2008-05-13 00:00:25 +00:00
|
|
|
}
|
2007-11-01 10:50:26 +00:00
|
|
|
|
2008-05-13 00:00:25 +00:00
|
|
|
char PreVerifier::ID = 0;
|
2010-08-23 17:52:01 +00:00
|
|
|
INITIALIZE_PASS(PreVerifier, "preverify", "Preliminary module verification",
|
2010-10-07 22:25:06 +00:00
|
|
|
false, false)
|
2010-10-22 17:35:07 +00:00
|
|
|
static char &PreVerifyID = PreVerifier::ID;
|
2007-11-01 10:50:26 +00:00
|
|
|
|
2008-05-13 00:00:25 +00:00
|
|
|
namespace {
|
2009-09-13 23:45:39 +00:00
|
|
|
struct Verifier : public FunctionPass, public InstVisitor<Verifier> {
|
2007-05-03 01:11:54 +00:00
|
|
|
static char ID; // Pass ID, replacement for typeid
|
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
|
2010-02-15 21:52:04 +00:00
|
|
|
LLVMContext *Context; // Context within which we are verifying
|
|
|
|
DominatorTree *DT; // Dominator Tree, caution can be null!
|
2009-09-07 20:44:51 +00:00
|
|
|
|
2009-08-23 04:02:03 +00:00
|
|
|
std::string Messages;
|
|
|
|
raw_string_ostream MessagesStr;
|
2004-04-02 15:45:08 +00:00
|
|
|
|
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
|
|
|
|
2010-04-29 16:10:30 +00:00
|
|
|
/// MDNodes - keep track of the metadata nodes that have been checked
|
|
|
|
/// already.
|
|
|
|
SmallPtrSet<MDNode *, 32> MDNodes;
|
|
|
|
|
2011-08-12 20:24:12 +00:00
|
|
|
/// PersonalityFn - The personality function referenced by the
|
|
|
|
/// LandingPadInsts. All LandingPadInsts within the same function must use
|
|
|
|
/// the same personality function.
|
|
|
|
const Value *PersonalityFn;
|
|
|
|
|
2005-04-21 23:48:37 +00:00
|
|
|
Verifier()
|
2011-08-12 20:24:12 +00:00
|
|
|
: FunctionPass(ID), Broken(false), RealPass(true),
|
|
|
|
action(AbortProcessAction), Mod(0), Context(0), DT(0),
|
|
|
|
MessagesStr(Messages), PersonalityFn(0) {
|
|
|
|
initializeVerifierPass(*PassRegistry::getPassRegistry());
|
|
|
|
}
|
2008-03-25 22:06:05 +00:00
|
|
|
explicit Verifier(VerifierFailureAction ctn)
|
2011-08-12 20:24:12 +00:00
|
|
|
: FunctionPass(ID), Broken(false), RealPass(true), action(ctn), Mod(0),
|
|
|
|
Context(0), DT(0), MessagesStr(Messages), PersonalityFn(0) {
|
|
|
|
initializeVerifierPass(*PassRegistry::getPassRegistry());
|
|
|
|
}
|
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;
|
2010-02-15 21:52:04 +00:00
|
|
|
Context = &M.getContext();
|
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
|
2007-06-11 15:40:48 +00:00
|
|
|
if (RealPass) DT = &getAnalysis<DominatorTree>();
|
2007-04-20 23:59:29 +00:00
|
|
|
|
|
|
|
Mod = F.getParent();
|
2010-02-15 21:52:04 +00:00
|
|
|
if (!Context) Context = &F.getContext();
|
2007-04-20 23:59:29 +00:00
|
|
|
|
2002-04-18 20:37:37 +00:00
|
|
|
visit(F);
|
2004-09-29 20:07:45 +00:00
|
|
|
InstsInThisBlock.clear();
|
2011-08-12 20:24:12 +00:00
|
|
|
PersonalityFn = 0;
|
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
|
|
|
|
2007-04-25 14:27:10 +00:00
|
|
|
for (Module::alias_iterator I = M.alias_begin(), E = M.alias_end();
|
|
|
|
I != E; ++I)
|
|
|
|
visitGlobalAlias(*I);
|
|
|
|
|
2010-04-29 16:10:30 +00:00
|
|
|
for (Module::named_metadata_iterator I = M.named_metadata_begin(),
|
|
|
|
E = M.named_metadata_end(); I != E; ++I)
|
|
|
|
visitNamedMDNode(*I);
|
|
|
|
|
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();
|
2007-10-31 21:04:18 +00:00
|
|
|
AU.addRequiredID(PreVerifyID);
|
2002-08-02 17:37:08 +00:00
|
|
|
if (RealPass)
|
2007-06-11 15:40:48 +00:00
|
|
|
AU.addRequired<DominatorTree>();
|
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() {
|
2008-08-27 17:36:58 +00:00
|
|
|
if (!Broken) return false;
|
2009-08-23 04:02:03 +00:00
|
|
|
MessagesStr << "Broken module found, ";
|
2008-08-27 17:36:58 +00:00
|
|
|
switch (action) {
|
2009-07-14 16:55:14 +00:00
|
|
|
default: llvm_unreachable("Unknown action");
|
2008-08-27 17:36:58 +00:00
|
|
|
case AbortProcessAction:
|
2009-08-23 04:02:03 +00:00
|
|
|
MessagesStr << "compilation aborted!\n";
|
2010-01-05 01:29:14 +00:00
|
|
|
dbgs() << MessagesStr.str();
|
2009-07-08 20:53:28 +00:00
|
|
|
// Client should choose different reaction if abort is not desired
|
|
|
|
abort();
|
2008-08-27 17:36:58 +00:00
|
|
|
case PrintMessageAction:
|
2009-08-23 04:02:03 +00:00
|
|
|
MessagesStr << "verification continues.\n";
|
2010-01-05 01:29:14 +00:00
|
|
|
dbgs() << MessagesStr.str();
|
2008-08-27 17:36:58 +00:00
|
|
|
return false;
|
|
|
|
case ReturnStatusAction:
|
2009-08-23 04:02:03 +00:00
|
|
|
MessagesStr << "compilation terminated.\n";
|
2009-03-15 06:40:32 +00:00
|
|
|
return true;
|
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...
|
2003-04-16 20:42:40 +00:00
|
|
|
void visitGlobalValue(GlobalValue &GV);
|
2004-12-15 20:23:49 +00:00
|
|
|
void visitGlobalVariable(GlobalVariable &GV);
|
2007-04-25 14:27:10 +00:00
|
|
|
void visitGlobalAlias(GlobalAlias &GA);
|
2010-04-29 16:10:30 +00:00
|
|
|
void visitNamedMDNode(NamedMDNode &NMD);
|
|
|
|
void visitMDNode(MDNode &MD, Function *F);
|
2002-06-25 15:56:27 +00:00
|
|
|
void visitFunction(Function &F);
|
|
|
|
void visitBasicBlock(BasicBlock &BB);
|
2008-08-28 04:02:44 +00:00
|
|
|
using InstVisitor<Verifier>::visit;
|
2009-09-07 20:44:51 +00:00
|
|
|
|
2008-08-28 04:02:44 +00:00
|
|
|
void visit(Instruction &I);
|
2009-09-07 20:44:51 +00:00
|
|
|
|
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);
|
2007-12-21 19:19:01 +00:00
|
|
|
void visitInvokeInst(InvokeInst &II);
|
2002-06-25 15:56:27 +00:00
|
|
|
void visitGetElementPtrInst(GetElementPtrInst &GEP);
|
|
|
|
void visitLoadInst(LoadInst &LI);
|
|
|
|
void visitStoreInst(StoreInst &SI);
|
|
|
|
void visitInstruction(Instruction &I);
|
|
|
|
void visitTerminatorInst(TerminatorInst &I);
|
2010-02-15 22:09:09 +00:00
|
|
|
void visitBranchInst(BranchInst &BI);
|
2002-06-25 15:56:27 +00:00
|
|
|
void visitReturnInst(ReturnInst &RI);
|
2004-05-21 16:47:21 +00:00
|
|
|
void visitSwitchInst(SwitchInst &SI);
|
2010-08-02 23:08:33 +00:00
|
|
|
void visitIndirectBrInst(IndirectBrInst &BI);
|
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);
|
2011-07-28 21:48:00 +00:00
|
|
|
void visitAtomicCmpXchgInst(AtomicCmpXchgInst &CXI);
|
|
|
|
void visitAtomicRMWInst(AtomicRMWInst &RMWI);
|
2011-07-25 23:16:38 +00:00
|
|
|
void visitFenceInst(FenceInst &FI);
|
2009-10-23 21:09:37 +00:00
|
|
|
void visitAllocaInst(AllocaInst &AI);
|
2008-07-23 00:34:11 +00:00
|
|
|
void visitExtractValueInst(ExtractValueInst &EVI);
|
|
|
|
void visitInsertValueInst(InsertValueInst &IVI);
|
2011-08-12 20:24:12 +00:00
|
|
|
void visitLandingPadInst(LandingPadInst &LPI);
|
2002-04-18 20:37:37 +00:00
|
|
|
|
2007-12-21 19:19:01 +00:00
|
|
|
void VerifyCallSite(CallSite CS);
|
2011-07-18 04:54:35 +00:00
|
|
|
bool PerformTypeCheck(Intrinsic::ID ID, Function *F, Type *Ty,
|
2008-11-13 07:11:27 +00:00
|
|
|
int VT, unsigned ArgNo, std::string &Suffix);
|
2007-08-04 01:51:18 +00:00
|
|
|
void VerifyIntrinsicPrototype(Intrinsic::ID ID, Function *F,
|
2008-11-13 09:08:33 +00:00
|
|
|
unsigned RetNum, unsigned ParamNum, ...);
|
2011-07-18 04:54:35 +00:00
|
|
|
void VerifyParameterAttrs(Attributes Attrs, Type *Ty,
|
2009-06-11 08:11:03 +00:00
|
|
|
bool isReturnValue, const Value *V);
|
2011-07-18 04:54:35 +00:00
|
|
|
void VerifyFunctionAttrs(FunctionType *FT, const AttrListPtr &Attrs,
|
2008-01-12 16:42:01 +00:00
|
|
|
const Value *V);
|
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)) {
|
2009-10-17 19:43:45 +00:00
|
|
|
MessagesStr << *V << '\n';
|
2003-11-21 20:23:48 +00:00
|
|
|
} else {
|
2009-08-23 04:02:03 +00:00
|
|
|
WriteAsOperand(MessagesStr, V, true, Mod);
|
2009-10-17 19:43:45 +00:00
|
|
|
MessagesStr << '\n';
|
2003-11-21 17:35:51 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-07-18 04:54:35 +00:00
|
|
|
void WriteType(Type *T) {
|
2009-02-28 21:05:51 +00:00
|
|
|
if (!T) return;
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
MessagesStr << ' ' << *T;
|
2004-05-25 08:53:29 +00:00
|
|
|
}
|
|
|
|
|
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.
|
2009-07-25 04:41:11 +00:00
|
|
|
void CheckFailed(const Twine &Message,
|
2003-11-21 17:35:51 +00:00
|
|
|
const Value *V1 = 0, const Value *V2 = 0,
|
|
|
|
const Value *V3 = 0, const Value *V4 = 0) {
|
2009-08-23 04:02:03 +00:00
|
|
|
MessagesStr << Message.str() << "\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
|
|
|
|
2009-09-08 02:02:39 +00:00
|
|
|
void CheckFailed(const Twine &Message, const Value *V1,
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *T2, const Value *V3 = 0) {
|
2009-08-23 04:02:03 +00:00
|
|
|
MessagesStr << Message.str() << "\n";
|
2004-05-25 08:53:29 +00:00
|
|
|
WriteValue(V1);
|
|
|
|
WriteType(T2);
|
|
|
|
WriteValue(V3);
|
2004-05-27 21:58:13 +00:00
|
|
|
Broken = true;
|
2004-05-25 08:53:29 +00:00
|
|
|
}
|
2009-09-08 01:23:52 +00:00
|
|
|
|
2011-07-18 04:54:35 +00:00
|
|
|
void CheckFailed(const Twine &Message, Type *T1,
|
|
|
|
Type *T2 = 0, Type *T3 = 0) {
|
2009-09-08 01:23:52 +00:00
|
|
|
MessagesStr << Message.str() << "\n";
|
|
|
|
WriteType(T1);
|
|
|
|
WriteType(T2);
|
|
|
|
WriteType(T3);
|
|
|
|
Broken = true;
|
|
|
|
}
|
2002-04-18 20:37:37 +00:00
|
|
|
};
|
2003-11-21 20:23:48 +00:00
|
|
|
} // End anonymous namespace
|
|
|
|
|
2008-05-13 00:00:25 +00:00
|
|
|
char Verifier::ID = 0;
|
2010-10-12 19:48:12 +00:00
|
|
|
INITIALIZE_PASS_BEGIN(Verifier, "verify", "Module Verifier", false, false)
|
|
|
|
INITIALIZE_PASS_DEPENDENCY(PreVerifier)
|
|
|
|
INITIALIZE_PASS_DEPENDENCY(DominatorTree)
|
|
|
|
INITIALIZE_PASS_END(Verifier, "verify", "Module Verifier", false, false)
|
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
|
|
|
|
2008-08-28 04:02:44 +00:00
|
|
|
void Verifier::visit(Instruction &I) {
|
|
|
|
for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i)
|
|
|
|
Assert1(I.getOperand(i) != 0, "Operand is null", &I);
|
|
|
|
InstVisitor<Verifier>::visit(I);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-04-16 20:42:40 +00:00
|
|
|
void Verifier::visitGlobalValue(GlobalValue &GV) {
|
2007-01-30 20:08:39 +00:00
|
|
|
Assert1(!GV.isDeclaration() ||
|
2010-01-27 20:34:15 +00:00
|
|
|
GV.isMaterializable() ||
|
2006-09-14 18:23:27 +00:00
|
|
|
GV.hasExternalLinkage() ||
|
|
|
|
GV.hasDLLImportLinkage() ||
|
2007-04-25 14:27:10 +00:00
|
|
|
GV.hasExternalWeakLinkage() ||
|
|
|
|
(isa<GlobalAlias>(GV) &&
|
2009-01-15 20:18:42 +00:00
|
|
|
(GV.hasLocalLinkage() || GV.hasWeakLinkage())),
|
2006-09-14 18:23:27 +00:00
|
|
|
"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);
|
2009-09-08 01:23:52 +00:00
|
|
|
|
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()) {
|
2009-09-08 01:23:52 +00:00
|
|
|
GlobalVariable *GVar = dyn_cast<GlobalVariable>(&GV);
|
2010-02-16 11:11:14 +00:00
|
|
|
Assert1(GVar && GVar->getType()->getElementType()->isArrayTy(),
|
2009-09-08 01:23:52 +00:00
|
|
|
"Only global arrays can have appending linkage!", GVar);
|
2003-04-16 20:42:40 +00:00
|
|
|
}
|
2010-08-20 22:05:50 +00:00
|
|
|
|
|
|
|
Assert1(!GV.hasLinkerPrivateWeakDefAutoLinkage() || GV.hasDefaultVisibility(),
|
|
|
|
"linker_private_weak_def_auto can only have default visibility!",
|
|
|
|
&GV);
|
2003-04-16 20:42:40 +00:00
|
|
|
}
|
|
|
|
|
2004-12-15 20:23:49 +00:00
|
|
|
void Verifier::visitGlobalVariable(GlobalVariable &GV) {
|
2007-09-19 17:14:45 +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);
|
2009-05-30 05:06:04 +00:00
|
|
|
|
2009-08-05 05:41:44 +00:00
|
|
|
// If the global has common linkage, it must have a zero initializer and
|
|
|
|
// cannot be constant.
|
|
|
|
if (GV.hasCommonLinkage()) {
|
2009-08-05 05:21:07 +00:00
|
|
|
Assert1(GV.getInitializer()->isNullValue(),
|
|
|
|
"'common' global must have a zero initializer!", &GV);
|
2009-08-05 05:41:44 +00:00
|
|
|
Assert1(!GV.isConstant(), "'common' global may not be marked constant!",
|
|
|
|
&GV);
|
|
|
|
}
|
2007-09-19 17:14:45 +00:00
|
|
|
} else {
|
|
|
|
Assert1(GV.hasExternalLinkage() || GV.hasDLLImportLinkage() ||
|
|
|
|
GV.hasExternalWeakLinkage(),
|
|
|
|
"invalid linkage type for global declaration", &GV);
|
|
|
|
}
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2011-04-08 07:30:21 +00:00
|
|
|
if (GV.hasName() && (GV.getName() == "llvm.global_ctors" ||
|
|
|
|
GV.getName() == "llvm.global_dtors")) {
|
|
|
|
Assert1(!GV.hasInitializer() || GV.hasAppendingLinkage(),
|
|
|
|
"invalid linkage for intrinsic global variable", &GV);
|
|
|
|
// Don't worry about emitting an error for it not being an array,
|
|
|
|
// visitGlobalValue will complain on appending non-array.
|
2011-07-18 04:54:35 +00:00
|
|
|
if (ArrayType *ATy = dyn_cast<ArrayType>(GV.getType())) {
|
|
|
|
StructType *STy = dyn_cast<StructType>(ATy->getElementType());
|
|
|
|
PointerType *FuncPtrTy =
|
2011-04-08 07:30:21 +00:00
|
|
|
FunctionType::get(Type::getVoidTy(*Context), false)->getPointerTo();
|
|
|
|
Assert1(STy && STy->getNumElements() == 2 &&
|
|
|
|
STy->getTypeAtIndex(0u)->isIntegerTy(32) &&
|
|
|
|
STy->getTypeAtIndex(1) == FuncPtrTy,
|
|
|
|
"wrong type for intrinsic global variable", &GV);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2004-12-15 20:23:49 +00:00
|
|
|
visitGlobalValue(GV);
|
|
|
|
}
|
|
|
|
|
2007-04-25 14:27:10 +00:00
|
|
|
void Verifier::visitGlobalAlias(GlobalAlias &GA) {
|
|
|
|
Assert1(!GA.getName().empty(),
|
|
|
|
"Alias name cannot be empty!", &GA);
|
2009-01-15 20:18:42 +00:00
|
|
|
Assert1(GA.hasExternalLinkage() || GA.hasLocalLinkage() ||
|
2007-04-25 14:27:10 +00:00
|
|
|
GA.hasWeakLinkage(),
|
|
|
|
"Alias should have external or external weak linkage!", &GA);
|
2008-05-08 23:11:06 +00:00
|
|
|
Assert1(GA.getAliasee(),
|
|
|
|
"Aliasee cannot be NULL!", &GA);
|
2007-04-28 13:45:00 +00:00
|
|
|
Assert1(GA.getType() == GA.getAliasee()->getType(),
|
|
|
|
"Alias and aliasee types should match!", &GA);
|
2011-01-08 16:42:36 +00:00
|
|
|
Assert1(!GA.hasUnnamedAddr(), "Alias cannot have unnamed_addr!", &GA);
|
2008-05-08 23:11:06 +00:00
|
|
|
|
2007-04-28 14:35:41 +00:00
|
|
|
if (!isa<GlobalValue>(GA.getAliasee())) {
|
|
|
|
const ConstantExpr *CE = dyn_cast<ConstantExpr>(GA.getAliasee());
|
2009-04-25 21:23:19 +00:00
|
|
|
Assert1(CE &&
|
|
|
|
(CE->getOpcode() == Instruction::BitCast ||
|
|
|
|
CE->getOpcode() == Instruction::GetElementPtr) &&
|
2007-04-29 18:02:48 +00:00
|
|
|
isa<GlobalValue>(CE->getOperand(0)),
|
2007-04-28 14:35:41 +00:00
|
|
|
"Aliasee should be either GlobalValue or bitcast of GlobalValue",
|
|
|
|
&GA);
|
|
|
|
}
|
2008-03-22 08:36:14 +00:00
|
|
|
|
2008-09-09 20:05:04 +00:00
|
|
|
const GlobalValue* Aliasee = GA.resolveAliasedGlobal(/*stopOnWeak*/ false);
|
2008-03-22 08:36:14 +00:00
|
|
|
Assert1(Aliasee,
|
2008-03-22 08:37:05 +00:00
|
|
|
"Aliasing chain should end with function or global variable", &GA);
|
2008-03-22 08:36:14 +00:00
|
|
|
|
2007-04-25 14:27:10 +00:00
|
|
|
visitGlobalValue(GA);
|
|
|
|
}
|
|
|
|
|
2010-04-29 16:10:30 +00:00
|
|
|
void Verifier::visitNamedMDNode(NamedMDNode &NMD) {
|
|
|
|
for (unsigned i = 0, e = NMD.getNumOperands(); i != e; ++i) {
|
|
|
|
MDNode *MD = NMD.getOperand(i);
|
|
|
|
if (!MD)
|
|
|
|
continue;
|
|
|
|
|
2010-07-21 23:38:33 +00:00
|
|
|
Assert1(!MD->isFunctionLocal(),
|
|
|
|
"Named metadata operand cannot be function local!", MD);
|
2010-04-29 16:10:30 +00:00
|
|
|
visitMDNode(*MD, 0);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitMDNode(MDNode &MD, Function *F) {
|
|
|
|
// Only visit each node once. Metadata can be mutually recursive, so this
|
|
|
|
// avoids infinite recursion here, as well as being an optimization.
|
|
|
|
if (!MDNodes.insert(&MD))
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (unsigned i = 0, e = MD.getNumOperands(); i != e; ++i) {
|
|
|
|
Value *Op = MD.getOperand(i);
|
|
|
|
if (!Op)
|
|
|
|
continue;
|
2010-07-21 20:25:43 +00:00
|
|
|
if (isa<Constant>(Op) || isa<MDString>(Op))
|
2010-04-29 16:10:30 +00:00
|
|
|
continue;
|
|
|
|
if (MDNode *N = dyn_cast<MDNode>(Op)) {
|
|
|
|
Assert2(MD.isFunctionLocal() || !N->isFunctionLocal(),
|
|
|
|
"Global metadata operand cannot be function local!", &MD, N);
|
|
|
|
visitMDNode(*N, F);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
Assert2(MD.isFunctionLocal(), "Invalid operand for global metadata!", &MD, Op);
|
|
|
|
|
|
|
|
// If this was an instruction, bb, or argument, verify that it is in the
|
|
|
|
// function that we expect.
|
|
|
|
Function *ActualF = 0;
|
|
|
|
if (Instruction *I = dyn_cast<Instruction>(Op))
|
|
|
|
ActualF = I->getParent()->getParent();
|
|
|
|
else if (BasicBlock *BB = dyn_cast<BasicBlock>(Op))
|
|
|
|
ActualF = BB->getParent();
|
|
|
|
else if (Argument *A = dyn_cast<Argument>(Op))
|
|
|
|
ActualF = A->getParent();
|
|
|
|
assert(ActualF && "Unimplemented function local metadata case!");
|
|
|
|
|
|
|
|
Assert2(ActualF == F, "function-local metadata used in wrong function",
|
|
|
|
&MD, Op);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-06-11 08:11:03 +00:00
|
|
|
// VerifyParameterAttrs - Check the given attributes for an argument or return
|
2008-01-12 16:42:01 +00:00
|
|
|
// value of the specified type. The value V is printed in error messages.
|
2011-07-18 04:54:35 +00:00
|
|
|
void Verifier::VerifyParameterAttrs(Attributes Attrs, Type *Ty,
|
2009-06-11 08:11:03 +00:00
|
|
|
bool isReturnValue, const Value *V) {
|
2008-09-25 21:00:45 +00:00
|
|
|
if (Attrs == Attribute::None)
|
2008-01-12 16:42:01 +00:00
|
|
|
return;
|
|
|
|
|
2009-06-11 08:11:03 +00:00
|
|
|
Attributes FnCheckAttr = Attrs & Attribute::FunctionOnly;
|
|
|
|
Assert1(!FnCheckAttr, "Attribute " + Attribute::getAsString(FnCheckAttr) +
|
|
|
|
" only applies to the function!", V);
|
|
|
|
|
2008-01-12 16:42:01 +00:00
|
|
|
if (isReturnValue) {
|
2008-09-25 21:00:45 +00:00
|
|
|
Attributes RetI = Attrs & Attribute::ParameterOnly;
|
|
|
|
Assert1(!RetI, "Attribute " + Attribute::getAsString(RetI) +
|
2008-08-05 15:51:44 +00:00
|
|
|
" does not apply to return values!", V);
|
2008-01-12 16:42:01 +00:00
|
|
|
}
|
2009-06-11 08:11:03 +00:00
|
|
|
|
2008-01-12 16:42:01 +00:00
|
|
|
for (unsigned i = 0;
|
2008-09-25 21:00:45 +00:00
|
|
|
i < array_lengthof(Attribute::MutuallyIncompatible); ++i) {
|
|
|
|
Attributes MutI = Attrs & Attribute::MutuallyIncompatible[i];
|
2008-01-12 16:42:01 +00:00
|
|
|
Assert1(!(MutI & (MutI - 1)), "Attributes " +
|
2008-09-25 21:00:45 +00:00
|
|
|
Attribute::getAsString(MutI) + " are incompatible!", V);
|
2008-01-12 16:42:01 +00:00
|
|
|
}
|
|
|
|
|
2008-09-25 21:00:45 +00:00
|
|
|
Attributes TypeI = Attrs & Attribute::typeIncompatible(Ty);
|
2008-01-12 16:42:01 +00:00
|
|
|
Assert1(!TypeI, "Wrong type for attribute " +
|
2008-09-25 21:00:45 +00:00
|
|
|
Attribute::getAsString(TypeI), V);
|
2008-08-27 14:48:06 +00:00
|
|
|
|
2008-09-25 21:00:45 +00:00
|
|
|
Attributes ByValI = Attrs & Attribute::ByVal;
|
2011-07-18 04:54:35 +00:00
|
|
|
if (PointerType *PTy = dyn_cast<PointerType>(Ty)) {
|
2008-08-27 14:48:06 +00:00
|
|
|
Assert1(!ByValI || PTy->getElementType()->isSized(),
|
2008-09-25 21:00:45 +00:00
|
|
|
"Attribute " + Attribute::getAsString(ByValI) +
|
2008-08-27 14:48:06 +00:00
|
|
|
" does not support unsized types!", V);
|
|
|
|
} else {
|
|
|
|
Assert1(!ByValI,
|
2008-09-25 21:00:45 +00:00
|
|
|
"Attribute " + Attribute::getAsString(ByValI) +
|
2008-08-27 14:48:06 +00:00
|
|
|
" only applies to parameters with pointer type!", V);
|
|
|
|
}
|
2008-01-12 16:42:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// VerifyFunctionAttrs - Check parameter attributes against a function type.
|
2007-12-21 19:19:01 +00:00
|
|
|
// The value V is printed in error messages.
|
2011-07-18 04:54:35 +00:00
|
|
|
void Verifier::VerifyFunctionAttrs(FunctionType *FT,
|
2008-09-25 21:00:45 +00:00
|
|
|
const AttrListPtr &Attrs,
|
2008-01-12 16:42:01 +00:00
|
|
|
const Value *V) {
|
2008-03-12 17:45:29 +00:00
|
|
|
if (Attrs.isEmpty())
|
2007-12-21 19:19:01 +00:00
|
|
|
return;
|
|
|
|
|
|
|
|
bool SawNest = false;
|
|
|
|
|
2008-03-12 17:45:29 +00:00
|
|
|
for (unsigned i = 0, e = Attrs.getNumSlots(); i != e; ++i) {
|
2008-09-25 21:00:45 +00:00
|
|
|
const AttributeWithIndex &Attr = Attrs.getSlot(i);
|
2007-12-21 19:19:01 +00:00
|
|
|
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *Ty;
|
2008-03-12 17:45:29 +00:00
|
|
|
if (Attr.Index == 0)
|
|
|
|
Ty = FT->getReturnType();
|
|
|
|
else if (Attr.Index-1 < FT->getNumParams())
|
|
|
|
Ty = FT->getParamType(Attr.Index-1);
|
|
|
|
else
|
2009-06-11 08:11:03 +00:00
|
|
|
break; // VarArgs attributes, verified elsewhere.
|
|
|
|
|
|
|
|
VerifyParameterAttrs(Attr.Attrs, Ty, Attr.Index == 0, V);
|
2007-12-21 19:19:01 +00:00
|
|
|
|
2008-09-25 21:00:45 +00:00
|
|
|
if (Attr.Attrs & Attribute::Nest) {
|
2007-12-21 19:19:01 +00:00
|
|
|
Assert1(!SawNest, "More than one parameter has attribute nest!", V);
|
|
|
|
SawNest = true;
|
|
|
|
}
|
|
|
|
|
2008-09-25 21:00:45 +00:00
|
|
|
if (Attr.Attrs & Attribute::StructRet)
|
2008-03-12 17:45:29 +00:00
|
|
|
Assert1(Attr.Index == 1, "Attribute sret not on first parameter!", V);
|
2007-12-21 19:19:01 +00:00
|
|
|
}
|
2008-10-01 23:41:25 +00:00
|
|
|
|
|
|
|
Attributes FAttrs = Attrs.getFnAttributes();
|
2009-06-11 08:11:03 +00:00
|
|
|
Attributes NotFn = FAttrs & (~Attribute::FunctionOnly);
|
|
|
|
Assert1(!NotFn, "Attribute " + Attribute::getAsString(NotFn) +
|
|
|
|
" does not apply to the function!", V);
|
|
|
|
|
2008-10-01 23:41:25 +00:00
|
|
|
for (unsigned i = 0;
|
|
|
|
i < array_lengthof(Attribute::MutuallyIncompatible); ++i) {
|
|
|
|
Attributes MutI = FAttrs & Attribute::MutuallyIncompatible[i];
|
|
|
|
Assert1(!(MutI & (MutI - 1)), "Attributes " +
|
|
|
|
Attribute::getAsString(MutI) + " are incompatible!", V);
|
|
|
|
}
|
2007-12-21 19:19:01 +00:00
|
|
|
}
|
|
|
|
|
2008-09-25 21:00:45 +00:00
|
|
|
static bool VerifyAttributeCount(const AttrListPtr &Attrs, unsigned Params) {
|
2008-09-23 22:35:17 +00:00
|
|
|
if (Attrs.isEmpty())
|
|
|
|
return true;
|
2009-09-07 20:44:51 +00:00
|
|
|
|
2008-09-23 22:35:17 +00:00
|
|
|
unsigned LastSlot = Attrs.getNumSlots() - 1;
|
|
|
|
unsigned LastIndex = Attrs.getSlot(LastSlot).Index;
|
|
|
|
if (LastIndex <= Params
|
|
|
|
|| (LastIndex == (unsigned)~0
|
|
|
|
&& (LastSlot == 0 || Attrs.getSlot(LastSlot - 1).Index <= Params)))
|
|
|
|
return true;
|
2009-09-07 20:44:51 +00:00
|
|
|
|
2008-09-23 22:35:17 +00:00
|
|
|
return false;
|
|
|
|
}
|
2009-09-07 20:44:51 +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.
|
2011-07-18 04:54:35 +00:00
|
|
|
FunctionType *FT = F.getFunctionType();
|
2007-08-18 06:13:19 +00:00
|
|
|
unsigned NumArgs = F.arg_size();
|
2002-04-13 22:48:46 +00:00
|
|
|
|
2010-02-15 21:52:04 +00:00
|
|
|
Assert1(Context == &F.getContext(),
|
|
|
|
"Function context does not match Module context!", &F);
|
|
|
|
|
2009-08-05 05:21:07 +00:00
|
|
|
Assert1(!F.hasCommonLinkage(), "Functions may not have common linkage", &F);
|
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() ||
|
2009-10-05 05:54:46 +00:00
|
|
|
F.getReturnType()->isVoidTy() ||
|
2010-02-16 11:11:14 +00:00
|
|
|
F.getReturnType()->isStructTy(),
|
2003-11-21 22:32:23 +00:00
|
|
|
"Functions cannot return aggregate values!", &F);
|
2002-04-13 22:48:46 +00:00
|
|
|
|
2009-10-05 05:54:46 +00:00
|
|
|
Assert1(!F.hasStructRetAttr() || F.getReturnType()->isVoidTy(),
|
2008-03-03 21:46:28 +00:00
|
|
|
"Invalid struct return type!", &F);
|
|
|
|
|
2008-09-25 21:00:45 +00:00
|
|
|
const AttrListPtr &Attrs = F.getAttributes();
|
2008-01-11 22:36:48 +00:00
|
|
|
|
2008-09-23 22:35:17 +00:00
|
|
|
Assert1(VerifyAttributeCount(Attrs, FT->getNumParams()),
|
2008-01-11 22:36:48 +00:00
|
|
|
"Attributes after last parameter!", &F);
|
|
|
|
|
2007-12-21 19:19:01 +00:00
|
|
|
// Check function attributes.
|
2008-01-12 16:42:01 +00:00
|
|
|
VerifyFunctionAttrs(FT, Attrs, &F);
|
2007-07-27 15:09:54 +00:00
|
|
|
|
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:
|
2010-05-16 09:08:45 +00:00
|
|
|
case CallingConv::X86_ThisCall:
|
2010-09-25 07:46:17 +00:00
|
|
|
case CallingConv::PTX_Kernel:
|
|
|
|
case CallingConv::PTX_Device:
|
2006-05-19 21:25:17 +00:00
|
|
|
Assert1(!F.isVarArg(),
|
|
|
|
"Varargs functions must have C calling conventions!", &F);
|
|
|
|
break;
|
|
|
|
}
|
2009-09-07 20:44:51 +00:00
|
|
|
|
2009-05-30 05:06:04 +00:00
|
|
|
bool isLLVMdotName = F.getName().size() >= 5 &&
|
|
|
|
F.getName().substr(0, 5) == "llvm.";
|
|
|
|
|
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));
|
2005-04-21 23:48:37 +00:00
|
|
|
Assert1(I->getType()->isFirstClassType(),
|
2008-08-27 14:44:57 +00:00
|
|
|
"Function arguments must have first-class types!", I);
|
2009-05-30 05:06:04 +00:00
|
|
|
if (!isLLVMdotName)
|
2009-10-05 05:54:46 +00:00
|
|
|
Assert2(!I->getType()->isMetadataTy(),
|
2009-05-30 05:06:04 +00:00
|
|
|
"Function takes metadata but isn't an intrinsic", I, &F);
|
2008-08-27 14:44:57 +00:00
|
|
|
}
|
2002-10-13 20:57:00 +00:00
|
|
|
|
2010-01-27 20:34:15 +00:00
|
|
|
if (F.isMaterializable()) {
|
|
|
|
// Function has a body somewhere we can't see.
|
|
|
|
} else if (F.isDeclaration()) {
|
2007-09-19 17:14:45 +00:00
|
|
|
Assert1(F.hasExternalLinkage() || F.hasDLLImportLinkage() ||
|
2010-01-27 20:34:15 +00:00
|
|
|
F.hasExternalWeakLinkage(),
|
2007-09-19 17:14:45 +00:00
|
|
|
"invalid linkage type for function declaration", &F);
|
|
|
|
} else {
|
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.
|
2009-05-30 05:06:04 +00:00
|
|
|
Assert1(!isLLVMdotName, "llvm intrinsics cannot be defined!", &F);
|
2006-12-13 04:45:46 +00:00
|
|
|
|
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);
|
2009-11-01 04:08:01 +00:00
|
|
|
|
|
|
|
// The address of the entry block cannot be taken, unless it is dead.
|
|
|
|
if (Entry->hasAddressTaken()) {
|
2009-11-01 18:11:50 +00:00
|
|
|
Assert1(!BlockAddress::get(Entry)->isConstantUsed(),
|
2009-11-01 04:08:01 +00:00
|
|
|
"blockaddress may not be used with the entry block!", Entry);
|
|
|
|
}
|
2002-04-13 22:48:46 +00:00
|
|
|
}
|
2010-03-24 13:21:49 +00:00
|
|
|
|
2009-09-11 17:05:29 +00:00
|
|
|
// If this function is actually an intrinsic, verify that it is only used in
|
|
|
|
// direct call/invokes, never having its "address taken".
|
|
|
|
if (F.getIntrinsicID()) {
|
2010-03-24 13:21:49 +00:00
|
|
|
const User *U;
|
|
|
|
if (F.hasAddressTaken(&U))
|
2009-09-11 17:05:29 +00:00
|
|
|
Assert1(0, "Invalid user of intrinsic instruction!", U);
|
|
|
|
}
|
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
|
|
|
}
|
|
|
|
|
2010-02-15 22:09:09 +00:00
|
|
|
void Verifier::visitBranchInst(BranchInst &BI) {
|
|
|
|
if (BI.isConditional()) {
|
|
|
|
Assert2(BI.getCondition()->getType()->isIntegerTy(1),
|
|
|
|
"Branch condition is not 'i1' type!", &BI, BI.getCondition());
|
|
|
|
}
|
|
|
|
visitTerminatorInst(BI);
|
|
|
|
}
|
|
|
|
|
2002-06-25 15:56:27 +00:00
|
|
|
void Verifier::visitReturnInst(ReturnInst &RI) {
|
|
|
|
Function *F = RI.getParent()->getParent();
|
2008-02-23 00:35:18 +00:00
|
|
|
unsigned N = RI.getNumOperands();
|
2009-10-05 05:54:46 +00:00
|
|
|
if (F->getReturnType()->isVoidTy())
|
2008-04-23 20:33:41 +00:00
|
|
|
Assert2(N == 0,
|
2008-11-15 17:50:47 +00:00
|
|
|
"Found return instr that returns non-void in Function of void "
|
2004-12-04 01:25:06 +00:00
|
|
|
"return type!", &RI, F->getReturnType());
|
2011-04-04 07:44:02 +00:00
|
|
|
else
|
|
|
|
Assert2(N == 1 && F->getReturnType() == RI.getOperand(0)->getType(),
|
|
|
|
"Function return type does not match operand "
|
|
|
|
"type of return inst!", &RI, F->getReturnType());
|
2009-09-07 20:44:51 +00:00
|
|
|
|
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.
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *SwitchTy = SI.getCondition()->getType();
|
2009-11-11 17:37:02 +00:00
|
|
|
SmallPtrSet<ConstantInt*, 32> Constants;
|
|
|
|
for (unsigned i = 1, e = SI.getNumCases(); i != e; ++i) {
|
2004-05-21 16:47:21 +00:00
|
|
|
Assert1(SI.getCaseValue(i)->getType() == SwitchTy,
|
|
|
|
"Switch constants must all be same type as switch value!", &SI);
|
2009-11-11 17:37:02 +00:00
|
|
|
Assert2(Constants.insert(SI.getCaseValue(i)),
|
|
|
|
"Duplicate integer as switch case", &SI, SI.getCaseValue(i));
|
|
|
|
}
|
2004-05-21 16:47:21 +00:00
|
|
|
|
|
|
|
visitTerminatorInst(SI);
|
|
|
|
}
|
|
|
|
|
2010-08-02 23:08:33 +00:00
|
|
|
void Verifier::visitIndirectBrInst(IndirectBrInst &BI) {
|
|
|
|
Assert1(BI.getAddress()->getType()->isPointerTy(),
|
|
|
|
"Indirectbr operand must have pointer type!", &BI);
|
|
|
|
for (unsigned i = 0, e = BI.getNumDestinations(); i != e; ++i)
|
|
|
|
Assert1(BI.getDestination(i)->getType()->isLabelTy(),
|
|
|
|
"Indirectbr destinations must all have pointer type!", &BI);
|
|
|
|
|
|
|
|
visitTerminatorInst(BI);
|
|
|
|
}
|
|
|
|
|
2004-03-12 05:54:31 +00:00
|
|
|
void Verifier::visitSelectInst(SelectInst &SI) {
|
2008-12-29 00:12:50 +00:00
|
|
|
Assert1(!SelectInst::areInvalidOperands(SI.getOperand(0), SI.getOperand(1),
|
|
|
|
SI.getOperand(2)),
|
|
|
|
"Invalid operands for select instruction!", &SI);
|
|
|
|
|
2004-03-12 05:54:31 +00:00
|
|
|
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
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *SrcTy = I.getOperand(0)->getType();
|
|
|
|
Type *DestTy = I.getType();
|
2006-11-27 01:05:10 +00:00
|
|
|
|
|
|
|
// Get the size of the types in bits, we'll need this later
|
2009-06-15 22:12:54 +00:00
|
|
|
unsigned SrcBitSize = SrcTy->getScalarSizeInBits();
|
|
|
|
unsigned DestBitSize = DestTy->getScalarSizeInBits();
|
2006-11-27 01:05:10 +00:00
|
|
|
|
2010-02-15 16:12:20 +00:00
|
|
|
Assert1(SrcTy->isIntOrIntVectorTy(), "Trunc only operates on integer", &I);
|
|
|
|
Assert1(DestTy->isIntOrIntVectorTy(), "Trunc only produces integer", &I);
|
2010-02-16 11:11:14 +00:00
|
|
|
Assert1(SrcTy->isVectorTy() == DestTy->isVectorTy(),
|
2009-02-02 07:40:17 +00:00
|
|
|
"trunc source and destination must both be a vector or neither", &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
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *SrcTy = I.getOperand(0)->getType();
|
|
|
|
Type *DestTy = I.getType();
|
2006-11-27 01:05:10 +00:00
|
|
|
|
|
|
|
// Get the size of the types in bits, we'll need this later
|
2010-02-15 16:12:20 +00:00
|
|
|
Assert1(SrcTy->isIntOrIntVectorTy(), "ZExt only operates on integer", &I);
|
|
|
|
Assert1(DestTy->isIntOrIntVectorTy(), "ZExt only produces an integer", &I);
|
2010-02-16 11:11:14 +00:00
|
|
|
Assert1(SrcTy->isVectorTy() == DestTy->isVectorTy(),
|
2009-02-02 07:40:17 +00:00
|
|
|
"zext source and destination must both be a vector or neither", &I);
|
2009-06-15 22:12:54 +00:00
|
|
|
unsigned SrcBitSize = SrcTy->getScalarSizeInBits();
|
|
|
|
unsigned DestBitSize = DestTy->getScalarSizeInBits();
|
2006-11-27 01:05:10 +00:00
|
|
|
|
|
|
|
Assert1(SrcBitSize < DestBitSize,"Type too small for ZExt", &I);
|
|
|
|
|
|
|
|
visitInstruction(I);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitSExtInst(SExtInst &I) {
|
|
|
|
// Get the source and destination types
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *SrcTy = I.getOperand(0)->getType();
|
|
|
|
Type *DestTy = I.getType();
|
2006-11-27 01:05:10 +00:00
|
|
|
|
|
|
|
// Get the size of the types in bits, we'll need this later
|
2009-06-15 22:12:54 +00:00
|
|
|
unsigned SrcBitSize = SrcTy->getScalarSizeInBits();
|
|
|
|
unsigned DestBitSize = DestTy->getScalarSizeInBits();
|
2006-11-27 01:05:10 +00:00
|
|
|
|
2010-02-15 16:12:20 +00:00
|
|
|
Assert1(SrcTy->isIntOrIntVectorTy(), "SExt only operates on integer", &I);
|
|
|
|
Assert1(DestTy->isIntOrIntVectorTy(), "SExt only produces an integer", &I);
|
2010-02-16 11:11:14 +00:00
|
|
|
Assert1(SrcTy->isVectorTy() == DestTy->isVectorTy(),
|
2009-02-02 07:40:17 +00:00
|
|
|
"sext source and destination must both be a vector or neither", &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
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *SrcTy = I.getOperand(0)->getType();
|
|
|
|
Type *DestTy = I.getType();
|
2006-11-27 01:05:10 +00:00
|
|
|
// Get the size of the types in bits, we'll need this later
|
2009-06-15 22:12:54 +00:00
|
|
|
unsigned SrcBitSize = SrcTy->getScalarSizeInBits();
|
|
|
|
unsigned DestBitSize = DestTy->getScalarSizeInBits();
|
2006-11-27 01:05:10 +00:00
|
|
|
|
2010-02-15 16:12:20 +00:00
|
|
|
Assert1(SrcTy->isFPOrFPVectorTy(),"FPTrunc only operates on FP", &I);
|
|
|
|
Assert1(DestTy->isFPOrFPVectorTy(),"FPTrunc only produces an FP", &I);
|
2010-02-16 11:11:14 +00:00
|
|
|
Assert1(SrcTy->isVectorTy() == DestTy->isVectorTy(),
|
2009-02-02 07:40:17 +00:00
|
|
|
"fptrunc source and destination must both be a vector or neither",&I);
|
2006-11-27 01:05:10 +00:00
|
|
|
Assert1(SrcBitSize > DestBitSize,"DestTy too big for FPTrunc", &I);
|
|
|
|
|
|
|
|
visitInstruction(I);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitFPExtInst(FPExtInst &I) {
|
|
|
|
// Get the source and destination types
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *SrcTy = I.getOperand(0)->getType();
|
|
|
|
Type *DestTy = I.getType();
|
2006-11-27 01:05:10 +00:00
|
|
|
|
|
|
|
// Get the size of the types in bits, we'll need this later
|
2009-06-15 22:12:54 +00:00
|
|
|
unsigned SrcBitSize = SrcTy->getScalarSizeInBits();
|
|
|
|
unsigned DestBitSize = DestTy->getScalarSizeInBits();
|
2006-11-27 01:05:10 +00:00
|
|
|
|
2010-02-15 16:12:20 +00:00
|
|
|
Assert1(SrcTy->isFPOrFPVectorTy(),"FPExt only operates on FP", &I);
|
|
|
|
Assert1(DestTy->isFPOrFPVectorTy(),"FPExt only produces an FP", &I);
|
2010-02-16 11:11:14 +00:00
|
|
|
Assert1(SrcTy->isVectorTy() == DestTy->isVectorTy(),
|
2009-02-02 07:40:17 +00:00
|
|
|
"fpext source and destination must both be a vector or neither", &I);
|
2006-11-27 01:05:10 +00:00
|
|
|
Assert1(SrcBitSize < DestBitSize,"DestTy too small for FPExt", &I);
|
|
|
|
|
|
|
|
visitInstruction(I);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitUIToFPInst(UIToFPInst &I) {
|
|
|
|
// Get the source and destination types
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *SrcTy = I.getOperand(0)->getType();
|
|
|
|
Type *DestTy = I.getType();
|
2006-11-27 01:05:10 +00:00
|
|
|
|
2010-02-16 11:11:14 +00:00
|
|
|
bool SrcVec = SrcTy->isVectorTy();
|
|
|
|
bool DstVec = DestTy->isVectorTy();
|
2007-11-17 03:58:34 +00:00
|
|
|
|
2008-03-12 17:45:29 +00:00
|
|
|
Assert1(SrcVec == DstVec,
|
|
|
|
"UIToFP source and dest must both be vector or scalar", &I);
|
2010-02-15 16:12:20 +00:00
|
|
|
Assert1(SrcTy->isIntOrIntVectorTy(),
|
2008-03-12 17:45:29 +00:00
|
|
|
"UIToFP source must be integer or integer vector", &I);
|
2010-02-15 16:12:20 +00:00
|
|
|
Assert1(DestTy->isFPOrFPVectorTy(),
|
2008-03-12 17:45:29 +00:00
|
|
|
"UIToFP result must be FP or FP vector", &I);
|
2007-11-17 03:58:34 +00:00
|
|
|
|
|
|
|
if (SrcVec && DstVec)
|
2008-03-12 17:45:29 +00:00
|
|
|
Assert1(cast<VectorType>(SrcTy)->getNumElements() ==
|
|
|
|
cast<VectorType>(DestTy)->getNumElements(),
|
2007-11-17 03:58:34 +00:00
|
|
|
"UIToFP source and dest vector length mismatch", &I);
|
2006-11-27 01:05:10 +00:00
|
|
|
|
|
|
|
visitInstruction(I);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitSIToFPInst(SIToFPInst &I) {
|
|
|
|
// Get the source and destination types
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *SrcTy = I.getOperand(0)->getType();
|
|
|
|
Type *DestTy = I.getType();
|
2006-11-27 01:05:10 +00:00
|
|
|
|
2010-02-16 11:11:14 +00:00
|
|
|
bool SrcVec = SrcTy->isVectorTy();
|
|
|
|
bool DstVec = DestTy->isVectorTy();
|
2007-11-17 03:58:34 +00:00
|
|
|
|
2008-03-12 17:45:29 +00:00
|
|
|
Assert1(SrcVec == DstVec,
|
|
|
|
"SIToFP source and dest must both be vector or scalar", &I);
|
2010-02-15 16:12:20 +00:00
|
|
|
Assert1(SrcTy->isIntOrIntVectorTy(),
|
2008-03-12 17:45:29 +00:00
|
|
|
"SIToFP source must be integer or integer vector", &I);
|
2010-02-15 16:12:20 +00:00
|
|
|
Assert1(DestTy->isFPOrFPVectorTy(),
|
2008-03-12 17:45:29 +00:00
|
|
|
"SIToFP result must be FP or FP vector", &I);
|
2007-11-17 03:58:34 +00:00
|
|
|
|
|
|
|
if (SrcVec && DstVec)
|
2008-03-12 17:45:29 +00:00
|
|
|
Assert1(cast<VectorType>(SrcTy)->getNumElements() ==
|
|
|
|
cast<VectorType>(DestTy)->getNumElements(),
|
2007-11-17 03:58:34 +00:00
|
|
|
"SIToFP source and dest vector length mismatch", &I);
|
2006-11-27 01:05:10 +00:00
|
|
|
|
|
|
|
visitInstruction(I);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitFPToUIInst(FPToUIInst &I) {
|
|
|
|
// Get the source and destination types
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *SrcTy = I.getOperand(0)->getType();
|
|
|
|
Type *DestTy = I.getType();
|
2006-11-27 01:05:10 +00:00
|
|
|
|
2010-02-16 11:11:14 +00:00
|
|
|
bool SrcVec = SrcTy->isVectorTy();
|
|
|
|
bool DstVec = DestTy->isVectorTy();
|
2007-11-17 03:58:34 +00:00
|
|
|
|
2008-03-12 17:45:29 +00:00
|
|
|
Assert1(SrcVec == DstVec,
|
|
|
|
"FPToUI source and dest must both be vector or scalar", &I);
|
2010-02-15 16:12:20 +00:00
|
|
|
Assert1(SrcTy->isFPOrFPVectorTy(), "FPToUI source must be FP or FP vector",
|
|
|
|
&I);
|
|
|
|
Assert1(DestTy->isIntOrIntVectorTy(),
|
2008-03-12 17:45:29 +00:00
|
|
|
"FPToUI result must be integer or integer vector", &I);
|
2007-11-17 03:58:34 +00:00
|
|
|
|
|
|
|
if (SrcVec && DstVec)
|
2008-03-12 17:45:29 +00:00
|
|
|
Assert1(cast<VectorType>(SrcTy)->getNumElements() ==
|
|
|
|
cast<VectorType>(DestTy)->getNumElements(),
|
2007-11-17 03:58:34 +00:00
|
|
|
"FPToUI source and dest vector length mismatch", &I);
|
2006-11-27 01:05:10 +00:00
|
|
|
|
|
|
|
visitInstruction(I);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitFPToSIInst(FPToSIInst &I) {
|
|
|
|
// Get the source and destination types
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *SrcTy = I.getOperand(0)->getType();
|
|
|
|
Type *DestTy = I.getType();
|
2006-11-27 01:05:10 +00:00
|
|
|
|
2010-02-16 11:11:14 +00:00
|
|
|
bool SrcVec = SrcTy->isVectorTy();
|
|
|
|
bool DstVec = DestTy->isVectorTy();
|
2007-11-17 03:58:34 +00:00
|
|
|
|
2008-03-12 17:45:29 +00:00
|
|
|
Assert1(SrcVec == DstVec,
|
|
|
|
"FPToSI source and dest must both be vector or scalar", &I);
|
2010-02-15 16:12:20 +00:00
|
|
|
Assert1(SrcTy->isFPOrFPVectorTy(),
|
2008-03-12 17:45:29 +00:00
|
|
|
"FPToSI source must be FP or FP vector", &I);
|
2010-02-15 16:12:20 +00:00
|
|
|
Assert1(DestTy->isIntOrIntVectorTy(),
|
2008-03-12 17:45:29 +00:00
|
|
|
"FPToSI result must be integer or integer vector", &I);
|
2007-11-17 03:58:34 +00:00
|
|
|
|
|
|
|
if (SrcVec && DstVec)
|
2008-03-12 17:45:29 +00:00
|
|
|
Assert1(cast<VectorType>(SrcTy)->getNumElements() ==
|
|
|
|
cast<VectorType>(DestTy)->getNumElements(),
|
2007-11-17 03:58:34 +00:00
|
|
|
"FPToSI source and dest vector length mismatch", &I);
|
2006-11-27 01:05:10 +00:00
|
|
|
|
|
|
|
visitInstruction(I);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitPtrToIntInst(PtrToIntInst &I) {
|
|
|
|
// Get the source and destination types
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *SrcTy = I.getOperand(0)->getType();
|
|
|
|
Type *DestTy = I.getType();
|
2006-11-27 01:05:10 +00:00
|
|
|
|
2010-02-16 11:11:14 +00:00
|
|
|
Assert1(SrcTy->isPointerTy(), "PtrToInt source must be pointer", &I);
|
2010-02-15 16:12:20 +00:00
|
|
|
Assert1(DestTy->isIntegerTy(), "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
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *SrcTy = I.getOperand(0)->getType();
|
|
|
|
Type *DestTy = I.getType();
|
2006-11-27 01:05:10 +00:00
|
|
|
|
2010-02-15 16:12:20 +00:00
|
|
|
Assert1(SrcTy->isIntegerTy(), "IntToPtr source must be an integral", &I);
|
2010-02-16 11:11:14 +00:00
|
|
|
Assert1(DestTy->isPointerTy(), "IntToPtr result must be a pointer",&I);
|
2006-11-27 01:05:10 +00:00
|
|
|
|
|
|
|
visitInstruction(I);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitBitCastInst(BitCastInst &I) {
|
|
|
|
// Get the source and destination types
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *SrcTy = I.getOperand(0)->getType();
|
|
|
|
Type *DestTy = I.getType();
|
2006-11-27 01:05:10 +00:00
|
|
|
|
|
|
|
// 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.
|
2010-02-16 11:11:14 +00:00
|
|
|
Assert1(DestTy->isPointerTy() == DestTy->isPointerTy(),
|
2006-11-27 01:05:10 +00:00
|
|
|
"Bitcast requires both operands to be pointer or neither", &I);
|
2009-07-30 02:00:06 +00:00
|
|
|
Assert1(SrcBitSize == DestBitSize, "Bitcast requires types of same width",&I);
|
2006-11-27 01:05:10 +00:00
|
|
|
|
2008-09-08 16:45:59 +00:00
|
|
|
// Disallow aggregates.
|
|
|
|
Assert1(!SrcTy->isAggregateType(),
|
|
|
|
"Bitcast operand must not be aggregate", &I);
|
|
|
|
Assert1(!DestTy->isAggregateType(),
|
|
|
|
"Bitcast type must not be aggregate", &I);
|
|
|
|
|
2006-11-27 01:05:10 +00:00
|
|
|
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.
|
2007-04-17 17:36:12 +00:00
|
|
|
Assert2(&PN == &PN.getParent()->front() ||
|
|
|
|
isa<PHINode>(--BasicBlock::iterator(&PN)),
|
2002-06-25 15:56:27 +00:00
|
|
|
"PHI nodes not grouped at top of basic block!",
|
|
|
|
&PN, PN.getParent());
|
|
|
|
|
2009-09-08 01:23:52 +00:00
|
|
|
// Check that all of the values of the PHI node have the same type as the
|
|
|
|
// result, and that the incoming blocks are really basic blocks.
|
|
|
|
for (unsigned i = 0, e = PN.getNumIncomingValues(); i != e; ++i) {
|
2003-11-12 07:13:37 +00:00
|
|
|
Assert1(PN.getType() == PN.getIncomingValue(i)->getType(),
|
|
|
|
"PHI node operands are not the same type as the result!", &PN);
|
2009-09-08 01:23:52 +00:00
|
|
|
}
|
2003-11-12 07:13:37 +00:00
|
|
|
|
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
|
|
|
|
2007-12-21 19:19:01 +00:00
|
|
|
void Verifier::VerifyCallSite(CallSite CS) {
|
|
|
|
Instruction *I = CS.getInstruction();
|
|
|
|
|
2010-02-16 11:11:14 +00:00
|
|
|
Assert1(CS.getCalledValue()->getType()->isPointerTy(),
|
2009-09-08 02:02:39 +00:00
|
|
|
"Called function must be a pointer!", I);
|
2011-07-18 04:54:35 +00:00
|
|
|
PointerType *FPTy = cast<PointerType>(CS.getCalledValue()->getType());
|
2002-05-08 19:49:50 +00:00
|
|
|
|
2010-02-16 11:11:14 +00:00
|
|
|
Assert1(FPTy->getElementType()->isFunctionTy(),
|
2009-09-08 02:02:39 +00:00
|
|
|
"Called function is not pointer to function type!", I);
|
2011-07-18 04:54:35 +00:00
|
|
|
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())
|
2007-12-21 19:19:01 +00:00
|
|
|
Assert1(CS.arg_size() >= FTy->getNumParams(),
|
|
|
|
"Called function requires more parameters than were provided!",I);
|
2002-05-08 19:49:50 +00:00
|
|
|
else
|
2007-12-21 19:19:01 +00:00
|
|
|
Assert1(CS.arg_size() == FTy->getNumParams(),
|
|
|
|
"Incorrect number of arguments passed to called function!", I);
|
2002-05-08 19:49:50 +00:00
|
|
|
|
2010-05-10 20:58:42 +00:00
|
|
|
// Verify that all arguments to the call match the function type.
|
2002-05-08 19:49:50 +00:00
|
|
|
for (unsigned i = 0, e = FTy->getNumParams(); i != e; ++i)
|
2007-12-21 19:19:01 +00:00
|
|
|
Assert3(CS.getArgument(i)->getType() == FTy->getParamType(i),
|
2002-05-08 19:49:50 +00:00
|
|
|
"Call parameter type does not match function signature!",
|
2007-12-21 19:19:01 +00:00
|
|
|
CS.getArgument(i), FTy->getParamType(i), I);
|
|
|
|
|
2008-09-25 21:00:45 +00:00
|
|
|
const AttrListPtr &Attrs = CS.getAttributes();
|
2008-01-11 22:36:48 +00:00
|
|
|
|
2008-09-23 22:35:17 +00:00
|
|
|
Assert1(VerifyAttributeCount(Attrs, CS.arg_size()),
|
2008-03-12 17:45:29 +00:00
|
|
|
"Attributes after last parameter!", I);
|
2008-01-11 22:36:48 +00:00
|
|
|
|
2007-12-21 19:19:01 +00:00
|
|
|
// Verify call attributes.
|
2008-01-12 16:42:01 +00:00
|
|
|
VerifyFunctionAttrs(FTy, Attrs, I);
|
2008-01-11 22:36:48 +00:00
|
|
|
|
2008-03-12 17:45:29 +00:00
|
|
|
if (FTy->isVarArg())
|
2008-01-11 22:36:48 +00:00
|
|
|
// Check attributes on the varargs part.
|
|
|
|
for (unsigned Idx = 1 + FTy->getNumParams(); Idx <= CS.arg_size(); ++Idx) {
|
2008-09-26 22:53:05 +00:00
|
|
|
Attributes Attr = Attrs.getParamAttributes(Idx);
|
2008-01-12 16:42:01 +00:00
|
|
|
|
2009-06-11 08:11:03 +00:00
|
|
|
VerifyParameterAttrs(Attr, CS.getArgument(Idx-1)->getType(), false, I);
|
2008-01-12 16:42:01 +00:00
|
|
|
|
2008-09-25 21:00:45 +00:00
|
|
|
Attributes VArgI = Attr & Attribute::VarArgsIncompatible;
|
|
|
|
Assert1(!VArgI, "Attribute " + Attribute::getAsString(VArgI) +
|
2008-08-05 15:51:44 +00:00
|
|
|
" cannot be used for vararg call arguments!", I);
|
2008-01-11 22:36:48 +00:00
|
|
|
}
|
2007-12-21 19:19:01 +00:00
|
|
|
|
2009-05-30 05:06:04 +00:00
|
|
|
// Verify that there's no metadata unless it's a direct call to an intrinsic.
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
if (CS.getCalledFunction() == 0 ||
|
2010-05-10 20:58:42 +00:00
|
|
|
!CS.getCalledFunction()->getName().startswith("llvm.")) {
|
2009-05-30 05:06:04 +00:00
|
|
|
for (FunctionType::param_iterator PI = FTy->param_begin(),
|
|
|
|
PE = FTy->param_end(); PI != PE; ++PI)
|
Land the long talked about "type system rewrite" patch. This
patch brings numerous advantages to LLVM. One way to look at it
is through diffstat:
109 files changed, 3005 insertions(+), 5906 deletions(-)
Removing almost 3K lines of code is a good thing. Other advantages
include:
1. Value::getType() is a simple load that can be CSE'd, not a mutating
union-find operation.
2. Types a uniqued and never move once created, defining away PATypeHolder.
3. Structs can be "named" now, and their name is part of the identity that
uniques them. This means that the compiler doesn't merge them structurally
which makes the IR much less confusing.
4. Now that there is no way to get a cycle in a type graph without a named
struct type, "upreferences" go away.
5. Type refinement is completely gone, which should make LTO much MUCH faster
in some common cases with C++ code.
6. Types are now generally immutable, so we can use "Type *" instead
"const Type *" everywhere.
Downsides of this patch are that it removes some functions from the C API,
so people using those will have to upgrade to (not yet added) new API.
"LLVM 3.0" is the right time to do this.
There are still some cleanups pending after this, this patch is large enough
as-is.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@134829 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-09 17:41:24 +00:00
|
|
|
Assert1(!(*PI)->isMetadataTy(),
|
2009-08-13 21:58:54 +00:00
|
|
|
"Function has metadata parameter but isn't an intrinsic", I);
|
2009-05-30 05:06:04 +00:00
|
|
|
}
|
|
|
|
|
2007-12-21 19:19:01 +00:00
|
|
|
visitInstruction(*I);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitCallInst(CallInst &CI) {
|
|
|
|
VerifyCallSite(&CI);
|
2002-07-18 00:13:42 +00:00
|
|
|
|
2009-02-05 01:49:45 +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);
|
2007-12-21 19:19:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitInvokeInst(InvokeInst &II) {
|
|
|
|
VerifyCallSite(&II);
|
2011-09-21 22:57:02 +00:00
|
|
|
|
|
|
|
// Verify that there is a landingpad instruction as the first non-PHI
|
|
|
|
// instruction of the 'unwind' destination.
|
|
|
|
Assert1(II.getUnwindDest()->isLandingPad(),
|
|
|
|
"The unwind destination does not have a landingpad instruction!",&II);
|
|
|
|
|
2010-08-02 23:09:14 +00:00
|
|
|
visitTerminatorInst(II);
|
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()) {
|
2009-06-05 16:10:00 +00:00
|
|
|
// Check that integer arithmetic operators are only used with
|
|
|
|
// integral operands.
|
|
|
|
case Instruction::Add:
|
|
|
|
case Instruction::Sub:
|
|
|
|
case Instruction::Mul:
|
|
|
|
case Instruction::SDiv:
|
|
|
|
case Instruction::UDiv:
|
|
|
|
case Instruction::SRem:
|
|
|
|
case Instruction::URem:
|
2010-02-15 16:12:20 +00:00
|
|
|
Assert1(B.getType()->isIntOrIntVectorTy(),
|
2009-06-05 16:10:00 +00:00
|
|
|
"Integer arithmetic operators only work with integral types!", &B);
|
|
|
|
Assert1(B.getType() == B.getOperand(0)->getType(),
|
|
|
|
"Integer arithmetic operators must have same type "
|
|
|
|
"for operands and result!", &B);
|
|
|
|
break;
|
|
|
|
// Check that floating-point arithmetic operators are only used with
|
|
|
|
// floating-point operands.
|
|
|
|
case Instruction::FAdd:
|
|
|
|
case Instruction::FSub:
|
|
|
|
case Instruction::FMul:
|
|
|
|
case Instruction::FDiv:
|
|
|
|
case Instruction::FRem:
|
2010-02-15 16:12:20 +00:00
|
|
|
Assert1(B.getType()->isFPOrFPVectorTy(),
|
2009-06-05 16:10:00 +00:00
|
|
|
"Floating-point arithmetic operators only work with "
|
2009-06-05 18:34:16 +00:00
|
|
|
"floating-point types!", &B);
|
2009-06-05 16:10:00 +00:00
|
|
|
Assert1(B.getType() == B.getOperand(0)->getType(),
|
|
|
|
"Floating-point arithmetic operators must have same type "
|
|
|
|
"for operands and result!", &B);
|
|
|
|
break;
|
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:
|
2010-02-15 16:12:20 +00:00
|
|
|
Assert1(B.getType()->isIntOrIntVectorTy(),
|
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:
|
2010-02-15 16:12:20 +00:00
|
|
|
Assert1(B.getType()->isIntOrIntVectorTy(),
|
2008-07-29 15:49:41 +00:00
|
|
|
"Shifts only work with integral types!", &B);
|
2007-02-02 02:16:23 +00:00
|
|
|
Assert1(B.getType() == B.getOperand(0)->getType(),
|
|
|
|
"Shift return type must be same as operands!", &B);
|
|
|
|
break;
|
2009-06-05 16:10:00 +00:00
|
|
|
default:
|
2009-07-14 16:55:14 +00:00
|
|
|
llvm_unreachable("Unknown BinaryOperator opcode!");
|
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
|
|
|
}
|
|
|
|
|
2010-08-22 23:45:14 +00:00
|
|
|
void Verifier::visitICmpInst(ICmpInst &IC) {
|
2006-11-20 01:22:35 +00:00
|
|
|
// Check that the operands are the same type
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *Op0Ty = IC.getOperand(0)->getType();
|
|
|
|
Type *Op1Ty = IC.getOperand(1)->getType();
|
2006-11-20 01:22:35 +00:00
|
|
|
Assert1(Op0Ty == Op1Ty,
|
|
|
|
"Both operands to ICmp instruction are not of the same type!", &IC);
|
|
|
|
// Check that the operands are the right type
|
2010-02-16 11:11:14 +00:00
|
|
|
Assert1(Op0Ty->isIntOrIntVectorTy() || Op0Ty->isPointerTy(),
|
2006-11-20 01:22:35 +00:00
|
|
|
"Invalid operand types for ICmp instruction", &IC);
|
2010-08-22 23:45:14 +00:00
|
|
|
// Check that the predicate is valid.
|
|
|
|
Assert1(IC.getPredicate() >= CmpInst::FIRST_ICMP_PREDICATE &&
|
|
|
|
IC.getPredicate() <= CmpInst::LAST_ICMP_PREDICATE,
|
|
|
|
"Invalid predicate in ICmp instruction!", &IC);
|
2009-05-30 05:06:04 +00:00
|
|
|
|
2006-11-20 01:22:35 +00:00
|
|
|
visitInstruction(IC);
|
|
|
|
}
|
|
|
|
|
2010-08-22 23:45:14 +00:00
|
|
|
void Verifier::visitFCmpInst(FCmpInst &FC) {
|
2006-11-20 01:22:35 +00:00
|
|
|
// Check that the operands are the same type
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *Op0Ty = FC.getOperand(0)->getType();
|
|
|
|
Type *Op1Ty = FC.getOperand(1)->getType();
|
2006-11-20 01:22:35 +00:00
|
|
|
Assert1(Op0Ty == Op1Ty,
|
|
|
|
"Both operands to FCmp instruction are not of the same type!", &FC);
|
|
|
|
// Check that the operands are the right type
|
2010-02-15 16:12:20 +00:00
|
|
|
Assert1(Op0Ty->isFPOrFPVectorTy(),
|
2006-11-20 01:22:35 +00:00
|
|
|
"Invalid operand types for FCmp instruction", &FC);
|
2010-08-22 23:45:14 +00:00
|
|
|
// Check that the predicate is valid.
|
|
|
|
Assert1(FC.getPredicate() >= CmpInst::FIRST_FCMP_PREDICATE &&
|
|
|
|
FC.getPredicate() <= CmpInst::LAST_FCMP_PREDICATE,
|
|
|
|
"Invalid predicate in FCmp instruction!", &FC);
|
|
|
|
|
2006-11-20 01:22:35 +00:00
|
|
|
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);
|
|
|
|
visitInstruction(SV);
|
|
|
|
}
|
|
|
|
|
2002-06-25 15:56:27 +00:00
|
|
|
void Verifier::visitGetElementPtrInst(GetElementPtrInst &GEP) {
|
2011-07-29 20:32:28 +00:00
|
|
|
Assert1(cast<PointerType>(GEP.getOperand(0)->getType())
|
|
|
|
->getElementType()->isSized(),
|
|
|
|
"GEP into unsized type!", &GEP);
|
|
|
|
|
2007-02-10 08:30:29 +00:00
|
|
|
SmallVector<Value*, 16> Idxs(GEP.idx_begin(), GEP.idx_end());
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *ElTy =
|
2011-07-25 09:48:08 +00:00
|
|
|
GetElementPtrInst::getIndexedType(GEP.getOperand(0)->getType(), Idxs);
|
2002-06-25 15:56:27 +00:00
|
|
|
Assert1(ElTy, "Invalid indices for GEP pointer type!", &GEP);
|
2010-02-16 11:11:14 +00:00
|
|
|
Assert2(GEP.getType()->isPointerTy() &&
|
2007-02-10 08:30:29 +00:00
|
|
|
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) {
|
2011-07-18 04:54:35 +00:00
|
|
|
PointerType *PTy = dyn_cast<PointerType>(LI.getOperand(0)->getType());
|
2009-09-08 01:23:52 +00:00
|
|
|
Assert1(PTy, "Load operand must be a pointer.", &LI);
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *ElTy = PTy->getElementType();
|
2009-09-08 02:02:39 +00:00
|
|
|
Assert2(ElTy == LI.getType(),
|
|
|
|
"Load result type does not match pointer operand type!", &LI, ElTy);
|
2011-08-09 23:02:53 +00:00
|
|
|
if (LI.isAtomic()) {
|
|
|
|
Assert1(LI.getOrdering() != Release && LI.getOrdering() != AcquireRelease,
|
|
|
|
"Load cannot have Release ordering", &LI);
|
|
|
|
Assert1(LI.getAlignment() != 0,
|
|
|
|
"Atomic load must specify explicit alignment", &LI);
|
|
|
|
} else {
|
|
|
|
Assert1(LI.getSynchScope() == CrossThread,
|
|
|
|
"Non-atomic load cannot have SynchronizationScope specified", &LI);
|
|
|
|
}
|
2002-04-24 19:12:21 +00:00
|
|
|
visitInstruction(LI);
|
|
|
|
}
|
|
|
|
|
2002-06-25 15:56:27 +00:00
|
|
|
void Verifier::visitStoreInst(StoreInst &SI) {
|
2011-07-18 04:54:35 +00:00
|
|
|
PointerType *PTy = dyn_cast<PointerType>(SI.getOperand(1)->getType());
|
2010-07-11 19:42:53 +00:00
|
|
|
Assert1(PTy, "Store operand must be a pointer.", &SI);
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *ElTy = PTy->getElementType();
|
2009-09-08 02:02:39 +00:00
|
|
|
Assert2(ElTy == SI.getOperand(0)->getType(),
|
|
|
|
"Stored value type does not match pointer operand type!",
|
|
|
|
&SI, ElTy);
|
2011-08-09 23:02:53 +00:00
|
|
|
if (SI.isAtomic()) {
|
|
|
|
Assert1(SI.getOrdering() != Acquire && SI.getOrdering() != AcquireRelease,
|
|
|
|
"Store cannot have Acquire ordering", &SI);
|
|
|
|
Assert1(SI.getAlignment() != 0,
|
|
|
|
"Atomic store must specify explicit alignment", &SI);
|
|
|
|
} else {
|
|
|
|
Assert1(SI.getSynchScope() == CrossThread,
|
|
|
|
"Non-atomic store cannot have SynchronizationScope specified", &SI);
|
|
|
|
}
|
2002-04-24 19:12:21 +00:00
|
|
|
visitInstruction(SI);
|
|
|
|
}
|
|
|
|
|
2009-10-23 21:09:37 +00:00
|
|
|
void Verifier::visitAllocaInst(AllocaInst &AI) {
|
2011-07-18 04:54:35 +00:00
|
|
|
PointerType *PTy = AI.getType();
|
2008-03-01 09:01:57 +00:00
|
|
|
Assert1(PTy->getAddressSpace() == 0,
|
|
|
|
"Allocation instruction pointer not in the generic address space!",
|
|
|
|
&AI);
|
|
|
|
Assert1(PTy->getElementType()->isSized(), "Cannot allocate unsized type",
|
|
|
|
&AI);
|
2010-05-28 01:14:11 +00:00
|
|
|
Assert1(AI.getArraySize()->getType()->isIntegerTy(),
|
|
|
|
"Alloca array size must have integer type", &AI);
|
2007-12-17 01:00:21 +00:00
|
|
|
visitInstruction(AI);
|
|
|
|
}
|
|
|
|
|
2011-07-28 21:48:00 +00:00
|
|
|
void Verifier::visitAtomicCmpXchgInst(AtomicCmpXchgInst &CXI) {
|
|
|
|
Assert1(CXI.getOrdering() != NotAtomic,
|
|
|
|
"cmpxchg instructions must be atomic.", &CXI);
|
|
|
|
Assert1(CXI.getOrdering() != Unordered,
|
|
|
|
"cmpxchg instructions cannot be unordered.", &CXI);
|
|
|
|
PointerType *PTy = dyn_cast<PointerType>(CXI.getOperand(0)->getType());
|
|
|
|
Assert1(PTy, "First cmpxchg operand must be a pointer.", &CXI);
|
|
|
|
Type *ElTy = PTy->getElementType();
|
|
|
|
Assert2(ElTy == CXI.getOperand(1)->getType(),
|
|
|
|
"Expected value type does not match pointer operand type!",
|
|
|
|
&CXI, ElTy);
|
|
|
|
Assert2(ElTy == CXI.getOperand(2)->getType(),
|
|
|
|
"Stored value type does not match pointer operand type!",
|
|
|
|
&CXI, ElTy);
|
|
|
|
visitInstruction(CXI);
|
|
|
|
}
|
|
|
|
|
|
|
|
void Verifier::visitAtomicRMWInst(AtomicRMWInst &RMWI) {
|
|
|
|
Assert1(RMWI.getOrdering() != NotAtomic,
|
|
|
|
"atomicrmw instructions must be atomic.", &RMWI);
|
|
|
|
Assert1(RMWI.getOrdering() != Unordered,
|
|
|
|
"atomicrmw instructions cannot be unordered.", &RMWI);
|
|
|
|
PointerType *PTy = dyn_cast<PointerType>(RMWI.getOperand(0)->getType());
|
|
|
|
Assert1(PTy, "First atomicrmw operand must be a pointer.", &RMWI);
|
|
|
|
Type *ElTy = PTy->getElementType();
|
|
|
|
Assert2(ElTy == RMWI.getOperand(1)->getType(),
|
|
|
|
"Argument value type does not match pointer operand type!",
|
|
|
|
&RMWI, ElTy);
|
|
|
|
Assert1(AtomicRMWInst::FIRST_BINOP <= RMWI.getOperation() &&
|
|
|
|
RMWI.getOperation() <= AtomicRMWInst::LAST_BINOP,
|
|
|
|
"Invalid binary operation!", &RMWI);
|
|
|
|
visitInstruction(RMWI);
|
|
|
|
}
|
|
|
|
|
2011-07-25 23:16:38 +00:00
|
|
|
void Verifier::visitFenceInst(FenceInst &FI) {
|
|
|
|
const AtomicOrdering Ordering = FI.getOrdering();
|
|
|
|
Assert1(Ordering == Acquire || Ordering == Release ||
|
|
|
|
Ordering == AcquireRelease || Ordering == SequentiallyConsistent,
|
|
|
|
"fence instructions may only have "
|
2011-08-08 08:02:48 +00:00
|
|
|
"acquire, release, acq_rel, or seq_cst ordering.", &FI);
|
2011-07-25 23:16:38 +00:00
|
|
|
visitInstruction(FI);
|
|
|
|
}
|
|
|
|
|
2008-07-23 00:34:11 +00:00
|
|
|
void Verifier::visitExtractValueInst(ExtractValueInst &EVI) {
|
|
|
|
Assert1(ExtractValueInst::getIndexedType(EVI.getAggregateOperand()->getType(),
|
2011-07-13 10:26:04 +00:00
|
|
|
EVI.getIndices()) ==
|
2008-07-23 00:34:11 +00:00
|
|
|
EVI.getType(),
|
|
|
|
"Invalid ExtractValueInst operands!", &EVI);
|
2008-04-23 04:06:15 +00:00
|
|
|
|
2008-07-23 00:34:11 +00:00
|
|
|
visitInstruction(EVI);
|
2008-02-19 22:15:16 +00:00
|
|
|
}
|
|
|
|
|
2008-07-23 00:34:11 +00:00
|
|
|
void Verifier::visitInsertValueInst(InsertValueInst &IVI) {
|
|
|
|
Assert1(ExtractValueInst::getIndexedType(IVI.getAggregateOperand()->getType(),
|
2011-07-13 10:26:04 +00:00
|
|
|
IVI.getIndices()) ==
|
2008-07-23 00:34:11 +00:00
|
|
|
IVI.getOperand(1)->getType(),
|
|
|
|
"Invalid InsertValueInst operands!", &IVI);
|
|
|
|
|
|
|
|
visitInstruction(IVI);
|
|
|
|
}
|
2002-04-18 20:37:37 +00:00
|
|
|
|
2011-08-12 20:24:12 +00:00
|
|
|
void Verifier::visitLandingPadInst(LandingPadInst &LPI) {
|
|
|
|
BasicBlock *BB = LPI.getParent();
|
|
|
|
|
|
|
|
// The landingpad instruction is ill-formed if it doesn't have any clauses and
|
|
|
|
// isn't a cleanup.
|
|
|
|
Assert1(LPI.getNumClauses() > 0 || LPI.isCleanup(),
|
|
|
|
"LandingPadInst needs at least one clause or to be a cleanup.", &LPI);
|
|
|
|
|
|
|
|
// The landingpad instruction defines its parent as a landing pad block. The
|
|
|
|
// landing pad block may be branched to only by the unwind edge of an invoke.
|
|
|
|
for (pred_iterator I = pred_begin(BB), E = pred_end(BB); I != E; ++I) {
|
|
|
|
const InvokeInst *II = dyn_cast<InvokeInst>((*I)->getTerminator());
|
|
|
|
Assert1(II && II->getUnwindDest() == BB,
|
|
|
|
"Block containing LandingPadInst must be jumped to "
|
|
|
|
"only by the unwind edge of an invoke.", &LPI);
|
|
|
|
}
|
|
|
|
|
|
|
|
// The landingpad instruction must be the first non-PHI instruction in the
|
|
|
|
// block.
|
|
|
|
Assert1(LPI.getParent()->getLandingPadInst() == &LPI,
|
|
|
|
"LandingPadInst not the first non-PHI instruction in the block.",
|
|
|
|
&LPI);
|
|
|
|
|
|
|
|
// The personality functions for all landingpad instructions within the same
|
|
|
|
// function should match.
|
|
|
|
if (PersonalityFn)
|
|
|
|
Assert1(LPI.getPersonalityFn() == PersonalityFn,
|
|
|
|
"Personality function doesn't match others in function", &LPI);
|
|
|
|
PersonalityFn = LPI.getPersonalityFn();
|
|
|
|
|
2011-09-27 16:43:19 +00:00
|
|
|
// All operands must be constants.
|
|
|
|
Assert1(isa<Constant>(PersonalityFn), "Personality function is not constant!",
|
|
|
|
&LPI);
|
|
|
|
for (unsigned i = 0, e = LPI.getNumClauses(); i < e; ++i) {
|
|
|
|
Value *Clause = LPI.getClause(i);
|
|
|
|
Assert1(isa<Constant>(Clause), "Clause is not constant!", &LPI);
|
|
|
|
if (LPI.isFilter(i))
|
|
|
|
Assert1(isa<ConstantArray>(Clause) || isa<ConstantAggregateZero>(Clause),
|
|
|
|
"Filter is not an array of constants!", &LPI);
|
|
|
|
}
|
|
|
|
|
2011-08-12 20:24:12 +00:00
|
|
|
visitInstruction(LPI);
|
|
|
|
}
|
|
|
|
|
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)
|
2009-05-29 19:39:36 +00:00
|
|
|
Assert1(*UI != (User*)&I || !DT->isReachableFromEntry(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
|
|
|
}
|
2009-09-07 20:44:51 +00:00
|
|
|
|
2002-07-18 00:13:42 +00:00
|
|
|
// Check that void typed values don't have names
|
2009-10-05 05:54:46 +00:00
|
|
|
Assert1(!I.getType()->isVoidTy() || !I.hasName(),
|
2002-06-25 15:56:27 +00:00
|
|
|
"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.
|
2009-10-05 05:54:46 +00:00
|
|
|
Assert1(I.getType()->isVoidTy() ||
|
2009-09-27 23:27:42 +00:00
|
|
|
I.getType()->isFirstClassType(),
|
2004-03-29 00:29:36 +00:00
|
|
|
"Instruction returns a non-scalar type!", &I);
|
|
|
|
|
2009-09-27 23:27:42 +00:00
|
|
|
// Check that the instruction doesn't produce metadata. Calls are already
|
|
|
|
// checked against the callee type.
|
2009-10-05 05:54:46 +00:00
|
|
|
Assert1(!I.getType()->isMetadataTy() ||
|
2009-05-30 05:06:04 +00:00
|
|
|
isa<CallInst>(I) || isa<InvokeInst>(I),
|
|
|
|
"Invalid use of metadata!", &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) {
|
2009-09-08 01:23:52 +00:00
|
|
|
if (Instruction *Used = dyn_cast<Instruction>(*UI))
|
|
|
|
Assert2(Used->getParent() != 0, "Instruction referencing instruction not"
|
|
|
|
" embedded in a basic block!", &I, Used);
|
2009-09-08 02:02:39 +00:00
|
|
|
else {
|
2009-09-08 01:23:52 +00:00
|
|
|
CheckFailed("Use of instruction is not an instruction!", *UI);
|
2009-09-08 02:02:39 +00:00
|
|
|
return;
|
|
|
|
}
|
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.
|
2008-02-21 01:54:02 +00:00
|
|
|
if (!I.getOperand(i)->getType()->isFirstClassType()) {
|
2008-07-23 00:34:11 +00:00
|
|
|
Assert1(0, "Instruction operands must be first-class values!", &I);
|
2008-02-21 01:54:02 +00:00
|
|
|
}
|
2009-05-30 05:06:04 +00:00
|
|
|
|
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.
|
2010-07-13 15:31:36 +00:00
|
|
|
Assert1(!F->isIntrinsic() || (i + 1 == e && isa<CallInst>(I)),
|
2003-05-08 03:47:33 +00:00
|
|
|
"Cannot take the address of an intrinsic!", &I);
|
2007-04-20 21:48:08 +00:00
|
|
|
Assert1(F->getParent() == Mod, "Referencing function in another module!",
|
|
|
|
&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);
|
2007-04-20 21:48:08 +00:00
|
|
|
} else if (GlobalValue *GV = dyn_cast<GlobalValue>(I.getOperand(i))) {
|
|
|
|
Assert1(GV->getParent() == Mod, "Referencing global in another module!",
|
|
|
|
&I);
|
2004-03-14 03:23:54 +00:00
|
|
|
} 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.
|
2009-05-29 19:39:36 +00:00
|
|
|
if (InvokeInst *II = dyn_cast<InvokeInst>(Op)) {
|
2004-01-14 05:42:52 +00:00
|
|
|
// Invoke results are only usable in the normal destination, not in the
|
|
|
|
// exceptional destination.
|
2009-05-29 19:39:36 +00:00
|
|
|
BasicBlock *NormalDest = II->getNormalDest();
|
|
|
|
|
|
|
|
Assert2(NormalDest != II->getUnwindDest(),
|
|
|
|
"No uses of invoke possible due to dominance structure!",
|
|
|
|
Op, &I);
|
|
|
|
|
|
|
|
// PHI nodes differ from other nodes because they actually "use" the
|
|
|
|
// value in the predecessor basic blocks they correspond to.
|
|
|
|
BasicBlock *UseBlock = BB;
|
2011-06-20 14:18:48 +00:00
|
|
|
if (PHINode *PN = dyn_cast<PHINode>(&I)) {
|
|
|
|
unsigned j = PHINode::getIncomingValueNumForOperand(i);
|
|
|
|
UseBlock = PN->getIncomingBlock(j);
|
|
|
|
}
|
2009-09-08 02:02:39 +00:00
|
|
|
Assert2(UseBlock, "Invoke operand is PHI node with bad incoming-BB",
|
|
|
|
Op, &I);
|
2009-05-29 19:39:36 +00:00
|
|
|
|
|
|
|
if (isa<PHINode>(I) && UseBlock == OpBlock) {
|
|
|
|
// Special case of a phi node in the normal destination or the unwind
|
|
|
|
// destination.
|
|
|
|
Assert2(BB == NormalDest || !DT->isReachableFromEntry(UseBlock),
|
|
|
|
"Invoke result not available in the unwind destination!",
|
|
|
|
Op, &I);
|
|
|
|
} else {
|
|
|
|
Assert2(DT->dominates(NormalDest, UseBlock) ||
|
|
|
|
!DT->isReachableFromEntry(UseBlock),
|
|
|
|
"Invoke result does not dominate all uses!", Op, &I);
|
|
|
|
|
2006-12-16 02:25:35 +00:00
|
|
|
// If the normal successor of an invoke instruction has multiple
|
2009-05-29 19:39:36 +00:00
|
|
|
// 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).
|
|
|
|
if (!NormalDest->getSinglePredecessor() &&
|
|
|
|
DT->isReachableFromEntry(UseBlock))
|
2006-12-16 02:25:35 +00:00
|
|
|
// If it is used by something non-phi, then the other case is that
|
2009-05-29 19:39:36 +00:00
|
|
|
// 'NormalDest' dominates all of its predecessors other than the
|
2006-12-16 02:25:35 +00:00
|
|
|
// invoke. In this case, the invoke value can still be used.
|
2009-05-29 19:39:36 +00:00
|
|
|
for (pred_iterator PI = pred_begin(NormalDest),
|
|
|
|
E = pred_end(NormalDest); PI != E; ++PI)
|
|
|
|
if (*PI != II->getParent() && !DT->dominates(NormalDest, *PI) &&
|
|
|
|
DT->isReachableFromEntry(*PI)) {
|
|
|
|
CheckFailed("Invoke result does not dominate all uses!", Op,&I);
|
|
|
|
return;
|
2006-12-16 02:25:35 +00:00
|
|
|
}
|
2009-05-29 19:39:36 +00:00
|
|
|
}
|
2011-06-20 14:18:48 +00:00
|
|
|
} else if (PHINode *PN = dyn_cast<PHINode>(&I)) {
|
2009-05-29 19:39:36 +00:00
|
|
|
// PHI nodes are more difficult than other nodes because they actually
|
|
|
|
// "use" the value in the predecessor basic blocks they correspond to.
|
2011-06-20 14:18:48 +00:00
|
|
|
unsigned j = PHINode::getIncomingValueNumForOperand(i);
|
|
|
|
BasicBlock *PredBB = PN->getIncomingBlock(j);
|
2009-09-08 01:23:52 +00:00
|
|
|
Assert2(PredBB && (DT->dominates(OpBlock, PredBB) ||
|
|
|
|
!DT->isReachableFromEntry(PredBB)),
|
2009-05-29 19:39:36 +00:00
|
|
|
"Instruction does not dominate all uses!", Op, &I);
|
|
|
|
} 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.
|
2009-05-29 19:39:36 +00:00
|
|
|
Assert2(InstsInThisBlock.count(Op) || !DT->isReachableFromEntry(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!
|
2008-07-18 05:23:39 +00:00
|
|
|
Assert2(InstsInThisBlock.count(Op) || DT->dominates(Op, &I) ||
|
2009-05-29 19:39:36 +00:00
|
|
|
!DT->isReachableFromEntry(BB),
|
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))) {
|
2010-07-13 15:31:36 +00:00
|
|
|
Assert1((i + 1 == e && isa<CallInst>(I)) ||
|
|
|
|
(i + 3 == e && isa<InvokeInst>(I)),
|
2006-01-26 00:08:45 +00:00
|
|
|
"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
|
|
|
}
|
|
|
|
|
2009-01-07 00:09:01 +00:00
|
|
|
// Flags used by TableGen to mark intrinsic parameters with the
|
|
|
|
// LLVMExtendedElementVectorType and LLVMTruncatedElementVectorType classes.
|
|
|
|
static const unsigned ExtendedElementVectorType = 0x40000000;
|
|
|
|
static const unsigned TruncatedElementVectorType = 0x20000000;
|
|
|
|
|
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-04-20 21:48:08 +00:00
|
|
|
Assert1(IF->isDeclaration(), "Intrinsic functions should never be defined!",
|
|
|
|
IF);
|
2009-09-07 20:44:51 +00:00
|
|
|
|
2006-03-09 22:06:04 +00:00
|
|
|
#define GET_INTRINSIC_VERIFIER
|
|
|
|
#include "llvm/Intrinsics.gen"
|
|
|
|
#undef GET_INTRINSIC_VERIFIER
|
2009-09-07 20:44:51 +00:00
|
|
|
|
2009-12-28 09:07:21 +00:00
|
|
|
// If the intrinsic takes MDNode arguments, verify that they are either global
|
|
|
|
// or are local to *this* function.
|
2010-06-07 19:18:58 +00:00
|
|
|
for (unsigned i = 0, e = CI.getNumArgOperands(); i != e; ++i)
|
|
|
|
if (MDNode *MD = dyn_cast<MDNode>(CI.getArgOperand(i)))
|
2010-04-29 16:10:30 +00:00
|
|
|
visitMDNode(*MD, CI.getParent()->getParent());
|
2009-12-18 20:09:14 +00:00
|
|
|
|
2007-09-17 20:30:04 +00:00
|
|
|
switch (ID) {
|
|
|
|
default:
|
|
|
|
break;
|
2010-01-22 19:06:12 +00:00
|
|
|
case Intrinsic::dbg_declare: { // llvm.dbg.declare
|
2010-06-23 13:56:57 +00:00
|
|
|
Assert1(CI.getArgOperand(0) && isa<MDNode>(CI.getArgOperand(0)),
|
2010-01-22 19:06:12 +00:00
|
|
|
"invalid llvm.dbg.declare intrinsic call 1", &CI);
|
2010-06-23 13:56:57 +00:00
|
|
|
MDNode *MD = cast<MDNode>(CI.getArgOperand(0));
|
2010-01-22 19:06:12 +00:00
|
|
|
Assert1(MD->getNumOperands() == 1,
|
|
|
|
"invalid llvm.dbg.declare intrinsic call 2", &CI);
|
|
|
|
} break;
|
2008-11-21 16:42:48 +00:00
|
|
|
case Intrinsic::memcpy:
|
|
|
|
case Intrinsic::memmove:
|
|
|
|
case Intrinsic::memset:
|
2010-06-23 13:56:57 +00:00
|
|
|
Assert1(isa<ConstantInt>(CI.getArgOperand(3)),
|
2008-08-23 05:31:10 +00:00
|
|
|
"alignment argument of memory intrinsics must be a constant int",
|
|
|
|
&CI);
|
2011-05-31 20:12:07 +00:00
|
|
|
Assert1(isa<ConstantInt>(CI.getArgOperand(4)),
|
|
|
|
"isvolatile argument of memory intrinsics must be a constant int",
|
|
|
|
&CI);
|
2008-08-23 05:31:10 +00:00
|
|
|
break;
|
2008-08-23 09:46:46 +00:00
|
|
|
case Intrinsic::gcroot:
|
|
|
|
case Intrinsic::gcwrite:
|
2008-08-24 20:46:13 +00:00
|
|
|
case Intrinsic::gcread:
|
|
|
|
if (ID == Intrinsic::gcroot) {
|
2008-10-25 16:28:35 +00:00
|
|
|
AllocaInst *AI =
|
2010-06-23 13:56:57 +00:00
|
|
|
dyn_cast<AllocaInst>(CI.getArgOperand(0)->stripPointerCasts());
|
2010-09-30 20:23:47 +00:00
|
|
|
Assert1(AI, "llvm.gcroot parameter #1 must be an alloca.", &CI);
|
2010-06-23 13:56:57 +00:00
|
|
|
Assert1(isa<Constant>(CI.getArgOperand(1)),
|
2008-08-24 20:46:13 +00:00
|
|
|
"llvm.gcroot parameter #2 must be a constant.", &CI);
|
2010-09-30 20:23:47 +00:00
|
|
|
if (!AI->getType()->getElementType()->isPointerTy()) {
|
|
|
|
Assert1(!isa<ConstantPointerNull>(CI.getArgOperand(1)),
|
|
|
|
"llvm.gcroot parameter #1 must either be a pointer alloca, "
|
|
|
|
"or argument #2 must be a non-null constant.", &CI);
|
|
|
|
}
|
2008-08-24 20:46:13 +00:00
|
|
|
}
|
2009-09-07 20:44:51 +00:00
|
|
|
|
2008-08-24 20:46:13 +00:00
|
|
|
Assert1(CI.getParent()->getParent()->hasGC(),
|
|
|
|
"Enclosing function does not use GC.", &CI);
|
|
|
|
break;
|
2007-09-29 16:25:54 +00:00
|
|
|
case Intrinsic::init_trampoline:
|
2010-06-23 13:56:57 +00:00
|
|
|
Assert1(isa<Function>(CI.getArgOperand(1)->stripPointerCasts()),
|
2007-09-29 16:25:54 +00:00
|
|
|
"llvm.init_trampoline parameter #2 must resolve to a function.",
|
|
|
|
&CI);
|
2007-12-25 02:02:10 +00:00
|
|
|
break;
|
2008-10-16 06:00:36 +00:00
|
|
|
case Intrinsic::prefetch:
|
2010-06-23 13:56:57 +00:00
|
|
|
Assert1(isa<ConstantInt>(CI.getArgOperand(1)) &&
|
|
|
|
isa<ConstantInt>(CI.getArgOperand(2)) &&
|
|
|
|
cast<ConstantInt>(CI.getArgOperand(1))->getZExtValue() < 2 &&
|
|
|
|
cast<ConstantInt>(CI.getArgOperand(2))->getZExtValue() < 4,
|
2008-10-16 06:00:36 +00:00
|
|
|
"invalid arguments to llvm.prefetch",
|
|
|
|
&CI);
|
|
|
|
break;
|
2008-11-18 23:09:31 +00:00
|
|
|
case Intrinsic::stackprotector:
|
2010-06-23 13:56:57 +00:00
|
|
|
Assert1(isa<AllocaInst>(CI.getArgOperand(1)->stripPointerCasts()),
|
2008-11-18 23:09:31 +00:00
|
|
|
"llvm.stackprotector parameter #2 must resolve to an alloca.",
|
|
|
|
&CI);
|
|
|
|
break;
|
2009-10-13 07:57:33 +00:00
|
|
|
case Intrinsic::lifetime_start:
|
|
|
|
case Intrinsic::lifetime_end:
|
|
|
|
case Intrinsic::invariant_start:
|
2010-06-23 13:56:57 +00:00
|
|
|
Assert1(isa<ConstantInt>(CI.getArgOperand(0)),
|
2009-10-13 07:57:33 +00:00
|
|
|
"size argument of memory use markers must be a constant integer",
|
|
|
|
&CI);
|
|
|
|
break;
|
|
|
|
case Intrinsic::invariant_end:
|
2010-06-23 13:56:57 +00:00
|
|
|
Assert1(isa<ConstantInt>(CI.getArgOperand(1)),
|
2009-10-13 07:57:33 +00:00
|
|
|
"llvm.invariant.end parameter #2 must be a constant integer", &CI);
|
|
|
|
break;
|
2007-09-17 20:30:04 +00:00
|
|
|
}
|
2002-04-18 20:37:37 +00:00
|
|
|
}
|
|
|
|
|
2009-01-08 01:56:06 +00:00
|
|
|
/// Produce a string to identify an intrinsic parameter or return value.
|
|
|
|
/// The ArgNo value numbers the return values from 0 to NumRets-1 and the
|
|
|
|
/// parameters beginning with NumRets.
|
|
|
|
///
|
|
|
|
static std::string IntrinsicParam(unsigned ArgNo, unsigned NumRets) {
|
2010-03-22 20:56:36 +00:00
|
|
|
if (ArgNo >= NumRets)
|
2009-01-08 01:56:06 +00:00
|
|
|
return "Intrinsic parameter #" + utostr(ArgNo - NumRets);
|
2010-03-22 20:56:36 +00:00
|
|
|
if (NumRets == 1)
|
|
|
|
return "Intrinsic result type";
|
|
|
|
return "Intrinsic result type #" + utostr(ArgNo);
|
2009-01-08 01:56:06 +00:00
|
|
|
}
|
|
|
|
|
2011-07-18 04:54:35 +00:00
|
|
|
bool Verifier::PerformTypeCheck(Intrinsic::ID ID, Function *F, Type *Ty,
|
2008-11-13 07:11:27 +00:00
|
|
|
int VT, unsigned ArgNo, std::string &Suffix) {
|
2011-07-18 04:54:35 +00:00
|
|
|
FunctionType *FTy = F->getFunctionType();
|
2008-11-13 07:11:27 +00:00
|
|
|
|
|
|
|
unsigned NumElts = 0;
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *EltTy = Ty;
|
|
|
|
VectorType *VTy = dyn_cast<VectorType>(Ty);
|
2009-01-07 00:09:01 +00:00
|
|
|
if (VTy) {
|
2008-11-13 07:11:27 +00:00
|
|
|
EltTy = VTy->getElementType();
|
|
|
|
NumElts = VTy->getNumElements();
|
|
|
|
}
|
|
|
|
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *RetTy = FTy->getReturnType();
|
|
|
|
StructType *ST = dyn_cast<StructType>(RetTy);
|
2010-03-22 20:56:36 +00:00
|
|
|
unsigned NumRetVals;
|
|
|
|
if (RetTy->isVoidTy())
|
|
|
|
NumRetVals = 0;
|
|
|
|
else if (ST)
|
|
|
|
NumRetVals = ST->getNumElements();
|
|
|
|
else
|
|
|
|
NumRetVals = 1;
|
2009-01-08 01:56:06 +00:00
|
|
|
|
2008-11-13 07:11:27 +00:00
|
|
|
if (VT < 0) {
|
|
|
|
int Match = ~VT;
|
2009-01-07 00:09:01 +00:00
|
|
|
|
|
|
|
// Check flags that indicate a type that is an integral vector type with
|
|
|
|
// elements that are larger or smaller than the elements of the matched
|
|
|
|
// type.
|
|
|
|
if ((Match & (ExtendedElementVectorType |
|
|
|
|
TruncatedElementVectorType)) != 0) {
|
2011-07-18 04:54:35 +00:00
|
|
|
IntegerType *IEltTy = dyn_cast<IntegerType>(EltTy);
|
2009-01-07 23:44:27 +00:00
|
|
|
if (!VTy || !IEltTy) {
|
2010-03-22 20:56:36 +00:00
|
|
|
CheckFailed(IntrinsicParam(ArgNo, NumRetVals) + " is not "
|
2009-01-07 23:44:27 +00:00
|
|
|
"an integral vector type.", F);
|
2009-01-07 00:09:01 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
// Adjust the current Ty (in the opposite direction) rather than
|
|
|
|
// the type being matched against.
|
2009-01-07 23:44:27 +00:00
|
|
|
if ((Match & ExtendedElementVectorType) != 0) {
|
|
|
|
if ((IEltTy->getBitWidth() & 1) != 0) {
|
2010-03-22 20:56:36 +00:00
|
|
|
CheckFailed(IntrinsicParam(ArgNo, NumRetVals) + " vector "
|
2009-01-07 23:44:27 +00:00
|
|
|
"element bit-width is odd.", F);
|
|
|
|
return false;
|
|
|
|
}
|
2009-01-07 00:09:01 +00:00
|
|
|
Ty = VectorType::getTruncatedElementVectorType(VTy);
|
2009-01-07 23:44:27 +00:00
|
|
|
} else
|
2009-01-07 00:09:01 +00:00
|
|
|
Ty = VectorType::getExtendedElementVectorType(VTy);
|
|
|
|
Match &= ~(ExtendedElementVectorType | TruncatedElementVectorType);
|
|
|
|
}
|
|
|
|
|
2010-03-22 20:56:36 +00:00
|
|
|
if (Match <= static_cast<int>(NumRetVals - 1)) {
|
2008-11-19 01:15:05 +00:00
|
|
|
if (ST)
|
|
|
|
RetTy = ST->getElementType(Match);
|
|
|
|
|
|
|
|
if (Ty != RetTy) {
|
2010-03-22 20:56:36 +00:00
|
|
|
CheckFailed(IntrinsicParam(ArgNo, NumRetVals) + " does not "
|
2008-11-13 07:11:27 +00:00
|
|
|
"match return type.", F);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
} else {
|
2010-03-22 20:56:36 +00:00
|
|
|
if (Ty != FTy->getParamType(Match - NumRetVals)) {
|
|
|
|
CheckFailed(IntrinsicParam(ArgNo, NumRetVals) + " does not "
|
|
|
|
"match parameter %" + utostr(Match - NumRetVals) + ".", F);
|
2008-11-13 07:11:27 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
2009-08-11 20:47:22 +00:00
|
|
|
} else if (VT == MVT::iAny) {
|
2010-02-15 16:12:20 +00:00
|
|
|
if (!EltTy->isIntegerTy()) {
|
2010-03-22 20:56:36 +00:00
|
|
|
CheckFailed(IntrinsicParam(ArgNo, NumRetVals) + " is not "
|
2009-01-08 01:56:06 +00:00
|
|
|
"an integer type.", F);
|
2008-11-13 07:11:27 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
unsigned GotBits = cast<IntegerType>(EltTy)->getBitWidth();
|
|
|
|
Suffix += ".";
|
|
|
|
|
|
|
|
if (EltTy != Ty)
|
|
|
|
Suffix += "v" + utostr(NumElts);
|
|
|
|
|
2009-04-04 07:22:01 +00:00
|
|
|
Suffix += "i" + utostr(GotBits);
|
2008-11-13 07:11:27 +00:00
|
|
|
|
|
|
|
// Check some constraints on various intrinsics.
|
|
|
|
switch (ID) {
|
|
|
|
default: break; // Not everything needs to be checked.
|
|
|
|
case Intrinsic::bswap:
|
2009-01-08 01:56:06 +00:00
|
|
|
if (GotBits < 16 || GotBits % 16 != 0) {
|
2008-11-13 07:11:27 +00:00
|
|
|
CheckFailed("Intrinsic requires even byte width argument", F);
|
2009-01-08 01:56:06 +00:00
|
|
|
return false;
|
|
|
|
}
|
2008-11-13 07:11:27 +00:00
|
|
|
break;
|
|
|
|
}
|
2009-08-11 20:47:22 +00:00
|
|
|
} else if (VT == MVT::fAny) {
|
2010-02-15 16:12:20 +00:00
|
|
|
if (!EltTy->isFloatingPointTy()) {
|
2010-03-22 20:56:36 +00:00
|
|
|
CheckFailed(IntrinsicParam(ArgNo, NumRetVals) + " is not "
|
2009-01-08 01:56:06 +00:00
|
|
|
"a floating-point type.", F);
|
2008-11-13 07:11:27 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
Suffix += ".";
|
|
|
|
|
|
|
|
if (EltTy != Ty)
|
|
|
|
Suffix += "v" + utostr(NumElts);
|
|
|
|
|
2009-08-10 22:56:29 +00:00
|
|
|
Suffix += EVT::getEVT(EltTy).getEVTString();
|
2009-08-11 20:47:22 +00:00
|
|
|
} else if (VT == MVT::vAny) {
|
2009-08-11 01:14:02 +00:00
|
|
|
if (!VTy) {
|
2010-03-22 20:56:36 +00:00
|
|
|
CheckFailed(IntrinsicParam(ArgNo, NumRetVals) + " is not a vector type.",
|
|
|
|
F);
|
2009-08-11 01:14:02 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
Suffix += ".v" + utostr(NumElts) + EVT::getEVT(EltTy).getEVTString();
|
2009-08-11 20:47:22 +00:00
|
|
|
} else if (VT == MVT::iPTR) {
|
2010-02-16 11:11:14 +00:00
|
|
|
if (!Ty->isPointerTy()) {
|
2010-03-22 20:56:36 +00:00
|
|
|
CheckFailed(IntrinsicParam(ArgNo, NumRetVals) + " is not a "
|
2009-01-08 01:56:06 +00:00
|
|
|
"pointer and a pointer is required.", F);
|
|
|
|
return false;
|
2008-11-13 07:11:27 +00:00
|
|
|
}
|
2009-08-11 20:47:22 +00:00
|
|
|
} else if (VT == MVT::iPTRAny) {
|
2008-11-13 07:11:27 +00:00
|
|
|
// Outside of TableGen, we don't distinguish iPTRAny (to any address space)
|
|
|
|
// and iPTR. In the verifier, we can not distinguish which case we have so
|
|
|
|
// allow either case to be legal.
|
2011-07-18 04:54:35 +00:00
|
|
|
if (PointerType* PTyp = dyn_cast<PointerType>(Ty)) {
|
2010-08-08 06:12:09 +00:00
|
|
|
EVT PointeeVT = EVT::getEVT(PTyp->getElementType(), true);
|
|
|
|
if (PointeeVT == MVT::Other) {
|
|
|
|
CheckFailed("Intrinsic has pointer to complex type.");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
Suffix += ".p" + utostr(PTyp->getAddressSpace()) +
|
|
|
|
PointeeVT.getEVTString();
|
2008-11-13 07:11:27 +00:00
|
|
|
} else {
|
2010-03-22 20:56:36 +00:00
|
|
|
CheckFailed(IntrinsicParam(ArgNo, NumRetVals) + " is not a "
|
2009-01-08 01:56:06 +00:00
|
|
|
"pointer and a pointer is required.", F);
|
2008-11-13 07:11:27 +00:00
|
|
|
return false;
|
|
|
|
}
|
2009-08-11 20:47:22 +00:00
|
|
|
} else if (EVT((MVT::SimpleValueType)VT).isVector()) {
|
|
|
|
EVT VVT = EVT((MVT::SimpleValueType)VT);
|
2008-11-13 07:11:27 +00:00
|
|
|
|
|
|
|
// If this is a vector argument, verify the number and type of elements.
|
2009-08-10 22:56:29 +00:00
|
|
|
if (VVT.getVectorElementType() != EVT::getEVT(EltTy)) {
|
2008-11-13 07:11:27 +00:00
|
|
|
CheckFailed("Intrinsic prototype has incorrect vector element type!", F);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (VVT.getVectorNumElements() != NumElts) {
|
|
|
|
CheckFailed("Intrinsic prototype has incorrect number of "
|
|
|
|
"vector elements!", F);
|
|
|
|
return false;
|
|
|
|
}
|
2009-08-12 00:36:31 +00:00
|
|
|
} else if (EVT((MVT::SimpleValueType)VT).getTypeForEVT(Ty->getContext()) !=
|
|
|
|
EltTy) {
|
2010-03-22 20:56:36 +00:00
|
|
|
CheckFailed(IntrinsicParam(ArgNo, NumRetVals) + " is wrong!", F);
|
2008-11-13 07:11:27 +00:00
|
|
|
return false;
|
|
|
|
} else if (EltTy != Ty) {
|
2010-03-22 20:56:36 +00:00
|
|
|
CheckFailed(IntrinsicParam(ArgNo, NumRetVals) + " is a vector "
|
2009-01-08 01:56:06 +00:00
|
|
|
"and a scalar is required.", F);
|
|
|
|
return false;
|
2008-11-13 07:11:27 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
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.
|
2008-11-13 09:08:33 +00:00
|
|
|
void Verifier::VerifyIntrinsicPrototype(Intrinsic::ID ID, Function *F,
|
2010-03-22 20:56:36 +00:00
|
|
|
unsigned NumRetVals,
|
|
|
|
unsigned NumParams, ...) {
|
2006-03-31 04:46:47 +00:00
|
|
|
va_list VA;
|
2010-03-22 20:56:36 +00:00
|
|
|
va_start(VA, NumParams);
|
2011-07-18 04:54:35 +00:00
|
|
|
FunctionType *FTy = F->getFunctionType();
|
2009-09-07 20:44:51 +00:00
|
|
|
|
2007-04-01 07:22:57 +00:00
|
|
|
// For overloaded intrinsics, the Suffix of the function name must match the
|
|
|
|
// types of the arguments. This variable keeps track of the expected
|
|
|
|
// suffix, to be checked at the end.
|
|
|
|
std::string Suffix;
|
|
|
|
|
2010-03-22 20:56:36 +00:00
|
|
|
if (FTy->getNumParams() + FTy->isVarArg() != NumParams) {
|
2007-08-04 01:51:18 +00:00
|
|
|
CheckFailed("Intrinsic prototype has incorrect number of arguments!", F);
|
|
|
|
return;
|
|
|
|
}
|
2006-03-31 04:46:47 +00:00
|
|
|
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *Ty = FTy->getReturnType();
|
|
|
|
StructType *ST = dyn_cast<StructType>(Ty);
|
2008-11-13 09:08:33 +00:00
|
|
|
|
2010-03-22 20:56:36 +00:00
|
|
|
if (NumRetVals == 0 && !Ty->isVoidTy()) {
|
|
|
|
CheckFailed("Intrinsic should return void", F);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2008-11-13 09:08:33 +00:00
|
|
|
// Verify the return types.
|
2010-03-22 20:56:36 +00:00
|
|
|
if (ST && ST->getNumElements() != NumRetVals) {
|
2008-11-13 09:08:33 +00:00
|
|
|
CheckFailed("Intrinsic prototype has incorrect number of return types!", F);
|
|
|
|
return;
|
|
|
|
}
|
2010-03-22 20:56:36 +00:00
|
|
|
|
|
|
|
for (unsigned ArgNo = 0; ArgNo != NumRetVals; ++ArgNo) {
|
2009-08-11 20:47:22 +00:00
|
|
|
int VT = va_arg(VA, int); // An MVT::SimpleValueType when non-negative.
|
2008-11-13 09:08:33 +00:00
|
|
|
|
|
|
|
if (ST) Ty = ST->getElementType(ArgNo);
|
|
|
|
if (!PerformTypeCheck(ID, F, Ty, VT, ArgNo, Suffix))
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Verify the parameter types.
|
2010-03-22 20:56:36 +00:00
|
|
|
for (unsigned ArgNo = 0; ArgNo != NumParams; ++ArgNo) {
|
2009-08-11 20:47:22 +00:00
|
|
|
int VT = va_arg(VA, int); // An MVT::SimpleValueType when non-negative.
|
2007-02-06 18:02:54 +00:00
|
|
|
|
2009-08-11 20:47:22 +00:00
|
|
|
if (VT == MVT::isVoid && ArgNo > 0) {
|
2007-08-04 01:51:18 +00:00
|
|
|
if (!FTy->isVarArg())
|
|
|
|
CheckFailed("Intrinsic prototype has no '...'!", F);
|
2006-03-31 04:46:47 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2010-03-22 20:56:36 +00:00
|
|
|
if (!PerformTypeCheck(ID, F, FTy->getParamType(ArgNo), VT,
|
|
|
|
ArgNo + NumRetVals, Suffix))
|
2007-08-04 01:51:18 +00:00
|
|
|
break;
|
2006-03-31 04:46:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
va_end(VA);
|
2007-04-01 07:22:57 +00:00
|
|
|
|
2008-07-30 04:36:53 +00:00
|
|
|
// For intrinsics without pointer arguments, if we computed a Suffix then the
|
|
|
|
// intrinsic is overloaded and we need to make sure that the name of the
|
|
|
|
// function is correct. We add the suffix to the name of the intrinsic and
|
|
|
|
// compare against the given function name. If they are not the same, the
|
|
|
|
// function name is invalid. This ensures that overloading of intrinsics
|
|
|
|
// uses a sane and consistent naming convention. Note that intrinsics with
|
|
|
|
// pointer argument may or may not be overloaded so we will check assuming it
|
|
|
|
// has a suffix and not.
|
2007-04-01 07:22:57 +00:00
|
|
|
if (!Suffix.empty()) {
|
|
|
|
std::string Name(Intrinsic::getName(ID));
|
2008-07-30 04:36:53 +00:00
|
|
|
if (Name + Suffix != F->getName()) {
|
2007-04-01 07:22:57 +00:00
|
|
|
CheckFailed("Overloaded intrinsic has incorrect suffix: '" +
|
|
|
|
F->getName().substr(Name.length()) + "'. It should be '" +
|
|
|
|
Suffix + "'", F);
|
2008-07-30 04:36:53 +00:00
|
|
|
}
|
2007-04-01 07:22:57 +00:00
|
|
|
}
|
2008-04-07 13:39:11 +00:00
|
|
|
|
|
|
|
// Check parameter attributes.
|
2008-09-25 21:00:45 +00:00
|
|
|
Assert1(F->getAttributes() == Intrinsic::getAttributes(ID),
|
2008-04-07 13:39:11 +00:00
|
|
|
"Intrinsic has wrong parameter attributes!", F);
|
2006-03-31 04:46:47 +00:00
|
|
|
}
|
|
|
|
|
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
|
|
|
|
2010-04-08 15:57:10 +00:00
|
|
|
/// verifyFunction - Check a function for errors, printing messages on stderr.
|
|
|
|
/// Return true if the function is corrupt.
|
|
|
|
///
|
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
|
|
|
|
2010-01-27 20:34:15 +00:00
|
|
|
FunctionPassManager FPM(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);
|
2008-06-24 17:47:37 +00:00
|
|
|
PM.run(const_cast<Module&>(M));
|
2009-09-07 20:44:51 +00:00
|
|
|
|
2006-07-06 18:02:27 +00:00
|
|
|
if (ErrorInfo && V->Broken)
|
2009-08-23 04:02:03 +00:00
|
|
|
*ErrorInfo = V->MessagesStr.str();
|
2002-08-02 17:37:08 +00:00
|
|
|
return V->Broken;
|
2001-06-06 20:29:01 +00:00
|
|
|
}
|