modified nacl_sync.h to have NACL_WUR for all functions that return a

src/shared/platform/nacl_semaphore_test.c

 /*
  * Copyright (c) 2011 The Native Client Authors. All rights reserved.
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */
 
 #include <stdio.h>
 
 #include "native_client/src/include/portability.h"
 #include "native_client/src/include/nacl_macros.h"
 
 #include "native_client/src/shared/platform/nacl_semaphore.h"
 
 #include "native_client/src/shared/platform/nacl_sync.h"
+#include "native_client/src/shared/platform/nacl_sync_checked.h"
 #include "native_client/src/shared/platform/nacl_threads.h"
 #include "native_client/src/shared/platform/nacl_time.h"
 #include "native_client/src/shared/platform/platform_init.h"
 
 #include "native_client/src/trusted/service_runtime/include/sys/time.h"
 
 #define STACK_SIZE_BYTES        (4 * 4096)
 #define NUM_TRIES_SUFFICIENT    (5)
 
 void ThreadSleepMs(uint64_t msec) {
@@ skipping 22 matching lines @@
   int       got_sem = 0;
   int       failed = 0;
 
   for (sleep_count = 0; sleep_count < gNumTriesSufficient; ++sleep_count) {
     /* the sem_trywait should not succeed the first time through */
     if (NACL_SYNC_BUSY != NaClSemTryWait(&gSem)) {
       got_sem = 1;
       break;
     }
     if (0 == sleep_count) {
-      NaClMutexLock(&gMu);
+      NaClXMutexLock(&gMu);
       ++gNumThreadsTried;
-      NaClMutexUnlock(&gMu);
-      NaClCondVarSignal(&gCv);
+      NaClXCondVarSignal(&gCv);
+      NaClXMutexUnlock(&gMu);
     }
     PauseSpinningThread();
   }
 
   if (got_sem) {
     printf("Thread %d: NaClSemTryWait succeeded at %"NACL_PRId64"\n",
            thread_num,
            sleep_count);
   } else {
     /* gNumThreadsTried == sleep_count */
     printf("Thread %d: NaClSemWait\n", thread_num);
     if (NACL_SYNC_OK != NaClSemWait(&gSem)) {
       printf("FAILED\n");
       printf("NaClSemWait failed!?!\n");
       failed = 1;
     }
   }
 
   if (0 == sleep_count) {
     printf("FAILED\n");
     printf("Thread %d never actually waited at NaClSemTryWait\n", thread_num);
     failed = 1;
   } else {
     printf("OK -- thread %d\n", thread_num);
   }
 
-  NaClMutexLock(&gMu);
+  NaClXMutexLock(&gMu);
   gFailure += failed;
   ++gNumThreadsDone;
-  NaClCondVarSignal(&gCv);
-  NaClMutexUnlock(&gMu);
+  NaClXCondVarSignal(&gCv);
+  NaClXMutexUnlock(&gMu);
 }
 
 int main(int ac, char **av) {
   int exit_status = -1;
   int opt;
   size_t num_threads = 16;
   size_t n;
   struct NaClThread thr;
 
   while (EOF != (opt = getopt(ac, av, "n:s:t:"))) {
@@ skipping 31 matching lines @@
   for (n = 0; n < num_threads; ++n) {
     if (!NaClThreadCtor(&thr, ThreadMain, (void *) (uintptr_t) n,
                         STACK_SIZE_BYTES)) {
       fprintf(stderr,
               "nacl_semaphore_test: could not create thread %"NACL_PRIdS"\n",
               n);
       goto cleanup4;  /* osx leak semaphore otherwise */
     }
   }
 
-  NaClMutexLock(&gMu);
+  NaClXMutexLock(&gMu);
   while (gNumThreadsTried != num_threads) {
-    NaClCondVarWait(&gCv, &gMu);
+    NaClXCondVarWait(&gCv, &gMu);
   }
-  NaClMutexUnlock(&gMu);
+  NaClXMutexUnlock(&gMu);
 
   for (n = 0; n < num_threads; ++n) {
     NaClSemPost(&gSem);  /* let a thread go */
   }
 
-  NaClMutexLock(&gMu);
+  NaClXMutexLock(&gMu);
   while (gNumThreadsDone != num_threads) {
-    NaClCondVarWait(&gCv, &gMu);
+    NaClXCondVarWait(&gCv, &gMu);
   }
   exit_status = gFailure;
-  NaClMutexUnlock(&gMu);
+  NaClXMutexUnlock(&gMu);
 
   if (0 == exit_status) {
     printf("SUCCESS\n");
   }
  cleanup4:
   /* single exit with (ah hem) simulation of RAII via cleanup sled */
   NaClCondVarDtor(&gCv);
  cleanup3:
   NaClMutexDtor(&gMu);
  cleanup2:
   NaClSemDtor(&gSem);
  cleanup1:
   NaClPlatformFini();
  cleanup0:
   return exit_status;
 }