contrib/compiler-rt/lib/sanitizer_common/tests/sanitizer_atomic_test.cc

   1 //===-- sanitizer_atomic_test.cc ------------------------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file is a part of ThreadSanitizer/AddressSanitizer runtime.
  11 //
  12 //===----------------------------------------------------------------------===//
  13 #include "sanitizer_common/sanitizer_atomic.h"
  14 #include "gtest/gtest.h"
  15
  16 namespace __sanitizer {
  17
  18 template<typename T>
  19 struct ValAndMagic {
  20   typename T::Type magic0;
  21   T a;
  22   typename T::Type magic1;
  23
  24   static ValAndMagic<T> *sink;
  25 };
  26
  27 template<typename T>
  28 ValAndMagic<T> *ValAndMagic<T>::sink;
  29
  30 template<typename T, memory_order load_mo, memory_order store_mo>
  31 void CheckStoreLoad() {
  32   typedef typename T::Type Type;
  33   ValAndMagic<T> val;
  34   // Prevent the compiler from scalarizing the struct.
  35   ValAndMagic<T>::sink = &val;
  36   // Ensure that surrounding memory is not overwritten.
  37   val.magic0 = val.magic1 = (Type)-3;
  38   for (u64 i = 0; i < 100; i++) {
  39     // Generate a value that occupies all bytes of the variable.
  40     u64 v = i;
  41     v |= v << 8;
  42     v |= v << 16;
  43     v |= v << 32;
  44     val.a.val_dont_use = (Type)v;
  45     EXPECT_EQ(atomic_load(&val.a, load_mo), (Type)v);
  46     val.a.val_dont_use = (Type)-1;
  47     atomic_store(&val.a, (Type)v, store_mo);
  48     EXPECT_EQ(val.a.val_dont_use, (Type)v);
  49   }
  50   EXPECT_EQ(val.magic0, (Type)-3);
  51   EXPECT_EQ(val.magic1, (Type)-3);
  52 }
  53
  54 TEST(SanitizerCommon, AtomicStoreLoad) {
  55   CheckStoreLoad<atomic_uint8_t, memory_order_relaxed, memory_order_relaxed>();
  56   CheckStoreLoad<atomic_uint8_t, memory_order_consume, memory_order_relaxed>();
  57   CheckStoreLoad<atomic_uint8_t, memory_order_acquire, memory_order_relaxed>();
  58   CheckStoreLoad<atomic_uint8_t, memory_order_relaxed, memory_order_release>();
  59   CheckStoreLoad<atomic_uint8_t, memory_order_seq_cst, memory_order_seq_cst>();
  60
  61   CheckStoreLoad<atomic_uint16_t, memory_order_relaxed, memory_order_relaxed>();
  62   CheckStoreLoad<atomic_uint16_t, memory_order_consume, memory_order_relaxed>();
  63   CheckStoreLoad<atomic_uint16_t, memory_order_acquire, memory_order_relaxed>();
  64   CheckStoreLoad<atomic_uint16_t, memory_order_relaxed, memory_order_release>();
  65   CheckStoreLoad<atomic_uint16_t, memory_order_seq_cst, memory_order_seq_cst>();
  66
  67   CheckStoreLoad<atomic_uint32_t, memory_order_relaxed, memory_order_relaxed>();
  68   CheckStoreLoad<atomic_uint32_t, memory_order_consume, memory_order_relaxed>();
  69   CheckStoreLoad<atomic_uint32_t, memory_order_acquire, memory_order_relaxed>();
  70   CheckStoreLoad<atomic_uint32_t, memory_order_relaxed, memory_order_release>();
  71   CheckStoreLoad<atomic_uint32_t, memory_order_seq_cst, memory_order_seq_cst>();
  72
  73   CheckStoreLoad<atomic_uint64_t, memory_order_relaxed, memory_order_relaxed>();
  74   CheckStoreLoad<atomic_uint64_t, memory_order_consume, memory_order_relaxed>();
  75   CheckStoreLoad<atomic_uint64_t, memory_order_acquire, memory_order_relaxed>();
  76   CheckStoreLoad<atomic_uint64_t, memory_order_relaxed, memory_order_release>();
  77   CheckStoreLoad<atomic_uint64_t, memory_order_seq_cst, memory_order_seq_cst>();
  78
  79   CheckStoreLoad<atomic_uintptr_t, memory_order_relaxed, memory_order_relaxed>
  80       ();
  81   CheckStoreLoad<atomic_uintptr_t, memory_order_consume, memory_order_relaxed>
  82       ();
  83   CheckStoreLoad<atomic_uintptr_t, memory_order_acquire, memory_order_relaxed>
  84       ();
  85   CheckStoreLoad<atomic_uintptr_t, memory_order_relaxed, memory_order_release>
  86       ();
  87   CheckStoreLoad<atomic_uintptr_t, memory_order_seq_cst, memory_order_seq_cst>
  88       ();
  89 }
  90
  91 // Clang crashes while compiling this test for Android:
  92 // http://llvm.org/bugs/show_bug.cgi?id=15587
  93 #if !SANITIZER_ANDROID
  94 template<typename T>
  95 void CheckAtomicCompareExchange() {
  96   typedef typename T::Type Type;
  97   {
  98     Type old_val = 42;
  99     Type new_val = 24;
 100     Type var = old_val;
 101     EXPECT_TRUE(atomic_compare_exchange_strong((T*)&var, &old_val, new_val,
 102                                                memory_order_relaxed));
 103     EXPECT_FALSE(atomic_compare_exchange_strong((T*)&var, &old_val, new_val,
 104                                                 memory_order_relaxed));
 105     EXPECT_EQ(new_val, old_val);
 106   }
 107   {
 108     Type old_val = 42;
 109     Type new_val = 24;
 110     Type var = old_val;
 111     EXPECT_TRUE(atomic_compare_exchange_weak((T*)&var, &old_val, new_val,
 112                                              memory_order_relaxed));
 113     EXPECT_FALSE(atomic_compare_exchange_weak((T*)&var, &old_val, new_val,
 114                                               memory_order_relaxed));
 115     EXPECT_EQ(new_val, old_val);
 116   }
 117 }
 118
 119 TEST(SanitizerCommon, AtomicCompareExchangeTest) {
 120   CheckAtomicCompareExchange<atomic_uint8_t>();
 121   CheckAtomicCompareExchange<atomic_uint16_t>();
 122   CheckAtomicCompareExchange<atomic_uint32_t>();
 123   CheckAtomicCompareExchange<atomic_uint64_t>();
 124   CheckAtomicCompareExchange<atomic_uintptr_t>();
 125 }
 126 #endif  //!SANITIZER_ANDROID
 127
 128 }  // namespace __sanitizer