Clang++: Template specialization doesn't work with function attributes

[gaaclarke]

Minimal reproduction

#include <type_traits>

#define VKAPI_ATTR __attribute__((pcs("aapcs-vfp")))

VKAPI_ATTR void function1(int a, double b) {
  // ...
}

VKAPI_ATTR void function2(int a, double b) {
  // ...
}

template <typename T, typename U>
struct CheckSameSignature : std::false_type {};

template <typename Ret, typename... Args>
struct CheckSameSignature<Ret(Args...), Ret(Args...)> : std::true_type {};

static_assert(
    CheckSameSignature<decltype(function1), decltype(function2)>::value,
    "Functions have different signatures");

int main() { return 0; }

godbolt: https://godbolt.org/z/v5rafYo55

clang version

armv7-a clang 11.0.1

observed behavior

The static_assert fails saying the signatures are not the same.

expected behavior

I expect these signatures to be considered the same, just as they are if you remove the attributes.

error output

error: static_assert failed due to requirement 'CheckSameSignature<void (int, double) __attribute__((pcs("aapcs-vfp"))), void (int, double) __attribute__((pcs("aapcs-vfp")))>::value' "Functions have different signatures"armv7-a clang 11.0.1 #1

description

I'm not 100% sure this isn't some oddity with the c++ spec and not a failure to specialize correctly.

[llvmbot]

@llvm/issue-subscribers-clang-frontend

[gaaclarke]

Looking at this a bit more I suspect maybe this is the correct behavior. The function signature with the attribute doesn't match Ret(Args...) at all.

[ahatanak]

It looks like gcc doesn't reject the code.

I’ve seen a similar example in which an attribute on a declaration prevents a partial specialization from being chosen:

@class NSString;
NSString *Foo(void) __attribute__((ns_returns_retained));

template <typename FunctionType>
struct Decomposer;

template <typename ReturnType, typename ... ArgumentTypes, bool DoesNotThrow>
struct Decomposer<ReturnType(*)(ArgumentTypes...) noexcept(DoesNotThrow)> {
};

Decomposer<decltype(&Foo)> d;

$ clang++ -fobjc-arc test.mm -c -std=c++20
test.mm:11:28: error: implicit instantiation of undefined template 'Decomposer<NSString ()() attribute((ns_returns_retained))>'
11 | Decomposer<decltype(&Foo)> d;
| ^
test.mm:5:8: note: template is declared here
5 | struct Decomposer;
| ^
1 error generated.

Is this the expected behavior?
@AaronBallman @zygoloid @rjmccall @mizvekov @cor3ntin

[mizvekov]

That looks expected to me.

If you test:

@class NSString;

NSString *Foo(void) __attribute__((ns_returns_retained));
NSString *Bar(void);

using T = decltype(Foo);
using T = decltype(Bar);

Compiled with -fobjc-arc, then that shows Foo and Bar are different function types.
The partial specialization in your example does not select functions with the ns_returns_retained type attribute, because its not part of the type in the partial specialization argument.

If you write it out as:

struct Decomposer<ReturnType(* __attribute__((ns_returns_retained)) )(ArgumentTypes...) noexcept(DoesNotThrow)>

Then you can see your example works.

[mizvekov]

The main example is the same problem, the aapcs-vfp attribute makes the function have a different type.
Modified example so that it works: https://godbolt.org/z/rhsGMhMTo

So, this is not a bug.