Bug Summary

File:unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp
Location:line 229, column 3
Description:Called function pointer is null (null dereference)

Annotated Source Code

1//===- MCJITMultipeModuleTest.cpp - Unit tests for the MCJIT---------------===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This test suite verifies MCJIT for handling multiple modules in a single
11// ExecutionEngine by building multiple modules, making function calls across
12// modules, accessing global variables, etc.
13//===----------------------------------------------------------------------===//
14
15#include "llvm/ExecutionEngine/MCJIT.h"
16#include "MCJITTestBase.h"
17#include "gtest/gtest.h"
18
19using namespace llvm;
20
21namespace {
22
23class MCJITMultipleModuleTest : public testing::Test, public MCJITTestBase {};
24
25// FIXME: ExecutionEngine has no support empty modules
26/*
27TEST_F(MCJITMultipleModuleTest, multiple_empty_modules) {
28 SKIP_UNSUPPORTED_PLATFORM;
29
30 createJIT(M.take());
31 // JIT-compile
32 EXPECT_NE(0, TheJIT->getObjectImage())
33 << "Unable to generate executable loaded object image";
34
35 TheJIT->addModule(createEmptyModule("<other module>"));
36 TheJIT->addModule(createEmptyModule("<other other module>"));
37
38 // JIT again
39 EXPECT_NE(0, TheJIT->getObjectImage())
40 << "Unable to generate executable loaded object image";
41}
42*/
43
44// Helper Function to test add operation
45void checkAdd(uint64_t ptr) {
46 ASSERT_TRUE(ptr != 0)switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar_ = ::testing::AssertionResult(ptr != 0)) ; else return
::testing::internal::AssertHelper(::testing::TestPartResult::
kFatalFailure, "/tmp/buildd/llvm-toolchain-snapshot-3.7~svn239931/unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp"
, 46, ::testing::internal::GetBoolAssertionFailureMessage( gtest_ar_
, "ptr != 0", "false", "true").c_str()) = ::testing::Message(
) << "Unable to get pointer to function.";
47 int (*AddPtr)(int, int) = (int (*)(int, int))ptr;
48 EXPECT_EQ(0, AddPtr(0, 0))switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar = (::testing::internal:: EqHelper<(sizeof(::testing
::internal::IsNullLiteralHelper(0)) == 1)>::Compare("0", "AddPtr(0, 0)"
, 0, AddPtr(0, 0)))) ; else ::testing::internal::AssertHelper
(::testing::TestPartResult::kNonFatalFailure, "/tmp/buildd/llvm-toolchain-snapshot-3.7~svn239931/unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp"
, 48, gtest_ar.failure_message()) = ::testing::Message();
49 EXPECT_EQ(1, AddPtr(1, 0))switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar = (::testing::internal:: EqHelper<(sizeof(::testing
::internal::IsNullLiteralHelper(1)) == 1)>::Compare("1", "AddPtr(1, 0)"
, 1, AddPtr(1, 0)))) ; else ::testing::internal::AssertHelper
(::testing::TestPartResult::kNonFatalFailure, "/tmp/buildd/llvm-toolchain-snapshot-3.7~svn239931/unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp"
, 49, gtest_ar.failure_message()) = ::testing::Message();
50 EXPECT_EQ(3, AddPtr(1, 2))switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar = (::testing::internal:: EqHelper<(sizeof(::testing
::internal::IsNullLiteralHelper(3)) == 1)>::Compare("3", "AddPtr(1, 2)"
, 3, AddPtr(1, 2)))) ; else ::testing::internal::AssertHelper
(::testing::TestPartResult::kNonFatalFailure, "/tmp/buildd/llvm-toolchain-snapshot-3.7~svn239931/unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp"
, 50, gtest_ar.failure_message()) = ::testing::Message();
51 EXPECT_EQ(-5, AddPtr(-2, -3))switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar = (::testing::internal:: EqHelper<(sizeof(::testing
::internal::IsNullLiteralHelper(-5)) == 1)>::Compare("-5",
"AddPtr(-2, -3)", -5, AddPtr(-2, -3)))) ; else ::testing::internal
::AssertHelper(::testing::TestPartResult::kNonFatalFailure, "/tmp/buildd/llvm-toolchain-snapshot-3.7~svn239931/unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp"
, 51, gtest_ar.failure_message()) = ::testing::Message();
52 EXPECT_EQ(30, AddPtr(10, 20))switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar = (::testing::internal:: EqHelper<(sizeof(::testing
::internal::IsNullLiteralHelper(30)) == 1)>::Compare("30",
"AddPtr(10, 20)", 30, AddPtr(10, 20)))) ; else ::testing::internal
::AssertHelper(::testing::TestPartResult::kNonFatalFailure, "/tmp/buildd/llvm-toolchain-snapshot-3.7~svn239931/unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp"
, 52, gtest_ar.failure_message()) = ::testing::Message();
53 EXPECT_EQ(-30, AddPtr(-10, -20))switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar = (::testing::internal:: EqHelper<(sizeof(::testing
::internal::IsNullLiteralHelper(-30)) == 1)>::Compare("-30"
, "AddPtr(-10, -20)", -30, AddPtr(-10, -20)))) ; else ::testing
::internal::AssertHelper(::testing::TestPartResult::kNonFatalFailure
, "/tmp/buildd/llvm-toolchain-snapshot-3.7~svn239931/unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp"
, 53, gtest_ar.failure_message()) = ::testing::Message();
54 EXPECT_EQ(-40, AddPtr(-10, -30))switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar = (::testing::internal:: EqHelper<(sizeof(::testing
::internal::IsNullLiteralHelper(-40)) == 1)>::Compare("-40"
, "AddPtr(-10, -30)", -40, AddPtr(-10, -30)))) ; else ::testing
::internal::AssertHelper(::testing::TestPartResult::kNonFatalFailure
, "/tmp/buildd/llvm-toolchain-snapshot-3.7~svn239931/unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp"
, 54, gtest_ar.failure_message()) = ::testing::Message();
55}
56
57void checkAccumulate(uint64_t ptr) {
58 ASSERT_TRUE(ptr != 0)switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar_ = ::testing::AssertionResult(ptr != 0)) ; else return
::testing::internal::AssertHelper(::testing::TestPartResult::
kFatalFailure, "/tmp/buildd/llvm-toolchain-snapshot-3.7~svn239931/unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp"
, 58, ::testing::internal::GetBoolAssertionFailureMessage( gtest_ar_
, "ptr != 0", "false", "true").c_str()) = ::testing::Message(
) << "Unable to get pointer to function.";
59 int32_t (*FPtr)(int32_t) = (int32_t (*)(int32_t))(intptr_t)ptr;
60 EXPECT_EQ(0, FPtr(0))switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar = (::testing::internal:: EqHelper<(sizeof(::testing
::internal::IsNullLiteralHelper(0)) == 1)>::Compare("0", "FPtr(0)"
, 0, FPtr(0)))) ; else ::testing::internal::AssertHelper(::testing
::TestPartResult::kNonFatalFailure, "/tmp/buildd/llvm-toolchain-snapshot-3.7~svn239931/unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp"
, 60, gtest_ar.failure_message()) = ::testing::Message();
61 EXPECT_EQ(1, FPtr(1))switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar = (::testing::internal:: EqHelper<(sizeof(::testing
::internal::IsNullLiteralHelper(1)) == 1)>::Compare("1", "FPtr(1)"
, 1, FPtr(1)))) ; else ::testing::internal::AssertHelper(::testing
::TestPartResult::kNonFatalFailure, "/tmp/buildd/llvm-toolchain-snapshot-3.7~svn239931/unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp"
, 61, gtest_ar.failure_message()) = ::testing::Message();
62 EXPECT_EQ(3, FPtr(2))switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar = (::testing::internal:: EqHelper<(sizeof(::testing
::internal::IsNullLiteralHelper(3)) == 1)>::Compare("3", "FPtr(2)"
, 3, FPtr(2)))) ; else ::testing::internal::AssertHelper(::testing
::TestPartResult::kNonFatalFailure, "/tmp/buildd/llvm-toolchain-snapshot-3.7~svn239931/unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp"
, 62, gtest_ar.failure_message()) = ::testing::Message();
63 EXPECT_EQ(6, FPtr(3))switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar = (::testing::internal:: EqHelper<(sizeof(::testing
::internal::IsNullLiteralHelper(6)) == 1)>::Compare("6", "FPtr(3)"
, 6, FPtr(3)))) ; else ::testing::internal::AssertHelper(::testing
::TestPartResult::kNonFatalFailure, "/tmp/buildd/llvm-toolchain-snapshot-3.7~svn239931/unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp"
, 63, gtest_ar.failure_message()) = ::testing::Message();
64 EXPECT_EQ(10, FPtr(4))switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar = (::testing::internal:: EqHelper<(sizeof(::testing
::internal::IsNullLiteralHelper(10)) == 1)>::Compare("10",
"FPtr(4)", 10, FPtr(4)))) ; else ::testing::internal::AssertHelper
(::testing::TestPartResult::kNonFatalFailure, "/tmp/buildd/llvm-toolchain-snapshot-3.7~svn239931/unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp"
, 64, gtest_ar.failure_message()) = ::testing::Message();
65 EXPECT_EQ(15, FPtr(5))switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar = (::testing::internal:: EqHelper<(sizeof(::testing
::internal::IsNullLiteralHelper(15)) == 1)>::Compare("15",
"FPtr(5)", 15, FPtr(5)))) ; else ::testing::internal::AssertHelper
(::testing::TestPartResult::kNonFatalFailure, "/tmp/buildd/llvm-toolchain-snapshot-3.7~svn239931/unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp"
, 65, gtest_ar.failure_message()) = ::testing::Message();
66}
67
68// FIXME: ExecutionEngine has no support empty modules
69/*
70TEST_F(MCJITMultipleModuleTest, multiple_empty_modules) {
71 SKIP_UNSUPPORTED_PLATFORM;
72
73 createJIT(M.take());
74 // JIT-compile
75 EXPECT_NE(0, TheJIT->getObjectImage())
76 << "Unable to generate executable loaded object image";
77
78 TheJIT->addModule(createEmptyModule("<other module>"));
79 TheJIT->addModule(createEmptyModule("<other other module>"));
80
81 // JIT again
82 EXPECT_NE(0, TheJIT->getObjectImage())
83 << "Unable to generate executable loaded object image";
84}
85*/
86
87// Module A { Function FA },
88// Module B { Function FB },
89// execute FA then FB
90TEST_F(MCJITMultipleModuleTest, two_module_case)class MCJITMultipleModuleTest_two_module_case_Test : public MCJITMultipleModuleTest
{ public: MCJITMultipleModuleTest_two_module_case_Test() {} private
: virtual void TestBody(); static ::testing::TestInfo* const test_info_
__attribute__ ((unused)); MCJITMultipleModuleTest_two_module_case_Test
(MCJITMultipleModuleTest_two_module_case_Test const &); void
operator=(MCJITMultipleModuleTest_two_module_case_Test const
&);};::testing::TestInfo* const MCJITMultipleModuleTest_two_module_case_Test
::test_info_ = ::testing::internal::MakeAndRegisterTestInfo(
"MCJITMultipleModuleTest", "two_module_case", __null, __null
, (::testing::internal::GetTypeId<MCJITMultipleModuleTest>
()), MCJITMultipleModuleTest::SetUpTestCase, MCJITMultipleModuleTest
::TearDownTestCase, new ::testing::internal::TestFactoryImpl<
MCJITMultipleModuleTest_two_module_case_Test>);void MCJITMultipleModuleTest_two_module_case_Test
::TestBody() {
91 SKIP_UNSUPPORTED_PLATFORMdo if (!ArchSupportsMCJIT() || !OSSupportsMCJIT()) return; while
(0);
92
93 std::unique_ptr<Module> A, B;
94 Function *FA, *FB;
95 createTwoModuleCase(A, FA, B, FB);
96
97 createJIT(std::move(A));
98 TheJIT->addModule(std::move(B));
99
100 uint64_t ptr = TheJIT->getFunctionAddress(FA->getName().str());
101 checkAdd(ptr);
102
103 ptr = TheJIT->getFunctionAddress(FB->getName().str());
104 checkAdd(ptr);
105}
106
107// Module A { Function FA },
108// Module B { Function FB },
109// execute FB then FA
110TEST_F(MCJITMultipleModuleTest, two_module_reverse_case)class MCJITMultipleModuleTest_two_module_reverse_case_Test : public
MCJITMultipleModuleTest { public: MCJITMultipleModuleTest_two_module_reverse_case_Test
() {} private: virtual void TestBody(); static ::testing::TestInfo
* const test_info_ __attribute__ ((unused)); MCJITMultipleModuleTest_two_module_reverse_case_Test
(MCJITMultipleModuleTest_two_module_reverse_case_Test const &
); void operator=(MCJITMultipleModuleTest_two_module_reverse_case_Test
const &);};::testing::TestInfo* const MCJITMultipleModuleTest_two_module_reverse_case_Test
::test_info_ = ::testing::internal::MakeAndRegisterTestInfo(
"MCJITMultipleModuleTest", "two_module_reverse_case", __null
, __null, (::testing::internal::GetTypeId<MCJITMultipleModuleTest
>()), MCJITMultipleModuleTest::SetUpTestCase, MCJITMultipleModuleTest
::TearDownTestCase, new ::testing::internal::TestFactoryImpl<
MCJITMultipleModuleTest_two_module_reverse_case_Test>);void
MCJITMultipleModuleTest_two_module_reverse_case_Test::TestBody
() {
111 SKIP_UNSUPPORTED_PLATFORMdo if (!ArchSupportsMCJIT() || !OSSupportsMCJIT()) return; while
(0);
112
113 std::unique_ptr<Module> A, B;
114 Function *FA, *FB;
115 createTwoModuleCase(A, FA, B, FB);
116
117 createJIT(std::move(A));
118 TheJIT->addModule(std::move(B));
119
120 uint64_t ptr = TheJIT->getFunctionAddress(FB->getName().str());
121 TheJIT->finalizeObject();
122 checkAdd(ptr);
123
124 ptr = TheJIT->getFunctionAddress(FA->getName().str());
125 checkAdd(ptr);
126}
127
128// Module A { Function FA },
129// Module B { Extern FA, Function FB which calls FA },
130// execute FB then FA
131TEST_F(MCJITMultipleModuleTest, two_module_extern_reverse_case)class MCJITMultipleModuleTest_two_module_extern_reverse_case_Test
: public MCJITMultipleModuleTest { public: MCJITMultipleModuleTest_two_module_extern_reverse_case_Test
() {} private: virtual void TestBody(); static ::testing::TestInfo
* const test_info_ __attribute__ ((unused)); MCJITMultipleModuleTest_two_module_extern_reverse_case_Test
(MCJITMultipleModuleTest_two_module_extern_reverse_case_Test const
&); void operator=(MCJITMultipleModuleTest_two_module_extern_reverse_case_Test
const &);};::testing::TestInfo* const MCJITMultipleModuleTest_two_module_extern_reverse_case_Test
::test_info_ = ::testing::internal::MakeAndRegisterTestInfo(
"MCJITMultipleModuleTest", "two_module_extern_reverse_case",
__null, __null, (::testing::internal::GetTypeId<MCJITMultipleModuleTest
>()), MCJITMultipleModuleTest::SetUpTestCase, MCJITMultipleModuleTest
::TearDownTestCase, new ::testing::internal::TestFactoryImpl<
MCJITMultipleModuleTest_two_module_extern_reverse_case_Test>
);void MCJITMultipleModuleTest_two_module_extern_reverse_case_Test
::TestBody() {
132 SKIP_UNSUPPORTED_PLATFORMdo if (!ArchSupportsMCJIT() || !OSSupportsMCJIT()) return; while
(0);
133
134 std::unique_ptr<Module> A, B;
135 Function *FA, *FB;
136 createTwoModuleExternCase(A, FA, B, FB);
137
138 createJIT(std::move(A));
139 TheJIT->addModule(std::move(B));
140
141 uint64_t ptr = TheJIT->getFunctionAddress(FB->getName().str());
142 TheJIT->finalizeObject();
143 checkAdd(ptr);
144
145 ptr = TheJIT->getFunctionAddress(FA->getName().str());
146 checkAdd(ptr);
147}
148
149// Module A { Function FA },
150// Module B { Extern FA, Function FB which calls FA },
151// execute FA then FB
152TEST_F(MCJITMultipleModuleTest, two_module_extern_case)class MCJITMultipleModuleTest_two_module_extern_case_Test : public
MCJITMultipleModuleTest { public: MCJITMultipleModuleTest_two_module_extern_case_Test
() {} private: virtual void TestBody(); static ::testing::TestInfo
* const test_info_ __attribute__ ((unused)); MCJITMultipleModuleTest_two_module_extern_case_Test
(MCJITMultipleModuleTest_two_module_extern_case_Test const &
); void operator=(MCJITMultipleModuleTest_two_module_extern_case_Test
const &);};::testing::TestInfo* const MCJITMultipleModuleTest_two_module_extern_case_Test
::test_info_ = ::testing::internal::MakeAndRegisterTestInfo(
"MCJITMultipleModuleTest", "two_module_extern_case", __null,
__null, (::testing::internal::GetTypeId<MCJITMultipleModuleTest
>()), MCJITMultipleModuleTest::SetUpTestCase, MCJITMultipleModuleTest
::TearDownTestCase, new ::testing::internal::TestFactoryImpl<
MCJITMultipleModuleTest_two_module_extern_case_Test>);void
MCJITMultipleModuleTest_two_module_extern_case_Test::TestBody
() {
153 SKIP_UNSUPPORTED_PLATFORMdo if (!ArchSupportsMCJIT() || !OSSupportsMCJIT()) return; while
(0);
154
155 std::unique_ptr<Module> A, B;
156 Function *FA, *FB;
157 createTwoModuleExternCase(A, FA, B, FB);
158
159 createJIT(std::move(A));
160 TheJIT->addModule(std::move(B));
161
162 uint64_t ptr = TheJIT->getFunctionAddress(FA->getName().str());
163 checkAdd(ptr);
164
165 ptr = TheJIT->getFunctionAddress(FB->getName().str());
166 checkAdd(ptr);
167}
168
169// Module A { Function FA1, Function FA2 which calls FA1 },
170// Module B { Extern FA1, Function FB which calls FA1 },
171// execute FB then FA2
172TEST_F(MCJITMultipleModuleTest, two_module_consecutive_call_case)class MCJITMultipleModuleTest_two_module_consecutive_call_case_Test
: public MCJITMultipleModuleTest { public: MCJITMultipleModuleTest_two_module_consecutive_call_case_Test
() {} private: virtual void TestBody(); static ::testing::TestInfo
* const test_info_ __attribute__ ((unused)); MCJITMultipleModuleTest_two_module_consecutive_call_case_Test
(MCJITMultipleModuleTest_two_module_consecutive_call_case_Test
const &); void operator=(MCJITMultipleModuleTest_two_module_consecutive_call_case_Test
const &);};::testing::TestInfo* const MCJITMultipleModuleTest_two_module_consecutive_call_case_Test
::test_info_ = ::testing::internal::MakeAndRegisterTestInfo(
"MCJITMultipleModuleTest", "two_module_consecutive_call_case"
, __null, __null, (::testing::internal::GetTypeId<MCJITMultipleModuleTest
>()), MCJITMultipleModuleTest::SetUpTestCase, MCJITMultipleModuleTest
::TearDownTestCase, new ::testing::internal::TestFactoryImpl<
MCJITMultipleModuleTest_two_module_consecutive_call_case_Test
>);void MCJITMultipleModuleTest_two_module_consecutive_call_case_Test
::TestBody() {
173 SKIP_UNSUPPORTED_PLATFORMdo if (!ArchSupportsMCJIT() || !OSSupportsMCJIT()) return; while
(0);
174
175 std::unique_ptr<Module> A, B;
176 Function *FA1, *FA2, *FB;
177 createTwoModuleExternCase(A, FA1, B, FB);
178 FA2 = insertSimpleCallFunction<int32_t(int32_t, int32_t)>(A.get(), FA1);
179
180 createJIT(std::move(A));
181 TheJIT->addModule(std::move(B));
182
183 uint64_t ptr = TheJIT->getFunctionAddress(FB->getName().str());
184 TheJIT->finalizeObject();
185 checkAdd(ptr);
186
187 ptr = TheJIT->getFunctionAddress(FA2->getName().str());
188 checkAdd(ptr);
189}
190
191// TODO:
192// Module A { Extern Global GVB, Global Variable GVA, Function FA loads GVB },
193// Module B { Extern Global GVA, Global Variable GVB, Function FB loads GVA },
194
195
196// Module A { Global Variable GVA, Function FA loads GVA },
197// Module B { Global Variable GVB, Function FB loads GVB },
198// execute FB then FA
199TEST_F(MCJITMultipleModuleTest, two_module_global_variables_case)class MCJITMultipleModuleTest_two_module_global_variables_case_Test
: public MCJITMultipleModuleTest { public: MCJITMultipleModuleTest_two_module_global_variables_case_Test
() {} private: virtual void TestBody(); static ::testing::TestInfo
* const test_info_ __attribute__ ((unused)); MCJITMultipleModuleTest_two_module_global_variables_case_Test
(MCJITMultipleModuleTest_two_module_global_variables_case_Test
const &); void operator=(MCJITMultipleModuleTest_two_module_global_variables_case_Test
const &);};::testing::TestInfo* const MCJITMultipleModuleTest_two_module_global_variables_case_Test
::test_info_ = ::testing::internal::MakeAndRegisterTestInfo(
"MCJITMultipleModuleTest", "two_module_global_variables_case"
, __null, __null, (::testing::internal::GetTypeId<MCJITMultipleModuleTest
>()), MCJITMultipleModuleTest::SetUpTestCase, MCJITMultipleModuleTest
::TearDownTestCase, new ::testing::internal::TestFactoryImpl<
MCJITMultipleModuleTest_two_module_global_variables_case_Test
>);void MCJITMultipleModuleTest_two_module_global_variables_case_Test
::TestBody() {
200 SKIP_UNSUPPORTED_PLATFORMdo if (!ArchSupportsMCJIT() || !OSSupportsMCJIT()) return; while
(0);
201
202 std::unique_ptr<Module> A, B;
203 Function *FA, *FB;
204 GlobalVariable *GVA, *GVB;
205 A.reset(createEmptyModule("A"));
206 B.reset(createEmptyModule("B"));
207
208 int32_t initialNum = 7;
209 GVA = insertGlobalInt32(A.get(), "GVA", initialNum);
210 GVB = insertGlobalInt32(B.get(), "GVB", initialNum);
211 FA = startFunction<int32_t(void)>(A.get(), "FA");
212 endFunctionWithRet(FA, Builder.CreateLoad(GVA));
213 FB = startFunction<int32_t(void)>(B.get(), "FB");
214 endFunctionWithRet(FB, Builder.CreateLoad(GVB));
215
216 createJIT(std::move(A));
217 TheJIT->addModule(std::move(B));
218
219 uint64_t FBPtr = TheJIT->getFunctionAddress(FB->getName().str());
220 TheJIT->finalizeObject();
221 EXPECT_TRUE(0 != FBPtr)switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar_ = ::testing::AssertionResult(0 != FBPtr)) ; else ::
testing::internal::AssertHelper(::testing::TestPartResult::kNonFatalFailure
, "/tmp/buildd/llvm-toolchain-snapshot-3.7~svn239931/unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp"
, 221, ::testing::internal::GetBoolAssertionFailureMessage( gtest_ar_
, "0 != FBPtr", "false", "true").c_str()) = ::testing::Message
();
222 int32_t(*FuncPtr)(void) = (int32_t(*)(void))FBPtr;
223 EXPECT_EQ(initialNum, FuncPtr())switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar = (::testing::internal:: EqHelper<(sizeof(::testing
::internal::IsNullLiteralHelper(initialNum)) == 1)>::Compare
("initialNum", "FuncPtr()", initialNum, FuncPtr()))) ; else ::
testing::internal::AssertHelper(::testing::TestPartResult::kNonFatalFailure
, "/tmp/buildd/llvm-toolchain-snapshot-3.7~svn239931/unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp"
, 223, gtest_ar.failure_message()) = ::testing::Message()
224 << "Invalid value for global returned from JITted function in module B";
225
226 uint64_t FAPtr = TheJIT->getFunctionAddress(FA->getName().str());
1
'FAPtr' initialized here
→
227 EXPECT_TRUE(0 != FAPtr)switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar_ = ::testing::AssertionResult(0 != FAPtr)) ; else ::
testing::internal::AssertHelper(::testing::TestPartResult::kNonFatalFailure
, "/tmp/buildd/llvm-toolchain-snapshot-3.7~svn239931/unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp"
, 227, ::testing::internal::GetBoolAssertionFailureMessage( gtest_ar_
, "0 != FAPtr", "false", "true").c_str()) = ::testing::Message
();
2
←
Within the expansion of the macro 'EXPECT_TRUE':
→
a
Assuming 'FAPtr' is equal to 0
228 FuncPtr = (int32_t(*)(void))FAPtr;
3
←
Null pointer value stored to 'FuncPtr'
→
229 EXPECT_EQ(initialNum, FuncPtr())switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar = (::testing::internal:: EqHelper<(sizeof(::testing
::internal::IsNullLiteralHelper(initialNum)) == 1)>::Compare
("initialNum", "FuncPtr()", initialNum, FuncPtr()))) ; else ::
testing::internal::AssertHelper(::testing::TestPartResult::kNonFatalFailure
, "/tmp/buildd/llvm-toolchain-snapshot-3.7~svn239931/unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp"
, 229, gtest_ar.failure_message()) = ::testing::Message()
4
←
Within the expansion of the macro 'EXPECT_EQ':
a
Called function pointer is null (null dereference)
230 << "Invalid value for global returned from JITted function in module A";
231}
232
233// Module A { Function FA },
234// Module B { Extern FA, Function FB which calls FA },
235// Module C { Extern FA, Function FC which calls FA },
236// execute FC, FB, FA
237TEST_F(MCJITMultipleModuleTest, three_module_case)class MCJITMultipleModuleTest_three_module_case_Test : public
MCJITMultipleModuleTest { public: MCJITMultipleModuleTest_three_module_case_Test
() {} private: virtual void TestBody(); static ::testing::TestInfo
* const test_info_ __attribute__ ((unused)); MCJITMultipleModuleTest_three_module_case_Test
(MCJITMultipleModuleTest_three_module_case_Test const &);
void operator=(MCJITMultipleModuleTest_three_module_case_Test
const &);};::testing::TestInfo* const MCJITMultipleModuleTest_three_module_case_Test
::test_info_ = ::testing::internal::MakeAndRegisterTestInfo(
"MCJITMultipleModuleTest", "three_module_case", __null, __null
, (::testing::internal::GetTypeId<MCJITMultipleModuleTest>
()), MCJITMultipleModuleTest::SetUpTestCase, MCJITMultipleModuleTest
::TearDownTestCase, new ::testing::internal::TestFactoryImpl<
MCJITMultipleModuleTest_three_module_case_Test>);void MCJITMultipleModuleTest_three_module_case_Test
::TestBody() {
238 SKIP_UNSUPPORTED_PLATFORMdo if (!ArchSupportsMCJIT() || !OSSupportsMCJIT()) return; while
(0);
239
240 std::unique_ptr<Module> A, B, C;
241 Function *FA, *FB, *FC;
242 createThreeModuleCase(A, FA, B, FB, C, FC);
243
244 createJIT(std::move(A));
245 TheJIT->addModule(std::move(B));
246 TheJIT->addModule(std::move(C));
247
248 uint64_t ptr = TheJIT->getFunctionAddress(FC->getName().str());
249 checkAdd(ptr);
250
251 ptr = TheJIT->getFunctionAddress(FB->getName().str());
252 checkAdd(ptr);
253
254 ptr = TheJIT->getFunctionAddress(FA->getName().str());
255 checkAdd(ptr);
256}
257
258// Module A { Function FA },
259// Module B { Extern FA, Function FB which calls FA },
260// Module C { Extern FA, Function FC which calls FA },
261// execute FA, FB, FC
262TEST_F(MCJITMultipleModuleTest, three_module_case_reverse_order)class MCJITMultipleModuleTest_three_module_case_reverse_order_Test
: public MCJITMultipleModuleTest { public: MCJITMultipleModuleTest_three_module_case_reverse_order_Test
() {} private: virtual void TestBody(); static ::testing::TestInfo
* const test_info_ __attribute__ ((unused)); MCJITMultipleModuleTest_three_module_case_reverse_order_Test
(MCJITMultipleModuleTest_three_module_case_reverse_order_Test
const &); void operator=(MCJITMultipleModuleTest_three_module_case_reverse_order_Test
const &);};::testing::TestInfo* const MCJITMultipleModuleTest_three_module_case_reverse_order_Test
::test_info_ = ::testing::internal::MakeAndRegisterTestInfo(
"MCJITMultipleModuleTest", "three_module_case_reverse_order"
, __null, __null, (::testing::internal::GetTypeId<MCJITMultipleModuleTest
>()), MCJITMultipleModuleTest::SetUpTestCase, MCJITMultipleModuleTest
::TearDownTestCase, new ::testing::internal::TestFactoryImpl<
MCJITMultipleModuleTest_three_module_case_reverse_order_Test
>);void MCJITMultipleModuleTest_three_module_case_reverse_order_Test
::TestBody() {
263 SKIP_UNSUPPORTED_PLATFORMdo if (!ArchSupportsMCJIT() || !OSSupportsMCJIT()) return; while
(0);
264
265 std::unique_ptr<Module> A, B, C;
266 Function *FA, *FB, *FC;
267 createThreeModuleCase(A, FA, B, FB, C, FC);
268
269 createJIT(std::move(A));
270 TheJIT->addModule(std::move(B));
271 TheJIT->addModule(std::move(C));
272
273 uint64_t ptr = TheJIT->getFunctionAddress(FA->getName().str());
274 checkAdd(ptr);
275
276 ptr = TheJIT->getFunctionAddress(FB->getName().str());
277 checkAdd(ptr);
278
279 ptr = TheJIT->getFunctionAddress(FC->getName().str());
280 checkAdd(ptr);
281}
282
283// Module A { Function FA },
284// Module B { Extern FA, Function FB which calls FA },
285// Module C { Extern FB, Function FC which calls FB },
286// execute FC, FB, FA
287TEST_F(MCJITMultipleModuleTest, three_module_chain_case)class MCJITMultipleModuleTest_three_module_chain_case_Test : public
MCJITMultipleModuleTest { public: MCJITMultipleModuleTest_three_module_chain_case_Test
() {} private: virtual void TestBody(); static ::testing::TestInfo
* const test_info_ __attribute__ ((unused)); MCJITMultipleModuleTest_three_module_chain_case_Test
(MCJITMultipleModuleTest_three_module_chain_case_Test const &
); void operator=(MCJITMultipleModuleTest_three_module_chain_case_Test
const &);};::testing::TestInfo* const MCJITMultipleModuleTest_three_module_chain_case_Test
::test_info_ = ::testing::internal::MakeAndRegisterTestInfo(
"MCJITMultipleModuleTest", "three_module_chain_case", __null
, __null, (::testing::internal::GetTypeId<MCJITMultipleModuleTest
>()), MCJITMultipleModuleTest::SetUpTestCase, MCJITMultipleModuleTest
::TearDownTestCase, new ::testing::internal::TestFactoryImpl<
MCJITMultipleModuleTest_three_module_chain_case_Test>);void
MCJITMultipleModuleTest_three_module_chain_case_Test::TestBody
() {
288 SKIP_UNSUPPORTED_PLATFORMdo if (!ArchSupportsMCJIT() || !OSSupportsMCJIT()) return; while
(0);
289
290 std::unique_ptr<Module> A, B, C;
291 Function *FA, *FB, *FC;
292 createThreeModuleChainedCallsCase(A, FA, B, FB, C, FC);
293
294 createJIT(std::move(A));
295 TheJIT->addModule(std::move(B));
296 TheJIT->addModule(std::move(C));
297
298 uint64_t ptr = TheJIT->getFunctionAddress(FC->getName().str());
299 checkAdd(ptr);
300
301 ptr = TheJIT->getFunctionAddress(FB->getName().str());
302 checkAdd(ptr);
303
304 ptr = TheJIT->getFunctionAddress(FA->getName().str());
305 checkAdd(ptr);
306}
307
308// Module A { Function FA },
309// Module B { Extern FA, Function FB which calls FA },
310// Module C { Extern FB, Function FC which calls FB },
311// execute FA, FB, FC
312TEST_F(MCJITMultipleModuleTest, three_modules_chain_case_reverse_order)class MCJITMultipleModuleTest_three_modules_chain_case_reverse_order_Test
: public MCJITMultipleModuleTest { public: MCJITMultipleModuleTest_three_modules_chain_case_reverse_order_Test
() {} private: virtual void TestBody(); static ::testing::TestInfo
* const test_info_ __attribute__ ((unused)); MCJITMultipleModuleTest_three_modules_chain_case_reverse_order_Test
(MCJITMultipleModuleTest_three_modules_chain_case_reverse_order_Test
const &); void operator=(MCJITMultipleModuleTest_three_modules_chain_case_reverse_order_Test
const &);};::testing::TestInfo* const MCJITMultipleModuleTest_three_modules_chain_case_reverse_order_Test
::test_info_ = ::testing::internal::MakeAndRegisterTestInfo(
"MCJITMultipleModuleTest", "three_modules_chain_case_reverse_order"
, __null, __null, (::testing::internal::GetTypeId<MCJITMultipleModuleTest
>()), MCJITMultipleModuleTest::SetUpTestCase, MCJITMultipleModuleTest
::TearDownTestCase, new ::testing::internal::TestFactoryImpl<
MCJITMultipleModuleTest_three_modules_chain_case_reverse_order_Test
>);void MCJITMultipleModuleTest_three_modules_chain_case_reverse_order_Test
::TestBody() {
313 SKIP_UNSUPPORTED_PLATFORMdo if (!ArchSupportsMCJIT() || !OSSupportsMCJIT()) return; while
(0);
314
315 std::unique_ptr<Module> A, B, C;
316 Function *FA, *FB, *FC;
317 createThreeModuleChainedCallsCase(A, FA, B, FB, C, FC);
318
319 createJIT(std::move(A));
320 TheJIT->addModule(std::move(B));
321 TheJIT->addModule(std::move(C));
322
323 uint64_t ptr = TheJIT->getFunctionAddress(FA->getName().str());
324 checkAdd(ptr);
325
326 ptr = TheJIT->getFunctionAddress(FB->getName().str());
327 checkAdd(ptr);
328
329 ptr = TheJIT->getFunctionAddress(FC->getName().str());
330 checkAdd(ptr);
331}
332
333// Module A { Extern FB, Function FA which calls FB1 },
334// Module B { Extern FA, Function FB1, Function FB2 which calls FA },
335// execute FA, then FB1
336// FIXME: this test case is not supported by MCJIT
337TEST_F(MCJITMultipleModuleTest, cross_module_dependency_case)class MCJITMultipleModuleTest_cross_module_dependency_case_Test
: public MCJITMultipleModuleTest { public: MCJITMultipleModuleTest_cross_module_dependency_case_Test
() {} private: virtual void TestBody(); static ::testing::TestInfo
* const test_info_ __attribute__ ((unused)); MCJITMultipleModuleTest_cross_module_dependency_case_Test
(MCJITMultipleModuleTest_cross_module_dependency_case_Test const
&); void operator=(MCJITMultipleModuleTest_cross_module_dependency_case_Test
const &);};::testing::TestInfo* const MCJITMultipleModuleTest_cross_module_dependency_case_Test
::test_info_ = ::testing::internal::MakeAndRegisterTestInfo(
"MCJITMultipleModuleTest", "cross_module_dependency_case", __null
, __null, (::testing::internal::GetTypeId<MCJITMultipleModuleTest
>()), MCJITMultipleModuleTest::SetUpTestCase, MCJITMultipleModuleTest
::TearDownTestCase, new ::testing::internal::TestFactoryImpl<
MCJITMultipleModuleTest_cross_module_dependency_case_Test>
);void MCJITMultipleModuleTest_cross_module_dependency_case_Test
::TestBody() {
338 SKIP_UNSUPPORTED_PLATFORMdo if (!ArchSupportsMCJIT() || !OSSupportsMCJIT()) return; while
(0);
339
340 std::unique_ptr<Module> A, B;
341 Function *FA, *FB1, *FB2;
342 createCrossModuleRecursiveCase(A, FA, B, FB1, FB2);
343
344 createJIT(std::move(A));
345 TheJIT->addModule(std::move(B));
346
347 uint64_t ptr = TheJIT->getFunctionAddress(FA->getName().str());
348 checkAccumulate(ptr);
349
350 ptr = TheJIT->getFunctionAddress(FB1->getName().str());
351 checkAccumulate(ptr);
352}
353
354// Module A { Extern FB, Function FA which calls FB1 },
355// Module B { Extern FA, Function FB1, Function FB2 which calls FA },
356// execute FB1 then FA
357// FIXME: this test case is not supported by MCJIT
358TEST_F(MCJITMultipleModuleTest, cross_module_dependency_case_reverse_order)class MCJITMultipleModuleTest_cross_module_dependency_case_reverse_order_Test
: public MCJITMultipleModuleTest { public: MCJITMultipleModuleTest_cross_module_dependency_case_reverse_order_Test
() {} private: virtual void TestBody(); static ::testing::TestInfo
* const test_info_ __attribute__ ((unused)); MCJITMultipleModuleTest_cross_module_dependency_case_reverse_order_Test
(MCJITMultipleModuleTest_cross_module_dependency_case_reverse_order_Test
const &); void operator=(MCJITMultipleModuleTest_cross_module_dependency_case_reverse_order_Test
const &);};::testing::TestInfo* const MCJITMultipleModuleTest_cross_module_dependency_case_reverse_order_Test
::test_info_ = ::testing::internal::MakeAndRegisterTestInfo(
"MCJITMultipleModuleTest", "cross_module_dependency_case_reverse_order"
, __null, __null, (::testing::internal::GetTypeId<MCJITMultipleModuleTest
>()), MCJITMultipleModuleTest::SetUpTestCase, MCJITMultipleModuleTest
::TearDownTestCase, new ::testing::internal::TestFactoryImpl<
MCJITMultipleModuleTest_cross_module_dependency_case_reverse_order_Test
>);void MCJITMultipleModuleTest_cross_module_dependency_case_reverse_order_Test
::TestBody() {
359 SKIP_UNSUPPORTED_PLATFORMdo if (!ArchSupportsMCJIT() || !OSSupportsMCJIT()) return; while
(0);
360
361 std::unique_ptr<Module> A, B;
362 Function *FA, *FB1, *FB2;
363 createCrossModuleRecursiveCase(A, FA, B, FB1, FB2);
364
365 createJIT(std::move(A));
366 TheJIT->addModule(std::move(B));
367
368 uint64_t ptr = TheJIT->getFunctionAddress(FB1->getName().str());
369 checkAccumulate(ptr);
370
371 ptr = TheJIT->getFunctionAddress(FA->getName().str());
372 checkAccumulate(ptr);
373}
374
375// Module A { Extern FB1, Function FA which calls FB1 },
376// Module B { Extern FA, Function FB1, Function FB2 which calls FA },
377// execute FB1 then FB2
378// FIXME: this test case is not supported by MCJIT
379TEST_F(MCJITMultipleModuleTest, cross_module_dependency_case3)class MCJITMultipleModuleTest_cross_module_dependency_case3_Test
: public MCJITMultipleModuleTest { public: MCJITMultipleModuleTest_cross_module_dependency_case3_Test
() {} private: virtual void TestBody(); static ::testing::TestInfo
* const test_info_ __attribute__ ((unused)); MCJITMultipleModuleTest_cross_module_dependency_case3_Test
(MCJITMultipleModuleTest_cross_module_dependency_case3_Test const
&); void operator=(MCJITMultipleModuleTest_cross_module_dependency_case3_Test
const &);};::testing::TestInfo* const MCJITMultipleModuleTest_cross_module_dependency_case3_Test
::test_info_ = ::testing::internal::MakeAndRegisterTestInfo(
"MCJITMultipleModuleTest", "cross_module_dependency_case3", __null
, __null, (::testing::internal::GetTypeId<MCJITMultipleModuleTest
>()), MCJITMultipleModuleTest::SetUpTestCase, MCJITMultipleModuleTest
::TearDownTestCase, new ::testing::internal::TestFactoryImpl<
MCJITMultipleModuleTest_cross_module_dependency_case3_Test>
);void MCJITMultipleModuleTest_cross_module_dependency_case3_Test
::TestBody() {
380 SKIP_UNSUPPORTED_PLATFORMdo if (!ArchSupportsMCJIT() || !OSSupportsMCJIT()) return; while
(0);
381
382 std::unique_ptr<Module> A, B;
383 Function *FA, *FB1, *FB2;
384 createCrossModuleRecursiveCase(A, FA, B, FB1, FB2);
385
386 createJIT(std::move(A));
387 TheJIT->addModule(std::move(B));
388
389 uint64_t ptr = TheJIT->getFunctionAddress(FB1->getName().str());
390 checkAccumulate(ptr);
391
392 ptr = TheJIT->getFunctionAddress(FB2->getName().str());
393 checkAccumulate(ptr);
394}
395
396// Test that FindFunctionNamed finds the definition of
397// a function in the correct module. We check two functions
398// in two different modules, to make sure that for at least
399// one of them MCJIT had to ignore the extern declaration.
400TEST_F(MCJITMultipleModuleTest, FindFunctionNamed_test)class MCJITMultipleModuleTest_FindFunctionNamed_test_Test : public
MCJITMultipleModuleTest { public: MCJITMultipleModuleTest_FindFunctionNamed_test_Test
() {} private: virtual void TestBody(); static ::testing::TestInfo
* const test_info_ __attribute__ ((unused)); MCJITMultipleModuleTest_FindFunctionNamed_test_Test
(MCJITMultipleModuleTest_FindFunctionNamed_test_Test const &
); void operator=(MCJITMultipleModuleTest_FindFunctionNamed_test_Test
const &);};::testing::TestInfo* const MCJITMultipleModuleTest_FindFunctionNamed_test_Test
::test_info_ = ::testing::internal::MakeAndRegisterTestInfo(
"MCJITMultipleModuleTest", "FindFunctionNamed_test", __null,
__null, (::testing::internal::GetTypeId<MCJITMultipleModuleTest
>()), MCJITMultipleModuleTest::SetUpTestCase, MCJITMultipleModuleTest
::TearDownTestCase, new ::testing::internal::TestFactoryImpl<
MCJITMultipleModuleTest_FindFunctionNamed_test_Test>);void
MCJITMultipleModuleTest_FindFunctionNamed_test_Test::TestBody
() {
401 SKIP_UNSUPPORTED_PLATFORMdo if (!ArchSupportsMCJIT() || !OSSupportsMCJIT()) return; while
(0);
402
403 std::unique_ptr<Module> A, B;
404 Function *FA, *FB1, *FB2;
405 createCrossModuleRecursiveCase(A, FA, B, FB1, FB2);
406
407 createJIT(std::move(A));
408 TheJIT->addModule(std::move(B));
409
410 EXPECT_EQ(FA, TheJIT->FindFunctionNamed(FA->getName().data()))switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar = (::testing::internal:: EqHelper<(sizeof(::testing
::internal::IsNullLiteralHelper(FA)) == 1)>::Compare("FA",
"TheJIT->FindFunctionNamed(FA->getName().data())", FA,
TheJIT->FindFunctionNamed(FA->getName().data())))) ; else
::testing::internal::AssertHelper(::testing::TestPartResult::
kNonFatalFailure, "/tmp/buildd/llvm-toolchain-snapshot-3.7~svn239931/unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp"
, 410, gtest_ar.failure_message()) = ::testing::Message();
411 EXPECT_EQ(FB1, TheJIT->FindFunctionNamed(FB1->getName().data()))switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar = (::testing::internal:: EqHelper<(sizeof(::testing
::internal::IsNullLiteralHelper(FB1)) == 1)>::Compare("FB1"
, "TheJIT->FindFunctionNamed(FB1->getName().data())", FB1
, TheJIT->FindFunctionNamed(FB1->getName().data())))) ;
else ::testing::internal::AssertHelper(::testing::TestPartResult
::kNonFatalFailure, "/tmp/buildd/llvm-toolchain-snapshot-3.7~svn239931/unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp"
, 411, gtest_ar.failure_message()) = ::testing::Message();
412}
413
414}