annotate llvm/tools/llvm-diff/DifferenceEngine.h @ 150:1d019706d866

LLVM10
author anatofuz
date Thu, 13 Feb 2020 15:10:13 +0900
parents
children 5f17cb93ff66
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
150
anatofuz
parents:
diff changeset
1 //===-- DifferenceEngine.h - Module comparator ------------------*- C++ -*-===//
anatofuz
parents:
diff changeset
2 //
anatofuz
parents:
diff changeset
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
anatofuz
parents:
diff changeset
4 // See https://llvm.org/LICENSE.txt for license information.
anatofuz
parents:
diff changeset
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
anatofuz
parents:
diff changeset
6 //
anatofuz
parents:
diff changeset
7 //===----------------------------------------------------------------------===//
anatofuz
parents:
diff changeset
8 //
anatofuz
parents:
diff changeset
9 // This header defines the interface to the LLVM difference engine,
anatofuz
parents:
diff changeset
10 // which structurally compares functions within a module.
anatofuz
parents:
diff changeset
11 //
anatofuz
parents:
diff changeset
12 //===----------------------------------------------------------------------===//
anatofuz
parents:
diff changeset
13
anatofuz
parents:
diff changeset
14 #ifndef LLVM_TOOLS_LLVM_DIFF_DIFFERENCEENGINE_H
anatofuz
parents:
diff changeset
15 #define LLVM_TOOLS_LLVM_DIFF_DIFFERENCEENGINE_H
anatofuz
parents:
diff changeset
16
anatofuz
parents:
diff changeset
17 #include "DiffConsumer.h"
anatofuz
parents:
diff changeset
18 #include "DiffLog.h"
anatofuz
parents:
diff changeset
19 #include "llvm/ADT/StringRef.h"
anatofuz
parents:
diff changeset
20 #include <utility>
anatofuz
parents:
diff changeset
21
anatofuz
parents:
diff changeset
22 namespace llvm {
anatofuz
parents:
diff changeset
23 class Function;
anatofuz
parents:
diff changeset
24 class GlobalValue;
anatofuz
parents:
diff changeset
25 class Instruction;
anatofuz
parents:
diff changeset
26 class LLVMContext;
anatofuz
parents:
diff changeset
27 class Module;
anatofuz
parents:
diff changeset
28 class Twine;
anatofuz
parents:
diff changeset
29 class Value;
anatofuz
parents:
diff changeset
30
anatofuz
parents:
diff changeset
31 /// A class for performing structural comparisons of LLVM assembly.
anatofuz
parents:
diff changeset
32 class DifferenceEngine {
anatofuz
parents:
diff changeset
33 public:
anatofuz
parents:
diff changeset
34 /// A RAII object for recording the current context.
anatofuz
parents:
diff changeset
35 struct Context {
anatofuz
parents:
diff changeset
36 Context(DifferenceEngine &Engine, Value *L, Value *R) : Engine(Engine) {
anatofuz
parents:
diff changeset
37 Engine.consumer.enterContext(L, R);
anatofuz
parents:
diff changeset
38 }
anatofuz
parents:
diff changeset
39
anatofuz
parents:
diff changeset
40 ~Context() {
anatofuz
parents:
diff changeset
41 Engine.consumer.exitContext();
anatofuz
parents:
diff changeset
42 }
anatofuz
parents:
diff changeset
43
anatofuz
parents:
diff changeset
44 private:
anatofuz
parents:
diff changeset
45 DifferenceEngine &Engine;
anatofuz
parents:
diff changeset
46 };
anatofuz
parents:
diff changeset
47
anatofuz
parents:
diff changeset
48 /// An oracle for answering whether two values are equivalent as
anatofuz
parents:
diff changeset
49 /// operands.
anatofuz
parents:
diff changeset
50 class Oracle {
anatofuz
parents:
diff changeset
51 virtual void anchor();
anatofuz
parents:
diff changeset
52 public:
anatofuz
parents:
diff changeset
53 virtual bool operator()(Value *L, Value *R) = 0;
anatofuz
parents:
diff changeset
54
anatofuz
parents:
diff changeset
55 protected:
anatofuz
parents:
diff changeset
56 virtual ~Oracle() {}
anatofuz
parents:
diff changeset
57 };
anatofuz
parents:
diff changeset
58
anatofuz
parents:
diff changeset
59 DifferenceEngine(Consumer &consumer)
anatofuz
parents:
diff changeset
60 : consumer(consumer), globalValueOracle(nullptr) {}
anatofuz
parents:
diff changeset
61
anatofuz
parents:
diff changeset
62 void diff(Module *L, Module *R);
anatofuz
parents:
diff changeset
63 void diff(Function *L, Function *R);
anatofuz
parents:
diff changeset
64 void log(StringRef text) {
anatofuz
parents:
diff changeset
65 consumer.log(text);
anatofuz
parents:
diff changeset
66 }
anatofuz
parents:
diff changeset
67 LogBuilder logf(StringRef text) {
anatofuz
parents:
diff changeset
68 return LogBuilder(consumer, text);
anatofuz
parents:
diff changeset
69 }
anatofuz
parents:
diff changeset
70 Consumer& getConsumer() const { return consumer; }
anatofuz
parents:
diff changeset
71
anatofuz
parents:
diff changeset
72 /// Installs an oracle to decide whether two global values are
anatofuz
parents:
diff changeset
73 /// equivalent as operands. Without an oracle, global values are
anatofuz
parents:
diff changeset
74 /// considered equivalent as operands precisely when they have the
anatofuz
parents:
diff changeset
75 /// same name.
anatofuz
parents:
diff changeset
76 void setGlobalValueOracle(Oracle *oracle) {
anatofuz
parents:
diff changeset
77 globalValueOracle = oracle;
anatofuz
parents:
diff changeset
78 }
anatofuz
parents:
diff changeset
79
anatofuz
parents:
diff changeset
80 /// Determines whether two global values are equivalent.
anatofuz
parents:
diff changeset
81 bool equivalentAsOperands(GlobalValue *L, GlobalValue *R);
anatofuz
parents:
diff changeset
82
anatofuz
parents:
diff changeset
83 private:
anatofuz
parents:
diff changeset
84 Consumer &consumer;
anatofuz
parents:
diff changeset
85 Oracle *globalValueOracle;
anatofuz
parents:
diff changeset
86 };
anatofuz
parents:
diff changeset
87 }
anatofuz
parents:
diff changeset
88
anatofuz
parents:
diff changeset
89 #endif