[libc] add strerror_r function

[michaelrj]

Summary

I've implemente the gnu variant of strerror_r since that seems to be the
one more relevant to what we're trying to do.

libc/config/linux/x86_64/entrypoints.txt

set(TARGET_LIBC_ENTRYPOINTS
     libc.src.string.memset
     libc.src.string.stpcpy
     libc.src.string.stpncpy
     libc.src.string.strcat
     libc.src.string.strchr
     libc.src.string.strcmp
     libc.src.string.strcpy
     libc.src.string.strcspn
+    libc.src.string.strerror
+    libc.src.string.strerror_r
     libc.src.string.strlcat
     libc.src.string.strlcpy
     libc.src.string.strlen
     libc.src.string.strncat
     libc.src.string.strncmp
     libc.src.string.strncpy
     libc.src.string.strnlen
     libc.src.string.strpbrk
     libc.src.string.strrchr
     libc.src.string.strspn
     libc.src.string.strstr
     libc.src.string.strtok
     libc.src.string.strtok_r
 
     # string.h entrypoints that depend on malloc
     libc.src.string.strdup
     libc.src.string.strndup
-    libc.src.string.strerror
 
     # inttypes.h entrypoints
     libc.src.inttypes.imaxabs
     libc.src.inttypes.imaxdiv
     libc.src.inttypes.strtoimax
     libc.src.inttypes.strtoumax
 
     # stdlib.h entrypoints

libc/spec/gnu_ext.td

HeaderSpec String = HeaderSpec<
       [], // Types
       [], // Enumerations
       [ 
         FunctionSpec<
             "memrchr",
             RetValSpec<VoidPtr>,
             [ArgSpec<VoidPtr>, ArgSpec<IntType>, ArgSpec<SizeTType>]
         >,
+        FunctionSpec<
+            "strerror_r",
+            RetValSpec<CharPtr>,
+            [ArgSpec<IntType>, ArgSpec<CharPtr>, ArgSpec<SizeTType>]
+        >,
       ]
   >;
 
   HeaderSpec FEnv = HeaderSpec<
       "fenv.h",
       [], // Macros
       [], // Types
       [], // Enumerations

libc/src/__support/error_to_string.h

 
 #ifndef LLVM_LIBC_SRC_SUPPORT_ERROR_TO_STRING
 #define LLVM_LIBC_SRC_SUPPORT_ERROR_TO_STRING
 
 namespace __llvm_libc {
 
 cpp::string_view get_error_string(int err_num);
 
+cpp::string_view get_error_string(int err_num, cpp::string_view buffer);
+
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SUPPORT_ERROR_TO_STRING

libc/src/__support/error_to_string.cpp

for (size_t cur_err = 0; cur_err < ERR_ARRAY_SIZE; ++cur_err) {
           string_array[string_array_index] = string_mappings[cur_err][i];
         }
       } else {
         err_offsets[cur_err] = -1;
       }
     }
   }
 
-  cpp::string_view get_str(int err_num) const {
+  cpp::string_view get_str(int err_num, cpp::string_view buffer) const {
     if (err_num >= 0 && static_cast<size_t>(err_num) < ERR_ARRAY_SIZE &&
         err_offsets[err_num] != -1) {
       return const_cast<char *>(string_array + err_offsets[err_num]);
     } else {
       // if the buffer can't hold "Unknown error" + ' ' + num_str, then just
       // return "Unknown error".
-      if (BUFFER_SIZE <
+      if (buffer.size() <
           (sizeof("Unknown error") + 1 + IntegerToString::dec_bufsize<int>()))
         return const_cast<char *>("Unknown error");
 
-      cpp::StringStream buffer_stream({error_buffer, BUFFER_SIZE});
+      cpp::StringStream buffer_stream(
+          {const_cast<char *>(buffer.data()), buffer.size()});
       buffer_stream << "Unknown error" << ' ' << err_num << '\0';
       return buffer_stream.str();
     }
   }
 };
 
 static constexpr ErrorMapper error_mapper;
 
 } // namespace internal
 
 cpp::string_view get_error_string(int err_num) {
-  return internal::error_mapper.get_str(err_num);
+  return internal::error_mapper.get_str(
+      err_num, {internal::error_buffer, internal::BUFFER_SIZE});
+}
+
+cpp::string_view get_error_string(int err_num, cpp::string_view buffer) {
+  return internal::error_mapper.get_str(err_num, buffer);
 }
 } // namespace __llvm_libc

libc/src/string/CMakeLists.txt

 add_entrypoint_object(
   strerror
   SRCS
     strerror.cpp
   HDRS
     strerror.h
   DEPENDS
     libc.src.__support.error_to_string
-    libc.src.__support.CPP.span
+)
+
+add_entrypoint_object(
+  strerror_r
+  SRCS
+    strerror_r.cpp
+  HDRS
+    strerror_r.h
+  DEPENDS
+    libc.src.__support.error_to_string
 )
 
 add_entrypoint_object(
   strlcat
   SRCS
     strlcat.cpp
   HDRS
     strlcat.h

libc/src/string/strerror.cpp

 //===-- Implementation of strerror ----------------------------------------===//
 //
 // 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/strerror.h"
-#include "src/__support/CPP/span.h"
 #include "src/__support/common.h"
 #include "src/__support/error_to_string.h"
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(char *, strerror, (int err_num)) {
   return const_cast<char *>(get_error_string(err_num).data());
 }
 
 } // namespace __llvm_libc

libc/src/string/strerror_r.h

-//===-- Definition of a class for mapping errors to strings -----*- C++ -*-===//
+//===-- Implementation header for strerror_r --------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
-#include "src/__support/CPP/string_view.h"
-#include "src/__support/integer_to_string.h"
+#ifndef LLVM_LIBC_SRC_STRING_STRERROR_R_H
+#define LLVM_LIBC_SRC_STRING_STRERROR_R_H
 
-#ifndef LLVM_LIBC_SRC_SUPPORT_ERROR_TO_STRING
-#define LLVM_LIBC_SRC_SUPPORT_ERROR_TO_STRING
+#include <stddef.h>
 
 namespace __llvm_libc {
 
-cpp::string_view get_error_string(int err_num);
+char *strerror_r(int err_num, char *buf, size_t buflen);
 
 } // namespace __llvm_libc
 
-#endif // LLVM_LIBC_SRC_SUPPORT_ERROR_TO_STRING
+#endif // LLVM_LIBC_SRC_STRING_STRERROR_R_H

libc/src/string/strerror_r.cpp

-//===-- Implementation of strerror ----------------------------------------===//
+//===-- Implementation of strerror_r --------------------------------------===//
 //
 // 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/strerror.h"
-#include "src/__support/CPP/span.h"
+#include "src/string/strerror_r.h"
 #include "src/__support/common.h"
 #include "src/__support/error_to_string.h"
 
+#include <stddef.h>
+
 namespace __llvm_libc {
 
-LLVM_LIBC_FUNCTION(char *, strerror, (int err_num)) {
-  return const_cast<char *>(get_error_string(err_num).data());
+// This is the gnu version of strerror_r. The XSI version may be added later.
+LLVM_LIBC_FUNCTION(char *, strerror_r,
+                   (int err_num, char *buf, size_t buflen)) {
+  return const_cast<char *>(get_error_string(err_num, {buf, buflen}).data());
 }
 
 } // namespace __llvm_libc

libc/test/src/string/CMakeLists.txt

add_libc_unittest(
   SUITE
     libc_string_unittests
   SRCS
     strerror_test.cpp
   DEPENDS
     libc.src.string.strerror
 )
 
+
+add_libc_unittest(
+  strerror_r_test
+  SUITE
+    libc_string_unittests
+  SRCS
+    strerror_r_test.cpp
+  DEPENDS
+    libc.src.string.strerror_r
+)
+
 add_libc_unittest(
   strlcat_test
   SUITE
     libc_string_unittests
   SRCS
     strlcat_test.cpp
   DEPENDS
     libc.src.string.strlcat

libc/test/src/string/strerror_r_test.cpp

+//===-- Unittests for strerror --------------------------------------------===//
+//
+// 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/strerror_r.h"
+#include "utils/UnitTest/Test.h"
+
+#include <stddef.h>
+
+// This tests the gnu variant of strerror_r (which returns a char*).
+TEST(LlvmLibcStrErrorRTest, GnuVariantTests) {
+  const size_t BUFF_SIZE = 128;
+  char buffer[BUFF_SIZE];
+  buffer[0] = '\0';
+  // If strerror_r returns a constant string, then it shouldn't affect the
+  // buffer.
+  ASSERT_STREQ(__llvm_libc::strerror_r(0, buffer, BUFF_SIZE), "Success");
+  ASSERT_EQ(buffer[0], '\0');
+
+  // Else it should write the result to the provided buffer.
+  ASSERT_STREQ(__llvm_libc::strerror_r(-1, buffer, BUFF_SIZE),
+               "Unknown error -1");
+  ASSERT_STREQ(buffer, "Unknown error -1");
+}