mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2025-10-05 11:17:53 +00:00
This patch is a big refactoring of llvm-diff. It doesn't add new features, but it re-organizes the old features, so I can insert the MetadataEngine to use the same infrastructure.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@127627 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Renato Golin
@@ -11,9 +11,9 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "DiffLog.h"
|
||||
#include "DifferenceEngine.h"
|
||||
|
||||
#include "llvm/Instructions.h"
|
||||
#include "llvm/LLVMContext.h"
|
||||
#include "llvm/Module.h"
|
||||
#include "llvm/Type.h"
|
||||
@@ -21,7 +21,6 @@
|
||||
#include "llvm/ADT/SmallVector.h"
|
||||
#include "llvm/ADT/StringRef.h"
|
||||
#include "llvm/Support/CommandLine.h"
|
||||
#include "llvm/Support/ErrorHandling.h"
|
||||
#include "llvm/Support/IRReader.h"
|
||||
#include "llvm/Support/MemoryBuffer.h"
|
||||
#include "llvm/Support/raw_ostream.h"
|
||||
@@ -43,221 +42,6 @@ static Module *ReadModule(LLVMContext &Context, StringRef Name) {
|
||||
return M;
|
||||
}
|
||||
|
||||
namespace {
|
||||
struct DiffContext {
|
||||
DiffContext(Value *L, Value *R)
|
||||
: L(L), R(R), Differences(false), IsFunction(isa<Function>(L)) {}
|
||||
Value *L;
|
||||
Value *R;
|
||||
bool Differences;
|
||||
bool IsFunction;
|
||||
DenseMap<Value*,unsigned> LNumbering;
|
||||
DenseMap<Value*,unsigned> RNumbering;
|
||||
};
|
||||
}
|
||||
|
||||
static void ComputeNumbering(Function *F, DenseMap<Value*,unsigned> &Numbering){
|
||||
unsigned IN = 0;
|
||||
|
||||
// Arguments get the first numbers.
|
||||
for (Function::arg_iterator
|
||||
AI = F->arg_begin(), AE = F->arg_end(); AI != AE; ++AI)
|
||||
if (!AI->hasName())
|
||||
Numbering[&*AI] = IN++;
|
||||
|
||||
// Walk the basic blocks in order.
|
||||
for (Function::iterator FI = F->begin(), FE = F->end(); FI != FE; ++FI) {
|
||||
if (!FI->hasName())
|
||||
Numbering[&*FI] = IN++;
|
||||
|
||||
// Walk the instructions in order.
|
||||
for (BasicBlock::iterator BI = FI->begin(), BE = FI->end(); BI != BE; ++BI)
|
||||
// void instructions don't get numbers.
|
||||
if (!BI->hasName() && !BI->getType()->isVoidTy())
|
||||
Numbering[&*BI] = IN++;
|
||||
}
|
||||
|
||||
assert(!Numbering.empty() && "asked for numbering but numbering was no-op");
|
||||
}
|
||||
|
||||
namespace {
|
||||
class DiffConsumer : public DifferenceEngine::Consumer {
|
||||
private:
|
||||
raw_ostream &out;
|
||||
Module *LModule;
|
||||
Module *RModule;
|
||||
SmallVector<DiffContext, 5> contexts;
|
||||
bool Differences;
|
||||
unsigned Indent;
|
||||
|
||||
void printValue(Value *V, bool isL) {
|
||||
if (V->hasName()) {
|
||||
out << (isa<GlobalValue>(V) ? '@' : '%') << V->getName();
|
||||
return;
|
||||
}
|
||||
if (V->getType()->isVoidTy()) {
|
||||
if (isa<StoreInst>(V)) {
|
||||
out << "store to ";
|
||||
printValue(cast<StoreInst>(V)->getPointerOperand(), isL);
|
||||
} else if (isa<CallInst>(V)) {
|
||||
out << "call to ";
|
||||
printValue(cast<CallInst>(V)->getCalledValue(), isL);
|
||||
} else if (isa<InvokeInst>(V)) {
|
||||
out << "invoke to ";
|
||||
printValue(cast<InvokeInst>(V)->getCalledValue(), isL);
|
||||
} else {
|
||||
out << *V;
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
unsigned N = contexts.size();
|
||||
while (N > 0) {
|
||||
--N;
|
||||
DiffContext &ctxt = contexts[N];
|
||||
if (!ctxt.IsFunction) continue;
|
||||
if (isL) {
|
||||
if (ctxt.LNumbering.empty())
|
||||
ComputeNumbering(cast<Function>(ctxt.L), ctxt.LNumbering);
|
||||
out << '%' << ctxt.LNumbering[V];
|
||||
return;
|
||||
} else {
|
||||
if (ctxt.RNumbering.empty())
|
||||
ComputeNumbering(cast<Function>(ctxt.R), ctxt.RNumbering);
|
||||
out << '%' << ctxt.RNumbering[V];
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
out << "<anonymous>";
|
||||
}
|
||||
|
||||
void header() {
|
||||
if (contexts.empty()) return;
|
||||
for (SmallVectorImpl<DiffContext>::iterator
|
||||
I = contexts.begin(), E = contexts.end(); I != E; ++I) {
|
||||
if (I->Differences) continue;
|
||||
if (isa<Function>(I->L)) {
|
||||
// Extra newline between functions.
|
||||
if (Differences) out << "\n";
|
||||
|
||||
Function *L = cast<Function>(I->L);
|
||||
Function *R = cast<Function>(I->R);
|
||||
if (L->getName() != R->getName())
|
||||
out << "in function " << L->getName()
|
||||
<< " / " << R->getName() << ":\n";
|
||||
else
|
||||
out << "in function " << L->getName() << ":\n";
|
||||
} else if (isa<BasicBlock>(I->L)) {
|
||||
BasicBlock *L = cast<BasicBlock>(I->L);
|
||||
BasicBlock *R = cast<BasicBlock>(I->R);
|
||||
if (L->hasName() && R->hasName() && L->getName() == R->getName())
|
||||
out << " in block %" << L->getName() << ":\n";
|
||||
else {
|
||||
out << " in block ";
|
||||
printValue(L, true);
|
||||
out << " / ";
|
||||
printValue(R, false);
|
||||
out << ":\n";
|
||||
}
|
||||
} else if (isa<Instruction>(I->L)) {
|
||||
out << " in instruction ";
|
||||
printValue(I->L, true);
|
||||
out << " / ";
|
||||
printValue(I->R, false);
|
||||
out << ":\n";
|
||||
}
|
||||
|
||||
I->Differences = true;
|
||||
}
|
||||
}
|
||||
|
||||
void indent() {
|
||||
unsigned N = Indent;
|
||||
while (N--) out << ' ';
|
||||
}
|
||||
|
||||
public:
|
||||
DiffConsumer(Module *L, Module *R)
|
||||
: out(errs()), LModule(L), RModule(R), Differences(false), Indent(0) {}
|
||||
|
||||
bool hadDifferences() const { return Differences; }
|
||||
|
||||
void enterContext(Value *L, Value *R) {
|
||||
contexts.push_back(DiffContext(L, R));
|
||||
Indent += 2;
|
||||
}
|
||||
void exitContext() {
|
||||
Differences |= contexts.back().Differences;
|
||||
contexts.pop_back();
|
||||
Indent -= 2;
|
||||
}
|
||||
|
||||
void log(StringRef text) {
|
||||
header();
|
||||
indent();
|
||||
out << text << '\n';
|
||||
}
|
||||
|
||||
void logf(const DifferenceEngine::LogBuilder &Log) {
|
||||
header();
|
||||
indent();
|
||||
|
||||
unsigned arg = 0;
|
||||
|
||||
StringRef format = Log.getFormat();
|
||||
while (true) {
|
||||
size_t percent = format.find('%');
|
||||
if (percent == StringRef::npos) {
|
||||
out << format;
|
||||
break;
|
||||
}
|
||||
assert(format[percent] == '%');
|
||||
|
||||
if (percent > 0) out << format.substr(0, percent);
|
||||
|
||||
switch (format[percent+1]) {
|
||||
case '%': out << '%'; break;
|
||||
case 'l': printValue(Log.getArgument(arg++), true); break;
|
||||
case 'r': printValue(Log.getArgument(arg++), false); break;
|
||||
default: llvm_unreachable("unknown format character");
|
||||
}
|
||||
|
||||
format = format.substr(percent+2);
|
||||
}
|
||||
|
||||
out << '\n';
|
||||
}
|
||||
|
||||
void logd(const DifferenceEngine::DiffLogBuilder &Log) {
|
||||
header();
|
||||
|
||||
for (unsigned I = 0, E = Log.getNumLines(); I != E; ++I) {
|
||||
indent();
|
||||
switch (Log.getLineKind(I)) {
|
||||
case DifferenceEngine::DC_match:
|
||||
out << " ";
|
||||
Log.getLeft(I)->dump();
|
||||
//printValue(Log.getLeft(I), true);
|
||||
break;
|
||||
case DifferenceEngine::DC_left:
|
||||
out << "< ";
|
||||
Log.getLeft(I)->dump();
|
||||
//printValue(Log.getLeft(I), true);
|
||||
break;
|
||||
case DifferenceEngine::DC_right:
|
||||
out << "> ";
|
||||
Log.getRight(I)->dump();
|
||||
//printValue(Log.getRight(I), false);
|
||||
break;
|
||||
}
|
||||
//out << "\n";
|
||||
}
|
||||
}
|
||||
|
||||
};
|
||||
} // end anonymous namespace
|
||||
|
||||
static void diffGlobal(DifferenceEngine &Engine, Module *L, Module *R,
|
||||
StringRef Name) {
|
||||
// Drop leading sigils from the global name.
|
||||
|
||||
Reference in New Issue
Block a user