[libc] Enable running libc unit tests on NVPTX

[jhuber6]

Summary

The previous patches added the necessary support for global constructors
used to register tests. This patch enables the NVPTX target to build
and run the unit tests on the GPU. Currently this only tests the ctype
tests, but adding more should be straightforward from here on.

This ran all the ctest unit tests when run on an sm_70.

Depends on D149517 D149527

[jhuber6]

Changing to use '-fno-use-cxa-atexit'.

[sivachandra]

OK after addressing the inline comment.

libc/test/UnitTest/CMakeLists.txt

30

Instead of large if/else block, can you do something like:

if(LIBC_GPU_TARGET_ARCHITECTURE_IS_NVPTX)
  set(library_type OBJECT)
else()
  set(library_type STATIC)
endif()

And then add ${library_type} to all of the libraries below.

[jhuber6]

Addressing comment

[jhuber6]

Update

[jhuber6]

Disable this test, causes link failured due toredefined main on NVPTX.

[jhuber6]

Disabling three tests that fail on NVPTX. Will work to reenable these later.

libc/cmake/modules/LLVMLibCTestRules.cmake

 set(LIBC_HERMETIC_TEST_COMPILE_OPTIONS ${LIBC_COMPILE_OPTIONS_DEFAULT}
     -fpie -ffreestanding -fno-exceptions -fno-rtti)
 # The GPU build requires overriding the default CMake triple and architecture.
 if(LIBC_GPU_TARGET_ARCHITECTURE_IS_AMDGPU)
   list(APPEND LIBC_HERMETIC_TEST_COMPILE_OPTIONS
        -mcpu=${LIBC_GPU_TARGET_ARCHITECTURE} -flto --target=${LIBC_GPU_TARGET_TRIPLE})
 elseif(LIBC_GPU_TARGET_ARCHITECTURE_IS_NVPTX)
   get_nvptx_compile_options(nvptx_options ${LIBC_GPU_TARGET_ARCHITECTURE})
-  list(APPEND ${nvptx_options} --target=${LIBC_GPU_TARGET_TRIPLE})
+  list(APPEND LIBC_HERMETIC_TEST_COMPILE_OPTIONS
+       ${nvptx_options} -fno-use-cxa-atexit --target=${LIBC_GPU_TARGET_TRIPLE})
 endif()
 
 # Rule to add a hermetic test. A hermetic test is one whose executable is fully
 # statically linked and consists of pieces drawn only from LLVM's libc. Nothing,
 # including the startup objects, come from the system libc.
 #
 # Usage:
 #   add_libc_hermetic_test(

libc/test/CMakeLists.txt

 )
 
 if(LIBC_TARGET_ARCHITECTURE_IS_GPU AND
    (NOT TARGET libc.utils.gpu.loader OR NOT TARGET libc.startup.gpu.crt1))
   message(WARNING "Cannot build libc GPU tests, missing loader implementation")
   return()
 endif()
 
-if(NOT LIBC_GPU_TARGET_ARCHITECTURE_IS_NVPTX)
-  add_subdirectory(src)
-  add_subdirectory(utils)
-endif()
 
 if(LLVM_LIBC_FULL_BUILD AND NOT LIBC_TARGET_OS_IS_BAREMETAL)
   add_subdirectory(IntegrationTest)
 endif()
 
 if(NOT LLVM_LIBC_FULL_BUILD)
   return()
 endif()
 
 if(NOT ${LIBC_TARGET_OS} STREQUAL "linux" AND
    NOT ${LIBC_TARGET_OS} STREQUAL "gpu")
   # Integration tests are currently only available for linux and the GPU.
   return()
 endif()
 add_subdirectory(integration)

libc/test/UnitTest/CMakeLists.txt

 set(libc_test_srcs_common
   Test.h
   LibcTest.cpp
   CmakeFilePath.cpp
   LibcTest.h
   TestLogger.cpp
   TestLogger.h
 )
 
 set(libc_death_test_srcs ExecuteFunction.h)
 if(${LIBC_TARGET_OS} STREQUAL "linux")
   list(APPEND libc_death_test_srcs 
        LibcDeathTestExecutors.cpp ExecuteFunctionUnix.cpp)
 endif()
 
+# The Nvidia 'nvlink' linker does not support static libraries.
+if(LIBC_GPU_TARGET_ARCHITECTURE_IS_NVPTX)
+  set(library_type OBJECT)
+else()
+  set(library_type STATIC)
+endif()
+
 add_library(
   LibcUnitTest
+  ${library_type}
   EXCLUDE_FROM_ALL
   ${libc_test_srcs_common}
   ${libc_death_test_srcs}
 )
 
 add_library(
   LibcHermeticTest
+  ${library_type}
   EXCLUDE_FROM_ALL
   ${libc_test_srcs_common}
   HermeticTestUtils.cpp
 )
 
 add_library(
   LibcUnitTestMain
+  ${library_type}
   EXCLUDE_FROM_ALL
   LibcTestMain.cpp
 )
 add_dependencies(LibcUnitTestMain LibcUnitTest)
 
 add_library(
   LibcHermeticTestMain
+  ${library_type}
   EXCLUDE_FROM_ALL
   LibcTestMain.cpp
 )
 add_dependencies(LibcHermeticTestMain LibcHermeticTest)
 
 foreach(lib LibcUnitTest LibcUnitTestMain LibcHermeticTest LibcHermeticTestMain)
   target_include_directories(${lib} PUBLIC ${LIBC_SOURCE_DIR})
   target_compile_options(${lib} PRIVATE -fno-exceptions -fno-rtti)
add_dependencies(
   LibcFPExceptionHelpers
   LibcUnitTest
   libc.src.__support.FPUtil.fp_bits
   libc.src.__support.FPUtil.fenv_impl
 )
 
 add_library(
   LibcMemoryHelpers
+  ${library_type}
   MemoryMatcher.h
   MemoryMatcher.cpp
 )
 add_dependencies(
   LibcMemoryHelpers
   LibcUnitTest
   libc.src.__support.CPP.span
 )

libc/test/UnitTest/HermeticTestUtils.cpp

 namespace __llvm_libc {
 
 int bcmp(const void *lhs, const void *rhs, size_t count);
 void bzero(void *ptr, size_t count);
 int memcmp(const void *lhs, const void *rhs, size_t count);
 void *memcpy(void *__restrict, const void *__restrict, size_t);
 void *memmove(void *dst, const void *src, size_t count);
 void *memset(void *ptr, int value, size_t count);
+int atexit(void (*func)(void));
 
 } // namespace __llvm_libc
 
 namespace {
 
 // Integration tests cannot use the SCUDO standalone allocator as SCUDO pulls
 // various other parts of the libc. Since SCUDO development does not use
 // LLVM libc build rules, it is very hard to keep track or pull all that SCUDO

 }
 void *memmove(void *dst, const void *src, size_t count) {
   return __llvm_libc::memmove(dst, src, count);
 }
 void *memset(void *ptr, int value, size_t count) {
   return __llvm_libc::memset(ptr, value, count);
 }
 
+// This is needed if the test was compiled with '-fno-use-cxa-atexit'.
+int atexit(void (*func)(void)) { return __llvm_libc::atexit(func); }
+
 void *malloc(size_t s) {
   void *mem = ptr;
   ptr += s;
   return mem;
 }
 
 void free(void *) {}
 
 void *realloc(void *ptr, size_t s) {
   free(ptr);
   return malloc(s);
 }
 
 // The unit test framework uses pure virtual functions. Since hermetic tests
 // cannot depend C++ runtime libraries, implement dummy functions to support
 // the virtual function runtime.
 void __cxa_pure_virtual() {
   // A pure virtual being called is an error so we just trap.
   __builtin_trap();
 }
 
-// Integration tests are linked with -nostdlib. BFD linker expects
+// Hermetic tests are linked with -nostdlib. BFD linker expects
 // __dso_handle when -nostdlib is used.
 void *__dso_handle = nullptr;
 
 } // extern "C"
 
 void operator delete(void *) {
   // The libc runtime should not use the global delete operator. Hence,
   // we just trap here to catch any such accidental usages.
   __builtin_trap();
 }

libc/test/src/__support/CMakeLists.txt

 add_custom_target(libc-support-tests)
 
+# This test fails with a misaigned address on NVPTX.
+if(NOT LIBC_GPU_TARGET_ARCHITECTURE_IS_NVPTX)
   add_libc_test(
     blockstore_test
     SUITE
       libc-support-tests
     SRCS
       blockstore_test.cpp
     DEPENDS
       libc.src.__support.blockstore
   )
+endif()
 
 add_libc_test(
   endian_test
   SUITE
     libc-support-tests
   SRCS
     endian_test.cpp
   DEPENDS
     libc.src.__support.common
 )
 
+# This test fails with a segmentation fault on NVPTX.
+if(NOT LIBC_GPU_TARGET_ARCHITECTURE_IS_NVPTX)
   add_libc_test(
     high_precision_decimal_test
     SUITE
       libc-support-tests
     SRCS
     high_precision_decimal_test.cpp
     DEPENDS
       libc.src.__support.high_precision_decimal
       libc.src.__support.uint128
   )
+endif()
 
 add_libc_test(
   str_to_float_test
   SUITE
     libc-support-tests
   SRCS
     str_to_float_test.cpp
   DEPENDS

libc/test/src/__support/CPP/CMakeLists.txt

add_libc_test(
   SUITE
     libc-cpp-utils-tests
   SRCS
     atomic_test.cpp
   DEPENDS
     libc.src.__support.CPP.atomic
 )
 
+# This test fails with a segmentation fault on NVPTX.
+if(NOT LIBC_GPU_TARGET_ARCHITECTURE_IS_NVPTX)
   add_libc_test(
     stringstream_test
     SUITE
       libc-cpp-utils-tests
     SRCS
       stringstream_test.cpp
     DEPENDS
       libc.src.__support.CPP.span
       libc.src.__support.CPP.stringstream
   )
+endif()
 
 add_libc_test(
   optional_test
   SUITE
     libc-cpp-utils-tests
   SRCS
     optional_test.cpp
   DEPENDS

libc/test/src/__support/CPP/atomic_test.cpp

 //===-- Unittests for Atomic ----------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/__support/CPP/atomic.h"
 #include "test/UnitTest/Test.h"
 
 // Tests in this file do not test atomicity as it would require using
 // threads, at which point it becomes a chicken and egg problem.
 
 TEST(LlvmLibcAtomicTest, LoadStore) {
   __llvm_libc::cpp::Atomic<int> aint(123);
-  ASSERT_EQ(aint.load(), 123);
+  ASSERT_EQ(aint.load(__llvm_libc::cpp::MemoryOrder::RELAXED), 123);
 
-  aint.store(100);
-  ASSERT_EQ(aint.load(), 100);
+  aint.store(100, __llvm_libc::cpp::MemoryOrder::RELAXED);
+  ASSERT_EQ(aint.load(__llvm_libc::cpp::MemoryOrder::RELAXED), 100);
 
   aint = 1234; // Equivalent of store
-  ASSERT_EQ(aint.load(), 1234);
+  ASSERT_EQ(aint.load(__llvm_libc::cpp::MemoryOrder::RELAXED), 1234);
 }
 
 TEST(LlvmLibcAtomicTest, CompareExchangeStrong) {
   int desired = 123;
   __llvm_libc::cpp::Atomic<int> aint(desired);
   ASSERT_TRUE(aint.compare_exchange_strong(desired, 100));
-  ASSERT_EQ(aint.load(), 100);
+  ASSERT_EQ(aint.load(__llvm_libc::cpp::MemoryOrder::RELAXED), 100);
 
   ASSERT_FALSE(aint.compare_exchange_strong(desired, 100));
-  ASSERT_EQ(aint.load(), 100);
+  ASSERT_EQ(aint.load(__llvm_libc::cpp::MemoryOrder::RELAXED), 100);
 }

libc/test/utils/UnitTest/CMakeLists.txt

+if(LIBC_TARGET_ARCHITECTURE_IS_GPU)
+  return()
+endif()
+
 add_custom_target(libc_unittest_tests)
 
 add_libc_unittest(
   testfilter_test
   SUITE
     libc_unittest_tests
   SRCS
     testfilter_test.cpp
   DEPENDS
     # TODO(michaelrj): Remove this dependancy. It's only here because all unit 
     # tests must have at least one dependancy.
     libc.src.__support.CPP.bit 
 )