1 // Copyright (c) 2006-2008 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.
5 // This file is an internal atomic implementation, use base/atomicops.h instead.
7 #ifndef BASE_ATOMICOPS_INTERNALS_X86_MSVC_H_
8 #define BASE_ATOMICOPS_INTERNALS_X86_MSVC_H_
12 #if defined(ARCH_CPU_64_BITS)
13 // windows.h #defines this (only on x64). This causes problems because the
14 // public API also uses MemoryBarrier at the public name for this fence. So, on
15 // X64, undef it, and call its documented
16 // (http://msdn.microsoft.com/en-us/library/windows/desktop/ms684208.aspx)
17 // implementation directly.
24 inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,
27 LONG result = InterlockedCompareExchange(
28 reinterpret_cast<volatile LONG*>(ptr),
29 static_cast<LONG>(new_value),
30 static_cast<LONG>(old_value));
31 return static_cast<Atomic32>(result);
34 inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr,
36 LONG result = InterlockedExchange(
37 reinterpret_cast<volatile LONG*>(ptr),
38 static_cast<LONG>(new_value));
39 return static_cast<Atomic32>(result);
42 inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr,
44 return InterlockedExchangeAdd(
45 reinterpret_cast<volatile LONG*>(ptr),
46 static_cast<LONG>(increment)) + increment;
49 inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr,
51 return Barrier_AtomicIncrement(ptr, increment);
54 #if !(defined(_MSC_VER) && _MSC_VER >= 1400)
55 #error "We require at least vs2005 for MemoryBarrier"
57 inline void MemoryBarrier() {
58 #if defined(ARCH_CPU_64_BITS)
59 // See #undef and note at the top of this file.
62 // We use MemoryBarrier from WinNT.h
67 inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr,
70 return NoBarrier_CompareAndSwap(ptr, old_value, new_value);
73 inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr,
76 return NoBarrier_CompareAndSwap(ptr, old_value, new_value);
79 inline void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value) {
83 inline void Acquire_Store(volatile Atomic32* ptr, Atomic32 value) {
84 NoBarrier_AtomicExchange(ptr, value);
85 // acts as a barrier in this implementation
88 inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) {
89 *ptr = value; // works w/o barrier for current Intel chips as of June 2005
90 // See comments in Atomic64 version of Release_Store() below.
93 inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) {
97 inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) {
98 Atomic32 value = *ptr;
102 inline Atomic32 Release_Load(volatile const Atomic32* ptr) {
109 // 64-bit low-level operations on 64-bit platform.
111 COMPILE_ASSERT(sizeof(Atomic64) == sizeof(PVOID), atomic_word_is_atomic);
113 inline Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr,
115 Atomic64 new_value) {
116 PVOID result = InterlockedCompareExchangePointer(
117 reinterpret_cast<volatile PVOID*>(ptr),
118 reinterpret_cast<PVOID>(new_value), reinterpret_cast<PVOID>(old_value));
119 return reinterpret_cast<Atomic64>(result);
122 inline Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr,
123 Atomic64 new_value) {
124 PVOID result = InterlockedExchangePointer(
125 reinterpret_cast<volatile PVOID*>(ptr),
126 reinterpret_cast<PVOID>(new_value));
127 return reinterpret_cast<Atomic64>(result);
130 inline Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr,
131 Atomic64 increment) {
132 return InterlockedExchangeAdd64(
133 reinterpret_cast<volatile LONGLONG*>(ptr),
134 static_cast<LONGLONG>(increment)) + increment;
137 inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr,
138 Atomic64 increment) {
139 return Barrier_AtomicIncrement(ptr, increment);
142 inline void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value) {
146 inline void Acquire_Store(volatile Atomic64* ptr, Atomic64 value) {
147 NoBarrier_AtomicExchange(ptr, value);
148 // acts as a barrier in this implementation
151 inline void Release_Store(volatile Atomic64* ptr, Atomic64 value) {
152 *ptr = value; // works w/o barrier for current Intel chips as of June 2005
154 // When new chips come out, check:
155 // IA-32 Intel Architecture Software Developer's Manual, Volume 3:
156 // System Programming Guide, Chatper 7: Multiple-processor management,
157 // Section 7.2, Memory Ordering.
159 // http://developer.intel.com/design/pentium4/manuals/index_new.htm
162 inline Atomic64 NoBarrier_Load(volatile const Atomic64* ptr) {
166 inline Atomic64 Acquire_Load(volatile const Atomic64* ptr) {
167 Atomic64 value = *ptr;
171 inline Atomic64 Release_Load(volatile const Atomic64* ptr) {
176 inline Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr,
178 Atomic64 new_value) {
179 return NoBarrier_CompareAndSwap(ptr, old_value, new_value);
182 inline Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr,
184 Atomic64 new_value) {
185 return NoBarrier_CompareAndSwap(ptr, old_value, new_value);
189 #endif // defined(_WIN64)
191 } // namespace base::subtle
194 #endif // BASE_ATOMICOPS_INTERNALS_X86_MSVC_H_