Implement cuda::demangle

Author: davebayer

libcudacxx/include/cuda/__binutils/demangle.h

@@ -0,0 +1,88 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// 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) 2025 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _CUDA___BINUTILS_DEMANGLE_H
+#define _CUDA___BINUTILS_DEMANGLE_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 _CCCL_HAS_CTK() && !_CCCL_COMPILER(NVRTC)
+
+#  include <cuda/std/__cstddef/types.h>
+#  include <cuda/std/__exception/cuda_error.h>
+#  include <cuda/std/cstdlib>
+#  include <cuda/std/string_view>
+
+#  include <string>
+
+#  include <nv_decode.h>
+
+#  include <cuda/std/__cccl/prologue.h>
+
+_LIBCUDACXX_BEGIN_NAMESPACE_CUDA
+
+//! @brief Demangles a CUDA C++ mangled name.
+//!
+//! @param __name The mangled name to demangle.
+//!
+//! @return A `std::string` containing the demangled name.
+//!
+//! @throws cuda::cuda_error if memory allocation fails, or if the input name is invalid.
+[[nodiscard]] ::std::string demangle(_CUDA_VSTD::string_view __name)
+{
+  // input must be zero-terminated, so we convert string_view to std::string
+  ::std::string __name_in{__name.begin(), __name.end()};
+
+  int __status{};
+  char* __dname_ptr = ::__cu_demangle(__name_in.c_str(), nullptr, nullptr, &__status);
+
+  _CCCL_TRY
+  {
+    switch (__status)
+    {
+      case 0: {
+        ::std::string __ret{__dname_ptr};
+        _CUDA_VSTD::free(__dname_ptr);
+        return __ret;
+      }
+      case -1:
+        ::cuda::__throw_cuda_error(::cudaErrorMemoryAllocation, "failed to allocate memory for demangled name");
+      case -2:
+        ::cuda::__throw_cuda_error(::cudaErrorInvalidSymbol, "invalid mangled name passed to demangle function");
+      case -3:
+        ::cuda::__throw_cuda_error(::cudaErrorInvalidValue, "invalid value passed to demangle function");
+      default:
+        // Should not happen, but if it does, we throw an unknown error
+        ::cuda::__throw_cuda_error(::cudaErrorUnknown, "unknown error during demangling occurred");
+    }
+  }
+  _CCCL_CATCH_ALL
+  {
+    // If an exception is thrown, free the allocated memory and rethrow the exception
+    _CUDA_VSTD::free(__dname_ptr);
+    throw;
+  }
+}
+
+_LIBCUDACXX_END_NAMESPACE_CUDA
+
+#  include <cuda/std/__cccl/epilogue.h>
+
+#endif // _CCCL_HAS_CTK() && !_CCCL_COMPILER(NVRTC)
+
+#endif // _CUDA___BINUTILS_DEMANGLE_H

libcudacxx/include/cuda/__binutils_

@@ -0,0 +1,26 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of libcu++, the C++ Standard Library for your entire system,
+// 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) 2025 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _CUDA_BINUTILS
+#define _CUDA_BINUTILS
+
+#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/__binutils/demangle.h>
+
+#endif // _CUDA_BINUTILS

libcudacxx/test/libcudacxx/CMakeLists.txt

@@ -77,17 +77,21 @@ if (${CMAKE_CUDA_COMPILER_ID} STREQUAL "Clang")
     " ${CMAKE_CUDA_FLAGS}"
     " -L${CUDAToolkit_LIBRARY_DIR}"
     " -lcuda"
-    " -lcudart")
+    " -lcudart"
+    " -lcufilt")
 elseif (${CMAKE_CUDA_COMPILER_ID} STREQUAL "NVIDIA")
   string(APPEND LIBCUDACXX_TEST_COMPILER_FLAGS
     " ${LIBCUDACXX_FORCE_INCLUDE}"
     " ${LIBCUDACXX_WARNING_LEVEL}"
     " -Wno-deprecated-gpu-targets")
+  string(APPEND LIBCUDACXX_TEST_LINKER_FLAGS
+    " -lcufilt")
 elseif (${CMAKE_CUDA_COMPILER_ID} STREQUAL "NVHPC")
   string(APPEND LIBCUDACXX_TEST_COMPILER_FLAGS
     " -stdpar")
   string(APPEND LIBCUDACXX_TEST_LINKER_FLAGS
-    " -stdpar")
+    " -stdpar"
+    " -lcufilt")
 endif()
 
 set(LIBCUDACXX_COMPUTE_ARCHS_STRING "${CMAKE_CUDA_ARCHITECTURES}")

libcudacxx/test/libcudacxx/cuda/binutils/demangle.pass.cpp

@@ -0,0 +1,58 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of CUDA Experimental in CUDA C++ Core Libraries,
+// 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) 2025 NVIDIA CORPORATION & AFFILIATES.
+//
+//===----------------------------------------------------------------------===//
+
+// UNSUPPORTED: nvrtc
+
+#include <cuda/__binutils_>
+#include <cuda/std/cassert>
+#include <cuda/std/string_view>
+#include <cuda/std/type_traits>
+
+#include <string>
+
+void test()
+{
+  // 1. test signature of
+  static_assert(cuda::std::is_same_v<decltype(cuda::demangle(cuda::std::string_view{})), std::string>);
+  static_assert(!noexcept(cuda::demangle(cuda::std::string_view{})));
+
+  // 2. test positive case
+  {
+    constexpr auto real_mangled_name = "_ZN8clstmp01I5cls01E13clstmp01_mf01Ev";
+    const auto demangled             = cuda::demangle(real_mangled_name);
+    assert(demangled == "clstmp01<cls01>::clstmp01_mf01()");
+  }
+
+  // 3. test error case
+#if _CCCL_HAS_EXCEPTIONS()
+  {
+    constexpr auto fake_mangled_name = "B@d_iDentiFier";
+    try
+    {
+      auto demangled = cuda::demangle(fake_mangled_name);
+      assert(false);
+    }
+    catch (const cuda::cuda_error& e)
+    {
+      assert(e.status() == cudaErrorInvalidSymbol);
+    }
+    catch (...)
+    {
+      assert(false);
+    }
+  }
+#endif // _CCCL_HAS_EXCEPTIONS()
+}
+
+int main(int, char**)
+{
+  NV_IF_TARGET(NV_IS_HOST, (test();))
+  return 0;
+}