raw_segment.hpp

// SPDX-License-Identifier: BSL-1.0
#ifndef CEL_RUNTIME_RAW_SEGMENT_HPP
#define CEL_RUNTIME_RAW_SEGMENT_HPP
#include <array>
#include <cel/runtime/detail/frame.hpp>
#include <cel/runtime/detail/retirement.hpp>
#include <concepts>
#include <functional>
#include <memory>
#include <tuple>
#include <type_traits>
#include <utility>
 
namespace cel::detail {
struct instruction_storage;
struct segment_access;
class raw_segment {
    detail::retirement_ptr<detail::instruction_storage> _storage;
    friend struct detail::segment_access;

    void* allocate_capture(std::size_t size, std::size_t alignment);
    void append(const void* capture,
                void (*execute)(const void*, frame&),
                void (*destroy)(const void*) noexcept,
                void (*retire)(const void*, detail::retirement_queue&) noexcept = nullptr);

    template <class F, class R, class... Args>
    struct operation {
        std::array<value_type, sizeof...(Args)> inputs; 
        std::array<value_type, std::is_void_v<R> ? 0 : 1>
            outputs; 
        F callback;  
        static auto result_types() {
            if constexpr (std::is_void_v<R>)
                return std::array<value_type, 0>{};
            else
                return std::array{detail::concrete_adapter<R>::type()};
        }
        template <class G>
        requires std::constructible_from<F, G&&> explicit operation(G&& input) :
            inputs{detail::concrete_adapter<Args>::type()...}, outputs(result_types()),
            callback(std::forward<G>(input)) {}
        template <std::size_t... I>
        void invoke(frame& scope, std::index_sequence<I...>) const {
            auto arguments =
                scope.template acquire_operands<Args...>(inputs, std::index_sequence<I...>{});
            scope.discard(sizeof...(Args));
            if constexpr (std::is_void_v<R>) {
                std::apply([&](auto&... args) { std::invoke(callback, scope, std::move(args)...); },
                           arguments);
            } else {
                R result = std::apply(
                    [&](auto&... args) -> R {
                        return std::invoke(callback, scope, std::move(args)...);
                    },
                    arguments);
                scope.push_result(outputs[0], result);
            }
        }
        static void execute(const void* capture, frame& scope) {
            static_cast<const operation*>(capture)->invoke(scope,
                                                           std::index_sequence_for<Args...>{});
        }
        static void destroy(const void* capture) noexcept {
            std::destroy_at(static_cast<const operation*>(capture));
        }
    };
 
public:
    raw_segment() noexcept;
    ~raw_segment();
    raw_segment(const raw_segment&) = delete;
    raw_segment& operator=(const raw_segment&) = delete;
    raw_segment(raw_segment&& other) noexcept;
    raw_segment& operator=(raw_segment&& other) noexcept;
    // [knowledge] Retain release-build depth/layout checks even for trusted instruction signatures.
    void execute(frame& scope) const;
    template <class R, class... Args, class F>
    void push_op(F&& callback) {
        using capture_type = std::decay_t<F>;
        static_assert(std::is_nothrow_destructible_v<capture_type>);
        static_assert(std::is_invocable_r_v<R, const capture_type&, frame&, Args...>);
        using stored = operation<capture_type, R, Args...>;
        auto* location = static_cast<stored*>(allocate_capture(sizeof(stored), alignof(stored)));
        auto* capture = std::construct_at(location, std::forward<F>(callback));
        try {
            append(capture, stored::execute, stored::destroy);
        } catch (...) {
            std::destroy_at(capture);
            throw;
        }
    }
    template <class R, class F>
    void push_op0(F&& callback) {
        push_op<R>(std::forward<F>(callback));
    }
    template <class R, class A, class F>
    void push_op1(F&& callback) {
        push_op<R, A>(std::forward<F>(callback));
    }
    template <class R, class A, class B, class F>
    void push_op2(F&& callback) {
        push_op<R, A, B>(std::forward<F>(callback));
    }
    template <class R, class A, class B, class C, class F>
    void push_op3(F&& callback) {
        push_op<R, A, B, C>(std::forward<F>(callback));
    }
};
} // namespace cel::detail
#endif