diff --git a/llvm/include/llvm/ADT/Any.h b/llvm/include/llvm/ADT/Any.h
--- a/llvm/include/llvm/ADT/Any.h
+++ b/llvm/include/llvm/ADT/Any.h
@@ -23,8 +23,100 @@
 #include <memory>
 #include <type_traits>
 
+#if !defined(_MSC_VER) || _MSC_VER >= 1934
+// The msvc standard library had a bug so <any> could not be included when
+// exceptions are disabled. Only enable the std::any wrapper for new enough
+// versions.
+// https://developercommunity.visualstudio.com/t/stdany-doesnt-link-when-exceptions-are-disabled/376072
+#define LLVM_ANY_WRAPS_STD_ANY
+#endif
+
+#ifdef LLVM_ANY_WRAPS_STD_ANY
+#include <any>
+#endif
+
 namespace llvm {
 
+#ifdef LLVM_ANY_WRAPS_STD_ANY
+
+class Any {
+public:
+  Any() = default;
+
+  Any(const Any &Other) : Storage(Other.Storage) {}
+
+  Any(Any &&Other) : Storage(std::move(Other.Storage)) {}
+
+  // When T is Any or T is not copy-constructible we need to explicitly disable
+  // the forwarding constructor so that the copy constructor gets selected
+  // instead.
+  template <typename T,
+            std::enable_if_t<
+                std::conjunction<
+                    std::negation<std::is_same<std::decay_t<T>, Any>>,
+                    // We also disable this overload when an `Any` object can be
+                    // converted to the parameter type because in that case,
+                    // this constructor may combine with that conversion during
+                    // overload resolution for determining copy
+                    // constructibility, and then when we try to determine copy
+                    // constructibility below we may infinitely recurse. This is
+                    // being evaluated by the standards committee as a potential
+                    // DR in `std::any` as well, but we're going ahead and
+                    // adopting it to work-around usage of `Any` with types that
+                    // need to be implicitly convertible from an `Any`.
+                    std::negation<std::is_convertible<Any, std::decay_t<T>>>,
+                    std::is_copy_constructible<std::decay_t<T>>>::value,
+                int> = 0>
+  Any(T &&Value) : Storage(std::forward<T>(Value)) {}
+
+  Any &operator=(Any Other) {
+    Storage = Other.Storage;
+    return *this;
+  }
+
+  bool has_value() const { return Storage.has_value(); }
+
+  void reset() { return Storage.reset(); }
+
+private:
+  template <typename T> friend bool any_isa(const Any &Value);
+  template <class T> friend const T any_cast(const Any &Value);
+  template <class T> friend T any_cast(Any &Value);
+  template <class T> friend T any_cast(Any &&Value);
+  template <class T> friend const T *any_cast(const Any *Value) noexcept;
+  template <class T> friend T *any_cast(Any *Value) noexcept;
+
+  std::any Storage;
+};
+
+template <typename T>
+LLVM_DEPRECATED("Use any_cast(Any*) != nullptr instead", "any_cast")
+bool any_isa(const Any &Value) {
+  return std::any_cast<T>(&Value.Storage);
+}
+
+template <class T> const T any_cast(const Any &Value) {
+  return std::any_cast<T>(Value.Storage);
+}
+
+template <class T> T any_cast(Any &Value) {
+  return std::any_cast<T>(Value.Storage);
+}
+
+template <class T> T any_cast(Any &&Value) {
+  return std::any_cast<T>(std::move(Value.Storage));
+}
+
+template <class T> const T *any_cast(const Any *Value) noexcept {
+  return std::any_cast<T>(&Value->Storage);
+}
+
+template <class T> T *any_cast(Any *Value) noexcept {
+  return std::any_cast<T>(&Value->Storage);
+}
+
+#else
+
 class LLVM_EXTERNAL_VISIBILITY Any {
 
   // The `Typeid<T>::Id` static data member below is a globally unique
@@ -161,6 +253,8 @@
   return &static_cast<Any::StorageImpl<U> &>(*Value->Storage).Value;
 }
 
+#endif // LLVM_ANY_WRAPS_STD_ANY
+
 } // end namespace llvm
 
 #endif // LLVM_ADT_ANY_H