Update libc_errno to work correctly for both overlay and full build modes.

Author: lntue

libc/src/errno/CMakeLists.txt

@@ -1,9 +1,16 @@
+set(full_build_flag "")
+if(LLVM_LIBC_FULL_BUILD)
+  set(full_build_flag "-DLIBC_FULL_BUILD")
+endif()
+
 add_entrypoint_object(
   errno
   SRCS
     libc_errno.cpp
   HDRS
     libc_errno.h     # Include this
+  COMPILE_OPTIONS
+    ${full_build_flag}
   DEPENDS
     libc.include.errno
     libc.src.__support.common

libc/src/errno/libc_errno.cpp

@@ -11,30 +11,44 @@
 
 namespace LIBC_NAMESPACE {
 
-#ifdef LIBC_TARGET_ARCH_IS_GPU
-struct ErrnoConsumer {
-  void operator=(int) {}
+struct Errno {
+  void operator=(int);
+  operator int();
 };
-#endif
 
-extern "C" {
-#ifdef LIBC_COPT_PUBLIC_PACKAGING
-// TODO: Declare __llvmlibc_errno only under LIBC_COPT_PUBLIC_PACKAGING and
-// __llvmlibc_internal_errno otherwise.
-// In overlay mode, this will be an unused thread local variable as libc_errno
-// will resolve to errno from the system libc's errno.h. In full build mode
-// however, libc_errno will resolve to this thread local variable via the errno
-// macro defined in LLVM libc's public errno.h header file.
-// TODO: Use a macro to distinguish full build and overlay build which can be
-//       used to exclude __llvmlibc_errno under overlay build.
+} // namespace LIBC_NAMESPACE
+
 #ifdef LIBC_TARGET_ARCH_IS_GPU
-ErrnoConsumer __llvmlibc_errno;
-#else
+// If we are targeting the GPU we currently don't support 'errno'. We simply
+// consume it.
+void LIBC_NAMESPACE::Errno::operator=(int) {}
+LIBC_NAMESPACE::Errno::operator int() { return 0; }
+
+#elif !defined(LIBC_COPT_PUBLIC_PACKAGING)
+// This mode is for unit testing.  We just use another internal errno.
+LIBC_THREAD_LOCAL int __llvmlibc_internal_errno;
+
+void LIBC_NAMESPACE::Errno::operator=(int a) { __llvmlibc_internal_errno = a; }
+LIBC_NAMESPACE::Errno::operator int() { return __llvmlibc_internal_errno; }
+
+#elif defined(LIBC_FULL_BUILD)
+// This mode is for public libc archive, hermetic, and integration tests.
+// In full build mode, we provide all the errno storage ourselves.
+extern "C" {
 LIBC_THREAD_LOCAL int __llvmlibc_errno;
-#endif // LIBC_TARGET_ARCH_IS_GPU
+}
+
+void LIBC_NAMESPACE::Errno::operator=(int a) { __llvmlibc_errno = a; }
+LIBC_NAMESPACE::Errno::operator int() { return __llvmlibc_errno; }
+
 #else
-LIBC_THREAD_LOCAL int __llvmlibc_internal_errno;
-#endif
-} // extern "C"
+// In overlay mode, we simply use the system errno.
+#include <errno.h>
 
-} // namespace LIBC_NAMESPACE
+void LIBC_NAMESPACE::Errno::operator=(int a) { errno = a; }
+LIBC_NAMESPACE::Errno::operator int() { return errno; }
+
+#endif // LIBC_FULL_BUILD
+
+// Define the global `libc_errno` instance.
+LIBC_NAMESPACE::Errno libc_errno;

libc/src/errno/libc_errno.h

@@ -14,43 +14,17 @@
 
 #include <errno.h>
 
-// If we are targeting the GPU we currently don't support 'errno'. We simply
-// consume it.
-#ifdef LIBC_TARGET_ARCH_IS_GPU
+// This header is to be consumed by internal implementations, in which all of
+// them should refer to `libc_errno` instead of using `errno` directly from
+// <errno.h> header.
+
 namespace LIBC_NAMESPACE {
-struct ErrnoConsumer {
-  void operator=(int) {}
+struct Errno {
+  void operator=(int);
+  operator int();
 };
 } // namespace LIBC_NAMESPACE
-#endif
-
-// All of the libc runtime and test code should use the "libc_errno" macro. They
-// should not refer to the "errno" macro directly.
-#ifdef LIBC_COPT_PUBLIC_PACKAGING
-#ifdef LIBC_TARGET_ARCH_IS_GPU
-extern "C" LIBC_NAMESPACE::ErrnoConsumer __llvmlibc_errno;
-#define libc_errno __llvmlibc_errno
-#else
-// This macro will resolve to errno from the errno.h file included above. Under
-// full build, this will be LLVM libc's errno. In overlay build, it will be
-// system libc's errno.
-#define libc_errno errno
-#endif
-#else
-namespace LIBC_NAMESPACE {
 
-// TODO: On the GPU build this will be mapped to a single global value. We need
-// to ensure that tests are not run with multiple threads that depend on errno
-// until we have true 'thread_local' support on the GPU.
-extern "C" LIBC_THREAD_LOCAL int __llvmlibc_internal_errno;
-
-// TODO: After all of libc/src and libc/test are switched over to use
-// libc_errno, this header file will be "shipped" via an add_entrypoint_object
-// target. At which point libc_errno, should point to __llvmlibc_internal_errno
-// if LIBC_COPT_PUBLIC_PACKAGING is not defined.
-#define libc_errno LIBC_NAMESPACE::__llvmlibc_internal_errno
-
-} // namespace LIBC_NAMESPACE
-#endif
+extern LIBC_NAMESPACE::Errno libc_errno;
 
 #endif // LLVM_LIBC_SRC_ERRNO_LIBC_ERRNO_H

libc/test/integration/src/pthread/pthread_create_test.cpp

@@ -47,7 +47,7 @@ static void *successThread(void *Arg) {
   pthread_t th = LIBC_NAMESPACE::pthread_self();
   auto *thread = reinterpret_cast<LIBC_NAMESPACE::Thread *>(&th);
 
-  ASSERT_EQ(libc_errno, 0);
+  ASSERT_EQ(static_cast<int>(libc_errno), 0);
   ASSERT_TRUE(thread);
   ASSERT_TRUE(thread->attrib);
 
@@ -62,22 +62,22 @@ static void *successThread(void *Arg) {
   ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_getstack(expec_attrs, &expec_stack,
                                                   &expec_stacksize),
             0);
-  ASSERT_EQ(libc_errno, 0);
+  ASSERT_EQ(static_cast<int>(libc_errno), 0);
 
   ASSERT_EQ(
       LIBC_NAMESPACE::pthread_attr_getstacksize(expec_attrs, &expec_stacksize2),
       0);
-  ASSERT_EQ(libc_errno, 0);
+  ASSERT_EQ(static_cast<int>(libc_errno), 0);
 
   ASSERT_EQ(
       LIBC_NAMESPACE::pthread_attr_getguardsize(expec_attrs, &expec_guardsize),
       0);
-  ASSERT_EQ(libc_errno, 0);
+  ASSERT_EQ(static_cast<int>(libc_errno), 0);
 
   ASSERT_EQ(
       LIBC_NAMESPACE::pthread_attr_getdetachstate(expec_attrs, &expec_detached),
       0);
-  ASSERT_EQ(libc_errno, 0);
+  ASSERT_EQ(static_cast<int>(libc_errno), 0);
 
   ASSERT_EQ(expec_stacksize, expec_stacksize2);
 
@@ -125,7 +125,7 @@ static void *successThread(void *Arg) {
   // permissions. Maybe we can read from /proc/{self}/map?
 
   ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_destroy(expec_attrs), 0);
-  ASSERT_EQ(libc_errno, 0);
+  ASSERT_EQ(static_cast<int>(libc_errno), 0);
 
   // Arg is malloced, so free.
   delete th_arg;
@@ -140,34 +140,34 @@ static void run_success_config(int detachstate, size_t guardsize,
   pthread_attr_t *attr = &(th_arg->attrs);
 
   ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_init(attr), 0);
-  ASSERT_EQ(libc_errno, 0);
+  ASSERT_EQ(static_cast<int>(libc_errno), 0);
 
   ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_setdetachstate(attr, detachstate), 0);
-  ASSERT_EQ(libc_errno, 0);
+  ASSERT_EQ(static_cast<int>(libc_errno), 0);
 
   ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_setguardsize(attr, guardsize), 0);
-  ASSERT_EQ(libc_errno, 0);
+  ASSERT_EQ(static_cast<int>(libc_errno), 0);
 
   void *Stack = nullptr;
   if (customstack) {
     Stack = LIBC_NAMESPACE::mmap(nullptr, stacksize, PROT_READ | PROT_WRITE,
                                  MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
     ASSERT_NE(Stack, MAP_FAILED);
     ASSERT_NE(Stack, static_cast<void *>(nullptr));
-    ASSERT_EQ(libc_errno, 0);
+    ASSERT_EQ(static_cast<int>(libc_errno), 0);
 
     ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_setstack(attr, Stack, stacksize), 0);
-    ASSERT_EQ(libc_errno, 0);
+    ASSERT_EQ(static_cast<int>(libc_errno), 0);
   } else {
     ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_setstacksize(attr, stacksize), 0);
-    ASSERT_EQ(libc_errno, 0);
+    ASSERT_EQ(static_cast<int>(libc_errno), 0);
   }
 
   void *expec_ret = nullptr;
   if (detachstate == PTHREAD_CREATE_JOINABLE) {
     ASSERT_EQ(LIBC_NAMESPACE::getrandom(&expec_ret, sizeof(expec_ret), 0),
               static_cast<ssize_t>(sizeof(expec_ret)));
-    ASSERT_EQ(libc_errno, 0);
+    ASSERT_EQ(static_cast<int>(libc_errno), 0);
   }
 
   th_arg->ret = expec_ret;
@@ -178,17 +178,17 @@ static void run_success_config(int detachstate, size_t guardsize,
   ASSERT_EQ(LIBC_NAMESPACE::pthread_create(&tid, attr, successThread,
                                            reinterpret_cast<void *>(th_arg)),
             0);
-  ASSERT_EQ(libc_errno, 0);
+  ASSERT_EQ(static_cast<int>(libc_errno), 0);
 
   if (detachstate == PTHREAD_CREATE_JOINABLE) {
     void *th_ret;
     ASSERT_EQ(LIBC_NAMESPACE::pthread_join(tid, &th_ret), 0);
-    ASSERT_EQ(libc_errno, 0);
+    ASSERT_EQ(static_cast<int>(libc_errno), 0);
     ASSERT_EQ(th_ret, expec_ret);
 
     if (customstack) {
       ASSERT_EQ(LIBC_NAMESPACE::munmap(Stack, stacksize), 0);
-      ASSERT_EQ(libc_errno, 0);
+      ASSERT_EQ(static_cast<int>(libc_errno), 0);
     }
   } else {
     ASSERT_FALSE(customstack);
@@ -260,23 +260,23 @@ static void create_and_check_failure_thread(pthread_attr_t *attr) {
   // was just really larger we failed mmap.
   ASSERT_TRUE(result == EINVAL || result == EAGAIN);
   // pthread_create should NOT set errno on error
-  ASSERT_EQ(libc_errno, 0);
+  ASSERT_EQ(static_cast<int>(libc_errno), 0);
 
   ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_destroy(attr), 0);
-  ASSERT_EQ(libc_errno, 0);
+  ASSERT_EQ(static_cast<int>(libc_errno), 0);
 }
 
 static void run_failure_config(size_t guardsize, size_t stacksize) {
   pthread_attr_t attr;
   guardsize &= -EXEC_PAGESIZE;
   ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_init(&attr), 0);
-  ASSERT_EQ(libc_errno, 0);
+  ASSERT_EQ(static_cast<int>(libc_errno), 0);
 
   ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_setguardsize(&attr, guardsize), 0);
-  ASSERT_EQ(libc_errno, 0);
+  ASSERT_EQ(static_cast<int>(libc_errno), 0);
 
   ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_setstacksize(&attr, stacksize), 0);
-  ASSERT_EQ(libc_errno, 0);
+  ASSERT_EQ(static_cast<int>(libc_errno), 0);
 
   create_and_check_failure_thread(&attr);
 }
@@ -301,32 +301,32 @@ static void run_failure_tests() {
 
   // Stacksize too small.
   ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_init(&attr), 0);
-  ASSERT_EQ(libc_errno, 0);
+  ASSERT_EQ(static_cast<int>(libc_errno), 0);
   attr.__stacksize = PTHREAD_STACK_MIN - 16;
   create_and_check_failure_thread(&attr);
 
   // Stack misaligned.
   ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_init(&attr), 0);
-  ASSERT_EQ(libc_errno, 0);
+  ASSERT_EQ(static_cast<int>(libc_errno), 0);
   attr.__stack = reinterpret_cast<void *>(1);
   create_and_check_failure_thread(&attr);
 
   // Stack + stacksize misaligned.
   ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_init(&attr), 0);
-  ASSERT_EQ(libc_errno, 0);
+  ASSERT_EQ(static_cast<int>(libc_errno), 0);
   attr.__stacksize = PTHREAD_STACK_MIN + 1;
   attr.__stack = reinterpret_cast<void *>(16);
   create_and_check_failure_thread(&attr);
 
   // Guardsize misaligned.
   ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_init(&attr), 0);
-  ASSERT_EQ(libc_errno, 0);
+  ASSERT_EQ(static_cast<int>(libc_errno), 0);
   attr.__guardsize = EXEC_PAGESIZE / 2;
   create_and_check_failure_thread(&attr);
 
   // Detachstate is unknown.
   ASSERT_EQ(LIBC_NAMESPACE::pthread_attr_init(&attr), 0);
-  ASSERT_EQ(libc_errno, 0);
+  ASSERT_EQ(static_cast<int>(libc_errno), 0);
   attr.__detachstate = -1;
   create_and_check_failure_thread(&attr);
 }

libc/test/integration/src/pthread/pthread_join_test.cpp

@@ -19,9 +19,9 @@ static void nullJoinTest() {
   pthread_t Tid;
   ASSERT_EQ(LIBC_NAMESPACE::pthread_create(&Tid, nullptr, simpleFunc, nullptr),
             0);
-  ASSERT_EQ(libc_errno, 0);
+  ASSERT_EQ(static_cast<int>(libc_errno), 0);
   ASSERT_EQ(LIBC_NAMESPACE::pthread_join(Tid, nullptr), 0);
-  ASSERT_EQ(libc_errno, 0);
+  ASSERT_EQ(static_cast<int>(libc_errno), 0);
 }
 
 TEST_MAIN() {

libc/test/integration/src/unistd/getcwd_test.cpp

@@ -30,7 +30,7 @@ TEST_MAIN(int argc, char **argv, char **envp) {
   // Bad size
   cwd = LIBC_NAMESPACE::getcwd(buffer, 0);
   ASSERT_TRUE(cwd == nullptr);
-  ASSERT_EQ(libc_errno, EINVAL);
+  ASSERT_EQ(static_cast<int>(libc_errno), EINVAL);
   libc_errno = 0;
 
   // Insufficient size

libc/test/src/dirent/dirent_test.cpp

@@ -44,7 +44,7 @@ TEST(LlvmLibcDirentTest, SimpleOpenAndRead) {
   }
 
   // Verify that we don't break out of the above loop in error.
-  ASSERT_EQ(libc_errno, 0);
+  ASSERT_EQ(static_cast<int>(libc_errno), 0);
 
   ASSERT_TRUE(file1 != nullptr);
   ASSERT_TRUE(file2 != nullptr);
@@ -58,14 +58,14 @@ TEST(LlvmLibcDirentTest, OpenNonExistentDir) {
   libc_errno = 0;
   ::DIR *dir = LIBC_NAMESPACE::opendir("___xyz123__.non_existent__");
   ASSERT_TRUE(dir == nullptr);
-  ASSERT_EQ(libc_errno, ENOENT);
+  ASSERT_EQ(static_cast<int>(libc_errno), ENOENT);
   libc_errno = 0;
 }
 
 TEST(LlvmLibcDirentTest, OpenFile) {
   libc_errno = 0;
   ::DIR *dir = LIBC_NAMESPACE::opendir("testdata/file1.txt");
   ASSERT_TRUE(dir == nullptr);
-  ASSERT_EQ(libc_errno, ENOTDIR);
+  ASSERT_EQ(static_cast<int>(libc_errno), ENOTDIR);
   libc_errno = 0;
 }

libc/test/src/errno/errno_test.cpp

@@ -12,5 +12,5 @@
 TEST(LlvmLibcErrnoTest, Basic) {
   int test_val = 123;
   libc_errno = test_val;
-  ASSERT_EQ(test_val, libc_errno);
+  ASSERT_EQ(static_cast<int>(libc_errno), test_val);
 }

libc/test/src/fcntl/creat_test.cpp

@@ -19,12 +19,12 @@ TEST(LlvmLibcCreatTest, CreatAndOpen) {
   using LIBC_NAMESPACE::testing::ErrnoSetterMatcher::Succeeds;
   constexpr const char *TEST_FILE = "testdata/creat.test";
   int fd = LIBC_NAMESPACE::creat(TEST_FILE, S_IRWXU);
-  ASSERT_EQ(libc_errno, 0);
+  ASSERT_EQ(static_cast<int>(libc_errno), 0);
   ASSERT_GT(fd, 0);
   ASSERT_THAT(LIBC_NAMESPACE::close(fd), Succeeds(0));
 
   fd = LIBC_NAMESPACE::open(TEST_FILE, O_RDONLY);
-  ASSERT_EQ(libc_errno, 0);
+  ASSERT_EQ(static_cast<int>(libc_errno), 0);
   ASSERT_GT(fd, 0);
   ASSERT_THAT(LIBC_NAMESPACE::close(fd), Succeeds(0));
 

libc/test/src/fcntl/openat_test.cpp

@@ -21,13 +21,13 @@ TEST(LlvmLibcUniStd, OpenAndReadTest) {
   constexpr const char *TEST_DIR = "testdata";
   constexpr const char *TEST_FILE = "openat.test";
   int dir_fd = LIBC_NAMESPACE::open(TEST_DIR, O_DIRECTORY);
-  ASSERT_EQ(libc_errno, 0);
+  ASSERT_EQ(static_cast<int>(libc_errno), 0);
   ASSERT_GT(dir_fd, 0);
   constexpr const char TEST_MSG[] = "openat test";
   constexpr int TEST_MSG_SIZE = sizeof(TEST_MSG) - 1;
 
   int read_fd = LIBC_NAMESPACE::openat(dir_fd, TEST_FILE, O_RDONLY);
-  ASSERT_EQ(libc_errno, 0);
+  ASSERT_EQ(static_cast<int>(libc_errno), 0);
   ASSERT_GT(read_fd, 0);
   char read_buf[TEST_MSG_SIZE];
   ASSERT_THAT(LIBC_NAMESPACE::read(read_fd, read_buf, TEST_MSG_SIZE),