Make Nix builds work

1 files changed, 188 insertions, 0 deletions

diff --git a/vendor/github.com/minio/md5-simd/md5-digest_amd64.go b/vendor/github.com/minio/md5-simd/md5-digest_amd64.go
new file mode 100644
index 0000000..5ea23a4
--- /dev/null
+++ b/vendor/github.com/minio/md5-simd/md5-digest_amd64.go
@@ -0,0 +1,188 @@
+//+build !noasm,!appengine,gc
+
+// Copyright (c) 2020 MinIO Inc. All rights reserved.
+// Use of this source code is governed by a license that can be
+// found in the LICENSE file.
+
+package md5simd
+
+import (
+        "encoding/binary"
+        "errors"
+        "fmt"
+        "sync"
+        "sync/atomic"
+)
+
+// md5Digest - Type for computing MD5 using either AVX2 or AVX512
+type md5Digest struct {
+        uid         uint64
+        blocksCh    chan blockInput
+        cycleServer chan uint64
+        x           [BlockSize]byte
+        nx          int
+        len         uint64
+        buffers     <-chan []byte
+}
+
+// NewHash - initialize instance for Md5 implementation.
+func (s *md5Server) NewHash() Hasher {
+        uid := atomic.AddUint64(&s.uidCounter, 1)
+        blockCh := make(chan blockInput, buffersPerLane)
+        s.newInput <- newClient{
+                uid:   uid,
+                input: blockCh,
+        }
+        return &md5Digest{
+                uid:         uid,
+                buffers:     s.buffers,
+                blocksCh:    blockCh,
+                cycleServer: s.cycle,
+        }
+}
+
+// Size - Return size of checksum
+func (d *md5Digest) Size() int { return Size }
+
+// BlockSize - Return blocksize of checksum
+func (d md5Digest) BlockSize() int { return BlockSize }
+
+func (d *md5Digest) Reset() {
+        if d.blocksCh == nil {
+                panic("reset after close")
+        }
+        d.nx = 0
+        d.len = 0
+        d.sendBlock(blockInput{uid: d.uid, reset: true}, false)
+}
+
+// write to digest
+func (d *md5Digest) Write(p []byte) (nn int, err error) {
+        if d.blocksCh == nil {
+                return 0, errors.New("md5Digest closed")
+        }
+
+        // break input into chunks of maximum internalBlockSize size
+        for {
+                l := len(p)
+                if l > internalBlockSize {
+                        l = internalBlockSize
+                }
+                nnn, err := d.write(p[:l])
+                if err != nil {
+                        return nn, err
+                }
+                nn += nnn
+                p = p[l:]
+
+                if len(p) == 0 {
+                        break
+                }
+
+        }
+        return
+}
+
+func (d *md5Digest) write(p []byte) (nn int, err error) {
+
+        nn = len(p)
+        d.len += uint64(nn)
+        if d.nx > 0 {
+                n := copy(d.x[d.nx:], p)
+                d.nx += n
+                if d.nx == BlockSize {
+                        // Create a copy of the overflow buffer in order to send it async over the channel
+                        // (since we will modify the overflow buffer down below with any access beyond multiples of 64)
+                        tmp := <-d.buffers
+                        tmp = tmp[:BlockSize]
+                        copy(tmp, d.x[:])
+                        d.sendBlock(blockInput{uid: d.uid, msg: tmp}, len(p)-n < BlockSize)
+                        d.nx = 0
+                }
+                p = p[n:]
+        }
+        if len(p) >= BlockSize {
+                n := len(p) &^ (BlockSize - 1)
+                buf := <-d.buffers
+                buf = buf[:n]
+                copy(buf, p)
+                d.sendBlock(blockInput{uid: d.uid, msg: buf}, len(p)-n < BlockSize)
+                p = p[n:]
+        }
+        if len(p) > 0 {
+                d.nx = copy(d.x[:], p)
+        }
+        return
+}
+
+func (d *md5Digest) Close() {
+        if d.blocksCh != nil {
+                close(d.blocksCh)
+                d.blocksCh = nil
+        }
+}
+
+var sumChPool sync.Pool
+
+func init() {
+        sumChPool.New = func() interface{} {
+                return make(chan sumResult, 1)
+        }
+}
+
+// Sum - Return MD5 sum in bytes
+func (d *md5Digest) Sum(in []byte) (result []byte) {
+        if d.blocksCh == nil {
+                panic("sum after close")
+        }
+
+        trail := <-d.buffers
+        trail = append(trail[:0], d.x[:d.nx]...)
+
+        length := d.len
+        // Padding.  Add a 1 bit and 0 bits until 56 bytes mod 64.
+        var tmp [64]byte
+        tmp[0] = 0x80
+        if length%64 < 56 {
+                trail = append(trail, tmp[0:56-length%64]...)
+        } else {
+                trail = append(trail, tmp[0:64+56-length%64]...)
+        }
+
+        // Length in bits.
+        length <<= 3
+        binary.LittleEndian.PutUint64(tmp[:], length) // append length in bits
+
+        trail = append(trail, tmp[0:8]...)
+        if len(trail)%BlockSize != 0 {
+                panic(fmt.Errorf("internal error: sum block was not aligned. len=%d, nx=%d", len(trail), d.nx))
+        }
+        sumCh := sumChPool.Get().(chan sumResult)
+        d.sendBlock(blockInput{uid: d.uid, msg: trail, sumCh: sumCh}, true)
+
+        sum := <-sumCh
+        sumChPool.Put(sumCh)
+
+        return append(in, sum.digest[:]...)
+}
+
+// sendBlock will send a block for processing.
+// If cycle is true we will block on cycle, otherwise we will only block
+// if the block channel is full.
+func (d *md5Digest) sendBlock(bi blockInput, cycle bool) {
+        if cycle {
+                select {
+                case d.blocksCh <- bi:
+                        d.cycleServer <- d.uid
+                }
+                return
+        }
+        // Only block on cycle if we filled the buffer
+        select {
+        case d.blocksCh <- bi:
+                return
+        default:
+                d.cycleServer <- d.uid
+                d.blocksCh <- bi
+        }
+}