OLD | NEW |
1 // Copyright 2010 the V8 project authors. All rights reserved. | 1 // Copyright 2010 the V8 project authors. All rights reserved. |
2 // Redistribution and use in source and binary forms, with or without | 2 // Redistribution and use in source and binary forms, with or without |
3 // modification, are permitted provided that the following conditions are | 3 // modification, are permitted provided that the following conditions are |
4 // met: | 4 // met: |
5 // | 5 // |
6 // * Redistributions of source code must retain the above copyright | 6 // * Redistributions of source code must retain the above copyright |
7 // notice, this list of conditions and the following disclaimer. | 7 // notice, this list of conditions and the following disclaimer. |
8 // * Redistributions in binary form must reproduce the above | 8 // * Redistributions in binary form must reproduce the above |
9 // copyright notice, this list of conditions and the following | 9 // copyright notice, this list of conditions and the following |
10 // disclaimer in the documentation and/or other materials provided | 10 // disclaimer in the documentation and/or other materials provided |
(...skipping 17 matching lines...) Expand all Loading... |
28 // This file is an internal atomic implementation, use atomicops.h instead. | 28 // This file is an internal atomic implementation, use atomicops.h instead. |
29 | 29 |
30 #ifndef V8_ATOMICOPS_INTERNALS_X86_MACOSX_H_ | 30 #ifndef V8_ATOMICOPS_INTERNALS_X86_MACOSX_H_ |
31 #define V8_ATOMICOPS_INTERNALS_X86_MACOSX_H_ | 31 #define V8_ATOMICOPS_INTERNALS_X86_MACOSX_H_ |
32 | 32 |
33 #include <libkern/OSAtomic.h> | 33 #include <libkern/OSAtomic.h> |
34 | 34 |
35 namespace v8 { | 35 namespace v8 { |
36 namespace internal { | 36 namespace internal { |
37 | 37 |
38 inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32 *ptr, | 38 inline Atomic32 NoBarrier_CompareAndSwap(volatile Atomic32* ptr, |
39 Atomic32 old_value, | 39 Atomic32 old_value, |
40 Atomic32 new_value) { | 40 Atomic32 new_value) { |
41 Atomic32 prev_value; | 41 Atomic32 prev_value; |
42 do { | 42 do { |
43 if (OSAtomicCompareAndSwap32(old_value, new_value, | 43 if (OSAtomicCompareAndSwap32(old_value, new_value, |
44 const_cast<Atomic32*>(ptr))) { | 44 const_cast<Atomic32*>(ptr))) { |
45 return old_value; | 45 return old_value; |
46 } | 46 } |
47 prev_value = *ptr; | 47 prev_value = *ptr; |
48 } while (prev_value == old_value); | 48 } while (prev_value == old_value); |
49 return prev_value; | 49 return prev_value; |
50 } | 50 } |
51 | 51 |
52 inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32 *ptr, | 52 inline Atomic32 NoBarrier_AtomicExchange(volatile Atomic32* ptr, |
53 Atomic32 new_value) { | 53 Atomic32 new_value) { |
54 Atomic32 old_value; | 54 Atomic32 old_value; |
55 do { | 55 do { |
56 old_value = *ptr; | 56 old_value = *ptr; |
57 } while (!OSAtomicCompareAndSwap32(old_value, new_value, | 57 } while (!OSAtomicCompareAndSwap32(old_value, new_value, |
58 const_cast<Atomic32*>(ptr))); | 58 const_cast<Atomic32*>(ptr))); |
59 return old_value; | 59 return old_value; |
60 } | 60 } |
61 | 61 |
62 inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32 *ptr, | 62 inline Atomic32 NoBarrier_AtomicIncrement(volatile Atomic32* ptr, |
63 Atomic32 increment) { | 63 Atomic32 increment) { |
64 return OSAtomicAdd32(increment, const_cast<Atomic32*>(ptr)); | 64 return OSAtomicAdd32(increment, const_cast<Atomic32*>(ptr)); |
65 } | 65 } |
66 | 66 |
67 inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32 *ptr, | 67 inline Atomic32 Barrier_AtomicIncrement(volatile Atomic32* ptr, |
68 Atomic32 increment) { | 68 Atomic32 increment) { |
69 return OSAtomicAdd32Barrier(increment, const_cast<Atomic32*>(ptr)); | 69 return OSAtomicAdd32Barrier(increment, const_cast<Atomic32*>(ptr)); |
70 } | 70 } |
71 | 71 |
72 inline void MemoryBarrier() { | 72 inline void MemoryBarrier() { |
73 OSMemoryBarrier(); | 73 OSMemoryBarrier(); |
74 } | 74 } |
75 | 75 |
76 inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32 *ptr, | 76 inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr, |
77 Atomic32 old_value, | 77 Atomic32 old_value, |
78 Atomic32 new_value) { | 78 Atomic32 new_value) { |
79 Atomic32 prev_value; | 79 Atomic32 prev_value; |
80 do { | 80 do { |
81 if (OSAtomicCompareAndSwap32Barrier(old_value, new_value, | 81 if (OSAtomicCompareAndSwap32Barrier(old_value, new_value, |
82 const_cast<Atomic32*>(ptr))) { | 82 const_cast<Atomic32*>(ptr))) { |
83 return old_value; | 83 return old_value; |
84 } | 84 } |
85 prev_value = *ptr; | 85 prev_value = *ptr; |
86 } while (prev_value == old_value); | 86 } while (prev_value == old_value); |
87 return prev_value; | 87 return prev_value; |
88 } | 88 } |
89 | 89 |
90 inline Atomic32 Release_CompareAndSwap(volatile Atomic32 *ptr, | 90 inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr, |
91 Atomic32 old_value, | 91 Atomic32 old_value, |
92 Atomic32 new_value) { | 92 Atomic32 new_value) { |
93 return Acquire_CompareAndSwap(ptr, old_value, new_value); | 93 return Acquire_CompareAndSwap(ptr, old_value, new_value); |
94 } | 94 } |
95 | 95 |
96 inline void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value) { | 96 inline void NoBarrier_Store(volatile Atomic32* ptr, Atomic32 value) { |
97 *ptr = value; | 97 *ptr = value; |
98 } | 98 } |
99 | 99 |
100 inline void Acquire_Store(volatile Atomic32 *ptr, Atomic32 value) { | 100 inline void Acquire_Store(volatile Atomic32* ptr, Atomic32 value) { |
101 *ptr = value; | 101 *ptr = value; |
102 MemoryBarrier(); | 102 MemoryBarrier(); |
103 } | 103 } |
104 | 104 |
105 inline void Release_Store(volatile Atomic32 *ptr, Atomic32 value) { | 105 inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) { |
106 MemoryBarrier(); | 106 MemoryBarrier(); |
107 *ptr = value; | 107 *ptr = value; |
108 } | 108 } |
109 | 109 |
110 inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) { | 110 inline Atomic32 NoBarrier_Load(volatile const Atomic32* ptr) { |
111 return *ptr; | 111 return *ptr; |
112 } | 112 } |
113 | 113 |
114 inline Atomic32 Acquire_Load(volatile const Atomic32 *ptr) { | 114 inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) { |
115 Atomic32 value = *ptr; | 115 Atomic32 value = *ptr; |
116 MemoryBarrier(); | 116 MemoryBarrier(); |
117 return value; | 117 return value; |
118 } | 118 } |
119 | 119 |
120 inline Atomic32 Release_Load(volatile const Atomic32 *ptr) { | 120 inline Atomic32 Release_Load(volatile const Atomic32* ptr) { |
121 MemoryBarrier(); | 121 MemoryBarrier(); |
122 return *ptr; | 122 return *ptr; |
123 } | 123 } |
124 | 124 |
125 #ifdef __LP64__ | 125 #ifdef __LP64__ |
126 | 126 |
127 // 64-bit implementation on 64-bit platform | 127 // 64-bit implementation on 64-bit platform |
128 | 128 |
129 inline Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64 *ptr, | 129 inline Atomic64 NoBarrier_CompareAndSwap(volatile Atomic64* ptr, |
130 Atomic64 old_value, | 130 Atomic64 old_value, |
131 Atomic64 new_value) { | 131 Atomic64 new_value) { |
132 Atomic64 prev_value; | 132 Atomic64 prev_value; |
133 do { | 133 do { |
134 if (OSAtomicCompareAndSwap64(old_value, new_value, | 134 if (OSAtomicCompareAndSwap64(old_value, new_value, |
135 const_cast<Atomic64*>(ptr))) { | 135 const_cast<Atomic64*>(ptr))) { |
136 return old_value; | 136 return old_value; |
137 } | 137 } |
138 prev_value = *ptr; | 138 prev_value = *ptr; |
139 } while (prev_value == old_value); | 139 } while (prev_value == old_value); |
140 return prev_value; | 140 return prev_value; |
141 } | 141 } |
142 | 142 |
143 inline Atomic64 NoBarrier_AtomicExchange(volatile Atomic64 *ptr, | 143 inline Atomic64 NoBarrier_AtomicExchange(volatile Atomic64* ptr, |
144 Atomic64 new_value) { | 144 Atomic64 new_value) { |
145 Atomic64 old_value; | 145 Atomic64 old_value; |
146 do { | 146 do { |
147 old_value = *ptr; | 147 old_value = *ptr; |
148 } while (!OSAtomicCompareAndSwap64(old_value, new_value, | 148 } while (!OSAtomicCompareAndSwap64(old_value, new_value, |
149 const_cast<Atomic64*>(ptr))); | 149 const_cast<Atomic64*>(ptr))); |
150 return old_value; | 150 return old_value; |
151 } | 151 } |
152 | 152 |
153 inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64 *ptr, | 153 inline Atomic64 NoBarrier_AtomicIncrement(volatile Atomic64* ptr, |
154 Atomic64 increment) { | 154 Atomic64 increment) { |
155 return OSAtomicAdd64(increment, const_cast<Atomic64*>(ptr)); | 155 return OSAtomicAdd64(increment, const_cast<Atomic64*>(ptr)); |
156 } | 156 } |
157 | 157 |
158 inline Atomic64 Barrier_AtomicIncrement(volatile Atomic64 *ptr, | 158 inline Atomic64 Barrier_AtomicIncrement(volatile Atomic64* ptr, |
159 Atomic64 increment) { | 159 Atomic64 increment) { |
160 return OSAtomicAdd64Barrier(increment, const_cast<Atomic64*>(ptr)); | 160 return OSAtomicAdd64Barrier(increment, const_cast<Atomic64*>(ptr)); |
161 } | 161 } |
162 | 162 |
163 inline Atomic64 Acquire_CompareAndSwap(volatile Atomic64 *ptr, | 163 inline Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr, |
164 Atomic64 old_value, | 164 Atomic64 old_value, |
165 Atomic64 new_value) { | 165 Atomic64 new_value) { |
166 Atomic64 prev_value; | 166 Atomic64 prev_value; |
167 do { | 167 do { |
168 if (OSAtomicCompareAndSwap64Barrier(old_value, new_value, | 168 if (OSAtomicCompareAndSwap64Barrier(old_value, new_value, |
169 const_cast<Atomic64*>(ptr))) { | 169 const_cast<Atomic64*>(ptr))) { |
170 return old_value; | 170 return old_value; |
171 } | 171 } |
172 prev_value = *ptr; | 172 prev_value = *ptr; |
173 } while (prev_value == old_value); | 173 } while (prev_value == old_value); |
174 return prev_value; | 174 return prev_value; |
175 } | 175 } |
176 | 176 |
177 inline Atomic64 Release_CompareAndSwap(volatile Atomic64 *ptr, | 177 inline Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr, |
178 Atomic64 old_value, | 178 Atomic64 old_value, |
179 Atomic64 new_value) { | 179 Atomic64 new_value) { |
180 // The lib kern interface does not distinguish between | 180 // The lib kern interface does not distinguish between |
181 // Acquire and Release memory barriers; they are equivalent. | 181 // Acquire and Release memory barriers; they are equivalent. |
182 return Acquire_CompareAndSwap(ptr, old_value, new_value); | 182 return Acquire_CompareAndSwap(ptr, old_value, new_value); |
183 } | 183 } |
184 | 184 |
185 inline void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value) { | 185 inline void NoBarrier_Store(volatile Atomic64* ptr, Atomic64 value) { |
186 *ptr = value; | 186 *ptr = value; |
187 } | 187 } |
188 | 188 |
189 inline void Acquire_Store(volatile Atomic64 *ptr, Atomic64 value) { | 189 inline void Acquire_Store(volatile Atomic64* ptr, Atomic64 value) { |
190 *ptr = value; | 190 *ptr = value; |
191 MemoryBarrier(); | 191 MemoryBarrier(); |
192 } | 192 } |
193 | 193 |
194 inline void Release_Store(volatile Atomic64 *ptr, Atomic64 value) { | 194 inline void Release_Store(volatile Atomic64* ptr, Atomic64 value) { |
195 MemoryBarrier(); | 195 MemoryBarrier(); |
196 *ptr = value; | 196 *ptr = value; |
197 } | 197 } |
198 | 198 |
199 inline Atomic64 NoBarrier_Load(volatile const Atomic64* ptr) { | 199 inline Atomic64 NoBarrier_Load(volatile const Atomic64* ptr) { |
200 return *ptr; | 200 return *ptr; |
201 } | 201 } |
202 | 202 |
203 inline Atomic64 Acquire_Load(volatile const Atomic64 *ptr) { | 203 inline Atomic64 Acquire_Load(volatile const Atomic64* ptr) { |
204 Atomic64 value = *ptr; | 204 Atomic64 value = *ptr; |
205 MemoryBarrier(); | 205 MemoryBarrier(); |
206 return value; | 206 return value; |
207 } | 207 } |
208 | 208 |
209 inline Atomic64 Release_Load(volatile const Atomic64 *ptr) { | 209 inline Atomic64 Release_Load(volatile const Atomic64* ptr) { |
210 MemoryBarrier(); | 210 MemoryBarrier(); |
211 return *ptr; | 211 return *ptr; |
212 } | 212 } |
213 | 213 |
214 #endif // defined(__LP64__) | 214 #endif // defined(__LP64__) |
215 | 215 |
216 // MacOS uses long for intptr_t, AtomicWord and Atomic32 are always different | 216 // MacOS uses long for intptr_t, AtomicWord and Atomic32 are always different |
217 // on the Mac, even when they are the same size. We need to explicitly cast | 217 // on the Mac, even when they are the same size. We need to explicitly cast |
218 // from AtomicWord to Atomic32/64 to implement the AtomicWord interface. | 218 // from AtomicWord to Atomic32/64 to implement the AtomicWord interface. |
219 #ifdef __LP64__ | 219 #ifdef __LP64__ |
(...skipping 37 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
257 } | 257 } |
258 | 258 |
259 inline AtomicWord Release_CompareAndSwap(volatile AtomicWord* ptr, | 259 inline AtomicWord Release_CompareAndSwap(volatile AtomicWord* ptr, |
260 AtomicWord old_value, | 260 AtomicWord old_value, |
261 AtomicWord new_value) { | 261 AtomicWord new_value) { |
262 return v8::internal::Release_CompareAndSwap( | 262 return v8::internal::Release_CompareAndSwap( |
263 reinterpret_cast<volatile AtomicWordCastType*>(ptr), | 263 reinterpret_cast<volatile AtomicWordCastType*>(ptr), |
264 old_value, new_value); | 264 old_value, new_value); |
265 } | 265 } |
266 | 266 |
267 inline void NoBarrier_Store(volatile AtomicWord *ptr, AtomicWord value) { | 267 inline void NoBarrier_Store(volatile AtomicWord* ptr, AtomicWord value) { |
268 NoBarrier_Store( | 268 NoBarrier_Store( |
269 reinterpret_cast<volatile AtomicWordCastType*>(ptr), value); | 269 reinterpret_cast<volatile AtomicWordCastType*>(ptr), value); |
270 } | 270 } |
271 | 271 |
272 inline void Acquire_Store(volatile AtomicWord* ptr, AtomicWord value) { | 272 inline void Acquire_Store(volatile AtomicWord* ptr, AtomicWord value) { |
273 return v8::internal::Acquire_Store( | 273 return v8::internal::Acquire_Store( |
274 reinterpret_cast<volatile AtomicWordCastType*>(ptr), value); | 274 reinterpret_cast<volatile AtomicWordCastType*>(ptr), value); |
275 } | 275 } |
276 | 276 |
277 inline void Release_Store(volatile AtomicWord* ptr, AtomicWord value) { | 277 inline void Release_Store(volatile AtomicWord* ptr, AtomicWord value) { |
278 return v8::internal::Release_Store( | 278 return v8::internal::Release_Store( |
279 reinterpret_cast<volatile AtomicWordCastType*>(ptr), value); | 279 reinterpret_cast<volatile AtomicWordCastType*>(ptr), value); |
280 } | 280 } |
281 | 281 |
282 inline AtomicWord NoBarrier_Load(volatile const AtomicWord *ptr) { | 282 inline AtomicWord NoBarrier_Load(volatile const AtomicWord* ptr) { |
283 return NoBarrier_Load( | 283 return NoBarrier_Load( |
284 reinterpret_cast<volatile const AtomicWordCastType*>(ptr)); | 284 reinterpret_cast<volatile const AtomicWordCastType*>(ptr)); |
285 } | 285 } |
286 | 286 |
287 inline AtomicWord Acquire_Load(volatile const AtomicWord* ptr) { | 287 inline AtomicWord Acquire_Load(volatile const AtomicWord* ptr) { |
288 return v8::internal::Acquire_Load( | 288 return v8::internal::Acquire_Load( |
289 reinterpret_cast<volatile const AtomicWordCastType*>(ptr)); | 289 reinterpret_cast<volatile const AtomicWordCastType*>(ptr)); |
290 } | 290 } |
291 | 291 |
292 inline AtomicWord Release_Load(volatile const AtomicWord* ptr) { | 292 inline AtomicWord Release_Load(volatile const AtomicWord* ptr) { |
293 return v8::internal::Release_Load( | 293 return v8::internal::Release_Load( |
294 reinterpret_cast<volatile const AtomicWordCastType*>(ptr)); | 294 reinterpret_cast<volatile const AtomicWordCastType*>(ptr)); |
295 } | 295 } |
296 | 296 |
297 #undef AtomicWordCastType | 297 #undef AtomicWordCastType |
298 | 298 |
299 } } // namespace v8::internal | 299 } } // namespace v8::internal |
300 | 300 |
301 #endif // V8_ATOMICOPS_INTERNALS_X86_MACOSX_H_ | 301 #endif // V8_ATOMICOPS_INTERNALS_X86_MACOSX_H_ |
OLD | NEW |