callback.hpp

#pragma once
 
#include <asmjit/asmjit.h>
#include <plugify/mem_addr.hpp>
#include <plugify/method.hpp>
#include <string_view>
#include <utility>
#include <memory>
 
namespace plugify {
    class JitCallback {
    public:
        explicit JitCallback(std::weak_ptr<asmjit::JitRuntime> rt);
 
        JitCallback(const JitCallback& other) = delete;
 
        JitCallback(JitCallback&& other) noexcept;
 
        ~JitCallback();
 
        struct Parameters {
            template<typename T>
            void SetArgument(size_t idx, T val) const noexcept {
                *(T*) GetArgumentPtr(idx) = val;
            }
 
            template<typename T>
            void SetArgumentAt(size_t idx, T val, size_t i = 0) const noexcept {
                (*(T**) GetArgumentPtr(idx))[i] = val;
            }
 
            template<typename T>
            T GetArgument(size_t idx) const noexcept {
                return *(T*) GetArgumentPtr(idx);
            }
 
            int8_t* GetArgumentPtr(size_t idx) const noexcept {
                return ((int8_t*) &arguments) + sizeof(uint64_t) * idx;
            }
 
        private:
            volatile uint64_t arguments; 
        };
 
        struct Return {
            template<typename T, typename...Args>
            void ConstructAt(Args&&... args) const noexcept {
                std::construct_at((T*) GetReturnPtr(), std::forward<Args>(args)...);
            }
 
            template<typename T>
            void SetReturn(T val) const noexcept {
                *(T*) GetReturnPtr() = val;
            }
 
            template<typename T>
            T GetReturn() const noexcept {
                return *(T*) GetReturnPtr();
            }
 
            int8_t* GetReturnPtr() const noexcept {
                return (int8_t*) &ret;
            }
 
        private:
            volatile uint64_t ret; 
        };
 
        using CallbackHandler = void(*)(MethodHandle method, MemAddr data, const Parameters* params, size_t count, const Return* ret);
        using HiddenParam = bool(*)(ValueType);
 
        MemAddr GetJitFunc(const asmjit::FuncSignature& sig, MethodHandle method, CallbackHandler callback, MemAddr data, bool hidden);
 
        MemAddr GetJitFunc(MethodHandle method, CallbackHandler callback, MemAddr data = nullptr, HiddenParam hidden = &ValueUtils::IsHiddenParam);
 
        MemAddr GetFunction() const noexcept { return _function; }
 
        MemAddr GetUserData() const noexcept { return _userData; }
 
        std::string_view GetError() noexcept { return !_function && _errorCode ? _errorCode : ""; }
 
        JitCallback& operator=(const JitCallback& other) = delete;
 
        JitCallback& operator=(JitCallback&& other) noexcept;
 
    private:
        std::weak_ptr<asmjit::JitRuntime> _rt;
        MemAddr _function;
        union {
            MemAddr _userData;
            const char* _errorCode{};
        };
    };
} // namespace plugify