Update to NSS 3.15.5 and NSPR 4.10.3.

nspr/pr/src/threads/prrwlock.c

 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 #include "primpl.h"
 
 #include <string.h>
 
 #if defined(HPUX) && defined(_PR_PTHREADS) && !defined(_PR_DCETHREADS)
@@ skipping 208 matching lines @@
          */
         rwlock->rw_lock_cnt++;
 
         PR_Unlock(rwlock->rw_lock);
 #endif
 
 #ifdef _PR_RWLOCK_RANK_ORDER_DEBUG
         /*
          * update thread's lock rank
          */
-        _PR_SET_THREAD_RWLOCK_RANK(rwlock);
+        if (rwlock->rw_rank != PR_RWLOCK_RANK_NONE)
+                _PR_SET_THREAD_RWLOCK_RANK(rwlock);
 #endif
 }
 
 /*
 ** Write-lock the RWLock.
 */
 PR_IMPLEMENT(void)
 PR_RWLock_Wlock(PRRWLock *rwlock)
 {
 #if defined(DEBUG)
@@ skipping 35 matching lines @@
         PR_ASSERT(me != NULL);
         rwlock->rw_owner = me;
 #endif
         PR_Unlock(rwlock->rw_lock);
 #endif
 
 #ifdef _PR_RWLOCK_RANK_ORDER_DEBUG
         /*
          * update thread's lock rank
          */
-        _PR_SET_THREAD_RWLOCK_RANK(rwlock);
+        if (rwlock->rw_rank != PR_RWLOCK_RANK_NONE)
+                _PR_SET_THREAD_RWLOCK_RANK(rwlock);
 #endif
 }
 
 /*
 ** Unlock the RW lock.
 */
 PR_IMPLEMENT(void)
 PR_RWLock_Unlock(PRRWLock *rwlock)
 {
 #if defined(DEBUG)
@@ skipping 44 matching lines @@
                 else if (rwlock->rw_reader_cnt > 0)
                         PR_NotifyAllCondVar(rwlock->rw_reader_waitq);
         }
         PR_Unlock(rwlock->rw_lock);
 #endif
 
 #ifdef _PR_RWLOCK_RANK_ORDER_DEBUG
         /*
          * update thread's lock rank
          */
-        _PR_UNSET_THREAD_RWLOCK_RANK(rwlock);
+        if (rwlock->rw_rank != PR_RWLOCK_RANK_NONE)
+                _PR_UNSET_THREAD_RWLOCK_RANK(rwlock);
 #endif
         return;
 }
 
 #ifndef _PR_RWLOCK_RANK_ORDER_DEBUG
 
 void _PR_InitRWLocks(void) { }
 
 #else
 
@@ skipping 61 matching lines @@
  *
  *              return thread's lock rank. If thread-private-data for the lock
  *              stack is not allocated, return PR_RWLOCK_RANK_NONE.
  */
         
 static PRUint32
 _PR_GET_THREAD_RWLOCK_RANK(void)
 {
         thread_rwlock_stack *lock_stack;
 
-        if ((lock_stack = PR_GetThreadPrivate(pr_thread_rwlock_key)) == NULL)
+        lock_stack = PR_GetThreadPrivate(pr_thread_rwlock_key);
+        if (lock_stack == NULL || lock_stack->trs_index == 0)
                 return (PR_RWLOCK_RANK_NONE);
         else
                 return(lock_stack->trs_stack[lock_stack->trs_index - 1]->rw_rank);
 }
 
 /*
  * _PR_UNSET_THREAD_RWLOCK_RANK
  *
  *              remove the rwlock from the lock stack. Since locks may not be
  *              unlocked in a FIFO order, the entire lock stack is searched.
  */
         
 static void
 _PR_UNSET_THREAD_RWLOCK_RANK(PRRWLock *rwlock)
 {
         thread_rwlock_stack *lock_stack;
         int new_index = 0, index, done = 0;
 
         lock_stack = PR_GetThreadPrivate(pr_thread_rwlock_key);
 
         PR_ASSERT(lock_stack != NULL);
 
-        index = lock_stack->trs_index - 1;
-        while (index-- >= 0) {
-                if ((lock_stack->trs_stack[index] == rwlock) && !done)  {
+        for (index = lock_stack->trs_index - 1; index >= 0; index--) {
+                if (!done && (lock_stack->trs_stack[index] == rwlock))  {
                         /*
                          * reset the slot for rwlock
                          */
                         lock_stack->trs_stack[index] = NULL;
                         done = 1;
                 }
                 /*
                  * search for the lowest-numbered empty slot, above which there are
                  * no non-empty slots
                  */
-                if ((lock_stack->trs_stack[index] != NULL) && !new_index)
+                if (!new_index && (lock_stack->trs_stack[index] != NULL))
                         new_index = index + 1;
                 if (done && new_index)
                         break;
         }
         /*
          * set top of stack to highest numbered empty slot
          */
         lock_stack->trs_index = new_index;
 
 }
 
 #endif  /* _PR_RWLOCK_RANK_ORDER_DEBUG */