Outline the throw statements in Try

Summary:
[Folly] Outline the `throw` statements in `Try`.

They are by definition cold and so we gain nothing from inlining them.

Reviewed By: Orvid

Differential Revision: D5478237

fbshipit-source-id: f413251a56ca4cbddcf3baea6679a552ae5bb19e

diff --git a/folly/Makefile.am b/folly/Makefile.am
index a1607f040733b2c6667982e91734d95ab76ac247..e2940ab5f4f5162a624c60ef8192f5d2ee7311c5 100644 (file)
--- a/folly/Makefile.am
+++ b/folly/Makefile.am
@@ -561,6 +561,7 @@ libfolly_la_SOURCES = \
        ThreadCachedArena.cpp \
        ThreadName.cpp \
        TimeoutQueue.cpp \
+       Try.cpp \
        Uri.cpp \
        Version.cpp \
        experimental/AsymmetricMemoryBarrier.cpp \

diff --git a/folly/Try-inl.h b/folly/Try-inl.h
index e6e4c415187b1012bc02fc7bf6d6e9eeb9c84a0a..272945f06b631ef273d0c9659015af2023c7d13c 100644 (file)
--- a/folly/Try-inl.h
+++ b/folly/Try-inl.h
@@ -117,12 +117,13 @@ const T& Try<T>::value() const & {
 
 template <class T>
 void Try<T>::throwIfFailed() const {
-  if (contains_ != Contains::VALUE) {
-    if (contains_ == Contains::EXCEPTION) {
+  switch (contains_) {
+    case Contains::VALUE:
+      return;
+    case Contains::EXCEPTION:
       e_.throw_exception();
-    } else {
-      throw UsingUninitializedTry();
-    }
+    default:
+      try_detail::throwUsingUninitializedTry();
   }
 }
 

diff --git a/folly/Try.cpp b/folly/Try.cpp
new file mode 100644 (file)
index 0000000..9fa8579
--- /dev/null
+++ b/folly/Try.cpp
@@ -0,0 +1,31 @@
+/*
+ * Copyright 2004-present Facebook, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/Try.h>
+
+namespace folly {
+
+namespace try_detail {
+[[noreturn]] void throwTryDoesNotContainException() {
+  throw TryException("exception(): Try does not contain an exception");
+}
+
+[[noreturn]] void throwUsingUninitializedTry() {
+  throw UsingUninitializedTry();
+}
+} // namespace try_detail
+
+} // namespace folly

diff --git a/folly/Try.h b/folly/Try.h
index df48794e656258c3dbc4639e65027407b4b1ea42..9a6ef5fce9e83247c91f598b4ce8269ccf117972 100644 (file)
--- a/folly/Try.h
+++ b/folly/Try.h
@@ -39,6 +39,11 @@ class UsingUninitializedTry : public TryException {
   UsingUninitializedTry() : TryException("Using uninitialized try") {}
 };
 
+namespace try_detail {
+[[noreturn]] void throwTryDoesNotContainException();
+[[noreturn]] void throwUsingUninitializedTry();
+} // namespace try_detail
+
 /*
  * Try<T> is a wrapper that contains either an instance of T, an exception, or
  * nothing. Exceptions are stored as exception_wrappers so that the user can
@@ -204,15 +209,15 @@ class Try {
   }
 
   exception_wrapper& exception() {
-    if (UNLIKELY(!hasException())) {
-      throw TryException("exception(): Try does not contain an exception");
+    if (!hasException()) {
+      try_detail::throwTryDoesNotContainException();
     }
     return e_;
   }
 
   const exception_wrapper& exception() const {
-    if (UNLIKELY(!hasException())) {
-      throw TryException("exception(): Try does not contain an exception");
+    if (!hasException()) {
+      try_detail::throwTryDoesNotContainException();
     }
     return e_;
   }
@@ -380,15 +385,15 @@ class Try<void> {
    * @returns mutable reference to the exception contained by this Try
    */
   exception_wrapper& exception() {
-    if (UNLIKELY(!hasException())) {
-      throw TryException("exception(): Try does not contain an exception");
+    if (!hasException()) {
+      try_detail::throwTryDoesNotContainException();
     }
     return e_;
   }
 
   const exception_wrapper& exception() const {
-    if (UNLIKELY(!hasException())) {
-      throw TryException("exception(): Try does not contain an exception");
+    if (!hasException()) {
+      try_detail::throwTryDoesNotContainException();
     }
     return e_;
   }