[libc] Add implementation of the POSIX getcwd function.

[michaelrj]

LGTM

libc/config/linux/x86_64/entrypoints.txt

set(TARGET_LIBC_ENTRYPOINTS
     libc.src.unistd.close
     libc.src.unistd.dup
     libc.src.unistd.dup2
     libc.src.unistd.dup3
     libc.src.unistd.execve
     libc.src.unistd.fchdir
     libc.src.unistd.fsync
     libc.src.unistd.ftruncate
+    libc.src.unistd.getcwd
     libc.src.unistd.geteuid
     libc.src.unistd.getpid
     libc.src.unistd.getppid
     libc.src.unistd.getuid
     libc.src.unistd.isatty
     libc.src.unistd.link
     libc.src.unistd.linkat
     libc.src.unistd.lseek

libc/spec/posix.td

[
           [ArgSpec<IntType>, ArgSpec<IntType>, ArgSpec<IntType>]
         >,
         FunctionSpec<
           "fchdir",
           RetValSpec<IntType>,
           [ArgSpec<IntType>]
         >,
         FunctionSpec<
+          "getcwd",
+          RetValSpec<CharPtr>,
+          [ArgSpec<CharPtr>, ArgSpec<SizeTType>]
+        >,
+        FunctionSpec<
           "close",
           RetValSpec<IntType>,
           [ArgSpec<IntType>]
         >,
         FunctionSpec<
           "execv",
           RetValSpec<IntType>,
           [ArgSpec<ConstCharPtr>, ArgSpec<ExecArgvT>]

libc/src/string/CMakeLists.txt

 add_subdirectory(memory_utils)
 
 add_header_library(
   string_utils
   HDRS
     string_utils.h
   DEPENDS
+    libc.include.stdlib
     libc.src.__support.CPP.bitset
     .memory_utils.memcpy_implementation
     .memory_utils.bzero_implementation
 )
 
 add_entrypoint_object(
   memccpy
   SRCS

libc/src/string/strdup.cpp

 
 #include "src/__support/common.h"
 
 #include <stdlib.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(char *, strdup, (const char *src)) {
-  if (src == nullptr) {
-    return nullptr;
-  }
-  size_t len = internal::string_length(src) + 1;
-  char *dest = reinterpret_cast<char *>(::malloc(len));
-  if (dest == nullptr) {
-    return nullptr;
-  }
-  inline_memcpy(dest, src, len);
-  return dest;
+  return internal::strdup(src);
 }
 
 } // namespace __llvm_libc

libc/src/string/string_utils.h

 //===-- String utils --------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LIBC_SRC_STRING_STRING_UTILS_H
 #define LIBC_SRC_STRING_STRING_UTILS_H
 
 #include "src/__support/CPP/bitset.h"
 #include "src/__support/common.h"
-#include "src/string/memory_utils/memcpy_implementations.h"
 #include "src/string/memory_utils/bzero_implementations.h"
-#include <stddef.h> // size_t
+#include "src/string/memory_utils/memcpy_implementations.h"
+#include <stddef.h> // For size_t
+#include <stdlib.h> // For malloc and free
 
 namespace __llvm_libc {
 namespace internal {
 
 // Returns the length of a string, denoted by the first occurrence
 // of a null terminator.
 static inline size_t string_length(const char *src) {
   size_t length;
static inline size_t strlcpy(char *__restrict dst, const char *__restrict src,
   if (!size)
     return len;
   size_t n = len < size - 1 ? len : size - 1;
   inline_memcpy(dst, src, n);
   inline_bzero(dst + n, size - n);
   return len;
 }
 
+inline char *strdup(const char *src) {
+  if (src == nullptr)
+    return nullptr;
+  size_t len = string_length(src) + 1;
+  char *newstr = reinterpret_cast<char *>(::malloc(len));
+  if (newstr == nullptr)
+    return nullptr;
+  inline_memcpy(newstr, src, len);
+  return newstr;
+}
+
 } // namespace internal
 } // namespace __llvm_libc
 
 #endif //  LIBC_SRC_STRING_STRING_UTILS_H

libc/src/unistd/CMakeLists.txt

 add_entrypoint_object(
   ftruncate
   ALIAS
   DEPENDS
     .${LIBC_TARGET_OS}.ftruncate
 )
 
 add_entrypoint_object(
+  getcwd
+  ALIAS
+  DEPENDS
+    .${LIBC_TARGET_OS}.getcwd
+)
+
+add_entrypoint_object(
   getpid
   ALIAS
   DEPENDS
     .${LIBC_TARGET_OS}.getpid
 )
 
 add_entrypoint_object(
   getppid

libc/src/unistd/getcwd.h

+//===-- Implementation header for getcwd ------------------------*- 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_UNISTD_GETCWD_H
+#define LLVM_LIBC_SRC_UNISTD_GETCWD_H
+
+#include <unistd.h>
+
+namespace __llvm_libc {
+
+char *getcwd(char *buf, size_t size);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_UNISTD_GETCWD_H

libc/src/unistd/linux/CMakeLists.txt

add_entrypoint_object(
   DEPENDS
     libc.include.unistd
     libc.include.sys_syscall
     libc.src.__support.OSUtil.osutil
     libc.src.errno.errno
 )
 
 add_entrypoint_object(
+  getcwd
+  SRCS
+    getcwd.cpp
+  HDRS
+    ../getcwd.h
+  DEPENDS
+    libc.include.errno
+    libc.include.stdlib
+    libc.include.unistd
+    libc.include.sys_syscall
+    libc.src.__support.OSUtil.osutil
+    libc.src.errno.errno
+)
+
+add_entrypoint_object(
   geteuid
   SRCS
     geteuid.cpp
   HDRS
     ../geteuid.h
   DEPENDS
     libc.include.unistd
     libc.include.sys_syscall

libc/src/unistd/linux/getcwd.cpp

+//===-- Linux implementation of getcwd ------------------------------------===//
+//
+// 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/getcwd.h"
+
+#include "src/__support/OSUtil/syscall.h" // For internal syscall function.
+#include "src/__support/common.h"
+#include "src/string/string_utils.h" // For strdup.
+
+#include <errno.h>
+#include <linux/limits.h> // This is safe to include without any name pollution.
+#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);
+  if (ret < 0) {
+    errno = -ret;
+    return false;
+  } else if (ret == 0 || buf[0] != '/') {
+    errno = ENOENT;
+    return false;
+  }
+  return true;
+}
+
+} // anonymous namespace
+
+LLVM_LIBC_FUNCTION(char *, getcwd, (char *buf, size_t size)) {
+  if (buf == nullptr) {
+    // We match glibc's behavior here and return the cwd in a malloc-ed buffer.
+    // We will allocate a static buffer of size PATH_MAX first and fetch the cwd
+    // into it. This way, if the syscall fails, we avoid unnecessary malloc
+    // and free.
+    char pathbuf[PATH_MAX];
+    if (!getcwd_syscall(pathbuf, PATH_MAX))
+      return nullptr;
+    char *cwd = internal::strdup(pathbuf);
+    if (cwd == nullptr) {
+      errno = ENOMEM;
+      return nullptr;
+    }
+    return cwd;
+  } else if (size == 0) {
+    errno = EINVAL;
+    return nullptr;
+  }
+
+  // TODO: When buf is not sufficient, evaluate the full cwd path using
+  // alternate approaches.
+
+  if (!getcwd_syscall(buf, size))
+    return nullptr;
+  return buf;
+}
+
+} // namespace __llvm_libc

libc/test/integration/src/unistd/CMakeLists.txt

 add_custom_target(unistd-integration-tests)
 add_dependencies(libc-integration-tests unistd-integration-tests)
 
 add_integration_test(
+  getcwd_test
+  SUITE
+    unistd-integration-tests
+  SRCS
+    getcwd_test.cpp
+  LOADER
+    libc.loader.linux.crt1
+  DEPENDS
+    libc.include.errno
+    libc.src.__support.CPP.string_view
+    libc.src.stdlib.getenv
+    libc.src.unistd.getcwd
+)
+
+add_integration_test(
   fork_test
   SUITE
     unistd-integration-tests
   SRCS
     fork_test.cpp
   LOADER
     libc.loader.linux.crt1
   DEPENDS

libc/test/integration/src/unistd/getcwd_test.cpp

+//===-- Unittests for getcwd ----------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "src/__support/CPP/string_view.h"
+#include "src/stdlib/getenv.h"
+#include "src/unistd/getcwd.h"
+
+#include "utils/IntegrationTest/test.h"
+
+#include <errno.h>
+
+using __llvm_libc::cpp::string_view;
+
+TEST_MAIN(int argc, char **argv, char **envp) {
+  char buffer[1024];
+  ASSERT_TRUE(string_view(__llvm_libc::getenv("PWD")) ==
+              __llvm_libc::getcwd(buffer, 1024));
+
+  // nullptr buffer
+  char *cwd = __llvm_libc::getcwd(nullptr, 0);
+  ASSERT_TRUE(string_view(__llvm_libc::getenv("PWD")) == cwd);
+  free(cwd);
+
+  // Bad size
+  cwd = __llvm_libc::getcwd(buffer, 0);
+  ASSERT_TRUE(cwd == nullptr);
+  ASSERT_EQ(errno, EINVAL);
+  errno = 0;
+
+  // Insufficient size
+  cwd = __llvm_libc::getcwd(buffer, 2);
+  ASSERT_TRUE(cwd == nullptr);
+  int err = errno;
+  ASSERT_EQ(err, ERANGE);
+
+  return 0;
+}