libgo: update to Go1.16beta1 release

This does not yet include support for the //go:embed directive added
in this release.

	* Makefile.am (check-runtime): Don't create check-runtime-dir.
	(mostlyclean-local): Don't remove check-runtime-dir.
	(check-go-tool, check-vet): Copy in go.mod and modules.txt.
	(check-cgo-test, check-carchive-test): Add go.mod file.
	* Makefile.in: Regenerate.

Reviewed-on: https://go-review.googlesource.com/c/gofrontend/+/280172

5 files changed, 53 insertions, 11 deletions

diff --git a/libgo/go/hash/crc32/crc32.go b/libgo/go/hash/crc32/crc32.go
index 908b84a..f330fdb 100644
--- a/libgo/go/hash/crc32/crc32.go
+++ b/libgo/go/hash/crc32/crc32.go
@@ -16,6 +16,7 @@ import (
 	"errors"
 	"hash"
 	"sync"
+	"sync/atomic"
 )
 
 // The size of a CRC-32 checksum in bytes.
@@ -78,6 +79,7 @@ var castagnoliTable8 *slicing8Table
 var castagnoliArchImpl bool
 var updateCastagnoli func(crc uint32, p []byte) uint32
 var castagnoliOnce sync.Once
+var haveCastagnoli uint32
 
 func castagnoliInit() {
 	castagnoliTable = simpleMakeTable(Castagnoli)
@@ -93,6 +95,8 @@ func castagnoliInit() {
 			return slicingUpdate(crc, castagnoliTable8, p)
 		}
 	}
+
+	atomic.StoreUint32(&haveCastagnoli, 1)
 }
 
 // IEEETable is the table for the IEEE polynomial.
@@ -208,10 +212,10 @@ func readUint32(b []byte) uint32 {
 
 // Update returns the result of adding the bytes in p to the crc.
 func Update(crc uint32, tab *Table, p []byte) uint32 {
-	switch tab {
-	case castagnoliTable:
+	switch {
+	case atomic.LoadUint32(&haveCastagnoli) != 0 && tab == castagnoliTable:
 		return updateCastagnoli(crc, p)
-	case IEEETable:
+	case tab == IEEETable:
 		// Unfortunately, because IEEETable is exported, IEEE may be used without a
 		// call to MakeTable. We have to make sure it gets initialized in that case.
 		ieeeOnce.Do(ieeeInit)
@@ -222,10 +226,10 @@ func Update(crc uint32, tab *Table, p []byte) uint32 {
 }
 
 func (d *digest) Write(p []byte) (n int, err error) {
-	switch d.tab {
-	case castagnoliTable:
+	switch {
+	case atomic.LoadUint32(&haveCastagnoli) != 0 && d.tab == castagnoliTable:
 		d.crc = updateCastagnoli(d.crc, p)
-	case IEEETable:
+	case d.tab == IEEETable:
 		// We only create digest objects through New() which takes care of
 		// initialization in this case.
 		d.crc = updateIEEE(d.crc, p)
diff --git a/libgo/go/hash/crc32/crc32_test.go b/libgo/go/hash/crc32/crc32_test.go
index 4bdafaf..cbb869d 100644
--- a/libgo/go/hash/crc32/crc32_test.go
+++ b/libgo/go/hash/crc32/crc32_test.go
@@ -13,6 +13,16 @@ import (
 	"testing"
 )
 
+// First test, so that it can be the one to initialize castagnoliTable.
+func TestCastagnoliRace(t *testing.T) {
+	// The MakeTable(Castagnoli) lazily initializes castagnoliTable,
+	// which races with the switch on tab during Write to check
+	// whether tab == castagnoliTable.
+	ieee := NewIEEE()
+	go MakeTable(Castagnoli)
+	ieee.Write([]byte("hello"))
+}
+
 type test struct {
 	ieee, castagnoli    uint32
 	in                  string
diff --git a/libgo/go/hash/crc32/gen_const_ppc64le.go b/libgo/go/hash/crc32/gen_const_ppc64le.go
index bfb3b3a..d7af018 100644
--- a/libgo/go/hash/crc32/gen_const_ppc64le.go
+++ b/libgo/go/hash/crc32/gen_const_ppc64le.go
@@ -27,7 +27,7 @@ package main
 import (
 	"bytes"
 	"fmt"
-	"io/ioutil"
+	"os"
 )
 
 var blocking = 32 * 1024
@@ -103,7 +103,7 @@ func main() {
 	genCrc32ConstTable(w, 0xeb31d82e, "Koop")
 	b := w.Bytes()
 
-	err := ioutil.WriteFile("crc32_table_ppc64le.s", b, 0666)
+	err := os.WriteFile("crc32_table_ppc64le.s", b, 0666)
 	if err != nil {
 		fmt.Printf("can't write output: %s\n", err)
 	}
diff --git a/libgo/go/hash/maphash/maphash.go b/libgo/go/hash/maphash/maphash.go
index 071dc04..ecc147d 100644
--- a/libgo/go/hash/maphash/maphash.go
+++ b/libgo/go/hash/maphash/maphash.go
@@ -6,12 +6,11 @@
 // These hash functions are intended to be used to implement hash tables or
 // other data structures that need to map arbitrary strings or byte
 // sequences to a uniform distribution on unsigned 64-bit integers.
+// Each different instance of a hash table or data structure should use its own Seed.
 //
-// The hash functions are collision-resistant but not cryptographically secure.
+// The hash functions are not cryptographically secure.
 // (See crypto/sha256 and crypto/sha512 for cryptographic use.)
 //
-// The hash value of a given byte sequence is consistent within a
-// single process, but will be different in different processes.
 package maphash
 
 import "unsafe"
diff --git a/libgo/go/hash/maphash/maphash_test.go b/libgo/go/hash/maphash/maphash_test.go
index caea43a..daf6eb4 100644
--- a/libgo/go/hash/maphash/maphash_test.go
+++ b/libgo/go/hash/maphash/maphash_test.go
@@ -165,3 +165,32 @@ func TestSeedFromReset(t *testing.T) {
 // Make sure a Hash implements the hash.Hash and hash.Hash64 interfaces.
 var _ hash.Hash = &Hash{}
 var _ hash.Hash64 = &Hash{}
+
+func benchmarkSize(b *testing.B, size int) {
+	h := &Hash{}
+	buf := make([]byte, size)
+	b.SetBytes(int64(size))
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		h.Reset()
+		h.Write(buf)
+		h.Sum64()
+	}
+}
+
+func BenchmarkHash8Bytes(b *testing.B) {
+	benchmarkSize(b, 8)
+}
+
+func BenchmarkHash320Bytes(b *testing.B) {
+	benchmarkSize(b, 320)
+}
+
+func BenchmarkHash1K(b *testing.B) {
+	benchmarkSize(b, 1024)
+}
+
+func BenchmarkHash8K(b *testing.B) {
+	benchmarkSize(b, 8192)
+}