diff --git a/llvm/include/llvm/Support/Casting.h b/llvm/include/llvm/Support/Casting.h
--- a/llvm/include/llvm/Support/Casting.h
+++ b/llvm/include/llvm/Support/Casting.h
@@ -7,13 +7,14 @@
 //===----------------------------------------------------------------------===//
 //
 // This file defines the isa<X>(), cast<X>(), dyn_cast<X>(), cast_or_null<X>(),
-// and dyn_cast_or_null<X>() templates.
+// dyn_cast_or_null<X>(), and dyn_cast_or_none<X>() templates.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_SUPPORT_CASTING_H
 #define LLVM_SUPPORT_CASTING_H
 
+#include "llvm/ADT/Optional.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/type_traits.h"
 #include <cassert>
@@ -320,6 +321,25 @@
   return cast<X>(std::move(Val));
 }
 
+//===----------------------------------------------------------------------===//
+//                          dyn_cast<x> Support Templates
+//===----------------------------------------------------------------------===//
+
+template <class X, class Y> struct dyn_cast_retty {
+private:
+  using CastReturnType = typename cast_retty<X, Y>::ret_type;
+  static constexpr bool ConstructibleFromNullptr =
+      std::is_constructible<CastReturnType, std::nullptr_t>::value ||
+      std::is_pointer<CastReturnType>::value;
+
+public:
+  using ret_type = typename std::conditional<
+      ConstructibleFromNullptr, CastReturnType,
+      Optional<std::remove_reference_t<CastReturnType>>>::type;
+
+  static ret_type castFailed() { return ret_type{}; }
+};
+
 // dyn_cast<X> - Return the argument parameter cast to the specified type.  This
 // casting operator returns null if the argument is of the wrong type, so it can
 // be used to test for a type as well as cast if successful.  This should be
@@ -327,22 +347,28 @@
 //
 //  if (const Instruction *I = dyn_cast<Instruction>(myVal)) { ... }
 //
+// Or, if the target type is not constructible from nullptr then it could be
+// used like this:
+//
+//  if (Optional<Instruction> I = dyn_cast<Instruction>(myVal)) { ... }
+//
 
 template <class X, class Y>
 LLVM_NODISCARD inline std::enable_if_t<
-    !is_simple_type<Y>::value, typename cast_retty<X, const Y>::ret_type>
+    !is_simple_type<Y>::value, typename dyn_cast_retty<X, const Y>::ret_type>
 dyn_cast(const Y &Val) {
-  return isa<X>(Val) ? cast<X>(Val) : nullptr;
+  return isa<X>(Val) ? cast<X>(Val) : dyn_cast_retty<X, const Y>::castFailed();
 }
 
 template <class X, class Y>
-LLVM_NODISCARD inline typename cast_retty<X, Y>::ret_type dyn_cast(Y &Val) {
-  return isa<X>(Val) ? cast<X>(Val) : nullptr;
+LLVM_NODISCARD inline typename dyn_cast_retty<X, Y>::ret_type dyn_cast(Y &Val) {
+  return isa<X>(Val) ? cast<X>(Val) : dyn_cast_retty<X, Y>::castFailed();
 }
 
 template <class X, class Y>
-LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
-  return isa<X>(Val) ? cast<X>(Val) : nullptr;
+LLVM_NODISCARD inline typename dyn_cast_retty<X, Y *>::ret_type
+dyn_cast(Y *Val) {
+  return isa<X>(Val) ? cast<X>(Val) : dyn_cast_retty<X, Y *>::castFailed();
 }
 
 // dyn_cast_or_null<X> - Functionally identical to dyn_cast, except that a null
@@ -368,6 +394,51 @@
   return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
 }
 
+// dyn_cast_or_none<X> - Functionally identical to dyn_cast, except that an
+// empty optional value is accepted.
+//
+
+//===----------------------------------------------------------------------===//
+//                          dyn_cast_or_none support
+//===----------------------------------------------------------------------===//
+
+// These three functions provide forwarding for non-optional types passed into
+// dyn_cast_or_none.
+//
+
+template <class X, class Y>
+LLVM_NODISCARD inline auto dyn_cast_or_none(const Y &Val)
+    -> decltype(dyn_cast<X>(Val)) {
+  return dyn_cast<X>(Val);
+}
+
+template <class X, class Y>
+LLVM_NODISCARD inline auto dyn_cast_or_none(Y &Val)
+    -> decltype(dyn_cast<X>(Val)) {
+  return dyn_cast<X>(Val);
+}
+
+template <class X, class Y>
+LLVM_NODISCARD inline auto dyn_cast_or_none(Y *Val)
+    -> decltype(dyn_cast_or_null<X>(Val)) {
+  return dyn_cast_or_null<X>(Val);
+}
+
+template <class X, class Y>
+LLVM_NODISCARD inline std::enable_if_t<
+    !is_simple_type<Y>::value, typename dyn_cast_retty<X, const Y>::ret_type>
+dyn_cast_or_none(Optional<const Y> &Val) {
+  return (Val.hasValue() && isa<X>(*Val)) ? cast<X>(*Val)
+                                          : dyn_cast_retty<X, Y>::castFailed();
+}
+
+template <class X, class Y>
+LLVM_NODISCARD inline typename dyn_cast_retty<X, Y>::ret_type
+dyn_cast_or_none(Optional<Y> &Val) {
+  return (Val.hasValue() && isa<X>(*Val)) ? cast<X>(*Val)
+                                          : dyn_cast_retty<X, Y>::castFailed();
+}
+
 // unique_dyn_cast<X> - Given a unique_ptr<Y>, try to return a unique_ptr<X>,
 // taking ownership of the input pointer iff isa<X>(Val) is true.  If the
 // cast is successful, From refers to nullptr on exit and the casted value
diff --git a/llvm/unittests/Support/Casting.cpp b/llvm/unittests/Support/Casting.cpp
--- a/llvm/unittests/Support/Casting.cpp
+++ b/llvm/unittests/Support/Casting.cpp
@@ -19,7 +19,7 @@
 struct IllegalCast;
 template <typename T> IllegalCast *cast(...) { return nullptr; }
 
-// set up two example classes
+// set up three example classes
 // with conversion facility
 //
 struct bar {
@@ -28,6 +28,7 @@
   struct foo *caz();
   struct foo *daz();
   struct foo *naz();
+  Optional<struct foo> optional();
 private:
   bar(const bar &);
 };
@@ -74,6 +75,10 @@
     return dyn_cast_or_null<foo>(this);
 }
 
+Optional<foo> bar::optional() {
+  return dyn_cast<foo>(*this);
+}
+
 
 bar *fub();
 
@@ -193,6 +198,27 @@
   EXPECT_NE(F5, null_foo);
 }
 
+TEST(CastingTest, dyn_cast_optional) {
+  Optional<foo> F1 = dyn_cast<foo>(B);
+  EXPECT_TRUE(F1.hasValue());
+  Optional<foo> F2 = dyn_cast<foo>(B1);
+  EXPECT_TRUE(F2.hasValue());
+  Optional<const foo> F3 = dyn_cast<foo>(B3);
+  EXPECT_TRUE(F3.hasValue());
+
+  Optional<foo> F4 = B1.optional();
+  EXPECT_TRUE(F4.hasValue());
+}
+
+TEST(CastingTest, dyn_cast_or_none) {
+  Optional<bar> empty{};
+  Optional<foo> F1 = dyn_cast_or_none<foo>(empty);
+  EXPECT_FALSE(F1.hasValue());
+
+  Optional<foo> F2 = dyn_cast_or_none<foo>(B1);
+  EXPECT_TRUE(F2.hasValue());
+}
+
 std::unique_ptr<derived> newd() { return std::make_unique<derived>(); }
 std::unique_ptr<base> newb() { return std::make_unique<derived>(); }