2845c2e36c8493d63ea05fe1ef11231bcf807448
[folly.git] / folly / ExceptionWrapper-inl.h
1 /*
2  * Copyright 2017-present Facebook, Inc.
3  *
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
7  *
8  *   http://www.apache.org/licenses/LICENSE-2.0
9  *
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.
15  */
16 /*
17  *
18  * Author: Eric Niebler <eniebler@fb.com>
19  */
20
21 #include <folly/Portability.h>
22
23 namespace folly {
24
25 template <class Fn>
26 struct exception_wrapper::arg_type_
27     : public arg_type_<decltype(&Fn::operator())> {
28 };
29 template <class Ret, class Class, class Arg>
30 struct exception_wrapper::arg_type_<Ret (Class::*)(Arg)> {
31   using type = Arg;
32 };
33 template <class Ret, class Class, class Arg>
34 struct exception_wrapper::arg_type_<Ret (Class::*)(Arg) const> {
35   using type = Arg;
36 };
37 template <class Ret, class Arg>
38 struct exception_wrapper::arg_type_<Ret (Arg)> {
39   using type = Arg;
40 };
41 template <class Ret, class Arg>
42 struct exception_wrapper::arg_type_<Ret (*)(Arg)> {
43   using type = Arg;
44 };
45 template <class Ret, class Class>
46 struct exception_wrapper::arg_type_<Ret (Class::*)(...)> {
47   using type = AnyException;
48 };
49 template <class Ret, class Class>
50 struct exception_wrapper::arg_type_<Ret (Class::*)(...) const> {
51   using type = AnyException;
52 };
53 template <class Ret>
54 struct exception_wrapper::arg_type_<Ret (...)> {
55   using type = AnyException;
56 };
57 template <class Ret>
58 struct exception_wrapper::arg_type_<Ret (*)(...)> {
59   using type = AnyException;
60 };
61
62 template <class Ret, class... Args>
63 inline Ret exception_wrapper::noop_(Args...) {
64   return Ret();
65 }
66
67 inline std::type_info const* exception_wrapper::uninit_type_(
68     exception_wrapper const*) {
69   return &typeid(void);
70 }
71
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));
75 }
76
77 template <class Ex>
78 inline Ex& exception_wrapper::Buffer::as() noexcept {
79   return *static_cast<Ex*>(static_cast<void*>(&buff_));
80 }
81 template <class Ex>
82 inline Ex const& exception_wrapper::Buffer::as() const noexcept {
83   return *static_cast<Ex const*>(static_cast<void const*>(&buff_));
84 }
85
86 inline std::exception const* exception_wrapper::as_exception_or_null_(
87     std::exception const& ex) {
88   return &ex;
89 }
90 inline std::exception const* exception_wrapper::as_exception_or_null_(
91     AnyException) {
92   return nullptr;
93 }
94
95 static_assert(
96     !kIsWindows || sizeof(void*) == 8,
97     "exception_wrapper is untested on 32 bit Windows.");
98 static_assert(
99     !kIsWindows || (kMscVer >= 1900 && kMscVer <= 2000),
100     "exception_wrapper is untested and possibly broken on your version of "
101     "MSVC");
102
103 inline std::uintptr_t exception_wrapper::ExceptionPtr::as_int_(
104     std::exception_ptr const& ptr,
105     std::exception const& e) {
106   if (!kIsWindows) {
107     return reinterpret_cast<std::uintptr_t>(&e);
108   } else {
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.
113     //
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.
121     FOLLY_PACK_PUSH
122     struct Win32ExceptionPtr {
123       char offset[40];
124       void* exceptionObject;
125     } FOLLY_PACK_ATTR;
126     FOLLY_PACK_POP
127
128     auto* win32ExceptionPtr =
129         reinterpret_cast<std::shared_ptr<Win32ExceptionPtr> const*>(
130             &ptr)->get();
131     return reinterpret_cast<std::uintptr_t>(win32ExceptionPtr->exceptionObject);
132   }
133 }
134 inline std::uintptr_t exception_wrapper::ExceptionPtr::as_int_(
135     std::exception_ptr const&,
136     AnyException e) {
137   return reinterpret_cast<std::uintptr_t>(e.typeinfo_) + 1;
138 }
139 inline bool exception_wrapper::ExceptionPtr::has_exception_() const {
140   return 0 == exception_or_type_ % 2;
141 }
142 inline std::exception const* exception_wrapper::ExceptionPtr::as_exception_()
143     const {
144   return reinterpret_cast<std::exception const*>(exception_or_type_);
145 }
146 inline std::type_info const* exception_wrapper::ExceptionPtr::as_type_() const {
147   return reinterpret_cast<std::type_info const*>(exception_or_type_ - 1);
148 }
149
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_);
153 }
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_));
158   delete_(from);
159 }
160 inline void exception_wrapper::ExceptionPtr::delete_(
161     exception_wrapper* that) {
162   that->eptr_.~ExceptionPtr();
163   that->vptr_ = &uninit_;
164 }
165 [[noreturn]] inline void exception_wrapper::ExceptionPtr::throw_(
166     exception_wrapper const* that) {
167   std::rethrow_exception(that->eptr_.ptr_);
168 }
169 inline std::type_info const* exception_wrapper::ExceptionPtr::type_(
170     exception_wrapper const* that) {
171   if (auto e = get_exception_(that)) {
172     return &typeid(*e);
173   }
174   return that->eptr_.as_type_();
175 }
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_()
179                                       : nullptr;
180 }
181 inline exception_wrapper exception_wrapper::ExceptionPtr::get_exception_ptr_(
182     exception_wrapper const* that) {
183   return *that;
184 }
185
186 template <class Ex>
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>());
191 }
192 template <class 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>()));
197   delete_(from);
198 }
199 template <class Ex>
200 inline void exception_wrapper::InPlace<Ex>::delete_(
201     exception_wrapper* that) {
202   that->buff_.as<Ex>().~Ex();
203   that->vptr_ = &uninit_;
204 }
205 template <class Ex>
206 [[noreturn]] inline void exception_wrapper::InPlace<Ex>::throw_(
207     exception_wrapper const* that) {
208   throw that->buff_.as<Ex>(); // @nolint
209 }
210 template <class Ex>
211 inline std::type_info const* exception_wrapper::InPlace<Ex>::type_(
212     exception_wrapper const*) {
213   return &typeid(Ex);
214 }
215 template <class Ex>
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>());
219 }
220 template <class Ex>
221 inline exception_wrapper exception_wrapper::InPlace<Ex>::get_exception_ptr_(
222     exception_wrapper const* that) {
223   try {
224     throw_(that);
225   } catch (Ex const& ex) {
226     return exception_wrapper{std::current_exception(), ex};
227   }
228 }
229
230 template <class Ex>
231 [[noreturn]] inline void
232 exception_wrapper::SharedPtr::Impl<Ex>::throw_() const {
233   throw ex_; // @nolint
234 }
235 template <class Ex>
236 inline std::exception const*
237 exception_wrapper::SharedPtr::Impl<Ex>::get_exception_() const noexcept {
238   return as_exception_or_null_(ex_);
239 }
240 template <class Ex>
241 inline exception_wrapper
242 exception_wrapper::SharedPtr::Impl<Ex>::get_exception_ptr_() const noexcept {
243   try {
244     throw_();
245   } catch (Ex& ex) {
246     return exception_wrapper{std::current_exception(), ex};
247   }
248 }
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_);
253 }
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_));
258   delete_(from);
259 }
260 inline void exception_wrapper::SharedPtr::delete_(
261     exception_wrapper* that) {
262   that->sptr_.~SharedPtr();
263   that->vptr_ = &uninit_;
264 }
265 [[noreturn]] inline void exception_wrapper::SharedPtr::throw_(
266     exception_wrapper const* that) {
267   that->sptr_.ptr_->throw_();
268   folly::assume_unreachable();
269 }
270 inline std::type_info const* exception_wrapper::SharedPtr::type_(
271     exception_wrapper const* that) {
272   return that->sptr_.ptr_->info_;
273 }
274 inline std::exception const* exception_wrapper::SharedPtr::get_exception_(
275     exception_wrapper const* that) {
276   return that->sptr_.ptr_->get_exception_();
277 }
278 inline exception_wrapper exception_wrapper::SharedPtr::get_exception_ptr_(
279     exception_wrapper const* that) {
280   return that->sptr_.ptr_->get_exception_ptr_();
281 }
282
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_) {}
287
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_) {}
291
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
295 }
296
297 inline exception_wrapper::exception_wrapper(
298     exception_wrapper const& that) : exception_wrapper{} {
299   that.vptr_->copy_(&that, this); // could throw
300   vptr_ = that.vptr_;
301 }
302
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
309   return *this;
310 }
311
312 inline exception_wrapper& exception_wrapper::operator=(
313     exception_wrapper const& that) {
314   exception_wrapper(that).swap(*this);
315   return *this;
316 }
317
318 inline exception_wrapper::~exception_wrapper() {
319   reset();
320 }
321
322 template <class Ex>
323 inline exception_wrapper::exception_wrapper(std::exception_ptr ptr, Ex& ex)
324     : eptr_{ptr, ExceptionPtr::as_int_(ptr, ex)},
325       vptr_(&ExceptionPtr::ops_) {
326   assert(eptr_.ptr_);
327 }
328
329 namespace exception_wrapper_detail {
330 template <class Ex>
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);
336 }
337 }
338
339 template <
340     class Ex,
341     class Ex_,
342     FOLLY_REQUIRES_DEF(
343         Conjunction<
344             exception_wrapper::IsStdException<Ex_>,
345             exception_wrapper::IsRegularExceptionType<Ex_>>::value)>
346 inline exception_wrapper::exception_wrapper(Ex&& ex)
347     : exception_wrapper{
348         exception_wrapper_detail::dont_slice(std::forward<Ex>(ex)),
349         PlacementOf<Ex_>{}} {
350 }
351
352 template <
353     class Ex,
354     class Ex_,
355     FOLLY_REQUIRES_DEF(
356         exception_wrapper::IsRegularExceptionType<Ex_>::value)>
357 inline exception_wrapper::exception_wrapper(in_place_t, Ex&& ex)
358     : exception_wrapper{
359         exception_wrapper_detail::dont_slice(std::forward<Ex>(ex)),
360         PlacementOf<Ex_>{}} {
361 }
362
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);
367 }
368
369 inline exception_wrapper::operator bool() const noexcept {
370   return vptr_ != &uninit_;
371 }
372
373 inline bool exception_wrapper::operator!() const noexcept {
374   return !static_cast<bool>(*this);
375 }
376
377 inline void exception_wrapper::reset() {
378   vptr_->delete_(this);
379 }
380
381 inline bool exception_wrapper::has_exception_ptr() const noexcept {
382   return vptr_ == &ExceptionPtr::ops_;
383 }
384
385 inline std::exception* exception_wrapper::get_exception() noexcept {
386   return const_cast<std::exception*>(vptr_->get_exception_(this));
387 }
388 inline std::exception const* exception_wrapper::get_exception() const noexcept {
389   return vptr_->get_exception_(this);
390 }
391
392 template <typename Ex>
393 inline Ex* exception_wrapper::get_exception() noexcept {
394   Ex* object{nullptr};
395   with_exception([&](Ex& ex) { object = &ex; });
396   return object;
397 }
398
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; });
403   return object;
404 }
405
406 inline std::exception_ptr const& exception_wrapper::to_exception_ptr()
407     noexcept {
408   // Computing an exception_ptr is expensive so cache the result.
409   return (*this = vptr_->get_exception_ptr_(this)).eptr_.ptr_;
410 }
411 inline std::exception_ptr exception_wrapper::to_exception_ptr() const noexcept {
412   return vptr_->get_exception_ptr_(this).eptr_.ptr_;
413 }
414
415 inline std::type_info const& exception_wrapper::none() noexcept {
416   return typeid(void);
417 }
418 inline std::type_info const& exception_wrapper::unknown() noexcept {
419   return typeid(Unknown);
420 }
421
422 inline std::type_info const& exception_wrapper::type() const noexcept {
423   return *vptr_->type_(this);
424 }
425
426 inline folly::fbstring exception_wrapper::what() const {
427   if (auto e = get_exception()) {
428     return class_name() + ": " + e->what();
429   }
430   return class_name();
431 }
432
433 inline folly::fbstring exception_wrapper::class_name() const {
434   auto& ti = type();
435   return ti == none()
436       ? ""
437       : ti == unknown() ? "<unknown exception>" : folly::demangle(ti);
438 }
439
440 template <class Ex>
441 inline bool exception_wrapper::is_compatible_with() const noexcept {
442   return with_exception([](Ex const&) {});
443 }
444
445 [[noreturn]] inline void exception_wrapper::throw_exception() const {
446   vptr_->throw_(this);
447   onNoExceptionError();
448 }
449
450 template <class CatchFn, bool IsConst>
451 struct exception_wrapper::ExceptionTypeOf {
452   using type = arg_type<_t<std::decay<CatchFn>>>;
453   static_assert(
454       std::is_reference<type>::value,
455       "Always catch exceptions by reference.");
456   static_assert(
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.");
461 };
462
463 // Nests a throw in the proper try/catch blocks
464 template <bool IsConst>
465 struct exception_wrapper::HandleReduce {
466   bool* handled_;
467
468   template <
469       class ThrowFn,
470       class CatchFn,
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_ ] {
475       try {
476         th();
477       } catch (Ex& e) {
478         // If we got here because a catch function threw, rethrow.
479         if (*handled_) {
480           throw;
481         }
482         *handled_ = true;
483         ca(e);
484       }
485     };
486   }
487
488   template <
489       class ThrowFn,
490       class CatchFn,
491       FOLLY_REQUIRES(IsCatchAll<CatchFn>::value)>
492   auto operator()(ThrowFn&& th, CatchFn& ca) const {
493     return [ th = std::forward<ThrowFn>(th), &ca, handled_ = handled_ ] {
494       try {
495         th();
496       } catch (...) {
497         // If we got here because a catch function threw, rethrow.
498         if (*handled_) {
499           throw;
500         }
501         *handled_ = true;
502         ca();
503       }
504     };
505   }
506 };
507
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>;
513
514   template <
515       class ThrowFn,
516       class CatchFn,
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)
521         -> StdEx* {
522       if (auto e = const_cast<StdEx*>(th(continuation))) {
523         if (auto e2 = dynamic_cast<_t<std::add_pointer<Ex>>>(e)) {
524           ca(*e2);
525         } else {
526           return e;
527         }
528       }
529       return nullptr;
530     };
531   }
532
533   template <
534       class ThrowFn,
535       class CatchFn,
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);
543       };
544       if (th(continuation) != nullptr) {
545         ca();
546       }
547       return nullptr;
548     };
549   }
550 };
551
552 // Called when some types in the catch clauses are not derived from
553 // std::exception.
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(); },
561       fns...);
562   impl();
563 }
564
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) {
575         return continuation(
576             const_cast<StdEx*>(this_.vptr_->get_exception_(&this_)));
577       },
578       fns...);
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.
584   }
585 }
586
587 namespace exception_wrapper_detail {
588 template <class Ex, class Fn>
589 struct catch_fn {
590   Fn fn_;
591   auto operator()(Ex& ex) {
592     return fn_(ex);
593   }
594 };
595
596 template <class Ex, class Fn>
597 inline catch_fn<Ex, Fn> catch_(Ex*, Fn fn) {
598   return {std::move(fn)};
599 }
600 template <class Fn>
601 inline Fn catch_(void const*, Fn fn) {
602   return fn;
603 }
604 } // namespace exception_wrapper_detail
605
606 template <class Ex, class This, class Fn>
607 inline bool exception_wrapper::with_exception_(This& this_, Fn fn_) {
608   if (!this_) {
609     return false;
610   }
611   bool handled = true;
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);
616   return handled;
617 }
618
619 template <class Ex, class Fn>
620 inline bool exception_wrapper::with_exception(Fn fn) {
621   return with_exception_<Ex>(*this, std::move(fn));
622 }
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));
626 }
627
628 template <class... CatchFns>
629 inline void exception_wrapper::handle(CatchFns... fns) {
630   using AllStdEx =
631       exception_wrapper_detail::AllOf<IsStdException, arg_type<CatchFns>...>;
632   if (!*this) {
633     onNoExceptionError();
634   }
635   this->handle_(AllStdEx{}, *this, fns...);
636 }
637 template <class... CatchFns>
638 inline void exception_wrapper::handle(CatchFns... fns) const {
639   using AllStdEx =
640       exception_wrapper_detail::AllOf<IsStdException, arg_type<CatchFns>...>;
641   if (!*this) {
642     onNoExceptionError();
643   }
644   this->handle_(AllStdEx{}, *this, fns...);
645 }
646
647 } // namespace folly