[libc-commits] [libc] [libc] Update integration tests to use the C functions directly (PR #81866)

Guillaume Chatelet via libc-commits libc-commits at lists.llvm.org
Thu Feb 15 07:41:51 PST 2024


https://github.com/gchatelet created https://github.com/llvm/llvm-project/pull/81866

None

>From 5bdcd8ec0658c7697a019106f4043e7f17645e75 Mon Sep 17 00:00:00 2001
From: Guillaume Chatelet <gchatelet at google.com>
Date: Thu, 15 Feb 2024 15:41:27 +0000
Subject: [PATCH] [libc] Update integration tests to use the C functions
 directly

---
 libc/test/IntegrationTest/test.cpp            |  41 -------
 libc/test/IntegrationTest/test.h              |  50 +++++++--
 .../src/stdio/sprintf_size_test.cpp           |  48 ++-------
 .../integration/src/stdlib/getenv_test.cpp    |  44 ++------
 .../src/threads/call_once_test.cpp            |  42 +++-----
 .../test/integration/src/threads/cnd_test.cpp | 101 ++++++++----------
 .../test/integration/src/threads/mtx_test.cpp |  99 +++++++----------
 .../src/threads/thrd_equal_test.cpp           |  34 +++---
 .../src/threads/thrd_exit_test.cpp            |  11 +-
 .../integration/src/threads/thrd_test.cpp     |  16 +--
 .../test/integration/src/threads/tss_test.cpp |  23 ++--
 .../integration/src/unistd/CMakeLists.txt     |   3 +-
 .../integration/src/unistd/execv_test.cpp     |  21 ++--
 .../src/unistd/execv_test_normal_exit.cpp     |   6 +-
 .../src/unistd/execv_test_signal_exit.cpp     |   6 +-
 .../integration/src/unistd/execve_test.cpp    |  21 ++--
 .../test/integration/src/unistd/fork_test.cpp |  53 ++++-----
 .../integration/src/unistd/getcwd_test.cpp    |  22 ++--
 .../src/unistd/stack_smashing_test.cpp        |  20 ++--
 .../integration/startup/linux/args_test.cpp   |  30 ++----
 .../integration/startup/linux/tls_test.cpp    |   9 +-
 libc/test/src/CMakeLists.txt                  |  19 ++--
 .../HdrGen/PrototypeTestGen/CMakeLists.txt    |  16 ++-
 23 files changed, 285 insertions(+), 450 deletions(-)

diff --git a/libc/test/IntegrationTest/test.cpp b/libc/test/IntegrationTest/test.cpp
index 3bdbe89a3fb62d..b5cdaa7fdf9247 100644
--- a/libc/test/IntegrationTest/test.cpp
+++ b/libc/test/IntegrationTest/test.cpp
@@ -9,47 +9,6 @@
 #include <stddef.h>
 #include <stdint.h>
 
-// Integration tests rely on the following memory functions. This is because the
-// compiler code generation can emit calls to them. We want to map the external
-// entrypoint to the internal implementation of the function used for testing.
-// This is done manually as not all targets support aliases.
-
-namespace LIBC_NAMESPACE {
-
-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 LIBC_NAMESPACE
-
-extern "C" {
-
-int bcmp(const void *lhs, const void *rhs, size_t count) {
-  return LIBC_NAMESPACE::bcmp(lhs, rhs, count);
-}
-void bzero(void *ptr, size_t count) { LIBC_NAMESPACE::bzero(ptr, count); }
-int memcmp(const void *lhs, const void *rhs, size_t count) {
-  return LIBC_NAMESPACE::memcmp(lhs, rhs, count);
-}
-void *memcpy(void *__restrict dst, const void *__restrict src, size_t count) {
-  return LIBC_NAMESPACE::memcpy(dst, src, count);
-}
-void *memmove(void *dst, const void *src, size_t count) {
-  return LIBC_NAMESPACE::memmove(dst, src, count);
-}
-void *memset(void *ptr, int value, size_t count) {
-  return LIBC_NAMESPACE::memset(ptr, value, count);
-}
-
-// This is needed if the test was compiled with '-fno-use-cxa-atexit'.
-int atexit(void (*func)(void)) { return LIBC_NAMESPACE::atexit(func); }
-
-} // extern "C"
-
 // 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
diff --git a/libc/test/IntegrationTest/test.h b/libc/test/IntegrationTest/test.h
index 64906ef179391b..a97c6c35752e4e 100644
--- a/libc/test/IntegrationTest/test.h
+++ b/libc/test/IntegrationTest/test.h
@@ -12,6 +12,18 @@
 #include "src/__support/OSUtil/io.h"
 #include "src/__support/OSUtil/quick_exit.h"
 
+inline static bool streq(const char *lhs, const char *rhs) {
+  if (lhs == rhs)
+    return true;
+  if ((!lhs && rhs) || (lhs && !rhs))
+    return false;
+  const char *l, *r;
+  for (l = lhs, r = rhs; *l != '\0' && *r != '\0'; ++l, ++r)
+    if (*l != *r)
+      return false;
+  return *l == '\0' && *r == '\0';
+}
+
 #define __AS_STRING(val) #val
 #define __CHECK_TRUE(file, line, val, should_exit)                             \
   if (!(val)) {                                                                \
@@ -45,9 +57,24 @@
       LIBC_NAMESPACE::quick_exit(127);                                         \
   }
 
+#define __CHECK_STREQ(file, line, val1, val2, should_exit)                     \
+  if (streq((val1), (val2)) == false) {                                        \
+    LIBC_NAMESPACE::write_to_stderr(file ":" __AS_STRING(                      \
+        line) ": Expected '" #val1 "' to be equal to '" #val2 "'\n");          \
+    if (should_exit)                                                           \
+      LIBC_NAMESPACE::quick_exit(127);                                         \
+  }
+
+#define __CHECK_STRNE(file, line, val1, val2, should_exit)                     \
+  if (streq((val1), (val2)) == true) {                                         \
+    LIBC_NAMESPACE::write_to_stderr(file ":" __AS_STRING(                      \
+        line) ": Expected '" #val1 "' to not be equal to '" #val2 "'\n");      \
+    if (should_exit)                                                           \
+      LIBC_NAMESPACE::quick_exit(127);                                         \
+  }
+
 ////////////////////////////////////////////////////////////////////////////////
 // Boolean checks are handled as comparison to the true / false values.
-
 #define EXPECT_TRUE(val) __CHECK_TRUE(__FILE__, __LINE__, val, false)
 #define ASSERT_TRUE(val) __CHECK_TRUE(__FILE__, __LINE__, val, true)
 #define EXPECT_FALSE(val) __CHECK_FALSE(__FILE__, __LINE__, val, false)
@@ -65,15 +92,24 @@
 #define ASSERT_NE(val1, val2)                                                  \
   __CHECK_NE(__FILE__, __LINE__, (val1), (val2), true)
 
+////////////////////////////////////////////////////////////////////////////////
+// String equality / inequality.
+
+#define EXPECT_STREQ(val1, val2)                                               \
+  __CHECK_STREQ(__FILE__, __LINE__, (val1), (val2), false)
+#define ASSERT_STREQ(val1, val2)                                               \
+  __CHECK_STREQ(__FILE__, __LINE__, (val1), (val2), true)
+#define EXPECT_STRNE(val1, val2)                                               \
+  __CHECK_STRNE(__FILE__, __LINE__, (val1), (val2), false)
+#define ASSERT_STRNE(val1, val2)                                               \
+  __CHECK_STRNE(__FILE__, __LINE__, (val1), (val2), true)
+
 ////////////////////////////////////////////////////////////////////////////////
 // Errno checks.
 
-#define ASSERT_ERRNO_EQ(VAL)                                                   \
-  ASSERT_EQ(VAL, static_cast<int>(LIBC_NAMESPACE::libc_errno))
-#define ASSERT_ERRNO_SUCCESS()                                                 \
-  ASSERT_EQ(0, static_cast<int>(LIBC_NAMESPACE::libc_errno))
-#define ASSERT_ERRNO_FAILURE()                                                 \
-  ASSERT_NE(0, static_cast<int>(LIBC_NAMESPACE::libc_errno))
+#define ASSERT_ERRNO_EQ(VAL) ASSERT_EQ(VAL, errno)
+#define ASSERT_ERRNO_SUCCESS() ASSERT_EQ(0, errno)
+#define ASSERT_ERRNO_FAILURE() ASSERT_NE(0, errno)
 
 // Integration tests are compiled with -ffreestanding which stops treating
 // the main function as a non-overloadable special function. Hence, we use a
diff --git a/libc/test/integration/src/stdio/sprintf_size_test.cpp b/libc/test/integration/src/stdio/sprintf_size_test.cpp
index 833159436d49cb..5ab2126e3ec118 100644
--- a/libc/test/integration/src/stdio/sprintf_size_test.cpp
+++ b/libc/test/integration/src/stdio/sprintf_size_test.cpp
@@ -1,4 +1,4 @@
-//===-- Unittests for getenv ----------------------------------------------===//
+//===-- Unittests for sprintf ---------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -6,55 +6,23 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include <stddef.h>
-
 #ifndef INTEGRATION_DISABLE_PRINTF
-#include "src/stdio/sprintf.h"
+#include <stdio.h> // sprintf
 #endif
 
 #include "test/IntegrationTest/test.h"
 
-static bool my_streq(const char *lhs, const char *rhs) {
-  if (lhs == rhs)
-    return true;
-  if (((lhs == static_cast<char *>(nullptr)) &&
-       (rhs != static_cast<char *>(nullptr))) ||
-      ((lhs != static_cast<char *>(nullptr)) &&
-       (rhs == static_cast<char *>(nullptr)))) {
-    return false;
-  }
-  const char *l, *r;
-  for (l = lhs, r = rhs; *l != '\0' && *r != '\0'; ++l, ++r)
-    if (*l != *r)
-      return false;
-
-  return *l == '\0' && *r == '\0';
-}
-
-static int my_strlen(const char *str) {
-  const char *other = str;
-  while (*other)
-    ++other;
-  return static_cast<int>(other - str);
-}
-
 TEST_MAIN(int argc, char **argv, char **envp) {
   ASSERT_EQ(argc, 5);
-  ASSERT_TRUE(my_streq(argv[1], "%s %c %d"));
-  ASSERT_EQ(my_strlen(argv[1]), 8);
-  ASSERT_TRUE(my_streq(argv[2], "First arg"));
-  ASSERT_EQ(my_strlen(argv[2]), 9);
-  ASSERT_TRUE(my_streq(argv[3], "a"));
-  ASSERT_EQ(my_strlen(argv[3]), 1);
-  ASSERT_TRUE(my_streq(argv[4], "0"));
-  ASSERT_EQ(my_strlen(argv[4]), 1);
+  ASSERT_STREQ(argv[1], "%s %c %d");
+  ASSERT_STREQ(argv[2], "First arg");
+  ASSERT_STREQ(argv[3], "a");
+  ASSERT_STREQ(argv[4], "0");
 
 #ifndef INTEGRATION_DISABLE_PRINTF
   char buf[100];
-  ASSERT_EQ(
-      LIBC_NAMESPACE::sprintf(buf, argv[1], argv[2], argv[3][0], argv[4][0]),
-      14);
-  ASSERT_TRUE(my_streq(buf, "First arg a 48"));
+  ASSERT_EQ(sprintf(buf, argv[1], argv[2], argv[3][0], argv[4][0]), 14);
+  ASSERT_STREQ(buf, "First arg a 48");
 #endif
 
   return 0;
diff --git a/libc/test/integration/src/stdlib/getenv_test.cpp b/libc/test/integration/src/stdlib/getenv_test.cpp
index 82a9b89533d2eb..130e0dd818b3bb 100644
--- a/libc/test/integration/src/stdlib/getenv_test.cpp
+++ b/libc/test/integration/src/stdlib/getenv_test.cpp
@@ -6,43 +6,19 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "src/stdlib/getenv.h"
-
 #include "test/IntegrationTest/test.h"
 
-static bool my_streq(const char *lhs, const char *rhs) {
-  if (lhs == rhs)
-    return true;
-  if (((lhs == static_cast<char *>(nullptr)) &&
-       (rhs != static_cast<char *>(nullptr))) ||
-      ((lhs != static_cast<char *>(nullptr)) &&
-       (rhs == static_cast<char *>(nullptr)))) {
-    return false;
-  }
-  const char *l, *r;
-  for (l = lhs, r = rhs; *l != '\0' && *r != '\0'; ++l, ++r)
-    if (*l != *r)
-      return false;
-
-  return *l == '\0' && *r == '\0';
-}
+#include <stdlib.h> // getenv
 
 TEST_MAIN(int argc, char **argv, char **envp) {
-  ASSERT_TRUE(
-      my_streq(LIBC_NAMESPACE::getenv(""), static_cast<char *>(nullptr)));
-  ASSERT_TRUE(
-      my_streq(LIBC_NAMESPACE::getenv("="), static_cast<char *>(nullptr)));
-  ASSERT_TRUE(my_streq(LIBC_NAMESPACE::getenv("MISSING ENV VARIABLE"),
-                       static_cast<char *>(nullptr)));
-  ASSERT_FALSE(
-      my_streq(LIBC_NAMESPACE::getenv("PATH"), static_cast<char *>(nullptr)));
-  ASSERT_TRUE(my_streq(LIBC_NAMESPACE::getenv("FRANCE"), "Paris"));
-  ASSERT_FALSE(my_streq(LIBC_NAMESPACE::getenv("FRANCE"), "Berlin"));
-  ASSERT_TRUE(my_streq(LIBC_NAMESPACE::getenv("GERMANY"), "Berlin"));
-  ASSERT_TRUE(
-      my_streq(LIBC_NAMESPACE::getenv("FRANC"), static_cast<char *>(nullptr)));
-  ASSERT_TRUE(my_streq(LIBC_NAMESPACE::getenv("FRANCE1"),
-                       static_cast<char *>(nullptr)));
-
+  ASSERT_STREQ(getenv(""), nullptr);
+  ASSERT_STREQ(getenv("="), nullptr);
+  ASSERT_STREQ(getenv("MISSING ENV VARIABLE"), nullptr);
+  ASSERT_STRNE(getenv("PATH"), nullptr);
+  ASSERT_STREQ(getenv("FRANCE"), "Paris");
+  ASSERT_STRNE(getenv("FRANCE"), "Berlin");
+  ASSERT_STREQ(getenv("GERMANY"), "Berlin");
+  ASSERT_STREQ(getenv("FRANC"), nullptr);
+  ASSERT_STREQ(getenv("FRANCE1"), nullptr);
   return 0;
 }
diff --git a/libc/test/integration/src/threads/call_once_test.cpp b/libc/test/integration/src/threads/call_once_test.cpp
index efb920d00723a4..e7ceac60fbcff2 100644
--- a/libc/test/integration/src/threads/call_once_test.cpp
+++ b/libc/test/integration/src/threads/call_once_test.cpp
@@ -7,13 +7,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "src/__support/CPP/atomic.h"
-#include "src/threads/call_once.h"
-#include "src/threads/mtx_destroy.h"
-#include "src/threads/mtx_init.h"
-#include "src/threads/mtx_lock.h"
-#include "src/threads/mtx_unlock.h"
-#include "src/threads/thrd_create.h"
-#include "src/threads/thrd_join.h"
 
 #include "test/IntegrationTest/test.h"
 
@@ -27,10 +20,8 @@ static void call_once_func() { ++call_count; }
 
 static int func(void *) {
   static once_flag flag = ONCE_FLAG_INIT;
-  LIBC_NAMESPACE::call_once(&flag, call_once_func);
-
+  call_once(&flag, call_once_func);
   thread_count.fetch_add(1);
-
   return 0;
 }
 
@@ -41,14 +32,13 @@ void call_from_5_threads() {
 
   thrd_t threads[NUM_THREADS];
   for (unsigned int i = 0; i < NUM_THREADS; ++i) {
-    ASSERT_EQ(LIBC_NAMESPACE::thrd_create(threads + i, func, nullptr),
+    ASSERT_EQ(thrd_create(threads + i, func, nullptr),
               static_cast<int>(thrd_success));
   }
 
   for (unsigned int i = 0; i < NUM_THREADS; ++i) {
     int retval;
-    ASSERT_EQ(LIBC_NAMESPACE::thrd_join(threads[i], &retval),
-              static_cast<int>(thrd_success));
+    ASSERT_EQ(thrd_join(threads[i], &retval), static_cast<int>(thrd_success));
     ASSERT_EQ(retval, 0);
   }
 
@@ -58,8 +48,8 @@ void call_from_5_threads() {
 
 static mtx_t once_func_blocker;
 static void blocking_once_func() {
-  LIBC_NAMESPACE::mtx_lock(&once_func_blocker);
-  LIBC_NAMESPACE::mtx_unlock(&once_func_blocker);
+  mtx_lock(&once_func_blocker);
+  mtx_unlock(&once_func_blocker);
 }
 
 static LIBC_NAMESPACE::cpp::Atomic<unsigned int> start_count;
@@ -67,7 +57,7 @@ static LIBC_NAMESPACE::cpp::Atomic<unsigned int> done_count;
 static int once_func_caller(void *) {
   static once_flag flag;
   start_count.fetch_add(1);
-  LIBC_NAMESPACE::call_once(&flag, blocking_once_func);
+  call_once(&flag, blocking_once_func);
   done_count.fetch_add(1);
   return 0;
 }
@@ -79,16 +69,15 @@ void test_synchronization() {
   start_count = 0;
   done_count = 0;
 
-  ASSERT_EQ(LIBC_NAMESPACE::mtx_init(&once_func_blocker, mtx_plain),
+  ASSERT_EQ(mtx_init(&once_func_blocker, mtx_plain),
             static_cast<int>(thrd_success));
   // Lock the blocking mutex so that the once func blocks.
-  ASSERT_EQ(LIBC_NAMESPACE::mtx_lock(&once_func_blocker),
-            static_cast<int>(thrd_success));
+  ASSERT_EQ(mtx_lock(&once_func_blocker), static_cast<int>(thrd_success));
 
   thrd_t t1, t2;
-  ASSERT_EQ(LIBC_NAMESPACE::thrd_create(&t1, once_func_caller, nullptr),
+  ASSERT_EQ(thrd_create(&t1, once_func_caller, nullptr),
             static_cast<int>(thrd_success));
-  ASSERT_EQ(LIBC_NAMESPACE::thrd_create(&t2, once_func_caller, nullptr),
+  ASSERT_EQ(thrd_create(&t2, once_func_caller, nullptr),
             static_cast<int>(thrd_success));
 
   while (start_count.load() != 2)
@@ -98,20 +87,17 @@ void test_synchronization() {
   EXPECT_EQ(done_count.val, 0U);
 
   // Unlock the blocking mutex so that the once func blocks.
-  ASSERT_EQ(LIBC_NAMESPACE::mtx_unlock(&once_func_blocker),
-            static_cast<int>(thrd_success));
+  ASSERT_EQ(mtx_unlock(&once_func_blocker), static_cast<int>(thrd_success));
 
   int retval;
-  ASSERT_EQ(LIBC_NAMESPACE::thrd_join(t1, &retval),
-            static_cast<int>(thrd_success));
+  ASSERT_EQ(thrd_join(t1, &retval), static_cast<int>(thrd_success));
   ASSERT_EQ(retval, 0);
-  ASSERT_EQ(LIBC_NAMESPACE::thrd_join(t2, &retval),
-            static_cast<int>(thrd_success));
+  ASSERT_EQ(thrd_join(t2, &retval), static_cast<int>(thrd_success));
   ASSERT_EQ(retval, 0);
 
   ASSERT_EQ(done_count.val, 2U);
 
-  LIBC_NAMESPACE::mtx_destroy(&once_func_blocker);
+  mtx_destroy(&once_func_blocker);
 }
 
 TEST_MAIN() {
diff --git a/libc/test/integration/src/threads/cnd_test.cpp b/libc/test/integration/src/threads/cnd_test.cpp
index 8791c6adbaa69f..4ebe86338288bf 100644
--- a/libc/test/integration/src/threads/cnd_test.cpp
+++ b/libc/test/integration/src/threads/cnd_test.cpp
@@ -7,17 +7,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "src/__support/CPP/atomic.h"
-#include "src/threads/cnd_broadcast.h"
-#include "src/threads/cnd_destroy.h"
-#include "src/threads/cnd_init.h"
-#include "src/threads/cnd_signal.h"
-#include "src/threads/cnd_wait.h"
-#include "src/threads/mtx_destroy.h"
-#include "src/threads/mtx_init.h"
-#include "src/threads/mtx_lock.h"
-#include "src/threads/mtx_unlock.h"
-#include "src/threads/thrd_create.h"
-#include "src/threads/thrd_join.h"
 
 #include "test/IntegrationTest/test.h"
 
@@ -42,51 +31,51 @@ static cnd_t broadcast_cnd, threads_ready_cnd;
 static mtx_t broadcast_mtx, threads_ready_mtx;
 
 int broadcast_thread_func(void *) {
-  LIBC_NAMESPACE::mtx_lock(&broadcast_mtx);
+  mtx_lock(&broadcast_mtx);
   unsigned oldval = broadcast_count.fetch_add(1);
   if (oldval == THRD_COUNT - 1) {
-    LIBC_NAMESPACE::mtx_lock(&threads_ready_mtx);
-    LIBC_NAMESPACE::cnd_signal(&threads_ready_cnd);
-    LIBC_NAMESPACE::mtx_unlock(&threads_ready_mtx);
+    mtx_lock(&threads_ready_mtx);
+    cnd_signal(&threads_ready_cnd);
+    mtx_unlock(&threads_ready_mtx);
   }
 
-  LIBC_NAMESPACE::cnd_wait(&broadcast_cnd, &broadcast_mtx);
-  LIBC_NAMESPACE::mtx_unlock(&broadcast_mtx);
+  cnd_wait(&broadcast_cnd, &broadcast_mtx);
+  mtx_unlock(&broadcast_mtx);
   broadcast_count.fetch_sub(1);
   return 0;
 }
 
 void wait_notify_broadcast_test() {
-  LIBC_NAMESPACE::cnd_init(&broadcast_cnd);
-  LIBC_NAMESPACE::cnd_init(&threads_ready_cnd);
-  LIBC_NAMESPACE::mtx_init(&broadcast_mtx, mtx_plain);
-  LIBC_NAMESPACE::mtx_init(&threads_ready_mtx, mtx_plain);
+  cnd_init(&broadcast_cnd);
+  cnd_init(&threads_ready_cnd);
+  mtx_init(&broadcast_mtx, mtx_plain);
+  mtx_init(&threads_ready_mtx, mtx_plain);
 
-  LIBC_NAMESPACE::mtx_lock(&threads_ready_mtx);
+  mtx_lock(&threads_ready_mtx);
   thrd_t threads[THRD_COUNT];
   for (unsigned int i = 0; i < THRD_COUNT; ++i)
-    LIBC_NAMESPACE::thrd_create(&threads[i], broadcast_thread_func, nullptr);
+    thrd_create(&threads[i], broadcast_thread_func, nullptr);
 
-  LIBC_NAMESPACE::cnd_wait(&threads_ready_cnd, &threads_ready_mtx);
-  LIBC_NAMESPACE::mtx_unlock(&threads_ready_mtx);
+  cnd_wait(&threads_ready_cnd, &threads_ready_mtx);
+  mtx_unlock(&threads_ready_mtx);
 
-  LIBC_NAMESPACE::mtx_lock(&broadcast_mtx);
+  mtx_lock(&broadcast_mtx);
   ASSERT_EQ(broadcast_count.val, THRD_COUNT);
-  LIBC_NAMESPACE::cnd_broadcast(&broadcast_cnd);
-  LIBC_NAMESPACE::mtx_unlock(&broadcast_mtx);
+  cnd_broadcast(&broadcast_cnd);
+  mtx_unlock(&broadcast_mtx);
 
   for (unsigned int i = 0; i < THRD_COUNT; ++i) {
     int retval = 0xBAD;
-    LIBC_NAMESPACE::thrd_join(threads[i], &retval);
+    thrd_join(threads[i], &retval);
     ASSERT_EQ(retval, 0);
   }
 
   ASSERT_EQ(broadcast_count.val, 0U);
 
-  LIBC_NAMESPACE::cnd_destroy(&broadcast_cnd);
-  LIBC_NAMESPACE::cnd_destroy(&threads_ready_cnd);
-  LIBC_NAMESPACE::mtx_destroy(&broadcast_mtx);
-  LIBC_NAMESPACE::mtx_destroy(&threads_ready_mtx);
+  cnd_destroy(&broadcast_cnd);
+  cnd_destroy(&threads_ready_cnd);
+  mtx_destroy(&broadcast_mtx);
+  mtx_destroy(&threads_ready_mtx);
 }
 
 } // namespace wait_notify_broadcast_test
@@ -101,47 +90,45 @@ mtx_t waiter_mtx, main_thread_mtx;
 cnd_t waiter_cnd, main_thread_cnd;
 
 int waiter_thread_func(void *unused) {
-  LIBC_NAMESPACE::mtx_lock(&waiter_mtx);
+  mtx_lock(&waiter_mtx);
 
-  LIBC_NAMESPACE::mtx_lock(&main_thread_mtx);
-  LIBC_NAMESPACE::cnd_signal(&main_thread_cnd);
-  LIBC_NAMESPACE::mtx_unlock(&main_thread_mtx);
+  mtx_lock(&main_thread_mtx);
+  cnd_signal(&main_thread_cnd);
+  mtx_unlock(&main_thread_mtx);
 
-  LIBC_NAMESPACE::cnd_wait(&waiter_cnd, &waiter_mtx);
-  LIBC_NAMESPACE::mtx_unlock(&waiter_mtx);
+  cnd_wait(&waiter_cnd, &waiter_mtx);
+  mtx_unlock(&waiter_mtx);
 
   return 0x600D;
 }
 
 void single_waiter_test() {
-  ASSERT_EQ(LIBC_NAMESPACE::mtx_init(&waiter_mtx, mtx_plain),
-            int(thrd_success));
-  ASSERT_EQ(LIBC_NAMESPACE::mtx_init(&main_thread_mtx, mtx_plain),
-            int(thrd_success));
-  ASSERT_EQ(LIBC_NAMESPACE::cnd_init(&waiter_cnd), int(thrd_success));
-  ASSERT_EQ(LIBC_NAMESPACE::cnd_init(&main_thread_cnd), int(thrd_success));
+  ASSERT_EQ(mtx_init(&waiter_mtx, mtx_plain), int(thrd_success));
+  ASSERT_EQ(mtx_init(&main_thread_mtx, mtx_plain), int(thrd_success));
+  ASSERT_EQ(cnd_init(&waiter_cnd), int(thrd_success));
+  ASSERT_EQ(cnd_init(&main_thread_cnd), int(thrd_success));
 
-  ASSERT_EQ(LIBC_NAMESPACE::mtx_lock(&main_thread_mtx), int(thrd_success));
+  ASSERT_EQ(mtx_lock(&main_thread_mtx), int(thrd_success));
 
   thrd_t waiter_thread;
-  LIBC_NAMESPACE::thrd_create(&waiter_thread, waiter_thread_func, nullptr);
+  thrd_create(&waiter_thread, waiter_thread_func, nullptr);
 
-  ASSERT_EQ(LIBC_NAMESPACE::cnd_wait(&main_thread_cnd, &main_thread_mtx),
+  cnd_wait(&main_thread_cnd, &main_thread_mtx),
             int(thrd_success));
-  ASSERT_EQ(LIBC_NAMESPACE::mtx_unlock(&main_thread_mtx), int(thrd_success));
+  mtx_unlock(&main_thread_mtx), int(thrd_success));
 
-  ASSERT_EQ(LIBC_NAMESPACE::mtx_lock(&waiter_mtx), int(thrd_success));
-  ASSERT_EQ(LIBC_NAMESPACE::cnd_signal(&waiter_cnd), int(thrd_success));
-  ASSERT_EQ(LIBC_NAMESPACE::mtx_unlock(&waiter_mtx), int(thrd_success));
+  ASSERT_EQ(mtx_lock(&waiter_mtx), int(thrd_success));
+  ASSERT_EQ(cnd_signal(&waiter_cnd), int(thrd_success));
+  mtx_unlock(&waiter_mtx), int(thrd_success));
 
   int retval;
-  LIBC_NAMESPACE::thrd_join(waiter_thread, &retval);
+  thrd_join(waiter_thread, &retval);
   ASSERT_EQ(retval, 0x600D);
 
-  LIBC_NAMESPACE::mtx_destroy(&waiter_mtx);
-  LIBC_NAMESPACE::mtx_destroy(&main_thread_mtx);
-  LIBC_NAMESPACE::cnd_destroy(&waiter_cnd);
-  LIBC_NAMESPACE::cnd_destroy(&main_thread_cnd);
+  mtx_destroy(&waiter_mtx);
+  mtx_destroy(&main_thread_mtx);
+  cnd_destroy(&waiter_cnd);
+  cnd_destroy(&main_thread_cnd);
 }
 
 } // namespace single_waiter_test
diff --git a/libc/test/integration/src/threads/mtx_test.cpp b/libc/test/integration/src/threads/mtx_test.cpp
index 82b0350af97afc..12c356735a5b2a 100644
--- a/libc/test/integration/src/threads/mtx_test.cpp
+++ b/libc/test/integration/src/threads/mtx_test.cpp
@@ -6,13 +6,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "src/threads/mtx_destroy.h"
-#include "src/threads/mtx_init.h"
-#include "src/threads/mtx_lock.h"
-#include "src/threads/mtx_unlock.h"
-#include "src/threads/thrd_create.h"
-#include "src/threads/thrd_join.h"
-
 #include "test/IntegrationTest/test.h"
 
 #include <threads.h>
@@ -26,12 +19,12 @@ static int shared_int = START;
 int counter(void *arg) {
   int last_count = START;
   while (true) {
-    LIBC_NAMESPACE::mtx_lock(&mutex);
+    mtx_lock(&mutex);
     if (shared_int == last_count + 1) {
       shared_int++;
       last_count = shared_int;
     }
-    LIBC_NAMESPACE::mtx_unlock(&mutex);
+    mtx_unlock(&mutex);
     if (last_count >= MAX)
       break;
   }
@@ -39,17 +32,16 @@ int counter(void *arg) {
 }
 
 void relay_counter() {
-  ASSERT_EQ(LIBC_NAMESPACE::mtx_init(&mutex, mtx_plain),
-            static_cast<int>(thrd_success));
+  ASSERT_EQ(mtx_init(&mutex, mtx_plain), static_cast<int>(thrd_success));
 
   // The idea of this test is that two competing threads will update
   // a counter only if the other thread has updated it.
   thrd_t thread;
-  LIBC_NAMESPACE::thrd_create(&thread, counter, nullptr);
+  thrd_create(&thread, counter, nullptr);
 
   int last_count = START;
   while (true) {
-    ASSERT_EQ(LIBC_NAMESPACE::mtx_lock(&mutex), static_cast<int>(thrd_success));
+    ASSERT_EQ(mtx_lock(&mutex), static_cast<int>(thrd_success));
     if (shared_int == START) {
       ++shared_int;
       last_count = shared_int;
@@ -58,57 +50,51 @@ void relay_counter() {
       ++shared_int;
       last_count = shared_int;
     }
-    ASSERT_EQ(LIBC_NAMESPACE::mtx_unlock(&mutex),
-              static_cast<int>(thrd_success));
+    ASSERT_EQ(mtx_unlock(&mutex), static_cast<int>(thrd_success));
     if (last_count > MAX)
       break;
   }
 
   int retval = 123;
-  LIBC_NAMESPACE::thrd_join(thread, &retval);
+  thrd_join(thread, &retval);
   ASSERT_EQ(retval, 0);
 
-  LIBC_NAMESPACE::mtx_destroy(&mutex);
+  mtx_destroy(&mutex);
 }
 
 mtx_t start_lock, step_lock;
 bool started, step;
 
 int stepper(void *arg) {
-  LIBC_NAMESPACE::mtx_lock(&start_lock);
+  mtx_lock(&start_lock);
   started = true;
-  LIBC_NAMESPACE::mtx_unlock(&start_lock);
+  mtx_unlock(&start_lock);
 
-  LIBC_NAMESPACE::mtx_lock(&step_lock);
+  mtx_lock(&step_lock);
   step = true;
-  LIBC_NAMESPACE::mtx_unlock(&step_lock);
+  mtx_unlock(&step_lock);
   return 0;
 }
 
 void wait_and_step() {
-  ASSERT_EQ(LIBC_NAMESPACE::mtx_init(&start_lock, mtx_plain),
-            static_cast<int>(thrd_success));
-  ASSERT_EQ(LIBC_NAMESPACE::mtx_init(&step_lock, mtx_plain),
-            static_cast<int>(thrd_success));
+  ASSERT_EQ(mtx_init(&start_lock, mtx_plain), static_cast<int>(thrd_success));
+  ASSERT_EQ(mtx_init(&step_lock, mtx_plain), static_cast<int>(thrd_success));
 
   // In this test, we start a new thread but block it before it can make a
   // step. Once we ensure that the thread is blocked, we unblock it.
   // After unblocking, we then verify that the thread was indeed unblocked.
   step = false;
   started = false;
-  ASSERT_EQ(LIBC_NAMESPACE::mtx_lock(&step_lock),
-            static_cast<int>(thrd_success));
+  ASSERT_EQ(mtx_lock(&step_lock), static_cast<int>(thrd_success));
 
   thrd_t thread;
-  LIBC_NAMESPACE::thrd_create(&thread, stepper, nullptr);
+  thrd_create(&thread, stepper, nullptr);
 
   while (true) {
     // Make sure the thread actually started.
-    ASSERT_EQ(LIBC_NAMESPACE::mtx_lock(&start_lock),
-              static_cast<int>(thrd_success));
+    ASSERT_EQ(mtx_lock(&start_lock), static_cast<int>(thrd_success));
     bool s = started;
-    ASSERT_EQ(LIBC_NAMESPACE::mtx_unlock(&start_lock),
-              static_cast<int>(thrd_success));
+    ASSERT_EQ(mtx_unlock(&start_lock), static_cast<int>(thrd_success));
     if (s)
       break;
   }
@@ -117,25 +103,22 @@ void wait_and_step() {
   ASSERT_FALSE(step);
 
   // Unlock the step lock and wait until the step is made.
-  ASSERT_EQ(LIBC_NAMESPACE::mtx_unlock(&step_lock),
-            static_cast<int>(thrd_success));
+  ASSERT_EQ(mtx_unlock(&step_lock), static_cast<int>(thrd_success));
 
   while (true) {
-    ASSERT_EQ(LIBC_NAMESPACE::mtx_lock(&step_lock),
-              static_cast<int>(thrd_success));
+    ASSERT_EQ(mtx_lock(&step_lock), static_cast<int>(thrd_success));
     bool current_step_value = step;
-    ASSERT_EQ(LIBC_NAMESPACE::mtx_unlock(&step_lock),
-              static_cast<int>(thrd_success));
+    ASSERT_EQ(mtx_unlock(&step_lock), static_cast<int>(thrd_success));
     if (current_step_value)
       break;
   }
 
   int retval = 123;
-  LIBC_NAMESPACE::thrd_join(thread, &retval);
+  thrd_join(thread, &retval);
   ASSERT_EQ(retval, 0);
 
-  LIBC_NAMESPACE::mtx_destroy(&start_lock);
-  LIBC_NAMESPACE::mtx_destroy(&step_lock);
+  mtx_destroy(&start_lock);
+  mtx_destroy(&step_lock);
 }
 
 static constexpr int THREAD_COUNT = 10;
@@ -144,54 +127,54 @@ static mtx_t counter_lock;
 static int wait_count = 0;
 
 int waiter_func(void *) {
-  LIBC_NAMESPACE::mtx_lock(&counter_lock);
+  mtx_lock(&counter_lock);
   ++wait_count;
-  LIBC_NAMESPACE::mtx_unlock(&counter_lock);
+  mtx_unlock(&counter_lock);
 
   // Block on the waiter lock until the main
   // thread unblocks.
-  LIBC_NAMESPACE::mtx_lock(&multiple_waiter_lock);
-  LIBC_NAMESPACE::mtx_unlock(&multiple_waiter_lock);
+  mtx_lock(&multiple_waiter_lock);
+  mtx_unlock(&multiple_waiter_lock);
 
-  LIBC_NAMESPACE::mtx_lock(&counter_lock);
+  mtx_lock(&counter_lock);
   --wait_count;
-  LIBC_NAMESPACE::mtx_unlock(&counter_lock);
+  mtx_unlock(&counter_lock);
 
   return 0;
 }
 
 void multiple_waiters() {
-  LIBC_NAMESPACE::mtx_init(&multiple_waiter_lock, mtx_plain);
-  LIBC_NAMESPACE::mtx_init(&counter_lock, mtx_plain);
+  mtx_init(&multiple_waiter_lock, mtx_plain);
+  mtx_init(&counter_lock, mtx_plain);
 
-  LIBC_NAMESPACE::mtx_lock(&multiple_waiter_lock);
+  mtx_lock(&multiple_waiter_lock);
   thrd_t waiters[THREAD_COUNT];
   for (int i = 0; i < THREAD_COUNT; ++i) {
-    LIBC_NAMESPACE::thrd_create(waiters + i, waiter_func, nullptr);
+    thrd_create(waiters + i, waiter_func, nullptr);
   }
 
   // Spin until the counter is incremented to the desired
   // value.
   while (true) {
-    LIBC_NAMESPACE::mtx_lock(&counter_lock);
+    mtx_lock(&counter_lock);
     if (wait_count == THREAD_COUNT) {
-      LIBC_NAMESPACE::mtx_unlock(&counter_lock);
+      mtx_unlock(&counter_lock);
       break;
     }
-    LIBC_NAMESPACE::mtx_unlock(&counter_lock);
+    mtx_unlock(&counter_lock);
   }
 
-  LIBC_NAMESPACE::mtx_unlock(&multiple_waiter_lock);
+  mtx_unlock(&multiple_waiter_lock);
 
   int retval;
   for (int i = 0; i < THREAD_COUNT; ++i) {
-    LIBC_NAMESPACE::thrd_join(waiters[i], &retval);
+    thrd_join(waiters[i], &retval);
   }
 
   ASSERT_EQ(wait_count, 0);
 
-  LIBC_NAMESPACE::mtx_destroy(&multiple_waiter_lock);
-  LIBC_NAMESPACE::mtx_destroy(&counter_lock);
+  mtx_destroy(&multiple_waiter_lock);
+  mtx_destroy(&counter_lock);
 }
 
 TEST_MAIN() {
diff --git a/libc/test/integration/src/threads/thrd_equal_test.cpp b/libc/test/integration/src/threads/thrd_equal_test.cpp
index 4f8866f088b925..0979a0ed225f00 100644
--- a/libc/test/integration/src/threads/thrd_equal_test.cpp
+++ b/libc/test/integration/src/threads/thrd_equal_test.cpp
@@ -6,15 +6,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "src/threads/mtx_destroy.h"
-#include "src/threads/mtx_init.h"
-#include "src/threads/mtx_lock.h"
-#include "src/threads/mtx_unlock.h"
-#include "src/threads/thrd_create.h"
-#include "src/threads/thrd_current.h"
-#include "src/threads/thrd_equal.h"
-#include "src/threads/thrd_join.h"
-
 #include "test/IntegrationTest/test.h"
 
 #include <threads.h>
@@ -23,21 +14,21 @@ thrd_t child_thread;
 mtx_t mutex;
 
 static int child_func(void *arg) {
-  LIBC_NAMESPACE::mtx_lock(&mutex);
+  mtx_lock(&mutex);
   int *ret = reinterpret_cast<int *>(arg);
-  auto self = LIBC_NAMESPACE::thrd_current();
-  *ret = LIBC_NAMESPACE::thrd_equal(child_thread, self);
-  LIBC_NAMESPACE::mtx_unlock(&mutex);
+  auto self = thrd_current();
+  *ret = thrd_equal(child_thread, self);
+  mtx_unlock(&mutex);
   return 0;
 }
 
 TEST_MAIN() {
   // We init and lock the mutex so that we guarantee that the child thread is
   // waiting after startup.
-  ASSERT_EQ(LIBC_NAMESPACE::mtx_init(&mutex, mtx_plain), int(thrd_success));
-  ASSERT_EQ(LIBC_NAMESPACE::mtx_lock(&mutex), int(thrd_success));
+  ASSERT_EQ(mtx_init(&mutex, mtx_plain), int(thrd_success));
+  ASSERT_EQ(mtx_lock(&mutex), int(thrd_success));
 
-  auto main_thread = LIBC_NAMESPACE::thrd_current();
+  auto main_thread = thrd_current();
 
   // The idea here is that, we start a child thread which will immediately
   // wait on |mutex|. The main thread will update the global |child_thread| var
@@ -46,23 +37,22 @@ TEST_MAIN() {
   // comparison is returned in the thread arg.
   int result = 0;
   thrd_t th;
-  ASSERT_EQ(LIBC_NAMESPACE::thrd_create(&th, child_func, &result),
-            int(thrd_success));
+  ASSERT_EQ(thrd_create(&th, child_func, &result), int(thrd_success));
   // This new thread should of course not be equal to the main thread.
-  ASSERT_EQ(LIBC_NAMESPACE::thrd_equal(th, main_thread), 0);
+  ASSERT_EQ(thrd_equal(th, main_thread), 0);
 
   // Set the |child_thread| global var and unlock to allow the child to perform
   // the comparison.
   child_thread = th;
-  ASSERT_EQ(LIBC_NAMESPACE::mtx_unlock(&mutex), int(thrd_success));
+  ASSERT_EQ(mtx_unlock(&mutex), int(thrd_success));
 
   int retval;
-  ASSERT_EQ(LIBC_NAMESPACE::thrd_join(th, &retval), int(thrd_success));
+  ASSERT_EQ(thrd_join(th, &retval), int(thrd_success));
   ASSERT_EQ(retval, 0);
   // The child thread should see that thrd_current return value is the same as
   // |child_thread|.
   ASSERT_NE(result, 0);
 
-  LIBC_NAMESPACE::mtx_destroy(&mutex);
+  mtx_destroy(&mutex);
   return 0;
 }
diff --git a/libc/test/integration/src/threads/thrd_exit_test.cpp b/libc/test/integration/src/threads/thrd_exit_test.cpp
index 0939a7621f443c..cd93352259c693 100644
--- a/libc/test/integration/src/threads/thrd_exit_test.cpp
+++ b/libc/test/integration/src/threads/thrd_exit_test.cpp
@@ -6,9 +6,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "src/threads/thrd_create.h"
-#include "src/threads/thrd_exit.h"
-#include "src/threads/thrd_join.h"
 #include "test/IntegrationTest/test.h"
 
 #include <threads.h>
@@ -33,7 +30,7 @@ thread_local A thread_local_a(123);
 
 int func(void *) {
   thread_local_a.set(321);
-  LIBC_NAMESPACE::thrd_exit(0);
+  thrd_exit(0);
   return 0;
 }
 
@@ -41,11 +38,11 @@ TEST_MAIN() {
   thrd_t th;
   int retval;
 
-  ASSERT_EQ(LIBC_NAMESPACE::thrd_create(&th, func, nullptr), thrd_success);
-  ASSERT_EQ(LIBC_NAMESPACE::thrd_join(th, &retval), thrd_success);
+  ASSERT_EQ(thrd_create(&th, func, nullptr), thrd_success);
+  ASSERT_EQ(thrd_join(th, &retval), thrd_success);
 
   ASSERT_TRUE(dtor_called);
-  LIBC_NAMESPACE::thrd_exit(0);
+  thrd_exit(0);
   return 0;
 }
 
diff --git a/libc/test/integration/src/threads/thrd_test.cpp b/libc/test/integration/src/threads/thrd_test.cpp
index 58728366b53ee6..80d1c5b545444c 100644
--- a/libc/test/integration/src/threads/thrd_test.cpp
+++ b/libc/test/integration/src/threads/thrd_test.cpp
@@ -6,9 +6,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "src/threads/thrd_create.h"
-#include "src/threads/thrd_join.h"
-
 #include "test/IntegrationTest/test.h"
 
 #include <threads.h>
@@ -24,10 +21,9 @@ void create_and_join() {
   for (counter = 0; counter <= thread_count;) {
     thrd_t thread;
     int old_counter_val = counter;
-    ASSERT_EQ(LIBC_NAMESPACE::thrd_create(&thread, thread_func, nullptr),
-              (int)thrd_success);
+    ASSERT_EQ(thrd_create(&thread, thread_func, nullptr), (int)thrd_success);
     int retval = thread_count + 1; // Start with a retval we dont expect.
-    ASSERT_EQ(LIBC_NAMESPACE::thrd_join(thread, &retval), (int)thrd_success);
+    ASSERT_EQ(thrd_join(thread, &retval), (int)thrd_success);
     ASSERT_EQ(retval, 0);
     ASSERT_EQ(counter, old_counter_val + 1);
   }
@@ -41,15 +37,13 @@ void spawn_and_join() {
 
   for (int i = 0; i < thread_count; ++i) {
     args[i] = i;
-    ASSERT_EQ(
-        LIBC_NAMESPACE::thrd_create(thread_list + i, return_arg, args + i),
-        (int)thrd_success);
+    ASSERT_EQ(thrd_create(thread_list + i, return_arg, args + i),
+              (int)thrd_success);
   }
 
   for (int i = 0; i < thread_count; ++i) {
     int retval = thread_count + 1; // Start with a retval we dont expect.
-    ASSERT_EQ(LIBC_NAMESPACE::thrd_join(thread_list[i], &retval),
-              (int)thrd_success);
+    ASSERT_EQ(thrd_join(thread_list[i], &retval), (int)thrd_success);
     ASSERT_EQ(retval, i);
   }
 }
diff --git a/libc/test/integration/src/threads/tss_test.cpp b/libc/test/integration/src/threads/tss_test.cpp
index c1c91c810bdf2d..3a3ecd084b57a6 100644
--- a/libc/test/integration/src/threads/tss_test.cpp
+++ b/libc/test/integration/src/threads/tss_test.cpp
@@ -6,13 +6,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "src/threads/thrd_create.h"
-#include "src/threads/thrd_exit.h"
-#include "src/threads/thrd_join.h"
-#include "src/threads/tss_create.h"
-#include "src/threads/tss_delete.h"
-#include "src/threads/tss_get.h"
-#include "src/threads/tss_set.h"
 #include "test/IntegrationTest/test.h"
 
 #include <threads.h>
@@ -31,8 +24,8 @@ void dtor(void *data) {
 }
 
 int func(void *obj) {
-  ASSERT_EQ(LIBC_NAMESPACE::tss_set(key, &child_thread_data), thrd_success);
-  int *d = reinterpret_cast<int *>(LIBC_NAMESPACE::tss_get(key));
+  ASSERT_EQ(tss_set(key, &child_thread_data), thrd_success);
+  int *d = reinterpret_cast<int *>(tss_get(key));
   ASSERT_TRUE(d != nullptr);
   ASSERT_EQ(&child_thread_data, d);
   ASSERT_EQ(*d, THREAD_DATA_INITVAL);
@@ -41,23 +34,23 @@ int func(void *obj) {
 }
 
 TEST_MAIN() {
-  ASSERT_EQ(LIBC_NAMESPACE::tss_create(&key, &dtor), thrd_success);
-  ASSERT_EQ(LIBC_NAMESPACE::tss_set(key, &main_thread_data), thrd_success);
-  int *d = reinterpret_cast<int *>(LIBC_NAMESPACE::tss_get(key));
+  ASSERT_EQ(tss_create(&key, &dtor), thrd_success);
+  ASSERT_EQ(tss_set(key, &main_thread_data), thrd_success);
+  int *d = reinterpret_cast<int *>(tss_get(key));
   ASSERT_TRUE(d != nullptr);
   ASSERT_EQ(&main_thread_data, d);
   ASSERT_EQ(*d, THREAD_DATA_INITVAL);
 
   thrd_t th;
   int arg = 0xBAD;
-  ASSERT_EQ(LIBC_NAMESPACE::thrd_create(&th, &func, &arg), thrd_success);
+  ASSERT_EQ(thrd_create(&th, &func, &arg), thrd_success);
   int retval = THREAD_DATA_INITVAL; // Init to some non-zero val.
-  ASSERT_EQ(LIBC_NAMESPACE::thrd_join(th, &retval), thrd_success);
+  ASSERT_EQ(thrd_join(th, &retval), thrd_success);
   ASSERT_EQ(retval, 0);
   ASSERT_EQ(arg, THREAD_RUN_VAL);
   ASSERT_EQ(child_thread_data, THREAD_DATA_FINIVAL);
 
-  LIBC_NAMESPACE::tss_delete(key);
+  tss_delete(key);
 
   return 0;
 }
diff --git a/libc/test/integration/src/unistd/CMakeLists.txt b/libc/test/integration/src/unistd/CMakeLists.txt
index 3f18231209512a..a240e269e50f69 100644
--- a/libc/test/integration/src/unistd/CMakeLists.txt
+++ b/libc/test/integration/src/unistd/CMakeLists.txt
@@ -8,7 +8,6 @@ add_integration_test(
   SRCS
     getcwd_test.cpp
   DEPENDS
-    libc.src.__support.CPP.string_view
     libc.src.errno.errno
     libc.src.stdlib.getenv
     libc.src.unistd.getcwd
@@ -90,7 +89,7 @@ add_integration_test(
   DEPENDS
     libc_execv_test_normal_exit
     libc_execv_test_signal_exit
-    libc.include.errno
+    libc.src.errno.errno
     libc.src.sys.wait.waitpid
     libc.src.unistd.execv
     libc.src.unistd.fork
diff --git a/libc/test/integration/src/unistd/execv_test.cpp b/libc/test/integration/src/unistd/execv_test.cpp
index 254ef955f2720e..f890d1ccc0c74d 100644
--- a/libc/test/integration/src/unistd/execv_test.cpp
+++ b/libc/test/integration/src/unistd/execv_test.cpp
@@ -6,46 +6,43 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "src/sys/wait/waitpid.h"
-#include "src/unistd/execv.h"
-#include "src/unistd/fork.h"
-
 #include "test/IntegrationTest/test.h"
 
-#include <signal.h>
-#include <sys/wait.h>
+#include <signal.h>   // SIGUSR1
+#include <sys/wait.h> // waitpid
+#include <unistd.h>   // fork, execv
 
 void fork_and_execv_normal_exit() {
-  pid_t pid = LIBC_NAMESPACE::fork();
+  pid_t pid = fork();
   if (pid == 0) {
     const char *path = "libc_execv_test_normal_exit";
     char *const argv[] = {
         const_cast<char *>("execv_test_normal_exit"),
         nullptr,
     };
-    LIBC_NAMESPACE::execv(path, argv);
+    execv(path, argv);
   }
   ASSERT_TRUE(pid > 0);
   int status;
-  pid_t cpid = LIBC_NAMESPACE::waitpid(pid, &status, 0);
+  pid_t cpid = waitpid(pid, &status, 0);
   ASSERT_TRUE(cpid > 0);
   ASSERT_EQ(cpid, pid);
   ASSERT_TRUE(WIFEXITED(status));
 }
 
 void fork_and_execv_signal_exit() {
-  pid_t pid = LIBC_NAMESPACE::fork();
+  pid_t pid = fork();
   if (pid == 0) {
     const char *path = "libc_execv_test_signal_exit";
     char *const argv[] = {
         const_cast<char *>("execv_test_normal_exit"),
         nullptr,
     };
-    LIBC_NAMESPACE::execv(path, argv);
+    execv(path, argv);
   }
   ASSERT_TRUE(pid > 0);
   int status;
-  pid_t cpid = LIBC_NAMESPACE::waitpid(pid, &status, 0);
+  pid_t cpid = waitpid(pid, &status, 0);
   ASSERT_TRUE(cpid > 0);
   ASSERT_EQ(cpid, pid);
   ASSERT_FALSE(WIFEXITED(status));
diff --git a/libc/test/integration/src/unistd/execv_test_normal_exit.cpp b/libc/test/integration/src/unistd/execv_test_normal_exit.cpp
index 567bd7d47d838b..3294b951100e06 100644
--- a/libc/test/integration/src/unistd/execv_test_normal_exit.cpp
+++ b/libc/test/integration/src/unistd/execv_test_normal_exit.cpp
@@ -1,6 +1,6 @@
-#include <signal.h>
-#include <stdlib.h>
-#include <unistd.h>
+#include <signal.h> // SIGUSR1
+#include <stdlib.h> // getenv
+#include <unistd.h> // raise
 
 int main() {
   char *env = getenv("EXECV_TEST");
diff --git a/libc/test/integration/src/unistd/execv_test_signal_exit.cpp b/libc/test/integration/src/unistd/execv_test_signal_exit.cpp
index e266b5c07490f8..183731c152babf 100644
--- a/libc/test/integration/src/unistd/execv_test_signal_exit.cpp
+++ b/libc/test/integration/src/unistd/execv_test_signal_exit.cpp
@@ -1,6 +1,6 @@
-#include <signal.h>
-#include <stdlib.h>
-#include <unistd.h>
+#include <signal.h> // SIGUSR1
+#include <stdlib.h> // getenv
+#include <unistd.h> // raise
 
 int main() {
   char *env = getenv("__MISSING_ENV_VAR__");
diff --git a/libc/test/integration/src/unistd/execve_test.cpp b/libc/test/integration/src/unistd/execve_test.cpp
index fb1a83da638566..83fda1d3ddae2c 100644
--- a/libc/test/integration/src/unistd/execve_test.cpp
+++ b/libc/test/integration/src/unistd/execve_test.cpp
@@ -6,46 +6,43 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "src/sys/wait/waitpid.h"
-#include "src/unistd/execve.h"
-#include "src/unistd/fork.h"
-
 #include "test/IntegrationTest/test.h"
 
-#include <signal.h>
-#include <sys/wait.h>
+#include <signal.h>   // SIGUSR1
+#include <sys/wait.h> // waitpid
+#include <unistd.h>   // fork, execve
 
 void fork_and_execv_normal_exit(char **envp) {
-  pid_t pid = LIBC_NAMESPACE::fork();
+  pid_t pid = fork();
   if (pid == 0) {
     const char *path = "libc_execv_test_normal_exit";
     char *const argv[] = {
         const_cast<char *>("execv_test_normal_exit"),
         nullptr,
     };
-    LIBC_NAMESPACE::execve(path, argv, envp);
+    execve(path, argv, envp);
   }
   ASSERT_TRUE(pid > 0);
   int status;
-  pid_t cpid = LIBC_NAMESPACE::waitpid(pid, &status, 0);
+  pid_t cpid = waitpid(pid, &status, 0);
   ASSERT_TRUE(cpid > 0);
   ASSERT_EQ(cpid, pid);
   ASSERT_TRUE(WIFEXITED(status));
 }
 
 void fork_and_execv_signal_exit(char **envp) {
-  pid_t pid = LIBC_NAMESPACE::fork();
+  pid_t pid = fork();
   if (pid == 0) {
     const char *path = "libc_execv_test_signal_exit";
     char *const argv[] = {
         const_cast<char *>("execv_test_normal_exit"),
         nullptr,
     };
-    LIBC_NAMESPACE::execve(path, argv, envp);
+    execve(path, argv, envp);
   }
   ASSERT_TRUE(pid > 0);
   int status;
-  pid_t cpid = LIBC_NAMESPACE::waitpid(pid, &status, 0);
+  pid_t cpid = waitpid(pid, &status, 0);
   ASSERT_TRUE(cpid > 0);
   ASSERT_EQ(cpid, pid);
   ASSERT_FALSE(WIFEXITED(status));
diff --git a/libc/test/integration/src/unistd/fork_test.cpp b/libc/test/integration/src/unistd/fork_test.cpp
index 9c9213ed46316d..5906ca7196ea7c 100644
--- a/libc/test/integration/src/unistd/fork_test.cpp
+++ b/libc/test/integration/src/unistd/fork_test.cpp
@@ -6,19 +6,13 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "src/pthread/pthread_atfork.h"
-#include "src/signal/raise.h"
-#include "src/sys/wait/wait.h"
-#include "src/sys/wait/wait4.h"
-#include "src/sys/wait/waitpid.h"
-#include "src/unistd/fork.h"
-
 #include "test/IntegrationTest/test.h"
 
 #include <errno.h>
-#include <signal.h>
-#include <sys/wait.h>
-#include <unistd.h>
+#include <pthread.h>  // pthread_atfork
+#include <signal.h>   // raise
+#include <sys/wait.h> // wait
+#include <unistd.h>   // fork
 
 // The tests wait4 and waitpid are present as tests for those functions
 // really and not for the fork function. They are here along with the tests
@@ -26,19 +20,19 @@
 // a child.
 
 void fork_and_wait_normal_exit() {
-  pid_t pid = LIBC_NAMESPACE::fork();
+  pid_t pid = fork();
   if (pid == 0)
     return; // Just end without any thing special.
   ASSERT_TRUE(pid > 0);
   int status;
-  pid_t cpid = LIBC_NAMESPACE::wait(&status);
+  pid_t cpid = wait(&status);
   ASSERT_TRUE(cpid > 0);
   ASSERT_EQ(cpid, pid);
   ASSERT_TRUE(WIFEXITED(status));
 }
 
 void fork_and_wait4_normal_exit() {
-  pid_t pid = LIBC_NAMESPACE::fork();
+  pid_t pid = fork();
   if (pid == 0)
     return; // Just end without any thing special.
   ASSERT_TRUE(pid > 0);
@@ -46,31 +40,31 @@ void fork_and_wait4_normal_exit() {
   struct rusage usage;
   usage.ru_utime = {0, 0};
   usage.ru_stime = {0, 0};
-  pid_t cpid = LIBC_NAMESPACE::wait4(pid, &status, 0, &usage);
+  pid_t cpid = wait4(pid, &status, 0, &usage);
   ASSERT_TRUE(cpid > 0);
   ASSERT_EQ(cpid, pid);
   ASSERT_TRUE(WIFEXITED(status));
 }
 
 void fork_and_waitpid_normal_exit() {
-  pid_t pid = LIBC_NAMESPACE::fork();
+  pid_t pid = fork();
   if (pid == 0)
     return; // Just end without any thing special.
   ASSERT_TRUE(pid > 0);
   int status;
-  pid_t cpid = LIBC_NAMESPACE::waitpid(pid, &status, 0);
+  pid_t cpid = waitpid(pid, &status, 0);
   ASSERT_TRUE(cpid > 0);
   ASSERT_EQ(cpid, pid);
   ASSERT_TRUE(WIFEXITED(status));
 }
 
 void fork_and_wait_signal_exit() {
-  pid_t pid = LIBC_NAMESPACE::fork();
+  pid_t pid = fork();
   if (pid == 0)
-    LIBC_NAMESPACE::raise(SIGUSR1);
+    raise(SIGUSR1);
   ASSERT_TRUE(pid > 0);
   int status;
-  pid_t cpid = LIBC_NAMESPACE::wait(&status);
+  pid_t cpid = wait(&status);
   ASSERT_TRUE(cpid > 0);
   ASSERT_EQ(cpid, pid);
   ASSERT_FALSE(WIFEXITED(status));
@@ -78,15 +72,15 @@ void fork_and_wait_signal_exit() {
 }
 
 void fork_and_wait4_signal_exit() {
-  pid_t pid = LIBC_NAMESPACE::fork();
+  pid_t pid = fork();
   if (pid == 0)
-    LIBC_NAMESPACE::raise(SIGUSR1);
+    raise(SIGUSR1);
   ASSERT_TRUE(pid > 0);
   int status;
   struct rusage usage;
   usage.ru_utime = {0, 0};
   usage.ru_stime = {0, 0};
-  pid_t cpid = LIBC_NAMESPACE::wait4(pid, &status, 0, &usage);
+  pid_t cpid = wait4(pid, &status, 0, &usage);
   ASSERT_TRUE(cpid > 0);
   ASSERT_EQ(cpid, pid);
   ASSERT_FALSE(WIFEXITED(status));
@@ -94,12 +88,12 @@ void fork_and_wait4_signal_exit() {
 }
 
 void fork_and_waitpid_signal_exit() {
-  pid_t pid = LIBC_NAMESPACE::fork();
+  pid_t pid = fork();
   if (pid == 0)
-    LIBC_NAMESPACE::raise(SIGUSR1);
+    raise(SIGUSR1);
   ASSERT_TRUE(pid > 0);
   int status;
-  pid_t cpid = LIBC_NAMESPACE::waitpid(pid, &status, 0);
+  pid_t cpid = waitpid(pid, &status, 0);
   ASSERT_TRUE(cpid > 0);
   ASSERT_EQ(cpid, pid);
   ASSERT_FALSE(WIFEXITED(status));
@@ -118,20 +112,19 @@ static void parent_cb() { parent = DONE; }
 static void child_cb() { child = DONE; }
 
 void fork_with_atfork_callbacks() {
-  ASSERT_EQ(LIBC_NAMESPACE::pthread_atfork(&prepare_cb, &parent_cb, &child_cb),
-            0);
-  pid_t pid = LIBC_NAMESPACE::fork();
+  ASSERT_EQ(pthread_atfork(&prepare_cb, &parent_cb, &child_cb), 0);
+  pid_t pid = fork();
   if (pid == 0) {
     // Raise a signal from the child if unexpected at-fork
     // behavior is observed.
     if (child != DONE || prepare != DONE || parent == DONE)
-      LIBC_NAMESPACE::raise(SIGUSR1);
+      raise(SIGUSR1);
     return;
   }
 
   ASSERT_TRUE(pid > 0);
   int status;
-  pid_t cpid = LIBC_NAMESPACE::waitpid(pid, &status, 0);
+  pid_t cpid = waitpid(pid, &status, 0);
   ASSERT_TRUE(cpid > 0);
   ASSERT_EQ(cpid, pid);
   ASSERT_TRUE(WIFEXITED(status));
diff --git a/libc/test/integration/src/unistd/getcwd_test.cpp b/libc/test/integration/src/unistd/getcwd_test.cpp
index 551768187bf018..1b6252c067a214 100644
--- a/libc/test/integration/src/unistd/getcwd_test.cpp
+++ b/libc/test/integration/src/unistd/getcwd_test.cpp
@@ -6,35 +6,29 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "src/__support/CPP/string_view.h"
-#include "src/errno/libc_errno.h"
-#include "src/stdlib/getenv.h"
-#include "src/unistd/getcwd.h"
-
 #include "test/IntegrationTest/test.h"
 
-#include <stdlib.h> // For malloc and free
-
-using LIBC_NAMESPACE::cpp::string_view;
+#include <errno.h>  // errno
+#include <stdlib.h> // getenv
+#include <unistd.h> // getcwd
 
 TEST_MAIN(int argc, char **argv, char **envp) {
   char buffer[1024];
-  ASSERT_TRUE(string_view(LIBC_NAMESPACE::getenv("PWD")) ==
-              LIBC_NAMESPACE::getcwd(buffer, 1024));
+  ASSERT_STREQ(getenv("PWD"), getcwd(buffer, 1024));
 
   // nullptr buffer
-  char *cwd = LIBC_NAMESPACE::getcwd(nullptr, 0);
-  ASSERT_TRUE(string_view(LIBC_NAMESPACE::getenv("PWD")) == cwd);
+  char *cwd = getcwd(nullptr, 0);
+  ASSERT_STREQ(getenv("PWD"), cwd);
   free(cwd);
 
   // Bad size
-  cwd = LIBC_NAMESPACE::getcwd(buffer, 0);
+  cwd = getcwd(buffer, 0);
   ASSERT_TRUE(cwd == nullptr);
   ASSERT_ERRNO_EQ(EINVAL);
   LIBC_NAMESPACE::libc_errno = 0;
 
   // Insufficient size
-  cwd = LIBC_NAMESPACE::getcwd(buffer, 2);
+  cwd = getcwd(buffer, 2);
   ASSERT_TRUE(cwd == nullptr);
   int err = LIBC_NAMESPACE::libc_errno;
   ASSERT_EQ(err, ERANGE);
diff --git a/libc/test/integration/src/unistd/stack_smashing_test.cpp b/libc/test/integration/src/unistd/stack_smashing_test.cpp
index 89fc53dac506ac..49b4e084c546cb 100644
--- a/libc/test/integration/src/unistd/stack_smashing_test.cpp
+++ b/libc/test/integration/src/unistd/stack_smashing_test.cpp
@@ -8,22 +8,16 @@
 
 #include "src/__support/CPP/string.h"
 #include "src/__support/OSUtil/io.h"
-#include "src/pthread/pthread_atfork.h"
-#include "src/signal/raise.h"
-#include "src/sys/wait/wait.h"
-#include "src/sys/wait/wait4.h"
-#include "src/sys/wait/waitpid.h"
-#include "src/unistd/fork.h"
 
 #include "test/IntegrationTest/test.h"
 
 #include <errno.h>
-#include <signal.h>
-#include <sys/wait.h>
-#include <unistd.h>
+#include <signal.h>   // SIGABRT
+#include <sys/wait.h> // wait
+#include <unistd.h>   // fork
 
 void no_stack_smashing_normal_exit() {
-  pid_t pid = LIBC_NAMESPACE::fork();
+  pid_t pid = fork();
   if (pid == 0) {
     // Child process
     char foo[30];
@@ -33,14 +27,14 @@ void no_stack_smashing_normal_exit() {
   }
   ASSERT_TRUE(pid > 0);
   int status;
-  pid_t cpid = LIBC_NAMESPACE::wait(&status);
+  pid_t cpid = wait(&status);
   ASSERT_TRUE(cpid > 0);
   ASSERT_EQ(cpid, pid);
   ASSERT_TRUE(WIFEXITED(status));
 }
 
 void stack_smashing_abort() {
-  pid_t pid = LIBC_NAMESPACE::fork();
+  pid_t pid = fork();
   if (pid == 0) {
     // Child process
     char foo[30];
@@ -55,7 +49,7 @@ void stack_smashing_abort() {
   }
   ASSERT_TRUE(pid > 0);
   int status;
-  pid_t cpid = LIBC_NAMESPACE::wait(&status);
+  pid_t cpid = wait(&status);
   ASSERT_TRUE(cpid > 0);
   ASSERT_EQ(cpid, pid);
   ASSERT_TRUE(WTERMSIG(status) == SIGABRT);
diff --git a/libc/test/integration/startup/linux/args_test.cpp b/libc/test/integration/startup/linux/args_test.cpp
index 1cc5a0e7692796..6ac6f5c9cf19d2 100644
--- a/libc/test/integration/startup/linux/args_test.cpp
+++ b/libc/test/integration/startup/linux/args_test.cpp
@@ -8,31 +8,13 @@
 
 #include "test/IntegrationTest/test.h"
 
-static bool my_streq(const char *lhs, const char *rhs) {
-  const char *l, *r;
-  for (l = lhs, r = rhs; *l != '\0' && *r != '\0'; ++l, ++r)
-    if (*l != *r)
-      return false;
-
-  return *l == '\0' && *r == '\0';
-}
-
 TEST_MAIN(int argc, char **argv, char **envp) {
   ASSERT_TRUE(argc == 4);
-  ASSERT_TRUE(my_streq(argv[1], "1"));
-  ASSERT_TRUE(my_streq(argv[2], "2"));
-  ASSERT_TRUE(my_streq(argv[3], "3"));
-
-  bool found_france = false;
-  bool found_germany = false;
-  for (; *envp != nullptr; ++envp) {
-    if (my_streq(*envp, "FRANCE=Paris"))
-      found_france = true;
-    if (my_streq(*envp, "GERMANY=Berlin"))
-      found_germany = true;
-  }
-
-  ASSERT_TRUE(found_france && found_germany);
-
+  ASSERT_STREQ(argv[1], "1");
+  ASSERT_STREQ(argv[2], "2");
+  ASSERT_STREQ(argv[3], "3");
+  ASSERT_STREQ(envp[0], "FRANCE=Paris");
+  ASSERT_STREQ(envp[1], "GERMANY=Berlin");
+  ASSERT_STREQ(envp[2], nullptr);
   return 0;
 }
diff --git a/libc/test/integration/startup/linux/tls_test.cpp b/libc/test/integration/startup/linux/tls_test.cpp
index 2a6385e195a496..dcdf2cfd11b09a 100644
--- a/libc/test/integration/startup/linux/tls_test.cpp
+++ b/libc/test/integration/startup/linux/tls_test.cpp
@@ -6,8 +6,6 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include "src/errno/libc_errno.h"
-#include "src/sys/mman/mmap.h"
 #include "test/IntegrationTest/test.h"
 
 #include <errno.h>
@@ -17,20 +15,19 @@ constexpr int threadLocalDataSize = 101;
 _Thread_local int a[threadLocalDataSize] = {123};
 
 TEST_MAIN(int argc, char **argv, char **envp) {
-  ASSERT_TRUE(a[0] == 123);
+  ASSERT_EQ(a[0], 123);
 
   for (int i = 1; i < threadLocalDataSize; ++i)
     a[i] = i;
   for (int i = 1; i < threadLocalDataSize; ++i)
-    ASSERT_TRUE(a[i] == i);
+    ASSERT_EQ(a[i], i);
 
   // Call mmap with bad params so that an error value is
   // set in errno. Since errno is implemented using a thread
   // local var, this helps us test setting of errno and
   // reading it back.
   ASSERT_ERRNO_SUCCESS();
-  void *addr = LIBC_NAMESPACE::mmap(nullptr, 0, PROT_READ,
-                                    MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+  void *addr = mmap(nullptr, 0, PROT_READ, MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
   ASSERT_TRUE(addr == MAP_FAILED);
   ASSERT_ERRNO_EQ(EINVAL);
 
diff --git a/libc/test/src/CMakeLists.txt b/libc/test/src/CMakeLists.txt
index 6c99c6735befff..060164a6413a64 100644
--- a/libc/test/src/CMakeLists.txt
+++ b/libc/test/src/CMakeLists.txt
@@ -99,17 +99,18 @@ file(GLOB spec_files ${LIBC_SOURCE_DIR}/spec/*.td)
 
 # Generate api test souce code.
 add_custom_command(
-  OUTPUT ${public_test}
-  COMMAND $<TARGET_FILE:libc-prototype-testgen> -o ${public_test}
-          ${entrypoints_name_list}
-          -I ${LIBC_SOURCE_DIR}
-          ${LIBC_SOURCE_DIR}/config/${LIBC_TARGET_OS}/api.td
-
-  DEPENDS ${LIBC_SOURCE_DIR}/config/${LIBC_TARGET_OS}/api.td ${spec_files}
-          libc-prototype-testgen ${TARGET_PUBLIC_HEADERS}
-          ${LIBC_TARGET}
+  OUTPUT "${public_test}"
+  COMMAND "$<TARGET_FILE:libc-prototype-testgen> -o ${public_test} ${entrypoints_name_list} -I ${LIBC_SOURCE_DIR} ${LIBC_SOURCE_DIR}/config/${LIBC_TARGET_OS}/api.td"
+  DEPENDS 
+    ${LIBC_SOURCE_DIR}/config/${LIBC_TARGET_OS}/api.td
+    ${spec_files}
+    libc-prototype-testgen
+    ${TARGET_PUBLIC_HEADERS}
+    ${LIBC_TARGET}
 )
 
+# message(FATAL_ERROR "${public_test}")
+
 add_custom_target(libc-api-test)
 add_dependencies(check-libc libc-api-test)
 
diff --git a/libc/utils/HdrGen/PrototypeTestGen/CMakeLists.txt b/libc/utils/HdrGen/PrototypeTestGen/CMakeLists.txt
index 9e25c21c6b3593..331eb70b7e9891 100644
--- a/libc/utils/HdrGen/PrototypeTestGen/CMakeLists.txt
+++ b/libc/utils/HdrGen/PrototypeTestGen/CMakeLists.txt
@@ -1,5 +1,17 @@
+include(TableGen)
+
+set(LLVM_LINK_COMPONENTS Support)
+
 add_tablegen(libc-prototype-testgen LLVM_LIBC
   PrototypeTestGen.cpp
 )
-target_link_libraries(libc-prototype-testgen PRIVATE LibcTableGenUtil)
-target_include_directories(libc-prototype-testgen PRIVATE ${LIBC_SOURCE_DIR})
+target_link_libraries(libc-prototype-testgen
+  PRIVATE
+    LibcTableGenUtil
+)
+target_include_directories(libc-prototype-testgen
+  PRIVATE
+    ${LIBC_SOURCE_DIR}
+    ${LLVM_INCLUDE_DIR}
+    ${LLVM_MAIN_INCLUDE_DIR}
+)



More information about the libc-commits mailing list