Fix static initializers for locks.

[tlwilmar]

Summary

Fix static initializers to use the proper unlocked value for the poll field of the tas and futex locks.

[hbae]

LGTM

openmp/trunk/runtime/src/kmp_lock.h

 // the depth_locked field for non-nested locks.
 //
 // Information normally available to the tools, such as lock location, lock
 // usage (normal lock vs. critical section), etc. is not available with test and
 // set locks.
 // ----------------------------------------------------------------------------
 
 struct kmp_base_tas_lock {
-  volatile kmp_int32 poll; // 0 => unlocked; locked: (gtid+1) of owning thread
+  // KMP_LOCK_FREE(tas) => unlocked; locked: (gtid+1) of owning thread
+  volatile kmp_int32 poll;
   kmp_int32 depth_locked; // depth locked, for nested locks only
 };
 
 typedef struct kmp_base_tas_lock kmp_base_tas_lock_t;
 
 union kmp_tas_lock {
   kmp_base_tas_lock_t lk;
   kmp_lock_pool_t pool; // make certain struct is large enough
   double lk_align; // use worst case alignment; no cache line padding
 };
 
 typedef union kmp_tas_lock kmp_tas_lock_t;
 
 // Static initializer for test and set lock variables. Usage:
 //    kmp_tas_lock_t xlock = KMP_TAS_LOCK_INITIALIZER( xlock );
 #define KMP_TAS_LOCK_INITIALIZER(lock)                                         \
   {                                                                            \
-    { 0, 0 }                                                                   \
+    { KMP_LOCK_FREE(tas), 0 }                                                  \
   }
 
 extern int __kmp_acquire_tas_lock(kmp_tas_lock_t *lck, kmp_int32 gtid);
 extern int __kmp_test_tas_lock(kmp_tas_lock_t *lck, kmp_int32 gtid);
 extern int __kmp_release_tas_lock(kmp_tas_lock_t *lck, kmp_int32 gtid);
 extern void __kmp_init_tas_lock(kmp_tas_lock_t *lck);
 extern void __kmp_destroy_tas_lock(kmp_tas_lock_t *lck);
 

 // allocated by the compiler for the lock, rather than a pointer to it.
 //
 // Information normally available to the tools, such as lock location, lock
 // usage (normal lock vs. critical section), etc. is not available with test and
 // set locks. With non-nested futex locks, the lock owner is not even available.
 // ----------------------------------------------------------------------------
 
 struct kmp_base_futex_lock {
-  volatile kmp_int32 poll; // 0 => unlocked
+  volatile kmp_int32 poll; // KMP_LOCK_FREE(futex) => unlocked
   // 2*(gtid+1) of owning thread, 0 if unlocked
   // locked: (gtid+1) of owning thread
   kmp_int32 depth_locked; // depth locked, for nested locks only
 };
 
 typedef struct kmp_base_futex_lock kmp_base_futex_lock_t;
 
 union kmp_futex_lock {
   kmp_base_futex_lock_t lk;
   kmp_lock_pool_t pool; // make certain struct is large enough
   double lk_align; // use worst case alignment
   // no cache line padding
 };
 
 typedef union kmp_futex_lock kmp_futex_lock_t;
 
 // Static initializer for futex lock variables. Usage:
 //    kmp_futex_lock_t xlock = KMP_FUTEX_LOCK_INITIALIZER( xlock );
 #define KMP_FUTEX_LOCK_INITIALIZER(lock)                                       \
   {                                                                            \
-    { 0, 0 }                                                                   \
+    { KMP_LOCK_FREE(futex), 0 }                                                \
   }
 
 extern int __kmp_acquire_futex_lock(kmp_futex_lock_t *lck, kmp_int32 gtid);
 extern int __kmp_test_futex_lock(kmp_futex_lock_t *lck, kmp_int32 gtid);
 extern int __kmp_release_futex_lock(kmp_futex_lock_t *lck, kmp_int32 gtid);
 extern void __kmp_init_futex_lock(kmp_futex_lock_t *lck);
 extern void __kmp_destroy_futex_lock(kmp_futex_lock_t *lck);