hook.h

Go to the documentation of this file.

 
#pragma once
 
#include <atomic>
#include <cstring>
#include <format>
#include <tuple>
#include <type_traits>
#include <cstddef>
#include <string>
#include <utility>
 
#include <rex/memory/mapped_ptr.h>
#include <rex/platform.h>
#include <rex/logging/log_category.h>
#include <rex/ppc/context.h>
#include <rex/ppc/recompiled_code.h>
#include <rex/ppc/call.h>
#include <rex/types.h>
#include <rex/assert.h>
#include <rex/ppc/image.h>
#include <rex/utility.h>

#ifdef REXGLUE_ENABLE_PROFILING
#include <tracy/Tracy.hpp>
#define REX_HOOK(subroutine, function)                           \
  extern "C" REX_DETAIL_ENTRY_EXPORT REX_FUNC(subroutine) {      \
    ZoneNamedN(___tracy_hook_zone, #subroutine, TracyIsStarted); \
    rex::ppc::GuestToHostThunk<function>(ctx, base);             \
  }
#else
#define REX_HOOK(subroutine, function)                      \
  extern "C" REX_DETAIL_ENTRY_EXPORT REX_FUNC(subroutine) { \
    rex::ppc::GuestToHostThunk<function>(ctx, base);        \
  }
#endif

#define REX_HOOK_RAW(name) extern "C" REX_DETAIL_ENTRY_EXPORT REX_FUNC(name)

#define REX_STUB(subroutine)                                                         \
  extern "C" REX_DETAIL_ENTRY_EXPORT REX_FUNC(subroutine) {                          \
    static constinit ::std::atomic_flag rex_stub_seen_;                              \
    ::rex::log::detail::WriteStub(::rex::log::cpu, rex_stub_seen_, #subroutine, {}); \
  }

#define REX_STUB_LOG(subroutine, msg)                                                 \
  extern "C" REX_DETAIL_ENTRY_EXPORT REX_FUNC(subroutine) {                           \
    static constinit ::std::atomic_flag rex_stub_seen_;                               \
    ::rex::log::detail::WriteStub(::rex::log::cpu, rex_stub_seen_, #subroutine, msg); \
  }

#define REX_STUB_RETURN(subroutine, value)                                           \
  extern "C" REX_DETAIL_ENTRY_EXPORT REX_FUNC(subroutine) {                          \
    static constinit ::std::atomic_flag rex_stub_seen_;                              \
    const auto rex_stub_value_ = (value);                                            \
    ::rex::log::detail::WriteStub(                                                   \
        ::rex::log::cpu, rex_stub_seen_, #subroutine,                                \
        ::std::format("returning {:#x}", static_cast<::rex::u32>(rex_stub_value_))); \
    ctx.r3.u64 = rex_stub_value_;                                                    \
  }

#define REX_EXPORT(name, function) REX_HOOK(name, function)

#define REX_EXPORT_STUB(name) REX_STUB(name)

#define REX_EXPORT_STUB_RETURN(name, value) REX_STUB_RETURN(name, value)

// NOLINTBEGIN(bugprone-macro-parentheses): callable is a declared name
#define REX_IMPORT(symbol, callable, sig)                          \
  REX_EXTERN(symbol);                                              \
  [[maybe_unused]] static rex::ppc::ImportFunction<sig> callable { \
    symbol                                                         \
  }
// NOLINTEND(bugprone-macro-parentheses)
 
namespace rex::ppc {
 
namespace detail {

struct DetourFrame {
  PPCContext* ctx;
  u8* base;
  u32 entry_r1;
  u64 entry_lr;
  bool ran_original;     
  DetourFrame* previous; 
};

REX_PPC_API DetourFrame*& GetInnermostDetourFrame();

REX_PPC_API std::string CheckDetourLocalWrites(const char* name, const PPCCodegenFlags& flags,
                                               const PPCContext& at_entry,
                                               const PPCContext& at_exit, std::atomic_flag& warned);

REX_PPC_API void CheckBoundDetourLocalWrites(const char* name, const PPCContext& at_entry,
                                             const PPCContext& at_exit, std::atomic_flag& warned);

REX_PPC_API bool CheckDetourArguments(const char* name, const PPCCallUsage& usage, u8 declared_gpr,
                                      u16 declared_fpr);

REX_PPC_API void CheckBoundDetourArguments(const char* name, PPCFunc* host, u8 declared_gpr,
                                           u16 declared_fpr);

struct DeclaredArguments {
  u8 gpr_mask;  
  u16 fpr_mask; 
};

template <typename Guest>
constexpr DeclaredArguments GetDeclaredArguments() {
  DeclaredArguments declared{};
  for (const ArgPlace& place : PlaceSignatureArgs(static_cast<Guest*>(nullptr))) {
    for (u32 slot = place.slot;
         slot < place.slot + place.slots && slot < ArgTranslator::kIntegerRegisters; ++slot) {
      declared.gpr_mask = static_cast<u8>(declared.gpr_mask | (1u << slot));
    }
    if (place.fpr >= 0) {
      declared.fpr_mask = static_cast<u16>(declared.fpr_mask | (1u << place.fpr));
    }
  }
  return declared;
}

template <typename F>
struct DetourBody;

template <typename R, typename... A>
struct DetourBody<R (*)(A...)> {
  static constexpr bool kContext = false;
  using Result = R;
  using Guest = R(A...);         
  using Args = std::tuple<A...>; 
};

template <typename R, typename... A>
struct DetourBody<R (*)(PPCContext&, A...)> {
  static constexpr bool kContext = true;
  using Result = R;
  using Guest = R(A...);         
  using Args = std::tuple<A...>; 
};

template <typename R, typename... Args>
R CallOriginal(DetourFrame& frame, PPCFunc& fn, Args... args) {
  static_assert(!HiddenReturnType<R>, "A detour cannot return a structure by value");
  PPCContext& ctx = *frame.ctx;
  u8* base = frame.base;
  frame.ran_original = true;
  auto arguments = std::make_tuple(args...);
  const u32 caller_r1 = ctx.r1.u32;
  const u64 caller_lr = ctx.lr;
  const bool opened = caller_r1 != frame.entry_r1;
  if (opened) {
    OpenCallFrame(ctx, base, (GetStackArgumentBytes<Args...>() + 15) & ~15u);
  }
  TranslateArgsToGuest(ctx, base, arguments);
  fn(ctx, base);
  if (opened) {
    ctx.r1.u32 = caller_r1;
    ctx.lr = caller_lr;
  }
  return LoadGuestResult<R>(base, ctx.r3, ctx.f1, ctx.v1, 0);
}

template <typename Guest, typename Args, size_t... I>
void ReadDetourArgs(PPCContext& ctx, u8* base, Args& args, std::index_sequence<I...>) noexcept {
  constexpr auto kPlaces = PlaceSignatureArgs(static_cast<Guest*>(nullptr));
  ((std::get<I>(args) =
        ArgTranslator::GetValue<std::tuple_element_t<I, Args>>(ctx, base, kPlaces[I])),
   ...);
}

class DetourScope : public rex::NonCopyable {
 public:
  DetourScope(PPCContext& ctx, u8* base, bool chained)
      : frame_{&ctx,   base,  ctx.r1.u32,
               ctx.lr, false, chained ? GetInnermostDetourFrame() : nullptr},
        context_previous_(ctx.detour_frame),
        chained_(chained) {
    if (chained_) {
      GetInnermostDetourFrame() = &frame_;
    }
    ctx.detour_frame = &frame_;
  }

  ~DetourScope() {
    frame_.ctx->r1.u32 = frame_.entry_r1;
    frame_.ctx->lr = frame_.entry_lr;
    frame_.ctx->detour_frame = context_previous_;
    if (chained_) {
      GetInnermostDetourFrame() = frame_.previous;
    }
  }
 
  const DetourFrame& GetFrame() const { return frame_; }
 
 private:
  DetourFrame frame_;
  DetourFrame* context_previous_;
  bool chained_;
};
 
}  // namespace detail

template <typename Sig>
struct DetourOriginal;

template <typename R, typename... Args>
struct DetourOriginal<R(Args...)> {
  PPCFunc& fn;
 
  constexpr explicit DetourOriginal(PPCFunc& original) noexcept : fn(original) {}

  R operator()(Args... args) const {
    detail::DetourFrame* frame = detail::GetInnermostDetourFrame();
    REX_ASSERT(frame != nullptr, "A detour original was called outside a detour body");
    return detail::CallOriginal<R>(*frame, fn, args...);
  }
};

template <typename R, typename... Args>
struct DetourOriginal<R(PPCContext&, Args...)> {
  PPCFunc& fn;
 
  constexpr explicit DetourOriginal(PPCFunc& original) noexcept : fn(original) {}

  R operator()(PPCContext& ctx, Args... args) const {
    detail::DetourFrame* frame = ctx.detour_frame;
    REX_ASSERT(frame != nullptr, "A detour original was called outside a detour body");
    return detail::CallOriginal<R>(*frame, this->fn, args...);
  }
};

template <auto Body>
__attribute__((noinline)) void RunDetour(PPCContext& ctx, u8* base, const char* name,
                                         [[maybe_unused]] PPCFunc* host) {
  using Traits = detail::DetourBody<decltype(Body)>;
  using R = Traits::Result;
  static_assert(!HiddenReturnType<R>, "A detour cannot return a structure by value");
 
  detail::CheckHookContext(ctx, name);
  if (ctx.stop_requested && ctx.stop_requested->load(std::memory_order_acquire)) {
    throw rex::ThreadStop{};
  }
#if !REX_PLATFORM_WIN32
  const rex::platform::HostCallDepth host_call_depth;
#endif
  typename Traits::Args args;
  detail::ReadDetourArgs<typename Traits::Guest>(
      ctx, base, args, std::make_index_sequence<std::tuple_size_v<typename Traits::Args>>());
 
#ifndef NDEBUG
  static constinit std::atomic_flag warned;
  static constinit std::atomic_flag arguments_checked;
  const PPCContext at_entry = ctx;
  if (!arguments_checked.test_and_set()) {
    constexpr detail::DeclaredArguments kDeclared =
        detail::GetDeclaredArguments<typename Traits::Guest>();
    detail::CheckBoundDetourArguments(name, host, kDeclared.gpr_mask, kDeclared.fpr_mask);
  }
#endif
  detail::DetourScope scope(ctx, base, !Traits::kContext);
 
  auto invoke = [&]() -> R {
    if constexpr (Traits::kContext) {
      return std::apply([&](auto&... values) -> R { return Body(ctx, values...); }, args);
    } else {
      return std::apply(Body, args);
    }
  };
  auto check_exit = [&] {
#ifndef NDEBUG
    const detail::DetourFrame& frame = scope.GetFrame();
    if (!frame.ran_original) {
      REXCPU_ERROR("REX_DETOUR {} returned without running its original", name);
    }
    REX_ASSERT(frame.ran_original, "REX_DETOUR returned without running its original");
    if (ctx.r1.u32 != frame.entry_r1) {
      REXCPU_ERROR("REX_DETOUR {} left a StackFrame open, r1 is {:#x} and was {:#x}", name,
                   ctx.r1.u32, frame.entry_r1);
    }
    REX_ASSERT(ctx.r1.u32 == frame.entry_r1, "REX_DETOUR left a StackFrame open");
    if (ctx.r2.u64 != at_entry.r2.u64) {
      REXCPU_ERROR("REX_DETOUR {} changed r2", name);
    }
    REX_ASSERT(ctx.r2.u64 == at_entry.r2.u64, "REX_DETOUR changed r2");
    if (ctx.r13.u64 != at_entry.r13.u64) {
      REXCPU_ERROR("REX_DETOUR {} changed r13", name);
    }
    REX_ASSERT(ctx.r13.u64 == at_entry.r13.u64, "REX_DETOUR changed r13");
    detail::CheckBoundDetourLocalWrites(name, at_entry, ctx, warned);
#else
    (void)name;
#endif
  };
  if constexpr (std::is_void_v<R>) {
    invoke();
    asm volatile("" ::: "memory");
    check_exit();
  } else {
    auto result = invoke();
    asm volatile("" ::: "memory");
    check_exit();
    StoreHostResult(ctx, base, 0, result);
  }
  if (ctx.stop_requested && ctx.stop_requested->load(std::memory_order_acquire)) {
    throw rex::ThreadStop{};
  }
}
 
}  // namespace rex::ppc

#ifdef REXGLUE_ENABLE_PROFILING
#define REX_DETAIL_DETOUR_ZONE(name) ZoneNamedN(___tracy_hook_zone, #name, TracyIsStarted);
#else
#define REX_DETAIL_DETOUR_ZONE(name)
#endif

// NOLINTBEGIN(bugprone-macro-parentheses): Ret and params declare a function
#define REX_DETOUR(name, Ret, params)                                                 \
  REX_EXTERN(__imp__##name);                                                          \
  struct name##_rex_detour {                                                          \
    static inline const rex::ppc::DetourOriginal<Ret params> original{__imp__##name}; \
    static Ret Body params;                                                           \
  };                                                                                  \
  REX_HOOK_RAW(name) {                                                                \
    REX_DETAIL_DETOUR_ZONE(name)                                                      \
    rex::ppc::RunDetour<&name##_rex_detour::Body>(ctx, base, #name, name);            \
  }                                                                                   \
  Ret name##_rex_detour::Body params
// NOLINTEND(bugprone-macro-parentheses)