diff --git a/tools/bugpoint/BugDriver.h b/tools/bugpoint/BugDriver.h
index 64a5235..3ef50f6 100644
--- a/tools/bugpoint/BugDriver.h
+++ b/tools/bugpoint/BugDriver.h
@@ -152,6 +152,26 @@
   bool diffProgram(const std::string &BytecodeFile = "",
                    const std::string &SharedObj = "",
                    bool RemoveBytecode = false);
+  /// EmitProgressBytecode - This function is used to output the current Program
+  /// to a file named "bugpoint-ID.bc".
+  ///
+  void EmitProgressBytecode(const std::string &ID, bool NoFlyer = false);
+
+  /// deleteInstructionFromProgram - This method clones the current Program and
+  /// deletes the specified instruction from the cloned module.  It then runs a
+  /// series of cleanup passes (ADCE and SimplifyCFG) to eliminate any code
+  /// which depends on the value.  The modified module is then returned.
+  ///
+  Module *deleteInstructionFromProgram(const Instruction *I, unsigned Simp)
+    const;
+
+  /// performFinalCleanups - This method clones the current Program and performs
+  /// a series of cleanups intended to get rid of extra cruft on the module.  If
+  /// the MayModifySemantics argument is true, then the cleanups is allowed to
+  /// modify how the code behaves.
+  ///
+  Module *performFinalCleanups(Module *M, bool MayModifySemantics = false);
+
 private:
   /// ParseInputFile - Given a bytecode or assembly input filename, parse and
   /// return it, or return null if not possible.
@@ -163,12 +183,6 @@
   ///
   bool writeProgramToFile(const std::string &Filename, Module *M = 0) const;
 
-
-  /// EmitProgressBytecode - This function is used to output the current Program
-  /// to a file named "bugpoint-ID.bc".
-  ///
-  void EmitProgressBytecode(const std::string &ID, bool NoFlyer = false);
-  
   /// runPasses - Run the specified passes on Program, outputting a bytecode
   /// file and writting the filename into OutputFile if successful.  If the
   /// optimizations fail for some reason (optimizer crashes), return true,
@@ -195,20 +209,6 @@
   ///
   static void PrintFunctionList(const std::vector<Function*> &Funcs);
 
-  /// deleteInstructionFromProgram - This method clones the current Program and
-  /// deletes the specified instruction from the cloned module.  It then runs a
-  /// series of cleanup passes (ADCE and SimplifyCFG) to eliminate any code
-  /// which depends on the value.  The modified module is then returned.
-  ///
-  Module *deleteInstructionFromProgram(Instruction *I, unsigned Simp) const;
-
-  /// performFinalCleanups - This method clones the current Program and performs
-  /// a series of cleanups intended to get rid of extra cruft on the module.  If
-  /// the MayModifySemantics argument is true, then the cleanups is allowed to
-  /// modify how the code behaves.
-  ///
-  Module *performFinalCleanups(Module *M, bool MayModifySemantics = false);
-
   /// initializeExecutionEnvironment - This method is used to set up the
   /// environment for executing LLVM programs.
   ///
diff --git a/tools/bugpoint/ExtractFunction.cpp b/tools/bugpoint/ExtractFunction.cpp
index 1c7f046..9841c44 100644
--- a/tools/bugpoint/ExtractFunction.cpp
+++ b/tools/bugpoint/ExtractFunction.cpp
@@ -48,29 +48,30 @@
 /// series of cleanup passes (ADCE and SimplifyCFG) to eliminate any code which
 /// depends on the value.  The modified module is then returned.
 ///
-Module *BugDriver::deleteInstructionFromProgram(Instruction *I,
+Module *BugDriver::deleteInstructionFromProgram(const Instruction *I,
                                                 unsigned Simplification) const {
   Module *Result = CloneModule(Program);
 
-  BasicBlock *PBB = I->getParent();
-  Function *PF = PBB->getParent();
+  const BasicBlock *PBB = I->getParent();
+  const Function *PF = PBB->getParent();
 
   Module::iterator RFI = Result->begin(); // Get iterator to corresponding fn
-  std::advance(RFI, std::distance(Program->begin(), Module::iterator(PF)));
+  std::advance(RFI, std::distance(PF->getParent()->begin(),
+                                  Module::const_iterator(PF)));
 
   Function::iterator RBI = RFI->begin();  // Get iterator to corresponding BB
-  std::advance(RBI, std::distance(PF->begin(), Function::iterator(PBB)));
+  std::advance(RBI, std::distance(PF->begin(), Function::const_iterator(PBB)));
 
   BasicBlock::iterator RI = RBI->begin(); // Get iterator to corresponding inst
-  std::advance(RI, std::distance(PBB->begin(), BasicBlock::iterator(I)));
-  I = RI;                                 // Got the corresponding instruction!
+  std::advance(RI, std::distance(PBB->begin(), BasicBlock::const_iterator(I)));
+  Instruction *TheInst = RI;              // Got the corresponding instruction!
 
   // If this instruction produces a value, replace any users with null values
-  if (I->getType() != Type::VoidTy)
-    I->replaceAllUsesWith(Constant::getNullValue(I->getType()));
+  if (TheInst->getType() != Type::VoidTy)
+    TheInst->replaceAllUsesWith(Constant::getNullValue(TheInst->getType()));
 
   // Remove the instruction from the program.
-  I->getParent()->getInstList().erase(I);
+  TheInst->getParent()->getInstList().erase(TheInst);
 
   // Spiff up the output a little bit.
   PassManager Passes;