Fix a typo.

[binutils-gdb.git] / gold / testsuite / tls_test_main.cc

diff --git a/gold/testsuite/tls_test_main.cc b/gold/testsuite/tls_test_main.cc
index 8b2d585c103d343afb07c24d21288afa2d536134..0ff02c6bc10413d8fbaa8e1edf8de7d5bab43d21 100644 (file)
--- a/gold/testsuite/tls_test_main.cc
+++ b/gold/testsuite/tls_test_main.cc
@@ -1,6 +1,6 @@
 // tls_test.cc -- test TLS variables for gold, main function
 
-// Copyright 2006, 2007 Free Software Foundation, Inc.
+// Copyright 2006, 2007, 2008 Free Software Foundation, Inc.
 // Written by Ian Lance Taylor <iant@google.com>.
 
 // This file is part of gold.
@@ -29,6 +29,23 @@
 
 #include "tls_test.h"
 
+// We make these macros so the assert() will give useful line-numbers.
+#define safe_lock(muptr)                       \
+  do                                           \
+    {                                          \
+      int err = pthread_mutex_lock(muptr);     \
+      assert(err == 0);                                \
+    }                                          \
+  while (0)
+
+#define safe_unlock(muptr)                     \
+  do                                           \
+    {                                          \
+      int err = pthread_mutex_unlock(muptr);   \
+      assert(err == 0);                                \
+    }                                          \
+  while (0)
+
 struct Mutex_set
 {
   pthread_mutex_t mutex1;
@@ -66,8 +83,8 @@ thread_routine(void* arg)
   Mutex_set* pms = static_cast<Mutex_set*>(arg);
 
   // Lock the first mutex.
-  int err = pthread_mutex_lock(&pms->mutex1);
-  assert(err == 0);
+  if (pms)
+    safe_lock(&pms->mutex1);
 
   // Run the tests.
   check("t1", t1());
@@ -82,15 +99,17 @@ thread_routine(void* arg)
   check("t9", t9());
   f10b(f10a());
   check("t10", t10());
+  check("t11", t11() != 0);
+  check("t12", t12());
   check("t_last", t_last());
 
   // Unlock the second mutex.
-  err = pthread_mutex_unlock(&pms->mutex2);
-  assert(err == 0);
+  if (pms)
+    safe_unlock(&pms->mutex2);
 
   // Lock the third mutex.
-  err = pthread_mutex_lock(&pms->mutex3);
-  assert(err == 0);
+  if (pms)
+    safe_lock(&pms->mutex3);
 
   check("t_last", t_last());
 
@@ -102,25 +121,23 @@ thread_routine(void* arg)
 int
 main()
 {
+  // First, as a sanity check, run through the tests in the "main" thread.
+  thread_routine(0);
+
   // Set up the mutex locks.  We want the first thread to start right
   // away, tell us when it is done with the first part, and wait for
   // us to release it.  We want the second thread to wait to start,
   // tell us when it is done with the first part, and wait for us to
   // release it.
-  int err = pthread_mutex_lock(&mutexes1.mutex2);
-  assert(err == 0);
-  err = pthread_mutex_lock(&mutexes1.mutex3);
-  assert(err == 0);
+  safe_lock(&mutexes1.mutex2);
+  safe_lock(&mutexes1.mutex3);
 
-  err = pthread_mutex_lock(&mutexes2.mutex1);
-  assert(err == 0);
-  err = pthread_mutex_lock(&mutexes2.mutex2);
-  assert(err == 0);
-  err = pthread_mutex_lock(&mutexes2.mutex3);
-  assert(err == 0);
+  safe_lock(&mutexes2.mutex1);
+  safe_lock(&mutexes2.mutex2);
+  safe_lock(&mutexes2.mutex3);
 
   pthread_t thread1;
-  err = pthread_create(&thread1, NULL, thread_routine, &mutexes1);
+  int err = pthread_create(&thread1, NULL, thread_routine, &mutexes1);
   assert(err == 0);
 
   pthread_t thread2;
@@ -128,20 +145,16 @@ main()
   assert(err == 0);
 
   // Wait for the first thread to complete the first part.
-  err = pthread_mutex_lock(&mutexes1.mutex2);
-  assert(err == 0);
+  safe_lock(&mutexes1.mutex2);
 
   // Tell the second thread to start.
-  err = pthread_mutex_unlock(&mutexes2.mutex1);
-  assert(err == 0);
+  safe_unlock(&mutexes2.mutex1);
 
   // Wait for the second thread to complete the first part.
-  err = pthread_mutex_lock(&mutexes2.mutex2);
-  assert(err == 0);
+  safe_lock(&mutexes2.mutex2);
 
   // Tell the first thread to continue and finish.
-  err = pthread_mutex_unlock(&mutexes1.mutex3);
-  assert(err == 0);
+  safe_unlock(&mutexes1.mutex3);
 
   // Wait for the first thread to finish.
   void* thread_val;
@@ -150,8 +163,7 @@ main()
   assert(thread_val == 0);
 
   // Tell the second thread to continue and finish.
-  err = pthread_mutex_unlock(&mutexes2.mutex3);
-  assert(err == 0);
+  safe_unlock(&mutexes2.mutex3);
 
   // Wait for the second thread to finish.
   err = pthread_join(thread2, &thread_val);