Make it possible to create multiple JIT instances at the same time, by removing

the global TheJIT and TheJITResolver variables.  Lazy compilation is supported
by a global map from a stub address to the JITResolver that knows how to
compile it.

Patch by Olivier Meurant!


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

1 files changed, 164 insertions, 0 deletions

diff --git a/unittests/ExecutionEngine/JIT/MultiJITTest.cpp b/unittests/ExecutionEngine/JIT/MultiJITTest.cpp
new file mode 100644
index 00000000000..8997d39836c
--- /dev/null
+++ b/unittests/ExecutionEngine/JIT/MultiJITTest.cpp
@@ -0,0 +1,164 @@
+//===- MultiJITTest.cpp - Unit tests for instantiating multiple JITs ------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "gtest/gtest.h"
+#include "llvm/LLVMContext.h"
+#include "llvm/Module.h"
+#include "llvm/Assembly/Parser.h"
+#include "llvm/ExecutionEngine/GenericValue.h"
+#include "llvm/ExecutionEngine/JIT.h"
+#include "llvm/Support/SourceMgr.h"
+#include <vector>
+
+using namespace llvm;
+
+namespace {
+
+bool LoadAssemblyInto(Module *M, const char *assembly) {
+  SMDiagnostic Error;
+  bool success =
+    NULL != ParseAssemblyString(assembly, M, Error, M->getContext());
+  std::string errMsg;
+  raw_string_ostream os(errMsg);
+  Error.Print("", os);
+  EXPECT_TRUE(success) << os.str();
+  return success;
+}
+
+void createModule1(LLVMContext &Context1, Module *&M1, Function *&FooF1) {
+  M1 = new Module("test1", Context1);
+  LoadAssemblyInto(M1,
+                   "define i32 @add1(i32 %ArgX1) { "
+                   "entry: "
+                   "  %addresult = add i32 1, %ArgX1 "
+                   "  ret i32 %addresult "
+                   "} "
+                   " "
+                   "define i32 @foo1() { "
+                   "entry: "
+                   "  %add1 = call i32 @add1(i32 10) "
+                   "  ret i32 %add1 "
+                   "} ");
+  FooF1 = M1->getFunction("foo1");
+}
+
+void createModule2(LLVMContext &Context2, Module *&M2, Function *&FooF2) {
+  M2 = new Module("test2", Context2);
+  LoadAssemblyInto(M2,
+                   "define i32 @add2(i32 %ArgX2) { "
+                   "entry: "
+                   "  %addresult = add i32 2, %ArgX2 "
+                   "  ret i32 %addresult "
+                   "} "
+                   " "
+                   "define i32 @foo2() { "
+                   "entry: "
+                   "  %add2 = call i32 @add2(i32 10) "
+                   "  ret i32 %add2 "
+                   "} ");
+  FooF2 = M2->getFunction("foo2");
+}
+
+TEST(MultiJitTest, EagerMode) {
+  LLVMContext Context1;
+  Module *M1 = 0;
+  Function *FooF1 = 0;
+  createModule1(Context1, M1, FooF1);
+
+  LLVMContext Context2;
+  Module *M2 = 0;
+  Function *FooF2 = 0;
+  createModule2(Context2, M2, FooF2);
+
+  // Now we create the JIT in eager mode
+  OwningPtr<ExecutionEngine> EE1(EngineBuilder(M1).create());
+  EE1->DisableLazyCompilation(true);
+  OwningPtr<ExecutionEngine> EE2(EngineBuilder(M2).create());
+  EE2->DisableLazyCompilation(true);
+
+  // Call the `foo' function with no arguments:
+  std::vector<GenericValue> noargs;
+  GenericValue gv1 = EE1->runFunction(FooF1, noargs);
+  GenericValue gv2 = EE2->runFunction(FooF2, noargs);
+
+  // Import result of execution:
+  EXPECT_EQ(gv1.IntVal, 11);
+  EXPECT_EQ(gv2.IntVal, 12);
+
+  EE1->freeMachineCodeForFunction(FooF1);
+  EE2->freeMachineCodeForFunction(FooF2);
+}
+
+TEST(MultiJitTest, LazyMode) {
+  LLVMContext Context1;
+  Module *M1 = 0;
+  Function *FooF1 = 0;
+  createModule1(Context1, M1, FooF1);
+
+  LLVMContext Context2;
+  Module *M2 = 0;
+  Function *FooF2 = 0;
+  createModule2(Context2, M2, FooF2);
+
+  // Now we create the JIT in lazy mode
+  OwningPtr<ExecutionEngine> EE1(EngineBuilder(M1).create());
+  EE1->DisableLazyCompilation(false);
+  OwningPtr<ExecutionEngine> EE2(EngineBuilder(M2).create());
+  EE2->DisableLazyCompilation(false);
+
+  // Call the `foo' function with no arguments:
+  std::vector<GenericValue> noargs;
+  GenericValue gv1 = EE1->runFunction(FooF1, noargs);
+  GenericValue gv2 = EE2->runFunction(FooF2, noargs);
+
+  // Import result of execution:
+  EXPECT_EQ(gv1.IntVal, 11);
+  EXPECT_EQ(gv2.IntVal, 12);
+
+  EE1->freeMachineCodeForFunction(FooF1);
+  EE2->freeMachineCodeForFunction(FooF2);
+}
+
+extern "C" {
+  extern void *getPointerToNamedFunction(const char *Name);
+}
+
+TEST(MultiJitTest, JitPool) {
+  LLVMContext Context1;
+  Module *M1 = 0;
+  Function *FooF1 = 0;
+  createModule1(Context1, M1, FooF1);
+
+  LLVMContext Context2;
+  Module *M2 = 0;
+  Function *FooF2 = 0;
+  createModule2(Context2, M2, FooF2);
+
+  // Now we create two JITs
+  OwningPtr<ExecutionEngine> EE1(EngineBuilder(M1).create());
+  OwningPtr<ExecutionEngine> EE2(EngineBuilder(M2).create());
+
+  Function *F1 = EE1->FindFunctionNamed("foo1");
+  void *foo1 = EE1->getPointerToFunction(F1);
+
+  Function *F2 = EE2->FindFunctionNamed("foo2");
+  void *foo2 = EE2->getPointerToFunction(F2);
+
+  // Function in M1
+  EXPECT_EQ(getPointerToNamedFunction("foo1"), foo1);
+
+  // Function in M2
+  EXPECT_EQ(getPointerToNamedFunction("foo2"), foo2);
+
+  // Symbol search
+  EXPECT_EQ((intptr_t)getPointerToNamedFunction("getPointerToNamedFunction"),
+            (intptr_t)&getPointerToNamedFunction);
+}
+
+}  // anonymous namespace