[ORC] Add a "lazy call-through" utility based on the same underlying trampoline
implementation as lazy compile callbacks, and a "lazy re-exports" utility that
builds lazy call-throughs.
Lazy call-throughs are similar to lazy compile callbacks (and are based on the
same underlying state saving/restoring trampolines) but resolve their targets
by performing a standard ORC lookup rather than invoking a user supplied
compiler callback. This allows them to inherit the thread-safety of ORC lookups
while blocking only the calling thread (whereas compile callbacks also block one
compile thread).
Lazy re-exports provide a simple way of building lazy call-throughs. Unlike a
regular re-export, a lazy re-export generates a new address (a stub entry point)
that will act like the re-exported symbol when called. The first call via a
lazy re-export will trigger compilation of the re-exported symbol before calling
through to it.
llvm-svn: 343061
diff --git a/llvm/unittests/ExecutionEngine/Orc/OrcTestCommon.h b/llvm/unittests/ExecutionEngine/Orc/OrcTestCommon.h
index acc0e5b..23ca74c 100644
--- a/llvm/unittests/ExecutionEngine/Orc/OrcTestCommon.h
+++ b/llvm/unittests/ExecutionEngine/Orc/OrcTestCommon.h
@@ -85,6 +85,44 @@
static bool NativeTargetInitialized;
};
+class SimpleMaterializationUnit : public orc::MaterializationUnit {
+public:
+ using MaterializeFunction =
+ std::function<void(orc::MaterializationResponsibility)>;
+ using DiscardFunction =
+ std::function<void(const orc::JITDylib &, orc::SymbolStringPtr)>;
+ using DestructorFunction = std::function<void()>;
+
+ SimpleMaterializationUnit(
+ orc::SymbolFlagsMap SymbolFlags, MaterializeFunction Materialize,
+ DiscardFunction Discard = DiscardFunction(),
+ DestructorFunction Destructor = DestructorFunction())
+ : MaterializationUnit(std::move(SymbolFlags)),
+ Materialize(std::move(Materialize)), Discard(std::move(Discard)),
+ Destructor(std::move(Destructor)) {}
+
+ ~SimpleMaterializationUnit() override {
+ if (Destructor)
+ Destructor();
+ }
+
+ void materialize(orc::MaterializationResponsibility R) override {
+ Materialize(std::move(R));
+ }
+
+ void discard(const orc::JITDylib &JD, orc::SymbolStringPtr Name) override {
+ if (Discard)
+ Discard(JD, std::move(Name));
+ else
+ llvm_unreachable("Discard not supported");
+ }
+
+private:
+ MaterializeFunction Materialize;
+ DiscardFunction Discard;
+ DestructorFunction Destructor;
+};
+
// Base class for Orc tests that will execute code.
class OrcExecutionTest {
public: