crypto/rc4/asm/rc4-amd64.pl

   1 #!/usr/bin/env perl
   2 #
   3 # ====================================================================
   4 # Written by Andy Polyakov <appro@fy.chalmers.se> for the OpenSSL
   5 # project. Rights for redistribution and usage in source and binary
   6 # forms are granted according to the OpenSSL license.
   7 # ====================================================================
   8 #
   9 # 2.22x RC4 tune-up:-) It should be noted though that my hand [as in
  10 # "hand-coded assembler"] doesn't stand for the whole improvement
  11 # coefficient. It turned out that eliminating RC4_CHAR from config
  12 # line results in ~40% improvement (yes, even for C implementation).
  13 # Presumably it has everything to do with AMD cache architecture and
  14 # RAW or whatever penalties. Once again! The module *requires* config
  15 # line *without* RC4_CHAR! As for coding "secret," I bet on partial
  16 # register arithmetics. For example instead 'inc %r8; and $255,%r8'
  17 # I simply 'inc %r8b'. Even though optimization manual discourages
  18 # to operate on partial registers, it turned out to be the best bet.
  19 # At least for AMD... How IA32E would perform remains to be seen...
  20
  21 $output=shift;
  22
  23 $win64a=1 if ($output =~ /win64a.[s|asm]/);
  24
  25 open STDOUT,">$output" || die "can't open $output: $!";
  26
  27 if (defined($win64a)) {
  28     $dat="%rcx";        # arg1
  29     $len="%rdx";        # arg2
  30     $inp="%rsi";        # r8, arg3 moves here
  31     $out="%rdi";        # r9, arg4 moves here
  32 } else {
  33     $dat="%rdi";        # arg1
  34     $len="%rsi";        # arg2
  35     $inp="%rdx";        # arg3
  36     $out="%rcx";        # arg4
  37 }
  38
  39 $XX="%r10";
  40 $TX="%r8";
  41 $YY="%r11";
  42 $TY="%r9";
  43
  44 sub PTR() {
  45     my $ret=shift;
  46     if (defined($win64a)) {
  47         $ret =~ s/\[([\S]+)\+([\S]+)\]/[$2+$1]/g;   # [%rN+%rM*4]->[%rM*4+%rN]
  48         $ret =~ s/:([^\[]+)\[([^\]]+)\]/:[$2+$1]/g; # :off[ea]->:[ea+off]
  49     } else {
  50         $ret =~ s/[\+\*]/,/g;           # [%rN+%rM*4]->[%rN,%rM,4]
  51         $ret =~ s/\[([^\]]+)\]/($1)/g;  # [%rN]->(%rN)
  52     }
  53     $ret;
  54 }
  55
  56 $code=<<___ if (!defined($win64a));
  57 .text
  58
  59 .globl  RC4
  60 .type   RC4,\@function
  61 .align  16
  62 RC4:    or      $len,$len
  63         jne     .Lentry
  64         repret
  65 .Lentry:
  66 ___
  67 $code=<<___ if (defined($win64a));
  68 TEXT    SEGMENT
  69 PUBLIC  RC4
  70 ALIGN   16
  71 RC4     PROC NEAR
  72         or      $len,$len
  73         jne     .Lentry
  74         repret
  75 .Lentry:
  76         push    %rdi
  77         push    %rsi
  78         sub     \$40,%rsp
  79         mov     %r8,$inp
  80         mov     %r9,$out
  81 ___
  82 $code.=<<___;
  83         add     \$8,$dat
  84         movl    `&PTR("DWORD:-8[$dat]")`,$XX#d
  85         movl    `&PTR("DWORD:-4[$dat]")`,$YY#d
  86         test    \$-8,$len
  87         jz      .Lloop1
  88 .align  16
  89 .Lloop8:
  90         movq    `&PTR("QWORD:[$inp]")`,%rax
  91
  92         inc     $XX#b
  93         movl    `&PTR("DWORD:[$dat+$XX*4]")`,$TX#d
  94         add     $TX#b,$YY#b
  95         movl    `&PTR("DWORD:[$dat+$YY*4]")`,$TY#d
  96         movl    $TX#d,`&PTR("DWORD:[$dat+$YY*4]")`
  97         movl    $TY#d,`&PTR("DWORD:[$dat+$XX*4]")`
  98         add     $TY#b,$TX#b
  99         inc     $XX#b
 100         movl    `&PTR("DWORD:[$dat+$TX*4]")`,$TY#d
 101         xor     $TY,%rax
 102 ___
 103 for ($i=1;$i<=6;$i++) {
 104 $code.=<<___;
 105         movl    `&PTR("DWORD:[$dat+$XX*4]")`,$TX#d
 106         add     $TX#b,$YY#b
 107         movl    `&PTR("DWORD:[$dat+$YY*4]")`,$TY#d
 108         movl    $TX#d,`&PTR("DWORD:[$dat+$YY*4]")`
 109         movl    $TY#d,`&PTR("DWORD:[$dat+$XX*4]")`
 110         add     $TY#b,$TX#b
 111         movl    `&PTR("DWORD:[$dat+$TX*4]")`,$TY#d
 112         shl     \$`8*$i`,$TY
 113         inc     $XX#b
 114         xor     $TY,%rax
 115 ___
 116 }
 117 $code.=<<___;
 118         movl    `&PTR("DWORD:[$dat+$XX*4]")`,$TX#d
 119         add     $TX#b,$YY#b
 120         movl    `&PTR("DWORD:[$dat+$YY*4]")`,$TY#d
 121         movl    $TX#d,`&PTR("DWORD:[$dat+$YY*4]")`
 122         movl    $TY#d,`&PTR("DWORD:[$dat+$XX*4]")`
 123         sub     \$8,$len
 124         add     $TY#b,$TX#b
 125         add     \$8,$out
 126         movl    `&PTR("DWORD:[$dat+$TX*4]")`,$TY#d
 127         shl     \$56,$TY
 128         add     \$8,$inp
 129         xor     $TY,%rax
 130
 131         mov     %rax,`&PTR("QWORD:-8[$out]")`
 132
 133         test    \$-8,$len
 134         jnz     .Lloop8
 135         cmp     \$0,$len
 136         jne     .Lloop1
 137 .Lexit:
 138         movl    $XX#d,`&PTR("DWORD:-8[$dat]")`
 139         movl    $YY#d,`&PTR("DWORD:-4[$dat]")`
 140 ___
 141 $code.=<<___ if (defined($win64a));
 142         add     \$40,%rsp
 143         pop     %rsi
 144         pop     %rdi
 145 ___
 146 $code.=<<___;
 147         repret
 148 .align  16
 149 .Lloop1:
 150         movzb   `&PTR("BYTE:[$inp]")`,%eax
 151         inc     $XX#b
 152         movl    `&PTR("DWORD:[$dat+$XX*4]")`,$TX#d
 153         add     $TX#b,$YY#b
 154         movl    `&PTR("DWORD:[$dat+$YY*4]")`,$TY#d
 155         movl    $TX#d,`&PTR("DWORD:[$dat+$YY*4]")`
 156         movl    $TY#d,`&PTR("DWORD:[$dat+$XX*4]")`
 157         add     $TY#b,$TX#b
 158         movl    `&PTR("DWORD:[$dat+$TX*4]")`,$TY#d
 159         xor     $TY,%rax
 160         inc     $inp
 161         movb    %al,`&PTR("BYTE:[$out]")`
 162         inc     $out
 163         dec     $len
 164         jnz     .Lloop1
 165         jmp     .Lexit
 166 ___
 167 $code.=<<___ if (defined($win64a));
 168 RC4     ENDP
 169 TEXT    ENDS
 170 END
 171 ___
 172 $code.=<<___ if (!defined($win64a));
 173 .size   RC4,.-RC4
 174 ___
 175
 176 $code =~ s/#([bwd])/$1/gm;
 177 $code =~ s/\`([^\`]*)\`/eval $1/gem;
 178
 179 if (defined($win64a)) {
 180     $code =~ s/\.align/ALIGN/gm;
 181     $code =~ s/[\$%]//gm;
 182     $code =~ s/\.L/\$L/gm;
 183     $code =~ s/([\w]+)([\s]+)([\S]+),([\S]+)/$1$2$4,$3/gm;
 184     $code =~ s/([QD]*WORD|BYTE):/$1 PTR/gm;
 185     $code =~ s/mov[bwlq]/mov/gm;
 186     $code =~ s/movzb/movzx/gm;
 187     $code =~ s/repret/DB\t0F3h,0C3h/gm;
 188 } else {
 189     $code =~ s/([QD]*WORD|BYTE)://gm;
 190     $code =~ s/repret/.byte\t0xF3,0xC3/gm;
 191 }
 192 print $code;