Added tests for mcjit multiple module

[msriram]

Summary

multiple module tests

[dmalea]

Looks great, only minor comments to make stuff more readable.

Since you're ahead of me (I'm still working on finishing up the testcases for the last 7 cases) do you want to look at adding some global variable tests as well?

unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp

36

This test should probably stay in MCJITTest.cpp

62

test1 is not very descriptive..maybe name the tests something else like independent_modules to express that modules don't have any dependencies on each other..

65

Using the variable M is convenient when there's only one module, but for multiple modules it's hard to follow what's going on. Maybe declare each module separately to make it clear that FA refers to a function in module A:

OwningPtr<Module> A;
A.reset(createEmptyModule("A"));
Function *FA = insertBlahFunction(A.get(), ...)

70

<caller module> is not a good name here.. Andy's naming scheme was clearer to understand, so maybe just "B" for the module that contains function FB is better?

123

Maybe a short comment here that explains what the test verifies would be good. For the tests I'm writing, I just pasted the comments Andy provided.

For example, something like:

Populates Modules A, B and C:
Module A { Function FA },
Module B { Extern FA, Function FB which calls FA },
Module C { Extern FB, Function FC which calls FB },
// execute FA, FB, FC

[msriram]

Yeah, I will take a look at the global variable tests and cross module linking case as well..

[msriram]

Fixed the naming style and reduced redundancy

[msriram]

Updated the revision with all your suggestions. Please note that I got seg fault when I did not have finalizeModule. We can go over it in your patch as well.

unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp

36

right!

62

done

65

done

70

done

123

done

[dmalea]

Looks Great! Only minor notes:

• indenting looks a bit off. I recommend just running clang-format on the whole file.
• regarding the finalize() call, let's meet up today with Andy to see if we can agree on an interface.
• let's merge this into Andy's MCJIT branch (mcjit-multi-modules) so we are all on the same branch.

unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp

10

This description also needs updating.

25

Are we still using this M? If not, I think we can skip the SetUp routine.

unittests/ExecutionEngine/MCJIT/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   asmparser
   bitreader
   bitwriter
   jit
   mcjit
   nativecodegen
   )
 
 set(MCJITTestsSources
   MCJITTest.cpp
   MCJITCAPITest.cpp
   MCJITMemoryManagerTest.cpp
+  MCJITMultipleModuleTest.cpp
   MCJITObjectCacheTest.cpp
   )
 
 if(MSVC)
   list(APPEND MCJITTestsSources MCJITTests.def)
 endif()
 
 add_llvm_unittest(MCJITTests
   ${MCJITTestsSources}
   )
 
 if(MINGW OR CYGWIN)
   set_property(TARGET MCJITTests PROPERTY LINK_FLAGS -Wl,--export-all-symbols)
 endif()

unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp

+//===- MCJITMultipeModuleTest.cpp - Unit tests for the MCJIT ---------------------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This test suite verifies basic MCJIT functionality such as making function
+// calls, using global variables, and compiling multpile modules.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ExecutionEngine/MCJIT.h"
+#include "MCJITTestBase.h"
+#include "gtest/gtest.h"
+
+using namespace llvm;
+
+class MCJITMultipleModuleTest : public testing::Test, public MCJITTestBase {
+protected:
+
+  virtual void SetUp() {
+    M.reset(createEmptyModule("<main>"));
+  }
+};
+
+namespace {
+
+// FIXME: ExecutionEngine has no support empty modules
+/*
+TEST_F(MCJITMultipleModuleTest, multiple_empty_modules) {
+  SKIP_UNSUPPORTED_PLATFORM;
+
+  createJIT(M.take());
+  // JIT-compile
+  EXPECT_NE(0, TheJIT->getObjectImage())
+    << "Unable to generate executable loaded object image";
+
+  TheJIT->addModule(createEmptyModule("<other module>"));
+  TheJIT->addModule(createEmptyModule("<other other module>"));
+
+  // JIT again
+  EXPECT_NE(0, TheJIT->getObjectImage())
+    << "Unable to generate executable loaded object image";
+}
+*/
+
+void testAdd(void *vPtr) {
+  ASSERT_TRUE(0!=vPtr);
+  int32_t(*FuncPtr)(int32_t, int32_t) = (int32_t(*)(int32_t, int32_t))(intptr_t)vPtr;
+  EXPECT_EQ(0, FuncPtr(0, 0));
+  EXPECT_EQ(1, FuncPtr(1, 0));
+  EXPECT_EQ(2, FuncPtr(1, 1));
+  EXPECT_EQ(-40, FuncPtr(-10, -30));
+}
+
+// Module A { Function FA },
+// Module B { Function FB },
+// execute FA then FB
+TEST_F(MCJITMultipleModuleTest, two_module_case) {
+  SKIP_UNSUPPORTED_PLATFORM;
+  OwningPtr<Module> A, B;
+  Function *FA, *FB;
+  createTwoModuleCase(A, FA, B, FB);
+
+  createJIT(A.take());
+  Module *SaveB = B.get();
+  TheJIT->addModule(B.take());
+
+  void *vPtr = TheJIT->getPointerToFunction(FA);
+  TheJIT->finalizeModule(SaveB);
+  testAdd(vPtr);
+
+  vPtr = TheJIT->getPointerToFunction(FB);
+  testAdd(vPtr);
+
+}
+
+// Module A { Function FA },
+// Module B { Function FB },
+// execute FB then FA
+TEST_F(MCJITMultipleModuleTest, two_module_reverse_case) {
+  SKIP_UNSUPPORTED_PLATFORM;
+  OwningPtr<Module> A, B;
+  Function *FA, *FB;
+  createTwoModuleCase(A, FA, B, FB);
+
+  createJIT(A.take());
+  TheJIT->addModule(B.take());
+
+  void *vPtr = TheJIT->getPointerToFunction(FB);
+  TheJIT->finalizeObject();
+  testAdd(vPtr);
+
+  vPtr = TheJIT->getPointerToFunction(FA);
+  testAdd(vPtr);
+}
+
+// Module A { Function FA },
+// Module B { Extern FA, Function FB which calls FA },
+// execute FB then FA
+TEST_F(MCJITMultipleModuleTest, two_module_extern_reverse_case) {
+  OwningPtr<Module> A, B;
+  Function *FA, *FB;
+  createTwoModuleExternCase(A, FA, B, FB);
+
+  createJIT(A.take());
+  TheJIT->addModule(B.take());
+
+  void *vPtr = TheJIT->getPointerToFunction(FB);
+  TheJIT->finalizeObject();
+  testAdd(vPtr);
+
+  vPtr = TheJIT->getPointerToFunction(FA);
+  testAdd(vPtr);
+}
+
+// Module A { Function FA },
+// Module B { Extern FA, Function FB which calls FA },
+// execute FA then FB
+TEST_F(MCJITMultipleModuleTest, two_module_extern_case) {
+  SKIP_UNSUPPORTED_PLATFORM;
+
+  OwningPtr<Module> A, B;
+  Function *FA, *FB;
+  createTwoModuleExternCase(A, FA, B, FB);
+
+  createJIT(A.take());
+  Module *SaveB = B.get();
+  TheJIT->addModule(B.take());
+
+  void *vPtr = TheJIT->getPointerToFunction(FA);
+  TheJIT->finalizeModule(SaveB);
+  testAdd(vPtr);
+
+  vPtr = TheJIT->getPointerToFunction(FB);
+  testAdd(vPtr);
+}
+
+// Module A { Function FA1, Function FA2 which calls FA1 },
+// Module B { Extern FA1, Function FB which calls FA1 },
+// execute FB then FA2
+TEST_F(MCJITMultipleModuleTest, two_module_consecutive_call_case) {
+  OwningPtr<Module> A, B;
+  Function *FA1, *FA2, *FB;
+  createTwoModuleExternCase(A, FA1, B, FB);
+  FA2 = insertSimpleCallFunction<int32_t(int32_t, int32_t)>(A.get(), FA1);
+
+  createJIT(A.take());
+  TheJIT->addModule(B.take());
+
+  void *vPtr = TheJIT->getPointerToFunction(FB);
+  TheJIT->finalizeObject();
+  testAdd(vPtr);
+
+  vPtr = TheJIT->getPointerToFunction(FA2);
+  testAdd(vPtr);
+}
+
+}

unittests/ExecutionEngine/MCJIT/MCJITTestBase.h

GlobalVariable *insertGlobalInt32(Module *M,
     GlobalVariable *Global = new GlobalVariable(*M,
                                                 GlobalTy,
                                                 false,
                                                 GlobalValue::ExternalLinkage,
                                                 IV,
                                                 name);
     return Global;
   }
+
+  // Populates Modules A and B:
+  // Module A { Function FA },
+  // Module B { Function FB }
+  void createTwoModuleCase(OwningPtr<Module> &A,
+   Function *&FA,
+   OwningPtr<Module> &B,
+   Function *&FB) {
+    A.reset(createEmptyModule("A"));
+    FA = insertAddFunction(A.get());
+
+    B.reset(createEmptyModule("B"));
+    FB = insertAddFunction(B.get());
+  }
+
+  // Populates Modules A and B:
+  // Module A { Function FA },
+  // Module B { Extern FA, Function FB which calls FA }
+  void createTwoModuleExternCase(OwningPtr<Module> &A,
+   Function *&FA,
+   OwningPtr<Module> &B,
+   Function *&FB) {
+    A.reset(createEmptyModule("A"));
+    FA = insertAddFunction(A.get());
+
+    B.reset(createEmptyModule("B"));
+    Function *FAExtern_in_B = insertExternalReferenceToFunction(B.get(), FA);
+    FB = insertSimpleCallFunction<int32_t(int32_t, int32_t)>(B.get(), FAExtern_in_B);
+  }
+
 };
 
 class MCJITTestBase : public MCJITTestAPICommon, public TrivialModuleBuilder {
 protected:
   
   MCJITTestBase()
     : TrivialModuleBuilder(HostTriple)
     , OptLevel(CodeGenOpt::None)