[libc] move stdlib and stdio to new errno pattern

[michaelrj]

Summary

Fixes https://github.com/llvm/llvm-project/issues/61071

[michaelrj]

also fix tests

[sivachandra]

A general comment: If a function is just using the symbolic error values like EINVAL, it can still include <errno.h> directly. Only those places where the errno is updated/read need to include src/errno/errno.h and depend on libc.src.errno.errno.

libc/src/stdio/CMakeLists.txt

28

I think you should add a new dep on libc.src.errno.errno for all of these targets?

[michaelrj]

While we could include <errno.h> from those targets, I think it's easier to read if all of the files include the same target.

[sivachandra]

libc/src/__support/StringUtil/CMakeLists.txt

18

Add the dep on libc.src.errno.errno.

libc/src/__support/threads/linux/thread.cpp

18

A corresponding dep should be added?

[michaelrj]

address final comments before landing

libc/src/__support/CMakeLists.txt

 
 add_header_library(
   str_to_integer
   HDRS
     str_to_integer.h
   DEPENDS
     .ctype_utils
     .str_to_num_result
-    libc.include.errno
     libc.src.errno.errno
     libc.src.__support.CPP.limits
     libc.src.__support.common
 )
 
 add_header_library(
   integer_to_string
   HDRS

libc/src/__support/File/CMakeLists.txt

 if(NOT (TARGET libc.src.__support.threads.mutex))
   # Not all platforms have a mutex implementation. If mutex is unvailable,
   # we just skip everything about files.
   return()
 endif()
 
 add_object_library(
   file
   SRCS
     file.cpp
   HDRS
     file.h
   DEPENDS
-    libc.include.errno
+    
     libc.src.__support.CPP.new
     libc.src.__support.CPP.span
     libc.src.__support.threads.mutex
     libc.src.__support.error_or
 )
 
 add_object_library(
   dir

 
 if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${LIBC_TARGET_OS}_file.cpp)
   add_object_library(
     platform_file
     SRCS
       ${LIBC_TARGET_OS}_file.cpp
     DEPENDS
       .file
-      libc.include.errno
+      
       libc.include.fcntl
       libc.include.stdio
       libc.include.sys_syscall
       libc.src.__support.CPP.new
       libc.src.__support.OSUtil.osutil
       libc.src.errno.errno
       libc.src.__support.error_or
   )
 endif()
 
 if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${LIBC_TARGET_OS}_dir.cpp)
   add_object_library(
     platform_dir
     SRCS
       ${LIBC_TARGET_OS}_dir.cpp
     DEPENDS
       .dir
-      libc.include.errno
       libc.include.fcntl
       libc.include.sys_syscall
       libc.src.__support.OSUtil.osutil
       libc.src.__support.error_or
   )
 endif()

libc/src/__support/File/dir.cpp

 //===--- Implementation of a platform independent Dir data structure ------===//
 //
 // 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 "dir.h"
 
 #include "src/__support/CPP/new.h"
 #include "src/__support/error_or.h"
+#include "src/errno/libc_errno.h" // For error macros
 
-#include <errno.h>
 #include <stdlib.h>
 
 namespace __llvm_libc {
 
 ErrorOr<Dir *> Dir::open(const char *path) {
   auto fd = platform_opendir(path);
   if (!fd)
     return __llvm_libc::Error(fd.error());

libc/src/__support/File/file.cpp

 //===--- Implementation of a platform independent file data structure -----===//
 //
 // 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 "file.h"
 
 #include "src/__support/CPP/new.h"
 #include "src/__support/CPP/span.h"
+#include "src/errno/libc_errno.h" // For error macros
 
-#include <errno.h> // For error macros
 #include <stdio.h>
 #include <stdlib.h>
 
 namespace __llvm_libc {
 
 FileIOResult File::write_unlocked(const void *data, size_t len) {
   if (!write_allowed()) {
     err = true;

libc/src/__support/File/linux_file.cpp

 //===--- Linux specialization of the File data structure ------------------===//
 //
 // 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 "file.h"
 
 #include "src/__support/CPP/new.h"
 #include "src/__support/OSUtil/syscall.h" // For internal syscall function.
+#include "src/errno/libc_errno.h"         // For error macros
 
-#include <errno.h> // For error macros
 #include <fcntl.h> // For mode_t and other flags to the open syscall
 #include <stdio.h>
 #include <sys/syscall.h> // For syscall numbers
 
 namespace __llvm_libc {
 
 namespace {
 

libc/src/__support/StringUtil/CMakeLists.txt

 add_object_library(
   error_to_string
   HDRS
     error_to_string.h
   SRCS
     error_to_string.cpp
   DEPENDS
   .message_mapper
-  libc.include.errno
   libc.src.__support.CPP.span
   libc.src.__support.CPP.string_view
   libc.src.__support.CPP.stringstream
   libc.src.__support.integer_to_string
 )
 
 
 add_object_library(

libc/src/__support/StringUtil/error_to_string.cpp

 //===-- Implementation of a class for mapping errors to strings -----------===//
 //
 // 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/StringUtil/error_to_string.h"
 
 #include "src/__support/CPP/span.h"
 #include "src/__support/CPP/string_view.h"
 #include "src/__support/CPP/stringstream.h"
 #include "src/__support/StringUtil/message_mapper.h"
 #include "src/__support/integer_to_string.h"
+#include "src/errno/libc_errno.h" // For error macros
 
-#include <errno.h>
 #include <stddef.h>
 
 namespace __llvm_libc {
 namespace internal {
 
 constexpr size_t max_buff_size() {
   constexpr size_t unknown_str_len = sizeof("Unknown error");
   constexpr size_t max_num_len =

libc/src/__support/str_to_float.h

 #include "src/__support/UInt128.h"
 #include "src/__support/builtin_wrappers.h"
 #include "src/__support/common.h"
 #include "src/__support/ctype_utils.h"
 #include "src/__support/detailed_powers_of_ten.h"
 #include "src/__support/high_precision_decimal.h"
 #include "src/__support/str_to_integer.h"
 #include "src/__support/str_to_num_result.h"
-#include <errno.h>
+#include "src/errno/libc_errno.h" // For ERANGE
 
 namespace __llvm_libc {
 namespace internal {
 
 template <class T> struct ExpandedFloat {
   typename fputil::FPBits<T>::UIntType mantissa;
   int32_t exponent;
 };

libc/src/__support/str_to_integer.h

 //===-- String to integer conversion utils ----------------------*- 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 LIBC_SRC_SUPPORT_STR_TO_INTEGER_H
 #define LIBC_SRC_SUPPORT_STR_TO_INTEGER_H
 
 #include "src/__support/CPP/limits.h"
 #include "src/__support/common.h"
 #include "src/__support/ctype_utils.h"
 #include "src/__support/str_to_num_result.h"
-#include <errno.h>
+#include "src/errno/libc_errno.h" // For ERANGE
 #include <limits.h>
 
 namespace __llvm_libc {
 namespace internal {
 
 // Returns a pointer to the first character in src that is not a whitespace
 // character (as determined by isspace())
 LIBC_INLINE const char *first_non_whitespace(const char *__restrict src) {

libc/src/__support/threads/linux/thread.cpp

 #include "config/linux/app.h"
 #include "src/__support/CPP/atomic.h"
 #include "src/__support/CPP/string_view.h"
 #include "src/__support/CPP/stringstream.h"
 #include "src/__support/OSUtil/syscall.h" // For syscall functions.
 #include "src/__support/common.h"
 #include "src/__support/error_or.h"
 #include "src/__support/threads/linux/futex_word.h" // For FutexWordType
+#include "src/errno/libc_errno.h"                   // For error macros
 
 #ifdef LIBC_TARGET_ARCH_IS_AARCH64
 #include <arm_acle.h>
 #endif
 
-#include <errno.h>
 #include <fcntl.h>
 #include <linux/futex.h>
 #include <linux/prctl.h> // For PR_SET_NAME
 #include <linux/sched.h> // For CLONE_* flags.
 #include <stdint.h>
 #include <sys/mman.h>    // For PROT_* and MAP_* definitions.
 #include <sys/syscall.h> // For syscall numbers.
 

libc/src/stdio/CMakeLists.txt

 add_entrypoint_object(
   fclose
   SRCS
     fclose.cpp
   HDRS
     fclose.h
   DEPENDS
     libc.include.stdio
-    libc.include.errno
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
 )
 
 add_entrypoint_object(
   clearerr
   SRCS
     clearerr.cpp

 
 add_entrypoint_object(
   fgetc
   SRCS
     fgetc.cpp
   HDRS
     fgetc.h
   DEPENDS
-    libc.include.errno
     libc.include.stdio
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
 )
 
 add_entrypoint_object(
   fgetc_unlocked
   SRCS
     fgetc_unlocked.cpp
   HDRS
     fgetc_unlocked.h
   DEPENDS
-    libc.include.errno
     libc.include.stdio
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
 )
 
 add_entrypoint_object(
   getc
   SRCS
     getc.cpp
   HDRS
     getc.h
   DEPENDS
-    libc.include.errno
     libc.include.stdio
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
 )
 
 add_entrypoint_object(
   getc_unlocked
   SRCS
     getc_unlocked.cpp
   HDRS
     getc_unlocked.h
   DEPENDS
-    libc.include.errno
     libc.include.stdio
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
 )
 
 add_entrypoint_object(
   fgets
   SRCS
     fgets.cpp
   HDRS
     fgets.h
   DEPENDS
-    libc.include.errno
     libc.include.stdio
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
 )
 
 add_entrypoint_object(
   fflush
   SRCS
     fflush.cpp
   HDRS
     fflush.h
   DEPENDS
-    libc.include.errno
     libc.include.stdio
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
 )
 
 add_entrypoint_object(
   flockfile
   SRCS

 
 add_entrypoint_object(
   fread_unlocked
   SRCS
     fread_unlocked.cpp
   HDRS
     fread_unlocked.h
   DEPENDS
-    libc.include.errno
     libc.include.stdio
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
 )
 
 add_entrypoint_object(
   fread
   SRCS
     fread.cpp
   HDRS
     fread.h
   DEPENDS
-    libc.include.errno
     libc.include.stdio
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
 )
 
 add_entrypoint_object(
   fwrite_unlocked
   SRCS
     fwrite_unlocked.cpp
   HDRS
     fwrite_unlocked.h
   DEPENDS
-    libc.include.errno
     libc.include.stdio
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
 )
 
 add_entrypoint_object(
   fwrite
   SRCS
     fwrite.cpp
   HDRS
     fwrite.h
   DEPENDS
-    libc.include.errno
     libc.include.stdio
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
 )
 
 add_entrypoint_object(
   fputc
   SRCS
     fputc.cpp
   HDRS
     fputc.h
   DEPENDS
-    libc.include.errno
     libc.include.stdio
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
 )
 
 add_entrypoint_object(
   putc
   SRCS
     putc.cpp
   HDRS
     putc.h
   DEPENDS
-    libc.include.errno
     libc.include.stdio
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
 )
 
 add_entrypoint_object(
   putchar
   SRCS
     putchar.cpp
   HDRS
     putchar.h
   DEPENDS
-    libc.include.errno
     libc.include.stdio
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
 )
 
 add_entrypoint_object(
   fputs
   SRCS
     fputs.cpp
   HDRS
     fputs.h
   DEPENDS
-    libc.include.errno
     libc.include.stdio
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
 )
 
 
 add_entrypoint_object(
   puts
   SRCS
     puts.cpp
   HDRS
     puts.h
   DEPENDS
-    libc.include.errno
     libc.include.stdio
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
 )
 
 add_entrypoint_object(
   fseek
   SRCS
     fseek.cpp
   HDRS
     fseek.h
   DEPENDS
-    libc.include.errno
     libc.include.stdio
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
 )
 
 add_entrypoint_object(
   ungetc
   SRCS

 
 add_entrypoint_object(
   setbuf
   SRCS
     setbuf.cpp
   HDRS
     setbuf.h
   DEPENDS
-    libc.include.errno
     libc.include.stdio
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
 )
 
 add_entrypoint_object(
   setvbuf
   SRCS
     setvbuf.cpp
   HDRS
     setvbuf.h
   DEPENDS
-    libc.include.errno
     libc.include.stdio
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
 )
 
 add_entrypoint_object(
   sscanf
   SRCS

 
 add_entrypoint_object(
   ftell
   SRCS
     ftell.cpp
   HDRS
     ftell.h
   DEPENDS
-    libc.include.errno
     libc.include.stdio
     libc.src.__support.File.file
     libc.src.__support.File.platform_file
 )
 
 add_entrypoint_object(
   remove
   ALIAS
   DEPENDS
     .${LIBC_TARGET_OS}.remove
 )

libc/src/stdio/fclose.cpp

 //===-- Implementation of fclose ------------------------------------------===//
 //
 // 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/stdio/fclose.h"
 #include "src/__support/File/file.h"
 
-#include <errno.h>
+#include "src/errno/libc_errno.h"
 #include <stdio.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, fclose, (::FILE * stream)) {
   auto *file = reinterpret_cast<__llvm_libc::File *>(stream);
   int result = File::cleanup(file);
   if (result != 0) {
-    errno = result;
+    libc_errno = result;
     return EOF;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/stdio/fflush.cpp

 //===-- Implementation of fflush ------------------------------------------===//
 //
 // 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/stdio/fflush.h"
 #include "src/__support/File/file.h"
 
-#include <errno.h>
+#include "src/errno/libc_errno.h"
 #include <stdio.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, fflush, (::FILE * stream)) {
   int result = reinterpret_cast<__llvm_libc::File *>(stream)->flush();
   if (result != 0) {
-    errno = result;
+    libc_errno = result;
     return EOF;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/stdio/fgetc.cpp

 //===-- Implementation of fgetc -------------------------------------------===//
 //
 // 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/stdio/fgetc.h"
 #include "src/__support/File/file.h"
 
-#include <errno.h>
+#include "src/errno/libc_errno.h"
 #include <stdio.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, fgetc, (::FILE * stream)) {
   unsigned char c;
   auto result = reinterpret_cast<__llvm_libc::File *>(stream)->read(&c, 1);
   size_t r = result.value;
   if (result.has_error())
-    errno = result.error;
+    libc_errno = result.error;
 
   if (r != 1)
     return EOF;
   return c;
 }
 
 } // namespace __llvm_libc

libc/src/stdio/fgetc_unlocked.cpp

 //===-- Implementation of fgetc_unlocked ----------------------------------===//
 //
 // 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/stdio/fgetc_unlocked.h"
 #include "src/__support/File/file.h"
 
-#include <errno.h>
+#include "src/errno/libc_errno.h"
 #include <stdio.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, fgetc_unlocked, (::FILE * stream)) {
   unsigned char c;
   auto result =
       reinterpret_cast<__llvm_libc::File *>(stream)->read_unlocked(&c, 1);
   size_t r = result.value;
   if (result.has_error())
-    errno = result.error;
+    libc_errno = result.error;
   if (r != 1)
     return EOF;
   return c;
 }
 
 } // namespace __llvm_libc

libc/src/stdio/fgets.cpp

 //===-- Implementation of fgets -------------------------------------------===//
 //
 // 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/stdio/fgets.h"
 #include "src/__support/File/file.h"
 
-#include <errno.h>
+#include "src/errno/libc_errno.h"
 #include <stddef.h>
 #include <stdio.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(char *, fgets,
                    (char *__restrict str, int count,
                     ::FILE *__restrict raw_stream)) {
   if (count < 1)
     return nullptr;
 
   unsigned char c = '\0';
   auto stream = reinterpret_cast<__llvm_libc::File *__restrict>(raw_stream);
   stream->lock();
 
   // i is an int because it's frequently compared to count, which is also int.
   int i = 0;
 
   for (; i < (count - 1) && c != '\n'; ++i) {
     auto result = stream->read_unlocked(&c, 1);
     size_t r = result.value;
     if (result.has_error())
-      errno = result.error;
+      libc_errno = result.error;
 
     if (r != 1)
       break;
     str[i] = c;
   }
 
   bool has_error = stream->error_unlocked();
   bool has_eof = stream->iseof_unlocked();

libc/src/stdio/fopen.cpp

 //===-- Implementation of fopen -------------------------------------------===//
 //
 // 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/stdio/fopen.h"
 #include "src/__support/File/file.h"
 
-#include <errno.h>
+#include "src/errno/libc_errno.h"
 #include <stdio.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(::FILE *, fopen,
                    (const char *__restrict name, const char *__restrict mode)) {
   auto result = __llvm_libc::openfile(name, mode);
   if (!result.has_value()) {
-    errno = result.error();
+    libc_errno = result.error();
     return nullptr;
   }
   return reinterpret_cast<::FILE *>(result.value());
 }
 
 } // namespace __llvm_libc

libc/src/stdio/fopencookie.cpp

 //===-- Implementation of fopencookie -------------------------------------===//
 //
 // 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/stdio/fopencookie.h"
 #include "src/__support/CPP/new.h"
 #include "src/__support/File/file.h"
 
-#include <errno.h>
+#include "src/errno/libc_errno.h"
 #include <stdio.h>
 #include <stdlib.h>
 
 namespace __llvm_libc {
 
 namespace {
 
 class CookieFile : public __llvm_libc::File {

libc/src/stdio/fputc.cpp

 //===-- Implementation of fputc -------------------------------------------===//
 //
 // 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/stdio/fputc.h"
 #include "src/__support/File/file.h"
 
-#include <errno.h>
+#include "src/errno/libc_errno.h"
 #include <stdio.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, fputc, (int c, ::FILE *stream)) {
   unsigned char uc = static_cast<unsigned char>(c);
 
   auto result = reinterpret_cast<__llvm_libc::File *>(stream)->write(&uc, 1);
   if (result.has_error())
-    errno = result.error;
+    libc_errno = result.error;
   size_t written = result.value;
 
   if (1 != written) {
     // The stream should be in an error state in this case.
     return EOF;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/stdio/fputs.cpp

 //===-- Implementation of fputs -------------------------------------------===//
 //
 // 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/stdio/fputs.h"
 #include "src/__support/CPP/string_view.h"
 #include "src/__support/File/file.h"
 
-#include <errno.h>
+#include "src/errno/libc_errno.h"
 #include <stdio.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, fputs,
                    (const char *__restrict str, ::FILE *__restrict stream)) {
   cpp::string_view str_view(str);
 
   auto result = reinterpret_cast<__llvm_libc::File *>(stream)->write(
       str, str_view.size());
   if (result.has_error())
-    errno = result.error;
+    libc_errno = result.error;
   size_t written = result.value;
 
   if (str_view.size() != written) {
     // The stream should be in an error state in this case.
     return EOF;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/stdio/fread.cpp

 //===-- Implementation of fread -------------------------------------------===//
 //
 // 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/stdio/fread.h"
 #include "src/__support/File/file.h"
 
-#include <errno.h>
+#include "src/errno/libc_errno.h"
 #include <stdio.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(size_t, fread,
                    (void *__restrict buffer, size_t size, size_t nmemb,
                     ::FILE *stream)) {
   if (size == 0 || nmemb == 0)
     return 0;
   auto result =
       reinterpret_cast<__llvm_libc::File *>(stream)->read(buffer, size * nmemb);
   if (result.has_error())
-    errno = result.error;
+    libc_errno = result.error;
   return result.value / size;
 }
 
 } // namespace __llvm_libc

libc/src/stdio/fread_unlocked.cpp

 //===-- Implementation of fread_unlocked ----------------------------------===//
 //
 // 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/stdio/fread_unlocked.h"
 #include "src/__support/File/file.h"
 
-#include <errno.h>
+#include "src/errno/libc_errno.h"
 #include <stdio.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(size_t, fread_unlocked,
                    (void *__restrict buffer, size_t size, size_t nmemb,
                     ::FILE *stream)) {
   if (size == 0 || nmemb == 0)
     return 0;
   auto result = reinterpret_cast<__llvm_libc::File *>(stream)->read_unlocked(
       buffer, size * nmemb);
   if (result.has_error())
-    errno = result.error;
+    libc_errno = result.error;
   return result.value / size;
 }
 
 } // namespace __llvm_libc

libc/src/stdio/fseek.cpp

 //===-- Implementation of fseek -------------------------------------------===//
 //
 // 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/stdio/fseek.h"
 #include "src/__support/File/file.h"
 
-#include <errno.h>
+#include "src/errno/libc_errno.h"
 #include <stdio.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, fseek, (::FILE * stream, long offset, int whence)) {
   auto result =
       reinterpret_cast<__llvm_libc::File *>(stream)->seek(offset, whence);
   if (!result.has_value()) {
-    errno = result.error();
+    libc_errno = result.error();
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/stdio/ftell.cpp

 //===-- Implementation of ftell -------------------------------------------===//
 //
 // 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/stdio/ftell.h"
 #include "src/__support/File/file.h"
 
-#include <errno.h>
+#include "src/errno/libc_errno.h"
 #include <stdio.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(long, ftell, (::FILE * stream)) {
   auto result = reinterpret_cast<__llvm_libc::File *>(stream)->tell();
   if (!result.has_value()) {
-    errno = result.error();
+    libc_errno = result.error();
     return -1;
   }
   return result.value();
 }
 
 } // namespace __llvm_libc

libc/src/stdio/fwrite.cpp

 //===-- Implementation of fwrite ------------------------------------------===//
 //
 // 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/stdio/fwrite.h"
 #include "src/__support/File/file.h"
 
-#include <errno.h>
+#include "src/errno/libc_errno.h"
 #include <stdio.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(size_t, fwrite,
                    (const void *__restrict buffer, size_t size, size_t nmemb,
                     ::FILE *stream)) {
   if (size == 0 || nmemb == 0)
     return 0;
   auto result = reinterpret_cast<__llvm_libc::File *>(stream)->write(
       buffer, size * nmemb);
   if (result.has_error())
-    errno = result.error;
+    libc_errno = result.error;
 
   return result.value / size;
 }
 
 } // namespace __llvm_libc

libc/src/stdio/fwrite_unlocked.cpp

 //===-- Implementation of fwrite_unlocked ---------------------------------===//
 //
 // 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/stdio/fwrite_unlocked.h"
 #include "src/__support/File/file.h"
 
-#include <errno.h>
+#include "src/errno/libc_errno.h"
 #include <stdio.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(size_t, fwrite_unlocked,
                    (const void *__restrict buffer, size_t size, size_t nmemb,
                     ::FILE *stream)) {
 
   if (size == 0 || nmemb == 0)
     return 0;
   auto result = reinterpret_cast<__llvm_libc::File *>(stream)->write_unlocked(
       buffer, size * nmemb);
   if (result.has_error())
-    errno = result.error;
+    libc_errno = result.error;
 
   return result.value / size;
 }
 
 } // namespace __llvm_libc

libc/src/stdio/getc.cpp

 //===-- Implementation of getc --------------------------------------------===//
 //
 // 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/stdio/getc.h"
 #include "src/__support/File/file.h"
 
-#include <errno.h>
+#include "src/errno/libc_errno.h"
 #include <stdio.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, getc, (::FILE * stream)) {
   unsigned char c;
   auto result = reinterpret_cast<__llvm_libc::File *>(stream)->read(&c, 1);
   size_t r = result.value;
   if (result.has_error())
-    errno = result.error;
+    libc_errno = result.error;
 
   if (r != 1)
     return EOF;
   return c;
 }
 
 } // namespace __llvm_libc

libc/src/stdio/getc_unlocked.cpp

 //===-- Implementation of getc_unlocked ----------------------------------===//
 //
 // 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/stdio/getc_unlocked.h"
 #include "src/__support/File/file.h"
 
-#include <errno.h>
+#include "src/errno/libc_errno.h"
 #include <stdio.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, getc_unlocked, (::FILE * stream)) {
   unsigned char c;
   auto result =
       reinterpret_cast<__llvm_libc::File *>(stream)->read_unlocked(&c, 1);
   size_t r = result.value;
   if (result.has_error())
-    errno = result.error;
+    libc_errno = result.error;
 
   if (r != 1)
     return EOF;
   return c;
 }
 
 } // namespace __llvm_libc

libc/src/stdio/linux/remove.cpp

 //===-- Linux implementation of remove ------------------------------------===//
 //
 // 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/stdio/remove.h"
 
 #include "src/__support/OSUtil/syscall.h" // For internal syscall function.
 #include "src/__support/common.h"
 
-#include <errno.h>
+#include "src/errno/libc_errno.h"
 #include <fcntl.h>       // For AT_* macros.
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, remove, (const char *path)) {
   // We first try unlinking it as a file. If it is ia file, it will succeed. If
   // it fails with EISDIR, we will try unlinking it as a directory.
   int ret = __llvm_libc::syscall_impl(SYS_unlinkat, AT_FDCWD, path, 0);
   if (ret == -EISDIR)
     ret = __llvm_libc::syscall_impl(SYS_unlinkat, AT_FDCWD, path, AT_REMOVEDIR);
   if (ret >= 0)
     return 0;
-  errno = -ret;
+  libc_errno = -ret;
   return -1;
 }
 
 } // namespace __llvm_libc

libc/src/stdio/putc.cpp

 //===-- Implementation of putc --------------------------------------------===//
 //
 // 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/stdio/putc.h"
 #include "src/__support/File/file.h"
 
-#include <errno.h>
+#include "src/errno/libc_errno.h"
 #include <stdio.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, putc, (int c, ::FILE *stream)) {
   unsigned char uc = static_cast<unsigned char>(c);
 
   auto result = reinterpret_cast<__llvm_libc::File *>(stream)->write(&uc, 1);
   if (result.has_error())
-    errno = result.error;
+    libc_errno = result.error;
   size_t written = result.value;
 
   if (1 != written) {
     // The stream should be in an error state in this case.
     return EOF;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/stdio/putchar.cpp

 //===-- Implementation of putchar -----------------------------------------===//
 //
 // 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/stdio/putchar.h"
 #include "src/__support/File/file.h"
 
-#include <errno.h>
+#include "src/errno/libc_errno.h"
 #include <stdio.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, putchar, (int c)) {
   unsigned char uc = static_cast<unsigned char>(c);
 
   auto result = __llvm_libc::stdout->write(&uc, 1);
   if (result.has_error())
-    errno = result.error;
+    libc_errno = result.error;
   size_t written = result.value;
 
   if (1 != written) {
     // The stream should be in an error state in this case.
     return EOF;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/stdio/puts.cpp

 //===-- Implementation of puts --------------------------------------------===//
 //
 // 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/stdio/puts.h"
 #include "src/__support/CPP/string_view.h"
 #include "src/__support/File/file.h"
 
-#include <errno.h>
+#include "src/errno/libc_errno.h"
 #include <stdio.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, puts, (const char *__restrict str)) {
   cpp::string_view str_view(str);
   auto result = __llvm_libc::stdout->write(str, str_view.size());
   if (result.has_error())
-    errno = result.error;
+    libc_errno = result.error;
   size_t written = result.value;
   if (str_view.size() != written) {
     // The stream should be in an error state in this case.
     return EOF;
   }
   result = __llvm_libc::stdout->write("\n", 1);
   if (result.has_error())
-    errno = result.error;
+    libc_errno = result.error;
   written = result.value;
   if (1 != written) {
     // The stream should be in an error state in this case.
     return EOF;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/stdio/setbuf.cpp

 //===-- Implementation of setbuf ------------------------------------------===//
 //
 // 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/stdio/setbuf.h"
 #include "src/__support/File/file.h"
 
-#include <errno.h>
+#include "src/errno/libc_errno.h"
 #include <stdio.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(void, setbuf,
                    (::FILE *__restrict stream, char *__restrict buf)) {
   int mode = _IOFBF;
   if (buf == nullptr)
     mode = _IONBF;
   int err = reinterpret_cast<__llvm_libc::File *>(stream)->set_buffer(
       buf, BUFSIZ, mode);
   if (err != 0)
-    errno = err;
+    libc_errno = err;
 }
 
 } // namespace __llvm_libc

libc/src/stdio/setvbuf.cpp

 //===-- Implementation of setvbuf -----------------------------------------===//
 //
 // 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/stdio/setvbuf.h"
 #include "src/__support/File/file.h"
 
-#include <errno.h>
+#include "src/errno/libc_errno.h"
 #include <stdio.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, setvbuf,
                    (::FILE *__restrict stream, char *__restrict buf, int type,
                     size_t size)) {
   int err = reinterpret_cast<__llvm_libc::File *>(stream)->set_buffer(buf, size,
                                                                       type);
   if (err != 0)
-    errno = err;
+    libc_errno = err;
   return err;
 }
 
 } // namespace __llvm_libc

libc/src/stdlib/atof.cpp

 //===-- Implementation of atof --------------------------------------------===//
 //
 // 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/stdlib/atof.h"
 #include "src/__support/common.h"
 #include "src/__support/str_to_float.h"
-#include <errno.h>
+#include "src/errno/libc_errno.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(double, atof, (const char *str)) {
   auto result = internal::strtofloatingpoint<double>(str);
   if (result.has_error())
-    errno = result.error;
+    libc_errno = result.error;
 
   return result.value;
 }
 
 } // namespace __llvm_libc

libc/src/stdlib/atoi.cpp

 //===-- Implementation of atoi --------------------------------------------===//
 //
 // 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/stdlib/atoi.h"
 #include "src/__support/common.h"
 #include "src/__support/str_to_integer.h"
+#include "src/errno/libc_errno.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, atoi, (const char *str)) {
   // This is done because the standard specifies that atoi is identical to
   // (int)(strtol).
   auto result = internal::strtointeger<long>(str, 10);
   if (result.has_error())
-    errno = result.error;
+    libc_errno = result.error;
 
   return static_cast<int>(result);
 }
 
 } // namespace __llvm_libc

libc/src/stdlib/atol.cpp

 //===-- Implementation of atol --------------------------------------------===//
 //
 // 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/stdlib/atol.h"
 #include "src/__support/common.h"
 #include "src/__support/str_to_integer.h"
+#include "src/errno/libc_errno.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(long, atol, (const char *str)) {
   auto result = internal::strtointeger<long>(str, 10);
   if (result.has_error())
-    errno = result.error;
+    libc_errno = result.error;
 
   return result;
 }
 
 } // namespace __llvm_libc

libc/src/stdlib/atoll.cpp

 //===-- Implementation of atoll -------------------------------------------===//
 //
 // 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/stdlib/atoll.h"
 #include "src/__support/common.h"
 #include "src/__support/str_to_integer.h"
+#include "src/errno/libc_errno.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(long long, atoll, (const char *str)) {
   auto result = internal::strtointeger<long long>(str, 10);
   if (result.has_error())
-    errno = result.error;
+    libc_errno = result.error;
 
   return result;
 }
 
 } // namespace __llvm_libc

libc/src/stdlib/strtod.cpp

 //===-- Implementation of strtod ------------------------------------------===//
 //
 // 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/stdlib/strtod.h"
 #include "src/__support/common.h"
 #include "src/__support/str_to_float.h"
-#include <errno.h>
+#include "src/errno/libc_errno.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(double, strtod,
                    (const char *__restrict str, char **__restrict str_end)) {
   auto result = internal::strtofloatingpoint<double>(str);
   if (result.has_error())
-    errno = result.error;
+    libc_errno = result.error;
 
   if (str_end != NULL)
     *str_end = const_cast<char *>(str + result.parsed_len);
 
   return result.value;
 }
 
 } // namespace __llvm_libc

libc/src/stdlib/strtof.cpp

 //===-- Implementation of strtof ------------------------------------------===//
 //
 // 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/stdlib/strtof.h"
 #include "src/__support/common.h"
 #include "src/__support/str_to_float.h"
-#include <errno.h>
+#include "src/errno/libc_errno.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(float, strtof,
                    (const char *__restrict str, char **__restrict str_end)) {
   auto result = internal::strtofloatingpoint<float>(str);
   if (result.has_error())
-    errno = result.error;
+    libc_errno = result.error;
 
   if (str_end != NULL)
     *str_end = const_cast<char *>(str + result.parsed_len);
 
   return result.value;
 }
 
 } // namespace __llvm_libc

libc/src/stdlib/strtol.cpp

 //===-- Implementation of strtol ------------------------------------------===//
 //
 // 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/stdlib/strtol.h"
 #include "src/__support/common.h"
 #include "src/__support/str_to_integer.h"
+#include "src/errno/libc_errno.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(long, strtol,
                    (const char *__restrict str, char **__restrict str_end,
                     int base)) {
   auto result = internal::strtointeger<long>(str, base);
   if (result.has_error())
-    errno = result.error;
+    libc_errno = result.error;
 
   if (str_end != nullptr)
     *str_end = const_cast<char *>(str + result.parsed_len);
 
   return result;
 }
 
 } // namespace __llvm_libc

libc/src/stdlib/strtold.cpp

 //===-- Implementation of strtold -----------------------------------------===//
 //
 // 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/stdlib/strtold.h"
 #include "src/__support/common.h"
 #include "src/__support/str_to_float.h"
-#include <errno.h>
+#include "src/errno/libc_errno.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(long double, strtold,
                    (const char *__restrict str, char **__restrict str_end)) {
   auto result = internal::strtofloatingpoint<long double>(str);
   if (result.has_error())
-    errno = result.error;
+    libc_errno = result.error;
 
   if (str_end != NULL)
     *str_end = const_cast<char *>(str + result.parsed_len);
 
   return result.value;
 }
 
 } // namespace __llvm_libc

libc/src/stdlib/strtoll.cpp

 //===-- Implementation of strtoll -----------------------------------------===//
 //
 // 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/stdlib/strtoll.h"
 #include "src/__support/common.h"
 #include "src/__support/str_to_integer.h"
+#include "src/errno/libc_errno.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(long long, strtoll,
                    (const char *__restrict str, char **__restrict str_end,
                     int base)) {
   auto result = internal::strtointeger<long long>(str, base);
   if (result.has_error())
-    errno = result.error;
+    libc_errno = result.error;
 
   if (str_end != nullptr)
     *str_end = const_cast<char *>(str + result.parsed_len);
 
   return result;
 }
 
 } // namespace __llvm_libc

libc/src/stdlib/strtoul.cpp

 //===-- Implementation of strtoul -----------------------------------------===//
 //
 // 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/stdlib/strtoul.h"
 #include "src/__support/common.h"
 #include "src/__support/str_to_integer.h"
+#include "src/errno/libc_errno.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(unsigned long, strtoul,
                    (const char *__restrict str, char **__restrict str_end,
                     int base)) {
   auto result = internal::strtointeger<unsigned long>(str, base);
   if (result.has_error())
-    errno = result.error;
+    libc_errno = result.error;
 
   if (str_end != nullptr)
     *str_end = const_cast<char *>(str + result.parsed_len);
 
   return result;
 }
 
 } // namespace __llvm_libc

libc/src/stdlib/strtoull.cpp

 //===-- Implementation of strtoull ----------------------------------------===//
 //
 // 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/stdlib/strtoull.h"
 #include "src/__support/common.h"
 #include "src/__support/str_to_integer.h"
+#include "src/errno/libc_errno.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(unsigned long long, strtoull,
                    (const char *__restrict str, char **__restrict str_end,
                     int base)) {
   auto result = internal::strtointeger<unsigned long long>(str, base);
   if (result.has_error())
-    errno = result.error;
+    libc_errno = result.error;
 
   if (str_end != nullptr)
     *str_end = const_cast<char *>(str + result.parsed_len);
 
   return result;
 }
 
 } // namespace __llvm_libc

libc/test/src/stdio/CMakeLists.txt

 add_libc_testsuite(libc_stdio_unittests)
 
 add_libc_unittest(
   fileop_test
   SUITE
     libc_stdio_unittests
   SRCS
     fileop_test.cpp
   DEPENDS
-    libc.include.errno
     libc.include.stdio
     libc.src.stdio.clearerr
     libc.src.stdio.fclose
     libc.src.stdio.feof
     libc.src.stdio.ferror
     libc.src.stdio.fflush
     libc.src.stdio.fopen
     libc.src.stdio.fputs

 
 add_libc_unittest(
   setvbuf_test
   SUITE
     libc_stdio_unittests
   SRCS
     setvbuf_test.cpp
   DEPENDS
-    libc.include.errno
     libc.include.stdio
     libc.src.stdio.fclose
     libc.src.stdio.fopen
     libc.src.stdio.fread
     libc.src.stdio.fwrite
     libc.src.stdio.setvbuf
 )
 
 add_libc_unittest(
   unlocked_fileop_test
   SUITE
     libc_stdio_unittests
   SRCS
     unlocked_fileop_test.cpp
   DEPENDS
-    libc.include.errno
     libc.include.stdio
     libc.src.stdio.clearerr_unlocked
     libc.src.stdio.fclose
     libc.src.stdio.feof_unlocked
     libc.src.stdio.ferror_unlocked
     libc.src.stdio.flockfile
     libc.src.stdio.fopen
     libc.src.stdio.fread_unlocked
     libc.src.stdio.funlockfile
     libc.src.stdio.fwrite_unlocked
 )
 
 add_libc_unittest(
   fopencookie_test
   SUITE
     libc_stdio_unittests
   SRCS
     fopencookie_test.cpp
   DEPENDS
-    libc.include.errno
     libc.include.stdio
     libc.include.stdlib
     libc.src.stdio.clearerr
     libc.src.stdio.fclose
     libc.src.stdio.feof
     libc.src.stdio.ferror
     libc.src.stdio.fflush
     libc.src.stdio.fopencookie

 if(${LIBC_TARGET_OS} STREQUAL "linux")
   add_libc_unittest(
     remove_test
     SUITE
       libc_stdio_unittests
     SRCS
       remove_test.cpp
     DEPENDS
-      libc.include.errno
       libc.include.unistd
       libc.src.fcntl.open
       libc.src.stdio.remove
       libc.src.sys.stat.mkdirat
       libc.src.unistd.access
       libc.src.unistd.close
   )
 endif()
 
 add_libc_unittest(
   fgetc_test
   SUITE
     libc_stdio_unittests
   SRCS
     fgetc_test.cpp
   DEPENDS
-    libc.include.errno
     libc.include.stdio
     libc.src.stdio.fclose
     libc.src.stdio.feof
     libc.src.stdio.ferror
     libc.src.stdio.fgetc
     libc.src.stdio.fopen
     libc.src.stdio.fwrite
     libc.src.stdio.getc
 )
 
 add_libc_unittest(
   fgetc_unlocked_test
   SUITE
     libc_stdio_unittests
   SRCS
     fgetc_unlocked_test.cpp
   DEPENDS
-    libc.include.errno
     libc.include.stdio
     libc.src.stdio.fclose
     libc.src.stdio.ferror
     libc.src.stdio.ferror_unlocked
     libc.src.stdio.feof
     libc.src.stdio.feof_unlocked
     libc.src.stdio.fgetc_unlocked
     libc.src.stdio.flockfile
     libc.src.stdio.fopen
     libc.src.stdio.funlockfile
     libc.src.stdio.fwrite
     libc.src.stdio.getc_unlocked
 )
 
 add_libc_unittest(
   fgets_test
   SUITE
     libc_stdio_unittests
   SRCS
     fgets_test.cpp
   DEPENDS
-    libc.include.errno
     libc.include.stdio
     libc.src.stdio.fclose
     libc.src.stdio.feof
     libc.src.stdio.ferror
     libc.src.stdio.fgets
     libc.src.stdio.fopen
     libc.src.stdio.fwrite
 )
 
 add_libc_unittest(
   ftell_test
   SUITE
     libc_stdio_unittests
   SRCS
     ftell_test.cpp
   DEPENDS
-    libc.include.errno
     libc.include.stdio
     libc.src.stdio.fclose
     libc.src.stdio.fflush
     libc.src.stdio.fopen
     libc.src.stdio.fread
     libc.src.stdio.fseek
     libc.src.stdio.ftell
     libc.src.stdio.fwrite
     libc.src.stdio.setvbuf
 )
 
 add_subdirectory(printf_core)
 add_subdirectory(scanf_core)
 add_subdirectory(testdata)

libc/test/src/stdio/fgetc_test.cpp

 #include "src/stdio/feof.h"
 #include "src/stdio/ferror.h"
 #include "src/stdio/fgetc.h"
 #include "src/stdio/fopen.h"
 #include "src/stdio/fwrite.h"
 #include "src/stdio/getc.h"
 #include "test/UnitTest/Test.h"
 
-#include <errno.h>
+#include "src/errno/libc_errno.h"
 #include <stdio.h>
 
 class LlvmLibcGetcTest : public __llvm_libc::testing::Test {
 public:
   using GetcFunc = int(FILE *);
   void test_with_func(GetcFunc *func, const char *filename) {
     ::FILE *file = __llvm_libc::fopen(filename, "w");
     ASSERT_FALSE(file == nullptr);
     constexpr char CONTENT[] = "123456789";
     constexpr size_t WRITE_SIZE = sizeof(CONTENT) - 1;
     ASSERT_EQ(WRITE_SIZE, __llvm_libc::fwrite(CONTENT, 1, WRITE_SIZE, file));
     // This is a write-only file so reads should fail.
     ASSERT_EQ(func(file), EOF);
     // This is an error and not a real EOF.
     ASSERT_EQ(__llvm_libc::feof(file), 0);
     ASSERT_NE(__llvm_libc::ferror(file), 0);
-    errno = 0;
+    libc_errno = 0;
 
     ASSERT_EQ(0, __llvm_libc::fclose(file));
 
     file = __llvm_libc::fopen(filename, "r");
     ASSERT_FALSE(file == nullptr);
 
     for (size_t i = 0; i < WRITE_SIZE; ++i) {
       int c = func(file);

libc/test/src/stdio/fgetc_unlocked_test.cpp

 #include "src/stdio/fgetc_unlocked.h"
 #include "src/stdio/flockfile.h"
 #include "src/stdio/fopen.h"
 #include "src/stdio/funlockfile.h"
 #include "src/stdio/fwrite.h"
 #include "src/stdio/getc_unlocked.h"
 #include "test/UnitTest/Test.h"
 
-#include <errno.h>
+#include "src/errno/libc_errno.h"
 #include <stdio.h>
 
 class LlvmLibcGetcTest : public __llvm_libc::testing::Test {
 public:
   using GetcFunc = int(FILE *);
   void test_with_func(GetcFunc *func, const char *filename) {
     ::FILE *file = __llvm_libc::fopen(filename, "w");
     ASSERT_FALSE(file == nullptr);
     constexpr char CONTENT[] = "123456789";
     constexpr size_t WRITE_SIZE = sizeof(CONTENT) - 1;
     ASSERT_EQ(WRITE_SIZE, __llvm_libc::fwrite(CONTENT, 1, WRITE_SIZE, file));
     // This is a write-only file so reads should fail.
     ASSERT_EQ(func(file), EOF);
     // This is an error and not a real EOF.
     ASSERT_EQ(__llvm_libc::feof(file), 0);
     ASSERT_NE(__llvm_libc::ferror(file), 0);
-    errno = 0;
+    libc_errno = 0;
 
     ASSERT_EQ(0, __llvm_libc::fclose(file));
 
     file = __llvm_libc::fopen(filename, "r");
     ASSERT_FALSE(file == nullptr);
 
     __llvm_libc::flockfile(file);
     for (size_t i = 0; i < WRITE_SIZE; ++i) {

libc/test/src/stdio/fgets_test.cpp

 //===-- Unittests for fgets -----------------------------------------------===//
 //
 // 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/stdio/fclose.h"
 #include "src/stdio/feof.h"
 #include "src/stdio/ferror.h"
 #include "src/stdio/fgets.h"
 #include "src/stdio/fopen.h"
 #include "src/stdio/fwrite.h"
 #include "test/UnitTest/Test.h"
 
-#include <errno.h>
+#include "src/errno/libc_errno.h"
 #include <stdio.h>
 
 TEST(LlvmLibcFgetsTest, WriteAndReadCharacters) {
   constexpr char FILENAME[] = "testdata/fgets.test";
   ::FILE *file = __llvm_libc::fopen(FILENAME, "w");
   ASSERT_FALSE(file == nullptr);
   constexpr char CONTENT[] = "123456789\n"
                              "1234567\n"
                              "123456\n"
                              "1";
   constexpr size_t WRITE_SIZE = sizeof(CONTENT) - 1;
 
   char buff[8];
   char *output;
 
   ASSERT_EQ(WRITE_SIZE, __llvm_libc::fwrite(CONTENT, 1, WRITE_SIZE, file));
   // This is a write-only file so reads should fail.
   ASSERT_TRUE(__llvm_libc::fgets(buff, 8, file) == nullptr);
   // This is an error and not a real EOF.
   ASSERT_EQ(__llvm_libc::feof(file), 0);
   ASSERT_NE(__llvm_libc::ferror(file), 0);
-  errno = 0;
+  libc_errno = 0;
 
   ASSERT_EQ(0, __llvm_libc::fclose(file));
 
   file = __llvm_libc::fopen(FILENAME, "r");
   ASSERT_FALSE(file == nullptr);
 
   // If we request just 1 byte, it should return just a null byte and not
   // advance the read head. This is implementation defined.
   output = __llvm_libc::fgets(buff, 1, file);
   ASSERT_TRUE(output == buff);
   ASSERT_EQ(buff[0], '\0');
-  ASSERT_EQ(errno, 0);
+  ASSERT_EQ(libc_errno, 0);
 
   // If we request less than 1 byte, it should do nothing and return nullptr.
   // This is also implementation defined.
   output = __llvm_libc::fgets(buff, 0, file);
   ASSERT_TRUE(output == nullptr);
 
   const char *output_arr[] = {
       "1234567", "89\n", "1234567", "\n", "123456\n", "1",
for (size_t i = 0; i < ARR_SIZE; ++i) {
 
     EXPECT_STREQ(buff, output_arr[i]);
   }
 
   // This should have hit the end of the file, but that isn't an error unless it
   // fails to read anything.
   ASSERT_NE(__llvm_libc::feof(file), 0);
   ASSERT_EQ(__llvm_libc::ferror(file), 0);
-  ASSERT_EQ(errno, 0);
+  ASSERT_EQ(libc_errno, 0);
 
   // Reading more should be an EOF, but not an error.
   output = __llvm_libc::fgets(buff, 8, file);
   ASSERT_TRUE(output == nullptr);
   ASSERT_NE(__llvm_libc::feof(file), 0);
-  ASSERT_EQ(errno, 0);
+  ASSERT_EQ(libc_errno, 0);
 
   ASSERT_EQ(0, __llvm_libc::fclose(file));
 }

libc/test/src/stdio/fileop_test.cpp

 #include "src/stdio/fflush.h"
 #include "src/stdio/fopen.h"
 #include "src/stdio/fputs.h"
 #include "src/stdio/fread.h"
 #include "src/stdio/fseek.h"
 #include "src/stdio/fwrite.h"
 #include "test/UnitTest/Test.h"
 
-#include <errno.h>
+#include "src/errno/libc_errno.h"
 #include <stdio.h>
 
 TEST(LlvmLibcFILETest, SimpleFileOperations) {
   constexpr char FILENAME[] = "testdata/simple_operations.test";
   ::FILE *file = __llvm_libc::fopen(FILENAME, "w");
   ASSERT_FALSE(file == nullptr);
   constexpr char CONTENT[] = "1234567890987654321";
   ASSERT_EQ(sizeof(CONTENT) - 1,
             __llvm_libc::fwrite(CONTENT, 1, sizeof(CONTENT) - 1, file));
 
   // This is not a readable file.
   char read_data[sizeof(CONTENT)];
   ASSERT_EQ(__llvm_libc::fread(read_data, 1, sizeof(CONTENT), file), size_t(0));
   ASSERT_NE(__llvm_libc::ferror(file), 0);
-  EXPECT_NE(errno, 0);
-  errno = 0;
+  EXPECT_NE(libc_errno, 0);
+  libc_errno = 0;
 
   __llvm_libc::clearerr(file);
   ASSERT_EQ(__llvm_libc::ferror(file), 0);
 
   ASSERT_EQ(0, __llvm_libc::fclose(file));
 
   file = __llvm_libc::fopen(FILENAME, "r");
   ASSERT_FALSE(file == nullptr);
TEST(LlvmLibcFILETest, SimpleFileOperations) {
   // Reading another time should trigger eof.
   ASSERT_NE(sizeof(CONTENT),
             __llvm_libc::fread(read_data, 1, sizeof(CONTENT), file));
   ASSERT_NE(__llvm_libc::feof(file), 0);
 
   // Should be an error to write.
   ASSERT_EQ(size_t(0), __llvm_libc::fwrite(CONTENT, 1, sizeof(CONTENT), file));
   ASSERT_NE(__llvm_libc::ferror(file), 0);
-  ASSERT_NE(errno, 0);
-  errno = 0;
+  ASSERT_NE(libc_errno, 0);
+  libc_errno = 0;
 
   __llvm_libc::clearerr(file);
 
   // Should be an error to puts.
   ASSERT_EQ(EOF, __llvm_libc::fputs(CONTENT, file));
   ASSERT_NE(__llvm_libc::ferror(file), 0);
-  ASSERT_NE(errno, 0);
-  errno = 0;
+  ASSERT_NE(libc_errno, 0);
+  libc_errno = 0;
 
   __llvm_libc::clearerr(file);
   ASSERT_EQ(__llvm_libc::ferror(file), 0);
 
-  errno = 0;
+  libc_errno = 0;
   ASSERT_EQ(__llvm_libc::fwrite("nothing", 1, 1, file), size_t(0));
-  ASSERT_NE(errno, 0);
-  errno = 0;
+  ASSERT_NE(libc_errno, 0);
+  libc_errno = 0;
 
   ASSERT_EQ(__llvm_libc::fclose(file), 0);
 
   // Now try puts.
   file = __llvm_libc::fopen(FILENAME, "w");
   ASSERT_FALSE(file == nullptr);
   // fputs returns a negative value on error (EOF) or any non-negative value on
   // success. This assert checks that the return value is non-negative.
   ASSERT_GE(__llvm_libc::fputs(CONTENT, file), 0);
 
   __llvm_libc::clearerr(file);
   ASSERT_EQ(__llvm_libc::ferror(file), 0);
 
   // This is not a readable file.
-  errno = 0;
+  libc_errno = 0;
   ASSERT_EQ(__llvm_libc::fread(data, 1, 1, file), size_t(0));
-  ASSERT_NE(errno, 0);
-  errno = 0;
+  ASSERT_NE(libc_errno, 0);
+  libc_errno = 0;
 
   ASSERT_EQ(0, __llvm_libc::fclose(file));
 
   file = __llvm_libc::fopen(FILENAME, "r");
   ASSERT_FALSE(file == nullptr);
 
   ASSERT_EQ(__llvm_libc::fread(read_data, 1, sizeof(CONTENT) - 1, file),
             sizeof(CONTENT) - 1);
   read_data[sizeof(CONTENT) - 1] = '\0';
   ASSERT_STREQ(read_data, CONTENT);
   ASSERT_EQ(__llvm_libc::fclose(file), 0);
 
-  // Check that the other functions correctly set errno.
+  // Check that the other functions correctly set libc_errno.
 
-  // errno = 0;
+  // libc_errno = 0;
   // ASSERT_NE(__llvm_libc::fseek(file, 0, SEEK_SET), 0);
-  // EXPECT_NE(errno, 0);
+  // EXPECT_NE(libc_errno, 0);
 
-  // errno = 0;
+  // libc_errno = 0;
   // ASSERT_NE(__llvm_libc::fclose(file), 0);
-  // EXPECT_NE(errno, 0);
+  // EXPECT_NE(libc_errno, 0);
 
-  // errno = 0;
+  // libc_errno = 0;
   // ASSERT_EQ(__llvm_libc::fopen("INVALID FILE NAME", "r"),
   //           static_cast<FILE *>(nullptr));
-  // EXPECT_NE(errno, 0);
+  // EXPECT_NE(libc_errno, 0);
 }
 
 TEST(LlvmLibcFILETest, FFlush) {
   constexpr char FILENAME[] = "testdata/fflush.test";
   ::FILE *file = __llvm_libc::fopen(FILENAME, "w+");
   ASSERT_FALSE(file == nullptr);
   constexpr char CONTENT[] = "1234567890987654321";
   ASSERT_EQ(sizeof(CONTENT),
TEST(LlvmLibcFILETest, FOpenFWriteSizeGreaterThanOne) {
   using MyStruct = struct {
     char c;
     unsigned long long i;
   };
   constexpr MyStruct WRITE_DATA[] = {{'a', 1}, {'b', 2}, {'c', 3}};
   constexpr size_t WRITE_NMEMB = sizeof(WRITE_DATA) / sizeof(MyStruct);
   constexpr char FILENAME[] = "testdata/fread_fwrite.test";
 
-  errno = 0;
+  libc_errno = 0;
   FILE *file = __llvm_libc::fopen(FILENAME, "w");
   ASSERT_FALSE(file == nullptr);
   ASSERT_EQ(size_t(0), __llvm_libc::fwrite(WRITE_DATA, 0, 1, file));
   ASSERT_EQ(WRITE_NMEMB, __llvm_libc::fwrite(WRITE_DATA, sizeof(MyStruct),
                                              WRITE_NMEMB, file));
-  EXPECT_EQ(errno, 0);
+  EXPECT_EQ(libc_errno, 0);
   ASSERT_EQ(__llvm_libc::fclose(file), 0);
 
   file = __llvm_libc::fopen(FILENAME, "r");
   ASSERT_FALSE(file == nullptr);
   MyStruct read_data[WRITE_NMEMB];
   ASSERT_EQ(size_t(0), __llvm_libc::fread(read_data, 0, 1, file));
   ASSERT_EQ(WRITE_NMEMB,
             __llvm_libc::fread(read_data, sizeof(MyStruct), WRITE_NMEMB, file));
-  EXPECT_EQ(errno, 0);
+  EXPECT_EQ(libc_errno, 0);
   // Trying to read more should fetch nothing.
   ASSERT_EQ(size_t(0),
             __llvm_libc::fread(read_data, sizeof(MyStruct), WRITE_NMEMB, file));
-  EXPECT_EQ(errno, 0);
+  EXPECT_EQ(libc_errno, 0);
   EXPECT_NE(__llvm_libc::feof(file), 0);
   EXPECT_EQ(__llvm_libc::ferror(file), 0);
   ASSERT_EQ(__llvm_libc::fclose(file), 0);
   // Verify that the data which was read is correct.
   for (size_t i = 0; i < WRITE_NMEMB; ++i) {
     ASSERT_EQ(read_data[i].c, WRITE_DATA[i].c);
     ASSERT_EQ(read_data[i].i, WRITE_DATA[i].i);
   }
 }

libc/test/src/stdio/fopencookie_test.cpp

 #include "src/stdio/fflush.h"
 #include "src/stdio/fopencookie.h"
 #include "src/stdio/fread.h"
 #include "src/stdio/fseek.h"
 #include "src/stdio/fwrite.h"
 #include "test/UnitTest/MemoryMatcher.h"
 #include "test/UnitTest/Test.h"
 
-#include <errno.h>
+#include "src/errno/libc_errno.h"
 #include <stdio.h>
 #include <stdlib.h>
 
 using MemoryView = __llvm_libc::memory::testing::MemoryView;
 
 struct StringStream {
   char *buf;
   size_t bufsize; // Size of buf
int seek_ss(void *cookie, off64_t *offset, int whence) {
   off64_t new_offset;
   if (whence == SEEK_SET) {
     new_offset = *offset;
   } else if (whence == SEEK_CUR) {
     new_offset = *offset + ss->offset;
   } else if (whence == SEEK_END) {
     new_offset = *offset + ss->endpos;
   } else {
-    errno = EINVAL;
+    libc_errno = EINVAL;
     return -1;
   }
   if (new_offset < 0 || size_t(new_offset) > ss->bufsize)
     return -1;
   ss->offset = new_offset;
   *offset = new_offset;
   return 0;
 }
TEST(LlvmLibcFOpenCookie, ReadOnlyCookieTest) {
   ASSERT_NE(sizeof(CONTENT),
             __llvm_libc::fread(read_data, 1, sizeof(CONTENT), f));
   ASSERT_NE(__llvm_libc::feof(f), 0);
 
   ASSERT_EQ(0, __llvm_libc::fseek(f, 0, SEEK_SET));
   // Should be an error to write.
   ASSERT_EQ(size_t(0), __llvm_libc::fwrite(CONTENT, 1, sizeof(CONTENT), f));
   ASSERT_NE(__llvm_libc::ferror(f), 0);
-  ASSERT_NE(errno, 0);
-  errno = 0;
+  ASSERT_NE(libc_errno, 0);
+  libc_errno = 0;
 
   __llvm_libc::clearerr(f);
   ASSERT_EQ(__llvm_libc::ferror(f), 0);
 
   ASSERT_EQ(0, __llvm_libc::fclose(f));
   free(ss);
 }
 
TEST(LlvmLibcFOpenCookie, WriteOnlyCookieTest) {
   ASSERT_EQ(0, __llvm_libc::fflush(f));
   ASSERT_STREQ(WRITE_DATA, ss->buf);
 
   ASSERT_EQ(0, __llvm_libc::fseek(f, 0, SEEK_SET));
   char read_data[sizeof(WRITE_DATA)];
   // Should be an error to read.
   ASSERT_EQ(size_t(0), __llvm_libc::fread(read_data, 1, sizeof(WRITE_DATA), f));
   ASSERT_NE(__llvm_libc::ferror(f), 0);
-  ASSERT_EQ(errno, EBADF);
-  errno = 0;
+  ASSERT_EQ(libc_errno, EBADF);
+  libc_errno = 0;
 
   __llvm_libc::clearerr(f);
   ASSERT_EQ(__llvm_libc::ferror(f), 0);
 
   ASSERT_EQ(0, __llvm_libc::fclose(f));
   free(ss);
 }
 
TEST(LlvmLibcFOpenCookie, AppendOnlyCookieTest) {
   ::FILE *f = __llvm_libc::fopencookie(ss, "a", STRING_STREAM_FUNCS);
   ASSERT_TRUE(f != nullptr);
 
   constexpr size_t READ_SIZE = 5;
   char read_data[READ_SIZE];
   // This is not a readable file.
   ASSERT_EQ(__llvm_libc::fread(read_data, 1, READ_SIZE, f), size_t(0));
   ASSERT_NE(__llvm_libc::ferror(f), 0);
-  EXPECT_NE(errno, 0);
-  errno = 0;
+  EXPECT_NE(libc_errno, 0);
+  libc_errno = 0;
 
   __llvm_libc::clearerr(f);
   ASSERT_EQ(__llvm_libc::ferror(f), 0);
 
   ASSERT_EQ(__llvm_libc::fwrite(WRITE_DATA, 1, sizeof(WRITE_DATA), f),
             sizeof(WRITE_DATA));
   EXPECT_EQ(__llvm_libc::fflush(f), 0);
   EXPECT_EQ(ss->endpos, sizeof(WRITE_DATA) + sizeof(INITIAL_CONTENT));

libc/test/src/stdio/fprintf_test.cpp

 #include "src/stdio/ferror.h"
 #include "src/stdio/fopen.h"
 #include "src/stdio/fread.h"
 
 #include "src/stdio/fprintf.h"
 
 #include "test/UnitTest/Test.h"
 
-#include <errno.h>
 #include <stdio.h>
 
 TEST(LlvmLibcFPrintfTest, WriteToFile) {
   constexpr char FILENAME[] = "testdata/fprintf_output.test";
   ::FILE *file = __llvm_libc::fopen(FILENAME, "w");
   ASSERT_FALSE(file == nullptr);
 
   int written;

libc/test/src/stdio/fscanf_test.cpp

 #include "src/stdio/ferror.h"
 #include "src/stdio/fopen.h"
 #include "src/stdio/fwrite.h"
 
 #include "src/stdio/fscanf.h"
 
 #include "test/UnitTest/Test.h"
 
-#include <errno.h>
 #include <stdio.h>
 
 TEST(LlvmLibcFScanfTest, WriteToFile) {
   constexpr char FILENAME[] = "testdata/fscanf_output.test";
   ::FILE *file = __llvm_libc::fopen(FILENAME, "w");
   ASSERT_FALSE(file == nullptr);
 
   int read;

libc/test/src/stdio/ftell_test.cpp

 #include "src/stdio/fopen.h"
 #include "src/stdio/fread.h"
 #include "src/stdio/fseek.h"
 #include "src/stdio/ftell.h"
 #include "src/stdio/fwrite.h"
 #include "src/stdio/setvbuf.h"
 #include "test/UnitTest/Test.h"
 
-#include <errno.h>
 #include <stdio.h>
 
 class LlvmLibcFTellTest : public __llvm_libc::testing::Test {
 protected:
   void test_with_bufmode(int bufmode) {
     constexpr char FILENAME[] = "testdata/ftell.test";
     // We will set a special buffer to the file so that we guarantee buffering.
     constexpr size_t BUFFER_SIZE = 1024;
void test_with_bufmode(int bufmode) {
     constexpr size_t READ_SIZE = WRITE_SIZE / 2;
     char data[READ_SIZE];
     // Reading a small amount will actually read out much more data and
     // buffer it. But, ftell should return the correct effective offset.
     ASSERT_EQ(READ_SIZE, __llvm_libc::fread(data, 1, READ_SIZE, file));
     ASSERT_EQ(size_t(__llvm_libc::ftell(file)), READ_SIZE);
 
     ASSERT_EQ(0, __llvm_libc::fclose(file));
-
-    // errno = 0;
-    // ASSERT_EQ(__llvm_libc::ftell(file), long(-1));
-    // ASSERT_NE(errno, 0);
   }
 };
 
 TEST_F(LlvmLibcFTellTest, TellWithFBF) { test_with_bufmode(_IOFBF); }
 
 TEST_F(LlvmLibcFTellTest, TellWithNBF) { test_with_bufmode(_IONBF); }
 
 TEST_F(LlvmLibcFTellTest, TellWithLBF) { test_with_bufmode(_IOLBF); }

libc/test/src/stdio/putc_test.cpp

 #include "src/stdio/ferror.h"
 #include "src/stdio/fopen.h"
 #include "src/stdio/fread.h"
 
 #include "src/stdio/putc.h"
 
 #include "test/UnitTest/Test.h"
 
-#include <errno.h>
 #include <stdio.h>
 
 TEST(LlvmLibcPutcTest, WriteToFile) {
   constexpr char FILENAME[] = "testdata/putc_output.test";
   ::FILE *file = __llvm_libc::fopen(FILENAME, "w");
   ASSERT_FALSE(file == nullptr);
 
   constexpr char simple[] = "simple letters";

libc/test/src/stdio/remove_test.cpp

 #include "src/stdio/remove.h"
 #include "src/sys/stat/mkdirat.h"
 #include "src/unistd/access.h"
 #include "src/unistd/close.h"
 #include "test/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 #include "utils/testutils/FDReader.h"
 
-#include <errno.h>
+#include "src/errno/libc_errno.h"
 #include <unistd.h>
 
 TEST(LlvmLibcRemoveTest, CreateAndRemoveFile) {
   // The test strategy is to create a file and remove it, and also verify that
   // it was removed.
-  errno = 0;
+  libc_errno = 0;
   using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
   using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
   constexpr const char *TEST_FILE = "testdata/remove.test.file";
   int fd = __llvm_libc::open(TEST_FILE, O_WRONLY | O_CREAT, S_IRWXU);
-  ASSERT_EQ(errno, 0);
+  ASSERT_EQ(libc_errno, 0);
   ASSERT_GT(fd, 0);
   ASSERT_THAT(__llvm_libc::close(fd), Succeeds(0));
 
   ASSERT_THAT(__llvm_libc::access(TEST_FILE, F_OK), Succeeds(0));
   ASSERT_THAT(__llvm_libc::remove(TEST_FILE), Succeeds(0));
   ASSERT_THAT(__llvm_libc::access(TEST_FILE, F_OK), Fails(ENOENT));
 }
 
 TEST(LlvmLibcRemoveTest, CreateAndRemoveDir) {
   // The test strategy is to create a dir and remove it, and also verify that
   // it was removed.
-  errno = 0;
+  libc_errno = 0;
   using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
   using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
   constexpr const char *TEST_DIR = "testdata/remove.test.dir";
   ASSERT_THAT(__llvm_libc::mkdirat(AT_FDCWD, TEST_DIR, S_IRWXU), Succeeds(0));
 
   ASSERT_THAT(__llvm_libc::access(TEST_DIR, F_OK), Succeeds(0));
   ASSERT_THAT(__llvm_libc::remove(TEST_DIR), Succeeds(0));
   ASSERT_THAT(__llvm_libc::access(TEST_DIR, F_OK), Fails(ENOENT));
 }
 
 TEST(LlvmLibcRemoveTest, RemoveNonExistent) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
   ASSERT_THAT(__llvm_libc::remove("testdata/non-existent"), Fails(ENOENT));
 }

libc/test/src/stdio/setvbuf_test.cpp

 //===-- Unittests for setvbuf ---------------------------------------------===//
 //
 // 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/stdio/fclose.h"
 #include "src/stdio/fopen.h"
 #include "src/stdio/fread.h"
 #include "src/stdio/fwrite.h"
 #include "src/stdio/setvbuf.h"
 #include "test/UnitTest/Test.h"
 
-#include <errno.h>
+#include "src/errno/libc_errno.h"
 #include <stdio.h>
 
 TEST(LlvmLibcSetvbufTest, SetNBFBuffer) {
   // The idea in this test is that we open a file for writing and reading, and
   // then set a NBF buffer to the write handle. Since it is NBF, the data
   // written using the write handle should be immediately readable by the read
   // handle.
   constexpr char FILENAME[] = "testdata/setvbuf_nbf.test";

 }
 
 TEST(LlvmLibcSetbufTest, InvalidBufferMode) {
   constexpr char FILENAME[] = "testdata/setvbuf_invalid_bufmode.test";
   ::FILE *f = __llvm_libc::fopen(FILENAME, "w");
   ASSERT_FALSE(f == nullptr);
   char buf[BUFSIZ];
   ASSERT_NE(__llvm_libc::setvbuf(f, buf, _IOFBF + _IOLBF + _IONBF, BUFSIZ), 0);
-  ASSERT_EQ(errno, EINVAL);
+  ASSERT_EQ(libc_errno, EINVAL);
 
-  errno = 0;
+  libc_errno = 0;
   ASSERT_EQ(0, __llvm_libc::fclose(f));
 }

libc/test/src/stdio/unlocked_fileop_test.cpp

 #include "src/stdio/ferror_unlocked.h"
 #include "src/stdio/flockfile.h"
 #include "src/stdio/fopen.h"
 #include "src/stdio/fread_unlocked.h"
 #include "src/stdio/funlockfile.h"
 #include "src/stdio/fwrite_unlocked.h"
 #include "test/UnitTest/Test.h"
 
-#include <errno.h>
+#include "src/errno/libc_errno.h"
 #include <stdio.h>
 
 TEST(LlvmLibcFILETest, UnlockedReadAndWrite) {
   constexpr char fNAME[] = "testdata/unlocked_read_and_write.test";
   ::FILE *f = __llvm_libc::fopen(fNAME, "w");
   ASSERT_FALSE(f == nullptr);
   constexpr char CONTENT[] = "1234567890987654321";
   __llvm_libc::flockfile(f);
   ASSERT_EQ(sizeof(CONTENT) - 1,
             __llvm_libc::fwrite_unlocked(CONTENT, 1, sizeof(CONTENT) - 1, f));
   // Should be an error to read.
   constexpr size_t READ_SIZE = 5;
   char data[READ_SIZE * 2 + 1];
   data[READ_SIZE * 2] = '\0';
 
   ASSERT_EQ(size_t(0),
             __llvm_libc::fread_unlocked(data, 1, sizeof(READ_SIZE), f));
   ASSERT_NE(__llvm_libc::ferror_unlocked(f), 0);
-  ASSERT_NE(errno, 0);
-  errno = 0;
+  ASSERT_NE(libc_errno, 0);
+  libc_errno = 0;
 
   __llvm_libc::clearerr_unlocked(f);
   ASSERT_EQ(__llvm_libc::ferror_unlocked(f), 0);
 
   __llvm_libc::funlockfile(f);
   ASSERT_EQ(0, __llvm_libc::fclose(f));
 
   f = __llvm_libc::fopen(fNAME, "r");
   ASSERT_FALSE(f == nullptr);
 
   __llvm_libc::flockfile(f);
   ASSERT_EQ(__llvm_libc::fread_unlocked(data, 1, READ_SIZE, f), READ_SIZE);
   ASSERT_EQ(__llvm_libc::fread_unlocked(data + READ_SIZE, 1, READ_SIZE, f),
             READ_SIZE);
 
   // Should be an error to write.
   ASSERT_EQ(size_t(0),
             __llvm_libc::fwrite_unlocked(CONTENT, 1, sizeof(CONTENT), f));
   ASSERT_NE(__llvm_libc::ferror_unlocked(f), 0);
-  ASSERT_NE(errno, 0);
-  errno = 0;
+  ASSERT_NE(libc_errno, 0);
+  libc_errno = 0;
 
   __llvm_libc::clearerr_unlocked(f);
   ASSERT_EQ(__llvm_libc::ferror_unlocked(f), 0);
 
   // Reading more should trigger eof.
   char large_data[sizeof(CONTENT)];
   ASSERT_NE(sizeof(CONTENT),
             __llvm_libc::fread_unlocked(large_data, 1, sizeof(CONTENT), f));
   ASSERT_NE(__llvm_libc::feof_unlocked(f), 0);
 
   __llvm_libc::funlockfile(f);
   ASSERT_STREQ(data, "1234567890");
 
   ASSERT_EQ(__llvm_libc::fclose(f), 0);
 }

libc/test/src/stdlib/CMakeLists.txt

 
 add_header_library(
   strtol_test_support
   HDRS
     StrtolTest.h
   DEPENDS
     libc.src.__support.CPP.limits
     libc.src.__support.CPP.type_traits
-    libc.include.errno
     libc.src.errno.errno
 )
 
 add_libc_unittest(
   strtol_test
   SUITE
     libc_stdlib_unittests
   SRCS

libc/test/src/stdlib/StrtolTest.h

 //===-- A template class for testing strto* functions -----------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/__support/CPP/limits.h"
 #include "src/__support/CPP/type_traits.h"
+#include "src/errno/libc_errno.h"
 #include "test/UnitTest/Test.h"
 
-#include <errno.h>
 #include <limits.h>
 #include <stddef.h>
 
 using __llvm_libc::cpp::is_signed_v;
 
 static inline char int_to_b36_char(int input) {
   if (input < 0 || input > 36)
     return '0';
   if (input < 10)
     return static_cast<char>('0' + input);
   return static_cast<char>('A' + input - 10);
 }
 
 template <typename ReturnT>
 struct StrtoTest : public __llvm_libc::testing::Test {
   using FunctionT = ReturnT (*)(const char *, char **, int);
 
   static constexpr ReturnT T_MAX =
       __llvm_libc::cpp::numeric_limits<ReturnT>::max();
   static constexpr ReturnT T_MIN =
       __llvm_libc::cpp::numeric_limits<ReturnT>::min();
 
   void InvalidBase(FunctionT func) {
     const char *ten = "10";
-    errno = 0;
+    libc_errno = 0;
     ASSERT_EQ(func(ten, nullptr, -1), ReturnT(0));
-    ASSERT_EQ(errno, EINVAL);
+    ASSERT_EQ(libc_errno, EINVAL);
   }
 
   void CleanBaseTenDecode(FunctionT func) {
     char *str_end = nullptr;
 
     // TODO: Look into collapsing these repeated segments.
     const char *ten = "10";
-    errno = 0;
+    libc_errno = 0;
     ASSERT_EQ(func(ten, &str_end, 10), ReturnT(10));
-    ASSERT_EQ(errno, 0);
+    ASSERT_EQ(libc_errno, 0);
     EXPECT_EQ(str_end - ten, ptrdiff_t(2));
 
-    errno = 0;
+    libc_errno = 0;
     ASSERT_EQ(func(ten, nullptr, 10), ReturnT(10));
-    ASSERT_EQ(errno, 0);
+    ASSERT_EQ(libc_errno, 0);
 
     const char *hundred = "100";
-    errno = 0;
+    libc_errno = 0;
     ASSERT_EQ(func(hundred, &str_end, 10), ReturnT(100));
-    ASSERT_EQ(errno, 0);
+    ASSERT_EQ(libc_errno, 0);
     EXPECT_EQ(str_end - hundred, ptrdiff_t(3));
 
     const char *big_number = "1234567890";
-    errno = 0;
+    libc_errno = 0;
     ASSERT_EQ(func(big_number, &str_end, 10), ReturnT(1234567890));
-    ASSERT_EQ(errno, 0);
+    ASSERT_EQ(libc_errno, 0);
     EXPECT_EQ(str_end - big_number, ptrdiff_t(10));
 
     // This number is larger than 2^32, meaning that if long is only 32 bits
     // wide, strtol will return LONG_MAX.
     const char *bigger_number = "12345678900";
-    errno = 0;
+    libc_errno = 0;
     if constexpr (sizeof(ReturnT) < 8) {
       ASSERT_EQ(func(bigger_number, &str_end, 10), T_MAX);
-      ASSERT_EQ(errno, ERANGE);
+      ASSERT_EQ(libc_errno, ERANGE);
     } else {
       ASSERT_EQ(func(bigger_number, &str_end, 10), ReturnT(12345678900));
-      ASSERT_EQ(errno, 0);
+      ASSERT_EQ(libc_errno, 0);
     }
     EXPECT_EQ(str_end - bigger_number, ptrdiff_t(11));
 
     const char *too_big_number = "123456789012345678901";
-    errno = 0;
+    libc_errno = 0;
     ASSERT_EQ(func(too_big_number, &str_end, 10), T_MAX);
-    ASSERT_EQ(errno, ERANGE);
+    ASSERT_EQ(libc_errno, ERANGE);
     EXPECT_EQ(str_end - too_big_number, ptrdiff_t(21));
 
     const char *long_number_range_test =
         "10000000000000000000000000000000000000000000000000";
-    errno = 0;
+    libc_errno = 0;
     ASSERT_EQ(func(long_number_range_test, &str_end, 10), T_MAX);
-    ASSERT_EQ(errno, ERANGE);
+    ASSERT_EQ(libc_errno, ERANGE);
     EXPECT_EQ(str_end - long_number_range_test, ptrdiff_t(50));
 
     // For most negative numbers, the unsigned functions treat it the same as
     // casting a negative variable to an unsigned type.
     const char *negative = "-100";
-    errno = 0;
+    libc_errno = 0;
     ASSERT_EQ(func(negative, &str_end, 10), ReturnT(-100));
-    ASSERT_EQ(errno, 0);
+    ASSERT_EQ(libc_errno, 0);
     EXPECT_EQ(str_end - negative, ptrdiff_t(4));
 
     const char *big_negative_number = "-1234567890";
-    errno = 0;
+    libc_errno = 0;
     ASSERT_EQ(func(big_negative_number, &str_end, 10), ReturnT(-1234567890));
-    ASSERT_EQ(errno, 0);
+    ASSERT_EQ(libc_errno, 0);
     EXPECT_EQ(str_end - big_negative_number, ptrdiff_t(11));
 
     const char *too_big_negative_number = "-123456789012345678901";
-    errno = 0;
+    libc_errno = 0;
     // If the number is signed, it should return the smallest negative number
     // for the current type, but if it's unsigned it should max out and return
     // the largest positive number for the current type. From the standard:
     // "If the correct value is outside the range of representable values,
     // LONG_MIN, LONG_MAX, LLONG_MIN, LLONG_MAX, ULONG_MAX, or ULLONG_MAX is
     // returned"
     // Note that 0 is not on that list.
     ASSERT_EQ(func(too_big_negative_number, &str_end, 10),
               (is_signed_v<ReturnT> ? T_MIN : T_MAX));
-    ASSERT_EQ(errno, ERANGE);
+    ASSERT_EQ(libc_errno, ERANGE);
     EXPECT_EQ(str_end - too_big_negative_number, ptrdiff_t(22));
   }
 
   void MessyBaseTenDecode(FunctionT func) {
     char *str_end = nullptr;
 
     const char *spaces_before = "     10";
-    errno = 0;
+    libc_errno = 0;
     ASSERT_EQ(func(spaces_before, &str_end, 10), ReturnT(10));
-    ASSERT_EQ(errno, 0);
+    ASSERT_EQ(libc_errno, 0);
     EXPECT_EQ(str_end - spaces_before, ptrdiff_t(7));
 
     const char *spaces_after = "10      ";
-    errno = 0;
+    libc_errno = 0;
     ASSERT_EQ(func(spaces_after, &str_end, 10), ReturnT(10));
-    ASSERT_EQ(errno, 0);
+    ASSERT_EQ(libc_errno, 0);
     EXPECT_EQ(str_end - spaces_after, ptrdiff_t(2));
 
     const char *word_before = "word10";
-    errno = 0;
+    libc_errno = 0;
     ASSERT_EQ(func(word_before, &str_end, 10), ReturnT(0));
-    ASSERT_EQ(errno, 0);
+    ASSERT_EQ(libc_errno, 0);
     EXPECT_EQ(str_end - word_before, ptrdiff_t(0));
 
     const char *word_after = "10word";
-    errno = 0;
+    libc_errno = 0;
     ASSERT_EQ(func(word_after, &str_end, 10), ReturnT(10));
-    ASSERT_EQ(errno, 0);
+    ASSERT_EQ(libc_errno, 0);
     EXPECT_EQ(str_end - word_after, ptrdiff_t(2));
 
     const char *two_numbers = "10 999";
-    errno = 0;
+    libc_errno = 0;
     ASSERT_EQ(func(two_numbers, &str_end, 10), ReturnT(10));
-    ASSERT_EQ(errno, 0);
+    ASSERT_EQ(libc_errno, 0);
     EXPECT_EQ(str_end - two_numbers, ptrdiff_t(2));
 
     const char *two_signs = "--10 999";
-    errno = 0;
+    libc_errno = 0;
     ASSERT_EQ(func(two_signs, &str_end, 10), ReturnT(0));
-    ASSERT_EQ(errno, 0);
+    ASSERT_EQ(libc_errno, 0);
     EXPECT_EQ(str_end - two_signs, ptrdiff_t(0));
 
     const char *sign_before = "+2=4";
-    errno = 0;
+    libc_errno = 0;
     ASSERT_EQ(func(sign_before, &str_end, 10), ReturnT(2));
-    ASSERT_EQ(errno, 0);
+    ASSERT_EQ(libc_errno, 0);
     EXPECT_EQ(str_end - sign_before, ptrdiff_t(2));
 
     const char *sign_after = "2+2=4";
-    errno = 0;
+    libc_errno = 0;
     ASSERT_EQ(func(sign_after, &str_end, 10), ReturnT(2));
-    ASSERT_EQ(errno, 0);
+    ASSERT_EQ(libc_errno, 0);
     EXPECT_EQ(str_end - sign_after, ptrdiff_t(1));
 
     const char *tab_before = "\t10";
-    errno = 0;
+    libc_errno = 0;
     ASSERT_EQ(func(tab_before, &str_end, 10), ReturnT(10));
-    ASSERT_EQ(errno, 0);
+    ASSERT_EQ(libc_errno, 0);
     EXPECT_EQ(str_end - tab_before, ptrdiff_t(3));
 
     const char *all_together = "\t  -12345and+67890";
-    errno = 0;
+    libc_errno = 0;
     ASSERT_EQ(func(all_together, &str_end, 10), ReturnT(-12345));
-    ASSERT_EQ(errno, 0);
+    ASSERT_EQ(libc_errno, 0);
     EXPECT_EQ(str_end - all_together, ptrdiff_t(9));
 
     const char *just_spaces = "  ";
-    errno = 0;
+    libc_errno = 0;
     ASSERT_EQ(func(just_spaces, &str_end, 10), ReturnT(0));
-    ASSERT_EQ(errno, 0);
+    ASSERT_EQ(libc_errno, 0);
     EXPECT_EQ(str_end - just_spaces, ptrdiff_t(0));
 
     const char *just_space_and_sign = " +";
-    errno = 0;
+    libc_errno = 0;
     ASSERT_EQ(func(just_space_and_sign, &str_end, 10), ReturnT(0));
-    ASSERT_EQ(errno, 0);
+    ASSERT_EQ(libc_errno, 0);
     EXPECT_EQ(str_end - just_space_and_sign, ptrdiff_t(0));
   }
 
   void DecodeInOtherBases(FunctionT func) {
     char small_string[4] = {'\0', '\0', '\0', '\0'};
     for (int base = 2; base <= 36; ++base) {
       for (int first_digit = 0; first_digit <= 36; ++first_digit) {
         small_string[0] = int_to_b36_char(first_digit);
         if (first_digit < base) {
-          errno = 0;
+          libc_errno = 0;
           ASSERT_EQ(func(small_string, nullptr, base),
                     static_cast<ReturnT>(first_digit));
-          ASSERT_EQ(errno, 0);
+          ASSERT_EQ(libc_errno, 0);
         } else {
-          errno = 0;
+          libc_errno = 0;
           ASSERT_EQ(func(small_string, nullptr, base), ReturnT(0));
-          ASSERT_EQ(errno, 0);
+          ASSERT_EQ(libc_errno, 0);
         }
       }
     }
 
     for (int base = 2; base <= 36; ++base) {
       for (int first_digit = 0; first_digit <= 36; ++first_digit) {
         small_string[0] = int_to_b36_char(first_digit);
         for (int second_digit = 0; second_digit <= 36; ++second_digit) {
           small_string[1] = int_to_b36_char(second_digit);
           if (first_digit < base && second_digit < base) {
-            errno = 0;
+            libc_errno = 0;
             ASSERT_EQ(
                 func(small_string, nullptr, base),
                 static_cast<ReturnT>(second_digit + (first_digit * base)));
-            ASSERT_EQ(errno, 0);
+            ASSERT_EQ(libc_errno, 0);
           } else if (first_digit < base) {
-            errno = 0;
+            libc_errno = 0;
             ASSERT_EQ(func(small_string, nullptr, base),
                       static_cast<ReturnT>(first_digit));
-            ASSERT_EQ(errno, 0);
+            ASSERT_EQ(libc_errno, 0);
           } else {
-            errno = 0;
+            libc_errno = 0;
             ASSERT_EQ(func(small_string, nullptr, base), ReturnT(0));
-            ASSERT_EQ(errno, 0);
+            ASSERT_EQ(libc_errno, 0);
           }
         }
       }
     }
 
     for (int base = 2; base <= 36; ++base) {
       for (int first_digit = 0; first_digit <= 36; ++first_digit) {
         small_string[0] = int_to_b36_char(first_digit);
         for (int second_digit = 0; second_digit <= 36; ++second_digit) {
           small_string[1] = int_to_b36_char(second_digit);
           for (int third_digit = 0; third_digit <= 36; ++third_digit) {
             small_string[2] = int_to_b36_char(third_digit);
 
             if (first_digit < base && second_digit < base &&
                 third_digit < base) {
-              errno = 0;
+              libc_errno = 0;
               ASSERT_EQ(func(small_string, nullptr, base),
                         static_cast<ReturnT>(third_digit +
                                              (second_digit * base) +
                                              (first_digit * base * base)));
-              ASSERT_EQ(errno, 0);
+              ASSERT_EQ(libc_errno, 0);
             } else if (first_digit < base && second_digit < base) {
-              errno = 0;
+              libc_errno = 0;
               ASSERT_EQ(
                   func(small_string, nullptr, base),
                   static_cast<ReturnT>(second_digit + (first_digit * base)));
-              ASSERT_EQ(errno, 0);
+              ASSERT_EQ(libc_errno, 0);
             } else if (first_digit < base) {
               // if the base is 16 there is a special case for the prefix 0X.
               // The number is treated as a one digit hexadecimal.
               if (base == 16 && first_digit == 0 && second_digit == 33) {
                 if (third_digit < base) {
-                  errno = 0;
+                  libc_errno = 0;
                   ASSERT_EQ(func(small_string, nullptr, base),
                             static_cast<ReturnT>(third_digit));
-                  ASSERT_EQ(errno, 0);
+                  ASSERT_EQ(libc_errno, 0);
                 } else {
-                  errno = 0;
+                  libc_errno = 0;
                   ASSERT_EQ(func(small_string, nullptr, base), ReturnT(0));
-                  ASSERT_EQ(errno, 0);
+                  ASSERT_EQ(libc_errno, 0);
                 }
               } else {
-                errno = 0;
+                libc_errno = 0;
                 ASSERT_EQ(func(small_string, nullptr, base),
                           static_cast<ReturnT>(first_digit));
-                ASSERT_EQ(errno, 0);
+                ASSERT_EQ(libc_errno, 0);
               }
             } else {
-              errno = 0;
+              libc_errno = 0;
               ASSERT_EQ(func(small_string, nullptr, base), ReturnT(0));
-              ASSERT_EQ(errno, 0);
+              ASSERT_EQ(libc_errno, 0);
             }
           }
         }
       }
     }
   }
 
   void CleanBaseSixteenDecode(FunctionT func) {
     char *str_end = nullptr;
 
     const char *no_prefix = "123abc";
-    errno = 0;
+    libc_errno = 0;
     ASSERT_EQ(func(no_prefix, &str_end, 16), ReturnT(0x123abc));
-    ASSERT_EQ(errno, 0);
+    ASSERT_EQ(libc_errno, 0);
     EXPECT_EQ(str_end - no_prefix, ptrdiff_t(6));
 
     const char *yes_prefix = "0x456def";
-    errno = 0;
+    libc_errno = 0;
     ASSERT_EQ(func(yes_prefix, &str_end, 16), ReturnT(0x456def));
-    ASSERT_EQ(errno, 0);
+    ASSERT_EQ(libc_errno, 0);
     EXPECT_EQ(str_end - yes_prefix, ptrdiff_t(8));
 
     const char *letter_after_prefix = "0xabc123";
-    errno = 0;
+    libc_errno = 0;
     ASSERT_EQ(func(letter_after_prefix, &str_end, 16), ReturnT(0xabc123));
-    ASSERT_EQ(errno, 0);
+    ASSERT_EQ(libc_errno, 0);
     EXPECT_EQ(str_end - letter_after_prefix, ptrdiff_t(8));
   }
 
   void MessyBaseSixteenDecode(FunctionT func) {
     char *str_end = nullptr;
 
     const char *just_prefix = "0x";
-    errno = 0;
+    libc_errno = 0;
     ASSERT_EQ(func(just_prefix, &str_end, 16), ReturnT(0));
-    ASSERT_EQ(errno, 0);
+    ASSERT_EQ(libc_errno, 0);
     EXPECT_EQ(str_end - just_prefix, ptrdiff_t(1));
 
-    errno = 0;
+    libc_errno = 0;
     ASSERT_EQ(func(just_prefix, &str_end, 0), ReturnT(0));
-    ASSERT_EQ(errno, 0);
+    ASSERT_EQ(libc_errno, 0);
     EXPECT_EQ(str_end - just_prefix, ptrdiff_t(1));
 
     const char *prefix_with_x_after = "0xx";
-    errno = 0;
+    libc_errno = 0;
     ASSERT_EQ(func(prefix_with_x_after, &str_end, 16), ReturnT(0));
-    ASSERT_EQ(errno, 0);
+    ASSERT_EQ(libc_errno, 0);
     EXPECT_EQ(str_end - prefix_with_x_after, ptrdiff_t(1));
 
-    errno = 0;
+    libc_errno = 0;
     ASSERT_EQ(func(prefix_with_x_after, &str_end, 0), ReturnT(0));
-    ASSERT_EQ(errno, 0);
+    ASSERT_EQ(libc_errno, 0);
     EXPECT_EQ(str_end - prefix_with_x_after, ptrdiff_t(1));
   }
 
   void AutomaticBaseSelection(FunctionT func) {
     char *str_end = nullptr;
 
     const char *base_ten = "12345";
-    errno = 0;
+    libc_errno = 0;
     ASSERT_EQ(func(base_ten, &str_end, 0), ReturnT(12345));
-    ASSERT_EQ(errno, 0);
+    ASSERT_EQ(libc_errno, 0);
     EXPECT_EQ(str_end - base_ten, ptrdiff_t(5));
 
     const char *base_sixteen_no_prefix = "123abc";
-    errno = 0;
+    libc_errno = 0;
     ASSERT_EQ(func(base_sixteen_no_prefix, &str_end, 0), ReturnT(123));
-    ASSERT_EQ(errno, 0);
+    ASSERT_EQ(libc_errno, 0);
     EXPECT_EQ(str_end - base_sixteen_no_prefix, ptrdiff_t(3));
 
     const char *base_sixteen_with_prefix = "0x456def";
-    errno = 0;
+    libc_errno = 0;
     ASSERT_EQ(func(base_sixteen_with_prefix, &str_end, 0), ReturnT(0x456def));
-    ASSERT_EQ(errno, 0);
+    ASSERT_EQ(libc_errno, 0);
     EXPECT_EQ(str_end - base_sixteen_with_prefix, ptrdiff_t(8));
 
     const char *base_eight_with_prefix = "012345";
-    errno = 0;
+    libc_errno = 0;
     ASSERT_EQ(func(base_eight_with_prefix, &str_end, 0), ReturnT(012345));
-    ASSERT_EQ(errno, 0);
+    ASSERT_EQ(libc_errno, 0);
     EXPECT_EQ(str_end - base_eight_with_prefix, ptrdiff_t(6));
 
     const char *just_zero = "0";
-    errno = 0;
+    libc_errno = 0;
     ASSERT_EQ(func(just_zero, &str_end, 0), ReturnT(0));
-    ASSERT_EQ(errno, 0);
+    ASSERT_EQ(libc_errno, 0);
     EXPECT_EQ(str_end - just_zero, ptrdiff_t(1));
 
     const char *just_zero_x = "0x";
-    errno = 0;
+    libc_errno = 0;
     ASSERT_EQ(func(just_zero_x, &str_end, 0), ReturnT(0));
-    ASSERT_EQ(errno, 0);
+    ASSERT_EQ(libc_errno, 0);
     EXPECT_EQ(str_end - just_zero_x, ptrdiff_t(1));
 
     const char *just_zero_eight = "08";
-    errno = 0;
+    libc_errno = 0;
     ASSERT_EQ(func(just_zero_eight, &str_end, 0), ReturnT(0));
-    ASSERT_EQ(errno, 0);
+    ASSERT_EQ(libc_errno, 0);
     EXPECT_EQ(str_end - just_zero_eight, ptrdiff_t(1));
   }
 };
 
 template <typename ReturnType>
 StrtoTest(ReturnType (*)(const char *)) -> StrtoTest<ReturnType>;
 
 #define STRTOL_TEST(name, func)                                                \

libc/test/src/stdlib/atof_test.cpp

 //===-- Unittests for atof ------------------------------------------------===//
 //
 // 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/errno/libc_errno.h"
 #include "src/stdlib/atof.h"
 
 #include "test/UnitTest/Test.h"
 
-#include <errno.h>
 #include <limits.h>
 #include <stddef.h>
 
 // This is just a simple test to make sure that this function works at all. It's
 // functionally identical to strtod so the bulk of the testing is there.
 TEST(LlvmLibcAToFTest, SimpleTest) {
   __llvm_libc::fputil::FPBits<double> expected_fp =
       __llvm_libc::fputil::FPBits<double>(uint64_t(0x405ec00000000000));
 
-  errno = 0;
+  libc_errno = 0;
   double result = __llvm_libc::atof("123");
 
   __llvm_libc::fputil::FPBits<double> actual_fp =
       __llvm_libc::fputil::FPBits<double>(result);
 
   EXPECT_EQ(actual_fp.bits, expected_fp.bits);
   EXPECT_EQ(actual_fp.get_sign(), expected_fp.get_sign());
   EXPECT_EQ(actual_fp.get_exponent(), expected_fp.get_exponent());
   EXPECT_EQ(actual_fp.get_mantissa(), expected_fp.get_mantissa());
-  EXPECT_EQ(errno, 0);
+  EXPECT_EQ(libc_errno, 0);
 }
 
 TEST(LlvmLibcAToFTest, FailedParsingTest) {
   __llvm_libc::fputil::FPBits<double> expected_fp =
       __llvm_libc::fputil::FPBits<double>(uint64_t(0));
 
-  errno = 0;
+  libc_errno = 0;
   double result = __llvm_libc::atof("???");
 
   __llvm_libc::fputil::FPBits<double> actual_fp =
       __llvm_libc::fputil::FPBits<double>(result);
 
   EXPECT_EQ(actual_fp.bits, expected_fp.bits);
   EXPECT_EQ(actual_fp.get_sign(), expected_fp.get_sign());
   EXPECT_EQ(actual_fp.get_exponent(), expected_fp.get_exponent());
   EXPECT_EQ(actual_fp.get_mantissa(), expected_fp.get_mantissa());
-  EXPECT_EQ(errno, 0);
+  EXPECT_EQ(libc_errno, 0);
 }

libc/test/src/stdlib/strtod_test.cpp

 //===-- Unittests for strtod ---------------------------------------------===//
 //
 // 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/errno/libc_errno.h"
 #include "src/stdlib/strtod.h"
 
 #include "test/UnitTest/Test.h"
 #include "utils/testutils/RoundingModeUtils.h"
 
-#include <errno.h>
 #include <limits.h>
 #include <stddef.h>
 
 using __llvm_libc::testutils::ForceRoundingModeTest;
 using __llvm_libc::testutils::RoundingMode;
 
 class LlvmLibcStrToDTest : public __llvm_libc::testing::Test,
                            ForceRoundingModeTest<RoundingMode::Nearest> {
void run_test(const char *inputString, const ptrdiff_t expectedStrLen,
     //       +-- 11 Exponent Bits
     //
     //  This is so that the result can be compared in parts.
     char *str_end = nullptr;
 
     __llvm_libc::fputil::FPBits<double> expected_fp =
         __llvm_libc::fputil::FPBits<double>(expectedRawData);
 
-    errno = 0;
+    libc_errno = 0;
     double result = __llvm_libc::strtod(inputString, &str_end);
 
     __llvm_libc::fputil::FPBits<double> actual_fp =
         __llvm_libc::fputil::FPBits<double>(result);
 
     EXPECT_EQ(str_end - inputString, expectedStrLen);
 
     EXPECT_EQ(actual_fp.bits, expected_fp.bits);
     EXPECT_EQ(actual_fp.get_sign(), expected_fp.get_sign());
     EXPECT_EQ(actual_fp.get_exponent(), expected_fp.get_exponent());
     EXPECT_EQ(actual_fp.get_mantissa(), expected_fp.get_mantissa());
-    EXPECT_EQ(errno, expectedErrno);
+    EXPECT_EQ(libc_errno, expectedErrno);
   }
 };
 
 TEST_F(LlvmLibcStrToDTest, SimpleTest) {
   run_test("123", 3, uint64_t(0x405ec00000000000));
 
   // This should fail on Eisel-Lemire, forcing a fallback to simple decimal
   // conversion.

libc/test/src/stdlib/strtof_test.cpp

 //===-- Unittests for strtof ---------------------------------------------===//
 //
 // 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/errno/libc_errno.h"
 #include "src/stdlib/strtof.h"
 
 #include "test/UnitTest/Test.h"
 #include "utils/testutils/RoundingModeUtils.h"
 
-#include <errno.h>
 #include <limits.h>
 #include <stddef.h>
 
 using __llvm_libc::testutils::ForceRoundingModeTest;
 using __llvm_libc::testutils::RoundingMode;
 
 class LlvmLibcStrToFTest : public __llvm_libc::testing::Test,
                            ForceRoundingModeTest<RoundingMode::Nearest> {
void run_test(const char *inputString, const ptrdiff_t expectedStrLen,
     //     +-- 8 Exponent Bits
     //
     //  This is so that the result can be compared in parts.
     char *str_end = nullptr;
 
     __llvm_libc::fputil::FPBits<float> expected_fp =
         __llvm_libc::fputil::FPBits<float>(expectedRawData);
 
-    errno = 0;
+    libc_errno = 0;
     float result = __llvm_libc::strtof(inputString, &str_end);
 
     __llvm_libc::fputil::FPBits<float> actual_fp =
         __llvm_libc::fputil::FPBits<float>(result);
 
     EXPECT_EQ(str_end - inputString, expectedStrLen);
 
     EXPECT_EQ(actual_fp.bits, expected_fp.bits);
     EXPECT_EQ(actual_fp.get_sign(), expected_fp.get_sign());
     EXPECT_EQ(actual_fp.get_exponent(), expected_fp.get_exponent());
     EXPECT_EQ(actual_fp.get_mantissa(), expected_fp.get_mantissa());
-    EXPECT_EQ(errno, expectedErrno);
+    EXPECT_EQ(libc_errno, expectedErrno);
   }
 };
 
 // This is the set of tests that I have working (verified correct when compared
 // to system libc). This is here so I don't break more things when I try to fix
 // them.
 
 TEST_F(LlvmLibcStrToFTest, BasicDecimalTests) {

libc/test/src/stdlib/strtold_test.cpp

 //===-- Unittests for strtold ---------------------------------------------===//
 //
 // 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/UInt128.h"
+#include "src/errno/libc_errno.h"
 #include "src/stdlib/strtold.h"
 
 #include "test/UnitTest/Test.h"
 
-#include <errno.h>
 #include <limits.h>
 #include <stddef.h>
 
 #if defined(LONG_DOUBLE_IS_DOUBLE)
 #define SELECT_CONST(val, _, __) val
 #elif defined(SPECIAL_X86_LONG_DOUBLE)
 #define SELECT_CONST(_, val, __) val
 #else
#endif
     //         |
     //         +-- 15 Exponent Bits
     char *str_end = nullptr;
 
     __llvm_libc::fputil::FPBits<long double> expected_fp =
         __llvm_libc::fputil::FPBits<long double>(expectedRawData);
     const int expected_errno = expectedErrno;
 
-    errno = 0;
+    libc_errno = 0;
     long double result = __llvm_libc::strtold(inputString, &str_end);
 
     __llvm_libc::fputil::FPBits<long double> actual_fp =
         __llvm_libc::fputil::FPBits<long double>();
     actual_fp = __llvm_libc::fputil::FPBits<long double>(result);
 
     EXPECT_EQ(str_end - inputString, expectedStrLen);
 
     EXPECT_EQ(actual_fp.bits, expected_fp.bits);
     EXPECT_EQ(actual_fp.get_sign(), expected_fp.get_sign());
     EXPECT_EQ(actual_fp.get_exponent(), expected_fp.get_exponent());
     EXPECT_EQ(actual_fp.get_mantissa(), expected_fp.get_mantissa());
-    EXPECT_EQ(errno, expected_errno);
+    EXPECT_EQ(libc_errno, expected_errno);
   }
 };
 
 TEST_F(LlvmLibcStrToLDTest, SimpleTest) {
   run_test("123", 3,
            SELECT_CONST(uint64_t(0x405ec00000000000),
                         UInt128(0x4005f60000) << 40,
                         UInt128(0x4005ec0000000000) << 64));

utils/bazel/llvm-project-overlay/libc/BUILD.bazel

 libc_support_library(
     name = "__support_str_to_integer",
     hdrs = ["src/__support/str_to_integer.h"],
     deps = [
         ":__support_common",
         ":__support_cpp_limits",
         ":__support_ctype_utils",
         ":__support_str_to_num_result",
+        ":errno",
     ],
 )
 
 libc_support_library(
     name = "__support_str_to_float",
     hdrs = [
         "src/__support/detailed_powers_of_ten.h",
         "src/__support/high_precision_decimal.h",
         "src/__support/str_to_float.h",
     ],
     deps = [
         ":__support_builtin_wrappers",
         ":__support_common",
         ":__support_cpp_limits",
         ":__support_cpp_optional",
         ":__support_ctype_utils",
         ":__support_fputil_fenv_impl",
         ":__support_fputil_fp_bits",
         ":__support_str_to_integer",
         ":__support_str_to_num_result",
         ":__support_uint128",
+        ":errno",
     ],
 )
 
 libc_support_library(
     name = "__support_fputil_basic_operations",
     hdrs = ["src/__support/FPUtil/BasicOperations.h"],
     deps = [
         ":__support_common",

 
 libc_function(
     name = "atoi",
     srcs = ["src/stdlib/atoi.cpp"],
     hdrs = ["src/stdlib/atoi.h"],
     deps = [
         ":__support_common",
         ":__support_str_to_integer",
+        ":errno",
     ],
 )
 
 libc_function(
     name = "atol",
     srcs = ["src/stdlib/atol.cpp"],
     hdrs = ["src/stdlib/atol.h"],
     deps = [
         ":__support_common",
         ":__support_str_to_integer",
+        ":errno",
     ],
 )
 
 libc_function(
     name = "atoll",
     srcs = ["src/stdlib/atoll.cpp"],
     hdrs = ["src/stdlib/atoll.h"],
     deps = [
         ":__support_common",
         ":__support_str_to_integer",
+        ":errno",
     ],
 )
 
 libc_function(
     name = "atof",
     srcs = ["src/stdlib/atof.cpp"],
     hdrs = ["src/stdlib/atof.h"],
     deps = [
         ":__support_common",
         ":__support_str_to_float",
+        ":errno",
     ],
 )
 
 libc_function(
     name = "bsearch",
     srcs = ["src/stdlib/bsearch.cpp"],
     hdrs = ["src/stdlib/bsearch.h"],
     deps = [

 
 libc_function(
     name = "strtol",
     srcs = ["src/stdlib/strtol.cpp"],
     hdrs = ["src/stdlib/strtol.h"],
     deps = [
         ":__support_common",
         ":__support_str_to_integer",
+        ":errno",
     ],
 )
 
 libc_function(
     name = "strtoll",
     srcs = ["src/stdlib/strtoll.cpp"],
     hdrs = ["src/stdlib/strtoll.h"],
     deps = [
         ":__support_common",
         ":__support_str_to_integer",
+        ":errno",
     ],
 )
 
 libc_function(
     name = "strtoul",
     srcs = ["src/stdlib/strtoul.cpp"],
     hdrs = ["src/stdlib/strtoul.h"],
     deps = [
         ":__support_common",
         ":__support_str_to_integer",
+        ":errno",
     ],
 )
 
 libc_function(
     name = "strtoull",
     srcs = ["src/stdlib/strtoull.cpp"],
     hdrs = ["src/stdlib/strtoull.h"],
     deps = [
         ":__support_common",
         ":__support_str_to_integer",
+        ":errno",
     ],
 )
 
 libc_function(
     name = "strtof",
     srcs = ["src/stdlib/strtof.cpp"],
     hdrs = ["src/stdlib/strtof.h"],
     deps = [
         ":__support_common",
         ":__support_str_to_float",
+        ":errno",
     ],
 )
 
 libc_function(
     name = "strtod",
     srcs = ["src/stdlib/strtod.cpp"],
     hdrs = ["src/stdlib/strtod.h"],
     deps = [
         ":__support_common",
         ":__support_str_to_float",
+        ":errno",
     ],
 )
 
 libc_function(
     name = "strtold",
     srcs = ["src/stdlib/strtold.cpp"],
     hdrs = ["src/stdlib/strtold.h"],
     deps = [
         ":__support_common",
         ":__support_str_to_float",
+        ":errno",
     ],
 )
 
 ############################### string targets ###############################
 
 no_sanitize_features = [
     "-asan",
     "-msan",