[analyzer] PthreadLock: Add the other XNU rwlock unlock functions.

[NoQ]

Summary

It turns out that XNU rwlocks, locked by lck_rw_lock_shared() and lck_rw_lock_exclusive(), can be unlocked through either the "unspecific" lck_rw_done() or the "specific" lck_rw_unlock_shared() and lck_rw_unlock_exclusive() calls. Add the two "specific" unlock functions to the checker.

lib/StaticAnalyzer/Checkers/PthreadLockChecker.cpp

void PthreadLockChecker::checkPostStmt(const CallExpr *CE,
   else if (FName == "lck_mtx_try_lock" ||
            FName == "lck_rw_try_lock_exclusive" ||
            FName == "lck_rw_try_lock_shared")
     AcquireLock(C, CE, state->getSVal(CE->getArg(0), LCtx),
                 true, XNUSemantics);
   else if (FName == "pthread_mutex_unlock" ||
            FName == "pthread_rwlock_unlock" ||
            FName == "lck_mtx_unlock" ||
+           FName == "lck_rw_unlock_exclusive" ||
+           FName == "lck_rw_unlock_shared" ||
            FName == "lck_rw_done")
     ReleaseLock(C, CE, state->getSVal(CE->getArg(0), LCtx));
   else if (FName == "pthread_mutex_destroy")
     DestroyLock(C, CE, state->getSVal(CE->getArg(0), LCtx), PthreadSemantics);
   else if (FName == "lck_mtx_destroy")
     DestroyLock(C, CE, state->getSVal(CE->getArg(0), LCtx), XNUSemantics);
   else if (FName == "pthread_mutex_init")
     InitLock(C, CE, state->getSVal(CE->getArg(0), LCtx));

test/Analysis/Inputs/system-header-simulator-for-pthread-lock.h

 typedef struct {
   void  *foo;
 } pthread_mutexattr_t;
 
 typedef struct {
   void  *foo;
 } lck_grp_t;
 
+typedef struct {
+  void *foo;
+} lck_rw_t;
+
 typedef pthread_mutex_t lck_mtx_t;
 
 extern int pthread_mutex_lock(pthread_mutex_t *);
 extern int pthread_mutex_unlock(pthread_mutex_t *);
 extern int pthread_mutex_trylock(pthread_mutex_t *);
 extern int pthread_mutex_destroy(pthread_mutex_t *);
 extern int pthread_mutex_init(pthread_mutex_t  *mutex, const pthread_mutexattr_t *mutexattr);
 
 typedef int boolean_t;
 extern void lck_mtx_lock(lck_mtx_t *);
 extern void lck_mtx_unlock(lck_mtx_t *);
 extern boolean_t lck_mtx_try_lock(lck_mtx_t *);
 extern void lck_mtx_destroy(lck_mtx_t *lck, lck_grp_t *grp);
+
+extern void lck_rw_lock_exclusive(lck_rw_t *lck);
+extern void lck_rw_unlock_exclusive(lck_rw_t *lck);
+extern void lck_rw_lock_shared(lck_rw_t *lck);
+extern void lck_rw_unlock_shared(lck_rw_t *lck);

test/Analysis/pthreadlock.c

 // RUN: %clang_analyze_cc1 -analyzer-checker=alpha.unix.PthreadLock -verify %s
 
 // Tests performing normal locking patterns and wrong locking orders
 
 #include "Inputs/system-header-simulator-for-pthread-lock.h"
 
 pthread_mutex_t mtx1, mtx2;
 pthread_mutex_t *pmtx;
 lck_mtx_t lck1, lck2;
 lck_grp_t grp1;
+lck_rw_t rw;
 
 #define NULL 0
 
 void
 ok1(void)
 {
   pthread_mutex_lock(&mtx1); // no-warning
 }

 void ok28(void) {
   if (pthread_mutex_destroy(&mtx1) != 0) { // no-warning
     pthread_mutex_lock(&mtx1);             // no-warning
     pthread_mutex_unlock(&mtx1);           // no-warning
     pthread_mutex_destroy(&mtx1);          // no-warning
   }
 }
 
+void ok29(void) {
+  lck_rw_lock_shared(&rw);
+  lck_rw_unlock_shared(&rw);
+  lck_rw_lock_exclusive(&rw); // no-warning
+  lck_rw_unlock_exclusive(&rw); // no-warning
+}
+
 void
 bad1(void)
 {
   pthread_mutex_lock(&mtx1);  // no-warning
   pthread_mutex_lock(&mtx1);  // expected-warning{{This lock has already been acquired}}
 }
 
 void

 }
 
 void bad31(void) {
   int ret = pthread_mutex_destroy(&mtx1); // no-warning
   pthread_mutex_lock(&mtx1);              // expected-warning{{This lock has already been destroyed}}
   if (ret != 0)
     pthread_mutex_lock(&mtx1);
 }
+
+void bad32(void) {
+  lck_rw_lock_shared(&rw);
+  lck_rw_unlock_exclusive(&rw); // FIXME: warn - should be shared?
+  lck_rw_lock_exclusive(&rw);
+  lck_rw_unlock_shared(&rw); // FIXME: warn - should be exclusive?
+}