2 * Copyright 2017-present Facebook, Inc.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
18 * Author: Eric Niebler <eniebler@fb.com>
21 #include <folly/Portability.h>
26 struct exception_wrapper::arg_type_
27 : public arg_type_<decltype(&Fn::operator())> {
29 template <class Ret, class Class, class Arg>
30 struct exception_wrapper::arg_type_<Ret (Class::*)(Arg)> {
33 template <class Ret, class Class, class Arg>
34 struct exception_wrapper::arg_type_<Ret (Class::*)(Arg) const> {
37 template <class Ret, class Arg>
38 struct exception_wrapper::arg_type_<Ret (Arg)> {
41 template <class Ret, class Arg>
42 struct exception_wrapper::arg_type_<Ret (*)(Arg)> {
45 template <class Ret, class Class>
46 struct exception_wrapper::arg_type_<Ret (Class::*)(...)> {
47 using type = AnyException;
49 template <class Ret, class Class>
50 struct exception_wrapper::arg_type_<Ret (Class::*)(...) const> {
51 using type = AnyException;
54 struct exception_wrapper::arg_type_<Ret (...)> {
55 using type = AnyException;
58 struct exception_wrapper::arg_type_<Ret (*)(...)> {
59 using type = AnyException;
62 template <class Ret, class... Args>
63 inline Ret exception_wrapper::noop_(Args...) {
67 inline std::type_info const* exception_wrapper::uninit_type_(
68 exception_wrapper const*) {
72 template <class Ex, class DEx>
73 inline exception_wrapper::Buffer::Buffer(in_place_t, Ex&& ex) {
74 ::new (static_cast<void*>(&buff_)) DEx(std::forward<Ex>(ex));
78 inline Ex& exception_wrapper::Buffer::as() noexcept {
79 return *static_cast<Ex*>(static_cast<void*>(&buff_));
82 inline Ex const& exception_wrapper::Buffer::as() const noexcept {
83 return *static_cast<Ex const*>(static_cast<void const*>(&buff_));
86 inline std::exception const* exception_wrapper::as_exception_or_null_(
87 std::exception const& ex) {
90 inline std::exception const* exception_wrapper::as_exception_or_null_(
96 !kIsWindows || sizeof(void*) == 8,
97 "exception_wrapper is untested on 32 bit Windows.");
99 !kIsWindows || (kMscVer >= 1900 && kMscVer <= 2000),
100 "exception_wrapper is untested and possibly broken on your version of "
103 inline std::uintptr_t exception_wrapper::ExceptionPtr::as_int_(
104 std::exception_ptr const& ptr,
105 std::exception const& e) {
107 return reinterpret_cast<std::uintptr_t>(&e);
109 // On Windows, as of MSVC2017, all thrown exceptions are copied to the stack
110 // first. Thus, we cannot depend on exception references associated with an
111 // exception_ptr to be live for the duration of the exception_ptr. We need
112 // to directly access the heap allocated memory inside the exception_ptr.
114 // std::exception_ptr is an opaque reinterpret_cast of
115 // std::shared_ptr<__ExceptionPtr>
116 // __ExceptionPtr is a non-virtual class with two members, a union and a
117 // bool. The union contains the now-undocumented EHExceptionRecord, which
118 // contains a struct which contains a void* which points to the heap
119 // allocated exception.
120 // We derive the offset to pExceptionObject via manual means.
122 struct Win32ExceptionPtr {
124 void* exceptionObject;
128 auto* win32ExceptionPtr =
129 reinterpret_cast<std::shared_ptr<Win32ExceptionPtr> const*>(
131 return reinterpret_cast<std::uintptr_t>(win32ExceptionPtr->exceptionObject);
134 inline std::uintptr_t exception_wrapper::ExceptionPtr::as_int_(
135 std::exception_ptr const&,
137 return reinterpret_cast<std::uintptr_t>(e.typeinfo_) + 1;
139 inline bool exception_wrapper::ExceptionPtr::has_exception_() const {
140 return 0 == exception_or_type_ % 2;
142 inline std::exception const* exception_wrapper::ExceptionPtr::as_exception_()
144 return reinterpret_cast<std::exception const*>(exception_or_type_);
146 inline std::type_info const* exception_wrapper::ExceptionPtr::as_type_() const {
147 return reinterpret_cast<std::type_info const*>(exception_or_type_ - 1);
150 inline void exception_wrapper::ExceptionPtr::copy_(
151 exception_wrapper const* from, exception_wrapper* to) {
152 ::new (static_cast<void*>(&to->eptr_)) ExceptionPtr(from->eptr_);
154 inline void exception_wrapper::ExceptionPtr::move_(
155 exception_wrapper* from, exception_wrapper* to) {
156 ::new (static_cast<void*>(&to->eptr_))
157 ExceptionPtr(std::move(from->eptr_));
160 inline void exception_wrapper::ExceptionPtr::delete_(
161 exception_wrapper* that) {
162 that->eptr_.~ExceptionPtr();
163 that->vptr_ = &uninit_;
165 [[noreturn]] inline void exception_wrapper::ExceptionPtr::throw_(
166 exception_wrapper const* that) {
167 std::rethrow_exception(that->eptr_.ptr_);
169 inline std::type_info const* exception_wrapper::ExceptionPtr::type_(
170 exception_wrapper const* that) {
171 if (auto e = get_exception_(that)) {
174 return that->eptr_.as_type_();
176 inline std::exception const* exception_wrapper::ExceptionPtr::get_exception_(
177 exception_wrapper const* that) {
178 return that->eptr_.has_exception_() ? that->eptr_.as_exception_()
181 inline exception_wrapper exception_wrapper::ExceptionPtr::get_exception_ptr_(
182 exception_wrapper const* that) {
187 inline void exception_wrapper::InPlace<Ex>::copy_(
188 exception_wrapper const* from, exception_wrapper* to) {
189 ::new (static_cast<void*>(std::addressof(to->buff_.as<Ex>())))
190 Ex(from->buff_.as<Ex>());
193 inline void exception_wrapper::InPlace<Ex>::move_(
194 exception_wrapper* from, exception_wrapper* to) {
195 ::new (static_cast<void*>(std::addressof(to->buff_.as<Ex>())))
196 Ex(std::move(from->buff_.as<Ex>()));
200 inline void exception_wrapper::InPlace<Ex>::delete_(
201 exception_wrapper* that) {
202 that->buff_.as<Ex>().~Ex();
203 that->vptr_ = &uninit_;
206 [[noreturn]] inline void exception_wrapper::InPlace<Ex>::throw_(
207 exception_wrapper const* that) {
208 throw that->buff_.as<Ex>(); // @nolint
211 inline std::type_info const* exception_wrapper::InPlace<Ex>::type_(
212 exception_wrapper const*) {
216 inline std::exception const* exception_wrapper::InPlace<Ex>::get_exception_(
217 exception_wrapper const* that) {
218 return as_exception_or_null_(that->buff_.as<Ex>());
221 inline exception_wrapper exception_wrapper::InPlace<Ex>::get_exception_ptr_(
222 exception_wrapper const* that) {
225 } catch (Ex const& ex) {
226 return exception_wrapper{std::current_exception(), ex};
231 [[noreturn]] inline void
232 exception_wrapper::SharedPtr::Impl<Ex>::throw_() const {
233 throw ex_; // @nolint
236 inline std::exception const*
237 exception_wrapper::SharedPtr::Impl<Ex>::get_exception_() const noexcept {
238 return as_exception_or_null_(ex_);
241 inline exception_wrapper
242 exception_wrapper::SharedPtr::Impl<Ex>::get_exception_ptr_() const noexcept {
246 return exception_wrapper{std::current_exception(), ex};
249 inline void exception_wrapper::SharedPtr::copy_(
250 exception_wrapper const* from, exception_wrapper* to) {
251 ::new (static_cast<void*>(std::addressof(to->sptr_)))
252 SharedPtr(from->sptr_);
254 inline void exception_wrapper::SharedPtr::move_(
255 exception_wrapper* from, exception_wrapper* to) {
256 ::new (static_cast<void*>(std::addressof(to->sptr_)))
257 SharedPtr(std::move(from->sptr_));
260 inline void exception_wrapper::SharedPtr::delete_(
261 exception_wrapper* that) {
262 that->sptr_.~SharedPtr();
263 that->vptr_ = &uninit_;
265 [[noreturn]] inline void exception_wrapper::SharedPtr::throw_(
266 exception_wrapper const* that) {
267 that->sptr_.ptr_->throw_();
268 folly::assume_unreachable();
270 inline std::type_info const* exception_wrapper::SharedPtr::type_(
271 exception_wrapper const* that) {
272 return that->sptr_.ptr_->info_;
274 inline std::exception const* exception_wrapper::SharedPtr::get_exception_(
275 exception_wrapper const* that) {
276 return that->sptr_.ptr_->get_exception_();
278 inline exception_wrapper exception_wrapper::SharedPtr::get_exception_ptr_(
279 exception_wrapper const* that) {
280 return that->sptr_.ptr_->get_exception_ptr_();
283 template <class Ex, class DEx>
284 inline exception_wrapper::exception_wrapper(Ex&& ex, OnHeapTag)
285 : sptr_{std::make_shared<SharedPtr::Impl<DEx>>(std::forward<Ex>(ex))},
286 vptr_(&SharedPtr::ops_) {}
288 template <class Ex, class DEx>
289 inline exception_wrapper::exception_wrapper(Ex&& ex, InSituTag)
290 : buff_{in_place, std::forward<Ex>(ex)}, vptr_(&InPlace<DEx>::ops_) {}
292 inline exception_wrapper::exception_wrapper(exception_wrapper&& that) noexcept
293 : exception_wrapper{} {
294 (vptr_ = that.vptr_)->move_(&that, this); // Move into *this, won't throw
297 inline exception_wrapper::exception_wrapper(
298 exception_wrapper const& that) : exception_wrapper{} {
299 that.vptr_->copy_(&that, this); // could throw
303 // If `this == &that`, this move assignment operator leaves the object in a
304 // valid but unspecified state.
305 inline exception_wrapper& exception_wrapper::operator=(
306 exception_wrapper&& that) noexcept {
307 vptr_->delete_(this); // Free the current exception
308 (vptr_ = that.vptr_)->move_(&that, this); // Move into *this, won't throw
312 inline exception_wrapper& exception_wrapper::operator=(
313 exception_wrapper const& that) {
314 exception_wrapper(that).swap(*this);
318 inline exception_wrapper::~exception_wrapper() {
323 inline exception_wrapper::exception_wrapper(std::exception_ptr ptr, Ex& ex)
324 : eptr_{ptr, ExceptionPtr::as_int_(ptr, ex)},
325 vptr_(&ExceptionPtr::ops_) {
329 namespace exception_wrapper_detail {
331 Ex&& dont_slice(Ex&& ex) {
332 assert(typeid(ex) == typeid(_t<std::decay<Ex>>) ||
333 !"Dynamic and static exception types don't match. Exception would "
334 "be sliced when storing in exception_wrapper.");
335 return std::forward<Ex>(ex);
344 exception_wrapper::IsStdException<Ex_>,
345 exception_wrapper::IsRegularExceptionType<Ex_>>::value)>
346 inline exception_wrapper::exception_wrapper(Ex&& ex)
348 exception_wrapper_detail::dont_slice(std::forward<Ex>(ex)),
349 PlacementOf<Ex_>{}} {
356 exception_wrapper::IsRegularExceptionType<Ex_>::value)>
357 inline exception_wrapper::exception_wrapper(in_place_t, Ex&& ex)
359 exception_wrapper_detail::dont_slice(std::forward<Ex>(ex)),
360 PlacementOf<Ex_>{}} {
363 inline void exception_wrapper::swap(exception_wrapper& that) noexcept {
364 exception_wrapper tmp(std::move(that));
365 that = std::move(*this);
366 *this = std::move(tmp);
369 inline exception_wrapper::operator bool() const noexcept {
370 return vptr_ != &uninit_;
373 inline bool exception_wrapper::operator!() const noexcept {
374 return !static_cast<bool>(*this);
377 inline void exception_wrapper::reset() {
378 vptr_->delete_(this);
381 inline bool exception_wrapper::has_exception_ptr() const noexcept {
382 return vptr_ == &ExceptionPtr::ops_;
385 inline std::exception* exception_wrapper::get_exception() noexcept {
386 return const_cast<std::exception*>(vptr_->get_exception_(this));
388 inline std::exception const* exception_wrapper::get_exception() const noexcept {
389 return vptr_->get_exception_(this);
392 template <typename Ex>
393 inline Ex* exception_wrapper::get_exception() noexcept {
395 with_exception([&](Ex& ex) { object = &ex; });
399 template <typename Ex>
400 inline Ex const* exception_wrapper::get_exception() const noexcept {
401 Ex const* object{nullptr};
402 with_exception([&](Ex const& ex) { object = &ex; });
406 inline std::exception_ptr const& exception_wrapper::to_exception_ptr()
408 // Computing an exception_ptr is expensive so cache the result.
409 return (*this = vptr_->get_exception_ptr_(this)).eptr_.ptr_;
411 inline std::exception_ptr exception_wrapper::to_exception_ptr() const noexcept {
412 return vptr_->get_exception_ptr_(this).eptr_.ptr_;
415 inline std::type_info const& exception_wrapper::none() noexcept {
418 inline std::type_info const& exception_wrapper::unknown() noexcept {
419 return typeid(Unknown);
422 inline std::type_info const& exception_wrapper::type() const noexcept {
423 return *vptr_->type_(this);
426 inline folly::fbstring exception_wrapper::what() const {
427 if (auto e = get_exception()) {
428 return class_name() + ": " + e->what();
433 inline folly::fbstring exception_wrapper::class_name() const {
437 : ti == unknown() ? "<unknown exception>" : folly::demangle(ti);
441 inline bool exception_wrapper::is_compatible_with() const noexcept {
442 return with_exception([](Ex const&) {});
445 [[noreturn]] inline void exception_wrapper::throw_exception() const {
447 onNoExceptionError();
450 template <class CatchFn, bool IsConst>
451 struct exception_wrapper::ExceptionTypeOf {
452 using type = arg_type<_t<std::decay<CatchFn>>>;
454 std::is_reference<type>::value,
455 "Always catch exceptions by reference.");
457 !IsConst || std::is_const<_t<std::remove_reference<type>>>::value,
458 "handle() or with_exception() called on a const exception_wrapper "
459 "and asked to catch a non-const exception. Handler will never fire. "
460 "Catch exception by const reference to fix this.");
463 // Nests a throw in the proper try/catch blocks
464 template <bool IsConst>
465 struct exception_wrapper::HandleReduce {
471 FOLLY_REQUIRES(!IsCatchAll<CatchFn>::value)>
472 auto operator()(ThrowFn&& th, CatchFn& ca) const {
473 using Ex = _t<ExceptionTypeOf<CatchFn, IsConst>>;
474 return [ th = std::forward<ThrowFn>(th), &ca, handled_ = handled_ ] {
478 // If we got here because a catch function threw, rethrow.
491 FOLLY_REQUIRES(IsCatchAll<CatchFn>::value)>
492 auto operator()(ThrowFn&& th, CatchFn& ca) const {
493 return [ th = std::forward<ThrowFn>(th), &ca, handled_ = handled_ ] {
497 // If we got here because a catch function threw, rethrow.
508 // When all the handlers expect types derived from std::exception, we can
509 // sometimes invoke the handlers without throwing any exceptions.
510 template <bool IsConst>
511 struct exception_wrapper::HandleStdExceptReduce {
512 using StdEx = AddConstIf<IsConst, std::exception>;
517 FOLLY_REQUIRES(!IsCatchAll<CatchFn>::value)>
518 auto operator()(ThrowFn&& th, CatchFn& ca) const {
519 using Ex = _t<ExceptionTypeOf<CatchFn, IsConst>>;
520 return [ th = std::forward<ThrowFn>(th), &ca ](auto&& continuation)
522 if (auto e = const_cast<StdEx*>(th(continuation))) {
523 if (auto e2 = dynamic_cast<_t<std::add_pointer<Ex>>>(e)) {
536 FOLLY_REQUIRES(IsCatchAll<CatchFn>::value)>
537 auto operator()(ThrowFn&& th, CatchFn& ca) const {
538 return [ th = std::forward<ThrowFn>(th), &ca ](auto&&) -> StdEx* {
539 // The following continuation causes ca() to execute if *this contains
540 // an exception /not/ derived from std::exception.
541 auto continuation = [&ca](StdEx* e) {
542 return e != nullptr ? e : ((void)ca(), nullptr);
544 if (th(continuation) != nullptr) {
552 // Called when some types in the catch clauses are not derived from
554 template <class This, class... CatchFns>
555 inline void exception_wrapper::handle_(
556 std::false_type, This& this_, CatchFns&... fns) {
557 bool handled = false;
558 auto impl = exception_wrapper_detail::fold(
559 HandleReduce<std::is_const<This>::value>{&handled},
560 [&] { this_.throw_exception(); },
565 // Called when all types in the catch clauses are either derived from
566 // std::exception or a catch-all clause.
567 template <class This, class... CatchFns>
568 inline void exception_wrapper::handle_(
569 std::true_type, This& this_, CatchFns&... fns) {
570 using StdEx = exception_wrapper_detail::
571 AddConstIf<std::is_const<This>::value, std::exception>;
572 auto impl = exception_wrapper_detail::fold(
573 HandleStdExceptReduce<std::is_const<This>::value>{},
574 [&](auto&& continuation) {
576 const_cast<StdEx*>(this_.vptr_->get_exception_(&this_)));
579 // This continuation gets evaluated if CatchFns... does not include a
580 // catch-all handler. It is a no-op.
581 auto continuation = [](StdEx* ex) { return ex; };
582 if (StdEx* e = impl(continuation)) {
583 throw *e; // Not handled. Throw.
587 namespace exception_wrapper_detail {
588 template <class Ex, class Fn>
591 auto operator()(Ex& ex) {
596 template <class Ex, class Fn>
597 inline catch_fn<Ex, Fn> catch_(Ex*, Fn fn) {
598 return {std::move(fn)};
601 inline Fn catch_(void const*, Fn fn) {
604 } // namespace exception_wrapper_detail
606 template <class Ex, class This, class Fn>
607 inline bool exception_wrapper::with_exception_(This& this_, Fn fn_) {
612 auto fn = exception_wrapper_detail::catch_(
613 static_cast<Ex*>(nullptr), std::move(fn_));
614 auto&& all = [&](...) { handled = false; };
615 handle_(IsStdException<arg_type<decltype(fn)>>{}, this_, fn, all);
619 template <class Ex, class Fn>
620 inline bool exception_wrapper::with_exception(Fn fn) {
621 return with_exception_<Ex>(*this, std::move(fn));
623 template <class Ex, class Fn>
624 inline bool exception_wrapper::with_exception(Fn fn) const {
625 return with_exception_<Ex const>(*this, std::move(fn));
628 template <class... CatchFns>
629 inline void exception_wrapper::handle(CatchFns... fns) {
631 exception_wrapper_detail::AllOf<IsStdException, arg_type<CatchFns>...>;
633 onNoExceptionError();
635 this->handle_(AllStdEx{}, *this, fns...);
637 template <class... CatchFns>
638 inline void exception_wrapper::handle(CatchFns... fns) const {
640 exception_wrapper_detail::AllOf<IsStdException, arg_type<CatchFns>...>;
642 onNoExceptionError();
644 this->handle_(AllStdEx{}, *this, fns...);