[sanitizers] Update sanitizers test to better match glibc internals

[rovka]

Summary

One of the tests relying on sem_t's layout gets the wrong value for versions of
glibc newer than 2.21 on platforms that don't have 64-bit atomics (e.g. ARM).

This commit fixes the test to work with:

• versions of glibc >= 2.21 on platforms with 64-bit atomics: unchanged
• versions of glibc >= 2.21 on platforms without 64-bit atomics: the semaphore

value is shifted by SEM_VALUE_SHIFT (which is set to 1 in glibc's internal
headers)

• versions of glibc < 2.21: unchanged

See the glibc 2.23 sources:

• sysdeps/nptl/internaltypes.h (struct new_sem for glibc >= 2.21 and struct old_sem for glibc < 2.21)
• nptl/sem_getvalue.c

This was uncovered on one of the new buildbots that we are trying to move to
production (ARM with glibc 2.23). I have tested on x86_64 with glibc 2.21 and
2.17, AArch64 with glibc 2.21 and ARM with glibc 2.19 and 2.23.

[rengolin]

This patch fixes our new Xenial buildbot[1], just waiting for that to go live.

cheers,
--renato

[1] http://buildmaster.tcwglab.linaro.org/builders/clang-cmake-thumbv7-a15-full-sh

[eugenis]

LGTM

test/sanitizer_common/TestCases/Linux/sem_init_glibc.cc

 // RUN: %clangxx -O0 -g %s -lutil -o %t && %run %t
 // This test depends on the glibc layout of struct sem_t and checks that we
 // don't leave sem_t::private uninitialized.
 // UNSUPPORTED: android
 #include <features.h>
 #include <assert.h>
 #include <semaphore.h>
 #include <string.h>
 #include <stdint.h>
 
 // This condition needs to correspond to __HAVE_64B_ATOMICS macro in glibc.
 #if (defined(__x86_64__) || defined(__aarch64__) || defined(__powerpc64__) || \
      defined(__s390x__) || defined(__sparc64__) || defined(__alpha__) || \
      defined(__ia64__) || defined(__m68k__)) && __GLIBC_PREREQ(2, 21)
 typedef uint64_t semval_t;
+#define GET_SEM_VALUE(V) (V)
 #else
 typedef unsigned semval_t;
+#if __GLIBC_PREREQ(2, 21)
+#define GET_SEM_VALUE(V) ((V) >> 1)
+#else
+#define GET_SEM_VALUE(V) (V)
+#endif
 #endif
 
 void my_sem_init(bool priv, int value, semval_t *a, unsigned char *b) {
   sem_t sem;
   memset(&sem, 0xAB, sizeof(sem));
   sem_init(&sem, priv, value);
 
   char *p = (char *)&sem;
   memcpy(a, p, sizeof(semval_t));
   memcpy(b, p + sizeof(semval_t), sizeof(char));
 
   sem_destroy(&sem);
 }
 
 int main() {
   semval_t a;
   unsigned char b;
 
   my_sem_init(false, 42, &a, &b);
-  assert(a == 42);
+  assert(GET_SEM_VALUE(a) == 42);
   assert(b != 0xAB);
 
   my_sem_init(true, 43, &a, &b);
-  assert(a == 43);
+  assert(GET_SEM_VALUE(a) == 43);
   assert(b != 0xAB);
 }