[libc] Add printf strerror conversion (%m)

libc/config/baremetal/config.json

@@ -16,6 +16,9 @@
     },
     "LIBC_CONF_PRINTF_FLOAT_TO_STR_USE_MEGA_LONG_DOUBLE_TABLE": {
       "value": false
+    },
+    "LIBC_CONF_PRINTF_DISABLE_STRERROR": {
+      "value": true
     }
   },
   "qsort": {

libc/config/config.json

@@ -25,6 +25,10 @@
     "LIBC_CONF_PRINTF_DISABLE_FIXED_POINT": {
       "value": false,
       "doc": "Disable printing fixed point values in printf and friends."
+    },
+    "LIBC_CONF_PRINTF_DISABLE_STRERROR": {
+      "value": false,
+      "doc": "Disable handling of %m to print strerror in printf and friends."
     }
   },
   "scanf": {

libc/config/gpu/config.json

@@ -16,6 +16,9 @@
     },
     "LIBC_CONF_PRINTF_FLOAT_TO_STR_USE_MEGA_LONG_DOUBLE_TABLE": {
       "value": false
+    },
+    "LIBC_CONF_PRINTF_DISABLE_STRERROR": {
+      "value": true
     }
   },
   "scanf": {

libc/docs/configure.rst

@@ -38,6 +38,7 @@ to learn about the defaults for your platform and target.
     - ``LIBC_CONF_PRINTF_DISABLE_FIXED_POINT``: Disable printing fixed point values in printf and friends.
     - ``LIBC_CONF_PRINTF_DISABLE_FLOAT``: Disable printing floating point values in printf and friends.
     - ``LIBC_CONF_PRINTF_DISABLE_INDEX_MODE``: Disable index mode in the printf format string.
+    - ``LIBC_CONF_PRINTF_DISABLE_STRERROR``: Disable handling of %m to print strerror in printf and friends.
     - ``LIBC_CONF_PRINTF_DISABLE_WRITE_INT``: Disable handling of %n in printf format string.
     - ``LIBC_CONF_PRINTF_FLOAT_TO_STR_USE_MEGA_LONG_DOUBLE_TABLE``: Use large table for better printf long double performance.
 * **"pthread" options**

libc/docs/dev/printf_behavior.rst

@@ -213,3 +213,15 @@ The %r, %R, %k, and %K fixed point number format specifiers are accepted as
 defined in ISO/IEC TR 18037 (the fixed point number extension). These are
 available when the compiler is detected as having support for fixed point
 numbers and the LIBC_COPT_PRINTF_DISABLE_FIXED_POINT flag is not set.
+
+The %m conversion will behave as specified by POSIX for syslog: It takes no
+arguments, and outputs the result of strerror(errno). Additionally, to match
+existing printf behaviors, it will behave as if it is a %s string conversion for
+the purpose of all options, except for the alt form flag. If the alt form flag
+is specified, %m will instead output a string matching the macro name of the
+value of errno (e.g. "ERANGE" for errno = ERANGE), again treating it as a string
+conversion. If there is no corresponding macro, then alt form %m will print the
+value of errno as an integer with the %d format, including all options. If
+errno = 0 and alt form is specified, the conversion will be a string conversion
+on "0" for simplicity of implementation. This matches what other libcs
+implementing this feature have done.

libc/src/__support/StringUtil/error_to_string.cpp

@@ -45,7 +45,10 @@ constexpr size_t TOTAL_STR_LEN = total_str_len(PLATFORM_ERRORS);
 constexpr size_t ERR_ARRAY_SIZE = max_key_val(PLATFORM_ERRORS) + 1;
 
 constexpr MessageMapper<ERR_ARRAY_SIZE, TOTAL_STR_LEN>
-    error_mapper(PLATFORM_ERRORS);
+    ERROR_MAPPER(PLATFORM_ERRORS);
+
+constexpr MessageMapper<ERR_ARRAY_SIZE, TOTAL_STR_LEN>
+    ERRNO_NAME_MAPPER(PLATFORM_ERRNO_NAMES);
 
 cpp::string_view build_error_string(int err_num, cpp::span<char> buffer) {
   // if the buffer can't hold "Unknown error" + ' ' + num_str, then just
@@ -68,11 +71,15 @@ cpp::string_view get_error_string(int err_num) {
 }
 
 cpp::string_view get_error_string(int err_num, cpp::span<char> buffer) {
-  auto opt_str = internal::error_mapper.get_str(err_num);
+  auto opt_str = internal::ERROR_MAPPER.get_str(err_num);
   if (opt_str)
     return *opt_str;
   else
     return internal::build_error_string(err_num, buffer);
 }
 
+cpp::optional<cpp::string_view> try_get_errno_name(int err_num) {
+  return internal::ERRNO_NAME_MAPPER.get_str(err_num);
+}
+
 } // namespace LIBC_NAMESPACE_DECL

libc/src/__support/StringUtil/error_to_string.h

@@ -9,6 +9,7 @@
 #ifndef LLVM_LIBC_SRC___SUPPORT_STRINGUTIL_ERROR_TO_STRING_H
 #define LLVM_LIBC_SRC___SUPPORT_STRINGUTIL_ERROR_TO_STRING_H
 
+#include "src/__support/CPP/optional.h"
 #include "src/__support/CPP/span.h"
 #include "src/__support/CPP/string_view.h"
 #include "src/__support/macros/config.h"
@@ -19,6 +20,8 @@ cpp::string_view get_error_string(int err_num);
 
 cpp::string_view get_error_string(int err_num, cpp::span<char> buffer);
 
+cpp::optional<cpp::string_view> try_get_errno_name(int err_num);
+
 } // namespace LIBC_NAMESPACE_DECL
 
 #endif // LLVM_LIBC_SRC___SUPPORT_STRINGUTIL_ERROR_TO_STRING_H

libc/src/__support/StringUtil/tables/linux_extension_errors.h

@@ -71,6 +71,61 @@ constexpr MsgTable<52> LINUX_ERRORS = {
     MsgMapping(EHWPOISON, "Memory page has hardware error"),
 };
 
+constexpr MsgTable<52> LINUX_ERRNO_NAMES = {
+    MsgMapping(ENOTBLK, "ENOTBLK"),
+    MsgMapping(ECHRNG, "ECHRNG"),
+    MsgMapping(EL2NSYNC, "EL2NSYNC"),
+    MsgMapping(EL3HLT, "EL3HLT"),
+    MsgMapping(EL3RST, "EL3RST"),
+    MsgMapping(ELNRNG, "ELNRNG"),
+    MsgMapping(EUNATCH, "EUNATCH"),
+    MsgMapping(ENOCSI, "ENOCSI"),
+    MsgMapping(EL2HLT, "EL2HLT"),
+    MsgMapping(EBADE, "EBADE"),
+    MsgMapping(EBADR, "EBADR"),
+    MsgMapping(EXFULL, "EXFULL"),
+    MsgMapping(ENOANO, "ENOANO"),
+    MsgMapping(EBADRQC, "EBADRQC"),
+    MsgMapping(EBADSLT, "EBADSLT"),
+    MsgMapping(EBFONT, "EBFONT"),
+    MsgMapping(ENONET, "ENONET"),
+    MsgMapping(ENOPKG, "ENOPKG"),
+    MsgMapping(EREMOTE, "EREMOTE"),
+    MsgMapping(EADV, "EADV"),
+    MsgMapping(ESRMNT, "ESRMNT"),
+    MsgMapping(ECOMM, "ECOMM"),
+    MsgMapping(EDOTDOT, "EDOTDOT"),
+    MsgMapping(ENOTUNIQ, "ENOTUNIQ"),
+    MsgMapping(EBADFD, "EBADFD"),
+    MsgMapping(EREMCHG, "EREMCHG"),
+    MsgMapping(ELIBACC, "ELIBACC"),
+    MsgMapping(ELIBBAD, "ELIBBAD"),
+    MsgMapping(ELIBSCN, "ELIBSCN"),
+    MsgMapping(ELIBMAX, "ELIBMAX"),
+    MsgMapping(ELIBEXEC, "ELIBEXEC"),
+    MsgMapping(ERESTART, "ERESTART"),
+    MsgMapping(ESTRPIPE, "ESTRPIPE"),
+    MsgMapping(EUSERS, "EUSERS"),
+    MsgMapping(ESOCKTNOSUPPORT, "ESOCKTNOSUPPORT"),
+    MsgMapping(EPFNOSUPPORT, "EPFNOSUPPORT"),
+    MsgMapping(ESHUTDOWN, "ESHUTDOWN"),
+    MsgMapping(ETOOMANYREFS, "ETOOMANYREFS"),
+    MsgMapping(EHOSTDOWN, "EHOSTDOWN"),
+    MsgMapping(EUCLEAN, "EUCLEAN"),
+    MsgMapping(ENOTNAM, "ENOTNAM"),
+    MsgMapping(ENAVAIL, "ENAVAIL"),
+    MsgMapping(EISNAM, "EISNAM"),
+    MsgMapping(EREMOTEIO, "EREMOTEIO"),
+    MsgMapping(ENOMEDIUM, "ENOMEDIUM"),
+    MsgMapping(EMEDIUMTYPE, "EMEDIUMTYPE"),
+    MsgMapping(ENOKEY, "ENOKEY"),
+    MsgMapping(EKEYEXPIRED, "EKEYEXPIRED"),
+    MsgMapping(EKEYREVOKED, "EKEYREVOKED"),
+    MsgMapping(EKEYREJECTED, "EKEYREJECTED"),
+    MsgMapping(ERFKILL, "ERFKILL"),
+    MsgMapping(EHWPOISON, "EHWPOISON"),
+};
+
 } // namespace LIBC_NAMESPACE_DECL
 
 #endif // LLVM_LIBC_SRC___SUPPORT_STRINGUTIL_TABLES_LINUX_EXTENSION_ERRORS_H

libc/src/__support/StringUtil/tables/linux_platform_errors.h

@@ -19,6 +19,9 @@ namespace LIBC_NAMESPACE_DECL {
 LIBC_INLINE_VAR constexpr auto PLATFORM_ERRORS =
     STDC_ERRORS + POSIX_ERRORS + LINUX_ERRORS;
 
+LIBC_INLINE_VAR constexpr auto PLATFORM_ERRNO_NAMES =
+    STDC_ERRNO_NAMES + POSIX_ERRNO_NAMES + LINUX_ERRNO_NAMES;
+
 } // namespace LIBC_NAMESPACE_DECL
 
 #endif // LLVM_LIBC_SRC___SUPPORT_STRINGUTIL_TABLES_LINUX_PLATFORM_ERRORS_H

libc/src/__support/StringUtil/tables/minimal_platform_errors.h

@@ -16,6 +16,8 @@ namespace LIBC_NAMESPACE_DECL {
 
 LIBC_INLINE_VAR constexpr auto PLATFORM_ERRORS = STDC_ERRORS;
 
+LIBC_INLINE_VAR constexpr auto PLATFORM_ERRNO_NAMES = STDC_ERRNO_NAMES;
+
 } // namespace LIBC_NAMESPACE_DECL
 
 #endif // LLVM_LIBC_SRC___SUPPORT_STRINGUTIL_TABLES_MINIMAL_PLATFORM_ERRORS_H

libc/src/__support/StringUtil/tables/posix_errors.h

@@ -95,6 +95,85 @@ LIBC_INLINE_VAR constexpr MsgTable<76> POSIX_ERRORS = {
     MsgMapping(ENOTRECOVERABLE, "State not recoverable"),
 };
 
+LIBC_INLINE_VAR constexpr MsgTable<76> POSIX_ERRNO_NAMES = {
+    MsgMapping(EPERM, "EPERM"),
+    MsgMapping(ENOENT, "ENOENT"),
+    MsgMapping(ESRCH, "ESRCH"),
+    MsgMapping(EINTR, "EINTR"),
+    MsgMapping(EIO, "EIO"),
+    MsgMapping(ENXIO, "ENXIO"),
+    MsgMapping(E2BIG, "E2BIG"),
+    MsgMapping(ENOEXEC, "ENOEXEC"),
+    MsgMapping(EBADF, "EBADF"),
+    MsgMapping(ECHILD, "ECHILD"),
+    MsgMapping(EAGAIN, "EAGAIN"),
+    MsgMapping(ENOMEM, "ENOMEM"),
+    MsgMapping(EACCES, "EACCES"),
+    MsgMapping(EFAULT, "EFAULT"),
+    MsgMapping(EBUSY, "EBUSY"),
+    MsgMapping(EEXIST, "EEXIST"),
+    MsgMapping(EXDEV, "EXDEV"),
+    MsgMapping(ENODEV, "ENODEV"),
+    MsgMapping(ENOTDIR, "ENOTDIR"),
+    MsgMapping(EISDIR, "EISDIR"),
+    MsgMapping(EINVAL, "EINVAL"),
+    MsgMapping(ENFILE, "ENFILE"),
+    MsgMapping(EMFILE, "EMFILE"),
+    MsgMapping(ENOTTY, "ENOTTY"),
+    MsgMapping(ETXTBSY, "ETXTBSY"),
+    MsgMapping(EFBIG, "EFBIG"),
+    MsgMapping(ENOSPC, "ENOSPC"),
+    MsgMapping(ESPIPE, "ESPIPE"),
+    MsgMapping(EROFS, "EROFS"),
+    MsgMapping(EMLINK, "EMLINK"),
+    MsgMapping(EPIPE, "EPIPE"),
+    MsgMapping(EDEADLK, "EDEADLK"),
+    MsgMapping(ENAMETOOLONG, "ENAMETOOLONG"),
+    MsgMapping(ENOLCK, "ENOLCK"),
+    MsgMapping(ENOSYS, "ENOSYS"),
+    MsgMapping(ENOTEMPTY, "ENOTEMPTY"),
+    MsgMapping(ELOOP, "ELOOP"),
+    MsgMapping(ENOMSG, "ENOMSG"),
+    MsgMapping(EIDRM, "EIDRM"),
+    MsgMapping(ENOSTR, "ENOSTR"),
+    MsgMapping(ENODATA, "ENODATA"),
+    MsgMapping(ETIME, "ETIME"),
+    MsgMapping(ENOSR, "ENOSR"),
+    MsgMapping(ENOLINK, "ENOLINK"),
+    MsgMapping(EPROTO, "EPROTO"),
+    MsgMapping(EMULTIHOP, "EMULTIHOP"),
+    MsgMapping(EBADMSG, "EBADMSG"),
+    MsgMapping(EOVERFLOW, "EOVERFLOW"),
+    MsgMapping(ENOTSOCK, "ENOTSOCK"),
+    MsgMapping(EDESTADDRREQ, "EDESTADDRREQ"),
+    MsgMapping(EMSGSIZE, "EMSGSIZE"),
+    MsgMapping(EPROTOTYPE, "EPROTOTYPE"),
+    MsgMapping(ENOPROTOOPT, "ENOPROTOOPT"),
+    MsgMapping(EPROTONOSUPPORT, "EPROTONOSUPPORT"),
+    MsgMapping(ENOTSUP, "ENOTSUP"),
+    MsgMapping(EAFNOSUPPORT, "EAFNOSUPPORT"),
+    MsgMapping(EADDRINUSE, "EADDRINUSE"),
+    MsgMapping(EADDRNOTAVAIL, "EADDRNOTAVAIL"),
+    MsgMapping(ENETDOWN, "ENETDOWN"),
+    MsgMapping(ENETUNREACH, "ENETUNREACH"),
+    MsgMapping(ENETRESET, "ENETRESET"),
+    MsgMapping(ECONNABORTED, "ECONNABORTED"),
+    MsgMapping(ECONNRESET, "ECONNRESET"),
+    MsgMapping(ENOBUFS, "ENOBUFS"),
+    MsgMapping(EISCONN, "EISCONN"),
+    MsgMapping(ENOTCONN, "ENOTCONN"),
+    MsgMapping(ETIMEDOUT, "ETIMEDOUT"),
+    MsgMapping(ECONNREFUSED, "ECONNREFUSED"),
+    MsgMapping(EHOSTUNREACH, "EHOSTUNREACH"),
+    MsgMapping(EALREADY, "EALREADY"),
+    MsgMapping(EINPROGRESS, "EINPROGRESS"),
+    MsgMapping(ESTALE, "ESTALE"),
+    MsgMapping(EDQUOT, "EDQUOT"),
+    MsgMapping(ECANCELED, "ECANCELED"),
+    MsgMapping(EOWNERDEAD, "EOWNERDEAD"),
+    MsgMapping(ENOTRECOVERABLE, "ENOTRECOVERABLE"),
+};
+
 } // namespace LIBC_NAMESPACE_DECL
 
 #endif // LLVM_LIBC_SRC___SUPPORT_STRINGUTIL_TABLES_POSIX_ERRORS_H

libc/src/__support/StringUtil/tables/stdc_errors.h

@@ -23,6 +23,13 @@ LIBC_INLINE_VAR constexpr const MsgTable<4> STDC_ERRORS = {
     MsgMapping(EILSEQ, "Invalid or incomplete multibyte or wide character"),
 };
 
+LIBC_INLINE_VAR constexpr const MsgTable<4> STDC_ERRNO_NAMES = {
+    MsgMapping(0, "0"),
+    MsgMapping(EDOM, "EDOM"),
+    MsgMapping(ERANGE, "ERANGE"),
+    MsgMapping(EILSEQ, "EILSEQ"),
+};
+
 } // namespace LIBC_NAMESPACE_DECL
 
 #endif // LLVM_LIBC_SRC___SUPPORT_STRINGUTIL_TABLES_STDC_ERRORS_H

libc/src/stdio/printf_core/CMakeLists.txt

@@ -13,6 +13,9 @@ endif()
 if(LIBC_CONF_PRINTF_DISABLE_FIXED_POINT)
   list(APPEND printf_config_copts "-DLIBC_COPT_PRINTF_DISABLE_FIXED_POINT")
 endif()
+if(LIBC_CONF_PRINTF_DISABLE_STRERROR)
+  list(APPEND printf_config_copts "-DLIBC_COPT_PRINTF_DISABLE_STRERROR")
+endif()
 if(printf_config_copts)
   list(PREPEND printf_config_copts "COMPILE_OPTIONS")
 endif()
@@ -81,6 +84,7 @@ add_object_library(
     float_hex_converter.h
     float_dec_converter.h
     fixed_converter.h #TODO: Check if this should be disabled when fixed unavail
+    strerror_converter.h
   DEPENDS
     .core_structs
     .printf_config
@@ -97,6 +101,7 @@ add_object_library(
     libc.src.__support.integer_to_string
     libc.src.__support.libc_assert
     libc.src.__support.uint128
+    libc.src.__support.StringUtil.error_to_string
 )
 
 add_object_library(

libc/src/stdio/printf_core/converter.cpp

@@ -11,6 +11,7 @@
 #include "src/__support/macros/config.h"
 #include "src/stdio/printf_core/core_structs.h"
 #include "src/stdio/printf_core/printf_config.h"
+#include "src/stdio/printf_core/strerror_converter.h"
 #include "src/stdio/printf_core/writer.h"
 
 // This option allows for replacing all of the conversion functions with custom
@@ -84,6 +85,10 @@ int convert(Writer *writer, const FormatSection &to_conv) {
   case 'K':
     return convert_fixed(writer, to_conv);
 #endif // LIBC_INTERNAL_PRINTF_HAS_FIXED_POINT
+#ifndef LIBC_COPT_PRINTF_DISABLE_STRERROR
+  case 'm':
+    return convert_strerror(writer, to_conv);
+#endif // LIBC_COPT_PRINTF_DISABLE_STRERROR
 #ifndef LIBC_COPT_PRINTF_DISABLE_WRITE_INT
   case 'n':
     return convert_write_int(writer, to_conv);

libc/src/stdio/printf_core/converter_atlas.h

@@ -43,4 +43,9 @@
 // defines convert_pointer
 #include "src/stdio/printf_core/ptr_converter.h"
 
+#ifndef LIBC_COPT_PRINTF_DISABLE_STRERROR
+// defines convert_strerror
+#include "src/stdio/printf_core/strerror_converter.h"
+#endif // LIBC_COPT_PRINTF_DISABLE_STRERROR
+
 #endif // LLVM_LIBC_SRC_STDIO_PRINTF_CORE_CONVERTER_ATLAS_H

libc/src/stdio/printf_core/parser.h

@@ -24,6 +24,9 @@
 #ifdef LIBC_INTERNAL_PRINTF_HAS_FIXED_POINT
 #include "src/__support/fixed_point/fx_rep.h"
 #endif // LIBC_INTERNAL_PRINTF_HAS_FIXED_POINT
+#ifndef LIBC_COPT_PRINTF_DISABLE_STRERROR
+#include "src/errno/libc_errno.h"
+#endif // LIBC_COPT_PRINTF_DISABLE_STRERROR
 
 namespace LIBC_NAMESPACE_DECL {
 namespace printf_core {
@@ -258,9 +261,16 @@ template <typename ArgProvider> class Parser {
         }
         break;
 #endif // LIBC_INTERNAL_PRINTF_HAS_FIXED_POINT
+#ifndef LIBC_COPT_PRINTF_DISABLE_STRERROR
+      case ('m'):
+        // %m is an odd conversion in that it doesn't consume an argument, it
+        // just takes the current value of errno as its argument.
+        section.conv_val_raw = libc_errno;
+        break;
+#endif // LIBC_COPT_PRINTF_DISABLE_STRERROR
 #ifndef LIBC_COPT_PRINTF_DISABLE_WRITE_INT
-      case ('n'):
-#endif // LIBC_COPT_PRINTF_DISABLE_WRITE_INT
+      case ('n'): // Intentional fallthrough
+#endif            // LIBC_COPT_PRINTF_DISABLE_WRITE_INT
       case ('p'):
         WRITE_ARG_VAL_SIMPLEST(section.conv_val_ptr, void *, conv_index);
         break;