libcxx: update to LLVM 18
release/18.x branch, commit 78b99c73ee4b96fe9ce0e294d4632326afb2db42 This adds the flag `-D_LIBCPP_HARDENING_MODE` which is determined based on the Zig optimization mode. This commit also fixes libunwind, libcxx, and libcxxabi to properly report sub compilation errors.
This commit is contained in:
Andrew Kelley
262
lib/libcxx/src/system_error.cpp
vendored
262
lib/libcxx/src/system_error.cpp
vendored
@@ -6,68 +6,34 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include <__config>
|
||||
#ifdef _LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS
|
||||
# define _LIBCPP_ERROR_CATEGORY_DEFINE_LEGACY_INLINE_FUNCTIONS
|
||||
#endif
|
||||
|
||||
#include <__assert>
|
||||
#include <__config>
|
||||
#include <__verbose_abort>
|
||||
#include <cerrno>
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include <string>
|
||||
#include <string.h>
|
||||
#include <string>
|
||||
#include <system_error>
|
||||
|
||||
#include "include/config_elast.h"
|
||||
|
||||
#if defined(__ANDROID__)
|
||||
#include <android/api-level.h>
|
||||
# include <android/api-level.h>
|
||||
#endif
|
||||
|
||||
_LIBCPP_BEGIN_NAMESPACE_STD
|
||||
|
||||
// class error_category
|
||||
|
||||
#if defined(_LIBCPP_ERROR_CATEGORY_DEFINE_LEGACY_INLINE_FUNCTIONS)
|
||||
error_category::error_category() noexcept
|
||||
{
|
||||
}
|
||||
#endif
|
||||
|
||||
error_category::~error_category() noexcept
|
||||
{
|
||||
}
|
||||
|
||||
error_condition
|
||||
error_category::default_error_condition(int ev) const noexcept
|
||||
{
|
||||
return error_condition(ev, *this);
|
||||
}
|
||||
|
||||
bool
|
||||
error_category::equivalent(int code, const error_condition& condition) const noexcept
|
||||
{
|
||||
return default_error_condition(code) == condition;
|
||||
}
|
||||
|
||||
bool
|
||||
error_category::equivalent(const error_code& code, int condition) const noexcept
|
||||
{
|
||||
return *this == code.category() && code.value() == condition;
|
||||
}
|
||||
|
||||
#if !defined(_LIBCPP_HAS_NO_THREADS)
|
||||
namespace {
|
||||
#if !defined(_LIBCPP_HAS_NO_THREADS)
|
||||
|
||||
// GLIBC also uses 1024 as the maximum buffer size internally.
|
||||
constexpr size_t strerror_buff_size = 1024;
|
||||
|
||||
string do_strerror_r(int ev);
|
||||
|
||||
#if defined(_LIBCPP_MSVCRT_LIKE)
|
||||
# if defined(_LIBCPP_MSVCRT_LIKE)
|
||||
string do_strerror_r(int ev) {
|
||||
char buffer[strerror_buff_size];
|
||||
if (::strerror_s(buffer, strerror_buff_size, ev) == 0)
|
||||
@@ -75,14 +41,13 @@ string do_strerror_r(int ev) {
|
||||
std::snprintf(buffer, strerror_buff_size, "unknown error %d", ev);
|
||||
return string(buffer);
|
||||
}
|
||||
#else
|
||||
# else
|
||||
|
||||
// Only one of the two following functions will be used, depending on
|
||||
// the return type of strerror_r:
|
||||
|
||||
// For the GNU variant, a char* return value:
|
||||
__attribute__((unused)) const char *
|
||||
handle_strerror_r_return(char *strerror_return, char *buffer) {
|
||||
__attribute__((unused)) const char* handle_strerror_r_return(char* strerror_return, char* buffer) {
|
||||
// GNU always returns a string pointer in its return value. The
|
||||
// string might point to either the input buffer, or a static
|
||||
// buffer, but we don't care which.
|
||||
@@ -90,8 +55,7 @@ handle_strerror_r_return(char *strerror_return, char *buffer) {
|
||||
}
|
||||
|
||||
// For the POSIX variant: an int return value.
|
||||
__attribute__((unused)) const char *
|
||||
handle_strerror_r_return(int strerror_return, char *buffer) {
|
||||
__attribute__((unused)) const char* handle_strerror_r_return(int strerror_return, char* buffer) {
|
||||
// The POSIX variant either:
|
||||
// - fills in the provided buffer and returns 0
|
||||
// - returns a positive error value, or
|
||||
@@ -104,7 +68,7 @@ handle_strerror_r_return(int strerror_return, char *buffer) {
|
||||
if (new_errno == EINVAL)
|
||||
return "";
|
||||
|
||||
_LIBCPP_ASSERT_UNCATEGORIZED(new_errno == ERANGE, "unexpected error from ::strerror_r");
|
||||
_LIBCPP_ASSERT_INTERNAL(new_errno == ERANGE, "unexpected error from ::strerror_r");
|
||||
// FIXME maybe? 'strerror_buff_size' is likely to exceed the
|
||||
// maximum error size so ERANGE shouldn't be returned.
|
||||
std::abort();
|
||||
@@ -113,184 +77,146 @@ handle_strerror_r_return(int strerror_return, char *buffer) {
|
||||
// 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);
|
||||
error_message = buffer;
|
||||
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);
|
||||
error_message = buffer;
|
||||
}
|
||||
errno = old_errno;
|
||||
return string(error_message);
|
||||
}
|
||||
# endif
|
||||
|
||||
#endif // !defined(_LIBCPP_HAS_NO_THREADS)
|
||||
|
||||
string make_error_str(const error_code& ec, string what_arg) {
|
||||
if (ec) {
|
||||
if (!what_arg.empty()) {
|
||||
what_arg += ": ";
|
||||
}
|
||||
errno = old_errno;
|
||||
return string(error_message);
|
||||
what_arg += ec.message();
|
||||
}
|
||||
return what_arg;
|
||||
}
|
||||
|
||||
string make_error_str(const error_code& ec) {
|
||||
if (ec) {
|
||||
return ec.message();
|
||||
}
|
||||
return string();
|
||||
}
|
||||
#endif
|
||||
} // end namespace
|
||||
#endif
|
||||
|
||||
string
|
||||
__do_message::message(int ev) const
|
||||
{
|
||||
string __do_message::message(int ev) const {
|
||||
#if defined(_LIBCPP_HAS_NO_THREADS)
|
||||
return string(::strerror(ev));
|
||||
return string(::strerror(ev));
|
||||
#else
|
||||
return do_strerror_r(ev);
|
||||
return do_strerror_r(ev);
|
||||
#endif
|
||||
}
|
||||
|
||||
class _LIBCPP_HIDDEN __generic_error_category
|
||||
: public __do_message
|
||||
{
|
||||
class _LIBCPP_HIDDEN __generic_error_category : public __do_message {
|
||||
public:
|
||||
virtual const char* name() const noexcept;
|
||||
virtual string message(int ev) const;
|
||||
virtual const char* name() const noexcept;
|
||||
virtual string message(int ev) const;
|
||||
};
|
||||
|
||||
const char*
|
||||
__generic_error_category::name() const noexcept
|
||||
{
|
||||
return "generic";
|
||||
}
|
||||
const char* __generic_error_category::name() const noexcept { return "generic"; }
|
||||
|
||||
string
|
||||
__generic_error_category::message(int ev) const
|
||||
{
|
||||
string __generic_error_category::message(int ev) const {
|
||||
#ifdef _LIBCPP_ELAST
|
||||
if (ev > _LIBCPP_ELAST)
|
||||
return string("unspecified generic_category error");
|
||||
if (ev > _LIBCPP_ELAST)
|
||||
return string("unspecified generic_category error");
|
||||
#endif // _LIBCPP_ELAST
|
||||
return __do_message::message(ev);
|
||||
return __do_message::message(ev);
|
||||
}
|
||||
|
||||
const error_category&
|
||||
generic_category() noexcept
|
||||
{
|
||||
static __generic_error_category s;
|
||||
return s;
|
||||
const error_category& generic_category() noexcept {
|
||||
union AvoidDestroyingGenericCategory {
|
||||
__generic_error_category generic_error_category;
|
||||
constexpr explicit AvoidDestroyingGenericCategory() : generic_error_category() {}
|
||||
~AvoidDestroyingGenericCategory() {}
|
||||
};
|
||||
constinit static AvoidDestroyingGenericCategory helper;
|
||||
return helper.generic_error_category;
|
||||
}
|
||||
|
||||
class _LIBCPP_HIDDEN __system_error_category
|
||||
: public __do_message
|
||||
{
|
||||
class _LIBCPP_HIDDEN __system_error_category : public __do_message {
|
||||
public:
|
||||
virtual const char* name() const noexcept;
|
||||
virtual string message(int ev) const;
|
||||
virtual error_condition default_error_condition(int ev) const noexcept;
|
||||
virtual const char* name() const noexcept;
|
||||
virtual string message(int ev) const;
|
||||
virtual error_condition default_error_condition(int ev) const noexcept;
|
||||
};
|
||||
|
||||
const char*
|
||||
__system_error_category::name() const noexcept
|
||||
{
|
||||
return "system";
|
||||
}
|
||||
const char* __system_error_category::name() const noexcept { return "system"; }
|
||||
|
||||
string
|
||||
__system_error_category::message(int ev) const
|
||||
{
|
||||
string __system_error_category::message(int ev) const {
|
||||
#ifdef _LIBCPP_ELAST
|
||||
if (ev > _LIBCPP_ELAST)
|
||||
return string("unspecified system_category error");
|
||||
if (ev > _LIBCPP_ELAST)
|
||||
return string("unspecified system_category error");
|
||||
#endif // _LIBCPP_ELAST
|
||||
return __do_message::message(ev);
|
||||
return __do_message::message(ev);
|
||||
}
|
||||
|
||||
error_condition
|
||||
__system_error_category::default_error_condition(int ev) const noexcept
|
||||
{
|
||||
error_condition __system_error_category::default_error_condition(int ev) const noexcept {
|
||||
#ifdef _LIBCPP_ELAST
|
||||
if (ev > _LIBCPP_ELAST)
|
||||
return error_condition(ev, system_category());
|
||||
if (ev > _LIBCPP_ELAST)
|
||||
return error_condition(ev, system_category());
|
||||
#endif // _LIBCPP_ELAST
|
||||
return error_condition(ev, generic_category());
|
||||
return error_condition(ev, generic_category());
|
||||
}
|
||||
|
||||
const error_category&
|
||||
system_category() noexcept
|
||||
{
|
||||
static __system_error_category s;
|
||||
return s;
|
||||
const error_category& system_category() noexcept {
|
||||
union AvoidDestroyingSystemCategory {
|
||||
__system_error_category system_error_category;
|
||||
constexpr explicit AvoidDestroyingSystemCategory() : system_error_category() {}
|
||||
~AvoidDestroyingSystemCategory() {}
|
||||
};
|
||||
constinit static AvoidDestroyingSystemCategory helper;
|
||||
return helper.system_error_category;
|
||||
}
|
||||
|
||||
// error_condition
|
||||
|
||||
string
|
||||
error_condition::message() const
|
||||
{
|
||||
return __cat_->message(__val_);
|
||||
}
|
||||
string error_condition::message() const { return __cat_->message(__val_); }
|
||||
|
||||
// error_code
|
||||
|
||||
string
|
||||
error_code::message() const
|
||||
{
|
||||
return __cat_->message(__val_);
|
||||
}
|
||||
string error_code::message() const { return __cat_->message(__val_); }
|
||||
|
||||
// system_error
|
||||
|
||||
string
|
||||
system_error::__init(const error_code& ec, string what_arg)
|
||||
{
|
||||
if (ec)
|
||||
{
|
||||
if (!what_arg.empty())
|
||||
what_arg += ": ";
|
||||
what_arg += ec.message();
|
||||
}
|
||||
return what_arg;
|
||||
}
|
||||
|
||||
system_error::system_error(error_code ec, const string& what_arg)
|
||||
: runtime_error(__init(ec, what_arg)),
|
||||
__ec_(ec)
|
||||
{
|
||||
}
|
||||
: runtime_error(make_error_str(ec, what_arg)), __ec_(ec) {}
|
||||
|
||||
system_error::system_error(error_code ec, const char* what_arg)
|
||||
: runtime_error(__init(ec, what_arg)),
|
||||
__ec_(ec)
|
||||
{
|
||||
}
|
||||
: runtime_error(make_error_str(ec, what_arg)), __ec_(ec) {}
|
||||
|
||||
system_error::system_error(error_code ec)
|
||||
: runtime_error(__init(ec, "")),
|
||||
__ec_(ec)
|
||||
{
|
||||
}
|
||||
system_error::system_error(error_code ec) : runtime_error(make_error_str(ec)), __ec_(ec) {}
|
||||
|
||||
system_error::system_error(int ev, const error_category& ecat, const string& what_arg)
|
||||
: runtime_error(__init(error_code(ev, ecat), what_arg)),
|
||||
__ec_(error_code(ev, ecat))
|
||||
{
|
||||
}
|
||||
: runtime_error(make_error_str(error_code(ev, ecat), what_arg)), __ec_(error_code(ev, ecat)) {}
|
||||
|
||||
system_error::system_error(int ev, const error_category& ecat, const char* what_arg)
|
||||
: runtime_error(__init(error_code(ev, ecat), what_arg)),
|
||||
__ec_(error_code(ev, ecat))
|
||||
{
|
||||
}
|
||||
: runtime_error(make_error_str(error_code(ev, ecat), what_arg)), __ec_(error_code(ev, ecat)) {}
|
||||
|
||||
system_error::system_error(int ev, const error_category& ecat)
|
||||
: runtime_error(__init(error_code(ev, ecat), "")),
|
||||
__ec_(error_code(ev, ecat))
|
||||
{
|
||||
}
|
||||
: runtime_error(make_error_str(error_code(ev, ecat))), __ec_(error_code(ev, ecat)) {}
|
||||
|
||||
system_error::~system_error() noexcept
|
||||
{
|
||||
}
|
||||
system_error::~system_error() noexcept {}
|
||||
|
||||
void
|
||||
__throw_system_error(int ev, const char* what_arg)
|
||||
{
|
||||
void __throw_system_error(int ev, const char* what_arg) {
|
||||
#ifndef _LIBCPP_HAS_NO_EXCEPTIONS
|
||||
throw system_error(error_code(ev, system_category()), what_arg);
|
||||
std::__throw_system_error(error_code(ev, system_category()), what_arg);
|
||||
#else
|
||||
_LIBCPP_VERBOSE_ABORT("system_error was thrown in -fno-exceptions mode with error %i and message \"%s\"", ev, what_arg);
|
||||
// The above could also handle the no-exception case, but for size, avoid referencing system_category() unnecessarily.
|
||||
_LIBCPP_VERBOSE_ABORT(
|
||||
"system_error was thrown in -fno-exceptions mode with error %i and message \"%s\"", ev, what_arg);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user