From: Michael Pratt Date: Mon, 4 Nov 2024 17:41:33 +0000 (-0500) Subject: cmd/compile: intrinsify swissmap match calls with SIMD on amd64 X-Git-Tag: go1.24rc1~170 X-Git-Url: http://www.git.cypherpunks.su/?a=commitdiff_plain;h=dce30a19200d06b778fa90c96231b3cf71fe72d8;p=gostls13.git 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 LUCI-TryBot-Result: Go LUCI Auto-Submit: Michael Pratt Reviewed-by: Keith Randall --- diff --git a/src/cmd/compile/internal/amd64/ssa.go b/src/cmd/compile/internal/amd64/ssa.go index 61f1c88a71..493369af51 100644 --- 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 c171d5fd19..23fb2361b5 100644 --- 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 86d8924943..df1ddfa69e 100644 --- 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 8a721b4134..e4da86db51 100644 --- 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 df2a6b3187..2e29a45c0b 100644 --- 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 59df1fb25a..f3e9d4d12b 100644 --- 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 15facbfe8a..46023cc9b7 100644 --- 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 f08e7ef869..6bc6b2f0b1 100644 --- 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 }