1 //===----------------------------------------------------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #include <__assert> 10 #include <__config> 11 #include <__verbose_abort> 12 #include <cerrno> 13 #include <cstdio> 14 #include <cstdlib> 15 #include <cstring> 16 #include <string.h> 17 #include <string> 18 #include <system_error> 19 20 #include "include/config_elast.h" 21 22 #if defined(__ANDROID__) 23 # include <android/api-level.h> 24 #endif 25 26 _LIBCPP_BEGIN_NAMESPACE_STD 27 28 namespace { 29 #if !defined(_LIBCPP_HAS_NO_THREADS) 30 31 // GLIBC also uses 1024 as the maximum buffer size internally. 32 constexpr size_t strerror_buff_size = 1024; 33 34 string do_strerror_r(int ev); 35 36 # if defined(_LIBCPP_MSVCRT_LIKE) 37 string do_strerror_r(int ev) { 38 char buffer[strerror_buff_size]; 39 if (::strerror_s(buffer, strerror_buff_size, ev) == 0) 40 return string(buffer); 41 std::snprintf(buffer, strerror_buff_size, "unknown error %d", ev); 42 return string(buffer); 43 } 44 # else 45 46 // Only one of the two following functions will be used, depending on 47 // the return type of strerror_r: 48 49 // For the GNU variant, a char* return value: 50 __attribute__((unused)) const char* handle_strerror_r_return(char* strerror_return, char* buffer) { 51 // GNU always returns a string pointer in its return value. The 52 // string might point to either the input buffer, or a static 53 // buffer, but we don't care which. 54 return strerror_return; 55 } 56 57 // For the POSIX variant: an int return value. 58 __attribute__((unused)) const char* handle_strerror_r_return(int strerror_return, char* buffer) { 59 // The POSIX variant either: 60 // - fills in the provided buffer and returns 0 61 // - returns a positive error value, or 62 // - returns -1 and fills in errno with an error value. 63 if (strerror_return == 0) 64 return buffer; 65 66 // Only handle EINVAL. Other errors abort. 67 int new_errno = strerror_return == -1 ? errno : strerror_return; 68 if (new_errno == EINVAL) 69 return ""; 70 71 _LIBCPP_ASSERT_INTERNAL(new_errno == ERANGE, "unexpected error from ::strerror_r"); 72 // FIXME maybe? 'strerror_buff_size' is likely to exceed the 73 // maximum error size so ERANGE shouldn't be returned. 74 std::abort(); 75 } 76 77 // This function handles both GNU and POSIX variants, dispatching to 78 // one of the two above functions. 79 string do_strerror_r(int ev) { 80 char buffer[strerror_buff_size]; 81 // Preserve errno around the call. (The C++ standard requires that 82 // system_error functions not modify errno). 83 const int old_errno = errno; 84 const char* error_message = handle_strerror_r_return(::strerror_r(ev, buffer, strerror_buff_size), buffer); 85 // If we didn't get any message, print one now. 86 if (!error_message[0]) { 87 std::snprintf(buffer, strerror_buff_size, "Unknown error %d", ev); 88 error_message = buffer; 89 } 90 errno = old_errno; 91 return string(error_message); 92 } 93 # endif 94 95 #endif // !defined(_LIBCPP_HAS_NO_THREADS) 96 97 string make_error_str(const error_code& ec, string what_arg) { 98 if (ec) { 99 if (!what_arg.empty()) { 100 what_arg += ": "; 101 } 102 what_arg += ec.message(); 103 } 104 return what_arg; 105 } 106 107 string make_error_str(const error_code& ec) { 108 if (ec) { 109 return ec.message(); 110 } 111 return string(); 112 } 113 } // end namespace 114 115 string __do_message::message(int ev) const { 116 #if defined(_LIBCPP_HAS_NO_THREADS) 117 return string(::strerror(ev)); 118 #else 119 return do_strerror_r(ev); 120 #endif 121 } 122 123 class _LIBCPP_HIDDEN __generic_error_category : public __do_message { 124 public: 125 virtual const char* name() const noexcept; 126 virtual string message(int ev) const; 127 }; 128 129 const char* __generic_error_category::name() const noexcept { return "generic"; } 130 131 string __generic_error_category::message(int ev) const { 132 #ifdef _LIBCPP_ELAST 133 if (ev > _LIBCPP_ELAST) 134 return string("unspecified generic_category error"); 135 #endif // _LIBCPP_ELAST 136 return __do_message::message(ev); 137 } 138 139 const error_category& generic_category() noexcept { 140 union AvoidDestroyingGenericCategory { 141 __generic_error_category generic_error_category; 142 constexpr explicit AvoidDestroyingGenericCategory() : generic_error_category() {} 143 ~AvoidDestroyingGenericCategory() {} 144 }; 145 constinit static AvoidDestroyingGenericCategory helper; 146 return helper.generic_error_category; 147 } 148 149 class _LIBCPP_HIDDEN __system_error_category : public __do_message { 150 public: 151 virtual const char* name() const noexcept; 152 virtual string message(int ev) const; 153 virtual error_condition default_error_condition(int ev) const noexcept; 154 }; 155 156 const char* __system_error_category::name() const noexcept { return "system"; } 157 158 string __system_error_category::message(int ev) const { 159 #ifdef _LIBCPP_ELAST 160 if (ev > _LIBCPP_ELAST) 161 return string("unspecified system_category error"); 162 #endif // _LIBCPP_ELAST 163 return __do_message::message(ev); 164 } 165 166 error_condition __system_error_category::default_error_condition(int ev) const noexcept { 167 #ifdef _LIBCPP_ELAST 168 if (ev > _LIBCPP_ELAST) 169 return error_condition(ev, system_category()); 170 #endif // _LIBCPP_ELAST 171 return error_condition(ev, generic_category()); 172 } 173 174 const error_category& system_category() noexcept { 175 union AvoidDestroyingSystemCategory { 176 __system_error_category system_error_category; 177 constexpr explicit AvoidDestroyingSystemCategory() : system_error_category() {} 178 ~AvoidDestroyingSystemCategory() {} 179 }; 180 constinit static AvoidDestroyingSystemCategory helper; 181 return helper.system_error_category; 182 } 183 184 // error_condition 185 186 string error_condition::message() const { return __cat_->message(__val_); } 187 188 // error_code 189 190 string error_code::message() const { return __cat_->message(__val_); } 191 192 // system_error 193 194 system_error::system_error(error_code ec, const string& what_arg) 195 : runtime_error(make_error_str(ec, what_arg)), __ec_(ec) {} 196 197 system_error::system_error(error_code ec, const char* what_arg) 198 : runtime_error(make_error_str(ec, what_arg)), __ec_(ec) {} 199 200 system_error::system_error(error_code ec) : runtime_error(make_error_str(ec)), __ec_(ec) {} 201 202 system_error::system_error(int ev, const error_category& ecat, const string& what_arg) 203 : runtime_error(make_error_str(error_code(ev, ecat), what_arg)), __ec_(error_code(ev, ecat)) {} 204 205 system_error::system_error(int ev, const error_category& ecat, const char* what_arg) 206 : runtime_error(make_error_str(error_code(ev, ecat), what_arg)), __ec_(error_code(ev, ecat)) {} 207 208 system_error::system_error(int ev, const error_category& ecat) 209 : runtime_error(make_error_str(error_code(ev, ecat))), __ec_(error_code(ev, ecat)) {} 210 211 system_error::~system_error() noexcept {} 212 213 void __throw_system_error(int ev, const char* what_arg) { 214 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS 215 std::__throw_system_error(error_code(ev, system_category()), what_arg); 216 #else 217 // The above could also handle the no-exception case, but for size, avoid referencing system_category() unnecessarily. 218 _LIBCPP_VERBOSE_ABORT( 219 "system_error was thrown in -fno-exceptions mode with error %i and message \"%s\"", ev, what_arg); 220 #endif 221 } 222 223 _LIBCPP_END_NAMESPACE_STD 224