[libc][NFC] Add new is_trivially_destructible check to libc's type_traits

[mikhail.ramalho]

Summary

This patch adds new code to check if a given object is trivially
destructible. The ifdefs where necessary to implement it in gcc, as it
doesn't have the __is_trivially_destructible builtin like clang.

In gcc, it's not enough to only call __has_trivial_destructor, see:
https://stackoverflow.com/questions/20181702/which-type-traits-cannot-be-implemented-without-compiler-hooks

This patch only adds the new check, it will be used in D150211.

[michaelrj]

LGTM

[sivachandra]

Apart from the nit, rest LGTM.

libc/src/__support/CPP/type_traits.h

289

Internal types have been listed in nested namespace named details in this file. So, you should follow that convention.

[jhuber6]

This might be preventing me from building on one of my systems.

FAILED: projects/libc/utils/gpu/server/CMakeFiles/llvmlibc_rpc_server.dir/rpc_server.cpp.o
CCACHE_CPP2=yes CCACHE_HASHDIR=yes /usr/bin/ccache /usr/bin/c++ -D_DEBUG -D_GLIBCXX_ASSERTIONS -D_GNU_SOURCE -D_LIBCPP_ENABLE_HARDENED_MODE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS -I/home/jhuber/llvm-project/build/projects/libc/utils/gpu/server -I/home/jhuber/llvm-project/libc/utils/gpu/server -I/home/jhuber/llvm-project/build/include -I/home/jhuber/llvm-project/llvm/include -I/home/jhuber/llvm-project/libc -I/home/jhuber/llvm-project/libc/include -fPIC -fno-semantic-interposition -fvisibility-inlines-hidden -Werror=date-time -fno-lifetime-dse -Wall -Wextra -Wno-unused-parameter -Wwrite-strings -Wcast-qual -Wno-missing-field-initializers -pedantic -Wno-long-long -Wimplicit-fallthrough -Wno-maybe-uninitialized -Wno-nonnull -Wno-class-memaccess -Wno-redundant-move -Wno-pessimizing-move -Wno-noexcept-type -Wdelete-non-virtual-dtor -Wsuggest-override -Wno-comment -Wno-misleading-indentation -fdiagnostics-color -ffunction-sections -fdata-sections -O3 -DNDEBUG -std=c++17 -UNDEBUG -Wno-attributes -MD -MT projects/libc/utils/gpu/server/CMakeFiles/llvmlibc_rpc_server.dir/rpc_server.cpp.o -MF projects/libc/utils/gpu/server/CMakeFiles/llvmlibc_rpc_server.dir/rpc_server.cpp.o.d -o projects/libc/utils/gpu/server/CMakeFiles/llvmlibc_rpc_server.dir/rpc_server.cpp.o -c /home/jhuber/llvm-project/libc/utils/gpu/server/rpc_server.cpp
In file included from /home/jhuber/llvm-project/libc/src/__support/RPC/rpc_util.h:12,
                 from /home/jhuber/llvm-project/libc/src/__support/RPC/rpc.h:21,
                 from /home/jhuber/llvm-project/libc/utils/gpu/server/rpc_server.cpp:11:
/home/jhuber/llvm-project/libc/src/__support/CPP/type_traits.h:223:18: error: missing binary operator before token "("
  223 | #if __has_builtin(__is_lvalue_reference) &&                                    \
      |                  ^
/home/jhuber/llvm-project/libc/src/__support/CPP/type_traits.h:246:18: error: missing binary operator before token "("
  246 | #if __has_builtin(__remove_all_extents)
      |                  ^
/home/jhuber/llvm-project/libc/src/__support/CPP/type_traits.h:263:18: error: missing binary operator before token "("
  263 | #if __has_builtin(__is_function)
      |                  ^
/home/jhuber/llvm-project/libc/src/__support/CPP/type_traits.h:277:18: error: missing binary operator before token "("
  277 | #if __has_builtin(__is_destructible)
      |                  ^
/home/jhuber/llvm-project/libc/src/__support/CPP/type_traits.h:331:18: error: missing binary operator before token "("
  331 | #if __has_builtin(__is_trivially_destructible)
      |                  ^
/home/jhuber/llvm-project/libc/src/__support/CPP/type_traits.h:337:20: error: missing binary operator before token "("
  337 | #elif __has_builtin(__has_trivial_destructor)
      |                    ^
In file included from /home/jhuber/llvm-project/libc/src/__support/RPC/rpc.h:25,
                 from /home/jhuber/llvm-project/libc/utils/gpu/server/rpc_server.cpp:11:
/home/jhuber/llvm-project/libc/src/__support/CPP/optional.h:39:33: error: ‘is_trivially_destructible’ was not declared in this scope; did you mean ‘is_trivially_constructible’?
   39 |   template <typename U, bool = !is_trivially_destructible<U>::value>
      |                                 ^~~~~~~~~~~~~~~~~~~~~~~~~
      |                                 is_trivially_constructible
/home/jhuber/llvm-project/libc/src/__support/CPP/optional.h:39:60: error: expected primary-expression before ‘>’ token
   39 |   template <typename U, bool = !is_trivially_destructible<U>::value>
      |                                                            ^
/home/jhuber/llvm-project/libc/src/__support/CPP/optional.h:39:58: warning: logical not is only applied to the left hand side of comparison [-Wlogical-not-parentheses]
   39 |   template <typename U, bool = !is_trivially_destructible<U>::value>
      |                                                          ^
/home/jhuber/llvm-project/libc/src/__support/CPP/optional.h:39:63: error: ‘value’ in namespace ‘::’ does not name a type
   39 |   template <typename U, bool = !is_trivially_destructible<U>::value>
      |                                                               ^~~~~
/home/jhuber/llvm-project/libc/src/__support/CPP/optional.h:52:4: warning: extra ‘;’ [-Wpedantic]
   52 |   };
      |    ^
      |    -
/home/jhuber/llvm-project/libc/src/__support/CPP/optional.h:54:32: error: ‘OptionalStorage’ is not a class template
   54 |   template <typename U> struct OptionalStorage<U, false> {
      |                                ^~~~~~~~~~~~~~~
[74/4706] Building CXX object utils/TableGen/CMakeFiles/llvm-tblgen.dir/CodeGenDAGPatterns.cpp.o
ninja: build stopped: subcommand failed.

This file is compiled with the system GCC which is version 9.4.

[sivachandra]

In D158033#4599842, @jhuber6 wrote:

This file is compiled with the system GCC which is version 9.4.

The official supported minimum GCC version is 12.2: https://libc.llvm.org/compiler_support.html

[jhuber6]

In D158033#4599844, @sivachandra wrote:

In D158033#4599842, @jhuber6 wrote:

This file is compiled with the system GCC which is version 9.4.

The official supported minimum GCC version is 12.2: https://libc.llvm.org/compiler_support.html

So this differs from the LLVM requirement? That's problematic for this particular file because it's expected to be compiled with the user's configuration since it implements the CPU side server to interface with the RPC server. The GPU portion is only compiled with just-built clang. So it'll end up that the files I'm including there need to at least be able to be compiled. Any way we could make these statically return false in this case? I'm assuming it won't negatively impact anything else considienrg they're already guarded by __has_builtin.

libc/src/__support/CPP/type_traits.h

 //===-- Self contained C++ type traits --------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_SUPPORT_CPP_TYPETRAITS_H
 #define LLVM_LIBC_SRC_SUPPORT_CPP_TYPETRAITS_H
 
 #include "src/__support/macros/attributes.h"
 
+#include <stddef.h> // For size_t.
+
 namespace __llvm_libc {
 namespace cpp {
 
 template <typename T> struct type_identity {
   using type = T;
 };
 
 template <bool B, typename T> struct enable_if;
 template <typename T> struct enable_if<true, T> : type_identity<T> {};
 template <bool B, typename T = void>
 using enable_if_t = typename enable_if<B, T>::type;
 
 template <typename T, T v> struct integral_constant {
   using value_type = T;
   LIBC_INLINE_VAR static constexpr T value = v;
 };
 using true_type = cpp::integral_constant<bool, true>;
 using false_type = cpp::integral_constant<bool, false>;
 
+template <bool V> using bool_constant = integral_constant<bool, V>;
+
 template <class T>
 struct is_trivially_copyable
     : public integral_constant<bool, __is_trivially_copyable(T)> {};
 
 template <class T, class... Args>
 struct is_trivially_constructible
     : integral_constant<bool, __is_trivially_constructible(T, Args...)> {};
 

 // FIXME: This should use LIBC_INLINE_VAR, but clang buggily complains about
 // this when LIBC_INLINE_VAR uses [[clang::internal_linkage]].
 template <typename F, typename T>
 constexpr bool
     is_convertible_v<F, T,
                      details::void_t<decltype(details::convertible_to_helper<T>(
                          declval<F>()))>> = true;
 
+namespace details {
+#if __has_builtin(__is_lvalue_reference) &&                                    \
+    __has_builtin(__is_rvalue_reference) && __has_builtin(__is_reference)
+
+template <typename T>
+struct is_lvalue_reference : bool_constant<__is_lvalue_reference(T)> {};
+template <typename T>
+struct is_rvalue_reference : bool_constant<__is_rvalue_reference(T)> {};
+template <typename T> struct is_reference : bool_constant<__is_reference(T)> {};
+
+#else // __has_builtin(__is_lvalue_reference) && etc...
+
+template <typename T> struct is_lvalue_reference : public false_type {};
+template <typename T> struct is_lvalue_reference<T &> : public true_type {};
+
+template <typename T> struct is_rvalue_reference : public false_type {};
+template <typename T> struct is_rvalue_reference<T &&> : public true_type {};
+
+template <typename T> struct is_reference : public false_type {};
+template <typename T> struct is_reference<T &> : public true_type {};
+template <typename T> struct is_reference<T &&> : public true_type {};
+
+#endif // __has_builtin(__is_lvalue_reference) && etc...
+
+#if __has_builtin(__remove_all_extents)
+template <typename T> using __remove_all_extents_t = __remove_all_extents(T);
+#else
+template <typename T> struct remove_all_extents {
+  typedef T type;
+};
+template <typename T> struct remove_all_extents<T[]> {
+  typedef typename remove_all_extents<T>::type type;
+};
+template <typename T, size_t _Np> struct remove_all_extents<T[_Np]> {
+  typedef typename remove_all_extents<T>::type type;
+};
+
+template <typename T>
+using __remove_all_extents_t = typename remove_all_extents<T>::type;
+#endif // __has_builtin(__remove_all_extents)
+
+#if __has_builtin(__is_function)
+
+template <typename T>
+struct is_function : integral_constant<bool, __is_function(T)> {};
+
+#else
+
+template <typename T>
+struct is_function
+    : public integral_constant<bool, !(is_reference<T>::value ||
+                                       is_const<const T>::value)> {};
+
+#endif // __has_builtin(__is_function)
+
+#if __has_builtin(__is_destructible)
+
+template <typename T>
+struct is_destructible : bool_constant<__is_destructible(T)> {};
+
+#else // __has_builtin(__is_destructible)
+
+//  if it's a reference, return true
+//  if it's a function, return false
+//  if it's   void,     return false
+//  if it's an array of unknown bound, return false
+//  Otherwise, return "declval<T&>().~T()" is well-formed
+//    where T is remove_all_extents<T>::type
+
+template <typename> struct __is_destructible_apply {
+  typedef int type;
+};
+
+template <typename T> struct __is_destructor_wellformed {
+  template <typename T1>
+  static true_type __test(
+      typename __is_destructible_apply<decltype(declval<T1 &>().~T1())>::type);
+
+  template <typename T1> static false_type __test(...);
+
+  static const bool value = decltype(__test<T>(12))::value;
+};
+
+template <typename T, bool> struct __destructible_imp;
+
+template <typename T>
+struct __destructible_imp<T, false>
+    : public integral_constant<
+          bool, __is_destructor_wellformed<__remove_all_extents_t<T>>::value> {
+};
+
+template <typename T> struct __destructible_imp<T, true> : public true_type {};
+
+template <typename T, bool> struct __destructible_false;
+template <typename T>
+struct __destructible_false<T, false>
+    : public __destructible_imp<T, is_reference<T>::value> {};
+template <typename T>
+struct __destructible_false<T, true> : public false_type {};
+
+template <typename T>
+struct is_destructible : public __destructible_false<T, is_function<T>::value> {
+};
+template <typename T> struct is_destructible<T[]> : public false_type {};
+template <> struct is_destructible<void> : public false_type {};
+
+#endif // __has_builtin(__is_destructible)
+} // namespace details
+
+#if __has_builtin(__is_trivially_destructible)
+
+template <typename T>
+struct is_trivially_destructible
+    : public integral_constant<bool, __is_trivially_destructible(T)> {};
+
+#elif __has_builtin(__has_trivial_destructor)
+
+template <typename T>
+struct is_trivially_destructible
+    : public integral_constant<
+          bool, __llvm_libc::cpp::details::is_destructible<T>::value
+                    &&__has_trivial_destructor(T)> {};
+
+#endif // __has_builtin(__is_trivially_destructible)
+
 } // namespace cpp
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_CPP_TYPETRAITS_H