function_dispatcher.h

Go to the documentation of this file.

 
#pragma once
 
#include <atomic>
#include <mutex>
#include <optional>
#include <span>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
 
#include <rex/platform.h>
#include <rex/types.h>
#include <rex/memory.h>
#include <rex/memory/virtual_memory.h>
#include <rex/platform/lock_order.h>
#include <rex/ppc/recompiled_code.h>
#include <rex/kernel/thread_state.h>
#include <rex/utility.h>
 
namespace rex::kernel {
 
class ThreadState;
 
class IFunctionRegistrar : public NonCopyable {
 public:
  virtual ~IFunctionRegistrar() = default;

  virtual bool SetFunction(u32 guest_address, ::PPCFunc* func) = 0;
};

class REX_KERNEL_API FunctionDispatcher : public IFunctionRegistrar {
 public:
  using RegisterFn = void (*)(IFunctionRegistrar*);

  explicit FunctionDispatcher(kernel::GuestAddressSpace* memory);
  virtual ~FunctionDispatcher();
 
  kernel::GuestAddressSpace* GetAddressSpace() const { return memory_; }

  u64 Execute(ThreadState* thread_state, u32 address, u64 args[], size_t arg_count);
  u64 ExecuteInterrupt(ThreadState* thread_state, u32 address, u64 args[], size_t arg_count);

  void SetGraphicsInterrupt(u32 callback, u32 user_data);

  void RaiseGraphicsInterrupt(u32 source, u32 cpu);

  u64 ExecuteTrap(ThreadState* thread_state, u32 address, u64 args[], size_t arg_count);

  static constexpr u32 kThunkReserveSize = 0x10000;

  bool InitializeFunctionTable(u32 code_base, u32 code_size, u32 image_base, u32 image_size,
                               bool is_entrypoint = false);
  bool SetFunction(u32 guest_address, ::PPCFunc* func) override;
  ::PPCFunc* GetFunction(u32 guest_address);
  u32 AllocateThunk(::PPCFunc* func, u32 caller_address);

  u32 FindCallerModuleBase(u32 guest_address);

  void RegisterModule(const std::string& module_id, u32 code_base, RegisterFn register_func,
                      std::span<const u8> recompiled_code = {});

  void AddRecompiledCode(std::span<const u8> code);

  std::optional<std::pair<u32, u32>> UnregisterModule(const std::string& module_id);
 
 private:
  bool Run(ThreadState* thread_state, u32 address, std::span<const u64> args);
  u64 RunInterrupt(ThreadState* thread_state, u32 address, u64 args[], size_t arg_count);
 
  struct ModuleTable {
    u32 code_base;
    u32 code_size;
    u32 image_base;
    u32 image_size;
    u32 next_thunk_address;
    u32 thunk_limit;
  };
 
  ModuleTable* FindModuleByAddress(u32 guest_address);
 
  kernel::GuestAddressSpace* memory_ = nullptr;
 
  std::unordered_map<u32, ::PPCFunc*> function_table_;
 
  std::vector<ModuleTable> module_tables_;

  u32 entrypoint_code_base_ = 0;
 
  bool registering_ = false;
  std::vector<u32> registered_addresses_;
 
  struct ModuleRegistration {
    u32 code_base;
    std::vector<u32> addresses;
  };
 
  std::unordered_map<std::string, ModuleRegistration> module_addresses_;

  mutable std::recursive_mutex dispatch_mutex_;
  std::atomic<u64> graphics_interrupt_{0};
 
  rex::platform::RankedMutex interrupt_mutex_{rex::platform::lock_rank::kInterruptState};
 
  mutable std::mutex recompiled_code_mutex_;
  std::vector<std::pair<std::string, std::span<const u8>>> recompiled_code_;
};
 
}  // namespace rex::kernel