Update dependencies

vendor/github.com/klauspost/compress/zstd/bitreader.go

@@ -5,12 +5,11 @@
 package zstd
 
 import (
+	"encoding/binary"
 	"errors"
 	"fmt"
 	"io"
 	"math/bits"
-
-	"github.com/klauspost/compress/internal/le"
 )
 
 // bitReader reads a bitstream in reverse.
@@ -18,8 +17,8 @@ import (
 // for aligning the input.
 type bitReader struct {
 	in       []byte
+	off      uint   // next byte to read is at in[off - 1]
 	value    uint64 // Maybe use [16]byte, but shifting is awkward.
-	cursor   int    // offset where next read should end
 	bitsRead uint8
 }
 
@@ -29,12 +28,12 @@ func (b *bitReader) init(in []byte) error {
 		return errors.New("corrupt stream: too short")
 	}
 	b.in = in
+	b.off = uint(len(in))
 	// The highest bit of the last byte indicates where to start
 	v := in[len(in)-1]
 	if v == 0 {
 		return errors.New("corrupt stream, did not find end of stream")
 	}
-	b.cursor = len(in)
 	b.bitsRead = 64
 	b.value = 0
 	if len(in) >= 8 {
@@ -70,16 +69,21 @@ func (b *bitReader) fillFast() {
 	if b.bitsRead < 32 {
 		return
 	}
-	b.cursor -= 4
-	b.value = (b.value << 32) | uint64(le.Load32(b.in, b.cursor))
+	// 2 bounds checks.
+	v := b.in[b.off-4:]
+	v = v[:4]
+	low := (uint32(v[0])) | (uint32(v[1]) << 8) | (uint32(v[2]) << 16) | (uint32(v[3]) << 24)
+	b.value = (b.value << 32) | uint64(low)
 	b.bitsRead -= 32
+	b.off -= 4
 }
 
 // fillFastStart() assumes the bitreader is empty and there is at least 8 bytes to read.
 func (b *bitReader) fillFastStart() {
-	b.cursor -= 8
-	b.value = le.Load64(b.in, b.cursor)
+	// Do single re-slice to avoid bounds checks.
+	b.value = binary.LittleEndian.Uint64(b.in[b.off-8:])
 	b.bitsRead = 0
+	b.off -= 8
 }
 
 // fill() will make sure at least 32 bits are available.
@@ -87,23 +91,25 @@ func (b *bitReader) fill() {
 	if b.bitsRead < 32 {
 		return
 	}
-	if b.cursor >= 4 {
-		b.cursor -= 4
-		b.value = (b.value << 32) | uint64(le.Load32(b.in, b.cursor))
+	if b.off >= 4 {
+		v := b.in[b.off-4:]
+		v = v[:4]
+		low := (uint32(v[0])) | (uint32(v[1]) << 8) | (uint32(v[2]) << 16) | (uint32(v[3]) << 24)
+		b.value = (b.value << 32) | uint64(low)
 		b.bitsRead -= 32
+		b.off -= 4
 		return
 	}
-
-	b.bitsRead -= uint8(8 * b.cursor)
-	for b.cursor > 0 {
-		b.cursor -= 1
-		b.value = (b.value << 8) | uint64(b.in[b.cursor])
+	for b.off > 0 {
+		b.value = (b.value << 8) | uint64(b.in[b.off-1])
+		b.bitsRead -= 8
+		b.off--
 	}
 }
 
 // finished returns true if all bits have been read from the bit stream.
 func (b *bitReader) finished() bool {
-	return b.cursor == 0 && b.bitsRead >= 64
+	return b.off == 0 && b.bitsRead >= 64
 }
 
 // overread returns true if more bits have been requested than is on the stream.
@@ -113,14 +119,13 @@ func (b *bitReader) overread() bool {
 
 // remain returns the number of bits remaining.
 func (b *bitReader) remain() uint {
-	return 8*uint(b.cursor) + 64 - uint(b.bitsRead)
+	return b.off*8 + 64 - uint(b.bitsRead)
 }
 
 // close the bitstream and returns an error if out-of-buffer reads occurred.
 func (b *bitReader) close() error {
 	// Release reference.
 	b.in = nil
-	b.cursor = 0
 	if !b.finished() {
 		return fmt.Errorf("%d extra bits on block, should be 0", b.remain())
 	}