ExecutionEngine.cpp: Move execution engine creation stuff into a new

  static method here.
 Remove some extra blank lines.
ExecutionEngine.h: Add its prototype.
lli.cpp: Call it.

Make creation method for each type of EE into a static method of its
own subclass.

Interpreter/Interpreter.cpp: ExecutionEngine::createInterpreter -->
 Interpreter::create
Interpreter/Interpreter.h: Likewise.
JIT/JIT.cpp: ExecutionEngine::createJIT --> VM::create
JIT/VM.h: Likewise.

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

diff --git a/include/llvm/ExecutionEngine/ExecutionEngine.h b/include/llvm/ExecutionEngine/ExecutionEngine.h
index e2d43c97f437548dae0683c5dc4dd01b543c4b5d..a0e54c14508a23e6939e07e0e2dbb95bd533460d 100644 (file)
--- a/include/llvm/ExecutionEngine/ExecutionEngine.h
+++ b/include/llvm/ExecutionEngine/ExecutionEngine.h
@@ -48,6 +48,9 @@ public:
                   const std::vector<std::string> &Args,
                   const char ** envp) = 0;
 
+  static ExecutionEngine *create (Module *M, bool ForceInterpreter,
+                                 bool DebugMode, bool TraceMode);
+
   /// createJIT - Create an return a new JIT compiler if there is one available
   /// for the current target.  Otherwise it returns null.
   ///

diff --git a/lib/ExecutionEngine/ExecutionEngine.cpp b/lib/ExecutionEngine/ExecutionEngine.cpp
index 89d9e1628925c5b78ae4dabacd5f6427d0cf9087..5691a248a06c85e6aecc3936e1a354519ccd224b 100644 (file)
--- a/lib/ExecutionEngine/ExecutionEngine.cpp
+++ b/lib/ExecutionEngine/ExecutionEngine.cpp
@@ -15,9 +15,25 @@
 #include "Support/Debug.h"
 #include "Support/Statistic.h"
 #include "Config/dlfcn.h"
+#include "JIT/VM.h"
+#include "Interpreter/Interpreter.h"
 
 Statistic<> NumInitBytes("lli", "Number of bytes of global vars initialized");
 
+ExecutionEngine *ExecutionEngine::create (Module *M, bool ForceInterpreter,
+                                         bool DebugMode, bool TraceMode) {
+  ExecutionEngine *EE = 0;
+
+  // If there is nothing that is forcing us to use the interpreter, make a JIT.
+  if (!ForceInterpreter && !DebugMode && !TraceMode)
+    EE = VM::create(M);
+
+  // If we can't make a JIT, make an interpreter instead.
+  if (EE == 0)
+    EE = Interpreter::create(M, DebugMode, TraceMode);
+  return EE;
+}
+
 // getPointerToGlobal - This returns the address of the specified global
 // value.  This may involve code generation if it's a function.
 //
@@ -29,7 +45,6 @@ void *ExecutionEngine::getPointerToGlobal(const GlobalValue *GV) {
   return GlobalAddress[GV];
 }
 
-
 GenericValue ExecutionEngine::getConstantValue(const Constant *C) {
   GenericValue Result;
 
@@ -259,7 +274,6 @@ GenericValue ExecutionEngine::LoadValueFromMemory(GenericValue *Ptr,
   return Result;
 }
 
-
 // InitializeMemory - Recursive function to apply a Constant value into the
 // specified memory location...
 //

diff --git a/lib/ExecutionEngine/Interpreter/Interpreter.cpp b/lib/ExecutionEngine/Interpreter/Interpreter.cpp
index 950e6a572732c3aac5e816d58e889ad6499eb4dd..6f540e2d1a8a3d0a161c22e6b0b31aaf42e5cde0 100644 (file)
--- a/lib/ExecutionEngine/Interpreter/Interpreter.cpp
+++ b/lib/ExecutionEngine/Interpreter/Interpreter.cpp
@@ -9,11 +9,9 @@
 #include "Interpreter.h"
 #include "llvm/Module.h"
 
-/// createInterpreter - Create a new interpreter object.  This can never fail.
+/// create - Create a new interpreter object.  This can never fail.
 ///
-ExecutionEngine *ExecutionEngine::createInterpreter(Module *M,
-                                                   bool DebugMode,
-                                                   bool TraceMode) {
+ExecutionEngine *Interpreter::create(Module *M, bool DebugMode, bool TraceMode){
   bool isLittleEndian;
   switch (M->getEndianness()) {
   case Module::LittleEndian: isLittleEndian = true; break;

diff --git a/lib/ExecutionEngine/Interpreter/Interpreter.h b/lib/ExecutionEngine/Interpreter/Interpreter.h
index 89581e0fd5f42da0667f2f77d690dfdf687d8e39..459904da6db1772c101ea687b860c9a83ed1dd53 100644 (file)
--- a/lib/ExecutionEngine/Interpreter/Interpreter.h
+++ b/lib/ExecutionEngine/Interpreter/Interpreter.h
@@ -91,8 +91,13 @@ public:
               bool DebugMode, bool TraceMode);
   inline ~Interpreter() { CW.setModule(0); }
 
-  // getExitCode - return the code that should be the exit code for the lli
-  // utility.
+  /// create - Create an interpreter ExecutionEngine. This can never fail.
+  ///
+  static ExecutionEngine *create(Module *M, bool DebugMode, bool TraceMode);
+
+  /// getExitCode - return the code that should be the exit code for the lli
+  /// utility.
+  ///
   inline int getExitCode() const { return ExitCode; }
 
   /// run - Start execution with the specified function and arguments.

diff --git a/lib/ExecutionEngine/JIT/JIT.cpp b/lib/ExecutionEngine/JIT/JIT.cpp
index 57d7b89d8f2937ffec23ebc604aacef05f646235..9a2dc1aacb7dd91c50e928fedacab509f794ead4 100644 (file)
--- a/lib/ExecutionEngine/JIT/JIT.cpp
+++ b/lib/ExecutionEngine/JIT/JIT.cpp
@@ -41,11 +41,10 @@ namespace {
 #endif /* NO_JITS_ENABLED */
 }
 
-/// createJIT - Create an return a new JIT compiler if there is one available
-/// for the current target.  Otherwise it returns null.
+/// create - Create an return a new JIT compiler if there is one available
+/// for the current target.  Otherwise, return null.
 ///
-ExecutionEngine *ExecutionEngine::createJIT(Module *M) {
-  
+ExecutionEngine *VM::create(Module *M) {
   TargetMachine* (*TargetMachineAllocator)(const Module &) = 0;
 
   // Allow a command-line switch to override what *should* be the default target

diff --git a/lib/ExecutionEngine/JIT/JIT.h b/lib/ExecutionEngine/JIT/JIT.h
index e886a1941223ee5adfff88490d6f85b7c30895f5..764afcf66fe4496775da49732a10145058797017 100644 (file)
--- a/lib/ExecutionEngine/JIT/JIT.h
+++ b/lib/ExecutionEngine/JIT/JIT.h
@@ -26,6 +26,11 @@ public:
   VM(Module *M, TargetMachine *tm);
   ~VM();
 
+  /// create - Create an return a new JIT compiler if there is one available
+  /// for the current target.  Otherwise, return null.
+  ///
+  static ExecutionEngine *create(Module *M);
+
   /// run - Start execution with the specified function and arguments.
   ///
   virtual int run(const std::string &FnName,

diff --git a/lib/ExecutionEngine/JIT/VM.h b/lib/ExecutionEngine/JIT/VM.h
index e886a1941223ee5adfff88490d6f85b7c30895f5..764afcf66fe4496775da49732a10145058797017 100644 (file)
--- a/lib/ExecutionEngine/JIT/VM.h
+++ b/lib/ExecutionEngine/JIT/VM.h
@@ -26,6 +26,11 @@ public:
   VM(Module *M, TargetMachine *tm);
   ~VM();
 
+  /// create - Create an return a new JIT compiler if there is one available
+  /// for the current target.  Otherwise, return null.
+  ///
+  static ExecutionEngine *create(Module *M);
+
   /// run - Start execution with the specified function and arguments.
   ///
   virtual int run(const std::string &FnName,

diff --git a/tools/lli/lli.cpp b/tools/lli/lli.cpp
index 3b9414a8773aa17e57fc0cb054abfe54b8db18ab..36af42168ad00c3c691c4593abbe7599d2ec20b5 100644 (file)
--- a/tools/lli/lli.cpp
+++ b/tools/lli/lli.cpp
@@ -59,15 +59,9 @@ int main(int argc, char** argv, const char ** envp) {
     exit(1);
   }
 
-  ExecutionEngine *EE = 0;
-
-  // If there is nothing that is forcing us to use the interpreter, make a JIT.
-  if (!ForceInterpreter && !DebugMode && !TraceMode)
-    EE = ExecutionEngine::createJIT(M);
-
-  // If we can't make a JIT, make an interpreter instead.
-  if (EE == 0)
-    EE = ExecutionEngine::createInterpreter(M, DebugMode, TraceMode);
+  ExecutionEngine *EE =
+    ExecutionEngine::create (M, ForceInterpreter, DebugMode, TraceMode);
+  assert (EE && "Couldn't create an ExecutionEngine, not even an interpreter?");
 
   // Add the module name to the start of the argv vector...
   // But delete .bc first, since programs (and users) might not expect to