|
1 // |
|
2 // Copyright (c) 2002, 2013, Oracle and/or its affiliates. All rights reserved. |
|
3 // DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
|
4 // |
|
5 // This code is free software; you can redistribute it and/or modify it |
|
6 // under the terms of the GNU General Public License version 2 only, as |
|
7 // published by the Free Software Foundation. |
|
8 // |
|
9 // This code is distributed in the hope that it will be useful, but WITHOUT |
|
10 // ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
11 // FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
12 // version 2 for more details (a copy is included in the LICENSE file that |
|
13 // accompanied this code). |
|
14 // |
|
15 // You should have received a copy of the GNU General Public License version |
|
16 // 2 along with this work; if not, write to the Free Software Foundation, |
|
17 // Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
|
18 // |
|
19 // Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
20 // or visit www.oracle.com if you need additional information or have any |
|
21 // questions. |
|
22 // |
|
23 // |
|
24 |
|
25 // Get the raw thread ID from %g7 |
|
26 |
|
27 .inline _raw_thread_id, 0 |
|
28 .register %g7,#scratch |
|
29 .volatile |
|
30 mov %g7, %o0 |
|
31 .nonvolatile |
|
32 .end |
|
33 |
|
34 |
|
35 // Clear SPARC fprs.FEF DU and DL bits -- |
|
36 // allows the kernel to avoid saving FPU state at context-switch time. |
|
37 // Use for state-transition points (into _thread_blocked) or when |
|
38 // parking. |
|
39 |
|
40 .inline _mark_fpu_nosave, 0 |
|
41 .volatile |
|
42 wr %g0, 0, %fprs |
|
43 .nonvolatile |
|
44 .end |
|
45 |
|
46 // Support for jint Atomic::xchg(jint exchange_value, volatile jint* dest). |
|
47 // |
|
48 // Arguments: |
|
49 // exchange_value: O0 |
|
50 // dest: O1 |
|
51 // |
|
52 // Results: |
|
53 // O0: the value previously stored in dest |
|
54 |
|
55 .inline _Atomic_swap32, 2 |
|
56 .volatile |
|
57 swap [%o1],%o0 |
|
58 .nonvolatile |
|
59 .end |
|
60 |
|
61 |
|
62 // Support for intptr_t Atomic::xchg_ptr(intptr_t exchange_value, volatile intptr_t * dest). |
|
63 // |
|
64 // 64-bit |
|
65 // |
|
66 // Arguments: |
|
67 // exchange_value: O0 |
|
68 // dest: O1 |
|
69 // |
|
70 // Results: |
|
71 // O0: the value previously stored in dest |
|
72 |
|
73 .inline _Atomic_swap64, 2 |
|
74 .volatile |
|
75 1: |
|
76 mov %o0, %o3 |
|
77 ldx [%o1], %o2 |
|
78 casx [%o1], %o2, %o3 |
|
79 cmp %o2, %o3 |
|
80 bne %xcc, 1b |
|
81 nop |
|
82 mov %o2, %o0 |
|
83 .nonvolatile |
|
84 .end |
|
85 |
|
86 |
|
87 // Support for jint Atomic::cmpxchg(jint exchange_value, |
|
88 // volatile jint* dest, |
|
89 // jint compare_value) |
|
90 // |
|
91 // Arguments: |
|
92 // exchange_value: O0 |
|
93 // dest: O1 |
|
94 // compare_value: O2 |
|
95 // |
|
96 // Results: |
|
97 // O0: the value previously stored in dest |
|
98 |
|
99 .inline _Atomic_cas32, 3 |
|
100 .volatile |
|
101 cas [%o1], %o2, %o0 |
|
102 .nonvolatile |
|
103 .end |
|
104 |
|
105 |
|
106 // Support for intptr_t Atomic::cmpxchg_ptr(intptr_t exchange_value, |
|
107 // volatile intptr_t* dest, |
|
108 // intptr_t compare_value) |
|
109 // |
|
110 // 64-bit |
|
111 // |
|
112 // Arguments: |
|
113 // exchange_value: O0 |
|
114 // dest: O1 |
|
115 // compare_value: O2 |
|
116 // |
|
117 // Results: |
|
118 // O0: the value previously stored in dest |
|
119 |
|
120 .inline _Atomic_cas64, 3 |
|
121 .volatile |
|
122 casx [%o1], %o2, %o0 |
|
123 .nonvolatile |
|
124 .end |
|
125 |
|
126 |
|
127 // Support for jlong Atomic::cmpxchg(jlong exchange_value, |
|
128 // volatile jlong* dest, |
|
129 // jlong compare_value) |
|
130 // |
|
131 // 32-bit calling conventions |
|
132 // |
|
133 // Arguments: |
|
134 // exchange_value: O1:O0 |
|
135 // dest: O2 |
|
136 // compare_value: O4:O3 |
|
137 // |
|
138 // Results: |
|
139 // O1:O0: the value previously stored in dest |
|
140 |
|
141 .inline _Atomic_casl, 3 |
|
142 .volatile |
|
143 sllx %o0, 32, %o0 |
|
144 srl %o1, 0, %o1 |
|
145 or %o0,%o1,%o0 |
|
146 sllx %o3, 32, %o3 |
|
147 srl %o4, 0, %o4 |
|
148 or %o3,%o4,%o3 |
|
149 casx [%o2], %o3, %o0 |
|
150 srl %o0, 0, %o1 |
|
151 srlx %o0, 32, %o0 |
|
152 .nonvolatile |
|
153 .end |
|
154 |
|
155 // Support for jlong Atomic::load and Atomic::store on v9. |
|
156 // |
|
157 // void _Atomic_move_long_v9(volatile jlong* src, volatile jlong* dst) |
|
158 // |
|
159 // Arguments: |
|
160 // src: O0 |
|
161 // dest: O1 |
|
162 // |
|
163 // Overwrites O2 |
|
164 |
|
165 .inline _Atomic_move_long_v9,2 |
|
166 .volatile |
|
167 ldx [%o0], %o2 |
|
168 stx %o2, [%o1] |
|
169 .nonvolatile |
|
170 .end |
|
171 |
|
172 // Support for jint Atomic::add(jint add_value, volatile jint* dest). |
|
173 // |
|
174 // Arguments: |
|
175 // add_value: O0 (e.g., +1 or -1) |
|
176 // dest: O1 |
|
177 // |
|
178 // Results: |
|
179 // O0: the new value stored in dest |
|
180 // |
|
181 // Overwrites O3 |
|
182 |
|
183 .inline _Atomic_add32, 2 |
|
184 .volatile |
|
185 2: |
|
186 ld [%o1], %o2 |
|
187 add %o0, %o2, %o3 |
|
188 cas [%o1], %o2, %o3 |
|
189 cmp %o2, %o3 |
|
190 bne 2b |
|
191 nop |
|
192 add %o0, %o2, %o0 |
|
193 .nonvolatile |
|
194 .end |
|
195 |
|
196 |
|
197 // Support for intptr_t Atomic::add_ptr(intptr_t add_value, volatile intptr_t* dest) |
|
198 // |
|
199 // 64-bit |
|
200 // |
|
201 // Arguments: |
|
202 // add_value: O0 (e.g., +1 or -1) |
|
203 // dest: O1 |
|
204 // |
|
205 // Results: |
|
206 // O0: the new value stored in dest |
|
207 // |
|
208 // Overwrites O3 |
|
209 |
|
210 .inline _Atomic_add64, 2 |
|
211 .volatile |
|
212 3: |
|
213 ldx [%o1], %o2 |
|
214 add %o0, %o2, %o3 |
|
215 casx [%o1], %o2, %o3 |
|
216 cmp %o2, %o3 |
|
217 bne %xcc, 3b |
|
218 nop |
|
219 add %o0, %o2, %o0 |
|
220 .nonvolatile |
|
221 .end |
|
222 |
|
223 |
|
224 // Support for void OrderAccess::acquire() |
|
225 // The method is intentionally empty. |
|
226 // It exists for the sole purpose of generating |
|
227 // a C/C++ sequence point over which the compiler won't |
|
228 // reorder code. |
|
229 |
|
230 .inline _OrderAccess_acquire,0 |
|
231 .volatile |
|
232 .nonvolatile |
|
233 .end |
|
234 |
|
235 |
|
236 // Support for void OrderAccess::fence() |
|
237 |
|
238 .inline _OrderAccess_fence,0 |
|
239 .volatile |
|
240 membar #StoreLoad |
|
241 .nonvolatile |
|
242 .end |
|
243 |
|
244 |
|
245 // Support for void Prefetch::read(void *loc, intx interval) |
|
246 // |
|
247 // Prefetch for several reads. |
|
248 |
|
249 .inline _Prefetch_read, 2 |
|
250 .volatile |
|
251 prefetch [%o0+%o1], 0 |
|
252 .nonvolatile |
|
253 .end |
|
254 |
|
255 |
|
256 // Support for void Prefetch::write(void *loc, intx interval) |
|
257 // |
|
258 // Prefetch for several writes. |
|
259 |
|
260 .inline _Prefetch_write, 2 |
|
261 .volatile |
|
262 prefetch [%o0+%o1], 2 |
|
263 .nonvolatile |
|
264 .end |
|
265 |
|
266 |
|
267 // Support for void Copy::conjoint_jlongs_atomic(jlong* from, jlong* to, size_t count) |
|
268 // |
|
269 // 32-bit |
|
270 // |
|
271 // Arguments: |
|
272 // from: O0 |
|
273 // to: O1 |
|
274 // count: O2 treated as signed |
|
275 // |
|
276 // Clobbers: |
|
277 // long_value: O2, O3 |
|
278 // count: O4 |
|
279 // |
|
280 // if (from > to) { |
|
281 // while (--count >= 0) { |
|
282 // *to++ = *from++; |
|
283 // } |
|
284 // } else { |
|
285 // while (--count >= 0) { |
|
286 // to[count] = from[count]; |
|
287 // } |
|
288 // } |
|
289 .inline _Copy_conjoint_jlongs_atomic, 3 |
|
290 .volatile |
|
291 cmp %o0, %o1 |
|
292 bleu 4f |
|
293 sll %o2, 3, %o4 |
|
294 ba 2f |
|
295 1: |
|
296 subcc %o4, 8, %o4 |
|
297 std %o2, [%o1] |
|
298 add %o0, 8, %o0 |
|
299 add %o1, 8, %o1 |
|
300 2: |
|
301 bge,a 1b |
|
302 ldd [%o0], %o2 |
|
303 ba 5f |
|
304 nop |
|
305 3: |
|
306 std %o2, [%o1+%o4] |
|
307 4: |
|
308 subcc %o4, 8, %o4 |
|
309 bge,a 3b |
|
310 ldd [%o0+%o4], %o2 |
|
311 5: |
|
312 .nonvolatile |
|
313 .end |