[libc] Switch signal and termios to libc_errno.

[michaelrj]

LGTM

[michaelrj]

Update the tests as well before landing.

[sivachandra]

Update correspondign tests as well.

libc/src/signal/linux/CMakeLists.txt

 add_entrypoint_object(
   kill
   SRCS
     kill.cpp
   HDRS
     ../kill.h
   DEPENDS
     libc.include.signal
-    libc.include.errno
     libc.src.errno.errno
     libc.include.sys_syscall
     libc.src.__support.OSUtil.osutil
 )
 
 add_entrypoint_object(
   raise
   SRCS

 add_entrypoint_object(
   sigemptyset
   SRCS
     sigemptyset.cpp
   HDRS
     ../sigemptyset.h
   DEPENDS
     .signal_utils
-    libc.include.errno
     libc.include.signal
     libc.src.errno.errno
 )
 
 add_entrypoint_object(
   sigaddset
   SRCS
     sigaddset.cpp
   HDRS
     ../sigaddset.h
   DEPENDS
     .signal_utils
-    libc.include.errno
     libc.include.signal
     libc.src.errno.errno
 )
 
 add_entrypoint_object(
   signal
   SRCS
     signal.cpp
   HDRS
     ../signal.h
   DEPENDS
     .sigaction
     libc.include.signal
 )
 
 add_entrypoint_object(
   sigfillset
   SRCS
     sigfillset.cpp
   HDRS
     ../sigfillset.h
   DEPENDS
     .signal_utils
-    libc.include.errno
     libc.include.signal
     libc.src.errno.errno
 )
 
 add_entrypoint_object(
   sigdelset
   SRCS
     sigdelset.cpp
   HDRS
     ../sigdelset.h
   DEPENDS
     .signal_utils
-    libc.include.errno
     libc.include.signal
     libc.src.errno.errno
 )

libc/src/signal/linux/kill.cpp

 //===-- Linux implementation of kill --------------------------------------===//
 //
 // 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/signal/kill.h"
 
 #include "src/__support/OSUtil/syscall.h" // For internal syscall function.
-#include "src/signal/linux/signal_utils.h"
-
 #include "src/__support/common.h"
+#include "src/errno/libc_errno.h"
+#include "src/signal/linux/signal_utils.h"
 
-#include <errno.h>
 #include <signal.h>
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, kill, (pid_t pid, int sig)) {
   int ret = __llvm_libc::syscall_impl(SYS_kill, pid, sig);
 
   // A negative return value indicates an error with the magnitude of the
   // value being the error code.
   if (ret != 0) {
-    errno = (ret > 0 ? ret : -ret);
+    libc_errno = (ret > 0 ? ret : -ret);
     return -1;
   }
 
   return ret; // always 0
 }
 
 } // namespace __llvm_libc

libc/src/signal/linux/sigaction.cpp

 //===-- Linux implementation of sigaction ---------------------------------===//
 //
 // 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/signal/sigaction.h"
+#include "src/errno/libc_errno.h"
 #include "src/signal/linux/signal_utils.h"
 
 #include "src/__support/common.h"
 
-#include <errno.h>
 #include <signal.h>
 
 namespace __llvm_libc {
 
 // TOOD: Some architectures will have their signal trampoline functions in the
 // vdso, use those when available.
 
 extern "C" void __restore_rt();
if (libc_new) {
     }
   }
 
   KernelSigaction kernel_old;
   int ret = __llvm_libc::syscall_impl(
       SYS_rt_sigaction, signal, libc_new ? &kernel_new : nullptr,
       libc_old ? &kernel_old : nullptr, sizeof(sigset_t));
   if (ret) {
-    errno = -ret;
+    libc_errno = -ret;
     return -1;
   }
 
   if (libc_old)
     *libc_old = kernel_old;
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/signal/linux/sigaddset.cpp

 //===-- Linux implementation of sigaddset ---------------------------------===//
 //
 // 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/signal/sigaddset.h"
 #include "src/__support/common.h"
+#include "src/errno/libc_errno.h"
 #include "src/signal/linux/signal_utils.h"
 
-#include <errno.h>
 #include <signal.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, sigaddset, (sigset_t * set, int signum)) {
   if (set != nullptr && add_signal(*set, signum))
     return 0;
-  errno = EINVAL;
+  libc_errno = EINVAL;
   return -1;
 }
 
 } // namespace __llvm_libc

libc/src/signal/linux/sigaltstack.cpp

 //===-- Linux implementation of sigaltstack -------------------------------===//
 //
 // 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/signal/sigaltstack.h"
+#include "src/errno/libc_errno.h"
 #include "src/signal/linux/signal_utils.h"
 
 #include "src/__support/common.h"
 
-#include <errno.h>
 #include <signal.h>
 #include <sys/syscall.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, sigaltstack,
                    (const stack_t *__restrict ss, stack_t *__restrict oss)) {
   if (ss != nullptr) {
     unsigned not_ss_disable = ~unsigned(SS_DISABLE);
     if ((unsigned(ss->ss_flags) & not_ss_disable) != 0) {
       // Flags cannot have anything other than SS_DISABLE set.
       // We do the type-casting to unsigned because the |ss_flags|
       // field of stack_t is of type "int".
-      errno = EINVAL;
+      libc_errno = EINVAL;
       return -1;
     }
     if (ss->ss_size < MINSIGSTKSZ) {
-      errno = ENOMEM;
+      libc_errno = ENOMEM;
       return -1;
     }
   }
 
   int ret = __llvm_libc::syscall_impl(SYS_sigaltstack, ss, oss);
   if (ret < 0) {
-    errno = -ret;
+    libc_errno = -ret;
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/signal/linux/sigdelset.cpp

 //===-- Linux implementation of sigdelset ---------------------------------===//
 //
 // 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/signal/sigdelset.h"
 #include "src/__support/common.h"
+#include "src/errno/libc_errno.h"
 #include "src/signal/linux/signal_utils.h"
 
-#include <errno.h>
 #include <signal.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, sigdelset, (sigset_t * set, int signum)) {
   if (set != nullptr && delete_signal(*set, signum))
     return 0;
-  errno = EINVAL;
+  libc_errno = EINVAL;
   return -1;
 }
 
 } // namespace __llvm_libc

libc/src/signal/linux/sigemptyset.cpp

 //===-- Linux implementation of sigemptyset -------------------------------===//
 //
 // 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/signal/sigemptyset.h"
+#include "src/errno/libc_errno.h"
 #include "src/signal/linux/signal_utils.h"
 
 #include "src/__support/common.h"
 
-#include <errno.h>
 #include <signal.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, sigemptyset, (sigset_t * set)) {
   if (!set) {
-    errno = EINVAL;
+    libc_errno = EINVAL;
     return -1;
   }
   *set = empty_set();
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/signal/linux/sigfillset.cpp

 //===-- Linux implementation of sigfillset --------------------------------===//
 //
 // 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/signal/sigfillset.h"
 #include "src/__support/common.h"
+#include "src/errno/libc_errno.h"
 #include "src/signal/linux/signal_utils.h"
 
-#include <errno.h>
 #include <signal.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, sigfillset, (sigset_t * set)) {
   if (!set) {
-    errno = EINVAL;
+    libc_errno = EINVAL;
     return -1;
   }
   *set = full_set();
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/signal/linux/sigprocmask.cpp

 //===-- Linux implementation of sigprocmask -------------------------------===//
 //
 // 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/signal/sigprocmask.h"
 #include "include/sys/syscall.h"          // For syscall numbers.
 #include "src/__support/OSUtil/syscall.h" // For internal syscall function.
+#include "src/errno/libc_errno.h"
 #include "src/signal/linux/signal_utils.h"
 
 #include "src/__support/common.h"
 
-#include <errno.h>
 #include <signal.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, sigprocmask,
                    (int how, const sigset_t *__restrict set,
                     sigset_t *__restrict oldset)) {
   int ret = __llvm_libc::syscall_impl(SYS_rt_sigprocmask, how, set, oldset,
                                       sizeof(sigset_t));
   if (!ret)
     return 0;
 
-  errno = -ret;
+  libc_errno = -ret;
   return -1;
 }
 
 } // namespace __llvm_libc

libc/src/termios/linux/cfsetispeed.cpp

 //===-- Linux implementation of cfsetispeed -------------------------------===//
 //
 // 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/termios/cfsetispeed.h"
 
 #include "src/__support/common.h"
+#include "src/errno/libc_errno.h"
 
-#include <errno.h>
 #include <termios.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, cfsetispeed, (struct termios * t, speed_t speed)) {
   constexpr speed_t NOT_SPEED_MASK = ~speed_t(CBAUD);
   // A speed value is valid only if it is equal to one of the B<NN+> values.
   if (t == nullptr || ((speed & NOT_SPEED_MASK) != 0)) {
-    errno = EINVAL;
+    libc_errno = EINVAL;
     return -1;
   }
 
   t->c_cflag = (t->c_cflag & NOT_SPEED_MASK) | speed;
   t->c_ispeed = speed;
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/termios/linux/cfsetospeed.cpp

 //===-- Linux implementation of cfsetospeed -------------------------------===//
 //
 // 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/termios/cfsetospeed.h"
+#include "src/errno/libc_errno.h"
 
 #include "src/__support/common.h"
 
-#include <errno.h>
 #include <termios.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, cfsetospeed, (struct termios * t, speed_t speed)) {
   constexpr speed_t NOT_SPEED_MASK = ~speed_t(CBAUD);
   // A speed value is valid only if it is equal to one of the B<NN+> values.
   if (t == nullptr || ((speed & NOT_SPEED_MASK) != 0)) {
-    errno = EINVAL;
+    libc_errno = EINVAL;
     return -1;
   }
 
   t->c_cflag = (t->c_cflag & NOT_SPEED_MASK) | speed;
   t->c_ospeed = speed;
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/termios/linux/tcdrain.cpp

 //===-- Linux implementation of tcdrain -----------------------------------===//
 //
 // 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/termios/tcdrain.h"
 
 #include "src/__support/OSUtil/syscall.h"
 #include "src/__support/common.h"
+#include "src/errno/libc_errno.h"
 
 #include <asm/ioctls.h> // Safe to include without the risk of name pollution.
-#include <errno.h>
 #include <sys/syscall.h> // For syscall numbers
 #include <termios.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, tcdrain, (int fd)) {
   long ret = __llvm_libc::syscall_impl(SYS_ioctl, fd, TCSBRK, 1);
   if (ret < 0) {
     errno = -ret;
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/termios/linux/tcflow.cpp

 //===-- Linux implementation of tcflow -----------------------------------===//
 //
 // 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/termios/tcflow.h"
 
 #include "src/__support/OSUtil/syscall.h"
 #include "src/__support/common.h"
+#include "src/errno/libc_errno.h"
 
 #include <asm/ioctls.h> // Safe to include without the risk of name pollution.
-#include <errno.h>
 #include <sys/syscall.h> // For syscall numbers
 #include <termios.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, tcflow, (int fd, int action)) {
   long ret = __llvm_libc::syscall_impl(SYS_ioctl, fd, TCXONC, action);
   if (ret < 0) {
-    errno = -ret;
+    libc_errno = -ret;
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/termios/linux/tcflush.cpp

 //===-- Linux implementation of tcflush -----------------------------------===//
 //
 // 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/termios/tcflush.h"
 
 #include "src/__support/OSUtil/syscall.h"
 #include "src/__support/common.h"
+#include "src/errno/libc_errno.h"
 
 #include <asm/ioctls.h> // Safe to include without the risk of name pollution.
-#include <errno.h>
 #include <sys/syscall.h> // For syscall numbers
 #include <termios.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, tcflush, (int fd, int queue_selector)) {
   long ret = __llvm_libc::syscall_impl(SYS_ioctl, fd, TCFLSH, queue_selector);
   if (ret < 0) {
     errno = -ret;
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/termios/linux/tcgetattr.cpp

 //===-- Linux implementation of tcgetattr ---------------------------------===//
 //
 // 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/termios/tcgetattr.h"
 #include "kernel_termios.h"
 
 #include "src/__support/OSUtil/syscall.h"
 #include "src/__support/common.h"
+#include "src/errno/libc_errno.h"
 
 #include <asm/ioctls.h> // Safe to include without the risk of name pollution.
-#include <errno.h>
 #include <sys/syscall.h> // For syscall numbers
 #include <termios.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, tcgetattr, (int fd, struct termios *t)) {
   __llvm_libc::kernel_termios kt;
   long ret = __llvm_libc::syscall_impl(SYS_ioctl, fd, TCGETS, &kt);
   if (ret < 0) {
-    errno = -ret;
+    libc_errno = -ret;
     return -1;
   }
   t->c_iflag = kt.c_iflag;
   t->c_oflag = kt.c_oflag;
   t->c_cflag = kt.c_cflag;
   t->c_lflag = kt.c_lflag;
   t->c_ispeed = kt.c_cflag & CBAUD;
   t->c_ospeed = kt.c_cflag & CBAUD;

libc/src/termios/linux/tcgetsid.cpp

 //===-- Linux implementation of tcgetsid ----------------------------------===//
 //
 // 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/termios/tcgetsid.h"
 
 #include "src/__support/OSUtil/syscall.h"
 #include "src/__support/common.h"
+#include "src/errno/libc_errno.h"
 
 #include <asm/ioctls.h> // Safe to include without the risk of name pollution.
-#include <errno.h>
 #include <sys/syscall.h> // For syscall numbers
 #include <termios.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(pid_t, tcgetsid, (int fd)) {
   pid_t sid;
   long ret = __llvm_libc::syscall_impl(SYS_ioctl, fd, TIOCGSID, &sid);
   if (ret < 0) {
     errno = -ret;
     return -1;
   }
   return sid;
 }
 
 } // namespace __llvm_libc

libc/src/termios/linux/tcsendbreak.cpp

 //===-- Linux implementation of tcsendbreak -------------------------------===//
 //
 // 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/termios/tcsendbreak.h"
 
 #include "src/__support/OSUtil/syscall.h"
 #include "src/__support/common.h"
+#include "src/errno/libc_errno.h"
 
 #include <asm/ioctls.h> // Safe to include without the risk of name pollution.
-#include <errno.h>
 #include <sys/syscall.h> // For syscall numbers
 #include <termios.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(pid_t, tcsendbreak, (int fd, int /* unused duration */)) {
   // POSIX leaves the behavior for non-zero duration implementation dependent.
   // Which means that the behavior can be the same as it is when duration is
   // zero. So, we just pass zero to the syscall.
   long ret = __llvm_libc::syscall_impl(SYS_ioctl, fd, TCSBRK, 0);
   if (ret < 0) {
-    errno = -ret;
+    libc_errno = -ret;
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/termios/linux/tcsetattr.cpp

 //===-- Linux implementation of tcsetattr ---------------------------------===//
 //
 // 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/termios/tcsetattr.h"
 #include "kernel_termios.h"
 
 #include "src/__support/OSUtil/syscall.h"
 #include "src/__support/common.h"
+#include "src/errno/libc_errno.h"
 
 #include <asm/ioctls.h> // Safe to include without the risk of name pollution.
-#include <errno.h>
 #include <sys/syscall.h> // For syscall numbers
 #include <termios.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, tcsetattr,
                    (int fd, int actions, const struct termios *t)) {
   struct kernel_termios kt;
   long cmd;
 
   switch (actions) {
   case TCSANOW:
     cmd = TCSETS;
     break;
   case TCSADRAIN:
     cmd = TCSETSW;
     break;
   case TCSAFLUSH:
     cmd = TCSETSF;
     break;
   default:
-    errno = EINVAL;
+    libc_errno = EINVAL;
     return -1;
   }
 
   kt.c_iflag = t->c_iflag;
   kt.c_oflag = t->c_oflag;
   kt.c_cflag = t->c_cflag;
   kt.c_lflag = t->c_lflag;
   size_t nccs = KERNEL_NCCS <= NCCS ? KERNEL_NCCS : NCCS;
   for (size_t i = 0; i < nccs; ++i)
     kt.c_cc[i] = t->c_cc[i];
   if (nccs < KERNEL_NCCS) {
     for (size_t i = nccs; i < KERNEL_NCCS; ++i)
       kt.c_cc[i] = 0;
   }
 
   long ret = __llvm_libc::syscall_impl(SYS_ioctl, fd, cmd, &kt);
   if (ret < 0) {
-    errno = -ret;
+    libc_errno = -ret;
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/test/src/signal/CMakeLists.txt

 add_libc_unittest(
   kill_test
   SUITE
     libc_signal_unittests
   SRCS
     kill_test.cpp
   DEPENDS
     libc.include.signal
-    libc.include.errno
-    libc.src.errno.errno
     libc.src.signal.kill
     libc.include.sys_syscall
     libc.src.__support.OSUtil.osutil
     libc.test.errno_setter_matcher
 )
 
 add_libc_unittest(
   sigaction_test

 
 add_libc_unittest(
   sigprocmask_test
   SUITE
     libc_signal_unittests
   SRCS
     sigprocmask_test.cpp
   DEPENDS
-    libc.include.errno
     libc.src.errno.errno
     libc.src.signal.raise
     libc.src.signal.sigaddset
     libc.src.signal.sigemptyset
     libc.src.signal.sigprocmask
     libc.test.errno_setter_matcher
 )
 

 
 add_libc_unittest(
   signal_test
   SUITE
     libc_signal_unittests
   SRCS
     signal_test.cpp
   DEPENDS
-    libc.include.errno
     libc.include.signal
     libc.src.errno.errno
     libc.src.signal.raise
     libc.src.signal.signal
     libc.test.errno_setter_matcher
 )
 
 add_libc_unittest(

 
 add_libc_unittest(
   sigaltstack_test
   SUITE
     libc_signal_unittests
   SRCS
     sigaltstack_test.cpp
   DEPENDS
-    libc.include.errno
     libc.include.signal
+    libc.src.errno.errno
     libc.src.signal.raise
     libc.src.signal.sigaltstack
     libc.src.signal.sigaction
+    libc.test.errno_setter_matcher
 )

libc/test/src/signal/kill_test.cpp

 //===-- Unittests for kill -----------------------------------------------===//
 //
 // 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/signal/kill.h"
 
 #include "include/sys/syscall.h"          // For syscall numbers.
 #include "src/__support/OSUtil/syscall.h" // For internal syscall function.
 #include "test/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
-#include <errno.h>
 #include <signal.h>
 
 using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
 
 TEST(LlvmLibcKillTest, TargetSelf) {
   pid_t parent_pid = __llvm_libc::syscall_impl(SYS_getpid);
   ASSERT_THAT(__llvm_libc::kill(parent_pid, 0), Succeeds(0));
 
   EXPECT_DEATH(
       [] {
         pid_t child_pid = __llvm_libc::syscall_impl(SYS_getpid);
         __llvm_libc::kill(child_pid, SIGKILL);
       },
       WITH_SIGNAL(SIGKILL));
 }

libc/test/src/signal/sigaddset_test.cpp

 //===-- Unittests for sigaddset -------------------------------------------===//
 //
 // 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 "include/errno.h"
 #include "include/signal.h"
 #include "src/signal/sigaddset.h"
 
 #include "test/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
+#include <errno.h>
+
 // This tests invalid inputs and ensures errno is properly set.
 TEST(LlvmLibcSignalTest, SigaddsetInvalid) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
   using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
   EXPECT_THAT(__llvm_libc::sigaddset(nullptr, SIGSEGV), Fails(EINVAL));
 
   sigset_t sigset;
   EXPECT_THAT(__llvm_libc::sigaddset(&sigset, -1), Fails(EINVAL));

libc/test/src/signal/sigaltstack_test.cpp

 //===-- Unittests for sigaltstack -----------------------------------------===//
 //
 // 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/OSUtil/syscall.h" // For internal syscall function.
+#include "src/errno/libc_errno.h"
 #include "src/signal/linux/signal_utils.h"
 #include "src/signal/raise.h"
 #include "src/signal/sigaction.h"
 #include "src/signal/sigaltstack.h"
 
 #include "test/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
-#include <errno.h>
 #include <signal.h>
 #include <stdint.h>
 #include <sys/syscall.h>
 
 constexpr int LOCAL_VAR_SIZE = 512;
 constexpr int ALT_STACK_SIZE = SIGSTKSZ + LOCAL_VAR_SIZE * 2;
 static uint8_t alt_stack[ALT_STACK_SIZE];
 
if (!(uintptr_t(var + i) < uintptr_t(alt_stack + ALT_STACK_SIZE) &&
       return;
     }
   }
   good_stack = true;
 }
 
 TEST(LlvmLibcSignalTest, SigaltstackRunOnAltStack) {
   struct sigaction action;
-  errno = 0;
+  libc_errno = 0;
   ASSERT_THAT(__llvm_libc::sigaction(SIGUSR1, nullptr, &action), Succeeds(0));
   action.sa_handler = handler;
   // Indicate that the signal should be delivered on an alternate stack.
   action.sa_flags = SA_ONSTACK;
   ASSERT_THAT(__llvm_libc::sigaction(SIGUSR1, &action, nullptr), Succeeds(0));
 
   stack_t ss;
   ss.ss_sp = alt_stack;

libc/test/src/signal/sigdelset_test.cpp

 //===-- Unittests for sigdelset -------------------------------------------===//
 //
 // 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 "include/errno.h"
 #include "include/signal.h"
 #include "src/signal/raise.h"
 #include "src/signal/sigdelset.h"
 #include "src/signal/sigfillset.h"
 #include "src/signal/sigprocmask.h"
 
 #include "test/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
+#include <errno.h>
+
 TEST(LlvmLibcSigdelset, Invalid) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
   // Invalid set.
   EXPECT_THAT(__llvm_libc::sigdelset(nullptr, SIGUSR1), Fails(EINVAL));
 
   sigset_t set;
   // Valid set, invalid signum.
   EXPECT_THAT(__llvm_libc::sigdelset(&set, -1), Fails(EINVAL));

libc/test/src/signal/sigfillset_test.cpp

 //===-- Unittests for sigfillset ------------------------------------------===//
 //
 // 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 "include/errno.h"
 #include "include/signal.h"
 #include "src/signal/raise.h"
 #include "src/signal/sigfillset.h"
 #include "src/signal/sigprocmask.h"
 
 #include "test/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
+#include <errno.h>
+
 TEST(LlvmLibcSigfillset, Invalid) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
   EXPECT_THAT(__llvm_libc::sigfillset(nullptr), Fails(EINVAL));
 }
 
 TEST(LlvmLibcSigfillset, BlocksAll) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
   sigset_t set;
   EXPECT_THAT(__llvm_libc::sigfillset(&set), Succeeds());
   EXPECT_THAT(__llvm_libc::sigprocmask(SIG_SETMASK, &set, nullptr), Succeeds());
   EXPECT_EXITS([] { __llvm_libc::raise(SIGUSR1); }, 0);
 }

libc/test/src/signal/signal_test.cpp

 //===-- Unittests for signal ----------------------------------------------===//
 //
 // 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 "include/errno.h"
 #include "include/signal.h"
-#include "src/errno/llvmlibc_errno.h"
+#include "src/errno/libc_errno.h"
 #include "src/signal/raise.h"
 #include "src/signal/signal.h"
 
 #include "test/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
 using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
 
 TEST(LlvmLibcSignal, Invalid) {
-  llvmlibc_errno = 0;
+  libc_errno = 0;
   __llvm_libc::sighandler_t valid = +[](int) {};
   EXPECT_THAT((void *)__llvm_libc::signal(0, valid),
               Fails(EINVAL, (void *)SIG_ERR));
   EXPECT_THAT((void *)__llvm_libc::signal(65, valid),
               Fails(EINVAL, (void *)SIG_ERR));
 }
 
 static int sum;

libc/test/src/signal/sigprocmask_test.cpp

 //===-- Unittests for sigprocmask -----------------------------------------===//
 //
 // 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 "include/errno.h"
 #include "include/signal.h"
-#include "src/errno/llvmlibc_errno.h"
+#include "src/errno/libc_errno.h"
 #include "src/signal/raise.h"
 #include "src/signal/sigaddset.h"
 #include "src/signal/sigemptyset.h"
 #include "src/signal/sigprocmask.h"
 
 #include "test/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
 class LlvmLibcSignalTest : public __llvm_libc::testing::Test {
   sigset_t oldSet;
 
 public:
   void SetUp() override { __llvm_libc::sigprocmask(0, nullptr, &oldSet); }
 
   void TearDown() override {
     __llvm_libc::sigprocmask(SIG_SETMASK, &oldSet, nullptr);
   }
 };
 
 using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
 using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
 
 // This tests for invalid input.
 TEST_F(LlvmLibcSignalTest, SigprocmaskInvalid) {
-  llvmlibc_errno = 0;
+  libc_errno = 0;
 
   sigset_t valid;
   // 17 and -4 are out of the range for sigprocmask's how paramater.
   EXPECT_THAT(__llvm_libc::sigprocmask(17, &valid, nullptr), Fails(EINVAL));
   EXPECT_THAT(__llvm_libc::sigprocmask(-4, &valid, nullptr), Fails(EINVAL));
 
   // This pointer is out of this processes address range.
   sigset_t *invalid = reinterpret_cast<sigset_t *>(-1);

libc/test/src/termios/CMakeLists.txt

 add_libc_testsuite(libc_termios_unittests)
 
 add_libc_unittest(
   termios_test
   SUITE
     libc_termios_unittests
   SRCS
     termios_test.cpp
   DEPENDS
-    libc.include.errno
     libc.include.termios
+    libc.src.errno.errno
     libc.src.fcntl.open
     libc.src.termios.cfgetispeed
     libc.src.termios.cfgetospeed
     libc.src.termios.cfsetispeed
     libc.src.termios.cfsetospeed
     libc.src.termios.tcgetattr
     libc.src.termios.tcgetsid
     libc.src.termios.tcsetattr
     libc.src.unistd.close
     libc.test.errno_setter_matcher
 )

libc/test/src/termios/termios_test.cpp

 //===-- Unittests for a bunch of functions in termios.h -------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
+#include "src/errno/libc_errno.h"
 #include "src/fcntl/open.h"
 #include "src/termios/cfgetispeed.h"
 #include "src/termios/cfgetospeed.h"
 #include "src/termios/cfsetispeed.h"
 #include "src/termios/cfsetospeed.h"
 #include "src/termios/tcgetattr.h"
 #include "src/termios/tcgetsid.h"
 #include "src/termios/tcsetattr.h"
 #include "src/unistd/close.h"
 #include "test/ErrnoSetterMatcher.h"
 #include "test/UnitTest/Test.h"
 
-#include <errno.h>
 #include <termios.h>
 
 using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
 using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
 
 // We just list a bunch of smoke tests here as it is not possible to
 // test functionality at the least because we want to run the tests
 // from ninja/make which change the terminal behavior.
 
 TEST(LlvmLibcTermiosTest, SpeedSmokeTest) {
   struct termios t;
-  errno = 0;
+  libc_errno = 0;
   ASSERT_THAT(__llvm_libc::cfsetispeed(&t, B50), Succeeds(0));
   ASSERT_EQ(__llvm_libc::cfgetispeed(&t), speed_t(B50));
   ASSERT_THAT(__llvm_libc::cfsetospeed(&t, B75), Succeeds(0));
   ASSERT_EQ(__llvm_libc::cfgetospeed(&t), speed_t(B75));
 
-  errno = 0;
+  libc_errno = 0;
   ASSERT_THAT(__llvm_libc::cfsetispeed(&t, ~CBAUD), Fails(EINVAL));
-  errno = 0;
+  libc_errno = 0;
   ASSERT_THAT(__llvm_libc::cfsetospeed(&t, ~CBAUD), Fails(EINVAL));
 }
 
 TEST(LlvmLibcTermiosTest, GetAttrSmokeTest) {
   struct termios t;
-  errno = 0;
+  libc_errno = 0;
   int fd = __llvm_libc::open("/dev/tty", O_RDONLY);
   if (fd < 0)
     return; // When /dev/tty is not available, no point continuing.
-  ASSERT_EQ(errno, 0);
+  ASSERT_EQ(libc_errno, 0);
   ASSERT_THAT(__llvm_libc::tcgetattr(fd, &t), Succeeds(0));
   ASSERT_EQ(__llvm_libc::close(fd), 0);
 }
 
 TEST(LlvmLibcTermiosTest, TcGetSidSmokeTest) {
-  errno = 0;
+  libc_errno = 0;
   int fd = __llvm_libc::open("/dev/tty", O_RDONLY);
   if (fd < 0)
     return; // When /dev/tty is not available, no point continuing.
-  ASSERT_EQ(errno, 0);
+  ASSERT_EQ(libc_errno, 0);
   ASSERT_GT(__llvm_libc::tcgetsid(fd), pid_t(0));
   ASSERT_EQ(__llvm_libc::close(fd), 0);
 }