Stowage/go
2
0
Fork 0
mirror of https://github.com/golang/go.git synced 2026-02-07 02:09:55 +00:00
Code Issues Projects Releases Packages Wiki Activity

cmd/compile: remove unused arg from gorecover

Browse source 
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>
This commit is contained in:
Keith Randall 2025-07-02 10:00:42 -07:00
parent 08376e1a9c
commit aeb256e98a
18 changed files with 398 additions and 417 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/cmd/compile/internal/escape/call.go
View file

@ -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)

2
src/cmd/compile/internal/escape/expr.go
View file

@ -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)

2
src/cmd/compile/internal/escape/stmt.go
View file

@ -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)

5
src/cmd/compile/internal/inline/inl.go
View file

@ -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

2
src/cmd/compile/internal/inline/inlheur/analyze_func_flags.go
View file

@ -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.

2
src/cmd/compile/internal/ir/expr.go
View file

@ -213,7 +213,7 @@ func (n *CallExpr) SetOp(op Op) {
ODELETE,
OGETG, OGETCALLERSP,
OMAKE, OMAX, OMIN, OPRINT, OPRINTLN,
ORECOVER, ORECOVERFP:
ORECOVER:
n.op = op
}
}

1
src/cmd/compile/internal/ir/node.go
View file

@ -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)

105
src/cmd/compile/internal/ir/op_string.go
View file

@ -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) {

2
src/cmd/compile/internal/typecheck/_builtin/runtime.go
View file

@ -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.

661
src/cmd/compile/internal/typecheck/builtin.go
View file

@ -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[:]
}

1
src/cmd/compile/internal/typecheck/const.go
View file

@ -455,7 +455,6 @@ func callOrChan(n ir.Node) bool {
ir.OPRINTLN,
ir.OREAL,
ir.ORECOVER,
ir.ORECOVERFP,
ir.ORECV,
ir.OUNSAFEADD,
ir.OUNSAFESLICE,

10
src/cmd/compile/internal/typecheck/func.go
View file

@ -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
}

2
src/cmd/compile/internal/typecheck/stmt.go
View file

@ -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)

6
src/cmd/compile/internal/walk/builtin.go
View file

@ -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.

4
src/cmd/compile/internal/walk/expr.go
View file

@ -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

4
src/cmd/compile/internal/walk/order.go
View file

@ -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:

2
src/cmd/compile/internal/walk/stmt.go
View file

@ -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)

2
src/runtime/panic.go
View file

@ -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 {