[ORC] Prototype ORC library reorg + RPC based TargetProcessControl.

[lhames]

Summary

Introduce OrcRPC based TargetProcessControlImplementation.

[sgraenitz]

Great that there is so fast progress! Haven't reviewed in detail (yet), but it looks like there are no conceptual changes compared to the proposal we know? A few notes inline.

llvm/include/llvm/ExecutionEngine/Orc/Shared/TargetProcessControlTypes.h

111

I am getting compile warnings here too (Apple clang-1100.0.33.12). On my machine it says "designated initializers are a C99 feature" :-) One more in OrcRPCTPCServer.h

llvm/tools/llvm-jitlink/llvm-jitlink.cpp

625

What is the advantage of using execvp over execv? (The latter is what lli did.) I think the way it is now, the default "llvm-jitlink-executor" will only be found if the directory is in PATH.

Changing this to execv I can run a hello world example with the default executor setting once I built both binaries. With execvp the default fails, but this still works:

./llvm-jitlink -oop-executor=./llvm-jitlink-executor ../hello_world.o

627

Maybe this could be:

errs() << "unable to launch out-of-process executor: "
       << ExecutorPath.get() << "\n";

[dblaikie]

llvm/include/llvm/ExecutionEngine/Orc/RPC/RPCSerialization.h

593–594

I'd probably write anything with all-public members as "struct" (don't think we have style policy on this - and certainly some folks/styles reserve "struct" for "type with only member variables/no invariants")

599

I'd usually write this as "if (O)" fwiw (especially with the deref on the next line - seems clear enough what's being tested), but all good either way.

llvm/include/llvm/ExecutionEngine/Orc/Shared/TargetProcessControlTypes.h

30–32

Could potentially skip these and use braced init whenever you want to create an object of this type and initialize the members in one go? (similarly below/for other similar types) Or perhaps there are difficult issues with deduced types and such?

llvm/include/llvm/ExecutionEngine/Orc/TargetProcess/OrcRPCTPCServer.h

131

Probably use StringRef for these return results - so the length is computed off the string literal, rather than a StringRef/other string conversion happening later and requiring a null terminator search at that point?

261

Would it be simpler to write this as a local stateless lambda (they can be converted to raw function pointers anyway) - I see it's used in two places, but the code is so simple (maybe the type parameters are complicated?) might not be pulling its weight as a named function?

530

StringRef, perhaps?

560–563

What's this about?

llvm/lib/ExecutionEngine/Orc/TPCEHFrameRegistrar.cpp

29–51

What's this scope for specifically? (I can't quickly spot which dtor you're trying to run before the return statement/make_unique)

75

Maybe add a makeMutableArrayRef that takes an array reference and deduces the size from that, rather than needing to specify it explicitly?

llvm/lib/ExecutionEngine/Orc/TargetProcessControl.cpp

102

Not sure if you want to, but just in case: You can make this actually a function type (Rather than a function pointer type): "using MainTy = int(int, char *[]);" and then have the usage be "jitTargetAddressToFunction<MainTy*>" - not sure if that's better, but an option in case in interests.

llvm/lib/ExecutionEngine/OrcTargetProcess/TargetExecutionUtils.cpp

39 ↗

(On Diff #300578)

Don't see much !! in LLVM - maybe (ProgramName != nullptr) instead?

llvm/tools/llvm-jitlink/llvm-jitlink-executor/llvm-jitlink-executor.cpp

52

Not possible to support, or "not implemented yet"?

91

Generally favor the implicit conversion (StringRef Arg1 = argv[1]) - means only implicit conversions can occur, making the code easier to read (because you don't have to be worried that some explicit conversion is occurring - I find this particularly important with unique_ptrs (unique_ptr<T> u(v()) is "oh, I need to check if this is taking ownership of a raw pointer" versus unique_ptr<T> u = v() "oh, great, it's returning unique_ptr by value")

llvm/tools/llvm-jitlink/llvm-jitlink.cpp

604–605

These get a bit hard to read - would it be worth having two separate names for the PipeFD arrays, maybe even some constants for the 0/1, which end is which sort of thing?

[sgraenitz]

llvm/tools/llvm-jitlink/llvm-jitlink.cpp

822

I think this only works for isOSBinFormatMachO() at the moment. Current symptom when targeting ELF:

bin/llvm-jitlink: Missing definition for llvm_orc_registerEHFrameSectionWrapper

[lhames]

Address review comments.

[lhames]

Fix diff to include original changes.

[lhames]

llvm/include/llvm/ExecutionEngine/Orc/RPC/RPCSerialization.h

593–594

This is a specialization and the base case is a class, so I think the specialization should be (and perhaps must be) a class?

llvm/include/llvm/ExecutionEngine/Orc/Shared/TargetProcessControlTypes.h

30–32

Yeah. I'm still conservative with my braced inits as I've seen them fail on MSVC builders but don't have a good sense of what those compilers do/don't support. Ideally this can be removed, but we can try fixing that selectively after the patch lands so that any failures due to it are clear.

111

Thanks for catching this. It should be fixed in the latest patch.

llvm/include/llvm/ExecutionEngine/Orc/TargetProcess/OrcRPCTPCServer.h

131

I think we want to stick with char*: We use the strings for diagnostics and RPC-handshakes, but neither of those are performance sensitive. The only performance sensitive use case for these strings is as densemap keys, where using StringRefs would cause us to use value comparisons instead of pointer comparisons.

261

Oh -- I didn't realize that stateless lambdas were convertible to raw function types. That's neat!

I think we keep it though: As you noticed -- Naming the argument types ends up making the lambda quite long. I guess we could use auto for this once we move to C++17?

530

StringRefs aren't safely convertible to a c_str -- We'd need to copy to a std::string anyway.

560–563

It's the MachO leading-underscore demangling, but it would be better written as if (*Sym != '_') ...;. Updated.

llvm/lib/ExecutionEngine/Orc/TPCEHFrameRegistrar.cpp

29–51

I often scope parts of functions that perform a specific, isolated task (in this case finding (De)RegisterEHFrameWrapperFnAddr. It acts as a porto-function that's easy to yank out if it grows / becomes complex enough, and it ensures that I don't accidentally re-use temporaries that support that task outside the scope.

75

Good idea, but I think I'd introduce that in a separate patch.

llvm/lib/ExecutionEngine/OrcTargetProcess/TargetExecutionUtils.cpp

39 ↗

(On Diff #300578)

% grep -iR '!!' include lib  | wc -l
   155
% grep -iR '!= nullptr' include lib  | wc -l
   658

Less common, but common enough -- I think this one can stay (or we should come up with a style guide point to dictate the preferred style).

llvm/tools/llvm-jitlink/llvm-jitlink-executor/llvm-jitlink-executor.cpp

52

Not implemented yet. We just need a windows implementation. I've added a FIXME.

91

Fixed.

llvm/tools/llvm-jitlink/llvm-jitlink.cpp

625

I like execvp, since it means that lookup for the executor program is going to follow the same paths as the lookup for llvm-jitlink itself. Maybe the best option would be to use execvp but default to a full path to llvm-jitlink-executor?

I'd be inclined to update lli to match this logic.

I don't have strong feelings about this though. If most people find execv preferable then I am happy to change it.

627

Good call. Fixed.

[lhames]

I'm curious to get your take on the library breakdown and corresponding headers too. We now have:

include/llvm/ExecutionEngine/Orc               -> lib/ExecutionEngine/Orc              (libLLVMOrc)
include/llvm/ExecutionEngine/Orc/Shared        -> lib/ExecutionEngine/OrcShared        (libLLVMOrcShared)
include/llvm/ExecutionEngine/Orc/TargetProcess -> lib/ExecutionEngine/OrcTargetProcess (libLLVMOrcTargetProcess)

This achieves the initial goal that executors should not need to link Orc (instead they only need to link OrcTargetProcess and OrcShared).

The library dependencies are:

Orc -> OrcShared, RuntimeDyld, JITLink, IR, Support
OrcTargetProcess -> OrcShared

Side note: My ideal solution would be to (a) move OrcJIT out into its own top-level directory, and (2) break libLLVMOrc up into quite a few libraries: ORC Core, ObjLinking, RTDyldLinking, IR, LLJIT, Shared, and TargetProcess at least. Unfortunately I don't think this is worth pursuing at the moment: Any real Orc use-case will need one of RTDyldObjectLinkingLayer or ObjectLinkingLayer, both of which depend and libObject, which depends on everything Orc does today anyway. However if/when libObject gets refactored to eliminate these dependencies we should revisit this.

[dblaikie]

llvm/include/llvm/ExecutionEngine/Orc/RPC/RPCSerialization.h

593–594

Oh fair, probably. Though traits classes tend to be all public members, so maybe the base template could be a struct too.

llvm/include/llvm/ExecutionEngine/Orc/TargetProcess/OrcRPCTPCServer.h

131

Could have a pointer identity DenseMap trait for StringRefs I guess... *goes to look* slightly surprised we don't have one already. My motivation's mostly the same (but less serious) as raw 'new' - const char*s make me give the code a second look in ways that StringRefs don't.

261

I think we keep it though: As you noticed -- Naming the argument types ends up making the lambda quite long.

Fair

I guess we could use auto for this once we move to C++17?

I was going to suggest that the conversion isn't available then (because the call operator becomes a template), but apparently it does work - neat! and it does template argument deduction to instantiate a specific call operator when the conversion is performed. So, yeah, one day.

560–563

Hmm - it strikes me as odd because it's using a compile-time feature rather than say, an API query to test whether the binary format is MachO. I guess that's because of the context of this being on the machine where the code will execute and thus APPLE is synonymous with MachO at that point? If it were possible to rely on some other property like the type of the object file where the symbol came from, that might make it a bit easier to test portably or less error-prone in some weird future where someone might be testing different object formats, etc?

llvm/lib/ExecutionEngine/Orc/TPCEHFrameRegistrar.cpp

29–51

Ah - I'd be inclined to push back a bit there, given it's a bit uncommon & not sure about other readers, but for me leads me to wonder what novel details are in this code such that a dtor needs to run before the return statement/making this code harder to read. But your call.

llvm/lib/ExecutionEngine/OrcTargetProcess/TargetExecutionUtils.cpp

39 ↗

(On Diff #300578)

Fair enough (FWIW the numbers skew a bit - not all of the !!s are for pointers, some for integer values (so would be comparable to != 0), Optional, etc - and, amusingly two dozen are emphatic comments or assert messages like "Case index out of range!" - always 3 in those cases, it seems, I didn't see any emphases)

[sgraenitz]

I'm curious to get your take on the library breakdown and corresponding headers too.

There's a number of includes still pointing to #include "llvm/ExecutionEngine/Orc/TargetProcess/XY". Otherwise, yes LGTM.

This achieves the initial goal that executors should not need to link Orc

+1 very reasonable!

llvm/tools/llvm-jitlink/llvm-jitlink.cpp

625

I have no strong opinion on it either, except that the default setting should work. If we keep execvp, then the default value for OOPExecutor should be ./llvm-jitlink-executor right?

[sgraenitz]

In D90132#2370918, @sgraenitz wrote:

I'm curious to get your take on the library breakdown and corresponding headers too.

There's a number of includes still pointing to #include "llvm/ExecutionEngine/Orc/TargetProcess/XY". Otherwise, yes LGTM.

Ok, actually the headers don't follow the breakdown. Why is that?

[sgraenitz]

Two issues when trying to build llvm-jitlink-executor with the libs separated:

llvm/lib/ExecutionEngine/OrcTargetProcess/LLVMBuild.txt

21 ↗

(On Diff #302060)

OrcShared is required here now

llvm/lib/ExecutionEngine/OrcTargetProcess/RegisterEHFrames.cpp

72 ↗

(On Diff #302060)

We cannot use JITLinkError in the target process, because it's defined in JITLink. Could it be a StringError for the moment? (One more case below.)

[lhames]

In D90132#2370956, @sgraenitz wrote:

Ok, actually the headers don't follow the breakdown. Why is that?

I just followed the existing layout that OrcError used, but I don't think there's any good reason for it. I've moved OrcShared and OrcTargetProcess to Orc/Shared and Orc/TargetProcess subdirectories in the latest patch.

llvm/include/llvm/ExecutionEngine/Orc/RPC/RPCSerialization.h

593–594

In this case the traits have some data members that are used as a cache. I think it makes sense to keep those private.

llvm/include/llvm/ExecutionEngine/Orc/TargetProcess/OrcRPCTPCServer.h

131

Interesting. I don't think of StringRefs that way: They're very much a view API to me (especially given the lack of guaranteed null termination), and relying on pointer equality between StringRefs (other than for optimization) is more surprising than relying on pointer equality between char*s.

I'm going to stick with char* in this patch, but it's worth discussing further. If we decide to change it then the entire RPCTypeName scheme (and associated RPC classes )need to be updated anyway, which his a job for another patch.

560–563

To be clear: This isn't the regular JIT lookup path, this is an RPC wrapper for dlsym in the target process. There's no object file to look at. We're taking a JIT symbol string (always linker mangled) and trying to look it up using dlsym, which expects a C symbol name. If the target process is MachO, which is determinable at compile time and synonymous with __APPLE__, then we need to apply MachO "demangling", i.e. dropping the leading underscore. A runtime check wouldn't add anything here.

llvm/lib/ExecutionEngine/Orc/TPCEHFrameRegistrar.cpp

29–51

Fair, and looking at it again this is a short function so there's less value to this kind of scoping. I think this may actually have been yanked out of a larger function earlier and I just failed to drop the braces. I've removed them in the latest patch.

llvm/lib/ExecutionEngine/OrcTargetProcess/RegisterEHFrames.cpp

72 ↗

(On Diff #302060)

Good catch -- thanks!

llvm/tools/llvm-jitlink/llvm-jitlink.cpp

625

I think it should default to the same relative path as llvm-jitlink, since that will be the standard build/install path. I've switched to this in the latest version.

[lhames]

Address review comments.

[lhames]

Please let me know if you have any other thoughts / comments, otherwise I'm hoping to commit this by the end of the week so we can move on to the next step: Full support for initializers in remote processes.

[sgraenitz]

Last issue: EH-frame registration isn't ready for ELF right? That would be great to fix (see the unticked inline comment).
I can offer to check the mangling prefix details once this had landed.

llvm/include/llvm/ExecutionEngine/Orc/TargetProcess/OrcRPCTPCServer.h

560–563

We shouldn't ignore use cases like ELF on __APPLE__ and ELF on _WIN32. Here symbols don't come with the appropriate mangling prefix, which means that the lookup logic becomes a little more complicated:

• printf should get prefixed and resolve to _printf
• my own function foo shouldn't and instead resolve to plain foo

I assume that foo will be resolved on the jitlink side, because the symbol is defined in user code. Thus, the request for it won't make it to the jitlink-executor side in the first place. OTOH printf will be looked up here on the jitlink-executor side, so adding the mangling prefix is correct.

There is a similar logic in SelfTargetProcessControl, where we add the GlobalManglingPrefix unconditionally if the process triple's default object format is MachO.

Maybe this is beyond the scope of this initial version, so I'd propose to investigate it in more detail and come up with a follow-up patch.

llvm/tools/llvm-jitlink/llvm-jitlink.cpp

625

Ok I see, this makes it independent from the current working directory. Great!

822

This note here is still open. EH-frame registration didn't work for me on Linux. With the proposed fix it does.

[lhames]

Make executable symbols in llvm-jitlink-executor visible.

[sgraenitz]

Ok, I grabbed your latest version and checked again for the EH frame registration on Linux. This works very well now! Thanks

[lhames]

llvm/include/llvm/ExecutionEngine/Orc/TargetProcess/OrcRPCTPCServer.h

560–563

I've always thought of ELF on Darwin/Win32 as a hack to paper over the fact that RuntimeDyldMachO and RuntimeDyldCOFF were missing features (especially debugger registration). Under that view the right answer is to implement those features in JITLink and then always use an object format that matches the platform (MachO for Darwin, ELF for Linux, COFF for Win32). That way there's never any question about the ABI or mangling lining up with the surrounding process.

I *do* occasionally use cross-format execution for testing purposes (e.g. llvm-jitlinking an ELF object to test JITLink ELF support), but I'm not sure whether we should make that kind of use case officially supported. If we do decide that it should be supported that's a bigger discussion that should happen outside this review, and should not block it.

llvm/tools/llvm-jitlink/llvm-jitlink.cpp

822

eh-frame registration isn't fully hooked up for JITLink/ELF as far as I know, but this should still work. I suspect the problem was that executable symbols weren't exported from llvm-jitlink-executor. I've fixed that in the latest patch -- could you let me know if it fixes your issue?

[lhames]

Committed in 1d0676b54c4.

[sgraenitz]

llvm/include/llvm/ExecutionEngine/Orc/TargetProcess/OrcRPCTPCServer.h

560–563

Yes, you are right, there won't be official support and so it shouldn't impact ongoing upstream development. Still, these use-cases exist downstream and for me it's worth it to keep them working (somehow). Eventually, I could solve this specific issue with a customized TPCDynamicLibrarySearchGenerator -- the other way around this time: https://gist.github.com/weliveindetail/7add5f366abe5f75da4476aa3f27d6bf

llvm/tools/llvm-jitlink/llvm-jitlink.cpp

822

Yes, I did a clean rebuild of the executor with symbols exported and that fixed it. Thanks!

llvm/examples/OrcV2Examples/LLJITWithTargetProcessControl/LLJITWithTargetProcessControl.cpp

int main(int argc, char *argv[]) {
 
   InitializeNativeTarget();
   InitializeNativeTargetAsmPrinter();
 
   cl::ParseCommandLineOptions(argc, argv, "LLJITWithLazyReexports");
   ExitOnErr.setBanner(std::string(argv[0]) + ": ");
 
   // (1) Create LLJIT instance.
-  auto TPC = ExitOnErr(SelfTargetProcessControl::Create());
+  auto SSP = std::make_shared<SymbolStringPool>();
+  auto TPC = ExitOnErr(SelfTargetProcessControl::Create(std::move(SSP)));
   auto J = ExitOnErr(LLJITBuilder().setTargetProcessControl(*TPC).create());
 
   // (2) Install transform to print modules as they are compiled:
   J->getIRTransformLayer().setTransform(
       [](ThreadSafeModule TSM,
          const MaterializationResponsibility &R) -> Expected<ThreadSafeModule> {
         TSM.withModuleDo([](Module &M) { dbgs() << "---Compiling---\n" << M; });
         return std::move(TSM); // Not a redundant move: fix build on gcc-7.5

llvm/include/llvm/ExecutionEngine/JITLink/EHFrameSupport.h

 #include "llvm/ADT/Triple.h"
 #include "llvm/ExecutionEngine/JITLink/JITLink.h"
 #include "llvm/ExecutionEngine/JITSymbol.h"
 #include "llvm/Support/Error.h"
 
 namespace llvm {
 namespace jitlink {
 
-/// Registers all FDEs in the given eh-frame section with the current process.
-Error registerEHFrameSection(const void *EHFrameSectionAddr,
-                             size_t EHFrameSectionSize);
-
-/// Deregisters all FDEs in the given eh-frame section with the current process.
-Error deregisterEHFrameSection(const void *EHFrameSectionAddr,
-                               size_t EHFrameSectionSize);
-
 /// Supports registration/deregistration of EH-frames in a target process.
 class EHFrameRegistrar {
 public:
   virtual ~EHFrameRegistrar();
   virtual Error registerEHFrames(JITTargetAddress EHFrameSectionAddr,
                                  size_t EHFrameSectionSize) = 0;
   virtual Error deregisterEHFrames(JITTargetAddress EHFrameSectionAddr,
                                    size_t EHFrameSectionSize) = 0;

llvm/include/llvm/ExecutionEngine/JITLink/JITLink.h

public:
   const std::string &getName() { return Name; }
 
   /// Returns the pointer size for use in this graph.
   unsigned getPointerSize() const { return PointerSize; }
 
   /// Returns the endianness of content in this graph.
   support::endianness getEndianness() const { return Endianness; }
 
+  /// Allocate a copy of the given String using the LinkGraph's allocator.
+  /// This can be useful when renaming symbols or adding new content to the
+  /// graph.
+  StringRef allocateString(Twine Source) {
+    SmallString<256> TmpBuffer;
+    auto SourceStr = Source.toStringRef(TmpBuffer);
+    auto *AllocatedBuffer = Allocator.Allocate<char>(SourceStr.size());
+    llvm::copy(SourceStr, AllocatedBuffer);
+    return StringRef(AllocatedBuffer, SourceStr.size());
+  }
+
   /// Create a section with the given name, protection flags, and alignment.
   Section &createSection(StringRef Name, sys::Memory::ProtectionFlags Prot) {
     std::unique_ptr<Section> Sec(new Section(Name, Prot, Sections.size()));
     Sections.push_back(std::move(Sec));
     return *Sections.back();
   }
 
   /// Create a content block.

llvm/include/llvm/ExecutionEngine/Orc/ExecutionUtils.h

 class Module;
 class TargetMachine;
 class Value;
 
 namespace orc {
 
 class ObjectLayer;
 
-/// Run a main function, returning the result.
-///
-/// If the optional ProgramName argument is given then it will be inserted
-/// before the strings in Args as the first argument to the called function.
-///
-/// It is legal to have an empty argument list and no program name, however
-/// many main functions will expect a name argument at least, and will fail
-/// if none is provided.
-int runAsMain(int (*Main)(int, char *[]), ArrayRef<std::string> Args,
-              Optional<StringRef> ProgramName = None);
-
 /// This iterator provides a convenient way to iterate over the elements
 ///        of an llvm.global_ctors/llvm.global_dtors instance.
 ///
 ///   The easiest way to get hold of instances of this class is to use the
 /// getConstructors/getDestructors functions.
 class CtorDtorIterator {
 public:
   /// Accessor for an element of the global_ctors/global_dtors array.

llvm/include/llvm/ExecutionEngine/Orc/OrcRPCTargetProcessControl.h

+//===--- OrcRPCTargetProcessControl.h - Remote target control ---*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Utilities for interacting with target processes.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_ORC_ORCRPCTARGETPROCESSCONTROL_H
+#define LLVM_EXECUTIONENGINE_ORC_ORCRPCTARGETPROCESSCONTROL_H
+
+#include "llvm/ExecutionEngine/Orc/RPC/RPCUtils.h"
+#include "llvm/ExecutionEngine/Orc/RPC/RawByteChannel.h"
+#include "llvm/ExecutionEngine/Orc/TargetProcess/OrcRPCTPCServer.h"
+#include "llvm/ExecutionEngine/Orc/TargetProcessControl.h"
+#include "llvm/Support/MSVCErrorWorkarounds.h"
+
+namespace llvm {
+namespace orc {
+
+/// JITLinkMemoryManager implementation for a process connected via an ORC RPC
+/// endpoint.
+template <typename OrcRPCTPCImplT>
+class OrcRPCTPCJITLinkMemoryManager : public jitlink::JITLinkMemoryManager {
+private:
+  struct HostAlloc {
+    std::unique_ptr<char[]> Mem;
+    uint64_t Size;
+  };
+
+  struct TargetAlloc {
+    JITTargetAddress Address = 0;
+    uint64_t AllocatedSize = 0;
+  };
+
+  using HostAllocMap = DenseMap<int, HostAlloc>;
+  using TargetAllocMap = DenseMap<int, TargetAlloc>;
+
+public:
+  class OrcRPCAllocation : public Allocation {
+  public:
+    OrcRPCAllocation(OrcRPCTPCJITLinkMemoryManager<OrcRPCTPCImplT> &Parent,
+                     HostAllocMap HostAllocs, TargetAllocMap TargetAllocs)
+        : Parent(Parent), HostAllocs(std::move(HostAllocs)),
+          TargetAllocs(std::move(TargetAllocs)) {
+      assert(HostAllocs.size() == TargetAllocs.size() &&
+             "HostAllocs size should match TargetAllocs");
+    }
+
+    ~OrcRPCAllocation() override {
+      assert(TargetAllocs.empty() && "failed to deallocate");
+    }
+
+    MutableArrayRef<char> getWorkingMemory(ProtectionFlags Seg) override {
+      auto I = HostAllocs.find(Seg);
+      assert(I != HostAllocs.end() && "No host allocation for segment");
+      auto &HA = I->second;
+      return {HA.Mem.get(), HA.Size};
+    }
+
+    JITTargetAddress getTargetMemory(ProtectionFlags Seg) override {
+      auto I = TargetAllocs.find(Seg);
+      assert(I != TargetAllocs.end() && "No target allocation for segment");
+      return I->second.Address;
+    }
+
+    void finalizeAsync(FinalizeContinuation OnFinalize) override {
+
+      std::vector<tpctypes::BufferWrite> BufferWrites;
+      orcrpctpc::ReleaseOrFinalizeMemRequest FMR;
+
+      for (auto &KV : HostAllocs) {
+        assert(TargetAllocs.count(KV.first) &&
+               "No target allocation for buffer");
+        auto &HA = KV.second;
+        auto &TA = TargetAllocs[KV.first];
+        BufferWrites.push_back({TA.Address, StringRef(HA.Mem.get(), HA.Size)});
+        FMR.push_back({orcrpctpc::toWireProtectionFlags(
+                           static_cast<sys::Memory::ProtectionFlags>(KV.first)),
+                       TA.Address, TA.AllocatedSize});
+      }
+
+      DEBUG_WITH_TYPE("orc", {
+        dbgs() << "finalizeAsync " << (void *)this << ":\n";
+        auto FMRI = FMR.begin();
+        for (auto &B : BufferWrites) {
+          auto Prot = FMRI->Prot;
+          ++FMRI;
+          dbgs() << "  Writing " << formatv("{0:x16}", B.Buffer.size())
+                 << " bytes to " << ((Prot & orcrpctpc::WPF_Read) ? 'R' : '-')
+                 << ((Prot & orcrpctpc::WPF_Write) ? 'W' : '-')
+                 << ((Prot & orcrpctpc::WPF_Exec) ? 'X' : '-')
+                 << " segment: local " << (void *)B.Buffer.data()
+                 << " -> target " << formatv("{0:x16}", B.Address) << "\n";
+        }
+      });
+      if (auto Err =
+              Parent.Parent.getMemoryAccess().writeBuffers(BufferWrites)) {
+        OnFinalize(std::move(Err));
+        return;
+      }
+
+      DEBUG_WITH_TYPE("orc", dbgs() << " Applying permissions...\n");
+      if (auto Err =
+              Parent.getEndpoint().template callAsync<orcrpctpc::FinalizeMem>(
+                  [OF = std::move(OnFinalize)](Error Err2) {
+                    // FIXME: Dispatch to work queue.
+                    std::thread([OF = std::move(OF),
+                                 Err3 = std::move(Err2)]() mutable {
+                      DEBUG_WITH_TYPE(
+                          "orc", { dbgs() << "  finalizeAsync complete\n"; });
+                      OF(std::move(Err3));
+                    }).detach();
+                    return Error::success();
+                  },
+                  FMR)) {
+        DEBUG_WITH_TYPE("orc", dbgs() << "    failed.\n");
+        Parent.getEndpoint().abandonPendingResponses();
+        Parent.reportError(std::move(Err));
+      }
+      DEBUG_WITH_TYPE("orc", {
+        dbgs() << "Leaving finalizeAsync (finalization may continue in "
+                  "background)\n";
+      });
+    }
+
+    Error deallocate() override {
+      orcrpctpc::ReleaseOrFinalizeMemRequest RMR;
+      for (auto &KV : TargetAllocs)
+        RMR.push_back({orcrpctpc::toWireProtectionFlags(
+                           static_cast<sys::Memory::ProtectionFlags>(KV.first)),
+                       KV.second.Address, KV.second.AllocatedSize});
+      TargetAllocs.clear();
+
+      return Parent.getEndpoint().template callB<orcrpctpc::ReleaseMem>(RMR);
+    }
+
+  private:
+    OrcRPCTPCJITLinkMemoryManager<OrcRPCTPCImplT> &Parent;
+    HostAllocMap HostAllocs;
+    TargetAllocMap TargetAllocs;
+  };
+
+  OrcRPCTPCJITLinkMemoryManager(OrcRPCTPCImplT &Parent) : Parent(Parent) {}
+
+  Expected<std::unique_ptr<Allocation>>
+  allocate(const SegmentsRequestMap &Request) override {
+    orcrpctpc::ReserveMemRequest RMR;
+    HostAllocMap HostAllocs;
+
+    for (auto &KV : Request) {
+      RMR.push_back({orcrpctpc::toWireProtectionFlags(
+                         static_cast<sys::Memory::ProtectionFlags>(KV.first)),
+                     KV.second.getContentSize() + KV.second.getZeroFillSize(),
+                     KV.second.getAlignment()});
+      HostAllocs[KV.first] = {
+          std::make_unique<char[]>(KV.second.getContentSize()),
+          KV.second.getContentSize()};
+    }
+
+    DEBUG_WITH_TYPE("orc", {
+      dbgs() << "Orc remote memmgr got request:\n";
+      for (auto &KV : Request)
+        dbgs() << "  permissions: "
+               << ((KV.first & sys::Memory::MF_READ) ? 'R' : '-')
+               << ((KV.first & sys::Memory::MF_WRITE) ? 'W' : '-')
+               << ((KV.first & sys::Memory::MF_EXEC) ? 'X' : '-')
+               << ", content size: "
+               << formatv("{0:x16}", KV.second.getContentSize())
+               << " + zero-fill-size: "
+               << formatv("{0:x16}", KV.second.getZeroFillSize())
+               << ", align: " << KV.second.getAlignment() << "\n";
+    });
+
+    // FIXME: LLVM RPC needs to be fixed to support alt
+    // serialization/deserialization on return types. For now just
+    // translate from std::map to DenseMap manually.
+    auto TmpTargetAllocs =
+        Parent.getEndpoint().template callB<orcrpctpc::ReserveMem>(RMR);
+    if (!TmpTargetAllocs)
+      return TmpTargetAllocs.takeError();
+
+    if (TmpTargetAllocs->size() != RMR.size())
+      return make_error<StringError>(
+          "Number of target allocations does not match request",
+          inconvertibleErrorCode());
+
+    TargetAllocMap TargetAllocs;
+    for (auto &E : *TmpTargetAllocs)
+      TargetAllocs[orcrpctpc::fromWireProtectionFlags(E.Prot)] = {
+          E.Address, E.AllocatedSize};
+
+    DEBUG_WITH_TYPE("orc", {
+      auto HAI = HostAllocs.begin();
+      for (auto &KV : TargetAllocs)
+        dbgs() << "  permissions: "
+               << ((KV.first & sys::Memory::MF_READ) ? 'R' : '-')
+               << ((KV.first & sys::Memory::MF_WRITE) ? 'W' : '-')
+               << ((KV.first & sys::Memory::MF_EXEC) ? 'X' : '-')
+               << " assigned local " << (void *)HAI->second.Mem.get()
+               << ", target " << formatv("{0:x16}", KV.second.Address) << "\n";
+    });
+
+    return std::make_unique<OrcRPCAllocation>(*this, std::move(HostAllocs),
+                                              std::move(TargetAllocs));
+  }
+
+private:
+  void reportError(Error Err) { Parent.reportError(std::move(Err)); }
+
+  decltype(std::declval<OrcRPCTPCImplT>().getEndpoint()) getEndpoint() {
+    return Parent.getEndpoint();
+  }
+
+  OrcRPCTPCImplT &Parent;
+};
+
+/// TargetProcessControl::MemoryAccess implementation for a process connected
+/// via an ORC RPC endpoint.
+template <typename OrcRPCTPCImplT>
+class OrcRPCTPCMemoryAccess : public TargetProcessControl::MemoryAccess {
+public:
+  OrcRPCTPCMemoryAccess(OrcRPCTPCImplT &Parent) : Parent(Parent) {}
+
+  void writeUInt8s(ArrayRef<tpctypes::UInt8Write> Ws,
+                   WriteResultFn OnWriteComplete) override {
+    writeViaRPC<orcrpctpc::WriteUInt8s>(Ws, std::move(OnWriteComplete));
+  }
+
+  void writeUInt16s(ArrayRef<tpctypes::UInt16Write> Ws,
+                    WriteResultFn OnWriteComplete) override {
+    writeViaRPC<orcrpctpc::WriteUInt16s>(Ws, std::move(OnWriteComplete));
+  }
+
+  void writeUInt32s(ArrayRef<tpctypes::UInt32Write> Ws,
+                    WriteResultFn OnWriteComplete) override {
+    writeViaRPC<orcrpctpc::WriteUInt32s>(Ws, std::move(OnWriteComplete));
+  }
+
+  void writeUInt64s(ArrayRef<tpctypes::UInt64Write> Ws,
+                    WriteResultFn OnWriteComplete) override {
+    writeViaRPC<orcrpctpc::WriteUInt64s>(Ws, std::move(OnWriteComplete));
+  }
+
+  void writeBuffers(ArrayRef<tpctypes::BufferWrite> Ws,
+                    WriteResultFn OnWriteComplete) override {
+    writeViaRPC<orcrpctpc::WriteBuffers>(Ws, std::move(OnWriteComplete));
+  }
+
+private:
+  template <typename WriteRPCFunction, typename WriteElementT>
+  void writeViaRPC(ArrayRef<WriteElementT> Ws, WriteResultFn OnWriteComplete) {
+    if (auto Err = Parent.getEndpoint().template callAsync<WriteRPCFunction>(
+            [OWC = std::move(OnWriteComplete)](Error Err2) mutable -> Error {
+              OWC(std::move(Err2));
+              return Error::success();
+            },
+            Ws)) {
+      Parent.reportError(std::move(Err));
+      Parent.getEndpoint().abandonPendingResponses();
+    }
+  }
+
+  OrcRPCTPCImplT &Parent;
+};
+
+// TargetProcessControl for a process connected via an ORC RPC Endpoint.
+template <typename RPCEndpointT>
+class OrcRPCTargetProcessControlBase : public TargetProcessControl {
+public:
+  using ErrorReporter = unique_function<void(Error)>;
+
+  using OnCloseConnectionFunction = unique_function<Error(Error)>;
+
+  OrcRPCTargetProcessControlBase(std::shared_ptr<SymbolStringPool> SSP,
+                                 RPCEndpointT &EP, ErrorReporter ReportError)
+      : TargetProcessControl(std::move(SSP)),
+        ReportError(std::move(ReportError)), EP(EP) {}
+
+  void reportError(Error Err) { ReportError(std::move(Err)); }
+
+  RPCEndpointT &getEndpoint() { return EP; }
+
+  Expected<tpctypes::DylibHandle> loadDylib(const char *DylibPath) override {
+    DEBUG_WITH_TYPE("orc", {
+      dbgs() << "Loading dylib \"" << (DylibPath ? DylibPath : "") << "\" ";
+      if (!DylibPath)
+        dbgs() << "(process symbols)";
+      dbgs() << "\n";
+    });
+    if (!DylibPath)
+      DylibPath = "";
+    auto H = EP.template callB<orcrpctpc::LoadDylib>(DylibPath);
+    DEBUG_WITH_TYPE("orc", {
+      if (H)
+        dbgs() << "  got handle " << formatv("{0:x16}", *H) << "\n";
+      else
+        dbgs() << "  error, unable to load\n";
+    });
+    return H;
+  }
+
+  Expected<std::vector<tpctypes::LookupResult>>
+  lookupSymbols(ArrayRef<tpctypes::LookupRequest> Request) override {
+    std::vector<orcrpctpc::RemoteLookupRequest> RR;
+    for (auto &E : Request) {
+      RR.push_back({});
+      RR.back().first = E.Handle;
+      for (auto &KV : E.Symbols)
+        RR.back().second.push_back(
+            {(*KV.first).str(),
+             KV.second == SymbolLookupFlags::WeaklyReferencedSymbol});
+    }
+    DEBUG_WITH_TYPE("orc", {
+      dbgs() << "Compound lookup:\n";
+      for (auto &R : Request) {
+        dbgs() << "  In " << formatv("{0:x16}", R.Handle) << ": {";
+        bool First = true;
+        for (auto &KV : R.Symbols) {
+          dbgs() << (First ? "" : ",") << " " << *KV.first;
+          First = false;
+        }
+        dbgs() << " }\n";
+      }
+    });
+    return EP.template callB<orcrpctpc::LookupSymbols>(RR);
+  }
+
+  Expected<int32_t> runAsMain(JITTargetAddress MainFnAddr,
+                              ArrayRef<std::string> Args) override {
+    DEBUG_WITH_TYPE("orc", {
+      dbgs() << "Running as main: " << formatv("{0:x16}", MainFnAddr)
+             << ", args = [";
+      for (unsigned I = 0; I != Args.size(); ++I)
+        dbgs() << (I ? "," : "") << " \"" << Args[I] << "\"";
+      dbgs() << "]\n";
+    });
+    auto Result = EP.template callB<orcrpctpc::RunMain>(MainFnAddr, Args);
+    DEBUG_WITH_TYPE("orc", {
+      dbgs() << "  call to " << formatv("{0:x16}", MainFnAddr);
+      if (Result)
+        dbgs() << " returned result " << *Result << "\n";
+      else
+        dbgs() << " failed\n";
+    });
+    return Result;
+  }
+
+  Expected<tpctypes::WrapperFunctionResult>
+  runWrapper(JITTargetAddress WrapperFnAddr,
+             ArrayRef<uint8_t> ArgBuffer) override {
+    DEBUG_WITH_TYPE("orc", {
+      dbgs() << "Running as wrapper function "
+             << formatv("{0:x16}", WrapperFnAddr) << " with "
+             << formatv("{0:x16}", ArgBuffer.size()) << " argument buffer\n";
+    });
+    auto Result =
+        EP.template callB<orcrpctpc::RunWrapper>(WrapperFnAddr, ArgBuffer);
+    // dbgs() << "Returned from runWrapper...\n";
+    return Result;
+  }
+
+  Error closeConnection(OnCloseConnectionFunction OnCloseConnection) {
+    DEBUG_WITH_TYPE("orc", dbgs() << "Closing connection to remote\n");
+    return EP.template callAsync<orcrpctpc::CloseConnection>(
+        std::move(OnCloseConnection));
+  }
+
+  Error closeConnectionAndWait() {
+    std::promise<MSVCPError> P;
+    auto F = P.get_future();
+    if (auto Err = closeConnection([&](Error Err2) -> Error {
+          P.set_value(std::move(Err2));
+          return Error::success();
+        })) {
+      EP.abandonAllPendingResponses();
+      return joinErrors(std::move(Err), F.get());
+    }
+    return F.get();
+  }
+
+protected:
+  /// Subclasses must call this during construction to initialize the
+  /// TargetTriple and PageSize members.
+  Error initializeORCRPCTPCBase() {
+    if (auto TripleOrErr = EP.template callB<orcrpctpc::GetTargetTriple>())
+      TargetTriple = Triple(*TripleOrErr);
+    else
+      return TripleOrErr.takeError();
+
+    if (auto PageSizeOrErr = EP.template callB<orcrpctpc::GetPageSize>())
+      PageSize = *PageSizeOrErr;
+    else
+      return PageSizeOrErr.takeError();
+
+    return Error::success();
+  }
+
+private:
+  ErrorReporter ReportError;
+  RPCEndpointT &EP;
+};
+
+} // end namespace orc
+} // end namespace llvm
+
+#endif // LLVM_EXECUTIONENGINE_ORC_ORCRPCTARGETPROCESSCONTROL_H

llvm/include/llvm/ExecutionEngine/Orc/RPC/FDRawByteChannel.h

 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_EXECUTIONENGINE_ORC_RPC_FDRAWBYTECHANNEL_H
 #define LLVM_EXECUTIONENGINE_ORC_RPC_FDRAWBYTECHANNEL_H
 
 #include "llvm/ExecutionEngine/Orc/RPC/RawByteChannel.h"
 
+#include "llvm/Support/FormatVariadic.h"
+#include "llvm/Support/raw_ostream.h"
+
 #if !defined(_MSC_VER) && !defined(__MINGW32__)
 #include <unistd.h>
 #else
 #include <io.h>
 #endif
 
 namespace llvm {
 namespace orc {
 namespace rpc {
 
 /// RPC channel that reads from and writes from file descriptors.
 class FDRawByteChannel final : public RawByteChannel {
 public:
   FDRawByteChannel(int InFD, int OutFD) : InFD(InFD), OutFD(OutFD) {}
 
   llvm::Error readBytes(char *Dst, unsigned Size) override {
+    // dbgs() << "Reading " << Size << " bytes: [";
     assert(Dst && "Attempt to read into null.");
     ssize_t Completed = 0;
     while (Completed < static_cast<ssize_t>(Size)) {
       ssize_t Read = ::read(InFD, Dst + Completed, Size - Completed);
       if (Read <= 0) {
+        // dbgs() << " <<<\n";
         auto ErrNo = errno;
         if (ErrNo == EAGAIN || ErrNo == EINTR)
           continue;
         else
           return llvm::errorCodeToError(
               std::error_code(errno, std::generic_category()));
       }
+      // for (size_t I = 0; I != Read; ++I)
+      //  dbgs() << " " << formatv("{0:x2}", Dst[Completed + I]);
       Completed += Read;
     }
+    // dbgs() << " ]\n";
     return llvm::Error::success();
   }
 
   llvm::Error appendBytes(const char *Src, unsigned Size) override {
+    // dbgs() << "Appending " << Size << " bytes: [";
     assert(Src && "Attempt to append from null.");
     ssize_t Completed = 0;
     while (Completed < static_cast<ssize_t>(Size)) {
       ssize_t Written = ::write(OutFD, Src + Completed, Size - Completed);
       if (Written < 0) {
+        // dbgs() << " <<<\n";
         auto ErrNo = errno;
         if (ErrNo == EAGAIN || ErrNo == EINTR)
           continue;
         else
           return llvm::errorCodeToError(
               std::error_code(errno, std::generic_category()));
       }
+      // for (size_t I = 0; I != Written; ++I)
+      //  dbgs() << " " << formatv("{0:x2}", Src[Completed + I]);
       Completed += Written;
     }
+    // dbgs() << " ]\n";
     return llvm::Error::success();
   }
 
   llvm::Error send() override { return llvm::Error::success(); }
 
 private:
   int InFD, OutFD;
 };
 
 } // namespace rpc
 } // namespace orc
 } // namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_ORC_RPC_FDRAWBYTECHANNEL_H

llvm/include/llvm/ExecutionEngine/Orc/RPC/RPCSerialization.h

 //===- llvm/ExecutionEngine/Orc/RPC/RPCSerialization.h --------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_EXECUTIONENGINE_ORC_RPC_RPCSERIALIZATION_H
 #define LLVM_EXECUTIONENGINE_ORC_RPC_RPCSERIALIZATION_H
 
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/DenseMap.h"
 #include "llvm/ExecutionEngine/Orc/OrcError.h"
 #include "llvm/Support/thread.h"
 #include <map>
 #include <mutex>
 #include <set>
 #include <sstream>
 #include <string>
 #include <vector>
static std::string Name = [] {
       raw_string_ostream(Name) << "std::tuple<"
                                << RPCTypeNameSequence<ArgTs...>() << ">";
       return Name;
     }();
     return Name.data();
   }
 };
 
+template <typename T> class RPCTypeName<Optional<T>> {
+public:
+  static const char *getName() {
+    static std::string Name = [] {
+      std::string Name;
+      raw_string_ostream(Name)
+          << "Optional<" << RPCTypeName<T>::getName() << ">";
+      return Name;
+    }();
+    return Name.data();
+  }
+};
+
 template <typename T>
 class RPCTypeName<std::vector<T>> {
 public:
   static const char*getName() {
     static std::string Name = [] {
       std::string Name;
       raw_string_ostream(Name) << "std::vector<" << RPCTypeName<T>::getName()
                                << ">";
private:
   // Serialization helper for std::tuple.
   template <size_t... Is>
   static Error deserializeTupleHelper(ChannelT &C, std::tuple<ArgTs...> &V,
                                       std::index_sequence<Is...> _) {
     return deserializeSeq(C, std::get<Is>(V)...);
   }
 };
 
+template <typename ChannelT, typename T>
+class SerializationTraits<ChannelT, Optional<T>> {
+public:
+  /// Serialize an Optional<T>.
+  static Error serialize(ChannelT &C, const Optional<T> &O) {
+    if (auto Err = serializeSeq(C, O != None))
+      return Err;
+    if (O)
+      if (auto Err = serializeSeq(C, *O))
+        return Err;
+    return Error::success();
+  }
+
+  /// Deserialize an Optional<T>.
+  static Error deserialize(ChannelT &C, Optional<T> &O) {
+    bool HasValue = false;
+    if (auto Err = deserializeSeq(C, HasValue))
+      return Err;
+    if (HasValue)
+      if (auto Err = deserializeSeq(C, *O))
+        return Err;
+    return Error::success();
+  };
+};
+
 /// SerializationTraits default specialization for std::vector.
 template <typename ChannelT, typename T>
 class SerializationTraits<ChannelT, std::vector<T>> {
 public:
 
   /// Serialize a std::vector<T> from std::vector<T>.
   static Error serialize(ChannelT &C, const std::vector<T> &V) {
     if (auto Err = serializeSeq(C, static_cast<uint64_t>(V.size())))
static Error deserialize(ChannelT &C, std::vector<T> &V) {
     for (auto &E : V)
       if (auto Err = deserializeSeq(C, E))
         return Err;
 
     return Error::success();
   }
 };
 
+/// Enable vector serialization from an ArrayRef.
+template <typename ChannelT, typename T>
+class SerializationTraits<ChannelT, std::vector<T>, ArrayRef<T>> {
+public:
+  static Error serialize(ChannelT &C, ArrayRef<T> V) {
+    if (auto Err = serializeSeq(C, static_cast<uint64_t>(V.size())))
+      return Err;
+
+    for (const auto &E : V)
+      if (auto Err = serializeSeq(C, E))
+        return Err;
+
+    return Error::success();
+  }
+};
+
 template <typename ChannelT, typename T, typename T2>
 class SerializationTraits<ChannelT, std::set<T>, std::set<T2>> {
 public:
   /// Serialize a std::set<T> from std::set<T2>.
   static Error serialize(ChannelT &C, const std::set<T2> &S) {
     if (auto Err = serializeSeq(C, static_cast<uint64_t>(S.size())))
       return Err;
 
while (Count-- != 0) {
         return make_error<StringError>("Duplicate element in deserialized map",
                                        orcError(OrcErrorCode::UnknownORCError));
     }
 
     return Error::success();
   }
 };
 
+template <typename ChannelT, typename K, typename V, typename K2, typename V2>
+class SerializationTraits<ChannelT, std::map<K, V>, DenseMap<K2, V2>> {
+public:
+  /// Serialize a std::map<K, V> from DenseMap<K2, V2>.
+  static Error serialize(ChannelT &C, const DenseMap<K2, V2> &M) {
+    if (auto Err = serializeSeq(C, static_cast<uint64_t>(M.size())))
+      return Err;
+
+    for (auto &E : M) {
+      if (auto Err =
+              SerializationTraits<ChannelT, K, K2>::serialize(C, E.first))
+        return Err;
+
+      if (auto Err =
+              SerializationTraits<ChannelT, V, V2>::serialize(C, E.second))
+        return Err;
+    }
+
+    return Error::success();
+  }
+
+  /// Serialize a std::map<K, V> from DenseMap<K2, V2>.
+  static Error deserialize(ChannelT &C, DenseMap<K2, V2> &M) {
+    assert(M.empty() && "Expected default-constructed map to deserialize into");
+
+    uint64_t Count = 0;
+    if (auto Err = deserializeSeq(C, Count))
+      return Err;
+
+    while (Count-- != 0) {
+      std::pair<K2, V2> Val;
+      if (auto Err =
+              SerializationTraits<ChannelT, K, K2>::deserialize(C, Val.first))
+        return Err;
+
+      if (auto Err =
+              SerializationTraits<ChannelT, V, V2>::deserialize(C, Val.second))
+        return Err;
+
+      auto Added = M.insert(Val).second;
+      if (!Added)
+        return make_error<StringError>("Duplicate element in deserialized map",
+                                       orcError(OrcErrorCode::UnknownORCError));
+    }
+
+    return Error::success();
+  }
+};
+
 } // end namespace rpc
 } // end namespace orc
 } // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_ORC_RPC_RPCSERIALIZATION_H

llvm/include/llvm/ExecutionEngine/Orc/Shared/TargetProcessControlTypes.h

+//===--- TargetProcessControlTypes.h -- Shared Core/TPC types ---*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// TargetProcessControl types that are used by both the Orc and
+// OrcTargetProcess libraries.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_ORC_SHARED_TARGETPROCESSCONTROLTYPES_H
+#define LLVM_EXECUTIONENGINE_ORC_SHARED_TARGETPROCESSCONTROLTYPES_H
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ExecutionEngine/JITSymbol.h"
+#include "llvm/ExecutionEngine/Orc/Core.h"
+
+#include <vector>
+
+namespace llvm {
+namespace orc {
+namespace tpctypes {
+
+template <typename T> struct UIntWrite {
+  UIntWrite() = default;
+  UIntWrite(JITTargetAddress Address, T Value)
+      : Address(Address), Value(Value) {}
+
+  JITTargetAddress Address = 0;
+  T Value = 0;
+};
+
+/// Describes a write to a uint8_t.
+using UInt8Write = UIntWrite<uint8_t>;
+
+/// Describes a write to a uint16_t.
+using UInt16Write = UIntWrite<uint16_t>;
+
+/// Describes a write to a uint32_t.
+using UInt32Write = UIntWrite<uint32_t>;
+
+/// Describes a write to a uint64_t.
+using UInt64Write = UIntWrite<uint64_t>;
+
+/// Describes a write to a buffer.
+/// For use with TargetProcessControl::MemoryAccess objects.
+struct BufferWrite {
+  BufferWrite() = default;
+  BufferWrite(JITTargetAddress Address, StringRef Buffer)
+      : Address(Address), Buffer(Buffer) {}
+
+  JITTargetAddress Address = 0;
+  StringRef Buffer;
+};
+
+/// A handle used to represent a loaded dylib in the target process.
+using DylibHandle = JITTargetAddress;
+
+/// A pair of a dylib and a set of symbols to be looked up.
+struct LookupRequest {
+  LookupRequest(DylibHandle Handle, const SymbolLookupSet &Symbols)
+      : Handle(Handle), Symbols(Symbols) {}
+  DylibHandle Handle;
+  const SymbolLookupSet &Symbols;
+};
+
+using LookupResult = std::vector<JITTargetAddress>;
+
+/// Either a uint8_t array or a uint8_t*.
+union CWrapperFunctionResultData {
+  uint8_t Value[8];
+  uint8_t *ValuePtr;
+};
+
+/// C ABI compatible wrapper function result.
+///
+/// This can be safely returned from extern "C" functions, but should be used
+/// to construct a WrapperFunctionResult for safety.
+struct CWrapperFunctionResult {
+  uint64_t Size;
+  CWrapperFunctionResultData Data;
+  void (*Destroy)(CWrapperFunctionResultData Data, uint64_t Size);
+};
+
+/// C++ wrapper function result: Same as CWrapperFunctionResult but
+/// auto-releases memory.
+class WrapperFunctionResult {
+public:
+  /// Create a default WrapperFunctionResult.
+  WrapperFunctionResult() { zeroInit(R); }
+
+  /// Create a WrapperFunctionResult from a CWrapperFunctionResult. This
+  /// instance takes ownership of the result object and will automatically
+  /// call the Destroy member upon destruction.
+  WrapperFunctionResult(CWrapperFunctionResult R) : R(R) {}
+
+  WrapperFunctionResult(const WrapperFunctionResult &) = delete;
+  WrapperFunctionResult &operator=(const WrapperFunctionResult &) = delete;
+
+  WrapperFunctionResult(WrapperFunctionResult &&Other) {
+    zeroInit(R);
+    std::swap(R, Other.R);
+  }
+
+  WrapperFunctionResult &operator=(WrapperFunctionResult &&Other) {
+    CWrapperFunctionResult Tmp;
+    zeroInit(Tmp);
+    std::swap(Tmp, Other.R);
+    std::swap(R, Tmp);
+    return *this;
+  }
+
+  ~WrapperFunctionResult() {
+    if (R.Destroy)
+      R.Destroy(R.Data, R.Size);
+  }
+
+  /// Relinquish ownership of and return the CWrapperFunctionResult.
+  CWrapperFunctionResult release() {
+    CWrapperFunctionResult Tmp;
+    zeroInit(Tmp);
+    std::swap(R, Tmp);
+    return Tmp;
+  }
+
+  /// Get an ArrayRef covering the data in the result.
+  ArrayRef<uint8_t> getData() const {
+    if (R.Size <= 8)
+      return ArrayRef<uint8_t>(R.Data.Value, R.Size);
+    return ArrayRef<uint8_t>(R.Data.ValuePtr, R.Size);
+  }
+
+  /// Create a WrapperFunctionResult from the given integer, provided its
+  /// size is no greater than 64 bits.
+  template <typename T,
+            typename _ = std::enable_if_t<std::is_integral<T>::value &&
+                                          sizeof(T) <= sizeof(uint64_t)>>
+  static WrapperFunctionResult from(T Value) {
+    CWrapperFunctionResult R;
+    R.Size = sizeof(T);
+    memcpy(&R.Data.Value, Value, R.Size);
+    R.Destroy = nullptr;
+    return R;
+  }
+
+  /// Create a WrapperFunctionResult from the given string.
+  static WrapperFunctionResult from(StringRef S);
+
+  /// Always free Data.ValuePtr by calling free on it.
+  static void destroyWithFree(CWrapperFunctionResultData Data, uint64_t Size);
+
+  /// Always free Data.ValuePtr by calling delete[] on it.
+  static void destroyWithDeleteArray(CWrapperFunctionResultData Data,
+                                     uint64_t Size);
+
+private:
+  void zeroInit(CWrapperFunctionResult &R) {
+    R.Size = 0;
+    R.Data.ValuePtr = nullptr;
+    R.Destroy = nullptr;
+  }
+
+  CWrapperFunctionResult R;
+};
+
+} // end namespace tpctypes
+} // end namespace orc
+} // end namespace llvm
+
+#endif // LLVM_EXECUTIONENGINE_ORC_SHARED_TARGETPROCESSCONTROLTYPES_H

llvm/include/llvm/ExecutionEngine/Orc/TPCDynamicLibrarySearchGenerator.h

public:
 
   /// Create a DynamicLibrarySearchGenerator that searches for symbols in the
   /// library with the given handle.
   ///
   /// If the Allow predicate is given then only symbols matching the predicate
   /// will be searched for. If the predicate is not given then all symbols will
   /// be searched for.
   TPCDynamicLibrarySearchGenerator(TargetProcessControl &TPC,
-                                   TargetProcessControl::DylibHandle H,
+                                   tpctypes::DylibHandle H,
                                    SymbolPredicate Allow = SymbolPredicate())
       : TPC(TPC), H(H), Allow(std::move(Allow)) {}
 
   /// Permanently loads the library at the given path and, on success, returns
   /// a DynamicLibrarySearchGenerator that will search it for symbol definitions
   /// in the library. On failure returns the reason the library failed to load.
   static Expected<std::unique_ptr<TPCDynamicLibrarySearchGenerator>>
   Load(TargetProcessControl &TPC, const char *LibraryPath,
        SymbolPredicate Allow = SymbolPredicate());
 
   /// Creates a TPCDynamicLibrarySearchGenerator that searches for symbols in
   /// the target process.
   static Expected<std::unique_ptr<TPCDynamicLibrarySearchGenerator>>
   GetForTargetProcess(TargetProcessControl &TPC,
                       SymbolPredicate Allow = SymbolPredicate()) {
     return Load(TPC, nullptr);
   }
 
   Error tryToGenerate(LookupState &LS, LookupKind K, JITDylib &JD,
                       JITDylibLookupFlags JDLookupFlags,
                       const SymbolLookupSet &Symbols) override;
 
 private:
   TargetProcessControl &TPC;
-  TargetProcessControl::DylibHandle H;
+  tpctypes::DylibHandle H;
   SymbolPredicate Allow;
 };
 
 } // end namespace orc
 } // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_ORC_TPCDYNAMICLIBRARYSEARCHGENERATOR_H

llvm/include/llvm/ExecutionEngine/Orc/TPCEHFrameRegistrar.h

+//===-- TPCEHFrameRegistrar.h - TPC based eh-frame registration -*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// TargetProcessControl based eh-frame registration.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_ORC_TPCEHFRAMEREGISTRAR_H
+#define LLVM_EXECUTIONENGINE_ORC_TPCEHFRAMEREGISTRAR_H
+
+#include "llvm/ExecutionEngine/JITLink/EHFrameSupport.h"
+#include "llvm/ExecutionEngine/Orc/TargetProcessControl.h"
+
+namespace llvm {
+namespace orc {
+
+/// Register/Deregisters EH frames in a remote process via a
+/// TargetProcessControl instance.
+class TPCEHFrameRegistrar : public jitlink::EHFrameRegistrar {
+public:
+  /// Create from a TargetProcessControl instance alone. This will use
+  /// the TPC's lookupSymbols method to find the registration/deregistration
+  /// funciton addresses by name.
+  static Expected<std::unique_ptr<TPCEHFrameRegistrar>>
+  Create(TargetProcessControl &TPC);
+
+  /// Create a TPCEHFrameRegistrar with the given TargetProcessControl
+  /// object and registration/deregistration function addresses.
+  TPCEHFrameRegistrar(TargetProcessControl &TPC,
+                      JITTargetAddress RegisterEHFrameWrapperFnAddr,
+                      JITTargetAddress DeregisterEHFRameWrapperFnAddr)
+      : TPC(TPC), RegisterEHFrameWrapperFnAddr(RegisterEHFrameWrapperFnAddr),
+        DeregisterEHFrameWrapperFnAddr(DeregisterEHFRameWrapperFnAddr) {}
+
+  Error registerEHFrames(JITTargetAddress EHFrameSectionAddr,
+                         size_t EHFrameSectionSize) override;
+  Error deregisterEHFrames(JITTargetAddress EHFrameSectionAddr,
+                           size_t EHFrameSectionSize) override;
+
+private:
+  TargetProcessControl &TPC;
+  JITTargetAddress RegisterEHFrameWrapperFnAddr;
+  JITTargetAddress DeregisterEHFrameWrapperFnAddr;
+};
+
+} // end namespace orc
+} // end namespace llvm
+
+#endif // LLVM_EXECUTIONENGINE_ORC_TPCEHFRAMEREGISTRAR_H

llvm/include/llvm/ExecutionEngine/Orc/TargetProcess/OrcRPCTPCServer.h

+//===-- OrcRPCTPCServer.h -- OrcRPCTargetProcessControl Server --*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// OrcRPCTargetProcessControl server class.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_ORC_TARGETPROCESS_ORCRPCTPCSERVER_H
+#define LLVM_EXECUTIONENGINE_ORC_TARGETPROCESS_ORCRPCTPCSERVER_H
+
+#include "llvm/ADT/BitmaskEnum.h"
+#include "llvm/ExecutionEngine/Orc/RPC/RPCUtils.h"
+#include "llvm/ExecutionEngine/Orc/RPC/RawByteChannel.h"
+#include "llvm/ExecutionEngine/Orc/Shared/TargetProcessControlTypes.h"
+#include "llvm/ExecutionEngine/Orc/TargetProcess/TargetExecutionUtils.h"
+#include "llvm/ExecutionEngine/Orc/TargetProcessControl.h"
+#include "llvm/Support/DynamicLibrary.h"
+#include "llvm/Support/FormatVariadic.h"
+#include "llvm/Support/Host.h"
+#include "llvm/Support/MathExtras.h"
+#include "llvm/Support/Memory.h"
+#include "llvm/Support/Process.h"
+
+#include <atomic>
+
+namespace llvm {
+namespace orc {
+
+namespace orcrpctpc {
+
+enum WireProtectionFlags : uint8_t {
+  WPF_None = 0,
+  WPF_Read = 1U << 0,
+  WPF_Write = 1U << 1,
+  WPF_Exec = 1U << 2,
+  LLVM_MARK_AS_BITMASK_ENUM(WPF_Exec)
+};
+
+/// Convert from sys::Memory::ProtectionFlags
+inline WireProtectionFlags
+toWireProtectionFlags(sys::Memory::ProtectionFlags PF) {
+  WireProtectionFlags WPF = WPF_None;
+  if (PF & sys::Memory::MF_READ)
+    WPF |= WPF_Read;
+  if (PF & sys::Memory::MF_WRITE)
+    WPF |= WPF_Write;
+  if (PF & sys::Memory::MF_EXEC)
+    WPF |= WPF_Exec;
+  return WPF;
+}
+
+inline sys::Memory::ProtectionFlags
+fromWireProtectionFlags(WireProtectionFlags WPF) {
+  int PF = 0;
+  if (WPF & WPF_Read)
+    PF |= sys::Memory::MF_READ;
+  if (WPF & WPF_Write)
+    PF |= sys::Memory::MF_WRITE;
+  if (WPF & WPF_Exec)
+    PF |= sys::Memory::MF_EXEC;
+  return static_cast<sys::Memory::ProtectionFlags>(PF);
+}
+
+struct ReserveMemRequestElement {
+  WireProtectionFlags Prot = WPF_None;
+  uint64_t Size = 0;
+  uint64_t Alignment = 0;
+};
+
+using ReserveMemRequest = std::vector<ReserveMemRequestElement>;
+
+struct ReserveMemResultElement {
+  WireProtectionFlags Prot = WPF_None;
+  JITTargetAddress Address = 0;
+  uint64_t AllocatedSize = 0;
+};
+
+using ReserveMemResult = std::vector<ReserveMemResultElement>;
+
+struct ReleaseOrFinalizeMemRequestElement {
+  WireProtectionFlags Prot = WPF_None;
+  JITTargetAddress Address = 0;
+  uint64_t Size = 0;
+};
+
+using ReleaseOrFinalizeMemRequest =
+    std::vector<ReleaseOrFinalizeMemRequestElement>;
+
+} // end namespace orcrpctpc
+
+namespace rpc {
+
+template <> class RPCTypeName<tpctypes::UInt8Write> {
+public:
+  static const char *getName() { return "UInt8Write"; }
+};
+
+template <> class RPCTypeName<tpctypes::UInt16Write> {
+public:
+  static const char *getName() { return "UInt16Write"; }
+};
+
+template <> class RPCTypeName<tpctypes::UInt32Write> {
+public:
+  static const char *getName() { return "UInt32Write"; }
+};
+
+template <> class RPCTypeName<tpctypes::UInt64Write> {
+public:
+  static const char *getName() { return "UInt64Write"; }
+};
+
+template <> class RPCTypeName<tpctypes::BufferWrite> {
+public:
+  static const char *getName() { return "BufferWrite"; }
+};
+
+template <> class RPCTypeName<orcrpctpc::ReserveMemRequestElement> {
+public:
+  static const char *getName() { return "ReserveMemRequestElement"; }
+};
+
+template <> class RPCTypeName<orcrpctpc::ReserveMemResultElement> {
+public:
+  static const char *getName() { return "ReserveMemResultElement"; }
+};
+
+template <> class RPCTypeName<orcrpctpc::ReleaseOrFinalizeMemRequestElement> {
+public:
+  static const char *getName() { return "ReleaseOrFinalizeMemRequestElement"; }
+};
+
+template <> class RPCTypeName<tpctypes::WrapperFunctionResult> {
+public:
+  static const char *getName() { return "WrapperFunctionResult"; }
+};
+
+template <typename ChannelT, typename WriteT>
+class SerializationTraits<
+    ChannelT, WriteT, WriteT,
+    std::enable_if_t<std::is_same<WriteT, tpctypes::UInt8Write>::value ||
+                     std::is_same<WriteT, tpctypes::UInt16Write>::value ||
+                     std::is_same<WriteT, tpctypes::UInt32Write>::value ||
+                     std::is_same<WriteT, tpctypes::UInt64Write>::value>> {
+public:
+  static Error serialize(ChannelT &C, const WriteT &W) {
+    return serializeSeq(C, W.Address, W.Value);
+  }
+  static Error deserialize(ChannelT &C, WriteT &W) {
+    return deserializeSeq(C, W.Address, W.Value);
+  }
+};
+
+template <typename ChannelT>
+class SerializationTraits<
+    ChannelT, tpctypes::BufferWrite, tpctypes::BufferWrite,
+    std::enable_if_t<std::is_base_of<RawByteChannel, ChannelT>::value>> {
+public:
+  static Error serialize(ChannelT &C, const tpctypes::BufferWrite &W) {
+    uint64_t Size = W.Buffer.size();
+    if (auto Err = serializeSeq(C, W.Address, Size))
+      return Err;
+
+    return C.appendBytes(W.Buffer.data(), Size);
+  }
+  static Error deserialize(ChannelT &C, tpctypes::BufferWrite &W) {
+    JITTargetAddress Address;
+    uint64_t Size;
+
+    if (auto Err = deserializeSeq(C, Address, Size))
+      return Err;
+
+    char *Buffer = jitTargetAddressToPointer<char *>(Address);
+
+    if (auto Err = C.readBytes(Buffer, Size))
+      return Err;
+
+    W = {Address, StringRef(Buffer, Size)};
+    return Error::success();
+  }
+};
+
+template <typename ChannelT>
+class SerializationTraits<ChannelT, orcrpctpc::ReserveMemRequestElement> {
+public:
+  static Error serialize(ChannelT &C,
+                         const orcrpctpc::ReserveMemRequestElement &E) {
+    return serializeSeq(C, static_cast<uint8_t>(E.Prot), E.Size, E.Alignment);
+  }
+
+  static Error deserialize(ChannelT &C,
+                           orcrpctpc::ReserveMemRequestElement &E) {
+    return deserializeSeq(C, *reinterpret_cast<uint8_t *>(&E.Prot), E.Size,
+                          E.Alignment);
+  }
+};
+
+template <typename ChannelT>
+class SerializationTraits<ChannelT, orcrpctpc::ReserveMemResultElement> {
+public:
+  static Error serialize(ChannelT &C,
+                         const orcrpctpc::ReserveMemResultElement &E) {
+    return serializeSeq(C, static_cast<uint8_t>(E.Prot), E.Address,
+                        E.AllocatedSize);
+  }
+
+  static Error deserialize(ChannelT &C, orcrpctpc::ReserveMemResultElement &E) {
+    return deserializeSeq(C, *reinterpret_cast<uint8_t *>(&E.Prot), E.Address,
+                          E.AllocatedSize);
+  }
+};
+
+template <typename ChannelT>
+class SerializationTraits<ChannelT,
+                          orcrpctpc::ReleaseOrFinalizeMemRequestElement> {
+public:
+  static Error
+  serialize(ChannelT &C,
+            const orcrpctpc::ReleaseOrFinalizeMemRequestElement &E) {
+    return serializeSeq(C, static_cast<uint8_t>(E.Prot), E.Address, E.Size);
+  }
+
+  static Error deserialize(ChannelT &C,
+                           orcrpctpc::ReleaseOrFinalizeMemRequestElement &E) {
+    return deserializeSeq(C, *reinterpret_cast<uint8_t *>(&E.Prot), E.Address,
+                          E.Size);
+  }
+};
+
+template <typename ChannelT>
+class SerializationTraits<
+    ChannelT, tpctypes::WrapperFunctionResult, tpctypes::WrapperFunctionResult,
+    std::enable_if_t<std::is_base_of<RawByteChannel, ChannelT>::value>> {
+public:
+  static Error serialize(ChannelT &C,
+                         const tpctypes::WrapperFunctionResult &E) {
+    auto Data = E.getData();
+    if (auto Err = serializeSeq(C, static_cast<uint64_t>(Data.size())))
+      return Err;
+    if (Data.size() == 0)
+      return Error::success();
+    return C.appendBytes(reinterpret_cast<const char *>(Data.data()),
+                         Data.size());
+  }
+
+  static Error deserialize(ChannelT &C, tpctypes::WrapperFunctionResult &E) {
+    tpctypes::CWrapperFunctionResult R;
+
+    R.Size = 0;
+    R.Data.ValuePtr = nullptr;
+    R.Destroy = nullptr;
+
+    if (auto Err = deserializeSeq(C, R.Size))
+      return Err;
+    if (R.Size == 0)
+      return Error::success();
+    R.Data.ValuePtr = new uint8_t[R.Size];
+    if (auto Err =
+            C.readBytes(reinterpret_cast<char *>(R.Data.ValuePtr), R.Size)) {
+      R.Destroy = tpctypes::WrapperFunctionResult::destroyWithDeleteArray;
+      return Err;
+    }
+
+    E = tpctypes::WrapperFunctionResult(R);
+    return Error::success();
+  }
+};
+
+} // end namespace rpc
+
+namespace orcrpctpc {
+
+using RemoteSymbolLookupSet = std::vector<std::pair<std::string, bool>>;
+using RemoteLookupRequest =
+    std::pair<tpctypes::DylibHandle, RemoteSymbolLookupSet>;
+
+class GetTargetTriple : public rpc::Function<GetTargetTriple, std::string()> {
+public:
+  static const char *getName() { return "GetTargetTriple"; }
+};
+
+class GetPageSize : public rpc::Function<GetPageSize, uint64_t()> {
+public:
+  static const char *getName() { return "GetPageSize"; }
+};
+
+class ReserveMem : public rpc::Function<ReserveMem, Expected<ReserveMemResult>(
+                                                        ReserveMemRequest)> {
+public:
+  static const char *getName() { return "ReserveMem"; }
+};
+
+class FinalizeMem
+    : public rpc::Function<FinalizeMem, Error(ReleaseOrFinalizeMemRequest)> {
+public:
+  static const char *getName() { return "FinalizeMem"; }
+};
+
+class ReleaseMem
+    : public rpc::Function<ReleaseMem, Error(ReleaseOrFinalizeMemRequest)> {
+public:
+  static const char *getName() { return "ReleaseMem"; }
+};
+
+class WriteUInt8s
+    : public rpc::Function<WriteUInt8s,
+                           Error(std::vector<tpctypes::UInt8Write>)> {
+public:
+  static const char *getName() { return "WriteUInt8s"; }
+};
+
+class WriteUInt16s
+    : public rpc::Function<WriteUInt16s,
+                           Error(std::vector<tpctypes::UInt16Write>)> {
+public:
+  static const char *getName() { return "WriteUInt16s"; }
+};
+
+class WriteUInt32s
+    : public rpc::Function<WriteUInt32s,
+                           Error(std::vector<tpctypes::UInt32Write>)> {
+public:
+  static const char *getName() { return "WriteUInt32s"; }
+};
+
+class WriteUInt64s
+    : public rpc::Function<WriteUInt64s,
+                           Error(std::vector<tpctypes::UInt64Write>)> {
+public:
+  static const char *getName() { return "WriteUInt64s"; }
+};
+
+class WriteBuffers
+    : public rpc::Function<WriteBuffers,
+                           Error(std::vector<tpctypes::BufferWrite>)> {
+public:
+  static const char *getName() { return "WriteBuffers"; }
+};
+
+class LoadDylib
+    : public rpc::Function<LoadDylib, Expected<tpctypes::DylibHandle>(
+                                          std::string DylibPath)> {
+public:
+  static const char *getName() { return "LoadDylib"; }
+};
+
+class LookupSymbols
+    : public rpc::Function<LookupSymbols,
+                           Expected<std::vector<tpctypes::LookupResult>>(
+                               std::vector<RemoteLookupRequest>)> {
+public:
+  static const char *getName() { return "LookupSymbols"; }
+};
+
+class RunMain
+    : public rpc::Function<RunMain, int32_t(JITTargetAddress MainAddr,
+                                            std::vector<std::string> Args)> {
+public:
+  static const char *getName() { return "RunMain"; }
+};
+
+class RunWrapper
+    : public rpc::Function<RunWrapper,
+                           tpctypes::WrapperFunctionResult(
+                               JITTargetAddress, std::vector<uint8_t>)> {
+public:
+  static const char *getName() { return "RunWrapper"; }
+};
+
+class CloseConnection : public rpc::Function<CloseConnection, void()> {
+public:
+  static const char *getName() { return "CloseConnection"; }
+};
+
+} // end namespace orcrpctpc
+
+/// TargetProcessControl for a process connected via an ORC RPC Endpoint.
+template <typename RPCEndpointT> class OrcRPCTPCServer {
+public:
+  /// Create an OrcRPCTPCServer from the given endpoint.
+  OrcRPCTPCServer(RPCEndpointT &EP) : EP(EP) {
+    using ThisT = OrcRPCTPCServer<RPCEndpointT>;
+
+    TripleStr = sys::getProcessTriple();
+    PageSize = sys::Process::getPageSizeEstimate();
+
+    EP.template addHandler<orcrpctpc::GetTargetTriple>(*this,
+                                                       &ThisT::getTargetTriple);
+    EP.template addHandler<orcrpctpc::GetPageSize>(*this, &ThisT::getPageSize);
+
+    EP.template addHandler<orcrpctpc::ReserveMem>(*this, &ThisT::reserveMemory);
+    EP.template addHandler<orcrpctpc::FinalizeMem>(*this,
+                                                   &ThisT::finalizeMemory);
+    EP.template addHandler<orcrpctpc::ReleaseMem>(*this, &ThisT::releaseMemory);
+
+    EP.template addHandler<orcrpctpc::WriteUInt8s>(
+        handleWriteUInt<tpctypes::UInt8Write>);
+    EP.template addHandler<orcrpctpc::WriteUInt16s>(
+        handleWriteUInt<tpctypes::UInt16Write>);
+    EP.template addHandler<orcrpctpc::WriteUInt32s>(
+        handleWriteUInt<tpctypes::UInt32Write>);
+    EP.template addHandler<orcrpctpc::WriteUInt64s>(
+        handleWriteUInt<tpctypes::UInt64Write>);
+    EP.template addHandler<orcrpctpc::WriteBuffers>(handleWriteBuffer);
+
+    EP.template addHandler<orcrpctpc::LoadDylib>(*this, &ThisT::loadDylib);
+    EP.template addHandler<orcrpctpc::LookupSymbols>(*this,
+                                                     &ThisT::lookupSymbols);
+
+    EP.template addHandler<orcrpctpc::RunMain>(*this, &ThisT::runMain);
+    EP.template addHandler<orcrpctpc::RunWrapper>(*this, &ThisT::runWrapper);
+
+    EP.template addHandler<orcrpctpc::CloseConnection>(*this,
+                                                       &ThisT::closeConnection);
+  }
+
+  /// Set the ProgramName to be used as the first argv element when running
+  /// functions via runAsMain.
+  void setProgramName(Optional<std::string> ProgramName = None) {
+    this->ProgramName = std::move(ProgramName);
+  }
+
+  /// Get the RPC endpoint for this server.
+  RPCEndpointT &getEndpoint() { return EP; }
+
+  /// Run the server loop.
+  Error run() {
+    while (!Finished) {
+      if (auto Err = EP.handleOne())
+        return Err;
+    }
+    return Error::success();
+  }
+
+private:
+  std::string getTargetTriple() { return TripleStr; }
+  uint64_t getPageSize() { return PageSize; }
+
+  template <typename WriteT>
+  static void handleWriteUInt(const std::vector<WriteT> &Ws) {
+    using ValueT = decltype(std::declval<WriteT>().Value);
+    for (auto &W : Ws)
+      *jitTargetAddressToPointer<ValueT *>(W.Address) = W.Value;
+  }
+
+  std::string getProtStr(orcrpctpc::WireProtectionFlags WPF) {
+    std::string Result;
+    Result += (WPF & orcrpctpc::WPF_Read) ? 'R' : '-';
+    Result += (WPF & orcrpctpc::WPF_Write) ? 'W' : '-';
+    Result += (WPF & orcrpctpc::WPF_Exec) ? 'X' : '-';
+    return Result;
+  }
+
+  static void handleWriteBuffer(const std::vector<tpctypes::BufferWrite> &Ws) {
+    for (auto &W : Ws) {
+      memcpy(jitTargetAddressToPointer<char *>(W.Address), W.Buffer.data(),
+             W.Buffer.size());
+    }
+  }
+
+  Expected<orcrpctpc::ReserveMemResult>
+  reserveMemory(const orcrpctpc::ReserveMemRequest &Request) {
+    orcrpctpc::ReserveMemResult Allocs;
+    auto PF = sys::Memory::MF_READ | sys::Memory::MF_WRITE;
+
+    uint64_t TotalSize = 0;
+
+    for (const auto &E : Request) {
+      uint64_t Size = alignTo(E.Size, PageSize);
+      uint16_t Align = E.Alignment;
+
+      if ((Align > PageSize) || (PageSize % Align))
+        return make_error<StringError>(
+            "Page alignmen does not satisfy requested alignment",
+            inconvertibleErrorCode());
+
+      TotalSize += Size;
+    }
+
+    // Allocate memory slab.
+    std::error_code EC;
+    auto MB = sys::Memory::allocateMappedMemory(TotalSize, nullptr, PF, EC);
+    if (EC)
+      return make_error<StringError>("Unable to allocate memory: " +
+                                         EC.message(),
+                                     inconvertibleErrorCode());
+
+    // Zero-fill the whole thing.
+    memset(MB.base(), 0, MB.allocatedSize());
+
+    // Carve up sections to return.
+    uint64_t SectionBase = 0;
+    for (const auto &E : Request) {
+      uint64_t SectionSize = alignTo(E.Size, PageSize);
+      Allocs.push_back({E.Prot,
+                        pointerToJITTargetAddress(MB.base()) + SectionBase,
+                        SectionSize});
+      SectionBase += SectionSize;
+    }
+
+    return Allocs;
+  }
+
+  Error finalizeMemory(const orcrpctpc::ReleaseOrFinalizeMemRequest &FMR) {
+    for (const auto &E : FMR) {
+      sys::MemoryBlock MB(jitTargetAddressToPointer<void *>(E.Address), E.Size);
+
+      auto PF = orcrpctpc::fromWireProtectionFlags(E.Prot);
+      if (auto EC =
+              sys::Memory::protectMappedMemory(MB, static_cast<unsigned>(PF)))
+        return make_error<StringError>("error protecting memory: " +
+                                           EC.message(),
+                                       inconvertibleErrorCode());
+    }
+    return Error::success();
+  }
+
+  Error releaseMemory(const orcrpctpc::ReleaseOrFinalizeMemRequest &RMR) {
+    for (const auto &E : RMR) {
+      sys::MemoryBlock MB(jitTargetAddressToPointer<void *>(E.Address), E.Size);
+
+      if (auto EC = sys::Memory::releaseMappedMemory(MB))
+        return make_error<StringError>("error release memory: " + EC.message(),
+                                       inconvertibleErrorCode());
+    }
+    return Error::success();
+  }
+
+  Expected<tpctypes::DylibHandle> loadDylib(const std::string &Path) {
+    std::string ErrMsg;
+    const char *DLPath = !Path.empty() ? Path.c_str() : nullptr;
+    auto DL = sys::DynamicLibrary::getPermanentLibrary(DLPath, &ErrMsg);
+    if (!DL.isValid())
+      return make_error<StringError>(std::move(ErrMsg),
+                                     inconvertibleErrorCode());
+
+    tpctypes::DylibHandle H = Dylibs.size();
+    Dylibs[H] = std::move(DL);
+    return H;
+  }
+
+  Expected<std::vector<tpctypes::LookupResult>>
+  lookupSymbols(const std::vector<orcrpctpc::RemoteLookupRequest> &Request) {
+    std::vector<tpctypes::LookupResult> Result;
+
+    for (const auto &E : Request) {
+      auto I = Dylibs.find(E.first);
+      if (I == Dylibs.end())
+        return make_error<StringError>("Unrecognized handle",
+                                       inconvertibleErrorCode());
+      auto &DL = I->second;
+      Result.push_back({});
+
+      for (const auto &KV : E.second) {
+        auto &SymString = KV.first;
+        bool WeakReference = KV.second;
+
+        const char *Sym = SymString.c_str();
+#ifdef __APPLE__
+        if (*Sym == '_')
+          ++Sym;
+#endif
+
+        void *Addr = DL.getAddressOfSymbol(Sym);
+        if (!Addr && !WeakReference)
+          return make_error<StringError>(Twine("Missing definition for ") + Sym,
+                                         inconvertibleErrorCode());
+
+        Result.back().push_back(pointerToJITTargetAddress(Addr));
+      }
+    }
+
+    return Result;
+  }
+
+  int32_t runMain(JITTargetAddress MainFnAddr,
+                  const std::vector<std::string> &Args) {
+    Optional<StringRef> ProgramNameOverride;
+    if (ProgramName)
+      ProgramNameOverride = *ProgramName;
+
+    return runAsMain(
+        jitTargetAddressToFunction<int (*)(int, char *[])>(MainFnAddr), Args,
+        ProgramNameOverride);
+  }
+
+  tpctypes::WrapperFunctionResult
+  runWrapper(JITTargetAddress WrapperFnAddr,
+             const std::vector<uint8_t> &ArgBuffer) {
+    using WrapperFnTy = tpctypes::CWrapperFunctionResult (*)(
+        const uint8_t *Data, uint64_t Size);
+    auto *WrapperFn = jitTargetAddressToFunction<WrapperFnTy>(WrapperFnAddr);
+    return WrapperFn(ArgBuffer.data(), ArgBuffer.size());
+  }
+
+  void closeConnection() { Finished = true; }
+
+  std::string TripleStr;
+  uint64_t PageSize = 0;
+  Optional<std::string> ProgramName;
+  RPCEndpointT &EP;
+  std::atomic<bool> Finished{false};
+  DenseMap<tpctypes::DylibHandle, sys::DynamicLibrary> Dylibs;
+};
+
+} // end namespace orc
+} // end namespace llvm
+
+#endif // LLVM_EXECUTIONENGINE_ORC_TARGETPROCESS_ORCRPCTPCSERVER_H

llvm/include/llvm/ExecutionEngine/Orc/TargetProcess/RegisterEHFrames.h

+//===----- RegisterEHFrames.h -- Register EH frame sections -----*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Support for dynamically registering and deregistering eh-frame sections
+// in-process via libunwind.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_ORC_TARGETPROCESS_REGISTEREHFRAMES_H
+#define LLVM_EXECUTIONENGINE_ORC_TARGETPROCESS_REGISTEREHFRAMES_H
+
+#include "llvm/ExecutionEngine/Orc/Shared/TargetProcessControlTypes.h"
+#include "llvm/Support/Error.h"
+#include <vector>
+
+namespace llvm {
+namespace orc {
+
+/// Register frames in the given eh-frame section with libunwind.
+Error registerEHFrameSection(const void *EHFrameSectionAddr,
+                             size_t EHFrameSectionSize);
+
+/// Unregister frames in the given eh-frame section with libunwind.
+Error deregisterEHFrameSection(const void *EHFrameSectionAddr,
+                               size_t EHFrameSectionSize);
+
+} // end namespace orc
+} // end namespace llvm
+
+extern "C" llvm::orc::tpctypes::CWrapperFunctionResult
+llvm_orc_registerEHFrameSectionWrapper(uint8_t *Data, uint64_t Size);
+
+extern "C" llvm::orc::tpctypes::CWrapperFunctionResult
+llvm_orc_deregisterEHFrameSectionWrapper(uint8_t *Data, uint64_t Size);
+
+#endif // LLVM_EXECUTIONENGINE_ORC_TARGETPROCESS_REGISTEREHFRAMES_H

llvm/include/llvm/ExecutionEngine/Orc/TargetProcess/TargetExecutionUtils.h

+//===-- TargetExecutionUtils.h - Utils for execution in target --*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Utilities for execution in the target process.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_ORC_TARGETPROCESS_TARGETEXECUTIONUTILS_H
+#define LLVM_EXECUTIONENGINE_ORC_TARGETPROCESS_TARGETEXECUTIONUTILS_H
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/Optional.h"
+#include "llvm/ADT/StringRef.h"
+#include <string>
+
+namespace llvm {
+namespace orc {
+
+/// Run a main function, returning the result.
+///
+/// If the optional ProgramName argument is given then it will be inserted
+/// before the strings in Args as the first argument to the called function.
+///
+/// It is legal to have an empty argument list and no program name, however
+/// many main functions will expect a name argument at least, and will fail
+/// if none is provided.
+int runAsMain(int (*Main)(int, char *[]), ArrayRef<std::string> Args,
+              Optional<StringRef> ProgramName = None);
+
+} // end namespace orc
+} // end namespace llvm
+
+#endif // LLVM_EXECUTIONENGINE_ORC_TARGETPROCESS_TARGETEXECUTIONUTILS_H

llvm/include/llvm/ExecutionEngine/Orc/TargetProcessControl.h

 #ifndef LLVM_EXECUTIONENGINE_ORC_TARGETPROCESSCONTROL_H
 #define LLVM_EXECUTIONENGINE_ORC_TARGETPROCESSCONTROL_H
 
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/ExecutionEngine/JITLink/JITLinkMemoryManager.h"
 #include "llvm/ExecutionEngine/Orc/Core.h"
+#include "llvm/ExecutionEngine/Orc/Shared/TargetProcessControlTypes.h"
 #include "llvm/Support/DynamicLibrary.h"
 #include "llvm/Support/MSVCErrorWorkarounds.h"
 
 #include <future>
 #include <vector>
 
 namespace llvm {
 namespace orc {
 
 /// TargetProcessControl supports interaction with a JIT target process.
 class TargetProcessControl {
 public:
   /// APIs for manipulating memory in the target process.
   class MemoryAccess {
   public:
-    template <typename T> struct UIntWrite {
-      UIntWrite() = default;
-      UIntWrite(JITTargetAddress Address, T Value)
-          : Address(Address), Value(Value) {}
-
-      JITTargetAddress Address = 0;
-      T Value = 0;
-    };
-
-    using UInt8Write = UIntWrite<uint8_t>;
-    using UInt16Write = UIntWrite<uint16_t>;
-    using UInt32Write = UIntWrite<uint32_t>;
-    using UInt64Write = UIntWrite<uint64_t>;
-
-    struct BufferWrite {
-      BufferWrite(JITTargetAddress Address, StringRef Buffer)
-          : Address(Address), Buffer(Buffer) {}
-
-      JITTargetAddress Address = 0;
-      StringRef Buffer;
-    };
-
+    /// Callback function for asynchronous writes.
     using WriteResultFn = unique_function<void(Error)>;
 
     virtual ~MemoryAccess();
 
-    virtual void writeUInt8s(ArrayRef<UInt8Write> Ws,
+    virtual void writeUInt8s(ArrayRef<tpctypes::UInt8Write> Ws,
                              WriteResultFn OnWriteComplete) = 0;
 
-    virtual void writeUInt16s(ArrayRef<UInt16Write> Ws,
+    virtual void writeUInt16s(ArrayRef<tpctypes::UInt16Write> Ws,
                               WriteResultFn OnWriteComplete) = 0;
 
-    virtual void writeUInt32s(ArrayRef<UInt32Write> Ws,
+    virtual void writeUInt32s(ArrayRef<tpctypes::UInt32Write> Ws,
                               WriteResultFn OnWriteComplete) = 0;
 
-    virtual void writeUInt64s(ArrayRef<UInt64Write> Ws,
+    virtual void writeUInt64s(ArrayRef<tpctypes::UInt64Write> Ws,
                               WriteResultFn OnWriteComplete) = 0;
 
-    virtual void writeBuffers(ArrayRef<BufferWrite> Ws,
+    virtual void writeBuffers(ArrayRef<tpctypes::BufferWrite> Ws,
                               WriteResultFn OnWriteComplete) = 0;
 
-    Error writeUInt8s(ArrayRef<UInt8Write> Ws) {
+    Error writeUInt8s(ArrayRef<tpctypes::UInt8Write> Ws) {
       std::promise<MSVCPError> ResultP;
       auto ResultF = ResultP.get_future();
       writeUInt8s(Ws, [&](Error Err) { ResultP.set_value(std::move(Err)); });
       return ResultF.get();
     }
 
-    Error writeUInt16s(ArrayRef<UInt16Write> Ws) {
+    Error writeUInt16s(ArrayRef<tpctypes::UInt16Write> Ws) {
       std::promise<MSVCPError> ResultP;
       auto ResultF = ResultP.get_future();
       writeUInt16s(Ws, [&](Error Err) { ResultP.set_value(std::move(Err)); });
       return ResultF.get();
     }
 
-    Error writeUInt32s(ArrayRef<UInt32Write> Ws) {
+    Error writeUInt32s(ArrayRef<tpctypes::UInt32Write> Ws) {
       std::promise<MSVCPError> ResultP;
       auto ResultF = ResultP.get_future();
       writeUInt32s(Ws, [&](Error Err) { ResultP.set_value(std::move(Err)); });
       return ResultF.get();
     }
 
-    Error writeUInt64s(ArrayRef<UInt64Write> Ws) {
+    Error writeUInt64s(ArrayRef<tpctypes::UInt64Write> Ws) {
       std::promise<MSVCPError> ResultP;
       auto ResultF = ResultP.get_future();
       writeUInt64s(Ws, [&](Error Err) { ResultP.set_value(std::move(Err)); });
       return ResultF.get();
     }
 
-    Error writeBuffers(ArrayRef<BufferWrite> Ws) {
+    Error writeBuffers(ArrayRef<tpctypes::BufferWrite> Ws) {
       std::promise<MSVCPError> ResultP;
       auto ResultF = ResultP.get_future();
       writeBuffers(Ws, [&](Error Err) { ResultP.set_value(std::move(Err)); });
       return ResultF.get();
     }
   };
 
-  /// A handle for a library opened via loadDylib.
-  ///
-  /// Note that this handle does not necessarily represent a JITDylib: it may
-  /// be a regular dynamic library or shared object (e.g. one opened via a
-  /// dlopen in the target process).
-  using DylibHandle = JITTargetAddress;
-
-  /// Request lookup within the given DylibHandle.
-  struct LookupRequestElement {
-    LookupRequestElement(DylibHandle Handle, const SymbolLookupSet &Symbols)
-        : Handle(Handle), Symbols(Symbols) {}
-    DylibHandle Handle;
-    const SymbolLookupSet &Symbols;
-  };
-
-  using LookupRequest = ArrayRef<LookupRequestElement>;
+  virtual ~TargetProcessControl();
 
-  using LookupResult = std::vector<std::vector<JITTargetAddress>>;
+  /// Intern a symbol name in the SymbolStringPool.
+  SymbolStringPtr intern(StringRef SymName) { return SSP->intern(SymName); }
 
-  virtual ~TargetProcessControl();
+  /// Return a shared pointer to the SymbolStringPool for this instance.
+  std::shared_ptr<SymbolStringPool> getSymbolStringPool() const { return SSP; }
 
   /// Return the Triple for the target process.
-  const Triple &getTargetTriple() const { return TT; }
+  const Triple &getTargetTriple() const { return TargetTriple; }
 
   /// Get the page size for the target process.
   unsigned getPageSize() const { return PageSize; }
 
-  /// Return a JITLinkMemoryManager for the target process.
-  jitlink::JITLinkMemoryManager &getMemMgr() const { return *MemMgr; }
-
   /// Return a MemoryAccess object for the target process.
   MemoryAccess &getMemoryAccess() const { return *MemAccess; }
 
+  /// Return a JITLinkMemoryManager for the target process.
+  jitlink::JITLinkMemoryManager &getMemMgr() const { return *MemMgr; }
+
   /// Load the dynamic library at the given path and return a handle to it.
   /// If LibraryPath is null this function will return the global handle for
   /// the target process.
-  virtual Expected<DylibHandle> loadDylib(const char *DylibPath) = 0;
+  virtual Expected<tpctypes::DylibHandle> loadDylib(const char *DylibPath) = 0;
 
   /// Search for symbols in the target process.
   ///
   /// The result of the lookup is a 2-dimentional array of target addresses
   /// that correspond to the lookup order. If a required symbol is not
   /// found then this method will return an error. If a weakly referenced
   /// symbol is not found then it be assigned a '0' value in the result.
-  virtual Expected<LookupResult> lookupSymbols(LookupRequest Request) = 0;
+  /// that correspond to the lookup order.
+  virtual Expected<std::vector<tpctypes::LookupResult>>
+  lookupSymbols(ArrayRef<tpctypes::LookupRequest> Request) = 0;
+
+  /// Run function with a main-like signature.
+  virtual Expected<int32_t> runAsMain(JITTargetAddress MainFnAddr,
+                                      ArrayRef<std::string> Args) = 0;
+
+  /// Run a wrapper function with signature:
+  ///
+  /// \code{.cpp}
+  ///   CWrapperFunctionResult fn(uint8_t *Data, uint64_t Size);
+  /// \endcode{.cpp}
+  ///
+  virtual Expected<tpctypes::WrapperFunctionResult>
+  runWrapper(JITTargetAddress WrapperFnAddr, ArrayRef<uint8_t> ArgBuffer) = 0;
+
+  /// Disconnect from the target process.
+  ///
+  /// This should be called after the JIT session is shut down.
+  virtual Error disconnect() = 0;
 
 protected:
+  TargetProcessControl(std::shared_ptr<SymbolStringPool> SSP)
+      : SSP(std::move(SSP)) {}
 
-  Triple TT;
+  std::shared_ptr<SymbolStringPool> SSP;
+  Triple TargetTriple;
   unsigned PageSize = 0;
-  jitlink::JITLinkMemoryManager *MemMgr = nullptr;
   MemoryAccess *MemAccess = nullptr;
+  jitlink::JITLinkMemoryManager *MemMgr = nullptr;
 };
 
 /// A TargetProcessControl implementation targeting the current process.
 class SelfTargetProcessControl : public TargetProcessControl,
                                  private TargetProcessControl::MemoryAccess {
 public:
   SelfTargetProcessControl(
-      Triple TT, unsigned PageSize,
-      std::unique_ptr<jitlink::JITLinkMemoryManager> MemMgr);
+      std::shared_ptr<SymbolStringPool> SSP, Triple TargetTriple,
+      unsigned PageSize, std::unique_ptr<jitlink::JITLinkMemoryManager> MemMgr);
 
   /// Create a SelfTargetProcessControl with the given memory manager.
   /// If no memory manager is given a jitlink::InProcessMemoryManager will
   /// be used by default.
   static Expected<std::unique_ptr<SelfTargetProcessControl>>
-  Create(std::unique_ptr<jitlink::JITLinkMemoryManager> MemMgr = nullptr);
+  Create(std::shared_ptr<SymbolStringPool> SSP,
+         std::unique_ptr<jitlink::JITLinkMemoryManager> MemMgr = nullptr);
+
+  Expected<tpctypes::DylibHandle> loadDylib(const char *DylibPath) override;
+
+  Expected<std::vector<tpctypes::LookupResult>>
+  lookupSymbols(ArrayRef<tpctypes::LookupRequest> Request) override;
+
+  Expected<int32_t> runAsMain(JITTargetAddress MainFnAddr,
+                              ArrayRef<std::string> Args) override;
 
-  Expected<DylibHandle> loadDylib(const char *DylibPath) override;
+  Expected<tpctypes::WrapperFunctionResult>
+  runWrapper(JITTargetAddress WrapperFnAddr,
+             ArrayRef<uint8_t> ArgBuffer) override;
 
-  Expected<LookupResult> lookupSymbols(LookupRequest Request) override;
+  Error disconnect() override;
 
 private:
-  void writeUInt8s(ArrayRef<UInt8Write> Ws,
+  void writeUInt8s(ArrayRef<tpctypes::UInt8Write> Ws,
                    WriteResultFn OnWriteComplete) override;
 
-  void writeUInt16s(ArrayRef<UInt16Write> Ws,
+  void writeUInt16s(ArrayRef<tpctypes::UInt16Write> Ws,
                     WriteResultFn OnWriteComplete) override;
 
-  void writeUInt32s(ArrayRef<UInt32Write> Ws,
+  void writeUInt32s(ArrayRef<tpctypes::UInt32Write> Ws,
                     WriteResultFn OnWriteComplete) override;
 
-  void writeUInt64s(ArrayRef<UInt64Write> Ws,
+  void writeUInt64s(ArrayRef<tpctypes::UInt64Write> Ws,
                     WriteResultFn OnWriteComplete) override;
 
-  void writeBuffers(ArrayRef<BufferWrite> Ws,
+  void writeBuffers(ArrayRef<tpctypes::BufferWrite> Ws,
                     WriteResultFn OnWriteComplete) override;
 
   std::unique_ptr<jitlink::JITLinkMemoryManager> OwnedMemMgr;
   char GlobalManglingPrefix = 0;
   std::vector<std::unique_ptr<sys::DynamicLibrary>> DynamicLibraries;
 };
 
 } // end namespace orc
 } // end namespace llvm
 
 #endif // LLVM_EXECUTIONENGINE_ORC_TARGETPROCESSCONTROL_H

llvm/lib/ExecutionEngine/CMakeLists.txt

 
 if(BUILD_SHARED_LIBS)
   target_link_libraries(LLVMExecutionEngine PUBLIC LLVMRuntimeDyld)
 endif()
 
 add_subdirectory(Interpreter)
 add_subdirectory(JITLink)
 add_subdirectory(MCJIT)
-add_subdirectory(OrcError)
 add_subdirectory(Orc)
 add_subdirectory(RuntimeDyld)
 
 if( LLVM_USE_OPROFILE )
   add_subdirectory(OProfileJIT)
 endif( LLVM_USE_OPROFILE )
 
 if( LLVM_USE_INTEL_JITEVENTS )
   add_subdirectory(IntelJITEvents)
 endif( LLVM_USE_INTEL_JITEVENTS )
 
 if( LLVM_USE_PERF )
   add_subdirectory(PerfJITEvents)
 endif( LLVM_USE_PERF )

llvm/lib/ExecutionEngine/JITLink/CMakeLists.txt

add_llvm_component_library(LLVMJITLink
 
   DEPENDS
   intrinsics_gen
   )
  
 target_link_libraries(LLVMJITLink
   PRIVATE
   LLVMObject
+  LLVMOrcTargetProcess
+  LLVMSupport
 )

llvm/lib/ExecutionEngine/JITLink/EHFrameSupport.cpp

 //===-------- JITLink_EHFrameSupport.cpp - JITLink eh-frame utils ---------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "EHFrameSupportImpl.h"
 
 #include "llvm/BinaryFormat/Dwarf.h"
 #include "llvm/Config/config.h"
+#include "llvm/ExecutionEngine/Orc/TargetProcess/RegisterEHFrames.h"
 #include "llvm/Support/DynamicLibrary.h"
 
 #define DEBUG_TYPE "jitlink"
 
 namespace llvm {
 namespace jitlink {
 
 EHFrameSplitter::EHFrameSplitter(StringRef EHFrameSectionName)
Expected<Symbol &> EHFrameEdgeFixer::getOrCreateSymbol(ParseContext &PC,
   auto *B = PC.AddrToBlock.getBlockCovering(Addr);
   if (!B)
     return make_error<JITLinkError>("No symbol or block covering address " +
                                     formatv("{0:x16}", Addr));
 
   return PC.G.addAnonymousSymbol(*B, Addr - B->getAddress(), 0, false, false);
 }
 
-#if defined(HAVE_REGISTER_FRAME) && defined(HAVE_DEREGISTER_FRAME) &&          \
-    !defined(__SEH__) && !defined(__USING_SJLJ_EXCEPTIONS__)
-extern "C" void __register_frame(const void *);
-extern "C" void __deregister_frame(const void *);
-
-Error registerFrameWrapper(const void *P) {
-  __register_frame(P);
-  return Error::success();
-}
-
-Error deregisterFrameWrapper(const void *P) {
-  __deregister_frame(P);
-  return Error::success();
-}
-
-#else
-
-// The building compiler does not have __(de)register_frame but
-// it may be found at runtime in a dynamically-loaded library.
-// For example, this happens when building LLVM with Visual C++
-// but using the MingW runtime.
-static Error registerFrameWrapper(const void *P) {
-  static void((*RegisterFrame)(const void *)) = 0;
-
-  if (!RegisterFrame)
-    *(void **)&RegisterFrame =
-        llvm::sys::DynamicLibrary::SearchForAddressOfSymbol("__register_frame");
-
-  if (RegisterFrame) {
-    RegisterFrame(P);
-    return Error::success();
-  }
-
-  return make_error<JITLinkError>("could not register eh-frame: "
-                                  "__register_frame function not found");
-}
-
-static Error deregisterFrameWrapper(const void *P) {
-  static void((*DeregisterFrame)(const void *)) = 0;
-
-  if (!DeregisterFrame)
-    *(void **)&DeregisterFrame =
-        llvm::sys::DynamicLibrary::SearchForAddressOfSymbol(
-            "__deregister_frame");
-
-  if (DeregisterFrame) {
-    DeregisterFrame(P);
-    return Error::success();
-  }
-
-  return make_error<JITLinkError>("could not deregister eh-frame: "
-                                  "__deregister_frame function not found");
-}
-#endif
-
-#ifdef __APPLE__
-
-template <typename HandleFDEFn>
-Error walkAppleEHFrameSection(const char *const SectionStart,
-                              size_t SectionSize,
-                              HandleFDEFn HandleFDE) {
-  const char *CurCFIRecord = SectionStart;
-  const char *End = SectionStart + SectionSize;
-  uint64_t Size = *reinterpret_cast<const uint32_t *>(CurCFIRecord);
-
-  while (CurCFIRecord != End && Size != 0) {
-    const char *OffsetField = CurCFIRecord + (Size == 0xffffffff ? 12 : 4);
-    if (Size == 0xffffffff)
-      Size = *reinterpret_cast<const uint64_t *>(CurCFIRecord + 4) + 12;
-    else
-      Size += 4;
-    uint32_t Offset = *reinterpret_cast<const uint32_t *>(OffsetField);
-
-    LLVM_DEBUG({
-      dbgs() << "Registering eh-frame section:\n";
-      dbgs() << "Processing " << (Offset ? "FDE" : "CIE") << " @"
-             << (void *)CurCFIRecord << ": [";
-      for (unsigned I = 0; I < Size; ++I)
-        dbgs() << format(" 0x%02" PRIx8, *(CurCFIRecord + I));
-      dbgs() << " ]\n";
-    });
-
-    if (Offset != 0)
-      if (auto Err = HandleFDE(CurCFIRecord))
-        return Err;
-
-    CurCFIRecord += Size;
-
-    Size = *reinterpret_cast<const uint32_t *>(CurCFIRecord);
-  }
-
-  return Error::success();
-}
-
-#endif // __APPLE__
-
-Error registerEHFrameSection(const void *EHFrameSectionAddr,
-                             size_t EHFrameSectionSize) {
-#ifdef __APPLE__
-  // On Darwin __register_frame has to be called for each FDE entry.
-  return walkAppleEHFrameSection(static_cast<const char *>(EHFrameSectionAddr),
-                                 EHFrameSectionSize,
-                                 registerFrameWrapper);
-#else
-  // On Linux __register_frame takes a single argument:
-  // a pointer to the start of the .eh_frame section.
-
-  // How can it find the end? Because crtendS.o is linked
-  // in and it has an .eh_frame section with four zero chars.
-  return registerFrameWrapper(EHFrameSectionAddr);
-#endif
-}
-
-Error deregisterEHFrameSection(const void *EHFrameSectionAddr,
-                               size_t EHFrameSectionSize) {
-#ifdef __APPLE__
-  return walkAppleEHFrameSection(static_cast<const char *>(EHFrameSectionAddr),
-                                 EHFrameSectionSize,
-                                 deregisterFrameWrapper);
-#else
-  return deregisterFrameWrapper(EHFrameSectionAddr);
-#endif
-}
-
 EHFrameRegistrar::~EHFrameRegistrar() {}
 
 Error InProcessEHFrameRegistrar::registerEHFrames(
     JITTargetAddress EHFrameSectionAddr, size_t EHFrameSectionSize) {
-  return registerEHFrameSection(
+  return orc::registerEHFrameSection(
       jitTargetAddressToPointer<void *>(EHFrameSectionAddr),
       EHFrameSectionSize);
 }
 
 Error InProcessEHFrameRegistrar::deregisterEHFrames(
     JITTargetAddress EHFrameSectionAddr, size_t EHFrameSectionSize) {
-  return deregisterEHFrameSection(
+  return orc::deregisterEHFrameSection(
       jitTargetAddressToPointer<void *>(EHFrameSectionAddr),
       EHFrameSectionSize);
 }
 
 LinkGraphPassFunction
 createEHFrameRecorderPass(const Triple &TT,
                           StoreFrameRangeFunction StoreRangeAddress) {
   const char *EHFrameSectionName = nullptr;

llvm/lib/ExecutionEngine/JITLink/LLVMBuild.txt

 ;   http://llvm.org/docs/LLVMBuild.html
 ;
 ;===------------------------------------------------------------------------===;
 
 [component_0]
 type = Library
 name = JITLink
 parent = ExecutionEngine
-required_libraries = BinaryFormat Object Support
+required_libraries = BinaryFormat Object OrcTargetProcess Support

llvm/lib/ExecutionEngine/LLVMBuild.txt

 ; For more information on the LLVMBuild system, please see:
 ;
 ;   http://llvm.org/docs/LLVMBuild.html
 ;
 ;===------------------------------------------------------------------------===;
 
 [common]
 subdirectories = Interpreter MCJIT JITLink RuntimeDyld IntelJITEvents
-                 OProfileJIT Orc OrcError PerfJITEvents
+                 OProfileJIT Orc PerfJITEvents
 
 [component_0]
 type = Library
 name = ExecutionEngine
 parent = Libraries
 required_libraries = Core MC Object RuntimeDyld Support Target

llvm/lib/ExecutionEngine/Orc/CMakeLists.txt

add_llvm_component_library(LLVMOrcJIT
   OrcABISupport.cpp
   OrcV2CBindings.cpp
   RTDyldObjectLinkingLayer.cpp
   Speculation.cpp
   SpeculateAnalyses.cpp
   TargetProcessControl.cpp
   ThreadSafeModule.cpp
   TPCDynamicLibrarySearchGenerator.cpp
+  TPCEHFrameRegistrar.cpp
   TPCIndirectionUtils.cpp
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/ExecutionEngine/Orc
 
   DEPENDS
   intrinsics_gen
   )
 
+add_subdirectory(Shared)
+add_subdirectory(TargetProcess)
+
 target_link_libraries(LLVMOrcJIT
   PRIVATE
   LLVMAnalysis
   LLVMBitReader
   LLVMBitWriter
   LLVMPasses
   )

llvm/lib/ExecutionEngine/Orc/ExecutionUtils.cpp

 #include "llvm/Object/MachOUniversal.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Target/TargetMachine.h"
 
 namespace llvm {
 namespace orc {
 
-int runAsMain(int (*Main)(int, char *[]), ArrayRef<std::string> Args,
-              Optional<StringRef> ProgramName) {
-  std::vector<std::unique_ptr<char[]>> ArgVStorage;
-  std::vector<char *> ArgV;
-
-  ArgVStorage.reserve(Args.size() + (ProgramName ? 1 : 0));
-  ArgV.reserve(Args.size() + 1 + (ProgramName ? 1 : 0));
-
-  if (ProgramName) {
-    ArgVStorage.push_back(std::make_unique<char[]>(ProgramName->size() + 1));
-    llvm::copy(*ProgramName, &ArgVStorage.back()[0]);
-    ArgVStorage.back()[ProgramName->size()] = '\0';
-    ArgV.push_back(ArgVStorage.back().get());
-  }
-
-  for (auto &Arg : Args) {
-    ArgVStorage.push_back(std::make_unique<char[]>(Arg.size() + 1));
-    llvm::copy(Arg, &ArgVStorage.back()[0]);
-    ArgVStorage.back()[Arg.size()] = '\0';
-    ArgV.push_back(ArgVStorage.back().get());
-  }
-  ArgV.push_back(nullptr);
-
-  return Main(Args.size() + !!ProgramName, ArgV.data());
-}
-
 CtorDtorIterator::CtorDtorIterator(const GlobalVariable *GV, bool End)
   : InitList(
       GV ? dyn_cast_or_null<ConstantArray>(GV->getInitializer()) : nullptr),
     I((InitList && End) ? InitList->getNumOperands() : 0) {
 }
 
 bool CtorDtorIterator::operator==(const CtorDtorIterator &Other) const {
   assert(InitList == Other.InitList && "Incomparable iterators.");

llvm/lib/ExecutionEngine/Orc/LLVMBuild.txt

 ;===- ./lib/ExecutionEngine/Orc/LLVMBuild.txt ----------------*- Conf -*--===;
 ;
 ; Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 ; See https://llvm.org/LICENSE.txt for license information.
 ; SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 ;
 ;===------------------------------------------------------------------------===;
 ;
 ; This is an LLVMBuild description file for the components in this subdirectory.
 ;
 ; For more information on the LLVMBuild system, please see:
 ;
 ;   http://llvm.org/docs/LLVMBuild.html
 ;
 ;===------------------------------------------------------------------------===;
 
+[common]
+subdirectories = Shared TargetProcess
+
 [component_0]
 type = Library
 name = OrcJIT
 parent = ExecutionEngine
-required_libraries = Core ExecutionEngine JITLink Object OrcError MC Passes
+required_libraries = Core ExecutionEngine JITLink Object OrcShared MC Passes
                      RuntimeDyld Support Target TransformUtils

llvm/lib/ExecutionEngine/Orc/Shared/CMakeLists.txt

-add_llvm_component_library(LLVMOrcError
+add_llvm_component_library(LLVMOrcShared
   OrcError.cpp
   RPCError.cpp
+  TargetProcessControlTypes.cpp
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/ExecutionEngine/Orc
   )

llvm/lib/ExecutionEngine/Orc/Shared/LLVMBuild.txt

-;===- ./lib/ExecutionEngine/OrcError/LLVMBuild.txt -------------*- Conf -*--===;
+;===- ./lib/ExecutionEngine/Orc/Shared/LLVMBuild.txt ------------*- Conf -*--===;
 ;
 ; Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 ; See https://llvm.org/LICENSE.txt for license information.
 ; SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 ;
 ;===------------------------------------------------------------------------===;
 ;
 ; This is an LLVMBuild description file for the components in this subdirectory.
 ;
 ; For more information on the LLVMBuild system, please see:
 ;
 ;   http://llvm.org/docs/LLVMBuild.html
 ;
 ;===------------------------------------------------------------------------===;
 
 [component_0]
 type = Library
-name = OrcError
-parent = ExecutionEngine
+name = OrcShared
+parent = OrcJIT
 required_libraries = Support

llvm/lib/ExecutionEngine/Orc/Shared/LLVMBuild.txt.rej

+***************
+*** 1,4 ****
+- ;===- ./lib/ExecutionEngine/OrcError/LLVMBuild.txt -------------*- Conf -*--===;
+  ;
+  ; Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+  ; See https://llvm.org/LICENSE.txt for license information.
+--- 1,4 ----
++ ;===- ./tools/llvm-jitlink/llvm-jitlink-executor/LLVMBuild.txt -*- Conf -*--===;
+  ;
+  ; Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+  ; See https://llvm.org/LICENSE.txt for license information.
+***************
+*** 15,21 ****
+  ;===------------------------------------------------------------------------===;
+  
+  [component_0]
+- type = Library
+- name = OrcError
+- parent = ExecutionEngine
+- required_libraries = Support
+--- 15,20 ----
+  ;===------------------------------------------------------------------------===;
+  
+  [component_0]
++ type = Tool
++ name = llvm-jitlink-executor
++ parent = llvm-jitlink

llvm/lib/ExecutionEngine/Orc/Shared/OrcError.cpp

std::string message(int condition) const override {
     case OrcErrorCode::UnexpectedSymbolDefinitions:
       return "UnexpectedSymbolDefinitions";
     }
     llvm_unreachable("Unhandled error code");
   }
 };
 
 static ManagedStatic<OrcErrorCategory> OrcErrCat;
-}
+} // namespace
 
 namespace llvm {
 namespace orc {
 
 char DuplicateDefinition::ID = 0;
 char JITSymbolNotFound::ID = 0;
 
 std::error_code orcError(OrcErrorCode ErrCode) {
   typedef std::underlying_type<OrcErrorCode>::type UT;
   return std::error_code(static_cast<UT>(ErrCode), *OrcErrCat);
 }
 
-
 DuplicateDefinition::DuplicateDefinition(std::string SymbolName)
     : SymbolName(std::move(SymbolName)) {}
 
 std::error_code DuplicateDefinition::convertToErrorCode() const {
   return orcError(OrcErrorCode::DuplicateDefinition);
 }
 
 void DuplicateDefinition::log(raw_ostream &OS) const {
   OS << "Duplicate definition of symbol '" << SymbolName << "'";
 }
 
 const std::string &DuplicateDefinition::getSymbolName() const {
   return SymbolName;
 }
 
 JITSymbolNotFound::JITSymbolNotFound(std::string SymbolName)
     : SymbolName(std::move(SymbolName)) {}
 
 std::error_code JITSymbolNotFound::convertToErrorCode() const {
   typedef std::underlying_type<OrcErrorCode>::type UT;
   return std::error_code(static_cast<UT>(OrcErrorCode::JITSymbolNotFound),
                          *OrcErrCat);
 }
 
 void JITSymbolNotFound::log(raw_ostream &OS) const {
   OS << "Could not find symbol '" << SymbolName << "'";
 }
 
 const std::string &JITSymbolNotFound::getSymbolName() const {
   return SymbolName;
 }
 
-}
-}
+} // namespace orc
+} // namespace llvm

llvm/lib/ExecutionEngine/Orc/Shared/RPCError.cpp

 //===--------------- RPCError.cpp - RPCERror implementation ---------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 // RPC Error type implmentations.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ExecutionEngine/Orc/RPC/RPCUtils.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/raw_ostream.h"
 
-#include <system_error>
 #include <string>
+#include <system_error>
 
 char llvm::orc::rpc::RPCFatalError::ID = 0;
 char llvm::orc::rpc::ConnectionClosed::ID = 0;
 char llvm::orc::rpc::ResponseAbandoned::ID = 0;
 char llvm::orc::rpc::CouldNotNegotiate::ID = 0;
 
 namespace llvm {
 namespace orc {

 std::error_code CouldNotNegotiate::convertToErrorCode() const {
   return orcError(OrcErrorCode::RPCCouldNotNegotiateFunction);
 }
 
 void CouldNotNegotiate::log(raw_ostream &OS) const {
   OS << "Could not negotiate RPC function " << Signature;
 }
 
-
 } // end namespace rpc
 } // end namespace orc
 } // end namespace llvm

llvm/lib/ExecutionEngine/Orc/Shared/TargetProcessControlTypes.cpp

+//===---------- TargetProcessControlTypes.cpp - Shared TPC types ----------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// TargetProcessControl types.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ExecutionEngine/Orc/Shared/TargetProcessControlTypes.h"
+
+namespace llvm {
+namespace orc {
+namespace tpctypes {
+
+WrapperFunctionResult WrapperFunctionResult::from(StringRef S) {
+  CWrapperFunctionResult R = {0, {.ValuePtr = nullptr}, nullptr};
+  R.Size = S.size();
+  if (R.Size > sizeof(uint64_t)) {
+    R.Data.ValuePtr = new uint8_t[R.Size];
+    memcpy(R.Data.ValuePtr, S.data(), R.Size);
+    R.Destroy = destroyWithDeleteArray;
+  } else
+    memcpy(R.Data.Value, S.data(), R.Size);
+  return R;
+}
+
+void WrapperFunctionResult::destroyWithFree(CWrapperFunctionResultData Data,
+                                            uint64_t Size) {
+  free(Data.ValuePtr);
+}
+
+void WrapperFunctionResult::destroyWithDeleteArray(
+    CWrapperFunctionResultData Data, uint64_t Size) {
+  delete[] Data.ValuePtr;
+}
+
+} // end namespace tpctypes
+} // end namespace orc
+} // end namespace llvm

llvm/lib/ExecutionEngine/Orc/TPCDynamicLibrarySearchGenerator.cpp

for (auto &KV : Symbols) {
     // Skip symbols that don't match the filter.
     if (Allow && !Allow(KV.first))
       continue;
     LookupSymbols.add(KV.first, SymbolLookupFlags::WeaklyReferencedSymbol);
   }
 
   SymbolMap NewSymbols;
 
-  TargetProcessControl::LookupRequestElement Request(H, LookupSymbols);
+  tpctypes::LookupRequest Request(H, LookupSymbols);
   auto Result = TPC.lookupSymbols(Request);
   if (!Result)
     return Result.takeError();
 
   assert(Result->size() == 1 && "Results for more than one library returned");
   assert(Result->front().size() == LookupSymbols.size() &&
          "Result has incorrect number of elements");
 

llvm/lib/ExecutionEngine/Orc/TPCEHFrameRegistrar.cpp

+//===------ TPCEHFrameRegistrar.cpp - TPC-based eh-frame registration -----===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ExecutionEngine/Orc/TPCEHFrameRegistrar.h"
+#include "llvm/Support/BinaryStreamWriter.h"
+
+namespace llvm {
+namespace orc {
+
+Expected<std::unique_ptr<TPCEHFrameRegistrar>>
+TPCEHFrameRegistrar::Create(TargetProcessControl &TPC) {
+  // FIXME: Proper mangling here -- we really need to decouple linker mangling
+  // from DataLayout.
+
+  // Find the addresses of the registration/deregistration functions in the
+  // target process.
+  auto ProcessHandle = TPC.loadDylib(nullptr);
+  if (!ProcessHandle)
+    return ProcessHandle.takeError();
+
+  std::string RegisterWrapperName, DeregisterWrapperName;
+  if (TPC.getTargetTriple().isOSBinFormatMachO()) {
+    RegisterWrapperName += '_';
+    DeregisterWrapperName += '_';
+  }
+  RegisterWrapperName += "llvm_orc_registerEHFrameSectionWrapper";
+  DeregisterWrapperName += "llvm_orc_deregisterEHFrameSectionWrapper";
+
+  SymbolLookupSet RegistrationSymbols;
+  RegistrationSymbols.add(TPC.intern(RegisterWrapperName));
+  RegistrationSymbols.add(TPC.intern(DeregisterWrapperName));
+
+  auto Result = TPC.lookupSymbols({{*ProcessHandle, RegistrationSymbols}});
+  if (!Result)
+    return Result.takeError();
+
+  assert(Result->size() == 1 && "Unexpected number of dylibs in result");
+  assert((*Result)[0].size() == 2 &&
+         "Unexpected number of addresses in result");
+
+  auto RegisterEHFrameWrapperFnAddr = (*Result)[0][0];
+  auto DeregisterEHFrameWrapperFnAddr = (*Result)[0][1];
+
+  return std::make_unique<TPCEHFrameRegistrar>(
+      TPC, RegisterEHFrameWrapperFnAddr, DeregisterEHFrameWrapperFnAddr);
+}
+
+Error TPCEHFrameRegistrar::registerEHFrames(JITTargetAddress EHFrameSectionAddr,
+                                            size_t EHFrameSectionSize) {
+  constexpr size_t ArgBufferSize = sizeof(uint64_t) + sizeof(uint64_t);
+  uint8_t ArgBuffer[ArgBufferSize];
+  BinaryStreamWriter ArgWriter(
+      MutableArrayRef<uint8_t>(ArgBuffer, ArgBufferSize),
+      support::endianness::big);
+  cantFail(ArgWriter.writeInteger(static_cast<uint64_t>(EHFrameSectionAddr)));
+  cantFail(ArgWriter.writeInteger(static_cast<uint64_t>(EHFrameSectionSize)));
+
+  return TPC.runWrapper(RegisterEHFrameWrapperFnAddr, ArgBuffer).takeError();
+}
+
+Error TPCEHFrameRegistrar::deregisterEHFrames(
+    JITTargetAddress EHFrameSectionAddr, size_t EHFrameSectionSize) {
+  constexpr size_t ArgBufferSize = sizeof(uint64_t) + sizeof(uint64_t);
+  uint8_t ArgBuffer[ArgBufferSize];
+  BinaryStreamWriter ArgWriter(
+      MutableArrayRef<uint8_t>(ArgBuffer, ArgBufferSize),
+      support::endianness::big);
+  cantFail(ArgWriter.writeInteger(static_cast<uint64_t>(EHFrameSectionAddr)));
+  cantFail(ArgWriter.writeInteger(static_cast<uint64_t>(EHFrameSectionSize)));
+
+  return TPC.runWrapper(DeregisterEHFrameWrapperFnAddr, ArgBuffer).takeError();
+}
+
+} // end namespace orc
+} // end namespace llvm

llvm/lib/ExecutionEngine/Orc/TPCIndirectionUtils.cpp

for (auto &SI : StubInits) {
       StubInfos[SI.first()] = std::make_pair(A, SI.second.second);
     }
   }
 
   auto &MemAccess = TPCIU.getTargetProcessControl().getMemoryAccess();
   switch (TPCIU.getABISupport().getPointerSize()) {
   case 4: {
     unsigned ASIdx = 0;
-    std::vector<TargetProcessControl::MemoryAccess::UInt32Write> PtrUpdates;
+    std::vector<tpctypes::UInt32Write> PtrUpdates;
     for (auto &SI : StubInits)
       PtrUpdates.push_back({(*AvailableStubInfos)[ASIdx++].PointerAddress,
                             static_cast<uint32_t>(SI.second.first)});
     return MemAccess.writeUInt32s(PtrUpdates);
   }
   case 8: {
     unsigned ASIdx = 0;
-    std::vector<TargetProcessControl::MemoryAccess::UInt64Write> PtrUpdates;
+    std::vector<tpctypes::UInt64Write> PtrUpdates;
     for (auto &SI : StubInits)
       PtrUpdates.push_back({(*AvailableStubInfos)[ASIdx++].PointerAddress,
                             static_cast<uint64_t>(SI.second.first)});
     return MemAccess.writeUInt64s(PtrUpdates);
   }
   default:
     return make_error<StringError>("Unsupported pointer size",
                                    inconvertibleErrorCode());
if (I == StubInfos.end())
       return make_error<StringError>("Unknown stub name",
                                      inconvertibleErrorCode());
     PtrAddr = I->second.first.PointerAddress;
   }
 
   auto &MemAccess = TPCIU.getTargetProcessControl().getMemoryAccess();
   switch (TPCIU.getABISupport().getPointerSize()) {
   case 4: {
-    TargetProcessControl::MemoryAccess::UInt32Write PUpdate(PtrAddr, NewAddr);
+    tpctypes::UInt32Write PUpdate(PtrAddr, NewAddr);
     return MemAccess.writeUInt32s(PUpdate);
   }
   case 8: {
-    TargetProcessControl::MemoryAccess::UInt64Write PUpdate(PtrAddr, NewAddr);
+    tpctypes::UInt64Write PUpdate(PtrAddr, NewAddr);
     return MemAccess.writeUInt64s(PUpdate);
   }
   default:
     return make_error<StringError>("Unsupported pointer size",
                                    inconvertibleErrorCode());
   }
 }
 

llvm/lib/ExecutionEngine/Orc/TargetProcess/CMakeLists.txt

+add_llvm_component_library(LLVMOrcTargetProcess
+  RegisterEHFrames.cpp
+  TargetExecutionUtils.cpp
+  ADDITIONAL_HEADER_DIRS
+  ${LLVM_MAIN_INCLUDE_DIR}/llvm/ExecutionEngine/Orc
+  )

llvm/lib/ExecutionEngine/Orc/TargetProcess/LLVMBuild.txt

-;===- ./lib/ExecutionEngine/OrcError/LLVMBuild.txt -------------*- Conf -*--===;
+;===- ./lib/ExecutionEngine/OrcTargetProcess/LLVMBuild.txt -----*- Conf -*--===;
 ;
 ; Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 ; See https://llvm.org/LICENSE.txt for license information.
 ; SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 ;
 ;===------------------------------------------------------------------------===;
 ;
 ; This is an LLVMBuild description file for the components in this subdirectory.
 ;
 ; For more information on the LLVMBuild system, please see:
 ;
 ;   http://llvm.org/docs/LLVMBuild.html
 ;
 ;===------------------------------------------------------------------------===;
 
 [component_0]
 type = Library
-name = OrcError
-parent = ExecutionEngine
-required_libraries = Support
+name = OrcTargetProcess
+parent = OrcJIT
+required_libraries = OrcShared Support

llvm/lib/ExecutionEngine/Orc/TargetProcess/RegisterEHFrames.cpp

+//===--------- RegisterEHFrames.cpp - Register EH frame sections ----------===//
+//
+//                     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/TargetProcess/RegisterEHFrames.h"
+
+#include "llvm/ExecutionEngine/JITSymbol.h"
+#include "llvm/Support/BinaryStreamReader.h"
+#include "llvm/Support/Compiler.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/DynamicLibrary.h"
+#include "llvm/Support/raw_ostream.h"
+
+#include "llvm/Support/FormatVariadic.h"
+
+#define DEBUG_TYPE "orc"
+
+using namespace llvm;
+using namespace llvm::orc;
+using namespace llvm::orc::tpctypes;
+
+namespace llvm {
+namespace orc {
+
+#if defined(HAVE_REGISTER_FRAME) && defined(HAVE_DEREGISTER_FRAME) &&          \
+    !defined(__SEH__) && !defined(__USING_SJLJ_EXCEPTIONS__)
+
+extern "C" void __register_frame(const void *);
+extern "C" void __deregister_frame(const void *);
+
+Error registerFrameWrapper(const void *P) {
+  __register_frame(P);
+  return Error::success();
+}
+
+Error deregisterFrameWrapper(const void *P) {
+  __deregister_frame(P);
+  return Error::success();
+}
+
+#else
+
+// The building compiler does not have __(de)register_frame but
+// it may be found at runtime in a dynamically-loaded library.
+// For example, this happens when building LLVM with Visual C++
+// but using the MingW runtime.
+static Error registerFrameWrapper(const void *P) {
+  static void((*RegisterFrame)(const void *)) = 0;
+
+  if (!RegisterFrame)
+    *(void **)&RegisterFrame =
+        llvm::sys::DynamicLibrary::SearchForAddressOfSymbol("__register_frame");
+
+  if (RegisterFrame) {
+    RegisterFrame(P);
+    return Error::success();
+  }
+
+  return make_error<StringError>("could not register eh-frame: "
+                                 "__register_frame function not found",
+                                 inconvertibleErrorCode());
+}
+
+static Error deregisterFrameWrapper(const void *P) {
+  static void((*DeregisterFrame)(const void *)) = 0;
+
+  if (!DeregisterFrame)
+    *(void **)&DeregisterFrame =
+        llvm::sys::DynamicLibrary::SearchForAddressOfSymbol(
+            "__deregister_frame");
+
+  if (DeregisterFrame) {
+    DeregisterFrame(P);
+    return Error::success();
+  }
+
+  return make_error<StringError>("could not deregister eh-frame: "
+                                 "__deregister_frame function not found",
+                                 inconvertibleErrorCode());
+}
+#endif
+
+#ifdef __APPLE__
+
+template <typename HandleFDEFn>
+Error walkAppleEHFrameSection(const char *const SectionStart,
+                              size_t SectionSize, HandleFDEFn HandleFDE) {
+  const char *CurCFIRecord = SectionStart;
+  const char *End = SectionStart + SectionSize;
+  uint64_t Size = *reinterpret_cast<const uint32_t *>(CurCFIRecord);
+
+  while (CurCFIRecord != End && Size != 0) {
+    const char *OffsetField = CurCFIRecord + (Size == 0xffffffff ? 12 : 4);
+    if (Size == 0xffffffff)
+      Size = *reinterpret_cast<const uint64_t *>(CurCFIRecord + 4) + 12;
+    else
+      Size += 4;
+    uint32_t Offset = *reinterpret_cast<const uint32_t *>(OffsetField);
+
+    LLVM_DEBUG({
+      dbgs() << "Registering eh-frame section:\n";
+      dbgs() << "Processing " << (Offset ? "FDE" : "CIE") << " @"
+             << (void *)CurCFIRecord << ": [";
+      for (unsigned I = 0; I < Size; ++I)
+        dbgs() << format(" 0x%02" PRIx8, *(CurCFIRecord + I));
+      dbgs() << " ]\n";
+    });
+
+    if (Offset != 0)
+      if (auto Err = HandleFDE(CurCFIRecord))
+        return Err;
+
+    CurCFIRecord += Size;
+
+    Size = *reinterpret_cast<const uint32_t *>(CurCFIRecord);
+  }
+
+  return Error::success();
+}
+
+#endif // __APPLE__
+
+Error registerEHFrameSection(const void *EHFrameSectionAddr,
+                             size_t EHFrameSectionSize) {
+#ifdef __APPLE__
+  // On Darwin __register_frame has to be called for each FDE entry.
+  return walkAppleEHFrameSection(static_cast<const char *>(EHFrameSectionAddr),
+                                 EHFrameSectionSize, registerFrameWrapper);
+#else
+  // On Linux __register_frame takes a single argument:
+  // a pointer to the start of the .eh_frame section.
+
+  // How can it find the end? Because crtendS.o is linked
+  // in and it has an .eh_frame section with four zero chars.
+  return registerFrameWrapper(EHFrameSectionAddr);
+#endif
+}
+
+Error deregisterEHFrameSection(const void *EHFrameSectionAddr,
+                               size_t EHFrameSectionSize) {
+#ifdef __APPLE__
+  return walkAppleEHFrameSection(static_cast<const char *>(EHFrameSectionAddr),
+                                 EHFrameSectionSize, deregisterFrameWrapper);
+#else
+  return deregisterFrameWrapper(EHFrameSectionAddr);
+#endif
+}
+
+} // end namespace orc
+} // end namespace llvm
+
+extern "C" CWrapperFunctionResult
+llvm_orc_registerEHFrameSectionWrapper(uint8_t *Data, uint64_t Size) {
+  if (Size != sizeof(uint64_t) + sizeof(uint64_t))
+    return WrapperFunctionResult::from(
+               "Invalid arguments to llvm_orc_registerEHFrameSectionWrapper")
+        .release();
+
+  uint64_t EHFrameSectionAddr;
+  uint64_t EHFrameSectionSize;
+
+  {
+    BinaryStreamReader ArgReader(ArrayRef<uint8_t>(Data, Size),
+                                 support::endianness::big);
+    cantFail(ArgReader.readInteger(EHFrameSectionAddr));
+    cantFail(ArgReader.readInteger(EHFrameSectionSize));
+  }
+
+  if (auto Err = registerEHFrameSection(
+          jitTargetAddressToPointer<void *>(EHFrameSectionAddr),
+          EHFrameSectionSize)) {
+    auto ErrMsg = toString(std::move(Err));
+    return WrapperFunctionResult::from(ErrMsg).release();
+  }
+  return WrapperFunctionResult().release();
+}
+
+extern "C" CWrapperFunctionResult
+llvm_orc_deregisterEHFrameSectionWrapper(uint8_t *Data, uint64_t Size) {
+  if (Size != sizeof(uint64_t) + sizeof(uint64_t))
+    return WrapperFunctionResult::from(
+               "Invalid arguments to llvm_orc_registerEHFrameSectionWrapper")
+        .release();
+
+  uint64_t EHFrameSectionAddr;
+  uint64_t EHFrameSectionSize;
+
+  {
+    BinaryStreamReader ArgReader(ArrayRef<uint8_t>(Data, Size),
+                                 support::endianness::big);
+    cantFail(ArgReader.readInteger(EHFrameSectionAddr));
+    cantFail(ArgReader.readInteger(EHFrameSectionSize));
+  }
+
+  if (auto Err = deregisterEHFrameSection(
+          jitTargetAddressToPointer<void *>(EHFrameSectionAddr),
+          EHFrameSectionSize)) {
+    auto ErrMsg = toString(std::move(Err));
+    return WrapperFunctionResult::from(ErrMsg).release();
+  }
+  return WrapperFunctionResult().release();
+}

llvm/lib/ExecutionEngine/Orc/TargetProcess/TargetExecutionUtils.cpp

+//===--- TargetExecutionUtils.cpp - Execution utils for target processes --===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ExecutionEngine/Orc/TargetProcess/TargetExecutionUtils.h"
+
+#include <vector>
+
+namespace llvm {
+namespace orc {
+
+int runAsMain(int (*Main)(int, char *[]), ArrayRef<std::string> Args,
+              Optional<StringRef> ProgramName) {
+  std::vector<std::unique_ptr<char[]>> ArgVStorage;
+  std::vector<char *> ArgV;
+
+  ArgVStorage.reserve(Args.size() + (ProgramName ? 1 : 0));
+  ArgV.reserve(Args.size() + 1 + (ProgramName ? 1 : 0));
+
+  if (ProgramName) {
+    ArgVStorage.push_back(std::make_unique<char[]>(ProgramName->size() + 1));
+    llvm::copy(*ProgramName, &ArgVStorage.back()[0]);
+    ArgVStorage.back()[ProgramName->size()] = '\0';
+    ArgV.push_back(ArgVStorage.back().get());
+  }
+
+  for (const auto &Arg : Args) {
+    ArgVStorage.push_back(std::make_unique<char[]>(Arg.size() + 1));
+    llvm::copy(Arg, &ArgVStorage.back()[0]);
+    ArgVStorage.back()[Arg.size()] = '\0';
+    ArgV.push_back(ArgVStorage.back().get());
+  }
+  ArgV.push_back(nullptr);
+
+  return Main(Args.size() + !!ProgramName, ArgV.data());
+}
+
+} // End namespace orc.
+} // End namespace llvm.

llvm/lib/ExecutionEngine/Orc/TargetProcessControl.cpp

 //===------ TargetProcessControl.cpp -- Target process control APIs -------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/ExecutionEngine/Orc/TargetProcessControl.h"
 
 #include "llvm/ExecutionEngine/Orc/Core.h"
+#include "llvm/ExecutionEngine/Orc/TargetProcess/TargetExecutionUtils.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/Process.h"
 
 #include <mutex>
 
 namespace llvm {
 namespace orc {
 
 TargetProcessControl::MemoryAccess::~MemoryAccess() {}
 
 TargetProcessControl::~TargetProcessControl() {}
 
 SelfTargetProcessControl::SelfTargetProcessControl(
-    Triple TT, unsigned PageSize,
-    std::unique_ptr<jitlink::JITLinkMemoryManager> MemMgr) {
+    std::shared_ptr<SymbolStringPool> SSP, Triple TargetTriple,
+    unsigned PageSize, std::unique_ptr<jitlink::JITLinkMemoryManager> MemMgr)
+    : TargetProcessControl(std::move(SSP)) {
 
   OwnedMemMgr = std::move(MemMgr);
   if (!OwnedMemMgr)
     OwnedMemMgr = std::make_unique<jitlink::InProcessMemoryManager>();
 
-  this->TT = std::move(TT);
+  this->TargetTriple = std::move(TargetTriple);
   this->PageSize = PageSize;
   this->MemMgr = OwnedMemMgr.get();
   this->MemAccess = this;
-  if (this->TT.isOSBinFormatMachO())
+  if (this->TargetTriple.isOSBinFormatMachO())
     GlobalManglingPrefix = '_';
 }
 
 Expected<std::unique_ptr<SelfTargetProcessControl>>
 SelfTargetProcessControl::Create(
+    std::shared_ptr<SymbolStringPool> SSP,
     std::unique_ptr<jitlink::JITLinkMemoryManager> MemMgr) {
   auto PageSize = sys::Process::getPageSize();
   if (!PageSize)
     return PageSize.takeError();
 
   Triple TT(sys::getProcessTriple());
 
-  return std::make_unique<SelfTargetProcessControl>(std::move(TT), *PageSize,
-                                                    std::move(MemMgr));
+  return std::make_unique<SelfTargetProcessControl>(
+      std::move(SSP), std::move(TT), *PageSize, std::move(MemMgr));
 }
 
-Expected<TargetProcessControl::DylibHandle>
+Expected<tpctypes::DylibHandle>
 SelfTargetProcessControl::loadDylib(const char *DylibPath) {
   std::string ErrMsg;
   auto Dylib = std::make_unique<sys::DynamicLibrary>(
       sys::DynamicLibrary::getPermanentLibrary(DylibPath, &ErrMsg));
   if (!Dylib->isValid())
     return make_error<StringError>(std::move(ErrMsg), inconvertibleErrorCode());
   DynamicLibraries.push_back(std::move(Dylib));
   return pointerToJITTargetAddress(DynamicLibraries.back().get());
 }
 
-Expected<TargetProcessControl::LookupResult>
-SelfTargetProcessControl::lookupSymbols(LookupRequest Request) {
-  LookupResult R;
+Expected<std::vector<tpctypes::LookupResult>>
+SelfTargetProcessControl::lookupSymbols(
+    ArrayRef<tpctypes::LookupRequest> Request) {
+  std::vector<tpctypes::LookupResult> R;
 
   for (auto &Elem : Request) {
     auto *Dylib = jitTargetAddressToPointer<sys::DynamicLibrary *>(Elem.Handle);
     assert(llvm::find_if(DynamicLibraries,
                          [=](const std::unique_ptr<sys::DynamicLibrary> &DL) {
                            return DL.get() == Dylib;
                          }) != DynamicLibraries.end() &&
            "Invalid handle");
for (auto &KV : Elem.Symbols) {
       }
       R.back().push_back(pointerToJITTargetAddress(Addr));
     }
   }
 
   return R;
 }
 
-void SelfTargetProcessControl::writeUInt8s(ArrayRef<UInt8Write> Ws,
+Expected<int32_t>
+SelfTargetProcessControl::runAsMain(JITTargetAddress MainFnAddr,
+                                    ArrayRef<std::string> Args) {
+  using MainTy = int (*)(int, char *[]);
+  return orc::runAsMain(jitTargetAddressToFunction<MainTy>(MainFnAddr), Args);
+}
+
+Expected<tpctypes::WrapperFunctionResult>
+SelfTargetProcessControl::runWrapper(JITTargetAddress WrapperFnAddr,
+                                     ArrayRef<uint8_t> ArgBuffer) {
+  using WrapperFnTy =
+      tpctypes::CWrapperFunctionResult (*)(const uint8_t *Data, uint64_t Size);
+  auto *WrapperFn = jitTargetAddressToFunction<WrapperFnTy>(WrapperFnAddr);
+  return WrapperFn(ArgBuffer.data(), ArgBuffer.size());
+};
+
+Error SelfTargetProcessControl::disconnect() { return Error::success(); }
+
+void SelfTargetProcessControl::writeUInt8s(ArrayRef<tpctypes::UInt8Write> Ws,
                                            WriteResultFn OnWriteComplete) {
   for (auto &W : Ws)
     *jitTargetAddressToPointer<uint8_t *>(W.Address) = W.Value;
   OnWriteComplete(Error::success());
 }
 
-void SelfTargetProcessControl::writeUInt16s(ArrayRef<UInt16Write> Ws,
+void SelfTargetProcessControl::writeUInt16s(ArrayRef<tpctypes::UInt16Write> Ws,
                                             WriteResultFn OnWriteComplete) {
   for (auto &W : Ws)
     *jitTargetAddressToPointer<uint16_t *>(W.Address) = W.Value;
   OnWriteComplete(Error::success());
 }
 
-void SelfTargetProcessControl::writeUInt32s(ArrayRef<UInt32Write> Ws,
+void SelfTargetProcessControl::writeUInt32s(ArrayRef<tpctypes::UInt32Write> Ws,
                                             WriteResultFn OnWriteComplete) {
   for (auto &W : Ws)
     *jitTargetAddressToPointer<uint32_t *>(W.Address) = W.Value;
   OnWriteComplete(Error::success());
 }
 
-void SelfTargetProcessControl::writeUInt64s(ArrayRef<UInt64Write> Ws,
+void SelfTargetProcessControl::writeUInt64s(ArrayRef<tpctypes::UInt64Write> Ws,
                                             WriteResultFn OnWriteComplete) {
   for (auto &W : Ws)
     *jitTargetAddressToPointer<uint64_t *>(W.Address) = W.Value;
   OnWriteComplete(Error::success());
 }
 
-void SelfTargetProcessControl::writeBuffers(ArrayRef<BufferWrite> Ws,
+void SelfTargetProcessControl::writeBuffers(ArrayRef<tpctypes::BufferWrite> Ws,
                                             WriteResultFn OnWriteComplete) {
   for (auto &W : Ws)
     memcpy(jitTargetAddressToPointer<char *>(W.Address), W.Buffer.data(),
            W.Buffer.size());
   OnWriteComplete(Error::success());
 }
 
 } // end namespace orc
 } // end namespace llvm

llvm/tools/lli/CMakeLists.txt

 if ( LLVM_INCLUDE_UTILS )
   add_subdirectory(ChildTarget)
 endif()
 
 set(LLVM_LINK_COMPONENTS
   CodeGen
   Core
   ExecutionEngine
   IRReader
   Interpreter
   MC
   MCJIT
   Object
-  OrcError
+  OrcShared
   OrcJIT
+  OrcTargetProcess
   Passes
   RuntimeDyld
   SelectionDAG
   Support
   Target
   TransformUtils
   native
   )

llvm/tools/lli/ChildTarget/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
-  OrcError
+  OrcShared
   OrcJIT
   RuntimeDyld
   Support
   )
 
 add_llvm_utility(lli-child-target
   ChildTarget.cpp
 
   DEPENDS
   intrinsics_gen
 )
 

llvm/tools/lli/LLVMBuild.txt

 parent = Tools
 required_libraries =
  AsmParser
  BitReader
  IRReader
  Instrumentation
  Interpreter
  MCJIT
+ OrcJIT
+ OrcShared
+ OrcTargetProcess
  Native
  NativeCodeGen
  SelectionDAG
  TransformUtils

llvm/tools/lli/lli.cpp

 #include "llvm/ExecutionEngine/ObjectCache.h"
 #include "llvm/ExecutionEngine/Orc/DebugUtils.h"
 #include "llvm/ExecutionEngine/Orc/ExecutionUtils.h"
 #include "llvm/ExecutionEngine/Orc/JITTargetMachineBuilder.h"
 #include "llvm/ExecutionEngine/Orc/LLJIT.h"
 #include "llvm/ExecutionEngine/Orc/MachOPlatform.h"
 #include "llvm/ExecutionEngine/Orc/OrcRemoteTargetClient.h"
 #include "llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h"
+#include "llvm/ExecutionEngine/Orc/TargetProcess/TargetExecutionUtils.h"
 #include "llvm/ExecutionEngine/SectionMemoryManager.h"
 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Type.h"
 #include "llvm/IR/Verifier.h"
 #include "llvm/IRReader/IRReader.h"
 #include "llvm/Object/Archive.h"

llvm/tools/llvm-jitlink/CMakeLists.txt

+if ( LLVM_INCLUDE_UTILS )
+  add_subdirectory(llvm-jitlink-executor)
+endif()
+
 set(LLVM_LINK_COMPONENTS
   AllTargetsDescs
   AllTargetsDisassemblers
   AllTargetsInfos
   BinaryFormat
   ExecutionEngine
   JITLink
   MC
   Object
   OrcJIT
+  OrcShared
+  OrcTargetProcess
   RuntimeDyld
   Support
   )
 
 add_llvm_tool(llvm-jitlink
   llvm-jitlink.cpp
   llvm-jitlink-elf.cpp
   llvm-jitlink-macho.cpp
   )
 
 export_executable_symbols(llvm-jitlink)

llvm/tools/llvm-jitlink/LLVMBuild.txt

 ;   http://llvm.org/docs/LLVMBuild.html
 ;
 ;===------------------------------------------------------------------------===;
 
 [component_0]
 type = Tool
 name = llvm-jitlink
 parent = Tools
-required_libraries = JITLink BinaryFormat MC Object RuntimeDyld Support
-                     all-targets
+required_libraries = JITLink BinaryFormat MC Object OrcJIT OrcTargetProcess
+                     Support all-targets

llvm/tools/llvm-jitlink/llvm-jitlink-executor/CMakeLists.txt

+set(LLVM_LINK_COMPONENTS
+  OrcShared
+  OrcTargetProcess
+  Support
+  )
+
+add_llvm_utility(llvm-jitlink-executor
+  llvm-jitlink-executor.cpp
+
+  DEPENDS
+  intrinsics_gen
+)
+
+export_executable_symbols(llvm-jitlink-executor)

llvm/tools/llvm-jitlink/llvm-jitlink-executor/LLVMBuild.txt

-;===- ./lib/ExecutionEngine/OrcError/LLVMBuild.txt -------------*- Conf -*--===;
+;===- ./tools/llvm-jitlink/llvm-jitlink-executor/LLVMBuild.txt -*- Conf -*--===;
 ;
 ; Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 ; See https://llvm.org/LICENSE.txt for license information.
 ; SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 ;
 ;===------------------------------------------------------------------------===;
 ;
 ; This is an LLVMBuild description file for the components in this subdirectory.
 ;
 ; For more information on the LLVMBuild system, please see:
 ;
 ;   http://llvm.org/docs/LLVMBuild.html
 ;
 ;===------------------------------------------------------------------------===;
 
 [component_0]
-type = Library
-name = OrcError
-parent = ExecutionEngine
-required_libraries = Support
+type = Tool
+name = llvm-jitlink-executor
+parent = llvm-jitlink
+required_libraries = OrcTargetProcess Support

llvm/tools/llvm-jitlink/llvm-jitlink-executor/llvm-jitlink-executor.cpp

+//===- llvm-jitlink-executor.cpp - Out-of-proc executor for llvm-jitlink -===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// Simple out-of-process executor for llvm-jitlink.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/ADT/StringRef.h"
+#include "llvm/ExecutionEngine/Orc/RPC/FDRawByteChannel.h"
+#include "llvm/ExecutionEngine/Orc/TargetProcess/OrcRPCTPCServer.h"
+#include "llvm/ExecutionEngine/Orc/TargetProcess/RegisterEHFrames.h"
+#include "llvm/Support/DynamicLibrary.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/raw_ostream.h"
+#include <sstream>
+
+#ifdef LLVM_ON_UNIX
+
+#include <netinet/in.h>
+#include <sys/socket.h>
+
+#endif
+
+using namespace llvm;
+using namespace llvm::orc;
+
+ExitOnError ExitOnErr;
+
+LLVM_ATTRIBUTE_USED void linkComponents() {
+  errs() << (void *)&llvm_orc_registerEHFrameSectionWrapper
+         << (void *)&llvm_orc_deregisterEHFrameSectionWrapper;
+}
+
+void printErrorAndExit(Twine ErrMsg) {
+  errs() << "error: " << ErrMsg.str() << "\n\n"
+         << "Usage:\n"
+         << "  llvm-jitlink-executor filedescs=<infd>,<outfd> [args...]\n"
+         << "  llvm-jitlink-executor listen=<host>:<port> [args...]\n";
+  exit(1);
+}
+
+int openListener(std::string Host, int Port) {
+#ifndef LLVM_ON_UNIX
+  // FIXME: Add TCP support for Windows.
+  printErrorAndExit("listen option not supported");
+#else
+  int SockFD = socket(PF_INET, SOCK_STREAM, 0);
+  struct sockaddr_in ServerAddr, ClientAddr;
+  socklen_t ClientAddrLen = sizeof(ClientAddr);
+  memset(&ServerAddr, 0, sizeof(ServerAddr));
+  ServerAddr.sin_family = PF_INET;
+  ServerAddr.sin_family = INADDR_ANY;
+  ServerAddr.sin_port = htons(Port);
+
+  {
+    // lose the "Address already in use" error message
+    int Yes = 1;
+    if (setsockopt(SockFD, SOL_SOCKET, SO_REUSEADDR, &Yes, sizeof(int)) == -1) {
+      errs() << "Error calling setsockopt.\n";
+      exit(1);
+    }
+  }
+
+  if (bind(SockFD, (struct sockaddr *)&ServerAddr, sizeof(ServerAddr)) < 0) {
+    errs() << "Error on binding.\n";
+    exit(1);
+  }
+
+  listen(SockFD, 1);
+  return accept(SockFD, (struct sockaddr *)&ClientAddr, &ClientAddrLen);
+#endif
+}
+
+int main(int argc, char *argv[]) {
+
+  ExitOnErr.setBanner(std::string(argv[0]) + ": ");
+
+  int InFD = 0;
+  int OutFD = 0;
+
+  if (argc < 2)
+    printErrorAndExit("insufficient arguments");
+  else {
+    StringRef Arg1 = argv[1];
+    StringRef SpecifierType, Specifier;
+    std::tie(SpecifierType, Specifier) = Arg1.split('=');
+    if (SpecifierType == "filedescs") {
+      StringRef FD1Str, FD2Str;
+      std::tie(FD1Str, FD2Str) = Specifier.split(',');
+      if (FD1Str.getAsInteger(10, InFD))
+        printErrorAndExit(FD1Str + " is not a valid file descriptor");
+      if (FD2Str.getAsInteger(10, OutFD))
+        printErrorAndExit(FD2Str + " is not a valid file descriptor");
+    } else if (SpecifierType == "listen") {
+      StringRef Host, PortStr;
+      std::tie(Host, PortStr) = Specifier.split(':');
+
+      int Port = 0;
+      if (PortStr.getAsInteger(10, Port))
+        printErrorAndExit("port" + PortStr + " is not a valid integer");
+
+      InFD = OutFD = openListener(Host.str(), Port);
+    } else
+      printErrorAndExit("invalid specifier type \"" + SpecifierType + "\"");
+  }
+
+  ExitOnErr.setBanner(std::string(argv[0]) + ":");
+
+  using JITLinkExecutorEndpoint =
+      rpc::MultiThreadedRPCEndpoint<rpc::FDRawByteChannel>;
+
+  rpc::registerStringError<rpc::FDRawByteChannel>();
+
+  rpc::FDRawByteChannel C(InFD, OutFD);
+  JITLinkExecutorEndpoint EP(C, true);
+  OrcRPCTPCServer<JITLinkExecutorEndpoint> Server(EP);
+  Server.setProgramName(std::string("llvm-jitlink-executor"));
+
+  ExitOnErr(Server.run());
+
+  return 0;
+}

llvm/tools/llvm-jitlink/llvm-jitlink.h

 #ifndef LLVM_TOOLS_LLVM_JITLINK_LLVM_JITLINK_H
 #define LLVM_TOOLS_LLVM_JITLINK_LLVM_JITLINK_H
 
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringSet.h"
 #include "llvm/ADT/Triple.h"
 #include "llvm/ExecutionEngine/Orc/Core.h"
 #include "llvm/ExecutionEngine/Orc/ObjectLinkingLayer.h"
+#include "llvm/ExecutionEngine/Orc/OrcRPCTargetProcessControl.h"
+#include "llvm/ExecutionEngine/Orc/RPC/FDRawByteChannel.h"
+#include "llvm/ExecutionEngine/Orc/RPC/RPCUtils.h"
 #include "llvm/ExecutionEngine/Orc/TargetProcessControl.h"
 #include "llvm/ExecutionEngine/RuntimeDyldChecker.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/Regex.h"
 #include "llvm/Support/raw_ostream.h"
 
 #include <vector>
 
public:
 
   Error add(orc::ResourceTrackerSP RT,
             std::unique_ptr<MemoryBuffer> O) override;
 
 private:
   Session &S;
 };
 
+using LLVMJITLinkChannel = orc::rpc::FDRawByteChannel;
+using LLVMJITLinkRPCEndpoint =
+    orc::rpc::MultiThreadedRPCEndpoint<LLVMJITLinkChannel>;
+using LLVMJITLinkRemoteMemoryManager =
+    orc::OrcRPCTPCJITLinkMemoryManager<LLVMJITLinkRPCEndpoint>;
+using LLVMJITLinkRemoteMemoryAccess =
+    orc::OrcRPCTPCMemoryAccess<LLVMJITLinkRPCEndpoint>;
+
+class LLVMJITLinkRemoteTargetProcessControl
+    : public orc::OrcRPCTargetProcessControlBase<LLVMJITLinkRPCEndpoint> {
+public:
+  using BaseT = orc::OrcRPCTargetProcessControlBase<LLVMJITLinkRPCEndpoint>;
+  static Expected<std::unique_ptr<TargetProcessControl>> LaunchExecutor();
+
+  static Expected<std::unique_ptr<TargetProcessControl>> ConnectToExecutor();
+
+  Error disconnect() override;
+
+private:
+  using LLVMJITLinkRemoteMemoryAccess =
+      orc::OrcRPCTPCMemoryAccess<LLVMJITLinkRemoteTargetProcessControl>;
+
+  using LLVMJITLinkRemoteMemoryManager =
+      orc::OrcRPCTPCJITLinkMemoryManager<LLVMJITLinkRemoteTargetProcessControl>;
+
+  LLVMJITLinkRemoteTargetProcessControl(
+      std::shared_ptr<orc::SymbolStringPool> SSP,
+      std::unique_ptr<LLVMJITLinkChannel> Channel,
+      std::unique_ptr<LLVMJITLinkRPCEndpoint> Endpoint,
+      ErrorReporter ReportError, Error &Err)
+      : BaseT(std::move(SSP), *Endpoint, std::move(ReportError)),
+        Channel(std::move(Channel)), Endpoint(std::move(Endpoint)) {
+    ErrorAsOutParameter _(&Err);
+
+    ListenerThread = std::thread([&]() {
+      while (!Finished) {
+        if (auto Err = this->Endpoint->handleOne()) {
+          reportError(std::move(Err));
+          return;
+        }
+      }
+    });
+
+    if (auto Err2 = initializeORCRPCTPCBase()) {
+      Err = joinErrors(std::move(Err2), disconnect());
+      return;
+    }
+
+    OwnedMemAccess = std::make_unique<LLVMJITLinkRemoteMemoryAccess>(*this);
+    MemAccess = OwnedMemAccess.get();
+    OwnedMemMgr = std::make_unique<LLVMJITLinkRemoteMemoryManager>(*this);
+    MemMgr = OwnedMemMgr.get();
+  }
+
+  std::unique_ptr<LLVMJITLinkChannel> Channel;
+  std::unique_ptr<LLVMJITLinkRPCEndpoint> Endpoint;
+  std::unique_ptr<TargetProcessControl::MemoryAccess> OwnedMemAccess;
+  std::unique_ptr<jitlink::JITLinkMemoryManager> OwnedMemMgr;
+  std::atomic<bool> Finished{false};
+  std::thread ListenerThread;
+};
+
 struct Session {
-  orc::ExecutionSession ES;
   std::unique_ptr<orc::TargetProcessControl> TPC;
+  orc::ExecutionSession ES;
   orc::JITDylib *MainJD;
   LLVMJITLinkObjectLinkingLayer ObjLayer;
   std::vector<orc::JITDylib *> JDSearchOrder;
 
   ~Session();
 
   static Expected<std::unique_ptr<Session>> Create(Triple TT);
   void dumpSessionInfo(raw_ostream &OS);
struct Session {
   uint64_t SizeAfterFixups = 0;
 
   StringSet<> HarnessFiles;
   StringSet<> HarnessExternals;
   StringSet<> HarnessDefinitions;
   DenseMap<StringRef, StringRef> CanonicalWeakDefs;
 
 private:
-  Session(Triple TT, uint64_t PageSize, Error &Err);
+  Session(std::unique_ptr<orc::TargetProcessControl> TPC, Error &Err);
 };
 
 /// Record symbols, GOT entries, stubs, and sections for ELF file.
 Error registerELFGraphInfo(Session &S, jitlink::LinkGraph &G);
 
 /// Record symbols, GOT entries, stubs, and sections for MachO file.
 Error registerMachOGraphInfo(Session &S, jitlink::LinkGraph &G);
 
 } // end namespace llvm
 
 #endif // LLVM_TOOLS_LLVM_JITLINK_LLVM_JITLINK_H

llvm/tools/llvm-jitlink/llvm-jitlink.cpp

 // library, which makes relocatable object files executable in memory. Its
 // primary function is as a testing utility for the jitlink library.
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm-jitlink.h"
 
 #include "llvm/BinaryFormat/Magic.h"
-#include "llvm/ExecutionEngine/JITLink/EHFrameSupport.h"
 #include "llvm/ExecutionEngine/Orc/ExecutionUtils.h"
 #include "llvm/ExecutionEngine/Orc/TPCDynamicLibrarySearchGenerator.h"
+#include "llvm/ExecutionEngine/Orc/TPCEHFrameRegistrar.h"
 #include "llvm/MC/MCAsmInfo.h"
 #include "llvm/MC/MCContext.h"
 #include "llvm/MC/MCDisassembler/MCDisassembler.h"
 #include "llvm/MC/MCInstPrinter.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/MC/MCSubtargetInfo.h"
 #include "llvm/MC/MCTargetOptions.h"
 #include "llvm/Object/COFF.h"
 #include "llvm/Object/MachO.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/InitLLVM.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Support/TargetSelect.h"
 #include "llvm/Support/Timer.h"
 
 #include <list>
 #include <string>
 
+#ifdef LLVM_ON_UNIX
+#include <netdb.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <unistd.h>
+#endif // LLVM_ON_UNIX
+
 #define DEBUG_TYPE "llvm_jitlink"
 
 using namespace llvm;
 using namespace llvm::jitlink;
 using namespace llvm::orc;
 
 static cl::list<std::string> InputFiles(cl::Positional, cl::OneOrMore,
                                         cl::desc("input files"));
static cl::opt<bool> ShowRelocatedSectionContents(
     cl::desc("show section contents after fixups have been applied"),
     cl::init(false));
 
 static cl::opt<bool> PhonyExternals(
     "phony-externals",
     cl::desc("resolve all otherwise unresolved externals to null"),
     cl::init(false));
 
+static cl::opt<std::string> OutOfProcessExecutor(
+    "oop-executor", cl::desc("Launch an out-of-process executor to run code"),
+    cl::ValueOptional);
+
+static cl::opt<std::string> OutOfProcessExecutorConnect(
+    "oop-executor-connect",
+    cl::desc("Connect to an out-of-process executor via TCP"));
+
 ExitOnError ExitOnErr;
 
 namespace llvm {
 
 static raw_ostream &
 operator<<(raw_ostream &OS, const Session::MemoryRegionInfo &MRI) {
   return OS << "target addr = "
             << format("0x%016" PRIx64, MRI.getTargetAddress())
Error LLVMJITLinkObjectLinkingLayer::add(ResourceTrackerSP RT,
 
   auto MU = std::make_unique<BasicObjectLayerMaterializationUnit>(
       *this, std::move(O), std::move(SymbolFlags), std::move(InitSymbol));
 
   auto &JD = RT->getJITDylib();
   return JD.define(std::move(MU), std::move(RT));
 }
 
+Expected<std::unique_ptr<TargetProcessControl>>
+LLVMJITLinkRemoteTargetProcessControl::LaunchExecutor() {
+#ifndef LLVM_ON_UNIX
+  // FIXME: Add support for Windows.
+  return make_error<StringError>("-" + OutOfProcessExecutor.ArgStr +
+                                     " not supported on non-unix platforms",
+                                 inconvertibleErrorCode());
+#else
+
+  rpc::registerStringError<LLVMJITLinkChannel>();
+
+  constexpr int ReadEnd = 0;
+  constexpr int WriteEnd = 1;
+
+  // Pipe FDs.
+  int ToExecutor[2];
+  int FromExecutor[2];
+
+  pid_t ChildPID;
+
+  // Create pipes to/from the executor..
+  if (pipe(ToExecutor) != 0 || pipe(FromExecutor) != 0)
+    return make_error<StringError>("Unable to create pipe for executor",
+                                   inconvertibleErrorCode());
+
+  ChildPID = fork();
+
+  if (ChildPID == 0) {
+    // In the child...
+
+    // Close the parent ends of the pipes
+    close(ToExecutor[WriteEnd]);
+    close(FromExecutor[ReadEnd]);
+
+    // Execute the child process.
+    std::unique_ptr<char[]> ExecutorPath, FDSpecifier;
+    {
+      ExecutorPath = std::make_unique<char[]>(OutOfProcessExecutor.size() + 1);
+      strcpy(ExecutorPath.get(), OutOfProcessExecutor.data());
+
+      std::string FDSpecifierStr("filedescs=");
+      FDSpecifierStr += utostr(ToExecutor[ReadEnd]);
+      FDSpecifierStr += ',';
+      FDSpecifierStr += utostr(FromExecutor[WriteEnd]);
+      FDSpecifier = std::make_unique<char[]>(FDSpecifierStr.size() + 1);
+      strcpy(FDSpecifier.get(), FDSpecifierStr.c_str());
+    }
+
+    char *const Args[] = {ExecutorPath.get(), FDSpecifier.get(), nullptr};
+    int RC = execvp(ExecutorPath.get(), Args);
+    if (RC != 0) {
+      errs() << "unable to launch out-of-process executor \""
+             << ExecutorPath.get() << "\"\n";
+      exit(1);
+    }
+  }
+  // else we're the parent...
+
+  // Close the child ends of the pipes
+  close(ToExecutor[ReadEnd]);
+  close(FromExecutor[WriteEnd]);
+
+  // Return an RPC channel connected to our end of the pipes.
+  auto SSP = std::make_shared<SymbolStringPool>();
+  auto Channel = std::make_unique<rpc::FDRawByteChannel>(FromExecutor[ReadEnd],
+                                                         ToExecutor[WriteEnd]);
+  auto Endpoint = std::make_unique<LLVMJITLinkRPCEndpoint>(*Channel, true);
+
+  auto ReportError = [](Error Err) {
+    logAllUnhandledErrors(std::move(Err), errs(), "");
+  };
+
+  Error Err = Error::success();
+  std::unique_ptr<LLVMJITLinkRemoteTargetProcessControl> RTPC(
+      new LLVMJITLinkRemoteTargetProcessControl(
+          std::move(SSP), std::move(Channel), std::move(Endpoint),
+          std::move(ReportError), Err));
+  if (Err)
+    return std::move(Err);
+  return std::move(RTPC);
+#endif
+}
+
+Expected<std::unique_ptr<TargetProcessControl>>
+LLVMJITLinkRemoteTargetProcessControl::ConnectToExecutor() {
+#ifndef LLVM_ON_UNIX
+  // FIXME: Add TCP support for Windows.
+  return make_error<StringError>("-" + OutOfProcessExecutorConnect.ArgStr +
+                                     " not supported on non-unix platforms",
+                                 inconvertibleErrorCode());
+#else
+
+  rpc::registerStringError<LLVMJITLinkChannel>();
+
+  StringRef HostNameStr, PortStr;
+  std::tie(HostNameStr, PortStr) =
+      StringRef(OutOfProcessExecutorConnect).split(':');
+
+  if (HostNameStr.empty())
+    return make_error<StringError>("host name for -" +
+                                       OutOfProcessExecutorConnect.ArgStr +
+                                       " can not be empty",
+                                   inconvertibleErrorCode());
+  if (PortStr.empty())
+    return make_error<StringError>(
+        "port for -" + OutOfProcessExecutorConnect.ArgStr + " can not be empty",
+        inconvertibleErrorCode());
+
+  std::string HostName = HostNameStr.str();
+  int Port = 0;
+  if (PortStr.getAsInteger(10, Port))
+    return make_error<StringError>("port number " + PortStr +
+                                       " is not a valid integer",
+                                   inconvertibleErrorCode());
+
+  int SockFD = socket(PF_INET, SOCK_STREAM, 0);
+  hostent *Server = gethostbyname(HostName.c_str());
+  sockaddr_in ServAddr;
+  memset(&ServAddr, 0, sizeof(ServAddr));
+  ServAddr.sin_family = PF_INET;
+  memmove(&Server->h_addr, &ServAddr.sin_addr.s_addr, Server->h_length);
+  ServAddr.sin_port = htons(Port);
+  if (connect(SockFD, reinterpret_cast<sockaddr *>(&ServAddr),
+              sizeof(ServAddr)) < 0)
+    return make_error<StringError>("Failed to connect to " + HostName + ":" +
+                                       Twine(Port),
+                                   inconvertibleErrorCode());
+
+  auto SSP = std::make_shared<SymbolStringPool>();
+  auto Channel = std::make_unique<rpc::FDRawByteChannel>(SockFD, SockFD);
+  auto Endpoint = std::make_unique<LLVMJITLinkRPCEndpoint>(*Channel, true);
+
+  auto ReportError = [](Error Err) {
+    logAllUnhandledErrors(std::move(Err), errs(), "");
+  };
+
+  Error Err = Error::success();
+  std::unique_ptr<LLVMJITLinkRemoteTargetProcessControl> RTPC(
+      new LLVMJITLinkRemoteTargetProcessControl(
+          std::move(SSP), std::move(Channel), std::move(Endpoint),
+          std::move(ReportError), Err));
+  if (Err)
+    return std::move(Err);
+  return std::move(RTPC);
+#endif
+}
+
+Error LLVMJITLinkRemoteTargetProcessControl::disconnect() {
+  std::promise<MSVCPError> P;
+  auto F = P.get_future();
+  auto Err = closeConnection([&](Error Err) -> Error {
+    P.set_value(std::move(Err));
+    Finished = true;
+    return Error::success();
+  });
+  ListenerThread.join();
+  return joinErrors(std::move(Err), F.get());
+};
+
 class PhonyExternalsGenerator : public DefinitionGenerator {
 public:
   Error tryToGenerate(LookupState &LS, LookupKind K, JITDylib &JD,
                       JITDylibLookupFlags JDLookupFlags,
                       const SymbolLookupSet &LookupSet) override {
     SymbolMap PhonySymbols;
     for (auto &KV : LookupSet)
       PhonySymbols[KV.first] = JITEvaluatedSymbol(0, JITSymbolFlags::Exported);
     return JD.define(absoluteSymbols(std::move(PhonySymbols)));
   }
 };
 
 Expected<std::unique_ptr<Session>> Session::Create(Triple TT) {
-  Error Err = Error::success();
 
   auto PageSize = sys::Process::getPageSize();
   if (!PageSize)
     return PageSize.takeError();
 
-  std::unique_ptr<Session> S(new Session(std::move(TT), *PageSize, Err));
+  /// If -oop-executor is passed then launch the executor.
+  std::unique_ptr<TargetProcessControl> TPC;
+  if (OutOfProcessExecutor.getNumOccurrences()) {
+    if (auto RTPC = LLVMJITLinkRemoteTargetProcessControl::LaunchExecutor())
+      TPC = std::move(*RTPC);
+    else
+      return RTPC.takeError();
+  } else if (OutOfProcessExecutorConnect.getNumOccurrences()) {
+    if (auto RTPC = LLVMJITLinkRemoteTargetProcessControl::ConnectToExecutor())
+      TPC = std::move(*RTPC);
+    else
+      return RTPC.takeError();
+  } else
+    TPC = std::make_unique<SelfTargetProcessControl>(
+        std::make_shared<SymbolStringPool>(), std::move(TT), *PageSize,
+        createMemoryManager());
+
+  Error Err = Error::success();
+  std::unique_ptr<Session> S(new Session(std::move(TPC), Err));
   if (Err)
     return std::move(Err);
   return std::move(S);
 }
 
 Session::~Session() {
   if (auto Err = ES.endSession())
     ES.reportError(std::move(Err));
 }
 
 // FIXME: Move to createJITDylib if/when we start using Platform support in
 // llvm-jitlink.
-Session::Session(Triple TT, uint64_t PageSize, Error &Err)
-    : TPC(std::make_unique<SelfTargetProcessControl>(std::move(TT), PageSize,
-                                                     createMemoryManager())),
-      ObjLayer(*this, TPC->getMemMgr()) {
+Session::Session(std::unique_ptr<TargetProcessControl> TPC, Error &Err)
+    : TPC(std::move(TPC)), ObjLayer(*this, this->TPC->getMemMgr()) {
 
   /// Local ObjectLinkingLayer::Plugin class to forward modifyPassConfig to the
   /// Session.
   class JITLinkSessionPlugin : public ObjectLinkingLayer::Plugin {
   public:
     JITLinkSessionPlugin(Session &S) : S(S) {}
     void modifyPassConfig(MaterializationResponsibility &MR, const Triple &TT,
                           PassConfiguration &PassConfig) override {
Session::Session(std::unique_ptr<TargetProcessControl> TPC, Error &Err)
 
   if (auto MainJDOrErr = ES.createJITDylib("main"))
     MainJD = &*MainJDOrErr;
   else {
     Err = MainJDOrErr.takeError();
     return;
   }
 
-  if (!NoExec && !TT.isOSWindows())
+  if (!NoExec && !this->TPC->getTargetTriple().isOSWindows())
     ObjLayer.addPlugin(std::make_unique<EHFrameRegistrationPlugin>(
-        ES, std::make_unique<InProcessEHFrameRegistrar>()));
+        ES, ExitOnErr(TPCEHFrameRegistrar::Create(*this->TPC))));
 
   ObjLayer.addPlugin(std::make_unique<JITLinkSessionPlugin>(*this));
 
   // Process any harness files.
   for (auto &HarnessFile : TestHarnesses) {
     HarnessFiles.insert(HarnessFile);
 
     auto ObjBuffer =
return make_error<StringError>(ErrorMsgStem + ": symbol " + SymbolName +
                                        " not found",
                                    inconvertibleErrorCode());
   return SymInfoItr->second;
 }
 
 } // end namespace llvm
 
 static Triple getFirstFileTriple() {
+  static Triple FirstTT = []() {
     assert(!InputFiles.empty() && "InputFiles can not be empty");
     auto ObjBuffer =
         ExitOnErr(errorOrToExpected(MemoryBuffer::getFile(InputFiles.front())));
     auto Obj = ExitOnErr(
         object::ObjectFile::createObjectFile(ObjBuffer->getMemBufferRef()));
     return Obj->makeTriple();
+  }();
+
+  return FirstTT;
 }
 
-static Error sanitizeArguments(const Session &S) {
+static Error sanitizeArguments(const Triple &TT, const char *ArgV0) {
+  // Set the entry point name if not specified.
   if (EntryPointName.empty()) {
-    if (S.TPC->getTargetTriple().getObjectFormat() == Triple::MachO)
+    if (TT.getObjectFormat() == Triple::MachO)
       EntryPointName = "_main";
     else
       EntryPointName = "main";
   }
 
+  // -noexec and --args should not be used together.
   if (NoExec && !InputArgv.empty())
     outs() << "Warning: --args passed to -noexec run will be ignored.\n";
 
   // If -slab-address is passed, require -slab-allocate and -noexec
   if (SlabAddress != ~0ULL) {
     if (SlabAllocateSizeString == "" || !NoExec)
       return make_error<StringError>(
           "-slab-address requires -slab-allocate and -noexec",
           inconvertibleErrorCode());
   }
 
+  // Only one of -oop-executor and -oop-executor-connect can be used.
+  if (!!OutOfProcessExecutor.getNumOccurrences() &&
+      !!OutOfProcessExecutorConnect.getNumOccurrences())
+    return make_error<StringError>(
+        "Only one of -" + OutOfProcessExecutor.ArgStr + " and -" +
+            OutOfProcessExecutorConnect.ArgStr + " can be specified",
+        inconvertibleErrorCode());
+
+  // If -oop-executor was used but no value was specified then use a sensible
+  // default.
+  if (!!OutOfProcessExecutor.getNumOccurrences() &&
+      OutOfProcessExecutor.empty()) {
+    SmallString<256> OOPExecutorPath(sys::fs::getMainExecutable(
+        ArgV0, reinterpret_cast<void *>(&sanitizeArguments)));
+    sys::path::remove_filename(OOPExecutorPath);
+    if (OOPExecutorPath.back() != '/')
+      OOPExecutorPath += '/';
+    OOPExecutorPath += "llvm-jitlink-executor";
+    OutOfProcessExecutor = OOPExecutorPath.str().str();
+  }
+
   return Error::success();
 }
 
 static Error loadProcessSymbols(Session &S) {
-  auto InternedEntryPointName = S.ES.intern(EntryPointName);
-  auto FilterMainEntryPoint = [InternedEntryPointName](SymbolStringPtr Name) {
-    return Name != InternedEntryPointName;
+  auto FilterMainEntryPoint =
+      [EPName = S.ES.intern(EntryPointName)](SymbolStringPtr Name) {
+        return Name != EPName;
       };
   S.MainJD->addGenerator(
       ExitOnErr(orc::TPCDynamicLibrarySearchGenerator::GetForTargetProcess(
           *S.TPC, std::move(FilterMainEntryPoint))));
 
   return Error::success();
 }
 
-static Error loadDylibs() {
-  // FIXME: This should all be handled inside DynamicLibrary.
+static Error loadDylibs(Session &S) {
   for (const auto &Dylib : Dylibs) {
-    if (!sys::fs::is_regular_file(Dylib))
-      return make_error<StringError>("\"" + Dylib + "\" is not a regular file",
-                                     inconvertibleErrorCode());
-    std::string ErrMsg;
-    if (sys::DynamicLibrary::LoadLibraryPermanently(Dylib.c_str(), &ErrMsg))
-      return make_error<StringError>(ErrMsg, inconvertibleErrorCode());
+    auto G = orc::TPCDynamicLibrarySearchGenerator::Load(*S.TPC, Dylib.c_str());
+    if (!G)
+      return G.takeError();
+    S.MainJD->addGenerator(std::move(*G));
   }
 
   return Error::success();
 }
 
 static void addPhonyExternalsGenerator(Session &S) {
   S.MainJD->addGenerator(std::make_unique<PhonyExternalsGenerator>());
 }
int main(int argc, char *argv[]) {
 
   cl::ParseCommandLineOptions(argc, argv, "llvm jitlink tool");
   ExitOnErr.setBanner(std::string(argv[0]) + ": ");
 
   /// If timers are enabled, create a JITLinkTimers instance.
   std::unique_ptr<JITLinkTimers> Timers =
       ShowTimes ? std::make_unique<JITLinkTimers>() : nullptr;
 
-  auto S = ExitOnErr(Session::Create(getFirstFileTriple()));
+  ExitOnErr(sanitizeArguments(getFirstFileTriple(), argv[0]));
 
-  ExitOnErr(sanitizeArguments(*S));
+  auto S = ExitOnErr(Session::Create(getFirstFileTriple()));
 
   {
     TimeRegion TR(Timers ? &Timers->LoadObjectsTimer : nullptr);
     ExitOnErr(loadObjects(*S));
   }
 
   if (!NoProcessSymbols)
     ExitOnErr(loadProcessSymbols(*S));
-  ExitOnErr(loadDylibs());
+  ExitOnErr(loadDylibs(*S));
 
   if (PhonyExternals)
     addPhonyExternalsGenerator(*S);
 
 
   if (ShowInitialExecutionSessionState)
     S->ES.dump(outs());
 
int main(int argc, char *argv[]) {
 
   dumpSessionStats(*S);
 
   if (NoExec)
     return 0;
 
   int Result = 0;
   {
-    using MainTy = int (*)(int, char *[]);
-    auto EntryFn = jitTargetAddressToFunction<MainTy>(EntryPoint.getAddress());
     TimeRegion TR(Timers ? &Timers->RunTimer : nullptr);
-    Result = runAsMain(EntryFn, InputArgv, StringRef(InputFiles.front()));
+    Result = ExitOnErr(S->TPC->runAsMain(EntryPoint.getAddress(), InputArgv));
   }
 
+  ExitOnErr(S->ES.endSession());
+  ExitOnErr(S->TPC->disconnect());
+
   return Result;
 }

llvm/unittests/ExecutionEngine/JITLink/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   ${LLVM_TARGETS_TO_BUILD}
   JITLink
   Object
+  OrcShared
+  OrcTargetProcess
   RuntimeDyld
   Support
   )
 
 add_llvm_unittest(JITLinkTests
     LinkGraphTests.cpp
   )
 
 target_link_libraries(JITLinkTests PRIVATE LLVMTestingSupport)

llvm/unittests/ExecutionEngine/Orc/CMakeLists.txt

 
 set(LLVM_LINK_COMPONENTS
   Core
   ExecutionEngine
   Object
-  OrcError
   OrcJIT
+  OrcShared
   Passes
   RuntimeDyld
   Support
   native
   )
 
 add_llvm_unittest(OrcJITTests
   CoreAPIsTest.cpp