Dispatch.h

Go to the documentation of this file.

//===--- Dispatch.h - CppInterOp's API Dispatch Mechanism ---*- C++ -*-===//
//
// Part of the compiler-research project, under the Apache License v2.0 with
// LLVM Exceptions.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// Defines the mechanism which enables dispatching of the CppInterOp API
// without linking, preventing any LLVM or Clang symbols from being leaked
// into the client application. This is achieved using a symbol-address table
// and an address lookup through a C symbol allowing clients to dlopen
// CppInterOp with RTLD_LOCAL, and automatically assign the API during runtime.
//
// The function list is generated by cppinterop-tblgen from CppInterOp.td
// into CppInterOpAPI.inc, which is included multiple times with different
// macro definitions (X-macro pattern).
//
//===----------------------------------------------------------------------===//
 
#ifndef CPPINTEROP_DISPATCH_H
#define CPPINTEROP_DISPATCH_H
 
#ifdef CPPINTEROP_CPPINTEROP_H
#error "CppInterOp.h and Dispatch.h are mutually exclusive — include only one."
#endif
 
#ifdef _WIN32
#include <windows.h>
#undef LoadLibrary
#else
#include <dlfcn.h>
#endif
 
#include "CppInterOp/Box.h"
#include "CppInterOp/CppInterOpTypes.h"
 
#include <cstdlib>
#include <iostream>
#include <memory>
#include <mutex>
#include <set>
 
using CppFnPtrTy = void (*)();
///\param[in] procname - the name of the FunctionEntry in the symbol lookup
/// table.
///
///\returns the function address of the requested API, or nullptr if not found
extern "C" CPPINTEROP_API CppFnPtrTy CppGetProcAddress(const char* procname);
 
// TODO: implement overload that takes an existing opened DL handle
inline void* dlGetProcAddress(const char* name,
                              const char* customLibPath = nullptr) {
  static auto init = std::make_unique<std::once_flag>();
  static void* (*getProc)(const char*);
 
  if (!name) {
    init = std::make_unique<std::once_flag>();
    getProc = nullptr;
    return nullptr;
  }
 
  std::call_once(*init, [customLibPath]() {
    const char* path =
        customLibPath ? customLibPath : std::getenv("CPPINTEROP_LIBRARY_PATH");
    if (!path)
      return;
 
#ifdef _WIN32
    HMODULE h = LoadLibraryA(path);
    if (h) {
      getProc = reinterpret_cast<void* (*)(const char*)>(
          GetProcAddress(h, "CppGetProcAddress"));
      if (!getProc)
        FreeLibrary(h);
    } else {
      std::cerr << "[CppInterOp Dispatch] error code=" << GetLastError()
                << "\n";
    }
#else
    void* handle = dlopen(path, RTLD_LOCAL | RTLD_NOW);
    if (handle) {
      // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
      getProc = reinterpret_cast<void* (*)(const char*)>(
          dlsym(handle, "CppGetProcAddress"));
      if (!getProc)
        dlclose(handle);
    } else {
      std::cerr << "[CppInterOp Dispatch] " << dlerror() << "\n";
    }
#endif
  });
 
  if (!getProc) {
    init = std::make_unique<std::once_flag>();
    getProc = nullptr;
    return nullptr;
  }
 
  return getProc(name);
}
 
// Raw function pointers populated by LoadDispatchAPI. No default arguments.
// Kept in a separate namespace so the dispatch-table state doesn't pollute
// the public Cpp:: surface.
namespace CppInternal::DispatchRaw {
using namespace Cpp;
// NOLINTBEGIN(cppcoreguidelines-avoid-non-const-global-variables)
#define CPPINTEROP_API_FUNC(DN, CN, Ret, DeclArgs, CallArgs, RawTypes)         \
  extern Ret(*DN) RawTypes;
#include "CppInterOp/CppInterOpAPI.inc"
// NOLINTEND(cppcoreguidelines-avoid-non-const-global-variables)
} // namespace CppInternal::DispatchRaw
 
// Inline wrappers go directly in namespace Cpp so that consumer source code
// (Cpp::IsAbstract, Cpp::GetNamed, ...) compiles identically against either
// CppInterOp.h (direct linking, declarations only) or Dispatch.h (inline
// bodies calling through the dispatch table). The two headers are mutually
// exclusive (#error guard at top) so only one body of Cpp::* exists per TU.
// CN (CppName) may differ from DN (DispatchName) for overloaded functions,
// e.g. CN=GetFunctionAddress, DN=GetFunctionAddress_fn.
namespace Cpp {
 
#define CPPINTEROP_API_FUNC(DN, CN, Ret, DeclArgs, CallArgs, RawTypes)         \
  inline Ret CN DeclArgs { return ::CppInternal::DispatchRaw::DN CallArgs; }
#include "CppInterOp/CppInterOpAPI.inc"
 
/// Initialize all CppInterOp API from the dynamically loaded library.
inline bool LoadDispatchAPI(const char* customLibPath = nullptr) {
#ifndef NDEBUG
  std::cout << "[CppInterOp Dispatch] Loading CppInterOp API from "
            << (customLibPath ? customLibPath : "default library path") << '\n';
#endif
  if (customLibPath) {
    void* test = dlGetProcAddress("GetInterpreter", customLibPath);
    if (!test) {
      std::cerr << "[CppInterOp Dispatch] Failed to load API from: "
                << customLibPath << '\n';
      return false;
    }
  }
 
  // NOLINTBEGIN(cppcoreguidelines-pro-type-reinterpret-cast)
#define CPPINTEROP_API_FUNC(DN, CN, Ret, DeclArgs, CallArgs, RawTypes)         \
  ::CppInternal::DispatchRaw::DN =                                             \
      reinterpret_cast<Ret(*) RawTypes>(dlGetProcAddress(#DN));
#include "CppInterOp/CppInterOpAPI.inc"
  // NOLINTEND(cppcoreguidelines-pro-type-reinterpret-cast)
 
  if (!::CppInternal::DispatchRaw::GetInterpreter ||
      !::CppInternal::DispatchRaw::CreateInterpreter) {
    std::cerr << "[CppInterOp Dispatch] Failed to load critical functions\n";
    return false;
  }
  return true;
}
 
inline void UnloadDispatchAPI() {
#define CPPINTEROP_API_FUNC(DN, CN, Ret, DeclArgs, CallArgs, RawTypes)         \
  ::CppInternal::DispatchRaw::DN = nullptr;
#include "CppInterOp/CppInterOpAPI.inc"
  dlGetProcAddress(nullptr, nullptr);
}
} // namespace Cpp
 
#endif // CPPINTEROP_DISPATCH_H