DifferenceEngine.h (212793) | DifferenceEngine.h (221337) |
---|---|
1//===-- DifferenceEngine.h - Module comparator ------------------*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This header defines the interface to the LLVM difference engine, 11// which structurally compares functions within a module. 12// 13//===----------------------------------------------------------------------===// 14 15#ifndef _LLVM_DIFFERENCE_ENGINE_H_ 16#define _LLVM_DIFFERENCE_ENGINE_H_ 17 18#include "llvm/ADT/SmallVector.h" 19#include "llvm/ADT/StringRef.h" | 1//===-- DifferenceEngine.h - Module comparator ------------------*- C++ -*-===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This header defines the interface to the LLVM difference engine, 11// which structurally compares functions within a module. 12// 13//===----------------------------------------------------------------------===// 14 15#ifndef _LLVM_DIFFERENCE_ENGINE_H_ 16#define _LLVM_DIFFERENCE_ENGINE_H_ 17 18#include "llvm/ADT/SmallVector.h" 19#include "llvm/ADT/StringRef.h" |
20#include "DiffLog.h" 21#include "DiffConsumer.h" |
|
20 21#include <utility> 22 23namespace llvm { 24 class Function; 25 class GlobalValue; 26 class Instruction; 27 class LLVMContext; 28 class Module; 29 class Twine; 30 class Value; 31 32 /// A class for performing structural comparisons of LLVM assembly. 33 class DifferenceEngine { 34 public: | 22 23#include <utility> 24 25namespace llvm { 26 class Function; 27 class GlobalValue; 28 class Instruction; 29 class LLVMContext; 30 class Module; 31 class Twine; 32 class Value; 33 34 /// A class for performing structural comparisons of LLVM assembly. 35 class DifferenceEngine { 36 public: |
35 /// A temporary-object class for building up log messages. 36 class LogBuilder { 37 DifferenceEngine &Engine; 38 39 /// The use of a stored StringRef here is okay because 40 /// LogBuilder should be used only as a temporary, and as a 41 /// temporary it will be destructed before whatever temporary 42 /// might be initializing this format. 43 StringRef Format; 44 45 SmallVector<Value*, 4> Arguments; 46 47 public: 48 LogBuilder(DifferenceEngine &Engine, StringRef Format) 49 : Engine(Engine), Format(Format) {} 50 51 LogBuilder &operator<<(Value *V) { 52 Arguments.push_back(V); 53 return *this; 54 } 55 56 ~LogBuilder() { 57 Engine.consumer.logf(*this); 58 } 59 60 StringRef getFormat() const { return Format; } 61 62 unsigned getNumArguments() const { return Arguments.size(); } 63 Value *getArgument(unsigned I) const { return Arguments[I]; } 64 }; 65 66 enum DiffChange { DC_match, DC_left, DC_right }; 67 68 /// A temporary-object class for building up diff messages. 69 class DiffLogBuilder { 70 typedef std::pair<Instruction*,Instruction*> DiffRecord; 71 SmallVector<DiffRecord, 20> Diff; 72 73 DifferenceEngine &Engine; 74 75 public: 76 DiffLogBuilder(DifferenceEngine &Engine) : Engine(Engine) {} 77 ~DiffLogBuilder() { Engine.consumer.logd(*this); } 78 79 void addMatch(Instruction *L, Instruction *R) { 80 Diff.push_back(DiffRecord(L, R)); 81 } 82 void addLeft(Instruction *L) { 83 // HACK: VS 2010 has a bug in the stdlib that requires this. 84 Diff.push_back(DiffRecord(L, DiffRecord::second_type(0))); 85 } 86 void addRight(Instruction *R) { 87 // HACK: VS 2010 has a bug in the stdlib that requires this. 88 Diff.push_back(DiffRecord(DiffRecord::first_type(0), R)); 89 } 90 91 unsigned getNumLines() const { return Diff.size(); } 92 DiffChange getLineKind(unsigned I) const { 93 return (Diff[I].first ? (Diff[I].second ? DC_match : DC_left) 94 : DC_right); 95 } 96 Instruction *getLeft(unsigned I) const { return Diff[I].first; } 97 Instruction *getRight(unsigned I) const { return Diff[I].second; } 98 }; 99 100 /// The interface for consumers of difference data. 101 struct Consumer { 102 /// Record that a local context has been entered. Left and 103 /// Right are IR "containers" of some sort which are being 104 /// considered for structural equivalence: global variables, 105 /// functions, blocks, instructions, etc. 106 virtual void enterContext(Value *Left, Value *Right) = 0; 107 108 /// Record that a local context has been exited. 109 virtual void exitContext() = 0; 110 111 /// Record a difference within the current context. 112 virtual void log(StringRef Text) = 0; 113 114 /// Record a formatted difference within the current context. 115 virtual void logf(const LogBuilder &Log) = 0; 116 117 /// Record a line-by-line instruction diff. 118 virtual void logd(const DiffLogBuilder &Log) = 0; 119 120 protected: 121 virtual ~Consumer() {} 122 }; 123 | |
124 /// A RAII object for recording the current context. 125 struct Context { 126 Context(DifferenceEngine &Engine, Value *L, Value *R) : Engine(Engine) { 127 Engine.consumer.enterContext(L, R); 128 } 129 130 ~Context() { 131 Engine.consumer.exitContext(); --- 12 unchanged lines hidden (view full) --- 144 virtual ~Oracle() {} 145 }; 146 147 DifferenceEngine(LLVMContext &context, Consumer &consumer) 148 : context(context), consumer(consumer), globalValueOracle(0) {} 149 150 void diff(Module *L, Module *R); 151 void diff(Function *L, Function *R); | 37 /// A RAII object for recording the current context. 38 struct Context { 39 Context(DifferenceEngine &Engine, Value *L, Value *R) : Engine(Engine) { 40 Engine.consumer.enterContext(L, R); 41 } 42 43 ~Context() { 44 Engine.consumer.exitContext(); --- 12 unchanged lines hidden (view full) --- 57 virtual ~Oracle() {} 58 }; 59 60 DifferenceEngine(LLVMContext &context, Consumer &consumer) 61 : context(context), consumer(consumer), globalValueOracle(0) {} 62 63 void diff(Module *L, Module *R); 64 void diff(Function *L, Function *R); |
152 | |
153 void log(StringRef text) { 154 consumer.log(text); 155 } | 65 void log(StringRef text) { 66 consumer.log(text); 67 } |
156 | |
157 LogBuilder logf(StringRef text) { | 68 LogBuilder logf(StringRef text) { |
158 return LogBuilder(*this, text); | 69 return LogBuilder(consumer, text); |
159 } | 70 } |
71 Consumer& getConsumer() const { return consumer; } |
|
160 161 /// Installs an oracle to decide whether two global values are 162 /// equivalent as operands. Without an oracle, global values are 163 /// considered equivalent as operands precisely when they have the 164 /// same name. 165 void setGlobalValueOracle(Oracle *oracle) { 166 globalValueOracle = oracle; 167 } --- 12 unchanged lines hidden --- | 72 73 /// Installs an oracle to decide whether two global values are 74 /// equivalent as operands. Without an oracle, global values are 75 /// considered equivalent as operands precisely when they have the 76 /// same name. 77 void setGlobalValueOracle(Oracle *oracle) { 78 globalValueOracle = oracle; 79 } --- 12 unchanged lines hidden --- |