| // |
| // Copyright (c) 2004, 2013, Oracle and/or its affiliates. All rights reserved. |
| // DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| // |
| // This code is free software; you can redistribute it and/or modify it |
| // under the terms of the GNU General Public License version 2 only, as |
| // published by the Free Software Foundation. |
| // |
| // This code is distributed in the hope that it will be useful, but WITHOUT |
| // ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| // FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| // version 2 for more details (a copy is included in the LICENSE file that |
| // accompanied this code). |
| // |
| // You should have received a copy of the GNU General Public License version |
| // 2 along with this work; if not, write to the Free Software Foundation, |
| // Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| // |
| // Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| // or visit www.oracle.com if you need additional information or have any |
| // questions. |
| // |
| |
| .globl fixcw |
| .globl sse_check |
| .globl sse_unavailable |
| .globl gs_load |
| .globl gs_thread |
| .globl _Atomic_cmpxchg_long_gcc |
| |
| // NOTE WELL! The _Copy functions are called directly |
| // from server-compiler-generated code via CallLeafNoFP, |
| // which means that they *must* either not use floating |
| // point or use it in the same manner as does the server |
| // compiler. |
| |
| .globl _Copy_conjoint_bytes |
| .globl _Copy_arrayof_conjoint_bytes |
| .globl _Copy_conjoint_jshorts_atomic |
| .globl _Copy_arrayof_conjoint_jshorts |
| .globl _Copy_conjoint_jints_atomic |
| .globl _Copy_arrayof_conjoint_jints |
| .globl _Copy_conjoint_jlongs_atomic |
| .globl _mmx_Copy_arrayof_conjoint_jshorts |
| |
| .section .text,"ax" |
| |
| / Support for void os::Solaris::init_thread_fpu_state() in os_solaris_i486.cpp |
| / Set fpu to 53 bit precision. This happens too early to use a stub. |
| .align 16 |
| fixcw: |
| pushl $0x27f |
| fldcw 0(%esp) |
| popl %eax |
| ret |
| |
| .align 16 |
| .globl SpinPause |
| SpinPause: |
| rep |
| nop |
| movl $1, %eax |
| ret |
| |
| |
| / Test SSE availability, used by os_solaris_i486.cpp |
| .align 16 |
| sse_check: |
| / Fault if SSE not available |
| xorps %xmm0,%xmm0 |
| / No fault |
| movl $1,%eax |
| ret |
| / Signal handler continues here if SSE is not available |
| sse_unavailable: |
| xorl %eax,%eax |
| ret |
| |
| / Fast thread accessors, used by threadLS_solaris_i486.cpp |
| .align 16 |
| gs_load: |
| movl 4(%esp),%ecx |
| movl %gs:(%ecx),%eax |
| ret |
| |
| .align 16 |
| gs_thread: |
| movl %gs:0x0,%eax |
| ret |
| |
| / Support for void Copy::conjoint_bytes(void* from, |
| / void* to, |
| / size_t count) |
| .align 16 |
| _Copy_conjoint_bytes: |
| pushl %esi |
| movl 4+12(%esp),%ecx / count |
| pushl %edi |
| movl 8+ 4(%esp),%esi / from |
| movl 8+ 8(%esp),%edi / to |
| cmpl %esi,%edi |
| leal -1(%esi,%ecx),%eax / from + count - 1 |
| jbe cb_CopyRight |
| cmpl %eax,%edi |
| jbe cb_CopyLeft |
| / copy from low to high |
| cb_CopyRight: |
| cmpl $3,%ecx |
| jbe 5f / <= 3 bytes |
| / align source address at dword address boundary |
| movl %ecx,%eax / original count |
| movl $4,%ecx |
| subl %esi,%ecx |
| andl $3,%ecx / prefix byte count |
| jz 1f / no prefix |
| subl %ecx,%eax / byte count less prefix |
| / copy prefix |
| subl %esi,%edi |
| 0: movb (%esi),%dl |
| movb %dl,(%edi,%esi,1) |
| addl $1,%esi |
| subl $1,%ecx |
| jnz 0b |
| addl %esi,%edi |
| 1: movl %eax,%ecx / byte count less prefix |
| shrl $2,%ecx / dword count |
| jz 4f / no dwords to move |
| cmpl $32,%ecx |
| jbe 2f / <= 32 dwords |
| / copy aligned dwords |
| rep; smovl |
| jmp 4f |
| / copy aligned dwords |
| 2: subl %esi,%edi |
| .align 16 |
| 3: movl (%esi),%edx |
| movl %edx,(%edi,%esi,1) |
| addl $4,%esi |
| subl $1,%ecx |
| jnz 3b |
| addl %esi,%edi |
| 4: movl %eax,%ecx / byte count less prefix |
| 5: andl $3,%ecx / suffix byte count |
| jz 7f / no suffix |
| / copy suffix |
| xorl %eax,%eax |
| 6: movb (%esi,%eax,1),%dl |
| movb %dl,(%edi,%eax,1) |
| addl $1,%eax |
| subl $1,%ecx |
| jnz 6b |
| 7: popl %edi |
| popl %esi |
| ret |
| / copy from high to low |
| cb_CopyLeft: |
| std |
| leal -4(%edi,%ecx),%edi / to + count - 4 |
| movl %eax,%esi / from + count - 1 |
| movl %ecx,%eax |
| subl $3,%esi / from + count - 4 |
| cmpl $3,%ecx |
| jbe 5f / <= 3 bytes |
| 1: shrl $2,%ecx / dword count |
| jz 4f / no dwords to move |
| cmpl $32,%ecx |
| ja 3f / > 32 dwords |
| / copy dwords, aligned or not |
| subl %esi,%edi |
| .align 16 |
| 2: movl (%esi),%edx |
| movl %edx,(%edi,%esi,1) |
| subl $4,%esi |
| subl $1,%ecx |
| jnz 2b |
| addl %esi,%edi |
| jmp 4f |
| / copy dwords, aligned or not |
| 3: rep; smovl |
| 4: movl %eax,%ecx / byte count |
| 5: andl $3,%ecx / suffix byte count |
| jz 7f / no suffix |
| / copy suffix |
| subl %esi,%edi |
| addl $3,%esi |
| 6: movb (%esi),%dl |
| movb %dl,(%edi,%esi,1) |
| subl $1,%esi |
| subl $1,%ecx |
| jnz 6b |
| 7: cld |
| popl %edi |
| popl %esi |
| ret |
| |
| / Support for void Copy::arrayof_conjoint_bytes(void* from, |
| / void* to, |
| / size_t count) |
| / |
| / Same as _Copy_conjoint_bytes, except no source alignment check. |
| .align 16 |
| _Copy_arrayof_conjoint_bytes: |
| pushl %esi |
| movl 4+12(%esp),%ecx / count |
| pushl %edi |
| movl 8+ 4(%esp),%esi / from |
| movl 8+ 8(%esp),%edi / to |
| cmpl %esi,%edi |
| leal -1(%esi,%ecx),%eax / from + count - 1 |
| jbe acb_CopyRight |
| cmpl %eax,%edi |
| jbe acb_CopyLeft |
| / copy from low to high |
| acb_CopyRight: |
| cmpl $3,%ecx |
| jbe 5f |
| 1: movl %ecx,%eax |
| shrl $2,%ecx |
| jz 4f |
| cmpl $32,%ecx |
| ja 3f |
| / copy aligned dwords |
| subl %esi,%edi |
| .align 16 |
| 2: movl (%esi),%edx |
| movl %edx,(%edi,%esi,1) |
| addl $4,%esi |
| subl $1,%ecx |
| jnz 2b |
| addl %esi,%edi |
| jmp 4f |
| / copy aligned dwords |
| 3: rep; smovl |
| 4: movl %eax,%ecx |
| 5: andl $3,%ecx |
| jz 7f |
| / copy suffix |
| xorl %eax,%eax |
| 6: movb (%esi,%eax,1),%dl |
| movb %dl,(%edi,%eax,1) |
| addl $1,%eax |
| subl $1,%ecx |
| jnz 6b |
| 7: popl %edi |
| popl %esi |
| ret |
| acb_CopyLeft: |
| std |
| leal -4(%edi,%ecx),%edi / to + count - 4 |
| movl %eax,%esi / from + count - 1 |
| movl %ecx,%eax |
| subl $3,%esi / from + count - 4 |
| cmpl $3,%ecx |
| jbe 5f |
| 1: shrl $2,%ecx |
| jz 4f |
| cmpl $32,%ecx |
| jbe 2f / <= 32 dwords |
| rep; smovl |
| jmp 4f |
| .=.+8 |
| 2: subl %esi,%edi |
| .align 16 |
| 3: movl (%esi),%edx |
| movl %edx,(%edi,%esi,1) |
| subl $4,%esi |
| subl $1,%ecx |
| jnz 3b |
| addl %esi,%edi |
| 4: movl %eax,%ecx |
| 5: andl $3,%ecx |
| jz 7f |
| subl %esi,%edi |
| addl $3,%esi |
| 6: movb (%esi),%dl |
| movb %dl,(%edi,%esi,1) |
| subl $1,%esi |
| subl $1,%ecx |
| jnz 6b |
| 7: cld |
| popl %edi |
| popl %esi |
| ret |
| |
| / Support for void Copy::conjoint_jshorts_atomic(void* from, |
| / void* to, |
| / size_t count) |
| .align 16 |
| _Copy_conjoint_jshorts_atomic: |
| pushl %esi |
| movl 4+12(%esp),%ecx / count |
| pushl %edi |
| movl 8+ 4(%esp),%esi / from |
| movl 8+ 8(%esp),%edi / to |
| cmpl %esi,%edi |
| leal -2(%esi,%ecx,2),%eax / from + count*2 - 2 |
| jbe cs_CopyRight |
| cmpl %eax,%edi |
| jbe cs_CopyLeft |
| / copy from low to high |
| cs_CopyRight: |
| / align source address at dword address boundary |
| movl %esi,%eax / original from |
| andl $3,%eax / either 0 or 2 |
| jz 1f / no prefix |
| / copy prefix |
| subl $1,%ecx |
| jl 5f / zero count |
| movw (%esi),%dx |
| movw %dx,(%edi) |
| addl %eax,%esi / %eax == 2 |
| addl %eax,%edi |
| 1: movl %ecx,%eax / word count less prefix |
| sarl %ecx / dword count |
| jz 4f / no dwords to move |
| cmpl $32,%ecx |
| jbe 2f / <= 32 dwords |
| / copy aligned dwords |
| rep; smovl |
| jmp 4f |
| / copy aligned dwords |
| 2: subl %esi,%edi |
| .align 16 |
| 3: movl (%esi),%edx |
| movl %edx,(%edi,%esi,1) |
| addl $4,%esi |
| subl $1,%ecx |
| jnz 3b |
| addl %esi,%edi |
| 4: andl $1,%eax / suffix count |
| jz 5f / no suffix |
| / copy suffix |
| movw (%esi),%dx |
| movw %dx,(%edi) |
| 5: popl %edi |
| popl %esi |
| ret |
| / copy from high to low |
| cs_CopyLeft: |
| std |
| leal -4(%edi,%ecx,2),%edi / to + count*2 - 4 |
| movl %eax,%esi / from + count*2 - 2 |
| movl %ecx,%eax |
| subl $2,%esi / from + count*2 - 4 |
| 1: sarl %ecx / dword count |
| jz 4f / no dwords to move |
| cmpl $32,%ecx |
| ja 3f / > 32 dwords |
| subl %esi,%edi |
| .align 16 |
| 2: movl (%esi),%edx |
| movl %edx,(%edi,%esi,1) |
| subl $4,%esi |
| subl $1,%ecx |
| jnz 2b |
| addl %esi,%edi |
| jmp 4f |
| 3: rep; smovl |
| 4: andl $1,%eax / suffix count |
| jz 5f / no suffix |
| / copy suffix |
| addl $2,%esi |
| addl $2,%edi |
| movw (%esi),%dx |
| movw %dx,(%edi) |
| 5: cld |
| popl %edi |
| popl %esi |
| ret |
| |
| / Support for void Copy::arrayof_conjoint_jshorts(void* from, |
| / void* to, |
| / size_t count) |
| .align 16 |
| _Copy_arrayof_conjoint_jshorts: |
| pushl %esi |
| movl 4+12(%esp),%ecx / count |
| pushl %edi |
| movl 8+ 4(%esp),%esi / from |
| movl 8+ 8(%esp),%edi / to |
| cmpl %esi,%edi |
| leal -2(%esi,%ecx,2),%eax / from + count*2 - 2 |
| jbe acs_CopyRight |
| cmpl %eax,%edi |
| jbe acs_CopyLeft |
| acs_CopyRight: |
| movl %ecx,%eax / word count |
| sarl %ecx / dword count |
| jz 4f / no dwords to move |
| cmpl $32,%ecx |
| jbe 2f / <= 32 dwords |
| / copy aligned dwords |
| rep; smovl |
| jmp 4f |
| / copy aligned dwords |
| .=.+5 |
| 2: subl %esi,%edi |
| .align 16 |
| 3: movl (%esi),%edx |
| movl %edx,(%edi,%esi,1) |
| addl $4,%esi |
| subl $1,%ecx |
| jnz 3b |
| addl %esi,%edi |
| 4: andl $1,%eax / suffix count |
| jz 5f / no suffix |
| / copy suffix |
| movw (%esi),%dx |
| movw %dx,(%edi) |
| 5: popl %edi |
| popl %esi |
| ret |
| acs_CopyLeft: |
| std |
| leal -4(%edi,%ecx,2),%edi / to + count*2 - 4 |
| movl %eax,%esi / from + count*2 - 2 |
| movl %ecx,%eax |
| subl $2,%esi / from + count*2 - 4 |
| sarl %ecx / dword count |
| jz 4f / no dwords to move |
| cmpl $32,%ecx |
| ja 3f / > 32 dwords |
| subl %esi,%edi |
| .align 16 |
| 2: movl (%esi),%edx |
| movl %edx,(%edi,%esi,1) |
| subl $4,%esi |
| subl $1,%ecx |
| jnz 2b |
| addl %esi,%edi |
| jmp 4f |
| 3: rep; smovl |
| 4: andl $1,%eax / suffix count |
| jz 5f / no suffix |
| / copy suffix |
| addl $2,%esi |
| addl $2,%edi |
| movw (%esi),%dx |
| movw %dx,(%edi) |
| 5: cld |
| popl %edi |
| popl %esi |
| ret |
| |
| / Support for void Copy::conjoint_jints_atomic(void* from, |
| / void* to, |
| / size_t count) |
| / Equivalent to |
| / arrayof_conjoint_jints |
| .align 16 |
| _Copy_conjoint_jints_atomic: |
| _Copy_arrayof_conjoint_jints: |
| pushl %esi |
| movl 4+12(%esp),%ecx / count |
| pushl %edi |
| movl 8+ 4(%esp),%esi / from |
| movl 8+ 8(%esp),%edi / to |
| cmpl %esi,%edi |
| leal -4(%esi,%ecx,4),%eax / from + count*4 - 4 |
| jbe ci_CopyRight |
| cmpl %eax,%edi |
| jbe ci_CopyLeft |
| ci_CopyRight: |
| cmpl $32,%ecx |
| jbe 2f / <= 32 dwords |
| rep; smovl |
| popl %edi |
| popl %esi |
| ret |
| .=.+10 |
| 2: subl %esi,%edi |
| jmp 4f |
| .align 16 |
| 3: movl (%esi),%edx |
| movl %edx,(%edi,%esi,1) |
| addl $4,%esi |
| 4: subl $1,%ecx |
| jge 3b |
| popl %edi |
| popl %esi |
| ret |
| ci_CopyLeft: |
| std |
| leal -4(%edi,%ecx,4),%edi / to + count*4 - 4 |
| cmpl $32,%ecx |
| ja 4f / > 32 dwords |
| subl %eax,%edi / eax == from + count*4 - 4 |
| jmp 3f |
| .align 16 |
| 2: movl (%eax),%edx |
| movl %edx,(%edi,%eax,1) |
| subl $4,%eax |
| 3: subl $1,%ecx |
| jge 2b |
| cld |
| popl %edi |
| popl %esi |
| ret |
| 4: movl %eax,%esi / from + count*4 - 4 |
| rep; smovl |
| cld |
| popl %edi |
| popl %esi |
| ret |
| |
| / Support for void Copy::conjoint_jlongs_atomic(jlong* from, |
| / jlong* to, |
| / size_t count) |
| / |
| / 32-bit |
| / |
| / count treated as signed |
| / |
| / if (from > to) { |
| / while (--count >= 0) { |
| / *to++ = *from++; |
| / } |
| / } else { |
| / while (--count >= 0) { |
| / to[count] = from[count]; |
| / } |
| / } |
| .align 16 |
| _Copy_conjoint_jlongs_atomic: |
| movl 4+8(%esp),%ecx / count |
| movl 4+0(%esp),%eax / from |
| movl 4+4(%esp),%edx / to |
| cmpl %eax,%edx |
| jae cla_CopyLeft |
| cla_CopyRight: |
| subl %eax,%edx |
| jmp 2f |
| .align 16 |
| 1: fildll (%eax) |
| fistpll (%edx,%eax,1) |
| addl $8,%eax |
| 2: subl $1,%ecx |
| jge 1b |
| ret |
| .align 16 |
| 3: fildll (%eax,%ecx,8) |
| fistpll (%edx,%ecx,8) |
| cla_CopyLeft: |
| subl $1,%ecx |
| jge 3b |
| ret |
| |
| / Support for void Copy::arrayof_conjoint_jshorts(void* from, |
| / void* to, |
| / size_t count) |
| .align 16 |
| _mmx_Copy_arrayof_conjoint_jshorts: |
| pushl %esi |
| movl 4+12(%esp),%ecx |
| pushl %edi |
| movl 8+ 4(%esp),%esi |
| movl 8+ 8(%esp),%edi |
| cmpl %esi,%edi |
| leal -2(%esi,%ecx,2),%eax |
| jbe mmx_acs_CopyRight |
| cmpl %eax,%edi |
| jbe mmx_acs_CopyLeft |
| mmx_acs_CopyRight: |
| movl %ecx,%eax |
| sarl %ecx |
| je 5f |
| cmpl $33,%ecx |
| jae 3f |
| 1: subl %esi,%edi |
| .align 16 |
| 2: movl (%esi),%edx |
| movl %edx,(%edi,%esi,1) |
| addl $4,%esi |
| subl $1,%ecx |
| jnz 2b |
| addl %esi,%edi |
| jmp 5f |
| 3: smovl / align to 8 bytes, we know we are 4 byte aligned to start |
| subl $1,%ecx |
| 4: .align 16 |
| movq 0(%esi),%mm0 |
| addl $64,%edi |
| movq 8(%esi),%mm1 |
| subl $16,%ecx |
| movq 16(%esi),%mm2 |
| movq %mm0,-64(%edi) |
| movq 24(%esi),%mm0 |
| movq %mm1,-56(%edi) |
| movq 32(%esi),%mm1 |
| movq %mm2,-48(%edi) |
| movq 40(%esi),%mm2 |
| movq %mm0,-40(%edi) |
| movq 48(%esi),%mm0 |
| movq %mm1,-32(%edi) |
| movq 56(%esi),%mm1 |
| movq %mm2,-24(%edi) |
| movq %mm0,-16(%edi) |
| addl $64,%esi |
| movq %mm1,-8(%edi) |
| cmpl $16,%ecx |
| jge 4b |
| emms |
| testl %ecx,%ecx |
| ja 1b |
| 5: andl $1,%eax |
| je 7f |
| 6: movw (%esi),%dx |
| movw %dx,(%edi) |
| 7: popl %edi |
| popl %esi |
| ret |
| mmx_acs_CopyLeft: |
| std |
| leal -4(%edi,%ecx,2),%edi |
| movl %eax,%esi |
| movl %ecx,%eax |
| subl $2,%esi |
| sarl %ecx |
| je 4f |
| cmpl $32,%ecx |
| ja 3f |
| subl %esi,%edi |
| .align 16 |
| 2: movl (%esi),%edx |
| movl %edx,(%edi,%esi,1) |
| subl $4,%esi |
| subl $1,%ecx |
| jnz 2b |
| addl %esi,%edi |
| jmp 4f |
| 3: rep; smovl |
| 4: andl $1,%eax |
| je 6f |
| addl $2,%esi |
| addl $2,%edi |
| 5: movw (%esi),%dx |
| movw %dx,(%edi) |
| 6: cld |
| popl %edi |
| popl %esi |
| ret |
| |
| |
| / Support for jlong Atomic::cmpxchg(jlong exchange_value, |
| / volatile jlong* dest, |
| / jlong compare_value, |
| / bool is_MP) |
| / Used only for Solaris/gcc builds |
| .align 16 |
| _Atomic_cmpxchg_long_gcc: |
| / 8(%esp) : return PC |
| pushl %ebx / 4(%esp) : old %ebx |
| pushl %edi / 0(%esp) : old %edi |
| movl 12(%esp), %ebx / 12(%esp) : exchange_value (low) |
| movl 16(%esp), %ecx / 16(%esp) : exchange_value (high) |
| movl 24(%esp), %eax / 24(%esp) : compare_value (low) |
| movl 28(%esp), %edx / 28(%esp) : compare_value (high) |
| movl 20(%esp), %edi / 20(%esp) : dest |
| cmpl $0, 32(%esp) / 32(%esp) : is_MP |
| je 1f |
| lock |
| 1: cmpxchg8b (%edi) |
| popl %edi |
| popl %ebx |
| ret |
