X-Git-Url: https://git.openssl.org/?p=openssl.git;a=blobdiff_plain;f=crypto%2Frc4%2Fasm%2Frc4-amd64.pl;h=2d3dedde0351131848dd48a1287dae67e21877a0;hp=767a4018fc55ec0d161af86873b822338263b72b;hb=81ee80ab88941658d7d427c76e1a6c94debfb4a3;hpb=e4528e48e37a7caa3c8cc825f8e92eb0518e8402

diff --git a/crypto/rc4/asm/rc4-amd64.pl b/crypto/rc4/asm/rc4-amd64.pl
index 767a4018fc..2d3dedde03 100755
--- a/crypto/rc4/asm/rc4-amd64.pl
+++ b/crypto/rc4/asm/rc4-amd64.pl
@@ -13,18 +13,34 @@
 # Presumably it has everything to do with AMD cache architecture and
 # RAW or whatever penalties. Once again! The module *requires* config
 # line *without* RC4_CHAR! As for coding "secret," I bet on partial
-# register arithmetics. For example instead 'inc %r8; and $255,%r8'
+# register arithmetics. For example instead of 'inc %r8; and $255,%r8'
 # I simply 'inc %r8b'. Even though optimization manual discourages
 # to operate on partial registers, it turned out to be the best bet.
 # At least for AMD... How IA32E would perform remains to be seen...
 
+# As was shown by Marc Bevand reordering of couple of load operations
+# results in even higher performance gain of 3.3x:-) At least on
+# Opteron... For reference, 1x in this case is RC4_CHAR C-code
+# compiled with gcc 3.3.2, which performs at ~54MBps per 1GHz clock.
+# Latter means that if you want to *estimate* what to expect from
+# *your* CPU, then multiply 54 by 3.3 and clock frequency in GHz.
+
+# Intel P4 EM64T core was found to run the AMD64 code really slow...
+# The only way to achieve comparable performance on P4 is to keep
+# RC4_CHAR. Kind of ironic, huh? As it's apparently impossible to
+# compose blended code, which would perform even within 30% marginal
+# on either AMD and Intel platforms, I implement both cases. See
+# rc4_skey.c for further details... This applies to 0.9.8 and later.
+# In 0.9.7 context RC4_CHAR codepath is never engaged and ~70 bytes
+# of code remain redundant.
+
 $output=shift;
 
-$win64=1 if ($output =~ /win64.[s|asm]/);
+$win64a=1 if ($output =~ /win64a.[s|asm]/);
 
 open STDOUT,">$output" || die "can't open $output: $!";
 
-if (defined($win64)) {
+if (defined($win64a)) {
     $dat="%rcx";	# arg1
     $len="%rdx";	# arg2
     $inp="%rsi";	# r8, arg3 moves here
@@ -43,8 +59,9 @@ $TY="%r9";
 
 sub PTR() {
     my $ret=shift;
-    if (defined($win64)) {
-	$ret =~ s/\[([\S]+)\+([\S]+)\]/[$2+$1]/g; # [%rN+%rM*4]->[%rM*4+%rN]
+    if (defined($win64a)) {
+	$ret =~ s/\[([\S]+)\+([\S]+)\]/[$2+$1]/g;   # [%rN+%rM*4]->[%rM*4+%rN]
+	$ret =~ s/:([^\[]+)\[([^\]]+)\]/:[$2+$1]/g; # :off[ea]->:[ea+off]
     } else {
 	$ret =~ s/[\+\*]/,/g;		# [%rN+%rM*4]->[%rN,%rM,4]
 	$ret =~ s/\[([^\]]+)\]/($1)/g;	# [%rN]->(%rN)
@@ -52,7 +69,7 @@ sub PTR() {
     $ret;
 }
 
-$code=<<___ if (!defined($win64));
+$code=<<___ if (!defined($win64a));
 .text
 
 .globl	RC4
@@ -60,130 +77,151 @@ $code=<<___ if (!defined($win64));
 .align	16
 RC4:	or	$len,$len
 	jne	.Lentry
-	.byte	0xF3,0xC3	# repz ret, 2-byte ret
+	repret
 .Lentry:
 ___
-$code=<<___ if (defined($win64));
-TEXT	SEGMENT
+$code=<<___ if (defined($win64a));
+_TEXT	SEGMENT
 PUBLIC	RC4
 ALIGN	16
-RC4	PROC NEAR
+RC4	PROC
 	or	$len,$len
 	jne	.Lentry
-	DB	F3h,C3h		; repz ret, 2-byte ret
+	repret
 .Lentry:
-	push	%edi
-	push	%esi
-	sub	\$40,%esp
+	push	%rdi
+	push	%rsi
+	sub	\$40,%rsp
 	mov	%r8,$inp
 	mov	%r9,$out
 ___
 $code.=<<___;
 	add	\$8,$dat
-	movl	`&PTR("DWORD-8[$dat]")`,$XX#d
-	movl	`&PTR("DWORD-4[$dat]")`,$YY#d
+	movl	`&PTR("DWORD:-8[$dat]")`,$XX#d
+	movl	`&PTR("DWORD:-4[$dat]")`,$YY#d
+	cmpl	\$-1,`&PTR("DWORD:256[$dat]")`
+	je	.LRC4_CHAR
 	test	\$-8,$len
 	jz	.Lloop1
 .align	16
 .Lloop8:
-	movq	`&PTR("QWORD[$inp]")`,%rax
-
 	inc	$XX#b
-	movl	`&PTR("DWORD[$dat+$XX*4]")`,$TX#d
+	movl	`&PTR("DWORD:[$dat+$XX*4]")`,$TX#d
 	add	$TX#b,$YY#b
-	movl	`&PTR("DWORD[$dat+$YY*4]")`,$TY#d
-	movl	$TX#d,`&PTR("DWORD[$dat+$YY*4]")`
-	movl	$TY#d,`&PTR("DWORD[$dat+$XX*4]")`
-	add	$TY#b,$TX#b
+	movl	`&PTR("DWORD:[$dat+$YY*4]")`,$TY#d
+	movl	$TX#d,`&PTR("DWORD:[$dat+$YY*4]")`
+	movl	$TY#d,`&PTR("DWORD:[$dat+$XX*4]")`
+	add	$TX#b,$TY#b
 	inc	$XX#b
-	movl	`&PTR("DWORD[$dat+$TX*4]")`,$TY#d
-	xor	$TY,%rax
+	movl	`&PTR("DWORD:[$dat+$XX*4]")`,$TX#d
+	movb	`&PTR("BYTE:[$dat+$TY*4]")`,%al
 ___
 for ($i=1;$i<=6;$i++) {
 $code.=<<___;
-	movl	`&PTR("DWORD[$dat+$XX*4]")`,$TX#d
 	add	$TX#b,$YY#b
-	movl	`&PTR("DWORD[$dat+$YY*4]")`,$TY#d
-	movl	$TX#d,`&PTR("DWORD[$dat+$YY*4]")`
-	movl	$TY#d,`&PTR("DWORD[$dat+$XX*4]")`
-	add	$TY#b,$TX#b
-	movl	`&PTR("DWORD[$dat+$TX*4]")`,$TY#d
-	shl	\$`8*$i`,$TY
+	ror	\$8,%rax
+	movl	`&PTR("DWORD:[$dat+$YY*4]")`,$TY#d
+	movl	$TX#d,`&PTR("DWORD:[$dat+$YY*4]")`
+	movl	$TY#d,`&PTR("DWORD:[$dat+$XX*4]")`
+	add	$TX#b,$TY#b
 	inc	$XX#b
-	xor	$TY,%rax
+	movl	`&PTR("DWORD:[$dat+$XX*4]")`,$TX#d
+	movb	`&PTR("BYTE:[$dat+$TY*4]")`,%al
 ___
 }
 $code.=<<___;
-	movl	`&PTR("DWORD[$dat+$XX*4]")`,$TX#d
 	add	$TX#b,$YY#b
-	movl	`&PTR("DWORD[$dat+$YY*4]")`,$TY#d
-	movl	$TX#d,`&PTR("DWORD[$dat+$YY*4]")`
-	movl	$TY#d,`&PTR("DWORD[$dat+$XX*4]")`
+	ror	\$8,%rax
+	movl	`&PTR("DWORD:[$dat+$YY*4]")`,$TY#d
+	movl	$TX#d,`&PTR("DWORD:[$dat+$YY*4]")`
+	movl	$TY#d,`&PTR("DWORD:[$dat+$XX*4]")`
 	sub	\$8,$len
 	add	$TY#b,$TX#b
-	add	\$8,$out
-	movl	`&PTR("DWORD[$dat+$TX*4]")`,$TY#d
-	shl	\$56,$TY
+	movb	`&PTR("BYTE:[$dat+$TX*4]")`,%al
+	ror	\$8,%rax
 	add	\$8,$inp
-	xor	$TY,%rax
+	add	\$8,$out
 
-	mov	%rax,`&PTR("QWORD-8[$out]")`
+	xor	`&PTR("QWORD:-8[$inp]")`,%rax
+	mov	%rax,`&PTR("QWORD:-8[$out]")`
 
 	test	\$-8,$len
 	jnz	.Lloop8
 	cmp	\$0,$len
 	jne	.Lloop1
 .Lexit:
-	movl	$XX#d,`&PTR("DWORD-8[$dat]")`
-	movl	$YY#d,`&PTR("DWORD-4[$dat]")`
+	movl	$XX#d,`&PTR("DWORD:-8[$dat]")`
+	movl	$YY#d,`&PTR("DWORD:-4[$dat]")`
 ___
-$code.=<<___ if (defined($win64));
-	add	\$40,%esp
-	pop	%esi
-	pop	%edi
-	DB	F3h,C3h		; retz ret, 2-byte ret
-___
-$code.=<<___ if (!defined($win64));
-	.byte	0xF3,0xC3	# repz ret, 2-byte ret
+$code.=<<___ if (defined($win64a));
+	add	\$40,%rsp
+	pop	%rsi
+	pop	%rdi
 ___
 $code.=<<___;
+	repret
 .align	16
 .Lloop1:
-	movzb	`&PTR("BYTE[$inp]")`,%rax
+	movzb	`&PTR("BYTE:[$inp]")`,%eax
 	inc	$XX#b
-	nop
-	movl	`&PTR("DWORD[$dat+$XX*4]")`,$TX#d
+	movl	`&PTR("DWORD:[$dat+$XX*4]")`,$TX#d
 	add	$TX#b,$YY#b
-	movl	`&PTR("DWORD[$dat+$YY*4]")`,$TY#d
-	movl	$TX#d,`&PTR("DWORD[$dat+$YY*4]")`
-	movl	$TY#d,`&PTR("DWORD[$dat+$XX*4]")`
+	movl	`&PTR("DWORD:[$dat+$YY*4]")`,$TY#d
+	movl	$TX#d,`&PTR("DWORD:[$dat+$YY*4]")`
+	movl	$TY#d,`&PTR("DWORD:[$dat+$XX*4]")`
 	add	$TY#b,$TX#b
-	movl	`&PTR("DWORD[$dat+$TX*4]")`,$TY#d
+	movl	`&PTR("DWORD:[$dat+$TX*4]")`,$TY#d
 	xor	$TY,%rax
 	inc	$inp
-	movb	%al,`&PTR("BYTE[$out]")`
+	movb	%al,`&PTR("BYTE:[$out]")`
 	inc	$out
 	dec	$len
 	jnz	.Lloop1
 	jmp	.Lexit
+
+.align	16
+.LRC4_CHAR:
+	add	\$1,$XX#b
+	movzb	`&PTR("BYTE:[$dat+$XX]")`,$TX#d
+	add	$TX#b,$YY#b
+	movzb	`&PTR("BYTE:[$dat+$YY]")`,$TY#d
+	movb	$TX#b,`&PTR("BYTE:[$dat+$YY]")`
+	movb	$TY#b,`&PTR("BYTE:[$dat+$XX]")`
+	add	$TX#b,$TY#b
+	movzb	`&PTR("BYTE:[$dat+$TY]")`,$TY#d
+	xorb	`&PTR("BYTE:[$inp]")`,$TY#b
+	movb	$TY#b,`&PTR("BYTE:[$out]")`
+	lea	1($inp),$inp
+	lea	1($out),$out
+	sub	\$1,$len
+	jnz	.LRC4_CHAR
+	jmp	.Lexit
+___
+$code.=<<___ if (defined($win64a));
+RC4	ENDP
+_TEXT	ENDS
+END
+___
+$code.=<<___ if (!defined($win64a));
+.size	RC4,.-RC4
 ___
-if (defined($win64)) {
-    $code.="RC4	ENDP\n";
-} else {
-    $code.=".size	RC4,.-RC4\n"
-}
 
 $code =~ s/#([bwd])/$1/gm;
 $code =~ s/\`([^\`]*)\`/eval $1/gem;
 
-if (defined($win64)) {
+if (defined($win64a)) {
     $code =~ s/\.align/ALIGN/gm;
     $code =~ s/[\$%]//gm;
     $code =~ s/\.L/\$L/gm;
     $code =~ s/([\w]+)([\s]+)([\S]+),([\S]+)/$1$2$4,$3/gm;
-    $code =~ s/([QD]*WORD|BYTE)/$1 PTR /gm;
-    $code =~ s/(mov[z]*)[bwlq]/$1/gm;
+    $code =~ s/([QD]*WORD|BYTE):/$1 PTR/gm;
+    $code =~ s/mov[bwlq]/mov/gm;
+    $code =~ s/movzb/movzx/gm;
+    $code =~ s/repret/DB\t0F3h,0C3h/gm;
+    $code =~ s/cmpl/cmp/gm;
+    $code =~ s/xorb/xor/gm;
 } else {
-    $code =~ s/[QD]*WORD|BYTE//gm;
+    $code =~ s/([QD]*WORD|BYTE)://gm;
+    $code =~ s/repret/.byte\t0xF3,0xC3/gm;
 }
 print $code;