summaryrefslogtreecommitdiff
path: root/vendor/github.com/dchest/siphash
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/github.com/dchest/siphash')
-rw-r--r--vendor/github.com/dchest/siphash/.travis.yml10
-rw-r--r--vendor/github.com/dchest/siphash/README.md69
-rw-r--r--vendor/github.com/dchest/siphash/blocks.go148
-rw-r--r--vendor/github.com/dchest/siphash/blocks_amd64.s86
-rw-r--r--vendor/github.com/dchest/siphash/blocks_arm.s144
-rw-r--r--vendor/github.com/dchest/siphash/blocks_asm.go21
-rw-r--r--vendor/github.com/dchest/siphash/hash.go216
-rw-r--r--vendor/github.com/dchest/siphash/hash128.go302
-rw-r--r--vendor/github.com/dchest/siphash/hash128_amd64.s292
-rw-r--r--vendor/github.com/dchest/siphash/hash_amd64.s201
-rw-r--r--vendor/github.com/dchest/siphash/hash_arm.go27
-rw-r--r--vendor/github.com/dchest/siphash/hash_asm.go24
-rw-r--r--vendor/github.com/dchest/siphash/siphash.go318
13 files changed, 1858 insertions, 0 deletions
diff --git a/vendor/github.com/dchest/siphash/.travis.yml b/vendor/github.com/dchest/siphash/.travis.yml
new file mode 100644
index 0000000..707addd
--- /dev/null
+++ b/vendor/github.com/dchest/siphash/.travis.yml
@@ -0,0 +1,10 @@
+language: go
+
+go:
+ - 1.4
+ - 1.5
+ - 1.7
+ - 1.8
+ - 1.9
+ - 1.10
+ - tip
diff --git a/vendor/github.com/dchest/siphash/README.md b/vendor/github.com/dchest/siphash/README.md
new file mode 100644
index 0000000..a3645e1
--- /dev/null
+++ b/vendor/github.com/dchest/siphash/README.md
@@ -0,0 +1,69 @@
+SipHash (Go)
+============
+
+[![Build Status](https://travis-ci.org/dchest/siphash.svg)](https://travis-ci.org/dchest/siphash)
+
+Go implementation of SipHash-2-4, a fast short-input PRF created by
+Jean-Philippe Aumasson and Daniel J. Bernstein (http://131002.net/siphash/).
+
+
+## Installation
+
+ $ go get github.com/dchest/siphash
+
+## Usage
+
+ import "github.com/dchest/siphash"
+
+There are two ways to use this package.
+The slower one is to use the standard hash.Hash64 interface:
+
+ h := siphash.New(key)
+ h.Write([]byte("Hello"))
+ sum := h.Sum(nil) // returns 8-byte []byte
+
+or
+
+ sum64 := h.Sum64() // returns uint64
+
+The faster one is to use Hash() function, which takes two uint64 parts of
+16-byte key and a byte slice, and returns uint64 hash:
+
+ sum64 := siphash.Hash(key0, key1, []byte("Hello"))
+
+The keys and output are little-endian.
+
+
+## Functions
+
+### func Hash(k0, k1 uint64, p []byte) uint64
+
+Hash returns the 64-bit SipHash-2-4 of the given byte slice with two
+64-bit parts of 128-bit key: k0 and k1.
+
+### func Hash128(k0, k1 uint64, p []byte) (uint64, uint64)
+
+Hash128 returns the 128-bit SipHash-2-4 of the given byte slice with two
+64-bit parts of 128-bit key: k0 and k1.
+
+Note that 128-bit SipHash is considered experimental by SipHash authors at this time.
+
+### func New(key []byte) hash.Hash64
+
+New returns a new hash.Hash64 computing SipHash-2-4 with 16-byte key.
+
+### func New128(key []byte) hash.Hash
+
+New128 returns a new hash.Hash computing SipHash-2-4 with 16-byte key and 16-byte output.
+
+Note that 16-byte output is considered experimental by SipHash authors at this time.
+
+
+## Public domain dedication
+
+Written by Dmitry Chestnykh and Damian Gryski.
+
+To the extent possible under law, the authors have dedicated all copyright
+and related and neighboring rights to this software to the public domain
+worldwide. This software is distributed without any warranty.
+http://creativecommons.org/publicdomain/zero/1.0/
diff --git a/vendor/github.com/dchest/siphash/blocks.go b/vendor/github.com/dchest/siphash/blocks.go
new file mode 100644
index 0000000..817b215
--- /dev/null
+++ b/vendor/github.com/dchest/siphash/blocks.go
@@ -0,0 +1,148 @@
+// +build !arm,!amd64 appengine gccgo
+
+package siphash
+
+func once(d *digest) {
+ blocks(d, d.x[:])
+}
+
+func finalize(d *digest) uint64 {
+ d0 := *d
+ once(&d0)
+
+ v0, v1, v2, v3 := d0.v0, d0.v1, d0.v2, d0.v3
+ v2 ^= 0xff
+
+ // Round 1.
+ v0 += v1
+ v1 = v1<<13 | v1>>(64-13)
+ v1 ^= v0
+ v0 = v0<<32 | v0>>(64-32)
+
+ v2 += v3
+ v3 = v3<<16 | v3>>(64-16)
+ v3 ^= v2
+
+ v0 += v3
+ v3 = v3<<21 | v3>>(64-21)
+ v3 ^= v0
+
+ v2 += v1
+ v1 = v1<<17 | v1>>(64-17)
+ v1 ^= v2
+ v2 = v2<<32 | v2>>(64-32)
+
+ // Round 2.
+ v0 += v1
+ v1 = v1<<13 | v1>>(64-13)
+ v1 ^= v0
+ v0 = v0<<32 | v0>>(64-32)
+
+ v2 += v3
+ v3 = v3<<16 | v3>>(64-16)
+ v3 ^= v2
+
+ v0 += v3
+ v3 = v3<<21 | v3>>(64-21)
+ v3 ^= v0
+
+ v2 += v1
+ v1 = v1<<17 | v1>>(64-17)
+ v1 ^= v2
+ v2 = v2<<32 | v2>>(64-32)
+
+ // Round 3.
+ v0 += v1
+ v1 = v1<<13 | v1>>(64-13)
+ v1 ^= v0
+ v0 = v0<<32 | v0>>(64-32)
+
+ v2 += v3
+ v3 = v3<<16 | v3>>(64-16)
+ v3 ^= v2
+
+ v0 += v3
+ v3 = v3<<21 | v3>>(64-21)
+ v3 ^= v0
+
+ v2 += v1
+ v1 = v1<<17 | v1>>(64-17)
+ v1 ^= v2
+ v2 = v2<<32 | v2>>(64-32)
+
+ // Round 4.
+ v0 += v1
+ v1 = v1<<13 | v1>>(64-13)
+ v1 ^= v0
+ v0 = v0<<32 | v0>>(64-32)
+
+ v2 += v3
+ v3 = v3<<16 | v3>>(64-16)
+ v3 ^= v2
+
+ v0 += v3
+ v3 = v3<<21 | v3>>(64-21)
+ v3 ^= v0
+
+ v2 += v1
+ v1 = v1<<17 | v1>>(64-17)
+ v1 ^= v2
+ v2 = v2<<32 | v2>>(64-32)
+
+ return v0 ^ v1 ^ v2 ^ v3
+}
+
+func blocks(d *digest, p []uint8) {
+ v0, v1, v2, v3 := d.v0, d.v1, d.v2, d.v3
+
+ for len(p) >= BlockSize {
+ m := uint64(p[0]) | uint64(p[1])<<8 | uint64(p[2])<<16 | uint64(p[3])<<24 |
+ uint64(p[4])<<32 | uint64(p[5])<<40 | uint64(p[6])<<48 | uint64(p[7])<<56
+
+ v3 ^= m
+
+ // Round 1.
+ v0 += v1
+ v1 = v1<<13 | v1>>(64-13)
+ v1 ^= v0
+ v0 = v0<<32 | v0>>(64-32)
+
+ v2 += v3
+ v3 = v3<<16 | v3>>(64-16)
+ v3 ^= v2
+
+ v0 += v3
+ v3 = v3<<21 | v3>>(64-21)
+ v3 ^= v0
+
+ v2 += v1
+ v1 = v1<<17 | v1>>(64-17)
+ v1 ^= v2
+ v2 = v2<<32 | v2>>(64-32)
+
+ // Round 2.
+ v0 += v1
+ v1 = v1<<13 | v1>>(64-13)
+ v1 ^= v0
+ v0 = v0<<32 | v0>>(64-32)
+
+ v2 += v3
+ v3 = v3<<16 | v3>>(64-16)
+ v3 ^= v2
+
+ v0 += v3
+ v3 = v3<<21 | v3>>(64-21)
+ v3 ^= v0
+
+ v2 += v1
+ v1 = v1<<17 | v1>>(64-17)
+ v1 ^= v2
+ v2 = v2<<32 | v2>>(64-32)
+
+ v0 ^= m
+
+ p = p[BlockSize:]
+ }
+
+ d.v0, d.v1, d.v2, d.v3 = v0, v1, v2, v3
+}
diff --git a/vendor/github.com/dchest/siphash/blocks_amd64.s b/vendor/github.com/dchest/siphash/blocks_amd64.s
new file mode 100644
index 0000000..2d4816f
--- /dev/null
+++ b/vendor/github.com/dchest/siphash/blocks_amd64.s
@@ -0,0 +1,86 @@
+// +build amd64,!appengine,!gccgo
+
+#define ROUND(v0, v1, v2, v3) \
+ ADDQ v1, v0; \
+ RORQ $51, v1; \
+ ADDQ v3, v2; \
+ XORQ v0, v1; \
+ RORQ $48, v3; \
+ RORQ $32, v0; \
+ XORQ v2, v3; \
+ ADDQ v1, v2; \
+ ADDQ v3, v0; \
+ RORQ $43, v3; \
+ RORQ $47, v1; \
+ XORQ v0, v3; \
+ XORQ v2, v1; \
+ RORQ $32, v2
+
+// blocks(d *digest, data []uint8)
+TEXT ·blocks(SB),4,$0-32
+ MOVQ d+0(FP), BX
+ MOVQ 0(BX), R9 // R9 = v0
+ MOVQ 8(BX), R10 // R10 = v1
+ MOVQ 16(BX), R11 // R11 = v2
+ MOVQ 24(BX), R12 // R12 = v3
+ MOVQ p_base+8(FP), DI // DI = *uint64
+ MOVQ p_len+16(FP), SI // SI = nblocks
+ XORL DX, DX // DX = index (0)
+ SHRQ $3, SI // SI /= 8
+body:
+ CMPQ DX, SI
+ JGE end
+ MOVQ 0(DI)(DX*8), CX // CX = m
+ XORQ CX, R12
+ ROUND(R9, R10, R11, R12)
+ ROUND(R9, R10, R11, R12)
+ XORQ CX, R9
+ ADDQ $1, DX
+ JMP body
+end:
+ MOVQ R9, 0(BX)
+ MOVQ R10, 8(BX)
+ MOVQ R11, 16(BX)
+ MOVQ R12, 24(BX)
+ RET
+
+// once(d *digest)
+TEXT ·once(SB),4,$0-8
+ MOVQ d+0(FP), BX
+ MOVQ 0(BX), R9 // R9 = v0
+ MOVQ 8(BX), R10 // R10 = v1
+ MOVQ 16(BX), R11 // R11 = v2
+ MOVQ 24(BX), R12 // R12 = v3
+ MOVQ 48(BX), CX // CX = d.x[:]
+ XORQ CX, R12
+ ROUND(R9, R10, R11, R12)
+ ROUND(R9, R10, R11, R12)
+ XORQ CX, R9
+ MOVQ R9, 0(BX)
+ MOVQ R10, 8(BX)
+ MOVQ R11, 16(BX)
+ MOVQ R12, 24(BX)
+ RET
+
+// finalize(d *digest) uint64
+TEXT ·finalize(SB),4,$0-16
+ MOVQ d+0(FP), BX
+ MOVQ 0(BX), R9 // R9 = v0
+ MOVQ 8(BX), R10 // R10 = v1
+ MOVQ 16(BX), R11 // R11 = v2
+ MOVQ 24(BX), R12 // R12 = v3
+ MOVQ 48(BX), CX // CX = d.x[:]
+ XORQ CX, R12
+ ROUND(R9, R10, R11, R12)
+ ROUND(R9, R10, R11, R12)
+ XORQ CX, R9
+ NOTB R11
+ ROUND(R9, R10, R11, R12)
+ ROUND(R9, R10, R11, R12)
+ ROUND(R9, R10, R11, R12)
+ ROUND(R9, R10, R11, R12)
+ XORQ R12, R11
+ XORQ R10, R9
+ XORQ R11, R9
+ MOVQ R9, ret+8(FP)
+ RET
diff --git a/vendor/github.com/dchest/siphash/blocks_arm.s b/vendor/github.com/dchest/siphash/blocks_arm.s
new file mode 100644
index 0000000..bfcfd9b
--- /dev/null
+++ b/vendor/github.com/dchest/siphash/blocks_arm.s
@@ -0,0 +1,144 @@
+#include "textflag.h"
+
+#define ROUND()\
+ ADD.S R2,R0,R0;\
+ ADC R3,R1,R1;\
+ EOR R2<<13,R0,R8;\
+ EOR R3>>19,R8,R8;\
+ EOR R2>>19,R1,R11;\
+ EOR R3<<13,R11,R11;\
+ ADD.S R6,R4,R4;\
+ ADC R7,R5,R5;\
+ EOR R6<<16,R4,R2;\
+ EOR R7>>16,R2,R2;\
+ EOR R6>>16,R5,R3;\
+ EOR R7<<16,R3,R3;\
+ ADD.S R2,R1,R1;\
+ ADC R3,R0,R0;\
+ EOR R2<<21,R1,R6;\
+ EOR R3>>11,R6,R6;\
+ EOR R2>>11,R0,R7;\
+ EOR R3<<21,R7,R7;\
+ ADD.S R8,R4,R4;\
+ ADC R11,R5,R5;\
+ EOR R8<<17,R4,R2;\
+ EOR R11>>15,R2,R2;\
+ EOR R8>>15,R5,R3;\
+ EOR R11<<17,R3,R3;\
+ ADD.S R2,R1,R1;\
+ ADC R3,R0,R0;\
+ EOR R2<<13,R1,R8;\
+ EOR R3>>19,R8,R8;\
+ EOR R2>>19,R0,R11;\
+ EOR R3<<13,R11,R11;\
+ ADD.S R6,R5,R5;\
+ ADC R7,R4,R4;\
+ EOR R6<<16,R5,R2;\
+ EOR R7>>16,R2,R2;\
+ EOR R6>>16,R4,R3;\
+ EOR R7<<16,R3,R3;\
+ ADD.S R2,R0,R0;\
+ ADC R3,R1,R1;\
+ EOR R2<<21,R0,R6;\
+ EOR R3>>11,R6,R6;\
+ EOR R2>>11,R1,R7;\
+ EOR R3<<21,R7,R7;\
+ ADD.S R8,R5,R5;\
+ ADC R11,R4,R4;\
+ EOR R8<<17,R5,R2;\
+ EOR R11>>15,R2,R2;\
+ EOR R8>>15,R4,R3;\
+ EOR R11<<17,R3,R3;
+
+// once(d *digest)
+TEXT ·once(SB),NOSPLIT,$4-4
+ MOVW d+0(FP),R8
+ MOVM.IA (R8),[R0,R1,R2,R3,R4,R5,R6,R7]
+ MOVW 48(R8),R12
+ MOVW 52(R8),R14
+ EOR R12,R6,R6
+ EOR R14,R7,R7
+ ROUND()
+ EOR R12,R0,R0
+ EOR R14,R1,R1
+ MOVW d+0(FP),R8
+ MOVM.IA [R0,R1,R2,R3,R4,R5,R6,R7],(R8)
+ RET
+
+// finalize(d *digest) uint64
+TEXT ·finalize(SB),NOSPLIT,$4-12
+ MOVW d+0(FP),R8
+ MOVM.IA (R8),[R0,R1,R2,R3,R4,R5,R6,R7]
+ MOVW 48(R8),R12
+ MOVW 52(R8),R14
+ EOR R12,R6,R6
+ EOR R14,R7,R7
+ ROUND()
+ EOR R12,R0,R0
+ EOR R14,R1,R1
+ EOR $255,R4
+ ROUND()
+ ROUND()
+ EOR R2,R0,R0
+ EOR R3,R1,R1
+ EOR R6,R4,R4
+ EOR R7,R5,R5
+ EOR R4,R0,R0
+ EOR R5,R1,R1
+ MOVW R0,ret_lo+4(FP)
+ MOVW R1,ret_hi+8(FP)
+ RET
+
+// blocks(d *digest, data []uint8)
+TEXT ·blocks(SB),NOSPLIT,$8-16
+ MOVW R9,sav-8(SP)
+ MOVW d+0(FP),R8
+ MOVM.IA (R8),[R0,R1,R2,R3,R4,R5,R6,R7]
+ MOVW p+4(FP),R9
+ MOVW p_len+8(FP),R11
+ ADD R9,R11,R11
+ MOVW R11,endp-4(SP)
+ AND.S $3,R9,R8
+ BNE blocksunaligned
+blocksloop:
+ MOVM.IA.W (R9),[R12,R14]
+ EOR R12,R6,R6
+ EOR R14,R7,R7
+ ROUND()
+ EOR R12,R0,R0
+ EOR R14,R1,R1
+ MOVW endp-4(SP),R11
+ CMP R11,R9
+ BLO blocksloop
+ MOVW d+0(FP),R8
+ MOVM.IA [R0,R1,R2,R3,R4,R5,R6,R7],(R8)
+ MOVW sav-8(SP),R9
+ RET
+blocksunaligned:
+ MOVBU (R9),R12
+ MOVBU 1(R9),R11
+ ORR R11<<8,R12,R12
+ MOVBU 2(R9),R11
+ ORR R11<<16,R12,R12
+ MOVBU 3(R9),R11
+ ORR R11<<24,R12,R12
+ MOVBU 4(R9),R14
+ MOVBU 5(R9),R11
+ ORR R11<<8,R14,R14
+ MOVBU 6(R9),R11
+ ORR R11<<16,R14,R14
+ MOVBU 7(R9),R11
+ ORR R11<<24,R14,R14
+ ADD $8,R9,R9
+ EOR R12,R6,R6
+ EOR R14,R7,R7
+ ROUND()
+ EOR R12,R0,R0
+ EOR R14,R1,R1
+ MOVW endp-4(SP),R11
+ CMP R11,R9
+ BLO blocksunaligned
+ MOVW d+0(FP),R8
+ MOVM.IA [R0,R1,R2,R3,R4,R5,R6,R7],(R8)
+ MOVW sav-8(SP),R9
+ RET
diff --git a/vendor/github.com/dchest/siphash/blocks_asm.go b/vendor/github.com/dchest/siphash/blocks_asm.go
new file mode 100644
index 0000000..a238394
--- /dev/null
+++ b/vendor/github.com/dchest/siphash/blocks_asm.go
@@ -0,0 +1,21 @@
+// +build arm amd64,!appengine,!gccgo
+
+// Written in 2012 by Dmitry Chestnykh.
+//
+// To the extent possible under law, the author have dedicated all copyright
+// and related and neighboring rights to this software to the public domain
+// worldwide. This software is distributed without any warranty.
+// http://creativecommons.org/publicdomain/zero/1.0/
+
+// This file contains a function definition for use with assembly implementations of Hash()
+
+package siphash
+
+//go:noescape
+func blocks(d *digest, p []uint8)
+
+//go:noescape
+func finalize(d *digest) uint64
+
+//go:noescape
+func once(d *digest)
diff --git a/vendor/github.com/dchest/siphash/hash.go b/vendor/github.com/dchest/siphash/hash.go
new file mode 100644
index 0000000..0de28d0
--- /dev/null
+++ b/vendor/github.com/dchest/siphash/hash.go
@@ -0,0 +1,216 @@
+// +build !arm,!amd64 appengine gccgo
+
+// Written in 2012 by Dmitry Chestnykh.
+//
+// To the extent possible under law, the author have dedicated all copyright
+// and related and neighboring rights to this software to the public domain
+// worldwide. This software is distributed without any warranty.
+// http://creativecommons.org/publicdomain/zero/1.0/
+
+package siphash
+
+// Hash returns the 64-bit SipHash-2-4 of the given byte slice with two 64-bit
+// parts of 128-bit key: k0 and k1.
+func Hash(k0, k1 uint64, p []byte) uint64 {
+ // Initialization.
+ v0 := k0 ^ 0x736f6d6570736575
+ v1 := k1 ^ 0x646f72616e646f6d
+ v2 := k0 ^ 0x6c7967656e657261
+ v3 := k1 ^ 0x7465646279746573
+ t := uint64(len(p)) << 56
+
+ // Compression.
+ for len(p) >= BlockSize {
+ m := uint64(p[0]) | uint64(p[1])<<8 | uint64(p[2])<<16 | uint64(p[3])<<24 |
+ uint64(p[4])<<32 | uint64(p[5])<<40 | uint64(p[6])<<48 | uint64(p[7])<<56
+ v3 ^= m
+
+ // Round 1.
+ v0 += v1
+ v1 = v1<<13 | v1>>(64-13)
+ v1 ^= v0
+ v0 = v0<<32 | v0>>(64-32)
+
+ v2 += v3
+ v3 = v3<<16 | v3>>(64-16)
+ v3 ^= v2
+
+ v0 += v3
+ v3 = v3<<21 | v3>>(64-21)
+ v3 ^= v0
+
+ v2 += v1
+ v1 = v1<<17 | v1>>(64-17)
+ v1 ^= v2
+ v2 = v2<<32 | v2>>(64-32)
+
+ // Round 2.
+ v0 += v1
+ v1 = v1<<13 | v1>>(64-13)
+ v1 ^= v0
+ v0 = v0<<32 | v0>>(64-32)
+
+ v2 += v3
+ v3 = v3<<16 | v3>>(64-16)
+ v3 ^= v2
+
+ v0 += v3
+ v3 = v3<<21 | v3>>(64-21)
+ v3 ^= v0
+
+ v2 += v1
+ v1 = v1<<17 | v1>>(64-17)
+ v1 ^= v2
+ v2 = v2<<32 | v2>>(64-32)
+
+ v0 ^= m
+ p = p[BlockSize:]
+ }
+
+ // Compress last block.
+ switch len(p) {
+ case 7:
+ t |= uint64(p[6]) << 48
+ fallthrough
+ case 6:
+ t |= uint64(p[5]) << 40
+ fallthrough
+ case 5:
+ t |= uint64(p[4]) << 32
+ fallthrough
+ case 4:
+ t |= uint64(p[3]) << 24
+ fallthrough
+ case 3:
+ t |= uint64(p[2]) << 16
+ fallthrough
+ case 2:
+ t |= uint64(p[1]) << 8
+ fallthrough
+ case 1:
+ t |= uint64(p[0])
+ }
+
+ v3 ^= t
+
+ // Round 1.
+ v0 += v1
+ v1 = v1<<13 | v1>>(64-13)
+ v1 ^= v0
+ v0 = v0<<32 | v0>>(64-32)
+
+ v2 += v3
+ v3 = v3<<16 | v3>>(64-16)
+ v3 ^= v2
+
+ v0 += v3
+ v3 = v3<<21 | v3>>(64-21)
+ v3 ^= v0
+
+ v2 += v1
+ v1 = v1<<17 | v1>>(64-17)
+ v1 ^= v2
+ v2 = v2<<32 | v2>>(64-32)
+
+ // Round 2.
+ v0 += v1
+ v1 = v1<<13 | v1>>(64-13)
+ v1 ^= v0
+ v0 = v0<<32 | v0>>(64-32)
+
+ v2 += v3
+ v3 = v3<<16 | v3>>(64-16)
+ v3 ^= v2
+
+ v0 += v3
+ v3 = v3<<21 | v3>>(64-21)
+ v3 ^= v0
+
+ v2 += v1
+ v1 = v1<<17 | v1>>(64-17)
+ v1 ^= v2
+ v2 = v2<<32 | v2>>(64-32)
+
+ v0 ^= t
+
+ // Finalization.
+ v2 ^= 0xff
+
+ // Round 1.
+ v0 += v1
+ v1 = v1<<13 | v1>>(64-13)
+ v1 ^= v0
+ v0 = v0<<32 | v0>>(64-32)
+
+ v2 += v3
+ v3 = v3<<16 | v3>>(64-16)
+ v3 ^= v2
+
+ v0 += v3
+ v3 = v3<<21 | v3>>(64-21)
+ v3 ^= v0
+
+ v2 += v1
+ v1 = v1<<17 | v1>>(64-17)
+ v1 ^= v2
+ v2 = v2<<32 | v2>>(64-32)
+
+ // Round 2.
+ v0 += v1
+ v1 = v1<<13 | v1>>(64-13)
+ v1 ^= v0
+ v0 = v0<<32 | v0>>(64-32)
+
+ v2 += v3
+ v3 = v3<<16 | v3>>(64-16)
+ v3 ^= v2
+
+ v0 += v3
+ v3 = v3<<21 | v3>>(64-21)
+ v3 ^= v0
+
+ v2 += v1
+ v1 = v1<<17 | v1>>(64-17)
+ v1 ^= v2
+ v2 = v2<<32 | v2>>(64-32)
+
+ // Round 3.
+ v0 += v1
+ v1 = v1<<13 | v1>>(64-13)
+ v1 ^= v0
+ v0 = v0<<32 | v0>>(64-32)
+
+ v2 += v3
+ v3 = v3<<16 | v3>>(64-16)
+ v3 ^= v2
+
+ v0 += v3
+ v3 = v3<<21 | v3>>(64-21)
+ v3 ^= v0
+
+ v2 += v1
+ v1 = v1<<17 | v1>>(64-17)
+ v1 ^= v2
+ v2 = v2<<32 | v2>>(64-32)
+
+ // Round 4.
+ v0 += v1
+ v1 = v1<<13 | v1>>(64-13)
+ v1 ^= v0
+ v0 = v0<<32 | v0>>(64-32)
+
+ v2 += v3
+ v3 = v3<<16 | v3>>(64-16)
+ v3 ^= v2
+
+ v0 += v3
+ v3 = v3<<21 | v3>>(64-21)
+ v3 ^= v0
+
+ v2 += v1
+ v1 = v1<<17 | v1>>(64-17)
+ v1 ^= v2
+ v2 = v2<<32 | v2>>(64-32)
+
+ return v0 ^ v1 ^ v2 ^ v3
+}
diff --git a/vendor/github.com/dchest/siphash/hash128.go b/vendor/github.com/dchest/siphash/hash128.go
new file mode 100644
index 0000000..634ce57
--- /dev/null
+++ b/vendor/github.com/dchest/siphash/hash128.go
@@ -0,0 +1,302 @@
+// +build !arm,!amd64 appengine gccgo
+// Written in 2012 by Dmitry Chestnykh.
+// Modifications 2014 for 128-bit hash function by Damian Gryski.
+//
+// To the extent possible under law, the authors have dedicated all copyright
+// and related and neighboring rights to this software to the public domain
+// worldwide. This software is distributed without any warranty.
+// http://creativecommons.org/publicdomain/zero/1.0/
+
+package siphash
+
+// Hash returns the 128-bit SipHash-2-4 of the given byte slice with two 64-bit
+// parts of 128-bit key: k0 and k1.
+//
+// Note that 128-bit SipHash is considered experimental by SipHash authors at this time.
+func Hash128(k0, k1 uint64, p []byte) (uint64, uint64) {
+ // Initialization.
+ v0 := k0 ^ 0x736f6d6570736575
+ v1 := k1 ^ 0x646f72616e646f6d
+ v2 := k0 ^ 0x6c7967656e657261
+ v3 := k1 ^ 0x7465646279746573
+ t := uint64(len(p)) << 56
+
+ v1 ^= 0xee
+
+ // Compression.
+ for len(p) >= BlockSize {
+ m := uint64(p[0]) | uint64(p[1])<<8 | uint64(p[2])<<16 | uint64(p[3])<<24 |
+ uint64(p[4])<<32 | uint64(p[5])<<40 | uint64(p[6])<<48 | uint64(p[7])<<56
+ v3 ^= m
+
+ // Round 1.
+ v0 += v1
+ v1 = v1<<13 | v1>>(64-13)
+ v1 ^= v0
+ v0 = v0<<32 | v0>>(64-32)
+
+ v2 += v3
+ v3 = v3<<16 | v3>>(64-16)
+ v3 ^= v2
+
+ v0 += v3
+ v3 = v3<<21 | v3>>(64-21)
+ v3 ^= v0
+
+ v2 += v1
+ v1 = v1<<17 | v1>>(64-17)
+ v1 ^= v2
+ v2 = v2<<32 | v2>>(64-32)
+
+ // Round 2.
+ v0 += v1
+ v1 = v1<<13 | v1>>(64-13)
+ v1 ^= v0
+ v0 = v0<<32 | v0>>(64-32)
+
+ v2 += v3
+ v3 = v3<<16 | v3>>(64-16)
+ v3 ^= v2
+
+ v0 += v3
+ v3 = v3<<21 | v3>>(64-21)
+ v3 ^= v0
+
+ v2 += v1
+ v1 = v1<<17 | v1>>(64-17)
+ v1 ^= v2
+ v2 = v2<<32 | v2>>(64-32)
+
+ v0 ^= m
+ p = p[BlockSize:]
+ }
+
+ // Compress last block.
+ switch len(p) {
+ case 7:
+ t |= uint64(p[6]) << 48
+ fallthrough
+ case 6:
+ t |= uint64(p[5]) << 40
+ fallthrough
+ case 5:
+ t |= uint64(p[4]) << 32
+ fallthrough
+ case 4:
+ t |= uint64(p[3]) << 24
+ fallthrough
+ case 3:
+ t |= uint64(p[2]) << 16
+ fallthrough
+ case 2:
+ t |= uint64(p[1]) << 8
+ fallthrough
+ case 1:
+ t |= uint64(p[0])
+ }
+
+ v3 ^= t
+
+ // Round 1.
+ v0 += v1
+ v1 = v1<<13 | v1>>(64-13)
+ v1 ^= v0
+ v0 = v0<<32 | v0>>(64-32)
+
+ v2 += v3
+ v3 = v3<<16 | v3>>(64-16)
+ v3 ^= v2
+
+ v0 += v3
+ v3 = v3<<21 | v3>>(64-21)
+ v3 ^= v0
+
+ v2 += v1
+ v1 = v1<<17 | v1>>(64-17)
+ v1 ^= v2
+ v2 = v2<<32 | v2>>(64-32)
+
+ // Round 2.
+ v0 += v1
+ v1 = v1<<13 | v1>>(64-13)
+ v1 ^= v0
+ v0 = v0<<32 | v0>>(64-32)
+
+ v2 += v3
+ v3 = v3<<16 | v3>>(64-16)
+ v3 ^= v2
+
+ v0 += v3
+ v3 = v3<<21 | v3>>(64-21)
+ v3 ^= v0
+
+ v2 += v1
+ v1 = v1<<17 | v1>>(64-17)
+ v1 ^= v2
+ v2 = v2<<32 | v2>>(64-32)
+
+ v0 ^= t
+
+ // Finalization.
+ v2 ^= 0xee
+
+ // Round 1.
+ v0 += v1
+ v1 = v1<<13 | v1>>(64-13)
+ v1 ^= v0
+ v0 = v0<<32 | v0>>(64-32)
+
+ v2 += v3
+ v3 = v3<<16 | v3>>(64-16)
+ v3 ^= v2
+
+ v0 += v3
+ v3 = v3<<21 | v3>>(64-21)
+ v3 ^= v0
+
+ v2 += v1
+ v1 = v1<<17 | v1>>(64-17)
+ v1 ^= v2
+ v2 = v2<<32 | v2>>(64-32)
+
+ // Round 2.
+ v0 += v1
+ v1 = v1<<13 | v1>>(64-13)
+ v1 ^= v0
+ v0 = v0<<32 | v0>>(64-32)
+
+ v2 += v3
+ v3 = v3<<16 | v3>>(64-16)
+ v3 ^= v2
+
+ v0 += v3
+ v3 = v3<<21 | v3>>(64-21)
+ v3 ^= v0
+
+ v2 += v1
+ v1 = v1<<17 | v1>>(64-17)
+ v1 ^= v2
+ v2 = v2<<32 | v2>>(64-32)
+
+ // Round 3.
+ v0 += v1
+ v1 = v1<<13 | v1>>(64-13)
+ v1 ^= v0
+ v0 = v0<<32 | v0>>(64-32)
+
+ v2 += v3
+ v3 = v3<<16 | v3>>(64-16)
+ v3 ^= v2
+
+ v0 += v3
+ v3 = v3<<21 | v3>>(64-21)
+ v3 ^= v0
+
+ v2 += v1
+ v1 = v1<<17 | v1>>(64-17)
+ v1 ^= v2
+ v2 = v2<<32 | v2>>(64-32)
+
+ // Round 4.
+ v0 += v1
+ v1 = v1<<13 | v1>>(64-13)
+ v1 ^= v0
+ v0 = v0<<32 | v0>>(64-32)
+
+ v2 += v3
+ v3 = v3<<16 | v3>>(64-16)
+ v3 ^= v2
+
+ v0 += v3
+ v3 = v3<<21 | v3>>(64-21)
+ v3 ^= v0
+
+ v2 += v1
+ v1 = v1<<17 | v1>>(64-17)
+ v1 ^= v2
+ v2 = v2<<32 | v2>>(64-32)
+
+ r0 := v0 ^ v1 ^ v2 ^ v3
+
+ v1 ^= 0xdd
+
+ // Round 1.
+ v0 += v1
+ v1 = v1<<13 | v1>>(64-13)
+ v1 ^= v0
+ v0 = v0<<32 | v0>>(64-32)
+
+ v2 += v3
+ v3 = v3<<16 | v3>>(64-16)
+ v3 ^= v2
+
+ v0 += v3
+ v3 = v3<<21 | v3>>(64-21)
+ v3 ^= v0
+
+ v2 += v1
+ v1 = v1<<17 | v1>>(64-17)
+ v1 ^= v2
+ v2 = v2<<32 | v2>>(64-32)
+
+ // Round 2.
+ v0 += v1
+ v1 = v1<<13 | v1>>(64-13)
+ v1 ^= v0
+ v0 = v0<<32 | v0>>(64-32)
+
+ v2 += v3
+ v3 = v3<<16 | v3>>(64-16)
+ v3 ^= v2
+
+ v0 += v3
+ v3 = v3<<21 | v3>>(64-21)
+ v3 ^= v0
+
+ v2 += v1
+ v1 = v1<<17 | v1>>(64-17)
+ v1 ^= v2
+ v2 = v2<<32 | v2>>(64-32)
+
+ // Round 3.
+ v0 += v1
+ v1 = v1<<13 | v1>>(64-13)
+ v1 ^= v0
+ v0 = v0<<32 | v0>>(64-32)
+
+ v2 += v3
+ v3 = v3<<16 | v3>>(64-16)
+ v3 ^= v2
+
+ v0 += v3
+ v3 = v3<<21 | v3>>(64-21)
+ v3 ^= v0
+
+ v2 += v1
+ v1 = v1<<17 | v1>>(64-17)
+ v1 ^= v2
+ v2 = v2<<32 | v2>>(64-32)
+
+ // Round 4.
+ v0 += v1
+ v1 = v1<<13 | v1>>(64-13)
+ v1 ^= v0
+ v0 = v0<<32 | v0>>(64-32)
+
+ v2 += v3
+ v3 = v3<<16 | v3>>(64-16)
+ v3 ^= v2
+
+ v0 += v3
+ v3 = v3<<21 | v3>>(64-21)
+ v3 ^= v0
+
+ v2 += v1
+ v1 = v1<<17 | v1>>(64-17)
+ v1 ^= v2
+ v2 = v2<<32 | v2>>(64-32)
+
+ r1 := v0 ^ v1 ^ v2 ^ v3
+
+ return r0, r1
+}
diff --git a/vendor/github.com/dchest/siphash/hash128_amd64.s b/vendor/github.com/dchest/siphash/hash128_amd64.s
new file mode 100644
index 0000000..86605cc
--- /dev/null
+++ b/vendor/github.com/dchest/siphash/hash128_amd64.s
@@ -0,0 +1,292 @@
+// +build amd64,!appengine,!gccgo
+
+// This is a translation of the gcc output of FloodyBerry's pure-C public
+// domain siphash implementation at https://github.com/floodyberry/siphash
+
+// This assembly code has been modified from the 64-bit output to the experiment 128-bit output.
+
+// SI = v0
+// AX = v1
+// CX = v2
+// DX = v3
+
+// func Hash128(k0, k1 uint64, b []byte) (r0 uint64, r1 uint64)
+TEXT ·Hash128(SB),4,$0-56
+ MOVQ k0+0(FP),CX
+ MOVQ $0x736F6D6570736575,R9
+ MOVQ k1+8(FP),DI
+ MOVQ $0x6C7967656E657261,BX
+ MOVQ $0x646F72616E646F6D,AX
+ MOVQ b_len+24(FP),DX
+ XORQ $0xEE,AX
+ MOVQ DX,R11
+ MOVQ DX,R10
+ XORQ CX,R9
+ XORQ CX,BX
+ MOVQ $0x7465646279746573,CX
+ XORQ DI,AX
+ XORQ DI,CX
+ SHLQ $0x38,R11
+ XORQ DI,DI
+ MOVQ b_base+16(FP),SI
+ ANDQ $0xFFFFFFFFFFFFFFF8,R10
+ JE afterLoop
+ XCHGQ AX,AX
+loopBody:
+ MOVQ 0(SI)(DI*1),R8
+ ADDQ AX,R9
+ RORQ $0x33,AX
+ XORQ R9,AX
+ RORQ $0x20,R9
+ ADDQ $0x8,DI
+ XORQ R8,CX
+ ADDQ CX,BX
+ RORQ $0x30,CX
+ XORQ BX,CX
+ ADDQ AX,BX
+ RORQ $0x2F,AX
+ ADDQ CX,R9
+ RORQ $0x2B,CX
+ XORQ BX,AX
+ XORQ R9,CX
+ RORQ $0x20,BX
+ ADDQ AX,R9
+ ADDQ CX,BX
+ RORQ $0x33,AX
+ RORQ $0x30,CX
+ XORQ R9,AX
+ XORQ BX,CX
+ RORQ $0x20,R9
+ ADDQ AX,BX
+ ADDQ CX,R9
+ RORQ $0x2F,AX
+ RORQ $0x2B,CX
+ XORQ BX,AX
+ RORQ $0x20,BX
+ XORQ R9,CX
+ XORQ R8,R9
+ CMPQ R10,DI
+ JA loopBody
+afterLoop:
+ SUBQ R10,DX
+
+ CMPQ DX,$0x7
+ JA afterSwitch
+
+ // no support for jump tables
+
+ CMPQ DX,$0x7
+ JE sw7
+
+ CMPQ DX,$0x6
+ JE sw6
+
+ CMPQ DX,$0x5
+ JE sw5
+
+ CMPQ DX,$0x4
+ JE sw4
+
+ CMPQ DX,$0x3
+ JE sw3
+
+ CMPQ DX,$0x2
+ JE sw2
+
+ CMPQ DX,$0x1
+ JE sw1
+
+ JMP afterSwitch
+
+sw7: MOVBQZX 6(SI)(DI*1),DX
+ SHLQ $0x30,DX
+ ORQ DX,R11
+sw6: MOVBQZX 0x5(SI)(DI*1),DX
+ SHLQ $0x28,DX
+ ORQ DX,R11
+sw5: MOVBQZX 0x4(SI)(DI*1),DX
+ SHLQ $0x20,DX
+ ORQ DX,R11
+sw4: MOVBQZX 0x3(SI)(DI*1),DX
+ SHLQ $0x18,DX
+ ORQ DX,R11
+sw3: MOVBQZX 0x2(SI)(DI*1),DX
+ SHLQ $0x10,DX
+ ORQ DX,R11
+sw2: MOVBQZX 0x1(SI)(DI*1),DX
+ SHLQ $0x8,DX
+ ORQ DX,R11
+sw1: MOVBQZX 0(SI)(DI*1),DX
+ ORQ DX,R11
+afterSwitch:
+ LEAQ (AX)(R9*1),SI
+ XORQ R11,CX
+ RORQ $0x33,AX
+ ADDQ CX,BX
+ MOVQ CX,DX
+ XORQ SI,AX
+ RORQ $0x30,DX
+ RORQ $0x20,SI
+ LEAQ 0(BX)(AX*1),CX
+ XORQ BX,DX
+ RORQ $0x2F,AX
+ ADDQ DX,SI
+ RORQ $0x2B,DX
+ XORQ CX,AX
+ XORQ SI,DX
+ RORQ $0x20,CX
+ ADDQ AX,SI
+ RORQ $0x33,AX
+ ADDQ DX,CX
+ XORQ SI,AX
+ RORQ $0x30,DX
+ RORQ $0x20,SI
+ XORQ CX,DX
+ ADDQ AX,CX
+ RORQ $0x2F,AX
+ ADDQ DX,SI
+ XORQ CX,AX
+ RORQ $0x2B,DX
+ RORQ $0x20,CX
+ XORQ SI,DX
+ XORQ R11,SI
+ XORB $0xEE,CL
+ ADDQ AX,SI
+ RORQ $0x33,AX
+ ADDQ DX,CX
+ RORQ $0x30,DX
+ XORQ SI,AX
+ XORQ CX,DX
+ RORQ $0x20,SI
+ ADDQ AX,CX
+ ADDQ DX,SI
+ RORQ $0x2F,AX
+ RORQ $0x2B,DX
+ XORQ CX,AX
+ XORQ SI,DX
+ RORQ $0x20,CX
+ ADDQ AX,SI
+ ADDQ DX,CX
+ RORQ $0x33,AX
+ RORQ $0x30,DX
+ XORQ SI,AX
+ RORQ $0x20,SI
+ XORQ CX,DX
+ ADDQ AX,CX
+ RORQ $0x2F,AX
+ ADDQ DX,SI
+ RORQ $0x2B,DX
+ XORQ CX,AX
+ XORQ SI,DX
+ RORQ $0x20,CX
+ ADDQ AX,SI
+ ADDQ DX,CX
+ RORQ $0x33,AX
+ RORQ $0x30,DX
+ XORQ CX,DX
+ XORQ SI,AX
+ RORQ $0x20,SI
+ ADDQ DX,SI
+ ADDQ AX,CX
+ RORQ $0x2F,AX
+ XORQ CX,AX
+ RORQ $0x2B,DX
+ RORQ $0x20,CX
+ XORQ SI,DX
+
+ // gcc optimized the tail end of this function differently. However,
+ // we need to preserve out registers to carry out the second stage of
+ // the finalization. This is a duplicate of an earlier finalization
+ // round.
+
+ ADDQ AX,SI
+ RORQ $0x33,AX
+ ADDQ DX,CX
+ RORQ $0x30,DX
+ XORQ SI,AX
+ XORQ CX,DX
+ RORQ $0x20,SI
+ ADDQ AX,CX
+ ADDQ DX,SI
+ RORQ $0x2F,AX
+ RORQ $0x2B,DX
+ XORQ CX,AX
+ XORQ SI,DX
+ RORQ $0x20,CX
+
+ // Stuff the result into BX instead of AX as gcc had done
+
+ MOVQ SI,BX
+ XORQ AX,BX
+ XORQ DX,BX
+ XORQ CX,BX
+ MOVQ BX,ret+40(FP)
+
+ // Start the second finalization round
+
+ XORB $0xDD,AL
+ ADDQ AX,SI
+ RORQ $0x33,AX
+ ADDQ DX,CX
+ RORQ $0x30,DX
+ XORQ SI,AX
+ XORQ CX,DX
+ RORQ $0x20,SI
+ ADDQ AX,CX
+ ADDQ DX,SI
+ RORQ $0x2F,AX
+ RORQ $0x2B,DX
+ XORQ CX,AX
+ XORQ SI,DX
+ RORQ $0x20,CX
+ ADDQ AX,SI
+ ADDQ DX,CX
+ RORQ $0x33,AX
+ RORQ $0x30,DX
+ XORQ SI,AX
+ RORQ $0x20,SI
+ XORQ CX,DX
+ ADDQ AX,CX
+ RORQ $0x2F,AX
+ ADDQ DX,SI
+ RORQ $0x2B,DX
+ XORQ CX,AX
+ XORQ SI,DX
+ RORQ $0x20,CX
+ ADDQ AX,SI
+ ADDQ DX,CX
+ RORQ $0x33,AX
+ RORQ $0x30,DX
+ XORQ CX,DX
+ XORQ SI,AX
+ RORQ $0x20,SI
+ ADDQ DX,SI
+ ADDQ AX,CX
+ RORQ $0x2F,AX
+ XORQ CX,AX
+ RORQ $0x2B,DX
+ RORQ $0x20,CX
+ XORQ SI,DX
+
+ ADDQ AX,SI
+ RORQ $0x33,AX
+ ADDQ DX,CX
+ RORQ $0x30,DX
+ XORQ SI,AX
+ XORQ CX,DX
+ RORQ $0x20,SI
+ ADDQ AX,CX
+ ADDQ DX,SI
+ RORQ $0x2F,AX
+ RORQ $0x2B,DX
+ XORQ CX,AX
+ XORQ SI,DX
+ RORQ $0x20,CX
+
+ MOVQ SI,BX
+ XORQ AX,BX
+ XORQ DX,BX
+ XORQ CX,BX
+ MOVQ BX,ret1+48(FP)
+
+ RET
diff --git a/vendor/github.com/dchest/siphash/hash_amd64.s b/vendor/github.com/dchest/siphash/hash_amd64.s
new file mode 100644
index 0000000..0ca1631
--- /dev/null
+++ b/vendor/github.com/dchest/siphash/hash_amd64.s
@@ -0,0 +1,201 @@
+// +build amd64,!appengine,!gccgo
+
+// This is a translation of the gcc output of FloodyBerry's pure-C public
+// domain siphash implementation at https://github.com/floodyberry/siphash
+// func Hash(k0, k1 uint64, b []byte) uint64
+TEXT ·Hash(SB),4,$0-48
+ MOVQ k0+0(FP),CX
+ MOVQ $0x736F6D6570736575,R9
+ MOVQ k1+8(FP),DI
+ MOVQ $0x6C7967656E657261,BX
+ MOVQ $0x646F72616E646F6D,AX
+ MOVQ b_len+24(FP),DX
+ MOVQ DX,R11
+ MOVQ DX,R10
+ XORQ CX,R9
+ XORQ CX,BX
+ MOVQ $0x7465646279746573,CX
+ XORQ DI,AX
+ XORQ DI,CX
+ SHLQ $0x38,R11
+ XORQ DI,DI
+ MOVQ b_base+16(FP),SI
+ ANDQ $0xFFFFFFFFFFFFFFF8,R10
+ JE afterLoop
+ XCHGQ AX,AX
+loopBody:
+ MOVQ 0(SI)(DI*1),R8
+ ADDQ AX,R9
+ RORQ $0x33,AX
+ XORQ R9,AX
+ RORQ $0x20,R9
+ ADDQ $0x8,DI
+ XORQ R8,CX
+ ADDQ CX,BX
+ RORQ $0x30,CX
+ XORQ BX,CX
+ ADDQ AX,BX
+ RORQ $0x2F,AX
+ ADDQ CX,R9
+ RORQ $0x2B,CX
+ XORQ BX,AX
+ XORQ R9,CX
+ RORQ $0x20,BX
+ ADDQ AX,R9
+ ADDQ CX,BX
+ RORQ $0x33,AX
+ RORQ $0x30,CX
+ XORQ R9,AX
+ XORQ BX,CX
+ RORQ $0x20,R9
+ ADDQ AX,BX
+ ADDQ CX,R9
+ RORQ $0x2F,AX
+ RORQ $0x2B,CX
+ XORQ BX,AX
+ RORQ $0x20,BX
+ XORQ R9,CX
+ XORQ R8,R9
+ CMPQ R10,DI
+ JA loopBody
+afterLoop:
+ SUBQ R10,DX
+
+ CMPQ DX,$0x7
+ JA afterSwitch
+
+ // no support for jump tables
+
+ CMPQ DX,$0x7
+ JE sw7
+
+ CMPQ DX,$0x6
+ JE sw6
+
+ CMPQ DX,$0x5
+ JE sw5
+
+ CMPQ DX,$0x4
+ JE sw4
+
+ CMPQ DX,$0x3
+ JE sw3
+
+ CMPQ DX,$0x2
+ JE sw2
+
+ CMPQ DX,$0x1
+ JE sw1
+
+ JMP afterSwitch
+
+sw7: MOVBQZX 6(SI)(DI*1),DX
+ SHLQ $0x30,DX
+ ORQ DX,R11
+sw6: MOVBQZX 0x5(SI)(DI*1),DX
+ SHLQ $0x28,DX
+ ORQ DX,R11
+sw5: MOVBQZX 0x4(SI)(DI*1),DX
+ SHLQ $0x20,DX
+ ORQ DX,R11
+sw4: MOVBQZX 0x3(SI)(DI*1),DX
+ SHLQ $0x18,DX
+ ORQ DX,R11
+sw3: MOVBQZX 0x2(SI)(DI*1),DX
+ SHLQ $0x10,DX
+ ORQ DX,R11
+sw2: MOVBQZX 0x1(SI)(DI*1),DX
+ SHLQ $0x8,DX
+ ORQ DX,R11
+sw1: MOVBQZX 0(SI)(DI*1),DX
+ ORQ DX,R11
+afterSwitch:
+ LEAQ (AX)(R9*1),SI
+ XORQ R11,CX
+ RORQ $0x33,AX
+ ADDQ CX,BX
+ MOVQ CX,DX
+ XORQ SI,AX
+ RORQ $0x30,DX
+ RORQ $0x20,SI
+ LEAQ 0(BX)(AX*1),CX
+ XORQ BX,DX
+ RORQ $0x2F,AX
+ ADDQ DX,SI
+ RORQ $0x2B,DX
+ XORQ CX,AX
+ XORQ SI,DX
+ RORQ $0x20,CX
+ ADDQ AX,SI
+ RORQ $0x33,AX
+ ADDQ DX,CX
+ XORQ SI,AX
+ RORQ $0x30,DX
+ RORQ $0x20,SI
+ XORQ CX,DX
+ ADDQ AX,CX
+ RORQ $0x2F,AX
+ ADDQ DX,SI
+ XORQ CX,AX
+ RORQ $0x2B,DX
+ RORQ $0x20,CX
+ XORQ SI,DX
+ XORQ R11,SI
+ XORB $0xFF,CL
+ ADDQ AX,SI
+ RORQ $0x33,AX
+ ADDQ DX,CX
+ RORQ $0x30,DX
+ XORQ SI,AX
+ XORQ CX,DX
+ RORQ $0x20,SI
+ ADDQ AX,CX
+ ADDQ DX,SI
+ RORQ $0x2F,AX
+ RORQ $0x2B,DX
+ XORQ CX,AX
+ XORQ SI,DX
+ RORQ $0x20,CX
+ ADDQ AX,SI
+ ADDQ DX,CX
+ RORQ $0x33,AX
+ RORQ $0x30,DX
+ XORQ SI,AX
+ RORQ $0x20,SI
+ XORQ CX,DX
+ ADDQ AX,CX
+ RORQ $0x2F,AX
+ ADDQ DX,SI
+ RORQ $0x2B,DX
+ XORQ CX,AX
+ XORQ SI,DX
+ RORQ $0x20,CX
+ ADDQ AX,SI
+ ADDQ DX,CX
+ RORQ $0x33,AX
+ RORQ $0x30,DX
+ XORQ CX,DX
+ XORQ SI,AX
+ RORQ $0x20,SI
+ ADDQ DX,SI
+ ADDQ AX,CX
+ RORQ $0x2F,AX
+ XORQ CX,AX
+ RORQ $0x2B,DX
+ RORQ $0x20,CX
+ XORQ SI,DX
+ ADDQ AX,SI
+ RORQ $0x33,AX
+ ADDQ DX,CX
+ XORQ SI,AX
+ RORQ $0x30,DX
+ XORQ CX,DX
+ ADDQ AX,CX
+ RORQ $0x2F,AX
+ XORQ CX,AX
+ RORQ $0x2B,DX
+ RORQ $0x20,CX
+ XORQ DX,AX
+ XORQ CX,AX
+ MOVQ AX,ret+40(FP)
+ RET
diff --git a/vendor/github.com/dchest/siphash/hash_arm.go b/vendor/github.com/dchest/siphash/hash_arm.go
new file mode 100644
index 0000000..428dd96
--- /dev/null
+++ b/vendor/github.com/dchest/siphash/hash_arm.go
@@ -0,0 +1,27 @@
+// +build arm
+
+package siphash
+
+// NB: ARM implementation of forgoes extra speed for Hash()
+// and Hash128() by simply reusing the same blocks() implementation
+// in assembly used by the streaming hash.
+
+func Hash(k0, k1 uint64, p []byte) uint64 {
+ var d digest
+ d.size = Size
+ d.k0 = k0
+ d.k1 = k1
+ d.Reset()
+ d.Write(p)
+ return d.Sum64()
+}
+
+func Hash128(k0, k1 uint64, p []byte) (uint64, uint64) {
+ var d digest
+ d.size = Size128
+ d.k0 = k0
+ d.k1 = k1
+ d.Reset()
+ d.Write(p)
+ return d.sum128()
+}
diff --git a/vendor/github.com/dchest/siphash/hash_asm.go b/vendor/github.com/dchest/siphash/hash_asm.go
new file mode 100644
index 0000000..1437a2a
--- /dev/null
+++ b/vendor/github.com/dchest/siphash/hash_asm.go
@@ -0,0 +1,24 @@
+// +build amd64,!appengine,!gccgo
+
+// Written in 2012 by Dmitry Chestnykh.
+//
+// To the extent possible under law, the author have dedicated all copyright
+// and related and neighboring rights to this software to the public domain
+// worldwide. This software is distributed without any warranty.
+// http://creativecommons.org/publicdomain/zero/1.0/
+
+// This file contains a function definition for use with assembly implementations of Hash()
+
+package siphash
+
+//go:noescape
+
+// Hash returns the 64-bit SipHash-2-4 of the given byte slice with two 64-bit
+// parts of 128-bit key: k0 and k1.
+func Hash(k0, k1 uint64, b []byte) uint64
+
+//go:noescape
+
+// Hash128 returns the 128-bit SipHash-2-4 of the given byte slice with two
+// 64-bit parts of 128-bit key: k0 and k1.
+func Hash128(k0, k1 uint64, b []byte) (uint64, uint64)
diff --git a/vendor/github.com/dchest/siphash/siphash.go b/vendor/github.com/dchest/siphash/siphash.go
new file mode 100644
index 0000000..4a3cb49
--- /dev/null
+++ b/vendor/github.com/dchest/siphash/siphash.go
@@ -0,0 +1,318 @@
+// Written in 2012-2014 by Dmitry Chestnykh.
+//
+// To the extent possible under law, the author have dedicated all copyright
+// and related and neighboring rights to this software to the public domain
+// worldwide. This software is distributed without any warranty.
+// http://creativecommons.org/publicdomain/zero/1.0/
+
+// Package siphash implements SipHash-2-4, a fast short-input PRF
+// created by Jean-Philippe Aumasson and Daniel J. Bernstein.
+package siphash
+
+import "hash"
+
+const (
+ // BlockSize is the block size of hash algorithm in bytes.
+ BlockSize = 8
+
+ // Size is the size of hash output in bytes.
+ Size = 8
+
+ // Size128 is the size of 128-bit hash output in bytes.
+ Size128 = 16
+)
+
+type digest struct {
+ v0, v1, v2, v3 uint64 // state
+ k0, k1 uint64 // two parts of key
+ x [8]byte // buffer for unprocessed bytes
+ nx int // number of bytes in buffer x
+ size int // output size in bytes (8 or 16)
+ t uint8 // message bytes counter (mod 256)
+}
+
+// newDigest returns a new digest with the given output size in bytes (must be 8 or 16).
+func newDigest(size int, key []byte) *digest {
+ if size != Size && size != Size128 {
+ panic("size must be 8 or 16")
+ }
+ d := new(digest)
+ d.k0 = uint64(key[0]) | uint64(key[1])<<8 | uint64(key[2])<<16 | uint64(key[3])<<24 |
+ uint64(key[4])<<32 | uint64(key[5])<<40 | uint64(key[6])<<48 | uint64(key[7])<<56
+ d.k1 = uint64(key[8]) | uint64(key[9])<<8 | uint64(key[10])<<16 | uint64(key[11])<<24 |
+ uint64(key[12])<<32 | uint64(key[13])<<40 | uint64(key[14])<<48 | uint64(key[15])<<56
+ d.size = size
+ d.Reset()
+ return d
+}
+
+// New returns a new hash.Hash64 computing SipHash-2-4 with 16-byte key and 8-byte output.
+func New(key []byte) hash.Hash64 {
+ return newDigest(Size, key)
+}
+
+// New128 returns a new hash.Hash computing SipHash-2-4 with 16-byte key and 16-byte output.
+//
+// Note that 16-byte output is considered experimental by SipHash authors at this time.
+func New128(key []byte) hash.Hash {
+ return newDigest(Size128, key)
+}
+
+func (d *digest) Reset() {
+ d.v0 = d.k0 ^ 0x736f6d6570736575
+ d.v1 = d.k1 ^ 0x646f72616e646f6d
+ d.v2 = d.k0 ^ 0x6c7967656e657261
+ d.v3 = d.k1 ^ 0x7465646279746573
+ d.t = 0
+ d.nx = 0
+ if d.size == Size128 {
+ d.v1 ^= 0xee
+ }
+}
+
+func (d *digest) Size() int { return d.size }
+
+func (d *digest) BlockSize() int { return BlockSize }
+
+func (d *digest) Write(p []byte) (nn int, err error) {
+ nn = len(p)
+ d.t += uint8(nn)
+ if d.nx > 0 {
+ n := len(p)
+ if n > BlockSize-d.nx {
+ n = BlockSize - d.nx
+ }
+ d.nx += copy(d.x[d.nx:], p)
+ if d.nx == BlockSize {
+ once(d)
+ d.nx = 0
+ }
+ p = p[n:]
+ }
+ if len(p) >= BlockSize {
+ n := len(p) &^ (BlockSize - 1)
+ blocks(d, p[:n])
+ p = p[n:]
+ }
+ if len(p) > 0 {
+ d.nx = copy(d.x[:], p)
+ }
+ return
+}
+
+func (d *digest) Sum64() uint64 {
+ for i := d.nx; i < BlockSize-1; i++ {
+ d.x[i] = 0
+ }
+ d.x[7] = d.t
+ return finalize(d)
+}
+
+func (d0 *digest) sum128() (r0, r1 uint64) {
+ // Make a copy of d0 so that caller can keep writing and summing.
+ d := *d0
+
+ for i := d.nx; i < BlockSize-1; i++ {
+ d.x[i] = 0
+ }
+ d.x[7] = d.t
+ blocks(&d, d.x[:])
+
+ v0, v1, v2, v3 := d.v0, d.v1, d.v2, d.v3
+ v2 ^= 0xee
+
+ // Round 1.
+ v0 += v1
+ v1 = v1<<13 | v1>>(64-13)
+ v1 ^= v0
+ v0 = v0<<32 | v0>>(64-32)
+
+ v2 += v3
+ v3 = v3<<16 | v3>>(64-16)
+ v3 ^= v2
+
+ v0 += v3
+ v3 = v3<<21 | v3>>(64-21)
+ v3 ^= v0
+
+ v2 += v1
+ v1 = v1<<17 | v1>>(64-17)
+ v1 ^= v2
+ v2 = v2<<32 | v2>>(64-32)
+
+ // Round 2.
+ v0 += v1
+ v1 = v1<<13 | v1>>(64-13)
+ v1 ^= v0
+ v0 = v0<<32 | v0>>(64-32)
+
+ v2 += v3
+ v3 = v3<<16 | v3>>(64-16)
+ v3 ^= v2
+
+ v0 += v3
+ v3 = v3<<21 | v3>>(64-21)
+ v3 ^= v0
+
+ v2 += v1
+ v1 = v1<<17 | v1>>(64-17)
+ v1 ^= v2
+ v2 = v2<<32 | v2>>(64-32)
+
+ // Round 3.
+ v0 += v1
+ v1 = v1<<13 | v1>>(64-13)
+ v1 ^= v0
+ v0 = v0<<32 | v0>>(64-32)
+
+ v2 += v3
+ v3 = v3<<16 | v3>>(64-16)
+ v3 ^= v2
+
+ v0 += v3
+ v3 = v3<<21 | v3>>(64-21)
+ v3 ^= v0
+
+ v2 += v1
+ v1 = v1<<17 | v1>>(64-17)
+ v1 ^= v2
+ v2 = v2<<32 | v2>>(64-32)
+
+ // Round 4.
+ v0 += v1
+ v1 = v1<<13 | v1>>(64-13)
+ v1 ^= v0
+ v0 = v0<<32 | v0>>(64-32)
+
+ v2 += v3
+ v3 = v3<<16 | v3>>(64-16)
+ v3 ^= v2
+
+ v0 += v3
+ v3 = v3<<21 | v3>>(64-21)
+ v3 ^= v0
+
+ v2 += v1
+ v1 = v1<<17 | v1>>(64-17)
+ v1 ^= v2
+ v2 = v2<<32 | v2>>(64-32)
+
+ r0 = v0 ^ v1 ^ v2 ^ v3
+
+ v1 ^= 0xdd
+
+ // Round 1.
+ v0 += v1
+ v1 = v1<<13 | v1>>(64-13)
+ v1 ^= v0
+ v0 = v0<<32 | v0>>(64-32)
+
+ v2 += v3
+ v3 = v3<<16 | v3>>(64-16)
+ v3 ^= v2
+
+ v0 += v3
+ v3 = v3<<21 | v3>>(64-21)
+ v3 ^= v0
+
+ v2 += v1
+ v1 = v1<<17 | v1>>(64-17)
+ v1 ^= v2
+ v2 = v2<<32 | v2>>(64-32)
+
+ // Round 2.
+ v0 += v1
+ v1 = v1<<13 | v1>>(64-13)
+ v1 ^= v0
+ v0 = v0<<32 | v0>>(64-32)
+
+ v2 += v3
+ v3 = v3<<16 | v3>>(64-16)
+ v3 ^= v2
+
+ v0 += v3
+ v3 = v3<<21 | v3>>(64-21)
+ v3 ^= v0
+
+ v2 += v1
+ v1 = v1<<17 | v1>>(64-17)
+ v1 ^= v2
+ v2 = v2<<32 | v2>>(64-32)
+
+ // Round 3.
+ v0 += v1
+ v1 = v1<<13 | v1>>(64-13)
+ v1 ^= v0
+ v0 = v0<<32 | v0>>(64-32)
+
+ v2 += v3
+ v3 = v3<<16 | v3>>(64-16)
+ v3 ^= v2
+
+ v0 += v3
+ v3 = v3<<21 | v3>>(64-21)
+ v3 ^= v0
+
+ v2 += v1
+ v1 = v1<<17 | v1>>(64-17)
+ v1 ^= v2
+ v2 = v2<<32 | v2>>(64-32)
+
+ // Round 4.
+ v0 += v1
+ v1 = v1<<13 | v1>>(64-13)
+ v1 ^= v0
+ v0 = v0<<32 | v0>>(64-32)
+
+ v2 += v3
+ v3 = v3<<16 | v3>>(64-16)
+ v3 ^= v2
+
+ v0 += v3
+ v3 = v3<<21 | v3>>(64-21)
+ v3 ^= v0
+
+ v2 += v1
+ v1 = v1<<17 | v1>>(64-17)
+ v1 ^= v2
+ v2 = v2<<32 | v2>>(64-32)
+
+ r1 = v0 ^ v1 ^ v2 ^ v3
+
+ return r0, r1
+}
+
+func (d *digest) Sum(in []byte) []byte {
+ if d.size == Size {
+ r := d.Sum64()
+ in = append(in,
+ byte(r),
+ byte(r>>8),
+ byte(r>>16),
+ byte(r>>24),
+ byte(r>>32),
+ byte(r>>40),
+ byte(r>>48),
+ byte(r>>56))
+ } else {
+ r0, r1 := d.sum128()
+ in = append(in,
+ byte(r0),
+ byte(r0>>8),
+ byte(r0>>16),
+ byte(r0>>24),
+ byte(r0>>32),
+ byte(r0>>40),
+ byte(r0>>48),
+ byte(r0>>56),
+ byte(r1),
+ byte(r1>>8),
+ byte(r1>>16),
+ byte(r1>>24),
+ byte(r1>>32),
+ byte(r1>>40),
+ byte(r1>>48),
+ byte(r1>>56))
+ }
+ return in
+}
generated by cgit v1.2.3 (git 2.25.1) at 2024-09-13 15:41:16 +0000