[libc] Add support library for use with tests.

[sivachandra]

Summary

We do not want tests to include standard library headers to avoid
name conflicts. This support library helps shield the test compilation
units from the standard library while still providing the flexibility to
use the standard library.

This change adds wrappers for functions std::abort and the unix sleep
functions. It also provides a simple threading utility which is a wrapper
over the C++ std::thread class.

[abrachet]

I was actually just working on a patch to add death tests, so I have a lot of thoughts on this :)

We could do something like:

header.h

struct PolymorphicFunction {
  virtual ~PolymorphicFunction() {}
  virtual void call() = 0;
};

void doDeathTest(PolymorphicFunction &);

template <typename Func>
void createPolyFunction(Func f) {
   struct F : public PolymorphicFunction {
      Func f;
      F(Func f) : f(f) {}
      void call() override {
         f();
      }
   };
   F polyFunc(f);
   // For forking death teast stack allocation was fine but for thread we can't do that.
   doDeathTest(polyFunc);
}

So that in tests we can use lambdas, even ones which have a capture. What do you think about something like that? A Thread class could hold PolymorphicFunction * for example.

libc/utils/testutils/Thread.h

14–15

I think these are not very ergonomic because they cannot be instantiated with lambdas. See my top level comment how I think we can do this better.

libc/utils/testutils/linux/sleep.cpp

8

Out of curiosity, why have you added sleep? Where do you think it will be useful?

[abrachet]

libc/utils/testutils/Support.h

7

We could just do (outside of the namespaces) extern "C" void abort(); instead of providing this wrapper ourselves.

I'm assuming because sleeps implementation is in a linux directory that it's called something else on Windows?

[gchatelet]

libc/utils/testutils/Support.h

6

Do we need sleep in tests? What would be the use case?

[sivachandra]

Address comments

[sivachandra]

libc/utils/testutils/Support.h

7

Agree about abort.

I added sleep so that I can write a stop and go test for a mutex implementation. I think on Windows it is this: https://docs.microsoft.com/en-us/windows/win32/api/synchapi/nf-synchapi-sleep?redirectedfrom=MSDN

libc/utils/testutils/Thread.h

14–15

Inspired by your change, I have updated this now. I did not see a reason to support all possible forms of a callable so I have limited my changes to just that I require for now.

libc/utils/testutils/linux/sleep.cpp

8

Answered above.

[sivachandra]

Add missing header guards.

[sivachandra]

Having thought through this patch and its use again, I am currently of the opinion that we should not really be creating equivalents of the library implementations. For example, if we want abort, we should use __llvm_libc::abort. The abort implementation will have its own atomic test and that should be good enough of a confidence to use it in other tests. Likewise, we should be using the __llvm_libc::thrd_create and friends instead of using equivalents build over other libraries. We can choose to employ C++ convenience however - that is, we could implement a thread class using the __llvm_libc::thrd_* functions.

WDYT?

[gchatelet]

In D74652#1885864, @sivachandra wrote:

Having thought through this patch and its use again, I am currently of the opinion that we should not really be creating equivalents of the library implementations. For example, if we want abort, we should use __llvm_libc::abort. The abort implementation will have its own atomic test and that should be good enough of a confidence to use it in other tests. Likewise, we should be using the __llvm_libc::thrd_create and friends instead of using equivalents build over other libraries. We can choose to employ C++ convenience however - that is, we could implement a thread class using the __llvm_libc::thrd_* functions.

WDYT?

Yes that makes sense. For readability it's much better as well since there's no ambiguity on which function gets called.

[sivachandra]

We will not take this route.

libc/cmake/modules/LLVMLibCRules.cmake

function(add_libc_unittest target_name)
 
   set_target_properties(${target_name} PROPERTIES RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
 
   add_dependencies(
     ${target_name}
     ${LIBC_UNITTEST_DEPENDS}
   )
 
-  target_link_libraries(${target_name} PRIVATE LibcUnitTest)
+  target_link_libraries(${target_name} PRIVATE LibcUnitTest libc_test_utils)
 
   add_custom_command(
     TARGET ${target_name}
     POST_BUILD
     COMMAND $<TARGET_FILE:${target_name}>
   )
   if(LIBC_UNITTEST_SUITE)
     add_dependencies(

libc/utils/CMakeLists.txt

 add_subdirectory(CPP)
 add_subdirectory(HdrGen)
 add_subdirectory(UnitTest)
 add_subdirectory(benchmarks)
+add_subdirectory(testutils)

libc/utils/testutils/CMakeLists.txt

+
+add_library(
+  libc_test_utils
+  Support.h
+  Thread.cpp
+  Thread.h
+)
+
+if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${LIBC_TARGET_OS})
+  target_sources(libc_test_utils PRIVATE ${LIBC_TARGET_OS}/sleep.cpp)
+endif()

libc/utils/testutils/Support.h

+//===------------ Declaration of test support utilities ---------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+namespace __llvm_libc {
+namespace testutils {
+
+extern "C" void abort();
+int sleep(unsigned int seconds);
+
+} // namespace testutils
+} // namespace __llvm_libc

libc/utils/testutils/Thread.h

+//===---- A Thread class which is a wrapper over std::thread ----*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIBC_UTILS_TESTING_THREAD_H
+#define LLVM_LIBC_UTILS_TESTING_THREAD_H
+
+namespace __llvm_libc {
+namespace testutils {
+
+class Thread {
+private:
+  class ClassWithCall {
+  public:
+    virtual ~ClassWithCall() {}
+    virtual void call() = 0;
+  };
+
+  class Caller {
+  private:
+    ClassWithCall *Callee;
+
+  public:
+    explicit Caller(ClassWithCall *C) : Callee(C) {}
+
+    void operator()() { Callee->call(); }
+  };
+
+  template <typename Callable>
+  class GenericClassWithCall : public ClassWithCall {
+  public:
+    explicit GenericClassWithCall(Callable C) : TheCallable(C) {}
+
+    void call() override { TheCallable(); }
+
+  private:
+    Callable TheCallable;
+  };
+
+  void startThread(Caller C);
+
+public:
+  template <typename Callable>
+  Thread(Callable C) : WithCallObj(new GenericClassWithCall<Callable>(C)) {
+    Caller TheCaller(WithCallObj);
+    startThread(TheCaller);
+  }
+
+  void join();
+
+private:
+  ClassWithCall *WithCallObj;
+  void *StdThreadPtr;
+};
+
+} // namespace testutils
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_UTILS_TESTING_THREAD_H

libc/utils/testutils/Thread.cpp

+//===-- Implementation of the Thread class as a wrapper over std::thread --===//
+//
+// 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 "Thread.h"
+
+#include <thread>
+
+namespace __llvm_libc {
+namespace testutils {
+
+void Thread::startThread(Thread::Caller C) {
+  StdThreadPtr = new std::thread(C);
+}
+
+void Thread::join() {
+  reinterpret_cast<std::thread *>(StdThreadPtr)->join();
+  delete reinterpret_cast<std::thread *>(StdThreadPtr);
+  delete WithCallObj;
+}
+
+} // namespace testutils
+} // namespace __llvm_libc

libc/utils/testutils/linux/sleep.cpp

+//===---------------- Wrapper over the linux sleep function ---------------===//
+//
+// 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 <unistd.h>
+
+namespace __llvm_libc {
+namespace testutils {
+
+int sleep(unsigned int Seconds) { return ::sleep(Seconds); }
+
+} // namespace testutils
+} // namespace __llvm_libc