[SystemZ][z/OS] Localize runtime error messages in libc++

[muiez]

Summary

The aim of this patch is to localize the string literals in order to carry out translations based on the char-mode. This is a continuation to add ASCII/EBCDIC support for z/OS. This could also be the ground work for enabling internationalization of the runtime messages.

[muiez]

Ping :)

[muiez]

@libc++ Can I get a review please? Thanks

[muiez]

resolve lit failure

[muiez]

kickoff CI

[fanbo-meng]

LGTM

[muiez]

Resolve merge conflicts

[zibi]

LGTM with minor suggestions.

libcxxabi/src/abort_message.cpp

8

I might be wrong but I think the use defined headers should be included after the system ones. Can you keep it the original order?

libcxxabi/src/abort_message.h

12

This will make consistent by including this header as user define one and move it down after `cxxabi.h as being done in other locations.

libcxxabi/src/cxa_guard_impl.h

48

same as above

libcxxabi/src/cxa_virtual.cpp

9

same as above

[muiez]

improve include's

[muiez]

libcxxabi/src/abort_message.cpp

8

The "abort_message.h" header should be included before the others in this case because we refer to bimodal functions (eg __fprintf_a). In particular, abort_message.h includes error_message.h which includes the Bimodal header. This should be included before the other headers (such as stdio.h) to avoid an undeclared identifier error.

[SeanP]

libcxxabi/src/abort_message.cpp

35–58

I suggest making a macro to wrap the function fprintf. That would simplify the this code. For example:

#ifdef __MVS__
  #define fprintf(...) \
    if (__isASCII()) __fprintf_a(__VA_ARGS__); \
    else __fprintf_e(__VA_ARGS__)
#endif

Do the same for vfprintf() and we can remove the duplication in this code. Same for the snprintf system_error.cpp. Just confirm fprintf, etc aren't macros already on MVS.

[muiez]

Refactor with macros

[muiez]

Ping :) @libcxx @libcxxabi

[muiez]

Fix merge conflict.

[muiez]

Correct conflict resolution

[muiez]

Ping :) @ldionne

[muiez]

Fix warning

[muiez]

The CI is failing with the following warning (shown as an error):

/home/libcxx-builder/.buildkite-agent/builds/63ef6a49a323-1/llvm-project/libcxx-ci/libcxx/src/system_error.cpp:134:44: error: format string is not a string literal [-Werror,-Wformat-nonliteral]
      snprintf(buffer, strerror_buff_size, getRuntimeErrorString(RM_UNKNOWN_ERROR), ev);

Any suggestions on getting passed this warning? It should be noted that getRuntimeErrorString(RM_UNKNOWN_ERROR) returns "Unknown error %d", which includes a format specifier so we can't make the call with "%s" as a string literal.

libcxx/src/any.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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 <any>
+#include "include/error_message.h"
 
 namespace std {
-const char* bad_any_cast::what() const noexcept {
-    return "bad any cast";
+const char* bad_any_cast::what() const noexcept { return getRuntimeErrorString(RM_BAD_ANY_CAST); }
 }
-}
-
 
 #include <experimental/__config>
 
 //  Preserve std::experimental::any_bad_cast for ABI compatibility
 //  Even though it no longer exists in a header file
 _LIBCPP_BEGIN_NAMESPACE_LFTS
 
 class _LIBCPP_EXCEPTION_ABI _LIBCPP_AVAILABILITY_BAD_ANY_CAST bad_any_cast : public bad_cast
 {
 public:
     virtual const char* what() const noexcept;
 };
 
-const char* bad_any_cast::what() const noexcept {
-    return "bad any cast";
-}
+const char* bad_any_cast::what() const noexcept { return getRuntimeErrorString(RM_BAD_ANY_CAST); }
 
 _LIBCPP_END_NAMESPACE_LFTS

libcxx/src/functional.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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 <functional>
+#include "include/error_message.h"
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 #ifdef _LIBCPP_ABI_BAD_FUNCTION_CALL_KEY_FUNCTION
 bad_function_call::~bad_function_call() noexcept
 {
 }
 #endif
 
 #ifdef _LIBCPP_ABI_BAD_FUNCTION_CALL_GOOD_WHAT_MESSAGE
 const char*
 bad_function_call::what() const noexcept
 {
-    return "std::bad_function_call";
+    return getRuntimeErrorString(RM_BAD_FUNCTION_CALL);
 }
 #endif
 
 _LIBCPP_END_NAMESPACE_STD

libcxx/src/future.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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 <__config>
 
 #ifndef _LIBCPP_HAS_NO_THREADS
 
 #include <future>
 #include <string>
+#include "include/error_message.h"
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 class _LIBCPP_HIDDEN __future_error_category
     : public __do_message
 {
 public:
     virtual const char* name() const noexcept;

 
 string
 __future_error_category::message(int ev) const
 {
     switch (static_cast<future_errc>(ev))
     {
     case future_errc(0):  // For backwards compatibility with C++11 (LWG 2056)
     case future_errc::broken_promise:
-        return string("The associated promise has been destructed prior "
-                      "to the associated state becoming ready.");
+      return string(getRuntimeErrorString(RM_BROKEN_PROMISE));
     case future_errc::future_already_retrieved:
-        return string("The future has already been retrieved from "
-                      "the promise or packaged_task.");
+      return string(getRuntimeErrorString(RM_FUTURE_ALREADY_RETRIEVED));
     case future_errc::promise_already_satisfied:
-        return string("The state of the promise has already been set.");
+      return string(getRuntimeErrorString(RM_PROMISE_ALREADY_SATISFIED));
     case future_errc::no_state:
-        return string("Operation not permitted on an object without "
-                      "an associated state.");
+      return string(getRuntimeErrorString(RM_NO_STATE));
     }
-    return string("unspecified future_errc value\n");
+    return string(getRuntimeErrorString(RM_UNSPECIFIED_FEV));
 }
 
 _LIBCPP_DIAGNOSTIC_POP
 
 const error_category&
 future_category() noexcept
 {
     static __future_error_category __f;

libcxx/src/include/error_message.h

+//===----------------------------------------------------------------------===////
+//
+// 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 ERROR_MESSAGE_H
+#define ERROR_MESSAGE_H
+
+#ifdef __MVS__
+#  define _AE_BIMODAL 1
+#  include <_Nascii.h>
+#endif
+
+#include "__config"
+
+#define ErrorList                                                                                                      \
+  ErrMsg(RM_BROKEN_PROMISE,                                                                                            \
+         "The associated promise has been destructed prior to the associated state becoming ready."),                  \
+      ErrMsg(RM_FUTURE_ALREADY_RETRIEVED, "The future has already been retrieved from the promise or packaged_task."), \
+      ErrMsg(RM_PROMISE_ALREADY_SATISFIED, "The state of the promise has already been set."),                          \
+      ErrMsg(RM_NO_STATE, "Operation not permitted on an object without an associated state."),                        \
+      ErrMsg(RM_UNSPECIFIED_FEV, "unspecified future_errc value\n"),                                                   \
+      ErrMsg(RM_PURE_VIRTUAL_FUNCTION, "Pure virtual function called!"),                                               \
+      ErrMsg(RM_DELETED_VIRTUAL_FUNCTION, "Deleted virtual function called!"),                                         \
+      ErrMsg(RM_WHAT_BAD_OPTIONAL, "bad_optional_access"),                                                             \
+      ErrMsg(RM_LIBCXXABI, "libc++abi: "),                                                                             \
+      ErrMsg(RM_NL, "\n"),                                                                                             \
+      ErrMsg(RM_UNSPECIFIED_ICE, "unspecified iostream_category error"),                                               \
+      ErrMsg(RM_STRERROR_MSG, "unexpected error from ::strerror_r"),                                                   \
+      ErrMsg(RM_UNKNOWN_ERROR, "Unknown error %d"),                                                                    \
+      ErrMsg(RM_UNSPECIFIED_GCE, "unspecified generic_category error"),                                                \
+      ErrMsg(RM_UNSPECIFIED_SCE, "unspecified system_category error"),                                                 \
+      ErrMsg(RM_BAD_ANY_CAST, "bad any cast"),                                                                         \
+      ErrMsg(RM_BAD_FUNCTION_CALL, "std::bad_function_call"),                                                          \
+      ErrMsg(RM_BAD_WEAK_PTR, "bad_weak_ptr"),                                                                         \
+      ErrMsg(RM_BAD_VARIANT_ACS, "bad_variant_access"),                                                                \
+      ErrMsg(RM_TERMINATE_EXCEPT_WHAT, "terminating with %s exception of type %s: %s"),                                \
+      ErrMsg(RM_TERMINATE_EXCEPT, "terminating with %s exception of type %s"),                                         \
+      ErrMsg(RM_TERMINATE, "terminating"),                                                                             \
+      ErrMsg(RM_FOREIGN_EXCEPTION, "terminating with %s foreign exception"),                                           \
+      ErrMsg(RM_TERMINATE_CAUSE_UNCAUGHT, "uncaught"),                                                                 \
+      ErrMsg(RM_TERMINATE_CAUSE_UNEXPECTED, "unexpected"),                                                             \
+      ErrMsg(RM_CANNOT_ZERO_TLS, "cannot zero out thread value for __cxa_get_globals()"),                              \
+      ErrMsg(RM_CANNOT_CREATE_TLS_KEY, "cannot create thread specific key for __cxa_get_globals()"),                   \
+      ErrMsg(RM_CANNOT_ALLOC_EH_GLOBALS, "cannot allocate __cxa_eh_globals"),                                          \
+      ErrMsg(RM_TLS_SET_EH_GLOBALS, "std::__libcpp_tls_set failure in __cxa_get_globals()"),                           \
+      ErrMsg(RM_THREAD_EXIT_TLS_CREATE, "std::__libcpp_tls_create() failed in __cxa_thread_atexit()"),                 \
+      ErrMsg(RM_EH_GLOBALS_FAST_EXECUTE_ONCE, "execute once failure in __cxa_get_globals_fast()"),                     \
+      ErrMsg(RM_VECTOR_ALLOC, "__cxa_vec_new failed to allocate memory"),                                              \
+      ErrMsg(RM_RETURNED_FROM_UNEXPECTED_HANDLER, "unexpected_handler unexpectedly returned"),                         \
+      ErrMsg(RM_RETURNED_FROM_TERMINATE_HANDLER, "terminate_handler unexpectedly returned"),                           \
+      ErrMsg(RM_THROW_INSIDE_TERMINATE_HANDLER, "terminate_handler unexpectedly threw an exception"),                  \
+      ErrMsg(RM_CXA_GUARD_ACQUIRE, "__cxa_guard_acquire"),                                                             \
+      ErrMsg(RM_CXA_GUARD_ACQUIRE_RECURSIVE, "__cxa_guard_acquire detected recursive initialization"),                 \
+      ErrMsg(RM_CXA_GUARD_RELEASE_BROADCAST, "__cxa_guard_release failed to broadcast"),                               \
+      ErrMsg(RM_CXA_GUARD_ABORT_BROADCAST, "__cxa_guard_abort failed to broadcast"),                                   \
+      ErrMsg(RM_CXA_GUARD_RELEASE, "__cxa_guard_release"),                                                             \
+      ErrMsg(RM_CXA_GUARD_ABORT, "__cxa_guard_abort"),                                                                 \
+      ErrMsg(RM_MUTEX_ACQUIRE, "%s failed to acquire mutex"),                                                          \
+      ErrMsg(RM_MUTEX_RELEASE, "%s failed to release mutex"),                                                          \
+      ErrMsg(RM_FUTEX, "Futex selected but not supported"),                                                            \
+
+
+#define ErrMsg(N, D) N
+enum Errs { ErrorList };
+#undef ErrMsg
+
+#define ErrMsg(N, D) D
+#ifdef __MVS__
+#  pragma convert("IBM-1047")
+static constexpr const char* const ErrTextEBCDIC[] = {ErrorList};
+#  pragma convert(pop)
+#  pragma convert("ISO8859-1")
+static constexpr const char* const ErrTextASCII[] = {ErrorList};
+#  pragma convert(pop)
+#endif
+static constexpr const char* const ErrText[] = {ErrorList};
+
+#undef ErrMsg
+
+#ifdef __MVS__
+_LIBCPP_INLINE_VISIBILITY
+inline const char* getRuntimeErrorString(int error) _NOEXCEPT {
+  return (__isASCII() ? ErrTextASCII[error] : ErrTextEBCDIC[error]);
+}
+#else
+_LIBCPP_INLINE_VISIBILITY
+inline constexpr const char* getRuntimeErrorString(int error) _NOEXCEPT { return ErrText[error]; }
+#endif
+
+#endif // ERROR_MESSAGE_H

libcxx/src/ios.cpp

 #include <ios>
 #include <limits>
 #include <memory>
 #include <new>
 #include <stdlib.h>
 #include <string>
 
 #include "include/config_elast.h"
+#include "include/error_message.h"
 
 _LIBCPP_PUSH_MACROS
 #include <__undef_macros>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 class _LIBCPP_HIDDEN __iostream_category
     : public __do_message

 __iostream_category::message(int ev) const
 {
     if (ev != static_cast<int>(io_errc::stream)
 #ifdef _LIBCPP_ELAST
         && ev <= _LIBCPP_ELAST
 #endif // _LIBCPP_ELAST
         )
         return __do_message::message(ev);
-    return string("unspecified iostream_category error");
+    return string(getRuntimeErrorString(RM_UNSPECIFIED_ICE));
 }
 
 const error_category&
 iostream_category() noexcept
 {
     static __iostream_category s;
     return s;
 }

libcxx/src/memory.cpp

 #  include <mutex>
 #  include <thread>
 #  if defined(__ELF__) && defined(_LIBCPP_LINK_PTHREAD_LIB)
 #    pragma comment(lib, "pthread")
 #  endif
 #endif
 
 #include "include/atomic_support.h"
+#include "include/error_message.h"
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 const allocator_arg_t allocator_arg = allocator_arg_t();
 
 bad_weak_ptr::~bad_weak_ptr() noexcept {}
 
-const char*
-bad_weak_ptr::what() const noexcept
-{
-    return "bad_weak_ptr";
-}
+const char* bad_weak_ptr::what() const noexcept { return getRuntimeErrorString(RM_BAD_WEAK_PTR); }
 
 __shared_count::~__shared_count()
 {
 }
 
 __shared_weak_count::~__shared_weak_count()
 {
 }

libcxx/src/optional.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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 <__availability>
 #include <optional>
+#include "include/error_message.h"
 
 namespace std
 {
 
 bad_optional_access::~bad_optional_access() noexcept = default;
 
-const char* bad_optional_access::what() const noexcept {
-  return "bad_optional_access";
-  }
+const char* bad_optional_access::what() const noexcept { return getRuntimeErrorString(RM_WHAT_BAD_OPTIONAL); }
 
 } // std
 
 
 #include <experimental/__config>
 
 //  Preserve std::experimental::bad_optional_access for ABI compatibility
 //  Even though it no longer exists in a header file

libcxx/src/system_error.cpp

 #include <cstdio>
 #include <cstdlib>
 #include <cstring>
 #include <string>
 #include <string.h>
 #include <system_error>
 
 #include "include/config_elast.h"
+#include "include/error_message.h"
 
 #if defined(__ANDROID__)
 #include <android/api-level.h>
 #endif
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 // class error_category
handle_strerror_r_return(int strerror_return, char *buffer) {
   if (strerror_return == 0)
     return buffer;
 
   // Only handle EINVAL. Other errors abort.
   int new_errno = strerror_return == -1 ? errno : strerror_return;
   if (new_errno == EINVAL)
     return "";
 
-  _LIBCPP_ASSERT(new_errno == ERANGE, "unexpected error from ::strerror_r");
+  _LIBCPP_ASSERT(new_errno == ERANGE, getRuntimeErrorString(RM_STRERROR_MSG));
+
   // FIXME maybe? 'strerror_buff_size' is likely to exceed the
   // maximum error size so ERANGE shouldn't be returned.
   std::abort();
 }
 
 // This function handles both GNU and POSIX variants, dispatching to
 // one of the two above functions.
 string do_strerror_r(int ev) {
     char buffer[strerror_buff_size];
     // Preserve errno around the call. (The C++ standard requires that
     // system_error functions not modify errno).
     const int old_errno = errno;
     const char *error_message = handle_strerror_r_return(
         ::strerror_r(ev, buffer, strerror_buff_size), buffer);
     // If we didn't get any message, print one now.
     if (!error_message[0]) {
-      std::snprintf(buffer, strerror_buff_size, "Unknown error %d", ev);
+#if defined(__MVS__)
+      if (__isASCII())
+        __snprintf_a(buffer, strerror_buff_size, getRuntimeErrorString(RM_UNKNOWN_ERROR), ev);
+      else
+        __snprintf_e(buffer, strerror_buff_size, getRuntimeErrorString(RM_UNKNOWN_ERROR), ev);
+#else
+      std::snprintf(buffer, strerror_buff_size, getRuntimeErrorString(RM_UNKNOWN_ERROR), ev);
+#endif
       error_message = buffer;
     }
     errno = old_errno;
     return string(error_message);
 }
 #endif
 } // end namespace
 #endif

 {
     return "generic";
 }
 
 string
 __generic_error_category::message(int ev) const
 {
 #ifdef _LIBCPP_ELAST
-    if (ev > _LIBCPP_ELAST)
-      return string("unspecified generic_category error");
-#endif // _LIBCPP_ELAST
+    return string(getRuntimeErrorString(RM_UNSPECIFIED_GCE));
+#endif  // _LIBCPP_ELAST
     return __do_message::message(ev);
 }
 
 const error_category&
 generic_category() noexcept
 {
     static __generic_error_category s;
     return s;

 {
     return "system";
 }
 
 string
 __system_error_category::message(int ev) const
 {
 #ifdef _LIBCPP_ELAST
-    if (ev > _LIBCPP_ELAST)
-      return string("unspecified system_category error");
-#endif // _LIBCPP_ELAST
+    return string(getRuntimeErrorString(RM_UNSPECIFIED_SCE));
+#endif  // _LIBCPP_ELAST
     return __do_message::message(ev);
 }
 
 error_condition
 __system_error_category::default_error_condition(int ev) const noexcept
 {
 #ifdef _LIBCPP_ELAST
     if (ev > _LIBCPP_ELAST)

libcxx/src/variant.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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 <variant>
+#include "include/error_message.h"
 
 namespace std {
 
-const char* bad_variant_access::what() const noexcept {
-  return "bad_variant_access";
-}
+const char* bad_variant_access::what() const noexcept { return getRuntimeErrorString(RM_BAD_VARIANT_ACS); }
 
 }  // namespace std

libcxxabi/src/abort_message.h

 //===----------------------------------------------------------------------===//
 //
 // 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 __ABORT_MESSAGE_H_
 #define __ABORT_MESSAGE_H_
 
+#include <include/error_message.h>
 #include "cxxabi.h"
 
 extern "C" _LIBCXXABI_HIDDEN _LIBCXXABI_NORETURN void
-abort_message(const char *format, ...) __attribute__((format(printf, 1, 2)));
+abort_message_check(Errs, const char*, ...) __attribute__((format(printf, 2, 0)));
+
+#define abort_message(m, ...) abort_message_check(m, ErrText[m] __VA_OPT__(,) __VA_ARGS__)
 
 #endif

libcxxabi/src/abort_message.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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 "abort_message.h"
 #include <stdlib.h>
 #include <stdio.h>
 #include <stdarg.h>
-#include "abort_message.h"
 
 #ifdef __BIONIC__
 #   include <android/api-level.h>
 #   if __ANDROID_API__ >= 21
 #       include <syslog.h>
         extern "C" void android_set_abort_message(const char* msg);
 #   else
 #       include <assert.h>
 #   endif // __ANDROID_API__ >= 21
 #endif // __BIONIC__
 
 #if defined(__APPLE__) && __has_include(<CrashReporterClient.h>)
 #   include <CrashReporterClient.h>
 #   define _LIBCXXABI_USE_CRASHREPORTER_CLIENT
 #endif
 
-void abort_message(const char* format, ...)
+void abort_message_check(Errs m, const char* _format, ...)
 {
     // Write message to stderr. We do this before formatting into a
     // variable-size buffer so that we still get some information if
     // formatting into the variable-sized buffer fails.
 #if !defined(NDEBUG) || !defined(LIBCXXABI_BAREMETAL)
     {
-        fprintf(stderr, "libc++abi: ");
-        va_list list;
-        va_start(list, format);
-        vfprintf(stderr, format, list);
-        va_end(list);
-        fprintf(stderr, "\n");
+#if defined(__MVS__)
+      if (__isASCII()) 
+        __fprintf_a(stderr, getRuntimeErrorString(RM_LIBCXXABI));
+      else
+        __fprintf_e(stderr, getRuntimeErrorString(RM_LIBCXXABI));
+      va_start(list, _format);
+      if (__isASCII())
+        __vfprintf_a(stderr, getRuntimeErrorString(m), list);
+      else
+        __vfprintf_e(stderr, getRuntimeErrorString(m), list);
+      if (__isASCII())
+        __fprintf_a(stderr, getRuntimeErrorString(RM_NL));
+      else
+        __fprintf_e(stderr, getRuntimeErrorString(RM_NL));
+#else
+      fprintf(stderr, getRuntimeErrorString(RM_LIBCXXABI));
+      va_list list;
+      va_start(list, _format);
+      vfprintf(stderr, getRuntimeErrorString(m), list);
+      va_end(list);
+      fprintf(stderr, getRuntimeErrorString(RM_NL));
+#endif
     }
 #endif
 
     // Format the arguments into an allocated buffer. We leak the buffer on
     // purpose, since we're about to abort() anyway.
 #if defined(_LIBCXXABI_USE_CRASHREPORTER_CLIENT)
     char* buffer;
     va_list list;
-    va_start(list, format);
-    vasprintf(&buffer, format, list);
+    va_start(list, _format);
+    vasprintf(&buffer, getRuntimeErrorString(m), list);
     va_end(list);
 
     CRSetCrashLogMessage(buffer);
 #elif defined(__BIONIC__)
     char* buffer;
     va_list list;
-    va_start(list, format);
-    vasprintf(&buffer, format, list);
+    va_start(list, _format);
+    vasprintf(&buffer, getRuntimeErrorString(m), list);
     va_end(list);
 
 #   if __ANDROID_API__ >= 21
     // Show error in tombstone.
     android_set_abort_message(buffer);
 
     // Show error in logcat.
     openlog("libc++abi", 0, 0);

libcxxabi/src/cxa_default_handlers.cpp

 #include "cxxabi.h"
 #include "cxa_handlers.h"
 #include "cxa_exception.h"
 #include "private_typeinfo.h"
 #include "include/atomic_support.h" // from libc++
 
 #if !defined(LIBCXXABI_SILENT_TERMINATE)
 
-static constinit const char* cause = "uncaught";
+static Errs cause = RM_TERMINATE_CAUSE_UNCAUGHT;
 
 __attribute__((noreturn))
 static void demangling_terminate_handler()
 {
 #ifndef _LIBCXXABI_NO_EXCEPTIONS
     // If there might be an uncaught exception
     using namespace __cxxabiv1;
     __cxa_eh_globals* globals = __cxa_get_globals_fast();

 #endif
                 // If the uncaught exception can be caught with std::exception&
                 const __shim_type_info* catch_type =
                     static_cast<const __shim_type_info*>(&typeid(std::exception));
                 if (catch_type->can_catch(thrown_type, thrown_object))
                 {
                     // Include the what() message from the exception
                     const std::exception* e = static_cast<const std::exception*>(thrown_object);
-                    abort_message("terminating with %s exception of type %s: %s",
-                                  cause, name, e->what());
+                    abort_message(RM_TERMINATE_EXCEPT_WHAT,
+                                  getRuntimeErrorString(cause), name, e->what());
                 }
                 else
                     // Else just note that we're terminating with an exception
-                    abort_message("terminating with %s exception of type %s",
-                                   cause, name);
+                    abort_message(RM_TERMINATE_EXCEPT,
+                                   getRuntimeErrorString(cause), name);
             }
             else
                 // Else we're terminating with a foreign exception
-                abort_message("terminating with %s foreign exception", cause);
+                abort_message(RM_FOREIGN_EXCEPTION, getRuntimeErrorString(cause));
         }
     }
 #endif
     // Else just note that we're terminating
-    abort_message("terminating");
+    abort_message(RM_TERMINATE);
 }
 
 __attribute__((noreturn))
 static void demangling_unexpected_handler()
 {
-    cause = "unexpected";
+    cause = RM_TERMINATE_CAUSE_UNEXPECTED;
     std::terminate();
 }
 
 static constexpr std::terminate_handler default_terminate_handler = demangling_terminate_handler;
 static constexpr std::terminate_handler default_unexpected_handler = demangling_unexpected_handler;
 #else
 static constexpr std::terminate_handler default_terminate_handler = ::abort;
 static constexpr std::terminate_handler default_unexpected_handler = std::terminate;

libcxxabi/src/cxa_exception_storage.cpp

 namespace __cxxabiv1 {
 namespace {
     std::__libcpp_tls_key key_;
     std::__libcpp_exec_once_flag flag_ = _LIBCPP_EXEC_ONCE_INITIALIZER;
 
     void _LIBCPP_TLS_DESTRUCTOR_CC destruct_(void *p) {
         __free_with_fallback(p);
         if (0 != std::__libcpp_tls_set(key_, NULL))
-            abort_message("cannot zero out thread value for __cxa_get_globals()");
+            abort_message(RM_CANNOT_ZERO_TLS);
     }
 
     void construct_() {
         if (0 != std::__libcpp_tls_create(&key_, destruct_))
-            abort_message("cannot create thread specific key for __cxa_get_globals()");
+            abort_message(RM_CANNOT_CREATE_TLS_KEY);
     }
 } // namespace
 
 extern "C" {
     __cxa_eh_globals *__cxa_get_globals() {
         // Try to get the globals for this thread
         __cxa_eh_globals *retVal = __cxa_get_globals_fast();
 
         // If this is the first time we've been asked for these globals, create them
         if (NULL == retVal) {
             retVal = static_cast<__cxa_eh_globals*>(
                 __calloc_with_fallback(1, sizeof(__cxa_eh_globals)));
             if (NULL == retVal)
-                abort_message("cannot allocate __cxa_eh_globals");
+                abort_message(RM_CANNOT_ALLOC_EH_GLOBALS);
             if (0 != std::__libcpp_tls_set(key_, retVal))
-               abort_message("std::__libcpp_tls_set failure in __cxa_get_globals()");
+               abort_message(RM_TLS_SET_EH_GLOBALS);
         }
         return retVal;
     }
 
     // Note that this implementation will reliably return NULL if not
     // preceded by a call to __cxa_get_globals().  This is an extension
     // to the Itanium ABI and is taken advantage of in several places in
     // libc++abi.
     __cxa_eh_globals *__cxa_get_globals_fast() {
         // First time through, create the key.
         if (0 != std::__libcpp_execute_once(&flag_, construct_))
-            abort_message("execute once failure in __cxa_get_globals_fast()");
+            abort_message(RM_EH_GLOBALS_FAST_EXECUTE_ONCE);
         return static_cast<__cxa_eh_globals*>(std::__libcpp_tls_get(key_));
     }
 } // extern "C"
 } // namespace __cxxabiv1
 
 #endif

libcxxabi/src/cxa_guard_impl.h

  *  Overall Design:
  *    The implementation was designed to allow each implementation to be tested
  *    independent of the C++ runtime or platform support.
  *
  */
 
 #include "__cxxabi_config.h"
 #include "include/atomic_support.h" // from libc++
+#include <include/error_message.h>
 #if defined(__has_include)
 #  if __has_include(<sys/syscall.h>)
 #    include <sys/syscall.h>
 #  endif
 #  if __has_include(<unistd.h>)
 #    include <unistd.h>
 #  endif
 #endif
struct InitByteNoThreads {
   explicit InitByteNoThreads(uint8_t* _init_byte_address, uint32_t*) : init_byte_address(_init_byte_address) {}
 
   /// The init byte portion of cxa_guard_acquire. Returns true if
   /// initialization has already been completed.
   bool acquire() {
     if (*init_byte_address == COMPLETE_BIT)
       return true;
     if (*init_byte_address & PENDING_BIT)
-      ABORT_WITH_MESSAGE("__cxa_guard_acquire detected recursive initialization");
+      ABORT_WITH_MESSAGE(RM_CXA_GUARD_ACQUIRE_RECURSIVE);
     *init_byte_address = PENDING_BIT;
     return false;
   }
 
   /// The init byte portion of cxa_guard_release.
   void release() { *init_byte_address = COMPLETE_BIT; }
   /// The init byte portion of cxa_guard_abort.
   void abort() { *init_byte_address = UNSET; }
struct InitByteGlobalMutex {
   explicit InitByteGlobalMutex(uint8_t* _init_byte_address, uint32_t* _thread_id_address)
       : init_byte_address(_init_byte_address), thread_id_address(_thread_id_address),
         has_thread_id_support(_thread_id_address != nullptr && GetThreadID != nullptr) {}
 
 public:
   /// The init byte portion of cxa_guard_acquire. Returns true if
   /// initialization has already been completed.
   bool acquire() {
-    LockGuard g("__cxa_guard_acquire");
+    LockGuard g(RM_CXA_GUARD_ACQUIRE);
     // Check for possible recursive initialization.
     if (has_thread_id_support && (*init_byte_address & PENDING_BIT)) {
       if (*thread_id_address == current_thread_id.get())
-        ABORT_WITH_MESSAGE("__cxa_guard_acquire detected recursive initialization");
+        ABORT_WITH_MESSAGE(RM_CXA_GUARD_ACQUIRE_RECURSIVE);
     }
 
     // Wait until the pending bit is not set.
     while (*init_byte_address & PENDING_BIT) {
       *init_byte_address |= WAITING_BIT;
       global_cond.wait(global_mutex);
     }
 
     if (*init_byte_address == COMPLETE_BIT)
       return true;
 
     if (has_thread_id_support)
       *thread_id_address = current_thread_id.get();
 
     *init_byte_address = PENDING_BIT;
     return false;
   }
 
   /// The init byte portion of cxa_guard_release.
   void release() {
     bool has_waiting;
     {
-      LockGuard g("__cxa_guard_release");
+      LockGuard g(RM_CXA_GUARD_RELEASE);
       has_waiting = *init_byte_address & WAITING_BIT;
       *init_byte_address = COMPLETE_BIT;
     }
     if (has_waiting) {
       if (global_cond.broadcast()) {
-        ABORT_WITH_MESSAGE("%s failed to broadcast", "__cxa_guard_release");
+        ABORT_WITH_MESSAGE(RM_CXA_GUARD_RELEASE_BROADCAST);
       }
     }
   }
 
   /// The init byte portion of cxa_guard_abort.
   void abort() {
     bool has_waiting;
     {
-      LockGuard g("__cxa_guard_abort");
+      LockGuard g(RM_CXA_GUARD_ABORT);
       if (has_thread_id_support)
         *thread_id_address = 0;
       has_waiting = *init_byte_address & WAITING_BIT;
       *init_byte_address = UNSET;
     }
     if (has_waiting) {
       if (global_cond.broadcast()) {
-        ABORT_WITH_MESSAGE("%s failed to broadcast", "__cxa_guard_abort");
+        ABORT_WITH_MESSAGE(RM_CXA_GUARD_ABORT_BROADCAST);
       }
     }
   }
 
 private:
   /// The address of the byte used during initialization.
   uint8_t* const init_byte_address;
   /// An optional address storing an identifier for the thread performing initialization.
   /// It's used to detect recursive initialization.
   uint32_t* const thread_id_address;
 
   const bool has_thread_id_support;
   LazyValue<uint32_t, GetThreadID> current_thread_id;
 
 private:
   struct LockGuard {
     LockGuard() = delete;
     LockGuard(LockGuard const&) = delete;
     LockGuard& operator=(LockGuard const&) = delete;
 
-    explicit LockGuard(const char* calling_func) : calling_func_(calling_func) {
+    explicit LockGuard(Errs calling_func) : calling_func_(calling_func) {
       if (global_mutex.lock())
-        ABORT_WITH_MESSAGE("%s failed to acquire mutex", calling_func_);
+        ABORT_WITH_MESSAGE(RM_MUTEX_ACQUIRE, getRuntimeErrorString(calling_func_));
     }
 
     ~LockGuard() {
       if (global_mutex.unlock())
-        ABORT_WITH_MESSAGE("%s failed to release mutex", calling_func_);
+        ABORT_WITH_MESSAGE(RM_MUTEX_RELEASE, getRuntimeErrorString(calling_func_));
     }
 
   private:
-    const char* const calling_func_;
+    Errs calling_func_;
   };
 };
 
 //===----------------------------------------------------------------------===//
 //                         Futex Implementation
 //===----------------------------------------------------------------------===//
 
 #if defined(SYS_futex)
while (true) {
 
       if (last_val == COMPLETE_BIT)
         return true;
 
       if (last_val & PENDING_BIT) {
 
         // Check for recursive initialization
         if (has_thread_id_support && thread_id.load(std::_AO_Relaxed) == current_thread_id.get()) {
-          ABORT_WITH_MESSAGE("__cxa_guard_acquire detected recursive initialization");
+          ABORT_WITH_MESSAGE(RM_CXA_GUARD_ACQUIRE_RECURSIVE);
         }
 
         if ((last_val & WAITING_BIT) == 0) {
           // This compare exchange can fail for several reasons
           // (1) another thread finished the whole thing before we got here
           // (2) another thread set the waiting bit we were trying to thread
           // (3) another thread had an exception and failed to finish
           if (!init_byte.compare_exchange(&last_val, PENDING_BIT | WAITING_BIT, std::_AO_Acq_Rel, std::_AO_Release)) {

libcxxabi/src/cxa_handlers.cpp

get_unexpected() noexcept
     return __libcpp_atomic_load(&__cxa_unexpected_handler, _AO_Acquire);
 }
 
 void
 __unexpected(unexpected_handler func)
 {
     func();
     // unexpected handler should not return
-    abort_message("unexpected_handler unexpectedly returned");
+    abort_message(RM_RETURNED_FROM_UNEXPECTED_HANDLER);
 }
 
 __attribute__((noreturn))
 void
 unexpected()
 {
     __unexpected(get_unexpected());
 }
 
 terminate_handler
 get_terminate() noexcept
 {
     return __libcpp_atomic_load(&__cxa_terminate_handler, _AO_Acquire);
 }
 
 void
 __terminate(terminate_handler func) noexcept
 {
 #ifndef _LIBCXXABI_NO_EXCEPTIONS
     try
     {
 #endif // _LIBCXXABI_NO_EXCEPTIONS
         func();
         // handler should not return
-        abort_message("terminate_handler unexpectedly returned");
+        abort_message(RM_RETURNED_FROM_TERMINATE_HANDLER);
 #ifndef _LIBCXXABI_NO_EXCEPTIONS
     }
     catch (...)
     {
         // handler should not throw exception
-        abort_message("terminate_handler unexpectedly threw an exception");
+        abort_message(RM_THROW_INSIDE_TERMINATE_HANDLER);
     }
 #endif // _LIBCXXABI_NO_EXCEPTIONS
 }
 
 __attribute__((noreturn))
 void
 terminate() noexcept
 {

libcxxabi/src/cxa_thread_atexit.cpp

namespace {
   }
 
   struct DtorsManager {
     DtorsManager() {
       // There is intentionally no matching std::__libcpp_tls_delete call, as
       // __cxa_thread_atexit() may be called arbitrarily late (for example, from
       // global destructors or atexit() handlers).
       if (std::__libcpp_tls_create(&dtors_key, run_dtors) != 0) {
-        abort_message("std::__libcpp_tls_create() failed in __cxa_thread_atexit()");
+        abort_message(RM_THREAD_EXIT_TLS_CREATE);
       }
     }
 
     ~DtorsManager() {
       // std::__libcpp_tls_key destructors do not run on threads that call exit()
       // (including when the main thread returns from main()), so we explicitly
       // call the destructor here.  This runs at exit time (potentially earlier
       // if libc++abi is dlclose()'d).  Any thread_locals initialized after this

libcxxabi/src/cxa_vector.cpp

 //
 
 namespace {
 _LIBCXXABI_NORETURN
 void throw_bad_array_new_length() {
 #ifndef _LIBCXXABI_NO_EXCEPTIONS
   throw std::bad_array_new_length();
 #else
-  abort_message("__cxa_vec_new failed to allocate memory");
+  abort_message(RM_VECTOR_ALLOC);
 #endif
 }
 
 bool mul_overflow(size_t x, size_t y, size_t *res) {
 #if (defined(_LIBCXXABI_COMPILER_CLANG) && __has_builtin(__builtin_mul_overflow)) \
     || defined(_LIBCXXABI_COMPILER_GCC)
     return __builtin_mul_overflow(x, y, res);
 #else

libcxxabi/src/cxa_virtual.cpp

 //===----------------------------------------------------------------------===//
 //
 // 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 <include/error_message.h>
 #include "cxxabi.h"
 #include "abort_message.h"
 
 namespace __cxxabiv1 {
 extern "C" {
 _LIBCXXABI_FUNC_VIS _LIBCXXABI_NORETURN
 void __cxa_pure_virtual(void) {
-  abort_message("Pure virtual function called!");
+  abort_message(RM_PURE_VIRTUAL_FUNCTION);
 }
 
 _LIBCXXABI_FUNC_VIS _LIBCXXABI_NORETURN
 void __cxa_deleted_virtual(void) {
-  abort_message("Deleted virtual function called!");
+  abort_message(RM_DELETED_VIRTUAL_FUNCTION);
 }
 } // extern "C"
 } // abi