Fix modules build for LLVMOrcShared

[sgraenitz]

Summary

Follow-up from D92873. OrcShared shouldn't depend on intrinsics_gen, it should only include code that is required in both, OrcJIT and OrcTargetProcess. The former already depends on intrinsics_gen and the latter doesn't need it.

This is a minimal change for fixing the modules build while avoiding the OrcShared dependency to intrinsics_gen -- not necessarily final. I think there are two discussion topics here:
(1) Should we clean up the module map? It seems there are some outdated entries.
(2) Can we copy/move a subset of ExecutionEngine's JITSymbol.h to OrcShared as proposed here and/or improve it?

[sgraenitz]

@lhames Does anything prevent us from having a dedicated JITTargetAddress in OrcShared? Am I remembering correctly, that JITSymbol is last dependency to ExecutionEngine? Maybe, now that release 12 branched we could think about planning a change like this?

llvm/include/llvm/module.modulemap

196

These moved to OrcShared, but I don't get errors as is. So, can we just remove them?

212

Is OrcSupport meant as the lib we call OrcShared today?

[teemperor]

Thanks for working on this! I think @lhames is the right person for any code restructuring, but I can review all the modulemap stuff.

llvm/include/llvm/module.modulemap

196

I don't think Clang reports missing excluded headers. I think the paths here should be update as I *believe* Clang otherwise compiles the headers twice into each module.

212

I think all the modules we have here are *supposed* to represent a specific library, but in some situations (like here) it's just a group of headers that at least allow us to compile everything as a module. If putting all the Orc/Shared headers into their own module works with the module build, then we can also rename this to LLVM_OrcShared and use an umbrella like in LLVM_DebugInfo_CodeView above.

I think it would be even better if we could split up the different headers into modules that match the specific libraries, e.g. LLVM_OrcJIT, LLVM_OrcTargetProcess, LLVM_OrcShared and a LLVM_ExecutionEngine module (the last one only contains the headers directly in ExecutionEngine, but given the comments above I'm not sure if we can modularize them).

[lhames]

Sorry for the very delayed review!

In D95747#2532432, @sgraenitz wrote:

@lhames Does anything prevent us from having a dedicated JITTargetAddress in OrcShared?

No. I recently added an ExecutorAddress class to OrcShared that I would like to use to slowly replace JITTargetAddress (in both ORC and JITLink), but I think that it is a good idea to have a dedicated JITTargetAddress in OrcShared to simplify the library story in the short term.

Am I remembering correctly, that JITSymbol is last dependency to ExecutionEngine? Maybe, now that release 12 branched we could think about planning a change like this?

I agree. I think we should wait until the current ExecutorProcessControl work settles down: that will allow us to remove a lot of existing code, which will make decoupling ORC from ExecutionEngine even easier. I think LLVM 14 or LLVM 15 is a reasonable timeframe for this.

[sgraenitz]

Hi Lang, thanks for your notes. I will leave this here as a reminder for myself and revisit the plan once it's time for the next release to branch.

[sgraenitz]

I never got around to it again and it doesn't look like that's going to change anytime soon. We still use JITSymbol.h in both, Orc and JITLink and we still have the dependency to intrinsics_gen.

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

+//===--- JITSymbol.h -- JIT symbol abstraction ------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+//
+// Abstraction for target process addresses.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_EXECUTIONENGINE_ORC_SHARED_JITSYMBOL_H
+#define LLVM_EXECUTIONENGINE_ORC_SHARED_JITSYMBOL_H
+
+#include <cassert>
+#include <cstdint>
+#include <type_traits>
+
+namespace llvm {
+namespace orc {
+
+/// Represents an address in the target process's address space.
+using JITTargetAddress = uint64_t;
+
+/// Convert a JITTargetAddress to a pointer.
+///
+/// Note: This is a raw cast of the address bit pattern to the given pointer
+/// type. When casting to a function pointer in order to execute JIT'd code
+/// jitTargetAddressToFunction should be preferred, as it will also perform
+/// pointer signing on targets that require it.
+template <typename T> T jitTargetAddressToPointer(JITTargetAddress Addr) {
+  static_assert(std::is_pointer<T>::value, "T must be a pointer type");
+  uintptr_t IntPtr = static_cast<uintptr_t>(Addr);
+  assert(IntPtr == Addr && "JITTargetAddress value out of range for uintptr_t");
+  return reinterpret_cast<T>(IntPtr);
+}
+
+/// Convert a JITTargetAddress to a callable function pointer.
+///
+/// Casts the given address to a callable function pointer. This operation
+/// will perform pointer signing for platforms that require it (e.g. arm64e).
+template <typename T> T jitTargetAddressToFunction(JITTargetAddress Addr) {
+  static_assert(std::is_pointer<T>::value &&
+                    std::is_function<std::remove_pointer_t<T>>::value,
+                "T must be a function pointer type");
+  return jitTargetAddressToPointer<T>(Addr);
+}
+
+/// Convert a pointer to a JITTargetAddress.
+template <typename T> JITTargetAddress pointerToJITTargetAddress(T *Ptr) {
+  return static_cast<JITTargetAddress>(reinterpret_cast<uintptr_t>(Ptr));
+}
+
+} // end namespace orc
+} // end namespace llvm
+
+#endif // LLVM_EXECUTIONENGINE_ORC_SHARED_JITSYMBOL_H

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

 //
 //===----------------------------------------------------------------------===//
 
 #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 <vector>
 
 namespace llvm {
+
+/// Represents an address in the target process's address space.
+using JITTargetAddress = uint64_t;
+
 namespace orc {
 namespace tpctypes {
 
 template <typename T> struct UIntWrite {
   UIntWrite() = default;
   UIntWrite(JITTargetAddress Address, T Value)
       : Address(Address), Value(Value) {}
 

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/Shared/JITSymbol.h"
 #include "llvm/ExecutionEngine/Orc/Shared/RPCUtils.h"
 #include "llvm/ExecutionEngine/Orc/Shared/RawByteChannel.h"
 #include "llvm/ExecutionEngine/Orc/Shared/TargetProcessControlTypes.h"
 #include "llvm/ExecutionEngine/Orc/TargetProcess/TargetExecutionUtils.h"
 #include "llvm/Support/DynamicLibrary.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/MathExtras.h"

llvm/include/llvm/module.modulemap

module LLVM_ExecutionEngine {
   exclude header "ExecutionEngine/Orc/OrcRemoteTargetClient.h"
   exclude header "ExecutionEngine/Orc/OrcRemoteTargetServer.h"
   exclude header "ExecutionEngine/Orc/RemoteObjectLayer.h"
 
   // Exclude headers from LLVM_OrcSupport.
   exclude header "ExecutionEngine/Orc/Shared/OrcError.h"
   exclude header "ExecutionEngine/Orc/RPC/RPCUtils.h"
   exclude header "ExecutionEngine/Orc/RPC/RPCSerialization.h"
   exclude header "ExecutionEngine/Orc/RPC/RawByteChannel.h"
 
+  exclude header "ExecutionEngine/Orc/TargetProcess/TargetExecutionUtils.h"
+
 }
 
 module LLVM_FileCheck {
   requires cplusplus
 
   umbrella "FileCheck"
   module * { export * }
 }
 
 // Orc utilities that don't depend only on Support (not ExecutionEngine or
 // IR). This is a workaround for ExecutionEngine's broken layering, and will
 // be removed in the future.
 module LLVM_OrcSupport {
   requires cplusplus
 
   header "ExecutionEngine/Orc/Shared/OrcError.h"
   header "ExecutionEngine/Orc/Shared/RPCUtils.h"
   header "ExecutionEngine/Orc/Shared/Serialization.h"
   header "ExecutionEngine/Orc/Shared/RawByteChannel.h"
 
   export *

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

 add_llvm_component_library(LLVMOrcShared
   OrcError.cpp
   RPCError.cpp
   TargetProcessControlTypes.cpp
   ADDITIONAL_HEADER_DIRS
   ${LLVM_MAIN_INCLUDE_DIR}/llvm/ExecutionEngine/Orc
 
-  DEPENDS
-  intrinsics_gen
-
   LINK_COMPONENTS
   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/Config/config.h"
-#include "llvm/ExecutionEngine/JITSymbol.h"
+#include "llvm/ExecutionEngine/Orc/Shared/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"