diff --git a/src/cmd/compile/internal/typecheck/builtin.go b/src/cmd/compile/internal/typecheck/builtin.go
index 878239d378..d83791df8b 100644
--- a/src/cmd/compile/internal/typecheck/builtin.go
+++ b/src/cmd/compile/internal/typecheck/builtin.go
@@ -95,109 +95,109 @@ var runtimeDecls = [...]struct {
 	{"makemap_small", funcTag, 77},
 	{"mapaccess1", funcTag, 78},
 	{"mapaccess1_fast32", funcTag, 79},
-	{"mapaccess1_fast64", funcTag, 79},
-	{"mapaccess1_faststr", funcTag, 79},
-	{"mapaccess1_fat", funcTag, 80},
-	{"mapaccess2", funcTag, 81},
-	{"mapaccess2_fast32", funcTag, 82},
-	{"mapaccess2_fast64", funcTag, 82},
-	{"mapaccess2_faststr", funcTag, 82},
-	{"mapaccess2_fat", funcTag, 83},
+	{"mapaccess1_fast64", funcTag, 80},
+	{"mapaccess1_faststr", funcTag, 81},
+	{"mapaccess1_fat", funcTag, 82},
+	{"mapaccess2", funcTag, 83},
+	{"mapaccess2_fast32", funcTag, 84},
+	{"mapaccess2_fast64", funcTag, 85},
+	{"mapaccess2_faststr", funcTag, 86},
+	{"mapaccess2_fat", funcTag, 87},
 	{"mapassign", funcTag, 78},
 	{"mapassign_fast32", funcTag, 79},
-	{"mapassign_fast32ptr", funcTag, 79},
-	{"mapassign_fast64", funcTag, 79},
-	{"mapassign_fast64ptr", funcTag, 79},
-	{"mapassign_faststr", funcTag, 79},
-	{"mapiterinit", funcTag, 84},
-	{"mapdelete", funcTag, 84},
-	{"mapdelete_fast32", funcTag, 85},
-	{"mapdelete_fast64", funcTag, 85},
-	{"mapdelete_faststr", funcTag, 85},
-	{"mapiternext", funcTag, 86},
-	{"mapclear", funcTag, 87},
-	{"makechan64", funcTag, 89},
-	{"makechan", funcTag, 90},
-	{"chanrecv1", funcTag, 92},
-	{"chanrecv2", funcTag, 93},
-	{"chansend1", funcTag, 95},
+	{"mapassign_fast32ptr", funcTag, 88},
+	{"mapassign_fast64", funcTag, 80},
+	{"mapassign_fast64ptr", funcTag, 88},
+	{"mapassign_faststr", funcTag, 81},
+	{"mapiterinit", funcTag, 89},
+	{"mapdelete", funcTag, 89},
+	{"mapdelete_fast32", funcTag, 90},
+	{"mapdelete_fast64", funcTag, 91},
+	{"mapdelete_faststr", funcTag, 92},
+	{"mapiternext", funcTag, 93},
+	{"mapclear", funcTag, 94},
+	{"makechan64", funcTag, 96},
+	{"makechan", funcTag, 97},
+	{"chanrecv1", funcTag, 99},
+	{"chanrecv2", funcTag, 100},
+	{"chansend1", funcTag, 102},
 	{"closechan", funcTag, 30},
-	{"writeBarrier", varTag, 97},
-	{"typedmemmove", funcTag, 98},
-	{"typedmemclr", funcTag, 99},
-	{"typedslicecopy", funcTag, 100},
-	{"selectnbsend", funcTag, 101},
-	{"selectnbrecv", funcTag, 102},
-	{"selectsetpc", funcTag, 103},
-	{"selectgo", funcTag, 104},
+	{"writeBarrier", varTag, 104},
+	{"typedmemmove", funcTag, 105},
+	{"typedmemclr", funcTag, 106},
+	{"typedslicecopy", funcTag, 107},
+	{"selectnbsend", funcTag, 108},
+	{"selectnbrecv", funcTag, 109},
+	{"selectsetpc", funcTag, 110},
+	{"selectgo", funcTag, 111},
 	{"block", funcTag, 9},
-	{"makeslice", funcTag, 105},
-	{"makeslice64", funcTag, 106},
-	{"makeslicecopy", funcTag, 107},
-	{"growslice", funcTag, 109},
-	{"memmove", funcTag, 110},
-	{"memclrNoHeapPointers", funcTag, 111},
-	{"memclrHasPointers", funcTag, 111},
-	{"memequal", funcTag, 112},
-	{"memequal0", funcTag, 113},
-	{"memequal8", funcTag, 113},
-	{"memequal16", funcTag, 113},
-	{"memequal32", funcTag, 113},
-	{"memequal64", funcTag, 113},
-	{"memequal128", funcTag, 113},
-	{"f32equal", funcTag, 114},
-	{"f64equal", funcTag, 114},
-	{"c64equal", funcTag, 114},
-	{"c128equal", funcTag, 114},
-	{"strequal", funcTag, 114},
-	{"interequal", funcTag, 114},
-	{"nilinterequal", funcTag, 114},
-	{"memhash", funcTag, 115},
-	{"memhash0", funcTag, 116},
-	{"memhash8", funcTag, 116},
-	{"memhash16", funcTag, 116},
-	{"memhash32", funcTag, 116},
-	{"memhash64", funcTag, 116},
-	{"memhash128", funcTag, 116},
-	{"f32hash", funcTag, 116},
-	{"f64hash", funcTag, 116},
-	{"c64hash", funcTag, 116},
-	{"c128hash", funcTag, 116},
-	{"strhash", funcTag, 116},
-	{"interhash", funcTag, 116},
-	{"nilinterhash", funcTag, 116},
-	{"int64div", funcTag, 117},
-	{"uint64div", funcTag, 118},
-	{"int64mod", funcTag, 117},
-	{"uint64mod", funcTag, 118},
-	{"float64toint64", funcTag, 119},
-	{"float64touint64", funcTag, 120},
-	{"float64touint32", funcTag, 121},
-	{"int64tofloat64", funcTag, 122},
-	{"uint64tofloat64", funcTag, 123},
-	{"uint32tofloat64", funcTag, 124},
-	{"complex128div", funcTag, 125},
-	{"getcallerpc", funcTag, 126},
-	{"getcallersp", funcTag, 126},
+	{"makeslice", funcTag, 112},
+	{"makeslice64", funcTag, 113},
+	{"makeslicecopy", funcTag, 114},
+	{"growslice", funcTag, 116},
+	{"memmove", funcTag, 117},
+	{"memclrNoHeapPointers", funcTag, 118},
+	{"memclrHasPointers", funcTag, 118},
+	{"memequal", funcTag, 119},
+	{"memequal0", funcTag, 120},
+	{"memequal8", funcTag, 120},
+	{"memequal16", funcTag, 120},
+	{"memequal32", funcTag, 120},
+	{"memequal64", funcTag, 120},
+	{"memequal128", funcTag, 120},
+	{"f32equal", funcTag, 121},
+	{"f64equal", funcTag, 121},
+	{"c64equal", funcTag, 121},
+	{"c128equal", funcTag, 121},
+	{"strequal", funcTag, 121},
+	{"interequal", funcTag, 121},
+	{"nilinterequal", funcTag, 121},
+	{"memhash", funcTag, 122},
+	{"memhash0", funcTag, 123},
+	{"memhash8", funcTag, 123},
+	{"memhash16", funcTag, 123},
+	{"memhash32", funcTag, 123},
+	{"memhash64", funcTag, 123},
+	{"memhash128", funcTag, 123},
+	{"f32hash", funcTag, 123},
+	{"f64hash", funcTag, 123},
+	{"c64hash", funcTag, 123},
+	{"c128hash", funcTag, 123},
+	{"strhash", funcTag, 123},
+	{"interhash", funcTag, 123},
+	{"nilinterhash", funcTag, 123},
+	{"int64div", funcTag, 124},
+	{"uint64div", funcTag, 125},
+	{"int64mod", funcTag, 124},
+	{"uint64mod", funcTag, 125},
+	{"float64toint64", funcTag, 126},
+	{"float64touint64", funcTag, 127},
+	{"float64touint32", funcTag, 128},
+	{"int64tofloat64", funcTag, 129},
+	{"uint64tofloat64", funcTag, 130},
+	{"uint32tofloat64", funcTag, 131},
+	{"complex128div", funcTag, 132},
+	{"getcallerpc", funcTag, 133},
+	{"getcallersp", funcTag, 133},
 	{"racefuncenter", funcTag, 31},
 	{"racefuncexit", funcTag, 9},
 	{"raceread", funcTag, 31},
 	{"racewrite", funcTag, 31},
-	{"racereadrange", funcTag, 127},
-	{"racewriterange", funcTag, 127},
-	{"msanread", funcTag, 127},
-	{"msanwrite", funcTag, 127},
-	{"msanmove", funcTag, 128},
-	{"checkptrAlignment", funcTag, 129},
-	{"checkptrArithmetic", funcTag, 131},
-	{"libfuzzerTraceCmp1", funcTag, 132},
-	{"libfuzzerTraceCmp2", funcTag, 133},
-	{"libfuzzerTraceCmp4", funcTag, 134},
-	{"libfuzzerTraceCmp8", funcTag, 135},
-	{"libfuzzerTraceConstCmp1", funcTag, 132},
-	{"libfuzzerTraceConstCmp2", funcTag, 133},
-	{"libfuzzerTraceConstCmp4", funcTag, 134},
-	{"libfuzzerTraceConstCmp8", funcTag, 135},
+	{"racereadrange", funcTag, 134},
+	{"racewriterange", funcTag, 134},
+	{"msanread", funcTag, 134},
+	{"msanwrite", funcTag, 134},
+	{"msanmove", funcTag, 135},
+	{"checkptrAlignment", funcTag, 136},
+	{"checkptrArithmetic", funcTag, 138},
+	{"libfuzzerTraceCmp1", funcTag, 139},
+	{"libfuzzerTraceCmp2", funcTag, 140},
+	{"libfuzzerTraceCmp4", funcTag, 141},
+	{"libfuzzerTraceCmp8", funcTag, 142},
+	{"libfuzzerTraceConstCmp1", funcTag, 139},
+	{"libfuzzerTraceConstCmp2", funcTag, 140},
+	{"libfuzzerTraceConstCmp4", funcTag, 141},
+	{"libfuzzerTraceConstCmp8", funcTag, 142},
 	{"x86HasPOPCNT", varTag, 6},
 	{"x86HasSSE41", varTag, 6},
 	{"x86HasFMA", varTag, 6},
@@ -220,7 +220,7 @@ func params(tlist ...*types.Type) []*types.Field {
 }
 
 func runtimeTypes() []*types.Type {
-	var typs [136]*types.Type
+	var typs [143]*types.Type
 	typs[0] = types.ByteType
 	typs[1] = types.NewPtr(typs[0])
 	typs[2] = types.Types[types.TANY]
@@ -300,62 +300,69 @@ func runtimeTypes() []*types.Type {
 	typs[76] = newSig(params(typs[1], typs[15], typs[3]), params(typs[74]))
 	typs[77] = newSig(nil, params(typs[74]))
 	typs[78] = newSig(params(typs[1], typs[74], typs[3]), params(typs[3]))
-	typs[79] = newSig(params(typs[1], typs[74], typs[2]), params(typs[3]))
-	typs[80] = newSig(params(typs[1], typs[74], typs[3], typs[1]), params(typs[3]))
-	typs[81] = newSig(params(typs[1], typs[74], typs[3]), params(typs[3], typs[6]))
-	typs[82] = newSig(params(typs[1], typs[74], typs[2]), params(typs[3], typs[6]))
-	typs[83] = newSig(params(typs[1], typs[74], typs[3], typs[1]), params(typs[3], typs[6]))
-	typs[84] = newSig(params(typs[1], typs[74], typs[3]), nil)
-	typs[85] = newSig(params(typs[1], typs[74], typs[2]), nil)
-	typs[86] = newSig(params(typs[3]), nil)
-	typs[87] = newSig(params(typs[1], typs[74]), nil)
-	typs[88] = types.NewChan(typs[2], types.Cboth)
-	typs[89] = newSig(params(typs[1], typs[22]), params(typs[88]))
-	typs[90] = newSig(params(typs[1], typs[15]), params(typs[88]))
-	typs[91] = types.NewChan(typs[2], types.Crecv)
-	typs[92] = newSig(params(typs[91], typs[3]), nil)
-	typs[93] = newSig(params(typs[91], typs[3]), params(typs[6]))
-	typs[94] = types.NewChan(typs[2], types.Csend)
-	typs[95] = newSig(params(typs[94], typs[3]), nil)
-	typs[96] = types.NewArray(typs[0], 3)
-	typs[97] = types.NewStruct(types.NoPkg, []*types.Field{types.NewField(src.NoXPos, Lookup("enabled"), typs[6]), types.NewField(src.NoXPos, Lookup("pad"), typs[96]), types.NewField(src.NoXPos, Lookup("needed"), typs[6]), types.NewField(src.NoXPos, Lookup("cgo"), typs[6]), types.NewField(src.NoXPos, Lookup("alignme"), typs[24])})
-	typs[98] = newSig(params(typs[1], typs[3], typs[3]), nil)
-	typs[99] = newSig(params(typs[1], typs[3]), nil)
-	typs[100] = newSig(params(typs[1], typs[3], typs[15], typs[3], typs[15]), params(typs[15]))
-	typs[101] = newSig(params(typs[94], typs[3]), params(typs[6]))
-	typs[102] = newSig(params(typs[3], typs[91]), params(typs[6], typs[6]))
-	typs[103] = newSig(params(typs[71]), nil)
-	typs[104] = newSig(params(typs[1], typs[1], typs[71], typs[15], typs[15], typs[6]), params(typs[15], typs[6]))
-	typs[105] = newSig(params(typs[1], typs[15], typs[15]), params(typs[7]))
-	typs[106] = newSig(params(typs[1], typs[22], typs[22]), params(typs[7]))
-	typs[107] = newSig(params(typs[1], typs[15], typs[15], typs[7]), params(typs[7]))
-	typs[108] = types.NewSlice(typs[2])
-	typs[109] = newSig(params(typs[1], typs[108], typs[15]), params(typs[108]))
-	typs[110] = newSig(params(typs[3], typs[3], typs[5]), nil)
-	typs[111] = newSig(params(typs[7], typs[5]), nil)
-	typs[112] = newSig(params(typs[3], typs[3], typs[5]), params(typs[6]))
-	typs[113] = newSig(params(typs[3], typs[3]), params(typs[6]))
-	typs[114] = newSig(params(typs[7], typs[7]), params(typs[6]))
-	typs[115] = newSig(params(typs[7], typs[5], typs[5]), params(typs[5]))
-	typs[116] = newSig(params(typs[7], typs[5]), params(typs[5]))
-	typs[117] = newSig(params(typs[22], typs[22]), params(typs[22]))
-	typs[118] = newSig(params(typs[24], typs[24]), params(typs[24]))
-	typs[119] = newSig(params(typs[20]), params(typs[22]))
-	typs[120] = newSig(params(typs[20]), params(typs[24]))
-	typs[121] = newSig(params(typs[20]), params(typs[60]))
-	typs[122] = newSig(params(typs[22]), params(typs[20]))
-	typs[123] = newSig(params(typs[24]), params(typs[20]))
-	typs[124] = newSig(params(typs[60]), params(typs[20]))
-	typs[125] = newSig(params(typs[26], typs[26]), params(typs[26]))
-	typs[126] = newSig(nil, params(typs[5]))
-	typs[127] = newSig(params(typs[5], typs[5]), nil)
-	typs[128] = newSig(params(typs[5], typs[5], typs[5]), nil)
-	typs[129] = newSig(params(typs[7], typs[1], typs[5]), nil)
-	typs[130] = types.NewSlice(typs[7])
-	typs[131] = newSig(params(typs[7], typs[130]), nil)
-	typs[132] = newSig(params(typs[64], typs[64]), nil)
-	typs[133] = newSig(params(typs[58], typs[58]), nil)
-	typs[134] = newSig(params(typs[60], typs[60]), nil)
-	typs[135] = newSig(params(typs[24], typs[24]), nil)
+	typs[79] = newSig(params(typs[1], typs[74], typs[60]), params(typs[3]))
+	typs[80] = newSig(params(typs[1], typs[74], typs[24]), params(typs[3]))
+	typs[81] = newSig(params(typs[1], typs[74], typs[28]), params(typs[3]))
+	typs[82] = newSig(params(typs[1], typs[74], typs[3], typs[1]), params(typs[3]))
+	typs[83] = newSig(params(typs[1], typs[74], typs[3]), params(typs[3], typs[6]))
+	typs[84] = newSig(params(typs[1], typs[74], typs[60]), params(typs[3], typs[6]))
+	typs[85] = newSig(params(typs[1], typs[74], typs[24]), params(typs[3], typs[6]))
+	typs[86] = newSig(params(typs[1], typs[74], typs[28]), params(typs[3], typs[6]))
+	typs[87] = newSig(params(typs[1], typs[74], typs[3], typs[1]), params(typs[3], typs[6]))
+	typs[88] = newSig(params(typs[1], typs[74], typs[7]), params(typs[3]))
+	typs[89] = newSig(params(typs[1], typs[74], typs[3]), nil)
+	typs[90] = newSig(params(typs[1], typs[74], typs[60]), nil)
+	typs[91] = newSig(params(typs[1], typs[74], typs[24]), nil)
+	typs[92] = newSig(params(typs[1], typs[74], typs[28]), nil)
+	typs[93] = newSig(params(typs[3]), nil)
+	typs[94] = newSig(params(typs[1], typs[74]), nil)
+	typs[95] = types.NewChan(typs[2], types.Cboth)
+	typs[96] = newSig(params(typs[1], typs[22]), params(typs[95]))
+	typs[97] = newSig(params(typs[1], typs[15]), params(typs[95]))
+	typs[98] = types.NewChan(typs[2], types.Crecv)
+	typs[99] = newSig(params(typs[98], typs[3]), nil)
+	typs[100] = newSig(params(typs[98], typs[3]), params(typs[6]))
+	typs[101] = types.NewChan(typs[2], types.Csend)
+	typs[102] = newSig(params(typs[101], typs[3]), nil)
+	typs[103] = types.NewArray(typs[0], 3)
+	typs[104] = types.NewStruct(types.NoPkg, []*types.Field{types.NewField(src.NoXPos, Lookup("enabled"), typs[6]), types.NewField(src.NoXPos, Lookup("pad"), typs[103]), types.NewField(src.NoXPos, Lookup("needed"), typs[6]), types.NewField(src.NoXPos, Lookup("cgo"), typs[6]), types.NewField(src.NoXPos, Lookup("alignme"), typs[24])})
+	typs[105] = newSig(params(typs[1], typs[3], typs[3]), nil)
+	typs[106] = newSig(params(typs[1], typs[3]), nil)
+	typs[107] = newSig(params(typs[1], typs[3], typs[15], typs[3], typs[15]), params(typs[15]))
+	typs[108] = newSig(params(typs[101], typs[3]), params(typs[6]))
+	typs[109] = newSig(params(typs[3], typs[98]), params(typs[6], typs[6]))
+	typs[110] = newSig(params(typs[71]), nil)
+	typs[111] = newSig(params(typs[1], typs[1], typs[71], typs[15], typs[15], typs[6]), params(typs[15], typs[6]))
+	typs[112] = newSig(params(typs[1], typs[15], typs[15]), params(typs[7]))
+	typs[113] = newSig(params(typs[1], typs[22], typs[22]), params(typs[7]))
+	typs[114] = newSig(params(typs[1], typs[15], typs[15], typs[7]), params(typs[7]))
+	typs[115] = types.NewSlice(typs[2])
+	typs[116] = newSig(params(typs[1], typs[115], typs[15]), params(typs[115]))
+	typs[117] = newSig(params(typs[3], typs[3], typs[5]), nil)
+	typs[118] = newSig(params(typs[7], typs[5]), nil)
+	typs[119] = newSig(params(typs[3], typs[3], typs[5]), params(typs[6]))
+	typs[120] = newSig(params(typs[3], typs[3]), params(typs[6]))
+	typs[121] = newSig(params(typs[7], typs[7]), params(typs[6]))
+	typs[122] = newSig(params(typs[7], typs[5], typs[5]), params(typs[5]))
+	typs[123] = newSig(params(typs[7], typs[5]), params(typs[5]))
+	typs[124] = newSig(params(typs[22], typs[22]), params(typs[22]))
+	typs[125] = newSig(params(typs[24], typs[24]), params(typs[24]))
+	typs[126] = newSig(params(typs[20]), params(typs[22]))
+	typs[127] = newSig(params(typs[20]), params(typs[24]))
+	typs[128] = newSig(params(typs[20]), params(typs[60]))
+	typs[129] = newSig(params(typs[22]), params(typs[20]))
+	typs[130] = newSig(params(typs[24]), params(typs[20]))
+	typs[131] = newSig(params(typs[60]), params(typs[20]))
+	typs[132] = newSig(params(typs[26], typs[26]), params(typs[26]))
+	typs[133] = newSig(nil, params(typs[5]))
+	typs[134] = newSig(params(typs[5], typs[5]), nil)
+	typs[135] = newSig(params(typs[5], typs[5], typs[5]), nil)
+	typs[136] = newSig(params(typs[7], typs[1], typs[5]), nil)
+	typs[137] = types.NewSlice(typs[7])
+	typs[138] = newSig(params(typs[7], typs[137]), nil)
+	typs[139] = newSig(params(typs[64], typs[64]), nil)
+	typs[140] = newSig(params(typs[58], typs[58]), nil)
+	typs[141] = newSig(params(typs[60], typs[60]), nil)
+	typs[142] = newSig(params(typs[24], typs[24]), nil)
 	return typs[:]
 }
diff --git a/src/cmd/compile/internal/typecheck/builtin/runtime.go b/src/cmd/compile/internal/typecheck/builtin/runtime.go
index b7fb2e6044..183ae40456 100644
--- a/src/cmd/compile/internal/typecheck/builtin/runtime.go
+++ b/src/cmd/compile/internal/typecheck/builtin/runtime.go
@@ -127,26 +127,26 @@ func makemap64(mapType *byte, hint int64, mapbuf *any) (hmap map[any]any)
 func makemap(mapType *byte, hint int, mapbuf *any) (hmap map[any]any)
 func makemap_small() (hmap map[any]any)
 func mapaccess1(mapType *byte, hmap map[any]any, key *any) (val *any)
-func mapaccess1_fast32(mapType *byte, hmap map[any]any, key any) (val *any)
-func mapaccess1_fast64(mapType *byte, hmap map[any]any, key any) (val *any)
-func mapaccess1_faststr(mapType *byte, hmap map[any]any, key any) (val *any)
+func mapaccess1_fast32(mapType *byte, hmap map[any]any, key uint32) (val *any)
+func mapaccess1_fast64(mapType *byte, hmap map[any]any, key uint64) (val *any)
+func mapaccess1_faststr(mapType *byte, hmap map[any]any, key string) (val *any)
 func mapaccess1_fat(mapType *byte, hmap map[any]any, key *any, zero *byte) (val *any)
 func mapaccess2(mapType *byte, hmap map[any]any, key *any) (val *any, pres bool)
-func mapaccess2_fast32(mapType *byte, hmap map[any]any, key any) (val *any, pres bool)
-func mapaccess2_fast64(mapType *byte, hmap map[any]any, key any) (val *any, pres bool)
-func mapaccess2_faststr(mapType *byte, hmap map[any]any, key any) (val *any, pres bool)
+func mapaccess2_fast32(mapType *byte, hmap map[any]any, key uint32) (val *any, pres bool)
+func mapaccess2_fast64(mapType *byte, hmap map[any]any, key uint64) (val *any, pres bool)
+func mapaccess2_faststr(mapType *byte, hmap map[any]any, key string) (val *any, pres bool)
 func mapaccess2_fat(mapType *byte, hmap map[any]any, key *any, zero *byte) (val *any, pres bool)
 func mapassign(mapType *byte, hmap map[any]any, key *any) (val *any)
-func mapassign_fast32(mapType *byte, hmap map[any]any, key any) (val *any)
-func mapassign_fast32ptr(mapType *byte, hmap map[any]any, key any) (val *any)
-func mapassign_fast64(mapType *byte, hmap map[any]any, key any) (val *any)
-func mapassign_fast64ptr(mapType *byte, hmap map[any]any, key any) (val *any)
-func mapassign_faststr(mapType *byte, hmap map[any]any, key any) (val *any)
+func mapassign_fast32(mapType *byte, hmap map[any]any, key uint32) (val *any)
+func mapassign_fast32ptr(mapType *byte, hmap map[any]any, key unsafe.Pointer) (val *any)
+func mapassign_fast64(mapType *byte, hmap map[any]any, key uint64) (val *any)
+func mapassign_fast64ptr(mapType *byte, hmap map[any]any, key unsafe.Pointer) (val *any)
+func mapassign_faststr(mapType *byte, hmap map[any]any, key string) (val *any)
 func mapiterinit(mapType *byte, hmap map[any]any, hiter *any)
 func mapdelete(mapType *byte, hmap map[any]any, key *any)
-func mapdelete_fast32(mapType *byte, hmap map[any]any, key any)
-func mapdelete_fast64(mapType *byte, hmap map[any]any, key any)
-func mapdelete_faststr(mapType *byte, hmap map[any]any, key any)
+func mapdelete_fast32(mapType *byte, hmap map[any]any, key uint32)
+func mapdelete_fast64(mapType *byte, hmap map[any]any, key uint64)
+func mapdelete_faststr(mapType *byte, hmap map[any]any, key string)
 func mapiternext(hiter *any)
 func mapclear(mapType *byte, hmap map[any]any)
 
diff --git a/src/cmd/compile/internal/walk/assign.go b/src/cmd/compile/internal/walk/assign.go
index 44622c741d..8550cfb5c8 100644
--- a/src/cmd/compile/internal/walk/assign.go
+++ b/src/cmd/compile/internal/walk/assign.go
@@ -176,10 +176,10 @@ func walkAssignMapRead(init *ir.Nodes, n *ir.AssignListStmt) ir.Node {
 
 	var call *ir.CallExpr
 	if w := t.Elem().Width; w <= zeroValSize {
-		fn := mapfn(mapaccess2[fast], t)
+		fn := mapfn(mapaccess2[fast], t, false)
 		call = mkcall1(fn, fn.Type().Results(), init, reflectdata.TypePtr(t), r.X, key)
 	} else {
-		fn := mapfn("mapaccess2_fat", t)
+		fn := mapfn("mapaccess2_fat", t, true)
 		z := reflectdata.ZeroAddr(w)
 		call = mkcall1(fn, fn.Type().Results(), init, reflectdata.TypePtr(t), r.X, key, z)
 	}
diff --git a/src/cmd/compile/internal/walk/complit.go b/src/cmd/compile/internal/walk/complit.go
index 54f2c5fefe..abd920d646 100644
--- a/src/cmd/compile/internal/walk/complit.go
+++ b/src/cmd/compile/internal/walk/complit.go
@@ -475,7 +475,10 @@ func maplit(n *ir.CompLitExpr, m ir.Node, init *ir.Nodes) {
 		zero := ir.NewAssignStmt(base.Pos, i, ir.NewInt(0))
 		cond := ir.NewBinaryExpr(base.Pos, ir.OLT, i, ir.NewInt(tk.NumElem()))
 		incr := ir.NewAssignStmt(base.Pos, i, ir.NewBinaryExpr(base.Pos, ir.OADD, i, ir.NewInt(1)))
-		body := ir.NewAssignStmt(base.Pos, lhs, rhs)
+
+		var body ir.Node = ir.NewAssignStmt(base.Pos, lhs, rhs)
+		body = typecheck.Stmt(body) // typechecker rewrites OINDEX to OINDEXMAP
+		body = orderStmtInPlace(body, map[string][]*ir.Name{})
 
 		loop := ir.NewForStmt(base.Pos, nil, cond, incr, nil)
 		loop.Body = []ir.Node{body}
@@ -503,7 +506,10 @@ func maplit(n *ir.CompLitExpr, m ir.Node, init *ir.Nodes) {
 		appendWalkStmt(init, ir.NewAssignStmt(base.Pos, tmpelem, elem))
 
 		ir.SetPos(tmpelem)
-		appendWalkStmt(init, ir.NewAssignStmt(base.Pos, ir.NewIndexExpr(base.Pos, m, tmpkey), tmpelem))
+		var a ir.Node = ir.NewAssignStmt(base.Pos, ir.NewIndexExpr(base.Pos, m, tmpkey), tmpelem)
+		a = typecheck.Stmt(a) // typechecker rewrites OINDEX to OINDEXMAP
+		a = orderStmtInPlace(a, map[string][]*ir.Name{})
+		appendWalkStmt(init, a)
 	}
 
 	appendWalkStmt(init, ir.NewUnaryExpr(base.Pos, ir.OVARKILL, tmpkey))
diff --git a/src/cmd/compile/internal/walk/expr.go b/src/cmd/compile/internal/walk/expr.go
index 0bf531e29d..0995c1314d 100644
--- a/src/cmd/compile/internal/walk/expr.go
+++ b/src/cmd/compile/internal/walk/expr.go
@@ -681,12 +681,16 @@ func walkIndexMap(n *ir.IndexExpr, init *ir.Nodes) ir.Node {
 	if n.Assigned {
 		// This m[k] expression is on the left-hand side of an assignment.
 		fast := mapfast(t)
-		if fast == mapslow {
+		switch fast {
+		case mapslow:
 			// standard version takes key by reference.
 			// order.expr made sure key is addressable.
 			key = typecheck.NodAddr(key)
+		case mapfast32ptr, mapfast64ptr:
+			// pointer version takes pointer key.
+			key = ir.NewConvExpr(n.Pos(), ir.OCONVNOP, types.Types[types.TUNSAFEPTR], key)
 		}
-		call = mkcall1(mapfn(mapassign[fast], t), nil, init, reflectdata.TypePtr(t), map_, key)
+		call = mkcall1(mapfn(mapassign[fast], t, false), nil, init, reflectdata.TypePtr(t), map_, key)
 	} else {
 		// m[k] is not the target of an assignment.
 		fast := mapfast(t)
@@ -697,10 +701,10 @@ func walkIndexMap(n *ir.IndexExpr, init *ir.Nodes) ir.Node {
 		}
 
 		if w := t.Elem().Width; w <= zeroValSize {
-			call = mkcall1(mapfn(mapaccess1[fast], t), types.NewPtr(t.Elem()), init, reflectdata.TypePtr(t), map_, key)
+			call = mkcall1(mapfn(mapaccess1[fast], t, false), types.NewPtr(t.Elem()), init, reflectdata.TypePtr(t), map_, key)
 		} else {
 			z := reflectdata.ZeroAddr(w)
-			call = mkcall1(mapfn("mapaccess1_fat", t), types.NewPtr(t.Elem()), init, reflectdata.TypePtr(t), map_, key, z)
+			call = mkcall1(mapfn("mapaccess1_fat", t, true), types.NewPtr(t.Elem()), init, reflectdata.TypePtr(t), map_, key, z)
 		}
 	}
 	call.SetType(types.NewPtr(t.Elem()))
diff --git a/src/cmd/compile/internal/walk/order.go b/src/cmd/compile/internal/walk/order.go
index a9e0e5efe8..8b30632665 100644
--- a/src/cmd/compile/internal/walk/order.go
+++ b/src/cmd/compile/internal/walk/order.go
@@ -6,6 +6,7 @@ package walk
 
 import (
 	"fmt"
+	"go/constant"
 
 	"cmd/compile/internal/base"
 	"cmd/compile/internal/escape"
@@ -269,10 +270,51 @@ func (o *orderState) addrTemp(n ir.Node) ir.Node {
 func (o *orderState) mapKeyTemp(t *types.Type, n ir.Node) ir.Node {
 	// Most map calls need to take the address of the key.
 	// Exception: map*_fast* calls. See golang.org/issue/19015.
-	if mapfast(t) == mapslow {
+	alg := mapfast(t)
+	if alg == mapslow {
 		return o.addrTemp(n)
 	}
-	return n
+	var kt *types.Type
+	switch alg {
+	case mapfast32, mapfast32ptr:
+		kt = types.Types[types.TUINT32]
+	case mapfast64, mapfast64ptr:
+		kt = types.Types[types.TUINT64]
+	case mapfaststr:
+		kt = types.Types[types.TSTRING]
+	}
+	nt := n.Type()
+	switch {
+	case nt == kt:
+		return n
+	case nt.Kind() == kt.Kind():
+		// can directly convert (e.g. named type to underlying type)
+		return typecheck.Expr(ir.NewConvExpr(n.Pos(), ir.OCONVNOP, kt, n))
+	case nt.IsInteger() && kt.IsInteger():
+		// can directly convert (e.g. int32 to uint32)
+		if n.Op() == ir.OLITERAL && nt.IsSigned() {
+			// avoid constant overflow error
+			n = ir.NewConstExpr(constant.MakeUint64(uint64(ir.Int64Val(n))), n)
+			n.SetType(kt)
+			return n
+		}
+		return typecheck.Expr(ir.NewConvExpr(n.Pos(), ir.OCONV, kt, n))
+	default:
+		// Unsafe cast through memory.
+		// We'll need to do a load with type kt. Create a temporary of type kt to
+		// ensure sufficient alignment. nt may be under-aligned.
+		if kt.Align < nt.Align {
+			base.Fatalf("mapKeyTemp: key type is not sufficiently aligned, kt=%v nt=%v", kt, nt)
+		}
+		clear := base.Flag.Cfg.Instrumenting // clear tmp if instrumenting, as it may be live at an inserted race call
+		tmp := o.newTemp(kt, clear)
+		// *(*nt)(&tmp) = n
+		var e ir.Node = typecheck.NodAddr(tmp)
+		e = ir.NewConvExpr(n.Pos(), ir.OCONVNOP, nt.PtrTo(), e)
+		e = ir.NewStarExpr(n.Pos(), e)
+		o.append(ir.NewAssignStmt(base.Pos, e, n))
+		return tmp
+	}
 }
 
 // mapKeyReplaceStrConv replaces OBYTES2STR by OBYTES2STRTMP
diff --git a/src/cmd/compile/internal/walk/stmt.go b/src/cmd/compile/internal/walk/stmt.go
index 773620bea6..0bf76680c4 100644
--- a/src/cmd/compile/internal/walk/stmt.go
+++ b/src/cmd/compile/internal/walk/stmt.go
@@ -197,11 +197,7 @@ func walkGoDefer(n *ir.GoDeferStmt) ir.Node {
 
 	case ir.ODELETE:
 		call := call.(*ir.CallExpr)
-		if mapfast(call.Args[0].Type()) == mapslow {
-			n.Call = wrapCall(call, &init)
-		} else {
-			n.Call = walkExpr(call, &init)
-		}
+		n.Call = wrapCall(call, &init)
 
 	case ir.OCOPY:
 		call := call.(*ir.BinaryExpr)
diff --git a/src/cmd/compile/internal/walk/walk.go b/src/cmd/compile/internal/walk/walk.go
index 1f0b777263..904587295a 100644
--- a/src/cmd/compile/internal/walk/walk.go
+++ b/src/cmd/compile/internal/walk/walk.go
@@ -14,7 +14,6 @@ import (
 	"cmd/compile/internal/ssagen"
 	"cmd/compile/internal/typecheck"
 	"cmd/compile/internal/types"
-	"cmd/internal/objabi"
 	"cmd/internal/src"
 )
 
@@ -158,12 +157,16 @@ func chanfn(name string, n int, t *types.Type) ir.Node {
 	return fn
 }
 
-func mapfn(name string, t *types.Type) ir.Node {
+func mapfn(name string, t *types.Type, isfat bool) ir.Node {
 	if !t.IsMap() {
 		base.Fatalf("mapfn %v", t)
 	}
 	fn := typecheck.LookupRuntime(name)
-	fn = typecheck.SubstArgTypes(fn, t.Key(), t.Elem(), t.Key(), t.Elem())
+	if mapfast(t) == mapslow || isfat {
+		fn = typecheck.SubstArgTypes(fn, t.Key(), t.Elem(), t.Key(), t.Elem())
+	} else {
+		fn = typecheck.SubstArgTypes(fn, t.Key(), t.Elem(), t.Elem())
+	}
 	return fn
 }
 
@@ -172,7 +175,11 @@ func mapfndel(name string, t *types.Type) ir.Node {
 		base.Fatalf("mapfn %v", t)
 	}
 	fn := typecheck.LookupRuntime(name)
-	fn = typecheck.SubstArgTypes(fn, t.Key(), t.Elem(), t.Key())
+	if mapfast(t) == mapslow {
+		fn = typecheck.SubstArgTypes(fn, t.Key(), t.Elem(), t.Key())
+	} else {
+		fn = typecheck.SubstArgTypes(fn, t.Key(), t.Elem())
+	}
 	return fn
 }
 
@@ -204,13 +211,6 @@ func mapfast(t *types.Type) int {
 	}
 	switch reflectdata.AlgType(t.Key()) {
 	case types.AMEM32:
-		if objabi.Experiment.RegabiArgs && t.Key().NumComponents(types.CountBlankFields) != 1 {
-			// If key has multiple components, under register ABI it will
-			// be passed differently than uint32.
-			// TODO: maybe unsafe-case to uint32. But needs to make the type
-			// checker happy.
-			return mapslow
-		}
 		if !t.Key().HasPointers() {
 			return mapfast32
 		}
@@ -219,10 +219,6 @@ func mapfast(t *types.Type) int {
 		}
 		base.Fatalf("small pointer %v", t.Key())
 	case types.AMEM64:
-		if objabi.Experiment.RegabiArgs && t.Key().NumComponents(types.CountBlankFields) != 1 {
-			// See above.
-			return mapslow
-		}
 		if !t.Key().HasPointers() {
 			return mapfast64
 		}