Index: include/llvm/Support/RWMutex.h
===================================================================
--- include/llvm/Support/RWMutex.h
+++ include/llvm/Support/RWMutex.h
@@ -142,35 +142,76 @@
     };
     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>;
+
   }
 }