reflect, runtime: remove *UnsafePointer wrappers for functions

This was needed in the past because LLVM used typed pointers and there
was a mismatch between pointer types. But we've dropped support for
typed pointers a while ago so now we can remove these wrappers.

This is just a cleanup, it shouldn't have any practical effect.

src/runtime/chan.go

@@ -148,12 +148,6 @@ func chanLen(c *channel) int {
 	return int(c.bufUsed)
 }
 
-// wrapper for use in reflect
-func chanLenUnsafePointer(p unsafe.Pointer) int {
-	c := (*channel)(p)
-	return chanLen(c)
-}
-
 // Return the capacity of this chan, called from the cap builtin.
 // A nil chan is defined as having capacity 0.
 //
@@ -165,12 +159,6 @@ func chanCap(c *channel) int {
 	return int(c.bufSize)
 }
 
-// wrapper for use in reflect
-func chanCapUnsafePointer(p unsafe.Pointer) int {
-	c := (*channel)(p)
-	return chanCap(c)
-}
-
 // resumeRX resumes the next receiver and returns the destination pointer.
 // If the ok value is true, then the caller is expected to store a value into this pointer.
 func (ch *channel) resumeRX(ok bool) unsafe.Pointer {

src/runtime/hashmap.go

@@ -87,10 +87,6 @@ func hashmapMake(keySize, valueSize uintptr, sizeHint uintptr, alg uint8) *hashm
 	}
 }
 
-func hashmapMakeUnsafePointer(keySize, valueSize uintptr, sizeHint uintptr, alg uint8) unsafe.Pointer {
-	return (unsafe.Pointer)(hashmapMake(keySize, valueSize, sizeHint, alg))
-}
-
 // Remove all entries from the map, without actually deallocating the space for
 // it. This is used for the clear builtin, and can be used to reuse a map (to
 // avoid extra heap allocations).
@@ -178,10 +174,6 @@ func hashmapLen(m *hashmap) int {
 	return int(m.count)
 }
 
-func hashmapLenUnsafePointer(m unsafe.Pointer) int {
-	return hashmapLen((*hashmap)(m))
-}
-
 //go:inline
 func hashmapBucketSize(m *hashmap) uintptr {
 	return unsafe.Sizeof(hashmapBucket{}) + uintptr(m.keySize)*8 + uintptr(m.valueSize)*8
@@ -268,10 +260,6 @@ func hashmapSet(m *hashmap, key unsafe.Pointer, value unsafe.Pointer, hash uint3
 	*emptySlotTophash = tophash
 }
 
-func hashmapSetUnsafePointer(m unsafe.Pointer, key unsafe.Pointer, value unsafe.Pointer, hash uint32) {
-	hashmapSet((*hashmap)(m), key, value, hash)
-}
-
 // hashmapInsertIntoNewBucket creates a new bucket, inserts the given key and
 // value into the bucket, and returns a pointer to this bucket.
 func hashmapInsertIntoNewBucket(m *hashmap, key, value unsafe.Pointer, tophash uint8) *hashmapBucket {
@@ -352,10 +340,6 @@ func hashmapGet(m *hashmap, key, value unsafe.Pointer, valueSize uintptr, hash u
 	return false
 }
 
-func hashmapGetUnsafePointer(m unsafe.Pointer, key, value unsafe.Pointer, valueSize uintptr, hash uint32) bool {
-	return hashmapGet((*hashmap)(m), key, value, valueSize, hash)
-}
-
 // Delete a given key from the map. No-op when the key does not exist in the
 // map.
 //
@@ -456,10 +440,6 @@ func hashmapNext(m *hashmap, it *hashmapIterator, key, value unsafe.Pointer) boo
 	}
 }
 
-func hashmapNextUnsafePointer(m unsafe.Pointer, it unsafe.Pointer, key, value unsafe.Pointer) bool {
-	return hashmapNext((*hashmap)(m), (*hashmapIterator)(it), key, value)
-}
-
 // Hashmap with plain binary data keys (not containing strings etc.).
 func hashmapBinarySet(m *hashmap, key, value unsafe.Pointer) {
 	if m == nil {
@@ -469,10 +449,6 @@ func hashmapBinarySet(m *hashmap, key, value unsafe.Pointer) {
 	hashmapSet(m, key, value, hash)
 }
 
-func hashmapBinarySetUnsafePointer(m unsafe.Pointer, key, value unsafe.Pointer) {
-	hashmapBinarySet((*hashmap)(m), key, value)
-}
-
 func hashmapBinaryGet(m *hashmap, key, value unsafe.Pointer, valueSize uintptr) bool {
 	if m == nil {
 		memzero(value, uintptr(valueSize))
@@ -482,10 +458,6 @@ func hashmapBinaryGet(m *hashmap, key, value unsafe.Pointer, valueSize uintptr)
 	return hashmapGet(m, key, value, valueSize, hash)
 }
 
-func hashmapBinaryGetUnsafePointer(m unsafe.Pointer, key, value unsafe.Pointer, valueSize uintptr) bool {
-	return hashmapBinaryGet((*hashmap)(m), key, value, valueSize)
-}
-
 func hashmapBinaryDelete(m *hashmap, key unsafe.Pointer) {
 	if m == nil {
 		return
@@ -494,10 +466,6 @@ func hashmapBinaryDelete(m *hashmap, key unsafe.Pointer) {
 	hashmapDelete(m, key, hash)
 }
 
-func hashmapBinaryDeleteUnsafePointer(m unsafe.Pointer, key unsafe.Pointer) {
-	hashmapBinaryDelete((*hashmap)(m), key)
-}
-
 // Hashmap with string keys (a common case).
 
 func hashmapStringEqual(x, y unsafe.Pointer, n uintptr) bool {
@@ -522,10 +490,6 @@ func hashmapStringSet(m *hashmap, key string, value unsafe.Pointer) {
 	hashmapSet(m, unsafe.Pointer(&key), value, hash)
 }
 
-func hashmapStringSetUnsafePointer(m unsafe.Pointer, key string, value unsafe.Pointer) {
-	hashmapStringSet((*hashmap)(m), key, value)
-}
-
 func hashmapStringGet(m *hashmap, key string, value unsafe.Pointer, valueSize uintptr) bool {
 	if m == nil {
 		memzero(value, uintptr(valueSize))
@@ -535,10 +499,6 @@ func hashmapStringGet(m *hashmap, key string, value unsafe.Pointer, valueSize ui
 	return hashmapGet(m, unsafe.Pointer(&key), value, valueSize, hash)
 }
 
-func hashmapStringGetUnsafePointer(m unsafe.Pointer, key string, value unsafe.Pointer, valueSize uintptr) bool {
-	return hashmapStringGet((*hashmap)(m), key, value, valueSize)
-}
-
 func hashmapStringDelete(m *hashmap, key string) {
 	if m == nil {
 		return
@@ -547,10 +507,6 @@ func hashmapStringDelete(m *hashmap, key string) {
 	hashmapDelete(m, unsafe.Pointer(&key), hash)
 }
 
-func hashmapStringDeleteUnsafePointer(m unsafe.Pointer, key string) {
-	hashmapStringDelete((*hashmap)(m), key)
-}
-
 // Hashmap with interface keys (for everything else).
 
 // This is a method that is intentionally unexported in the reflect package. It
@@ -654,10 +610,6 @@ func hashmapInterfaceSet(m *hashmap, key interface{}, value unsafe.Pointer) {
 	hashmapSet(m, unsafe.Pointer(&key), value, hash)
 }
 
-func hashmapInterfaceSetUnsafePointer(m unsafe.Pointer, key interface{}, value unsafe.Pointer) {
-	hashmapInterfaceSet((*hashmap)(m), key, value)
-}
-
 func hashmapInterfaceGet(m *hashmap, key interface{}, value unsafe.Pointer, valueSize uintptr) bool {
 	if m == nil {
 		memzero(value, uintptr(valueSize))
@@ -667,10 +619,6 @@ func hashmapInterfaceGet(m *hashmap, key interface{}, value unsafe.Pointer, valu
 	return hashmapGet(m, unsafe.Pointer(&key), value, valueSize, hash)
 }
 
-func hashmapInterfaceGetUnsafePointer(m unsafe.Pointer, key interface{}, value unsafe.Pointer, valueSize uintptr) bool {
-	return hashmapInterfaceGet((*hashmap)(m), key, value, valueSize)
-}
-
 func hashmapInterfaceDelete(m *hashmap, key interface{}) {
 	if m == nil {
 		return
@@ -678,7 +626,3 @@ func hashmapInterfaceDelete(m *hashmap, key interface{}) {
 	hash := hashmapInterfaceHash(key, m.seed)
 	hashmapDelete(m, unsafe.Pointer(&key), hash)
 }
-
-func hashmapInterfaceDeleteUnsafePointer(m unsafe.Pointer, key interface{}) {
-	hashmapInterfaceDelete((*hashmap)(m), key)
-}