commit 3d265911c2aac65d978f679101594f9071024874

Author: Andreas Schwab <schwab@suse.de>

Date:   Mon Nov 12 11:11:40 2018 +0100

    Reindent nptl/pthread_rwlock_common.c

diff --git a/nptl/pthread_rwlock_common.c b/nptl/pthread_rwlock_common.c

index a290d08332b802a5..5dd534271aed6b41 100644

--- a/nptl/pthread_rwlock_common.c

+++ b/nptl/pthread_rwlock_common.c

@@ -34,7 +34,7 @@

    A thread is allowed to acquire a read lock recursively (i.e., have rdlock

    critical sections that overlap in sequenced-before) unless the kind of the

-   rwlock is set to PTHREAD_RWLOCK_PREFER_WRITERS_NONRECURSIVE_NP.

+   rwlock is set to PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP.

    This lock is built so that workloads of mostly readers can be executed with

    low runtime overheads.  This matches that the default kind of the lock is

@@ -46,7 +46,7 @@

    An uncontended write lock acquisition is as fast as for a normal

    exclusive mutex but writer contention is somewhat more costly due to

    keeping track of the exact number of writers.  If the rwlock kind requests

-   writers to be preferred (i.e., PTHREAD_RWLOCK_PREFER_WRITERS_NP or the

+   writers to be preferred (i.e., PTHREAD_RWLOCK_PREFER_WRITER_NP or the

    no-recursive-readers variant of it), then writer--to--writer lock ownership

    hand-over is fairly fast and bypasses lock acquisition attempts by readers.

    The costs of lock ownership transfer between readers and writers vary.  If

@@ -251,7 +251,7 @@ __pthread_rwlock_rdunlock (pthread_rwlock_t *rwlock)

 	 the first reader's store to __wrphase_futex (or a later value) if

 	 the writer observes that a write phase has been started.  */

       if (atomic_compare_exchange_weak_release (&rwlock->__data.__readers,

-	  &r, rnew))

+						&r, rnew))

 	break;

       /* TODO Back-off.  */

     }

@@ -285,7 +285,7 @@ __pthread_rwlock_rdlock_full (pthread_rwlock_t *rwlock,

   /* Make sure we are not holding the rwlock as a writer.  This is a deadlock

      situation we recognize and report.  */

   if (__glibc_unlikely (atomic_load_relaxed (&rwlock->__data.__cur_writer)

-      == THREAD_GETMEM (THREAD_SELF, tid)))

+			== THREAD_GETMEM (THREAD_SELF, tid)))

     return EDEADLK;

   /* If we prefer writers, recursive rdlock is disallowed, we are in a read

@@ -299,9 +299,9 @@ __pthread_rwlock_rdlock_full (pthread_rwlock_t *rwlock,

   if (rwlock->__data.__flags == PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP)

     {

       r = atomic_load_relaxed (&rwlock->__data.__readers);

-      while (((r & PTHREAD_RWLOCK_WRPHASE) == 0)

-	      && ((r & PTHREAD_RWLOCK_WRLOCKED) != 0)

-	      && ((r >> PTHREAD_RWLOCK_READER_SHIFT) > 0))

+      while ((r & PTHREAD_RWLOCK_WRPHASE) == 0

+	     && (r & PTHREAD_RWLOCK_WRLOCKED) != 0

+	     && (r >> PTHREAD_RWLOCK_READER_SHIFT) > 0)

 	{

 	  /* TODO Spin first.  */

 	  /* Try setting the flag signaling that we are waiting without having

@@ -315,11 +315,11 @@ __pthread_rwlock_rdlock_full (pthread_rwlock_t *rwlock,

 		 __readers, and all threads set the flag under the same

 		 conditions.  */

 	      while ((atomic_load_relaxed (&rwlock->__data.__readers)

-		  & PTHREAD_RWLOCK_RWAITING) != 0)

+		      & PTHREAD_RWLOCK_RWAITING) != 0)

 		{

 		  int private = __pthread_rwlock_get_private (rwlock);

 		  int err = futex_abstimed_wait (&rwlock->__data.__readers,

-		      r, abstime, private);

+						 r, abstime, private);

 		  /* We ignore EAGAIN and EINTR.  On time-outs, we can just

 		     return because we don't need to clean up anything.  */

 		  if (err == ETIMEDOUT)

@@ -338,8 +338,9 @@ __pthread_rwlock_rdlock_full (pthread_rwlock_t *rwlock,

      expected value for future operations.  Acquire MO so we synchronize with

      prior writers as well as the last reader of the previous read phase (see

      below).  */

-  r = atomic_fetch_add_acquire (&rwlock->__data.__readers,

-      (1 << PTHREAD_RWLOCK_READER_SHIFT)) + (1 << PTHREAD_RWLOCK_READER_SHIFT);

+  r = (atomic_fetch_add_acquire (&rwlock->__data.__readers,

+				 (1 << PTHREAD_RWLOCK_READER_SHIFT))

+       + (1 << PTHREAD_RWLOCK_READER_SHIFT));

   /* Check whether there is an overflow in the number of readers.  We assume

      that the total number of threads is less than half the maximum number

@@ -359,8 +360,9 @@ __pthread_rwlock_rdlock_full (pthread_rwlock_t *rwlock,

       /* Relaxed MO is okay because we just want to undo our registration and

 	 cannot have changed the rwlock state substantially if the CAS

 	 succeeds.  */

-      if (atomic_compare_exchange_weak_relaxed (&rwlock->__data.__readers, &r,

-	  r - (1 << PTHREAD_RWLOCK_READER_SHIFT)))

+      if (atomic_compare_exchange_weak_relaxed

+	  (&rwlock->__data.__readers,

+	   &r, r - (1 << PTHREAD_RWLOCK_READER_SHIFT)))

 	return EAGAIN;

     }

@@ -378,15 +380,15 @@ __pthread_rwlock_rdlock_full (pthread_rwlock_t *rwlock,

   /* Otherwise, if we were in a write phase (states #6 or #8), we must wait

      for explicit hand-over of the read phase; the only exception is if we

      can start a read phase if there is no primary writer currently.  */

-  while (((r & PTHREAD_RWLOCK_WRPHASE) != 0)

-      && ((r & PTHREAD_RWLOCK_WRLOCKED) == 0))

+  while ((r & PTHREAD_RWLOCK_WRPHASE) != 0

+	 && (r & PTHREAD_RWLOCK_WRLOCKED) == 0)

     {

-       /* Try to enter a read phase: If the CAS below succeeds, we have

+      /* Try to enter a read phase: If the CAS below succeeds, we have

 	 ownership; if it fails, we will simply retry and reassess the

 	 situation.

 	 Acquire MO so we synchronize with prior writers.  */

       if (atomic_compare_exchange_weak_acquire (&rwlock->__data.__readers, &r,

-	  r ^ PTHREAD_RWLOCK_WRPHASE))

+						r ^ PTHREAD_RWLOCK_WRPHASE))

 	{

 	  /* We started the read phase, so we are also responsible for

 	     updating the write-phase futex.  Relaxed MO is sufficient.

@@ -397,7 +399,7 @@ __pthread_rwlock_rdlock_full (pthread_rwlock_t *rwlock,

 	     (but we can pretend to do the setting and unsetting of WRLOCKED

 	     atomically, and thus can skip this step).  */

 	  if ((atomic_exchange_relaxed (&rwlock->__data.__wrphase_futex, 0)

-	      & PTHREAD_RWLOCK_FUTEX_USED) != 0)

+	       & PTHREAD_RWLOCK_FUTEX_USED) != 0)

 	    {

 	      int private = __pthread_rwlock_get_private (rwlock);

 	      futex_wake (&rwlock->__data.__wrphase_futex, INT_MAX, private);

@@ -435,16 +437,17 @@ __pthread_rwlock_rdlock_full (pthread_rwlock_t *rwlock,

   for (;;)

     {

       while (((wpf = atomic_load_relaxed (&rwlock->__data.__wrphase_futex))

-	  | PTHREAD_RWLOCK_FUTEX_USED) == (1 | PTHREAD_RWLOCK_FUTEX_USED))

+	      | PTHREAD_RWLOCK_FUTEX_USED) == (1 | PTHREAD_RWLOCK_FUTEX_USED))

 	{

 	  int private = __pthread_rwlock_get_private (rwlock);

 	  if (((wpf & PTHREAD_RWLOCK_FUTEX_USED) == 0)

-	      && !atomic_compare_exchange_weak_relaxed

+	      && (!atomic_compare_exchange_weak_relaxed

 		  (&rwlock->__data.__wrphase_futex,

-		   &wpf, wpf | PTHREAD_RWLOCK_FUTEX_USED))

+		   &wpf, wpf | PTHREAD_RWLOCK_FUTEX_USED)))

 	    continue;

 	  int err = futex_abstimed_wait (&rwlock->__data.__wrphase_futex,

-	      1 | PTHREAD_RWLOCK_FUTEX_USED, abstime, private);

+					 1 | PTHREAD_RWLOCK_FUTEX_USED,

+					 abstime, private);

 	  if (err == ETIMEDOUT)

 	    {

 	      /* If we timed out, we need to unregister.  If no read phase

@@ -477,8 +480,8 @@ __pthread_rwlock_rdlock_full (pthread_rwlock_t *rwlock,

 		 in this case and thus make the spin-waiting we need

 		 unnecessarily expensive.  */

 	      while ((atomic_load_relaxed (&rwlock->__data.__wrphase_futex)

-		  | PTHREAD_RWLOCK_FUTEX_USED)

-		  == (1 | PTHREAD_RWLOCK_FUTEX_USED))

+		      | PTHREAD_RWLOCK_FUTEX_USED)

+		     == (1 | PTHREAD_RWLOCK_FUTEX_USED))

 		{

 		  /* TODO Back-off?  */

 		}

@@ -495,7 +498,7 @@ __pthread_rwlock_rdlock_full (pthread_rwlock_t *rwlock,

 	 release of the writer, and so that we observe a recent value of

 	 __wrphase_futex (see below).  */

       if ((atomic_load_acquire (&rwlock->__data.__readers)

-	  & PTHREAD_RWLOCK_WRPHASE) == 0)

+	   & PTHREAD_RWLOCK_WRPHASE) == 0)

 	/* We are in a read phase now, so the least recent modification of

 	   __wrphase_futex we can read from is the store by the writer

 	   with value 1.  Thus, only now we can assume that if we observe

@@ -516,8 +519,9 @@ __pthread_rwlock_wrunlock (pthread_rwlock_t *rwlock)

   atomic_store_relaxed (&rwlock->__data.__cur_writer, 0);

   /* Disable waiting by writers.  We will wake up after we decided how to

      proceed.  */

-  bool wake_writers = ((atomic_exchange_relaxed

-      (&rwlock->__data.__writers_futex, 0) & PTHREAD_RWLOCK_FUTEX_USED) != 0);

+  bool wake_writers

+    = ((atomic_exchange_relaxed (&rwlock->__data.__writers_futex, 0)

+	& PTHREAD_RWLOCK_FUTEX_USED) != 0);

   if (rwlock->__data.__flags != PTHREAD_RWLOCK_PREFER_READER_NP)

     {

@@ -529,8 +533,8 @@ __pthread_rwlock_wrunlock (pthread_rwlock_t *rwlock)

 	     synchronize with us and thus can take over our view of

 	     __readers (including, for example, whether we are in a write

 	     phase or not).  */

-	  if (atomic_compare_exchange_weak_release (&rwlock->__data.__writers,

-	      &w, w | PTHREAD_RWLOCK_WRHANDOVER))

+	  if (atomic_compare_exchange_weak_release

+	      (&rwlock->__data.__writers, &w, w | PTHREAD_RWLOCK_WRHANDOVER))

 	    /* Another writer will take over.  */

 	    goto done;

 	  /* TODO Back-off.  */

@@ -543,9 +547,10 @@ __pthread_rwlock_wrunlock (pthread_rwlock_t *rwlock)

   unsigned int r = atomic_load_relaxed (&rwlock->__data.__readers);

   /* Release MO so that subsequent readers or writers synchronize with us.  */

   while (!atomic_compare_exchange_weak_release

-      (&rwlock->__data.__readers, &r, (r ^ PTHREAD_RWLOCK_WRLOCKED)

-	  ^ ((r >> PTHREAD_RWLOCK_READER_SHIFT) == 0 ? 0

-	      : PTHREAD_RWLOCK_WRPHASE)))

+	 (&rwlock->__data.__readers, &r,

+	  ((r ^ PTHREAD_RWLOCK_WRLOCKED)

+	   ^ ((r >> PTHREAD_RWLOCK_READER_SHIFT) == 0 ? 0

+	      : PTHREAD_RWLOCK_WRPHASE))))

     {

       /* TODO Back-off.  */

     }

@@ -574,7 +579,7 @@ __pthread_rwlock_wrlock_full (pthread_rwlock_t *rwlock,

   /* Make sure we are not holding the rwlock as a writer.  This is a deadlock

      situation we recognize and report.  */

   if (__glibc_unlikely (atomic_load_relaxed (&rwlock->__data.__cur_writer)

-      == THREAD_GETMEM (THREAD_SELF, tid)))

+			== THREAD_GETMEM (THREAD_SELF, tid)))

     return EDEADLK;

   /* First we try to acquire the role of primary writer by setting WRLOCKED;

@@ -593,12 +598,12 @@ __pthread_rwlock_wrlock_full (pthread_rwlock_t *rwlock,

      this could be less scalable if readers arrive and leave frequently.  */

   bool may_share_futex_used_flag = false;

   unsigned int r = atomic_fetch_or_acquire (&rwlock->__data.__readers,

-      PTHREAD_RWLOCK_WRLOCKED);

+					    PTHREAD_RWLOCK_WRLOCKED);

   if (__glibc_unlikely ((r & PTHREAD_RWLOCK_WRLOCKED) != 0))

     {

       /* There is another primary writer.  */

-      bool prefer_writer =

-	  (rwlock->__data.__flags != PTHREAD_RWLOCK_PREFER_READER_NP);

+      bool prefer_writer

+	= (rwlock->__data.__flags != PTHREAD_RWLOCK_PREFER_READER_NP);

       if (prefer_writer)

 	{

 	  /* We register as a waiting writer, so that we can make use of

@@ -617,8 +622,7 @@ __pthread_rwlock_wrlock_full (pthread_rwlock_t *rwlock,

 	      /* Try to become the primary writer or retry.  Acquire MO as in

 		 the fetch_or above.  */

 	      if (atomic_compare_exchange_weak_acquire

-		  (&rwlock->__data.__readers, &r,

-		      r | PTHREAD_RWLOCK_WRLOCKED))

+		  (&rwlock->__data.__readers, &r, r | PTHREAD_RWLOCK_WRLOCKED))

 		{

 		  if (prefer_writer)

 		    {

@@ -633,8 +637,7 @@ __pthread_rwlock_wrlock_full (pthread_rwlock_t *rwlock,

 			 __writers).

 			 ??? Perhaps this is not strictly necessary for

 			 reasons we do not yet know of.  */

-		      atomic_fetch_add_relaxed (&rwlock->__data.__writers,

-			  -1);

+		      atomic_fetch_add_relaxed (&rwlock->__data.__writers, -1);

 		    }

 		  break;

 		}

@@ -646,8 +649,7 @@ __pthread_rwlock_wrlock_full (pthread_rwlock_t *rwlock,

 	     succeed, we own WRLOCKED.  */

 	  if (prefer_writer)

 	    {

-	      unsigned int w = atomic_load_relaxed

-		  (&rwlock->__data.__writers);

+	      unsigned int w = atomic_load_relaxed (&rwlock->__data.__writers);

 	      if ((w & PTHREAD_RWLOCK_WRHANDOVER) != 0)

 		{

 		  /* Acquire MO is required here so that we synchronize with

@@ -677,13 +679,13 @@ __pthread_rwlock_wrlock_full (pthread_rwlock_t *rwlock,

 	  /* We did not acquire WRLOCKED nor were able to use writer--writer

 	     hand-over, so we block on __writers_futex.  */

 	  int private = __pthread_rwlock_get_private (rwlock);

-	  unsigned int wf = atomic_load_relaxed

-	      (&rwlock->__data.__writers_futex);

+	  unsigned int wf

+	    = atomic_load_relaxed (&rwlock->__data.__writers_futex);

 	  if (((wf & ~(unsigned int) PTHREAD_RWLOCK_FUTEX_USED) != 1)

 	      || ((wf != (1 | PTHREAD_RWLOCK_FUTEX_USED))

-		  && !atomic_compare_exchange_weak_relaxed

+		  && (!atomic_compare_exchange_weak_relaxed

 		      (&rwlock->__data.__writers_futex, &wf,

-		       1 | PTHREAD_RWLOCK_FUTEX_USED)))

+		       1 | PTHREAD_RWLOCK_FUTEX_USED))))

 	    {

 	      /* If we cannot block on __writers_futex because there is no

 		 primary writer, or we cannot set PTHREAD_RWLOCK_FUTEX_USED,

@@ -704,7 +706,8 @@ __pthread_rwlock_wrlock_full (pthread_rwlock_t *rwlock,

 	     in this group.  */

 	  may_share_futex_used_flag = true;

 	  int err = futex_abstimed_wait (&rwlock->__data.__writers_futex,

-	      1 | PTHREAD_RWLOCK_FUTEX_USED, abstime, private);

+					 1 | PTHREAD_RWLOCK_FUTEX_USED,

+					 abstime, private);

 	  if (err == ETIMEDOUT)

 	    {

 	      if (prefer_writer)

@@ -716,10 +719,10 @@ __pthread_rwlock_wrlock_full (pthread_rwlock_t *rwlock,

 		     that this happened before the timeout; see

 		     pthread_rwlock_rdlock_full for the full reasoning.)

 		     Also see the similar code above.  */

-		  unsigned int w = atomic_load_relaxed

-		      (&rwlock->__data.__writers);

+		  unsigned int w

+		    = atomic_load_relaxed (&rwlock->__data.__writers);

 		  while (!atomic_compare_exchange_weak_acquire

-		      (&rwlock->__data.__writers, &w,

+			 (&rwlock->__data.__writers, &w,

 			  (w == PTHREAD_RWLOCK_WRHANDOVER + 1 ? 0 : w - 1)))

 		    {

 		      /* TODO Back-off.  */

@@ -751,7 +754,8 @@ __pthread_rwlock_wrlock_full (pthread_rwlock_t *rwlock,

      modifications of __readers ensures that this store happens after the

      store of value 0 by the previous primary writer.  */

   atomic_store_relaxed (&rwlock->__data.__writers_futex,

-      1 | (may_share_futex_used_flag ? PTHREAD_RWLOCK_FUTEX_USED : 0));

+			1 | (may_share_futex_used_flag

+			     ? PTHREAD_RWLOCK_FUTEX_USED : 0));

   /* If we are in a write phase, we have acquired the lock.  */

   if ((r & PTHREAD_RWLOCK_WRPHASE) != 0)

@@ -759,15 +763,15 @@ __pthread_rwlock_wrlock_full (pthread_rwlock_t *rwlock,

   /* If we are in a read phase and there are no readers, try to start a write

      phase.  */

-  while (((r & PTHREAD_RWLOCK_WRPHASE) == 0)

-      && ((r >> PTHREAD_RWLOCK_READER_SHIFT) == 0))

+  while ((r & PTHREAD_RWLOCK_WRPHASE) == 0

+	 && (r >> PTHREAD_RWLOCK_READER_SHIFT) == 0)

     {

       /* Acquire MO so that we synchronize with prior writers and do

 	 not interfere with their updates to __writers_futex, as well

 	 as regarding prior readers and their updates to __wrphase_futex,

 	 respectively.  */

       if (atomic_compare_exchange_weak_acquire (&rwlock->__data.__readers,

-	  &r, r | PTHREAD_RWLOCK_WRPHASE))

+						&r, r | PTHREAD_RWLOCK_WRPHASE))

 	{

 	  /* We have started a write phase, so need to enable readers to wait.

 	     See the similar case in __pthread_rwlock_rdlock_full.  Unlike in

@@ -792,24 +796,24 @@ __pthread_rwlock_wrlock_full (pthread_rwlock_t *rwlock,

   for (;;)

     {

       while (((wpf = atomic_load_relaxed (&rwlock->__data.__wrphase_futex))

-	  | PTHREAD_RWLOCK_FUTEX_USED) == PTHREAD_RWLOCK_FUTEX_USED)

+	      | PTHREAD_RWLOCK_FUTEX_USED) == PTHREAD_RWLOCK_FUTEX_USED)

 	{

 	  int private = __pthread_rwlock_get_private (rwlock);

-	  if (((wpf & PTHREAD_RWLOCK_FUTEX_USED) == 0)

-	      && !atomic_compare_exchange_weak_relaxed

+	  if ((wpf & PTHREAD_RWLOCK_FUTEX_USED) == 0

+	      && (!atomic_compare_exchange_weak_relaxed

 		  (&rwlock->__data.__wrphase_futex, &wpf,

-		   PTHREAD_RWLOCK_FUTEX_USED))

+		   PTHREAD_RWLOCK_FUTEX_USED)))

 	    continue;

 	  int err = futex_abstimed_wait (&rwlock->__data.__wrphase_futex,

-	      PTHREAD_RWLOCK_FUTEX_USED, abstime, private);

+					 PTHREAD_RWLOCK_FUTEX_USED,

+					 abstime, private);

 	  if (err == ETIMEDOUT)

 	    {

-	      if (rwlock->__data.__flags

-		  != PTHREAD_RWLOCK_PREFER_READER_NP)

+	      if (rwlock->__data.__flags != PTHREAD_RWLOCK_PREFER_READER_NP)

 		{

 		  /* We try writer--writer hand-over.  */

-		  unsigned int w = atomic_load_relaxed

-		      (&rwlock->__data.__writers);

+		  unsigned int w

+		    = atomic_load_relaxed (&rwlock->__data.__writers);

 		  if (w != 0)

 		    {

 		      /* We are about to hand over WRLOCKED, so we must

@@ -823,13 +827,13 @@ __pthread_rwlock_wrlock_full (pthread_rwlock_t *rwlock,

 			 Release MO so that another writer that gets

 			 WRLOCKED from us can take over our view of

 			 __readers.  */

-		      unsigned int wf = atomic_exchange_relaxed

-			  (&rwlock->__data.__writers_futex, 0);

+		      unsigned int wf

+			= atomic_exchange_relaxed (&rwlock->__data.__writers_futex, 0);

 		      while (w != 0)

 			{

 			  if (atomic_compare_exchange_weak_release

 			      (&rwlock->__data.__writers, &w,

-				  w | PTHREAD_RWLOCK_WRHANDOVER))

+			       w | PTHREAD_RWLOCK_WRHANDOVER))

 			    {

 			      /* Wake other writers.  */

 			      if ((wf & PTHREAD_RWLOCK_FUTEX_USED) != 0)

@@ -844,8 +848,7 @@ __pthread_rwlock_wrlock_full (pthread_rwlock_t *rwlock,

 			 again.  Make sure we don't loose the flag that

 			 signals whether there are threads waiting on

 			 this futex.  */

-		      atomic_store_relaxed

-			  (&rwlock->__data.__writers_futex, wf);

+		      atomic_store_relaxed (&rwlock->__data.__writers_futex, wf);

 		    }

 		}

 	      /* If we timed out and we are not in a write phase, we can

@@ -857,8 +860,8 @@ __pthread_rwlock_wrlock_full (pthread_rwlock_t *rwlock,

 		  /* We are about to release WRLOCKED, so we must release

 		     __writers_futex too; see the handling of

 		     writer--writer hand-over above.  */

-		  unsigned int wf = atomic_exchange_relaxed

-		      (&rwlock->__data.__writers_futex, 0);

+		  unsigned int wf

+		    = atomic_exchange_relaxed (&rwlock->__data.__writers_futex, 0);

 		  while ((r & PTHREAD_RWLOCK_WRPHASE) == 0)

 		    {

 		      /* While we don't need to make anything from a

@@ -877,11 +880,11 @@ __pthread_rwlock_wrlock_full (pthread_rwlock_t *rwlock,

 			  /* Wake other writers.  */

 			  if ((wf & PTHREAD_RWLOCK_FUTEX_USED) != 0)

 			    futex_wake (&rwlock->__data.__writers_futex,

-				1, private);

+					1, private);

 			  /* Wake waiting readers.  */

 			  if ((r & PTHREAD_RWLOCK_RWAITING) != 0)

 			    futex_wake (&rwlock->__data.__readers,

-				INT_MAX, private);

+					INT_MAX, private);

 			  return ETIMEDOUT;

 			}

 		    }

@@ -898,10 +901,9 @@ __pthread_rwlock_wrlock_full (pthread_rwlock_t *rwlock,

 	      atomic_thread_fence_acquire ();

 	      /* We still need to wait for explicit hand-over, but we must

 		 not use futex_wait anymore.  */

-	      while ((atomic_load_relaxed

-		  (&rwlock->__data.__wrphase_futex)

-		   | PTHREAD_RWLOCK_FUTEX_USED)

-		  == PTHREAD_RWLOCK_FUTEX_USED)

+	      while ((atomic_load_relaxed (&rwlock->__data.__wrphase_futex)

+		      | PTHREAD_RWLOCK_FUTEX_USED)

+		     == PTHREAD_RWLOCK_FUTEX_USED)

 		{

 		  /* TODO Back-off.  */

 		}

@@ -915,12 +917,12 @@ __pthread_rwlock_wrlock_full (pthread_rwlock_t *rwlock,

       if (ready)

 	break;

       if ((atomic_load_acquire (&rwlock->__data.__readers)

-	  & PTHREAD_RWLOCK_WRPHASE) != 0)

+	   & PTHREAD_RWLOCK_WRPHASE) != 0)

 	ready = true;

     }

  done:

   atomic_store_relaxed (&rwlock->__data.__cur_writer,

-      THREAD_GETMEM (THREAD_SELF, tid));

+			THREAD_GETMEM (THREAD_SELF, tid));

   return 0;

 }