src/base/atomicops_internals_portable.h

   1 // Copyright 2012 the V8 project 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 atomicops.h instead.
   6
   7 #ifndef V8_BASE_ATOMICOPS_INTERNALS_PORTABLE_H_
   8 #define V8_BASE_ATOMICOPS_INTERNALS_PORTABLE_H_
   9
  10 namespace v8 {
  11 namespace base {
  12
  13 inline void MemoryBarrier() { __sync_synchronize(); }
  14
  15 inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,
  16                                          Atomic32 old_value,
  17                                          Atomic32 new_value) {
  18   return __sync_val_compare_and_swap(ptr, old_value, new_value);
  19 }
  20
  21 inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr,
  22                                          Atomic32 new_value) {
  23   return __sync_lock_test_and_set(ptr, new_value);
  24 }
  25
  26 inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr,
  27                                           Atomic32 increment) {
  28   return __sync_add_and_fetch(ptr, increment);
  29 }
  30
  31 inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr,
  32                                         Atomic32 increment) {
  33   return __sync_add_and_fetch(ptr, increment);
  34 }
  35
  36 inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr,
  37                                        Atomic32 old_value, Atomic32 new_value) {
  38   return __sync_val_compare_and_swap(ptr, old_value, new_value);
  39 }
  40
  41 inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr,
  42                                        Atomic32 old_value, Atomic32 new_value) {
  43   return __sync_val_compare_and_swap(ptr, old_value, new_value);
  44 }
  45
  46 inline void NoBarrier_Store(volatile Atomic8* ptr, Atomic8 value) {
  47   __sync_lock_test_and_set(ptr, value);
  48 }
  49
  50 inline void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value) {
  51   __sync_lock_test_and_set(ptr, value);
  52 }
  53
  54 inline void Acquire_Store(volatile Atomic32* ptr, Atomic32 value) {
  55   __sync_lock_test_and_set(ptr, value);
  56 }
  57
  58 inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) {
  59   __sync_lock_test_and_set(ptr, value);
  60 }
  61
  62 inline Atomic8 NoBarrier_Load(volatile const Atomic8* ptr) {
  63   return __sync_add_and_fetch(ptr, 0);
  64 }
  65
  66 inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) {
  67   return __sync_add_and_fetch(ptr, 0);
  68 }
  69
  70 inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) {
  71   return __sync_add_and_fetch(ptr, 0);
  72 }
  73
  74 inline Atomic32 Release_Load(volatile const Atomic32* ptr) {
  75   return __sync_add_and_fetch(ptr, 0);
  76 }
  77
  78 // 64-bit versions of the operations.
  79 // See the 32-bit versions for comments.
  80
  81 inline Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr,
  82                                          Atomic64 old_value,
  83                                          Atomic64 new_value) {
  84   return __sync_val_compare_and_swap(ptr, old_value, new_value);
  85 }
  86
  87 inline Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr,
  88                                          Atomic64 new_value) {
  89   return __sync_lock_test_and_set(ptr, new_value);
  90 }
  91
  92 inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr,
  93                                           Atomic64 increment) {
  94   return __sync_add_and_fetch(ptr, increment);
  95 }
  96
  97 inline Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr,
  98                                         Atomic64 increment) {
  99   return __sync_add_and_fetch(ptr, increment);
 100 }
 101
 102 inline Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr,
 103                                        Atomic64 old_value, Atomic64 new_value) {
 104   return __sync_val_compare_and_swap(ptr, old_value, new_value);
 105 }
 106
 107 inline Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr,
 108                                        Atomic64 old_value, Atomic64 new_value) {
 109   return __sync_val_compare_and_swap(ptr, old_value, new_value);
 110 }
 111
 112 inline void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value) {
 113   __sync_lock_test_and_set(ptr, value);
 114 }
 115
 116 inline void Acquire_Store(volatile Atomic64* ptr, Atomic64 value) {
 117   __sync_lock_test_and_set(ptr, value);
 118 }
 119
 120 inline void Release_Store(volatile Atomic64* ptr, Atomic64 value) {
 121   __sync_lock_test_and_set(ptr, value);
 122 }
 123
 124 inline Atomic64 NoBarrier_Load(volatile const Atomic64* ptr) {
 125   return __sync_add_and_fetch(ptr, 0);
 126 }
 127
 128 inline Atomic64 Acquire_Load(volatile const Atomic64* ptr) {
 129   return __sync_add_and_fetch(ptr, 0);
 130 }
 131
 132 inline Atomic64 Release_Load(volatile const Atomic64* ptr) {
 133   return __sync_add_and_fetch(ptr, 0);
 134 }
 135 }
 136 }  // namespace v8::base
 137
 138 #endif  // V8_BASE_ATOMICOPS_INTERNALS_PORTABLE_H_