Use the intrinsic version of the Interlocked* functions.

base/atomicops_internals_x86_msvc.h

 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // This file is an internal atomic implementation, use base/atomicops.h instead.
 
 #ifndef BASE_ATOMICOPS_INTERNALS_X86_MSVC_H_
 #define BASE_ATOMICOPS_INTERNALS_X86_MSVC_H_
 
 #include <windows.h>
 
+#include <intrin.h>
+
 #include "base/macros.h"
 
 #if defined(ARCH_CPU_64_BITS)
 // windows.h #defines this (only on x64). This causes problems because the
 // public API also uses MemoryBarrier at the public name for this fence. So, on
 // X64, undef it, and call its documented
 // (http://msdn.microsoft.com/en-us/library/windows/desktop/ms684208.aspx)
 // implementation directly.
 #undef MemoryBarrier
 #endif
 
 namespace base {
 namespace subtle {
 
+#if defined(_M_X64)
+#pragma intrinsic(_InterlockedCompareExchange)

[Sigurður Ásgeirsson, 2014/06/03 15:03:08]

Stupid question, but why do you need to declare the intrinsics like this. Won't
<intrin.h> do that for you?

[Sébastien Marchand, 2014/06/03 19:58:45]

I don't need to, I've looked at 'sandbox/win/src/sandbox_nt_util.h' as an
example but I think that the code in this file could be cleaned too...

+#pragma intrinsic(_InterlockedExchange)
+#pragma intrinsic(_InterlockedExchangeAdd)
+
+#elif defined(_M_IX86)
+extern "C" long _InterlockedCompareExchange(long volatile* destination,
+                                            long exchange, long comperand);
+#pragma intrinsic(_InterlockedCompareExchange)
+
+extern "C" long _InterlockedExchange(long volatile* destination, long exchange);
+#pragma intrinsic(_InterlockedExchange)
+
+extern "C" long _InterlockedExchangeAdd(long volatile* destination,
+                                        long increment);
+#pragma intrinsic(_InterlockedExchangeAdd)
+
+#else
+#error Architecture not supported.
+
+#endif
+
 inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,
                                          Atomic32 old_value,
                                          Atomic32 new_value) {
-  LONG result = InterlockedCompareExchange(
+  LONG result = _InterlockedCompareExchange(

[Sigurður Ásgeirsson, 2014/06/03 15:03:08]

maybe a one-line comment that Interlocked* doesn't resolve to intrinsics on x86?

[Sébastien Marchand, 2014/06/03 19:58:45]

Done.

       reinterpret_cast<volatile LONG*>(ptr),
       static_cast<LONG>(new_value),
       static_cast<LONG>(old_value));
   return static_cast<Atomic32>(result);
 }
 
 inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr,
                                          Atomic32 new_value) {
-  LONG result = InterlockedExchange(
+  LONG result = _InterlockedExchange(
       reinterpret_cast<volatile LONG*>(ptr),
       static_cast<LONG>(new_value));
   return static_cast<Atomic32>(result);
 }
 
 inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr,
                                         Atomic32 increment) {
-  return InterlockedExchangeAdd(
+  return _InterlockedExchangeAdd(
       reinterpret_cast<volatile LONG*>(ptr),
       static_cast<LONG>(increment)) + increment;
 }
 
 inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr,
                                           Atomic32 increment) {
   return Barrier_AtomicIncrement(ptr, increment);
 }
 
 #if !(defined(_MSC_VER) && _MSC_VER >= 1400)
@@ skipping 130 matching lines @@
   return NoBarrier_CompareAndSwap(ptr, old_value, new_value);
 }
 
 
 #endif  // defined(_WIN64)
 
 }  // namespace base::subtle
 }  // namespace base
 
 #endif  // BASE_ATOMICOPS_INTERNALS_X86_MSVC_H_