[SPARC] Fix 8 and 16-bit atomic load and store.
[lldb.git] / llvm / test / CodeGen / SPARC / atomics.ll
1 ; RUN: llc < %s -march=sparcv9 -verify-machineinstrs | FileCheck %s
2
3 ; CHECK-LABEL: test_atomic_i8
4 ; CHECK:       ldub [%o0]
5 ; CHECK:       membar
6 ; CHECK:       ldub [%o1]
7 ; CHECK:       membar
8 ; CHECK:       membar
9 ; CHECK:       stb {{.+}}, [%o2]
10 define i8 @test_atomic_i8(i8* %ptr1, i8* %ptr2, i8* %ptr3) {
11 entry:
12   %0 = load atomic i8, i8* %ptr1 acquire, align 1
13   %1 = load atomic i8, i8* %ptr2 acquire, align 1
14   %2 = add i8 %0, %1
15   store atomic i8 %2, i8* %ptr3 release, align 1
16   ret i8 %2
17 }
18
19 ; CHECK-LABEL: test_atomic_i16
20 ; CHECK:       lduh [%o0]
21 ; CHECK:       membar
22 ; CHECK:       lduh [%o1]
23 ; CHECK:       membar
24 ; CHECK:       membar
25 ; CHECK:       sth {{.+}}, [%o2]
26 define i16 @test_atomic_i16(i16* %ptr1, i16* %ptr2, i16* %ptr3) {
27 entry:
28   %0 = load atomic i16, i16* %ptr1 acquire, align 2
29   %1 = load atomic i16, i16* %ptr2 acquire, align 2
30   %2 = add i16 %0, %1
31   store atomic i16 %2, i16* %ptr3 release, align 2
32   ret i16 %2
33 }
34
35 ; CHECK-LABEL: test_atomic_i32
36 ; CHECK:       ld [%o0]
37 ; CHECK:       membar
38 ; CHECK:       ld [%o1]
39 ; CHECK:       membar
40 ; CHECK:       membar
41 ; CHECK:       st {{.+}}, [%o2]
42 define i32 @test_atomic_i32(i32* %ptr1, i32* %ptr2, i32* %ptr3) {
43 entry:
44   %0 = load atomic i32, i32* %ptr1 acquire, align 4
45   %1 = load atomic i32, i32* %ptr2 acquire, align 4
46   %2 = add i32 %0, %1
47   store atomic i32 %2, i32* %ptr3 release, align 4
48   ret i32 %2
49 }
50
51 ; CHECK-LABEL: test_atomic_i64
52 ; CHECK:       ldx [%o0]
53 ; CHECK:       membar
54 ; CHECK:       ldx [%o1]
55 ; CHECK:       membar
56 ; CHECK:       membar
57 ; CHECK:       stx {{.+}}, [%o2]
58 define i64 @test_atomic_i64(i64* %ptr1, i64* %ptr2, i64* %ptr3) {
59 entry:
60   %0 = load atomic i64, i64* %ptr1 acquire, align 8
61   %1 = load atomic i64, i64* %ptr2 acquire, align 8
62   %2 = add i64 %0, %1
63   store atomic i64 %2, i64* %ptr3 release, align 8
64   ret i64 %2
65 }
66
67 ; CHECK-LABEL: test_cmpxchg_i32
68 ; CHECK:       mov 123, [[R:%[gilo][0-7]]]
69 ; CHECK:       cas [%o1], %o0, [[R]]
70
71 define i32 @test_cmpxchg_i32(i32 %a, i32* %ptr) {
72 entry:
73   %pair = cmpxchg i32* %ptr, i32 %a, i32 123 monotonic monotonic
74   %b = extractvalue { i32, i1 } %pair, 0
75   ret i32 %b
76 }
77
78 ; CHECK-LABEL: test_cmpxchg_i64
79 ; CHECK:       mov 123, [[R:%[gilo][0-7]]]
80 ; CHECK:       casx [%o1], %o0, [[R]]
81
82 define i64 @test_cmpxchg_i64(i64 %a, i64* %ptr) {
83 entry:
84   %pair = cmpxchg i64* %ptr, i64 %a, i64 123 monotonic monotonic
85   %b = extractvalue { i64, i1 } %pair, 0
86   ret i64 %b
87 }
88
89 ; CHECK-LABEL: test_swap_i32
90 ; CHECK:       mov 42, [[R:%[gilo][0-7]]]
91 ; CHECK:       swap [%o1], [[R]]
92
93 define i32 @test_swap_i32(i32 %a, i32* %ptr) {
94 entry:
95   %b = atomicrmw xchg i32* %ptr, i32 42 monotonic
96   ret i32 %b
97 }
98
99 ; CHECK-LABEL: test_swap_i64
100 ; CHECK:       casx [%o1],
101
102 define i64 @test_swap_i64(i64 %a, i64* %ptr) {
103 entry:
104   %b = atomicrmw xchg i64* %ptr, i64 42 monotonic
105   ret i64 %b
106 }
107
108 ; CHECK-LABEL: test_load_add_32
109 ; CHECK: membar
110 ; CHECK: add [[V:%[gilo][0-7]]], %o1, [[U:%[gilo][0-7]]]
111 ; CHECK: cas [%o0], [[V]], [[U]]
112 ; CHECK: membar
113 define zeroext i32 @test_load_add_32(i32* %p, i32 zeroext %v) {
114 entry:
115   %0 = atomicrmw add i32* %p, i32 %v seq_cst
116   ret i32 %0
117 }
118
119 ; CHECK-LABEL: test_load_sub_64
120 ; CHECK: membar
121 ; CHECK: sub
122 ; CHECK: casx [%o0]
123 ; CHECK: membar
124 define zeroext i64 @test_load_sub_64(i64* %p, i64 zeroext %v) {
125 entry:
126   %0 = atomicrmw sub i64* %p, i64 %v seq_cst
127   ret i64 %0
128 }
129
130 ; CHECK-LABEL: test_load_xor_32
131 ; CHECK: membar
132 ; CHECK: xor
133 ; CHECK: cas [%o0]
134 ; CHECK: membar
135 define zeroext i32 @test_load_xor_32(i32* %p, i32 zeroext %v) {
136 entry:
137   %0 = atomicrmw xor i32* %p, i32 %v seq_cst
138   ret i32 %0
139 }
140
141 ; CHECK-LABEL: test_load_and_32
142 ; CHECK: membar
143 ; CHECK: and
144 ; CHECK-NOT: xor
145 ; CHECK: cas [%o0]
146 ; CHECK: membar
147 define zeroext i32 @test_load_and_32(i32* %p, i32 zeroext %v) {
148 entry:
149   %0 = atomicrmw and i32* %p, i32 %v seq_cst
150   ret i32 %0
151 }
152
153 ; CHECK-LABEL: test_load_nand_32
154 ; CHECK: membar
155 ; CHECK: and
156 ; CHECK: xor
157 ; CHECK: cas [%o0]
158 ; CHECK: membar
159 define zeroext i32 @test_load_nand_32(i32* %p, i32 zeroext %v) {
160 entry:
161   %0 = atomicrmw nand i32* %p, i32 %v seq_cst
162   ret i32 %0
163 }
164
165 ; CHECK-LABEL: test_load_max_64
166 ; CHECK: membar
167 ; CHECK: cmp
168 ; CHECK: movg %xcc
169 ; CHECK: casx [%o0]
170 ; CHECK: membar
171 define zeroext i64 @test_load_max_64(i64* %p, i64 zeroext %v) {
172 entry:
173   %0 = atomicrmw max i64* %p, i64 %v seq_cst
174   ret i64 %0
175 }
176
177 ; CHECK-LABEL: test_load_umin_32
178 ; CHECK: membar
179 ; CHECK: cmp
180 ; CHECK: movleu %icc
181 ; CHECK: cas [%o0]
182 ; CHECK: membar
183 define zeroext i32 @test_load_umin_32(i32* %p, i32 zeroext %v) {
184 entry:
185   %0 = atomicrmw umin i32* %p, i32 %v seq_cst
186   ret i32 %0
187 }