New __ptrauth scalar types are wrongly reported as trivially copy/move constructible

[halbi2]

Follows #137473 and #154394.
https://godbolt.org/z/zhsdnxKPe

using PA = void * __ptrauth(0,1,0);
template <class T> struct H { T t; };

static_assert(!__is_trivially_copyable(PA));
static_assert(__is_trivially_constructible(PA, PA&));  // WRONG
static_assert(__is_trivially_assignable(PA&, PA&));  // WRONG
static_assert(!__is_trivially_copyable(H<PA>));
static_assert(!__is_trivially_constructible(H<PA>, H<PA>&));
static_assert(!__is_trivially_assignable(H<PA>&, H<PA>&));

It cannot be that PA is trivially constructible and assignable by itself alone, but becomes non-trivial only when placed into a class type H. It also cannot be that PA is trivially constructible, assignable, and destructible, yet is not trivially_copyable. The conclusion is that PA must be non-trivial even when it is alone.

@ojhunt will you look please?

[llvmbot]

@llvm/issue-subscribers-clang-frontend

Author: None (halbi2)

Follows #137473 and #154394. https://godbolt.org/z/zhsdnxKPe ``` using PA = void * __ptrauth(0,1,0); template <class T> struct H { T t; };

static_assert(!__is_trivially_copyable(PA));
static_assert(__is_trivially_constructible(PA, PA&)); // WRONG
static_assert(__is_trivially_assignable(PA&, PA&)); // WRONG
static_assert(!__is_trivially_copyable(H<PA>));
static_assert(!__is_trivially_constructible(H<PA>, H<PA>&));
static_assert(!__is_trivially_assignable(H<PA>&, H<PA>&));

It cannot be that `PA` is trivially constructible and assignable by itself alone, but becomes non-trivial only when placed into a class type `H`. It also cannot be that `PA` is trivially constructible, assignable, and destructible, yet is not trivially_copyable. The conclusion is that `PA` must be non-trivial even when it is alone.

@<!-- -->ojhunt will you look please?
</details>

[ojhunt]

assignable is definitely wrong - likely something is early exiting on a pointer, but what are the semantics of trivially constructible for a pointer? is that zero init or something else?

[ojhunt]

Oh sorry, trivially copy constructible is the context - yeah this is definitely something doing a no longer correct early exit on a scalar.

[ojhunt]

Cool, so the code is obviously correct, so time to find where the obviously correct code is not, in fact, correct :D

[ojhunt]

Oh, hmmm, it's related to them being reference types, I was so very confused as the logic for raw pointers is all present.

I wonder if there's some kind of qualifier stripping happening

[ojhunt]

Ok, from comments in the code __is_trivially_assignable(T, U) is equivalent to

declval<T>() = declval<U>()

With the constraint that this cannot perform a non-trivial operation, e.g it is not a synonym for memcopyable, e.g.

static_assert(!__is_trivially_assignable(int, float));
static_assert(__is_trivially_assignable(int&, float&));

Similar logic applies to trivially constructable.

This kind of implies the current trivially_{constructible,assignable} for H<PA> is incorrect as declval<H<PA>&>() = declval<H<PA>>() is a valid assignment with no non-trivial operations being performed.

[ojhunt]

(at least this makes things more understandable :D)