[libc] Add custom operator new to handle allocation failures gracefully.

[sivachandra]

Summary

This patch adds the implementation of the custom operator new functions.
The implementation of the internal strdup has been updated to use
operator new for allocation.

We will make it a policy and document that all allocations have to go
through the libc's own operator new. A future change will also add
operator delete replacements and make it a policy that deallocations in
libc internal code have to go through those replacements.

[lntue]

libc/src/string/allocating_string_utils.h

27

Does it mean that our strdup will always return aligned strings?

[tschuett]

libc/src/string/allocating_string_utils.h

27

Would in this case a malloc returning a result or error type easier to understand and safer?

[sivachandra]

libc/src/string/allocating_string_utils.h

27

Does it mean that our strdup will always return aligned strings?

This is should call the non-aligning operator new. Why do you think it would always calls the aligning operator new?

27

Would in this case a malloc returning a result or error type easier to understand and safer?

Couple of points:

1. We want the libc source code to look as much as possible like a normal modern C++ library.
2. Using new/delete for allocation/deallocation has the added benefit that compilers will synthesize constructor/destructor calls appropriately. It is not relevant here I would think, but uniformity helps improve readability and keeps coding guidlines/principles simple.

[tschuett]

libc/src/string/allocating_string_utils.h

27

std::expected will be modern C++.

[sivachandra]

libc/src/string/allocating_string_utils.h

27

Sure, std::expected is a very good choice in a few places. What I am referring to here is using new/delete vs a custom allocator function which wraps malloc/free.

[sivachandra]

libc/src/string/allocating_string_utils.h

27

I have passed on your suggestion about std::expected here: https://reviews.llvm.org/D139576

[lntue]

libc/src/__support/CPP/new.h

54

What should happen if ac == nullptr? Does second parameter has to be a pointer according to the standard, or it can be a reference instead?

libc/src/string/allocating_string_utils.h

27

Does it mean that our strdup will always return aligned strings?

This is should call the non-aligning operator new. Why do you think it would always calls the aligning operator new?

Never mind, I was looking at wrong signatures.

[sivachandra]

Use reference argument.

[sivachandra]

libc/src/__support/CPP/new.h

54

Ah, good catch! I likely mixed up coding styles here. I have updated to use reference args throughout.

libc/src/__support/CPP/new.h

+//===-- Libc specific custom operator new and delete ------------*- 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_CPP_NEW_H
+#define LLVM_LIBC_SRC_SUPPORT_CPP_NEW_H
+
+#include <stddef.h> // For size_t
+#include <stdlib.h> // For malloc, free etc.
+
+// Defining members in the std namespace is not preferred. But, we do it here
+// so that we can use it to define the operator new which takes std::align_val_t
+// argument.
+namespace std {
+
+enum class align_val_t : size_t {};
+
+} // namespace std
+
+namespace __llvm_libc {
+
+class AllocChecker {
+  bool success = false;
+  AllocChecker &operator=(bool status) {
+    success = status;
+    return *this;
+  }
+
+public:
+  AllocChecker() = default;
+  operator bool() const { return success; }
+
+  static void *alloc(size_t s, AllocChecker &ac) {
+    void *mem = ::malloc(s);
+    ac = (mem != nullptr);
+    return mem;
+  }
+
+  static void *aligned_alloc(size_t s, std::align_val_t align,
+                             AllocChecker &ac) {
+    void *mem = ::aligned_alloc(align, s);
+    ac = (mem != nullptr);
+    return mem;
+  }
+};
+
+} // namespace __llvm_libc
+
+inline void *operator new(size_t size, __llvm_libc::AllocChecker *ac) noexcept {
+  return __llvm_libc::AllocChecker::alloc(size, *ac);
+}
+
+inline void *operator new(size_t size, std::align_val_t align,
+                          __llvm_libc::AllocChecker *ac) noexcept {
+  return __llvm_libc::AllocChecker::aligned_alloc(size, align, *ac);
+}
+
+inline void *operator new[](size_t size,
+                            __llvm_libc::AllocChecker *ac) noexcept {
+  return __llvm_libc::AllocChecker::alloc(size, *ac);
+}
+
+inline void *operator new[](size_t size, std::align_val_t align,
+                            __llvm_libc::AllocChecker *ac) noexcept {
+  return __llvm_libc::AllocChecker::aligned_alloc(size, align, *ac);
+}
+
+#endif // LLVM_LIBC_SRC_SUPPORT_CPP_NEW_H

libc/src/string/CMakeLists.txt

DEPENDS
     .memory_utils.bzero_implementation
 )
 
 add_header_library(
   allocating_string_utils
   HDRS
     allocating_string_utils.h
   DEPENDS
-    libc.include.stdlib
     .memory_utils.memcpy_implementation
+    libc.include.stdlib
+    libc.src.__support.CPP.optional
 )
 
 add_entrypoint_object(
   bcopy
   SRCS
     bcopy.cpp
   HDRS
     bcopy.h
add_entrypoint_object(
   strdup
   SRCS
     strdup.cpp
   HDRS
     strdup.h
   DEPENDS
     .memory_utils.memcpy_implementation
     .string_utils
+    libc.include.errno
     libc.include.stdlib
+    libc.src.errno.errno
 )
 
 add_entrypoint_object(
   strerror
   SRCS
     strerror.cpp
   HDRS
     strerror.h

libc/src/string/allocating_string_utils.h

 //===-- Allocating 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_ALLOCATING_STRING_UTILS_H
 #define LIBC_SRC_STRING_ALLOCATING_STRING_UTILS_H
 
-#include "src/__support/CPP/bitset.h"
-#include "src/__support/common.h"
-#include "src/string/memory_utils/bzero_implementations.h"
-#include "src/string/memory_utils/memcpy_implementations.h"
+#include "src/__support/CPP/new.h"
+#include "src/__support/CPP/optional.h"
+#include "src/string/memory_utils/memcpy_implementations.h" // For string_length
 #include "src/string/string_utils.h"
+
 #include <stddef.h> // For size_t
-#include <stdlib.h> // For malloc
 
 namespace __llvm_libc {
 namespace internal {
 
-inline char *strdup(const char *src) {
+cpp::optional<char *> strdup(const char *src) {
   if (src == nullptr)
-    return nullptr;
+    return cpp::nullopt;
   size_t len = string_length(src) + 1;
-  char *newstr = reinterpret_cast<char *>(::malloc(len));
-  if (newstr == nullptr)
-    return nullptr;
+  AllocChecker ac;
+  char *newstr = new (&ac) char[len];
+  if (!ac)
+    return cpp::nullopt;
   inline_memcpy(newstr, src, len);
   return newstr;
 }
 
 } // namespace internal
 } // namespace __llvm_libc
 
 #endif

libc/src/string/strdup.cpp

 //===-- Implementation of strdup ------------------------------------------===//
 //
 // 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/string/strdup.h"
 #include "src/string/allocating_string_utils.h"
 #include "src/string/memory_utils/memcpy_implementations.h"
 
 #include "src/__support/common.h"
 
+#include <errno.h>
 #include <stdlib.h>
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(char *, strdup, (const char *src)) {
-  return internal::strdup(src);
+  auto dup = internal::strdup(src);
+  if (dup)
+    return *dup;
+  if (src != nullptr)
+    errno = ENOMEM;
+  return nullptr;
 }
 
 } // namespace __llvm_libc

libc/src/unistd/linux/getcwd.cpp

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) {
+    auto cwd = internal::strdup(pathbuf);
+    if (!cwd) {
       errno = ENOMEM;
       return nullptr;
     }
-    return cwd;
+    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/src/string/CMakeLists.txt

 
 add_libc_unittest(
   strdup_test
   SUITE
     libc_string_unittests
   SRCS
     strdup_test.cpp
   DEPENDS
+    libc.include.errno
     libc.include.stdlib
     libc.src.string.strdup
+    libc.src.errno.errno
 )
 
 add_libc_unittest(
   strerror_test
   SUITE
     libc_string_unittests
   SRCS
     strerror_test.cpp

libc/test/src/string/strdup_test.cpp

 //===-- Unittests for strdup ----------------------------------------------===//
 //
 // 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/string/strdup.h"
 #include "utils/UnitTest/Test.h"
+
+#include <errno.h>
 #include <stdlib.h>
 
 TEST(LlvmLibcStrDupTest, EmptyString) {
   const char *empty = "";
 
+  errno = 0;
   char *result = __llvm_libc::strdup(empty);
+  ASSERT_EQ(errno, 0);
+
   ASSERT_NE(result, static_cast<char *>(nullptr));
   ASSERT_NE(empty, const_cast<const char *>(result));
   ASSERT_STREQ(empty, result);
   ::free(result);
 }
 
 TEST(LlvmLibcStrDupTest, AnyString) {
   const char *abc = "abc";
 
+  errno = 0;
   char *result = __llvm_libc::strdup(abc);
+  ASSERT_EQ(errno, 0);
 
   ASSERT_NE(result, static_cast<char *>(nullptr));
   ASSERT_NE(abc, const_cast<const char *>(result));
   ASSERT_STREQ(abc, result);
   ::free(result);
 }
 
 TEST(LlvmLibcStrDupTest, NullPtr) {
-
+  errno = 0;
   char *result = __llvm_libc::strdup(nullptr);
+  ASSERT_EQ(errno, 0);
 
   ASSERT_EQ(result, static_cast<char *>(nullptr));
 }