Add files using upload-large-folder tool

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__complex/nvbf16.h

@@ -0,0 +1,353 @@
+// -*- 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
+// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___COMPLEX_NVBF16_H
+#define _LIBCUDACXX___COMPLEX_NVBF16_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#if defined(_LIBCUDACXX_HAS_NVBF16)
+
+_CCCL_DIAG_PUSH
+_CCCL_DIAG_SUPPRESS_CLANG("-Wunused-function")
+#  include <cuda_bf16.h>
+_CCCL_DIAG_POP
+
+#  include <cuda/std/__cmath/nvbf16.h>
+#  include <cuda/std/__complex/vector_support.h>
+#  include <cuda/std/__fwd/get.h>
+#  include <cuda/std/__type_traits/enable_if.h>
+#  include <cuda/std/__type_traits/integral_constant.h>
+#  include <cuda/std/__type_traits/is_constructible.h>
+#  include <cuda/std/__type_traits/is_extended_floating_point.h>
+#  include <cuda/std/cmath>
+#  include <cuda/std/complex>
+
+#  if !_CCCL_COMPILER(NVRTC)
+#    include <sstream> // for std::basic_ostringstream
+#  endif // !_CCCL_COMPILER(NVRTC)
+
+// This is a workaround against the user defining macros __CUDA_NO_HALF_CONVERSIONS__ __CUDA_NO_HALF_OPERATORS__
+namespace __cccl_internal
+{
+template <>
+struct __is_non_narrowing_convertible<__nv_bfloat16, float>
+{
+  static constexpr bool value = true;
+};
+
+template <>
+struct __is_non_narrowing_convertible<__nv_bfloat16, double>
+{
+  static constexpr bool value = true;
+};
+
+template <>
+struct __is_non_narrowing_convertible<float, __nv_bfloat16>
+{
+  static constexpr bool value = true;
+};
+
+template <>
+struct __is_non_narrowing_convertible<double, __nv_bfloat16>
+{
+  static constexpr bool value = true;
+};
+} // namespace __cccl_internal
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <>
+struct __complex_alignment<__nv_bfloat16> : integral_constant<size_t, alignof(__nv_bfloat162)>
+{};
+
+template <>
+struct __type_to_vector<__nv_bfloat16>
+{
+  using __type = __nv_bfloat162;
+};
+
+template <>
+struct __cccl_complex_overload_traits<__nv_bfloat16, false, false>
+{
+  typedef __nv_bfloat16 _ValueType;
+  typedef complex<__nv_bfloat16> _ComplexType;
+};
+
+template <class _Tp>
+_LIBCUDACXX_HIDE_FROM_ABI __nv_bfloat16 __convert_to_bfloat16(const _Tp& __value) noexcept
+{
+  return __value;
+}
+
+_LIBCUDACXX_HIDE_FROM_ABI __nv_bfloat16 __convert_to_bfloat16(const float& __value) noexcept
+{
+  return __float2bfloat16(__value);
+}
+
+_LIBCUDACXX_HIDE_FROM_ABI __nv_bfloat16 __convert_to_bfloat16(const double& __value) noexcept
+{
+  return __double2bfloat16(__value);
+}
+
+template <>
+class _CCCL_TYPE_VISIBILITY_DEFAULT _CCCL_ALIGNAS(alignof(__nv_bfloat162)) complex<__nv_bfloat16>
+{
+  __nv_bfloat162 __repr_;
+
+  template <class _Up>
+  friend class complex;
+
+  template <class _Up>
+  friend struct __get_complex_impl;
+
+public:
+  using value_type = __nv_bfloat16;
+
+  _LIBCUDACXX_HIDE_FROM_ABI complex(const value_type& __re = value_type(), const value_type& __im = value_type())
+      : __repr_(__re, __im)
+  {}
+
+  template <class _Up, enable_if_t<__cccl_internal::__is_non_narrowing_convertible<value_type, _Up>::value, int> = 0>
+  _LIBCUDACXX_HIDE_FROM_ABI complex(const complex<_Up>& __c)
+      : __repr_(__convert_to_bfloat16(__c.real()), __convert_to_bfloat16(__c.imag()))
+  {}
+
+  template <class _Up,
+            enable_if_t<!__cccl_internal::__is_non_narrowing_convertible<value_type, _Up>::value, int> = 0,
+            enable_if_t<_CCCL_TRAIT(is_constructible, value_type, _Up), int>                           = 0>
+  _LIBCUDACXX_HIDE_FROM_ABI explicit complex(const complex<_Up>& __c)
+      : __repr_(__convert_to_bfloat16(__c.real()), __convert_to_bfloat16(__c.imag()))
+  {}
+
+  _LIBCUDACXX_HIDE_FROM_ABI complex& operator=(const value_type& __re)
+  {
+    __repr_.x = __re;
+    __repr_.y = value_type();
+    return *this;
+  }
+
+  template <class _Up>
+  _LIBCUDACXX_HIDE_FROM_ABI complex& operator=(const complex<_Up>& __c)
+  {
+    __repr_.x = __convert_to_bfloat16(__c.real());
+    __repr_.y = __convert_to_bfloat16(__c.imag());
+    return *this;
+  }
+
+#  if !_CCCL_COMPILER(NVRTC)
+  template <class _Up>
+  _LIBCUDACXX_HIDE_FROM_ABI complex(const ::std::complex<_Up>& __other)
+      : __repr_(_LIBCUDACXX_ACCESS_STD_COMPLEX_REAL(__other), _LIBCUDACXX_ACCESS_STD_COMPLEX_IMAG(__other))
+  {}
+
+  template <class _Up>
+  _LIBCUDACXX_HIDE_FROM_ABI complex& operator=(const ::std::complex<_Up>& __other)
+  {
+    __repr_.x = _LIBCUDACXX_ACCESS_STD_COMPLEX_REAL(__other);
+    __repr_.y = _LIBCUDACXX_ACCESS_STD_COMPLEX_IMAG(__other);
+    return *this;
+  }
+
+  _CCCL_HOST operator ::std::complex<value_type>() const
+  {
+    return {__repr_.x, __repr_.y};
+  }
+#  endif // !_CCCL_COMPILER(NVRTC)
+
+  _LIBCUDACXX_HIDE_FROM_ABI value_type real() const
+  {
+    return __repr_.x;
+  }
+  _LIBCUDACXX_HIDE_FROM_ABI value_type imag() const
+  {
+    return __repr_.y;
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI void real(value_type __re)
+  {
+    __repr_.x = __re;
+  }
+  _LIBCUDACXX_HIDE_FROM_ABI void imag(value_type __im)
+  {
+    __repr_.y = __im;
+  }
+
+  // Those additional volatile overloads are meant to help with reductions in thrust
+  _LIBCUDACXX_HIDE_FROM_ABI value_type real() const volatile
+  {
+    return __repr_.x;
+  }
+  _LIBCUDACXX_HIDE_FROM_ABI value_type imag() const volatile
+  {
+    return __repr_.y;
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI complex& operator+=(const value_type& __re)
+  {
+    __repr_.x = __hadd(__repr_.x, __re);
+    return *this;
+  }
+  _LIBCUDACXX_HIDE_FROM_ABI complex& operator-=(const value_type& __re)
+  {
+    __repr_.x = __hsub(__repr_.x, __re);
+    return *this;
+  }
+  _LIBCUDACXX_HIDE_FROM_ABI complex& operator*=(const value_type& __re)
+  {
+    __repr_.x = __hmul(__repr_.x, __re);
+    __repr_.y = __hmul(__repr_.y, __re);
+    return *this;
+  }
+  _LIBCUDACXX_HIDE_FROM_ABI complex& operator/=(const value_type& __re)
+  {
+    __repr_.x = __hdiv(__repr_.x, __re);
+    __repr_.y = __hdiv(__repr_.y, __re);
+    return *this;
+  }
+
+  // We can utilize vectorized operations for those operators
+  _LIBCUDACXX_HIDE_FROM_ABI friend complex& operator+=(complex& __lhs, const complex& __rhs) noexcept
+  {
+    __lhs.__repr_ = __hadd2(__lhs.__repr_, __rhs.__repr_);
+    return __lhs;
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI friend complex& operator-=(complex& __lhs, const complex& __rhs) noexcept
+  {
+    __lhs.__repr_ = __hsub2(__lhs.__repr_, __rhs.__repr_);
+    return __lhs;
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI friend bool operator==(const complex& __lhs, const complex& __rhs) noexcept
+  {
+    return __hbeq2(__lhs.__repr_, __rhs.__repr_);
+  }
+};
+
+template <> // complex<float>
+template <> // complex<__half>
+_LIBCUDACXX_HIDE_FROM_ABI complex<float>::complex(const complex<__nv_bfloat16>& __c)
+    : __re_(__bfloat162float(__c.real()))
+    , __im_(__bfloat162float(__c.imag()))
+{}
+
+template <> // complex<double>
+template <> // complex<__half>
+_LIBCUDACXX_HIDE_FROM_ABI complex<double>::complex(const complex<__nv_bfloat16>& __c)
+    : __re_(__bfloat162float(__c.real()))
+    , __im_(__bfloat162float(__c.imag()))
+{}
+
+template <> // complex<float>
+template <> // complex<__nv_bfloat16>
+_LIBCUDACXX_HIDE_FROM_ABI complex<float>& complex<float>::operator=(const complex<__nv_bfloat16>& __c)
+{
+  __re_ = __bfloat162float(__c.real());
+  __im_ = __bfloat162float(__c.imag());
+  return *this;
+}
+
+template <> // complex<double>
+template <> // complex<__nv_bfloat16>
+_LIBCUDACXX_HIDE_FROM_ABI complex<double>& complex<double>::operator=(const complex<__nv_bfloat16>& __c)
+{
+  __re_ = __bfloat162float(__c.real());
+  __im_ = __bfloat162float(__c.imag());
+  return *this;
+}
+
+_LIBCUDACXX_HIDE_FROM_ABI __nv_bfloat16 arg(__nv_bfloat16 __re)
+{
+  return _CUDA_VSTD::atan2(__int2bfloat16_rn(0), __re);
+}
+
+// We have performance issues with some trigonometric functions with __nv_bfloat16
+template <>
+_LIBCUDACXX_HIDE_FROM_ABI complex<__nv_bfloat16> asinh(const complex<__nv_bfloat16>& __x)
+{
+  return complex<__nv_bfloat16>{_CUDA_VSTD::asinh(complex<float>{__x})};
+}
+template <>
+_LIBCUDACXX_HIDE_FROM_ABI complex<__nv_bfloat16> acosh(const complex<__nv_bfloat16>& __x)
+{
+  return complex<__nv_bfloat16>{_CUDA_VSTD::acosh(complex<float>{__x})};
+}
+template <>
+_LIBCUDACXX_HIDE_FROM_ABI complex<__nv_bfloat16> atanh(const complex<__nv_bfloat16>& __x)
+{
+  return complex<__nv_bfloat16>{_CUDA_VSTD::atanh(complex<float>{__x})};
+}
+template <>
+_LIBCUDACXX_HIDE_FROM_ABI complex<__nv_bfloat16> acos(const complex<__nv_bfloat16>& __x)
+{
+  return complex<__nv_bfloat16>{_CUDA_VSTD::acos(complex<float>{__x})};
+}
+
+template <>
+struct __get_complex_impl<__nv_bfloat16>
+{
+  template <size_t _Index>
+  static _LIBCUDACXX_HIDE_FROM_ABI constexpr __nv_bfloat16& get(complex<__nv_bfloat16>& __z) noexcept
+  {
+    return (_Index == 0) ? __z.__repr_.x : __z.__repr_.y;
+  }
+
+  template <size_t _Index>
+  static _LIBCUDACXX_HIDE_FROM_ABI constexpr __nv_bfloat16&& get(complex<__nv_bfloat16>&& __z) noexcept
+  {
+    return _CUDA_VSTD::move((_Index == 0) ? __z.__repr_.x : __z.__repr_.y);
+  }
+
+  template <size_t _Index>
+  static _LIBCUDACXX_HIDE_FROM_ABI constexpr const __nv_bfloat16& get(const complex<__nv_bfloat16>& __z) noexcept
+  {
+    return (_Index == 0) ? __z.__repr_.x : __z.__repr_.y;
+  }
+
+  template <size_t _Index>
+  static _LIBCUDACXX_HIDE_FROM_ABI constexpr const __nv_bfloat16&& get(const complex<__nv_bfloat16>&& __z) noexcept
+  {
+    return _CUDA_VSTD::move((_Index == 0) ? __z.__repr_.x : __z.__repr_.y);
+  }
+};
+
+#  if !_CCCL_COMPILER(NVRTC)
+template <class _CharT, class _Traits>
+::std::basic_istream<_CharT, _Traits>&
+operator>>(::std::basic_istream<_CharT, _Traits>& __is, complex<__nv_bfloat16>& __x)
+{
+  ::std::complex<float> __temp;
+  __is >> __temp;
+  __x = __temp;
+  return __is;
+}
+
+template <class _CharT, class _Traits>
+::std::basic_ostream<_CharT, _Traits>&
+operator<<(::std::basic_ostream<_CharT, _Traits>& __os, const complex<__nv_bfloat16>& __x)
+{
+  return __os << complex<float>{__x};
+}
+#  endif // !_CCCL_COMPILER(NVRTC)
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif /// _LIBCUDACXX_HAS_NVBF16
+
+#endif // _LIBCUDACXX___COMPLEX_NVBF16_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__complex/nvfp16.h

@@ -0,0 +1,349 @@
+// -*- 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
+// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___CUDA_COMPLEX_NVFP16_H
+#define _LIBCUDACXX___CUDA_COMPLEX_NVFP16_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#if defined(_LIBCUDACXX_HAS_NVFP16)
+
+#  include <cuda_fp16.h>
+
+#  include <cuda/std/__cmath/nvfp16.h>
+#  include <cuda/std/__complex/vector_support.h>
+#  include <cuda/std/__fwd/get.h>
+#  include <cuda/std/__type_traits/enable_if.h>
+#  include <cuda/std/__type_traits/integral_constant.h>
+#  include <cuda/std/__type_traits/is_constructible.h>
+#  include <cuda/std/__type_traits/is_extended_floating_point.h>
+#  include <cuda/std/cmath>
+#  include <cuda/std/complex>
+
+#  if !_CCCL_COMPILER(NVRTC)
+#    include <sstream> // for std::basic_ostringstream
+#  endif // !_CCCL_COMPILER(NVRTC)
+
+// This is a workaround against the user defining macros __CUDA_NO_HALF_CONVERSIONS__ __CUDA_NO_HALF_OPERATORS__
+namespace __cccl_internal
+{
+template <>
+struct __is_non_narrowing_convertible<__half, float>
+{
+  static constexpr bool value = true;
+};
+
+template <>
+struct __is_non_narrowing_convertible<__half, double>
+{
+  static constexpr bool value = true;
+};
+
+template <>
+struct __is_non_narrowing_convertible<float, __half>
+{
+  static constexpr bool value = true;
+};
+
+template <>
+struct __is_non_narrowing_convertible<double, __half>
+{
+  static constexpr bool value = true;
+};
+} // namespace __cccl_internal
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <>
+struct __complex_alignment<__half> : integral_constant<size_t, alignof(__half2)>
+{};
+
+template <>
+struct __type_to_vector<__half>
+{
+  using __type = __half2;
+};
+
+template <>
+struct __cccl_complex_overload_traits<__half, false, false>
+{
+  typedef __half _ValueType;
+  typedef complex<__half> _ComplexType;
+};
+
+template <class _Tp>
+_LIBCUDACXX_HIDE_FROM_ABI __half __convert_to_half(const _Tp& __value) noexcept
+{
+  return __value;
+}
+
+_LIBCUDACXX_HIDE_FROM_ABI __half __convert_to_half(const float& __value) noexcept
+{
+  return __float2half(__value);
+}
+
+_LIBCUDACXX_HIDE_FROM_ABI __half __convert_to_half(const double& __value) noexcept
+{
+  return __double2half(__value);
+}
+
+template <>
+class _CCCL_TYPE_VISIBILITY_DEFAULT _CCCL_ALIGNAS(alignof(__half2)) complex<__half>
+{
+  __half2 __repr_;
+
+  template <class _Up>
+  friend class complex;
+
+  template <class _Up>
+  friend struct __get_complex_impl;
+
+public:
+  using value_type = __half;
+
+  _LIBCUDACXX_HIDE_FROM_ABI complex(const value_type& __re = value_type(), const value_type& __im = value_type())
+      : __repr_(__re, __im)
+  {}
+
+  template <class _Up, enable_if_t<__cccl_internal::__is_non_narrowing_convertible<value_type, _Up>::value, int> = 0>
+  _LIBCUDACXX_HIDE_FROM_ABI complex(const complex<_Up>& __c)
+      : __repr_(__convert_to_half(__c.real()), __convert_to_half(__c.imag()))
+  {}
+
+  template <class _Up,
+            enable_if_t<!__cccl_internal::__is_non_narrowing_convertible<value_type, _Up>::value, int> = 0,
+            enable_if_t<_CCCL_TRAIT(is_constructible, value_type, _Up), int>                           = 0>
+  _LIBCUDACXX_HIDE_FROM_ABI explicit complex(const complex<_Up>& __c)
+      : __repr_(__convert_to_half(__c.real()), __convert_to_half(__c.imag()))
+  {}
+
+  _LIBCUDACXX_HIDE_FROM_ABI complex& operator=(const value_type& __re)
+  {
+    __repr_.x = __re;
+    __repr_.y = value_type();
+    return *this;
+  }
+
+  template <class _Up>
+  _LIBCUDACXX_HIDE_FROM_ABI complex& operator=(const complex<_Up>& __c)
+  {
+    __repr_.x = __convert_to_half(__c.real());
+    __repr_.y = __convert_to_half(__c.imag());
+    return *this;
+  }
+
+#  if !_CCCL_COMPILER(NVRTC)
+  template <class _Up>
+  _LIBCUDACXX_HIDE_FROM_ABI complex(const ::std::complex<_Up>& __other)
+      : __repr_(_LIBCUDACXX_ACCESS_STD_COMPLEX_REAL(__other), _LIBCUDACXX_ACCESS_STD_COMPLEX_IMAG(__other))
+  {}
+
+  template <class _Up>
+  _LIBCUDACXX_HIDE_FROM_ABI complex& operator=(const ::std::complex<_Up>& __other)
+  {
+    __repr_.x = _LIBCUDACXX_ACCESS_STD_COMPLEX_REAL(__other);
+    __repr_.y = _LIBCUDACXX_ACCESS_STD_COMPLEX_IMAG(__other);
+    return *this;
+  }
+
+  _CCCL_HOST operator ::std::complex<value_type>() const
+  {
+    return {__repr_.x, __repr_.y};
+  }
+#  endif // !_CCCL_COMPILER(NVRTC)
+
+  _LIBCUDACXX_HIDE_FROM_ABI value_type real() const
+  {
+    return __repr_.x;
+  }
+  _LIBCUDACXX_HIDE_FROM_ABI value_type imag() const
+  {
+    return __repr_.y;
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI void real(value_type __re)
+  {
+    __repr_.x = __re;
+  }
+  _LIBCUDACXX_HIDE_FROM_ABI void imag(value_type __im)
+  {
+    __repr_.y = __im;
+  }
+
+  // Those additional volatile overloads are meant to help with reductions in thrust
+  _LIBCUDACXX_HIDE_FROM_ABI value_type real() const volatile
+  {
+    return __repr_.x;
+  }
+  _LIBCUDACXX_HIDE_FROM_ABI value_type imag() const volatile
+  {
+    return __repr_.y;
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI complex& operator+=(const value_type& __re)
+  {
+    __repr_.x = __hadd(__repr_.x, __re);
+    return *this;
+  }
+  _LIBCUDACXX_HIDE_FROM_ABI complex& operator-=(const value_type& __re)
+  {
+    __repr_.x = __hsub(__repr_.x, __re);
+    return *this;
+  }
+  _LIBCUDACXX_HIDE_FROM_ABI complex& operator*=(const value_type& __re)
+  {
+    __repr_.x = __hmul(__repr_.x, __re);
+    __repr_.y = __hmul(__repr_.y, __re);
+    return *this;
+  }
+  _LIBCUDACXX_HIDE_FROM_ABI complex& operator/=(const value_type& __re)
+  {
+    __repr_.x = __hdiv(__repr_.x, __re);
+    __repr_.y = __hdiv(__repr_.y, __re);
+    return *this;
+  }
+
+  // We can utilize vectorized operations for those operators
+  _LIBCUDACXX_HIDE_FROM_ABI friend complex& operator+=(complex& __lhs, const complex& __rhs) noexcept
+  {
+    __lhs.__repr_ = __hadd2(__lhs.__repr_, __rhs.__repr_);
+    return __lhs;
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI friend complex& operator-=(complex& __lhs, const complex& __rhs) noexcept
+  {
+    __lhs.__repr_ = __hsub2(__lhs.__repr_, __rhs.__repr_);
+    return __lhs;
+  }
+
+  _LIBCUDACXX_HIDE_FROM_ABI friend bool operator==(const complex& __lhs, const complex& __rhs) noexcept
+  {
+    return __hbeq2(__lhs.__repr_, __rhs.__repr_);
+  }
+};
+
+template <> // complex<float>
+template <> // complex<__half>
+_LIBCUDACXX_HIDE_FROM_ABI complex<float>::complex(const complex<__half>& __c)
+    : __re_(__half2float(__c.real()))
+    , __im_(__half2float(__c.imag()))
+{}
+
+template <> // complex<double>
+template <> // complex<__half>
+_LIBCUDACXX_HIDE_FROM_ABI complex<double>::complex(const complex<__half>& __c)
+    : __re_(__half2float(__c.real()))
+    , __im_(__half2float(__c.imag()))
+{}
+
+template <> // complex<float>
+template <> // complex<__half>
+_LIBCUDACXX_HIDE_FROM_ABI complex<float>& complex<float>::operator=(const complex<__half>& __c)
+{
+  __re_ = __half2float(__c.real());
+  __im_ = __half2float(__c.imag());
+  return *this;
+}
+
+template <> // complex<double>
+template <> // complex<__half>
+_LIBCUDACXX_HIDE_FROM_ABI complex<double>& complex<double>::operator=(const complex<__half>& __c)
+{
+  __re_ = __half2float(__c.real());
+  __im_ = __half2float(__c.imag());
+  return *this;
+}
+
+_LIBCUDACXX_HIDE_FROM_ABI __half arg(__half __re)
+{
+  return _CUDA_VSTD::atan2(__int2half_rn(0), __re);
+}
+
+// We have performance issues with some trigonometric functions with __half
+template <>
+_LIBCUDACXX_HIDE_FROM_ABI complex<__half> asinh(const complex<__half>& __x)
+{
+  return complex<__half>{_CUDA_VSTD::asinh(complex<float>{__x})};
+}
+template <>
+_LIBCUDACXX_HIDE_FROM_ABI complex<__half> acosh(const complex<__half>& __x)
+{
+  return complex<__half>{_CUDA_VSTD::acosh(complex<float>{__x})};
+}
+template <>
+_LIBCUDACXX_HIDE_FROM_ABI complex<__half> atanh(const complex<__half>& __x)
+{
+  return complex<__half>{_CUDA_VSTD::atanh(complex<float>{__x})};
+}
+template <>
+_LIBCUDACXX_HIDE_FROM_ABI complex<__half> acos(const complex<__half>& __x)
+{
+  return complex<__half>{_CUDA_VSTD::acos(complex<float>{__x})};
+}
+
+template <>
+struct __get_complex_impl<__half>
+{
+  template <size_t _Index>
+  static _LIBCUDACXX_HIDE_FROM_ABI constexpr __half& get(complex<__half>& __z) noexcept
+  {
+    return (_Index == 0) ? __z.__repr_.x : __z.__repr_.y;
+  }
+
+  template <size_t _Index>
+  static _LIBCUDACXX_HIDE_FROM_ABI constexpr __half&& get(complex<__half>&& __z) noexcept
+  {
+    return _CUDA_VSTD::move((_Index == 0) ? __z.__repr_.x : __z.__repr_.y);
+  }
+
+  template <size_t _Index>
+  static _LIBCUDACXX_HIDE_FROM_ABI constexpr const __half& get(const complex<__half>& __z) noexcept
+  {
+    return (_Index == 0) ? __z.__repr_.x : __z.__repr_.y;
+  }
+
+  template <size_t _Index>
+  static _LIBCUDACXX_HIDE_FROM_ABI constexpr const __half&& get(const complex<__half>&& __z) noexcept
+  {
+    return _CUDA_VSTD::move((_Index == 0) ? __z.__repr_.x : __z.__repr_.y);
+  }
+};
+
+#  if !defined(_LIBCUDACXX_HAS_NO_LOCALIZATION) && !_CCCL_COMPILER(NVRTC)
+template <class _CharT, class _Traits>
+::std::basic_istream<_CharT, _Traits>& operator>>(::std::basic_istream<_CharT, _Traits>& __is, complex<__half>& __x)
+{
+  ::std::complex<float> __temp;
+  __is >> __temp;
+  __x = __temp;
+  return __is;
+}
+
+template <class _CharT, class _Traits>
+::std::basic_ostream<_CharT, _Traits>&
+operator<<(::std::basic_ostream<_CharT, _Traits>& __os, const complex<__half>& __x)
+{
+  return __os << complex<float>{__x};
+}
+#  endif // !_LIBCUDACXX_HAS_NO_LOCALIZATION && !_CCCL_COMPILER(NVRTC)
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif /// _LIBCUDACXX_HAS_NVFP16
+
+#endif // _LIBCUDACXX___CUDA_COMPLEX_NVFP16_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__complex/vector_support.h

@@ -0,0 +1,145 @@
+// -*- 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
+// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___COMPLEX_TRAITS_H
+#define _LIBCUDACXX___COMPLEX_TRAITS_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/enable_if.h>
+#include <cuda/std/__type_traits/integral_constant.h>
+#include <cuda/std/__type_traits/is_arithmetic.h>
+#include <cuda/std/__type_traits/is_extended_floating_point.h>
+#include <cuda/std/__type_traits/is_floating_point.h>
+#include <cuda/std/__type_traits/void_t.h>
+#include <cuda/std/__utility/declval.h>
+#include <cuda/std/cstddef>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+struct __is_complex_float
+{
+  static constexpr auto value = _CCCL_TRAIT(is_floating_point, _Tp) || _CCCL_TRAIT(__is_extended_floating_point, _Tp);
+};
+
+template <class _Tp>
+struct __is_complex_arithmetic
+{
+  static constexpr auto value = _CCCL_TRAIT(is_arithmetic, _Tp) || __is_complex_float<_Tp>::value;
+};
+
+template <class _Tp>
+struct __complex_alignment : integral_constant<size_t, 2 * sizeof(_Tp)>
+{};
+
+#if _LIBCUDACXX_CUDA_ABI_VERSION > 3
+#  define _LIBCUDACXX_COMPLEX_ALIGNAS _CCCL_ALIGNAS(__complex_alignment<_Tp>::value)
+#else
+#  define _LIBCUDACXX_COMPLEX_ALIGNAS
+#endif
+
+template <class _Tp>
+struct __type_to_vector;
+
+template <class _Tp>
+using __type_to_vector_t = typename __type_to_vector<_Tp>::__type;
+
+template <class _Tp, typename = void>
+struct __has_vector_type : false_type
+{};
+
+template <class _Tp>
+struct __has_vector_type<_Tp, void_t<__type_to_vector_t<_Tp>>> : true_type
+{};
+
+template <class _Tp>
+struct __abcd_results
+{
+  _Tp __ac;
+  _Tp __bd;
+  _Tp __ad;
+  _Tp __bc;
+};
+
+template <class _Tp>
+struct __ab_results
+{
+  _Tp __a;
+  _Tp __b;
+};
+
+template <class _Tp, typename = enable_if_t<!__has_vector_type<_Tp>::value>>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX14 __abcd_results<_Tp>
+__complex_calculate_partials(_Tp __a, _Tp __b, _Tp __c, _Tp __d) noexcept
+{
+  return {__a * __c, __b * __d, __a * __d, __b * __c};
+}
+
+template <class _Tp, typename = enable_if_t<!__has_vector_type<_Tp>::value>>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX14 __ab_results<_Tp>
+__complex_piecewise_mul(_Tp __x1, _Tp __y1, _Tp __x2, _Tp __y2) noexcept
+{
+  return {__x1 * __x2, __y1 * __y2};
+}
+
+template <class _Tp>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX14 enable_if_t<__has_vector_type<_Tp>::value, __abcd_results<_Tp>>
+__complex_calculate_partials(_Tp __a, _Tp __b, _Tp __c, _Tp __d) noexcept
+{
+  __abcd_results<_Tp> __ret;
+
+  using _Vec = __type_to_vector_t<_Tp>;
+
+  _Vec __first{__a, __b};
+  _Vec __second{__c, __d};
+  _Vec __second_flip{__d, __c};
+
+  _Vec __ac_bd = __first * __second;
+  _Vec __ad_bc = __first * __second_flip;
+
+  __ret.__ac = __ac_bd.x;
+  __ret.__bd = __ac_bd.y;
+  __ret.__ad = __ad_bc.x;
+  __ret.__bc = __ad_bc.y;
+
+  return __ret;
+}
+
+template <class _Tp>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX14 enable_if_t<__has_vector_type<_Tp>::value, __ab_results<_Tp>>
+__complex_piecewise_mul(_Tp __x1, _Tp __y1, _Tp __x2, _Tp __y2) noexcept
+{
+  __ab_results<_Tp> __ret;
+
+  using _Vec = __type_to_vector_t<_Tp>;
+
+  _Vec __v1{__x1, __y1};
+  _Vec __v2{__x2, __y2};
+
+  _Vec __result = __v1 * __v2;
+
+  __ret.__a = __result.x;
+  __ret.__b = __result.y;
+
+  return __ret;
+}
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___COMPLEX_TRAITS_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__type_traits/add_const.h

@@ -0,0 +1,36 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_ADD_CONST_H
+#define _LIBCUDACXX___TYPE_TRAITS_ADD_CONST_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT add_const
+{
+  typedef _CCCL_NODEBUG_ALIAS const _Tp type;
+};
+
+template <class _Tp>
+using add_const_t _CCCL_NODEBUG_ALIAS = typename add_const<_Tp>::type;
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_ADD_CONST_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__type_traits/add_volatile.h

@@ -0,0 +1,36 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_ADD_VOLATILE_H
+#define _LIBCUDACXX___TYPE_TRAITS_ADD_VOLATILE_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT add_volatile
+{
+  typedef _CCCL_NODEBUG_ALIAS volatile _Tp type;
+};
+
+template <class _Tp>
+using add_volatile_t _CCCL_NODEBUG_ALIAS = typename add_volatile<_Tp>::type;
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_ADD_VOLATILE_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__type_traits/aligned_storage.h

@@ -0,0 +1,145 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 _LIBCUDACXX___TYPE_TRAITS_ALIGNED_STORAGE_H
+#define _LIBCUDACXX___TYPE_TRAITS_ALIGNED_STORAGE_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/conditional.h>
+#include <cuda/std/__type_traits/integral_constant.h>
+#include <cuda/std/__type_traits/nat.h>
+#include <cuda/std/__type_traits/type_list.h>
+#include <cuda/std/cstddef>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+struct __align_type
+{
+  static const size_t value = _LIBCUDACXX_PREFERRED_ALIGNOF(_Tp);
+  typedef _Tp type;
+};
+
+struct __struct_double
+{
+  long double __lx;
+};
+struct __struct_double4
+{
+  double __lx[4];
+};
+
+typedef __type_list<__align_type<unsigned char>,
+                    __align_type<unsigned short>,
+                    __align_type<unsigned int>,
+                    __align_type<unsigned long>,
+                    __align_type<unsigned long long>,
+                    __align_type<double>,
+                    __align_type<long double>,
+                    __align_type<__struct_double>,
+                    __align_type<__struct_double4>,
+                    __align_type<int*>>
+  __all_types;
+
+template <size_t _Align>
+struct _CCCL_ALIGNAS(_Align) __fallback_overaligned
+{
+  static const size_t value = _Align;
+  using type                = __fallback_overaligned;
+};
+
+template <size_t _Align>
+struct __has_align
+{
+  template <class _Ty>
+  using __call = bool_constant<_Align == _Ty::value>;
+};
+
+template <class _TL, size_t _Align>
+struct __find_pod
+    : public __type_front<__type_find_if<__type_push_back<_TL, __fallback_overaligned<_Align>>, __has_align<_Align>>>
+{};
+
+_CCCL_HOST_DEVICE constexpr size_t __select_align_fn_2_(size_t __len, size_t __min, size_t __max)
+{
+  return __len < __max ? __min : __max;
+}
+
+_CCCL_HOST_DEVICE constexpr size_t __select_align_fn_(size_t __len, size_t __a1, size_t __a2)
+{
+  return __select_align_fn_2_(__len, __a2 < __a1 ? __a2 : __a1, __a1 < __a2 ? __a2 : __a1);
+}
+
+template <size_t _Len>
+struct __select_align_fn
+{
+  template <class _State, class _Ty>
+  using __call = integral_constant<size_t, __select_align_fn_(_Len, _State::value, _Ty::value)>;
+};
+
+template <class _TL, size_t _Len>
+struct __find_max_align : public __type_fold_left<_TL, integral_constant<size_t, 0>, __select_align_fn<_Len>>
+{};
+
+template <size_t _Len, size_t _Align = __find_max_align<__all_types, _Len>::value>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT aligned_storage
+{
+  typedef typename __find_pod<__all_types, _Align>::type _Aligner;
+  union type
+  {
+    _Aligner __align;
+    unsigned char __data[(_Len + _Align - 1) / _Align * _Align];
+  };
+};
+
+template <size_t _Len, size_t _Align = __find_max_align<__all_types, _Len>::value>
+using aligned_storage_t _CCCL_NODEBUG_ALIAS = typename aligned_storage<_Len, _Align>::type;
+
+#define _CREATE_ALIGNED_STORAGE_SPECIALIZATION(n)               \
+  template <size_t _Len>                                        \
+  struct _CCCL_TYPE_VISIBILITY_DEFAULT aligned_storage<_Len, n> \
+  {                                                             \
+    struct _CCCL_ALIGNAS(n) type                                \
+    {                                                           \
+      unsigned char __lx[(_Len + n - 1) / n * n];               \
+    };                                                          \
+  }
+
+_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x1);
+_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x2);
+_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x4);
+_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x8);
+_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x10);
+_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x20);
+_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x40);
+_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x80);
+_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x100);
+_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x200);
+_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x400);
+_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x800);
+_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x1000);
+_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x2000);
+// PE/COFF does not support alignment beyond 8192 (=0x2000)
+#if !defined(_WIN32)
+_CREATE_ALIGNED_STORAGE_SPECIALIZATION(0x4000);
+#endif // !defined(_WIN32)
+
+#undef _CREATE_ALIGNED_STORAGE_SPECIALIZATION
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_ALIGNED_STORAGE_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__type_traits/alignment_of.h

@@ -0,0 +1,39 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_ALIGNMENT_OF_H
+#define _LIBCUDACXX___TYPE_TRAITS_ALIGNMENT_OF_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/integral_constant.h>
+#include <cuda/std/cstddef>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT alignment_of : public integral_constant<size_t, _LIBCUDACXX_ALIGNOF(_Tp)>
+{};
+
+#if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr size_t alignment_of_v = _LIBCUDACXX_ALIGNOF(_Tp);
+#endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_ALIGNMENT_OF_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__type_traits/common_reference.h

@@ -0,0 +1,260 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+// SPDX-FileCopyrightText: Copyright (c) Microsoft Corporation.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_COMMON_REFERENCE_H
+#define _LIBCUDACXX___TYPE_TRAITS_COMMON_REFERENCE_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/common_type.h>
+#include <cuda/std/__type_traits/conditional.h>
+#include <cuda/std/__type_traits/copy_cv.h>
+#include <cuda/std/__type_traits/copy_cvref.h>
+#include <cuda/std/__type_traits/disjunction.h>
+#include <cuda/std/__type_traits/enable_if.h>
+#include <cuda/std/__type_traits/is_array.h>
+#include <cuda/std/__type_traits/is_convertible.h>
+#include <cuda/std/__type_traits/is_reference.h>
+#include <cuda/std/__type_traits/is_same.h>
+#include <cuda/std/__type_traits/is_scalar.h>
+#include <cuda/std/__type_traits/remove_cvref.h>
+#include <cuda/std/__type_traits/remove_reference.h>
+#include <cuda/std/__type_traits/void_t.h>
+#include <cuda/std/__utility/declval.h>
+
+_CCCL_NV_DIAG_SUPPRESS(1384) // warning: pointer converted to bool
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+// common_reference
+
+// Let COND_RES(X, Y) be:
+#if _CCCL_COMPILER(MSVC) // Workaround for DevCom-1627396
+template <class _Tp>
+_Tp __returns_exactly() noexcept; // not defined
+
+template <class _Xp, class _Yp>
+using __cond_res_if_right = decltype(false ? __returns_exactly<_Xp>() : __returns_exactly<_Yp>());
+
+template <class _Tp, class _Up, class = void>
+struct __cond_res_workaround
+{};
+
+template <class _Tp, class _Up>
+struct __cond_res_workaround<_Tp, _Up, void_t<__cond_res_if_right<_Tp, _Up>>>
+{
+  using _RTp = remove_cvref_t<_Tp>;
+  using type =
+    conditional_t<is_same_v<_RTp, remove_cvref_t<_Up>> && (is_scalar_v<_RTp> || is_array_v<_RTp>)
+                    && ((is_lvalue_reference_v<_Tp> && is_rvalue_reference_v<_Up>)
+                        || (is_rvalue_reference_v<_Tp> && is_lvalue_reference_v<_Up>) ),
+                  decay_t<__copy_cv_t<remove_reference_t<_Tp>, remove_reference_t<_Up>>>,
+                  __cond_res_if_right<_Tp, _Up>>;
+};
+
+template <class _Xp, class _Yp>
+using __cond_res = typename __cond_res_workaround<_Xp, _Yp>::type;
+#else // ^^^ _CCCL_COMPILER(MSVC) ^^^ / vvv !_CCCL_COMPILER(MSVC) vvv
+template <class _Xp, class _Yp>
+using __cond_res = decltype(false ? _CUDA_VSTD::declval<_Xp (&)()>()() : _CUDA_VSTD::declval<_Yp (&)()>()());
+#endif // !_CCCL_COMPILER(MSVC)
+
+// Let `XREF(A)` denote a unary alias template `T` such that `T<U>` denotes the same type as `U`
+// with the addition of `A`'s cv and reference qualifiers, for a non-reference cv-unqualified type
+// `U`.
+// [Note: `XREF(A)` is `__xref<A>::template __call`]
+template <class _Tp>
+using __xref = __apply_cvref_fn<_Tp>;
+
+// Given types A and B, let X be remove_reference_t<A>, let Y be remove_reference_t<B>,
+// and let COMMON-REF(A, B) be:
+template <class _Ap, class _Bp, class = void>
+struct __common_ref;
+
+template <class _Xp, class _Yp>
+using __common_ref_t _CCCL_NODEBUG_ALIAS = typename __common_ref<_Xp, _Yp>::__type;
+
+template <class _Xp, class _Yp>
+using __cv_cond_res = __cond_res<__copy_cv_t<_Xp, _Yp>&, __copy_cv_t<_Yp, _Xp>&>;
+
+//    If A and B are both lvalue reference types, COMMON-REF(A, B) is
+//    COND-RES(COPYCV(X, Y)&, COPYCV(Y, X)&) if that type exists and is a reference type.
+template <class _Ap, class _Bp>
+struct __common_ref<_Ap&, _Bp&, enable_if_t<_CCCL_TRAIT(is_reference, __cv_cond_res<_Ap, _Bp>)>>
+{
+  using __type = __cv_cond_res<_Ap, _Bp>;
+};
+
+//    Otherwise, let C be remove_reference_t<COMMON-REF(X&, Y&)>&&. ...
+template <class _Xp, class _Yp>
+using __common_ref_C = remove_reference_t<__common_ref_t<_Xp&, _Yp&>>&&;
+
+//    .... If A and B are both rvalue reference types, C is well-formed, and
+//    is_convertible_v<A, C> && is_convertible_v<B, C> is true, then COMMON-REF(A, B) is C.
+template <class _Ap, class _Bp, class = void>
+struct __common_ref_rr
+{};
+
+template <class _Ap, class _Bp>
+struct __common_ref_rr<_Ap&&,
+                       _Bp&&,
+                       enable_if_t<_CCCL_TRAIT(is_convertible, _Ap&&, __common_ref_C<_Ap, _Bp>)
+                                   && _CCCL_TRAIT(is_convertible, _Bp&&, __common_ref_C<_Ap, _Bp>)>>
+{
+  using __type = __common_ref_C<_Ap, _Bp>;
+};
+
+template <class _Ap, class _Bp>
+struct __common_ref<_Ap&&, _Bp&&> : __common_ref_rr<_Ap&&, _Bp&&>
+{};
+
+//    Otherwise, let D be COMMON-REF(const X&, Y&). ...
+template <class _Tp, class _Up>
+using __common_ref_D = __common_ref_t<const _Tp&, _Up&>;
+
+//    ... If A is an rvalue reference and B is an lvalue reference and D is well-formed and
+//    is_convertible_v<A, D> is true, then COMMON-REF(A, B) is D.
+template <class _Ap, class _Bp, class = void>
+struct __common_ref_lr
+{};
+
+template <class _Ap, class _Bp>
+struct __common_ref_lr<_Ap&&, _Bp&, enable_if_t<_CCCL_TRAIT(is_convertible, _Ap&&, __common_ref_D<_Ap, _Bp>)>>
+{
+  using __type = __common_ref_D<_Ap, _Bp>;
+};
+
+template <class _Ap, class _Bp>
+struct __common_ref<_Ap&&, _Bp&> : __common_ref_lr<_Ap&&, _Bp&>
+{};
+
+//    Otherwise, if A is an lvalue reference and B is an rvalue reference, then
+//    COMMON-REF(A, B) is COMMON-REF(B, A).
+template <class _Ap, class _Bp>
+struct __common_ref<_Ap&, _Bp&&> : __common_ref_lr<_Bp&&, _Ap&>
+{};
+
+//    Otherwise, COMMON-REF(A, B) is ill-formed.
+template <class _Ap, class _Bp, class>
+struct __common_ref
+{};
+
+// Note C: For the common_reference trait applied to a parameter pack [...]
+
+template <class...>
+struct common_reference;
+
+template <class... _Types>
+using common_reference_t _CCCL_NODEBUG_ALIAS = typename common_reference<_Types...>::type;
+
+#if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class, class, class = void>
+_CCCL_INLINE_VAR constexpr bool __has_common_reference = false;
+
+template <class _Tp, class _Up>
+_CCCL_INLINE_VAR constexpr bool __has_common_reference<_Tp, _Up, void_t<common_reference_t<_Tp, _Up>>> = true;
+#endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+// bullet 1 - sizeof...(T) == 0
+template <>
+struct common_reference<>
+{};
+
+// bullet 2 - sizeof...(T) == 1
+template <class _Tp>
+struct common_reference<_Tp>
+{
+  using type = _Tp;
+};
+
+// bullet 3 - sizeof...(T) == 2
+template <class _Tp, class _Up, class = void>
+struct __common_reference_sub_bullet3;
+template <class _Tp, class _Up, class = void>
+struct __common_reference_sub_bullet2 : __common_reference_sub_bullet3<_Tp, _Up>
+{};
+template <class _Tp, class _Up, class = void>
+struct __common_reference_sub_bullet1 : __common_reference_sub_bullet2<_Tp, _Up>
+{};
+
+// sub-bullet 1 - If T1 and T2 are reference types and COMMON-REF(T1, T2) is well-formed, then
+// the member typedef `type` denotes that type.
+template <class _Tp, class _Up>
+struct common_reference<_Tp, _Up> : __common_reference_sub_bullet1<_Tp, _Up>
+{};
+
+template <class _Tp, class _Up>
+struct __common_reference_sub_bullet1<
+  _Tp,
+  _Up,
+  void_t<__common_ref_t<_Tp, _Up>, enable_if_t<_CCCL_TRAIT(is_reference, _Tp) && _CCCL_TRAIT(is_reference, _Up)>>>
+{
+  using type = __common_ref_t<_Tp, _Up>;
+};
+
+// sub-bullet 2 - Otherwise, if basic_common_reference<remove_cvref_t<T1>, remove_cvref_t<T2>, XREF(T1), XREF(T2)>::type
+// is well-formed, then the member typedef `type` denotes that type.
+template <class, class, template <class> class, template <class> class>
+struct basic_common_reference
+{};
+
+template <class _Tp, class _Up>
+using __basic_common_reference_t _CCCL_NODEBUG_ALIAS =
+  typename basic_common_reference<remove_cvref_t<_Tp>,
+                                  remove_cvref_t<_Up>,
+                                  __xref<_Tp>::template __call,
+                                  __xref<_Up>::template __call>::type;
+
+template <class _Tp, class _Up>
+struct __common_reference_sub_bullet2<_Tp, _Up, void_t<__basic_common_reference_t<_Tp, _Up>>>
+{
+  using type = __basic_common_reference_t<_Tp, _Up>;
+};
+
+// sub-bullet 3 - Otherwise, if COND-RES(T1, T2) is well-formed,
+// then the member typedef `type` denotes that type.
+template <class _Tp, class _Up>
+struct __common_reference_sub_bullet3<_Tp, _Up, void_t<__cond_res<_Tp, _Up>>>
+{
+  using type = __cond_res<_Tp, _Up>;
+};
+
+// sub-bullet 4 & 5 - Otherwise, if common_type_t<T1, T2> is well-formed,
+//                    then the member typedef `type` denotes that type.
+//                  - Otherwise, there shall be no member `type`.
+template <class _Tp, class _Up, class>
+struct __common_reference_sub_bullet3 : common_type<_Tp, _Up>
+{};
+
+// bullet 4 - If there is such a type `C`, the member typedef type shall denote the same type, if
+//            any, as `common_reference_t<C, Rest...>`.
+template <class _Tp, class _Up, class _Vp, class... _Rest>
+struct common_reference<_Tp, _Up, _Vp, void_t<common_reference_t<_Tp, _Up>>, _Rest...>
+    : common_reference<common_reference_t<_Tp, _Up>, _Vp, _Rest...>
+{};
+
+// bullet 5 - Otherwise, there shall be no member `type`.
+template <class...>
+struct common_reference
+{};
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+_CCCL_NV_DIAG_DEFAULT(1384)
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_COMMON_REFERENCE_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__type_traits/common_type.h

@@ -0,0 +1,172 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_COMMON_TYPE_H
+#define _LIBCUDACXX___TYPE_TRAITS_COMMON_TYPE_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/copy_cvref.h>
+#include <cuda/std/__type_traits/decay.h>
+#include <cuda/std/__type_traits/enable_if.h>
+#include <cuda/std/__type_traits/is_arithmetic.h>
+#include <cuda/std/__type_traits/is_extended_floating_point.h>
+#include <cuda/std/__type_traits/is_same.h>
+#include <cuda/std/__type_traits/remove_cvref.h>
+#include <cuda/std/__type_traits/void_t.h>
+#include <cuda/std/__utility/declval.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class... _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT common_type;
+
+template <class... _Tp>
+using common_type_t _CCCL_NODEBUG_ALIAS = typename common_type<_Tp...>::type;
+
+// Let COND_RES(X, Y) be:
+template <class _Tp, class _Up>
+using __cond_type = decltype(false ? declval<_Tp>() : declval<_Up>());
+
+// We need to ensure that extended floating point types like __half and __nv bfloat16 have a common type with real
+// floating point types
+template <class _Tp, class _Up, class = void>
+struct __common_type_extended_floating_point
+{};
+
+#if !defined(__CUDA_NO_HALF_CONVERSIONS__) && !defined(__CUDA_NO_HALF_OPERATORS__) \
+  && !defined(__CUDA_NO_BFLOAT16_CONVERSIONS__) && !defined(__CUDA_NO_BFLOAT16_OPERATORS__)
+template <class _Tp, class _Up>
+struct __common_type_extended_floating_point<_Tp,
+                                             _Up,
+                                             enable_if_t<_CCCL_TRAIT(__is_extended_floating_point, remove_cvref_t<_Tp>)
+                                                         && _CCCL_TRAIT(is_arithmetic, remove_cvref_t<_Up>)>>
+{
+  using type = common_type_t<__copy_cvref_t<_Tp, float>, _Up>;
+};
+
+template <class _Tp, class _Up>
+struct __common_type_extended_floating_point<
+  _Tp,
+  _Up,
+  enable_if_t<_CCCL_TRAIT(is_arithmetic, remove_cvref_t<_Tp>)
+              && _CCCL_TRAIT(__is_extended_floating_point, remove_cvref_t<_Up>)>>
+{
+  using type = common_type_t<_Tp, __copy_cvref_t<_Up, float>>;
+};
+#endif // extended floating point as arithmetic type
+
+template <class _Tp, class _Up, class = void>
+struct __common_type3 : __common_type_extended_floating_point<_Tp, _Up>
+{};
+
+#if _CCCL_STD_VER >= 2020
+// sub-bullet 4 - "if COND_RES(CREF(D1), CREF(D2)) denotes a type..."
+template <class _Tp, class _Up>
+struct __common_type3<_Tp, _Up, void_t<__cond_type<const _Tp&, const _Up&>>>
+{
+  using type = remove_cvref_t<__cond_type<const _Tp&, const _Up&>>;
+};
+#endif // _CCCL_STD_VER >= 2020
+
+template <class _Tp, class _Up, class = void>
+struct __common_type2_imp : __common_type3<_Tp, _Up>
+{};
+
+// MSVC has a bug in its declval handling, where it happily accepts __cond_type<_Tp, _Up>, even though both
+// branches have diverging return types, this happens for extended floating point types
+template <class _Tp, class _Up>
+using __msvc_declval_workaround =
+#if _CCCL_COMPILER(MSVC)
+  enable_if_t<_CCCL_TRAIT(is_same, __cond_type<_Tp, _Up>, __cond_type<_Up, _Tp>)>;
+#else // ^^^ _CCCL_COMPILER(MSVC) ^^^ / vvv !_CCCL_COMPILER(MSVC) vvv
+  void;
+#endif // !_CCCL_COMPILER(MSVC)
+
+// sub-bullet 3 - "if decay_t<decltype(false ? declval<D1>() : declval<D2>())> ..."
+template <class _Tp, class _Up>
+struct __common_type2_imp<_Tp, _Up, void_t<__cond_type<_Tp, _Up>, __msvc_declval_workaround<_Tp, _Up>>>
+{
+  typedef _CCCL_NODEBUG_ALIAS decay_t<__cond_type<_Tp, _Up>> type;
+};
+
+template <class, class = void>
+struct __common_type_impl
+{};
+
+template <class... _Tp>
+struct __common_types;
+
+template <class _Tp, class _Up>
+struct __common_type_impl<__common_types<_Tp, _Up>, void_t<common_type_t<_Tp, _Up>>>
+{
+  typedef common_type_t<_Tp, _Up> type;
+};
+
+template <class _Tp, class _Up, class _Vp, class... _Rest>
+struct __common_type_impl<__common_types<_Tp, _Up, _Vp, _Rest...>, void_t<common_type_t<_Tp, _Up>>>
+    : __common_type_impl<__common_types<common_type_t<_Tp, _Up>, _Vp, _Rest...>>
+{};
+
+// bullet 1 - sizeof...(Tp) == 0
+
+template <>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT common_type<>
+{};
+
+// bullet 2 - sizeof...(Tp) == 1
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT common_type<_Tp> : public common_type<_Tp, _Tp>
+{};
+
+// bullet 3 - sizeof...(Tp) == 2
+
+// sub-bullet 1 - "If is_same_v<T1, D1> is false or ..."
+template <class _Tp, class _Up, class _D1 = decay_t<_Tp>, class _D2 = decay_t<_Up>>
+struct __common_type2 : common_type<_D1, _D2>
+{};
+
+template <class _Tp, class _Up>
+struct __common_type2<_Tp, _Up, _Tp, _Up> : __common_type2_imp<_Tp, _Up>
+{};
+
+template <class _Tp, class _Up>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT common_type<_Tp, _Up> : __common_type2<_Tp, _Up>
+{};
+
+// bullet 4 - sizeof...(Tp) > 2
+
+template <class _Tp, class _Up, class _Vp, class... _Rest>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT common_type<_Tp, _Up, _Vp, _Rest...>
+    : __common_type_impl<__common_types<_Tp, _Up, _Vp, _Rest...>>
+{};
+
+template <class... _Tp>
+using common_type_t _CCCL_NODEBUG_ALIAS = typename common_type<_Tp...>::type;
+
+#if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class, class, class = void>
+_CCCL_INLINE_VAR constexpr bool __has_common_type = false;
+
+template <class _Tp, class _Up>
+_CCCL_INLINE_VAR constexpr bool __has_common_type<_Tp, _Up, void_t<common_type_t<_Tp, _Up>>> = true;
+#endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_COMMON_TYPE_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__type_traits/conjunction.h

@@ -0,0 +1,65 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_CONJUNCTION_H
+#define _LIBCUDACXX___TYPE_TRAITS_CONJUNCTION_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/conditional.h>
+#include <cuda/std/__type_traits/enable_if.h>
+#include <cuda/std/__type_traits/integral_constant.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class...>
+using __expand_to_true = true_type;
+
+template <class... _Pred>
+_CCCL_HOST_DEVICE __expand_to_true<enable_if_t<_Pred::value>...> __and_helper(int);
+
+template <class...>
+_CCCL_HOST_DEVICE false_type __and_helper(...);
+
+// _And always performs lazy evaluation of its arguments.
+//
+// However, `_And<_Pred...>` itself will evaluate its result immediately (without having to
+// be instantiated) since it is an alias, unlike `conjunction<_Pred...>`, which is a struct.
+// If you want to defer the evaluation of `_And<_Pred...>` itself, use `_Lazy<_And, _Pred...>`.
+template <class... _Pred>
+using _And _CCCL_NODEBUG_ALIAS = decltype(__and_helper<_Pred...>(0));
+
+template <class...>
+struct conjunction : true_type
+{};
+
+template <class _Arg>
+struct conjunction<_Arg> : _Arg
+{};
+
+template <class _Arg, class... _Args>
+struct conjunction<_Arg, _Args...> : _If<!bool(_Arg::value), _Arg, conjunction<_Args...>>
+{};
+
+#if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class... _Args>
+_CCCL_INLINE_VAR constexpr bool conjunction_v = conjunction<_Args...>::value;
+#endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_CONJUNCTION_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__type_traits/copy_cv.h

@@ -0,0 +1,72 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_COPY_CV_H
+#define _LIBCUDACXX___TYPE_TRAITS_COPY_CV_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/copy_cvref.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+// Let COPYCV(FROM, TO) be an alias for type TO with the addition of FROM's
+// top-level cv-qualifiers.
+#ifndef _CCCL_NO_VARIABLE_TEMPLATES
+template <class>
+extern __apply_cvref_ __apply_cv;
+template <class _Tp>
+extern __apply_cvref_c __apply_cv<const _Tp>;
+template <class _Tp>
+extern __apply_cvref_v __apply_cv<volatile _Tp>;
+template <class _Tp>
+extern __apply_cvref_cv __apply_cv<const volatile _Tp>;
+
+template <class _Tp>
+using __apply_cv_fn = decltype(__apply_cv<_Tp>);
+#else // ^^^ !_CCCL_NO_VARIABLE_TEMPLATES / _CCCL_NO_VARIABLE_TEMPLATES vvv
+template <class>
+struct __apply_cv
+{
+  using type _CCCL_NODEBUG_ALIAS = __apply_cvref_;
+};
+template <class _Tp>
+struct __apply_cv<const _Tp>
+{
+  using type _CCCL_NODEBUG_ALIAS = __apply_cvref_c;
+};
+template <class _Tp>
+struct __apply_cv<volatile _Tp>
+{
+  using type _CCCL_NODEBUG_ALIAS = __apply_cvref_v;
+};
+template <class _Tp>
+struct __apply_cv<const volatile _Tp>
+{
+  using type _CCCL_NODEBUG_ALIAS = __apply_cvref_cv;
+};
+
+template <class _Tp>
+using __apply_cv_fn _CCCL_NODEBUG_ALIAS = typename __apply_cv<_Tp>::type;
+#endif // _CCCL_NO_VARIABLE_TEMPLATES
+
+template <class _From, class _To>
+using __copy_cv_t = typename __apply_cv_fn<_From>::template __call<_To>;
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_COPY_CV_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__type_traits/copy_cvref.h

@@ -0,0 +1,210 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_COPY_CVREF_H
+#define _LIBCUDACXX___TYPE_TRAITS_COPY_CVREF_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/add_lvalue_reference.h>
+#include <cuda/std/__type_traits/add_rvalue_reference.h>
+
+#if _CCCL_COMPILER(GCC, <, 7)
+#  define _CCCL_ADD_LVALUE_REFERENCE_WAR(_Tp) add_lvalue_reference_t<_Tp>
+#  define _CCCL_ADD_RVALUE_REFERENCE_WAR(_Tp) add_rvalue_reference_t<_Tp>
+#else
+#  define _CCCL_ADD_LVALUE_REFERENCE_WAR(_Tp) _Tp&
+#  define _CCCL_ADD_RVALUE_REFERENCE_WAR(_Tp) _Tp&&
+#endif
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+struct __apply_cvref_
+{
+  template <class _Tp>
+  using __call _CCCL_NODEBUG_ALIAS = _Tp;
+};
+
+struct __apply_cvref_c
+{
+  template <class _Tp>
+  using __call _CCCL_NODEBUG_ALIAS = const _Tp;
+};
+
+struct __apply_cvref_v
+{
+  template <class _Tp>
+  using __call _CCCL_NODEBUG_ALIAS = volatile _Tp;
+};
+
+struct __apply_cvref_cv
+{
+  template <class _Tp>
+  using __call _CCCL_NODEBUG_ALIAS = const volatile _Tp;
+};
+
+struct __apply_cvref_lr
+{
+  template <class _Tp>
+  using __call _CCCL_NODEBUG_ALIAS = _CCCL_ADD_LVALUE_REFERENCE_WAR(_Tp);
+};
+
+struct __apply_cvref_clr
+{
+  template <class _Tp>
+  using __call _CCCL_NODEBUG_ALIAS = _CCCL_ADD_LVALUE_REFERENCE_WAR(const _Tp);
+};
+
+struct __apply_cvref_vlr
+{
+  template <class _Tp>
+  using __call _CCCL_NODEBUG_ALIAS = _CCCL_ADD_LVALUE_REFERENCE_WAR(volatile _Tp);
+};
+
+struct __apply_cvref_cvlr
+{
+  template <class _Tp>
+  using __call _CCCL_NODEBUG_ALIAS = _CCCL_ADD_LVALUE_REFERENCE_WAR(const volatile _Tp);
+};
+
+struct __apply_cvref_rr
+{
+  template <class _Tp>
+  using __call _CCCL_NODEBUG_ALIAS = _CCCL_ADD_RVALUE_REFERENCE_WAR(_Tp);
+};
+
+struct __apply_cvref_crr
+{
+  template <class _Tp>
+  using __call _CCCL_NODEBUG_ALIAS = _CCCL_ADD_RVALUE_REFERENCE_WAR(const _Tp);
+};
+
+struct __apply_cvref_vrr
+{
+  template <class _Tp>
+  using __call _CCCL_NODEBUG_ALIAS = _CCCL_ADD_RVALUE_REFERENCE_WAR(volatile _Tp);
+};
+
+struct __apply_cvref_cvrr
+{
+  template <class _Tp>
+  using __call _CCCL_NODEBUG_ALIAS = _CCCL_ADD_RVALUE_REFERENCE_WAR(const volatile _Tp);
+};
+
+#ifndef _CCCL_NO_VARIABLE_TEMPLATES
+template <class>
+extern __apply_cvref_ __apply_cvref;
+template <class _Tp>
+extern __apply_cvref_c __apply_cvref<const _Tp>;
+template <class _Tp>
+extern __apply_cvref_v __apply_cvref<volatile _Tp>;
+template <class _Tp>
+extern __apply_cvref_cv __apply_cvref<const volatile _Tp>;
+template <class _Tp>
+extern __apply_cvref_lr __apply_cvref<_Tp&>;
+template <class _Tp>
+extern __apply_cvref_clr __apply_cvref<const _Tp&>;
+template <class _Tp>
+extern __apply_cvref_vlr __apply_cvref<volatile _Tp&>;
+template <class _Tp>
+extern __apply_cvref_cvlr __apply_cvref<const volatile _Tp&>;
+template <class _Tp>
+extern __apply_cvref_rr __apply_cvref<_Tp&&>;
+template <class _Tp>
+extern __apply_cvref_crr __apply_cvref<const _Tp&&>;
+template <class _Tp>
+extern __apply_cvref_vrr __apply_cvref<volatile _Tp&&>;
+template <class _Tp>
+extern __apply_cvref_cvrr __apply_cvref<const volatile _Tp&&>;
+
+template <class _Tp>
+using __apply_cvref_fn = decltype(__apply_cvref<_Tp>);
+#else // ^^^ !_CCCL_NO_VARIABLE_TEMPLATES / _CCCL_NO_VARIABLE_TEMPLATES vvv
+template <class>
+struct __apply_cvref
+{
+  using type _CCCL_NODEBUG_ALIAS = __apply_cvref_;
+};
+template <class _Tp>
+struct __apply_cvref<const _Tp>
+{
+  using type _CCCL_NODEBUG_ALIAS = __apply_cvref_c;
+};
+template <class _Tp>
+struct __apply_cvref<volatile _Tp>
+{
+  using type _CCCL_NODEBUG_ALIAS = __apply_cvref_v;
+};
+template <class _Tp>
+struct __apply_cvref<const volatile _Tp>
+{
+  using type _CCCL_NODEBUG_ALIAS = __apply_cvref_cv;
+};
+template <class _Tp>
+struct __apply_cvref<_Tp&>
+{
+  using type _CCCL_NODEBUG_ALIAS = __apply_cvref_lr;
+};
+template <class _Tp>
+struct __apply_cvref<const _Tp&>
+{
+  using type _CCCL_NODEBUG_ALIAS = __apply_cvref_clr;
+};
+template <class _Tp>
+struct __apply_cvref<volatile _Tp&>
+{
+  using type _CCCL_NODEBUG_ALIAS = __apply_cvref_vlr;
+};
+template <class _Tp>
+struct __apply_cvref<const volatile _Tp&>
+{
+  using type _CCCL_NODEBUG_ALIAS = __apply_cvref_cvlr;
+};
+template <class _Tp>
+struct __apply_cvref<_Tp&&>
+{
+  using type _CCCL_NODEBUG_ALIAS = __apply_cvref_rr;
+};
+template <class _Tp>
+struct __apply_cvref<const _Tp&&>
+{
+  using type _CCCL_NODEBUG_ALIAS = __apply_cvref_crr;
+};
+template <class _Tp>
+struct __apply_cvref<volatile _Tp&&>
+{
+  using type _CCCL_NODEBUG_ALIAS = __apply_cvref_vrr;
+};
+template <class _Tp>
+struct __apply_cvref<const volatile _Tp&&>
+{
+  using type _CCCL_NODEBUG_ALIAS = __apply_cvref_cvrr;
+};
+
+template <class _Tp>
+using __apply_cvref_fn _CCCL_NODEBUG_ALIAS = typename __apply_cvref<_Tp>::type;
+#endif // _CCCL_NO_VARIABLE_TEMPLATES
+
+template <class _From, class _To>
+using __copy_cvref_t = typename __apply_cvref_fn<_From>::template __call<_To>;
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#undef _CCCL_ADD_RVALUE_REFERENCE_WAR
+#undef _CCCL_ADD_LVALUE_REFERENCE_WAR
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_COPY_CVREF_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__type_traits/dependent_type.h

@@ -0,0 +1,31 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_DEPENDENT_TYPE_H
+#define _LIBCUDACXX___TYPE_TRAITS_DEPENDENT_TYPE_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp, bool>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT __dependent_type : public _Tp
+{};
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_DEPENDENT_TYPE_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__type_traits/disjunction.h

@@ -0,0 +1,75 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_DISJUNCTION_H
+#define _LIBCUDACXX___TYPE_TRAITS_DISJUNCTION_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/integral_constant.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <bool>
+struct _OrImpl;
+
+template <>
+struct _OrImpl<true>
+{
+  template <class _Res, class _First, class... _Rest>
+  using _Result _CCCL_NODEBUG_ALIAS =
+    typename _OrImpl<!bool(_First::value) && sizeof...(_Rest) != 0>::template _Result<_First, _Rest...>;
+};
+
+template <>
+struct _OrImpl<false>
+{
+  template <class _Res, class...>
+  using _Result = _Res;
+};
+
+// _Or always performs lazy evaluation of its arguments.
+//
+// However, `_Or<_Pred...>` itself will evaluate its result immediately (without having to
+// be instantiated) since it is an alias, unlike `disjunction<_Pred...>`, which is a struct.
+// If you want to defer the evaluation of `_Or<_Pred...>` itself, use `_Lazy<_Or, _Pred...>`
+// or `disjunction<_Pred...>` directly.
+template <class... _Args>
+using _Or _CCCL_NODEBUG_ALIAS = typename _OrImpl<sizeof...(_Args) != 0>::template _Result<false_type, _Args...>;
+
+#if _CCCL_COMPILER(MSVC)
+template <class... _Args>
+struct disjunction : false_type
+{};
+
+template <class _First, class... _Rest>
+struct disjunction<_First, _Rest...> : _OrImpl<true>::template _Result<false_type, _First, _Rest...>
+{};
+#else
+template <class... _Args>
+struct disjunction : _Or<_Args...>
+{};
+#endif // !_CCCL_COMPILER(MSVC)
+
+#if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class... _Args>
+_CCCL_INLINE_VAR constexpr bool disjunction_v = _Or<_Args...>::value;
+#endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_DISJUNCTION_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__type_traits/enable_if.h

@@ -0,0 +1,39 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_ENABLE_IF_H
+#define _LIBCUDACXX___TYPE_TRAITS_ENABLE_IF_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <bool, class _Tp = void>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT enable_if
+{};
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT enable_if<true, _Tp>
+{
+  typedef _Tp type;
+};
+
+template <bool _Bp, class _Tp = void>
+using enable_if_t _CCCL_NODEBUG_ALIAS = typename enable_if<_Bp, _Tp>::type;
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_ENABLE_IF_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__type_traits/extent.h

@@ -0,0 +1,68 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_EXTENT_H
+#define _LIBCUDACXX___TYPE_TRAITS_EXTENT_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/integral_constant.h>
+#include <cuda/std/cstddef>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if defined(_CCCL_BUILTIN_ARRAY_EXTENT) && !defined(_LIBCUDACXX_USE_ARRAY_EXTENT_FALLBACK)
+
+template <class _Tp, size_t _Dim = 0>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT extent : integral_constant<size_t, _CCCL_BUILTIN_ARRAY_EXTENT(_Tp, _Dim)>
+{};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp, unsigned _Ip = 0>
+_CCCL_INLINE_VAR constexpr size_t extent_v = _CCCL_BUILTIN_ARRAY_EXTENT(_Tp, _Ip);
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#else // ^^^ _CCCL_BUILTIN_ARRAY_EXTENT ^^^ / vvv !_CCCL_BUILTIN_ARRAY_EXTENT vvv
+
+template <class _Tp, unsigned _Ip = 0>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT extent : public integral_constant<size_t, 0>
+{};
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT extent<_Tp[], 0> : public integral_constant<size_t, 0>
+{};
+template <class _Tp, unsigned _Ip>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT extent<_Tp[], _Ip> : public integral_constant<size_t, extent<_Tp, _Ip - 1>::value>
+{};
+template <class _Tp, size_t _Np>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT extent<_Tp[_Np], 0> : public integral_constant<size_t, _Np>
+{};
+template <class _Tp, size_t _Np, unsigned _Ip>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT extent<_Tp[_Np], _Ip>
+    : public integral_constant<size_t, extent<_Tp, _Ip - 1>::value>
+{};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp, unsigned _Ip = 0>
+_CCCL_INLINE_VAR constexpr size_t extent_v = extent<_Tp, _Ip>::value;
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#endif // !_CCCL_BUILTIN_ARRAY_EXTENT
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_EXTENT_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__type_traits/has_unique_object_representation.h

@@ -0,0 +1,45 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_HAS_UNIQUE_OBJECT_REPRESENTATION_H
+#define _LIBCUDACXX___TYPE_TRAITS_HAS_UNIQUE_OBJECT_REPRESENTATION_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/integral_constant.h>
+#include <cuda/std/__type_traits/remove_all_extents.h>
+#include <cuda/std/__type_traits/remove_cv.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if defined(_CCCL_BUILTIN_HAS_UNIQUE_OBJECT_REPRESENTATIONS)
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT has_unique_object_representations
+    : public integral_constant<bool, __has_unique_object_representations(remove_cv_t<remove_all_extents_t<_Tp>>)>
+{};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool has_unique_object_representations_v = has_unique_object_representations<_Tp>::value;
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#endif // _CCCL_BUILTIN_HAS_UNIQUE_OBJECT_REPRESENTATIONS
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_HAS_UNIQUE_OBJECT_REPRESENTATION_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__type_traits/integral_constant.h

@@ -0,0 +1,58 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_INTEGRAL_CONSTANT_H
+#define _LIBCUDACXX___TYPE_TRAITS_INTEGRAL_CONSTANT_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp, _Tp __v>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT integral_constant
+{
+  static constexpr const _Tp value = __v;
+  typedef _Tp value_type;
+  typedef integral_constant type;
+  _LIBCUDACXX_HIDE_FROM_ABI constexpr operator value_type() const noexcept
+  {
+    return value;
+  }
+  _LIBCUDACXX_HIDE_FROM_ABI constexpr value_type operator()() const noexcept
+  {
+    return value;
+  }
+};
+
+template <class _Tp, _Tp __v>
+constexpr const _Tp integral_constant<_Tp, __v>::value;
+
+typedef integral_constant<bool, true> true_type;
+typedef integral_constant<bool, false> false_type;
+
+template <bool _Val>
+using _BoolConstant _LIBCUDACXX_DEPRECATED _CCCL_NODEBUG_ALIAS = integral_constant<bool, _Val>;
+
+template <bool __b>
+using bool_constant = integral_constant<bool, __b>;
+
+// deprecated [Since 2.7.0]
+#define _LIBCUDACXX_BOOL_CONSTANT(__b) bool_constant<(__b)>
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_INTEGRAL_CONSTANT_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__type_traits/is_aggregate.h

@@ -0,0 +1,42 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_AGGREGATE_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_AGGREGATE_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/integral_constant.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if defined(_CCCL_BUILTIN_IS_AGGREGATE)
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_aggregate : public integral_constant<bool, _CCCL_BUILTIN_IS_AGGREGATE(_Tp)>
+{};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_aggregate_v = _CCCL_BUILTIN_IS_AGGREGATE(_Tp);
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#endif // defined(_CCCL_BUILTIN_IS_AGGREGATE)
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_IS_AGGREGATE_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__type_traits/is_arithmetic.h

@@ -0,0 +1,41 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_ARITHMETIC_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_ARITHMETIC_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/integral_constant.h>
+#include <cuda/std/__type_traits/is_floating_point.h>
+#include <cuda/std/__type_traits/is_integral.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_arithmetic
+    : public integral_constant<bool, is_integral<_Tp>::value || is_floating_point<_Tp>::value>
+{};
+
+#if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_arithmetic_v = is_arithmetic<_Tp>::value;
+#endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_IS_ARITHMETIC_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__type_traits/is_base_of.h

@@ -0,0 +1,83 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_BASE_OF_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_BASE_OF_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/enable_if.h>
+#include <cuda/std/__type_traits/integral_constant.h>
+#include <cuda/std/__type_traits/is_class.h>
+#include <cuda/std/__utility/declval.h>
+#include <cuda/std/cstddef>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if defined(_CCCL_BUILTIN_IS_BASE_OF) && !defined(_LIBCUDACXX_USE_IS_BASE_OF_FALLBACK)
+
+template <class _Bp, class _Dp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_base_of : public integral_constant<bool, _CCCL_BUILTIN_IS_BASE_OF(_Bp, _Dp)>
+{};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Bp, class _Dp>
+_CCCL_INLINE_VAR constexpr bool is_base_of_v = _CCCL_BUILTIN_IS_BASE_OF(_Bp, _Dp);
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#else // defined(_CCCL_BUILTIN_IS_BASE_OF) && !defined(_LIBCUDACXX_USE_IS_BASE_OF_FALLBACK)
+
+namespace __is_base_of_imp
+{
+template <class _Tp>
+struct _Dst
+{
+  _LIBCUDACXX_HIDE_FROM_ABI _Dst(const volatile _Tp&);
+};
+template <class _Tp>
+struct _Src
+{
+  _LIBCUDACXX_HIDE_FROM_ABI operator const volatile _Tp&();
+  template <class _Up>
+  _LIBCUDACXX_HIDE_FROM_ABI operator const _Dst<_Up>&();
+};
+template <size_t>
+struct __one
+{
+  typedef char type;
+};
+template <class _Bp, class _Dp>
+_CCCL_HOST_DEVICE typename __one<sizeof(_Dst<_Bp>(_CUDA_VSTD::declval<_Src<_Dp>>()))>::type __test(int);
+template <class _Bp, class _Dp>
+_CCCL_HOST_DEVICE __two __test(...);
+} // namespace __is_base_of_imp
+
+template <class _Bp, class _Dp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_base_of
+    : public integral_constant<bool, is_class<_Bp>::value && sizeof(__is_base_of_imp::__test<_Bp, _Dp>(0)) == 2>
+{};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Bp, class _Dp>
+_CCCL_INLINE_VAR constexpr bool is_base_of_v = is_base_of<_Bp, _Dp>::value;
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#endif // defined(_CCCL_BUILTIN_IS_BASE_OF) && !defined(_LIBCUDACXX_USE_IS_BASE_OF_FALLBACK)
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_IS_BASE_OF_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__type_traits/is_bounded_array.h

@@ -0,0 +1,49 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_BOUNDED_ARRAY_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_BOUNDED_ARRAY_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/integral_constant.h>
+#include <cuda/std/cstddef>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT __cccl_is_bounded_array : false_type
+{};
+template <class _Tp, size_t _Np>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT __cccl_is_bounded_array<_Tp[_Np]> : true_type
+{};
+
+template <class>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_bounded_array : false_type
+{};
+template <class _Tp, size_t _Np>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_bounded_array<_Tp[_Np]> : true_type
+{};
+
+#if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_bounded_array_v = is_bounded_array<_Tp>::value;
+#endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_IS_BOUNDED_ARRAY_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__type_traits/is_callable.h

@@ -0,0 +1,44 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_CALLABLE_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_CALLABLE_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/integral_constant.h>
+#include <cuda/std/__utility/declval.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Func, class... _Args, class = decltype(_CUDA_VSTD::declval<_Func>()(_CUDA_VSTD::declval<_Args>()...))>
+_LIBCUDACXX_HIDE_FROM_ABI true_type __is_callable_helper(int);
+template <class...>
+_LIBCUDACXX_HIDE_FROM_ABI false_type __is_callable_helper(...);
+
+template <class _Func, class... _Args>
+struct __is_callable : decltype(__is_callable_helper<_Func, _Args...>(0))
+{};
+
+#ifndef _CCCL_NO_VARIABLE_TEMPLATES
+template <class _Func, class... _Args>
+_CCCL_INLINE_VAR constexpr bool __is_callable_v = decltype(__is_callable_helper<_Func, _Args...>(0))::value;
+#endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_IS_CALLABLE_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__type_traits/is_class.h

@@ -0,0 +1,68 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_CLASS_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_CLASS_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/integral_constant.h>
+#include <cuda/std/__type_traits/is_union.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+struct __two
+{
+  char __lx[2];
+};
+
+#if defined(_CCCL_BUILTIN_IS_CLASS) && !defined(_LIBCUDACXX_USE_IS_CLASS_FALLBACK)
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_class : public integral_constant<bool, _CCCL_BUILTIN_IS_CLASS(_Tp)>
+{};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_class_v = _CCCL_BUILTIN_IS_CLASS(_Tp);
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#else
+
+namespace __is_class_imp
+{
+template <class _Tp>
+_CCCL_HOST_DEVICE char __test(int _Tp::*);
+template <class _Tp>
+_CCCL_HOST_DEVICE __two __test(...);
+} // namespace __is_class_imp
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_class
+    : public integral_constant<bool, sizeof(__is_class_imp::__test<_Tp>(0)) == 1 && !is_union<_Tp>::value>
+{};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_class_v = is_class<_Tp>::value;
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#endif // defined(_CCCL_BUILTIN_IS_CLASS) && !defined(_LIBCUDACXX_USE_IS_CLASS_FALLBACK)
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_IS_CLASS_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__type_traits/is_constant_evaluated.h

@@ -0,0 +1,47 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_CONSTANT_EVALUATED_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_CONSTANT_EVALUATED_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if defined(_CCCL_BUILTIN_IS_CONSTANT_EVALUATED)
+_LIBCUDACXX_HIDE_FROM_ABI constexpr bool is_constant_evaluated() noexcept
+{
+  return _CCCL_BUILTIN_IS_CONSTANT_EVALUATED();
+}
+_LIBCUDACXX_HIDE_FROM_ABI constexpr bool __cccl_default_is_constant_evaluated() noexcept
+{
+  return _CCCL_BUILTIN_IS_CONSTANT_EVALUATED();
+}
+#else // ^^^ _CCCL_BUILTIN_IS_CONSTANT_EVALUATED ^^^ / vvv !_CCCL_BUILTIN_IS_CONSTANT_EVALUATED vvv
+_LIBCUDACXX_HIDE_FROM_ABI constexpr bool is_constant_evaluated() noexcept
+{
+  return false;
+}
+_LIBCUDACXX_HIDE_FROM_ABI constexpr bool __cccl_default_is_constant_evaluated() noexcept
+{
+  return true;
+}
+#endif // !_CCCL_BUILTIN_IS_CONSTANT_EVALUATED
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_IS_CONSTANT_EVALUATED_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__type_traits/is_core_convertible.h

@@ -0,0 +1,43 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_CORE_CONVERTIBLE_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_CORE_CONVERTIBLE_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/integral_constant.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+// [conv.general]/3 says "E is convertible to T" whenever "T t=E;" is well-formed.
+// We can't test for that, but we can test implicit convertibility by passing it
+// to a function. Notice that __is_core_convertible<void,void> is false,
+// and __is_core_convertible<immovable-type,immovable-type> is true in C++17 and later.
+
+template <class _Tp, class _Up, class = void>
+struct __is_core_convertible : public false_type
+{};
+
+template <class _Tp, class _Up>
+struct __is_core_convertible<_Tp, _Up, decltype(static_cast<void (*)(_Up)>(0)(static_cast<_Tp (*)()>(0)()))>
+    : public true_type
+{};
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_IS_CORE_CONVERTIBLE_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__type_traits/is_default_constructible.h

@@ -0,0 +1,38 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_DEFAULT_CONSTRUCTIBLE_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_DEFAULT_CONSTRUCTIBLE_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/is_constructible.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_default_constructible : public is_constructible<_Tp>
+{};
+
+#if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_default_constructible_v = is_constructible_v<_Tp>;
+#endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_IS_DEFAULT_CONSTRUCTIBLE_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__type_traits/is_destructible.h

@@ -0,0 +1,115 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_DESTRUCTIBLE_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_DESTRUCTIBLE_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/integral_constant.h>
+#include <cuda/std/__type_traits/is_function.h>
+#include <cuda/std/__type_traits/is_reference.h>
+#include <cuda/std/__type_traits/remove_all_extents.h>
+#include <cuda/std/__utility/declval.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if defined(_CCCL_BUILTIN_IS_DESTRUCTIBLE) && !defined(_LIBCUDACXX_USE_IS_DESTRUCTIBLE_FALLBACK)
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_destructible
+    : public integral_constant<bool, _CCCL_BUILTIN_IS_DESTRUCTIBLE(_Tp)>
+{};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_destructible_v = _CCCL_BUILTIN_IS_DESTRUCTIBLE(_Tp);
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#else // ^^^ _CCCL_BUILTIN_IS_DESTRUCTIBLE ^^^ / vvv !_CCCL_BUILTIN_IS_DESTRUCTIBLE vvv
+
+//  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<_Up&>().~_Up()" is well-formed
+//    where _Up is remove_all_extents<_Tp>::type
+
+template <class>
+struct __is_destructible_apply
+{
+  typedef int type;
+};
+
+template <typename _Tp>
+struct __is_destructor_wellformed
+{
+  template <typename _Tp1>
+  _LIBCUDACXX_HIDE_FROM_ABI static true_type
+    __test(typename __is_destructible_apply<decltype(_CUDA_VSTD::declval<_Tp1&>().~_Tp1())>::type);
+
+  template <typename _Tp1>
+  _LIBCUDACXX_HIDE_FROM_ABI static false_type __test(...);
+
+  static const bool value = decltype(__test<_Tp>(12))::value;
+};
+
+template <class _Tp, bool>
+struct __destructible_imp;
+
+template <class _Tp>
+struct __destructible_imp<_Tp, false>
+    : public integral_constant<bool, __is_destructor_wellformed<remove_all_extents_t<_Tp>>::value>
+{};
+
+template <class _Tp>
+struct __destructible_imp<_Tp, true> : public true_type
+{};
+
+template <class _Tp, bool>
+struct __destructible_false;
+
+template <class _Tp>
+struct __destructible_false<_Tp, false> : public __destructible_imp<_Tp, is_reference<_Tp>::value>
+{};
+
+template <class _Tp>
+struct __destructible_false<_Tp, true> : public false_type
+{};
+
+template <class _Tp>
+struct is_destructible : public __destructible_false<_Tp, is_function<_Tp>::value>
+{};
+
+template <class _Tp>
+struct is_destructible<_Tp[]> : public false_type
+{};
+
+template <>
+struct is_destructible<void> : public false_type
+{};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_destructible_v = is_destructible<_Tp>::value;
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#endif // !_CCCL_BUILTIN_IS_DESTRUCTIBLE
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_IS_DESTRUCTIBLE_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__type_traits/is_enum.h

@@ -0,0 +1,68 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_ENUM_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_ENUM_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/integral_constant.h>
+#include <cuda/std/__type_traits/is_array.h>
+#include <cuda/std/__type_traits/is_class.h>
+#include <cuda/std/__type_traits/is_floating_point.h>
+#include <cuda/std/__type_traits/is_function.h>
+#include <cuda/std/__type_traits/is_integral.h>
+#include <cuda/std/__type_traits/is_member_pointer.h>
+#include <cuda/std/__type_traits/is_pointer.h>
+#include <cuda/std/__type_traits/is_reference.h>
+#include <cuda/std/__type_traits/is_union.h>
+#include <cuda/std/__type_traits/is_void.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if defined(_CCCL_BUILTIN_IS_ENUM) && !defined(_LIBCUDACXX_USE_IS_ENUM_FALLBACK)
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_enum : public integral_constant<bool, _CCCL_BUILTIN_IS_ENUM(_Tp)>
+{};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_enum_v = _CCCL_BUILTIN_IS_ENUM(_Tp);
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#else
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_enum
+    : public integral_constant<
+        bool,
+        !is_void<_Tp>::value && !is_integral<_Tp>::value && !is_floating_point<_Tp>::value && !is_array<_Tp>::value
+          && !is_pointer<_Tp>::value && !is_reference<_Tp>::value && !is_member_pointer<_Tp>::value
+          && !is_union<_Tp>::value && !is_class<_Tp>::value && !is_function<_Tp>::value>
+{};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_enum_v = is_enum<_Tp>::value;
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#endif // defined(_CCCL_BUILTIN_IS_ENUM) && !defined(_LIBCUDACXX_USE_IS_ENUM_FALLBACK)
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_IS_ENUM_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__type_traits/is_extended_floating_point.h

@@ -0,0 +1,96 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2024 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_EXTENDED_FLOATING_POINT_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_EXTENDED_FLOATING_POINT_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/integral_constant.h>
+
+#if defined(_CCCL_HAS_NVFP16)
+#  include <cuda_fp16.h>
+#endif // _CCCL_HAS_NVFP16
+
+#if defined(_CCCL_HAS_NVBF16)
+_CCCL_DIAG_PUSH
+_CCCL_DIAG_SUPPRESS_CLANG("-Wunused-function")
+#  include <cuda_bf16.h>
+_CCCL_DIAG_POP
+#endif // _CCCL_HAS_NVBF16
+
+#if _CCCL_HAS_NVFP8()
+#  include <cuda_fp8.h>
+#endif // _CCCL_HAS_NVFP8()
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+struct __is_extended_floating_point : false_type
+{};
+
+#if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool __is_extended_floating_point_v
+#  if defined(_CCCL_NO_INLINE_VARIABLES)
+  = __is_extended_floating_point<_Tp>::value;
+#  else // ^^^ _CCCL_NO_INLINE_VARIABLES ^^^ / vvv !_CCCL_NO_INLINE_VARIABLES vvv
+  = false;
+#  endif // !_CCCL_NO_INLINE_VARIABLES
+#endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#if defined(_CCCL_HAS_NVFP16)
+template <>
+struct __is_extended_floating_point<__half> : true_type
+{};
+
+#  ifndef _CCCL_NO_INLINE_VARIABLES
+template <>
+_CCCL_INLINE_VAR constexpr bool __is_extended_floating_point_v<__half> = true;
+#  endif // !_CCCL_NO_INLINE_VARIABLES
+#endif // _CCCL_HAS_NVFP16
+
+#if defined(_CCCL_HAS_NVBF16)
+template <>
+struct __is_extended_floating_point<__nv_bfloat16> : true_type
+{};
+
+#  ifndef _CCCL_NO_INLINE_VARIABLES
+template <>
+_CCCL_INLINE_VAR constexpr bool __is_extended_floating_point_v<__nv_bfloat16> = true;
+#  endif // !_CCCL_NO_INLINE_VARIABLES
+#endif // _CCCL_HAS_NVBF16
+
+#if _CCCL_HAS_NVFP8()
+template <>
+struct __is_extended_floating_point<__nv_fp8_e4m3> : true_type
+{};
+template <>
+struct __is_extended_floating_point<__nv_fp8_e5m2> : true_type
+{};
+
+#  ifndef _CCCL_NO_INLINE_VARIABLES
+template <>
+_CCCL_INLINE_VAR constexpr bool __is_extended_floating_point_v<__nv_fp8_e4m3> = true;
+template <>
+_CCCL_INLINE_VAR constexpr bool __is_extended_floating_point_v<__nv_fp8_e5m2> = true;
+#  endif // !_CCCL_NO_INLINE_VARIABLES
+#endif // _CCCL_HAS_NVFP8()
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_IS_EXTENDED_FLOATING_POINT_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__type_traits/is_implicitly_default_constructible.h

@@ -0,0 +1,53 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_IMPLICITLY_DEFAULT_CONSTRUCTIBLE_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_IMPLICITLY_DEFAULT_CONSTRUCTIBLE_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/integral_constant.h>
+#include <cuda/std/__type_traits/is_default_constructible.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+// First of all, we can't implement this check in C++03 mode because the {}
+// default initialization syntax isn't valid.
+// Second, we implement the trait in a funny manner with two defaulted template
+// arguments to workaround Clang's PR43454.
+template <class _Tp>
+_LIBCUDACXX_HIDE_FROM_ABI void __test_implicit_default_constructible(_Tp);
+
+template <class _Tp, class = void, class = typename is_default_constructible<_Tp>::type>
+struct __is_implicitly_default_constructible : false_type
+{};
+
+template <class _Tp>
+struct __is_implicitly_default_constructible<_Tp,
+                                             decltype(__test_implicit_default_constructible<_Tp const&>({})),
+                                             true_type> : true_type
+{};
+
+template <class _Tp>
+struct __is_implicitly_default_constructible<_Tp,
+                                             decltype(__test_implicit_default_constructible<_Tp const&>({})),
+                                             false_type> : false_type
+{};
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_IS_IMPLICITLY_DEFAULT_CONSTRUCTIBLE_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__type_traits/is_member_function_pointer.h

@@ -0,0 +1,79 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_MEMBER_FUNCTION_POINTER_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_MEMBER_FUNCTION_POINTER_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/integral_constant.h>
+#include <cuda/std/__type_traits/is_function.h>
+#include <cuda/std/__type_traits/remove_cv.h>
+#include <cuda/std/cstddef>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+struct __cccl_is_member_pointer
+{
+  enum
+  {
+    __is_member = false,
+    __is_func   = false,
+    __is_obj    = false
+  };
+};
+template <class _Tp, class _Up>
+struct __cccl_is_member_pointer<_Tp _Up::*>
+{
+  enum
+  {
+    __is_member = true,
+    __is_func   = is_function<_Tp>::value,
+    __is_obj    = !__is_func,
+  };
+};
+
+#if defined(_CCCL_BUILTIN_IS_MEMBER_FUNCTION_POINTER) && !defined(_LIBCUDACXX_USE_IS_MEMBER_FUNCTION_POINTER_FALLBACK)
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_member_function_pointer
+    : public integral_constant<bool, _CCCL_BUILTIN_IS_MEMBER_FUNCTION_POINTER(_Tp)>
+{};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_member_function_pointer_v = _CCCL_BUILTIN_IS_MEMBER_FUNCTION_POINTER(_Tp);
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#else // ^^^ _CCCL_BUILTIN_IS_MEMBER_FUNCTION_POINTER ^^^ / vvv !_CCCL_BUILTIN_IS_MEMBER_FUNCTION_POINTER vvv
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_member_function_pointer
+    : public integral_constant<bool, __cccl_is_member_pointer<remove_cv_t<_Tp>>::__is_func>
+{};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_member_function_pointer_v = is_member_function_pointer<_Tp>::value;
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#endif // !_CCCL_BUILTIN_IS_MEMBER_FUNCTION_POINTER
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_IS_MEMBER_FUNCTION_POINTER_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__type_traits/is_member_pointer.h

@@ -0,0 +1,57 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_MEMBER_POINTER_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_MEMBER_POINTER_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/integral_constant.h>
+#include <cuda/std/__type_traits/is_member_function_pointer.h>
+#include <cuda/std/__type_traits/remove_cv.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if defined(_CCCL_BUILTIN_IS_MEMBER_POINTER) && !defined(_LIBCUDACXX_USE_IS_MEMBER_POINTER_FALLBACK)
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_member_pointer
+    : public integral_constant<bool, _CCCL_BUILTIN_IS_MEMBER_POINTER(_Tp)>
+{};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_member_pointer_v = _CCCL_BUILTIN_IS_MEMBER_POINTER(_Tp);
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#else // ^^^ _CCCL_BUILTIN_IS_MEMBER_POINTER ^^^ / vvv !_CCCL_BUILTIN_IS_MEMBER_POINTER vvv
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_member_pointer
+    : public integral_constant<bool, __cccl_is_member_pointer<remove_cv_t<_Tp>>::__is_member>
+{};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_member_pointer_v = is_member_pointer<_Tp>::value;
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#endif // !_CCCL_BUILTIN_IS_MEMBER_POINTER
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_IS_MEMBER_POINTER_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__type_traits/is_move_constructible.h

@@ -0,0 +1,40 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_MOVE_CONSTRUCTIBLE_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_MOVE_CONSTRUCTIBLE_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/add_lvalue_reference.h>
+#include <cuda/std/__type_traits/add_rvalue_reference.h>
+#include <cuda/std/__type_traits/is_constructible.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_move_constructible : public is_constructible<_Tp, add_rvalue_reference_t<_Tp>>
+{};
+
+#if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_move_constructible_v = is_move_constructible<_Tp>::value;
+#endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_IS_MOVE_CONSTRUCTIBLE_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__type_traits/is_nothrow_constructible.h

@@ -0,0 +1,84 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_NOTHROW_CONSTRUCTIBLE_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_NOTHROW_CONSTRUCTIBLE_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/integral_constant.h>
+#include <cuda/std/__type_traits/is_constructible.h>
+#include <cuda/std/__type_traits/is_scalar.h>
+#include <cuda/std/__utility/declval.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if defined(_CCCL_BUILTIN_IS_NOTHROW_CONSTRUCTIBLE) && !defined(_LIBCUDACXX_USE_IS_NOTHROW_CONSTRUCTIBLE_FALLBACK)
+
+template <class _Tp, class... _Args>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_nothrow_constructible
+    : public integral_constant<bool, _CCCL_BUILTIN_IS_NOTHROW_CONSTRUCTIBLE(_Tp, _Args...)>
+{};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp, class... _Args>
+_CCCL_INLINE_VAR constexpr bool is_nothrow_constructible_v = _CCCL_BUILTIN_IS_NOTHROW_CONSTRUCTIBLE(_Tp, _Args...);
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#else
+
+template <bool, bool, class _Tp, class... _Args>
+struct __cccl_is_nothrow_constructible;
+
+template <class _Tp, class... _Args>
+struct __cccl_is_nothrow_constructible</*is constructible*/ true, /*is reference*/ false, _Tp, _Args...>
+    : public integral_constant<bool, noexcept(_Tp(_CUDA_VSTD::declval<_Args>()...))>
+{};
+
+template <class _Tp>
+_LIBCUDACXX_HIDE_FROM_ABI void __implicit_conversion_to(_Tp) noexcept
+{}
+
+template <class _Tp, class _Arg>
+struct __cccl_is_nothrow_constructible</*is constructible*/ true, /*is reference*/ true, _Tp, _Arg>
+    : public integral_constant<bool, noexcept(__implicit_conversion_to<_Tp>(_CUDA_VSTD::declval<_Arg>()))>
+{};
+
+template <class _Tp, bool _IsReference, class... _Args>
+struct __cccl_is_nothrow_constructible</*is constructible*/ false, _IsReference, _Tp, _Args...> : public false_type
+{};
+
+template <class _Tp, class... _Args>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_nothrow_constructible
+    : __cccl_is_nothrow_constructible<is_constructible<_Tp, _Args...>::value, is_reference<_Tp>::value, _Tp, _Args...>
+{};
+
+template <class _Tp, size_t _Ns>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_nothrow_constructible<_Tp[_Ns]>
+    : __cccl_is_nothrow_constructible<is_constructible<_Tp>::value, is_reference<_Tp>::value, _Tp>
+{};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp, class... _Args>
+_CCCL_INLINE_VAR constexpr bool is_nothrow_constructible_v = is_nothrow_constructible<_Tp, _Args...>::value;
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#endif // defined(_CCCL_BUILTIN_IS_NOTHROW_CONSTRUCTIBLE) && !defined(_LIBCUDACXX_USE_IS_NOTHROW_CONSTRUCTIBLE_FALLBACK)
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_IS_NOTHROW_CONSTRUCTIBLE_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__type_traits/is_nothrow_convertible.h

@@ -0,0 +1,57 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_NOTHROW_CONVERTIBLE_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_NOTHROW_CONVERTIBLE_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/conjunction.h>
+#include <cuda/std/__type_traits/disjunction.h>
+#include <cuda/std/__type_traits/integral_constant.h>
+#include <cuda/std/__type_traits/is_convertible.h>
+#include <cuda/std/__type_traits/is_void.h>
+#include <cuda/std/__type_traits/lazy.h>
+#include <cuda/std/__utility/declval.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <typename _Tp>
+_CCCL_HOST_DEVICE static void __test_noexcept(_Tp) noexcept;
+
+template <typename _Fm, typename _To>
+_CCCL_HOST_DEVICE static bool_constant<noexcept(_CUDA_VSTD::__test_noexcept<_To>(_CUDA_VSTD::declval<_Fm>()))>
+__is_nothrow_convertible_test();
+
+template <typename _Fm, typename _To>
+struct __is_nothrow_convertible_helper : decltype(__is_nothrow_convertible_test<_Fm, _To>())
+{};
+
+template <typename _Fm, typename _To>
+struct is_nothrow_convertible
+    : _Or<_And<is_void<_To>, is_void<_Fm>>,
+          _Lazy<_And, is_convertible<_Fm, _To>, __is_nothrow_convertible_helper<_Fm, _To>>>::type
+{};
+
+#if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <typename _Fm, typename _To>
+_CCCL_INLINE_VAR constexpr bool is_nothrow_convertible_v = is_nothrow_convertible<_Fm, _To>::value;
+#endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_IS_NOTHROW_CONVERTIBLE_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__type_traits/is_nothrow_copy_assignable.h

@@ -0,0 +1,60 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_NOTHROW_COPY_ASSIGNABLE_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_NOTHROW_COPY_ASSIGNABLE_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/add_const.h>
+#include <cuda/std/__type_traits/add_lvalue_reference.h>
+#include <cuda/std/__type_traits/is_nothrow_assignable.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if defined(_CCCL_BUILTIN_IS_NOTHROW_ASSIGNABLE) && !defined(_LIBCUDACXX_USE_IS_NOTHROW_ASSIGNABLE_FALLBACK)
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_nothrow_copy_assignable
+    : public integral_constant<bool,
+                               _CCCL_BUILTIN_IS_NOTHROW_ASSIGNABLE(
+                                 add_lvalue_reference_t<_Tp>, add_lvalue_reference_t<typename add_const<_Tp>::type>)>
+{};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_nothrow_copy_assignable_v = _CCCL_BUILTIN_IS_NOTHROW_ASSIGNABLE(
+  add_lvalue_reference_t<_Tp>, add_lvalue_reference_t<typename add_const<_Tp>::type>);
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#else
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_nothrow_copy_assignable
+    : public is_nothrow_assignable<add_lvalue_reference_t<_Tp>, add_lvalue_reference_t<typename add_const<_Tp>::type>>
+{};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_nothrow_copy_assignable_v = is_nothrow_copy_assignable<_Tp>::value;
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#endif
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_IS_NOTHROW_COPY_ASSIGNABLE_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__type_traits/is_nothrow_copy_constructible.h

@@ -0,0 +1,41 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_NOTHROW_COPY_CONSTRUCTIBLE_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_NOTHROW_COPY_CONSTRUCTIBLE_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/add_const.h>
+#include <cuda/std/__type_traits/add_lvalue_reference.h>
+#include <cuda/std/__type_traits/is_nothrow_constructible.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_nothrow_copy_constructible
+    : public is_nothrow_constructible<_Tp, add_lvalue_reference_t<typename add_const<_Tp>::type>>
+{};
+
+#if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_nothrow_copy_constructible_v = is_nothrow_copy_constructible<_Tp>::value;
+#endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_IS_NOTHROW_COPY_CONSTRUCTIBLE_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__type_traits/is_nothrow_move_constructible.h

@@ -0,0 +1,40 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_NOTHROW_MOVE_CONSTRUCTIBLE_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_NOTHROW_MOVE_CONSTRUCTIBLE_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/add_rvalue_reference.h>
+#include <cuda/std/__type_traits/is_nothrow_constructible.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_nothrow_move_constructible
+    : public is_nothrow_constructible<_Tp, add_rvalue_reference_t<_Tp>>
+{};
+
+#if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_nothrow_move_constructible_v = is_nothrow_move_constructible<_Tp>::value;
+#endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_IS_NOTHROW_MOVE_CONSTRUCTIBLE_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__type_traits/is_null_pointer.h

@@ -0,0 +1,51 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_NULL_POINTER_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_NULL_POINTER_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/integral_constant.h>
+#include <cuda/std/__type_traits/remove_cv.h>
+#include <cuda/std/cstddef>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+struct __is_nullptr_t_impl : public false_type
+{};
+template <>
+struct __is_nullptr_t_impl<nullptr_t> : public true_type
+{};
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT __is_nullptr_t : public __is_nullptr_t_impl<remove_cv_t<_Tp>>
+{};
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_null_pointer : public __is_nullptr_t_impl<remove_cv_t<_Tp>>
+{};
+
+#if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_null_pointer_v = is_null_pointer<_Tp>::value;
+#endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_IS_NULL_POINTER_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__type_traits/is_object.h

@@ -0,0 +1,60 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_OBJECT_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_OBJECT_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/integral_constant.h>
+#include <cuda/std/__type_traits/is_array.h>
+#include <cuda/std/__type_traits/is_class.h>
+#include <cuda/std/__type_traits/is_scalar.h>
+#include <cuda/std/__type_traits/is_union.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if defined(_CCCL_BUILTIN_IS_OBJECT) && !defined(_LIBCUDACXX_USE_IS_OBJECT_FALLBACK)
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_object : public integral_constant<bool, _CCCL_BUILTIN_IS_OBJECT(_Tp)>
+{};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_object_v = _CCCL_BUILTIN_IS_OBJECT(_Tp);
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#else
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_object
+    : public integral_constant<bool,
+                               is_scalar<_Tp>::value || is_array<_Tp>::value || is_union<_Tp>::value
+                                 || is_class<_Tp>::value>
+{};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_object_v = is_object<_Tp>::value;
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#endif // defined(_CCCL_BUILTIN_IS_OBJECT) && !defined(_LIBCUDACXX_USE_IS_OBJECT_FALLBACK)
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_IS_OBJECT_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__type_traits/is_pod.h

@@ -0,0 +1,62 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_POD_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_POD_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/integral_constant.h>
+#include <cuda/std/__type_traits/is_trivially_copy_assignable.h>
+#include <cuda/std/__type_traits/is_trivially_copy_constructible.h>
+#include <cuda/std/__type_traits/is_trivially_default_constructible.h>
+#include <cuda/std/__type_traits/is_trivially_destructible.h>
+#include <cuda/std/cstddef>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if defined(_CCCL_BUILTIN_IS_POD) && !defined(_LIBCUDACXX_USE_IS_POD_FALLBACK)
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_pod : public integral_constant<bool, _CCCL_BUILTIN_IS_POD(_Tp)>
+{};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_pod_v = _CCCL_BUILTIN_IS_POD(_Tp);
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#else
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_pod
+    : public integral_constant<
+        bool,
+        is_trivially_default_constructible<_Tp>::value && is_trivially_copy_constructible<_Tp>::value
+          && is_trivially_copy_assignable<_Tp>::value && is_trivially_destructible<_Tp>::value>
+{};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_pod_v = is_pod<_Tp>::value;
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#endif // defined(_CCCL_BUILTIN_IS_POD) && !defined(_LIBCUDACXX_USE_IS_POD_FALLBACK)
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_IS_POD_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__type_traits/is_primary_template.h

@@ -0,0 +1,50 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_PRIMARY_TEMPLATE_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_PRIMARY_TEMPLATE_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/enable_if.h>
+#include <cuda/std/__type_traits/is_same.h>
+#include <cuda/std/__type_traits/is_valid_expansion.h>
+#include <cuda/std/__type_traits/void_t.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if _CCCL_COMPILER(MSVC)
+template <class _Tp, class = void>
+struct __is_primary_template : false_type
+{};
+
+template <class _Tp>
+struct __is_primary_template<_Tp, void_t<typename _Tp::__primary_template>>
+    : public is_same<_Tp, typename _Tp::__primary_template>
+{};
+
+#else // ^^^ _CCCL_COMPILER(MSVC) ^^^ / vvv !_CCCL_COMPILER(MSVC) vvv
+
+template <class _Tp>
+using __test_for_primary_template = enable_if_t<_IsSame<_Tp, typename _Tp::__primary_template>::value>;
+template <class _Tp>
+using __is_primary_template = _IsValidExpansion<__test_for_primary_template, _Tp>;
+#endif // !_CCCL_COMPILER(MSVC)
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_IS_PRIMARY_TEMPLATE_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__type_traits/is_reference.h

@@ -0,0 +1,95 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_REFERENCE_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_REFERENCE_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/integral_constant.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if defined(_CCCL_BUILTIN_IS_LVALUE_REFERENCE) && !defined(_LIBCUDACXX_USE_IS_LVALUE_REFERENCE_FALLBACK)  \
+  && defined(_CCCL_BUILTIN_IS_RVALUE_REFERENCE) && !defined(_LIBCUDACXX_USE_IS_RVALUE_REFERENCE_FALLBACK) \
+  && defined(_CCCL_BUILTIN_IS_REFERENCE) && !defined(_LIBCUDACXX_USE_IS_REFERENCE_FALLBACK)
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_lvalue_reference
+    : public integral_constant<bool, _CCCL_BUILTIN_IS_LVALUE_REFERENCE(_Tp)>
+{};
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_rvalue_reference
+    : public integral_constant<bool, _CCCL_BUILTIN_IS_RVALUE_REFERENCE(_Tp)>
+{};
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_reference : public integral_constant<bool, _CCCL_BUILTIN_IS_REFERENCE(_Tp)>
+{};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_lvalue_reference_v = _CCCL_BUILTIN_IS_LVALUE_REFERENCE(_Tp);
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_rvalue_reference_v = _CCCL_BUILTIN_IS_RVALUE_REFERENCE(_Tp);
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_reference_v = _CCCL_BUILTIN_IS_REFERENCE(_Tp);
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#else
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_lvalue_reference : public false_type
+{};
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_lvalue_reference<_Tp&> : public true_type
+{};
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_rvalue_reference : public false_type
+{};
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_rvalue_reference<_Tp&&> : public true_type
+{};
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_reference : public false_type
+{};
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_reference<_Tp&> : public true_type
+{};
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_reference<_Tp&&> : public true_type
+{};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_lvalue_reference_v = is_lvalue_reference<_Tp>::value;
+
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_rvalue_reference_v = is_rvalue_reference<_Tp>::value;
+
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_reference_v = is_reference<_Tp>::value;
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#endif // !_CCCL_BUILTIN_IS_LVALUE_REFERENCE
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_IS_REFERENCE_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__type_traits/is_reference_wrapper.h

@@ -0,0 +1,43 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_REFERENCE_WRAPPER_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_REFERENCE_WRAPPER_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/integral_constant.h>
+#include <cuda/std/__type_traits/remove_cv.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+class _CCCL_TYPE_VISIBILITY_DEFAULT reference_wrapper;
+
+template <class _Tp>
+struct __is_reference_wrapper_impl : public false_type
+{};
+template <class _Tp>
+struct __is_reference_wrapper_impl<reference_wrapper<_Tp>> : public true_type
+{};
+template <class _Tp>
+struct __is_reference_wrapper : public __is_reference_wrapper_impl<remove_cv_t<_Tp>>
+{};
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_ENABLE_IF_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__type_traits/is_scalar.h

@@ -0,0 +1,75 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_SCALAR_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_SCALAR_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/integral_constant.h>
+#include <cuda/std/__type_traits/is_arithmetic.h>
+#include <cuda/std/__type_traits/is_enum.h>
+#include <cuda/std/__type_traits/is_member_pointer.h>
+#include <cuda/std/__type_traits/is_null_pointer.h>
+#include <cuda/std/__type_traits/is_pointer.h>
+#include <cuda/std/cstddef>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if defined(_CCCL_BUILTIN_IS_SCALAR) && !defined(_LIBCUDACXX_USE_IS_SCALAR_FALLBACK)
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_scalar : public integral_constant<bool, _CCCL_BUILTIN_IS_SCALAR(_Tp)>
+{};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_scalar_v = _CCCL_BUILTIN_IS_SCALAR(_Tp);
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#else
+
+template <class _Tp>
+struct __is_block : false_type
+{};
+#  if defined(_LIBCUDACXX_HAS_EXTENSION_BLOCKS)
+template <class _Rp, class... _Args>
+struct __is_block<_Rp (^)(_Args...)> : true_type
+{};
+#  endif
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_scalar
+    : public integral_constant<bool,
+                               is_arithmetic<_Tp>::value || is_member_pointer<_Tp>::value || is_pointer<_Tp>::value
+                                 || __is_nullptr_t<_Tp>::value || __is_block<_Tp>::value || is_enum<_Tp>::value>
+{};
+
+template <>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_scalar<nullptr_t> : public true_type
+{};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_scalar_v = is_scalar<_Tp>::value;
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#endif // defined(_CCCL_BUILTIN_IS_SCALAR) && !defined(_LIBCUDACXX_USE_IS_SCALAR_FALLBACK)
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_IS_SCALAR_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__type_traits/is_signed.h

@@ -0,0 +1,75 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_SIGNED_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_SIGNED_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/integral_constant.h>
+#include <cuda/std/__type_traits/is_arithmetic.h>
+
+_CCCL_DIAG_PUSH
+_CCCL_DIAG_SUPPRESS_MSVC(4197) //  top-level volatile in cast is ignored
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if defined(_CCCL_BUILTIN_IS_SIGNED) && !defined(_LIBCUDACXX_USE_IS_SIGNED_FALLBACK)
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_signed : public integral_constant<bool, _CCCL_BUILTIN_IS_SIGNED(_Tp)>
+{};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_signed_v = _CCCL_BUILTIN_IS_SIGNED(_Tp);
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#else
+
+template <class _Tp, bool = is_integral<_Tp>::value>
+struct __cccl_is_signed_impl : public bool_constant<(_Tp(-1) < _Tp(0))>
+{};
+
+template <class _Tp>
+struct __cccl_is_signed_impl<_Tp, false> : public true_type
+{}; // floating point
+
+template <class _Tp, bool = is_arithmetic<_Tp>::value>
+struct __cccl_is_signed : public __cccl_is_signed_impl<_Tp>
+{};
+
+template <class _Tp>
+struct __cccl_is_signed<_Tp, false> : public false_type
+{};
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_signed : public __cccl_is_signed<_Tp>
+{};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_signed_v = is_signed<_Tp>::value;
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#endif // defined(_CCCL_BUILTIN_IS_SIGNED) && !defined(_LIBCUDACXX_USE_IS_SIGNED_FALLBACK)
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+_CCCL_DIAG_POP
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_IS_SIGNED_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__type_traits/is_standard_layout.h

@@ -0,0 +1,57 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_STANDARD_LAYOUT_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_STANDARD_LAYOUT_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/integral_constant.h>
+#include <cuda/std/__type_traits/is_scalar.h>
+#include <cuda/std/__type_traits/remove_all_extents.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if defined(_CCCL_BUILTIN_IS_STANDARD_LAYOUT) && !defined(_LIBCUDACXX_USE_IS_STANDARD_LAYOUT_FALLBACK)
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_standard_layout
+    : public integral_constant<bool, _CCCL_BUILTIN_IS_STANDARD_LAYOUT(_Tp)>
+{};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_standard_layout_v = _CCCL_BUILTIN_IS_STANDARD_LAYOUT(_Tp);
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#else
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_standard_layout
+    : integral_constant<bool, is_scalar<remove_all_extents_t<_Tp>>::value>
+{};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_standard_layout_v = is_standard_layout<_Tp>::value;
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#endif // defined(_CCCL_BUILTIN_IS_STANDARD_LAYOUT) && !defined(_LIBCUDACXX_USE_IS_STANDARD_LAYOUT_FALLBACK)
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_IS_STANDARD_LAYOUT_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__type_traits/is_swappable.h

@@ -0,0 +1,203 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_SWAPPABLE_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_SWAPPABLE_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/add_lvalue_reference.h>
+#include <cuda/std/__type_traits/conditional.h>
+#include <cuda/std/__type_traits/disjunction.h>
+#include <cuda/std/__type_traits/enable_if.h>
+#include <cuda/std/__type_traits/is_move_assignable.h>
+#include <cuda/std/__type_traits/is_move_constructible.h>
+#include <cuda/std/__type_traits/is_nothrow_move_assignable.h>
+#include <cuda/std/__type_traits/is_nothrow_move_constructible.h>
+#include <cuda/std/__type_traits/is_referenceable.h>
+#include <cuda/std/__type_traits/is_same.h>
+#include <cuda/std/__type_traits/is_void.h>
+#include <cuda/std/__type_traits/nat.h>
+#include <cuda/std/__type_traits/type_identity.h>
+#include <cuda/std/__utility/declval.h>
+#include <cuda/std/cstddef>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+// We need to detect whether there is already a free function swap that would end up being ambiguous.
+// This can happen when a type pulls in both namespace std and namespace cuda::std via ADL.
+// In that case we are always safe to just not do anything because that type must be host only.
+// However, we must be careful to ensure that we still create the overload if there is just a hidden friend swap
+namespace __detect_hidden_friend_swap
+{
+// This will intentionally create an ambiguity with std::swap if that is find-able by ADL. But it will not interfere
+// with hidden friend swap
+template <class _Tp>
+_CCCL_HOST_DEVICE void swap(_Tp&, _Tp&);
+
+struct __hidden_friend_swap_found
+{};
+
+template <class _Tp>
+_LIBCUDACXX_HIDE_FROM_ABI auto __swap(_Tp& __lhs, _Tp& __rhs) -> decltype(swap(__lhs, __rhs));
+_LIBCUDACXX_HIDE_FROM_ABI auto __swap(...) -> __hidden_friend_swap_found;
+template <class _Tp>
+struct __has_hidden_friend_swap
+    : is_same<decltype(__detect_hidden_friend_swap::__swap(_CUDA_VSTD::declval<_Tp&>(), _CUDA_VSTD::declval<_Tp&>())),
+              void>
+{};
+} // namespace __detect_hidden_friend_swap
+
+namespace __detect_adl_swap
+{
+
+template <class _Tp>
+void swap(_Tp&, _Tp&) = delete;
+
+struct __no_adl_swap_found
+{};
+template <class _Tp>
+_LIBCUDACXX_HIDE_FROM_ABI auto __swap(_Tp& __lhs, _Tp& __rhs) -> decltype(swap(__lhs, __rhs));
+_LIBCUDACXX_HIDE_FROM_ABI auto __swap(...) -> __no_adl_swap_found;
+template <class _Tp>
+struct __has_no_adl_swap
+    : is_same<decltype(__detect_adl_swap::__swap(_CUDA_VSTD::declval<_Tp&>(), _CUDA_VSTD::declval<_Tp&>())),
+              __no_adl_swap_found>
+{};
+template <class _Tp, size_t _Np>
+struct __has_no_adl_swap_array
+    : is_same<
+        decltype(__detect_adl_swap::__swap(_CUDA_VSTD::declval<_Tp (&)[_Np]>(), _CUDA_VSTD::declval<_Tp (&)[_Np]>())),
+        __no_adl_swap_found>
+{};
+
+// We should only define swap if there is no ADL found function or it is a hidden friend
+template <class _Tp>
+struct __can_define_swap : _Or<__has_no_adl_swap<_Tp>, __detect_hidden_friend_swap::__has_hidden_friend_swap<_Tp>>
+{};
+} // namespace __detect_adl_swap
+
+template <class _Tp>
+struct __is_swappable;
+template <class _Tp>
+struct __is_nothrow_swappable;
+
+template <class _Tp>
+using __swap_result_t _CCCL_NODEBUG_ALIAS =
+  enable_if_t<__detect_adl_swap::__can_define_swap<_Tp>::value && _CCCL_TRAIT(is_move_constructible, _Tp)
+              && _CCCL_TRAIT(is_move_assignable, _Tp)>;
+
+// we use type_identity_t<_Tp> as second parameter, to avoid ambiguity with std::swap, which will thus be preferred by
+// overload resolution (which is ok since std::swap is only considered when explicitly called, or found by ADL for types
+// from std::)
+template <class _Tp>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX14 __swap_result_t<_Tp> swap(_Tp& __x, type_identity_t<_Tp>& __y) noexcept(
+  _CCCL_TRAIT(is_nothrow_move_constructible, _Tp) && _CCCL_TRAIT(is_nothrow_move_assignable, _Tp));
+
+template <class _Tp, size_t _Np>
+_LIBCUDACXX_HIDE_FROM_ABI _CCCL_CONSTEXPR_CXX14
+enable_if_t<__detect_adl_swap::__has_no_adl_swap_array<_Tp, _Np>::value && __is_swappable<_Tp>::value>
+  swap(_Tp (&__a)[_Np], _Tp (&__b)[_Np]) noexcept(__is_nothrow_swappable<_Tp>::value);
+
+namespace __detail
+{
+// ALL generic swap overloads MUST already have a declaration available at this point.
+
+template <class _Tp, class _Up = _Tp, bool _NotVoid = !_CCCL_TRAIT(is_void, _Tp) && !_CCCL_TRAIT(is_void, _Up)>
+struct __swappable_with
+{
+  template <class _LHS, class _RHS>
+  _LIBCUDACXX_HIDE_FROM_ABI static decltype(swap(_CUDA_VSTD::declval<_LHS>(), _CUDA_VSTD::declval<_RHS>()))
+  __test_swap(int);
+  template <class, class>
+  _LIBCUDACXX_HIDE_FROM_ABI static __nat __test_swap(long);
+
+  // Extra parens are needed for the C++03 definition of decltype.
+  typedef decltype((__test_swap<_Tp, _Up>(0))) __swap1;
+  typedef decltype((__test_swap<_Up, _Tp>(0))) __swap2;
+
+  static const bool value = _IsNotSame<__swap1, __nat>::value && _IsNotSame<__swap2, __nat>::value;
+};
+
+template <class _Tp, class _Up>
+struct __swappable_with<_Tp, _Up, false> : false_type
+{};
+
+template <class _Tp, class _Up = _Tp, bool _Swappable = __swappable_with<_Tp, _Up>::value>
+struct __nothrow_swappable_with
+{
+  static const bool value = noexcept(swap(_CUDA_VSTD::declval<_Tp>(), _CUDA_VSTD::declval<_Up>()))
+                         && noexcept(swap(_CUDA_VSTD::declval<_Up>(), _CUDA_VSTD::declval<_Tp>()));
+};
+
+template <class _Tp, class _Up>
+struct __nothrow_swappable_with<_Tp, _Up, false> : false_type
+{};
+
+} // namespace __detail
+
+template <class _Tp>
+struct __is_swappable : public integral_constant<bool, __detail::__swappable_with<_Tp&>::value>
+{};
+
+template <class _Tp>
+struct __is_nothrow_swappable : public integral_constant<bool, __detail::__nothrow_swappable_with<_Tp&>::value>
+{};
+
+#if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+
+template <class _Tp, class _Up>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_swappable_with
+    : public integral_constant<bool, __detail::__swappable_with<_Tp, _Up>::value>
+{};
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_swappable
+    : public conditional_t<__cccl_is_referenceable<_Tp>::value,
+                           is_swappable_with<add_lvalue_reference_t<_Tp>, add_lvalue_reference_t<_Tp>>,
+                           false_type>
+{};
+
+template <class _Tp, class _Up>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_nothrow_swappable_with
+    : public integral_constant<bool, __detail::__nothrow_swappable_with<_Tp, _Up>::value>
+{};
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_nothrow_swappable
+    : public conditional_t<__cccl_is_referenceable<_Tp>::value,
+                           is_nothrow_swappable_with<add_lvalue_reference_t<_Tp>, add_lvalue_reference_t<_Tp>>,
+                           false_type>
+{};
+
+template <class _Tp, class _Up>
+_CCCL_INLINE_VAR constexpr bool is_swappable_with_v = is_swappable_with<_Tp, _Up>::value;
+
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_swappable_v = is_swappable<_Tp>::value;
+
+template <class _Tp, class _Up>
+_CCCL_INLINE_VAR constexpr bool is_nothrow_swappable_with_v = is_nothrow_swappable_with<_Tp, _Up>::value;
+
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_nothrow_swappable_v = is_nothrow_swappable<_Tp>::value;
+
+#endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_IS_SWAPPABLE_H

vllm/lib/python3.10/site-packages/cupy/_core/include/cupy/_cccl/libcudacxx/cuda/std/__type_traits/is_trivial.h

@@ -0,0 +1,56 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+// SPDX-FileCopyrightText: Copyright (c) 2023 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCUDACXX___TYPE_TRAITS_IS_TRIVIAL_H
+#define _LIBCUDACXX___TYPE_TRAITS_IS_TRIVIAL_H
+
+#include <cuda/std/detail/__config>
+
+#if defined(_CCCL_IMPLICIT_SYSTEM_HEADER_GCC)
+#  pragma GCC system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_CLANG)
+#  pragma clang system_header
+#elif defined(_CCCL_IMPLICIT_SYSTEM_HEADER_MSVC)
+#  pragma system_header
+#endif // no system header
+
+#include <cuda/std/__type_traits/integral_constant.h>
+#include <cuda/std/__type_traits/is_trivially_copyable.h>
+#include <cuda/std/__type_traits/is_trivially_default_constructible.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_STD
+
+#if defined(_CCCL_BUILTIN_IS_TRIVIAL) && !defined(_LIBCUDACXX_USE_IS_TRIVIAL_FALLBACK)
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_trivial : public integral_constant<bool, _CCCL_BUILTIN_IS_TRIVIAL(_Tp)>
+{};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_trivial_v = _CCCL_BUILTIN_IS_TRIVIAL(_Tp);
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#else
+
+template <class _Tp>
+struct _CCCL_TYPE_VISIBILITY_DEFAULT is_trivial
+    : public integral_constant<bool, is_trivially_copyable<_Tp>::value && is_trivially_default_constructible<_Tp>::value>
+{};
+
+#  if !defined(_CCCL_NO_VARIABLE_TEMPLATES)
+template <class _Tp>
+_CCCL_INLINE_VAR constexpr bool is_trivial_v = is_trivial<_Tp>::value;
+#  endif // !_CCCL_NO_VARIABLE_TEMPLATES
+
+#endif // defined(_CCCL_BUILTIN_IS_TRIVIAL) && !defined(_LIBCUDACXX_USE_IS_TRIVIAL_FALLBACK)
+
+_LIBCUDACXX_END_NAMESPACE_STD
+
+#endif // _LIBCUDACXX___TYPE_TRAITS_IS_TRIVIAL_H