mirror of
https://github.com/guanzhi/GmSSL.git
synced 2026-09-23 22:03:48 +08:00
update
This commit is contained in:
Zhi Guan
@@ -56,25 +56,49 @@ sha256-ia64.s: asm/sha512-ia64.pl
|
||||
sha512-ia64.s: asm/sha512-ia64.pl
|
||||
(cd asm; $(PERL) sha512-ia64.pl ../$@ $(CFLAGS))
|
||||
|
||||
sha256-armv4.s: asm/sha256-armv4.pl
|
||||
$(PERL) $< $@
|
||||
sha256-armv4.S: asm/sha256-armv4.pl
|
||||
$(PERL) $< $(PERLASM_SCHEME) $@
|
||||
|
||||
sha1-alpha.s: asm/sha1-alpha.pl
|
||||
(preproc=$$$$.$@.S; trap "rm $$preproc" INT; \
|
||||
$(PERL) asm/sha1-alpha.pl > $$preproc && \
|
||||
$(CC) -E -P $$preproc > $@ && rm $$preproc)
|
||||
|
||||
# Solaris make has to be explicitly told
|
||||
sha1-x86_64.s: asm/sha1-x86_64.pl; $(PERL) asm/sha1-x86_64.pl $(PERLASM_SCHEME) > $@
|
||||
sha1-mb-x86_64.s: asm/sha1-mb-x86_64.pl; $(PERL) asm/sha1-mb-x86_64.pl $(PERLASM_SCHEME) > $@
|
||||
sha256-x86_64.s:asm/sha512-x86_64.pl; $(PERL) asm/sha512-x86_64.pl $(PERLASM_SCHEME) $@
|
||||
sha256-mb-x86_64.s: asm/sha256-mb-x86_64.pl; $(PERL) asm/sha256-mb-x86_64.pl $(PERLASM_SCHEME) > $@
|
||||
sha512-x86_64.s:asm/sha512-x86_64.pl; $(PERL) asm/sha512-x86_64.pl $(PERLASM_SCHEME) $@
|
||||
sha1-sparcv9.s: asm/sha1-sparcv9.pl; $(PERL) asm/sha1-sparcv9.pl $@ $(CFLAGS)
|
||||
sha256-sparcv9.s:asm/sha512-sparcv9.pl; $(PERL) asm/sha512-sparcv9.pl $@ $(CFLAGS)
|
||||
sha512-sparcv9.s:asm/sha512-sparcv9.pl; $(PERL) asm/sha512-sparcv9.pl $@ $(CFLAGS)
|
||||
sha1-sparcv9.S: asm/sha1-sparcv9.pl; $(PERL) asm/sha1-sparcv9.pl $@ $(CFLAGS)
|
||||
sha256-sparcv9.S:asm/sha512-sparcv9.pl; $(PERL) asm/sha512-sparcv9.pl $@ $(CFLAGS)
|
||||
sha512-sparcv9.S:asm/sha512-sparcv9.pl; $(PERL) asm/sha512-sparcv9.pl $@ $(CFLAGS)
|
||||
|
||||
sha1-ppc.s: asm/sha1-ppc.pl; $(PERL) asm/sha1-ppc.pl $(PERLASM_SCHEME) $@
|
||||
sha256-ppc.s: asm/sha512-ppc.pl; $(PERL) asm/sha512-ppc.pl $(PERLASM_SCHEME) $@
|
||||
sha512-ppc.s: asm/sha512-ppc.pl; $(PERL) asm/sha512-ppc.pl $(PERLASM_SCHEME) $@
|
||||
sha256p8-ppc.s: asm/sha512p8-ppc.pl; $(PERL) asm/sha512p8-ppc.pl $(PERLASM_SCHEME) $@
|
||||
sha512p8-ppc.s: asm/sha512p8-ppc.pl; $(PERL) asm/sha512p8-ppc.pl $(PERLASM_SCHEME) $@
|
||||
|
||||
sha1-parisc.s: asm/sha1-parisc.pl; $(PERL) asm/sha1-parisc.pl $(PERLASM_SCHEME) $@
|
||||
sha256-parisc.s:asm/sha512-parisc.pl; $(PERL) asm/sha512-parisc.pl $(PERLASM_SCHEME) $@
|
||||
sha512-parisc.s:asm/sha512-parisc.pl; $(PERL) asm/sha512-parisc.pl $(PERLASM_SCHEME) $@
|
||||
|
||||
sha1-mips.S: asm/sha1-mips.pl; $(PERL) asm/sha1-mips.pl $(PERLASM_SCHEME) $@
|
||||
sha256-mips.S: asm/sha512-mips.pl; $(PERL) asm/sha512-mips.pl $(PERLASM_SCHEME) $@
|
||||
sha512-mips.S: asm/sha512-mips.pl; $(PERL) asm/sha512-mips.pl $(PERLASM_SCHEME) $@
|
||||
|
||||
# GNU make "catch all"
|
||||
sha1-%.s: asm/sha1-%.pl; $(PERL) $< $@
|
||||
sha256-%.s: asm/sha512-%.pl; $(PERL) $< $@
|
||||
sha512-%.s: asm/sha512-%.pl; $(PERL) $< $@
|
||||
sha1-%.S: asm/sha1-%.pl; $(PERL) $< $(PERLASM_SCHEME) $@
|
||||
sha256-%.S: asm/sha512-%.pl; $(PERL) $< $(PERLASM_SCHEME) $@
|
||||
sha512-%.S: asm/sha512-%.pl; $(PERL) $< $(PERLASM_SCHEME) $@
|
||||
|
||||
sha1-armv4-large.o: sha1-armv4-large.S
|
||||
sha256-armv4.o: sha256-armv4.S
|
||||
sha512-armv4.o: sha512-armv4.S
|
||||
sha1-armv8.o: sha1-armv8.S
|
||||
sha256-armv8.o: sha256-armv8.S
|
||||
sha512-armv8.o: sha512-armv8.S
|
||||
|
||||
files:
|
||||
$(PERL) $(TOP)/util/files.pl Makefile >> $(TOP)/MINFO
|
||||
@@ -100,6 +124,8 @@ tests:
|
||||
lint:
|
||||
lint -DLINT $(INCLUDES) $(SRC)>fluff
|
||||
|
||||
update: depend
|
||||
|
||||
depend:
|
||||
@[ -n "$(MAKEDEPEND)" ] # should be set by upper Makefile...
|
||||
$(MAKEDEPEND) -- $(CFLAG) $(INCLUDES) $(DEPFLAG) -- $(PROGS) $(LIBSRC)
|
||||
@@ -119,8 +145,11 @@ sha1_one.o: ../../include/openssl/opensslv.h ../../include/openssl/ossl_typ.h
|
||||
sha1_one.o: ../../include/openssl/safestack.h ../../include/openssl/sha.h
|
||||
sha1_one.o: ../../include/openssl/stack.h ../../include/openssl/symhacks.h
|
||||
sha1_one.o: sha1_one.c
|
||||
sha1dgst.o: ../../include/openssl/e_os2.h ../../include/openssl/opensslconf.h
|
||||
sha1dgst.o: ../../include/openssl/opensslv.h ../../include/openssl/sha.h
|
||||
sha1dgst.o: ../../include/openssl/crypto.h ../../include/openssl/e_os2.h
|
||||
sha1dgst.o: ../../include/openssl/opensslconf.h
|
||||
sha1dgst.o: ../../include/openssl/opensslv.h ../../include/openssl/ossl_typ.h
|
||||
sha1dgst.o: ../../include/openssl/safestack.h ../../include/openssl/sha.h
|
||||
sha1dgst.o: ../../include/openssl/stack.h ../../include/openssl/symhacks.h
|
||||
sha1dgst.o: ../md32_common.h sha1dgst.c sha_locl.h
|
||||
sha256.o: ../../include/openssl/crypto.h ../../include/openssl/e_os2.h
|
||||
sha256.o: ../../include/openssl/opensslconf.h ../../include/openssl/opensslv.h
|
||||
@@ -135,8 +164,11 @@ sha512.o: ../../include/openssl/opensslv.h ../../include/openssl/ossl_typ.h
|
||||
sha512.o: ../../include/openssl/safestack.h ../../include/openssl/sha.h
|
||||
sha512.o: ../../include/openssl/stack.h ../../include/openssl/symhacks.h
|
||||
sha512.o: ../cryptlib.h sha512.c
|
||||
sha_dgst.o: ../../include/openssl/e_os2.h ../../include/openssl/opensslconf.h
|
||||
sha_dgst.o: ../../include/openssl/opensslv.h ../../include/openssl/sha.h
|
||||
sha_dgst.o: ../../include/openssl/crypto.h ../../include/openssl/e_os2.h
|
||||
sha_dgst.o: ../../include/openssl/opensslconf.h
|
||||
sha_dgst.o: ../../include/openssl/opensslv.h ../../include/openssl/ossl_typ.h
|
||||
sha_dgst.o: ../../include/openssl/safestack.h ../../include/openssl/sha.h
|
||||
sha_dgst.o: ../../include/openssl/stack.h ../../include/openssl/symhacks.h
|
||||
sha_dgst.o: ../md32_common.h sha_dgst.c sha_locl.h
|
||||
sha_one.o: ../../include/openssl/crypto.h ../../include/openssl/e_os2.h
|
||||
sha_one.o: ../../include/openssl/opensslconf.h ../../include/openssl/opensslv.h
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
322
crypto/sha/asm/sha1-alpha.pl
Normal file
322
crypto/sha/asm/sha1-alpha.pl
Normal file
@@ -0,0 +1,322 @@
|
||||
#!/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 Alpha.
|
||||
|
||||
# On 21264 performance is 33% better than code generated by vendor
|
||||
# compiler, and 75% better than GCC [3.4], and in absolute terms is
|
||||
# 8.7 cycles per processed byte. Implementation features vectorized
|
||||
# byte swap, but not Xupdate.
|
||||
|
||||
@X=( "\$0", "\$1", "\$2", "\$3", "\$4", "\$5", "\$6", "\$7",
|
||||
"\$8", "\$9", "\$10", "\$11", "\$12", "\$13", "\$14", "\$15");
|
||||
$ctx="a0"; # $16
|
||||
$inp="a1";
|
||||
$num="a2";
|
||||
$A="a3";
|
||||
$B="a4"; # 20
|
||||
$C="a5";
|
||||
$D="t8";
|
||||
$E="t9"; @V=($A,$B,$C,$D,$E);
|
||||
$t0="t10"; # 24
|
||||
$t1="t11";
|
||||
$t2="ra";
|
||||
$t3="t12";
|
||||
$K="AT"; # 28
|
||||
|
||||
sub BODY_00_19 {
|
||||
my ($i,$a,$b,$c,$d,$e)=@_;
|
||||
my $j=$i+1;
|
||||
$code.=<<___ if ($i==0);
|
||||
ldq_u @X[0],0+0($inp)
|
||||
ldq_u @X[1],0+7($inp)
|
||||
___
|
||||
$code.=<<___ if (!($i&1) && $i<14);
|
||||
ldq_u @X[$i+2],($i+2)*4+0($inp)
|
||||
ldq_u @X[$i+3],($i+2)*4+7($inp)
|
||||
___
|
||||
$code.=<<___ if (!($i&1) && $i<15);
|
||||
extql @X[$i],$inp,@X[$i]
|
||||
extqh @X[$i+1],$inp,@X[$i+1]
|
||||
|
||||
or @X[$i+1],@X[$i],@X[$i] # pair of 32-bit values are fetched
|
||||
|
||||
srl @X[$i],24,$t0 # vectorized byte swap
|
||||
srl @X[$i],8,$t2
|
||||
|
||||
sll @X[$i],8,$t3
|
||||
sll @X[$i],24,@X[$i]
|
||||
zapnot $t0,0x11,$t0
|
||||
zapnot $t2,0x22,$t2
|
||||
|
||||
zapnot @X[$i],0x88,@X[$i]
|
||||
or $t0,$t2,$t0
|
||||
zapnot $t3,0x44,$t3
|
||||
sll $a,5,$t1
|
||||
|
||||
or @X[$i],$t0,@X[$i]
|
||||
addl $K,$e,$e
|
||||
and $b,$c,$t2
|
||||
zapnot $a,0xf,$a
|
||||
|
||||
or @X[$i],$t3,@X[$i]
|
||||
srl $a,27,$t0
|
||||
bic $d,$b,$t3
|
||||
sll $b,30,$b
|
||||
|
||||
extll @X[$i],4,@X[$i+1] # extract upper half
|
||||
or $t2,$t3,$t2
|
||||
addl @X[$i],$e,$e
|
||||
|
||||
addl $t1,$e,$e
|
||||
srl $b,32,$t3
|
||||
zapnot @X[$i],0xf,@X[$i]
|
||||
|
||||
addl $t0,$e,$e
|
||||
addl $t2,$e,$e
|
||||
or $t3,$b,$b
|
||||
___
|
||||
$code.=<<___ if (($i&1) && $i<15);
|
||||
sll $a,5,$t1
|
||||
addl $K,$e,$e
|
||||
and $b,$c,$t2
|
||||
zapnot $a,0xf,$a
|
||||
|
||||
srl $a,27,$t0
|
||||
addl @X[$i%16],$e,$e
|
||||
bic $d,$b,$t3
|
||||
sll $b,30,$b
|
||||
|
||||
or $t2,$t3,$t2
|
||||
addl $t1,$e,$e
|
||||
srl $b,32,$t3
|
||||
zapnot @X[$i],0xf,@X[$i]
|
||||
|
||||
addl $t0,$e,$e
|
||||
addl $t2,$e,$e
|
||||
or $t3,$b,$b
|
||||
___
|
||||
$code.=<<___ if ($i>=15); # with forward Xupdate
|
||||
sll $a,5,$t1
|
||||
addl $K,$e,$e
|
||||
and $b,$c,$t2
|
||||
xor @X[($j+2)%16],@X[$j%16],@X[$j%16]
|
||||
|
||||
zapnot $a,0xf,$a
|
||||
addl @X[$i%16],$e,$e
|
||||
bic $d,$b,$t3
|
||||
xor @X[($j+8)%16],@X[$j%16],@X[$j%16]
|
||||
|
||||
srl $a,27,$t0
|
||||
addl $t1,$e,$e
|
||||
or $t2,$t3,$t2
|
||||
xor @X[($j+13)%16],@X[$j%16],@X[$j%16]
|
||||
|
||||
sll $b,30,$b
|
||||
addl $t0,$e,$e
|
||||
srl @X[$j%16],31,$t1
|
||||
|
||||
addl $t2,$e,$e
|
||||
srl $b,32,$t3
|
||||
addl @X[$j%16],@X[$j%16],@X[$j%16]
|
||||
|
||||
or $t3,$b,$b
|
||||
zapnot @X[$i%16],0xf,@X[$i%16]
|
||||
or $t1,@X[$j%16],@X[$j%16]
|
||||
___
|
||||
}
|
||||
|
||||
sub BODY_20_39 {
|
||||
my ($i,$a,$b,$c,$d,$e)=@_;
|
||||
my $j=$i+1;
|
||||
$code.=<<___ if ($i<79); # with forward Xupdate
|
||||
sll $a,5,$t1
|
||||
addl $K,$e,$e
|
||||
zapnot $a,0xf,$a
|
||||
xor @X[($j+2)%16],@X[$j%16],@X[$j%16]
|
||||
|
||||
sll $b,30,$t3
|
||||
addl $t1,$e,$e
|
||||
xor $b,$c,$t2
|
||||
xor @X[($j+8)%16],@X[$j%16],@X[$j%16]
|
||||
|
||||
srl $b,2,$b
|
||||
addl @X[$i%16],$e,$e
|
||||
xor $d,$t2,$t2
|
||||
xor @X[($j+13)%16],@X[$j%16],@X[$j%16]
|
||||
|
||||
srl @X[$j%16],31,$t1
|
||||
addl $t2,$e,$e
|
||||
srl $a,27,$t0
|
||||
addl @X[$j%16],@X[$j%16],@X[$j%16]
|
||||
|
||||
or $t3,$b,$b
|
||||
addl $t0,$e,$e
|
||||
or $t1,@X[$j%16],@X[$j%16]
|
||||
___
|
||||
$code.=<<___ if ($i<77);
|
||||
zapnot @X[$i%16],0xf,@X[$i%16]
|
||||
___
|
||||
$code.=<<___ if ($i==79); # with context fetch
|
||||
sll $a,5,$t1
|
||||
addl $K,$e,$e
|
||||
zapnot $a,0xf,$a
|
||||
ldl @X[0],0($ctx)
|
||||
|
||||
sll $b,30,$t3
|
||||
addl $t1,$e,$e
|
||||
xor $b,$c,$t2
|
||||
ldl @X[1],4($ctx)
|
||||
|
||||
srl $b,2,$b
|
||||
addl @X[$i%16],$e,$e
|
||||
xor $d,$t2,$t2
|
||||
ldl @X[2],8($ctx)
|
||||
|
||||
srl $a,27,$t0
|
||||
addl $t2,$e,$e
|
||||
ldl @X[3],12($ctx)
|
||||
|
||||
or $t3,$b,$b
|
||||
addl $t0,$e,$e
|
||||
ldl @X[4],16($ctx)
|
||||
___
|
||||
}
|
||||
|
||||
sub BODY_40_59 {
|
||||
my ($i,$a,$b,$c,$d,$e)=@_;
|
||||
my $j=$i+1;
|
||||
$code.=<<___; # with forward Xupdate
|
||||
sll $a,5,$t1
|
||||
addl $K,$e,$e
|
||||
zapnot $a,0xf,$a
|
||||
xor @X[($j+2)%16],@X[$j%16],@X[$j%16]
|
||||
|
||||
srl $a,27,$t0
|
||||
and $b,$c,$t2
|
||||
and $b,$d,$t3
|
||||
xor @X[($j+8)%16],@X[$j%16],@X[$j%16]
|
||||
|
||||
sll $b,30,$b
|
||||
addl $t1,$e,$e
|
||||
xor @X[($j+13)%16],@X[$j%16],@X[$j%16]
|
||||
|
||||
srl @X[$j%16],31,$t1
|
||||
addl $t0,$e,$e
|
||||
or $t2,$t3,$t2
|
||||
and $c,$d,$t3
|
||||
|
||||
or $t2,$t3,$t2
|
||||
srl $b,32,$t3
|
||||
addl @X[$i%16],$e,$e
|
||||
addl @X[$j%16],@X[$j%16],@X[$j%16]
|
||||
|
||||
or $t3,$b,$b
|
||||
addl $t2,$e,$e
|
||||
or $t1,@X[$j%16],@X[$j%16]
|
||||
zapnot @X[$i%16],0xf,@X[$i%16]
|
||||
___
|
||||
}
|
||||
|
||||
$code=<<___;
|
||||
#ifdef __linux__
|
||||
#include <asm/regdef.h>
|
||||
#else
|
||||
#include <asm.h>
|
||||
#include <regdef.h>
|
||||
#endif
|
||||
|
||||
.text
|
||||
|
||||
.set noat
|
||||
.set noreorder
|
||||
.globl sha1_block_data_order
|
||||
.align 5
|
||||
.ent sha1_block_data_order
|
||||
sha1_block_data_order:
|
||||
lda sp,-64(sp)
|
||||
stq ra,0(sp)
|
||||
stq s0,8(sp)
|
||||
stq s1,16(sp)
|
||||
stq s2,24(sp)
|
||||
stq s3,32(sp)
|
||||
stq s4,40(sp)
|
||||
stq s5,48(sp)
|
||||
stq fp,56(sp)
|
||||
.mask 0x0400fe00,-64
|
||||
.frame sp,64,ra
|
||||
.prologue 0
|
||||
|
||||
ldl $A,0($ctx)
|
||||
ldl $B,4($ctx)
|
||||
sll $num,6,$num
|
||||
ldl $C,8($ctx)
|
||||
ldl $D,12($ctx)
|
||||
ldl $E,16($ctx)
|
||||
addq $inp,$num,$num
|
||||
|
||||
.Lloop:
|
||||
.set noreorder
|
||||
ldah $K,23170(zero)
|
||||
zapnot $B,0xf,$B
|
||||
lda $K,31129($K) # K_00_19
|
||||
___
|
||||
for ($i=0;$i<20;$i++) { &BODY_00_19($i,@V); unshift(@V,pop(@V)); }
|
||||
|
||||
$code.=<<___;
|
||||
ldah $K,28378(zero)
|
||||
lda $K,-5215($K) # K_20_39
|
||||
___
|
||||
for (;$i<40;$i++) { &BODY_20_39($i,@V); unshift(@V,pop(@V)); }
|
||||
|
||||
$code.=<<___;
|
||||
ldah $K,-28900(zero)
|
||||
lda $K,-17188($K) # K_40_59
|
||||
___
|
||||
for (;$i<60;$i++) { &BODY_40_59($i,@V); unshift(@V,pop(@V)); }
|
||||
|
||||
$code.=<<___;
|
||||
ldah $K,-13725(zero)
|
||||
lda $K,-15914($K) # K_60_79
|
||||
___
|
||||
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
|
||||
stl $A,0($ctx)
|
||||
stl $B,4($ctx)
|
||||
addq $inp,64,$inp
|
||||
stl $C,8($ctx)
|
||||
stl $D,12($ctx)
|
||||
stl $E,16($ctx)
|
||||
cmpult $inp,$num,$t1
|
||||
bne $t1,.Lloop
|
||||
|
||||
.set noreorder
|
||||
ldq ra,0(sp)
|
||||
ldq s0,8(sp)
|
||||
ldq s1,16(sp)
|
||||
ldq s2,24(sp)
|
||||
ldq s3,32(sp)
|
||||
ldq s4,40(sp)
|
||||
ldq s5,48(sp)
|
||||
ldq fp,56(sp)
|
||||
lda sp,64(sp)
|
||||
ret (ra)
|
||||
.end sha1_block_data_order
|
||||
.ascii "SHA1 block transform for Alpha, CRYPTOGAMS by <appro\@openssl.org>"
|
||||
.align 2
|
||||
___
|
||||
$output=shift and open STDOUT,">$output";
|
||||
print $code;
|
||||
close STDOUT;
|
||||
@@ -1,7 +1,7 @@
|
||||
#!/usr/bin/env perl
|
||||
|
||||
# ====================================================================
|
||||
# Written by Andy Polyakov <appro@fy.chalmers.se> for the OpenSSL
|
||||
# Written by Andy Polyakov <appro@openssl.org> 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/.
|
||||
@@ -47,6 +47,24 @@
|
||||
# Cortex A8 core and in absolute terms ~870 cycles per input block
|
||||
# [or 13.6 cycles per byte].
|
||||
|
||||
# February 2011.
|
||||
#
|
||||
# Profiler-assisted and platform-specific optimization resulted in 10%
|
||||
# improvement on Cortex A8 core and 12.2 cycles per byte.
|
||||
|
||||
# September 2013.
|
||||
#
|
||||
# Add NEON implementation (see sha1-586.pl for background info). On
|
||||
# Cortex A8 it was measured to process one byte in 6.7 cycles or >80%
|
||||
# faster than integer-only code. Because [fully unrolled] NEON code
|
||||
# is ~2.5x larger and there are some redundant instructions executed
|
||||
# when processing last block, improvement is not as big for smallest
|
||||
# blocks, only ~30%. Snapdragon S4 is a tad faster, 6.4 cycles per
|
||||
# byte, which is also >80% faster than integer-only code.
|
||||
|
||||
# May 2014.
|
||||
#
|
||||
# Add ARMv8 code path performing at 2.35 cpb on Apple A7.
|
||||
|
||||
while (($output=shift) && ($output!~/^\w[\w\-]*\.\w+$/)) {}
|
||||
open STDOUT,">$output";
|
||||
@@ -76,31 +94,41 @@ $code.=<<___;
|
||||
add $e,$K,$e,ror#2 @ E+=K_xx_xx
|
||||
ldr $t3,[$Xi,#2*4]
|
||||
eor $t0,$t0,$t1
|
||||
eor $t2,$t2,$t3
|
||||
eor $t2,$t2,$t3 @ 1 cycle stall
|
||||
eor $t1,$c,$d @ F_xx_xx
|
||||
mov $t0,$t0,ror#31
|
||||
add $e,$e,$a,ror#27 @ E+=ROR(A,27)
|
||||
eor $t0,$t0,$t2,ror#31
|
||||
str $t0,[$Xi,#-4]!
|
||||
$opt1 @ F_xx_xx
|
||||
$opt2 @ F_xx_xx
|
||||
add $e,$e,$t0 @ E+=X[i]
|
||||
str $t0,[$Xi,#-4]!
|
||||
___
|
||||
}
|
||||
|
||||
sub BODY_00_15 {
|
||||
my ($a,$b,$c,$d,$e)=@_;
|
||||
$code.=<<___;
|
||||
ldrb $t0,[$inp],#4
|
||||
ldrb $t1,[$inp,#-1]
|
||||
ldrb $t2,[$inp,#-2]
|
||||
#if __ARM_ARCH__<7
|
||||
ldrb $t1,[$inp,#2]
|
||||
ldrb $t0,[$inp,#3]
|
||||
ldrb $t2,[$inp,#1]
|
||||
add $e,$K,$e,ror#2 @ E+=K_00_19
|
||||
ldrb $t3,[$inp,#-3]
|
||||
add $e,$e,$a,ror#27 @ E+=ROR(A,27)
|
||||
orr $t0,$t1,$t0,lsl#24
|
||||
ldrb $t3,[$inp],#4
|
||||
orr $t0,$t0,$t1,lsl#8
|
||||
eor $t1,$c,$d @ F_xx_xx
|
||||
orr $t0,$t0,$t2,lsl#8
|
||||
orr $t0,$t0,$t3,lsl#16
|
||||
orr $t0,$t0,$t2,lsl#16
|
||||
add $e,$e,$a,ror#27 @ E+=ROR(A,27)
|
||||
orr $t0,$t0,$t3,lsl#24
|
||||
#else
|
||||
ldr $t0,[$inp],#4 @ handles unaligned
|
||||
add $e,$K,$e,ror#2 @ E+=K_00_19
|
||||
eor $t1,$c,$d @ F_xx_xx
|
||||
add $e,$e,$a,ror#27 @ E+=ROR(A,27)
|
||||
#ifdef __ARMEL__
|
||||
rev $t0,$t0 @ byte swap
|
||||
#endif
|
||||
#endif
|
||||
and $t1,$b,$t1,ror#2
|
||||
add $e,$e,$t0 @ E+=X[i]
|
||||
eor $t1,$t1,$d,ror#2 @ F_00_19(B,C,D)
|
||||
@@ -136,13 +164,25 @@ ___
|
||||
}
|
||||
|
||||
$code=<<___;
|
||||
#include "arm_arch.h"
|
||||
|
||||
.text
|
||||
.code 32
|
||||
|
||||
.global sha1_block_data_order
|
||||
.type sha1_block_data_order,%function
|
||||
|
||||
.align 2
|
||||
.align 5
|
||||
sha1_block_data_order:
|
||||
#if __ARM_MAX_ARCH__>=7
|
||||
sub r3,pc,#8 @ sha1_block_data_order
|
||||
ldr r12,.LOPENSSL_armcap
|
||||
ldr r12,[r3,r12] @ OPENSSL_armcap_P
|
||||
tst r12,#ARMV8_SHA1
|
||||
bne .LARMv8
|
||||
tst r12,#ARMV7_NEON
|
||||
bne .LNEON
|
||||
#endif
|
||||
stmdb sp!,{r4-r12,lr}
|
||||
add $len,$inp,$len,lsl#6 @ $len to point at the end of $inp
|
||||
ldmia $ctx,{$a,$b,$c,$d,$e}
|
||||
@@ -161,6 +201,7 @@ for($i=0;$i<5;$i++) {
|
||||
$code.=<<___;
|
||||
teq $Xi,sp
|
||||
bne .L_00_15 @ [((11+4)*5+2)*3]
|
||||
sub sp,sp,#25*4
|
||||
___
|
||||
&BODY_00_15(@V); unshift(@V,pop(@V));
|
||||
&BODY_16_19(@V); unshift(@V,pop(@V));
|
||||
@@ -170,7 +211,6 @@ ___
|
||||
$code.=<<___;
|
||||
|
||||
ldr $K,.LK_20_39 @ [+15+16*4]
|
||||
sub sp,sp,#25*4
|
||||
cmn sp,#0 @ [+3], clear carry to denote 20_39
|
||||
.L_20_39_or_60_79:
|
||||
___
|
||||
@@ -209,20 +249,435 @@ $code.=<<___;
|
||||
teq $inp,$len
|
||||
bne .Lloop @ [+18], total 1307
|
||||
|
||||
#if __ARM_ARCH__>=5
|
||||
ldmia sp!,{r4-r12,pc}
|
||||
#else
|
||||
ldmia sp!,{r4-r12,lr}
|
||||
tst lr,#1
|
||||
moveq pc,lr @ be binary compatible with V4, yet
|
||||
bx lr @ interoperable with Thumb ISA:-)
|
||||
.align 2
|
||||
#endif
|
||||
.size sha1_block_data_order,.-sha1_block_data_order
|
||||
|
||||
.align 5
|
||||
.LK_00_19: .word 0x5a827999
|
||||
.LK_20_39: .word 0x6ed9eba1
|
||||
.LK_40_59: .word 0x8f1bbcdc
|
||||
.LK_60_79: .word 0xca62c1d6
|
||||
.size sha1_block_data_order,.-sha1_block_data_order
|
||||
.asciz "SHA1 block transform for ARMv4, CRYPTOGAMS by <appro\@openssl.org>"
|
||||
.align 2
|
||||
#if __ARM_MAX_ARCH__>=7
|
||||
.LOPENSSL_armcap:
|
||||
.word OPENSSL_armcap_P-sha1_block_data_order
|
||||
#endif
|
||||
.asciz "SHA1 block transform for ARMv4/NEON/ARMv8, CRYPTOGAMS by <appro\@openssl.org>"
|
||||
.align 5
|
||||
___
|
||||
#####################################################################
|
||||
# NEON stuff
|
||||
#
|
||||
{{{
|
||||
my @V=($a,$b,$c,$d,$e);
|
||||
my ($K_XX_XX,$Ki,$t0,$t1,$Xfer,$saved_sp)=map("r$_",(8..12,14));
|
||||
my $Xi=4;
|
||||
my @X=map("q$_",(8..11,0..3));
|
||||
my @Tx=("q12","q13");
|
||||
my ($K,$zero)=("q14","q15");
|
||||
my $j=0;
|
||||
|
||||
sub AUTOLOAD() # thunk [simplified] x86-style perlasm
|
||||
{ my $opcode = $AUTOLOAD; $opcode =~ s/.*:://; $opcode =~ s/_/\./;
|
||||
my $arg = pop;
|
||||
$arg = "#$arg" if ($arg*1 eq $arg);
|
||||
$code .= "\t$opcode\t".join(',',@_,$arg)."\n";
|
||||
}
|
||||
|
||||
sub body_00_19 () {
|
||||
(
|
||||
'($a,$b,$c,$d,$e)=@V;'. # '$code.="@ $j\n";'.
|
||||
'&bic ($t0,$d,$b)',
|
||||
'&add ($e,$e,$Ki)', # e+=X[i]+K
|
||||
'&and ($t1,$c,$b)',
|
||||
'&ldr ($Ki,sprintf "[sp,#%d]",4*(($j+1)&15))',
|
||||
'&add ($e,$e,$a,"ror#27")', # e+=ROR(A,27)
|
||||
'&eor ($t1,$t1,$t0)', # F_00_19
|
||||
'&mov ($b,$b,"ror#2")', # b=ROR(b,2)
|
||||
'&add ($e,$e,$t1);'. # e+=F_00_19
|
||||
'$j++; unshift(@V,pop(@V));'
|
||||
)
|
||||
}
|
||||
sub body_20_39 () {
|
||||
(
|
||||
'($a,$b,$c,$d,$e)=@V;'. # '$code.="@ $j\n";'.
|
||||
'&eor ($t0,$b,$d)',
|
||||
'&add ($e,$e,$Ki)', # e+=X[i]+K
|
||||
'&ldr ($Ki,sprintf "[sp,#%d]",4*(($j+1)&15)) if ($j<79)',
|
||||
'&eor ($t1,$t0,$c)', # F_20_39
|
||||
'&add ($e,$e,$a,"ror#27")', # e+=ROR(A,27)
|
||||
'&mov ($b,$b,"ror#2")', # b=ROR(b,2)
|
||||
'&add ($e,$e,$t1);'. # e+=F_20_39
|
||||
'$j++; unshift(@V,pop(@V));'
|
||||
)
|
||||
}
|
||||
sub body_40_59 () {
|
||||
(
|
||||
'($a,$b,$c,$d,$e)=@V;'. # '$code.="@ $j\n";'.
|
||||
'&add ($e,$e,$Ki)', # e+=X[i]+K
|
||||
'&and ($t0,$c,$d)',
|
||||
'&ldr ($Ki,sprintf "[sp,#%d]",4*(($j+1)&15))',
|
||||
'&add ($e,$e,$a,"ror#27")', # e+=ROR(A,27)
|
||||
'&eor ($t1,$c,$d)',
|
||||
'&add ($e,$e,$t0)',
|
||||
'&and ($t1,$t1,$b)',
|
||||
'&mov ($b,$b,"ror#2")', # b=ROR(b,2)
|
||||
'&add ($e,$e,$t1);'. # e+=F_40_59
|
||||
'$j++; unshift(@V,pop(@V));'
|
||||
)
|
||||
}
|
||||
|
||||
sub Xupdate_16_31 ()
|
||||
{ use integer;
|
||||
my $body = shift;
|
||||
my @insns = (&$body,&$body,&$body,&$body);
|
||||
my ($a,$b,$c,$d,$e);
|
||||
|
||||
&vext_8 (@X[0],@X[-4&7],@X[-3&7],8); # compose "X[-14]" in "X[0]"
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&vadd_i32 (@Tx[1],@X[-1&7],$K);
|
||||
eval(shift(@insns));
|
||||
&vld1_32 ("{$K\[]}","[$K_XX_XX,:32]!") if ($Xi%5==0);
|
||||
eval(shift(@insns));
|
||||
&vext_8 (@Tx[0],@X[-1&7],$zero,4); # "X[-3]", 3 words
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&veor (@X[0],@X[0],@X[-4&7]); # "X[0]"^="X[-16]"
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&veor (@Tx[0],@Tx[0],@X[-2&7]); # "X[-3]"^"X[-8]"
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&veor (@Tx[0],@Tx[0],@X[0]); # "X[0]"^="X[-3]"^"X[-8]
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&vst1_32 ("{@Tx[1]}","[$Xfer,:128]!"); # X[]+K xfer
|
||||
&sub ($Xfer,$Xfer,64) if ($Xi%4==0);
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&vext_8 (@Tx[1],$zero,@Tx[0],4); # "X[0]"<<96, extract one dword
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&vadd_i32 (@X[0],@Tx[0],@Tx[0]);
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&vsri_32 (@X[0],@Tx[0],31); # "X[0]"<<<=1
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&vshr_u32 (@Tx[0],@Tx[1],30);
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&vshl_u32 (@Tx[1],@Tx[1],2);
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&veor (@X[0],@X[0],@Tx[0]);
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&veor (@X[0],@X[0],@Tx[1]); # "X[0]"^=("X[0]">>96)<<<2
|
||||
|
||||
foreach (@insns) { eval; } # remaining instructions [if any]
|
||||
|
||||
$Xi++; push(@X,shift(@X)); # "rotate" X[]
|
||||
}
|
||||
|
||||
sub Xupdate_32_79 ()
|
||||
{ use integer;
|
||||
my $body = shift;
|
||||
my @insns = (&$body,&$body,&$body,&$body);
|
||||
my ($a,$b,$c,$d,$e);
|
||||
|
||||
&vext_8 (@Tx[0],@X[-2&7],@X[-1&7],8); # compose "X[-6]"
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&veor (@X[0],@X[0],@X[-4&7]); # "X[0]"="X[-32]"^"X[-16]"
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&veor (@X[0],@X[0],@X[-7&7]); # "X[0]"^="X[-28]"
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&vadd_i32 (@Tx[1],@X[-1&7],$K);
|
||||
eval(shift(@insns));
|
||||
&vld1_32 ("{$K\[]}","[$K_XX_XX,:32]!") if ($Xi%5==0);
|
||||
eval(shift(@insns));
|
||||
&veor (@Tx[0],@Tx[0],@X[0]); # "X[-6]"^="X[0]"
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&vshr_u32 (@X[0],@Tx[0],30);
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&vst1_32 ("{@Tx[1]}","[$Xfer,:128]!"); # X[]+K xfer
|
||||
&sub ($Xfer,$Xfer,64) if ($Xi%4==0);
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&vsli_32 (@X[0],@Tx[0],2); # "X[0]"="X[-6]"<<<2
|
||||
|
||||
foreach (@insns) { eval; } # remaining instructions [if any]
|
||||
|
||||
$Xi++; push(@X,shift(@X)); # "rotate" X[]
|
||||
}
|
||||
|
||||
sub Xuplast_80 ()
|
||||
{ use integer;
|
||||
my $body = shift;
|
||||
my @insns = (&$body,&$body,&$body,&$body);
|
||||
my ($a,$b,$c,$d,$e);
|
||||
|
||||
&vadd_i32 (@Tx[1],@X[-1&7],$K);
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&vst1_32 ("{@Tx[1]}","[$Xfer,:128]!");
|
||||
&sub ($Xfer,$Xfer,64);
|
||||
|
||||
&teq ($inp,$len);
|
||||
&sub ($K_XX_XX,$K_XX_XX,16); # rewind $K_XX_XX
|
||||
&subeq ($inp,$inp,64); # reload last block to avoid SEGV
|
||||
&vld1_8 ("{@X[-4&7]-@X[-3&7]}","[$inp]!");
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&vld1_8 ("{@X[-2&7]-@X[-1&7]}","[$inp]!");
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&vld1_32 ("{$K\[]}","[$K_XX_XX,:32]!"); # load K_00_19
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&vrev32_8 (@X[-4&7],@X[-4&7]);
|
||||
|
||||
foreach (@insns) { eval; } # remaining instructions
|
||||
|
||||
$Xi=0;
|
||||
}
|
||||
|
||||
sub Xloop()
|
||||
{ use integer;
|
||||
my $body = shift;
|
||||
my @insns = (&$body,&$body,&$body,&$body);
|
||||
my ($a,$b,$c,$d,$e);
|
||||
|
||||
&vrev32_8 (@X[($Xi-3)&7],@X[($Xi-3)&7]);
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&vadd_i32 (@X[$Xi&7],@X[($Xi-4)&7],$K);
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&vst1_32 ("{@X[$Xi&7]}","[$Xfer,:128]!");# X[]+K xfer to IALU
|
||||
|
||||
foreach (@insns) { eval; }
|
||||
|
||||
$Xi++;
|
||||
}
|
||||
|
||||
$code.=<<___;
|
||||
#if __ARM_MAX_ARCH__>=7
|
||||
.arch armv7-a
|
||||
.fpu neon
|
||||
|
||||
.type sha1_block_data_order_neon,%function
|
||||
.align 4
|
||||
sha1_block_data_order_neon:
|
||||
.LNEON:
|
||||
stmdb sp!,{r4-r12,lr}
|
||||
add $len,$inp,$len,lsl#6 @ $len to point at the end of $inp
|
||||
@ dmb @ errata #451034 on early Cortex A8
|
||||
@ vstmdb sp!,{d8-d15} @ ABI specification says so
|
||||
mov $saved_sp,sp
|
||||
sub sp,sp,#64 @ alloca
|
||||
adr $K_XX_XX,.LK_00_19
|
||||
bic sp,sp,#15 @ align for 128-bit stores
|
||||
|
||||
ldmia $ctx,{$a,$b,$c,$d,$e} @ load context
|
||||
mov $Xfer,sp
|
||||
|
||||
vld1.8 {@X[-4&7]-@X[-3&7]},[$inp]! @ handles unaligned
|
||||
veor $zero,$zero,$zero
|
||||
vld1.8 {@X[-2&7]-@X[-1&7]},[$inp]!
|
||||
vld1.32 {${K}\[]},[$K_XX_XX,:32]! @ load K_00_19
|
||||
vrev32.8 @X[-4&7],@X[-4&7] @ yes, even on
|
||||
vrev32.8 @X[-3&7],@X[-3&7] @ big-endian...
|
||||
vrev32.8 @X[-2&7],@X[-2&7]
|
||||
vadd.i32 @X[0],@X[-4&7],$K
|
||||
vrev32.8 @X[-1&7],@X[-1&7]
|
||||
vadd.i32 @X[1],@X[-3&7],$K
|
||||
vst1.32 {@X[0]},[$Xfer,:128]!
|
||||
vadd.i32 @X[2],@X[-2&7],$K
|
||||
vst1.32 {@X[1]},[$Xfer,:128]!
|
||||
vst1.32 {@X[2]},[$Xfer,:128]!
|
||||
ldr $Ki,[sp] @ big RAW stall
|
||||
|
||||
.Loop_neon:
|
||||
___
|
||||
&Xupdate_16_31(\&body_00_19);
|
||||
&Xupdate_16_31(\&body_00_19);
|
||||
&Xupdate_16_31(\&body_00_19);
|
||||
&Xupdate_16_31(\&body_00_19);
|
||||
&Xupdate_32_79(\&body_00_19);
|
||||
&Xupdate_32_79(\&body_20_39);
|
||||
&Xupdate_32_79(\&body_20_39);
|
||||
&Xupdate_32_79(\&body_20_39);
|
||||
&Xupdate_32_79(\&body_20_39);
|
||||
&Xupdate_32_79(\&body_20_39);
|
||||
&Xupdate_32_79(\&body_40_59);
|
||||
&Xupdate_32_79(\&body_40_59);
|
||||
&Xupdate_32_79(\&body_40_59);
|
||||
&Xupdate_32_79(\&body_40_59);
|
||||
&Xupdate_32_79(\&body_40_59);
|
||||
&Xupdate_32_79(\&body_20_39);
|
||||
&Xuplast_80(\&body_20_39);
|
||||
&Xloop(\&body_20_39);
|
||||
&Xloop(\&body_20_39);
|
||||
&Xloop(\&body_20_39);
|
||||
$code.=<<___;
|
||||
ldmia $ctx,{$Ki,$t0,$t1,$Xfer} @ accumulate context
|
||||
add $a,$a,$Ki
|
||||
ldr $Ki,[$ctx,#16]
|
||||
add $b,$b,$t0
|
||||
add $c,$c,$t1
|
||||
add $d,$d,$Xfer
|
||||
moveq sp,$saved_sp
|
||||
add $e,$e,$Ki
|
||||
ldrne $Ki,[sp]
|
||||
stmia $ctx,{$a,$b,$c,$d,$e}
|
||||
addne $Xfer,sp,#3*16
|
||||
bne .Loop_neon
|
||||
|
||||
@ vldmia sp!,{d8-d15}
|
||||
ldmia sp!,{r4-r12,pc}
|
||||
.size sha1_block_data_order_neon,.-sha1_block_data_order_neon
|
||||
#endif
|
||||
___
|
||||
}}}
|
||||
#####################################################################
|
||||
# ARMv8 stuff
|
||||
#
|
||||
{{{
|
||||
my ($ABCD,$E,$E0,$E1)=map("q$_",(0..3));
|
||||
my @MSG=map("q$_",(4..7));
|
||||
my @Kxx=map("q$_",(8..11));
|
||||
my ($W0,$W1,$ABCD_SAVE)=map("q$_",(12..14));
|
||||
|
||||
$code.=<<___;
|
||||
#if __ARM_MAX_ARCH__>=7
|
||||
.type sha1_block_data_order_armv8,%function
|
||||
.align 5
|
||||
sha1_block_data_order_armv8:
|
||||
.LARMv8:
|
||||
vstmdb sp!,{d8-d15} @ ABI specification says so
|
||||
|
||||
veor $E,$E,$E
|
||||
adr r3,.LK_00_19
|
||||
vld1.32 {$ABCD},[$ctx]!
|
||||
vld1.32 {$E\[0]},[$ctx]
|
||||
sub $ctx,$ctx,#16
|
||||
vld1.32 {@Kxx[0]\[]},[r3,:32]!
|
||||
vld1.32 {@Kxx[1]\[]},[r3,:32]!
|
||||
vld1.32 {@Kxx[2]\[]},[r3,:32]!
|
||||
vld1.32 {@Kxx[3]\[]},[r3,:32]
|
||||
|
||||
.Loop_v8:
|
||||
vld1.8 {@MSG[0]-@MSG[1]},[$inp]!
|
||||
vld1.8 {@MSG[2]-@MSG[3]},[$inp]!
|
||||
vrev32.8 @MSG[0],@MSG[0]
|
||||
vrev32.8 @MSG[1],@MSG[1]
|
||||
|
||||
vadd.i32 $W0,@Kxx[0],@MSG[0]
|
||||
vrev32.8 @MSG[2],@MSG[2]
|
||||
vmov $ABCD_SAVE,$ABCD @ offload
|
||||
subs $len,$len,#1
|
||||
|
||||
vadd.i32 $W1,@Kxx[0],@MSG[1]
|
||||
vrev32.8 @MSG[3],@MSG[3]
|
||||
sha1h $E1,$ABCD @ 0
|
||||
sha1c $ABCD,$E,$W0
|
||||
vadd.i32 $W0,@Kxx[$j],@MSG[2]
|
||||
sha1su0 @MSG[0],@MSG[1],@MSG[2]
|
||||
___
|
||||
for ($j=0,$i=1;$i<20-3;$i++) {
|
||||
my $f=("c","p","m","p")[$i/5];
|
||||
$code.=<<___;
|
||||
sha1h $E0,$ABCD @ $i
|
||||
sha1$f $ABCD,$E1,$W1
|
||||
vadd.i32 $W1,@Kxx[$j],@MSG[3]
|
||||
sha1su1 @MSG[0],@MSG[3]
|
||||
___
|
||||
$code.=<<___ if ($i<20-4);
|
||||
sha1su0 @MSG[1],@MSG[2],@MSG[3]
|
||||
___
|
||||
($E0,$E1)=($E1,$E0); ($W0,$W1)=($W1,$W0);
|
||||
push(@MSG,shift(@MSG)); $j++ if ((($i+3)%5)==0);
|
||||
}
|
||||
$code.=<<___;
|
||||
sha1h $E0,$ABCD @ $i
|
||||
sha1p $ABCD,$E1,$W1
|
||||
vadd.i32 $W1,@Kxx[$j],@MSG[3]
|
||||
|
||||
sha1h $E1,$ABCD @ 18
|
||||
sha1p $ABCD,$E0,$W0
|
||||
|
||||
sha1h $E0,$ABCD @ 19
|
||||
sha1p $ABCD,$E1,$W1
|
||||
|
||||
vadd.i32 $E,$E,$E0
|
||||
vadd.i32 $ABCD,$ABCD,$ABCD_SAVE
|
||||
bne .Loop_v8
|
||||
|
||||
vst1.32 {$ABCD},[$ctx]!
|
||||
vst1.32 {$E\[0]},[$ctx]
|
||||
|
||||
vldmia sp!,{d8-d15}
|
||||
ret @ bx lr
|
||||
.size sha1_block_data_order_armv8,.-sha1_block_data_order_armv8
|
||||
#endif
|
||||
___
|
||||
}}}
|
||||
$code.=<<___;
|
||||
#if __ARM_MAX_ARCH__>=7
|
||||
.comm OPENSSL_armcap_P,4,4
|
||||
#endif
|
||||
___
|
||||
|
||||
$code =~ s/\bbx\s+lr\b/.word\t0xe12fff1e/gm; # make it possible to compile with -march=armv4
|
||||
print $code;
|
||||
{ my %opcode = (
|
||||
"sha1c" => 0xf2000c40, "sha1p" => 0xf2100c40,
|
||||
"sha1m" => 0xf2200c40, "sha1su0" => 0xf2300c40,
|
||||
"sha1h" => 0xf3b902c0, "sha1su1" => 0xf3ba0380 );
|
||||
|
||||
sub unsha1 {
|
||||
my ($mnemonic,$arg)=@_;
|
||||
|
||||
if ($arg =~ m/q([0-9]+)(?:,\s*q([0-9]+))?,\s*q([0-9]+)/o) {
|
||||
my $word = $opcode{$mnemonic}|(($1&7)<<13)|(($1&8)<<19)
|
||||
|(($2&7)<<17)|(($2&8)<<4)
|
||||
|(($3&7)<<1) |(($3&8)<<2);
|
||||
# since ARMv7 instructions are always encoded little-endian.
|
||||
# correct solution is to use .inst directive, but older
|
||||
# assemblers don't implement it:-(
|
||||
sprintf ".byte\t0x%02x,0x%02x,0x%02x,0x%02x\t@ %s %s",
|
||||
$word&0xff,($word>>8)&0xff,
|
||||
($word>>16)&0xff,($word>>24)&0xff,
|
||||
$mnemonic,$arg;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
foreach (split($/,$code)) {
|
||||
s/{q([0-9]+)\[\]}/sprintf "{d%d[],d%d[]}",2*$1,2*$1+1/eo or
|
||||
s/{q([0-9]+)\[0\]}/sprintf "{d%d[0]}",2*$1/eo;
|
||||
|
||||
s/\b(sha1\w+)\s+(q.*)/unsha1($1,$2)/geo;
|
||||
|
||||
s/\bret\b/bx lr/o or
|
||||
s/\bbx\s+lr\b/.word\t0xe12fff1e/o; # make it possible to compile with -march=armv4
|
||||
|
||||
print $_,$/;
|
||||
}
|
||||
|
||||
close STDOUT; # enforce flush
|
||||
|
||||
338
crypto/sha/asm/sha1-armv8.pl
Normal file
338
crypto/sha/asm/sha1-armv8.pl
Normal file
@@ -0,0 +1,338 @@
|
||||
#!/usr/bin/env perl
|
||||
#
|
||||
# ====================================================================
|
||||
# Written by Andy Polyakov <appro@openssl.org> 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 for ARMv8.
|
||||
#
|
||||
# Performance in cycles per processed byte and improvement coefficient
|
||||
# over code generated with "default" compiler:
|
||||
#
|
||||
# hardware-assisted software(*)
|
||||
# Apple A7 2.31 4.13 (+14%)
|
||||
# Cortex-A53 2.24 8.03 (+97%)
|
||||
# Cortex-A57 2.35 7.88 (+74%)
|
||||
# Denver 2.13 3.97 (+0%)(**)
|
||||
# X-Gene 8.80 (+200%)
|
||||
#
|
||||
# (*) Software results are presented mostly for reference purposes.
|
||||
# (**) Keep in mind that Denver relies on binary translation, which
|
||||
# optimizes compiler output at run-time.
|
||||
|
||||
$flavour = shift;
|
||||
open STDOUT,">".shift;
|
||||
|
||||
($ctx,$inp,$num)=("x0","x1","x2");
|
||||
@Xw=map("w$_",(3..17,19));
|
||||
@Xx=map("x$_",(3..17,19));
|
||||
@V=($A,$B,$C,$D,$E)=map("w$_",(20..24));
|
||||
($t0,$t1,$t2,$K)=map("w$_",(25..28));
|
||||
|
||||
|
||||
sub BODY_00_19 {
|
||||
my ($i,$a,$b,$c,$d,$e)=@_;
|
||||
my $j=($i+2)&15;
|
||||
|
||||
$code.=<<___ if ($i<15 && !($i&1));
|
||||
lsr @Xx[$i+1],@Xx[$i],#32
|
||||
___
|
||||
$code.=<<___ if ($i<14 && !($i&1));
|
||||
ldr @Xx[$i+2],[$inp,#`($i+2)*4-64`]
|
||||
___
|
||||
$code.=<<___ if ($i<14 && ($i&1));
|
||||
#ifdef __ARMEB__
|
||||
ror @Xx[$i+1],@Xx[$i+1],#32
|
||||
#else
|
||||
rev32 @Xx[$i+1],@Xx[$i+1]
|
||||
#endif
|
||||
___
|
||||
$code.=<<___ if ($i<14);
|
||||
bic $t0,$d,$b
|
||||
and $t1,$c,$b
|
||||
ror $t2,$a,#27
|
||||
add $d,$d,$K // future e+=K
|
||||
orr $t0,$t0,$t1
|
||||
add $e,$e,$t2 // e+=rot(a,5)
|
||||
ror $b,$b,#2
|
||||
add $d,$d,@Xw[($i+1)&15] // future e+=X[i]
|
||||
add $e,$e,$t0 // e+=F(b,c,d)
|
||||
___
|
||||
$code.=<<___ if ($i==19);
|
||||
movz $K,#0xeba1
|
||||
movk $K,#0x6ed9,lsl#16
|
||||
___
|
||||
$code.=<<___ if ($i>=14);
|
||||
eor @Xw[$j],@Xw[$j],@Xw[($j+2)&15]
|
||||
bic $t0,$d,$b
|
||||
and $t1,$c,$b
|
||||
ror $t2,$a,#27
|
||||
eor @Xw[$j],@Xw[$j],@Xw[($j+8)&15]
|
||||
add $d,$d,$K // future e+=K
|
||||
orr $t0,$t0,$t1
|
||||
add $e,$e,$t2 // e+=rot(a,5)
|
||||
eor @Xw[$j],@Xw[$j],@Xw[($j+13)&15]
|
||||
ror $b,$b,#2
|
||||
add $d,$d,@Xw[($i+1)&15] // future e+=X[i]
|
||||
add $e,$e,$t0 // e+=F(b,c,d)
|
||||
ror @Xw[$j],@Xw[$j],#31
|
||||
___
|
||||
}
|
||||
|
||||
sub BODY_40_59 {
|
||||
my ($i,$a,$b,$c,$d,$e)=@_;
|
||||
my $j=($i+2)&15;
|
||||
|
||||
$code.=<<___ if ($i==59);
|
||||
movz $K,#0xc1d6
|
||||
movk $K,#0xca62,lsl#16
|
||||
___
|
||||
$code.=<<___;
|
||||
orr $t0,$b,$c
|
||||
and $t1,$b,$c
|
||||
eor @Xw[$j],@Xw[$j],@Xw[($j+2)&15]
|
||||
ror $t2,$a,#27
|
||||
and $t0,$t0,$d
|
||||
add $d,$d,$K // future e+=K
|
||||
eor @Xw[$j],@Xw[$j],@Xw[($j+8)&15]
|
||||
add $e,$e,$t2 // e+=rot(a,5)
|
||||
orr $t0,$t0,$t1
|
||||
ror $b,$b,#2
|
||||
eor @Xw[$j],@Xw[$j],@Xw[($j+13)&15]
|
||||
add $d,$d,@Xw[($i+1)&15] // future e+=X[i]
|
||||
add $e,$e,$t0 // e+=F(b,c,d)
|
||||
ror @Xw[$j],@Xw[$j],#31
|
||||
___
|
||||
}
|
||||
|
||||
sub BODY_20_39 {
|
||||
my ($i,$a,$b,$c,$d,$e)=@_;
|
||||
my $j=($i+2)&15;
|
||||
|
||||
$code.=<<___ if ($i==39);
|
||||
movz $K,#0xbcdc
|
||||
movk $K,#0x8f1b,lsl#16
|
||||
___
|
||||
$code.=<<___ if ($i<78);
|
||||
eor @Xw[$j],@Xw[$j],@Xw[($j+2)&15]
|
||||
eor $t0,$d,$b
|
||||
ror $t2,$a,#27
|
||||
add $d,$d,$K // future e+=K
|
||||
eor @Xw[$j],@Xw[$j],@Xw[($j+8)&15]
|
||||
eor $t0,$t0,$c
|
||||
add $e,$e,$t2 // e+=rot(a,5)
|
||||
ror $b,$b,#2
|
||||
eor @Xw[$j],@Xw[$j],@Xw[($j+13)&15]
|
||||
add $d,$d,@Xw[($i+1)&15] // future e+=X[i]
|
||||
add $e,$e,$t0 // e+=F(b,c,d)
|
||||
ror @Xw[$j],@Xw[$j],#31
|
||||
___
|
||||
$code.=<<___ if ($i==78);
|
||||
ldp @Xw[1],@Xw[2],[$ctx]
|
||||
eor $t0,$d,$b
|
||||
ror $t2,$a,#27
|
||||
add $d,$d,$K // future e+=K
|
||||
eor $t0,$t0,$c
|
||||
add $e,$e,$t2 // e+=rot(a,5)
|
||||
ror $b,$b,#2
|
||||
add $d,$d,@Xw[($i+1)&15] // future e+=X[i]
|
||||
add $e,$e,$t0 // e+=F(b,c,d)
|
||||
___
|
||||
$code.=<<___ if ($i==79);
|
||||
ldp @Xw[3],@Xw[4],[$ctx,#8]
|
||||
eor $t0,$d,$b
|
||||
ror $t2,$a,#27
|
||||
eor $t0,$t0,$c
|
||||
add $e,$e,$t2 // e+=rot(a,5)
|
||||
ror $b,$b,#2
|
||||
ldr @Xw[5],[$ctx,#16]
|
||||
add $e,$e,$t0 // e+=F(b,c,d)
|
||||
___
|
||||
}
|
||||
|
||||
$code.=<<___;
|
||||
#include "arm_arch.h"
|
||||
|
||||
.text
|
||||
|
||||
.globl sha1_block_data_order
|
||||
.type sha1_block_data_order,%function
|
||||
.align 6
|
||||
sha1_block_data_order:
|
||||
ldr x16,.LOPENSSL_armcap_P
|
||||
adr x17,.LOPENSSL_armcap_P
|
||||
add x16,x16,x17
|
||||
ldr w16,[x16]
|
||||
tst w16,#ARMV8_SHA1
|
||||
b.ne .Lv8_entry
|
||||
|
||||
stp x29,x30,[sp,#-96]!
|
||||
add x29,sp,#0
|
||||
stp x19,x20,[sp,#16]
|
||||
stp x21,x22,[sp,#32]
|
||||
stp x23,x24,[sp,#48]
|
||||
stp x25,x26,[sp,#64]
|
||||
stp x27,x28,[sp,#80]
|
||||
|
||||
ldp $A,$B,[$ctx]
|
||||
ldp $C,$D,[$ctx,#8]
|
||||
ldr $E,[$ctx,#16]
|
||||
|
||||
.Loop:
|
||||
ldr @Xx[0],[$inp],#64
|
||||
movz $K,#0x7999
|
||||
sub $num,$num,#1
|
||||
movk $K,#0x5a82,lsl#16
|
||||
#ifdef __ARMEB__
|
||||
ror $Xx[0],@Xx[0],#32
|
||||
#else
|
||||
rev32 @Xx[0],@Xx[0]
|
||||
#endif
|
||||
add $E,$E,$K // warm it up
|
||||
add $E,$E,@Xw[0]
|
||||
___
|
||||
for($i=0;$i<20;$i++) { &BODY_00_19($i,@V); unshift(@V,pop(@V)); }
|
||||
for(;$i<40;$i++) { &BODY_20_39($i,@V); unshift(@V,pop(@V)); }
|
||||
for(;$i<60;$i++) { &BODY_40_59($i,@V); unshift(@V,pop(@V)); }
|
||||
for(;$i<80;$i++) { &BODY_20_39($i,@V); unshift(@V,pop(@V)); }
|
||||
$code.=<<___;
|
||||
add $B,$B,@Xw[2]
|
||||
add $C,$C,@Xw[3]
|
||||
add $A,$A,@Xw[1]
|
||||
add $D,$D,@Xw[4]
|
||||
add $E,$E,@Xw[5]
|
||||
stp $A,$B,[$ctx]
|
||||
stp $C,$D,[$ctx,#8]
|
||||
str $E,[$ctx,#16]
|
||||
cbnz $num,.Loop
|
||||
|
||||
ldp x19,x20,[sp,#16]
|
||||
ldp x21,x22,[sp,#32]
|
||||
ldp x23,x24,[sp,#48]
|
||||
ldp x25,x26,[sp,#64]
|
||||
ldp x27,x28,[sp,#80]
|
||||
ldr x29,[sp],#96
|
||||
ret
|
||||
.size sha1_block_data_order,.-sha1_block_data_order
|
||||
___
|
||||
{{{
|
||||
my ($ABCD,$E,$E0,$E1)=map("v$_.16b",(0..3));
|
||||
my @MSG=map("v$_.16b",(4..7));
|
||||
my @Kxx=map("v$_.4s",(16..19));
|
||||
my ($W0,$W1)=("v20.4s","v21.4s");
|
||||
my $ABCD_SAVE="v22.16b";
|
||||
|
||||
$code.=<<___;
|
||||
.type sha1_block_armv8,%function
|
||||
.align 6
|
||||
sha1_block_armv8:
|
||||
.Lv8_entry:
|
||||
stp x29,x30,[sp,#-16]!
|
||||
add x29,sp,#0
|
||||
|
||||
adr x4,.Lconst
|
||||
eor $E,$E,$E
|
||||
ld1.32 {$ABCD},[$ctx],#16
|
||||
ld1.32 {$E}[0],[$ctx]
|
||||
sub $ctx,$ctx,#16
|
||||
ld1.32 {@Kxx[0]-@Kxx[3]},[x4]
|
||||
|
||||
.Loop_hw:
|
||||
ld1 {@MSG[0]-@MSG[3]},[$inp],#64
|
||||
sub $num,$num,#1
|
||||
rev32 @MSG[0],@MSG[0]
|
||||
rev32 @MSG[1],@MSG[1]
|
||||
|
||||
add.i32 $W0,@Kxx[0],@MSG[0]
|
||||
rev32 @MSG[2],@MSG[2]
|
||||
orr $ABCD_SAVE,$ABCD,$ABCD // offload
|
||||
|
||||
add.i32 $W1,@Kxx[0],@MSG[1]
|
||||
rev32 @MSG[3],@MSG[3]
|
||||
sha1h $E1,$ABCD
|
||||
sha1c $ABCD,$E,$W0 // 0
|
||||
add.i32 $W0,@Kxx[$j],@MSG[2]
|
||||
sha1su0 @MSG[0],@MSG[1],@MSG[2]
|
||||
___
|
||||
for ($j=0,$i=1;$i<20-3;$i++) {
|
||||
my $f=("c","p","m","p")[$i/5];
|
||||
$code.=<<___;
|
||||
sha1h $E0,$ABCD // $i
|
||||
sha1$f $ABCD,$E1,$W1
|
||||
add.i32 $W1,@Kxx[$j],@MSG[3]
|
||||
sha1su1 @MSG[0],@MSG[3]
|
||||
___
|
||||
$code.=<<___ if ($i<20-4);
|
||||
sha1su0 @MSG[1],@MSG[2],@MSG[3]
|
||||
___
|
||||
($E0,$E1)=($E1,$E0); ($W0,$W1)=($W1,$W0);
|
||||
push(@MSG,shift(@MSG)); $j++ if ((($i+3)%5)==0);
|
||||
}
|
||||
$code.=<<___;
|
||||
sha1h $E0,$ABCD // $i
|
||||
sha1p $ABCD,$E1,$W1
|
||||
add.i32 $W1,@Kxx[$j],@MSG[3]
|
||||
|
||||
sha1h $E1,$ABCD // 18
|
||||
sha1p $ABCD,$E0,$W0
|
||||
|
||||
sha1h $E0,$ABCD // 19
|
||||
sha1p $ABCD,$E1,$W1
|
||||
|
||||
add.i32 $E,$E,$E0
|
||||
add.i32 $ABCD,$ABCD,$ABCD_SAVE
|
||||
|
||||
cbnz $num,.Loop_hw
|
||||
|
||||
st1.32 {$ABCD},[$ctx],#16
|
||||
st1.32 {$E}[0],[$ctx]
|
||||
|
||||
ldr x29,[sp],#16
|
||||
ret
|
||||
.size sha1_block_armv8,.-sha1_block_armv8
|
||||
.align 6
|
||||
.Lconst:
|
||||
.long 0x5a827999,0x5a827999,0x5a827999,0x5a827999 //K_00_19
|
||||
.long 0x6ed9eba1,0x6ed9eba1,0x6ed9eba1,0x6ed9eba1 //K_20_39
|
||||
.long 0x8f1bbcdc,0x8f1bbcdc,0x8f1bbcdc,0x8f1bbcdc //K_40_59
|
||||
.long 0xca62c1d6,0xca62c1d6,0xca62c1d6,0xca62c1d6 //K_60_79
|
||||
.LOPENSSL_armcap_P:
|
||||
.quad OPENSSL_armcap_P-.
|
||||
.asciz "SHA1 block transform for ARMv8, CRYPTOGAMS by <appro\@openssl.org>"
|
||||
.align 2
|
||||
.comm OPENSSL_armcap_P,4,4
|
||||
___
|
||||
}}}
|
||||
|
||||
{ my %opcode = (
|
||||
"sha1c" => 0x5e000000, "sha1p" => 0x5e001000,
|
||||
"sha1m" => 0x5e002000, "sha1su0" => 0x5e003000,
|
||||
"sha1h" => 0x5e280800, "sha1su1" => 0x5e281800 );
|
||||
|
||||
sub unsha1 {
|
||||
my ($mnemonic,$arg)=@_;
|
||||
|
||||
$arg =~ m/[qv]([0-9]+)[^,]*,\s*[qv]([0-9]+)[^,]*(?:,\s*[qv]([0-9]+))?/o
|
||||
&&
|
||||
sprintf ".inst\t0x%08x\t//%s %s",
|
||||
$opcode{$mnemonic}|$1|($2<<5)|($3<<16),
|
||||
$mnemonic,$arg;
|
||||
}
|
||||
}
|
||||
|
||||
foreach(split("\n",$code)) {
|
||||
|
||||
s/\`([^\`]*)\`/eval($1)/geo;
|
||||
|
||||
s/\b(sha1\w+)\s+([qv].*)/unsha1($1,$2)/geo;
|
||||
|
||||
s/\.\w?32\b//o and s/\.16b/\.4s/go;
|
||||
m/(ld|st)1[^\[]+\[0\]/o and s/\.4s/\.s/go;
|
||||
|
||||
print $_,"\n";
|
||||
}
|
||||
|
||||
close STDOUT;
|
||||
@@ -15,7 +15,7 @@
|
||||
# is >50% better than HP C and >2x better than gcc.
|
||||
|
||||
$code=<<___;
|
||||
.ident \"sha1-ia64.s, version 1.2\"
|
||||
.ident \"sha1-ia64.s, version 1.3\"
|
||||
.ident \"IA-64 ISA artwork by Andy Polyakov <appro\@fy.chalmers.se>\"
|
||||
.explicit
|
||||
|
||||
@@ -26,14 +26,10 @@ if ($^O eq "hpux") {
|
||||
$ADDP="addp4";
|
||||
for (@ARGV) { $ADDP="add" if (/[\+DD|\-mlp]64/); }
|
||||
} else { $ADDP="add"; }
|
||||
for (@ARGV) { $big_endian=1 if (/\-DB_ENDIAN/);
|
||||
$big_endian=0 if (/\-DL_ENDIAN/); }
|
||||
if (!defined($big_endian))
|
||||
{ $big_endian=(unpack('L',pack('N',1))==1); }
|
||||
|
||||
#$human=1;
|
||||
if ($human) { # useful for visual code auditing...
|
||||
($A,$B,$C,$D,$E,$T) = ("A","B","C","D","E","T");
|
||||
($A,$B,$C,$D,$E) = ("A","B","C","D","E");
|
||||
($h0,$h1,$h2,$h3,$h4) = ("h0","h1","h2","h3","h4");
|
||||
($K_00_19, $K_20_39, $K_40_59, $K_60_79) =
|
||||
( "K_00_19","K_20_39","K_40_59","K_60_79" );
|
||||
@@ -41,47 +37,50 @@ if ($human) { # useful for visual code auditing...
|
||||
"X8", "X9","X10","X11","X12","X13","X14","X15" );
|
||||
}
|
||||
else {
|
||||
($A,$B,$C,$D,$E,$T) = ("loc0","loc1","loc2","loc3","loc4","loc5");
|
||||
($h0,$h1,$h2,$h3,$h4) = ("loc6","loc7","loc8","loc9","loc10");
|
||||
($A,$B,$C,$D,$E) = ("loc0","loc1","loc2","loc3","loc4");
|
||||
($h0,$h1,$h2,$h3,$h4) = ("loc5","loc6","loc7","loc8","loc9");
|
||||
($K_00_19, $K_20_39, $K_40_59, $K_60_79) =
|
||||
( "r14", "r15", "loc11", "loc12" );
|
||||
( "r14", "r15", "loc10", "loc11" );
|
||||
@X= ( "r16", "r17", "r18", "r19", "r20", "r21", "r22", "r23",
|
||||
"r24", "r25", "r26", "r27", "r28", "r29", "r30", "r31" );
|
||||
}
|
||||
|
||||
sub BODY_00_15 {
|
||||
local *code=shift;
|
||||
local ($i,$a,$b,$c,$d,$e,$f)=@_;
|
||||
my ($i,$a,$b,$c,$d,$e)=@_;
|
||||
my $j=$i+1;
|
||||
my $Xn=@X[$j%16];
|
||||
|
||||
$code.=<<___ if ($i==0);
|
||||
{ .mmi; ld1 $X[$i&0xf]=[inp],2 // MSB
|
||||
{ .mmi; ld1 $X[$i]=[inp],2 // MSB
|
||||
ld1 tmp2=[tmp3],2 };;
|
||||
{ .mmi; ld1 tmp0=[inp],2
|
||||
ld1 tmp4=[tmp3],2 // LSB
|
||||
dep $X[$i&0xf]=$X[$i&0xf],tmp2,8,8 };;
|
||||
dep $X[$i]=$X[$i],tmp2,8,8 };;
|
||||
___
|
||||
if ($i<15) {
|
||||
$code.=<<___;
|
||||
{ .mmi; ld1 $X[($i+1)&0xf]=[inp],2 // +1
|
||||
{ .mmi; ld1 $Xn=[inp],2 // forward Xload
|
||||
nop.m 0x0
|
||||
dep tmp1=tmp0,tmp4,8,8 };;
|
||||
{ .mmi; ld1 tmp2=[tmp3],2 // +1
|
||||
{ .mmi; ld1 tmp2=[tmp3],2 // forward Xload
|
||||
and tmp4=$c,$b
|
||||
dep $X[$i&0xf]=$X[$i&0xf],tmp1,16,16 } //;;
|
||||
{ .mmi; andcm tmp1=$d,$b
|
||||
add tmp0=$e,$K_00_19
|
||||
dep $X[$i]=$X[$i],tmp1,16,16} //;;
|
||||
{ .mmi; add $e=$e,$K_00_19 // e+=K_00_19
|
||||
andcm tmp1=$d,$b
|
||||
dep.z tmp5=$a,5,27 };; // a<<5
|
||||
{ .mmi; or tmp4=tmp4,tmp1 // F_00_19(b,c,d)=(b&c)|(~b&d)
|
||||
add $f=tmp0,$X[$i&0xf] // f=xi+e+K_00_19
|
||||
{ .mmi; add $e=$e,$X[$i] // e+=Xload
|
||||
or tmp4=tmp4,tmp1 // F_00_19(b,c,d)=(b&c)|(~b&d)
|
||||
extr.u tmp1=$a,27,5 };; // a>>27
|
||||
{ .mmi; ld1 tmp0=[inp],2 // +1
|
||||
add $f=$f,tmp4 // f+=F_00_19(b,c,d)
|
||||
{ .mmi; ld1 tmp0=[inp],2 // forward Xload
|
||||
add $e=$e,tmp4 // e+=F_00_19(b,c,d)
|
||||
shrp $b=tmp6,tmp6,2 } // b=ROTATE(b,30)
|
||||
{ .mmi; ld1 tmp4=[tmp3],2 // +1
|
||||
{ .mmi; ld1 tmp4=[tmp3],2 // forward Xload
|
||||
or tmp5=tmp1,tmp5 // ROTATE(a,5)
|
||||
mux2 tmp6=$a,0x44 };; // see b in next iteration
|
||||
{ .mii; add $f=$f,tmp5 // f+=ROTATE(a,5)
|
||||
dep $X[($i+1)&0xf]=$X[($i+1)&0xf],tmp2,8,8 // +1
|
||||
mux2 $X[$i&0xf]=$X[$i&0xf],0x44 } //;;
|
||||
{ .mii; add $e=$e,tmp5 // e+=ROTATE(a,5)
|
||||
dep $Xn=$Xn,tmp2,8,8 // forward Xload
|
||||
mux2 $X[$i]=$X[$i],0x44 } //;;
|
||||
|
||||
___
|
||||
}
|
||||
@@ -89,24 +88,24 @@ else {
|
||||
$code.=<<___;
|
||||
{ .mii; and tmp3=$c,$b
|
||||
dep tmp1=tmp0,tmp4,8,8;;
|
||||
dep $X[$i&0xf]=$X[$i&0xf],tmp1,16,16 } //;;
|
||||
{ .mmi; andcm tmp1=$d,$b
|
||||
add tmp0=$e,$K_00_19
|
||||
dep $X[$i]=$X[$i],tmp1,16,16} //;;
|
||||
{ .mmi; add $e=$e,$K_00_19 // e+=K_00_19
|
||||
andcm tmp1=$d,$b
|
||||
dep.z tmp5=$a,5,27 };; // a<<5
|
||||
{ .mmi; or tmp4=tmp3,tmp1 // F_00_19(b,c,d)=(b&c)|(~b&d)
|
||||
add $f=tmp0,$X[$i&0xf] // f=xi+e+K_00_19
|
||||
{ .mmi; add $e=$e,$X[$i] // e+=Xupdate
|
||||
or tmp4=tmp3,tmp1 // F_00_19(b,c,d)=(b&c)|(~b&d)
|
||||
extr.u tmp1=$a,27,5 } // a>>27
|
||||
{ .mmi; xor tmp2=$X[($i+0+1)&0xf],$X[($i+2+1)&0xf] // +1
|
||||
xor tmp3=$X[($i+8+1)&0xf],$X[($i+13+1)&0xf] // +1
|
||||
{ .mmi; xor $Xn=$Xn,$X[($j+2)%16] // forward Xupdate
|
||||
xor tmp3=$X[($j+8)%16],$X[($j+13)%16] // forward Xupdate
|
||||
nop.i 0 };;
|
||||
{ .mmi; add $f=$f,tmp4 // f+=F_00_19(b,c,d)
|
||||
xor tmp2=tmp2,tmp3 // +1
|
||||
{ .mmi; add $e=$e,tmp4 // e+=F_00_19(b,c,d)
|
||||
xor $Xn=$Xn,tmp3 // forward Xupdate
|
||||
shrp $b=tmp6,tmp6,2 } // b=ROTATE(b,30)
|
||||
{ .mmi; or tmp1=tmp1,tmp5 // ROTATE(a,5)
|
||||
mux2 tmp6=$a,0x44 };; // see b in next iteration
|
||||
{ .mii; add $f=$f,tmp1 // f+=ROTATE(a,5)
|
||||
shrp $e=tmp2,tmp2,31 // f+1=ROTATE(x[0]^x[2]^x[8]^x[13],1)
|
||||
mux2 $X[$i&0xf]=$X[$i&0xf],0x44 };;
|
||||
{ .mii; add $e=$e,tmp1 // e+=ROTATE(a,5)
|
||||
shrp $Xn=$Xn,$Xn,31 // ROTATE(x[0]^x[2]^x[8]^x[13],1)
|
||||
mux2 $X[$i]=$X[$i],0x44 };;
|
||||
|
||||
___
|
||||
}
|
||||
@@ -114,27 +113,28 @@ ___
|
||||
|
||||
sub BODY_16_19 {
|
||||
local *code=shift;
|
||||
local ($i,$a,$b,$c,$d,$e,$f)=@_;
|
||||
my ($i,$a,$b,$c,$d,$e)=@_;
|
||||
my $j=$i+1;
|
||||
my $Xn=@X[$j%16];
|
||||
|
||||
$code.=<<___;
|
||||
{ .mmi; mov $X[$i&0xf]=$f // Xupdate
|
||||
and tmp0=$c,$b
|
||||
{ .mib; add $e=$e,$K_00_19 // e+=K_00_19
|
||||
dep.z tmp5=$a,5,27 } // a<<5
|
||||
{ .mmi; andcm tmp1=$d,$b
|
||||
add tmp4=$e,$K_00_19 };;
|
||||
{ .mmi; or tmp0=tmp0,tmp1 // F_00_19(b,c,d)=(b&c)|(~b&d)
|
||||
add $f=$f,tmp4 // f+=e+K_00_19
|
||||
{ .mib; andcm tmp1=$d,$b
|
||||
and tmp0=$c,$b };;
|
||||
{ .mmi; add $e=$e,$X[$i%16] // e+=Xupdate
|
||||
or tmp0=tmp0,tmp1 // F_00_19(b,c,d)=(b&c)|(~b&d)
|
||||
extr.u tmp1=$a,27,5 } // a>>27
|
||||
{ .mmi; xor tmp2=$X[($i+0+1)&0xf],$X[($i+2+1)&0xf] // +1
|
||||
xor tmp3=$X[($i+8+1)&0xf],$X[($i+13+1)&0xf] // +1
|
||||
{ .mmi; xor $Xn=$Xn,$X[($j+2)%16] // forward Xupdate
|
||||
xor tmp3=$X[($j+8)%16],$X[($j+13)%16] // forward Xupdate
|
||||
nop.i 0 };;
|
||||
{ .mmi; add $f=$f,tmp0 // f+=F_00_19(b,c,d)
|
||||
xor tmp2=tmp2,tmp3 // +1
|
||||
{ .mmi; add $e=$e,tmp0 // f+=F_00_19(b,c,d)
|
||||
xor $Xn=$Xn,tmp3 // forward Xupdate
|
||||
shrp $b=tmp6,tmp6,2 } // b=ROTATE(b,30)
|
||||
{ .mmi; or tmp1=tmp1,tmp5 // ROTATE(a,5)
|
||||
mux2 tmp6=$a,0x44 };; // see b in next iteration
|
||||
{ .mii; add $f=$f,tmp1 // f+=ROTATE(a,5)
|
||||
shrp $e=tmp2,tmp2,31 // f+1=ROTATE(x[0]^x[2]^x[8]^x[13],1)
|
||||
{ .mii; add $e=$e,tmp1 // e+=ROTATE(a,5)
|
||||
shrp $Xn=$Xn,$Xn,31 // ROTATE(x[0]^x[2]^x[8]^x[13],1)
|
||||
nop.i 0 };;
|
||||
|
||||
___
|
||||
@@ -142,49 +142,47 @@ ___
|
||||
|
||||
sub BODY_20_39 {
|
||||
local *code=shift;
|
||||
local ($i,$a,$b,$c,$d,$e,$f,$Konst)=@_;
|
||||
my ($i,$a,$b,$c,$d,$e,$Konst)=@_;
|
||||
$Konst = $K_20_39 if (!defined($Konst));
|
||||
my $j=$i+1;
|
||||
my $Xn=@X[$j%16];
|
||||
|
||||
if ($i<79) {
|
||||
$code.=<<___;
|
||||
{ .mib; mov $X[$i&0xf]=$f // Xupdate
|
||||
{ .mib; add $e=$e,$Konst // e+=K_XX_XX
|
||||
dep.z tmp5=$a,5,27 } // a<<5
|
||||
{ .mib; xor tmp0=$c,$b
|
||||
add tmp4=$e,$Konst };;
|
||||
{ .mmi; xor tmp0=tmp0,$d // F_20_39(b,c,d)=b^c^d
|
||||
add $f=$f,tmp4 // f+=e+K_20_39
|
||||
xor $Xn=$Xn,$X[($j+2)%16] };; // forward Xupdate
|
||||
{ .mib; add $e=$e,$X[$i%16] // e+=Xupdate
|
||||
extr.u tmp1=$a,27,5 } // a>>27
|
||||
{ .mmi; xor tmp2=$X[($i+0+1)&0xf],$X[($i+2+1)&0xf] // +1
|
||||
xor tmp3=$X[($i+8+1)&0xf],$X[($i+13+1)&0xf] // +1
|
||||
nop.i 0 };;
|
||||
{ .mmi; add $f=$f,tmp0 // f+=F_20_39(b,c,d)
|
||||
xor tmp2=tmp2,tmp3 // +1
|
||||
{ .mib; xor tmp0=tmp0,$d // F_20_39(b,c,d)=b^c^d
|
||||
xor $Xn=$Xn,$X[($j+8)%16] };; // forward Xupdate
|
||||
{ .mmi; add $e=$e,tmp0 // e+=F_20_39(b,c,d)
|
||||
xor $Xn=$Xn,$X[($j+13)%16] // forward Xupdate
|
||||
shrp $b=tmp6,tmp6,2 } // b=ROTATE(b,30)
|
||||
{ .mmi; or tmp1=tmp1,tmp5 // ROTATE(a,5)
|
||||
mux2 tmp6=$a,0x44 };; // see b in next iteration
|
||||
{ .mii; add $f=$f,tmp1 // f+=ROTATE(a,5)
|
||||
shrp $e=tmp2,tmp2,31 // f+1=ROTATE(x[0]^x[2]^x[8]^x[13],1)
|
||||
{ .mii; add $e=$e,tmp1 // e+=ROTATE(a,5)
|
||||
shrp $Xn=$Xn,$Xn,31 // ROTATE(x[0]^x[2]^x[8]^x[13],1)
|
||||
nop.i 0 };;
|
||||
|
||||
___
|
||||
}
|
||||
else {
|
||||
$code.=<<___;
|
||||
{ .mib; mov $X[$i&0xf]=$f // Xupdate
|
||||
{ .mib; add $e=$e,$Konst // e+=K_60_79
|
||||
dep.z tmp5=$a,5,27 } // a<<5
|
||||
{ .mib; xor tmp0=$c,$b
|
||||
add tmp4=$e,$Konst };;
|
||||
{ .mib; xor tmp0=tmp0,$d // F_20_39(b,c,d)=b^c^d
|
||||
extr.u tmp1=$a,27,5 } // a>>27
|
||||
{ .mib; add $f=$f,tmp4 // f+=e+K_20_39
|
||||
add $h1=$h1,$a };; // wrap up
|
||||
{ .mmi; add $f=$f,tmp0 // f+=F_20_39(b,c,d)
|
||||
shrp $b=tmp6,tmp6,2 } // b=ROTATE(b,30) ;;?
|
||||
{ .mmi; or tmp1=tmp1,tmp5 // ROTATE(a,5)
|
||||
{ .mib; add $e=$e,$X[$i%16] // e+=Xupdate
|
||||
extr.u tmp1=$a,27,5 } // a>>27
|
||||
{ .mib; xor tmp0=tmp0,$d // F_20_39(b,c,d)=b^c^d
|
||||
add $h3=$h3,$c };; // wrap up
|
||||
{ .mib; add tmp3=1,inp // used in unaligned codepath
|
||||
add $f=$f,tmp1 } // f+=ROTATE(a,5)
|
||||
{ .mib; add $h2=$h2,$b // wrap up
|
||||
{ .mmi; add $e=$e,tmp0 // e+=F_20_39(b,c,d)
|
||||
or tmp1=tmp1,tmp5 // ROTATE(a,5)
|
||||
shrp $b=tmp6,tmp6,2 };; // b=ROTATE(b,30) ;;?
|
||||
{ .mmi; add $e=$e,tmp1 // e+=ROTATE(a,5)
|
||||
add tmp3=1,inp // used in unaligned codepath
|
||||
add $h4=$h4,$d };; // wrap up
|
||||
|
||||
___
|
||||
@@ -193,29 +191,29 @@ ___
|
||||
|
||||
sub BODY_40_59 {
|
||||
local *code=shift;
|
||||
local ($i,$a,$b,$c,$d,$e,$f)=@_;
|
||||
my ($i,$a,$b,$c,$d,$e)=@_;
|
||||
my $j=$i+1;
|
||||
my $Xn=@X[$j%16];
|
||||
|
||||
$code.=<<___;
|
||||
{ .mmi; mov $X[$i&0xf]=$f // Xupdate
|
||||
and tmp0=$c,$b
|
||||
{ .mib; add $e=$e,$K_40_59 // e+=K_40_59
|
||||
dep.z tmp5=$a,5,27 } // a<<5
|
||||
{ .mmi; and tmp1=$d,$b
|
||||
add tmp4=$e,$K_40_59 };;
|
||||
{ .mmi; or tmp0=tmp0,tmp1 // (b&c)|(b&d)
|
||||
add $f=$f,tmp4 // f+=e+K_40_59
|
||||
{ .mib; and tmp1=$c,$d
|
||||
xor tmp0=$c,$d };;
|
||||
{ .mmi; add $e=$e,$X[$i%16] // e+=Xupdate
|
||||
add tmp5=tmp5,tmp1 // a<<5+(c&d)
|
||||
extr.u tmp1=$a,27,5 } // a>>27
|
||||
{ .mmi; and tmp4=$c,$d
|
||||
xor tmp2=$X[($i+0+1)&0xf],$X[($i+2+1)&0xf] // +1
|
||||
xor tmp3=$X[($i+8+1)&0xf],$X[($i+13+1)&0xf] // +1
|
||||
};;
|
||||
{ .mmi; or tmp1=tmp1,tmp5 // ROTATE(a,5)
|
||||
xor tmp2=tmp2,tmp3 // +1
|
||||
{ .mmi; and tmp0=tmp0,$b
|
||||
xor $Xn=$Xn,$X[($j+2)%16] // forward Xupdate
|
||||
xor tmp3=$X[($j+8)%16],$X[($j+13)%16] };; // forward Xupdate
|
||||
{ .mmi; add $e=$e,tmp0 // e+=b&(c^d)
|
||||
add tmp5=tmp5,tmp1 // ROTATE(a,5)+(c&d)
|
||||
shrp $b=tmp6,tmp6,2 } // b=ROTATE(b,30)
|
||||
{ .mmi; or tmp0=tmp0,tmp4 // F_40_59(b,c,d)=(b&c)|(b&d)|(c&d)
|
||||
{ .mmi; xor $Xn=$Xn,tmp3
|
||||
mux2 tmp6=$a,0x44 };; // see b in next iteration
|
||||
{ .mii; add $f=$f,tmp0 // f+=F_40_59(b,c,d)
|
||||
shrp $e=tmp2,tmp2,31;; // f+1=ROTATE(x[0]^x[2]^x[8]^x[13],1)
|
||||
add $f=$f,tmp1 };; // f+=ROTATE(a,5)
|
||||
{ .mii; add $e=$e,tmp5 // e+=ROTATE(a,5)+(c&d)
|
||||
shrp $Xn=$Xn,$Xn,31 // ROTATE(x[0]^x[2]^x[8]^x[13],1)
|
||||
nop.i 0x0 };;
|
||||
|
||||
___
|
||||
}
|
||||
@@ -237,7 +235,7 @@ inp=r33; // in1
|
||||
.align 32
|
||||
sha1_block_data_order:
|
||||
.prologue
|
||||
{ .mmi; alloc tmp1=ar.pfs,3,15,0,0
|
||||
{ .mmi; alloc tmp1=ar.pfs,3,14,0,0
|
||||
$ADDP tmp0=4,ctx
|
||||
.save ar.lc,r3
|
||||
mov r3=ar.lc }
|
||||
@@ -245,8 +243,8 @@ sha1_block_data_order:
|
||||
$ADDP inp=0,inp
|
||||
mov r2=pr };;
|
||||
tmp4=in2;
|
||||
tmp5=loc13;
|
||||
tmp6=loc14;
|
||||
tmp5=loc12;
|
||||
tmp6=loc13;
|
||||
.body
|
||||
{ .mlx; ld4 $h0=[ctx],8
|
||||
movl $K_00_19=0x5a827999 }
|
||||
@@ -273,7 +271,8 @@ tmp6=loc14;
|
||||
|
||||
___
|
||||
|
||||
{ my $i,@V=($A,$B,$C,$D,$E,$T);
|
||||
{ my $i;
|
||||
my @V=($A,$B,$C,$D,$E);
|
||||
|
||||
for($i=0;$i<16;$i++) { &BODY_00_15(\$code,$i,@V); unshift(@V,pop(@V)); }
|
||||
for(;$i<20;$i++) { &BODY_16_19(\$code,$i,@V); unshift(@V,pop(@V)); }
|
||||
@@ -281,12 +280,12 @@ ___
|
||||
for(;$i<60;$i++) { &BODY_40_59(\$code,$i,@V); unshift(@V,pop(@V)); }
|
||||
for(;$i<80;$i++) { &BODY_60_79(\$code,$i,@V); unshift(@V,pop(@V)); }
|
||||
|
||||
(($V[5] eq $D) and ($V[0] eq $E)) or die; # double-check
|
||||
(($V[0] eq $A) and ($V[4] eq $E)) or die; # double-check
|
||||
}
|
||||
|
||||
$code.=<<___;
|
||||
{ .mmb; add $h0=$h0,$E
|
||||
nop.m 0
|
||||
{ .mmb; add $h0=$h0,$A
|
||||
add $h2=$h2,$C
|
||||
br.ctop.dptk.many .Ldtop };;
|
||||
.Ldend:
|
||||
{ .mmi; add tmp0=4,ctx
|
||||
|
||||
1574
crypto/sha/asm/sha1-mb-x86_64.pl
Normal file
1574
crypto/sha/asm/sha1-mb-x86_64.pl
Normal file
File diff suppressed because it is too large
Load Diff
450
crypto/sha/asm/sha1-mips.pl
Normal file
450
crypto/sha/asm/sha1-mips.pl
Normal file
@@ -0,0 +1,450 @@
|
||||
#!/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 MIPS.
|
||||
|
||||
# Performance improvement is 30% on unaligned input. The "secret" is
|
||||
# to deploy lwl/lwr pair to load unaligned input. One could have
|
||||
# vectorized Xupdate on MIPSIII/IV, but the goal was to code MIPS32-
|
||||
# compatible subroutine. There is room for minor optimization on
|
||||
# little-endian platforms...
|
||||
|
||||
# September 2012.
|
||||
#
|
||||
# Add MIPS32r2 code (>25% less instructions).
|
||||
|
||||
######################################################################
|
||||
# There is a number of MIPS ABI in use, O32 and N32/64 are most
|
||||
# widely used. Then there is a new contender: NUBI. It appears that if
|
||||
# one picks the latter, it's possible to arrange code in ABI neutral
|
||||
# manner. Therefore let's stick to NUBI register layout:
|
||||
#
|
||||
($zero,$at,$t0,$t1,$t2)=map("\$$_",(0..2,24,25));
|
||||
($a0,$a1,$a2,$a3,$a4,$a5,$a6,$a7)=map("\$$_",(4..11));
|
||||
($s0,$s1,$s2,$s3,$s4,$s5,$s6,$s7,$s8,$s9,$s10,$s11)=map("\$$_",(12..23));
|
||||
($gp,$tp,$sp,$fp,$ra)=map("\$$_",(3,28..31));
|
||||
#
|
||||
# The return value is placed in $a0. Following coding rules facilitate
|
||||
# interoperability:
|
||||
#
|
||||
# - never ever touch $tp, "thread pointer", former $gp;
|
||||
# - copy return value to $t0, former $v0 [or to $a0 if you're adapting
|
||||
# old code];
|
||||
# - on O32 populate $a4-$a7 with 'lw $aN,4*N($sp)' if necessary;
|
||||
#
|
||||
# For reference here is register layout for N32/64 MIPS ABIs:
|
||||
#
|
||||
# ($zero,$at,$v0,$v1)=map("\$$_",(0..3));
|
||||
# ($a0,$a1,$a2,$a3,$a4,$a5,$a6,$a7)=map("\$$_",(4..11));
|
||||
# ($t0,$t1,$t2,$t3,$t8,$t9)=map("\$$_",(12..15,24,25));
|
||||
# ($s0,$s1,$s2,$s3,$s4,$s5,$s6,$s7)=map("\$$_",(16..23));
|
||||
# ($gp,$sp,$fp,$ra)=map("\$$_",(28..31));
|
||||
#
|
||||
$flavour = shift || "o32"; # supported flavours are o32,n32,64,nubi32,nubi64
|
||||
|
||||
if ($flavour =~ /64|n32/i) {
|
||||
$PTR_ADD="dadd"; # incidentally works even on n32
|
||||
$PTR_SUB="dsub"; # incidentally works even on n32
|
||||
$REG_S="sd";
|
||||
$REG_L="ld";
|
||||
$PTR_SLL="dsll"; # incidentally works even on n32
|
||||
$SZREG=8;
|
||||
} else {
|
||||
$PTR_ADD="add";
|
||||
$PTR_SUB="sub";
|
||||
$REG_S="sw";
|
||||
$REG_L="lw";
|
||||
$PTR_SLL="sll";
|
||||
$SZREG=4;
|
||||
}
|
||||
#
|
||||
# <appro@openssl.org>
|
||||
#
|
||||
######################################################################
|
||||
|
||||
$big_endian=(`echo MIPSEL | $ENV{CC} -E -`=~/MIPSEL/)?1:0 if ($ENV{CC});
|
||||
|
||||
for (@ARGV) { $output=$_ if (/^\w[\w\-]*\.\w+$/); }
|
||||
open STDOUT,">$output";
|
||||
|
||||
if (!defined($big_endian))
|
||||
{ $big_endian=(unpack('L',pack('N',1))==1); }
|
||||
|
||||
# offsets of the Most and Least Significant Bytes
|
||||
$MSB=$big_endian?0:3;
|
||||
$LSB=3&~$MSB;
|
||||
|
||||
@X=map("\$$_",(8..23)); # a4-a7,s0-s11
|
||||
|
||||
$ctx=$a0;
|
||||
$inp=$a1;
|
||||
$num=$a2;
|
||||
$A="\$1";
|
||||
$B="\$2";
|
||||
$C="\$3";
|
||||
$D="\$7";
|
||||
$E="\$24"; @V=($A,$B,$C,$D,$E);
|
||||
$t0="\$25";
|
||||
$t1=$num; # $num is offloaded to stack
|
||||
$t2="\$30"; # fp
|
||||
$K="\$31"; # ra
|
||||
|
||||
sub BODY_00_14 {
|
||||
my ($i,$a,$b,$c,$d,$e)=@_;
|
||||
my $j=$i+1;
|
||||
$code.=<<___ if (!$big_endian);
|
||||
#if defined(_MIPS_ARCH_MIPS32R2) || defined(_MIPS_ARCH_MIPS64R2)
|
||||
wsbh @X[$i],@X[$i] # byte swap($i)
|
||||
rotr @X[$i],@X[$i],16
|
||||
#else
|
||||
srl $t0,@X[$i],24 # byte swap($i)
|
||||
srl $t1,@X[$i],8
|
||||
andi $t2,@X[$i],0xFF00
|
||||
sll @X[$i],@X[$i],24
|
||||
andi $t1,0xFF00
|
||||
sll $t2,$t2,8
|
||||
or @X[$i],$t0
|
||||
or $t1,$t2
|
||||
or @X[$i],$t1
|
||||
#endif
|
||||
___
|
||||
$code.=<<___;
|
||||
#if defined(_MIPS_ARCH_MIPS32R2) || defined(_MIPS_ARCH_MIPS64R2)
|
||||
addu $e,$K # $i
|
||||
xor $t0,$c,$d
|
||||
rotr $t1,$a,27
|
||||
lwl @X[$j],$j*4+$MSB($inp)
|
||||
and $t0,$b
|
||||
addu $e,$t1
|
||||
lwr @X[$j],$j*4+$LSB($inp)
|
||||
xor $t0,$d
|
||||
addu $e,@X[$i]
|
||||
rotr $b,$b,2
|
||||
addu $e,$t0
|
||||
#else
|
||||
lwl @X[$j],$j*4+$MSB($inp)
|
||||
sll $t0,$a,5 # $i
|
||||
addu $e,$K
|
||||
lwr @X[$j],$j*4+$LSB($inp)
|
||||
srl $t1,$a,27
|
||||
addu $e,$t0
|
||||
xor $t0,$c,$d
|
||||
addu $e,$t1
|
||||
sll $t2,$b,30
|
||||
and $t0,$b
|
||||
srl $b,$b,2
|
||||
xor $t0,$d
|
||||
addu $e,@X[$i]
|
||||
or $b,$t2
|
||||
addu $e,$t0
|
||||
#endif
|
||||
___
|
||||
}
|
||||
|
||||
sub BODY_15_19 {
|
||||
my ($i,$a,$b,$c,$d,$e)=@_;
|
||||
my $j=$i+1;
|
||||
|
||||
$code.=<<___ if (!$big_endian && $i==15);
|
||||
#if defined(_MIPS_ARCH_MIPS32R2) || defined(_MIPS_ARCH_MIPS64R2)
|
||||
wsbh @X[$i],@X[$i] # byte swap($i)
|
||||
rotr @X[$i],@X[$i],16
|
||||
#else
|
||||
srl $t0,@X[$i],24 # byte swap($i)
|
||||
srl $t1,@X[$i],8
|
||||
andi $t2,@X[$i],0xFF00
|
||||
sll @X[$i],@X[$i],24
|
||||
andi $t1,0xFF00
|
||||
sll $t2,$t2,8
|
||||
or @X[$i],$t0
|
||||
or @X[$i],$t1
|
||||
or @X[$i],$t2
|
||||
#endif
|
||||
___
|
||||
$code.=<<___;
|
||||
#if defined(_MIPS_ARCH_MIPS32R2) || defined(_MIPS_ARCH_MIPS64R2)
|
||||
addu $e,$K # $i
|
||||
xor @X[$j%16],@X[($j+2)%16]
|
||||
xor $t0,$c,$d
|
||||
rotr $t1,$a,27
|
||||
xor @X[$j%16],@X[($j+8)%16]
|
||||
and $t0,$b
|
||||
addu $e,$t1
|
||||
xor @X[$j%16],@X[($j+13)%16]
|
||||
xor $t0,$d
|
||||
addu $e,@X[$i%16]
|
||||
rotr @X[$j%16],@X[$j%16],31
|
||||
rotr $b,$b,2
|
||||
addu $e,$t0
|
||||
#else
|
||||
xor @X[$j%16],@X[($j+2)%16]
|
||||
sll $t0,$a,5 # $i
|
||||
addu $e,$K
|
||||
srl $t1,$a,27
|
||||
addu $e,$t0
|
||||
xor @X[$j%16],@X[($j+8)%16]
|
||||
xor $t0,$c,$d
|
||||
addu $e,$t1
|
||||
xor @X[$j%16],@X[($j+13)%16]
|
||||
sll $t2,$b,30
|
||||
and $t0,$b
|
||||
srl $t1,@X[$j%16],31
|
||||
addu @X[$j%16],@X[$j%16]
|
||||
srl $b,$b,2
|
||||
xor $t0,$d
|
||||
or @X[$j%16],$t1
|
||||
addu $e,@X[$i%16]
|
||||
or $b,$t2
|
||||
addu $e,$t0
|
||||
#endif
|
||||
___
|
||||
}
|
||||
|
||||
sub BODY_20_39 {
|
||||
my ($i,$a,$b,$c,$d,$e)=@_;
|
||||
my $j=$i+1;
|
||||
$code.=<<___ if ($i<79);
|
||||
#if defined(_MIPS_ARCH_MIPS32R2) || defined(_MIPS_ARCH_MIPS64R2)
|
||||
xor @X[$j%16],@X[($j+2)%16]
|
||||
addu $e,$K # $i
|
||||
rotr $t1,$a,27
|
||||
xor @X[$j%16],@X[($j+8)%16]
|
||||
xor $t0,$c,$d
|
||||
addu $e,$t1
|
||||
xor @X[$j%16],@X[($j+13)%16]
|
||||
xor $t0,$b
|
||||
addu $e,@X[$i%16]
|
||||
rotr @X[$j%16],@X[$j%16],31
|
||||
rotr $b,$b,2
|
||||
addu $e,$t0
|
||||
#else
|
||||
xor @X[$j%16],@X[($j+2)%16]
|
||||
sll $t0,$a,5 # $i
|
||||
addu $e,$K
|
||||
srl $t1,$a,27
|
||||
addu $e,$t0
|
||||
xor @X[$j%16],@X[($j+8)%16]
|
||||
xor $t0,$c,$d
|
||||
addu $e,$t1
|
||||
xor @X[$j%16],@X[($j+13)%16]
|
||||
sll $t2,$b,30
|
||||
xor $t0,$b
|
||||
srl $t1,@X[$j%16],31
|
||||
addu @X[$j%16],@X[$j%16]
|
||||
srl $b,$b,2
|
||||
addu $e,@X[$i%16]
|
||||
or @X[$j%16],$t1
|
||||
or $b,$t2
|
||||
addu $e,$t0
|
||||
#endif
|
||||
___
|
||||
$code.=<<___ if ($i==79);
|
||||
#if defined(_MIPS_ARCH_MIPS32R2) || defined(_MIPS_ARCH_MIPS64R2)
|
||||
lw @X[0],0($ctx)
|
||||
addu $e,$K # $i
|
||||
lw @X[1],4($ctx)
|
||||
rotr $t1,$a,27
|
||||
lw @X[2],8($ctx)
|
||||
xor $t0,$c,$d
|
||||
addu $e,$t1
|
||||
lw @X[3],12($ctx)
|
||||
xor $t0,$b
|
||||
addu $e,@X[$i%16]
|
||||
lw @X[4],16($ctx)
|
||||
rotr $b,$b,2
|
||||
addu $e,$t0
|
||||
#else
|
||||
lw @X[0],0($ctx)
|
||||
sll $t0,$a,5 # $i
|
||||
addu $e,$K
|
||||
lw @X[1],4($ctx)
|
||||
srl $t1,$a,27
|
||||
addu $e,$t0
|
||||
lw @X[2],8($ctx)
|
||||
xor $t0,$c,$d
|
||||
addu $e,$t1
|
||||
lw @X[3],12($ctx)
|
||||
sll $t2,$b,30
|
||||
xor $t0,$b
|
||||
lw @X[4],16($ctx)
|
||||
srl $b,$b,2
|
||||
addu $e,@X[$i%16]
|
||||
or $b,$t2
|
||||
addu $e,$t0
|
||||
#endif
|
||||
___
|
||||
}
|
||||
|
||||
sub BODY_40_59 {
|
||||
my ($i,$a,$b,$c,$d,$e)=@_;
|
||||
my $j=$i+1;
|
||||
$code.=<<___ if ($i<79);
|
||||
#if defined(_MIPS_ARCH_MIPS32R2) || defined(_MIPS_ARCH_MIPS64R2)
|
||||
addu $e,$K # $i
|
||||
and $t0,$c,$d
|
||||
xor @X[$j%16],@X[($j+2)%16]
|
||||
rotr $t1,$a,27
|
||||
addu $e,$t0
|
||||
xor @X[$j%16],@X[($j+8)%16]
|
||||
xor $t0,$c,$d
|
||||
addu $e,$t1
|
||||
xor @X[$j%16],@X[($j+13)%16]
|
||||
and $t0,$b
|
||||
addu $e,@X[$i%16]
|
||||
rotr @X[$j%16],@X[$j%16],31
|
||||
rotr $b,$b,2
|
||||
addu $e,$t0
|
||||
#else
|
||||
xor @X[$j%16],@X[($j+2)%16]
|
||||
sll $t0,$a,5 # $i
|
||||
addu $e,$K
|
||||
srl $t1,$a,27
|
||||
addu $e,$t0
|
||||
xor @X[$j%16],@X[($j+8)%16]
|
||||
and $t0,$c,$d
|
||||
addu $e,$t1
|
||||
xor @X[$j%16],@X[($j+13)%16]
|
||||
sll $t2,$b,30
|
||||
addu $e,$t0
|
||||
srl $t1,@X[$j%16],31
|
||||
xor $t0,$c,$d
|
||||
addu @X[$j%16],@X[$j%16]
|
||||
and $t0,$b
|
||||
srl $b,$b,2
|
||||
or @X[$j%16],$t1
|
||||
addu $e,@X[$i%16]
|
||||
or $b,$t2
|
||||
addu $e,$t0
|
||||
#endif
|
||||
___
|
||||
}
|
||||
|
||||
$FRAMESIZE=16; # large enough to accomodate NUBI saved registers
|
||||
$SAVED_REGS_MASK = ($flavour =~ /nubi/i) ? 0xc0fff008 : 0xc0ff0000;
|
||||
|
||||
$code=<<___;
|
||||
#ifdef OPENSSL_FIPSCANISTER
|
||||
# include <openssl/fipssyms.h>
|
||||
#endif
|
||||
|
||||
#if defined(__mips_smartmips) && !defined(_MIPS_ARCH_MIPS32R2)
|
||||
#define _MIPS_ARCH_MIPS32R2
|
||||
#endif
|
||||
|
||||
.text
|
||||
|
||||
.set noat
|
||||
.set noreorder
|
||||
.align 5
|
||||
.globl sha1_block_data_order
|
||||
.ent sha1_block_data_order
|
||||
sha1_block_data_order:
|
||||
.frame $sp,$FRAMESIZE*$SZREG,$ra
|
||||
.mask $SAVED_REGS_MASK,-$SZREG
|
||||
.set noreorder
|
||||
$PTR_SUB $sp,$FRAMESIZE*$SZREG
|
||||
$REG_S $ra,($FRAMESIZE-1)*$SZREG($sp)
|
||||
$REG_S $fp,($FRAMESIZE-2)*$SZREG($sp)
|
||||
$REG_S $s11,($FRAMESIZE-3)*$SZREG($sp)
|
||||
$REG_S $s10,($FRAMESIZE-4)*$SZREG($sp)
|
||||
$REG_S $s9,($FRAMESIZE-5)*$SZREG($sp)
|
||||
$REG_S $s8,($FRAMESIZE-6)*$SZREG($sp)
|
||||
$REG_S $s7,($FRAMESIZE-7)*$SZREG($sp)
|
||||
$REG_S $s6,($FRAMESIZE-8)*$SZREG($sp)
|
||||
$REG_S $s5,($FRAMESIZE-9)*$SZREG($sp)
|
||||
$REG_S $s4,($FRAMESIZE-10)*$SZREG($sp)
|
||||
___
|
||||
$code.=<<___ if ($flavour =~ /nubi/i); # optimize non-nubi prologue
|
||||
$REG_S $s3,($FRAMESIZE-11)*$SZREG($sp)
|
||||
$REG_S $s2,($FRAMESIZE-12)*$SZREG($sp)
|
||||
$REG_S $s1,($FRAMESIZE-13)*$SZREG($sp)
|
||||
$REG_S $s0,($FRAMESIZE-14)*$SZREG($sp)
|
||||
$REG_S $gp,($FRAMESIZE-15)*$SZREG($sp)
|
||||
___
|
||||
$code.=<<___;
|
||||
$PTR_SLL $num,6
|
||||
$PTR_ADD $num,$inp
|
||||
$REG_S $num,0($sp)
|
||||
lw $A,0($ctx)
|
||||
lw $B,4($ctx)
|
||||
lw $C,8($ctx)
|
||||
lw $D,12($ctx)
|
||||
b .Loop
|
||||
lw $E,16($ctx)
|
||||
.align 4
|
||||
.Loop:
|
||||
.set reorder
|
||||
lwl @X[0],$MSB($inp)
|
||||
lui $K,0x5a82
|
||||
lwr @X[0],$LSB($inp)
|
||||
ori $K,0x7999 # K_00_19
|
||||
___
|
||||
for ($i=0;$i<15;$i++) { &BODY_00_14($i,@V); unshift(@V,pop(@V)); }
|
||||
for (;$i<20;$i++) { &BODY_15_19($i,@V); unshift(@V,pop(@V)); }
|
||||
$code.=<<___;
|
||||
lui $K,0x6ed9
|
||||
ori $K,0xeba1 # K_20_39
|
||||
___
|
||||
for (;$i<40;$i++) { &BODY_20_39($i,@V); unshift(@V,pop(@V)); }
|
||||
$code.=<<___;
|
||||
lui $K,0x8f1b
|
||||
ori $K,0xbcdc # K_40_59
|
||||
___
|
||||
for (;$i<60;$i++) { &BODY_40_59($i,@V); unshift(@V,pop(@V)); }
|
||||
$code.=<<___;
|
||||
lui $K,0xca62
|
||||
ori $K,0xc1d6 # K_60_79
|
||||
___
|
||||
for (;$i<80;$i++) { &BODY_20_39($i,@V); unshift(@V,pop(@V)); }
|
||||
$code.=<<___;
|
||||
$PTR_ADD $inp,64
|
||||
$REG_L $num,0($sp)
|
||||
|
||||
addu $A,$X[0]
|
||||
addu $B,$X[1]
|
||||
sw $A,0($ctx)
|
||||
addu $C,$X[2]
|
||||
addu $D,$X[3]
|
||||
sw $B,4($ctx)
|
||||
addu $E,$X[4]
|
||||
sw $C,8($ctx)
|
||||
sw $D,12($ctx)
|
||||
sw $E,16($ctx)
|
||||
.set noreorder
|
||||
bne $inp,$num,.Loop
|
||||
nop
|
||||
|
||||
.set noreorder
|
||||
$REG_L $ra,($FRAMESIZE-1)*$SZREG($sp)
|
||||
$REG_L $fp,($FRAMESIZE-2)*$SZREG($sp)
|
||||
$REG_L $s11,($FRAMESIZE-3)*$SZREG($sp)
|
||||
$REG_L $s10,($FRAMESIZE-4)*$SZREG($sp)
|
||||
$REG_L $s9,($FRAMESIZE-5)*$SZREG($sp)
|
||||
$REG_L $s8,($FRAMESIZE-6)*$SZREG($sp)
|
||||
$REG_L $s7,($FRAMESIZE-7)*$SZREG($sp)
|
||||
$REG_L $s6,($FRAMESIZE-8)*$SZREG($sp)
|
||||
$REG_L $s5,($FRAMESIZE-9)*$SZREG($sp)
|
||||
$REG_L $s4,($FRAMESIZE-10)*$SZREG($sp)
|
||||
___
|
||||
$code.=<<___ if ($flavour =~ /nubi/i);
|
||||
$REG_L $s3,($FRAMESIZE-11)*$SZREG($sp)
|
||||
$REG_L $s2,($FRAMESIZE-12)*$SZREG($sp)
|
||||
$REG_L $s1,($FRAMESIZE-13)*$SZREG($sp)
|
||||
$REG_L $s0,($FRAMESIZE-14)*$SZREG($sp)
|
||||
$REG_L $gp,($FRAMESIZE-15)*$SZREG($sp)
|
||||
___
|
||||
$code.=<<___;
|
||||
jr $ra
|
||||
$PTR_ADD $sp,$FRAMESIZE*$SZREG
|
||||
.end sha1_block_data_order
|
||||
.rdata
|
||||
.asciiz "SHA1 for MIPS, CRYPTOGAMS by <appro\@openssl.org>"
|
||||
___
|
||||
print $code;
|
||||
close STDOUT;
|
||||
260
crypto/sha/asm/sha1-parisc.pl
Normal file
260
crypto/sha/asm/sha1-parisc.pl
Normal file
@@ -0,0 +1,260 @@
|
||||
#!/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);
|
||||
$code =~ s/\bbv\b/bve/gm if ($SIZE_T==8);
|
||||
print $code;
|
||||
close STDOUT;
|
||||
@@ -9,8 +9,7 @@
|
||||
|
||||
# I let hardware handle unaligned input(*), except on page boundaries
|
||||
# (see below for details). Otherwise straightforward implementation
|
||||
# with X vector in register bank. The module is big-endian [which is
|
||||
# not big deal as there're no little-endian targets left around].
|
||||
# with X vector in register bank.
|
||||
#
|
||||
# (*) this means that this module is inappropriate for PPC403? Does
|
||||
# anybody know if pre-POWER3 can sustain unaligned load?
|
||||
@@ -24,18 +23,24 @@ $flavour = shift;
|
||||
|
||||
if ($flavour =~ /64/) {
|
||||
$SIZE_T =8;
|
||||
$LRSAVE =2*$SIZE_T;
|
||||
$UCMP ="cmpld";
|
||||
$STU ="stdu";
|
||||
$POP ="ld";
|
||||
$PUSH ="std";
|
||||
} elsif ($flavour =~ /32/) {
|
||||
$SIZE_T =4;
|
||||
$LRSAVE =$SIZE_T;
|
||||
$UCMP ="cmplw";
|
||||
$STU ="stwu";
|
||||
$POP ="lwz";
|
||||
$PUSH ="stw";
|
||||
} else { die "nonsense $flavour"; }
|
||||
|
||||
# Define endianess based on flavour
|
||||
# i.e.: linux64le
|
||||
$LITTLE_ENDIAN = ($flavour=~/le$/) ? $SIZE_T : 0;
|
||||
|
||||
$0 =~ m/(.*[\/\\])[^\/\\]+$/; $dir=$1;
|
||||
( $xlate="${dir}ppc-xlate.pl" and -f $xlate ) or
|
||||
( $xlate="${dir}../../perlasm/ppc-xlate.pl" and -f $xlate) or
|
||||
@@ -43,7 +48,8 @@ die "can't locate ppc-xlate.pl";
|
||||
|
||||
open STDOUT,"| $^X $xlate $flavour ".shift || die "can't call $xlate: $!";
|
||||
|
||||
$FRAME=24*$SIZE_T;
|
||||
$FRAME=24*$SIZE_T+64;
|
||||
$LOCALS=6*$SIZE_T;
|
||||
|
||||
$K ="r0";
|
||||
$sp ="r1";
|
||||
@@ -65,14 +71,28 @@ $T ="r12";
|
||||
@X=("r16","r17","r18","r19","r20","r21","r22","r23",
|
||||
"r24","r25","r26","r27","r28","r29","r30","r31");
|
||||
|
||||
sub loadbe {
|
||||
my ($dst, $src, $temp_reg) = @_;
|
||||
$code.=<<___ if (!$LITTLE_ENDIAN);
|
||||
lwz $dst,$src
|
||||
___
|
||||
$code.=<<___ if ($LITTLE_ENDIAN);
|
||||
lwz $temp_reg,$src
|
||||
rotlwi $dst,$temp_reg,8
|
||||
rlwimi $dst,$temp_reg,24,0,7
|
||||
rlwimi $dst,$temp_reg,24,16,23
|
||||
___
|
||||
}
|
||||
|
||||
sub BODY_00_19 {
|
||||
my ($i,$a,$b,$c,$d,$e,$f)=@_;
|
||||
my $j=$i+1;
|
||||
$code.=<<___ if ($i==0);
|
||||
lwz @X[$i],`$i*4`($inp)
|
||||
___
|
||||
|
||||
# Since the last value of $f is discarded, we can use
|
||||
# it as a temp reg to swap byte-order when needed.
|
||||
loadbe("@X[$i]","`$i*4`($inp)",$f) if ($i==0);
|
||||
loadbe("@X[$j]","`$j*4`($inp)",$f) if ($i<15);
|
||||
$code.=<<___ if ($i<15);
|
||||
lwz @X[$j],`$j*4`($inp)
|
||||
add $f,$K,$e
|
||||
rotlwi $e,$a,5
|
||||
add $f,$f,@X[$i]
|
||||
@@ -105,31 +125,31 @@ my ($i,$a,$b,$c,$d,$e,$f)=@_;
|
||||
my $j=$i+1;
|
||||
$code.=<<___ if ($i<79);
|
||||
add $f,$K,$e
|
||||
xor $t0,$b,$d
|
||||
rotlwi $e,$a,5
|
||||
xor @X[$j%16],@X[$j%16],@X[($j+2)%16]
|
||||
add $f,$f,@X[$i%16]
|
||||
xor $t0,$b,$c
|
||||
xor $t0,$t0,$c
|
||||
xor @X[$j%16],@X[$j%16],@X[($j+8)%16]
|
||||
add $f,$f,$e
|
||||
rotlwi $b,$b,30
|
||||
xor $t0,$t0,$d
|
||||
xor @X[$j%16],@X[$j%16],@X[($j+13)%16]
|
||||
add $f,$f,$t0
|
||||
rotlwi $b,$b,30
|
||||
xor @X[$j%16],@X[$j%16],@X[($j+13)%16]
|
||||
add $f,$f,$e
|
||||
rotlwi @X[$j%16],@X[$j%16],1
|
||||
___
|
||||
$code.=<<___ if ($i==79);
|
||||
add $f,$K,$e
|
||||
xor $t0,$b,$d
|
||||
rotlwi $e,$a,5
|
||||
lwz r16,0($ctx)
|
||||
add $f,$f,@X[$i%16]
|
||||
xor $t0,$b,$c
|
||||
xor $t0,$t0,$c
|
||||
lwz r17,4($ctx)
|
||||
add $f,$f,$e
|
||||
add $f,$f,$t0
|
||||
rotlwi $b,$b,30
|
||||
lwz r18,8($ctx)
|
||||
xor $t0,$t0,$d
|
||||
lwz r19,12($ctx)
|
||||
add $f,$f,$t0
|
||||
add $f,$f,$e
|
||||
lwz r20,16($ctx)
|
||||
___
|
||||
}
|
||||
@@ -162,9 +182,8 @@ $code=<<___;
|
||||
.globl .sha1_block_data_order
|
||||
.align 4
|
||||
.sha1_block_data_order:
|
||||
$STU $sp,-$FRAME($sp)
|
||||
mflr r0
|
||||
$STU $sp,`-($FRAME+64)`($sp)
|
||||
$PUSH r0,`$FRAME-$SIZE_T*18`($sp)
|
||||
$PUSH r15,`$FRAME-$SIZE_T*17`($sp)
|
||||
$PUSH r16,`$FRAME-$SIZE_T*16`($sp)
|
||||
$PUSH r17,`$FRAME-$SIZE_T*15`($sp)
|
||||
@@ -182,6 +201,7 @@ $code=<<___;
|
||||
$PUSH r29,`$FRAME-$SIZE_T*3`($sp)
|
||||
$PUSH r30,`$FRAME-$SIZE_T*2`($sp)
|
||||
$PUSH r31,`$FRAME-$SIZE_T*1`($sp)
|
||||
$PUSH r0,`$FRAME+$LRSAVE`($sp)
|
||||
lwz $A,0($ctx)
|
||||
lwz $B,4($ctx)
|
||||
lwz $C,8($ctx)
|
||||
@@ -192,8 +212,53 @@ $code=<<___;
|
||||
Laligned:
|
||||
mtctr $num
|
||||
bl Lsha1_block_private
|
||||
b Ldone
|
||||
|
||||
; PowerPC specification allows an implementation to be ill-behaved
|
||||
; upon unaligned access which crosses page boundary. "Better safe
|
||||
; than sorry" principle makes me treat it specially. But I don't
|
||||
; look for particular offending word, but rather for 64-byte input
|
||||
; block which crosses the boundary. Once found that block is aligned
|
||||
; and hashed separately...
|
||||
.align 4
|
||||
Lunaligned:
|
||||
subfic $t1,$inp,4096
|
||||
andi. $t1,$t1,4095 ; distance to closest page boundary
|
||||
srwi. $t1,$t1,6 ; t1/=64
|
||||
beq Lcross_page
|
||||
$UCMP $num,$t1
|
||||
ble- Laligned ; didn't cross the page boundary
|
||||
mtctr $t1
|
||||
subfc $num,$t1,$num
|
||||
bl Lsha1_block_private
|
||||
Lcross_page:
|
||||
li $t1,16
|
||||
mtctr $t1
|
||||
addi r20,$sp,$LOCALS ; spot within the frame
|
||||
Lmemcpy:
|
||||
lbz r16,0($inp)
|
||||
lbz r17,1($inp)
|
||||
lbz r18,2($inp)
|
||||
lbz r19,3($inp)
|
||||
addi $inp,$inp,4
|
||||
stb r16,0(r20)
|
||||
stb r17,1(r20)
|
||||
stb r18,2(r20)
|
||||
stb r19,3(r20)
|
||||
addi r20,r20,4
|
||||
bdnz Lmemcpy
|
||||
|
||||
$PUSH $inp,`$FRAME-$SIZE_T*18`($sp)
|
||||
li $t1,1
|
||||
addi $inp,$sp,$LOCALS
|
||||
mtctr $t1
|
||||
bl Lsha1_block_private
|
||||
$POP $inp,`$FRAME-$SIZE_T*18`($sp)
|
||||
addic. $num,$num,-1
|
||||
bne- Lunaligned
|
||||
|
||||
Ldone:
|
||||
$POP r0,`$FRAME-$SIZE_T*18`($sp)
|
||||
$POP r0,`$FRAME+$LRSAVE`($sp)
|
||||
$POP r15,`$FRAME-$SIZE_T*17`($sp)
|
||||
$POP r16,`$FRAME-$SIZE_T*16`($sp)
|
||||
$POP r17,`$FRAME-$SIZE_T*15`($sp)
|
||||
@@ -212,54 +277,11 @@ Ldone:
|
||||
$POP r30,`$FRAME-$SIZE_T*2`($sp)
|
||||
$POP r31,`$FRAME-$SIZE_T*1`($sp)
|
||||
mtlr r0
|
||||
addi $sp,$sp,`$FRAME+64`
|
||||
addi $sp,$sp,$FRAME
|
||||
blr
|
||||
___
|
||||
|
||||
# PowerPC specification allows an implementation to be ill-behaved
|
||||
# upon unaligned access which crosses page boundary. "Better safe
|
||||
# than sorry" principle makes me treat it specially. But I don't
|
||||
# look for particular offending word, but rather for 64-byte input
|
||||
# block which crosses the boundary. Once found that block is aligned
|
||||
# and hashed separately...
|
||||
$code.=<<___;
|
||||
.align 4
|
||||
Lunaligned:
|
||||
subfic $t1,$inp,4096
|
||||
andi. $t1,$t1,4095 ; distance to closest page boundary
|
||||
srwi. $t1,$t1,6 ; t1/=64
|
||||
beq Lcross_page
|
||||
$UCMP $num,$t1
|
||||
ble- Laligned ; didn't cross the page boundary
|
||||
mtctr $t1
|
||||
subfc $num,$t1,$num
|
||||
bl Lsha1_block_private
|
||||
Lcross_page:
|
||||
li $t1,16
|
||||
mtctr $t1
|
||||
addi r20,$sp,$FRAME ; spot below the frame
|
||||
Lmemcpy:
|
||||
lbz r16,0($inp)
|
||||
lbz r17,1($inp)
|
||||
lbz r18,2($inp)
|
||||
lbz r19,3($inp)
|
||||
addi $inp,$inp,4
|
||||
stb r16,0(r20)
|
||||
stb r17,1(r20)
|
||||
stb r18,2(r20)
|
||||
stb r19,3(r20)
|
||||
addi r20,r20,4
|
||||
bdnz Lmemcpy
|
||||
|
||||
$PUSH $inp,`$FRAME-$SIZE_T*19`($sp)
|
||||
li $t1,1
|
||||
addi $inp,$sp,$FRAME
|
||||
mtctr $t1
|
||||
bl Lsha1_block_private
|
||||
$POP $inp,`$FRAME-$SIZE_T*19`($sp)
|
||||
addic. $num,$num,-1
|
||||
bne- Lunaligned
|
||||
b Ldone
|
||||
.long 0
|
||||
.byte 0,12,4,1,0x80,18,3,0
|
||||
.long 0
|
||||
___
|
||||
|
||||
# This is private block function, which uses tailored calling
|
||||
@@ -309,6 +331,9 @@ $code.=<<___;
|
||||
addi $inp,$inp,`16*4`
|
||||
bdnz- Lsha1_block_private
|
||||
blr
|
||||
.long 0
|
||||
.byte 0,12,0x14,0,0,0,0,0
|
||||
.size .sha1_block_data_order,.-.sha1_block_data_order
|
||||
___
|
||||
$code.=<<___;
|
||||
.asciz "SHA1 block transform for PPC, CRYPTOGAMS by <appro\@fy.chalmers.se>"
|
||||
|
||||
@@ -21,9 +21,28 @@
|
||||
# instructions to favour dual-issue z10 pipeline. On z10 hardware is
|
||||
# "only" ~2.3x faster than software.
|
||||
|
||||
# November 2010.
|
||||
#
|
||||
# Adapt for -m31 build. If kernel supports what's called "highgprs"
|
||||
# feature on Linux [see /proc/cpuinfo], it's possible to use 64-bit
|
||||
# instructions and achieve "64-bit" performance even in 31-bit legacy
|
||||
# application context. The feature is not specific to any particular
|
||||
# processor, as long as it's "z-CPU". Latter implies that the code
|
||||
# remains z/Architecture specific.
|
||||
|
||||
$kimdfunc=1; # magic function code for kimd instruction
|
||||
|
||||
$output=shift;
|
||||
$flavour = shift;
|
||||
|
||||
if ($flavour =~ /3[12]/) {
|
||||
$SIZE_T=4;
|
||||
$g="";
|
||||
} else {
|
||||
$SIZE_T=8;
|
||||
$g="g";
|
||||
}
|
||||
|
||||
while (($output=shift) && ($output!~/^\w[\w\-]*\.\w+$/)) {}
|
||||
open STDOUT,">$output";
|
||||
|
||||
$K_00_39="%r0"; $K=$K_00_39;
|
||||
@@ -42,13 +61,14 @@ $t1="%r11";
|
||||
@X=("%r12","%r13","%r14");
|
||||
$sp="%r15";
|
||||
|
||||
$frame=160+16*4;
|
||||
$stdframe=16*$SIZE_T+4*8;
|
||||
$frame=$stdframe+16*4;
|
||||
|
||||
sub Xupdate {
|
||||
my $i=shift;
|
||||
|
||||
$code.=<<___ if ($i==15);
|
||||
lg $prefetch,160($sp) ### Xupdate(16) warm-up
|
||||
lg $prefetch,$stdframe($sp) ### Xupdate(16) warm-up
|
||||
lr $X[0],$X[2]
|
||||
___
|
||||
return if ($i&1); # Xupdate is vectorized and executed every 2nd cycle
|
||||
@@ -58,8 +78,8 @@ $code.=<<___ if ($i<16);
|
||||
___
|
||||
$code.=<<___ if ($i>=16);
|
||||
xgr $X[0],$prefetch ### Xupdate($i)
|
||||
lg $prefetch,`160+4*(($i+2)%16)`($sp)
|
||||
xg $X[0],`160+4*(($i+8)%16)`($sp)
|
||||
lg $prefetch,`$stdframe+4*(($i+2)%16)`($sp)
|
||||
xg $X[0],`$stdframe+4*(($i+8)%16)`($sp)
|
||||
xgr $X[0],$prefetch
|
||||
rll $X[0],$X[0],1
|
||||
rllg $X[1],$X[0],32
|
||||
@@ -68,7 +88,7 @@ $code.=<<___ if ($i>=16);
|
||||
lr $X[2],$X[1] # feedback
|
||||
___
|
||||
$code.=<<___ if ($i<=70);
|
||||
stg $X[0],`160+4*($i%16)`($sp)
|
||||
stg $X[0],`$stdframe+4*($i%16)`($sp)
|
||||
___
|
||||
unshift(@X,pop(@X));
|
||||
}
|
||||
@@ -148,9 +168,9 @@ $code.=<<___ if ($kimdfunc);
|
||||
tmhl %r0,0x4000 # check for message-security assist
|
||||
jz .Lsoftware
|
||||
lghi %r0,0
|
||||
la %r1,16($sp)
|
||||
la %r1,`2*$SIZE_T`($sp)
|
||||
.long 0xb93e0002 # kimd %r0,%r2
|
||||
lg %r0,16($sp)
|
||||
lg %r0,`2*$SIZE_T`($sp)
|
||||
tmhh %r0,`0x8000>>$kimdfunc`
|
||||
jz .Lsoftware
|
||||
lghi %r0,$kimdfunc
|
||||
@@ -165,11 +185,11 @@ $code.=<<___ if ($kimdfunc);
|
||||
___
|
||||
$code.=<<___;
|
||||
lghi %r1,-$frame
|
||||
stg $ctx,16($sp)
|
||||
stmg %r6,%r15,48($sp)
|
||||
st${g} $ctx,`2*$SIZE_T`($sp)
|
||||
stm${g} %r6,%r15,`6*$SIZE_T`($sp)
|
||||
lgr %r0,$sp
|
||||
la $sp,0(%r1,$sp)
|
||||
stg %r0,0($sp)
|
||||
st${g} %r0,0($sp)
|
||||
|
||||
larl $t0,Ktable
|
||||
llgf $A,0($ctx)
|
||||
@@ -199,7 +219,7 @@ ___
|
||||
for (;$i<80;$i++) { &BODY_20_39($i,@V); unshift(@V,pop(@V)); }
|
||||
$code.=<<___;
|
||||
|
||||
lg $ctx,`$frame+16`($sp)
|
||||
l${g} $ctx,`$frame+2*$SIZE_T`($sp)
|
||||
la $inp,64($inp)
|
||||
al $A,0($ctx)
|
||||
al $B,4($ctx)
|
||||
@@ -211,13 +231,13 @@ $code.=<<___;
|
||||
st $C,8($ctx)
|
||||
st $D,12($ctx)
|
||||
st $E,16($ctx)
|
||||
brct $len,.Lloop
|
||||
brct${g} $len,.Lloop
|
||||
|
||||
lmg %r6,%r15,`$frame+48`($sp)
|
||||
lm${g} %r6,%r15,`$frame+6*$SIZE_T`($sp)
|
||||
br %r14
|
||||
.size sha1_block_data_order,.-sha1_block_data_order
|
||||
.string "SHA1 block transform for s390x, CRYPTOGAMS by <appro\@openssl.org>"
|
||||
.comm OPENSSL_s390xcap_P,8,8
|
||||
.comm OPENSSL_s390xcap_P,16,8
|
||||
___
|
||||
|
||||
$code =~ s/\`([^\`]*)\`/eval $1/gem;
|
||||
|
||||
@@ -5,6 +5,8 @@
|
||||
# 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/.
|
||||
#
|
||||
# Hardware SPARC T4 support by David S. Miller <davem@davemloft.net>.
|
||||
# ====================================================================
|
||||
|
||||
# Performance improvement is not really impressive on pre-T1 CPU: +8%
|
||||
@@ -18,10 +20,10 @@
|
||||
# ensure scalability on UltraSPARC T1, or rather to avoid decay when
|
||||
# amount of active threads exceeds the number of physical cores.
|
||||
|
||||
$bits=32;
|
||||
for (@ARGV) { $bits=64 if (/\-m64/ || /\-xarch\=v9/); }
|
||||
if ($bits==64) { $bias=2047; $frame=192; }
|
||||
else { $bias=0; $frame=112; }
|
||||
# SPARC T4 SHA1 hardware achieves 3.72 cycles per byte, which is 3.1x
|
||||
# faster than software. Multi-process benchmark saturates at 11x
|
||||
# single-process result on 8-core processor, or ~9GBps per 2.85GHz
|
||||
# socket.
|
||||
|
||||
$output=shift;
|
||||
open STDOUT,">$output";
|
||||
@@ -178,17 +180,102 @@ $code.=<<___;
|
||||
___
|
||||
}
|
||||
|
||||
$code.=<<___ if ($bits==64);
|
||||
$code.=<<___;
|
||||
#include "sparc_arch.h"
|
||||
|
||||
#ifdef __arch64__
|
||||
.register %g2,#scratch
|
||||
.register %g3,#scratch
|
||||
___
|
||||
$code.=<<___;
|
||||
#endif
|
||||
|
||||
.section ".text",#alloc,#execinstr
|
||||
|
||||
#ifdef __PIC__
|
||||
SPARC_PIC_THUNK(%g1)
|
||||
#endif
|
||||
|
||||
.align 32
|
||||
.globl sha1_block_data_order
|
||||
sha1_block_data_order:
|
||||
save %sp,-$frame,%sp
|
||||
SPARC_LOAD_ADDRESS_LEAF(OPENSSL_sparcv9cap_P,%g1,%g5)
|
||||
ld [%g1+4],%g1 ! OPENSSL_sparcv9cap_P[1]
|
||||
|
||||
andcc %g1, CFR_SHA1, %g0
|
||||
be .Lsoftware
|
||||
nop
|
||||
|
||||
ld [%o0 + 0x00], %f0 ! load context
|
||||
ld [%o0 + 0x04], %f1
|
||||
ld [%o0 + 0x08], %f2
|
||||
andcc %o1, 0x7, %g0
|
||||
ld [%o0 + 0x0c], %f3
|
||||
bne,pn %icc, .Lhwunaligned
|
||||
ld [%o0 + 0x10], %f4
|
||||
|
||||
.Lhw_loop:
|
||||
ldd [%o1 + 0x00], %f8
|
||||
ldd [%o1 + 0x08], %f10
|
||||
ldd [%o1 + 0x10], %f12
|
||||
ldd [%o1 + 0x18], %f14
|
||||
ldd [%o1 + 0x20], %f16
|
||||
ldd [%o1 + 0x28], %f18
|
||||
ldd [%o1 + 0x30], %f20
|
||||
subcc %o2, 1, %o2 ! done yet?
|
||||
ldd [%o1 + 0x38], %f22
|
||||
add %o1, 0x40, %o1
|
||||
prefetch [%o1 + 63], 20
|
||||
|
||||
.word 0x81b02820 ! SHA1
|
||||
|
||||
bne,pt SIZE_T_CC, .Lhw_loop
|
||||
nop
|
||||
|
||||
.Lhwfinish:
|
||||
st %f0, [%o0 + 0x00] ! store context
|
||||
st %f1, [%o0 + 0x04]
|
||||
st %f2, [%o0 + 0x08]
|
||||
st %f3, [%o0 + 0x0c]
|
||||
retl
|
||||
st %f4, [%o0 + 0x10]
|
||||
|
||||
.align 8
|
||||
.Lhwunaligned:
|
||||
alignaddr %o1, %g0, %o1
|
||||
|
||||
ldd [%o1 + 0x00], %f10
|
||||
.Lhwunaligned_loop:
|
||||
ldd [%o1 + 0x08], %f12
|
||||
ldd [%o1 + 0x10], %f14
|
||||
ldd [%o1 + 0x18], %f16
|
||||
ldd [%o1 + 0x20], %f18
|
||||
ldd [%o1 + 0x28], %f20
|
||||
ldd [%o1 + 0x30], %f22
|
||||
ldd [%o1 + 0x38], %f24
|
||||
subcc %o2, 1, %o2 ! done yet?
|
||||
ldd [%o1 + 0x40], %f26
|
||||
add %o1, 0x40, %o1
|
||||
prefetch [%o1 + 63], 20
|
||||
|
||||
faligndata %f10, %f12, %f8
|
||||
faligndata %f12, %f14, %f10
|
||||
faligndata %f14, %f16, %f12
|
||||
faligndata %f16, %f18, %f14
|
||||
faligndata %f18, %f20, %f16
|
||||
faligndata %f20, %f22, %f18
|
||||
faligndata %f22, %f24, %f20
|
||||
faligndata %f24, %f26, %f22
|
||||
|
||||
.word 0x81b02820 ! SHA1
|
||||
|
||||
bne,pt SIZE_T_CC, .Lhwunaligned_loop
|
||||
for %f26, %f26, %f10 ! %f10=%f26
|
||||
|
||||
ba .Lhwfinish
|
||||
nop
|
||||
|
||||
.align 16
|
||||
.Lsoftware:
|
||||
save %sp,-STACK_FRAME,%sp
|
||||
sllx $len,6,$len
|
||||
add $inp,$len,$len
|
||||
|
||||
@@ -268,7 +355,7 @@ $code.=<<___;
|
||||
add $E,@X[4],$E
|
||||
st $E,[$ctx+16]
|
||||
|
||||
bne `$bits==64?"%xcc":"%icc"`,.Lloop
|
||||
bne SIZE_T_CC,.Lloop
|
||||
andn $inp,7,$tmp0
|
||||
|
||||
ret
|
||||
@@ -279,6 +366,62 @@ $code.=<<___;
|
||||
.align 4
|
||||
___
|
||||
|
||||
$code =~ s/\`([^\`]*)\`/eval $1/gem;
|
||||
print $code;
|
||||
# Purpose of these subroutines is to explicitly encode VIS instructions,
|
||||
# so that one can compile the module without having to specify VIS
|
||||
# extentions on compiler command line, e.g. -xarch=v9 vs. -xarch=v9a.
|
||||
# Idea is to reserve for option to produce "universal" binary and let
|
||||
# programmer detect if current CPU is VIS capable at run-time.
|
||||
sub unvis {
|
||||
my ($mnemonic,$rs1,$rs2,$rd)=@_;
|
||||
my $ref,$opf;
|
||||
my %visopf = ( "faligndata" => 0x048,
|
||||
"for" => 0x07c );
|
||||
|
||||
$ref = "$mnemonic\t$rs1,$rs2,$rd";
|
||||
|
||||
if ($opf=$visopf{$mnemonic}) {
|
||||
foreach ($rs1,$rs2,$rd) {
|
||||
return $ref if (!/%f([0-9]{1,2})/);
|
||||
$_=$1;
|
||||
if ($1>=32) {
|
||||
return $ref if ($1&1);
|
||||
# re-encode for upper double register addressing
|
||||
$_=($1|$1>>5)&31;
|
||||
}
|
||||
}
|
||||
|
||||
return sprintf ".word\t0x%08x !%s",
|
||||
0x81b00000|$rd<<25|$rs1<<14|$opf<<5|$rs2,
|
||||
$ref;
|
||||
} else {
|
||||
return $ref;
|
||||
}
|
||||
}
|
||||
sub unalignaddr {
|
||||
my ($mnemonic,$rs1,$rs2,$rd)=@_;
|
||||
my %bias = ( "g" => 0, "o" => 8, "l" => 16, "i" => 24 );
|
||||
my $ref="$mnemonic\t$rs1,$rs2,$rd";
|
||||
|
||||
foreach ($rs1,$rs2,$rd) {
|
||||
if (/%([goli])([0-7])/) { $_=$bias{$1}+$2; }
|
||||
else { return $ref; }
|
||||
}
|
||||
return sprintf ".word\t0x%08x !%s",
|
||||
0x81b00300|$rd<<25|$rs1<<14|$rs2,
|
||||
$ref;
|
||||
}
|
||||
|
||||
foreach (split("\n",$code)) {
|
||||
s/\`([^\`]*)\`/eval $1/ge;
|
||||
|
||||
s/\b(f[^\s]*)\s+(%f[0-9]{1,2}),\s*(%f[0-9]{1,2}),\s*(%f[0-9]{1,2})/
|
||||
&unvis($1,$2,$3,$4)
|
||||
/ge;
|
||||
s/\b(alignaddr)\s+(%[goli][0-7]),\s*(%[goli][0-7]),\s*(%[goli][0-7])/
|
||||
&unalignaddr($1,$2,$3,$4)
|
||||
/ge;
|
||||
|
||||
print $_,"\n";
|
||||
}
|
||||
|
||||
close STDOUT;
|
||||
|
||||
@@ -549,7 +549,7 @@ ___
|
||||
# programmer detect if current CPU is VIS capable at run-time.
|
||||
sub unvis {
|
||||
my ($mnemonic,$rs1,$rs2,$rd)=@_;
|
||||
my $ref,$opf;
|
||||
my ($ref,$opf);
|
||||
my %visopf = ( "fmul8ulx16" => 0x037,
|
||||
"faligndata" => 0x048,
|
||||
"fpadd32" => 0x052,
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@@ -1,10 +1,12 @@
|
||||
#!/usr/bin/env perl
|
||||
|
||||
# ====================================================================
|
||||
# Written by Andy Polyakov <appro@fy.chalmers.se> for the OpenSSL
|
||||
# Written by Andy Polyakov <appro@openssl.org> 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/.
|
||||
#
|
||||
# Permission to use under GPL terms is granted.
|
||||
# ====================================================================
|
||||
|
||||
# SHA256 block procedure for ARMv4. May 2007.
|
||||
@@ -18,13 +20,30 @@
|
||||
# Rescheduling for dual-issue pipeline resulted in 22% improvement on
|
||||
# Cortex A8 core and ~20 cycles per processed byte.
|
||||
|
||||
# February 2011.
|
||||
#
|
||||
# Profiler-assisted and platform-specific optimization resulted in 16%
|
||||
# improvement on Cortex A8 core and ~15.4 cycles per processed byte.
|
||||
|
||||
# September 2013.
|
||||
#
|
||||
# Add NEON implementation. On Cortex A8 it was measured to process one
|
||||
# byte in 12.5 cycles or 23% faster than integer-only code. Snapdragon
|
||||
# S4 does it in 12.5 cycles too, but it's 50% faster than integer-only
|
||||
# code (meaning that latter performs sub-optimally, nothing was done
|
||||
# about it).
|
||||
|
||||
# May 2014.
|
||||
#
|
||||
# Add ARMv8 code path performing at 2.0 cpb on Apple A7.
|
||||
|
||||
while (($output=shift) && ($output!~/^\w[\w\-]*\.\w+$/)) {}
|
||||
open STDOUT,">$output";
|
||||
|
||||
$ctx="r0"; $t0="r0";
|
||||
$inp="r1";
|
||||
$inp="r1"; $t4="r1";
|
||||
$len="r2"; $t1="r2";
|
||||
$T1="r3";
|
||||
$T1="r3"; $t3="r3";
|
||||
$A="r4";
|
||||
$B="r5";
|
||||
$C="r6";
|
||||
@@ -46,65 +65,112 @@ sub BODY_00_15 {
|
||||
my ($i,$a,$b,$c,$d,$e,$f,$g,$h) = @_;
|
||||
|
||||
$code.=<<___ if ($i<16);
|
||||
ldrb $T1,[$inp,#3] @ $i
|
||||
#if __ARM_ARCH__>=7
|
||||
@ ldr $t1,[$inp],#4 @ $i
|
||||
# if $i==15
|
||||
str $inp,[sp,#17*4] @ make room for $t4
|
||||
# endif
|
||||
eor $t0,$e,$e,ror#`$Sigma1[1]-$Sigma1[0]`
|
||||
add $a,$a,$t2 @ h+=Maj(a,b,c) from the past
|
||||
eor $t0,$t0,$e,ror#`$Sigma1[2]-$Sigma1[0]` @ Sigma1(e)
|
||||
rev $t1,$t1
|
||||
#else
|
||||
@ ldrb $t1,[$inp,#3] @ $i
|
||||
add $a,$a,$t2 @ h+=Maj(a,b,c) from the past
|
||||
ldrb $t2,[$inp,#2]
|
||||
ldrb $t1,[$inp,#1]
|
||||
ldrb $t0,[$inp],#4
|
||||
orr $T1,$T1,$t2,lsl#8
|
||||
orr $T1,$T1,$t1,lsl#16
|
||||
orr $T1,$T1,$t0,lsl#24
|
||||
`"str $inp,[sp,#17*4]" if ($i==15)`
|
||||
ldrb $t0,[$inp,#1]
|
||||
orr $t1,$t1,$t2,lsl#8
|
||||
ldrb $t2,[$inp],#4
|
||||
orr $t1,$t1,$t0,lsl#16
|
||||
# if $i==15
|
||||
str $inp,[sp,#17*4] @ make room for $t4
|
||||
# endif
|
||||
eor $t0,$e,$e,ror#`$Sigma1[1]-$Sigma1[0]`
|
||||
orr $t1,$t1,$t2,lsl#24
|
||||
eor $t0,$t0,$e,ror#`$Sigma1[2]-$Sigma1[0]` @ Sigma1(e)
|
||||
#endif
|
||||
___
|
||||
$code.=<<___;
|
||||
ldr $t2,[$Ktbl],#4 @ *K256++
|
||||
mov $t0,$e,ror#$Sigma1[0]
|
||||
str $T1,[sp,#`$i%16`*4]
|
||||
eor $t0,$t0,$e,ror#$Sigma1[1]
|
||||
add $h,$h,$t1 @ h+=X[i]
|
||||
str $t1,[sp,#`$i%16`*4]
|
||||
eor $t1,$f,$g
|
||||
eor $t0,$t0,$e,ror#$Sigma1[2] @ Sigma1(e)
|
||||
add $h,$h,$t0,ror#$Sigma1[0] @ h+=Sigma1(e)
|
||||
and $t1,$t1,$e
|
||||
add $T1,$T1,$t0
|
||||
add $h,$h,$t2 @ h+=K256[i]
|
||||
eor $t1,$t1,$g @ Ch(e,f,g)
|
||||
add $T1,$T1,$h
|
||||
mov $h,$a,ror#$Sigma0[0]
|
||||
add $T1,$T1,$t1
|
||||
eor $h,$h,$a,ror#$Sigma0[1]
|
||||
add $T1,$T1,$t2
|
||||
eor $h,$h,$a,ror#$Sigma0[2] @ Sigma0(a)
|
||||
orr $t0,$a,$b
|
||||
and $t1,$a,$b
|
||||
and $t0,$t0,$c
|
||||
add $h,$h,$T1
|
||||
orr $t0,$t0,$t1 @ Maj(a,b,c)
|
||||
add $d,$d,$T1
|
||||
add $h,$h,$t0
|
||||
eor $t0,$a,$a,ror#`$Sigma0[1]-$Sigma0[0]`
|
||||
add $h,$h,$t1 @ h+=Ch(e,f,g)
|
||||
#if $i==31
|
||||
and $t2,$t2,#0xff
|
||||
cmp $t2,#0xf2 @ done?
|
||||
#endif
|
||||
#if $i<15
|
||||
# if __ARM_ARCH__>=7
|
||||
ldr $t1,[$inp],#4 @ prefetch
|
||||
# else
|
||||
ldrb $t1,[$inp,#3]
|
||||
# endif
|
||||
eor $t2,$a,$b @ a^b, b^c in next round
|
||||
#else
|
||||
ldr $t1,[sp,#`($i+2)%16`*4] @ from future BODY_16_xx
|
||||
eor $t2,$a,$b @ a^b, b^c in next round
|
||||
ldr $t4,[sp,#`($i+15)%16`*4] @ from future BODY_16_xx
|
||||
#endif
|
||||
eor $t0,$t0,$a,ror#`$Sigma0[2]-$Sigma0[0]` @ Sigma0(a)
|
||||
and $t3,$t3,$t2 @ (b^c)&=(a^b)
|
||||
add $d,$d,$h @ d+=h
|
||||
eor $t3,$t3,$b @ Maj(a,b,c)
|
||||
add $h,$h,$t0,ror#$Sigma0[0] @ h+=Sigma0(a)
|
||||
@ add $h,$h,$t3 @ h+=Maj(a,b,c)
|
||||
___
|
||||
($t2,$t3)=($t3,$t2);
|
||||
}
|
||||
|
||||
sub BODY_16_XX {
|
||||
my ($i,$a,$b,$c,$d,$e,$f,$g,$h) = @_;
|
||||
|
||||
$code.=<<___;
|
||||
ldr $t1,[sp,#`($i+1)%16`*4] @ $i
|
||||
ldr $t2,[sp,#`($i+14)%16`*4]
|
||||
ldr $T1,[sp,#`($i+0)%16`*4]
|
||||
@ ldr $t1,[sp,#`($i+1)%16`*4] @ $i
|
||||
@ ldr $t4,[sp,#`($i+14)%16`*4]
|
||||
mov $t0,$t1,ror#$sigma0[0]
|
||||
ldr $inp,[sp,#`($i+9)%16`*4]
|
||||
add $a,$a,$t2 @ h+=Maj(a,b,c) from the past
|
||||
mov $t2,$t4,ror#$sigma1[0]
|
||||
eor $t0,$t0,$t1,ror#$sigma0[1]
|
||||
eor $t2,$t2,$t4,ror#$sigma1[1]
|
||||
eor $t0,$t0,$t1,lsr#$sigma0[2] @ sigma0(X[i+1])
|
||||
mov $t1,$t2,ror#$sigma1[0]
|
||||
add $T1,$T1,$t0
|
||||
eor $t1,$t1,$t2,ror#$sigma1[1]
|
||||
add $T1,$T1,$inp
|
||||
eor $t1,$t1,$t2,lsr#$sigma1[2] @ sigma1(X[i+14])
|
||||
add $T1,$T1,$t1
|
||||
ldr $t1,[sp,#`($i+0)%16`*4]
|
||||
eor $t2,$t2,$t4,lsr#$sigma1[2] @ sigma1(X[i+14])
|
||||
ldr $t4,[sp,#`($i+9)%16`*4]
|
||||
|
||||
add $t2,$t2,$t0
|
||||
eor $t0,$e,$e,ror#`$Sigma1[1]-$Sigma1[0]` @ from BODY_00_15
|
||||
add $t1,$t1,$t2
|
||||
eor $t0,$t0,$e,ror#`$Sigma1[2]-$Sigma1[0]` @ Sigma1(e)
|
||||
add $t1,$t1,$t4 @ X[i]
|
||||
___
|
||||
&BODY_00_15(@_);
|
||||
}
|
||||
|
||||
$code=<<___;
|
||||
#ifndef __KERNEL__
|
||||
# include "arm_arch.h"
|
||||
#else
|
||||
# define __ARM_ARCH__ __LINUX_ARM_ARCH__
|
||||
# define __ARM_MAX_ARCH__ 7
|
||||
#endif
|
||||
|
||||
.text
|
||||
#if __ARM_ARCH__<7
|
||||
.code 32
|
||||
#else
|
||||
.syntax unified
|
||||
# ifdef __thumb2__
|
||||
.thumb
|
||||
# else
|
||||
.code 32
|
||||
# endif
|
||||
#endif
|
||||
|
||||
.type K256,%object
|
||||
.align 5
|
||||
@@ -126,61 +192,522 @@ K256:
|
||||
.word 0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208
|
||||
.word 0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2
|
||||
.size K256,.-K256
|
||||
.word 0 @ terminator
|
||||
#if __ARM_MAX_ARCH__>=7 && !defined(__KERNEL__)
|
||||
.LOPENSSL_armcap:
|
||||
.word OPENSSL_armcap_P-sha256_block_data_order
|
||||
#endif
|
||||
.align 5
|
||||
|
||||
.global sha256_block_data_order
|
||||
.type sha256_block_data_order,%function
|
||||
sha256_block_data_order:
|
||||
#if __ARM_ARCH__<7
|
||||
sub r3,pc,#8 @ sha256_block_data_order
|
||||
#else
|
||||
adr r3,sha256_block_data_order
|
||||
#endif
|
||||
#if __ARM_MAX_ARCH__>=7 && !defined(__KERNEL__)
|
||||
ldr r12,.LOPENSSL_armcap
|
||||
ldr r12,[r3,r12] @ OPENSSL_armcap_P
|
||||
tst r12,#ARMV8_SHA256
|
||||
bne .LARMv8
|
||||
tst r12,#ARMV7_NEON
|
||||
bne .LNEON
|
||||
#endif
|
||||
add $len,$inp,$len,lsl#6 @ len to point at the end of inp
|
||||
stmdb sp!,{$ctx,$inp,$len,r4-r12,lr}
|
||||
stmdb sp!,{$ctx,$inp,$len,r4-r11,lr}
|
||||
ldmia $ctx,{$A,$B,$C,$D,$E,$F,$G,$H}
|
||||
sub $Ktbl,r3,#256 @ K256
|
||||
sub $Ktbl,r3,#256+32 @ K256
|
||||
sub sp,sp,#16*4 @ alloca(X[16])
|
||||
.Loop:
|
||||
# if __ARM_ARCH__>=7
|
||||
ldr $t1,[$inp],#4
|
||||
# else
|
||||
ldrb $t1,[$inp,#3]
|
||||
# endif
|
||||
eor $t3,$B,$C @ magic
|
||||
eor $t2,$t2,$t2
|
||||
___
|
||||
for($i=0;$i<16;$i++) { &BODY_00_15($i,@V); unshift(@V,pop(@V)); }
|
||||
$code.=".Lrounds_16_xx:\n";
|
||||
for (;$i<32;$i++) { &BODY_16_XX($i,@V); unshift(@V,pop(@V)); }
|
||||
$code.=<<___;
|
||||
and $t2,$t2,#0xff
|
||||
cmp $t2,#0xf2
|
||||
#if __ARM_ARCH__>=7
|
||||
ite eq @ Thumb2 thing, sanity check in ARM
|
||||
#endif
|
||||
ldreq $t3,[sp,#16*4] @ pull ctx
|
||||
bne .Lrounds_16_xx
|
||||
|
||||
ldr $T1,[sp,#16*4] @ pull ctx
|
||||
ldr $t0,[$T1,#0]
|
||||
ldr $t1,[$T1,#4]
|
||||
ldr $t2,[$T1,#8]
|
||||
add $A,$A,$t2 @ h+=Maj(a,b,c) from the past
|
||||
ldr $t0,[$t3,#0]
|
||||
ldr $t1,[$t3,#4]
|
||||
ldr $t2,[$t3,#8]
|
||||
add $A,$A,$t0
|
||||
ldr $t0,[$T1,#12]
|
||||
ldr $t0,[$t3,#12]
|
||||
add $B,$B,$t1
|
||||
ldr $t1,[$T1,#16]
|
||||
ldr $t1,[$t3,#16]
|
||||
add $C,$C,$t2
|
||||
ldr $t2,[$T1,#20]
|
||||
ldr $t2,[$t3,#20]
|
||||
add $D,$D,$t0
|
||||
ldr $t0,[$T1,#24]
|
||||
ldr $t0,[$t3,#24]
|
||||
add $E,$E,$t1
|
||||
ldr $t1,[$T1,#28]
|
||||
ldr $t1,[$t3,#28]
|
||||
add $F,$F,$t2
|
||||
ldr $inp,[sp,#17*4] @ pull inp
|
||||
ldr $t2,[sp,#18*4] @ pull inp+len
|
||||
add $G,$G,$t0
|
||||
add $H,$H,$t1
|
||||
stmia $T1,{$A,$B,$C,$D,$E,$F,$G,$H}
|
||||
stmia $t3,{$A,$B,$C,$D,$E,$F,$G,$H}
|
||||
cmp $inp,$t2
|
||||
sub $Ktbl,$Ktbl,#256 @ rewind Ktbl
|
||||
bne .Loop
|
||||
|
||||
add sp,sp,#`16+3`*4 @ destroy frame
|
||||
ldmia sp!,{r4-r12,lr}
|
||||
#if __ARM_ARCH__>=5
|
||||
ldmia sp!,{r4-r11,pc}
|
||||
#else
|
||||
ldmia sp!,{r4-r11,lr}
|
||||
tst lr,#1
|
||||
moveq pc,lr @ be binary compatible with V4, yet
|
||||
bx lr @ interoperable with Thumb ISA:-)
|
||||
.size sha256_block_data_order,.-sha256_block_data_order
|
||||
.asciz "SHA256 block transform for ARMv4, CRYPTOGAMS by <appro\@openssl.org>"
|
||||
#endif
|
||||
.size sha256_block_data_order,.-sha256_block_data_order
|
||||
___
|
||||
######################################################################
|
||||
# NEON stuff
|
||||
#
|
||||
{{{
|
||||
my @X=map("q$_",(0..3));
|
||||
my ($T0,$T1,$T2,$T3,$T4,$T5)=("q8","q9","q10","q11","d24","d25");
|
||||
my $Xfer=$t4;
|
||||
my $j=0;
|
||||
|
||||
sub Dlo() { shift=~m|q([1]?[0-9])|?"d".($1*2):""; }
|
||||
sub Dhi() { shift=~m|q([1]?[0-9])|?"d".($1*2+1):""; }
|
||||
|
||||
sub AUTOLOAD() # thunk [simplified] x86-style perlasm
|
||||
{ my $opcode = $AUTOLOAD; $opcode =~ s/.*:://; $opcode =~ s/_/\./;
|
||||
my $arg = pop;
|
||||
$arg = "#$arg" if ($arg*1 eq $arg);
|
||||
$code .= "\t$opcode\t".join(',',@_,$arg)."\n";
|
||||
}
|
||||
|
||||
sub Xupdate()
|
||||
{ use integer;
|
||||
my $body = shift;
|
||||
my @insns = (&$body,&$body,&$body,&$body);
|
||||
my ($a,$b,$c,$d,$e,$f,$g,$h);
|
||||
|
||||
&vext_8 ($T0,@X[0],@X[1],4); # X[1..4]
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&vext_8 ($T1,@X[2],@X[3],4); # X[9..12]
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&vshr_u32 ($T2,$T0,$sigma0[0]);
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&vadd_i32 (@X[0],@X[0],$T1); # X[0..3] += X[9..12]
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&vshr_u32 ($T1,$T0,$sigma0[2]);
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&vsli_32 ($T2,$T0,32-$sigma0[0]);
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&vshr_u32 ($T3,$T0,$sigma0[1]);
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&veor ($T1,$T1,$T2);
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&vsli_32 ($T3,$T0,32-$sigma0[1]);
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&vshr_u32 ($T4,&Dhi(@X[3]),$sigma1[0]);
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&veor ($T1,$T1,$T3); # sigma0(X[1..4])
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&vsli_32 ($T4,&Dhi(@X[3]),32-$sigma1[0]);
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&vshr_u32 ($T5,&Dhi(@X[3]),$sigma1[2]);
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&vadd_i32 (@X[0],@X[0],$T1); # X[0..3] += sigma0(X[1..4])
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&veor ($T5,$T5,$T4);
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&vshr_u32 ($T4,&Dhi(@X[3]),$sigma1[1]);
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&vsli_32 ($T4,&Dhi(@X[3]),32-$sigma1[1]);
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&veor ($T5,$T5,$T4); # sigma1(X[14..15])
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&vadd_i32 (&Dlo(@X[0]),&Dlo(@X[0]),$T5);# X[0..1] += sigma1(X[14..15])
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&vshr_u32 ($T4,&Dlo(@X[0]),$sigma1[0]);
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&vsli_32 ($T4,&Dlo(@X[0]),32-$sigma1[0]);
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&vshr_u32 ($T5,&Dlo(@X[0]),$sigma1[2]);
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&veor ($T5,$T5,$T4);
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&vshr_u32 ($T4,&Dlo(@X[0]),$sigma1[1]);
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&vld1_32 ("{$T0}","[$Ktbl,:128]!");
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&vsli_32 ($T4,&Dlo(@X[0]),32-$sigma1[1]);
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&veor ($T5,$T5,$T4); # sigma1(X[16..17])
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&vadd_i32 (&Dhi(@X[0]),&Dhi(@X[0]),$T5);# X[2..3] += sigma1(X[16..17])
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&vadd_i32 ($T0,$T0,@X[0]);
|
||||
while($#insns>=2) { eval(shift(@insns)); }
|
||||
&vst1_32 ("{$T0}","[$Xfer,:128]!");
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
|
||||
push(@X,shift(@X)); # "rotate" X[]
|
||||
}
|
||||
|
||||
sub Xpreload()
|
||||
{ use integer;
|
||||
my $body = shift;
|
||||
my @insns = (&$body,&$body,&$body,&$body);
|
||||
my ($a,$b,$c,$d,$e,$f,$g,$h);
|
||||
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&vld1_32 ("{$T0}","[$Ktbl,:128]!");
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&vrev32_8 (@X[0],@X[0]);
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&vadd_i32 ($T0,$T0,@X[0]);
|
||||
foreach (@insns) { eval; } # remaining instructions
|
||||
&vst1_32 ("{$T0}","[$Xfer,:128]!");
|
||||
|
||||
push(@X,shift(@X)); # "rotate" X[]
|
||||
}
|
||||
|
||||
sub body_00_15 () {
|
||||
(
|
||||
'($a,$b,$c,$d,$e,$f,$g,$h)=@V;'.
|
||||
'&add ($h,$h,$t1)', # h+=X[i]+K[i]
|
||||
'&eor ($t1,$f,$g)',
|
||||
'&eor ($t0,$e,$e,"ror#".($Sigma1[1]-$Sigma1[0]))',
|
||||
'&add ($a,$a,$t2)', # h+=Maj(a,b,c) from the past
|
||||
'&and ($t1,$t1,$e)',
|
||||
'&eor ($t2,$t0,$e,"ror#".($Sigma1[2]-$Sigma1[0]))', # Sigma1(e)
|
||||
'&eor ($t0,$a,$a,"ror#".($Sigma0[1]-$Sigma0[0]))',
|
||||
'&eor ($t1,$t1,$g)', # Ch(e,f,g)
|
||||
'&add ($h,$h,$t2,"ror#$Sigma1[0]")', # h+=Sigma1(e)
|
||||
'&eor ($t2,$a,$b)', # a^b, b^c in next round
|
||||
'&eor ($t0,$t0,$a,"ror#".($Sigma0[2]-$Sigma0[0]))', # Sigma0(a)
|
||||
'&add ($h,$h,$t1)', # h+=Ch(e,f,g)
|
||||
'&ldr ($t1,sprintf "[sp,#%d]",4*(($j+1)&15)) if (($j&15)!=15);'.
|
||||
'&ldr ($t1,"[$Ktbl]") if ($j==15);'.
|
||||
'&ldr ($t1,"[sp,#64]") if ($j==31)',
|
||||
'&and ($t3,$t3,$t2)', # (b^c)&=(a^b)
|
||||
'&add ($d,$d,$h)', # d+=h
|
||||
'&add ($h,$h,$t0,"ror#$Sigma0[0]");'. # h+=Sigma0(a)
|
||||
'&eor ($t3,$t3,$b)', # Maj(a,b,c)
|
||||
'$j++; unshift(@V,pop(@V)); ($t2,$t3)=($t3,$t2);'
|
||||
)
|
||||
}
|
||||
|
||||
$code.=<<___;
|
||||
#if __ARM_MAX_ARCH__>=7
|
||||
.arch armv7-a
|
||||
.fpu neon
|
||||
|
||||
.global sha256_block_data_order_neon
|
||||
.type sha256_block_data_order_neon,%function
|
||||
.align 4
|
||||
sha256_block_data_order_neon:
|
||||
.LNEON:
|
||||
stmdb sp!,{r4-r12,lr}
|
||||
|
||||
sub $H,sp,#16*4+16
|
||||
adr $Ktbl,K256
|
||||
bic $H,$H,#15 @ align for 128-bit stores
|
||||
mov $t2,sp
|
||||
mov sp,$H @ alloca
|
||||
add $len,$inp,$len,lsl#6 @ len to point at the end of inp
|
||||
|
||||
vld1.8 {@X[0]},[$inp]!
|
||||
vld1.8 {@X[1]},[$inp]!
|
||||
vld1.8 {@X[2]},[$inp]!
|
||||
vld1.8 {@X[3]},[$inp]!
|
||||
vld1.32 {$T0},[$Ktbl,:128]!
|
||||
vld1.32 {$T1},[$Ktbl,:128]!
|
||||
vld1.32 {$T2},[$Ktbl,:128]!
|
||||
vld1.32 {$T3},[$Ktbl,:128]!
|
||||
vrev32.8 @X[0],@X[0] @ yes, even on
|
||||
str $ctx,[sp,#64]
|
||||
vrev32.8 @X[1],@X[1] @ big-endian
|
||||
str $inp,[sp,#68]
|
||||
mov $Xfer,sp
|
||||
vrev32.8 @X[2],@X[2]
|
||||
str $len,[sp,#72]
|
||||
vrev32.8 @X[3],@X[3]
|
||||
str $t2,[sp,#76] @ save original sp
|
||||
vadd.i32 $T0,$T0,@X[0]
|
||||
vadd.i32 $T1,$T1,@X[1]
|
||||
vst1.32 {$T0},[$Xfer,:128]!
|
||||
vadd.i32 $T2,$T2,@X[2]
|
||||
vst1.32 {$T1},[$Xfer,:128]!
|
||||
vadd.i32 $T3,$T3,@X[3]
|
||||
vst1.32 {$T2},[$Xfer,:128]!
|
||||
vst1.32 {$T3},[$Xfer,:128]!
|
||||
|
||||
ldmia $ctx,{$A-$H}
|
||||
sub $Xfer,$Xfer,#64
|
||||
ldr $t1,[sp,#0]
|
||||
eor $t2,$t2,$t2
|
||||
eor $t3,$B,$C
|
||||
b .L_00_48
|
||||
|
||||
.align 4
|
||||
.L_00_48:
|
||||
___
|
||||
&Xupdate(\&body_00_15);
|
||||
&Xupdate(\&body_00_15);
|
||||
&Xupdate(\&body_00_15);
|
||||
&Xupdate(\&body_00_15);
|
||||
$code.=<<___;
|
||||
teq $t1,#0 @ check for K256 terminator
|
||||
ldr $t1,[sp,#0]
|
||||
sub $Xfer,$Xfer,#64
|
||||
bne .L_00_48
|
||||
|
||||
ldr $inp,[sp,#68]
|
||||
ldr $t0,[sp,#72]
|
||||
sub $Ktbl,$Ktbl,#256 @ rewind $Ktbl
|
||||
teq $inp,$t0
|
||||
it eq
|
||||
subeq $inp,$inp,#64 @ avoid SEGV
|
||||
vld1.8 {@X[0]},[$inp]! @ load next input block
|
||||
vld1.8 {@X[1]},[$inp]!
|
||||
vld1.8 {@X[2]},[$inp]!
|
||||
vld1.8 {@X[3]},[$inp]!
|
||||
it ne
|
||||
strne $inp,[sp,#68]
|
||||
mov $Xfer,sp
|
||||
___
|
||||
&Xpreload(\&body_00_15);
|
||||
&Xpreload(\&body_00_15);
|
||||
&Xpreload(\&body_00_15);
|
||||
&Xpreload(\&body_00_15);
|
||||
$code.=<<___;
|
||||
ldr $t0,[$t1,#0]
|
||||
add $A,$A,$t2 @ h+=Maj(a,b,c) from the past
|
||||
ldr $t2,[$t1,#4]
|
||||
ldr $t3,[$t1,#8]
|
||||
ldr $t4,[$t1,#12]
|
||||
add $A,$A,$t0 @ accumulate
|
||||
ldr $t0,[$t1,#16]
|
||||
add $B,$B,$t2
|
||||
ldr $t2,[$t1,#20]
|
||||
add $C,$C,$t3
|
||||
ldr $t3,[$t1,#24]
|
||||
add $D,$D,$t4
|
||||
ldr $t4,[$t1,#28]
|
||||
add $E,$E,$t0
|
||||
str $A,[$t1],#4
|
||||
add $F,$F,$t2
|
||||
str $B,[$t1],#4
|
||||
add $G,$G,$t3
|
||||
str $C,[$t1],#4
|
||||
add $H,$H,$t4
|
||||
str $D,[$t1],#4
|
||||
stmia $t1,{$E-$H}
|
||||
|
||||
ittte ne
|
||||
movne $Xfer,sp
|
||||
ldrne $t1,[sp,#0]
|
||||
eorne $t2,$t2,$t2
|
||||
ldreq sp,[sp,#76] @ restore original sp
|
||||
itt ne
|
||||
eorne $t3,$B,$C
|
||||
bne .L_00_48
|
||||
|
||||
ldmia sp!,{r4-r12,pc}
|
||||
.size sha256_block_data_order_neon,.-sha256_block_data_order_neon
|
||||
#endif
|
||||
___
|
||||
}}}
|
||||
######################################################################
|
||||
# ARMv8 stuff
|
||||
#
|
||||
{{{
|
||||
my ($ABCD,$EFGH,$abcd)=map("q$_",(0..2));
|
||||
my @MSG=map("q$_",(8..11));
|
||||
my ($W0,$W1,$ABCD_SAVE,$EFGH_SAVE)=map("q$_",(12..15));
|
||||
my $Ktbl="r3";
|
||||
|
||||
$code.=<<___;
|
||||
#if __ARM_MAX_ARCH__>=7 && !defined(__KERNEL__)
|
||||
|
||||
# ifdef __thumb2__
|
||||
# define INST(a,b,c,d) .byte c,d|0xc,a,b
|
||||
# else
|
||||
# define INST(a,b,c,d) .byte a,b,c,d
|
||||
# endif
|
||||
|
||||
.type sha256_block_data_order_armv8,%function
|
||||
.align 5
|
||||
sha256_block_data_order_armv8:
|
||||
.LARMv8:
|
||||
vld1.32 {$ABCD,$EFGH},[$ctx]
|
||||
# ifdef __thumb2__
|
||||
adr $Ktbl,.LARMv8
|
||||
sub $Ktbl,$Ktbl,#.LARMv8-K256
|
||||
# else
|
||||
adrl $Ktbl,K256
|
||||
# endif
|
||||
add $len,$inp,$len,lsl#6 @ len to point at the end of inp
|
||||
|
||||
.Loop_v8:
|
||||
vld1.8 {@MSG[0]-@MSG[1]},[$inp]!
|
||||
vld1.8 {@MSG[2]-@MSG[3]},[$inp]!
|
||||
vld1.32 {$W0},[$Ktbl]!
|
||||
vrev32.8 @MSG[0],@MSG[0]
|
||||
vrev32.8 @MSG[1],@MSG[1]
|
||||
vrev32.8 @MSG[2],@MSG[2]
|
||||
vrev32.8 @MSG[3],@MSG[3]
|
||||
vmov $ABCD_SAVE,$ABCD @ offload
|
||||
vmov $EFGH_SAVE,$EFGH
|
||||
teq $inp,$len
|
||||
___
|
||||
for($i=0;$i<12;$i++) {
|
||||
$code.=<<___;
|
||||
vld1.32 {$W1},[$Ktbl]!
|
||||
vadd.i32 $W0,$W0,@MSG[0]
|
||||
sha256su0 @MSG[0],@MSG[1]
|
||||
vmov $abcd,$ABCD
|
||||
sha256h $ABCD,$EFGH,$W0
|
||||
sha256h2 $EFGH,$abcd,$W0
|
||||
sha256su1 @MSG[0],@MSG[2],@MSG[3]
|
||||
___
|
||||
($W0,$W1)=($W1,$W0); push(@MSG,shift(@MSG));
|
||||
}
|
||||
$code.=<<___;
|
||||
vld1.32 {$W1},[$Ktbl]!
|
||||
vadd.i32 $W0,$W0,@MSG[0]
|
||||
vmov $abcd,$ABCD
|
||||
sha256h $ABCD,$EFGH,$W0
|
||||
sha256h2 $EFGH,$abcd,$W0
|
||||
|
||||
vld1.32 {$W0},[$Ktbl]!
|
||||
vadd.i32 $W1,$W1,@MSG[1]
|
||||
vmov $abcd,$ABCD
|
||||
sha256h $ABCD,$EFGH,$W1
|
||||
sha256h2 $EFGH,$abcd,$W1
|
||||
|
||||
vld1.32 {$W1},[$Ktbl]
|
||||
vadd.i32 $W0,$W0,@MSG[2]
|
||||
sub $Ktbl,$Ktbl,#256-16 @ rewind
|
||||
vmov $abcd,$ABCD
|
||||
sha256h $ABCD,$EFGH,$W0
|
||||
sha256h2 $EFGH,$abcd,$W0
|
||||
|
||||
vadd.i32 $W1,$W1,@MSG[3]
|
||||
vmov $abcd,$ABCD
|
||||
sha256h $ABCD,$EFGH,$W1
|
||||
sha256h2 $EFGH,$abcd,$W1
|
||||
|
||||
vadd.i32 $ABCD,$ABCD,$ABCD_SAVE
|
||||
vadd.i32 $EFGH,$EFGH,$EFGH_SAVE
|
||||
it ne
|
||||
bne .Loop_v8
|
||||
|
||||
vst1.32 {$ABCD,$EFGH},[$ctx]
|
||||
|
||||
ret @ bx lr
|
||||
.size sha256_block_data_order_armv8,.-sha256_block_data_order_armv8
|
||||
#endif
|
||||
___
|
||||
}}}
|
||||
$code.=<<___;
|
||||
.asciz "SHA256 block transform for ARMv4/NEON/ARMv8, CRYPTOGAMS by <appro\@openssl.org>"
|
||||
.align 2
|
||||
#if __ARM_MAX_ARCH__>=7 && !defined(__KERNEL__)
|
||||
.comm OPENSSL_armcap_P,4,4
|
||||
#endif
|
||||
___
|
||||
|
||||
$code =~ s/\`([^\`]*)\`/eval $1/gem;
|
||||
$code =~ s/\bbx\s+lr\b/.word\t0xe12fff1e/gm; # make it possible to compile with -march=armv4
|
||||
print $code;
|
||||
open SELF,$0;
|
||||
while(<SELF>) {
|
||||
next if (/^#!/);
|
||||
last if (!s/^#/@/ and !/^$/);
|
||||
print;
|
||||
}
|
||||
close SELF;
|
||||
|
||||
{ my %opcode = (
|
||||
"sha256h" => 0xf3000c40, "sha256h2" => 0xf3100c40,
|
||||
"sha256su0" => 0xf3ba03c0, "sha256su1" => 0xf3200c40 );
|
||||
|
||||
sub unsha256 {
|
||||
my ($mnemonic,$arg)=@_;
|
||||
|
||||
if ($arg =~ m/q([0-9]+)(?:,\s*q([0-9]+))?,\s*q([0-9]+)/o) {
|
||||
my $word = $opcode{$mnemonic}|(($1&7)<<13)|(($1&8)<<19)
|
||||
|(($2&7)<<17)|(($2&8)<<4)
|
||||
|(($3&7)<<1) |(($3&8)<<2);
|
||||
# since ARMv7 instructions are always encoded little-endian.
|
||||
# correct solution is to use .inst directive, but older
|
||||
# assemblers don't implement it:-(
|
||||
sprintf "INST(0x%02x,0x%02x,0x%02x,0x%02x)\t@ %s %s",
|
||||
$word&0xff,($word>>8)&0xff,
|
||||
($word>>16)&0xff,($word>>24)&0xff,
|
||||
$mnemonic,$arg;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
foreach (split($/,$code)) {
|
||||
|
||||
s/\`([^\`]*)\`/eval $1/geo;
|
||||
|
||||
s/\b(sha256\w+)\s+(q.*)/unsha256($1,$2)/geo;
|
||||
|
||||
s/\bret\b/bx lr/go or
|
||||
s/\bbx\s+lr\b/.word\t0xe12fff1e/go; # make it possible to compile with -march=armv4
|
||||
|
||||
print $_,"\n";
|
||||
}
|
||||
|
||||
close STDOUT; # enforce flush
|
||||
|
||||
1560
crypto/sha/asm/sha256-mb-x86_64.pl
Normal file
1560
crypto/sha/asm/sha256-mb-x86_64.pl
Normal file
File diff suppressed because it is too large
Load Diff
@@ -1,7 +1,7 @@
|
||||
#!/usr/bin/env perl
|
||||
#
|
||||
# ====================================================================
|
||||
# Written by Andy Polyakov <appro@fy.chalmers.se> for the OpenSSL
|
||||
# Written by Andy Polyakov <appro@openssl.org> 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/.
|
||||
@@ -9,17 +9,31 @@
|
||||
#
|
||||
# SHA512 block transform for x86. September 2007.
|
||||
#
|
||||
# May 2013.
|
||||
#
|
||||
# Add SSSE3 code path, 20-25% improvement [over original SSE2 code].
|
||||
#
|
||||
# Performance in clock cycles per processed byte (less is better):
|
||||
#
|
||||
# Pentium PIII P4 AMD K8 Core2
|
||||
# gcc 100 75 116 54 66
|
||||
# icc 97 77 95 55 57
|
||||
# x86 asm 61 56 82 36 40
|
||||
# SSE2 asm - - 38 24 20
|
||||
# x86_64 asm(*) - - 30 10.0 10.5
|
||||
# gcc icc x86 asm SIMD(*) x86_64(**)
|
||||
# Pentium 100 97 61 - -
|
||||
# PIII 75 77 56 - -
|
||||
# P4 116 95 82 34.6 30.8
|
||||
# AMD K8 54 55 36 20.7 9.57
|
||||
# Core2 66 57 40 15.9 9.97
|
||||
# Westmere 70 - 38 12.2 9.58
|
||||
# Sandy Bridge 58 - 35 11.9 11.2
|
||||
# Ivy Bridge 50 - 33 11.5 8.17
|
||||
# Haswell 46 - 29 11.3 7.66
|
||||
# Bulldozer 121 - 50 14.0 13.5
|
||||
# VIA Nano 91 - 52 33 14.7
|
||||
# Atom 126 - 68 48(***) 14.7
|
||||
# Silvermont 97 - 58 42(***) 17.5
|
||||
#
|
||||
# (*) x86_64 assembler performance is presented for reference
|
||||
# purposes.
|
||||
# (*) whichever best applicable.
|
||||
# (**) x86_64 assembler performance is presented for reference
|
||||
# purposes, the results are for integer-only code.
|
||||
# (***) paddq is increadibly slow on Atom.
|
||||
#
|
||||
# IALU code-path is optimized for elder Pentiums. On vanilla Pentium
|
||||
# performance improvement over compiler generated code reaches ~60%,
|
||||
@@ -66,72 +80,77 @@ $Hsse2=&QWP(56,"esp");
|
||||
$A="mm0"; # B-D and
|
||||
$E="mm4"; # F-H are commonly loaded to respectively mm1-mm3 and
|
||||
# mm5-mm7, but it's done on on-demand basis...
|
||||
$BxC="mm2"; # ... except for B^C
|
||||
|
||||
sub BODY_00_15_sse2 {
|
||||
my $prefetch=shift;
|
||||
my $phase=shift;
|
||||
|
||||
&movq ("mm5",$Fsse2); # load f
|
||||
&movq ("mm6",$Gsse2); # load g
|
||||
&movq ("mm7",$Hsse2); # load h
|
||||
#&movq ("mm5",$Fsse2); # load f
|
||||
#&movq ("mm6",$Gsse2); # load g
|
||||
|
||||
&movq ("mm1",$E); # %mm1 is sliding right
|
||||
&movq ("mm2",$E); # %mm2 is sliding left
|
||||
&pxor ("mm5","mm6"); # f^=g
|
||||
&psrlq ("mm1",14);
|
||||
&movq ($Esse2,$E); # modulo-scheduled save e
|
||||
&psllq ("mm2",23);
|
||||
&movq ($Esse2,$E); # modulo-scheduled save e
|
||||
&pand ("mm5",$E); # f&=e
|
||||
&psllq ($E,23); # $E is sliding left
|
||||
&movq ($A,"mm3") if ($phase<2);
|
||||
&movq (&QWP(8*9,"esp"),"mm7") # save X[i]
|
||||
&movq ("mm3","mm1"); # %mm3 is T1
|
||||
&psrlq ("mm1",4);
|
||||
&pxor ("mm3","mm2");
|
||||
&psllq ("mm2",23);
|
||||
&psrlq ("mm1",4);
|
||||
&pxor ("mm5","mm6"); # Ch(e,f,g)
|
||||
&pxor ("mm3",$E);
|
||||
&psllq ($E,23);
|
||||
&pxor ("mm3","mm1");
|
||||
&psrlq ("mm1",23);
|
||||
&pxor ("mm3","mm2");
|
||||
&psllq ("mm2",4);
|
||||
&movq ($Asse2,$A); # modulo-scheduled save a
|
||||
&paddq ("mm7","mm5"); # X[i]+=Ch(e,f,g)
|
||||
&pxor ("mm3",$E);
|
||||
&psrlq ("mm1",23);
|
||||
&paddq ("mm7",$Hsse2); # X[i]+=h
|
||||
&pxor ("mm3","mm1");
|
||||
&paddq ("mm7",QWP(0,$K512)); # h+=K512[i]
|
||||
&pxor ("mm3","mm2"); # T1=Sigma1_512(e)
|
||||
&psllq ($E,4);
|
||||
&paddq ("mm7",QWP(0,$K512)); # X[i]+=K512[i]
|
||||
&pxor ("mm3",$E); # T1=Sigma1_512(e)
|
||||
|
||||
&pxor ("mm5","mm6"); # f^=g
|
||||
&movq ($E,$Dsse2); # e = load d, e in next round
|
||||
&paddq ("mm3","mm7"); # T1+=X[i]
|
||||
&movq ("mm5",$A); # %mm5 is sliding right
|
||||
&psrlq ("mm5",28);
|
||||
&paddq ($E,"mm3"); # d += T1
|
||||
&movq ("mm6",$A); # %mm6 is sliding left
|
||||
&movq ("mm7","mm5");
|
||||
&psllq ("mm6",25);
|
||||
&movq ("mm1",$Bsse2); # load b
|
||||
&pand ("mm5",$E); # f&=e
|
||||
&movq ("mm2",$Csse2); # load c
|
||||
&pxor ("mm5","mm6"); # f^=g
|
||||
&movq ($E,$Dsse2); # e = load d
|
||||
&paddq ("mm3","mm5"); # T1+=Ch(e,f,g)
|
||||
&movq (&QWP(0,"esp"),$A); # modulo-scheduled save a
|
||||
&paddq ("mm3","mm7"); # T1+=h
|
||||
|
||||
&movq ("mm5",$A); # %mm5 is sliding right
|
||||
&movq ("mm6",$A); # %mm6 is sliding left
|
||||
&paddq ("mm3",&QWP(8*9,"esp")); # T1+=X[0]
|
||||
&psrlq ("mm5",28);
|
||||
&paddq ($E,"mm3"); # e += T1
|
||||
&psllq ("mm6",25);
|
||||
&movq ("mm7","mm5"); # %mm7 is T2
|
||||
&psrlq ("mm5",6);
|
||||
&pxor ("mm7","mm6");
|
||||
&psllq ("mm6",5);
|
||||
&pxor ("mm7","mm5");
|
||||
&psrlq ("mm5",5);
|
||||
&pxor ("mm7","mm6");
|
||||
&psllq ("mm6",6);
|
||||
&pxor ("mm7","mm5");
|
||||
&psrlq ("mm5",6);
|
||||
&pxor ("mm7","mm6");
|
||||
&sub ("esp",8);
|
||||
&pxor ("mm7","mm6"); # T2=Sigma0_512(a)
|
||||
&psllq ("mm6",5);
|
||||
&pxor ("mm7","mm5");
|
||||
&pxor ($A,"mm1"); # a^b, b^c in next round
|
||||
&psrlq ("mm5",5);
|
||||
&pxor ("mm7","mm6");
|
||||
&pand ($BxC,$A); # (b^c)&(a^b)
|
||||
&psllq ("mm6",6);
|
||||
&pxor ("mm7","mm5");
|
||||
&pxor ($BxC,"mm1"); # [h=]Maj(a,b,c)
|
||||
&pxor ("mm6","mm7"); # Sigma0_512(a)
|
||||
&movq ("mm7",&QWP(8*(9+16-1),"esp")) if ($phase!=0); # pre-fetch
|
||||
&movq ("mm5",$Fsse2) if ($phase==0); # load f
|
||||
|
||||
&movq ("mm5",$A); # %mm5=a
|
||||
&por ($A,"mm2"); # a=a|c
|
||||
&movq ("mm6",&QWP(8*(9+16-14),"esp")) if ($prefetch);
|
||||
&pand ("mm5","mm2"); # %mm5=a&c
|
||||
&pand ($A,"mm1"); # a=(a|c)&b
|
||||
&movq ("mm2",&QWP(8*(9+16-1),"esp")) if ($prefetch);
|
||||
&por ("mm5",$A); # %mm5=(a&c)|((a|c)&b)
|
||||
&paddq ("mm7","mm5"); # T2+=Maj(a,b,c)
|
||||
&movq ($A,"mm3"); # a=T1
|
||||
if ($phase>1) {
|
||||
&paddq ($BxC,"mm6"); # h+=Sigma0(a)
|
||||
&add ($K512,8);
|
||||
#&paddq ($BxC,"mm3"); # h+=T1
|
||||
|
||||
&mov (&LB("edx"),&BP(0,$K512));
|
||||
&paddq ($A,"mm7"); # a+=T2
|
||||
&add ($K512,8);
|
||||
($A,$BxC) = ($BxC,$A); # rotate registers
|
||||
} else {
|
||||
&paddq ("mm3",$BxC); # T1+=Maj(a,b,c)
|
||||
&movq ($BxC,$A);
|
||||
&add ($K512,8);
|
||||
&paddq ("mm3","mm6"); # T1+=Sigma0(a)
|
||||
&movq ("mm6",$Gsse2) if ($phase==0); # load g
|
||||
#&movq ($A,"mm3"); # h=T1
|
||||
}
|
||||
}
|
||||
|
||||
sub BODY_00_15_x86 {
|
||||
@@ -142,9 +161,9 @@ sub BODY_00_15_x86 {
|
||||
&mov ("edx",$Ehi);
|
||||
&mov ("esi","ecx");
|
||||
|
||||
&shr ("ecx",9) # lo>>9
|
||||
&shr ("ecx",9); # lo>>9
|
||||
&mov ("edi","edx");
|
||||
&shr ("edx",9) # hi>>9
|
||||
&shr ("edx",9); # hi>>9
|
||||
&mov ("ebx","ecx");
|
||||
&shl ("esi",14); # lo<<14
|
||||
&mov ("eax","edx");
|
||||
@@ -207,9 +226,9 @@ sub BODY_00_15_x86 {
|
||||
&mov ($Dhi,"ebx");
|
||||
&mov ("esi","ecx");
|
||||
|
||||
&shr ("ecx",2) # lo>>2
|
||||
&shr ("ecx",2); # lo>>2
|
||||
&mov ("edi","edx");
|
||||
&shr ("edx",2) # hi>>2
|
||||
&shr ("edx",2); # hi>>2
|
||||
&mov ("ebx","ecx");
|
||||
&shl ("esi",4); # lo<<4
|
||||
&mov ("eax","edx");
|
||||
@@ -284,110 +303,357 @@ sub BODY_00_15_x86 {
|
||||
|
||||
if ($sse2) {
|
||||
&picmeup("edx","OPENSSL_ia32cap_P",$K512,&label("K512"));
|
||||
&bt (&DWP(0,"edx"),26);
|
||||
&jnc (&label("loop_x86"));
|
||||
&mov ("ecx",&DWP(0,"edx"));
|
||||
&test ("ecx",1<<26);
|
||||
&jz (&label("loop_x86"));
|
||||
|
||||
&mov ("edx",&DWP(4,"edx"));
|
||||
|
||||
# load ctx->h[0-7]
|
||||
&movq ($A,&QWP(0,"esi"));
|
||||
&and ("ecx",1<<24); # XMM registers availability
|
||||
&movq ("mm1",&QWP(8,"esi"));
|
||||
&movq ("mm2",&QWP(16,"esi"));
|
||||
&and ("edx",1<<9); # SSSE3 bit
|
||||
&movq ($BxC,&QWP(16,"esi"));
|
||||
&or ("ecx","edx");
|
||||
&movq ("mm3",&QWP(24,"esi"));
|
||||
&movq ($E,&QWP(32,"esi"));
|
||||
&movq ("mm5",&QWP(40,"esi"));
|
||||
&movq ("mm6",&QWP(48,"esi"));
|
||||
&movq ("mm7",&QWP(56,"esi"));
|
||||
&cmp ("ecx",1<<24|1<<9);
|
||||
&je (&label("SSSE3"));
|
||||
&sub ("esp",8*10);
|
||||
&jmp (&label("loop_sse2"));
|
||||
|
||||
&set_label("loop_sse2",16);
|
||||
# &movq ($Asse2,$A);
|
||||
#&movq ($Asse2,$A);
|
||||
&movq ($Bsse2,"mm1");
|
||||
&movq ($Csse2,"mm2");
|
||||
&movq ($Csse2,$BxC);
|
||||
&movq ($Dsse2,"mm3");
|
||||
# &movq ($Esse2,$E);
|
||||
#&movq ($Esse2,$E);
|
||||
&movq ($Fsse2,"mm5");
|
||||
&movq ($Gsse2,"mm6");
|
||||
&pxor ($BxC,"mm1"); # magic
|
||||
&movq ($Hsse2,"mm7");
|
||||
&movq ("mm3",$A); # magic
|
||||
|
||||
&mov ("ecx",&DWP(0,"edi"));
|
||||
&mov ("edx",&DWP(4,"edi"));
|
||||
&mov ("eax",&DWP(0,"edi"));
|
||||
&mov ("ebx",&DWP(4,"edi"));
|
||||
&add ("edi",8);
|
||||
&bswap ("ecx");
|
||||
&bswap ("edx");
|
||||
&mov (&DWP(8*9+4,"esp"),"ecx");
|
||||
&mov (&DWP(8*9+0,"esp"),"edx");
|
||||
&mov ("edx",15); # counter
|
||||
&bswap ("eax");
|
||||
&bswap ("ebx");
|
||||
&jmp (&label("00_14_sse2"));
|
||||
|
||||
&set_label("00_14_sse2",16);
|
||||
&movd ("mm1","eax");
|
||||
&mov ("eax",&DWP(0,"edi"));
|
||||
&movd ("mm7","ebx");
|
||||
&mov ("ebx",&DWP(4,"edi"));
|
||||
&add ("edi",8);
|
||||
&bswap ("eax");
|
||||
&bswap ("ebx");
|
||||
&mov (&DWP(8*8+4,"esp"),"eax");
|
||||
&mov (&DWP(8*8+0,"esp"),"ebx");
|
||||
&punpckldq("mm7","mm1");
|
||||
|
||||
&BODY_00_15_sse2();
|
||||
|
||||
&cmp (&LB("edx"),0x35);
|
||||
&jne (&label("00_14_sse2"));
|
||||
&dec ("edx");
|
||||
&jnz (&label("00_14_sse2"));
|
||||
|
||||
&movd ("mm1","eax");
|
||||
&movd ("mm7","ebx");
|
||||
&punpckldq("mm7","mm1");
|
||||
|
||||
&BODY_00_15_sse2(1);
|
||||
|
||||
&pxor ($A,$A); # A is in %mm3
|
||||
&mov ("edx",32); # counter
|
||||
&jmp (&label("16_79_sse2"));
|
||||
|
||||
&set_label("16_79_sse2",16);
|
||||
#&movq ("mm2",&QWP(8*(9+16-1),"esp")); #prefetched in BODY_00_15
|
||||
#&movq ("mm6",&QWP(8*(9+16-14),"esp"));
|
||||
&movq ("mm1","mm2");
|
||||
|
||||
&psrlq ("mm2",1);
|
||||
&movq ("mm7","mm6");
|
||||
&psrlq ("mm6",6);
|
||||
&movq ("mm3","mm2");
|
||||
|
||||
&psrlq ("mm2",7-1);
|
||||
&movq ("mm5","mm6");
|
||||
&psrlq ("mm6",19-6);
|
||||
&pxor ("mm3","mm2");
|
||||
|
||||
&psrlq ("mm2",8-7);
|
||||
&pxor ("mm5","mm6");
|
||||
&psrlq ("mm6",61-19);
|
||||
&pxor ("mm3","mm2");
|
||||
|
||||
&movq ("mm2",&QWP(8*(9+16),"esp"));
|
||||
|
||||
for ($j=0;$j<2;$j++) { # 2x unroll
|
||||
#&movq ("mm7",&QWP(8*(9+16-1),"esp")); # prefetched in BODY_00_15
|
||||
&movq ("mm5",&QWP(8*(9+16-14),"esp"));
|
||||
&movq ("mm1","mm7");
|
||||
&psrlq ("mm7",1);
|
||||
&movq ("mm6","mm5");
|
||||
&psrlq ("mm5",6);
|
||||
&psllq ("mm1",56);
|
||||
&pxor ("mm5","mm6");
|
||||
&psllq ("mm7",3);
|
||||
&paddq ($A,"mm3"); # from BODY_00_15
|
||||
&movq ("mm3","mm7");
|
||||
&psrlq ("mm7",7-1);
|
||||
&pxor ("mm3","mm1");
|
||||
&psllq ("mm1",63-56);
|
||||
&pxor ("mm3","mm7");
|
||||
&psrlq ("mm7",8-7);
|
||||
&pxor ("mm3","mm1");
|
||||
&movq ("mm1","mm5");
|
||||
&psrlq ("mm5",19-6);
|
||||
&pxor ("mm7","mm3"); # sigma0
|
||||
|
||||
&paddq ("mm2",&QWP(8*(9+16-9),"esp"));
|
||||
&psllq ("mm6",3);
|
||||
&pxor ("mm1","mm5");
|
||||
&paddq ("mm7",&QWP(8*(9+16),"esp"));
|
||||
&pxor ("mm1","mm6");
|
||||
&psrlq ("mm5",61-19);
|
||||
&paddq ("mm7",&QWP(8*(9+16-9),"esp"));
|
||||
&pxor ("mm1","mm5");
|
||||
&psllq ("mm6",45-3);
|
||||
&movq ("mm5",$Fsse2); # load f
|
||||
&pxor ("mm1","mm6"); # sigma1
|
||||
&movq ("mm6",$Gsse2); # load g
|
||||
|
||||
&psllq ("mm1",63-56);
|
||||
&pxor ("mm5","mm7");
|
||||
&psllq ("mm7",45-3);
|
||||
&pxor ("mm3","mm1");
|
||||
&pxor ("mm5","mm7");
|
||||
&paddq ("mm7","mm1"); # X[i]
|
||||
#&movq (&QWP(8*9,"esp"),"mm7"); # moved to BODY_00_15
|
||||
|
||||
&paddq ("mm3","mm5");
|
||||
&paddq ("mm3","mm2");
|
||||
&movq (&QWP(8*9,"esp"),"mm3");
|
||||
&BODY_00_15_sse2(2);
|
||||
}
|
||||
&dec ("edx");
|
||||
&jnz (&label("16_79_sse2"));
|
||||
|
||||
&BODY_00_15_sse2(1);
|
||||
|
||||
&cmp (&LB("edx"),0x17);
|
||||
&jne (&label("16_79_sse2"));
|
||||
|
||||
# &movq ($A,$Asse2);
|
||||
#&movq ($A,$Asse2);
|
||||
&paddq ($A,"mm3"); # from BODY_00_15
|
||||
&movq ("mm1",$Bsse2);
|
||||
&movq ("mm2",$Csse2);
|
||||
#&movq ($BxC,$Csse2);
|
||||
&movq ("mm3",$Dsse2);
|
||||
# &movq ($E,$Esse2);
|
||||
#&movq ($E,$Esse2);
|
||||
&movq ("mm5",$Fsse2);
|
||||
&movq ("mm6",$Gsse2);
|
||||
&movq ("mm7",$Hsse2);
|
||||
|
||||
&pxor ($BxC,"mm1"); # de-magic
|
||||
&paddq ($A,&QWP(0,"esi"));
|
||||
&paddq ("mm1",&QWP(8,"esi"));
|
||||
&paddq ("mm2",&QWP(16,"esi"));
|
||||
&paddq ($BxC,&QWP(16,"esi"));
|
||||
&paddq ("mm3",&QWP(24,"esi"));
|
||||
&paddq ($E,&QWP(32,"esi"));
|
||||
&paddq ("mm5",&QWP(40,"esi"));
|
||||
&paddq ("mm6",&QWP(48,"esi"));
|
||||
&paddq ("mm7",&QWP(56,"esi"));
|
||||
|
||||
&mov ("eax",8*80);
|
||||
&movq (&QWP(0,"esi"),$A);
|
||||
&movq (&QWP(8,"esi"),"mm1");
|
||||
&movq (&QWP(16,"esi"),$BxC);
|
||||
&movq (&QWP(24,"esi"),"mm3");
|
||||
&movq (&QWP(32,"esi"),$E);
|
||||
&movq (&QWP(40,"esi"),"mm5");
|
||||
&movq (&QWP(48,"esi"),"mm6");
|
||||
&movq (&QWP(56,"esi"),"mm7");
|
||||
|
||||
&lea ("esp",&DWP(0,"esp","eax")); # destroy frame
|
||||
&sub ($K512,"eax"); # rewind K
|
||||
|
||||
&cmp ("edi",&DWP(8*10+8,"esp")); # are we done yet?
|
||||
&jb (&label("loop_sse2"));
|
||||
|
||||
&mov ("esp",&DWP(8*10+12,"esp")); # restore sp
|
||||
&emms ();
|
||||
&function_end_A();
|
||||
|
||||
&set_label("SSSE3",32);
|
||||
{ my ($cnt,$frame)=("ecx","edx");
|
||||
my @X=map("xmm$_",(0..7));
|
||||
my $j;
|
||||
my $i=0;
|
||||
|
||||
&lea ($frame,&DWP(-64,"esp"));
|
||||
&sub ("esp",256);
|
||||
|
||||
# fixed stack frame layout
|
||||
#
|
||||
# +0 A B C D E F G H # backing store
|
||||
# +64 X[0]+K[i] .. X[15]+K[i] # XMM->MM xfer area
|
||||
# +192 # XMM off-load ring buffer
|
||||
# +256 # saved parameters
|
||||
|
||||
&movdqa (@X[1],&QWP(80*8,$K512)); # byte swap mask
|
||||
&movdqu (@X[0],&QWP(0,"edi"));
|
||||
&pshufb (@X[0],@X[1]);
|
||||
for ($j=0;$j<8;$j++) {
|
||||
&movdqa (&QWP(16*(($j-1)%4),$frame),@X[3]) if ($j>4); # off-load
|
||||
&movdqa (@X[3],&QWP(16*($j%8),$K512));
|
||||
&movdqa (@X[2],@X[1]) if ($j<7); # perpetuate byte swap mask
|
||||
&movdqu (@X[1],&QWP(16*($j+1),"edi")) if ($j<7); # next input
|
||||
&movdqa (@X[1],&QWP(16*(($j+1)%4),$frame)) if ($j==7);# restore @X[0]
|
||||
&paddq (@X[3],@X[0]);
|
||||
&pshufb (@X[1],@X[2]) if ($j<7);
|
||||
&movdqa (&QWP(16*($j%8)-128,$frame),@X[3]); # xfer X[i]+K[i]
|
||||
|
||||
push(@X,shift(@X)); # rotate(@X)
|
||||
}
|
||||
#&jmp (&label("loop_ssse3"));
|
||||
&nop ();
|
||||
|
||||
&set_label("loop_ssse3",32);
|
||||
&movdqa (@X[2],&QWP(16*(($j+1)%4),$frame)); # pre-restore @X[1]
|
||||
&movdqa (&QWP(16*(($j-1)%4),$frame),@X[3]); # off-load @X[3]
|
||||
&lea ($K512,&DWP(16*8,$K512));
|
||||
|
||||
#&movq ($Asse2,$A); # off-load A-H
|
||||
&movq ($Bsse2,"mm1");
|
||||
&mov ("ebx","edi");
|
||||
&movq ($Csse2,$BxC);
|
||||
&lea ("edi",&DWP(128,"edi")); # advance input
|
||||
&movq ($Dsse2,"mm3");
|
||||
&cmp ("edi","eax");
|
||||
#&movq ($Esse2,$E);
|
||||
&movq ($Fsse2,"mm5");
|
||||
&cmovb ("ebx","edi");
|
||||
&movq ($Gsse2,"mm6");
|
||||
&mov ("ecx",4); # loop counter
|
||||
&pxor ($BxC,"mm1"); # magic
|
||||
&movq ($Hsse2,"mm7");
|
||||
&pxor ("mm3","mm3"); # magic
|
||||
|
||||
&jmp (&label("00_47_ssse3"));
|
||||
|
||||
sub BODY_00_15_ssse3 { # "phase-less" copy of BODY_00_15_sse2
|
||||
(
|
||||
'&movq ("mm1",$E)', # %mm1 is sliding right
|
||||
'&movq ("mm7",&QWP(((-8*$i)%128)-128,$frame))',# X[i]+K[i]
|
||||
'&pxor ("mm5","mm6")', # f^=g
|
||||
'&psrlq ("mm1",14)',
|
||||
'&movq (&QWP(8*($i+4)%64,"esp"),$E)', # modulo-scheduled save e
|
||||
'&pand ("mm5",$E)', # f&=e
|
||||
'&psllq ($E,23)', # $E is sliding left
|
||||
'&paddq ($A,"mm3")', # [h+=Maj(a,b,c)]
|
||||
'&movq ("mm3","mm1")', # %mm3 is T1
|
||||
'&psrlq("mm1",4)',
|
||||
'&pxor ("mm5","mm6")', # Ch(e,f,g)
|
||||
'&pxor ("mm3",$E)',
|
||||
'&psllq($E,23)',
|
||||
'&pxor ("mm3","mm1")',
|
||||
'&movq (&QWP(8*$i%64,"esp"),$A)', # modulo-scheduled save a
|
||||
'&paddq("mm7","mm5")', # X[i]+=Ch(e,f,g)
|
||||
'&pxor ("mm3",$E)',
|
||||
'&psrlq("mm1",23)',
|
||||
'&paddq("mm7",&QWP(8*($i+7)%64,"esp"))', # X[i]+=h
|
||||
'&pxor ("mm3","mm1")',
|
||||
'&psllq($E,4)',
|
||||
'&pxor ("mm3",$E)', # T1=Sigma1_512(e)
|
||||
|
||||
'&movq ($E,&QWP(8*($i+3)%64,"esp"))', # e = load d, e in next round
|
||||
'&paddq ("mm3","mm7")', # T1+=X[i]
|
||||
'&movq ("mm5",$A)', # %mm5 is sliding right
|
||||
'&psrlq("mm5",28)',
|
||||
'&paddq ($E,"mm3")', # d += T1
|
||||
'&movq ("mm6",$A)', # %mm6 is sliding left
|
||||
'&movq ("mm7","mm5")',
|
||||
'&psllq("mm6",25)',
|
||||
'&movq ("mm1",&QWP(8*($i+1)%64,"esp"))', # load b
|
||||
'&psrlq("mm5",6)',
|
||||
'&pxor ("mm7","mm6")',
|
||||
'&psllq("mm6",5)',
|
||||
'&pxor ("mm7","mm5")',
|
||||
'&pxor ($A,"mm1")', # a^b, b^c in next round
|
||||
'&psrlq("mm5",5)',
|
||||
'&pxor ("mm7","mm6")',
|
||||
'&pand ($BxC,$A)', # (b^c)&(a^b)
|
||||
'&psllq("mm6",6)',
|
||||
'&pxor ("mm7","mm5")',
|
||||
'&pxor ($BxC,"mm1")', # [h=]Maj(a,b,c)
|
||||
'&pxor ("mm6","mm7")', # Sigma0_512(a)
|
||||
'&movq ("mm5",&QWP(8*($i+5-1)%64,"esp"))', # pre-load f
|
||||
'&paddq ($BxC,"mm6")', # h+=Sigma0(a)
|
||||
'&movq ("mm6",&QWP(8*($i+6-1)%64,"esp"))', # pre-load g
|
||||
|
||||
'($A,$BxC) = ($BxC,$A); $i--;'
|
||||
);
|
||||
}
|
||||
|
||||
&set_label("00_47_ssse3",32);
|
||||
|
||||
for(;$j<16;$j++) {
|
||||
my ($t0,$t2,$t1)=@X[2..4];
|
||||
my @insns = (&BODY_00_15_ssse3(),&BODY_00_15_ssse3());
|
||||
|
||||
&movdqa ($t2,@X[5]);
|
||||
&movdqa (@X[1],$t0); # restore @X[1]
|
||||
&palignr ($t0,@X[0],8); # X[1..2]
|
||||
&movdqa (&QWP(16*($j%4),$frame),@X[4]); # off-load @X[4]
|
||||
&palignr ($t2,@X[4],8); # X[9..10]
|
||||
|
||||
&movdqa ($t1,$t0);
|
||||
&psrlq ($t0,7);
|
||||
&paddq (@X[0],$t2); # X[0..1] += X[9..10]
|
||||
&movdqa ($t2,$t1);
|
||||
&psrlq ($t1,1);
|
||||
&psllq ($t2,64-8);
|
||||
&pxor ($t0,$t1);
|
||||
&psrlq ($t1,8-1);
|
||||
&pxor ($t0,$t2);
|
||||
&psllq ($t2,8-1);
|
||||
&pxor ($t0,$t1);
|
||||
&movdqa ($t1,@X[7]);
|
||||
&pxor ($t0,$t2); # sigma0(X[1..2])
|
||||
&movdqa ($t2,@X[7]);
|
||||
&psrlq ($t1,6);
|
||||
&paddq (@X[0],$t0); # X[0..1] += sigma0(X[1..2])
|
||||
|
||||
&movdqa ($t0,@X[7]);
|
||||
&psrlq ($t2,19);
|
||||
&psllq ($t0,64-61);
|
||||
&pxor ($t1,$t2);
|
||||
&psrlq ($t2,61-19);
|
||||
&pxor ($t1,$t0);
|
||||
&psllq ($t0,61-19);
|
||||
&pxor ($t1,$t2);
|
||||
&movdqa ($t2,&QWP(16*(($j+2)%4),$frame));# pre-restore @X[1]
|
||||
&pxor ($t1,$t0); # sigma0(X[1..2])
|
||||
&movdqa ($t0,&QWP(16*($j%8),$K512));
|
||||
eval(shift(@insns));
|
||||
&paddq (@X[0],$t1); # X[0..1] += sigma0(X[14..15])
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
eval(shift(@insns));
|
||||
&paddq ($t0,@X[0]);
|
||||
foreach(@insns) { eval; }
|
||||
&movdqa (&QWP(16*($j%8)-128,$frame),$t0);# xfer X[i]+K[i]
|
||||
|
||||
push(@X,shift(@X)); # rotate(@X)
|
||||
}
|
||||
&lea ($K512,&DWP(16*8,$K512));
|
||||
&dec ("ecx");
|
||||
&jnz (&label("00_47_ssse3"));
|
||||
|
||||
&movdqa (@X[1],&QWP(0,$K512)); # byte swap mask
|
||||
&lea ($K512,&DWP(-80*8,$K512)); # rewind
|
||||
&movdqu (@X[0],&QWP(0,"ebx"));
|
||||
&pshufb (@X[0],@X[1]);
|
||||
|
||||
for ($j=0;$j<8;$j++) { # load next or same block
|
||||
my @insns = (&BODY_00_15_ssse3(),&BODY_00_15_ssse3());
|
||||
|
||||
&movdqa (&QWP(16*(($j-1)%4),$frame),@X[3]) if ($j>4); # off-load
|
||||
&movdqa (@X[3],&QWP(16*($j%8),$K512));
|
||||
&movdqa (@X[2],@X[1]) if ($j<7); # perpetuate byte swap mask
|
||||
&movdqu (@X[1],&QWP(16*($j+1),"ebx")) if ($j<7); # next input
|
||||
&movdqa (@X[1],&QWP(16*(($j+1)%4),$frame)) if ($j==7);# restore @X[0]
|
||||
&paddq (@X[3],@X[0]);
|
||||
&pshufb (@X[1],@X[2]) if ($j<7);
|
||||
foreach(@insns) { eval; }
|
||||
&movdqa (&QWP(16*($j%8)-128,$frame),@X[3]);# xfer X[i]+K[i]
|
||||
|
||||
push(@X,shift(@X)); # rotate(@X)
|
||||
}
|
||||
|
||||
#&movq ($A,$Asse2); # load A-H
|
||||
&movq ("mm1",$Bsse2);
|
||||
&paddq ($A,"mm3"); # from BODY_00_15
|
||||
#&movq ($BxC,$Csse2);
|
||||
&movq ("mm3",$Dsse2);
|
||||
#&movq ($E,$Esse2);
|
||||
#&movq ("mm5",$Fsse2);
|
||||
#&movq ("mm6",$Gsse2);
|
||||
&movq ("mm7",$Hsse2);
|
||||
|
||||
&pxor ($BxC,"mm1"); # de-magic
|
||||
&paddq ($A,&QWP(0,"esi"));
|
||||
&paddq ("mm1",&QWP(8,"esi"));
|
||||
&paddq ($BxC,&QWP(16,"esi"));
|
||||
&paddq ("mm3",&QWP(24,"esi"));
|
||||
&paddq ($E,&QWP(32,"esi"));
|
||||
&paddq ("mm5",&QWP(40,"esi"));
|
||||
@@ -396,21 +662,19 @@ if ($sse2) {
|
||||
|
||||
&movq (&QWP(0,"esi"),$A);
|
||||
&movq (&QWP(8,"esi"),"mm1");
|
||||
&movq (&QWP(16,"esi"),"mm2");
|
||||
&movq (&QWP(16,"esi"),$BxC);
|
||||
&movq (&QWP(24,"esi"),"mm3");
|
||||
&movq (&QWP(32,"esi"),$E);
|
||||
&movq (&QWP(40,"esi"),"mm5");
|
||||
&movq (&QWP(48,"esi"),"mm6");
|
||||
&movq (&QWP(56,"esi"),"mm7");
|
||||
|
||||
&add ("esp",8*80); # destroy frame
|
||||
&sub ($K512,8*80); # rewind K
|
||||
|
||||
&cmp ("edi",&DWP(8*10+8,"esp")); # are we done yet?
|
||||
&jb (&label("loop_sse2"));
|
||||
&cmp ("edi","eax") # are we done yet?
|
||||
&jb (&label("loop_ssse3"));
|
||||
|
||||
&mov ("esp",&DWP(64+12,$frame)); # restore sp
|
||||
&emms ();
|
||||
&mov ("esp",&DWP(8*10+12,"esp")); # restore sp
|
||||
}
|
||||
&function_end_A();
|
||||
}
|
||||
&set_label("loop_x86",16);
|
||||
@@ -452,9 +716,9 @@ if ($sse2) {
|
||||
&mov ("edx",&DWP(8*(9+15+16-1)+4,"esp"));
|
||||
&mov ("esi","ecx");
|
||||
|
||||
&shr ("ecx",1) # lo>>1
|
||||
&shr ("ecx",1); # lo>>1
|
||||
&mov ("edi","edx");
|
||||
&shr ("edx",1) # hi>>1
|
||||
&shr ("edx",1); # hi>>1
|
||||
&mov ("eax","ecx");
|
||||
&shl ("esi",24); # lo<<24
|
||||
&mov ("ebx","edx");
|
||||
@@ -488,9 +752,9 @@ if ($sse2) {
|
||||
&mov ("edx",&DWP(8*(9+15+16-14)+4,"esp"));
|
||||
&mov ("esi","ecx");
|
||||
|
||||
&shr ("ecx",6) # lo>>6
|
||||
&shr ("ecx",6); # lo>>6
|
||||
&mov ("edi","edx");
|
||||
&shr ("edx",6) # hi>>6
|
||||
&shr ("edx",6); # hi>>6
|
||||
&mov ("eax","ecx");
|
||||
&shl ("esi",3); # lo<<3
|
||||
&mov ("ebx","edx");
|
||||
@@ -638,6 +902,9 @@ if ($sse2) {
|
||||
&data_word(0xfc657e2a,0x597f299c); # u64
|
||||
&data_word(0x3ad6faec,0x5fcb6fab); # u64
|
||||
&data_word(0x4a475817,0x6c44198c); # u64
|
||||
|
||||
&data_word(0x04050607,0x00010203); # byte swap
|
||||
&data_word(0x0c0d0e0f,0x08090a0b); # mask
|
||||
&function_end_B("sha512_block_data_order");
|
||||
&asciz("SHA512 block transform for x86, CRYPTOGAMS by <appro\@openssl.org>");
|
||||
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
#!/usr/bin/env perl
|
||||
|
||||
# ====================================================================
|
||||
# Written by Andy Polyakov <appro@fy.chalmers.se> for the OpenSSL
|
||||
# Written by Andy Polyakov <appro@openssl.org> 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/.
|
||||
@@ -18,22 +18,50 @@
|
||||
# Rescheduling for dual-issue pipeline resulted in 6% improvement on
|
||||
# Cortex A8 core and ~40 cycles per processed byte.
|
||||
|
||||
# February 2011.
|
||||
#
|
||||
# Profiler-assisted and platform-specific optimization resulted in 7%
|
||||
# improvement on Coxtex A8 core and ~38 cycles per byte.
|
||||
|
||||
# March 2011.
|
||||
#
|
||||
# Add NEON implementation. On Cortex A8 it was measured to process
|
||||
# one byte in 23.3 cycles or ~60% faster than integer-only code.
|
||||
|
||||
# August 2012.
|
||||
#
|
||||
# Improve NEON performance by 12% on Snapdragon S4. In absolute
|
||||
# terms it's 22.6 cycles per byte, which is disappointing result.
|
||||
# Technical writers asserted that 3-way S4 pipeline can sustain
|
||||
# multiple NEON instructions per cycle, but dual NEON issue could
|
||||
# not be observed, and for NEON-only sequences IPC(*) was found to
|
||||
# be limited by 1:-( 0.33 and 0.66 were measured for sequences with
|
||||
# ILPs(*) of 1 and 2 respectively. This in turn means that you can
|
||||
# even find yourself striving, as I did here, for achieving IPC
|
||||
# adequate to one delivered by Cortex A8 [for reference, it's
|
||||
# 0.5 for ILP of 1, and 1 for higher ILPs].
|
||||
#
|
||||
# (*) ILP, instruction-level parallelism, how many instructions
|
||||
# *can* execute at the same time. IPC, instructions per cycle,
|
||||
# indicates how many instructions actually execute.
|
||||
|
||||
# Byte order [in]dependence. =========================================
|
||||
#
|
||||
# Caller is expected to maintain specific *dword* order in h[0-7],
|
||||
# namely with most significant dword at *lower* address, which is
|
||||
# reflected in below two parameters. *Byte* order within these dwords
|
||||
# in turn is whatever *native* byte order on current platform.
|
||||
$hi=0;
|
||||
$lo=4;
|
||||
# Originally caller was expected to maintain specific *dword* order in
|
||||
# h[0-7], namely with most significant dword at *lower* address, which
|
||||
# was reflected in below two parameters as 0 and 4. Now caller is
|
||||
# expected to maintain native byte order for whole 64-bit values.
|
||||
$hi="HI";
|
||||
$lo="LO";
|
||||
# ====================================================================
|
||||
|
||||
while (($output=shift) && ($output!~/^\w[\w\-]*\.\w+$/)) {}
|
||||
open STDOUT,">$output";
|
||||
|
||||
$ctx="r0";
|
||||
$ctx="r0"; # parameter block
|
||||
$inp="r1";
|
||||
$len="r2";
|
||||
|
||||
$Tlo="r3";
|
||||
$Thi="r4";
|
||||
$Alo="r5";
|
||||
@@ -61,15 +89,17 @@ $Xoff=8*8;
|
||||
sub BODY_00_15() {
|
||||
my $magic = shift;
|
||||
$code.=<<___;
|
||||
ldr $t2,[sp,#$Hoff+0] @ h.lo
|
||||
ldr $t3,[sp,#$Hoff+4] @ h.hi
|
||||
@ Sigma1(x) (ROTR((x),14) ^ ROTR((x),18) ^ ROTR((x),41))
|
||||
@ LO lo>>14^hi<<18 ^ lo>>18^hi<<14 ^ hi>>9^lo<<23
|
||||
@ HI hi>>14^lo<<18 ^ hi>>18^lo<<14 ^ lo>>9^hi<<23
|
||||
mov $t0,$Elo,lsr#14
|
||||
str $Tlo,[sp,#$Xoff+0]
|
||||
mov $t1,$Ehi,lsr#14
|
||||
str $Thi,[sp,#$Xoff+4]
|
||||
eor $t0,$t0,$Ehi,lsl#18
|
||||
ldr $t2,[sp,#$Hoff+0] @ h.lo
|
||||
eor $t1,$t1,$Elo,lsl#18
|
||||
ldr $t3,[sp,#$Hoff+4] @ h.hi
|
||||
eor $t0,$t0,$Elo,lsr#18
|
||||
eor $t1,$t1,$Ehi,lsr#18
|
||||
eor $t0,$t0,$Ehi,lsl#14
|
||||
@@ -96,25 +126,24 @@ $code.=<<___;
|
||||
and $t1,$t1,$Ehi
|
||||
str $Ahi,[sp,#$Aoff+4]
|
||||
eor $t0,$t0,$t2
|
||||
ldr $t2,[$Ktbl,#4] @ K[i].lo
|
||||
ldr $t2,[$Ktbl,#$lo] @ K[i].lo
|
||||
eor $t1,$t1,$t3 @ Ch(e,f,g)
|
||||
ldr $t3,[$Ktbl,#0] @ K[i].hi
|
||||
ldr $t3,[$Ktbl,#$hi] @ K[i].hi
|
||||
|
||||
adds $Tlo,$Tlo,$t0
|
||||
ldr $Elo,[sp,#$Doff+0] @ d.lo
|
||||
adc $Thi,$Thi,$t1 @ T += Ch(e,f,g)
|
||||
ldr $Ehi,[sp,#$Doff+4] @ d.hi
|
||||
adds $Tlo,$Tlo,$t2
|
||||
and $t0,$t2,#0xff
|
||||
adc $Thi,$Thi,$t3 @ T += K[i]
|
||||
adds $Elo,$Elo,$Tlo
|
||||
adc $Ehi,$Ehi,$Thi @ d += T
|
||||
|
||||
and $t0,$t2,#0xff
|
||||
teq $t0,#$magic
|
||||
orreq $Ktbl,$Ktbl,#1
|
||||
|
||||
ldr $t2,[sp,#$Boff+0] @ b.lo
|
||||
adc $Ehi,$Ehi,$Thi @ d += T
|
||||
teq $t0,#$magic
|
||||
|
||||
ldr $t3,[sp,#$Coff+0] @ c.lo
|
||||
orreq $Ktbl,$Ktbl,#1
|
||||
@ Sigma0(x) (ROTR((x),28) ^ ROTR((x),34) ^ ROTR((x),39))
|
||||
@ LO lo>>28^hi<<4 ^ hi>>2^lo<<30 ^ hi>>7^lo<<25
|
||||
@ HI hi>>28^lo<<4 ^ lo>>2^hi<<30 ^ lo>>7^hi<<25
|
||||
@@ -131,80 +160,104 @@ $code.=<<___;
|
||||
eor $t0,$t0,$Alo,lsl#25
|
||||
eor $t1,$t1,$Ahi,lsl#25 @ Sigma0(a)
|
||||
adds $Tlo,$Tlo,$t0
|
||||
and $t0,$Alo,$t2
|
||||
adc $Thi,$Thi,$t1 @ T += Sigma0(a)
|
||||
|
||||
and $t0,$Alo,$t2
|
||||
orr $Alo,$Alo,$t2
|
||||
ldr $t1,[sp,#$Boff+4] @ b.hi
|
||||
orr $Alo,$Alo,$t2
|
||||
ldr $t2,[sp,#$Coff+4] @ c.hi
|
||||
and $Alo,$Alo,$t3
|
||||
orr $Alo,$Alo,$t0 @ Maj(a,b,c).lo
|
||||
and $t3,$Ahi,$t1
|
||||
orr $Ahi,$Ahi,$t1
|
||||
orr $Alo,$Alo,$t0 @ Maj(a,b,c).lo
|
||||
and $Ahi,$Ahi,$t2
|
||||
orr $Ahi,$Ahi,$t3 @ Maj(a,b,c).hi
|
||||
adds $Alo,$Alo,$Tlo
|
||||
adc $Ahi,$Ahi,$Thi @ h += T
|
||||
|
||||
orr $Ahi,$Ahi,$t3 @ Maj(a,b,c).hi
|
||||
sub sp,sp,#8
|
||||
adc $Ahi,$Ahi,$Thi @ h += T
|
||||
tst $Ktbl,#1
|
||||
add $Ktbl,$Ktbl,#8
|
||||
___
|
||||
}
|
||||
$code=<<___;
|
||||
#include "arm_arch.h"
|
||||
#ifdef __ARMEL__
|
||||
# define LO 0
|
||||
# define HI 4
|
||||
# define WORD64(hi0,lo0,hi1,lo1) .word lo0,hi0, lo1,hi1
|
||||
#else
|
||||
# define HI 0
|
||||
# define LO 4
|
||||
# define WORD64(hi0,lo0,hi1,lo1) .word hi0,lo0, hi1,lo1
|
||||
#endif
|
||||
|
||||
.text
|
||||
.code 32
|
||||
.type K512,%object
|
||||
.align 5
|
||||
K512:
|
||||
.word 0x428a2f98,0xd728ae22, 0x71374491,0x23ef65cd
|
||||
.word 0xb5c0fbcf,0xec4d3b2f, 0xe9b5dba5,0x8189dbbc
|
||||
.word 0x3956c25b,0xf348b538, 0x59f111f1,0xb605d019
|
||||
.word 0x923f82a4,0xaf194f9b, 0xab1c5ed5,0xda6d8118
|
||||
.word 0xd807aa98,0xa3030242, 0x12835b01,0x45706fbe
|
||||
.word 0x243185be,0x4ee4b28c, 0x550c7dc3,0xd5ffb4e2
|
||||
.word 0x72be5d74,0xf27b896f, 0x80deb1fe,0x3b1696b1
|
||||
.word 0x9bdc06a7,0x25c71235, 0xc19bf174,0xcf692694
|
||||
.word 0xe49b69c1,0x9ef14ad2, 0xefbe4786,0x384f25e3
|
||||
.word 0x0fc19dc6,0x8b8cd5b5, 0x240ca1cc,0x77ac9c65
|
||||
.word 0x2de92c6f,0x592b0275, 0x4a7484aa,0x6ea6e483
|
||||
.word 0x5cb0a9dc,0xbd41fbd4, 0x76f988da,0x831153b5
|
||||
.word 0x983e5152,0xee66dfab, 0xa831c66d,0x2db43210
|
||||
.word 0xb00327c8,0x98fb213f, 0xbf597fc7,0xbeef0ee4
|
||||
.word 0xc6e00bf3,0x3da88fc2, 0xd5a79147,0x930aa725
|
||||
.word 0x06ca6351,0xe003826f, 0x14292967,0x0a0e6e70
|
||||
.word 0x27b70a85,0x46d22ffc, 0x2e1b2138,0x5c26c926
|
||||
.word 0x4d2c6dfc,0x5ac42aed, 0x53380d13,0x9d95b3df
|
||||
.word 0x650a7354,0x8baf63de, 0x766a0abb,0x3c77b2a8
|
||||
.word 0x81c2c92e,0x47edaee6, 0x92722c85,0x1482353b
|
||||
.word 0xa2bfe8a1,0x4cf10364, 0xa81a664b,0xbc423001
|
||||
.word 0xc24b8b70,0xd0f89791, 0xc76c51a3,0x0654be30
|
||||
.word 0xd192e819,0xd6ef5218, 0xd6990624,0x5565a910
|
||||
.word 0xf40e3585,0x5771202a, 0x106aa070,0x32bbd1b8
|
||||
.word 0x19a4c116,0xb8d2d0c8, 0x1e376c08,0x5141ab53
|
||||
.word 0x2748774c,0xdf8eeb99, 0x34b0bcb5,0xe19b48a8
|
||||
.word 0x391c0cb3,0xc5c95a63, 0x4ed8aa4a,0xe3418acb
|
||||
.word 0x5b9cca4f,0x7763e373, 0x682e6ff3,0xd6b2b8a3
|
||||
.word 0x748f82ee,0x5defb2fc, 0x78a5636f,0x43172f60
|
||||
.word 0x84c87814,0xa1f0ab72, 0x8cc70208,0x1a6439ec
|
||||
.word 0x90befffa,0x23631e28, 0xa4506ceb,0xde82bde9
|
||||
.word 0xbef9a3f7,0xb2c67915, 0xc67178f2,0xe372532b
|
||||
.word 0xca273ece,0xea26619c, 0xd186b8c7,0x21c0c207
|
||||
.word 0xeada7dd6,0xcde0eb1e, 0xf57d4f7f,0xee6ed178
|
||||
.word 0x06f067aa,0x72176fba, 0x0a637dc5,0xa2c898a6
|
||||
.word 0x113f9804,0xbef90dae, 0x1b710b35,0x131c471b
|
||||
.word 0x28db77f5,0x23047d84, 0x32caab7b,0x40c72493
|
||||
.word 0x3c9ebe0a,0x15c9bebc, 0x431d67c4,0x9c100d4c
|
||||
.word 0x4cc5d4be,0xcb3e42b6, 0x597f299c,0xfc657e2a
|
||||
.word 0x5fcb6fab,0x3ad6faec, 0x6c44198c,0x4a475817
|
||||
WORD64(0x428a2f98,0xd728ae22, 0x71374491,0x23ef65cd)
|
||||
WORD64(0xb5c0fbcf,0xec4d3b2f, 0xe9b5dba5,0x8189dbbc)
|
||||
WORD64(0x3956c25b,0xf348b538, 0x59f111f1,0xb605d019)
|
||||
WORD64(0x923f82a4,0xaf194f9b, 0xab1c5ed5,0xda6d8118)
|
||||
WORD64(0xd807aa98,0xa3030242, 0x12835b01,0x45706fbe)
|
||||
WORD64(0x243185be,0x4ee4b28c, 0x550c7dc3,0xd5ffb4e2)
|
||||
WORD64(0x72be5d74,0xf27b896f, 0x80deb1fe,0x3b1696b1)
|
||||
WORD64(0x9bdc06a7,0x25c71235, 0xc19bf174,0xcf692694)
|
||||
WORD64(0xe49b69c1,0x9ef14ad2, 0xefbe4786,0x384f25e3)
|
||||
WORD64(0x0fc19dc6,0x8b8cd5b5, 0x240ca1cc,0x77ac9c65)
|
||||
WORD64(0x2de92c6f,0x592b0275, 0x4a7484aa,0x6ea6e483)
|
||||
WORD64(0x5cb0a9dc,0xbd41fbd4, 0x76f988da,0x831153b5)
|
||||
WORD64(0x983e5152,0xee66dfab, 0xa831c66d,0x2db43210)
|
||||
WORD64(0xb00327c8,0x98fb213f, 0xbf597fc7,0xbeef0ee4)
|
||||
WORD64(0xc6e00bf3,0x3da88fc2, 0xd5a79147,0x930aa725)
|
||||
WORD64(0x06ca6351,0xe003826f, 0x14292967,0x0a0e6e70)
|
||||
WORD64(0x27b70a85,0x46d22ffc, 0x2e1b2138,0x5c26c926)
|
||||
WORD64(0x4d2c6dfc,0x5ac42aed, 0x53380d13,0x9d95b3df)
|
||||
WORD64(0x650a7354,0x8baf63de, 0x766a0abb,0x3c77b2a8)
|
||||
WORD64(0x81c2c92e,0x47edaee6, 0x92722c85,0x1482353b)
|
||||
WORD64(0xa2bfe8a1,0x4cf10364, 0xa81a664b,0xbc423001)
|
||||
WORD64(0xc24b8b70,0xd0f89791, 0xc76c51a3,0x0654be30)
|
||||
WORD64(0xd192e819,0xd6ef5218, 0xd6990624,0x5565a910)
|
||||
WORD64(0xf40e3585,0x5771202a, 0x106aa070,0x32bbd1b8)
|
||||
WORD64(0x19a4c116,0xb8d2d0c8, 0x1e376c08,0x5141ab53)
|
||||
WORD64(0x2748774c,0xdf8eeb99, 0x34b0bcb5,0xe19b48a8)
|
||||
WORD64(0x391c0cb3,0xc5c95a63, 0x4ed8aa4a,0xe3418acb)
|
||||
WORD64(0x5b9cca4f,0x7763e373, 0x682e6ff3,0xd6b2b8a3)
|
||||
WORD64(0x748f82ee,0x5defb2fc, 0x78a5636f,0x43172f60)
|
||||
WORD64(0x84c87814,0xa1f0ab72, 0x8cc70208,0x1a6439ec)
|
||||
WORD64(0x90befffa,0x23631e28, 0xa4506ceb,0xde82bde9)
|
||||
WORD64(0xbef9a3f7,0xb2c67915, 0xc67178f2,0xe372532b)
|
||||
WORD64(0xca273ece,0xea26619c, 0xd186b8c7,0x21c0c207)
|
||||
WORD64(0xeada7dd6,0xcde0eb1e, 0xf57d4f7f,0xee6ed178)
|
||||
WORD64(0x06f067aa,0x72176fba, 0x0a637dc5,0xa2c898a6)
|
||||
WORD64(0x113f9804,0xbef90dae, 0x1b710b35,0x131c471b)
|
||||
WORD64(0x28db77f5,0x23047d84, 0x32caab7b,0x40c72493)
|
||||
WORD64(0x3c9ebe0a,0x15c9bebc, 0x431d67c4,0x9c100d4c)
|
||||
WORD64(0x4cc5d4be,0xcb3e42b6, 0x597f299c,0xfc657e2a)
|
||||
WORD64(0x5fcb6fab,0x3ad6faec, 0x6c44198c,0x4a475817)
|
||||
.size K512,.-K512
|
||||
#if __ARM_MAX_ARCH__>=7
|
||||
.LOPENSSL_armcap:
|
||||
.word OPENSSL_armcap_P-sha512_block_data_order
|
||||
.skip 32-4
|
||||
#else
|
||||
.skip 32
|
||||
#endif
|
||||
|
||||
.global sha512_block_data_order
|
||||
.type sha512_block_data_order,%function
|
||||
sha512_block_data_order:
|
||||
sub r3,pc,#8 @ sha512_block_data_order
|
||||
add $len,$inp,$len,lsl#7 @ len to point at the end of inp
|
||||
#if __ARM_MAX_ARCH__>=7
|
||||
ldr r12,.LOPENSSL_armcap
|
||||
ldr r12,[r3,r12] @ OPENSSL_armcap_P
|
||||
tst r12,#1
|
||||
bne .LNEON
|
||||
#endif
|
||||
stmdb sp!,{r4-r12,lr}
|
||||
sub $Ktbl,r3,#640 @ K512
|
||||
sub $Ktbl,r3,#672 @ K512
|
||||
sub sp,sp,#9*8
|
||||
|
||||
ldr $Elo,[$ctx,#$Eoff+$lo]
|
||||
@@ -238,6 +291,7 @@ sha512_block_data_order:
|
||||
str $Thi,[sp,#$Foff+4]
|
||||
|
||||
.L00_15:
|
||||
#if __ARM_ARCH__<7
|
||||
ldrb $Tlo,[$inp,#7]
|
||||
ldrb $t0, [$inp,#6]
|
||||
ldrb $t1, [$inp,#5]
|
||||
@@ -252,26 +306,30 @@ sha512_block_data_order:
|
||||
orr $Thi,$Thi,$t3,lsl#8
|
||||
orr $Thi,$Thi,$t0,lsl#16
|
||||
orr $Thi,$Thi,$t1,lsl#24
|
||||
str $Tlo,[sp,#$Xoff+0]
|
||||
str $Thi,[sp,#$Xoff+4]
|
||||
#else
|
||||
ldr $Tlo,[$inp,#4]
|
||||
ldr $Thi,[$inp],#8
|
||||
#ifdef __ARMEL__
|
||||
rev $Tlo,$Tlo
|
||||
rev $Thi,$Thi
|
||||
#endif
|
||||
#endif
|
||||
___
|
||||
&BODY_00_15(0x94);
|
||||
$code.=<<___;
|
||||
tst $Ktbl,#1
|
||||
beq .L00_15
|
||||
bic $Ktbl,$Ktbl,#1
|
||||
|
||||
.L16_79:
|
||||
ldr $t0,[sp,#`$Xoff+8*(16-1)`+0]
|
||||
ldr $t1,[sp,#`$Xoff+8*(16-1)`+4]
|
||||
ldr $t2,[sp,#`$Xoff+8*(16-14)`+0]
|
||||
ldr $t3,[sp,#`$Xoff+8*(16-14)`+4]
|
||||
|
||||
bic $Ktbl,$Ktbl,#1
|
||||
.L16_79:
|
||||
@ sigma0(x) (ROTR((x),1) ^ ROTR((x),8) ^ ((x)>>7))
|
||||
@ LO lo>>1^hi<<31 ^ lo>>8^hi<<24 ^ lo>>7^hi<<25
|
||||
@ HI hi>>1^lo<<31 ^ hi>>8^lo<<24 ^ hi>>7
|
||||
mov $Tlo,$t0,lsr#1
|
||||
ldr $t2,[sp,#`$Xoff+8*(16-14)`+0]
|
||||
mov $Thi,$t1,lsr#1
|
||||
ldr $t3,[sp,#`$Xoff+8*(16-14)`+4]
|
||||
eor $Tlo,$Tlo,$t1,lsl#31
|
||||
eor $Thi,$Thi,$t0,lsl#31
|
||||
eor $Tlo,$Tlo,$t0,lsr#8
|
||||
@@ -295,25 +353,24 @@ $code.=<<___;
|
||||
eor $t1,$t1,$t3,lsl#3
|
||||
eor $t0,$t0,$t2,lsr#6
|
||||
eor $t1,$t1,$t3,lsr#6
|
||||
ldr $t2,[sp,#`$Xoff+8*(16-9)`+0]
|
||||
eor $t0,$t0,$t3,lsl#26
|
||||
|
||||
ldr $t2,[sp,#`$Xoff+8*(16-9)`+0]
|
||||
ldr $t3,[sp,#`$Xoff+8*(16-9)`+4]
|
||||
adds $Tlo,$Tlo,$t0
|
||||
ldr $t0,[sp,#`$Xoff+8*16`+0]
|
||||
adc $Thi,$Thi,$t1
|
||||
|
||||
ldr $t0,[sp,#`$Xoff+8*16`+0]
|
||||
ldr $t1,[sp,#`$Xoff+8*16`+4]
|
||||
adds $Tlo,$Tlo,$t2
|
||||
adc $Thi,$Thi,$t3
|
||||
adds $Tlo,$Tlo,$t0
|
||||
adc $Thi,$Thi,$t1
|
||||
str $Tlo,[sp,#$Xoff+0]
|
||||
str $Thi,[sp,#$Xoff+4]
|
||||
___
|
||||
&BODY_00_15(0x17);
|
||||
$code.=<<___;
|
||||
tst $Ktbl,#1
|
||||
ldreq $t0,[sp,#`$Xoff+8*(16-1)`+0]
|
||||
ldreq $t1,[sp,#`$Xoff+8*(16-1)`+4]
|
||||
beq .L16_79
|
||||
bic $Ktbl,$Ktbl,#1
|
||||
|
||||
@@ -324,12 +381,12 @@ $code.=<<___;
|
||||
ldr $t2, [$ctx,#$Boff+$lo]
|
||||
ldr $t3, [$ctx,#$Boff+$hi]
|
||||
adds $t0,$Alo,$t0
|
||||
adc $t1,$Ahi,$t1
|
||||
adds $t2,$Tlo,$t2
|
||||
adc $t3,$Thi,$t3
|
||||
str $t0, [$ctx,#$Aoff+$lo]
|
||||
adc $t1,$Ahi,$t1
|
||||
str $t1, [$ctx,#$Aoff+$hi]
|
||||
adds $t2,$Tlo,$t2
|
||||
str $t2, [$ctx,#$Boff+$lo]
|
||||
adc $t3,$Thi,$t3
|
||||
str $t3, [$ctx,#$Boff+$hi]
|
||||
|
||||
ldr $Alo,[sp,#$Coff+0]
|
||||
@@ -341,12 +398,12 @@ $code.=<<___;
|
||||
ldr $t2, [$ctx,#$Doff+$lo]
|
||||
ldr $t3, [$ctx,#$Doff+$hi]
|
||||
adds $t0,$Alo,$t0
|
||||
adc $t1,$Ahi,$t1
|
||||
adds $t2,$Tlo,$t2
|
||||
adc $t3,$Thi,$t3
|
||||
str $t0, [$ctx,#$Coff+$lo]
|
||||
adc $t1,$Ahi,$t1
|
||||
str $t1, [$ctx,#$Coff+$hi]
|
||||
adds $t2,$Tlo,$t2
|
||||
str $t2, [$ctx,#$Doff+$lo]
|
||||
adc $t3,$Thi,$t3
|
||||
str $t3, [$ctx,#$Doff+$hi]
|
||||
|
||||
ldr $Tlo,[sp,#$Foff+0]
|
||||
@@ -356,12 +413,12 @@ $code.=<<___;
|
||||
ldr $t2, [$ctx,#$Foff+$lo]
|
||||
ldr $t3, [$ctx,#$Foff+$hi]
|
||||
adds $Elo,$Elo,$t0
|
||||
adc $Ehi,$Ehi,$t1
|
||||
adds $t2,$Tlo,$t2
|
||||
adc $t3,$Thi,$t3
|
||||
str $Elo,[$ctx,#$Eoff+$lo]
|
||||
adc $Ehi,$Ehi,$t1
|
||||
str $Ehi,[$ctx,#$Eoff+$hi]
|
||||
adds $t2,$Tlo,$t2
|
||||
str $t2, [$ctx,#$Foff+$lo]
|
||||
adc $t3,$Thi,$t3
|
||||
str $t3, [$ctx,#$Foff+$hi]
|
||||
|
||||
ldr $Alo,[sp,#$Goff+0]
|
||||
@@ -373,12 +430,12 @@ $code.=<<___;
|
||||
ldr $t2, [$ctx,#$Hoff+$lo]
|
||||
ldr $t3, [$ctx,#$Hoff+$hi]
|
||||
adds $t0,$Alo,$t0
|
||||
adc $t1,$Ahi,$t1
|
||||
adds $t2,$Tlo,$t2
|
||||
adc $t3,$Thi,$t3
|
||||
str $t0, [$ctx,#$Goff+$lo]
|
||||
adc $t1,$Ahi,$t1
|
||||
str $t1, [$ctx,#$Goff+$hi]
|
||||
adds $t2,$Tlo,$t2
|
||||
str $t2, [$ctx,#$Hoff+$lo]
|
||||
adc $t3,$Thi,$t3
|
||||
str $t3, [$ctx,#$Hoff+$hi]
|
||||
|
||||
add sp,sp,#640
|
||||
@@ -388,16 +445,165 @@ $code.=<<___;
|
||||
bne .Loop
|
||||
|
||||
add sp,sp,#8*9 @ destroy frame
|
||||
#if __ARM_ARCH__>=5
|
||||
ldmia sp!,{r4-r12,pc}
|
||||
#else
|
||||
ldmia sp!,{r4-r12,lr}
|
||||
tst lr,#1
|
||||
moveq pc,lr @ be binary compatible with V4, yet
|
||||
bx lr @ interoperable with Thumb ISA:-)
|
||||
.size sha512_block_data_order,.-sha512_block_data_order
|
||||
.asciz "SHA512 block transform for ARMv4, CRYPTOGAMS by <appro\@openssl.org>"
|
||||
#endif
|
||||
___
|
||||
|
||||
{
|
||||
my @Sigma0=(28,34,39);
|
||||
my @Sigma1=(14,18,41);
|
||||
my @sigma0=(1, 8, 7);
|
||||
my @sigma1=(19,61,6);
|
||||
|
||||
my $Ktbl="r3";
|
||||
my $cnt="r12"; # volatile register known as ip, intra-procedure-call scratch
|
||||
|
||||
my @X=map("d$_",(0..15));
|
||||
my @V=($A,$B,$C,$D,$E,$F,$G,$H)=map("d$_",(16..23));
|
||||
|
||||
sub NEON_00_15() {
|
||||
my $i=shift;
|
||||
my ($a,$b,$c,$d,$e,$f,$g,$h)=@_;
|
||||
my ($t0,$t1,$t2,$T1,$K,$Ch,$Maj)=map("d$_",(24..31)); # temps
|
||||
|
||||
$code.=<<___ if ($i<16 || $i&1);
|
||||
vshr.u64 $t0,$e,#@Sigma1[0] @ $i
|
||||
#if $i<16
|
||||
vld1.64 {@X[$i%16]},[$inp]! @ handles unaligned
|
||||
#endif
|
||||
vshr.u64 $t1,$e,#@Sigma1[1]
|
||||
#if $i>0
|
||||
vadd.i64 $a,$Maj @ h+=Maj from the past
|
||||
#endif
|
||||
vshr.u64 $t2,$e,#@Sigma1[2]
|
||||
___
|
||||
$code.=<<___;
|
||||
vld1.64 {$K},[$Ktbl,:64]! @ K[i++]
|
||||
vsli.64 $t0,$e,#`64-@Sigma1[0]`
|
||||
vsli.64 $t1,$e,#`64-@Sigma1[1]`
|
||||
vmov $Ch,$e
|
||||
vsli.64 $t2,$e,#`64-@Sigma1[2]`
|
||||
#if $i<16 && defined(__ARMEL__)
|
||||
vrev64.8 @X[$i],@X[$i]
|
||||
#endif
|
||||
veor $t1,$t0
|
||||
vbsl $Ch,$f,$g @ Ch(e,f,g)
|
||||
vshr.u64 $t0,$a,#@Sigma0[0]
|
||||
veor $t2,$t1 @ Sigma1(e)
|
||||
vadd.i64 $T1,$Ch,$h
|
||||
vshr.u64 $t1,$a,#@Sigma0[1]
|
||||
vsli.64 $t0,$a,#`64-@Sigma0[0]`
|
||||
vadd.i64 $T1,$t2
|
||||
vshr.u64 $t2,$a,#@Sigma0[2]
|
||||
vadd.i64 $K,@X[$i%16]
|
||||
vsli.64 $t1,$a,#`64-@Sigma0[1]`
|
||||
veor $Maj,$a,$b
|
||||
vsli.64 $t2,$a,#`64-@Sigma0[2]`
|
||||
veor $h,$t0,$t1
|
||||
vadd.i64 $T1,$K
|
||||
vbsl $Maj,$c,$b @ Maj(a,b,c)
|
||||
veor $h,$t2 @ Sigma0(a)
|
||||
vadd.i64 $d,$T1
|
||||
vadd.i64 $Maj,$T1
|
||||
@ vadd.i64 $h,$Maj
|
||||
___
|
||||
}
|
||||
|
||||
sub NEON_16_79() {
|
||||
my $i=shift;
|
||||
|
||||
if ($i&1) { &NEON_00_15($i,@_); return; }
|
||||
|
||||
# 2x-vectorized, therefore runs every 2nd round
|
||||
my @X=map("q$_",(0..7)); # view @X as 128-bit vector
|
||||
my ($t0,$t1,$s0,$s1) = map("q$_",(12..15)); # temps
|
||||
my ($d0,$d1,$d2) = map("d$_",(24..26)); # temps from NEON_00_15
|
||||
my $e=@_[4]; # $e from NEON_00_15
|
||||
$i /= 2;
|
||||
$code.=<<___;
|
||||
vshr.u64 $t0,@X[($i+7)%8],#@sigma1[0]
|
||||
vshr.u64 $t1,@X[($i+7)%8],#@sigma1[1]
|
||||
vadd.i64 @_[0],d30 @ h+=Maj from the past
|
||||
vshr.u64 $s1,@X[($i+7)%8],#@sigma1[2]
|
||||
vsli.64 $t0,@X[($i+7)%8],#`64-@sigma1[0]`
|
||||
vext.8 $s0,@X[$i%8],@X[($i+1)%8],#8 @ X[i+1]
|
||||
vsli.64 $t1,@X[($i+7)%8],#`64-@sigma1[1]`
|
||||
veor $s1,$t0
|
||||
vshr.u64 $t0,$s0,#@sigma0[0]
|
||||
veor $s1,$t1 @ sigma1(X[i+14])
|
||||
vshr.u64 $t1,$s0,#@sigma0[1]
|
||||
vadd.i64 @X[$i%8],$s1
|
||||
vshr.u64 $s1,$s0,#@sigma0[2]
|
||||
vsli.64 $t0,$s0,#`64-@sigma0[0]`
|
||||
vsli.64 $t1,$s0,#`64-@sigma0[1]`
|
||||
vext.8 $s0,@X[($i+4)%8],@X[($i+5)%8],#8 @ X[i+9]
|
||||
veor $s1,$t0
|
||||
vshr.u64 $d0,$e,#@Sigma1[0] @ from NEON_00_15
|
||||
vadd.i64 @X[$i%8],$s0
|
||||
vshr.u64 $d1,$e,#@Sigma1[1] @ from NEON_00_15
|
||||
veor $s1,$t1 @ sigma0(X[i+1])
|
||||
vshr.u64 $d2,$e,#@Sigma1[2] @ from NEON_00_15
|
||||
vadd.i64 @X[$i%8],$s1
|
||||
___
|
||||
&NEON_00_15(2*$i,@_);
|
||||
}
|
||||
|
||||
$code.=<<___;
|
||||
#if __ARM_MAX_ARCH__>=7
|
||||
.arch armv7-a
|
||||
.fpu neon
|
||||
|
||||
.align 4
|
||||
.LNEON:
|
||||
dmb @ errata #451034 on early Cortex A8
|
||||
vstmdb sp!,{d8-d15} @ ABI specification says so
|
||||
sub $Ktbl,r3,#672 @ K512
|
||||
vldmia $ctx,{$A-$H} @ load context
|
||||
.Loop_neon:
|
||||
___
|
||||
for($i=0;$i<16;$i++) { &NEON_00_15($i,@V); unshift(@V,pop(@V)); }
|
||||
$code.=<<___;
|
||||
mov $cnt,#4
|
||||
.L16_79_neon:
|
||||
subs $cnt,#1
|
||||
___
|
||||
for(;$i<32;$i++) { &NEON_16_79($i,@V); unshift(@V,pop(@V)); }
|
||||
$code.=<<___;
|
||||
bne .L16_79_neon
|
||||
|
||||
vadd.i64 $A,d30 @ h+=Maj from the past
|
||||
vldmia $ctx,{d24-d31} @ load context to temp
|
||||
vadd.i64 q8,q12 @ vectorized accumulate
|
||||
vadd.i64 q9,q13
|
||||
vadd.i64 q10,q14
|
||||
vadd.i64 q11,q15
|
||||
vstmia $ctx,{$A-$H} @ save context
|
||||
teq $inp,$len
|
||||
sub $Ktbl,#640 @ rewind K512
|
||||
bne .Loop_neon
|
||||
|
||||
vldmia sp!,{d8-d15} @ epilogue
|
||||
ret @ bx lr
|
||||
#endif
|
||||
___
|
||||
}
|
||||
$code.=<<___;
|
||||
.size sha512_block_data_order,.-sha512_block_data_order
|
||||
.asciz "SHA512 block transform for ARMv4/NEON, CRYPTOGAMS by <appro\@openssl.org>"
|
||||
.align 2
|
||||
#if __ARM_MAX_ARCH__>=7
|
||||
.comm OPENSSL_armcap_P,4,4
|
||||
#endif
|
||||
___
|
||||
|
||||
$code =~ s/\`([^\`]*)\`/eval $1/gem;
|
||||
$code =~ s/\bbx\s+lr\b/.word\t0xe12fff1e/gm; # make it possible to compile with -march=armv4
|
||||
$code =~ s/\bret\b/bx lr/gm;
|
||||
print $code;
|
||||
close STDOUT; # enforce flush
|
||||
|
||||
422
crypto/sha/asm/sha512-armv8.pl
Normal file
422
crypto/sha/asm/sha512-armv8.pl
Normal file
@@ -0,0 +1,422 @@
|
||||
#!/usr/bin/env perl
|
||||
#
|
||||
# ====================================================================
|
||||
# Written by Andy Polyakov <appro@openssl.org> 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/.
|
||||
# ====================================================================
|
||||
#
|
||||
# SHA256/512 for ARMv8.
|
||||
#
|
||||
# Performance in cycles per processed byte and improvement coefficient
|
||||
# over code generated with "default" compiler:
|
||||
#
|
||||
# SHA256-hw SHA256(*) SHA512
|
||||
# Apple A7 1.97 10.5 (+33%) 6.73 (-1%(**))
|
||||
# Cortex-A53 2.38 15.5 (+115%) 10.0 (+150%(***))
|
||||
# Cortex-A57 2.31 11.6 (+86%) 7.51 (+260%(***))
|
||||
# Denver 2.01 10.5 (+26%) 6.70 (+8%)
|
||||
# X-Gene 20.0 (+100%) 12.8 (+300%(***))
|
||||
#
|
||||
# (*) Software SHA256 results are of lesser relevance, presented
|
||||
# mostly for informational purposes.
|
||||
# (**) The result is a trade-off: it's possible to improve it by
|
||||
# 10% (or by 1 cycle per round), but at the cost of 20% loss
|
||||
# on Cortex-A53 (or by 4 cycles per round).
|
||||
# (***) Super-impressive coefficients over gcc-generated code are
|
||||
# indication of some compiler "pathology", most notably code
|
||||
# generated with -mgeneral-regs-only is significanty faster
|
||||
# and the gap is only 40-90%.
|
||||
|
||||
$flavour=shift;
|
||||
$output=shift;
|
||||
open STDOUT,">$output";
|
||||
|
||||
if ($output =~ /512/) {
|
||||
$BITS=512;
|
||||
$SZ=8;
|
||||
@Sigma0=(28,34,39);
|
||||
@Sigma1=(14,18,41);
|
||||
@sigma0=(1, 8, 7);
|
||||
@sigma1=(19,61, 6);
|
||||
$rounds=80;
|
||||
$reg_t="x";
|
||||
} else {
|
||||
$BITS=256;
|
||||
$SZ=4;
|
||||
@Sigma0=( 2,13,22);
|
||||
@Sigma1=( 6,11,25);
|
||||
@sigma0=( 7,18, 3);
|
||||
@sigma1=(17,19,10);
|
||||
$rounds=64;
|
||||
$reg_t="w";
|
||||
}
|
||||
|
||||
$func="sha${BITS}_block_data_order";
|
||||
|
||||
($ctx,$inp,$num,$Ktbl)=map("x$_",(0..2,30));
|
||||
|
||||
@X=map("$reg_t$_",(3..15,0..2));
|
||||
@V=($A,$B,$C,$D,$E,$F,$G,$H)=map("$reg_t$_",(20..27));
|
||||
($t0,$t1,$t2,$t3)=map("$reg_t$_",(16,17,19,28));
|
||||
|
||||
sub BODY_00_xx {
|
||||
my ($i,$a,$b,$c,$d,$e,$f,$g,$h)=@_;
|
||||
my $j=($i+1)&15;
|
||||
my ($T0,$T1,$T2)=(@X[($i-8)&15],@X[($i-9)&15],@X[($i-10)&15]);
|
||||
$T0=@X[$i+3] if ($i<11);
|
||||
|
||||
$code.=<<___ if ($i<16);
|
||||
#ifndef __ARMEB__
|
||||
rev @X[$i],@X[$i] // $i
|
||||
#endif
|
||||
___
|
||||
$code.=<<___ if ($i<13 && ($i&1));
|
||||
ldp @X[$i+1],@X[$i+2],[$inp],#2*$SZ
|
||||
___
|
||||
$code.=<<___ if ($i==13);
|
||||
ldp @X[14],@X[15],[$inp]
|
||||
___
|
||||
$code.=<<___ if ($i>=14);
|
||||
ldr @X[($i-11)&15],[sp,#`$SZ*(($i-11)%4)`]
|
||||
___
|
||||
$code.=<<___ if ($i>0 && $i<16);
|
||||
add $a,$a,$t1 // h+=Sigma0(a)
|
||||
___
|
||||
$code.=<<___ if ($i>=11);
|
||||
str @X[($i-8)&15],[sp,#`$SZ*(($i-8)%4)`]
|
||||
___
|
||||
# While ARMv8 specifies merged rotate-n-logical operation such as
|
||||
# 'eor x,y,z,ror#n', it was found to negatively affect performance
|
||||
# on Apple A7. The reason seems to be that it requires even 'y' to
|
||||
# be available earlier. This means that such merged instruction is
|
||||
# not necessarily best choice on critical path... On the other hand
|
||||
# Cortex-A5x handles merged instructions much better than disjoint
|
||||
# rotate and logical... See (**) footnote above.
|
||||
$code.=<<___ if ($i<15);
|
||||
ror $t0,$e,#$Sigma1[0]
|
||||
add $h,$h,$t2 // h+=K[i]
|
||||
eor $T0,$e,$e,ror#`$Sigma1[2]-$Sigma1[1]`
|
||||
and $t1,$f,$e
|
||||
bic $t2,$g,$e
|
||||
add $h,$h,@X[$i&15] // h+=X[i]
|
||||
orr $t1,$t1,$t2 // Ch(e,f,g)
|
||||
eor $t2,$a,$b // a^b, b^c in next round
|
||||
eor $t0,$t0,$T0,ror#$Sigma1[1] // Sigma1(e)
|
||||
ror $T0,$a,#$Sigma0[0]
|
||||
add $h,$h,$t1 // h+=Ch(e,f,g)
|
||||
eor $t1,$a,$a,ror#`$Sigma0[2]-$Sigma0[1]`
|
||||
add $h,$h,$t0 // h+=Sigma1(e)
|
||||
and $t3,$t3,$t2 // (b^c)&=(a^b)
|
||||
add $d,$d,$h // d+=h
|
||||
eor $t3,$t3,$b // Maj(a,b,c)
|
||||
eor $t1,$T0,$t1,ror#$Sigma0[1] // Sigma0(a)
|
||||
add $h,$h,$t3 // h+=Maj(a,b,c)
|
||||
ldr $t3,[$Ktbl],#$SZ // *K++, $t2 in next round
|
||||
//add $h,$h,$t1 // h+=Sigma0(a)
|
||||
___
|
||||
$code.=<<___ if ($i>=15);
|
||||
ror $t0,$e,#$Sigma1[0]
|
||||
add $h,$h,$t2 // h+=K[i]
|
||||
ror $T1,@X[($j+1)&15],#$sigma0[0]
|
||||
and $t1,$f,$e
|
||||
ror $T2,@X[($j+14)&15],#$sigma1[0]
|
||||
bic $t2,$g,$e
|
||||
ror $T0,$a,#$Sigma0[0]
|
||||
add $h,$h,@X[$i&15] // h+=X[i]
|
||||
eor $t0,$t0,$e,ror#$Sigma1[1]
|
||||
eor $T1,$T1,@X[($j+1)&15],ror#$sigma0[1]
|
||||
orr $t1,$t1,$t2 // Ch(e,f,g)
|
||||
eor $t2,$a,$b // a^b, b^c in next round
|
||||
eor $t0,$t0,$e,ror#$Sigma1[2] // Sigma1(e)
|
||||
eor $T0,$T0,$a,ror#$Sigma0[1]
|
||||
add $h,$h,$t1 // h+=Ch(e,f,g)
|
||||
and $t3,$t3,$t2 // (b^c)&=(a^b)
|
||||
eor $T2,$T2,@X[($j+14)&15],ror#$sigma1[1]
|
||||
eor $T1,$T1,@X[($j+1)&15],lsr#$sigma0[2] // sigma0(X[i+1])
|
||||
add $h,$h,$t0 // h+=Sigma1(e)
|
||||
eor $t3,$t3,$b // Maj(a,b,c)
|
||||
eor $t1,$T0,$a,ror#$Sigma0[2] // Sigma0(a)
|
||||
eor $T2,$T2,@X[($j+14)&15],lsr#$sigma1[2] // sigma1(X[i+14])
|
||||
add @X[$j],@X[$j],@X[($j+9)&15]
|
||||
add $d,$d,$h // d+=h
|
||||
add $h,$h,$t3 // h+=Maj(a,b,c)
|
||||
ldr $t3,[$Ktbl],#$SZ // *K++, $t2 in next round
|
||||
add @X[$j],@X[$j],$T1
|
||||
add $h,$h,$t1 // h+=Sigma0(a)
|
||||
add @X[$j],@X[$j],$T2
|
||||
___
|
||||
($t2,$t3)=($t3,$t2);
|
||||
}
|
||||
|
||||
$code.=<<___;
|
||||
#include "arm_arch.h"
|
||||
|
||||
.text
|
||||
|
||||
.globl $func
|
||||
.type $func,%function
|
||||
.align 6
|
||||
$func:
|
||||
___
|
||||
$code.=<<___ if ($SZ==4);
|
||||
ldr x16,.LOPENSSL_armcap_P
|
||||
adr x17,.LOPENSSL_armcap_P
|
||||
add x16,x16,x17
|
||||
ldr w16,[x16]
|
||||
tst w16,#ARMV8_SHA256
|
||||
b.ne .Lv8_entry
|
||||
___
|
||||
$code.=<<___;
|
||||
stp x29,x30,[sp,#-128]!
|
||||
add x29,sp,#0
|
||||
|
||||
stp x19,x20,[sp,#16]
|
||||
stp x21,x22,[sp,#32]
|
||||
stp x23,x24,[sp,#48]
|
||||
stp x25,x26,[sp,#64]
|
||||
stp x27,x28,[sp,#80]
|
||||
sub sp,sp,#4*$SZ
|
||||
|
||||
ldp $A,$B,[$ctx] // load context
|
||||
ldp $C,$D,[$ctx,#2*$SZ]
|
||||
ldp $E,$F,[$ctx,#4*$SZ]
|
||||
add $num,$inp,$num,lsl#`log(16*$SZ)/log(2)` // end of input
|
||||
ldp $G,$H,[$ctx,#6*$SZ]
|
||||
adr $Ktbl,K$BITS
|
||||
stp $ctx,$num,[x29,#96]
|
||||
|
||||
.Loop:
|
||||
ldp @X[0],@X[1],[$inp],#2*$SZ
|
||||
ldr $t2,[$Ktbl],#$SZ // *K++
|
||||
eor $t3,$B,$C // magic seed
|
||||
str $inp,[x29,#112]
|
||||
___
|
||||
for ($i=0;$i<16;$i++) { &BODY_00_xx($i,@V); unshift(@V,pop(@V)); }
|
||||
$code.=".Loop_16_xx:\n";
|
||||
for (;$i<32;$i++) { &BODY_00_xx($i,@V); unshift(@V,pop(@V)); }
|
||||
$code.=<<___;
|
||||
cbnz $t2,.Loop_16_xx
|
||||
|
||||
ldp $ctx,$num,[x29,#96]
|
||||
ldr $inp,[x29,#112]
|
||||
sub $Ktbl,$Ktbl,#`$SZ*($rounds+1)` // rewind
|
||||
|
||||
ldp @X[0],@X[1],[$ctx]
|
||||
ldp @X[2],@X[3],[$ctx,#2*$SZ]
|
||||
add $inp,$inp,#14*$SZ // advance input pointer
|
||||
ldp @X[4],@X[5],[$ctx,#4*$SZ]
|
||||
add $A,$A,@X[0]
|
||||
ldp @X[6],@X[7],[$ctx,#6*$SZ]
|
||||
add $B,$B,@X[1]
|
||||
add $C,$C,@X[2]
|
||||
add $D,$D,@X[3]
|
||||
stp $A,$B,[$ctx]
|
||||
add $E,$E,@X[4]
|
||||
add $F,$F,@X[5]
|
||||
stp $C,$D,[$ctx,#2*$SZ]
|
||||
add $G,$G,@X[6]
|
||||
add $H,$H,@X[7]
|
||||
cmp $inp,$num
|
||||
stp $E,$F,[$ctx,#4*$SZ]
|
||||
stp $G,$H,[$ctx,#6*$SZ]
|
||||
b.ne .Loop
|
||||
|
||||
ldp x19,x20,[x29,#16]
|
||||
add sp,sp,#4*$SZ
|
||||
ldp x21,x22,[x29,#32]
|
||||
ldp x23,x24,[x29,#48]
|
||||
ldp x25,x26,[x29,#64]
|
||||
ldp x27,x28,[x29,#80]
|
||||
ldp x29,x30,[sp],#128
|
||||
ret
|
||||
.size $func,.-$func
|
||||
|
||||
.align 6
|
||||
.type K$BITS,%object
|
||||
K$BITS:
|
||||
___
|
||||
$code.=<<___ if ($SZ==8);
|
||||
.quad 0x428a2f98d728ae22,0x7137449123ef65cd
|
||||
.quad 0xb5c0fbcfec4d3b2f,0xe9b5dba58189dbbc
|
||||
.quad 0x3956c25bf348b538,0x59f111f1b605d019
|
||||
.quad 0x923f82a4af194f9b,0xab1c5ed5da6d8118
|
||||
.quad 0xd807aa98a3030242,0x12835b0145706fbe
|
||||
.quad 0x243185be4ee4b28c,0x550c7dc3d5ffb4e2
|
||||
.quad 0x72be5d74f27b896f,0x80deb1fe3b1696b1
|
||||
.quad 0x9bdc06a725c71235,0xc19bf174cf692694
|
||||
.quad 0xe49b69c19ef14ad2,0xefbe4786384f25e3
|
||||
.quad 0x0fc19dc68b8cd5b5,0x240ca1cc77ac9c65
|
||||
.quad 0x2de92c6f592b0275,0x4a7484aa6ea6e483
|
||||
.quad 0x5cb0a9dcbd41fbd4,0x76f988da831153b5
|
||||
.quad 0x983e5152ee66dfab,0xa831c66d2db43210
|
||||
.quad 0xb00327c898fb213f,0xbf597fc7beef0ee4
|
||||
.quad 0xc6e00bf33da88fc2,0xd5a79147930aa725
|
||||
.quad 0x06ca6351e003826f,0x142929670a0e6e70
|
||||
.quad 0x27b70a8546d22ffc,0x2e1b21385c26c926
|
||||
.quad 0x4d2c6dfc5ac42aed,0x53380d139d95b3df
|
||||
.quad 0x650a73548baf63de,0x766a0abb3c77b2a8
|
||||
.quad 0x81c2c92e47edaee6,0x92722c851482353b
|
||||
.quad 0xa2bfe8a14cf10364,0xa81a664bbc423001
|
||||
.quad 0xc24b8b70d0f89791,0xc76c51a30654be30
|
||||
.quad 0xd192e819d6ef5218,0xd69906245565a910
|
||||
.quad 0xf40e35855771202a,0x106aa07032bbd1b8
|
||||
.quad 0x19a4c116b8d2d0c8,0x1e376c085141ab53
|
||||
.quad 0x2748774cdf8eeb99,0x34b0bcb5e19b48a8
|
||||
.quad 0x391c0cb3c5c95a63,0x4ed8aa4ae3418acb
|
||||
.quad 0x5b9cca4f7763e373,0x682e6ff3d6b2b8a3
|
||||
.quad 0x748f82ee5defb2fc,0x78a5636f43172f60
|
||||
.quad 0x84c87814a1f0ab72,0x8cc702081a6439ec
|
||||
.quad 0x90befffa23631e28,0xa4506cebde82bde9
|
||||
.quad 0xbef9a3f7b2c67915,0xc67178f2e372532b
|
||||
.quad 0xca273eceea26619c,0xd186b8c721c0c207
|
||||
.quad 0xeada7dd6cde0eb1e,0xf57d4f7fee6ed178
|
||||
.quad 0x06f067aa72176fba,0x0a637dc5a2c898a6
|
||||
.quad 0x113f9804bef90dae,0x1b710b35131c471b
|
||||
.quad 0x28db77f523047d84,0x32caab7b40c72493
|
||||
.quad 0x3c9ebe0a15c9bebc,0x431d67c49c100d4c
|
||||
.quad 0x4cc5d4becb3e42b6,0x597f299cfc657e2a
|
||||
.quad 0x5fcb6fab3ad6faec,0x6c44198c4a475817
|
||||
.quad 0 // terminator
|
||||
___
|
||||
$code.=<<___ if ($SZ==4);
|
||||
.long 0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5
|
||||
.long 0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5
|
||||
.long 0xd807aa98,0x12835b01,0x243185be,0x550c7dc3
|
||||
.long 0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174
|
||||
.long 0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc
|
||||
.long 0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da
|
||||
.long 0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7
|
||||
.long 0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967
|
||||
.long 0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13
|
||||
.long 0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85
|
||||
.long 0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3
|
||||
.long 0xd192e819,0xd6990624,0xf40e3585,0x106aa070
|
||||
.long 0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5
|
||||
.long 0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3
|
||||
.long 0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208
|
||||
.long 0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2
|
||||
.long 0 //terminator
|
||||
___
|
||||
$code.=<<___;
|
||||
.size K$BITS,.-K$BITS
|
||||
.align 3
|
||||
.LOPENSSL_armcap_P:
|
||||
.quad OPENSSL_armcap_P-.
|
||||
.asciz "SHA$BITS block transform for ARMv8, CRYPTOGAMS by <appro\@openssl.org>"
|
||||
.align 2
|
||||
___
|
||||
|
||||
if ($SZ==4) {
|
||||
my $Ktbl="x3";
|
||||
|
||||
my ($ABCD,$EFGH,$abcd)=map("v$_.16b",(0..2));
|
||||
my @MSG=map("v$_.16b",(4..7));
|
||||
my ($W0,$W1)=("v16.4s","v17.4s");
|
||||
my ($ABCD_SAVE,$EFGH_SAVE)=("v18.16b","v19.16b");
|
||||
|
||||
$code.=<<___;
|
||||
.type sha256_block_armv8,%function
|
||||
.align 6
|
||||
sha256_block_armv8:
|
||||
.Lv8_entry:
|
||||
stp x29,x30,[sp,#-16]!
|
||||
add x29,sp,#0
|
||||
|
||||
ld1.32 {$ABCD,$EFGH},[$ctx]
|
||||
adr $Ktbl,K256
|
||||
|
||||
.Loop_hw:
|
||||
ld1 {@MSG[0]-@MSG[3]},[$inp],#64
|
||||
sub $num,$num,#1
|
||||
ld1.32 {$W0},[$Ktbl],#16
|
||||
rev32 @MSG[0],@MSG[0]
|
||||
rev32 @MSG[1],@MSG[1]
|
||||
rev32 @MSG[2],@MSG[2]
|
||||
rev32 @MSG[3],@MSG[3]
|
||||
orr $ABCD_SAVE,$ABCD,$ABCD // offload
|
||||
orr $EFGH_SAVE,$EFGH,$EFGH
|
||||
___
|
||||
for($i=0;$i<12;$i++) {
|
||||
$code.=<<___;
|
||||
ld1.32 {$W1},[$Ktbl],#16
|
||||
add.i32 $W0,$W0,@MSG[0]
|
||||
sha256su0 @MSG[0],@MSG[1]
|
||||
orr $abcd,$ABCD,$ABCD
|
||||
sha256h $ABCD,$EFGH,$W0
|
||||
sha256h2 $EFGH,$abcd,$W0
|
||||
sha256su1 @MSG[0],@MSG[2],@MSG[3]
|
||||
___
|
||||
($W0,$W1)=($W1,$W0); push(@MSG,shift(@MSG));
|
||||
}
|
||||
$code.=<<___;
|
||||
ld1.32 {$W1},[$Ktbl],#16
|
||||
add.i32 $W0,$W0,@MSG[0]
|
||||
orr $abcd,$ABCD,$ABCD
|
||||
sha256h $ABCD,$EFGH,$W0
|
||||
sha256h2 $EFGH,$abcd,$W0
|
||||
|
||||
ld1.32 {$W0},[$Ktbl],#16
|
||||
add.i32 $W1,$W1,@MSG[1]
|
||||
orr $abcd,$ABCD,$ABCD
|
||||
sha256h $ABCD,$EFGH,$W1
|
||||
sha256h2 $EFGH,$abcd,$W1
|
||||
|
||||
ld1.32 {$W1},[$Ktbl]
|
||||
add.i32 $W0,$W0,@MSG[2]
|
||||
sub $Ktbl,$Ktbl,#$rounds*$SZ-16 // rewind
|
||||
orr $abcd,$ABCD,$ABCD
|
||||
sha256h $ABCD,$EFGH,$W0
|
||||
sha256h2 $EFGH,$abcd,$W0
|
||||
|
||||
add.i32 $W1,$W1,@MSG[3]
|
||||
orr $abcd,$ABCD,$ABCD
|
||||
sha256h $ABCD,$EFGH,$W1
|
||||
sha256h2 $EFGH,$abcd,$W1
|
||||
|
||||
add.i32 $ABCD,$ABCD,$ABCD_SAVE
|
||||
add.i32 $EFGH,$EFGH,$EFGH_SAVE
|
||||
|
||||
cbnz $num,.Loop_hw
|
||||
|
||||
st1.32 {$ABCD,$EFGH},[$ctx]
|
||||
|
||||
ldr x29,[sp],#16
|
||||
ret
|
||||
.size sha256_block_armv8,.-sha256_block_armv8
|
||||
___
|
||||
}
|
||||
|
||||
$code.=<<___;
|
||||
.comm OPENSSL_armcap_P,4,4
|
||||
___
|
||||
|
||||
{ my %opcode = (
|
||||
"sha256h" => 0x5e004000, "sha256h2" => 0x5e005000,
|
||||
"sha256su0" => 0x5e282800, "sha256su1" => 0x5e006000 );
|
||||
|
||||
sub unsha256 {
|
||||
my ($mnemonic,$arg)=@_;
|
||||
|
||||
$arg =~ m/[qv]([0-9]+)[^,]*,\s*[qv]([0-9]+)[^,]*(?:,\s*[qv]([0-9]+))?/o
|
||||
&&
|
||||
sprintf ".inst\t0x%08x\t//%s %s",
|
||||
$opcode{$mnemonic}|$1|($2<<5)|($3<<16),
|
||||
$mnemonic,$arg;
|
||||
}
|
||||
}
|
||||
|
||||
foreach(split("\n",$code)) {
|
||||
|
||||
s/\`([^\`]*)\`/eval($1)/geo;
|
||||
|
||||
s/\b(sha256\w+)\s+([qv].*)/unsha256($1,$2)/geo;
|
||||
|
||||
s/\.\w?32\b//o and s/\.16b/\.4s/go;
|
||||
m/(ld|st)1[^\[]+\[0\]/o and s/\.4s/\.s/go;
|
||||
|
||||
print $_,"\n";
|
||||
}
|
||||
|
||||
close STDOUT;
|
||||
@@ -1,7 +1,7 @@
|
||||
#!/usr/bin/env perl
|
||||
#
|
||||
# ====================================================================
|
||||
# Written by Andy Polyakov <appro@fy.chalmers.se> for the OpenSSL
|
||||
# Written by Andy Polyakov <appro@openssl.org> 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/.
|
||||
@@ -48,16 +48,22 @@
|
||||
# because on Itanium 1 stall on MM result is accompanied by
|
||||
# pipeline flush, which takes 6 cycles:-(
|
||||
#
|
||||
# Resulting performance numbers for 900MHz Itanium 2 system:
|
||||
# June 2012
|
||||
#
|
||||
# The 'numbers' are in 1000s of bytes per second processed.
|
||||
# type 16 bytes 64 bytes 256 bytes 1024 bytes 8192 bytes
|
||||
# sha1(*) 6210.14k 20376.30k 52447.83k 85870.05k 105478.12k
|
||||
# sha256 7476.45k 20572.05k 41538.34k 56062.29k 62093.18k
|
||||
# sha512 4996.56k 20026.28k 47597.20k 85278.79k 111501.31k
|
||||
# Improve performance by 15-20%. Note about "rules of engagement"
|
||||
# above. Contemporary cores are equipped with additional shifter,
|
||||
# so that they should perform even better than below, presumably
|
||||
# by ~10%.
|
||||
#
|
||||
# (*) SHA1 numbers are for HP-UX compiler and are presented purely
|
||||
# for reference purposes. I bet it can improved too...
|
||||
######################################################################
|
||||
# Current performance in cycles per processed byte for Itanium 2
|
||||
# pre-9000 series [little-endian] system:
|
||||
#
|
||||
# SHA1(*) 5.7
|
||||
# SHA256 12.6
|
||||
# SHA512 6.7
|
||||
#
|
||||
# (*) SHA1 result is presented purely for reference purposes.
|
||||
#
|
||||
# To generate code, pass the file name with either 256 or 512 in its
|
||||
# name and compiler flags.
|
||||
@@ -106,8 +112,8 @@ if (!defined($big_endian))
|
||||
{ $big_endian=(unpack('L',pack('N',1))==1); }
|
||||
|
||||
$code=<<___;
|
||||
.ident \"$output, version 1.1\"
|
||||
.ident \"IA-64 ISA artwork by Andy Polyakov <appro\@fy.chalmers.se>\"
|
||||
.ident \"$output, version 2.0\"
|
||||
.ident \"IA-64 ISA artwork by Andy Polyakov <appro\@openssl.org>\"
|
||||
.explicit
|
||||
.text
|
||||
|
||||
@@ -115,26 +121,25 @@ pfssave=r2;
|
||||
lcsave=r3;
|
||||
prsave=r14;
|
||||
K=r15;
|
||||
A=r16; B=r17; C=r18; D=r19;
|
||||
E=r20; F=r21; G=r22; H=r23;
|
||||
A_=r16; B_=r17; C_=r18; D_=r19;
|
||||
E_=r20; F_=r21; G_=r22; H_=r23;
|
||||
T1=r24; T2=r25;
|
||||
s0=r26; s1=r27; t0=r28; t1=r29;
|
||||
Ktbl=r30;
|
||||
ctx=r31; // 1st arg
|
||||
input=r48; // 2nd arg
|
||||
num=r49; // 3rd arg
|
||||
sgm0=r50; sgm1=r51; // small constants
|
||||
A_=r54; B_=r55; C_=r56; D_=r57;
|
||||
E_=r58; F_=r59; G_=r60; H_=r61;
|
||||
input=r56; // 2nd arg
|
||||
num=r57; // 3rd arg
|
||||
sgm0=r58; sgm1=r59; // small constants
|
||||
|
||||
// void $func (SHA_CTX *ctx, const void *in,size_t num[,int host])
|
||||
.global $func#
|
||||
.proc $func#
|
||||
.align 32
|
||||
.skip 16
|
||||
$func:
|
||||
.prologue
|
||||
.save ar.pfs,pfssave
|
||||
{ .mmi; alloc pfssave=ar.pfs,3,27,0,16
|
||||
{ .mmi; alloc pfssave=ar.pfs,3,25,0,24
|
||||
$ADDP ctx=0,r32 // 1st arg
|
||||
.save ar.lc,lcsave
|
||||
mov lcsave=ar.lc }
|
||||
@@ -145,11 +150,9 @@ $func:
|
||||
|
||||
.body
|
||||
{ .mib; add r8=0*$SZ,ctx
|
||||
add r9=1*$SZ,ctx
|
||||
brp.loop.imp .L_first16,.L_first16_end-16 }
|
||||
add r9=1*$SZ,ctx }
|
||||
{ .mib; add r10=2*$SZ,ctx
|
||||
add r11=3*$SZ,ctx
|
||||
brp.loop.imp .L_rest,.L_rest_end-16 };;
|
||||
add r11=3*$SZ,ctx };;
|
||||
|
||||
// load A-H
|
||||
.Lpic_point:
|
||||
@@ -164,7 +167,7 @@ $func:
|
||||
add Ktbl=($TABLE#-.Lpic_point),Ktbl }
|
||||
{ .mmi; $LDW G_=[r10]
|
||||
$LDW H_=[r11]
|
||||
cmp.ne p0,p16=0,r0 };; // used in sha256_block
|
||||
cmp.ne p0,p16=0,r0 };;
|
||||
___
|
||||
$code.=<<___ if ($BITS==64);
|
||||
{ .mii; and r8=7,input
|
||||
@@ -179,50 +182,26 @@ $code.=<<___ if ($BITS==64);
|
||||
___
|
||||
$code.=<<___;
|
||||
.L_outer:
|
||||
.rotr X[16]
|
||||
{ .mmi; mov A=A_
|
||||
mov B=B_
|
||||
.rotr R[8],X[16]
|
||||
A=R[0]; B=R[1]; C=R[2]; D=R[3]; E=R[4]; F=R[5]; G=R[6]; H=R[7]
|
||||
{ .mmi; ld1 X[15]=[input],$SZ // eliminated in sha512
|
||||
mov A=A_
|
||||
mov ar.lc=14 }
|
||||
{ .mmi; mov C=C_
|
||||
mov D=D_
|
||||
mov E=E_ }
|
||||
{ .mmi; mov F=F_
|
||||
mov G=G_
|
||||
mov ar.ec=2 }
|
||||
{ .mmi; ld1 X[15]=[input],$SZ // eliminated in 64-bit
|
||||
{ .mmi; mov B=B_
|
||||
mov C=C_
|
||||
mov D=D_ }
|
||||
{ .mmi; mov E=E_
|
||||
mov F=F_
|
||||
mov ar.ec=2 };;
|
||||
{ .mmi; mov G=G_
|
||||
mov H=H_
|
||||
mov sgm1=$sigma1[2] };;
|
||||
|
||||
___
|
||||
$t0="t0", $t1="t1", $code.=<<___ if ($BITS==32);
|
||||
.align 32
|
||||
.L_first16:
|
||||
{ .mmi; add r9=1-$SZ,input
|
||||
add r10=2-$SZ,input
|
||||
add r11=3-$SZ,input };;
|
||||
{ .mmi; ld1 r9=[r9]
|
||||
ld1 r10=[r10]
|
||||
dep.z $t1=E,32,32 }
|
||||
{ .mmi; $LDW K=[Ktbl],$SZ
|
||||
ld1 r11=[r11]
|
||||
zxt4 E=E };;
|
||||
{ .mii; or $t1=$t1,E
|
||||
dep X[15]=X[15],r9,8,8
|
||||
dep r11=r10,r11,8,8 };;
|
||||
{ .mmi; and T1=F,E
|
||||
and T2=A,B
|
||||
dep X[15]=X[15],r11,16,16 }
|
||||
{ .mmi; andcm r8=G,E
|
||||
and r9=A,C
|
||||
mux2 $t0=A,0x44 };; // copy lower half to upper
|
||||
{ .mmi; (p16) ld1 X[15-1]=[input],$SZ // prefetch
|
||||
xor T1=T1,r8 // T1=((e & f) ^ (~e & g))
|
||||
_rotr r11=$t1,$Sigma1[0] } // ROTR(e,14)
|
||||
{ .mib; and r10=B,C
|
||||
xor T2=T2,r9 };;
|
||||
mov sgm1=$sigma1[2] }
|
||||
{ .mib; mov r8=0
|
||||
add r9=1-$SZ,input
|
||||
brp.loop.imp .L_first16,.L_first16_end-16 };;
|
||||
___
|
||||
$t0="A", $t1="E", $code.=<<___ if ($BITS==64);
|
||||
// in 64-bit mode I load whole X[16] at once and take care of alignment...
|
||||
// in sha512 case I load whole X[16] at once and take care of alignment...
|
||||
{ .mmi; add r8=1*$SZ,input
|
||||
add r9=2*$SZ,input
|
||||
add r10=3*$SZ,input };;
|
||||
@@ -248,7 +227,9 @@ $t0="A", $t1="E", $code.=<<___ if ($BITS==64);
|
||||
$LDW X[ 2]=[r8],4*$SZ
|
||||
(p15) br.cond.dpnt.many .L7byte };;
|
||||
{ .mmb; $LDW X[ 1]=[r9],4*$SZ
|
||||
$LDW X[ 0]=[r10],4*$SZ
|
||||
$LDW X[ 0]=[r10],4*$SZ }
|
||||
{ .mib; mov r8=0
|
||||
mux1 X[15]=X[15],\@rev // eliminated on big-endian
|
||||
br.many .L_first16 };;
|
||||
.L1byte:
|
||||
{ .mmi; $LDW X[13]=[r9],4*$SZ
|
||||
@@ -281,7 +262,9 @@ $t0="A", $t1="E", $code.=<<___ if ($BITS==64);
|
||||
shrp X[ 3]=X[ 3],X[ 2],56 }
|
||||
{ .mii; shrp X[ 2]=X[ 2],X[ 1],56
|
||||
shrp X[ 1]=X[ 1],X[ 0],56 }
|
||||
{ .mib; shrp X[ 0]=X[ 0],T1,56
|
||||
{ .mib; shrp X[ 0]=X[ 0],T1,56 }
|
||||
{ .mib; mov r8=0
|
||||
mux1 X[15]=X[15],\@rev // eliminated on big-endian
|
||||
br.many .L_first16 };;
|
||||
.L2byte:
|
||||
{ .mmi; $LDW X[11]=[input],4*$SZ
|
||||
@@ -313,7 +296,9 @@ $t0="A", $t1="E", $code.=<<___ if ($BITS==64);
|
||||
shrp X[ 2]=X[ 2],X[ 1],48 }
|
||||
{ .mii; shrp X[ 1]=X[ 1],X[ 0],48
|
||||
shrp X[ 0]=X[ 0],T1,48 }
|
||||
{ .mfb; br.many .L_first16 };;
|
||||
{ .mib; mov r8=0
|
||||
mux1 X[15]=X[15],\@rev // eliminated on big-endian
|
||||
br.many .L_first16 };;
|
||||
.L3byte:
|
||||
{ .mmi; $LDW X[ 9]=[r9],4*$SZ
|
||||
$LDW X[ 8]=[r10],4*$SZ
|
||||
@@ -341,7 +326,9 @@ $t0="A", $t1="E", $code.=<<___ if ($BITS==64);
|
||||
shrp X[ 3]=X[ 3],X[ 2],40 }
|
||||
{ .mii; shrp X[ 2]=X[ 2],X[ 1],40
|
||||
shrp X[ 1]=X[ 1],X[ 0],40 }
|
||||
{ .mib; shrp X[ 0]=X[ 0],T1,40
|
||||
{ .mib; shrp X[ 0]=X[ 0],T1,40 }
|
||||
{ .mib; mov r8=0
|
||||
mux1 X[15]=X[15],\@rev // eliminated on big-endian
|
||||
br.many .L_first16 };;
|
||||
.L4byte:
|
||||
{ .mmi; $LDW X[ 7]=[input],4*$SZ
|
||||
@@ -369,7 +356,9 @@ $t0="A", $t1="E", $code.=<<___ if ($BITS==64);
|
||||
shrp X[ 2]=X[ 2],X[ 1],32 }
|
||||
{ .mii; shrp X[ 1]=X[ 1],X[ 0],32
|
||||
shrp X[ 0]=X[ 0],T1,32 }
|
||||
{ .mfb; br.many .L_first16 };;
|
||||
{ .mib; mov r8=0
|
||||
mux1 X[15]=X[15],\@rev // eliminated on big-endian
|
||||
br.many .L_first16 };;
|
||||
.L5byte:
|
||||
{ .mmi; $LDW X[ 5]=[r9],4*$SZ
|
||||
$LDW X[ 4]=[r10],4*$SZ
|
||||
@@ -393,7 +382,9 @@ $t0="A", $t1="E", $code.=<<___ if ($BITS==64);
|
||||
shrp X[ 3]=X[ 3],X[ 2],24 }
|
||||
{ .mii; shrp X[ 2]=X[ 2],X[ 1],24
|
||||
shrp X[ 1]=X[ 1],X[ 0],24 }
|
||||
{ .mib; shrp X[ 0]=X[ 0],T1,24
|
||||
{ .mib; shrp X[ 0]=X[ 0],T1,24 }
|
||||
{ .mib; mov r8=0
|
||||
mux1 X[15]=X[15],\@rev // eliminated on big-endian
|
||||
br.many .L_first16 };;
|
||||
.L6byte:
|
||||
{ .mmi; $LDW X[ 3]=[input],4*$SZ
|
||||
@@ -417,7 +408,9 @@ $t0="A", $t1="E", $code.=<<___ if ($BITS==64);
|
||||
shrp X[ 2]=X[ 2],X[ 1],16 }
|
||||
{ .mii; shrp X[ 1]=X[ 1],X[ 0],16
|
||||
shrp X[ 0]=X[ 0],T1,16 }
|
||||
{ .mfb; br.many .L_first16 };;
|
||||
{ .mib; mov r8=0
|
||||
mux1 X[15]=X[15],\@rev // eliminated on big-endian
|
||||
br.many .L_first16 };;
|
||||
.L7byte:
|
||||
{ .mmi; $LDW X[ 1]=[r9],4*$SZ
|
||||
$LDW X[ 0]=[r10],4*$SZ
|
||||
@@ -437,128 +430,146 @@ $t0="A", $t1="E", $code.=<<___ if ($BITS==64);
|
||||
shrp X[ 3]=X[ 3],X[ 2],8 }
|
||||
{ .mii; shrp X[ 2]=X[ 2],X[ 1],8
|
||||
shrp X[ 1]=X[ 1],X[ 0],8 }
|
||||
{ .mib; shrp X[ 0]=X[ 0],T1,8
|
||||
br.many .L_first16 };;
|
||||
{ .mib; shrp X[ 0]=X[ 0],T1,8 }
|
||||
{ .mib; mov r8=0
|
||||
mux1 X[15]=X[15],\@rev };; // eliminated on big-endian
|
||||
|
||||
.align 32
|
||||
.L_first16:
|
||||
{ .mmi; $LDW K=[Ktbl],$SZ
|
||||
and T1=F,E
|
||||
and T2=A,B }
|
||||
{ .mmi; //$LDW X[15]=[input],$SZ // X[i]=*input++
|
||||
add A=A,r8 // H+=Sigma(0) from the past
|
||||
_rotr r10=$t1,$Sigma1[0] } // ROTR(e,14)
|
||||
{ .mmi; and T1=F,E
|
||||
andcm r8=G,E
|
||||
and r9=A,C };;
|
||||
{ .mmi; xor T1=T1,r8 //T1=((e & f) ^ (~e & g))
|
||||
and r10=B,C
|
||||
_rotr r11=$t1,$Sigma1[0] } // ROTR(e,14)
|
||||
{ .mmi; xor T2=T2,r9
|
||||
mux1 X[15]=X[15],\@rev };; // eliminated in big-endian
|
||||
(p16) mux1 X[14]=X[14],\@rev };; // eliminated on big-endian
|
||||
{ .mmi; and T2=A,B
|
||||
and r9=A,C
|
||||
_rotr r11=$t1,$Sigma1[1] } // ROTR(e,41)
|
||||
{ .mmi; xor T1=T1,r8 // T1=((e & f) ^ (~e & g))
|
||||
and r8=B,C };;
|
||||
___
|
||||
$t0="t0", $t1="t1", $code.=<<___ if ($BITS==32);
|
||||
.align 32
|
||||
.L_first16:
|
||||
{ .mmi; add A=A,r8 // H+=Sigma(0) from the past
|
||||
add r10=2-$SZ,input
|
||||
add r11=3-$SZ,input };;
|
||||
{ .mmi; ld1 r9=[r9]
|
||||
ld1 r10=[r10]
|
||||
dep.z $t1=E,32,32 }
|
||||
{ .mmi; ld1 r11=[r11]
|
||||
$LDW K=[Ktbl],$SZ
|
||||
zxt4 E=E };;
|
||||
{ .mii; or $t1=$t1,E
|
||||
dep X[15]=X[15],r9,8,8
|
||||
mux2 $t0=A,0x44 };; // copy lower half to upper
|
||||
{ .mmi; and T1=F,E
|
||||
andcm r8=G,E
|
||||
dep r11=r10,r11,8,8 };;
|
||||
{ .mmi; and T2=A,B
|
||||
and r9=A,C
|
||||
dep X[15]=X[15],r11,16,16 };;
|
||||
{ .mmi; (p16) ld1 X[15-1]=[input],$SZ // prefetch
|
||||
xor T1=T1,r8 // T1=((e & f) ^ (~e & g))
|
||||
_rotr r10=$t1,$Sigma1[0] } // ROTR(e,14)
|
||||
{ .mmi; and r8=B,C
|
||||
_rotr r11=$t1,$Sigma1[1] };; // ROTR(e,18)
|
||||
___
|
||||
$code.=<<___;
|
||||
{ .mib; add T1=T1,H // T1=Ch(e,f,g)+h
|
||||
_rotr r8=$t1,$Sigma1[1] } // ROTR(e,18)
|
||||
{ .mib; xor T2=T2,r10 // T2=((a & b) ^ (a & c) ^ (b & c))
|
||||
mov H=G };;
|
||||
{ .mib; xor r11=r8,r11
|
||||
_rotr r9=$t1,$Sigma1[2] } // ROTR(e,41)
|
||||
{ .mib; mov G=F
|
||||
mov F=E };;
|
||||
{ .mib; xor r9=r9,r11 // r9=Sigma1(e)
|
||||
_rotr r10=$t0,$Sigma0[0] } // ROTR(a,28)
|
||||
{ .mib; add T1=T1,K // T1=Ch(e,f,g)+h+K512[i]
|
||||
mov E=D };;
|
||||
{ .mib; add T1=T1,r9 // T1+=Sigma1(e)
|
||||
_rotr r11=$t0,$Sigma0[1] } // ROTR(a,34)
|
||||
{ .mib; mov D=C
|
||||
mov C=B };;
|
||||
{ .mib; add T1=T1,X[15] // T1+=X[i]
|
||||
_rotr r8=$t0,$Sigma0[2] } // ROTR(a,39)
|
||||
{ .mib; xor r10=r10,r11
|
||||
mux2 X[15]=X[15],0x44 };; // eliminated in 64-bit
|
||||
{ .mmi; xor r10=r8,r10 // r10=Sigma0(a)
|
||||
mov B=A
|
||||
add A=T1,T2 };;
|
||||
{ .mib; add E=E,T1
|
||||
add A=A,r10 // T2=Maj(a,b,c)+Sigma0(a)
|
||||
br.ctop.sptk .L_first16 };;
|
||||
{ .mmi; add T1=T1,H // T1=Ch(e,f,g)+h
|
||||
xor r10=r10,r11
|
||||
_rotr r11=$t1,$Sigma1[2] } // ROTR(e,41)
|
||||
{ .mmi; xor T2=T2,r9
|
||||
add K=K,X[15] };;
|
||||
{ .mmi; add T1=T1,K // T1+=K[i]+X[i]
|
||||
xor T2=T2,r8 // T2=((a & b) ^ (a & c) ^ (b & c))
|
||||
_rotr r8=$t0,$Sigma0[0] } // ROTR(a,28)
|
||||
{ .mmi; xor r11=r11,r10 // Sigma1(e)
|
||||
_rotr r9=$t0,$Sigma0[1] };; // ROTR(a,34)
|
||||
{ .mmi; add T1=T1,r11 // T+=Sigma1(e)
|
||||
xor r8=r8,r9
|
||||
_rotr r9=$t0,$Sigma0[2] };; // ROTR(a,39)
|
||||
{ .mmi; xor r8=r8,r9 // Sigma0(a)
|
||||
add D=D,T1
|
||||
mux2 H=X[15],0x44 } // mov H=X[15] in sha512
|
||||
{ .mib; (p16) add r9=1-$SZ,input // not used in sha512
|
||||
add X[15]=T1,T2 // H=T1+Maj(a,b,c)
|
||||
br.ctop.sptk .L_first16 };;
|
||||
.L_first16_end:
|
||||
|
||||
{ .mii; mov ar.lc=$rounds-17
|
||||
mov ar.ec=1 };;
|
||||
{ .mib; mov ar.lc=$rounds-17
|
||||
brp.loop.imp .L_rest,.L_rest_end-16 }
|
||||
{ .mib; mov ar.ec=1
|
||||
br.many .L_rest };;
|
||||
|
||||
.align 32
|
||||
.L_rest:
|
||||
.rotr X[16]
|
||||
{ .mib; $LDW K=[Ktbl],$SZ
|
||||
{ .mmi; $LDW K=[Ktbl],$SZ
|
||||
add A=A,r8 // H+=Sigma0(a) from the past
|
||||
_rotr r8=X[15-1],$sigma0[0] } // ROTR(s0,1)
|
||||
{ .mib; $ADD X[15]=X[15],X[15-9] // X[i&0xF]+=X[(i+9)&0xF]
|
||||
$SHRU s0=X[15-1],sgm0 };; // s0=X[(i+1)&0xF]>>7
|
||||
{ .mmi; add X[15]=X[15],X[15-9] // X[i&0xF]+=X[(i+9)&0xF]
|
||||
$SHRU s0=X[15-1],sgm0 };; // s0=X[(i+1)&0xF]>>7
|
||||
{ .mib; and T1=F,E
|
||||
_rotr r9=X[15-1],$sigma0[1] } // ROTR(s0,8)
|
||||
{ .mib; andcm r10=G,E
|
||||
$SHRU s1=X[15-14],sgm1 };; // s1=X[(i+14)&0xF]>>6
|
||||
$SHRU s1=X[15-14],sgm1 };; // s1=X[(i+14)&0xF]>>6
|
||||
// Pair of mmi; splits on Itanium 1 and prevents pipeline flush
|
||||
// upon $SHRU output usage
|
||||
{ .mmi; xor T1=T1,r10 // T1=((e & f) ^ (~e & g))
|
||||
xor r9=r8,r9
|
||||
_rotr r10=X[15-14],$sigma1[0] };;// ROTR(s1,19)
|
||||
{ .mib; and T2=A,B
|
||||
_rotr r11=X[15-14],$sigma1[1] }// ROTR(s1,61)
|
||||
{ .mib; and r8=A,C };;
|
||||
_rotr r10=X[15-14],$sigma1[0] }// ROTR(s1,19)
|
||||
{ .mmi; and T2=A,B
|
||||
and r8=A,C
|
||||
_rotr r11=X[15-14],$sigma1[1] };;// ROTR(s1,61)
|
||||
___
|
||||
$t0="t0", $t1="t1", $code.=<<___ if ($BITS==32);
|
||||
// I adhere to mmi; in order to hold Itanium 1 back and avoid 6 cycle
|
||||
// pipeline flush in last bundle. Note that even on Itanium2 the
|
||||
// latter stalls for one clock cycle...
|
||||
{ .mmi; xor s0=s0,r9 // s0=sigma0(X[(i+1)&0xF])
|
||||
dep.z $t1=E,32,32 }
|
||||
{ .mmi; xor r10=r11,r10
|
||||
zxt4 E=E };;
|
||||
{ .mmi; or $t1=$t1,E
|
||||
xor s1=s1,r10 // s1=sigma1(X[(i+14)&0xF])
|
||||
mux2 $t0=A,0x44 };; // copy lower half to upper
|
||||
{ .mib; xor s0=s0,r9 // s0=sigma0(X[(i+1)&0xF])
|
||||
dep.z $t1=E,32,32 }
|
||||
{ .mib; xor r10=r11,r10
|
||||
zxt4 E=E };;
|
||||
{ .mii; xor s1=s1,r10 // s1=sigma1(X[(i+14)&0xF])
|
||||
shrp r9=E,$t1,32+$Sigma1[0] // ROTR(e,14)
|
||||
mux2 $t0=A,0x44 };; // copy lower half to upper
|
||||
// Pair of mmi; splits on Itanium 1 and prevents pipeline flush
|
||||
// upon mux2 output usage
|
||||
{ .mmi; xor T2=T2,r8
|
||||
_rotr r9=$t1,$Sigma1[0] } // ROTR(e,14)
|
||||
shrp r8=E,$t1,32+$Sigma1[1]} // ROTR(e,18)
|
||||
{ .mmi; and r10=B,C
|
||||
add T1=T1,H // T1=Ch(e,f,g)+h
|
||||
$ADD X[15]=X[15],s0 };; // X[i&0xF]+=sigma0(X[(i+1)&0xF])
|
||||
or $t1=$t1,E };;
|
||||
___
|
||||
$t0="A", $t1="E", $code.=<<___ if ($BITS==64);
|
||||
{ .mib; xor s0=s0,r9 // s0=sigma0(X[(i+1)&0xF])
|
||||
_rotr r9=$t1,$Sigma1[0] } // ROTR(e,14)
|
||||
_rotr r9=$t1,$Sigma1[0] } // ROTR(e,14)
|
||||
{ .mib; xor r10=r11,r10
|
||||
xor T2=T2,r8 };;
|
||||
xor T2=T2,r8 };;
|
||||
{ .mib; xor s1=s1,r10 // s1=sigma1(X[(i+14)&0xF])
|
||||
add T1=T1,H }
|
||||
_rotr r8=$t1,$Sigma1[1] } // ROTR(e,18)
|
||||
{ .mib; and r10=B,C
|
||||
$ADD X[15]=X[15],s0 };; // X[i&0xF]+=sigma0(X[(i+1)&0xF])
|
||||
add T1=T1,H };; // T1+=H
|
||||
___
|
||||
$code.=<<___;
|
||||
{ .mmi; xor T2=T2,r10 // T2=((a & b) ^ (a & c) ^ (b & c))
|
||||
mov H=G
|
||||
_rotr r8=$t1,$Sigma1[1] };; // ROTR(e,18)
|
||||
{ .mmi; xor r11=r8,r9
|
||||
$ADD X[15]=X[15],s1 // X[i&0xF]+=sigma1(X[(i+14)&0xF])
|
||||
_rotr r9=$t1,$Sigma1[2] } // ROTR(e,41)
|
||||
{ .mmi; mov G=F
|
||||
mov F=E };;
|
||||
{ .mib; xor r9=r9,r11 // r9=Sigma1(e)
|
||||
_rotr r10=$t0,$Sigma0[0] } // ROTR(a,28)
|
||||
{ .mib; add T1=T1,K // T1=Ch(e,f,g)+h+K512[i]
|
||||
mov E=D };;
|
||||
{ .mib; add T1=T1,r9 // T1+=Sigma1(e)
|
||||
_rotr r11=$t0,$Sigma0[1] } // ROTR(a,34)
|
||||
{ .mib; mov D=C
|
||||
mov C=B };;
|
||||
{ .mmi; add T1=T1,X[15] // T1+=X[i]
|
||||
xor r10=r10,r11
|
||||
_rotr r8=$t0,$Sigma0[2] };; // ROTR(a,39)
|
||||
{ .mmi; xor r10=r8,r10 // r10=Sigma0(a)
|
||||
mov B=A
|
||||
add A=T1,T2 };;
|
||||
{ .mib; add E=E,T1
|
||||
add A=A,r10 // T2=Maj(a,b,c)+Sigma0(a)
|
||||
br.ctop.sptk .L_rest };;
|
||||
{ .mib; xor r9=r9,r8
|
||||
_rotr r8=$t1,$Sigma1[2] } // ROTR(e,41)
|
||||
{ .mib; xor T2=T2,r10 // T2=((a & b) ^ (a & c) ^ (b & c))
|
||||
add X[15]=X[15],s0 };; // X[i]+=sigma0(X[i+1])
|
||||
{ .mmi; xor r9=r9,r8 // Sigma1(e)
|
||||
add X[15]=X[15],s1 // X[i]+=sigma0(X[i+14])
|
||||
_rotr r8=$t0,$Sigma0[0] };; // ROTR(a,28)
|
||||
{ .mmi; add K=K,X[15]
|
||||
add T1=T1,r9 // T1+=Sigma1(e)
|
||||
_rotr r9=$t0,$Sigma0[1] };; // ROTR(a,34)
|
||||
{ .mmi; add T1=T1,K // T1+=K[i]+X[i]
|
||||
xor r8=r8,r9
|
||||
_rotr r9=$t0,$Sigma0[2] };; // ROTR(a,39)
|
||||
{ .mib; add D=D,T1
|
||||
mux2 H=X[15],0x44 } // mov H=X[15] in sha512
|
||||
{ .mib; xor r8=r8,r9 // Sigma0(a)
|
||||
add X[15]=T1,T2 // H=T1+Maj(a,b,c)
|
||||
br.ctop.sptk .L_rest };;
|
||||
.L_rest_end:
|
||||
|
||||
{ .mmi; add A=A,r8 };; // H+=Sigma0(a) from the past
|
||||
{ .mmi; add A_=A_,A
|
||||
add B_=B_,B
|
||||
add C_=C_,C }
|
||||
@@ -590,17 +601,19 @@ $code.=<<___;
|
||||
.endp $func#
|
||||
___
|
||||
|
||||
$code =~ s/\`([^\`]*)\`/eval $1/gem;
|
||||
$code =~ s/_rotr(\s+)([^=]+)=([^,]+),([0-9]+)/shrp$1$2=$3,$3,$4/gm;
|
||||
if ($BITS==64) {
|
||||
$code =~ s/mux2(\s+)\S+/nop.i$1 0x0/gm;
|
||||
$code =~ s/mux1(\s+)\S+/nop.i$1 0x0/gm if ($big_endian);
|
||||
$code =~ s/(shrp\s+X\[[^=]+)=([^,]+),([^,]+),([1-9]+)/$1=$3,$2,64-$4/gm
|
||||
foreach(split($/,$code)) {
|
||||
s/\`([^\`]*)\`/eval $1/gem;
|
||||
s/_rotr(\s+)([^=]+)=([^,]+),([0-9]+)/shrp$1$2=$3,$3,$4/gm;
|
||||
if ($BITS==64) {
|
||||
s/mux2(\s+)([^=]+)=([^,]+),\S+/mov$1 $2=$3/gm;
|
||||
s/mux1(\s+)\S+/nop.i$1 0x0/gm if ($big_endian);
|
||||
s/(shrp\s+X\[[^=]+)=([^,]+),([^,]+),([1-9]+)/$1=$3,$2,64-$4/gm
|
||||
if (!$big_endian);
|
||||
$code =~ s/ld1(\s+)X\[\S+/nop.m$1 0x0/gm;
|
||||
}
|
||||
s/ld1(\s+)X\[\S+/nop.m$1 0x0/gm;
|
||||
}
|
||||
|
||||
print $code;
|
||||
print $_,"\n";
|
||||
}
|
||||
|
||||
print<<___ if ($BITS==32);
|
||||
.align 64
|
||||
|
||||
510
crypto/sha/asm/sha512-mips.pl
Normal file
510
crypto/sha/asm/sha512-mips.pl
Normal file
@@ -0,0 +1,510 @@
|
||||
#!/usr/bin/env perl
|
||||
|
||||
# ====================================================================
|
||||
# Written by Andy Polyakov <appro@openssl.org> 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/.
|
||||
# ====================================================================
|
||||
|
||||
# SHA2 block procedures for MIPS.
|
||||
|
||||
# October 2010.
|
||||
#
|
||||
# SHA256 performance improvement on MIPS R5000 CPU is ~27% over gcc-
|
||||
# generated code in o32 build and ~55% in n32/64 build. SHA512 [which
|
||||
# for now can only be compiled for MIPS64 ISA] improvement is modest
|
||||
# ~17%, but it comes for free, because it's same instruction sequence.
|
||||
# Improvement coefficients are for aligned input.
|
||||
|
||||
# September 2012.
|
||||
#
|
||||
# Add MIPS[32|64]R2 code (>25% less instructions).
|
||||
|
||||
######################################################################
|
||||
# There is a number of MIPS ABI in use, O32 and N32/64 are most
|
||||
# widely used. Then there is a new contender: NUBI. It appears that if
|
||||
# one picks the latter, it's possible to arrange code in ABI neutral
|
||||
# manner. Therefore let's stick to NUBI register layout:
|
||||
#
|
||||
($zero,$at,$t0,$t1,$t2)=map("\$$_",(0..2,24,25));
|
||||
($a0,$a1,$a2,$a3,$a4,$a5,$a6,$a7)=map("\$$_",(4..11));
|
||||
($s0,$s1,$s2,$s3,$s4,$s5,$s6,$s7,$s8,$s9,$s10,$s11)=map("\$$_",(12..23));
|
||||
($gp,$tp,$sp,$fp,$ra)=map("\$$_",(3,28..31));
|
||||
#
|
||||
# The return value is placed in $a0. Following coding rules facilitate
|
||||
# interoperability:
|
||||
#
|
||||
# - never ever touch $tp, "thread pointer", former $gp [o32 can be
|
||||
# excluded from the rule, because it's specified volatile];
|
||||
# - copy return value to $t0, former $v0 [or to $a0 if you're adapting
|
||||
# old code];
|
||||
# - on O32 populate $a4-$a7 with 'lw $aN,4*N($sp)' if necessary;
|
||||
#
|
||||
# For reference here is register layout for N32/64 MIPS ABIs:
|
||||
#
|
||||
# ($zero,$at,$v0,$v1)=map("\$$_",(0..3));
|
||||
# ($a0,$a1,$a2,$a3,$a4,$a5,$a6,$a7)=map("\$$_",(4..11));
|
||||
# ($t0,$t1,$t2,$t3,$t8,$t9)=map("\$$_",(12..15,24,25));
|
||||
# ($s0,$s1,$s2,$s3,$s4,$s5,$s6,$s7)=map("\$$_",(16..23));
|
||||
# ($gp,$sp,$fp,$ra)=map("\$$_",(28..31));
|
||||
#
|
||||
$flavour = shift || "o32"; # supported flavours are o32,n32,64,nubi32,nubi64
|
||||
|
||||
if ($flavour =~ /64|n32/i) {
|
||||
$PTR_ADD="dadd"; # incidentally works even on n32
|
||||
$PTR_SUB="dsub"; # incidentally works even on n32
|
||||
$REG_S="sd";
|
||||
$REG_L="ld";
|
||||
$PTR_SLL="dsll"; # incidentally works even on n32
|
||||
$SZREG=8;
|
||||
} else {
|
||||
$PTR_ADD="add";
|
||||
$PTR_SUB="sub";
|
||||
$REG_S="sw";
|
||||
$REG_L="lw";
|
||||
$PTR_SLL="sll";
|
||||
$SZREG=4;
|
||||
}
|
||||
$pf = ($flavour =~ /nubi/i) ? $t0 : $t2;
|
||||
#
|
||||
# <appro@openssl.org>
|
||||
#
|
||||
######################################################################
|
||||
|
||||
$big_endian=(`echo MIPSEL | $ENV{CC} -E -`=~/MIPSEL/)?1:0 if ($ENV{CC});
|
||||
|
||||
for (@ARGV) { $output=$_ if (/^\w[\w\-]*\.\w+$/); }
|
||||
open STDOUT,">$output";
|
||||
|
||||
if (!defined($big_endian)) { $big_endian=(unpack('L',pack('N',1))==1); }
|
||||
|
||||
if ($output =~ /512/) {
|
||||
$label="512";
|
||||
$SZ=8;
|
||||
$LD="ld"; # load from memory
|
||||
$ST="sd"; # store to memory
|
||||
$SLL="dsll"; # shift left logical
|
||||
$SRL="dsrl"; # shift right logical
|
||||
$ADDU="daddu";
|
||||
$ROTR="drotr";
|
||||
@Sigma0=(28,34,39);
|
||||
@Sigma1=(14,18,41);
|
||||
@sigma0=( 7, 1, 8); # right shift first
|
||||
@sigma1=( 6,19,61); # right shift first
|
||||
$lastK=0x817;
|
||||
$rounds=80;
|
||||
} else {
|
||||
$label="256";
|
||||
$SZ=4;
|
||||
$LD="lw"; # load from memory
|
||||
$ST="sw"; # store to memory
|
||||
$SLL="sll"; # shift left logical
|
||||
$SRL="srl"; # shift right logical
|
||||
$ADDU="addu";
|
||||
$ROTR="rotr";
|
||||
@Sigma0=( 2,13,22);
|
||||
@Sigma1=( 6,11,25);
|
||||
@sigma0=( 3, 7,18); # right shift first
|
||||
@sigma1=(10,17,19); # right shift first
|
||||
$lastK=0x8f2;
|
||||
$rounds=64;
|
||||
}
|
||||
|
||||
$MSB = $big_endian ? 0 : ($SZ-1);
|
||||
$LSB = ($SZ-1)&~$MSB;
|
||||
|
||||
@V=($A,$B,$C,$D,$E,$F,$G,$H)=map("\$$_",(1,2,3,7,24,25,30,31));
|
||||
@X=map("\$$_",(8..23));
|
||||
|
||||
$ctx=$a0;
|
||||
$inp=$a1;
|
||||
$len=$a2; $Ktbl=$len;
|
||||
|
||||
sub BODY_00_15 {
|
||||
my ($i,$a,$b,$c,$d,$e,$f,$g,$h)=@_;
|
||||
my ($T1,$tmp0,$tmp1,$tmp2)=(@X[4],@X[5],@X[6],@X[7]);
|
||||
|
||||
$code.=<<___ if ($i<15);
|
||||
${LD}l @X[1],`($i+1)*$SZ+$MSB`($inp)
|
||||
${LD}r @X[1],`($i+1)*$SZ+$LSB`($inp)
|
||||
___
|
||||
$code.=<<___ if (!$big_endian && $i<16 && $SZ==4);
|
||||
#if defined(_MIPS_ARCH_MIPS32R2) || defined(_MIPS_ARCH_MIPS64R2)
|
||||
wsbh @X[0],@X[0] # byte swap($i)
|
||||
rotr @X[0],@X[0],16
|
||||
#else
|
||||
srl $tmp0,@X[0],24 # byte swap($i)
|
||||
srl $tmp1,@X[0],8
|
||||
andi $tmp2,@X[0],0xFF00
|
||||
sll @X[0],@X[0],24
|
||||
andi $tmp1,0xFF00
|
||||
sll $tmp2,$tmp2,8
|
||||
or @X[0],$tmp0
|
||||
or $tmp1,$tmp2
|
||||
or @X[0],$tmp1
|
||||
#endif
|
||||
___
|
||||
$code.=<<___ if (!$big_endian && $i<16 && $SZ==8);
|
||||
#if defined(_MIPS_ARCH_MIPS64R2)
|
||||
dsbh @X[0],@X[0] # byte swap($i)
|
||||
dshd @X[0],@X[0]
|
||||
#else
|
||||
ori $tmp0,$zero,0xFF
|
||||
dsll $tmp2,$tmp0,32
|
||||
or $tmp0,$tmp2 # 0x000000FF000000FF
|
||||
and $tmp1,@X[0],$tmp0 # byte swap($i)
|
||||
dsrl $tmp2,@X[0],24
|
||||
dsll $tmp1,24
|
||||
and $tmp2,$tmp0
|
||||
dsll $tmp0,8 # 0x0000FF000000FF00
|
||||
or $tmp1,$tmp2
|
||||
and $tmp2,@X[0],$tmp0
|
||||
dsrl @X[0],8
|
||||
dsll $tmp2,8
|
||||
and @X[0],$tmp0
|
||||
or $tmp1,$tmp2
|
||||
or @X[0],$tmp1
|
||||
dsrl $tmp1,@X[0],32
|
||||
dsll @X[0],32
|
||||
or @X[0],$tmp1
|
||||
#endif
|
||||
___
|
||||
$code.=<<___;
|
||||
#if defined(_MIPS_ARCH_MIPS32R2) || defined(_MIPS_ARCH_MIPS64R2)
|
||||
xor $tmp2,$f,$g # $i
|
||||
$ROTR $tmp0,$e,@Sigma1[0]
|
||||
$ADDU $T1,$X[0],$h
|
||||
$ROTR $tmp1,$e,@Sigma1[1]
|
||||
and $tmp2,$e
|
||||
$ROTR $h,$e,@Sigma1[2]
|
||||
xor $tmp0,$tmp1
|
||||
$ROTR $tmp1,$a,@Sigma0[0]
|
||||
xor $tmp2,$g # Ch(e,f,g)
|
||||
xor $tmp0,$h # Sigma1(e)
|
||||
|
||||
$ROTR $h,$a,@Sigma0[1]
|
||||
$ADDU $T1,$tmp2
|
||||
$LD $tmp2,`$i*$SZ`($Ktbl) # K[$i]
|
||||
xor $h,$tmp1
|
||||
$ROTR $tmp1,$a,@Sigma0[2]
|
||||
$ADDU $T1,$tmp0
|
||||
and $tmp0,$b,$c
|
||||
xor $h,$tmp1 # Sigma0(a)
|
||||
xor $tmp1,$b,$c
|
||||
#else
|
||||
$ADDU $T1,$X[0],$h # $i
|
||||
$SRL $h,$e,@Sigma1[0]
|
||||
xor $tmp2,$f,$g
|
||||
$SLL $tmp1,$e,`$SZ*8-@Sigma1[2]`
|
||||
and $tmp2,$e
|
||||
$SRL $tmp0,$e,@Sigma1[1]
|
||||
xor $h,$tmp1
|
||||
$SLL $tmp1,$e,`$SZ*8-@Sigma1[1]`
|
||||
xor $h,$tmp0
|
||||
$SRL $tmp0,$e,@Sigma1[2]
|
||||
xor $h,$tmp1
|
||||
$SLL $tmp1,$e,`$SZ*8-@Sigma1[0]`
|
||||
xor $h,$tmp0
|
||||
xor $tmp2,$g # Ch(e,f,g)
|
||||
xor $tmp0,$tmp1,$h # Sigma1(e)
|
||||
|
||||
$SRL $h,$a,@Sigma0[0]
|
||||
$ADDU $T1,$tmp2
|
||||
$LD $tmp2,`$i*$SZ`($Ktbl) # K[$i]
|
||||
$SLL $tmp1,$a,`$SZ*8-@Sigma0[2]`
|
||||
$ADDU $T1,$tmp0
|
||||
$SRL $tmp0,$a,@Sigma0[1]
|
||||
xor $h,$tmp1
|
||||
$SLL $tmp1,$a,`$SZ*8-@Sigma0[1]`
|
||||
xor $h,$tmp0
|
||||
$SRL $tmp0,$a,@Sigma0[2]
|
||||
xor $h,$tmp1
|
||||
$SLL $tmp1,$a,`$SZ*8-@Sigma0[0]`
|
||||
xor $h,$tmp0
|
||||
and $tmp0,$b,$c
|
||||
xor $h,$tmp1 # Sigma0(a)
|
||||
xor $tmp1,$b,$c
|
||||
#endif
|
||||
$ST @X[0],`($i%16)*$SZ`($sp) # offload to ring buffer
|
||||
$ADDU $h,$tmp0
|
||||
and $tmp1,$a
|
||||
$ADDU $T1,$tmp2 # +=K[$i]
|
||||
$ADDU $h,$tmp1 # +=Maj(a,b,c)
|
||||
$ADDU $d,$T1
|
||||
$ADDU $h,$T1
|
||||
___
|
||||
$code.=<<___ if ($i>=13);
|
||||
$LD @X[3],`(($i+3)%16)*$SZ`($sp) # prefetch from ring buffer
|
||||
___
|
||||
}
|
||||
|
||||
sub BODY_16_XX {
|
||||
my $i=@_[0];
|
||||
my ($tmp0,$tmp1,$tmp2,$tmp3)=(@X[4],@X[5],@X[6],@X[7]);
|
||||
|
||||
$code.=<<___;
|
||||
#if defined(_MIPS_ARCH_MIPS32R2) || defined(_MIPS_ARCH_MIPS64R2)
|
||||
$SRL $tmp2,@X[1],@sigma0[0] # Xupdate($i)
|
||||
$ROTR $tmp0,@X[1],@sigma0[1]
|
||||
$ADDU @X[0],@X[9] # +=X[i+9]
|
||||
xor $tmp2,$tmp0
|
||||
$ROTR $tmp0,@X[1],@sigma0[2]
|
||||
|
||||
$SRL $tmp3,@X[14],@sigma1[0]
|
||||
$ROTR $tmp1,@X[14],@sigma1[1]
|
||||
xor $tmp2,$tmp0 # sigma0(X[i+1])
|
||||
$ROTR $tmp0,@X[14],@sigma1[2]
|
||||
xor $tmp3,$tmp1
|
||||
$ADDU @X[0],$tmp2
|
||||
#else
|
||||
$SRL $tmp2,@X[1],@sigma0[0] # Xupdate($i)
|
||||
$ADDU @X[0],@X[9] # +=X[i+9]
|
||||
$SLL $tmp1,@X[1],`$SZ*8-@sigma0[2]`
|
||||
$SRL $tmp0,@X[1],@sigma0[1]
|
||||
xor $tmp2,$tmp1
|
||||
$SLL $tmp1,`@sigma0[2]-@sigma0[1]`
|
||||
xor $tmp2,$tmp0
|
||||
$SRL $tmp0,@X[1],@sigma0[2]
|
||||
xor $tmp2,$tmp1
|
||||
|
||||
$SRL $tmp3,@X[14],@sigma1[0]
|
||||
xor $tmp2,$tmp0 # sigma0(X[i+1])
|
||||
$SLL $tmp1,@X[14],`$SZ*8-@sigma1[2]`
|
||||
$ADDU @X[0],$tmp2
|
||||
$SRL $tmp0,@X[14],@sigma1[1]
|
||||
xor $tmp3,$tmp1
|
||||
$SLL $tmp1,`@sigma1[2]-@sigma1[1]`
|
||||
xor $tmp3,$tmp0
|
||||
$SRL $tmp0,@X[14],@sigma1[2]
|
||||
xor $tmp3,$tmp1
|
||||
#endif
|
||||
xor $tmp3,$tmp0 # sigma1(X[i+14])
|
||||
$ADDU @X[0],$tmp3
|
||||
___
|
||||
&BODY_00_15(@_);
|
||||
}
|
||||
|
||||
$FRAMESIZE=16*$SZ+16*$SZREG;
|
||||
$SAVED_REGS_MASK = ($flavour =~ /nubi/i) ? 0xc0fff008 : 0xc0ff0000;
|
||||
|
||||
$code.=<<___;
|
||||
#ifdef OPENSSL_FIPSCANISTER
|
||||
# include <openssl/fipssyms.h>
|
||||
#endif
|
||||
|
||||
#if defined(__mips_smartmips) && !defined(_MIPS_ARCH_MIPS32R2)
|
||||
#define _MIPS_ARCH_MIPS32R2
|
||||
#endif
|
||||
|
||||
.text
|
||||
.set noat
|
||||
#if !defined(__mips_eabi) && (!defined(__vxworks) || defined(__pic__))
|
||||
.option pic2
|
||||
#endif
|
||||
|
||||
.align 5
|
||||
.globl sha${label}_block_data_order
|
||||
.ent sha${label}_block_data_order
|
||||
sha${label}_block_data_order:
|
||||
.frame $sp,$FRAMESIZE,$ra
|
||||
.mask $SAVED_REGS_MASK,-$SZREG
|
||||
.set noreorder
|
||||
___
|
||||
$code.=<<___ if ($flavour =~ /o32/i); # o32 PIC-ification
|
||||
.cpload $pf
|
||||
___
|
||||
$code.=<<___;
|
||||
$PTR_SUB $sp,$FRAMESIZE
|
||||
$REG_S $ra,$FRAMESIZE-1*$SZREG($sp)
|
||||
$REG_S $fp,$FRAMESIZE-2*$SZREG($sp)
|
||||
$REG_S $s11,$FRAMESIZE-3*$SZREG($sp)
|
||||
$REG_S $s10,$FRAMESIZE-4*$SZREG($sp)
|
||||
$REG_S $s9,$FRAMESIZE-5*$SZREG($sp)
|
||||
$REG_S $s8,$FRAMESIZE-6*$SZREG($sp)
|
||||
$REG_S $s7,$FRAMESIZE-7*$SZREG($sp)
|
||||
$REG_S $s6,$FRAMESIZE-8*$SZREG($sp)
|
||||
$REG_S $s5,$FRAMESIZE-9*$SZREG($sp)
|
||||
$REG_S $s4,$FRAMESIZE-10*$SZREG($sp)
|
||||
___
|
||||
$code.=<<___ if ($flavour =~ /nubi/i); # optimize non-nubi prologue
|
||||
$REG_S $s3,$FRAMESIZE-11*$SZREG($sp)
|
||||
$REG_S $s2,$FRAMESIZE-12*$SZREG($sp)
|
||||
$REG_S $s1,$FRAMESIZE-13*$SZREG($sp)
|
||||
$REG_S $s0,$FRAMESIZE-14*$SZREG($sp)
|
||||
$REG_S $gp,$FRAMESIZE-15*$SZREG($sp)
|
||||
___
|
||||
$code.=<<___;
|
||||
$PTR_SLL @X[15],$len,`log(16*$SZ)/log(2)`
|
||||
___
|
||||
$code.=<<___ if ($flavour !~ /o32/i); # non-o32 PIC-ification
|
||||
.cplocal $Ktbl
|
||||
.cpsetup $pf,$zero,sha${label}_block_data_order
|
||||
___
|
||||
$code.=<<___;
|
||||
.set reorder
|
||||
la $Ktbl,K${label} # PIC-ified 'load address'
|
||||
|
||||
$LD $A,0*$SZ($ctx) # load context
|
||||
$LD $B,1*$SZ($ctx)
|
||||
$LD $C,2*$SZ($ctx)
|
||||
$LD $D,3*$SZ($ctx)
|
||||
$LD $E,4*$SZ($ctx)
|
||||
$LD $F,5*$SZ($ctx)
|
||||
$LD $G,6*$SZ($ctx)
|
||||
$LD $H,7*$SZ($ctx)
|
||||
|
||||
$PTR_ADD @X[15],$inp # pointer to the end of input
|
||||
$REG_S @X[15],16*$SZ($sp)
|
||||
b .Loop
|
||||
|
||||
.align 5
|
||||
.Loop:
|
||||
${LD}l @X[0],$MSB($inp)
|
||||
${LD}r @X[0],$LSB($inp)
|
||||
___
|
||||
for ($i=0;$i<16;$i++)
|
||||
{ &BODY_00_15($i,@V); unshift(@V,pop(@V)); push(@X,shift(@X)); }
|
||||
$code.=<<___;
|
||||
b .L16_xx
|
||||
.align 4
|
||||
.L16_xx:
|
||||
___
|
||||
for (;$i<32;$i++)
|
||||
{ &BODY_16_XX($i,@V); unshift(@V,pop(@V)); push(@X,shift(@X)); }
|
||||
$code.=<<___;
|
||||
and @X[6],0xfff
|
||||
li @X[7],$lastK
|
||||
.set noreorder
|
||||
bne @X[6],@X[7],.L16_xx
|
||||
$PTR_ADD $Ktbl,16*$SZ # Ktbl+=16
|
||||
|
||||
$REG_L @X[15],16*$SZ($sp) # restore pointer to the end of input
|
||||
$LD @X[0],0*$SZ($ctx)
|
||||
$LD @X[1],1*$SZ($ctx)
|
||||
$LD @X[2],2*$SZ($ctx)
|
||||
$PTR_ADD $inp,16*$SZ
|
||||
$LD @X[3],3*$SZ($ctx)
|
||||
$ADDU $A,@X[0]
|
||||
$LD @X[4],4*$SZ($ctx)
|
||||
$ADDU $B,@X[1]
|
||||
$LD @X[5],5*$SZ($ctx)
|
||||
$ADDU $C,@X[2]
|
||||
$LD @X[6],6*$SZ($ctx)
|
||||
$ADDU $D,@X[3]
|
||||
$LD @X[7],7*$SZ($ctx)
|
||||
$ADDU $E,@X[4]
|
||||
$ST $A,0*$SZ($ctx)
|
||||
$ADDU $F,@X[5]
|
||||
$ST $B,1*$SZ($ctx)
|
||||
$ADDU $G,@X[6]
|
||||
$ST $C,2*$SZ($ctx)
|
||||
$ADDU $H,@X[7]
|
||||
$ST $D,3*$SZ($ctx)
|
||||
$ST $E,4*$SZ($ctx)
|
||||
$ST $F,5*$SZ($ctx)
|
||||
$ST $G,6*$SZ($ctx)
|
||||
$ST $H,7*$SZ($ctx)
|
||||
|
||||
bne $inp,@X[15],.Loop
|
||||
$PTR_SUB $Ktbl,`($rounds-16)*$SZ` # rewind $Ktbl
|
||||
|
||||
$REG_L $ra,$FRAMESIZE-1*$SZREG($sp)
|
||||
$REG_L $fp,$FRAMESIZE-2*$SZREG($sp)
|
||||
$REG_L $s11,$FRAMESIZE-3*$SZREG($sp)
|
||||
$REG_L $s10,$FRAMESIZE-4*$SZREG($sp)
|
||||
$REG_L $s9,$FRAMESIZE-5*$SZREG($sp)
|
||||
$REG_L $s8,$FRAMESIZE-6*$SZREG($sp)
|
||||
$REG_L $s7,$FRAMESIZE-7*$SZREG($sp)
|
||||
$REG_L $s6,$FRAMESIZE-8*$SZREG($sp)
|
||||
$REG_L $s5,$FRAMESIZE-9*$SZREG($sp)
|
||||
$REG_L $s4,$FRAMESIZE-10*$SZREG($sp)
|
||||
___
|
||||
$code.=<<___ if ($flavour =~ /nubi/i);
|
||||
$REG_L $s3,$FRAMESIZE-11*$SZREG($sp)
|
||||
$REG_L $s2,$FRAMESIZE-12*$SZREG($sp)
|
||||
$REG_L $s1,$FRAMESIZE-13*$SZREG($sp)
|
||||
$REG_L $s0,$FRAMESIZE-14*$SZREG($sp)
|
||||
$REG_L $gp,$FRAMESIZE-15*$SZREG($sp)
|
||||
___
|
||||
$code.=<<___;
|
||||
jr $ra
|
||||
$PTR_ADD $sp,$FRAMESIZE
|
||||
.end sha${label}_block_data_order
|
||||
|
||||
.rdata
|
||||
.align 5
|
||||
K${label}:
|
||||
___
|
||||
if ($SZ==4) {
|
||||
$code.=<<___;
|
||||
.word 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5
|
||||
.word 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5
|
||||
.word 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3
|
||||
.word 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174
|
||||
.word 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc
|
||||
.word 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da
|
||||
.word 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7
|
||||
.word 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967
|
||||
.word 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13
|
||||
.word 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85
|
||||
.word 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3
|
||||
.word 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070
|
||||
.word 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5
|
||||
.word 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3
|
||||
.word 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208
|
||||
.word 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
|
||||
___
|
||||
} else {
|
||||
$code.=<<___;
|
||||
.dword 0x428a2f98d728ae22, 0x7137449123ef65cd
|
||||
.dword 0xb5c0fbcfec4d3b2f, 0xe9b5dba58189dbbc
|
||||
.dword 0x3956c25bf348b538, 0x59f111f1b605d019
|
||||
.dword 0x923f82a4af194f9b, 0xab1c5ed5da6d8118
|
||||
.dword 0xd807aa98a3030242, 0x12835b0145706fbe
|
||||
.dword 0x243185be4ee4b28c, 0x550c7dc3d5ffb4e2
|
||||
.dword 0x72be5d74f27b896f, 0x80deb1fe3b1696b1
|
||||
.dword 0x9bdc06a725c71235, 0xc19bf174cf692694
|
||||
.dword 0xe49b69c19ef14ad2, 0xefbe4786384f25e3
|
||||
.dword 0x0fc19dc68b8cd5b5, 0x240ca1cc77ac9c65
|
||||
.dword 0x2de92c6f592b0275, 0x4a7484aa6ea6e483
|
||||
.dword 0x5cb0a9dcbd41fbd4, 0x76f988da831153b5
|
||||
.dword 0x983e5152ee66dfab, 0xa831c66d2db43210
|
||||
.dword 0xb00327c898fb213f, 0xbf597fc7beef0ee4
|
||||
.dword 0xc6e00bf33da88fc2, 0xd5a79147930aa725
|
||||
.dword 0x06ca6351e003826f, 0x142929670a0e6e70
|
||||
.dword 0x27b70a8546d22ffc, 0x2e1b21385c26c926
|
||||
.dword 0x4d2c6dfc5ac42aed, 0x53380d139d95b3df
|
||||
.dword 0x650a73548baf63de, 0x766a0abb3c77b2a8
|
||||
.dword 0x81c2c92e47edaee6, 0x92722c851482353b
|
||||
.dword 0xa2bfe8a14cf10364, 0xa81a664bbc423001
|
||||
.dword 0xc24b8b70d0f89791, 0xc76c51a30654be30
|
||||
.dword 0xd192e819d6ef5218, 0xd69906245565a910
|
||||
.dword 0xf40e35855771202a, 0x106aa07032bbd1b8
|
||||
.dword 0x19a4c116b8d2d0c8, 0x1e376c085141ab53
|
||||
.dword 0x2748774cdf8eeb99, 0x34b0bcb5e19b48a8
|
||||
.dword 0x391c0cb3c5c95a63, 0x4ed8aa4ae3418acb
|
||||
.dword 0x5b9cca4f7763e373, 0x682e6ff3d6b2b8a3
|
||||
.dword 0x748f82ee5defb2fc, 0x78a5636f43172f60
|
||||
.dword 0x84c87814a1f0ab72, 0x8cc702081a6439ec
|
||||
.dword 0x90befffa23631e28, 0xa4506cebde82bde9
|
||||
.dword 0xbef9a3f7b2c67915, 0xc67178f2e372532b
|
||||
.dword 0xca273eceea26619c, 0xd186b8c721c0c207
|
||||
.dword 0xeada7dd6cde0eb1e, 0xf57d4f7fee6ed178
|
||||
.dword 0x06f067aa72176fba, 0x0a637dc5a2c898a6
|
||||
.dword 0x113f9804bef90dae, 0x1b710b35131c471b
|
||||
.dword 0x28db77f523047d84, 0x32caab7b40c72493
|
||||
.dword 0x3c9ebe0a15c9bebc, 0x431d67c49c100d4c
|
||||
.dword 0x4cc5d4becb3e42b6, 0x597f299cfc657e2a
|
||||
.dword 0x5fcb6fab3ad6faec, 0x6c44198c4a475817
|
||||
___
|
||||
}
|
||||
$code.=<<___;
|
||||
.asciiz "SHA${label} for MIPS, CRYPTOGAMS by <appro\@openssl.org>"
|
||||
.align 5
|
||||
|
||||
___
|
||||
|
||||
$code =~ s/\`([^\`]*)\`/eval $1/gem;
|
||||
print $code;
|
||||
close STDOUT;
|
||||
793
crypto/sha/asm/sha512-parisc.pl
Executable file
793
crypto/sha/asm/sha512-parisc.pl
Executable file
@@ -0,0 +1,793 @@
|
||||
#!/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/.
|
||||
# ====================================================================
|
||||
|
||||
# SHA256/512 block procedure for PA-RISC.
|
||||
|
||||
# June 2009.
|
||||
#
|
||||
# SHA256 performance is >75% better than gcc 3.2 generated code on
|
||||
# PA-7100LC. Compared to code generated by vendor compiler this
|
||||
# implementation is almost 70% faster in 64-bit build, but delivers
|
||||
# virtually same performance in 32-bit build on PA-8600.
|
||||
#
|
||||
# SHA512 performance is >2.9x better than gcc 3.2 generated code on
|
||||
# PA-7100LC, PA-RISC 1.1 processor. Then implementation detects if the
|
||||
# code is executed on PA-RISC 2.0 processor and switches to 64-bit
|
||||
# code path delivering adequate peformance even in "blended" 32-bit
|
||||
# build. Though 64-bit code is not any faster than code generated by
|
||||
# vendor compiler on PA-8600...
|
||||
#
|
||||
# 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";
|
||||
}
|
||||
|
||||
if ($output =~ /512/) {
|
||||
$func="sha512_block_data_order";
|
||||
$SZ=8;
|
||||
@Sigma0=(28,34,39);
|
||||
@Sigma1=(14,18,41);
|
||||
@sigma0=(1, 8, 7);
|
||||
@sigma1=(19,61, 6);
|
||||
$rounds=80;
|
||||
$LAST10BITS=0x017;
|
||||
$LD="ldd";
|
||||
$LDM="ldd,ma";
|
||||
$ST="std";
|
||||
} else {
|
||||
$func="sha256_block_data_order";
|
||||
$SZ=4;
|
||||
@Sigma0=( 2,13,22);
|
||||
@Sigma1=( 6,11,25);
|
||||
@sigma0=( 7,18, 3);
|
||||
@sigma1=(17,19,10);
|
||||
$rounds=64;
|
||||
$LAST10BITS=0x0f2;
|
||||
$LD="ldw";
|
||||
$LDM="ldwm";
|
||||
$ST="stw";
|
||||
}
|
||||
|
||||
$FRAME=16*$SIZE_T+$FRAME_MARKER;# 16 saved regs + frame marker
|
||||
# [+ argument transfer]
|
||||
$XOFF=16*$SZ+32; # local variables
|
||||
$FRAME+=$XOFF;
|
||||
$XOFF+=$FRAME_MARKER; # distance between %sp and local variables
|
||||
|
||||
$ctx="%r26"; # zapped by $a0
|
||||
$inp="%r25"; # zapped by $a1
|
||||
$num="%r24"; # zapped by $t0
|
||||
|
||||
$a0 ="%r26";
|
||||
$a1 ="%r25";
|
||||
$t0 ="%r24";
|
||||
$t1 ="%r29";
|
||||
$Tbl="%r31";
|
||||
|
||||
@V=($A,$B,$C,$D,$E,$F,$G,$H)=("%r17","%r18","%r19","%r20","%r21","%r22","%r23","%r28");
|
||||
|
||||
@X=("%r1", "%r2", "%r3", "%r4", "%r5", "%r6", "%r7", "%r8",
|
||||
"%r9", "%r10","%r11","%r12","%r13","%r14","%r15","%r16",$inp);
|
||||
|
||||
sub ROUND_00_15 {
|
||||
my ($i,$a,$b,$c,$d,$e,$f,$g,$h)=@_;
|
||||
$code.=<<___;
|
||||
_ror $e,$Sigma1[0],$a0
|
||||
and $f,$e,$t0
|
||||
_ror $e,$Sigma1[1],$a1
|
||||
addl $t1,$h,$h
|
||||
andcm $g,$e,$t1
|
||||
xor $a1,$a0,$a0
|
||||
_ror $a1,`$Sigma1[2]-$Sigma1[1]`,$a1
|
||||
or $t0,$t1,$t1 ; Ch(e,f,g)
|
||||
addl @X[$i%16],$h,$h
|
||||
xor $a0,$a1,$a1 ; Sigma1(e)
|
||||
addl $t1,$h,$h
|
||||
_ror $a,$Sigma0[0],$a0
|
||||
addl $a1,$h,$h
|
||||
|
||||
_ror $a,$Sigma0[1],$a1
|
||||
and $a,$b,$t0
|
||||
and $a,$c,$t1
|
||||
xor $a1,$a0,$a0
|
||||
_ror $a1,`$Sigma0[2]-$Sigma0[1]`,$a1
|
||||
xor $t1,$t0,$t0
|
||||
and $b,$c,$t1
|
||||
xor $a0,$a1,$a1 ; Sigma0(a)
|
||||
addl $h,$d,$d
|
||||
xor $t1,$t0,$t0 ; Maj(a,b,c)
|
||||
`"$LDM $SZ($Tbl),$t1" if ($i<15)`
|
||||
addl $a1,$h,$h
|
||||
addl $t0,$h,$h
|
||||
|
||||
___
|
||||
}
|
||||
|
||||
sub ROUND_16_xx {
|
||||
my ($i,$a,$b,$c,$d,$e,$f,$g,$h)=@_;
|
||||
$i-=16;
|
||||
$code.=<<___;
|
||||
_ror @X[($i+1)%16],$sigma0[0],$a0
|
||||
_ror @X[($i+1)%16],$sigma0[1],$a1
|
||||
addl @X[($i+9)%16],@X[$i],@X[$i]
|
||||
_ror @X[($i+14)%16],$sigma1[0],$t0
|
||||
_ror @X[($i+14)%16],$sigma1[1],$t1
|
||||
xor $a1,$a0,$a0
|
||||
_shr @X[($i+1)%16],$sigma0[2],$a1
|
||||
xor $t1,$t0,$t0
|
||||
_shr @X[($i+14)%16],$sigma1[2],$t1
|
||||
xor $a1,$a0,$a0 ; sigma0(X[(i+1)&0x0f])
|
||||
xor $t1,$t0,$t0 ; sigma1(X[(i+14)&0x0f])
|
||||
$LDM $SZ($Tbl),$t1
|
||||
addl $a0,@X[$i],@X[$i]
|
||||
addl $t0,@X[$i],@X[$i]
|
||||
___
|
||||
$code.=<<___ if ($i==15);
|
||||
extru $t1,31,10,$a1
|
||||
comiclr,<> $LAST10BITS,$a1,%r0
|
||||
ldo 1($Tbl),$Tbl ; signal end of $Tbl
|
||||
___
|
||||
&ROUND_00_15($i+16,$a,$b,$c,$d,$e,$f,$g,$h);
|
||||
}
|
||||
|
||||
$code=<<___;
|
||||
.LEVEL $LEVEL
|
||||
.SPACE \$TEXT\$
|
||||
.SUBSPA \$CODE\$,QUAD=0,ALIGN=8,ACCESS=0x2C,CODE_ONLY
|
||||
|
||||
.ALIGN 64
|
||||
L\$table
|
||||
___
|
||||
$code.=<<___ if ($SZ==8);
|
||||
.WORD 0x428a2f98,0xd728ae22,0x71374491,0x23ef65cd
|
||||
.WORD 0xb5c0fbcf,0xec4d3b2f,0xe9b5dba5,0x8189dbbc
|
||||
.WORD 0x3956c25b,0xf348b538,0x59f111f1,0xb605d019
|
||||
.WORD 0x923f82a4,0xaf194f9b,0xab1c5ed5,0xda6d8118
|
||||
.WORD 0xd807aa98,0xa3030242,0x12835b01,0x45706fbe
|
||||
.WORD 0x243185be,0x4ee4b28c,0x550c7dc3,0xd5ffb4e2
|
||||
.WORD 0x72be5d74,0xf27b896f,0x80deb1fe,0x3b1696b1
|
||||
.WORD 0x9bdc06a7,0x25c71235,0xc19bf174,0xcf692694
|
||||
.WORD 0xe49b69c1,0x9ef14ad2,0xefbe4786,0x384f25e3
|
||||
.WORD 0x0fc19dc6,0x8b8cd5b5,0x240ca1cc,0x77ac9c65
|
||||
.WORD 0x2de92c6f,0x592b0275,0x4a7484aa,0x6ea6e483
|
||||
.WORD 0x5cb0a9dc,0xbd41fbd4,0x76f988da,0x831153b5
|
||||
.WORD 0x983e5152,0xee66dfab,0xa831c66d,0x2db43210
|
||||
.WORD 0xb00327c8,0x98fb213f,0xbf597fc7,0xbeef0ee4
|
||||
.WORD 0xc6e00bf3,0x3da88fc2,0xd5a79147,0x930aa725
|
||||
.WORD 0x06ca6351,0xe003826f,0x14292967,0x0a0e6e70
|
||||
.WORD 0x27b70a85,0x46d22ffc,0x2e1b2138,0x5c26c926
|
||||
.WORD 0x4d2c6dfc,0x5ac42aed,0x53380d13,0x9d95b3df
|
||||
.WORD 0x650a7354,0x8baf63de,0x766a0abb,0x3c77b2a8
|
||||
.WORD 0x81c2c92e,0x47edaee6,0x92722c85,0x1482353b
|
||||
.WORD 0xa2bfe8a1,0x4cf10364,0xa81a664b,0xbc423001
|
||||
.WORD 0xc24b8b70,0xd0f89791,0xc76c51a3,0x0654be30
|
||||
.WORD 0xd192e819,0xd6ef5218,0xd6990624,0x5565a910
|
||||
.WORD 0xf40e3585,0x5771202a,0x106aa070,0x32bbd1b8
|
||||
.WORD 0x19a4c116,0xb8d2d0c8,0x1e376c08,0x5141ab53
|
||||
.WORD 0x2748774c,0xdf8eeb99,0x34b0bcb5,0xe19b48a8
|
||||
.WORD 0x391c0cb3,0xc5c95a63,0x4ed8aa4a,0xe3418acb
|
||||
.WORD 0x5b9cca4f,0x7763e373,0x682e6ff3,0xd6b2b8a3
|
||||
.WORD 0x748f82ee,0x5defb2fc,0x78a5636f,0x43172f60
|
||||
.WORD 0x84c87814,0xa1f0ab72,0x8cc70208,0x1a6439ec
|
||||
.WORD 0x90befffa,0x23631e28,0xa4506ceb,0xde82bde9
|
||||
.WORD 0xbef9a3f7,0xb2c67915,0xc67178f2,0xe372532b
|
||||
.WORD 0xca273ece,0xea26619c,0xd186b8c7,0x21c0c207
|
||||
.WORD 0xeada7dd6,0xcde0eb1e,0xf57d4f7f,0xee6ed178
|
||||
.WORD 0x06f067aa,0x72176fba,0x0a637dc5,0xa2c898a6
|
||||
.WORD 0x113f9804,0xbef90dae,0x1b710b35,0x131c471b
|
||||
.WORD 0x28db77f5,0x23047d84,0x32caab7b,0x40c72493
|
||||
.WORD 0x3c9ebe0a,0x15c9bebc,0x431d67c4,0x9c100d4c
|
||||
.WORD 0x4cc5d4be,0xcb3e42b6,0x597f299c,0xfc657e2a
|
||||
.WORD 0x5fcb6fab,0x3ad6faec,0x6c44198c,0x4a475817
|
||||
___
|
||||
$code.=<<___ if ($SZ==4);
|
||||
.WORD 0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5
|
||||
.WORD 0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5
|
||||
.WORD 0xd807aa98,0x12835b01,0x243185be,0x550c7dc3
|
||||
.WORD 0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174
|
||||
.WORD 0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc
|
||||
.WORD 0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da
|
||||
.WORD 0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7
|
||||
.WORD 0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967
|
||||
.WORD 0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13
|
||||
.WORD 0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85
|
||||
.WORD 0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3
|
||||
.WORD 0xd192e819,0xd6990624,0xf40e3585,0x106aa070
|
||||
.WORD 0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5
|
||||
.WORD 0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3
|
||||
.WORD 0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208
|
||||
.WORD 0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2
|
||||
___
|
||||
$code.=<<___;
|
||||
|
||||
.EXPORT $func,ENTRY,ARGW0=GR,ARGW1=GR,ARGW2=GR
|
||||
.ALIGN 64
|
||||
$func
|
||||
.PROC
|
||||
.CALLINFO FRAME=`$FRAME-16*$SIZE_T`,NO_CALLS,SAVE_RP,ENTRY_GR=18
|
||||
.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)
|
||||
$PUSH %r17,`-$FRAME+14*$SIZE_T`(%sp)
|
||||
$PUSH %r18,`-$FRAME+15*$SIZE_T`(%sp)
|
||||
|
||||
_shl $num,`log(16*$SZ)/log(2)`,$num
|
||||
addl $inp,$num,$num ; $num to point at the end of $inp
|
||||
|
||||
$PUSH $num,`-$FRAME_MARKER-4*$SIZE_T`(%sp) ; save arguments
|
||||
$PUSH $inp,`-$FRAME_MARKER-3*$SIZE_T`(%sp)
|
||||
$PUSH $ctx,`-$FRAME_MARKER-2*$SIZE_T`(%sp)
|
||||
|
||||
blr %r0,$Tbl
|
||||
ldi 3,$t1
|
||||
L\$pic
|
||||
andcm $Tbl,$t1,$Tbl ; wipe privilege level
|
||||
ldo L\$table-L\$pic($Tbl),$Tbl
|
||||
___
|
||||
$code.=<<___ if ($SZ==8 && $SIZE_T==4);
|
||||
ldi 31,$t1
|
||||
mtctl $t1,%cr11
|
||||
extrd,u,*= $t1,%sar,1,$t1 ; executes on PA-RISC 1.0
|
||||
b L\$parisc1
|
||||
nop
|
||||
___
|
||||
$code.=<<___;
|
||||
$LD `0*$SZ`($ctx),$A ; load context
|
||||
$LD `1*$SZ`($ctx),$B
|
||||
$LD `2*$SZ`($ctx),$C
|
||||
$LD `3*$SZ`($ctx),$D
|
||||
$LD `4*$SZ`($ctx),$E
|
||||
$LD `5*$SZ`($ctx),$F
|
||||
$LD `6*$SZ`($ctx),$G
|
||||
$LD `7*$SZ`($ctx),$H
|
||||
|
||||
extru $inp,31,`log($SZ)/log(2)`,$t0
|
||||
sh3addl $t0,%r0,$t0
|
||||
subi `8*$SZ`,$t0,$t0
|
||||
mtctl $t0,%cr11 ; load %sar with align factor
|
||||
|
||||
L\$oop
|
||||
ldi `$SZ-1`,$t0
|
||||
$LDM $SZ($Tbl),$t1
|
||||
andcm $inp,$t0,$t0 ; align $inp
|
||||
___
|
||||
for ($i=0;$i<15;$i++) { # load input block
|
||||
$code.="\t$LD `$SZ*$i`($t0),@X[$i]\n"; }
|
||||
$code.=<<___;
|
||||
cmpb,*= $inp,$t0,L\$aligned
|
||||
$LD `$SZ*15`($t0),@X[15]
|
||||
$LD `$SZ*16`($t0),@X[16]
|
||||
___
|
||||
for ($i=0;$i<16;$i++) { # align data
|
||||
$code.="\t_align @X[$i],@X[$i+1],@X[$i]\n"; }
|
||||
$code.=<<___;
|
||||
L\$aligned
|
||||
nop ; otherwise /usr/ccs/bin/as is confused by below .WORD
|
||||
___
|
||||
|
||||
for($i=0;$i<16;$i++) { &ROUND_00_15($i,@V); unshift(@V,pop(@V)); }
|
||||
$code.=<<___;
|
||||
L\$rounds
|
||||
nop ; otherwise /usr/ccs/bin/as is confused by below .WORD
|
||||
___
|
||||
for(;$i<32;$i++) { &ROUND_16_xx($i,@V); unshift(@V,pop(@V)); }
|
||||
$code.=<<___;
|
||||
bb,>= $Tbl,31,L\$rounds ; end of $Tbl signalled?
|
||||
nop
|
||||
|
||||
$POP `-$FRAME_MARKER-2*$SIZE_T`(%sp),$ctx ; restore arguments
|
||||
$POP `-$FRAME_MARKER-3*$SIZE_T`(%sp),$inp
|
||||
$POP `-$FRAME_MARKER-4*$SIZE_T`(%sp),$num
|
||||
ldo `-$rounds*$SZ-1`($Tbl),$Tbl ; rewind $Tbl
|
||||
|
||||
$LD `0*$SZ`($ctx),@X[0] ; load context
|
||||
$LD `1*$SZ`($ctx),@X[1]
|
||||
$LD `2*$SZ`($ctx),@X[2]
|
||||
$LD `3*$SZ`($ctx),@X[3]
|
||||
$LD `4*$SZ`($ctx),@X[4]
|
||||
$LD `5*$SZ`($ctx),@X[5]
|
||||
addl @X[0],$A,$A
|
||||
$LD `6*$SZ`($ctx),@X[6]
|
||||
addl @X[1],$B,$B
|
||||
$LD `7*$SZ`($ctx),@X[7]
|
||||
ldo `16*$SZ`($inp),$inp ; advance $inp
|
||||
|
||||
$ST $A,`0*$SZ`($ctx) ; save context
|
||||
addl @X[2],$C,$C
|
||||
$ST $B,`1*$SZ`($ctx)
|
||||
addl @X[3],$D,$D
|
||||
$ST $C,`2*$SZ`($ctx)
|
||||
addl @X[4],$E,$E
|
||||
$ST $D,`3*$SZ`($ctx)
|
||||
addl @X[5],$F,$F
|
||||
$ST $E,`4*$SZ`($ctx)
|
||||
addl @X[6],$G,$G
|
||||
$ST $F,`5*$SZ`($ctx)
|
||||
addl @X[7],$H,$H
|
||||
$ST $G,`6*$SZ`($ctx)
|
||||
$ST $H,`7*$SZ`($ctx)
|
||||
|
||||
cmpb,*<>,n $inp,$num,L\$oop
|
||||
$PUSH $inp,`-$FRAME_MARKER-3*$SIZE_T`(%sp) ; save $inp
|
||||
___
|
||||
if ($SZ==8 && $SIZE_T==4) # SHA512 for 32-bit PA-RISC 1.0
|
||||
{{
|
||||
$code.=<<___;
|
||||
b L\$done
|
||||
nop
|
||||
|
||||
.ALIGN 64
|
||||
L\$parisc1
|
||||
___
|
||||
|
||||
@V=( $Ahi, $Alo, $Bhi, $Blo, $Chi, $Clo, $Dhi, $Dlo,
|
||||
$Ehi, $Elo, $Fhi, $Flo, $Ghi, $Glo, $Hhi, $Hlo) =
|
||||
( "%r1", "%r2", "%r3", "%r4", "%r5", "%r6", "%r7", "%r8",
|
||||
"%r9","%r10","%r11","%r12","%r13","%r14","%r15","%r16");
|
||||
$a0 ="%r17";
|
||||
$a1 ="%r18";
|
||||
$a2 ="%r19";
|
||||
$a3 ="%r20";
|
||||
$t0 ="%r21";
|
||||
$t1 ="%r22";
|
||||
$t2 ="%r28";
|
||||
$t3 ="%r29";
|
||||
$Tbl="%r31";
|
||||
|
||||
@X=("%r23","%r24","%r25","%r26"); # zaps $num,$inp,$ctx
|
||||
|
||||
sub ROUND_00_15_pa1 {
|
||||
my ($i,$ahi,$alo,$bhi,$blo,$chi,$clo,$dhi,$dlo,
|
||||
$ehi,$elo,$fhi,$flo,$ghi,$glo,$hhi,$hlo,$flag)=@_;
|
||||
my ($Xhi,$Xlo,$Xnhi,$Xnlo) = @X;
|
||||
|
||||
$code.=<<___ if (!$flag);
|
||||
ldw `-$XOFF+8*(($i+1)%16)`(%sp),$Xnhi
|
||||
ldw `-$XOFF+8*(($i+1)%16)+4`(%sp),$Xnlo ; load X[i+1]
|
||||
___
|
||||
$code.=<<___;
|
||||
shd $ehi,$elo,$Sigma1[0],$t0
|
||||
add $Xlo,$hlo,$hlo
|
||||
shd $elo,$ehi,$Sigma1[0],$t1
|
||||
addc $Xhi,$hhi,$hhi ; h += X[i]
|
||||
shd $ehi,$elo,$Sigma1[1],$t2
|
||||
ldwm 8($Tbl),$Xhi
|
||||
shd $elo,$ehi,$Sigma1[1],$t3
|
||||
ldw -4($Tbl),$Xlo ; load K[i]
|
||||
xor $t2,$t0,$t0
|
||||
xor $t3,$t1,$t1
|
||||
and $flo,$elo,$a0
|
||||
and $fhi,$ehi,$a1
|
||||
shd $ehi,$elo,$Sigma1[2],$t2
|
||||
andcm $glo,$elo,$a2
|
||||
shd $elo,$ehi,$Sigma1[2],$t3
|
||||
andcm $ghi,$ehi,$a3
|
||||
xor $t2,$t0,$t0
|
||||
xor $t3,$t1,$t1 ; Sigma1(e)
|
||||
add $Xlo,$hlo,$hlo
|
||||
xor $a2,$a0,$a0
|
||||
addc $Xhi,$hhi,$hhi ; h += K[i]
|
||||
xor $a3,$a1,$a1 ; Ch(e,f,g)
|
||||
|
||||
add $t0,$hlo,$hlo
|
||||
shd $ahi,$alo,$Sigma0[0],$t0
|
||||
addc $t1,$hhi,$hhi ; h += Sigma1(e)
|
||||
shd $alo,$ahi,$Sigma0[0],$t1
|
||||
add $a0,$hlo,$hlo
|
||||
shd $ahi,$alo,$Sigma0[1],$t2
|
||||
addc $a1,$hhi,$hhi ; h += Ch(e,f,g)
|
||||
shd $alo,$ahi,$Sigma0[1],$t3
|
||||
|
||||
xor $t2,$t0,$t0
|
||||
xor $t3,$t1,$t1
|
||||
shd $ahi,$alo,$Sigma0[2],$t2
|
||||
and $alo,$blo,$a0
|
||||
shd $alo,$ahi,$Sigma0[2],$t3
|
||||
and $ahi,$bhi,$a1
|
||||
xor $t2,$t0,$t0
|
||||
xor $t3,$t1,$t1 ; Sigma0(a)
|
||||
|
||||
and $alo,$clo,$a2
|
||||
and $ahi,$chi,$a3
|
||||
xor $a2,$a0,$a0
|
||||
add $hlo,$dlo,$dlo
|
||||
xor $a3,$a1,$a1
|
||||
addc $hhi,$dhi,$dhi ; d += h
|
||||
and $blo,$clo,$a2
|
||||
add $t0,$hlo,$hlo
|
||||
and $bhi,$chi,$a3
|
||||
addc $t1,$hhi,$hhi ; h += Sigma0(a)
|
||||
xor $a2,$a0,$a0
|
||||
add $a0,$hlo,$hlo
|
||||
xor $a3,$a1,$a1 ; Maj(a,b,c)
|
||||
addc $a1,$hhi,$hhi ; h += Maj(a,b,c)
|
||||
|
||||
___
|
||||
$code.=<<___ if ($i==15 && $flag);
|
||||
extru $Xlo,31,10,$Xlo
|
||||
comiclr,= $LAST10BITS,$Xlo,%r0
|
||||
b L\$rounds_pa1
|
||||
nop
|
||||
___
|
||||
push(@X,shift(@X)); push(@X,shift(@X));
|
||||
}
|
||||
|
||||
sub ROUND_16_xx_pa1 {
|
||||
my ($Xhi,$Xlo,$Xnhi,$Xnlo) = @X;
|
||||
my ($i)=shift;
|
||||
$i-=16;
|
||||
$code.=<<___;
|
||||
ldw `-$XOFF+8*(($i+1)%16)`(%sp),$Xnhi
|
||||
ldw `-$XOFF+8*(($i+1)%16)+4`(%sp),$Xnlo ; load X[i+1]
|
||||
ldw `-$XOFF+8*(($i+9)%16)`(%sp),$a1
|
||||
ldw `-$XOFF+8*(($i+9)%16)+4`(%sp),$a0 ; load X[i+9]
|
||||
ldw `-$XOFF+8*(($i+14)%16)`(%sp),$a3
|
||||
ldw `-$XOFF+8*(($i+14)%16)+4`(%sp),$a2 ; load X[i+14]
|
||||
shd $Xnhi,$Xnlo,$sigma0[0],$t0
|
||||
shd $Xnlo,$Xnhi,$sigma0[0],$t1
|
||||
add $a0,$Xlo,$Xlo
|
||||
shd $Xnhi,$Xnlo,$sigma0[1],$t2
|
||||
addc $a1,$Xhi,$Xhi
|
||||
shd $Xnlo,$Xnhi,$sigma0[1],$t3
|
||||
xor $t2,$t0,$t0
|
||||
shd $Xnhi,$Xnlo,$sigma0[2],$t2
|
||||
xor $t3,$t1,$t1
|
||||
extru $Xnhi,`31-$sigma0[2]`,`32-$sigma0[2]`,$t3
|
||||
xor $t2,$t0,$t0
|
||||
shd $a3,$a2,$sigma1[0],$a0
|
||||
xor $t3,$t1,$t1 ; sigma0(X[i+1)&0x0f])
|
||||
shd $a2,$a3,$sigma1[0],$a1
|
||||
add $t0,$Xlo,$Xlo
|
||||
shd $a3,$a2,$sigma1[1],$t2
|
||||
addc $t1,$Xhi,$Xhi
|
||||
shd $a2,$a3,$sigma1[1],$t3
|
||||
xor $t2,$a0,$a0
|
||||
shd $a3,$a2,$sigma1[2],$t2
|
||||
xor $t3,$a1,$a1
|
||||
extru $a3,`31-$sigma1[2]`,`32-$sigma1[2]`,$t3
|
||||
xor $t2,$a0,$a0
|
||||
xor $t3,$a1,$a1 ; sigma0(X[i+14)&0x0f])
|
||||
add $a0,$Xlo,$Xlo
|
||||
addc $a1,$Xhi,$Xhi
|
||||
|
||||
stw $Xhi,`-$XOFF+8*($i%16)`(%sp)
|
||||
stw $Xlo,`-$XOFF+8*($i%16)+4`(%sp)
|
||||
___
|
||||
&ROUND_00_15_pa1($i,@_,1);
|
||||
}
|
||||
$code.=<<___;
|
||||
ldw `0*4`($ctx),$Ahi ; load context
|
||||
ldw `1*4`($ctx),$Alo
|
||||
ldw `2*4`($ctx),$Bhi
|
||||
ldw `3*4`($ctx),$Blo
|
||||
ldw `4*4`($ctx),$Chi
|
||||
ldw `5*4`($ctx),$Clo
|
||||
ldw `6*4`($ctx),$Dhi
|
||||
ldw `7*4`($ctx),$Dlo
|
||||
ldw `8*4`($ctx),$Ehi
|
||||
ldw `9*4`($ctx),$Elo
|
||||
ldw `10*4`($ctx),$Fhi
|
||||
ldw `11*4`($ctx),$Flo
|
||||
ldw `12*4`($ctx),$Ghi
|
||||
ldw `13*4`($ctx),$Glo
|
||||
ldw `14*4`($ctx),$Hhi
|
||||
ldw `15*4`($ctx),$Hlo
|
||||
|
||||
extru $inp,31,2,$t0
|
||||
sh3addl $t0,%r0,$t0
|
||||
subi 32,$t0,$t0
|
||||
mtctl $t0,%cr11 ; load %sar with align factor
|
||||
|
||||
L\$oop_pa1
|
||||
extru $inp,31,2,$a3
|
||||
comib,= 0,$a3,L\$aligned_pa1
|
||||
sub $inp,$a3,$inp
|
||||
|
||||
ldw `0*4`($inp),$X[0]
|
||||
ldw `1*4`($inp),$X[1]
|
||||
ldw `2*4`($inp),$t2
|
||||
ldw `3*4`($inp),$t3
|
||||
ldw `4*4`($inp),$a0
|
||||
ldw `5*4`($inp),$a1
|
||||
ldw `6*4`($inp),$a2
|
||||
ldw `7*4`($inp),$a3
|
||||
vshd $X[0],$X[1],$X[0]
|
||||
vshd $X[1],$t2,$X[1]
|
||||
stw $X[0],`-$XOFF+0*4`(%sp)
|
||||
ldw `8*4`($inp),$t0
|
||||
vshd $t2,$t3,$t2
|
||||
stw $X[1],`-$XOFF+1*4`(%sp)
|
||||
ldw `9*4`($inp),$t1
|
||||
vshd $t3,$a0,$t3
|
||||
___
|
||||
{
|
||||
my @t=($t2,$t3,$a0,$a1,$a2,$a3,$t0,$t1);
|
||||
for ($i=2;$i<=(128/4-8);$i++) {
|
||||
$code.=<<___;
|
||||
stw $t[0],`-$XOFF+$i*4`(%sp)
|
||||
ldw `(8+$i)*4`($inp),$t[0]
|
||||
vshd $t[1],$t[2],$t[1]
|
||||
___
|
||||
push(@t,shift(@t));
|
||||
}
|
||||
for (;$i<(128/4-1);$i++) {
|
||||
$code.=<<___;
|
||||
stw $t[0],`-$XOFF+$i*4`(%sp)
|
||||
vshd $t[1],$t[2],$t[1]
|
||||
___
|
||||
push(@t,shift(@t));
|
||||
}
|
||||
$code.=<<___;
|
||||
b L\$collected_pa1
|
||||
stw $t[0],`-$XOFF+$i*4`(%sp)
|
||||
|
||||
___
|
||||
}
|
||||
$code.=<<___;
|
||||
L\$aligned_pa1
|
||||
ldw `0*4`($inp),$X[0]
|
||||
ldw `1*4`($inp),$X[1]
|
||||
ldw `2*4`($inp),$t2
|
||||
ldw `3*4`($inp),$t3
|
||||
ldw `4*4`($inp),$a0
|
||||
ldw `5*4`($inp),$a1
|
||||
ldw `6*4`($inp),$a2
|
||||
ldw `7*4`($inp),$a3
|
||||
stw $X[0],`-$XOFF+0*4`(%sp)
|
||||
ldw `8*4`($inp),$t0
|
||||
stw $X[1],`-$XOFF+1*4`(%sp)
|
||||
ldw `9*4`($inp),$t1
|
||||
___
|
||||
{
|
||||
my @t=($t2,$t3,$a0,$a1,$a2,$a3,$t0,$t1);
|
||||
for ($i=2;$i<(128/4-8);$i++) {
|
||||
$code.=<<___;
|
||||
stw $t[0],`-$XOFF+$i*4`(%sp)
|
||||
ldw `(8+$i)*4`($inp),$t[0]
|
||||
___
|
||||
push(@t,shift(@t));
|
||||
}
|
||||
for (;$i<128/4;$i++) {
|
||||
$code.=<<___;
|
||||
stw $t[0],`-$XOFF+$i*4`(%sp)
|
||||
___
|
||||
push(@t,shift(@t));
|
||||
}
|
||||
$code.="L\$collected_pa1\n";
|
||||
}
|
||||
|
||||
for($i=0;$i<16;$i++) { &ROUND_00_15_pa1($i,@V); unshift(@V,pop(@V)); unshift(@V,pop(@V)); }
|
||||
$code.="L\$rounds_pa1\n";
|
||||
for(;$i<32;$i++) { &ROUND_16_xx_pa1($i,@V); unshift(@V,pop(@V)); unshift(@V,pop(@V)); }
|
||||
|
||||
$code.=<<___;
|
||||
$POP `-$FRAME_MARKER-2*$SIZE_T`(%sp),$ctx ; restore arguments
|
||||
$POP `-$FRAME_MARKER-3*$SIZE_T`(%sp),$inp
|
||||
$POP `-$FRAME_MARKER-4*$SIZE_T`(%sp),$num
|
||||
ldo `-$rounds*$SZ`($Tbl),$Tbl ; rewind $Tbl
|
||||
|
||||
ldw `0*4`($ctx),$t1 ; update context
|
||||
ldw `1*4`($ctx),$t0
|
||||
ldw `2*4`($ctx),$t3
|
||||
ldw `3*4`($ctx),$t2
|
||||
ldw `4*4`($ctx),$a1
|
||||
ldw `5*4`($ctx),$a0
|
||||
ldw `6*4`($ctx),$a3
|
||||
add $t0,$Alo,$Alo
|
||||
ldw `7*4`($ctx),$a2
|
||||
addc $t1,$Ahi,$Ahi
|
||||
ldw `8*4`($ctx),$t1
|
||||
add $t2,$Blo,$Blo
|
||||
ldw `9*4`($ctx),$t0
|
||||
addc $t3,$Bhi,$Bhi
|
||||
ldw `10*4`($ctx),$t3
|
||||
add $a0,$Clo,$Clo
|
||||
ldw `11*4`($ctx),$t2
|
||||
addc $a1,$Chi,$Chi
|
||||
ldw `12*4`($ctx),$a1
|
||||
add $a2,$Dlo,$Dlo
|
||||
ldw `13*4`($ctx),$a0
|
||||
addc $a3,$Dhi,$Dhi
|
||||
ldw `14*4`($ctx),$a3
|
||||
add $t0,$Elo,$Elo
|
||||
ldw `15*4`($ctx),$a2
|
||||
addc $t1,$Ehi,$Ehi
|
||||
stw $Ahi,`0*4`($ctx)
|
||||
add $t2,$Flo,$Flo
|
||||
stw $Alo,`1*4`($ctx)
|
||||
addc $t3,$Fhi,$Fhi
|
||||
stw $Bhi,`2*4`($ctx)
|
||||
add $a0,$Glo,$Glo
|
||||
stw $Blo,`3*4`($ctx)
|
||||
addc $a1,$Ghi,$Ghi
|
||||
stw $Chi,`4*4`($ctx)
|
||||
add $a2,$Hlo,$Hlo
|
||||
stw $Clo,`5*4`($ctx)
|
||||
addc $a3,$Hhi,$Hhi
|
||||
stw $Dhi,`6*4`($ctx)
|
||||
ldo `16*$SZ`($inp),$inp ; advance $inp
|
||||
stw $Dlo,`7*4`($ctx)
|
||||
stw $Ehi,`8*4`($ctx)
|
||||
stw $Elo,`9*4`($ctx)
|
||||
stw $Fhi,`10*4`($ctx)
|
||||
stw $Flo,`11*4`($ctx)
|
||||
stw $Ghi,`12*4`($ctx)
|
||||
stw $Glo,`13*4`($ctx)
|
||||
stw $Hhi,`14*4`($ctx)
|
||||
comb,= $inp,$num,L\$done
|
||||
stw $Hlo,`15*4`($ctx)
|
||||
b L\$oop_pa1
|
||||
$PUSH $inp,`-$FRAME_MARKER-3*$SIZE_T`(%sp) ; save $inp
|
||||
L\$done
|
||||
___
|
||||
}}
|
||||
$code.=<<___;
|
||||
$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
|
||||
$POP `-$FRAME+14*$SIZE_T`(%sp),%r17
|
||||
$POP `-$FRAME+15*$SIZE_T`(%sp),%r18
|
||||
bv (%r2)
|
||||
.EXIT
|
||||
$POPMB -$FRAME(%sp),%r3
|
||||
.PROCEND
|
||||
.STRINGZ "SHA`64*$SZ` block transform for PA-RISC, CRYPTOGAMS by <appro\@openssl.org>"
|
||||
___
|
||||
|
||||
# Explicitly encode PA-RISC 2.0 instructions used in this module, so
|
||||
# that it can be compiled with .LEVEL 1.0. It should be noted that I
|
||||
# wouldn't have to do this, if GNU assembler understood .ALLOW 2.0
|
||||
# directive...
|
||||
|
||||
my $ldd = sub {
|
||||
my ($mod,$args) = @_;
|
||||
my $orig = "ldd$mod\t$args";
|
||||
|
||||
if ($args =~ /(\-?[0-9]+)\(%r([0-9]+)\),%r([0-9]+)/) # format 3 suffices
|
||||
{ my $opcode=(0x14<<26)|($2<<21)|($3<<16)|(($1&0x1FF8)<<1)|(($1>>13)&1);
|
||||
$opcode|=(1<<3) if ($mod =~ /^,m/);
|
||||
$opcode|=(1<<2) if ($mod =~ /^,mb/);
|
||||
sprintf "\t.WORD\t0x%08x\t; %s",$opcode,$orig;
|
||||
}
|
||||
else { "\t".$orig; }
|
||||
};
|
||||
|
||||
my $std = sub {
|
||||
my ($mod,$args) = @_;
|
||||
my $orig = "std$mod\t$args";
|
||||
|
||||
if ($args =~ /%r([0-9]+),(\-?[0-9]+)\(%r([0-9]+)\)/) # format 3 suffices
|
||||
{ my $opcode=(0x1c<<26)|($3<<21)|($1<<16)|(($2&0x1FF8)<<1)|(($2>>13)&1);
|
||||
sprintf "\t.WORD\t0x%08x\t; %s",$opcode,$orig;
|
||||
}
|
||||
else { "\t".$orig; }
|
||||
};
|
||||
|
||||
my $extrd = sub {
|
||||
my ($mod,$args) = @_;
|
||||
my $orig = "extrd$mod\t$args";
|
||||
|
||||
# I only have ",u" completer, it's implicitly encoded...
|
||||
if ($args =~ /%r([0-9]+),([0-9]+),([0-9]+),%r([0-9]+)/) # format 15
|
||||
{ my $opcode=(0x36<<26)|($1<<21)|($4<<16);
|
||||
my $len=32-$3;
|
||||
$opcode |= (($2&0x20)<<6)|(($2&0x1f)<<5); # encode pos
|
||||
$opcode |= (($len&0x20)<<7)|($len&0x1f); # encode len
|
||||
sprintf "\t.WORD\t0x%08x\t; %s",$opcode,$orig;
|
||||
}
|
||||
elsif ($args =~ /%r([0-9]+),%sar,([0-9]+),%r([0-9]+)/) # format 12
|
||||
{ my $opcode=(0x34<<26)|($1<<21)|($3<<16)|(2<<11)|(1<<9);
|
||||
my $len=32-$2;
|
||||
$opcode |= (($len&0x20)<<3)|($len&0x1f); # encode len
|
||||
$opcode |= (1<<13) if ($mod =~ /,\**=/);
|
||||
sprintf "\t.WORD\t0x%08x\t; %s",$opcode,$orig;
|
||||
}
|
||||
else { "\t".$orig; }
|
||||
};
|
||||
|
||||
my $shrpd = sub {
|
||||
my ($mod,$args) = @_;
|
||||
my $orig = "shrpd$mod\t$args";
|
||||
|
||||
if ($args =~ /%r([0-9]+),%r([0-9]+),([0-9]+),%r([0-9]+)/) # format 14
|
||||
{ my $opcode=(0x34<<26)|($2<<21)|($1<<16)|(1<<10)|$4;
|
||||
my $cpos=63-$3;
|
||||
$opcode |= (($cpos&0x20)<<6)|(($cpos&0x1f)<<5); # encode sa
|
||||
sprintf "\t.WORD\t0x%08x\t; %s",$opcode,$orig;
|
||||
}
|
||||
elsif ($args =~ /%r([0-9]+),%r([0-9]+),%sar,%r([0-9]+)/) # format 11
|
||||
{ sprintf "\t.WORD\t0x%08x\t; %s",
|
||||
(0x34<<26)|($2<<21)|($1<<16)|(1<<9)|$3,$orig;
|
||||
}
|
||||
else { "\t".$orig; }
|
||||
};
|
||||
|
||||
sub assemble {
|
||||
my ($mnemonic,$mod,$args)=@_;
|
||||
my $opcode = eval("\$$mnemonic");
|
||||
|
||||
ref($opcode) eq 'CODE' ? &$opcode($mod,$args) : "\t$mnemonic$mod\t$args";
|
||||
}
|
||||
|
||||
foreach (split("\n",$code)) {
|
||||
s/\`([^\`]*)\`/eval $1/ge;
|
||||
|
||||
s/shd\s+(%r[0-9]+),(%r[0-9]+),([0-9]+)/
|
||||
$3>31 ? sprintf("shd\t%$2,%$1,%d",$3-32) # rotation for >=32
|
||||
: sprintf("shd\t%$1,%$2,%d",$3)/e or
|
||||
# translate made up instructons: _ror, _shr, _align, _shl
|
||||
s/_ror(\s+)(%r[0-9]+),/
|
||||
($SZ==4 ? "shd" : "shrpd")."$1$2,$2,"/e or
|
||||
|
||||
s/_shr(\s+%r[0-9]+),([0-9]+),/
|
||||
$SZ==4 ? sprintf("extru%s,%d,%d,",$1,31-$2,32-$2)
|
||||
: sprintf("extrd,u%s,%d,%d,",$1,63-$2,64-$2)/e or
|
||||
|
||||
s/_align(\s+%r[0-9]+,%r[0-9]+),/
|
||||
($SZ==4 ? "vshd$1," : "shrpd$1,%sar,")/e or
|
||||
|
||||
s/_shl(\s+%r[0-9]+),([0-9]+),/
|
||||
$SIZE_T==4 ? sprintf("zdep%s,%d,%d,",$1,31-$2,32-$2)
|
||||
: sprintf("depd,z%s,%d,%d,",$1,63-$2,64-$2)/e;
|
||||
|
||||
s/^\s+([a-z]+)([\S]*)\s+([\S]*)/&assemble($1,$2,$3)/e if ($SIZE_T==4);
|
||||
|
||||
s/cmpb,\*/comb,/ if ($SIZE_T==4);
|
||||
|
||||
s/\bbv\b/bve/ if ($SIZE_T==8);
|
||||
|
||||
print $_,"\n";
|
||||
}
|
||||
|
||||
close STDOUT;
|
||||
@@ -1,7 +1,7 @@
|
||||
#!/usr/bin/env perl
|
||||
|
||||
# ====================================================================
|
||||
# Written by Andy Polyakov <appro@fy.chalmers.se> for the OpenSSL
|
||||
# Written by Andy Polyakov <appro@openssl.org> 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/.
|
||||
@@ -9,8 +9,7 @@
|
||||
|
||||
# I let hardware handle unaligned input, except on page boundaries
|
||||
# (see below for details). Otherwise straightforward implementation
|
||||
# with X vector in register bank. The module is big-endian [which is
|
||||
# not big deal as there're no little-endian targets left around].
|
||||
# with X vector in register bank.
|
||||
|
||||
# sha256 | sha512
|
||||
# -m64 -m32 | -m64 -m32
|
||||
@@ -40,6 +39,7 @@ $output =shift;
|
||||
|
||||
if ($flavour =~ /64/) {
|
||||
$SIZE_T=8;
|
||||
$LRSAVE=2*$SIZE_T;
|
||||
$STU="stdu";
|
||||
$UCMP="cmpld";
|
||||
$SHL="sldi";
|
||||
@@ -47,6 +47,7 @@ if ($flavour =~ /64/) {
|
||||
$PUSH="std";
|
||||
} elsif ($flavour =~ /32/) {
|
||||
$SIZE_T=4;
|
||||
$LRSAVE=$SIZE_T;
|
||||
$STU="stwu";
|
||||
$UCMP="cmplw";
|
||||
$SHL="slwi";
|
||||
@@ -54,6 +55,8 @@ if ($flavour =~ /64/) {
|
||||
$PUSH="stw";
|
||||
} else { die "nonsense $flavour"; }
|
||||
|
||||
$LITTLE_ENDIAN = ($flavour=~/le$/) ? $SIZE_T : 0;
|
||||
|
||||
$0 =~ m/(.*[\/\\])[^\/\\]+$/; $dir=$1;
|
||||
( $xlate="${dir}ppc-xlate.pl" and -f $xlate ) or
|
||||
( $xlate="${dir}../../perlasm/ppc-xlate.pl" and -f $xlate) or
|
||||
@@ -62,7 +65,7 @@ die "can't locate ppc-xlate.pl";
|
||||
open STDOUT,"| $^X $xlate $flavour $output" || die "can't call $xlate: $!";
|
||||
|
||||
if ($output =~ /512/) {
|
||||
$func="sha512_block_data_order";
|
||||
$func="sha512_block_ppc";
|
||||
$SZ=8;
|
||||
@Sigma0=(28,34,39);
|
||||
@Sigma1=(14,18,41);
|
||||
@@ -74,7 +77,7 @@ if ($output =~ /512/) {
|
||||
$ROR="rotrdi";
|
||||
$SHR="srdi";
|
||||
} else {
|
||||
$func="sha256_block_data_order";
|
||||
$func="sha256_block_ppc";
|
||||
$SZ=4;
|
||||
@Sigma0=( 2,13,22);
|
||||
@Sigma1=( 6,11,25);
|
||||
@@ -87,7 +90,8 @@ if ($output =~ /512/) {
|
||||
$SHR="srwi";
|
||||
}
|
||||
|
||||
$FRAME=32*$SIZE_T;
|
||||
$FRAME=32*$SIZE_T+16*$SZ;
|
||||
$LOCALS=6*$SIZE_T;
|
||||
|
||||
$sp ="r1";
|
||||
$toc="r2";
|
||||
@@ -107,7 +111,7 @@ $B ="r9";
|
||||
$C ="r10";
|
||||
$D ="r11";
|
||||
$E ="r12";
|
||||
$F ="r13"; $F="r2" if ($SIZE_T==8);# reassigned to exempt TLS pointer
|
||||
$F =$t1; $t1 = "r0"; # stay away from "r13";
|
||||
$G ="r14";
|
||||
$H ="r15";
|
||||
|
||||
@@ -115,24 +119,23 @@ $H ="r15";
|
||||
@X=("r16","r17","r18","r19","r20","r21","r22","r23",
|
||||
"r24","r25","r26","r27","r28","r29","r30","r31");
|
||||
|
||||
$inp="r31"; # reassigned $inp! aliases with @X[15]
|
||||
$inp="r31" if($SZ==4 || $SIZE_T==8); # reassigned $inp! aliases with @X[15]
|
||||
|
||||
sub ROUND_00_15 {
|
||||
my ($i,$a,$b,$c,$d,$e,$f,$g,$h)=@_;
|
||||
$code.=<<___;
|
||||
$LD $T,`$i*$SZ`($Tbl)
|
||||
$ROR $a0,$e,$Sigma1[0]
|
||||
$ROR $a1,$e,$Sigma1[1]
|
||||
and $t0,$f,$e
|
||||
andc $t1,$g,$e
|
||||
add $T,$T,$h
|
||||
xor $a0,$a0,$a1
|
||||
add $h,$h,$t1
|
||||
andc $t1,$g,$e
|
||||
$ROR $a1,$a1,`$Sigma1[2]-$Sigma1[1]`
|
||||
or $t0,$t0,$t1 ; Ch(e,f,g)
|
||||
add $T,$T,@X[$i]
|
||||
add $h,$h,@X[$i%16]
|
||||
xor $a0,$a0,$a1 ; Sigma1(e)
|
||||
add $T,$T,$t0
|
||||
add $T,$T,$a0
|
||||
add $h,$h,$t0
|
||||
add $h,$h,$a0
|
||||
|
||||
$ROR $a0,$a,$Sigma0[0]
|
||||
$ROR $a1,$a,$Sigma0[1]
|
||||
@@ -143,9 +146,14 @@ $code.=<<___;
|
||||
xor $t0,$t0,$t1
|
||||
and $t1,$b,$c
|
||||
xor $a0,$a0,$a1 ; Sigma0(a)
|
||||
add $d,$d,$T
|
||||
add $d,$d,$h
|
||||
xor $t0,$t0,$t1 ; Maj(a,b,c)
|
||||
add $h,$T,$a0
|
||||
___
|
||||
$code.=<<___ if ($i<15);
|
||||
$LD $t1,`($i+1)*$SZ`($Tbl)
|
||||
___
|
||||
$code.=<<___;
|
||||
add $h,$h,$a0
|
||||
add $h,$h,$t0
|
||||
|
||||
___
|
||||
@@ -166,10 +174,11 @@ $code.=<<___;
|
||||
add @X[$i],@X[$i],@X[($i+9)%16]
|
||||
xor $a0,$a0,$a1 ; sigma0(X[(i+1)&0x0f])
|
||||
xor $t0,$t0,$t1 ; sigma1(X[(i+14)&0x0f])
|
||||
$LD $t1,`$i*$SZ`($Tbl)
|
||||
add @X[$i],@X[$i],$a0
|
||||
add @X[$i],@X[$i],$t0
|
||||
___
|
||||
&ROUND_00_15($i,$a,$b,$c,$d,$e,$f,$g,$h);
|
||||
&ROUND_00_15($i+16,$a,$b,$c,$d,$e,$f,$g,$h);
|
||||
}
|
||||
|
||||
$code=<<___;
|
||||
@@ -179,15 +188,12 @@ $code=<<___;
|
||||
.globl $func
|
||||
.align 6
|
||||
$func:
|
||||
$STU $sp,-$FRAME($sp)
|
||||
mflr r0
|
||||
$STU $sp,`-($FRAME+16*$SZ)`($sp)
|
||||
$SHL $num,$num,`log(16*$SZ)/log(2)`
|
||||
|
||||
$PUSH $ctx,`$FRAME-$SIZE_T*22`($sp)
|
||||
|
||||
$PUSH r0,`$FRAME-$SIZE_T*21`($sp)
|
||||
$PUSH $toc,`$FRAME-$SIZE_T*20`($sp)
|
||||
$PUSH r13,`$FRAME-$SIZE_T*19`($sp)
|
||||
$PUSH r14,`$FRAME-$SIZE_T*18`($sp)
|
||||
$PUSH r15,`$FRAME-$SIZE_T*17`($sp)
|
||||
$PUSH r16,`$FRAME-$SIZE_T*16`($sp)
|
||||
@@ -206,7 +212,11 @@ $func:
|
||||
$PUSH r29,`$FRAME-$SIZE_T*3`($sp)
|
||||
$PUSH r30,`$FRAME-$SIZE_T*2`($sp)
|
||||
$PUSH r31,`$FRAME-$SIZE_T*1`($sp)
|
||||
$PUSH r0,`$FRAME+$LRSAVE`($sp)
|
||||
___
|
||||
|
||||
if ($SZ==4 || $SIZE_T==8) {
|
||||
$code.=<<___;
|
||||
$LD $A,`0*$SZ`($ctx)
|
||||
mr $inp,r4 ; incarnate $inp
|
||||
$LD $B,`1*$SZ`($ctx)
|
||||
@@ -216,8 +226,17 @@ $func:
|
||||
$LD $F,`5*$SZ`($ctx)
|
||||
$LD $G,`6*$SZ`($ctx)
|
||||
$LD $H,`7*$SZ`($ctx)
|
||||
___
|
||||
} else {
|
||||
for ($i=16;$i<32;$i++) {
|
||||
$code.=<<___;
|
||||
lwz r$i,`$LITTLE_ENDIAN^(4*($i-16))`($ctx)
|
||||
___
|
||||
}
|
||||
}
|
||||
|
||||
b LPICmeup
|
||||
$code.=<<___;
|
||||
bl LPICmeup
|
||||
LPICedup:
|
||||
andi. r0,$inp,3
|
||||
bne Lunaligned
|
||||
@@ -226,10 +245,82 @@ Laligned:
|
||||
$PUSH $num,`$FRAME-$SIZE_T*24`($sp) ; end pointer
|
||||
$PUSH $inp,`$FRAME-$SIZE_T*23`($sp) ; inp pointer
|
||||
bl Lsha2_block_private
|
||||
b Ldone
|
||||
|
||||
; PowerPC specification allows an implementation to be ill-behaved
|
||||
; upon unaligned access which crosses page boundary. "Better safe
|
||||
; than sorry" principle makes me treat it specially. But I don't
|
||||
; look for particular offending word, but rather for the input
|
||||
; block which crosses the boundary. Once found that block is aligned
|
||||
; and hashed separately...
|
||||
.align 4
|
||||
Lunaligned:
|
||||
subfic $t1,$inp,4096
|
||||
andi. $t1,$t1,`4096-16*$SZ` ; distance to closest page boundary
|
||||
beq Lcross_page
|
||||
$UCMP $num,$t1
|
||||
ble- Laligned ; didn't cross the page boundary
|
||||
subfc $num,$t1,$num
|
||||
add $t1,$inp,$t1
|
||||
$PUSH $num,`$FRAME-$SIZE_T*25`($sp) ; save real remaining num
|
||||
$PUSH $t1,`$FRAME-$SIZE_T*24`($sp) ; intermediate end pointer
|
||||
$PUSH $inp,`$FRAME-$SIZE_T*23`($sp) ; inp pointer
|
||||
bl Lsha2_block_private
|
||||
; $inp equals to the intermediate end pointer here
|
||||
$POP $num,`$FRAME-$SIZE_T*25`($sp) ; restore real remaining num
|
||||
Lcross_page:
|
||||
li $t1,`16*$SZ/4`
|
||||
mtctr $t1
|
||||
___
|
||||
if ($SZ==4 || $SIZE_T==8) {
|
||||
$code.=<<___;
|
||||
addi r20,$sp,$LOCALS ; aligned spot below the frame
|
||||
Lmemcpy:
|
||||
lbz r16,0($inp)
|
||||
lbz r17,1($inp)
|
||||
lbz r18,2($inp)
|
||||
lbz r19,3($inp)
|
||||
addi $inp,$inp,4
|
||||
stb r16,0(r20)
|
||||
stb r17,1(r20)
|
||||
stb r18,2(r20)
|
||||
stb r19,3(r20)
|
||||
addi r20,r20,4
|
||||
bdnz Lmemcpy
|
||||
___
|
||||
} else {
|
||||
$code.=<<___;
|
||||
addi r12,$sp,$LOCALS ; aligned spot below the frame
|
||||
Lmemcpy:
|
||||
lbz r8,0($inp)
|
||||
lbz r9,1($inp)
|
||||
lbz r10,2($inp)
|
||||
lbz r11,3($inp)
|
||||
addi $inp,$inp,4
|
||||
stb r8,0(r12)
|
||||
stb r9,1(r12)
|
||||
stb r10,2(r12)
|
||||
stb r11,3(r12)
|
||||
addi r12,r12,4
|
||||
bdnz Lmemcpy
|
||||
___
|
||||
}
|
||||
|
||||
$code.=<<___;
|
||||
$PUSH $inp,`$FRAME-$SIZE_T*26`($sp) ; save real inp
|
||||
addi $t1,$sp,`$LOCALS+16*$SZ` ; fictitious end pointer
|
||||
addi $inp,$sp,$LOCALS ; fictitious inp pointer
|
||||
$PUSH $num,`$FRAME-$SIZE_T*25`($sp) ; save real num
|
||||
$PUSH $t1,`$FRAME-$SIZE_T*24`($sp) ; end pointer
|
||||
$PUSH $inp,`$FRAME-$SIZE_T*23`($sp) ; inp pointer
|
||||
bl Lsha2_block_private
|
||||
$POP $inp,`$FRAME-$SIZE_T*26`($sp) ; restore real inp
|
||||
$POP $num,`$FRAME-$SIZE_T*25`($sp) ; restore real num
|
||||
addic. $num,$num,`-16*$SZ` ; num--
|
||||
bne- Lunaligned
|
||||
|
||||
Ldone:
|
||||
$POP r0,`$FRAME-$SIZE_T*21`($sp)
|
||||
$POP $toc,`$FRAME-$SIZE_T*20`($sp)
|
||||
$POP r13,`$FRAME-$SIZE_T*19`($sp)
|
||||
$POP r0,`$FRAME+$LRSAVE`($sp)
|
||||
$POP r14,`$FRAME-$SIZE_T*18`($sp)
|
||||
$POP r15,`$FRAME-$SIZE_T*17`($sp)
|
||||
$POP r16,`$FRAME-$SIZE_T*16`($sp)
|
||||
@@ -249,84 +340,53 @@ Ldone:
|
||||
$POP r30,`$FRAME-$SIZE_T*2`($sp)
|
||||
$POP r31,`$FRAME-$SIZE_T*1`($sp)
|
||||
mtlr r0
|
||||
addi $sp,$sp,`$FRAME+16*$SZ`
|
||||
addi $sp,$sp,$FRAME
|
||||
blr
|
||||
.long 0
|
||||
.byte 0,12,4,1,0x80,18,3,0
|
||||
.long 0
|
||||
___
|
||||
|
||||
# PowerPC specification allows an implementation to be ill-behaved
|
||||
# upon unaligned access which crosses page boundary. "Better safe
|
||||
# than sorry" principle makes me treat it specially. But I don't
|
||||
# look for particular offending word, but rather for the input
|
||||
# block which crosses the boundary. Once found that block is aligned
|
||||
# and hashed separately...
|
||||
$code.=<<___;
|
||||
.align 4
|
||||
Lunaligned:
|
||||
subfic $t1,$inp,4096
|
||||
andi. $t1,$t1,`4096-16*$SZ` ; distance to closest page boundary
|
||||
beq Lcross_page
|
||||
$UCMP $num,$t1
|
||||
ble- Laligned ; didn't cross the page boundary
|
||||
subfc $num,$t1,$num
|
||||
add $t1,$inp,$t1
|
||||
$PUSH $num,`$FRAME-$SIZE_T*25`($sp) ; save real remaining num
|
||||
$PUSH $t1,`$FRAME-$SIZE_T*24`($sp) ; intermediate end pointer
|
||||
$PUSH $inp,`$FRAME-$SIZE_T*23`($sp) ; inp pointer
|
||||
bl Lsha2_block_private
|
||||
; $inp equals to the intermediate end pointer here
|
||||
$POP $num,`$FRAME-$SIZE_T*25`($sp) ; restore real remaining num
|
||||
Lcross_page:
|
||||
li $t1,`16*$SZ/4`
|
||||
mtctr $t1
|
||||
addi r20,$sp,$FRAME ; aligned spot below the frame
|
||||
Lmemcpy:
|
||||
lbz r16,0($inp)
|
||||
lbz r17,1($inp)
|
||||
lbz r18,2($inp)
|
||||
lbz r19,3($inp)
|
||||
addi $inp,$inp,4
|
||||
stb r16,0(r20)
|
||||
stb r17,1(r20)
|
||||
stb r18,2(r20)
|
||||
stb r19,3(r20)
|
||||
addi r20,r20,4
|
||||
bdnz Lmemcpy
|
||||
|
||||
$PUSH $inp,`$FRAME-$SIZE_T*26`($sp) ; save real inp
|
||||
addi $t1,$sp,`$FRAME+16*$SZ` ; fictitious end pointer
|
||||
addi $inp,$sp,$FRAME ; fictitious inp pointer
|
||||
$PUSH $num,`$FRAME-$SIZE_T*25`($sp) ; save real num
|
||||
$PUSH $t1,`$FRAME-$SIZE_T*24`($sp) ; end pointer
|
||||
$PUSH $inp,`$FRAME-$SIZE_T*23`($sp) ; inp pointer
|
||||
bl Lsha2_block_private
|
||||
$POP $inp,`$FRAME-$SIZE_T*26`($sp) ; restore real inp
|
||||
$POP $num,`$FRAME-$SIZE_T*25`($sp) ; restore real num
|
||||
addic. $num,$num,`-16*$SZ` ; num--
|
||||
bne- Lunaligned
|
||||
b Ldone
|
||||
___
|
||||
|
||||
if ($SZ==4 || $SIZE_T==8) {
|
||||
$code.=<<___;
|
||||
.align 4
|
||||
Lsha2_block_private:
|
||||
$LD $t1,0($Tbl)
|
||||
___
|
||||
for($i=0;$i<16;$i++) {
|
||||
$code.=<<___ if ($SZ==4);
|
||||
$code.=<<___ if ($SZ==4 && !$LITTLE_ENDIAN);
|
||||
lwz @X[$i],`$i*$SZ`($inp)
|
||||
___
|
||||
$code.=<<___ if ($SZ==4 && $LITTLE_ENDIAN);
|
||||
lwz $a0,`$i*$SZ`($inp)
|
||||
rotlwi @X[$i],$a0,8
|
||||
rlwimi @X[$i],$a0,24,0,7
|
||||
rlwimi @X[$i],$a0,24,16,23
|
||||
___
|
||||
# 64-bit loads are split to 2x32-bit ones, as CPU can't handle
|
||||
# unaligned 64-bit loads, only 32-bit ones...
|
||||
$code.=<<___ if ($SZ==8);
|
||||
$code.=<<___ if ($SZ==8 && !$LITTLE_ENDIAN);
|
||||
lwz $t0,`$i*$SZ`($inp)
|
||||
lwz @X[$i],`$i*$SZ+4`($inp)
|
||||
insrdi @X[$i],$t0,32,0
|
||||
___
|
||||
$code.=<<___ if ($SZ==8 && $LITTLE_ENDIAN);
|
||||
lwz $a0,`$i*$SZ`($inp)
|
||||
lwz $a1,`$i*$SZ+4`($inp)
|
||||
rotlwi $t0,$a0,8
|
||||
rotlwi @X[$i],$a1,8
|
||||
rlwimi $t0,$a0,24,0,7
|
||||
rlwimi @X[$i],$a1,24,0,7
|
||||
rlwimi $t0,$a0,24,16,23
|
||||
rlwimi @X[$i],$a1,24,16,23
|
||||
insrdi @X[$i],$t0,32,0
|
||||
___
|
||||
&ROUND_00_15($i,@V);
|
||||
unshift(@V,pop(@V));
|
||||
}
|
||||
$code.=<<___;
|
||||
li $T,`$rounds/16-1`
|
||||
mtctr $T
|
||||
li $t0,`$rounds/16-1`
|
||||
mtctr $t0
|
||||
.align 4
|
||||
Lrounds:
|
||||
addi $Tbl,$Tbl,`16*$SZ`
|
||||
@@ -372,71 +432,341 @@ $code.=<<___;
|
||||
$ST $H,`7*$SZ`($ctx)
|
||||
bne Lsha2_block_private
|
||||
blr
|
||||
.long 0
|
||||
.byte 0,12,0x14,0,0,0,0,0
|
||||
.size $func,.-$func
|
||||
___
|
||||
} else {
|
||||
########################################################################
|
||||
# SHA512 for PPC32, X vector is off-loaded to stack...
|
||||
#
|
||||
# | sha512
|
||||
# | -m32
|
||||
# ----------------------+-----------------------
|
||||
# PPC74x0,gcc-4.0.1 | +48%
|
||||
# POWER6,gcc-4.4.6 | +124%(*)
|
||||
# POWER7,gcc-4.4.6 | +79%(*)
|
||||
# e300,gcc-4.1.0 | +167%
|
||||
#
|
||||
# (*) ~1/3 of -m64 result [and ~20% better than -m32 code generated
|
||||
# by xlc-12.1]
|
||||
|
||||
my $XOFF=$LOCALS;
|
||||
|
||||
my @V=map("r$_",(16..31)); # A..H
|
||||
|
||||
my ($s0,$s1,$t0,$t1,$t2,$t3,$a0,$a1,$a2,$a3)=map("r$_",(0,5,6,8..12,14,15));
|
||||
my ($x0,$x1)=("r3","r4"); # zaps $ctx and $inp
|
||||
|
||||
sub ROUND_00_15_ppc32 {
|
||||
my ($i, $ahi,$alo,$bhi,$blo,$chi,$clo,$dhi,$dlo,
|
||||
$ehi,$elo,$fhi,$flo,$ghi,$glo,$hhi,$hlo)=@_;
|
||||
|
||||
$code.=<<___;
|
||||
lwz $t2,`$SZ*($i%16)+($LITTLE_ENDIAN^4)`($Tbl)
|
||||
xor $a0,$flo,$glo
|
||||
lwz $t3,`$SZ*($i%16)+($LITTLE_ENDIAN^0)`($Tbl)
|
||||
xor $a1,$fhi,$ghi
|
||||
addc $hlo,$hlo,$t0 ; h+=x[i]
|
||||
stw $t0,`$XOFF+0+$SZ*($i%16)`($sp) ; save x[i]
|
||||
|
||||
srwi $s0,$elo,$Sigma1[0]
|
||||
srwi $s1,$ehi,$Sigma1[0]
|
||||
and $a0,$a0,$elo
|
||||
adde $hhi,$hhi,$t1
|
||||
and $a1,$a1,$ehi
|
||||
stw $t1,`$XOFF+4+$SZ*($i%16)`($sp)
|
||||
srwi $t0,$elo,$Sigma1[1]
|
||||
srwi $t1,$ehi,$Sigma1[1]
|
||||
addc $hlo,$hlo,$t2 ; h+=K512[i]
|
||||
insrwi $s0,$ehi,$Sigma1[0],0
|
||||
insrwi $s1,$elo,$Sigma1[0],0
|
||||
xor $a0,$a0,$glo ; Ch(e,f,g)
|
||||
adde $hhi,$hhi,$t3
|
||||
xor $a1,$a1,$ghi
|
||||
insrwi $t0,$ehi,$Sigma1[1],0
|
||||
insrwi $t1,$elo,$Sigma1[1],0
|
||||
addc $hlo,$hlo,$a0 ; h+=Ch(e,f,g)
|
||||
srwi $t2,$ehi,$Sigma1[2]-32
|
||||
srwi $t3,$elo,$Sigma1[2]-32
|
||||
xor $s0,$s0,$t0
|
||||
xor $s1,$s1,$t1
|
||||
insrwi $t2,$elo,$Sigma1[2]-32,0
|
||||
insrwi $t3,$ehi,$Sigma1[2]-32,0
|
||||
xor $a0,$alo,$blo ; a^b, b^c in next round
|
||||
adde $hhi,$hhi,$a1
|
||||
xor $a1,$ahi,$bhi
|
||||
xor $s0,$s0,$t2 ; Sigma1(e)
|
||||
xor $s1,$s1,$t3
|
||||
|
||||
srwi $t0,$alo,$Sigma0[0]
|
||||
and $a2,$a2,$a0
|
||||
addc $hlo,$hlo,$s0 ; h+=Sigma1(e)
|
||||
and $a3,$a3,$a1
|
||||
srwi $t1,$ahi,$Sigma0[0]
|
||||
srwi $s0,$ahi,$Sigma0[1]-32
|
||||
adde $hhi,$hhi,$s1
|
||||
srwi $s1,$alo,$Sigma0[1]-32
|
||||
insrwi $t0,$ahi,$Sigma0[0],0
|
||||
insrwi $t1,$alo,$Sigma0[0],0
|
||||
xor $a2,$a2,$blo ; Maj(a,b,c)
|
||||
addc $dlo,$dlo,$hlo ; d+=h
|
||||
xor $a3,$a3,$bhi
|
||||
insrwi $s0,$alo,$Sigma0[1]-32,0
|
||||
insrwi $s1,$ahi,$Sigma0[1]-32,0
|
||||
adde $dhi,$dhi,$hhi
|
||||
srwi $t2,$ahi,$Sigma0[2]-32
|
||||
srwi $t3,$alo,$Sigma0[2]-32
|
||||
xor $s0,$s0,$t0
|
||||
addc $hlo,$hlo,$a2 ; h+=Maj(a,b,c)
|
||||
xor $s1,$s1,$t1
|
||||
insrwi $t2,$alo,$Sigma0[2]-32,0
|
||||
insrwi $t3,$ahi,$Sigma0[2]-32,0
|
||||
adde $hhi,$hhi,$a3
|
||||
___
|
||||
$code.=<<___ if ($i>=15);
|
||||
lwz $t0,`$XOFF+0+$SZ*(($i+2)%16)`($sp)
|
||||
lwz $t1,`$XOFF+4+$SZ*(($i+2)%16)`($sp)
|
||||
___
|
||||
$code.=<<___ if ($i<15 && !$LITTLE_ENDIAN);
|
||||
lwz $t1,`$SZ*($i+1)+0`($inp)
|
||||
lwz $t0,`$SZ*($i+1)+4`($inp)
|
||||
___
|
||||
$code.=<<___ if ($i<15 && $LITTLE_ENDIAN);
|
||||
lwz $a2,`$SZ*($i+1)+0`($inp)
|
||||
lwz $a3,`$SZ*($i+1)+4`($inp)
|
||||
rotlwi $t1,$a2,8
|
||||
rotlwi $t0,$a3,8
|
||||
rlwimi $t1,$a2,24,0,7
|
||||
rlwimi $t0,$a3,24,0,7
|
||||
rlwimi $t1,$a2,24,16,23
|
||||
rlwimi $t0,$a3,24,16,23
|
||||
___
|
||||
$code.=<<___;
|
||||
xor $s0,$s0,$t2 ; Sigma0(a)
|
||||
xor $s1,$s1,$t3
|
||||
addc $hlo,$hlo,$s0 ; h+=Sigma0(a)
|
||||
adde $hhi,$hhi,$s1
|
||||
___
|
||||
$code.=<<___ if ($i==15);
|
||||
lwz $x0,`$XOFF+0+$SZ*(($i+1)%16)`($sp)
|
||||
lwz $x1,`$XOFF+4+$SZ*(($i+1)%16)`($sp)
|
||||
___
|
||||
}
|
||||
sub ROUND_16_xx_ppc32 {
|
||||
my ($i, $ahi,$alo,$bhi,$blo,$chi,$clo,$dhi,$dlo,
|
||||
$ehi,$elo,$fhi,$flo,$ghi,$glo,$hhi,$hlo)=@_;
|
||||
|
||||
$code.=<<___;
|
||||
srwi $s0,$t0,$sigma0[0]
|
||||
srwi $s1,$t1,$sigma0[0]
|
||||
srwi $t2,$t0,$sigma0[1]
|
||||
srwi $t3,$t1,$sigma0[1]
|
||||
insrwi $s0,$t1,$sigma0[0],0
|
||||
insrwi $s1,$t0,$sigma0[0],0
|
||||
srwi $a0,$t0,$sigma0[2]
|
||||
insrwi $t2,$t1,$sigma0[1],0
|
||||
insrwi $t3,$t0,$sigma0[1],0
|
||||
insrwi $a0,$t1,$sigma0[2],0
|
||||
xor $s0,$s0,$t2
|
||||
lwz $t2,`$XOFF+0+$SZ*(($i+14)%16)`($sp)
|
||||
srwi $a1,$t1,$sigma0[2]
|
||||
xor $s1,$s1,$t3
|
||||
lwz $t3,`$XOFF+4+$SZ*(($i+14)%16)`($sp)
|
||||
xor $a0,$a0,$s0
|
||||
srwi $s0,$t2,$sigma1[0]
|
||||
xor $a1,$a1,$s1
|
||||
srwi $s1,$t3,$sigma1[0]
|
||||
addc $x0,$x0,$a0 ; x[i]+=sigma0(x[i+1])
|
||||
srwi $a0,$t3,$sigma1[1]-32
|
||||
insrwi $s0,$t3,$sigma1[0],0
|
||||
insrwi $s1,$t2,$sigma1[0],0
|
||||
adde $x1,$x1,$a1
|
||||
srwi $a1,$t2,$sigma1[1]-32
|
||||
|
||||
insrwi $a0,$t2,$sigma1[1]-32,0
|
||||
srwi $t2,$t2,$sigma1[2]
|
||||
insrwi $a1,$t3,$sigma1[1]-32,0
|
||||
insrwi $t2,$t3,$sigma1[2],0
|
||||
xor $s0,$s0,$a0
|
||||
lwz $a0,`$XOFF+0+$SZ*(($i+9)%16)`($sp)
|
||||
srwi $t3,$t3,$sigma1[2]
|
||||
xor $s1,$s1,$a1
|
||||
lwz $a1,`$XOFF+4+$SZ*(($i+9)%16)`($sp)
|
||||
xor $s0,$s0,$t2
|
||||
addc $x0,$x0,$a0 ; x[i]+=x[i+9]
|
||||
xor $s1,$s1,$t3
|
||||
adde $x1,$x1,$a1
|
||||
addc $x0,$x0,$s0 ; x[i]+=sigma1(x[i+14])
|
||||
adde $x1,$x1,$s1
|
||||
___
|
||||
($t0,$t1,$x0,$x1) = ($x0,$x1,$t0,$t1);
|
||||
&ROUND_00_15_ppc32(@_);
|
||||
}
|
||||
|
||||
$code.=<<___;
|
||||
.align 4
|
||||
Lsha2_block_private:
|
||||
___
|
||||
$code.=<<___ if (!$LITTLE_ENDIAN);
|
||||
lwz $t1,0($inp)
|
||||
xor $a2,@V[3],@V[5] ; B^C, magic seed
|
||||
lwz $t0,4($inp)
|
||||
xor $a3,@V[2],@V[4]
|
||||
___
|
||||
$code.=<<___ if ($LITTLE_ENDIAN);
|
||||
lwz $a1,0($inp)
|
||||
xor $a2,@V[3],@V[5] ; B^C, magic seed
|
||||
lwz $a0,4($inp)
|
||||
xor $a3,@V[2],@V[4]
|
||||
rotlwi $t1,$a1,8
|
||||
rotlwi $t0,$a0,8
|
||||
rlwimi $t1,$a1,24,0,7
|
||||
rlwimi $t0,$a0,24,0,7
|
||||
rlwimi $t1,$a1,24,16,23
|
||||
rlwimi $t0,$a0,24,16,23
|
||||
___
|
||||
for($i=0;$i<16;$i++) {
|
||||
&ROUND_00_15_ppc32($i,@V);
|
||||
unshift(@V,pop(@V)); unshift(@V,pop(@V));
|
||||
($a0,$a1,$a2,$a3) = ($a2,$a3,$a0,$a1);
|
||||
}
|
||||
$code.=<<___;
|
||||
li $a0,`$rounds/16-1`
|
||||
mtctr $a0
|
||||
.align 4
|
||||
Lrounds:
|
||||
addi $Tbl,$Tbl,`16*$SZ`
|
||||
___
|
||||
for(;$i<32;$i++) {
|
||||
&ROUND_16_xx_ppc32($i,@V);
|
||||
unshift(@V,pop(@V)); unshift(@V,pop(@V));
|
||||
($a0,$a1,$a2,$a3) = ($a2,$a3,$a0,$a1);
|
||||
}
|
||||
$code.=<<___;
|
||||
bdnz- Lrounds
|
||||
|
||||
$POP $ctx,`$FRAME-$SIZE_T*22`($sp)
|
||||
$POP $inp,`$FRAME-$SIZE_T*23`($sp) ; inp pointer
|
||||
$POP $num,`$FRAME-$SIZE_T*24`($sp) ; end pointer
|
||||
subi $Tbl,$Tbl,`($rounds-16)*$SZ` ; rewind Tbl
|
||||
|
||||
lwz $t0,`$LITTLE_ENDIAN^0`($ctx)
|
||||
lwz $t1,`$LITTLE_ENDIAN^4`($ctx)
|
||||
lwz $t2,`$LITTLE_ENDIAN^8`($ctx)
|
||||
lwz $t3,`$LITTLE_ENDIAN^12`($ctx)
|
||||
lwz $a0,`$LITTLE_ENDIAN^16`($ctx)
|
||||
lwz $a1,`$LITTLE_ENDIAN^20`($ctx)
|
||||
lwz $a2,`$LITTLE_ENDIAN^24`($ctx)
|
||||
addc @V[1],@V[1],$t1
|
||||
lwz $a3,`$LITTLE_ENDIAN^28`($ctx)
|
||||
adde @V[0],@V[0],$t0
|
||||
lwz $t0,`$LITTLE_ENDIAN^32`($ctx)
|
||||
addc @V[3],@V[3],$t3
|
||||
lwz $t1,`$LITTLE_ENDIAN^36`($ctx)
|
||||
adde @V[2],@V[2],$t2
|
||||
lwz $t2,`$LITTLE_ENDIAN^40`($ctx)
|
||||
addc @V[5],@V[5],$a1
|
||||
lwz $t3,`$LITTLE_ENDIAN^44`($ctx)
|
||||
adde @V[4],@V[4],$a0
|
||||
lwz $a0,`$LITTLE_ENDIAN^48`($ctx)
|
||||
addc @V[7],@V[7],$a3
|
||||
lwz $a1,`$LITTLE_ENDIAN^52`($ctx)
|
||||
adde @V[6],@V[6],$a2
|
||||
lwz $a2,`$LITTLE_ENDIAN^56`($ctx)
|
||||
addc @V[9],@V[9],$t1
|
||||
lwz $a3,`$LITTLE_ENDIAN^60`($ctx)
|
||||
adde @V[8],@V[8],$t0
|
||||
stw @V[0],`$LITTLE_ENDIAN^0`($ctx)
|
||||
stw @V[1],`$LITTLE_ENDIAN^4`($ctx)
|
||||
addc @V[11],@V[11],$t3
|
||||
stw @V[2],`$LITTLE_ENDIAN^8`($ctx)
|
||||
stw @V[3],`$LITTLE_ENDIAN^12`($ctx)
|
||||
adde @V[10],@V[10],$t2
|
||||
stw @V[4],`$LITTLE_ENDIAN^16`($ctx)
|
||||
stw @V[5],`$LITTLE_ENDIAN^20`($ctx)
|
||||
addc @V[13],@V[13],$a1
|
||||
stw @V[6],`$LITTLE_ENDIAN^24`($ctx)
|
||||
stw @V[7],`$LITTLE_ENDIAN^28`($ctx)
|
||||
adde @V[12],@V[12],$a0
|
||||
stw @V[8],`$LITTLE_ENDIAN^32`($ctx)
|
||||
stw @V[9],`$LITTLE_ENDIAN^36`($ctx)
|
||||
addc @V[15],@V[15],$a3
|
||||
stw @V[10],`$LITTLE_ENDIAN^40`($ctx)
|
||||
stw @V[11],`$LITTLE_ENDIAN^44`($ctx)
|
||||
adde @V[14],@V[14],$a2
|
||||
stw @V[12],`$LITTLE_ENDIAN^48`($ctx)
|
||||
stw @V[13],`$LITTLE_ENDIAN^52`($ctx)
|
||||
stw @V[14],`$LITTLE_ENDIAN^56`($ctx)
|
||||
stw @V[15],`$LITTLE_ENDIAN^60`($ctx)
|
||||
|
||||
addi $inp,$inp,`16*$SZ` ; advance inp
|
||||
$PUSH $inp,`$FRAME-$SIZE_T*23`($sp)
|
||||
$UCMP $inp,$num
|
||||
bne Lsha2_block_private
|
||||
blr
|
||||
.long 0
|
||||
.byte 0,12,0x14,0,0,0,0,0
|
||||
.size $func,.-$func
|
||||
___
|
||||
}
|
||||
|
||||
# Ugly hack here, because PPC assembler syntax seem to vary too
|
||||
# much from platforms to platform...
|
||||
$code.=<<___;
|
||||
.align 6
|
||||
LPICmeup:
|
||||
bl LPIC
|
||||
addi $Tbl,$Tbl,`64-4` ; "distance" between . and last nop
|
||||
b LPICedup
|
||||
nop
|
||||
nop
|
||||
nop
|
||||
nop
|
||||
nop
|
||||
LPIC: mflr $Tbl
|
||||
mflr r0
|
||||
bcl 20,31,\$+4
|
||||
mflr $Tbl ; vvvvvv "distance" between . and 1st data entry
|
||||
addi $Tbl,$Tbl,`64-8`
|
||||
mtlr r0
|
||||
blr
|
||||
nop
|
||||
nop
|
||||
nop
|
||||
nop
|
||||
nop
|
||||
nop
|
||||
.long 0
|
||||
.byte 0,12,0x14,0,0,0,0,0
|
||||
.space `64-9*4`
|
||||
___
|
||||
$code.=<<___ if ($SZ==8);
|
||||
.long 0x428a2f98,0xd728ae22,0x71374491,0x23ef65cd
|
||||
.long 0xb5c0fbcf,0xec4d3b2f,0xe9b5dba5,0x8189dbbc
|
||||
.long 0x3956c25b,0xf348b538,0x59f111f1,0xb605d019
|
||||
.long 0x923f82a4,0xaf194f9b,0xab1c5ed5,0xda6d8118
|
||||
.long 0xd807aa98,0xa3030242,0x12835b01,0x45706fbe
|
||||
.long 0x243185be,0x4ee4b28c,0x550c7dc3,0xd5ffb4e2
|
||||
.long 0x72be5d74,0xf27b896f,0x80deb1fe,0x3b1696b1
|
||||
.long 0x9bdc06a7,0x25c71235,0xc19bf174,0xcf692694
|
||||
.long 0xe49b69c1,0x9ef14ad2,0xefbe4786,0x384f25e3
|
||||
.long 0x0fc19dc6,0x8b8cd5b5,0x240ca1cc,0x77ac9c65
|
||||
.long 0x2de92c6f,0x592b0275,0x4a7484aa,0x6ea6e483
|
||||
.long 0x5cb0a9dc,0xbd41fbd4,0x76f988da,0x831153b5
|
||||
.long 0x983e5152,0xee66dfab,0xa831c66d,0x2db43210
|
||||
.long 0xb00327c8,0x98fb213f,0xbf597fc7,0xbeef0ee4
|
||||
.long 0xc6e00bf3,0x3da88fc2,0xd5a79147,0x930aa725
|
||||
.long 0x06ca6351,0xe003826f,0x14292967,0x0a0e6e70
|
||||
.long 0x27b70a85,0x46d22ffc,0x2e1b2138,0x5c26c926
|
||||
.long 0x4d2c6dfc,0x5ac42aed,0x53380d13,0x9d95b3df
|
||||
.long 0x650a7354,0x8baf63de,0x766a0abb,0x3c77b2a8
|
||||
.long 0x81c2c92e,0x47edaee6,0x92722c85,0x1482353b
|
||||
.long 0xa2bfe8a1,0x4cf10364,0xa81a664b,0xbc423001
|
||||
.long 0xc24b8b70,0xd0f89791,0xc76c51a3,0x0654be30
|
||||
.long 0xd192e819,0xd6ef5218,0xd6990624,0x5565a910
|
||||
.long 0xf40e3585,0x5771202a,0x106aa070,0x32bbd1b8
|
||||
.long 0x19a4c116,0xb8d2d0c8,0x1e376c08,0x5141ab53
|
||||
.long 0x2748774c,0xdf8eeb99,0x34b0bcb5,0xe19b48a8
|
||||
.long 0x391c0cb3,0xc5c95a63,0x4ed8aa4a,0xe3418acb
|
||||
.long 0x5b9cca4f,0x7763e373,0x682e6ff3,0xd6b2b8a3
|
||||
.long 0x748f82ee,0x5defb2fc,0x78a5636f,0x43172f60
|
||||
.long 0x84c87814,0xa1f0ab72,0x8cc70208,0x1a6439ec
|
||||
.long 0x90befffa,0x23631e28,0xa4506ceb,0xde82bde9
|
||||
.long 0xbef9a3f7,0xb2c67915,0xc67178f2,0xe372532b
|
||||
.long 0xca273ece,0xea26619c,0xd186b8c7,0x21c0c207
|
||||
.long 0xeada7dd6,0xcde0eb1e,0xf57d4f7f,0xee6ed178
|
||||
.long 0x06f067aa,0x72176fba,0x0a637dc5,0xa2c898a6
|
||||
.long 0x113f9804,0xbef90dae,0x1b710b35,0x131c471b
|
||||
.long 0x28db77f5,0x23047d84,0x32caab7b,0x40c72493
|
||||
.long 0x3c9ebe0a,0x15c9bebc,0x431d67c4,0x9c100d4c
|
||||
.long 0x4cc5d4be,0xcb3e42b6,0x597f299c,0xfc657e2a
|
||||
.long 0x5fcb6fab,0x3ad6faec,0x6c44198c,0x4a475817
|
||||
.quad 0x428a2f98d728ae22,0x7137449123ef65cd
|
||||
.quad 0xb5c0fbcfec4d3b2f,0xe9b5dba58189dbbc
|
||||
.quad 0x3956c25bf348b538,0x59f111f1b605d019
|
||||
.quad 0x923f82a4af194f9b,0xab1c5ed5da6d8118
|
||||
.quad 0xd807aa98a3030242,0x12835b0145706fbe
|
||||
.quad 0x243185be4ee4b28c,0x550c7dc3d5ffb4e2
|
||||
.quad 0x72be5d74f27b896f,0x80deb1fe3b1696b1
|
||||
.quad 0x9bdc06a725c71235,0xc19bf174cf692694
|
||||
.quad 0xe49b69c19ef14ad2,0xefbe4786384f25e3
|
||||
.quad 0x0fc19dc68b8cd5b5,0x240ca1cc77ac9c65
|
||||
.quad 0x2de92c6f592b0275,0x4a7484aa6ea6e483
|
||||
.quad 0x5cb0a9dcbd41fbd4,0x76f988da831153b5
|
||||
.quad 0x983e5152ee66dfab,0xa831c66d2db43210
|
||||
.quad 0xb00327c898fb213f,0xbf597fc7beef0ee4
|
||||
.quad 0xc6e00bf33da88fc2,0xd5a79147930aa725
|
||||
.quad 0x06ca6351e003826f,0x142929670a0e6e70
|
||||
.quad 0x27b70a8546d22ffc,0x2e1b21385c26c926
|
||||
.quad 0x4d2c6dfc5ac42aed,0x53380d139d95b3df
|
||||
.quad 0x650a73548baf63de,0x766a0abb3c77b2a8
|
||||
.quad 0x81c2c92e47edaee6,0x92722c851482353b
|
||||
.quad 0xa2bfe8a14cf10364,0xa81a664bbc423001
|
||||
.quad 0xc24b8b70d0f89791,0xc76c51a30654be30
|
||||
.quad 0xd192e819d6ef5218,0xd69906245565a910
|
||||
.quad 0xf40e35855771202a,0x106aa07032bbd1b8
|
||||
.quad 0x19a4c116b8d2d0c8,0x1e376c085141ab53
|
||||
.quad 0x2748774cdf8eeb99,0x34b0bcb5e19b48a8
|
||||
.quad 0x391c0cb3c5c95a63,0x4ed8aa4ae3418acb
|
||||
.quad 0x5b9cca4f7763e373,0x682e6ff3d6b2b8a3
|
||||
.quad 0x748f82ee5defb2fc,0x78a5636f43172f60
|
||||
.quad 0x84c87814a1f0ab72,0x8cc702081a6439ec
|
||||
.quad 0x90befffa23631e28,0xa4506cebde82bde9
|
||||
.quad 0xbef9a3f7b2c67915,0xc67178f2e372532b
|
||||
.quad 0xca273eceea26619c,0xd186b8c721c0c207
|
||||
.quad 0xeada7dd6cde0eb1e,0xf57d4f7fee6ed178
|
||||
.quad 0x06f067aa72176fba,0x0a637dc5a2c898a6
|
||||
.quad 0x113f9804bef90dae,0x1b710b35131c471b
|
||||
.quad 0x28db77f523047d84,0x32caab7b40c72493
|
||||
.quad 0x3c9ebe0a15c9bebc,0x431d67c49c100d4c
|
||||
.quad 0x4cc5d4becb3e42b6,0x597f299cfc657e2a
|
||||
.quad 0x5fcb6fab3ad6faec,0x6c44198c4a475817
|
||||
___
|
||||
$code.=<<___ if ($SZ==4);
|
||||
.long 0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5
|
||||
|
||||
@@ -26,6 +26,26 @@
|
||||
# favour dual-issue z10 pipeline. Hardware SHA256/512 is ~4.7x faster
|
||||
# than software.
|
||||
|
||||
# November 2010.
|
||||
#
|
||||
# Adapt for -m31 build. If kernel supports what's called "highgprs"
|
||||
# feature on Linux [see /proc/cpuinfo], it's possible to use 64-bit
|
||||
# instructions and achieve "64-bit" performance even in 31-bit legacy
|
||||
# application context. The feature is not specific to any particular
|
||||
# processor, as long as it's "z-CPU". Latter implies that the code
|
||||
# remains z/Architecture specific. On z900 SHA256 was measured to
|
||||
# perform 2.4x and SHA512 - 13x better than code generated by gcc 4.3.
|
||||
|
||||
$flavour = shift;
|
||||
|
||||
if ($flavour =~ /3[12]/) {
|
||||
$SIZE_T=4;
|
||||
$g="";
|
||||
} else {
|
||||
$SIZE_T=8;
|
||||
$g="g";
|
||||
}
|
||||
|
||||
$t0="%r0";
|
||||
$t1="%r1";
|
||||
$ctx="%r2"; $t2="%r2";
|
||||
@@ -44,7 +64,7 @@ $tbl="%r13";
|
||||
$T1="%r14";
|
||||
$sp="%r15";
|
||||
|
||||
$output=shift;
|
||||
while (($output=shift) && ($output!~/^\w[\w\-]*\.\w+$/)) {}
|
||||
open STDOUT,">$output";
|
||||
|
||||
if ($output =~ /512/) {
|
||||
@@ -78,7 +98,8 @@ if ($output =~ /512/) {
|
||||
}
|
||||
$Func="sha${label}_block_data_order";
|
||||
$Table="K${label}";
|
||||
$frame=160+16*$SZ;
|
||||
$stdframe=16*$SIZE_T+4*8;
|
||||
$frame=$stdframe+16*$SZ;
|
||||
|
||||
sub BODY_00_15 {
|
||||
my ($i,$a,$b,$c,$d,$e,$f,$g,$h) = @_;
|
||||
@@ -93,9 +114,9 @@ $code.=<<___;
|
||||
xgr $t0,$t1
|
||||
$ROT $t1,$t1,`$Sigma1[2]-$Sigma1[1]`
|
||||
xgr $t2,$g
|
||||
$ST $T1,`160+$SZ*($i%16)`($sp)
|
||||
$ST $T1,`$stdframe+$SZ*($i%16)`($sp)
|
||||
xgr $t0,$t1 # Sigma1(e)
|
||||
la $T1,0($T1,$h) # T1+=h
|
||||
algr $T1,$h # T1+=h
|
||||
ngr $t2,$e
|
||||
lgr $t1,$a
|
||||
algr $T1,$t0 # T1+=Sigma1(e)
|
||||
@@ -113,7 +134,7 @@ $code.=<<___;
|
||||
ngr $t2,$b
|
||||
algr $h,$T1 # h+=T1
|
||||
ogr $t2,$t1 # Maj(a,b,c)
|
||||
la $d,0($d,$T1) # d+=T1
|
||||
algr $d,$T1 # d+=T1
|
||||
algr $h,$t2 # h+=Maj(a,b,c)
|
||||
___
|
||||
}
|
||||
@@ -122,19 +143,19 @@ sub BODY_16_XX {
|
||||
my ($i,$a,$b,$c,$d,$e,$f,$g,$h) = @_;
|
||||
|
||||
$code.=<<___;
|
||||
$LD $T1,`160+$SZ*(($i+1)%16)`($sp) ### $i
|
||||
$LD $t1,`160+$SZ*(($i+14)%16)`($sp)
|
||||
$LD $T1,`$stdframe+$SZ*(($i+1)%16)`($sp) ### $i
|
||||
$LD $t1,`$stdframe+$SZ*(($i+14)%16)`($sp)
|
||||
$ROT $t0,$T1,$sigma0[0]
|
||||
$SHR $T1,$sigma0[2]
|
||||
$ROT $t2,$t0,`$sigma0[1]-$sigma0[0]`
|
||||
xgr $T1,$t0
|
||||
$ROT $t0,$t1,$sigma1[0]
|
||||
xgr $T1,$t2 # sigma0(X[i+1])
|
||||
xgr $T1,$t2 # sigma0(X[i+1])
|
||||
$SHR $t1,$sigma1[2]
|
||||
$ADD $T1,`160+$SZ*($i%16)`($sp) # +=X[i]
|
||||
$ADD $T1,`$stdframe+$SZ*($i%16)`($sp) # +=X[i]
|
||||
xgr $t1,$t0
|
||||
$ROT $t0,$t0,`$sigma1[1]-$sigma1[0]`
|
||||
$ADD $T1,`160+$SZ*(($i+9)%16)`($sp) # +=X[i+9]
|
||||
$ADD $T1,`$stdframe+$SZ*(($i+9)%16)`($sp) # +=X[i+9]
|
||||
xgr $t1,$t0 # sigma1(X[i+14])
|
||||
algr $T1,$t1 # +=sigma1(X[i+14])
|
||||
___
|
||||
@@ -212,6 +233,7 @@ $code.=<<___;
|
||||
.globl $Func
|
||||
.type $Func,\@function
|
||||
$Func:
|
||||
sllg $len,$len,`log(16*$SZ)/log(2)`
|
||||
___
|
||||
$code.=<<___ if ($kimdfunc);
|
||||
larl %r1,OPENSSL_s390xcap_P
|
||||
@@ -219,15 +241,15 @@ $code.=<<___ if ($kimdfunc);
|
||||
tmhl %r0,0x4000 # check for message-security assist
|
||||
jz .Lsoftware
|
||||
lghi %r0,0
|
||||
la %r1,16($sp)
|
||||
la %r1,`2*$SIZE_T`($sp)
|
||||
.long 0xb93e0002 # kimd %r0,%r2
|
||||
lg %r0,16($sp)
|
||||
lg %r0,`2*$SIZE_T`($sp)
|
||||
tmhh %r0,`0x8000>>$kimdfunc`
|
||||
jz .Lsoftware
|
||||
lghi %r0,$kimdfunc
|
||||
lgr %r1,$ctx
|
||||
lgr %r2,$inp
|
||||
sllg %r3,$len,`log(16*$SZ)/log(2)`
|
||||
lgr %r3,$len
|
||||
.long 0xb93e0002 # kimd %r0,%r2
|
||||
brc 1,.-4 # pay attention to "partial completion"
|
||||
br %r14
|
||||
@@ -235,13 +257,12 @@ $code.=<<___ if ($kimdfunc);
|
||||
.Lsoftware:
|
||||
___
|
||||
$code.=<<___;
|
||||
sllg $len,$len,`log(16*$SZ)/log(2)`
|
||||
lghi %r1,-$frame
|
||||
agr $len,$inp
|
||||
stmg $ctx,%r15,16($sp)
|
||||
la $len,0($len,$inp)
|
||||
stm${g} $ctx,%r15,`2*$SIZE_T`($sp)
|
||||
lgr %r0,$sp
|
||||
la $sp,0(%r1,$sp)
|
||||
stg %r0,0($sp)
|
||||
st${g} %r0,0($sp)
|
||||
|
||||
larl $tbl,$Table
|
||||
$LD $A,`0*$SZ`($ctx)
|
||||
@@ -265,7 +286,7 @@ $code.=<<___;
|
||||
clgr $len,$t0
|
||||
jne .Lrounds_16_xx
|
||||
|
||||
lg $ctx,`$frame+16`($sp)
|
||||
l${g} $ctx,`$frame+2*$SIZE_T`($sp)
|
||||
la $inp,`16*$SZ`($inp)
|
||||
$ADD $A,`0*$SZ`($ctx)
|
||||
$ADD $B,`1*$SZ`($ctx)
|
||||
@@ -283,14 +304,14 @@ $code.=<<___;
|
||||
$ST $F,`5*$SZ`($ctx)
|
||||
$ST $G,`6*$SZ`($ctx)
|
||||
$ST $H,`7*$SZ`($ctx)
|
||||
clg $inp,`$frame+32`($sp)
|
||||
cl${g} $inp,`$frame+4*$SIZE_T`($sp)
|
||||
jne .Lloop
|
||||
|
||||
lmg %r6,%r15,`$frame+48`($sp)
|
||||
lm${g} %r6,%r15,`$frame+6*$SIZE_T`($sp)
|
||||
br %r14
|
||||
.size $Func,.-$Func
|
||||
.string "SHA${label} block transform for s390x, CRYPTOGAMS by <appro\@openssl.org>"
|
||||
.comm OPENSSL_s390xcap_P,8,8
|
||||
.comm OPENSSL_s390xcap_P,16,8
|
||||
___
|
||||
|
||||
$code =~ s/\`([^\`]*)\`/eval $1/gem;
|
||||
|
||||
@@ -5,6 +5,8 @@
|
||||
# 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/.
|
||||
#
|
||||
# Hardware SPARC T4 support by David S. Miller <davem@davemloft.net>.
|
||||
# ====================================================================
|
||||
|
||||
# SHA256 performance improvement over compiler generated code varies
|
||||
@@ -41,11 +43,11 @@
|
||||
# loads are always slower than one 64-bit load. Once again this
|
||||
# is unlike pre-T1 UltraSPARC, where, if scheduled appropriately,
|
||||
# 2x32-bit loads can be as fast as 1x64-bit ones.
|
||||
|
||||
$bits=32;
|
||||
for (@ARGV) { $bits=64 if (/\-m64/ || /\-xarch\=v9/); }
|
||||
if ($bits==64) { $bias=2047; $frame=192; }
|
||||
else { $bias=0; $frame=112; }
|
||||
#
|
||||
# SPARC T4 SHA256/512 hardware achieves 3.17/2.01 cycles per byte,
|
||||
# which is 9.3x/11.1x faster than software. Multi-process benchmark
|
||||
# saturates at 11.5x single-process result on 8-core processor, or
|
||||
# ~11/16GBps per 2.85GHz socket.
|
||||
|
||||
$output=shift;
|
||||
open STDOUT,">$output";
|
||||
@@ -170,6 +172,7 @@ $code.=<<___ if ($i==0);
|
||||
ld [$inp+16],%l4
|
||||
ld [$inp+20],%l5
|
||||
ld [$inp+24],%l6
|
||||
cmp $tmp31,0
|
||||
ld [$inp+28],%l7
|
||||
___
|
||||
$code.=<<___ if ($i<15);
|
||||
@@ -182,29 +185,29 @@ $code.=<<___ if ($i<15);
|
||||
or @pair[1],$tmp2,$tmp2
|
||||
`"ld [$inp+".eval(32+4+$i*8)."],@pair[1]" if ($i<12)`
|
||||
add $h,$tmp2,$T1
|
||||
$ST $tmp2,[%sp+`$bias+$frame+$i*$SZ`]
|
||||
$ST $tmp2,[%sp+STACK_BIAS+STACK_FRAME+`$i*$SZ`]
|
||||
___
|
||||
$code.=<<___ if ($i==12);
|
||||
brnz,a $tmp31,.+8
|
||||
bnz,a,pn %icc,.+8
|
||||
ld [$inp+128],%l0
|
||||
___
|
||||
$code.=<<___ if ($i==15);
|
||||
ld [%sp+`$bias+$frame+(($i+1+1)%16)*$SZ+0`],%l2
|
||||
ld [%sp+STACK_BIAS+STACK_FRAME+`(($i+1+1)%16)*$SZ+0`],%l2
|
||||
sllx @pair[1],$tmp31,$tmp2 ! Xload($i)
|
||||
add $tmp31,32,$tmp0
|
||||
ld [%sp+`$bias+$frame+(($i+1+1)%16)*$SZ+4`],%l3
|
||||
ld [%sp+STACK_BIAS+STACK_FRAME+`(($i+1+1)%16)*$SZ+4`],%l3
|
||||
sllx @pair[0],$tmp0,$tmp1
|
||||
ld [%sp+`$bias+$frame+(($i+1+9)%16)*$SZ+0`],%l4
|
||||
ld [%sp+STACK_BIAS+STACK_FRAME+`(($i+1+9)%16)*$SZ+0`],%l4
|
||||
srlx @pair[2],$tmp32,@pair[1]
|
||||
or $tmp1,$tmp2,$tmp2
|
||||
ld [%sp+`$bias+$frame+(($i+1+9)%16)*$SZ+4`],%l5
|
||||
ld [%sp+STACK_BIAS+STACK_FRAME+`(($i+1+9)%16)*$SZ+4`],%l5
|
||||
or @pair[1],$tmp2,$tmp2
|
||||
ld [%sp+`$bias+$frame+(($i+1+14)%16)*$SZ+0`],%l6
|
||||
ld [%sp+STACK_BIAS+STACK_FRAME+`(($i+1+14)%16)*$SZ+0`],%l6
|
||||
add $h,$tmp2,$T1
|
||||
$ST $tmp2,[%sp+`$bias+$frame+$i*$SZ`]
|
||||
ld [%sp+`$bias+$frame+(($i+1+14)%16)*$SZ+4`],%l7
|
||||
ld [%sp+`$bias+$frame+(($i+1+0)%16)*$SZ+0`],%l0
|
||||
ld [%sp+`$bias+$frame+(($i+1+0)%16)*$SZ+4`],%l1
|
||||
$ST $tmp2,[%sp+STACK_BIAS+STACK_FRAME+`$i*$SZ`]
|
||||
ld [%sp+STACK_BIAS+STACK_FRAME+`(($i+1+14)%16)*$SZ+4`],%l7
|
||||
ld [%sp+STACK_BIAS+STACK_FRAME+`(($i+1+0)%16)*$SZ+0`],%l0
|
||||
ld [%sp+STACK_BIAS+STACK_FRAME+`(($i+1+0)%16)*$SZ+4`],%l1
|
||||
___
|
||||
} if ($SZ==8);
|
||||
|
||||
@@ -305,9 +308,9 @@ $code.=<<___;
|
||||
srlx @X[(($i+9)/2)%8],32,$tmp1 ! X[i+9]
|
||||
xor $tmp0,$tmp2,$tmp2 ! sigma1(X[i+14])
|
||||
srl @X[($i/2)%8],0,$tmp0
|
||||
add $tmp2,$tmp1,$tmp1
|
||||
add $xi,$T1,$T1 ! +=X[i]
|
||||
xor $tmp0,@X[($i/2)%8],@X[($i/2)%8]
|
||||
add $tmp2,$T1,$T1
|
||||
add $tmp1,$T1,$T1
|
||||
|
||||
srl $T1,0,$T1
|
||||
@@ -318,9 +321,9 @@ ___
|
||||
$code.=<<___;
|
||||
srlx @X[($i/2)%8],32,$tmp1 ! X[i]
|
||||
xor $tmp0,$tmp2,$tmp2 ! sigma1(X[i+14])
|
||||
srl @X[($i/2)%8],0,@X[($i/2)%8]
|
||||
add $xi,$T1,$T1 ! +=X[i+9]
|
||||
add $tmp2,$T1,$T1
|
||||
add $tmp2,$tmp1,$tmp1
|
||||
srl @X[($i/2)%8],0,@X[($i/2)%8]
|
||||
add $tmp1,$T1,$T1
|
||||
|
||||
sllx $T1,32,$tmp0
|
||||
@@ -340,9 +343,9 @@ $code.=<<___;
|
||||
or %l3,$tmp0,$tmp0
|
||||
|
||||
srlx $tmp0,@sigma0[0],$T1
|
||||
ld [%sp+`$bias+$frame+(($i+1+1)%16)*$SZ+0`],%l2
|
||||
ld [%sp+STACK_BIAS+STACK_FRAME+`(($i+1+1)%16)*$SZ+0`],%l2
|
||||
sllx $tmp0,`64-@sigma0[2]`,$tmp1
|
||||
ld [%sp+`$bias+$frame+(($i+1+1)%16)*$SZ+4`],%l3
|
||||
ld [%sp+STACK_BIAS+STACK_FRAME+`(($i+1+1)%16)*$SZ+4`],%l3
|
||||
srlx $tmp0,@sigma0[1],$tmp0
|
||||
xor $tmp1,$T1,$T1
|
||||
sllx $tmp1,`@sigma0[2]-@sigma0[1]`,$tmp1
|
||||
@@ -354,9 +357,9 @@ $code.=<<___;
|
||||
or %l7,$tmp2,$tmp2
|
||||
|
||||
srlx $tmp2,@sigma1[0],$tmp1
|
||||
ld [%sp+`$bias+$frame+(($i+1+14)%16)*$SZ+0`],%l6
|
||||
ld [%sp+STACK_BIAS+STACK_FRAME+`(($i+1+14)%16)*$SZ+0`],%l6
|
||||
sllx $tmp2,`64-@sigma1[2]`,$tmp0
|
||||
ld [%sp+`$bias+$frame+(($i+1+14)%16)*$SZ+4`],%l7
|
||||
ld [%sp+STACK_BIAS+STACK_FRAME+`(($i+1+14)%16)*$SZ+4`],%l7
|
||||
srlx $tmp2,@sigma1[1],$tmp2
|
||||
xor $tmp0,$tmp1,$tmp1
|
||||
sllx $tmp0,`@sigma1[2]-@sigma1[1]`,$tmp0
|
||||
@@ -365,27 +368,30 @@ $code.=<<___;
|
||||
xor $tmp0,$tmp1,$tmp1
|
||||
sllx %l4,32,$tmp0
|
||||
xor $tmp2,$tmp1,$tmp1 ! sigma1(X[$i+14])
|
||||
ld [%sp+`$bias+$frame+(($i+1+9)%16)*$SZ+0`],%l4
|
||||
ld [%sp+STACK_BIAS+STACK_FRAME+`(($i+1+9)%16)*$SZ+0`],%l4
|
||||
or %l5,$tmp0,$tmp0
|
||||
ld [%sp+`$bias+$frame+(($i+1+9)%16)*$SZ+4`],%l5
|
||||
ld [%sp+STACK_BIAS+STACK_FRAME+`(($i+1+9)%16)*$SZ+4`],%l5
|
||||
|
||||
sllx %l0,32,$tmp2
|
||||
add $tmp1,$T1,$T1
|
||||
ld [%sp+`$bias+$frame+(($i+1+0)%16)*$SZ+0`],%l0
|
||||
ld [%sp+STACK_BIAS+STACK_FRAME+`(($i+1+0)%16)*$SZ+0`],%l0
|
||||
or %l1,$tmp2,$tmp2
|
||||
add $tmp0,$T1,$T1 ! +=X[$i+9]
|
||||
ld [%sp+`$bias+$frame+(($i+1+0)%16)*$SZ+4`],%l1
|
||||
ld [%sp+STACK_BIAS+STACK_FRAME+`(($i+1+0)%16)*$SZ+4`],%l1
|
||||
add $tmp2,$T1,$T1 ! +=X[$i]
|
||||
$ST $T1,[%sp+`$bias+$frame+($i%16)*$SZ`]
|
||||
$ST $T1,[%sp+STACK_BIAS+STACK_FRAME+`($i%16)*$SZ`]
|
||||
___
|
||||
&BODY_00_15(@_);
|
||||
} if ($SZ==8);
|
||||
|
||||
$code.=<<___ if ($bits==64);
|
||||
$code.=<<___;
|
||||
#include "sparc_arch.h"
|
||||
|
||||
#ifdef __arch64__
|
||||
.register %g2,#scratch
|
||||
.register %g3,#scratch
|
||||
___
|
||||
$code.=<<___;
|
||||
#endif
|
||||
|
||||
.section ".text",#alloc,#execinstr
|
||||
|
||||
.align 64
|
||||
@@ -457,9 +463,203 @@ ___
|
||||
}
|
||||
$code.=<<___;
|
||||
.size K${label},.-K${label}
|
||||
|
||||
#ifdef __PIC__
|
||||
SPARC_PIC_THUNK(%g1)
|
||||
#endif
|
||||
|
||||
.globl sha${label}_block_data_order
|
||||
.align 32
|
||||
sha${label}_block_data_order:
|
||||
save %sp,`-$frame-$locals`,%sp
|
||||
SPARC_LOAD_ADDRESS_LEAF(OPENSSL_sparcv9cap_P,%g1,%g5)
|
||||
ld [%g1+4],%g1 ! OPENSSL_sparcv9cap_P[1]
|
||||
|
||||
andcc %g1, CFR_SHA${label}, %g0
|
||||
be .Lsoftware
|
||||
nop
|
||||
___
|
||||
$code.=<<___ if ($SZ==8); # SHA512
|
||||
ldd [%o0 + 0x00], %f0 ! load context
|
||||
ldd [%o0 + 0x08], %f2
|
||||
ldd [%o0 + 0x10], %f4
|
||||
ldd [%o0 + 0x18], %f6
|
||||
ldd [%o0 + 0x20], %f8
|
||||
ldd [%o0 + 0x28], %f10
|
||||
andcc %o1, 0x7, %g0
|
||||
ldd [%o0 + 0x30], %f12
|
||||
bne,pn %icc, .Lhwunaligned
|
||||
ldd [%o0 + 0x38], %f14
|
||||
|
||||
.Lhwaligned_loop:
|
||||
ldd [%o1 + 0x00], %f16
|
||||
ldd [%o1 + 0x08], %f18
|
||||
ldd [%o1 + 0x10], %f20
|
||||
ldd [%o1 + 0x18], %f22
|
||||
ldd [%o1 + 0x20], %f24
|
||||
ldd [%o1 + 0x28], %f26
|
||||
ldd [%o1 + 0x30], %f28
|
||||
ldd [%o1 + 0x38], %f30
|
||||
ldd [%o1 + 0x40], %f32
|
||||
ldd [%o1 + 0x48], %f34
|
||||
ldd [%o1 + 0x50], %f36
|
||||
ldd [%o1 + 0x58], %f38
|
||||
ldd [%o1 + 0x60], %f40
|
||||
ldd [%o1 + 0x68], %f42
|
||||
ldd [%o1 + 0x70], %f44
|
||||
subcc %o2, 1, %o2 ! done yet?
|
||||
ldd [%o1 + 0x78], %f46
|
||||
add %o1, 0x80, %o1
|
||||
prefetch [%o1 + 63], 20
|
||||
prefetch [%o1 + 64+63], 20
|
||||
|
||||
.word 0x81b02860 ! SHA512
|
||||
|
||||
bne,pt SIZE_T_CC, .Lhwaligned_loop
|
||||
nop
|
||||
|
||||
.Lhwfinish:
|
||||
std %f0, [%o0 + 0x00] ! store context
|
||||
std %f2, [%o0 + 0x08]
|
||||
std %f4, [%o0 + 0x10]
|
||||
std %f6, [%o0 + 0x18]
|
||||
std %f8, [%o0 + 0x20]
|
||||
std %f10, [%o0 + 0x28]
|
||||
std %f12, [%o0 + 0x30]
|
||||
retl
|
||||
std %f14, [%o0 + 0x38]
|
||||
|
||||
.align 16
|
||||
.Lhwunaligned:
|
||||
alignaddr %o1, %g0, %o1
|
||||
|
||||
ldd [%o1 + 0x00], %f18
|
||||
.Lhwunaligned_loop:
|
||||
ldd [%o1 + 0x08], %f20
|
||||
ldd [%o1 + 0x10], %f22
|
||||
ldd [%o1 + 0x18], %f24
|
||||
ldd [%o1 + 0x20], %f26
|
||||
ldd [%o1 + 0x28], %f28
|
||||
ldd [%o1 + 0x30], %f30
|
||||
ldd [%o1 + 0x38], %f32
|
||||
ldd [%o1 + 0x40], %f34
|
||||
ldd [%o1 + 0x48], %f36
|
||||
ldd [%o1 + 0x50], %f38
|
||||
ldd [%o1 + 0x58], %f40
|
||||
ldd [%o1 + 0x60], %f42
|
||||
ldd [%o1 + 0x68], %f44
|
||||
ldd [%o1 + 0x70], %f46
|
||||
ldd [%o1 + 0x78], %f48
|
||||
subcc %o2, 1, %o2 ! done yet?
|
||||
ldd [%o1 + 0x80], %f50
|
||||
add %o1, 0x80, %o1
|
||||
prefetch [%o1 + 63], 20
|
||||
prefetch [%o1 + 64+63], 20
|
||||
|
||||
faligndata %f18, %f20, %f16
|
||||
faligndata %f20, %f22, %f18
|
||||
faligndata %f22, %f24, %f20
|
||||
faligndata %f24, %f26, %f22
|
||||
faligndata %f26, %f28, %f24
|
||||
faligndata %f28, %f30, %f26
|
||||
faligndata %f30, %f32, %f28
|
||||
faligndata %f32, %f34, %f30
|
||||
faligndata %f34, %f36, %f32
|
||||
faligndata %f36, %f38, %f34
|
||||
faligndata %f38, %f40, %f36
|
||||
faligndata %f40, %f42, %f38
|
||||
faligndata %f42, %f44, %f40
|
||||
faligndata %f44, %f46, %f42
|
||||
faligndata %f46, %f48, %f44
|
||||
faligndata %f48, %f50, %f46
|
||||
|
||||
.word 0x81b02860 ! SHA512
|
||||
|
||||
bne,pt SIZE_T_CC, .Lhwunaligned_loop
|
||||
for %f50, %f50, %f18 ! %f18=%f50
|
||||
|
||||
ba .Lhwfinish
|
||||
nop
|
||||
___
|
||||
$code.=<<___ if ($SZ==4); # SHA256
|
||||
ld [%o0 + 0x00], %f0
|
||||
ld [%o0 + 0x04], %f1
|
||||
ld [%o0 + 0x08], %f2
|
||||
ld [%o0 + 0x0c], %f3
|
||||
ld [%o0 + 0x10], %f4
|
||||
ld [%o0 + 0x14], %f5
|
||||
andcc %o1, 0x7, %g0
|
||||
ld [%o0 + 0x18], %f6
|
||||
bne,pn %icc, .Lhwunaligned
|
||||
ld [%o0 + 0x1c], %f7
|
||||
|
||||
.Lhwloop:
|
||||
ldd [%o1 + 0x00], %f8
|
||||
ldd [%o1 + 0x08], %f10
|
||||
ldd [%o1 + 0x10], %f12
|
||||
ldd [%o1 + 0x18], %f14
|
||||
ldd [%o1 + 0x20], %f16
|
||||
ldd [%o1 + 0x28], %f18
|
||||
ldd [%o1 + 0x30], %f20
|
||||
subcc %o2, 1, %o2 ! done yet?
|
||||
ldd [%o1 + 0x38], %f22
|
||||
add %o1, 0x40, %o1
|
||||
prefetch [%o1 + 63], 20
|
||||
|
||||
.word 0x81b02840 ! SHA256
|
||||
|
||||
bne,pt SIZE_T_CC, .Lhwloop
|
||||
nop
|
||||
|
||||
.Lhwfinish:
|
||||
st %f0, [%o0 + 0x00] ! store context
|
||||
st %f1, [%o0 + 0x04]
|
||||
st %f2, [%o0 + 0x08]
|
||||
st %f3, [%o0 + 0x0c]
|
||||
st %f4, [%o0 + 0x10]
|
||||
st %f5, [%o0 + 0x14]
|
||||
st %f6, [%o0 + 0x18]
|
||||
retl
|
||||
st %f7, [%o0 + 0x1c]
|
||||
|
||||
.align 8
|
||||
.Lhwunaligned:
|
||||
alignaddr %o1, %g0, %o1
|
||||
|
||||
ldd [%o1 + 0x00], %f10
|
||||
.Lhwunaligned_loop:
|
||||
ldd [%o1 + 0x08], %f12
|
||||
ldd [%o1 + 0x10], %f14
|
||||
ldd [%o1 + 0x18], %f16
|
||||
ldd [%o1 + 0x20], %f18
|
||||
ldd [%o1 + 0x28], %f20
|
||||
ldd [%o1 + 0x30], %f22
|
||||
ldd [%o1 + 0x38], %f24
|
||||
subcc %o2, 1, %o2 ! done yet?
|
||||
ldd [%o1 + 0x40], %f26
|
||||
add %o1, 0x40, %o1
|
||||
prefetch [%o1 + 63], 20
|
||||
|
||||
faligndata %f10, %f12, %f8
|
||||
faligndata %f12, %f14, %f10
|
||||
faligndata %f14, %f16, %f12
|
||||
faligndata %f16, %f18, %f14
|
||||
faligndata %f18, %f20, %f16
|
||||
faligndata %f20, %f22, %f18
|
||||
faligndata %f22, %f24, %f20
|
||||
faligndata %f24, %f26, %f22
|
||||
|
||||
.word 0x81b02840 ! SHA256
|
||||
|
||||
bne,pt SIZE_T_CC, .Lhwunaligned_loop
|
||||
for %f26, %f26, %f10 ! %f10=%f26
|
||||
|
||||
ba .Lhwfinish
|
||||
nop
|
||||
___
|
||||
$code.=<<___;
|
||||
.align 16
|
||||
.Lsoftware:
|
||||
save %sp,-STACK_FRAME-$locals,%sp
|
||||
and $inp,`$align-1`,$tmp31
|
||||
sllx $len,`log(16*$SZ)/log(2)`,$len
|
||||
andn $inp,`$align-1`,$inp
|
||||
@@ -578,7 +778,7 @@ ___
|
||||
$code.=<<___;
|
||||
add $inp,`16*$SZ`,$inp ! advance inp
|
||||
cmp $inp,$len
|
||||
bne `$bits==64?"%xcc":"%icc"`,.Lloop
|
||||
bne SIZE_T_CC,.Lloop
|
||||
sub $Ktbl,`($rounds-16)*$SZ`,$Ktbl ! rewind Ktbl
|
||||
|
||||
ret
|
||||
@@ -589,6 +789,62 @@ $code.=<<___;
|
||||
.align 4
|
||||
___
|
||||
|
||||
$code =~ s/\`([^\`]*)\`/eval $1/gem;
|
||||
print $code;
|
||||
# Purpose of these subroutines is to explicitly encode VIS instructions,
|
||||
# so that one can compile the module without having to specify VIS
|
||||
# extentions on compiler command line, e.g. -xarch=v9 vs. -xarch=v9a.
|
||||
# Idea is to reserve for option to produce "universal" binary and let
|
||||
# programmer detect if current CPU is VIS capable at run-time.
|
||||
sub unvis {
|
||||
my ($mnemonic,$rs1,$rs2,$rd)=@_;
|
||||
my $ref,$opf;
|
||||
my %visopf = ( "faligndata" => 0x048,
|
||||
"for" => 0x07c );
|
||||
|
||||
$ref = "$mnemonic\t$rs1,$rs2,$rd";
|
||||
|
||||
if ($opf=$visopf{$mnemonic}) {
|
||||
foreach ($rs1,$rs2,$rd) {
|
||||
return $ref if (!/%f([0-9]{1,2})/);
|
||||
$_=$1;
|
||||
if ($1>=32) {
|
||||
return $ref if ($1&1);
|
||||
# re-encode for upper double register addressing
|
||||
$_=($1|$1>>5)&31;
|
||||
}
|
||||
}
|
||||
|
||||
return sprintf ".word\t0x%08x !%s",
|
||||
0x81b00000|$rd<<25|$rs1<<14|$opf<<5|$rs2,
|
||||
$ref;
|
||||
} else {
|
||||
return $ref;
|
||||
}
|
||||
}
|
||||
sub unalignaddr {
|
||||
my ($mnemonic,$rs1,$rs2,$rd)=@_;
|
||||
my %bias = ( "g" => 0, "o" => 8, "l" => 16, "i" => 24 );
|
||||
my $ref="$mnemonic\t$rs1,$rs2,$rd";
|
||||
|
||||
foreach ($rs1,$rs2,$rd) {
|
||||
if (/%([goli])([0-7])/) { $_=$bias{$1}+$2; }
|
||||
else { return $ref; }
|
||||
}
|
||||
return sprintf ".word\t0x%08x !%s",
|
||||
0x81b00300|$rd<<25|$rs1<<14|$rs2,
|
||||
$ref;
|
||||
}
|
||||
|
||||
foreach (split("\n",$code)) {
|
||||
s/\`([^\`]*)\`/eval $1/ge;
|
||||
|
||||
s/\b(f[^\s]*)\s+(%f[0-9]{1,2}),\s*(%f[0-9]{1,2}),\s*(%f[0-9]{1,2})/
|
||||
&unvis($1,$2,$3,$4)
|
||||
/ge;
|
||||
s/\b(alignaddr)\s+(%[goli][0-7]),\s*(%[goli][0-7]),\s*(%[goli][0-7])/
|
||||
&unalignaddr($1,$2,$3,$4)
|
||||
/ge;
|
||||
|
||||
print $_,"\n";
|
||||
}
|
||||
|
||||
close STDOUT;
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
424
crypto/sha/asm/sha512p8-ppc.pl
Executable file
424
crypto/sha/asm/sha512p8-ppc.pl
Executable file
@@ -0,0 +1,424 @@
|
||||
#!/usr/bin/env perl
|
||||
|
||||
# ====================================================================
|
||||
# Written by Andy Polyakov <appro@openssl.org> 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/.
|
||||
# ====================================================================
|
||||
|
||||
# SHA256/512 for PowerISA v2.07.
|
||||
#
|
||||
# Accurate performance measurements are problematic, because it's
|
||||
# always virtualized setup with possibly throttled processor.
|
||||
# Relative comparison is therefore more informative. This module is
|
||||
# ~60% faster than integer-only sha512-ppc.pl. To anchor to something
|
||||
# else, SHA256 is 24% slower than sha1-ppc.pl and 2.5x slower than
|
||||
# hardware-assisted aes-128-cbc encrypt. SHA512 is 20% faster than
|
||||
# sha1-ppc.pl and 1.6x slower than aes-128-cbc. Another interesting
|
||||
# result is degree of computational resources' utilization. POWER8 is
|
||||
# "massively multi-threaded chip" and difference between single- and
|
||||
# maximum multi-process benchmark results tells that utlization is
|
||||
# whooping 94%. For sha512-ppc.pl we get [not unimpressive] 84% and
|
||||
# for sha1-ppc.pl - 73%. 100% means that multi-process result equals
|
||||
# to single-process one, given that all threads end up on the same
|
||||
# physical core.
|
||||
|
||||
$flavour=shift;
|
||||
$output =shift;
|
||||
|
||||
if ($flavour =~ /64/) {
|
||||
$SIZE_T=8;
|
||||
$LRSAVE=2*$SIZE_T;
|
||||
$STU="stdu";
|
||||
$POP="ld";
|
||||
$PUSH="std";
|
||||
} elsif ($flavour =~ /32/) {
|
||||
$SIZE_T=4;
|
||||
$LRSAVE=$SIZE_T;
|
||||
$STU="stwu";
|
||||
$POP="lwz";
|
||||
$PUSH="stw";
|
||||
} else { die "nonsense $flavour"; }
|
||||
|
||||
$LENDIAN=($flavour=~/le/);
|
||||
|
||||
$0 =~ m/(.*[\/\\])[^\/\\]+$/; $dir=$1;
|
||||
( $xlate="${dir}ppc-xlate.pl" and -f $xlate ) or
|
||||
( $xlate="${dir}../../perlasm/ppc-xlate.pl" and -f $xlate) or
|
||||
die "can't locate ppc-xlate.pl";
|
||||
|
||||
open STDOUT,"| $^X $xlate $flavour $output" || die "can't call $xlate: $!";
|
||||
|
||||
if ($output =~ /512/) {
|
||||
$bits=512;
|
||||
$SZ=8;
|
||||
$sz="d";
|
||||
$rounds=80;
|
||||
} else {
|
||||
$bits=256;
|
||||
$SZ=4;
|
||||
$sz="w";
|
||||
$rounds=64;
|
||||
}
|
||||
|
||||
$func="sha${bits}_block_p8";
|
||||
$FRAME=8*$SIZE_T;
|
||||
|
||||
$sp ="r1";
|
||||
$toc="r2";
|
||||
$ctx="r3";
|
||||
$inp="r4";
|
||||
$num="r5";
|
||||
$Tbl="r6";
|
||||
$idx="r7";
|
||||
$lrsave="r8";
|
||||
$offload="r11";
|
||||
$vrsave="r12";
|
||||
($x00,$x10,$x20,$x30,$x40,$x50,$x60,$x70)=map("r$_",(0,10,26..31));
|
||||
$x00=0 if ($flavour =~ /osx/);
|
||||
|
||||
@V=($A,$B,$C,$D,$E,$F,$G,$H)=map("v$_",(0..7));
|
||||
@X=map("v$_",(8..23));
|
||||
($Ki,$Func,$S0,$S1,$s0,$s1,$lemask)=map("v$_",(24..31));
|
||||
|
||||
sub ROUND {
|
||||
my ($i,$a,$b,$c,$d,$e,$f,$g,$h)=@_;
|
||||
my $j=($i+1)%16;
|
||||
|
||||
$code.=<<___ if ($i<15 && ($i%(16/$SZ))==(16/$SZ-1));
|
||||
lvx_u @X[$i+1],0,$inp ; load X[i] in advance
|
||||
addi $inp,$inp,16
|
||||
___
|
||||
$code.=<<___ if ($i<16 && ($i%(16/$SZ)));
|
||||
vsldoi @X[$i],@X[$i-1],@X[$i-1],$SZ
|
||||
___
|
||||
$code.=<<___ if ($LENDIAN && $i<16 && ($i%(16/$SZ))==0);
|
||||
vperm @X[$i],@X[$i],@X[$i],$lemask
|
||||
___
|
||||
$code.=<<___;
|
||||
`"vshasigma${sz} $s0,@X[($j+1)%16],0,0" if ($i>=15)`
|
||||
vsel $Func,$g,$f,$e ; Ch(e,f,g)
|
||||
vshasigma${sz} $S1,$e,1,15 ; Sigma1(e)
|
||||
vaddu${sz}m $h,$h,@X[$i%16] ; h+=X[i]
|
||||
vshasigma${sz} $S0,$a,1,0 ; Sigma0(a)
|
||||
`"vshasigma${sz} $s1,@X[($j+14)%16],0,15" if ($i>=15)`
|
||||
vaddu${sz}m $h,$h,$Func ; h+=Ch(e,f,g)
|
||||
vxor $Func,$a,$b
|
||||
`"vaddu${sz}m @X[$j],@X[$j],@X[($j+9)%16]" if ($i>=15)`
|
||||
vaddu${sz}m $h,$h,$S1 ; h+=Sigma1(e)
|
||||
vsel $Func,$b,$c,$Func ; Maj(a,b,c)
|
||||
vaddu${sz}m $g,$g,$Ki ; future h+=K[i]
|
||||
vaddu${sz}m $d,$d,$h ; d+=h
|
||||
vaddu${sz}m $S0,$S0,$Func ; Sigma0(a)+Maj(a,b,c)
|
||||
`"vaddu${sz}m @X[$j],@X[$j],$s0" if ($i>=15)`
|
||||
lvx $Ki,$idx,$Tbl ; load next K[i]
|
||||
addi $idx,$idx,16
|
||||
vaddu${sz}m $h,$h,$S0 ; h+=Sigma0(a)+Maj(a,b,c)
|
||||
`"vaddu${sz}m @X[$j],@X[$j],$s1" if ($i>=15)`
|
||||
___
|
||||
}
|
||||
|
||||
$code=<<___;
|
||||
.machine "any"
|
||||
.text
|
||||
|
||||
.globl $func
|
||||
.align 6
|
||||
$func:
|
||||
$STU $sp,-`($FRAME+21*16+6*$SIZE_T)`($sp)
|
||||
mflr $lrsave
|
||||
li r10,`$FRAME+8*16+15`
|
||||
li r11,`$FRAME+8*16+31`
|
||||
stvx v20,r10,$sp # ABI says so
|
||||
addi r10,r10,32
|
||||
mfspr $vrsave,256
|
||||
stvx v21,r11,$sp
|
||||
addi r11,r11,32
|
||||
stvx v22,r10,$sp
|
||||
addi r10,r10,32
|
||||
stvx v23,r11,$sp
|
||||
addi r11,r11,32
|
||||
stvx v24,r10,$sp
|
||||
addi r10,r10,32
|
||||
stvx v25,r11,$sp
|
||||
addi r11,r11,32
|
||||
stvx v26,r10,$sp
|
||||
addi r10,r10,32
|
||||
stvx v27,r11,$sp
|
||||
addi r11,r11,32
|
||||
stvx v28,r10,$sp
|
||||
addi r10,r10,32
|
||||
stvx v29,r11,$sp
|
||||
addi r11,r11,32
|
||||
stvx v30,r10,$sp
|
||||
stvx v31,r11,$sp
|
||||
li r11,-1
|
||||
stw $vrsave,`$FRAME+21*16-4`($sp) # save vrsave
|
||||
li $x10,0x10
|
||||
$PUSH r26,`$FRAME+21*16+0*$SIZE_T`($sp)
|
||||
li $x20,0x20
|
||||
$PUSH r27,`$FRAME+21*16+1*$SIZE_T`($sp)
|
||||
li $x30,0x30
|
||||
$PUSH r28,`$FRAME+21*16+2*$SIZE_T`($sp)
|
||||
li $x40,0x40
|
||||
$PUSH r29,`$FRAME+21*16+3*$SIZE_T`($sp)
|
||||
li $x50,0x50
|
||||
$PUSH r30,`$FRAME+21*16+4*$SIZE_T`($sp)
|
||||
li $x60,0x60
|
||||
$PUSH r31,`$FRAME+21*16+5*$SIZE_T`($sp)
|
||||
li $x70,0x70
|
||||
$PUSH $lrsave,`$FRAME+21*16+6*$SIZE_T+$LRSAVE`($sp)
|
||||
mtspr 256,r11
|
||||
|
||||
bl LPICmeup
|
||||
addi $offload,$sp,$FRAME+15
|
||||
___
|
||||
$code.=<<___ if ($LENDIAN);
|
||||
li $idx,8
|
||||
lvsl $lemask,0,$idx
|
||||
vspltisb $Ki,0x0f
|
||||
vxor $lemask,$lemask,$Ki
|
||||
___
|
||||
$code.=<<___ if ($SZ==4);
|
||||
lvx_4w $A,$x00,$ctx
|
||||
lvx_4w $E,$x10,$ctx
|
||||
vsldoi $B,$A,$A,4 # unpack
|
||||
vsldoi $C,$A,$A,8
|
||||
vsldoi $D,$A,$A,12
|
||||
vsldoi $F,$E,$E,4
|
||||
vsldoi $G,$E,$E,8
|
||||
vsldoi $H,$E,$E,12
|
||||
___
|
||||
$code.=<<___ if ($SZ==8);
|
||||
lvx_u $A,$x00,$ctx
|
||||
lvx_u $C,$x10,$ctx
|
||||
lvx_u $E,$x20,$ctx
|
||||
vsldoi $B,$A,$A,8 # unpack
|
||||
lvx_u $G,$x30,$ctx
|
||||
vsldoi $D,$C,$C,8
|
||||
vsldoi $F,$E,$E,8
|
||||
vsldoi $H,$G,$G,8
|
||||
___
|
||||
$code.=<<___;
|
||||
li r0,`($rounds-16)/16` # inner loop counter
|
||||
b Loop
|
||||
.align 5
|
||||
Loop:
|
||||
lvx $Ki,$x00,$Tbl
|
||||
li $idx,16
|
||||
lvx_u @X[0],0,$inp
|
||||
addi $inp,$inp,16
|
||||
stvx $A,$x00,$offload # offload $A-$H
|
||||
stvx $B,$x10,$offload
|
||||
stvx $C,$x20,$offload
|
||||
stvx $D,$x30,$offload
|
||||
stvx $E,$x40,$offload
|
||||
stvx $F,$x50,$offload
|
||||
stvx $G,$x60,$offload
|
||||
stvx $H,$x70,$offload
|
||||
vaddu${sz}m $H,$H,$Ki # h+K[i]
|
||||
lvx $Ki,$idx,$Tbl
|
||||
addi $idx,$idx,16
|
||||
___
|
||||
for ($i=0;$i<16;$i++) { &ROUND($i,@V); unshift(@V,pop(@V)); }
|
||||
$code.=<<___;
|
||||
mtctr r0
|
||||
b L16_xx
|
||||
.align 5
|
||||
L16_xx:
|
||||
___
|
||||
for (;$i<32;$i++) { &ROUND($i,@V); unshift(@V,pop(@V)); }
|
||||
$code.=<<___;
|
||||
bdnz L16_xx
|
||||
|
||||
lvx @X[2],$x00,$offload
|
||||
subic. $num,$num,1
|
||||
lvx @X[3],$x10,$offload
|
||||
vaddu${sz}m $A,$A,@X[2]
|
||||
lvx @X[4],$x20,$offload
|
||||
vaddu${sz}m $B,$B,@X[3]
|
||||
lvx @X[5],$x30,$offload
|
||||
vaddu${sz}m $C,$C,@X[4]
|
||||
lvx @X[6],$x40,$offload
|
||||
vaddu${sz}m $D,$D,@X[5]
|
||||
lvx @X[7],$x50,$offload
|
||||
vaddu${sz}m $E,$E,@X[6]
|
||||
lvx @X[8],$x60,$offload
|
||||
vaddu${sz}m $F,$F,@X[7]
|
||||
lvx @X[9],$x70,$offload
|
||||
vaddu${sz}m $G,$G,@X[8]
|
||||
vaddu${sz}m $H,$H,@X[9]
|
||||
bne Loop
|
||||
___
|
||||
$code.=<<___ if ($SZ==4);
|
||||
lvx @X[0],$idx,$Tbl
|
||||
addi $idx,$idx,16
|
||||
vperm $A,$A,$B,$Ki # pack the answer
|
||||
lvx @X[1],$idx,$Tbl
|
||||
vperm $E,$E,$F,$Ki
|
||||
vperm $A,$A,$C,@X[0]
|
||||
vperm $E,$E,$G,@X[0]
|
||||
vperm $A,$A,$D,@X[1]
|
||||
vperm $E,$E,$H,@X[1]
|
||||
stvx_4w $A,$x00,$ctx
|
||||
stvx_4w $E,$x10,$ctx
|
||||
___
|
||||
$code.=<<___ if ($SZ==8);
|
||||
vperm $A,$A,$B,$Ki # pack the answer
|
||||
vperm $C,$C,$D,$Ki
|
||||
vperm $E,$E,$F,$Ki
|
||||
vperm $G,$G,$H,$Ki
|
||||
stvx_u $A,$x00,$ctx
|
||||
stvx_u $C,$x10,$ctx
|
||||
stvx_u $E,$x20,$ctx
|
||||
stvx_u $G,$x30,$ctx
|
||||
___
|
||||
$code.=<<___;
|
||||
li r10,`$FRAME+8*16+15`
|
||||
mtlr $lrsave
|
||||
li r11,`$FRAME+8*16+31`
|
||||
mtspr 256,$vrsave
|
||||
lvx v20,r10,$sp # ABI says so
|
||||
addi r10,r10,32
|
||||
lvx v21,r11,$sp
|
||||
addi r11,r11,32
|
||||
lvx v22,r10,$sp
|
||||
addi r10,r10,32
|
||||
lvx v23,r11,$sp
|
||||
addi r11,r11,32
|
||||
lvx v24,r10,$sp
|
||||
addi r10,r10,32
|
||||
lvx v25,r11,$sp
|
||||
addi r11,r11,32
|
||||
lvx v26,r10,$sp
|
||||
addi r10,r10,32
|
||||
lvx v27,r11,$sp
|
||||
addi r11,r11,32
|
||||
lvx v28,r10,$sp
|
||||
addi r10,r10,32
|
||||
lvx v29,r11,$sp
|
||||
addi r11,r11,32
|
||||
lvx v30,r10,$sp
|
||||
lvx v31,r11,$sp
|
||||
$POP r26,`$FRAME+21*16+0*$SIZE_T`($sp)
|
||||
$POP r27,`$FRAME+21*16+1*$SIZE_T`($sp)
|
||||
$POP r28,`$FRAME+21*16+2*$SIZE_T`($sp)
|
||||
$POP r29,`$FRAME+21*16+3*$SIZE_T`($sp)
|
||||
$POP r30,`$FRAME+21*16+4*$SIZE_T`($sp)
|
||||
$POP r31,`$FRAME+21*16+5*$SIZE_T`($sp)
|
||||
addi $sp,$sp,`$FRAME+21*16+6*$SIZE_T`
|
||||
blr
|
||||
.long 0
|
||||
.byte 0,12,4,1,0x80,6,3,0
|
||||
.long 0
|
||||
.size $func,.-$func
|
||||
___
|
||||
|
||||
# Ugly hack here, because PPC assembler syntax seem to vary too
|
||||
# much from platforms to platform...
|
||||
$code.=<<___;
|
||||
.align 6
|
||||
LPICmeup:
|
||||
mflr r0
|
||||
bcl 20,31,\$+4
|
||||
mflr $Tbl ; vvvvvv "distance" between . and 1st data entry
|
||||
addi $Tbl,$Tbl,`64-8`
|
||||
mtlr r0
|
||||
blr
|
||||
.long 0
|
||||
.byte 0,12,0x14,0,0,0,0,0
|
||||
.space `64-9*4`
|
||||
___
|
||||
|
||||
if ($SZ==8) {
|
||||
local *table = sub {
|
||||
foreach(@_) { $code.=".quad $_,$_\n"; }
|
||||
};
|
||||
table(
|
||||
"0x428a2f98d728ae22","0x7137449123ef65cd",
|
||||
"0xb5c0fbcfec4d3b2f","0xe9b5dba58189dbbc",
|
||||
"0x3956c25bf348b538","0x59f111f1b605d019",
|
||||
"0x923f82a4af194f9b","0xab1c5ed5da6d8118",
|
||||
"0xd807aa98a3030242","0x12835b0145706fbe",
|
||||
"0x243185be4ee4b28c","0x550c7dc3d5ffb4e2",
|
||||
"0x72be5d74f27b896f","0x80deb1fe3b1696b1",
|
||||
"0x9bdc06a725c71235","0xc19bf174cf692694",
|
||||
"0xe49b69c19ef14ad2","0xefbe4786384f25e3",
|
||||
"0x0fc19dc68b8cd5b5","0x240ca1cc77ac9c65",
|
||||
"0x2de92c6f592b0275","0x4a7484aa6ea6e483",
|
||||
"0x5cb0a9dcbd41fbd4","0x76f988da831153b5",
|
||||
"0x983e5152ee66dfab","0xa831c66d2db43210",
|
||||
"0xb00327c898fb213f","0xbf597fc7beef0ee4",
|
||||
"0xc6e00bf33da88fc2","0xd5a79147930aa725",
|
||||
"0x06ca6351e003826f","0x142929670a0e6e70",
|
||||
"0x27b70a8546d22ffc","0x2e1b21385c26c926",
|
||||
"0x4d2c6dfc5ac42aed","0x53380d139d95b3df",
|
||||
"0x650a73548baf63de","0x766a0abb3c77b2a8",
|
||||
"0x81c2c92e47edaee6","0x92722c851482353b",
|
||||
"0xa2bfe8a14cf10364","0xa81a664bbc423001",
|
||||
"0xc24b8b70d0f89791","0xc76c51a30654be30",
|
||||
"0xd192e819d6ef5218","0xd69906245565a910",
|
||||
"0xf40e35855771202a","0x106aa07032bbd1b8",
|
||||
"0x19a4c116b8d2d0c8","0x1e376c085141ab53",
|
||||
"0x2748774cdf8eeb99","0x34b0bcb5e19b48a8",
|
||||
"0x391c0cb3c5c95a63","0x4ed8aa4ae3418acb",
|
||||
"0x5b9cca4f7763e373","0x682e6ff3d6b2b8a3",
|
||||
"0x748f82ee5defb2fc","0x78a5636f43172f60",
|
||||
"0x84c87814a1f0ab72","0x8cc702081a6439ec",
|
||||
"0x90befffa23631e28","0xa4506cebde82bde9",
|
||||
"0xbef9a3f7b2c67915","0xc67178f2e372532b",
|
||||
"0xca273eceea26619c","0xd186b8c721c0c207",
|
||||
"0xeada7dd6cde0eb1e","0xf57d4f7fee6ed178",
|
||||
"0x06f067aa72176fba","0x0a637dc5a2c898a6",
|
||||
"0x113f9804bef90dae","0x1b710b35131c471b",
|
||||
"0x28db77f523047d84","0x32caab7b40c72493",
|
||||
"0x3c9ebe0a15c9bebc","0x431d67c49c100d4c",
|
||||
"0x4cc5d4becb3e42b6","0x597f299cfc657e2a",
|
||||
"0x5fcb6fab3ad6faec","0x6c44198c4a475817","0");
|
||||
$code.=<<___ if (!$LENDIAN);
|
||||
.quad 0x0001020304050607,0x1011121314151617
|
||||
___
|
||||
$code.=<<___ if ($LENDIAN); # quad-swapped
|
||||
.quad 0x1011121314151617,0x0001020304050607
|
||||
___
|
||||
} else {
|
||||
local *table = sub {
|
||||
foreach(@_) { $code.=".long $_,$_,$_,$_\n"; }
|
||||
};
|
||||
table(
|
||||
"0x428a2f98","0x71374491","0xb5c0fbcf","0xe9b5dba5",
|
||||
"0x3956c25b","0x59f111f1","0x923f82a4","0xab1c5ed5",
|
||||
"0xd807aa98","0x12835b01","0x243185be","0x550c7dc3",
|
||||
"0x72be5d74","0x80deb1fe","0x9bdc06a7","0xc19bf174",
|
||||
"0xe49b69c1","0xefbe4786","0x0fc19dc6","0x240ca1cc",
|
||||
"0x2de92c6f","0x4a7484aa","0x5cb0a9dc","0x76f988da",
|
||||
"0x983e5152","0xa831c66d","0xb00327c8","0xbf597fc7",
|
||||
"0xc6e00bf3","0xd5a79147","0x06ca6351","0x14292967",
|
||||
"0x27b70a85","0x2e1b2138","0x4d2c6dfc","0x53380d13",
|
||||
"0x650a7354","0x766a0abb","0x81c2c92e","0x92722c85",
|
||||
"0xa2bfe8a1","0xa81a664b","0xc24b8b70","0xc76c51a3",
|
||||
"0xd192e819","0xd6990624","0xf40e3585","0x106aa070",
|
||||
"0x19a4c116","0x1e376c08","0x2748774c","0x34b0bcb5",
|
||||
"0x391c0cb3","0x4ed8aa4a","0x5b9cca4f","0x682e6ff3",
|
||||
"0x748f82ee","0x78a5636f","0x84c87814","0x8cc70208",
|
||||
"0x90befffa","0xa4506ceb","0xbef9a3f7","0xc67178f2","0");
|
||||
$code.=<<___ if (!$LENDIAN);
|
||||
.long 0x00010203,0x10111213,0x10111213,0x10111213
|
||||
.long 0x00010203,0x04050607,0x10111213,0x10111213
|
||||
.long 0x00010203,0x04050607,0x08090a0b,0x10111213
|
||||
___
|
||||
$code.=<<___ if ($LENDIAN); # word-swapped
|
||||
.long 0x10111213,0x10111213,0x10111213,0x00010203
|
||||
.long 0x10111213,0x10111213,0x04050607,0x00010203
|
||||
.long 0x10111213,0x08090a0b,0x04050607,0x00010203
|
||||
___
|
||||
}
|
||||
$code.=<<___;
|
||||
.asciz "SHA${bits} for PowerISA 2.07, CRYPTOGAMS by <appro\@openssl.org>"
|
||||
.align 2
|
||||
___
|
||||
|
||||
$code =~ s/\`([^\`]*)\`/eval $1/gem;
|
||||
print $code;
|
||||
close STDOUT;
|
||||
106
crypto/sha/sha.c
106
crypto/sha/sha.c
@@ -5,21 +5,21 @@
|
||||
* This package is an SSL implementation written
|
||||
* by Eric Young (eay@cryptsoft.com).
|
||||
* The implementation was written so as to conform with Netscapes SSL.
|
||||
*
|
||||
*
|
||||
* This library is free for commercial and non-commercial use as long as
|
||||
* the following conditions are aheared to. The following conditions
|
||||
* apply to all code found in this distribution, be it the RC4, RSA,
|
||||
* lhash, DES, etc., code; not just the SSL code. The SSL documentation
|
||||
* included with this distribution is covered by the same copyright terms
|
||||
* except that the holder is Tim Hudson (tjh@cryptsoft.com).
|
||||
*
|
||||
*
|
||||
* Copyright remains Eric Young's, and as such any Copyright notices in
|
||||
* the code are not to be removed.
|
||||
* If this package is used in a product, Eric Young should be given attribution
|
||||
* as the author of the parts of the library used.
|
||||
* This can be in the form of a textual message at program startup or
|
||||
* in documentation (online or textual) provided with the package.
|
||||
*
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
@@ -34,10 +34,10 @@
|
||||
* Eric Young (eay@cryptsoft.com)"
|
||||
* The word 'cryptographic' can be left out if the rouines from the library
|
||||
* being used are not cryptographic related :-).
|
||||
* 4. If you include any Windows specific code (or a derivative thereof) from
|
||||
* 4. If you include any Windows specific code (or a derivative thereof) from
|
||||
* the apps directory (application code) you must include an acknowledgement:
|
||||
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
|
||||
*
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
@@ -49,7 +49,7 @@
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*
|
||||
*
|
||||
* The licence and distribution terms for any publically available version or
|
||||
* derivative of this code cannot be changed. i.e. this code cannot simply be
|
||||
* copied and put under another distribution licence
|
||||
@@ -60,65 +60,59 @@
|
||||
#include <stdlib.h>
|
||||
#include <openssl/sha.h>
|
||||
|
||||
#define BUFSIZE 1024*16
|
||||
#define BUFSIZE 1024*16
|
||||
|
||||
void do_fp(FILE *f);
|
||||
void pt(unsigned char *md);
|
||||
int read(int, void *, unsigned int);
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
int i,err=0;
|
||||
FILE *IN;
|
||||
{
|
||||
int i, err = 0;
|
||||
FILE *IN;
|
||||
|
||||
if (argc == 1)
|
||||
{
|
||||
do_fp(stdin);
|
||||
}
|
||||
else
|
||||
{
|
||||
for (i=1; i<argc; i++)
|
||||
{
|
||||
IN=fopen(argv[i],"r");
|
||||
if (IN == NULL)
|
||||
{
|
||||
perror(argv[i]);
|
||||
err++;
|
||||
continue;
|
||||
}
|
||||
printf("SHA(%s)= ",argv[i]);
|
||||
do_fp(IN);
|
||||
fclose(IN);
|
||||
}
|
||||
}
|
||||
exit(err);
|
||||
}
|
||||
if (argc == 1) {
|
||||
do_fp(stdin);
|
||||
} else {
|
||||
for (i = 1; i < argc; i++) {
|
||||
IN = fopen(argv[i], "r");
|
||||
if (IN == NULL) {
|
||||
perror(argv[i]);
|
||||
err++;
|
||||
continue;
|
||||
}
|
||||
printf("SHA(%s)= ", argv[i]);
|
||||
do_fp(IN);
|
||||
fclose(IN);
|
||||
}
|
||||
}
|
||||
exit(err);
|
||||
}
|
||||
|
||||
void do_fp(FILE *f)
|
||||
{
|
||||
SHA_CTX c;
|
||||
unsigned char md[SHA_DIGEST_LENGTH];
|
||||
int fd;
|
||||
int i;
|
||||
unsigned char buf[BUFSIZE];
|
||||
{
|
||||
SHA_CTX c;
|
||||
unsigned char md[SHA_DIGEST_LENGTH];
|
||||
int fd;
|
||||
int i;
|
||||
unsigned char buf[BUFSIZE];
|
||||
|
||||
fd=fileno(f);
|
||||
SHA_Init(&c);
|
||||
for (;;)
|
||||
{
|
||||
i=read(fd,buf,BUFSIZE);
|
||||
if (i <= 0) break;
|
||||
SHA_Update(&c,buf,(unsigned long)i);
|
||||
}
|
||||
SHA_Final(&(md[0]),&c);
|
||||
pt(md);
|
||||
}
|
||||
fd = fileno(f);
|
||||
SHA_Init(&c);
|
||||
for (;;) {
|
||||
i = read(fd, buf, BUFSIZE);
|
||||
if (i <= 0)
|
||||
break;
|
||||
SHA_Update(&c, buf, (unsigned long)i);
|
||||
}
|
||||
SHA_Final(&(md[0]), &c);
|
||||
pt(md);
|
||||
}
|
||||
|
||||
void pt(unsigned char *md)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i=0; i<SHA_DIGEST_LENGTH; i++)
|
||||
printf("%02x",md[i]);
|
||||
printf("\n");
|
||||
}
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < SHA_DIGEST_LENGTH; i++)
|
||||
printf("%02x", md[i]);
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
190
crypto/sha/sha.h
190
crypto/sha/sha.h
@@ -5,21 +5,21 @@
|
||||
* This package is an SSL implementation written
|
||||
* by Eric Young (eay@cryptsoft.com).
|
||||
* The implementation was written so as to conform with Netscapes SSL.
|
||||
*
|
||||
*
|
||||
* This library is free for commercial and non-commercial use as long as
|
||||
* the following conditions are aheared to. The following conditions
|
||||
* apply to all code found in this distribution, be it the RC4, RSA,
|
||||
* lhash, DES, etc., code; not just the SSL code. The SSL documentation
|
||||
* included with this distribution is covered by the same copyright terms
|
||||
* except that the holder is Tim Hudson (tjh@cryptsoft.com).
|
||||
*
|
||||
*
|
||||
* Copyright remains Eric Young's, and as such any Copyright notices in
|
||||
* the code are not to be removed.
|
||||
* If this package is used in a product, Eric Young should be given attribution
|
||||
* as the author of the parts of the library used.
|
||||
* This can be in the form of a textual message at program startup or
|
||||
* in documentation (online or textual) provided with the package.
|
||||
*
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
@@ -34,10 +34,10 @@
|
||||
* Eric Young (eay@cryptsoft.com)"
|
||||
* The word 'cryptographic' can be left out if the rouines from the library
|
||||
* being used are not cryptographic related :-).
|
||||
* 4. If you include any Windows specific code (or a derivative thereof) from
|
||||
* 4. If you include any Windows specific code (or a derivative thereof) from
|
||||
* the apps directory (application code) you must include an acknowledgement:
|
||||
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
|
||||
*
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
@@ -49,7 +49,7 @@
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*
|
||||
*
|
||||
* The licence and distribution terms for any publically available version or
|
||||
* derivative of this code cannot be changed. i.e. this code cannot simply be
|
||||
* copied and put under another distribution licence
|
||||
@@ -57,141 +57,155 @@
|
||||
*/
|
||||
|
||||
#ifndef HEADER_SHA_H
|
||||
#define HEADER_SHA_H
|
||||
# define HEADER_SHA_H
|
||||
|
||||
#include <openssl/e_os2.h>
|
||||
#include <stddef.h>
|
||||
# include <openssl/e_os2.h>
|
||||
# include <stddef.h>
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#if defined(OPENSSL_NO_SHA) || (defined(OPENSSL_NO_SHA0) && defined(OPENSSL_NO_SHA1))
|
||||
#error SHA is disabled.
|
||||
#endif
|
||||
# if defined(OPENSSL_NO_SHA) || (defined(OPENSSL_NO_SHA0) && defined(OPENSSL_NO_SHA1))
|
||||
# error SHA is disabled.
|
||||
# endif
|
||||
|
||||
#if defined(OPENSSL_FIPS)
|
||||
#define FIPS_SHA_SIZE_T size_t
|
||||
#endif
|
||||
# if defined(OPENSSL_FIPS)
|
||||
# define FIPS_SHA_SIZE_T size_t
|
||||
# endif
|
||||
|
||||
/*
|
||||
/*-
|
||||
* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
||||
* ! SHA_LONG has to be at least 32 bits wide. If it's wider, then !
|
||||
* ! SHA_LONG_LOG2 has to be defined along. !
|
||||
* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
||||
*/
|
||||
|
||||
#if defined(__LP32__)
|
||||
#define SHA_LONG unsigned long
|
||||
#elif defined(OPENSSL_SYS_CRAY) || defined(__ILP64__)
|
||||
#define SHA_LONG unsigned long
|
||||
#define SHA_LONG_LOG2 3
|
||||
#else
|
||||
#define SHA_LONG unsigned int
|
||||
#endif
|
||||
# if defined(__LP32__)
|
||||
# define SHA_LONG unsigned long
|
||||
# elif defined(OPENSSL_SYS_CRAY) || defined(__ILP64__)
|
||||
# define SHA_LONG unsigned long
|
||||
# define SHA_LONG_LOG2 3
|
||||
# else
|
||||
# define SHA_LONG unsigned int
|
||||
# endif
|
||||
|
||||
#define SHA_LBLOCK 16
|
||||
#define SHA_CBLOCK (SHA_LBLOCK*4) /* SHA treats input data as a
|
||||
* contiguous array of 32 bit
|
||||
* wide big-endian values. */
|
||||
#define SHA_LAST_BLOCK (SHA_CBLOCK-8)
|
||||
#define SHA_DIGEST_LENGTH 20
|
||||
# define SHA_LBLOCK 16
|
||||
# define SHA_CBLOCK (SHA_LBLOCK*4)/* SHA treats input data as a
|
||||
* contiguous array of 32 bit wide
|
||||
* big-endian values. */
|
||||
# define SHA_LAST_BLOCK (SHA_CBLOCK-8)
|
||||
# define SHA_DIGEST_LENGTH 20
|
||||
|
||||
typedef struct SHAstate_st
|
||||
{
|
||||
SHA_LONG h0,h1,h2,h3,h4;
|
||||
SHA_LONG Nl,Nh;
|
||||
SHA_LONG data[SHA_LBLOCK];
|
||||
unsigned int num;
|
||||
} SHA_CTX;
|
||||
typedef struct SHAstate_st {
|
||||
SHA_LONG h0, h1, h2, h3, h4;
|
||||
SHA_LONG Nl, Nh;
|
||||
SHA_LONG data[SHA_LBLOCK];
|
||||
unsigned int num;
|
||||
} SHA_CTX;
|
||||
|
||||
#ifndef OPENSSL_NO_SHA0
|
||||
# ifndef OPENSSL_NO_SHA0
|
||||
# ifdef OPENSSL_FIPS
|
||||
int private_SHA_Init(SHA_CTX *c);
|
||||
# endif
|
||||
int SHA_Init(SHA_CTX *c);
|
||||
int SHA_Update(SHA_CTX *c, const void *data, size_t len);
|
||||
int SHA_Final(unsigned char *md, SHA_CTX *c);
|
||||
unsigned char *SHA(const unsigned char *d, size_t n, unsigned char *md);
|
||||
void SHA_Transform(SHA_CTX *c, const unsigned char *data);
|
||||
#endif
|
||||
#ifndef OPENSSL_NO_SHA1
|
||||
# endif
|
||||
# ifndef OPENSSL_NO_SHA1
|
||||
# ifdef OPENSSL_FIPS
|
||||
int private_SHA1_Init(SHA_CTX *c);
|
||||
# endif
|
||||
int SHA1_Init(SHA_CTX *c);
|
||||
int SHA1_Update(SHA_CTX *c, const void *data, size_t len);
|
||||
int SHA1_Final(unsigned char *md, SHA_CTX *c);
|
||||
unsigned char *SHA1(const unsigned char *d, size_t n, unsigned char *md);
|
||||
void SHA1_Transform(SHA_CTX *c, const unsigned char *data);
|
||||
#endif
|
||||
# endif
|
||||
|
||||
#define SHA256_CBLOCK (SHA_LBLOCK*4) /* SHA-256 treats input data as a
|
||||
* contiguous array of 32 bit
|
||||
* wide big-endian values. */
|
||||
#define SHA224_DIGEST_LENGTH 28
|
||||
#define SHA256_DIGEST_LENGTH 32
|
||||
# define SHA256_CBLOCK (SHA_LBLOCK*4)/* SHA-256 treats input data as a
|
||||
* contiguous array of 32 bit wide
|
||||
* big-endian values. */
|
||||
# define SHA224_DIGEST_LENGTH 28
|
||||
# define SHA256_DIGEST_LENGTH 32
|
||||
|
||||
typedef struct SHA256state_st
|
||||
{
|
||||
SHA_LONG h[8];
|
||||
SHA_LONG Nl,Nh;
|
||||
SHA_LONG data[SHA_LBLOCK];
|
||||
unsigned int num,md_len;
|
||||
} SHA256_CTX;
|
||||
typedef struct SHA256state_st {
|
||||
SHA_LONG h[8];
|
||||
SHA_LONG Nl, Nh;
|
||||
SHA_LONG data[SHA_LBLOCK];
|
||||
unsigned int num, md_len;
|
||||
} SHA256_CTX;
|
||||
|
||||
#ifndef OPENSSL_NO_SHA256
|
||||
# ifndef OPENSSL_NO_SHA256
|
||||
# ifdef OPENSSL_FIPS
|
||||
int private_SHA224_Init(SHA256_CTX *c);
|
||||
int private_SHA256_Init(SHA256_CTX *c);
|
||||
# endif
|
||||
int SHA224_Init(SHA256_CTX *c);
|
||||
int SHA224_Update(SHA256_CTX *c, const void *data, size_t len);
|
||||
int SHA224_Final(unsigned char *md, SHA256_CTX *c);
|
||||
unsigned char *SHA224(const unsigned char *d, size_t n,unsigned char *md);
|
||||
unsigned char *SHA224(const unsigned char *d, size_t n, unsigned char *md);
|
||||
int SHA256_Init(SHA256_CTX *c);
|
||||
int SHA256_Update(SHA256_CTX *c, const void *data, size_t len);
|
||||
int SHA256_Final(unsigned char *md, SHA256_CTX *c);
|
||||
unsigned char *SHA256(const unsigned char *d, size_t n,unsigned char *md);
|
||||
unsigned char *SHA256(const unsigned char *d, size_t n, unsigned char *md);
|
||||
void SHA256_Transform(SHA256_CTX *c, const unsigned char *data);
|
||||
#endif
|
||||
# endif
|
||||
|
||||
#define SHA384_DIGEST_LENGTH 48
|
||||
#define SHA512_DIGEST_LENGTH 64
|
||||
# define SHA384_DIGEST_LENGTH 48
|
||||
# define SHA512_DIGEST_LENGTH 64
|
||||
|
||||
#ifndef OPENSSL_NO_SHA512
|
||||
# ifndef OPENSSL_NO_SHA512
|
||||
/*
|
||||
* Unlike 32-bit digest algorithms, SHA-512 *relies* on SHA_LONG64
|
||||
* being exactly 64-bit wide. See Implementation Notes in sha512.c
|
||||
* for further details.
|
||||
*/
|
||||
#define SHA512_CBLOCK (SHA_LBLOCK*8) /* SHA-512 treats input data as a
|
||||
* contiguous array of 64 bit
|
||||
* wide big-endian values. */
|
||||
#if (defined(_WIN32) || defined(_WIN64)) && !defined(__MINGW32__)
|
||||
#define SHA_LONG64 unsigned __int64
|
||||
#define U64(C) C##UI64
|
||||
#elif defined(__arch64__)
|
||||
#define SHA_LONG64 unsigned long
|
||||
#define U64(C) C##UL
|
||||
#else
|
||||
#define SHA_LONG64 unsigned long long
|
||||
#define U64(C) C##ULL
|
||||
#endif
|
||||
/*
|
||||
* SHA-512 treats input data as a
|
||||
* contiguous array of 64 bit
|
||||
* wide big-endian values.
|
||||
*/
|
||||
# define SHA512_CBLOCK (SHA_LBLOCK*8)
|
||||
# if (defined(_WIN32) || defined(_WIN64)) && !defined(__MINGW32__)
|
||||
# define SHA_LONG64 unsigned __int64
|
||||
# define U64(C) C##UI64
|
||||
# elif defined(__arch64__)
|
||||
# define SHA_LONG64 unsigned long
|
||||
# define U64(C) C##UL
|
||||
# else
|
||||
# define SHA_LONG64 unsigned long long
|
||||
# define U64(C) C##ULL
|
||||
# endif
|
||||
|
||||
typedef struct SHA512state_st
|
||||
{
|
||||
SHA_LONG64 h[8];
|
||||
SHA_LONG64 Nl,Nh;
|
||||
union {
|
||||
SHA_LONG64 d[SHA_LBLOCK];
|
||||
unsigned char p[SHA512_CBLOCK];
|
||||
} u;
|
||||
unsigned int num,md_len;
|
||||
} SHA512_CTX;
|
||||
#endif
|
||||
typedef struct SHA512state_st {
|
||||
SHA_LONG64 h[8];
|
||||
SHA_LONG64 Nl, Nh;
|
||||
union {
|
||||
SHA_LONG64 d[SHA_LBLOCK];
|
||||
unsigned char p[SHA512_CBLOCK];
|
||||
} u;
|
||||
unsigned int num, md_len;
|
||||
} SHA512_CTX;
|
||||
# endif
|
||||
|
||||
#ifndef OPENSSL_NO_SHA512
|
||||
# ifndef OPENSSL_NO_SHA512
|
||||
# ifdef OPENSSL_FIPS
|
||||
int private_SHA384_Init(SHA512_CTX *c);
|
||||
int private_SHA512_Init(SHA512_CTX *c);
|
||||
# endif
|
||||
int SHA384_Init(SHA512_CTX *c);
|
||||
int SHA384_Update(SHA512_CTX *c, const void *data, size_t len);
|
||||
int SHA384_Final(unsigned char *md, SHA512_CTX *c);
|
||||
unsigned char *SHA384(const unsigned char *d, size_t n,unsigned char *md);
|
||||
unsigned char *SHA384(const unsigned char *d, size_t n, unsigned char *md);
|
||||
int SHA512_Init(SHA512_CTX *c);
|
||||
int SHA512_Update(SHA512_CTX *c, const void *data, size_t len);
|
||||
int SHA512_Final(unsigned char *md, SHA512_CTX *c);
|
||||
unsigned char *SHA512(const unsigned char *d, size_t n,unsigned char *md);
|
||||
unsigned char *SHA512(const unsigned char *d, size_t n, unsigned char *md);
|
||||
void SHA512_Transform(SHA512_CTX *c, const unsigned char *data);
|
||||
#endif
|
||||
# endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
||||
Binary file not shown.
File diff suppressed because it is too large
Load Diff
@@ -5,21 +5,21 @@
|
||||
* This package is an SSL implementation written
|
||||
* by Eric Young (eay@cryptsoft.com).
|
||||
* The implementation was written so as to conform with Netscapes SSL.
|
||||
*
|
||||
*
|
||||
* This library is free for commercial and non-commercial use as long as
|
||||
* the following conditions are aheared to. The following conditions
|
||||
* apply to all code found in this distribution, be it the RC4, RSA,
|
||||
* lhash, DES, etc., code; not just the SSL code. The SSL documentation
|
||||
* included with this distribution is covered by the same copyright terms
|
||||
* except that the holder is Tim Hudson (tjh@cryptsoft.com).
|
||||
*
|
||||
*
|
||||
* Copyright remains Eric Young's, and as such any Copyright notices in
|
||||
* the code are not to be removed.
|
||||
* If this package is used in a product, Eric Young should be given attribution
|
||||
* as the author of the parts of the library used.
|
||||
* This can be in the form of a textual message at program startup or
|
||||
* in documentation (online or textual) provided with the package.
|
||||
*
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
@@ -34,10 +34,10 @@
|
||||
* Eric Young (eay@cryptsoft.com)"
|
||||
* The word 'cryptographic' can be left out if the rouines from the library
|
||||
* being used are not cryptographic related :-).
|
||||
* 4. If you include any Windows specific code (or a derivative thereof) from
|
||||
* 4. If you include any Windows specific code (or a derivative thereof) from
|
||||
* the apps directory (application code) you must include an acknowledgement:
|
||||
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
|
||||
*
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
@@ -49,7 +49,7 @@
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*
|
||||
*
|
||||
* The licence and distribution terms for any publically available version or
|
||||
* derivative of this code cannot be changed. i.e. this code cannot simply be
|
||||
* copied and put under another distribution licence
|
||||
@@ -60,7 +60,7 @@
|
||||
#include <stdlib.h>
|
||||
#include <openssl/sha.h>
|
||||
|
||||
#define BUFSIZE 1024*16
|
||||
#define BUFSIZE 1024*16
|
||||
|
||||
void do_fp(FILE *f);
|
||||
void pt(unsigned char *md);
|
||||
@@ -69,59 +69,53 @@ int read(int, void *, unsigned int);
|
||||
#endif
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
int i,err=0;
|
||||
FILE *IN;
|
||||
{
|
||||
int i, err = 0;
|
||||
FILE *IN;
|
||||
|
||||
if (argc == 1)
|
||||
{
|
||||
do_fp(stdin);
|
||||
}
|
||||
else
|
||||
{
|
||||
for (i=1; i<argc; i++)
|
||||
{
|
||||
IN=fopen(argv[i],"r");
|
||||
if (IN == NULL)
|
||||
{
|
||||
perror(argv[i]);
|
||||
err++;
|
||||
continue;
|
||||
}
|
||||
printf("SHA1(%s)= ",argv[i]);
|
||||
do_fp(IN);
|
||||
fclose(IN);
|
||||
}
|
||||
}
|
||||
exit(err);
|
||||
}
|
||||
if (argc == 1) {
|
||||
do_fp(stdin);
|
||||
} else {
|
||||
for (i = 1; i < argc; i++) {
|
||||
IN = fopen(argv[i], "r");
|
||||
if (IN == NULL) {
|
||||
perror(argv[i]);
|
||||
err++;
|
||||
continue;
|
||||
}
|
||||
printf("SHA1(%s)= ", argv[i]);
|
||||
do_fp(IN);
|
||||
fclose(IN);
|
||||
}
|
||||
}
|
||||
exit(err);
|
||||
}
|
||||
|
||||
void do_fp(FILE *f)
|
||||
{
|
||||
SHA_CTX c;
|
||||
unsigned char md[SHA_DIGEST_LENGTH];
|
||||
int fd;
|
||||
int i;
|
||||
unsigned char buf[BUFSIZE];
|
||||
{
|
||||
SHA_CTX c;
|
||||
unsigned char md[SHA_DIGEST_LENGTH];
|
||||
int fd;
|
||||
int i;
|
||||
unsigned char buf[BUFSIZE];
|
||||
|
||||
fd=fileno(f);
|
||||
SHA1_Init(&c);
|
||||
for (;;)
|
||||
{
|
||||
i=read(fd,buf,BUFSIZE);
|
||||
if (i <= 0) break;
|
||||
SHA1_Update(&c,buf,(unsigned long)i);
|
||||
}
|
||||
SHA1_Final(&(md[0]),&c);
|
||||
pt(md);
|
||||
}
|
||||
fd = fileno(f);
|
||||
SHA1_Init(&c);
|
||||
for (;;) {
|
||||
i = read(fd, buf, BUFSIZE);
|
||||
if (i <= 0)
|
||||
break;
|
||||
SHA1_Update(&c, buf, (unsigned long)i);
|
||||
}
|
||||
SHA1_Final(&(md[0]), &c);
|
||||
pt(md);
|
||||
}
|
||||
|
||||
void pt(unsigned char *md)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i=0; i<SHA_DIGEST_LENGTH; i++)
|
||||
printf("%02x",md[i]);
|
||||
printf("\n");
|
||||
}
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < SHA_DIGEST_LENGTH; i++)
|
||||
printf("%02x", md[i]);
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
@@ -5,21 +5,21 @@
|
||||
* This package is an SSL implementation written
|
||||
* by Eric Young (eay@cryptsoft.com).
|
||||
* The implementation was written so as to conform with Netscapes SSL.
|
||||
*
|
||||
*
|
||||
* This library is free for commercial and non-commercial use as long as
|
||||
* the following conditions are aheared to. The following conditions
|
||||
* apply to all code found in this distribution, be it the RC4, RSA,
|
||||
* lhash, DES, etc., code; not just the SSL code. The SSL documentation
|
||||
* included with this distribution is covered by the same copyright terms
|
||||
* except that the holder is Tim Hudson (tjh@cryptsoft.com).
|
||||
*
|
||||
*
|
||||
* Copyright remains Eric Young's, and as such any Copyright notices in
|
||||
* the code are not to be removed.
|
||||
* If this package is used in a product, Eric Young should be given attribution
|
||||
* as the author of the parts of the library used.
|
||||
* This can be in the form of a textual message at program startup or
|
||||
* in documentation (online or textual) provided with the package.
|
||||
*
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
@@ -34,10 +34,10 @@
|
||||
* Eric Young (eay@cryptsoft.com)"
|
||||
* The word 'cryptographic' can be left out if the rouines from the library
|
||||
* being used are not cryptographic related :-).
|
||||
* 4. If you include any Windows specific code (or a derivative thereof) from
|
||||
* 4. If you include any Windows specific code (or a derivative thereof) from
|
||||
* the apps directory (application code) you must include an acknowledgement:
|
||||
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
|
||||
*
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
@@ -49,7 +49,7 @@
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*
|
||||
*
|
||||
* The licence and distribution terms for any publically available version or
|
||||
* derivative of this code cannot be changed. i.e. this code cannot simply be
|
||||
* copied and put under another distribution licence
|
||||
@@ -58,21 +58,22 @@
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <openssl/sha.h>
|
||||
#include <openssl/crypto.h>
|
||||
#include <openssl/sha.h>
|
||||
|
||||
#ifndef OPENSSL_NO_SHA1
|
||||
unsigned char *SHA1(const unsigned char *d, size_t n, unsigned char *md)
|
||||
{
|
||||
SHA_CTX c;
|
||||
static unsigned char m[SHA_DIGEST_LENGTH];
|
||||
{
|
||||
SHA_CTX c;
|
||||
static unsigned char m[SHA_DIGEST_LENGTH];
|
||||
|
||||
if (md == NULL) md=m;
|
||||
if (!SHA1_Init(&c))
|
||||
return NULL;
|
||||
SHA1_Update(&c,d,n);
|
||||
SHA1_Final(md,&c);
|
||||
OPENSSL_cleanse(&c,sizeof(c));
|
||||
return(md);
|
||||
}
|
||||
if (md == NULL)
|
||||
md = m;
|
||||
if (!SHA1_Init(&c))
|
||||
return NULL;
|
||||
SHA1_Update(&c, d, n);
|
||||
SHA1_Final(md, &c);
|
||||
OPENSSL_cleanse(&c, sizeof(c));
|
||||
return (md);
|
||||
}
|
||||
#endif
|
||||
|
||||
Binary file not shown.
@@ -5,21 +5,21 @@
|
||||
* This package is an SSL implementation written
|
||||
* by Eric Young (eay@cryptsoft.com).
|
||||
* The implementation was written so as to conform with Netscapes SSL.
|
||||
*
|
||||
*
|
||||
* This library is free for commercial and non-commercial use as long as
|
||||
* the following conditions are aheared to. The following conditions
|
||||
* apply to all code found in this distribution, be it the RC4, RSA,
|
||||
* lhash, DES, etc., code; not just the SSL code. The SSL documentation
|
||||
* included with this distribution is covered by the same copyright terms
|
||||
* except that the holder is Tim Hudson (tjh@cryptsoft.com).
|
||||
*
|
||||
*
|
||||
* Copyright remains Eric Young's, and as such any Copyright notices in
|
||||
* the code are not to be removed.
|
||||
* If this package is used in a product, Eric Young should be given attribution
|
||||
* as the author of the parts of the library used.
|
||||
* This can be in the form of a textual message at program startup or
|
||||
* in documentation (online or textual) provided with the package.
|
||||
*
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
@@ -34,10 +34,10 @@
|
||||
* Eric Young (eay@cryptsoft.com)"
|
||||
* The word 'cryptographic' can be left out if the rouines from the library
|
||||
* being used are not cryptographic related :-).
|
||||
* 4. If you include any Windows specific code (or a derivative thereof) from
|
||||
* 4. If you include any Windows specific code (or a derivative thereof) from
|
||||
* the apps directory (application code) you must include an acknowledgement:
|
||||
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
|
||||
*
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
@@ -49,26 +49,26 @@
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*
|
||||
*
|
||||
* The licence and distribution terms for any publically available version or
|
||||
* derivative of this code cannot be changed. i.e. this code cannot simply be
|
||||
* copied and put under another distribution licence
|
||||
* [including the GNU Public Licence.]
|
||||
*/
|
||||
|
||||
#include <openssl/crypto.h>
|
||||
#include <openssl/opensslconf.h>
|
||||
#if !defined(OPENSSL_NO_SHA1) && !defined(OPENSSL_NO_SHA)
|
||||
|
||||
#undef SHA_0
|
||||
#define SHA_1
|
||||
# undef SHA_0
|
||||
# define SHA_1
|
||||
|
||||
#include <openssl/opensslv.h>
|
||||
# include <openssl/opensslv.h>
|
||||
|
||||
const char SHA1_version[]="SHA1" OPENSSL_VERSION_PTEXT;
|
||||
const char SHA1_version[] = "SHA1" OPENSSL_VERSION_PTEXT;
|
||||
|
||||
/* The implementation is in ../md32_common.h */
|
||||
|
||||
#include "sha_locl.h"
|
||||
# include "sha_locl.h"
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
Binary file not shown.
@@ -5,21 +5,21 @@
|
||||
* This package is an SSL implementation written
|
||||
* by Eric Young (eay@cryptsoft.com).
|
||||
* The implementation was written so as to conform with Netscapes SSL.
|
||||
*
|
||||
*
|
||||
* This library is free for commercial and non-commercial use as long as
|
||||
* the following conditions are aheared to. The following conditions
|
||||
* apply to all code found in this distribution, be it the RC4, RSA,
|
||||
* lhash, DES, etc., code; not just the SSL code. The SSL documentation
|
||||
* included with this distribution is covered by the same copyright terms
|
||||
* except that the holder is Tim Hudson (tjh@cryptsoft.com).
|
||||
*
|
||||
*
|
||||
* Copyright remains Eric Young's, and as such any Copyright notices in
|
||||
* the code are not to be removed.
|
||||
* If this package is used in a product, Eric Young should be given attribution
|
||||
* as the author of the parts of the library used.
|
||||
* This can be in the form of a textual message at program startup or
|
||||
* in documentation (online or textual) provided with the package.
|
||||
*
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
@@ -34,10 +34,10 @@
|
||||
* Eric Young (eay@cryptsoft.com)"
|
||||
* The word 'cryptographic' can be left out if the rouines from the library
|
||||
* being used are not cryptographic related :-).
|
||||
* 4. If you include any Windows specific code (or a derivative thereof) from
|
||||
* 4. If you include any Windows specific code (or a derivative thereof) from
|
||||
* the apps directory (application code) you must include an acknowledgement:
|
||||
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
|
||||
*
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
@@ -49,7 +49,7 @@
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*
|
||||
*
|
||||
* The licence and distribution terms for any publically available version or
|
||||
* derivative of this code cannot be changed. i.e. this code cannot simply be
|
||||
* copied and put under another distribution licence
|
||||
@@ -66,113 +66,109 @@
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
printf("No SHA support\n");
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
#else
|
||||
#include <openssl/evp.h>
|
||||
#include <openssl/sha.h>
|
||||
# include <openssl/evp.h>
|
||||
# include <openssl/sha.h>
|
||||
|
||||
#ifdef CHARSET_EBCDIC
|
||||
#include <openssl/ebcdic.h>
|
||||
#endif
|
||||
# ifdef CHARSET_EBCDIC
|
||||
# include <openssl/ebcdic.h>
|
||||
# endif
|
||||
|
||||
#undef SHA_0 /* FIPS 180 */
|
||||
#define SHA_1 /* FIPS 180-1 */
|
||||
# undef SHA_0 /* FIPS 180 */
|
||||
# define SHA_1 /* FIPS 180-1 */
|
||||
|
||||
static char *test[]={
|
||||
"abc",
|
||||
"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
|
||||
NULL,
|
||||
};
|
||||
static char *test[] = {
|
||||
"abc",
|
||||
"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
|
||||
NULL,
|
||||
};
|
||||
|
||||
#ifdef SHA_0
|
||||
static char *ret[]={
|
||||
"0164b8a914cd2a5e74c4f7ff082c4d97f1edf880",
|
||||
"d2516ee1acfa5baf33dfc1c471e438449ef134c8",
|
||||
};
|
||||
static char *bigret=
|
||||
"3232affa48628a26653b5aaa44541fd90d690603";
|
||||
#endif
|
||||
#ifdef SHA_1
|
||||
static char *ret[]={
|
||||
"a9993e364706816aba3e25717850c26c9cd0d89d",
|
||||
"84983e441c3bd26ebaae4aa1f95129e5e54670f1",
|
||||
};
|
||||
static char *bigret=
|
||||
"34aa973cd4c4daa4f61eeb2bdbad27316534016f";
|
||||
#endif
|
||||
# ifdef SHA_0
|
||||
static char *ret[] = {
|
||||
"0164b8a914cd2a5e74c4f7ff082c4d97f1edf880",
|
||||
"d2516ee1acfa5baf33dfc1c471e438449ef134c8",
|
||||
};
|
||||
|
||||
static char *bigret = "3232affa48628a26653b5aaa44541fd90d690603";
|
||||
# endif
|
||||
# ifdef SHA_1
|
||||
static char *ret[] = {
|
||||
"a9993e364706816aba3e25717850c26c9cd0d89d",
|
||||
"84983e441c3bd26ebaae4aa1f95129e5e54670f1",
|
||||
};
|
||||
|
||||
static char *bigret = "34aa973cd4c4daa4f61eeb2bdbad27316534016f";
|
||||
# endif
|
||||
|
||||
static char *pt(unsigned char *md);
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
int i,err=0;
|
||||
char **P,**R;
|
||||
static unsigned char buf[1000];
|
||||
char *p,*r;
|
||||
EVP_MD_CTX c;
|
||||
unsigned char md[SHA_DIGEST_LENGTH];
|
||||
{
|
||||
int i, err = 0;
|
||||
char **P, **R;
|
||||
static unsigned char buf[1000];
|
||||
char *p, *r;
|
||||
EVP_MD_CTX c;
|
||||
unsigned char md[SHA_DIGEST_LENGTH];
|
||||
|
||||
#ifdef CHARSET_EBCDIC
|
||||
ebcdic2ascii(test[0], test[0], strlen(test[0]));
|
||||
ebcdic2ascii(test[1], test[1], strlen(test[1]));
|
||||
#endif
|
||||
# ifdef CHARSET_EBCDIC
|
||||
ebcdic2ascii(test[0], test[0], strlen(test[0]));
|
||||
ebcdic2ascii(test[1], test[1], strlen(test[1]));
|
||||
# endif
|
||||
|
||||
EVP_MD_CTX_init(&c);
|
||||
P=test;
|
||||
R=ret;
|
||||
i=1;
|
||||
while (*P != NULL)
|
||||
{
|
||||
EVP_Digest(*P,strlen((char *)*P),md,NULL,EVP_sha1(), NULL);
|
||||
p=pt(md);
|
||||
if (strcmp(p,(char *)*R) != 0)
|
||||
{
|
||||
printf("error calculating SHA1 on '%s'\n",*P);
|
||||
printf("got %s instead of %s\n",p,*R);
|
||||
err++;
|
||||
}
|
||||
else
|
||||
printf("test %d ok\n",i);
|
||||
i++;
|
||||
R++;
|
||||
P++;
|
||||
}
|
||||
EVP_MD_CTX_init(&c);
|
||||
P = test;
|
||||
R = ret;
|
||||
i = 1;
|
||||
while (*P != NULL) {
|
||||
EVP_Digest(*P, strlen((char *)*P), md, NULL, EVP_sha1(), NULL);
|
||||
p = pt(md);
|
||||
if (strcmp(p, (char *)*R) != 0) {
|
||||
printf("error calculating SHA1 on '%s'\n", *P);
|
||||
printf("got %s instead of %s\n", p, *R);
|
||||
err++;
|
||||
} else
|
||||
printf("test %d ok\n", i);
|
||||
i++;
|
||||
R++;
|
||||
P++;
|
||||
}
|
||||
|
||||
memset(buf,'a',1000);
|
||||
#ifdef CHARSET_EBCDIC
|
||||
ebcdic2ascii(buf, buf, 1000);
|
||||
#endif /*CHARSET_EBCDIC*/
|
||||
EVP_DigestInit_ex(&c,EVP_sha1(), NULL);
|
||||
for (i=0; i<1000; i++)
|
||||
EVP_DigestUpdate(&c,buf,1000);
|
||||
EVP_DigestFinal_ex(&c,md,NULL);
|
||||
p=pt(md);
|
||||
memset(buf, 'a', 1000);
|
||||
# ifdef CHARSET_EBCDIC
|
||||
ebcdic2ascii(buf, buf, 1000);
|
||||
# endif /* CHARSET_EBCDIC */
|
||||
EVP_DigestInit_ex(&c, EVP_sha1(), NULL);
|
||||
for (i = 0; i < 1000; i++)
|
||||
EVP_DigestUpdate(&c, buf, 1000);
|
||||
EVP_DigestFinal_ex(&c, md, NULL);
|
||||
p = pt(md);
|
||||
|
||||
r=bigret;
|
||||
if (strcmp(p,r) != 0)
|
||||
{
|
||||
printf("error calculating SHA1 on 'a' * 1000\n");
|
||||
printf("got %s instead of %s\n",p,r);
|
||||
err++;
|
||||
}
|
||||
else
|
||||
printf("test 3 ok\n");
|
||||
r = bigret;
|
||||
if (strcmp(p, r) != 0) {
|
||||
printf("error calculating SHA1 on 'a' * 1000\n");
|
||||
printf("got %s instead of %s\n", p, r);
|
||||
err++;
|
||||
} else
|
||||
printf("test 3 ok\n");
|
||||
|
||||
#ifdef OPENSSL_SYS_NETWARE
|
||||
if (err) printf("ERROR: %d\n", err);
|
||||
#endif
|
||||
EXIT(err);
|
||||
EVP_MD_CTX_cleanup(&c);
|
||||
return(0);
|
||||
}
|
||||
# ifdef OPENSSL_SYS_NETWARE
|
||||
if (err)
|
||||
printf("ERROR: %d\n", err);
|
||||
# endif
|
||||
EXIT(err);
|
||||
EVP_MD_CTX_cleanup(&c);
|
||||
return (0);
|
||||
}
|
||||
|
||||
static char *pt(unsigned char *md)
|
||||
{
|
||||
int i;
|
||||
static char buf[80];
|
||||
{
|
||||
int i;
|
||||
static char buf[80];
|
||||
|
||||
for (i=0; i<SHA_DIGEST_LENGTH; i++)
|
||||
sprintf(&(buf[i*2]),"%02x",md[i]);
|
||||
return(buf);
|
||||
}
|
||||
for (i = 0; i < SHA_DIGEST_LENGTH; i++)
|
||||
sprintf(&(buf[i * 2]), "%02x", md[i]);
|
||||
return (buf);
|
||||
}
|
||||
#endif
|
||||
|
||||
Binary file not shown.
@@ -1,259 +0,0 @@
|
||||
.file "sha512-586.s"
|
||||
.text
|
||||
.globl _sha256_block_data_order
|
||||
.align 4
|
||||
_sha256_block_data_order:
|
||||
L_sha256_block_data_order_begin:
|
||||
pushl %ebp
|
||||
pushl %ebx
|
||||
pushl %esi
|
||||
pushl %edi
|
||||
movl 20(%esp),%esi
|
||||
movl 24(%esp),%edi
|
||||
movl 28(%esp),%eax
|
||||
movl %esp,%ebx
|
||||
call L000pic_point
|
||||
L000pic_point:
|
||||
popl %ebp
|
||||
leal L001K256-L000pic_point(%ebp),%ebp
|
||||
subl $16,%esp
|
||||
andl $-64,%esp
|
||||
shll $6,%eax
|
||||
addl %edi,%eax
|
||||
movl %esi,(%esp)
|
||||
movl %edi,4(%esp)
|
||||
movl %eax,8(%esp)
|
||||
movl %ebx,12(%esp)
|
||||
.align 4,0x90
|
||||
L002loop:
|
||||
movl (%edi),%eax
|
||||
movl 4(%edi),%ebx
|
||||
movl 8(%edi),%ecx
|
||||
movl 12(%edi),%edx
|
||||
bswap %eax
|
||||
bswap %ebx
|
||||
bswap %ecx
|
||||
bswap %edx
|
||||
pushl %eax
|
||||
pushl %ebx
|
||||
pushl %ecx
|
||||
pushl %edx
|
||||
movl 16(%edi),%eax
|
||||
movl 20(%edi),%ebx
|
||||
movl 24(%edi),%ecx
|
||||
movl 28(%edi),%edx
|
||||
bswap %eax
|
||||
bswap %ebx
|
||||
bswap %ecx
|
||||
bswap %edx
|
||||
pushl %eax
|
||||
pushl %ebx
|
||||
pushl %ecx
|
||||
pushl %edx
|
||||
movl 32(%edi),%eax
|
||||
movl 36(%edi),%ebx
|
||||
movl 40(%edi),%ecx
|
||||
movl 44(%edi),%edx
|
||||
bswap %eax
|
||||
bswap %ebx
|
||||
bswap %ecx
|
||||
bswap %edx
|
||||
pushl %eax
|
||||
pushl %ebx
|
||||
pushl %ecx
|
||||
pushl %edx
|
||||
movl 48(%edi),%eax
|
||||
movl 52(%edi),%ebx
|
||||
movl 56(%edi),%ecx
|
||||
movl 60(%edi),%edx
|
||||
bswap %eax
|
||||
bswap %ebx
|
||||
bswap %ecx
|
||||
bswap %edx
|
||||
pushl %eax
|
||||
pushl %ebx
|
||||
pushl %ecx
|
||||
pushl %edx
|
||||
addl $64,%edi
|
||||
subl $32,%esp
|
||||
movl %edi,100(%esp)
|
||||
movl (%esi),%eax
|
||||
movl 4(%esi),%ebx
|
||||
movl 8(%esi),%ecx
|
||||
movl 12(%esi),%edi
|
||||
movl %ebx,4(%esp)
|
||||
movl %ecx,8(%esp)
|
||||
movl %edi,12(%esp)
|
||||
movl 16(%esi),%edx
|
||||
movl 20(%esi),%ebx
|
||||
movl 24(%esi),%ecx
|
||||
movl 28(%esi),%edi
|
||||
movl %ebx,20(%esp)
|
||||
movl %ecx,24(%esp)
|
||||
movl %edi,28(%esp)
|
||||
.align 4,0x90
|
||||
L00300_15:
|
||||
movl 92(%esp),%ebx
|
||||
movl %edx,%ecx
|
||||
rorl $6,%ecx
|
||||
movl %edx,%edi
|
||||
rorl $11,%edi
|
||||
movl 20(%esp),%esi
|
||||
xorl %edi,%ecx
|
||||
rorl $14,%edi
|
||||
xorl %edi,%ecx
|
||||
movl 24(%esp),%edi
|
||||
addl %ecx,%ebx
|
||||
movl %edx,16(%esp)
|
||||
xorl %edi,%esi
|
||||
movl %eax,%ecx
|
||||
andl %edx,%esi
|
||||
movl 12(%esp),%edx
|
||||
xorl %edi,%esi
|
||||
movl %eax,%edi
|
||||
addl %esi,%ebx
|
||||
rorl $2,%ecx
|
||||
addl 28(%esp),%ebx
|
||||
rorl $13,%edi
|
||||
movl 4(%esp),%esi
|
||||
xorl %edi,%ecx
|
||||
rorl $9,%edi
|
||||
addl %ebx,%edx
|
||||
xorl %edi,%ecx
|
||||
movl 8(%esp),%edi
|
||||
addl %ecx,%ebx
|
||||
movl %eax,(%esp)
|
||||
movl %eax,%ecx
|
||||
subl $4,%esp
|
||||
orl %esi,%eax
|
||||
andl %esi,%ecx
|
||||
andl %edi,%eax
|
||||
movl (%ebp),%esi
|
||||
orl %ecx,%eax
|
||||
addl $4,%ebp
|
||||
addl %ebx,%eax
|
||||
addl %esi,%edx
|
||||
addl %esi,%eax
|
||||
cmpl $3248222580,%esi
|
||||
jne L00300_15
|
||||
movl 152(%esp),%ebx
|
||||
.align 4,0x90
|
||||
L00416_63:
|
||||
movl %ebx,%esi
|
||||
movl 100(%esp),%ecx
|
||||
shrl $3,%ebx
|
||||
rorl $7,%esi
|
||||
xorl %esi,%ebx
|
||||
rorl $11,%esi
|
||||
movl %ecx,%edi
|
||||
xorl %esi,%ebx
|
||||
shrl $10,%ecx
|
||||
movl 156(%esp),%esi
|
||||
rorl $17,%edi
|
||||
xorl %edi,%ecx
|
||||
rorl $2,%edi
|
||||
addl %esi,%ebx
|
||||
xorl %ecx,%edi
|
||||
addl %edi,%ebx
|
||||
movl %edx,%ecx
|
||||
addl 120(%esp),%ebx
|
||||
rorl $6,%ecx
|
||||
movl %edx,%edi
|
||||
rorl $11,%edi
|
||||
movl 20(%esp),%esi
|
||||
xorl %edi,%ecx
|
||||
rorl $14,%edi
|
||||
movl %ebx,92(%esp)
|
||||
xorl %edi,%ecx
|
||||
movl 24(%esp),%edi
|
||||
addl %ecx,%ebx
|
||||
movl %edx,16(%esp)
|
||||
xorl %edi,%esi
|
||||
movl %eax,%ecx
|
||||
andl %edx,%esi
|
||||
movl 12(%esp),%edx
|
||||
xorl %edi,%esi
|
||||
movl %eax,%edi
|
||||
addl %esi,%ebx
|
||||
rorl $2,%ecx
|
||||
addl 28(%esp),%ebx
|
||||
rorl $13,%edi
|
||||
movl 4(%esp),%esi
|
||||
xorl %edi,%ecx
|
||||
rorl $9,%edi
|
||||
addl %ebx,%edx
|
||||
xorl %edi,%ecx
|
||||
movl 8(%esp),%edi
|
||||
addl %ecx,%ebx
|
||||
movl %eax,(%esp)
|
||||
movl %eax,%ecx
|
||||
subl $4,%esp
|
||||
orl %esi,%eax
|
||||
andl %esi,%ecx
|
||||
andl %edi,%eax
|
||||
movl (%ebp),%esi
|
||||
orl %ecx,%eax
|
||||
addl $4,%ebp
|
||||
addl %ebx,%eax
|
||||
movl 152(%esp),%ebx
|
||||
addl %esi,%edx
|
||||
addl %esi,%eax
|
||||
cmpl $3329325298,%esi
|
||||
jne L00416_63
|
||||
movl 352(%esp),%esi
|
||||
movl 4(%esp),%ebx
|
||||
movl 8(%esp),%ecx
|
||||
movl 12(%esp),%edi
|
||||
addl (%esi),%eax
|
||||
addl 4(%esi),%ebx
|
||||
addl 8(%esi),%ecx
|
||||
addl 12(%esi),%edi
|
||||
movl %eax,(%esi)
|
||||
movl %ebx,4(%esi)
|
||||
movl %ecx,8(%esi)
|
||||
movl %edi,12(%esi)
|
||||
movl 20(%esp),%eax
|
||||
movl 24(%esp),%ebx
|
||||
movl 28(%esp),%ecx
|
||||
movl 356(%esp),%edi
|
||||
addl 16(%esi),%edx
|
||||
addl 20(%esi),%eax
|
||||
addl 24(%esi),%ebx
|
||||
addl 28(%esi),%ecx
|
||||
movl %edx,16(%esi)
|
||||
movl %eax,20(%esi)
|
||||
movl %ebx,24(%esi)
|
||||
movl %ecx,28(%esi)
|
||||
addl $352,%esp
|
||||
subl $256,%ebp
|
||||
cmpl 8(%esp),%edi
|
||||
jb L002loop
|
||||
movl 12(%esp),%esp
|
||||
popl %edi
|
||||
popl %esi
|
||||
popl %ebx
|
||||
popl %ebp
|
||||
ret
|
||||
.align 6,0x90
|
||||
L001K256:
|
||||
.long 1116352408,1899447441,3049323471,3921009573
|
||||
.long 961987163,1508970993,2453635748,2870763221
|
||||
.long 3624381080,310598401,607225278,1426881987
|
||||
.long 1925078388,2162078206,2614888103,3248222580
|
||||
.long 3835390401,4022224774,264347078,604807628
|
||||
.long 770255983,1249150122,1555081692,1996064986
|
||||
.long 2554220882,2821834349,2952996808,3210313671
|
||||
.long 3336571891,3584528711,113926993,338241895
|
||||
.long 666307205,773529912,1294757372,1396182291
|
||||
.long 1695183700,1986661051,2177026350,2456956037
|
||||
.long 2730485921,2820302411,3259730800,3345764771
|
||||
.long 3516065817,3600352804,4094571909,275423344
|
||||
.long 430227734,506948616,659060556,883997877
|
||||
.long 958139571,1322822218,1537002063,1747873779
|
||||
.long 1955562222,2024104815,2227730452,2361852424
|
||||
.long 2428436474,2756734187,3204031479,3329325298
|
||||
.byte 83,72,65,50,53,54,32,98,108,111,99,107,32,116,114,97
|
||||
.byte 110,115,102,111,114,109,32,102,111,114,32,120,56,54,44,32
|
||||
.byte 67,82,89,80,84,79,71,65,77,83,32,98,121,32,60,97
|
||||
.byte 112,112,114,111,64,111,112,101,110,115,115,108,46,111,114,103
|
||||
.byte 62,0
|
||||
@@ -7,73 +7,88 @@
|
||||
#include <openssl/opensslconf.h>
|
||||
#if !defined(OPENSSL_NO_SHA) && !defined(OPENSSL_NO_SHA256)
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
# include <stdlib.h>
|
||||
# include <string.h>
|
||||
|
||||
#include <openssl/crypto.h>
|
||||
#include <openssl/sha.h>
|
||||
#include <openssl/opensslv.h>
|
||||
# include <openssl/crypto.h>
|
||||
# include <openssl/sha.h>
|
||||
# include <openssl/opensslv.h>
|
||||
|
||||
const char SHA256_version[]="SHA-256" OPENSSL_VERSION_PTEXT;
|
||||
const char SHA256_version[] = "SHA-256" OPENSSL_VERSION_PTEXT;
|
||||
|
||||
int SHA224_Init (SHA256_CTX *c)
|
||||
{
|
||||
memset (c,0,sizeof(*c));
|
||||
c->h[0]=0xc1059ed8UL; c->h[1]=0x367cd507UL;
|
||||
c->h[2]=0x3070dd17UL; c->h[3]=0xf70e5939UL;
|
||||
c->h[4]=0xffc00b31UL; c->h[5]=0x68581511UL;
|
||||
c->h[6]=0x64f98fa7UL; c->h[7]=0xbefa4fa4UL;
|
||||
c->md_len=SHA224_DIGEST_LENGTH;
|
||||
return 1;
|
||||
}
|
||||
fips_md_init_ctx(SHA224, SHA256)
|
||||
{
|
||||
memset(c, 0, sizeof(*c));
|
||||
c->h[0] = 0xc1059ed8UL;
|
||||
c->h[1] = 0x367cd507UL;
|
||||
c->h[2] = 0x3070dd17UL;
|
||||
c->h[3] = 0xf70e5939UL;
|
||||
c->h[4] = 0xffc00b31UL;
|
||||
c->h[5] = 0x68581511UL;
|
||||
c->h[6] = 0x64f98fa7UL;
|
||||
c->h[7] = 0xbefa4fa4UL;
|
||||
c->md_len = SHA224_DIGEST_LENGTH;
|
||||
return 1;
|
||||
}
|
||||
|
||||
int SHA256_Init (SHA256_CTX *c)
|
||||
{
|
||||
memset (c,0,sizeof(*c));
|
||||
c->h[0]=0x6a09e667UL; c->h[1]=0xbb67ae85UL;
|
||||
c->h[2]=0x3c6ef372UL; c->h[3]=0xa54ff53aUL;
|
||||
c->h[4]=0x510e527fUL; c->h[5]=0x9b05688cUL;
|
||||
c->h[6]=0x1f83d9abUL; c->h[7]=0x5be0cd19UL;
|
||||
c->md_len=SHA256_DIGEST_LENGTH;
|
||||
return 1;
|
||||
}
|
||||
fips_md_init(SHA256)
|
||||
{
|
||||
memset(c, 0, sizeof(*c));
|
||||
c->h[0] = 0x6a09e667UL;
|
||||
c->h[1] = 0xbb67ae85UL;
|
||||
c->h[2] = 0x3c6ef372UL;
|
||||
c->h[3] = 0xa54ff53aUL;
|
||||
c->h[4] = 0x510e527fUL;
|
||||
c->h[5] = 0x9b05688cUL;
|
||||
c->h[6] = 0x1f83d9abUL;
|
||||
c->h[7] = 0x5be0cd19UL;
|
||||
c->md_len = SHA256_DIGEST_LENGTH;
|
||||
return 1;
|
||||
}
|
||||
|
||||
unsigned char *SHA224(const unsigned char *d, size_t n, unsigned char *md)
|
||||
{
|
||||
SHA256_CTX c;
|
||||
static unsigned char m[SHA224_DIGEST_LENGTH];
|
||||
{
|
||||
SHA256_CTX c;
|
||||
static unsigned char m[SHA224_DIGEST_LENGTH];
|
||||
|
||||
if (md == NULL) md=m;
|
||||
SHA224_Init(&c);
|
||||
SHA256_Update(&c,d,n);
|
||||
SHA256_Final(md,&c);
|
||||
OPENSSL_cleanse(&c,sizeof(c));
|
||||
return(md);
|
||||
}
|
||||
if (md == NULL)
|
||||
md = m;
|
||||
SHA224_Init(&c);
|
||||
SHA256_Update(&c, d, n);
|
||||
SHA256_Final(md, &c);
|
||||
OPENSSL_cleanse(&c, sizeof(c));
|
||||
return (md);
|
||||
}
|
||||
|
||||
unsigned char *SHA256(const unsigned char *d, size_t n, unsigned char *md)
|
||||
{
|
||||
SHA256_CTX c;
|
||||
static unsigned char m[SHA256_DIGEST_LENGTH];
|
||||
{
|
||||
SHA256_CTX c;
|
||||
static unsigned char m[SHA256_DIGEST_LENGTH];
|
||||
|
||||
if (md == NULL) md=m;
|
||||
SHA256_Init(&c);
|
||||
SHA256_Update(&c,d,n);
|
||||
SHA256_Final(md,&c);
|
||||
OPENSSL_cleanse(&c,sizeof(c));
|
||||
return(md);
|
||||
}
|
||||
if (md == NULL)
|
||||
md = m;
|
||||
SHA256_Init(&c);
|
||||
SHA256_Update(&c, d, n);
|
||||
SHA256_Final(md, &c);
|
||||
OPENSSL_cleanse(&c, sizeof(c));
|
||||
return (md);
|
||||
}
|
||||
|
||||
int SHA224_Update(SHA256_CTX *c, const void *data, size_t len)
|
||||
{ return SHA256_Update (c,data,len); }
|
||||
int SHA224_Final (unsigned char *md, SHA256_CTX *c)
|
||||
{ return SHA256_Final (md,c); }
|
||||
{
|
||||
return SHA256_Update(c, data, len);
|
||||
}
|
||||
|
||||
#define DATA_ORDER_IS_BIG_ENDIAN
|
||||
int SHA224_Final(unsigned char *md, SHA256_CTX *c)
|
||||
{
|
||||
return SHA256_Final(md, c);
|
||||
}
|
||||
|
||||
#define HASH_LONG SHA_LONG
|
||||
#define HASH_CTX SHA256_CTX
|
||||
#define HASH_CBLOCK SHA_CBLOCK
|
||||
# define DATA_ORDER_IS_BIG_ENDIAN
|
||||
|
||||
# define HASH_LONG SHA_LONG
|
||||
# define HASH_CTX SHA256_CTX
|
||||
# define HASH_CBLOCK SHA_CBLOCK
|
||||
/*
|
||||
* Note that FIPS180-2 discusses "Truncation of the Hash Function Output."
|
||||
* default: case below covers for it. It's not clear however if it's
|
||||
@@ -82,201 +97,291 @@ int SHA224_Final (unsigned char *md, SHA256_CTX *c)
|
||||
* Idea behind separate cases for pre-defined lenghts is to let the
|
||||
* compiler decide if it's appropriate to unroll small loops.
|
||||
*/
|
||||
#define HASH_MAKE_STRING(c,s) do { \
|
||||
unsigned long ll; \
|
||||
unsigned int nn; \
|
||||
switch ((c)->md_len) \
|
||||
{ case SHA224_DIGEST_LENGTH: \
|
||||
for (nn=0;nn<SHA224_DIGEST_LENGTH/4;nn++) \
|
||||
{ ll=(c)->h[nn]; HOST_l2c(ll,(s)); } \
|
||||
break; \
|
||||
case SHA256_DIGEST_LENGTH: \
|
||||
for (nn=0;nn<SHA256_DIGEST_LENGTH/4;nn++) \
|
||||
{ ll=(c)->h[nn]; HOST_l2c(ll,(s)); } \
|
||||
break; \
|
||||
default: \
|
||||
if ((c)->md_len > SHA256_DIGEST_LENGTH) \
|
||||
return 0; \
|
||||
for (nn=0;nn<(c)->md_len/4;nn++) \
|
||||
{ ll=(c)->h[nn]; HOST_l2c(ll,(s)); } \
|
||||
break; \
|
||||
} \
|
||||
} while (0)
|
||||
# define HASH_MAKE_STRING(c,s) do { \
|
||||
unsigned long ll; \
|
||||
unsigned int nn; \
|
||||
switch ((c)->md_len) \
|
||||
{ case SHA224_DIGEST_LENGTH: \
|
||||
for (nn=0;nn<SHA224_DIGEST_LENGTH/4;nn++) \
|
||||
{ ll=(c)->h[nn]; (void)HOST_l2c(ll,(s)); } \
|
||||
break; \
|
||||
case SHA256_DIGEST_LENGTH: \
|
||||
for (nn=0;nn<SHA256_DIGEST_LENGTH/4;nn++) \
|
||||
{ ll=(c)->h[nn]; (void)HOST_l2c(ll,(s)); } \
|
||||
break; \
|
||||
default: \
|
||||
if ((c)->md_len > SHA256_DIGEST_LENGTH) \
|
||||
return 0; \
|
||||
for (nn=0;nn<(c)->md_len/4;nn++) \
|
||||
{ ll=(c)->h[nn]; (void)HOST_l2c(ll,(s)); } \
|
||||
break; \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
#define HASH_UPDATE SHA256_Update
|
||||
#define HASH_TRANSFORM SHA256_Transform
|
||||
#define HASH_FINAL SHA256_Final
|
||||
#define HASH_BLOCK_DATA_ORDER sha256_block_data_order
|
||||
#ifndef SHA256_ASM
|
||||
# define HASH_UPDATE SHA256_Update
|
||||
# define HASH_TRANSFORM SHA256_Transform
|
||||
# define HASH_FINAL SHA256_Final
|
||||
# define HASH_BLOCK_DATA_ORDER sha256_block_data_order
|
||||
# ifndef SHA256_ASM
|
||||
static
|
||||
#endif
|
||||
void sha256_block_data_order (SHA256_CTX *ctx, const void *in, size_t num);
|
||||
# endif
|
||||
void sha256_block_data_order(SHA256_CTX *ctx, const void *in, size_t num);
|
||||
|
||||
#include "md32_common.h"
|
||||
# include "md32_common.h"
|
||||
|
||||
#ifndef SHA256_ASM
|
||||
# ifndef SHA256_ASM
|
||||
static const SHA_LONG K256[64] = {
|
||||
0x428a2f98UL,0x71374491UL,0xb5c0fbcfUL,0xe9b5dba5UL,
|
||||
0x3956c25bUL,0x59f111f1UL,0x923f82a4UL,0xab1c5ed5UL,
|
||||
0xd807aa98UL,0x12835b01UL,0x243185beUL,0x550c7dc3UL,
|
||||
0x72be5d74UL,0x80deb1feUL,0x9bdc06a7UL,0xc19bf174UL,
|
||||
0xe49b69c1UL,0xefbe4786UL,0x0fc19dc6UL,0x240ca1ccUL,
|
||||
0x2de92c6fUL,0x4a7484aaUL,0x5cb0a9dcUL,0x76f988daUL,
|
||||
0x983e5152UL,0xa831c66dUL,0xb00327c8UL,0xbf597fc7UL,
|
||||
0xc6e00bf3UL,0xd5a79147UL,0x06ca6351UL,0x14292967UL,
|
||||
0x27b70a85UL,0x2e1b2138UL,0x4d2c6dfcUL,0x53380d13UL,
|
||||
0x650a7354UL,0x766a0abbUL,0x81c2c92eUL,0x92722c85UL,
|
||||
0xa2bfe8a1UL,0xa81a664bUL,0xc24b8b70UL,0xc76c51a3UL,
|
||||
0xd192e819UL,0xd6990624UL,0xf40e3585UL,0x106aa070UL,
|
||||
0x19a4c116UL,0x1e376c08UL,0x2748774cUL,0x34b0bcb5UL,
|
||||
0x391c0cb3UL,0x4ed8aa4aUL,0x5b9cca4fUL,0x682e6ff3UL,
|
||||
0x748f82eeUL,0x78a5636fUL,0x84c87814UL,0x8cc70208UL,
|
||||
0x90befffaUL,0xa4506cebUL,0xbef9a3f7UL,0xc67178f2UL };
|
||||
0x428a2f98UL, 0x71374491UL, 0xb5c0fbcfUL, 0xe9b5dba5UL,
|
||||
0x3956c25bUL, 0x59f111f1UL, 0x923f82a4UL, 0xab1c5ed5UL,
|
||||
0xd807aa98UL, 0x12835b01UL, 0x243185beUL, 0x550c7dc3UL,
|
||||
0x72be5d74UL, 0x80deb1feUL, 0x9bdc06a7UL, 0xc19bf174UL,
|
||||
0xe49b69c1UL, 0xefbe4786UL, 0x0fc19dc6UL, 0x240ca1ccUL,
|
||||
0x2de92c6fUL, 0x4a7484aaUL, 0x5cb0a9dcUL, 0x76f988daUL,
|
||||
0x983e5152UL, 0xa831c66dUL, 0xb00327c8UL, 0xbf597fc7UL,
|
||||
0xc6e00bf3UL, 0xd5a79147UL, 0x06ca6351UL, 0x14292967UL,
|
||||
0x27b70a85UL, 0x2e1b2138UL, 0x4d2c6dfcUL, 0x53380d13UL,
|
||||
0x650a7354UL, 0x766a0abbUL, 0x81c2c92eUL, 0x92722c85UL,
|
||||
0xa2bfe8a1UL, 0xa81a664bUL, 0xc24b8b70UL, 0xc76c51a3UL,
|
||||
0xd192e819UL, 0xd6990624UL, 0xf40e3585UL, 0x106aa070UL,
|
||||
0x19a4c116UL, 0x1e376c08UL, 0x2748774cUL, 0x34b0bcb5UL,
|
||||
0x391c0cb3UL, 0x4ed8aa4aUL, 0x5b9cca4fUL, 0x682e6ff3UL,
|
||||
0x748f82eeUL, 0x78a5636fUL, 0x84c87814UL, 0x8cc70208UL,
|
||||
0x90befffaUL, 0xa4506cebUL, 0xbef9a3f7UL, 0xc67178f2UL
|
||||
};
|
||||
|
||||
/*
|
||||
* FIPS specification refers to right rotations, while our ROTATE macro
|
||||
* is left one. This is why you might notice that rotation coefficients
|
||||
* differ from those observed in FIPS document by 32-N...
|
||||
*/
|
||||
#define Sigma0(x) (ROTATE((x),30) ^ ROTATE((x),19) ^ ROTATE((x),10))
|
||||
#define Sigma1(x) (ROTATE((x),26) ^ ROTATE((x),21) ^ ROTATE((x),7))
|
||||
#define sigma0(x) (ROTATE((x),25) ^ ROTATE((x),14) ^ ((x)>>3))
|
||||
#define sigma1(x) (ROTATE((x),15) ^ ROTATE((x),13) ^ ((x)>>10))
|
||||
# define Sigma0(x) (ROTATE((x),30) ^ ROTATE((x),19) ^ ROTATE((x),10))
|
||||
# define Sigma1(x) (ROTATE((x),26) ^ ROTATE((x),21) ^ ROTATE((x),7))
|
||||
# define sigma0(x) (ROTATE((x),25) ^ ROTATE((x),14) ^ ((x)>>3))
|
||||
# define sigma1(x) (ROTATE((x),15) ^ ROTATE((x),13) ^ ((x)>>10))
|
||||
|
||||
#define Ch(x,y,z) (((x) & (y)) ^ ((~(x)) & (z)))
|
||||
#define Maj(x,y,z) (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
|
||||
# define Ch(x,y,z) (((x) & (y)) ^ ((~(x)) & (z)))
|
||||
# define Maj(x,y,z) (((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))
|
||||
|
||||
#ifdef OPENSSL_SMALL_FOOTPRINT
|
||||
# ifdef OPENSSL_SMALL_FOOTPRINT
|
||||
|
||||
static void sha256_block_data_order (SHA256_CTX *ctx, const void *in, size_t num)
|
||||
{
|
||||
unsigned MD32_REG_T a,b,c,d,e,f,g,h,s0,s1,T1,T2;
|
||||
SHA_LONG X[16],l;
|
||||
int i;
|
||||
const unsigned char *data=in;
|
||||
static void sha256_block_data_order(SHA256_CTX *ctx, const void *in,
|
||||
size_t num)
|
||||
{
|
||||
unsigned MD32_REG_T a, b, c, d, e, f, g, h, s0, s1, T1, T2;
|
||||
SHA_LONG X[16], l;
|
||||
int i;
|
||||
const unsigned char *data = in;
|
||||
|
||||
while (num--) {
|
||||
while (num--) {
|
||||
|
||||
a = ctx->h[0]; b = ctx->h[1]; c = ctx->h[2]; d = ctx->h[3];
|
||||
e = ctx->h[4]; f = ctx->h[5]; g = ctx->h[6]; h = ctx->h[7];
|
||||
a = ctx->h[0];
|
||||
b = ctx->h[1];
|
||||
c = ctx->h[2];
|
||||
d = ctx->h[3];
|
||||
e = ctx->h[4];
|
||||
f = ctx->h[5];
|
||||
g = ctx->h[6];
|
||||
h = ctx->h[7];
|
||||
|
||||
for (i=0;i<16;i++)
|
||||
{
|
||||
HOST_c2l(data,l); T1 = X[i] = l;
|
||||
T1 += h + Sigma1(e) + Ch(e,f,g) + K256[i];
|
||||
T2 = Sigma0(a) + Maj(a,b,c);
|
||||
h = g; g = f; f = e; e = d + T1;
|
||||
d = c; c = b; b = a; a = T1 + T2;
|
||||
}
|
||||
for (i = 0; i < 16; i++) {
|
||||
HOST_c2l(data, l);
|
||||
T1 = X[i] = l;
|
||||
T1 += h + Sigma1(e) + Ch(e, f, g) + K256[i];
|
||||
T2 = Sigma0(a) + Maj(a, b, c);
|
||||
h = g;
|
||||
g = f;
|
||||
f = e;
|
||||
e = d + T1;
|
||||
d = c;
|
||||
c = b;
|
||||
b = a;
|
||||
a = T1 + T2;
|
||||
}
|
||||
|
||||
for (;i<64;i++)
|
||||
{
|
||||
s0 = X[(i+1)&0x0f]; s0 = sigma0(s0);
|
||||
s1 = X[(i+14)&0x0f]; s1 = sigma1(s1);
|
||||
for (; i < 64; i++) {
|
||||
s0 = X[(i + 1) & 0x0f];
|
||||
s0 = sigma0(s0);
|
||||
s1 = X[(i + 14) & 0x0f];
|
||||
s1 = sigma1(s1);
|
||||
|
||||
T1 = X[i&0xf] += s0 + s1 + X[(i+9)&0xf];
|
||||
T1 += h + Sigma1(e) + Ch(e,f,g) + K256[i];
|
||||
T2 = Sigma0(a) + Maj(a,b,c);
|
||||
h = g; g = f; f = e; e = d + T1;
|
||||
d = c; c = b; b = a; a = T1 + T2;
|
||||
}
|
||||
T1 = X[i & 0xf] += s0 + s1 + X[(i + 9) & 0xf];
|
||||
T1 += h + Sigma1(e) + Ch(e, f, g) + K256[i];
|
||||
T2 = Sigma0(a) + Maj(a, b, c);
|
||||
h = g;
|
||||
g = f;
|
||||
f = e;
|
||||
e = d + T1;
|
||||
d = c;
|
||||
c = b;
|
||||
b = a;
|
||||
a = T1 + T2;
|
||||
}
|
||||
|
||||
ctx->h[0] += a; ctx->h[1] += b; ctx->h[2] += c; ctx->h[3] += d;
|
||||
ctx->h[4] += e; ctx->h[5] += f; ctx->h[6] += g; ctx->h[7] += h;
|
||||
ctx->h[0] += a;
|
||||
ctx->h[1] += b;
|
||||
ctx->h[2] += c;
|
||||
ctx->h[3] += d;
|
||||
ctx->h[4] += e;
|
||||
ctx->h[5] += f;
|
||||
ctx->h[6] += g;
|
||||
ctx->h[7] += h;
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#else
|
||||
# else
|
||||
|
||||
#define ROUND_00_15(i,a,b,c,d,e,f,g,h) do { \
|
||||
T1 += h + Sigma1(e) + Ch(e,f,g) + K256[i]; \
|
||||
h = Sigma0(a) + Maj(a,b,c); \
|
||||
d += T1; h += T1; } while (0)
|
||||
# define ROUND_00_15(i,a,b,c,d,e,f,g,h) do { \
|
||||
T1 += h + Sigma1(e) + Ch(e,f,g) + K256[i]; \
|
||||
h = Sigma0(a) + Maj(a,b,c); \
|
||||
d += T1; h += T1; } while (0)
|
||||
|
||||
#define ROUND_16_63(i,a,b,c,d,e,f,g,h,X) do { \
|
||||
s0 = X[(i+1)&0x0f]; s0 = sigma0(s0); \
|
||||
s1 = X[(i+14)&0x0f]; s1 = sigma1(s1); \
|
||||
T1 = X[(i)&0x0f] += s0 + s1 + X[(i+9)&0x0f]; \
|
||||
ROUND_00_15(i,a,b,c,d,e,f,g,h); } while (0)
|
||||
# define ROUND_16_63(i,a,b,c,d,e,f,g,h,X) do { \
|
||||
s0 = X[(i+1)&0x0f]; s0 = sigma0(s0); \
|
||||
s1 = X[(i+14)&0x0f]; s1 = sigma1(s1); \
|
||||
T1 = X[(i)&0x0f] += s0 + s1 + X[(i+9)&0x0f]; \
|
||||
ROUND_00_15(i,a,b,c,d,e,f,g,h); } while (0)
|
||||
|
||||
static void sha256_block_data_order (SHA256_CTX *ctx, const void *in, size_t num)
|
||||
{
|
||||
unsigned MD32_REG_T a,b,c,d,e,f,g,h,s0,s1,T1;
|
||||
SHA_LONG X[16];
|
||||
int i;
|
||||
const unsigned char *data=in;
|
||||
const union { long one; char little; } is_endian = {1};
|
||||
static void sha256_block_data_order(SHA256_CTX *ctx, const void *in,
|
||||
size_t num)
|
||||
{
|
||||
unsigned MD32_REG_T a, b, c, d, e, f, g, h, s0, s1, T1;
|
||||
SHA_LONG X[16];
|
||||
int i;
|
||||
const unsigned char *data = in;
|
||||
const union {
|
||||
long one;
|
||||
char little;
|
||||
} is_endian = {
|
||||
1
|
||||
};
|
||||
|
||||
while (num--) {
|
||||
while (num--) {
|
||||
|
||||
a = ctx->h[0]; b = ctx->h[1]; c = ctx->h[2]; d = ctx->h[3];
|
||||
e = ctx->h[4]; f = ctx->h[5]; g = ctx->h[6]; h = ctx->h[7];
|
||||
a = ctx->h[0];
|
||||
b = ctx->h[1];
|
||||
c = ctx->h[2];
|
||||
d = ctx->h[3];
|
||||
e = ctx->h[4];
|
||||
f = ctx->h[5];
|
||||
g = ctx->h[6];
|
||||
h = ctx->h[7];
|
||||
|
||||
if (!is_endian.little && sizeof(SHA_LONG)==4 && ((size_t)in%4)==0)
|
||||
{
|
||||
const SHA_LONG *W=(const SHA_LONG *)data;
|
||||
if (!is_endian.little && sizeof(SHA_LONG) == 4
|
||||
&& ((size_t)in % 4) == 0) {
|
||||
const SHA_LONG *W = (const SHA_LONG *)data;
|
||||
|
||||
T1 = X[0] = W[0]; ROUND_00_15(0,a,b,c,d,e,f,g,h);
|
||||
T1 = X[1] = W[1]; ROUND_00_15(1,h,a,b,c,d,e,f,g);
|
||||
T1 = X[2] = W[2]; ROUND_00_15(2,g,h,a,b,c,d,e,f);
|
||||
T1 = X[3] = W[3]; ROUND_00_15(3,f,g,h,a,b,c,d,e);
|
||||
T1 = X[4] = W[4]; ROUND_00_15(4,e,f,g,h,a,b,c,d);
|
||||
T1 = X[5] = W[5]; ROUND_00_15(5,d,e,f,g,h,a,b,c);
|
||||
T1 = X[6] = W[6]; ROUND_00_15(6,c,d,e,f,g,h,a,b);
|
||||
T1 = X[7] = W[7]; ROUND_00_15(7,b,c,d,e,f,g,h,a);
|
||||
T1 = X[8] = W[8]; ROUND_00_15(8,a,b,c,d,e,f,g,h);
|
||||
T1 = X[9] = W[9]; ROUND_00_15(9,h,a,b,c,d,e,f,g);
|
||||
T1 = X[10] = W[10]; ROUND_00_15(10,g,h,a,b,c,d,e,f);
|
||||
T1 = X[11] = W[11]; ROUND_00_15(11,f,g,h,a,b,c,d,e);
|
||||
T1 = X[12] = W[12]; ROUND_00_15(12,e,f,g,h,a,b,c,d);
|
||||
T1 = X[13] = W[13]; ROUND_00_15(13,d,e,f,g,h,a,b,c);
|
||||
T1 = X[14] = W[14]; ROUND_00_15(14,c,d,e,f,g,h,a,b);
|
||||
T1 = X[15] = W[15]; ROUND_00_15(15,b,c,d,e,f,g,h,a);
|
||||
T1 = X[0] = W[0];
|
||||
ROUND_00_15(0, a, b, c, d, e, f, g, h);
|
||||
T1 = X[1] = W[1];
|
||||
ROUND_00_15(1, h, a, b, c, d, e, f, g);
|
||||
T1 = X[2] = W[2];
|
||||
ROUND_00_15(2, g, h, a, b, c, d, e, f);
|
||||
T1 = X[3] = W[3];
|
||||
ROUND_00_15(3, f, g, h, a, b, c, d, e);
|
||||
T1 = X[4] = W[4];
|
||||
ROUND_00_15(4, e, f, g, h, a, b, c, d);
|
||||
T1 = X[5] = W[5];
|
||||
ROUND_00_15(5, d, e, f, g, h, a, b, c);
|
||||
T1 = X[6] = W[6];
|
||||
ROUND_00_15(6, c, d, e, f, g, h, a, b);
|
||||
T1 = X[7] = W[7];
|
||||
ROUND_00_15(7, b, c, d, e, f, g, h, a);
|
||||
T1 = X[8] = W[8];
|
||||
ROUND_00_15(8, a, b, c, d, e, f, g, h);
|
||||
T1 = X[9] = W[9];
|
||||
ROUND_00_15(9, h, a, b, c, d, e, f, g);
|
||||
T1 = X[10] = W[10];
|
||||
ROUND_00_15(10, g, h, a, b, c, d, e, f);
|
||||
T1 = X[11] = W[11];
|
||||
ROUND_00_15(11, f, g, h, a, b, c, d, e);
|
||||
T1 = X[12] = W[12];
|
||||
ROUND_00_15(12, e, f, g, h, a, b, c, d);
|
||||
T1 = X[13] = W[13];
|
||||
ROUND_00_15(13, d, e, f, g, h, a, b, c);
|
||||
T1 = X[14] = W[14];
|
||||
ROUND_00_15(14, c, d, e, f, g, h, a, b);
|
||||
T1 = X[15] = W[15];
|
||||
ROUND_00_15(15, b, c, d, e, f, g, h, a);
|
||||
|
||||
data += SHA256_CBLOCK;
|
||||
}
|
||||
else
|
||||
{
|
||||
SHA_LONG l;
|
||||
data += SHA256_CBLOCK;
|
||||
} else {
|
||||
SHA_LONG l;
|
||||
|
||||
HOST_c2l(data,l); T1 = X[0] = l; ROUND_00_15(0,a,b,c,d,e,f,g,h);
|
||||
HOST_c2l(data,l); T1 = X[1] = l; ROUND_00_15(1,h,a,b,c,d,e,f,g);
|
||||
HOST_c2l(data,l); T1 = X[2] = l; ROUND_00_15(2,g,h,a,b,c,d,e,f);
|
||||
HOST_c2l(data,l); T1 = X[3] = l; ROUND_00_15(3,f,g,h,a,b,c,d,e);
|
||||
HOST_c2l(data,l); T1 = X[4] = l; ROUND_00_15(4,e,f,g,h,a,b,c,d);
|
||||
HOST_c2l(data,l); T1 = X[5] = l; ROUND_00_15(5,d,e,f,g,h,a,b,c);
|
||||
HOST_c2l(data,l); T1 = X[6] = l; ROUND_00_15(6,c,d,e,f,g,h,a,b);
|
||||
HOST_c2l(data,l); T1 = X[7] = l; ROUND_00_15(7,b,c,d,e,f,g,h,a);
|
||||
HOST_c2l(data,l); T1 = X[8] = l; ROUND_00_15(8,a,b,c,d,e,f,g,h);
|
||||
HOST_c2l(data,l); T1 = X[9] = l; ROUND_00_15(9,h,a,b,c,d,e,f,g);
|
||||
HOST_c2l(data,l); T1 = X[10] = l; ROUND_00_15(10,g,h,a,b,c,d,e,f);
|
||||
HOST_c2l(data,l); T1 = X[11] = l; ROUND_00_15(11,f,g,h,a,b,c,d,e);
|
||||
HOST_c2l(data,l); T1 = X[12] = l; ROUND_00_15(12,e,f,g,h,a,b,c,d);
|
||||
HOST_c2l(data,l); T1 = X[13] = l; ROUND_00_15(13,d,e,f,g,h,a,b,c);
|
||||
HOST_c2l(data,l); T1 = X[14] = l; ROUND_00_15(14,c,d,e,f,g,h,a,b);
|
||||
HOST_c2l(data,l); T1 = X[15] = l; ROUND_00_15(15,b,c,d,e,f,g,h,a);
|
||||
}
|
||||
HOST_c2l(data, l);
|
||||
T1 = X[0] = l;
|
||||
ROUND_00_15(0, a, b, c, d, e, f, g, h);
|
||||
HOST_c2l(data, l);
|
||||
T1 = X[1] = l;
|
||||
ROUND_00_15(1, h, a, b, c, d, e, f, g);
|
||||
HOST_c2l(data, l);
|
||||
T1 = X[2] = l;
|
||||
ROUND_00_15(2, g, h, a, b, c, d, e, f);
|
||||
HOST_c2l(data, l);
|
||||
T1 = X[3] = l;
|
||||
ROUND_00_15(3, f, g, h, a, b, c, d, e);
|
||||
HOST_c2l(data, l);
|
||||
T1 = X[4] = l;
|
||||
ROUND_00_15(4, e, f, g, h, a, b, c, d);
|
||||
HOST_c2l(data, l);
|
||||
T1 = X[5] = l;
|
||||
ROUND_00_15(5, d, e, f, g, h, a, b, c);
|
||||
HOST_c2l(data, l);
|
||||
T1 = X[6] = l;
|
||||
ROUND_00_15(6, c, d, e, f, g, h, a, b);
|
||||
HOST_c2l(data, l);
|
||||
T1 = X[7] = l;
|
||||
ROUND_00_15(7, b, c, d, e, f, g, h, a);
|
||||
HOST_c2l(data, l);
|
||||
T1 = X[8] = l;
|
||||
ROUND_00_15(8, a, b, c, d, e, f, g, h);
|
||||
HOST_c2l(data, l);
|
||||
T1 = X[9] = l;
|
||||
ROUND_00_15(9, h, a, b, c, d, e, f, g);
|
||||
HOST_c2l(data, l);
|
||||
T1 = X[10] = l;
|
||||
ROUND_00_15(10, g, h, a, b, c, d, e, f);
|
||||
HOST_c2l(data, l);
|
||||
T1 = X[11] = l;
|
||||
ROUND_00_15(11, f, g, h, a, b, c, d, e);
|
||||
HOST_c2l(data, l);
|
||||
T1 = X[12] = l;
|
||||
ROUND_00_15(12, e, f, g, h, a, b, c, d);
|
||||
HOST_c2l(data, l);
|
||||
T1 = X[13] = l;
|
||||
ROUND_00_15(13, d, e, f, g, h, a, b, c);
|
||||
HOST_c2l(data, l);
|
||||
T1 = X[14] = l;
|
||||
ROUND_00_15(14, c, d, e, f, g, h, a, b);
|
||||
HOST_c2l(data, l);
|
||||
T1 = X[15] = l;
|
||||
ROUND_00_15(15, b, c, d, e, f, g, h, a);
|
||||
}
|
||||
|
||||
for (i=16;i<64;i+=8)
|
||||
{
|
||||
ROUND_16_63(i+0,a,b,c,d,e,f,g,h,X);
|
||||
ROUND_16_63(i+1,h,a,b,c,d,e,f,g,X);
|
||||
ROUND_16_63(i+2,g,h,a,b,c,d,e,f,X);
|
||||
ROUND_16_63(i+3,f,g,h,a,b,c,d,e,X);
|
||||
ROUND_16_63(i+4,e,f,g,h,a,b,c,d,X);
|
||||
ROUND_16_63(i+5,d,e,f,g,h,a,b,c,X);
|
||||
ROUND_16_63(i+6,c,d,e,f,g,h,a,b,X);
|
||||
ROUND_16_63(i+7,b,c,d,e,f,g,h,a,X);
|
||||
}
|
||||
for (i = 16; i < 64; i += 8) {
|
||||
ROUND_16_63(i + 0, a, b, c, d, e, f, g, h, X);
|
||||
ROUND_16_63(i + 1, h, a, b, c, d, e, f, g, X);
|
||||
ROUND_16_63(i + 2, g, h, a, b, c, d, e, f, X);
|
||||
ROUND_16_63(i + 3, f, g, h, a, b, c, d, e, X);
|
||||
ROUND_16_63(i + 4, e, f, g, h, a, b, c, d, X);
|
||||
ROUND_16_63(i + 5, d, e, f, g, h, a, b, c, X);
|
||||
ROUND_16_63(i + 6, c, d, e, f, g, h, a, b, X);
|
||||
ROUND_16_63(i + 7, b, c, d, e, f, g, h, a, X);
|
||||
}
|
||||
|
||||
ctx->h[0] += a; ctx->h[1] += b; ctx->h[2] += c; ctx->h[3] += d;
|
||||
ctx->h[4] += e; ctx->h[5] += f; ctx->h[6] += g; ctx->h[7] += h;
|
||||
ctx->h[0] += a;
|
||||
ctx->h[1] += b;
|
||||
ctx->h[2] += c;
|
||||
ctx->h[3] += d;
|
||||
ctx->h[4] += e;
|
||||
ctx->h[5] += f;
|
||||
ctx->h[6] += g;
|
||||
ctx->h[7] += h;
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
#endif /* SHA256_ASM */
|
||||
# endif
|
||||
# endif /* SHA256_ASM */
|
||||
|
||||
#endif /* OPENSSL_NO_SHA256 */
|
||||
#endif /* OPENSSL_NO_SHA256 */
|
||||
|
||||
Binary file not shown.
@@ -14,134 +14,145 @@
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
printf("No SHA256 support\n");
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
#else
|
||||
|
||||
unsigned char app_b1[SHA256_DIGEST_LENGTH] = {
|
||||
0xba,0x78,0x16,0xbf,0x8f,0x01,0xcf,0xea,
|
||||
0x41,0x41,0x40,0xde,0x5d,0xae,0x22,0x23,
|
||||
0xb0,0x03,0x61,0xa3,0x96,0x17,0x7a,0x9c,
|
||||
0xb4,0x10,0xff,0x61,0xf2,0x00,0x15,0xad };
|
||||
0xba, 0x78, 0x16, 0xbf, 0x8f, 0x01, 0xcf, 0xea,
|
||||
0x41, 0x41, 0x40, 0xde, 0x5d, 0xae, 0x22, 0x23,
|
||||
0xb0, 0x03, 0x61, 0xa3, 0x96, 0x17, 0x7a, 0x9c,
|
||||
0xb4, 0x10, 0xff, 0x61, 0xf2, 0x00, 0x15, 0xad
|
||||
};
|
||||
|
||||
unsigned char app_b2[SHA256_DIGEST_LENGTH] = {
|
||||
0x24,0x8d,0x6a,0x61,0xd2,0x06,0x38,0xb8,
|
||||
0xe5,0xc0,0x26,0x93,0x0c,0x3e,0x60,0x39,
|
||||
0xa3,0x3c,0xe4,0x59,0x64,0xff,0x21,0x67,
|
||||
0xf6,0xec,0xed,0xd4,0x19,0xdb,0x06,0xc1 };
|
||||
0x24, 0x8d, 0x6a, 0x61, 0xd2, 0x06, 0x38, 0xb8,
|
||||
0xe5, 0xc0, 0x26, 0x93, 0x0c, 0x3e, 0x60, 0x39,
|
||||
0xa3, 0x3c, 0xe4, 0x59, 0x64, 0xff, 0x21, 0x67,
|
||||
0xf6, 0xec, 0xed, 0xd4, 0x19, 0xdb, 0x06, 0xc1
|
||||
};
|
||||
|
||||
unsigned char app_b3[SHA256_DIGEST_LENGTH] = {
|
||||
0xcd,0xc7,0x6e,0x5c,0x99,0x14,0xfb,0x92,
|
||||
0x81,0xa1,0xc7,0xe2,0x84,0xd7,0x3e,0x67,
|
||||
0xf1,0x80,0x9a,0x48,0xa4,0x97,0x20,0x0e,
|
||||
0x04,0x6d,0x39,0xcc,0xc7,0x11,0x2c,0xd0 };
|
||||
0xcd, 0xc7, 0x6e, 0x5c, 0x99, 0x14, 0xfb, 0x92,
|
||||
0x81, 0xa1, 0xc7, 0xe2, 0x84, 0xd7, 0x3e, 0x67,
|
||||
0xf1, 0x80, 0x9a, 0x48, 0xa4, 0x97, 0x20, 0x0e,
|
||||
0x04, 0x6d, 0x39, 0xcc, 0xc7, 0x11, 0x2c, 0xd0
|
||||
};
|
||||
|
||||
unsigned char addenum_1[SHA224_DIGEST_LENGTH] = {
|
||||
0x23,0x09,0x7d,0x22,0x34,0x05,0xd8,0x22,
|
||||
0x86,0x42,0xa4,0x77,0xbd,0xa2,0x55,0xb3,
|
||||
0x2a,0xad,0xbc,0xe4,0xbd,0xa0,0xb3,0xf7,
|
||||
0xe3,0x6c,0x9d,0xa7 };
|
||||
0x23, 0x09, 0x7d, 0x22, 0x34, 0x05, 0xd8, 0x22,
|
||||
0x86, 0x42, 0xa4, 0x77, 0xbd, 0xa2, 0x55, 0xb3,
|
||||
0x2a, 0xad, 0xbc, 0xe4, 0xbd, 0xa0, 0xb3, 0xf7,
|
||||
0xe3, 0x6c, 0x9d, 0xa7
|
||||
};
|
||||
|
||||
unsigned char addenum_2[SHA224_DIGEST_LENGTH] = {
|
||||
0x75,0x38,0x8b,0x16,0x51,0x27,0x76,0xcc,
|
||||
0x5d,0xba,0x5d,0xa1,0xfd,0x89,0x01,0x50,
|
||||
0xb0,0xc6,0x45,0x5c,0xb4,0xf5,0x8b,0x19,
|
||||
0x52,0x52,0x25,0x25 };
|
||||
0x75, 0x38, 0x8b, 0x16, 0x51, 0x27, 0x76, 0xcc,
|
||||
0x5d, 0xba, 0x5d, 0xa1, 0xfd, 0x89, 0x01, 0x50,
|
||||
0xb0, 0xc6, 0x45, 0x5c, 0xb4, 0xf5, 0x8b, 0x19,
|
||||
0x52, 0x52, 0x25, 0x25
|
||||
};
|
||||
|
||||
unsigned char addenum_3[SHA224_DIGEST_LENGTH] = {
|
||||
0x20,0x79,0x46,0x55,0x98,0x0c,0x91,0xd8,
|
||||
0xbb,0xb4,0xc1,0xea,0x97,0x61,0x8a,0x4b,
|
||||
0xf0,0x3f,0x42,0x58,0x19,0x48,0xb2,0xee,
|
||||
0x4e,0xe7,0xad,0x67 };
|
||||
0x20, 0x79, 0x46, 0x55, 0x98, 0x0c, 0x91, 0xd8,
|
||||
0xbb, 0xb4, 0xc1, 0xea, 0x97, 0x61, 0x8a, 0x4b,
|
||||
0xf0, 0x3f, 0x42, 0x58, 0x19, 0x48, 0xb2, 0xee,
|
||||
0x4e, 0xe7, 0xad, 0x67
|
||||
};
|
||||
|
||||
int main (int argc,char **argv)
|
||||
{ unsigned char md[SHA256_DIGEST_LENGTH];
|
||||
int i;
|
||||
EVP_MD_CTX evp;
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
unsigned char md[SHA256_DIGEST_LENGTH];
|
||||
int i;
|
||||
EVP_MD_CTX evp;
|
||||
|
||||
fprintf(stdout,"Testing SHA-256 ");
|
||||
fprintf(stdout, "Testing SHA-256 ");
|
||||
|
||||
EVP_Digest ("abc",3,md,NULL,EVP_sha256(),NULL);
|
||||
if (memcmp(md,app_b1,sizeof(app_b1)))
|
||||
{ fflush(stdout);
|
||||
fprintf(stderr,"\nTEST 1 of 3 failed.\n");
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
fprintf(stdout,"."); fflush(stdout);
|
||||
EVP_Digest("abc", 3, md, NULL, EVP_sha256(), NULL);
|
||||
if (memcmp(md, app_b1, sizeof(app_b1))) {
|
||||
fflush(stdout);
|
||||
fprintf(stderr, "\nTEST 1 of 3 failed.\n");
|
||||
return 1;
|
||||
} else
|
||||
fprintf(stdout, ".");
|
||||
fflush(stdout);
|
||||
|
||||
EVP_Digest ("abcdbcde""cdefdefg""efghfghi""ghijhijk"
|
||||
"ijkljklm""klmnlmno""mnopnopq",56,md,NULL,EVP_sha256(),NULL);
|
||||
if (memcmp(md,app_b2,sizeof(app_b2)))
|
||||
{ fflush(stdout);
|
||||
fprintf(stderr,"\nTEST 2 of 3 failed.\n");
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
fprintf(stdout,"."); fflush(stdout);
|
||||
EVP_Digest("abcdbcde" "cdefdefg" "efghfghi" "ghijhijk"
|
||||
"ijkljklm" "klmnlmno" "mnopnopq", 56, md, NULL, EVP_sha256(),
|
||||
NULL);
|
||||
if (memcmp(md, app_b2, sizeof(app_b2))) {
|
||||
fflush(stdout);
|
||||
fprintf(stderr, "\nTEST 2 of 3 failed.\n");
|
||||
return 1;
|
||||
} else
|
||||
fprintf(stdout, ".");
|
||||
fflush(stdout);
|
||||
|
||||
EVP_MD_CTX_init (&evp);
|
||||
EVP_DigestInit_ex (&evp,EVP_sha256(),NULL);
|
||||
for (i=0;i<1000000;i+=160)
|
||||
EVP_DigestUpdate (&evp, "aaaaaaaa""aaaaaaaa""aaaaaaaa""aaaaaaaa"
|
||||
"aaaaaaaa""aaaaaaaa""aaaaaaaa""aaaaaaaa"
|
||||
"aaaaaaaa""aaaaaaaa""aaaaaaaa""aaaaaaaa"
|
||||
"aaaaaaaa""aaaaaaaa""aaaaaaaa""aaaaaaaa"
|
||||
"aaaaaaaa""aaaaaaaa""aaaaaaaa""aaaaaaaa",
|
||||
(1000000-i)<160?1000000-i:160);
|
||||
EVP_DigestFinal_ex (&evp,md,NULL);
|
||||
EVP_MD_CTX_cleanup (&evp);
|
||||
EVP_MD_CTX_init(&evp);
|
||||
EVP_DigestInit_ex(&evp, EVP_sha256(), NULL);
|
||||
for (i = 0; i < 1000000; i += 160)
|
||||
EVP_DigestUpdate(&evp, "aaaaaaaa" "aaaaaaaa" "aaaaaaaa" "aaaaaaaa"
|
||||
"aaaaaaaa" "aaaaaaaa" "aaaaaaaa" "aaaaaaaa"
|
||||
"aaaaaaaa" "aaaaaaaa" "aaaaaaaa" "aaaaaaaa"
|
||||
"aaaaaaaa" "aaaaaaaa" "aaaaaaaa" "aaaaaaaa"
|
||||
"aaaaaaaa" "aaaaaaaa" "aaaaaaaa" "aaaaaaaa",
|
||||
(1000000 - i) < 160 ? 1000000 - i : 160);
|
||||
EVP_DigestFinal_ex(&evp, md, NULL);
|
||||
EVP_MD_CTX_cleanup(&evp);
|
||||
|
||||
if (memcmp(md,app_b3,sizeof(app_b3)))
|
||||
{ fflush(stdout);
|
||||
fprintf(stderr,"\nTEST 3 of 3 failed.\n");
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
fprintf(stdout,"."); fflush(stdout);
|
||||
if (memcmp(md, app_b3, sizeof(app_b3))) {
|
||||
fflush(stdout);
|
||||
fprintf(stderr, "\nTEST 3 of 3 failed.\n");
|
||||
return 1;
|
||||
} else
|
||||
fprintf(stdout, ".");
|
||||
fflush(stdout);
|
||||
|
||||
fprintf(stdout," passed.\n"); fflush(stdout);
|
||||
fprintf(stdout, " passed.\n");
|
||||
fflush(stdout);
|
||||
|
||||
fprintf(stdout,"Testing SHA-224 ");
|
||||
fprintf(stdout, "Testing SHA-224 ");
|
||||
|
||||
EVP_Digest ("abc",3,md,NULL,EVP_sha224(),NULL);
|
||||
if (memcmp(md,addenum_1,sizeof(addenum_1)))
|
||||
{ fflush(stdout);
|
||||
fprintf(stderr,"\nTEST 1 of 3 failed.\n");
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
fprintf(stdout,"."); fflush(stdout);
|
||||
EVP_Digest("abc", 3, md, NULL, EVP_sha224(), NULL);
|
||||
if (memcmp(md, addenum_1, sizeof(addenum_1))) {
|
||||
fflush(stdout);
|
||||
fprintf(stderr, "\nTEST 1 of 3 failed.\n");
|
||||
return 1;
|
||||
} else
|
||||
fprintf(stdout, ".");
|
||||
fflush(stdout);
|
||||
|
||||
EVP_Digest ("abcdbcde""cdefdefg""efghfghi""ghijhijk"
|
||||
"ijkljklm""klmnlmno""mnopnopq",56,md,NULL,EVP_sha224(),NULL);
|
||||
if (memcmp(md,addenum_2,sizeof(addenum_2)))
|
||||
{ fflush(stdout);
|
||||
fprintf(stderr,"\nTEST 2 of 3 failed.\n");
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
fprintf(stdout,"."); fflush(stdout);
|
||||
EVP_Digest("abcdbcde" "cdefdefg" "efghfghi" "ghijhijk"
|
||||
"ijkljklm" "klmnlmno" "mnopnopq", 56, md, NULL, EVP_sha224(),
|
||||
NULL);
|
||||
if (memcmp(md, addenum_2, sizeof(addenum_2))) {
|
||||
fflush(stdout);
|
||||
fprintf(stderr, "\nTEST 2 of 3 failed.\n");
|
||||
return 1;
|
||||
} else
|
||||
fprintf(stdout, ".");
|
||||
fflush(stdout);
|
||||
|
||||
EVP_MD_CTX_init (&evp);
|
||||
EVP_DigestInit_ex (&evp,EVP_sha224(),NULL);
|
||||
for (i=0;i<1000000;i+=64)
|
||||
EVP_DigestUpdate (&evp, "aaaaaaaa""aaaaaaaa""aaaaaaaa""aaaaaaaa"
|
||||
"aaaaaaaa""aaaaaaaa""aaaaaaaa""aaaaaaaa",
|
||||
(1000000-i)<64?1000000-i:64);
|
||||
EVP_DigestFinal_ex (&evp,md,NULL);
|
||||
EVP_MD_CTX_cleanup (&evp);
|
||||
EVP_MD_CTX_init(&evp);
|
||||
EVP_DigestInit_ex(&evp, EVP_sha224(), NULL);
|
||||
for (i = 0; i < 1000000; i += 64)
|
||||
EVP_DigestUpdate(&evp, "aaaaaaaa" "aaaaaaaa" "aaaaaaaa" "aaaaaaaa"
|
||||
"aaaaaaaa" "aaaaaaaa" "aaaaaaaa" "aaaaaaaa",
|
||||
(1000000 - i) < 64 ? 1000000 - i : 64);
|
||||
EVP_DigestFinal_ex(&evp, md, NULL);
|
||||
EVP_MD_CTX_cleanup(&evp);
|
||||
|
||||
if (memcmp(md,addenum_3,sizeof(addenum_3)))
|
||||
{ fflush(stdout);
|
||||
fprintf(stderr,"\nTEST 3 of 3 failed.\n");
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
fprintf(stdout,"."); fflush(stdout);
|
||||
if (memcmp(md, addenum_3, sizeof(addenum_3))) {
|
||||
fflush(stdout);
|
||||
fprintf(stderr, "\nTEST 3 of 3 failed.\n");
|
||||
return 1;
|
||||
} else
|
||||
fprintf(stdout, ".");
|
||||
fflush(stdout);
|
||||
|
||||
fprintf(stdout," passed.\n"); fflush(stdout);
|
||||
fprintf(stdout, " passed.\n");
|
||||
fflush(stdout);
|
||||
|
||||
return 0;
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
Binary file not shown.
@@ -1,833 +0,0 @@
|
||||
.file "sha512-586.s"
|
||||
.text
|
||||
.globl _sha512_block_data_order
|
||||
.align 4
|
||||
_sha512_block_data_order:
|
||||
L_sha512_block_data_order_begin:
|
||||
pushl %ebp
|
||||
pushl %ebx
|
||||
pushl %esi
|
||||
pushl %edi
|
||||
movl 20(%esp),%esi
|
||||
movl 24(%esp),%edi
|
||||
movl 28(%esp),%eax
|
||||
movl %esp,%ebx
|
||||
call L000pic_point
|
||||
L000pic_point:
|
||||
popl %ebp
|
||||
leal L001K512-L000pic_point(%ebp),%ebp
|
||||
subl $16,%esp
|
||||
andl $-64,%esp
|
||||
shll $7,%eax
|
||||
addl %edi,%eax
|
||||
movl %esi,(%esp)
|
||||
movl %edi,4(%esp)
|
||||
movl %eax,8(%esp)
|
||||
movl %ebx,12(%esp)
|
||||
leal _OPENSSL_ia32cap_P,%edx
|
||||
btl $26,(%edx)
|
||||
jnc L002loop_x86
|
||||
movq (%esi),%mm0
|
||||
movq 8(%esi),%mm1
|
||||
movq 16(%esi),%mm2
|
||||
movq 24(%esi),%mm3
|
||||
movq 32(%esi),%mm4
|
||||
movq 40(%esi),%mm5
|
||||
movq 48(%esi),%mm6
|
||||
movq 56(%esi),%mm7
|
||||
subl $80,%esp
|
||||
.align 4,0x90
|
||||
L003loop_sse2:
|
||||
movq %mm1,8(%esp)
|
||||
movq %mm2,16(%esp)
|
||||
movq %mm3,24(%esp)
|
||||
movq %mm5,40(%esp)
|
||||
movq %mm6,48(%esp)
|
||||
movq %mm7,56(%esp)
|
||||
movl (%edi),%ecx
|
||||
movl 4(%edi),%edx
|
||||
addl $8,%edi
|
||||
bswap %ecx
|
||||
bswap %edx
|
||||
movl %ecx,76(%esp)
|
||||
movl %edx,72(%esp)
|
||||
.align 4,0x90
|
||||
L00400_14_sse2:
|
||||
movl (%edi),%eax
|
||||
movl 4(%edi),%ebx
|
||||
addl $8,%edi
|
||||
bswap %eax
|
||||
bswap %ebx
|
||||
movl %eax,68(%esp)
|
||||
movl %ebx,64(%esp)
|
||||
movq 40(%esp),%mm5
|
||||
movq 48(%esp),%mm6
|
||||
movq 56(%esp),%mm7
|
||||
movq %mm4,%mm1
|
||||
movq %mm4,%mm2
|
||||
psrlq $14,%mm1
|
||||
movq %mm4,32(%esp)
|
||||
psllq $23,%mm2
|
||||
movq %mm1,%mm3
|
||||
psrlq $4,%mm1
|
||||
pxor %mm2,%mm3
|
||||
psllq $23,%mm2
|
||||
pxor %mm1,%mm3
|
||||
psrlq $23,%mm1
|
||||
pxor %mm2,%mm3
|
||||
psllq $4,%mm2
|
||||
pxor %mm1,%mm3
|
||||
paddq (%ebp),%mm7
|
||||
pxor %mm2,%mm3
|
||||
pxor %mm6,%mm5
|
||||
movq 8(%esp),%mm1
|
||||
pand %mm4,%mm5
|
||||
movq 16(%esp),%mm2
|
||||
pxor %mm6,%mm5
|
||||
movq 24(%esp),%mm4
|
||||
paddq %mm5,%mm3
|
||||
movq %mm0,(%esp)
|
||||
paddq %mm7,%mm3
|
||||
movq %mm0,%mm5
|
||||
movq %mm0,%mm6
|
||||
paddq 72(%esp),%mm3
|
||||
psrlq $28,%mm5
|
||||
paddq %mm3,%mm4
|
||||
psllq $25,%mm6
|
||||
movq %mm5,%mm7
|
||||
psrlq $6,%mm5
|
||||
pxor %mm6,%mm7
|
||||
psllq $5,%mm6
|
||||
pxor %mm5,%mm7
|
||||
psrlq $5,%mm5
|
||||
pxor %mm6,%mm7
|
||||
psllq $6,%mm6
|
||||
pxor %mm5,%mm7
|
||||
subl $8,%esp
|
||||
pxor %mm6,%mm7
|
||||
movq %mm0,%mm5
|
||||
por %mm2,%mm0
|
||||
pand %mm2,%mm5
|
||||
pand %mm1,%mm0
|
||||
por %mm0,%mm5
|
||||
paddq %mm5,%mm7
|
||||
movq %mm3,%mm0
|
||||
movb (%ebp),%dl
|
||||
paddq %mm7,%mm0
|
||||
addl $8,%ebp
|
||||
cmpb $53,%dl
|
||||
jne L00400_14_sse2
|
||||
movq 40(%esp),%mm5
|
||||
movq 48(%esp),%mm6
|
||||
movq 56(%esp),%mm7
|
||||
movq %mm4,%mm1
|
||||
movq %mm4,%mm2
|
||||
psrlq $14,%mm1
|
||||
movq %mm4,32(%esp)
|
||||
psllq $23,%mm2
|
||||
movq %mm1,%mm3
|
||||
psrlq $4,%mm1
|
||||
pxor %mm2,%mm3
|
||||
psllq $23,%mm2
|
||||
pxor %mm1,%mm3
|
||||
psrlq $23,%mm1
|
||||
pxor %mm2,%mm3
|
||||
psllq $4,%mm2
|
||||
pxor %mm1,%mm3
|
||||
paddq (%ebp),%mm7
|
||||
pxor %mm2,%mm3
|
||||
pxor %mm6,%mm5
|
||||
movq 8(%esp),%mm1
|
||||
pand %mm4,%mm5
|
||||
movq 16(%esp),%mm2
|
||||
pxor %mm6,%mm5
|
||||
movq 24(%esp),%mm4
|
||||
paddq %mm5,%mm3
|
||||
movq %mm0,(%esp)
|
||||
paddq %mm7,%mm3
|
||||
movq %mm0,%mm5
|
||||
movq %mm0,%mm6
|
||||
paddq 72(%esp),%mm3
|
||||
psrlq $28,%mm5
|
||||
paddq %mm3,%mm4
|
||||
psllq $25,%mm6
|
||||
movq %mm5,%mm7
|
||||
psrlq $6,%mm5
|
||||
pxor %mm6,%mm7
|
||||
psllq $5,%mm6
|
||||
pxor %mm5,%mm7
|
||||
psrlq $5,%mm5
|
||||
pxor %mm6,%mm7
|
||||
psllq $6,%mm6
|
||||
pxor %mm5,%mm7
|
||||
subl $8,%esp
|
||||
pxor %mm6,%mm7
|
||||
movq %mm0,%mm5
|
||||
por %mm2,%mm0
|
||||
movq 88(%esp),%mm6
|
||||
pand %mm2,%mm5
|
||||
pand %mm1,%mm0
|
||||
movq 192(%esp),%mm2
|
||||
por %mm0,%mm5
|
||||
paddq %mm5,%mm7
|
||||
movq %mm3,%mm0
|
||||
movb (%ebp),%dl
|
||||
paddq %mm7,%mm0
|
||||
addl $8,%ebp
|
||||
.align 4,0x90
|
||||
L00516_79_sse2:
|
||||
movq %mm2,%mm1
|
||||
psrlq $1,%mm2
|
||||
movq %mm6,%mm7
|
||||
psrlq $6,%mm6
|
||||
movq %mm2,%mm3
|
||||
psrlq $6,%mm2
|
||||
movq %mm6,%mm5
|
||||
psrlq $13,%mm6
|
||||
pxor %mm2,%mm3
|
||||
psrlq $1,%mm2
|
||||
pxor %mm6,%mm5
|
||||
psrlq $42,%mm6
|
||||
pxor %mm2,%mm3
|
||||
movq 200(%esp),%mm2
|
||||
psllq $56,%mm1
|
||||
pxor %mm6,%mm5
|
||||
psllq $3,%mm7
|
||||
pxor %mm1,%mm3
|
||||
paddq 128(%esp),%mm2
|
||||
psllq $7,%mm1
|
||||
pxor %mm7,%mm5
|
||||
psllq $42,%mm7
|
||||
pxor %mm1,%mm3
|
||||
pxor %mm7,%mm5
|
||||
paddq %mm5,%mm3
|
||||
paddq %mm2,%mm3
|
||||
movq %mm3,72(%esp)
|
||||
movq 40(%esp),%mm5
|
||||
movq 48(%esp),%mm6
|
||||
movq 56(%esp),%mm7
|
||||
movq %mm4,%mm1
|
||||
movq %mm4,%mm2
|
||||
psrlq $14,%mm1
|
||||
movq %mm4,32(%esp)
|
||||
psllq $23,%mm2
|
||||
movq %mm1,%mm3
|
||||
psrlq $4,%mm1
|
||||
pxor %mm2,%mm3
|
||||
psllq $23,%mm2
|
||||
pxor %mm1,%mm3
|
||||
psrlq $23,%mm1
|
||||
pxor %mm2,%mm3
|
||||
psllq $4,%mm2
|
||||
pxor %mm1,%mm3
|
||||
paddq (%ebp),%mm7
|
||||
pxor %mm2,%mm3
|
||||
pxor %mm6,%mm5
|
||||
movq 8(%esp),%mm1
|
||||
pand %mm4,%mm5
|
||||
movq 16(%esp),%mm2
|
||||
pxor %mm6,%mm5
|
||||
movq 24(%esp),%mm4
|
||||
paddq %mm5,%mm3
|
||||
movq %mm0,(%esp)
|
||||
paddq %mm7,%mm3
|
||||
movq %mm0,%mm5
|
||||
movq %mm0,%mm6
|
||||
paddq 72(%esp),%mm3
|
||||
psrlq $28,%mm5
|
||||
paddq %mm3,%mm4
|
||||
psllq $25,%mm6
|
||||
movq %mm5,%mm7
|
||||
psrlq $6,%mm5
|
||||
pxor %mm6,%mm7
|
||||
psllq $5,%mm6
|
||||
pxor %mm5,%mm7
|
||||
psrlq $5,%mm5
|
||||
pxor %mm6,%mm7
|
||||
psllq $6,%mm6
|
||||
pxor %mm5,%mm7
|
||||
subl $8,%esp
|
||||
pxor %mm6,%mm7
|
||||
movq %mm0,%mm5
|
||||
por %mm2,%mm0
|
||||
movq 88(%esp),%mm6
|
||||
pand %mm2,%mm5
|
||||
pand %mm1,%mm0
|
||||
movq 192(%esp),%mm2
|
||||
por %mm0,%mm5
|
||||
paddq %mm5,%mm7
|
||||
movq %mm3,%mm0
|
||||
movb (%ebp),%dl
|
||||
paddq %mm7,%mm0
|
||||
addl $8,%ebp
|
||||
cmpb $23,%dl
|
||||
jne L00516_79_sse2
|
||||
movq 8(%esp),%mm1
|
||||
movq 16(%esp),%mm2
|
||||
movq 24(%esp),%mm3
|
||||
movq 40(%esp),%mm5
|
||||
movq 48(%esp),%mm6
|
||||
movq 56(%esp),%mm7
|
||||
paddq (%esi),%mm0
|
||||
paddq 8(%esi),%mm1
|
||||
paddq 16(%esi),%mm2
|
||||
paddq 24(%esi),%mm3
|
||||
paddq 32(%esi),%mm4
|
||||
paddq 40(%esi),%mm5
|
||||
paddq 48(%esi),%mm6
|
||||
paddq 56(%esi),%mm7
|
||||
movq %mm0,(%esi)
|
||||
movq %mm1,8(%esi)
|
||||
movq %mm2,16(%esi)
|
||||
movq %mm3,24(%esi)
|
||||
movq %mm4,32(%esi)
|
||||
movq %mm5,40(%esi)
|
||||
movq %mm6,48(%esi)
|
||||
movq %mm7,56(%esi)
|
||||
addl $640,%esp
|
||||
subl $640,%ebp
|
||||
cmpl 88(%esp),%edi
|
||||
jb L003loop_sse2
|
||||
emms
|
||||
movl 92(%esp),%esp
|
||||
popl %edi
|
||||
popl %esi
|
||||
popl %ebx
|
||||
popl %ebp
|
||||
ret
|
||||
.align 4,0x90
|
||||
L002loop_x86:
|
||||
movl (%edi),%eax
|
||||
movl 4(%edi),%ebx
|
||||
movl 8(%edi),%ecx
|
||||
movl 12(%edi),%edx
|
||||
bswap %eax
|
||||
bswap %ebx
|
||||
bswap %ecx
|
||||
bswap %edx
|
||||
pushl %eax
|
||||
pushl %ebx
|
||||
pushl %ecx
|
||||
pushl %edx
|
||||
movl 16(%edi),%eax
|
||||
movl 20(%edi),%ebx
|
||||
movl 24(%edi),%ecx
|
||||
movl 28(%edi),%edx
|
||||
bswap %eax
|
||||
bswap %ebx
|
||||
bswap %ecx
|
||||
bswap %edx
|
||||
pushl %eax
|
||||
pushl %ebx
|
||||
pushl %ecx
|
||||
pushl %edx
|
||||
movl 32(%edi),%eax
|
||||
movl 36(%edi),%ebx
|
||||
movl 40(%edi),%ecx
|
||||
movl 44(%edi),%edx
|
||||
bswap %eax
|
||||
bswap %ebx
|
||||
bswap %ecx
|
||||
bswap %edx
|
||||
pushl %eax
|
||||
pushl %ebx
|
||||
pushl %ecx
|
||||
pushl %edx
|
||||
movl 48(%edi),%eax
|
||||
movl 52(%edi),%ebx
|
||||
movl 56(%edi),%ecx
|
||||
movl 60(%edi),%edx
|
||||
bswap %eax
|
||||
bswap %ebx
|
||||
bswap %ecx
|
||||
bswap %edx
|
||||
pushl %eax
|
||||
pushl %ebx
|
||||
pushl %ecx
|
||||
pushl %edx
|
||||
movl 64(%edi),%eax
|
||||
movl 68(%edi),%ebx
|
||||
movl 72(%edi),%ecx
|
||||
movl 76(%edi),%edx
|
||||
bswap %eax
|
||||
bswap %ebx
|
||||
bswap %ecx
|
||||
bswap %edx
|
||||
pushl %eax
|
||||
pushl %ebx
|
||||
pushl %ecx
|
||||
pushl %edx
|
||||
movl 80(%edi),%eax
|
||||
movl 84(%edi),%ebx
|
||||
movl 88(%edi),%ecx
|
||||
movl 92(%edi),%edx
|
||||
bswap %eax
|
||||
bswap %ebx
|
||||
bswap %ecx
|
||||
bswap %edx
|
||||
pushl %eax
|
||||
pushl %ebx
|
||||
pushl %ecx
|
||||
pushl %edx
|
||||
movl 96(%edi),%eax
|
||||
movl 100(%edi),%ebx
|
||||
movl 104(%edi),%ecx
|
||||
movl 108(%edi),%edx
|
||||
bswap %eax
|
||||
bswap %ebx
|
||||
bswap %ecx
|
||||
bswap %edx
|
||||
pushl %eax
|
||||
pushl %ebx
|
||||
pushl %ecx
|
||||
pushl %edx
|
||||
movl 112(%edi),%eax
|
||||
movl 116(%edi),%ebx
|
||||
movl 120(%edi),%ecx
|
||||
movl 124(%edi),%edx
|
||||
bswap %eax
|
||||
bswap %ebx
|
||||
bswap %ecx
|
||||
bswap %edx
|
||||
pushl %eax
|
||||
pushl %ebx
|
||||
pushl %ecx
|
||||
pushl %edx
|
||||
addl $128,%edi
|
||||
subl $72,%esp
|
||||
movl %edi,204(%esp)
|
||||
leal 8(%esp),%edi
|
||||
movl $16,%ecx
|
||||
.long 2784229001
|
||||
.align 4,0x90
|
||||
L00600_15_x86:
|
||||
movl 40(%esp),%ecx
|
||||
movl 44(%esp),%edx
|
||||
movl %ecx,%esi
|
||||
shrl $9,%ecx
|
||||
movl %edx,%edi
|
||||
shrl $9,%edx
|
||||
movl %ecx,%ebx
|
||||
shll $14,%esi
|
||||
movl %edx,%eax
|
||||
shll $14,%edi
|
||||
xorl %esi,%ebx
|
||||
shrl $5,%ecx
|
||||
xorl %edi,%eax
|
||||
shrl $5,%edx
|
||||
xorl %ecx,%eax
|
||||
shll $4,%esi
|
||||
xorl %edx,%ebx
|
||||
shll $4,%edi
|
||||
xorl %esi,%ebx
|
||||
shrl $4,%ecx
|
||||
xorl %edi,%eax
|
||||
shrl $4,%edx
|
||||
xorl %ecx,%eax
|
||||
shll $5,%esi
|
||||
xorl %edx,%ebx
|
||||
shll $5,%edi
|
||||
xorl %esi,%eax
|
||||
xorl %edi,%ebx
|
||||
movl 48(%esp),%ecx
|
||||
movl 52(%esp),%edx
|
||||
movl 56(%esp),%esi
|
||||
movl 60(%esp),%edi
|
||||
addl 64(%esp),%eax
|
||||
adcl 68(%esp),%ebx
|
||||
xorl %esi,%ecx
|
||||
xorl %edi,%edx
|
||||
andl 40(%esp),%ecx
|
||||
andl 44(%esp),%edx
|
||||
addl 192(%esp),%eax
|
||||
adcl 196(%esp),%ebx
|
||||
xorl %esi,%ecx
|
||||
xorl %edi,%edx
|
||||
movl (%ebp),%esi
|
||||
movl 4(%ebp),%edi
|
||||
addl %ecx,%eax
|
||||
adcl %edx,%ebx
|
||||
movl 32(%esp),%ecx
|
||||
movl 36(%esp),%edx
|
||||
addl %esi,%eax
|
||||
adcl %edi,%ebx
|
||||
movl %eax,(%esp)
|
||||
movl %ebx,4(%esp)
|
||||
addl %ecx,%eax
|
||||
adcl %edx,%ebx
|
||||
movl 8(%esp),%ecx
|
||||
movl 12(%esp),%edx
|
||||
movl %eax,32(%esp)
|
||||
movl %ebx,36(%esp)
|
||||
movl %ecx,%esi
|
||||
shrl $2,%ecx
|
||||
movl %edx,%edi
|
||||
shrl $2,%edx
|
||||
movl %ecx,%ebx
|
||||
shll $4,%esi
|
||||
movl %edx,%eax
|
||||
shll $4,%edi
|
||||
xorl %esi,%ebx
|
||||
shrl $5,%ecx
|
||||
xorl %edi,%eax
|
||||
shrl $5,%edx
|
||||
xorl %ecx,%ebx
|
||||
shll $21,%esi
|
||||
xorl %edx,%eax
|
||||
shll $21,%edi
|
||||
xorl %esi,%eax
|
||||
shrl $21,%ecx
|
||||
xorl %edi,%ebx
|
||||
shrl $21,%edx
|
||||
xorl %ecx,%eax
|
||||
shll $5,%esi
|
||||
xorl %edx,%ebx
|
||||
shll $5,%edi
|
||||
xorl %esi,%eax
|
||||
xorl %edi,%ebx
|
||||
movl 8(%esp),%ecx
|
||||
movl 12(%esp),%edx
|
||||
movl 16(%esp),%esi
|
||||
movl 20(%esp),%edi
|
||||
addl (%esp),%eax
|
||||
adcl 4(%esp),%ebx
|
||||
orl %esi,%ecx
|
||||
orl %edi,%edx
|
||||
andl 24(%esp),%ecx
|
||||
andl 28(%esp),%edx
|
||||
andl 8(%esp),%esi
|
||||
andl 12(%esp),%edi
|
||||
orl %esi,%ecx
|
||||
orl %edi,%edx
|
||||
addl %ecx,%eax
|
||||
adcl %edx,%ebx
|
||||
movl %eax,(%esp)
|
||||
movl %ebx,4(%esp)
|
||||
movb (%ebp),%dl
|
||||
subl $8,%esp
|
||||
leal 8(%ebp),%ebp
|
||||
cmpb $148,%dl
|
||||
jne L00600_15_x86
|
||||
.align 4,0x90
|
||||
L00716_79_x86:
|
||||
movl 312(%esp),%ecx
|
||||
movl 316(%esp),%edx
|
||||
movl %ecx,%esi
|
||||
shrl $1,%ecx
|
||||
movl %edx,%edi
|
||||
shrl $1,%edx
|
||||
movl %ecx,%eax
|
||||
shll $24,%esi
|
||||
movl %edx,%ebx
|
||||
shll $24,%edi
|
||||
xorl %esi,%ebx
|
||||
shrl $6,%ecx
|
||||
xorl %edi,%eax
|
||||
shrl $6,%edx
|
||||
xorl %ecx,%eax
|
||||
shll $7,%esi
|
||||
xorl %edx,%ebx
|
||||
shll $1,%edi
|
||||
xorl %esi,%ebx
|
||||
shrl $1,%ecx
|
||||
xorl %edi,%eax
|
||||
shrl $1,%edx
|
||||
xorl %ecx,%eax
|
||||
shll $6,%edi
|
||||
xorl %edx,%ebx
|
||||
xorl %edi,%eax
|
||||
movl %eax,(%esp)
|
||||
movl %ebx,4(%esp)
|
||||
movl 208(%esp),%ecx
|
||||
movl 212(%esp),%edx
|
||||
movl %ecx,%esi
|
||||
shrl $6,%ecx
|
||||
movl %edx,%edi
|
||||
shrl $6,%edx
|
||||
movl %ecx,%eax
|
||||
shll $3,%esi
|
||||
movl %edx,%ebx
|
||||
shll $3,%edi
|
||||
xorl %esi,%eax
|
||||
shrl $13,%ecx
|
||||
xorl %edi,%ebx
|
||||
shrl $13,%edx
|
||||
xorl %ecx,%eax
|
||||
shll $10,%esi
|
||||
xorl %edx,%ebx
|
||||
shll $10,%edi
|
||||
xorl %esi,%ebx
|
||||
shrl $10,%ecx
|
||||
xorl %edi,%eax
|
||||
shrl $10,%edx
|
||||
xorl %ecx,%ebx
|
||||
shll $13,%edi
|
||||
xorl %edx,%eax
|
||||
xorl %edi,%eax
|
||||
movl 320(%esp),%ecx
|
||||
movl 324(%esp),%edx
|
||||
addl (%esp),%eax
|
||||
adcl 4(%esp),%ebx
|
||||
movl 248(%esp),%esi
|
||||
movl 252(%esp),%edi
|
||||
addl %ecx,%eax
|
||||
adcl %edx,%ebx
|
||||
addl %esi,%eax
|
||||
adcl %edi,%ebx
|
||||
movl %eax,192(%esp)
|
||||
movl %ebx,196(%esp)
|
||||
movl 40(%esp),%ecx
|
||||
movl 44(%esp),%edx
|
||||
movl %ecx,%esi
|
||||
shrl $9,%ecx
|
||||
movl %edx,%edi
|
||||
shrl $9,%edx
|
||||
movl %ecx,%ebx
|
||||
shll $14,%esi
|
||||
movl %edx,%eax
|
||||
shll $14,%edi
|
||||
xorl %esi,%ebx
|
||||
shrl $5,%ecx
|
||||
xorl %edi,%eax
|
||||
shrl $5,%edx
|
||||
xorl %ecx,%eax
|
||||
shll $4,%esi
|
||||
xorl %edx,%ebx
|
||||
shll $4,%edi
|
||||
xorl %esi,%ebx
|
||||
shrl $4,%ecx
|
||||
xorl %edi,%eax
|
||||
shrl $4,%edx
|
||||
xorl %ecx,%eax
|
||||
shll $5,%esi
|
||||
xorl %edx,%ebx
|
||||
shll $5,%edi
|
||||
xorl %esi,%eax
|
||||
xorl %edi,%ebx
|
||||
movl 48(%esp),%ecx
|
||||
movl 52(%esp),%edx
|
||||
movl 56(%esp),%esi
|
||||
movl 60(%esp),%edi
|
||||
addl 64(%esp),%eax
|
||||
adcl 68(%esp),%ebx
|
||||
xorl %esi,%ecx
|
||||
xorl %edi,%edx
|
||||
andl 40(%esp),%ecx
|
||||
andl 44(%esp),%edx
|
||||
addl 192(%esp),%eax
|
||||
adcl 196(%esp),%ebx
|
||||
xorl %esi,%ecx
|
||||
xorl %edi,%edx
|
||||
movl (%ebp),%esi
|
||||
movl 4(%ebp),%edi
|
||||
addl %ecx,%eax
|
||||
adcl %edx,%ebx
|
||||
movl 32(%esp),%ecx
|
||||
movl 36(%esp),%edx
|
||||
addl %esi,%eax
|
||||
adcl %edi,%ebx
|
||||
movl %eax,(%esp)
|
||||
movl %ebx,4(%esp)
|
||||
addl %ecx,%eax
|
||||
adcl %edx,%ebx
|
||||
movl 8(%esp),%ecx
|
||||
movl 12(%esp),%edx
|
||||
movl %eax,32(%esp)
|
||||
movl %ebx,36(%esp)
|
||||
movl %ecx,%esi
|
||||
shrl $2,%ecx
|
||||
movl %edx,%edi
|
||||
shrl $2,%edx
|
||||
movl %ecx,%ebx
|
||||
shll $4,%esi
|
||||
movl %edx,%eax
|
||||
shll $4,%edi
|
||||
xorl %esi,%ebx
|
||||
shrl $5,%ecx
|
||||
xorl %edi,%eax
|
||||
shrl $5,%edx
|
||||
xorl %ecx,%ebx
|
||||
shll $21,%esi
|
||||
xorl %edx,%eax
|
||||
shll $21,%edi
|
||||
xorl %esi,%eax
|
||||
shrl $21,%ecx
|
||||
xorl %edi,%ebx
|
||||
shrl $21,%edx
|
||||
xorl %ecx,%eax
|
||||
shll $5,%esi
|
||||
xorl %edx,%ebx
|
||||
shll $5,%edi
|
||||
xorl %esi,%eax
|
||||
xorl %edi,%ebx
|
||||
movl 8(%esp),%ecx
|
||||
movl 12(%esp),%edx
|
||||
movl 16(%esp),%esi
|
||||
movl 20(%esp),%edi
|
||||
addl (%esp),%eax
|
||||
adcl 4(%esp),%ebx
|
||||
orl %esi,%ecx
|
||||
orl %edi,%edx
|
||||
andl 24(%esp),%ecx
|
||||
andl 28(%esp),%edx
|
||||
andl 8(%esp),%esi
|
||||
andl 12(%esp),%edi
|
||||
orl %esi,%ecx
|
||||
orl %edi,%edx
|
||||
addl %ecx,%eax
|
||||
adcl %edx,%ebx
|
||||
movl %eax,(%esp)
|
||||
movl %ebx,4(%esp)
|
||||
movb (%ebp),%dl
|
||||
subl $8,%esp
|
||||
leal 8(%ebp),%ebp
|
||||
cmpb $23,%dl
|
||||
jne L00716_79_x86
|
||||
movl 840(%esp),%esi
|
||||
movl 844(%esp),%edi
|
||||
movl (%esi),%eax
|
||||
movl 4(%esi),%ebx
|
||||
movl 8(%esi),%ecx
|
||||
movl 12(%esi),%edx
|
||||
addl 8(%esp),%eax
|
||||
adcl 12(%esp),%ebx
|
||||
movl %eax,(%esi)
|
||||
movl %ebx,4(%esi)
|
||||
addl 16(%esp),%ecx
|
||||
adcl 20(%esp),%edx
|
||||
movl %ecx,8(%esi)
|
||||
movl %edx,12(%esi)
|
||||
movl 16(%esi),%eax
|
||||
movl 20(%esi),%ebx
|
||||
movl 24(%esi),%ecx
|
||||
movl 28(%esi),%edx
|
||||
addl 24(%esp),%eax
|
||||
adcl 28(%esp),%ebx
|
||||
movl %eax,16(%esi)
|
||||
movl %ebx,20(%esi)
|
||||
addl 32(%esp),%ecx
|
||||
adcl 36(%esp),%edx
|
||||
movl %ecx,24(%esi)
|
||||
movl %edx,28(%esi)
|
||||
movl 32(%esi),%eax
|
||||
movl 36(%esi),%ebx
|
||||
movl 40(%esi),%ecx
|
||||
movl 44(%esi),%edx
|
||||
addl 40(%esp),%eax
|
||||
adcl 44(%esp),%ebx
|
||||
movl %eax,32(%esi)
|
||||
movl %ebx,36(%esi)
|
||||
addl 48(%esp),%ecx
|
||||
adcl 52(%esp),%edx
|
||||
movl %ecx,40(%esi)
|
||||
movl %edx,44(%esi)
|
||||
movl 48(%esi),%eax
|
||||
movl 52(%esi),%ebx
|
||||
movl 56(%esi),%ecx
|
||||
movl 60(%esi),%edx
|
||||
addl 56(%esp),%eax
|
||||
adcl 60(%esp),%ebx
|
||||
movl %eax,48(%esi)
|
||||
movl %ebx,52(%esi)
|
||||
addl 64(%esp),%ecx
|
||||
adcl 68(%esp),%edx
|
||||
movl %ecx,56(%esi)
|
||||
movl %edx,60(%esi)
|
||||
addl $840,%esp
|
||||
subl $640,%ebp
|
||||
cmpl 8(%esp),%edi
|
||||
jb L002loop_x86
|
||||
movl 12(%esp),%esp
|
||||
popl %edi
|
||||
popl %esi
|
||||
popl %ebx
|
||||
popl %ebp
|
||||
ret
|
||||
.align 6,0x90
|
||||
L001K512:
|
||||
.long 3609767458,1116352408
|
||||
.long 602891725,1899447441
|
||||
.long 3964484399,3049323471
|
||||
.long 2173295548,3921009573
|
||||
.long 4081628472,961987163
|
||||
.long 3053834265,1508970993
|
||||
.long 2937671579,2453635748
|
||||
.long 3664609560,2870763221
|
||||
.long 2734883394,3624381080
|
||||
.long 1164996542,310598401
|
||||
.long 1323610764,607225278
|
||||
.long 3590304994,1426881987
|
||||
.long 4068182383,1925078388
|
||||
.long 991336113,2162078206
|
||||
.long 633803317,2614888103
|
||||
.long 3479774868,3248222580
|
||||
.long 2666613458,3835390401
|
||||
.long 944711139,4022224774
|
||||
.long 2341262773,264347078
|
||||
.long 2007800933,604807628
|
||||
.long 1495990901,770255983
|
||||
.long 1856431235,1249150122
|
||||
.long 3175218132,1555081692
|
||||
.long 2198950837,1996064986
|
||||
.long 3999719339,2554220882
|
||||
.long 766784016,2821834349
|
||||
.long 2566594879,2952996808
|
||||
.long 3203337956,3210313671
|
||||
.long 1034457026,3336571891
|
||||
.long 2466948901,3584528711
|
||||
.long 3758326383,113926993
|
||||
.long 168717936,338241895
|
||||
.long 1188179964,666307205
|
||||
.long 1546045734,773529912
|
||||
.long 1522805485,1294757372
|
||||
.long 2643833823,1396182291
|
||||
.long 2343527390,1695183700
|
||||
.long 1014477480,1986661051
|
||||
.long 1206759142,2177026350
|
||||
.long 344077627,2456956037
|
||||
.long 1290863460,2730485921
|
||||
.long 3158454273,2820302411
|
||||
.long 3505952657,3259730800
|
||||
.long 106217008,3345764771
|
||||
.long 3606008344,3516065817
|
||||
.long 1432725776,3600352804
|
||||
.long 1467031594,4094571909
|
||||
.long 851169720,275423344
|
||||
.long 3100823752,430227734
|
||||
.long 1363258195,506948616
|
||||
.long 3750685593,659060556
|
||||
.long 3785050280,883997877
|
||||
.long 3318307427,958139571
|
||||
.long 3812723403,1322822218
|
||||
.long 2003034995,1537002063
|
||||
.long 3602036899,1747873779
|
||||
.long 1575990012,1955562222
|
||||
.long 1125592928,2024104815
|
||||
.long 2716904306,2227730452
|
||||
.long 442776044,2361852424
|
||||
.long 593698344,2428436474
|
||||
.long 3733110249,2756734187
|
||||
.long 2999351573,3204031479
|
||||
.long 3815920427,3329325298
|
||||
.long 3928383900,3391569614
|
||||
.long 566280711,3515267271
|
||||
.long 3454069534,3940187606
|
||||
.long 4000239992,4118630271
|
||||
.long 1914138554,116418474
|
||||
.long 2731055270,174292421
|
||||
.long 3203993006,289380356
|
||||
.long 320620315,460393269
|
||||
.long 587496836,685471733
|
||||
.long 1086792851,852142971
|
||||
.long 365543100,1017036298
|
||||
.long 2618297676,1126000580
|
||||
.long 3409855158,1288033470
|
||||
.long 4234509866,1501505948
|
||||
.long 987167468,1607167915
|
||||
.long 1246189591,1816402316
|
||||
.byte 83,72,65,53,49,50,32,98,108,111,99,107,32,116,114,97
|
||||
.byte 110,115,102,111,114,109,32,102,111,114,32,120,56,54,44,32
|
||||
.byte 67,82,89,80,84,79,71,65,77,83,32,98,121,32,60,97
|
||||
.byte 112,112,114,111,64,111,112,101,110,115,115,108,46,111,114,103
|
||||
.byte 62,0
|
||||
.comm _OPENSSL_ia32cap_P,4
|
||||
1095
crypto/sha/sha512.c
1095
crypto/sha/sha512.c
File diff suppressed because it is too large
Load Diff
Binary file not shown.
@@ -15,170 +15,182 @@
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
printf("No SHA512 support\n");
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
#else
|
||||
|
||||
unsigned char app_c1[SHA512_DIGEST_LENGTH] = {
|
||||
0xdd,0xaf,0x35,0xa1,0x93,0x61,0x7a,0xba,
|
||||
0xcc,0x41,0x73,0x49,0xae,0x20,0x41,0x31,
|
||||
0x12,0xe6,0xfa,0x4e,0x89,0xa9,0x7e,0xa2,
|
||||
0x0a,0x9e,0xee,0xe6,0x4b,0x55,0xd3,0x9a,
|
||||
0x21,0x92,0x99,0x2a,0x27,0x4f,0xc1,0xa8,
|
||||
0x36,0xba,0x3c,0x23,0xa3,0xfe,0xeb,0xbd,
|
||||
0x45,0x4d,0x44,0x23,0x64,0x3c,0xe8,0x0e,
|
||||
0x2a,0x9a,0xc9,0x4f,0xa5,0x4c,0xa4,0x9f };
|
||||
0xdd, 0xaf, 0x35, 0xa1, 0x93, 0x61, 0x7a, 0xba,
|
||||
0xcc, 0x41, 0x73, 0x49, 0xae, 0x20, 0x41, 0x31,
|
||||
0x12, 0xe6, 0xfa, 0x4e, 0x89, 0xa9, 0x7e, 0xa2,
|
||||
0x0a, 0x9e, 0xee, 0xe6, 0x4b, 0x55, 0xd3, 0x9a,
|
||||
0x21, 0x92, 0x99, 0x2a, 0x27, 0x4f, 0xc1, 0xa8,
|
||||
0x36, 0xba, 0x3c, 0x23, 0xa3, 0xfe, 0xeb, 0xbd,
|
||||
0x45, 0x4d, 0x44, 0x23, 0x64, 0x3c, 0xe8, 0x0e,
|
||||
0x2a, 0x9a, 0xc9, 0x4f, 0xa5, 0x4c, 0xa4, 0x9f
|
||||
};
|
||||
|
||||
unsigned char app_c2[SHA512_DIGEST_LENGTH] = {
|
||||
0x8e,0x95,0x9b,0x75,0xda,0xe3,0x13,0xda,
|
||||
0x8c,0xf4,0xf7,0x28,0x14,0xfc,0x14,0x3f,
|
||||
0x8f,0x77,0x79,0xc6,0xeb,0x9f,0x7f,0xa1,
|
||||
0x72,0x99,0xae,0xad,0xb6,0x88,0x90,0x18,
|
||||
0x50,0x1d,0x28,0x9e,0x49,0x00,0xf7,0xe4,
|
||||
0x33,0x1b,0x99,0xde,0xc4,0xb5,0x43,0x3a,
|
||||
0xc7,0xd3,0x29,0xee,0xb6,0xdd,0x26,0x54,
|
||||
0x5e,0x96,0xe5,0x5b,0x87,0x4b,0xe9,0x09 };
|
||||
0x8e, 0x95, 0x9b, 0x75, 0xda, 0xe3, 0x13, 0xda,
|
||||
0x8c, 0xf4, 0xf7, 0x28, 0x14, 0xfc, 0x14, 0x3f,
|
||||
0x8f, 0x77, 0x79, 0xc6, 0xeb, 0x9f, 0x7f, 0xa1,
|
||||
0x72, 0x99, 0xae, 0xad, 0xb6, 0x88, 0x90, 0x18,
|
||||
0x50, 0x1d, 0x28, 0x9e, 0x49, 0x00, 0xf7, 0xe4,
|
||||
0x33, 0x1b, 0x99, 0xde, 0xc4, 0xb5, 0x43, 0x3a,
|
||||
0xc7, 0xd3, 0x29, 0xee, 0xb6, 0xdd, 0x26, 0x54,
|
||||
0x5e, 0x96, 0xe5, 0x5b, 0x87, 0x4b, 0xe9, 0x09
|
||||
};
|
||||
|
||||
unsigned char app_c3[SHA512_DIGEST_LENGTH] = {
|
||||
0xe7,0x18,0x48,0x3d,0x0c,0xe7,0x69,0x64,
|
||||
0x4e,0x2e,0x42,0xc7,0xbc,0x15,0xb4,0x63,
|
||||
0x8e,0x1f,0x98,0xb1,0x3b,0x20,0x44,0x28,
|
||||
0x56,0x32,0xa8,0x03,0xaf,0xa9,0x73,0xeb,
|
||||
0xde,0x0f,0xf2,0x44,0x87,0x7e,0xa6,0x0a,
|
||||
0x4c,0xb0,0x43,0x2c,0xe5,0x77,0xc3,0x1b,
|
||||
0xeb,0x00,0x9c,0x5c,0x2c,0x49,0xaa,0x2e,
|
||||
0x4e,0xad,0xb2,0x17,0xad,0x8c,0xc0,0x9b };
|
||||
0xe7, 0x18, 0x48, 0x3d, 0x0c, 0xe7, 0x69, 0x64,
|
||||
0x4e, 0x2e, 0x42, 0xc7, 0xbc, 0x15, 0xb4, 0x63,
|
||||
0x8e, 0x1f, 0x98, 0xb1, 0x3b, 0x20, 0x44, 0x28,
|
||||
0x56, 0x32, 0xa8, 0x03, 0xaf, 0xa9, 0x73, 0xeb,
|
||||
0xde, 0x0f, 0xf2, 0x44, 0x87, 0x7e, 0xa6, 0x0a,
|
||||
0x4c, 0xb0, 0x43, 0x2c, 0xe5, 0x77, 0xc3, 0x1b,
|
||||
0xeb, 0x00, 0x9c, 0x5c, 0x2c, 0x49, 0xaa, 0x2e,
|
||||
0x4e, 0xad, 0xb2, 0x17, 0xad, 0x8c, 0xc0, 0x9b
|
||||
};
|
||||
|
||||
unsigned char app_d1[SHA384_DIGEST_LENGTH] = {
|
||||
0xcb,0x00,0x75,0x3f,0x45,0xa3,0x5e,0x8b,
|
||||
0xb5,0xa0,0x3d,0x69,0x9a,0xc6,0x50,0x07,
|
||||
0x27,0x2c,0x32,0xab,0x0e,0xde,0xd1,0x63,
|
||||
0x1a,0x8b,0x60,0x5a,0x43,0xff,0x5b,0xed,
|
||||
0x80,0x86,0x07,0x2b,0xa1,0xe7,0xcc,0x23,
|
||||
0x58,0xba,0xec,0xa1,0x34,0xc8,0x25,0xa7 };
|
||||
0xcb, 0x00, 0x75, 0x3f, 0x45, 0xa3, 0x5e, 0x8b,
|
||||
0xb5, 0xa0, 0x3d, 0x69, 0x9a, 0xc6, 0x50, 0x07,
|
||||
0x27, 0x2c, 0x32, 0xab, 0x0e, 0xde, 0xd1, 0x63,
|
||||
0x1a, 0x8b, 0x60, 0x5a, 0x43, 0xff, 0x5b, 0xed,
|
||||
0x80, 0x86, 0x07, 0x2b, 0xa1, 0xe7, 0xcc, 0x23,
|
||||
0x58, 0xba, 0xec, 0xa1, 0x34, 0xc8, 0x25, 0xa7
|
||||
};
|
||||
|
||||
unsigned char app_d2[SHA384_DIGEST_LENGTH] = {
|
||||
0x09,0x33,0x0c,0x33,0xf7,0x11,0x47,0xe8,
|
||||
0x3d,0x19,0x2f,0xc7,0x82,0xcd,0x1b,0x47,
|
||||
0x53,0x11,0x1b,0x17,0x3b,0x3b,0x05,0xd2,
|
||||
0x2f,0xa0,0x80,0x86,0xe3,0xb0,0xf7,0x12,
|
||||
0xfc,0xc7,0xc7,0x1a,0x55,0x7e,0x2d,0xb9,
|
||||
0x66,0xc3,0xe9,0xfa,0x91,0x74,0x60,0x39 };
|
||||
0x09, 0x33, 0x0c, 0x33, 0xf7, 0x11, 0x47, 0xe8,
|
||||
0x3d, 0x19, 0x2f, 0xc7, 0x82, 0xcd, 0x1b, 0x47,
|
||||
0x53, 0x11, 0x1b, 0x17, 0x3b, 0x3b, 0x05, 0xd2,
|
||||
0x2f, 0xa0, 0x80, 0x86, 0xe3, 0xb0, 0xf7, 0x12,
|
||||
0xfc, 0xc7, 0xc7, 0x1a, 0x55, 0x7e, 0x2d, 0xb9,
|
||||
0x66, 0xc3, 0xe9, 0xfa, 0x91, 0x74, 0x60, 0x39
|
||||
};
|
||||
|
||||
unsigned char app_d3[SHA384_DIGEST_LENGTH] = {
|
||||
0x9d,0x0e,0x18,0x09,0x71,0x64,0x74,0xcb,
|
||||
0x08,0x6e,0x83,0x4e,0x31,0x0a,0x4a,0x1c,
|
||||
0xed,0x14,0x9e,0x9c,0x00,0xf2,0x48,0x52,
|
||||
0x79,0x72,0xce,0xc5,0x70,0x4c,0x2a,0x5b,
|
||||
0x07,0xb8,0xb3,0xdc,0x38,0xec,0xc4,0xeb,
|
||||
0xae,0x97,0xdd,0xd8,0x7f,0x3d,0x89,0x85 };
|
||||
0x9d, 0x0e, 0x18, 0x09, 0x71, 0x64, 0x74, 0xcb,
|
||||
0x08, 0x6e, 0x83, 0x4e, 0x31, 0x0a, 0x4a, 0x1c,
|
||||
0xed, 0x14, 0x9e, 0x9c, 0x00, 0xf2, 0x48, 0x52,
|
||||
0x79, 0x72, 0xce, 0xc5, 0x70, 0x4c, 0x2a, 0x5b,
|
||||
0x07, 0xb8, 0xb3, 0xdc, 0x38, 0xec, 0xc4, 0xeb,
|
||||
0xae, 0x97, 0xdd, 0xd8, 0x7f, 0x3d, 0x89, 0x85
|
||||
};
|
||||
|
||||
int main (int argc,char **argv)
|
||||
{ unsigned char md[SHA512_DIGEST_LENGTH];
|
||||
int i;
|
||||
EVP_MD_CTX evp;
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
unsigned char md[SHA512_DIGEST_LENGTH];
|
||||
int i;
|
||||
EVP_MD_CTX evp;
|
||||
|
||||
#ifdef OPENSSL_IA32_SSE2
|
||||
/* Alternative to this is to call OpenSSL_add_all_algorithms...
|
||||
* The below code is retained exclusively for debugging purposes. */
|
||||
{ char *env;
|
||||
# ifdef OPENSSL_IA32_SSE2
|
||||
/*
|
||||
* Alternative to this is to call OpenSSL_add_all_algorithms... The below
|
||||
* code is retained exclusively for debugging purposes.
|
||||
*/
|
||||
{
|
||||
char *env;
|
||||
|
||||
if ((env=getenv("OPENSSL_ia32cap")))
|
||||
OPENSSL_ia32cap = strtoul (env,NULL,0);
|
||||
if ((env = getenv("OPENSSL_ia32cap")))
|
||||
OPENSSL_ia32cap = strtoul(env, NULL, 0);
|
||||
}
|
||||
#endif
|
||||
# endif
|
||||
|
||||
fprintf(stdout,"Testing SHA-512 ");
|
||||
fprintf(stdout, "Testing SHA-512 ");
|
||||
|
||||
EVP_Digest ("abc",3,md,NULL,EVP_sha512(),NULL);
|
||||
if (memcmp(md,app_c1,sizeof(app_c1)))
|
||||
{ fflush(stdout);
|
||||
fprintf(stderr,"\nTEST 1 of 3 failed.\n");
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
fprintf(stdout,"."); fflush(stdout);
|
||||
EVP_Digest("abc", 3, md, NULL, EVP_sha512(), NULL);
|
||||
if (memcmp(md, app_c1, sizeof(app_c1))) {
|
||||
fflush(stdout);
|
||||
fprintf(stderr, "\nTEST 1 of 3 failed.\n");
|
||||
return 1;
|
||||
} else
|
||||
fprintf(stdout, ".");
|
||||
fflush(stdout);
|
||||
|
||||
EVP_Digest ("abcdefgh""bcdefghi""cdefghij""defghijk"
|
||||
"efghijkl""fghijklm""ghijklmn""hijklmno"
|
||||
"ijklmnop""jklmnopq""klmnopqr""lmnopqrs"
|
||||
"mnopqrst""nopqrstu",112,md,NULL,EVP_sha512(),NULL);
|
||||
if (memcmp(md,app_c2,sizeof(app_c2)))
|
||||
{ fflush(stdout);
|
||||
fprintf(stderr,"\nTEST 2 of 3 failed.\n");
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
fprintf(stdout,"."); fflush(stdout);
|
||||
EVP_Digest("abcdefgh" "bcdefghi" "cdefghij" "defghijk"
|
||||
"efghijkl" "fghijklm" "ghijklmn" "hijklmno"
|
||||
"ijklmnop" "jklmnopq" "klmnopqr" "lmnopqrs"
|
||||
"mnopqrst" "nopqrstu", 112, md, NULL, EVP_sha512(), NULL);
|
||||
if (memcmp(md, app_c2, sizeof(app_c2))) {
|
||||
fflush(stdout);
|
||||
fprintf(stderr, "\nTEST 2 of 3 failed.\n");
|
||||
return 1;
|
||||
} else
|
||||
fprintf(stdout, ".");
|
||||
fflush(stdout);
|
||||
|
||||
EVP_MD_CTX_init (&evp);
|
||||
EVP_DigestInit_ex (&evp,EVP_sha512(),NULL);
|
||||
for (i=0;i<1000000;i+=288)
|
||||
EVP_DigestUpdate (&evp, "aaaaaaaa""aaaaaaaa""aaaaaaaa""aaaaaaaa"
|
||||
"aaaaaaaa""aaaaaaaa""aaaaaaaa""aaaaaaaa"
|
||||
"aaaaaaaa""aaaaaaaa""aaaaaaaa""aaaaaaaa"
|
||||
"aaaaaaaa""aaaaaaaa""aaaaaaaa""aaaaaaaa"
|
||||
"aaaaaaaa""aaaaaaaa""aaaaaaaa""aaaaaaaa"
|
||||
"aaaaaaaa""aaaaaaaa""aaaaaaaa""aaaaaaaa"
|
||||
"aaaaaaaa""aaaaaaaa""aaaaaaaa""aaaaaaaa"
|
||||
"aaaaaaaa""aaaaaaaa""aaaaaaaa""aaaaaaaa"
|
||||
"aaaaaaaa""aaaaaaaa""aaaaaaaa""aaaaaaaa",
|
||||
(1000000-i)<288?1000000-i:288);
|
||||
EVP_DigestFinal_ex (&evp,md,NULL);
|
||||
EVP_MD_CTX_cleanup (&evp);
|
||||
EVP_MD_CTX_init(&evp);
|
||||
EVP_DigestInit_ex(&evp, EVP_sha512(), NULL);
|
||||
for (i = 0; i < 1000000; i += 288)
|
||||
EVP_DigestUpdate(&evp, "aaaaaaaa" "aaaaaaaa" "aaaaaaaa" "aaaaaaaa"
|
||||
"aaaaaaaa" "aaaaaaaa" "aaaaaaaa" "aaaaaaaa"
|
||||
"aaaaaaaa" "aaaaaaaa" "aaaaaaaa" "aaaaaaaa"
|
||||
"aaaaaaaa" "aaaaaaaa" "aaaaaaaa" "aaaaaaaa"
|
||||
"aaaaaaaa" "aaaaaaaa" "aaaaaaaa" "aaaaaaaa"
|
||||
"aaaaaaaa" "aaaaaaaa" "aaaaaaaa" "aaaaaaaa"
|
||||
"aaaaaaaa" "aaaaaaaa" "aaaaaaaa" "aaaaaaaa"
|
||||
"aaaaaaaa" "aaaaaaaa" "aaaaaaaa" "aaaaaaaa"
|
||||
"aaaaaaaa" "aaaaaaaa" "aaaaaaaa" "aaaaaaaa",
|
||||
(1000000 - i) < 288 ? 1000000 - i : 288);
|
||||
EVP_DigestFinal_ex(&evp, md, NULL);
|
||||
EVP_MD_CTX_cleanup(&evp);
|
||||
|
||||
if (memcmp(md,app_c3,sizeof(app_c3)))
|
||||
{ fflush(stdout);
|
||||
fprintf(stderr,"\nTEST 3 of 3 failed.\n");
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
fprintf(stdout,"."); fflush(stdout);
|
||||
if (memcmp(md, app_c3, sizeof(app_c3))) {
|
||||
fflush(stdout);
|
||||
fprintf(stderr, "\nTEST 3 of 3 failed.\n");
|
||||
return 1;
|
||||
} else
|
||||
fprintf(stdout, ".");
|
||||
fflush(stdout);
|
||||
|
||||
fprintf(stdout," passed.\n"); fflush(stdout);
|
||||
fprintf(stdout, " passed.\n");
|
||||
fflush(stdout);
|
||||
|
||||
fprintf(stdout,"Testing SHA-384 ");
|
||||
fprintf(stdout, "Testing SHA-384 ");
|
||||
|
||||
EVP_Digest ("abc",3,md,NULL,EVP_sha384(),NULL);
|
||||
if (memcmp(md,app_d1,sizeof(app_d1)))
|
||||
{ fflush(stdout);
|
||||
fprintf(stderr,"\nTEST 1 of 3 failed.\n");
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
fprintf(stdout,"."); fflush(stdout);
|
||||
EVP_Digest("abc", 3, md, NULL, EVP_sha384(), NULL);
|
||||
if (memcmp(md, app_d1, sizeof(app_d1))) {
|
||||
fflush(stdout);
|
||||
fprintf(stderr, "\nTEST 1 of 3 failed.\n");
|
||||
return 1;
|
||||
} else
|
||||
fprintf(stdout, ".");
|
||||
fflush(stdout);
|
||||
|
||||
EVP_Digest ("abcdefgh""bcdefghi""cdefghij""defghijk"
|
||||
"efghijkl""fghijklm""ghijklmn""hijklmno"
|
||||
"ijklmnop""jklmnopq""klmnopqr""lmnopqrs"
|
||||
"mnopqrst""nopqrstu",112,md,NULL,EVP_sha384(),NULL);
|
||||
if (memcmp(md,app_d2,sizeof(app_d2)))
|
||||
{ fflush(stdout);
|
||||
fprintf(stderr,"\nTEST 2 of 3 failed.\n");
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
fprintf(stdout,"."); fflush(stdout);
|
||||
EVP_Digest("abcdefgh" "bcdefghi" "cdefghij" "defghijk"
|
||||
"efghijkl" "fghijklm" "ghijklmn" "hijklmno"
|
||||
"ijklmnop" "jklmnopq" "klmnopqr" "lmnopqrs"
|
||||
"mnopqrst" "nopqrstu", 112, md, NULL, EVP_sha384(), NULL);
|
||||
if (memcmp(md, app_d2, sizeof(app_d2))) {
|
||||
fflush(stdout);
|
||||
fprintf(stderr, "\nTEST 2 of 3 failed.\n");
|
||||
return 1;
|
||||
} else
|
||||
fprintf(stdout, ".");
|
||||
fflush(stdout);
|
||||
|
||||
EVP_MD_CTX_init (&evp);
|
||||
EVP_DigestInit_ex (&evp,EVP_sha384(),NULL);
|
||||
for (i=0;i<1000000;i+=64)
|
||||
EVP_DigestUpdate (&evp, "aaaaaaaa""aaaaaaaa""aaaaaaaa""aaaaaaaa"
|
||||
"aaaaaaaa""aaaaaaaa""aaaaaaaa""aaaaaaaa",
|
||||
(1000000-i)<64?1000000-i:64);
|
||||
EVP_DigestFinal_ex (&evp,md,NULL);
|
||||
EVP_MD_CTX_cleanup (&evp);
|
||||
EVP_MD_CTX_init(&evp);
|
||||
EVP_DigestInit_ex(&evp, EVP_sha384(), NULL);
|
||||
for (i = 0; i < 1000000; i += 64)
|
||||
EVP_DigestUpdate(&evp, "aaaaaaaa" "aaaaaaaa" "aaaaaaaa" "aaaaaaaa"
|
||||
"aaaaaaaa" "aaaaaaaa" "aaaaaaaa" "aaaaaaaa",
|
||||
(1000000 - i) < 64 ? 1000000 - i : 64);
|
||||
EVP_DigestFinal_ex(&evp, md, NULL);
|
||||
EVP_MD_CTX_cleanup(&evp);
|
||||
|
||||
if (memcmp(md,app_d3,sizeof(app_d3)))
|
||||
{ fflush(stdout);
|
||||
fprintf(stderr,"\nTEST 3 of 3 failed.\n");
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
fprintf(stdout,"."); fflush(stdout);
|
||||
if (memcmp(md, app_d3, sizeof(app_d3))) {
|
||||
fflush(stdout);
|
||||
fprintf(stderr, "\nTEST 3 of 3 failed.\n");
|
||||
return 1;
|
||||
} else
|
||||
fprintf(stdout, ".");
|
||||
fflush(stdout);
|
||||
|
||||
fprintf(stdout," passed.\n"); fflush(stdout);
|
||||
fprintf(stdout, " passed.\n");
|
||||
fflush(stdout);
|
||||
|
||||
return 0;
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
|
||||
@@ -5,21 +5,21 @@
|
||||
* This package is an SSL implementation written
|
||||
* by Eric Young (eay@cryptsoft.com).
|
||||
* The implementation was written so as to conform with Netscapes SSL.
|
||||
*
|
||||
*
|
||||
* This library is free for commercial and non-commercial use as long as
|
||||
* the following conditions are aheared to. The following conditions
|
||||
* apply to all code found in this distribution, be it the RC4, RSA,
|
||||
* lhash, DES, etc., code; not just the SSL code. The SSL documentation
|
||||
* included with this distribution is covered by the same copyright terms
|
||||
* except that the holder is Tim Hudson (tjh@cryptsoft.com).
|
||||
*
|
||||
*
|
||||
* Copyright remains Eric Young's, and as such any Copyright notices in
|
||||
* the code are not to be removed.
|
||||
* If this package is used in a product, Eric Young should be given attribution
|
||||
* as the author of the parts of the library used.
|
||||
* This can be in the form of a textual message at program startup or
|
||||
* in documentation (online or textual) provided with the package.
|
||||
*
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
@@ -34,10 +34,10 @@
|
||||
* Eric Young (eay@cryptsoft.com)"
|
||||
* The word 'cryptographic' can be left out if the rouines from the library
|
||||
* being used are not cryptographic related :-).
|
||||
* 4. If you include any Windows specific code (or a derivative thereof) from
|
||||
* 4. If you include any Windows specific code (or a derivative thereof) from
|
||||
* the apps directory (application code) you must include an acknowledgement:
|
||||
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
|
||||
*
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
@@ -49,26 +49,26 @@
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*
|
||||
*
|
||||
* The licence and distribution terms for any publically available version or
|
||||
* derivative of this code cannot be changed. i.e. this code cannot simply be
|
||||
* copied and put under another distribution licence
|
||||
* [including the GNU Public Licence.]
|
||||
*/
|
||||
|
||||
#include <openssl/crypto.h>
|
||||
#include <openssl/opensslconf.h>
|
||||
#if !defined(OPENSSL_NO_SHA0) && !defined(OPENSSL_NO_SHA)
|
||||
|
||||
#undef SHA_1
|
||||
#define SHA_0
|
||||
# undef SHA_1
|
||||
# define SHA_0
|
||||
|
||||
#include <openssl/opensslv.h>
|
||||
# include <openssl/opensslv.h>
|
||||
|
||||
const char SHA_version[]="SHA" OPENSSL_VERSION_PTEXT;
|
||||
const char SHA_version[] = "SHA" OPENSSL_VERSION_PTEXT;
|
||||
|
||||
/* The implementation is in ../md32_common.h */
|
||||
|
||||
#include "sha_locl.h"
|
||||
# include "sha_locl.h"
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
Binary file not shown.
@@ -5,21 +5,21 @@
|
||||
* This package is an SSL implementation written
|
||||
* by Eric Young (eay@cryptsoft.com).
|
||||
* The implementation was written so as to conform with Netscapes SSL.
|
||||
*
|
||||
*
|
||||
* This library is free for commercial and non-commercial use as long as
|
||||
* the following conditions are aheared to. The following conditions
|
||||
* apply to all code found in this distribution, be it the RC4, RSA,
|
||||
* lhash, DES, etc., code; not just the SSL code. The SSL documentation
|
||||
* included with this distribution is covered by the same copyright terms
|
||||
* except that the holder is Tim Hudson (tjh@cryptsoft.com).
|
||||
*
|
||||
*
|
||||
* Copyright remains Eric Young's, and as such any Copyright notices in
|
||||
* the code are not to be removed.
|
||||
* If this package is used in a product, Eric Young should be given attribution
|
||||
* as the author of the parts of the library used.
|
||||
* This can be in the form of a textual message at program startup or
|
||||
* in documentation (online or textual) provided with the package.
|
||||
*
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
@@ -34,10 +34,10 @@
|
||||
* Eric Young (eay@cryptsoft.com)"
|
||||
* The word 'cryptographic' can be left out if the rouines from the library
|
||||
* being used are not cryptographic related :-).
|
||||
* 4. If you include any Windows specific code (or a derivative thereof) from
|
||||
* 4. If you include any Windows specific code (or a derivative thereof) from
|
||||
* the apps directory (application code) you must include an acknowledgement:
|
||||
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
|
||||
*
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
@@ -49,7 +49,7 @@
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*
|
||||
*
|
||||
* The licence and distribution terms for any publically available version or
|
||||
* derivative of this code cannot be changed. i.e. this code cannot simply be
|
||||
* copied and put under another distribution licence
|
||||
@@ -67,48 +67,48 @@
|
||||
#define HASH_LONG SHA_LONG
|
||||
#define HASH_CTX SHA_CTX
|
||||
#define HASH_CBLOCK SHA_CBLOCK
|
||||
#define HASH_MAKE_STRING(c,s) do { \
|
||||
unsigned long ll; \
|
||||
ll=(c)->h0; HOST_l2c(ll,(s)); \
|
||||
ll=(c)->h1; HOST_l2c(ll,(s)); \
|
||||
ll=(c)->h2; HOST_l2c(ll,(s)); \
|
||||
ll=(c)->h3; HOST_l2c(ll,(s)); \
|
||||
ll=(c)->h4; HOST_l2c(ll,(s)); \
|
||||
} while (0)
|
||||
#define HASH_MAKE_STRING(c,s) do { \
|
||||
unsigned long ll; \
|
||||
ll=(c)->h0; (void)HOST_l2c(ll,(s)); \
|
||||
ll=(c)->h1; (void)HOST_l2c(ll,(s)); \
|
||||
ll=(c)->h2; (void)HOST_l2c(ll,(s)); \
|
||||
ll=(c)->h3; (void)HOST_l2c(ll,(s)); \
|
||||
ll=(c)->h4; (void)HOST_l2c(ll,(s)); \
|
||||
} while (0)
|
||||
|
||||
#if defined(SHA_0)
|
||||
|
||||
# define HASH_UPDATE SHA_Update
|
||||
# define HASH_TRANSFORM SHA_Transform
|
||||
# define HASH_FINAL SHA_Final
|
||||
# define HASH_INIT SHA_Init
|
||||
# define HASH_BLOCK_DATA_ORDER sha_block_data_order
|
||||
# define Xupdate(a,ix,ia,ib,ic,id) (ix=(a)=(ia^ib^ic^id))
|
||||
# define HASH_UPDATE SHA_Update
|
||||
# define HASH_TRANSFORM SHA_Transform
|
||||
# define HASH_FINAL SHA_Final
|
||||
# define HASH_INIT SHA_Init
|
||||
# define HASH_BLOCK_DATA_ORDER sha_block_data_order
|
||||
# define Xupdate(a,ix,ia,ib,ic,id) (ix=(a)=(ia^ib^ic^id))
|
||||
|
||||
static void sha_block_data_order (SHA_CTX *c, const void *p,size_t num);
|
||||
static void sha_block_data_order(SHA_CTX *c, const void *p, size_t num);
|
||||
|
||||
#elif defined(SHA_1)
|
||||
|
||||
# define HASH_UPDATE SHA1_Update
|
||||
# define HASH_TRANSFORM SHA1_Transform
|
||||
# define HASH_FINAL SHA1_Final
|
||||
# define HASH_INIT SHA1_Init
|
||||
# define HASH_BLOCK_DATA_ORDER sha1_block_data_order
|
||||
# define HASH_UPDATE SHA1_Update
|
||||
# define HASH_TRANSFORM SHA1_Transform
|
||||
# define HASH_FINAL SHA1_Final
|
||||
# define HASH_INIT SHA1_Init
|
||||
# define HASH_BLOCK_DATA_ORDER sha1_block_data_order
|
||||
# if defined(__MWERKS__) && defined(__MC68K__)
|
||||
/* Metrowerks for Motorola fails otherwise:-( <appro@fy.chalmers.se> */
|
||||
# define Xupdate(a,ix,ia,ib,ic,id) do { (a)=(ia^ib^ic^id); \
|
||||
ix=(a)=ROTATE((a),1); \
|
||||
} while (0)
|
||||
# define Xupdate(a,ix,ia,ib,ic,id) do { (a)=(ia^ib^ic^id); \
|
||||
ix=(a)=ROTATE((a),1); \
|
||||
} while (0)
|
||||
# else
|
||||
# define Xupdate(a,ix,ia,ib,ic,id) ( (a)=(ia^ib^ic^id), \
|
||||
ix=(a)=ROTATE((a),1) \
|
||||
)
|
||||
# define Xupdate(a,ix,ia,ib,ic,id) ( (a)=(ia^ib^ic^id), \
|
||||
ix=(a)=ROTATE((a),1) \
|
||||
)
|
||||
# endif
|
||||
|
||||
#ifndef SHA1_ASM
|
||||
# ifndef SHA1_ASM
|
||||
static
|
||||
#endif
|
||||
void sha1_block_data_order (SHA_CTX *c, const void *p,size_t num);
|
||||
# endif
|
||||
void sha1_block_data_order(SHA_CTX *c, const void *p, size_t num);
|
||||
|
||||
#else
|
||||
# error "Either SHA_0 or SHA_1 must be defined."
|
||||
@@ -122,69 +122,73 @@ void sha1_block_data_order (SHA_CTX *c, const void *p,size_t num);
|
||||
#define INIT_DATA_h3 0x10325476UL
|
||||
#define INIT_DATA_h4 0xc3d2e1f0UL
|
||||
|
||||
int HASH_INIT (SHA_CTX *c)
|
||||
{
|
||||
memset (c,0,sizeof(*c));
|
||||
c->h0=INIT_DATA_h0;
|
||||
c->h1=INIT_DATA_h1;
|
||||
c->h2=INIT_DATA_h2;
|
||||
c->h3=INIT_DATA_h3;
|
||||
c->h4=INIT_DATA_h4;
|
||||
return 1;
|
||||
}
|
||||
#ifdef SHA_0
|
||||
fips_md_init(SHA)
|
||||
#else
|
||||
fips_md_init_ctx(SHA1, SHA)
|
||||
#endif
|
||||
{
|
||||
memset(c, 0, sizeof(*c));
|
||||
c->h0 = INIT_DATA_h0;
|
||||
c->h1 = INIT_DATA_h1;
|
||||
c->h2 = INIT_DATA_h2;
|
||||
c->h3 = INIT_DATA_h3;
|
||||
c->h4 = INIT_DATA_h4;
|
||||
return 1;
|
||||
}
|
||||
|
||||
#define K_00_19 0x5a827999UL
|
||||
#define K_00_19 0x5a827999UL
|
||||
#define K_20_39 0x6ed9eba1UL
|
||||
#define K_40_59 0x8f1bbcdcUL
|
||||
#define K_60_79 0xca62c1d6UL
|
||||
|
||||
/* As pointed out by Wei Dai <weidai@eskimo.com>, F() below can be
|
||||
* simplified to the code in F_00_19. Wei attributes these optimisations
|
||||
* to Peter Gutmann's SHS code, and he attributes it to Rich Schroeppel.
|
||||
* #define F(x,y,z) (((x) & (y)) | ((~(x)) & (z)))
|
||||
* I've just become aware of another tweak to be made, again from Wei Dai,
|
||||
* in F_40_59, (x&a)|(y&a) -> (x|y)&a
|
||||
/*
|
||||
* As pointed out by Wei Dai <weidai@eskimo.com>, F() below can be simplified
|
||||
* to the code in F_00_19. Wei attributes these optimisations to Peter
|
||||
* Gutmann's SHS code, and he attributes it to Rich Schroeppel. #define
|
||||
* F(x,y,z) (((x) & (y)) | ((~(x)) & (z))) I've just become aware of another
|
||||
* tweak to be made, again from Wei Dai, in F_40_59, (x&a)|(y&a) -> (x|y)&a
|
||||
*/
|
||||
#define F_00_19(b,c,d) ((((c) ^ (d)) & (b)) ^ (d))
|
||||
#define F_20_39(b,c,d) ((b) ^ (c) ^ (d))
|
||||
#define F_40_59(b,c,d) (((b) & (c)) | (((b)|(c)) & (d)))
|
||||
#define F_60_79(b,c,d) F_20_39(b,c,d)
|
||||
#define F_00_19(b,c,d) ((((c) ^ (d)) & (b)) ^ (d))
|
||||
#define F_20_39(b,c,d) ((b) ^ (c) ^ (d))
|
||||
#define F_40_59(b,c,d) (((b) & (c)) | (((b)|(c)) & (d)))
|
||||
#define F_60_79(b,c,d) F_20_39(b,c,d)
|
||||
|
||||
#ifndef OPENSSL_SMALL_FOOTPRINT
|
||||
|
||||
#define BODY_00_15(i,a,b,c,d,e,f,xi) \
|
||||
(f)=xi+(e)+K_00_19+ROTATE((a),5)+F_00_19((b),(c),(d)); \
|
||||
(b)=ROTATE((b),30);
|
||||
# define BODY_00_15(i,a,b,c,d,e,f,xi) \
|
||||
(f)=xi+(e)+K_00_19+ROTATE((a),5)+F_00_19((b),(c),(d)); \
|
||||
(b)=ROTATE((b),30);
|
||||
|
||||
#define BODY_16_19(i,a,b,c,d,e,f,xi,xa,xb,xc,xd) \
|
||||
Xupdate(f,xi,xa,xb,xc,xd); \
|
||||
(f)+=(e)+K_00_19+ROTATE((a),5)+F_00_19((b),(c),(d)); \
|
||||
(b)=ROTATE((b),30);
|
||||
# define BODY_16_19(i,a,b,c,d,e,f,xi,xa,xb,xc,xd) \
|
||||
Xupdate(f,xi,xa,xb,xc,xd); \
|
||||
(f)+=(e)+K_00_19+ROTATE((a),5)+F_00_19((b),(c),(d)); \
|
||||
(b)=ROTATE((b),30);
|
||||
|
||||
#define BODY_20_31(i,a,b,c,d,e,f,xi,xa,xb,xc,xd) \
|
||||
Xupdate(f,xi,xa,xb,xc,xd); \
|
||||
(f)+=(e)+K_20_39+ROTATE((a),5)+F_20_39((b),(c),(d)); \
|
||||
(b)=ROTATE((b),30);
|
||||
# define BODY_20_31(i,a,b,c,d,e,f,xi,xa,xb,xc,xd) \
|
||||
Xupdate(f,xi,xa,xb,xc,xd); \
|
||||
(f)+=(e)+K_20_39+ROTATE((a),5)+F_20_39((b),(c),(d)); \
|
||||
(b)=ROTATE((b),30);
|
||||
|
||||
#define BODY_32_39(i,a,b,c,d,e,f,xa,xb,xc,xd) \
|
||||
Xupdate(f,xa,xa,xb,xc,xd); \
|
||||
(f)+=(e)+K_20_39+ROTATE((a),5)+F_20_39((b),(c),(d)); \
|
||||
(b)=ROTATE((b),30);
|
||||
# define BODY_32_39(i,a,b,c,d,e,f,xa,xb,xc,xd) \
|
||||
Xupdate(f,xa,xa,xb,xc,xd); \
|
||||
(f)+=(e)+K_20_39+ROTATE((a),5)+F_20_39((b),(c),(d)); \
|
||||
(b)=ROTATE((b),30);
|
||||
|
||||
#define BODY_40_59(i,a,b,c,d,e,f,xa,xb,xc,xd) \
|
||||
Xupdate(f,xa,xa,xb,xc,xd); \
|
||||
(f)+=(e)+K_40_59+ROTATE((a),5)+F_40_59((b),(c),(d)); \
|
||||
(b)=ROTATE((b),30);
|
||||
# define BODY_40_59(i,a,b,c,d,e,f,xa,xb,xc,xd) \
|
||||
Xupdate(f,xa,xa,xb,xc,xd); \
|
||||
(f)+=(e)+K_40_59+ROTATE((a),5)+F_40_59((b),(c),(d)); \
|
||||
(b)=ROTATE((b),30);
|
||||
|
||||
#define BODY_60_79(i,a,b,c,d,e,f,xa,xb,xc,xd) \
|
||||
Xupdate(f,xa,xa,xb,xc,xd); \
|
||||
(f)=xa+(e)+K_60_79+ROTATE((a),5)+F_60_79((b),(c),(d)); \
|
||||
(b)=ROTATE((b),30);
|
||||
# define BODY_60_79(i,a,b,c,d,e,f,xa,xb,xc,xd) \
|
||||
Xupdate(f,xa,xa,xb,xc,xd); \
|
||||
(f)=xa+(e)+K_60_79+ROTATE((a),5)+F_60_79((b),(c),(d)); \
|
||||
(b)=ROTATE((b),30);
|
||||
|
||||
#ifdef X
|
||||
#undef X
|
||||
#endif
|
||||
#ifndef MD32_XARRAY
|
||||
# ifdef X
|
||||
# undef X
|
||||
# endif
|
||||
# ifndef MD32_XARRAY
|
||||
/*
|
||||
* Originally X was an array. As it's automatic it's natural
|
||||
* to expect RISC compiler to accomodate at least part of it in
|
||||
@@ -192,246 +196,305 @@ int HASH_INIT (SHA_CTX *c)
|
||||
* "find" this expectation reasonable:-( On order to make such
|
||||
* compilers generate better code I replace X[] with a bunch of
|
||||
* X0, X1, etc. See the function body below...
|
||||
* <appro@fy.chalmers.se>
|
||||
* <appro@fy.chalmers.se>
|
||||
*/
|
||||
# define X(i) XX##i
|
||||
#else
|
||||
# define X(i) XX##i
|
||||
# else
|
||||
/*
|
||||
* However! Some compilers (most notably HP C) get overwhelmed by
|
||||
* that many local variables so that we have to have the way to
|
||||
* fall down to the original behavior.
|
||||
*/
|
||||
# define X(i) XX[i]
|
||||
#endif
|
||||
# define X(i) XX[i]
|
||||
# endif
|
||||
|
||||
#if !defined(SHA_1) || !defined(SHA1_ASM)
|
||||
static void HASH_BLOCK_DATA_ORDER (SHA_CTX *c, const void *p, size_t num)
|
||||
{
|
||||
const unsigned char *data=p;
|
||||
register unsigned MD32_REG_T A,B,C,D,E,T,l;
|
||||
#ifndef MD32_XARRAY
|
||||
unsigned MD32_REG_T XX0, XX1, XX2, XX3, XX4, XX5, XX6, XX7,
|
||||
XX8, XX9,XX10,XX11,XX12,XX13,XX14,XX15;
|
||||
#else
|
||||
SHA_LONG XX[16];
|
||||
#endif
|
||||
# if !defined(SHA_1) || !defined(SHA1_ASM)
|
||||
static void HASH_BLOCK_DATA_ORDER(SHA_CTX *c, const void *p, size_t num)
|
||||
{
|
||||
const unsigned char *data = p;
|
||||
register unsigned MD32_REG_T A, B, C, D, E, T, l;
|
||||
# ifndef MD32_XARRAY
|
||||
unsigned MD32_REG_T XX0, XX1, XX2, XX3, XX4, XX5, XX6, XX7,
|
||||
XX8, XX9, XX10, XX11, XX12, XX13, XX14, XX15;
|
||||
# else
|
||||
SHA_LONG XX[16];
|
||||
# endif
|
||||
|
||||
A=c->h0;
|
||||
B=c->h1;
|
||||
C=c->h2;
|
||||
D=c->h3;
|
||||
E=c->h4;
|
||||
A = c->h0;
|
||||
B = c->h1;
|
||||
C = c->h2;
|
||||
D = c->h3;
|
||||
E = c->h4;
|
||||
|
||||
for (;;)
|
||||
{
|
||||
const union { long one; char little; } is_endian = {1};
|
||||
for (;;) {
|
||||
const union {
|
||||
long one;
|
||||
char little;
|
||||
} is_endian = {
|
||||
1
|
||||
};
|
||||
|
||||
if (!is_endian.little && sizeof(SHA_LONG)==4 && ((size_t)p%4)==0)
|
||||
{
|
||||
const SHA_LONG *W=(const SHA_LONG *)data;
|
||||
if (!is_endian.little && sizeof(SHA_LONG) == 4
|
||||
&& ((size_t)p % 4) == 0) {
|
||||
const SHA_LONG *W = (const SHA_LONG *)data;
|
||||
|
||||
X( 0) = W[0]; X( 1) = W[ 1];
|
||||
BODY_00_15( 0,A,B,C,D,E,T,X( 0)); X( 2) = W[ 2];
|
||||
BODY_00_15( 1,T,A,B,C,D,E,X( 1)); X( 3) = W[ 3];
|
||||
BODY_00_15( 2,E,T,A,B,C,D,X( 2)); X( 4) = W[ 4];
|
||||
BODY_00_15( 3,D,E,T,A,B,C,X( 3)); X( 5) = W[ 5];
|
||||
BODY_00_15( 4,C,D,E,T,A,B,X( 4)); X( 6) = W[ 6];
|
||||
BODY_00_15( 5,B,C,D,E,T,A,X( 5)); X( 7) = W[ 7];
|
||||
BODY_00_15( 6,A,B,C,D,E,T,X( 6)); X( 8) = W[ 8];
|
||||
BODY_00_15( 7,T,A,B,C,D,E,X( 7)); X( 9) = W[ 9];
|
||||
BODY_00_15( 8,E,T,A,B,C,D,X( 8)); X(10) = W[10];
|
||||
BODY_00_15( 9,D,E,T,A,B,C,X( 9)); X(11) = W[11];
|
||||
BODY_00_15(10,C,D,E,T,A,B,X(10)); X(12) = W[12];
|
||||
BODY_00_15(11,B,C,D,E,T,A,X(11)); X(13) = W[13];
|
||||
BODY_00_15(12,A,B,C,D,E,T,X(12)); X(14) = W[14];
|
||||
BODY_00_15(13,T,A,B,C,D,E,X(13)); X(15) = W[15];
|
||||
BODY_00_15(14,E,T,A,B,C,D,X(14));
|
||||
BODY_00_15(15,D,E,T,A,B,C,X(15));
|
||||
X(0) = W[0];
|
||||
X(1) = W[1];
|
||||
BODY_00_15(0, A, B, C, D, E, T, X(0));
|
||||
X(2) = W[2];
|
||||
BODY_00_15(1, T, A, B, C, D, E, X(1));
|
||||
X(3) = W[3];
|
||||
BODY_00_15(2, E, T, A, B, C, D, X(2));
|
||||
X(4) = W[4];
|
||||
BODY_00_15(3, D, E, T, A, B, C, X(3));
|
||||
X(5) = W[5];
|
||||
BODY_00_15(4, C, D, E, T, A, B, X(4));
|
||||
X(6) = W[6];
|
||||
BODY_00_15(5, B, C, D, E, T, A, X(5));
|
||||
X(7) = W[7];
|
||||
BODY_00_15(6, A, B, C, D, E, T, X(6));
|
||||
X(8) = W[8];
|
||||
BODY_00_15(7, T, A, B, C, D, E, X(7));
|
||||
X(9) = W[9];
|
||||
BODY_00_15(8, E, T, A, B, C, D, X(8));
|
||||
X(10) = W[10];
|
||||
BODY_00_15(9, D, E, T, A, B, C, X(9));
|
||||
X(11) = W[11];
|
||||
BODY_00_15(10, C, D, E, T, A, B, X(10));
|
||||
X(12) = W[12];
|
||||
BODY_00_15(11, B, C, D, E, T, A, X(11));
|
||||
X(13) = W[13];
|
||||
BODY_00_15(12, A, B, C, D, E, T, X(12));
|
||||
X(14) = W[14];
|
||||
BODY_00_15(13, T, A, B, C, D, E, X(13));
|
||||
X(15) = W[15];
|
||||
BODY_00_15(14, E, T, A, B, C, D, X(14));
|
||||
BODY_00_15(15, D, E, T, A, B, C, X(15));
|
||||
|
||||
data += SHA_CBLOCK;
|
||||
}
|
||||
else
|
||||
{
|
||||
HOST_c2l(data,l); X( 0)=l; HOST_c2l(data,l); X( 1)=l;
|
||||
BODY_00_15( 0,A,B,C,D,E,T,X( 0)); HOST_c2l(data,l); X( 2)=l;
|
||||
BODY_00_15( 1,T,A,B,C,D,E,X( 1)); HOST_c2l(data,l); X( 3)=l;
|
||||
BODY_00_15( 2,E,T,A,B,C,D,X( 2)); HOST_c2l(data,l); X( 4)=l;
|
||||
BODY_00_15( 3,D,E,T,A,B,C,X( 3)); HOST_c2l(data,l); X( 5)=l;
|
||||
BODY_00_15( 4,C,D,E,T,A,B,X( 4)); HOST_c2l(data,l); X( 6)=l;
|
||||
BODY_00_15( 5,B,C,D,E,T,A,X( 5)); HOST_c2l(data,l); X( 7)=l;
|
||||
BODY_00_15( 6,A,B,C,D,E,T,X( 6)); HOST_c2l(data,l); X( 8)=l;
|
||||
BODY_00_15( 7,T,A,B,C,D,E,X( 7)); HOST_c2l(data,l); X( 9)=l;
|
||||
BODY_00_15( 8,E,T,A,B,C,D,X( 8)); HOST_c2l(data,l); X(10)=l;
|
||||
BODY_00_15( 9,D,E,T,A,B,C,X( 9)); HOST_c2l(data,l); X(11)=l;
|
||||
BODY_00_15(10,C,D,E,T,A,B,X(10)); HOST_c2l(data,l); X(12)=l;
|
||||
BODY_00_15(11,B,C,D,E,T,A,X(11)); HOST_c2l(data,l); X(13)=l;
|
||||
BODY_00_15(12,A,B,C,D,E,T,X(12)); HOST_c2l(data,l); X(14)=l;
|
||||
BODY_00_15(13,T,A,B,C,D,E,X(13)); HOST_c2l(data,l); X(15)=l;
|
||||
BODY_00_15(14,E,T,A,B,C,D,X(14));
|
||||
BODY_00_15(15,D,E,T,A,B,C,X(15));
|
||||
}
|
||||
data += SHA_CBLOCK;
|
||||
} else {
|
||||
(void)HOST_c2l(data, l);
|
||||
X(0) = l;
|
||||
(void)HOST_c2l(data, l);
|
||||
X(1) = l;
|
||||
BODY_00_15(0, A, B, C, D, E, T, X(0));
|
||||
(void)HOST_c2l(data, l);
|
||||
X(2) = l;
|
||||
BODY_00_15(1, T, A, B, C, D, E, X(1));
|
||||
(void)HOST_c2l(data, l);
|
||||
X(3) = l;
|
||||
BODY_00_15(2, E, T, A, B, C, D, X(2));
|
||||
(void)HOST_c2l(data, l);
|
||||
X(4) = l;
|
||||
BODY_00_15(3, D, E, T, A, B, C, X(3));
|
||||
(void)HOST_c2l(data, l);
|
||||
X(5) = l;
|
||||
BODY_00_15(4, C, D, E, T, A, B, X(4));
|
||||
(void)HOST_c2l(data, l);
|
||||
X(6) = l;
|
||||
BODY_00_15(5, B, C, D, E, T, A, X(5));
|
||||
(void)HOST_c2l(data, l);
|
||||
X(7) = l;
|
||||
BODY_00_15(6, A, B, C, D, E, T, X(6));
|
||||
(void)HOST_c2l(data, l);
|
||||
X(8) = l;
|
||||
BODY_00_15(7, T, A, B, C, D, E, X(7));
|
||||
(void)HOST_c2l(data, l);
|
||||
X(9) = l;
|
||||
BODY_00_15(8, E, T, A, B, C, D, X(8));
|
||||
(void)HOST_c2l(data, l);
|
||||
X(10) = l;
|
||||
BODY_00_15(9, D, E, T, A, B, C, X(9));
|
||||
(void)HOST_c2l(data, l);
|
||||
X(11) = l;
|
||||
BODY_00_15(10, C, D, E, T, A, B, X(10));
|
||||
(void)HOST_c2l(data, l);
|
||||
X(12) = l;
|
||||
BODY_00_15(11, B, C, D, E, T, A, X(11));
|
||||
(void)HOST_c2l(data, l);
|
||||
X(13) = l;
|
||||
BODY_00_15(12, A, B, C, D, E, T, X(12));
|
||||
(void)HOST_c2l(data, l);
|
||||
X(14) = l;
|
||||
BODY_00_15(13, T, A, B, C, D, E, X(13));
|
||||
(void)HOST_c2l(data, l);
|
||||
X(15) = l;
|
||||
BODY_00_15(14, E, T, A, B, C, D, X(14));
|
||||
BODY_00_15(15, D, E, T, A, B, C, X(15));
|
||||
}
|
||||
|
||||
BODY_16_19(16,C,D,E,T,A,B,X( 0),X( 0),X( 2),X( 8),X(13));
|
||||
BODY_16_19(17,B,C,D,E,T,A,X( 1),X( 1),X( 3),X( 9),X(14));
|
||||
BODY_16_19(18,A,B,C,D,E,T,X( 2),X( 2),X( 4),X(10),X(15));
|
||||
BODY_16_19(19,T,A,B,C,D,E,X( 3),X( 3),X( 5),X(11),X( 0));
|
||||
BODY_16_19(16, C, D, E, T, A, B, X(0), X(0), X(2), X(8), X(13));
|
||||
BODY_16_19(17, B, C, D, E, T, A, X(1), X(1), X(3), X(9), X(14));
|
||||
BODY_16_19(18, A, B, C, D, E, T, X(2), X(2), X(4), X(10), X(15));
|
||||
BODY_16_19(19, T, A, B, C, D, E, X(3), X(3), X(5), X(11), X(0));
|
||||
|
||||
BODY_20_31(20,E,T,A,B,C,D,X( 4),X( 4),X( 6),X(12),X( 1));
|
||||
BODY_20_31(21,D,E,T,A,B,C,X( 5),X( 5),X( 7),X(13),X( 2));
|
||||
BODY_20_31(22,C,D,E,T,A,B,X( 6),X( 6),X( 8),X(14),X( 3));
|
||||
BODY_20_31(23,B,C,D,E,T,A,X( 7),X( 7),X( 9),X(15),X( 4));
|
||||
BODY_20_31(24,A,B,C,D,E,T,X( 8),X( 8),X(10),X( 0),X( 5));
|
||||
BODY_20_31(25,T,A,B,C,D,E,X( 9),X( 9),X(11),X( 1),X( 6));
|
||||
BODY_20_31(26,E,T,A,B,C,D,X(10),X(10),X(12),X( 2),X( 7));
|
||||
BODY_20_31(27,D,E,T,A,B,C,X(11),X(11),X(13),X( 3),X( 8));
|
||||
BODY_20_31(28,C,D,E,T,A,B,X(12),X(12),X(14),X( 4),X( 9));
|
||||
BODY_20_31(29,B,C,D,E,T,A,X(13),X(13),X(15),X( 5),X(10));
|
||||
BODY_20_31(30,A,B,C,D,E,T,X(14),X(14),X( 0),X( 6),X(11));
|
||||
BODY_20_31(31,T,A,B,C,D,E,X(15),X(15),X( 1),X( 7),X(12));
|
||||
BODY_20_31(20, E, T, A, B, C, D, X(4), X(4), X(6), X(12), X(1));
|
||||
BODY_20_31(21, D, E, T, A, B, C, X(5), X(5), X(7), X(13), X(2));
|
||||
BODY_20_31(22, C, D, E, T, A, B, X(6), X(6), X(8), X(14), X(3));
|
||||
BODY_20_31(23, B, C, D, E, T, A, X(7), X(7), X(9), X(15), X(4));
|
||||
BODY_20_31(24, A, B, C, D, E, T, X(8), X(8), X(10), X(0), X(5));
|
||||
BODY_20_31(25, T, A, B, C, D, E, X(9), X(9), X(11), X(1), X(6));
|
||||
BODY_20_31(26, E, T, A, B, C, D, X(10), X(10), X(12), X(2), X(7));
|
||||
BODY_20_31(27, D, E, T, A, B, C, X(11), X(11), X(13), X(3), X(8));
|
||||
BODY_20_31(28, C, D, E, T, A, B, X(12), X(12), X(14), X(4), X(9));
|
||||
BODY_20_31(29, B, C, D, E, T, A, X(13), X(13), X(15), X(5), X(10));
|
||||
BODY_20_31(30, A, B, C, D, E, T, X(14), X(14), X(0), X(6), X(11));
|
||||
BODY_20_31(31, T, A, B, C, D, E, X(15), X(15), X(1), X(7), X(12));
|
||||
|
||||
BODY_32_39(32,E,T,A,B,C,D,X( 0),X( 2),X( 8),X(13));
|
||||
BODY_32_39(33,D,E,T,A,B,C,X( 1),X( 3),X( 9),X(14));
|
||||
BODY_32_39(34,C,D,E,T,A,B,X( 2),X( 4),X(10),X(15));
|
||||
BODY_32_39(35,B,C,D,E,T,A,X( 3),X( 5),X(11),X( 0));
|
||||
BODY_32_39(36,A,B,C,D,E,T,X( 4),X( 6),X(12),X( 1));
|
||||
BODY_32_39(37,T,A,B,C,D,E,X( 5),X( 7),X(13),X( 2));
|
||||
BODY_32_39(38,E,T,A,B,C,D,X( 6),X( 8),X(14),X( 3));
|
||||
BODY_32_39(39,D,E,T,A,B,C,X( 7),X( 9),X(15),X( 4));
|
||||
BODY_32_39(32, E, T, A, B, C, D, X(0), X(2), X(8), X(13));
|
||||
BODY_32_39(33, D, E, T, A, B, C, X(1), X(3), X(9), X(14));
|
||||
BODY_32_39(34, C, D, E, T, A, B, X(2), X(4), X(10), X(15));
|
||||
BODY_32_39(35, B, C, D, E, T, A, X(3), X(5), X(11), X(0));
|
||||
BODY_32_39(36, A, B, C, D, E, T, X(4), X(6), X(12), X(1));
|
||||
BODY_32_39(37, T, A, B, C, D, E, X(5), X(7), X(13), X(2));
|
||||
BODY_32_39(38, E, T, A, B, C, D, X(6), X(8), X(14), X(3));
|
||||
BODY_32_39(39, D, E, T, A, B, C, X(7), X(9), X(15), X(4));
|
||||
|
||||
BODY_40_59(40,C,D,E,T,A,B,X( 8),X(10),X( 0),X( 5));
|
||||
BODY_40_59(41,B,C,D,E,T,A,X( 9),X(11),X( 1),X( 6));
|
||||
BODY_40_59(42,A,B,C,D,E,T,X(10),X(12),X( 2),X( 7));
|
||||
BODY_40_59(43,T,A,B,C,D,E,X(11),X(13),X( 3),X( 8));
|
||||
BODY_40_59(44,E,T,A,B,C,D,X(12),X(14),X( 4),X( 9));
|
||||
BODY_40_59(45,D,E,T,A,B,C,X(13),X(15),X( 5),X(10));
|
||||
BODY_40_59(46,C,D,E,T,A,B,X(14),X( 0),X( 6),X(11));
|
||||
BODY_40_59(47,B,C,D,E,T,A,X(15),X( 1),X( 7),X(12));
|
||||
BODY_40_59(48,A,B,C,D,E,T,X( 0),X( 2),X( 8),X(13));
|
||||
BODY_40_59(49,T,A,B,C,D,E,X( 1),X( 3),X( 9),X(14));
|
||||
BODY_40_59(50,E,T,A,B,C,D,X( 2),X( 4),X(10),X(15));
|
||||
BODY_40_59(51,D,E,T,A,B,C,X( 3),X( 5),X(11),X( 0));
|
||||
BODY_40_59(52,C,D,E,T,A,B,X( 4),X( 6),X(12),X( 1));
|
||||
BODY_40_59(53,B,C,D,E,T,A,X( 5),X( 7),X(13),X( 2));
|
||||
BODY_40_59(54,A,B,C,D,E,T,X( 6),X( 8),X(14),X( 3));
|
||||
BODY_40_59(55,T,A,B,C,D,E,X( 7),X( 9),X(15),X( 4));
|
||||
BODY_40_59(56,E,T,A,B,C,D,X( 8),X(10),X( 0),X( 5));
|
||||
BODY_40_59(57,D,E,T,A,B,C,X( 9),X(11),X( 1),X( 6));
|
||||
BODY_40_59(58,C,D,E,T,A,B,X(10),X(12),X( 2),X( 7));
|
||||
BODY_40_59(59,B,C,D,E,T,A,X(11),X(13),X( 3),X( 8));
|
||||
BODY_40_59(40, C, D, E, T, A, B, X(8), X(10), X(0), X(5));
|
||||
BODY_40_59(41, B, C, D, E, T, A, X(9), X(11), X(1), X(6));
|
||||
BODY_40_59(42, A, B, C, D, E, T, X(10), X(12), X(2), X(7));
|
||||
BODY_40_59(43, T, A, B, C, D, E, X(11), X(13), X(3), X(8));
|
||||
BODY_40_59(44, E, T, A, B, C, D, X(12), X(14), X(4), X(9));
|
||||
BODY_40_59(45, D, E, T, A, B, C, X(13), X(15), X(5), X(10));
|
||||
BODY_40_59(46, C, D, E, T, A, B, X(14), X(0), X(6), X(11));
|
||||
BODY_40_59(47, B, C, D, E, T, A, X(15), X(1), X(7), X(12));
|
||||
BODY_40_59(48, A, B, C, D, E, T, X(0), X(2), X(8), X(13));
|
||||
BODY_40_59(49, T, A, B, C, D, E, X(1), X(3), X(9), X(14));
|
||||
BODY_40_59(50, E, T, A, B, C, D, X(2), X(4), X(10), X(15));
|
||||
BODY_40_59(51, D, E, T, A, B, C, X(3), X(5), X(11), X(0));
|
||||
BODY_40_59(52, C, D, E, T, A, B, X(4), X(6), X(12), X(1));
|
||||
BODY_40_59(53, B, C, D, E, T, A, X(5), X(7), X(13), X(2));
|
||||
BODY_40_59(54, A, B, C, D, E, T, X(6), X(8), X(14), X(3));
|
||||
BODY_40_59(55, T, A, B, C, D, E, X(7), X(9), X(15), X(4));
|
||||
BODY_40_59(56, E, T, A, B, C, D, X(8), X(10), X(0), X(5));
|
||||
BODY_40_59(57, D, E, T, A, B, C, X(9), X(11), X(1), X(6));
|
||||
BODY_40_59(58, C, D, E, T, A, B, X(10), X(12), X(2), X(7));
|
||||
BODY_40_59(59, B, C, D, E, T, A, X(11), X(13), X(3), X(8));
|
||||
|
||||
BODY_60_79(60,A,B,C,D,E,T,X(12),X(14),X( 4),X( 9));
|
||||
BODY_60_79(61,T,A,B,C,D,E,X(13),X(15),X( 5),X(10));
|
||||
BODY_60_79(62,E,T,A,B,C,D,X(14),X( 0),X( 6),X(11));
|
||||
BODY_60_79(63,D,E,T,A,B,C,X(15),X( 1),X( 7),X(12));
|
||||
BODY_60_79(64,C,D,E,T,A,B,X( 0),X( 2),X( 8),X(13));
|
||||
BODY_60_79(65,B,C,D,E,T,A,X( 1),X( 3),X( 9),X(14));
|
||||
BODY_60_79(66,A,B,C,D,E,T,X( 2),X( 4),X(10),X(15));
|
||||
BODY_60_79(67,T,A,B,C,D,E,X( 3),X( 5),X(11),X( 0));
|
||||
BODY_60_79(68,E,T,A,B,C,D,X( 4),X( 6),X(12),X( 1));
|
||||
BODY_60_79(69,D,E,T,A,B,C,X( 5),X( 7),X(13),X( 2));
|
||||
BODY_60_79(70,C,D,E,T,A,B,X( 6),X( 8),X(14),X( 3));
|
||||
BODY_60_79(71,B,C,D,E,T,A,X( 7),X( 9),X(15),X( 4));
|
||||
BODY_60_79(72,A,B,C,D,E,T,X( 8),X(10),X( 0),X( 5));
|
||||
BODY_60_79(73,T,A,B,C,D,E,X( 9),X(11),X( 1),X( 6));
|
||||
BODY_60_79(74,E,T,A,B,C,D,X(10),X(12),X( 2),X( 7));
|
||||
BODY_60_79(75,D,E,T,A,B,C,X(11),X(13),X( 3),X( 8));
|
||||
BODY_60_79(76,C,D,E,T,A,B,X(12),X(14),X( 4),X( 9));
|
||||
BODY_60_79(77,B,C,D,E,T,A,X(13),X(15),X( 5),X(10));
|
||||
BODY_60_79(78,A,B,C,D,E,T,X(14),X( 0),X( 6),X(11));
|
||||
BODY_60_79(79,T,A,B,C,D,E,X(15),X( 1),X( 7),X(12));
|
||||
|
||||
c->h0=(c->h0+E)&0xffffffffL;
|
||||
c->h1=(c->h1+T)&0xffffffffL;
|
||||
c->h2=(c->h2+A)&0xffffffffL;
|
||||
c->h3=(c->h3+B)&0xffffffffL;
|
||||
c->h4=(c->h4+C)&0xffffffffL;
|
||||
BODY_60_79(60, A, B, C, D, E, T, X(12), X(14), X(4), X(9));
|
||||
BODY_60_79(61, T, A, B, C, D, E, X(13), X(15), X(5), X(10));
|
||||
BODY_60_79(62, E, T, A, B, C, D, X(14), X(0), X(6), X(11));
|
||||
BODY_60_79(63, D, E, T, A, B, C, X(15), X(1), X(7), X(12));
|
||||
BODY_60_79(64, C, D, E, T, A, B, X(0), X(2), X(8), X(13));
|
||||
BODY_60_79(65, B, C, D, E, T, A, X(1), X(3), X(9), X(14));
|
||||
BODY_60_79(66, A, B, C, D, E, T, X(2), X(4), X(10), X(15));
|
||||
BODY_60_79(67, T, A, B, C, D, E, X(3), X(5), X(11), X(0));
|
||||
BODY_60_79(68, E, T, A, B, C, D, X(4), X(6), X(12), X(1));
|
||||
BODY_60_79(69, D, E, T, A, B, C, X(5), X(7), X(13), X(2));
|
||||
BODY_60_79(70, C, D, E, T, A, B, X(6), X(8), X(14), X(3));
|
||||
BODY_60_79(71, B, C, D, E, T, A, X(7), X(9), X(15), X(4));
|
||||
BODY_60_79(72, A, B, C, D, E, T, X(8), X(10), X(0), X(5));
|
||||
BODY_60_79(73, T, A, B, C, D, E, X(9), X(11), X(1), X(6));
|
||||
BODY_60_79(74, E, T, A, B, C, D, X(10), X(12), X(2), X(7));
|
||||
BODY_60_79(75, D, E, T, A, B, C, X(11), X(13), X(3), X(8));
|
||||
BODY_60_79(76, C, D, E, T, A, B, X(12), X(14), X(4), X(9));
|
||||
BODY_60_79(77, B, C, D, E, T, A, X(13), X(15), X(5), X(10));
|
||||
BODY_60_79(78, A, B, C, D, E, T, X(14), X(0), X(6), X(11));
|
||||
BODY_60_79(79, T, A, B, C, D, E, X(15), X(1), X(7), X(12));
|
||||
|
||||
if (--num == 0) break;
|
||||
c->h0 = (c->h0 + E) & 0xffffffffL;
|
||||
c->h1 = (c->h1 + T) & 0xffffffffL;
|
||||
c->h2 = (c->h2 + A) & 0xffffffffL;
|
||||
c->h3 = (c->h3 + B) & 0xffffffffL;
|
||||
c->h4 = (c->h4 + C) & 0xffffffffL;
|
||||
|
||||
A=c->h0;
|
||||
B=c->h1;
|
||||
C=c->h2;
|
||||
D=c->h3;
|
||||
E=c->h4;
|
||||
if (--num == 0)
|
||||
break;
|
||||
|
||||
}
|
||||
}
|
||||
#endif
|
||||
A = c->h0;
|
||||
B = c->h1;
|
||||
C = c->h2;
|
||||
D = c->h3;
|
||||
E = c->h4;
|
||||
|
||||
#else /* OPENSSL_SMALL_FOOTPRINT */
|
||||
}
|
||||
}
|
||||
# endif
|
||||
|
||||
#define BODY_00_15(xi) do { \
|
||||
T=E+K_00_19+F_00_19(B,C,D); \
|
||||
E=D, D=C, C=ROTATE(B,30), B=A; \
|
||||
A=ROTATE(A,5)+T+xi; } while(0)
|
||||
#else /* OPENSSL_SMALL_FOOTPRINT */
|
||||
|
||||
#define BODY_16_19(xa,xb,xc,xd) do { \
|
||||
Xupdate(T,xa,xa,xb,xc,xd); \
|
||||
T+=E+K_00_19+F_00_19(B,C,D); \
|
||||
E=D, D=C, C=ROTATE(B,30), B=A; \
|
||||
A=ROTATE(A,5)+T; } while(0)
|
||||
# define BODY_00_15(xi) do { \
|
||||
T=E+K_00_19+F_00_19(B,C,D); \
|
||||
E=D, D=C, C=ROTATE(B,30), B=A; \
|
||||
A=ROTATE(A,5)+T+xi; } while(0)
|
||||
|
||||
#define BODY_20_39(xa,xb,xc,xd) do { \
|
||||
Xupdate(T,xa,xa,xb,xc,xd); \
|
||||
T+=E+K_20_39+F_20_39(B,C,D); \
|
||||
E=D, D=C, C=ROTATE(B,30), B=A; \
|
||||
A=ROTATE(A,5)+T; } while(0)
|
||||
# define BODY_16_19(xa,xb,xc,xd) do { \
|
||||
Xupdate(T,xa,xa,xb,xc,xd); \
|
||||
T+=E+K_00_19+F_00_19(B,C,D); \
|
||||
E=D, D=C, C=ROTATE(B,30), B=A; \
|
||||
A=ROTATE(A,5)+T; } while(0)
|
||||
|
||||
#define BODY_40_59(xa,xb,xc,xd) do { \
|
||||
Xupdate(T,xa,xa,xb,xc,xd); \
|
||||
T+=E+K_40_59+F_40_59(B,C,D); \
|
||||
E=D, D=C, C=ROTATE(B,30), B=A; \
|
||||
A=ROTATE(A,5)+T; } while(0)
|
||||
# define BODY_20_39(xa,xb,xc,xd) do { \
|
||||
Xupdate(T,xa,xa,xb,xc,xd); \
|
||||
T+=E+K_20_39+F_20_39(B,C,D); \
|
||||
E=D, D=C, C=ROTATE(B,30), B=A; \
|
||||
A=ROTATE(A,5)+T; } while(0)
|
||||
|
||||
#define BODY_60_79(xa,xb,xc,xd) do { \
|
||||
Xupdate(T,xa,xa,xb,xc,xd); \
|
||||
T=E+K_60_79+F_60_79(B,C,D); \
|
||||
E=D, D=C, C=ROTATE(B,30), B=A; \
|
||||
A=ROTATE(A,5)+T+xa; } while(0)
|
||||
# define BODY_40_59(xa,xb,xc,xd) do { \
|
||||
Xupdate(T,xa,xa,xb,xc,xd); \
|
||||
T+=E+K_40_59+F_40_59(B,C,D); \
|
||||
E=D, D=C, C=ROTATE(B,30), B=A; \
|
||||
A=ROTATE(A,5)+T; } while(0)
|
||||
|
||||
#if !defined(SHA_1) || !defined(SHA1_ASM)
|
||||
static void HASH_BLOCK_DATA_ORDER (SHA_CTX *c, const void *p, size_t num)
|
||||
{
|
||||
const unsigned char *data=p;
|
||||
register unsigned MD32_REG_T A,B,C,D,E,T,l;
|
||||
int i;
|
||||
SHA_LONG X[16];
|
||||
# define BODY_60_79(xa,xb,xc,xd) do { \
|
||||
Xupdate(T,xa,xa,xb,xc,xd); \
|
||||
T=E+K_60_79+F_60_79(B,C,D); \
|
||||
E=D, D=C, C=ROTATE(B,30), B=A; \
|
||||
A=ROTATE(A,5)+T+xa; } while(0)
|
||||
|
||||
A=c->h0;
|
||||
B=c->h1;
|
||||
C=c->h2;
|
||||
D=c->h3;
|
||||
E=c->h4;
|
||||
# if !defined(SHA_1) || !defined(SHA1_ASM)
|
||||
static void HASH_BLOCK_DATA_ORDER(SHA_CTX *c, const void *p, size_t num)
|
||||
{
|
||||
const unsigned char *data = p;
|
||||
register unsigned MD32_REG_T A, B, C, D, E, T, l;
|
||||
int i;
|
||||
SHA_LONG X[16];
|
||||
|
||||
for (;;)
|
||||
{
|
||||
for (i=0;i<16;i++)
|
||||
{ HOST_c2l(data,l); X[i]=l; BODY_00_15(X[i]); }
|
||||
for (i=0;i<4;i++)
|
||||
{ BODY_16_19(X[i], X[i+2], X[i+8], X[(i+13)&15]); }
|
||||
for (;i<24;i++)
|
||||
{ BODY_20_39(X[i&15], X[(i+2)&15], X[(i+8)&15],X[(i+13)&15]); }
|
||||
for (i=0;i<20;i++)
|
||||
{ BODY_40_59(X[(i+8)&15],X[(i+10)&15],X[i&15], X[(i+5)&15]); }
|
||||
for (i=4;i<24;i++)
|
||||
{ BODY_60_79(X[(i+8)&15],X[(i+10)&15],X[i&15], X[(i+5)&15]); }
|
||||
A = c->h0;
|
||||
B = c->h1;
|
||||
C = c->h2;
|
||||
D = c->h3;
|
||||
E = c->h4;
|
||||
|
||||
c->h0=(c->h0+A)&0xffffffffL;
|
||||
c->h1=(c->h1+B)&0xffffffffL;
|
||||
c->h2=(c->h2+C)&0xffffffffL;
|
||||
c->h3=(c->h3+D)&0xffffffffL;
|
||||
c->h4=(c->h4+E)&0xffffffffL;
|
||||
for (;;) {
|
||||
for (i = 0; i < 16; i++) {
|
||||
HOST_c2l(data, l);
|
||||
X[i] = l;
|
||||
BODY_00_15(X[i]);
|
||||
}
|
||||
for (i = 0; i < 4; i++) {
|
||||
BODY_16_19(X[i], X[i + 2], X[i + 8], X[(i + 13) & 15]);
|
||||
}
|
||||
for (; i < 24; i++) {
|
||||
BODY_20_39(X[i & 15], X[(i + 2) & 15], X[(i + 8) & 15],
|
||||
X[(i + 13) & 15]);
|
||||
}
|
||||
for (i = 0; i < 20; i++) {
|
||||
BODY_40_59(X[(i + 8) & 15], X[(i + 10) & 15], X[i & 15],
|
||||
X[(i + 5) & 15]);
|
||||
}
|
||||
for (i = 4; i < 24; i++) {
|
||||
BODY_60_79(X[(i + 8) & 15], X[(i + 10) & 15], X[i & 15],
|
||||
X[(i + 5) & 15]);
|
||||
}
|
||||
|
||||
if (--num == 0) break;
|
||||
c->h0 = (c->h0 + A) & 0xffffffffL;
|
||||
c->h1 = (c->h1 + B) & 0xffffffffL;
|
||||
c->h2 = (c->h2 + C) & 0xffffffffL;
|
||||
c->h3 = (c->h3 + D) & 0xffffffffL;
|
||||
c->h4 = (c->h4 + E) & 0xffffffffL;
|
||||
|
||||
A=c->h0;
|
||||
B=c->h1;
|
||||
C=c->h2;
|
||||
D=c->h3;
|
||||
E=c->h4;
|
||||
if (--num == 0)
|
||||
break;
|
||||
|
||||
}
|
||||
}
|
||||
#endif
|
||||
A = c->h0;
|
||||
B = c->h1;
|
||||
C = c->h2;
|
||||
D = c->h3;
|
||||
E = c->h4;
|
||||
|
||||
}
|
||||
}
|
||||
# endif
|
||||
|
||||
#endif
|
||||
|
||||
@@ -5,21 +5,21 @@
|
||||
* This package is an SSL implementation written
|
||||
* by Eric Young (eay@cryptsoft.com).
|
||||
* The implementation was written so as to conform with Netscapes SSL.
|
||||
*
|
||||
*
|
||||
* This library is free for commercial and non-commercial use as long as
|
||||
* the following conditions are aheared to. The following conditions
|
||||
* apply to all code found in this distribution, be it the RC4, RSA,
|
||||
* lhash, DES, etc., code; not just the SSL code. The SSL documentation
|
||||
* included with this distribution is covered by the same copyright terms
|
||||
* except that the holder is Tim Hudson (tjh@cryptsoft.com).
|
||||
*
|
||||
*
|
||||
* Copyright remains Eric Young's, and as such any Copyright notices in
|
||||
* the code are not to be removed.
|
||||
* If this package is used in a product, Eric Young should be given attribution
|
||||
* as the author of the parts of the library used.
|
||||
* This can be in the form of a textual message at program startup or
|
||||
* in documentation (online or textual) provided with the package.
|
||||
*
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
@@ -34,10 +34,10 @@
|
||||
* Eric Young (eay@cryptsoft.com)"
|
||||
* The word 'cryptographic' can be left out if the rouines from the library
|
||||
* being used are not cryptographic related :-).
|
||||
* 4. If you include any Windows specific code (or a derivative thereof) from
|
||||
* 4. If you include any Windows specific code (or a derivative thereof) from
|
||||
* the apps directory (application code) you must include an acknowledgement:
|
||||
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
|
||||
*
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
@@ -49,7 +49,7 @@
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*
|
||||
*
|
||||
* The licence and distribution terms for any publically available version or
|
||||
* derivative of this code cannot be changed. i.e. this code cannot simply be
|
||||
* copied and put under another distribution licence
|
||||
@@ -63,16 +63,17 @@
|
||||
|
||||
#ifndef OPENSSL_NO_SHA0
|
||||
unsigned char *SHA(const unsigned char *d, size_t n, unsigned char *md)
|
||||
{
|
||||
SHA_CTX c;
|
||||
static unsigned char m[SHA_DIGEST_LENGTH];
|
||||
{
|
||||
SHA_CTX c;
|
||||
static unsigned char m[SHA_DIGEST_LENGTH];
|
||||
|
||||
if (md == NULL) md=m;
|
||||
if (!SHA_Init(&c))
|
||||
return NULL;
|
||||
SHA_Update(&c,d,n);
|
||||
SHA_Final(md,&c);
|
||||
OPENSSL_cleanse(&c,sizeof(c));
|
||||
return(md);
|
||||
}
|
||||
if (md == NULL)
|
||||
md = m;
|
||||
if (!SHA_Init(&c))
|
||||
return NULL;
|
||||
SHA_Update(&c, d, n);
|
||||
SHA_Final(md, &c);
|
||||
OPENSSL_cleanse(&c, sizeof(c));
|
||||
return (md);
|
||||
}
|
||||
#endif
|
||||
|
||||
Binary file not shown.
@@ -5,21 +5,21 @@
|
||||
* This package is an SSL implementation written
|
||||
* by Eric Young (eay@cryptsoft.com).
|
||||
* The implementation was written so as to conform with Netscapes SSL.
|
||||
*
|
||||
*
|
||||
* This library is free for commercial and non-commercial use as long as
|
||||
* the following conditions are aheared to. The following conditions
|
||||
* apply to all code found in this distribution, be it the RC4, RSA,
|
||||
* lhash, DES, etc., code; not just the SSL code. The SSL documentation
|
||||
* included with this distribution is covered by the same copyright terms
|
||||
* except that the holder is Tim Hudson (tjh@cryptsoft.com).
|
||||
*
|
||||
*
|
||||
* Copyright remains Eric Young's, and as such any Copyright notices in
|
||||
* the code are not to be removed.
|
||||
* If this package is used in a product, Eric Young should be given attribution
|
||||
* as the author of the parts of the library used.
|
||||
* This can be in the form of a textual message at program startup or
|
||||
* in documentation (online or textual) provided with the package.
|
||||
*
|
||||
*
|
||||
* Redistribution and use in source and binary forms, with or without
|
||||
* modification, are permitted provided that the following conditions
|
||||
* are met:
|
||||
@@ -34,10 +34,10 @@
|
||||
* Eric Young (eay@cryptsoft.com)"
|
||||
* The word 'cryptographic' can be left out if the rouines from the library
|
||||
* being used are not cryptographic related :-).
|
||||
* 4. If you include any Windows specific code (or a derivative thereof) from
|
||||
* 4. If you include any Windows specific code (or a derivative thereof) from
|
||||
* the apps directory (application code) you must include an acknowledgement:
|
||||
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
|
||||
*
|
||||
*
|
||||
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
|
||||
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
@@ -49,7 +49,7 @@
|
||||
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
||||
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
||||
* SUCH DAMAGE.
|
||||
*
|
||||
*
|
||||
* The licence and distribution terms for any publically available version or
|
||||
* derivative of this code cannot be changed. i.e. this code cannot simply be
|
||||
* copied and put under another distribution licence
|
||||
@@ -66,113 +66,109 @@
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
printf("No SHA0 support\n");
|
||||
return(0);
|
||||
return (0);
|
||||
}
|
||||
#else
|
||||
#include <openssl/evp.h>
|
||||
#include <openssl/sha.h>
|
||||
# include <openssl/evp.h>
|
||||
# include <openssl/sha.h>
|
||||
|
||||
#ifdef CHARSET_EBCDIC
|
||||
#include <openssl/ebcdic.h>
|
||||
#endif
|
||||
# ifdef CHARSET_EBCDIC
|
||||
# include <openssl/ebcdic.h>
|
||||
# endif
|
||||
|
||||
#define SHA_0 /* FIPS 180 */
|
||||
#undef SHA_1 /* FIPS 180-1 */
|
||||
# define SHA_0 /* FIPS 180 */
|
||||
# undef SHA_1 /* FIPS 180-1 */
|
||||
|
||||
static char *test[]={
|
||||
"abc",
|
||||
"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
|
||||
NULL,
|
||||
};
|
||||
static char *test[] = {
|
||||
"abc",
|
||||
"abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq",
|
||||
NULL,
|
||||
};
|
||||
|
||||
#ifdef SHA_0
|
||||
static char *ret[]={
|
||||
"0164b8a914cd2a5e74c4f7ff082c4d97f1edf880",
|
||||
"d2516ee1acfa5baf33dfc1c471e438449ef134c8",
|
||||
};
|
||||
static char *bigret=
|
||||
"3232affa48628a26653b5aaa44541fd90d690603";
|
||||
#endif
|
||||
#ifdef SHA_1
|
||||
static char *ret[]={
|
||||
"a9993e364706816aba3e25717850c26c9cd0d89d",
|
||||
"84983e441c3bd26ebaae4aa1f95129e5e54670f1",
|
||||
};
|
||||
static char *bigret=
|
||||
"34aa973cd4c4daa4f61eeb2bdbad27316534016f";
|
||||
#endif
|
||||
# ifdef SHA_0
|
||||
static char *ret[] = {
|
||||
"0164b8a914cd2a5e74c4f7ff082c4d97f1edf880",
|
||||
"d2516ee1acfa5baf33dfc1c471e438449ef134c8",
|
||||
};
|
||||
|
||||
static char *bigret = "3232affa48628a26653b5aaa44541fd90d690603";
|
||||
# endif
|
||||
# ifdef SHA_1
|
||||
static char *ret[] = {
|
||||
"a9993e364706816aba3e25717850c26c9cd0d89d",
|
||||
"84983e441c3bd26ebaae4aa1f95129e5e54670f1",
|
||||
};
|
||||
|
||||
static char *bigret = "34aa973cd4c4daa4f61eeb2bdbad27316534016f";
|
||||
# endif
|
||||
|
||||
static char *pt(unsigned char *md);
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
int i,err=0;
|
||||
char **P,**R;
|
||||
static unsigned char buf[1000];
|
||||
char *p,*r;
|
||||
EVP_MD_CTX c;
|
||||
unsigned char md[SHA_DIGEST_LENGTH];
|
||||
{
|
||||
int i, err = 0;
|
||||
char **P, **R;
|
||||
static unsigned char buf[1000];
|
||||
char *p, *r;
|
||||
EVP_MD_CTX c;
|
||||
unsigned char md[SHA_DIGEST_LENGTH];
|
||||
|
||||
#ifdef CHARSET_EBCDIC
|
||||
ebcdic2ascii(test[0], test[0], strlen(test[0]));
|
||||
ebcdic2ascii(test[1], test[1], strlen(test[1]));
|
||||
#endif
|
||||
# ifdef CHARSET_EBCDIC
|
||||
ebcdic2ascii(test[0], test[0], strlen(test[0]));
|
||||
ebcdic2ascii(test[1], test[1], strlen(test[1]));
|
||||
# endif
|
||||
|
||||
EVP_MD_CTX_init(&c);
|
||||
P=test;
|
||||
R=ret;
|
||||
i=1;
|
||||
while (*P != NULL)
|
||||
{
|
||||
EVP_Digest(*P,strlen(*P),md,NULL,EVP_sha(), NULL);
|
||||
p=pt(md);
|
||||
if (strcmp(p,*R) != 0)
|
||||
{
|
||||
printf("error calculating SHA on '%s'\n",*P);
|
||||
printf("got %s instead of %s\n",p,*R);
|
||||
err++;
|
||||
}
|
||||
else
|
||||
printf("test %d ok\n",i);
|
||||
i++;
|
||||
R++;
|
||||
P++;
|
||||
}
|
||||
EVP_MD_CTX_init(&c);
|
||||
P = test;
|
||||
R = ret;
|
||||
i = 1;
|
||||
while (*P != NULL) {
|
||||
EVP_Digest(*P, strlen(*P), md, NULL, EVP_sha(), NULL);
|
||||
p = pt(md);
|
||||
if (strcmp(p, *R) != 0) {
|
||||
printf("error calculating SHA on '%s'\n", *P);
|
||||
printf("got %s instead of %s\n", p, *R);
|
||||
err++;
|
||||
} else
|
||||
printf("test %d ok\n", i);
|
||||
i++;
|
||||
R++;
|
||||
P++;
|
||||
}
|
||||
|
||||
memset(buf,'a',1000);
|
||||
#ifdef CHARSET_EBCDIC
|
||||
ebcdic2ascii(buf, buf, 1000);
|
||||
#endif /*CHARSET_EBCDIC*/
|
||||
EVP_DigestInit_ex(&c,EVP_sha(), NULL);
|
||||
for (i=0; i<1000; i++)
|
||||
EVP_DigestUpdate(&c,buf,1000);
|
||||
EVP_DigestFinal_ex(&c,md,NULL);
|
||||
p=pt(md);
|
||||
memset(buf, 'a', 1000);
|
||||
# ifdef CHARSET_EBCDIC
|
||||
ebcdic2ascii(buf, buf, 1000);
|
||||
# endif /* CHARSET_EBCDIC */
|
||||
EVP_DigestInit_ex(&c, EVP_sha(), NULL);
|
||||
for (i = 0; i < 1000; i++)
|
||||
EVP_DigestUpdate(&c, buf, 1000);
|
||||
EVP_DigestFinal_ex(&c, md, NULL);
|
||||
p = pt(md);
|
||||
|
||||
r=bigret;
|
||||
if (strcmp(p,r) != 0)
|
||||
{
|
||||
printf("error calculating SHA on '%s'\n",p);
|
||||
printf("got %s instead of %s\n",p,r);
|
||||
err++;
|
||||
}
|
||||
else
|
||||
printf("test 3 ok\n");
|
||||
r = bigret;
|
||||
if (strcmp(p, r) != 0) {
|
||||
printf("error calculating SHA on '%s'\n", p);
|
||||
printf("got %s instead of %s\n", p, r);
|
||||
err++;
|
||||
} else
|
||||
printf("test 3 ok\n");
|
||||
|
||||
#ifdef OPENSSL_SYS_NETWARE
|
||||
if (err) printf("ERROR: %d\n", err);
|
||||
#endif
|
||||
EVP_MD_CTX_cleanup(&c);
|
||||
EXIT(err);
|
||||
return(0);
|
||||
}
|
||||
# ifdef OPENSSL_SYS_NETWARE
|
||||
if (err)
|
||||
printf("ERROR: %d\n", err);
|
||||
# endif
|
||||
EVP_MD_CTX_cleanup(&c);
|
||||
EXIT(err);
|
||||
return (0);
|
||||
}
|
||||
|
||||
static char *pt(unsigned char *md)
|
||||
{
|
||||
int i;
|
||||
static char buf[80];
|
||||
{
|
||||
int i;
|
||||
static char buf[80];
|
||||
|
||||
for (i=0; i<SHA_DIGEST_LENGTH; i++)
|
||||
sprintf(&(buf[i*2]),"%02x",md[i]);
|
||||
return(buf);
|
||||
}
|
||||
for (i = 0; i < SHA_DIGEST_LENGTH; i++)
|
||||
sprintf(&(buf[i * 2]), "%02x", md[i]);
|
||||
return (buf);
|
||||
}
|
||||
#endif
|
||||
|
||||
Reference in New Issue
Block a user