When we build the library with the stable ABI, we need to include some functions in the dylib that were made inline in later versions of the library (to avoid breaking code that might be relying on those symbols). However, those methods were made non-inline whenever we'd be building the library, which means that all translation units would end up using the old out-of-line definition of these methods, as opposed to the new inlined version. This patch makes it so that only the translation units that actually define the out-of-line methods use the old definition, opening up potential optimization opportunities in other translation units. This should solve some of the issues encountered in D65667. Differential Revision: https://reviews.llvm.org/D123519
299 lines
7.0 KiB
C++
299 lines
7.0 KiB
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 <__config>
|
|
#ifdef _LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS
|
|
# define _LIBCPP_ERROR_CATEGORY_DEFINE_LEGACY_INLINE_FUNCTIONS
|
|
#endif
|
|
|
|
#include <__assert>
|
|
#include <cerrno>
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
#include <cstring>
|
|
#include <string>
|
|
#include <string.h>
|
|
#include <system_error>
|
|
|
|
#include "include/config_elast.h"
|
|
|
|
#if defined(__ANDROID__)
|
|
#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 {
|
|
|
|
// 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)
|
|
string do_strerror_r(int ev) {
|
|
char buffer[strerror_buff_size];
|
|
if (::strerror_s(buffer, strerror_buff_size, ev) == 0)
|
|
return string(buffer);
|
|
std::snprintf(buffer, strerror_buff_size, "unknown error %d", ev);
|
|
return string(buffer);
|
|
}
|
|
#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) {
|
|
// 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.
|
|
return strerror_return;
|
|
}
|
|
|
|
// For the POSIX variant: an int return value.
|
|
__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
|
|
// - returns -1 and fills in errno with an error value.
|
|
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");
|
|
// 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);
|
|
error_message = buffer;
|
|
}
|
|
errno = old_errno;
|
|
return string(error_message);
|
|
}
|
|
#endif
|
|
} // end namespace
|
|
#endif
|
|
|
|
string
|
|
__do_message::message(int ev) const
|
|
{
|
|
#if defined(_LIBCPP_HAS_NO_THREADS)
|
|
return string(::strerror(ev));
|
|
#else
|
|
return do_strerror_r(ev);
|
|
#endif
|
|
}
|
|
|
|
class _LIBCPP_HIDDEN __generic_error_category
|
|
: public __do_message
|
|
{
|
|
public:
|
|
virtual const char* name() const noexcept;
|
|
virtual string message(int ev) const;
|
|
};
|
|
|
|
const char*
|
|
__generic_error_category::name() const noexcept
|
|
{
|
|
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 __do_message::message(ev);
|
|
}
|
|
|
|
const error_category&
|
|
generic_category() noexcept
|
|
{
|
|
static __generic_error_category s;
|
|
return s;
|
|
}
|
|
|
|
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;
|
|
};
|
|
|
|
const char*
|
|
__system_error_category::name() const noexcept
|
|
{
|
|
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 __do_message::message(ev);
|
|
}
|
|
|
|
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());
|
|
#endif // _LIBCPP_ELAST
|
|
return error_condition(ev, generic_category());
|
|
}
|
|
|
|
const error_category&
|
|
system_category() noexcept
|
|
{
|
|
static __system_error_category s;
|
|
return s;
|
|
}
|
|
|
|
// error_condition
|
|
|
|
string
|
|
error_condition::message() const
|
|
{
|
|
return __cat_->message(__val_);
|
|
}
|
|
|
|
// error_code
|
|
|
|
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)
|
|
{
|
|
}
|
|
|
|
system_error::system_error(error_code ec, const char* what_arg)
|
|
: runtime_error(__init(ec, what_arg)),
|
|
__ec_(ec)
|
|
{
|
|
}
|
|
|
|
system_error::system_error(error_code ec)
|
|
: runtime_error(__init(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))
|
|
{
|
|
}
|
|
|
|
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))
|
|
{
|
|
}
|
|
|
|
system_error::system_error(int ev, const error_category& ecat)
|
|
: runtime_error(__init(error_code(ev, ecat), "")),
|
|
__ec_(error_code(ev, ecat))
|
|
{
|
|
}
|
|
|
|
system_error::~system_error() noexcept
|
|
{
|
|
}
|
|
|
|
void
|
|
__throw_system_error(int ev, const char* what_arg)
|
|
{
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
throw system_error(error_code(ev, system_category()), what_arg);
|
|
#else
|
|
(void)ev;
|
|
(void)what_arg;
|
|
_VSTD::abort();
|
|
#endif
|
|
}
|
|
|
|
_LIBCPP_END_NAMESPACE_STD
|