From: Yedidya Feldblum <yfeldblum@fb.com>
Date: Mon, 24 Jul 2017 04:43:04 +0000 (-0700)
Subject: Outline the throw statements in Try
X-Git-Tag: v2017.07.24.00~1
X-Git-Url: http://demsky.eecs.uci.edu/git/?a=commitdiff_plain;h=1d7c30b288dcd95c32663a5f552cdac5f8a77bbf;p=folly.git

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 a1607f04..e2940ab5 100644
--- 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 e6e4c415..272945f0 100644
--- 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
index 00000000..9fa85793
--- /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 df48794e..9a6ef5fc 100644
--- 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_;
   }