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