cmd/compile: remove unused arg from gorecover

We don't need this argument anymore to match up
a recover with its corresponding panic.

Change-Id: I5d3646cdd766259ee9d3d995a2f215f02e17abc6
Reviewed-on: https://go-review.googlesource.com/c/go/+/685555
Reviewed-by: Michael Knyszek <mknyszek@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Keith Randall <khr@google.com>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>

18 files changed, 398 insertions, 417 deletions

diff --git a/src/cmd/compile/internal/escape/call.go b/src/cmd/compile/internal/escape/call.go
index 58c44eb9bb..f9351de975 100644
--- a/src/cmd/compile/internal/escape/call.go
+++ b/src/cmd/compile/internal/escape/call.go
@@ -192,7 +192,7 @@ func (e *escape) call(ks []hole, call ir.Node) {
 		e.discard(call.X)
 		e.discard(call.Y)
 
-	case ir.ODELETE, ir.OPRINT, ir.OPRINTLN, ir.ORECOVERFP:
+	case ir.ODELETE, ir.OPRINT, ir.OPRINTLN, ir.ORECOVER:
 		call := call.(*ir.CallExpr)
 		for _, arg := range call.Args {
 			e.discard(arg)
diff --git a/src/cmd/compile/internal/escape/expr.go b/src/cmd/compile/internal/escape/expr.go
index f479a2913a..1521c2edd1 100644
--- a/src/cmd/compile/internal/escape/expr.go
+++ b/src/cmd/compile/internal/escape/expr.go
@@ -139,7 +139,7 @@ func (e *escape) exprSkipInit(k hole, n ir.Node) {
 		e.discard(n.X)
 
 	case ir.OCALLMETH, ir.OCALLFUNC, ir.OCALLINTER, ir.OINLCALL,
-		ir.OLEN, ir.OCAP, ir.OMIN, ir.OMAX, ir.OCOMPLEX, ir.OREAL, ir.OIMAG, ir.OAPPEND, ir.OCOPY, ir.ORECOVERFP,
+		ir.OLEN, ir.OCAP, ir.OMIN, ir.OMAX, ir.OCOMPLEX, ir.OREAL, ir.OIMAG, ir.OAPPEND, ir.OCOPY, ir.ORECOVER,
 		ir.OUNSAFEADD, ir.OUNSAFESLICE, ir.OUNSAFESTRING, ir.OUNSAFESTRINGDATA, ir.OUNSAFESLICEDATA:
 		e.call([]hole{k}, n)
 
diff --git a/src/cmd/compile/internal/escape/stmt.go b/src/cmd/compile/internal/escape/stmt.go
index b766864a30..2388873caf 100644
--- a/src/cmd/compile/internal/escape/stmt.go
+++ b/src/cmd/compile/internal/escape/stmt.go
@@ -183,7 +183,7 @@ func (e *escape) stmt(n ir.Node) {
 			dsts[i] = res.Nname.(*ir.Name)
 		}
 		e.assignList(dsts, n.Results, "return", n)
-	case ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER, ir.OINLCALL, ir.OCLEAR, ir.OCLOSE, ir.OCOPY, ir.ODELETE, ir.OPANIC, ir.OPRINT, ir.OPRINTLN, ir.ORECOVERFP:
+	case ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER, ir.OINLCALL, ir.OCLEAR, ir.OCLOSE, ir.OCOPY, ir.ODELETE, ir.OPANIC, ir.OPRINT, ir.OPRINTLN, ir.ORECOVER:
 		e.call(nil, n)
 	case ir.OGO, ir.ODEFER:
 		n := n.(*ir.GoDeferStmt)
diff --git a/src/cmd/compile/internal/inline/inl.go b/src/cmd/compile/internal/inline/inl.go
index 459c2498fc..c06f76fe9f 100644
--- a/src/cmd/compile/internal/inline/inl.go
+++ b/src/cmd/compile/internal/inline/inl.go
@@ -605,10 +605,7 @@ opSwitch:
 		v.budget -= inlineExtraPanicCost
 
 	case ir.ORECOVER:
-		base.FatalfAt(n.Pos(), "ORECOVER missed typecheck")
-	case ir.ORECOVERFP:
-		// recover matches the argument frame pointer to find
-		// the right panic value, so it needs an argument frame.
+		// TODO: maybe we could allow inlining of recover() now?
 		v.reason = "call to recover"
 		return true
 
diff --git a/src/cmd/compile/internal/inline/inlheur/analyze_func_flags.go b/src/cmd/compile/internal/inline/inlheur/analyze_func_flags.go
index d86fd7d71b..22312e2241 100644
--- a/src/cmd/compile/internal/inline/inlheur/analyze_func_flags.go
+++ b/src/cmd/compile/internal/inline/inlheur/analyze_func_flags.go
@@ -335,7 +335,7 @@ func (ffa *funcFlagsAnalyzer) nodeVisitPost(n ir.Node) {
 		ir.OPRINTLN, ir.OPRINT, ir.OLABEL, ir.OCALLINTER, ir.ODEFER,
 		ir.OSEND, ir.ORECV, ir.OSELRECV2, ir.OGO, ir.OAPPEND, ir.OAS2DOTTYPE,
 		ir.OAS2MAPR, ir.OGETG, ir.ODELETE, ir.OINLMARK, ir.OAS2RECV,
-		ir.OMIN, ir.OMAX, ir.OMAKE, ir.ORECOVERFP, ir.OGETCALLERSP:
+		ir.OMIN, ir.OMAX, ir.OMAKE, ir.OGETCALLERSP:
 		// these should all be benign/uninteresting
 	case ir.OTAILCALL, ir.OJUMPTABLE, ir.OTYPESW:
 		// don't expect to see these at all.
diff --git a/src/cmd/compile/internal/ir/expr.go b/src/cmd/compile/internal/ir/expr.go
index 98b353147f..9d34f27ce5 100644
--- a/src/cmd/compile/internal/ir/expr.go
+++ b/src/cmd/compile/internal/ir/expr.go
@@ -213,7 +213,7 @@ func (n *CallExpr) SetOp(op Op) {
 		ODELETE,
 		OGETG, OGETCALLERSP,
 		OMAKE, OMAX, OMIN, OPRINT, OPRINTLN,
-		ORECOVER, ORECOVERFP:
+		ORECOVER:
 		n.op = op
 	}
 }
diff --git a/src/cmd/compile/internal/ir/node.go b/src/cmd/compile/internal/ir/node.go
index 058ada5ac3..003ec15de1 100644
--- a/src/cmd/compile/internal/ir/node.go
+++ b/src/cmd/compile/internal/ir/node.go
@@ -234,7 +234,6 @@ const (
 	OSLICEHEADER      // sliceheader{Ptr, Len, Cap} (Ptr is unsafe.Pointer, Len is length, Cap is capacity)
 	OSTRINGHEADER     // stringheader{Ptr, Len} (Ptr is unsafe.Pointer, Len is length)
 	ORECOVER          // recover()
-	ORECOVERFP        // recover(Args) w/ explicit FP argument
 	ORECV             // <-X
 	ORUNESTR          // Type(X) (Type is string, X is rune)
 	OSELRECV2         // like OAS2: Lhs = Rhs where len(Lhs)=2, len(Rhs)=1, Rhs[0].Op = ORECV (appears as .Var of OCASE)
diff --git a/src/cmd/compile/internal/ir/op_string.go b/src/cmd/compile/internal/ir/op_string.go
index a1806d1349..7494beee4c 100644
--- a/src/cmd/compile/internal/ir/op_string.go
+++ b/src/cmd/compile/internal/ir/op_string.go
@@ -108,62 +108,61 @@ func _() {
 	_ = x[OSLICEHEADER-97]
 	_ = x[OSTRINGHEADER-98]
 	_ = x[ORECOVER-99]
-	_ = x[ORECOVERFP-100]
-	_ = x[ORECV-101]
-	_ = x[ORUNESTR-102]
-	_ = x[OSELRECV2-103]
-	_ = x[OMIN-104]
-	_ = x[OMAX-105]
-	_ = x[OREAL-106]
-	_ = x[OIMAG-107]
-	_ = x[OCOMPLEX-108]
-	_ = x[OUNSAFEADD-109]
-	_ = x[OUNSAFESLICE-110]
-	_ = x[OUNSAFESLICEDATA-111]
-	_ = x[OUNSAFESTRING-112]
-	_ = x[OUNSAFESTRINGDATA-113]
-	_ = x[OMETHEXPR-114]
-	_ = x[OMETHVALUE-115]
-	_ = x[OBLOCK-116]
-	_ = x[OBREAK-117]
-	_ = x[OCASE-118]
-	_ = x[OCONTINUE-119]
-	_ = x[ODEFER-120]
-	_ = x[OFALL-121]
-	_ = x[OFOR-122]
-	_ = x[OGOTO-123]
-	_ = x[OIF-124]
-	_ = x[OLABEL-125]
-	_ = x[OGO-126]
-	_ = x[ORANGE-127]
-	_ = x[ORETURN-128]
-	_ = x[OSELECT-129]
-	_ = x[OSWITCH-130]
-	_ = x[OTYPESW-131]
-	_ = x[OINLCALL-132]
-	_ = x[OMAKEFACE-133]
-	_ = x[OITAB-134]
-	_ = x[OIDATA-135]
-	_ = x[OSPTR-136]
-	_ = x[OCFUNC-137]
-	_ = x[OCHECKNIL-138]
-	_ = x[ORESULT-139]
-	_ = x[OINLMARK-140]
-	_ = x[OLINKSYMOFFSET-141]
-	_ = x[OJUMPTABLE-142]
-	_ = x[OINTERFACESWITCH-143]
-	_ = x[ODYNAMICDOTTYPE-144]
-	_ = x[ODYNAMICDOTTYPE2-145]
-	_ = x[ODYNAMICTYPE-146]
-	_ = x[OTAILCALL-147]
-	_ = x[OGETG-148]
-	_ = x[OGETCALLERSP-149]
-	_ = x[OEND-150]
+	_ = x[ORECV-100]
+	_ = x[ORUNESTR-101]
+	_ = x[OSELRECV2-102]
+	_ = x[OMIN-103]
+	_ = x[OMAX-104]
+	_ = x[OREAL-105]
+	_ = x[OIMAG-106]
+	_ = x[OCOMPLEX-107]
+	_ = x[OUNSAFEADD-108]
+	_ = x[OUNSAFESLICE-109]
+	_ = x[OUNSAFESLICEDATA-110]
+	_ = x[OUNSAFESTRING-111]
+	_ = x[OUNSAFESTRINGDATA-112]
+	_ = x[OMETHEXPR-113]
+	_ = x[OMETHVALUE-114]
+	_ = x[OBLOCK-115]
+	_ = x[OBREAK-116]
+	_ = x[OCASE-117]
+	_ = x[OCONTINUE-118]
+	_ = x[ODEFER-119]
+	_ = x[OFALL-120]
+	_ = x[OFOR-121]
+	_ = x[OGOTO-122]
+	_ = x[OIF-123]
+	_ = x[OLABEL-124]
+	_ = x[OGO-125]
+	_ = x[ORANGE-126]
+	_ = x[ORETURN-127]
+	_ = x[OSELECT-128]
+	_ = x[OSWITCH-129]
+	_ = x[OTYPESW-130]
+	_ = x[OINLCALL-131]
+	_ = x[OMAKEFACE-132]
+	_ = x[OITAB-133]
+	_ = x[OIDATA-134]
+	_ = x[OSPTR-135]
+	_ = x[OCFUNC-136]
+	_ = x[OCHECKNIL-137]
+	_ = x[ORESULT-138]
+	_ = x[OINLMARK-139]
+	_ = x[OLINKSYMOFFSET-140]
+	_ = x[OJUMPTABLE-141]
+	_ = x[OINTERFACESWITCH-142]
+	_ = x[ODYNAMICDOTTYPE-143]
+	_ = x[ODYNAMICDOTTYPE2-144]
+	_ = x[ODYNAMICTYPE-145]
+	_ = x[OTAILCALL-146]
+	_ = x[OGETG-147]
+	_ = x[OGETCALLERSP-148]
+	_ = x[OEND-149]
 }
 
-const _Op_name = "XXXNAMENONAMETYPELITERALNILADDSUBORXORADDSTRADDRANDANDAPPENDBYTES2STRBYTES2STRTMPRUNES2STRSTR2BYTESSTR2BYTESTMPSTR2RUNESSLICE2ARRSLICE2ARRPTRASAS2AS2DOTTYPEAS2FUNCAS2MAPRAS2RECVASOPCALLCALLFUNCCALLMETHCALLINTERCAPCLEARCLOSECLOSURECOMPLITMAPLITSTRUCTLITARRAYLITSLICELITPTRLITCONVCONVIFACECONVNOPCOPYDCLDCLFUNCDELETEDOTDOTPTRDOTMETHDOTINTERXDOTDOTTYPEDOTTYPE2EQNELTLEGEGTDEREFINDEXINDEXMAPKEYSTRUCTKEYLENMAKEMAKECHANMAKEMAPMAKESLICEMAKESLICECOPYMULDIVMODLSHRSHANDANDNOTNEWNOTBITNOTPLUSNEGORORPANICPRINTPRINTLNPARENSENDSLICESLICEARRSLICESTRSLICE3SLICE3ARRSLICEHEADERSTRINGHEADERRECOVERRECOVERFPRECVRUNESTRSELRECV2MINMAXREALIMAGCOMPLEXUNSAFEADDUNSAFESLICEUNSAFESLICEDATAUNSAFESTRINGUNSAFESTRINGDATAMETHEXPRMETHVALUEBLOCKBREAKCASECONTINUEDEFERFALLFORGOTOIFLABELGORANGERETURNSELECTSWITCHTYPESWINLCALLMAKEFACEITABIDATASPTRCFUNCCHECKNILRESULTINLMARKLINKSYMOFFSETJUMPTABLEINTERFACESWITCHDYNAMICDOTTYPEDYNAMICDOTTYPE2DYNAMICTYPETAILCALLGETGGETCALLERSPEND"
+const _Op_name = "XXXNAMENONAMETYPELITERALNILADDSUBORXORADDSTRADDRANDANDAPPENDBYTES2STRBYTES2STRTMPRUNES2STRSTR2BYTESSTR2BYTESTMPSTR2RUNESSLICE2ARRSLICE2ARRPTRASAS2AS2DOTTYPEAS2FUNCAS2MAPRAS2RECVASOPCALLCALLFUNCCALLMETHCALLINTERCAPCLEARCLOSECLOSURECOMPLITMAPLITSTRUCTLITARRAYLITSLICELITPTRLITCONVCONVIFACECONVNOPCOPYDCLDCLFUNCDELETEDOTDOTPTRDOTMETHDOTINTERXDOTDOTTYPEDOTTYPE2EQNELTLEGEGTDEREFINDEXINDEXMAPKEYSTRUCTKEYLENMAKEMAKECHANMAKEMAPMAKESLICEMAKESLICECOPYMULDIVMODLSHRSHANDANDNOTNEWNOTBITNOTPLUSNEGORORPANICPRINTPRINTLNPARENSENDSLICESLICEARRSLICESTRSLICE3SLICE3ARRSLICEHEADERSTRINGHEADERRECOVERRECVRUNESTRSELRECV2MINMAXREALIMAGCOMPLEXUNSAFEADDUNSAFESLICEUNSAFESLICEDATAUNSAFESTRINGUNSAFESTRINGDATAMETHEXPRMETHVALUEBLOCKBREAKCASECONTINUEDEFERFALLFORGOTOIFLABELGORANGERETURNSELECTSWITCHTYPESWINLCALLMAKEFACEITABIDATASPTRCFUNCCHECKNILRESULTINLMARKLINKSYMOFFSETJUMPTABLEINTERFACESWITCHDYNAMICDOTTYPEDYNAMICDOTTYPE2DYNAMICTYPETAILCALLGETGGETCALLERSPEND"
 
-var _Op_index = [...]uint16{0, 3, 7, 13, 17, 24, 27, 30, 33, 35, 38, 44, 48, 54, 60, 69, 81, 90, 99, 111, 120, 129, 141, 143, 146, 156, 163, 170, 177, 181, 185, 193, 201, 210, 213, 218, 223, 230, 237, 243, 252, 260, 268, 274, 278, 287, 294, 298, 301, 308, 314, 317, 323, 330, 338, 342, 349, 357, 359, 361, 363, 365, 367, 369, 374, 379, 387, 390, 399, 402, 406, 414, 421, 430, 443, 446, 449, 452, 455, 458, 461, 467, 470, 473, 479, 483, 486, 490, 495, 500, 507, 512, 516, 521, 529, 537, 543, 552, 563, 575, 582, 591, 595, 602, 610, 613, 616, 620, 624, 631, 640, 651, 666, 678, 694, 702, 711, 716, 721, 725, 733, 738, 742, 745, 749, 751, 756, 758, 763, 769, 775, 781, 787, 794, 802, 806, 811, 815, 820, 828, 834, 841, 854, 863, 878, 892, 907, 918, 926, 930, 941, 944}
+var _Op_index = [...]uint16{0, 3, 7, 13, 17, 24, 27, 30, 33, 35, 38, 44, 48, 54, 60, 69, 81, 90, 99, 111, 120, 129, 141, 143, 146, 156, 163, 170, 177, 181, 185, 193, 201, 210, 213, 218, 223, 230, 237, 243, 252, 260, 268, 274, 278, 287, 294, 298, 301, 308, 314, 317, 323, 330, 338, 342, 349, 357, 359, 361, 363, 365, 367, 369, 374, 379, 387, 390, 399, 402, 406, 414, 421, 430, 443, 446, 449, 452, 455, 458, 461, 467, 470, 473, 479, 483, 486, 490, 495, 500, 507, 512, 516, 521, 529, 537, 543, 552, 563, 575, 582, 586, 593, 601, 604, 607, 611, 615, 622, 631, 642, 657, 669, 685, 693, 702, 707, 712, 716, 724, 729, 733, 736, 740, 742, 747, 749, 754, 760, 766, 772, 778, 785, 793, 797, 802, 806, 811, 819, 825, 832, 845, 854, 869, 883, 898, 909, 917, 921, 932, 935}
 
 func (i Op) String() string {
 	if i >= Op(len(_Op_index)-1) {
diff --git a/src/cmd/compile/internal/typecheck/_builtin/runtime.go b/src/cmd/compile/internal/typecheck/_builtin/runtime.go
index a1397b32b3..628c7e2fbc 100644
--- a/src/cmd/compile/internal/typecheck/_builtin/runtime.go
+++ b/src/cmd/compile/internal/typecheck/_builtin/runtime.go
@@ -25,7 +25,7 @@ func throwinit()
 func panicwrap()
 
 func gopanic(interface{})
-func gorecover(*int32) interface{}
+func gorecover() interface{}
 func goschedguarded()
 
 // Note: these declarations are just for wasm port.
diff --git a/src/cmd/compile/internal/typecheck/builtin.go b/src/cmd/compile/internal/typecheck/builtin.go
index f3ab6766ec..730ed4146a 100644
--- a/src/cmd/compile/internal/typecheck/builtin.go
+++ b/src/cmd/compile/internal/typecheck/builtin.go
@@ -36,204 +36,204 @@ var runtimeDecls = [...]struct {
 	{"throwinit", funcTag, 9},
 	{"panicwrap", funcTag, 9},
 	{"gopanic", funcTag, 11},
-	{"gorecover", funcTag, 14},
+	{"gorecover", funcTag, 12},
 	{"goschedguarded", funcTag, 9},
-	{"goPanicIndex", funcTag, 16},
-	{"goPanicIndexU", funcTag, 18},
-	{"goPanicSliceAlen", funcTag, 16},
-	{"goPanicSliceAlenU", funcTag, 18},
-	{"goPanicSliceAcap", funcTag, 16},
-	{"goPanicSliceAcapU", funcTag, 18},
-	{"goPanicSliceB", funcTag, 16},
-	{"goPanicSliceBU", funcTag, 18},
-	{"goPanicSlice3Alen", funcTag, 16},
-	{"goPanicSlice3AlenU", funcTag, 18},
-	{"goPanicSlice3Acap", funcTag, 16},
-	{"goPanicSlice3AcapU", funcTag, 18},
-	{"goPanicSlice3B", funcTag, 16},
-	{"goPanicSlice3BU", funcTag, 18},
-	{"goPanicSlice3C", funcTag, 16},
-	{"goPanicSlice3CU", funcTag, 18},
-	{"goPanicSliceConvert", funcTag, 16},
-	{"printbool", funcTag, 19},
-	{"printfloat", funcTag, 21},
-	{"printint", funcTag, 23},
-	{"printhex", funcTag, 25},
-	{"printuint", funcTag, 25},
-	{"printcomplex", funcTag, 27},
-	{"printstring", funcTag, 29},
-	{"printpointer", funcTag, 30},
-	{"printuintptr", funcTag, 31},
-	{"printiface", funcTag, 30},
-	{"printeface", funcTag, 30},
-	{"printslice", funcTag, 30},
+	{"goPanicIndex", funcTag, 14},
+	{"goPanicIndexU", funcTag, 16},
+	{"goPanicSliceAlen", funcTag, 14},
+	{"goPanicSliceAlenU", funcTag, 16},
+	{"goPanicSliceAcap", funcTag, 14},
+	{"goPanicSliceAcapU", funcTag, 16},
+	{"goPanicSliceB", funcTag, 14},
+	{"goPanicSliceBU", funcTag, 16},
+	{"goPanicSlice3Alen", funcTag, 14},
+	{"goPanicSlice3AlenU", funcTag, 16},
+	{"goPanicSlice3Acap", funcTag, 14},
+	{"goPanicSlice3AcapU", funcTag, 16},
+	{"goPanicSlice3B", funcTag, 14},
+	{"goPanicSlice3BU", funcTag, 16},
+	{"goPanicSlice3C", funcTag, 14},
+	{"goPanicSlice3CU", funcTag, 16},
+	{"goPanicSliceConvert", funcTag, 14},
+	{"printbool", funcTag, 17},
+	{"printfloat", funcTag, 19},
+	{"printint", funcTag, 21},
+	{"printhex", funcTag, 23},
+	{"printuint", funcTag, 23},
+	{"printcomplex", funcTag, 25},
+	{"printstring", funcTag, 27},
+	{"printpointer", funcTag, 28},
+	{"printuintptr", funcTag, 29},
+	{"printiface", funcTag, 28},
+	{"printeface", funcTag, 28},
+	{"printslice", funcTag, 28},
 	{"printnl", funcTag, 9},
 	{"printsp", funcTag, 9},
 	{"printlock", funcTag, 9},
 	{"printunlock", funcTag, 9},
-	{"concatstring2", funcTag, 34},
-	{"concatstring3", funcTag, 35},
-	{"concatstring4", funcTag, 36},
-	{"concatstring5", funcTag, 37},
-	{"concatstrings", funcTag, 39},
-	{"concatbyte2", funcTag, 41},
-	{"concatbyte3", funcTag, 42},
-	{"concatbyte4", funcTag, 43},
-	{"concatbyte5", funcTag, 44},
-	{"concatbytes", funcTag, 45},
-	{"cmpstring", funcTag, 46},
-	{"intstring", funcTag, 49},
-	{"slicebytetostring", funcTag, 50},
-	{"slicebytetostringtmp", funcTag, 51},
-	{"slicerunetostring", funcTag, 54},
-	{"stringtoslicebyte", funcTag, 55},
-	{"stringtoslicerune", funcTag, 58},
-	{"slicecopy", funcTag, 59},
-	{"decoderune", funcTag, 60},
-	{"countrunes", funcTag, 61},
-	{"convT", funcTag, 62},
-	{"convTnoptr", funcTag, 62},
-	{"convT16", funcTag, 64},
-	{"convT32", funcTag, 66},
-	{"convT64", funcTag, 67},
-	{"convTstring", funcTag, 68},
-	{"convTslice", funcTag, 71},
-	{"assertE2I", funcTag, 72},
-	{"assertE2I2", funcTag, 72},
-	{"panicdottypeE", funcTag, 73},
-	{"panicdottypeI", funcTag, 73},
-	{"panicnildottype", funcTag, 74},
-	{"typeAssert", funcTag, 72},
-	{"interfaceSwitch", funcTag, 75},
-	{"ifaceeq", funcTag, 77},
-	{"efaceeq", funcTag, 77},
-	{"panicrangestate", funcTag, 78},
-	{"deferrangefunc", funcTag, 79},
-	{"rand", funcTag, 80},
-	{"rand32", funcTag, 81},
-	{"makemap64", funcTag, 83},
-	{"makemap", funcTag, 84},
-	{"makemap_small", funcTag, 85},
-	{"mapaccess1", funcTag, 86},
-	{"mapaccess1_fast32", funcTag, 87},
-	{"mapaccess1_fast64", funcTag, 88},
-	{"mapaccess1_faststr", funcTag, 89},
-	{"mapaccess1_fat", funcTag, 90},
-	{"mapaccess2", funcTag, 91},
-	{"mapaccess2_fast32", funcTag, 92},
-	{"mapaccess2_fast64", funcTag, 93},
-	{"mapaccess2_faststr", funcTag, 94},
-	{"mapaccess2_fat", funcTag, 95},
-	{"mapassign", funcTag, 86},
-	{"mapassign_fast32", funcTag, 87},
-	{"mapassign_fast32ptr", funcTag, 96},
-	{"mapassign_fast64", funcTag, 88},
-	{"mapassign_fast64ptr", funcTag, 96},
-	{"mapassign_faststr", funcTag, 89},
-	{"mapiterinit", funcTag, 97},
-	{"mapIterStart", funcTag, 97},
-	{"mapdelete", funcTag, 97},
-	{"mapdelete_fast32", funcTag, 98},
-	{"mapdelete_fast64", funcTag, 99},
-	{"mapdelete_faststr", funcTag, 100},
-	{"mapiternext", funcTag, 101},
-	{"mapIterNext", funcTag, 101},
-	{"mapclear", funcTag, 102},
-	{"makechan64", funcTag, 104},
-	{"makechan", funcTag, 105},
-	{"chanrecv1", funcTag, 107},
-	{"chanrecv2", funcTag, 108},
-	{"chansend1", funcTag, 110},
-	{"closechan", funcTag, 111},
-	{"chanlen", funcTag, 112},
-	{"chancap", funcTag, 112},
-	{"writeBarrier", varTag, 114},
-	{"typedmemmove", funcTag, 115},
-	{"typedmemclr", funcTag, 116},
-	{"typedslicecopy", funcTag, 117},
-	{"selectnbsend", funcTag, 118},
-	{"selectnbrecv", funcTag, 119},
-	{"selectsetpc", funcTag, 120},
-	{"selectgo", funcTag, 121},
+	{"concatstring2", funcTag, 32},
+	{"concatstring3", funcTag, 33},
+	{"concatstring4", funcTag, 34},
+	{"concatstring5", funcTag, 35},
+	{"concatstrings", funcTag, 37},
+	{"concatbyte2", funcTag, 39},
+	{"concatbyte3", funcTag, 40},
+	{"concatbyte4", funcTag, 41},
+	{"concatbyte5", funcTag, 42},
+	{"concatbytes", funcTag, 43},
+	{"cmpstring", funcTag, 44},
+	{"intstring", funcTag, 47},
+	{"slicebytetostring", funcTag, 48},
+	{"slicebytetostringtmp", funcTag, 49},
+	{"slicerunetostring", funcTag, 52},
+	{"stringtoslicebyte", funcTag, 53},
+	{"stringtoslicerune", funcTag, 56},
+	{"slicecopy", funcTag, 57},
+	{"decoderune", funcTag, 58},
+	{"countrunes", funcTag, 59},
+	{"convT", funcTag, 60},
+	{"convTnoptr", funcTag, 60},
+	{"convT16", funcTag, 62},
+	{"convT32", funcTag, 64},
+	{"convT64", funcTag, 65},
+	{"convTstring", funcTag, 66},
+	{"convTslice", funcTag, 69},
+	{"assertE2I", funcTag, 70},
+	{"assertE2I2", funcTag, 70},
+	{"panicdottypeE", funcTag, 71},
+	{"panicdottypeI", funcTag, 71},
+	{"panicnildottype", funcTag, 72},
+	{"typeAssert", funcTag, 70},
+	{"interfaceSwitch", funcTag, 73},
+	{"ifaceeq", funcTag, 75},
+	{"efaceeq", funcTag, 75},
+	{"panicrangestate", funcTag, 76},
+	{"deferrangefunc", funcTag, 12},
+	{"rand", funcTag, 77},
+	{"rand32", funcTag, 78},
+	{"makemap64", funcTag, 80},
+	{"makemap", funcTag, 81},
+	{"makemap_small", funcTag, 82},
+	{"mapaccess1", funcTag, 83},
+	{"mapaccess1_fast32", funcTag, 84},
+	{"mapaccess1_fast64", funcTag, 85},
+	{"mapaccess1_faststr", funcTag, 86},
+	{"mapaccess1_fat", funcTag, 87},
+	{"mapaccess2", funcTag, 88},
+	{"mapaccess2_fast32", funcTag, 89},
+	{"mapaccess2_fast64", funcTag, 90},
+	{"mapaccess2_faststr", funcTag, 91},
+	{"mapaccess2_fat", funcTag, 92},
+	{"mapassign", funcTag, 83},
+	{"mapassign_fast32", funcTag, 84},
+	{"mapassign_fast32ptr", funcTag, 93},
+	{"mapassign_fast64", funcTag, 85},
+	{"mapassign_fast64ptr", funcTag, 93},
+	{"mapassign_faststr", funcTag, 86},
+	{"mapiterinit", funcTag, 94},
+	{"mapIterStart", funcTag, 94},
+	{"mapdelete", funcTag, 94},
+	{"mapdelete_fast32", funcTag, 95},
+	{"mapdelete_fast64", funcTag, 96},
+	{"mapdelete_faststr", funcTag, 97},
+	{"mapiternext", funcTag, 98},
+	{"mapIterNext", funcTag, 98},
+	{"mapclear", funcTag, 99},
+	{"makechan64", funcTag, 101},
+	{"makechan", funcTag, 102},
+	{"chanrecv1", funcTag, 104},
+	{"chanrecv2", funcTag, 105},
+	{"chansend1", funcTag, 107},
+	{"closechan", funcTag, 108},
+	{"chanlen", funcTag, 109},
+	{"chancap", funcTag, 109},
+	{"writeBarrier", varTag, 111},
+	{"typedmemmove", funcTag, 112},
+	{"typedmemclr", funcTag, 113},
+	{"typedslicecopy", funcTag, 114},
+	{"selectnbsend", funcTag, 115},
+	{"selectnbrecv", funcTag, 116},
+	{"selectsetpc", funcTag, 117},
+	{"selectgo", funcTag, 118},
 	{"block", funcTag, 9},
-	{"makeslice", funcTag, 122},
-	{"makeslice64", funcTag, 123},
-	{"makeslicecopy", funcTag, 124},
-	{"growslice", funcTag, 126},
-	{"unsafeslicecheckptr", funcTag, 127},
+	{"makeslice", funcTag, 119},
+	{"makeslice64", funcTag, 120},
+	{"makeslicecopy", funcTag, 121},
+	{"growslice", funcTag, 123},
+	{"unsafeslicecheckptr", funcTag, 124},
 	{"panicunsafeslicelen", funcTag, 9},
 	{"panicunsafeslicenilptr", funcTag, 9},
-	{"unsafestringcheckptr", funcTag, 128},
+	{"unsafestringcheckptr", funcTag, 125},
 	{"panicunsafestringlen", funcTag, 9},
 	{"panicunsafestringnilptr", funcTag, 9},
-	{"memmove", funcTag, 129},
-	{"memclrNoHeapPointers", funcTag, 130},
-	{"memclrHasPointers", funcTag, 130},
-	{"memequal", funcTag, 131},
-	{"memequal0", funcTag, 132},
-	{"memequal8", funcTag, 132},
-	{"memequal16", funcTag, 132},
-	{"memequal32", funcTag, 132},
-	{"memequal64", funcTag, 132},
-	{"memequal128", funcTag, 132},
-	{"f32equal", funcTag, 133},
-	{"f64equal", funcTag, 133},
-	{"c64equal", funcTag, 133},
-	{"c128equal", funcTag, 133},
-	{"strequal", funcTag, 133},
-	{"interequal", funcTag, 133},
-	{"nilinterequal", funcTag, 133},
-	{"memhash", funcTag, 134},
-	{"memhash0", funcTag, 135},
-	{"memhash8", funcTag, 135},
-	{"memhash16", funcTag, 135},
-	{"memhash32", funcTag, 135},
-	{"memhash64", funcTag, 135},
-	{"memhash128", funcTag, 135},
-	{"f32hash", funcTag, 136},
-	{"f64hash", funcTag, 136},
-	{"c64hash", funcTag, 136},
-	{"c128hash", funcTag, 136},
-	{"strhash", funcTag, 136},
-	{"interhash", funcTag, 136},
-	{"nilinterhash", funcTag, 136},
-	{"int64div", funcTag, 137},
-	{"uint64div", funcTag, 138},
-	{"int64mod", funcTag, 137},
-	{"uint64mod", funcTag, 138},
-	{"float64toint64", funcTag, 139},
-	{"float64touint64", funcTag, 140},
-	{"float64touint32", funcTag, 141},
-	{"int64tofloat64", funcTag, 142},
-	{"int64tofloat32", funcTag, 144},
-	{"uint64tofloat64", funcTag, 145},
-	{"uint64tofloat32", funcTag, 146},
-	{"uint32tofloat64", funcTag, 147},
-	{"complex128div", funcTag, 148},
-	{"racefuncenter", funcTag, 31},
+	{"memmove", funcTag, 126},
+	{"memclrNoHeapPointers", funcTag, 127},
+	{"memclrHasPointers", funcTag, 127},
+	{"memequal", funcTag, 128},
+	{"memequal0", funcTag, 129},
+	{"memequal8", funcTag, 129},
+	{"memequal16", funcTag, 129},
+	{"memequal32", funcTag, 129},
+	{"memequal64", funcTag, 129},
+	{"memequal128", funcTag, 129},
+	{"f32equal", funcTag, 130},
+	{"f64equal", funcTag, 130},
+	{"c64equal", funcTag, 130},
+	{"c128equal", funcTag, 130},
+	{"strequal", funcTag, 130},
+	{"interequal", funcTag, 130},
+	{"nilinterequal", funcTag, 130},
+	{"memhash", funcTag, 131},
+	{"memhash0", funcTag, 132},
+	{"memhash8", funcTag, 132},
+	{"memhash16", funcTag, 132},
+	{"memhash32", funcTag, 132},
+	{"memhash64", funcTag, 132},
+	{"memhash128", funcTag, 132},
+	{"f32hash", funcTag, 133},
+	{"f64hash", funcTag, 133},
+	{"c64hash", funcTag, 133},
+	{"c128hash", funcTag, 133},
+	{"strhash", funcTag, 133},
+	{"interhash", funcTag, 133},
+	{"nilinterhash", funcTag, 133},
+	{"int64div", funcTag, 134},
+	{"uint64div", funcTag, 135},
+	{"int64mod", funcTag, 134},
+	{"uint64mod", funcTag, 135},
+	{"float64toint64", funcTag, 136},
+	{"float64touint64", funcTag, 137},
+	{"float64touint32", funcTag, 138},
+	{"int64tofloat64", funcTag, 139},
+	{"int64tofloat32", funcTag, 141},
+	{"uint64tofloat64", funcTag, 142},
+	{"uint64tofloat32", funcTag, 143},
+	{"uint32tofloat64", funcTag, 144},
+	{"complex128div", funcTag, 145},
+	{"racefuncenter", funcTag, 29},
 	{"racefuncexit", funcTag, 9},
-	{"raceread", funcTag, 31},
-	{"racewrite", funcTag, 31},
-	{"racereadrange", funcTag, 149},
-	{"racewriterange", funcTag, 149},
-	{"msanread", funcTag, 149},
-	{"msanwrite", funcTag, 149},
-	{"msanmove", funcTag, 150},
-	{"asanread", funcTag, 149},
-	{"asanwrite", funcTag, 149},
-	{"checkptrAlignment", funcTag, 151},
-	{"checkptrArithmetic", funcTag, 153},
-	{"libfuzzerTraceCmp1", funcTag, 154},
-	{"libfuzzerTraceCmp2", funcTag, 155},
-	{"libfuzzerTraceCmp4", funcTag, 156},
-	{"libfuzzerTraceCmp8", funcTag, 157},
-	{"libfuzzerTraceConstCmp1", funcTag, 154},
-	{"libfuzzerTraceConstCmp2", funcTag, 155},
-	{"libfuzzerTraceConstCmp4", funcTag, 156},
-	{"libfuzzerTraceConstCmp8", funcTag, 157},
-	{"libfuzzerHookStrCmp", funcTag, 158},
-	{"libfuzzerHookEqualFold", funcTag, 158},
-	{"addCovMeta", funcTag, 160},
+	{"raceread", funcTag, 29},
+	{"racewrite", funcTag, 29},
+	{"racereadrange", funcTag, 146},
+	{"racewriterange", funcTag, 146},
+	{"msanread", funcTag, 146},
+	{"msanwrite", funcTag, 146},
+	{"msanmove", funcTag, 147},
+	{"asanread", funcTag, 146},
+	{"asanwrite", funcTag, 146},
+	{"checkptrAlignment", funcTag, 148},
+	{"checkptrArithmetic", funcTag, 150},
+	{"libfuzzerTraceCmp1", funcTag, 151},
+	{"libfuzzerTraceCmp2", funcTag, 152},
+	{"libfuzzerTraceCmp4", funcTag, 153},
+	{"libfuzzerTraceCmp8", funcTag, 154},
+	{"libfuzzerTraceConstCmp1", funcTag, 151},
+	{"libfuzzerTraceConstCmp2", funcTag, 152},
+	{"libfuzzerTraceConstCmp4", funcTag, 153},
+	{"libfuzzerTraceConstCmp8", funcTag, 154},
+	{"libfuzzerHookStrCmp", funcTag, 155},
+	{"libfuzzerHookEqualFold", funcTag, 155},
+	{"addCovMeta", funcTag, 157},
 	{"x86HasPOPCNT", varTag, 6},
 	{"x86HasSSE41", varTag, 6},
 	{"x86HasFMA", varTag, 6},
@@ -243,11 +243,11 @@ var runtimeDecls = [...]struct {
 	{"loong64HasLAM_BH", varTag, 6},
 	{"loong64HasLSX", varTag, 6},
 	{"riscv64HasZbb", varTag, 6},
-	{"asanregisterglobals", funcTag, 130},
+	{"asanregisterglobals", funcTag, 127},
 }
 
 func runtimeTypes() []*types.Type {
-	var typs [161]*types.Type
+	var typs [158]*types.Type
 	typs[0] = types.ByteType
 	typs[1] = types.NewPtr(typs[0])
 	typs[2] = types.Types[types.TANY]
@@ -260,155 +260,152 @@ func runtimeTypes() []*types.Type {
 	typs[9] = newSig(nil, nil)
 	typs[10] = types.Types[types.TINTER]
 	typs[11] = newSig(params(typs[10]), nil)
-	typs[12] = types.Types[types.TINT32]
-	typs[13] = types.NewPtr(typs[12])
-	typs[14] = newSig(params(typs[13]), params(typs[10]))
-	typs[15] = types.Types[types.TINT]
-	typs[16] = newSig(params(typs[15], typs[15]), nil)
-	typs[17] = types.Types[types.TUINT]
-	typs[18] = newSig(params(typs[17], typs[15]), nil)
-	typs[19] = newSig(params(typs[6]), nil)
-	typs[20] = types.Types[types.TFLOAT64]
+	typs[12] = newSig(nil, params(typs[10]))
+	typs[13] = types.Types[types.TINT]
+	typs[14] = newSig(params(typs[13], typs[13]), nil)
+	typs[15] = types.Types[types.TUINT]
+	typs[16] = newSig(params(typs[15], typs[13]), nil)
+	typs[17] = newSig(params(typs[6]), nil)
+	typs[18] = types.Types[types.TFLOAT64]
+	typs[19] = newSig(params(typs[18]), nil)
+	typs[20] = types.Types[types.TINT64]
 	typs[21] = newSig(params(typs[20]), nil)
-	typs[22] = types.Types[types.TINT64]
+	typs[22] = types.Types[types.TUINT64]
 	typs[23] = newSig(params(typs[22]), nil)
-	typs[24] = types.Types[types.TUINT64]
+	typs[24] = types.Types[types.TCOMPLEX128]
 	typs[25] = newSig(params(typs[24]), nil)
-	typs[26] = types.Types[types.TCOMPLEX128]
+	typs[26] = types.Types[types.TSTRING]
 	typs[27] = newSig(params(typs[26]), nil)
-	typs[28] = types.Types[types.TSTRING]
-	typs[29] = newSig(params(typs[28]), nil)
-	typs[30] = newSig(params(typs[2]), nil)
-	typs[31] = newSig(params(typs[5]), nil)
-	typs[32] = types.NewArray(typs[0], 32)
-	typs[33] = types.NewPtr(typs[32])
-	typs[34] = newSig(params(typs[33], typs[28], typs[28]), params(typs[28]))
-	typs[35] = newSig(params(typs[33], typs[28], typs[28], typs[28]), params(typs[28]))
-	typs[36] = newSig(params(typs[33], typs[28], typs[28], typs[28], typs[28]), params(typs[28]))
-	typs[37] = newSig(params(typs[33], typs[28], typs[28], typs[28], typs[28], typs[28]), params(typs[28]))
-	typs[38] = types.NewSlice(typs[28])
-	typs[39] = newSig(params(typs[33], typs[38]), params(typs[28]))
-	typs[40] = types.NewSlice(typs[0])
-	typs[41] = newSig(params(typs[33], typs[28], typs[28]), params(typs[40]))
-	typs[42] = newSig(params(typs[33], typs[28], typs[28], typs[28]), params(typs[40]))
-	typs[43] = newSig(params(typs[33], typs[28], typs[28], typs[28], typs[28]), params(typs[40]))
-	typs[44] = newSig(params(typs[33], typs[28], typs[28], typs[28], typs[28], typs[28]), params(typs[40]))
-	typs[45] = newSig(params(typs[33], typs[38]), params(typs[40]))
-	typs[46] = newSig(params(typs[28], typs[28]), params(typs[15]))
-	typs[47] = types.NewArray(typs[0], 4)
-	typs[48] = types.NewPtr(typs[47])
-	typs[49] = newSig(params(typs[48], typs[22]), params(typs[28]))
-	typs[50] = newSig(params(typs[33], typs[1], typs[15]), params(typs[28]))
-	typs[51] = newSig(params(typs[1], typs[15]), params(typs[28]))
-	typs[52] = types.RuneType
-	typs[53] = types.NewSlice(typs[52])
-	typs[54] = newSig(params(typs[33], typs[53]), params(typs[28]))
-	typs[55] = newSig(params(typs[33], typs[28]), params(typs[40]))
-	typs[56] = types.NewArray(typs[52], 32)
-	typs[57] = types.NewPtr(typs[56])
-	typs[58] = newSig(params(typs[57], typs[28]), params(typs[53]))
-	typs[59] = newSig(params(typs[3], typs[15], typs[3], typs[15], typs[5]), params(typs[15]))
-	typs[60] = newSig(params(typs[28], typs[15]), params(typs[52], typs[15]))
-	typs[61] = newSig(params(typs[28]), params(typs[15]))
-	typs[62] = newSig(params(typs[1], typs[3]), params(typs[7]))
-	typs[63] = types.Types[types.TUINT16]
+	typs[28] = newSig(params(typs[2]), nil)
+	typs[29] = newSig(params(typs[5]), nil)
+	typs[30] = types.NewArray(typs[0], 32)
+	typs[31] = types.NewPtr(typs[30])
+	typs[32] = newSig(params(typs[31], typs[26], typs[26]), params(typs[26]))
+	typs[33] = newSig(params(typs[31], typs[26], typs[26], typs[26]), params(typs[26]))
+	typs[34] = newSig(params(typs[31], typs[26], typs[26], typs[26], typs[26]), params(typs[26]))
+	typs[35] = newSig(params(typs[31], typs[26], typs[26], typs[26], typs[26], typs[26]), params(typs[26]))
+	typs[36] = types.NewSlice(typs[26])
+	typs[37] = newSig(params(typs[31], typs[36]), params(typs[26]))
+	typs[38] = types.NewSlice(typs[0])
+	typs[39] = newSig(params(typs[31], typs[26], typs[26]), params(typs[38]))
+	typs[40] = newSig(params(typs[31], typs[26], typs[26], typs[26]), params(typs[38]))
+	typs[41] = newSig(params(typs[31], typs[26], typs[26], typs[26], typs[26]), params(typs[38]))
+	typs[42] = newSig(params(typs[31], typs[26], typs[26], typs[26], typs[26], typs[26]), params(typs[38]))
+	typs[43] = newSig(params(typs[31], typs[36]), params(typs[38]))
+	typs[44] = newSig(params(typs[26], typs[26]), params(typs[13]))
+	typs[45] = types.NewArray(typs[0], 4)
+	typs[46] = types.NewPtr(typs[45])
+	typs[47] = newSig(params(typs[46], typs[20]), params(typs[26]))
+	typs[48] = newSig(params(typs[31], typs[1], typs[13]), params(typs[26]))
+	typs[49] = newSig(params(typs[1], typs[13]), params(typs[26]))
+	typs[50] = types.RuneType
+	typs[51] = types.NewSlice(typs[50])
+	typs[52] = newSig(params(typs[31], typs[51]), params(typs[26]))
+	typs[53] = newSig(params(typs[31], typs[26]), params(typs[38]))
+	typs[54] = types.NewArray(typs[50], 32)
+	typs[55] = types.NewPtr(typs[54])
+	typs[56] = newSig(params(typs[55], typs[26]), params(typs[51]))
+	typs[57] = newSig(params(typs[3], typs[13], typs[3], typs[13], typs[5]), params(typs[13]))
+	typs[58] = newSig(params(typs[26], typs[13]), params(typs[50], typs[13]))
+	typs[59] = newSig(params(typs[26]), params(typs[13]))
+	typs[60] = newSig(params(typs[1], typs[3]), params(typs[7]))
+	typs[61] = types.Types[types.TUINT16]
+	typs[62] = newSig(params(typs[61]), params(typs[7]))
+	typs[63] = types.Types[types.TUINT32]
 	typs[64] = newSig(params(typs[63]), params(typs[7]))
-	typs[65] = types.Types[types.TUINT32]
-	typs[66] = newSig(params(typs[65]), params(typs[7]))
-	typs[67] = newSig(params(typs[24]), params(typs[7]))
-	typs[68] = newSig(params(typs[28]), params(typs[7]))
-	typs[69] = types.Types[types.TUINT8]
-	typs[70] = types.NewSlice(typs[69])
-	typs[71] = newSig(params(typs[70]), params(typs[7]))
-	typs[72] = newSig(params(typs[1], typs[1]), params(typs[1]))
-	typs[73] = newSig(params(typs[1], typs[1], typs[1]), nil)
-	typs[74] = newSig(params(typs[1]), nil)
-	typs[75] = newSig(params(typs[1], typs[1]), params(typs[15], typs[1]))
-	typs[76] = types.NewPtr(typs[5])
-	typs[77] = newSig(params(typs[76], typs[7], typs[7]), params(typs[6]))
-	typs[78] = newSig(params(typs[15]), nil)
-	typs[79] = newSig(nil, params(typs[10]))
-	typs[80] = newSig(nil, params(typs[24]))
-	typs[81] = newSig(nil, params(typs[65]))
-	typs[82] = types.NewMap(typs[2], typs[2])
-	typs[83] = newSig(params(typs[1], typs[22], typs[3]), params(typs[82]))
-	typs[84] = newSig(params(typs[1], typs[15], typs[3]), params(typs[82]))
-	typs[85] = newSig(nil, params(typs[82]))
-	typs[86] = newSig(params(typs[1], typs[82], typs[3]), params(typs[3]))
-	typs[87] = newSig(params(typs[1], typs[82], typs[65]), params(typs[3]))
-	typs[88] = newSig(params(typs[1], typs[82], typs[24]), params(typs[3]))
-	typs[89] = newSig(params(typs[1], typs[82], typs[28]), params(typs[3]))
-	typs[90] = newSig(params(typs[1], typs[82], typs[3], typs[1]), params(typs[3]))
-	typs[91] = newSig(params(typs[1], typs[82], typs[3]), params(typs[3], typs[6]))
-	typs[92] = newSig(params(typs[1], typs[82], typs[65]), params(typs[3], typs[6]))
-	typs[93] = newSig(params(typs[1], typs[82], typs[24]), params(typs[3], typs[6]))
-	typs[94] = newSig(params(typs[1], typs[82], typs[28]), params(typs[3], typs[6]))
-	typs[95] = newSig(params(typs[1], typs[82], typs[3], typs[1]), params(typs[3], typs[6]))
-	typs[96] = newSig(params(typs[1], typs[82], typs[7]), params(typs[3]))
-	typs[97] = newSig(params(typs[1], typs[82], typs[3]), nil)
-	typs[98] = newSig(params(typs[1], typs[82], typs[65]), nil)
-	typs[99] = newSig(params(typs[1], typs[82], typs[24]), nil)
-	typs[100] = newSig(params(typs[1], typs[82], typs[28]), nil)
-	typs[101] = newSig(params(typs[3]), nil)
-	typs[102] = newSig(params(typs[1], typs[82]), nil)
-	typs[103] = types.NewChan(typs[2], types.Cboth)
-	typs[104] = newSig(params(typs[1], typs[22]), params(typs[103]))
-	typs[105] = newSig(params(typs[1], typs[15]), params(typs[103]))
-	typs[106] = types.NewChan(typs[2], types.Crecv)
+	typs[65] = newSig(params(typs[22]), params(typs[7]))
+	typs[66] = newSig(params(typs[26]), params(typs[7]))
+	typs[67] = types.Types[types.TUINT8]
+	typs[68] = types.NewSlice(typs[67])
+	typs[69] = newSig(params(typs[68]), params(typs[7]))
+	typs[70] = newSig(params(typs[1], typs[1]), params(typs[1]))
+	typs[71] = newSig(params(typs[1], typs[1], typs[1]), nil)
+	typs[72] = newSig(params(typs[1]), nil)
+	typs[73] = newSig(params(typs[1], typs[1]), params(typs[13], typs[1]))
+	typs[74] = types.NewPtr(typs[5])
+	typs[75] = newSig(params(typs[74], typs[7], typs[7]), params(typs[6]))
+	typs[76] = newSig(params(typs[13]), nil)
+	typs[77] = newSig(nil, params(typs[22]))
+	typs[78] = newSig(nil, params(typs[63]))
+	typs[79] = types.NewMap(typs[2], typs[2])
+	typs[80] = newSig(params(typs[1], typs[20], typs[3]), params(typs[79]))
+	typs[81] = newSig(params(typs[1], typs[13], typs[3]), params(typs[79]))
+	typs[82] = newSig(nil, params(typs[79]))
+	typs[83] = newSig(params(typs[1], typs[79], typs[3]), params(typs[3]))
+	typs[84] = newSig(params(typs[1], typs[79], typs[63]), params(typs[3]))
+	typs[85] = newSig(params(typs[1], typs[79], typs[22]), params(typs[3]))
+	typs[86] = newSig(params(typs[1], typs[79], typs[26]), params(typs[3]))
+	typs[87] = newSig(params(typs[1], typs[79], typs[3], typs[1]), params(typs[3]))
+	typs[88] = newSig(params(typs[1], typs[79], typs[3]), params(typs[3], typs[6]))
+	typs[89] = newSig(params(typs[1], typs[79], typs[63]), params(typs[3], typs[6]))
+	typs[90] = newSig(params(typs[1], typs[79], typs[22]), params(typs[3], typs[6]))
+	typs[91] = newSig(params(typs[1], typs[79], typs[26]), params(typs[3], typs[6]))
+	typs[92] = newSig(params(typs[1], typs[79], typs[3], typs[1]), params(typs[3], typs[6]))
+	typs[93] = newSig(params(typs[1], typs[79], typs[7]), params(typs[3]))
+	typs[94] = newSig(params(typs[1], typs[79], typs[3]), nil)
+	typs[95] = newSig(params(typs[1], typs[79], typs[63]), nil)
+	typs[96] = newSig(params(typs[1], typs[79], typs[22]), nil)
+	typs[97] = newSig(params(typs[1], typs[79], typs[26]), nil)
+	typs[98] = newSig(params(typs[3]), nil)
+	typs[99] = newSig(params(typs[1], typs[79]), nil)
+	typs[100] = types.NewChan(typs[2], types.Cboth)
+	typs[101] = newSig(params(typs[1], typs[20]), params(typs[100]))
+	typs[102] = newSig(params(typs[1], typs[13]), params(typs[100]))
+	typs[103] = types.NewChan(typs[2], types.Crecv)
+	typs[104] = newSig(params(typs[103], typs[3]), nil)
+	typs[105] = newSig(params(typs[103], typs[3]), params(typs[6]))
+	typs[106] = types.NewChan(typs[2], types.Csend)
 	typs[107] = newSig(params(typs[106], typs[3]), nil)
-	typs[108] = newSig(params(typs[106], typs[3]), params(typs[6]))
-	typs[109] = types.NewChan(typs[2], types.Csend)
-	typs[110] = newSig(params(typs[109], typs[3]), nil)
-	typs[111] = newSig(params(typs[109]), nil)
-	typs[112] = newSig(params(typs[2]), params(typs[15]))
-	typs[113] = types.NewArray(typs[0], 3)
-	typs[114] = types.NewStruct([]*types.Field{types.NewField(src.NoXPos, Lookup("enabled"), typs[6]), types.NewField(src.NoXPos, Lookup("pad"), typs[113]), types.NewField(src.NoXPos, Lookup("cgo"), typs[6]), types.NewField(src.NoXPos, Lookup("alignme"), typs[24])})
-	typs[115] = newSig(params(typs[1], typs[3], typs[3]), nil)
-	typs[116] = newSig(params(typs[1], typs[3]), nil)
-	typs[117] = newSig(params(typs[1], typs[3], typs[15], typs[3], typs[15]), params(typs[15]))
-	typs[118] = newSig(params(typs[109], typs[3]), params(typs[6]))
-	typs[119] = newSig(params(typs[3], typs[106]), params(typs[6], typs[6]))
-	typs[120] = newSig(params(typs[76]), nil)
-	typs[121] = newSig(params(typs[1], typs[1], typs[76], typs[15], typs[15], typs[6]), params(typs[15], typs[6]))
-	typs[122] = newSig(params(typs[1], typs[15], typs[15]), params(typs[7]))
-	typs[123] = newSig(params(typs[1], typs[22], typs[22]), params(typs[7]))
-	typs[124] = newSig(params(typs[1], typs[15], typs[15], typs[7]), params(typs[7]))
-	typs[125] = types.NewSlice(typs[2])
-	typs[126] = newSig(params(typs[3], typs[15], typs[15], typs[15], typs[1]), params(typs[125]))
-	typs[127] = newSig(params(typs[1], typs[7], typs[22]), nil)
-	typs[128] = newSig(params(typs[7], typs[22]), nil)
-	typs[129] = newSig(params(typs[3], typs[3], typs[5]), nil)
-	typs[130] = newSig(params(typs[7], typs[5]), nil)
-	typs[131] = newSig(params(typs[3], typs[3], typs[5]), params(typs[6]))
-	typs[132] = newSig(params(typs[3], typs[3]), params(typs[6]))
-	typs[133] = newSig(params(typs[7], typs[7]), params(typs[6]))
-	typs[134] = newSig(params(typs[3], typs[5], typs[5]), params(typs[5]))
-	typs[135] = newSig(params(typs[7], typs[5]), params(typs[5]))
-	typs[136] = newSig(params(typs[3], typs[5]), params(typs[5]))
-	typs[137] = newSig(params(typs[22], typs[22]), params(typs[22]))
-	typs[138] = newSig(params(typs[24], typs[24]), params(typs[24]))
-	typs[139] = newSig(params(typs[20]), params(typs[22]))
-	typs[140] = newSig(params(typs[20]), params(typs[24]))
-	typs[141] = newSig(params(typs[20]), params(typs[65]))
-	typs[142] = newSig(params(typs[22]), params(typs[20]))
-	typs[143] = types.Types[types.TFLOAT32]
-	typs[144] = newSig(params(typs[22]), params(typs[143]))
-	typs[145] = newSig(params(typs[24]), params(typs[20]))
-	typs[146] = newSig(params(typs[24]), params(typs[143]))
-	typs[147] = newSig(params(typs[65]), params(typs[20]))
-	typs[148] = newSig(params(typs[26], typs[26]), params(typs[26]))
-	typs[149] = newSig(params(typs[5], typs[5]), nil)
-	typs[150] = newSig(params(typs[5], typs[5], typs[5]), nil)
-	typs[151] = newSig(params(typs[7], typs[1], typs[5]), nil)
-	typs[152] = types.NewSlice(typs[7])
-	typs[153] = newSig(params(typs[7], typs[152]), nil)
-	typs[154] = newSig(params(typs[69], typs[69], typs[17]), nil)
-	typs[155] = newSig(params(typs[63], typs[63], typs[17]), nil)
-	typs[156] = newSig(params(typs[65], typs[65], typs[17]), nil)
-	typs[157] = newSig(params(typs[24], typs[24], typs[17]), nil)
-	typs[158] = newSig(params(typs[28], typs[28], typs[17]), nil)
-	typs[159] = types.NewArray(typs[0], 16)
-	typs[160] = newSig(params(typs[7], typs[65], typs[159], typs[28], typs[15], typs[69], typs[69]), params(typs[65]))
+	typs[108] = newSig(params(typs[106]), nil)
+	typs[109] = newSig(params(typs[2]), params(typs[13]))
+	typs[110] = types.NewArray(typs[0], 3)
+	typs[111] = types.NewStruct([]*types.Field{types.NewField(src.NoXPos, Lookup("enabled"), typs[6]), types.NewField(src.NoXPos, Lookup("pad"), typs[110]), types.NewField(src.NoXPos, Lookup("cgo"), typs[6]), types.NewField(src.NoXPos, Lookup("alignme"), typs[22])})
+	typs[112] = newSig(params(typs[1], typs[3], typs[3]), nil)
+	typs[113] = newSig(params(typs[1], typs[3]), nil)
+	typs[114] = newSig(params(typs[1], typs[3], typs[13], typs[3], typs[13]), params(typs[13]))
+	typs[115] = newSig(params(typs[106], typs[3]), params(typs[6]))
+	typs[116] = newSig(params(typs[3], typs[103]), params(typs[6], typs[6]))
+	typs[117] = newSig(params(typs[74]), nil)
+	typs[118] = newSig(params(typs[1], typs[1], typs[74], typs[13], typs[13], typs[6]), params(typs[13], typs[6]))
+	typs[119] = newSig(params(typs[1], typs[13], typs[13]), params(typs[7]))
+	typs[120] = newSig(params(typs[1], typs[20], typs[20]), params(typs[7]))
+	typs[121] = newSig(params(typs[1], typs[13], typs[13], typs[7]), params(typs[7]))
+	typs[122] = types.NewSlice(typs[2])
+	typs[123] = newSig(params(typs[3], typs[13], typs[13], typs[13], typs[1]), params(typs[122]))
+	typs[124] = newSig(params(typs[1], typs[7], typs[20]), nil)
+	typs[125] = newSig(params(typs[7], typs[20]), nil)
+	typs[126] = newSig(params(typs[3], typs[3], typs[5]), nil)
+	typs[127] = newSig(params(typs[7], typs[5]), nil)
+	typs[128] = newSig(params(typs[3], typs[3], typs[5]), params(typs[6]))
+	typs[129] = newSig(params(typs[3], typs[3]), params(typs[6]))
+	typs[130] = newSig(params(typs[7], typs[7]), params(typs[6]))
+	typs[131] = newSig(params(typs[3], typs[5], typs[5]), params(typs[5]))
+	typs[132] = newSig(params(typs[7], typs[5]), params(typs[5]))
+	typs[133] = newSig(params(typs[3], typs[5]), params(typs[5]))
+	typs[134] = newSig(params(typs[20], typs[20]), params(typs[20]))
+	typs[135] = newSig(params(typs[22], typs[22]), params(typs[22]))
+	typs[136] = newSig(params(typs[18]), params(typs[20]))
+	typs[137] = newSig(params(typs[18]), params(typs[22]))
+	typs[138] = newSig(params(typs[18]), params(typs[63]))
+	typs[139] = newSig(params(typs[20]), params(typs[18]))
+	typs[140] = types.Types[types.TFLOAT32]
+	typs[141] = newSig(params(typs[20]), params(typs[140]))
+	typs[142] = newSig(params(typs[22]), params(typs[18]))
+	typs[143] = newSig(params(typs[22]), params(typs[140]))
+	typs[144] = newSig(params(typs[63]), params(typs[18]))
+	typs[145] = newSig(params(typs[24], typs[24]), params(typs[24]))
+	typs[146] = newSig(params(typs[5], typs[5]), nil)
+	typs[147] = newSig(params(typs[5], typs[5], typs[5]), nil)
+	typs[148] = newSig(params(typs[7], typs[1], typs[5]), nil)
+	typs[149] = types.NewSlice(typs[7])
+	typs[150] = newSig(params(typs[7], typs[149]), nil)
+	typs[151] = newSig(params(typs[67], typs[67], typs[15]), nil)
+	typs[152] = newSig(params(typs[61], typs[61], typs[15]), nil)
+	typs[153] = newSig(params(typs[63], typs[63], typs[15]), nil)
+	typs[154] = newSig(params(typs[22], typs[22], typs[15]), nil)
+	typs[155] = newSig(params(typs[26], typs[26], typs[15]), nil)
+	typs[156] = types.NewArray(typs[0], 16)
+	typs[157] = newSig(params(typs[7], typs[63], typs[156], typs[26], typs[13], typs[67], typs[67]), params(typs[63]))
 	return typs[:]
 }
 
diff --git a/src/cmd/compile/internal/typecheck/const.go b/src/cmd/compile/internal/typecheck/const.go
index fc6e799e74..6a664156af 100644
--- a/src/cmd/compile/internal/typecheck/const.go
+++ b/src/cmd/compile/internal/typecheck/const.go
@@ -455,7 +455,6 @@ func callOrChan(n ir.Node) bool {
 		ir.OPRINTLN,
 		ir.OREAL,
 		ir.ORECOVER,
-		ir.ORECOVERFP,
 		ir.ORECV,
 		ir.OUNSAFEADD,
 		ir.OUNSAFESLICE,
diff --git a/src/cmd/compile/internal/typecheck/func.go b/src/cmd/compile/internal/typecheck/func.go
index 02e59fa360..5765731546 100644
--- a/src/cmd/compile/internal/typecheck/func.go
+++ b/src/cmd/compile/internal/typecheck/func.go
@@ -758,17 +758,7 @@ func tcRecover(n *ir.CallExpr) ir.Node {
 		return n
 	}
 
-	// FP is equal to caller's SP plus FixedFrameSize.
-	var fp ir.Node = ir.NewCallExpr(n.Pos(), ir.OGETCALLERSP, nil, nil)
-	if off := base.Ctxt.Arch.FixedFrameSize; off != 0 {
-		fp = ir.NewBinaryExpr(n.Pos(), ir.OADD, fp, ir.NewInt(base.Pos, off))
-	}
-	// TODO(mdempsky): Replace *int32 with unsafe.Pointer, without upsetting checkptr.
-	fp = ir.NewConvExpr(n.Pos(), ir.OCONVNOP, types.NewPtr(types.Types[types.TINT32]), fp)
-
-	n.SetOp(ir.ORECOVERFP)
 	n.SetType(types.Types[types.TINTER])
-	n.Args = []ir.Node{Expr(fp)}
 	return n
 }
 
diff --git a/src/cmd/compile/internal/typecheck/stmt.go b/src/cmd/compile/internal/typecheck/stmt.go
index 8d792485d8..ac49f251bb 100644
--- a/src/cmd/compile/internal/typecheck/stmt.go
+++ b/src/cmd/compile/internal/typecheck/stmt.go
@@ -319,7 +319,7 @@ func normalizeGoDeferCall(pos src.XPos, op ir.Op, call ir.Node, init *ir.Nodes)
 		argps = append(argps, &call.Fun.(*ir.SelectorExpr).X) // must be first for OCHECKNIL; see below
 		visitList(call.Args)
 
-	case ir.OAPPEND, ir.ODELETE, ir.OPRINT, ir.OPRINTLN, ir.ORECOVERFP:
+	case ir.OAPPEND, ir.ODELETE, ir.OPRINT, ir.OPRINTLN, ir.ORECOVER:
 		call := call.(*ir.CallExpr)
 		visitList(call.Args)
 		visit(&call.RType)
diff --git a/src/cmd/compile/internal/walk/builtin.go b/src/cmd/compile/internal/walk/builtin.go
index 84e7436103..3b5985d130 100644
--- a/src/cmd/compile/internal/walk/builtin.go
+++ b/src/cmd/compile/internal/walk/builtin.go
@@ -860,9 +860,9 @@ func walkPrint(nn *ir.CallExpr, init *ir.Nodes) ir.Node {
 	return walkStmt(typecheck.Stmt(r))
 }
 
-// walkRecoverFP walks an ORECOVERFP node.
-func walkRecoverFP(nn *ir.CallExpr, init *ir.Nodes) ir.Node {
-	return mkcall("gorecover", nn.Type(), init, walkExpr(nn.Args[0], init))
+// walkRecover walks an ORECOVER node.
+func walkRecover(nn *ir.CallExpr, init *ir.Nodes) ir.Node {
+	return mkcall("gorecover", nn.Type(), init)
 }
 
 // walkUnsafeData walks an OUNSAFESLICEDATA or OUNSAFESTRINGDATA expression.
diff --git a/src/cmd/compile/internal/walk/expr.go b/src/cmd/compile/internal/walk/expr.go
index 6775bc4fc8..fbfc56a39c 100644
--- a/src/cmd/compile/internal/walk/expr.go
+++ b/src/cmd/compile/internal/walk/expr.go
@@ -182,8 +182,8 @@ func walkExpr1(n ir.Node, init *ir.Nodes) ir.Node {
 		n := n.(*ir.UnaryExpr)
 		return mkcall("gopanic", nil, init, n.X)
 
-	case ir.ORECOVERFP:
-		return walkRecoverFP(n.(*ir.CallExpr), init)
+	case ir.ORECOVER:
+		return walkRecover(n.(*ir.CallExpr), init)
 
 	case ir.OCFUNC:
 		return n
diff --git a/src/cmd/compile/internal/walk/order.go b/src/cmd/compile/internal/walk/order.go
index cb022faddf..daa7f92617 100644
--- a/src/cmd/compile/internal/walk/order.go
+++ b/src/cmd/compile/internal/walk/order.go
@@ -846,7 +846,7 @@ func (o *orderState) stmt(n ir.Node) {
 		o.out = append(o.out, n)
 		o.popTemp(t)
 
-	case ir.OPRINT, ir.OPRINTLN, ir.ORECOVERFP:
+	case ir.OPRINT, ir.OPRINTLN, ir.ORECOVER:
 		n := n.(*ir.CallExpr)
 		t := o.markTemp()
 		o.call(n)
@@ -1355,7 +1355,7 @@ func (o *orderState) expr1(n, lhs ir.Node) ir.Node {
 		ir.OMIN,
 		ir.ONEW,
 		ir.OREAL,
-		ir.ORECOVERFP,
+		ir.ORECOVER,
 		ir.OSTR2BYTES,
 		ir.OSTR2BYTESTMP,
 		ir.OSTR2RUNES:
diff --git a/src/cmd/compile/internal/walk/stmt.go b/src/cmd/compile/internal/walk/stmt.go
index b2a226e078..2c01fd10f1 100644
--- a/src/cmd/compile/internal/walk/stmt.go
+++ b/src/cmd/compile/internal/walk/stmt.go
@@ -50,7 +50,7 @@ func walkStmt(n ir.Node) ir.Node {
 		ir.OPRINT,
 		ir.OPRINTLN,
 		ir.OPANIC,
-		ir.ORECOVERFP,
+		ir.ORECOVER,
 		ir.OGETG:
 		if n.Typecheck() == 0 {
 			base.Fatalf("missing typecheck: %+v", n)
diff --git a/src/runtime/panic.go b/src/runtime/panic.go
index bf79b6518e..8f9ab4dd47 100644
--- a/src/runtime/panic.go
+++ b/src/runtime/panic.go
@@ -1083,7 +1083,7 @@ func (p *_panic) initOpenCodedDefers(fn funcInfo, varp unsafe.Pointer) bool {
 }
 
 // The implementation of the predeclared function recover.
-func gorecover(_ uintptr) any {
+func gorecover() any {
 	gp := getg()
 	p := gp._panic
 	if p == nil || p.goexit || p.recovered {