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