! 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