llvm-project

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