cmd/compile: pass only the itab to the assertI2I-style functions

It is currently slightly better to pass the whole interface to these
functions, so that we don't need to spill/restore the data word across
the function call.

I'm adding a cache in front of these calls, which means we'll no longer
need a spill/restore in the common case, so it is better to just pass
the itab word.

It also makes unifying the logic between I2I and I2I2 versions easier.

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

diff --git a/src/cmd/compile/internal/ssagen/ssa.go b/src/cmd/compile/internal/ssagen/ssa.go
index df6a5357f2e53fe7f8dcbe44f52a65e93fa6d219..56acd05fc240166c8a971b9806630326176c4c6b 100644 (file)
--- a/src/cmd/compile/internal/ssagen/ssa.go
+++ b/src/cmd/compile/internal/ssagen/ssa.go
@@ -6631,23 +6631,26 @@ func (s *state) dottype1(pos src.XPos, src, dst *types.Type, iface, source, targ
                if base.Debug.TypeAssert > 0 {
                        base.WarnfAt(pos, "type assertion not inlined")
                }
-               if !commaok {
-                       fn := ir.Syms.AssertI2I
+               var fn *obj.LSym
+               if commaok {
+                       fn = ir.Syms.AssertI2I2
+                       if src.IsEmptyInterface() {
+                               fn = ir.Syms.AssertE2I2
+                       }
+               } else {
+                       fn = ir.Syms.AssertI2I
                        if src.IsEmptyInterface() {
                                fn = ir.Syms.AssertE2I
                        }
-                       data := s.newValue1(ssa.OpIData, types.Types[types.TUNSAFEPTR], iface)
-                       tab := s.newValue1(ssa.OpITab, byteptr, iface)
-                       tab = s.rtcall(fn, true, []*types.Type{byteptr}, target, tab)[0]
-                       return s.newValue2(ssa.OpIMake, dst, tab, data), nil
                }
-               fn := ir.Syms.AssertI2I2
-               if src.IsEmptyInterface() {
-                       fn = ir.Syms.AssertE2I2
+               data := s.newValue1(ssa.OpIData, types.Types[types.TUNSAFEPTR], iface)
+               tab := s.newValue1(ssa.OpITab, byteptr, iface)
+               tab = s.rtcall(fn, true, []*types.Type{byteptr}, target, tab)[0]
+               var ok *ssa.Value
+               if commaok {
+                       ok = s.newValue2(ssa.OpNeqPtr, types.Types[types.TBOOL], tab, s.constNil(byteptr))
                }
-               res = s.rtcall(fn, true, []*types.Type{dst}, target, iface)[0]
-               resok = s.newValue2(ssa.OpNeqInter, types.Types[types.TBOOL], res, s.constInterface(dst))
-               return
+               return s.newValue2(ssa.OpIMake, dst, tab, data), ok
        }
 
        if base.Debug.TypeAssert > 0 {

diff --git a/src/cmd/compile/internal/typecheck/_builtin/runtime.go b/src/cmd/compile/internal/typecheck/_builtin/runtime.go
index 1e68fddaa0b84838375e72833394cd06ae304b55..ead4a8d219db00ea654d423bb0b4a12211980d25 100644 (file)
--- a/src/cmd/compile/internal/typecheck/_builtin/runtime.go
+++ b/src/cmd/compile/internal/typecheck/_builtin/runtime.go
@@ -105,9 +105,9 @@ func convTslice(val []uint8) unsafe.Pointer
 
 // interface type assertions x.(T)
 func assertE2I(inter *byte, typ *byte) *byte
-func assertE2I2(inter *byte, eface any) (ret any)
+func assertE2I2(inter *byte, typ *byte) *byte
 func assertI2I(inter *byte, tab *byte) *byte
-func assertI2I2(inter *byte, iface any) (ret any)
+func assertI2I2(inter *byte, tab *byte) *byte
 func panicdottypeE(have, want, iface *byte)
 func panicdottypeI(have, want, iface *byte)
 func panicnildottype(want *byte)

diff --git a/src/cmd/compile/internal/typecheck/builtin.go b/src/cmd/compile/internal/typecheck/builtin.go
index fb1c3d7cf8211aaec3d0c579bf81068bf3aa12cf..d9efa128dfc63c4751688bd305c1824ebbef6d47 100644 (file)
--- a/src/cmd/compile/internal/typecheck/builtin.go
+++ b/src/cmd/compile/internal/typecheck/builtin.go
@@ -95,148 +95,148 @@ var runtimeDecls = [...]struct {
        {"convTstring", funcTag, 65},
        {"convTslice", funcTag, 68},
        {"assertE2I", funcTag, 69},
-       {"assertE2I2", funcTag, 70},
+       {"assertE2I2", funcTag, 69},
        {"assertI2I", funcTag, 69},
-       {"assertI2I2", funcTag, 70},
-       {"panicdottypeE", funcTag, 71},
-       {"panicdottypeI", funcTag, 71},
-       {"panicnildottype", funcTag, 72},
-       {"interfaceSwitch", funcTag, 73},
-       {"ifaceeq", funcTag, 74},
-       {"efaceeq", funcTag, 74},
-       {"deferrangefunc", funcTag, 75},
-       {"fastrand", funcTag, 76},
-       {"makemap64", funcTag, 78},
-       {"makemap", funcTag, 79},
-       {"makemap_small", funcTag, 80},
-       {"mapaccess1", funcTag, 81},
-       {"mapaccess1_fast32", funcTag, 82},
-       {"mapaccess1_fast64", funcTag, 83},
-       {"mapaccess1_faststr", funcTag, 84},
-       {"mapaccess1_fat", funcTag, 85},
-       {"mapaccess2", funcTag, 86},
-       {"mapaccess2_fast32", funcTag, 87},
-       {"mapaccess2_fast64", funcTag, 88},
-       {"mapaccess2_faststr", funcTag, 89},
-       {"mapaccess2_fat", funcTag, 90},
-       {"mapassign", funcTag, 81},
-       {"mapassign_fast32", funcTag, 82},
-       {"mapassign_fast32ptr", funcTag, 91},
-       {"mapassign_fast64", funcTag, 83},
-       {"mapassign_fast64ptr", funcTag, 91},
-       {"mapassign_faststr", funcTag, 84},
-       {"mapiterinit", funcTag, 92},
-       {"mapdelete", funcTag, 92},
-       {"mapdelete_fast32", funcTag, 93},
-       {"mapdelete_fast64", funcTag, 94},
-       {"mapdelete_faststr", funcTag, 95},
-       {"mapiternext", funcTag, 96},
-       {"mapclear", funcTag, 97},
-       {"makechan64", funcTag, 99},
-       {"makechan", funcTag, 100},
-       {"chanrecv1", funcTag, 102},
-       {"chanrecv2", funcTag, 103},
-       {"chansend1", funcTag, 105},
+       {"assertI2I2", funcTag, 69},
+       {"panicdottypeE", funcTag, 70},
+       {"panicdottypeI", funcTag, 70},
+       {"panicnildottype", funcTag, 71},
+       {"interfaceSwitch", funcTag, 72},
+       {"ifaceeq", funcTag, 73},
+       {"efaceeq", funcTag, 73},
+       {"deferrangefunc", funcTag, 74},
+       {"fastrand", funcTag, 75},
+       {"makemap64", funcTag, 77},
+       {"makemap", funcTag, 78},
+       {"makemap_small", funcTag, 79},
+       {"mapaccess1", funcTag, 80},
+       {"mapaccess1_fast32", funcTag, 81},
+       {"mapaccess1_fast64", funcTag, 82},
+       {"mapaccess1_faststr", funcTag, 83},
+       {"mapaccess1_fat", funcTag, 84},
+       {"mapaccess2", funcTag, 85},
+       {"mapaccess2_fast32", funcTag, 86},
+       {"mapaccess2_fast64", funcTag, 87},
+       {"mapaccess2_faststr", funcTag, 88},
+       {"mapaccess2_fat", funcTag, 89},
+       {"mapassign", funcTag, 80},
+       {"mapassign_fast32", funcTag, 81},
+       {"mapassign_fast32ptr", funcTag, 90},
+       {"mapassign_fast64", funcTag, 82},
+       {"mapassign_fast64ptr", funcTag, 90},
+       {"mapassign_faststr", funcTag, 83},
+       {"mapiterinit", funcTag, 91},
+       {"mapdelete", funcTag, 91},
+       {"mapdelete_fast32", funcTag, 92},
+       {"mapdelete_fast64", funcTag, 93},
+       {"mapdelete_faststr", funcTag, 94},
+       {"mapiternext", funcTag, 95},
+       {"mapclear", funcTag, 96},
+       {"makechan64", funcTag, 98},
+       {"makechan", funcTag, 99},
+       {"chanrecv1", funcTag, 101},
+       {"chanrecv2", funcTag, 102},
+       {"chansend1", funcTag, 104},
        {"closechan", funcTag, 30},
-       {"writeBarrier", varTag, 107},
-       {"typedmemmove", funcTag, 108},
-       {"typedmemclr", funcTag, 109},
-       {"typedslicecopy", funcTag, 110},
-       {"selectnbsend", funcTag, 111},
-       {"selectnbrecv", funcTag, 112},
-       {"selectsetpc", funcTag, 113},
-       {"selectgo", funcTag, 114},
+       {"writeBarrier", varTag, 106},
+       {"typedmemmove", funcTag, 107},
+       {"typedmemclr", funcTag, 108},
+       {"typedslicecopy", funcTag, 109},
+       {"selectnbsend", funcTag, 110},
+       {"selectnbrecv", funcTag, 111},
+       {"selectsetpc", funcTag, 112},
+       {"selectgo", funcTag, 113},
        {"block", funcTag, 9},
-       {"makeslice", funcTag, 115},
-       {"makeslice64", funcTag, 116},
-       {"makeslicecopy", funcTag, 117},
-       {"growslice", funcTag, 119},
-       {"unsafeslicecheckptr", funcTag, 120},
+       {"makeslice", funcTag, 114},
+       {"makeslice64", funcTag, 115},
+       {"makeslicecopy", funcTag, 116},
+       {"growslice", funcTag, 118},
+       {"unsafeslicecheckptr", funcTag, 119},
        {"panicunsafeslicelen", funcTag, 9},
        {"panicunsafeslicenilptr", funcTag, 9},
-       {"unsafestringcheckptr", funcTag, 121},
+       {"unsafestringcheckptr", funcTag, 120},
        {"panicunsafestringlen", funcTag, 9},
        {"panicunsafestringnilptr", funcTag, 9},
-       {"memmove", funcTag, 122},
-       {"memclrNoHeapPointers", funcTag, 123},
-       {"memclrHasPointers", funcTag, 123},
-       {"memequal", funcTag, 124},
-       {"memequal0", funcTag, 125},
-       {"memequal8", funcTag, 125},
-       {"memequal16", funcTag, 125},
-       {"memequal32", funcTag, 125},
-       {"memequal64", funcTag, 125},
-       {"memequal128", funcTag, 125},
-       {"f32equal", funcTag, 126},
-       {"f64equal", funcTag, 126},
-       {"c64equal", funcTag, 126},
-       {"c128equal", funcTag, 126},
-       {"strequal", funcTag, 126},
-       {"interequal", funcTag, 126},
-       {"nilinterequal", funcTag, 126},
-       {"memhash", funcTag, 127},
-       {"memhash0", funcTag, 128},
-       {"memhash8", funcTag, 128},
-       {"memhash16", funcTag, 128},
-       {"memhash32", funcTag, 128},
-       {"memhash64", funcTag, 128},
-       {"memhash128", funcTag, 128},
-       {"f32hash", funcTag, 129},
-       {"f64hash", funcTag, 129},
-       {"c64hash", funcTag, 129},
-       {"c128hash", funcTag, 129},
-       {"strhash", funcTag, 129},
-       {"interhash", funcTag, 129},
-       {"nilinterhash", funcTag, 129},
-       {"int64div", funcTag, 130},
-       {"uint64div", funcTag, 131},
-       {"int64mod", funcTag, 130},
-       {"uint64mod", funcTag, 131},
-       {"float64toint64", funcTag, 132},
-       {"float64touint64", funcTag, 133},
-       {"float64touint32", funcTag, 134},
-       {"int64tofloat64", funcTag, 135},
-       {"int64tofloat32", funcTag, 137},
-       {"uint64tofloat64", funcTag, 138},
-       {"uint64tofloat32", funcTag, 139},
-       {"uint32tofloat64", funcTag, 140},
-       {"complex128div", funcTag, 141},
-       {"getcallerpc", funcTag, 142},
-       {"getcallersp", funcTag, 142},
+       {"memmove", funcTag, 121},
+       {"memclrNoHeapPointers", funcTag, 122},
+       {"memclrHasPointers", funcTag, 122},
+       {"memequal", funcTag, 123},
+       {"memequal0", funcTag, 124},
+       {"memequal8", funcTag, 124},
+       {"memequal16", funcTag, 124},
+       {"memequal32", funcTag, 124},
+       {"memequal64", funcTag, 124},
+       {"memequal128", funcTag, 124},
+       {"f32equal", funcTag, 125},
+       {"f64equal", funcTag, 125},
+       {"c64equal", funcTag, 125},
+       {"c128equal", funcTag, 125},
+       {"strequal", funcTag, 125},
+       {"interequal", funcTag, 125},
+       {"nilinterequal", funcTag, 125},
+       {"memhash", funcTag, 126},
+       {"memhash0", funcTag, 127},
+       {"memhash8", funcTag, 127},
+       {"memhash16", funcTag, 127},
+       {"memhash32", funcTag, 127},
+       {"memhash64", funcTag, 127},
+       {"memhash128", funcTag, 127},
+       {"f32hash", funcTag, 128},
+       {"f64hash", funcTag, 128},
+       {"c64hash", funcTag, 128},
+       {"c128hash", funcTag, 128},
+       {"strhash", funcTag, 128},
+       {"interhash", funcTag, 128},
+       {"nilinterhash", funcTag, 128},
+       {"int64div", funcTag, 129},
+       {"uint64div", funcTag, 130},
+       {"int64mod", funcTag, 129},
+       {"uint64mod", funcTag, 130},
+       {"float64toint64", funcTag, 131},
+       {"float64touint64", funcTag, 132},
+       {"float64touint32", funcTag, 133},
+       {"int64tofloat64", funcTag, 134},
+       {"int64tofloat32", funcTag, 136},
+       {"uint64tofloat64", funcTag, 137},
+       {"uint64tofloat32", funcTag, 138},
+       {"uint32tofloat64", funcTag, 139},
+       {"complex128div", funcTag, 140},
+       {"getcallerpc", funcTag, 141},
+       {"getcallersp", funcTag, 141},
        {"racefuncenter", funcTag, 31},
        {"racefuncexit", funcTag, 9},
        {"raceread", funcTag, 31},
        {"racewrite", funcTag, 31},
-       {"racereadrange", funcTag, 143},
-       {"racewriterange", funcTag, 143},
-       {"msanread", funcTag, 143},
-       {"msanwrite", funcTag, 143},
-       {"msanmove", funcTag, 144},
-       {"asanread", funcTag, 143},
-       {"asanwrite", funcTag, 143},
-       {"checkptrAlignment", funcTag, 145},
-       {"checkptrArithmetic", funcTag, 147},
-       {"libfuzzerTraceCmp1", funcTag, 148},
-       {"libfuzzerTraceCmp2", funcTag, 149},
-       {"libfuzzerTraceCmp4", funcTag, 150},
-       {"libfuzzerTraceCmp8", funcTag, 151},
-       {"libfuzzerTraceConstCmp1", funcTag, 148},
-       {"libfuzzerTraceConstCmp2", funcTag, 149},
-       {"libfuzzerTraceConstCmp4", funcTag, 150},
-       {"libfuzzerTraceConstCmp8", funcTag, 151},
-       {"libfuzzerHookStrCmp", funcTag, 152},
-       {"libfuzzerHookEqualFold", funcTag, 152},
-       {"addCovMeta", funcTag, 154},
+       {"racereadrange", funcTag, 142},
+       {"racewriterange", funcTag, 142},
+       {"msanread", funcTag, 142},
+       {"msanwrite", funcTag, 142},
+       {"msanmove", funcTag, 143},
+       {"asanread", funcTag, 142},
+       {"asanwrite", funcTag, 142},
+       {"checkptrAlignment", funcTag, 144},
+       {"checkptrArithmetic", funcTag, 146},
+       {"libfuzzerTraceCmp1", funcTag, 147},
+       {"libfuzzerTraceCmp2", funcTag, 148},
+       {"libfuzzerTraceCmp4", funcTag, 149},
+       {"libfuzzerTraceCmp8", funcTag, 150},
+       {"libfuzzerTraceConstCmp1", funcTag, 147},
+       {"libfuzzerTraceConstCmp2", funcTag, 148},
+       {"libfuzzerTraceConstCmp4", funcTag, 149},
+       {"libfuzzerTraceConstCmp8", funcTag, 150},
+       {"libfuzzerHookStrCmp", funcTag, 151},
+       {"libfuzzerHookEqualFold", funcTag, 151},
+       {"addCovMeta", funcTag, 153},
        {"x86HasPOPCNT", varTag, 6},
        {"x86HasSSE41", varTag, 6},
        {"x86HasFMA", varTag, 6},
        {"armHasVFPv4", varTag, 6},
        {"arm64HasATOMICS", varTag, 6},
-       {"asanregisterglobals", funcTag, 123},
+       {"asanregisterglobals", funcTag, 122},
 }
 
 func runtimeTypes() []*types.Type {
-       var typs [155]*types.Type
+       var typs [154]*types.Type
        typs[0] = types.ByteType
        typs[1] = types.NewPtr(typs[0])
        typs[2] = types.Types[types.TANY]
@@ -307,91 +307,90 @@ func runtimeTypes() []*types.Type {
        typs[67] = types.NewSlice(typs[66])
        typs[68] = newSig(params(typs[67]), params(typs[7]))
        typs[69] = newSig(params(typs[1], typs[1]), params(typs[1]))
-       typs[70] = newSig(params(typs[1], typs[2]), params(typs[2]))
-       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[15], typs[1]))
-       typs[74] = newSig(params(typs[57], typs[7], typs[7]), params(typs[6]))
-       typs[75] = newSig(nil, params(typs[10]))
-       typs[76] = newSig(nil, params(typs[62]))
-       typs[77] = types.NewMap(typs[2], typs[2])
-       typs[78] = newSig(params(typs[1], typs[22], typs[3]), params(typs[77]))
-       typs[79] = newSig(params(typs[1], typs[15], typs[3]), params(typs[77]))
-       typs[80] = newSig(nil, params(typs[77]))
-       typs[81] = newSig(params(typs[1], typs[77], typs[3]), params(typs[3]))
-       typs[82] = newSig(params(typs[1], typs[77], typs[62]), params(typs[3]))
-       typs[83] = newSig(params(typs[1], typs[77], typs[24]), params(typs[3]))
-       typs[84] = newSig(params(typs[1], typs[77], typs[28]), params(typs[3]))
-       typs[85] = newSig(params(typs[1], typs[77], typs[3], typs[1]), params(typs[3]))
-       typs[86] = newSig(params(typs[1], typs[77], typs[3]), params(typs[3], typs[6]))
-       typs[87] = newSig(params(typs[1], typs[77], typs[62]), params(typs[3], typs[6]))
-       typs[88] = newSig(params(typs[1], typs[77], typs[24]), params(typs[3], typs[6]))
-       typs[89] = newSig(params(typs[1], typs[77], typs[28]), params(typs[3], typs[6]))
-       typs[90] = newSig(params(typs[1], typs[77], typs[3], typs[1]), params(typs[3], typs[6]))
-       typs[91] = newSig(params(typs[1], typs[77], typs[7]), params(typs[3]))
-       typs[92] = newSig(params(typs[1], typs[77], typs[3]), nil)
-       typs[93] = newSig(params(typs[1], typs[77], typs[62]), nil)
-       typs[94] = newSig(params(typs[1], typs[77], typs[24]), nil)
-       typs[95] = newSig(params(typs[1], typs[77], typs[28]), nil)
-       typs[96] = newSig(params(typs[3]), nil)
-       typs[97] = newSig(params(typs[1], typs[77]), nil)
-       typs[98] = types.NewChan(typs[2], types.Cboth)
-       typs[99] = newSig(params(typs[1], typs[22]), params(typs[98]))
-       typs[100] = newSig(params(typs[1], typs[15]), params(typs[98]))
-       typs[101] = types.NewChan(typs[2], types.Crecv)
-       typs[102] = newSig(params(typs[101], typs[3]), nil)
-       typs[103] = newSig(params(typs[101], typs[3]), params(typs[6]))
-       typs[104] = types.NewChan(typs[2], types.Csend)
-       typs[105] = newSig(params(typs[104], typs[3]), nil)
-       typs[106] = types.NewArray(typs[0], 3)
-       typs[107] = types.NewStruct([]*types.Field{types.NewField(src.NoXPos, Lookup("enabled"), typs[6]), types.NewField(src.NoXPos, Lookup("pad"), typs[106]), types.NewField(src.NoXPos, Lookup("needed"), typs[6]), types.NewField(src.NoXPos, Lookup("cgo"), typs[6]), types.NewField(src.NoXPos, Lookup("alignme"), typs[24])})
-       typs[108] = newSig(params(typs[1], typs[3], typs[3]), nil)
-       typs[109] = newSig(params(typs[1], typs[3]), nil)
-       typs[110] = newSig(params(typs[1], typs[3], typs[15], typs[3], typs[15]), params(typs[15]))
-       typs[111] = newSig(params(typs[104], typs[3]), params(typs[6]))
-       typs[112] = newSig(params(typs[3], typs[101]), params(typs[6], typs[6]))
-       typs[113] = newSig(params(typs[57]), nil)
-       typs[114] = newSig(params(typs[1], typs[1], typs[57], typs[15], typs[15], typs[6]), params(typs[15], typs[6]))
-       typs[115] = newSig(params(typs[1], typs[15], typs[15]), params(typs[7]))
-       typs[116] = newSig(params(typs[1], typs[22], typs[22]), params(typs[7]))
-       typs[117] = newSig(params(typs[1], typs[15], typs[15], typs[7]), params(typs[7]))
-       typs[118] = types.NewSlice(typs[2])
-       typs[119] = newSig(params(typs[3], typs[15], typs[15], typs[15], typs[1]), params(typs[118]))
-       typs[120] = newSig(params(typs[1], typs[7], typs[22]), nil)
-       typs[121] = newSig(params(typs[7], typs[22]), nil)
-       typs[122] = newSig(params(typs[3], typs[3], typs[5]), nil)
-       typs[123] = newSig(params(typs[7], typs[5]), nil)
-       typs[124] = newSig(params(typs[3], typs[3], typs[5]), params(typs[6]))
-       typs[125] = newSig(params(typs[3], typs[3]), params(typs[6]))
-       typs[126] = newSig(params(typs[7], typs[7]), params(typs[6]))
-       typs[127] = newSig(params(typs[3], typs[5], typs[5]), params(typs[5]))
-       typs[128] = newSig(params(typs[7], typs[5]), params(typs[5]))
-       typs[129] = newSig(params(typs[3], typs[5]), params(typs[5]))
-       typs[130] = newSig(params(typs[22], typs[22]), params(typs[22]))
-       typs[131] = newSig(params(typs[24], typs[24]), params(typs[24]))
-       typs[132] = newSig(params(typs[20]), params(typs[22]))
-       typs[133] = newSig(params(typs[20]), params(typs[24]))
-       typs[134] = newSig(params(typs[20]), params(typs[62]))
-       typs[135] = newSig(params(typs[22]), params(typs[20]))
-       typs[136] = types.Types[types.TFLOAT32]
-       typs[137] = newSig(params(typs[22]), params(typs[136]))
-       typs[138] = newSig(params(typs[24]), params(typs[20]))
-       typs[139] = newSig(params(typs[24]), params(typs[136]))
-       typs[140] = newSig(params(typs[62]), params(typs[20]))
-       typs[141] = newSig(params(typs[26], typs[26]), params(typs[26]))
-       typs[142] = newSig(nil, params(typs[5]))
-       typs[143] = newSig(params(typs[5], typs[5]), nil)
-       typs[144] = newSig(params(typs[5], typs[5], typs[5]), nil)
-       typs[145] = newSig(params(typs[7], typs[1], typs[5]), nil)
-       typs[146] = types.NewSlice(typs[7])
-       typs[147] = newSig(params(typs[7], typs[146]), nil)
-       typs[148] = newSig(params(typs[66], typs[66], typs[17]), nil)
-       typs[149] = newSig(params(typs[60], typs[60], typs[17]), nil)
-       typs[150] = newSig(params(typs[62], typs[62], typs[17]), nil)
-       typs[151] = newSig(params(typs[24], typs[24], typs[17]), nil)
-       typs[152] = newSig(params(typs[28], typs[28], typs[17]), nil)
-       typs[153] = types.NewArray(typs[0], 16)
-       typs[154] = newSig(params(typs[7], typs[62], typs[153], typs[28], typs[15], typs[66], typs[66]), params(typs[62]))
+       typs[70] = newSig(params(typs[1], typs[1], typs[1]), nil)
+       typs[71] = newSig(params(typs[1]), nil)
+       typs[72] = newSig(params(typs[1], typs[1]), params(typs[15], typs[1]))
+       typs[73] = newSig(params(typs[57], typs[7], typs[7]), params(typs[6]))
+       typs[74] = newSig(nil, params(typs[10]))
+       typs[75] = newSig(nil, params(typs[62]))
+       typs[76] = types.NewMap(typs[2], typs[2])
+       typs[77] = newSig(params(typs[1], typs[22], typs[3]), params(typs[76]))
+       typs[78] = newSig(params(typs[1], typs[15], typs[3]), params(typs[76]))
+       typs[79] = newSig(nil, params(typs[76]))
+       typs[80] = newSig(params(typs[1], typs[76], typs[3]), params(typs[3]))
+       typs[81] = newSig(params(typs[1], typs[76], typs[62]), params(typs[3]))
+       typs[82] = newSig(params(typs[1], typs[76], typs[24]), params(typs[3]))
+       typs[83] = newSig(params(typs[1], typs[76], typs[28]), params(typs[3]))
+       typs[84] = newSig(params(typs[1], typs[76], typs[3], typs[1]), params(typs[3]))
+       typs[85] = newSig(params(typs[1], typs[76], typs[3]), params(typs[3], typs[6]))
+       typs[86] = newSig(params(typs[1], typs[76], typs[62]), params(typs[3], typs[6]))
+       typs[87] = newSig(params(typs[1], typs[76], typs[24]), params(typs[3], typs[6]))
+       typs[88] = newSig(params(typs[1], typs[76], typs[28]), params(typs[3], typs[6]))
+       typs[89] = newSig(params(typs[1], typs[76], typs[3], typs[1]), params(typs[3], typs[6]))
+       typs[90] = newSig(params(typs[1], typs[76], typs[7]), params(typs[3]))
+       typs[91] = newSig(params(typs[1], typs[76], typs[3]), nil)
+       typs[92] = newSig(params(typs[1], typs[76], typs[62]), nil)
+       typs[93] = newSig(params(typs[1], typs[76], typs[24]), nil)
+       typs[94] = newSig(params(typs[1], typs[76], typs[28]), nil)
+       typs[95] = newSig(params(typs[3]), nil)
+       typs[96] = newSig(params(typs[1], typs[76]), nil)
+       typs[97] = types.NewChan(typs[2], types.Cboth)
+       typs[98] = newSig(params(typs[1], typs[22]), params(typs[97]))
+       typs[99] = newSig(params(typs[1], typs[15]), params(typs[97]))
+       typs[100] = types.NewChan(typs[2], types.Crecv)
+       typs[101] = newSig(params(typs[100], typs[3]), nil)
+       typs[102] = newSig(params(typs[100], typs[3]), params(typs[6]))
+       typs[103] = types.NewChan(typs[2], types.Csend)
+       typs[104] = newSig(params(typs[103], typs[3]), nil)
+       typs[105] = types.NewArray(typs[0], 3)
+       typs[106] = types.NewStruct([]*types.Field{types.NewField(src.NoXPos, Lookup("enabled"), typs[6]), types.NewField(src.NoXPos, Lookup("pad"), typs[105]), types.NewField(src.NoXPos, Lookup("needed"), typs[6]), types.NewField(src.NoXPos, Lookup("cgo"), typs[6]), types.NewField(src.NoXPos, Lookup("alignme"), typs[24])})
+       typs[107] = newSig(params(typs[1], typs[3], typs[3]), nil)
+       typs[108] = newSig(params(typs[1], typs[3]), nil)
+       typs[109] = newSig(params(typs[1], typs[3], typs[15], typs[3], typs[15]), params(typs[15]))
+       typs[110] = newSig(params(typs[103], typs[3]), params(typs[6]))
+       typs[111] = newSig(params(typs[3], typs[100]), params(typs[6], typs[6]))
+       typs[112] = newSig(params(typs[57]), nil)
+       typs[113] = newSig(params(typs[1], typs[1], typs[57], typs[15], typs[15], typs[6]), params(typs[15], typs[6]))
+       typs[114] = newSig(params(typs[1], typs[15], typs[15]), params(typs[7]))
+       typs[115] = newSig(params(typs[1], typs[22], typs[22]), params(typs[7]))
+       typs[116] = newSig(params(typs[1], typs[15], typs[15], typs[7]), params(typs[7]))
+       typs[117] = types.NewSlice(typs[2])
+       typs[118] = newSig(params(typs[3], typs[15], typs[15], typs[15], typs[1]), params(typs[117]))
+       typs[119] = newSig(params(typs[1], typs[7], typs[22]), nil)
+       typs[120] = newSig(params(typs[7], typs[22]), nil)
+       typs[121] = newSig(params(typs[3], typs[3], typs[5]), nil)
+       typs[122] = newSig(params(typs[7], typs[5]), nil)
+       typs[123] = newSig(params(typs[3], typs[3], typs[5]), params(typs[6]))
+       typs[124] = newSig(params(typs[3], typs[3]), params(typs[6]))
+       typs[125] = newSig(params(typs[7], typs[7]), params(typs[6]))
+       typs[126] = newSig(params(typs[3], typs[5], typs[5]), params(typs[5]))
+       typs[127] = newSig(params(typs[7], typs[5]), params(typs[5]))
+       typs[128] = newSig(params(typs[3], typs[5]), params(typs[5]))
+       typs[129] = newSig(params(typs[22], typs[22]), params(typs[22]))
+       typs[130] = newSig(params(typs[24], typs[24]), params(typs[24]))
+       typs[131] = newSig(params(typs[20]), params(typs[22]))
+       typs[132] = newSig(params(typs[20]), params(typs[24]))
+       typs[133] = newSig(params(typs[20]), params(typs[62]))
+       typs[134] = newSig(params(typs[22]), params(typs[20]))
+       typs[135] = types.Types[types.TFLOAT32]
+       typs[136] = newSig(params(typs[22]), params(typs[135]))
+       typs[137] = newSig(params(typs[24]), params(typs[20]))
+       typs[138] = newSig(params(typs[24]), params(typs[135]))
+       typs[139] = newSig(params(typs[62]), params(typs[20]))
+       typs[140] = newSig(params(typs[26], typs[26]), params(typs[26]))
+       typs[141] = newSig(nil, params(typs[5]))
+       typs[142] = newSig(params(typs[5], typs[5]), nil)
+       typs[143] = newSig(params(typs[5], typs[5], typs[5]), nil)
+       typs[144] = newSig(params(typs[7], typs[1], typs[5]), nil)
+       typs[145] = types.NewSlice(typs[7])
+       typs[146] = newSig(params(typs[7], typs[145]), nil)
+       typs[147] = newSig(params(typs[66], typs[66], typs[17]), nil)
+       typs[148] = newSig(params(typs[60], typs[60], typs[17]), nil)
+       typs[149] = newSig(params(typs[62], typs[62], typs[17]), nil)
+       typs[150] = newSig(params(typs[24], typs[24], typs[17]), nil)
+       typs[151] = newSig(params(typs[28], typs[28], typs[17]), nil)
+       typs[152] = types.NewArray(typs[0], 16)
+       typs[153] = newSig(params(typs[7], typs[62], typs[152], typs[28], typs[15], typs[66], typs[66]), params(typs[62]))
        return typs[:]
 }
 

diff --git a/src/runtime/iface.go b/src/runtime/iface.go
index 99ac3eb4616ad79771ec5d66dc31d10b4c0386c5..911b86cd373faf6994223f815d43f4b62dfc93d8 100644 (file)
--- a/src/runtime/iface.go
+++ b/src/runtime/iface.go
@@ -414,9 +414,6 @@ func convI2I(dst *interfacetype, src *itab) *itab {
        if src == nil {
                return nil
        }
-       if src.inter == dst {
-               return src
-       }
        return getitab(dst, src._type, false)
 }
 
@@ -425,26 +422,14 @@ func assertI2I(inter *interfacetype, tab *itab) *itab {
                // explicit conversions require non-nil interface value.
                panic(&TypeAssertionError{nil, nil, &inter.Type, ""})
        }
-       if tab.inter == inter {
-               return tab
-       }
        return getitab(inter, tab._type, false)
 }
 
-func assertI2I2(inter *interfacetype, i iface) (r iface) {
-       tab := i.tab
+func assertI2I2(inter *interfacetype, tab *itab) *itab {
        if tab == nil {
-               return
-       }
-       if tab.inter != inter {
-               tab = getitab(inter, tab._type, true)
-               if tab == nil {
-                       return
-               }
+               return nil
        }
-       r.tab = tab
-       r.data = i.data
-       return
+       return getitab(inter, tab._type, true)
 }
 
 func assertE2I(inter *interfacetype, t *_type) *itab {
@@ -455,18 +440,11 @@ func assertE2I(inter *interfacetype, t *_type) *itab {
        return getitab(inter, t, false)
 }
 
-func assertE2I2(inter *interfacetype, e eface) (r iface) {
-       t := e._type
+func assertE2I2(inter *interfacetype, t *_type) *itab {
        if t == nil {
-               return
-       }
-       tab := getitab(inter, t, true)
-       if tab == nil {
-               return
+               return nil
        }
-       r.tab = tab
-       r.data = e.data
-       return
+       return getitab(inter, t, true)
 }
 
 // interfaceSwitch compares t against the list of cases in s.

diff --git a/src/runtime/mfinal.go b/src/runtime/mfinal.go
index 99ca3a75627b3b6bfb7d2f4fb4b93e0a57a6546e..147018ef44d7e94688502482a2b7ff49373ea7b2 100644 (file)
--- a/src/runtime/mfinal.go
+++ b/src/runtime/mfinal.go
@@ -464,7 +464,7 @@ func SetFinalizer(obj any, finalizer any) {
                        // ok - satisfies empty interface
                        goto okarg
                }
-               if iface := assertE2I2(ityp, *efaceOf(&obj)); iface.tab != nil {
+               if itab := assertE2I2(ityp, efaceOf(&obj)._type); itab != nil {
                        goto okarg
                }
        }