2 * interlocked functions
4 * Copyright 1996 Alexandre Julliard
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 #include "wine/port.h"
29 __ASM_GLOBAL_FUNC(interlocked_cmpxchg
,
30 "movl 12(%esp),%eax\n\t"
31 "movl 8(%esp),%ecx\n\t"
32 "movl 4(%esp),%edx\n\t"
33 "lock; cmpxchgl %ecx,(%edx)\n\t"
35 __ASM_GLOBAL_FUNC(interlocked_cmpxchg_ptr
,
36 "movl 12(%esp),%eax\n\t"
37 "movl 8(%esp),%ecx\n\t"
38 "movl 4(%esp),%edx\n\t"
39 "lock; cmpxchgl %ecx,(%edx)\n\t"
41 __ASM_GLOBAL_FUNC(interlocked_cmpxchg64
,
43 __ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
44 __ASM_CFI(".cfi_rel_offset %ebx,0\n\t")
46 __ASM_CFI(".cfi_adjust_cfa_offset 4\n\t")
47 __ASM_CFI(".cfi_rel_offset %esi,0\n\t")
48 "movl 12(%esp),%esi\n\t"
49 "movl 16(%esp),%ebx\n\t"
50 "movl 20(%esp),%ecx\n\t"
51 "movl 24(%esp),%eax\n\t"
52 "movl 28(%esp),%edx\n\t"
53 "lock; cmpxchg8b (%esi)\n\t"
55 __ASM_CFI(".cfi_same_value %esi\n\t")
56 __ASM_CFI(".cfi_adjust_cfa_offset -4\n\t")
58 __ASM_CFI(".cfi_same_value %ebx\n\t")
59 __ASM_CFI(".cfi_adjust_cfa_offset -4\n\t")
61 __ASM_GLOBAL_FUNC(interlocked_xchg
,
62 "movl 8(%esp),%eax\n\t"
63 "movl 4(%esp),%edx\n\t"
64 "lock; xchgl %eax,(%edx)\n\t"
66 __ASM_GLOBAL_FUNC(interlocked_xchg_ptr
,
67 "movl 8(%esp),%eax\n\t"
68 "movl 4(%esp),%edx\n\t"
69 "lock; xchgl %eax,(%edx)\n\t"
71 __ASM_GLOBAL_FUNC(interlocked_xchg_add
,
72 "movl 8(%esp),%eax\n\t"
73 "movl 4(%esp),%edx\n\t"
74 "lock; xaddl %eax,(%edx)\n\t"
77 #elif defined(_MSC_VER)
79 __declspec(naked
) int interlocked_cmpxchg( int *dest
, int xchg
, int compare
)
81 __asm mov eax
, 12[esp
];
82 __asm mov ecx
, 8[esp
];
83 __asm mov edx
, 4[esp
];
84 __asm lock cmpxchg
[edx
], ecx
;
88 __declspec(naked
) void *interlocked_cmpxchg_ptr( void **dest
, void *xchg
, void *compare
)
90 __asm mov eax
, 12[esp
];
91 __asm mov ecx
, 8[esp
];
92 __asm mov edx
, 4[esp
];
93 __asm lock cmpxchg
[edx
], ecx
;
97 __declspec(naked
) __int64
interlocked_cmpxchg64( __int64
*dest
, __int64 xchg
, __int64 compare
)
101 __asm mov esi
, 12[esp
];
102 __asm mov ebx
, 16[esp
];
103 __asm mov ecx
, 20[esp
];
104 __asm mov eax
, 24[esp
];
105 __asm mov edx
, 28[esp
];
106 __asm lock cmpxchg8b
[esi
];
112 __declspec(naked
) int interlocked_xchg( int *dest
, int val
)
114 __asm mov eax
, 8[esp
];
115 __asm mov edx
, 4[esp
];
116 __asm lock xchg
[edx
], eax
;
120 __declspec(naked
) void *interlocked_xchg_ptr( void **dest
, void *val
)
122 __asm mov eax
, 8[esp
];
123 __asm mov edx
, 4[esp
];
124 __asm lock xchg
[edx
], eax
;
128 __declspec(naked
) int interlocked_xchg_add( int *dest
, int incr
)
130 __asm mov eax
, 8[esp
];
131 __asm mov edx
, 4[esp
];
132 __asm lock xadd
[edx
], eax
;
137 # error You must implement the interlocked* functions for your compiler
140 #elif defined(__x86_64__)
142 __ASM_GLOBAL_FUNC(interlocked_cmpxchg
,
144 "lock cmpxchgl %esi,(%rdi)\n\t"
146 __ASM_GLOBAL_FUNC(interlocked_cmpxchg_ptr
,
148 "lock cmpxchgq %rsi,(%rdi)\n\t"
150 __ASM_GLOBAL_FUNC(interlocked_cmpxchg64
,
152 "lock cmpxchgq %rsi,(%rdi)\n\t"
154 __ASM_GLOBAL_FUNC(interlocked_xchg
,
156 "lock xchgl %eax, (%rdi)\n\t"
158 __ASM_GLOBAL_FUNC(interlocked_xchg_ptr
,
160 "lock xchgq %rax,(%rdi)\n\t"
162 __ASM_GLOBAL_FUNC(interlocked_xchg_add
,
164 "lock xaddl %eax, (%rdi)\n\t"
166 __ASM_GLOBAL_FUNC(interlocked_cmpxchg128
,
168 ".cfi_adjust_cfa_offset 8\n\t"
169 ".cfi_rel_offset %rbx,0\n\t"
170 "mov %rcx,%r8\n\t" /* compare */
171 "mov %rdx,%rbx\n\t" /* xchg_low */
172 "mov %rsi,%rcx\n\t" /* xchg_high */
173 "mov 0(%r8),%rax\n\t"
174 "mov 8(%r8),%rdx\n\t"
175 "lock cmpxchg16b (%rdi)\n\t"
176 "mov %rax,0(%r8)\n\t"
177 "mov %rdx,8(%r8)\n\t"
180 ".cfi_adjust_cfa_offset -8\n\t"
181 ".cfi_same_value %rbx\n\t"
184 #elif defined(__powerpc__)
185 void* interlocked_cmpxchg_ptr( void **dest
, void* xchg
, void* compare
)
189 __asm__
__volatile__(
197 : "=&r"(ret
), "=&r"(scratch
)
198 : "r"(dest
), "r"(xchg
), "r"(compare
)
203 __int64
interlocked_cmpxchg64( __int64
*dest
, __int64 xchg
, __int64 compare
)
205 /* FIXME: add code */
209 int interlocked_cmpxchg( int *dest
, int xchg
, int compare
)
213 __asm__
__volatile__(
221 : "=&r"(ret
), "=&r"(scratch
)
222 : "r"(dest
), "r"(xchg
), "r"(compare
)
223 : "cr0","memory","r0");
227 int interlocked_xchg_add( int *dest
, int incr
)
231 __asm__
__volatile__(
232 "0: lwarx %0, %3, %1\n"
234 " stwcx. %0, %3, %1\n"
238 : "r"(dest
), "r"(incr
), "r"(zero
)
239 : "cr0", "memory", "r0"
244 int interlocked_xchg( int* dest
, int val
)
247 __asm__
__volatile__(
253 : "r"(dest
), "r"(val
)
254 : "cr0","memory","r0");
258 void* interlocked_xchg_ptr( void** dest
, void* val
)
261 __asm__
__volatile__(
267 : "r"(dest
), "r"(val
)
268 : "cr0","memory","r0");
272 #elif defined(__sparc__) && defined(__sun__)
275 * As the earlier Sparc processors lack necessary atomic instructions,
276 * I'm simply falling back to the library-provided _lwp_mutex routines
277 * to ensure mutual exclusion in a way appropriate for the current
280 * FIXME: If we have the compare-and-swap instruction (Sparc v9 and above)
281 * we could use this to speed up the Interlocked operations ...
284 static lwp_mutex_t interlocked_mutex
= DEFAULTMUTEX
;
286 int interlocked_cmpxchg( int *dest
, int xchg
, int compare
)
288 _lwp_mutex_lock( &interlocked_mutex
);
289 if (*dest
== compare
) *dest
= xchg
;
290 else compare
= *dest
;
291 _lwp_mutex_unlock( &interlocked_mutex
);
295 void *interlocked_cmpxchg_ptr( void **dest
, void *xchg
, void *compare
)
297 _lwp_mutex_lock( &interlocked_mutex
);
298 if (*dest
== compare
) *dest
= xchg
;
299 else compare
= *dest
;
300 _lwp_mutex_unlock( &interlocked_mutex
);
304 __int64
interlocked_cmpxchg64( __int64
*dest
, __int64 xchg
, __int64 compare
)
306 _lwp_mutex_lock( &interlocked_mutex
);
307 if (*dest
== compare
) *dest
= xchg
;
308 else compare
= *dest
;
309 _lwp_mutex_unlock( &interlocked_mutex
);
313 int interlocked_xchg( int *dest
, int val
)
316 _lwp_mutex_lock( &interlocked_mutex
);
319 _lwp_mutex_unlock( &interlocked_mutex
);
323 void *interlocked_xchg_ptr( void **dest
, void *val
)
326 _lwp_mutex_lock( &interlocked_mutex
);
329 _lwp_mutex_unlock( &interlocked_mutex
);
333 int interlocked_xchg_add( int *dest
, int incr
)
336 _lwp_mutex_lock( &interlocked_mutex
);
339 _lwp_mutex_unlock( &interlocked_mutex
);
343 #elif defined(__ALPHA__) && defined(__GNUC__)
345 __ASM_GLOBAL_FUNC(interlocked_cmpxchg
,
347 "ldl_l $0,0($16)\n\t"
348 "cmpeq $0,$18,$1\n\t"
349 "beq $1,L1cmpxchg\n\t"
351 "stl_c $0,0($16)\n\t"
352 "beq $0,L0cmpxchg\n\t"
357 __ASM_GLOBAL_FUNC(interlocked_cmpxchg_ptr
,
359 "ldq_l $0,0($16)\n\t"
360 "cmpeq $0,$18,$1\n\t"
361 "beq $1,L1cmpxchg_ptr\n\t"
363 "stq_c $0,0($16)\n\t"
364 "beq $0,L0cmpxchg_ptr\n\t"
369 __int64
interlocked_cmpxchg64(__int64
*dest
, __int64 xchg
, __int64 compare
)
371 /* FIXME: add code */
375 __ASM_GLOBAL_FUNC(interlocked_xchg
,
377 "ldl_l $0,0($16)\n\t"
379 "stl_c $1,0($16)\n\t"
383 __ASM_GLOBAL_FUNC(interlocked_xchg_ptr
,
385 "ldq_l $0,0($16)\n\t"
387 "stq_c $1,0($16)\n\t"
388 "beq $1,L0xchg_ptr\n\t"
391 __ASM_GLOBAL_FUNC(interlocked_xchg_add
,
393 "ldl_l $0,0($16)\n\t"
395 "stl_c $1,0($16)\n\t"
396 "beq $1,L0xchg_add\n\t"
400 # error You must implement the interlocked* functions for your CPU