2010-07-29 15:53:27 +08:00
|
|
|
//===-- DifferenceEngine.h - Module comparator ------------------*- C++ -*-===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This header defines the interface to the LLVM difference engine,
|
|
|
|
// which structurally compares functions within a module.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#ifndef _LLVM_DIFFERENCE_ENGINE_H_
|
|
|
|
#define _LLVM_DIFFERENCE_ENGINE_H_
|
|
|
|
|
2012-12-04 18:44:52 +08:00
|
|
|
#include "DiffConsumer.h"
|
|
|
|
#include "DiffLog.h"
|
2010-07-30 02:08:23 +08:00
|
|
|
#include "llvm/ADT/SmallVector.h"
|
|
|
|
#include "llvm/ADT/StringRef.h"
|
2010-07-29 15:53:27 +08:00
|
|
|
#include <utility>
|
|
|
|
|
|
|
|
namespace llvm {
|
2010-07-30 02:08:23 +08:00
|
|
|
class Function;
|
|
|
|
class GlobalValue;
|
|
|
|
class Instruction;
|
2010-07-29 15:53:27 +08:00
|
|
|
class LLVMContext;
|
|
|
|
class Module;
|
|
|
|
class Twine;
|
|
|
|
class Value;
|
|
|
|
|
|
|
|
/// A class for performing structural comparisons of LLVM assembly.
|
|
|
|
class DifferenceEngine {
|
|
|
|
public:
|
|
|
|
/// A RAII object for recording the current context.
|
|
|
|
struct Context {
|
|
|
|
Context(DifferenceEngine &Engine, Value *L, Value *R) : Engine(Engine) {
|
|
|
|
Engine.consumer.enterContext(L, R);
|
|
|
|
}
|
|
|
|
|
|
|
|
~Context() {
|
|
|
|
Engine.consumer.exitContext();
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
DifferenceEngine &Engine;
|
|
|
|
};
|
|
|
|
|
|
|
|
/// An oracle for answering whether two values are equivalent as
|
|
|
|
/// operands.
|
2011-12-20 10:50:00 +08:00
|
|
|
class Oracle {
|
|
|
|
virtual void anchor();
|
|
|
|
public:
|
2010-07-29 15:53:27 +08:00
|
|
|
virtual bool operator()(Value *L, Value *R) = 0;
|
|
|
|
|
|
|
|
protected:
|
2010-09-04 02:41:20 +08:00
|
|
|
virtual ~Oracle() {}
|
2010-07-29 15:53:27 +08:00
|
|
|
};
|
|
|
|
|
2012-06-07 02:25:08 +08:00
|
|
|
DifferenceEngine(Consumer &consumer)
|
|
|
|
: consumer(consumer), globalValueOracle(0) {}
|
2010-07-29 15:53:27 +08:00
|
|
|
|
|
|
|
void diff(Module *L, Module *R);
|
|
|
|
void diff(Function *L, Function *R);
|
|
|
|
void log(StringRef text) {
|
|
|
|
consumer.log(text);
|
|
|
|
}
|
|
|
|
LogBuilder logf(StringRef text) {
|
2011-03-15 06:22:46 +08:00
|
|
|
return LogBuilder(consumer, text);
|
2010-07-29 15:53:27 +08:00
|
|
|
}
|
2011-03-15 06:22:46 +08:00
|
|
|
Consumer& getConsumer() const { return consumer; }
|
2010-07-29 15:53:27 +08:00
|
|
|
|
|
|
|
/// Installs an oracle to decide whether two global values are
|
|
|
|
/// equivalent as operands. Without an oracle, global values are
|
|
|
|
/// considered equivalent as operands precisely when they have the
|
|
|
|
/// same name.
|
|
|
|
void setGlobalValueOracle(Oracle *oracle) {
|
|
|
|
globalValueOracle = oracle;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Determines whether two global values are equivalent.
|
|
|
|
bool equivalentAsOperands(GlobalValue *L, GlobalValue *R);
|
|
|
|
|
|
|
|
private:
|
|
|
|
Consumer &consumer;
|
|
|
|
Oracle *globalValueOracle;
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
#endif
|