//===----------------------------------------------------------------------===//
#include "llvm/ExecutionEngine/JIT.h"
-#include "llvm/Assembly/Parser.h"
+#include "llvm/AsmParser/Parser.h"
#include "llvm/ExecutionEngine/GenericValue.h"
#include "llvm/IR/LLVMContext.h"
#include "llvm/IR/Module.h"
namespace {
-// ARM and PowerPC tests disabled pending fix for PR10783.
-#if !defined(__arm__) && !defined(__powerpc__)
+// ARM, PowerPC and SystemZ tests disabled pending fix for PR10783.
+#if !defined(__arm__) && !defined(__powerpc__) && !defined(__s390__) \
+ && !defined(__aarch64__)
-bool LoadAssemblyInto(Module *M, const char *assembly) {
+std::unique_ptr<Module> loadAssembly(LLVMContext &Context,
+ const char *Assembly) {
SMDiagnostic Error;
- bool success =
- NULL != ParseAssemblyString(assembly, M, Error, M->getContext());
+ std::unique_ptr<Module> Ret = parseAssemblyString(Assembly, Error, Context);
std::string errMsg;
raw_string_ostream os(errMsg);
Error.print("", os);
- EXPECT_TRUE(success) << os.str();
- return success;
+ EXPECT_TRUE((bool)Ret) << os.str();
+ return std::move(Ret);
}
-void createModule1(LLVMContext &Context1, Module *&M1, Function *&FooF1) {
- M1 = new Module("test1", Context1);
- LoadAssemblyInto(M1,
+std::unique_ptr<Module> createModule1(LLVMContext &Context1, Function *&FooF1) {
+ std::unique_ptr<Module> Ret = loadAssembly(Context1,
"define i32 @add1(i32 %ArgX1) { "
"entry: "
" %addresult = add i32 1, %ArgX1 "
" %add1 = call i32 @add1(i32 10) "
" ret i32 %add1 "
"} ");
- FooF1 = M1->getFunction("foo1");
+ FooF1 = Ret->getFunction("foo1");
+ return std::move(Ret);
}
-void createModule2(LLVMContext &Context2, Module *&M2, Function *&FooF2) {
- M2 = new Module("test2", Context2);
- LoadAssemblyInto(M2,
+std::unique_ptr<Module> createModule2(LLVMContext &Context2, Function *&FooF2) {
+ std::unique_ptr<Module> Ret = loadAssembly(Context2,
"define i32 @add2(i32 %ArgX2) { "
"entry: "
" %addresult = add i32 2, %ArgX2 "
" %add2 = call i32 @add2(i32 10) "
" ret i32 %add2 "
"} ");
- FooF2 = M2->getFunction("foo2");
+ FooF2 = Ret->getFunction("foo2");
+ return std::move(Ret);
}
TEST(MultiJitTest, EagerMode) {
LLVMContext Context1;
- Module *M1 = 0;
- Function *FooF1 = 0;
- createModule1(Context1, M1, FooF1);
+ Function *FooF1 = nullptr;
+ std::unique_ptr<Module> M1 = createModule1(Context1, FooF1);
LLVMContext Context2;
- Module *M2 = 0;
- Function *FooF2 = 0;
- createModule2(Context2, M2, FooF2);
+ Function *FooF2 = nullptr;
+ std::unique_ptr<Module> M2 = createModule2(Context2, FooF2);
// Now we create the JIT in eager mode
- OwningPtr<ExecutionEngine> EE1(EngineBuilder(M1).create());
+ std::unique_ptr<ExecutionEngine> EE1(EngineBuilder(std::move(M1)).create());
EE1->DisableLazyCompilation(true);
- OwningPtr<ExecutionEngine> EE2(EngineBuilder(M2).create());
+ std::unique_ptr<ExecutionEngine> EE2(EngineBuilder(std::move(M2)).create());
EE2->DisableLazyCompilation(true);
// Call the `foo' function with no arguments:
TEST(MultiJitTest, LazyMode) {
LLVMContext Context1;
- Module *M1 = 0;
- Function *FooF1 = 0;
- createModule1(Context1, M1, FooF1);
+ Function *FooF1 = nullptr;
+ std::unique_ptr<Module> M1 = createModule1(Context1, FooF1);
LLVMContext Context2;
- Module *M2 = 0;
- Function *FooF2 = 0;
- createModule2(Context2, M2, FooF2);
+ Function *FooF2 = nullptr;
+ std::unique_ptr<Module> M2 = createModule2(Context2, FooF2);
// Now we create the JIT in lazy mode
- OwningPtr<ExecutionEngine> EE1(EngineBuilder(M1).create());
+ std::unique_ptr<ExecutionEngine> EE1(EngineBuilder(std::move(M1)).create());
EE1->DisableLazyCompilation(false);
- OwningPtr<ExecutionEngine> EE2(EngineBuilder(M2).create());
+ std::unique_ptr<ExecutionEngine> EE2(EngineBuilder(std::move(M2)).create());
EE2->DisableLazyCompilation(false);
// Call the `foo' function with no arguments:
TEST(MultiJitTest, JitPool) {
LLVMContext Context1;
- Module *M1 = 0;
- Function *FooF1 = 0;
- createModule1(Context1, M1, FooF1);
+ Function *FooF1 = nullptr;
+ std::unique_ptr<Module> M1 = createModule1(Context1, FooF1);
LLVMContext Context2;
- Module *M2 = 0;
- Function *FooF2 = 0;
- createModule2(Context2, M2, FooF2);
+ Function *FooF2 = nullptr;
+ std::unique_ptr<Module> M2 = createModule2(Context2, FooF2);
// Now we create two JITs
- OwningPtr<ExecutionEngine> EE1(EngineBuilder(M1).create());
- OwningPtr<ExecutionEngine> EE2(EngineBuilder(M2).create());
+ std::unique_ptr<ExecutionEngine> EE1(EngineBuilder(std::move(M1)).create());
+ std::unique_ptr<ExecutionEngine> EE2(EngineBuilder(std::move(M2)).create());
Function *F1 = EE1->FindFunctionNamed("foo1");
void *foo1 = EE1->getPointerToFunction(F1);
EXPECT_TRUE(fa != 0);
fa = *(intptr_t *)fa; // Bound value of IAT
}
+#elif defined(__x86_64__)
+ // getPointerToNamedFunction might be indirect jump
+ // on Win32 x64 --enable-shared.
+ // FF 25 <pcrel32>: jmp *(RIP + pointer to IAT)
+ if (sa != fa && memcmp((char *)fa, "\xFF\x25", 2) == 0) {
+ fa += *(int32_t *)(fa + 2) + 6; // Address to IAT(RIP)
+ fa = *(intptr_t *)fa; // Bound value of IAT
+ }
#endif
EXPECT_TRUE(sa == fa);
}
-#endif // !defined(__arm__) && !defined(__powerpc__)
+#endif // !defined(__arm__) && !defined(__powerpc__) && !defined(__s390__)
} // anonymous namespace