crypto/sha/asm/sha1-586.pl

   1 #! /usr/bin/env perl
   2 # Copyright 1998-2016 The OpenSSL Project Authors. All Rights Reserved.
   3 #
   4 # Licensed under the OpenSSL license (the "License").  You may not use
   5 # this file except in compliance with the License.  You can obtain a copy
   6 # in the file LICENSE in the source distribution or at
   7 # https://www.openssl.org/source/license.html
   8
   9
  10 # ====================================================================
  11 # [Re]written by Andy Polyakov <appro@openssl.org> for the OpenSSL
  12 # project. The module is, however, dual licensed under OpenSSL and
  13 # CRYPTOGAMS licenses depending on where you obtain it. For further
  14 # details see http://www.openssl.org/~appro/cryptogams/.
  15 # ====================================================================
  16
  17 # "[Re]written" was achieved in two major overhauls. In 2004 BODY_*
  18 # functions were re-implemented to address P4 performance issue [see
  19 # commentary below], and in 2006 the rest was rewritten in order to
  20 # gain freedom to liberate licensing terms.
  21
  22 # January, September 2004.
  23 #
  24 # It was noted that Intel IA-32 C compiler generates code which
  25 # performs ~30% *faster* on P4 CPU than original *hand-coded*
  26 # SHA1 assembler implementation. To address this problem (and
  27 # prove that humans are still better than machines:-), the
  28 # original code was overhauled, which resulted in following
  29 # performance changes:
  30 #
  31 #               compared with original  compared with Intel cc
  32 #               assembler impl.         generated code
  33 # Pentium       -16%                    +48%
  34 # PIII/AMD      +8%                     +16%
  35 # P4            +85%(!)                 +45%
  36 #
  37 # As you can see Pentium came out as looser:-( Yet I reckoned that
  38 # improvement on P4 outweights the loss and incorporate this
  39 # re-tuned code to 0.9.7 and later.
  40 # ----------------------------------------------------------------
  41 #                                       <appro@fy.chalmers.se>
  42
  43 # August 2009.
  44 #
  45 # George Spelvin has tipped that F_40_59(b,c,d) can be rewritten as
  46 # '(c&d) + (b&(c^d))', which allows to accumulate partial results
  47 # and lighten "pressure" on scratch registers. This resulted in
  48 # >12% performance improvement on contemporary AMD cores (with no
  49 # degradation on other CPUs:-). Also, the code was revised to maximize
  50 # "distance" between instructions producing input to 'lea' instruction
  51 # and the 'lea' instruction itself, which is essential for Intel Atom
  52 # core and resulted in ~15% improvement.
  53
  54 # October 2010.
  55 #
  56 # Add SSSE3, Supplemental[!] SSE3, implementation. The idea behind it
  57 # is to offload message schedule denoted by Wt in NIST specification,
  58 # or Xupdate in OpenSSL source, to SIMD unit. The idea is not novel,
  59 # and in SSE2 context was first explored by Dean Gaudet in 2004, see
  60 # http://arctic.org/~dean/crypto/sha1.html. Since then several things
  61 # have changed that made it interesting again:
  62 #
  63 # a) XMM units became faster and wider;
  64 # b) instruction set became more versatile;
  65 # c) an important observation was made by Max Locktykhin, which made
  66 #    it possible to reduce amount of instructions required to perform
  67 #    the operation in question, for further details see
  68 #    http://software.intel.com/en-us/articles/improving-the-performance-of-the-secure-hash-algorithm-1/.
  69
  70 # April 2011.
  71 #
  72 # Add AVX code path, probably most controversial... The thing is that
  73 # switch to AVX alone improves performance by as little as 4% in
  74 # comparison to SSSE3 code path. But below result doesn't look like
  75 # 4% improvement... Trouble is that Sandy Bridge decodes 'ro[rl]' as
  76 # pair of µ-ops, and it's the additional µ-ops, two per round, that
  77 # make it run slower than Core2 and Westmere. But 'sh[rl]d' is decoded
  78 # as single µ-op by Sandy Bridge and it's replacing 'ro[rl]' with
  79 # equivalent 'sh[rl]d' that is responsible for the impressive 5.1
  80 # cycles per processed byte. But 'sh[rl]d' is not something that used
  81 # to be fast, nor does it appear to be fast in upcoming Bulldozer
  82 # [according to its optimization manual]. Which is why AVX code path
  83 # is guarded by *both* AVX and synthetic bit denoting Intel CPUs.
  84 # One can argue that it's unfair to AMD, but without 'sh[rl]d' it
  85 # makes no sense to keep the AVX code path. If somebody feels that
  86 # strongly, it's probably more appropriate to discuss possibility of
  87 # using vector rotate XOP on AMD...
  88
  89 # March 2014.
  90 #
  91 # Add support for Intel SHA Extensions.
  92
  93 ######################################################################
  94 # Current performance is summarized in following table. Numbers are
  95 # CPU clock cycles spent to process single byte (less is better).
  96 #
  97 #               x86             SSSE3           AVX
  98 # Pentium       15.7            -
  99 # PIII          11.5            -
 100 # P4            10.6            -
 101 # AMD K8        7.1             -
 102 # Core2         7.3             6.0/+22%        -
 103 # Westmere      7.3             5.5/+33%        -
 104 # Sandy Bridge  8.8             6.2/+40%        5.1(**)/+73%
 105 # Ivy Bridge    7.2             4.8/+51%        4.7(**)/+53%
 106 # Haswell       6.5             4.3/+51%        4.1(**)/+58%
 107 # Bulldozer     11.6            6.0/+92%
 108 # VIA Nano      10.6            7.5/+41%
 109 # Atom          12.5            9.3(*)/+35%
 110 # Silvermont    14.5            9.9(*)/+46%
 111 #
 112 # (*)   Loop is 1056 instructions long and expected result is ~8.25.
 113 #       The discrepancy is because of front-end limitations, so
 114 #       called MS-ROM penalties, and on Silvermont even rotate's
 115 #       limited parallelism.
 116 #
 117 # (**)  As per above comment, the result is for AVX *plus* sh[rl]d.
 118
 119 $0 =~ m/(.*[\/\\])[^\/\\]+$/; $dir=$1;
 120 push(@INC,"${dir}","${dir}../../perlasm");
 121 require "x86asm.pl";
 122
 123 $output=pop;
 124 open STDOUT,">$output";
 125
 126 &asm_init($ARGV[0],"sha1-586.pl",$ARGV[$#ARGV] eq "386");
 127
 128 $xmm=$ymm=0;
 129 for (@ARGV) { $xmm=1 if (/-DOPENSSL_IA32_SSE2/); }
 130
 131 $ymm=1 if ($xmm &&
 132                 `$ENV{CC} -Wa,-v -c -o /dev/null -x assembler /dev/null 2>&1`
 133                         =~ /GNU assembler version ([2-9]\.[0-9]+)/ &&
 134                 $1>=2.19);      # first version supporting AVX
 135
 136 $ymm=1 if ($xmm && !$ymm && $ARGV[0] eq "win32n" &&
 137                 `nasm -v 2>&1` =~ /NASM version ([2-9]\.[0-9]+)/ &&
 138                 $1>=2.03);      # first version supporting AVX
 139
 140 $ymm=1 if ($xmm && !$ymm && $ARGV[0] eq "win32" &&
 141                 `ml 2>&1` =~ /Version ([0-9]+)\./ &&
 142                 $1>=10);        # first version supporting AVX
 143
 144 $ymm=1 if ($xmm && !$ymm && `$ENV{CC} -v 2>&1` =~ /(^clang version|based on LLVM) ([3-9]\.[0-9]+)/ &&
 145                 $2>=3.0);       # first version supporting AVX
 146
 147 $shaext=$xmm;   ### set to zero if compiling for 1.0.1
 148
 149 &external_label("OPENSSL_ia32cap_P") if ($xmm);
 150
 151
 152 $A="eax";
 153 $B="ebx";
 154 $C="ecx";
 155 $D="edx";
 156 $E="edi";
 157 $T="esi";
 158 $tmp1="ebp";
 159
 160 @V=($A,$B,$C,$D,$E,$T);
 161
 162 $alt=0; # 1 denotes alternative IALU implementation, which performs
 163         # 8% *worse* on P4, same on Westmere and Atom, 2% better on
 164         # Sandy Bridge...
 165
 166 sub BODY_00_15
 167         {
 168         local($n,$a,$b,$c,$d,$e,$f)=@_;
 169
 170         &comment("00_15 $n");
 171
 172         &mov($f,$c);                    # f to hold F_00_19(b,c,d)
 173          if ($n==0)  { &mov($tmp1,$a); }
 174          else        { &mov($a,$tmp1); }
 175         &rotl($tmp1,5);                 # tmp1=ROTATE(a,5)
 176          &xor($f,$d);
 177         &add($tmp1,$e);                 # tmp1+=e;
 178          &mov($e,&swtmp($n%16));        # e becomes volatile and is loaded
 179                                         # with xi, also note that e becomes
 180                                         # f in next round...
 181         &and($f,$b);
 182         &rotr($b,2);                    # b=ROTATE(b,30)
 183          &xor($f,$d);                   # f holds F_00_19(b,c,d)
 184         &lea($tmp1,&DWP(0x5a827999,$tmp1,$e));  # tmp1+=K_00_19+xi
 185
 186         if ($n==15) { &mov($e,&swtmp(($n+1)%16));# pre-fetch f for next round
 187                       &add($f,$tmp1); } # f+=tmp1
 188         else        { &add($tmp1,$f); } # f becomes a in next round
 189         &mov($tmp1,$a)                  if ($alt && $n==15);
 190         }
 191
 192 sub BODY_16_19
 193         {
 194         local($n,$a,$b,$c,$d,$e,$f)=@_;
 195
 196         &comment("16_19 $n");
 197
 198 if ($alt) {
 199         &xor($c,$d);
 200          &xor($f,&swtmp(($n+2)%16));    # f to hold Xupdate(xi,xa,xb,xc,xd)
 201         &and($tmp1,$c);                 # tmp1 to hold F_00_19(b,c,d), b&=c^d
 202          &xor($f,&swtmp(($n+8)%16));
 203         &xor($tmp1,$d);                 # tmp1=F_00_19(b,c,d)
 204          &xor($f,&swtmp(($n+13)%16));   # f holds xa^xb^xc^xd
 205         &rotl($f,1);                    # f=ROTATE(f,1)
 206          &add($e,$tmp1);                # e+=F_00_19(b,c,d)
 207         &xor($c,$d);                    # restore $c
 208          &mov($tmp1,$a);                # b in next round
 209         &rotr($b,$n==16?2:7);           # b=ROTATE(b,30)
 210          &mov(&swtmp($n%16),$f);        # xi=f
 211         &rotl($a,5);                    # ROTATE(a,5)
 212          &lea($f,&DWP(0x5a827999,$f,$e));# f+=F_00_19(b,c,d)+e
 213         &mov($e,&swtmp(($n+1)%16));     # pre-fetch f for next round
 214          &add($f,$a);                   # f+=ROTATE(a,5)
 215 } else {
 216         &mov($tmp1,$c);                 # tmp1 to hold F_00_19(b,c,d)
 217          &xor($f,&swtmp(($n+2)%16));    # f to hold Xupdate(xi,xa,xb,xc,xd)
 218         &xor($tmp1,$d);
 219          &xor($f,&swtmp(($n+8)%16));
 220         &and($tmp1,$b);
 221          &xor($f,&swtmp(($n+13)%16));   # f holds xa^xb^xc^xd
 222         &rotl($f,1);                    # f=ROTATE(f,1)
 223          &xor($tmp1,$d);                # tmp1=F_00_19(b,c,d)
 224         &add($e,$tmp1);                 # e+=F_00_19(b,c,d)
 225          &mov($tmp1,$a);
 226         &rotr($b,2);                    # b=ROTATE(b,30)
 227          &mov(&swtmp($n%16),$f);        # xi=f
 228         &rotl($tmp1,5);                 # ROTATE(a,5)
 229          &lea($f,&DWP(0x5a827999,$f,$e));# f+=F_00_19(b,c,d)+e
 230         &mov($e,&swtmp(($n+1)%16));     # pre-fetch f for next round
 231          &add($f,$tmp1);                # f+=ROTATE(a,5)
 232 }
 233         }
 234
 235 sub BODY_20_39
 236         {
 237         local($n,$a,$b,$c,$d,$e,$f)=@_;
 238         local $K=($n<40)?0x6ed9eba1:0xca62c1d6;
 239
 240         &comment("20_39 $n");
 241
 242 if ($alt) {
 243         &xor($tmp1,$c);                 # tmp1 to hold F_20_39(b,c,d), b^=c
 244          &xor($f,&swtmp(($n+2)%16));    # f to hold Xupdate(xi,xa,xb,xc,xd)
 245         &xor($tmp1,$d);                 # tmp1 holds F_20_39(b,c,d)
 246          &xor($f,&swtmp(($n+8)%16));
 247         &add($e,$tmp1);                 # e+=F_20_39(b,c,d)
 248          &xor($f,&swtmp(($n+13)%16));   # f holds xa^xb^xc^xd
 249         &rotl($f,1);                    # f=ROTATE(f,1)
 250          &mov($tmp1,$a);                # b in next round
 251         &rotr($b,7);                    # b=ROTATE(b,30)
 252          &mov(&swtmp($n%16),$f)         if($n<77);# xi=f
 253         &rotl($a,5);                    # ROTATE(a,5)
 254          &xor($b,$c)                    if($n==39);# warm up for BODY_40_59
 255         &and($tmp1,$b)                  if($n==39);
 256          &lea($f,&DWP($K,$f,$e));       # f+=e+K_XX_YY
 257         &mov($e,&swtmp(($n+1)%16))      if($n<79);# pre-fetch f for next round
 258          &add($f,$a);                   # f+=ROTATE(a,5)
 259         &rotr($a,5)                     if ($n==79);
 260 } else {
 261         &mov($tmp1,$b);                 # tmp1 to hold F_20_39(b,c,d)
 262          &xor($f,&swtmp(($n+2)%16));    # f to hold Xupdate(xi,xa,xb,xc,xd)
 263         &xor($tmp1,$c);
 264          &xor($f,&swtmp(($n+8)%16));
 265         &xor($tmp1,$d);                 # tmp1 holds F_20_39(b,c,d)
 266          &xor($f,&swtmp(($n+13)%16));   # f holds xa^xb^xc^xd
 267         &rotl($f,1);                    # f=ROTATE(f,1)
 268          &add($e,$tmp1);                # e+=F_20_39(b,c,d)
 269         &rotr($b,2);                    # b=ROTATE(b,30)
 270          &mov($tmp1,$a);
 271         &rotl($tmp1,5);                 # ROTATE(a,5)
 272          &mov(&swtmp($n%16),$f) if($n<77);# xi=f
 273         &lea($f,&DWP($K,$f,$e));        # f+=e+K_XX_YY
 274          &mov($e,&swtmp(($n+1)%16)) if($n<79);# pre-fetch f for next round
 275         &add($f,$tmp1);                 # f+=ROTATE(a,5)
 276 }
 277         }
 278
 279 sub BODY_40_59
 280         {
 281         local($n,$a,$b,$c,$d,$e,$f)=@_;
 282
 283         &comment("40_59 $n");
 284
 285 if ($alt) {
 286         &add($e,$tmp1);                 # e+=b&(c^d)
 287          &xor($f,&swtmp(($n+2)%16));    # f to hold Xupdate(xi,xa,xb,xc,xd)
 288         &mov($tmp1,$d);
 289          &xor($f,&swtmp(($n+8)%16));
 290         &xor($c,$d);                    # restore $c
 291          &xor($f,&swtmp(($n+13)%16));   # f holds xa^xb^xc^xd
 292         &rotl($f,1);                    # f=ROTATE(f,1)
 293          &and($tmp1,$c);
 294         &rotr($b,7);                    # b=ROTATE(b,30)
 295          &add($e,$tmp1);                # e+=c&d
 296         &mov($tmp1,$a);                 # b in next round
 297          &mov(&swtmp($n%16),$f);        # xi=f
 298         &rotl($a,5);                    # ROTATE(a,5)
 299          &xor($b,$c)                    if ($n<59);
 300         &and($tmp1,$b)                  if ($n<59);# tmp1 to hold F_40_59(b,c,d)
 301          &lea($f,&DWP(0x8f1bbcdc,$f,$e));# f+=K_40_59+e+(b&(c^d))
 302         &mov($e,&swtmp(($n+1)%16));     # pre-fetch f for next round
 303          &add($f,$a);                   # f+=ROTATE(a,5)
 304 } else {
 305         &mov($tmp1,$c);                 # tmp1 to hold F_40_59(b,c,d)
 306          &xor($f,&swtmp(($n+2)%16));    # f to hold Xupdate(xi,xa,xb,xc,xd)
 307         &xor($tmp1,$d);
 308          &xor($f,&swtmp(($n+8)%16));
 309         &and($tmp1,$b);
 310          &xor($f,&swtmp(($n+13)%16));   # f holds xa^xb^xc^xd
 311         &rotl($f,1);                    # f=ROTATE(f,1)
 312          &add($tmp1,$e);                # b&(c^d)+=e
 313         &rotr($b,2);                    # b=ROTATE(b,30)
 314          &mov($e,$a);                   # e becomes volatile
 315         &rotl($e,5);                    # ROTATE(a,5)
 316          &mov(&swtmp($n%16),$f);        # xi=f
 317         &lea($f,&DWP(0x8f1bbcdc,$f,$tmp1));# f+=K_40_59+e+(b&(c^d))
 318          &mov($tmp1,$c);
 319         &add($f,$e);                    # f+=ROTATE(a,5)
 320          &and($tmp1,$d);
 321         &mov($e,&swtmp(($n+1)%16));     # pre-fetch f for next round
 322          &add($f,$tmp1);                # f+=c&d
 323 }
 324         }
 325
 326 &function_begin("sha1_block_data_order");
 327 if ($xmm) {
 328   &static_label("shaext_shortcut")      if ($shaext);
 329   &static_label("ssse3_shortcut");
 330   &static_label("avx_shortcut")         if ($ymm);
 331   &static_label("K_XX_XX");
 332
 333         &call   (&label("pic_point"));  # make it PIC!
 334   &set_label("pic_point");
 335         &blindpop($tmp1);
 336         &picmeup($T,"OPENSSL_ia32cap_P",$tmp1,&label("pic_point"));
 337         &lea    ($tmp1,&DWP(&label("K_XX_XX")."-".&label("pic_point"),$tmp1));
 338
 339         &mov    ($A,&DWP(0,$T));
 340         &mov    ($D,&DWP(4,$T));
 341         &test   ($D,1<<9);              # check SSSE3 bit
 342         &jz     (&label("x86"));
 343         &mov    ($C,&DWP(8,$T));
 344         &test   ($A,1<<24);             # check FXSR bit
 345         &jz     (&label("x86"));
 346         if ($shaext) {
 347                 &test   ($C,1<<29);             # check SHA bit
 348                 &jnz    (&label("shaext_shortcut"));
 349         }
 350         if ($ymm) {
 351                 &and    ($D,1<<28);             # mask AVX bit
 352                 &and    ($A,1<<30);             # mask "Intel CPU" bit
 353                 &or     ($A,$D);
 354                 &cmp    ($A,1<<28|1<<30);
 355                 &je     (&label("avx_shortcut"));
 356         }
 357         &jmp    (&label("ssse3_shortcut"));
 358   &set_label("x86",16);
 359 }
 360         &mov($tmp1,&wparam(0)); # SHA_CTX *c
 361         &mov($T,&wparam(1));    # const void *input
 362         &mov($A,&wparam(2));    # size_t num
 363         &stack_push(16+3);      # allocate X[16]
 364         &shl($A,6);
 365         &add($A,$T);
 366         &mov(&wparam(2),$A);    # pointer beyond the end of input
 367         &mov($E,&DWP(16,$tmp1));# pre-load E
 368         &jmp(&label("loop"));
 369
 370 &set_label("loop",16);
 371
 372         # copy input chunk to X, but reversing byte order!
 373         for ($i=0; $i<16; $i+=4)
 374                 {
 375                 &mov($A,&DWP(4*($i+0),$T));
 376                 &mov($B,&DWP(4*($i+1),$T));
 377                 &mov($C,&DWP(4*($i+2),$T));
 378                 &mov($D,&DWP(4*($i+3),$T));
 379                 &bswap($A);
 380                 &bswap($B);
 381                 &bswap($C);
 382                 &bswap($D);
 383                 &mov(&swtmp($i+0),$A);
 384                 &mov(&swtmp($i+1),$B);
 385                 &mov(&swtmp($i+2),$C);
 386                 &mov(&swtmp($i+3),$D);
 387                 }
 388         &mov(&wparam(1),$T);    # redundant in 1st spin
 389
 390         &mov($A,&DWP(0,$tmp1)); # load SHA_CTX
 391         &mov($B,&DWP(4,$tmp1));
 392         &mov($C,&DWP(8,$tmp1));
 393         &mov($D,&DWP(12,$tmp1));
 394         # E is pre-loaded
 395
 396         for($i=0;$i<16;$i++)    { &BODY_00_15($i,@V); unshift(@V,pop(@V)); }
 397         for(;$i<20;$i++)        { &BODY_16_19($i,@V); unshift(@V,pop(@V)); }
 398         for(;$i<40;$i++)        { &BODY_20_39($i,@V); unshift(@V,pop(@V)); }
 399         for(;$i<60;$i++)        { &BODY_40_59($i,@V); unshift(@V,pop(@V)); }
 400         for(;$i<80;$i++)        { &BODY_20_39($i,@V); unshift(@V,pop(@V)); }
 401
 402         (($V[5] eq $D) and ($V[0] eq $E)) or die;       # double-check
 403
 404         &mov($tmp1,&wparam(0)); # re-load SHA_CTX*
 405         &mov($D,&wparam(1));    # D is last "T" and is discarded
 406
 407         &add($E,&DWP(0,$tmp1)); # E is last "A"...
 408         &add($T,&DWP(4,$tmp1));
 409         &add($A,&DWP(8,$tmp1));
 410         &add($B,&DWP(12,$tmp1));
 411         &add($C,&DWP(16,$tmp1));
 412
 413         &mov(&DWP(0,$tmp1),$E); # update SHA_CTX
 414          &add($D,64);           # advance input pointer
 415         &mov(&DWP(4,$tmp1),$T);
 416          &cmp($D,&wparam(2));   # have we reached the end yet?
 417         &mov(&DWP(8,$tmp1),$A);
 418          &mov($E,$C);           # C is last "E" which needs to be "pre-loaded"
 419         &mov(&DWP(12,$tmp1),$B);
 420          &mov($T,$D);           # input pointer
 421         &mov(&DWP(16,$tmp1),$C);
 422         &jb(&label("loop"));
 423
 424         &stack_pop(16+3);
 425 &function_end("sha1_block_data_order");
 426
 427 if ($xmm) {
 428 if ($shaext) {
 429 ######################################################################
 430 # Intel SHA Extensions implementation of SHA1 update function.
 431 #
 432 my ($ctx,$inp,$num)=("edi","esi","ecx");
 433 my ($ABCD,$E,$E_,$BSWAP)=map("xmm$_",(0..3));
 434 my @MSG=map("xmm$_",(4..7));
 435
 436 sub sha1rnds4 {
 437  my ($dst,$src,$imm)=@_;
 438     if ("$dst:$src" =~ /xmm([0-7]):xmm([0-7])/)
 439     {   &data_byte(0x0f,0x3a,0xcc,0xc0|($1<<3)|$2,$imm);        }
 440 }
 441 sub sha1op38 {
 442  my ($opcodelet,$dst,$src)=@_;
 443     if ("$dst:$src" =~ /xmm([0-7]):xmm([0-7])/)
 444     {   &data_byte(0x0f,0x38,$opcodelet,0xc0|($1<<3)|$2);       }
 445 }
 446 sub sha1nexte   { sha1op38(0xc8,@_); }
 447 sub sha1msg1    { sha1op38(0xc9,@_); }
 448 sub sha1msg2    { sha1op38(0xca,@_); }
 449
 450 &function_begin("_sha1_block_data_order_shaext");
 451         &call   (&label("pic_point"));  # make it PIC!
 452         &set_label("pic_point");
 453         &blindpop($tmp1);
 454         &lea    ($tmp1,&DWP(&label("K_XX_XX")."-".&label("pic_point"),$tmp1));
 455 &set_label("shaext_shortcut");
 456         &mov    ($ctx,&wparam(0));
 457         &mov    ("ebx","esp");
 458         &mov    ($inp,&wparam(1));
 459         &mov    ($num,&wparam(2));
 460         &sub    ("esp",32);
 461
 462         &movdqu ($ABCD,&QWP(0,$ctx));
 463         &movd   ($E,&DWP(16,$ctx));
 464         &and    ("esp",-32);
 465         &movdqa ($BSWAP,&QWP(0x50,$tmp1));      # byte-n-word swap
 466
 467         &movdqu (@MSG[0],&QWP(0,$inp));
 468         &pshufd ($ABCD,$ABCD,0b00011011);       # flip word order
 469         &movdqu (@MSG[1],&QWP(0x10,$inp));
 470         &pshufd ($E,$E,0b00011011);             # flip word order
 471         &movdqu (@MSG[2],&QWP(0x20,$inp));
 472         &pshufb (@MSG[0],$BSWAP);
 473         &movdqu (@MSG[3],&QWP(0x30,$inp));
 474         &pshufb (@MSG[1],$BSWAP);
 475         &pshufb (@MSG[2],$BSWAP);
 476         &pshufb (@MSG[3],$BSWAP);
 477         &jmp    (&label("loop_shaext"));
 478
 479 &set_label("loop_shaext",16);
 480         &dec            ($num);
 481         &lea            ("eax",&DWP(0x40,$inp));
 482         &movdqa         (&QWP(0,"esp"),$E);     # offload $E
 483         &paddd          ($E,@MSG[0]);
 484         &cmovne         ($inp,"eax");
 485         &movdqa         (&QWP(16,"esp"),$ABCD); # offload $ABCD
 486
 487 for($i=0;$i<20-4;$i+=2) {
 488         &sha1msg1       (@MSG[0],@MSG[1]);
 489         &movdqa         ($E_,$ABCD);
 490         &sha1rnds4      ($ABCD,$E,int($i/5));   # 0-3...
 491         &sha1nexte      ($E_,@MSG[1]);
 492         &pxor           (@MSG[0],@MSG[2]);
 493         &sha1msg1       (@MSG[1],@MSG[2]);
 494         &sha1msg2       (@MSG[0],@MSG[3]);
 495
 496         &movdqa         ($E,$ABCD);
 497         &sha1rnds4      ($ABCD,$E_,int(($i+1)/5));
 498         &sha1nexte      ($E,@MSG[2]);
 499         &pxor           (@MSG[1],@MSG[3]);
 500         &sha1msg2       (@MSG[1],@MSG[0]);
 501
 502         push(@MSG,shift(@MSG)); push(@MSG,shift(@MSG));
 503 }
 504         &movdqu         (@MSG[0],&QWP(0,$inp));
 505         &movdqa         ($E_,$ABCD);
 506         &sha1rnds4      ($ABCD,$E,3);           # 64-67
 507         &sha1nexte      ($E_,@MSG[1]);
 508         &movdqu         (@MSG[1],&QWP(0x10,$inp));
 509         &pshufb         (@MSG[0],$BSWAP);
 510
 511         &movdqa         ($E,$ABCD);
 512         &sha1rnds4      ($ABCD,$E_,3);          # 68-71
 513         &sha1nexte      ($E,@MSG[2]);
 514         &movdqu         (@MSG[2],&QWP(0x20,$inp));
 515         &pshufb         (@MSG[1],$BSWAP);
 516
 517         &movdqa         ($E_,$ABCD);
 518         &sha1rnds4      ($ABCD,$E,3);           # 72-75
 519         &sha1nexte      ($E_,@MSG[3]);
 520         &movdqu         (@MSG[3],&QWP(0x30,$inp));
 521         &pshufb         (@MSG[2],$BSWAP);
 522
 523         &movdqa         ($E,$ABCD);
 524         &sha1rnds4      ($ABCD,$E_,3);          # 76-79
 525         &movdqa         ($E_,&QWP(0,"esp"));
 526         &pshufb         (@MSG[3],$BSWAP);
 527         &sha1nexte      ($E,$E_);
 528         &paddd          ($ABCD,&QWP(16,"esp"));
 529
 530         &jnz            (&label("loop_shaext"));
 531
 532         &pshufd ($ABCD,$ABCD,0b00011011);
 533         &pshufd ($E,$E,0b00011011);
 534         &movdqu (&QWP(0,$ctx),$ABCD)
 535         &movd   (&DWP(16,$ctx),$E);
 536         &mov    ("esp","ebx");
 537 &function_end("_sha1_block_data_order_shaext");
 538 }
 539 ######################################################################
 540 # The SSSE3 implementation.
 541 #
 542 # %xmm[0-7] are used as ring @X[] buffer containing quadruples of last
 543 # 32 elements of the message schedule or Xupdate outputs. First 4
 544 # quadruples are simply byte-swapped input, next 4 are calculated
 545 # according to method originally suggested by Dean Gaudet (modulo
 546 # being implemented in SSSE3). Once 8 quadruples or 32 elements are
 547 # collected, it switches to routine proposed by Max Locktyukhin.
 548 #
 549 # Calculations inevitably require temporary reqisters, and there are
 550 # no %xmm registers left to spare. For this reason part of the ring
 551 # buffer, X[2..4] to be specific, is offloaded to 3 quadriples ring
 552 # buffer on the stack. Keep in mind that X[2] is alias X[-6], X[3] -
 553 # X[-5], and X[4] - X[-4]...
 554 #
 555 # Another notable optimization is aggressive stack frame compression
 556 # aiming to minimize amount of 9-byte instructions...
 557 #
 558 # Yet another notable optimization is "jumping" $B variable. It means
 559 # that there is no register permanently allocated for $B value. This
 560 # allowed to eliminate one instruction from body_20_39...
 561 #
 562 my $Xi=4;                       # 4xSIMD Xupdate round, start pre-seeded
 563 my @X=map("xmm$_",(4..7,0..3)); # pre-seeded for $Xi=4
 564 my @V=($A,$B,$C,$D,$E);
 565 my $j=0;                        # hash round
 566 my $rx=0;
 567 my @T=($T,$tmp1);
 568 my $inp;
 569
 570 my $_rol=sub { &rol(@_) };
 571 my $_ror=sub { &ror(@_) };
 572
 573 &function_begin("_sha1_block_data_order_ssse3");
 574         &call   (&label("pic_point"));  # make it PIC!
 575         &set_label("pic_point");
 576         &blindpop($tmp1);
 577         &lea    ($tmp1,&DWP(&label("K_XX_XX")."-".&label("pic_point"),$tmp1));
 578 &set_label("ssse3_shortcut");
 579
 580         &movdqa (@X[3],&QWP(0,$tmp1));          # K_00_19
 581         &movdqa (@X[4],&QWP(16,$tmp1));         # K_20_39
 582         &movdqa (@X[5],&QWP(32,$tmp1));         # K_40_59
 583         &movdqa (@X[6],&QWP(48,$tmp1));         # K_60_79
 584         &movdqa (@X[2],&QWP(64,$tmp1));         # pbswap mask
 585
 586         &mov    ($E,&wparam(0));                # load argument block
 587         &mov    ($inp=@T[1],&wparam(1));
 588         &mov    ($D,&wparam(2));
 589         &mov    (@T[0],"esp");
 590
 591         # stack frame layout
 592         #
 593         # +0    X[0]+K  X[1]+K  X[2]+K  X[3]+K  # XMM->IALU xfer area
 594         #       X[4]+K  X[5]+K  X[6]+K  X[7]+K
 595         #       X[8]+K  X[9]+K  X[10]+K X[11]+K
 596         #       X[12]+K X[13]+K X[14]+K X[15]+K
 597         #
 598         # +64   X[0]    X[1]    X[2]    X[3]    # XMM->XMM backtrace area
 599         #       X[4]    X[5]    X[6]    X[7]
 600         #       X[8]    X[9]    X[10]   X[11]   # even borrowed for K_00_19
 601         #
 602         # +112  K_20_39 K_20_39 K_20_39 K_20_39 # constants
 603         #       K_40_59 K_40_59 K_40_59 K_40_59
 604         #       K_60_79 K_60_79 K_60_79 K_60_79
 605         #       K_00_19 K_00_19 K_00_19 K_00_19
 606         #       pbswap mask
 607         #
 608         # +192  ctx                             # argument block
 609         # +196  inp
 610         # +200  end
 611         # +204  esp
 612         &sub    ("esp",208);
 613         &and    ("esp",-64);
 614
 615         &movdqa (&QWP(112+0,"esp"),@X[4]);      # copy constants
 616         &movdqa (&QWP(112+16,"esp"),@X[5]);
 617         &movdqa (&QWP(112+32,"esp"),@X[6]);
 618         &shl    ($D,6);                         # len*64
 619         &movdqa (&QWP(112+48,"esp"),@X[3]);
 620         &add    ($D,$inp);                      # end of input
 621         &movdqa (&QWP(112+64,"esp"),@X[2]);
 622         &add    ($inp,64);
 623         &mov    (&DWP(192+0,"esp"),$E);         # save argument block
 624         &mov    (&DWP(192+4,"esp"),$inp);
 625         &mov    (&DWP(192+8,"esp"),$D);
 626         &mov    (&DWP(192+12,"esp"),@T[0]);     # save original %esp
 627
 628         &mov    ($A,&DWP(0,$E));                # load context
 629         &mov    ($B,&DWP(4,$E));
 630         &mov    ($C,&DWP(8,$E));
 631         &mov    ($D,&DWP(12,$E));
 632         &mov    ($E,&DWP(16,$E));
 633         &mov    (@T[0],$B);                     # magic seed
 634
 635         &movdqu (@X[-4&7],&QWP(-64,$inp));      # load input to %xmm[0-3]
 636         &movdqu (@X[-3&7],&QWP(-48,$inp));
 637         &movdqu (@X[-2&7],&QWP(-32,$inp));
 638         &movdqu (@X[-1&7],&QWP(-16,$inp));
 639         &pshufb (@X[-4&7],@X[2]);               # byte swap
 640         &pshufb (@X[-3&7],@X[2]);
 641         &pshufb (@X[-2&7],@X[2]);
 642         &movdqa (&QWP(112-16,"esp"),@X[3]);     # borrow last backtrace slot
 643         &pshufb (@X[-1&7],@X[2]);
 644         &paddd  (@X[-4&7],@X[3]);               # add K_00_19
 645         &paddd  (@X[-3&7],@X[3]);
 646         &paddd  (@X[-2&7],@X[3]);
 647         &movdqa (&QWP(0,"esp"),@X[-4&7]);       # X[]+K xfer to IALU
 648         &psubd  (@X[-4&7],@X[3]);               # restore X[]
 649         &movdqa (&QWP(0+16,"esp"),@X[-3&7]);
 650         &psubd  (@X[-3&7],@X[3]);
 651         &movdqa (&QWP(0+32,"esp"),@X[-2&7]);
 652         &mov    (@T[1],$C);
 653         &psubd  (@X[-2&7],@X[3]);
 654         &xor    (@T[1],$D);
 655         &pshufd (@X[0],@X[-4&7],0xee);          # was &movdqa   (@X[0],@X[-3&7]);
 656         &and    (@T[0],@T[1]);
 657         &jmp    (&label("loop"));
 658
 659 ######################################################################
 660 # SSE instruction sequence is first broken to groups of indepentent
 661 # instructions, independent in respect to their inputs and shifter
 662 # (not all architectures have more than one). Then IALU instructions
 663 # are "knitted in" between the SSE groups. Distance is maintained for
 664 # SSE latency of 2 in hope that it fits better upcoming AMD Bulldozer
 665 # [which allegedly also implements SSSE3]...
 666 #
 667 # Temporary registers usage. X[2] is volatile at the entry and at the
 668 # end is restored from backtrace ring buffer. X[3] is expected to
 669 # contain current K_XX_XX constant and is used to caclulate X[-1]+K
 670 # from previous round, it becomes volatile the moment the value is
 671 # saved to stack for transfer to IALU. X[4] becomes volatile whenever
 672 # X[-4] is accumulated and offloaded to backtrace ring buffer, at the
 673 # end it is loaded with next K_XX_XX [which becomes X[3] in next
 674 # round]...
 675 #
 676 sub Xupdate_ssse3_16_31()               # recall that $Xi starts wtih 4
 677 { use integer;
 678   my $body = shift;
 679   my @insns = (&$body,&$body,&$body,&$body);    # 40 instructions
 680   my ($a,$b,$c,$d,$e);
 681
 682          eval(shift(@insns));           # ror
 683          eval(shift(@insns));
 684          eval(shift(@insns));
 685         &punpcklqdq(@X[0],@X[-3&7]);    # compose "X[-14]" in "X[0]", was &palignr(@X[0],@X[-4&7],8);
 686         &movdqa (@X[2],@X[-1&7]);
 687          eval(shift(@insns));
 688          eval(shift(@insns));
 689
 690           &paddd        (@X[3],@X[-1&7]);
 691           &movdqa       (&QWP(64+16*(($Xi-4)%3),"esp"),@X[-4&7]);# save X[] to backtrace buffer
 692          eval(shift(@insns));           # rol
 693          eval(shift(@insns));
 694         &psrldq (@X[2],4);              # "X[-3]", 3 dwords
 695          eval(shift(@insns));
 696          eval(shift(@insns));
 697         &pxor   (@X[0],@X[-4&7]);       # "X[0]"^="X[-16]"
 698          eval(shift(@insns));
 699          eval(shift(@insns));           # ror
 700
 701         &pxor   (@X[2],@X[-2&7]);       # "X[-3]"^"X[-8]"
 702          eval(shift(@insns));
 703          eval(shift(@insns));
 704          eval(shift(@insns));
 705
 706         &pxor   (@X[0],@X[2]);          # "X[0]"^="X[-3]"^"X[-8]"
 707          eval(shift(@insns));
 708          eval(shift(@insns));           # rol
 709           &movdqa       (&QWP(0+16*(($Xi-1)&3),"esp"),@X[3]);   # X[]+K xfer to IALU
 710          eval(shift(@insns));
 711          eval(shift(@insns));
 712
 713         &movdqa (@X[4],@X[0]);
 714          eval(shift(@insns));
 715          eval(shift(@insns));
 716          eval(shift(@insns));           # ror
 717         &movdqa (@X[2],@X[0]);
 718          eval(shift(@insns));
 719
 720         &pslldq (@X[4],12);             # "X[0]"<<96, extract one dword
 721         &paddd  (@X[0],@X[0]);
 722          eval(shift(@insns));
 723          eval(shift(@insns));
 724
 725         &psrld  (@X[2],31);
 726          eval(shift(@insns));
 727          eval(shift(@insns));           # rol
 728         &movdqa (@X[3],@X[4]);
 729          eval(shift(@insns));
 730          eval(shift(@insns));
 731          eval(shift(@insns));
 732
 733         &psrld  (@X[4],30);
 734          eval(shift(@insns));
 735          eval(shift(@insns));           # ror
 736         &por    (@X[0],@X[2]);          # "X[0]"<<<=1
 737          eval(shift(@insns));
 738           &movdqa       (@X[2],&QWP(64+16*(($Xi-6)%3),"esp")) if ($Xi>5);       # restore X[] from backtrace buffer
 739          eval(shift(@insns));
 740          eval(shift(@insns));
 741
 742         &pslld  (@X[3],2);
 743          eval(shift(@insns));
 744          eval(shift(@insns));           # rol
 745         &pxor   (@X[0],@X[4]);
 746           &movdqa       (@X[4],&QWP(112-16+16*(($Xi)/5),"esp"));        # K_XX_XX
 747          eval(shift(@insns));
 748          eval(shift(@insns));
 749
 750         &pxor   (@X[0],@X[3]);          # "X[0]"^=("X[0]"<<96)<<<2
 751           &pshufd       (@X[1],@X[-3&7],0xee)   if ($Xi<7);     # was &movdqa   (@X[1],@X[-2&7])
 752           &pshufd       (@X[3],@X[-1&7],0xee)   if ($Xi==7);
 753          eval(shift(@insns));
 754          eval(shift(@insns));
 755
 756          foreach (@insns) { eval; }     # remaining instructions [if any]
 757
 758   $Xi++;        push(@X,shift(@X));     # "rotate" X[]
 759 }
 760
 761 sub Xupdate_ssse3_32_79()
 762 { use integer;
 763   my $body = shift;
 764   my @insns = (&$body,&$body,&$body,&$body);    # 32 to 44 instructions
 765   my ($a,$b,$c,$d,$e);
 766
 767          eval(shift(@insns));           # body_20_39
 768         &pxor   (@X[0],@X[-4&7]);       # "X[0]"="X[-32]"^"X[-16]"
 769         &punpcklqdq(@X[2],@X[-1&7]);    # compose "X[-6]", was &palignr(@X[2],@X[-2&7],8)
 770          eval(shift(@insns));
 771          eval(shift(@insns));
 772          eval(shift(@insns));           # rol
 773
 774         &pxor   (@X[0],@X[-7&7]);       # "X[0]"^="X[-28]"
 775           &movdqa       (&QWP(64+16*(($Xi-4)%3),"esp"),@X[-4&7]);       # save X[] to backtrace buffer
 776          eval(shift(@insns));
 777          eval(shift(@insns));
 778          eval(shift(@insns))            if (@insns[0] =~ /_rol/);
 779          if ($Xi%5) {
 780           &movdqa       (@X[4],@X[3]);  # "perpetuate" K_XX_XX...
 781          } else {                       # ... or load next one
 782           &movdqa       (@X[4],&QWP(112-16+16*($Xi/5),"esp"));
 783          }
 784          eval(shift(@insns));           # ror
 785           &paddd        (@X[3],@X[-1&7]);
 786          eval(shift(@insns));
 787
 788         &pxor   (@X[0],@X[2]);          # "X[0]"^="X[-6]"
 789          eval(shift(@insns));           # body_20_39
 790          eval(shift(@insns));
 791          eval(shift(@insns));
 792          eval(shift(@insns));           # rol
 793
 794         &movdqa (@X[2],@X[0]);
 795           &movdqa       (&QWP(0+16*(($Xi-1)&3),"esp"),@X[3]);   # X[]+K xfer to IALU
 796          eval(shift(@insns));
 797          eval(shift(@insns));
 798          eval(shift(@insns));           # ror
 799          eval(shift(@insns));
 800          eval(shift(@insns))            if (@insns[0] =~ /_rol/);
 801
 802         &pslld  (@X[0],2);
 803          eval(shift(@insns));           # body_20_39
 804          eval(shift(@insns));
 805         &psrld  (@X[2],30);
 806          eval(shift(@insns));
 807          eval(shift(@insns));           # rol
 808          eval(shift(@insns));
 809          eval(shift(@insns));
 810          eval(shift(@insns));           # ror
 811          eval(shift(@insns));
 812          eval(shift(@insns))            if (@insns[1] =~ /_rol/);
 813          eval(shift(@insns))            if (@insns[0] =~ /_rol/);
 814
 815         &por    (@X[0],@X[2]);          # "X[0]"<<<=2
 816          eval(shift(@insns));           # body_20_39
 817          eval(shift(@insns));
 818           &movdqa       (@X[2],&QWP(64+16*(($Xi-6)%3),"esp")) if($Xi<19);       # restore X[] from backtrace buffer
 819          eval(shift(@insns));
 820          eval(shift(@insns));           # rol
 821          eval(shift(@insns));
 822          eval(shift(@insns));
 823          eval(shift(@insns));           # ror
 824           &pshufd       (@X[3],@X[-1],0xee)     if ($Xi<19);    # was &movdqa   (@X[3],@X[0])
 825          eval(shift(@insns));
 826
 827          foreach (@insns) { eval; }     # remaining instructions
 828
 829   $Xi++;        push(@X,shift(@X));     # "rotate" X[]
 830 }
 831
 832 sub Xuplast_ssse3_80()
 833 { use integer;
 834   my $body = shift;
 835   my @insns = (&$body,&$body,&$body,&$body);    # 32 instructions
 836   my ($a,$b,$c,$d,$e);
 837
 838          eval(shift(@insns));
 839          eval(shift(@insns));
 840          eval(shift(@insns));
 841          eval(shift(@insns));
 842          eval(shift(@insns));
 843          eval(shift(@insns));
 844          eval(shift(@insns));
 845           &paddd        (@X[3],@X[-1&7]);
 846          eval(shift(@insns));
 847          eval(shift(@insns));
 848          eval(shift(@insns));
 849          eval(shift(@insns));
 850
 851           &movdqa       (&QWP(0+16*(($Xi-1)&3),"esp"),@X[3]);   # X[]+K xfer IALU
 852
 853          foreach (@insns) { eval; }             # remaining instructions
 854
 855         &mov    ($inp=@T[1],&DWP(192+4,"esp"));
 856         &cmp    ($inp,&DWP(192+8,"esp"));
 857         &je     (&label("done"));
 858
 859         &movdqa (@X[3],&QWP(112+48,"esp"));     # K_00_19
 860         &movdqa (@X[2],&QWP(112+64,"esp"));     # pbswap mask
 861         &movdqu (@X[-4&7],&QWP(0,$inp));        # load input
 862         &movdqu (@X[-3&7],&QWP(16,$inp));
 863         &movdqu (@X[-2&7],&QWP(32,$inp));
 864         &movdqu (@X[-1&7],&QWP(48,$inp));
 865         &add    ($inp,64);
 866         &pshufb (@X[-4&7],@X[2]);               # byte swap
 867         &mov    (&DWP(192+4,"esp"),$inp);
 868         &movdqa (&QWP(112-16,"esp"),@X[3]);     # borrow last backtrace slot
 869
 870   $Xi=0;
 871 }
 872
 873 sub Xloop_ssse3()
 874 { use integer;
 875   my $body = shift;
 876   my @insns = (&$body,&$body,&$body,&$body);    # 32 instructions
 877   my ($a,$b,$c,$d,$e);
 878
 879          eval(shift(@insns));
 880          eval(shift(@insns));
 881          eval(shift(@insns));
 882          eval(shift(@insns));
 883          eval(shift(@insns));
 884          eval(shift(@insns));
 885          eval(shift(@insns));
 886         &pshufb (@X[($Xi-3)&7],@X[2]);
 887          eval(shift(@insns));
 888          eval(shift(@insns));
 889          eval(shift(@insns));
 890          eval(shift(@insns));
 891         &paddd  (@X[($Xi-4)&7],@X[3]);
 892          eval(shift(@insns));
 893          eval(shift(@insns));
 894          eval(shift(@insns));
 895          eval(shift(@insns));
 896         &movdqa (&QWP(0+16*$Xi,"esp"),@X[($Xi-4)&7]);   # X[]+K xfer to IALU
 897          eval(shift(@insns));
 898          eval(shift(@insns));
 899          eval(shift(@insns));
 900          eval(shift(@insns));
 901         &psubd  (@X[($Xi-4)&7],@X[3]);
 902
 903         foreach (@insns) { eval; }
 904   $Xi++;
 905 }
 906
 907 sub Xtail_ssse3()
 908 { use integer;
 909   my $body = shift;
 910   my @insns = (&$body,&$body,&$body,&$body);    # 32 instructions
 911   my ($a,$b,$c,$d,$e);
 912
 913         foreach (@insns) { eval; }
 914 }
 915
 916 sub body_00_19 () {     # ((c^d)&b)^d
 917         # on start @T[0]=(c^d)&b
 918         return &body_20_39()    if ($rx==19);   $rx++;
 919         (
 920         '($a,$b,$c,$d,$e)=@V;'.
 921         '&$_ror ($b,$j?7:2);',  # $b>>>2
 922         '&xor   (@T[0],$d);',
 923         '&mov   (@T[1],$a);',   # $b in next round
 924
 925         '&add   ($e,&DWP(4*($j&15),"esp"));',   # X[]+K xfer
 926         '&xor   ($b,$c);',      # $c^$d for next round
 927
 928         '&$_rol ($a,5);',
 929         '&add   ($e,@T[0]);',
 930         '&and   (@T[1],$b);',   # ($b&($c^$d)) for next round
 931
 932         '&xor   ($b,$c);',      # restore $b
 933         '&add   ($e,$a);'       .'$j++; unshift(@V,pop(@V)); unshift(@T,pop(@T));'
 934         );
 935 }
 936
 937 sub body_20_39 () {     # b^d^c
 938         # on entry @T[0]=b^d
 939         return &body_40_59()    if ($rx==39);   $rx++;
 940         (
 941         '($a,$b,$c,$d,$e)=@V;'.
 942         '&add   ($e,&DWP(4*($j&15),"esp"));',   # X[]+K xfer
 943         '&xor   (@T[0],$d)      if($j==19);'.
 944         '&xor   (@T[0],$c)      if($j> 19);',   # ($b^$d^$c)
 945         '&mov   (@T[1],$a);',   # $b in next round
 946
 947         '&$_rol ($a,5);',
 948         '&add   ($e,@T[0]);',
 949         '&xor   (@T[1],$c)      if ($j< 79);',  # $b^$d for next round
 950
 951         '&$_ror ($b,7);',       # $b>>>2
 952         '&add   ($e,$a);'       .'$j++; unshift(@V,pop(@V)); unshift(@T,pop(@T));'
 953         );
 954 }
 955
 956 sub body_40_59 () {     # ((b^c)&(c^d))^c
 957         # on entry @T[0]=(b^c), (c^=d)
 958         $rx++;
 959         (
 960         '($a,$b,$c,$d,$e)=@V;'.
 961         '&add   ($e,&DWP(4*($j&15),"esp"));',   # X[]+K xfer
 962         '&and   (@T[0],$c)      if ($j>=40);',  # (b^c)&(c^d)
 963         '&xor   ($c,$d)         if ($j>=40);',  # restore $c
 964
 965         '&$_ror ($b,7);',       # $b>>>2
 966         '&mov   (@T[1],$a);',   # $b for next round
 967         '&xor   (@T[0],$c);',
 968
 969         '&$_rol ($a,5);',
 970         '&add   ($e,@T[0]);',
 971         '&xor   (@T[1],$c)      if ($j==59);'.
 972         '&xor   (@T[1],$b)      if ($j< 59);',  # b^c for next round
 973
 974         '&xor   ($b,$c)         if ($j< 59);',  # c^d for next round
 975         '&add   ($e,$a);'       .'$j++; unshift(@V,pop(@V)); unshift(@T,pop(@T));'
 976         );
 977 }
 978 ######
 979 sub bodyx_00_19 () {    # ((c^d)&b)^d
 980         # on start @T[0]=(b&c)^(~b&d), $e+=X[]+K
 981         return &bodyx_20_39()   if ($rx==19);   $rx++;
 982         (
 983         '($a,$b,$c,$d,$e)=@V;'.
 984
 985         '&rorx  ($b,$b,2)                       if ($j==0);'.   # $b>>>2
 986         '&rorx  ($b,@T[1],7)                    if ($j!=0);',   # $b>>>2
 987         '&lea   ($e,&DWP(0,$e,@T[0]));',
 988         '&rorx  (@T[0],$a,5);',
 989
 990         '&andn  (@T[1],$a,$c);',
 991         '&and   ($a,$b)',
 992         '&add   ($d,&DWP(4*(($j+1)&15),"esp"));',       # X[]+K xfer
 993
 994         '&xor   (@T[1],$a)',
 995         '&add   ($e,@T[0]);'    .'$j++; unshift(@V,pop(@V)); unshift(@T,pop(@T));'
 996         );
 997 }
 998
 999 sub bodyx_20_39 () {    # b^d^c
1000         # on start $b=b^c^d
1001         return &bodyx_40_59()   if ($rx==39);   $rx++;
1002         (
1003         '($a,$b,$c,$d,$e)=@V;'.
1004
1005         '&add   ($e,($j==19?@T[0]:$b))',
1006         '&rorx  ($b,@T[1],7);', # $b>>>2
1007         '&rorx  (@T[0],$a,5);',
1008
1009         '&xor   ($a,$b)                         if ($j<79);',
1010         '&add   ($d,&DWP(4*(($j+1)&15),"esp"))  if ($j<79);',   # X[]+K xfer
1011         '&xor   ($a,$c)                         if ($j<79);',
1012         '&add   ($e,@T[0]);'    .'$j++; unshift(@V,pop(@V)); unshift(@T,pop(@T));'
1013         );
1014 }
1015
1016 sub bodyx_40_59 () {    # ((b^c)&(c^d))^c
1017         # on start $b=((b^c)&(c^d))^c
1018         return &bodyx_20_39()   if ($rx==59);   $rx++;
1019         (
1020         '($a,$b,$c,$d,$e)=@V;'.
1021
1022         '&rorx  (@T[0],$a,5)',
1023         '&lea   ($e,&DWP(0,$e,$b))',
1024         '&rorx  ($b,@T[1],7)',  # $b>>>2
1025         '&add   ($d,&DWP(4*(($j+1)&15),"esp"))',        # X[]+K xfer
1026
1027         '&mov   (@T[1],$c)',
1028         '&xor   ($a,$b)',       # b^c for next round
1029         '&xor   (@T[1],$b)',    # c^d for next round
1030
1031         '&and   ($a,@T[1])',
1032         '&add   ($e,@T[0])',
1033         '&xor   ($a,$b)'        .'$j++; unshift(@V,pop(@V)); unshift(@T,pop(@T));'
1034         );
1035 }
1036
1037 &set_label("loop",16);
1038         &Xupdate_ssse3_16_31(\&body_00_19);
1039         &Xupdate_ssse3_16_31(\&body_00_19);
1040         &Xupdate_ssse3_16_31(\&body_00_19);
1041         &Xupdate_ssse3_16_31(\&body_00_19);
1042         &Xupdate_ssse3_32_79(\&body_00_19);
1043         &Xupdate_ssse3_32_79(\&body_20_39);
1044         &Xupdate_ssse3_32_79(\&body_20_39);
1045         &Xupdate_ssse3_32_79(\&body_20_39);
1046         &Xupdate_ssse3_32_79(\&body_20_39);
1047         &Xupdate_ssse3_32_79(\&body_20_39);
1048         &Xupdate_ssse3_32_79(\&body_40_59);
1049         &Xupdate_ssse3_32_79(\&body_40_59);
1050         &Xupdate_ssse3_32_79(\&body_40_59);
1051         &Xupdate_ssse3_32_79(\&body_40_59);
1052         &Xupdate_ssse3_32_79(\&body_40_59);
1053         &Xupdate_ssse3_32_79(\&body_20_39);
1054         &Xuplast_ssse3_80(\&body_20_39);        # can jump to "done"
1055
1056                                 $saved_j=$j; @saved_V=@V;
1057
1058         &Xloop_ssse3(\&body_20_39);
1059         &Xloop_ssse3(\&body_20_39);
1060         &Xloop_ssse3(\&body_20_39);
1061
1062         &mov    (@T[1],&DWP(192,"esp"));        # update context
1063         &add    ($A,&DWP(0,@T[1]));
1064         &add    (@T[0],&DWP(4,@T[1]));          # $b
1065         &add    ($C,&DWP(8,@T[1]));
1066         &mov    (&DWP(0,@T[1]),$A);
1067         &add    ($D,&DWP(12,@T[1]));
1068         &mov    (&DWP(4,@T[1]),@T[0]);
1069         &add    ($E,&DWP(16,@T[1]));
1070         &mov    (&DWP(8,@T[1]),$C);
1071         &mov    ($B,$C);
1072         &mov    (&DWP(12,@T[1]),$D);
1073         &xor    ($B,$D);
1074         &mov    (&DWP(16,@T[1]),$E);
1075         &mov    (@T[1],@T[0]);
1076         &pshufd (@X[0],@X[-4&7],0xee);          # was &movdqa   (@X[0],@X[-3&7]);
1077         &and    (@T[0],$B);
1078         &mov    ($B,$T[1]);
1079
1080         &jmp    (&label("loop"));
1081
1082 &set_label("done",16);          $j=$saved_j; @V=@saved_V;
1083
1084         &Xtail_ssse3(\&body_20_39);
1085         &Xtail_ssse3(\&body_20_39);
1086         &Xtail_ssse3(\&body_20_39);
1087
1088         &mov    (@T[1],&DWP(192,"esp"));        # update context
1089         &add    ($A,&DWP(0,@T[1]));
1090         &mov    ("esp",&DWP(192+12,"esp"));     # restore %esp
1091         &add    (@T[0],&DWP(4,@T[1]));          # $b
1092         &add    ($C,&DWP(8,@T[1]));
1093         &mov    (&DWP(0,@T[1]),$A);
1094         &add    ($D,&DWP(12,@T[1]));
1095         &mov    (&DWP(4,@T[1]),@T[0]);
1096         &add    ($E,&DWP(16,@T[1]));
1097         &mov    (&DWP(8,@T[1]),$C);
1098         &mov    (&DWP(12,@T[1]),$D);
1099         &mov    (&DWP(16,@T[1]),$E);
1100
1101 &function_end("_sha1_block_data_order_ssse3");
1102
1103 $rx=0;  # reset
1104
1105 if ($ymm) {
1106 my $Xi=4;                       # 4xSIMD Xupdate round, start pre-seeded
1107 my @X=map("xmm$_",(4..7,0..3)); # pre-seeded for $Xi=4
1108 my @V=($A,$B,$C,$D,$E);
1109 my $j=0;                        # hash round
1110 my @T=($T,$tmp1);
1111 my $inp;
1112
1113 my $_rol=sub { &shld(@_[0],@_) };
1114 my $_ror=sub { &shrd(@_[0],@_) };
1115
1116 &function_begin("_sha1_block_data_order_avx");
1117         &call   (&label("pic_point"));  # make it PIC!
1118         &set_label("pic_point");
1119         &blindpop($tmp1);
1120         &lea    ($tmp1,&DWP(&label("K_XX_XX")."-".&label("pic_point"),$tmp1));
1121 &set_label("avx_shortcut");
1122         &vzeroall();
1123
1124         &vmovdqa(@X[3],&QWP(0,$tmp1));          # K_00_19
1125         &vmovdqa(@X[4],&QWP(16,$tmp1));         # K_20_39
1126         &vmovdqa(@X[5],&QWP(32,$tmp1));         # K_40_59
1127         &vmovdqa(@X[6],&QWP(48,$tmp1));         # K_60_79
1128         &vmovdqa(@X[2],&QWP(64,$tmp1));         # pbswap mask
1129
1130         &mov    ($E,&wparam(0));                # load argument block
1131         &mov    ($inp=@T[1],&wparam(1));
1132         &mov    ($D,&wparam(2));
1133         &mov    (@T[0],"esp");
1134
1135         # stack frame layout
1136         #
1137         # +0    X[0]+K  X[1]+K  X[2]+K  X[3]+K  # XMM->IALU xfer area
1138         #       X[4]+K  X[5]+K  X[6]+K  X[7]+K
1139         #       X[8]+K  X[9]+K  X[10]+K X[11]+K
1140         #       X[12]+K X[13]+K X[14]+K X[15]+K
1141         #
1142         # +64   X[0]    X[1]    X[2]    X[3]    # XMM->XMM backtrace area
1143         #       X[4]    X[5]    X[6]    X[7]
1144         #       X[8]    X[9]    X[10]   X[11]   # even borrowed for K_00_19
1145         #
1146         # +112  K_20_39 K_20_39 K_20_39 K_20_39 # constants
1147         #       K_40_59 K_40_59 K_40_59 K_40_59
1148         #       K_60_79 K_60_79 K_60_79 K_60_79
1149         #       K_00_19 K_00_19 K_00_19 K_00_19
1150         #       pbswap mask
1151         #
1152         # +192  ctx                             # argument block
1153         # +196  inp
1154         # +200  end
1155         # +204  esp
1156         &sub    ("esp",208);
1157         &and    ("esp",-64);
1158
1159         &vmovdqa(&QWP(112+0,"esp"),@X[4]);      # copy constants
1160         &vmovdqa(&QWP(112+16,"esp"),@X[5]);
1161         &vmovdqa(&QWP(112+32,"esp"),@X[6]);
1162         &shl    ($D,6);                         # len*64
1163         &vmovdqa(&QWP(112+48,"esp"),@X[3]);
1164         &add    ($D,$inp);                      # end of input
1165         &vmovdqa(&QWP(112+64,"esp"),@X[2]);
1166         &add    ($inp,64);
1167         &mov    (&DWP(192+0,"esp"),$E);         # save argument block
1168         &mov    (&DWP(192+4,"esp"),$inp);
1169         &mov    (&DWP(192+8,"esp"),$D);
1170         &mov    (&DWP(192+12,"esp"),@T[0]);     # save original %esp
1171
1172         &mov    ($A,&DWP(0,$E));                # load context
1173         &mov    ($B,&DWP(4,$E));
1174         &mov    ($C,&DWP(8,$E));
1175         &mov    ($D,&DWP(12,$E));
1176         &mov    ($E,&DWP(16,$E));
1177         &mov    (@T[0],$B);                     # magic seed
1178
1179         &vmovdqu(@X[-4&7],&QWP(-64,$inp));      # load input to %xmm[0-3]
1180         &vmovdqu(@X[-3&7],&QWP(-48,$inp));
1181         &vmovdqu(@X[-2&7],&QWP(-32,$inp));
1182         &vmovdqu(@X[-1&7],&QWP(-16,$inp));
1183         &vpshufb(@X[-4&7],@X[-4&7],@X[2]);      # byte swap
1184         &vpshufb(@X[-3&7],@X[-3&7],@X[2]);
1185         &vpshufb(@X[-2&7],@X[-2&7],@X[2]);
1186         &vmovdqa(&QWP(112-16,"esp"),@X[3]);     # borrow last backtrace slot
1187         &vpshufb(@X[-1&7],@X[-1&7],@X[2]);
1188         &vpaddd (@X[0],@X[-4&7],@X[3]);         # add K_00_19
1189         &vpaddd (@X[1],@X[-3&7],@X[3]);
1190         &vpaddd (@X[2],@X[-2&7],@X[3]);
1191         &vmovdqa(&QWP(0,"esp"),@X[0]);          # X[]+K xfer to IALU
1192         &mov    (@T[1],$C);
1193         &vmovdqa(&QWP(0+16,"esp"),@X[1]);
1194         &xor    (@T[1],$D);
1195         &vmovdqa(&QWP(0+32,"esp"),@X[2]);
1196         &and    (@T[0],@T[1]);
1197         &jmp    (&label("loop"));
1198
1199 sub Xupdate_avx_16_31()         # recall that $Xi starts wtih 4
1200 { use integer;
1201   my $body = shift;
1202   my @insns = (&$body,&$body,&$body,&$body);    # 40 instructions
1203   my ($a,$b,$c,$d,$e);
1204
1205          eval(shift(@insns));
1206          eval(shift(@insns));
1207         &vpalignr(@X[0],@X[-3&7],@X[-4&7],8);   # compose "X[-14]" in "X[0]"
1208          eval(shift(@insns));
1209          eval(shift(@insns));
1210
1211           &vpaddd       (@X[3],@X[3],@X[-1&7]);
1212           &vmovdqa      (&QWP(64+16*(($Xi-4)%3),"esp"),@X[-4&7]);# save X[] to backtrace buffer
1213          eval(shift(@insns));
1214          eval(shift(@insns));
1215         &vpsrldq(@X[2],@X[-1&7],4);             # "X[-3]", 3 dwords
1216          eval(shift(@insns));
1217          eval(shift(@insns));
1218         &vpxor  (@X[0],@X[0],@X[-4&7]);         # "X[0]"^="X[-16]"
1219          eval(shift(@insns));
1220          eval(shift(@insns));
1221
1222         &vpxor  (@X[2],@X[2],@X[-2&7]);         # "X[-3]"^"X[-8]"
1223          eval(shift(@insns));
1224          eval(shift(@insns));
1225           &vmovdqa      (&QWP(0+16*(($Xi-1)&3),"esp"),@X[3]);   # X[]+K xfer to IALU
1226          eval(shift(@insns));
1227          eval(shift(@insns));
1228
1229         &vpxor  (@X[0],@X[0],@X[2]);            # "X[0]"^="X[-3]"^"X[-8]"
1230          eval(shift(@insns));
1231          eval(shift(@insns));
1232          eval(shift(@insns));
1233          eval(shift(@insns));
1234
1235         &vpsrld (@X[2],@X[0],31);
1236          eval(shift(@insns));
1237          eval(shift(@insns));
1238          eval(shift(@insns));
1239          eval(shift(@insns));
1240
1241         &vpslldq(@X[4],@X[0],12);               # "X[0]"<<96, extract one dword
1242         &vpaddd (@X[0],@X[0],@X[0]);
1243          eval(shift(@insns));
1244          eval(shift(@insns));
1245          eval(shift(@insns));
1246          eval(shift(@insns));
1247
1248         &vpsrld (@X[3],@X[4],30);
1249         &vpor   (@X[0],@X[0],@X[2]);            # "X[0]"<<<=1
1250          eval(shift(@insns));
1251          eval(shift(@insns));
1252          eval(shift(@insns));
1253          eval(shift(@insns));
1254
1255         &vpslld (@X[4],@X[4],2);
1256           &vmovdqa      (@X[2],&QWP(64+16*(($Xi-6)%3),"esp")) if ($Xi>5);       # restore X[] from backtrace buffer
1257          eval(shift(@insns));
1258          eval(shift(@insns));
1259         &vpxor  (@X[0],@X[0],@X[3]);
1260          eval(shift(@insns));
1261          eval(shift(@insns));
1262          eval(shift(@insns));
1263          eval(shift(@insns));
1264
1265         &vpxor  (@X[0],@X[0],@X[4]);            # "X[0]"^=("X[0]"<<96)<<<2
1266          eval(shift(@insns));
1267          eval(shift(@insns));
1268           &vmovdqa      (@X[4],&QWP(112-16+16*(($Xi)/5),"esp"));        # K_XX_XX
1269          eval(shift(@insns));
1270          eval(shift(@insns));
1271
1272          foreach (@insns) { eval; }     # remaining instructions [if any]
1273
1274   $Xi++;        push(@X,shift(@X));     # "rotate" X[]
1275 }
1276
1277 sub Xupdate_avx_32_79()
1278 { use integer;
1279   my $body = shift;
1280   my @insns = (&$body,&$body,&$body,&$body);    # 32 to 44 instructions
1281   my ($a,$b,$c,$d,$e);
1282
1283         &vpalignr(@X[2],@X[-1&7],@X[-2&7],8);   # compose "X[-6]"
1284         &vpxor  (@X[0],@X[0],@X[-4&7]); # "X[0]"="X[-32]"^"X[-16]"
1285          eval(shift(@insns));           # body_20_39
1286          eval(shift(@insns));
1287          eval(shift(@insns));
1288          eval(shift(@insns));           # rol
1289
1290         &vpxor  (@X[0],@X[0],@X[-7&7]); # "X[0]"^="X[-28]"
1291           &vmovdqa      (&QWP(64+16*(($Xi-4)%3),"esp"),@X[-4&7]);       # save X[] to backtrace buffer
1292          eval(shift(@insns));
1293          eval(shift(@insns));
1294          if ($Xi%5) {
1295           &vmovdqa      (@X[4],@X[3]);  # "perpetuate" K_XX_XX...
1296          } else {                       # ... or load next one
1297           &vmovdqa      (@X[4],&QWP(112-16+16*($Xi/5),"esp"));
1298          }
1299           &vpaddd       (@X[3],@X[3],@X[-1&7]);
1300          eval(shift(@insns));           # ror
1301          eval(shift(@insns));
1302
1303         &vpxor  (@X[0],@X[0],@X[2]);            # "X[0]"^="X[-6]"
1304          eval(shift(@insns));           # body_20_39
1305          eval(shift(@insns));
1306          eval(shift(@insns));
1307          eval(shift(@insns));           # rol
1308
1309         &vpsrld (@X[2],@X[0],30);
1310           &vmovdqa      (&QWP(0+16*(($Xi-1)&3),"esp"),@X[3]);   # X[]+K xfer to IALU
1311          eval(shift(@insns));
1312          eval(shift(@insns));
1313          eval(shift(@insns));           # ror
1314          eval(shift(@insns));
1315
1316         &vpslld (@X[0],@X[0],2);
1317          eval(shift(@insns));           # body_20_39
1318          eval(shift(@insns));
1319          eval(shift(@insns));
1320          eval(shift(@insns));           # rol
1321          eval(shift(@insns));
1322          eval(shift(@insns));
1323          eval(shift(@insns));           # ror
1324          eval(shift(@insns));
1325
1326         &vpor   (@X[0],@X[0],@X[2]);    # "X[0]"<<<=2
1327          eval(shift(@insns));           # body_20_39
1328          eval(shift(@insns));
1329           &vmovdqa      (@X[2],&QWP(64+16*(($Xi-6)%3),"esp")) if($Xi<19);       # restore X[] from backtrace buffer
1330          eval(shift(@insns));
1331          eval(shift(@insns));           # rol
1332          eval(shift(@insns));
1333          eval(shift(@insns));
1334          eval(shift(@insns));           # ror
1335          eval(shift(@insns));
1336
1337          foreach (@insns) { eval; }     # remaining instructions
1338
1339   $Xi++;        push(@X,shift(@X));     # "rotate" X[]
1340 }
1341
1342 sub Xuplast_avx_80()
1343 { use integer;
1344   my $body = shift;
1345   my @insns = (&$body,&$body,&$body,&$body);    # 32 instructions
1346   my ($a,$b,$c,$d,$e);
1347
1348          eval(shift(@insns));
1349           &vpaddd       (@X[3],@X[3],@X[-1&7]);
1350          eval(shift(@insns));
1351          eval(shift(@insns));
1352          eval(shift(@insns));
1353          eval(shift(@insns));
1354
1355           &vmovdqa      (&QWP(0+16*(($Xi-1)&3),"esp"),@X[3]);   # X[]+K xfer IALU
1356
1357          foreach (@insns) { eval; }             # remaining instructions
1358
1359         &mov    ($inp=@T[1],&DWP(192+4,"esp"));
1360         &cmp    ($inp,&DWP(192+8,"esp"));
1361         &je     (&label("done"));
1362
1363         &vmovdqa(@X[3],&QWP(112+48,"esp"));     # K_00_19
1364         &vmovdqa(@X[2],&QWP(112+64,"esp"));     # pbswap mask
1365         &vmovdqu(@X[-4&7],&QWP(0,$inp));        # load input
1366         &vmovdqu(@X[-3&7],&QWP(16,$inp));
1367         &vmovdqu(@X[-2&7],&QWP(32,$inp));
1368         &vmovdqu(@X[-1&7],&QWP(48,$inp));
1369         &add    ($inp,64);
1370         &vpshufb(@X[-4&7],@X[-4&7],@X[2]);              # byte swap
1371         &mov    (&DWP(192+4,"esp"),$inp);
1372         &vmovdqa(&QWP(112-16,"esp"),@X[3]);     # borrow last backtrace slot
1373
1374   $Xi=0;
1375 }
1376
1377 sub Xloop_avx()
1378 { use integer;
1379   my $body = shift;
1380   my @insns = (&$body,&$body,&$body,&$body);    # 32 instructions
1381   my ($a,$b,$c,$d,$e);
1382
1383          eval(shift(@insns));
1384          eval(shift(@insns));
1385         &vpshufb        (@X[($Xi-3)&7],@X[($Xi-3)&7],@X[2]);
1386          eval(shift(@insns));
1387          eval(shift(@insns));
1388         &vpaddd (@X[$Xi&7],@X[($Xi-4)&7],@X[3]);
1389          eval(shift(@insns));
1390          eval(shift(@insns));
1391          eval(shift(@insns));
1392          eval(shift(@insns));
1393         &vmovdqa        (&QWP(0+16*$Xi,"esp"),@X[$Xi&7]);       # X[]+K xfer to IALU
1394          eval(shift(@insns));
1395          eval(shift(@insns));
1396
1397         foreach (@insns) { eval; }
1398   $Xi++;
1399 }
1400
1401 sub Xtail_avx()
1402 { use integer;
1403   my $body = shift;
1404   my @insns = (&$body,&$body,&$body,&$body);    # 32 instructions
1405   my ($a,$b,$c,$d,$e);
1406
1407         foreach (@insns) { eval; }
1408 }
1409
1410 &set_label("loop",16);
1411         &Xupdate_avx_16_31(\&body_00_19);
1412         &Xupdate_avx_16_31(\&body_00_19);
1413         &Xupdate_avx_16_31(\&body_00_19);
1414         &Xupdate_avx_16_31(\&body_00_19);
1415         &Xupdate_avx_32_79(\&body_00_19);
1416         &Xupdate_avx_32_79(\&body_20_39);
1417         &Xupdate_avx_32_79(\&body_20_39);
1418         &Xupdate_avx_32_79(\&body_20_39);
1419         &Xupdate_avx_32_79(\&body_20_39);
1420         &Xupdate_avx_32_79(\&body_20_39);
1421         &Xupdate_avx_32_79(\&body_40_59);
1422         &Xupdate_avx_32_79(\&body_40_59);
1423         &Xupdate_avx_32_79(\&body_40_59);
1424         &Xupdate_avx_32_79(\&body_40_59);
1425         &Xupdate_avx_32_79(\&body_40_59);
1426         &Xupdate_avx_32_79(\&body_20_39);
1427         &Xuplast_avx_80(\&body_20_39);  # can jump to "done"
1428
1429                                 $saved_j=$j; @saved_V=@V;
1430
1431         &Xloop_avx(\&body_20_39);
1432         &Xloop_avx(\&body_20_39);
1433         &Xloop_avx(\&body_20_39);
1434
1435         &mov    (@T[1],&DWP(192,"esp"));        # update context
1436         &add    ($A,&DWP(0,@T[1]));
1437         &add    (@T[0],&DWP(4,@T[1]));          # $b
1438         &add    ($C,&DWP(8,@T[1]));
1439         &mov    (&DWP(0,@T[1]),$A);
1440         &add    ($D,&DWP(12,@T[1]));
1441         &mov    (&DWP(4,@T[1]),@T[0]);
1442         &add    ($E,&DWP(16,@T[1]));
1443         &mov    ($B,$C);
1444         &mov    (&DWP(8,@T[1]),$C);
1445         &xor    ($B,$D);
1446         &mov    (&DWP(12,@T[1]),$D);
1447         &mov    (&DWP(16,@T[1]),$E);
1448         &mov    (@T[1],@T[0]);
1449         &and    (@T[0],$B);
1450         &mov    ($B,@T[1]);
1451
1452         &jmp    (&label("loop"));
1453
1454 &set_label("done",16);          $j=$saved_j; @V=@saved_V;
1455
1456         &Xtail_avx(\&body_20_39);
1457         &Xtail_avx(\&body_20_39);
1458         &Xtail_avx(\&body_20_39);
1459
1460         &vzeroall();
1461
1462         &mov    (@T[1],&DWP(192,"esp"));        # update context
1463         &add    ($A,&DWP(0,@T[1]));
1464         &mov    ("esp",&DWP(192+12,"esp"));     # restore %esp
1465         &add    (@T[0],&DWP(4,@T[1]));          # $b
1466         &add    ($C,&DWP(8,@T[1]));
1467         &mov    (&DWP(0,@T[1]),$A);
1468         &add    ($D,&DWP(12,@T[1]));
1469         &mov    (&DWP(4,@T[1]),@T[0]);
1470         &add    ($E,&DWP(16,@T[1]));
1471         &mov    (&DWP(8,@T[1]),$C);
1472         &mov    (&DWP(12,@T[1]),$D);
1473         &mov    (&DWP(16,@T[1]),$E);
1474 &function_end("_sha1_block_data_order_avx");
1475 }
1476 &set_label("K_XX_XX",64);
1477 &data_word(0x5a827999,0x5a827999,0x5a827999,0x5a827999);        # K_00_19
1478 &data_word(0x6ed9eba1,0x6ed9eba1,0x6ed9eba1,0x6ed9eba1);        # K_20_39
1479 &data_word(0x8f1bbcdc,0x8f1bbcdc,0x8f1bbcdc,0x8f1bbcdc);        # K_40_59
1480 &data_word(0xca62c1d6,0xca62c1d6,0xca62c1d6,0xca62c1d6);        # K_60_79
1481 &data_word(0x00010203,0x04050607,0x08090a0b,0x0c0d0e0f);        # pbswap mask
1482 &data_byte(0xf,0xe,0xd,0xc,0xb,0xa,0x9,0x8,0x7,0x6,0x5,0x4,0x3,0x2,0x1,0x0);
1483 }
1484 &asciz("SHA1 block transform for x86, CRYPTOGAMS by <appro\@openssl.org>");
1485
1486 &asm_finish();
1487
1488 close STDOUT;