From 09e3314cca72712244f2ff775f0589f6383e9ffc Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Sun, 14 Oct 2007 03:23:38 +0000 Subject: [PATCH] From Craig Silverstein: TLS test cleanups. --- gold/testsuite/tls_test.cc | 69 +++++++++++++++++++++------------------- gold/testsuite/tls_test.h | 5 +++ gold/testsuite/tls_test_file2.cc | 5 ++- gold/testsuite/tls_test_main.cc | 64 +++++++++++++++++++++---------------- 4 files changed, 83 insertions(+), 60 deletions(-) diff --git a/gold/testsuite/tls_test.cc b/gold/testsuite/tls_test.cc index 995e20b53d..ca3d9c5981 100644 --- a/gold/testsuite/tls_test.cc +++ b/gold/testsuite/tls_test.cc @@ -44,8 +44,20 @@ // last Verify that the above tests left the variables set correctly. +#include #include "tls_test.h" +#define CHECK_EQ_OR_RETURN(var, expected) \ + do \ + { \ + if ((var) != (expected)) \ + { \ + printf(#var ": expected %d, found %d\n", expected, var); \ + return false; \ + } \ + } \ + while (0) + __thread int v1; static __thread int v2; __thread int v3 = 3; @@ -53,16 +65,10 @@ static __thread int v4 = 4; __thread int v5; static __thread int v6; -// These variables are defined in tls_test_file2.cc -extern __thread int o1; -extern __thread int o2; -extern __thread int o3; - bool t1() { - if (v1 != 0) - return false; + CHECK_EQ_OR_RETURN(v1, 0); v1 = 10; return true; } @@ -70,8 +76,7 @@ t1() bool t2() { - if (v2 != 0) - return false; + CHECK_EQ_OR_RETURN(v2, 0); v2 = 20; return true; } @@ -79,8 +84,7 @@ t2() bool t3() { - if (v3 != 3) - return false; + CHECK_EQ_OR_RETURN(v3, 3); v3 = 30; return true; } @@ -88,8 +92,7 @@ t3() bool t4() { - if (v4 != 4) - return false; + CHECK_EQ_OR_RETURN(v4, 4); v4 = 40; return true; } @@ -111,7 +114,8 @@ f5b(int* p) bool t5() { - return v5 == 50; + CHECK_EQ_OR_RETURN(v5, 50); + return true; } // For test 6 the main function calls f6b(f6a()), then calls t6(). @@ -131,7 +135,8 @@ f6b(int* p) bool t6() { - return v6 == 60; + CHECK_EQ_OR_RETURN(v6, 60); + return true; } // The slot for t7() is unused. @@ -139,18 +144,16 @@ t6() bool t8() { - if (o1 != 0) - return false; - o1 = 10; + CHECK_EQ_OR_RETURN(o1, 0); + o1 = -10; return true; } bool t9() { - if (o2 != 2) - return false; - o2 = 20; + CHECK_EQ_OR_RETURN(o2, -2); + o2 = -20; return true; } @@ -165,25 +168,27 @@ f10a() void f10b(int* p) { - *p = 30; + *p = -30; } bool t10() { - return o3 == 30; + CHECK_EQ_OR_RETURN(o3, -30); + return true; } bool t_last() { - return (v1 == 10 - && v2 == 20 - && v3 == 30 - && v4 == 40 - && v5 == 50 - && v6 == 60 - && o1 == 10 - && o2 == 20 - && o3 == 30); + CHECK_EQ_OR_RETURN(v1, 10); + CHECK_EQ_OR_RETURN(v2, 20); + CHECK_EQ_OR_RETURN(v3, 30); + CHECK_EQ_OR_RETURN(v4, 40); + CHECK_EQ_OR_RETURN(v5, 50); + CHECK_EQ_OR_RETURN(v6, 60); + CHECK_EQ_OR_RETURN(o1, -10); + CHECK_EQ_OR_RETURN(o2, -20); + CHECK_EQ_OR_RETURN(o3, -30); + return true; } diff --git a/gold/testsuite/tls_test.h b/gold/testsuite/tls_test.h index 1a1b6fd080..b78e49eedf 100644 --- a/gold/testsuite/tls_test.h +++ b/gold/testsuite/tls_test.h @@ -44,3 +44,8 @@ extern void f10b(int*); extern bool t10(); extern bool t_last(); + +// These variables are defined in tls_test_file2.cc +extern __thread int o1; +extern __thread int o2; +extern __thread int o3; diff --git a/gold/testsuite/tls_test_file2.cc b/gold/testsuite/tls_test_file2.cc index 103681a079..150a13925a 100644 --- a/gold/testsuite/tls_test_file2.cc +++ b/gold/testsuite/tls_test_file2.cc @@ -21,7 +21,10 @@ // MA 02110-1301, USA. // This is the definition of a thread-local variable in another file. +// See tls_test.cc for more information. + +#include "tls_test.h" __thread int o1; -__thread int o2 = 2; +__thread int o2 = -2; __thread int o3; diff --git a/gold/testsuite/tls_test_main.cc b/gold/testsuite/tls_test_main.cc index 8b2d585c10..805ffcb2d2 100644 --- a/gold/testsuite/tls_test_main.cc +++ b/gold/testsuite/tls_test_main.cc @@ -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(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()); @@ -85,12 +102,12 @@ thread_routine(void* arg) 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 +119,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 +143,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 +161,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); -- 2.11.0