[libc] Use the new style includes

[phosek]

Summary

We should be using the standard includes.

libc/src/pthread/pthread_mutex_init.h

 //===-- Implementation header for pthread_mutex_init function ---*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEX_INIT_H
 #define LLVM_LIBC_SRC_PTHREAD_PTHREAD_MUTEX_INIT_H
 
-#include "include/pthread.h"
+#include <pthread.h>
 
 namespace __llvm_libc {
 
 int pthread_mutex_init(pthread_mutex_t *mutex,
                        const pthread_mutexattr_t *__restrict attr);
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_PTHREAD_pthread_mutex_INIT_H

libc/src/signal/linux/signal_utils.h

 //===-- Internal header for Linux signals -----------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_SIGNAL_LINUX_SIGNAL_UTILS_H
 #define LLVM_LIBC_SRC_SIGNAL_LINUX_SIGNAL_UTILS_H
 
-#include "include/sys/syscall.h"          // For syscall numbers.
 #include "src/__support/OSUtil/syscall.h" // For internal syscall function.
 #include "src/__support/common.h"
 
 #include <signal.h>
 #include <stddef.h>
+#include <sys/syscall.h>          // For syscall numbers.
 
 namespace __llvm_libc {
 
 // The POSIX definition of struct sigaction and the sigaction data structure
 // expected by the rt_sigaction syscall differ in their definition. So, we
 // define the equivalent of the what the kernel expects to help with making
 // the rt_sigaction syscall.
 //

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 <signal.h>
+#include <sys/syscall.h> // For syscall numbers.
 
 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;
 
   libc_errno = -ret;
   return -1;
 }
 
 } // namespace __llvm_libc

libc/src/signal/raise.h

 //===-- Implementation header for raise function ----------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_SIGNAL_RAISE_H
 #define LLVM_LIBC_SRC_SIGNAL_RAISE_H
 
-#include "include/signal.h"
+#include <signal.h>
 
 namespace __llvm_libc {
 
 int raise(int sig);
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SIGNAL_RAISE_H

libc/src/signal/sigdelset.h

 //===-- Implementation header for sigdelset ---------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_SIGNAL_SIGDELSET_H
 #define LLVM_LIBC_SRC_SIGNAL_SIGDELSET_H
 
-#include "include/signal.h"
+#include <signal.h>
 
 namespace __llvm_libc {
 
 int sigdelset(sigset_t *set, int signum);
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SIGNAL_SIGDELSET_H

libc/src/signal/sigemptyset.h

 //===-- Implementation header for sigemptyset -------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_SIGNAL_SIGEMPTYSET_H
 #define LLVM_LIBC_SRC_SIGNAL_SIGEMPTYSET_H
 
-#include "include/signal.h"
+#include <signal.h>
 
 namespace __llvm_libc {
 
 int sigemptyset(sigset_t *set);
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SIGNAL_SIGEMPTYSET_H

libc/src/signal/sigfillset.h

 //===-- Implementation header for sigfillset --------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_SIGNAL_SIGFILLSET_H
 #define LLVM_LIBC_SRC_SIGNAL_SIGFILLSET_H
 
-#include "include/signal.h"
+#include <signal.h>
 
 namespace __llvm_libc {
 
 int sigfillset(sigset_t *set);
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SIGNAL_SIGFILLSET_H

libc/src/signal/signal.h

 //===-- Implementation header for signal ------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_SIGNAL_SIGNAL_H
 #define LLVM_LIBC_SRC_SIGNAL_SIGNAL_H
 
-#include "include/signal.h"
+#include <signal.h>
 
 namespace __llvm_libc {
 
 using sighandler_t = __sighandler_t;
 
 sighandler_t signal(int signum, sighandler_t handler);
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SIGNAL_SIGNAL_H

libc/src/signal/sigprocmask.h

 //===-- Implementation header for sigprocmask -------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_SIGNAL_SIGPROCMASK_H
 #define LLVM_LIBC_SRC_SIGNAL_SIGPROCMASK_H
 
-#include "include/signal.h"
+#include <signal.h>
 
 namespace __llvm_libc {
 
 int sigprocmask(int how, const sigset_t *__restrict set,
                 sigset_t *__restrict oldset);
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SIGNAL_SIGPROCMASK_H

libc/src/threads/cnd_broadcast.h

 //===-- Implementation header for cnd_broadcast function --------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_THREADS_CND_BROADCAST_H
 #define LLVM_LIBC_SRC_THREADS_CND_BROADCAST_H
 
-#include "include/threads.h"
+#include <threads.h>
 
 namespace __llvm_libc {
 
 int cnd_broadcast(cnd_t *cond);
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_THREADS_CND_BROADCAST_H

libc/src/threads/cnd_destroy.h

 //===-- Implementation header for cnd_destroy function ----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_THREADS_CND_DESTROY_H
 #define LLVM_LIBC_SRC_THREADS_CND_DESTROY_H
 
-#include "include/threads.h"
+#include <threads.h>
 
 namespace __llvm_libc {
 
 void cnd_destroy(cnd_t *cond);
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_THREADS_CND_DESTROY_H

libc/src/threads/cnd_init.h

 //===-- Implementation header for cnd_init function -------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_THREADS_CND_INIT_H
 #define LLVM_LIBC_SRC_THREADS_CND_INIT_H
 
-#include "include/threads.h"
+#include <threads.h>
 
 namespace __llvm_libc {
 
 int cnd_init(cnd_t *cond);
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_THREADS_CND_INIT_H

libc/src/threads/cnd_signal.h

 //===-- Implementation header for cnd_signal function -----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_THREADS_CND_SIGNAL_H
 #define LLVM_LIBC_SRC_THREADS_CND_SIGNAL_H
 
-#include "include/threads.h"
+#include <threads.h>
 
 namespace __llvm_libc {
 
 int cnd_signal(cnd_t *cond);
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_THREADS_CND_SIGNAL_H

libc/src/threads/cnd_wait.h

 //===-- Implementation header for cnd_wait function -------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_THREADS_CND_WAIT_H
 #define LLVM_LIBC_SRC_THREADS_CND_WAIT_H
 
-#include "include/threads.h"
+#include <threads.h>
 
 namespace __llvm_libc {
 
 int cnd_wait(cnd_t *cond, mtx_t *mutex);
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_THREADS_CND_WAIT_H

libc/src/threads/linux/CndVar.h

 //===-- Utility condition variable class ------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_THREADS_LINUX_CNDVAR_H
 #define LLVM_LIBC_SRC_THREADS_LINUX_CNDVAR_H
 
-#include "include/sys/syscall.h" // For syscall numbers.
-#include "include/threads.h"     // For values like thrd_success etc.
 #include "src/__support/CPP/atomic.h"
 #include "src/__support/OSUtil/syscall.h" // For syscall functions.
 #include "src/__support/threads/linux/futex_word.h"
 #include "src/__support/threads/mutex.h"
 
 #include <linux/futex.h> // For futex operations.
 #include <stdint.h>
+#include <sys/syscall.h> // For syscall numbers.
+#include <threads.h>     // For values like thrd_success etc.
 
 namespace __llvm_libc {
 
 struct CndVar {
   enum CndWaiterStatus : uint32_t {
     WS_Waiting = 0xE,
     WS_Signalled = 0x5,
   };

libc/src/threads/mtx_destroy.h

 //===-- Implementation header for mtx_destroy function ----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_THREADS_MTX_DESTROY_H
 #define LLVM_LIBC_SRC_THREADS_MTX_DESTROY_H
 
-#include "include/threads.h"
+#include <threads.h>
 
 namespace __llvm_libc {
 
 void mtx_destroy(mtx_t *mutex);
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_THREADS_MTX_DESTROY_H

libc/src/threads/mtx_destroy.cpp

 //===-- Linux implementation of the mtx_destroy function ------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/threads/mtx_destroy.h"
-#include "include/threads.h" // For mtx_t definition.
 #include "src/__support/common.h"
 #include "src/__support/threads/mutex.h"
 
+#include <threads.h> // For mtx_t definition.
+
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(void, mtx_destroy, (mtx_t *)) {}
 
 } // namespace __llvm_libc

libc/src/threads/mtx_init.h

 //===-- Implementation header for mtx_init function -------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_THREADS_MTX_INIT_H
 #define LLVM_LIBC_SRC_THREADS_MTX_INIT_H
 
-#include "include/threads.h"
+#include <threads.h>
 
 namespace __llvm_libc {
 
 int mtx_init(mtx_t *mutex, int type);
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_THREADS_MTX_INIT_H

libc/src/threads/mtx_init.cpp

 //===-- Linux implementation of the mtx_init function ---------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/threads/mtx_init.h"
-#include "include/threads.h" // For mtx_t definition.
 #include "src/__support/common.h"
 #include "src/__support/threads/mutex.h"
 
+#include <threads.h> // For mtx_t definition.
+
 namespace __llvm_libc {
 
 static_assert(sizeof(Mutex) <= sizeof(mtx_t),
               "The public mtx_t type cannot accommodate the internal mutex "
               "type.");
 
 LLVM_LIBC_FUNCTION(int, mtx_init, (mtx_t * m, int type)) {
   auto err = Mutex::init(reinterpret_cast<Mutex *>(m), type & mtx_timed,
                          type & mtx_recursive, 0);
   return err == MutexError::NONE ? thrd_success : thrd_error;
 }
 
 } // namespace __llvm_libc

libc/src/threads/mtx_lock.h

 //===-- Implementation header for mtx_lock function -------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_THREADS_MTX_LOCK_H
 #define LLVM_LIBC_SRC_THREADS_MTX_LOCK_H
 
-#include "include/threads.h"
+#include <threads.h>
 
 namespace __llvm_libc {
 
 int mtx_lock(mtx_t *mutex);
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_THREADS_MTX_LOCK_H

libc/src/threads/mtx_lock.cpp

 //===-- Linux implementation of the mtx_lock function ---------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/threads/mtx_lock.h"
-#include "include/threads.h" // For mtx_t definition.
 #include "src/__support/common.h"
 #include "src/__support/threads/mutex.h"
 
+#include <threads.h> // For mtx_t definition.
+
 namespace __llvm_libc {
 
 // The implementation currently handles only plain mutexes.
 LLVM_LIBC_FUNCTION(int, mtx_lock, (mtx_t * mutex)) {
   auto *m = reinterpret_cast<Mutex *>(mutex);
   auto err = m->lock();
   return err == MutexError::NONE ? thrd_success : thrd_error;
 }
 
 } // namespace __llvm_libc

libc/src/threads/mtx_unlock.h

 //===-- Implementation header for mtx_unlock function -----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_THREADS_MTX_UNLOCK_H
 #define LLVM_LIBC_SRC_THREADS_MTX_UNLOCK_H
 
-#include "include/threads.h"
+#include <threads.h>
 
 namespace __llvm_libc {
 
 int mtx_unlock(mtx_t *mutex);
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_THREADS_MTX_UNLOCK_H

libc/src/threads/mtx_unlock.cpp

 //===-- Linux implementation of the mtx_unlock function -------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/threads/mtx_unlock.h"
-#include "include/threads.h" // For mtx_t definition.
 #include "src/__support/common.h"
 #include "src/__support/threads/mutex.h"
 
+#include <threads.h> // For mtx_t definition.
+
 namespace __llvm_libc {
 
 // The implementation currently handles only plain mutexes.
 LLVM_LIBC_FUNCTION(int, mtx_unlock, (mtx_t * mutex)) {
   auto *m = reinterpret_cast<Mutex *>(mutex);
   auto err = m->unlock();
   return err == MutexError::NONE ? thrd_success : thrd_error;
 }
 
 } // namespace __llvm_libc

libc/src/threads/thrd_current.h

 //===-- Implementation header for thrd_current function ---------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_THREADS_THRD_CURRENT_H
 #define LLVM_LIBC_SRC_THREADS_THRD_CURRENT_H
 
-#include "include/threads.h"
+#include <threads.h>
 
 namespace __llvm_libc {
 
 thrd_t thrd_current();
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_THREADS_THRD_CURRENT_H

libc/src/threads/thrd_detach.h

 //===-- Implementation header for thrd_detach function ----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_THREADS_THRD_DETACH_H
 #define LLVM_LIBC_SRC_THREADS_THRD_DETACH_H
 
-#include "include/threads.h"
+#include <threads.h>
 
 namespace __llvm_libc {
 
 int thrd_detach(thrd_t thread);
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_THREADS_THRD_DETACH_H

libc/src/threads/thrd_equal.h

 //===-- Implementation header for thrd_equal function -----------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_THREADS_THRD_EQUAL_H
 #define LLVM_LIBC_SRC_THREADS_THRD_EQUAL_H
 
-#include "include/threads.h"
+#include <threads.h>
 
 namespace __llvm_libc {
 
 int thrd_equal(thrd_t lhs, thrd_t rhs);
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_THREADS_THRD_EQUAL_H

libc/src/threads/thrd_exit.h

 //===-- Implementation header for thrd_exit function ------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_THREADS_THRD_EXIT_H
 #define LLVM_LIBC_SRC_THREADS_THRD_EXIT_H
 
-#include "include/threads.h"
+#include <threads.h>
 
 namespace __llvm_libc {
 
 void thrd_exit(int retval);
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_THREADS_THRD_EXIT_H

libc/src/threads/thrd_join.h

 //===-- Implementation header for thrd_join function ------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBC_SRC_THREADS_THRD_JOIN_H
 #define LLVM_LIBC_SRC_THREADS_THRD_JOIN_H
 
-#include "include/threads.h"
+#include <threads.h>
 
 namespace __llvm_libc {
 
 int thrd_join(thrd_t thread, int *retval);
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_THREADS_THRD_JOIN_H

libc/src/time/nanosleep.cpp

 //===-- Implementation of nanosleep function ------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/time/nanosleep.h"
 
-#include "include/sys/syscall.h"          // For syscall numbers.
 #include "src/__support/OSUtil/syscall.h" // For syscall functions.
 #include "src/__support/common.h"
 #include "src/errno/libc_errno.h"
 
+#include <sys/syscall.h> // For syscall numbers.
+
 namespace __llvm_libc {
 
 // TODO(michaelrj): Move this into time/linux with the other syscalls.
 LLVM_LIBC_FUNCTION(int, nanosleep,
                    (const struct timespec *req, struct timespec *rem)) {
   int ret = __llvm_libc::syscall_impl(SYS_nanosleep, req, rem);
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return ret;
 }
 
 } // namespace __llvm_libc