|
1 # |
|
2 # Copyright (c) 2004, 2017, 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 # NOTE WELL! The _Copy functions are called directly |
|
26 # from server-compiler-generated code via CallLeafNoFP, |
|
27 # which means that they *must* either not use floating |
|
28 # point or use it in the same manner as does the server |
|
29 # compiler. |
|
30 |
|
31 .globl _Copy_conjoint_bytes |
|
32 .globl _Copy_arrayof_conjoint_bytes |
|
33 .globl _Copy_conjoint_jshorts_atomic |
|
34 .globl _Copy_arrayof_conjoint_jshorts |
|
35 .globl _Copy_conjoint_jints_atomic |
|
36 .globl _Copy_arrayof_conjoint_jints |
|
37 .globl _Copy_conjoint_jlongs_atomic |
|
38 .globl _mmx_Copy_arrayof_conjoint_jshorts |
|
39 |
|
40 .globl _Atomic_cmpxchg_long |
|
41 .globl _Atomic_move_long |
|
42 |
|
43 .text |
|
44 |
|
45 .globl SpinPause |
|
46 .type SpinPause,@function |
|
47 .p2align 4,,15 |
|
48 SpinPause: |
|
49 rep |
|
50 nop |
|
51 movl $1, %eax |
|
52 ret |
|
53 |
|
54 # Support for void Copy::conjoint_bytes(void* from, |
|
55 # void* to, |
|
56 # size_t count) |
|
57 .p2align 4,,15 |
|
58 .type _Copy_conjoint_bytes,@function |
|
59 _Copy_conjoint_bytes: |
|
60 pushl %esi |
|
61 movl 4+12(%esp),%ecx # count |
|
62 pushl %edi |
|
63 movl 8+ 4(%esp),%esi # from |
|
64 movl 8+ 8(%esp),%edi # to |
|
65 cmpl %esi,%edi |
|
66 leal -1(%esi,%ecx),%eax # from + count - 1 |
|
67 jbe cb_CopyRight |
|
68 cmpl %eax,%edi |
|
69 jbe cb_CopyLeft |
|
70 # copy from low to high |
|
71 cb_CopyRight: |
|
72 cmpl $3,%ecx |
|
73 jbe 5f # <= 3 bytes |
|
74 # align source address at dword address boundary |
|
75 movl %ecx,%eax # original count |
|
76 movl $4,%ecx |
|
77 subl %esi,%ecx |
|
78 andl $3,%ecx # prefix byte count |
|
79 jz 1f # no prefix |
|
80 subl %ecx,%eax # byte count less prefix |
|
81 # copy prefix |
|
82 subl %esi,%edi |
|
83 0: movb (%esi),%dl |
|
84 movb %dl,(%edi,%esi,1) |
|
85 addl $1,%esi |
|
86 subl $1,%ecx |
|
87 jnz 0b |
|
88 addl %esi,%edi |
|
89 1: movl %eax,%ecx # byte count less prefix |
|
90 shrl $2,%ecx # dword count |
|
91 jz 4f # no dwords to move |
|
92 cmpl $32,%ecx |
|
93 jbe 2f # <= 32 dwords |
|
94 # copy aligned dwords |
|
95 rep; smovl |
|
96 jmp 4f |
|
97 # copy aligned dwords |
|
98 2: subl %esi,%edi |
|
99 .p2align 4,,15 |
|
100 3: movl (%esi),%edx |
|
101 movl %edx,(%edi,%esi,1) |
|
102 addl $4,%esi |
|
103 subl $1,%ecx |
|
104 jnz 3b |
|
105 addl %esi,%edi |
|
106 4: movl %eax,%ecx # byte count less prefix |
|
107 5: andl $3,%ecx # suffix byte count |
|
108 jz 7f # no suffix |
|
109 # copy suffix |
|
110 xorl %eax,%eax |
|
111 6: movb (%esi,%eax,1),%dl |
|
112 movb %dl,(%edi,%eax,1) |
|
113 addl $1,%eax |
|
114 subl $1,%ecx |
|
115 jnz 6b |
|
116 7: popl %edi |
|
117 popl %esi |
|
118 ret |
|
119 # copy from high to low |
|
120 cb_CopyLeft: |
|
121 std |
|
122 leal -4(%edi,%ecx),%edi # to + count - 4 |
|
123 movl %eax,%esi # from + count - 1 |
|
124 movl %ecx,%eax |
|
125 subl $3,%esi # from + count - 4 |
|
126 cmpl $3,%ecx |
|
127 jbe 5f # <= 3 bytes |
|
128 1: shrl $2,%ecx # dword count |
|
129 jz 4f # no dwords to move |
|
130 cmpl $32,%ecx |
|
131 ja 3f # > 32 dwords |
|
132 # copy dwords, aligned or not |
|
133 subl %esi,%edi |
|
134 .p2align 4,,15 |
|
135 2: movl (%esi),%edx |
|
136 movl %edx,(%edi,%esi,1) |
|
137 subl $4,%esi |
|
138 subl $1,%ecx |
|
139 jnz 2b |
|
140 addl %esi,%edi |
|
141 jmp 4f |
|
142 # copy dwords, aligned or not |
|
143 3: rep; smovl |
|
144 4: movl %eax,%ecx # byte count |
|
145 5: andl $3,%ecx # suffix byte count |
|
146 jz 7f # no suffix |
|
147 # copy suffix |
|
148 subl %esi,%edi |
|
149 addl $3,%esi |
|
150 6: movb (%esi),%dl |
|
151 movb %dl,(%edi,%esi,1) |
|
152 subl $1,%esi |
|
153 subl $1,%ecx |
|
154 jnz 6b |
|
155 7: cld |
|
156 popl %edi |
|
157 popl %esi |
|
158 ret |
|
159 |
|
160 # Support for void Copy::arrayof_conjoint_bytes(void* from, |
|
161 # void* to, |
|
162 # size_t count) |
|
163 # |
|
164 # Same as _Copy_conjoint_bytes, except no source alignment check. |
|
165 .p2align 4,,15 |
|
166 .type _Copy_arrayof_conjoint_bytes,@function |
|
167 _Copy_arrayof_conjoint_bytes: |
|
168 pushl %esi |
|
169 movl 4+12(%esp),%ecx # count |
|
170 pushl %edi |
|
171 movl 8+ 4(%esp),%esi # from |
|
172 movl 8+ 8(%esp),%edi # to |
|
173 cmpl %esi,%edi |
|
174 leal -1(%esi,%ecx),%eax # from + count - 1 |
|
175 jbe acb_CopyRight |
|
176 cmpl %eax,%edi |
|
177 jbe acb_CopyLeft |
|
178 # copy from low to high |
|
179 acb_CopyRight: |
|
180 cmpl $3,%ecx |
|
181 jbe 5f |
|
182 1: movl %ecx,%eax |
|
183 shrl $2,%ecx |
|
184 jz 4f |
|
185 cmpl $32,%ecx |
|
186 ja 3f |
|
187 # copy aligned dwords |
|
188 subl %esi,%edi |
|
189 .p2align 4,,15 |
|
190 2: movl (%esi),%edx |
|
191 movl %edx,(%edi,%esi,1) |
|
192 addl $4,%esi |
|
193 subl $1,%ecx |
|
194 jnz 2b |
|
195 addl %esi,%edi |
|
196 jmp 4f |
|
197 # copy aligned dwords |
|
198 3: rep; smovl |
|
199 4: movl %eax,%ecx |
|
200 5: andl $3,%ecx |
|
201 jz 7f |
|
202 # copy suffix |
|
203 xorl %eax,%eax |
|
204 6: movb (%esi,%eax,1),%dl |
|
205 movb %dl,(%edi,%eax,1) |
|
206 addl $1,%eax |
|
207 subl $1,%ecx |
|
208 jnz 6b |
|
209 7: popl %edi |
|
210 popl %esi |
|
211 ret |
|
212 acb_CopyLeft: |
|
213 std |
|
214 leal -4(%edi,%ecx),%edi # to + count - 4 |
|
215 movl %eax,%esi # from + count - 1 |
|
216 movl %ecx,%eax |
|
217 subl $3,%esi # from + count - 4 |
|
218 cmpl $3,%ecx |
|
219 jbe 5f |
|
220 1: shrl $2,%ecx |
|
221 jz 4f |
|
222 cmpl $32,%ecx |
|
223 jbe 2f # <= 32 dwords |
|
224 rep; smovl |
|
225 jmp 4f |
|
226 .space 8 |
|
227 2: subl %esi,%edi |
|
228 .p2align 4,,15 |
|
229 3: movl (%esi),%edx |
|
230 movl %edx,(%edi,%esi,1) |
|
231 subl $4,%esi |
|
232 subl $1,%ecx |
|
233 jnz 3b |
|
234 addl %esi,%edi |
|
235 4: movl %eax,%ecx |
|
236 5: andl $3,%ecx |
|
237 jz 7f |
|
238 subl %esi,%edi |
|
239 addl $3,%esi |
|
240 6: movb (%esi),%dl |
|
241 movb %dl,(%edi,%esi,1) |
|
242 subl $1,%esi |
|
243 subl $1,%ecx |
|
244 jnz 6b |
|
245 7: cld |
|
246 popl %edi |
|
247 popl %esi |
|
248 ret |
|
249 |
|
250 # Support for void Copy::conjoint_jshorts_atomic(void* from, |
|
251 # void* to, |
|
252 # size_t count) |
|
253 .p2align 4,,15 |
|
254 .type _Copy_conjoint_jshorts_atomic,@function |
|
255 _Copy_conjoint_jshorts_atomic: |
|
256 pushl %esi |
|
257 movl 4+12(%esp),%ecx # count |
|
258 pushl %edi |
|
259 movl 8+ 4(%esp),%esi # from |
|
260 movl 8+ 8(%esp),%edi # to |
|
261 cmpl %esi,%edi |
|
262 leal -2(%esi,%ecx,2),%eax # from + count*2 - 2 |
|
263 jbe cs_CopyRight |
|
264 cmpl %eax,%edi |
|
265 jbe cs_CopyLeft |
|
266 # copy from low to high |
|
267 cs_CopyRight: |
|
268 # align source address at dword address boundary |
|
269 movl %esi,%eax # original from |
|
270 andl $3,%eax # either 0 or 2 |
|
271 jz 1f # no prefix |
|
272 # copy prefix |
|
273 subl $1,%ecx |
|
274 jl 5f # zero count |
|
275 movw (%esi),%dx |
|
276 movw %dx,(%edi) |
|
277 addl %eax,%esi # %eax == 2 |
|
278 addl %eax,%edi |
|
279 1: movl %ecx,%eax # word count less prefix |
|
280 sarl %ecx # dword count |
|
281 jz 4f # no dwords to move |
|
282 cmpl $32,%ecx |
|
283 jbe 2f # <= 32 dwords |
|
284 # copy aligned dwords |
|
285 rep; smovl |
|
286 jmp 4f |
|
287 # copy aligned dwords |
|
288 2: subl %esi,%edi |
|
289 .p2align 4,,15 |
|
290 3: movl (%esi),%edx |
|
291 movl %edx,(%edi,%esi,1) |
|
292 addl $4,%esi |
|
293 subl $1,%ecx |
|
294 jnz 3b |
|
295 addl %esi,%edi |
|
296 4: andl $1,%eax # suffix count |
|
297 jz 5f # no suffix |
|
298 # copy suffix |
|
299 movw (%esi),%dx |
|
300 movw %dx,(%edi) |
|
301 5: popl %edi |
|
302 popl %esi |
|
303 ret |
|
304 # copy from high to low |
|
305 cs_CopyLeft: |
|
306 std |
|
307 leal -4(%edi,%ecx,2),%edi # to + count*2 - 4 |
|
308 movl %eax,%esi # from + count*2 - 2 |
|
309 movl %ecx,%eax |
|
310 subl $2,%esi # from + count*2 - 4 |
|
311 1: sarl %ecx # dword count |
|
312 jz 4f # no dwords to move |
|
313 cmpl $32,%ecx |
|
314 ja 3f # > 32 dwords |
|
315 subl %esi,%edi |
|
316 .p2align 4,,15 |
|
317 2: movl (%esi),%edx |
|
318 movl %edx,(%edi,%esi,1) |
|
319 subl $4,%esi |
|
320 subl $1,%ecx |
|
321 jnz 2b |
|
322 addl %esi,%edi |
|
323 jmp 4f |
|
324 3: rep; smovl |
|
325 4: andl $1,%eax # suffix count |
|
326 jz 5f # no suffix |
|
327 # copy suffix |
|
328 addl $2,%esi |
|
329 addl $2,%edi |
|
330 movw (%esi),%dx |
|
331 movw %dx,(%edi) |
|
332 5: cld |
|
333 popl %edi |
|
334 popl %esi |
|
335 ret |
|
336 |
|
337 # Support for void Copy::arrayof_conjoint_jshorts(void* from, |
|
338 # void* to, |
|
339 # size_t count) |
|
340 .p2align 4,,15 |
|
341 .type _Copy_arrayof_conjoint_jshorts,@function |
|
342 _Copy_arrayof_conjoint_jshorts: |
|
343 pushl %esi |
|
344 movl 4+12(%esp),%ecx # count |
|
345 pushl %edi |
|
346 movl 8+ 4(%esp),%esi # from |
|
347 movl 8+ 8(%esp),%edi # to |
|
348 cmpl %esi,%edi |
|
349 leal -2(%esi,%ecx,2),%eax # from + count*2 - 2 |
|
350 jbe acs_CopyRight |
|
351 cmpl %eax,%edi |
|
352 jbe acs_CopyLeft |
|
353 acs_CopyRight: |
|
354 movl %ecx,%eax # word count |
|
355 sarl %ecx # dword count |
|
356 jz 4f # no dwords to move |
|
357 cmpl $32,%ecx |
|
358 jbe 2f # <= 32 dwords |
|
359 # copy aligned dwords |
|
360 rep; smovl |
|
361 jmp 4f |
|
362 # copy aligned dwords |
|
363 .space 5 |
|
364 2: subl %esi,%edi |
|
365 .p2align 4,,15 |
|
366 3: movl (%esi),%edx |
|
367 movl %edx,(%edi,%esi,1) |
|
368 addl $4,%esi |
|
369 subl $1,%ecx |
|
370 jnz 3b |
|
371 addl %esi,%edi |
|
372 4: andl $1,%eax # suffix count |
|
373 jz 5f # no suffix |
|
374 # copy suffix |
|
375 movw (%esi),%dx |
|
376 movw %dx,(%edi) |
|
377 5: popl %edi |
|
378 popl %esi |
|
379 ret |
|
380 acs_CopyLeft: |
|
381 std |
|
382 leal -4(%edi,%ecx,2),%edi # to + count*2 - 4 |
|
383 movl %eax,%esi # from + count*2 - 2 |
|
384 movl %ecx,%eax |
|
385 subl $2,%esi # from + count*2 - 4 |
|
386 sarl %ecx # dword count |
|
387 jz 4f # no dwords to move |
|
388 cmpl $32,%ecx |
|
389 ja 3f # > 32 dwords |
|
390 subl %esi,%edi |
|
391 .p2align 4,,15 |
|
392 2: movl (%esi),%edx |
|
393 movl %edx,(%edi,%esi,1) |
|
394 subl $4,%esi |
|
395 subl $1,%ecx |
|
396 jnz 2b |
|
397 addl %esi,%edi |
|
398 jmp 4f |
|
399 3: rep; smovl |
|
400 4: andl $1,%eax # suffix count |
|
401 jz 5f # no suffix |
|
402 # copy suffix |
|
403 addl $2,%esi |
|
404 addl $2,%edi |
|
405 movw (%esi),%dx |
|
406 movw %dx,(%edi) |
|
407 5: cld |
|
408 popl %edi |
|
409 popl %esi |
|
410 ret |
|
411 |
|
412 # Support for void Copy::conjoint_jints_atomic(void* from, |
|
413 # void* to, |
|
414 # size_t count) |
|
415 # Equivalent to |
|
416 # arrayof_conjoint_jints |
|
417 .p2align 4,,15 |
|
418 .type _Copy_conjoint_jints_atomic,@function |
|
419 .type _Copy_arrayof_conjoint_jints,@function |
|
420 _Copy_conjoint_jints_atomic: |
|
421 _Copy_arrayof_conjoint_jints: |
|
422 pushl %esi |
|
423 movl 4+12(%esp),%ecx # count |
|
424 pushl %edi |
|
425 movl 8+ 4(%esp),%esi # from |
|
426 movl 8+ 8(%esp),%edi # to |
|
427 cmpl %esi,%edi |
|
428 leal -4(%esi,%ecx,4),%eax # from + count*4 - 4 |
|
429 jbe ci_CopyRight |
|
430 cmpl %eax,%edi |
|
431 jbe ci_CopyLeft |
|
432 ci_CopyRight: |
|
433 cmpl $32,%ecx |
|
434 jbe 2f # <= 32 dwords |
|
435 rep; smovl |
|
436 popl %edi |
|
437 popl %esi |
|
438 ret |
|
439 .space 10 |
|
440 2: subl %esi,%edi |
|
441 jmp 4f |
|
442 .p2align 4,,15 |
|
443 3: movl (%esi),%edx |
|
444 movl %edx,(%edi,%esi,1) |
|
445 addl $4,%esi |
|
446 4: subl $1,%ecx |
|
447 jge 3b |
|
448 popl %edi |
|
449 popl %esi |
|
450 ret |
|
451 ci_CopyLeft: |
|
452 std |
|
453 leal -4(%edi,%ecx,4),%edi # to + count*4 - 4 |
|
454 cmpl $32,%ecx |
|
455 ja 4f # > 32 dwords |
|
456 subl %eax,%edi # eax == from + count*4 - 4 |
|
457 jmp 3f |
|
458 .p2align 4,,15 |
|
459 2: movl (%eax),%edx |
|
460 movl %edx,(%edi,%eax,1) |
|
461 subl $4,%eax |
|
462 3: subl $1,%ecx |
|
463 jge 2b |
|
464 cld |
|
465 popl %edi |
|
466 popl %esi |
|
467 ret |
|
468 4: movl %eax,%esi # from + count*4 - 4 |
|
469 rep; smovl |
|
470 cld |
|
471 popl %edi |
|
472 popl %esi |
|
473 ret |
|
474 |
|
475 # Support for void Copy::conjoint_jlongs_atomic(jlong* from, |
|
476 # jlong* to, |
|
477 # size_t count) |
|
478 # |
|
479 # 32-bit |
|
480 # |
|
481 # count treated as signed |
|
482 # |
|
483 # if (from > to) { |
|
484 # while (--count >= 0) { |
|
485 # *to++ = *from++; |
|
486 # } |
|
487 # } else { |
|
488 # while (--count >= 0) { |
|
489 # to[count] = from[count]; |
|
490 # } |
|
491 # } |
|
492 .p2align 4,,15 |
|
493 .type _Copy_conjoint_jlongs_atomic,@function |
|
494 _Copy_conjoint_jlongs_atomic: |
|
495 movl 4+8(%esp),%ecx # count |
|
496 movl 4+0(%esp),%eax # from |
|
497 movl 4+4(%esp),%edx # to |
|
498 cmpl %eax,%edx |
|
499 jae cla_CopyLeft |
|
500 cla_CopyRight: |
|
501 subl %eax,%edx |
|
502 jmp 2f |
|
503 .p2align 4,,15 |
|
504 1: fildll (%eax) |
|
505 fistpll (%edx,%eax,1) |
|
506 addl $8,%eax |
|
507 2: subl $1,%ecx |
|
508 jge 1b |
|
509 ret |
|
510 .p2align 4,,15 |
|
511 3: fildll (%eax,%ecx,8) |
|
512 fistpll (%edx,%ecx,8) |
|
513 cla_CopyLeft: |
|
514 subl $1,%ecx |
|
515 jge 3b |
|
516 ret |
|
517 |
|
518 # Support for void Copy::arrayof_conjoint_jshorts(void* from, |
|
519 # void* to, |
|
520 # size_t count) |
|
521 .p2align 4,,15 |
|
522 .type _mmx_Copy_arrayof_conjoint_jshorts,@function |
|
523 _mmx_Copy_arrayof_conjoint_jshorts: |
|
524 pushl %esi |
|
525 movl 4+12(%esp),%ecx |
|
526 pushl %edi |
|
527 movl 8+ 4(%esp),%esi |
|
528 movl 8+ 8(%esp),%edi |
|
529 cmpl %esi,%edi |
|
530 leal -2(%esi,%ecx,2),%eax |
|
531 jbe mmx_acs_CopyRight |
|
532 cmpl %eax,%edi |
|
533 jbe mmx_acs_CopyLeft |
|
534 mmx_acs_CopyRight: |
|
535 movl %ecx,%eax |
|
536 sarl %ecx |
|
537 je 5f |
|
538 cmpl $33,%ecx |
|
539 jae 3f |
|
540 1: subl %esi,%edi |
|
541 .p2align 4,,15 |
|
542 2: movl (%esi),%edx |
|
543 movl %edx,(%edi,%esi,1) |
|
544 addl $4,%esi |
|
545 subl $1,%ecx |
|
546 jnz 2b |
|
547 addl %esi,%edi |
|
548 jmp 5f |
|
549 3: smovl # align to 8 bytes, we know we are 4 byte aligned to start |
|
550 subl $1,%ecx |
|
551 4: .p2align 4,,15 |
|
552 movq 0(%esi),%mm0 |
|
553 addl $64,%edi |
|
554 movq 8(%esi),%mm1 |
|
555 subl $16,%ecx |
|
556 movq 16(%esi),%mm2 |
|
557 movq %mm0,-64(%edi) |
|
558 movq 24(%esi),%mm0 |
|
559 movq %mm1,-56(%edi) |
|
560 movq 32(%esi),%mm1 |
|
561 movq %mm2,-48(%edi) |
|
562 movq 40(%esi),%mm2 |
|
563 movq %mm0,-40(%edi) |
|
564 movq 48(%esi),%mm0 |
|
565 movq %mm1,-32(%edi) |
|
566 movq 56(%esi),%mm1 |
|
567 movq %mm2,-24(%edi) |
|
568 movq %mm0,-16(%edi) |
|
569 addl $64,%esi |
|
570 movq %mm1,-8(%edi) |
|
571 cmpl $16,%ecx |
|
572 jge 4b |
|
573 emms |
|
574 testl %ecx,%ecx |
|
575 ja 1b |
|
576 5: andl $1,%eax |
|
577 je 7f |
|
578 6: movw (%esi),%dx |
|
579 movw %dx,(%edi) |
|
580 7: popl %edi |
|
581 popl %esi |
|
582 ret |
|
583 mmx_acs_CopyLeft: |
|
584 std |
|
585 leal -4(%edi,%ecx,2),%edi |
|
586 movl %eax,%esi |
|
587 movl %ecx,%eax |
|
588 subl $2,%esi |
|
589 sarl %ecx |
|
590 je 4f |
|
591 cmpl $32,%ecx |
|
592 ja 3f |
|
593 subl %esi,%edi |
|
594 .p2align 4,,15 |
|
595 2: movl (%esi),%edx |
|
596 movl %edx,(%edi,%esi,1) |
|
597 subl $4,%esi |
|
598 subl $1,%ecx |
|
599 jnz 2b |
|
600 addl %esi,%edi |
|
601 jmp 4f |
|
602 3: rep; smovl |
|
603 4: andl $1,%eax |
|
604 je 6f |
|
605 addl $2,%esi |
|
606 addl $2,%edi |
|
607 5: movw (%esi),%dx |
|
608 movw %dx,(%edi) |
|
609 6: cld |
|
610 popl %edi |
|
611 popl %esi |
|
612 ret |
|
613 |
|
614 |
|
615 # Support for jlong Atomic::cmpxchg(jlong exchange_value, |
|
616 # volatile jlong* dest, |
|
617 # jlong compare_value) |
|
618 # |
|
619 .p2align 4,,15 |
|
620 .type _Atomic_cmpxchg_long,@function |
|
621 _Atomic_cmpxchg_long: |
|
622 # 8(%esp) : return PC |
|
623 pushl %ebx # 4(%esp) : old %ebx |
|
624 pushl %edi # 0(%esp) : old %edi |
|
625 movl 12(%esp), %ebx # 12(%esp) : exchange_value (low) |
|
626 movl 16(%esp), %ecx # 16(%esp) : exchange_value (high) |
|
627 movl 24(%esp), %eax # 24(%esp) : compare_value (low) |
|
628 movl 28(%esp), %edx # 28(%esp) : compare_value (high) |
|
629 movl 20(%esp), %edi # 20(%esp) : dest |
|
630 lock cmpxchg8b (%edi) |
|
631 popl %edi |
|
632 popl %ebx |
|
633 ret |
|
634 |
|
635 |
|
636 # Support for jlong Atomic::load and Atomic::store. |
|
637 # void _Atomic_move_long(const volatile jlong* src, volatile jlong* dst) |
|
638 .p2align 4,,15 |
|
639 .type _Atomic_move_long,@function |
|
640 _Atomic_move_long: |
|
641 movl 4(%esp), %eax # src |
|
642 fildll (%eax) |
|
643 movl 8(%esp), %eax # dest |
|
644 fistpll (%eax) |
|
645 ret |
|
646 |