[llvm-diff] Constify APIs so that there aren't conflicts

[void]

Summary

Some APIs work with const variables while others don't. This can cause
conflicts when calling one from the other.

This is NFC.

llvm/tools/llvm-diff/DiffConsumer.h

class StringRef;
   /// The interface for consumers of difference data.
   class Consumer {
     virtual void anchor();
   public:
     /// Record that a local context has been entered.  Left and
     /// Right are IR "containers" of some sort which are being
     /// considered for structural equivalence: global variables,
     /// functions, blocks, instructions, etc.
-    virtual void enterContext(Value *Left, Value *Right) = 0;
+    virtual void enterContext(const Value *Left, const Value *Right) = 0;
 
     /// Record that a local context has been exited.
     virtual void exitContext() = 0;
 
     /// Record a difference within the current context.
     virtual void log(StringRef Text) = 0;
 
     /// Record a formatted difference within the current context.
     virtual void logf(const LogBuilder &Log) = 0;
 
     /// 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(Value *L, Value *R)
+      DiffContext(const Value *L, const Value *R)
           : L(L), R(R), Differences(false), IsFunction(isa<Function>(L)) {}
-      Value *L;
-      Value *R;
+      const Value *L;
+      const Value *R;
       bool Differences;
       bool IsFunction;
-      DenseMap<Value*,unsigned> LNumbering;
-      DenseMap<Value*,unsigned> RNumbering;
+      DenseMap<const Value *, unsigned> LNumbering;
+      DenseMap<const Value *, unsigned> RNumbering;
     };
 
     raw_ostream &out;
     SmallVector<DiffContext, 5> contexts;
     bool Differences;
     unsigned Indent;
 
-    void printValue(Value *V, bool isL);
+    void printValue(const Value *V, bool isL);
     void header();
     void indent();
 
   public:
     DiffConsumer()
       : out(errs()), Differences(false), Indent(0) {}
 
     bool hadDifferences() const;
-    void enterContext(Value *L, Value *R) override;
+    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/DiffConsumer.cpp

 
 #include "DiffConsumer.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/ErrorHandling.h"
 
 using namespace llvm;
 
-static void ComputeNumbering(Function *F, DenseMap<Value*,unsigned> &Numbering){
+static void ComputeNumbering(const Function *F,
+                             DenseMap<const 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++;
+  for (const auto &Arg : F->args())
+    if (!Arg.hasName())
+      Numbering[&Arg] = 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++;
+  for (const auto &Func : *F) {
+    if (!Func.hasName())
+      Numbering[&Func] = IN++;
 
     // Walk the instructions in order.
-    for (BasicBlock::iterator BI = FI->begin(), BE = FI->end(); BI != BE; ++BI)
+    for (const auto &BB : Func)
       // void instructions don't get numbers.
-      if (!BI->hasName() && !BI->getType()->isVoidTy())
-        Numbering[&*BI] = IN++;
+      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(Value *V, bool isL) {
+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)) {
       out << "store to ";
       printValue(SI->getPointerOperand(), isL);
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";
 
-      Function *L = cast<Function>(I->L);
-      Function *R = cast<Function>(I->R);
+      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)) {
-      BasicBlock *L = cast<BasicBlock>(I->L);
-      BasicBlock *R = cast<BasicBlock>(I->R);
+      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";
       else {
         out << "  in block ";
         printValue(L, true);
         out << " / ";
         printValue(R, false);
         out << ":\n";
void DiffConsumer::indent() {
   unsigned N = Indent;
   while (N--) out << ' ';
 }
 
 bool DiffConsumer::hadDifferences() const {
   return Differences;
 }
 
-void DiffConsumer::enterContext(Value *L, Value *R) {
+void DiffConsumer::enterContext(const Value *L, const Value *R) {
   contexts.push_back(DiffContext(L, R));
   Indent += 2;
 }
 
 void DiffConsumer::exitContext() {
   Differences |= contexts.back().Differences;
   contexts.pop_back();
   Indent -= 2;

llvm/tools/llvm-diff/DiffLog.h

class LogBuilder {
     Consumer *consumer;
 
     /// The use of a stored StringRef here is okay because
     /// LogBuilder should be used only as a temporary, and as a
     /// temporary it will be destructed before whatever temporary
     /// might be initializing this format.
     StringRef Format;
 
-    SmallVector<Value*, 4> Arguments;
+    SmallVector<const Value *, 4> Arguments;
 
   public:
     LogBuilder(Consumer &c, StringRef Format) : consumer(&c), Format(Format) {}
     LogBuilder(LogBuilder &&L)
         : consumer(L.consumer), Format(L.Format),
           Arguments(std::move(L.Arguments)) {
       L.consumer = nullptr;
     }
 
-    LogBuilder &operator<<(Value *V) {
+    LogBuilder &operator<<(const Value *V) {
       Arguments.push_back(V);
       return *this;
     }
 
     ~LogBuilder();
 
     StringRef getFormat() const;
     unsigned getNumArguments() const;
-    Value *getArgument(unsigned I) const;
+    const Value *getArgument(unsigned I) const;
   };
 
   /// A temporary-object class for building up diff messages.
   class DiffLogBuilder {
-    typedef std::pair<Instruction*,Instruction*> DiffRecord;
+    typedef std::pair<const Instruction *, const Instruction *> DiffRecord;
     SmallVector<DiffRecord, 20> Diff;
 
     Consumer &consumer;
 
   public:
     DiffLogBuilder(Consumer &c) : consumer(c) {}
     ~DiffLogBuilder();
 
-    void addMatch(Instruction *L, Instruction *R);
+    void addMatch(const Instruction *L, const Instruction *R);
     // HACK: VS 2010 has a bug in the stdlib that requires this.
-    void addLeft(Instruction *L);
-    void addRight(Instruction *R);
+    void addLeft(const Instruction *L);
+    void addRight(const Instruction *R);
 
     unsigned getNumLines() const;
     DiffChange getLineKind(unsigned I) const;
-    Instruction *getLeft(unsigned I) const;
-    Instruction *getRight(unsigned I) const;
+    const Instruction *getLeft(unsigned I) const;
+    const Instruction *getRight(unsigned I) const;
   };
 
 }
 
 #endif

llvm/tools/llvm-diff/DiffLog.cpp

 LogBuilder::~LogBuilder() {
   if (consumer)
     consumer->logf(*this);
 }
 
 StringRef LogBuilder::getFormat() const { return Format; }
 
 unsigned LogBuilder::getNumArguments() const { return Arguments.size(); }
-Value *LogBuilder::getArgument(unsigned I) const { return Arguments[I]; }
+const Value *LogBuilder::getArgument(unsigned I) const { return Arguments[I]; }
 
 DiffLogBuilder::~DiffLogBuilder() { consumer.logd(*this); }
 
-void DiffLogBuilder::addMatch(Instruction *L, Instruction *R) {
+void DiffLogBuilder::addMatch(const Instruction *L, const Instruction *R) {
   Diff.push_back(DiffRecord(L, R));
 }
-void DiffLogBuilder::addLeft(Instruction *L) {
+void DiffLogBuilder::addLeft(const Instruction *L) {
   // HACK: VS 2010 has a bug in the stdlib that requires this.
   Diff.push_back(DiffRecord(L, DiffRecord::second_type(nullptr)));
 }
-void DiffLogBuilder::addRight(Instruction *R) {
+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);
 }
-Instruction *DiffLogBuilder::getLeft(unsigned I) const { return Diff[I].first; }
-Instruction *DiffLogBuilder::getRight(unsigned I) const { return Diff[I].second; }
+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/DifferenceEngine.h

namespace llvm {
   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) {
+      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()(Value *L, Value *R) = 0;
+      virtual bool operator()(const Value *L, const Value *R) = 0;
 
     protected:
       virtual ~Oracle() {}
     };
 
     DifferenceEngine(Consumer &consumer)
       : consumer(consumer), globalValueOracle(nullptr) {}
 
-    void diff(Module *L, Module *R);
-    void diff(Function *L, Function *R);
+    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(GlobalValue *L, GlobalValue *R);
+    bool equivalentAsOperands(const GlobalValue *L, const GlobalValue *R);
 
   private:
     Consumer &consumer;
     Oracle *globalValueOracle;
   };
 }
 
 #endif

llvm/tools/llvm-diff/DifferenceEngine.cpp

public:
   }
 };
 
 /// A function-scope difference engine.
 class FunctionDifferenceEngine {
   DifferenceEngine &Engine;
 
   /// The current mapping from old local values to new local values.
-  DenseMap<Value*, Value*> Values;
+  DenseMap<const Value *, const Value *> Values;
 
   /// The current mapping from old blocks to new blocks.
-  DenseMap<BasicBlock*, BasicBlock*> Blocks;
+  DenseMap<const BasicBlock *, const BasicBlock *> Blocks;
 
-  DenseSet<std::pair<Value*, Value*> > TentativeValues;
+  DenseSet<std::pair<const Value *, const Value *>> TentativeValues;
 
-  unsigned getUnprocPredCount(BasicBlock *Block) const {
+  unsigned getUnprocPredCount(const BasicBlock *Block) const {
     unsigned Count = 0;
-    for (pred_iterator I = pred_begin(Block), E = pred_end(Block); I != E; ++I)
+    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<BasicBlock*, BasicBlock*> BlockPair;
+  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()(const BlockPair &Old, const BlockPair &New) {
+    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(BasicBlock *L, BasicBlock *R) {
-    BasicBlock *&Ref = Blocks[L];
+  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(Instruction *L, Instruction *R) {
+  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);
     }
   }
 
-  void diff(BasicBlock *L, BasicBlock *R) {
+  void diff(const BasicBlock *L, const BasicBlock *R) {
     DifferenceEngine::Context C(Engine, L, R);
 
-    BasicBlock::iterator LI = L->begin(), LE = L->end();
-    BasicBlock::iterator RI = R->begin();
+    BasicBlock::const_iterator LI = L->begin(), LE = L->end();
+    BasicBlock::const_iterator RI = R->begin();
 
     do {
       assert(LI != LE && RI != R->end());
-      Instruction *LeftI = &*LI, *RightI = &*RI;
+      const Instruction *LeftI = &*LI, *RightI = &*RI;
 
       // If the instructions differ, start the more sophisticated diff
       // algorithm at the start of the block.
       if (diff(LeftI, RightI, false, false)) {
         TentativeValues.clear();
         return runBlockDiff(L->begin(), R->begin());
       }
 
       // Otherwise, tentatively unify them.
       if (!LeftI->use_empty())
         TentativeValues.insert(std::make_pair(LeftI, RightI));
 
       ++LI;
       ++RI;
     } while (LI != LE); // This is sufficient: we can't get equality of
                         // terminators if there are residual instructions.
 
     // Unify everything in the block, non-tentatively this time.
     TentativeValues.clear();
     for (LI = L->begin(), RI = R->begin(); LI != LE; ++LI, ++RI)
       unify(&*LI, &*RI);
   }
 
-  bool matchForBlockDiff(Instruction *L, Instruction *R);
-  void runBlockDiff(BasicBlock::iterator LI, BasicBlock::iterator RI);
+  bool matchForBlockDiff(const Instruction *L, const Instruction *R);
+  void runBlockDiff(BasicBlock::const_iterator LI,
+                    BasicBlock::const_iterator RI);
 
-  bool diffCallSites(CallBase &L, CallBase &R, bool Complain) {
+  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(Instruction *L, Instruction *R, bool Complain, bool TryUnify) {
+  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 (Complain) Engine.log("different phi types");
           return true;
         }
       }
       return false;
 
     // Terminators.
     } else if (isa<InvokeInst>(L)) {
-      InvokeInst &LI = cast<InvokeInst>(*L);
-      InvokeInst &RI = cast<InvokeInst>(*R);
+      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());
         tryUnify(LI.getUnwindDest(), RI.getUnwindDest());
       }
       return false;
 
     } else if (isa<BranchInst>(L)) {
-      BranchInst *LI = cast<BranchInst>(L);
-      BranchInst *RI = cast<BranchInst>(R);
+      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)) {
-      IndirectBrInst *LI = cast<IndirectBrInst>(L);
-      IndirectBrInst *RI = cast<IndirectBrInst>(R);
+      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)) {
-      SwitchInst *LI = cast<SwitchInst>(L);
-      SwitchInst *RI = cast<SwitchInst>(R);
+      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<ConstantInt*,BasicBlock*> LCases;
+      DenseMap<const ConstantInt *, const BasicBlock *> LCases;
       for (auto Case : LI->cases())
         LCases[Case.getCaseValue()] = Case.getCaseSuccessor();
 
       for (auto Case : RI->cases()) {
-        ConstantInt *CaseValue = Case.getCaseValue();
-        BasicBlock *LCase = LCases[CaseValue];
+        const ConstantInt *CaseValue = Case.getCaseValue();
+        const BasicBlock *LCase = LCases[CaseValue];
         if (LCase) {
           if (TryUnify)
             tryUnify(LCase, Case.getCaseSuccessor());
           LCases.erase(CaseValue);
         } else if (Complain || !Difference) {
           if (Complain)
             Engine.logf("right switch has extra case %r") << CaseValue;
           Difference = true;
         }
       }
       if (!Difference)
-        for (DenseMap<ConstantInt*,BasicBlock*>::iterator
-               I = LCases.begin(), E = LCases.end(); I != E; ++I) {
+        for (DenseMap<const ConstantInt *, const BasicBlock *>::iterator
+                 I = LCases.begin(),
+                 E = LCases.end();
+             I != E; ++I) {
           if (Complain)
             Engine.logf("left switch has extra case %l") << I->first;
           Difference = true;
         }
       return Difference;
     } else if (isa<UnreachableInst>(L)) {
       return false;
     }
for (unsigned I = 0, E = L->getNumOperands(); I != E; ++I) {
         if (Complain) Engine.logf("operands %l and %r differ") << LO << RO;
         return true;
       }
     }
 
     return false;
   }
 
-  bool equivalentAsOperands(Constant *L, Constant *R) {
+  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.
bool equivalentAsOperands(const Constant *L, const Constant *R) {
     // 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)) {
-      ConstantVector *CVL = cast<ConstantVector>(L);
-      ConstantVector *CVR = cast<ConstantVector>(R);
+      const ConstantVector *CVL = cast<ConstantVector>(L);
+      const ConstantVector *CVR = cast<ConstantVector>(R);
       if (CVL->getType()->getNumElements() != CVR->getType()->getNumElements())
         return false;
       for (unsigned i = 0; i < CVL->getType()->getNumElements(); i++) {
         if (!equivalentAsOperands(CVL->getOperand(i), CVR->getOperand(i)))
           return false;
       }
       return true;
     }
 
     return false;
   }
 
-  bool equivalentAsOperands(ConstantExpr *L, ConstantExpr *R) {
+  bool equivalentAsOperands(const ConstantExpr *L, const ConstantExpr *R) {
     if (L == R)
       return true;
     if (L->getOpcode() != R->getOpcode())
       return false;
 
     switch (L->getOpcode()) {
     case Instruction::ICmp:
     case Instruction::FCmp:
bool equivalentAsOperands(const ConstantExpr *L, const ConstantExpr *R) {
 
     for (unsigned I = 0, E = L->getNumOperands(); I != E; ++I)
       if (!equivalentAsOperands(L->getOperand(I), R->getOperand(I)))
         return false;
 
     return true;
   }
 
-  bool equivalentAsOperands(Value *L, Value *R) {
+  bool equivalentAsOperands(const Value *L, const Value *R) {
     // Fall out if the values have different kind.
     // This possibly shouldn't take priority over oracles.
     if (L->getValueID() != R->getValueID())
       return false;
 
     // Value subtypes:  Argument, Constant, Instruction, BasicBlock,
     //                  InlineAsm, MDNode, MDString, PseudoSourceValue
 
class FunctionDifferenceEngine {
 
   // Avoid a gcc warning about accessing 'this' in an initializer.
   FunctionDifferenceEngine *this_() { return this; }
 
 public:
   FunctionDifferenceEngine(DifferenceEngine &Engine) :
     Engine(Engine), Queue(QueueSorter(*this_())) {}
 
-  void diff(Function *L, Function *R) {
+  void diff(const Function *L, const Function *R) {
     if (L->arg_size() != R->arg_size())
       Engine.log("different argument counts");
 
     // Map the arguments.
-    for (Function::arg_iterator
-           LI = L->arg_begin(), LE = L->arg_end(),
+    for (Function::const_arg_iterator LI = L->arg_begin(), LE = L->arg_end(),
                                       RI = R->arg_begin(), RE = R->arg_end();
          LI != LE && RI != RE; ++LI, ++RI)
       Values[&*LI] = &*RI;
 
     tryUnify(&*L->begin(), &*R->begin());
     processQueue();
   }
 };
 
 struct DiffEntry {
   DiffEntry() : Cost(0) {}
 
   unsigned Cost;
   llvm::SmallVector<char, 8> Path; // actually of DifferenceEngine::DiffChange
 };
 
-bool FunctionDifferenceEngine::matchForBlockDiff(Instruction *L,
-                                                 Instruction *R) {
+bool FunctionDifferenceEngine::matchForBlockDiff(const Instruction *L,
+                                                 const Instruction *R) {
   return !diff(L, R, false, false);
 }
 
-void FunctionDifferenceEngine::runBlockDiff(BasicBlock::iterator LStart,
-                                            BasicBlock::iterator RStart) {
-  BasicBlock::iterator LE = LStart->getParent()->end();
-  BasicBlock::iterator RE = RStart->getParent()->end();
+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::iterator RI = RStart; RI != RE; ++RI) {
+  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::iterator LI = LStart; LI != LE; ++LI, ++Index) {
+    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);
       }
     }
 
     std::swap(Cur, Next);
   }
 
   // We don't need the tentative values anymore; everything from here
   // on out should be non-tentative.
   TentativeValues.clear();
 
   SmallVectorImpl<char> &Path = Cur[NL].Path;
-  BasicBlock::iterator LI = LStart, RI = RStart;
+  BasicBlock::const_iterator LI = LStart, RI = RStart;
 
   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);
       {
-        Instruction *L = &*LI, *R = &*RI;
+        const Instruction *L = &*LI, *R = &*RI;
         unify(L, R);
         Diff.addMatch(L, R);
       }
       ++LI; ++RI;
       break;
 
     case DC_left:
       assert(LI != LE);
while (LI != LE) {
     unify(&*LI, &*RI);
     ++LI;
     ++RI;
   }
 
   // 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.
-  Instruction *LTerm = LStart->getParent()->getTerminator();
-  Instruction *RTerm = RStart->getParent()->getTerminator();
+  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::iterator I = LTerm->getIterator();
+    BasicBlock::const_iterator I = LTerm->getIterator();
     if (I == LStart->getParent()->begin()) return;
     --I;
     if (!isa<CallInst>(*I)) return;
-    CallInst *LCall = cast<CallInst>(&*I);
-    InvokeInst *RInvoke = cast<InvokeInst>(RTerm);
+    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::iterator I = RTerm->getIterator();
+    BasicBlock::const_iterator I = RTerm->getIterator();
     if (I == RStart->getParent()->begin()) return;
     --I;
     if (!isa<CallInst>(*I)) return;
-    CallInst *RCall = cast<CallInst>(I);
-    InvokeInst *LInvoke = cast<InvokeInst>(LTerm);
+    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(Function *L, Function *R) {
+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
     FunctionDifferenceEngine(*this).diff(L, R);
 }
 
-void DifferenceEngine::diff(Module *L, Module *R) {
+void DifferenceEngine::diff(const Module *L, const Module *R) {
   StringSet<> LNames;
-  SmallVector<std::pair<Function*,Function*>, 20> Queue;
+  SmallVector<std::pair<const Function *, const Function *>, 20> Queue;
 
   unsigned LeftAnonCount = 0;
   unsigned RightAnonCount = 0;
 
-  for (Module::iterator I = L->begin(), E = L->end(); I != E; ++I) {
-    Function *LFn = &*I;
+  for (Module::const_iterator I = L->begin(), E = L->end(); I != E; ++I) {
+    const Function *LFn = &*I;
     StringRef Name = LFn->getName();
     if (Name.empty()) {
       ++LeftAnonCount;
       continue;
     }
 
     LNames.insert(Name);
 
     if (Function *RFn = R->getFunction(LFn->getName()))
       Queue.push_back(std::make_pair(LFn, RFn));
     else
       logf("function %l exists only in left module") << LFn;
   }
 
-  for (Module::iterator I = R->begin(), E = R->end(); I != E; ++I) {
-    Function *RFn = &*I;
+  for (Module::const_iterator I = R->begin(), E = R->end(); I != E; ++I) {
+    const Function *RFn = &*I;
     StringRef Name = RFn->getName();
     if (Name.empty()) {
       ++RightAnonCount;
       continue;
     }
 
     if (!LNames.count(Name))
       logf("function %r exists only in right module") << RFn;
   }
 
-
   if (LeftAnonCount != 0 || RightAnonCount != 0) {
     SmallString<32> Tmp;
     logf(("not comparing " + Twine(LeftAnonCount) +
           " anonymous functions in the left module and " +
           Twine(RightAnonCount) + " in the right module")
              .toStringRef(Tmp));
   }
 
-  for (SmallVectorImpl<std::pair<Function*,Function*> >::iterator
-         I = Queue.begin(), E = Queue.end(); I != E; ++I)
+  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(GlobalValue *L, GlobalValue *R) {
+bool DifferenceEngine::equivalentAsOperands(const GlobalValue *L,
+                                            const GlobalValue *R) {
   if (globalValueOracle) return (*globalValueOracle)(L, R);
 
   if (isa<GlobalVariable>(L) && isa<GlobalVariable>(R)) {
-    GlobalVariable *GVL = cast<GlobalVariable>(L);
-    GlobalVariable *GVR = cast<GlobalVariable>(R);
+    const GlobalVariable *GVL = cast<GlobalVariable>(L);
+    const GlobalVariable *GVR = cast<GlobalVariable>(R);
     if (GVL->hasLocalLinkage() && GVL->hasUniqueInitializer() &&
         GVR->hasLocalLinkage() && GVR->hasUniqueInitializer())
       return GVL->getInitializer() == GVR->getInitializer();
   }
 
   return L->getName() == R->getName();
 }