[llvm-diff] Create libLLVMDiff library

[void]

Summary

Some tools may want to use the LLVM "diff" code. Move the code into a
library for easy use.

No functionality change intende.

[JonChesterfield]

CI is failing on:

Cannot find source file:
   llvm-livepatch.cpp

New file missing from this commit?

edit: precommit testing also failed on that, e.g. https://buildkite.com/llvm-project/premerge-checks/builds/50915#a9e6c562-ce15-448d-935f-b63a5d50555b

[dyung]

Was the llvm-livepatch changes intended to be part of this change?

[MaskRay]

A new tool llvm-livepatch probably needs a discussion on llvm-dev...

llvm/tools/llvm-diff/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   Core
   IRReader
   Support
   )
 
 add_llvm_tool(llvm-diff
   llvm-diff.cpp
-  DiffConsumer.cpp
-  DiffLog.cpp
-  DifferenceEngine.cpp
 
   DEPENDS
   intrinsics_gen
   )
+
+add_subdirectory(lib)
+target_link_libraries(llvm-diff PRIVATE LLVMDiff)

llvm/tools/llvm-diff/lib/CMakeLists.txt

+set(LLVM_LINK_COMPONENTS
+    Core
+    Support
+    )
+
+add_llvm_library(LLVMDiff
+  STATIC
+  DiffConsumer.cpp
+  DiffConsumer.h
+  DifferenceEngine.cpp
+  DifferenceEngine.h
+  DiffLog.cpp
+  DiffLog.h
+  )

llvm/tools/llvm-diff/lib/DiffConsumer.h

 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/IR/Value.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace llvm {
 class StringRef;
   class Module;
   class Value;
   class Function;
 
   /// The interface for consumers of difference data.
   class Consumer {
     virtual void anchor();
   public:
     /// Record that a local context has been entered.  Left and
public:
 
     /// Record a line-by-line instruction diff.
     virtual void logd(const DiffLogBuilder &Log) = 0;
 
   protected:
     virtual ~Consumer() {}
   };
 
   class DiffConsumer : public Consumer {
   private:
     struct DiffContext {
       DiffContext(const Value *L, const Value *R)
           : L(L), R(R), Differences(false), IsFunction(isa<Function>(L)) {}
       const Value *L;
       const Value *R;
       bool Differences;
       bool IsFunction;
       DenseMap<const Value *, unsigned> LNumbering;
       DenseMap<const Value *, unsigned> RNumbering;
     };
 
     raw_ostream &out;
     SmallVector<DiffContext, 5> contexts;
     bool Differences;
     unsigned Indent;
 
     void printValue(const Value *V, bool isL);
     void header();
     void indent();
 
   public:
     DiffConsumer()
       : out(errs()), Differences(false), Indent(0) {}
 
     bool hadDifferences() const;
     void enterContext(const Value *L, const Value *R) override;
     void exitContext() override;
     void log(StringRef text) override;
     void logf(const LogBuilder &Log) override;
     void logd(const DiffLogBuilder &Log) override;
   };
 }
 
 #endif

llvm/tools/llvm-diff/lib/DiffConsumer.cpp

for (const auto &BB : Func)
       // void instructions don't get numbers.
       if (!BB.hasName() && !BB.getType()->isVoidTy())
         Numbering[&BB] = IN++;
   }
 
   assert(!Numbering.empty() && "asked for numbering but numbering was no-op");
 }
 
 void Consumer::anchor() { }
 
 void DiffConsumer::printValue(const Value *V, bool isL) {
   if (V->hasName()) {
     out << (isa<GlobalValue>(V) ? '@' : '%') << V->getName();
     return;
   }
   if (V->getType()->isVoidTy()) {
     if (auto *SI = dyn_cast<StoreInst>(V)) {
if (isa<Constant>(V)) {
     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 DiffConsumer::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";
 
       const Function *L = cast<Function>(I->L);
       const 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)) {
       const BasicBlock *L = cast<BasicBlock>(I->L);
       const BasicBlock *R = cast<BasicBlock>(I->R);
       if (L->hasName() && R->hasName() && L->getName() == R->getName())
         out << "  in block %" << L->getName() << ":\n";
for (SmallVectorImpl<DiffContext>::iterator
     }
 
     I->Differences = true;
   }
 }
 
 void DiffConsumer::indent() {
   unsigned N = Indent;
   while (N--) out << ' ';
 }
 
 bool DiffConsumer::hadDifferences() const {
   return Differences;
 }
 
 void DiffConsumer::enterContext(const Value *L, const Value *R) {
   contexts.push_back(DiffContext(L, R));
   Indent += 2;
 }
 
void DiffConsumer::logf(const LogBuilder &Log) {
   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 DiffConsumer::logd(const DiffLogBuilder &Log) {
   header();
 
   for (unsigned I = 0, E = Log.getNumLines(); I != E; ++I) {
     indent();
     switch (Log.getLineKind(I)) {
     case DC_match:
       out << "  ";
       Log.getLeft(I)->print(dbgs()); dbgs() << '\n';
       //printValue(Log.getLeft(I), true);
       break;
     case DC_left:
       out << "< ";
       Log.getLeft(I)->print(dbgs()); dbgs() << '\n';
       //printValue(Log.getLeft(I), true);
       break;
     case DC_right:
       out << "> ";
       Log.getRight(I)->print(dbgs()); dbgs() << '\n';
       //printValue(Log.getRight(I), false);
       break;
     }
     //out << "\n";
   }
 }

llvm/tools/llvm-diff/lib/DiffLog.h

 
 #ifndef LLVM_TOOLS_LLVM_DIFF_DIFFLOG_H
 #define LLVM_TOOLS_LLVM_DIFF_DIFFLOG_H
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 
 namespace llvm {
   class Instruction;
   class Value;
   class Consumer;
 
   /// Trichotomy assumption
   enum DiffChange { DC_match, DC_left, DC_right };
 
   /// A temporary-object class for building up log messages.
   class LogBuilder {

llvm/tools/llvm-diff/lib/DiffLog.cpp

 void DiffLogBuilder::addRight(const Instruction *R) {
   // HACK: VS 2010 has a bug in the stdlib that requires this.
   Diff.push_back(DiffRecord(DiffRecord::first_type(nullptr), R));
 }
 
 unsigned DiffLogBuilder::getNumLines() const { return Diff.size(); }
 
 DiffChange DiffLogBuilder::getLineKind(unsigned I) const {
   return (Diff[I].first ? (Diff[I].second ? DC_match : DC_left)
                         : DC_right);
 }
 const Instruction *DiffLogBuilder::getLeft(unsigned I) const {
   return Diff[I].first;
 }
 const Instruction *DiffLogBuilder::getRight(unsigned I) const {
   return Diff[I].second;
 }

llvm/tools/llvm-diff/lib/DifferenceEngine.h

 #define LLVM_TOOLS_LLVM_DIFF_DIFFERENCEENGINE_H
 
 #include "DiffConsumer.h"
 #include "DiffLog.h"
 #include "llvm/ADT/StringRef.h"
 #include <utility>
 
 namespace llvm {
   class Function;
   class GlobalValue;
   class Instruction;
   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, const Value *L, const 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.
     class Oracle {
       virtual void anchor();
     public:
       virtual bool operator()(const Value *L, const Value *R) = 0;
 
     protected:
       virtual ~Oracle() {}
     };
 
     DifferenceEngine(Consumer &consumer)
       : consumer(consumer), globalValueOracle(nullptr) {}
 
     void diff(const Module *L, const Module *R);
     void diff(const Function *L, const Function *R);
     void log(StringRef text) {
       consumer.log(text);
     }
     LogBuilder logf(StringRef text) {
       return LogBuilder(consumer, text);
     }
     Consumer& getConsumer() const { return consumer; }
 
     /// 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(const GlobalValue *L, const GlobalValue *R);
 
   private:
     Consumer &consumer;
     Oracle *globalValueOracle;
   };
 }
 
 #endif

llvm/tools/llvm-diff/lib/DifferenceEngine.cpp

 #include "llvm/Support/type_traits.h"
 #include <utility>
 
 using namespace llvm;
 
 namespace {
 
 /// A priority queue, implemented as a heap.
 template <class T, class Sorter, unsigned InlineCapacity>
 class PriorityQueue {
   Sorter Precedes;
   llvm::SmallVector<T, InlineCapacity> Storage;
 
 public:
   PriorityQueue(const Sorter &Precedes) : Precedes(Precedes) {}
 
   /// Checks whether the heap is empty.
   bool empty() const { return Storage.empty(); }
 
   /// Insert a new value on the heap.
   void insert(const T &V) {
     unsigned Index = Storage.size();
     Storage.push_back(V);
     if (Index == 0) return;
 
     T *data = Storage.data();
     while (true) {
       unsigned Target = (Index + 1) / 2 - 1;
       if (!Precedes(data[Index], data[Target])) return;
       std::swap(data[Index], data[Target]);
       if (Target == 0) return;
       Index = Target;
     }
   }
 
   /// Remove the minimum value in the heap.  Only valid on a non-empty heap.
   T remove_min() {
     assert(!empty());
     T tmp = Storage[0];
     
     unsigned NewSize = Storage.size() - 1;
     if (NewSize) {
       // Move the slot at the end to the beginning.
       if (std::is_trivially_copyable<T>::value)
         Storage[0] = Storage[NewSize];
       else
         std::swap(Storage[0], Storage[NewSize]);
 
       // Bubble the root up as necessary.
       unsigned Index = 0;
       while (true) {
         // With a 1-based index, the children would be Index*2 and Index*2+1.
         unsigned R = (Index + 1) * 2;
         unsigned L = R - 1;
 
         // If R is out of bounds, we're done after this in any case.
         if (R >= NewSize) {
           // If L is also out of bounds, we're done immediately.
           if (L >= NewSize) break;
 
           // Otherwise, test whether we should swap L and Index.
           if (Precedes(Storage[L], Storage[Index]))
             std::swap(Storage[L], Storage[Index]);
           break;
         }
 
         // Otherwise, we need to compare with the smaller of L and R.
class FunctionDifferenceEngine {
   DenseMap<const BasicBlock *, const BasicBlock *> Blocks;
 
   DenseSet<std::pair<const Value *, const Value *>> TentativeValues;
 
   unsigned getUnprocPredCount(const BasicBlock *Block) const {
     unsigned Count = 0;
     for (const_pred_iterator I = pred_begin(Block), E = pred_end(Block); I != E;
          ++I)
       if (!Blocks.count(*I)) Count++;
     return Count;
   }
 
   typedef std::pair<const BasicBlock *, const BasicBlock *> BlockPair;
 
   /// A type which sorts a priority queue by the number of unprocessed
   /// predecessor blocks it has remaining.
   ///
   /// This is actually really expensive to calculate.
   struct QueueSorter {
     const FunctionDifferenceEngine &fde;
     explicit QueueSorter(const FunctionDifferenceEngine &fde) : fde(fde) {}
 
     bool operator()(BlockPair &Old, BlockPair &New) {
       return fde.getUnprocPredCount(Old.first)
            < fde.getUnprocPredCount(New.first);
     }
   };
 
   /// A queue of unified blocks to process.
   PriorityQueue<BlockPair, QueueSorter, 20> Queue;
 
   /// Try to unify the given two blocks.  Enqueues them for processing
   /// if they haven't already been processed.
   ///
   /// Returns true if there was a problem unifying them.
   bool tryUnify(const BasicBlock *L, const BasicBlock *R) {
     const BasicBlock *&Ref = Blocks[L];
 
     if (Ref) {
       if (Ref == R) return false;
 
       Engine.logf("successor %l cannot be equivalent to %r; "
                   "it's already equivalent to %r")
         << L << R << Ref;
       return true;
     }
 
     Ref = R;
     Queue.insert(BlockPair(L, R));
     return false;
   }
 
   /// Unifies two instructions, given that they're known not to have
   /// structural differences.
   void unify(const Instruction *L, const Instruction *R) {
     DifferenceEngine::Context C(Engine, L, R);
 
     bool Result = diff(L, R, true, true);
     assert(!Result && "structural differences second time around?");
     (void) Result;
     if (!L->use_empty())
       Values[L] = R;
   }
 
   void processQueue() {
     while (!Queue.empty()) {
       BlockPair Pair = Queue.remove_min();
       diff(Pair.first, Pair.second);
class FunctionDifferenceEngine {
 
   bool matchForBlockDiff(const Instruction *L, const Instruction *R);
   void runBlockDiff(BasicBlock::const_iterator LI,
                     BasicBlock::const_iterator RI);
 
   bool diffCallSites(const CallBase &L, const CallBase &R, bool Complain) {
     // FIXME: call attributes
     if (!equivalentAsOperands(L.getCalledOperand(), R.getCalledOperand())) {
       if (Complain) Engine.log("called functions differ");
       return true;
     }
     if (L.arg_size() != R.arg_size()) {
       if (Complain) Engine.log("argument counts differ");
       return true;
     }
     for (unsigned I = 0, E = L.arg_size(); I != E; ++I)
       if (!equivalentAsOperands(L.getArgOperand(I), R.getArgOperand(I))) {
         if (Complain)
           Engine.logf("arguments %l and %r differ")
               << L.getArgOperand(I) << R.getArgOperand(I);
         return true;
       }
     return false;
   }
 
   bool diff(const Instruction *L, const Instruction *R, bool Complain,
             bool TryUnify) {
     // FIXME: metadata (if Complain is set)
 
     // Different opcodes always imply different operations.
     if (L->getOpcode() != R->getOpcode()) {
       if (Complain) Engine.log("different instruction types");
       return true;
     }
 
     if (isa<CmpInst>(L)) {
       if (cast<CmpInst>(L)->getPredicate()
             != cast<CmpInst>(R)->getPredicate()) {
         if (Complain) Engine.log("different predicates");
         return true;
       }
     } else if (isa<CallInst>(L)) {
       return diffCallSites(cast<CallInst>(*L), cast<CallInst>(*R), Complain);
     } else if (isa<PHINode>(L)) {
       // FIXME: implement.
 
       // This is really weird;  type uniquing is broken?
       if (L->getType() != R->getType()) {
         if (!L->getType()->isPointerTy() || !R->getType()->isPointerTy()) {
           if (Complain) Engine.log("different phi types");
           return true;
         }
       }
       return false;
 
     // Terminators.
     } else if (isa<InvokeInst>(L)) {
       const InvokeInst &LI = cast<InvokeInst>(*L);
       const InvokeInst &RI = cast<InvokeInst>(*R);
       if (diffCallSites(LI, RI, Complain))
         return true;
 
       if (TryUnify) {
         tryUnify(LI.getNormalDest(), RI.getNormalDest());
// Terminators.
       if (TryUnify)
         tryUnify(LI.getDefaultDest(), RI.getDefaultDest());
       return false;
 
     } else if (isa<BranchInst>(L)) {
       const BranchInst *LI = cast<BranchInst>(L);
       const BranchInst *RI = cast<BranchInst>(R);
       if (LI->isConditional() != RI->isConditional()) {
         if (Complain) Engine.log("branch conditionality differs");
         return true;
       }
 
       if (LI->isConditional()) {
         if (!equivalentAsOperands(LI->getCondition(), RI->getCondition())) {
           if (Complain) Engine.log("branch conditions differ");
           return true;
         }
         if (TryUnify) tryUnify(LI->getSuccessor(1), RI->getSuccessor(1));
       }
       if (TryUnify) tryUnify(LI->getSuccessor(0), RI->getSuccessor(0));
       return false;
 
     } else if (isa<IndirectBrInst>(L)) {
       const IndirectBrInst *LI = cast<IndirectBrInst>(L);
       const IndirectBrInst *RI = cast<IndirectBrInst>(R);
       if (LI->getNumDestinations() != RI->getNumDestinations()) {
         if (Complain) Engine.log("indirectbr # of destinations differ");
         return true;
       }
 
       if (!equivalentAsOperands(LI->getAddress(), RI->getAddress())) {
         if (Complain) Engine.log("indirectbr addresses differ");
         return true;
       }
 
       if (TryUnify) {
         for (unsigned i = 0; i < LI->getNumDestinations(); i++) {
           tryUnify(LI->getDestination(i), RI->getDestination(i));
         }
       }
       return false;
 
     } else if (isa<SwitchInst>(L)) {
       const SwitchInst *LI = cast<SwitchInst>(L);
       const SwitchInst *RI = cast<SwitchInst>(R);
       if (!equivalentAsOperands(LI->getCondition(), RI->getCondition())) {
         if (Complain) Engine.log("switch conditions differ");
         return true;
       }
       if (TryUnify) tryUnify(LI->getDefaultDest(), RI->getDefaultDest());
 
       bool Difference = false;
 
       DenseMap<const ConstantInt *, const BasicBlock *> LCases;
       for (auto Case : LI->cases())
         LCases[Case.getCaseValue()] = Case.getCaseSuccessor();
 
       for (auto Case : RI->cases()) {
// Terminators.
           Difference = true;
         }
       return Difference;
     } else if (isa<UnreachableInst>(L)) {
       return false;
     }
 
     if (L->getNumOperands() != R->getNumOperands()) {
       if (Complain) Engine.log("instructions have different operand counts");
       return true;
     }
 
     for (unsigned I = 0, E = L->getNumOperands(); I != E; ++I) {
       Value *LO = L->getOperand(I), *RO = R->getOperand(I);
       if (!equivalentAsOperands(LO, RO)) {
         if (Complain) Engine.logf("operands %l and %r differ") << LO << RO;
         return true;
       }
     }
 
     return false;
   }
 
 public:
   bool equivalentAsOperands(const Constant *L, const Constant *R) {
     // Use equality as a preliminary filter.
     if (L == R)
       return true;
 
     if (L->getValueID() != R->getValueID())
       return false;
 
     // Ask the engine about global values.
     if (isa<GlobalValue>(L))
       return Engine.equivalentAsOperands(cast<GlobalValue>(L),
                                          cast<GlobalValue>(R));
 
     // Compare constant expressions structurally.
     if (isa<ConstantExpr>(L))
       return equivalentAsOperands(cast<ConstantExpr>(L),
                                   cast<ConstantExpr>(R));
 
     // Constants of the "same type" don't always actually have the same
     // type; I don't know why.  Just white-list them.
     if (isa<ConstantPointerNull>(L) || isa<UndefValue>(L) || isa<ConstantAggregateZero>(L))
       return true;
 
     // Block addresses only match if we've already encountered the
     // block.  FIXME: tentative matches?
     if (isa<BlockAddress>(L))
       return Blocks[cast<BlockAddress>(L)->getBasicBlock()]
                  == cast<BlockAddress>(R)->getBasicBlock();
 
     // If L and R are ConstantVectors, compare each element
     if (isa<ConstantVector>(L)) {
       const ConstantVector *CVL = cast<ConstantVector>(L);
       const ConstantVector *CVR = cast<ConstantVector>(R);
       if (CVL->getType()->getNumElements() != CVR->getType()->getNumElements())
         return false;

 
 void FunctionDifferenceEngine::runBlockDiff(BasicBlock::const_iterator LStart,
                                             BasicBlock::const_iterator RStart) {
   BasicBlock::const_iterator LE = LStart->getParent()->end();
   BasicBlock::const_iterator RE = RStart->getParent()->end();
 
   unsigned NL = std::distance(LStart, LE);
 
   SmallVector<DiffEntry, 20> Paths1(NL+1);
   SmallVector<DiffEntry, 20> Paths2(NL+1);
 
   DiffEntry *Cur = Paths1.data();
   DiffEntry *Next = Paths2.data();
 
   const unsigned LeftCost = 2;
   const unsigned RightCost = 2;
   const unsigned MatchCost = 0;
 
   assert(TentativeValues.empty());
 
   // Initialize the first column.
   for (unsigned I = 0; I != NL+1; ++I) {
     Cur[I].Cost = I * LeftCost;
     for (unsigned J = 0; J != I; ++J)
       Cur[I].Path.push_back(DC_left);
   }
 
   for (BasicBlock::const_iterator RI = RStart; RI != RE; ++RI) {
     // Initialize the first row.
     Next[0] = Cur[0];
     Next[0].Cost += RightCost;
     Next[0].Path.push_back(DC_right);
 
     unsigned Index = 1;
     for (BasicBlock::const_iterator LI = LStart; LI != LE; ++LI, ++Index) {
       if (matchForBlockDiff(&*LI, &*RI)) {
         Next[Index] = Cur[Index-1];
         Next[Index].Cost += MatchCost;
         Next[Index].Path.push_back(DC_match);
         TentativeValues.insert(std::make_pair(&*LI, &*RI));
       } else if (Next[Index-1].Cost <= Cur[Index].Cost) {
         Next[Index] = Next[Index-1];
         Next[Index].Cost += LeftCost;
         Next[Index].Path.push_back(DC_left);
       } else {
         Next[Index] = Cur[Index];
         Next[Index].Cost += RightCost;
         Next[Index].Path.push_back(DC_right);
       }
void FunctionDifferenceEngine::runBlockDiff(BasicBlock::const_iterator LStart,
 
   DiffLogBuilder Diff(Engine.getConsumer());
 
   // Drop trailing matches.
   while (Path.size() && Path.back() == DC_match)
     Path.pop_back();
 
   // Skip leading matches.
   SmallVectorImpl<char>::iterator
     PI = Path.begin(), PE = Path.end();
   while (PI != PE && *PI == DC_match) {
     unify(&*LI, &*RI);
     ++PI;
     ++LI;
     ++RI;
   }
 
   for (; PI != PE; ++PI) {
     switch (static_cast<DiffChange>(*PI)) {
     case DC_match:
       assert(LI != LE && RI != RE);
       {
         const Instruction *L = &*LI, *R = &*RI;
         unify(L, R);
         Diff.addMatch(L, R);
       }
       ++LI; ++RI;
       break;
 
     case DC_left:
       assert(LI != LE);
       Diff.addLeft(&*LI);
       ++LI;
       break;
 
void FunctionDifferenceEngine::runBlockDiff(BasicBlock::const_iterator LStart,
   }
 
   // If the terminators have different kinds, but one is an invoke and the
   // other is an unconditional branch immediately following a call, unify
   // the results and the destinations.
   const Instruction *LTerm = LStart->getParent()->getTerminator();
   const Instruction *RTerm = RStart->getParent()->getTerminator();
   if (isa<BranchInst>(LTerm) && isa<InvokeInst>(RTerm)) {
     if (cast<BranchInst>(LTerm)->isConditional()) return;
     BasicBlock::const_iterator I = LTerm->getIterator();
     if (I == LStart->getParent()->begin()) return;
     --I;
     if (!isa<CallInst>(*I)) return;
     const CallInst *LCall = cast<CallInst>(&*I);
     const InvokeInst *RInvoke = cast<InvokeInst>(RTerm);
     if (!equivalentAsOperands(LCall->getCalledOperand(),
                               RInvoke->getCalledOperand()))
       return;
     if (!LCall->use_empty())
       Values[LCall] = RInvoke;
     tryUnify(LTerm->getSuccessor(0), RInvoke->getNormalDest());
   } else if (isa<InvokeInst>(LTerm) && isa<BranchInst>(RTerm)) {
     if (cast<BranchInst>(RTerm)->isConditional()) return;
     BasicBlock::const_iterator I = RTerm->getIterator();
     if (I == RStart->getParent()->begin()) return;
     --I;
     if (!isa<CallInst>(*I)) return;
     const CallInst *RCall = cast<CallInst>(I);
     const InvokeInst *LInvoke = cast<InvokeInst>(LTerm);
     if (!equivalentAsOperands(LInvoke->getCalledOperand(),
                               RCall->getCalledOperand()))
       return;
     if (!LInvoke->use_empty())
       Values[LInvoke] = RCall;
     tryUnify(LInvoke->getNormalDest(), RTerm->getSuccessor(0));
   }
 }
 }
 
 void DifferenceEngine::Oracle::anchor() { }
 
 void DifferenceEngine::diff(const Function *L, const Function *R) {
   Context C(*this, L, R);
 
   // FIXME: types
   // FIXME: attributes and CC
   // FIXME: parameter attributes
   
   // If both are declarations, we're done.
   if (L->empty() && R->empty())
     return;
   else if (L->empty())
     log("left function is declaration, right function is definition");
   else if (R->empty())
     log("right function is declaration, left function is definition");
   else
for (SmallVectorImpl<std::pair<const Function *, const Function *>>::iterator
            I = Queue.begin(),
            E = Queue.end();
        I != E; ++I)
     diff(I->first, I->second);
 }
 
 bool DifferenceEngine::equivalentAsOperands(const GlobalValue *L,
                                             const GlobalValue *R) {
   if (globalValueOracle) return (*globalValueOracle)(L, R);
 
   if (isa<GlobalVariable>(L) && isa<GlobalVariable>(R)) {
     const GlobalVariable *GVL = cast<GlobalVariable>(L);
     const GlobalVariable *GVR = cast<GlobalVariable>(R);
     if (GVL->hasLocalLinkage() && GVL->hasUniqueInitializer() &&
         GVR->hasLocalLinkage() && GVR->hasUniqueInitializer())
       return FunctionDifferenceEngine(*this, GVL, GVR)
           .equivalentAsOperands(GVL->getInitializer(), GVR->getInitializer());
   }
 
   return L->getName() == R->getName();
 }

llvm/tools/llvm-diff/llvm-diff.cpp

 //===-- llvm-diff.cpp - Module comparator command-line driver ---*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines the command-line driver for the difference engine.
 //
 //===----------------------------------------------------------------------===//
 
-#include "DiffLog.h"
-#include "DifferenceEngine.h"
+#include "lib/DiffLog.h"
+#include "lib/DifferenceEngine.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Type.h"
 #include "llvm/IRReader/IRReader.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/SourceMgr.h"

llvm/tools/llvm-livepatch/CMakeLists.txt

+set(LLVM_LINK_COMPONENTS
+  Core
+  IRReader
+  Support
+  )
+
+add_llvm_tool(llvm-livepatch
+  llvm-livepatch.cpp
+
+  DEPENDS
+  intrinsics_gen
+  )