Source file src/crypto/internal/fips/sha512/_asm/sha512block_amd64_asm.go

     1  // Copyright 2024 The Go Authors. All rights reserved.
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package main
     6  
     7  import (
     8  	"os"
     9  
    10  	. "github.com/mmcloughlin/avo/build"
    11  	. "github.com/mmcloughlin/avo/operand"
    12  	. "github.com/mmcloughlin/avo/reg"
    13  )
    14  
    15  //go:generate go run . -out ../sha512block_amd64.s
    16  
    17  // SHA512 block routine. See sha512block.go for Go equivalent.
    18  //
    19  // The algorithm is detailed in FIPS 180-4:
    20  //
    21  //  https://csrc.nist.gov/publications/fips/fips180-4/fips-180-4.pdf
    22  //
    23  // Wt = Mt; for 0 <= t <= 15
    24  // Wt = SIGMA1(Wt-2) + SIGMA0(Wt-15) + Wt-16; for 16 <= t <= 79
    25  //
    26  // a = H0
    27  // b = H1
    28  // c = H2
    29  // d = H3
    30  // e = H4
    31  // f = H5
    32  // g = H6
    33  // h = H7
    34  //
    35  // for t = 0 to 79 {
    36  //    T1 = h + BIGSIGMA1(e) + Ch(e,f,g) + Kt + Wt
    37  //    T2 = BIGSIGMA0(a) + Maj(a,b,c)
    38  //    h = g
    39  //    g = f
    40  //    f = e
    41  //    e = d + T1
    42  //    d = c
    43  //    c = b
    44  //    b = a
    45  //    a = T1 + T2
    46  // }
    47  //
    48  // H0 = a + H0
    49  // H1 = b + H1
    50  // H2 = c + H2
    51  // H3 = d + H3
    52  // H4 = e + H4
    53  // H5 = f + H5
    54  // H6 = g + H6
    55  // H7 = h + H7
    56  
    57  const ThatPeskyUnicodeDot = "\u00b7"
    58  
    59  var _K = []uint64{
    60  	0x428a2f98d728ae22,
    61  	0x7137449123ef65cd,
    62  	0xb5c0fbcfec4d3b2f,
    63  	0xe9b5dba58189dbbc,
    64  	0x3956c25bf348b538,
    65  	0x59f111f1b605d019,
    66  	0x923f82a4af194f9b,
    67  	0xab1c5ed5da6d8118,
    68  	0xd807aa98a3030242,
    69  	0x12835b0145706fbe,
    70  	0x243185be4ee4b28c,
    71  	0x550c7dc3d5ffb4e2,
    72  	0x72be5d74f27b896f,
    73  	0x80deb1fe3b1696b1,
    74  	0x9bdc06a725c71235,
    75  	0xc19bf174cf692694,
    76  	0xe49b69c19ef14ad2,
    77  	0xefbe4786384f25e3,
    78  	0x0fc19dc68b8cd5b5,
    79  	0x240ca1cc77ac9c65,
    80  	0x2de92c6f592b0275,
    81  	0x4a7484aa6ea6e483,
    82  	0x5cb0a9dcbd41fbd4,
    83  	0x76f988da831153b5,
    84  	0x983e5152ee66dfab,
    85  	0xa831c66d2db43210,
    86  	0xb00327c898fb213f,
    87  	0xbf597fc7beef0ee4,
    88  	0xc6e00bf33da88fc2,
    89  	0xd5a79147930aa725,
    90  	0x06ca6351e003826f,
    91  	0x142929670a0e6e70,
    92  	0x27b70a8546d22ffc,
    93  	0x2e1b21385c26c926,
    94  	0x4d2c6dfc5ac42aed,
    95  	0x53380d139d95b3df,
    96  	0x650a73548baf63de,
    97  	0x766a0abb3c77b2a8,
    98  	0x81c2c92e47edaee6,
    99  	0x92722c851482353b,
   100  	0xa2bfe8a14cf10364,
   101  	0xa81a664bbc423001,
   102  	0xc24b8b70d0f89791,
   103  	0xc76c51a30654be30,
   104  	0xd192e819d6ef5218,
   105  	0xd69906245565a910,
   106  	0xf40e35855771202a,
   107  	0x106aa07032bbd1b8,
   108  	0x19a4c116b8d2d0c8,
   109  	0x1e376c085141ab53,
   110  	0x2748774cdf8eeb99,
   111  	0x34b0bcb5e19b48a8,
   112  	0x391c0cb3c5c95a63,
   113  	0x4ed8aa4ae3418acb,
   114  	0x5b9cca4f7763e373,
   115  	0x682e6ff3d6b2b8a3,
   116  	0x748f82ee5defb2fc,
   117  	0x78a5636f43172f60,
   118  	0x84c87814a1f0ab72,
   119  	0x8cc702081a6439ec,
   120  	0x90befffa23631e28,
   121  	0xa4506cebde82bde9,
   122  	0xbef9a3f7b2c67915,
   123  	0xc67178f2e372532b,
   124  	0xca273eceea26619c,
   125  	0xd186b8c721c0c207,
   126  	0xeada7dd6cde0eb1e,
   127  	0xf57d4f7fee6ed178,
   128  	0x06f067aa72176fba,
   129  	0x0a637dc5a2c898a6,
   130  	0x113f9804bef90dae,
   131  	0x1b710b35131c471b,
   132  	0x28db77f523047d84,
   133  	0x32caab7b40c72493,
   134  	0x3c9ebe0a15c9bebc,
   135  	0x431d67c49c100d4c,
   136  	0x4cc5d4becb3e42b6,
   137  	0x597f299cfc657e2a,
   138  	0x5fcb6fab3ad6faec,
   139  	0x6c44198c4a475817,
   140  }
   141  
   142  func main() {
   143  	// https://github.com/mmcloughlin/avo/issues/450
   144  	os.Setenv("GOOS", "linux")
   145  	os.Setenv("GOARCH", "amd64")
   146  
   147  	Package("crypto/internal/fips/sha512")
   148  	ConstraintExpr("!purego")
   149  	blockAMD64()
   150  	blockAVX2()
   151  	Generate()
   152  }
   153  
   154  // Wt = Mt; for 0 <= t <= 15
   155  //
   156  // Line 50
   157  func MSGSCHEDULE0(index int) {
   158  	MOVQ(Mem{Base: SI}.Offset(index*8), RAX)
   159  	BSWAPQ(RAX)
   160  	MOVQ(RAX, Mem{Base: BP}.Offset(index*8))
   161  }
   162  
   163  // Wt = SIGMA1(Wt-2) + Wt-7 + SIGMA0(Wt-15) + Wt-16; for 16 <= t <= 79
   164  //
   165  //	SIGMA0(x) = ROTR(1,x) XOR ROTR(8,x) XOR SHR(7,x)
   166  //	SIGMA1(x) = ROTR(19,x) XOR ROTR(61,x) XOR SHR(6,x)
   167  //
   168  // Line 58
   169  func MSGSCHEDULE1(index int) {
   170  	MOVQ(Mem{Base: BP}.Offset((index-2)*8), RAX)
   171  	MOVQ(RAX, RCX)
   172  	RORQ(Imm(19), RAX)
   173  	MOVQ(RCX, RDX)
   174  	RORQ(Imm(61), RCX)
   175  	SHRQ(Imm(6), RDX)
   176  	MOVQ(Mem{Base: BP}.Offset((index-15)*8), RBX)
   177  	XORQ(RCX, RAX)
   178  	MOVQ(RBX, RCX)
   179  	XORQ(RDX, RAX)
   180  	RORQ(Imm(1), RBX)
   181  	MOVQ(RCX, RDX)
   182  	SHRQ(Imm(7), RDX)
   183  	RORQ(Imm(8), RCX)
   184  	ADDQ(Mem{Base: BP}.Offset((index-7)*8), RAX)
   185  	XORQ(RCX, RBX)
   186  	XORQ(RDX, RBX)
   187  	ADDQ(Mem{Base: BP}.Offset((index-16)*8), RBX)
   188  	ADDQ(RBX, RAX)
   189  	MOVQ(RAX, Mem{Base: BP}.Offset((index)*8))
   190  }
   191  
   192  // Calculate T1 in AX - uses AX, CX and DX registers.
   193  // h is also used as an accumulator. Wt is passed in AX.
   194  //
   195  //	T1 = h + BIGSIGMA1(e) + Ch(e, f, g) + Kt + Wt
   196  //	  BIGSIGMA1(x) = ROTR(14,x) XOR ROTR(18,x) XOR ROTR(41,x)
   197  //	  Ch(x, y, z) = (x AND y) XOR (NOT x AND z)
   198  //
   199  // Line 85
   200  func SHA512T1(konst uint64, e, f, g, h GPPhysical) {
   201  	MOVQ(U64(konst), RDX)
   202  	ADDQ(RAX, h)
   203  	MOVQ(e, RAX)
   204  	ADDQ(RDX, h)
   205  	MOVQ(e, RCX)
   206  	RORQ(U8(14), RAX)
   207  	MOVQ(e, RDX)
   208  	RORQ(U8(18), RCX)
   209  	XORQ(RCX, RAX)
   210  	MOVQ(e, RCX)
   211  	RORQ(U8(41), RDX)
   212  	ANDQ(f, RCX)
   213  	XORQ(RAX, RDX)
   214  	MOVQ(e, RAX)
   215  	NOTQ(RAX)
   216  	ADDQ(RDX, h)
   217  	ANDQ(g, RAX)
   218  	XORQ(RCX, RAX)
   219  	ADDQ(h, RAX)
   220  }
   221  
   222  // Calculate T2 in BX - uses BX, CX, DX and DI registers.
   223  //
   224  //	T2 = BIGSIGMA0(a) + Maj(a, b, c)
   225  //	  BIGSIGMA0(x) = ROTR(28,x) XOR ROTR(34,x) XOR ROTR(39,x)
   226  //	  Maj(x, y, z) = (x AND y) XOR (x AND z) XOR (y AND z)
   227  //
   228  // Line 110
   229  func SHA512T2(a, b, c GPPhysical) {
   230  	MOVQ(a, RDI)
   231  	MOVQ(c, RBX)
   232  	RORQ(Imm(28), RDI)
   233  	MOVQ(a, RDX)
   234  	ANDQ(b, RBX)
   235  	RORQ(Imm(34), RDX)
   236  	MOVQ(a, RCX)
   237  	ANDQ(c, RCX)
   238  	XORQ(RDX, RDI)
   239  	XORQ(RCX, RBX)
   240  	MOVQ(a, RDX)
   241  	MOVQ(b, RCX)
   242  	RORQ(Imm(39), RDX)
   243  	ANDQ(a, RCX)
   244  	XORQ(RCX, RBX)
   245  	XORQ(RDX, RDI)
   246  	ADDQ(RDI, RBX)
   247  }
   248  
   249  // Calculate T1 and T2, then e = d + T1 and a = T1 + T2.
   250  // The values for e and a are stored in d and h, ready for rotation.
   251  //
   252  // Line 131
   253  func SHA512ROUND(index int, konst uint64, a, b, c, d, e, f, g, h GPPhysical) {
   254  	SHA512T1(konst, e, f, g, h)
   255  	SHA512T2(a, b, c)
   256  	MOVQ(RBX, h)
   257  	ADDQ(RAX, d)
   258  	ADDQ(RAX, h)
   259  }
   260  
   261  // Line 169
   262  func SHA512ROUND0(index int, konst uint64, a, b, c, d, e, f, g, h GPPhysical) {
   263  	MSGSCHEDULE0(index)
   264  	SHA512ROUND(index, konst, a, b, c, d, e, f, g, h)
   265  }
   266  
   267  // Line 142
   268  func SHA512ROUND1(index int, konst uint64, a, b, c, d, e, f, g, h GPPhysical) {
   269  	MSGSCHEDULE1(index)
   270  	SHA512ROUND(index, konst, a, b, c, d, e, f, g, h)
   271  }
   272  
   273  // Line 146
   274  func blockAMD64() {
   275  	Implement("blockAMD64")
   276  	AllocLocal(648)
   277  
   278  	Load(Param("p").Base(), RSI)
   279  	Load(Param("p").Len(), RDX)
   280  	SHRQ(Imm(7), RDX)
   281  	SHLQ(Imm(7), RDX)
   282  
   283  	LEAQ(Mem{Base: SI, Index: DX, Scale: 1}, RDI)
   284  	MOVQ(RDI, Mem{Base: SP}.Offset(640))
   285  	CMPQ(RSI, RDI)
   286  	JEQ(LabelRef("end"))
   287  
   288  	Load(Param("dig"), RBP)
   289  	MOVQ(Mem{Base: BP}.Offset(0*8), R8)  // a = H0
   290  	MOVQ(Mem{Base: BP}.Offset(1*8), R9)  // b = H1
   291  	MOVQ(Mem{Base: BP}.Offset(2*8), R10) // c = H2
   292  	MOVQ(Mem{Base: BP}.Offset(3*8), R11) // d = H3
   293  	MOVQ(Mem{Base: BP}.Offset(4*8), R12) // e = H4
   294  	MOVQ(Mem{Base: BP}.Offset(5*8), R13) // f = H5
   295  	MOVQ(Mem{Base: BP}.Offset(6*8), R14) // g = H6
   296  	MOVQ(Mem{Base: BP}.Offset(7*8), R15) // h = H7
   297  	PSHUFFLE_BYTE_FLIP_MASK_DATA()
   298  	loop()
   299  	end()
   300  }
   301  
   302  func rotateRight(slice *[]GPPhysical) []GPPhysical {
   303  	n := len(*slice)
   304  	new := make([]GPPhysical, n)
   305  	for i, reg := range *slice {
   306  		new[(i+1)%n] = reg
   307  	}
   308  	return new
   309  }
   310  
   311  // Line 167
   312  func loop() {
   313  	Label("loop")
   314  	MOVQ(RSP, RBP) // message schedule
   315  
   316  	n := len(_K)
   317  	regs := []GPPhysical{R8, R9, R10, R11, R12, R13, R14, R15}
   318  
   319  	for i := 0; i < 16; i++ {
   320  		SHA512ROUND0(i, _K[i], regs[0], regs[1], regs[2], regs[3], regs[4], regs[5], regs[6], regs[7])
   321  		regs = rotateRight(&regs)
   322  	}
   323  
   324  	for i := 16; i < n; i++ {
   325  		SHA512ROUND1(i, _K[i], regs[0], regs[1], regs[2], regs[3], regs[4], regs[5], regs[6], regs[7])
   326  		regs = rotateRight(&regs)
   327  	}
   328  
   329  	Load(Param("dig"), RBP)
   330  
   331  	BP_Mem := Mem{Base: BP}
   332  	ADDQ(BP_Mem.Offset(0*8), R8) // H0 = a + H0
   333  	MOVQ(R8, BP_Mem.Offset(0*8))
   334  	ADDQ(BP_Mem.Offset(1*8), R9) // H1 = b + H1
   335  	MOVQ(R9, BP_Mem.Offset(1*8))
   336  	ADDQ(BP_Mem.Offset(2*8), R10) // H2 = c + H2
   337  	MOVQ(R10, BP_Mem.Offset(2*8))
   338  	ADDQ(BP_Mem.Offset(3*8), R11) // H3 = d + H3
   339  	MOVQ(R11, BP_Mem.Offset(3*8))
   340  	ADDQ(BP_Mem.Offset(4*8), R12) // H4 = e + H4
   341  	MOVQ(R12, BP_Mem.Offset(4*8))
   342  	ADDQ(BP_Mem.Offset(5*8), R13) // H5 = f + H5
   343  	MOVQ(R13, BP_Mem.Offset(5*8))
   344  	ADDQ(BP_Mem.Offset(6*8), R14) // H6 = g + H6
   345  	MOVQ(R14, BP_Mem.Offset(6*8))
   346  	ADDQ(BP_Mem.Offset(7*8), R15) // H7 = h + H7
   347  	MOVQ(R15, BP_Mem.Offset(7*8))
   348  
   349  	ADDQ(Imm(128), RSI)
   350  	CMPQ(RSI, Mem{Base: SP}.Offset(640))
   351  	JB(LabelRef("loop"))
   352  }
   353  
   354  // Line 274
   355  func end() {
   356  	Label("end")
   357  	RET()
   358  }
   359  
   360  // Version below is based on "Fast SHA512 Implementations on Intel
   361  // Architecture Processors" White-paper
   362  // https://www.intel.com/content/dam/www/public/us/en/documents/white-papers/fast-sha512-implementations-ia-processors-paper.pdf
   363  // AVX2 version by Intel, same algorithm in Linux kernel:
   364  // https://github.com/torvalds/linux/blob/master/arch/x86/crypto/sha512-avx2-asm.S
   365  
   366  // James Guilford <james.guilford@intel.com>
   367  // Kirk Yap <kirk.s.yap@intel.com>
   368  // Tim Chen <tim.c.chen@linux.intel.com>
   369  // David Cote <david.m.cote@intel.com>
   370  // Aleksey Sidorov <aleksey.sidorov@intel.com>
   371  
   372  // Line 289
   373  var (
   374  	YFER_SIZE int = (4 * 8)
   375  	SRND_SIZE     = (1 * 8)
   376  	INP_SIZE      = (1 * 8)
   377  
   378  	frame_YFER   = (0)
   379  	frame_SRND   = (frame_YFER + YFER_SIZE)
   380  	frame_INP    = (frame_SRND + SRND_SIZE)
   381  	frame_INPEND = (frame_INP + INP_SIZE)
   382  )
   383  
   384  // Line 298
   385  func addm(p1 Mem, p2 GPPhysical) {
   386  	ADDQ(p1, p2)
   387  	MOVQ(p2, p1)
   388  }
   389  
   390  // Line 302
   391  func COPY_YMM_AND_BSWAP(p1 VecPhysical, p2 Mem, p3 VecPhysical) {
   392  	VMOVDQU(p2, p1)
   393  	VPSHUFB(p3, p1, p1)
   394  }
   395  
   396  // Line 306
   397  func MY_VPALIGNR(YDST, YSRC1, YSRC2 VecPhysical, RVAL int) {
   398  	VPERM2F128(U8(0x3), YSRC2, YSRC1, YDST)
   399  	VPALIGNR(U8(RVAL), YSRC2, YDST, YDST)
   400  }
   401  
   402  // Line 324
   403  func blockAVX2() {
   404  	Implement("blockAVX2")
   405  	Attributes(NOSPLIT)
   406  	AllocLocal(56)
   407  
   408  	Load(Param("dig"), RSI)
   409  	Load(Param("p").Base(), RDI)
   410  	Load(Param("p").Len(), RDX)
   411  
   412  	SHRQ(Imm(7), RDX)
   413  	SHLQ(Imm(7), RDX)
   414  
   415  	JZ(LabelRef("done_hash"))
   416  	ADDQ(RDI, RDX)
   417  	MOVQ(RDX, Mem{Base: SP}.Offset(frame_INPEND))
   418  
   419  	MOVQ(Mem{Base: SI}.Offset(0*8), RAX)
   420  	MOVQ(Mem{Base: SI}.Offset(1*8), RBX)
   421  	MOVQ(Mem{Base: SI}.Offset(2*8), RCX)
   422  	MOVQ(Mem{Base: SI}.Offset(3*8), R8)
   423  	MOVQ(Mem{Base: SI}.Offset(4*8), RDX)
   424  	MOVQ(Mem{Base: SI}.Offset(5*8), R9)
   425  	MOVQ(Mem{Base: SI}.Offset(6*8), R10)
   426  	MOVQ(Mem{Base: SI}.Offset(7*8), R11)
   427  
   428  	PSHUFFLE_BYTE_FLIP_MASK := PSHUFFLE_BYTE_FLIP_MASK_DATA()
   429  	VMOVDQU(PSHUFFLE_BYTE_FLIP_MASK, Y9)
   430  
   431  	loop0()
   432  	loop1()
   433  	loop2()
   434  	done_hash()
   435  }
   436  
   437  // Line 347
   438  func loop0() {
   439  	Label("loop0")
   440  
   441  	_K := NewDataAddr(Symbol{Name: "$" + ThatPeskyUnicodeDot + "_K"}, 0)
   442  	MOVQ(_K, RBP)
   443  
   444  	// byte swap first 16 dwords
   445  	COPY_YMM_AND_BSWAP(Y4, Mem{Base: DI}.Offset(0*32), Y9)
   446  	COPY_YMM_AND_BSWAP(Y5, Mem{Base: DI}.Offset(1*32), Y9)
   447  	COPY_YMM_AND_BSWAP(Y6, Mem{Base: DI}.Offset(2*32), Y9)
   448  	COPY_YMM_AND_BSWAP(Y7, Mem{Base: DI}.Offset(3*32), Y9)
   449  
   450  	MOVQ(RDI, Mem{Base: SP}.Offset(frame_INP))
   451  
   452  	// schedule 64 input dwords, by doing 12 rounds of 4 each
   453  	MOVQ(U32(4), Mem{Base: SP}.Offset(frame_SRND))
   454  }
   455  
   456  // Line 361
   457  func loop1() {
   458  	Label("loop1")
   459  	VPADDQ(Mem{Base: BP}, Y4, Y0)
   460  	VMOVDQU(Y0, Mem{Base: SP}.Offset(frame_YFER))
   461  
   462  	MY_VPALIGNR(Y0, Y7, Y6, 8)
   463  
   464  	VPADDQ(Y4, Y0, Y0)
   465  
   466  	MY_VPALIGNR(Y1, Y5, Y4, 8)
   467  
   468  	VPSRLQ(Imm(1), Y1, Y2)
   469  	VPSLLQ(Imm(64-1), Y1, Y3)
   470  	VPOR(Y2, Y3, Y3)
   471  
   472  	VPSRLQ(Imm(7), Y1, Y8)
   473  
   474  	MOVQ(RAX, RDI)
   475  	RORXQ(Imm(41), RDX, R13)
   476  	RORXQ(Imm(18), RDX, R14)
   477  	ADDQ(Mem{Base: SP}.Offset(frame_YFER), R11)
   478  	ORQ(RCX, RDI)
   479  	MOVQ(R9, R15)
   480  	RORXQ(Imm(34), RAX, R12)
   481  
   482  	XORQ(R14, R13)
   483  	XORQ(R10, R15)
   484  	RORXQ(Imm(14), RDX, R14)
   485  
   486  	ANDQ(RDX, R15)
   487  	XORQ(R14, R13)
   488  	RORXQ(Imm(39), RAX, R14)
   489  	ADDQ(R11, R8)
   490  
   491  	ANDQ(RBX, RDI)
   492  	XORQ(R12, R14)
   493  	RORXQ(Imm(28), RAX, R12)
   494  
   495  	XORQ(R10, R15)
   496  	XORQ(R12, R14)
   497  	MOVQ(RAX, R12)
   498  	ANDQ(RCX, R12)
   499  
   500  	ADDQ(R13, R15)
   501  	ORQ(R12, RDI)
   502  	ADDQ(R14, R11)
   503  
   504  	ADDQ(R15, R8)
   505  
   506  	ADDQ(R15, R11)
   507  	ADDQ(RDI, R11)
   508  
   509  	VPSRLQ(Imm(8), Y1, Y2)
   510  	VPSLLQ(Imm(64-8), Y1, Y1)
   511  	VPOR(Y2, Y1, Y1)
   512  
   513  	VPXOR(Y8, Y3, Y3)
   514  	VPXOR(Y1, Y3, Y1)
   515  
   516  	VPADDQ(Y1, Y0, Y0)
   517  
   518  	VPERM2F128(Imm(0x0), Y0, Y0, Y4)
   519  
   520  	MASK_YMM_LO := MASK_YMM_LO_DATA()
   521  	VPAND(MASK_YMM_LO, Y0, Y0)
   522  
   523  	VPERM2F128(Imm(0x11), Y7, Y7, Y2)
   524  	VPSRLQ(Imm(6), Y2, Y8)
   525  
   526  	MOVQ(R11, RDI)
   527  	RORXQ(Imm(41), R8, R13)
   528  	RORXQ(Imm(18), R8, R14)
   529  	ADDQ(Mem{Base: SP}.Offset(1*8+frame_YFER), R10)
   530  	ORQ(RBX, RDI)
   531  
   532  	MOVQ(RDX, R15)
   533  	RORXQ(Imm(34), R11, R12)
   534  	XORQ(R14, R13)
   535  	XORQ(R9, R15)
   536  
   537  	RORXQ(Imm(14), R8, R14)
   538  	XORQ(R14, R13)
   539  	RORXQ(Imm(39), R11, R14)
   540  	ANDQ(R8, R15)
   541  	ADDQ(R10, RCX)
   542  
   543  	ANDQ(RAX, RDI)
   544  	XORQ(R12, R14)
   545  
   546  	RORXQ(Imm(28), R11, R12)
   547  	XORQ(R9, R15)
   548  
   549  	XORQ(R12, R14)
   550  	MOVQ(R11, R12)
   551  	ANDQ(RBX, R12)
   552  	ADDQ(R13, R15)
   553  
   554  	ORQ(R12, RDI)
   555  	ADDQ(R14, R10)
   556  
   557  	ADDQ(R15, RCX)
   558  	ADDQ(R15, R10)
   559  	ADDQ(RDI, R10)
   560  
   561  	VPSRLQ(Imm(19), Y2, Y3)
   562  	VPSLLQ(Imm(64-19), Y2, Y1)
   563  	VPOR(Y1, Y3, Y3)
   564  	VPXOR(Y3, Y8, Y8)
   565  	VPSRLQ(Imm(61), Y2, Y3)
   566  	VPSLLQ(Imm(64-61), Y2, Y1)
   567  	VPOR(Y1, Y3, Y3)
   568  	VPXOR(Y3, Y8, Y8)
   569  
   570  	VPADDQ(Y8, Y4, Y4)
   571  
   572  	VPSRLQ(Imm(6), Y4, Y8)
   573  
   574  	MOVQ(R10, RDI)
   575  	RORXQ(Imm(41), RCX, R13)
   576  	ADDQ(Mem{Base: SP}.Offset(2*8+frame_YFER), R9)
   577  
   578  	RORXQ(Imm(18), RCX, R14)
   579  	ORQ(RAX, RDI)
   580  	MOVQ(R8, R15)
   581  	XORQ(RDX, R15)
   582  
   583  	RORXQ(Imm(34), R10, R12)
   584  	XORQ(R14, R13)
   585  	ANDQ(RCX, R15)
   586  
   587  	RORXQ(Imm(14), RCX, R14)
   588  	ADDQ(R9, RBX)
   589  	ANDQ(R11, RDI)
   590  
   591  	XORQ(R14, R13)
   592  	RORXQ(Imm(39), R10, R14)
   593  	XORQ(RDX, R15)
   594  
   595  	XORQ(R12, R14)
   596  	RORXQ(Imm(28), R10, R12)
   597  
   598  	XORQ(R12, R14)
   599  	MOVQ(R10, R12)
   600  	ANDQ(RAX, R12)
   601  	ADDQ(R13, R15)
   602  
   603  	ORQ(R12, RDI)
   604  	ADDQ(R14, R9)
   605  	ADDQ(R15, RBX)
   606  	ADDQ(R15, R9)
   607  
   608  	ADDQ(RDI, R9)
   609  
   610  	VPSRLQ(Imm(19), Y4, Y3)
   611  	VPSLLQ(Imm(64-19), Y4, Y1)
   612  	VPOR(Y1, Y3, Y3)
   613  	VPXOR(Y3, Y8, Y8)
   614  	VPSRLQ(Imm(61), Y4, Y3)
   615  	VPSLLQ(Imm(64-61), Y4, Y1)
   616  	VPOR(Y1, Y3, Y3)
   617  	VPXOR(Y3, Y8, Y8)
   618  
   619  	VPADDQ(Y8, Y0, Y2)
   620  
   621  	VPBLENDD(Imm(0xF0), Y2, Y4, Y4)
   622  
   623  	MOVQ(R9, RDI)
   624  	RORXQ(Imm(41), RBX, R13)
   625  	RORXQ(Imm(18), RBX, R14)
   626  	ADDQ(Mem{Base: SP}.Offset(3*8+frame_YFER), RDX)
   627  	ORQ(R11, RDI)
   628  
   629  	MOVQ(RCX, R15)
   630  	RORXQ(Imm(34), R9, R12)
   631  	XORQ(R14, R13)
   632  	XORQ(R8, R15)
   633  
   634  	RORXQ(Imm(14), RBX, R14)
   635  	ANDQ(RBX, R15)
   636  	ADDQ(RDX, RAX)
   637  	ANDQ(R10, RDI)
   638  
   639  	XORQ(R14, R13)
   640  	XORQ(R8, R15)
   641  
   642  	RORXQ(Imm(39), R9, R14)
   643  	ADDQ(R13, R15)
   644  
   645  	XORQ(R12, R14)
   646  	ADDQ(R15, RAX)
   647  
   648  	RORXQ(Imm(28), R9, R12)
   649  
   650  	XORQ(R12, R14)
   651  	MOVQ(R9, R12)
   652  	ANDQ(R11, R12)
   653  	ORQ(R12, RDI)
   654  
   655  	ADDQ(R14, RDX)
   656  	ADDQ(R15, RDX)
   657  	ADDQ(RDI, RDX)
   658  
   659  	VPADDQ(Mem{Base: BP}.Offset(1*32), Y5, Y0)
   660  	VMOVDQU(Y0, Mem{Base: SP}.Offset(frame_YFER))
   661  
   662  	MY_VPALIGNR(Y0, Y4, Y7, 8)
   663  
   664  	VPADDQ(Y5, Y0, Y0)
   665  
   666  	MY_VPALIGNR(Y1, Y6, Y5, 8)
   667  
   668  	VPSRLQ(Imm(1), Y1, Y2)
   669  	VPSLLQ(Imm(64-1), Y1, Y3)
   670  	VPOR(Y2, Y3, Y3)
   671  
   672  	VPSRLQ(Imm(7), Y1, Y8)
   673  
   674  	MOVQ(RDX, RDI)
   675  	RORXQ(Imm(41), RAX, R13)
   676  	RORXQ(Imm(18), RAX, R14)
   677  	ADDQ(Mem{Base: SP}.Offset(frame_YFER), R8)
   678  	ORQ(R10, RDI)
   679  	MOVQ(RBX, R15)
   680  	RORXQ(Imm(34), RDX, R12)
   681  
   682  	XORQ(R14, R13)
   683  	XORQ(RCX, R15)
   684  	RORXQ(Imm(14), RAX, R14)
   685  
   686  	ANDQ(RAX, R15)
   687  	XORQ(R14, R13)
   688  	RORXQ(Imm(39), RDX, R14)
   689  	ADDQ(R8, R11)
   690  
   691  	ANDQ(R9, RDI)
   692  	XORQ(R12, R14)
   693  	RORXQ(Imm(28), RDX, R12)
   694  
   695  	XORQ(RCX, R15)
   696  	XORQ(R12, R14)
   697  	MOVQ(RDX, R12)
   698  	ANDQ(R10, R12)
   699  
   700  	ADDQ(R13, R15)
   701  	ORQ(R12, RDI)
   702  	ADDQ(R14, R8)
   703  
   704  	ADDQ(R15, R11)
   705  
   706  	ADDQ(R15, R8)
   707  	ADDQ(RDI, R8)
   708  
   709  	VPSRLQ(Imm(8), Y1, Y2)
   710  	VPSLLQ(Imm(64-8), Y1, Y1)
   711  	VPOR(Y2, Y1, Y1)
   712  
   713  	VPXOR(Y8, Y3, Y3)
   714  	VPXOR(Y1, Y3, Y1)
   715  
   716  	VPADDQ(Y1, Y0, Y0)
   717  
   718  	VPERM2F128(Imm(0x0), Y0, Y0, Y5)
   719  
   720  	VPAND(MASK_YMM_LO, Y0, Y0)
   721  
   722  	VPERM2F128(Imm(0x11), Y4, Y4, Y2)
   723  	VPSRLQ(Imm(6), Y2, Y8)
   724  
   725  	MOVQ(R8, RDI)
   726  	RORXQ(Imm(41), R11, R13)
   727  	RORXQ(Imm(18), R11, R14)
   728  	ADDQ(Mem{Base: SP}.Offset(1*8+frame_YFER), RCX)
   729  	ORQ(R9, RDI)
   730  
   731  	MOVQ(RAX, R15)
   732  	RORXQ(Imm(34), R8, R12)
   733  	XORQ(R14, R13)
   734  	XORQ(RBX, R15)
   735  
   736  	RORXQ(Imm(14), R11, R14)
   737  	XORQ(R14, R13)
   738  	RORXQ(Imm(39), R8, R14)
   739  	ANDQ(R11, R15)
   740  	ADDQ(RCX, R10)
   741  
   742  	ANDQ(RDX, RDI)
   743  	XORQ(R12, R14)
   744  
   745  	RORXQ(Imm(28), R8, R12)
   746  	XORQ(RBX, R15)
   747  
   748  	XORQ(R12, R14)
   749  	MOVQ(R8, R12)
   750  	ANDQ(R9, R12)
   751  	ADDQ(R13, R15)
   752  
   753  	ORQ(R12, RDI)
   754  	ADDQ(R14, RCX)
   755  
   756  	ADDQ(R15, R10)
   757  	ADDQ(R15, RCX)
   758  	ADDQ(RDI, RCX)
   759  
   760  	VPSRLQ(Imm(19), Y2, Y3)
   761  	VPSLLQ(Imm(64-19), Y2, Y1)
   762  	VPOR(Y1, Y3, Y3)
   763  	VPXOR(Y3, Y8, Y8)
   764  	VPSRLQ(Imm(61), Y2, Y3)
   765  	VPSLLQ(Imm(64-61), Y2, Y1)
   766  	VPOR(Y1, Y3, Y3)
   767  	VPXOR(Y3, Y8, Y8)
   768  
   769  	VPADDQ(Y8, Y5, Y5)
   770  
   771  	VPSRLQ(Imm(6), Y5, Y8)
   772  
   773  	MOVQ(RCX, RDI)
   774  	RORXQ(Imm(41), R10, R13)
   775  	ADDQ(Mem{Base: SP}.Offset(2*8+frame_YFER), RBX)
   776  
   777  	RORXQ(Imm(18), R10, R14)
   778  	ORQ(RDX, RDI)
   779  	MOVQ(R11, R15)
   780  	XORQ(RAX, R15)
   781  
   782  	RORXQ(Imm(34), RCX, R12)
   783  	XORQ(R14, R13)
   784  	ANDQ(R10, R15)
   785  
   786  	RORXQ(Imm(14), R10, R14)
   787  	ADDQ(RBX, R9)
   788  	ANDQ(R8, RDI)
   789  
   790  	XORQ(R14, R13)
   791  	RORXQ(Imm(39), RCX, R14)
   792  	XORQ(RAX, R15)
   793  
   794  	XORQ(R12, R14)
   795  	RORXQ(Imm(28), RCX, R12)
   796  
   797  	XORQ(R12, R14)
   798  	MOVQ(RCX, R12)
   799  	ANDQ(RDX, R12)
   800  	ADDQ(R13, R15)
   801  
   802  	ORQ(R12, RDI)
   803  	ADDQ(R14, RBX)
   804  	ADDQ(R15, R9)
   805  	ADDQ(R15, RBX)
   806  
   807  	ADDQ(RDI, RBX)
   808  
   809  	VPSRLQ(Imm(19), Y5, Y3)
   810  	VPSLLQ(Imm(64-19), Y5, Y1)
   811  	VPOR(Y1, Y3, Y3)
   812  	VPXOR(Y3, Y8, Y8)
   813  	VPSRLQ(Imm(61), Y5, Y3)
   814  	VPSLLQ(Imm(64-61), Y5, Y1)
   815  	VPOR(Y1, Y3, Y3)
   816  	VPXOR(Y3, Y8, Y8)
   817  
   818  	VPADDQ(Y8, Y0, Y2)
   819  
   820  	VPBLENDD(Imm(0xF0), Y2, Y5, Y5)
   821  
   822  	MOVQ(RBX, RDI)
   823  	RORXQ(Imm(41), R9, R13)
   824  	RORXQ(Imm(18), R9, R14)
   825  	ADDQ(Mem{Base: SP}.Offset(3*8+frame_YFER), RAX)
   826  	ORQ(R8, RDI)
   827  
   828  	MOVQ(R10, R15)
   829  	RORXQ(Imm(34), RBX, R12)
   830  	XORQ(R14, R13)
   831  	XORQ(R11, R15)
   832  
   833  	RORXQ(Imm(14), R9, R14)
   834  	ANDQ(R9, R15)
   835  	ADDQ(RAX, RDX)
   836  	ANDQ(RCX, RDI)
   837  
   838  	XORQ(R14, R13)
   839  	XORQ(R11, R15)
   840  
   841  	RORXQ(Imm(39), RBX, R14)
   842  	ADDQ(R13, R15)
   843  
   844  	XORQ(R12, R14)
   845  	ADDQ(R15, RDX)
   846  
   847  	RORXQ(Imm(28), RBX, R12)
   848  
   849  	XORQ(R12, R14)
   850  	MOVQ(RBX, R12)
   851  	ANDQ(R8, R12)
   852  	ORQ(R12, RDI)
   853  
   854  	ADDQ(R14, RAX)
   855  	ADDQ(R15, RAX)
   856  	ADDQ(RDI, RAX)
   857  
   858  	VPADDQ(Mem{Base: BP}.Offset(2*32), Y6, Y0)
   859  	VMOVDQU(Y0, Mem{Base: SP}.Offset(frame_YFER))
   860  
   861  	MY_VPALIGNR(Y0, Y5, Y4, 8)
   862  
   863  	VPADDQ(Y6, Y0, Y0)
   864  
   865  	MY_VPALIGNR(Y1, Y7, Y6, 8)
   866  
   867  	VPSRLQ(Imm(1), Y1, Y2)
   868  	VPSLLQ(Imm(64-1), Y1, Y3)
   869  	VPOR(Y2, Y3, Y3)
   870  
   871  	VPSRLQ(Imm(7), Y1, Y8)
   872  
   873  	MOVQ(RAX, RDI)
   874  	RORXQ(Imm(41), RDX, R13)
   875  	RORXQ(Imm(18), RDX, R14)
   876  	ADDQ(Mem{Base: SP}.Offset(frame_YFER), R11)
   877  	ORQ(RCX, RDI)
   878  	MOVQ(R9, R15)
   879  	RORXQ(Imm(34), RAX, R12)
   880  
   881  	XORQ(R14, R13)
   882  	XORQ(R10, R15)
   883  	RORXQ(Imm(14), RDX, R14)
   884  
   885  	ANDQ(RDX, R15)
   886  	XORQ(R14, R13)
   887  	RORXQ(Imm(39), RAX, R14)
   888  	ADDQ(R11, R8)
   889  
   890  	ANDQ(RBX, RDI)
   891  	XORQ(R12, R14)
   892  	RORXQ(Imm(28), RAX, R12)
   893  
   894  	XORQ(R10, R15)
   895  	XORQ(R12, R14)
   896  	MOVQ(RAX, R12)
   897  	ANDQ(RCX, R12)
   898  
   899  	ADDQ(R13, R15)
   900  	ORQ(R12, RDI)
   901  	ADDQ(R14, R11)
   902  
   903  	ADDQ(R15, R8)
   904  
   905  	ADDQ(R15, R11)
   906  	ADDQ(RDI, R11)
   907  
   908  	VPSRLQ(Imm(8), Y1, Y2)
   909  	VPSLLQ(Imm(64-8), Y1, Y1)
   910  	VPOR(Y2, Y1, Y1)
   911  
   912  	VPXOR(Y8, Y3, Y3)
   913  	VPXOR(Y1, Y3, Y1)
   914  
   915  	VPADDQ(Y1, Y0, Y0)
   916  
   917  	VPERM2F128(Imm(0x0), Y0, Y0, Y6)
   918  
   919  	VPAND(MASK_YMM_LO, Y0, Y0)
   920  
   921  	VPERM2F128(Imm(0x11), Y5, Y5, Y2)
   922  	VPSRLQ(Imm(6), Y2, Y8)
   923  
   924  	MOVQ(R11, RDI)
   925  	RORXQ(Imm(41), R8, R13)
   926  	RORXQ(Imm(18), R8, R14)
   927  	ADDQ(Mem{Base: SP}.Offset(1*8+frame_YFER), R10)
   928  	ORQ(RBX, RDI)
   929  
   930  	MOVQ(RDX, R15)
   931  	RORXQ(Imm(34), R11, R12)
   932  	XORQ(R14, R13)
   933  	XORQ(R9, R15)
   934  
   935  	RORXQ(Imm(14), R8, R14)
   936  	XORQ(R14, R13)
   937  	RORXQ(Imm(39), R11, R14)
   938  	ANDQ(R8, R15)
   939  	ADDQ(R10, RCX)
   940  
   941  	ANDQ(RAX, RDI)
   942  	XORQ(R12, R14)
   943  
   944  	RORXQ(Imm(28), R11, R12)
   945  	XORQ(R9, R15)
   946  
   947  	XORQ(R12, R14)
   948  	MOVQ(R11, R12)
   949  	ANDQ(RBX, R12)
   950  	ADDQ(R13, R15)
   951  
   952  	ORQ(R12, RDI)
   953  	ADDQ(R14, R10)
   954  
   955  	ADDQ(R15, RCX)
   956  	ADDQ(R15, R10)
   957  	ADDQ(RDI, R10)
   958  
   959  	VPSRLQ(Imm(19), Y2, Y3)
   960  	VPSLLQ(Imm(64-19), Y2, Y1)
   961  	VPOR(Y1, Y3, Y3)
   962  	VPXOR(Y3, Y8, Y8)
   963  	VPSRLQ(Imm(61), Y2, Y3)
   964  	VPSLLQ(Imm(64-61), Y2, Y1)
   965  	VPOR(Y1, Y3, Y3)
   966  	VPXOR(Y3, Y8, Y8)
   967  
   968  	VPADDQ(Y8, Y6, Y6)
   969  
   970  	VPSRLQ(Imm(6), Y6, Y8)
   971  
   972  	MOVQ(R10, RDI)
   973  	RORXQ(Imm(41), RCX, R13)
   974  	ADDQ(Mem{Base: SP}.Offset(2*8+frame_YFER), R9)
   975  
   976  	RORXQ(Imm(18), RCX, R14)
   977  	ORQ(RAX, RDI)
   978  	MOVQ(R8, R15)
   979  	XORQ(RDX, R15)
   980  
   981  	RORXQ(Imm(34), R10, R12)
   982  	XORQ(R14, R13)
   983  	ANDQ(RCX, R15)
   984  
   985  	RORXQ(Imm(14), RCX, R14)
   986  	ADDQ(R9, RBX)
   987  	ANDQ(R11, RDI)
   988  
   989  	XORQ(R14, R13)
   990  	RORXQ(Imm(39), R10, R14)
   991  	XORQ(RDX, R15)
   992  
   993  	XORQ(R12, R14)
   994  	RORXQ(Imm(28), R10, R12)
   995  
   996  	XORQ(R12, R14)
   997  	MOVQ(R10, R12)
   998  	ANDQ(RAX, R12)
   999  	ADDQ(R13, R15)
  1000  
  1001  	ORQ(R12, RDI)
  1002  	ADDQ(R14, R9)
  1003  	ADDQ(R15, RBX)
  1004  	ADDQ(R15, R9)
  1005  
  1006  	ADDQ(RDI, R9)
  1007  
  1008  	VPSRLQ(Imm(19), Y6, Y3)
  1009  	VPSLLQ(Imm(64-19), Y6, Y1)
  1010  	VPOR(Y1, Y3, Y3)
  1011  	VPXOR(Y3, Y8, Y8)
  1012  	VPSRLQ(Imm(61), Y6, Y3)
  1013  	VPSLLQ(Imm(64-61), Y6, Y1)
  1014  	VPOR(Y1, Y3, Y3)
  1015  	VPXOR(Y3, Y8, Y8)
  1016  
  1017  	VPADDQ(Y8, Y0, Y2)
  1018  
  1019  	VPBLENDD(Imm(0xF0), Y2, Y6, Y6)
  1020  
  1021  	MOVQ(R9, RDI)
  1022  	RORXQ(Imm(41), RBX, R13)
  1023  	RORXQ(Imm(18), RBX, R14)
  1024  	ADDQ(Mem{Base: SP}.Offset(3*8+frame_YFER), RDX)
  1025  	ORQ(R11, RDI)
  1026  
  1027  	MOVQ(RCX, R15)
  1028  	RORXQ(Imm(34), R9, R12)
  1029  	XORQ(R14, R13)
  1030  	XORQ(R8, R15)
  1031  
  1032  	RORXQ(Imm(14), RBX, R14)
  1033  	ANDQ(RBX, R15)
  1034  	ADDQ(RDX, RAX)
  1035  	ANDQ(R10, RDI)
  1036  
  1037  	XORQ(R14, R13)
  1038  	XORQ(R8, R15)
  1039  
  1040  	RORXQ(Imm(39), R9, R14)
  1041  	ADDQ(R13, R15)
  1042  
  1043  	XORQ(R12, R14)
  1044  	ADDQ(R15, RAX)
  1045  
  1046  	RORXQ(Imm(28), R9, R12)
  1047  
  1048  	XORQ(R12, R14)
  1049  	MOVQ(R9, R12)
  1050  	ANDQ(R11, R12)
  1051  	ORQ(R12, RDI)
  1052  
  1053  	ADDQ(R14, RDX)
  1054  	ADDQ(R15, RDX)
  1055  	ADDQ(RDI, RDX)
  1056  
  1057  	VPADDQ(Mem{Base: BP}.Offset(3*32), Y7, Y0)
  1058  	VMOVDQU(Y0, Mem{Base: SP}.Offset(frame_YFER))
  1059  	ADDQ(U8(4*32), RBP)
  1060  
  1061  	MY_VPALIGNR(Y0, Y6, Y5, 8)
  1062  
  1063  	VPADDQ(Y7, Y0, Y0)
  1064  
  1065  	MY_VPALIGNR(Y1, Y4, Y7, 8)
  1066  
  1067  	VPSRLQ(Imm(1), Y1, Y2)
  1068  	VPSLLQ(Imm(64-1), Y1, Y3)
  1069  	VPOR(Y2, Y3, Y3)
  1070  
  1071  	VPSRLQ(Imm(7), Y1, Y8)
  1072  
  1073  	MOVQ(RDX, RDI)
  1074  	RORXQ(Imm(41), RAX, R13)
  1075  	RORXQ(Imm(18), RAX, R14)
  1076  	ADDQ(Mem{Base: SP}.Offset(frame_YFER), R8)
  1077  	ORQ(R10, RDI)
  1078  	MOVQ(RBX, R15)
  1079  	RORXQ(Imm(34), RDX, R12)
  1080  
  1081  	XORQ(R14, R13)
  1082  	XORQ(RCX, R15)
  1083  	RORXQ(Imm(14), RAX, R14)
  1084  
  1085  	ANDQ(RAX, R15)
  1086  	XORQ(R14, R13)
  1087  	RORXQ(Imm(39), RDX, R14)
  1088  	ADDQ(R8, R11)
  1089  
  1090  	ANDQ(R9, RDI)
  1091  	XORQ(R12, R14)
  1092  	RORXQ(Imm(28), RDX, R12)
  1093  
  1094  	XORQ(RCX, R15)
  1095  	XORQ(R12, R14)
  1096  	MOVQ(RDX, R12)
  1097  	ANDQ(R10, R12)
  1098  
  1099  	ADDQ(R13, R15)
  1100  	ORQ(R12, RDI)
  1101  	ADDQ(R14, R8)
  1102  
  1103  	ADDQ(R15, R11)
  1104  
  1105  	ADDQ(R15, R8)
  1106  	ADDQ(RDI, R8)
  1107  
  1108  	VPSRLQ(Imm(8), Y1, Y2)
  1109  	VPSLLQ(Imm(64-8), Y1, Y1)
  1110  	VPOR(Y2, Y1, Y1)
  1111  
  1112  	VPXOR(Y8, Y3, Y3)
  1113  	VPXOR(Y1, Y3, Y1)
  1114  
  1115  	VPADDQ(Y1, Y0, Y0)
  1116  
  1117  	VPERM2F128(Imm(0x0), Y0, Y0, Y7)
  1118  
  1119  	VPAND(MASK_YMM_LO, Y0, Y0)
  1120  
  1121  	VPERM2F128(Imm(0x11), Y6, Y6, Y2)
  1122  	VPSRLQ(Imm(6), Y2, Y8)
  1123  
  1124  	MOVQ(R8, RDI)
  1125  	RORXQ(Imm(41), R11, R13)
  1126  	RORXQ(Imm(18), R11, R14)
  1127  	ADDQ(Mem{Base: SP}.Offset(1*8+frame_YFER), RCX)
  1128  	ORQ(R9, RDI)
  1129  
  1130  	MOVQ(RAX, R15)
  1131  	RORXQ(Imm(34), R8, R12)
  1132  	XORQ(R14, R13)
  1133  	XORQ(RBX, R15)
  1134  
  1135  	RORXQ(Imm(14), R11, R14)
  1136  	XORQ(R14, R13)
  1137  	RORXQ(Imm(39), R8, R14)
  1138  	ANDQ(R11, R15)
  1139  	ADDQ(RCX, R10)
  1140  
  1141  	ANDQ(RDX, RDI)
  1142  	XORQ(R12, R14)
  1143  
  1144  	RORXQ(Imm(28), R8, R12)
  1145  	XORQ(RBX, R15)
  1146  
  1147  	XORQ(R12, R14)
  1148  	MOVQ(R8, R12)
  1149  	ANDQ(R9, R12)
  1150  	ADDQ(R13, R15)
  1151  
  1152  	ORQ(R12, RDI)
  1153  	ADDQ(R14, RCX)
  1154  
  1155  	ADDQ(R15, R10)
  1156  	ADDQ(R15, RCX)
  1157  	ADDQ(RDI, RCX)
  1158  
  1159  	VPSRLQ(Imm(19), Y2, Y3)
  1160  	VPSLLQ(Imm(64-19), Y2, Y1)
  1161  	VPOR(Y1, Y3, Y3)
  1162  	VPXOR(Y3, Y8, Y8)
  1163  	VPSRLQ(Imm(61), Y2, Y3)
  1164  	VPSLLQ(Imm(64-61), Y2, Y1)
  1165  	VPOR(Y1, Y3, Y3)
  1166  	VPXOR(Y3, Y8, Y8)
  1167  
  1168  	VPADDQ(Y8, Y7, Y7)
  1169  
  1170  	VPSRLQ(Imm(6), Y7, Y8)
  1171  
  1172  	MOVQ(RCX, RDI)
  1173  	RORXQ(Imm(41), R10, R13)
  1174  	ADDQ(Mem{Base: SP}.Offset(2*8+frame_YFER), RBX)
  1175  
  1176  	RORXQ(Imm(18), R10, R14)
  1177  	ORQ(RDX, RDI)
  1178  	MOVQ(R11, R15)
  1179  	XORQ(RAX, R15)
  1180  
  1181  	RORXQ(Imm(34), RCX, R12)
  1182  	XORQ(R14, R13)
  1183  	ANDQ(R10, R15)
  1184  
  1185  	RORXQ(Imm(14), R10, R14)
  1186  	ADDQ(RBX, R9)
  1187  	ANDQ(R8, RDI)
  1188  
  1189  	XORQ(R14, R13)
  1190  	RORXQ(Imm(39), RCX, R14)
  1191  	XORQ(RAX, R15)
  1192  
  1193  	XORQ(R12, R14)
  1194  	RORXQ(Imm(28), RCX, R12)
  1195  
  1196  	XORQ(R12, R14)
  1197  	MOVQ(RCX, R12)
  1198  	ANDQ(RDX, R12)
  1199  	ADDQ(R13, R15)
  1200  
  1201  	ORQ(R12, RDI)
  1202  	ADDQ(R14, RBX)
  1203  	ADDQ(R15, R9)
  1204  	ADDQ(R15, RBX)
  1205  
  1206  	ADDQ(RDI, RBX)
  1207  
  1208  	VPSRLQ(Imm(19), Y7, Y3)
  1209  	VPSLLQ(Imm(64-19), Y7, Y1)
  1210  	VPOR(Y1, Y3, Y3)
  1211  	VPXOR(Y3, Y8, Y8)
  1212  	VPSRLQ(Imm(61), Y7, Y3)
  1213  	VPSLLQ(Imm(64-61), Y7, Y1)
  1214  	VPOR(Y1, Y3, Y3)
  1215  	VPXOR(Y3, Y8, Y8)
  1216  
  1217  	VPADDQ(Y8, Y0, Y2)
  1218  
  1219  	VPBLENDD(Imm(0xF0), Y2, Y7, Y7)
  1220  
  1221  	MOVQ(RBX, RDI)
  1222  	RORXQ(Imm(41), R9, R13)
  1223  	RORXQ(Imm(18), R9, R14)
  1224  	ADDQ(Mem{Base: SP}.Offset(3*8+frame_YFER), RAX)
  1225  	ORQ(R8, RDI)
  1226  
  1227  	MOVQ(R10, R15)
  1228  	RORXQ(Imm(34), RBX, R12)
  1229  	XORQ(R14, R13)
  1230  	XORQ(R11, R15)
  1231  
  1232  	RORXQ(Imm(14), R9, R14)
  1233  	ANDQ(R9, R15)
  1234  	ADDQ(RAX, RDX)
  1235  	ANDQ(RCX, RDI)
  1236  
  1237  	XORQ(R14, R13)
  1238  	XORQ(R11, R15)
  1239  
  1240  	RORXQ(Imm(39), RBX, R14)
  1241  	ADDQ(R13, R15)
  1242  
  1243  	XORQ(R12, R14)
  1244  	ADDQ(R15, RDX)
  1245  
  1246  	RORXQ(Imm(28), RBX, R12)
  1247  
  1248  	XORQ(R12, R14)
  1249  	MOVQ(RBX, R12)
  1250  	ANDQ(R8, R12)
  1251  	ORQ(R12, RDI)
  1252  
  1253  	ADDQ(R14, RAX)
  1254  	ADDQ(R15, RAX)
  1255  	ADDQ(RDI, RAX)
  1256  
  1257  	SUBQ(Imm(1), Mem{Base: SP}.Offset(frame_SRND))
  1258  	JNE(LabelRef("loop1"))
  1259  
  1260  	MOVQ(U32(2), Mem{Base: SP}.Offset(frame_SRND))
  1261  }
  1262  
  1263  // Line 1164
  1264  func loop2() {
  1265  	Label("loop2")
  1266  	VPADDQ(Mem{Base: BP}, Y4, Y0)
  1267  	VMOVDQU(Y0, Mem{Base: SP}.Offset(frame_YFER))
  1268  
  1269  	MOVQ(R9, R15)
  1270  	RORXQ(Imm(41), RDX, R13)
  1271  	RORXQ(Imm(18), RDX, R14)
  1272  	XORQ(R10, R15)
  1273  
  1274  	XORQ(R14, R13)
  1275  	RORXQ(Imm(14), RDX, R14)
  1276  	ANDQ(RDX, R15)
  1277  
  1278  	XORQ(R14, R13)
  1279  	RORXQ(Imm(34), RAX, R12)
  1280  	XORQ(R10, R15)
  1281  	RORXQ(Imm(39), RAX, R14)
  1282  	MOVQ(RAX, RDI)
  1283  
  1284  	XORQ(R12, R14)
  1285  	RORXQ(Imm(28), RAX, R12)
  1286  	ADDQ(Mem{Base: SP}.Offset(frame_YFER), R11)
  1287  	ORQ(RCX, RDI)
  1288  
  1289  	XORQ(R12, R14)
  1290  	MOVQ(RAX, R12)
  1291  	ANDQ(RBX, RDI)
  1292  	ANDQ(RCX, R12)
  1293  	ADDQ(R13, R15)
  1294  
  1295  	ADDQ(R11, R8)
  1296  	ORQ(R12, RDI)
  1297  	ADDQ(R14, R11)
  1298  
  1299  	ADDQ(R15, R8)
  1300  
  1301  	ADDQ(R15, R11)
  1302  	MOVQ(RDX, R15)
  1303  	RORXQ(Imm(41), R8, R13)
  1304  	RORXQ(Imm(18), R8, R14)
  1305  	XORQ(R9, R15)
  1306  
  1307  	XORQ(R14, R13)
  1308  	RORXQ(Imm(14), R8, R14)
  1309  	ANDQ(R8, R15)
  1310  	ADDQ(RDI, R11)
  1311  
  1312  	XORQ(R14, R13)
  1313  	RORXQ(Imm(34), R11, R12)
  1314  	XORQ(R9, R15)
  1315  	RORXQ(Imm(39), R11, R14)
  1316  	MOVQ(R11, RDI)
  1317  
  1318  	XORQ(R12, R14)
  1319  	RORXQ(Imm(28), R11, R12)
  1320  	ADDQ(Mem{Base: SP}.Offset(8*1+frame_YFER), R10)
  1321  	ORQ(RBX, RDI)
  1322  
  1323  	XORQ(R12, R14)
  1324  	MOVQ(R11, R12)
  1325  	ANDQ(RAX, RDI)
  1326  	ANDQ(RBX, R12)
  1327  	ADDQ(R13, R15)
  1328  
  1329  	ADDQ(R10, RCX)
  1330  	ORQ(R12, RDI)
  1331  	ADDQ(R14, R10)
  1332  
  1333  	ADDQ(R15, RCX)
  1334  
  1335  	ADDQ(R15, R10)
  1336  	MOVQ(R8, R15)
  1337  	RORXQ(Imm(41), RCX, R13)
  1338  	RORXQ(Imm(18), RCX, R14)
  1339  	XORQ(RDX, R15)
  1340  
  1341  	XORQ(R14, R13)
  1342  	RORXQ(Imm(14), RCX, R14)
  1343  	ANDQ(RCX, R15)
  1344  	ADDQ(RDI, R10)
  1345  
  1346  	XORQ(R14, R13)
  1347  	RORXQ(Imm(34), R10, R12)
  1348  	XORQ(RDX, R15)
  1349  	RORXQ(Imm(39), R10, R14)
  1350  	MOVQ(R10, RDI)
  1351  
  1352  	XORQ(R12, R14)
  1353  	RORXQ(Imm(28), R10, R12)
  1354  	ADDQ(Mem{Base: SP}.Offset(8*2+frame_YFER), R9)
  1355  	ORQ(RAX, RDI)
  1356  
  1357  	XORQ(R12, R14)
  1358  	MOVQ(R10, R12)
  1359  	ANDQ(R11, RDI)
  1360  	ANDQ(RAX, R12)
  1361  	ADDQ(R13, R15)
  1362  
  1363  	ADDQ(R9, RBX)
  1364  	ORQ(R12, RDI)
  1365  	ADDQ(R14, R9)
  1366  
  1367  	ADDQ(R15, RBX)
  1368  
  1369  	ADDQ(R15, R9)
  1370  	MOVQ(RCX, R15)
  1371  	RORXQ(Imm(41), RBX, R13)
  1372  	RORXQ(Imm(18), RBX, R14)
  1373  	XORQ(R8, R15)
  1374  
  1375  	XORQ(R14, R13)
  1376  	RORXQ(Imm(14), RBX, R14)
  1377  	ANDQ(RBX, R15)
  1378  	ADDQ(RDI, R9)
  1379  
  1380  	XORQ(R14, R13)
  1381  	RORXQ(Imm(34), R9, R12)
  1382  	XORQ(R8, R15)
  1383  	RORXQ(Imm(39), R9, R14)
  1384  	MOVQ(R9, RDI)
  1385  
  1386  	XORQ(R12, R14)
  1387  	RORXQ(Imm(28), R9, R12)
  1388  	ADDQ(Mem{Base: SP}.Offset(8*3+frame_YFER), RDX)
  1389  	ORQ(R11, RDI)
  1390  
  1391  	XORQ(R12, R14)
  1392  	MOVQ(R9, R12)
  1393  	ANDQ(R10, RDI)
  1394  	ANDQ(R11, R12)
  1395  	ADDQ(R13, R15)
  1396  
  1397  	ADDQ(RDX, RAX)
  1398  	ORQ(R12, RDI)
  1399  	ADDQ(R14, RDX)
  1400  
  1401  	ADDQ(R15, RAX)
  1402  
  1403  	ADDQ(R15, RDX)
  1404  
  1405  	ADDQ(RDI, RDX)
  1406  
  1407  	VPADDQ(Mem{Base: BP}.Offset(1*32), Y5, Y0)
  1408  	VMOVDQU(Y0, Mem{Base: SP}.Offset(frame_YFER))
  1409  	ADDQ(U8(2*32), RBP)
  1410  
  1411  	MOVQ(RBX, R15)
  1412  	RORXQ(Imm(41), RAX, R13)
  1413  	RORXQ(Imm(18), RAX, R14)
  1414  	XORQ(RCX, R15)
  1415  
  1416  	XORQ(R14, R13)
  1417  	RORXQ(Imm(14), RAX, R14)
  1418  	ANDQ(RAX, R15)
  1419  
  1420  	XORQ(R14, R13)
  1421  	RORXQ(Imm(34), RDX, R12)
  1422  	XORQ(RCX, R15)
  1423  	RORXQ(Imm(39), RDX, R14)
  1424  	MOVQ(RDX, RDI)
  1425  
  1426  	XORQ(R12, R14)
  1427  	RORXQ(Imm(28), RDX, R12)
  1428  	ADDQ(Mem{Base: SP}.Offset(frame_YFER), R8)
  1429  	ORQ(R10, RDI)
  1430  
  1431  	XORQ(R12, R14)
  1432  	MOVQ(RDX, R12)
  1433  	ANDQ(R9, RDI)
  1434  	ANDQ(R10, R12)
  1435  	ADDQ(R13, R15)
  1436  
  1437  	ADDQ(R8, R11)
  1438  	ORQ(R12, RDI)
  1439  	ADDQ(R14, R8)
  1440  
  1441  	ADDQ(R15, R11)
  1442  
  1443  	ADDQ(R15, R8)
  1444  	MOVQ(RAX, R15)
  1445  	RORXQ(Imm(41), R11, R13)
  1446  	RORXQ(Imm(18), R11, R14)
  1447  	XORQ(RBX, R15)
  1448  
  1449  	XORQ(R14, R13)
  1450  	RORXQ(Imm(14), R11, R14)
  1451  	ANDQ(R11, R15)
  1452  	ADDQ(RDI, R8)
  1453  
  1454  	XORQ(R14, R13)
  1455  	RORXQ(Imm(34), R8, R12)
  1456  	XORQ(RBX, R15)
  1457  	RORXQ(Imm(39), R8, R14)
  1458  	MOVQ(R8, RDI)
  1459  
  1460  	XORQ(R12, R14)
  1461  	RORXQ(Imm(28), R8, R12)
  1462  	ADDQ(Mem{Base: SP}.Offset(8*1+frame_YFER), RCX)
  1463  	ORQ(R9, RDI)
  1464  
  1465  	XORQ(R12, R14)
  1466  	MOVQ(R8, R12)
  1467  	ANDQ(RDX, RDI)
  1468  	ANDQ(R9, R12)
  1469  	ADDQ(R13, R15)
  1470  
  1471  	ADDQ(RCX, R10)
  1472  	ORQ(R12, RDI)
  1473  	ADDQ(R14, RCX)
  1474  
  1475  	ADDQ(R15, R10)
  1476  
  1477  	ADDQ(R15, RCX)
  1478  	MOVQ(R11, R15)
  1479  	RORXQ(Imm(41), R10, R13)
  1480  	RORXQ(Imm(18), R10, R14)
  1481  	XORQ(RAX, R15)
  1482  
  1483  	XORQ(R14, R13)
  1484  	RORXQ(Imm(14), R10, R14)
  1485  	ANDQ(R10, R15)
  1486  	ADDQ(RDI, RCX)
  1487  
  1488  	XORQ(R14, R13)
  1489  	RORXQ(Imm(34), RCX, R12)
  1490  	XORQ(RAX, R15)
  1491  	RORXQ(Imm(39), RCX, R14)
  1492  	MOVQ(RCX, RDI)
  1493  
  1494  	XORQ(R12, R14)
  1495  	RORXQ(Imm(28), RCX, R12)
  1496  	ADDQ(Mem{Base: SP}.Offset(8*2+frame_YFER), RBX)
  1497  	ORQ(RDX, RDI)
  1498  
  1499  	XORQ(R12, R14)
  1500  	MOVQ(RCX, R12)
  1501  	ANDQ(R8, RDI)
  1502  	ANDQ(RDX, R12)
  1503  	ADDQ(R13, R15)
  1504  
  1505  	ADDQ(RBX, R9)
  1506  	ORQ(R12, RDI)
  1507  	ADDQ(R14, RBX)
  1508  
  1509  	ADDQ(R15, R9)
  1510  
  1511  	ADDQ(R15, RBX)
  1512  	MOVQ(R10, R15)
  1513  	RORXQ(Imm(41), R9, R13)
  1514  	RORXQ(Imm(18), R9, R14)
  1515  	XORQ(R11, R15)
  1516  
  1517  	XORQ(R14, R13)
  1518  	RORXQ(Imm(14), R9, R14)
  1519  	ANDQ(R9, R15)
  1520  	ADDQ(RDI, RBX)
  1521  
  1522  	XORQ(R14, R13)
  1523  	RORXQ(Imm(34), RBX, R12)
  1524  	XORQ(R11, R15)
  1525  	RORXQ(Imm(39), RBX, R14)
  1526  	MOVQ(RBX, RDI)
  1527  
  1528  	XORQ(R12, R14)
  1529  	RORXQ(Imm(28), RBX, R12)
  1530  	ADDQ(Mem{Base: SP}.Offset(8*3+frame_YFER), RAX)
  1531  	ORQ(R8, RDI)
  1532  
  1533  	XORQ(R12, R14)
  1534  	MOVQ(RBX, R12)
  1535  	ANDQ(RCX, RDI)
  1536  	ANDQ(R8, R12)
  1537  	ADDQ(R13, R15)
  1538  
  1539  	ADDQ(RAX, RDX)
  1540  	ORQ(R12, RDI)
  1541  	ADDQ(R14, RAX)
  1542  
  1543  	ADDQ(R15, RDX)
  1544  
  1545  	ADDQ(R15, RAX)
  1546  
  1547  	ADDQ(RDI, RAX)
  1548  
  1549  	VMOVDQU(Y6, Y4)
  1550  	VMOVDQU(Y7, Y5)
  1551  
  1552  	SUBQ(Imm(1), Mem{Base: SP}.Offset(frame_SRND))
  1553  	JNE(LabelRef("loop2"))
  1554  
  1555  	addm(Mem{Base: SI}.Offset(8*0), RAX)
  1556  	addm(Mem{Base: SI}.Offset(8*1), RBX)
  1557  	addm(Mem{Base: SI}.Offset(8*2), RCX)
  1558  	addm(Mem{Base: SI}.Offset(8*3), R8)
  1559  	addm(Mem{Base: SI}.Offset(8*4), RDX)
  1560  	addm(Mem{Base: SI}.Offset(8*5), R9)
  1561  	addm(Mem{Base: SI}.Offset(8*6), R10)
  1562  	addm(Mem{Base: SI}.Offset(8*7), R11)
  1563  
  1564  	MOVQ(Mem{Base: SP}.Offset(frame_INP), RDI)
  1565  	ADDQ(Imm(128), RDI)
  1566  	CMPQ(RDI, Mem{Base: SP}.Offset(frame_INPEND))
  1567  	JNE(LabelRef("loop0"))
  1568  }
  1569  
  1570  // Line 1468
  1571  func done_hash() {
  1572  	Label("done_hash")
  1573  	VZEROUPPER()
  1574  	RET()
  1575  }
  1576  
  1577  // ##~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~DATA SECTION~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~##
  1578  
  1579  // Pointers for memoizing Data section symbols
  1580  var PSHUFFLE_BYTE_FLIP_MASK_DATA_ptr, MASK_YMM_LO_ptr *Mem
  1581  
  1582  // Line 310
  1583  func PSHUFFLE_BYTE_FLIP_MASK_DATA() Mem {
  1584  	if PSHUFFLE_BYTE_FLIP_MASK_DATA_ptr != nil {
  1585  		return *PSHUFFLE_BYTE_FLIP_MASK_DATA_ptr
  1586  	}
  1587  
  1588  	PSHUFFLE_BYTE_FLIP_MASK_DATA := GLOBL("PSHUFFLE_BYTE_FLIP_MASK", NOPTR|RODATA)
  1589  	PSHUFFLE_BYTE_FLIP_MASK_DATA_ptr = &PSHUFFLE_BYTE_FLIP_MASK_DATA
  1590  	DATA(0x00, U64(0x0001020304050607))
  1591  	DATA(0x08, U64(0x08090a0b0c0d0e0f))
  1592  	DATA(0x10, U64(0x1011121314151617))
  1593  	DATA(0x18, U64(0x18191a1b1c1d1e1f))
  1594  	return PSHUFFLE_BYTE_FLIP_MASK_DATA
  1595  }
  1596  
  1597  // Line 317
  1598  func MASK_YMM_LO_DATA() Mem {
  1599  	if MASK_YMM_LO_ptr != nil {
  1600  		return *MASK_YMM_LO_ptr
  1601  	}
  1602  
  1603  	MASK_YMM_LO := GLOBL("MASK_YMM_LO", NOPTR|RODATA)
  1604  	MASK_YMM_LO_ptr = &MASK_YMM_LO
  1605  	DATA(0x00, U64(0x0000000000000000))
  1606  	DATA(0x08, U64(0x0000000000000000))
  1607  	DATA(0x10, U64(0xFFFFFFFFFFFFFFFF))
  1608  	DATA(0x18, U64(0xFFFFFFFFFFFFFFFF))
  1609  	return MASK_YMM_LO
  1610  }
  1611  

View as plain text