1// Copyright 2010 the V8 project authors. All rights reserved.
2// Redistribution and use in source and binary forms, with or without
3// modification, are permitted provided that the following conditions are
4// met:
5//
6//     * Redistributions of source code must retain the above copyright
7//       notice, this list of conditions and the following disclaimer.
8//     * Redistributions in binary form must reproduce the above
9//       copyright notice, this list of conditions and the following
10//       disclaimer in the documentation and/or other materials provided
11//       with the distribution.
12//     * Neither the name of Google Inc. nor the names of its
13//       contributors may be used to endorse or promote products derived
14//       from this software without specific prior written permission.
15//
16// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
28// This file is an internal atomic implementation, use atomicops.h instead.
29//
30// LinuxKernelCmpxchg and Barrier_AtomicIncrement are from Google Gears.
31
32#ifndef V8_ATOMICOPS_INTERNALS_ARM_GCC_H_
33#define V8_ATOMICOPS_INTERNALS_ARM_GCC_H_
34
35namespace v8 {
36namespace internal {
37
38// 0xffff0fc0 is the hard coded address of a function provided by
39// the kernel which implements an atomic compare-exchange. On older
40// ARM architecture revisions (pre-v6) this may be implemented using
41// a syscall. This address is stable, and in active use (hard coded)
42// by at least glibc-2.7 and the Android C library.
43typedef Atomic32 (*LinuxKernelCmpxchgFunc)(Atomic32 old_value,
44                                           Atomic32 new_value,
45                                           volatile Atomic32* ptr);
46LinuxKernelCmpxchgFunc pLinuxKernelCmpxchg __attribute__((weak)) =
47    (LinuxKernelCmpxchgFunc) 0xffff0fc0;
48
49typedef void (*LinuxKernelMemoryBarrierFunc)(void);
50LinuxKernelMemoryBarrierFunc pLinuxKernelMemoryBarrier __attribute__((weak)) =
51    (LinuxKernelMemoryBarrierFunc) 0xffff0fa0;
52
53
54inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr,
55                                         Atomic32 old_value,
56                                         Atomic32 new_value) {
57  Atomic32 prev_value = *ptr;
58  do {
59    if (!pLinuxKernelCmpxchg(old_value, new_value,
60                             const_cast<Atomic32*>(ptr))) {
61      return old_value;
62    }
63    prev_value = *ptr;
64  } while (prev_value == old_value);
65  return prev_value;
66}
67
68inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr,
69                                         Atomic32 new_value) {
70  Atomic32 old_value;
71  do {
72    old_value = *ptr;
73  } while (pLinuxKernelCmpxchg(old_value, new_value,
74                               const_cast<Atomic32*>(ptr)));
75  return old_value;
76}
77
78inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr,
79                                          Atomic32 increment) {
80  return Barrier_AtomicIncrement(ptr, increment);
81}
82
83inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr,
84                                        Atomic32 increment) {
85  for (;;) {
86    // Atomic exchange the old value with an incremented one.
87    Atomic32 old_value = *ptr;
88    Atomic32 new_value = old_value + increment;
89    if (pLinuxKernelCmpxchg(old_value, new_value,
90                            const_cast<Atomic32*>(ptr)) == 0) {
91      // The exchange took place as expected.
92      return new_value;
93    }
94    // Otherwise, *ptr changed mid-loop and we need to retry.
95  }
96}
97
98inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr,
99                                       Atomic32 old_value,
100                                       Atomic32 new_value) {
101  return NoBarrier_CompareAndSwap(ptr, old_value, new_value);
102}
103
104inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr,
105                                       Atomic32 old_value,
106                                       Atomic32 new_value) {
107  return NoBarrier_CompareAndSwap(ptr, old_value, new_value);
108}
109
110inline void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value) {
111  *ptr = value;
112}
113
114inline void MemoryBarrier() {
115  pLinuxKernelMemoryBarrier();
116}
117
118inline void Acquire_Store(volatile Atomic32* ptr, Atomic32 value) {
119  *ptr = value;
120  MemoryBarrier();
121}
122
123inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) {
124  MemoryBarrier();
125  *ptr = value;
126}
127
128inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) {
129  return *ptr;
130}
131
132inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) {
133  Atomic32 value = *ptr;
134  MemoryBarrier();
135  return value;
136}
137
138inline Atomic32 Release_Load(volatile const Atomic32* ptr) {
139  MemoryBarrier();
140  return *ptr;
141}
142
143} }  // namespace v8::internal
144
145#endif  // V8_ATOMICOPS_INTERNALS_ARM_GCC_H_
146