[llvm-commits] CVS: llvm/tools/bugpoint/BugDriver.h ExtractFunction.cpp

[Chris Lattner]

Changes in directory llvm/tools/bugpoint:

BugDriver.h updated: 1.28 -> 1.29
ExtractFunction.cpp updated: 1.22 -> 1.23

---
Log message:

Make more stuff public.  Make the instruction argument to 
deleteInstructionFromProgram be const


---
Diffs of the changes:  (+31 -30)

Index: llvm/tools/bugpoint/BugDriver.h
diff -u llvm/tools/bugpoint/BugDriver.h:1.28 llvm/tools/bugpoint/BugDriver.h:1.29
--- llvm/tools/bugpoint/BugDriver.h:1.28	Wed Feb 18 15:35:28 2004
+++ llvm/tools/bugpoint/BugDriver.h	Wed Feb 18 15:50:26 2004
@@ -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,
@@ -194,20 +208,6 @@
   /// PrintFunctionList - prints out list of problematic functions
   ///
   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.


Index: llvm/tools/bugpoint/ExtractFunction.cpp
diff -u llvm/tools/bugpoint/ExtractFunction.cpp:1.22 llvm/tools/bugpoint/ExtractFunction.cpp:1.23
--- llvm/tools/bugpoint/ExtractFunction.cpp:1.22	Sat Dec  6 20:31:03 2003
+++ llvm/tools/bugpoint/ExtractFunction.cpp	Wed Feb 18 15:50:26 2004
@@ -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;