Assembler version of Sum64String

.travis.yml

@@ -7,5 +7,6 @@ go:
   - master
 env:
   - TAGS=""
+  - TAGS="-tags appengine"
   - TAGS="-tags purego"
 script: go test $TAGS -v ./...

sum64string_unsafe.go

@@ -0,0 +1,11 @@
+// +build !amd64 !appengine,purego
+
+package xxhash
+
+// Sum64String computes the 64-bit xxHash digest of s.
+// It may be faster than Sum64([]byte(s)) by avoiding a copy.
+func Sum64String(s string) uint64 {
+	// Forward to the version in xxhash_unsafe.go.
+	// Go 1.15 inlines this function.
+	return sum64String(s)
+}

xxhash_amd64.go

@@ -9,5 +9,11 @@ package xxhash
 //go:noescape
 func Sum64(b []byte) uint64
 
+// Sum64String computes the 64-bit xxHash digest of s.
+// It may be faster than Sum64([]byte(s)) by avoiding a copy.
+//
+//go:noescape
+func Sum64String(s string) uint64
+
 //go:noescape
 func writeBlocks(d *Digest, b []byte) int

xxhash_amd64.s

@@ -9,6 +9,7 @@
 // CX	pointer to advance through b
 // DX	n
 // BX	loop end
+// DI	pointer to return value storage
 // R8	v1, k1
 // R9	v2
 // R10	v3
@@ -40,14 +41,25 @@
 
 // func Sum64(b []byte) uint64
 TEXT ·Sum64(SB), NOSPLIT, $0-32
+	MOVQ b_base+0(FP), CX
+	MOVQ b_len+8(FP), DX
+	LEAQ ret+24(FP), DI
+	JMP  sum64<>(SB)
+
+// func Sum64String(s string) uint64
+TEXT ·Sum64String(SB), NOSPLIT, $0-24
+	MOVQ s_base+0(FP), CX
+	MOVQ s_len+8(FP), DX
+	LEAQ ret+16(FP), DI
+	JMP  sum64<>(SB)
+
+// Takes arguments in CX, DX. Stores its return value through DI.
+TEXT sum64<>(SB), NOFRAME+NOSPLIT, $0
 	// Load fixed primes.
 	MOVQ ·prime1v(SB), R13
 	MOVQ ·prime2v(SB), R14
 	MOVQ ·prime4v(SB), R15
 
-	// Load slice.
-	MOVQ b_base+0(FP), CX
-	MOVQ b_len+8(FP), DX
 	LEAQ (CX)(DX*1), BX
 
 	// The first loop limit will be len(b)-32.
@@ -166,7 +178,7 @@ finalize:
 	SHRQ  $32, R12
 	XORQ  R12, AX
 
-	MOVQ AX, ret+24(FP)
+	MOVQ AX, (DI)
 	RET
 
 // writeBlocks uses the same registers as above except that it uses AX to store

xxhash_unsafe.go

@@ -23,9 +23,7 @@ import (
 // for strings to squeeze out a bit more speed. Mid-stack inlining should
 // eventually fix this.
 
-// Sum64String computes the 64-bit xxHash digest of s.
-// It may be faster than Sum64([]byte(s)) by avoiding a copy.
-func Sum64String(s string) uint64 {
+func sum64String(s string) uint64 {
 	var b []byte
 	bh := (*reflect.SliceHeader)(unsafe.Pointer(&b))
 	bh.Data = (*reflect.StringHeader)(unsafe.Pointer(&s)).Data