[Support] Generic version of RWMutex

[mshockwave]

Summary

This revision provides similar lock/unlock behavior to std::unique_lock in addition to std::defer_lock.
User can choose to lock the mutex upon object construction or do it manually. The lock would be unlocked either within the destructor or by calling unlock explicitly.
The original SmartScopedReader and SmartScopedWriter are also replaced by this generic version of reader/writer lock.

include/llvm/Support/RWMutex.h

public:
       }
 
     private:
       SmartRWMutex(const SmartRWMutex<mt_only> & original);
       void operator=(const SmartRWMutex<mt_only> &);
     };
     typedef SmartRWMutex<false> RWMutex;
 
-    /// ScopedReader - RAII acquisition of a reader lock
-    template<bool mt_only>
-    struct SmartScopedReader {
-      SmartRWMutex<mt_only>& mutex;
+    /// SmartReader - Generic variant that allows customized
+    /// lock/unlock policy
+    template<bool mt_only,bool auto_lock>
+    class GenericSmartReader {
+      SmartRWMutex<mt_only>& Mutex;
+      bool IsLocked;
+
+    public:
+      explicit GenericSmartReader(SmartRWMutex<mt_only>& m) :
+        Mutex(m), IsLocked(false) {
+        if(auto_lock) lock();
+      }
 
-      explicit SmartScopedReader(SmartRWMutex<mt_only>& m) : mutex(m) {
-        mutex.lock_shared();
+      void lock() { 
+        if(!IsLocked){
+          Mutex.lock_shared();
+          IsLocked = true;
+        }
       }
 
-      ~SmartScopedReader() {
-        mutex.unlock_shared();
+      void unlock() { 
+        if(IsLocked) Mutex.unlock_shared(); 
+        IsLocked = false;
       }
+
+      ~GenericSmartReader() { unlock(); }
     };
-    typedef SmartScopedReader<false> ScopedReader;
+    template<bool auto_lock>
+    using SmartReader = GenericSmartReader<false,auto_lock>;
 
-    /// ScopedWriter - RAII acquisition of a writer lock
-    template<bool mt_only>
-    struct SmartScopedWriter {
-      SmartRWMutex<mt_only>& mutex;
+    /// SmartWriter - Generic variant that allows customized
+    /// lock/unlock policy
+    template<bool mt_only,bool auto_lock>
+    class GenericSmartWriter {
+      SmartRWMutex<mt_only>& Mutex;
+      bool IsLocked;
 
-      explicit SmartScopedWriter(SmartRWMutex<mt_only>& m) : mutex(m) {
-        mutex.lock();
+    public:
+      explicit GenericSmartWriter(SmartRWMutex<mt_only>& m) :
+        Mutex(m), IsLocked(false){
+        if(auto_lock) lock();
       }
 
-      ~SmartScopedWriter() {
-        mutex.unlock();
+      void lock(){
+        if(!IsLocked) {
+          Mutex.lock();
+          IsLocked = true;
+        }
       }
+
+      void unlock() {
+        if(IsLocked) Mutex.unlock();
+        IsLocked = false;
+      }
+
+      ~GenericSmartWriter() { unlock(); }
     };
-    typedef SmartScopedWriter<false> ScopedWriter;
+    template<bool auto_lock>
+    using SmartWriter = GenericSmartWriter<false,auto_lock>;
+
+    /// ScopedReader - RAII acquisition of a reader lock
+    template<bool mt_only>
+    using SmartScopedReader = GenericSmartReader<mt_only,true>;
+    using ScopedReader = SmartScopedReader<false>;
+
+    /// ScopedWriter - RAII acquisition of a writer lock
+    template<bool mt_only>
+    using SmartScopedWriter = GenericSmartWriter<mt_only,true>;
+    using ScopedWriter = SmartScopedWriter<false>;
+
   }
 }
 
 #endif