src/v8/src/atomicops_internals_atomicword_compat.h

   1 // Copyright 2014 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_ATOMICOPS_INTERNALS_ATOMICWORD_COMPAT_H_
   8 #define V8_ATOMICOPS_INTERNALS_ATOMICWORD_COMPAT_H_
   9
  10 // AtomicWord is a synonym for intptr_t, and Atomic32 is a synonym for int32,
  11 // which in turn means int. On some LP32 platforms, intptr_t is an int, but
  12 // on others, it's a long. When AtomicWord and Atomic32 are based on different
  13 // fundamental types, their pointers are incompatible.
  14 //
  15 // This file defines function overloads to allow both AtomicWord and Atomic32
  16 // data to be used with this interface.
  17 //
  18 // On LP64 platforms, AtomicWord and Atomic64 are both always long,
  19 // so this problem doesn't occur.
  20
  21 #if !defined(V8_HOST_ARCH_64_BIT)
  22
  23 namespace v8 {
  24 namespace internal {
  25
  26 inline AtomicWord NoBarrier_CompareAndSwap(volatile AtomicWord* ptr,
  27                                            AtomicWord old_value,
  28                                            AtomicWord new_value) {
  29   return NoBarrier_CompareAndSwap(
  30       reinterpret_cast<volatile Atomic32*>(ptr), old_value, new_value);
  31 }
  32
  33 inline AtomicWord NoBarrier_AtomicExchange(volatile AtomicWord* ptr,
  34                                            AtomicWord new_value) {
  35   return NoBarrier_AtomicExchange(
  36       reinterpret_cast<volatile Atomic32*>(ptr), new_value);
  37 }
  38
  39 inline AtomicWord NoBarrier_AtomicIncrement(volatile AtomicWord* ptr,
  40                                             AtomicWord increment) {
  41   return NoBarrier_AtomicIncrement(
  42       reinterpret_cast<volatile Atomic32*>(ptr), increment);
  43 }
  44
  45 inline AtomicWord Barrier_AtomicIncrement(volatile AtomicWord* ptr,
  46                                           AtomicWord increment) {
  47   return Barrier_AtomicIncrement(
  48       reinterpret_cast<volatile Atomic32*>(ptr), increment);
  49 }
  50
  51 inline AtomicWord Acquire_CompareAndSwap(volatile AtomicWord* ptr,
  52                                          AtomicWord old_value,
  53                                          AtomicWord new_value) {
  54   return v8::internal::Acquire_CompareAndSwap(
  55       reinterpret_cast<volatile Atomic32*>(ptr), old_value, new_value);
  56 }
  57
  58 inline AtomicWord Release_CompareAndSwap(volatile AtomicWord* ptr,
  59                                          AtomicWord old_value,
  60                                          AtomicWord new_value) {
  61   return v8::internal::Release_CompareAndSwap(
  62       reinterpret_cast<volatile Atomic32*>(ptr), old_value, new_value);
  63 }
  64
  65 inline void NoBarrier_Store(volatile AtomicWord *ptr, AtomicWord value) {
  66   NoBarrier_Store(
  67       reinterpret_cast<volatile Atomic32*>(ptr), value);
  68 }
  69
  70 inline void Acquire_Store(volatile AtomicWord* ptr, AtomicWord value) {
  71   return v8::internal::Acquire_Store(
  72       reinterpret_cast<volatile Atomic32*>(ptr), value);
  73 }
  74
  75 inline void Release_Store(volatile AtomicWord* ptr, AtomicWord value) {
  76   return v8::internal::Release_Store(
  77       reinterpret_cast<volatile Atomic32*>(ptr), value);
  78 }
  79
  80 inline AtomicWord NoBarrier_Load(volatile const AtomicWord *ptr) {
  81   return NoBarrier_Load(
  82       reinterpret_cast<volatile const Atomic32*>(ptr));
  83 }
  84
  85 inline AtomicWord Acquire_Load(volatile const AtomicWord* ptr) {
  86   return v8::internal::Acquire_Load(
  87       reinterpret_cast<volatile const Atomic32*>(ptr));
  88 }
  89
  90 inline AtomicWord Release_Load(volatile const AtomicWord* ptr) {
  91   return v8::internal::Release_Load(
  92       reinterpret_cast<volatile const Atomic32*>(ptr));
  93 }
  94
  95 } }  // namespace v8::internal
  96
  97 #endif  // !defined(V8_HOST_ARCH_64_BIT)
  98
  99 #endif  // V8_ATOMICOPS_INTERNALS_ATOMICWORD_COMPAT_H_