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>

diff --git a/src/cmd/compile/internal/escape/call.go b/src/cmd/compile/internal/escape/call.go
index 58c44eb9bbd3ceb1bdb42479c772881c3d71dc20..f9351de975fdabdca240c515dce38d9ad73b705a 100644 (file)
--- 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 f479a2913a3f8090b8d37d921e3ef06998304b2a..1521c2edd176054253b8ea7dcaf0256b25feb5ef 100644 (file)
--- 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 b766864a306f8297d7612555da3a29c6cda37da5..2388873caf7bf5a147751ba0d83d342f553eefdf 100644 (file)
--- 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 459c2498fc40da55b62f7f50829c444812552103..c06f76fe9ff029158ef84a102b61f297a7a71557 100644 (file)
--- 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 d86fd7d71b969aab742fbb7c939e8108da241e57..22312e2241ff6d0c818814ceed23f5100873c3df 100644 (file)
--- 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 98b353147f749ff67d9b6386541dc74f89beb9e0..9d34f27ce533631f581b1ed561c076c4c9433943 100644 (file)
--- 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 058ada5ac3f185e4ed2d0a3aefe0a638cb9dc270..003ec15de129e180d9713d3966eac5e7df001918 100644 (file)
--- 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 a1806d1349d6155664ab591d25ba5b2e8103350d..7494beee4c58e082a9e5ca5b65c6dbe927b43186 100644 (file)
--- 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 a1397b32b352412e9eeeaaf5b6de5f1be19e8db3..628c7e2fbc560a3ba9ae65b431b0a9c45623ae86 100644 (file)
--- 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 f3ab6766ec8b2be86fb769e5efd0d727e26a6c01..730ed4146a75adc878fe628edeb25bf30865925c 100644 (file)
--- 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 fc6e799e747bb2640225a55f9972f43e6c933d66..6a664156af2649f43ed71fd7a4efde5e4ca253b3 100644 (file)
--- 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 02e59fa360451d06731f932533b3b49bfc9c9adc..57657315467abfcad370e7ef007e2ff9778d4bd0 100644 (file)
--- 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 8d792485d863c401d98b279449a763415b46e96c..ac49f251bb93a4247a89b9e8efe9f65c39c4034e 100644 (file)
--- 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 84e7436103ecb9054e4c6a99e49820ac3a9d470f..3b5985d1303664f717bac8fe7bc16002f580314b 100644 (file)
--- 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 6775bc4fc8d276806a74171a2d0a7b51709594e7..fbfc56a39c307139b907596f81e047fb13d9e189 100644 (file)
--- 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 cb022faddf29e3d1f7dc32e479fba7e0654dfa27..daa7f92617df35af04b5d8bb286dd573f0fa83f1 100644 (file)
--- 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 b2a226e0789fbb27e88aea93af69440398034e3c..2c01fd10f124e569d2218714b0d36629de51603a 100644 (file)
--- 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 bf79b6518e88c39e6b75eeffd7945e98bfec876a..8f9ab4dd47345b95deedb244611bde53e542fe50 100644 (file)
--- 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 {