summaryrefslogtreecommitdiff
path: root/vendor/golang.org/x/crypto/blake2s
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/golang.org/x/crypto/blake2s')
-rw-r--r--vendor/golang.org/x/crypto/blake2s/blake2s.go254
-rw-r--r--vendor/golang.org/x/crypto/blake2s/blake2s_386.go32
-rw-r--r--vendor/golang.org/x/crypto/blake2s/blake2s_386.s429
-rw-r--r--vendor/golang.org/x/crypto/blake2s/blake2s_amd64.go37
-rw-r--r--vendor/golang.org/x/crypto/blake2s/blake2s_amd64.s2173
-rw-r--r--vendor/golang.org/x/crypto/blake2s/blake2s_generic.go178
-rw-r--r--vendor/golang.org/x/crypto/blake2s/blake2s_ref.go17
-rw-r--r--vendor/golang.org/x/crypto/blake2s/blake2x.go178
8 files changed, 0 insertions, 3298 deletions
diff --git a/vendor/golang.org/x/crypto/blake2s/blake2s.go b/vendor/golang.org/x/crypto/blake2s/blake2s.go
deleted file mode 100644
index c25d07d4f..000000000
--- a/vendor/golang.org/x/crypto/blake2s/blake2s.go
+++ /dev/null
@@ -1,254 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-// Package blake2s implements the BLAKE2s hash algorithm defined by RFC 7693
-// and the extendable output function (XOF) BLAKE2Xs.
-//
-// BLAKE2s is optimized for 8- to 32-bit platforms and produces digests of any
-// size between 1 and 32 bytes.
-// For a detailed specification of BLAKE2s see https://blake2.net/blake2.pdf
-// and for BLAKE2Xs see https://blake2.net/blake2x.pdf
-//
-// If you aren't sure which function you need, use BLAKE2s (Sum256 or New256).
-// If you need a secret-key MAC (message authentication code), use the New256
-// function with a non-nil key.
-//
-// BLAKE2X is a construction to compute hash values larger than 32 bytes. It
-// can produce hash values between 0 and 65535 bytes.
-package blake2s
-
-import (
- "crypto"
- "encoding/binary"
- "errors"
- "hash"
-)
-
-const (
- // The blocksize of BLAKE2s in bytes.
- BlockSize = 64
-
- // The hash size of BLAKE2s-256 in bytes.
- Size = 32
-
- // The hash size of BLAKE2s-128 in bytes.
- Size128 = 16
-)
-
-var errKeySize = errors.New("blake2s: invalid key size")
-
-var iv = [8]uint32{
- 0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
- 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
-}
-
-// Sum256 returns the BLAKE2s-256 checksum of the data.
-func Sum256(data []byte) [Size]byte {
- var sum [Size]byte
- checkSum(&sum, Size, data)
- return sum
-}
-
-// New256 returns a new hash.Hash computing the BLAKE2s-256 checksum. A non-nil
-// key turns the hash into a MAC. The key must between zero and 32 bytes long.
-// When the key is nil, the returned hash.Hash implements BinaryMarshaler
-// and BinaryUnmarshaler for state (de)serialization as documented by hash.Hash.
-func New256(key []byte) (hash.Hash, error) { return newDigest(Size, key) }
-
-func init() {
- crypto.RegisterHash(crypto.BLAKE2s_256, func() hash.Hash {
- h, _ := New256(nil)
- return h
- })
-}
-
-// New128 returns a new hash.Hash computing the BLAKE2s-128 checksum given a
-// non-empty key. Note that a 128-bit digest is too small to be secure as a
-// cryptographic hash and should only be used as a MAC, thus the key argument
-// is not optional.
-func New128(key []byte) (hash.Hash, error) {
- if len(key) == 0 {
- return nil, errors.New("blake2s: a key is required for a 128-bit hash")
- }
- return newDigest(Size128, key)
-}
-
-func newDigest(hashSize int, key []byte) (*digest, error) {
- if len(key) > Size {
- return nil, errKeySize
- }
- d := &digest{
- size: hashSize,
- keyLen: len(key),
- }
- copy(d.key[:], key)
- d.Reset()
- return d, nil
-}
-
-func checkSum(sum *[Size]byte, hashSize int, data []byte) {
- var (
- h [8]uint32
- c [2]uint32
- )
-
- h = iv
- h[0] ^= uint32(hashSize) | (1 << 16) | (1 << 24)
-
- if length := len(data); length > BlockSize {
- n := length &^ (BlockSize - 1)
- if length == n {
- n -= BlockSize
- }
- hashBlocks(&h, &c, 0, data[:n])
- data = data[n:]
- }
-
- var block [BlockSize]byte
- offset := copy(block[:], data)
- remaining := uint32(BlockSize - offset)
-
- if c[0] < remaining {
- c[1]--
- }
- c[0] -= remaining
-
- hashBlocks(&h, &c, 0xFFFFFFFF, block[:])
-
- for i, v := range h {
- binary.LittleEndian.PutUint32(sum[4*i:], v)
- }
-}
-
-type digest struct {
- h [8]uint32
- c [2]uint32
- size int
- block [BlockSize]byte
- offset int
-
- key [BlockSize]byte
- keyLen int
-}
-
-const (
- magic = "b2s"
- marshaledSize = len(magic) + 8*4 + 2*4 + 1 + BlockSize + 1
-)
-
-func (d *digest) MarshalBinary() ([]byte, error) {
- if d.keyLen != 0 {
- return nil, errors.New("crypto/blake2s: cannot marshal MACs")
- }
- b := make([]byte, 0, marshaledSize)
- b = append(b, magic...)
- for i := 0; i < 8; i++ {
- b = appendUint32(b, d.h[i])
- }
- b = appendUint32(b, d.c[0])
- b = appendUint32(b, d.c[1])
- // Maximum value for size is 32
- b = append(b, byte(d.size))
- b = append(b, d.block[:]...)
- b = append(b, byte(d.offset))
- return b, nil
-}
-
-func (d *digest) UnmarshalBinary(b []byte) error {
- if len(b) < len(magic) || string(b[:len(magic)]) != magic {
- return errors.New("crypto/blake2s: invalid hash state identifier")
- }
- if len(b) != marshaledSize {
- return errors.New("crypto/blake2s: invalid hash state size")
- }
- b = b[len(magic):]
- for i := 0; i < 8; i++ {
- b, d.h[i] = consumeUint32(b)
- }
- b, d.c[0] = consumeUint32(b)
- b, d.c[1] = consumeUint32(b)
- d.size = int(b[0])
- b = b[1:]
- copy(d.block[:], b[:BlockSize])
- b = b[BlockSize:]
- d.offset = int(b[0])
- return nil
-}
-
-func (d *digest) BlockSize() int { return BlockSize }
-
-func (d *digest) Size() int { return d.size }
-
-func (d *digest) Reset() {
- d.h = iv
- d.h[0] ^= uint32(d.size) | (uint32(d.keyLen) << 8) | (1 << 16) | (1 << 24)
- d.offset, d.c[0], d.c[1] = 0, 0, 0
- if d.keyLen > 0 {
- d.block = d.key
- d.offset = BlockSize
- }
-}
-
-func (d *digest) Write(p []byte) (n int, err error) {
- n = len(p)
-
- if d.offset > 0 {
- remaining := BlockSize - d.offset
- if n <= remaining {
- d.offset += copy(d.block[d.offset:], p)
- return
- }
- copy(d.block[d.offset:], p[:remaining])
- hashBlocks(&d.h, &d.c, 0, d.block[:])
- d.offset = 0
- p = p[remaining:]
- }
-
- if length := len(p); length > BlockSize {
- nn := length &^ (BlockSize - 1)
- if length == nn {
- nn -= BlockSize
- }
- hashBlocks(&d.h, &d.c, 0, p[:nn])
- p = p[nn:]
- }
-
- d.offset += copy(d.block[:], p)
- return
-}
-
-func (d *digest) Sum(sum []byte) []byte {
- var hash [Size]byte
- d.finalize(&hash)
- return append(sum, hash[:d.size]...)
-}
-
-func (d *digest) finalize(hash *[Size]byte) {
- var block [BlockSize]byte
- h := d.h
- c := d.c
-
- copy(block[:], d.block[:d.offset])
- remaining := uint32(BlockSize - d.offset)
- if c[0] < remaining {
- c[1]--
- }
- c[0] -= remaining
-
- hashBlocks(&h, &c, 0xFFFFFFFF, block[:])
- for i, v := range h {
- binary.LittleEndian.PutUint32(hash[4*i:], v)
- }
-}
-
-func appendUint32(b []byte, x uint32) []byte {
- var a [4]byte
- binary.BigEndian.PutUint32(a[:], x)
- return append(b, a[:]...)
-}
-
-func consumeUint32(b []byte) ([]byte, uint32) {
- x := binary.BigEndian.Uint32(b)
- return b[4:], x
-}
diff --git a/vendor/golang.org/x/crypto/blake2s/blake2s_386.go b/vendor/golang.org/x/crypto/blake2s/blake2s_386.go
deleted file mode 100644
index 97f629617..000000000
--- a/vendor/golang.org/x/crypto/blake2s/blake2s_386.go
+++ /dev/null
@@ -1,32 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-//go:build 386 && gc && !purego
-
-package blake2s
-
-import "golang.org/x/sys/cpu"
-
-var (
- useSSE4 = false
- useSSSE3 = cpu.X86.HasSSSE3
- useSSE2 = cpu.X86.HasSSE2
-)
-
-//go:noescape
-func hashBlocksSSE2(h *[8]uint32, c *[2]uint32, flag uint32, blocks []byte)
-
-//go:noescape
-func hashBlocksSSSE3(h *[8]uint32, c *[2]uint32, flag uint32, blocks []byte)
-
-func hashBlocks(h *[8]uint32, c *[2]uint32, flag uint32, blocks []byte) {
- switch {
- case useSSSE3:
- hashBlocksSSSE3(h, c, flag, blocks)
- case useSSE2:
- hashBlocksSSE2(h, c, flag, blocks)
- default:
- hashBlocksGeneric(h, c, flag, blocks)
- }
-}
diff --git a/vendor/golang.org/x/crypto/blake2s/blake2s_386.s b/vendor/golang.org/x/crypto/blake2s/blake2s_386.s
deleted file mode 100644
index 919c02654..000000000
--- a/vendor/golang.org/x/crypto/blake2s/blake2s_386.s
+++ /dev/null
@@ -1,429 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-//go:build 386 && gc && !purego
-
-#include "textflag.h"
-
-DATA iv0<>+0x00(SB)/4, $0x6a09e667
-DATA iv0<>+0x04(SB)/4, $0xbb67ae85
-DATA iv0<>+0x08(SB)/4, $0x3c6ef372
-DATA iv0<>+0x0c(SB)/4, $0xa54ff53a
-GLOBL iv0<>(SB), (NOPTR+RODATA), $16
-
-DATA iv1<>+0x00(SB)/4, $0x510e527f
-DATA iv1<>+0x04(SB)/4, $0x9b05688c
-DATA iv1<>+0x08(SB)/4, $0x1f83d9ab
-DATA iv1<>+0x0c(SB)/4, $0x5be0cd19
-GLOBL iv1<>(SB), (NOPTR+RODATA), $16
-
-DATA rol16<>+0x00(SB)/8, $0x0504070601000302
-DATA rol16<>+0x08(SB)/8, $0x0D0C0F0E09080B0A
-GLOBL rol16<>(SB), (NOPTR+RODATA), $16
-
-DATA rol8<>+0x00(SB)/8, $0x0407060500030201
-DATA rol8<>+0x08(SB)/8, $0x0C0F0E0D080B0A09
-GLOBL rol8<>(SB), (NOPTR+RODATA), $16
-
-DATA counter<>+0x00(SB)/8, $0x40
-DATA counter<>+0x08(SB)/8, $0x0
-GLOBL counter<>(SB), (NOPTR+RODATA), $16
-
-#define ROTL_SSE2(n, t, v) \
- MOVO v, t; \
- PSLLL $n, t; \
- PSRLL $(32-n), v; \
- PXOR t, v
-
-#define ROTL_SSSE3(c, v) \
- PSHUFB c, v
-
-#define ROUND_SSE2(v0, v1, v2, v3, m0, m1, m2, m3, t) \
- PADDL m0, v0; \
- PADDL v1, v0; \
- PXOR v0, v3; \
- ROTL_SSE2(16, t, v3); \
- PADDL v3, v2; \
- PXOR v2, v1; \
- ROTL_SSE2(20, t, v1); \
- PADDL m1, v0; \
- PADDL v1, v0; \
- PXOR v0, v3; \
- ROTL_SSE2(24, t, v3); \
- PADDL v3, v2; \
- PXOR v2, v1; \
- ROTL_SSE2(25, t, v1); \
- PSHUFL $0x39, v1, v1; \
- PSHUFL $0x4E, v2, v2; \
- PSHUFL $0x93, v3, v3; \
- PADDL m2, v0; \
- PADDL v1, v0; \
- PXOR v0, v3; \
- ROTL_SSE2(16, t, v3); \
- PADDL v3, v2; \
- PXOR v2, v1; \
- ROTL_SSE2(20, t, v1); \
- PADDL m3, v0; \
- PADDL v1, v0; \
- PXOR v0, v3; \
- ROTL_SSE2(24, t, v3); \
- PADDL v3, v2; \
- PXOR v2, v1; \
- ROTL_SSE2(25, t, v1); \
- PSHUFL $0x39, v3, v3; \
- PSHUFL $0x4E, v2, v2; \
- PSHUFL $0x93, v1, v1
-
-#define ROUND_SSSE3(v0, v1, v2, v3, m0, m1, m2, m3, t, c16, c8) \
- PADDL m0, v0; \
- PADDL v1, v0; \
- PXOR v0, v3; \
- ROTL_SSSE3(c16, v3); \
- PADDL v3, v2; \
- PXOR v2, v1; \
- ROTL_SSE2(20, t, v1); \
- PADDL m1, v0; \
- PADDL v1, v0; \
- PXOR v0, v3; \
- ROTL_SSSE3(c8, v3); \
- PADDL v3, v2; \
- PXOR v2, v1; \
- ROTL_SSE2(25, t, v1); \
- PSHUFL $0x39, v1, v1; \
- PSHUFL $0x4E, v2, v2; \
- PSHUFL $0x93, v3, v3; \
- PADDL m2, v0; \
- PADDL v1, v0; \
- PXOR v0, v3; \
- ROTL_SSSE3(c16, v3); \
- PADDL v3, v2; \
- PXOR v2, v1; \
- ROTL_SSE2(20, t, v1); \
- PADDL m3, v0; \
- PADDL v1, v0; \
- PXOR v0, v3; \
- ROTL_SSSE3(c8, v3); \
- PADDL v3, v2; \
- PXOR v2, v1; \
- ROTL_SSE2(25, t, v1); \
- PSHUFL $0x39, v3, v3; \
- PSHUFL $0x4E, v2, v2; \
- PSHUFL $0x93, v1, v1
-
-#define PRECOMPUTE(dst, off, src, t) \
- MOVL 0*4(src), t; \
- MOVL t, 0*4+off+0(dst); \
- MOVL t, 9*4+off+64(dst); \
- MOVL t, 5*4+off+128(dst); \
- MOVL t, 14*4+off+192(dst); \
- MOVL t, 4*4+off+256(dst); \
- MOVL t, 2*4+off+320(dst); \
- MOVL t, 8*4+off+384(dst); \
- MOVL t, 12*4+off+448(dst); \
- MOVL t, 3*4+off+512(dst); \
- MOVL t, 15*4+off+576(dst); \
- MOVL 1*4(src), t; \
- MOVL t, 4*4+off+0(dst); \
- MOVL t, 8*4+off+64(dst); \
- MOVL t, 14*4+off+128(dst); \
- MOVL t, 5*4+off+192(dst); \
- MOVL t, 12*4+off+256(dst); \
- MOVL t, 11*4+off+320(dst); \
- MOVL t, 1*4+off+384(dst); \
- MOVL t, 6*4+off+448(dst); \
- MOVL t, 10*4+off+512(dst); \
- MOVL t, 3*4+off+576(dst); \
- MOVL 2*4(src), t; \
- MOVL t, 1*4+off+0(dst); \
- MOVL t, 13*4+off+64(dst); \
- MOVL t, 6*4+off+128(dst); \
- MOVL t, 8*4+off+192(dst); \
- MOVL t, 2*4+off+256(dst); \
- MOVL t, 0*4+off+320(dst); \
- MOVL t, 14*4+off+384(dst); \
- MOVL t, 11*4+off+448(dst); \
- MOVL t, 12*4+off+512(dst); \
- MOVL t, 4*4+off+576(dst); \
- MOVL 3*4(src), t; \
- MOVL t, 5*4+off+0(dst); \
- MOVL t, 15*4+off+64(dst); \
- MOVL t, 9*4+off+128(dst); \
- MOVL t, 1*4+off+192(dst); \
- MOVL t, 11*4+off+256(dst); \
- MOVL t, 7*4+off+320(dst); \
- MOVL t, 13*4+off+384(dst); \
- MOVL t, 3*4+off+448(dst); \
- MOVL t, 6*4+off+512(dst); \
- MOVL t, 10*4+off+576(dst); \
- MOVL 4*4(src), t; \
- MOVL t, 2*4+off+0(dst); \
- MOVL t, 1*4+off+64(dst); \
- MOVL t, 15*4+off+128(dst); \
- MOVL t, 10*4+off+192(dst); \
- MOVL t, 6*4+off+256(dst); \
- MOVL t, 8*4+off+320(dst); \
- MOVL t, 3*4+off+384(dst); \
- MOVL t, 13*4+off+448(dst); \
- MOVL t, 14*4+off+512(dst); \
- MOVL t, 5*4+off+576(dst); \
- MOVL 5*4(src), t; \
- MOVL t, 6*4+off+0(dst); \
- MOVL t, 11*4+off+64(dst); \
- MOVL t, 2*4+off+128(dst); \
- MOVL t, 9*4+off+192(dst); \
- MOVL t, 1*4+off+256(dst); \
- MOVL t, 13*4+off+320(dst); \
- MOVL t, 4*4+off+384(dst); \
- MOVL t, 8*4+off+448(dst); \
- MOVL t, 15*4+off+512(dst); \
- MOVL t, 7*4+off+576(dst); \
- MOVL 6*4(src), t; \
- MOVL t, 3*4+off+0(dst); \
- MOVL t, 7*4+off+64(dst); \
- MOVL t, 13*4+off+128(dst); \
- MOVL t, 12*4+off+192(dst); \
- MOVL t, 10*4+off+256(dst); \
- MOVL t, 1*4+off+320(dst); \
- MOVL t, 9*4+off+384(dst); \
- MOVL t, 14*4+off+448(dst); \
- MOVL t, 0*4+off+512(dst); \
- MOVL t, 6*4+off+576(dst); \
- MOVL 7*4(src), t; \
- MOVL t, 7*4+off+0(dst); \
- MOVL t, 14*4+off+64(dst); \
- MOVL t, 10*4+off+128(dst); \
- MOVL t, 0*4+off+192(dst); \
- MOVL t, 5*4+off+256(dst); \
- MOVL t, 9*4+off+320(dst); \
- MOVL t, 12*4+off+384(dst); \
- MOVL t, 1*4+off+448(dst); \
- MOVL t, 13*4+off+512(dst); \
- MOVL t, 2*4+off+576(dst); \
- MOVL 8*4(src), t; \
- MOVL t, 8*4+off+0(dst); \
- MOVL t, 5*4+off+64(dst); \
- MOVL t, 4*4+off+128(dst); \
- MOVL t, 15*4+off+192(dst); \
- MOVL t, 14*4+off+256(dst); \
- MOVL t, 3*4+off+320(dst); \
- MOVL t, 11*4+off+384(dst); \
- MOVL t, 10*4+off+448(dst); \
- MOVL t, 7*4+off+512(dst); \
- MOVL t, 1*4+off+576(dst); \
- MOVL 9*4(src), t; \
- MOVL t, 12*4+off+0(dst); \
- MOVL t, 2*4+off+64(dst); \
- MOVL t, 11*4+off+128(dst); \
- MOVL t, 4*4+off+192(dst); \
- MOVL t, 0*4+off+256(dst); \
- MOVL t, 15*4+off+320(dst); \
- MOVL t, 10*4+off+384(dst); \
- MOVL t, 7*4+off+448(dst); \
- MOVL t, 5*4+off+512(dst); \
- MOVL t, 9*4+off+576(dst); \
- MOVL 10*4(src), t; \
- MOVL t, 9*4+off+0(dst); \
- MOVL t, 4*4+off+64(dst); \
- MOVL t, 8*4+off+128(dst); \
- MOVL t, 13*4+off+192(dst); \
- MOVL t, 3*4+off+256(dst); \
- MOVL t, 5*4+off+320(dst); \
- MOVL t, 7*4+off+384(dst); \
- MOVL t, 15*4+off+448(dst); \
- MOVL t, 11*4+off+512(dst); \
- MOVL t, 0*4+off+576(dst); \
- MOVL 11*4(src), t; \
- MOVL t, 13*4+off+0(dst); \
- MOVL t, 10*4+off+64(dst); \
- MOVL t, 0*4+off+128(dst); \
- MOVL t, 3*4+off+192(dst); \
- MOVL t, 9*4+off+256(dst); \
- MOVL t, 6*4+off+320(dst); \
- MOVL t, 15*4+off+384(dst); \
- MOVL t, 4*4+off+448(dst); \
- MOVL t, 2*4+off+512(dst); \
- MOVL t, 12*4+off+576(dst); \
- MOVL 12*4(src), t; \
- MOVL t, 10*4+off+0(dst); \
- MOVL t, 12*4+off+64(dst); \
- MOVL t, 1*4+off+128(dst); \
- MOVL t, 6*4+off+192(dst); \
- MOVL t, 13*4+off+256(dst); \
- MOVL t, 4*4+off+320(dst); \
- MOVL t, 0*4+off+384(dst); \
- MOVL t, 2*4+off+448(dst); \
- MOVL t, 8*4+off+512(dst); \
- MOVL t, 14*4+off+576(dst); \
- MOVL 13*4(src), t; \
- MOVL t, 14*4+off+0(dst); \
- MOVL t, 3*4+off+64(dst); \
- MOVL t, 7*4+off+128(dst); \
- MOVL t, 2*4+off+192(dst); \
- MOVL t, 15*4+off+256(dst); \
- MOVL t, 12*4+off+320(dst); \
- MOVL t, 6*4+off+384(dst); \
- MOVL t, 0*4+off+448(dst); \
- MOVL t, 9*4+off+512(dst); \
- MOVL t, 11*4+off+576(dst); \
- MOVL 14*4(src), t; \
- MOVL t, 11*4+off+0(dst); \
- MOVL t, 0*4+off+64(dst); \
- MOVL t, 12*4+off+128(dst); \
- MOVL t, 7*4+off+192(dst); \
- MOVL t, 8*4+off+256(dst); \
- MOVL t, 14*4+off+320(dst); \
- MOVL t, 2*4+off+384(dst); \
- MOVL t, 5*4+off+448(dst); \
- MOVL t, 1*4+off+512(dst); \
- MOVL t, 13*4+off+576(dst); \
- MOVL 15*4(src), t; \
- MOVL t, 15*4+off+0(dst); \
- MOVL t, 6*4+off+64(dst); \
- MOVL t, 3*4+off+128(dst); \
- MOVL t, 11*4+off+192(dst); \
- MOVL t, 7*4+off+256(dst); \
- MOVL t, 10*4+off+320(dst); \
- MOVL t, 5*4+off+384(dst); \
- MOVL t, 9*4+off+448(dst); \
- MOVL t, 4*4+off+512(dst); \
- MOVL t, 8*4+off+576(dst)
-
-// func hashBlocksSSE2(h *[8]uint32, c *[2]uint32, flag uint32, blocks []byte)
-TEXT ·hashBlocksSSE2(SB), 0, $672-24 // frame = 656 + 16 byte alignment
- MOVL h+0(FP), AX
- MOVL c+4(FP), BX
- MOVL flag+8(FP), CX
- MOVL blocks_base+12(FP), SI
- MOVL blocks_len+16(FP), DX
-
- MOVL SP, DI
- ADDL $15, DI
- ANDL $~15, DI
-
- MOVL CX, 8(DI)
- MOVL 0(BX), CX
- MOVL CX, 0(DI)
- MOVL 4(BX), CX
- MOVL CX, 4(DI)
- XORL CX, CX
- MOVL CX, 12(DI)
-
- MOVOU 0(AX), X0
- MOVOU 16(AX), X1
- MOVOU counter<>(SB), X2
-
-loop:
- MOVO X0, X4
- MOVO X1, X5
- MOVOU iv0<>(SB), X6
- MOVOU iv1<>(SB), X7
-
- MOVO 0(DI), X3
- PADDQ X2, X3
- PXOR X3, X7
- MOVO X3, 0(DI)
-
- PRECOMPUTE(DI, 16, SI, CX)
- ROUND_SSE2(X4, X5, X6, X7, 16(DI), 32(DI), 48(DI), 64(DI), X3)
- ROUND_SSE2(X4, X5, X6, X7, 16+64(DI), 32+64(DI), 48+64(DI), 64+64(DI), X3)
- ROUND_SSE2(X4, X5, X6, X7, 16+128(DI), 32+128(DI), 48+128(DI), 64+128(DI), X3)
- ROUND_SSE2(X4, X5, X6, X7, 16+192(DI), 32+192(DI), 48+192(DI), 64+192(DI), X3)
- ROUND_SSE2(X4, X5, X6, X7, 16+256(DI), 32+256(DI), 48+256(DI), 64+256(DI), X3)
- ROUND_SSE2(X4, X5, X6, X7, 16+320(DI), 32+320(DI), 48+320(DI), 64+320(DI), X3)
- ROUND_SSE2(X4, X5, X6, X7, 16+384(DI), 32+384(DI), 48+384(DI), 64+384(DI), X3)
- ROUND_SSE2(X4, X5, X6, X7, 16+448(DI), 32+448(DI), 48+448(DI), 64+448(DI), X3)
- ROUND_SSE2(X4, X5, X6, X7, 16+512(DI), 32+512(DI), 48+512(DI), 64+512(DI), X3)
- ROUND_SSE2(X4, X5, X6, X7, 16+576(DI), 32+576(DI), 48+576(DI), 64+576(DI), X3)
-
- PXOR X4, X0
- PXOR X5, X1
- PXOR X6, X0
- PXOR X7, X1
-
- LEAL 64(SI), SI
- SUBL $64, DX
- JNE loop
-
- MOVL 0(DI), CX
- MOVL CX, 0(BX)
- MOVL 4(DI), CX
- MOVL CX, 4(BX)
-
- MOVOU X0, 0(AX)
- MOVOU X1, 16(AX)
-
- RET
-
-// func hashBlocksSSSE3(h *[8]uint32, c *[2]uint32, flag uint32, blocks []byte)
-TEXT ·hashBlocksSSSE3(SB), 0, $704-24 // frame = 688 + 16 byte alignment
- MOVL h+0(FP), AX
- MOVL c+4(FP), BX
- MOVL flag+8(FP), CX
- MOVL blocks_base+12(FP), SI
- MOVL blocks_len+16(FP), DX
-
- MOVL SP, DI
- ADDL $15, DI
- ANDL $~15, DI
-
- MOVL CX, 8(DI)
- MOVL 0(BX), CX
- MOVL CX, 0(DI)
- MOVL 4(BX), CX
- MOVL CX, 4(DI)
- XORL CX, CX
- MOVL CX, 12(DI)
-
- MOVOU 0(AX), X0
- MOVOU 16(AX), X1
- MOVOU counter<>(SB), X2
-
-loop:
- MOVO X0, 656(DI)
- MOVO X1, 672(DI)
- MOVO X0, X4
- MOVO X1, X5
- MOVOU iv0<>(SB), X6
- MOVOU iv1<>(SB), X7
-
- MOVO 0(DI), X3
- PADDQ X2, X3
- PXOR X3, X7
- MOVO X3, 0(DI)
-
- MOVOU rol16<>(SB), X0
- MOVOU rol8<>(SB), X1
-
- PRECOMPUTE(DI, 16, SI, CX)
- ROUND_SSSE3(X4, X5, X6, X7, 16(DI), 32(DI), 48(DI), 64(DI), X3, X0, X1)
- ROUND_SSSE3(X4, X5, X6, X7, 16+64(DI), 32+64(DI), 48+64(DI), 64+64(DI), X3, X0, X1)
- ROUND_SSSE3(X4, X5, X6, X7, 16+128(DI), 32+128(DI), 48+128(DI), 64+128(DI), X3, X0, X1)
- ROUND_SSSE3(X4, X5, X6, X7, 16+192(DI), 32+192(DI), 48+192(DI), 64+192(DI), X3, X0, X1)
- ROUND_SSSE3(X4, X5, X6, X7, 16+256(DI), 32+256(DI), 48+256(DI), 64+256(DI), X3, X0, X1)
- ROUND_SSSE3(X4, X5, X6, X7, 16+320(DI), 32+320(DI), 48+320(DI), 64+320(DI), X3, X0, X1)
- ROUND_SSSE3(X4, X5, X6, X7, 16+384(DI), 32+384(DI), 48+384(DI), 64+384(DI), X3, X0, X1)
- ROUND_SSSE3(X4, X5, X6, X7, 16+448(DI), 32+448(DI), 48+448(DI), 64+448(DI), X3, X0, X1)
- ROUND_SSSE3(X4, X5, X6, X7, 16+512(DI), 32+512(DI), 48+512(DI), 64+512(DI), X3, X0, X1)
- ROUND_SSSE3(X4, X5, X6, X7, 16+576(DI), 32+576(DI), 48+576(DI), 64+576(DI), X3, X0, X1)
-
- MOVO 656(DI), X0
- MOVO 672(DI), X1
- PXOR X4, X0
- PXOR X5, X1
- PXOR X6, X0
- PXOR X7, X1
-
- LEAL 64(SI), SI
- SUBL $64, DX
- JNE loop
-
- MOVL 0(DI), CX
- MOVL CX, 0(BX)
- MOVL 4(DI), CX
- MOVL CX, 4(BX)
-
- MOVOU X0, 0(AX)
- MOVOU X1, 16(AX)
-
- RET
diff --git a/vendor/golang.org/x/crypto/blake2s/blake2s_amd64.go b/vendor/golang.org/x/crypto/blake2s/blake2s_amd64.go
deleted file mode 100644
index 8a7310254..000000000
--- a/vendor/golang.org/x/crypto/blake2s/blake2s_amd64.go
+++ /dev/null
@@ -1,37 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-//go:build amd64 && gc && !purego
-
-package blake2s
-
-import "golang.org/x/sys/cpu"
-
-var (
- useSSE4 = cpu.X86.HasSSE41
- useSSSE3 = cpu.X86.HasSSSE3
- useSSE2 = cpu.X86.HasSSE2
-)
-
-//go:noescape
-func hashBlocksSSE2(h *[8]uint32, c *[2]uint32, flag uint32, blocks []byte)
-
-//go:noescape
-func hashBlocksSSSE3(h *[8]uint32, c *[2]uint32, flag uint32, blocks []byte)
-
-//go:noescape
-func hashBlocksSSE4(h *[8]uint32, c *[2]uint32, flag uint32, blocks []byte)
-
-func hashBlocks(h *[8]uint32, c *[2]uint32, flag uint32, blocks []byte) {
- switch {
- case useSSE4:
- hashBlocksSSE4(h, c, flag, blocks)
- case useSSSE3:
- hashBlocksSSSE3(h, c, flag, blocks)
- case useSSE2:
- hashBlocksSSE2(h, c, flag, blocks)
- default:
- hashBlocksGeneric(h, c, flag, blocks)
- }
-}
diff --git a/vendor/golang.org/x/crypto/blake2s/blake2s_amd64.s b/vendor/golang.org/x/crypto/blake2s/blake2s_amd64.s
deleted file mode 100644
index 57d510fc0..000000000
--- a/vendor/golang.org/x/crypto/blake2s/blake2s_amd64.s
+++ /dev/null
@@ -1,2173 +0,0 @@
-// Code generated by command: go run blake2s_amd64_asm.go -out ../blake2s_amd64.s -pkg blake2s. DO NOT EDIT.
-
-//go:build amd64 && gc && !purego
-
-#include "textflag.h"
-
-// func hashBlocksSSE2(h *[8]uint32, c *[2]uint32, flag uint32, blocks []byte)
-// Requires: SSE2
-TEXT ·hashBlocksSSE2(SB), $672-48
- MOVQ h+0(FP), AX
- MOVQ c+8(FP), BX
- MOVL flag+16(FP), CX
- MOVQ blocks_base+24(FP), SI
- MOVQ blocks_len+32(FP), DX
- MOVQ SP, BP
- ADDQ $0x0f, BP
- ANDQ $-16, BP
- MOVQ (BX), R9
- MOVQ R9, (BP)
- MOVQ CX, 8(BP)
- MOVOU (AX), X0
- MOVOU 16(AX), X1
- MOVOU iv0<>+0(SB), X2
- MOVOU iv1<>+0(SB), X3
- MOVOU counter<>+0(SB), X12
- MOVOU rol16<>+0(SB), X13
- MOVOU rol8<>+0(SB), X14
- MOVO (BP), X15
-
-loop:
- MOVO X0, X4
- MOVO X1, X5
- MOVO X2, X6
- MOVO X3, X7
- PADDQ X12, X15
- PXOR X15, X7
- MOVQ (SI), R8
- MOVQ 8(SI), R9
- MOVQ 16(SI), R10
- MOVQ 24(SI), R11
- MOVQ 32(SI), R12
- MOVQ 40(SI), R13
- MOVQ 48(SI), R14
- MOVQ 56(SI), R15
- MOVL R8, 16(BP)
- MOVL R8, 116(BP)
- MOVL R8, 164(BP)
- MOVL R8, 264(BP)
- MOVL R8, 288(BP)
- MOVL R8, 344(BP)
- MOVL R8, 432(BP)
- MOVL R8, 512(BP)
- MOVL R8, 540(BP)
- MOVL R8, 652(BP)
- SHRQ $0x20, R8
- MOVL R8, 32(BP)
- MOVL R8, 112(BP)
- MOVL R8, 200(BP)
- MOVL R8, 228(BP)
- MOVL R8, 320(BP)
- MOVL R8, 380(BP)
- MOVL R8, 404(BP)
- MOVL R8, 488(BP)
- MOVL R8, 568(BP)
- MOVL R8, 604(BP)
- MOVL R9, 20(BP)
- MOVL R9, 132(BP)
- MOVL R9, 168(BP)
- MOVL R9, 240(BP)
- MOVL R9, 280(BP)
- MOVL R9, 336(BP)
- MOVL R9, 456(BP)
- MOVL R9, 508(BP)
- MOVL R9, 576(BP)
- MOVL R9, 608(BP)
- SHRQ $0x20, R9
- MOVL R9, 36(BP)
- MOVL R9, 140(BP)
- MOVL R9, 180(BP)
- MOVL R9, 212(BP)
- MOVL R9, 316(BP)
- MOVL R9, 364(BP)
- MOVL R9, 452(BP)
- MOVL R9, 476(BP)
- MOVL R9, 552(BP)
- MOVL R9, 632(BP)
- MOVL R10, 24(BP)
- MOVL R10, 84(BP)
- MOVL R10, 204(BP)
- MOVL R10, 248(BP)
- MOVL R10, 296(BP)
- MOVL R10, 368(BP)
- MOVL R10, 412(BP)
- MOVL R10, 516(BP)
- MOVL R10, 584(BP)
- MOVL R10, 612(BP)
- SHRQ $0x20, R10
- MOVL R10, 40(BP)
- MOVL R10, 124(BP)
- MOVL R10, 152(BP)
- MOVL R10, 244(BP)
- MOVL R10, 276(BP)
- MOVL R10, 388(BP)
- MOVL R10, 416(BP)
- MOVL R10, 496(BP)
- MOVL R10, 588(BP)
- MOVL R10, 620(BP)
- MOVL R11, 28(BP)
- MOVL R11, 108(BP)
- MOVL R11, 196(BP)
- MOVL R11, 256(BP)
- MOVL R11, 312(BP)
- MOVL R11, 340(BP)
- MOVL R11, 436(BP)
- MOVL R11, 520(BP)
- MOVL R11, 528(BP)
- MOVL R11, 616(BP)
- SHRQ $0x20, R11
- MOVL R11, 44(BP)
- MOVL R11, 136(BP)
- MOVL R11, 184(BP)
- MOVL R11, 208(BP)
- MOVL R11, 292(BP)
- MOVL R11, 372(BP)
- MOVL R11, 448(BP)
- MOVL R11, 468(BP)
- MOVL R11, 580(BP)
- MOVL R11, 600(BP)
- MOVL R12, 48(BP)
- MOVL R12, 100(BP)
- MOVL R12, 160(BP)
- MOVL R12, 268(BP)
- MOVL R12, 328(BP)
- MOVL R12, 348(BP)
- MOVL R12, 444(BP)
- MOVL R12, 504(BP)
- MOVL R12, 556(BP)
- MOVL R12, 596(BP)
- SHRQ $0x20, R12
- MOVL R12, 64(BP)
- MOVL R12, 88(BP)
- MOVL R12, 188(BP)
- MOVL R12, 224(BP)
- MOVL R12, 272(BP)
- MOVL R12, 396(BP)
- MOVL R12, 440(BP)
- MOVL R12, 492(BP)
- MOVL R12, 548(BP)
- MOVL R12, 628(BP)
- MOVL R13, 52(BP)
- MOVL R13, 96(BP)
- MOVL R13, 176(BP)
- MOVL R13, 260(BP)
- MOVL R13, 284(BP)
- MOVL R13, 356(BP)
- MOVL R13, 428(BP)
- MOVL R13, 524(BP)
- MOVL R13, 572(BP)
- MOVL R13, 592(BP)
- SHRQ $0x20, R13
- MOVL R13, 68(BP)
- MOVL R13, 120(BP)
- MOVL R13, 144(BP)
- MOVL R13, 220(BP)
- MOVL R13, 308(BP)
- MOVL R13, 360(BP)
- MOVL R13, 460(BP)
- MOVL R13, 480(BP)
- MOVL R13, 536(BP)
- MOVL R13, 640(BP)
- MOVL R14, 56(BP)
- MOVL R14, 128(BP)
- MOVL R14, 148(BP)
- MOVL R14, 232(BP)
- MOVL R14, 324(BP)
- MOVL R14, 352(BP)
- MOVL R14, 400(BP)
- MOVL R14, 472(BP)
- MOVL R14, 560(BP)
- MOVL R14, 648(BP)
- SHRQ $0x20, R14
- MOVL R14, 72(BP)
- MOVL R14, 92(BP)
- MOVL R14, 172(BP)
- MOVL R14, 216(BP)
- MOVL R14, 332(BP)
- MOVL R14, 384(BP)
- MOVL R14, 424(BP)
- MOVL R14, 464(BP)
- MOVL R14, 564(BP)
- MOVL R14, 636(BP)
- MOVL R15, 60(BP)
- MOVL R15, 80(BP)
- MOVL R15, 192(BP)
- MOVL R15, 236(BP)
- MOVL R15, 304(BP)
- MOVL R15, 392(BP)
- MOVL R15, 408(BP)
- MOVL R15, 484(BP)
- MOVL R15, 532(BP)
- MOVL R15, 644(BP)
- SHRQ $0x20, R15
- MOVL R15, 76(BP)
- MOVL R15, 104(BP)
- MOVL R15, 156(BP)
- MOVL R15, 252(BP)
- MOVL R15, 300(BP)
- MOVL R15, 376(BP)
- MOVL R15, 420(BP)
- MOVL R15, 500(BP)
- MOVL R15, 544(BP)
- MOVL R15, 624(BP)
- PADDL 16(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- MOVO X7, X8
- PSLLL $0x10, X8
- PSRLL $0x10, X7
- PXOR X8, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL 32(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- MOVO X7, X8
- PSLLL $0x18, X8
- PSRLL $0x08, X7
- PXOR X8, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X5, X5
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X7, X7
- PADDL 48(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- MOVO X7, X8
- PSLLL $0x10, X8
- PSRLL $0x10, X7
- PXOR X8, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL 64(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- MOVO X7, X8
- PSLLL $0x18, X8
- PSRLL $0x08, X7
- PXOR X8, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X7, X7
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X5, X5
- PADDL 80(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- MOVO X7, X8
- PSLLL $0x10, X8
- PSRLL $0x10, X7
- PXOR X8, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL 96(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- MOVO X7, X8
- PSLLL $0x18, X8
- PSRLL $0x08, X7
- PXOR X8, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X5, X5
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X7, X7
- PADDL 112(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- MOVO X7, X8
- PSLLL $0x10, X8
- PSRLL $0x10, X7
- PXOR X8, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL 128(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- MOVO X7, X8
- PSLLL $0x18, X8
- PSRLL $0x08, X7
- PXOR X8, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X7, X7
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X5, X5
- PADDL 144(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- MOVO X7, X8
- PSLLL $0x10, X8
- PSRLL $0x10, X7
- PXOR X8, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL 160(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- MOVO X7, X8
- PSLLL $0x18, X8
- PSRLL $0x08, X7
- PXOR X8, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X5, X5
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X7, X7
- PADDL 176(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- MOVO X7, X8
- PSLLL $0x10, X8
- PSRLL $0x10, X7
- PXOR X8, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL 192(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- MOVO X7, X8
- PSLLL $0x18, X8
- PSRLL $0x08, X7
- PXOR X8, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X7, X7
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X5, X5
- PADDL 208(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- MOVO X7, X8
- PSLLL $0x10, X8
- PSRLL $0x10, X7
- PXOR X8, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL 224(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- MOVO X7, X8
- PSLLL $0x18, X8
- PSRLL $0x08, X7
- PXOR X8, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X5, X5
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X7, X7
- PADDL 240(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- MOVO X7, X8
- PSLLL $0x10, X8
- PSRLL $0x10, X7
- PXOR X8, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL 256(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- MOVO X7, X8
- PSLLL $0x18, X8
- PSRLL $0x08, X7
- PXOR X8, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X7, X7
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X5, X5
- PADDL 272(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- MOVO X7, X8
- PSLLL $0x10, X8
- PSRLL $0x10, X7
- PXOR X8, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL 288(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- MOVO X7, X8
- PSLLL $0x18, X8
- PSRLL $0x08, X7
- PXOR X8, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X5, X5
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X7, X7
- PADDL 304(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- MOVO X7, X8
- PSLLL $0x10, X8
- PSRLL $0x10, X7
- PXOR X8, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL 320(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- MOVO X7, X8
- PSLLL $0x18, X8
- PSRLL $0x08, X7
- PXOR X8, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X7, X7
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X5, X5
- PADDL 336(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- MOVO X7, X8
- PSLLL $0x10, X8
- PSRLL $0x10, X7
- PXOR X8, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL 352(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- MOVO X7, X8
- PSLLL $0x18, X8
- PSRLL $0x08, X7
- PXOR X8, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X5, X5
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X7, X7
- PADDL 368(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- MOVO X7, X8
- PSLLL $0x10, X8
- PSRLL $0x10, X7
- PXOR X8, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL 384(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- MOVO X7, X8
- PSLLL $0x18, X8
- PSRLL $0x08, X7
- PXOR X8, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X7, X7
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X5, X5
- PADDL 400(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- MOVO X7, X8
- PSLLL $0x10, X8
- PSRLL $0x10, X7
- PXOR X8, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL 416(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- MOVO X7, X8
- PSLLL $0x18, X8
- PSRLL $0x08, X7
- PXOR X8, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X5, X5
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X7, X7
- PADDL 432(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- MOVO X7, X8
- PSLLL $0x10, X8
- PSRLL $0x10, X7
- PXOR X8, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL 448(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- MOVO X7, X8
- PSLLL $0x18, X8
- PSRLL $0x08, X7
- PXOR X8, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X7, X7
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X5, X5
- PADDL 464(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- MOVO X7, X8
- PSLLL $0x10, X8
- PSRLL $0x10, X7
- PXOR X8, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL 480(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- MOVO X7, X8
- PSLLL $0x18, X8
- PSRLL $0x08, X7
- PXOR X8, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X5, X5
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X7, X7
- PADDL 496(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- MOVO X7, X8
- PSLLL $0x10, X8
- PSRLL $0x10, X7
- PXOR X8, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL 512(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- MOVO X7, X8
- PSLLL $0x18, X8
- PSRLL $0x08, X7
- PXOR X8, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X7, X7
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X5, X5
- PADDL 528(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- MOVO X7, X8
- PSLLL $0x10, X8
- PSRLL $0x10, X7
- PXOR X8, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL 544(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- MOVO X7, X8
- PSLLL $0x18, X8
- PSRLL $0x08, X7
- PXOR X8, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X5, X5
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X7, X7
- PADDL 560(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- MOVO X7, X8
- PSLLL $0x10, X8
- PSRLL $0x10, X7
- PXOR X8, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL 576(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- MOVO X7, X8
- PSLLL $0x18, X8
- PSRLL $0x08, X7
- PXOR X8, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X7, X7
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X5, X5
- PADDL 592(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- MOVO X7, X8
- PSLLL $0x10, X8
- PSRLL $0x10, X7
- PXOR X8, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL 608(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- MOVO X7, X8
- PSLLL $0x18, X8
- PSRLL $0x08, X7
- PXOR X8, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X5, X5
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X7, X7
- PADDL 624(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- MOVO X7, X8
- PSLLL $0x10, X8
- PSRLL $0x10, X7
- PXOR X8, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL 640(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- MOVO X7, X8
- PSLLL $0x18, X8
- PSRLL $0x08, X7
- PXOR X8, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X7, X7
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X5, X5
- PXOR X4, X0
- PXOR X5, X1
- PXOR X6, X0
- PXOR X7, X1
- LEAQ 64(SI), SI
- SUBQ $0x40, DX
- JNE loop
- MOVO X15, (BP)
- MOVQ (BP), R9
- MOVQ R9, (BX)
- MOVOU X0, (AX)
- MOVOU X1, 16(AX)
- RET
-
-DATA iv0<>+0(SB)/4, $0x6a09e667
-DATA iv0<>+4(SB)/4, $0xbb67ae85
-DATA iv0<>+8(SB)/4, $0x3c6ef372
-DATA iv0<>+12(SB)/4, $0xa54ff53a
-GLOBL iv0<>(SB), RODATA|NOPTR, $16
-
-DATA iv1<>+0(SB)/4, $0x510e527f
-DATA iv1<>+4(SB)/4, $0x9b05688c
-DATA iv1<>+8(SB)/4, $0x1f83d9ab
-DATA iv1<>+12(SB)/4, $0x5be0cd19
-GLOBL iv1<>(SB), RODATA|NOPTR, $16
-
-DATA counter<>+0(SB)/8, $0x0000000000000040
-DATA counter<>+8(SB)/8, $0x0000000000000000
-GLOBL counter<>(SB), RODATA|NOPTR, $16
-
-DATA rol16<>+0(SB)/8, $0x0504070601000302
-DATA rol16<>+8(SB)/8, $0x0d0c0f0e09080b0a
-GLOBL rol16<>(SB), RODATA|NOPTR, $16
-
-DATA rol8<>+0(SB)/8, $0x0407060500030201
-DATA rol8<>+8(SB)/8, $0x0c0f0e0d080b0a09
-GLOBL rol8<>(SB), RODATA|NOPTR, $16
-
-// func hashBlocksSSSE3(h *[8]uint32, c *[2]uint32, flag uint32, blocks []byte)
-// Requires: SSE2, SSSE3
-TEXT ·hashBlocksSSSE3(SB), $672-48
- MOVQ h+0(FP), AX
- MOVQ c+8(FP), BX
- MOVL flag+16(FP), CX
- MOVQ blocks_base+24(FP), SI
- MOVQ blocks_len+32(FP), DX
- MOVQ SP, BP
- ADDQ $0x0f, BP
- ANDQ $-16, BP
- MOVQ (BX), R9
- MOVQ R9, (BP)
- MOVQ CX, 8(BP)
- MOVOU (AX), X0
- MOVOU 16(AX), X1
- MOVOU iv0<>+0(SB), X2
- MOVOU iv1<>+0(SB), X3
- MOVOU counter<>+0(SB), X12
- MOVOU rol16<>+0(SB), X13
- MOVOU rol8<>+0(SB), X14
- MOVO (BP), X15
-
-loop:
- MOVO X0, X4
- MOVO X1, X5
- MOVO X2, X6
- MOVO X3, X7
- PADDQ X12, X15
- PXOR X15, X7
- MOVQ (SI), R8
- MOVQ 8(SI), R9
- MOVQ 16(SI), R10
- MOVQ 24(SI), R11
- MOVQ 32(SI), R12
- MOVQ 40(SI), R13
- MOVQ 48(SI), R14
- MOVQ 56(SI), R15
- MOVL R8, 16(BP)
- MOVL R8, 116(BP)
- MOVL R8, 164(BP)
- MOVL R8, 264(BP)
- MOVL R8, 288(BP)
- MOVL R8, 344(BP)
- MOVL R8, 432(BP)
- MOVL R8, 512(BP)
- MOVL R8, 540(BP)
- MOVL R8, 652(BP)
- SHRQ $0x20, R8
- MOVL R8, 32(BP)
- MOVL R8, 112(BP)
- MOVL R8, 200(BP)
- MOVL R8, 228(BP)
- MOVL R8, 320(BP)
- MOVL R8, 380(BP)
- MOVL R8, 404(BP)
- MOVL R8, 488(BP)
- MOVL R8, 568(BP)
- MOVL R8, 604(BP)
- MOVL R9, 20(BP)
- MOVL R9, 132(BP)
- MOVL R9, 168(BP)
- MOVL R9, 240(BP)
- MOVL R9, 280(BP)
- MOVL R9, 336(BP)
- MOVL R9, 456(BP)
- MOVL R9, 508(BP)
- MOVL R9, 576(BP)
- MOVL R9, 608(BP)
- SHRQ $0x20, R9
- MOVL R9, 36(BP)
- MOVL R9, 140(BP)
- MOVL R9, 180(BP)
- MOVL R9, 212(BP)
- MOVL R9, 316(BP)
- MOVL R9, 364(BP)
- MOVL R9, 452(BP)
- MOVL R9, 476(BP)
- MOVL R9, 552(BP)
- MOVL R9, 632(BP)
- MOVL R10, 24(BP)
- MOVL R10, 84(BP)
- MOVL R10, 204(BP)
- MOVL R10, 248(BP)
- MOVL R10, 296(BP)
- MOVL R10, 368(BP)
- MOVL R10, 412(BP)
- MOVL R10, 516(BP)
- MOVL R10, 584(BP)
- MOVL R10, 612(BP)
- SHRQ $0x20, R10
- MOVL R10, 40(BP)
- MOVL R10, 124(BP)
- MOVL R10, 152(BP)
- MOVL R10, 244(BP)
- MOVL R10, 276(BP)
- MOVL R10, 388(BP)
- MOVL R10, 416(BP)
- MOVL R10, 496(BP)
- MOVL R10, 588(BP)
- MOVL R10, 620(BP)
- MOVL R11, 28(BP)
- MOVL R11, 108(BP)
- MOVL R11, 196(BP)
- MOVL R11, 256(BP)
- MOVL R11, 312(BP)
- MOVL R11, 340(BP)
- MOVL R11, 436(BP)
- MOVL R11, 520(BP)
- MOVL R11, 528(BP)
- MOVL R11, 616(BP)
- SHRQ $0x20, R11
- MOVL R11, 44(BP)
- MOVL R11, 136(BP)
- MOVL R11, 184(BP)
- MOVL R11, 208(BP)
- MOVL R11, 292(BP)
- MOVL R11, 372(BP)
- MOVL R11, 448(BP)
- MOVL R11, 468(BP)
- MOVL R11, 580(BP)
- MOVL R11, 600(BP)
- MOVL R12, 48(BP)
- MOVL R12, 100(BP)
- MOVL R12, 160(BP)
- MOVL R12, 268(BP)
- MOVL R12, 328(BP)
- MOVL R12, 348(BP)
- MOVL R12, 444(BP)
- MOVL R12, 504(BP)
- MOVL R12, 556(BP)
- MOVL R12, 596(BP)
- SHRQ $0x20, R12
- MOVL R12, 64(BP)
- MOVL R12, 88(BP)
- MOVL R12, 188(BP)
- MOVL R12, 224(BP)
- MOVL R12, 272(BP)
- MOVL R12, 396(BP)
- MOVL R12, 440(BP)
- MOVL R12, 492(BP)
- MOVL R12, 548(BP)
- MOVL R12, 628(BP)
- MOVL R13, 52(BP)
- MOVL R13, 96(BP)
- MOVL R13, 176(BP)
- MOVL R13, 260(BP)
- MOVL R13, 284(BP)
- MOVL R13, 356(BP)
- MOVL R13, 428(BP)
- MOVL R13, 524(BP)
- MOVL R13, 572(BP)
- MOVL R13, 592(BP)
- SHRQ $0x20, R13
- MOVL R13, 68(BP)
- MOVL R13, 120(BP)
- MOVL R13, 144(BP)
- MOVL R13, 220(BP)
- MOVL R13, 308(BP)
- MOVL R13, 360(BP)
- MOVL R13, 460(BP)
- MOVL R13, 480(BP)
- MOVL R13, 536(BP)
- MOVL R13, 640(BP)
- MOVL R14, 56(BP)
- MOVL R14, 128(BP)
- MOVL R14, 148(BP)
- MOVL R14, 232(BP)
- MOVL R14, 324(BP)
- MOVL R14, 352(BP)
- MOVL R14, 400(BP)
- MOVL R14, 472(BP)
- MOVL R14, 560(BP)
- MOVL R14, 648(BP)
- SHRQ $0x20, R14
- MOVL R14, 72(BP)
- MOVL R14, 92(BP)
- MOVL R14, 172(BP)
- MOVL R14, 216(BP)
- MOVL R14, 332(BP)
- MOVL R14, 384(BP)
- MOVL R14, 424(BP)
- MOVL R14, 464(BP)
- MOVL R14, 564(BP)
- MOVL R14, 636(BP)
- MOVL R15, 60(BP)
- MOVL R15, 80(BP)
- MOVL R15, 192(BP)
- MOVL R15, 236(BP)
- MOVL R15, 304(BP)
- MOVL R15, 392(BP)
- MOVL R15, 408(BP)
- MOVL R15, 484(BP)
- MOVL R15, 532(BP)
- MOVL R15, 644(BP)
- SHRQ $0x20, R15
- MOVL R15, 76(BP)
- MOVL R15, 104(BP)
- MOVL R15, 156(BP)
- MOVL R15, 252(BP)
- MOVL R15, 300(BP)
- MOVL R15, 376(BP)
- MOVL R15, 420(BP)
- MOVL R15, 500(BP)
- MOVL R15, 544(BP)
- MOVL R15, 624(BP)
- PADDL 16(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X13, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL 32(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X14, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X5, X5
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X7, X7
- PADDL 48(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X13, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL 64(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X14, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X7, X7
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X5, X5
- PADDL 80(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X13, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL 96(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X14, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X5, X5
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X7, X7
- PADDL 112(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X13, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL 128(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X14, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X7, X7
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X5, X5
- PADDL 144(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X13, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL 160(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X14, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X5, X5
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X7, X7
- PADDL 176(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X13, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL 192(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X14, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X7, X7
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X5, X5
- PADDL 208(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X13, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL 224(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X14, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X5, X5
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X7, X7
- PADDL 240(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X13, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL 256(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X14, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X7, X7
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X5, X5
- PADDL 272(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X13, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL 288(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X14, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X5, X5
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X7, X7
- PADDL 304(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X13, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL 320(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X14, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X7, X7
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X5, X5
- PADDL 336(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X13, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL 352(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X14, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X5, X5
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X7, X7
- PADDL 368(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X13, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL 384(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X14, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X7, X7
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X5, X5
- PADDL 400(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X13, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL 416(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X14, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X5, X5
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X7, X7
- PADDL 432(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X13, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL 448(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X14, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X7, X7
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X5, X5
- PADDL 464(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X13, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL 480(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X14, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X5, X5
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X7, X7
- PADDL 496(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X13, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL 512(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X14, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X7, X7
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X5, X5
- PADDL 528(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X13, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL 544(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X14, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X5, X5
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X7, X7
- PADDL 560(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X13, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL 576(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X14, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X7, X7
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X5, X5
- PADDL 592(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X13, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL 608(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X14, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X5, X5
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X7, X7
- PADDL 624(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X13, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL 640(BP), X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X14, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X7, X7
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X5, X5
- PXOR X4, X0
- PXOR X5, X1
- PXOR X6, X0
- PXOR X7, X1
- LEAQ 64(SI), SI
- SUBQ $0x40, DX
- JNE loop
- MOVO X15, (BP)
- MOVQ (BP), R9
- MOVQ R9, (BX)
- MOVOU X0, (AX)
- MOVOU X1, 16(AX)
- RET
-
-// func hashBlocksSSE4(h *[8]uint32, c *[2]uint32, flag uint32, blocks []byte)
-// Requires: SSE2, SSE4.1, SSSE3
-TEXT ·hashBlocksSSE4(SB), $32-48
- MOVQ h+0(FP), AX
- MOVQ c+8(FP), BX
- MOVL flag+16(FP), CX
- MOVQ blocks_base+24(FP), SI
- MOVQ blocks_len+32(FP), DX
- MOVQ SP, BP
- ADDQ $0x0f, BP
- ANDQ $-16, BP
- MOVQ (BX), R9
- MOVQ R9, (BP)
- MOVQ CX, 8(BP)
- MOVOU (AX), X0
- MOVOU 16(AX), X1
- MOVOU iv0<>+0(SB), X2
- MOVOU iv1<>+0(SB), X3
- MOVOU counter<>+0(SB), X12
- MOVOU rol16<>+0(SB), X13
- MOVOU rol8<>+0(SB), X14
- MOVO (BP), X15
-
-loop:
- MOVO X0, X4
- MOVO X1, X5
- MOVO X2, X6
- MOVO X3, X7
- PADDQ X12, X15
- PXOR X15, X7
- MOVL (SI), X8
- PINSRD $0x01, 8(SI), X8
- PINSRD $0x02, 16(SI), X8
- PINSRD $0x03, 24(SI), X8
- MOVL 4(SI), X9
- PINSRD $0x01, 12(SI), X9
- PINSRD $0x02, 20(SI), X9
- PINSRD $0x03, 28(SI), X9
- MOVL 32(SI), X10
- PINSRD $0x01, 40(SI), X10
- PINSRD $0x02, 48(SI), X10
- PINSRD $0x03, 56(SI), X10
- MOVL 36(SI), X11
- PINSRD $0x01, 44(SI), X11
- PINSRD $0x02, 52(SI), X11
- PINSRD $0x03, 60(SI), X11
- PADDL X8, X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X13, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL X9, X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X14, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X5, X5
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X7, X7
- PADDL X10, X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X13, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL X11, X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X14, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X7, X7
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X5, X5
- MOVL 56(SI), X8
- PINSRD $0x01, 16(SI), X8
- PINSRD $0x02, 36(SI), X8
- PINSRD $0x03, 52(SI), X8
- MOVL 40(SI), X9
- PINSRD $0x01, 32(SI), X9
- PINSRD $0x02, 60(SI), X9
- PINSRD $0x03, 24(SI), X9
- MOVL 4(SI), X10
- PINSRD $0x01, (SI), X10
- PINSRD $0x02, 44(SI), X10
- PINSRD $0x03, 20(SI), X10
- MOVL 48(SI), X11
- PINSRD $0x01, 8(SI), X11
- PINSRD $0x02, 28(SI), X11
- PINSRD $0x03, 12(SI), X11
- PADDL X8, X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X13, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL X9, X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X14, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X5, X5
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X7, X7
- PADDL X10, X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X13, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL X11, X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X14, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X7, X7
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X5, X5
- MOVL 44(SI), X8
- PINSRD $0x01, 48(SI), X8
- PINSRD $0x02, 20(SI), X8
- PINSRD $0x03, 60(SI), X8
- MOVL 32(SI), X9
- PINSRD $0x01, (SI), X9
- PINSRD $0x02, 8(SI), X9
- PINSRD $0x03, 52(SI), X9
- MOVL 40(SI), X10
- PINSRD $0x01, 12(SI), X10
- PINSRD $0x02, 28(SI), X10
- PINSRD $0x03, 36(SI), X10
- MOVL 56(SI), X11
- PINSRD $0x01, 24(SI), X11
- PINSRD $0x02, 4(SI), X11
- PINSRD $0x03, 16(SI), X11
- PADDL X8, X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X13, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL X9, X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X14, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X5, X5
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X7, X7
- PADDL X10, X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X13, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL X11, X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X14, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X7, X7
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X5, X5
- MOVL 28(SI), X8
- PINSRD $0x01, 12(SI), X8
- PINSRD $0x02, 52(SI), X8
- PINSRD $0x03, 44(SI), X8
- MOVL 36(SI), X9
- PINSRD $0x01, 4(SI), X9
- PINSRD $0x02, 48(SI), X9
- PINSRD $0x03, 56(SI), X9
- MOVL 8(SI), X10
- PINSRD $0x01, 20(SI), X10
- PINSRD $0x02, 16(SI), X10
- PINSRD $0x03, 60(SI), X10
- MOVL 24(SI), X11
- PINSRD $0x01, 40(SI), X11
- PINSRD $0x02, (SI), X11
- PINSRD $0x03, 32(SI), X11
- PADDL X8, X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X13, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL X9, X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X14, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X5, X5
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X7, X7
- PADDL X10, X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X13, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL X11, X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X14, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X7, X7
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X5, X5
- MOVL 36(SI), X8
- PINSRD $0x01, 20(SI), X8
- PINSRD $0x02, 8(SI), X8
- PINSRD $0x03, 40(SI), X8
- MOVL (SI), X9
- PINSRD $0x01, 28(SI), X9
- PINSRD $0x02, 16(SI), X9
- PINSRD $0x03, 60(SI), X9
- MOVL 56(SI), X10
- PINSRD $0x01, 44(SI), X10
- PINSRD $0x02, 24(SI), X10
- PINSRD $0x03, 12(SI), X10
- MOVL 4(SI), X11
- PINSRD $0x01, 48(SI), X11
- PINSRD $0x02, 32(SI), X11
- PINSRD $0x03, 52(SI), X11
- PADDL X8, X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X13, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL X9, X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X14, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X5, X5
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X7, X7
- PADDL X10, X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X13, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL X11, X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X14, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X7, X7
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X5, X5
- MOVL 8(SI), X8
- PINSRD $0x01, 24(SI), X8
- PINSRD $0x02, (SI), X8
- PINSRD $0x03, 32(SI), X8
- MOVL 48(SI), X9
- PINSRD $0x01, 40(SI), X9
- PINSRD $0x02, 44(SI), X9
- PINSRD $0x03, 12(SI), X9
- MOVL 16(SI), X10
- PINSRD $0x01, 28(SI), X10
- PINSRD $0x02, 60(SI), X10
- PINSRD $0x03, 4(SI), X10
- MOVL 52(SI), X11
- PINSRD $0x01, 20(SI), X11
- PINSRD $0x02, 56(SI), X11
- PINSRD $0x03, 36(SI), X11
- PADDL X8, X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X13, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL X9, X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X14, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X5, X5
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X7, X7
- PADDL X10, X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X13, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL X11, X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X14, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X7, X7
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X5, X5
- MOVL 48(SI), X8
- PINSRD $0x01, 4(SI), X8
- PINSRD $0x02, 56(SI), X8
- PINSRD $0x03, 16(SI), X8
- MOVL 20(SI), X9
- PINSRD $0x01, 60(SI), X9
- PINSRD $0x02, 52(SI), X9
- PINSRD $0x03, 40(SI), X9
- MOVL (SI), X10
- PINSRD $0x01, 24(SI), X10
- PINSRD $0x02, 36(SI), X10
- PINSRD $0x03, 32(SI), X10
- MOVL 28(SI), X11
- PINSRD $0x01, 12(SI), X11
- PINSRD $0x02, 8(SI), X11
- PINSRD $0x03, 44(SI), X11
- PADDL X8, X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X13, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL X9, X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X14, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X5, X5
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X7, X7
- PADDL X10, X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X13, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL X11, X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X14, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X7, X7
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X5, X5
- MOVL 52(SI), X8
- PINSRD $0x01, 28(SI), X8
- PINSRD $0x02, 48(SI), X8
- PINSRD $0x03, 12(SI), X8
- MOVL 44(SI), X9
- PINSRD $0x01, 56(SI), X9
- PINSRD $0x02, 4(SI), X9
- PINSRD $0x03, 36(SI), X9
- MOVL 20(SI), X10
- PINSRD $0x01, 60(SI), X10
- PINSRD $0x02, 32(SI), X10
- PINSRD $0x03, 8(SI), X10
- MOVL (SI), X11
- PINSRD $0x01, 16(SI), X11
- PINSRD $0x02, 24(SI), X11
- PINSRD $0x03, 40(SI), X11
- PADDL X8, X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X13, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL X9, X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X14, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X5, X5
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X7, X7
- PADDL X10, X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X13, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL X11, X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X14, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X7, X7
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X5, X5
- MOVL 24(SI), X8
- PINSRD $0x01, 56(SI), X8
- PINSRD $0x02, 44(SI), X8
- PINSRD $0x03, (SI), X8
- MOVL 60(SI), X9
- PINSRD $0x01, 36(SI), X9
- PINSRD $0x02, 12(SI), X9
- PINSRD $0x03, 32(SI), X9
- MOVL 48(SI), X10
- PINSRD $0x01, 52(SI), X10
- PINSRD $0x02, 4(SI), X10
- PINSRD $0x03, 40(SI), X10
- MOVL 8(SI), X11
- PINSRD $0x01, 28(SI), X11
- PINSRD $0x02, 16(SI), X11
- PINSRD $0x03, 20(SI), X11
- PADDL X8, X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X13, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL X9, X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X14, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X5, X5
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X7, X7
- PADDL X10, X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X13, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL X11, X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X14, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X7, X7
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X5, X5
- MOVL 40(SI), X8
- PINSRD $0x01, 32(SI), X8
- PINSRD $0x02, 28(SI), X8
- PINSRD $0x03, 4(SI), X8
- MOVL 8(SI), X9
- PINSRD $0x01, 16(SI), X9
- PINSRD $0x02, 24(SI), X9
- PINSRD $0x03, 20(SI), X9
- MOVL 60(SI), X10
- PINSRD $0x01, 36(SI), X10
- PINSRD $0x02, 12(SI), X10
- PINSRD $0x03, 52(SI), X10
- MOVL 44(SI), X11
- PINSRD $0x01, 56(SI), X11
- PINSRD $0x02, 48(SI), X11
- PINSRD $0x03, (SI), X11
- PADDL X8, X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X13, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL X9, X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X14, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X5, X5
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X7, X7
- PADDL X10, X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X13, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x14, X8
- PSRLL $0x0c, X5
- PXOR X8, X5
- PADDL X11, X4
- PADDL X5, X4
- PXOR X4, X7
- PSHUFB X14, X7
- PADDL X7, X6
- PXOR X6, X5
- MOVO X5, X8
- PSLLL $0x19, X8
- PSRLL $0x07, X5
- PXOR X8, X5
- PSHUFL $0x39, X7, X7
- PSHUFL $0x4e, X6, X6
- PSHUFL $0x93, X5, X5
- PXOR X4, X0
- PXOR X5, X1
- PXOR X6, X0
- PXOR X7, X1
- LEAQ 64(SI), SI
- SUBQ $0x40, DX
- JNE loop
- MOVO X15, (BP)
- MOVQ (BP), R9
- MOVQ R9, (BX)
- MOVOU X0, (AX)
- MOVOU X1, 16(AX)
- RET
diff --git a/vendor/golang.org/x/crypto/blake2s/blake2s_generic.go b/vendor/golang.org/x/crypto/blake2s/blake2s_generic.go
deleted file mode 100644
index 24a1ff22a..000000000
--- a/vendor/golang.org/x/crypto/blake2s/blake2s_generic.go
+++ /dev/null
@@ -1,178 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package blake2s
-
-import (
- "math/bits"
-)
-
-// the precomputed values for BLAKE2s
-// there are 10 16-byte arrays - one for each round
-// the entries are calculated from the sigma constants.
-var precomputed = [10][16]byte{
- {0, 2, 4, 6, 1, 3, 5, 7, 8, 10, 12, 14, 9, 11, 13, 15},
- {14, 4, 9, 13, 10, 8, 15, 6, 1, 0, 11, 5, 12, 2, 7, 3},
- {11, 12, 5, 15, 8, 0, 2, 13, 10, 3, 7, 9, 14, 6, 1, 4},
- {7, 3, 13, 11, 9, 1, 12, 14, 2, 5, 4, 15, 6, 10, 0, 8},
- {9, 5, 2, 10, 0, 7, 4, 15, 14, 11, 6, 3, 1, 12, 8, 13},
- {2, 6, 0, 8, 12, 10, 11, 3, 4, 7, 15, 1, 13, 5, 14, 9},
- {12, 1, 14, 4, 5, 15, 13, 10, 0, 6, 9, 8, 7, 3, 2, 11},
- {13, 7, 12, 3, 11, 14, 1, 9, 5, 15, 8, 2, 0, 4, 6, 10},
- {6, 14, 11, 0, 15, 9, 3, 8, 12, 13, 1, 10, 2, 7, 4, 5},
- {10, 8, 7, 1, 2, 4, 6, 5, 15, 9, 3, 13, 11, 14, 12, 0},
-}
-
-func hashBlocksGeneric(h *[8]uint32, c *[2]uint32, flag uint32, blocks []byte) {
- var m [16]uint32
- c0, c1 := c[0], c[1]
-
- for i := 0; i < len(blocks); {
- c0 += BlockSize
- if c0 < BlockSize {
- c1++
- }
-
- v0, v1, v2, v3, v4, v5, v6, v7 := h[0], h[1], h[2], h[3], h[4], h[5], h[6], h[7]
- v8, v9, v10, v11, v12, v13, v14, v15 := iv[0], iv[1], iv[2], iv[3], iv[4], iv[5], iv[6], iv[7]
- v12 ^= c0
- v13 ^= c1
- v14 ^= flag
-
- for j := range m {
- m[j] = uint32(blocks[i]) | uint32(blocks[i+1])<<8 | uint32(blocks[i+2])<<16 | uint32(blocks[i+3])<<24
- i += 4
- }
-
- for k := range precomputed {
- s := &(precomputed[k])
-
- v0 += m[s[0]]
- v0 += v4
- v12 ^= v0
- v12 = bits.RotateLeft32(v12, -16)
- v8 += v12
- v4 ^= v8
- v4 = bits.RotateLeft32(v4, -12)
- v1 += m[s[1]]
- v1 += v5
- v13 ^= v1
- v13 = bits.RotateLeft32(v13, -16)
- v9 += v13
- v5 ^= v9
- v5 = bits.RotateLeft32(v5, -12)
- v2 += m[s[2]]
- v2 += v6
- v14 ^= v2
- v14 = bits.RotateLeft32(v14, -16)
- v10 += v14
- v6 ^= v10
- v6 = bits.RotateLeft32(v6, -12)
- v3 += m[s[3]]
- v3 += v7
- v15 ^= v3
- v15 = bits.RotateLeft32(v15, -16)
- v11 += v15
- v7 ^= v11
- v7 = bits.RotateLeft32(v7, -12)
-
- v0 += m[s[4]]
- v0 += v4
- v12 ^= v0
- v12 = bits.RotateLeft32(v12, -8)
- v8 += v12
- v4 ^= v8
- v4 = bits.RotateLeft32(v4, -7)
- v1 += m[s[5]]
- v1 += v5
- v13 ^= v1
- v13 = bits.RotateLeft32(v13, -8)
- v9 += v13
- v5 ^= v9
- v5 = bits.RotateLeft32(v5, -7)
- v2 += m[s[6]]
- v2 += v6
- v14 ^= v2
- v14 = bits.RotateLeft32(v14, -8)
- v10 += v14
- v6 ^= v10
- v6 = bits.RotateLeft32(v6, -7)
- v3 += m[s[7]]
- v3 += v7
- v15 ^= v3
- v15 = bits.RotateLeft32(v15, -8)
- v11 += v15
- v7 ^= v11
- v7 = bits.RotateLeft32(v7, -7)
-
- v0 += m[s[8]]
- v0 += v5
- v15 ^= v0
- v15 = bits.RotateLeft32(v15, -16)
- v10 += v15
- v5 ^= v10
- v5 = bits.RotateLeft32(v5, -12)
- v1 += m[s[9]]
- v1 += v6
- v12 ^= v1
- v12 = bits.RotateLeft32(v12, -16)
- v11 += v12
- v6 ^= v11
- v6 = bits.RotateLeft32(v6, -12)
- v2 += m[s[10]]
- v2 += v7
- v13 ^= v2
- v13 = bits.RotateLeft32(v13, -16)
- v8 += v13
- v7 ^= v8
- v7 = bits.RotateLeft32(v7, -12)
- v3 += m[s[11]]
- v3 += v4
- v14 ^= v3
- v14 = bits.RotateLeft32(v14, -16)
- v9 += v14
- v4 ^= v9
- v4 = bits.RotateLeft32(v4, -12)
-
- v0 += m[s[12]]
- v0 += v5
- v15 ^= v0
- v15 = bits.RotateLeft32(v15, -8)
- v10 += v15
- v5 ^= v10
- v5 = bits.RotateLeft32(v5, -7)
- v1 += m[s[13]]
- v1 += v6
- v12 ^= v1
- v12 = bits.RotateLeft32(v12, -8)
- v11 += v12
- v6 ^= v11
- v6 = bits.RotateLeft32(v6, -7)
- v2 += m[s[14]]
- v2 += v7
- v13 ^= v2
- v13 = bits.RotateLeft32(v13, -8)
- v8 += v13
- v7 ^= v8
- v7 = bits.RotateLeft32(v7, -7)
- v3 += m[s[15]]
- v3 += v4
- v14 ^= v3
- v14 = bits.RotateLeft32(v14, -8)
- v9 += v14
- v4 ^= v9
- v4 = bits.RotateLeft32(v4, -7)
- }
-
- h[0] ^= v0 ^ v8
- h[1] ^= v1 ^ v9
- h[2] ^= v2 ^ v10
- h[3] ^= v3 ^ v11
- h[4] ^= v4 ^ v12
- h[5] ^= v5 ^ v13
- h[6] ^= v6 ^ v14
- h[7] ^= v7 ^ v15
- }
- c[0], c[1] = c0, c1
-}
diff --git a/vendor/golang.org/x/crypto/blake2s/blake2s_ref.go b/vendor/golang.org/x/crypto/blake2s/blake2s_ref.go
deleted file mode 100644
index 38ce8e283..000000000
--- a/vendor/golang.org/x/crypto/blake2s/blake2s_ref.go
+++ /dev/null
@@ -1,17 +0,0 @@
-// Copyright 2016 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-//go:build (!amd64 && !386) || !gc || purego
-
-package blake2s
-
-var (
- useSSE4 = false
- useSSSE3 = false
- useSSE2 = false
-)
-
-func hashBlocks(h *[8]uint32, c *[2]uint32, flag uint32, blocks []byte) {
- hashBlocksGeneric(h, c, flag, blocks)
-}
diff --git a/vendor/golang.org/x/crypto/blake2s/blake2x.go b/vendor/golang.org/x/crypto/blake2s/blake2x.go
deleted file mode 100644
index 828749ff0..000000000
--- a/vendor/golang.org/x/crypto/blake2s/blake2x.go
+++ /dev/null
@@ -1,178 +0,0 @@
-// Copyright 2017 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-package blake2s
-
-import (
- "encoding/binary"
- "errors"
- "io"
-)
-
-// XOF defines the interface to hash functions that
-// support arbitrary-length output.
-type XOF interface {
- // Write absorbs more data into the hash's state. It panics if called
- // after Read.
- io.Writer
-
- // Read reads more output from the hash. It returns io.EOF if the limit
- // has been reached.
- io.Reader
-
- // Clone returns a copy of the XOF in its current state.
- Clone() XOF
-
- // Reset resets the XOF to its initial state.
- Reset()
-}
-
-// OutputLengthUnknown can be used as the size argument to NewXOF to indicate
-// the length of the output is not known in advance.
-const OutputLengthUnknown = 0
-
-// magicUnknownOutputLength is a magic value for the output size that indicates
-// an unknown number of output bytes.
-const magicUnknownOutputLength = 65535
-
-// maxOutputLength is the absolute maximum number of bytes to produce when the
-// number of output bytes is unknown.
-const maxOutputLength = (1 << 32) * 32
-
-// NewXOF creates a new variable-output-length hash. The hash either produce a
-// known number of bytes (1 <= size < 65535), or an unknown number of bytes
-// (size == OutputLengthUnknown). In the latter case, an absolute limit of
-// 128GiB applies.
-//
-// A non-nil key turns the hash into a MAC. The key must between
-// zero and 32 bytes long.
-func NewXOF(size uint16, key []byte) (XOF, error) {
- if len(key) > Size {
- return nil, errKeySize
- }
- if size == magicUnknownOutputLength {
- // 2^16-1 indicates an unknown number of bytes and thus isn't a
- // valid length.
- return nil, errors.New("blake2s: XOF length too large")
- }
- if size == OutputLengthUnknown {
- size = magicUnknownOutputLength
- }
- x := &xof{
- d: digest{
- size: Size,
- keyLen: len(key),
- },
- length: size,
- }
- copy(x.d.key[:], key)
- x.Reset()
- return x, nil
-}
-
-type xof struct {
- d digest
- length uint16
- remaining uint64
- cfg, root, block [Size]byte
- offset int
- nodeOffset uint32
- readMode bool
-}
-
-func (x *xof) Write(p []byte) (n int, err error) {
- if x.readMode {
- panic("blake2s: write to XOF after read")
- }
- return x.d.Write(p)
-}
-
-func (x *xof) Clone() XOF {
- clone := *x
- return &clone
-}
-
-func (x *xof) Reset() {
- x.cfg[0] = byte(Size)
- binary.LittleEndian.PutUint32(x.cfg[4:], uint32(Size)) // leaf length
- binary.LittleEndian.PutUint16(x.cfg[12:], x.length) // XOF length
- x.cfg[15] = byte(Size) // inner hash size
-
- x.d.Reset()
- x.d.h[3] ^= uint32(x.length)
-
- x.remaining = uint64(x.length)
- if x.remaining == magicUnknownOutputLength {
- x.remaining = maxOutputLength
- }
- x.offset, x.nodeOffset = 0, 0
- x.readMode = false
-}
-
-func (x *xof) Read(p []byte) (n int, err error) {
- if !x.readMode {
- x.d.finalize(&x.root)
- x.readMode = true
- }
-
- if x.remaining == 0 {
- return 0, io.EOF
- }
-
- n = len(p)
- if uint64(n) > x.remaining {
- n = int(x.remaining)
- p = p[:n]
- }
-
- if x.offset > 0 {
- blockRemaining := Size - x.offset
- if n < blockRemaining {
- x.offset += copy(p, x.block[x.offset:])
- x.remaining -= uint64(n)
- return
- }
- copy(p, x.block[x.offset:])
- p = p[blockRemaining:]
- x.offset = 0
- x.remaining -= uint64(blockRemaining)
- }
-
- for len(p) >= Size {
- binary.LittleEndian.PutUint32(x.cfg[8:], x.nodeOffset)
- x.nodeOffset++
-
- x.d.initConfig(&x.cfg)
- x.d.Write(x.root[:])
- x.d.finalize(&x.block)
-
- copy(p, x.block[:])
- p = p[Size:]
- x.remaining -= uint64(Size)
- }
-
- if todo := len(p); todo > 0 {
- if x.remaining < uint64(Size) {
- x.cfg[0] = byte(x.remaining)
- }
- binary.LittleEndian.PutUint32(x.cfg[8:], x.nodeOffset)
- x.nodeOffset++
-
- x.d.initConfig(&x.cfg)
- x.d.Write(x.root[:])
- x.d.finalize(&x.block)
-
- x.offset = copy(p, x.block[:todo])
- x.remaining -= uint64(todo)
- }
-
- return
-}
-
-func (d *digest) initConfig(cfg *[Size]byte) {
- d.offset, d.c[0], d.c[1] = 0, 0, 0
- for i := range d.h {
- d.h[i] = iv[i] ^ binary.LittleEndian.Uint32(cfg[i*4:])
- }
-}
generated by cgit v1.2.3 (git 2.46.0) at 2025-07-13 19:06:56 +0000