1
2 /* This is an example of a program which does atomic memory operations
3 between two processes which share a page. Valgrind 3.4.1 and
4 earlier produce incorrect answers because it does not preserve
5 atomicity of the relevant instructions in the generated code; but
6 the post-DCAS-merge versions of Valgrind do behave correctly. */
7
8 /* On ARM, this can be compiled into either ARM or Thumb code, so as
9 to test both A and T encodings of LDREX/STREX et al. Also on ARM,
10 it tests doubleword atomics (LDREXD, STREXD) which I don't think it
11 does on any other platform. */
12
13 #include <stdlib.h>
14 #include <stdio.h>
15 #include <string.h>
16 #include <assert.h>
17 #include <unistd.h>
18 #include <sys/wait.h>
19 #include "tests/sys_mman.h"
20
21 #define NNN 3456987
22
23 #define IS_8_ALIGNED(_ptr) (0 == (((unsigned long)(_ptr)) & 7))
24
25
atomic_add_8bit(char * p,int n)26 __attribute__((noinline)) void atomic_add_8bit ( char* p, int n )
27 {
28 #if defined(VGA_x86)
29 unsigned long block[2];
30 block[0] = (unsigned long)p;
31 block[1] = n;
32 __asm__ __volatile__(
33 "movl 0(%%esi),%%eax" "\n\t"
34 "movl 4(%%esi),%%ebx" "\n\t"
35 "lock; addb %%bl,(%%eax)" "\n"
36 : : "S"(&block[0])/* S means "esi only" */ : "memory","cc","eax","ebx"
37 );
38 #elif defined(VGA_amd64)
39 unsigned long block[2];
40 block[0] = (unsigned long)p;
41 block[1] = n;
42 __asm__ __volatile__(
43 "movq 0(%%rsi),%%rax" "\n\t"
44 "movq 8(%%rsi),%%rbx" "\n\t"
45 "lock; addb %%bl,(%%rax)" "\n"
46 : : "S"(&block[0])/* S means "rsi only" */ : "memory","cc","rax","rbx"
47 );
48 #elif defined(VGA_ppc32)
49 /* Nasty hack. Does correctly atomically do *p += n, but only if p
50 is 4-aligned -- guaranteed by caller. */
51 unsigned long success;
52 do {
53 __asm__ __volatile__(
54 "lwarx 15,0,%1" "\n\t"
55 "add 15,15,%2" "\n\t"
56 "stwcx. 15,0,%1" "\n\t"
57 "mfcr %0" "\n\t"
58 "srwi %0,%0,29" "\n\t"
59 "andi. %0,%0,1" "\n"
60 : /*out*/"=b"(success)
61 : /*in*/ "b"(p), "b"(((unsigned long)n) << 24)
62 : /*trash*/ "memory", "cc", "r15"
63 );
64 } while (success != 1);
65 #elif defined(VGA_ppc64be)
66 /* Nasty hack. Does correctly atomically do *p += n, but only if p
67 is 8-aligned -- guaranteed by caller. */
68 unsigned long success;
69 do {
70 __asm__ __volatile__(
71 "ldarx 15,0,%1" "\n\t"
72 "add 15,15,%2" "\n\t"
73 "stdcx. 15,0,%1" "\n\t"
74 "mfcr %0" "\n\t"
75 "srwi %0,%0,29" "\n\t"
76 "andi. %0,%0,1" "\n"
77 : /*out*/"=b"(success)
78 : /*in*/ "b"(p), "b"(((unsigned long)n) << 56)
79 : /*trash*/ "memory", "cc", "r15"
80 );
81 } while (success != 1);
82 #elif defined(VGA_ppc64le)
83 /* Nasty hack. Does correctly atomically do *p += n, but only if p
84 is 8-aligned -- guaranteed by caller. */
85 unsigned long success;
86 do {
87 __asm__ __volatile__(
88 "ldarx 15,0,%1" "\n\t"
89 "add 15,15,%2" "\n\t"
90 "stdcx. 15,0,%1" "\n\t"
91 "mfcr %0" "\n\t"
92 "srwi %0,%0,29" "\n\t"
93 "andi. %0,%0,1" "\n"
94 : /*out*/"=b"(success)
95 : /*in*/ "b"(p), "b"(((unsigned long)n))
96 : /*trash*/ "memory", "cc", "r15"
97 );
98 } while (success != 1);
99 #elif defined(VGA_arm)
100 unsigned int block[3]
101 = { (unsigned int)p, (unsigned int)n, 0xFFFFFFFF };
102 do {
103 __asm__ __volatile__(
104 "mov r5, %0" "\n\t"
105 "ldr r9, [r5, #0]" "\n\t" // p
106 "ldr r10, [r5, #4]" "\n\t" // n
107 "ldrexb r8, [r9]" "\n\t"
108 "add r8, r8, r10" "\n\t"
109 "strexb r4, r8, [r9]" "\n\t"
110 "str r4, [r5, #8]" "\n\t"
111 : /*out*/
112 : /*in*/ "r"(&block[0])
113 : /*trash*/ "memory", "cc", "r5", "r8", "r9", "r10", "r4"
114 );
115 } while (block[2] != 0);
116 #elif defined(VGA_arm64)
117 unsigned long long int block[3]
118 = { (unsigned long long int)p, (unsigned long long int)n,
119 0xFFFFFFFFFFFFFFFFULL};
120 do {
121 __asm__ __volatile__(
122 "mov x5, %0" "\n\t"
123 "ldr x9, [x5, #0]" "\n\t" // p
124 "ldr x10, [x5, #8]" "\n\t" // n
125 "ldxrb w8, [x9]" "\n\t"
126 "add x8, x8, x10" "\n\t"
127 "stxrb w4, w8, [x9]" "\n\t"
128 "str x4, [x5, #16]" "\n\t"
129 : /*out*/
130 : /*in*/ "r"(&block[0])
131 : /*trash*/ "memory", "cc", "x5", "x8", "x9", "x10", "x4"
132 );
133 } while (block[2] != 0);
134 #elif defined(VGA_s390x)
135 int dummy;
136 __asm__ __volatile__(
137 " l 0,%0\n\t"
138 "0: st 0,%1\n\t"
139 " icm 1,1,%1\n\t"
140 " ar 1,%2\n\t"
141 " stcm 1,1,%1\n\t"
142 " l 1,%1\n\t"
143 " cs 0,1,%0\n\t"
144 " jl 0b\n\t"
145 : "+m" (*p), "+m" (dummy)
146 : "d" (n)
147 : "cc", "memory", "0", "1");
148 #elif defined(VGA_mips32)
149 /* We rely on the fact that p is 4-aligned. Otherwise 'll' may throw an
150 exception that can cause this function to fail. */
151 #if defined (_MIPSEL)
152 unsigned int block[3]
153 = { (unsigned int)p, (unsigned int)n, 0x0 };
154 do {
155 __asm__ __volatile__(
156 "move $t0, %0" "\n\t"
157 "lw $t1, 0($t0)" "\n\t" // p
158 "lw $t2, 4($t0)" "\n\t" // n
159 "andi $t2, $t2, 0xFF" "\n\t" // n = n and 0xFF
160 "li $t4, 0xFF" "\n\t"
161 "nor $t4, $t4, $zero" "\n\t" // $t4 = 0xFFFFFF00
162 "ll $t3, 0($t1)" "\n\t" // $t3 = old value
163 "and $t4, $t4, $t3" "\n\t" // $t4 = $t3 and 0xFFFFFF00
164 "addu $t3, $t3, $t2" "\n\t" // $t3 = $t3 + n
165 "andi $t3, $t3, 0xFF" "\n\t" // $t3 = $t3 and 0xFF
166 "or $t3, $t3, $t4" "\n\t" // $t3 = $t3 or $t4
167 "sc $t3, 0($t1)" "\n\t"
168 "sw $t3, 8($t0)" "\n\t" // save result
169 : /*out*/
170 : /*in*/ "r"(&block[0])
171 : /*trash*/ "memory", "t0", "t1", "t2", "t3", "t4"
172 );
173 } while (block[2] != 1);
174 #elif defined (_MIPSEB)
175 unsigned int block[3]
176 = { (unsigned int)p, (unsigned int)n << 24, 0x0 };
177 do {
178 __asm__ __volatile__(
179 "move $t0, %0" "\n\t"
180 "lw $t1, 0($t0)" "\n\t" // p
181 "lw $t2, 4($t0)" "\n\t" // n
182 "ll $t3, 0($t1)" "\n\t"
183 "addu $t3, $t3, $t2" "\n\t"
184 "sc $t3, 0($t1)" "\n\t"
185 "sw $t3, 8($t0)" "\n\t"
186 : /*out*/
187 : /*in*/ "r"(&block[0])
188 : /*trash*/ "memory", "t0", "t1", "t2", "t3"
189 );
190 } while (block[2] != 1);
191 #endif
192 #elif defined(VGA_mips64)
193 /* We rely on the fact that p is 4-aligned. Otherwise 'll' may throw an
194 exception that can cause this function to fail. */
195 #if defined (_MIPSEL)
196 unsigned long block[3]
197 = { (unsigned long)p, (unsigned long)n, 0x0ULL };
198 do {
199 __asm__ __volatile__(
200 "move $t0, %0" "\n\t"
201 "ld $t1, 0($t0)" "\n\t" // p
202 "ld $t2, 8($t0)" "\n\t" // n
203 "andi $t2, $t2, 0xFF" "\n\t" // n = n and 0xFF
204 "li $s0, 0xFF" "\n\t"
205 "nor $s0, $s0, $zero" "\n\t" // $s0 = 0xFFFFFF00
206 "ll $t3, 0($t1)" "\n\t" // $t3 = old value
207 "and $s0, $s0, $t3" "\n\t" // $s0 = $t3 and 0xFFFFFF00
208 "addu $t3, $t3, $t2" "\n\t" // $t3 = $t3 + n
209 "andi $t3, $t3, 0xFF" "\n\t" // $t3 = $t3 and 0xFF
210 "or $t3, $t3, $s0" "\n\t" // $t3 = $t3 or $s0
211 "sc $t3, 0($t1)" "\n\t"
212 "sw $t3, 16($t0)" "\n\t" // save result
213 : /*out*/
214 : /*in*/ "r"(&block[0])
215 : /*trash*/ "memory", "t0", "t1", "t2", "t3", "s0"
216 );
217 } while (block[2] != 1);
218 #elif defined (_MIPSEB)
219 unsigned long block[3]
220 = { (unsigned long)p, (unsigned long)n << 56, 0x0 };
221 do {
222 __asm__ __volatile__(
223 "move $t0, %0" "\n\t"
224 "ld $t1, 0($t0)" "\n\t" // p
225 "ld $t2, 8($t0)" "\n\t" // n
226 "lld $t3, 0($t1)" "\n\t"
227 "daddu $t3, $t3, $t2" "\n\t"
228 "scd $t3, 0($t1)" "\n\t"
229 "sd $t3, 16($t0)" "\n\t"
230 : /*out*/
231 : /*in*/ "r"(&block[0])
232 : /*trash*/ "memory", "t0", "t1", "t2", "t3"
233 );
234 } while (block[2] != 1);
235 #endif
236 #else
237 # error "Unsupported arch"
238 #endif
239 }
240
241
atomic_add_16bit(short * p,int n)242 __attribute__((noinline)) void atomic_add_16bit ( short* p, int n )
243 {
244 #if defined(VGA_x86)
245 unsigned long block[2];
246 block[0] = (unsigned long)p;
247 block[1] = n;
248 __asm__ __volatile__(
249 "movl 0(%%esi),%%eax" "\n\t"
250 "movl 4(%%esi),%%ebx" "\n\t"
251 "lock; addw %%bx,(%%eax)" "\n"
252 : : "S"(&block[0])/* S means "esi only" */ : "memory","cc","eax","ebx"
253 );
254 #elif defined(VGA_amd64)
255 unsigned long block[2];
256 block[0] = (unsigned long)p;
257 block[1] = n;
258 __asm__ __volatile__(
259 "movq 0(%%rsi),%%rax" "\n\t"
260 "movq 8(%%rsi),%%rbx" "\n\t"
261 "lock; addw %%bx,(%%rax)" "\n"
262 : : "S"(&block[0])/* S means "rsi only" */ : "memory","cc","rax","rbx"
263 );
264 #elif defined(VGA_ppc32)
265 /* Nasty hack. Does correctly atomically do *p += n, but only if p
266 is 8-aligned -- guaranteed by caller. */
267 unsigned long success;
268 do {
269 __asm__ __volatile__(
270 "lwarx 15,0,%1" "\n\t"
271 "add 15,15,%2" "\n\t"
272 "stwcx. 15,0,%1" "\n\t"
273 "mfcr %0" "\n\t"
274 "srwi %0,%0,29" "\n\t"
275 "andi. %0,%0,1" "\n"
276 : /*out*/"=b"(success)
277 : /*in*/ "b"(p), "b"(((unsigned long)n) << 16)
278 : /*trash*/ "memory", "cc", "r15"
279 );
280 } while (success != 1);
281 #elif defined(VGA_ppc64be)
282 /* Nasty hack. Does correctly atomically do *p += n, but only if p
283 is 8-aligned -- guaranteed by caller. */
284 unsigned long success;
285 do {
286 __asm__ __volatile__(
287 "ldarx 15,0,%1" "\n\t"
288 "add 15,15,%2" "\n\t"
289 "stdcx. 15,0,%1" "\n\t"
290 "mfcr %0" "\n\t"
291 "srwi %0,%0,29" "\n\t"
292 "andi. %0,%0,1" "\n"
293 : /*out*/"=b"(success)
294 : /*in*/ "b"(p), "b"(((unsigned long)n) << 48)
295 : /*trash*/ "memory", "cc", "r15"
296 );
297 } while (success != 1);
298 #elif defined(VGA_ppc64le)
299 /* Nasty hack. Does correctly atomically do *p += n, but only if p
300 is 8-aligned -- guaranteed by caller. */
301 unsigned long success;
302 do {
303 __asm__ __volatile__(
304 "ldarx 15,0,%1" "\n\t"
305 "add 15,15,%2" "\n\t"
306 "stdcx. 15,0,%1" "\n\t"
307 "mfcr %0" "\n\t"
308 "srwi %0,%0,29" "\n\t"
309 "andi. %0,%0,1" "\n"
310 : /*out*/"=b"(success)
311 : /*in*/ "b"(p), "b"(((unsigned long)n))
312 : /*trash*/ "memory", "cc", "r15"
313 );
314 } while (success != 1);
315 #elif defined(VGA_arm)
316 unsigned int block[3]
317 = { (unsigned int)p, (unsigned int)n, 0xFFFFFFFF };
318 do {
319 __asm__ __volatile__(
320 "mov r5, %0" "\n\t"
321 "ldr r9, [r5, #0]" "\n\t" // p
322 "ldr r10, [r5, #4]" "\n\t" // n
323 "ldrexh r8, [r9]" "\n\t"
324 "add r8, r8, r10" "\n\t"
325 "strexh r4, r8, [r9]" "\n\t"
326 "str r4, [r5, #8]" "\n\t"
327 : /*out*/
328 : /*in*/ "r"(&block[0])
329 : /*trash*/ "memory", "cc", "r5", "r8", "r9", "r10", "r4"
330 );
331 } while (block[2] != 0);
332 #elif defined(VGA_arm64)
333 unsigned long long int block[3]
334 = { (unsigned long long int)p, (unsigned long long int)n,
335 0xFFFFFFFFFFFFFFFFULL};
336 do {
337 __asm__ __volatile__(
338 "mov x5, %0" "\n\t"
339 "ldr x9, [x5, #0]" "\n\t" // p
340 "ldr x10, [x5, #8]" "\n\t" // n
341 "ldxrh w8, [x9]" "\n\t"
342 "add x8, x8, x10" "\n\t"
343 "stxrh w4, w8, [x9]" "\n\t"
344 "str x4, [x5, #16]" "\n\t"
345 : /*out*/
346 : /*in*/ "r"(&block[0])
347 : /*trash*/ "memory", "cc", "x5", "x8", "x9", "x10", "x4"
348 );
349 } while (block[2] != 0);
350 #elif defined(VGA_s390x)
351 int dummy;
352 __asm__ __volatile__(
353 " l 0,%0\n\t"
354 "0: st 0,%1\n\t"
355 " icm 1,3,%1\n\t"
356 " ar 1,%2\n\t"
357 " stcm 1,3,%1\n\t"
358 " l 1,%1\n\t"
359 " cs 0,1,%0\n\t"
360 " jl 0b\n\t"
361 : "+m" (*p), "+m" (dummy)
362 : "d" (n)
363 : "cc", "memory", "0", "1");
364 #elif defined(VGA_mips32)
365 /* We rely on the fact that p is 4-aligned. Otherwise 'll' may throw an
366 exception that can cause this function to fail. */
367 #if defined (_MIPSEL)
368 unsigned int block[3]
369 = { (unsigned int)p, (unsigned int)n, 0x0 };
370 do {
371 __asm__ __volatile__(
372 "move $t0, %0" "\n\t"
373 "lw $t1, 0($t0)" "\n\t" // p
374 "lw $t2, 4($t0)" "\n\t" // n
375 "andi $t2, $t2, 0xFFFF" "\n\t" // n = n and 0xFFFF
376 "li $t4, 0xFFFF" "\n\t"
377 "nor $t4, $t4, $zero" "\n\t" // $t4 = 0xFFFF0000
378 "ll $t3, 0($t1)" "\n\t" // $t3 = old value
379 "and $t4, $t4, $t3" "\n\t" // $t4 = $t3 and 0xFFFF0000
380 "addu $t3, $t3, $t2" "\n\t" // $t3 = $t3 + n
381 "andi $t3, $t3, 0xFFFF" "\n\t" // $t3 = $t3 and 0xFFFF
382 "or $t3, $t3, $t4" "\n\t" // $t3 = $t3 or $t4
383 "sc $t3, 0($t1)" "\n\t"
384 "sw $t3, 8($t0)" "\n\t" // save result
385 : /*out*/
386 : /*in*/ "r"(&block[0])
387 : /*trash*/ "memory", "t0", "t1", "t2", "t3", "t4"
388 );
389 } while (block[2] != 1);
390 #elif defined (_MIPSEB)
391 unsigned int block[3]
392 = { (unsigned int)p, (unsigned int)n << 16, 0x0 };
393 do {
394 __asm__ __volatile__(
395 "move $t0, %0" "\n\t"
396 "lw $t1, 0($t0)" "\n\t" // p
397 "lw $t2, 4($t0)" "\n\t" // n
398 "ll $t3, 0($t1)" "\n\t"
399 "addu $t3, $t3, $t2" "\n\t"
400 "sc $t3, 0($t1)" "\n\t"
401 "sw $t3, 8($t0)" "\n\t"
402 : /*out*/
403 : /*in*/ "r"(&block[0])
404 : /*trash*/ "memory", "t0", "t1", "t2", "t3"
405 );
406 } while (block[2] != 1);
407 #endif
408 #elif defined(VGA_mips64)
409 /* We rely on the fact that p is 4-aligned. Otherwise 'll' may throw an
410 exception that can cause this function to fail. */
411 #if defined (_MIPSEL)
412 unsigned long block[3]
413 = { (unsigned long)p, (unsigned long)n, 0x0ULL };
414 do {
415 __asm__ __volatile__(
416 "move $t0, %0" "\n\t"
417 "ld $t1, 0($t0)" "\n\t" // p
418 "ld $t2, 8($t0)" "\n\t" // n
419 "andi $t2, $t2, 0xFFFF" "\n\t" // n = n and 0xFFFF
420 "li $s0, 0xFFFF" "\n\t"
421 "nor $s0, $s0, $zero" "\n\t" // $s0= 0xFFFF0000
422 "ll $t3, 0($t1)" "\n\t" // $t3 = old value
423 "and $s0, $s0, $t3" "\n\t" // $s0 = $t3 and 0xFFFF0000
424 "addu $t3, $t3, $t2" "\n\t" // $t3 = $t3 + n
425 "andi $t3, $t3, 0xFFFF" "\n\t" // $t3 = $t3 and 0xFFFF
426 "or $t3, $t3, $s0" "\n\t" // $t3 = $t3 or $s0
427 "sc $t3, 0($t1)" "\n\t"
428 "sw $t3, 16($t0)" "\n\t" // save result
429 : /*out*/
430 : /*in*/ "r"(&block[0])
431 : /*trash*/ "memory", "t0", "t1", "t2", "t3", "s0"
432 );
433 } while (block[2] != 1);
434 #elif defined (_MIPSEB)
435 unsigned long block[3]
436 = { (unsigned long)p, (unsigned long)n << 48, 0x0 };
437 do {
438 __asm__ __volatile__(
439 "move $t0, %0" "\n\t"
440 "ld $t1, 0($t0)" "\n\t" // p
441 "ld $t2, 8($t0)" "\n\t" // n
442 "lld $t3, 0($t1)" "\n\t"
443 "daddu $t3, $t3, $t2" "\n\t"
444 "scd $t3, 0($t1)" "\n\t"
445 "sd $t3, 16($t0)" "\n\t"
446 : /*out*/
447 : /*in*/ "r"(&block[0])
448 : /*trash*/ "memory", "t0", "t1", "t2", "t3"
449 );
450 } while (block[2] != 1);
451 #endif
452 #else
453 # error "Unsupported arch"
454 #endif
455 }
456
atomic_add_32bit(int * p,int n)457 __attribute__((noinline)) void atomic_add_32bit ( int* p, int n )
458 {
459 #if defined(VGA_x86)
460 unsigned long block[2];
461 block[0] = (unsigned long)p;
462 block[1] = n;
463 __asm__ __volatile__(
464 "movl 0(%%esi),%%eax" "\n\t"
465 "movl 4(%%esi),%%ebx" "\n\t"
466 "lock; addl %%ebx,(%%eax)" "\n"
467 : : "S"(&block[0])/* S means "esi only" */ : "memory","cc","eax","ebx"
468 );
469 #elif defined(VGA_amd64)
470 unsigned long block[2];
471 block[0] = (unsigned long)p;
472 block[1] = n;
473 __asm__ __volatile__(
474 "movq 0(%%rsi),%%rax" "\n\t"
475 "movq 8(%%rsi),%%rbx" "\n\t"
476 "lock; addl %%ebx,(%%rax)" "\n"
477 : : "S"(&block[0])/* S means "rsi only" */ : "memory","cc","rax","rbx"
478 );
479 #elif defined(VGA_ppc32)
480 unsigned long success;
481 do {
482 __asm__ __volatile__(
483 "lwarx 15,0,%1" "\n\t"
484 "add 15,15,%2" "\n\t"
485 "stwcx. 15,0,%1" "\n\t"
486 "mfcr %0" "\n\t"
487 "srwi %0,%0,29" "\n\t"
488 "andi. %0,%0,1" "\n"
489 : /*out*/"=b"(success)
490 : /*in*/ "b"(p), "b"(n)
491 : /*trash*/ "memory", "cc", "r15"
492 );
493 } while (success != 1);
494 #elif defined(VGA_ppc64be)
495 /* Nasty hack. Does correctly atomically do *p += n, but only if p
496 is 8-aligned -- guaranteed by caller. */
497 unsigned long success;
498 do {
499 __asm__ __volatile__(
500 "ldarx 15,0,%1" "\n\t"
501 "add 15,15,%2" "\n\t"
502 "stdcx. 15,0,%1" "\n\t"
503 "mfcr %0" "\n\t"
504 "srwi %0,%0,29" "\n\t"
505 "andi. %0,%0,1" "\n"
506 : /*out*/"=b"(success)
507 : /*in*/ "b"(p), "b"(((unsigned long)n) << 32)
508 : /*trash*/ "memory", "cc", "r15"
509 );
510 } while (success != 1);
511 #elif defined(VGA_ppc64le)
512 /* Nasty hack. Does correctly atomically do *p += n, but only if p
513 is 8-aligned -- guaranteed by caller. */
514 unsigned long success;
515 do {
516 __asm__ __volatile__(
517 "ldarx 15,0,%1" "\n\t"
518 "add 15,15,%2" "\n\t"
519 "stdcx. 15,0,%1" "\n\t"
520 "mfcr %0" "\n\t"
521 "srwi %0,%0,29" "\n\t"
522 "andi. %0,%0,1" "\n"
523 : /*out*/"=b"(success)
524 : /*in*/ "b"(p), "b"(((unsigned long)n))
525 : /*trash*/ "memory", "cc", "r15"
526 );
527 } while (success != 1);
528 #elif defined(VGA_arm)
529 unsigned int block[3]
530 = { (unsigned int)p, (unsigned int)n, 0xFFFFFFFF };
531 do {
532 __asm__ __volatile__(
533 "mov r5, %0" "\n\t"
534 "ldr r9, [r5, #0]" "\n\t" // p
535 "ldr r10, [r5, #4]" "\n\t" // n
536 "ldrex r8, [r9]" "\n\t"
537 "add r8, r8, r10" "\n\t"
538 "strex r4, r8, [r9]" "\n\t"
539 "str r4, [r5, #8]" "\n\t"
540 : /*out*/
541 : /*in*/ "r"(&block[0])
542 : /*trash*/ "memory", "cc", "r5", "r8", "r9", "r10", "r4"
543 );
544 } while (block[2] != 0);
545 #elif defined(VGA_arm64)
546 unsigned long long int block[3]
547 = { (unsigned long long int)p, (unsigned long long int)n,
548 0xFFFFFFFFFFFFFFFFULL};
549 do {
550 __asm__ __volatile__(
551 "mov x5, %0" "\n\t"
552 "ldr x9, [x5, #0]" "\n\t" // p
553 "ldr x10, [x5, #8]" "\n\t" // n
554 "ldxr w8, [x9]" "\n\t"
555 "add x8, x8, x10" "\n\t"
556 "stxr w4, w8, [x9]" "\n\t"
557 "str x4, [x5, #16]" "\n\t"
558 : /*out*/
559 : /*in*/ "r"(&block[0])
560 : /*trash*/ "memory", "cc", "x5", "x8", "x9", "x10", "x4"
561 );
562 } while (block[2] != 0);
563 #elif defined(VGA_s390x)
564 __asm__ __volatile__(
565 " l 0,%0\n\t"
566 "0: lr 1,0\n\t"
567 " ar 1,%1\n\t"
568 " cs 0,1,%0\n\t"
569 " jl 0b\n\t"
570 : "+m" (*p)
571 : "d" (n)
572 : "cc", "memory", "0", "1");
573 #elif defined(VGA_mips32)
574 unsigned int block[3]
575 = { (unsigned int)p, (unsigned int)n, 0x0 };
576 do {
577 __asm__ __volatile__(
578 "move $t0, %0" "\n\t"
579 "lw $t1, 0($t0)" "\n\t" // p
580 "lw $t2, 4($t0)" "\n\t" // n
581 "ll $t3, 0($t1)" "\n\t"
582 "addu $t3, $t3, $t2" "\n\t"
583 "sc $t3, 0($t1)" "\n\t"
584 "sw $t3, 8($t0)" "\n\t"
585 : /*out*/
586 : /*in*/ "r"(&block[0])
587 : /*trash*/ "memory", "t0", "t1", "t2", "t3"
588 );
589 } while (block[2] != 1);
590 #elif defined(VGA_mips64)
591 unsigned long block[3]
592 = { (unsigned long)p, (unsigned long)n, 0x0ULL };
593 do {
594 __asm__ __volatile__(
595 "move $t0, %0" "\n\t"
596 "ld $t1, 0($t0)" "\n\t" // p
597 "ld $t2, 8($t0)" "\n\t" // n
598 "ll $t3, 0($t1)" "\n\t"
599 "addu $t3, $t3, $t2" "\n\t"
600 "sc $t3, 0($t1)" "\n\t"
601 "sd $t3, 16($t0)" "\n\t"
602 : /*out*/
603 : /*in*/ "r"(&block[0])
604 : /*trash*/ "memory", "t0", "t1", "t2", "t3"
605 );
606 } while (block[2] != 1);
607 #else
608 # error "Unsupported arch"
609 #endif
610 }
611
atomic_add_64bit(long long int * p,int n)612 __attribute__((noinline)) void atomic_add_64bit ( long long int* p, int n )
613 {
614 #if defined(VGA_x86) || defined(VGA_ppc32) || defined(VGA_mips32)
615 /* do nothing; is not supported */
616 #elif defined(VGA_amd64)
617 // this is a bit subtle. It relies on the fact that, on a 64-bit platform,
618 // sizeof(unsigned long long int) == sizeof(unsigned long) == sizeof(void*)
619 unsigned long long int block[2];
620 block[0] = (unsigned long long int)(unsigned long)p;
621 block[1] = n;
622 __asm__ __volatile__(
623 "movq 0(%%rsi),%%rax" "\n\t"
624 "movq 8(%%rsi),%%rbx" "\n\t"
625 "lock; addq %%rbx,(%%rax)" "\n"
626 : : "S"(&block[0])/* S means "rsi only" */ : "memory","cc","rax","rbx"
627 );
628 #elif defined(VGA_ppc64be) || defined(VGA_ppc64le)
629 unsigned long success;
630 do {
631 __asm__ __volatile__(
632 "ldarx 15,0,%1" "\n\t"
633 "add 15,15,%2" "\n\t"
634 "stdcx. 15,0,%1" "\n\t"
635 "mfcr %0" "\n\t"
636 "srwi %0,%0,29" "\n\t"
637 "andi. %0,%0,1" "\n"
638 : /*out*/"=b"(success)
639 : /*in*/ "b"(p), "b"(n)
640 : /*trash*/ "memory", "cc", "r15"
641 );
642 } while (success != 1);
643 #elif defined(VGA_arm)
644 unsigned long long int block[3]
645 = { (unsigned long long int)(unsigned long)p,
646 (unsigned long long int)n,
647 0xFFFFFFFFFFFFFFFFULL };
648 do {
649 __asm__ __volatile__(
650 "mov r5, %0" "\n\t"
651 "ldr r8, [r5, #0]" "\n\t" // p
652 "ldrd r2, r3, [r5, #8]" "\n\t" // n
653 "ldrexd r0, r1, [r8]" "\n\t"
654 "adds r2, r2, r0" "\n\t"
655 "adc r3, r3, r1" "\n\t"
656 "strexd r1, r2, r3, [r8]" "\n\t"
657 "str r1, [r5, #16]" "\n\t"
658 : /*out*/
659 : /*in*/ "r"(&block[0])
660 : /*trash*/ "memory", "cc", "r5", "r0", "r1", "r8", "r2", "r3"
661 );
662 } while (block[2] != 0xFFFFFFFF00000000ULL);
663 #elif defined(VGA_arm64)
664 unsigned long long int block[3]
665 = { (unsigned long long int)p, (unsigned long long int)n,
666 0xFFFFFFFFFFFFFFFFULL};
667 do {
668 __asm__ __volatile__(
669 "mov x5, %0" "\n\t"
670 "ldr x9, [x5, #0]" "\n\t" // p
671 "ldr x10, [x5, #8]" "\n\t" // n
672 "ldxr x8, [x9]" "\n\t"
673 "add x8, x8, x10" "\n\t"
674 "stxr w4, x8, [x9]" "\n\t"
675 "str x4, [x5, #16]" "\n\t"
676 : /*out*/
677 : /*in*/ "r"(&block[0])
678 : /*trash*/ "memory", "cc", "x5", "x8", "x9", "x10", "x4"
679 );
680 } while (block[2] != 0);
681 #elif defined(VGA_s390x)
682 __asm__ __volatile__(
683 " lg 0,%0\n\t"
684 "0: lgr 1,0\n\t"
685 " agr 1,%1\n\t"
686 " csg 0,1,%0\n\t"
687 " jl 0b\n\t"
688 : "+m" (*p)
689 : "d" (n)
690 : "cc", "memory", "0", "1");
691 #elif defined(VGA_mips64)
692 unsigned long block[3]
693 = { (unsigned long)p, (unsigned long)n, 0x0ULL };
694 do {
695 __asm__ __volatile__(
696 "move $t0, %0" "\n\t"
697 "ld $t1, 0($t0)" "\n\t" // p
698 "ld $t2, 8($t0)" "\n\t" // n
699 "lld $t3, 0($t1)" "\n\t"
700 "daddu $t3, $t3, $t2" "\n\t"
701 "scd $t3, 0($t1)" "\n\t"
702 "sd $t3, 16($t0)" "\n\t"
703 : /*out*/
704 : /*in*/ "r"(&block[0])
705 : /*trash*/ "memory", "t0", "t1", "t2", "t3"
706 );
707 } while (block[2] != 1);
708 #else
709 # error "Unsupported arch"
710 #endif
711 }
712
main(int argc,char ** argv)713 int main ( int argc, char** argv )
714 {
715 int i, status;
716 char* page;
717 char* p8;
718 short* p16;
719 int* p32;
720 long long int* p64;
721 pid_t child, p2;
722
723 printf("parent, pre-fork\n");
724
725 page = mmap( 0, sysconf(_SC_PAGESIZE),
726 PROT_READ|PROT_WRITE,
727 MAP_ANONYMOUS|MAP_SHARED, -1, 0 );
728 if (page == MAP_FAILED) {
729 perror("mmap failed");
730 exit(1);
731 }
732
733 p8 = (char*)(page+0);
734 p16 = (short*)(page+256);
735 p32 = (int*)(page+512);
736 p64 = (long long int*)(page+768);
737
738 assert( IS_8_ALIGNED(p8) );
739 assert( IS_8_ALIGNED(p16) );
740 assert( IS_8_ALIGNED(p32) );
741 assert( IS_8_ALIGNED(p64) );
742
743 memset(page, 0, 1024);
744
745 *p8 = 0;
746 *p16 = 0;
747 *p32 = 0;
748 *p64 = 0;
749
750 child = fork();
751 if (child == -1) {
752 perror("fork() failed\n");
753 return 1;
754 }
755
756 if (child == 0) {
757 /* --- CHILD --- */
758 printf("child\n");
759 for (i = 0; i < NNN; i++) {
760 atomic_add_8bit(p8, 1);
761 atomic_add_16bit(p16, 1);
762 atomic_add_32bit(p32, 1);
763 atomic_add_64bit(p64, 98765 ); /* ensure we hit the upper 32 bits */
764 }
765 return 1;
766 /* NOTREACHED */
767
768 }
769
770 /* --- PARENT --- */
771
772 printf("parent\n");
773
774 for (i = 0; i < NNN; i++) {
775 atomic_add_8bit(p8, 1);
776 atomic_add_16bit(p16, 1);
777 atomic_add_32bit(p32, 1);
778 atomic_add_64bit(p64, 98765 ); /* ensure we hit the upper 32 bits */
779 }
780
781 p2 = waitpid(child, &status, 0);
782 assert(p2 == child);
783
784 /* assert that child finished normally */
785 assert(WIFEXITED(status));
786
787 printf("FINAL VALUES: 8 bit %d, 16 bit %d, 32 bit %d, 64 bit %lld\n",
788 (int)(*(signed char*)p8), (int)(*p16), *p32, *p64 );
789
790 if (-74 == (int)(*(signed char*)p8)
791 && 32694 == (int)(*p16)
792 && 6913974 == *p32
793 && (0LL == *p64 || 682858642110LL == *p64)) {
794 printf("PASS\n");
795 } else {
796 printf("FAIL -- see source code for expected values\n");
797 }
798
799 printf("parent exits\n");
800
801 return 0;
802 }
803