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