~ljy/RK3588_XEN.git

! Copyright 2005-2016 The OpenSSL Project Authors. All Rights Reserved.
!
! Licensed under the OpenSSL license (the "License").  You may not use
! this file except in compliance with the License.  You can obtain a copy
! in the file LICENSE in the source distribution or at
! https://www.openssl.org/source/license.html
 
#if defined(__SUNPRO_C) && defined(__sparcv9)
# define ABI64  /* They've said -xarch=v9 at command line */
#elif defined(__GNUC__) && defined(__arch64__)
# define ABI64  /* They've said -m64 at command line */
#endif
 
#ifdef ABI64
  .register    %g2,#scratch
  .register    %g3,#scratch
# define    FRAME    -192
# define    BIAS    2047
#else
# define    FRAME    -96
# define    BIAS    0
#endif
 
.text
.align    32
.global    OPENSSL_wipe_cpu
.type    OPENSSL_wipe_cpu,#function
! Keep in mind that this does not excuse us from wiping the stack!
! This routine wipes registers, but not the backing store [which
! resides on the stack, toward lower addresses]. To facilitate for
! stack wiping I return pointer to the top of stack of the *caller*.
OPENSSL_wipe_cpu:
    save    %sp,FRAME,%sp
    nop
#ifdef __sun
#include <sys/trap.h>
    ta    ST_CLEAN_WINDOWS
#else
    call    .walk.reg.wins
#endif
    nop
    call    .PIC.zero.up
    mov    .zero-(.-4),%o0
    ld    [%o0],%f0
    ld    [%o0],%f1
 
    subcc    %g0,1,%o0
    ! Following is V9 "rd %ccr,%o0" instruction. However! V8
    ! specification says that it ("rd %asr2,%o0" in V8 terms) does
    ! not cause illegal_instruction trap. It therefore can be used
    ! to determine if the CPU the code is executing on is V8- or
    ! V9-compliant, as V9 returns a distinct value of 0x99,
    ! "negative" and "borrow" bits set in both %icc and %xcc.
    .word    0x91408000    !rd    %ccr,%o0
    cmp    %o0,0x99
    bne    .v8
    nop
            ! Even though we do not use %fp register bank,
            ! we wipe it as memcpy might have used it...
            .word    0xbfa00040    !fmovd    %f0,%f62
            .word    0xbba00040    !...
            .word    0xb7a00040
            .word    0xb3a00040
            .word    0xafa00040
            .word    0xaba00040
            .word    0xa7a00040
            .word    0xa3a00040
            .word    0x9fa00040
            .word    0x9ba00040
            .word    0x97a00040
            .word    0x93a00040
            .word    0x8fa00040
            .word    0x8ba00040
            .word    0x87a00040
            .word    0x83a00040    !fmovd    %f0,%f32
.v8:            fmovs    %f1,%f31
    clr    %o0
            fmovs    %f0,%f30
    clr    %o1
            fmovs    %f1,%f29
    clr    %o2
            fmovs    %f0,%f28
    clr    %o3
            fmovs    %f1,%f27
    clr    %o4
            fmovs    %f0,%f26
    clr    %o5
            fmovs    %f1,%f25
    clr    %o7
            fmovs    %f0,%f24
    clr    %l0
            fmovs    %f1,%f23
    clr    %l1
            fmovs    %f0,%f22
    clr    %l2
            fmovs    %f1,%f21
    clr    %l3
            fmovs    %f0,%f20
    clr    %l4
            fmovs    %f1,%f19
    clr    %l5
            fmovs    %f0,%f18
    clr    %l6
            fmovs    %f1,%f17
    clr    %l7
            fmovs    %f0,%f16
    clr    %i0
            fmovs    %f1,%f15
    clr    %i1
            fmovs    %f0,%f14
    clr    %i2
            fmovs    %f1,%f13
    clr    %i3
            fmovs    %f0,%f12
    clr    %i4
            fmovs    %f1,%f11
    clr    %i5
            fmovs    %f0,%f10
    clr    %g1
            fmovs    %f1,%f9
    clr    %g2
            fmovs    %f0,%f8
    clr    %g3
            fmovs    %f1,%f7
    clr    %g4
            fmovs    %f0,%f6
    clr    %g5
            fmovs    %f1,%f5
            fmovs    %f0,%f4
            fmovs    %f1,%f3
            fmovs    %f0,%f2
 
    add    %fp,BIAS,%i0    ! return pointer to caller´s top of stack
 
    ret
    restore
 
.zero:    .long    0x0,0x0
.PIC.zero.up:
    retl
    add    %o0,%o7,%o0
#ifdef DEBUG
.global    walk_reg_wins
.type    walk_reg_wins,#function
walk_reg_wins:
#endif
.walk.reg.wins:
    save    %sp,FRAME,%sp
    cmp    %i7,%o7
    be    2f
    clr    %o0
    cmp    %o7,0    ! compiler never cleans %o7...
    be    1f    ! could have been a leaf function...
    clr    %o1
    call    .walk.reg.wins
    nop
1:    clr    %o2
    clr    %o3
    clr    %o4
    clr    %o5
    clr    %o7
    clr    %l0
    clr    %l1
    clr    %l2
    clr    %l3
    clr    %l4
    clr    %l5
    clr    %l6
    clr    %l7
    add    %o0,1,%i0    ! used for debugging
2:    ret
    restore
.size    OPENSSL_wipe_cpu,.-OPENSSL_wipe_cpu
 
.global    OPENSSL_atomic_add
.type    OPENSSL_atomic_add,#function
.align    32
OPENSSL_atomic_add:
#ifndef ABI64
    subcc    %g0,1,%o2
    .word    0x95408000    !rd    %ccr,%o2, see comment above
    cmp    %o2,0x99
    be    .v9
    nop
    save    %sp,FRAME,%sp
    ba    .enter
    nop
#ifdef __sun
! Note that you do not have to link with libthread to call thr_yield,
! as libc provides a stub, which is overloaded the moment you link
! with *either* libpthread or libthread...
#define    YIELD_CPU    thr_yield
#else
! applies at least to Linux and FreeBSD... Feedback expected...
#define    YIELD_CPU    sched_yield
#endif
.spin:    call    YIELD_CPU
    nop
.enter:    ld    [%i0],%i2
    cmp    %i2,-4096
    be    .spin
    mov    -1,%i2
    swap    [%i0],%i2
    cmp    %i2,-1
    be    .spin
    add    %i2,%i1,%i2
    stbar
    st    %i2,[%i0]
    sra    %i2,%g0,%i0
    ret
    restore
.v9:
#endif
    ld    [%o0],%o2
1:    add    %o1,%o2,%o3
    .word    0xd7e2100a    !cas [%o0],%o2,%o3, compare [%o0] with %o2 and swap %o3
    cmp    %o2,%o3
    bne    1b
    mov    %o3,%o2        ! cas is always fetching to dest. register
    add    %o1,%o2,%o0    ! OpenSSL expects the new value
    retl
    sra    %o0,%g0,%o0    ! we return signed int, remember?
.size    OPENSSL_atomic_add,.-OPENSSL_atomic_add
 
.global    _sparcv9_rdtick
.align    32
_sparcv9_rdtick:
    subcc    %g0,1,%o0
    .word    0x91408000    !rd    %ccr,%o0
    cmp    %o0,0x99
    bne    .notick
    xor    %o0,%o0,%o0
    .word    0x91410000    !rd    %tick,%o0
    retl
    .word    0x93323020    !srlx    %o0,32,%o1
.notick:
    retl
    xor    %o1,%o1,%o1
.type    _sparcv9_rdtick,#function
.size    _sparcv9_rdtick,.-_sparcv9_rdtick
 
.global    _sparcv9_vis1_probe
.align    8
_sparcv9_vis1_probe:
    add    %sp,BIAS+2,%o1
    .word    0xc19a5a40    !ldda    [%o1]ASI_FP16_P,%f0
    retl
    .word    0x81b00d80    !fxor    %f0,%f0,%f0
.type    _sparcv9_vis1_probe,#function
.size    _sparcv9_vis1_probe,.-_sparcv9_vis1_probe
 
! Probe and instrument VIS1 instruction. Output is number of cycles it
! takes to execute rdtick and pair of VIS1 instructions. US-Tx VIS unit
! is slow (documented to be 6 cycles on T2) and the core is in-order
! single-issue, it should be possible to distinguish Tx reliably...
! Observed return values are:
!
!    UltraSPARC IIe        7
!    UltraSPARC III        7
!    UltraSPARC T1        24
!    SPARC T4        65(*)
!
! (*)    result has lesser to do with VIS instruction latencies, rdtick
!    appears that slow, but it does the trick in sense that FP and
!    VIS code paths are still slower than integer-only ones.
!
! Numbers for T2 and SPARC64 V-VII are more than welcomed.
!
! It would be possible to detect specifically US-T1 by instrumenting
! fmul8ulx16, which is emulated on T1 and as such accounts for quite
! a lot of %tick-s, couple of thousand on Linux...
.global    _sparcv9_vis1_instrument
.align    8
_sparcv9_vis1_instrument:
    .word    0x81b00d80    !fxor    %f0,%f0,%f0
    .word    0x85b08d82    !fxor    %f2,%f2,%f2
    .word    0x91410000    !rd    %tick,%o0
    .word    0x81b00d80    !fxor    %f0,%f0,%f0
    .word    0x85b08d82    !fxor    %f2,%f2,%f2
    .word    0x93410000    !rd    %tick,%o1
    .word    0x81b00d80    !fxor    %f0,%f0,%f0
    .word    0x85b08d82    !fxor    %f2,%f2,%f2
    .word    0x95410000    !rd    %tick,%o2
    .word    0x81b00d80    !fxor    %f0,%f0,%f0
    .word    0x85b08d82    !fxor    %f2,%f2,%f2
    .word    0x97410000    !rd    %tick,%o3
    .word    0x81b00d80    !fxor    %f0,%f0,%f0
    .word    0x85b08d82    !fxor    %f2,%f2,%f2
    .word    0x99410000    !rd    %tick,%o4
 
    ! calculate intervals
    sub    %o1,%o0,%o0
    sub    %o2,%o1,%o1
    sub    %o3,%o2,%o2
    sub    %o4,%o3,%o3
 
    ! find minimum value
    cmp    %o0,%o1
    .word    0x38680002    !bgu,a    %xcc,.+8
    mov    %o1,%o0
    cmp    %o0,%o2
    .word    0x38680002    !bgu,a    %xcc,.+8
    mov    %o2,%o0
    cmp    %o0,%o3
    .word    0x38680002    !bgu,a    %xcc,.+8
    mov    %o3,%o0
 
    retl
    nop
.type    _sparcv9_vis1_instrument,#function
.size    _sparcv9_vis1_instrument,.-_sparcv9_vis1_instrument
 
.global    _sparcv9_vis2_probe
.align    8
_sparcv9_vis2_probe:
    retl
    .word    0x81b00980    !bshuffle    %f0,%f0,%f0
.type    _sparcv9_vis2_probe,#function
.size    _sparcv9_vis2_probe,.-_sparcv9_vis2_probe
 
.global    _sparcv9_fmadd_probe
.align    8
_sparcv9_fmadd_probe:
    .word    0x81b00d80    !fxor    %f0,%f0,%f0
    .word    0x85b08d82    !fxor    %f2,%f2,%f2
    retl
    .word    0x81b80440    !fmaddd    %f0,%f0,%f2,%f0
.type    _sparcv9_fmadd_probe,#function
.size    _sparcv9_fmadd_probe,.-_sparcv9_fmadd_probe
 
.global    _sparcv9_rdcfr
.align    8
_sparcv9_rdcfr:
    retl
    .word    0x91468000    !rd    %asr26,%o0
.type    _sparcv9_rdcfr,#function
.size    _sparcv9_rdcfr,.-_sparcv9_rdcfr
 
.global    _sparcv9_vis3_probe
.align    8
_sparcv9_vis3_probe:
    retl
    .word    0x81b022a0    !xmulx    %g0,%g0,%g0
.type    _sparcv9_vis3_probe,#function
.size    _sparcv9_vis3_probe,.-_sparcv9_vis3_probe
 
.global    _sparcv9_random
.align    8
_sparcv9_random:
    retl
    .word    0x91b002a0    !random    %o0
.type    _sparcv9_random,#function
.size    _sparcv9_random,.-_sparcv9_vis3_probe
 
.global    _sparcv9_fjaesx_probe
.align    8
_sparcv9_fjaesx_probe:
    .word    0x81b09206    !faesencx %f2,%f6,%f0
    retl
    nop
.size    _sparcv9_fjaesx_probe,.-_sparcv9_fjaesx_probe
 
.global    OPENSSL_cleanse
.align    32
OPENSSL_cleanse:
    cmp    %o1,14
    nop
#ifdef ABI64
    bgu    %xcc,.Lot
#else
    bgu    .Lot
#endif
    cmp    %o1,0
    bne    .Little
    nop
    retl
    nop
 
.Little:
    stb    %g0,[%o0]
    subcc    %o1,1,%o1
    bnz    .Little
    add    %o0,1,%o0
    retl
    nop
.align    32
.Lot:
#ifndef ABI64
    subcc    %g0,1,%g1
    ! see above for explanation
    .word    0x83408000    !rd    %ccr,%g1
    cmp    %g1,0x99
    bne    .v8lot
    nop
#endif
 
.v9lot:    andcc    %o0,7,%g0
    bz    .v9aligned
    nop
    stb    %g0,[%o0]
    sub    %o1,1,%o1
    ba    .v9lot
    add    %o0,1,%o0
.align    16,0x01000000
.v9aligned:
    .word    0xc0720000    !stx    %g0,[%o0]
    sub    %o1,8,%o1
    andcc    %o1,-8,%g0
#ifdef ABI64
    .word    0x126ffffd    !bnz    %xcc,.v9aligned
#else
    .word    0x124ffffd    !bnz    %icc,.v9aligned
#endif
    add    %o0,8,%o0
 
    cmp    %o1,0
    bne    .Little
    nop
    retl
    nop
#ifndef ABI64
.v8lot:    andcc    %o0,3,%g0
    bz    .v8aligned
    nop
    stb    %g0,[%o0]
    sub    %o1,1,%o1
    ba    .v8lot
    add    %o0,1,%o0
    nop
.v8aligned:
    st    %g0,[%o0]
    sub    %o1,4,%o1
    andcc    %o1,-4,%g0
    bnz    .v8aligned
    add    %o0,4,%o0
 
    cmp    %o1,0
    bne    .Little
    nop
    retl
    nop
#endif
.type    OPENSSL_cleanse,#function
.size    OPENSSL_cleanse,.-OPENSSL_cleanse
 
.global    CRYPTO_memcmp
.align    16
CRYPTO_memcmp:
    cmp    %o2,0
#ifdef ABI64
    beq,pn    %xcc,.Lno_data
#else
    beq    .Lno_data
#endif
    xor    %g1,%g1,%g1
    nop
 
.Loop_cmp:
    ldub    [%o0],%o3
    add    %o0,1,%o0
    ldub    [%o1],%o4
    add    %o1,1,%o1
    subcc    %o2,1,%o2
    xor    %o3,%o4,%o4
#ifdef ABI64
    bnz    %xcc,.Loop_cmp
#else
    bnz    .Loop_cmp
#endif
    or    %o4,%g1,%g1
 
    sub    %g0,%g1,%g1
    srl    %g1,31,%g1
.Lno_data:
    retl
    mov    %g1,%o0
.type    CRYPTO_memcmp,#function
.size    CRYPTO_memcmp,.-CRYPTO_memcmp
 
.global    _sparcv9_vis1_instrument_bus
.align    8
_sparcv9_vis1_instrument_bus:
    mov    %o1,%o3                    ! save cnt
    .word    0x99410000    !rd    %tick,%o4    ! tick
    mov    %o4,%o5                    ! lasttick = tick
    set    0,%g4                    ! diff
 
    andn    %o0,63,%g1
    .word    0xc1985e00    !ldda    [%g1]0xf0,%f0    ! block load
    .word    0x8143e040    !membar    #Sync
    .word    0xc1b85c00    !stda    %f0,[%g1]0xe0    ! block store and commit
    .word    0x8143e040    !membar    #Sync
    ld    [%o0],%o4
    add    %o4,%g4,%g4
    .word    0xc9e2100c    !cas    [%o0],%o4,%g4
 
.Loop:    .word    0x99410000    !rd    %tick,%o4
    sub    %o4,%o5,%g4                ! diff=tick-lasttick
    mov    %o4,%o5                    ! lasttick=tick
 
    andn    %o0,63,%g1
    .word    0xc1985e00    !ldda    [%g1]0xf0,%f0    ! block load
    .word    0x8143e040    !membar    #Sync
    .word    0xc1b85c00    !stda    %f0,[%g1]0xe0    ! block store and commit
    .word    0x8143e040    !membar    #Sync
    ld    [%o0],%o4
    add    %o4,%g4,%g4
    .word    0xc9e2100c    !cas    [%o0],%o4,%g4
    subcc    %o1,1,%o1                ! --$cnt
    bnz    .Loop
    add    %o0,4,%o0                ! ++$out
 
    retl
    mov    %o3,%o0
.type    _sparcv9_vis1_instrument_bus,#function
.size    _sparcv9_vis1_instrument_bus,.-_sparcv9_vis1_instrument_bus
 
.global    _sparcv9_vis1_instrument_bus2
.align    8
_sparcv9_vis1_instrument_bus2:
    mov    %o1,%o3                    ! save cnt
    sll    %o1,2,%o1                ! cnt*=4
 
    .word    0x99410000    !rd    %tick,%o4    ! tick
    mov    %o4,%o5                    ! lasttick = tick
    set    0,%g4                    ! diff
 
    andn    %o0,63,%g1
    .word    0xc1985e00    !ldda    [%g1]0xf0,%f0    ! block load
    .word    0x8143e040    !membar    #Sync
    .word    0xc1b85c00    !stda    %f0,[%g1]0xe0    ! block store and commit
    .word    0x8143e040    !membar    #Sync
    ld    [%o0],%o4
    add    %o4,%g4,%g4
    .word    0xc9e2100c    !cas    [%o0],%o4,%g4
 
    .word    0x99410000    !rd    %tick,%o4    ! tick
    sub    %o4,%o5,%g4                ! diff=tick-lasttick
    mov    %o4,%o5                    ! lasttick=tick
    mov    %g4,%g5                    ! lastdiff=diff
.Loop2:
    andn    %o0,63,%g1
    .word    0xc1985e00    !ldda    [%g1]0xf0,%f0    ! block load
    .word    0x8143e040    !membar    #Sync
    .word    0xc1b85c00    !stda    %f0,[%g1]0xe0    ! block store and commit
    .word    0x8143e040    !membar    #Sync
    ld    [%o0],%o4
    add    %o4,%g4,%g4
    .word    0xc9e2100c    !cas    [%o0],%o4,%g4
 
    subcc    %o2,1,%o2                ! --max
    bz    .Ldone2
    nop
 
    .word    0x99410000    !rd    %tick,%o4    ! tick
    sub    %o4,%o5,%g4                ! diff=tick-lasttick
    mov    %o4,%o5                    ! lasttick=tick
    cmp    %g4,%g5
    mov    %g4,%g5                    ! lastdiff=diff
 
    .word    0x83408000    !rd    %ccr,%g1
    and    %g1,4,%g1                ! isolate zero flag
    xor    %g1,4,%g1                ! flip zero flag
 
    subcc    %o1,%g1,%o1                ! conditional --$cnt
    bnz    .Loop2
    add    %o0,%g1,%o0                ! conditional ++$out
 
.Ldone2:
    srl    %o1,2,%o1
    retl
    sub    %o3,%o1,%o0
.type    _sparcv9_vis1_instrument_bus2,#function
.size    _sparcv9_vis1_instrument_bus2,.-_sparcv9_vis1_instrument_bus2
 
.section    ".init",#alloc,#execinstr
    call    OPENSSL_cpuid_setup
    nop