mirror of
https://github.com/RPCS3/llvm-mirror.git
synced 2024-11-25 20:23:11 +01:00
fceb425485
This will allow trampoline pools to be re-used for a new lazy-reexport utility that generates looks up function bodies using the standard symbol lookup process (rather than using a user provided compile function). This new utility provides the same capabilities (since MaterializationUnits already allow user supplied compile functions to be run) as JITCompileCallbackManager, but can use the new asynchronous lookup functions to avoid blocking a compile thread. This patch also updates createLocalCompileCallbackManager to return an error if a callback manager can not be created, and updates clients of that API to account for the change. Finally, the OrcCBindingsStack is updates so that if a callback manager is not available for the target platform a valid stack (without support for lazy compilation) can still be constructed. llvm-svn: 343059
90 lines
2.7 KiB
C++
90 lines
2.7 KiB
C++
//===----- CompileOnDemandLayerTest.cpp - Unit tests for the COD layer ----===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h"
|
|
#include "OrcTestCommon.h"
|
|
#include "gtest/gtest.h"
|
|
|
|
using namespace llvm;
|
|
using namespace llvm::orc;
|
|
|
|
namespace {
|
|
|
|
class DummyTrampolinePool : public orc::TrampolinePool {
|
|
public:
|
|
Expected<JITTargetAddress> getTrampoline() {
|
|
llvm_unreachable("Unimplemented");
|
|
}
|
|
};
|
|
|
|
class DummyCallbackManager : public JITCompileCallbackManager {
|
|
public:
|
|
DummyCallbackManager(ExecutionSession &ES)
|
|
: JITCompileCallbackManager(llvm::make_unique<DummyTrampolinePool>(), ES,
|
|
0) {}
|
|
};
|
|
|
|
class DummyStubsManager : public orc::IndirectStubsManager {
|
|
public:
|
|
Error createStub(StringRef StubName, JITTargetAddress InitAddr,
|
|
JITSymbolFlags Flags) override {
|
|
llvm_unreachable("Not implemented");
|
|
}
|
|
|
|
Error createStubs(const StubInitsMap &StubInits) override {
|
|
llvm_unreachable("Not implemented");
|
|
}
|
|
|
|
JITEvaluatedSymbol findStub(StringRef Name, bool ExportedStubsOnly) override {
|
|
llvm_unreachable("Not implemented");
|
|
}
|
|
|
|
JITEvaluatedSymbol findPointer(StringRef Name) override {
|
|
llvm_unreachable("Not implemented");
|
|
}
|
|
|
|
Error updatePointer(StringRef Name, JITTargetAddress NewAddr) override {
|
|
llvm_unreachable("Not implemented");
|
|
}
|
|
};
|
|
|
|
TEST(CompileOnDemandLayerTest, FindSymbol) {
|
|
MockBaseLayer<int, std::shared_ptr<Module>> TestBaseLayer;
|
|
TestBaseLayer.findSymbolImpl =
|
|
[](const std::string &Name, bool) {
|
|
if (Name == "foo")
|
|
return JITSymbol(1, JITSymbolFlags::Exported);
|
|
return JITSymbol(nullptr);
|
|
};
|
|
|
|
|
|
ExecutionSession ES(std::make_shared<SymbolStringPool>());
|
|
DummyCallbackManager CallbackMgr(ES);
|
|
|
|
auto GetResolver =
|
|
[](orc::VModuleKey) -> std::shared_ptr<llvm::orc::SymbolResolver> {
|
|
llvm_unreachable("Should never be called");
|
|
};
|
|
|
|
auto SetResolver = [](orc::VModuleKey, std::shared_ptr<orc::SymbolResolver>) {
|
|
llvm_unreachable("Should never be called");
|
|
};
|
|
|
|
llvm::orc::CompileOnDemandLayer<decltype(TestBaseLayer)> COD(
|
|
ES, TestBaseLayer, GetResolver, SetResolver,
|
|
[](Function &F) { return std::set<Function *>{&F}; }, CallbackMgr,
|
|
[] { return llvm::make_unique<DummyStubsManager>(); }, true);
|
|
|
|
auto Sym = COD.findSymbol("foo", true);
|
|
|
|
EXPECT_TRUE(!!Sym) << "CompileOnDemand::findSymbol should call findSymbol in "
|
|
"the base layer.";
|
|
}
|
|
}
|