[Clang] Export CanPassInRegisters as a type trait

[royjacobson]

Summary

While working on D140664, I thought it would be nice to be able to write tests
for parameter passing ABI. Currently we test this by dumping the AST and
matching the results which makes it hard to write new tests.
Adding this builtin will allow writing better ABI tests which
can help improve our coverage in this area.

While less useful, maybe some users would also find it useful for asserting
against pessimisations for their classes.

[erichkeane]

clang/lib/Sema/SemaExprCXX.cpp

5380

Is there good reason to return true for all non-record types? Should we instead be limiting the types that can make it this far?

[shafik]

clang/lib/Sema/SemaExprCXX.cpp

5380

Looking how it is used internally, I think it makes sense to restrict this to records.

[royjacobson]

Reject non class types, update doc.

[royjacobson]

clang/lib/Sema/SemaExprCXX.cpp

5380

My initial thinking was 'well references/builtins ARE passed by registers'. But I thought about this a bit and I agree with you, it's probably better to restrict this.

[royjacobson]

fix the test after diag change

[philnik]

Is this essentially "is_trivial_for_the_purposes_of_abi"?

[royjacobson]

In D141775#4255923, @philnik wrote:

Is this essentially "is_trivial_for_the_purposes_of_abi"?

I'd say so. Are you asking for a potential libc++ use case?

[philnik]

In D141775#4256381, @royjacobson wrote:

In D141775#4255923, @philnik wrote:

Is this essentially "is_trivial_for_the_purposes_of_abi"?

I'd say so. Are you asking for a potential libc++ use case?

Kinda. I first thought it would say whether the type is actually passed in registers. That would have been very useful for things like __is_cheap_to_copy and move_only_function. Unfortunately, trivial for the purposes of ABI isn't enough to know in these cases.

clang/docs/LanguageExtensions.rst

 
 * ``__array_rank(type)`` (Embarcadero):
   Returns the number of levels of array in the type ``type``:
   ``0`` if ``type`` is not an array type, and
   ``__array_rank(element) + 1`` if ``type`` is an array of ``element``.
 * ``__array_extent(type, dim)`` (Embarcadero):
   The ``dim``'th array bound in the type ``type``, or ``0`` if
   ``dim >= __array_rank(type)``.
+* ``__can_pass_in_regs`` (C++)
+  Returns whether a class can be passed in registers under the current
+  ABI. This type can only be applied to unqualified class types.
+  This is not a portable type trait.
 * ``__has_nothrow_assign`` (GNU, Microsoft, Embarcadero):
   Deprecated, use ``__is_nothrow_assignable`` instead.
 * ``__has_nothrow_move_assign`` (GNU, Microsoft):
   Deprecated, use ``__is_nothrow_assignable`` instead.
 * ``__has_nothrow_copy`` (GNU, Microsoft):
   Deprecated, use ``__is_nothrow_constructible`` instead.
 * ``__has_nothrow_constructor`` (GNU, Microsoft):
   Deprecated, use ``__is_nothrow_constructible`` instead.

clang/include/clang/Basic/DiagnosticSemaKinds.td

def warn_unsafe_buffer_operation : Warning<
   "unsafe buffer access|function introduces unsafe buffer manipulation}0">,
   InGroup<UnsafeBufferUsage>, DefaultIgnore;
 def note_unsafe_buffer_operation : Note<
   "used%select{| in pointer arithmetic| in buffer access}0 here">;
 def note_unsafe_buffer_variable_fixit : Note<
   "change type of '%0' to '%select{std::span|std::array|std::span::iterator}1' to preserve bounds information">;
 def err_loongarch_builtin_requires_la32 : Error<
   "this builtin requires target: loongarch32">;
+
+def err_builtin_pass_in_regs_non_class : Error<
+  "argument %0 is not an unqualified class type">;
+
 } // end of sema component.

clang/include/clang/Basic/TokenKinds.def

 
 // Clang-only C++ Type Traits
 TYPE_TRAIT_1(__is_trivially_relocatable, IsTriviallyRelocatable, KEYCXX)
 TYPE_TRAIT_1(__is_bounded_array, IsBoundedArray, KEYCXX)
 TYPE_TRAIT_1(__is_unbounded_array, IsUnboundedArray, KEYCXX)
 TYPE_TRAIT_1(__is_nullptr, IsNullPointer, KEYCXX)
 TYPE_TRAIT_1(__is_scoped_enum, IsScopedEnum, KEYCXX)
 TYPE_TRAIT_1(__is_referenceable, IsReferenceable, KEYCXX)
+TYPE_TRAIT_1(__can_pass_in_regs, CanPassInRegs, KEYCXX)
 TYPE_TRAIT_2(__reference_binds_to_temporary, ReferenceBindsToTemporary, KEYCXX)
 
 // Embarcadero Expression Traits
 EXPRESSION_TRAIT(__is_lvalue_expr, IsLValueExpr, KEYCXX)
 EXPRESSION_TRAIT(__is_rvalue_expr, IsRValueExpr, KEYCXX)
 
 // Embarcadero Unary Type Traits
 TYPE_TRAIT_1(__is_arithmetic, IsArithmetic, KEYCXX)

clang/lib/Sema/SemaExprCXX.cpp

static bool CheckUnaryTypeTraitTypeCompleteness(Sema &S, TypeTrait UTT,
   //   remove_all_extents_t<T> shall be a complete type or cv void.
   case UTT_IsTrivial:
   case UTT_IsTriviallyCopyable:
   case UTT_IsStandardLayout:
   case UTT_IsPOD:
   case UTT_IsLiteral:
   // By analogy, is_trivially_relocatable imposes the same constraints.
   case UTT_IsTriviallyRelocatable:
+  case UTT_CanPassInRegs:
   // Per the GCC type traits documentation, T shall be a complete type, cv void,
   // or an array of unknown bound. But GCC actually imposes the same constraints
   // as above.
   case UTT_HasNothrowAssign:
   case UTT_HasNothrowMoveAssign:
   case UTT_HasNothrowConstructor:
   case UTT_HasNothrowCopy:
   case UTT_HasTrivialAssign:
case UTT_IsCompleteType:
     //   function call.
     return !T->isIncompleteType();
   case UTT_HasUniqueObjectRepresentations:
     return C.hasUniqueObjectRepresentations(T);
   case UTT_IsTriviallyRelocatable:
     return T.isTriviallyRelocatableType(C);
   case UTT_IsReferenceable:
     return T.isReferenceable();
+  case UTT_CanPassInRegs:
+    if (CXXRecordDecl *RD = T->getAsCXXRecordDecl(); RD && !T.hasQualifiers())
+      return RD->canPassInRegisters();
+    Self.Diag(KeyLoc, diag::err_builtin_pass_in_regs_non_class) << T;
+    return false;
   }
 }
 
 static bool EvaluateBinaryTypeTrait(Sema &Self, TypeTrait BTT, QualType LhsT,
                                     QualType RhsT, SourceLocation KeyLoc);
 
 static bool evaluateTypeTrait(Sema &S, TypeTrait Kind, SourceLocation KWLoc,
                               ArrayRef<TypeSourceInfo *> Args,

clang/test/SemaCXX/type-traits.cpp

 struct [[clang::trivial_abi]] TrivialAbiNontrivialMoveCtor {
   TrivialAbiNontrivialMoveCtor(TrivialAbiNontrivialMoveCtor&&) {}
 };
 static_assert(__is_trivially_relocatable(TrivialAbiNontrivialMoveCtor), "");
 static_assert(__is_trivially_relocatable(TrivialAbiNontrivialMoveCtor[]), "");
 
 } // namespace is_trivially_relocatable
 
+namespace can_pass_in_regs {
+
+struct A { };
+
+struct B {
+  ~B();
+};
+
+struct C; // expected-note {{forward declaration}}
+
+union D {
+  int x;
+};
+
+static_assert(__can_pass_in_regs(A), "");
+static_assert(__can_pass_in_regs(A), "");
+static_assert(!__can_pass_in_regs(B), "");
+static_assert(__can_pass_in_regs(D), "");
+
+void test_errors() {
+  (void)__can_pass_in_regs(const A); // expected-error {{not an unqualified class type}}
+  (void)__can_pass_in_regs(A&); // expected-error {{not an unqualified class type}}
+  (void)__can_pass_in_regs(A&&); // expected-error {{not an unqualified class type}}
+  (void)__can_pass_in_regs(const A&); // expected-error {{not an unqualified class type}}
+  (void)__can_pass_in_regs(C); // expected-error {{incomplete type}}
+  (void)__can_pass_in_regs(int); // expected-error {{not an unqualified class type}}
+  (void)__can_pass_in_regs(int&); // expected-error {{not an unqualified class type}}
+}
+}
+
 struct S {};
 template <class T> using remove_const_t = __remove_const(T);
 
 void check_remove_const() {
   static_assert(__is_same(remove_const_t<void>, void), "");
   static_assert(__is_same(remove_const_t<const void>, void), "");
   static_assert(__is_same(remove_const_t<int>, int), "");
   static_assert(__is_same(remove_const_t<const int>, int), "");