cmd/compile: intrinsify swissmap match calls with SIMD on amd64

Use similar SIMD operations to the ones used in Abseil. We still
using 8-slot groups (even though the XMM registers could handle 16-slot
groups) to keep the implementation simpler (no changes to the memory
layout of maps).

Still, the implementations of matchH2 and matchEmpty are shorter than
the portable version using standard arithmetic operations. They also
return a packed bitset, which avoids the need to shift in bitset.first.

That said, the packed bitset is a downside in cognitive complexity, as
we have to think about two different possible representations. This
doesn't leak out of the API, but we do need to intrinsify bitset to
switch to a compatible implementation.

The compiler's intrinsics don't support intrinsifying methods, so the
implementations move to free functions.

This makes operations between 0-3% faster on my machine. e.g.,

MapGetHit/impl=runtimeMap/t=Int64/len=6-12                      12.34n ±  1%   11.42n ± 1%   -7.46% (p=0.000 n=25)
MapGetHit/impl=runtimeMap/t=Int64/len=12-12                     15.14n ±  2%   14.88n ± 1%   -1.72% (p=0.009 n=25)
MapGetHit/impl=runtimeMap/t=Int64/len=18-12                     15.04n ±  6%   14.66n ± 2%   -2.53% (p=0.000 n=25)
MapGetHit/impl=runtimeMap/t=Int64/len=24-12                     15.80n ±  1%   15.48n ± 3%        ~ (p=0.444 n=25)
MapGetHit/impl=runtimeMap/t=Int64/len=30-12                     15.55n ±  4%   14.77n ± 3%   -5.02% (p=0.004 n=25)
MapGetHit/impl=runtimeMap/t=Int64/len=64-12                     15.26n ±  1%   15.05n ± 1%        ~ (p=0.055 n=25)
MapGetHit/impl=runtimeMap/t=Int64/len=128-12                    15.34n ±  1%   15.02n ± 2%   -2.09% (p=0.000 n=25)
MapGetHit/impl=runtimeMap/t=Int64/len=256-12                    15.42n ±  1%   15.15n ± 1%   -1.75% (p=0.001 n=25)
MapGetHit/impl=runtimeMap/t=Int64/len=512-12                    15.48n ±  1%   15.18n ± 1%   -1.94% (p=0.000 n=25)
MapGetHit/impl=runtimeMap/t=Int64/len=1024-12                   17.38n ±  1%   17.05n ± 1%   -1.90% (p=0.000 n=25)
MapGetHit/impl=runtimeMap/t=Int64/len=2048-12                   17.96n ±  0%   17.59n ± 1%   -2.06% (p=0.000 n=25)
MapGetHit/impl=runtimeMap/t=Int64/len=4096-12                   18.36n ±  1%   18.18n ± 1%   -0.98% (p=0.013 n=25)
MapGetHit/impl=runtimeMap/t=Int64/len=8192-12                   18.75n ±  0%   18.31n ± 1%   -2.35% (p=0.000 n=25)
MapGetHit/impl=runtimeMap/t=Int64/len=65536-12                  26.25n ±  0%   25.95n ± 1%   -1.14% (p=0.000 n=25)
MapGetHit/impl=runtimeMap/t=Int64/len=262144-12                 44.24n ±  1%   44.06n ± 1%        ~ (p=0.181 n=25)
MapGetHit/impl=runtimeMap/t=Int64/len=1048576-12                85.02n ±  0%   85.35n ± 0%   +0.39% (p=0.032 n=25)
MapGetHit/impl=runtimeMap/t=Int64/len=4194304-12                98.87n ±  1%   98.85n ± 1%        ~ (p=0.799 n=25)

For #54766.

Cq-Include-Trybots: luci.golang.try:gotip-linux-ppc64_power10,gotip-linux-amd64-goamd64v3
Change-Id: Ic1b852f02744404122cb3672900fd95f4625905e
Reviewed-on: https://go-review.googlesource.com/c/go/+/626277
Reviewed-by: Keith Randall <khr@golang.org>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Auto-Submit: Michael Pratt <mpratt@google.com>
Reviewed-by: Keith Randall <khr@google.com>

diff --git a/src/cmd/compile/internal/amd64/ssa.go b/src/cmd/compile/internal/amd64/ssa.go
index 61f1c88a718afc42d85bf94ec07a48333a9ecdb2..493369af51ce150cf6e59d5d8f6299cb7e7fd0fa 100644 (file)
--- a/src/cmd/compile/internal/amd64/ssa.go
+++ b/src/cmd/compile/internal/amd64/ssa.go
@@ -256,9 +256,39 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
                ssa.OpAMD64POR, ssa.OpAMD64PXOR,
                ssa.OpAMD64BTSL, ssa.OpAMD64BTSQ,
                ssa.OpAMD64BTCL, ssa.OpAMD64BTCQ,
-               ssa.OpAMD64BTRL, ssa.OpAMD64BTRQ:
+               ssa.OpAMD64BTRL, ssa.OpAMD64BTRQ,
+               ssa.OpAMD64PCMPEQB, ssa.OpAMD64PSIGNB,
+               ssa.OpAMD64PUNPCKLBW:
                opregreg(s, v.Op.Asm(), v.Reg(), v.Args[1].Reg())
 
+       case ssa.OpAMD64PSHUFLW:
+               p := s.Prog(v.Op.Asm())
+               imm := v.AuxInt
+               if imm < 0 || imm > 255 {
+                       v.Fatalf("Invalid source selection immediate")
+               }
+               p.From.Offset = imm
+               p.From.Type = obj.TYPE_CONST
+               p.AddRestSourceReg(v.Args[0].Reg())
+               p.To.Type = obj.TYPE_REG
+               p.To.Reg = v.Reg()
+
+       case ssa.OpAMD64PSHUFBbroadcast:
+               // PSHUFB with a control mask of zero copies byte 0 to all
+               // bytes in the register.
+               //
+               // X15 is always zero with ABIInternal.
+               if s.ABI != obj.ABIInternal {
+                       // zero X15 manually
+                       opregreg(s, x86.AXORPS, x86.REG_X15, x86.REG_X15)
+               }
+
+               p := s.Prog(v.Op.Asm())
+               p.From.Type = obj.TYPE_REG
+               p.To.Type = obj.TYPE_REG
+               p.To.Reg = v.Reg()
+               p.From.Reg = x86.REG_X15
+
        case ssa.OpAMD64SHRDQ, ssa.OpAMD64SHLDQ:
                p := s.Prog(v.Op.Asm())
                lo, hi, bits := v.Args[0].Reg(), v.Args[1].Reg(), v.Args[2].Reg()
@@ -915,7 +945,7 @@ func ssaGenValue(s *ssagen.State, v *ssa.Value) {
                ssagen.AddAux2(&p.To, v, sc.Off64())
        case ssa.OpAMD64MOVLQSX, ssa.OpAMD64MOVWQSX, ssa.OpAMD64MOVBQSX, ssa.OpAMD64MOVLQZX, ssa.OpAMD64MOVWQZX, ssa.OpAMD64MOVBQZX,
                ssa.OpAMD64CVTTSS2SL, ssa.OpAMD64CVTTSD2SL, ssa.OpAMD64CVTTSS2SQ, ssa.OpAMD64CVTTSD2SQ,
-               ssa.OpAMD64CVTSS2SD, ssa.OpAMD64CVTSD2SS:
+               ssa.OpAMD64CVTSS2SD, ssa.OpAMD64CVTSD2SS, ssa.OpAMD64VPBROADCASTB, ssa.OpAMD64PMOVMSKB:
                opregreg(s, v.Op.Asm(), v.Reg(), v.Args[0].Reg())
        case ssa.OpAMD64CVTSL2SD, ssa.OpAMD64CVTSQ2SD, ssa.OpAMD64CVTSQ2SS, ssa.OpAMD64CVTSL2SS:
                r := v.Reg()

diff --git a/src/cmd/compile/internal/ssa/_gen/AMD64Ops.go b/src/cmd/compile/internal/ssa/_gen/AMD64Ops.go
index c171d5fd197e60b395fb380d08b0df50c3151d7d..23fb2361b561987c79e15007dee35c71a5fd1ca8 100644 (file)
--- a/src/cmd/compile/internal/ssa/_gen/AMD64Ops.go
+++ b/src/cmd/compile/internal/ssa/_gen/AMD64Ops.go
@@ -1134,6 +1134,60 @@ func init() {
                {name: "SHRXLloadidx8", argLength: 4, reg: gp21shxloadidx, asm: "SHRXL", scale: 8, aux: "SymOff", typ: "Uint32", faultOnNilArg0: true, symEffect: "Read"}, // unsigned *(arg0+8*arg1+auxint+aux) >> arg2, arg3=mem, shift amount is mod 32
                {name: "SHRXQloadidx1", argLength: 4, reg: gp21shxloadidx, asm: "SHRXQ", scale: 1, aux: "SymOff", typ: "Uint64", faultOnNilArg0: true, symEffect: "Read"}, // unsigned *(arg0+1*arg1+auxint+aux) >> arg2, arg3=mem, shift amount is mod 64
                {name: "SHRXQloadidx8", argLength: 4, reg: gp21shxloadidx, asm: "SHRXQ", scale: 8, aux: "SymOff", typ: "Uint64", faultOnNilArg0: true, symEffect: "Read"}, // unsigned *(arg0+8*arg1+auxint+aux) >> arg2, arg3=mem, shift amount is mod 64
+
+               // Unpack bytes, low 64-bits.
+               //
+               // Input/output registers treated as [8]uint8.
+               //
+               // output = {in1[0], in2[0], in1[1], in2[1], in1[2], in2[2], in1[3], in2[3]}
+               {name: "PUNPCKLBW", argLength: 2, reg: fp21, resultInArg0: true, asm: "PUNPCKLBW"},
+
+               // Shuffle 16-bit words, low 64-bits.
+               //
+               // Input/output registers treated as [4]uint16.
+               // aux=source word index for each destination word, 2 bits per index.
+               //
+               // output[i] = input[(aux>>2*i)&3].
+               {name: "PSHUFLW", argLength: 1, reg: fp11, aux: "Int8", asm: "PSHUFLW"},
+
+               // Broadcast input byte.
+               //
+               // Input treated as uint8, output treated as [16]uint8.
+               //
+               // output[i] = input.
+               {name: "PSHUFBbroadcast", argLength: 1, reg: fp11, resultInArg0: true, asm: "PSHUFB"}, // PSHUFB with mask zero, (GOAMD64=v1)
+               {name: "VPBROADCASTB", argLength: 1, reg: gpfp, asm: "VPBROADCASTB"}, // Broadcast input byte from gp (GOAMD64=v3)
+
+               // Byte negate/zero/preserve (GOAMD64=v2).
+               //
+               // Input/output registers treated as [16]uint8.
+               //
+               // if in2[i] > 0 {
+               //   output[i] = in1[i]
+               // } else if in2[i] == 0 {
+               //   output[i] = 0
+               // } else {
+               //   output[i] = -1 * in1[i]
+               // }
+               {name: "PSIGNB", argLength: 2, reg: fp21, resultInArg0: true, asm: "PSIGNB"},
+
+               // Byte compare.
+               //
+               // Input/output registers treated as [16]uint8.
+               //
+               // if in1[i] == in2[i] {
+               //   output[i] = 0xff
+               // } else {
+               //   output[i] = 0
+               // }
+               {name: "PCMPEQB", argLength: 2, reg: fp21, resultInArg0: true, asm: "PCMPEQB"},
+
+               // Byte sign mask. Output is a bitmap of sign bits from each input byte.
+               //
+               // Input treated as [16]uint8. Output is [16]bit (uint16 bitmap).
+               //
+               // output[i] = (input[i] >> 7) & 1
+               {name: "PMOVMSKB", argLength: 1, reg: fpgp, asm: "PMOVMSKB"},
        }
 
        var AMD64blocks = []blockData{

diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go
index 86d8924943093a836bd7c9559d501a1419516da2..df1ddfa69edfc101c757899c8f03f837bcd34062 100644 (file)
--- a/src/cmd/compile/internal/ssa/opGen.go
+++ b/src/cmd/compile/internal/ssa/opGen.go
@@ -1150,6 +1150,13 @@ const (
        OpAMD64SHRXLloadidx8
        OpAMD64SHRXQloadidx1
        OpAMD64SHRXQloadidx8
+       OpAMD64PUNPCKLBW
+       OpAMD64PSHUFLW
+       OpAMD64PSHUFBbroadcast
+       OpAMD64VPBROADCASTB
+       OpAMD64PSIGNB
+       OpAMD64PCMPEQB
+       OpAMD64PMOVMSKB
 
        OpARMADD
        OpARMADDconst
@@ -15333,6 +15340,105 @@ var opcodeTable = [...]opInfo{
                        },
                },
        },
+       {
+               name:         "PUNPCKLBW",
+               argLen:       2,
+               resultInArg0: true,
+               asm:          x86.APUNPCKLBW,
+               reg: regInfo{
+                       inputs: []inputInfo{
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                               {1, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                       },
+                       outputs: []outputInfo{
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                       },
+               },
+       },
+       {
+               name:    "PSHUFLW",
+               auxType: auxInt8,
+               argLen:  1,
+               asm:     x86.APSHUFLW,
+               reg: regInfo{
+                       inputs: []inputInfo{
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                       },
+                       outputs: []outputInfo{
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                       },
+               },
+       },
+       {
+               name:         "PSHUFBbroadcast",
+               argLen:       1,
+               resultInArg0: true,
+               asm:          x86.APSHUFB,
+               reg: regInfo{
+                       inputs: []inputInfo{
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                       },
+                       outputs: []outputInfo{
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                       },
+               },
+       },
+       {
+               name:   "VPBROADCASTB",
+               argLen: 1,
+               asm:    x86.AVPBROADCASTB,
+               reg: regInfo{
+                       inputs: []inputInfo{
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                       },
+                       outputs: []outputInfo{
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                       },
+               },
+       },
+       {
+               name:         "PSIGNB",
+               argLen:       2,
+               resultInArg0: true,
+               asm:          x86.APSIGNB,
+               reg: regInfo{
+                       inputs: []inputInfo{
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                               {1, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                       },
+                       outputs: []outputInfo{
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                       },
+               },
+       },
+       {
+               name:         "PCMPEQB",
+               argLen:       2,
+               resultInArg0: true,
+               asm:          x86.APCMPEQB,
+               reg: regInfo{
+                       inputs: []inputInfo{
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                               {1, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                       },
+                       outputs: []outputInfo{
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                       },
+               },
+       },
+       {
+               name:   "PMOVMSKB",
+               argLen: 1,
+               asm:    x86.APMOVMSKB,
+               reg: regInfo{
+                       inputs: []inputInfo{
+                               {0, 2147418112}, // X0 X1 X2 X3 X4 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14
+                       },
+                       outputs: []outputInfo{
+                               {0, 49135}, // AX CX DX BX BP SI DI R8 R9 R10 R11 R12 R13 R15
+                       },
+               },
+       },
 
        {
                name:        "ADD",

diff --git a/src/cmd/compile/internal/ssagen/intrinsics.go b/src/cmd/compile/internal/ssagen/intrinsics.go
index 8a721b41348b81c7fb7fc9df024459149ab09144..e4da86db51ad8b2ca143290c75dab28d47484067 100644 (file)
--- a/src/cmd/compile/internal/ssagen/intrinsics.go
+++ b/src/cmd/compile/internal/ssagen/intrinsics.go
@@ -6,6 +6,7 @@ package ssagen
 
 import (
        "fmt"
+       "internal/abi"
        "internal/buildcfg"
 
        "cmd/compile/internal/base"
@@ -1259,6 +1260,297 @@ func initIntrinsics(cfg *intrinsicBuildConfig) {
 
        /******** math/big ********/
        alias("math/big", "mulWW", "math/bits", "Mul64", p8...)
+
+       /******** internal/runtime/maps ********/
+
+       // Important: The intrinsic implementations below return a packed
+       // bitset, while the portable Go implementation uses an unpacked
+       // representation (one bit set in each byte).
+       //
+       // Thus we must replace most bitset methods with implementations that
+       // work with the packed representation.
+       //
+       // TODO(prattmic): The bitset implementations don't use SIMD, so they
+       // could be handled with build tags (though that would break
+       // -d=ssa/intrinsics/off=1).
+
+       // With a packed representation we no longer need to shift the result
+       // of TrailingZeros64.
+       alias("internal/runtime/maps", "bitsetFirst", "internal/runtime/sys", "TrailingZeros64", sys.ArchAMD64)
+
+       addF("internal/runtime/maps", "bitsetRemoveBelow",
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       b := args[0]
+                       i := args[1]
+
+                       // Clear the lower i bits in b.
+                       //
+                       // out = b &^ ((1 << i) - 1)
+
+                       one := s.constInt64(types.Types[types.TUINT64], 1)
+
+                       mask := s.newValue2(ssa.OpLsh8x8, types.Types[types.TUINT64], one, i)
+                       mask = s.newValue2(ssa.OpSub64, types.Types[types.TUINT64], mask, one)
+                       mask = s.newValue1(ssa.OpCom64, types.Types[types.TUINT64], mask)
+
+                       return s.newValue2(ssa.OpAnd64, types.Types[types.TUINT64], b, mask)
+               },
+               sys.AMD64)
+
+       addF("internal/runtime/maps", "bitsetLowestSet",
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       b := args[0]
+
+                       // Test the lowest bit in b.
+                       //
+                       // out = (b & 1) == 1
+
+                       one := s.constInt64(types.Types[types.TUINT64], 1)
+                       and := s.newValue2(ssa.OpAnd64, types.Types[types.TUINT64], b, one)
+                       return s.newValue2(ssa.OpEq64, types.Types[types.TBOOL], and, one)
+               },
+               sys.AMD64)
+
+       addF("internal/runtime/maps", "bitsetShiftOutLowest",
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       b := args[0]
+
+                       // Right shift out the lowest bit in b.
+                       //
+                       // out = b >> 1
+
+                       one := s.constInt64(types.Types[types.TUINT64], 1)
+                       return s.newValue2(ssa.OpRsh64Ux64, types.Types[types.TUINT64], b, one)
+               },
+               sys.AMD64)
+
+       addF("internal/runtime/maps", "ctrlGroupMatchH2",
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       g := args[0]
+                       h := args[1]
+
+                       // Explicit copies to fp registers. See
+                       // https://go.dev/issue/70451.
+                       gfp := s.newValue1(ssa.OpAMD64MOVQi2f, types.TypeInt128, g)
+                       hfp := s.newValue1(ssa.OpAMD64MOVQi2f, types.TypeInt128, h)
+
+                       // Broadcast h2 into each byte of a word.
+                       var broadcast *ssa.Value
+                       if buildcfg.GOAMD64 >= 4 {
+                               // VPBROADCASTB saves 1 instruction vs PSHUFB
+                               // because the input can come from a GP
+                               // register, while PSHUFB requires moving into
+                               // an FP register first.
+                               //
+                               // Nominally PSHUFB would require a second
+                               // additional instruction to load the control
+                               // mask into a FP register. But broadcast uses
+                               // a control mask of 0, and the register ABI
+                               // already defines X15 as a zero register.
+                               broadcast = s.newValue1(ssa.OpAMD64VPBROADCASTB, types.TypeInt128, h) // use gp copy of h
+                       } else if buildcfg.GOAMD64 >= 2 {
+                               // PSHUFB performs a byte broadcast when given
+                               // a control input of 0.
+                               broadcast = s.newValue1(ssa.OpAMD64PSHUFBbroadcast, types.TypeInt128, hfp)
+                       } else {
+                               // No direct byte broadcast. First we must
+                               // duplicate the lower byte and then do a
+                               // 16-bit broadcast.
+
+                               // "Unpack" h2 with itself. This duplicates the
+                               // input, resulting in h2 in the lower two
+                               // bytes.
+                               unpack := s.newValue2(ssa.OpAMD64PUNPCKLBW, types.TypeInt128, hfp, hfp)
+
+                               // Copy the lower 16-bits of unpack into every
+                               // 16-bit slot in the lower 64-bits of the
+                               // output register. Note that immediate 0
+                               // selects the low word as the source for every
+                               // destination slot.
+                               broadcast = s.newValue1I(ssa.OpAMD64PSHUFLW, types.TypeInt128, 0, unpack)
+
+                               // No need to broadcast into the upper 64-bits,
+                               // as we don't use those.
+                       }
+
+                       // Compare each byte of the control word with h2. Each
+                       // matching byte has every bit set.
+                       eq := s.newValue2(ssa.OpAMD64PCMPEQB, types.TypeInt128, broadcast, gfp)
+
+                       // Construct a "byte mask": each output bit is equal to
+                       // the sign bit each input byte.
+                       //
+                       // This results in a packed output (bit N set means
+                       // byte N matched).
+                       //
+                       // NOTE: See comment above on bitsetFirst.
+                       out := s.newValue1(ssa.OpAMD64PMOVMSKB, types.Types[types.TUINT16], eq)
+
+                       // g is only 64-bits so the upper 64-bits of the
+                       // 128-bit register will be zero. If h2 is also zero,
+                       // then we'll get matches on those bytes. Truncate the
+                       // upper bits to ignore such matches.
+                       ret := s.newValue1(ssa.OpZeroExt8to64, types.Types[types.TUINT64], out)
+
+                       return ret
+               },
+               sys.AMD64)
+
+       addF("internal/runtime/maps", "ctrlGroupMatchEmpty",
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       // An empty slot is   1000 0000
+                       // A deleted slot is  1111 1110
+                       // A full slot is     0??? ????
+
+                       g := args[0]
+
+                       // Explicit copy to fp register. See
+                       // https://go.dev/issue/70451.
+                       gfp := s.newValue1(ssa.OpAMD64MOVQi2f, types.TypeInt128, g)
+
+                       if buildcfg.GOAMD64 >= 2 {
+                               // "PSIGNB negates each data element of the
+                               // destination operand (the first operand) if
+                               // the signed integer value of the
+                               // corresponding data element in the source
+                               // operand (the second operand) is less than
+                               // zero. If the signed integer value of a data
+                               // element in the source operand is positive,
+                               // the corresponding data element in the
+                               // destination operand is unchanged. If a data
+                               // element in the source operand is zero, the
+                               // corresponding data element in the
+                               // destination operand is set to zero" - Intel SDM
+                               //
+                               // If we pass the group control word as both
+                               // arguments:
+                               // - Full slots are unchanged.
+                               // - Deleted slots are negated, becoming
+                               //   0000 0010.
+                               // - Empty slots are negated, becoming
+                               //   1000 0000 (unchanged!).
+                               //
+                               // The result is that only empty slots have the
+                               // sign bit set. We then use PMOVMSKB to
+                               // extract the sign bits.
+                               sign := s.newValue2(ssa.OpAMD64PSIGNB, types.TypeInt128, gfp, gfp)
+
+                               // Construct a "byte mask": each output bit is
+                               // equal to the sign bit each input byte. The
+                               // sign bit is only set for empty or deleted
+                               // slots.
+                               //
+                               // This results in a packed output (bit N set
+                               // means byte N matched).
+                               //
+                               // NOTE: See comment above on bitsetFirst.
+                               ret := s.newValue1(ssa.OpAMD64PMOVMSKB, types.Types[types.TUINT16], sign)
+
+                               // g is only 64-bits so the upper 64-bits of
+                               // the 128-bit register will be zero. PSIGNB
+                               // will keep all of these bytes zero, so no
+                               // need to truncate.
+
+                               return ret
+                       }
+
+                       // No PSIGNB, simply do byte equality with ctrlEmpty.
+
+                       // Load ctrlEmpty into each byte of a control word.
+                       var ctrlsEmpty uint64 = abi.SwissMapCtrlEmpty
+                       e := s.constInt64(types.Types[types.TUINT64], int64(ctrlsEmpty))
+                       // Explicit copy to fp register. See
+                       // https://go.dev/issue/70451.
+                       efp := s.newValue1(ssa.OpAMD64MOVQi2f, types.TypeInt128, e)
+
+                       // Compare each byte of the control word with ctrlEmpty. Each
+                       // matching byte has every bit set.
+                       eq := s.newValue2(ssa.OpAMD64PCMPEQB, types.TypeInt128, efp, gfp)
+
+                       // Construct a "byte mask": each output bit is equal to
+                       // the sign bit each input byte.
+                       //
+                       // This results in a packed output (bit N set means
+                       // byte N matched).
+                       //
+                       // NOTE: See comment above on bitsetFirst.
+                       out := s.newValue1(ssa.OpAMD64PMOVMSKB, types.Types[types.TUINT16], eq)
+
+                       // g is only 64-bits so the upper 64-bits of the
+                       // 128-bit register will be zero. The upper 64-bits of
+                       // efp are also zero, so we'll get matches on those
+                       // bytes. Truncate the upper bits to ignore such
+                       // matches.
+                       return s.newValue1(ssa.OpZeroExt8to64, types.Types[types.TUINT64], out)
+               },
+               sys.AMD64)
+
+       addF("internal/runtime/maps", "ctrlGroupMatchEmptyOrDeleted",
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       // An empty slot is   1000 0000
+                       // A deleted slot is  1111 1110
+                       // A full slot is     0??? ????
+                       //
+                       // A slot is empty or deleted iff bit 7 (sign bit) is
+                       // set.
+
+                       g := args[0]
+
+                       // Explicit copy to fp register. See
+                       // https://go.dev/issue/70451.
+                       gfp := s.newValue1(ssa.OpAMD64MOVQi2f, types.TypeInt128, g)
+
+                       // Construct a "byte mask": each output bit is equal to
+                       // the sign bit each input byte. The sign bit is only
+                       // set for empty or deleted slots.
+                       //
+                       // This results in a packed output (bit N set means
+                       // byte N matched).
+                       //
+                       // NOTE: See comment above on bitsetFirst.
+                       ret := s.newValue1(ssa.OpAMD64PMOVMSKB, types.Types[types.TUINT16], gfp)
+
+                       // g is only 64-bits so the upper 64-bits of the
+                       // 128-bit register will be zero. Zero will never match
+                       // ctrlEmpty or ctrlDeleted, so no need to truncate.
+
+                       return ret
+               },
+               sys.AMD64)
+
+       addF("internal/runtime/maps", "ctrlGroupMatchFull",
+               func(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value {
+                       // An empty slot is   1000 0000
+                       // A deleted slot is  1111 1110
+                       // A full slot is     0??? ????
+                       //
+                       // A slot is full iff bit 7 (sign bit) is unset.
+
+                       g := args[0]
+
+                       // Explicit copy to fp register. See
+                       // https://go.dev/issue/70451.
+                       gfp := s.newValue1(ssa.OpAMD64MOVQi2f, types.TypeInt128, g)
+
+                       // Construct a "byte mask": each output bit is equal to
+                       // the sign bit each input byte. The sign bit is only
+                       // set for empty or deleted slots.
+                       //
+                       // This results in a packed output (bit N set means
+                       // byte N matched).
+                       //
+                       // NOTE: See comment above on bitsetFirst.
+                       mask := s.newValue1(ssa.OpAMD64PMOVMSKB, types.Types[types.TUINT16], gfp)
+
+                       // Invert the mask to set the bits for the full slots.
+                       out := s.newValue1(ssa.OpCom16, types.Types[types.TUINT16], mask)
+
+                       // g is only 64-bits so the upper 64-bits of the
+                       // 128-bit register will be zero, with bit 7 unset.
+                       // Truncate the upper bits to ignore these.
+                       return s.newValue1(ssa.OpZeroExt8to64, types.Types[types.TUINT64], out)
+               },
+               sys.AMD64)
 }
 
 // findIntrinsic returns a function which builds the SSA equivalent of the

diff --git a/src/cmd/compile/internal/ssagen/intrinsics_test.go b/src/cmd/compile/internal/ssagen/intrinsics_test.go
index df2a6b3187282b3a3760ea58bdc6012a52c8cc2a..2e29a45c0b83f585b3daf6a8b36855087746c978 100644 (file)
--- a/src/cmd/compile/internal/ssagen/intrinsics_test.go
+++ b/src/cmd/compile/internal/ssagen/intrinsics_test.go
@@ -23,1275 +23,1283 @@ type testIntrinsicKey struct {
 }
 
 var wantIntrinsics = map[testIntrinsicKey]struct{}{
-       {"386", "internal/runtime/math", "MulUintptr"}:             struct{}{},
-       {"386", "internal/runtime/sys", "Bswap32"}:                 struct{}{},
-       {"386", "internal/runtime/sys", "Bswap64"}:                 struct{}{},
-       {"386", "internal/runtime/sys", "GetCallerPC"}:             struct{}{},
-       {"386", "internal/runtime/sys", "GetCallerSP"}:             struct{}{},
-       {"386", "internal/runtime/sys", "GetClosurePtr"}:           struct{}{},
-       {"386", "internal/runtime/sys", "TrailingZeros32"}:         struct{}{},
-       {"386", "internal/runtime/sys", "TrailingZeros64"}:         struct{}{},
-       {"386", "internal/runtime/sys", "TrailingZeros8"}:          struct{}{},
-       {"386", "math", "sqrt"}:                                    struct{}{},
-       {"386", "math/bits", "ReverseBytes32"}:                     struct{}{},
-       {"386", "math/bits", "ReverseBytes64"}:                     struct{}{},
-       {"386", "math/bits", "TrailingZeros16"}:                    struct{}{},
-       {"386", "math/bits", "TrailingZeros32"}:                    struct{}{},
-       {"386", "math/bits", "TrailingZeros64"}:                    struct{}{},
-       {"386", "math/bits", "TrailingZeros8"}:                     struct{}{},
-       {"386", "runtime", "KeepAlive"}:                            struct{}{},
-       {"386", "runtime", "slicebytetostringtmp"}:                 struct{}{},
-       {"amd64", "internal/runtime/atomic", "And"}:                struct{}{},
-       {"amd64", "internal/runtime/atomic", "And32"}:              struct{}{},
-       {"amd64", "internal/runtime/atomic", "And64"}:              struct{}{},
-       {"amd64", "internal/runtime/atomic", "And8"}:               struct{}{},
-       {"amd64", "internal/runtime/atomic", "Cas"}:                struct{}{},
-       {"amd64", "internal/runtime/atomic", "Cas64"}:              struct{}{},
-       {"amd64", "internal/runtime/atomic", "CasRel"}:             struct{}{},
-       {"amd64", "internal/runtime/atomic", "Casint32"}:           struct{}{},
-       {"amd64", "internal/runtime/atomic", "Casint64"}:           struct{}{},
-       {"amd64", "internal/runtime/atomic", "Casp1"}:              struct{}{},
-       {"amd64", "internal/runtime/atomic", "Casuintptr"}:         struct{}{},
-       {"amd64", "internal/runtime/atomic", "Load"}:               struct{}{},
-       {"amd64", "internal/runtime/atomic", "Load64"}:             struct{}{},
-       {"amd64", "internal/runtime/atomic", "Load8"}:              struct{}{},
-       {"amd64", "internal/runtime/atomic", "LoadAcq"}:            struct{}{},
-       {"amd64", "internal/runtime/atomic", "LoadAcq64"}:          struct{}{},
-       {"amd64", "internal/runtime/atomic", "LoadAcquintptr"}:     struct{}{},
-       {"amd64", "internal/runtime/atomic", "Loadint32"}:          struct{}{},
-       {"amd64", "internal/runtime/atomic", "Loadint64"}:          struct{}{},
-       {"amd64", "internal/runtime/atomic", "Loadp"}:              struct{}{},
-       {"amd64", "internal/runtime/atomic", "Loaduint"}:           struct{}{},
-       {"amd64", "internal/runtime/atomic", "Loaduintptr"}:        struct{}{},
-       {"amd64", "internal/runtime/atomic", "Or"}:                 struct{}{},
-       {"amd64", "internal/runtime/atomic", "Or32"}:               struct{}{},
-       {"amd64", "internal/runtime/atomic", "Or64"}:               struct{}{},
-       {"amd64", "internal/runtime/atomic", "Or8"}:                struct{}{},
-       {"amd64", "internal/runtime/atomic", "Store"}:              struct{}{},
-       {"amd64", "internal/runtime/atomic", "Store64"}:            struct{}{},
-       {"amd64", "internal/runtime/atomic", "Store8"}:             struct{}{},
-       {"amd64", "internal/runtime/atomic", "StoreRel"}:           struct{}{},
-       {"amd64", "internal/runtime/atomic", "StoreRel64"}:         struct{}{},
-       {"amd64", "internal/runtime/atomic", "StoreReluintptr"}:    struct{}{},
-       {"amd64", "internal/runtime/atomic", "Storeint32"}:         struct{}{},
-       {"amd64", "internal/runtime/atomic", "Storeint64"}:         struct{}{},
-       {"amd64", "internal/runtime/atomic", "StorepNoWB"}:         struct{}{},
-       {"amd64", "internal/runtime/atomic", "Storeuintptr"}:       struct{}{},
-       {"amd64", "internal/runtime/atomic", "Xadd"}:               struct{}{},
-       {"amd64", "internal/runtime/atomic", "Xadd64"}:             struct{}{},
-       {"amd64", "internal/runtime/atomic", "Xaddint32"}:          struct{}{},
-       {"amd64", "internal/runtime/atomic", "Xaddint64"}:          struct{}{},
-       {"amd64", "internal/runtime/atomic", "Xadduintptr"}:        struct{}{},
-       {"amd64", "internal/runtime/atomic", "Xchg"}:               struct{}{},
-       {"amd64", "internal/runtime/atomic", "Xchg64"}:             struct{}{},
-       {"amd64", "internal/runtime/atomic", "Xchg8"}:              struct{}{},
-       {"amd64", "internal/runtime/atomic", "Xchgint32"}:          struct{}{},
-       {"amd64", "internal/runtime/atomic", "Xchgint64"}:          struct{}{},
-       {"amd64", "internal/runtime/atomic", "Xchguintptr"}:        struct{}{},
-       {"amd64", "internal/runtime/math", "Add64"}:                struct{}{},
-       {"amd64", "internal/runtime/math", "Mul64"}:                struct{}{},
-       {"amd64", "internal/runtime/math", "MulUintptr"}:           struct{}{},
-       {"amd64", "internal/runtime/sys", "Bswap32"}:               struct{}{},
-       {"amd64", "internal/runtime/sys", "Bswap64"}:               struct{}{},
-       {"amd64", "internal/runtime/sys", "GetCallerPC"}:           struct{}{},
-       {"amd64", "internal/runtime/sys", "GetCallerSP"}:           struct{}{},
-       {"amd64", "internal/runtime/sys", "GetClosurePtr"}:         struct{}{},
-       {"amd64", "internal/runtime/sys", "Len64"}:                 struct{}{},
-       {"amd64", "internal/runtime/sys", "Len8"}:                  struct{}{},
-       {"amd64", "internal/runtime/sys", "OnesCount64"}:           struct{}{},
-       {"amd64", "internal/runtime/sys", "Prefetch"}:              struct{}{},
-       {"amd64", "internal/runtime/sys", "PrefetchStreamed"}:      struct{}{},
-       {"amd64", "internal/runtime/sys", "TrailingZeros32"}:       struct{}{},
-       {"amd64", "internal/runtime/sys", "TrailingZeros64"}:       struct{}{},
-       {"amd64", "internal/runtime/sys", "TrailingZeros8"}:        struct{}{},
-       {"amd64", "math", "Ceil"}:                                  struct{}{},
-       {"amd64", "math", "FMA"}:                                   struct{}{},
-       {"amd64", "math", "Floor"}:                                 struct{}{},
-       {"amd64", "math", "RoundToEven"}:                           struct{}{},
-       {"amd64", "math", "Trunc"}:                                 struct{}{},
-       {"amd64", "math", "sqrt"}:                                  struct{}{},
-       {"amd64", "math/big", "mulWW"}:                             struct{}{},
-       {"amd64", "math/bits", "Add"}:                              struct{}{},
-       {"amd64", "math/bits", "Add64"}:                            struct{}{},
-       {"amd64", "math/bits", "Div"}:                              struct{}{},
-       {"amd64", "math/bits", "Div64"}:                            struct{}{},
-       {"amd64", "math/bits", "Len"}:                              struct{}{},
-       {"amd64", "math/bits", "Len16"}:                            struct{}{},
-       {"amd64", "math/bits", "Len32"}:                            struct{}{},
-       {"amd64", "math/bits", "Len64"}:                            struct{}{},
-       {"amd64", "math/bits", "Len8"}:                             struct{}{},
-       {"amd64", "math/bits", "Mul"}:                              struct{}{},
-       {"amd64", "math/bits", "Mul64"}:                            struct{}{},
-       {"amd64", "math/bits", "OnesCount"}:                        struct{}{},
-       {"amd64", "math/bits", "OnesCount16"}:                      struct{}{},
-       {"amd64", "math/bits", "OnesCount32"}:                      struct{}{},
-       {"amd64", "math/bits", "OnesCount64"}:                      struct{}{},
-       {"amd64", "math/bits", "ReverseBytes32"}:                   struct{}{},
-       {"amd64", "math/bits", "ReverseBytes64"}:                   struct{}{},
-       {"amd64", "math/bits", "RotateLeft"}:                       struct{}{},
-       {"amd64", "math/bits", "RotateLeft16"}:                     struct{}{},
-       {"amd64", "math/bits", "RotateLeft32"}:                     struct{}{},
-       {"amd64", "math/bits", "RotateLeft64"}:                     struct{}{},
-       {"amd64", "math/bits", "RotateLeft8"}:                      struct{}{},
-       {"amd64", "math/bits", "Sub"}:                              struct{}{},
-       {"amd64", "math/bits", "Sub64"}:                            struct{}{},
-       {"amd64", "math/bits", "TrailingZeros16"}:                  struct{}{},
-       {"amd64", "math/bits", "TrailingZeros32"}:                  struct{}{},
-       {"amd64", "math/bits", "TrailingZeros64"}:                  struct{}{},
-       {"amd64", "math/bits", "TrailingZeros8"}:                   struct{}{},
-       {"amd64", "runtime", "KeepAlive"}:                          struct{}{},
-       {"amd64", "runtime", "slicebytetostringtmp"}:               struct{}{},
-       {"amd64", "sync", "runtime_LoadAcquintptr"}:                struct{}{},
-       {"amd64", "sync", "runtime_StoreReluintptr"}:               struct{}{},
-       {"amd64", "sync/atomic", "AddInt32"}:                       struct{}{},
-       {"amd64", "sync/atomic", "AddInt64"}:                       struct{}{},
-       {"amd64", "sync/atomic", "AddUint32"}:                      struct{}{},
-       {"amd64", "sync/atomic", "AddUint64"}:                      struct{}{},
-       {"amd64", "sync/atomic", "AddUintptr"}:                     struct{}{},
-       {"amd64", "sync/atomic", "AndInt32"}:                       struct{}{},
-       {"amd64", "sync/atomic", "AndInt64"}:                       struct{}{},
-       {"amd64", "sync/atomic", "AndUint32"}:                      struct{}{},
-       {"amd64", "sync/atomic", "AndUint64"}:                      struct{}{},
-       {"amd64", "sync/atomic", "AndUintptr"}:                     struct{}{},
-       {"amd64", "sync/atomic", "CompareAndSwapInt32"}:            struct{}{},
-       {"amd64", "sync/atomic", "CompareAndSwapInt64"}:            struct{}{},
-       {"amd64", "sync/atomic", "CompareAndSwapUint32"}:           struct{}{},
-       {"amd64", "sync/atomic", "CompareAndSwapUint64"}:           struct{}{},
-       {"amd64", "sync/atomic", "CompareAndSwapUintptr"}:          struct{}{},
-       {"amd64", "sync/atomic", "LoadInt32"}:                      struct{}{},
-       {"amd64", "sync/atomic", "LoadInt64"}:                      struct{}{},
-       {"amd64", "sync/atomic", "LoadPointer"}:                    struct{}{},
-       {"amd64", "sync/atomic", "LoadUint32"}:                     struct{}{},
-       {"amd64", "sync/atomic", "LoadUint64"}:                     struct{}{},
-       {"amd64", "sync/atomic", "LoadUintptr"}:                    struct{}{},
-       {"amd64", "sync/atomic", "OrInt32"}:                        struct{}{},
-       {"amd64", "sync/atomic", "OrInt64"}:                        struct{}{},
-       {"amd64", "sync/atomic", "OrUint32"}:                       struct{}{},
-       {"amd64", "sync/atomic", "OrUint64"}:                       struct{}{},
-       {"amd64", "sync/atomic", "OrUintptr"}:                      struct{}{},
-       {"amd64", "sync/atomic", "StoreInt32"}:                     struct{}{},
-       {"amd64", "sync/atomic", "StoreInt64"}:                     struct{}{},
-       {"amd64", "sync/atomic", "StoreUint32"}:                    struct{}{},
-       {"amd64", "sync/atomic", "StoreUint64"}:                    struct{}{},
-       {"amd64", "sync/atomic", "StoreUintptr"}:                   struct{}{},
-       {"amd64", "sync/atomic", "SwapInt32"}:                      struct{}{},
-       {"amd64", "sync/atomic", "SwapInt64"}:                      struct{}{},
-       {"amd64", "sync/atomic", "SwapUint32"}:                     struct{}{},
-       {"amd64", "sync/atomic", "SwapUint64"}:                     struct{}{},
-       {"amd64", "sync/atomic", "SwapUintptr"}:                    struct{}{},
-       {"arm", "internal/runtime/sys", "Bswap32"}:                 struct{}{},
-       {"arm", "internal/runtime/sys", "Bswap64"}:                 struct{}{},
-       {"arm", "internal/runtime/sys", "GetCallerPC"}:             struct{}{},
-       {"arm", "internal/runtime/sys", "GetCallerSP"}:             struct{}{},
-       {"arm", "internal/runtime/sys", "GetClosurePtr"}:           struct{}{},
-       {"arm", "internal/runtime/sys", "Len64"}:                   struct{}{},
-       {"arm", "internal/runtime/sys", "Len8"}:                    struct{}{},
-       {"arm", "internal/runtime/sys", "TrailingZeros32"}:         struct{}{},
-       {"arm", "internal/runtime/sys", "TrailingZeros64"}:         struct{}{},
-       {"arm", "internal/runtime/sys", "TrailingZeros8"}:          struct{}{},
-       {"arm", "math", "Abs"}:                                     struct{}{},
-       {"arm", "math", "FMA"}:                                     struct{}{},
-       {"arm", "math", "sqrt"}:                                    struct{}{},
-       {"arm", "math/bits", "Len"}:                                struct{}{},
-       {"arm", "math/bits", "Len16"}:                              struct{}{},
-       {"arm", "math/bits", "Len32"}:                              struct{}{},
-       {"arm", "math/bits", "Len64"}:                              struct{}{},
-       {"arm", "math/bits", "Len8"}:                               struct{}{},
-       {"arm", "math/bits", "ReverseBytes32"}:                     struct{}{},
-       {"arm", "math/bits", "ReverseBytes64"}:                     struct{}{},
-       {"arm", "math/bits", "RotateLeft32"}:                       struct{}{},
-       {"arm", "math/bits", "TrailingZeros16"}:                    struct{}{},
-       {"arm", "math/bits", "TrailingZeros32"}:                    struct{}{},
-       {"arm", "math/bits", "TrailingZeros64"}:                    struct{}{},
-       {"arm", "math/bits", "TrailingZeros8"}:                     struct{}{},
-       {"arm", "runtime", "KeepAlive"}:                            struct{}{},
-       {"arm", "runtime", "slicebytetostringtmp"}:                 struct{}{},
-       {"arm64", "internal/runtime/atomic", "And"}:                struct{}{},
-       {"arm64", "internal/runtime/atomic", "And32"}:              struct{}{},
-       {"arm64", "internal/runtime/atomic", "And64"}:              struct{}{},
-       {"arm64", "internal/runtime/atomic", "And8"}:               struct{}{},
-       {"arm64", "internal/runtime/atomic", "Anduintptr"}:         struct{}{},
-       {"arm64", "internal/runtime/atomic", "Cas"}:                struct{}{},
-       {"arm64", "internal/runtime/atomic", "Cas64"}:              struct{}{},
-       {"arm64", "internal/runtime/atomic", "CasRel"}:             struct{}{},
-       {"arm64", "internal/runtime/atomic", "Casint32"}:           struct{}{},
-       {"arm64", "internal/runtime/atomic", "Casint64"}:           struct{}{},
-       {"arm64", "internal/runtime/atomic", "Casp1"}:              struct{}{},
-       {"arm64", "internal/runtime/atomic", "Casuintptr"}:         struct{}{},
-       {"arm64", "internal/runtime/atomic", "Load"}:               struct{}{},
-       {"arm64", "internal/runtime/atomic", "Load64"}:             struct{}{},
-       {"arm64", "internal/runtime/atomic", "Load8"}:              struct{}{},
-       {"arm64", "internal/runtime/atomic", "LoadAcq"}:            struct{}{},
-       {"arm64", "internal/runtime/atomic", "LoadAcq64"}:          struct{}{},
-       {"arm64", "internal/runtime/atomic", "LoadAcquintptr"}:     struct{}{},
-       {"arm64", "internal/runtime/atomic", "Loadint32"}:          struct{}{},
-       {"arm64", "internal/runtime/atomic", "Loadint64"}:          struct{}{},
-       {"arm64", "internal/runtime/atomic", "Loadp"}:              struct{}{},
-       {"arm64", "internal/runtime/atomic", "Loaduint"}:           struct{}{},
-       {"arm64", "internal/runtime/atomic", "Loaduintptr"}:        struct{}{},
-       {"arm64", "internal/runtime/atomic", "Or"}:                 struct{}{},
-       {"arm64", "internal/runtime/atomic", "Or32"}:               struct{}{},
-       {"arm64", "internal/runtime/atomic", "Or64"}:               struct{}{},
-       {"arm64", "internal/runtime/atomic", "Or8"}:                struct{}{},
-       {"arm64", "internal/runtime/atomic", "Oruintptr"}:          struct{}{},
-       {"arm64", "internal/runtime/atomic", "Store"}:              struct{}{},
-       {"arm64", "internal/runtime/atomic", "Store64"}:            struct{}{},
-       {"arm64", "internal/runtime/atomic", "Store8"}:             struct{}{},
-       {"arm64", "internal/runtime/atomic", "StoreRel"}:           struct{}{},
-       {"arm64", "internal/runtime/atomic", "StoreRel64"}:         struct{}{},
-       {"arm64", "internal/runtime/atomic", "StoreReluintptr"}:    struct{}{},
-       {"arm64", "internal/runtime/atomic", "Storeint32"}:         struct{}{},
-       {"arm64", "internal/runtime/atomic", "Storeint64"}:         struct{}{},
-       {"arm64", "internal/runtime/atomic", "StorepNoWB"}:         struct{}{},
-       {"arm64", "internal/runtime/atomic", "Storeuintptr"}:       struct{}{},
-       {"arm64", "internal/runtime/atomic", "Xadd"}:               struct{}{},
-       {"arm64", "internal/runtime/atomic", "Xadd64"}:             struct{}{},
-       {"arm64", "internal/runtime/atomic", "Xaddint32"}:          struct{}{},
-       {"arm64", "internal/runtime/atomic", "Xaddint64"}:          struct{}{},
-       {"arm64", "internal/runtime/atomic", "Xadduintptr"}:        struct{}{},
-       {"arm64", "internal/runtime/atomic", "Xchg8"}:              struct{}{},
-       {"arm64", "internal/runtime/atomic", "Xchg"}:               struct{}{},
-       {"arm64", "internal/runtime/atomic", "Xchg64"}:             struct{}{},
-       {"arm64", "internal/runtime/atomic", "Xchgint32"}:          struct{}{},
-       {"arm64", "internal/runtime/atomic", "Xchgint64"}:          struct{}{},
-       {"arm64", "internal/runtime/atomic", "Xchguintptr"}:        struct{}{},
-       {"arm64", "internal/runtime/math", "Add64"}:                struct{}{},
-       {"arm64", "internal/runtime/math", "Mul64"}:                struct{}{},
-       {"arm64", "internal/runtime/math", "MulUintptr"}:           struct{}{},
-       {"arm64", "internal/runtime/sys", "Bswap32"}:               struct{}{},
-       {"arm64", "internal/runtime/sys", "Bswap64"}:               struct{}{},
-       {"arm64", "internal/runtime/sys", "GetCallerPC"}:           struct{}{},
-       {"arm64", "internal/runtime/sys", "GetCallerSP"}:           struct{}{},
-       {"arm64", "internal/runtime/sys", "GetClosurePtr"}:         struct{}{},
-       {"arm64", "internal/runtime/sys", "Len64"}:                 struct{}{},
-       {"arm64", "internal/runtime/sys", "Len8"}:                  struct{}{},
-       {"arm64", "internal/runtime/sys", "OnesCount64"}:           struct{}{},
-       {"arm64", "internal/runtime/sys", "Prefetch"}:              struct{}{},
-       {"arm64", "internal/runtime/sys", "PrefetchStreamed"}:      struct{}{},
-       {"arm64", "internal/runtime/sys", "TrailingZeros32"}:       struct{}{},
-       {"arm64", "internal/runtime/sys", "TrailingZeros64"}:       struct{}{},
-       {"arm64", "internal/runtime/sys", "TrailingZeros8"}:        struct{}{},
-       {"arm64", "math", "Abs"}:                                   struct{}{},
-       {"arm64", "math", "Ceil"}:                                  struct{}{},
-       {"arm64", "math", "FMA"}:                                   struct{}{},
-       {"arm64", "math", "Floor"}:                                 struct{}{},
-       {"arm64", "math", "Round"}:                                 struct{}{},
-       {"arm64", "math", "RoundToEven"}:                           struct{}{},
-       {"arm64", "math", "Trunc"}:                                 struct{}{},
-       {"arm64", "math", "sqrt"}:                                  struct{}{},
-       {"arm64", "math/big", "mulWW"}:                             struct{}{},
-       {"arm64", "math/bits", "Add"}:                              struct{}{},
-       {"arm64", "math/bits", "Add64"}:                            struct{}{},
-       {"arm64", "math/bits", "Len"}:                              struct{}{},
-       {"arm64", "math/bits", "Len16"}:                            struct{}{},
-       {"arm64", "math/bits", "Len32"}:                            struct{}{},
-       {"arm64", "math/bits", "Len64"}:                            struct{}{},
-       {"arm64", "math/bits", "Len8"}:                             struct{}{},
-       {"arm64", "math/bits", "Mul"}:                              struct{}{},
-       {"arm64", "math/bits", "Mul64"}:                            struct{}{},
-       {"arm64", "math/bits", "OnesCount16"}:                      struct{}{},
-       {"arm64", "math/bits", "OnesCount32"}:                      struct{}{},
-       {"arm64", "math/bits", "OnesCount64"}:                      struct{}{},
-       {"arm64", "math/bits", "Reverse"}:                          struct{}{},
-       {"arm64", "math/bits", "Reverse16"}:                        struct{}{},
-       {"arm64", "math/bits", "Reverse32"}:                        struct{}{},
-       {"arm64", "math/bits", "Reverse64"}:                        struct{}{},
-       {"arm64", "math/bits", "Reverse8"}:                         struct{}{},
-       {"arm64", "math/bits", "ReverseBytes32"}:                   struct{}{},
-       {"arm64", "math/bits", "ReverseBytes64"}:                   struct{}{},
-       {"arm64", "math/bits", "RotateLeft"}:                       struct{}{},
-       {"arm64", "math/bits", "RotateLeft32"}:                     struct{}{},
-       {"arm64", "math/bits", "RotateLeft64"}:                     struct{}{},
-       {"arm64", "math/bits", "Sub"}:                              struct{}{},
-       {"arm64", "math/bits", "Sub64"}:                            struct{}{},
-       {"arm64", "math/bits", "TrailingZeros16"}:                  struct{}{},
-       {"arm64", "math/bits", "TrailingZeros32"}:                  struct{}{},
-       {"arm64", "math/bits", "TrailingZeros64"}:                  struct{}{},
-       {"arm64", "math/bits", "TrailingZeros8"}:                   struct{}{},
-       {"arm64", "runtime", "KeepAlive"}:                          struct{}{},
-       {"arm64", "runtime", "publicationBarrier"}:                 struct{}{},
-       {"arm64", "runtime", "slicebytetostringtmp"}:               struct{}{},
-       {"arm64", "sync", "runtime_LoadAcquintptr"}:                struct{}{},
-       {"arm64", "sync", "runtime_StoreReluintptr"}:               struct{}{},
-       {"arm64", "sync/atomic", "AddInt32"}:                       struct{}{},
-       {"arm64", "sync/atomic", "AddInt64"}:                       struct{}{},
-       {"arm64", "sync/atomic", "AddUint32"}:                      struct{}{},
-       {"arm64", "sync/atomic", "AddUint64"}:                      struct{}{},
-       {"arm64", "sync/atomic", "AddUintptr"}:                     struct{}{},
-       {"arm64", "sync/atomic", "AndInt32"}:                       struct{}{},
-       {"arm64", "sync/atomic", "AndInt64"}:                       struct{}{},
-       {"arm64", "sync/atomic", "AndUint32"}:                      struct{}{},
-       {"arm64", "sync/atomic", "AndUint64"}:                      struct{}{},
-       {"arm64", "sync/atomic", "AndUintptr"}:                     struct{}{},
-       {"arm64", "sync/atomic", "CompareAndSwapInt32"}:            struct{}{},
-       {"arm64", "sync/atomic", "CompareAndSwapInt64"}:            struct{}{},
-       {"arm64", "sync/atomic", "CompareAndSwapUint32"}:           struct{}{},
-       {"arm64", "sync/atomic", "CompareAndSwapUint64"}:           struct{}{},
-       {"arm64", "sync/atomic", "CompareAndSwapUintptr"}:          struct{}{},
-       {"arm64", "sync/atomic", "LoadInt32"}:                      struct{}{},
-       {"arm64", "sync/atomic", "LoadInt64"}:                      struct{}{},
-       {"arm64", "sync/atomic", "LoadPointer"}:                    struct{}{},
-       {"arm64", "sync/atomic", "LoadUint32"}:                     struct{}{},
-       {"arm64", "sync/atomic", "LoadUint64"}:                     struct{}{},
-       {"arm64", "sync/atomic", "LoadUintptr"}:                    struct{}{},
-       {"arm64", "sync/atomic", "OrInt32"}:                        struct{}{},
-       {"arm64", "sync/atomic", "OrInt64"}:                        struct{}{},
-       {"arm64", "sync/atomic", "OrUint32"}:                       struct{}{},
-       {"arm64", "sync/atomic", "OrUint64"}:                       struct{}{},
-       {"arm64", "sync/atomic", "OrUintptr"}:                      struct{}{},
-       {"arm64", "sync/atomic", "StoreInt32"}:                     struct{}{},
-       {"arm64", "sync/atomic", "StoreInt64"}:                     struct{}{},
-       {"arm64", "sync/atomic", "StoreUint32"}:                    struct{}{},
-       {"arm64", "sync/atomic", "StoreUint64"}:                    struct{}{},
-       {"arm64", "sync/atomic", "StoreUintptr"}:                   struct{}{},
-       {"arm64", "sync/atomic", "SwapInt32"}:                      struct{}{},
-       {"arm64", "sync/atomic", "SwapInt64"}:                      struct{}{},
-       {"arm64", "sync/atomic", "SwapUint32"}:                     struct{}{},
-       {"arm64", "sync/atomic", "SwapUint64"}:                     struct{}{},
-       {"arm64", "sync/atomic", "SwapUintptr"}:                    struct{}{},
-       {"loong64", "internal/runtime/atomic", "And"}:              struct{}{},
-       {"loong64", "internal/runtime/atomic", "And32"}:            struct{}{},
-       {"loong64", "internal/runtime/atomic", "And64"}:            struct{}{},
-       {"loong64", "internal/runtime/atomic", "And8"}:             struct{}{},
-       {"loong64", "internal/runtime/atomic", "Anduintptr"}:       struct{}{},
-       {"loong64", "internal/runtime/atomic", "Cas"}:              struct{}{},
-       {"loong64", "internal/runtime/atomic", "Cas64"}:            struct{}{},
-       {"loong64", "internal/runtime/atomic", "CasRel"}:           struct{}{},
-       {"loong64", "internal/runtime/atomic", "Casint32"}:         struct{}{},
-       {"loong64", "internal/runtime/atomic", "Casint64"}:         struct{}{},
-       {"loong64", "internal/runtime/atomic", "Casp1"}:            struct{}{},
-       {"loong64", "internal/runtime/atomic", "Casuintptr"}:       struct{}{},
-       {"loong64", "internal/runtime/atomic", "Load"}:             struct{}{},
-       {"loong64", "internal/runtime/atomic", "Load64"}:           struct{}{},
-       {"loong64", "internal/runtime/atomic", "Load8"}:            struct{}{},
-       {"loong64", "internal/runtime/atomic", "LoadAcq"}:          struct{}{},
-       {"loong64", "internal/runtime/atomic", "LoadAcq64"}:        struct{}{},
-       {"loong64", "internal/runtime/atomic", "LoadAcquintptr"}:   struct{}{},
-       {"loong64", "internal/runtime/atomic", "Loadint32"}:        struct{}{},
-       {"loong64", "internal/runtime/atomic", "Loadint64"}:        struct{}{},
-       {"loong64", "internal/runtime/atomic", "Loadp"}:            struct{}{},
-       {"loong64", "internal/runtime/atomic", "Loaduint"}:         struct{}{},
-       {"loong64", "internal/runtime/atomic", "Loaduintptr"}:      struct{}{},
-       {"loong64", "internal/runtime/atomic", "Or"}:               struct{}{},
-       {"loong64", "internal/runtime/atomic", "Or32"}:             struct{}{},
-       {"loong64", "internal/runtime/atomic", "Or64"}:             struct{}{},
-       {"loong64", "internal/runtime/atomic", "Or8"}:              struct{}{},
-       {"loong64", "internal/runtime/atomic", "Oruintptr"}:        struct{}{},
-       {"loong64", "internal/runtime/atomic", "Store"}:            struct{}{},
-       {"loong64", "internal/runtime/atomic", "Store64"}:          struct{}{},
-       {"loong64", "internal/runtime/atomic", "Store8"}:           struct{}{},
-       {"loong64", "internal/runtime/atomic", "StoreRel"}:         struct{}{},
-       {"loong64", "internal/runtime/atomic", "StoreRel64"}:       struct{}{},
-       {"loong64", "internal/runtime/atomic", "StoreReluintptr"}:  struct{}{},
-       {"loong64", "internal/runtime/atomic", "Storeint32"}:       struct{}{},
-       {"loong64", "internal/runtime/atomic", "Storeint64"}:       struct{}{},
-       {"loong64", "internal/runtime/atomic", "StorepNoWB"}:       struct{}{},
-       {"loong64", "internal/runtime/atomic", "Storeuintptr"}:     struct{}{},
-       {"loong64", "internal/runtime/atomic", "Xadd"}:             struct{}{},
-       {"loong64", "internal/runtime/atomic", "Xadd64"}:           struct{}{},
-       {"loong64", "internal/runtime/atomic", "Xaddint32"}:        struct{}{},
-       {"loong64", "internal/runtime/atomic", "Xaddint64"}:        struct{}{},
-       {"loong64", "internal/runtime/atomic", "Xadduintptr"}:      struct{}{},
-       {"loong64", "internal/runtime/atomic", "Xchg8"}:            struct{}{},
-       {"loong64", "internal/runtime/atomic", "Xchg"}:             struct{}{},
-       {"loong64", "internal/runtime/atomic", "Xchg64"}:           struct{}{},
-       {"loong64", "internal/runtime/atomic", "Xchgint32"}:        struct{}{},
-       {"loong64", "internal/runtime/atomic", "Xchgint64"}:        struct{}{},
-       {"loong64", "internal/runtime/atomic", "Xchguintptr"}:      struct{}{},
-       {"loong64", "internal/runtime/math", "Add64"}:              struct{}{},
-       {"loong64", "internal/runtime/math", "Mul64"}:              struct{}{},
-       {"loong64", "internal/runtime/math", "MulUintptr"}:         struct{}{},
-       {"loong64", "internal/runtime/sys", "Bswap32"}:             struct{}{},
-       {"loong64", "internal/runtime/sys", "Bswap64"}:             struct{}{},
-       {"loong64", "internal/runtime/sys", "GetCallerPC"}:         struct{}{},
-       {"loong64", "internal/runtime/sys", "GetCallerSP"}:         struct{}{},
-       {"loong64", "internal/runtime/sys", "GetClosurePtr"}:       struct{}{},
-       {"loong64", "internal/runtime/sys", "Len64"}:               struct{}{},
-       {"loong64", "internal/runtime/sys", "Len8"}:                struct{}{},
-       {"loong64", "internal/runtime/sys", "OnesCount64"}:         struct{}{},
-       {"loong64", "internal/runtime/sys", "TrailingZeros32"}:     struct{}{},
-       {"loong64", "internal/runtime/sys", "TrailingZeros64"}:     struct{}{},
-       {"loong64", "internal/runtime/sys", "TrailingZeros8"}:      struct{}{},
-       {"loong64", "math", "Abs"}:                                 struct{}{},
-       {"loong64", "math", "Copysign"}:                            struct{}{},
-       {"loong64", "math", "FMA"}:                                 struct{}{},
-       {"loong64", "math", "sqrt"}:                                struct{}{},
-       {"loong64", "math/big", "mulWW"}:                           struct{}{},
-       {"loong64", "math/bits", "Add"}:                            struct{}{},
-       {"loong64", "math/bits", "Add64"}:                          struct{}{},
-       {"loong64", "math/bits", "Mul"}:                            struct{}{},
-       {"loong64", "math/bits", "Mul64"}:                          struct{}{},
-       {"loong64", "math/bits", "Len"}:                            struct{}{},
-       {"loong64", "math/bits", "Len8"}:                           struct{}{},
-       {"loong64", "math/bits", "Len16"}:                          struct{}{},
-       {"loong64", "math/bits", "Len32"}:                          struct{}{},
-       {"loong64", "math/bits", "Len64"}:                          struct{}{},
-       {"loong64", "math/bits", "OnesCount16"}:                    struct{}{},
-       {"loong64", "math/bits", "OnesCount32"}:                    struct{}{},
-       {"loong64", "math/bits", "OnesCount64"}:                    struct{}{},
-       {"loong64", "math/bits", "Reverse"}:                        struct{}{},
-       {"loong64", "math/bits", "Reverse8"}:                       struct{}{},
-       {"loong64", "math/bits", "Reverse16"}:                      struct{}{},
-       {"loong64", "math/bits", "Reverse32"}:                      struct{}{},
-       {"loong64", "math/bits", "Reverse64"}:                      struct{}{},
-       {"loong64", "math/bits", "RotateLeft"}:                     struct{}{},
-       {"loong64", "math/bits", "RotateLeft32"}:                   struct{}{},
-       {"loong64", "math/bits", "RotateLeft64"}:                   struct{}{},
-       {"loong64", "math/bits", "ReverseBytes16"}:                 struct{}{},
-       {"loong64", "math/bits", "ReverseBytes32"}:                 struct{}{},
-       {"loong64", "math/bits", "ReverseBytes64"}:                 struct{}{},
-       {"loong64", "math/bits", "TrailingZeros16"}:                struct{}{},
-       {"loong64", "math/bits", "TrailingZeros32"}:                struct{}{},
-       {"loong64", "math/bits", "TrailingZeros64"}:                struct{}{},
-       {"loong64", "math/bits", "TrailingZeros8"}:                 struct{}{},
-       {"loong64", "math/bits", "Sub"}:                            struct{}{},
-       {"loong64", "math/bits", "Sub64"}:                          struct{}{},
-       {"loong64", "runtime", "KeepAlive"}:                        struct{}{},
-       {"loong64", "runtime", "publicationBarrier"}:               struct{}{},
-       {"loong64", "runtime", "slicebytetostringtmp"}:             struct{}{},
-       {"loong64", "sync", "runtime_LoadAcquintptr"}:              struct{}{},
-       {"loong64", "sync", "runtime_StoreReluintptr"}:             struct{}{},
-       {"loong64", "sync/atomic", "AddInt32"}:                     struct{}{},
-       {"loong64", "sync/atomic", "AddInt64"}:                     struct{}{},
-       {"loong64", "sync/atomic", "AddUint32"}:                    struct{}{},
-       {"loong64", "sync/atomic", "AddUint64"}:                    struct{}{},
-       {"loong64", "sync/atomic", "AddUintptr"}:                   struct{}{},
-       {"loong64", "sync/atomic", "AddInt32"}:                     struct{}{},
-       {"loong64", "sync/atomic", "AddInt64"}:                     struct{}{},
-       {"loong64", "sync/atomic", "AddUint32"}:                    struct{}{},
-       {"loong64", "sync/atomic", "AddUint64"}:                    struct{}{},
-       {"loong64", "sync/atomic", "AddUintptr"}:                   struct{}{},
-       {"loong64", "sync/atomic", "AndInt32"}:                     struct{}{},
-       {"loong64", "sync/atomic", "AndInt64"}:                     struct{}{},
-       {"loong64", "sync/atomic", "AndUint32"}:                    struct{}{},
-       {"loong64", "sync/atomic", "AndUint64"}:                    struct{}{},
-       {"loong64", "sync/atomic", "AndUintptr"}:                   struct{}{},
-       {"loong64", "sync/atomic", "CompareAndSwapInt32"}:          struct{}{},
-       {"loong64", "sync/atomic", "CompareAndSwapInt64"}:          struct{}{},
-       {"loong64", "sync/atomic", "CompareAndSwapUint32"}:         struct{}{},
-       {"loong64", "sync/atomic", "CompareAndSwapUint64"}:         struct{}{},
-       {"loong64", "sync/atomic", "CompareAndSwapUintptr"}:        struct{}{},
-       {"loong64", "sync/atomic", "LoadInt32"}:                    struct{}{},
-       {"loong64", "sync/atomic", "LoadInt64"}:                    struct{}{},
-       {"loong64", "sync/atomic", "LoadPointer"}:                  struct{}{},
-       {"loong64", "sync/atomic", "LoadUint32"}:                   struct{}{},
-       {"loong64", "sync/atomic", "LoadUint64"}:                   struct{}{},
-       {"loong64", "sync/atomic", "LoadUintptr"}:                  struct{}{},
-       {"loong64", "sync/atomic", "OrInt32"}:                      struct{}{},
-       {"loong64", "sync/atomic", "OrInt64"}:                      struct{}{},
-       {"loong64", "sync/atomic", "OrUint32"}:                     struct{}{},
-       {"loong64", "sync/atomic", "OrUint64"}:                     struct{}{},
-       {"loong64", "sync/atomic", "OrUintptr"}:                    struct{}{},
-       {"loong64", "sync/atomic", "StoreInt32"}:                   struct{}{},
-       {"loong64", "sync/atomic", "StoreInt64"}:                   struct{}{},
-       {"loong64", "sync/atomic", "StoreUint32"}:                  struct{}{},
-       {"loong64", "sync/atomic", "StoreUint64"}:                  struct{}{},
-       {"loong64", "sync/atomic", "StoreUintptr"}:                 struct{}{},
-       {"loong64", "sync/atomic", "SwapInt32"}:                    struct{}{},
-       {"loong64", "sync/atomic", "SwapInt64"}:                    struct{}{},
-       {"loong64", "sync/atomic", "SwapUint32"}:                   struct{}{},
-       {"loong64", "sync/atomic", "SwapUint64"}:                   struct{}{},
-       {"loong64", "sync/atomic", "SwapUintptr"}:                  struct{}{},
-       {"mips", "internal/runtime/atomic", "And"}:                 struct{}{},
-       {"mips", "internal/runtime/atomic", "And8"}:                struct{}{},
-       {"mips", "internal/runtime/atomic", "Cas"}:                 struct{}{},
-       {"mips", "internal/runtime/atomic", "CasRel"}:              struct{}{},
-       {"mips", "internal/runtime/atomic", "Casint32"}:            struct{}{},
-       {"mips", "internal/runtime/atomic", "Casp1"}:               struct{}{},
-       {"mips", "internal/runtime/atomic", "Casuintptr"}:          struct{}{},
-       {"mips", "internal/runtime/atomic", "Load"}:                struct{}{},
-       {"mips", "internal/runtime/atomic", "Load8"}:               struct{}{},
-       {"mips", "internal/runtime/atomic", "LoadAcq"}:             struct{}{},
-       {"mips", "internal/runtime/atomic", "LoadAcquintptr"}:      struct{}{},
-       {"mips", "internal/runtime/atomic", "Loadint32"}:           struct{}{},
-       {"mips", "internal/runtime/atomic", "Loadp"}:               struct{}{},
-       {"mips", "internal/runtime/atomic", "Loaduint"}:            struct{}{},
-       {"mips", "internal/runtime/atomic", "Loaduintptr"}:         struct{}{},
-       {"mips", "internal/runtime/atomic", "Or"}:                  struct{}{},
-       {"mips", "internal/runtime/atomic", "Or8"}:                 struct{}{},
-       {"mips", "internal/runtime/atomic", "Store"}:               struct{}{},
-       {"mips", "internal/runtime/atomic", "Store8"}:              struct{}{},
-       {"mips", "internal/runtime/atomic", "StoreRel"}:            struct{}{},
-       {"mips", "internal/runtime/atomic", "StoreReluintptr"}:     struct{}{},
-       {"mips", "internal/runtime/atomic", "Storeint32"}:          struct{}{},
-       {"mips", "internal/runtime/atomic", "StorepNoWB"}:          struct{}{},
-       {"mips", "internal/runtime/atomic", "Storeuintptr"}:        struct{}{},
-       {"mips", "internal/runtime/atomic", "Xadd"}:                struct{}{},
-       {"mips", "internal/runtime/atomic", "Xaddint32"}:           struct{}{},
-       {"mips", "internal/runtime/atomic", "Xadduintptr"}:         struct{}{},
-       {"mips", "internal/runtime/atomic", "Xchg"}:                struct{}{},
-       {"mips", "internal/runtime/atomic", "Xchgint32"}:           struct{}{},
-       {"mips", "internal/runtime/atomic", "Xchguintptr"}:         struct{}{},
-       {"mips", "internal/runtime/sys", "GetCallerPC"}:            struct{}{},
-       {"mips", "internal/runtime/sys", "GetCallerSP"}:            struct{}{},
-       {"mips", "internal/runtime/sys", "GetClosurePtr"}:          struct{}{},
-       {"mips", "internal/runtime/sys", "Len64"}:                  struct{}{},
-       {"mips", "internal/runtime/sys", "Len8"}:                   struct{}{},
-       {"mips", "internal/runtime/sys", "TrailingZeros32"}:        struct{}{},
-       {"mips", "internal/runtime/sys", "TrailingZeros64"}:        struct{}{},
-       {"mips", "internal/runtime/sys", "TrailingZeros8"}:         struct{}{},
-       {"mips", "math", "Abs"}:                                    struct{}{},
-       {"mips", "math", "sqrt"}:                                   struct{}{},
-       {"mips", "math/bits", "Len"}:                               struct{}{},
-       {"mips", "math/bits", "Len16"}:                             struct{}{},
-       {"mips", "math/bits", "Len32"}:                             struct{}{},
-       {"mips", "math/bits", "Len64"}:                             struct{}{},
-       {"mips", "math/bits", "Len8"}:                              struct{}{},
-       {"mips", "math/bits", "TrailingZeros16"}:                   struct{}{},
-       {"mips", "math/bits", "TrailingZeros32"}:                   struct{}{},
-       {"mips", "math/bits", "TrailingZeros64"}:                   struct{}{},
-       {"mips", "math/bits", "TrailingZeros8"}:                    struct{}{},
-       {"mips", "runtime", "KeepAlive"}:                           struct{}{},
-       {"mips", "runtime", "slicebytetostringtmp"}:                struct{}{},
-       {"mips", "sync", "runtime_LoadAcquintptr"}:                 struct{}{},
-       {"mips", "sync", "runtime_StoreReluintptr"}:                struct{}{},
-       {"mips", "sync/atomic", "AddInt32"}:                        struct{}{},
-       {"mips", "sync/atomic", "AddUint32"}:                       struct{}{},
-       {"mips", "sync/atomic", "AddUintptr"}:                      struct{}{},
-       {"mips", "sync/atomic", "CompareAndSwapInt32"}:             struct{}{},
-       {"mips", "sync/atomic", "CompareAndSwapUint32"}:            struct{}{},
-       {"mips", "sync/atomic", "CompareAndSwapUintptr"}:           struct{}{},
-       {"mips", "sync/atomic", "LoadInt32"}:                       struct{}{},
-       {"mips", "sync/atomic", "LoadPointer"}:                     struct{}{},
-       {"mips", "sync/atomic", "LoadUint32"}:                      struct{}{},
-       {"mips", "sync/atomic", "LoadUintptr"}:                     struct{}{},
-       {"mips", "sync/atomic", "StoreInt32"}:                      struct{}{},
-       {"mips", "sync/atomic", "StoreUint32"}:                     struct{}{},
-       {"mips", "sync/atomic", "StoreUintptr"}:                    struct{}{},
-       {"mips", "sync/atomic", "SwapInt32"}:                       struct{}{},
-       {"mips", "sync/atomic", "SwapUint32"}:                      struct{}{},
-       {"mips", "sync/atomic", "SwapUintptr"}:                     struct{}{},
-       {"mips64", "internal/runtime/atomic", "And"}:               struct{}{},
-       {"mips64", "internal/runtime/atomic", "And8"}:              struct{}{},
-       {"mips64", "internal/runtime/atomic", "Cas"}:               struct{}{},
-       {"mips64", "internal/runtime/atomic", "Cas64"}:             struct{}{},
-       {"mips64", "internal/runtime/atomic", "CasRel"}:            struct{}{},
-       {"mips64", "internal/runtime/atomic", "Casint32"}:          struct{}{},
-       {"mips64", "internal/runtime/atomic", "Casint64"}:          struct{}{},
-       {"mips64", "internal/runtime/atomic", "Casp1"}:             struct{}{},
-       {"mips64", "internal/runtime/atomic", "Casuintptr"}:        struct{}{},
-       {"mips64", "internal/runtime/atomic", "Load"}:              struct{}{},
-       {"mips64", "internal/runtime/atomic", "Load64"}:            struct{}{},
-       {"mips64", "internal/runtime/atomic", "Load8"}:             struct{}{},
-       {"mips64", "internal/runtime/atomic", "LoadAcq"}:           struct{}{},
-       {"mips64", "internal/runtime/atomic", "LoadAcq64"}:         struct{}{},
-       {"mips64", "internal/runtime/atomic", "LoadAcquintptr"}:    struct{}{},
-       {"mips64", "internal/runtime/atomic", "Loadint32"}:         struct{}{},
-       {"mips64", "internal/runtime/atomic", "Loadint64"}:         struct{}{},
-       {"mips64", "internal/runtime/atomic", "Loadp"}:             struct{}{},
-       {"mips64", "internal/runtime/atomic", "Loaduint"}:          struct{}{},
-       {"mips64", "internal/runtime/atomic", "Loaduintptr"}:       struct{}{},
-       {"mips64", "internal/runtime/atomic", "Or"}:                struct{}{},
-       {"mips64", "internal/runtime/atomic", "Or8"}:               struct{}{},
-       {"mips64", "internal/runtime/atomic", "Store"}:             struct{}{},
-       {"mips64", "internal/runtime/atomic", "Store64"}:           struct{}{},
-       {"mips64", "internal/runtime/atomic", "Store8"}:            struct{}{},
-       {"mips64", "internal/runtime/atomic", "StoreRel"}:          struct{}{},
-       {"mips64", "internal/runtime/atomic", "StoreRel64"}:        struct{}{},
-       {"mips64", "internal/runtime/atomic", "StoreReluintptr"}:   struct{}{},
-       {"mips64", "internal/runtime/atomic", "Storeint32"}:        struct{}{},
-       {"mips64", "internal/runtime/atomic", "Storeint64"}:        struct{}{},
-       {"mips64", "internal/runtime/atomic", "StorepNoWB"}:        struct{}{},
-       {"mips64", "internal/runtime/atomic", "Storeuintptr"}:      struct{}{},
-       {"mips64", "internal/runtime/atomic", "Xadd"}:              struct{}{},
-       {"mips64", "internal/runtime/atomic", "Xadd64"}:            struct{}{},
-       {"mips64", "internal/runtime/atomic", "Xaddint32"}:         struct{}{},
-       {"mips64", "internal/runtime/atomic", "Xaddint64"}:         struct{}{},
-       {"mips64", "internal/runtime/atomic", "Xadduintptr"}:       struct{}{},
-       {"mips64", "internal/runtime/atomic", "Xchg"}:              struct{}{},
-       {"mips64", "internal/runtime/atomic", "Xchg64"}:            struct{}{},
-       {"mips64", "internal/runtime/atomic", "Xchgint32"}:         struct{}{},
-       {"mips64", "internal/runtime/atomic", "Xchgint64"}:         struct{}{},
-       {"mips64", "internal/runtime/atomic", "Xchguintptr"}:       struct{}{},
-       {"mips64", "internal/runtime/math", "Add64"}:               struct{}{},
-       {"mips64", "internal/runtime/math", "Mul64"}:               struct{}{},
-       {"mips64", "internal/runtime/math", "MulUintptr"}:          struct{}{},
-       {"mips64", "internal/runtime/sys", "GetCallerPC"}:          struct{}{},
-       {"mips64", "internal/runtime/sys", "GetCallerSP"}:          struct{}{},
-       {"mips64", "internal/runtime/sys", "GetClosurePtr"}:        struct{}{},
-       {"mips64", "math", "Abs"}:                                  struct{}{},
-       {"mips64", "math", "sqrt"}:                                 struct{}{},
-       {"mips64", "math/big", "mulWW"}:                            struct{}{},
-       {"mips64", "math/bits", "Add"}:                             struct{}{},
-       {"mips64", "math/bits", "Add64"}:                           struct{}{},
-       {"mips64", "math/bits", "Mul"}:                             struct{}{},
-       {"mips64", "math/bits", "Mul64"}:                           struct{}{},
-       {"mips64", "math/bits", "Sub"}:                             struct{}{},
-       {"mips64", "math/bits", "Sub64"}:                           struct{}{},
-       {"mips64", "runtime", "KeepAlive"}:                         struct{}{},
-       {"mips64", "runtime", "slicebytetostringtmp"}:              struct{}{},
-       {"mips64", "sync", "runtime_LoadAcquintptr"}:               struct{}{},
-       {"mips64", "sync", "runtime_StoreReluintptr"}:              struct{}{},
-       {"mips64", "sync/atomic", "AddInt32"}:                      struct{}{},
-       {"mips64", "sync/atomic", "AddInt64"}:                      struct{}{},
-       {"mips64", "sync/atomic", "AddUint32"}:                     struct{}{},
-       {"mips64", "sync/atomic", "AddUint64"}:                     struct{}{},
-       {"mips64", "sync/atomic", "AddUintptr"}:                    struct{}{},
-       {"mips64", "sync/atomic", "CompareAndSwapInt32"}:           struct{}{},
-       {"mips64", "sync/atomic", "CompareAndSwapInt64"}:           struct{}{},
-       {"mips64", "sync/atomic", "CompareAndSwapUint32"}:          struct{}{},
-       {"mips64", "sync/atomic", "CompareAndSwapUint64"}:          struct{}{},
-       {"mips64", "sync/atomic", "CompareAndSwapUintptr"}:         struct{}{},
-       {"mips64", "sync/atomic", "LoadInt32"}:                     struct{}{},
-       {"mips64", "sync/atomic", "LoadInt64"}:                     struct{}{},
-       {"mips64", "sync/atomic", "LoadPointer"}:                   struct{}{},
-       {"mips64", "sync/atomic", "LoadUint32"}:                    struct{}{},
-       {"mips64", "sync/atomic", "LoadUint64"}:                    struct{}{},
-       {"mips64", "sync/atomic", "LoadUintptr"}:                   struct{}{},
-       {"mips64", "sync/atomic", "StoreInt32"}:                    struct{}{},
-       {"mips64", "sync/atomic", "StoreInt64"}:                    struct{}{},
-       {"mips64", "sync/atomic", "StoreUint32"}:                   struct{}{},
-       {"mips64", "sync/atomic", "StoreUint64"}:                   struct{}{},
-       {"mips64", "sync/atomic", "StoreUintptr"}:                  struct{}{},
-       {"mips64", "sync/atomic", "SwapInt32"}:                     struct{}{},
-       {"mips64", "sync/atomic", "SwapInt64"}:                     struct{}{},
-       {"mips64", "sync/atomic", "SwapUint32"}:                    struct{}{},
-       {"mips64", "sync/atomic", "SwapUint64"}:                    struct{}{},
-       {"mips64", "sync/atomic", "SwapUintptr"}:                   struct{}{},
-       {"mips64le", "internal/runtime/atomic", "And"}:             struct{}{},
-       {"mips64le", "internal/runtime/atomic", "And8"}:            struct{}{},
-       {"mips64le", "internal/runtime/atomic", "Cas"}:             struct{}{},
-       {"mips64le", "internal/runtime/atomic", "Cas64"}:           struct{}{},
-       {"mips64le", "internal/runtime/atomic", "CasRel"}:          struct{}{},
-       {"mips64le", "internal/runtime/atomic", "Casint32"}:        struct{}{},
-       {"mips64le", "internal/runtime/atomic", "Casint64"}:        struct{}{},
-       {"mips64le", "internal/runtime/atomic", "Casp1"}:           struct{}{},
-       {"mips64le", "internal/runtime/atomic", "Casuintptr"}:      struct{}{},
-       {"mips64le", "internal/runtime/atomic", "Load"}:            struct{}{},
-       {"mips64le", "internal/runtime/atomic", "Load64"}:          struct{}{},
-       {"mips64le", "internal/runtime/atomic", "Load8"}:           struct{}{},
-       {"mips64le", "internal/runtime/atomic", "LoadAcq"}:         struct{}{},
-       {"mips64le", "internal/runtime/atomic", "LoadAcq64"}:       struct{}{},
-       {"mips64le", "internal/runtime/atomic", "LoadAcquintptr"}:  struct{}{},
-       {"mips64le", "internal/runtime/atomic", "Loadint32"}:       struct{}{},
-       {"mips64le", "internal/runtime/atomic", "Loadint64"}:       struct{}{},
-       {"mips64le", "internal/runtime/atomic", "Loadp"}:           struct{}{},
-       {"mips64le", "internal/runtime/atomic", "Loaduint"}:        struct{}{},
-       {"mips64le", "internal/runtime/atomic", "Loaduintptr"}:     struct{}{},
-       {"mips64le", "internal/runtime/atomic", "Or"}:              struct{}{},
-       {"mips64le", "internal/runtime/atomic", "Or8"}:             struct{}{},
-       {"mips64le", "internal/runtime/atomic", "Store"}:           struct{}{},
-       {"mips64le", "internal/runtime/atomic", "Store64"}:         struct{}{},
-       {"mips64le", "internal/runtime/atomic", "Store8"}:          struct{}{},
-       {"mips64le", "internal/runtime/atomic", "StoreRel"}:        struct{}{},
-       {"mips64le", "internal/runtime/atomic", "StoreRel64"}:      struct{}{},
-       {"mips64le", "internal/runtime/atomic", "StoreReluintptr"}: struct{}{},
-       {"mips64le", "internal/runtime/atomic", "Storeint32"}:      struct{}{},
-       {"mips64le", "internal/runtime/atomic", "Storeint64"}:      struct{}{},
-       {"mips64le", "internal/runtime/atomic", "StorepNoWB"}:      struct{}{},
-       {"mips64le", "internal/runtime/atomic", "Storeuintptr"}:    struct{}{},
-       {"mips64le", "internal/runtime/atomic", "Xadd"}:            struct{}{},
-       {"mips64le", "internal/runtime/atomic", "Xadd64"}:          struct{}{},
-       {"mips64le", "internal/runtime/atomic", "Xaddint32"}:       struct{}{},
-       {"mips64le", "internal/runtime/atomic", "Xaddint64"}:       struct{}{},
-       {"mips64le", "internal/runtime/atomic", "Xadduintptr"}:     struct{}{},
-       {"mips64le", "internal/runtime/atomic", "Xchg"}:            struct{}{},
-       {"mips64le", "internal/runtime/atomic", "Xchg64"}:          struct{}{},
-       {"mips64le", "internal/runtime/atomic", "Xchgint32"}:       struct{}{},
-       {"mips64le", "internal/runtime/atomic", "Xchgint64"}:       struct{}{},
-       {"mips64le", "internal/runtime/atomic", "Xchguintptr"}:     struct{}{},
-       {"mips64le", "internal/runtime/math", "Add64"}:             struct{}{},
-       {"mips64le", "internal/runtime/math", "Mul64"}:             struct{}{},
-       {"mips64le", "internal/runtime/math", "MulUintptr"}:        struct{}{},
-       {"mips64le", "internal/runtime/sys", "GetCallerPC"}:        struct{}{},
-       {"mips64le", "internal/runtime/sys", "GetCallerSP"}:        struct{}{},
-       {"mips64le", "internal/runtime/sys", "GetClosurePtr"}:      struct{}{},
-       {"mips64le", "math", "Abs"}:                                struct{}{},
-       {"mips64le", "math", "sqrt"}:                               struct{}{},
-       {"mips64le", "math/big", "mulWW"}:                          struct{}{},
-       {"mips64le", "math/bits", "Add"}:                           struct{}{},
-       {"mips64le", "math/bits", "Add64"}:                         struct{}{},
-       {"mips64le", "math/bits", "Mul"}:                           struct{}{},
-       {"mips64le", "math/bits", "Mul64"}:                         struct{}{},
-       {"mips64le", "math/bits", "Sub"}:                           struct{}{},
-       {"mips64le", "math/bits", "Sub64"}:                         struct{}{},
-       {"mips64le", "runtime", "KeepAlive"}:                       struct{}{},
-       {"mips64le", "runtime", "slicebytetostringtmp"}:            struct{}{},
-       {"mips64le", "sync", "runtime_LoadAcquintptr"}:             struct{}{},
-       {"mips64le", "sync", "runtime_StoreReluintptr"}:            struct{}{},
-       {"mips64le", "sync/atomic", "AddInt32"}:                    struct{}{},
-       {"mips64le", "sync/atomic", "AddInt64"}:                    struct{}{},
-       {"mips64le", "sync/atomic", "AddUint32"}:                   struct{}{},
-       {"mips64le", "sync/atomic", "AddUint64"}:                   struct{}{},
-       {"mips64le", "sync/atomic", "AddUintptr"}:                  struct{}{},
-       {"mips64le", "sync/atomic", "CompareAndSwapInt32"}:         struct{}{},
-       {"mips64le", "sync/atomic", "CompareAndSwapInt64"}:         struct{}{},
-       {"mips64le", "sync/atomic", "CompareAndSwapUint32"}:        struct{}{},
-       {"mips64le", "sync/atomic", "CompareAndSwapUint64"}:        struct{}{},
-       {"mips64le", "sync/atomic", "CompareAndSwapUintptr"}:       struct{}{},
-       {"mips64le", "sync/atomic", "LoadInt32"}:                   struct{}{},
-       {"mips64le", "sync/atomic", "LoadInt64"}:                   struct{}{},
-       {"mips64le", "sync/atomic", "LoadPointer"}:                 struct{}{},
-       {"mips64le", "sync/atomic", "LoadUint32"}:                  struct{}{},
-       {"mips64le", "sync/atomic", "LoadUint64"}:                  struct{}{},
-       {"mips64le", "sync/atomic", "LoadUintptr"}:                 struct{}{},
-       {"mips64le", "sync/atomic", "StoreInt32"}:                  struct{}{},
-       {"mips64le", "sync/atomic", "StoreInt64"}:                  struct{}{},
-       {"mips64le", "sync/atomic", "StoreUint32"}:                 struct{}{},
-       {"mips64le", "sync/atomic", "StoreUint64"}:                 struct{}{},
-       {"mips64le", "sync/atomic", "StoreUintptr"}:                struct{}{},
-       {"mips64le", "sync/atomic", "SwapInt32"}:                   struct{}{},
-       {"mips64le", "sync/atomic", "SwapInt64"}:                   struct{}{},
-       {"mips64le", "sync/atomic", "SwapUint32"}:                  struct{}{},
-       {"mips64le", "sync/atomic", "SwapUint64"}:                  struct{}{},
-       {"mips64le", "sync/atomic", "SwapUintptr"}:                 struct{}{},
-       {"mipsle", "internal/runtime/atomic", "And"}:               struct{}{},
-       {"mipsle", "internal/runtime/atomic", "And8"}:              struct{}{},
-       {"mipsle", "internal/runtime/atomic", "Cas"}:               struct{}{},
-       {"mipsle", "internal/runtime/atomic", "CasRel"}:            struct{}{},
-       {"mipsle", "internal/runtime/atomic", "Casint32"}:          struct{}{},
-       {"mipsle", "internal/runtime/atomic", "Casp1"}:             struct{}{},
-       {"mipsle", "internal/runtime/atomic", "Casuintptr"}:        struct{}{},
-       {"mipsle", "internal/runtime/atomic", "Load"}:              struct{}{},
-       {"mipsle", "internal/runtime/atomic", "Load8"}:             struct{}{},
-       {"mipsle", "internal/runtime/atomic", "LoadAcq"}:           struct{}{},
-       {"mipsle", "internal/runtime/atomic", "LoadAcquintptr"}:    struct{}{},
-       {"mipsle", "internal/runtime/atomic", "Loadint32"}:         struct{}{},
-       {"mipsle", "internal/runtime/atomic", "Loadp"}:             struct{}{},
-       {"mipsle", "internal/runtime/atomic", "Loaduint"}:          struct{}{},
-       {"mipsle", "internal/runtime/atomic", "Loaduintptr"}:       struct{}{},
-       {"mipsle", "internal/runtime/atomic", "Or"}:                struct{}{},
-       {"mipsle", "internal/runtime/atomic", "Or8"}:               struct{}{},
-       {"mipsle", "internal/runtime/atomic", "Store"}:             struct{}{},
-       {"mipsle", "internal/runtime/atomic", "Store8"}:            struct{}{},
-       {"mipsle", "internal/runtime/atomic", "StoreRel"}:          struct{}{},
-       {"mipsle", "internal/runtime/atomic", "StoreReluintptr"}:   struct{}{},
-       {"mipsle", "internal/runtime/atomic", "Storeint32"}:        struct{}{},
-       {"mipsle", "internal/runtime/atomic", "StorepNoWB"}:        struct{}{},
-       {"mipsle", "internal/runtime/atomic", "Storeuintptr"}:      struct{}{},
-       {"mipsle", "internal/runtime/atomic", "Xadd"}:              struct{}{},
-       {"mipsle", "internal/runtime/atomic", "Xaddint32"}:         struct{}{},
-       {"mipsle", "internal/runtime/atomic", "Xadduintptr"}:       struct{}{},
-       {"mipsle", "internal/runtime/atomic", "Xchg"}:              struct{}{},
-       {"mipsle", "internal/runtime/atomic", "Xchgint32"}:         struct{}{},
-       {"mipsle", "internal/runtime/atomic", "Xchguintptr"}:       struct{}{},
-       {"mipsle", "internal/runtime/sys", "GetCallerPC"}:          struct{}{},
-       {"mipsle", "internal/runtime/sys", "GetCallerSP"}:          struct{}{},
-       {"mipsle", "internal/runtime/sys", "GetClosurePtr"}:        struct{}{},
-       {"mipsle", "internal/runtime/sys", "Len64"}:                struct{}{},
-       {"mipsle", "internal/runtime/sys", "Len8"}:                 struct{}{},
-       {"mipsle", "internal/runtime/sys", "TrailingZeros32"}:      struct{}{},
-       {"mipsle", "internal/runtime/sys", "TrailingZeros64"}:      struct{}{},
-       {"mipsle", "internal/runtime/sys", "TrailingZeros8"}:       struct{}{},
-       {"mipsle", "math", "Abs"}:                                  struct{}{},
-       {"mipsle", "math", "sqrt"}:                                 struct{}{},
-       {"mipsle", "math/bits", "Len"}:                             struct{}{},
-       {"mipsle", "math/bits", "Len16"}:                           struct{}{},
-       {"mipsle", "math/bits", "Len32"}:                           struct{}{},
-       {"mipsle", "math/bits", "Len64"}:                           struct{}{},
-       {"mipsle", "math/bits", "Len8"}:                            struct{}{},
-       {"mipsle", "math/bits", "TrailingZeros16"}:                 struct{}{},
-       {"mipsle", "math/bits", "TrailingZeros32"}:                 struct{}{},
-       {"mipsle", "math/bits", "TrailingZeros64"}:                 struct{}{},
-       {"mipsle", "math/bits", "TrailingZeros8"}:                  struct{}{},
-       {"mipsle", "runtime", "KeepAlive"}:                         struct{}{},
-       {"mipsle", "runtime", "slicebytetostringtmp"}:              struct{}{},
-       {"mipsle", "sync", "runtime_LoadAcquintptr"}:               struct{}{},
-       {"mipsle", "sync", "runtime_StoreReluintptr"}:              struct{}{},
-       {"mipsle", "sync/atomic", "AddInt32"}:                      struct{}{},
-       {"mipsle", "sync/atomic", "AddUint32"}:                     struct{}{},
-       {"mipsle", "sync/atomic", "AddUintptr"}:                    struct{}{},
-       {"mipsle", "sync/atomic", "CompareAndSwapInt32"}:           struct{}{},
-       {"mipsle", "sync/atomic", "CompareAndSwapUint32"}:          struct{}{},
-       {"mipsle", "sync/atomic", "CompareAndSwapUintptr"}:         struct{}{},
-       {"mipsle", "sync/atomic", "LoadInt32"}:                     struct{}{},
-       {"mipsle", "sync/atomic", "LoadPointer"}:                   struct{}{},
-       {"mipsle", "sync/atomic", "LoadUint32"}:                    struct{}{},
-       {"mipsle", "sync/atomic", "LoadUintptr"}:                   struct{}{},
-       {"mipsle", "sync/atomic", "StoreInt32"}:                    struct{}{},
-       {"mipsle", "sync/atomic", "StoreUint32"}:                   struct{}{},
-       {"mipsle", "sync/atomic", "StoreUintptr"}:                  struct{}{},
-       {"mipsle", "sync/atomic", "SwapInt32"}:                     struct{}{},
-       {"mipsle", "sync/atomic", "SwapUint32"}:                    struct{}{},
-       {"mipsle", "sync/atomic", "SwapUintptr"}:                   struct{}{},
-       {"ppc64", "internal/runtime/atomic", "And"}:                struct{}{},
-       {"ppc64", "internal/runtime/atomic", "And8"}:               struct{}{},
-       {"ppc64", "internal/runtime/atomic", "Cas"}:                struct{}{},
-       {"ppc64", "internal/runtime/atomic", "Cas64"}:              struct{}{},
-       {"ppc64", "internal/runtime/atomic", "CasRel"}:             struct{}{},
-       {"ppc64", "internal/runtime/atomic", "Casint32"}:           struct{}{},
-       {"ppc64", "internal/runtime/atomic", "Casint64"}:           struct{}{},
-       {"ppc64", "internal/runtime/atomic", "Casp1"}:              struct{}{},
-       {"ppc64", "internal/runtime/atomic", "Casuintptr"}:         struct{}{},
-       {"ppc64", "internal/runtime/atomic", "Load"}:               struct{}{},
-       {"ppc64", "internal/runtime/atomic", "Load64"}:             struct{}{},
-       {"ppc64", "internal/runtime/atomic", "Load8"}:              struct{}{},
-       {"ppc64", "internal/runtime/atomic", "LoadAcq"}:            struct{}{},
-       {"ppc64", "internal/runtime/atomic", "LoadAcq64"}:          struct{}{},
-       {"ppc64", "internal/runtime/atomic", "LoadAcquintptr"}:     struct{}{},
-       {"ppc64", "internal/runtime/atomic", "Loadint32"}:          struct{}{},
-       {"ppc64", "internal/runtime/atomic", "Loadint64"}:          struct{}{},
-       {"ppc64", "internal/runtime/atomic", "Loadp"}:              struct{}{},
-       {"ppc64", "internal/runtime/atomic", "Loaduint"}:           struct{}{},
-       {"ppc64", "internal/runtime/atomic", "Loaduintptr"}:        struct{}{},
-       {"ppc64", "internal/runtime/atomic", "Or"}:                 struct{}{},
-       {"ppc64", "internal/runtime/atomic", "Or8"}:                struct{}{},
-       {"ppc64", "internal/runtime/atomic", "Store"}:              struct{}{},
-       {"ppc64", "internal/runtime/atomic", "Store64"}:            struct{}{},
-       {"ppc64", "internal/runtime/atomic", "Store8"}:             struct{}{},
-       {"ppc64", "internal/runtime/atomic", "StoreRel"}:           struct{}{},
-       {"ppc64", "internal/runtime/atomic", "StoreRel64"}:         struct{}{},
-       {"ppc64", "internal/runtime/atomic", "StoreReluintptr"}:    struct{}{},
-       {"ppc64", "internal/runtime/atomic", "Storeint32"}:         struct{}{},
-       {"ppc64", "internal/runtime/atomic", "Storeint64"}:         struct{}{},
-       {"ppc64", "internal/runtime/atomic", "Storeuintptr"}:       struct{}{},
-       {"ppc64", "internal/runtime/atomic", "Xadd"}:               struct{}{},
-       {"ppc64", "internal/runtime/atomic", "Xadd64"}:             struct{}{},
-       {"ppc64", "internal/runtime/atomic", "Xaddint32"}:          struct{}{},
-       {"ppc64", "internal/runtime/atomic", "Xaddint64"}:          struct{}{},
-       {"ppc64", "internal/runtime/atomic", "Xadduintptr"}:        struct{}{},
-       {"ppc64", "internal/runtime/atomic", "Xchg8"}:              struct{}{},
-       {"ppc64", "internal/runtime/atomic", "Xchg"}:               struct{}{},
-       {"ppc64", "internal/runtime/atomic", "Xchg64"}:             struct{}{},
-       {"ppc64", "internal/runtime/atomic", "Xchgint32"}:          struct{}{},
-       {"ppc64", "internal/runtime/atomic", "Xchgint64"}:          struct{}{},
-       {"ppc64", "internal/runtime/atomic", "Xchguintptr"}:        struct{}{},
-       {"ppc64", "internal/runtime/math", "Add64"}:                struct{}{},
-       {"ppc64", "internal/runtime/math", "Mul64"}:                struct{}{},
-       {"ppc64", "internal/runtime/math", "MulUintptr"}:           struct{}{},
-       {"ppc64", "internal/runtime/sys", "Bswap32"}:               struct{}{},
-       {"ppc64", "internal/runtime/sys", "Bswap64"}:               struct{}{},
-       {"ppc64", "internal/runtime/sys", "GetCallerPC"}:           struct{}{},
-       {"ppc64", "internal/runtime/sys", "GetCallerSP"}:           struct{}{},
-       {"ppc64", "internal/runtime/sys", "GetClosurePtr"}:         struct{}{},
-       {"ppc64", "internal/runtime/sys", "Len64"}:                 struct{}{},
-       {"ppc64", "internal/runtime/sys", "Len8"}:                  struct{}{},
-       {"ppc64", "internal/runtime/sys", "OnesCount64"}:           struct{}{},
-       {"ppc64", "internal/runtime/sys", "Prefetch"}:              struct{}{},
-       {"ppc64", "internal/runtime/sys", "PrefetchStreamed"}:      struct{}{},
-       {"ppc64", "internal/runtime/sys", "TrailingZeros32"}:       struct{}{},
-       {"ppc64", "internal/runtime/sys", "TrailingZeros64"}:       struct{}{},
-       {"ppc64", "math", "Abs"}:                                   struct{}{},
-       {"ppc64", "math", "Ceil"}:                                  struct{}{},
-       {"ppc64", "math", "Copysign"}:                              struct{}{},
-       {"ppc64", "math", "FMA"}:                                   struct{}{},
-       {"ppc64", "math", "Floor"}:                                 struct{}{},
-       {"ppc64", "math", "Round"}:                                 struct{}{},
-       {"ppc64", "math", "Trunc"}:                                 struct{}{},
-       {"ppc64", "math", "sqrt"}:                                  struct{}{},
-       {"ppc64", "math/big", "mulWW"}:                             struct{}{},
-       {"ppc64", "math/bits", "Add"}:                              struct{}{},
-       {"ppc64", "math/bits", "Add64"}:                            struct{}{},
-       {"ppc64", "math/bits", "Len"}:                              struct{}{},
-       {"ppc64", "math/bits", "Len16"}:                            struct{}{},
-       {"ppc64", "math/bits", "Len32"}:                            struct{}{},
-       {"ppc64", "math/bits", "Len64"}:                            struct{}{},
-       {"ppc64", "math/bits", "Len8"}:                             struct{}{},
-       {"ppc64", "math/bits", "Mul"}:                              struct{}{},
-       {"ppc64", "math/bits", "Mul64"}:                            struct{}{},
-       {"ppc64", "math/bits", "OnesCount16"}:                      struct{}{},
-       {"ppc64", "math/bits", "OnesCount32"}:                      struct{}{},
-       {"ppc64", "math/bits", "OnesCount64"}:                      struct{}{},
-       {"ppc64", "math/bits", "OnesCount8"}:                       struct{}{},
-       {"ppc64", "math/bits", "ReverseBytes16"}:                   struct{}{},
-       {"ppc64", "math/bits", "ReverseBytes32"}:                   struct{}{},
-       {"ppc64", "math/bits", "ReverseBytes64"}:                   struct{}{},
-       {"ppc64", "math/bits", "RotateLeft"}:                       struct{}{},
-       {"ppc64", "math/bits", "RotateLeft32"}:                     struct{}{},
-       {"ppc64", "math/bits", "RotateLeft64"}:                     struct{}{},
-       {"ppc64", "math/bits", "Sub"}:                              struct{}{},
-       {"ppc64", "math/bits", "Sub64"}:                            struct{}{},
-       {"ppc64", "math/bits", "TrailingZeros16"}:                  struct{}{},
-       {"ppc64", "math/bits", "TrailingZeros32"}:                  struct{}{},
-       {"ppc64", "math/bits", "TrailingZeros64"}:                  struct{}{},
-       {"ppc64", "runtime", "KeepAlive"}:                          struct{}{},
-       {"ppc64", "runtime", "publicationBarrier"}:                 struct{}{},
-       {"ppc64", "runtime", "slicebytetostringtmp"}:               struct{}{},
-       {"ppc64", "sync", "runtime_LoadAcquintptr"}:                struct{}{},
-       {"ppc64", "sync", "runtime_StoreReluintptr"}:               struct{}{},
-       {"ppc64", "sync/atomic", "AddInt32"}:                       struct{}{},
-       {"ppc64", "sync/atomic", "AddInt64"}:                       struct{}{},
-       {"ppc64", "sync/atomic", "AddUint32"}:                      struct{}{},
-       {"ppc64", "sync/atomic", "AddUint64"}:                      struct{}{},
-       {"ppc64", "sync/atomic", "AddUintptr"}:                     struct{}{},
-       {"ppc64", "sync/atomic", "CompareAndSwapInt32"}:            struct{}{},
-       {"ppc64", "sync/atomic", "CompareAndSwapInt64"}:            struct{}{},
-       {"ppc64", "sync/atomic", "CompareAndSwapUint32"}:           struct{}{},
-       {"ppc64", "sync/atomic", "CompareAndSwapUint64"}:           struct{}{},
-       {"ppc64", "sync/atomic", "CompareAndSwapUintptr"}:          struct{}{},
-       {"ppc64", "sync/atomic", "LoadInt32"}:                      struct{}{},
-       {"ppc64", "sync/atomic", "LoadInt64"}:                      struct{}{},
-       {"ppc64", "sync/atomic", "LoadPointer"}:                    struct{}{},
-       {"ppc64", "sync/atomic", "LoadUint32"}:                     struct{}{},
-       {"ppc64", "sync/atomic", "LoadUint64"}:                     struct{}{},
-       {"ppc64", "sync/atomic", "LoadUintptr"}:                    struct{}{},
-       {"ppc64", "sync/atomic", "StoreInt32"}:                     struct{}{},
-       {"ppc64", "sync/atomic", "StoreInt64"}:                     struct{}{},
-       {"ppc64", "sync/atomic", "StoreUint32"}:                    struct{}{},
-       {"ppc64", "sync/atomic", "StoreUint64"}:                    struct{}{},
-       {"ppc64", "sync/atomic", "StoreUintptr"}:                   struct{}{},
-       {"ppc64", "sync/atomic", "SwapInt32"}:                      struct{}{},
-       {"ppc64", "sync/atomic", "SwapInt64"}:                      struct{}{},
-       {"ppc64", "sync/atomic", "SwapUint32"}:                     struct{}{},
-       {"ppc64", "sync/atomic", "SwapUint64"}:                     struct{}{},
-       {"ppc64", "sync/atomic", "SwapUintptr"}:                    struct{}{},
-       {"ppc64le", "internal/runtime/atomic", "And"}:              struct{}{},
-       {"ppc64le", "internal/runtime/atomic", "And8"}:             struct{}{},
-       {"ppc64le", "internal/runtime/atomic", "Cas"}:              struct{}{},
-       {"ppc64le", "internal/runtime/atomic", "Cas64"}:            struct{}{},
-       {"ppc64le", "internal/runtime/atomic", "CasRel"}:           struct{}{},
-       {"ppc64le", "internal/runtime/atomic", "Casint32"}:         struct{}{},
-       {"ppc64le", "internal/runtime/atomic", "Casint64"}:         struct{}{},
-       {"ppc64le", "internal/runtime/atomic", "Casp1"}:            struct{}{},
-       {"ppc64le", "internal/runtime/atomic", "Casuintptr"}:       struct{}{},
-       {"ppc64le", "internal/runtime/atomic", "Load"}:             struct{}{},
-       {"ppc64le", "internal/runtime/atomic", "Load64"}:           struct{}{},
-       {"ppc64le", "internal/runtime/atomic", "Load8"}:            struct{}{},
-       {"ppc64le", "internal/runtime/atomic", "LoadAcq"}:          struct{}{},
-       {"ppc64le", "internal/runtime/atomic", "LoadAcq64"}:        struct{}{},
-       {"ppc64le", "internal/runtime/atomic", "LoadAcquintptr"}:   struct{}{},
-       {"ppc64le", "internal/runtime/atomic", "Loadint32"}:        struct{}{},
-       {"ppc64le", "internal/runtime/atomic", "Loadint64"}:        struct{}{},
-       {"ppc64le", "internal/runtime/atomic", "Loadp"}:            struct{}{},
-       {"ppc64le", "internal/runtime/atomic", "Loaduint"}:         struct{}{},
-       {"ppc64le", "internal/runtime/atomic", "Loaduintptr"}:      struct{}{},
-       {"ppc64le", "internal/runtime/atomic", "Or"}:               struct{}{},
-       {"ppc64le", "internal/runtime/atomic", "Or8"}:              struct{}{},
-       {"ppc64le", "internal/runtime/atomic", "Store"}:            struct{}{},
-       {"ppc64le", "internal/runtime/atomic", "Store64"}:          struct{}{},
-       {"ppc64le", "internal/runtime/atomic", "Store8"}:           struct{}{},
-       {"ppc64le", "internal/runtime/atomic", "StoreRel"}:         struct{}{},
-       {"ppc64le", "internal/runtime/atomic", "StoreRel64"}:       struct{}{},
-       {"ppc64le", "internal/runtime/atomic", "StoreReluintptr"}:  struct{}{},
-       {"ppc64le", "internal/runtime/atomic", "Storeint32"}:       struct{}{},
-       {"ppc64le", "internal/runtime/atomic", "Storeint64"}:       struct{}{},
-       {"ppc64le", "internal/runtime/atomic", "Storeuintptr"}:     struct{}{},
-       {"ppc64le", "internal/runtime/atomic", "Xadd"}:             struct{}{},
-       {"ppc64le", "internal/runtime/atomic", "Xadd64"}:           struct{}{},
-       {"ppc64le", "internal/runtime/atomic", "Xaddint32"}:        struct{}{},
-       {"ppc64le", "internal/runtime/atomic", "Xaddint64"}:        struct{}{},
-       {"ppc64le", "internal/runtime/atomic", "Xadduintptr"}:      struct{}{},
-       {"ppc64le", "internal/runtime/atomic", "Xchg8"}:            struct{}{},
-       {"ppc64le", "internal/runtime/atomic", "Xchg"}:             struct{}{},
-       {"ppc64le", "internal/runtime/atomic", "Xchg64"}:           struct{}{},
-       {"ppc64le", "internal/runtime/atomic", "Xchgint32"}:        struct{}{},
-       {"ppc64le", "internal/runtime/atomic", "Xchgint64"}:        struct{}{},
-       {"ppc64le", "internal/runtime/atomic", "Xchguintptr"}:      struct{}{},
-       {"ppc64le", "internal/runtime/math", "Add64"}:              struct{}{},
-       {"ppc64le", "internal/runtime/math", "Mul64"}:              struct{}{},
-       {"ppc64le", "internal/runtime/math", "MulUintptr"}:         struct{}{},
-       {"ppc64le", "internal/runtime/sys", "Bswap32"}:             struct{}{},
-       {"ppc64le", "internal/runtime/sys", "Bswap64"}:             struct{}{},
-       {"ppc64le", "internal/runtime/sys", "GetCallerPC"}:         struct{}{},
-       {"ppc64le", "internal/runtime/sys", "GetCallerSP"}:         struct{}{},
-       {"ppc64le", "internal/runtime/sys", "GetClosurePtr"}:       struct{}{},
-       {"ppc64le", "internal/runtime/sys", "Len64"}:               struct{}{},
-       {"ppc64le", "internal/runtime/sys", "Len8"}:                struct{}{},
-       {"ppc64le", "internal/runtime/sys", "OnesCount64"}:         struct{}{},
-       {"ppc64le", "internal/runtime/sys", "Prefetch"}:            struct{}{},
-       {"ppc64le", "internal/runtime/sys", "PrefetchStreamed"}:    struct{}{},
-       {"ppc64le", "internal/runtime/sys", "TrailingZeros32"}:     struct{}{},
-       {"ppc64le", "internal/runtime/sys", "TrailingZeros64"}:     struct{}{},
-       {"ppc64le", "math", "Abs"}:                                 struct{}{},
-       {"ppc64le", "math", "Ceil"}:                                struct{}{},
-       {"ppc64le", "math", "Copysign"}:                            struct{}{},
-       {"ppc64le", "math", "FMA"}:                                 struct{}{},
-       {"ppc64le", "math", "Floor"}:                               struct{}{},
-       {"ppc64le", "math", "Round"}:                               struct{}{},
-       {"ppc64le", "math", "Trunc"}:                               struct{}{},
-       {"ppc64le", "math", "sqrt"}:                                struct{}{},
-       {"ppc64le", "math/big", "mulWW"}:                           struct{}{},
-       {"ppc64le", "math/bits", "Add"}:                            struct{}{},
-       {"ppc64le", "math/bits", "Add64"}:                          struct{}{},
-       {"ppc64le", "math/bits", "Len"}:                            struct{}{},
-       {"ppc64le", "math/bits", "Len16"}:                          struct{}{},
-       {"ppc64le", "math/bits", "Len32"}:                          struct{}{},
-       {"ppc64le", "math/bits", "Len64"}:                          struct{}{},
-       {"ppc64le", "math/bits", "Len8"}:                           struct{}{},
-       {"ppc64le", "math/bits", "Mul"}:                            struct{}{},
-       {"ppc64le", "math/bits", "Mul64"}:                          struct{}{},
-       {"ppc64le", "math/bits", "OnesCount16"}:                    struct{}{},
-       {"ppc64le", "math/bits", "OnesCount32"}:                    struct{}{},
-       {"ppc64le", "math/bits", "OnesCount64"}:                    struct{}{},
-       {"ppc64le", "math/bits", "OnesCount8"}:                     struct{}{},
-       {"ppc64le", "math/bits", "ReverseBytes16"}:                 struct{}{},
-       {"ppc64le", "math/bits", "ReverseBytes32"}:                 struct{}{},
-       {"ppc64le", "math/bits", "ReverseBytes64"}:                 struct{}{},
-       {"ppc64le", "math/bits", "RotateLeft"}:                     struct{}{},
-       {"ppc64le", "math/bits", "RotateLeft32"}:                   struct{}{},
-       {"ppc64le", "math/bits", "RotateLeft64"}:                   struct{}{},
-       {"ppc64le", "math/bits", "Sub"}:                            struct{}{},
-       {"ppc64le", "math/bits", "Sub64"}:                          struct{}{},
-       {"ppc64le", "math/bits", "TrailingZeros16"}:                struct{}{},
-       {"ppc64le", "math/bits", "TrailingZeros32"}:                struct{}{},
-       {"ppc64le", "math/bits", "TrailingZeros64"}:                struct{}{},
-       {"ppc64le", "runtime", "KeepAlive"}:                        struct{}{},
-       {"ppc64le", "runtime", "publicationBarrier"}:               struct{}{},
-       {"ppc64le", "runtime", "slicebytetostringtmp"}:             struct{}{},
-       {"ppc64le", "sync", "runtime_LoadAcquintptr"}:              struct{}{},
-       {"ppc64le", "sync", "runtime_StoreReluintptr"}:             struct{}{},
-       {"ppc64le", "sync/atomic", "AddInt32"}:                     struct{}{},
-       {"ppc64le", "sync/atomic", "AddInt64"}:                     struct{}{},
-       {"ppc64le", "sync/atomic", "AddUint32"}:                    struct{}{},
-       {"ppc64le", "sync/atomic", "AddUint64"}:                    struct{}{},
-       {"ppc64le", "sync/atomic", "AddUintptr"}:                   struct{}{},
-       {"ppc64le", "sync/atomic", "CompareAndSwapInt32"}:          struct{}{},
-       {"ppc64le", "sync/atomic", "CompareAndSwapInt64"}:          struct{}{},
-       {"ppc64le", "sync/atomic", "CompareAndSwapUint32"}:         struct{}{},
-       {"ppc64le", "sync/atomic", "CompareAndSwapUint64"}:         struct{}{},
-       {"ppc64le", "sync/atomic", "CompareAndSwapUintptr"}:        struct{}{},
-       {"ppc64le", "sync/atomic", "LoadInt32"}:                    struct{}{},
-       {"ppc64le", "sync/atomic", "LoadInt64"}:                    struct{}{},
-       {"ppc64le", "sync/atomic", "LoadPointer"}:                  struct{}{},
-       {"ppc64le", "sync/atomic", "LoadUint32"}:                   struct{}{},
-       {"ppc64le", "sync/atomic", "LoadUint64"}:                   struct{}{},
-       {"ppc64le", "sync/atomic", "LoadUintptr"}:                  struct{}{},
-       {"ppc64le", "sync/atomic", "StoreInt32"}:                   struct{}{},
-       {"ppc64le", "sync/atomic", "StoreInt64"}:                   struct{}{},
-       {"ppc64le", "sync/atomic", "StoreUint32"}:                  struct{}{},
-       {"ppc64le", "sync/atomic", "StoreUint64"}:                  struct{}{},
-       {"ppc64le", "sync/atomic", "StoreUintptr"}:                 struct{}{},
-       {"ppc64le", "sync/atomic", "SwapInt32"}:                    struct{}{},
-       {"ppc64le", "sync/atomic", "SwapInt64"}:                    struct{}{},
-       {"ppc64le", "sync/atomic", "SwapUint32"}:                   struct{}{},
-       {"ppc64le", "sync/atomic", "SwapUint64"}:                   struct{}{},
-       {"ppc64le", "sync/atomic", "SwapUintptr"}:                  struct{}{},
-       {"riscv64", "internal/runtime/atomic", "And"}:              struct{}{},
-       {"riscv64", "internal/runtime/atomic", "And8"}:             struct{}{},
-       {"riscv64", "internal/runtime/atomic", "Cas"}:              struct{}{},
-       {"riscv64", "internal/runtime/atomic", "Cas64"}:            struct{}{},
-       {"riscv64", "internal/runtime/atomic", "CasRel"}:           struct{}{},
-       {"riscv64", "internal/runtime/atomic", "Casint32"}:         struct{}{},
-       {"riscv64", "internal/runtime/atomic", "Casint64"}:         struct{}{},
-       {"riscv64", "internal/runtime/atomic", "Casp1"}:            struct{}{},
-       {"riscv64", "internal/runtime/atomic", "Casuintptr"}:       struct{}{},
-       {"riscv64", "internal/runtime/atomic", "Load"}:             struct{}{},
-       {"riscv64", "internal/runtime/atomic", "Load64"}:           struct{}{},
-       {"riscv64", "internal/runtime/atomic", "Load8"}:            struct{}{},
-       {"riscv64", "internal/runtime/atomic", "LoadAcq"}:          struct{}{},
-       {"riscv64", "internal/runtime/atomic", "LoadAcq64"}:        struct{}{},
-       {"riscv64", "internal/runtime/atomic", "LoadAcquintptr"}:   struct{}{},
-       {"riscv64", "internal/runtime/atomic", "Loadint32"}:        struct{}{},
-       {"riscv64", "internal/runtime/atomic", "Loadint64"}:        struct{}{},
-       {"riscv64", "internal/runtime/atomic", "Loadp"}:            struct{}{},
-       {"riscv64", "internal/runtime/atomic", "Loaduint"}:         struct{}{},
-       {"riscv64", "internal/runtime/atomic", "Loaduintptr"}:      struct{}{},
-       {"riscv64", "internal/runtime/atomic", "Or"}:               struct{}{},
-       {"riscv64", "internal/runtime/atomic", "Or8"}:              struct{}{},
-       {"riscv64", "internal/runtime/atomic", "Store"}:            struct{}{},
-       {"riscv64", "internal/runtime/atomic", "Store64"}:          struct{}{},
-       {"riscv64", "internal/runtime/atomic", "Store8"}:           struct{}{},
-       {"riscv64", "internal/runtime/atomic", "StoreRel"}:         struct{}{},
-       {"riscv64", "internal/runtime/atomic", "StoreRel64"}:       struct{}{},
-       {"riscv64", "internal/runtime/atomic", "StoreReluintptr"}:  struct{}{},
-       {"riscv64", "internal/runtime/atomic", "Storeint32"}:       struct{}{},
-       {"riscv64", "internal/runtime/atomic", "Storeint64"}:       struct{}{},
-       {"riscv64", "internal/runtime/atomic", "StorepNoWB"}:       struct{}{},
-       {"riscv64", "internal/runtime/atomic", "Storeuintptr"}:     struct{}{},
-       {"riscv64", "internal/runtime/atomic", "Xadd"}:             struct{}{},
-       {"riscv64", "internal/runtime/atomic", "Xadd64"}:           struct{}{},
-       {"riscv64", "internal/runtime/atomic", "Xaddint32"}:        struct{}{},
-       {"riscv64", "internal/runtime/atomic", "Xaddint64"}:        struct{}{},
-       {"riscv64", "internal/runtime/atomic", "Xadduintptr"}:      struct{}{},
-       {"riscv64", "internal/runtime/atomic", "Xchg"}:             struct{}{},
-       {"riscv64", "internal/runtime/atomic", "Xchg64"}:           struct{}{},
-       {"riscv64", "internal/runtime/atomic", "Xchgint32"}:        struct{}{},
-       {"riscv64", "internal/runtime/atomic", "Xchgint64"}:        struct{}{},
-       {"riscv64", "internal/runtime/atomic", "Xchguintptr"}:      struct{}{},
-       {"riscv64", "internal/runtime/math", "Add64"}:              struct{}{},
-       {"riscv64", "internal/runtime/math", "Mul64"}:              struct{}{},
-       {"riscv64", "internal/runtime/math", "MulUintptr"}:         struct{}{},
-       {"riscv64", "internal/runtime/sys", "GetCallerPC"}:         struct{}{},
-       {"riscv64", "internal/runtime/sys", "GetCallerSP"}:         struct{}{},
-       {"riscv64", "internal/runtime/sys", "GetClosurePtr"}:       struct{}{},
-       {"riscv64", "math", "Abs"}:                                 struct{}{},
-       {"riscv64", "math", "Copysign"}:                            struct{}{},
-       {"riscv64", "math", "FMA"}:                                 struct{}{},
-       {"riscv64", "math", "sqrt"}:                                struct{}{},
-       {"riscv64", "math/big", "mulWW"}:                           struct{}{},
-       {"riscv64", "math/bits", "Add"}:                            struct{}{},
-       {"riscv64", "math/bits", "Add64"}:                          struct{}{},
-       {"riscv64", "math/bits", "Mul"}:                            struct{}{},
-       {"riscv64", "math/bits", "Mul64"}:                          struct{}{},
-       {"riscv64", "math/bits", "RotateLeft"}:                     struct{}{},
-       {"riscv64", "math/bits", "RotateLeft16"}:                   struct{}{},
-       {"riscv64", "math/bits", "RotateLeft32"}:                   struct{}{},
-       {"riscv64", "math/bits", "RotateLeft64"}:                   struct{}{},
-       {"riscv64", "math/bits", "RotateLeft8"}:                    struct{}{},
-       {"riscv64", "math/bits", "Sub"}:                            struct{}{},
-       {"riscv64", "math/bits", "Sub64"}:                          struct{}{},
-       {"riscv64", "runtime", "KeepAlive"}:                        struct{}{},
-       {"riscv64", "runtime", "publicationBarrier"}:               struct{}{},
-       {"riscv64", "runtime", "slicebytetostringtmp"}:             struct{}{},
-       {"riscv64", "sync", "runtime_LoadAcquintptr"}:              struct{}{},
-       {"riscv64", "sync", "runtime_StoreReluintptr"}:             struct{}{},
-       {"riscv64", "sync/atomic", "AddInt32"}:                     struct{}{},
-       {"riscv64", "sync/atomic", "AddInt64"}:                     struct{}{},
-       {"riscv64", "sync/atomic", "AddUint32"}:                    struct{}{},
-       {"riscv64", "sync/atomic", "AddUint64"}:                    struct{}{},
-       {"riscv64", "sync/atomic", "AddUintptr"}:                   struct{}{},
-       {"riscv64", "sync/atomic", "CompareAndSwapInt32"}:          struct{}{},
-       {"riscv64", "sync/atomic", "CompareAndSwapInt64"}:          struct{}{},
-       {"riscv64", "sync/atomic", "CompareAndSwapUint32"}:         struct{}{},
-       {"riscv64", "sync/atomic", "CompareAndSwapUint64"}:         struct{}{},
-       {"riscv64", "sync/atomic", "CompareAndSwapUintptr"}:        struct{}{},
-       {"riscv64", "sync/atomic", "LoadInt32"}:                    struct{}{},
-       {"riscv64", "sync/atomic", "LoadInt64"}:                    struct{}{},
-       {"riscv64", "sync/atomic", "LoadPointer"}:                  struct{}{},
-       {"riscv64", "sync/atomic", "LoadUint32"}:                   struct{}{},
-       {"riscv64", "sync/atomic", "LoadUint64"}:                   struct{}{},
-       {"riscv64", "sync/atomic", "LoadUintptr"}:                  struct{}{},
-       {"riscv64", "sync/atomic", "StoreInt32"}:                   struct{}{},
-       {"riscv64", "sync/atomic", "StoreInt64"}:                   struct{}{},
-       {"riscv64", "sync/atomic", "StoreUint32"}:                  struct{}{},
-       {"riscv64", "sync/atomic", "StoreUint64"}:                  struct{}{},
-       {"riscv64", "sync/atomic", "StoreUintptr"}:                 struct{}{},
-       {"riscv64", "sync/atomic", "SwapInt32"}:                    struct{}{},
-       {"riscv64", "sync/atomic", "SwapInt64"}:                    struct{}{},
-       {"riscv64", "sync/atomic", "SwapUint32"}:                   struct{}{},
-       {"riscv64", "sync/atomic", "SwapUint64"}:                   struct{}{},
-       {"riscv64", "sync/atomic", "SwapUintptr"}:                  struct{}{},
-       {"s390x", "internal/runtime/atomic", "And"}:                struct{}{},
-       {"s390x", "internal/runtime/atomic", "And8"}:               struct{}{},
-       {"s390x", "internal/runtime/atomic", "Cas"}:                struct{}{},
-       {"s390x", "internal/runtime/atomic", "Cas64"}:              struct{}{},
-       {"s390x", "internal/runtime/atomic", "CasRel"}:             struct{}{},
-       {"s390x", "internal/runtime/atomic", "Casint32"}:           struct{}{},
-       {"s390x", "internal/runtime/atomic", "Casint64"}:           struct{}{},
-       {"s390x", "internal/runtime/atomic", "Casp1"}:              struct{}{},
-       {"s390x", "internal/runtime/atomic", "Casuintptr"}:         struct{}{},
-       {"s390x", "internal/runtime/atomic", "Load"}:               struct{}{},
-       {"s390x", "internal/runtime/atomic", "Load64"}:             struct{}{},
-       {"s390x", "internal/runtime/atomic", "Load8"}:              struct{}{},
-       {"s390x", "internal/runtime/atomic", "LoadAcq"}:            struct{}{},
-       {"s390x", "internal/runtime/atomic", "LoadAcq64"}:          struct{}{},
-       {"s390x", "internal/runtime/atomic", "LoadAcquintptr"}:     struct{}{},
-       {"s390x", "internal/runtime/atomic", "Loadint32"}:          struct{}{},
-       {"s390x", "internal/runtime/atomic", "Loadint64"}:          struct{}{},
-       {"s390x", "internal/runtime/atomic", "Loadp"}:              struct{}{},
-       {"s390x", "internal/runtime/atomic", "Loaduint"}:           struct{}{},
-       {"s390x", "internal/runtime/atomic", "Loaduintptr"}:        struct{}{},
-       {"s390x", "internal/runtime/atomic", "Or"}:                 struct{}{},
-       {"s390x", "internal/runtime/atomic", "Or8"}:                struct{}{},
-       {"s390x", "internal/runtime/atomic", "Store"}:              struct{}{},
-       {"s390x", "internal/runtime/atomic", "Store64"}:            struct{}{},
-       {"s390x", "internal/runtime/atomic", "Store8"}:             struct{}{},
-       {"s390x", "internal/runtime/atomic", "StoreRel"}:           struct{}{},
-       {"s390x", "internal/runtime/atomic", "StoreRel64"}:         struct{}{},
-       {"s390x", "internal/runtime/atomic", "StoreReluintptr"}:    struct{}{},
-       {"s390x", "internal/runtime/atomic", "Storeint32"}:         struct{}{},
-       {"s390x", "internal/runtime/atomic", "Storeint64"}:         struct{}{},
-       {"s390x", "internal/runtime/atomic", "StorepNoWB"}:         struct{}{},
-       {"s390x", "internal/runtime/atomic", "Storeuintptr"}:       struct{}{},
-       {"s390x", "internal/runtime/atomic", "Xadd"}:               struct{}{},
-       {"s390x", "internal/runtime/atomic", "Xadd64"}:             struct{}{},
-       {"s390x", "internal/runtime/atomic", "Xaddint32"}:          struct{}{},
-       {"s390x", "internal/runtime/atomic", "Xaddint64"}:          struct{}{},
-       {"s390x", "internal/runtime/atomic", "Xadduintptr"}:        struct{}{},
-       {"s390x", "internal/runtime/atomic", "Xchg"}:               struct{}{},
-       {"s390x", "internal/runtime/atomic", "Xchg64"}:             struct{}{},
-       {"s390x", "internal/runtime/atomic", "Xchgint32"}:          struct{}{},
-       {"s390x", "internal/runtime/atomic", "Xchgint64"}:          struct{}{},
-       {"s390x", "internal/runtime/atomic", "Xchguintptr"}:        struct{}{},
-       {"s390x", "internal/runtime/math", "Add64"}:                struct{}{},
-       {"s390x", "internal/runtime/math", "Mul64"}:                struct{}{},
-       {"s390x", "internal/runtime/sys", "Bswap32"}:               struct{}{},
-       {"s390x", "internal/runtime/sys", "Bswap64"}:               struct{}{},
-       {"s390x", "internal/runtime/sys", "GetCallerPC"}:           struct{}{},
-       {"s390x", "internal/runtime/sys", "GetCallerSP"}:           struct{}{},
-       {"s390x", "internal/runtime/sys", "GetClosurePtr"}:         struct{}{},
-       {"s390x", "internal/runtime/sys", "Len64"}:                 struct{}{},
-       {"s390x", "internal/runtime/sys", "Len8"}:                  struct{}{},
-       {"s390x", "internal/runtime/sys", "OnesCount64"}:           struct{}{},
-       {"s390x", "internal/runtime/sys", "TrailingZeros32"}:       struct{}{},
-       {"s390x", "internal/runtime/sys", "TrailingZeros64"}:       struct{}{},
-       {"s390x", "internal/runtime/sys", "TrailingZeros8"}:        struct{}{},
-       {"s390x", "math", "Ceil"}:                                  struct{}{},
-       {"s390x", "math", "FMA"}:                                   struct{}{},
-       {"s390x", "math", "Floor"}:                                 struct{}{},
-       {"s390x", "math", "Round"}:                                 struct{}{},
-       {"s390x", "math", "RoundToEven"}:                           struct{}{},
-       {"s390x", "math", "Trunc"}:                                 struct{}{},
-       {"s390x", "math", "sqrt"}:                                  struct{}{},
-       {"s390x", "math/big", "mulWW"}:                             struct{}{},
-       {"s390x", "math/bits", "Add"}:                              struct{}{},
-       {"s390x", "math/bits", "Add64"}:                            struct{}{},
-       {"s390x", "math/bits", "Len"}:                              struct{}{},
-       {"s390x", "math/bits", "Len16"}:                            struct{}{},
-       {"s390x", "math/bits", "Len32"}:                            struct{}{},
-       {"s390x", "math/bits", "Len64"}:                            struct{}{},
-       {"s390x", "math/bits", "Len8"}:                             struct{}{},
-       {"s390x", "math/bits", "Mul"}:                              struct{}{},
-       {"s390x", "math/bits", "Mul64"}:                            struct{}{},
-       {"s390x", "math/bits", "OnesCount16"}:                      struct{}{},
-       {"s390x", "math/bits", "OnesCount32"}:                      struct{}{},
-       {"s390x", "math/bits", "OnesCount64"}:                      struct{}{},
-       {"s390x", "math/bits", "OnesCount8"}:                       struct{}{},
-       {"s390x", "math/bits", "ReverseBytes32"}:                   struct{}{},
-       {"s390x", "math/bits", "ReverseBytes64"}:                   struct{}{},
-       {"s390x", "math/bits", "RotateLeft"}:                       struct{}{},
-       {"s390x", "math/bits", "RotateLeft32"}:                     struct{}{},
-       {"s390x", "math/bits", "RotateLeft64"}:                     struct{}{},
-       {"s390x", "math/bits", "Sub"}:                              struct{}{},
-       {"s390x", "math/bits", "Sub64"}:                            struct{}{},
-       {"s390x", "math/bits", "TrailingZeros16"}:                  struct{}{},
-       {"s390x", "math/bits", "TrailingZeros32"}:                  struct{}{},
-       {"s390x", "math/bits", "TrailingZeros64"}:                  struct{}{},
-       {"s390x", "math/bits", "TrailingZeros8"}:                   struct{}{},
-       {"s390x", "runtime", "KeepAlive"}:                          struct{}{},
-       {"s390x", "runtime", "slicebytetostringtmp"}:               struct{}{},
-       {"s390x", "sync", "runtime_LoadAcquintptr"}:                struct{}{},
-       {"s390x", "sync", "runtime_StoreReluintptr"}:               struct{}{},
-       {"s390x", "sync/atomic", "AddInt32"}:                       struct{}{},
-       {"s390x", "sync/atomic", "AddInt64"}:                       struct{}{},
-       {"s390x", "sync/atomic", "AddUint32"}:                      struct{}{},
-       {"s390x", "sync/atomic", "AddUint64"}:                      struct{}{},
-       {"s390x", "sync/atomic", "AddUintptr"}:                     struct{}{},
-       {"s390x", "sync/atomic", "CompareAndSwapInt32"}:            struct{}{},
-       {"s390x", "sync/atomic", "CompareAndSwapInt64"}:            struct{}{},
-       {"s390x", "sync/atomic", "CompareAndSwapUint32"}:           struct{}{},
-       {"s390x", "sync/atomic", "CompareAndSwapUint64"}:           struct{}{},
-       {"s390x", "sync/atomic", "CompareAndSwapUintptr"}:          struct{}{},
-       {"s390x", "sync/atomic", "LoadInt32"}:                      struct{}{},
-       {"s390x", "sync/atomic", "LoadInt64"}:                      struct{}{},
-       {"s390x", "sync/atomic", "LoadPointer"}:                    struct{}{},
-       {"s390x", "sync/atomic", "LoadUint32"}:                     struct{}{},
-       {"s390x", "sync/atomic", "LoadUint64"}:                     struct{}{},
-       {"s390x", "sync/atomic", "LoadUintptr"}:                    struct{}{},
-       {"s390x", "sync/atomic", "StoreInt32"}:                     struct{}{},
-       {"s390x", "sync/atomic", "StoreInt64"}:                     struct{}{},
-       {"s390x", "sync/atomic", "StoreUint32"}:                    struct{}{},
-       {"s390x", "sync/atomic", "StoreUint64"}:                    struct{}{},
-       {"s390x", "sync/atomic", "StoreUintptr"}:                   struct{}{},
-       {"s390x", "sync/atomic", "SwapInt32"}:                      struct{}{},
-       {"s390x", "sync/atomic", "SwapInt64"}:                      struct{}{},
-       {"s390x", "sync/atomic", "SwapUint32"}:                     struct{}{},
-       {"s390x", "sync/atomic", "SwapUint64"}:                     struct{}{},
-       {"s390x", "sync/atomic", "SwapUintptr"}:                    struct{}{},
-       {"wasm", "internal/runtime/sys", "GetCallerPC"}:            struct{}{},
-       {"wasm", "internal/runtime/sys", "GetCallerSP"}:            struct{}{},
-       {"wasm", "internal/runtime/sys", "GetClosurePtr"}:          struct{}{},
-       {"wasm", "internal/runtime/sys", "Len64"}:                  struct{}{},
-       {"wasm", "internal/runtime/sys", "Len8"}:                   struct{}{},
-       {"wasm", "internal/runtime/sys", "OnesCount64"}:            struct{}{},
-       {"wasm", "internal/runtime/sys", "TrailingZeros32"}:        struct{}{},
-       {"wasm", "internal/runtime/sys", "TrailingZeros64"}:        struct{}{},
-       {"wasm", "internal/runtime/sys", "TrailingZeros8"}:         struct{}{},
-       {"wasm", "math", "Abs"}:                                    struct{}{},
-       {"wasm", "math", "Ceil"}:                                   struct{}{},
-       {"wasm", "math", "Copysign"}:                               struct{}{},
-       {"wasm", "math", "Floor"}:                                  struct{}{},
-       {"wasm", "math", "RoundToEven"}:                            struct{}{},
-       {"wasm", "math", "Trunc"}:                                  struct{}{},
-       {"wasm", "math", "sqrt"}:                                   struct{}{},
-       {"wasm", "math/bits", "Len"}:                               struct{}{},
-       {"wasm", "math/bits", "Len16"}:                             struct{}{},
-       {"wasm", "math/bits", "Len32"}:                             struct{}{},
-       {"wasm", "math/bits", "Len64"}:                             struct{}{},
-       {"wasm", "math/bits", "Len8"}:                              struct{}{},
-       {"wasm", "math/bits", "OnesCount16"}:                       struct{}{},
-       {"wasm", "math/bits", "OnesCount32"}:                       struct{}{},
-       {"wasm", "math/bits", "OnesCount64"}:                       struct{}{},
-       {"wasm", "math/bits", "OnesCount8"}:                        struct{}{},
-       {"wasm", "math/bits", "RotateLeft"}:                        struct{}{},
-       {"wasm", "math/bits", "RotateLeft32"}:                      struct{}{},
-       {"wasm", "math/bits", "RotateLeft64"}:                      struct{}{},
-       {"wasm", "math/bits", "TrailingZeros16"}:                   struct{}{},
-       {"wasm", "math/bits", "TrailingZeros32"}:                   struct{}{},
-       {"wasm", "math/bits", "TrailingZeros64"}:                   struct{}{},
-       {"wasm", "math/bits", "TrailingZeros8"}:                    struct{}{},
-       {"wasm", "runtime", "KeepAlive"}:                           struct{}{},
-       {"wasm", "runtime", "slicebytetostringtmp"}:                struct{}{},
+       {"386", "internal/runtime/math", "MulUintptr"}:                     struct{}{},
+       {"386", "internal/runtime/sys", "Bswap32"}:                         struct{}{},
+       {"386", "internal/runtime/sys", "Bswap64"}:                         struct{}{},
+       {"386", "internal/runtime/sys", "GetCallerPC"}:                     struct{}{},
+       {"386", "internal/runtime/sys", "GetCallerSP"}:                     struct{}{},
+       {"386", "internal/runtime/sys", "GetClosurePtr"}:                   struct{}{},
+       {"386", "internal/runtime/sys", "TrailingZeros32"}:                 struct{}{},
+       {"386", "internal/runtime/sys", "TrailingZeros64"}:                 struct{}{},
+       {"386", "internal/runtime/sys", "TrailingZeros8"}:                  struct{}{},
+       {"386", "math", "sqrt"}:                                            struct{}{},
+       {"386", "math/bits", "ReverseBytes32"}:                             struct{}{},
+       {"386", "math/bits", "ReverseBytes64"}:                             struct{}{},
+       {"386", "math/bits", "TrailingZeros16"}:                            struct{}{},
+       {"386", "math/bits", "TrailingZeros32"}:                            struct{}{},
+       {"386", "math/bits", "TrailingZeros64"}:                            struct{}{},
+       {"386", "math/bits", "TrailingZeros8"}:                             struct{}{},
+       {"386", "runtime", "KeepAlive"}:                                    struct{}{},
+       {"386", "runtime", "slicebytetostringtmp"}:                         struct{}{},
+       {"amd64", "internal/runtime/atomic", "And"}:                        struct{}{},
+       {"amd64", "internal/runtime/atomic", "And32"}:                      struct{}{},
+       {"amd64", "internal/runtime/atomic", "And64"}:                      struct{}{},
+       {"amd64", "internal/runtime/atomic", "And8"}:                       struct{}{},
+       {"amd64", "internal/runtime/atomic", "Cas"}:                        struct{}{},
+       {"amd64", "internal/runtime/atomic", "Cas64"}:                      struct{}{},
+       {"amd64", "internal/runtime/atomic", "CasRel"}:                     struct{}{},
+       {"amd64", "internal/runtime/atomic", "Casint32"}:                   struct{}{},
+       {"amd64", "internal/runtime/atomic", "Casint64"}:                   struct{}{},
+       {"amd64", "internal/runtime/atomic", "Casp1"}:                      struct{}{},
+       {"amd64", "internal/runtime/atomic", "Casuintptr"}:                 struct{}{},
+       {"amd64", "internal/runtime/atomic", "Load"}:                       struct{}{},
+       {"amd64", "internal/runtime/atomic", "Load64"}:                     struct{}{},
+       {"amd64", "internal/runtime/atomic", "Load8"}:                      struct{}{},
+       {"amd64", "internal/runtime/atomic", "LoadAcq"}:                    struct{}{},
+       {"amd64", "internal/runtime/atomic", "LoadAcq64"}:                  struct{}{},
+       {"amd64", "internal/runtime/atomic", "LoadAcquintptr"}:             struct{}{},
+       {"amd64", "internal/runtime/atomic", "Loadint32"}:                  struct{}{},
+       {"amd64", "internal/runtime/atomic", "Loadint64"}:                  struct{}{},
+       {"amd64", "internal/runtime/atomic", "Loadp"}:                      struct{}{},
+       {"amd64", "internal/runtime/atomic", "Loaduint"}:                   struct{}{},
+       {"amd64", "internal/runtime/atomic", "Loaduintptr"}:                struct{}{},
+       {"amd64", "internal/runtime/atomic", "Or"}:                         struct{}{},
+       {"amd64", "internal/runtime/atomic", "Or32"}:                       struct{}{},
+       {"amd64", "internal/runtime/atomic", "Or64"}:                       struct{}{},
+       {"amd64", "internal/runtime/atomic", "Or8"}:                        struct{}{},
+       {"amd64", "internal/runtime/atomic", "Store"}:                      struct{}{},
+       {"amd64", "internal/runtime/atomic", "Store64"}:                    struct{}{},
+       {"amd64", "internal/runtime/atomic", "Store8"}:                     struct{}{},
+       {"amd64", "internal/runtime/atomic", "StoreRel"}:                   struct{}{},
+       {"amd64", "internal/runtime/atomic", "StoreRel64"}:                 struct{}{},
+       {"amd64", "internal/runtime/atomic", "StoreReluintptr"}:            struct{}{},
+       {"amd64", "internal/runtime/atomic", "Storeint32"}:                 struct{}{},
+       {"amd64", "internal/runtime/atomic", "Storeint64"}:                 struct{}{},
+       {"amd64", "internal/runtime/atomic", "StorepNoWB"}:                 struct{}{},
+       {"amd64", "internal/runtime/atomic", "Storeuintptr"}:               struct{}{},
+       {"amd64", "internal/runtime/atomic", "Xadd"}:                       struct{}{},
+       {"amd64", "internal/runtime/atomic", "Xadd64"}:                     struct{}{},
+       {"amd64", "internal/runtime/atomic", "Xaddint32"}:                  struct{}{},
+       {"amd64", "internal/runtime/atomic", "Xaddint64"}:                  struct{}{},
+       {"amd64", "internal/runtime/atomic", "Xadduintptr"}:                struct{}{},
+       {"amd64", "internal/runtime/atomic", "Xchg"}:                       struct{}{},
+       {"amd64", "internal/runtime/atomic", "Xchg64"}:                     struct{}{},
+       {"amd64", "internal/runtime/atomic", "Xchg8"}:                      struct{}{},
+       {"amd64", "internal/runtime/atomic", "Xchgint32"}:                  struct{}{},
+       {"amd64", "internal/runtime/atomic", "Xchgint64"}:                  struct{}{},
+       {"amd64", "internal/runtime/atomic", "Xchguintptr"}:                struct{}{},
+       {"amd64", "internal/runtime/maps", "bitsetFirst"}:                  struct{}{},
+       {"amd64", "internal/runtime/maps", "bitsetRemoveBelow"}:            struct{}{},
+       {"amd64", "internal/runtime/maps", "bitsetLowestSet"}:              struct{}{},
+       {"amd64", "internal/runtime/maps", "bitsetShiftOutLowest"}:         struct{}{},
+       {"amd64", "internal/runtime/maps", "ctrlGroupMatchH2"}:             struct{}{},
+       {"amd64", "internal/runtime/maps", "ctrlGroupMatchEmpty"}:          struct{}{},
+       {"amd64", "internal/runtime/maps", "ctrlGroupMatchEmptyOrDeleted"}: struct{}{},
+       {"amd64", "internal/runtime/maps", "ctrlGroupMatchFull"}:           struct{}{},
+       {"amd64", "internal/runtime/math", "Add64"}:                        struct{}{},
+       {"amd64", "internal/runtime/math", "Mul64"}:                        struct{}{},
+       {"amd64", "internal/runtime/math", "MulUintptr"}:                   struct{}{},
+       {"amd64", "internal/runtime/sys", "Bswap32"}:                       struct{}{},
+       {"amd64", "internal/runtime/sys", "Bswap64"}:                       struct{}{},
+       {"amd64", "internal/runtime/sys", "GetCallerPC"}:                   struct{}{},
+       {"amd64", "internal/runtime/sys", "GetCallerSP"}:                   struct{}{},
+       {"amd64", "internal/runtime/sys", "GetClosurePtr"}:                 struct{}{},
+       {"amd64", "internal/runtime/sys", "Len64"}:                         struct{}{},
+       {"amd64", "internal/runtime/sys", "Len8"}:                          struct{}{},
+       {"amd64", "internal/runtime/sys", "OnesCount64"}:                   struct{}{},
+       {"amd64", "internal/runtime/sys", "Prefetch"}:                      struct{}{},
+       {"amd64", "internal/runtime/sys", "PrefetchStreamed"}:              struct{}{},
+       {"amd64", "internal/runtime/sys", "TrailingZeros32"}:               struct{}{},
+       {"amd64", "internal/runtime/sys", "TrailingZeros64"}:               struct{}{},
+       {"amd64", "internal/runtime/sys", "TrailingZeros8"}:                struct{}{},
+       {"amd64", "math", "Ceil"}:                                          struct{}{},
+       {"amd64", "math", "FMA"}:                                           struct{}{},
+       {"amd64", "math", "Floor"}:                                         struct{}{},
+       {"amd64", "math", "RoundToEven"}:                                   struct{}{},
+       {"amd64", "math", "Trunc"}:                                         struct{}{},
+       {"amd64", "math", "sqrt"}:                                          struct{}{},
+       {"amd64", "math/big", "mulWW"}:                                     struct{}{},
+       {"amd64", "math/bits", "Add"}:                                      struct{}{},
+       {"amd64", "math/bits", "Add64"}:                                    struct{}{},
+       {"amd64", "math/bits", "Div"}:                                      struct{}{},
+       {"amd64", "math/bits", "Div64"}:                                    struct{}{},
+       {"amd64", "math/bits", "Len"}:                                      struct{}{},
+       {"amd64", "math/bits", "Len16"}:                                    struct{}{},
+       {"amd64", "math/bits", "Len32"}:                                    struct{}{},
+       {"amd64", "math/bits", "Len64"}:                                    struct{}{},
+       {"amd64", "math/bits", "Len8"}:                                     struct{}{},
+       {"amd64", "math/bits", "Mul"}:                                      struct{}{},
+       {"amd64", "math/bits", "Mul64"}:                                    struct{}{},
+       {"amd64", "math/bits", "OnesCount"}:                                struct{}{},
+       {"amd64", "math/bits", "OnesCount16"}:                              struct{}{},
+       {"amd64", "math/bits", "OnesCount32"}:                              struct{}{},
+       {"amd64", "math/bits", "OnesCount64"}:                              struct{}{},
+       {"amd64", "math/bits", "ReverseBytes32"}:                           struct{}{},
+       {"amd64", "math/bits", "ReverseBytes64"}:                           struct{}{},
+       {"amd64", "math/bits", "RotateLeft"}:                               struct{}{},
+       {"amd64", "math/bits", "RotateLeft16"}:                             struct{}{},
+       {"amd64", "math/bits", "RotateLeft32"}:                             struct{}{},
+       {"amd64", "math/bits", "RotateLeft64"}:                             struct{}{},
+       {"amd64", "math/bits", "RotateLeft8"}:                              struct{}{},
+       {"amd64", "math/bits", "Sub"}:                                      struct{}{},
+       {"amd64", "math/bits", "Sub64"}:                                    struct{}{},
+       {"amd64", "math/bits", "TrailingZeros16"}:                          struct{}{},
+       {"amd64", "math/bits", "TrailingZeros32"}:                          struct{}{},
+       {"amd64", "math/bits", "TrailingZeros64"}:                          struct{}{},
+       {"amd64", "math/bits", "TrailingZeros8"}:                           struct{}{},
+       {"amd64", "runtime", "KeepAlive"}:                                  struct{}{},
+       {"amd64", "runtime", "slicebytetostringtmp"}:                       struct{}{},
+       {"amd64", "sync", "runtime_LoadAcquintptr"}:                        struct{}{},
+       {"amd64", "sync", "runtime_StoreReluintptr"}:                       struct{}{},
+       {"amd64", "sync/atomic", "AddInt32"}:                               struct{}{},
+       {"amd64", "sync/atomic", "AddInt64"}:                               struct{}{},
+       {"amd64", "sync/atomic", "AddUint32"}:                              struct{}{},
+       {"amd64", "sync/atomic", "AddUint64"}:                              struct{}{},
+       {"amd64", "sync/atomic", "AddUintptr"}:                             struct{}{},
+       {"amd64", "sync/atomic", "AndInt32"}:                               struct{}{},
+       {"amd64", "sync/atomic", "AndInt64"}:                               struct{}{},
+       {"amd64", "sync/atomic", "AndUint32"}:                              struct{}{},
+       {"amd64", "sync/atomic", "AndUint64"}:                              struct{}{},
+       {"amd64", "sync/atomic", "AndUintptr"}:                             struct{}{},
+       {"amd64", "sync/atomic", "CompareAndSwapInt32"}:                    struct{}{},
+       {"amd64", "sync/atomic", "CompareAndSwapInt64"}:                    struct{}{},
+       {"amd64", "sync/atomic", "CompareAndSwapUint32"}:                   struct{}{},
+       {"amd64", "sync/atomic", "CompareAndSwapUint64"}:                   struct{}{},
+       {"amd64", "sync/atomic", "CompareAndSwapUintptr"}:                  struct{}{},
+       {"amd64", "sync/atomic", "LoadInt32"}:                              struct{}{},
+       {"amd64", "sync/atomic", "LoadInt64"}:                              struct{}{},
+       {"amd64", "sync/atomic", "LoadPointer"}:                            struct{}{},
+       {"amd64", "sync/atomic", "LoadUint32"}:                             struct{}{},
+       {"amd64", "sync/atomic", "LoadUint64"}:                             struct{}{},
+       {"amd64", "sync/atomic", "LoadUintptr"}:                            struct{}{},
+       {"amd64", "sync/atomic", "OrInt32"}:                                struct{}{},
+       {"amd64", "sync/atomic", "OrInt64"}:                                struct{}{},
+       {"amd64", "sync/atomic", "OrUint32"}:                               struct{}{},
+       {"amd64", "sync/atomic", "OrUint64"}:                               struct{}{},
+       {"amd64", "sync/atomic", "OrUintptr"}:                              struct{}{},
+       {"amd64", "sync/atomic", "StoreInt32"}:                             struct{}{},
+       {"amd64", "sync/atomic", "StoreInt64"}:                             struct{}{},
+       {"amd64", "sync/atomic", "StoreUint32"}:                            struct{}{},
+       {"amd64", "sync/atomic", "StoreUint64"}:                            struct{}{},
+       {"amd64", "sync/atomic", "StoreUintptr"}:                           struct{}{},
+       {"amd64", "sync/atomic", "SwapInt32"}:                              struct{}{},
+       {"amd64", "sync/atomic", "SwapInt64"}:                              struct{}{},
+       {"amd64", "sync/atomic", "SwapUint32"}:                             struct{}{},
+       {"amd64", "sync/atomic", "SwapUint64"}:                             struct{}{},
+       {"amd64", "sync/atomic", "SwapUintptr"}:                            struct{}{},
+       {"arm", "internal/runtime/sys", "Bswap32"}:                         struct{}{},
+       {"arm", "internal/runtime/sys", "Bswap64"}:                         struct{}{},
+       {"arm", "internal/runtime/sys", "GetCallerPC"}:                     struct{}{},
+       {"arm", "internal/runtime/sys", "GetCallerSP"}:                     struct{}{},
+       {"arm", "internal/runtime/sys", "GetClosurePtr"}:                   struct{}{},
+       {"arm", "internal/runtime/sys", "Len64"}:                           struct{}{},
+       {"arm", "internal/runtime/sys", "Len8"}:                            struct{}{},
+       {"arm", "internal/runtime/sys", "TrailingZeros32"}:                 struct{}{},
+       {"arm", "internal/runtime/sys", "TrailingZeros64"}:                 struct{}{},
+       {"arm", "internal/runtime/sys", "TrailingZeros8"}:                  struct{}{},
+       {"arm", "math", "Abs"}:                                             struct{}{},
+       {"arm", "math", "FMA"}:                                             struct{}{},
+       {"arm", "math", "sqrt"}:                                            struct{}{},
+       {"arm", "math/bits", "Len"}:                                        struct{}{},
+       {"arm", "math/bits", "Len16"}:                                      struct{}{},
+       {"arm", "math/bits", "Len32"}:                                      struct{}{},
+       {"arm", "math/bits", "Len64"}:                                      struct{}{},
+       {"arm", "math/bits", "Len8"}:                                       struct{}{},
+       {"arm", "math/bits", "ReverseBytes32"}:                             struct{}{},
+       {"arm", "math/bits", "ReverseBytes64"}:                             struct{}{},
+       {"arm", "math/bits", "RotateLeft32"}:                               struct{}{},
+       {"arm", "math/bits", "TrailingZeros16"}:                            struct{}{},
+       {"arm", "math/bits", "TrailingZeros32"}:                            struct{}{},
+       {"arm", "math/bits", "TrailingZeros64"}:                            struct{}{},
+       {"arm", "math/bits", "TrailingZeros8"}:                             struct{}{},
+       {"arm", "runtime", "KeepAlive"}:                                    struct{}{},
+       {"arm", "runtime", "slicebytetostringtmp"}:                         struct{}{},
+       {"arm64", "internal/runtime/atomic", "And"}:                        struct{}{},
+       {"arm64", "internal/runtime/atomic", "And32"}:                      struct{}{},
+       {"arm64", "internal/runtime/atomic", "And64"}:                      struct{}{},
+       {"arm64", "internal/runtime/atomic", "And8"}:                       struct{}{},
+       {"arm64", "internal/runtime/atomic", "Anduintptr"}:                 struct{}{},
+       {"arm64", "internal/runtime/atomic", "Cas"}:                        struct{}{},
+       {"arm64", "internal/runtime/atomic", "Cas64"}:                      struct{}{},
+       {"arm64", "internal/runtime/atomic", "CasRel"}:                     struct{}{},
+       {"arm64", "internal/runtime/atomic", "Casint32"}:                   struct{}{},
+       {"arm64", "internal/runtime/atomic", "Casint64"}:                   struct{}{},
+       {"arm64", "internal/runtime/atomic", "Casp1"}:                      struct{}{},
+       {"arm64", "internal/runtime/atomic", "Casuintptr"}:                 struct{}{},
+       {"arm64", "internal/runtime/atomic", "Load"}:                       struct{}{},
+       {"arm64", "internal/runtime/atomic", "Load64"}:                     struct{}{},
+       {"arm64", "internal/runtime/atomic", "Load8"}:                      struct{}{},
+       {"arm64", "internal/runtime/atomic", "LoadAcq"}:                    struct{}{},
+       {"arm64", "internal/runtime/atomic", "LoadAcq64"}:                  struct{}{},
+       {"arm64", "internal/runtime/atomic", "LoadAcquintptr"}:             struct{}{},
+       {"arm64", "internal/runtime/atomic", "Loadint32"}:                  struct{}{},
+       {"arm64", "internal/runtime/atomic", "Loadint64"}:                  struct{}{},
+       {"arm64", "internal/runtime/atomic", "Loadp"}:                      struct{}{},
+       {"arm64", "internal/runtime/atomic", "Loaduint"}:                   struct{}{},
+       {"arm64", "internal/runtime/atomic", "Loaduintptr"}:                struct{}{},
+       {"arm64", "internal/runtime/atomic", "Or"}:                         struct{}{},
+       {"arm64", "internal/runtime/atomic", "Or32"}:                       struct{}{},
+       {"arm64", "internal/runtime/atomic", "Or64"}:                       struct{}{},
+       {"arm64", "internal/runtime/atomic", "Or8"}:                        struct{}{},
+       {"arm64", "internal/runtime/atomic", "Oruintptr"}:                  struct{}{},
+       {"arm64", "internal/runtime/atomic", "Store"}:                      struct{}{},
+       {"arm64", "internal/runtime/atomic", "Store64"}:                    struct{}{},
+       {"arm64", "internal/runtime/atomic", "Store8"}:                     struct{}{},
+       {"arm64", "internal/runtime/atomic", "StoreRel"}:                   struct{}{},
+       {"arm64", "internal/runtime/atomic", "StoreRel64"}:                 struct{}{},
+       {"arm64", "internal/runtime/atomic", "StoreReluintptr"}:            struct{}{},
+       {"arm64", "internal/runtime/atomic", "Storeint32"}:                 struct{}{},
+       {"arm64", "internal/runtime/atomic", "Storeint64"}:                 struct{}{},
+       {"arm64", "internal/runtime/atomic", "StorepNoWB"}:                 struct{}{},
+       {"arm64", "internal/runtime/atomic", "Storeuintptr"}:               struct{}{},
+       {"arm64", "internal/runtime/atomic", "Xadd"}:                       struct{}{},
+       {"arm64", "internal/runtime/atomic", "Xadd64"}:                     struct{}{},
+       {"arm64", "internal/runtime/atomic", "Xaddint32"}:                  struct{}{},
+       {"arm64", "internal/runtime/atomic", "Xaddint64"}:                  struct{}{},
+       {"arm64", "internal/runtime/atomic", "Xadduintptr"}:                struct{}{},
+       {"arm64", "internal/runtime/atomic", "Xchg8"}:                      struct{}{},
+       {"arm64", "internal/runtime/atomic", "Xchg"}:                       struct{}{},
+       {"arm64", "internal/runtime/atomic", "Xchg64"}:                     struct{}{},
+       {"arm64", "internal/runtime/atomic", "Xchgint32"}:                  struct{}{},
+       {"arm64", "internal/runtime/atomic", "Xchgint64"}:                  struct{}{},
+       {"arm64", "internal/runtime/atomic", "Xchguintptr"}:                struct{}{},
+       {"arm64", "internal/runtime/math", "Add64"}:                        struct{}{},
+       {"arm64", "internal/runtime/math", "Mul64"}:                        struct{}{},
+       {"arm64", "internal/runtime/math", "MulUintptr"}:                   struct{}{},
+       {"arm64", "internal/runtime/sys", "Bswap32"}:                       struct{}{},
+       {"arm64", "internal/runtime/sys", "Bswap64"}:                       struct{}{},
+       {"arm64", "internal/runtime/sys", "GetCallerPC"}:                   struct{}{},
+       {"arm64", "internal/runtime/sys", "GetCallerSP"}:                   struct{}{},
+       {"arm64", "internal/runtime/sys", "GetClosurePtr"}:                 struct{}{},
+       {"arm64", "internal/runtime/sys", "Len64"}:                         struct{}{},
+       {"arm64", "internal/runtime/sys", "Len8"}:                          struct{}{},
+       {"arm64", "internal/runtime/sys", "OnesCount64"}:                   struct{}{},
+       {"arm64", "internal/runtime/sys", "Prefetch"}:                      struct{}{},
+       {"arm64", "internal/runtime/sys", "PrefetchStreamed"}:              struct{}{},
+       {"arm64", "internal/runtime/sys", "TrailingZeros32"}:               struct{}{},
+       {"arm64", "internal/runtime/sys", "TrailingZeros64"}:               struct{}{},
+       {"arm64", "internal/runtime/sys", "TrailingZeros8"}:                struct{}{},
+       {"arm64", "math", "Abs"}:                                           struct{}{},
+       {"arm64", "math", "Ceil"}:                                          struct{}{},
+       {"arm64", "math", "FMA"}:                                           struct{}{},
+       {"arm64", "math", "Floor"}:                                         struct{}{},
+       {"arm64", "math", "Round"}:                                         struct{}{},
+       {"arm64", "math", "RoundToEven"}:                                   struct{}{},
+       {"arm64", "math", "Trunc"}:                                         struct{}{},
+       {"arm64", "math", "sqrt"}:                                          struct{}{},
+       {"arm64", "math/big", "mulWW"}:                                     struct{}{},
+       {"arm64", "math/bits", "Add"}:                                      struct{}{},
+       {"arm64", "math/bits", "Add64"}:                                    struct{}{},
+       {"arm64", "math/bits", "Len"}:                                      struct{}{},
+       {"arm64", "math/bits", "Len16"}:                                    struct{}{},
+       {"arm64", "math/bits", "Len32"}:                                    struct{}{},
+       {"arm64", "math/bits", "Len64"}:                                    struct{}{},
+       {"arm64", "math/bits", "Len8"}:                                     struct{}{},
+       {"arm64", "math/bits", "Mul"}:                                      struct{}{},
+       {"arm64", "math/bits", "Mul64"}:                                    struct{}{},
+       {"arm64", "math/bits", "OnesCount16"}:                              struct{}{},
+       {"arm64", "math/bits", "OnesCount32"}:                              struct{}{},
+       {"arm64", "math/bits", "OnesCount64"}:                              struct{}{},
+       {"arm64", "math/bits", "Reverse"}:                                  struct{}{},
+       {"arm64", "math/bits", "Reverse16"}:                                struct{}{},
+       {"arm64", "math/bits", "Reverse32"}:                                struct{}{},
+       {"arm64", "math/bits", "Reverse64"}:                                struct{}{},
+       {"arm64", "math/bits", "Reverse8"}:                                 struct{}{},
+       {"arm64", "math/bits", "ReverseBytes32"}:                           struct{}{},
+       {"arm64", "math/bits", "ReverseBytes64"}:                           struct{}{},
+       {"arm64", "math/bits", "RotateLeft"}:                               struct{}{},
+       {"arm64", "math/bits", "RotateLeft32"}:                             struct{}{},
+       {"arm64", "math/bits", "RotateLeft64"}:                             struct{}{},
+       {"arm64", "math/bits", "Sub"}:                                      struct{}{},
+       {"arm64", "math/bits", "Sub64"}:                                    struct{}{},
+       {"arm64", "math/bits", "TrailingZeros16"}:                          struct{}{},
+       {"arm64", "math/bits", "TrailingZeros32"}:                          struct{}{},
+       {"arm64", "math/bits", "TrailingZeros64"}:                          struct{}{},
+       {"arm64", "math/bits", "TrailingZeros8"}:                           struct{}{},
+       {"arm64", "runtime", "KeepAlive"}:                                  struct{}{},
+       {"arm64", "runtime", "publicationBarrier"}:                         struct{}{},
+       {"arm64", "runtime", "slicebytetostringtmp"}:                       struct{}{},
+       {"arm64", "sync", "runtime_LoadAcquintptr"}:                        struct{}{},
+       {"arm64", "sync", "runtime_StoreReluintptr"}:                       struct{}{},
+       {"arm64", "sync/atomic", "AddInt32"}:                               struct{}{},
+       {"arm64", "sync/atomic", "AddInt64"}:                               struct{}{},
+       {"arm64", "sync/atomic", "AddUint32"}:                              struct{}{},
+       {"arm64", "sync/atomic", "AddUint64"}:                              struct{}{},
+       {"arm64", "sync/atomic", "AddUintptr"}:                             struct{}{},
+       {"arm64", "sync/atomic", "AndInt32"}:                               struct{}{},
+       {"arm64", "sync/atomic", "AndInt64"}:                               struct{}{},
+       {"arm64", "sync/atomic", "AndUint32"}:                              struct{}{},
+       {"arm64", "sync/atomic", "AndUint64"}:                              struct{}{},
+       {"arm64", "sync/atomic", "AndUintptr"}:                             struct{}{},
+       {"arm64", "sync/atomic", "CompareAndSwapInt32"}:                    struct{}{},
+       {"arm64", "sync/atomic", "CompareAndSwapInt64"}:                    struct{}{},
+       {"arm64", "sync/atomic", "CompareAndSwapUint32"}:                   struct{}{},
+       {"arm64", "sync/atomic", "CompareAndSwapUint64"}:                   struct{}{},
+       {"arm64", "sync/atomic", "CompareAndSwapUintptr"}:                  struct{}{},
+       {"arm64", "sync/atomic", "LoadInt32"}:                              struct{}{},
+       {"arm64", "sync/atomic", "LoadInt64"}:                              struct{}{},
+       {"arm64", "sync/atomic", "LoadPointer"}:                            struct{}{},
+       {"arm64", "sync/atomic", "LoadUint32"}:                             struct{}{},
+       {"arm64", "sync/atomic", "LoadUint64"}:                             struct{}{},
+       {"arm64", "sync/atomic", "LoadUintptr"}:                            struct{}{},
+       {"arm64", "sync/atomic", "OrInt32"}:                                struct{}{},
+       {"arm64", "sync/atomic", "OrInt64"}:                                struct{}{},
+       {"arm64", "sync/atomic", "OrUint32"}:                               struct{}{},
+       {"arm64", "sync/atomic", "OrUint64"}:                               struct{}{},
+       {"arm64", "sync/atomic", "OrUintptr"}:                              struct{}{},
+       {"arm64", "sync/atomic", "StoreInt32"}:                             struct{}{},
+       {"arm64", "sync/atomic", "StoreInt64"}:                             struct{}{},
+       {"arm64", "sync/atomic", "StoreUint32"}:                            struct{}{},
+       {"arm64", "sync/atomic", "StoreUint64"}:                            struct{}{},
+       {"arm64", "sync/atomic", "StoreUintptr"}:                           struct{}{},
+       {"arm64", "sync/atomic", "SwapInt32"}:                              struct{}{},
+       {"arm64", "sync/atomic", "SwapInt64"}:                              struct{}{},
+       {"arm64", "sync/atomic", "SwapUint32"}:                             struct{}{},
+       {"arm64", "sync/atomic", "SwapUint64"}:                             struct{}{},
+       {"arm64", "sync/atomic", "SwapUintptr"}:                            struct{}{},
+       {"loong64", "internal/runtime/atomic", "And"}:                      struct{}{},
+       {"loong64", "internal/runtime/atomic", "And32"}:                    struct{}{},
+       {"loong64", "internal/runtime/atomic", "And64"}:                    struct{}{},
+       {"loong64", "internal/runtime/atomic", "And8"}:                     struct{}{},
+       {"loong64", "internal/runtime/atomic", "Anduintptr"}:               struct{}{},
+       {"loong64", "internal/runtime/atomic", "Cas"}:                      struct{}{},
+       {"loong64", "internal/runtime/atomic", "Cas64"}:                    struct{}{},
+       {"loong64", "internal/runtime/atomic", "CasRel"}:                   struct{}{},
+       {"loong64", "internal/runtime/atomic", "Casint32"}:                 struct{}{},
+       {"loong64", "internal/runtime/atomic", "Casint64"}:                 struct{}{},
+       {"loong64", "internal/runtime/atomic", "Casp1"}:                    struct{}{},
+       {"loong64", "internal/runtime/atomic", "Casuintptr"}:               struct{}{},
+       {"loong64", "internal/runtime/atomic", "Load"}:                     struct{}{},
+       {"loong64", "internal/runtime/atomic", "Load64"}:                   struct{}{},
+       {"loong64", "internal/runtime/atomic", "Load8"}:                    struct{}{},
+       {"loong64", "internal/runtime/atomic", "LoadAcq"}:                  struct{}{},
+       {"loong64", "internal/runtime/atomic", "LoadAcq64"}:                struct{}{},
+       {"loong64", "internal/runtime/atomic", "LoadAcquintptr"}:           struct{}{},
+       {"loong64", "internal/runtime/atomic", "Loadint32"}:                struct{}{},
+       {"loong64", "internal/runtime/atomic", "Loadint64"}:                struct{}{},
+       {"loong64", "internal/runtime/atomic", "Loadp"}:                    struct{}{},
+       {"loong64", "internal/runtime/atomic", "Loaduint"}:                 struct{}{},
+       {"loong64", "internal/runtime/atomic", "Loaduintptr"}:              struct{}{},
+       {"loong64", "internal/runtime/atomic", "Or"}:                       struct{}{},
+       {"loong64", "internal/runtime/atomic", "Or32"}:                     struct{}{},
+       {"loong64", "internal/runtime/atomic", "Or64"}:                     struct{}{},
+       {"loong64", "internal/runtime/atomic", "Or8"}:                      struct{}{},
+       {"loong64", "internal/runtime/atomic", "Oruintptr"}:                struct{}{},
+       {"loong64", "internal/runtime/atomic", "Store"}:                    struct{}{},
+       {"loong64", "internal/runtime/atomic", "Store64"}:                  struct{}{},
+       {"loong64", "internal/runtime/atomic", "Store8"}:                   struct{}{},
+       {"loong64", "internal/runtime/atomic", "StoreRel"}:                 struct{}{},
+       {"loong64", "internal/runtime/atomic", "StoreRel64"}:               struct{}{},
+       {"loong64", "internal/runtime/atomic", "StoreReluintptr"}:          struct{}{},
+       {"loong64", "internal/runtime/atomic", "Storeint32"}:               struct{}{},
+       {"loong64", "internal/runtime/atomic", "Storeint64"}:               struct{}{},
+       {"loong64", "internal/runtime/atomic", "StorepNoWB"}:               struct{}{},
+       {"loong64", "internal/runtime/atomic", "Storeuintptr"}:             struct{}{},
+       {"loong64", "internal/runtime/atomic", "Xadd"}:                     struct{}{},
+       {"loong64", "internal/runtime/atomic", "Xadd64"}:                   struct{}{},
+       {"loong64", "internal/runtime/atomic", "Xaddint32"}:                struct{}{},
+       {"loong64", "internal/runtime/atomic", "Xaddint64"}:                struct{}{},
+       {"loong64", "internal/runtime/atomic", "Xadduintptr"}:              struct{}{},
+       {"loong64", "internal/runtime/atomic", "Xchg8"}:                    struct{}{},
+       {"loong64", "internal/runtime/atomic", "Xchg"}:                     struct{}{},
+       {"loong64", "internal/runtime/atomic", "Xchg64"}:                   struct{}{},
+       {"loong64", "internal/runtime/atomic", "Xchgint32"}:                struct{}{},
+       {"loong64", "internal/runtime/atomic", "Xchgint64"}:                struct{}{},
+       {"loong64", "internal/runtime/atomic", "Xchguintptr"}:              struct{}{},
+       {"loong64", "internal/runtime/math", "Add64"}:                      struct{}{},
+       {"loong64", "internal/runtime/math", "Mul64"}:                      struct{}{},
+       {"loong64", "internal/runtime/math", "MulUintptr"}:                 struct{}{},
+       {"loong64", "internal/runtime/sys", "Bswap32"}:                     struct{}{},
+       {"loong64", "internal/runtime/sys", "Bswap64"}:                     struct{}{},
+       {"loong64", "internal/runtime/sys", "GetCallerPC"}:                 struct{}{},
+       {"loong64", "internal/runtime/sys", "GetCallerSP"}:                 struct{}{},
+       {"loong64", "internal/runtime/sys", "GetClosurePtr"}:               struct{}{},
+       {"loong64", "internal/runtime/sys", "Len64"}:                       struct{}{},
+       {"loong64", "internal/runtime/sys", "Len8"}:                        struct{}{},
+       {"loong64", "internal/runtime/sys", "OnesCount64"}:                 struct{}{},
+       {"loong64", "internal/runtime/sys", "TrailingZeros32"}:             struct{}{},
+       {"loong64", "internal/runtime/sys", "TrailingZeros64"}:             struct{}{},
+       {"loong64", "internal/runtime/sys", "TrailingZeros8"}:              struct{}{},
+       {"loong64", "math", "Abs"}:                                         struct{}{},
+       {"loong64", "math", "Copysign"}:                                    struct{}{},
+       {"loong64", "math", "FMA"}:                                         struct{}{},
+       {"loong64", "math", "sqrt"}:                                        struct{}{},
+       {"loong64", "math/big", "mulWW"}:                                   struct{}{},
+       {"loong64", "math/bits", "Add"}:                                    struct{}{},
+       {"loong64", "math/bits", "Add64"}:                                  struct{}{},
+       {"loong64", "math/bits", "Mul"}:                                    struct{}{},
+       {"loong64", "math/bits", "Mul64"}:                                  struct{}{},
+       {"loong64", "math/bits", "Len"}:                                    struct{}{},
+       {"loong64", "math/bits", "Len8"}:                                   struct{}{},
+       {"loong64", "math/bits", "Len16"}:                                  struct{}{},
+       {"loong64", "math/bits", "Len32"}:                                  struct{}{},
+       {"loong64", "math/bits", "Len64"}:                                  struct{}{},
+       {"loong64", "math/bits", "OnesCount16"}:                            struct{}{},
+       {"loong64", "math/bits", "OnesCount32"}:                            struct{}{},
+       {"loong64", "math/bits", "OnesCount64"}:                            struct{}{},
+       {"loong64", "math/bits", "Reverse"}:                                struct{}{},
+       {"loong64", "math/bits", "Reverse8"}:                               struct{}{},
+       {"loong64", "math/bits", "Reverse16"}:                              struct{}{},
+       {"loong64", "math/bits", "Reverse32"}:                              struct{}{},
+       {"loong64", "math/bits", "Reverse64"}:                              struct{}{},
+       {"loong64", "math/bits", "RotateLeft"}:                             struct{}{},
+       {"loong64", "math/bits", "RotateLeft32"}:                           struct{}{},
+       {"loong64", "math/bits", "RotateLeft64"}:                           struct{}{},
+       {"loong64", "math/bits", "ReverseBytes16"}:                         struct{}{},
+       {"loong64", "math/bits", "ReverseBytes32"}:                         struct{}{},
+       {"loong64", "math/bits", "ReverseBytes64"}:                         struct{}{},
+       {"loong64", "math/bits", "TrailingZeros16"}:                        struct{}{},
+       {"loong64", "math/bits", "TrailingZeros32"}:                        struct{}{},
+       {"loong64", "math/bits", "TrailingZeros64"}:                        struct{}{},
+       {"loong64", "math/bits", "TrailingZeros8"}:                         struct{}{},
+       {"loong64", "math/bits", "Sub"}:                                    struct{}{},
+       {"loong64", "math/bits", "Sub64"}:                                  struct{}{},
+       {"loong64", "runtime", "KeepAlive"}:                                struct{}{},
+       {"loong64", "runtime", "publicationBarrier"}:                       struct{}{},
+       {"loong64", "runtime", "slicebytetostringtmp"}:                     struct{}{},
+       {"loong64", "sync", "runtime_LoadAcquintptr"}:                      struct{}{},
+       {"loong64", "sync", "runtime_StoreReluintptr"}:                     struct{}{},
+       {"loong64", "sync/atomic", "AddInt32"}:                             struct{}{},
+       {"loong64", "sync/atomic", "AddInt64"}:                             struct{}{},
+       {"loong64", "sync/atomic", "AddUint32"}:                            struct{}{},
+       {"loong64", "sync/atomic", "AddUint64"}:                            struct{}{},
+       {"loong64", "sync/atomic", "AddUintptr"}:                           struct{}{},
+       {"loong64", "sync/atomic", "AddInt32"}:                             struct{}{},
+       {"loong64", "sync/atomic", "AddInt64"}:                             struct{}{},
+       {"loong64", "sync/atomic", "AddUint32"}:                            struct{}{},
+       {"loong64", "sync/atomic", "AddUint64"}:                            struct{}{},
+       {"loong64", "sync/atomic", "AddUintptr"}:                           struct{}{},
+       {"loong64", "sync/atomic", "AndInt32"}:                             struct{}{},
+       {"loong64", "sync/atomic", "AndInt64"}:                             struct{}{},
+       {"loong64", "sync/atomic", "AndUint32"}:                            struct{}{},
+       {"loong64", "sync/atomic", "AndUint64"}:                            struct{}{},
+       {"loong64", "sync/atomic", "AndUintptr"}:                           struct{}{},
+       {"loong64", "sync/atomic", "CompareAndSwapInt32"}:                  struct{}{},
+       {"loong64", "sync/atomic", "CompareAndSwapInt64"}:                  struct{}{},
+       {"loong64", "sync/atomic", "CompareAndSwapUint32"}:                 struct{}{},
+       {"loong64", "sync/atomic", "CompareAndSwapUint64"}:                 struct{}{},
+       {"loong64", "sync/atomic", "CompareAndSwapUintptr"}:                struct{}{},
+       {"loong64", "sync/atomic", "LoadInt32"}:                            struct{}{},
+       {"loong64", "sync/atomic", "LoadInt64"}:                            struct{}{},
+       {"loong64", "sync/atomic", "LoadPointer"}:                          struct{}{},
+       {"loong64", "sync/atomic", "LoadUint32"}:                           struct{}{},
+       {"loong64", "sync/atomic", "LoadUint64"}:                           struct{}{},
+       {"loong64", "sync/atomic", "LoadUintptr"}:                          struct{}{},
+       {"loong64", "sync/atomic", "OrInt32"}:                              struct{}{},
+       {"loong64", "sync/atomic", "OrInt64"}:                              struct{}{},
+       {"loong64", "sync/atomic", "OrUint32"}:                             struct{}{},
+       {"loong64", "sync/atomic", "OrUint64"}:                             struct{}{},
+       {"loong64", "sync/atomic", "OrUintptr"}:                            struct{}{},
+       {"loong64", "sync/atomic", "StoreInt32"}:                           struct{}{},
+       {"loong64", "sync/atomic", "StoreInt64"}:                           struct{}{},
+       {"loong64", "sync/atomic", "StoreUint32"}:                          struct{}{},
+       {"loong64", "sync/atomic", "StoreUint64"}:                          struct{}{},
+       {"loong64", "sync/atomic", "StoreUintptr"}:                         struct{}{},
+       {"loong64", "sync/atomic", "SwapInt32"}:                            struct{}{},
+       {"loong64", "sync/atomic", "SwapInt64"}:                            struct{}{},
+       {"loong64", "sync/atomic", "SwapUint32"}:                           struct{}{},
+       {"loong64", "sync/atomic", "SwapUint64"}:                           struct{}{},
+       {"loong64", "sync/atomic", "SwapUintptr"}:                          struct{}{},
+       {"mips", "internal/runtime/atomic", "And"}:                         struct{}{},
+       {"mips", "internal/runtime/atomic", "And8"}:                        struct{}{},
+       {"mips", "internal/runtime/atomic", "Cas"}:                         struct{}{},
+       {"mips", "internal/runtime/atomic", "CasRel"}:                      struct{}{},
+       {"mips", "internal/runtime/atomic", "Casint32"}:                    struct{}{},
+       {"mips", "internal/runtime/atomic", "Casp1"}:                       struct{}{},
+       {"mips", "internal/runtime/atomic", "Casuintptr"}:                  struct{}{},
+       {"mips", "internal/runtime/atomic", "Load"}:                        struct{}{},
+       {"mips", "internal/runtime/atomic", "Load8"}:                       struct{}{},
+       {"mips", "internal/runtime/atomic", "LoadAcq"}:                     struct{}{},
+       {"mips", "internal/runtime/atomic", "LoadAcquintptr"}:              struct{}{},
+       {"mips", "internal/runtime/atomic", "Loadint32"}:                   struct{}{},
+       {"mips", "internal/runtime/atomic", "Loadp"}:                       struct{}{},
+       {"mips", "internal/runtime/atomic", "Loaduint"}:                    struct{}{},
+       {"mips", "internal/runtime/atomic", "Loaduintptr"}:                 struct{}{},
+       {"mips", "internal/runtime/atomic", "Or"}:                          struct{}{},
+       {"mips", "internal/runtime/atomic", "Or8"}:                         struct{}{},
+       {"mips", "internal/runtime/atomic", "Store"}:                       struct{}{},
+       {"mips", "internal/runtime/atomic", "Store8"}:                      struct{}{},
+       {"mips", "internal/runtime/atomic", "StoreRel"}:                    struct{}{},
+       {"mips", "internal/runtime/atomic", "StoreReluintptr"}:             struct{}{},
+       {"mips", "internal/runtime/atomic", "Storeint32"}:                  struct{}{},
+       {"mips", "internal/runtime/atomic", "StorepNoWB"}:                  struct{}{},
+       {"mips", "internal/runtime/atomic", "Storeuintptr"}:                struct{}{},
+       {"mips", "internal/runtime/atomic", "Xadd"}:                        struct{}{},
+       {"mips", "internal/runtime/atomic", "Xaddint32"}:                   struct{}{},
+       {"mips", "internal/runtime/atomic", "Xadduintptr"}:                 struct{}{},
+       {"mips", "internal/runtime/atomic", "Xchg"}:                        struct{}{},
+       {"mips", "internal/runtime/atomic", "Xchgint32"}:                   struct{}{},
+       {"mips", "internal/runtime/atomic", "Xchguintptr"}:                 struct{}{},
+       {"mips", "internal/runtime/sys", "GetCallerPC"}:                    struct{}{},
+       {"mips", "internal/runtime/sys", "GetCallerSP"}:                    struct{}{},
+       {"mips", "internal/runtime/sys", "GetClosurePtr"}:                  struct{}{},
+       {"mips", "internal/runtime/sys", "Len64"}:                          struct{}{},
+       {"mips", "internal/runtime/sys", "Len8"}:                           struct{}{},
+       {"mips", "internal/runtime/sys", "TrailingZeros32"}:                struct{}{},
+       {"mips", "internal/runtime/sys", "TrailingZeros64"}:                struct{}{},
+       {"mips", "internal/runtime/sys", "TrailingZeros8"}:                 struct{}{},
+       {"mips", "math", "Abs"}:                                            struct{}{},
+       {"mips", "math", "sqrt"}:                                           struct{}{},
+       {"mips", "math/bits", "Len"}:                                       struct{}{},
+       {"mips", "math/bits", "Len16"}:                                     struct{}{},
+       {"mips", "math/bits", "Len32"}:                                     struct{}{},
+       {"mips", "math/bits", "Len64"}:                                     struct{}{},
+       {"mips", "math/bits", "Len8"}:                                      struct{}{},
+       {"mips", "math/bits", "TrailingZeros16"}:                           struct{}{},
+       {"mips", "math/bits", "TrailingZeros32"}:                           struct{}{},
+       {"mips", "math/bits", "TrailingZeros64"}:                           struct{}{},
+       {"mips", "math/bits", "TrailingZeros8"}:                            struct{}{},
+       {"mips", "runtime", "KeepAlive"}:                                   struct{}{},
+       {"mips", "runtime", "slicebytetostringtmp"}:                        struct{}{},
+       {"mips", "sync", "runtime_LoadAcquintptr"}:                         struct{}{},
+       {"mips", "sync", "runtime_StoreReluintptr"}:                        struct{}{},
+       {"mips", "sync/atomic", "AddInt32"}:                                struct{}{},
+       {"mips", "sync/atomic", "AddUint32"}:                               struct{}{},
+       {"mips", "sync/atomic", "AddUintptr"}:                              struct{}{},
+       {"mips", "sync/atomic", "CompareAndSwapInt32"}:                     struct{}{},
+       {"mips", "sync/atomic", "CompareAndSwapUint32"}:                    struct{}{},
+       {"mips", "sync/atomic", "CompareAndSwapUintptr"}:                   struct{}{},
+       {"mips", "sync/atomic", "LoadInt32"}:                               struct{}{},
+       {"mips", "sync/atomic", "LoadPointer"}:                             struct{}{},
+       {"mips", "sync/atomic", "LoadUint32"}:                              struct{}{},
+       {"mips", "sync/atomic", "LoadUintptr"}:                             struct{}{},
+       {"mips", "sync/atomic", "StoreInt32"}:                              struct{}{},
+       {"mips", "sync/atomic", "StoreUint32"}:                             struct{}{},
+       {"mips", "sync/atomic", "StoreUintptr"}:                            struct{}{},
+       {"mips", "sync/atomic", "SwapInt32"}:                               struct{}{},
+       {"mips", "sync/atomic", "SwapUint32"}:                              struct{}{},
+       {"mips", "sync/atomic", "SwapUintptr"}:                             struct{}{},
+       {"mips64", "internal/runtime/atomic", "And"}:                       struct{}{},
+       {"mips64", "internal/runtime/atomic", "And8"}:                      struct{}{},
+       {"mips64", "internal/runtime/atomic", "Cas"}:                       struct{}{},
+       {"mips64", "internal/runtime/atomic", "Cas64"}:                     struct{}{},
+       {"mips64", "internal/runtime/atomic", "CasRel"}:                    struct{}{},
+       {"mips64", "internal/runtime/atomic", "Casint32"}:                  struct{}{},
+       {"mips64", "internal/runtime/atomic", "Casint64"}:                  struct{}{},
+       {"mips64", "internal/runtime/atomic", "Casp1"}:                     struct{}{},
+       {"mips64", "internal/runtime/atomic", "Casuintptr"}:                struct{}{},
+       {"mips64", "internal/runtime/atomic", "Load"}:                      struct{}{},
+       {"mips64", "internal/runtime/atomic", "Load64"}:                    struct{}{},
+       {"mips64", "internal/runtime/atomic", "Load8"}:                     struct{}{},
+       {"mips64", "internal/runtime/atomic", "LoadAcq"}:                   struct{}{},
+       {"mips64", "internal/runtime/atomic", "LoadAcq64"}:                 struct{}{},
+       {"mips64", "internal/runtime/atomic", "LoadAcquintptr"}:            struct{}{},
+       {"mips64", "internal/runtime/atomic", "Loadint32"}:                 struct{}{},
+       {"mips64", "internal/runtime/atomic", "Loadint64"}:                 struct{}{},
+       {"mips64", "internal/runtime/atomic", "Loadp"}:                     struct{}{},
+       {"mips64", "internal/runtime/atomic", "Loaduint"}:                  struct{}{},
+       {"mips64", "internal/runtime/atomic", "Loaduintptr"}:               struct{}{},
+       {"mips64", "internal/runtime/atomic", "Or"}:                        struct{}{},
+       {"mips64", "internal/runtime/atomic", "Or8"}:                       struct{}{},
+       {"mips64", "internal/runtime/atomic", "Store"}:                     struct{}{},
+       {"mips64", "internal/runtime/atomic", "Store64"}:                   struct{}{},
+       {"mips64", "internal/runtime/atomic", "Store8"}:                    struct{}{},
+       {"mips64", "internal/runtime/atomic", "StoreRel"}:                  struct{}{},
+       {"mips64", "internal/runtime/atomic", "StoreRel64"}:                struct{}{},
+       {"mips64", "internal/runtime/atomic", "StoreReluintptr"}:           struct{}{},
+       {"mips64", "internal/runtime/atomic", "Storeint32"}:                struct{}{},
+       {"mips64", "internal/runtime/atomic", "Storeint64"}:                struct{}{},
+       {"mips64", "internal/runtime/atomic", "StorepNoWB"}:                struct{}{},
+       {"mips64", "internal/runtime/atomic", "Storeuintptr"}:              struct{}{},
+       {"mips64", "internal/runtime/atomic", "Xadd"}:                      struct{}{},
+       {"mips64", "internal/runtime/atomic", "Xadd64"}:                    struct{}{},
+       {"mips64", "internal/runtime/atomic", "Xaddint32"}:                 struct{}{},
+       {"mips64", "internal/runtime/atomic", "Xaddint64"}:                 struct{}{},
+       {"mips64", "internal/runtime/atomic", "Xadduintptr"}:               struct{}{},
+       {"mips64", "internal/runtime/atomic", "Xchg"}:                      struct{}{},
+       {"mips64", "internal/runtime/atomic", "Xchg64"}:                    struct{}{},
+       {"mips64", "internal/runtime/atomic", "Xchgint32"}:                 struct{}{},
+       {"mips64", "internal/runtime/atomic", "Xchgint64"}:                 struct{}{},
+       {"mips64", "internal/runtime/atomic", "Xchguintptr"}:               struct{}{},
+       {"mips64", "internal/runtime/math", "Add64"}:                       struct{}{},
+       {"mips64", "internal/runtime/math", "Mul64"}:                       struct{}{},
+       {"mips64", "internal/runtime/math", "MulUintptr"}:                  struct{}{},
+       {"mips64", "internal/runtime/sys", "GetCallerPC"}:                  struct{}{},
+       {"mips64", "internal/runtime/sys", "GetCallerSP"}:                  struct{}{},
+       {"mips64", "internal/runtime/sys", "GetClosurePtr"}:                struct{}{},
+       {"mips64", "math", "Abs"}:                                          struct{}{},
+       {"mips64", "math", "sqrt"}:                                         struct{}{},
+       {"mips64", "math/big", "mulWW"}:                                    struct{}{},
+       {"mips64", "math/bits", "Add"}:                                     struct{}{},
+       {"mips64", "math/bits", "Add64"}:                                   struct{}{},
+       {"mips64", "math/bits", "Mul"}:                                     struct{}{},
+       {"mips64", "math/bits", "Mul64"}:                                   struct{}{},
+       {"mips64", "math/bits", "Sub"}:                                     struct{}{},
+       {"mips64", "math/bits", "Sub64"}:                                   struct{}{},
+       {"mips64", "runtime", "KeepAlive"}:                                 struct{}{},
+       {"mips64", "runtime", "slicebytetostringtmp"}:                      struct{}{},
+       {"mips64", "sync", "runtime_LoadAcquintptr"}:                       struct{}{},
+       {"mips64", "sync", "runtime_StoreReluintptr"}:                      struct{}{},
+       {"mips64", "sync/atomic", "AddInt32"}:                              struct{}{},
+       {"mips64", "sync/atomic", "AddInt64"}:                              struct{}{},
+       {"mips64", "sync/atomic", "AddUint32"}:                             struct{}{},
+       {"mips64", "sync/atomic", "AddUint64"}:                             struct{}{},
+       {"mips64", "sync/atomic", "AddUintptr"}:                            struct{}{},
+       {"mips64", "sync/atomic", "CompareAndSwapInt32"}:                   struct{}{},
+       {"mips64", "sync/atomic", "CompareAndSwapInt64"}:                   struct{}{},
+       {"mips64", "sync/atomic", "CompareAndSwapUint32"}:                  struct{}{},
+       {"mips64", "sync/atomic", "CompareAndSwapUint64"}:                  struct{}{},
+       {"mips64", "sync/atomic", "CompareAndSwapUintptr"}:                 struct{}{},
+       {"mips64", "sync/atomic", "LoadInt32"}:                             struct{}{},
+       {"mips64", "sync/atomic", "LoadInt64"}:                             struct{}{},
+       {"mips64", "sync/atomic", "LoadPointer"}:                           struct{}{},
+       {"mips64", "sync/atomic", "LoadUint32"}:                            struct{}{},
+       {"mips64", "sync/atomic", "LoadUint64"}:                            struct{}{},
+       {"mips64", "sync/atomic", "LoadUintptr"}:                           struct{}{},
+       {"mips64", "sync/atomic", "StoreInt32"}:                            struct{}{},
+       {"mips64", "sync/atomic", "StoreInt64"}:                            struct{}{},
+       {"mips64", "sync/atomic", "StoreUint32"}:                           struct{}{},
+       {"mips64", "sync/atomic", "StoreUint64"}:                           struct{}{},
+       {"mips64", "sync/atomic", "StoreUintptr"}:                          struct{}{},
+       {"mips64", "sync/atomic", "SwapInt32"}:                             struct{}{},
+       {"mips64", "sync/atomic", "SwapInt64"}:                             struct{}{},
+       {"mips64", "sync/atomic", "SwapUint32"}:                            struct{}{},
+       {"mips64", "sync/atomic", "SwapUint64"}:                            struct{}{},
+       {"mips64", "sync/atomic", "SwapUintptr"}:                           struct{}{},
+       {"mips64le", "internal/runtime/atomic", "And"}:                     struct{}{},
+       {"mips64le", "internal/runtime/atomic", "And8"}:                    struct{}{},
+       {"mips64le", "internal/runtime/atomic", "Cas"}:                     struct{}{},
+       {"mips64le", "internal/runtime/atomic", "Cas64"}:                   struct{}{},
+       {"mips64le", "internal/runtime/atomic", "CasRel"}:                  struct{}{},
+       {"mips64le", "internal/runtime/atomic", "Casint32"}:                struct{}{},
+       {"mips64le", "internal/runtime/atomic", "Casint64"}:                struct{}{},
+       {"mips64le", "internal/runtime/atomic", "Casp1"}:                   struct{}{},
+       {"mips64le", "internal/runtime/atomic", "Casuintptr"}:              struct{}{},
+       {"mips64le", "internal/runtime/atomic", "Load"}:                    struct{}{},
+       {"mips64le", "internal/runtime/atomic", "Load64"}:                  struct{}{},
+       {"mips64le", "internal/runtime/atomic", "Load8"}:                   struct{}{},
+       {"mips64le", "internal/runtime/atomic", "LoadAcq"}:                 struct{}{},
+       {"mips64le", "internal/runtime/atomic", "LoadAcq64"}:               struct{}{},
+       {"mips64le", "internal/runtime/atomic", "LoadAcquintptr"}:          struct{}{},
+       {"mips64le", "internal/runtime/atomic", "Loadint32"}:               struct{}{},
+       {"mips64le", "internal/runtime/atomic", "Loadint64"}:               struct{}{},
+       {"mips64le", "internal/runtime/atomic", "Loadp"}:                   struct{}{},
+       {"mips64le", "internal/runtime/atomic", "Loaduint"}:                struct{}{},
+       {"mips64le", "internal/runtime/atomic", "Loaduintptr"}:             struct{}{},
+       {"mips64le", "internal/runtime/atomic", "Or"}:                      struct{}{},
+       {"mips64le", "internal/runtime/atomic", "Or8"}:                     struct{}{},
+       {"mips64le", "internal/runtime/atomic", "Store"}:                   struct{}{},
+       {"mips64le", "internal/runtime/atomic", "Store64"}:                 struct{}{},
+       {"mips64le", "internal/runtime/atomic", "Store8"}:                  struct{}{},
+       {"mips64le", "internal/runtime/atomic", "StoreRel"}:                struct{}{},
+       {"mips64le", "internal/runtime/atomic", "StoreRel64"}:              struct{}{},
+       {"mips64le", "internal/runtime/atomic", "StoreReluintptr"}:         struct{}{},
+       {"mips64le", "internal/runtime/atomic", "Storeint32"}:              struct{}{},
+       {"mips64le", "internal/runtime/atomic", "Storeint64"}:              struct{}{},
+       {"mips64le", "internal/runtime/atomic", "StorepNoWB"}:              struct{}{},
+       {"mips64le", "internal/runtime/atomic", "Storeuintptr"}:            struct{}{},
+       {"mips64le", "internal/runtime/atomic", "Xadd"}:                    struct{}{},
+       {"mips64le", "internal/runtime/atomic", "Xadd64"}:                  struct{}{},
+       {"mips64le", "internal/runtime/atomic", "Xaddint32"}:               struct{}{},
+       {"mips64le", "internal/runtime/atomic", "Xaddint64"}:               struct{}{},
+       {"mips64le", "internal/runtime/atomic", "Xadduintptr"}:             struct{}{},
+       {"mips64le", "internal/runtime/atomic", "Xchg"}:                    struct{}{},
+       {"mips64le", "internal/runtime/atomic", "Xchg64"}:                  struct{}{},
+       {"mips64le", "internal/runtime/atomic", "Xchgint32"}:               struct{}{},
+       {"mips64le", "internal/runtime/atomic", "Xchgint64"}:               struct{}{},
+       {"mips64le", "internal/runtime/atomic", "Xchguintptr"}:             struct{}{},
+       {"mips64le", "internal/runtime/math", "Add64"}:                     struct{}{},
+       {"mips64le", "internal/runtime/math", "Mul64"}:                     struct{}{},
+       {"mips64le", "internal/runtime/math", "MulUintptr"}:                struct{}{},
+       {"mips64le", "internal/runtime/sys", "GetCallerPC"}:                struct{}{},
+       {"mips64le", "internal/runtime/sys", "GetCallerSP"}:                struct{}{},
+       {"mips64le", "internal/runtime/sys", "GetClosurePtr"}:              struct{}{},
+       {"mips64le", "math", "Abs"}:                                        struct{}{},
+       {"mips64le", "math", "sqrt"}:                                       struct{}{},
+       {"mips64le", "math/big", "mulWW"}:                                  struct{}{},
+       {"mips64le", "math/bits", "Add"}:                                   struct{}{},
+       {"mips64le", "math/bits", "Add64"}:                                 struct{}{},
+       {"mips64le", "math/bits", "Mul"}:                                   struct{}{},
+       {"mips64le", "math/bits", "Mul64"}:                                 struct{}{},
+       {"mips64le", "math/bits", "Sub"}:                                   struct{}{},
+       {"mips64le", "math/bits", "Sub64"}:                                 struct{}{},
+       {"mips64le", "runtime", "KeepAlive"}:                               struct{}{},
+       {"mips64le", "runtime", "slicebytetostringtmp"}:                    struct{}{},
+       {"mips64le", "sync", "runtime_LoadAcquintptr"}:                     struct{}{},
+       {"mips64le", "sync", "runtime_StoreReluintptr"}:                    struct{}{},
+       {"mips64le", "sync/atomic", "AddInt32"}:                            struct{}{},
+       {"mips64le", "sync/atomic", "AddInt64"}:                            struct{}{},
+       {"mips64le", "sync/atomic", "AddUint32"}:                           struct{}{},
+       {"mips64le", "sync/atomic", "AddUint64"}:                           struct{}{},
+       {"mips64le", "sync/atomic", "AddUintptr"}:                          struct{}{},
+       {"mips64le", "sync/atomic", "CompareAndSwapInt32"}:                 struct{}{},
+       {"mips64le", "sync/atomic", "CompareAndSwapInt64"}:                 struct{}{},
+       {"mips64le", "sync/atomic", "CompareAndSwapUint32"}:                struct{}{},
+       {"mips64le", "sync/atomic", "CompareAndSwapUint64"}:                struct{}{},
+       {"mips64le", "sync/atomic", "CompareAndSwapUintptr"}:               struct{}{},
+       {"mips64le", "sync/atomic", "LoadInt32"}:                           struct{}{},
+       {"mips64le", "sync/atomic", "LoadInt64"}:                           struct{}{},
+       {"mips64le", "sync/atomic", "LoadPointer"}:                         struct{}{},
+       {"mips64le", "sync/atomic", "LoadUint32"}:                          struct{}{},
+       {"mips64le", "sync/atomic", "LoadUint64"}:                          struct{}{},
+       {"mips64le", "sync/atomic", "LoadUintptr"}:                         struct{}{},
+       {"mips64le", "sync/atomic", "StoreInt32"}:                          struct{}{},
+       {"mips64le", "sync/atomic", "StoreInt64"}:                          struct{}{},
+       {"mips64le", "sync/atomic", "StoreUint32"}:                         struct{}{},
+       {"mips64le", "sync/atomic", "StoreUint64"}:                         struct{}{},
+       {"mips64le", "sync/atomic", "StoreUintptr"}:                        struct{}{},
+       {"mips64le", "sync/atomic", "SwapInt32"}:                           struct{}{},
+       {"mips64le", "sync/atomic", "SwapInt64"}:                           struct{}{},
+       {"mips64le", "sync/atomic", "SwapUint32"}:                          struct{}{},
+       {"mips64le", "sync/atomic", "SwapUint64"}:                          struct{}{},
+       {"mips64le", "sync/atomic", "SwapUintptr"}:                         struct{}{},
+       {"mipsle", "internal/runtime/atomic", "And"}:                       struct{}{},
+       {"mipsle", "internal/runtime/atomic", "And8"}:                      struct{}{},
+       {"mipsle", "internal/runtime/atomic", "Cas"}:                       struct{}{},
+       {"mipsle", "internal/runtime/atomic", "CasRel"}:                    struct{}{},
+       {"mipsle", "internal/runtime/atomic", "Casint32"}:                  struct{}{},
+       {"mipsle", "internal/runtime/atomic", "Casp1"}:                     struct{}{},
+       {"mipsle", "internal/runtime/atomic", "Casuintptr"}:                struct{}{},
+       {"mipsle", "internal/runtime/atomic", "Load"}:                      struct{}{},
+       {"mipsle", "internal/runtime/atomic", "Load8"}:                     struct{}{},
+       {"mipsle", "internal/runtime/atomic", "LoadAcq"}:                   struct{}{},
+       {"mipsle", "internal/runtime/atomic", "LoadAcquintptr"}:            struct{}{},
+       {"mipsle", "internal/runtime/atomic", "Loadint32"}:                 struct{}{},
+       {"mipsle", "internal/runtime/atomic", "Loadp"}:                     struct{}{},
+       {"mipsle", "internal/runtime/atomic", "Loaduint"}:                  struct{}{},
+       {"mipsle", "internal/runtime/atomic", "Loaduintptr"}:               struct{}{},
+       {"mipsle", "internal/runtime/atomic", "Or"}:                        struct{}{},
+       {"mipsle", "internal/runtime/atomic", "Or8"}:                       struct{}{},
+       {"mipsle", "internal/runtime/atomic", "Store"}:                     struct{}{},
+       {"mipsle", "internal/runtime/atomic", "Store8"}:                    struct{}{},
+       {"mipsle", "internal/runtime/atomic", "StoreRel"}:                  struct{}{},
+       {"mipsle", "internal/runtime/atomic", "StoreReluintptr"}:           struct{}{},
+       {"mipsle", "internal/runtime/atomic", "Storeint32"}:                struct{}{},
+       {"mipsle", "internal/runtime/atomic", "StorepNoWB"}:                struct{}{},
+       {"mipsle", "internal/runtime/atomic", "Storeuintptr"}:              struct{}{},
+       {"mipsle", "internal/runtime/atomic", "Xadd"}:                      struct{}{},
+       {"mipsle", "internal/runtime/atomic", "Xaddint32"}:                 struct{}{},
+       {"mipsle", "internal/runtime/atomic", "Xadduintptr"}:               struct{}{},
+       {"mipsle", "internal/runtime/atomic", "Xchg"}:                      struct{}{},
+       {"mipsle", "internal/runtime/atomic", "Xchgint32"}:                 struct{}{},
+       {"mipsle", "internal/runtime/atomic", "Xchguintptr"}:               struct{}{},
+       {"mipsle", "internal/runtime/sys", "GetCallerPC"}:                  struct{}{},
+       {"mipsle", "internal/runtime/sys", "GetCallerSP"}:                  struct{}{},
+       {"mipsle", "internal/runtime/sys", "GetClosurePtr"}:                struct{}{},
+       {"mipsle", "internal/runtime/sys", "Len64"}:                        struct{}{},
+       {"mipsle", "internal/runtime/sys", "Len8"}:                         struct{}{},
+       {"mipsle", "internal/runtime/sys", "TrailingZeros32"}:              struct{}{},
+       {"mipsle", "internal/runtime/sys", "TrailingZeros64"}:              struct{}{},
+       {"mipsle", "internal/runtime/sys", "TrailingZeros8"}:               struct{}{},
+       {"mipsle", "math", "Abs"}:                                          struct{}{},
+       {"mipsle", "math", "sqrt"}:                                         struct{}{},
+       {"mipsle", "math/bits", "Len"}:                                     struct{}{},
+       {"mipsle", "math/bits", "Len16"}:                                   struct{}{},
+       {"mipsle", "math/bits", "Len32"}:                                   struct{}{},
+       {"mipsle", "math/bits", "Len64"}:                                   struct{}{},
+       {"mipsle", "math/bits", "Len8"}:                                    struct{}{},
+       {"mipsle", "math/bits", "TrailingZeros16"}:                         struct{}{},
+       {"mipsle", "math/bits", "TrailingZeros32"}:                         struct{}{},
+       {"mipsle", "math/bits", "TrailingZeros64"}:                         struct{}{},
+       {"mipsle", "math/bits", "TrailingZeros8"}:                          struct{}{},
+       {"mipsle", "runtime", "KeepAlive"}:                                 struct{}{},
+       {"mipsle", "runtime", "slicebytetostringtmp"}:                      struct{}{},
+       {"mipsle", "sync", "runtime_LoadAcquintptr"}:                       struct{}{},
+       {"mipsle", "sync", "runtime_StoreReluintptr"}:                      struct{}{},
+       {"mipsle", "sync/atomic", "AddInt32"}:                              struct{}{},
+       {"mipsle", "sync/atomic", "AddUint32"}:                             struct{}{},
+       {"mipsle", "sync/atomic", "AddUintptr"}:                            struct{}{},
+       {"mipsle", "sync/atomic", "CompareAndSwapInt32"}:                   struct{}{},
+       {"mipsle", "sync/atomic", "CompareAndSwapUint32"}:                  struct{}{},
+       {"mipsle", "sync/atomic", "CompareAndSwapUintptr"}:                 struct{}{},
+       {"mipsle", "sync/atomic", "LoadInt32"}:                             struct{}{},
+       {"mipsle", "sync/atomic", "LoadPointer"}:                           struct{}{},
+       {"mipsle", "sync/atomic", "LoadUint32"}:                            struct{}{},
+       {"mipsle", "sync/atomic", "LoadUintptr"}:                           struct{}{},
+       {"mipsle", "sync/atomic", "StoreInt32"}:                            struct{}{},
+       {"mipsle", "sync/atomic", "StoreUint32"}:                           struct{}{},
+       {"mipsle", "sync/atomic", "StoreUintptr"}:                          struct{}{},
+       {"mipsle", "sync/atomic", "SwapInt32"}:                             struct{}{},
+       {"mipsle", "sync/atomic", "SwapUint32"}:                            struct{}{},
+       {"mipsle", "sync/atomic", "SwapUintptr"}:                           struct{}{},
+       {"ppc64", "internal/runtime/atomic", "And"}:                        struct{}{},
+       {"ppc64", "internal/runtime/atomic", "And8"}:                       struct{}{},
+       {"ppc64", "internal/runtime/atomic", "Cas"}:                        struct{}{},
+       {"ppc64", "internal/runtime/atomic", "Cas64"}:                      struct{}{},
+       {"ppc64", "internal/runtime/atomic", "CasRel"}:                     struct{}{},
+       {"ppc64", "internal/runtime/atomic", "Casint32"}:                   struct{}{},
+       {"ppc64", "internal/runtime/atomic", "Casint64"}:                   struct{}{},
+       {"ppc64", "internal/runtime/atomic", "Casp1"}:                      struct{}{},
+       {"ppc64", "internal/runtime/atomic", "Casuintptr"}:                 struct{}{},
+       {"ppc64", "internal/runtime/atomic", "Load"}:                       struct{}{},
+       {"ppc64", "internal/runtime/atomic", "Load64"}:                     struct{}{},
+       {"ppc64", "internal/runtime/atomic", "Load8"}:                      struct{}{},
+       {"ppc64", "internal/runtime/atomic", "LoadAcq"}:                    struct{}{},
+       {"ppc64", "internal/runtime/atomic", "LoadAcq64"}:                  struct{}{},
+       {"ppc64", "internal/runtime/atomic", "LoadAcquintptr"}:             struct{}{},
+       {"ppc64", "internal/runtime/atomic", "Loadint32"}:                  struct{}{},
+       {"ppc64", "internal/runtime/atomic", "Loadint64"}:                  struct{}{},
+       {"ppc64", "internal/runtime/atomic", "Loadp"}:                      struct{}{},
+       {"ppc64", "internal/runtime/atomic", "Loaduint"}:                   struct{}{},
+       {"ppc64", "internal/runtime/atomic", "Loaduintptr"}:                struct{}{},
+       {"ppc64", "internal/runtime/atomic", "Or"}:                         struct{}{},
+       {"ppc64", "internal/runtime/atomic", "Or8"}:                        struct{}{},
+       {"ppc64", "internal/runtime/atomic", "Store"}:                      struct{}{},
+       {"ppc64", "internal/runtime/atomic", "Store64"}:                    struct{}{},
+       {"ppc64", "internal/runtime/atomic", "Store8"}:                     struct{}{},
+       {"ppc64", "internal/runtime/atomic", "StoreRel"}:                   struct{}{},
+       {"ppc64", "internal/runtime/atomic", "StoreRel64"}:                 struct{}{},
+       {"ppc64", "internal/runtime/atomic", "StoreReluintptr"}:            struct{}{},
+       {"ppc64", "internal/runtime/atomic", "Storeint32"}:                 struct{}{},
+       {"ppc64", "internal/runtime/atomic", "Storeint64"}:                 struct{}{},
+       {"ppc64", "internal/runtime/atomic", "Storeuintptr"}:               struct{}{},
+       {"ppc64", "internal/runtime/atomic", "Xadd"}:                       struct{}{},
+       {"ppc64", "internal/runtime/atomic", "Xadd64"}:                     struct{}{},
+       {"ppc64", "internal/runtime/atomic", "Xaddint32"}:                  struct{}{},
+       {"ppc64", "internal/runtime/atomic", "Xaddint64"}:                  struct{}{},
+       {"ppc64", "internal/runtime/atomic", "Xadduintptr"}:                struct{}{},
+       {"ppc64", "internal/runtime/atomic", "Xchg8"}:                      struct{}{},
+       {"ppc64", "internal/runtime/atomic", "Xchg"}:                       struct{}{},
+       {"ppc64", "internal/runtime/atomic", "Xchg64"}:                     struct{}{},
+       {"ppc64", "internal/runtime/atomic", "Xchgint32"}:                  struct{}{},
+       {"ppc64", "internal/runtime/atomic", "Xchgint64"}:                  struct{}{},
+       {"ppc64", "internal/runtime/atomic", "Xchguintptr"}:                struct{}{},
+       {"ppc64", "internal/runtime/math", "Add64"}:                        struct{}{},
+       {"ppc64", "internal/runtime/math", "Mul64"}:                        struct{}{},
+       {"ppc64", "internal/runtime/math", "MulUintptr"}:                   struct{}{},
+       {"ppc64", "internal/runtime/sys", "Bswap32"}:                       struct{}{},
+       {"ppc64", "internal/runtime/sys", "Bswap64"}:                       struct{}{},
+       {"ppc64", "internal/runtime/sys", "GetCallerPC"}:                   struct{}{},
+       {"ppc64", "internal/runtime/sys", "GetCallerSP"}:                   struct{}{},
+       {"ppc64", "internal/runtime/sys", "GetClosurePtr"}:                 struct{}{},
+       {"ppc64", "internal/runtime/sys", "Len64"}:                         struct{}{},
+       {"ppc64", "internal/runtime/sys", "Len8"}:                          struct{}{},
+       {"ppc64", "internal/runtime/sys", "OnesCount64"}:                   struct{}{},
+       {"ppc64", "internal/runtime/sys", "Prefetch"}:                      struct{}{},
+       {"ppc64", "internal/runtime/sys", "PrefetchStreamed"}:              struct{}{},
+       {"ppc64", "internal/runtime/sys", "TrailingZeros32"}:               struct{}{},
+       {"ppc64", "internal/runtime/sys", "TrailingZeros64"}:               struct{}{},
+       {"ppc64", "math", "Abs"}:                                           struct{}{},
+       {"ppc64", "math", "Ceil"}:                                          struct{}{},
+       {"ppc64", "math", "Copysign"}:                                      struct{}{},
+       {"ppc64", "math", "FMA"}:                                           struct{}{},
+       {"ppc64", "math", "Floor"}:                                         struct{}{},
+       {"ppc64", "math", "Round"}:                                         struct{}{},
+       {"ppc64", "math", "Trunc"}:                                         struct{}{},
+       {"ppc64", "math", "sqrt"}:                                          struct{}{},
+       {"ppc64", "math/big", "mulWW"}:                                     struct{}{},
+       {"ppc64", "math/bits", "Add"}:                                      struct{}{},
+       {"ppc64", "math/bits", "Add64"}:                                    struct{}{},
+       {"ppc64", "math/bits", "Len"}:                                      struct{}{},
+       {"ppc64", "math/bits", "Len16"}:                                    struct{}{},
+       {"ppc64", "math/bits", "Len32"}:                                    struct{}{},
+       {"ppc64", "math/bits", "Len64"}:                                    struct{}{},
+       {"ppc64", "math/bits", "Len8"}:                                     struct{}{},
+       {"ppc64", "math/bits", "Mul"}:                                      struct{}{},
+       {"ppc64", "math/bits", "Mul64"}:                                    struct{}{},
+       {"ppc64", "math/bits", "OnesCount16"}:                              struct{}{},
+       {"ppc64", "math/bits", "OnesCount32"}:                              struct{}{},
+       {"ppc64", "math/bits", "OnesCount64"}:                              struct{}{},
+       {"ppc64", "math/bits", "OnesCount8"}:                               struct{}{},
+       {"ppc64", "math/bits", "ReverseBytes16"}:                           struct{}{},
+       {"ppc64", "math/bits", "ReverseBytes32"}:                           struct{}{},
+       {"ppc64", "math/bits", "ReverseBytes64"}:                           struct{}{},
+       {"ppc64", "math/bits", "RotateLeft"}:                               struct{}{},
+       {"ppc64", "math/bits", "RotateLeft32"}:                             struct{}{},
+       {"ppc64", "math/bits", "RotateLeft64"}:                             struct{}{},
+       {"ppc64", "math/bits", "Sub"}:                                      struct{}{},
+       {"ppc64", "math/bits", "Sub64"}:                                    struct{}{},
+       {"ppc64", "math/bits", "TrailingZeros16"}:                          struct{}{},
+       {"ppc64", "math/bits", "TrailingZeros32"}:                          struct{}{},
+       {"ppc64", "math/bits", "TrailingZeros64"}:                          struct{}{},
+       {"ppc64", "runtime", "KeepAlive"}:                                  struct{}{},
+       {"ppc64", "runtime", "publicationBarrier"}:                         struct{}{},
+       {"ppc64", "runtime", "slicebytetostringtmp"}:                       struct{}{},
+       {"ppc64", "sync", "runtime_LoadAcquintptr"}:                        struct{}{},
+       {"ppc64", "sync", "runtime_StoreReluintptr"}:                       struct{}{},
+       {"ppc64", "sync/atomic", "AddInt32"}:                               struct{}{},
+       {"ppc64", "sync/atomic", "AddInt64"}:                               struct{}{},
+       {"ppc64", "sync/atomic", "AddUint32"}:                              struct{}{},
+       {"ppc64", "sync/atomic", "AddUint64"}:                              struct{}{},
+       {"ppc64", "sync/atomic", "AddUintptr"}:                             struct{}{},
+       {"ppc64", "sync/atomic", "CompareAndSwapInt32"}:                    struct{}{},
+       {"ppc64", "sync/atomic", "CompareAndSwapInt64"}:                    struct{}{},
+       {"ppc64", "sync/atomic", "CompareAndSwapUint32"}:                   struct{}{},
+       {"ppc64", "sync/atomic", "CompareAndSwapUint64"}:                   struct{}{},
+       {"ppc64", "sync/atomic", "CompareAndSwapUintptr"}:                  struct{}{},
+       {"ppc64", "sync/atomic", "LoadInt32"}:                              struct{}{},
+       {"ppc64", "sync/atomic", "LoadInt64"}:                              struct{}{},
+       {"ppc64", "sync/atomic", "LoadPointer"}:                            struct{}{},
+       {"ppc64", "sync/atomic", "LoadUint32"}:                             struct{}{},
+       {"ppc64", "sync/atomic", "LoadUint64"}:                             struct{}{},
+       {"ppc64", "sync/atomic", "LoadUintptr"}:                            struct{}{},
+       {"ppc64", "sync/atomic", "StoreInt32"}:                             struct{}{},
+       {"ppc64", "sync/atomic", "StoreInt64"}:                             struct{}{},
+       {"ppc64", "sync/atomic", "StoreUint32"}:                            struct{}{},
+       {"ppc64", "sync/atomic", "StoreUint64"}:                            struct{}{},
+       {"ppc64", "sync/atomic", "StoreUintptr"}:                           struct{}{},
+       {"ppc64", "sync/atomic", "SwapInt32"}:                              struct{}{},
+       {"ppc64", "sync/atomic", "SwapInt64"}:                              struct{}{},
+       {"ppc64", "sync/atomic", "SwapUint32"}:                             struct{}{},
+       {"ppc64", "sync/atomic", "SwapUint64"}:                             struct{}{},
+       {"ppc64", "sync/atomic", "SwapUintptr"}:                            struct{}{},
+       {"ppc64le", "internal/runtime/atomic", "And"}:                      struct{}{},
+       {"ppc64le", "internal/runtime/atomic", "And8"}:                     struct{}{},
+       {"ppc64le", "internal/runtime/atomic", "Cas"}:                      struct{}{},
+       {"ppc64le", "internal/runtime/atomic", "Cas64"}:                    struct{}{},
+       {"ppc64le", "internal/runtime/atomic", "CasRel"}:                   struct{}{},
+       {"ppc64le", "internal/runtime/atomic", "Casint32"}:                 struct{}{},
+       {"ppc64le", "internal/runtime/atomic", "Casint64"}:                 struct{}{},
+       {"ppc64le", "internal/runtime/atomic", "Casp1"}:                    struct{}{},
+       {"ppc64le", "internal/runtime/atomic", "Casuintptr"}:               struct{}{},
+       {"ppc64le", "internal/runtime/atomic", "Load"}:                     struct{}{},
+       {"ppc64le", "internal/runtime/atomic", "Load64"}:                   struct{}{},
+       {"ppc64le", "internal/runtime/atomic", "Load8"}:                    struct{}{},
+       {"ppc64le", "internal/runtime/atomic", "LoadAcq"}:                  struct{}{},
+       {"ppc64le", "internal/runtime/atomic", "LoadAcq64"}:                struct{}{},
+       {"ppc64le", "internal/runtime/atomic", "LoadAcquintptr"}:           struct{}{},
+       {"ppc64le", "internal/runtime/atomic", "Loadint32"}:                struct{}{},
+       {"ppc64le", "internal/runtime/atomic", "Loadint64"}:                struct{}{},
+       {"ppc64le", "internal/runtime/atomic", "Loadp"}:                    struct{}{},
+       {"ppc64le", "internal/runtime/atomic", "Loaduint"}:                 struct{}{},
+       {"ppc64le", "internal/runtime/atomic", "Loaduintptr"}:              struct{}{},
+       {"ppc64le", "internal/runtime/atomic", "Or"}:                       struct{}{},
+       {"ppc64le", "internal/runtime/atomic", "Or8"}:                      struct{}{},
+       {"ppc64le", "internal/runtime/atomic", "Store"}:                    struct{}{},
+       {"ppc64le", "internal/runtime/atomic", "Store64"}:                  struct{}{},
+       {"ppc64le", "internal/runtime/atomic", "Store8"}:                   struct{}{},
+       {"ppc64le", "internal/runtime/atomic", "StoreRel"}:                 struct{}{},
+       {"ppc64le", "internal/runtime/atomic", "StoreRel64"}:               struct{}{},
+       {"ppc64le", "internal/runtime/atomic", "StoreReluintptr"}:          struct{}{},
+       {"ppc64le", "internal/runtime/atomic", "Storeint32"}:               struct{}{},
+       {"ppc64le", "internal/runtime/atomic", "Storeint64"}:               struct{}{},
+       {"ppc64le", "internal/runtime/atomic", "Storeuintptr"}:             struct{}{},
+       {"ppc64le", "internal/runtime/atomic", "Xadd"}:                     struct{}{},
+       {"ppc64le", "internal/runtime/atomic", "Xadd64"}:                   struct{}{},
+       {"ppc64le", "internal/runtime/atomic", "Xaddint32"}:                struct{}{},
+       {"ppc64le", "internal/runtime/atomic", "Xaddint64"}:                struct{}{},
+       {"ppc64le", "internal/runtime/atomic", "Xadduintptr"}:              struct{}{},
+       {"ppc64le", "internal/runtime/atomic", "Xchg8"}:                    struct{}{},
+       {"ppc64le", "internal/runtime/atomic", "Xchg"}:                     struct{}{},
+       {"ppc64le", "internal/runtime/atomic", "Xchg64"}:                   struct{}{},
+       {"ppc64le", "internal/runtime/atomic", "Xchgint32"}:                struct{}{},
+       {"ppc64le", "internal/runtime/atomic", "Xchgint64"}:                struct{}{},
+       {"ppc64le", "internal/runtime/atomic", "Xchguintptr"}:              struct{}{},
+       {"ppc64le", "internal/runtime/math", "Add64"}:                      struct{}{},
+       {"ppc64le", "internal/runtime/math", "Mul64"}:                      struct{}{},
+       {"ppc64le", "internal/runtime/math", "MulUintptr"}:                 struct{}{},
+       {"ppc64le", "internal/runtime/sys", "Bswap32"}:                     struct{}{},
+       {"ppc64le", "internal/runtime/sys", "Bswap64"}:                     struct{}{},
+       {"ppc64le", "internal/runtime/sys", "GetCallerPC"}:                 struct{}{},
+       {"ppc64le", "internal/runtime/sys", "GetCallerSP"}:                 struct{}{},
+       {"ppc64le", "internal/runtime/sys", "GetClosurePtr"}:               struct{}{},
+       {"ppc64le", "internal/runtime/sys", "Len64"}:                       struct{}{},
+       {"ppc64le", "internal/runtime/sys", "Len8"}:                        struct{}{},
+       {"ppc64le", "internal/runtime/sys", "OnesCount64"}:                 struct{}{},
+       {"ppc64le", "internal/runtime/sys", "Prefetch"}:                    struct{}{},
+       {"ppc64le", "internal/runtime/sys", "PrefetchStreamed"}:            struct{}{},
+       {"ppc64le", "internal/runtime/sys", "TrailingZeros32"}:             struct{}{},
+       {"ppc64le", "internal/runtime/sys", "TrailingZeros64"}:             struct{}{},
+       {"ppc64le", "math", "Abs"}:                                         struct{}{},
+       {"ppc64le", "math", "Ceil"}:                                        struct{}{},
+       {"ppc64le", "math", "Copysign"}:                                    struct{}{},
+       {"ppc64le", "math", "FMA"}:                                         struct{}{},
+       {"ppc64le", "math", "Floor"}:                                       struct{}{},
+       {"ppc64le", "math", "Round"}:                                       struct{}{},
+       {"ppc64le", "math", "Trunc"}:                                       struct{}{},
+       {"ppc64le", "math", "sqrt"}:                                        struct{}{},
+       {"ppc64le", "math/big", "mulWW"}:                                   struct{}{},
+       {"ppc64le", "math/bits", "Add"}:                                    struct{}{},
+       {"ppc64le", "math/bits", "Add64"}:                                  struct{}{},
+       {"ppc64le", "math/bits", "Len"}:                                    struct{}{},
+       {"ppc64le", "math/bits", "Len16"}:                                  struct{}{},
+       {"ppc64le", "math/bits", "Len32"}:                                  struct{}{},
+       {"ppc64le", "math/bits", "Len64"}:                                  struct{}{},
+       {"ppc64le", "math/bits", "Len8"}:                                   struct{}{},
+       {"ppc64le", "math/bits", "Mul"}:                                    struct{}{},
+       {"ppc64le", "math/bits", "Mul64"}:                                  struct{}{},
+       {"ppc64le", "math/bits", "OnesCount16"}:                            struct{}{},
+       {"ppc64le", "math/bits", "OnesCount32"}:                            struct{}{},
+       {"ppc64le", "math/bits", "OnesCount64"}:                            struct{}{},
+       {"ppc64le", "math/bits", "OnesCount8"}:                             struct{}{},
+       {"ppc64le", "math/bits", "ReverseBytes16"}:                         struct{}{},
+       {"ppc64le", "math/bits", "ReverseBytes32"}:                         struct{}{},
+       {"ppc64le", "math/bits", "ReverseBytes64"}:                         struct{}{},
+       {"ppc64le", "math/bits", "RotateLeft"}:                             struct{}{},
+       {"ppc64le", "math/bits", "RotateLeft32"}:                           struct{}{},
+       {"ppc64le", "math/bits", "RotateLeft64"}:                           struct{}{},
+       {"ppc64le", "math/bits", "Sub"}:                                    struct{}{},
+       {"ppc64le", "math/bits", "Sub64"}:                                  struct{}{},
+       {"ppc64le", "math/bits", "TrailingZeros16"}:                        struct{}{},
+       {"ppc64le", "math/bits", "TrailingZeros32"}:                        struct{}{},
+       {"ppc64le", "math/bits", "TrailingZeros64"}:                        struct{}{},
+       {"ppc64le", "runtime", "KeepAlive"}:                                struct{}{},
+       {"ppc64le", "runtime", "publicationBarrier"}:                       struct{}{},
+       {"ppc64le", "runtime", "slicebytetostringtmp"}:                     struct{}{},
+       {"ppc64le", "sync", "runtime_LoadAcquintptr"}:                      struct{}{},
+       {"ppc64le", "sync", "runtime_StoreReluintptr"}:                     struct{}{},
+       {"ppc64le", "sync/atomic", "AddInt32"}:                             struct{}{},
+       {"ppc64le", "sync/atomic", "AddInt64"}:                             struct{}{},
+       {"ppc64le", "sync/atomic", "AddUint32"}:                            struct{}{},
+       {"ppc64le", "sync/atomic", "AddUint64"}:                            struct{}{},
+       {"ppc64le", "sync/atomic", "AddUintptr"}:                           struct{}{},
+       {"ppc64le", "sync/atomic", "CompareAndSwapInt32"}:                  struct{}{},
+       {"ppc64le", "sync/atomic", "CompareAndSwapInt64"}:                  struct{}{},
+       {"ppc64le", "sync/atomic", "CompareAndSwapUint32"}:                 struct{}{},
+       {"ppc64le", "sync/atomic", "CompareAndSwapUint64"}:                 struct{}{},
+       {"ppc64le", "sync/atomic", "CompareAndSwapUintptr"}:                struct{}{},
+       {"ppc64le", "sync/atomic", "LoadInt32"}:                            struct{}{},
+       {"ppc64le", "sync/atomic", "LoadInt64"}:                            struct{}{},
+       {"ppc64le", "sync/atomic", "LoadPointer"}:                          struct{}{},
+       {"ppc64le", "sync/atomic", "LoadUint32"}:                           struct{}{},
+       {"ppc64le", "sync/atomic", "LoadUint64"}:                           struct{}{},
+       {"ppc64le", "sync/atomic", "LoadUintptr"}:                          struct{}{},
+       {"ppc64le", "sync/atomic", "StoreInt32"}:                           struct{}{},
+       {"ppc64le", "sync/atomic", "StoreInt64"}:                           struct{}{},
+       {"ppc64le", "sync/atomic", "StoreUint32"}:                          struct{}{},
+       {"ppc64le", "sync/atomic", "StoreUint64"}:                          struct{}{},
+       {"ppc64le", "sync/atomic", "StoreUintptr"}:                         struct{}{},
+       {"ppc64le", "sync/atomic", "SwapInt32"}:                            struct{}{},
+       {"ppc64le", "sync/atomic", "SwapInt64"}:                            struct{}{},
+       {"ppc64le", "sync/atomic", "SwapUint32"}:                           struct{}{},
+       {"ppc64le", "sync/atomic", "SwapUint64"}:                           struct{}{},
+       {"ppc64le", "sync/atomic", "SwapUintptr"}:                          struct{}{},
+       {"riscv64", "internal/runtime/atomic", "And"}:                      struct{}{},
+       {"riscv64", "internal/runtime/atomic", "And8"}:                     struct{}{},
+       {"riscv64", "internal/runtime/atomic", "Cas"}:                      struct{}{},
+       {"riscv64", "internal/runtime/atomic", "Cas64"}:                    struct{}{},
+       {"riscv64", "internal/runtime/atomic", "CasRel"}:                   struct{}{},
+       {"riscv64", "internal/runtime/atomic", "Casint32"}:                 struct{}{},
+       {"riscv64", "internal/runtime/atomic", "Casint64"}:                 struct{}{},
+       {"riscv64", "internal/runtime/atomic", "Casp1"}:                    struct{}{},
+       {"riscv64", "internal/runtime/atomic", "Casuintptr"}:               struct{}{},
+       {"riscv64", "internal/runtime/atomic", "Load"}:                     struct{}{},
+       {"riscv64", "internal/runtime/atomic", "Load64"}:                   struct{}{},
+       {"riscv64", "internal/runtime/atomic", "Load8"}:                    struct{}{},
+       {"riscv64", "internal/runtime/atomic", "LoadAcq"}:                  struct{}{},
+       {"riscv64", "internal/runtime/atomic", "LoadAcq64"}:                struct{}{},
+       {"riscv64", "internal/runtime/atomic", "LoadAcquintptr"}:           struct{}{},
+       {"riscv64", "internal/runtime/atomic", "Loadint32"}:                struct{}{},
+       {"riscv64", "internal/runtime/atomic", "Loadint64"}:                struct{}{},
+       {"riscv64", "internal/runtime/atomic", "Loadp"}:                    struct{}{},
+       {"riscv64", "internal/runtime/atomic", "Loaduint"}:                 struct{}{},
+       {"riscv64", "internal/runtime/atomic", "Loaduintptr"}:              struct{}{},
+       {"riscv64", "internal/runtime/atomic", "Or"}:                       struct{}{},
+       {"riscv64", "internal/runtime/atomic", "Or8"}:                      struct{}{},
+       {"riscv64", "internal/runtime/atomic", "Store"}:                    struct{}{},
+       {"riscv64", "internal/runtime/atomic", "Store64"}:                  struct{}{},
+       {"riscv64", "internal/runtime/atomic", "Store8"}:                   struct{}{},
+       {"riscv64", "internal/runtime/atomic", "StoreRel"}:                 struct{}{},
+       {"riscv64", "internal/runtime/atomic", "StoreRel64"}:               struct{}{},
+       {"riscv64", "internal/runtime/atomic", "StoreReluintptr"}:          struct{}{},
+       {"riscv64", "internal/runtime/atomic", "Storeint32"}:               struct{}{},
+       {"riscv64", "internal/runtime/atomic", "Storeint64"}:               struct{}{},
+       {"riscv64", "internal/runtime/atomic", "StorepNoWB"}:               struct{}{},
+       {"riscv64", "internal/runtime/atomic", "Storeuintptr"}:             struct{}{},
+       {"riscv64", "internal/runtime/atomic", "Xadd"}:                     struct{}{},
+       {"riscv64", "internal/runtime/atomic", "Xadd64"}:                   struct{}{},
+       {"riscv64", "internal/runtime/atomic", "Xaddint32"}:                struct{}{},
+       {"riscv64", "internal/runtime/atomic", "Xaddint64"}:                struct{}{},
+       {"riscv64", "internal/runtime/atomic", "Xadduintptr"}:              struct{}{},
+       {"riscv64", "internal/runtime/atomic", "Xchg"}:                     struct{}{},
+       {"riscv64", "internal/runtime/atomic", "Xchg64"}:                   struct{}{},
+       {"riscv64", "internal/runtime/atomic", "Xchgint32"}:                struct{}{},
+       {"riscv64", "internal/runtime/atomic", "Xchgint64"}:                struct{}{},
+       {"riscv64", "internal/runtime/atomic", "Xchguintptr"}:              struct{}{},
+       {"riscv64", "internal/runtime/math", "Add64"}:                      struct{}{},
+       {"riscv64", "internal/runtime/math", "Mul64"}:                      struct{}{},
+       {"riscv64", "internal/runtime/math", "MulUintptr"}:                 struct{}{},
+       {"riscv64", "internal/runtime/sys", "GetCallerPC"}:                 struct{}{},
+       {"riscv64", "internal/runtime/sys", "GetCallerSP"}:                 struct{}{},
+       {"riscv64", "internal/runtime/sys", "GetClosurePtr"}:               struct{}{},
+       {"riscv64", "math", "Abs"}:                                         struct{}{},
+       {"riscv64", "math", "Copysign"}:                                    struct{}{},
+       {"riscv64", "math", "FMA"}:                                         struct{}{},
+       {"riscv64", "math", "sqrt"}:                                        struct{}{},
+       {"riscv64", "math/big", "mulWW"}:                                   struct{}{},
+       {"riscv64", "math/bits", "Add"}:                                    struct{}{},
+       {"riscv64", "math/bits", "Add64"}:                                  struct{}{},
+       {"riscv64", "math/bits", "Mul"}:                                    struct{}{},
+       {"riscv64", "math/bits", "Mul64"}:                                  struct{}{},
+       {"riscv64", "math/bits", "RotateLeft"}:                             struct{}{},
+       {"riscv64", "math/bits", "RotateLeft16"}:                           struct{}{},
+       {"riscv64", "math/bits", "RotateLeft32"}:                           struct{}{},
+       {"riscv64", "math/bits", "RotateLeft64"}:                           struct{}{},
+       {"riscv64", "math/bits", "RotateLeft8"}:                            struct{}{},
+       {"riscv64", "math/bits", "Sub"}:                                    struct{}{},
+       {"riscv64", "math/bits", "Sub64"}:                                  struct{}{},
+       {"riscv64", "runtime", "KeepAlive"}:                                struct{}{},
+       {"riscv64", "runtime", "publicationBarrier"}:                       struct{}{},
+       {"riscv64", "runtime", "slicebytetostringtmp"}:                     struct{}{},
+       {"riscv64", "sync", "runtime_LoadAcquintptr"}:                      struct{}{},
+       {"riscv64", "sync", "runtime_StoreReluintptr"}:                     struct{}{},
+       {"riscv64", "sync/atomic", "AddInt32"}:                             struct{}{},
+       {"riscv64", "sync/atomic", "AddInt64"}:                             struct{}{},
+       {"riscv64", "sync/atomic", "AddUint32"}:                            struct{}{},
+       {"riscv64", "sync/atomic", "AddUint64"}:                            struct{}{},
+       {"riscv64", "sync/atomic", "AddUintptr"}:                           struct{}{},
+       {"riscv64", "sync/atomic", "CompareAndSwapInt32"}:                  struct{}{},
+       {"riscv64", "sync/atomic", "CompareAndSwapInt64"}:                  struct{}{},
+       {"riscv64", "sync/atomic", "CompareAndSwapUint32"}:                 struct{}{},
+       {"riscv64", "sync/atomic", "CompareAndSwapUint64"}:                 struct{}{},
+       {"riscv64", "sync/atomic", "CompareAndSwapUintptr"}:                struct{}{},
+       {"riscv64", "sync/atomic", "LoadInt32"}:                            struct{}{},
+       {"riscv64", "sync/atomic", "LoadInt64"}:                            struct{}{},
+       {"riscv64", "sync/atomic", "LoadPointer"}:                          struct{}{},
+       {"riscv64", "sync/atomic", "LoadUint32"}:                           struct{}{},
+       {"riscv64", "sync/atomic", "LoadUint64"}:                           struct{}{},
+       {"riscv64", "sync/atomic", "LoadUintptr"}:                          struct{}{},
+       {"riscv64", "sync/atomic", "StoreInt32"}:                           struct{}{},
+       {"riscv64", "sync/atomic", "StoreInt64"}:                           struct{}{},
+       {"riscv64", "sync/atomic", "StoreUint32"}:                          struct{}{},
+       {"riscv64", "sync/atomic", "StoreUint64"}:                          struct{}{},
+       {"riscv64", "sync/atomic", "StoreUintptr"}:                         struct{}{},
+       {"riscv64", "sync/atomic", "SwapInt32"}:                            struct{}{},
+       {"riscv64", "sync/atomic", "SwapInt64"}:                            struct{}{},
+       {"riscv64", "sync/atomic", "SwapUint32"}:                           struct{}{},
+       {"riscv64", "sync/atomic", "SwapUint64"}:                           struct{}{},
+       {"riscv64", "sync/atomic", "SwapUintptr"}:                          struct{}{},
+       {"s390x", "internal/runtime/atomic", "And"}:                        struct{}{},
+       {"s390x", "internal/runtime/atomic", "And8"}:                       struct{}{},
+       {"s390x", "internal/runtime/atomic", "Cas"}:                        struct{}{},
+       {"s390x", "internal/runtime/atomic", "Cas64"}:                      struct{}{},
+       {"s390x", "internal/runtime/atomic", "CasRel"}:                     struct{}{},
+       {"s390x", "internal/runtime/atomic", "Casint32"}:                   struct{}{},
+       {"s390x", "internal/runtime/atomic", "Casint64"}:                   struct{}{},
+       {"s390x", "internal/runtime/atomic", "Casp1"}:                      struct{}{},
+       {"s390x", "internal/runtime/atomic", "Casuintptr"}:                 struct{}{},
+       {"s390x", "internal/runtime/atomic", "Load"}:                       struct{}{},
+       {"s390x", "internal/runtime/atomic", "Load64"}:                     struct{}{},
+       {"s390x", "internal/runtime/atomic", "Load8"}:                      struct{}{},
+       {"s390x", "internal/runtime/atomic", "LoadAcq"}:                    struct{}{},
+       {"s390x", "internal/runtime/atomic", "LoadAcq64"}:                  struct{}{},
+       {"s390x", "internal/runtime/atomic", "LoadAcquintptr"}:             struct{}{},
+       {"s390x", "internal/runtime/atomic", "Loadint32"}:                  struct{}{},
+       {"s390x", "internal/runtime/atomic", "Loadint64"}:                  struct{}{},
+       {"s390x", "internal/runtime/atomic", "Loadp"}:                      struct{}{},
+       {"s390x", "internal/runtime/atomic", "Loaduint"}:                   struct{}{},
+       {"s390x", "internal/runtime/atomic", "Loaduintptr"}:                struct{}{},
+       {"s390x", "internal/runtime/atomic", "Or"}:                         struct{}{},
+       {"s390x", "internal/runtime/atomic", "Or8"}:                        struct{}{},
+       {"s390x", "internal/runtime/atomic", "Store"}:                      struct{}{},
+       {"s390x", "internal/runtime/atomic", "Store64"}:                    struct{}{},
+       {"s390x", "internal/runtime/atomic", "Store8"}:                     struct{}{},
+       {"s390x", "internal/runtime/atomic", "StoreRel"}:                   struct{}{},
+       {"s390x", "internal/runtime/atomic", "StoreRel64"}:                 struct{}{},
+       {"s390x", "internal/runtime/atomic", "StoreReluintptr"}:            struct{}{},
+       {"s390x", "internal/runtime/atomic", "Storeint32"}:                 struct{}{},
+       {"s390x", "internal/runtime/atomic", "Storeint64"}:                 struct{}{},
+       {"s390x", "internal/runtime/atomic", "StorepNoWB"}:                 struct{}{},
+       {"s390x", "internal/runtime/atomic", "Storeuintptr"}:               struct{}{},
+       {"s390x", "internal/runtime/atomic", "Xadd"}:                       struct{}{},
+       {"s390x", "internal/runtime/atomic", "Xadd64"}:                     struct{}{},
+       {"s390x", "internal/runtime/atomic", "Xaddint32"}:                  struct{}{},
+       {"s390x", "internal/runtime/atomic", "Xaddint64"}:                  struct{}{},
+       {"s390x", "internal/runtime/atomic", "Xadduintptr"}:                struct{}{},
+       {"s390x", "internal/runtime/atomic", "Xchg"}:                       struct{}{},
+       {"s390x", "internal/runtime/atomic", "Xchg64"}:                     struct{}{},
+       {"s390x", "internal/runtime/atomic", "Xchgint32"}:                  struct{}{},
+       {"s390x", "internal/runtime/atomic", "Xchgint64"}:                  struct{}{},
+       {"s390x", "internal/runtime/atomic", "Xchguintptr"}:                struct{}{},
+       {"s390x", "internal/runtime/math", "Add64"}:                        struct{}{},
+       {"s390x", "internal/runtime/math", "Mul64"}:                        struct{}{},
+       {"s390x", "internal/runtime/sys", "Bswap32"}:                       struct{}{},
+       {"s390x", "internal/runtime/sys", "Bswap64"}:                       struct{}{},
+       {"s390x", "internal/runtime/sys", "GetCallerPC"}:                   struct{}{},
+       {"s390x", "internal/runtime/sys", "GetCallerSP"}:                   struct{}{},
+       {"s390x", "internal/runtime/sys", "GetClosurePtr"}:                 struct{}{},
+       {"s390x", "internal/runtime/sys", "Len64"}:                         struct{}{},
+       {"s390x", "internal/runtime/sys", "Len8"}:                          struct{}{},
+       {"s390x", "internal/runtime/sys", "OnesCount64"}:                   struct{}{},
+       {"s390x", "internal/runtime/sys", "TrailingZeros32"}:               struct{}{},
+       {"s390x", "internal/runtime/sys", "TrailingZeros64"}:               struct{}{},
+       {"s390x", "internal/runtime/sys", "TrailingZeros8"}:                struct{}{},
+       {"s390x", "math", "Ceil"}:                                          struct{}{},
+       {"s390x", "math", "FMA"}:                                           struct{}{},
+       {"s390x", "math", "Floor"}:                                         struct{}{},
+       {"s390x", "math", "Round"}:                                         struct{}{},
+       {"s390x", "math", "RoundToEven"}:                                   struct{}{},
+       {"s390x", "math", "Trunc"}:                                         struct{}{},
+       {"s390x", "math", "sqrt"}:                                          struct{}{},
+       {"s390x", "math/big", "mulWW"}:                                     struct{}{},
+       {"s390x", "math/bits", "Add"}:                                      struct{}{},
+       {"s390x", "math/bits", "Add64"}:                                    struct{}{},
+       {"s390x", "math/bits", "Len"}:                                      struct{}{},
+       {"s390x", "math/bits", "Len16"}:                                    struct{}{},
+       {"s390x", "math/bits", "Len32"}:                                    struct{}{},
+       {"s390x", "math/bits", "Len64"}:                                    struct{}{},
+       {"s390x", "math/bits", "Len8"}:                                     struct{}{},
+       {"s390x", "math/bits", "Mul"}:                                      struct{}{},
+       {"s390x", "math/bits", "Mul64"}:                                    struct{}{},
+       {"s390x", "math/bits", "OnesCount16"}:                              struct{}{},
+       {"s390x", "math/bits", "OnesCount32"}:                              struct{}{},
+       {"s390x", "math/bits", "OnesCount64"}:                              struct{}{},
+       {"s390x", "math/bits", "OnesCount8"}:                               struct{}{},
+       {"s390x", "math/bits", "ReverseBytes32"}:                           struct{}{},
+       {"s390x", "math/bits", "ReverseBytes64"}:                           struct{}{},
+       {"s390x", "math/bits", "RotateLeft"}:                               struct{}{},
+       {"s390x", "math/bits", "RotateLeft32"}:                             struct{}{},
+       {"s390x", "math/bits", "RotateLeft64"}:                             struct{}{},
+       {"s390x", "math/bits", "Sub"}:                                      struct{}{},
+       {"s390x", "math/bits", "Sub64"}:                                    struct{}{},
+       {"s390x", "math/bits", "TrailingZeros16"}:                          struct{}{},
+       {"s390x", "math/bits", "TrailingZeros32"}:                          struct{}{},
+       {"s390x", "math/bits", "TrailingZeros64"}:                          struct{}{},
+       {"s390x", "math/bits", "TrailingZeros8"}:                           struct{}{},
+       {"s390x", "runtime", "KeepAlive"}:                                  struct{}{},
+       {"s390x", "runtime", "slicebytetostringtmp"}:                       struct{}{},
+       {"s390x", "sync", "runtime_LoadAcquintptr"}:                        struct{}{},
+       {"s390x", "sync", "runtime_StoreReluintptr"}:                       struct{}{},
+       {"s390x", "sync/atomic", "AddInt32"}:                               struct{}{},
+       {"s390x", "sync/atomic", "AddInt64"}:                               struct{}{},
+       {"s390x", "sync/atomic", "AddUint32"}:                              struct{}{},
+       {"s390x", "sync/atomic", "AddUint64"}:                              struct{}{},
+       {"s390x", "sync/atomic", "AddUintptr"}:                             struct{}{},
+       {"s390x", "sync/atomic", "CompareAndSwapInt32"}:                    struct{}{},
+       {"s390x", "sync/atomic", "CompareAndSwapInt64"}:                    struct{}{},
+       {"s390x", "sync/atomic", "CompareAndSwapUint32"}:                   struct{}{},
+       {"s390x", "sync/atomic", "CompareAndSwapUint64"}:                   struct{}{},
+       {"s390x", "sync/atomic", "CompareAndSwapUintptr"}:                  struct{}{},
+       {"s390x", "sync/atomic", "LoadInt32"}:                              struct{}{},
+       {"s390x", "sync/atomic", "LoadInt64"}:                              struct{}{},
+       {"s390x", "sync/atomic", "LoadPointer"}:                            struct{}{},
+       {"s390x", "sync/atomic", "LoadUint32"}:                             struct{}{},
+       {"s390x", "sync/atomic", "LoadUint64"}:                             struct{}{},
+       {"s390x", "sync/atomic", "LoadUintptr"}:                            struct{}{},
+       {"s390x", "sync/atomic", "StoreInt32"}:                             struct{}{},
+       {"s390x", "sync/atomic", "StoreInt64"}:                             struct{}{},
+       {"s390x", "sync/atomic", "StoreUint32"}:                            struct{}{},
+       {"s390x", "sync/atomic", "StoreUint64"}:                            struct{}{},
+       {"s390x", "sync/atomic", "StoreUintptr"}:                           struct{}{},
+       {"s390x", "sync/atomic", "SwapInt32"}:                              struct{}{},
+       {"s390x", "sync/atomic", "SwapInt64"}:                              struct{}{},
+       {"s390x", "sync/atomic", "SwapUint32"}:                             struct{}{},
+       {"s390x", "sync/atomic", "SwapUint64"}:                             struct{}{},
+       {"s390x", "sync/atomic", "SwapUintptr"}:                            struct{}{},
+       {"wasm", "internal/runtime/sys", "GetCallerPC"}:                    struct{}{},
+       {"wasm", "internal/runtime/sys", "GetCallerSP"}:                    struct{}{},
+       {"wasm", "internal/runtime/sys", "GetClosurePtr"}:                  struct{}{},
+       {"wasm", "internal/runtime/sys", "Len64"}:                          struct{}{},
+       {"wasm", "internal/runtime/sys", "Len8"}:                           struct{}{},
+       {"wasm", "internal/runtime/sys", "OnesCount64"}:                    struct{}{},
+       {"wasm", "internal/runtime/sys", "TrailingZeros32"}:                struct{}{},
+       {"wasm", "internal/runtime/sys", "TrailingZeros64"}:                struct{}{},
+       {"wasm", "internal/runtime/sys", "TrailingZeros8"}:                 struct{}{},
+       {"wasm", "math", "Abs"}:                                            struct{}{},
+       {"wasm", "math", "Ceil"}:                                           struct{}{},
+       {"wasm", "math", "Copysign"}:                                       struct{}{},
+       {"wasm", "math", "Floor"}:                                          struct{}{},
+       {"wasm", "math", "RoundToEven"}:                                    struct{}{},
+       {"wasm", "math", "Trunc"}:                                          struct{}{},
+       {"wasm", "math", "sqrt"}:                                           struct{}{},
+       {"wasm", "math/bits", "Len"}:                                       struct{}{},
+       {"wasm", "math/bits", "Len16"}:                                     struct{}{},
+       {"wasm", "math/bits", "Len32"}:                                     struct{}{},
+       {"wasm", "math/bits", "Len64"}:                                     struct{}{},
+       {"wasm", "math/bits", "Len8"}:                                      struct{}{},
+       {"wasm", "math/bits", "OnesCount16"}:                               struct{}{},
+       {"wasm", "math/bits", "OnesCount32"}:                               struct{}{},
+       {"wasm", "math/bits", "OnesCount64"}:                               struct{}{},
+       {"wasm", "math/bits", "OnesCount8"}:                                struct{}{},
+       {"wasm", "math/bits", "RotateLeft"}:                                struct{}{},
+       {"wasm", "math/bits", "RotateLeft32"}:                              struct{}{},
+       {"wasm", "math/bits", "RotateLeft64"}:                              struct{}{},
+       {"wasm", "math/bits", "TrailingZeros16"}:                           struct{}{},
+       {"wasm", "math/bits", "TrailingZeros32"}:                           struct{}{},
+       {"wasm", "math/bits", "TrailingZeros64"}:                           struct{}{},
+       {"wasm", "math/bits", "TrailingZeros8"}:                            struct{}{},
+       {"wasm", "runtime", "KeepAlive"}:                                   struct{}{},
+       {"wasm", "runtime", "slicebytetostringtmp"}:                        struct{}{},
 }
 
 func TestIntrinsics(t *testing.T) {

diff --git a/src/internal/runtime/maps/group.go b/src/internal/runtime/maps/group.go
index 59df1fb25a0db854b2c127252a58e7a13bd5052b..f3e9d4d12b9b7ee7ca1a17e307f1022357e02add 100644 (file)
--- a/src/internal/runtime/maps/group.go
+++ b/src/internal/runtime/maps/group.go
@@ -30,33 +30,82 @@ const (
 
 // bitset represents a set of slots within a group.
 //
-// The underlying representation uses one byte per slot, where each byte is
+// The underlying representation depends on GOARCH.
+//
+// On AMD64, bitset uses one bit per slot, where the bit is set if the slot is
+// part of the set. All of the ctrlGroup.match* methods are replaced with
+// intrinsics that return this packed representation.
+//
+// On other architectures, bitset uses one byte per slot, where each byte is
 // either 0x80 if the slot is part of the set or 0x00 otherwise. This makes it
-// convenient to calculate for an entire group at once (e.g. see matchEmpty).
+// convenient to calculate for an entire group at once using standard
+// arithemetic instructions.
 type bitset uint64
 
-// first assumes that only the MSB of each control byte can be set (e.g. bitset
-// is the result of matchEmpty or similar) and returns the relative index of the
-// first control byte in the group that has the MSB set.
+// first returns the relative index of the first control byte in the group that
+// is in the set.
 //
-// Returns abi.SwissMapGroupSlots if the bitset is empty.
+// Preconditions: b is not 0 (empty).
 func (b bitset) first() uintptr {
+       return bitsetFirst(b)
+}
+
+// Portable implementation of first.
+//
+// On AMD64, this is replaced with an intrisic that simply does
+// TrailingZeros64. There is no need to shift as the bitset is packed.
+func bitsetFirst(b bitset) uintptr {
        return uintptr(sys.TrailingZeros64(uint64(b))) >> 3
 }
 
-// removeFirst removes the first set bit (that is, resets the least significant
+// removeFirst clears the first set bit (that is, resets the least significant
 // set bit to 0).
 func (b bitset) removeFirst() bitset {
        return b & (b - 1)
 }
 
-// removeBelow removes all set bits below slot i (non-inclusive).
+// removeBelow clears all set bits below slot i (non-inclusive).
 func (b bitset) removeBelow(i uintptr) bitset {
+       return bitsetRemoveBelow(b, i)
+}
+
+// Portable implementation of removeBelow.
+//
+// On AMD64, this is replaced with an intrisic that clears the lower i bits.
+func bitsetRemoveBelow(b bitset, i uintptr) bitset {
        // Clear all bits below slot i's byte.
        mask := (uint64(1) << (8 * uint64(i))) - 1
        return b &^ bitset(mask)
 }
 
+// lowestSet returns true if the bit is set for the lowest index in the bitset.
+//
+// This is intended for use with shiftOutLowest to loop over all entries in the
+// bitset regardless of whether they are set.
+func (b bitset) lowestSet() bool {
+       return bitsetLowestSet(b)
+}
+
+// Portable implementation of lowestSet.
+//
+// On AMD64, this is replaced with an intrisic that checks the lowest bit.
+func bitsetLowestSet(b bitset) bool {
+       return b&(1<<7) != 0
+}
+
+// shiftOutLowest shifts the lowest entry out of the bitset. Afterwards, the
+// lowest entry in the bitset corresponds to the next slot.
+func (b bitset) shiftOutLowest() bitset {
+       return bitsetShiftOutLowest(b)
+}
+
+// Portable implementation of shiftOutLowest.
+//
+// On AMD64, this is replaced with an intrisic that shifts a single bit.
+func bitsetShiftOutLowest(b bitset) bitset {
+       return b >> 8
+}
+
 // Each slot in the hash table has a control byte which can have one of three
 // states: empty, deleted, and full. They have the following bit patterns:
 //
@@ -96,6 +145,14 @@ func (g *ctrlGroup) setEmpty() {
 // matchH2 returns the set of slots which are full and for which the 7-bit hash
 // matches the given value. May return false positives.
 func (g ctrlGroup) matchH2(h uintptr) bitset {
+       return ctrlGroupMatchH2(g, h)
+}
+
+// Portable implementation of matchH2.
+//
+// Note: On AMD64, this is an intrinsic implemented with SIMD instructions. See
+// note on bitset about the packed instrinsified return value.
+func ctrlGroupMatchH2(g ctrlGroup, h uintptr) bitset {
        // NB: This generic matching routine produces false positive matches when
        // h is 2^N and the control bytes have a seq of 2^N followed by 2^N+1. For
        // example: if ctrls==0x0302 and h=02, we'll compute v as 0x0100. When we
@@ -110,6 +167,14 @@ func (g ctrlGroup) matchH2(h uintptr) bitset {
 
 // matchEmpty returns the set of slots in the group that are empty.
 func (g ctrlGroup) matchEmpty() bitset {
+       return ctrlGroupMatchEmpty(g)
+}
+
+// Portable implementation of matchEmpty.
+//
+// Note: On AMD64, this is an intrinsic implemented with SIMD instructions. See
+// note on bitset about the packed instrinsified return value.
+func ctrlGroupMatchEmpty(g ctrlGroup) bitset {
        // An empty slot is   1000 0000
        // A deleted slot is  1111 1110
        // A full slot is     0??? ????
@@ -123,6 +188,14 @@ func (g ctrlGroup) matchEmpty() bitset {
 // matchEmptyOrDeleted returns the set of slots in the group that are empty or
 // deleted.
 func (g ctrlGroup) matchEmptyOrDeleted() bitset {
+       return ctrlGroupMatchEmptyOrDeleted(g)
+}
+
+// Portable implementation of matchEmptyOrDeleted.
+//
+// Note: On AMD64, this is an intrinsic implemented with SIMD instructions. See
+// note on bitset about the packed instrinsified return value.
+func ctrlGroupMatchEmptyOrDeleted(g ctrlGroup) bitset {
        // An empty slot is  1000 0000
        // A deleted slot is 1111 1110
        // A full slot is    0??? ????
@@ -134,6 +207,14 @@ func (g ctrlGroup) matchEmptyOrDeleted() bitset {
 
 // matchFull returns the set of slots in the group that are full.
 func (g ctrlGroup) matchFull() bitset {
+       return ctrlGroupMatchFull(g)
+}
+
+// Portable implementation of matchFull.
+//
+// Note: On AMD64, this is an intrinsic implemented with SIMD instructions. See
+// note on bitset about the packed instrinsified return value.
+func ctrlGroupMatchFull(g ctrlGroup) bitset {
        // An empty slot is  1000 0000
        // A deleted slot is 1111 1110
        // A full slot is    0??? ????

diff --git a/src/internal/runtime/maps/runtime_fast32_swiss.go b/src/internal/runtime/maps/runtime_fast32_swiss.go
index 15facbfe8a6bb2100372af8533f019ad4d75bbf9..46023cc9b70729f01b8239c2766d9e4d8c6b8bc3 100644 (file)
--- a/src/internal/runtime/maps/runtime_fast32_swiss.go
+++ b/src/internal/runtime/maps/runtime_fast32_swiss.go
@@ -38,12 +38,12 @@ func runtime_mapaccess1_fast32(typ *abi.SwissMapType, m *Map, key uint32) unsafe
                slotKey := g.key(typ, 0)
                slotSize := typ.SlotSize
                for full != 0 {
-                       if key == *(*uint32)(slotKey) && full&(1<<7) != 0 {
+                       if key == *(*uint32)(slotKey) && full.lowestSet() {
                                slotElem := unsafe.Pointer(uintptr(slotKey) + typ.ElemOff)
                                return slotElem
                        }
                        slotKey = unsafe.Pointer(uintptr(slotKey) + slotSize)
-                       full >>= 8
+                       full = full.shiftOutLowest()
                }
                return unsafe.Pointer(&zeroVal[0])
        }
@@ -107,12 +107,12 @@ func runtime_mapaccess2_fast32(typ *abi.SwissMapType, m *Map, key uint32) (unsaf
                slotKey := g.key(typ, 0)
                slotSize := typ.SlotSize
                for full != 0 {
-                       if key == *(*uint32)(slotKey) && full&(1<<7) != 0 {
+                       if key == *(*uint32)(slotKey) && full.lowestSet() {
                                slotElem := unsafe.Pointer(uintptr(slotKey) + typ.ElemOff)
                                return slotElem, true
                        }
                        slotKey = unsafe.Pointer(uintptr(slotKey) + slotSize)
-                       full >>= 8
+                       full = full.shiftOutLowest()
                }
                return unsafe.Pointer(&zeroVal[0]), false
        }

diff --git a/src/internal/runtime/maps/runtime_fast64_swiss.go b/src/internal/runtime/maps/runtime_fast64_swiss.go
index f08e7ef86900aa262d48d4bc6a0280702d3a30d3..6bc6b2f0b1f5cab30e5973ea7bb25219531b4ac8 100644 (file)
--- a/src/internal/runtime/maps/runtime_fast64_swiss.go
+++ b/src/internal/runtime/maps/runtime_fast64_swiss.go
@@ -38,12 +38,12 @@ func runtime_mapaccess1_fast64(typ *abi.SwissMapType, m *Map, key uint64) unsafe
                slotKey := g.key(typ, 0)
                slotSize := typ.SlotSize
                for full != 0 {
-                       if key == *(*uint64)(slotKey) && full&(1<<7) != 0 {
+                       if key == *(*uint64)(slotKey) && full.lowestSet() {
                                slotElem := unsafe.Pointer(uintptr(slotKey) + 8)
                                return slotElem
                        }
                        slotKey = unsafe.Pointer(uintptr(slotKey) + slotSize)
-                       full >>= 8
+                       full = full.shiftOutLowest()
                }
                return unsafe.Pointer(&zeroVal[0])
        }
@@ -107,12 +107,12 @@ func runtime_mapaccess2_fast64(typ *abi.SwissMapType, m *Map, key uint64) (unsaf
                slotKey := g.key(typ, 0)
                slotSize := typ.SlotSize
                for full != 0 {
-                       if key == *(*uint64)(slotKey) && full&(1<<7) != 0 {
+                       if key == *(*uint64)(slotKey) && full.lowestSet() {
                                slotElem := unsafe.Pointer(uintptr(slotKey) + 8)
                                return slotElem, true
                        }
                        slotKey = unsafe.Pointer(uintptr(slotKey) + slotSize)
-                       full >>= 8
+                       full = full.shiftOutLowest()
                }
                return unsafe.Pointer(&zeroVal[0]), false
        }