RPCS3/llvm
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm.git synced 2024-11-30 23:21:04 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Alternative fix for problem addressed in r182233

Browse Source 
Revision r182233 partially reverted the change in r181200 to simplify
JIT unif test #ifdefs, because that change caused a link error on some
host operating systems where the export list requires the following
symbols to be defined:

 JITTest_AvailableExternallyFunction
 JITTest_AvailableExternallyGlobal

As discussed on the list, the commit reverts r182233 (and re-installs
the full r181200 change), and instead fixes the link problem by moving
those two symbols to the top of the file and unconditionally defining
them.



git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@182367 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Ulrich Weigand 2013-05-21 10:30:59 +00:00
parent f106d8bad6
commit e3658a26b5
1 changed files with 19 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

61
unittests/ExecutionEngine/JIT/JITTest.cpp
View File

@ -33,10 +33,26 @@
using namespace llvm;
// This variable is intentionally defined differently in the statically-compiled
// program from the IR input to the JIT to assert that the JIT doesn't use its
// definition. Note that this variable must be defined even on platforms where
// JIT tests are disabled as it is referenced from the .def file.
extern "C" int32_t JITTest_AvailableExternallyGlobal;
int32_t JITTest_AvailableExternallyGlobal LLVM_ATTRIBUTE_USED = 42;
// This function is intentionally defined differently in the statically-compiled
// program from the IR input to the JIT to assert that the JIT doesn't use its
// definition. Note that this function must be defined even on platforms where
// JIT tests are disabled as it is referenced from the .def file.
extern "C" int32_t JITTest_AvailableExternallyFunction() LLVM_ATTRIBUTE_USED;
extern "C" int32_t JITTest_AvailableExternallyFunction() {
return 42;
}
namespace {
// Tests on PowerPC and SystemZ disabled as we're running the old jit
#if !defined(__powerpc__) && !defined(__s390__)
// Tests on ARM, PowerPC and SystemZ disabled as we're running the old jit
#if !defined(__arm__) && !defined(__powerpc__) && !defined(__s390__)
Function *makeReturnGlobal(std::string Name, GlobalVariable *G, Module *M) {
std::vector<Type*> params;
@ -185,9 +201,6 @@ class JITTest : public testing::Test {
OwningPtr<ExecutionEngine> TheJIT;
};
// Tests on ARM disabled as we're running the old jit
#if !defined(__arm__)
// Regression test for a bug. The JIT used to allocate globals inside the same
// memory block used for the function, and when the function code was freed,
// the global was left in the same place. This test allocates a function
@ -256,11 +269,6 @@ TEST(JIT, GlobalInFunction) {
EXPECT_EQ(3, *GPtr);
}
#endif // !defined(__arm__)
// ARM tests disabled pending fix for PR10783.
#if !defined(__arm__)
int PlusOne(int arg) {
return arg + 1;
}
@ -421,7 +429,6 @@ TEST_F(JITTest, ModuleDeletion) {
EXPECT_EQ(RJMM->startFunctionBodyCalls.size(),
RJMM->deallocateFunctionBodyCalls.size());
}
#endif // !defined(__arm__)
// ARM, MIPS and PPC still emit stubs for calls since the target may be
// too far away to call directly. This #if can probably be removed when
@ -467,9 +474,6 @@ TEST_F(JITTest, NoStubs) {
}
#endif // !ARM && !PPC
// Tests on ARM disabled as we're running the old jit
#if !defined(__arm__)
TEST_F(JITTest, FunctionPointersOutliveTheirCreator) {
TheJIT->DisableLazyCompilation(true);
LoadAssembly("define i8()* @get_foo_addr() { "
@ -504,9 +508,6 @@ TEST_F(JITTest, FunctionPointersOutliveTheirCreator) {
#endif
}
#endif //!defined(__arm__)
// Tests on ARM disabled as we're running the old jit. In addition,
// ARM does not have an implementation of replaceMachineCodeForFunction(),
// so recompileAndRelinkFunction doesn't work.
#if !defined(__arm__)
@ -542,17 +543,6 @@ TEST_F(JITTest, FunctionIsRecompiledAndRelinked) {
}
#endif // !defined(__arm__)
} // anonymous namespace
// This variable is intentionally defined differently in the statically-compiled
// program from the IR input to the JIT to assert that the JIT doesn't use its
// definition.
extern "C" int32_t JITTest_AvailableExternallyGlobal;
int32_t JITTest_AvailableExternallyGlobal LLVM_ATTRIBUTE_USED = 42;
namespace {
// Tests on ARM disabled as we're running the old jit
#if !defined(__arm__)
TEST_F(JITTest, AvailableExternallyGlobalIsntEmitted) {
TheJIT->DisableLazyCompilation(true);
LoadAssembly("@JITTest_AvailableExternallyGlobal = "
@ -569,19 +559,7 @@ TEST_F(JITTest, AvailableExternallyGlobalIsntEmitted) {
EXPECT_EQ(42, loader()) << "func should return 42 from the external global,"
<< " not 7 from the IR version.";
}
#endif //!defined(__arm__)
} // anonymous namespace
// This function is intentionally defined differently in the statically-compiled
// program from the IR input to the JIT to assert that the JIT doesn't use its
// definition.
extern "C" int32_t JITTest_AvailableExternallyFunction() LLVM_ATTRIBUTE_USED;
extern "C" int32_t JITTest_AvailableExternallyFunction() {
return 42;
}
namespace {
// ARM tests disabled pending fix for PR10783.
#if !defined(__arm__)
TEST_F(JITTest, AvailableExternallyFunctionIsntCompiled) {
TheJIT->DisableLazyCompilation(true);
LoadAssembly("define available_externally i32 "
@ -737,8 +715,7 @@ TEST(LazyLoadedJITTest, EagerCompiledRecursionThroughGhost) {
(intptr_t)TheJIT->getPointerToFunction(recur1IR));
EXPECT_EQ(3, recur1(4));
}
#endif // !defined(__arm__)
#endif // !defined(__powerpc__) && !defined(__s390__)
#endif // !defined(__arm__) && !defined(__powerpc__) && !defined(__s390__)
// This code is copied from JITEventListenerTest, but it only runs once for all
// the tests in this directory. Everything seems fine, but that's strange