Bug Summary

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

Annotated Source Code

1//===- MCJITMultipeModuleTest.cpp - Unit tests for the MCJIT ----*- C++ -*-===//
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.8~svn257205/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.8~svn257205/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.8~svn257205/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.8~svn257205/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.8~svn257205/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.8~svn257205/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.8~svn257205/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.8~svn257205/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.8~svn257205/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.8~svn257205/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.8~svn257205/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.8~svn257205/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.8~svn257205/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.8~svn257205/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.8~svn257205/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, Internal Global GVC, Function FB loads GVB },
198// execute FB then FA, also check that the global variables are properly accesible
199// through the ExecutionEngine APIs
200TEST_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() {
201 SKIP_UNSUPPORTED_PLATFORMdo if (!ArchSupportsMCJIT() || !OSSupportsMCJIT()) return; while
(0);
202
203 std::unique_ptr<Module> A, B;
204 Function *FA, *FB;
205 GlobalVariable *GVA, *GVB, *GVC;
206 A.reset(createEmptyModule("A"));
207 B.reset(createEmptyModule("B"));
208
209 int32_t initialNum = 7;
210 GVA = insertGlobalInt32(A.get(), "GVA", initialNum);
211 GVB = insertGlobalInt32(B.get(), "GVB", initialNum);
212 FA = startFunction<int32_t(void)>(A.get(), "FA");
213 endFunctionWithRet(FA, Builder.CreateLoad(GVA));
214 FB = startFunction<int32_t(void)>(B.get(), "FB");
215 endFunctionWithRet(FB, Builder.CreateLoad(GVB));
216
217 GVC = insertGlobalInt32(B.get(), "GVC", initialNum);
218 GVC->setLinkage(GlobalValue::InternalLinkage);
219
220 createJIT(std::move(A));
221 TheJIT->addModule(std::move(B));
222
223 EXPECT_EQ(GVA, TheJIT->FindGlobalVariableNamed("GVA"))switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar = (::testing::internal:: EqHelper<(sizeof(::testing
::internal::IsNullLiteralHelper(GVA)) == 1)>::Compare("GVA"
, "TheJIT->FindGlobalVariableNamed(\"GVA\")", GVA, TheJIT->
FindGlobalVariableNamed("GVA")))) ; else ::testing::internal::
AssertHelper(::testing::TestPartResult::kNonFatalFailure, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn257205/unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp"
, 223, gtest_ar.failure_message()) = ::testing::Message();
224 EXPECT_EQ(GVB, TheJIT->FindGlobalVariableNamed("GVB"))switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar = (::testing::internal:: EqHelper<(sizeof(::testing
::internal::IsNullLiteralHelper(GVB)) == 1)>::Compare("GVB"
, "TheJIT->FindGlobalVariableNamed(\"GVB\")", GVB, TheJIT->
FindGlobalVariableNamed("GVB")))) ; else ::testing::internal::
AssertHelper(::testing::TestPartResult::kNonFatalFailure, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn257205/unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp"
, 224, gtest_ar.failure_message()) = ::testing::Message();
225 EXPECT_EQ(GVC, TheJIT->FindGlobalVariableNamed("GVC",true))switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar = (::testing::internal:: EqHelper<(sizeof(::testing
::internal::IsNullLiteralHelper(GVC)) == 1)>::Compare("GVC"
, "TheJIT->FindGlobalVariableNamed(\"GVC\",true)", GVC, TheJIT
->FindGlobalVariableNamed("GVC",true)))) ; else ::testing::
internal::AssertHelper(::testing::TestPartResult::kNonFatalFailure
, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn257205/unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp"
, 225, gtest_ar.failure_message()) = ::testing::Message();
226 EXPECT_EQ(nullptr, TheJIT->FindGlobalVariableNamed("GVC"))switch (0) case 0: default: if (const ::testing::AssertionResult
gtest_ar = (::testing::internal:: EqHelper<(sizeof(::testing
::internal::IsNullLiteralHelper(nullptr)) == 1)>::Compare(
"nullptr", "TheJIT->FindGlobalVariableNamed(\"GVC\")", nullptr
, TheJIT->FindGlobalVariableNamed("GVC")))) ; else ::testing
::internal::AssertHelper(::testing::TestPartResult::kNonFatalFailure
, "/tmp/buildd/llvm-toolchain-snapshot-3.8~svn257205/unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp"
, 226, gtest_ar.failure_message()) = ::testing::Message();
227
228 uint64_t FBPtr = TheJIT->getFunctionAddress(FB->getName().str());
229 TheJIT->finalizeObject();
230 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.8~svn257205/unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp"
, 230, ::testing::internal::GetBoolAssertionFailureMessage( gtest_ar_
, "0 != FBPtr", "false", "true").c_str()) = ::testing::Message
();
231 int32_t(*FuncPtr)() = (int32_t(*)())FBPtr;
232 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.8~svn257205/unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp"
, 232, gtest_ar.failure_message()) = ::testing::Message()
233 << "Invalid value for global returned from JITted function in module B";
234
235 uint64_t FAPtr = TheJIT->getFunctionAddress(FA->getName().str());
1
'FAPtr' initialized here
→
236 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.8~svn257205/unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp"
, 236, ::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
237 FuncPtr = (int32_t(*)())FAPtr;
3
←
Null pointer value stored to 'FuncPtr'
→
238 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.8~svn257205/unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp"
, 238, gtest_ar.failure_message()) = ::testing::Message()
4
←
Within the expansion of the macro 'EXPECT_EQ':
a
Called function pointer is null (null dereference)
239 << "Invalid value for global returned from JITted function in module A";
240}
241
242// Module A { Function FA },
243// Module B { Extern FA, Function FB which calls FA },
244// Module C { Extern FA, Function FC which calls FA },
245// execute FC, FB, FA
246TEST_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() {
247 SKIP_UNSUPPORTED_PLATFORMdo if (!ArchSupportsMCJIT() || !OSSupportsMCJIT()) return; while
(0);
248
249 std::unique_ptr<Module> A, B, C;
250 Function *FA, *FB, *FC;
251 createThreeModuleCase(A, FA, B, FB, C, FC);
252
253 createJIT(std::move(A));
254 TheJIT->addModule(std::move(B));
255 TheJIT->addModule(std::move(C));
256
257 uint64_t ptr = TheJIT->getFunctionAddress(FC->getName().str());
258 checkAdd(ptr);
259
260 ptr = TheJIT->getFunctionAddress(FB->getName().str());
261 checkAdd(ptr);
262
263 ptr = TheJIT->getFunctionAddress(FA->getName().str());
264 checkAdd(ptr);
265}
266
267// Module A { Function FA },
268// Module B { Extern FA, Function FB which calls FA },
269// Module C { Extern FA, Function FC which calls FA },
270// execute FA, FB, FC
271TEST_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() {
272 SKIP_UNSUPPORTED_PLATFORMdo if (!ArchSupportsMCJIT() || !OSSupportsMCJIT()) return; while
(0);
273
274 std::unique_ptr<Module> A, B, C;
275 Function *FA, *FB, *FC;
276 createThreeModuleCase(A, FA, B, FB, C, FC);
277
278 createJIT(std::move(A));
279 TheJIT->addModule(std::move(B));
280 TheJIT->addModule(std::move(C));
281
282 uint64_t ptr = TheJIT->getFunctionAddress(FA->getName().str());
283 checkAdd(ptr);
284
285 ptr = TheJIT->getFunctionAddress(FB->getName().str());
286 checkAdd(ptr);
287
288 ptr = TheJIT->getFunctionAddress(FC->getName().str());
289 checkAdd(ptr);
290}
291
292// Module A { Function FA },
293// Module B { Extern FA, Function FB which calls FA },
294// Module C { Extern FB, Function FC which calls FB },
295// execute FC, FB, FA
296TEST_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
() {
297 SKIP_UNSUPPORTED_PLATFORMdo if (!ArchSupportsMCJIT() || !OSSupportsMCJIT()) return; while
(0);
298
299 std::unique_ptr<Module> A, B, C;
300 Function *FA, *FB, *FC;
301 createThreeModuleChainedCallsCase(A, FA, B, FB, C, FC);
302
303 createJIT(std::move(A));
304 TheJIT->addModule(std::move(B));
305 TheJIT->addModule(std::move(C));
306
307 uint64_t ptr = TheJIT->getFunctionAddress(FC->getName().str());
308 checkAdd(ptr);
309
310 ptr = TheJIT->getFunctionAddress(FB->getName().str());
311 checkAdd(ptr);
312
313 ptr = TheJIT->getFunctionAddress(FA->getName().str());
314 checkAdd(ptr);
315}
316
317// Module A { Function FA },
318// Module B { Extern FA, Function FB which calls FA },
319// Module C { Extern FB, Function FC which calls FB },
320// execute FA, FB, FC
321TEST_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() {
322 SKIP_UNSUPPORTED_PLATFORMdo if (!ArchSupportsMCJIT() || !OSSupportsMCJIT()) return; while
(0);
323
324 std::unique_ptr<Module> A, B, C;
325 Function *FA, *FB, *FC;
326 createThreeModuleChainedCallsCase(A, FA, B, FB, C, FC);
327
328 createJIT(std::move(A));
329 TheJIT->addModule(std::move(B));
330 TheJIT->addModule(std::move(C));
331
332 uint64_t ptr = TheJIT->getFunctionAddress(FA->getName().str());
333 checkAdd(ptr);
334
335 ptr = TheJIT->getFunctionAddress(FB->getName().str());
336 checkAdd(ptr);
337
338 ptr = TheJIT->getFunctionAddress(FC->getName().str());
339 checkAdd(ptr);
340}
341
342// Module A { Extern FB, Function FA which calls FB1 },
343// Module B { Extern FA, Function FB1, Function FB2 which calls FA },
344// execute FA, then FB1
345// FIXME: this test case is not supported by MCJIT
346TEST_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() {
347 SKIP_UNSUPPORTED_PLATFORMdo if (!ArchSupportsMCJIT() || !OSSupportsMCJIT()) return; while
(0);
348
349 std::unique_ptr<Module> A, B;
350 Function *FA, *FB1, *FB2;
351 createCrossModuleRecursiveCase(A, FA, B, FB1, FB2);
352
353 createJIT(std::move(A));
354 TheJIT->addModule(std::move(B));
355
356 uint64_t ptr = TheJIT->getFunctionAddress(FA->getName().str());
357 checkAccumulate(ptr);
358
359 ptr = TheJIT->getFunctionAddress(FB1->getName().str());
360 checkAccumulate(ptr);
361}
362
363// Module A { Extern FB, Function FA which calls FB1 },
364// Module B { Extern FA, Function FB1, Function FB2 which calls FA },
365// execute FB1 then FA
366// FIXME: this test case is not supported by MCJIT
367TEST_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() {
368 SKIP_UNSUPPORTED_PLATFORMdo if (!ArchSupportsMCJIT() || !OSSupportsMCJIT()) return; while
(0);
369
370 std::unique_ptr<Module> A, B;
371 Function *FA, *FB1, *FB2;
372 createCrossModuleRecursiveCase(A, FA, B, FB1, FB2);
373
374 createJIT(std::move(A));
375 TheJIT->addModule(std::move(B));
376
377 uint64_t ptr = TheJIT->getFunctionAddress(FB1->getName().str());
378 checkAccumulate(ptr);
379
380 ptr = TheJIT->getFunctionAddress(FA->getName().str());
381 checkAccumulate(ptr);
382}
383
384// Module A { Extern FB1, Function FA which calls FB1 },
385// Module B { Extern FA, Function FB1, Function FB2 which calls FA },
386// execute FB1 then FB2
387// FIXME: this test case is not supported by MCJIT
388TEST_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() {
389 SKIP_UNSUPPORTED_PLATFORMdo if (!ArchSupportsMCJIT() || !OSSupportsMCJIT()) return; while
(0);
390
391 std::unique_ptr<Module> A, B;
392 Function *FA, *FB1, *FB2;
393 createCrossModuleRecursiveCase(A, FA, B, FB1, FB2);
394
395 createJIT(std::move(A));
396 TheJIT->addModule(std::move(B));
397
398 uint64_t ptr = TheJIT->getFunctionAddress(FB1->getName().str());
399 checkAccumulate(ptr);
400
401 ptr = TheJIT->getFunctionAddress(FB2->getName().str());
402 checkAccumulate(ptr);
403}
404
405// Test that FindFunctionNamed finds the definition of
406// a function in the correct module. We check two functions
407// in two different modules, to make sure that for at least
408// one of them MCJIT had to ignore the extern declaration.
409TEST_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
() {
410 SKIP_UNSUPPORTED_PLATFORMdo if (!ArchSupportsMCJIT() || !OSSupportsMCJIT()) return; while
(0);
411
412 std::unique_ptr<Module> A, B;
413 Function *FA, *FB1, *FB2;
414 createCrossModuleRecursiveCase(A, FA, B, FB1, FB2);
415
416 createJIT(std::move(A));
417 TheJIT->addModule(std::move(B));
418
419 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.8~svn257205/unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp"
, 419, gtest_ar.failure_message()) = ::testing::Message();
420 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.8~svn257205/unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp"
, 420, gtest_ar.failure_message()) = ::testing::Message();
421}
422
423} // end anonymous namespace