base/atomicops_internals_x86_macosx.h

   1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // This file is an internal atomic implementation, use base/atomicops.h instead.
   6
   7 #ifndef BASE_ATOMICOPS_INTERNALS_X86_MACOSX_H_
   8 #define BASE_ATOMICOPS_INTERNALS_X86_MACOSX_H_
   9 #pragma once
  10
  11 #include <libkern/OSAtomic.h>
  12
  13 namespace base {
  14 namespace subtle {
  15
  16 inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32 *ptr,
  17                                          Atomic32 old_value,
  18                                          Atomic32 new_value) {
  19   Atomic32 prev_value;
  20   do {
  21     if (OSAtomicCompareAndSwap32(old_value, new_value,
  22                                  const_cast<Atomic32*>(ptr))) {
  23       return old_value;
  24     }
  25     prev_value = *ptr;
  26   } while (prev_value == old_value);
  27   return prev_value;
  28 }
  29
  30 inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32 *ptr,
  31                                          Atomic32 new_value) {
  32   Atomic32 old_value;
  33   do {
  34     old_value = *ptr;
  35   } while (!OSAtomicCompareAndSwap32(old_value, new_value,
  36                                      const_cast<Atomic32*>(ptr)));
  37   return old_value;
  38 }
  39
  40 inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32 *ptr,
  41                                           Atomic32 increment) {
  42   return OSAtomicAdd32(increment, const_cast<Atomic32*>(ptr));
  43 }
  44
  45 inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32 *ptr,
  46                                           Atomic32 increment) {
  47   return OSAtomicAdd32Barrier(increment, const_cast<Atomic32*>(ptr));
  48 }
  49
  50 inline void MemoryBarrier() {
  51   OSMemoryBarrier();
  52 }
  53
  54 inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32 *ptr,
  55                                        Atomic32 old_value,
  56                                        Atomic32 new_value) {
  57   Atomic32 prev_value;
  58   do {
  59     if (OSAtomicCompareAndSwap32Barrier(old_value, new_value,
  60                                         const_cast<Atomic32*>(ptr))) {
  61       return old_value;
  62     }
  63     prev_value = *ptr;
  64   } while (prev_value == old_value);
  65   return prev_value;
  66 }
  67
  68 inline Atomic32 Release_CompareAndSwap(volatile Atomic32 *ptr,
  69                                        Atomic32 old_value,
  70                                        Atomic32 new_value) {
  71   return Acquire_CompareAndSwap(ptr, old_value, new_value);
  72 }
  73
  74 inline void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value) {
  75   *ptr = value;
  76 }
  77
  78 inline void Acquire_Store(volatile Atomic32 *ptr, Atomic32 value) {
  79   *ptr = value;
  80   MemoryBarrier();
  81 }
  82
  83 inline void Release_Store(volatile Atomic32 *ptr, Atomic32 value) {
  84   MemoryBarrier();
  85   *ptr = value;
  86 }
  87
  88 inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) {
  89   return *ptr;
  90 }
  91
  92 inline Atomic32 Acquire_Load(volatile const Atomic32 *ptr) {
  93   Atomic32 value = *ptr;
  94   MemoryBarrier();
  95   return value;
  96 }
  97
  98 inline Atomic32 Release_Load(volatile const Atomic32 *ptr) {
  99   MemoryBarrier();
 100   return *ptr;
 101 }
 102
 103 #ifdef __LP64__
 104
 105 // 64-bit implementation on 64-bit platform
 106
 107 inline Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64 *ptr,
 108                                          Atomic64 old_value,
 109                                          Atomic64 new_value) {
 110   Atomic64 prev_value;
 111   do {
 112     if (OSAtomicCompareAndSwap64(old_value, new_value,
 113                                  reinterpret_cast<volatile int64_t*>(ptr))) {
 114       return old_value;
 115     }
 116     prev_value = *ptr;
 117   } while (prev_value == old_value);
 118   return prev_value;
 119 }
 120
 121 inline Atomic64 NoBarrier_AtomicExchange(volatile Atomic64 *ptr,
 122                                          Atomic64 new_value) {
 123   Atomic64 old_value;
 124   do {
 125     old_value = *ptr;
 126   } while (!OSAtomicCompareAndSwap64(old_value, new_value,
 127                                      reinterpret_cast<volatile int64_t*>(ptr)));
 128   return old_value;
 129 }
 130
 131 inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64 *ptr,
 132                                           Atomic64 increment) {
 133   return OSAtomicAdd64(increment, reinterpret_cast<volatile int64_t*>(ptr));
 134 }
 135
 136 inline Atomic64 Barrier_AtomicIncrement(volatile Atomic64 *ptr,
 137                                         Atomic64 increment) {
 138   return OSAtomicAdd64Barrier(increment,
 139                               reinterpret_cast<volatile int64_t*>(ptr));
 140 }
 141
 142 inline Atomic64 Acquire_CompareAndSwap(volatile Atomic64 *ptr,
 143                                        Atomic64 old_value,
 144                                        Atomic64 new_value) {
 145   Atomic64 prev_value;
 146   do {
 147     if (OSAtomicCompareAndSwap64Barrier(
 148         old_value, new_value, reinterpret_cast<volatile int64_t*>(ptr))) {
 149       return old_value;
 150     }
 151     prev_value = *ptr;
 152   } while (prev_value == old_value);
 153   return prev_value;
 154 }
 155
 156 inline Atomic64 Release_CompareAndSwap(volatile Atomic64 *ptr,
 157                                        Atomic64 old_value,
 158                                        Atomic64 new_value) {
 159   // The lib kern interface does not distinguish between
 160   // Acquire and Release memory barriers; they are equivalent.
 161   return Acquire_CompareAndSwap(ptr, old_value, new_value);
 162 }
 163
 164 inline void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value) {
 165   *ptr = value;
 166 }
 167
 168 inline void Acquire_Store(volatile Atomic64 *ptr, Atomic64 value) {
 169   *ptr = value;
 170   MemoryBarrier();
 171 }
 172
 173 inline void Release_Store(volatile Atomic64 *ptr, Atomic64 value) {
 174   MemoryBarrier();
 175   *ptr = value;
 176 }
 177
 178 inline Atomic64 NoBarrier_Load(volatile const Atomic64* ptr) {
 179   return *ptr;
 180 }
 181
 182 inline Atomic64 Acquire_Load(volatile const Atomic64 *ptr) {
 183   Atomic64 value = *ptr;
 184   MemoryBarrier();
 185   return value;
 186 }
 187
 188 inline Atomic64 Release_Load(volatile const Atomic64 *ptr) {
 189   MemoryBarrier();
 190   return *ptr;
 191 }
 192
 193 #endif  // defined(__LP64__)
 194
 195 }   // namespace base::subtle
 196 }   // namespace base
 197
 198 #endif  // BASE_ATOMICOPS_INTERNALS_X86_MACOSX_H_