[libc][For demonstration only] Refactor how errno is accessed in libc interal code.

[sivachandra]

Summary

Internal code should read/set errno using the new macro libc_errno
introduced by this change. When building for tests, this macro resolves
to an internal libc only errno variable. Which means, libc tests
will not affect the global errno value (the errno of the libc to which
the tests are linked to.)

Not all tests are clean but one should be able to build the libc after
this change.

libc/config/linux/x86_64/entrypoints.txt

set(TARGET_LIBC_ENTRYPOINTS
     libc.src.ctype.ispunct
     libc.src.ctype.isspace
     libc.src.ctype.isupper
     libc.src.ctype.isxdigit
     libc.src.ctype.toascii
     libc.src.ctype.tolower
     libc.src.ctype.toupper
 
+    libc.src.errno.errno
+
     # fcntl.h entrypoints
     libc.src.fcntl.creat
     libc.src.fcntl.open
     libc.src.fcntl.openat
 
     # sched.h entrypoints
     libc.src.sched.sched_getaffinity
     libc.src.sched.sched_setaffinity

libc/include/CMakeLists.txt

DEPENDS
     .llvm-libc-types.tss_dtor_t
 )
 
 add_gen_header(
   errno
   DEF_FILE errno.h.def
   GEN_HDR errno.h
   DEPENDS
+    .llvm_libc_common_h
     .llvm-libc-macros.generic_error_number_macros
 )
 
 add_gen_header(
   signal
   DEF_FILE signal.h.def
   PARAMS
     platform_signal=../config/${LIBC_TARGET_OS}/signal.h.in

libc/include/errno.h.def

 #ifndef ENOTRECOVERABLE
 #define ENOTRECOVERABLE 131
 #endif // ENOTRECOVERABLE
 
 #else // __linux__
 #include <llvm-libc-macros/generic-error-number-macros.h>
 #endif
 
+__BEGIN_C_DECLS
 extern _Thread_local int __llvmlibc_errno;
+__END_C_DECLS
 #define errno __llvmlibc_errno
 
 #endif // LLVM_LIBC_ERRNO_H

libc/src/errno/CMakeLists.txt

-if (LLVM_LIBC_FULL_BUILD)
-add_object_library(
+add_entrypoint_object(
   errno
   SRCS
-    errno.cpp
+    libc_errno.cpp
   HDRS
-    llvmlibc_errno.h
+    libc_errno.h
+  DEPENDS
+    libc.include.errno
+  COMPILE_OPTIONS
+    -fomit-frame-pointer
 )
-else()
-add_object_library(
-  errno
-  SRCS
-    dummy_errno.cpp
-  HDRS
-    dummy_errno.h
-)
-endif()

libc/src/errno/errno.cpp

-//===-- Implementation of __errno_location --------------------------------===//
-//
-// 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
-//
-//===----------------------------------------------------------------------===//
-
-thread_local int __llvmlibc_errno = 0;

libc/src/errno/libc_errno.h

+//===-- Implementation header for errno -------------------------*- 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_SRC_ERRNO_LLVMLIBC_ERRNO_H
+#define LLVM_LIBC_SRC_ERRNO_LLVMLIBC_ERRNO_H
+
+#include <errno.h>
+
+// Internal code (the libc runtime code as well as unit tests) should use this
+// and not use the errno macro from the public errno.h header.
+#ifdef LIBC_COPT_PUBLIC_PACKAGING
+// 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
+#else
+namespace __llvm_libc {
+extern "C" thread_local int __llvmlibc_internal_errno;
+} // namespace __llvm_libc
+#define libc_errno __llvm_libc::__llvmlibc_internal_errno
+#endif
+
+#endif // LLVM_LIBC_SRC_ERRNO_LLVMLIBC_ERRNO_H

libc/src/errno/libc_errno.cpp

+//===-- Implementation of errno -------------------------------------------===//
+//
+// 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 {
+
+extern "C" {
+#ifdef LIBC_COPT_PUBLIC_PACKAGING
+// 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.
+thread_local int __llvmlibc_errno;
+#else
+thread_local int __llvmlibc_internal_errno;
+#endif
+} // extern "C"
+
+} // namespace __llvm_libc

libc/src/errno/llvmlibc_errno.h

-//===-- Implementation header for errno -------------------------*- 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_SRC_ERRNO_LLVMLIBC_ERRNO_H
-#define LLVM_LIBC_SRC_ERRNO_LLVMLIBC_ERRNO_H
-
-// Internal code should use this and not use the errno macro from the
-// public header.
-extern thread_local int __llvmlibc_errno;
-#define llvmlibc_errno __llvmlibc_errno
-
-#endif // LLVM_LIBC_SRC_ERRNO_LLVMLIBC_ERRNO_H

libc/src/math/generic/exp2f.cpp

 //===-- Single-precision 2^x 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 "src/math/exp2f.h"
 #include "src/__support/FPUtil/FEnvImpl.h"
 #include "src/__support/FPUtil/FPBits.h"
 #include "src/__support/FPUtil/PolyEval.h"
 #include "src/__support/FPUtil/multiply_add.h"
 #include "src/__support/FPUtil/nearest_integer.h"
 #include "src/__support/common.h"
 #include "src/__support/macros/optimization.h" // LIBC_UNLIKELY
-
-#include <errno.h>
+#include "src/errno/libc_errno.h"
 
 #include "explogxf.h"
 
 namespace __llvm_libc {
 
 constexpr uint32_t exval1 = 0x3b42'9d37U;
 constexpr uint32_t exval2 = 0xbcf3'a937U;
 constexpr uint32_t exval_mask = exval1 & exval2;
if (LIBC_UNLIKELY(x_abs >= 0x4300'0000U)) {
     // x >= 128
     if (!xbits.get_sign()) {
       // x is finite
       if (x_u < 0x7f80'0000U) {
         int rounding = fputil::get_round();
         if (rounding == FE_DOWNWARD || rounding == FE_TOWARDZERO)
           return static_cast<float>(FPBits(FPBits::MAX_NORMAL));
 
-        errno = ERANGE;
+        libc_errno = ERANGE;
       }
       // x is +inf or nan
       return x + FPBits::inf().get_val();
     }
     // x <= -150
     if (x_u >= 0xc316'0000U) {
       // exp(-Inf) = 0
       if (xbits.is_inf())
         return 0.0f;
       // exp(nan) = nan
       if (xbits.is_nan())
         return x;
       if (fputil::get_round() == FE_UPWARD)
         return FPBits(FPBits::MIN_SUBNORMAL).get_val();
       if (x != 0.0f)
-        errno = ERANGE;
+        libc_errno = ERANGE;
       return 0.0f;
     }
   }
 
   // Check exceptional values.
   if (LIBC_UNLIKELY((x_u & exval_mask) == exval_mask)) {
     if (LIBC_UNLIKELY(x_u == exval1)) { // x = 0x1.853a6ep-9f
       if (fputil::get_round() == FE_TONEAREST)

libc/src/time/time_utils.h

 //===-- Collection of utils for mktime and friends --------------*- 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_SRC_TIME_TIME_UTILS_H
 #define LLVM_LIBC_SRC_TIME_TIME_UTILS_H
 
 #include <stddef.h> // For size_t.
 
 #include "include/errno.h"
 
 #include "src/__support/common.h"
-#include "src/errno/llvmlibc_errno.h"
+#include "src/errno/libc_errno.h"
 #include "src/time/mktime.h"
 
 #include <stdint.h>
 
 namespace __llvm_libc {
 namespace time_utils {
 
 enum Month : int {

 };
 
 // Update the "tm" structure's year, month, etc. members from seconds.
 // "total_seconds" is the number of seconds since January 1st, 1970.
 extern int64_t update_from_seconds(int64_t total_seconds, struct tm *tm);
 
 // POSIX.1-2017 requires this.
 LIBC_INLINE time_t out_of_range() {
-  llvmlibc_errno = EOVERFLOW;
+  libc_errno = EOVERFLOW;
   return static_cast<time_t>(-1);
 }
 
-LIBC_INLINE void invalid_value() { llvmlibc_errno = EINVAL; }
+LIBC_INLINE void invalid_value() { libc_errno = EINVAL; }
 
 LIBC_INLINE char *asctime(const struct tm *timeptr, char *buffer,
                           size_t bufferLength) {
   if (timeptr == nullptr || buffer == nullptr) {
     invalid_value();
     return nullptr;
   }
   if (timeptr->tm_wday < 0 ||

libc/test/UnitTest/CMakeLists.txt

 add_library(
   LibcFPTestHelpers
     FPExceptMatcher.cpp
     FPExceptMatcher.h
     FPMatcher.cpp
     FPMatcher.h
 )
 target_include_directories(LibcFPTestHelpers PUBLIC ${LIBC_SOURCE_DIR})
-target_link_libraries(LibcFPTestHelpers LibcUnitTest libc_test_utils)
+target_link_libraries(LibcFPTestHelpers LibcUnitTest libc_test_utils libc.src.errno.errno.__internal__)
 add_dependencies(
   LibcFPTestHelpers
   LibcUnitTest
   libc.test.UnitTest.string_utils
+  libc.src.errno.errno.__internal__
   libc.src.__support.FPUtil.fp_bits
   libc.src.__support.FPUtil.fenv_impl
 )
 
 add_library(
   LibcMemoryHelpers
     MemoryMatcher.h
     MemoryMatcher.cpp

libc/test/UnitTest/FPMatcher.h

 //===-- FPMatchers.h --------------------------------------------*- 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_UNITTEST_FPMATCHER_H
 #define LLVM_LIBC_UTILS_UNITTEST_FPMATCHER_H
 
 #include "src/__support/FPUtil/FEnvImpl.h"
 #include "src/__support/FPUtil/FPBits.h"
+#include "src/errno/libc_errno.h"
 #include "test/UnitTest/Test.h"
 #include "utils/testutils/RoundingModeUtils.h"
 
-#include <errno.h>
 #include <math.h>
 
 namespace __llvm_libc {
 namespace fputil {
 namespace testing {
 
 template <typename ValType, typename StreamType>
 cpp::enable_if_t<cpp::is_floating_point_v<ValType>, void>
#define ASSERT_FP_NE(expected, actual)                                         \
   ASSERT_THAT(                                                                 \
       actual,                                                                  \
       __llvm_libc::fputil::testing::getMatcher<__llvm_libc::testing::Cond_NE>( \
           expected))
 
 #define EXPECT_MATH_ERRNO(expected)                                            \
   do {                                                                         \
     if (math_errhandling & MATH_ERRNO) {                                       \
-      int actual = errno;                                                      \
-      errno = 0;                                                               \
+      int actual = libc_errno;                                                 \
+      libc_errno = 0;                                                          \
       EXPECT_EQ(actual, expected);                                             \
     }                                                                          \
   } while (0)
 
 #define ASSERT_MATH_ERRNO(expected)                                            \
   do {                                                                         \
     if (math_errhandling & MATH_ERRNO) {                                       \
-      int actual = errno;                                                      \
-      errno = 0;                                                               \
+      int actual = libc_errno;                                                 \
+      libc_errno = 0;                                                          \
       ASSERT_EQ(actual, expected);                                             \
     }                                                                          \
   } while (0)
 
 #define EXPECT_FP_EXCEPTION(expected)                                          \
   do {                                                                         \
     if (math_errhandling & MATH_ERREXCEPT) {                                   \
       EXPECT_EQ(__llvm_libc::fputil::test_except(FE_ALL_EXCEPT), expected);    \

libc/test/src/errno/CMakeLists.txt

-if(NOT LLVM_LIBC_FULL_BUILD)
-  return()
-endif()
-
 add_libc_testsuite(libc_errno_unittests)
 
 add_libc_unittest(
   errno_test
   SUITE
     libc_errno_unittests
   SRCS
     errno_test.cpp
   DEPENDS
+    libc.include.errno
     libc.src.errno.errno
 )

libc/test/src/errno/errno_test.cpp

 //===-- Unittests for errno -----------------------------------------------===//
 //
 // 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/errno/llvmlibc_errno.h"
+#include "src/errno/libc_errno.h"
 #include "test/UnitTest/Test.h"
 
 TEST(LlvmLibcErrnoTest, Basic) {
   int test_val = 123;
-  llvmlibc_errno = test_val;
-  ASSERT_EQ(test_val, llvmlibc_errno);
+  libc_errno = test_val;
+  ASSERT_EQ(test_val, libc_errno);
 }

libc/test/src/math/exp2f_test.cpp

 //===-- Unittests for exp2f -----------------------------------------------===//
 //
 // 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/FPUtil/FPBits.h"
 #include "src/__support/macros/properties/cpu_features.h" // LIBC_TARGET_CPU_HAS_FMA
+#include "src/errno/libc_errno.h"
 #include "src/math/exp2f.h"
 #include "test/UnitTest/FPMatcher.h"
 #include "test/UnitTest/Test.h"
 #include "utils/MPFRWrapper/MPFRUtils.h"
 #include <math.h>
 
 #include <errno.h>
 #include <stdint.h>
 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 DECLARE_SPECIAL_CONSTANTS(float)
 
 TEST(LlvmLibcExp2fTest, SpecialNumbers) {
-  errno = 0;
+  libc_errno = 0;
 
   EXPECT_FP_EQ(aNaN, __llvm_libc::exp2f(aNaN));
   EXPECT_MATH_ERRNO(0);
 
   EXPECT_FP_EQ(inf, __llvm_libc::exp2f(inf));
   EXPECT_MATH_ERRNO(0);
 
   EXPECT_FP_EQ(0.0f, __llvm_libc::exp2f(neg_inf));
   EXPECT_MATH_ERRNO(0);
 
   EXPECT_FP_EQ(1.0f, __llvm_libc::exp2f(0.0f));
   EXPECT_MATH_ERRNO(0);
 
   EXPECT_FP_EQ(1.0f, __llvm_libc::exp2f(-0.0f));
   EXPECT_MATH_ERRNO(0);
 }
 
 TEST(LlvmLibcExp2fTest, Overflow) {
-  errno = 0;
+  libc_errno = 0;
   EXPECT_FP_EQ(inf, __llvm_libc::exp2f(float(FPBits(0x7f7fffffU))));
   EXPECT_MATH_ERRNO(ERANGE);
 
   EXPECT_FP_EQ(inf, __llvm_libc::exp2f(float(FPBits(0x43000000U))));
   EXPECT_MATH_ERRNO(ERANGE);
 
   EXPECT_FP_EQ(inf, __llvm_libc::exp2f(float(FPBits(0x43000001U))));
   EXPECT_MATH_ERRNO(ERANGE);
constexpr uint32_t INPUTS[N] = {
       0xb8d3d026U, /*-0x1.a7a04cp-14f*/
       0xbcf3a937U, /*-0x1.e7526ep-6f*/
       0xc2fa0001U, /*-0x1.f40002p+6f*/
       0xc2fc0000U, /*-0x1.f8p+6f*/
       0xc2fc0001U, /*-0x1.f80002p+6f*/
       0xc3150000U, /*-0x1.2ap+7f*/
   };
   for (int i = 0; i < N; ++i) {
-    errno = 0;
+    libc_errno = 0;
     float x = float(FPBits(INPUTS[i]));
     EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp2, x,
                                    __llvm_libc::exp2f(x), 0.5);
     EXPECT_MATH_ERRNO(0);
   }
 }
 
 TEST(LlvmLibcExp2fTest, Underflow) {
-  errno = 0;
+  libc_errno = 0;
   EXPECT_FP_EQ(0.0f, __llvm_libc::exp2f(float(FPBits(0xff7fffffU))));
   EXPECT_MATH_ERRNO(ERANGE);
 
   float x = float(FPBits(0xc3158000U));
   EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp2, x,
                                  __llvm_libc::exp2f(x), 0.5);
   EXPECT_MATH_ERRNO(0);
 

 
 TEST(LlvmLibcExp2fTest, InFloatRange) {
   constexpr uint32_t COUNT = 1000000;
   constexpr uint32_t STEP = UINT32_MAX / COUNT;
   for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
     float x = float(FPBits(v));
     if (isnan(x) || isinf(x))
       continue;
-    errno = 0;
+    libc_errno = 0;
     float result = __llvm_libc::exp2f(x);
 
     // If the computation resulted in an error or did not produce valid result
     // in the single-precision floating point range, then ignore comparing with
     // MPFR result as MPFR can still produce valid results because of its
     // wider precision.
-    if (isnan(result) || isinf(result) || errno != 0)
+    if (isnan(result) || isinf(result) || libc_errno != 0)
       continue;
     ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp2, x,
                                    __llvm_libc::exp2f(x), 0.5);
   }
 }