diff options
author | Keith Randall <khr@golang.org> | 2020-03-06 14:01:26 -0800 |
---|---|---|
committer | Keith Randall <khr@golang.org> | 2020-03-10 16:26:59 +0000 |
commit | 2b8e60d464515634462ca472ca09c791e2cbf6ae (patch) | |
tree | fd9fbce5eafa054a302e77e9df284f33460b7497 /src/runtime/export_test.go | |
parent | 9f74f0afa6270e6735c1b6f59519cc88ff2ed1e4 (diff) | |
download | go-2b8e60d464515634462ca472ca09c791e2cbf6ae.tar.gz go-2b8e60d464515634462ca472ca09c791e2cbf6ae.zip |
runtime: make typehash match compiler generated hashes exactly
If typehash (used by reflect) does not match the built-in map's hash,
then problems occur. If a map is built using reflect, and then
assigned to a variable of map type, the hash function can change. That
causes very bad things.
This issue is rare. MapOf consults a cache of all types that occur in
the binary before making a new one. To make a true new map type (with
a hash function derived from typehash) that map type must not occur in
the binary anywhere. But to cause the bug, we need a variable of that
type in order to assign to it. The only way to make that work is to
use a named map type for the variable, so it is distinct from the
unnamed version that MapOf looks for.
Fixes #37716
Change-Id: I3537bfceca8cbfa1af84202f432f3c06953fe0ed
Reviewed-on: https://go-review.googlesource.com/c/go/+/222357
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Diffstat (limited to 'src/runtime/export_test.go')
-rw-r--r-- | src/runtime/export_test.go | 25 |
1 files changed, 25 insertions, 0 deletions
diff --git a/src/runtime/export_test.go b/src/runtime/export_test.go index 88cb1acc5b..6a8d00c60d 100644 --- a/src/runtime/export_test.go +++ b/src/runtime/export_test.go @@ -950,3 +950,28 @@ func SemNwait(addr *uint32) uint32 { root := semroot(addr) return atomic.Load(&root.nwait) } + +// MapHashCheck computes the hash of the key k for the map m, twice. +// Method 1 uses the built-in hasher for the map. +// Method 2 uses the typehash function (the one used by reflect). +// Returns the two hash values, which should always be equal. +func MapHashCheck(m interface{}, k interface{}) (uintptr, uintptr) { + // Unpack m. + mt := (*maptype)(unsafe.Pointer(efaceOf(&m)._type)) + mh := (*hmap)(efaceOf(&m).data) + + // Unpack k. + kt := efaceOf(&k)._type + var p unsafe.Pointer + if isDirectIface(kt) { + q := efaceOf(&k).data + p = unsafe.Pointer(&q) + } else { + p = efaceOf(&k).data + } + + // Compute the hash functions. + x := mt.hasher(noescape(p), uintptr(mh.hash0)) + y := typehash(kt, noescape(p), uintptr(mh.hash0)) + return x, y +} |