[libc] Enable __llvm_libc_syscall and fork on riscv64.

[mikhail.ramalho]

Summary

This patch enables the remaining calls from unistd.

The test cases had to be updated to:

1. Use SYS_symlinkat if SYS_symlink is not available
2. Use SYS_readlinkat if SYS_readlink is not available
3. Use SYS_unlinkat if SYS_unlink is not available
4. Use SYS_openat if SYS_open is not available

We also abort compilation if neither of the syscalls mentioned above are
available.

[sivachandra]

I have updated the commit message to make it clear that this change is for riscv64.

libc/config/linux/riscv64/entrypoints.txt

list(APPEND TARGET_LIBC_ENTRYPOINTS
     libc.src.time.gmtime_r
     libc.src.time.mktime
     libc.src.time.nanosleep
     libc.src.time.time
 
     # unistd.h entrypoints
     libc.src.unistd.environ
     libc.src.unistd.execv
+    libc.src.unistd.fork
+    libc.src.unistd.__llvm_libc_syscall
     libc.src.unistd.getopt
     libc.src.unistd.optarg
     libc.src.unistd.optind
     libc.src.unistd.optopt
     libc.src.unistd.opterr
 
     # sys/select.h entrypoints
     libc.src.sys.select.select
   )
 endif()
 
 set(TARGET_LLVMLIBC_ENTRYPOINTS
   ${TARGET_LIBC_ENTRYPOINTS}
   ${TARGET_LIBM_ENTRYPOINTS}
 )

libc/src/unistd/linux/fork.cpp

 //===-- Linux implementation of fork --------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "src/unistd/fork.h"
 
 #include "src/__support/OSUtil/syscall.h" // For internal syscall function.
 #include "src/__support/common.h"
 #include "src/__support/threads/fork_callbacks.h"
 #include "src/__support/threads/thread.h" // For thread self object
 
 #include "src/errno/libc_errno.h"
+#include <signal.h>      // For SIGCHLD
 #include <sys/syscall.h> // For syscall numbers.
 
 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)) {

libc/test/src/unistd/syscall_test.cpp

TEST(LlvmLibcSyscallTest, TrivialCall) {
   ASSERT_GE(__llvm_libc::syscall(SYS_gettid), 0l);
   ASSERT_EQ(libc_errno, 0);
 }
 
 TEST(LlvmLibcSyscallTest, SymlinkCreateDestroy) {
   constexpr const char LINK_VAL[] = "syscall_readlink_test_value";
   constexpr const char LINK[] = "testdata/syscall_readlink.test.link";
 
+#ifdef SYS_symlink
   ASSERT_GE(__llvm_libc::syscall(SYS_symlink, LINK_VAL, LINK), 0l);
+#elif defined(SYS_symlinkat)
+  ASSERT_GE(__llvm_libc::syscall(SYS_symlinkat, LINK_VAL, AT_FDCWD, LINK), 0l);
+#else
+#error "Symlink syscalls not available."
+#endif
   ASSERT_EQ(libc_errno, 0);
 
   char buf[sizeof(LINK_VAL)];
 
+#ifdef SYS_readlink
   ASSERT_GE(__llvm_libc::syscall(SYS_readlink, LINK, buf, sizeof(buf)), 0l);
+#elif defined(SYS_readlinkat)
+  ASSERT_GE(
+      __llvm_libc::syscall(SYS_readlinkat, AT_FDCWD, LINK, buf, sizeof(buf)),
+      0l);
+#endif
   ASSERT_EQ(libc_errno, 0);
 
+#ifdef SYS_unlink
   ASSERT_GE(__llvm_libc::syscall(SYS_unlink, LINK), 0l);
+#elif defined(SYS_unlinkat)
+  ASSERT_GE(__llvm_libc::syscall(SYS_unlinkat, AT_FDCWD, LINK, 0), 0l);
+#else
+#error "Unlink syscalls not available."
+#endif
   ASSERT_EQ(libc_errno, 0);
 }
 
 TEST(LlvmLibcSyscallTest, FileReadWrite) {
   constexpr const char HELLO[] = "hello";
   constexpr int HELLO_SIZE = sizeof(HELLO);
 
   constexpr const char *TEST_FILE = "testdata/syscall_pread_pwrite.test";
 
+#ifdef SYS_open
   int fd =
       __llvm_libc::syscall(SYS_open, TEST_FILE, O_WRONLY | O_CREAT, S_IRWXU);
+#elif defined(SYS_openat)
+  int fd = __llvm_libc::syscall(SYS_openat, AT_FDCWD, TEST_FILE,
+                                O_WRONLY | O_CREAT, S_IRWXU);
+#else
+#error "Open syscalls not available to available."
+#endif
   ASSERT_GT(fd, 0);
   ASSERT_EQ(libc_errno, 0);
 
   ASSERT_GE(__llvm_libc::syscall(SYS_pwrite64, fd, HELLO, HELLO_SIZE, 0), 0l);
   ASSERT_EQ(libc_errno, 0);
 
   ASSERT_GE(__llvm_libc::syscall(SYS_fsync, fd), 0l);
   ASSERT_EQ(libc_errno, 0);
constexpr const char *TEST_FILE_LINK_PATH =
       "testdata/syscall_linkat.test.link";
 
   // The test strategy is as follows:
   //   1. Create a normal file
   //   2. Create a link to that file.
   //   3. Open the link to check that the link was created.
   //   4. Cleanup the file and its link.
 
+#ifdef SYS_open
   int write_fd = __llvm_libc::syscall(SYS_open, TEST_FILE_PATH,
                                       O_WRONLY | O_CREAT, S_IRWXU);
+#elif defined(SYS_openat)
+  int write_fd = __llvm_libc::syscall(SYS_openat, AT_FDCWD, TEST_FILE_PATH,
+                                      O_WRONLY | O_CREAT, S_IRWXU);
+#else
+#error "Open syscalls not available to available."
+#endif
   ASSERT_GT(write_fd, 0);
   ASSERT_EQ(libc_errno, 0);
 
   ASSERT_GE(__llvm_libc::syscall(SYS_close, write_fd), 0l);
   ASSERT_EQ(libc_errno, 0);
 
+#ifdef SYS_open
   int dir_fd = __llvm_libc::syscall(SYS_open, TEST_DIR, O_DIRECTORY, 0);
+#elif defined(SYS_openat)
+  int dir_fd =
+      __llvm_libc::syscall(SYS_openat, AT_FDCWD, TEST_DIR, O_DIRECTORY, 0);
+#else
+#error "Open syscalls not available to available."
+#endif
   ASSERT_GT(dir_fd, 0);
   ASSERT_EQ(libc_errno, 0);
 
   ASSERT_GE(__llvm_libc::syscall(SYS_linkat, dir_fd, TEST_FILE, dir_fd,
                                  TEST_FILE_LINK, 0),
             0l);
   ASSERT_EQ(libc_errno, 0);
-
+#ifdef SYS_open
   int link_fd = __llvm_libc::syscall(SYS_open, TEST_FILE_LINK_PATH, O_PATH, 0);
+#elif defined(SYS_openat)
+  int link_fd = __llvm_libc::syscall(SYS_openat, AT_FDCWD, TEST_FILE_LINK_PATH,
+                                     O_PATH, 0);
+#else
+#error "Open syscalls not available to available."
+#endif
   ASSERT_GT(link_fd, 0);
   ASSERT_EQ(libc_errno, 0);
 
+#ifdef SYS_unlink
   ASSERT_GE(__llvm_libc::syscall(SYS_unlink, TEST_FILE_PATH), 0l);
+#elif defined(SYS_unlinkat)
+  ASSERT_GE(__llvm_libc::syscall(SYS_unlinkat, AT_FDCWD, TEST_FILE_PATH, 0),
+            0l);
+#else
+#error "Unlink syscalls not available."
+#endif
   ASSERT_EQ(libc_errno, 0);
 
+#ifdef SYS_unlink
   ASSERT_GE(__llvm_libc::syscall(SYS_unlink, TEST_FILE_LINK_PATH), 0l);
+#elif defined(SYS_unlinkat)
+  ASSERT_GE(
+      __llvm_libc::syscall(SYS_unlinkat, AT_FDCWD, TEST_FILE_LINK_PATH, 0), 0l);
+#else
+#error "Unlink syscalls not available."
+#endif
   ASSERT_EQ(libc_errno, 0);
 
   ASSERT_GE(__llvm_libc::syscall(SYS_close, dir_fd), 0l);
   ASSERT_EQ(libc_errno, 0);
 }