Commit 1a111921 authored by Andy Polyakov's avatar Andy Polyakov
Browse files

PA-RISC assembler pack update from HEAD.

parent 5d9bb428

crypto/aes/asm/aes-parisc.pl

0 → 100644
+1021 −0

File added.

Preview size limit exceeded, changes collapsed.

crypto/bn/asm/parisc-mont.pl

0 → 100644
+993 −0

File added.

Preview size limit exceeded, changes collapsed.

crypto/pariscid.pl

0 → 100644
+224 −0
Original line number Diff line number Diff line 
#!/usr/bin/env perl



$flavour = shift;

$output = shift;

open STDOUT,">$output";



if ($flavour =~ /64/) {

	$LEVEL		="2.0W";

	$SIZE_T		=8;

	$ST		="std";

} else {

	$LEVEL		="1.1";

	$SIZE_T		=4;

	$ST		="stw";

}



$rp="%r2";

$sp="%r30";

$rv="%r28";



$code=<<___;

	.LEVEL	$LEVEL

	.SPACE	\$TEXT\$

	.SUBSPA	\$CODE\$,QUAD=0,ALIGN=8,ACCESS=0x2C,CODE_ONLY



	.EXPORT	OPENSSL_cpuid_setup,ENTRY

	.ALIGN	8

OPENSSL_cpuid_setup

	.PROC

	.CALLINFO	NO_CALLS

	.ENTRY

	bv	($rp)

	.EXIT

	nop

	.PROCEND



	.EXPORT	OPENSSL_rdtsc,ENTRY

	.ALIGN	8

OPENSSL_rdtsc

	.PROC

	.CALLINFO	NO_CALLS

	.ENTRY

	mfctl	%cr16,$rv

	bv	($rp)

	.EXIT

	nop

	.PROCEND



	.EXPORT	OPENSSL_wipe_cpu,ENTRY

	.ALIGN	8

OPENSSL_wipe_cpu

	.PROC

	.CALLINFO	NO_CALLS

	.ENTRY

	xor		%r0,%r0,%r1

	fcpy,dbl	%fr0,%fr4

	xor		%r0,%r0,%r19

	fcpy,dbl	%fr0,%fr5

	xor		%r0,%r0,%r20

	fcpy,dbl	%fr0,%fr6

	xor		%r0,%r0,%r21

	fcpy,dbl	%fr0,%fr7

	xor		%r0,%r0,%r22

	fcpy,dbl	%fr0,%fr8

	xor		%r0,%r0,%r23

	fcpy,dbl	%fr0,%fr9

	xor		%r0,%r0,%r24

	fcpy,dbl	%fr0,%fr10

	xor		%r0,%r0,%r25

	fcpy,dbl	%fr0,%fr11

	xor		%r0,%r0,%r26

	fcpy,dbl	%fr0,%fr22

	xor		%r0,%r0,%r29

	fcpy,dbl	%fr0,%fr23

	xor		%r0,%r0,%r31

	fcpy,dbl	%fr0,%fr24

	fcpy,dbl	%fr0,%fr25

	fcpy,dbl	%fr0,%fr26

	fcpy,dbl	%fr0,%fr27

	fcpy,dbl	%fr0,%fr28

	fcpy,dbl	%fr0,%fr29

	fcpy,dbl	%fr0,%fr30

	fcpy,dbl	%fr0,%fr31

	bv		($rp)

	.EXIT

	ldo		0($sp),$rv

	.PROCEND

___

{

my $inp="%r26";

my $len="%r25";



$code.=<<___;

	.EXPORT	OPENSSL_cleanse,ENTRY,ARGW0=GR,ARGW1=GR

	.ALIGN	8

OPENSSL_cleanse

	.PROC

	.CALLINFO	NO_CALLS

	.ENTRY

	cmpib,*=	0,$len,Ldone

	nop

	cmpib,*>>=	15,$len,Little

	ldi		$SIZE_T-1,%r1



Lalign

	and,*<>		$inp,%r1,%r28

	b,n		Laligned

	stb		%r0,0($inp)

	ldo		-1($len),$len

	b		Lalign

	ldo		1($inp),$inp



Laligned

	andcm		$len,%r1,%r28

Lot

	$ST		%r0,0($inp)

	addib,*<>	-$SIZE_T,%r28,Lot

	ldo		$SIZE_T($inp),$inp



	and,*<>		$len,%r1,$len

	b,n		Ldone

Little

	stb		%r0,0($inp)

	addib,*<>	-1,$len,Little

	ldo		1($inp),$inp

Ldone

	bv		($rp)

	.EXIT

	nop

	.PROCEND

___

}

{

my ($out,$cnt,$max)=("%r26","%r25","%r24");

my ($tick,$lasttick)=("%r23","%r22");

my ($diff,$lastdiff)=("%r21","%r20");



$code.=<<___;

	.EXPORT	OPENSSL_instrument_bus,ENTRY,ARGW0=GR,ARGW1=GR

	.ALIGN	8

OPENSSL_instrument_bus

	.PROC

	.CALLINFO	NO_CALLS

	.ENTRY

	copy		$cnt,$rv

	mfctl		%cr16,$tick

	copy		$tick,$lasttick

	ldi		0,$diff



	fdc		0($out)

	ldw		0($out),$tick

	add		$diff,$tick,$tick

	stw		$tick,0($out)

Loop

	mfctl		%cr16,$tick

	sub		$tick,$lasttick,$diff

	copy		$tick,$lasttick



	fdc		0($out)

	ldw		0($out),$tick

	add		$diff,$tick,$tick

	stw		$tick,0($out)



	addib,<>	-1,$cnt,Loop

	addi		4,$out,$out



	bv		($rp)

	.EXIT

	sub		$rv,$cnt,$rv

	.PROCEND



	.EXPORT	OPENSSL_instrument_bus2,ENTRY,ARGW0=GR,ARGW1=GR

	.ALIGN	8

OPENSSL_instrument_bus2

	.PROC

	.CALLINFO	NO_CALLS

	.ENTRY

	copy		$cnt,$rv

	sub		%r0,$cnt,$cnt



	mfctl		%cr16,$tick

	copy		$tick,$lasttick

	ldi		0,$diff



	fdc		0($out)

	ldw		0($out),$tick

	add		$diff,$tick,$tick

	stw		$tick,0($out)



	mfctl		%cr16,$tick

	sub		$tick,$lasttick,$diff

	copy		$tick,$lasttick

Loop2

	copy		$diff,$lastdiff

	fdc		0($out)

	ldw		0($out),$tick

	add		$diff,$tick,$tick

	stw		$tick,0($out)



	addib,=		-1,$max,Ldone2

	nop



	mfctl		%cr16,$tick

	sub		$tick,$lasttick,$diff

	copy		$tick,$lasttick

	cmpclr,<>	$lastdiff,$diff,$tick

	ldi		1,$tick



	ldi		1,%r1

	xor		%r1,$tick,$tick

	addb,<>		$tick,$cnt,Loop2

	shladd,l	$tick,2,$out,$out

Ldone2

	bv		($rp)

	.EXIT

	add		$rv,$cnt,$rv

	.PROCEND

___

}

$code =~ s/cmpib,\*/comib,/gm if ($SIZE_T==4);

$code =~ s/,\*/,/gm if ($SIZE_T==4);

print $code;

close STDOUT;

crypto/rc4/asm/rc4-parisc.pl

0 → 100644
+313 −0
Original line number Diff line number Diff line 
#!/usr/bin/env perl



# ====================================================================

# Written by Andy Polyakov <appro@fy.chalmers.se> for the OpenSSL

# project. The module is, however, dual licensed under OpenSSL and

# CRYPTOGAMS licenses depending on where you obtain it. For further

# details see http://www.openssl.org/~appro/cryptogams/.

# ====================================================================



# RC4 for PA-RISC.



# June 2009.

#

# Performance is 33% better than gcc 3.2 generated code on PA-7100LC.

# For reference, [4x] unrolled loop is >40% faster than folded one.

# It's possible to unroll loop 8 times on PA-RISC 2.0, but improvement

# is believed to be not sufficient to justify the effort...

#

# Special thanks to polarhome.com for providing HP-UX account.



$0 =~ m/(.*[\/\\])[^\/\\]+$/; $dir=$1;



$flavour = shift;

$output = shift;

open STDOUT,">$output";



if ($flavour =~ /64/) {

	$LEVEL		="2.0W";

	$SIZE_T		=8;

	$FRAME_MARKER	=80;

	$SAVED_RP	=16;

	$PUSH		="std";

	$PUSHMA		="std,ma";

	$POP		="ldd";

	$POPMB		="ldd,mb";

} else {

	$LEVEL		="1.0";

	$SIZE_T		=4;

	$FRAME_MARKER	=48;

	$SAVED_RP	=20;

	$PUSH		="stw";

	$PUSHMA		="stwm";

	$POP		="ldw";

	$POPMB		="ldwm";

}



$FRAME=4*$SIZE_T+$FRAME_MARKER;	# 4 saved regs + frame marker

				#                [+ argument transfer]

$SZ=1;				# defaults to RC4_CHAR

if (open CONF,"<${dir}../../opensslconf.h") {

    while(<CONF>) {

	if (m/#\s*define\s+RC4_INT\s+(.*)/) {

	    $SZ = ($1=~/char$/) ? 1 : 4;

	    last;

	}

    }

    close CONF;

}



if ($SZ==1) {	# RC4_CHAR

    $LD="ldb";

    $LDX="ldbx";

    $MKX="addl";

    $ST="stb";

} else {	# RC4_INT (~5% faster than RC4_CHAR on PA-7100LC)

    $LD="ldw";

    $LDX="ldwx,s";

    $MKX="sh2addl";

    $ST="stw";

}



$key="%r26";

$len="%r25";

$inp="%r24";

$out="%r23";



@XX=("%r19","%r20");

@TX=("%r21","%r22");

$YY="%r28";

$TY="%r29";



$acc="%r1";

$ix="%r2";

$iy="%r3";

$dat0="%r4";

$dat1="%r5";

$rem="%r6";

$mask="%r31";



sub unrolledloopbody {

for ($i=0;$i<4;$i++) {

$code.=<<___;

	ldo	1($XX[0]),$XX[1]

	`sprintf("$LDX	%$TY(%$key),%$dat1") if ($i>0)`	

	and	$mask,$XX[1],$XX[1]

	$LDX	$YY($key),$TY

	$MKX	$YY,$key,$ix

	$LDX	$XX[1]($key),$TX[1]

	$MKX	$XX[0],$key,$iy

	$ST	$TX[0],0($ix)

	comclr,<> $XX[1],$YY,%r0	; conditional

	copy	$TX[0],$TX[1]		; move

	`sprintf("%sdep	%$dat1,%d,8,%$acc",$i==1?"z":"",8*($i-1)+7) if ($i>0)`

	$ST	$TY,0($iy)

	addl	$TX[0],$TY,$TY

	addl	$TX[1],$YY,$YY

	and	$mask,$TY,$TY

	and	$mask,$YY,$YY

___

push(@TX,shift(@TX)); push(@XX,shift(@XX));	# "rotate" registers

} }



sub foldedloop {

my ($label,$count)=@_;

$code.=<<___;

$label

	$MKX	$YY,$key,$iy

	$LDX	$YY($key),$TY

	$MKX	$XX[0],$key,$ix

	$ST	$TX[0],0($iy)

	ldo	1($XX[0]),$XX[0]

	$ST	$TY,0($ix)

	addl	$TX[0],$TY,$TY

	ldbx	$inp($out),$dat1

	and	$mask,$TY,$TY

	and	$mask,$XX[0],$XX[0]

	$LDX	$TY($key),$acc

	$LDX	$XX[0]($key),$TX[0]

	ldo	1($out),$out

	xor	$dat1,$acc,$acc

	addl	$TX[0],$YY,$YY

	stb	$acc,-1($out)

	addib,<> -1,$count,$label	; $count is always small

	and	$mask,$YY,$YY

___

}



$code=<<___;

	.LEVEL	$LEVEL

	.SPACE	\$TEXT\$

	.SUBSPA	\$CODE\$,QUAD=0,ALIGN=8,ACCESS=0x2C,CODE_ONLY



	.EXPORT	RC4,ENTRY,ARGW0=GR,ARGW1=GR,ARGW2=GR,ARGW3=GR

RC4

	.PROC

	.CALLINFO	FRAME=`$FRAME-4*$SIZE_T`,NO_CALLS,SAVE_RP,ENTRY_GR=6

	.ENTRY

	$PUSH	%r2,-$SAVED_RP(%sp)	; standard prologue

	$PUSHMA	%r3,$FRAME(%sp)

	$PUSH	%r4,`-$FRAME+1*$SIZE_T`(%sp)

	$PUSH	%r5,`-$FRAME+2*$SIZE_T`(%sp)

	$PUSH	%r6,`-$FRAME+3*$SIZE_T`(%sp)



	cmpib,*= 0,$len,L\$abort

	sub	$inp,$out,$inp		; distance between $inp and $out



	$LD	`0*$SZ`($key),$XX[0]

	$LD	`1*$SZ`($key),$YY

	ldo	`2*$SZ`($key),$key



	ldi	0xff,$mask

	ldi	3,$dat0		



	ldo	1($XX[0]),$XX[0]	; warm up loop

	and	$mask,$XX[0],$XX[0]

	$LDX	$XX[0]($key),$TX[0]

	addl	$TX[0],$YY,$YY

	cmpib,*>>= 6,$len,L\$oop1	; is $len large enough to bother?

	and	$mask,$YY,$YY



	and,<>	$out,$dat0,$rem		; is $out aligned?

	b	L\$alignedout

	subi	4,$rem,$rem

	sub	$len,$rem,$len

___

&foldedloop("L\$alignout",$rem);	# process till $out is aligned



$code.=<<___;

L\$alignedout				; $len is at least 4 here

	and,<>	$inp,$dat0,$acc		; is $inp aligned?

	b	L\$oop4

	sub	$inp,$acc,$rem		; align $inp



	sh3addl	$acc,%r0,$acc

	subi	32,$acc,$acc

	mtctl	$acc,%cr11		; load %sar with vshd align factor

	ldwx	$rem($out),$dat0

	ldo	4($rem),$rem

L\$oop4misalignedinp

___

&unrolledloopbody();

$code.=<<___;

	$LDX	$TY($key),$ix

	ldwx	$rem($out),$dat1

	ldo	-4($len),$len

	or	$ix,$acc,$acc		; last piece, no need to dep

	vshd	$dat0,$dat1,$iy		; align data

	copy	$dat1,$dat0

	xor	$iy,$acc,$acc

	stw	$acc,0($out)

	cmpib,*<< 3,$len,L\$oop4misalignedinp

	ldo	4($out),$out

	cmpib,*= 0,$len,L\$done

	nop

	b	L\$oop1

	nop



	.ALIGN	8

L\$oop4

___

&unrolledloopbody();

$code.=<<___;

	$LDX	$TY($key),$ix

	ldwx	$inp($out),$dat0

	ldo	-4($len),$len

	or	$ix,$acc,$acc		; last piece, no need to dep

	xor	$dat0,$acc,$acc

	stw	$acc,0($out)

	cmpib,*<< 3,$len,L\$oop4

	ldo	4($out),$out

	cmpib,*= 0,$len,L\$done

	nop

___

&foldedloop("L\$oop1",$len);

$code.=<<___;

L\$done

	$POP	`-$FRAME-$SAVED_RP`(%sp),%r2

	ldo	-1($XX[0]),$XX[0]	; chill out loop

	sub	$YY,$TX[0],$YY

	and	$mask,$XX[0],$XX[0]

	and	$mask,$YY,$YY

	$ST	$XX[0],`-2*$SZ`($key)

	$ST	$YY,`-1*$SZ`($key)

	$POP	`-$FRAME+1*$SIZE_T`(%sp),%r4

	$POP	`-$FRAME+2*$SIZE_T`(%sp),%r5

	$POP	`-$FRAME+3*$SIZE_T`(%sp),%r6

L\$abort

	bv	(%r2)

	.EXIT

	$POPMB	-$FRAME(%sp),%r3

	.PROCEND

___



$code.=<<___;



	.EXPORT	RC4_set_key,ENTRY,ARGW0=GR,ARGW1=GR,ARGW2=GR

	.ALIGN	8

RC4_set_key

	.PROC

	.CALLINFO	NO_CALLS

	.ENTRY

	$ST	%r0,`0*$SZ`($key)

	$ST	%r0,`1*$SZ`($key)

	ldo	`2*$SZ`($key),$key

	copy	%r0,@XX[0]

L\$1st

	$ST	@XX[0],0($key)

	ldo	1(@XX[0]),@XX[0]

	bb,>=	@XX[0],`31-8`,L\$1st	; @XX[0]<256

	ldo	$SZ($key),$key



	ldo	`-256*$SZ`($key),$key	; rewind $key

	addl	$len,$inp,$inp		; $inp to point at the end

	sub	%r0,$len,%r23		; inverse index

	copy	%r0,@XX[0]

	copy	%r0,@XX[1]

	ldi	0xff,$mask



L\$2nd

	$LDX	@XX[0]($key),@TX[0]

	ldbx	%r23($inp),@TX[1]

	addi,nuv 1,%r23,%r23		; increment and conditional

	sub	%r0,$len,%r23		; inverse index

	addl	@TX[0],@XX[1],@XX[1]

	addl	@TX[1],@XX[1],@XX[1]

	and	$mask,@XX[1],@XX[1]

	$MKX	@XX[0],$key,$TY

	$LDX	@XX[1]($key),@TX[1]

	$MKX	@XX[1],$key,$YY

	ldo	1(@XX[0]),@XX[0]

	$ST	@TX[0],0($YY)

	bb,>=	@XX[0],`31-8`,L\$2nd	; @XX[0]<256

	$ST	@TX[1],0($TY)



	bv,n	(%r2)

	.EXIT

	nop

	.PROCEND



	.EXPORT	RC4_options,ENTRY

	.ALIGN	8

RC4_options

	.PROC

	.CALLINFO	NO_CALLS

	.ENTRY

	blr	%r0,%r28

	ldi	3,%r1

L\$pic

	andcm	%r28,%r1,%r28

	bv	(%r2)

	.EXIT

	ldo	L\$opts-L\$pic(%r28),%r28

	.PROCEND

	.ALIGN	8

L\$opts

	.STRINGZ "rc4(4x,`$SZ==1?"char":"int"`)"

	.STRINGZ "RC4 for PA-RISC, CRYPTOGAMS by <appro\@openssl.org>"

___

$code =~ s/\`([^\`]*)\`/eval $1/gem;

$code =~ s/cmpib,\*/comib,/gm if ($SIZE_T==4);



print $code;

close STDOUT;

crypto/sha/asm/sha1-parisc.pl

0 → 100644
+259 −0
Original line number Diff line number Diff line 
#!/usr/bin/env perl



# ====================================================================

# Written by Andy Polyakov <appro@fy.chalmers.se> for the OpenSSL

# project. The module is, however, dual licensed under OpenSSL and

# CRYPTOGAMS licenses depending on where you obtain it. For further

# details see http://www.openssl.org/~appro/cryptogams/.

# ====================================================================



# SHA1 block procedure for PA-RISC.



# June 2009.

#

# On PA-7100LC performance is >30% better than gcc 3.2 generated code

# for aligned input and >50% better for unaligned. Compared to vendor

# compiler on PA-8600 it's almost 60% faster in 64-bit build and just

# few percent faster in 32-bit one (this for aligned input, data for

# unaligned input is not available).

#

# Special thanks to polarhome.com for providing HP-UX account.



$flavour = shift;

$output = shift;

open STDOUT,">$output";



if ($flavour =~ /64/) {

	$LEVEL		="2.0W";

	$SIZE_T		=8;

	$FRAME_MARKER	=80;

	$SAVED_RP	=16;

	$PUSH		="std";

	$PUSHMA		="std,ma";

	$POP		="ldd";

	$POPMB		="ldd,mb";

} else {

	$LEVEL		="1.0";

	$SIZE_T		=4;

	$FRAME_MARKER	=48;

	$SAVED_RP	=20;

	$PUSH		="stw";

	$PUSHMA		="stwm";

	$POP		="ldw";

	$POPMB		="ldwm";

}



$FRAME=14*$SIZE_T+$FRAME_MARKER;# 14 saved regs + frame marker

				#                 [+ argument transfer]

$ctx="%r26";		# arg0

$inp="%r25";		# arg1

$num="%r24";		# arg2



$t0="%r28";

$t1="%r29";

$K="%r31";



@X=("%r1", "%r2", "%r3", "%r4", "%r5", "%r6", "%r7", "%r8",

    "%r9", "%r10","%r11","%r12","%r13","%r14","%r15","%r16",$t0);



@V=($A,$B,$C,$D,$E)=("%r19","%r20","%r21","%r22","%r23");



sub BODY_00_19 {

my ($i,$a,$b,$c,$d,$e)=@_;

my $j=$i+1;

$code.=<<___ if ($i<15);

	addl	$K,$e,$e	; $i

	shd	$a,$a,27,$t1

	addl	@X[$i],$e,$e

	and	$c,$b,$t0

	addl	$t1,$e,$e

	andcm	$d,$b,$t1

	shd	$b,$b,2,$b

	or	$t1,$t0,$t0

	addl	$t0,$e,$e

___

$code.=<<___ if ($i>=15);	# with forward Xupdate

	addl	$K,$e,$e	; $i

	shd	$a,$a,27,$t1

	xor	@X[($j+2)%16],@X[$j%16],@X[$j%16]

	addl	@X[$i%16],$e,$e

	and	$c,$b,$t0

	xor	@X[($j+8)%16],@X[$j%16],@X[$j%16]

	addl	$t1,$e,$e

	andcm	$d,$b,$t1

	shd	$b,$b,2,$b

	or	$t1,$t0,$t0

	xor	@X[($j+13)%16],@X[$j%16],@X[$j%16]

	add	$t0,$e,$e

	shd	@X[$j%16],@X[$j%16],31,@X[$j%16]

___

}



sub BODY_20_39 {

my ($i,$a,$b,$c,$d,$e)=@_;

my $j=$i+1;

$code.=<<___ if ($i<79);

	xor	@X[($j+2)%16],@X[$j%16],@X[$j%16]	; $i

	addl	$K,$e,$e

	shd	$a,$a,27,$t1

	xor	@X[($j+8)%16],@X[$j%16],@X[$j%16]

	addl	@X[$i%16],$e,$e

	xor	$b,$c,$t0

	xor	@X[($j+13)%16],@X[$j%16],@X[$j%16]

	addl	$t1,$e,$e

	shd	$b,$b,2,$b

	xor	$d,$t0,$t0

	shd	@X[$j%16],@X[$j%16],31,@X[$j%16]

	addl	$t0,$e,$e

___

$code.=<<___ if ($i==79);	# with context load

	ldw	0($ctx),@X[0]	; $i

	addl	$K,$e,$e

	shd	$a,$a,27,$t1

	ldw	4($ctx),@X[1]

	addl	@X[$i%16],$e,$e

	xor	$b,$c,$t0

	ldw	8($ctx),@X[2]

	addl	$t1,$e,$e

	shd	$b,$b,2,$b

	xor	$d,$t0,$t0

	ldw	12($ctx),@X[3]

	addl	$t0,$e,$e

	ldw	16($ctx),@X[4]

___

}



sub BODY_40_59 {

my ($i,$a,$b,$c,$d,$e)=@_;

my $j=$i+1;

$code.=<<___;

	shd	$a,$a,27,$t1	; $i

	addl	$K,$e,$e

	xor	@X[($j+2)%16],@X[$j%16],@X[$j%16]

	xor	$d,$c,$t0

	addl	@X[$i%16],$e,$e

	xor	@X[($j+8)%16],@X[$j%16],@X[$j%16]

	and	$b,$t0,$t0

	addl	$t1,$e,$e

	shd	$b,$b,2,$b

	xor	@X[($j+13)%16],@X[$j%16],@X[$j%16]

	addl	$t0,$e,$e

	and	$d,$c,$t1

	shd	@X[$j%16],@X[$j%16],31,@X[$j%16]

	addl	$t1,$e,$e

___

}



$code=<<___;

	.LEVEL	$LEVEL

	.SPACE	\$TEXT\$

	.SUBSPA	\$CODE\$,QUAD=0,ALIGN=8,ACCESS=0x2C,CODE_ONLY



	.EXPORT	sha1_block_data_order,ENTRY,ARGW0=GR,ARGW1=GR,ARGW2=GR

sha1_block_data_order

	.PROC

	.CALLINFO	FRAME=`$FRAME-14*$SIZE_T`,NO_CALLS,SAVE_RP,ENTRY_GR=16

	.ENTRY

	$PUSH	%r2,-$SAVED_RP(%sp)	; standard prologue

	$PUSHMA	%r3,$FRAME(%sp)

	$PUSH	%r4,`-$FRAME+1*$SIZE_T`(%sp)

	$PUSH	%r5,`-$FRAME+2*$SIZE_T`(%sp)

	$PUSH	%r6,`-$FRAME+3*$SIZE_T`(%sp)

	$PUSH	%r7,`-$FRAME+4*$SIZE_T`(%sp)

	$PUSH	%r8,`-$FRAME+5*$SIZE_T`(%sp)

	$PUSH	%r9,`-$FRAME+6*$SIZE_T`(%sp)

	$PUSH	%r10,`-$FRAME+7*$SIZE_T`(%sp)

	$PUSH	%r11,`-$FRAME+8*$SIZE_T`(%sp)

	$PUSH	%r12,`-$FRAME+9*$SIZE_T`(%sp)

	$PUSH	%r13,`-$FRAME+10*$SIZE_T`(%sp)

	$PUSH	%r14,`-$FRAME+11*$SIZE_T`(%sp)

	$PUSH	%r15,`-$FRAME+12*$SIZE_T`(%sp)

	$PUSH	%r16,`-$FRAME+13*$SIZE_T`(%sp)



	ldw	0($ctx),$A

	ldw	4($ctx),$B

	ldw	8($ctx),$C

	ldw	12($ctx),$D

	ldw	16($ctx),$E



	extru	$inp,31,2,$t0		; t0=inp&3;

	sh3addl	$t0,%r0,$t0		; t0*=8;

	subi	32,$t0,$t0		; t0=32-t0;

	mtctl	$t0,%cr11		; %sar=t0;



L\$oop

	ldi	3,$t0

	andcm	$inp,$t0,$t0		; 64-bit neutral

___

	for ($i=0;$i<15;$i++) {		# load input block

	$code.="\tldw	`4*$i`($t0),@X[$i]\n";		}

$code.=<<___;

	cmpb,*=	$inp,$t0,L\$aligned

	ldw	60($t0),@X[15]

	ldw	64($t0),@X[16]

___

	for ($i=0;$i<16;$i++) {		# align input

	$code.="\tvshd	@X[$i],@X[$i+1],@X[$i]\n";	}

$code.=<<___;

L\$aligned

	ldil	L'0x5a827000,$K		; K_00_19

	ldo	0x999($K),$K

___

for ($i=0;$i<20;$i++)   { &BODY_00_19($i,@V); unshift(@V,pop(@V)); }

$code.=<<___;

	ldil	L'0x6ed9e000,$K		; K_20_39

	ldo	0xba1($K),$K

___



for (;$i<40;$i++)       { &BODY_20_39($i,@V); unshift(@V,pop(@V)); }

$code.=<<___;

	ldil	L'0x8f1bb000,$K		; K_40_59

	ldo	0xcdc($K),$K

___



for (;$i<60;$i++)       { &BODY_40_59($i,@V); unshift(@V,pop(@V)); }

$code.=<<___;

	ldil	L'0xca62c000,$K		; K_60_79

	ldo	0x1d6($K),$K

___

for (;$i<80;$i++)       { &BODY_20_39($i,@V); unshift(@V,pop(@V)); }



$code.=<<___;

	addl	@X[0],$A,$A

	addl	@X[1],$B,$B

	addl	@X[2],$C,$C

	addl	@X[3],$D,$D

	addl	@X[4],$E,$E

	stw	$A,0($ctx)

	stw	$B,4($ctx)

	stw	$C,8($ctx)

	stw	$D,12($ctx)

	stw	$E,16($ctx)

	addib,*<> -1,$num,L\$oop

	ldo	64($inp),$inp



	$POP	`-$FRAME-$SAVED_RP`(%sp),%r2	; standard epilogue

	$POP	`-$FRAME+1*$SIZE_T`(%sp),%r4

	$POP	`-$FRAME+2*$SIZE_T`(%sp),%r5

	$POP	`-$FRAME+3*$SIZE_T`(%sp),%r6

	$POP	`-$FRAME+4*$SIZE_T`(%sp),%r7

	$POP	`-$FRAME+5*$SIZE_T`(%sp),%r8

	$POP	`-$FRAME+6*$SIZE_T`(%sp),%r9

	$POP	`-$FRAME+7*$SIZE_T`(%sp),%r10

	$POP	`-$FRAME+8*$SIZE_T`(%sp),%r11

	$POP	`-$FRAME+9*$SIZE_T`(%sp),%r12

	$POP	`-$FRAME+10*$SIZE_T`(%sp),%r13

	$POP	`-$FRAME+11*$SIZE_T`(%sp),%r14

	$POP	`-$FRAME+12*$SIZE_T`(%sp),%r15

	$POP	`-$FRAME+13*$SIZE_T`(%sp),%r16

	bv	(%r2)

	.EXIT

	$POPMB	-$FRAME(%sp),%r3

	.PROCEND

	.STRINGZ "SHA1 block transform for PA-RISC, CRYPTOGAMS by <appro\@openssl.org>"

___



$code =~ s/\`([^\`]*)\`/eval $1/gem;

$code =~ s/,\*/,/gm if ($SIZE_T==4);

print $code;

close STDOUT;