Re-introduce the RWMutexImpl for macOS < 10.12

[JDevlieghere]

Summary

Unfortunately, std::shared_timed_mutex is only available on macOS 10.12 and later. This prevents LLVM from compiling when you have a deployment target that's older. This patch reintroduced the old RWMutexImpl but guards it by the macOS availability macro.

[arphaman]

It's not pretty, but it fixes the issue. We will need a better story for other partially available symbols when we'll be moving over to C++17.

[jfb]

Could you document this limitation in CodingStandards.rst, like what I removed for C++11 in https://reviews.llvm.org/D66195#change-S42p9rAdiuZJ ?

llvm/include/llvm/Support/RWMutex.h

namespace sys {
     /// running in multithreaded mode.
     template<bool mt_only>
     class SmartRWMutex {
       // shared_mutex (C++17) is more efficient than shared_timed_mutex (C++14)
       // on Windows and always available on MSVC.
 #if defined(_MSC_VER) || __cplusplus > 201402L
       std::shared_mutex impl;
 #else
+      // std::shared_timed_mutex is only availble on macOS 10.12 and later.
+#if defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) &&                  \
+    defined(__MAC_10_12) &&                                                    \
+    __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < __MAC_10_12
+      /// Platform agnostic RWMutex class.
+      /// Platform agnostic RWMutex class.
+      class RWMutexImpl {
+        /// @name Constructors
+        /// @{
+      public:
+        /// Initializes the lock but doesn't acquire it.
+        /// Default Constructor.
+        explicit RWMutexImpl();
+
+        /// @}
+        /// @name Do Not Implement
+        /// @{
+        RWMutexImpl(const RWMutexImpl &original) = delete;
+        RWMutexImpl &operator=(const RWMutexImpl &) = delete;
+        /// @}
+
+        /// Releases and removes the lock
+        /// Destructor
+        ~RWMutexImpl();
+
+        /// @}
+        /// @name Methods
+        /// @{
+      public:
+        /// Attempts to unconditionally acquire the lock in reader mode. If the
+        /// lock is held by a writer, this method will wait until it can acquire
+        /// the lock.
+        /// @returns false if any kind of error occurs, true otherwise.
+        /// Unconditionally acquire the lock in reader mode.
+        bool reader_acquire();
+
+        /// Attempts to release the lock in reader mode.
+        /// @returns false if any kind of error occurs, true otherwise.
+        /// Unconditionally release the lock in reader mode.
+        bool reader_release();
+
+        /// Attempts to unconditionally acquire the lock in reader mode. If the
+        /// lock is held by any readers, this method will wait until it can
+        /// acquire the lock.
+        /// @returns false if any kind of error occurs, true otherwise.
+        /// Unconditionally acquire the lock in writer mode.
+        bool writer_acquire();
+
+        /// Attempts to release the lock in writer mode.
+        /// @returns false if any kind of error occurs, true otherwise.
+        /// Unconditionally release the lock in write mode.
+        bool writer_release();
+
+        //@}
+        /// @name Platform Dependent Data
+        /// @{
+      private:
+#if defined(LLVM_ENABLE_THREADS) && LLVM_ENABLE_THREADS != 0
+        void *data_ = nullptr; ///< We don't know what the data will be
+#endif
+      } impl;
+#else
       std::shared_timed_mutex impl;
 #endif
+#endif
       unsigned readers = 0;
       unsigned writers = 0;
 
     public:
       bool lock_shared() {
         if (!mt_only || llvm_is_multithreaded()) {
           impl.lock_shared();
           return true;