Print this page
first pass


 134 
 135 $code=<<___;
 136 #if defined(lint) || defined(__lint)
 137 
 138 #include "arcfour.h"
 139 
 140 /* ARGSUSED */
 141 void
 142 arcfour_crypt_asm(ARCFour_key *key, uchar_t *in, uchar_t *out, size_t len)
 143 {}
 144 
 145 /* ARGSUSED */
 146 void
 147 arcfour_key_init(ARCFour_key *key, uchar_t *keyval, int keyvallen)
 148 {}
 149 
 150 #else
 151 #include <sys/asm_linkage.h>
 152 
 153 ENTRY_NP(arcfour_crypt_asm)
 154         /* EXPORT DELETE START */
 155 
 156         or      $len,$len # If (len == 0) return
 157         jne     .Lentry
 158         ret
 159 .Lentry:
 160         push    %r12
 161         push    %r13
 162 
 163         / Set $dat to beginning of array, key->arr[0]
 164         add     \$8,$dat
 165         / Get key->j
 166         movl    -8($dat),$XX[0]#d
 167         / Get key->i
 168         movl    -4($dat),$YY#d
 169 
 170         /
 171         / Use a 4-byte key schedule element array
 172         /
 173         inc     $XX[0]#b
 174         movl    ($dat,$XX[0],4),$TX[0]#d
 175         test    \$-8,$len


 226         ret
 227 
 228 .align  16
 229 .Lloop1:
 230         add     $TX[0]#b,$YY#b
 231         movl    ($dat,$YY,4),$TY#d
 232         movl    $TX[0]#d,($dat,$YY,4)
 233         movl    $TY#d,($dat,$XX[0],4)
 234         add     $TY#b,$TX[0]#b
 235         inc     $XX[0]#b
 236         movl    ($dat,$TX[0],4),$TY#d
 237         movl    ($dat,$XX[0],4),$TX[0]#d
 238         xorb    ($inp),$TY#b
 239         inc     $inp
 240         movb    $TY#b,($out)
 241         inc     $out
 242         dec     $len
 243         jnz     .Lloop1
 244         jmp     .Lexit
 245 
 246         /* EXPORT DELETE END */
 247         ret
 248 SET_SIZE(arcfour_crypt_asm)
 249 ___
 250 
 251 
 252 #
 253 # Parameters
 254 #
 255 
 256 # OpenSSL:
 257 # void RC4_set_key(RC4_KEY *key, int len, const unsigned char *data);
 258 #$dat="%rdi";       # arg1
 259 #$len="%rsi";       # arg2
 260 #$inp="%rdx";       # arg3
 261 
 262 # OpenSolaris:
 263 # void arcfour_key_init(ARCFour_key *key, uchar_t *keyval, int keyvallen);
 264 $dat="%rdi";        # arg1
 265 $inp="%rsi";        # arg2
 266 $len="%rdx";        # arg3
 267 
 268 # Temporaries
 269 $idx="%r8";
 270 $ido="%r9";
 271 
 272 $code.=<<___;
 273         / int arcfour_crypt_on_intel(void);
 274 .extern arcfour_crypt_on_intel
 275 
 276 ENTRY_NP(arcfour_key_init)
 277         /* EXPORT DELETE START */
 278 
 279         / Find out if we're running on Intel or something else (e.g., AMD64).
 280         / This sets %eax to 1 for Intel, otherwise 0.
 281         push    %rdi            / Save arg1
 282         push    %rsi            / Save arg2
 283         push    %rdx            / Save arg3
 284         call    arcfour_crypt_on_intel
 285         pop     %rdx            / Restore arg3
 286         pop     %rsi            / Restore arg2
 287         pop     %rdi            / Restore arg1
 288         / Save return value in key->flag (1=Intel, 0=AMD)
 289         movl    %eax,1032($dat)
 290 
 291         / Set $dat to beginning of array, key->arr[0]
 292         lea     8($dat),$dat
 293         lea     ($inp,$len),$inp
 294         neg     $len
 295         mov     $len,%rcx
 296 
 297         xor     %eax,%eax
 298         xor     $ido,$ido


 313         xor     $idx,$idx
 314 
 315 .align  16
 316 .Lw2ndloop:
 317         mov     ($dat,$ido,4),%r10d
 318         add     ($inp,$len,1),$idx#b
 319         add     %r10b,$idx#b
 320         add     \$1,$len
 321         mov     ($dat,$idx,4),%r11d
 322         cmovz   %rcx,$len
 323         mov     %r10d,($dat,$idx,4)
 324         mov     %r11d,($dat,$ido,4)
 325         add     \$1,$ido#b
 326         jnc     .Lw2ndloop
 327 
 328         / Exit code
 329         xor     %eax,%eax
 330         mov     %eax,-8($dat)
 331         mov     %eax,-4($dat)
 332 
 333         /* EXPORT DELETE END */
 334         ret
 335 SET_SIZE(arcfour_key_init)
 336 .asciz  "RC4 for x86_64, CRYPTOGAMS by <appro\@openssl.org>"
 337 #endif /* !lint && !__lint */
 338 ___
 339 
 340 $code =~ s/#([bwd])/$1/gm;
 341 
 342 print $code;
 343 
 344 close STDOUT;


 134 
 135 $code=<<___;
 136 #if defined(lint) || defined(__lint)
 137 
 138 #include "arcfour.h"
 139 
 140 /* ARGSUSED */
 141 void
 142 arcfour_crypt_asm(ARCFour_key *key, uchar_t *in, uchar_t *out, size_t len)
 143 {}
 144 
 145 /* ARGSUSED */
 146 void
 147 arcfour_key_init(ARCFour_key *key, uchar_t *keyval, int keyvallen)
 148 {}
 149 
 150 #else
 151 #include <sys/asm_linkage.h>
 152 
 153 ENTRY_NP(arcfour_crypt_asm)


 154         or      $len,$len # If (len == 0) return
 155         jne     .Lentry
 156         ret
 157 .Lentry:
 158         push    %r12
 159         push    %r13
 160 
 161         / Set $dat to beginning of array, key->arr[0]
 162         add     \$8,$dat
 163         / Get key->j
 164         movl    -8($dat),$XX[0]#d
 165         / Get key->i
 166         movl    -4($dat),$YY#d
 167 
 168         /
 169         / Use a 4-byte key schedule element array
 170         /
 171         inc     $XX[0]#b
 172         movl    ($dat,$XX[0],4),$TX[0]#d
 173         test    \$-8,$len


 224         ret
 225 
 226 .align  16
 227 .Lloop1:
 228         add     $TX[0]#b,$YY#b
 229         movl    ($dat,$YY,4),$TY#d
 230         movl    $TX[0]#d,($dat,$YY,4)
 231         movl    $TY#d,($dat,$XX[0],4)
 232         add     $TY#b,$TX[0]#b
 233         inc     $XX[0]#b
 234         movl    ($dat,$TX[0],4),$TY#d
 235         movl    ($dat,$XX[0],4),$TX[0]#d
 236         xorb    ($inp),$TY#b
 237         inc     $inp
 238         movb    $TY#b,($out)
 239         inc     $out
 240         dec     $len
 241         jnz     .Lloop1
 242         jmp     .Lexit
 243 

 244         ret
 245 SET_SIZE(arcfour_crypt_asm)
 246 ___
 247 
 248 
 249 #
 250 # Parameters
 251 #
 252 
 253 # OpenSSL:
 254 # void RC4_set_key(RC4_KEY *key, int len, const unsigned char *data);
 255 #$dat="%rdi";       # arg1
 256 #$len="%rsi";       # arg2
 257 #$inp="%rdx";       # arg3
 258 
 259 # OpenSolaris:
 260 # void arcfour_key_init(ARCFour_key *key, uchar_t *keyval, int keyvallen);
 261 $dat="%rdi";        # arg1
 262 $inp="%rsi";        # arg2
 263 $len="%rdx";        # arg3
 264 
 265 # Temporaries
 266 $idx="%r8";
 267 $ido="%r9";
 268 
 269 $code.=<<___;
 270         / int arcfour_crypt_on_intel(void);
 271 .extern arcfour_crypt_on_intel
 272 
 273 ENTRY_NP(arcfour_key_init)


 274         / Find out if we're running on Intel or something else (e.g., AMD64).
 275         / This sets %eax to 1 for Intel, otherwise 0.
 276         push    %rdi            / Save arg1
 277         push    %rsi            / Save arg2
 278         push    %rdx            / Save arg3
 279         call    arcfour_crypt_on_intel
 280         pop     %rdx            / Restore arg3
 281         pop     %rsi            / Restore arg2
 282         pop     %rdi            / Restore arg1
 283         / Save return value in key->flag (1=Intel, 0=AMD)
 284         movl    %eax,1032($dat)
 285 
 286         / Set $dat to beginning of array, key->arr[0]
 287         lea     8($dat),$dat
 288         lea     ($inp,$len),$inp
 289         neg     $len
 290         mov     $len,%rcx
 291 
 292         xor     %eax,%eax
 293         xor     $ido,$ido


 308         xor     $idx,$idx
 309 
 310 .align  16
 311 .Lw2ndloop:
 312         mov     ($dat,$ido,4),%r10d
 313         add     ($inp,$len,1),$idx#b
 314         add     %r10b,$idx#b
 315         add     \$1,$len
 316         mov     ($dat,$idx,4),%r11d
 317         cmovz   %rcx,$len
 318         mov     %r10d,($dat,$idx,4)
 319         mov     %r11d,($dat,$ido,4)
 320         add     \$1,$ido#b
 321         jnc     .Lw2ndloop
 322 
 323         / Exit code
 324         xor     %eax,%eax
 325         mov     %eax,-8($dat)
 326         mov     %eax,-4($dat)
 327 

 328         ret
 329 SET_SIZE(arcfour_key_init)
 330 .asciz  "RC4 for x86_64, CRYPTOGAMS by <appro\@openssl.org>"
 331 #endif /* !lint && !__lint */
 332 ___
 333 
 334 $code =~ s/#([bwd])/$1/gm;
 335 
 336 print $code;
 337 
 338 close STDOUT;