Remove __attribute__((...)) from a function pointer or reference

Question

#include <utility>
#include <iostream>

int main()
{
    using std_type = std::remove_reference<void (__attribute__((stdcall)) &)(int) noexcept>::type;
    using cdecl_type = std::remove_reference<void (__attribute__((cdecl)) &)(int) noexcept>::type;
    using type = std::remove_reference<void (&)(int) noexcept>::type;
    
    std::cout<<typeid(std_type).name()<<"\n";
    std::cout<<typeid(cdecl_type).name()<<"\n";
    std::cout<<typeid(type).name()<<"\n";
}

Output:

U7stdcallDoFviE
U5cdeclDoFviE
U5cdeclDoFviE

If I compare the types with std::is_same<std_type, cdecl_type>::value it returns false.

I need to remove the attribute so that the following code works, without having to have specializations for __stdcall:

template<typename T>
struct remove_class {};

template<typename C, typename R, typename... A>
struct remove_class<R(C::*)(A...)>
{
    using type = R(A...);
};

template <typename C, typename R, typename... A>
struct remove_class<R(C::*)(A...) const>
{
    using type = R(A...);
};

template<typename C, typename R, typename... A>
struct remove_class<R(C::*)(A...) volatile>
{
    using type = R(A...);
};

template<typename C, typename R, typename... A>
struct remove_class<R(C::*)(A...) noexcept>
{
    using type = R(A...);
};

template<typename C, typename R, typename... A>
struct remove_class<R(C::*)(A...) const volatile>
{
    using type = R(A...);
};

template<typename C, typename R, typename... A>
struct remove_class<R(C::*)(A...) const noexcept>
{
    using type = R(A...);
};

template<typename C, typename R, typename... A>
struct remove_class<R(C::*)(A...) volatile noexcept>
{
    using type = R(A...);
};

template<typename C, typename R, typename... A>
struct remove_class<R(C::*)(A...) const volatile noexcept>
{
    using type = R(A...);
};

template<typename T>
struct function_signature
{
    using type = typename remove_class<decltype(&std::remove_reference<T>::type::operator())>::type;
};

template<typename R, typename... A>
struct function_signature<R(A...)>
{
    using type = R(A...);
};

and:

template<typename T>
struct function_arguments_type
{
    using type = typename function_arguments_type<typename function_signature<T>::type>::type;
};

template<typename R, typename... A>
struct function_arguments_type<R(A...)>
{
    using type = typename std::tuple<A...>;
};

So that I can determine what is the return type of a function, and what is the type of its arguments.

Is there a way to remove the __attribute__((....)) from a function's signature or at least make my templates work without having to specialize every single one of them for __stdcall?

Answer 1

You can still create a traits remove_stdcall, something like:

template <typename Func>
struct remove_stdcall
{
    using type = Func;
};

template <typename Ret, typename ... Args>
struct remove_stdcall<Ret __attribute__((stdcall)) (Args...) noexcept>
{
    using type = Ret(Args...) noexcept;
};

template <typename Ret, typename ... Args>
struct remove_stdcall<Ret __attribute__((stdcall))(Args...)>
{
    using type = Ret(Args...);
};

Demo.