Tweak atomicops implementation for Mac OS X to compile correctly when __LP64_...

base/atomicops_internals_x86_macosx.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_MACOSX_H_
 #define BASE_ATOMICOPS_INTERNALS_X86_MACOSX_H_
 #pragma once
 
@@ skipping 92 matching lines @@
 #ifdef __LP64__
 
 // 64-bit implementation on 64-bit platform
 
 inline Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64 *ptr,
                                          Atomic64 old_value,
                                          Atomic64 new_value) {
   Atomic64 prev_value;
   do {
     if (OSAtomicCompareAndSwap64(old_value, new_value,
-                                 const_cast<Atomic64*>(ptr))) {
+                                 reinterpret_cast<volatile int64_t*>(ptr))) {
       return old_value;
     }
     prev_value = *ptr;
   } while (prev_value == old_value);
   return prev_value;
 }
 
 inline Atomic64 NoBarrier_AtomicExchange(volatile Atomic64 *ptr,
                                          Atomic64 new_value) {
   Atomic64 old_value;
   do {
     old_value = *ptr;
   } while (!OSAtomicCompareAndSwap64(old_value, new_value,
-                                     const_cast<Atomic64*>(ptr)));
+                                     reinterpret_cast<volatile int64_t*>(ptr)));
   return old_value;
 }
 
 inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64 *ptr,
                                           Atomic64 increment) {
-  return OSAtomicAdd64(increment, const_cast<Atomic64*>(ptr));
+  return OSAtomicAdd64(increment, reinterpret_cast<volatile int64_t*>(ptr));
 }
 
 inline Atomic64 Barrier_AtomicIncrement(volatile Atomic64 *ptr,
                                         Atomic64 increment) {
-  return OSAtomicAdd64Barrier(increment, const_cast<Atomic64*>(ptr));
+  return OSAtomicAdd64Barrier(increment,
+                              reinterpret_cast<volatile int64_t*>(ptr));
 }
 
 inline Atomic64 Acquire_CompareAndSwap(volatile Atomic64 *ptr,
                                        Atomic64 old_value,
                                        Atomic64 new_value) {
   Atomic64 prev_value;
   do {
     if (OSAtomicCompareAndSwap64Barrier(old_value, new_value,
-                                        const_cast<Atomic64*>(ptr))) {
+                              reinterpret_cast<volatile int64_t*>(ptr))) {
       return old_value;
     }
     prev_value = *ptr;
   } while (prev_value == old_value);
   return prev_value;
 }
 
 inline Atomic64 Release_CompareAndSwap(volatile Atomic64 *ptr,
                                        Atomic64 old_value,
                                        Atomic64 new_value) {
@@ skipping 28 matching lines @@
 
 inline Atomic64 Release_Load(volatile const Atomic64 *ptr) {
   MemoryBarrier();
   return *ptr;
 }
 
 #endif  // defined(__LP64__)
 
 // MacOS uses long for intptr_t, AtomicWord and Atomic32 are always different
 // on the Mac, even when they are the same size.  We need to explicitly cast
-// from AtomicWord to Atomic32/64 to implement the AtomicWord interface.
-#ifdef __LP64__
-#define AtomicWordCastType Atomic64
-#else
+// from AtomicWord to Atomic32 to implement the AtomicWord interface.
+// When in 64-bit mode, AtomicWord is the same as Atomic64, so we need not
+// add duplicate definitions.
+#ifndef __LP64__
 #define AtomicWordCastType Atomic32
-#endif
 
 inline AtomicWord NoBarrier_CompareAndSwap(volatile AtomicWord* ptr,
                                            AtomicWord old_value,
                                            AtomicWord new_value) {
   return NoBarrier_CompareAndSwap(
       reinterpret_cast<volatile AtomicWordCastType*>(ptr),
       old_value, new_value);
 }
 
 inline AtomicWord NoBarrier_AtomicExchange(volatile AtomicWord* ptr,
@@ skipping 54 matching lines @@
   return base::subtle::Acquire_Load(
       reinterpret_cast<volatile const AtomicWordCastType*>(ptr));
 }
 
 inline AtomicWord Release_Load(volatile const AtomicWord* ptr) {
   return base::subtle::Release_Load(
       reinterpret_cast<volatile const AtomicWordCastType*>(ptr));
 }
 
 #undef AtomicWordCastType
+#endif
 
 }   // namespace base::subtle
 }   // namespace base
 
 #endif  // BASE_ATOMICOPS_INTERNALS_X86_MACOSX_H_