call.hpp

#pragma once
 
#include <asmjit/asmjit.h>
#include <plugify/mem_addr.hpp>
#include <plugify/method.hpp>
#include <string_view>
#include <utility>
#include <memory>
#include <vector>
 
namespace plugify {
    class JitCall {
    public:
        explicit JitCall(std::weak_ptr<asmjit::JitRuntime> rt);
 
        JitCall(const JitCall& other) = delete;
 
        JitCall(JitCall&& other) noexcept;
 
        ~JitCall();
 
        struct Parameters {
            typedef const uint64_t* Data;
            
            explicit Parameters(size_t count) {
                arguments.reserve(count);
            }
 
            template<typename T>
            void AddArgument(T val) {
                uint64_t& arg = arguments.emplace_back(0);
                *(T*) &arg = val;
            }
 
            Data GetDataPtr() const noexcept {
                return arguments.data();
            }
            
        private:
            std::vector<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[0];
            }
 
        private:
            volatile uint64_t ret[2]{}; 
        };
        
        enum class WaitType {
            None,
            Breakpoint,
            Wait_Keypress
        };
    
        using CallingFunc = void(*)(Parameters::Data params, const Return*); // Return can be null
        using HiddenParam = bool(*)(ValueType);
 
        MemAddr GetJitFunc(const asmjit::FuncSignature& sig, MemAddr target, WaitType waitType, bool hidden);
 
        MemAddr GetJitFunc(MethodHandle method, MemAddr target, WaitType waitType = WaitType::None, HiddenParam hidden = &ValueUtils::IsHiddenParam);
 
        MemAddr GetFunction() const noexcept { return _function; }
 
        MemAddr GetTargetFunc() const noexcept { return _targetFunc; }
 
        std::string_view GetError() noexcept { return !_function && _errorCode ? _errorCode : ""; }
 
        JitCall& operator=(const JitCall& other) = delete;
 
        JitCall& operator=(JitCall&& other) noexcept;
 
    private:
        std::weak_ptr<asmjit::JitRuntime> _rt;
        MemAddr _function;
        union {
            MemAddr _targetFunc;
            const char* _errorCode{};
        };
    };
} // namespace plugify