CallConvention.hpp

Go to the documentation of this file.

//          Copyright Dominic (DNKpp) Koepke 2024 - 2025.
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          https://www.boost.org/LICENSE_1_0.txt)
 
#ifndef MIMICPP_CALL_CONVENTION_HPP
#define MIMICPP_CALL_CONVENTION_HPP
 
#include "mimic++/Fwd.hpp"
#include "mimic++/TypeTraits.hpp"
#include "mimic++/config/Config.hpp"
#include "mimic++/reporting/TargetReport.hpp"
#include "mimic++/utilities/SourceLocation.hpp"
 
#ifndef MIMICPP_DETAIL_IS_MODULE
    #include <concepts>
    #include <tuple>
    #include <utility>
#endif
 
namespace mimicpp
{

}

#define MIMICPP_DETAIL_DEFINE_REMOVE_CALL_CONVENTION(call_convention, specs) \
    template <typename Return, typename... Params>                           \
    struct remove_call_convention<Return call_convention(Params...) specs>   \
    {                                                                        \
        using type = Return(Params...) specs;                                \
    }

#define MIMICPP_DETAIL_DEFINE_ADD_CALL_CONVENTION(call_convention, specs) \
    template <typename Return, typename... Params>                        \
    struct add_call_convention<Return(Params...) specs>                   \
    {                                                                     \
        using type = Return call_convention(Params...) specs;             \
    }

#define MIMICPP_DETAIL_DEFINE_CALL_CONVENTION_CALL_INTERFACE(call_convention, specs)   \
    template <typename Derived, typename Return, typename... Params>                   \
    class CallInterface<                                                               \
        Derived,                                                                       \
        Return call_convention(Params...) specs>                                       \
    {                                                                                  \
    public:                                                                            \
        constexpr Return call_convention operator()(                                   \
            Params... params,                                                          \
            ::mimicpp::util::SourceLocation from = {}) specs                           \
        {                                                                              \
            return static_cast<Derived const&>(*this)                                  \
                .handle_call(                                                          \
                    ::mimicpp::reporting::TypeReport::make<Return(Params...) specs>(), \
                    ::std::tuple{::std::ref(params)...},                               \
                    ::std::move(from));                                                \
        }                                                                              \
    }

#define MIMICPP_DETAIL_DEFINE_CALL_CONVENTION_SPECIALIZATIONS(call_convention, specs) \
    MIMICPP_DETAIL_DEFINE_REMOVE_CALL_CONVENTION(call_convention, specs);             \
    MIMICPP_DETAIL_DEFINE_ADD_CALL_CONVENTION(call_convention, specs);                \
    MIMICPP_DETAIL_DEFINE_CALL_CONVENTION_CALL_INTERFACE(call_convention, specs)

#define MIMICPP_REGISTER_CALL_CONVENTION(call_convention, namespace_name)                              \
    namespace namespace_name                                                                           \
    {                                                                                                  \
        struct tag                                                                                     \
        {                                                                                              \
        };                                                                                             \
                                                                                                       \
        constexpr bool is_default_call_convention = ::std::same_as<void(), void call_convention()>;    \
                                                                                                       \
        template <typename Signature>                                                                  \
        struct remove_call_convention;                                                                 \
                                                                                                       \
        template <typename Signature>                                                                  \
        using remove_call_convention_t = typename remove_call_convention<Signature>::type;             \
                                                                                                       \
        template <typename Signature>                                                                  \
        concept has_call_convention = !::std::same_as<Signature, remove_call_convention_t<Signature>>; \
                                                                                                       \
        template <typename Signature>                                                                  \
        struct add_call_convention;                                                                    \
                                                                                                       \
        template <typename Signature>                                                                  \
        using add_call_convention_t = typename add_call_convention<Signature>::type;                   \
                                                                                                       \
        template <has_call_convention Signature>                                                       \
        struct add_call_convention<Signature>                                                          \
        {                                                                                              \
            using type = Signature;                                                                    \
        };                                                                                             \
                                                                                                       \
        template <typename Derived, typename Signature>                                                \
        class CallInterface;                                                                           \
                                                                                                       \
        MIMICPP_DETAIL_DEFINE_CALL_CONVENTION_SPECIALIZATIONS(call_convention, );                      \
        MIMICPP_DETAIL_DEFINE_CALL_CONVENTION_SPECIALIZATIONS(call_convention, noexcept);              \
        MIMICPP_DETAIL_DEFINE_CALL_CONVENTION_SPECIALIZATIONS(call_convention, const);                 \
        MIMICPP_DETAIL_DEFINE_CALL_CONVENTION_SPECIALIZATIONS(call_convention, const noexcept);        \
        MIMICPP_DETAIL_DEFINE_CALL_CONVENTION_SPECIALIZATIONS(call_convention, &);                     \
        MIMICPP_DETAIL_DEFINE_CALL_CONVENTION_SPECIALIZATIONS(call_convention, & noexcept);            \
        MIMICPP_DETAIL_DEFINE_CALL_CONVENTION_SPECIALIZATIONS(call_convention, const&);                \
        MIMICPP_DETAIL_DEFINE_CALL_CONVENTION_SPECIALIZATIONS(call_convention, const& noexcept);       \
        MIMICPP_DETAIL_DEFINE_CALL_CONVENTION_SPECIALIZATIONS(call_convention, &&);                    \
        MIMICPP_DETAIL_DEFINE_CALL_CONVENTION_SPECIALIZATIONS(call_convention, && noexcept);           \
        MIMICPP_DETAIL_DEFINE_CALL_CONVENTION_SPECIALIZATIONS(call_convention, const&&);               \
        MIMICPP_DETAIL_DEFINE_CALL_CONVENTION_SPECIALIZATIONS(call_convention, const&& noexcept);      \
    }                                                                                                  \
    /* Wrapping the specializations in the actual namespace is required for gcc 11*/                   \
    namespace mimicpp                                                                                  \
    {                                                                                                  \
        template <::namespace_name::has_call_convention Signature>                                     \
            requires(!::namespace_name::is_default_call_convention)                                    \
        struct signature_call_convention<Signature>                                                    \
        {                                                                                              \
            using type = ::namespace_name::tag;                                                        \
        };                                                                                             \
                                                                                                       \
        /* In cases, where the call-convention is the default, we still want to get this tag,          \
        because it's not guaranteed, that it will be applied on member functions (e.g. __vectorcall).  \
        Due to this, we must explicitly mark the call-interface operators.*/                           \
        template <::mimicpp::has_default_call_convention Signature>                                    \
            requires ::namespace_name::is_default_call_convention                                      \
        struct signature_call_convention<Signature>                                                    \
        {                                                                                              \
            using type = ::namespace_name::tag;                                                        \
        };                                                                                             \
                                                                                                       \
        template <>                                                                                    \
        struct call_convention_traits<::namespace_name::tag>                                           \
        {                                                                                              \
            using tag_t = ::namespace_name::tag;                                                       \
                                                                                                       \
            template <typename Signature>                                                              \
            using remove_call_convention_t = ::namespace_name::remove_call_convention_t<Signature>;    \
                                                                                                       \
            template <typename Signature>                                                              \
            using add_call_convention_t = ::namespace_name::add_call_convention_t<Signature>;          \
                                                                                                       \
            template <typename Derived, typename Signature>                                            \
            using call_interface_t = ::namespace_name::CallInterface<Derived, Signature>;              \
        };                                                                                             \
    }
 
#endif