Change the execute methods to take the shared object filename by const reference.

Other adjustments to work with the new ToolRunner interfaces


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@9130 91177308-0d34-0410-b5e6-96231b3b80d8

3 files changed, 37 insertions, 27 deletions

diff --git a/tools/bugpoint/BugDriver.h b/tools/bugpoint/BugDriver.h
index 2b43aae..532bbb5 100644
--- a/tools/bugpoint/BugDriver.h
+++ b/tools/bugpoint/BugDriver.h
@@ -165,21 +165,25 @@ private:
   ///
   std::string executeProgram(std::string RequestedOutputFilename = "",
                              std::string Bytecode = "",
-                             std::string SharedObject = "",
+                             const std::string &SharedObjects = "",
                              AbstractInterpreter *AI = 0);
 
   /// executeProgramWithCBE - Used to create reference output with the C
   /// backend, if reference output is not provided.
-  std::string executeProgramWithCBE(std::string RequestedOutputFilename = "",
-                                    std::string Bytecode = "",
-                                    std::string SharedObject = "");
+  ///
+  std::string executeProgramWithCBE(std::string OutputFile = "",
+                                    std::string BytecodeFile = "",
+                                    const std::string &SharedObj = "") {
+    return executeProgram(OutputFile, BytecodeFile, SharedObj,
+                          (AbstractInterpreter*)cbe);
+  }
 
   /// diffProgram - This method executes the specified module and diffs the
   /// output against the file specified by ReferenceOutputFile.  If the output
   /// is different, true is returned.
   ///
   bool diffProgram(const std::string &BytecodeFile = "",
-                   const std::string &SharedObject = "",
+                   const std::string &SharedObj = "",
                    bool RemoveBytecode = false);
 };
 
diff --git a/tools/bugpoint/CodeGeneratorBug.cpp b/tools/bugpoint/CodeGeneratorBug.cpp
index b775709..8bb3b49 100644
--- a/tools/bugpoint/CodeGeneratorBug.cpp
+++ b/tools/bugpoint/CodeGeneratorBug.cpp
@@ -48,8 +48,7 @@ public:
 
 
 bool ReduceMisCodegenFunctions::TestFuncs(const std::vector<Function*> &Funcs,
-                                          bool KeepFiles)
-{
+                                          bool KeepFiles) {
   std::cout << "Testing functions: ";
   BD.PrintFunctionList(Funcs);
   std::cout << "\t";
@@ -225,7 +224,7 @@ bool ReduceMisCodegenFunctions::TestFuncs(const std::vector<Function*> &Funcs,
   }
 
   // Make a shared library
-  std::string SharedObject = compileSharedObject(SafeModuleBC);
+  std::string SharedObject = BD.compileSharedObject(SafeModuleBC);
 
   delete SafeModule;
   delete TestModule;
diff --git a/tools/bugpoint/ExecutionDriver.cpp b/tools/bugpoint/ExecutionDriver.cpp
index 17e2ce2..749dac5 100644
--- a/tools/bugpoint/ExecutionDriver.cpp
+++ b/tools/bugpoint/ExecutionDriver.cpp
@@ -67,10 +67,18 @@ bool BugDriver::initializeExecutionEnvironment() {
   // the command line
   std::string Message;
   switch (InterpreterSel) {
-  case RunLLI: Interpreter = createLLItool(getToolName(), Message); break;
-  case RunLLC: Interpreter = createLLCtool(getToolName(), Message); break;
-  case RunJIT: Interpreter = createJITtool(getToolName(), Message); break;
-  case RunCBE: Interpreter = createCBEtool(getToolName(), Message); break;
+  case RunLLI:
+    Interpreter = AbstractInterpreter::createLLI(getToolName(), Message);
+    break;
+  case RunLLC:
+    Interpreter = AbstractInterpreter::createLLC(getToolName(), Message);
+    break;
+  case RunJIT:
+    Interpreter = AbstractInterpreter::createJIT(getToolName(), Message);
+    break;
+  case RunCBE:
+    Interpreter = AbstractInterpreter::createCBE(getToolName(), Message);
+    break;
   default:
     Message = "Sorry, this back-end is not supported by bugpoint right now!\n";
     break;
@@ -78,9 +86,9 @@ bool BugDriver::initializeExecutionEnvironment() {
   std::cerr << Message;
 
   // Initialize auxiliary tools for debugging
-  cbe = createCBEtool(getToolName(), Message);
+  cbe = AbstractInterpreter::createCBE(getToolName(), Message);
   if (!cbe) { std::cout << Message << "\nExiting.\n"; exit(1); }
-  gcc = createGCCtool(getToolName(), Message);
+  gcc = GCC::create(getToolName(), Message);
   if (!gcc) { std::cout << Message << "\nExiting.\n"; exit(1); }
 
   // If there was an error creating the selected interpreter, quit with error.
@@ -94,9 +102,10 @@ bool BugDriver::initializeExecutionEnvironment() {
 ///
 std::string BugDriver::executeProgram(std::string OutputFile,
                                       std::string BytecodeFile,
-                                      std::string SharedObject,
+                                      const std::string &SharedObj,
                                       AbstractInterpreter *AI) {
-  assert((Interpreter||AI) && "Interpreter should have been created already!");
+  if (AI == 0) AI = Interpreter;
+  assert(AI && "Interpreter should have been created already!");
   bool CreatedBytecode = false;
   if (BytecodeFile.empty()) {
     // Emit the program to a bytecode file...
@@ -115,12 +124,15 @@ std::string BugDriver::executeProgram(std::string OutputFile,
   // Check to see if this is a valid output filename...
   OutputFile = getUniqueFilename(OutputFile);
 
+  // Figure out which shared objects to run, if any.
+  std::vector<std::string> SharedObjs;
+  if (!SharedObj.empty())
+    SharedObjs.push_back(SharedObj);
+
   // Actually execute the program!
-  int RetVal = (AI != 0) ?
-    AI->ExecuteProgram(BytecodeFile, InputArgv, InputFile, OutputFile,
-                       SharedObject) :
-    Interpreter->ExecuteProgram(BytecodeFile, InputArgv, 
-                                InputFile, OutputFile, SharedObject);
+  int RetVal = AI->ExecuteProgram(BytecodeFile, InputArgv, InputFile,
+                                  OutputFile, SharedObjs);
+
 
   // Remove the temporary bytecode file.
   if (CreatedBytecode) removeFile(BytecodeFile);
@@ -129,11 +141,6 @@ std::string BugDriver::executeProgram(std::string OutputFile,
   return OutputFile;
 }
 
-std::string BugDriver::executeProgramWithCBE(std::string OutputFile,
-                                             std::string BytecodeFile,
-                                             std::string SharedObject) {
-  return executeProgram(OutputFile, BytecodeFile, SharedObject, cbe);
-}
 
 std::string BugDriver::compileSharedObject(const std::string &BytecodeFile) {
   assert(Interpreter && "Interpreter should have been created already!");
@@ -153,7 +160,7 @@ std::string BugDriver::compileSharedObject(const std::string &BytecodeFile) {
 #endif
 
   std::string SharedObjectFile;
-  if (gcc->MakeSharedObject(OutputCFile, CFile, SharedObject))
+  if (gcc->MakeSharedObject(OutputCFile, GCC::CFile, SharedObjectFile))
     exit(1);
 
   // Remove the intermediate C file