[libc][cleanup] Fix most conversion warnings

[michaelrj]

Summary

This patch is large, but is almost entirely just adding casts to calls
to syscall_impl. Much of the work was done programatically, with human
checking when the syntax or types got confusing.

[mcgrathr]

https://godbolt.org/z/G5MMexh38 demonstrates another approach that might reduce the boilerplate here.

[michaelrj]

nightmare rebase

[michaelrj]

move to templated syscall_impl

[mcgrathr]

lgtm with a couple nits

libc/src/__support/CPP/bit.h

54

missing LIBC_INLINE

libc/src/__support/OSUtil/linux/syscall.h

28–29

I'm not familiar with a style that uses all-caps for template parameters that aren't single letters.

[michaelrj]

address comments, fix vfprintf_internal

libc/src/__support/CPP/bit.h

 #else
   for (unsigned i = 0; i < sizeof(To); ++i)
     dst[i] = src[i];
 #endif // defined(LLVM_LIBC_HAS_BUILTIN_MEMCPY_INLINE)
   return to;
 #endif // defined(LLVM_LIBC_HAS_BUILTIN_BIT_CAST)
 }
 
+template <class To, class From>
+LIBC_INLINE constexpr To bit_or_static_cast(const From &from) {
+  if constexpr (sizeof(To) == sizeof(From)) {
+    return bit_cast<To>(from);
+  } else {
+    return static_cast<To>(from);
+  }
+}
+
 } // namespace __llvm_libc::cpp
 
 #endif // LLVM_LIBC_SUPPORT_CPP_BIT_H

libc/src/__support/File/linux/dir.cpp

 #include <fcntl.h>       // For open flags
 #include <sys/syscall.h> // For syscall numbers
 
 namespace __llvm_libc {
 
 ErrorOr<int> platform_opendir(const char *name) {
   int open_flags = O_RDONLY | O_DIRECTORY | O_CLOEXEC;
 #ifdef SYS_open
-  int fd = __llvm_libc::syscall_impl(SYS_open, name, open_flags);
+  int fd = __llvm_libc::syscall_impl<int>(SYS_open, name, open_flags);
 #elif defined(SYS_openat)
-  int fd = __llvm_libc::syscall_impl(SYS_openat, AT_FDCWD, name, open_flags);
+  int fd =
+      __llvm_libc::syscall_impl<int>(SYS_openat, AT_FDCWD, name, open_flags);
 #else
 #error                                                                         \
     "SYS_open and SYS_openat syscalls not available to perform an open operation."
 #endif
 
   if (fd < 0) {
     return __llvm_libc::Error(-fd);
   }
   return fd;
 }
 
 ErrorOr<size_t> platform_fetch_dirents(int fd, cpp::span<uint8_t> buffer) {
 #ifdef SYS_getdents64
-  long size = __llvm_libc::syscall_impl(SYS_getdents64, fd, buffer.data(),
+  long size = __llvm_libc::syscall_impl<long>(SYS_getdents64, fd, buffer.data(),
                                               buffer.size());
 #else
 #error "getdents64 syscalls not available to perform a fetch dirents operation."
 #endif
 
   if (size < 0) {
     return __llvm_libc::Error(static_cast<int>(-size));
   }
   return size;
 }
 
 int platform_closedir(int fd) {
-  long ret = __llvm_libc::syscall_impl(SYS_close, fd);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_close, fd);
   if (ret < 0) {
     return static_cast<int>(-ret);
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/__support/File/linux/file.cpp

public:
 
   int get_fd() const { return fd; }
 };
 
 namespace {
 
 FileIOResult write_func(File *f, const void *data, size_t size) {
   auto *lf = reinterpret_cast<LinuxFile *>(f);
-  int ret = __llvm_libc::syscall_impl(SYS_write, lf->get_fd(), data, size);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_write, lf->get_fd(), data, size);
   if (ret < 0) {
     return {0, -ret};
   }
   return ret;
 }
 
 FileIOResult read_func(File *f, void *buf, size_t size) {
   auto *lf = reinterpret_cast<LinuxFile *>(f);
-  int ret = __llvm_libc::syscall_impl(SYS_read, lf->get_fd(), buf, size);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_read, lf->get_fd(), buf, size);
   if (ret < 0) {
     return {0, -ret};
   }
   return ret;
 }
 
 ErrorOr<long> seek_func(File *f, long offset, int whence) {
   auto *lf = reinterpret_cast<LinuxFile *>(f);
   long result;
 #ifdef SYS_lseek
-  int ret = __llvm_libc::syscall_impl(SYS_lseek, lf->get_fd(), offset, whence);
+  int ret =
+      __llvm_libc::syscall_impl<int>(SYS_lseek, lf->get_fd(), offset, whence);
   result = ret;
 #elif defined(SYS_llseek)
-  int ret = __llvm_libc::syscall_impl(SYS_llseek, lf->get_fd(),
+  int ret = __llvm_libc::syscall_impl<int>(SYS_llseek, lf->get_fd(),
+                                           (long)(((uint64_t)(offset)) >> 32),
+                                           (long)offset, &result, whence);
+  result = ret;
+#elif defined(SYS_llseek)
+  int ret = __llvm_libc::syscall_impl<int>(SYS_llseek, lf->get_fd(),
                                            (long)(((uint64_t)(offset)) >> 32),
                                            (long)offset, &result, whence);
   result = ret;
 #elif defined(SYS__llseek)
-  int ret = __llvm_libc::syscall_impl(SYS__llseek, lf->get_fd(), offset >> 32,
-                                      offset, &result, whence);
+  int ret = __llvm_libc::syscall_impl<int>(
+      SYS__llseek, lf->get_fd(), offset >> 32, offset, &result, whence);
 #else
 #error "lseek, llseek and _llseek syscalls not available."
 #endif
 
   if (ret < 0)
     return Error(-ret);
 
   return result;
 }
 
 int close_func(File *f) {
   auto *lf = reinterpret_cast<LinuxFile *>(f);
-  int ret = __llvm_libc::syscall_impl(SYS_close, lf->get_fd());
+  int ret = __llvm_libc::syscall_impl<int>(SYS_close, lf->get_fd());
   if (ret < 0) {
     return -ret;
   }
   delete lf;
   return 0;
 }
 
 } // anonymous namespace
else
       open_flags |= O_RDONLY;
   }
 
   // File created will have 0666 permissions.
   constexpr long OPEN_MODE =
       S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
 
 #ifdef SYS_open
-  int fd = __llvm_libc::syscall_impl(SYS_open, path, open_flags, OPEN_MODE);
+  int fd =
+      __llvm_libc::syscall_impl<int>(SYS_open, path, open_flags, OPEN_MODE);
 #elif defined(SYS_openat)
-  int fd = __llvm_libc::syscall_impl(SYS_openat, AT_FDCWD, path, open_flags,
-                                     OPEN_MODE);
+  int fd = __llvm_libc::syscall_impl<int>(SYS_openat, AT_FDCWD, path,
+                                          open_flags, OPEN_MODE);
 #else
 #error "open and openat syscalls not available."
 #endif
 
   if (fd < 0)
     return Error(-fd);
 
   uint8_t *buffer;

libc/src/__support/OSUtil/darwin/quick_exit.h

 #include "syscall.h" // For internal syscall function.
 
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 
 LIBC_INLINE void quick_exit(int status) {
   for (;;) {
-    __llvm_libc::syscall_impl(1 /* SYS_exit */, status);
+    __llvm_libc::syscall_impl<long>(1 /* SYS_exit */, status);
   }
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_OSUTIL_DARWIN_QUICK_EXIT_H

libc/src/__support/OSUtil/darwin/syscall.h

 //===---------------------- Darwin syscalls ---------------------*- 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_SUPPORT_OSUTIL_DARWIN_SYSCALL_H
 #define LLVM_LIBC_SRC_SUPPORT_OSUTIL_DARWIN_SYSCALL_H
 
+#include "src/__support/CPP/bit.h"
 #include "src/__support/common.h"
 #include "src/__support/macros/properties/architectures.h"
 
 #ifdef LIBC_TARGET_ARCH_IS_ANY_ARM
 #include "arm/syscall.h"
 #else
 #error "Unsupported architecture"
 #endif
 
 namespace __llvm_libc {
 
-template <typename... Ts>
-LIBC_INLINE long syscall_impl(long __number, Ts... ts) {
+template <typename R, typename... Ts>
+LIBC_INLINE R syscall_impl(long __number, Ts... ts) {
   static_assert(sizeof...(Ts) <= 6, "Too many arguments for syscall");
-  return syscall_impl(__number, (long)ts...);
+  return cpp::bit_or_static_cast<R>(syscall_impl(__number, (long)ts...));
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_OSUTIL_DARWIN_SYSCALL_H

libc/src/__support/OSUtil/linux/io.h

 #include "src/__support/CPP/string_view.h"
 #include "syscall.h" // For internal syscall function.
 
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LIBC_INLINE void write_to_stderr(cpp::string_view msg) {
-  __llvm_libc::syscall_impl(SYS_write, 2 /* stderr */, msg.data(), msg.size());
+  __llvm_libc::syscall_impl<long>(SYS_write, 2 /* stderr */, msg.data(),
+                                  msg.size());
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_OSUTIL_LINUX_IO_H

libc/src/__support/OSUtil/linux/quick_exit.h

 #include "src/__support/common.h"
 
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LIBC_INLINE void quick_exit(int status) {
   for (;;) {
-    __llvm_libc::syscall_impl(SYS_exit_group, status);
-    __llvm_libc::syscall_impl(SYS_exit, status);
+    __llvm_libc::syscall_impl<long>(SYS_exit_group, status);
+    __llvm_libc::syscall_impl<long>(SYS_exit, status);
   }
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_OSUTIL_LINUX_QUICK_EXIT_H

libc/src/__support/OSUtil/linux/syscall.h

 //===----------------------- Linux syscalls ---------------------*- 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_SUPPORT_OSUTIL_LINUX_SYSCALL_H
 #define LLVM_LIBC_SRC_SUPPORT_OSUTIL_LINUX_SYSCALL_H
 
+#include "src/__support/CPP/bit.h"
 #include "src/__support/common.h"
 #include "src/__support/macros/properties/architectures.h"
 
 #ifdef LIBC_TARGET_ARCH_IS_X86_64
 #include "x86_64/syscall.h"
 #elif defined(LIBC_TARGET_ARCH_IS_AARCH64)
 #include "aarch64/syscall.h"
 #elif defined(LIBC_TARGET_ARCH_IS_ARM)
 #include "arm/syscall.h"
 #elif defined(LIBC_TARGET_ARCH_IS_RISCV64)
 #include "riscv64/syscall.h"
 #endif
 
 namespace __llvm_libc {
 
-template <typename... Ts>
-LIBC_INLINE long syscall_impl(long __number, Ts... ts) {
+template <typename R, typename... Ts>
+LIBC_INLINE R syscall_impl(long __number, Ts... ts) {
   static_assert(sizeof...(Ts) <= 6, "Too many arguments for syscall");
-  return syscall_impl(__number, (long)ts...);
+  return cpp::bit_or_static_cast<R>(syscall_impl(__number, (long)ts...));
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_OSUTIL_LINUX_SYSCALL_H

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

int callonce(CallOnceFlag *flag, CallOnceCallback *func) {
   FutexWordType not_called = NOT_CALLED;
 
   // The call_once call can return only after the called function |func|
   // returns. So, we use futexes to synchronize calls with the same flag value.
   if (futex_word->compare_exchange_strong(not_called, START)) {
     func();
     auto status = futex_word->exchange(FINISH);
     if (status == WAITING) {
-      __llvm_libc::syscall_impl(FUTEX_SYSCALL_ID, &futex_word->val,
+      __llvm_libc::syscall_impl<long>(FUTEX_SYSCALL_ID, &futex_word->val,
                                       FUTEX_WAKE_PRIVATE,
                                       INT_MAX, // Wake all waiters.
                                       0, 0, 0);
     }
     return 0;
   }
 
   FutexWordType status = START;
   if (futex_word->compare_exchange_strong(status, WAITING) ||
       status == WAITING) {
-    __llvm_libc::syscall_impl(
+    __llvm_libc::syscall_impl<long>(
         FUTEX_SYSCALL_ID, &futex_word->val, FUTEX_WAIT_PRIVATE,
         WAITING, // Block only if status is still |WAITING|.
         0, 0, 0);
   }
 
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/__support/threads/linux/mutex.h

while (true) {
       }
 
       switch (LockState(mutex_status)) {
       case LockState::Waiting:
         // If other threads are waiting already, then join them. Note that the
         // futex syscall will block if the futex data is still
         // `LockState::Waiting` (the 4th argument to the syscall function
         // below.)
-        __llvm_libc::syscall_impl(FUTEX_SYSCALL_ID, &futex_word.val,
-                                  FUTEX_WAIT_PRIVATE,
-                                  FutexWordType(LockState::Waiting), 0, 0, 0);
+        __llvm_libc::syscall_impl<long>(
+            FUTEX_SYSCALL_ID, &futex_word.val, FUTEX_WAIT_PRIVATE,
         was_waiting = true;
         // Once woken up/unblocked, try everything all over.
         continue;
       case LockState::Locked:
         // Mutex has been locked by another thread so set the status to
         // LockState::Waiting.
         if (futex_word.compare_exchange_strong(
                 locked_status, FutexWordType(LockState::Waiting))) {
           // If we are able to set the futex data to `LockState::Waiting`, then
           // we will wait for the futex to be woken up. Note again that the
           // following syscall will block only if the futex data is still
           // `LockState::Waiting`.
-          __llvm_libc::syscall_impl(FUTEX_SYSCALL_ID, &futex_word,
-                                    FUTEX_WAIT_PRIVATE,
-                                    FutexWordType(LockState::Waiting), 0, 0, 0);
+          __llvm_libc::syscall_impl<long>(
+              FUTEX_SYSCALL_ID, &futex_word, FUTEX_WAIT_PRIVATE,
           was_waiting = true;
         }
         continue;
       case LockState::Free:
         // If it was LockState::Free, we shouldn't be here at all.
         return MutexError::BAD_LOCK_STATE;
       }
     }
   }
 
   MutexError unlock() {
     while (true) {
       FutexWordType mutex_status = FutexWordType(LockState::Waiting);
       if (futex_word.compare_exchange_strong(mutex_status,
                                              FutexWordType(LockState::Free))) {
         // If any thread is waiting to be woken up, then do it.
-        __llvm_libc::syscall_impl(FUTEX_SYSCALL_ID, &futex_word,
+        __llvm_libc::syscall_impl<long>(FUTEX_SYSCALL_ID, &futex_word,
                                         FUTEX_WAKE_PRIVATE, 1, 0, 0, 0);
         return MutexError::NONE;
       }
 
       if (mutex_status == FutexWordType(LockState::Locked)) {
         // If nobody was waiting at this point, just free it.
         if (futex_word.compare_exchange_strong(mutex_status,
                                                FutexWordType(LockState::Free)))
           return MutexError::NONE;

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

LIBC_INLINE ErrorOr<void *> alloc_stack(size_t stacksize, size_t guardsize) {
   int prot = guardsize ? PROT_NONE : PROT_READ | PROT_WRITE;
   auto size_or_err = add_no_overflow(stacksize, guardsize);
   if (!size_or_err)
     return Error{int(size_or_err.error())};
   size_t size = size_or_err.value();
 
   // TODO: Maybe add MAP_STACK? Currently unimplemented on linux but helps
   // future-proof.
-  long mmap_result =
-      __llvm_libc::syscall_impl(MMAP_SYSCALL_NUMBER,
-                                0, // No special address
-                                size, prot,
-                                MAP_ANONYMOUS | MAP_PRIVATE, // Process private.
-                                -1, // Not backed by any file
-                                0   // No offset
-      );
+  long mmap_result = __llvm_libc::syscall_impl<long>(
+      MMAP_SYSCALL_NUMBER,
+      -1,                          // Not backed by any file
+      0                            // No offset
   if (mmap_result < 0 && (uintptr_t(mmap_result) >= UINTPTR_MAX - size))
     return Error{int(-mmap_result)};
 
   if (guardsize) {
     // Give read/write permissions to actual stack.
     // TODO: We are assuming stack growsdown here.
     long result =
-        __llvm_libc::syscall_impl(SYS_mprotect, mmap_result + guardsize,
+        __llvm_libc::syscall_impl<long>(SYS_mprotect, mmap_result + guardsize,
                                         stacksize, PROT_READ | PROT_WRITE);
 
     if (result != 0)
       return Error{int(-result)};
   }
   mmap_result += guardsize;
   return reinterpret_cast<void *>(mmap_result);
 }
 
 // This must always be inlined as we may be freeing the calling threads stack in
 // which case a normal return from the top the stack would cause an invalid
 // memory read.
 [[gnu::always_inline]] LIBC_INLINE void
 free_stack(void *stack, size_t stacksize, size_t guardsize) {
   uintptr_t stackaddr = reinterpret_cast<uintptr_t>(stack);
   stackaddr -= guardsize;
   stack = reinterpret_cast<void *>(stackaddr);
-  __llvm_libc::syscall_impl(SYS_munmap, stack, stacksize + guardsize);
+  __llvm_libc::syscall_impl<long>(SYS_munmap, stack, stacksize + guardsize);
 }
 
 struct Thread;
 
 // We align the start args to 16-byte boundary as we adjust the allocated
 // stack memory with its size. We want the adjusted address to be at a
 // 16-byte boundary to satisfy the x86_64 and aarch64 ABI requirements.
 // If different architecture in future requires higher alignment, then we
int Thread::run(ThreadStyle style, ThreadRunner runner, void *arg, void *stack,
   attrib->platform_data = clear_tid;
 
   // The clone syscall takes arguments in an architecture specific order.
   // Also, we want the result of the syscall to be in a register as the child
   // thread gets a completely different stack after it is created. The stack
   // variables from this function will not be availalbe to the child thread.
 #if defined(LIBC_TARGET_ARCH_IS_X86_64)
   long register clone_result asm(CLONE_RESULT_REGISTER);
-  clone_result = __llvm_libc::syscall_impl(
+  clone_result = __llvm_libc::syscall_impl<long>(
       SYS_clone, CLONE_SYSCALL_FLAGS, adjusted_stack,
       &attrib->tid,    // The address where the child tid is written
       &clear_tid->val, // The futex where the child thread status is signalled
       tls.tp           // The thread pointer value for the new thread.
   );
 #elif defined(LIBC_TARGET_ARCH_IS_AARCH64) ||                                  \
     defined(LIBC_TARGET_ARCH_IS_RISCV64)
   long register clone_result asm(CLONE_RESULT_REGISTER);
-  clone_result = __llvm_libc::syscall_impl(
+  clone_result = __llvm_libc::syscall_impl<long>(
       SYS_clone, CLONE_SYSCALL_FLAGS, adjusted_stack,
       &attrib->tid,   // The address where the child tid is written
       tls.tp,         // The thread pointer value for the new thread.
       &clear_tid->val // The futex where the child thread status is signalled
   );
 #else
 #error "Unsupported architecture for the clone syscall."
 #endif
#else
     asm volatile("mov x29, sp");
 #endif
 #elif defined(LIBC_TARGET_ARCH_IS_ANY_RISCV)
     asm volatile("mv fp, sp");
 #endif
     start_thread();
   } else if (clone_result < 0) {
     cleanup_thread_resources(attrib);
-    return -clone_result;
+    return static_cast<int>(-clone_result);
   }
 
   return 0;
 }
 
 int Thread::join(ThreadReturnValue &retval) {
   wait();
 
void Thread::wait() {
   // The kernel should set the value at the clear tid address to zero.
   // If not, it is a spurious wake and we should continue to wait on
   // the futex.
   auto *clear_tid =
       reinterpret_cast<cpp::Atomic<FutexWordType> *>(attrib->platform_data);
   while (clear_tid->load() != 0) {
     // We cannot do a FUTEX_WAIT_PRIVATE here as the kernel does a
     // FUTEX_WAKE and not a FUTEX_WAKE_PRIVATE.
-    __llvm_libc::syscall_impl(FUTEX_SYSCALL_ID, &clear_tid->val, FUTEX_WAIT,
-                              CLEAR_TID_VALUE, nullptr);
+    __llvm_libc::syscall_impl<long>(FUTEX_SYSCALL_ID, &clear_tid->val,
+                                    FUTEX_WAIT, CLEAR_TID_VALUE, nullptr);
   }
 }
 
 bool Thread::operator==(const Thread &thread) const {
   return attrib->tid == thread.attrib->tid;
 }
 
 static constexpr cpp::string_view THREAD_NAME_PATH_PREFIX("/proc/self/task/");

 
 int Thread::set_name(const cpp::string_view &name) {
   if (name.size() >= NAME_SIZE_MAX)
     return ERANGE;
 
   if (*this == self) {
     // If we are setting the name of the current thread, then we can
     // use the syscall to set the name.
-    int retval = __llvm_libc::syscall_impl(SYS_prctl, PR_SET_NAME, name.data());
+    int retval =
+        __llvm_libc::syscall_impl<int>(SYS_prctl, PR_SET_NAME, name.data());
     if (retval < 0)
       return -retval;
     else
       return 0;
   }
 
   char path_name_buffer[THREAD_NAME_PATH_SIZE];
   cpp::StringStream path_stream(path_name_buffer);
   construct_thread_name_file_path(path_stream, attrib->tid);
 #ifdef SYS_open
-  int fd = __llvm_libc::syscall_impl(SYS_open, path_name_buffer, O_RDWR);
+  int fd = __llvm_libc::syscall_impl<int>(SYS_open, path_name_buffer, O_RDWR);
 #else
-  int fd =
-      __llvm_libc::syscall_impl(SYS_openat, AT_FDCWD, path_name_buffer, O_RDWR);
+  int fd = __llvm_libc::syscall_impl<int>(SYS_openat, AT_FDCWD,
+                                          path_name_buffer, O_RDWR);
 #endif
   if (fd < 0)
     return -fd;
 
   int retval =
-      __llvm_libc::syscall_impl(SYS_write, fd, name.data(), name.size());
-  __llvm_libc::syscall_impl(SYS_close, fd);
+      __llvm_libc::syscall_impl<int>(SYS_write, fd, name.data(), name.size());
+  __llvm_libc::syscall_impl<long>(SYS_close, fd);
 
   if (retval < 0)
     return -retval;
   else if (retval != int(name.size()))
     return EIO;
   else
     return 0;
 }
 
 int Thread::get_name(cpp::StringStream &name) const {
   if (name.bufsize() < NAME_SIZE_MAX)
     return ERANGE;
 
   char name_buffer[NAME_SIZE_MAX];
 
   if (*this == self) {
     // If we are getting the name of the current thread, then we can
     // use the syscall to get the name.
-    int retval = __llvm_libc::syscall_impl(SYS_prctl, PR_GET_NAME, name_buffer);
+    int retval =
+        __llvm_libc::syscall_impl<int>(SYS_prctl, PR_GET_NAME, name_buffer);
     if (retval < 0)
       return -retval;
     name << name_buffer << cpp::StringStream::ENDS;
     return 0;
   }
 
   char path_name_buffer[THREAD_NAME_PATH_SIZE];
   cpp::StringStream path_stream(path_name_buffer);
   construct_thread_name_file_path(path_stream, attrib->tid);
 #ifdef SYS_open
-  int fd = __llvm_libc::syscall_impl(SYS_open, path_name_buffer, O_RDONLY);
+  int fd = __llvm_libc::syscall_impl<int>(SYS_open, path_name_buffer, O_RDONLY);
 #else
-  int fd = __llvm_libc::syscall_impl(SYS_openat, AT_FDCWD, path_name_buffer,
-                                     O_RDONLY);
+  int fd = __llvm_libc::syscall_impl<int>(SYS_openat, AT_FDCWD,
+                                          path_name_buffer, O_RDONLY);
 #endif
   if (fd < 0)
     return -fd;
 
   int retval =
-      __llvm_libc::syscall_impl(SYS_read, fd, name_buffer, NAME_SIZE_MAX);
-  __llvm_libc::syscall_impl(SYS_close, fd);
+      __llvm_libc::syscall_impl<int>(SYS_read, fd, name_buffer, NAME_SIZE_MAX);
+  __llvm_libc::syscall_impl<long>(SYS_close, fd);
   if (retval < 0)
     return -retval;
   if (retval == NAME_SIZE_MAX)
     return ERANGE;
   if (name_buffer[retval - 1] == '\n')
     name_buffer[retval - 1] = '\0';
   else
     name_buffer[retval] = '\0';
void thread_exit(ThreadReturnValue retval, ThreadStyle style) {
   uint32_t joinable_state = uint32_t(DetachState::JOINABLE);
   if (!attrib->detach_state.compare_exchange_strong(
           joinable_state, uint32_t(DetachState::EXITING))) {
     // Thread is detached so cleanup the resources.
     cleanup_thread_resources(attrib);
 
     // Set the CLEAR_TID address to nullptr to prevent the kernel
     // from signalling at a non-existent futex location.
-    __llvm_libc::syscall_impl(SYS_set_tid_address, 0);
+    __llvm_libc::syscall_impl<long>(SYS_set_tid_address, 0);
     // Return value for detached thread should be unused. We need to avoid
     // referencing `style` or `retval.*` because they may be stored on the stack
     // and we have deallocated our stack!
-    __llvm_libc::syscall_impl(SYS_exit, 0);
+    __llvm_libc::syscall_impl<long>(SYS_exit, 0);
     __builtin_unreachable();
   }
 
   if (style == ThreadStyle::POSIX)
-    __llvm_libc::syscall_impl(SYS_exit, retval.posix_retval);
+    __llvm_libc::syscall_impl<long>(SYS_exit, retval.posix_retval);
   else
-    __llvm_libc::syscall_impl(SYS_exit, retval.stdc_retval);
+    __llvm_libc::syscall_impl<long>(SYS_exit, retval.stdc_retval);
   __builtin_unreachable();
 }
 
 } // namespace __llvm_libc

libc/src/__support/threads/thread.cpp

class TSSKeyMgr {
   Mutex mtx;
   cpp::array<TSSKeyUnit, TSS_KEY_COUNT> units;
 
 public:
   constexpr TSSKeyMgr() : mtx(false, false, false) {}
 
   cpp::optional<unsigned int> new_key(TSSDtor *dtor) {
     MutexLock lock(&mtx);
-    for (size_t i = 0; i < TSS_KEY_COUNT; ++i) {
+    for (unsigned int i = 0; i < TSS_KEY_COUNT; ++i) {
       TSSKeyUnit &u = units[i];
       if (!u.active) {
         u = {dtor};
         return i;
       }
     }
     return cpp::optional<unsigned int>();
   }

libc/src/fcntl/linux/creat.cpp

 
 #include <fcntl.h>
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, creat, (const char *path, int mode_flags)) {
 #ifdef SYS_open
-  int fd = __llvm_libc::syscall_impl(SYS_open, path,
-                                     O_CREAT | O_WRONLY | O_TRUNC, mode_flags);
+  int fd = __llvm_libc::syscall_impl<int>(
+      SYS_open, path, O_CREAT | O_WRONLY | O_TRUNC, mode_flags);
 #else
-  int fd = __llvm_libc::syscall_impl(SYS_openat, AT_FDCWD, path,
-                                     O_CREAT | O_WRONLY | O_TRUNC, mode_flags);
+  int fd = __llvm_libc::syscall_impl<int>(
+      SYS_openat, AT_FDCWD, path, O_CREAT | O_WRONLY | O_TRUNC, mode_flags);
 #endif
 
   if (fd > 0)
     return fd;
 
   libc_errno = -fd;
   return -1;
 }
 
 } // namespace __llvm_libc

libc/src/fcntl/linux/open.cpp

LLVM_LIBC_FUNCTION(int, open, (const char *path, int flags, ...)) {
   if ((flags & O_CREAT) || (flags & O_TMPFILE) == O_TMPFILE) {
     va_list varargs;
     va_start(varargs, flags);
     mode_flags = va_arg(varargs, mode_t);
     va_end(varargs);
   }
 
 #ifdef SYS_open
-  int fd = __llvm_libc::syscall_impl(SYS_open, path, flags, mode_flags);
+  int fd = __llvm_libc::syscall_impl<int>(SYS_open, path, flags, mode_flags);
 #else
-  int fd =
-      __llvm_libc::syscall_impl(SYS_openat, AT_FDCWD, path, flags, mode_flags);
+  int fd = __llvm_libc::syscall_impl<int>(SYS_openat, AT_FDCWD, path, flags,
+                                          mode_flags);
 #endif
   if (fd > 0)
     return fd;
 
   libc_errno = -fd;
   return -1;
 }
 
 } // namespace __llvm_libc

libc/src/fcntl/linux/openat.cpp

LLVM_LIBC_FUNCTION(int, openat, (int dfd, const char *path, int flags, ...)) {
   // with O_TMPFILE
   if ((flags & O_CREAT) || (flags & O_TMPFILE) == O_TMPFILE) {
     va_list varargs;
     va_start(varargs, flags);
     mode_flags = va_arg(varargs, mode_t);
     va_end(varargs);
   }
 
-  int fd = __llvm_libc::syscall_impl(SYS_openat, dfd, path, flags, mode_flags);
+  int fd =
+      __llvm_libc::syscall_impl<int>(SYS_openat, dfd, path, flags, mode_flags);
   if (fd > 0)
     return fd;
 
   libc_errno = -fd;
   return -1;
 }
 
 } // namespace __llvm_libc

libc/src/sched/linux/sched_get_priority_max.cpp

 #include "src/__support/common.h"
 #include "src/errno/libc_errno.h"
 
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, sched_get_priority_max, (int policy)) {
-  long ret = __llvm_libc::syscall_impl(SYS_sched_get_priority_max, policy);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_sched_get_priority_max, policy);
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return ret;
 }
 
 } // namespace __llvm_libc

libc/src/sched/linux/sched_get_priority_min.cpp

 #include "src/__support/common.h"
 #include "src/errno/libc_errno.h"
 
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, sched_get_priority_min, (int policy)) {
-  long ret = __llvm_libc::syscall_impl(SYS_sched_get_priority_min, policy);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_sched_get_priority_min, policy);
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return ret;
 }
 
 } // namespace __llvm_libc

libc/src/sched/linux/sched_getaffinity.cpp

 #include <sched.h>
 #include <stdint.h>
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, sched_getaffinity,
                    (pid_t tid, size_t cpuset_size, cpu_set_t *mask)) {
-  long ret =
-      __llvm_libc::syscall_impl(SYS_sched_getaffinity, tid, cpuset_size, mask);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_sched_getaffinity, tid,
+                                           cpuset_size, mask);
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   if (size_t(ret) < cpuset_size) {
     // This means that only |ret| bytes in |mask| have been set. We will have to
     // zero out the remaining bytes.
     auto *mask_bytes = reinterpret_cast<uint8_t *>(mask);
     for (size_t i = size_t(ret); i < cpuset_size; ++i)
       mask_bytes[i] = 0;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/sched/linux/sched_getparam.cpp

 #include "src/errno/libc_errno.h"
 
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, sched_getparam,
                    (pid_t tid, struct sched_param *param)) {
-  long ret = __llvm_libc::syscall_impl(SYS_sched_getparam, tid, param);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_sched_getparam, tid, param);
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/sched/linux/sched_getscheduler.cpp

 #include "src/__support/common.h"
 #include "src/errno/libc_errno.h"
 
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, sched_getscheduler, (pid_t tid)) {
-  long ret = __llvm_libc::syscall_impl(SYS_sched_getscheduler, tid);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_sched_getscheduler, tid);
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return ret;
 }
 
 } // namespace __llvm_libc

libc/src/sched/linux/sched_rr_get_interval.cpp

 #include <linux/time_types.h> // For __kernel_timespec.
 #endif
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, sched_rr_get_interval,
                    (pid_t tid, struct timespec *tp)) {
 #ifdef SYS_sched_rr_get_interval
-  long ret = __llvm_libc::syscall_impl(SYS_sched_rr_get_interval, tid, tp);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_sched_rr_get_interval, tid, tp);
 #elif defined(SYS_sched_rr_get_interval_time64)
   // The difference between the  and SYS_sched_rr_get_interval
   // SYS_sched_rr_get_interval_time64 syscalls is the data type used for the
   // time interval parameter: the latter takes a struct __kernel_timespec
-  long ret;
+  int ret;
   if (tp) {
     struct __kernel_timespec ts32;
-    ret =
-        __llvm_libc::syscall_impl(SYS_sched_rr_get_interval_time64, tid, &ts32);
+    ret = __llvm_libc::syscall_impl<int>(SYS_sched_rr_get_interval_time64, tid,
+                                         &ts32);
     if (ret == 0) {
       tp->tv_sec = ts32.tv_sec;
       tp->tv_nsec = ts32.tv_nsec;
     }
   } else
     // When tp is a nullptr, we still do the syscall to set ret and errno
-    ret = __llvm_libc::syscall_impl(SYS_sched_rr_get_interval_time64, tid,
+    ret = __llvm_libc::syscall_impl<int>(SYS_sched_rr_get_interval_time64, tid,
                                          nullptr);
 #else
 #error                                                                         \
     "sched_rr_get_interval and sched_rr_get_interval_time64 syscalls not available."
 #endif
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/sched/linux/sched_setaffinity.cpp

 
 #include <sched.h>
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, sched_setaffinity,
                    (pid_t tid, size_t cpuset_size, const cpu_set_t *mask)) {
-  long ret =
-      __llvm_libc::syscall_impl(SYS_sched_setaffinity, tid, cpuset_size, mask);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_sched_setaffinity, tid,
+                                           cpuset_size, mask);
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/sched/linux/sched_setparam.cpp

 #include "src/errno/libc_errno.h"
 
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, sched_setparam,
                    (pid_t tid, const struct sched_param *param)) {
-  long ret = __llvm_libc::syscall_impl(SYS_sched_setparam, tid, param);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_sched_setparam, tid, param);
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/sched/linux/sched_setscheduler.cpp

 #include "src/errno/libc_errno.h"
 
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, sched_setscheduler,
                    (pid_t tid, int policy, const struct sched_param *param)) {
-  long ret =
-      __llvm_libc::syscall_impl(SYS_sched_setscheduler, tid, policy, param);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_sched_setscheduler, tid, policy,
+                                           param);
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return ret;
 }
 
 } // namespace __llvm_libc

libc/src/sched/linux/sched_yield.cpp

 #include "src/__support/common.h"
 #include "src/errno/libc_errno.h"
 
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, sched_yield, ()) {
-  long ret = __llvm_libc::syscall_impl(SYS_sched_yield);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_sched_yield);
   // As of writing this, yield() cannot fail
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/signal/linux/__restore.cpp

 #include "src/__support/OSUtil/syscall.h"
 
 namespace __llvm_libc {
 
 extern "C" void __restore_rt()
     __attribute__((no_sanitize("all"),
                    hidden));
 
-extern "C" void __restore_rt() { __llvm_libc::syscall_impl(SYS_rt_sigreturn); }
+extern "C" void __restore_rt() {
+  __llvm_libc::syscall_impl<long>(SYS_rt_sigreturn);
+}
 
 } // namespace __llvm_libc

libc/src/signal/linux/kill.cpp

 #include "src/signal/linux/signal_utils.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);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_kill, pid, sig);
 
   // A negative return value indicates an error with the magnitude of the
   // value being the error code.
   if (ret != 0) {
     libc_errno = (ret > 0 ? ret : -ret);
     return -1;
   }
 
   return ret; // always 0
 }
 
 } // namespace __llvm_libc

libc/src/signal/linux/raise.cpp

 
 #include "src/__support/common.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, raise, (int sig)) {
   ::sigset_t sigset;
   block_all_signals(sigset);
-  long pid = __llvm_libc::syscall_impl(SYS_getpid);
-  long tid = __llvm_libc::syscall_impl(SYS_gettid);
-  int ret = __llvm_libc::syscall_impl(SYS_tgkill, pid, tid, sig);
+  long pid = __llvm_libc::syscall_impl<long>(SYS_getpid);
+  long tid = __llvm_libc::syscall_impl<long>(SYS_gettid);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_tgkill, pid, tid, sig);
   restore_signals(sigset);
   return ret;
 }
 
 } // namespace __llvm_libc

libc/src/signal/linux/sigaction.cpp

if (libc_new) {
     kernel_new = *libc_new;
     if (!(kernel_new.sa_flags & SA_RESTORER)) {
       kernel_new.sa_flags |= SA_RESTORER;
       kernel_new.sa_restorer = __restore_rt;
     }
   }
 
   KernelSigaction kernel_old;
-  int ret = __llvm_libc::syscall_impl(
+  int ret = __llvm_libc::syscall_impl<int>(
       SYS_rt_sigaction, signal, libc_new ? &kernel_new : nullptr,
       libc_old ? &kernel_old : nullptr, sizeof(sigset_t));
   if (ret) {
     libc_errno = -ret;
     return -1;
   }
 
   if (libc_old)
     *libc_old = kernel_old;
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/signal/linux/sigaltstack.cpp

if ((unsigned(ss->ss_flags) & not_ss_disable) != 0) {
       return -1;
     }
     if (ss->ss_size < MINSIGSTKSZ) {
       libc_errno = ENOMEM;
       return -1;
     }
   }
 
-  int ret = __llvm_libc::syscall_impl(SYS_sigaltstack, ss, oss);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_sigaltstack, ss, oss);
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/signal/linux/signal_utils.h

LIBC_INLINE KernelSigaction &operator=(const struct sigaction &sa) {
     } else {
       sa_handler = sa.sa_handler;
     }
     return *this;
   }
 
   LIBC_INLINE operator struct sigaction() const {
     struct sigaction sa;
-    sa.sa_flags = sa_flags;
+    sa.sa_flags = static_cast<int>(sa_flags);
     sa.sa_mask = sa_mask;
     sa.sa_restorer = sa_restorer;
     if (sa_flags & SA_SIGINFO)
       sa.sa_sigaction = reinterpret_cast<SiginfoHandlerType *>(sa_handler);
     else
       sa.sa_handler = sa_handler;
     return sa;
   }
LIBC_INLINE constexpr bool delete_signal(sigset_t &set, int signal) {
   size_t word = n / BITS_PER_SIGWORD;
   size_t bit = n % BITS_PER_SIGWORD;
   set.__signals[word] &= ~(1UL << bit);
   return true;
 }
 
 LIBC_INLINE int block_all_signals(sigset_t &set) {
   sigset_t full = full_set();
-  return __llvm_libc::syscall_impl(SYS_rt_sigprocmask, SIG_BLOCK, &full, &set,
-                                   sizeof(sigset_t));
+  return __llvm_libc::syscall_impl<int>(SYS_rt_sigprocmask, SIG_BLOCK, &full,
+                                        &set, sizeof(sigset_t));
 }
 
 LIBC_INLINE int restore_signals(const sigset_t &set) {
-  return __llvm_libc::syscall_impl(SYS_rt_sigprocmask, SIG_SETMASK, &set,
+  return __llvm_libc::syscall_impl<int>(SYS_rt_sigprocmask, SIG_SETMASK, &set,
                                         nullptr, sizeof(sigset_t));
 }
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SIGNAL_LINUX_SIGNAL_UTILS_H

libc/src/signal/linux/sigprocmask.cpp

 #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,
+  int ret = __llvm_libc::syscall_impl<int>(SYS_rt_sigprocmask, how, set, oldset,
                                            sizeof(sigset_t));
   if (!ret)
     return 0;
 
   libc_errno = -ret;
   return -1;
 }
 
 } // namespace __llvm_libc

libc/src/spawn/linux/posix_spawn.cpp

 
 namespace {
 
 pid_t fork() {
   // TODO: Use only the clone syscall and use a sperate small stack in the child
   // to avoid duplicating the complete stack from the parent. A new stack will
   // be created on exec anyway so duplicating the full stack is unnecessary.
 #ifdef SYS_fork
-  return __llvm_libc::syscall_impl(SYS_fork);
+  return __llvm_libc::syscall_impl<pid_t>(SYS_fork);
 #elif defined(SYS_clone)
-  return __llvm_libc::syscall_impl(SYS_clone, SIGCHLD, 0);
+  return __llvm_libc::syscall_impl<pid_t>(SYS_clone, SIGCHLD, 0);
 #else
 #error "fork or clone syscalls not available."
 #endif
 }
 
 cpp::optional<int> open(const char *path, int oflags, mode_t mode) {
 #ifdef SYS_open
-  int fd = __llvm_libc::syscall_impl(SYS_open, path, oflags, mode);
+  int fd = __llvm_libc::syscall_impl<int>(SYS_open, path, oflags, mode);
 #else
-  int fd = __llvm_libc::syscall_impl(SYS_openat, AT_FDCWD, path, oflags, mode);
+  int fd =
+      __llvm_libc::syscall_impl<int>(SYS_openat, AT_FDCWD, path, oflags, mode);
 #endif
   if (fd > 0)
     return fd;
   // The open function is called as part of the child process' preparatory
   // steps. If an open fails, the child process just exits. So, unlike
   // the public open function, we do not need to set errno here.
   return cpp::nullopt;
 }
 
-void close(int fd) { __llvm_libc::syscall_impl(SYS_close, fd); }
+void close(int fd) { __llvm_libc::syscall_impl<long>(SYS_close, fd); }
 
 // We use dup3 if dup2 is not available, similar to our implementation of dup2
 bool dup2(int fd, int newfd) {
 #ifdef SYS_dup2
-  long ret = __llvm_libc::syscall_impl(SYS_dup2, fd, newfd);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_dup2, fd, newfd);
 #elif defined(SYS_dup3)
-  long ret = __llvm_libc::syscall_impl(SYS_dup3, fd, newfd, 0);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_dup3, fd, newfd, 0);
 #else
 #error "dup2 and dup3 syscalls not available."
 #endif
   return ret < 0 ? false : true;
 }
 
 // All exits from child_process are error exits. So, we use a simple
 // exit implementation which exits with code 127.
 void exit() {
   for (;;) {
-    __llvm_libc::syscall_impl(SYS_exit_group, 127);
-    __llvm_libc::syscall_impl(SYS_exit, 127);
+    __llvm_libc::syscall_impl<long>(SYS_exit_group, 127);
+    __llvm_libc::syscall_impl<long>(SYS_exit, 127);
   }
 }
 
 void child_process(const char *__restrict path,
                    const posix_spawn_file_actions_t *file_actions,
                    const posix_spawnattr_t *__restrict, // For now unused
                    char *const *__restrict argv, char *const *__restrict envp) {
   // TODO: In the code below, the child_process just exits on error during
while (act != nullptr) {
           exit();
         break;
       }
       }
       act = act->next;
     }
   }
 
-  if (__llvm_libc::syscall_impl(SYS_execve, path, argv, envp) < 0)
+  if (__llvm_libc::syscall_impl<long>(SYS_execve, path, argv, envp) < 0)
     exit();
 }
 
 } // anonymous namespace
 
 LLVM_LIBC_FUNCTION(int, posix_spawn,
                    (pid_t *__restrict pid, const char *__restrict path,
                     const posix_spawn_file_actions_t *file_actions,

libc/src/stdio/linux/remove.cpp

 #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);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_unlinkat, AT_FDCWD, path, 0);
   if (ret == -EISDIR)
-    ret = __llvm_libc::syscall_impl(SYS_unlinkat, AT_FDCWD, path, AT_REMOVEDIR);
+    ret = __llvm_libc::syscall_impl<int>(SYS_unlinkat, AT_FDCWD, path,
+                                         AT_REMOVEDIR);
   if (ret >= 0)
     return 0;
   libc_errno = -ret;
   return -1;
 }
 
 } // namespace __llvm_libc

libc/src/stdio/printf_core/vfprintf_internal.h

 LIBC_INLINE void flockfile(FILE *f) {
   reinterpret_cast<__llvm_libc::File *>(f)->lock();
 }
 
 LIBC_INLINE void funlockfile(FILE *f) {
   reinterpret_cast<__llvm_libc::File *>(f)->unlock();
 }
 
-LIBC_INLINE int fwrite_unlocked(const void *ptr, size_t size, size_t nmemb,
+LIBC_INLINE size_t fwrite_unlocked(const void *ptr, size_t size, size_t nmemb,
                                    FILE *f) {
-  return static_cast<int>(
-      reinterpret_cast<__llvm_libc::File *>(f)->write_unlocked(ptr,
-                                                               size * nmemb));
+  return reinterpret_cast<__llvm_libc::File *>(f)->write_unlocked(ptr,
+                                                                  size * nmemb);
 }
 #else  // defined(LIBC_COPT_PRINTF_USE_SYSTEM_FILE)
 LIBC_INLINE int ferror_unlocked(::FILE *f) { return ::ferror_unlocked(f); }
 
 LIBC_INLINE void flockfile(::FILE *f) { ::flockfile(f); }
 
 LIBC_INLINE void funlockfile(::FILE *f) { ::funlockfile(f); }
 
-LIBC_INLINE int fwrite_unlocked(const void *ptr, size_t size, size_t nmemb,
+LIBC_INLINE size_t fwrite_unlocked(const void *ptr, size_t size, size_t nmemb,
                                    ::FILE *f) {
   return ::fwrite_unlocked(ptr, size, nmemb, f);
 }
 #endif // LIBC_COPT_PRINTF_USE_SYSTEM_FILE
 } // namespace internal
 
 namespace printf_core {
 
 LIBC_INLINE int file_write_hook(cpp::string_view new_str, void *fp) {

libc/src/sys/mman/linux/madvise.cpp

 #include "src/errno/libc_errno.h"
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 // This function is currently linux only. It has to be refactored suitably if
 // madvise is to be supported on non-linux operating systems also.
 LLVM_LIBC_FUNCTION(int, madvise, (void *addr, size_t size, int advice)) {
-  long ret_val = __llvm_libc::syscall_impl(
+  int ret = __llvm_libc::syscall_impl<int>(
       SYS_madvise, reinterpret_cast<long>(addr), size, advice);
 
   // A negative return value indicates an error with the magnitude of the
   // value being the error code.
-  if (ret_val < 0) {
-    libc_errno = -ret_val;
+  if (ret < 0) {
+    libc_errno = -ret;
     return -1;
   }
 
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/sys/mman/linux/mmap.cpp

#ifdef SYS_mmap2
   offset /= EXEC_PAGESIZE;
   long syscall_number = SYS_mmap2;
 #elif defined(SYS_mmap)
   long syscall_number = SYS_mmap;
 #else
 #error "mmap or mmap2 syscalls not available."
 #endif
 
-  long ret_val =
+  long ret =
       __llvm_libc::syscall_impl(syscall_number, reinterpret_cast<long>(addr),
                                 size, prot, flags, fd, offset);
 
   // The mmap/mmap2 syscalls return negative values on error. These negative
   // values are actually the negative values of the error codes. So, fix them
   // up in case an error code is detected.
   //
   // A point to keep in mind for the fix up is that a negative return value
   // from the syscall can also be an error-free value returned by the syscall.
   // However, since a valid return address cannot be within the last page, a
   // return value corresponding to a location in the last page is an error
   // value.
-  if (ret_val < 0 && ret_val > -EXEC_PAGESIZE) {
-    libc_errno = -ret_val;
+  if (ret < 0 && ret > -EXEC_PAGESIZE) {
+    libc_errno = static_cast<int>(-ret);
     return MAP_FAILED;
   }
 
-  return reinterpret_cast<void *>(ret_val);
+  return reinterpret_cast<void *>(ret);
 }
 
 } // namespace __llvm_libc

libc/src/sys/mman/linux/mprotect.cpp

 #include "src/errno/libc_errno.h"
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 // This function is currently linux only. It has to be refactored suitably if
 // mprotect is to be supported on non-linux operating systems also.
 LLVM_LIBC_FUNCTION(int, mprotect, (void *addr, size_t size, int prot)) {
-  long ret_val = __llvm_libc::syscall_impl(
+  int ret = __llvm_libc::syscall_impl<int>(
       SYS_mprotect, reinterpret_cast<long>(addr), size, prot);
 
   // A negative return value indicates an error with the magnitude of the
   // value being the error code.
-  if (ret_val < 0) {
-    libc_errno = -ret_val;
+  if (ret < 0) {
+    libc_errno = -ret;
     return -1;
   }
 
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/sys/mman/linux/munmap.cpp

 #include "src/errno/libc_errno.h"
 #include <sys/syscall.h>          // For syscall numbers.
 
 namespace __llvm_libc {
 
 // This function is currently linux only. It has to be refactored suitably if
 // mmap is to be supported on non-linux operating systems also.
 LLVM_LIBC_FUNCTION(int, munmap, (void *addr, size_t size)) {
-  long ret_val =
-      __llvm_libc::syscall_impl(SYS_munmap, reinterpret_cast<long>(addr), size);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_munmap,
+                                           reinterpret_cast<long>(addr), size);
 
   // A negative return value indicates an error with the magnitude of the
   // value being the error code.
-  if (ret_val < 0) {
-    libc_errno = -ret_val;
+  if (ret < 0) {
+    libc_errno = -ret;
     return -1;
   }
 
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/sys/mman/linux/posix_madvise.cpp

 // This function is currently linux only. It has to be refactored suitably if
 // posix_madvise is to be supported on non-linux operating systems also.
 LLVM_LIBC_FUNCTION(int, posix_madvise, (void *addr, size_t size, int advice)) {
   // POSIX_MADV_DONTNEED does nothing because the default MADV_DONTNEED may
   // cause data loss, which the posix madvise does not allow.
   if (advice == POSIX_MADV_DONTNEED) {
     return 0;
   }
-  long ret_val = __llvm_libc::syscall_impl(
+  int ret = __llvm_libc::syscall_impl<int>(
       SYS_madvise, reinterpret_cast<long>(addr), size, advice);
-  return ret_val < 0 ? -ret_val : 0;
+  return ret < 0 ? -ret : 0;
 }
 
 } // namespace __llvm_libc

libc/src/sys/random/linux/getrandom.cpp

 
 #include "src/errno/libc_errno.h"
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(ssize_t, getrandom,
                    (void *buf, size_t buflen, unsigned int flags)) {
-  long ret = __llvm_libc::syscall_impl(SYS_getrandom, buf, buflen, flags);
+  ssize_t ret =
+      __llvm_libc::syscall_impl<ssize_t>(SYS_getrandom, buf, buflen, flags);
   if (ret < 0) {
-    libc_errno = -ret;
+    libc_errno = static_cast<int>(-ret);
     return -1;
   }
   return ret;
 }
 
 } // namespace __llvm_libc

libc/src/sys/resource/linux/getrlimit.cpp

 
 #include "src/errno/libc_errno.h"
 #include <sys/resource.h> // For struct rlimit
 #include <sys/syscall.h>  // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, getrlimit, (int res, struct rlimit *limits)) {
-  long ret = __llvm_libc::syscall_impl(SYS_prlimit64, 0, res, nullptr, limits);
+  int ret =
+      __llvm_libc::syscall_impl<int>(SYS_prlimit64, 0, res, nullptr, limits);
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/sys/resource/linux/setrlimit.cpp

 
 #include "src/errno/libc_errno.h"
 #include <sys/resource.h> // For struct rlimit
 #include <sys/syscall.h>  // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, setrlimit, (int res, const struct rlimit *limits)) {
-  long ret = __llvm_libc::syscall_impl(SYS_prlimit64, 0, res, limits, nullptr);
+  int ret =
+      __llvm_libc::syscall_impl<int>(SYS_prlimit64, 0, res, limits, nullptr);
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/sys/select/linux/select.cpp

if ((TIME_MAX - timeout->tv_sec) < (timeout->tv_usec / 1000000)) {
       ts.tv_nsec = 999999999;
     } else {
       ts.tv_sec = timeout->tv_sec + timeout->tv_usec / 1000000;
       ts.tv_nsec = timeout->tv_usec * 1000;
     }
   }
   pselect6_sigset_t pss{nullptr, sizeof(sigset_t)};
 #if SYS_pselect6
-  long ret = __llvm_libc::syscall_impl(SYS_pselect6, nfds, read_set, write_set,
-                                       error_set, &ts, &pss);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_pselect6, nfds, read_set,
+                                           write_set, error_set, &ts, &pss);
 #elif defined(SYS_pselect6_time64)
-  long ret = __llvm_libc::syscall_impl(SYS_pselect6_time64, nfds, read_set,
+  int ret = __llvm_libc::syscall_impl<int>(SYS_pselect6_time64, nfds, read_set,
                                            write_set, error_set, &ts, &pss);
 #else
 #error "SYS_pselect6 and SYS_pselect6_time64 syscalls not available."
 #endif
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return ret;
 }
 
 } // namespace __llvm_libc

libc/src/sys/sendfile/linux/sendfile.cpp

 #include <sys/sendfile.h>
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(ssize_t, sendfile,
                    (int out_fd, int in_fd, off_t *offset, size_t count)) {
 #ifdef SYS_sendfile
-  long ret =
-      __llvm_libc::syscall_impl(SYS_sendfile, in_fd, out_fd, offset, count);
+  ssize_t ret = __llvm_libc::syscall_impl<ssize_t>(SYS_sendfile, in_fd, out_fd,
+                                                   offset, count);
 #elif defined(SYS_sendfile64)
   // Same as sendfile but can handle large offsets
   static_assert(sizeof(off_t) == 8);
-  long ret =
-      __llvm_libc::syscall_impl(SYS_sendfile64, in_fd, out_fd, offset, count);
+  ssize_t ret = __llvm_libc::syscall_impl<ssize_t>(SYS_sendfile64, in_fd,
+                                                   out_fd, offset, count);
 #else
 #error "sendfile and sendfile64 syscalls not available."
 #endif
   if (ret < 0) {
-    libc_errno = -ret;
+    libc_errno = static_cast<int>(-ret);
     return -1;
   }
   return ret;
 }
 
 } // namespace __llvm_libc

libc/src/sys/socket/linux/socket.cpp

 
 #include <linux/net.h>   // For SYS_SOCKET socketcall number.
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, socket, (int domain, int type, int protocol)) {
 #ifdef SYS_socket
-  long ret = __llvm_libc::syscall_impl(SYS_socket, domain, type, protocol);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_socket, domain, type, protocol);
 #elif defined(SYS_socketcall)
   unsigned long sockcall_args[3] = {domain, type, protocol};
-  long ret =
-      __llvm_libc::syscall_impl(SYS_socketcall, SYS_SOCKET, sockcall_args);
+  int ret =
+      __llvm_libc::syscall_impl<int>(SYS_socketcall, SYS_SOCKET, sockcall_args);
 #else
 #error "socket and socketcall syscalls unavailable for this platform."
 #endif
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return ret;
 }
 
 } // namespace __llvm_libc

libc/src/sys/stat/linux/chmod.cpp

 #include <fcntl.h>
 #include <sys/stat.h>
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, chmod, (const char *path, mode_t mode)) {
 #ifdef SYS_chmod
-  long ret = __llvm_libc::syscall_impl(SYS_chmod, path, mode);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_chmod, path, mode);
 #elif defined(SYS_fchmodat)
-  long ret = __llvm_libc::syscall_impl(SYS_fchmodat, AT_FDCWD, path, mode);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_fchmodat, AT_FDCWD, path, mode);
 #else
 #error "chmod and fchmodat syscalls not available."
 #endif
 
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/sys/stat/linux/fchmod.cpp

 #include "src/errno/libc_errno.h"
 #include <fcntl.h>
 #include <sys/stat.h>
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, fchmod, (int fd, mode_t mode)) {
-  long ret = __llvm_libc::syscall_impl(SYS_fchmod, fd, mode);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_fchmod, fd, mode);
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/sys/stat/linux/fchmodat.cpp

 #include "src/errno/libc_errno.h"
 #include <sys/stat.h>
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, fchmodat,
                    (int dirfd, const char *path, mode_t mode, int flags)) {
-  long ret = __llvm_libc::syscall_impl(SYS_fchmodat, dirfd, path, mode, flags);
+  int ret =
+      __llvm_libc::syscall_impl<int>(SYS_fchmodat, dirfd, path, mode, flags);
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/sys/stat/linux/kernel_statx.h

 } // Anonymous namespace
 
 namespace __llvm_libc {
 
 LIBC_INLINE int statx(int dirfd, const char *__restrict path, int flags,
                       struct stat *__restrict statbuf) {
   // We make a statx syscall and copy out the result into the |statbuf|.
   ::statx_buf xbuf;
-  long ret = __llvm_libc::syscall_impl(SYS_statx, dirfd, path, flags,
+  int ret = __llvm_libc::syscall_impl<int>(SYS_statx, dirfd, path, flags,
                                            ::STATX_BASIC_STATS_MASK, &xbuf);
   if (ret < 0)
     return -ret;
 
   statbuf->st_dev = MKDEV(xbuf.stx_dev_major, xbuf.stx_dev_minor);
   statbuf->st_ino = xbuf.stx_ino;
   statbuf->st_mode = xbuf.stx_mode;
   statbuf->st_nlink = xbuf.stx_nlink;
   statbuf->st_uid = xbuf.stx_uid;

libc/src/sys/stat/linux/mkdir.cpp

 #include <fcntl.h>
 #include <sys/stat.h>
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, mkdir, (const char *path, mode_t mode)) {
 #ifdef SYS_mkdir
-  long ret = __llvm_libc::syscall_impl(SYS_mkdir, path, mode);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_mkdir, path, mode);
 #elif defined(SYS_mkdirat)
-  long ret = __llvm_libc::syscall_impl(SYS_mkdirat, AT_FDCWD, path, mode);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_mkdirat, AT_FDCWD, path, mode);
 #else
 #error "mkdir and mkdirat syscalls not available."
 #endif
 
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/sys/stat/linux/mkdirat.cpp

 #include "src/errno/libc_errno.h"
 #include <sys/stat.h>
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, mkdirat, (int dfd, const char *path, mode_t mode)) {
 #ifdef SYS_mkdirat
-  long ret = __llvm_libc::syscall_impl(SYS_mkdirat, dfd, path, mode);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_mkdirat, dfd, path, mode);
 #else
 #error "mkdirat syscall not available."
 #endif
 
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/sys/utsname/linux/uname.cpp

 
 #include "src/errno/libc_errno.h"
 #include <sys/syscall.h> // For syscall numbers.
 #include <sys/utsname.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, uname, (struct utsname * name)) {
-  long ret = __llvm_libc::syscall_impl(SYS_uname, name);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_uname, name);
 
   if (ret >= 0)
     return 1;
   libc_errno = -ret;
   return -1;
 }
 
 } // namespace __llvm_libc

libc/src/sys/wait/wait4Impl.h

 namespace internal {
 
 // The implementation of wait here is very minimal. We will add more
 // functionality and standard compliance in future.
 
 LIBC_INLINE ErrorOr<pid_t> wait4impl(pid_t pid, int *wait_status, int options,
                                      struct rusage *usage) {
 #if SYS_wait4
-  pid = __llvm_libc::syscall_impl(SYS_wait4, pid, wait_status, options, usage);
+  pid = __llvm_libc::syscall_impl<pid_t>(SYS_wait4, pid, wait_status, options,
+                                         usage);
 #elif defined(SYS_waitid)
   int idtype = P_PID;
   if (pid == -1) {
     idtype = P_ALL;
   } else if (pid < -1) {
     idtype = P_PGID;
     pid *= -1;
   } else if (pid == 0) {
     idtype = P_PGID;
   }
 
   options |= WEXITED;
 
   siginfo_t info;
-  pid =
-      __llvm_libc::syscall_impl(SYS_waitid, idtype, pid, &info, options, usage);
+  pid = __llvm_libc::syscall_impl<pid_t>(SYS_waitid, idtype, pid, &info,
+                                         options, usage);
   if (pid >= 0)
     pid = info.si_pid;
 
   if (wait_status) {
     switch (info.si_code) {
     case CLD_EXITED:
       *wait_status = W_EXITCODE(info.si_status, 0);
       break;

libc/src/termios/linux/tcdrain.cpp

 
 #include <asm/ioctls.h> // Safe to include without the risk of name pollution.
 #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);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_ioctl, fd, TCSBRK, 1);
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/termios/linux/tcflow.cpp

 
 #include <asm/ioctls.h> // Safe to include without the risk of name pollution.
 #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);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_ioctl, fd, TCXONC, action);
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/termios/linux/tcflush.cpp

 
 #include <asm/ioctls.h> // Safe to include without the risk of name pollution.
 #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);
+  int ret =
+      __llvm_libc::syscall_impl<int>(SYS_ioctl, fd, TCFLSH, queue_selector);
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/termios/linux/tcgetattr.cpp

 #include <asm/ioctls.h> // Safe to include without the risk of name pollution.
 #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);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_ioctl, fd, TCGETS, &kt);
   if (ret < 0) {
     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;

libc/src/termios/linux/tcgetsid.cpp

 #include <asm/ioctls.h> // Safe to include without the risk of name pollution.
 #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);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_ioctl, fd, TIOCGSID, &sid);
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return sid;
 }
 
 } // namespace __llvm_libc

libc/src/termios/linux/tcsendbreak.cpp

 #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);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_ioctl, fd, TCSBRK, 0);
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/termios/linux/tcsetattr.cpp

LLVM_LIBC_FUNCTION(int, tcsetattr,
   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);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_ioctl, fd, cmd, &kt);
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/threads/linux/CndVar.h

CndWaiter waiter;
           waitq_front = nullptr;
         else
           waitq_back->next = nullptr;
 
         return thrd_error;
       }
     }
 
-    __llvm_libc::syscall_impl(FUTEX_SYSCALL_ID, &waiter.futex_word.val,
+    __llvm_libc::syscall_impl<long>(FUTEX_SYSCALL_ID, &waiter.futex_word.val,
                                     FUTEX_WAIT, WS_Waiting, 0, 0, 0);
 
     // At this point, if locking |m| fails, we can simply return as the
     // queued up waiter would have been removed from the queue.
     auto err = m->lock();
     return err == MutexError::NONE ? thrd_success : thrd_error;
   }
 
   int notify_one() {
     // We don't use an RAII locker in this method as we want to unlock
     // |qmtx| and signal the waiter using a single FUTEX_WAKE_OP signal.
     qmtx.lock();
     if (waitq_front == nullptr) {
       qmtx.unlock();
       return thrd_success;
     }
 
     CndWaiter *first = waitq_front;
     waitq_front = waitq_front->next;
     if (waitq_front == nullptr)
       waitq_back = nullptr;
 
     qmtx.futex_word = FutexWordType(Mutex::LockState::Free);
 
-    __llvm_libc::syscall_impl(
+    __llvm_libc::syscall_impl<long>(
         FUTEX_SYSCALL_ID, &qmtx.futex_word.val, FUTEX_WAKE_OP, 1, 1,
         &first->futex_word.val,
         FUTEX_OP(FUTEX_OP_SET, WS_Signalled, FUTEX_OP_CMP_EQ, WS_Waiting));
     return thrd_success;
   }
 
   int broadcast() {
     MutexLock ml(&qmtx);
     uint32_t dummy_futex_word;
     CndWaiter *waiter = waitq_front;
     waitq_front = waitq_back = nullptr;
     while (waiter != nullptr) {
       // FUTEX_WAKE_OP is used instead of just FUTEX_WAKE as it allows us to
       // atomically update the waiter status to WS_Signalled before waking
       // up the waiter. A dummy location is used for the other futex of
       // FUTEX_WAKE_OP.
-      __llvm_libc::syscall_impl(
+      __llvm_libc::syscall_impl<long>(
           FUTEX_SYSCALL_ID, &dummy_futex_word, FUTEX_WAKE_OP, 1, 1,
           &waiter->futex_word.val,
           FUTEX_OP(FUTEX_OP_SET, WS_Signalled, FUTEX_OP_CMP_EQ, WS_Waiting));
       waiter = waiter->next;
     }
     return thrd_success;
   }
 };

libc/src/time/clock_gettime.cpp

 #include <time.h>
 
 namespace __llvm_libc {
 
 // TODO(michaelrj): Move this into time/linux with the other syscalls.
 LLVM_LIBC_FUNCTION(int, clock_gettime,
                    (clockid_t clockid, struct timespec *tp)) {
 #if SYS_clock_gettime
-  long ret_val =
-      __llvm_libc::syscall_impl(SYS_clock_gettime, static_cast<long>(clockid),
+  int ret = __llvm_libc::syscall_impl<int>(SYS_clock_gettime,
+                                           static_cast<long>(clockid),
                                            reinterpret_cast<long>(tp));
 #elif defined(SYS_clock_gettime64)
-  long ret_val =
-      __llvm_libc::syscall_impl(SYS_clock_gettime64, static_cast<long>(clockid),
+  int ret = __llvm_libc::syscall_impl<int>(SYS_clock_gettime64,
+                                           static_cast<long>(clockid),
                                            reinterpret_cast<long>(tp));
 #else
 #error "SYS_clock_gettime and SYS_clock_gettime64 syscalls not available."
 #endif
 
   // A negative return value indicates an error with the magnitude of the
   // value being the error code.
-  if (ret_val < 0) {
-    libc_errno = -ret_val;
+  if (ret < 0) {
+    libc_errno = -ret;
     return -1;
   }
 
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/time/gettimeofday.cpp

 
 // TODO(michaelrj): Move this into time/linux with the other syscalls.
 LLVM_LIBC_FUNCTION(int, gettimeofday,
                    (struct timeval * tv, [[maybe_unused]] void *unused)) {
   if (tv == nullptr)
     return 0;
   struct timespec tp;
 #if SYS_clock_gettime
-  long ret_val = __llvm_libc::syscall_impl(SYS_clock_gettime,
+  int ret = __llvm_libc::syscall_impl<int>(SYS_clock_gettime,
                                            static_cast<long>(CLOCK_REALTIME),
                                            reinterpret_cast<long>(&tp));
 #elif defined(SYS_clock_gettime64)
-  long ret_val = __llvm_libc::syscall_impl(SYS_clock_gettime64,
+  int ret = __llvm_libc::syscall_impl<int>(SYS_clock_gettime64,
                                            static_cast<long>(CLOCK_REALTIME),
                                            reinterpret_cast<long>(&tp));
 #else
 #error "SYS_clock_gettime and SYS_clock_gettime64 syscalls not available."
 #endif
   // A negative return value indicates an error with the magnitude of the
   // value being the error code.
-  if (ret_val < 0) {
-    libc_errno = -ret_val;
+  if (ret < 0) {
+    libc_errno = -ret;
     return -1;
   }
   tv->tv_sec = tp.tv_sec;
-  tv->tv_usec = tp.tv_nsec / 1000;
+  tv->tv_usec = static_cast<suseconds_t>(tp.tv_nsec / 1000);
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/time/linux/clock.cpp

 #include <sys/syscall.h> // For syscall numbers.
 #include <time.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(clock_t, clock, ()) {
   struct timespec ts;
 #if SYS_clock_gettime
-  long ret_val = __llvm_libc::syscall_impl(
+  int ret = __llvm_libc::syscall_impl<int>(
       SYS_clock_gettime, CLOCK_PROCESS_CPUTIME_ID, reinterpret_cast<long>(&ts));
 #elif defined(SYS_clock_gettime64)
-  long ret_val =
-      __llvm_libc::syscall_impl(SYS_clock_gettime64, CLOCK_PROCESS_CPUTIME_ID,
+  int ret = __llvm_libc::syscall_impl<int>(SYS_clock_gettime64,
+                                           CLOCK_PROCESS_CPUTIME_ID,
                                            reinterpret_cast<long>(&ts));
 #else
 #error "SYS_clock_gettime and SYS_clock_gettime64 syscalls not available."
 #endif
-  if (ret_val < 0) {
-    libc_errno = -ret_val;
+  if (ret < 0) {
+    libc_errno = -ret;
     return clock_t(-1);
   }
 
   // The above syscall gets the CPU time in seconds plus nanoseconds.
   // The standard requires that we return clock_t(-1) if we cannot represent
   // clocks as a clock_t value.
   constexpr clock_t CLOCK_SECS_MAX =
       cpp::numeric_limits<clock_t>::max() / CLOCKS_PER_SEC;

libc/src/time/linux/time.cpp

 #include <time.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(time_t, time, (time_t * tp)) {
   // TODO: Use the Linux VDSO to fetch the time and avoid the syscall.
   struct timespec ts;
 #if SYS_clock_gettime
-  long ret_val = __llvm_libc::syscall_impl(SYS_clock_gettime, CLOCK_REALTIME,
+  int ret = __llvm_libc::syscall_impl<int>(SYS_clock_gettime, CLOCK_REALTIME,
                                            reinterpret_cast<long>(&ts));
 #elif defined(SYS_clock_gettime64)
-  long ret_val = __llvm_libc::syscall_impl(SYS_clock_gettime64, CLOCK_REALTIME,
+  int ret = __llvm_libc::syscall_impl<int>(SYS_clock_gettime64, CLOCK_REALTIME,
                                            reinterpret_cast<long>(&ts));
 #else
 #error "SYS_clock_gettime and SYS_clock_gettime64 syscalls not available."
 #endif
-  if (ret_val < 0) {
-    libc_errno = -ret_val;
+  if (ret < 0) {
+    libc_errno = -ret;
     return -1;
   }
 
   if (tp != nullptr)
     *tp = time_t(ts.tv_sec);
   return time_t(ts.tv_sec);
 }
 
 } // namespace __llvm_libc

libc/src/time/nanosleep.cpp

 #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)) {
 #if SYS_nanosleep
-  int ret = __llvm_libc::syscall_impl(SYS_nanosleep, req, rem);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_nanosleep, req, rem);
 #elif defined(SYS_clock_nanosleep_time64)
-  int ret = __llvm_libc::syscall_impl(SYS_clock_nanosleep_time64, req, rem);
+  int ret =
+      __llvm_libc::syscall_impl<int>(SYS_clock_nanosleep_time64, req, rem);
 #else
 #error "SYS_nanosleep and SYS_clock_nanosleep_time64 syscalls not available."
 #endif
 
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return ret;
 }
 
 } // namespace __llvm_libc

libc/src/time/time_utils.cpp

if (months >= TimeConstants::MONTHS_PER_YEAR - 2) {
     years++;
   }
 
   if (years > INT_MAX || years < INT_MIN)
     return time_utils::out_of_range();
 
   // All the data (years, month and remaining days) was calculated from
   // March, 2000. Thus adjust the data to be from January, 1900.
-  tm->tm_year = years + 2000 - TimeConstants::TIME_YEAR_BASE;
-  tm->tm_mon = months + 2;
-  tm->tm_mday = remainingDays + 1;
-  tm->tm_wday = wday;
-  tm->tm_yday = yday;
-
-  tm->tm_hour = remainingSeconds / TimeConstants::SECONDS_PER_HOUR;
-  tm->tm_min = remainingSeconds / TimeConstants::SECONDS_PER_MIN %
-               TimeConstants::SECONDS_PER_MIN;
-  tm->tm_sec = remainingSeconds % TimeConstants::SECONDS_PER_MIN;
+  tm->tm_year = static_cast<int>(years + 2000 - TimeConstants::TIME_YEAR_BASE);
+  tm->tm_mon = static_cast<int>(months + 2);
+  tm->tm_mday = static_cast<int>(remainingDays + 1);
+  tm->tm_wday = static_cast<int>(wday);
+  tm->tm_yday = static_cast<int>(yday);
+
+  tm->tm_hour =
+      static_cast<int>(remainingSeconds / TimeConstants::SECONDS_PER_HOUR);
+  tm->tm_min =
+      static_cast<int>(remainingSeconds / TimeConstants::SECONDS_PER_MIN %
+                       TimeConstants::SECONDS_PER_MIN);
+  tm->tm_sec =
+      static_cast<int>(remainingSeconds % TimeConstants::SECONDS_PER_MIN);
   // TODO(rtenneti): Need to handle timezone and update of tm_isdst.
   tm->tm_isdst = 0;
 
   return 0;
 }
 
 } // namespace time_utils
 } // namespace __llvm_libc

libc/src/unistd/linux/access.cpp

 #include "src/errno/libc_errno.h"
 #include <fcntl.h>
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, access, (const char *path, int mode)) {
 #ifdef SYS_access
-  long ret = __llvm_libc::syscall_impl(SYS_access, path, mode);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_access, path, mode);
 #elif defined(SYS_faccessat)
-  long ret = __llvm_libc::syscall_impl(SYS_faccessat, AT_FDCWD, path, mode, 0);
+  int ret =
+      __llvm_libc::syscall_impl<int>(SYS_faccessat, AT_FDCWD, path, mode, 0);
 #else
 #error "access and faccessat syscalls not available."
 #endif
 
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/chdir.cpp

 #include "src/__support/common.h"
 
 #include "src/errno/libc_errno.h"
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, chdir, (const char *path)) {
-  long ret = __llvm_libc::syscall_impl(SYS_chdir, path);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_chdir, path);
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/close.cpp

 #include "src/__support/common.h"
 
 #include "src/errno/libc_errno.h"
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, close, (int fd)) {
-  long ret = __llvm_libc::syscall_impl(SYS_close, fd);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_close, fd);
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return ret;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/dup.cpp

 #include "src/__support/common.h"
 
 #include "src/errno/libc_errno.h"
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, dup, (int fd)) {
-  long ret = __llvm_libc::syscall_impl(SYS_dup, fd);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_dup, fd);
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return ret;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/dup2.cpp

 #include <fcntl.h>
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, dup2, (int oldfd, int newfd)) {
 #ifdef SYS_dup2
   // If dup2 syscall is available, we make use of directly.
-  long ret = __llvm_libc::syscall_impl(SYS_dup2, oldfd, newfd);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_dup2, oldfd, newfd);
 #elif defined(SYS_dup3)
   // If dup2 syscall is not available, we try using the dup3 syscall. However,
   // dup3 fails if oldfd is the same as newfd. So, we handle that case
   // separately before making the dup3 syscall.
   if (oldfd == newfd) {
     // Check if oldfd is actually a valid file descriptor.
 #if SYS_fcntl
-    long ret = __llvm_libc::syscall_impl(SYS_fcntl, oldfd, F_GETFD);
+    int ret = __llvm_libc::syscall_impl<int>(SYS_fcntl, oldfd, F_GETFD);
 #elif defined(SYS_fcntl64)
     // Same as fcntl but can handle large offsets
     static_assert(sizeof(off_t) == 8);
-    long ret = __llvm_libc::syscall_impl(SYS_fcntl64, oldfd, F_GETFD);
+    int ret = __llvm_libc::syscall_impl<int>(SYS_fcntl64, oldfd, F_GETFD);
 #else
 #error "SYS_fcntl and SYS_fcntl64 syscalls not available."
 #endif
     if (ret >= 0)
       return oldfd;
     libc_errno = -ret;
     return -1;
   }
-  long ret = __llvm_libc::syscall_impl(SYS_dup3, oldfd, newfd, 0);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_dup3, oldfd, newfd, 0);
 #else
 #error "dup2 and dup3 syscalls not available."
 #endif
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return ret;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/dup3.cpp

 
 #include "src/errno/libc_errno.h"
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, dup3, (int oldfd, int newfd, int flags)) {
   // If dup2 syscall is available, we make use of directly.
-  long ret = __llvm_libc::syscall_impl(SYS_dup3, oldfd, newfd, flags);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_dup3, oldfd, newfd, flags);
   if (ret >= 0)
     return ret;
   libc_errno = -ret;
   return -1;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/execv.cpp

 #include "src/__support/common.h"
 
 #include "src/errno/libc_errno.h"
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, execv, (const char *path, char *const argv[])) {
-  long ret =
-      __llvm_libc::syscall_impl(SYS_execve, path, argv, __llvm_libc::environ);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_execve, path, argv,
+                                           __llvm_libc::environ);
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
 
   // Control will not reach here on success but have a return statement will
   // keep the compilers happy.
   return ret;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/execve.cpp

 
 #include "src/errno/libc_errno.h"
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, execve,
                    (const char *path, char *const argv[], char *const envp[])) {
-  long ret = __llvm_libc::syscall_impl(SYS_execve, path, argv, envp);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_execve, path, argv, envp);
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
 
   // Control will not reach here on success but have a return statement will
   // keep the compilers happy.
   return ret;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/fchdir.cpp

 #include "src/__support/common.h"
 
 #include "src/errno/libc_errno.h"
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, fchdir, (int fd)) {
-  long ret = __llvm_libc::syscall_impl(SYS_fchdir, fd);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_fchdir, fd);
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/fork.cpp

 namespace __llvm_libc {
 
 // The implementation of fork here is very minimal. We will add more
 // functionality and standard compliance in future.
 
 LLVM_LIBC_FUNCTION(pid_t, fork, (void)) {
   invoke_prepare_callbacks();
 #ifdef SYS_fork
-  pid_t ret = __llvm_libc::syscall_impl(SYS_fork);
+  pid_t ret = __llvm_libc::syscall_impl<pid_t>(SYS_fork);
 #elif defined(SYS_clone)
-  pid_t ret = __llvm_libc::syscall_impl(SYS_clone, SIGCHLD, 0);
+  pid_t ret = __llvm_libc::syscall_impl<pid_t>(SYS_clone, SIGCHLD, 0);
 #else
 #error "fork and clone syscalls not available."
 #endif
   if (ret == 0) {
     // Return value is 0 in the child process.
     // The child is created with a single thread whose self object will be a
     // copy of parent process' thread which called fork. So, we have to fix up
     // the child process' self object with the new process' tid.
-    self.attrib->tid = __llvm_libc::syscall_impl(SYS_gettid);
+    self.attrib->tid = __llvm_libc::syscall_impl<pid_t>(SYS_gettid);
     invoke_child_callbacks();
     return 0;
   }
 
   if (ret < 0) {
     // Error case, a child process was not created.
-    libc_errno = -ret;
+    libc_errno = static_cast<int>(-ret);
     return -1;
   }
 
   invoke_parent_callbacks();
   return ret;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/fsync.cpp

 #include "src/__support/common.h"
 
 #include "src/errno/libc_errno.h"
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, fsync, (int fd)) {
-  long ret = __llvm_libc::syscall_impl(SYS_fsync, fd);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_fsync, fd);
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return ret;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/ftruncate.cpp

 #include <stdint.h>      // For uint64_t.
 #include <sys/syscall.h> // For syscall numbers.
 #include <unistd.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, ftruncate, (int fd, off_t len)) {
 #ifdef SYS_ftruncate
-  int ret = __llvm_libc::syscall_impl(SYS_ftruncate, fd, len);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_ftruncate, fd, len);
 #elif defined(SYS_ftruncate64)
   // Same as ftruncate but can handle large offsets
   static_assert(sizeof(off_t) == 8);
-  int ret = __llvm_libc::syscall_impl(SYS_ftruncate64, fd, (long)len,
+  int ret = __llvm_libc::syscall_impl<int>(SYS_ftruncate64, fd, (long)len,
                                            (long)(((uint64_t)(len)) >> 32));
 #else
 #error "ftruncate and ftruncate64 syscalls not available."
 #endif
 
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/getcwd.cpp

 #include <stdlib.h>
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 namespace {
 
 bool getcwd_syscall(char *buf, size_t size) {
-  int ret = __llvm_libc::syscall_impl(SYS_getcwd, buf, size);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_getcwd, buf, size);
   if (ret < 0) {
     libc_errno = -ret;
     return false;
   } else if (ret == 0 || buf[0] != '/') {
     libc_errno = ENOENT;
     return false;
   }
   return true;

libc/src/unistd/linux/geteuid.cpp

 #include "src/__support/OSUtil/syscall.h" // For internal syscall function.
 #include "src/__support/common.h"
 
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(uid_t, geteuid, ()) {
-  return __llvm_libc::syscall_impl(SYS_geteuid);
+  return __llvm_libc::syscall_impl<uid_t>(SYS_geteuid);
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/getpid.cpp

 #include "src/__support/OSUtil/syscall.h" // For internal syscall function.
 #include "src/__support/common.h"
 
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(pid_t, getpid, ()) {
-  return __llvm_libc::syscall_impl(SYS_getpid);
+  return __llvm_libc::syscall_impl<pid_t>(SYS_getpid);
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/getppid.cpp

 #include "src/__support/OSUtil/syscall.h" // For internal syscall function.
 #include "src/__support/common.h"
 
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(pid_t, getppid, ()) {
-  return __llvm_libc::syscall_impl(SYS_getppid);
+  return __llvm_libc::syscall_impl<pid_t>(SYS_getppid);
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/getuid.cpp

 #include "src/__support/OSUtil/syscall.h" // For internal syscall function.
 #include "src/__support/common.h"
 
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(uid_t, getuid, ()) {
-  return __llvm_libc::syscall_impl(SYS_getuid);
+  return __llvm_libc::syscall_impl<uid_t>(SYS_getuid);
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/isatty.cpp

 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, isatty, (int fd)) {
   constexpr int INIT_VAL = 0x1234abcd;
   int line_d_val = INIT_VAL;
   // This gets the line dicipline of the terminal. When called on something that
   // isn't a terminal it doesn't change line_d_val and returns -1.
-  int result = __llvm_libc::syscall_impl(SYS_ioctl, fd, TIOCGETD, &line_d_val);
+  int result =
+      __llvm_libc::syscall_impl<int>(SYS_ioctl, fd, TIOCGETD, &line_d_val);
   if (result == 0)
     return 1;
 
   libc_errno = -result;
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/link.cpp

 
 #include <fcntl.h>
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, link, (const char *path1, const char *path2)) {
 #ifdef SYS_link
-  long ret = __llvm_libc::syscall_impl(SYS_link, path1, path2);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_link, path1, path2);
 #elif defined(SYS_linkat)
-  long ret = __llvm_libc::syscall_impl(SYS_linkat, AT_FDCWD, path1, AT_FDCWD,
-                                       path2, 0);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_linkat, AT_FDCWD, path1,
+                                           AT_FDCWD, path2, 0);
 #else
 #error "link or linkat syscalls not available."
 #endif
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return ret;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/linkat.cpp

 #include <fcntl.h>
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, linkat,
                    (int fd1, const char *path1, int fd2, const char *path2,
                     int flags)) {
-  long ret =
-      __llvm_libc::syscall_impl(SYS_linkat, fd1, path1, fd2, path2, flags);
+  int ret =
+      __llvm_libc::syscall_impl<int>(SYS_linkat, fd1, path1, fd2, path2, flags);
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return ret;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/lseek.cpp

 #include <sys/syscall.h> // For syscall numbers.
 #include <unistd.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(off_t, lseek, (int fd, off_t offset, int whence)) {
   off_t result;
 #ifdef SYS_lseek
-  long ret = __llvm_libc::syscall_impl(SYS_lseek, fd, offset, whence);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_lseek, fd, offset, whence);
   result = ret;
 #elif defined(SYS_llseek)
   long ret = __llvm_libc::syscall_impl(SYS_llseek, fd,
                                        (long)(((uint64_t)(offset)) >> 32),
                                        (long)offset, &result, whence);
   result = ret;
 #elif defined(SYS__llseek)
-  long ret = __llvm_libc::syscall_impl(SYS__llseek, fd, offset >> 32, offset,
-                                       &result, whence);
+  int ret = __llvm_libc::syscall_impl<int>(SYS__llseek, fd, offset >> 32,
+                                           offset, &result, whence);
 #else
 #error "lseek, llseek and _llseek syscalls not available."
 #endif
 
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return result;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/pread.cpp

 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(ssize_t, pread,
                    (int fd, void *buf, size_t count, off_t offset)) {
 #ifdef LIBC_TARGET_ARCH_IS_RISCV32
   static_assert(sizeof(off_t) == 8);
-  long ret =
-      __llvm_libc::syscall_impl(SYS_pread64, fd, buf, count, (long)offset,
-                                (long)(((uint64_t)(offset)) >> 32));
+  ssize_t ret = __llvm_libc::syscall_impl<ssize_t>(
+      SYS_pread64, fd, buf, count, (long)offset,
 #else
-  long ret = __llvm_libc::syscall_impl(SYS_pread64, fd, buf, count, offset);
+  ssize_t ret =
+      __llvm_libc::syscall_impl<ssize_t>(SYS_pread64, fd, buf, count, offset);
 #endif
   if (ret < 0) {
-    libc_errno = -ret;
+    libc_errno = static_cast<int>(-ret);
     return -1;
   }
   return ret;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/pwrite.cpp

 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(ssize_t, pwrite,
                    (int fd, const void *buf, size_t count, off_t offset)) {
 #ifdef LIBC_TARGET_ARCH_IS_RISCV32
   static_assert(sizeof(off_t) == 8);
-  long ret =
-      __llvm_libc::syscall_impl(SYS_pwrite64, fd, buf, count, (long)offset,
-                                (long)(((uint64_t)(offset)) >> 32));
+  ssize_t ret = __llvm_libc::syscall_impl<ssize_t>(
+      SYS_pwrite64, fd, buf, count, (long)offset,
 #else
-  long ret = __llvm_libc::syscall_impl(SYS_pwrite64, fd, buf, count, offset);
+  ssize_t ret =
+      __llvm_libc::syscall_impl<ssize_t>(SYS_pwrite64, fd, buf, count, offset);
 #endif
   if (ret < 0) {
-    libc_errno = -ret;
+    libc_errno = static_cast<int>(-ret);
     return -1;
   }
   return ret;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/read.cpp

 #include "src/__support/common.h"
 
 #include "src/errno/libc_errno.h"
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(ssize_t, read, (int fd, void *buf, size_t count)) {
-  long ret = __llvm_libc::syscall_impl(SYS_read, fd, buf, count);
+  ssize_t ret = __llvm_libc::syscall_impl<ssize_t>(SYS_read, fd, buf, count);
   if (ret < 0) {
-    libc_errno = -ret;
+    libc_errno = static_cast<int>(-ret);
     return -1;
   }
   return ret;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/readlink.cpp

 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(ssize_t, readlink,
                    (const char *__restrict path, char *__restrict buf,
                     size_t bufsize)) {
 #ifdef SYS_readlink
-  ssize_t ret = __llvm_libc::syscall_impl(SYS_readlink, path, buf, bufsize);
-#elif defined(SYS_readlinkat)
   ssize_t ret =
-      __llvm_libc::syscall_impl(SYS_readlinkat, AT_FDCWD, path, buf, bufsize);
+      __llvm_libc::syscall_impl<ssize_t>(SYS_readlink, path, buf, bufsize);
+#elif defined(SYS_readlinkat)
+  ssize_t ret = __llvm_libc::syscall_impl<ssize_t>(SYS_readlinkat, AT_FDCWD,
+                                                   path, buf, bufsize);
 #else
 #error "readlink or readlinkat syscalls not available."
 #endif
   if (ret < 0) {
-    libc_errno = -ret;
+    libc_errno = static_cast<int>(-ret);
     return -1;
   }
   return ret;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/readlinkat.cpp

 #include <fcntl.h>
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(ssize_t, readlinkat,
                    (int fd, const char *__restrict path, char *__restrict buf,
                     size_t bufsize)) {
-  ssize_t ret =
-      __llvm_libc::syscall_impl(SYS_readlinkat, fd, path, buf, bufsize);
+  ssize_t ret = __llvm_libc::syscall_impl<ssize_t>(SYS_readlinkat, fd, path,
+                                                   buf, bufsize);
   if (ret < 0) {
-    libc_errno = -ret;
+    libc_errno = static_cast<int>(-ret);
     return -1;
   }
   return ret;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/rmdir.cpp

 
 #include <fcntl.h>
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, rmdir, (const char *path)) {
 #ifdef SYS_rmdir
-  long ret = __llvm_libc::syscall_impl(SYS_rmdir, path);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_rmdir, path);
 #elif defined(SYS_unlinkat)
-  long ret =
-      __llvm_libc::syscall_impl(SYS_unlinkat, AT_FDCWD, path, AT_REMOVEDIR);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_unlinkat, AT_FDCWD, path,
+                                           AT_REMOVEDIR);
 #else
 #error "rmdir and unlinkat syscalls not available."
 #endif
 
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/symlink.cpp

 
 #include <fcntl.h>
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, symlink, (const char *path1, const char *path2)) {
 #ifdef SYS_symlink
-  long ret = __llvm_libc::syscall_impl(SYS_symlink, path1, path2);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_symlink, path1, path2);
 #elif defined(SYS_symlinkat)
-  long ret = __llvm_libc::syscall_impl(SYS_symlinkat, path1, AT_FDCWD, path2);
+  int ret =
+      __llvm_libc::syscall_impl<int>(SYS_symlinkat, path1, AT_FDCWD, path2);
 #else
 #error "symlink or symlinkat syscalls not available."
 #endif
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return ret;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/symlinkat.cpp

 #include "src/errno/libc_errno.h"
 #include <fcntl.h>
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, symlinkat,
                    (const char *path1, int fd, const char *path2)) {
-  long ret = __llvm_libc::syscall_impl(SYS_symlinkat, path1, fd, path2);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_symlinkat, path1, fd, path2);
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return ret;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/syscall.cpp

 #include "src/errno/libc_errno.h"
 #include <stdarg.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(long, __llvm_libc_syscall,
                    (long number, long arg1, long arg2, long arg3, long arg4,
                     long arg5, long arg6)) {
-  long ret =
-      __llvm_libc::syscall_impl(number, arg1, arg2, arg3, arg4, arg5, arg6);
+  long ret = __llvm_libc::syscall_impl<long>(number, arg1, arg2, arg3, arg4,
+                                             arg5, arg6);
   // Syscalls may return large positive values that overflow, but will never
   // return values between -4096 and -1
   if (static_cast<unsigned long>(ret) > -4096UL) {
-    libc_errno = -ret;
+    libc_errno = static_cast<int>(-ret);
     return -1;
   }
   return ret;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/truncate.cpp

 #include <stdint.h>      // For uint64_t.
 #include <sys/syscall.h> // For syscall numbers.
 #include <unistd.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, truncate, (const char *path, off_t len)) {
 #ifdef SYS_truncate
-  int ret = __llvm_libc::syscall_impl(SYS_truncate, path, len);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_truncate, path, len);
 #elif defined(SYS_truncate64)
   // Same as truncate but can handle large offsets
   static_assert(sizeof(off_t) == 8);
-  int ret = __llvm_libc::syscall_impl(SYS_truncate64, path, (long)len,
+  int ret = __llvm_libc::syscall_impl<int>(SYS_truncate64, path, (long)len,
                                            (long)(((uint64_t)(len)) >> 32));
 #else
 #error "truncate and truncate64 syscalls not available."
 #endif
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/unlink.cpp

 #include "src/errno/libc_errno.h"
 #include <fcntl.h>
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, unlink, (const char *path)) {
 #ifdef SYS_unlink
-  long ret = __llvm_libc::syscall_impl(SYS_unlink, path);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_unlink, path);
 #elif defined(SYS_unlinkat)
-  long ret = __llvm_libc::syscall_impl(SYS_unlinkat, AT_FDCWD, path, 0);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_unlinkat, AT_FDCWD, path, 0);
 #else
 #error "unlink and unlinkat syscalls not available."
 #endif
 
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/unlinkat.cpp

 
 #include <fcntl.h>
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, unlinkat, (int dfd, const char *path, int flags)) {
 #ifdef SYS_unlinkat
-  long ret = __llvm_libc::syscall_impl(SYS_unlinkat, dfd, path, flags);
+  int ret = __llvm_libc::syscall_impl<int>(SYS_unlinkat, dfd, path, flags);
 #else
 #error "unlinkat syscalls not available."
 #endif
 
   if (ret < 0) {
     libc_errno = -ret;
     return -1;
   }
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/write.cpp

 #include "src/__support/common.h"
 #include "src/errno/libc_errno.h"
 
 #include <sys/syscall.h> // For syscall numbers.
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(ssize_t, write, (int fd, const void *buf, size_t count)) {
-  long ret = __llvm_libc::syscall_impl(SYS_write, fd, buf, count);
+  ssize_t ret = __llvm_libc::syscall_impl<ssize_t>(SYS_write, fd, buf, count);
   if (ret < 0) {
-    libc_errno = -ret;
+    libc_errno = static_cast<int>(-ret);
     return -1;
   }
   return ret;
 }
 
 } // namespace __llvm_libc

libc/startup/linux/aarch64/start.cpp

void init_tls(TLSDescriptor &tls_descriptor) {
   if (diff != 0)
     padding += (ALIGNMENT_MASK - diff) + 1;
 
   uintptr_t alloc_size = size_of_pointers + padding + app.tls.size;
 
   // We cannot call the mmap function here as the functions set errno on
   // failure. Since errno is implemented via a thread local variable, we cannot
   // use errno before TLS is setup.
-  long mmap_ret_val = __llvm_libc::syscall_impl(
+  long mmap_ret_val = __llvm_libc::syscall_impl<long>(
       MMAP_SYSCALL_NUMBER, nullptr, alloc_size, PROT_READ | PROT_WRITE,
       MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
   // We cannot check the return value with MAP_FAILED as that is the return
   // of the mmap function and not the mmap syscall.
   if (mmap_ret_val < 0 && static_cast<uintptr_t>(mmap_ret_val) > -app.pageSize)
-    __llvm_libc::syscall_impl(SYS_exit, 1);
+    __llvm_libc::syscall_impl<long>(SYS_exit, 1);
   uintptr_t thread_ptr = uintptr_t(reinterpret_cast<uintptr_t *>(mmap_ret_val));
   uintptr_t tls_addr = thread_ptr + size_of_pointers + padding;
   __llvm_libc::inline_memcpy(reinterpret_cast<char *>(tls_addr),
                              reinterpret_cast<const char *>(app.tls.address),
                              app.tls.init_size);
   tls_descriptor.size = alloc_size;
   tls_descriptor.addr = thread_ptr;
   tls_descriptor.tp = thread_ptr;
 }
 
 void cleanup_tls(uintptr_t addr, uintptr_t size) {
   if (size == 0)
     return;
-  __llvm_libc::syscall_impl(SYS_munmap, addr, size);
+  __llvm_libc::syscall_impl<long>(SYS_munmap, addr, size);
 }
 
 static void set_thread_ptr(uintptr_t val) { __arm_wsr64("tpidr_el0", val); }
 
 using InitCallback = void(int, char **, char **);
 using FiniCallback = void(void);
 
 extern "C" {

 
 // TODO: Would be nice to use the aux entry structure from elf.h when available.
 struct AuxEntry {
   uint64_t type;
   uint64_t value;
 };
 
 __attribute__((noinline)) static void do_start() {
-  auto tid = __llvm_libc::syscall_impl(SYS_gettid);
+  auto tid = __llvm_libc::syscall_impl<long>(SYS_gettid);
   if (tid <= 0)
-    __llvm_libc::syscall_impl(SYS_exit, 1);
-  __llvm_libc::main_thread_attrib.tid = tid;
+    __llvm_libc::syscall_impl<long>(SYS_exit, 1);
+  __llvm_libc::main_thread_attrib.tid = static_cast<int>(tid);
 
   // After the argv array, is a 8-byte long NULL value before the array of env
   // values. The end of the env values is marked by another 8-byte long NULL
   // value. We step over it (the "+ 1" below) to get to the env values.
   uint64_t *env_ptr = app.args->argv + app.args->argc + 1;
   uint64_t *env_end_marker = env_ptr;
   app.envPtr = env_ptr;
   while (*env_end_marker)
__attribute__((noinline)) static void do_start() {
 
   // We want the fini array callbacks to be run after other atexit
   // callbacks are run. So, we register them before running the init
   // array callbacks as they can potentially register their own atexit
   // callbacks.
   __llvm_libc::atexit(&__llvm_libc::call_fini_array_callbacks);
 
   __llvm_libc::call_init_array_callbacks(
-      app.args->argc, reinterpret_cast<char **>(app.args->argv),
+      static_cast<int>(app.args->argc),
+      reinterpret_cast<char **>(app.args->argv),
       reinterpret_cast<char **>(env_ptr));
 
-  int retval = main(app.args->argc, reinterpret_cast<char **>(app.args->argv),
+  int retval = main(static_cast<int>(app.args->argc),
+                    reinterpret_cast<char **>(app.args->argv),
                     reinterpret_cast<char **>(env_ptr));
 
   // TODO: TLS cleanup should be done after all other atexit callbacks
   // are run. So, register a cleanup callback for it with atexit before
   // everything else.
   __llvm_libc::cleanup_tls(tls.addr, tls.size);
   __llvm_libc::exit(retval);
 }

libc/startup/linux/riscv64/start.cpp

void init_tls(TLSDescriptor &tls_descriptor) {
   if (diff != 0)
     padding += (ALIGNMENT_MASK - diff) + 1;
 
   uintptr_t alloc_size = size_of_pointers + padding + app.tls.size;
 
   // We cannot call the mmap function here as the functions set errno on
   // failure. Since errno is implemented via a thread local variable, we cannot
   // use errno before TLS is setup.
-  long mmap_ret_val = __llvm_libc::syscall_impl(
+  long mmap_ret_val = __llvm_libc::syscall_impl<long>(
       MMAP_SYSCALL_NUMBER, nullptr, alloc_size, PROT_READ | PROT_WRITE,
       MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
   // We cannot check the return value with MAP_FAILED as that is the return
   // of the mmap function and not the mmap syscall.
   if (mmap_ret_val < 0 && static_cast<uintptr_t>(mmap_ret_val) > -app.pageSize)
-    __llvm_libc::syscall_impl(SYS_exit, 1);
+    __llvm_libc::syscall_impl<long>(SYS_exit, 1);
   uintptr_t thread_ptr = uintptr_t(reinterpret_cast<uintptr_t *>(mmap_ret_val));
   uintptr_t tls_addr = thread_ptr + size_of_pointers + padding;
   __llvm_libc::inline_memcpy(reinterpret_cast<char *>(tls_addr),
                              reinterpret_cast<const char *>(app.tls.address),
                              app.tls.init_size);
   tls_descriptor.size = alloc_size;
   tls_descriptor.addr = thread_ptr;
   tls_descriptor.tp = tls_addr;
 }
 
 void cleanup_tls(uintptr_t addr, uintptr_t size) {
   if (size == 0)
     return;
-  __llvm_libc::syscall_impl(SYS_munmap, addr, size);
+  __llvm_libc::syscall_impl<long>(SYS_munmap, addr, size);
 }
 
 static void set_thread_ptr(uintptr_t val) {
   LIBC_INLINE_ASM("ld tp, %0\n\t" : : "m"(val));
 }
 
 using InitCallback = void(int, char **, char **);
 using FiniCallback = void(void);
struct AuxEntry {
   uint64_t value;
 };
 
 __attribute__((noinline)) static void do_start() {
   LIBC_INLINE_ASM(".option push\n\t"
                   ".option norelax\n\t"
                   "lla gp, __global_pointer$\n\t"
                   ".option pop\n\t");
-  auto tid = __llvm_libc::syscall_impl(SYS_gettid);
+  auto tid = __llvm_libc::syscall_impl<long>(SYS_gettid);
   if (tid <= 0)
-    __llvm_libc::syscall_impl(SYS_exit, 1);
-  __llvm_libc::main_thread_attrib.tid = tid;
+    __llvm_libc::syscall_impl<long>(SYS_exit, 1);
+  __llvm_libc::main_thread_attrib.tid = static_cast<int>(tid);
 
   // After the argv array, is a 8-byte long NULL value before the array of env
   // values. The end of the env values is marked by another 8-byte long NULL
   // value. We step over it (the "+ 1" below) to get to the env values.
   uint64_t *env_ptr = app.args->argv + app.args->argc + 1;
   uint64_t *env_end_marker = env_ptr;
   app.envPtr = env_ptr;
   while (*env_end_marker)
__attribute__((noinline)) static void do_start() {
 
   // We want the fini array callbacks to be run after other atexit
   // callbacks are run. So, we register them before running the init
   // array callbacks as they can potentially register their own atexit
   // callbacks.
   __llvm_libc::atexit(&__llvm_libc::call_fini_array_callbacks);
 
   __llvm_libc::call_init_array_callbacks(
-      app.args->argc, reinterpret_cast<char **>(app.args->argv),
+      static_cast<int>(app.args->argc),
+      reinterpret_cast<char **>(app.args->argv),
       reinterpret_cast<char **>(env_ptr));
 
-  int retval = main(app.args->argc, reinterpret_cast<char **>(app.args->argv),
+  int retval = main(static_cast<int>(app.args->argc),
+                    reinterpret_cast<char **>(app.args->argv),
                     reinterpret_cast<char **>(env_ptr));
 
   // TODO: TLS cleanup should be done after all other atexit callbacks
   // are run. So, register a cleanup callback for it with atexit before
   // everything else.
   __llvm_libc::cleanup_tls(tls.addr, tls.size);
   __llvm_libc::exit(retval);
 }
 
 extern "C" void _start() {
   // Fetch the args using the frame pointer.
   app.args = reinterpret_cast<__llvm_libc::Args *>(
       reinterpret_cast<uintptr_t *>(__builtin_frame_address(0)));
   do_start();
 }

libc/startup/linux/x86_64/start.cpp

void init_tls(TLSDescriptor &tls_descriptor) {
   // Per the x86_64 TLS ABI, the entry pointed to by the thread pointer is the
   // address of the TLS block. So, we add more size to accomodate this address
   // entry.
   uintptr_t tlsSizeWithAddr = tlsSize + sizeof(uintptr_t);
 
   // We cannot call the mmap function here as the functions set errno on
   // failure. Since errno is implemented via a thread local variable, we cannot
   // use errno before TLS is setup.
-  long mmapRetVal = __llvm_libc::syscall_impl(
+  long mmapRetVal = __llvm_libc::syscall_impl<long>(
       mmapSyscallNumber, nullptr, tlsSizeWithAddr, PROT_READ | PROT_WRITE,
       MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
   // We cannot check the return value with MAP_FAILED as that is the return
   // of the mmap function and not the mmap syscall.
   if (mmapRetVal < 0 && static_cast<uintptr_t>(mmapRetVal) > -app.pageSize)
-    __llvm_libc::syscall_impl(SYS_exit, 1);
+    __llvm_libc::syscall_impl<long>(SYS_exit, 1);
   uintptr_t *tlsAddr = reinterpret_cast<uintptr_t *>(mmapRetVal);
 
   // x86_64 TLS faces down from the thread pointer with the first entry
   // pointing to the address of the first real TLS byte.
   uintptr_t endPtr = reinterpret_cast<uintptr_t>(tlsAddr) + tlsSize;
   *reinterpret_cast<uintptr_t *>(endPtr) = endPtr;
 
   __llvm_libc::inline_memcpy(reinterpret_cast<char *>(tlsAddr),
                              reinterpret_cast<const char *>(app.tls.address),
                              app.tls.init_size);
 
   tls_descriptor = {tlsSizeWithAddr, uintptr_t(tlsAddr), endPtr};
   return;
 }
 
 void cleanup_tls(uintptr_t addr, uintptr_t size) {
   if (size == 0)
     return;
-  __llvm_libc::syscall_impl(SYS_munmap, addr, size);
+  __llvm_libc::syscall_impl<long>(SYS_munmap, addr, size);
 }
 
 // Sets the thread pointer to |val|. Returns true on success, false on failure.
 static bool set_thread_ptr(uintptr_t val) {
   return __llvm_libc::syscall_impl(SYS_arch_prctl, ARCH_SET_FS, val) != -1;
 }
 
 using InitCallback = void(int, char **, char **);
extern "C" void _start() {
   // NOTE: Compiler attributes for alignment do not help here as the stack
   // pointer on entry to this _start function is controlled by the OS. In fact,
   // compilers can generate code assuming the alignment as required by the ABI.
   // If the stack pointers as setup by the OS are already aligned, then the
   // following code is a NOP.
   __asm__ __volatile__("andq $0xfffffffffffffff0, %rsp\n\t");
   __asm__ __volatile__("andq $0xfffffffffffffff0, %rbp\n\t");
 
-  auto tid = __llvm_libc::syscall_impl(SYS_gettid);
+  auto tid = __llvm_libc::syscall_impl<long>(SYS_gettid);
   if (tid <= 0)
-    __llvm_libc::syscall_impl(SYS_exit, 1);
-  __llvm_libc::main_thread_attrib.tid = tid;
+    __llvm_libc::syscall_impl<long>(SYS_exit, 1);
+  __llvm_libc::main_thread_attrib.tid = static_cast<int>(tid);
 
   // After the argv array, is a 8-byte long NULL value before the array of env
   // values. The end of the env values is marked by another 8-byte long NULL
   // value. We step over it (the "+ 1" below) to get to the env values.
   uint64_t *env_ptr = app.args->argv + app.args->argc + 1;
   uint64_t *env_end_marker = env_ptr;
   app.envPtr = env_ptr;
   while (*env_end_marker)
for (uintptr_t i = 0; i < programHdrCount; ++i) {
     app.tls.size = phdr->p_memsz;
     app.tls.init_size = phdr->p_filesz;
     app.tls.align = phdr->p_align;
   }
 
   __llvm_libc::TLSDescriptor tls;
   __llvm_libc::init_tls(tls);
   if (tls.size != 0 && !__llvm_libc::set_thread_ptr(tls.tp))
-    __llvm_libc::syscall_impl(SYS_exit, 1);
+    __llvm_libc::syscall_impl<long>(SYS_exit, 1);
 
   __llvm_libc::self.attrib = &__llvm_libc::main_thread_attrib;
   __llvm_libc::main_thread_attrib.atexit_callback_mgr =
       __llvm_libc::internal::get_thread_atexit_callback_mgr();
 
   // We want the fini array callbacks to be run after other atexit
   // callbacks are run. So, we register them before running the init
   // array callbacks as they can potentially register their own atexit
   // callbacks.
   __llvm_libc::atexit(&__llvm_libc::call_fini_array_callbacks);
 
   __llvm_libc::call_init_array_callbacks(
-      app.args->argc, reinterpret_cast<char **>(app.args->argv),
+      static_cast<int>(app.args->argc),
+      reinterpret_cast<char **>(app.args->argv),
       reinterpret_cast<char **>(env_ptr));
 
-  int retval = main(app.args->argc, reinterpret_cast<char **>(app.args->argv),
+  int retval = main(static_cast<int>(app.args->argc),
+                    reinterpret_cast<char **>(app.args->argv),
                     reinterpret_cast<char **>(env_ptr));
 
   // TODO: TLS cleanup should be done after all other atexit callbacks
   // are run. So, register a cleanup callback for it with atexit before
   // everything else.
   __llvm_libc::cleanup_tls(tls.addr, tls.size);
   __llvm_libc::exit(retval);
 }

libc/test/src/__support/OSUtil/linux/x86_64/syscall_test.cpp

 #include "test/UnitTest/Test.h"
 
 TEST(LlvmLibcX86_64_SyscallTest, APITest) {
   // We only do a signature test here. Actual functionality tests are
   // done by the unit tests of the syscall wrappers like mmap.
 
   using __llvm_libc::cpp::function;
 
-  function<long(long)> f([](long n) { return __llvm_libc::syscall_impl(n); });
+  function<long(long)> f(
+      [](long n) { return __llvm_libc::syscall_impl<long>(n); });
   function<long(long, long)> f1(
-      [](long n, long a1) { return __llvm_libc::syscall_impl(n, a1); });
+      [](long n, long a1) { return __llvm_libc::syscall_impl<long>(n, a1); });
   function<long(long, long, long)> f2([](long n, long a1, long a2) {
-    return __llvm_libc::syscall_impl(n, a1, a2);
+    return __llvm_libc::syscall_impl<long>(n, a1, a2);
   });
   function<long(long, long, long, long)> f3(
       [](long n, long a1, long a2, long a3) {
-        return __llvm_libc::syscall_impl(n, a1, a2, a3);
+        return __llvm_libc::syscall_impl<long>(n, a1, a2, a3);
       });
   function<long(long, long, long, long, long)> f4(
       [](long n, long a1, long a2, long a3, long a4) {
-        return __llvm_libc::syscall_impl(n, a1, a2, a3, a4);
+        return __llvm_libc::syscall_impl<long>(n, a1, a2, a3, a4);
       });
   function<long(long, long, long, long, long, long)> f5(
       [](long n, long a1, long a2, long a3, long a4, long a5) {
-        return __llvm_libc::syscall_impl(n, a1, a2, a3, a4, a5);
+        return __llvm_libc::syscall_impl<long>(n, a1, a2, a3, a4, a5);
       });
   function<long(long, long, long, long, long, long, long)> f6(
       [](long n, long a1, long a2, long a3, long a4, long a5, long a6) {
-        return __llvm_libc::syscall_impl(n, a1, a2, a3, a4, a5, a6);
+        return __llvm_libc::syscall_impl<long>(n, a1, a2, a3, a4, a5, a6);
       });
 
   function<long(long, void *)> not_long_type(
-      [](long n, void *a1) { return __llvm_libc::syscall_impl(n, a1); });
+      [](long n, void *a1) { return __llvm_libc::syscall_impl<long>(n, a1); });
 }

libc/test/src/sched/affinity_test.cpp

 
 #include <sched.h>
 #include <sys/syscall.h>
 
 TEST(LlvmLibcSchedAffinityTest, SmokeTest) {
   cpu_set_t mask;
   libc_errno = 0;
   using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
-  pid_t tid = __llvm_libc::syscall_impl(SYS_gettid);
+  pid_t tid = __llvm_libc::syscall_impl<pid_t>(SYS_gettid);
   ASSERT_GT(tid, pid_t(0));
   // We just get and set the same mask.
   ASSERT_THAT(__llvm_libc::sched_getaffinity(tid, sizeof(cpu_set_t), &mask),
               Succeeds(0));
   ASSERT_THAT(__llvm_libc::sched_setaffinity(tid, sizeof(cpu_set_t), &mask),
               Succeeds(0));
 }
 
 TEST(LlvmLibcSchedAffinityTest, BadMask) {
   using __llvm_libc::testing::ErrnoSetterMatcher::Fails;
-  pid_t tid = __llvm_libc::syscall_impl(SYS_gettid);
+  pid_t tid = __llvm_libc::syscall_impl<pid_t>(SYS_gettid);
 
   libc_errno = 0;
   ASSERT_THAT(__llvm_libc::sched_getaffinity(tid, sizeof(cpu_set_t), nullptr),
               Fails(EFAULT));
 
   libc_errno = 0;
   ASSERT_THAT(__llvm_libc::sched_setaffinity(tid, sizeof(cpu_set_t), nullptr),
               Fails(EFAULT));
 
   libc_errno = 0;
 }

libc/test/src/sched/cpu_count_test.cpp

 
 #include <sched.h>
 #include <sys/syscall.h>
 
 TEST(LlvmLibcSchedCpuCountTest, SmokeTest) {
   cpu_set_t mask;
   libc_errno = 0;
   using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
-  pid_t tid = __llvm_libc::syscall_impl(SYS_gettid);
+  pid_t tid = __llvm_libc::syscall_impl<pid_t>(SYS_gettid);
   ASSERT_GT(tid, pid_t(0));
   ASSERT_THAT(__llvm_libc::sched_getaffinity(tid, sizeof(cpu_set_t), &mask),
               Succeeds(0));
 
   // CPU_COUNT is a macro, but it expands to an LLVM-libc internal function that
   // needs to be in the appropriate namespace for the test.
   int num_cpus = __llvm_libc::CPU_COUNT(&mask);
   ASSERT_GT(num_cpus, 0);
   ASSERT_LE(num_cpus, int(sizeof(cpu_set_t) * sizeof(unsigned long)));
 }

libc/test/src/signal/kill_test.cpp

 #include "test/UnitTest/Test.h"
 
 #include <signal.h>
 #include <sys/syscall.h> // For syscall numbers.
 
 using __llvm_libc::testing::ErrnoSetterMatcher::Succeeds;
 
 TEST(LlvmLibcKillTest, TargetSelf) {
-  pid_t parent_pid = __llvm_libc::syscall_impl(SYS_getpid);
+  pid_t parent_pid = __llvm_libc::syscall_impl<pid_t>(SYS_getpid);
   ASSERT_THAT(__llvm_libc::kill(parent_pid, 0), Succeeds(0));
 
   EXPECT_DEATH(
       [] {
-        pid_t child_pid = __llvm_libc::syscall_impl(SYS_getpid);
+        pid_t child_pid = __llvm_libc::syscall_impl<pid_t>(SYS_getpid);
         __llvm_libc::kill(child_pid, SIGKILL);
       },
       WITH_SIGNAL(SIGKILL));
 }

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

libc_support_library(
     hdrs = ["src/__support/OSUtil/syscall.h"],
     textual_hdrs = [
         "src/__support/OSUtil/linux/syscall.h",
         "src/__support/OSUtil/linux/aarch64/syscall.h",
         "src/__support/OSUtil/linux/x86_64/syscall.h",
     ],
     deps = [
         ":__support_common",
+        ":__support_cpp_bit",
         ":libc_root",
     ],
 )
 
 libc_support_library(
     name = "__support_osutil_io",
     hdrs = ["src/__support/OSUtil/io.h"],
     textual_hdrs = [