Add files using upload-large-folder tool

go/src/internal/abi/abi.go

@@ -0,0 +1,104 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package abi
+
+import (
+	"internal/goarch"
+	"unsafe"
+)
+
+// RegArgs is a struct that has space for each argument
+// and return value register on the current architecture.
+//
+// Assembly code knows the layout of the first two fields
+// of RegArgs.
+//
+// RegArgs also contains additional space to hold pointers
+// when it may not be safe to keep them only in the integer
+// register space otherwise.
+type RegArgs struct {
+	// Values in these slots should be precisely the bit-by-bit
+	// representation of how they would appear in a register.
+	//
+	// This means that on big endian arches, integer values should
+	// be in the top bits of the slot. Floats are usually just
+	// directly represented, but some architectures treat narrow
+	// width floating point values specially (e.g. they're promoted
+	// first, or they need to be NaN-boxed).
+	Ints   [IntArgRegs]uintptr  // untyped integer registers
+	Floats [FloatArgRegs]uint64 // untyped float registers
+
+	// Fields above this point are known to assembly.
+
+	// Ptrs is a space that duplicates Ints but with pointer type,
+	// used to make pointers passed or returned  in registers
+	// visible to the GC by making the type unsafe.Pointer.
+	Ptrs [IntArgRegs]unsafe.Pointer
+
+	// ReturnIsPtr is a bitmap that indicates which registers
+	// contain or will contain pointers on the return path from
+	// a reflectcall. The i'th bit indicates whether the i'th
+	// register contains or will contain a valid Go pointer.
+	ReturnIsPtr IntArgRegBitmap
+}
+
+func (r *RegArgs) Dump() {
+	print("Ints:")
+	for _, x := range r.Ints {
+		print(" ", x)
+	}
+	println()
+	print("Floats:")
+	for _, x := range r.Floats {
+		print(" ", x)
+	}
+	println()
+	print("Ptrs:")
+	for _, x := range r.Ptrs {
+		print(" ", x)
+	}
+	println()
+}
+
+// IntRegArgAddr returns a pointer inside of r.Ints[reg] that is appropriately
+// offset for an argument of size argSize.
+//
+// argSize must be non-zero, fit in a register, and a power-of-two.
+//
+// This method is a helper for dealing with the endianness of different CPU
+// architectures, since sub-word-sized arguments in big endian architectures
+// need to be "aligned" to the upper edge of the register to be interpreted
+// by the CPU correctly.
+func (r *RegArgs) IntRegArgAddr(reg int, argSize uintptr) unsafe.Pointer {
+	if argSize > goarch.PtrSize || argSize == 0 || argSize&(argSize-1) != 0 {
+		panic("invalid argSize")
+	}
+	offset := uintptr(0)
+	if goarch.BigEndian {
+		offset = goarch.PtrSize - argSize
+	}
+	return unsafe.Pointer(uintptr(unsafe.Pointer(&r.Ints[reg])) + offset)
+}
+
+// IntArgRegBitmap is a bitmap large enough to hold one bit per
+// integer argument/return register.
+type IntArgRegBitmap [(IntArgRegs + 7) / 8]uint8
+
+// Set sets the i'th bit of the bitmap to 1.
+func (b *IntArgRegBitmap) Set(i int) {
+	b[i/8] |= uint8(1) << (i % 8)
+}
+
+// Get returns whether the i'th bit of the bitmap is set.
+//
+// nosplit because it's called in extremely sensitive contexts, like
+// on the reflectcall return path.
+//
+//go:nosplit
+func (b *IntArgRegBitmap) Get(i int) bool {
+	// Compute p=&b[i/8], but without a bounds check. We don't have the stack for it.
+	p := (*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(b)) + uintptr(i/8)))
+	return *p&(uint8(1)<<(i%8)) != 0
+}

go/src/internal/abi/abi_amd64.go

@@ -0,0 +1,18 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package abi
+
+const (
+	// See abi_generic.go.
+
+	// RAX, RBX, RCX, RDI, RSI, R8, R9, R10, R11.
+	IntArgRegs = 9
+
+	// X0 -> X14.
+	FloatArgRegs = 15
+
+	// We use SSE2 registers which support 64-bit float operations.
+	EffectiveFloatRegSize = 8
+)

go/src/internal/abi/abi_arm64.go

@@ -0,0 +1,17 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package abi
+
+const (
+	// See abi_generic.go.
+
+	// R0 - R15.
+	IntArgRegs = 16
+
+	// F0 - F15.
+	FloatArgRegs = 16
+
+	EffectiveFloatRegSize = 8
+)

go/src/internal/abi/abi_generic.go

@@ -0,0 +1,38 @@
+// Copyright 2020 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build !goexperiment.regabiargs && !amd64 && !arm64 && !loong64 && !ppc64 && !ppc64le && !riscv64
+
+package abi
+
+const (
+	// ABI-related constants.
+	//
+	// In the generic case, these are all zero
+	// which lets them gracefully degrade to ABI0.
+
+	// IntArgRegs is the number of registers dedicated
+	// to passing integer argument values. Result registers are identical
+	// to argument registers, so this number is used for those too.
+	IntArgRegs = 0
+
+	// FloatArgRegs is the number of registers dedicated
+	// to passing floating-point argument values. Result registers are
+	// identical to argument registers, so this number is used for
+	// those too.
+	FloatArgRegs = 0
+
+	// EffectiveFloatRegSize describes the width of floating point
+	// registers on the current platform from the ABI's perspective.
+	//
+	// Since Go only supports 32-bit and 64-bit floating point primitives,
+	// this number should be either 0, 4, or 8. 0 indicates no floating
+	// point registers for the ABI or that floating point values will be
+	// passed via the softfloat ABI.
+	//
+	// For platforms that support larger floating point register widths,
+	// such as x87's 80-bit "registers" (not that we support x87 currently),
+	// use 8.
+	EffectiveFloatRegSize = 0
+)

go/src/internal/abi/abi_loong64.go

@@ -0,0 +1,17 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package abi
+
+const (
+	// See abi_generic.go.
+
+	// R4 - R19
+	IntArgRegs = 16
+
+	// F0 - F15
+	FloatArgRegs = 16
+
+	EffectiveFloatRegSize = 8
+)

go/src/internal/abi/abi_ppc64x.go

@@ -0,0 +1,19 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build ppc64 || ppc64le
+
+package abi
+
+const (
+	// See abi_generic.go.
+
+	// R3 - R10, R14 - R17.
+	IntArgRegs = 12
+
+	// F1 - F12.
+	FloatArgRegs = 12
+
+	EffectiveFloatRegSize = 8
+)

go/src/internal/abi/abi_riscv64.go

@@ -0,0 +1,17 @@
+// Copyright 2022 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package abi
+
+const (
+	// See abi_generic.go.
+
+	// X8 - X23
+	IntArgRegs = 16
+
+	// F8 - F23.
+	FloatArgRegs = 16
+
+	EffectiveFloatRegSize = 8
+)

go/src/internal/abi/abi_s390x.go

@@ -0,0 +1,19 @@
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build goexperiment.regabiargs
+
+package abi
+
+const (
+	// See abi_generic.go.
+
+	// R2 - R9.
+	IntArgRegs = 8
+
+	// F0 - F15
+	FloatArgRegs = 16
+
+	EffectiveFloatRegSize = 8
+)

go/src/internal/abi/abi_test.go

@@ -0,0 +1,79 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package abi_test
+
+import (
+	"internal/abi"
+	"internal/testenv"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestFuncPC(t *testing.T) {
+	// Test that FuncPC* can get correct function PC.
+	pcFromAsm := abi.FuncPCTestFnAddr
+
+	// Test FuncPC for locally defined function
+	pcFromGo := abi.FuncPCTest()
+	if pcFromGo != pcFromAsm {
+		t.Errorf("FuncPC returns wrong PC, want %x, got %x", pcFromAsm, pcFromGo)
+	}
+
+	// Test FuncPC for imported function
+	pcFromGo = abi.FuncPCABI0(abi.FuncPCTestFn)
+	if pcFromGo != pcFromAsm {
+		t.Errorf("FuncPC returns wrong PC, want %x, got %x", pcFromAsm, pcFromGo)
+	}
+}
+
+func TestFuncPCCompileError(t *testing.T) {
+	// Test that FuncPC* on a function of a mismatched ABI is rejected.
+	testenv.MustHaveGoBuild(t)
+
+	// We want to test internal package, which we cannot normally import.
+	// Run the assembler and compiler manually.
+	tmpdir := t.TempDir()
+	asmSrc := filepath.Join("testdata", "x.s")
+	goSrc := filepath.Join("testdata", "x.go")
+	symabi := filepath.Join(tmpdir, "symabi")
+	obj := filepath.Join(tmpdir, "x.o")
+
+	// Write an importcfg file for the dependencies of the package.
+	importcfgfile := filepath.Join(tmpdir, "hello.importcfg")
+	testenv.WriteImportcfg(t, importcfgfile, nil, "internal/abi")
+
+	// parse assembly code for symabi.
+	cmd := testenv.Command(t, testenv.GoToolPath(t), "tool", "asm", "-p=p", "-gensymabis", "-o", symabi, asmSrc)
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("go tool asm -gensymabis failed: %v\n%s", err, out)
+	}
+
+	// compile go code.
+	cmd = testenv.Command(t, testenv.GoToolPath(t), "tool", "compile", "-importcfg="+importcfgfile, "-p=p", "-symabis", symabi, "-o", obj, goSrc)
+	out, err = cmd.CombinedOutput()
+	if err == nil {
+		t.Fatalf("go tool compile did not fail")
+	}
+
+	// Expect errors in line 17, 18, 20, no errors on other lines.
+	want := []string{"x.go:17", "x.go:18", "x.go:20"}
+	got := strings.Split(string(out), "\n")
+	if got[len(got)-1] == "" {
+		got = got[:len(got)-1] // remove last empty line
+	}
+	for i, s := range got {
+		if !strings.Contains(s, want[i]) {
+			t.Errorf("did not error on line %s", want[i])
+		}
+	}
+	if len(got) != len(want) {
+		t.Errorf("unexpected number of errors, want %d, got %d", len(want), len(got))
+	}
+	if t.Failed() {
+		t.Logf("output:\n%s", string(out))
+	}
+}

go/src/internal/abi/abi_test.s

@@ -0,0 +1,27 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#include "textflag.h"
+
+#ifdef GOARCH_386
+#define PTRSIZE 4
+#endif
+#ifdef GOARCH_arm
+#define PTRSIZE 4
+#endif
+#ifdef GOARCH_mips
+#define PTRSIZE 4
+#endif
+#ifdef GOARCH_mipsle
+#define PTRSIZE 4
+#endif
+#ifndef PTRSIZE
+#define PTRSIZE 8
+#endif
+
+TEXT	internal∕abi·FuncPCTestFn(SB),NOSPLIT,$0-0
+	RET
+
+GLOBL	internal∕abi·FuncPCTestFnAddr(SB), NOPTR, $PTRSIZE
+DATA	internal∕abi·FuncPCTestFnAddr(SB)/PTRSIZE, $internal∕abi·FuncPCTestFn(SB)

go/src/internal/abi/bounds.go

@@ -0,0 +1,113 @@
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package abi
+
+// This type and constants are for encoding different
+// kinds of bounds check failures.
+type BoundsErrorCode uint8
+
+const (
+	BoundsIndex      BoundsErrorCode = iota // s[x], 0 <= x < len(s) failed
+	BoundsSliceAlen                         // s[?:x], 0 <= x <= len(s) failed
+	BoundsSliceAcap                         // s[?:x], 0 <= x <= cap(s) failed
+	BoundsSliceB                            // s[x:y], 0 <= x <= y failed (but boundsSliceA didn't happen)
+	BoundsSlice3Alen                        // s[?:?:x], 0 <= x <= len(s) failed
+	BoundsSlice3Acap                        // s[?:?:x], 0 <= x <= cap(s) failed
+	BoundsSlice3B                           // s[?:x:y], 0 <= x <= y failed (but boundsSlice3A didn't happen)
+	BoundsSlice3C                           // s[x:y:?], 0 <= x <= y failed (but boundsSlice3A/B didn't happen)
+	BoundsConvert                           // (*[x]T)(s), 0 <= x <= len(s) failed
+	numBoundsCodes
+)
+
+const (
+	BoundsMaxReg   = 15
+	BoundsMaxConst = 31
+)
+
+// Here's how we encode PCDATA_PanicBounds entries:
+
+// We allow 16 registers (0-15) and 32 constants (0-31).
+// Encode the following constant c:
+//     bits    use
+// -----------------------------
+//       0     x is in a register
+//       1     y is in a register
+//
+// if x is in a register
+//       2     x is signed
+//     [3:6]   x's register number
+// else
+//     [2:6]   x's constant value
+//
+// if y is in a register
+//     [7:10]  y's register number
+// else
+//     [7:11]  y's constant value
+//
+// The final integer is c * numBoundsCode + code
+
+// TODO: 32-bit
+
+// Encode bounds failure information into an integer for PCDATA_PanicBounds.
+// Register numbers must be in 0-15. Constants must be in 0-31.
+func BoundsEncode(code BoundsErrorCode, signed, xIsReg, yIsReg bool, xVal, yVal int) int {
+	c := int(0)
+	if xIsReg {
+		c |= 1 << 0
+		if signed {
+			c |= 1 << 2
+		}
+		if xVal < 0 || xVal > BoundsMaxReg {
+			panic("bad xReg")
+		}
+		c |= xVal << 3
+	} else {
+		if xVal < 0 || xVal > BoundsMaxConst {
+			panic("bad xConst")
+		}
+		c |= xVal << 2
+	}
+	if yIsReg {
+		c |= 1 << 1
+		if yVal < 0 || yVal > BoundsMaxReg {
+			panic("bad yReg")
+		}
+		c |= yVal << 7
+	} else {
+		if yVal < 0 || yVal > BoundsMaxConst {
+			panic("bad yConst")
+		}
+		c |= yVal << 7
+	}
+	return c*int(numBoundsCodes) + int(code)
+}
+func BoundsDecode(v int) (code BoundsErrorCode, signed, xIsReg, yIsReg bool, xVal, yVal int) {
+	code = BoundsErrorCode(v % int(numBoundsCodes))
+	c := v / int(numBoundsCodes)
+	xIsReg = c&1 != 0
+	c >>= 1
+	yIsReg = c&1 != 0
+	c >>= 1
+	if xIsReg {
+		signed = c&1 != 0
+		c >>= 1
+		xVal = c & 0xf
+		c >>= 4
+	} else {
+		xVal = c & 0x1f
+		c >>= 5
+	}
+	if yIsReg {
+		yVal = c & 0xf
+		c >>= 4
+	} else {
+		yVal = c & 0x1f
+		c >>= 5
+	}
+	if c != 0 {
+		panic("BoundsDecode decoding error")
+	}
+	return
+}

go/src/internal/abi/compiletype.go

@@ -0,0 +1,28 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package abi
+
+// These functions are the build-time version of the Go type data structures.
+
+// Their contents must be kept in sync with their definitions.
+// Because the host and target type sizes can differ, the compiler and
+// linker cannot use the host information that they might get from
+// either unsafe.Sizeof and Alignof, nor runtime, reflect, or reflectlite.
+
+// CommonSize returns sizeof(Type) for a compilation target with a given ptrSize
+func CommonSize(ptrSize int) int { return 4*ptrSize + 8 + 8 }
+
+// StructFieldSize returns sizeof(StructField) for a compilation target with a given ptrSize
+func StructFieldSize(ptrSize int) int { return 3 * ptrSize }
+
+// UncommonSize returns sizeof(UncommonType).  This currently does not depend on ptrSize.
+// This exported function is in an internal package, so it may change to depend on ptrSize in the future.
+func UncommonSize() uint64 { return 4 + 2 + 2 + 4 + 4 }
+
+// TFlagOff returns the offset of Type.TFlag for a compilation target with a given ptrSize
+func TFlagOff(ptrSize int) int { return 2*ptrSize + 4 }
+
+// ITabTypeOff returns the offset of ITab.Type for a compilation target with a given ptrSize
+func ITabTypeOff(ptrSize int) int { return ptrSize }

go/src/internal/abi/escape.go

@@ -0,0 +1,65 @@
+// Copyright 2024 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package abi
+
+import "unsafe"
+
+// NoEscape hides the pointer p from escape analysis, preventing it
+// from escaping to the heap. It compiles down to nothing.
+//
+// WARNING: This is very subtle to use correctly. The caller must
+// ensure that it's truly safe for p to not escape to the heap by
+// maintaining runtime pointer invariants (for example, that globals
+// and the heap may not generally point into a stack).
+//
+//go:nosplit
+//go:nocheckptr
+func NoEscape(p unsafe.Pointer) unsafe.Pointer {
+	x := uintptr(p)
+	return unsafe.Pointer(x ^ 0)
+}
+
+var alwaysFalse bool
+var escapeSink any
+
+// Escape forces any pointers in x to escape to the heap.
+func Escape[T any](x T) T {
+	if alwaysFalse {
+		escapeSink = x
+	}
+	return x
+}
+
+// EscapeNonString forces v to be on the heap, if v contains a
+// non-string pointer.
+//
+// This is used in hash/maphash.Comparable. We cannot hash pointers
+// to local variables on stack, as their addresses might change on
+// stack growth. Strings are okay as the hash depends on only the
+// content, not the pointer.
+//
+// This is essentially
+//
+//	if hasNonStringPointers(T) { Escape(v) }
+//
+// Implemented as a compiler intrinsic.
+func EscapeNonString[T any](v T) { panic("intrinsic") }
+
+// EscapeToResultNonString models a data flow edge from v to the result,
+// if v contains a non-string pointer. If v contains only string pointers,
+// it returns a copy of v, but is not modeled as a data flow edge
+// from the escape analysis's perspective.
+//
+// This is used in unique.clone, to model the data flow edge on the
+// value with strings excluded, because strings are cloned (by
+// content).
+//
+// TODO: probably we should define this as a intrinsic and EscapeNonString
+// could just be "heap = EscapeToResultNonString(v)". This way we can model
+// an edge to the result but not necessarily heap.
+func EscapeToResultNonString[T any](v T) T {
+	EscapeNonString(v)
+	return *(*T)(NoEscape(unsafe.Pointer(&v)))
+}

go/src/internal/abi/export_test.go

@@ -0,0 +1,14 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package abi
+
+func FuncPCTestFn()
+
+var FuncPCTestFnAddr uintptr // address of FuncPCTestFn, directly retrieved from assembly
+
+//go:noinline
+func FuncPCTest() uintptr {
+	return FuncPCABI0(FuncPCTestFn)
+}

go/src/internal/abi/funcpc.go

@@ -0,0 +1,31 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build !gccgo
+
+package abi
+
+// FuncPC* intrinsics.
+//
+// CAREFUL: In programs with plugins, FuncPC* can return different values
+// for the same function (because there are actually multiple copies of
+// the same function in the address space). To be safe, don't use the
+// results of this function in any == expression. It is only safe to
+// use the result as an address at which to start executing code.
+
+// FuncPCABI0 returns the entry PC of the function f, which must be a
+// direct reference of a function defined as ABI0. Otherwise it is a
+// compile-time error.
+//
+// Implemented as a compile intrinsic.
+func FuncPCABI0(f any) uintptr
+
+// FuncPCABIInternal returns the entry PC of the function f. If f is a
+// direct reference of a function, it must be defined as ABIInternal.
+// Otherwise it is a compile-time error. If f is not a direct reference
+// of a defined function, it assumes that f is a func value. Otherwise
+// the behavior is undefined.
+//
+// Implemented as a compile intrinsic.
+func FuncPCABIInternal(f any) uintptr

go/src/internal/abi/funcpc_gccgo.go

@@ -0,0 +1,21 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// For bootstrapping with gccgo.
+
+//go:build gccgo
+
+package abi
+
+import "unsafe"
+
+func FuncPCABI0(f interface{}) uintptr {
+	words := (*[2]unsafe.Pointer)(unsafe.Pointer(&f))
+	return *(*uintptr)(unsafe.Pointer(words[1]))
+}
+
+func FuncPCABIInternal(f interface{}) uintptr {
+	words := (*[2]unsafe.Pointer)(unsafe.Pointer(&f))
+	return *(*uintptr)(unsafe.Pointer(words[1]))
+}

go/src/internal/abi/iface.go

@@ -0,0 +1,41 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package abi
+
+import "unsafe"
+
+// The first word of every non-empty interface type contains an *ITab.
+// It records the underlying concrete type (Type), the interface type it
+// is implementing (Inter), and some ancillary information.
+//
+// allocated in non-garbage-collected memory
+type ITab struct {
+	Inter *InterfaceType
+	Type  *Type
+	Hash  uint32     // copy of Type.Hash. Used for type switches.
+	Fun   [1]uintptr // variable sized. fun[0]==0 means Type does not implement Inter.
+}
+
+// EmptyInterface describes the layout of a "interface{}" or a "any."
+// These are represented differently than non-empty interface, as the first
+// word always points to an abi.Type.
+type EmptyInterface struct {
+	Type *Type
+	Data unsafe.Pointer
+}
+
+// NonEmptyInterface describes the layout of an interface that contains any methods.
+type NonEmptyInterface struct {
+	ITab *ITab
+	Data unsafe.Pointer
+}
+
+// CommonInterface describes the layout of both [EmptyInterface] and [NonEmptyInterface].
+type CommonInterface struct {
+	// Either an *ITab or a *Type, unexported to avoid accidental use.
+	_ unsafe.Pointer
+
+	Data unsafe.Pointer
+}

go/src/internal/abi/map.go

@@ -0,0 +1,64 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package abi
+
+import (
+	"unsafe"
+)
+
+// Map constants common to several packages
+// runtime/runtime-gdb.py:MapTypePrinter contains its own copy
+const (
+	// Number of bits in the group.slot count.
+	MapGroupSlotsBits = 3
+
+	// Number of slots in a group.
+	MapGroupSlots = 1 << MapGroupSlotsBits // 8
+
+	// Maximum key or elem size to keep inline (instead of mallocing per element).
+	// Must fit in a uint8.
+	MapMaxKeyBytes  = 128
+	MapMaxElemBytes = 128
+
+	ctrlEmpty = 0b10000000
+	bitsetLSB = 0x0101010101010101
+
+	// Value of control word with all empty slots.
+	MapCtrlEmpty = bitsetLSB * uint64(ctrlEmpty)
+)
+
+type MapType struct {
+	Type
+	Key   *Type
+	Elem  *Type
+	Group *Type // internal type representing a slot group
+	// function for hashing keys (ptr to key, seed) -> hash
+	Hasher    func(unsafe.Pointer, uintptr) uintptr
+	GroupSize uintptr // == Group.Size_
+	SlotSize  uintptr // size of key/elem slot
+	ElemOff   uintptr // offset of elem in key/elem slot
+	Flags     uint32
+}
+
+// Flag values
+const (
+	MapNeedKeyUpdate = 1 << iota
+	MapHashMightPanic
+	MapIndirectKey
+	MapIndirectElem
+)
+
+func (mt *MapType) NeedKeyUpdate() bool { // true if we need to update key on an overwrite
+	return mt.Flags&MapNeedKeyUpdate != 0
+}
+func (mt *MapType) HashMightPanic() bool { // true if hash function might panic
+	return mt.Flags&MapHashMightPanic != 0
+}
+func (mt *MapType) IndirectKey() bool { // store ptr to key instead of key itself
+	return mt.Flags&MapIndirectKey != 0
+}
+func (mt *MapType) IndirectElem() bool { // store ptr to elem instead of elem itself
+	return mt.Flags&MapIndirectElem != 0
+}

go/src/internal/abi/rangefuncconsts.go

@@ -0,0 +1,18 @@
+// Copyright 2024 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package abi
+
+type RF_State int
+
+// These constants are shared between the compiler, which uses them for state functions
+// and panic indicators, and the runtime, which turns them into more meaningful strings
+// For best code generation, RF_DONE and RF_READY should be 0 and 1.
+const (
+	RF_DONE          = RF_State(iota) // body of loop has exited in a non-panic way
+	RF_READY                          // body of loop has not exited yet, is not running  -- this is not a panic index
+	RF_PANIC                          // body of loop is either currently running, or has panicked
+	RF_EXHAUSTED                      // iterator function return, i.e., sequence is "exhausted"
+	RF_MISSING_PANIC = 4              // body of loop panicked but iterator function defer-recovered it away
+)

go/src/internal/abi/runtime.go

@@ -0,0 +1,8 @@
+// Copyright 2024 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package abi
+
+// ZeroValSize is the size in bytes of runtime.zeroVal.
+const ZeroValSize = 1024

go/src/internal/abi/stack.go

@@ -0,0 +1,33 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package abi
+
+const (
+	// StackNosplitBase is the base maximum number of bytes that a chain of
+	// NOSPLIT functions can use.
+	//
+	// This value must be multiplied by the stack guard multiplier, so do not
+	// use it directly. See runtime/stack.go:stackNosplit and
+	// cmd/internal/objabi/stack.go:StackNosplit.
+	StackNosplitBase = 800
+
+	// We have three different sequences for stack bounds checks, depending on
+	// whether the stack frame of a function is small, big, or huge.
+
+	// After a stack split check the SP is allowed to be StackSmall bytes below
+	// the stack guard.
+	//
+	// Functions that need frames <= StackSmall can perform the stack check
+	// using a single comparison directly between the stack guard and the SP
+	// because we ensure that StackSmall bytes of stack space are available
+	// beyond the stack guard.
+	StackSmall = 128
+
+	// Functions that need frames <= StackBig can assume that neither
+	// SP-framesize nor stackGuard-StackSmall will underflow, and thus use a
+	// more efficient check. In order to ensure this, StackBig must be <= the
+	// size of the unmapped space at zero.
+	StackBig = 4096
+)

go/src/internal/abi/stub.s

@@ -0,0 +1,7 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// This file silences errors about body-less functions
+// that are provided by intrinsics in the latest version of the compiler,
+// but may not be known to the bootstrap compiler.

go/src/internal/abi/switch.go

@@ -0,0 +1,58 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package abi
+
+import "internal/goarch"
+
+type InterfaceSwitch struct {
+	Cache  *InterfaceSwitchCache
+	NCases int
+
+	// Array of NCases elements.
+	// Each case must be a non-empty interface type.
+	Cases [1]*InterfaceType
+}
+
+type InterfaceSwitchCache struct {
+	Mask    uintptr                      // mask for index. Must be a power of 2 minus 1
+	Entries [1]InterfaceSwitchCacheEntry // Mask+1 entries total
+}
+
+type InterfaceSwitchCacheEntry struct {
+	// type of source value (a *Type)
+	Typ uintptr
+	// case # to dispatch to
+	Case int
+	// itab to use for resulting case variable (a *runtime.itab)
+	Itab uintptr
+}
+
+func UseInterfaceSwitchCache(arch goarch.ArchFamilyType) bool {
+	// We need an atomic load instruction to make the cache multithreaded-safe.
+	// (AtomicLoadPtr needs to be implemented in cmd/compile/internal/ssa/_gen/ARCH.rules.)
+	switch arch {
+	case goarch.AMD64, goarch.ARM64, goarch.LOONG64, goarch.MIPS, goarch.MIPS64, goarch.PPC64, goarch.RISCV64, goarch.S390X:
+		return true
+	default:
+		return false
+	}
+}
+
+type TypeAssert struct {
+	Cache   *TypeAssertCache
+	Inter   *InterfaceType
+	CanFail bool
+}
+type TypeAssertCache struct {
+	Mask    uintptr
+	Entries [1]TypeAssertCacheEntry
+}
+type TypeAssertCacheEntry struct {
+	// type of source value (a *runtime._type)
+	Typ uintptr
+	// itab to use for result (a *runtime.itab)
+	// nil if CanFail is set and conversion would fail.
+	Itab uintptr
+}

go/src/internal/abi/symtab.go

@@ -0,0 +1,143 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package abi
+
+// PCLnTabMagic is the version at the start of the PC/line table.
+// This is the start of the .pclntab section, and is also runtime.pcHeader.
+// The magic numbers are chosen such that reading the value with
+// a different endianness does not result in the same value.
+// That lets us the magic number to determine the endianness.
+type PCLnTabMagic uint32
+
+const (
+	// Initial PCLnTabMagic value used in Go 1.2 through Go 1.15.
+	Go12PCLnTabMagic PCLnTabMagic = 0xfffffffb
+	// PCLnTabMagic value used in Go 1.16 through Go 1.17.
+	// Several fields added to header (CL 241598).
+	Go116PCLnTabMagic PCLnTabMagic = 0xfffffffa
+	// PCLnTabMagic value used in Go 1.18 through Go 1.19.
+	// Entry PC of func data changed from address to offset (CL 351463).
+	Go118PCLnTabMagic PCLnTabMagic = 0xfffffff0
+	// PCLnTabMagic value used in Go 1.20 and later.
+	// A ":" was added to generated symbol names (#37762).
+	Go120PCLnTabMagic PCLnTabMagic = 0xfffffff1
+
+	// CurrentPCLnTabMagic is the value emitted by the current toolchain.
+	// This is written by the linker to the pcHeader and read by the
+	// runtime and debug/gosym (and external tools like Delve).
+	//
+	// Change this value when updating the pclntab version.
+	// Changing this exported value is OK because is an
+	// internal package.
+	CurrentPCLnTabMagic = Go120PCLnTabMagic
+)
+
+// A FuncFlag records bits about a function, passed to the runtime.
+type FuncFlag uint8
+
+const (
+	// FuncFlagTopFrame indicates a function that appears at the top of its stack.
+	// The traceback routine stop at such a function and consider that a
+	// successful, complete traversal of the stack.
+	// Examples of TopFrame functions include goexit, which appears
+	// at the top of a user goroutine stack, and mstart, which appears
+	// at the top of a system goroutine stack.
+	FuncFlagTopFrame FuncFlag = 1 << iota
+
+	// FuncFlagSPWrite indicates a function that writes an arbitrary value to SP
+	// (any write other than adding or subtracting a constant amount).
+	// The traceback routines cannot encode such changes into the
+	// pcsp tables, so the function traceback cannot safely unwind past
+	// SPWrite functions. Stopping at an SPWrite function is considered
+	// to be an incomplete unwinding of the stack. In certain contexts
+	// (in particular garbage collector stack scans) that is a fatal error.
+	FuncFlagSPWrite
+
+	// FuncFlagAsm indicates that a function was implemented in assembly.
+	FuncFlagAsm
+)
+
+// A FuncID identifies particular functions that need to be treated
+// specially by the runtime.
+// Note that in some situations involving plugins, there may be multiple
+// copies of a particular special runtime function.
+type FuncID uint8
+
+const (
+	// If you add a FuncID, you probably also want to add an entry to the map in
+	// ../../cmd/internal/objabi/funcid.go
+
+	FuncIDNormal FuncID = iota // not a special function
+	FuncID_abort
+	FuncID_asmcgocall
+	FuncID_asyncPreempt
+	FuncID_cgocallback
+	FuncID_corostart
+	FuncID_debugCallV2
+	FuncID_gcBgMarkWorker
+	FuncID_goexit
+	FuncID_gogo
+	FuncID_gopanic
+	FuncID_handleAsyncEvent
+	FuncID_mcall
+	FuncID_morestack
+	FuncID_mstart
+	FuncID_panicwrap
+	FuncID_rt0_go
+	FuncID_runtime_main
+	FuncID_runFinalizers
+	FuncID_runCleanups
+	FuncID_sigpanic
+	FuncID_systemstack
+	FuncID_systemstack_switch
+	FuncIDWrapper // any autogenerated code (hash/eq algorithms, method wrappers, etc.)
+)
+
+// ArgsSizeUnknown is set in Func.argsize to mark all functions
+// whose argument size is unknown (C vararg functions, and
+// assembly code without an explicit specification).
+// This value is generated by the compiler, assembler, or linker.
+const ArgsSizeUnknown = -0x80000000
+
+// IDs for PCDATA and FUNCDATA tables in Go binaries.
+//
+// These must agree with ../../../runtime/funcdata.h.
+const (
+	PCDATA_UnsafePoint   = 0
+	PCDATA_StackMapIndex = 1
+	PCDATA_InlTreeIndex  = 2
+	PCDATA_ArgLiveIndex  = 3
+	PCDATA_PanicBounds   = 4
+
+	FUNCDATA_ArgsPointerMaps    = 0
+	FUNCDATA_LocalsPointerMaps  = 1
+	FUNCDATA_StackObjects       = 2
+	FUNCDATA_InlTree            = 3
+	FUNCDATA_OpenCodedDeferInfo = 4
+	FUNCDATA_ArgInfo            = 5
+	FUNCDATA_ArgLiveInfo        = 6
+	FUNCDATA_WrapInfo           = 7
+)
+
+// Special values for the PCDATA_UnsafePoint table.
+const (
+	UnsafePointSafe   = -1 // Safe for async preemption
+	UnsafePointUnsafe = -2 // Unsafe for async preemption
+
+	// UnsafePointRestart1(2) apply on a sequence of instructions, within
+	// which if an async preemption happens, we should back off the PC
+	// to the start of the sequence when resuming.
+	// We need two so we can distinguish the start/end of the sequence
+	// in case that two sequences are next to each other.
+	UnsafePointRestart1 = -3
+	UnsafePointRestart2 = -4
+
+	// Like UnsafePointRestart1, but back to function entry if async preempted.
+	UnsafePointRestartAtEntry = -5
+)
+
+const MINFUNC = 16 // minimum size for a function
+
+const FuncTabBucketSize = 256 * MINFUNC // size of bucket in the pc->func lookup table

go/src/internal/abi/type.go

@@ -0,0 +1,777 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package abi
+
+import (
+	"unsafe"
+)
+
+// Type is the runtime representation of a Go type.
+//
+// Be careful about accessing this type at build time, as the version
+// of this type in the compiler/linker may not have the same layout
+// as the version in the target binary, due to pointer width
+// differences and any experiments. Use cmd/compile/internal/rttype
+// or the functions in compiletype.go to access this type instead.
+// (TODO: this admonition applies to every type in this package.
+// Put it in some shared location?)
+type Type struct {
+	Size_       uintptr
+	PtrBytes    uintptr // number of (prefix) bytes in the type that can contain pointers
+	Hash        uint32  // hash of type; avoids computation in hash tables
+	TFlag       TFlag   // extra type information flags
+	Align_      uint8   // alignment of variable with this type
+	FieldAlign_ uint8   // alignment of struct field with this type
+	Kind_       Kind    // what kind of type this is (string, int, ...)
+	// function for comparing objects of this type
+	// (ptr to object A, ptr to object B) -> ==?
+	Equal func(unsafe.Pointer, unsafe.Pointer) bool
+	// GCData stores the GC type data for the garbage collector.
+	// Normally, GCData points to a bitmask that describes the
+	// ptr/nonptr fields of the type. The bitmask will have at
+	// least PtrBytes/ptrSize bits.
+	// If the TFlagGCMaskOnDemand bit is set, GCData is instead a
+	// **byte and the pointer to the bitmask is one dereference away.
+	// The runtime will build the bitmask if needed.
+	// (See runtime/type.go:getGCMask.)
+	// Note: multiple types may have the same value of GCData,
+	// including when TFlagGCMaskOnDemand is set. The types will, of course,
+	// have the same pointer layout (but not necessarily the same size).
+	GCData    *byte
+	Str       NameOff // string form
+	PtrToThis TypeOff // type for pointer to this type, may be zero
+}
+
+// A Kind represents the specific kind of type that a Type represents.
+// The zero Kind is not a valid kind.
+type Kind uint8
+
+const (
+	Invalid Kind = iota
+	Bool
+	Int
+	Int8
+	Int16
+	Int32
+	Int64
+	Uint
+	Uint8
+	Uint16
+	Uint32
+	Uint64
+	Uintptr
+	Float32
+	Float64
+	Complex64
+	Complex128
+	Array
+	Chan
+	Func
+	Interface
+	Map
+	Pointer
+	Slice
+	String
+	Struct
+	UnsafePointer
+)
+
+// TFlag is used by a Type to signal what extra type information is
+// available in the memory directly following the Type value.
+type TFlag uint8
+
+const (
+	// TFlagUncommon means that there is a data with a type, UncommonType,
+	// just beyond the shared-per-type common data.  That is, the data
+	// for struct types will store their UncommonType at one offset, the
+	// data for interface types will store their UncommonType at a different
+	// offset.  UncommonType is always accessed via a pointer that is computed
+	// using trust-us-we-are-the-implementors pointer arithmetic.
+	//
+	// For example, if t.Kind() == Struct and t.tflag&TFlagUncommon != 0,
+	// then t has UncommonType data and it can be accessed as:
+	//
+	//	type structTypeUncommon struct {
+	//		structType
+	//		u UncommonType
+	//	}
+	//	u := &(*structTypeUncommon)(unsafe.Pointer(t)).u
+	TFlagUncommon TFlag = 1 << 0
+
+	// TFlagExtraStar means the name in the str field has an
+	// extraneous '*' prefix. This is because for most types T in
+	// a program, the type *T also exists and reusing the str data
+	// saves binary size.
+	TFlagExtraStar TFlag = 1 << 1
+
+	// TFlagNamed means the type has a name.
+	TFlagNamed TFlag = 1 << 2
+
+	// TFlagRegularMemory means that equal and hash functions can treat
+	// this type as a single region of t.size bytes.
+	TFlagRegularMemory TFlag = 1 << 3
+
+	// TFlagGCMaskOnDemand means that the GC pointer bitmask will be
+	// computed on demand at runtime instead of being precomputed at
+	// compile time. If this flag is set, the GCData field effectively
+	// has type **byte instead of *byte. The runtime will store a
+	// pointer to the GC pointer bitmask in *GCData.
+	TFlagGCMaskOnDemand TFlag = 1 << 4
+
+	// TFlagDirectIface means that a value of this type is stored directly
+	// in the data field of an interface, instead of indirectly.
+	// This flag is just a cached computation of Size_ == PtrBytes == goarch.PtrSize.
+	TFlagDirectIface TFlag = 1 << 5
+
+	// Leaving this breadcrumb behind for dlv. It should not be used, and no
+	// Kind should be big enough to set this bit.
+	KindDirectIface Kind = 1 << 5
+)
+
+// NameOff is the offset to a name from moduledata.types.  See resolveNameOff in runtime.
+type NameOff int32
+
+// TypeOff is the offset to a type from moduledata.types.  See resolveTypeOff in runtime.
+type TypeOff int32
+
+// TextOff is an offset from the top of a text section.  See (rtype).textOff in runtime.
+type TextOff int32
+
+// String returns the name of k.
+func (k Kind) String() string {
+	if int(k) < len(kindNames) {
+		return kindNames[k]
+	}
+	return kindNames[0]
+}
+
+var kindNames = []string{
+	Invalid:       "invalid",
+	Bool:          "bool",
+	Int:           "int",
+	Int8:          "int8",
+	Int16:         "int16",
+	Int32:         "int32",
+	Int64:         "int64",
+	Uint:          "uint",
+	Uint8:         "uint8",
+	Uint16:        "uint16",
+	Uint32:        "uint32",
+	Uint64:        "uint64",
+	Uintptr:       "uintptr",
+	Float32:       "float32",
+	Float64:       "float64",
+	Complex64:     "complex64",
+	Complex128:    "complex128",
+	Array:         "array",
+	Chan:          "chan",
+	Func:          "func",
+	Interface:     "interface",
+	Map:           "map",
+	Pointer:       "ptr",
+	Slice:         "slice",
+	String:        "string",
+	Struct:        "struct",
+	UnsafePointer: "unsafe.Pointer",
+}
+
+// TypeOf returns the abi.Type of some value.
+func TypeOf(a any) *Type {
+	eface := *(*EmptyInterface)(unsafe.Pointer(&a))
+	// Types are either static (for compiler-created types) or
+	// heap-allocated but always reachable (for reflection-created
+	// types, held in the central map). So there is no need to
+	// escape types. noescape here help avoid unnecessary escape
+	// of v.
+	return (*Type)(NoEscape(unsafe.Pointer(eface.Type)))
+}
+
+// TypeFor returns the abi.Type for a type parameter.
+func TypeFor[T any]() *Type {
+	return (*PtrType)(unsafe.Pointer(TypeOf((*T)(nil)))).Elem
+}
+
+func (t *Type) Kind() Kind { return t.Kind_ }
+
+func (t *Type) HasName() bool {
+	return t.TFlag&TFlagNamed != 0
+}
+
+// Pointers reports whether t contains pointers.
+func (t *Type) Pointers() bool { return t.PtrBytes != 0 }
+
+// IsDirectIface reports whether t is stored directly in an interface value.
+func (t *Type) IsDirectIface() bool {
+	return t.TFlag&TFlagDirectIface != 0
+}
+
+func (t *Type) GcSlice(begin, end uintptr) []byte {
+	if t.TFlag&TFlagGCMaskOnDemand != 0 {
+		panic("GcSlice can't handle on-demand gcdata types")
+	}
+	return unsafe.Slice(t.GCData, int(end))[begin:]
+}
+
+// Method on non-interface type
+type Method struct {
+	Name NameOff // name of method
+	Mtyp TypeOff // method type (without receiver)
+	Ifn  TextOff // fn used in interface call (one-word receiver)
+	Tfn  TextOff // fn used for normal method call
+}
+
+// UncommonType is present only for defined types or types with methods
+// (if T is a defined type, the uncommonTypes for T and *T have methods).
+// Using a pointer to this struct reduces the overall size required
+// to describe a non-defined type with no methods.
+type UncommonType struct {
+	PkgPath NameOff // import path; empty for built-in types like int, string
+	Mcount  uint16  // number of methods
+	Xcount  uint16  // number of exported methods
+	Moff    uint32  // offset from this uncommontype to [mcount]Method
+	_       uint32  // unused
+}
+
+func (t *UncommonType) Methods() []Method {
+	if t.Mcount == 0 {
+		return nil
+	}
+	return (*[1 << 16]Method)(addChecked(unsafe.Pointer(t), uintptr(t.Moff), "t.mcount > 0"))[:t.Mcount:t.Mcount]
+}
+
+func (t *UncommonType) ExportedMethods() []Method {
+	if t.Xcount == 0 {
+		return nil
+	}
+	return (*[1 << 16]Method)(addChecked(unsafe.Pointer(t), uintptr(t.Moff), "t.xcount > 0"))[:t.Xcount:t.Xcount]
+}
+
+// addChecked returns p+x.
+//
+// The whySafe string is ignored, so that the function still inlines
+// as efficiently as p+x, but all call sites should use the string to
+// record why the addition is safe, which is to say why the addition
+// does not cause x to advance to the very end of p's allocation
+// and therefore point incorrectly at the next block in memory.
+func addChecked(p unsafe.Pointer, x uintptr, whySafe string) unsafe.Pointer {
+	return unsafe.Pointer(uintptr(p) + x)
+}
+
+// Imethod represents a method on an interface type
+type Imethod struct {
+	Name NameOff // name of method
+	Typ  TypeOff // .(*FuncType) underneath
+}
+
+// ArrayType represents a fixed array type.
+type ArrayType struct {
+	Type
+	Elem  *Type // array element type
+	Slice *Type // slice type
+	Len   uintptr
+}
+
+// Len returns the length of t if t is an array type, otherwise 0
+func (t *Type) Len() int {
+	if t.Kind() == Array {
+		return int((*ArrayType)(unsafe.Pointer(t)).Len)
+	}
+	return 0
+}
+
+func (t *Type) Common() *Type {
+	return t
+}
+
+type ChanDir int
+
+const (
+	RecvDir    ChanDir = 1 << iota         // <-chan
+	SendDir                                // chan<-
+	BothDir            = RecvDir | SendDir // chan
+	InvalidDir ChanDir = 0
+)
+
+// ChanType represents a channel type
+type ChanType struct {
+	Type
+	Elem *Type
+	Dir  ChanDir
+}
+
+type structTypeUncommon struct {
+	StructType
+	u UncommonType
+}
+
+// ChanDir returns the direction of t if t is a channel type, otherwise InvalidDir (0).
+func (t *Type) ChanDir() ChanDir {
+	if t.Kind() == Chan {
+		ch := (*ChanType)(unsafe.Pointer(t))
+		return ch.Dir
+	}
+	return InvalidDir
+}
+
+// Uncommon returns a pointer to T's "uncommon" data if there is any, otherwise nil
+func (t *Type) Uncommon() *UncommonType {
+	if t.TFlag&TFlagUncommon == 0 {
+		return nil
+	}
+	switch t.Kind() {
+	case Struct:
+		return &(*structTypeUncommon)(unsafe.Pointer(t)).u
+	case Pointer:
+		type u struct {
+			PtrType
+			u UncommonType
+		}
+		return &(*u)(unsafe.Pointer(t)).u
+	case Func:
+		type u struct {
+			FuncType
+			u UncommonType
+		}
+		return &(*u)(unsafe.Pointer(t)).u
+	case Slice:
+		type u struct {
+			SliceType
+			u UncommonType
+		}
+		return &(*u)(unsafe.Pointer(t)).u
+	case Array:
+		type u struct {
+			ArrayType
+			u UncommonType
+		}
+		return &(*u)(unsafe.Pointer(t)).u
+	case Chan:
+		type u struct {
+			ChanType
+			u UncommonType
+		}
+		return &(*u)(unsafe.Pointer(t)).u
+	case Map:
+		type u struct {
+			MapType
+			u UncommonType
+		}
+		return &(*u)(unsafe.Pointer(t)).u
+	case Interface:
+		type u struct {
+			InterfaceType
+			u UncommonType
+		}
+		return &(*u)(unsafe.Pointer(t)).u
+	default:
+		type u struct {
+			Type
+			u UncommonType
+		}
+		return &(*u)(unsafe.Pointer(t)).u
+	}
+}
+
+// Elem returns the element type for t if t is an array, channel, map, pointer, or slice, otherwise nil.
+func (t *Type) Elem() *Type {
+	switch t.Kind() {
+	case Array:
+		tt := (*ArrayType)(unsafe.Pointer(t))
+		return tt.Elem
+	case Chan:
+		tt := (*ChanType)(unsafe.Pointer(t))
+		return tt.Elem
+	case Map:
+		tt := (*MapType)(unsafe.Pointer(t))
+		return tt.Elem
+	case Pointer:
+		tt := (*PtrType)(unsafe.Pointer(t))
+		return tt.Elem
+	case Slice:
+		tt := (*SliceType)(unsafe.Pointer(t))
+		return tt.Elem
+	}
+	return nil
+}
+
+// StructType returns t cast to a *StructType, or nil if its tag does not match.
+func (t *Type) StructType() *StructType {
+	if t.Kind() != Struct {
+		return nil
+	}
+	return (*StructType)(unsafe.Pointer(t))
+}
+
+// MapType returns t cast to a *MapType, or nil if its tag does not match.
+func (t *Type) MapType() *MapType {
+	if t.Kind() != Map {
+		return nil
+	}
+	return (*MapType)(unsafe.Pointer(t))
+}
+
+// ArrayType returns t cast to a *ArrayType, or nil if its tag does not match.
+func (t *Type) ArrayType() *ArrayType {
+	if t.Kind() != Array {
+		return nil
+	}
+	return (*ArrayType)(unsafe.Pointer(t))
+}
+
+// FuncType returns t cast to a *FuncType, or nil if its tag does not match.
+func (t *Type) FuncType() *FuncType {
+	if t.Kind() != Func {
+		return nil
+	}
+	return (*FuncType)(unsafe.Pointer(t))
+}
+
+// InterfaceType returns t cast to a *InterfaceType, or nil if its tag does not match.
+func (t *Type) InterfaceType() *InterfaceType {
+	if t.Kind() != Interface {
+		return nil
+	}
+	return (*InterfaceType)(unsafe.Pointer(t))
+}
+
+// Size returns the size of data with type t.
+func (t *Type) Size() uintptr { return t.Size_ }
+
+// Align returns the alignment of data with type t.
+func (t *Type) Align() int { return int(t.Align_) }
+
+func (t *Type) FieldAlign() int { return int(t.FieldAlign_) }
+
+type InterfaceType struct {
+	Type
+	PkgPath Name      // import path
+	Methods []Imethod // sorted by hash
+}
+
+func (t *Type) ExportedMethods() []Method {
+	ut := t.Uncommon()
+	if ut == nil {
+		return nil
+	}
+	return ut.ExportedMethods()
+}
+
+func (t *Type) NumMethod() int {
+	if t.Kind() == Interface {
+		tt := (*InterfaceType)(unsafe.Pointer(t))
+		return tt.NumMethod()
+	}
+	return len(t.ExportedMethods())
+}
+
+// NumMethod returns the number of interface methods in the type's method set.
+func (t *InterfaceType) NumMethod() int { return len(t.Methods) }
+
+func (t *Type) Key() *Type {
+	if t.Kind() == Map {
+		return (*MapType)(unsafe.Pointer(t)).Key
+	}
+	return nil
+}
+
+type SliceType struct {
+	Type
+	Elem *Type // slice element type
+}
+
+// FuncType represents a function type.
+//
+// A *Type for each in and out parameter is stored in an array that
+// directly follows the funcType (and possibly its uncommonType). So
+// a function type with one method, one input, and one output is:
+//
+//	struct {
+//		funcType
+//		uncommonType
+//		[2]*rtype    // [0] is in, [1] is out
+//	}
+type FuncType struct {
+	Type
+	InCount  uint16
+	OutCount uint16 // top bit is set if last input parameter is ...
+}
+
+func (t *FuncType) In(i int) *Type {
+	return t.InSlice()[i]
+}
+
+func (t *FuncType) NumIn() int {
+	return int(t.InCount)
+}
+
+func (t *FuncType) NumOut() int {
+	return int(t.OutCount & (1<<15 - 1))
+}
+
+func (t *FuncType) Out(i int) *Type {
+	return (t.OutSlice()[i])
+}
+
+func (t *FuncType) InSlice() []*Type {
+	uadd := unsafe.Sizeof(*t)
+	if t.TFlag&TFlagUncommon != 0 {
+		uadd += unsafe.Sizeof(UncommonType{})
+	}
+	if t.InCount == 0 {
+		return nil
+	}
+	return (*[1 << 16]*Type)(addChecked(unsafe.Pointer(t), uadd, "t.inCount > 0"))[:t.InCount:t.InCount]
+}
+func (t *FuncType) OutSlice() []*Type {
+	outCount := uint16(t.NumOut())
+	if outCount == 0 {
+		return nil
+	}
+	uadd := unsafe.Sizeof(*t)
+	if t.TFlag&TFlagUncommon != 0 {
+		uadd += unsafe.Sizeof(UncommonType{})
+	}
+	return (*[1 << 17]*Type)(addChecked(unsafe.Pointer(t), uadd, "outCount > 0"))[t.InCount : t.InCount+outCount : t.InCount+outCount]
+}
+
+func (t *FuncType) IsVariadic() bool {
+	return t.OutCount&(1<<15) != 0
+}
+
+type PtrType struct {
+	Type
+	Elem *Type // pointer element (pointed at) type
+}
+
+type StructField struct {
+	Name   Name    // name is always non-empty
+	Typ    *Type   // type of field
+	Offset uintptr // byte offset of field
+}
+
+func (f *StructField) Embedded() bool {
+	return f.Name.IsEmbedded()
+}
+
+type StructType struct {
+	Type
+	PkgPath Name
+	Fields  []StructField
+}
+
+// Name is an encoded type Name with optional extra data.
+//
+// The first byte is a bit field containing:
+//
+//	1<<0 the name is exported
+//	1<<1 tag data follows the name
+//	1<<2 pkgPath nameOff follows the name and tag
+//	1<<3 the name is of an embedded (a.k.a. anonymous) field
+//
+// Following that, there is a varint-encoded length of the name,
+// followed by the name itself.
+//
+// If tag data is present, it also has a varint-encoded length
+// followed by the tag itself.
+//
+// If the import path follows, then 4 bytes at the end of
+// the data form a nameOff. The import path is only set for concrete
+// methods that are defined in a different package than their type.
+//
+// If a name starts with "*", then the exported bit represents
+// whether the pointed to type is exported.
+//
+// Note: this encoding must match here and in:
+//   cmd/compile/internal/reflectdata/reflect.go
+//   cmd/link/internal/ld/decodesym.go
+
+type Name struct {
+	Bytes *byte
+}
+
+// DataChecked does pointer arithmetic on n's Bytes, and that arithmetic is asserted to
+// be safe for the reason in whySafe (which can appear in a backtrace, etc.)
+func (n Name) DataChecked(off int, whySafe string) *byte {
+	return (*byte)(addChecked(unsafe.Pointer(n.Bytes), uintptr(off), whySafe))
+}
+
+// Data does pointer arithmetic on n's Bytes, and that arithmetic is asserted to
+// be safe because the runtime made the call (other packages use DataChecked)
+func (n Name) Data(off int) *byte {
+	return (*byte)(addChecked(unsafe.Pointer(n.Bytes), uintptr(off), "the runtime doesn't need to give you a reason"))
+}
+
+// IsExported returns "is n exported?"
+func (n Name) IsExported() bool {
+	return (*n.Bytes)&(1<<0) != 0
+}
+
+// HasTag returns true iff there is tag data following this name
+func (n Name) HasTag() bool {
+	return (*n.Bytes)&(1<<1) != 0
+}
+
+// IsEmbedded returns true iff n is embedded (an anonymous field).
+func (n Name) IsEmbedded() bool {
+	return (*n.Bytes)&(1<<3) != 0
+}
+
+// ReadVarint parses a varint as encoded by encoding/binary.
+// It returns the number of encoded bytes and the encoded value.
+func (n Name) ReadVarint(off int) (int, int) {
+	v := 0
+	for i := 0; ; i++ {
+		x := *n.DataChecked(off+i, "read varint")
+		v += int(x&0x7f) << (7 * i)
+		if x&0x80 == 0 {
+			return i + 1, v
+		}
+	}
+}
+
+// IsBlank indicates whether n is "_".
+func (n Name) IsBlank() bool {
+	if n.Bytes == nil {
+		return false
+	}
+	_, l := n.ReadVarint(1)
+	return l == 1 && *n.Data(2) == '_'
+}
+
+// writeVarint writes n to buf in varint form. Returns the
+// number of bytes written. n must be nonnegative.
+// Writes at most 10 bytes.
+func writeVarint(buf []byte, n int) int {
+	for i := 0; ; i++ {
+		b := byte(n & 0x7f)
+		n >>= 7
+		if n == 0 {
+			buf[i] = b
+			return i + 1
+		}
+		buf[i] = b | 0x80
+	}
+}
+
+// Name returns the name of n, or empty if it does not actually have a name.
+func (n Name) Name() string {
+	if n.Bytes == nil {
+		return ""
+	}
+	i, l := n.ReadVarint(1)
+	return unsafe.String(n.DataChecked(1+i, "non-empty string"), l)
+}
+
+// Tag returns the tag string for n, or empty if there is none.
+func (n Name) Tag() string {
+	if !n.HasTag() {
+		return ""
+	}
+	i, l := n.ReadVarint(1)
+	i2, l2 := n.ReadVarint(1 + i + l)
+	return unsafe.String(n.DataChecked(1+i+l+i2, "non-empty string"), l2)
+}
+
+func NewName(n, tag string, exported, embedded bool) Name {
+	if len(n) >= 1<<29 {
+		panic("abi.NewName: name too long: " + n[:1024] + "...")
+	}
+	if len(tag) >= 1<<29 {
+		panic("abi.NewName: tag too long: " + tag[:1024] + "...")
+	}
+	var nameLen [10]byte
+	var tagLen [10]byte
+	nameLenLen := writeVarint(nameLen[:], len(n))
+	tagLenLen := writeVarint(tagLen[:], len(tag))
+
+	var bits byte
+	l := 1 + nameLenLen + len(n)
+	if exported {
+		bits |= 1 << 0
+	}
+	if len(tag) > 0 {
+		l += tagLenLen + len(tag)
+		bits |= 1 << 1
+	}
+	if embedded {
+		bits |= 1 << 3
+	}
+
+	b := make([]byte, l)
+	b[0] = bits
+	copy(b[1:], nameLen[:nameLenLen])
+	copy(b[1+nameLenLen:], n)
+	if len(tag) > 0 {
+		tb := b[1+nameLenLen+len(n):]
+		copy(tb, tagLen[:tagLenLen])
+		copy(tb[tagLenLen:], tag)
+	}
+
+	return Name{Bytes: &b[0]}
+}
+
+const (
+	TraceArgsLimit    = 10 // print no more than 10 args/components
+	TraceArgsMaxDepth = 5  // no more than 5 layers of nesting
+
+	// maxLen is a (conservative) upper bound of the byte stream length. For
+	// each arg/component, it has no more than 2 bytes of data (size, offset),
+	// and no more than one {, }, ... at each level (it cannot have both the
+	// data and ... unless it is the last one, just be conservative). Plus 1
+	// for _endSeq.
+	TraceArgsMaxLen = (TraceArgsMaxDepth*3+2)*TraceArgsLimit + 1
+)
+
+// Populate the data.
+// The data is a stream of bytes, which contains the offsets and sizes of the
+// non-aggregate arguments or non-aggregate fields/elements of aggregate-typed
+// arguments, along with special "operators". Specifically,
+//   - for each non-aggregate arg/field/element, its offset from FP (1 byte) and
+//     size (1 byte)
+//   - special operators:
+//   - 0xff - end of sequence
+//   - 0xfe - print { (at the start of an aggregate-typed argument)
+//   - 0xfd - print } (at the end of an aggregate-typed argument)
+//   - 0xfc - print ... (more args/fields/elements)
+//   - 0xfb - print _ (offset too large)
+const (
+	TraceArgsEndSeq         = 0xff
+	TraceArgsStartAgg       = 0xfe
+	TraceArgsEndAgg         = 0xfd
+	TraceArgsDotdotdot      = 0xfc
+	TraceArgsOffsetTooLarge = 0xfb
+	TraceArgsSpecial        = 0xf0 // above this are operators, below this are ordinary offsets
+)
+
+// MaxPtrmaskBytes is the maximum length of a GC ptrmask bitmap,
+// which holds 1-bit entries describing where pointers are in a given type.
+// Above this length, the GC information is recorded as a GC program,
+// which can express repetition compactly. In either form, the
+// information is used by the runtime to initialize the heap bitmap,
+// and for large types (like 128 or more words), they are roughly the
+// same speed. GC programs are never much larger and often more
+// compact. (If large arrays are involved, they can be arbitrarily
+// more compact.)
+//
+// The cutoff must be large enough that any allocation large enough to
+// use a GC program is large enough that it does not share heap bitmap
+// bytes with any other objects, allowing the GC program execution to
+// assume an aligned start and not use atomic operations. In the current
+// runtime, this means all malloc size classes larger than the cutoff must
+// be multiples of four words. On 32-bit systems that's 16 bytes, and
+// all size classes >= 16 bytes are 16-byte aligned, so no real constraint.
+// On 64-bit systems, that's 32 bytes, and 32-byte alignment is guaranteed
+// for size classes >= 256 bytes. On a 64-bit system, 256 bytes allocated
+// is 32 pointers, the bits for which fit in 4 bytes. So MaxPtrmaskBytes
+// must be >= 4.
+//
+// We used to use 16 because the GC programs do have some constant overhead
+// to get started, and processing 128 pointers seems to be enough to
+// amortize that overhead well.
+//
+// To make sure that the runtime's chansend can call typeBitsBulkBarrier,
+// we raised the limit to 2048, so that even 32-bit systems are guaranteed to
+// use bitmaps for objects up to 64 kB in size.
+const MaxPtrmaskBytes = 2048

go/src/internal/asan/asan.go

@@ -0,0 +1,19 @@
+// Copyright 2024 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build asan
+
+package asan
+
+import (
+	"unsafe"
+)
+
+const Enabled = true
+
+//go:linkname Read runtime.asanread
+func Read(addr unsafe.Pointer, len uintptr)
+
+//go:linkname Write runtime.asanwrite
+func Write(addr unsafe.Pointer, len uintptr)

go/src/internal/asan/doc.go

@@ -0,0 +1,10 @@
+// Copyright 2024 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package asan contains helper functions for manually instrumenting
+// code for the address sanitizer.
+// The runtime package intentionally exports these functions only in the
+// asan build; this package exports them unconditionally but without the
+// "asan" build tag they are no-ops.
+package asan

go/src/internal/asan/noasan.go

@@ -0,0 +1,17 @@
+// Copyright 2024 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build !asan
+
+package asan
+
+import (
+	"unsafe"
+)
+
+const Enabled = false
+
+func Read(addr unsafe.Pointer, len uintptr) {}
+
+func Write(addr unsafe.Pointer, len uintptr) {}

go/src/internal/bisect/bisect.go

@@ -0,0 +1,778 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package bisect can be used by compilers and other programs
+// to serve as a target for the bisect debugging tool.
+// See [golang.org/x/tools/cmd/bisect] for details about using the tool.
+//
+// To be a bisect target, allowing bisect to help determine which of a set of independent
+// changes provokes a failure, a program needs to:
+//
+//  1. Define a way to accept a change pattern on its command line or in its environment.
+//     The most common mechanism is a command-line flag.
+//     The pattern can be passed to [New] to create a [Matcher], the compiled form of a pattern.
+//
+//  2. Assign each change a unique ID. One possibility is to use a sequence number,
+//     but the most common mechanism is to hash some kind of identifying information
+//     like the file and line number where the change might be applied.
+//     [Hash] hashes its arguments to compute an ID.
+//
+//  3. Enable each change that the pattern says should be enabled.
+//     The [Matcher.ShouldEnable] method answers this question for a given change ID.
+//
+//  4. Print a report identifying each change that the pattern says should be printed.
+//     The [Matcher.ShouldPrint] method answers this question for a given change ID.
+//     The report consists of one more lines on standard error or standard output
+//     that contain a “match marker”. [Marker] returns the match marker for a given ID.
+//     When bisect reports a change as causing the failure, it identifies the change
+//     by printing the report lines with the match marker removed.
+//
+// # Example Usage
+//
+// A program starts by defining how it receives the pattern. In this example, we will assume a flag.
+// The next step is to compile the pattern:
+//
+//	m, err := bisect.New(patternFlag)
+//	if err != nil {
+//		log.Fatal(err)
+//	}
+//
+// Then, each time a potential change is considered, the program computes
+// a change ID by hashing identifying information (source file and line, in this case)
+// and then calls m.ShouldPrint and m.ShouldEnable to decide whether to
+// print and enable the change, respectively. The two can return different values
+// depending on whether bisect is trying to find a minimal set of changes to
+// disable or to enable to provoke the failure.
+//
+// It is usually helpful to write a helper function that accepts the identifying information
+// and then takes care of hashing, printing, and reporting whether the identified change
+// should be enabled. For example, a helper for changes identified by a file and line number
+// would be:
+//
+//	func ShouldEnable(file string, line int) {
+//		h := bisect.Hash(file, line)
+//		if m.ShouldPrint(h) {
+//			fmt.Fprintf(os.Stderr, "%v %s:%d\n", bisect.Marker(h), file, line)
+//		}
+//		return m.ShouldEnable(h)
+//	}
+//
+// Finally, note that New returns a nil Matcher when there is no pattern,
+// meaning that the target is not running under bisect at all,
+// so all changes should be enabled and none should be printed.
+// In that common case, the computation of the hash can be avoided entirely
+// by checking for m == nil first:
+//
+//	func ShouldEnable(file string, line int) bool {
+//		if m == nil {
+//			return true
+//		}
+//		h := bisect.Hash(file, line)
+//		if m.ShouldPrint(h) {
+//			fmt.Fprintf(os.Stderr, "%v %s:%d\n", bisect.Marker(h), file, line)
+//		}
+//		return m.ShouldEnable(h)
+//	}
+//
+// When the identifying information is expensive to format, this code can call
+// [Matcher.MarkerOnly] to find out whether short report lines containing only the
+// marker are permitted for a given run. (Bisect permits such lines when it is
+// still exploring the space of possible changes and will not be showing the
+// output to the user.) If so, the client can choose to print only the marker:
+//
+//	func ShouldEnable(file string, line int) bool {
+//		if m == nil {
+//			return true
+//		}
+//		h := bisect.Hash(file, line)
+//		if m.ShouldPrint(h) {
+//			if m.MarkerOnly() {
+//				bisect.PrintMarker(os.Stderr, h)
+//			} else {
+//				fmt.Fprintf(os.Stderr, "%v %s:%d\n", bisect.Marker(h), file, line)
+//			}
+//		}
+//		return m.ShouldEnable(h)
+//	}
+//
+// This specific helper – deciding whether to enable a change identified by
+// file and line number and printing about the change when necessary – is
+// provided by the [Matcher.FileLine] method.
+//
+// Another common usage is deciding whether to make a change in a function
+// based on the caller's stack, to identify the specific calling contexts that the
+// change breaks. The [Matcher.Stack] method takes care of obtaining the stack,
+// printing it when necessary, and reporting whether to enable the change
+// based on that stack.
+//
+// # Pattern Syntax
+//
+// Patterns are generated by the bisect tool and interpreted by [New].
+// Users should not have to understand the patterns except when
+// debugging a target's bisect support or debugging the bisect tool itself.
+//
+// The pattern syntax selecting a change is a sequence of bit strings
+// separated by + and - operators. Each bit string denotes the set of
+// changes with IDs ending in those bits, + is set addition, - is set subtraction,
+// and the expression is evaluated in the usual left-to-right order.
+// The special binary number “y” denotes the set of all changes,
+// standing in for the empty bit string.
+// In the expression, all the + operators must appear before all the - operators.
+// A leading + adds to an empty set. A leading - subtracts from the set of all
+// possible suffixes.
+//
+// For example:
+//
+//   - “01+10” and “+01+10” both denote the set of changes
+//     with IDs ending with the bits 01 or 10.
+//
+//   - “01+10-1001” denotes the set of changes with IDs
+//     ending with the bits 01 or 10, but excluding those ending in 1001.
+//
+//   - “-01-1000” and “y-01-1000 both denote the set of all changes
+//     with IDs not ending in 01 nor 1000.
+//
+//   - “0+1-01+001” is not a valid pattern, because all the + operators do not
+//     appear before all the - operators.
+//
+// In the syntaxes described so far, the pattern specifies the changes to
+// enable and report. If a pattern is prefixed by a “!”, the meaning
+// changes: the pattern specifies the changes to DISABLE and report. This
+// mode of operation is needed when a program passes with all changes
+// enabled but fails with no changes enabled. In this case, bisect
+// searches for minimal sets of changes to disable.
+// Put another way, the leading “!” inverts the result from [Matcher.ShouldEnable]
+// but does not invert the result from [Matcher.ShouldPrint].
+//
+// As a convenience for manual debugging, “n” is an alias for “!y”,
+// meaning to disable and report all changes.
+//
+// Finally, a leading “v” in the pattern indicates that the reports will be shown
+// to the user of bisect to describe the changes involved in a failure.
+// At the API level, the leading “v” causes [Matcher.Visible] to return true.
+// See the next section for details.
+//
+// # Match Reports
+//
+// The target program must enable only those changed matched
+// by the pattern, and it must print a match report for each such change.
+// A match report consists of one or more lines of text that will be
+// printed by the bisect tool to describe a change implicated in causing
+// a failure. Each line in the report for a given change must contain a
+// match marker with that change ID, as returned by [Marker].
+// The markers are elided when displaying the lines to the user.
+//
+// A match marker has the form “[bisect-match 0x1234]” where
+// 0x1234 is the change ID in hexadecimal.
+// An alternate form is “[bisect-match 010101]”, giving the change ID in binary.
+//
+// When [Matcher.Visible] returns false, the match reports are only
+// being processed by bisect to learn the set of enabled changes,
+// not shown to the user, meaning that each report can be a match
+// marker on a line by itself, eliding the usual textual description.
+// When the textual description is expensive to compute,
+// checking [Matcher.Visible] can help the avoid that expense
+// in most runs.
+package bisect
+
+import (
+	"runtime"
+	"sync"
+	"sync/atomic"
+)
+
+// New creates and returns a new Matcher implementing the given pattern.
+// The pattern syntax is defined in the package doc comment.
+//
+// In addition to the pattern syntax syntax, New("") returns nil, nil.
+// The nil *Matcher is valid for use: it returns true from ShouldEnable
+// and false from ShouldPrint for all changes. Callers can avoid calling
+// [Hash], [Matcher.ShouldEnable], and [Matcher.ShouldPrint] entirely
+// when they recognize the nil Matcher.
+func New(pattern string) (*Matcher, error) {
+	if pattern == "" {
+		return nil, nil
+	}
+
+	m := new(Matcher)
+
+	p := pattern
+	// Special case for leading 'q' so that 'qn' quietly disables, e.g. fmahash=qn to disable fma
+	// Any instance of 'v' disables 'q'.
+	if len(p) > 0 && p[0] == 'q' {
+		m.quiet = true
+		p = p[1:]
+		if p == "" {
+			return nil, &parseError{"invalid pattern syntax: " + pattern}
+		}
+	}
+	// Allow multiple v, so that “bisect cmd vPATTERN” can force verbose all the time.
+	for len(p) > 0 && p[0] == 'v' {
+		m.verbose = true
+		m.quiet = false
+		p = p[1:]
+		if p == "" {
+			return nil, &parseError{"invalid pattern syntax: " + pattern}
+		}
+	}
+
+	// Allow multiple !, each negating the last, so that “bisect cmd !PATTERN” works
+	// even when bisect chooses to add its own !.
+	m.enable = true
+	for len(p) > 0 && p[0] == '!' {
+		m.enable = !m.enable
+		p = p[1:]
+		if p == "" {
+			return nil, &parseError{"invalid pattern syntax: " + pattern}
+		}
+	}
+
+	if p == "n" {
+		// n is an alias for !y.
+		m.enable = !m.enable
+		p = "y"
+	}
+
+	// Parse actual pattern syntax.
+	result := true
+	bits := uint64(0)
+	start := 0
+	wid := 1 // 1-bit (binary); sometimes 4-bit (hex)
+	for i := 0; i <= len(p); i++ {
+		// Imagine a trailing - at the end of the pattern to flush final suffix
+		c := byte('-')
+		if i < len(p) {
+			c = p[i]
+		}
+		if i == start && wid == 1 && c == 'x' { // leading x for hex
+			start = i + 1
+			wid = 4
+			continue
+		}
+		switch c {
+		default:
+			return nil, &parseError{"invalid pattern syntax: " + pattern}
+		case '2', '3', '4', '5', '6', '7', '8', '9':
+			if wid != 4 {
+				return nil, &parseError{"invalid pattern syntax: " + pattern}
+			}
+			fallthrough
+		case '0', '1':
+			bits <<= wid
+			bits |= uint64(c - '0')
+		case 'a', 'b', 'c', 'd', 'e', 'f', 'A', 'B', 'C', 'D', 'E', 'F':
+			if wid != 4 {
+				return nil, &parseError{"invalid pattern syntax: " + pattern}
+			}
+			bits <<= 4
+			bits |= uint64(c&^0x20 - 'A' + 10)
+		case 'y':
+			if i+1 < len(p) && (p[i+1] == '0' || p[i+1] == '1') {
+				return nil, &parseError{"invalid pattern syntax: " + pattern}
+			}
+			bits = 0
+		case '+', '-':
+			if c == '+' && result == false {
+				// Have already seen a -. Should be - from here on.
+				return nil, &parseError{"invalid pattern syntax (+ after -): " + pattern}
+			}
+			if i > 0 {
+				n := (i - start) * wid
+				if n > 64 {
+					return nil, &parseError{"pattern bits too long: " + pattern}
+				}
+				if n <= 0 {
+					return nil, &parseError{"invalid pattern syntax: " + pattern}
+				}
+				if p[start] == 'y' {
+					n = 0
+				}
+				mask := uint64(1)<<n - 1
+				m.list = append(m.list, cond{mask, bits, result})
+			} else if c == '-' {
+				// leading - subtracts from complete set
+				m.list = append(m.list, cond{0, 0, true})
+			}
+			bits = 0
+			result = c == '+'
+			start = i + 1
+			wid = 1
+		}
+	}
+	return m, nil
+}
+
+// A Matcher is the parsed, compiled form of a PATTERN string.
+// The nil *Matcher is valid: it has all changes enabled but none reported.
+type Matcher struct {
+	verbose bool   // annotate reporting with human-helpful information
+	quiet   bool   // disables all reporting.  reset if verbose is true. use case is -d=fmahash=qn
+	enable  bool   // when true, list is for “enable and report” (when false, “disable and report”)
+	list    []cond // conditions; later ones win over earlier ones
+	dedup   atomic.Pointer[dedup]
+}
+
+// A cond is a single condition in the matcher.
+// Given an input id, if id&mask == bits, return the result.
+type cond struct {
+	mask   uint64
+	bits   uint64
+	result bool
+}
+
+// MarkerOnly reports whether it is okay to print only the marker for
+// a given change, omitting the identifying information.
+// MarkerOnly returns true when bisect is using the printed reports
+// only for an intermediate search step, not for showing to users.
+func (m *Matcher) MarkerOnly() bool {
+	return !m.verbose
+}
+
+// ShouldEnable reports whether the change with the given id should be enabled.
+func (m *Matcher) ShouldEnable(id uint64) bool {
+	if m == nil {
+		return true
+	}
+	return m.matchResult(id) == m.enable
+}
+
+// ShouldPrint reports whether to print identifying information about the change with the given id.
+func (m *Matcher) ShouldPrint(id uint64) bool {
+	if m == nil || m.quiet {
+		return false
+	}
+	return m.matchResult(id)
+}
+
+// matchResult returns the result from the first condition that matches id.
+func (m *Matcher) matchResult(id uint64) bool {
+	for i := len(m.list) - 1; i >= 0; i-- {
+		c := &m.list[i]
+		if id&c.mask == c.bits {
+			return c.result
+		}
+	}
+	return false
+}
+
+// FileLine reports whether the change identified by file and line should be enabled.
+// If the change should be printed, FileLine prints a one-line report to w.
+func (m *Matcher) FileLine(w Writer, file string, line int) bool {
+	if m == nil {
+		return true
+	}
+	return m.fileLine(w, file, line)
+}
+
+// fileLine does the real work for FileLine.
+// This lets FileLine's body handle m == nil and potentially be inlined.
+func (m *Matcher) fileLine(w Writer, file string, line int) bool {
+	h := Hash(file, line)
+	if m.ShouldPrint(h) {
+		if m.MarkerOnly() {
+			PrintMarker(w, h)
+		} else {
+			printFileLine(w, h, file, line)
+		}
+	}
+	return m.ShouldEnable(h)
+}
+
+// printFileLine prints a non-marker-only report for file:line to w.
+func printFileLine(w Writer, h uint64, file string, line int) error {
+	const markerLen = 40 // overestimate
+	b := make([]byte, 0, markerLen+len(file)+24)
+	b = AppendMarker(b, h)
+	b = appendFileLine(b, file, line)
+	b = append(b, '\n')
+	_, err := w.Write(b)
+	return err
+}
+
+// appendFileLine appends file:line to dst, returning the extended slice.
+func appendFileLine(dst []byte, file string, line int) []byte {
+	dst = append(dst, file...)
+	dst = append(dst, ':')
+	u := uint(line)
+	if line < 0 {
+		dst = append(dst, '-')
+		u = -u
+	}
+	var buf [24]byte
+	i := len(buf)
+	for i == len(buf) || u > 0 {
+		i--
+		buf[i] = '0' + byte(u%10)
+		u /= 10
+	}
+	dst = append(dst, buf[i:]...)
+	return dst
+}
+
+// MatchStack assigns the current call stack a change ID.
+// If the stack should be printed, MatchStack prints it.
+// Then MatchStack reports whether a change at the current call stack should be enabled.
+func (m *Matcher) Stack(w Writer) bool {
+	if m == nil {
+		return true
+	}
+	return m.stack(w)
+}
+
+// stack does the real work for Stack.
+// This lets stack's body handle m == nil and potentially be inlined.
+func (m *Matcher) stack(w Writer) bool {
+	const maxStack = 16
+	var stk [maxStack]uintptr
+	n := runtime.Callers(2, stk[:])
+	// caller #2 is not for printing; need it to normalize PCs if ASLR.
+	if n <= 1 {
+		return false
+	}
+
+	base := stk[0]
+	// normalize PCs
+	for i := range stk[:n] {
+		stk[i] -= base
+	}
+
+	h := Hash(stk[:n])
+	if m.ShouldPrint(h) {
+		var d *dedup
+		for {
+			d = m.dedup.Load()
+			if d != nil {
+				break
+			}
+			d = new(dedup)
+			if m.dedup.CompareAndSwap(nil, d) {
+				break
+			}
+		}
+
+		if m.MarkerOnly() {
+			if !d.seenLossy(h) {
+				PrintMarker(w, h)
+			}
+		} else {
+			if !d.seen(h) {
+				// Restore PCs in stack for printing
+				for i := range stk[:n] {
+					stk[i] += base
+				}
+				printStack(w, h, stk[1:n])
+			}
+		}
+	}
+	return m.ShouldEnable(h)
+}
+
+// Writer is the same interface as io.Writer.
+// It is duplicated here to avoid importing io.
+type Writer interface {
+	Write([]byte) (int, error)
+}
+
+// PrintMarker prints to w a one-line report containing only the marker for h.
+// It is appropriate to use when [Matcher.ShouldPrint] and [Matcher.MarkerOnly] both return true.
+func PrintMarker(w Writer, h uint64) error {
+	var buf [50]byte
+	b := AppendMarker(buf[:0], h)
+	b = append(b, '\n')
+	_, err := w.Write(b)
+	return err
+}
+
+// printStack prints to w a multi-line report containing a formatting of the call stack stk,
+// with each line preceded by the marker for h.
+func printStack(w Writer, h uint64, stk []uintptr) error {
+	buf := make([]byte, 0, 2048)
+
+	var prefixBuf [100]byte
+	prefix := AppendMarker(prefixBuf[:0], h)
+
+	frames := runtime.CallersFrames(stk)
+	for {
+		f, more := frames.Next()
+		buf = append(buf, prefix...)
+		buf = append(buf, f.Function...)
+		buf = append(buf, "()\n"...)
+		buf = append(buf, prefix...)
+		buf = append(buf, '\t')
+		buf = appendFileLine(buf, f.File, f.Line)
+		buf = append(buf, '\n')
+		if !more {
+			break
+		}
+	}
+	buf = append(buf, prefix...)
+	buf = append(buf, '\n')
+	_, err := w.Write(buf)
+	return err
+}
+
+// Marker returns the match marker text to use on any line reporting details
+// about a match of the given ID.
+// It always returns the hexadecimal format.
+func Marker(id uint64) string {
+	return string(AppendMarker(nil, id))
+}
+
+// AppendMarker is like [Marker] but appends the marker to dst.
+func AppendMarker(dst []byte, id uint64) []byte {
+	const prefix = "[bisect-match 0x"
+	var buf [len(prefix) + 16 + 1]byte
+	copy(buf[:], prefix)
+	for i := 0; i < 16; i++ {
+		buf[len(prefix)+i] = "0123456789abcdef"[id>>60]
+		id <<= 4
+	}
+	buf[len(prefix)+16] = ']'
+	return append(dst, buf[:]...)
+}
+
+// CutMarker finds the first match marker in line and removes it,
+// returning the shortened line (with the marker removed),
+// the ID from the match marker,
+// and whether a marker was found at all.
+// If there is no marker, CutMarker returns line, 0, false.
+func CutMarker(line string) (short string, id uint64, ok bool) {
+	// Find first instance of prefix.
+	prefix := "[bisect-match "
+	i := 0
+	for ; ; i++ {
+		if i >= len(line)-len(prefix) {
+			return line, 0, false
+		}
+		if line[i] == '[' && line[i:i+len(prefix)] == prefix {
+			break
+		}
+	}
+
+	// Scan to ].
+	j := i + len(prefix)
+	for j < len(line) && line[j] != ']' {
+		j++
+	}
+	if j >= len(line) {
+		return line, 0, false
+	}
+
+	// Parse id.
+	idstr := line[i+len(prefix) : j]
+	if len(idstr) >= 3 && idstr[:2] == "0x" {
+		// parse hex
+		if len(idstr) > 2+16 { // max 0x + 16 digits
+			return line, 0, false
+		}
+		for i := 2; i < len(idstr); i++ {
+			id <<= 4
+			switch c := idstr[i]; {
+			case '0' <= c && c <= '9':
+				id |= uint64(c - '0')
+			case 'a' <= c && c <= 'f':
+				id |= uint64(c - 'a' + 10)
+			case 'A' <= c && c <= 'F':
+				id |= uint64(c - 'A' + 10)
+			}
+		}
+	} else {
+		if idstr == "" || len(idstr) > 64 { // min 1 digit, max 64 digits
+			return line, 0, false
+		}
+		// parse binary
+		for i := 0; i < len(idstr); i++ {
+			id <<= 1
+			switch c := idstr[i]; c {
+			default:
+				return line, 0, false
+			case '0', '1':
+				id |= uint64(c - '0')
+			}
+		}
+	}
+
+	// Construct shortened line.
+	// Remove at most one space from around the marker,
+	// so that "foo [marker] bar" shortens to "foo bar".
+	j++ // skip ]
+	if i > 0 && line[i-1] == ' ' {
+		i--
+	} else if j < len(line) && line[j] == ' ' {
+		j++
+	}
+	short = line[:i] + line[j:]
+	return short, id, true
+}
+
+// Hash computes a hash of the data arguments,
+// each of which must be of type string, byte, int, uint, int32, uint32, int64, uint64, uintptr, or a slice of one of those types.
+func Hash(data ...any) uint64 {
+	h := offset64
+	for _, v := range data {
+		switch v := v.(type) {
+		default:
+			// Note: Not printing the type, because reflect.ValueOf(v)
+			// would make the interfaces prepared by the caller escape
+			// and therefore allocate. This way, Hash(file, line) runs
+			// without any allocation. It should be clear from the
+			// source code calling Hash what the bad argument was.
+			panic("bisect.Hash: unexpected argument type")
+		case string:
+			h = fnvString(h, v)
+		case byte:
+			h = fnv(h, v)
+		case int:
+			h = fnvUint64(h, uint64(v))
+		case uint:
+			h = fnvUint64(h, uint64(v))
+		case int32:
+			h = fnvUint32(h, uint32(v))
+		case uint32:
+			h = fnvUint32(h, v)
+		case int64:
+			h = fnvUint64(h, uint64(v))
+		case uint64:
+			h = fnvUint64(h, v)
+		case uintptr:
+			h = fnvUint64(h, uint64(v))
+		case []string:
+			for _, x := range v {
+				h = fnvString(h, x)
+			}
+		case []byte:
+			for _, x := range v {
+				h = fnv(h, x)
+			}
+		case []int:
+			for _, x := range v {
+				h = fnvUint64(h, uint64(x))
+			}
+		case []uint:
+			for _, x := range v {
+				h = fnvUint64(h, uint64(x))
+			}
+		case []int32:
+			for _, x := range v {
+				h = fnvUint32(h, uint32(x))
+			}
+		case []uint32:
+			for _, x := range v {
+				h = fnvUint32(h, x)
+			}
+		case []int64:
+			for _, x := range v {
+				h = fnvUint64(h, uint64(x))
+			}
+		case []uint64:
+			for _, x := range v {
+				h = fnvUint64(h, x)
+			}
+		case []uintptr:
+			for _, x := range v {
+				h = fnvUint64(h, uint64(x))
+			}
+		}
+	}
+	return h
+}
+
+// Trivial error implementation, here to avoid importing errors.
+
+// parseError is a trivial error implementation,
+// defined here to avoid importing errors.
+type parseError struct{ text string }
+
+func (e *parseError) Error() string { return e.text }
+
+// FNV-1a implementation. See Go's hash/fnv/fnv.go.
+// Copied here for simplicity (can handle integers more directly)
+// and to avoid importing hash/fnv.
+
+const (
+	offset64 uint64 = 14695981039346656037
+	prime64  uint64 = 1099511628211
+)
+
+func fnv(h uint64, x byte) uint64 {
+	h ^= uint64(x)
+	h *= prime64
+	return h
+}
+
+func fnvString(h uint64, x string) uint64 {
+	for i := 0; i < len(x); i++ {
+		h ^= uint64(x[i])
+		h *= prime64
+	}
+	return h
+}
+
+func fnvUint64(h uint64, x uint64) uint64 {
+	for i := 0; i < 8; i++ {
+		h ^= x & 0xFF
+		x >>= 8
+		h *= prime64
+	}
+	return h
+}
+
+func fnvUint32(h uint64, x uint32) uint64 {
+	for i := 0; i < 4; i++ {
+		h ^= uint64(x & 0xFF)
+		x >>= 8
+		h *= prime64
+	}
+	return h
+}
+
+// A dedup is a deduplicator for call stacks, so that we only print
+// a report for new call stacks, not for call stacks we've already
+// reported.
+//
+// It has two modes: an approximate but lock-free mode that
+// may still emit some duplicates, and a precise mode that uses
+// a lock and never emits duplicates.
+type dedup struct {
+	// 128-entry 4-way, lossy cache for seenLossy
+	recent [128][4]uint64
+
+	// complete history for seen
+	mu sync.Mutex
+	m  map[uint64]bool
+}
+
+// seen records that h has now been seen and reports whether it was seen before.
+// When seen returns false, the caller is expected to print a report for h.
+func (d *dedup) seen(h uint64) bool {
+	d.mu.Lock()
+	if d.m == nil {
+		d.m = make(map[uint64]bool)
+	}
+	seen := d.m[h]
+	d.m[h] = true
+	d.mu.Unlock()
+	return seen
+}
+
+// seenLossy is a variant of seen that avoids a lock by using a cache of recently seen hashes.
+// Each cache entry is N-way set-associative: h can appear in any of the slots.
+// If h does not appear in any of them, then it is inserted into a random slot,
+// overwriting whatever was there before.
+func (d *dedup) seenLossy(h uint64) bool {
+	cache := &d.recent[uint(h)%uint(len(d.recent))]
+	for i := 0; i < len(cache); i++ {
+		if atomic.LoadUint64(&cache[i]) == h {
+			return true
+		}
+	}
+
+	// Compute index in set to evict as hash of current set.
+	ch := offset64
+	for _, x := range cache {
+		ch = fnvUint64(ch, x)
+	}
+	atomic.StoreUint64(&cache[uint(ch)%uint(len(cache))], h)
+	return false
+}

go/src/internal/buildcfg/cfg.go

@@ -0,0 +1,467 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package buildcfg provides access to the build configuration
+// described by the current environment. It is for use by build tools
+// such as cmd/go or cmd/compile and for setting up go/build's Default context.
+//
+// Note that it does NOT provide access to the build configuration used to
+// build the currently-running binary. For that, use runtime.GOOS etc
+// as well as internal/goexperiment.
+package buildcfg
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strconv"
+	"strings"
+)
+
+var (
+	GOROOT    = os.Getenv("GOROOT") // cached for efficiency
+	GOARCH    = envOr("GOARCH", defaultGOARCH)
+	GOOS      = envOr("GOOS", defaultGOOS)
+	GO386     = envOr("GO386", DefaultGO386)
+	GOAMD64   = goamd64()
+	GOARM     = goarm()
+	GOARM64   = goarm64()
+	GOMIPS    = gomips()
+	GOMIPS64  = gomips64()
+	GOPPC64   = goppc64()
+	GORISCV64 = goriscv64()
+	GOWASM    = gowasm()
+	ToolTags  = toolTags()
+	GO_LDSO   = defaultGO_LDSO
+	GOFIPS140 = gofips140()
+	Version   = version
+)
+
+// Error is one of the errors found (if any) in the build configuration.
+var Error error
+
+// Check exits the program with a fatal error if Error is non-nil.
+func Check() {
+	if Error != nil {
+		fmt.Fprintf(os.Stderr, "%s: %v\n", filepath.Base(os.Args[0]), Error)
+		os.Exit(2)
+	}
+}
+
+func envOr(key, value string) string {
+	if x := os.Getenv(key); x != "" {
+		return x
+	}
+	return value
+}
+
+func goamd64() int {
+	switch v := envOr("GOAMD64", DefaultGOAMD64); v {
+	case "v1":
+		return 1
+	case "v2":
+		return 2
+	case "v3":
+		return 3
+	case "v4":
+		return 4
+	}
+	Error = fmt.Errorf("invalid GOAMD64: must be v1, v2, v3, v4")
+	return int(DefaultGOAMD64[len("v")] - '0')
+}
+
+func gofips140() string {
+	v := envOr("GOFIPS140", DefaultGOFIPS140)
+	switch v {
+	case "off", "latest", "inprocess", "certified":
+		return v
+	}
+	if isFIPSVersion(v) {
+		return v
+	}
+	Error = fmt.Errorf("invalid GOFIPS140: must be off, latest, inprocess, certified, or v1.Y.Z")
+	return DefaultGOFIPS140
+}
+
+// isFIPSVersion reports whether v is a valid FIPS version,
+// of the form v1.Y.Z or v1.Y.Z-hhhhhhhh or v1.Y.Z-rcN.
+func isFIPSVersion(v string) bool {
+	v, ok := strings.CutPrefix(v, "v1.")
+	if !ok {
+		return false
+	}
+	if v, ok = cutNum(v); !ok {
+		return false
+	}
+	if v, ok = strings.CutPrefix(v, "."); !ok {
+		return false
+	}
+	if v, ok = cutNum(v); !ok {
+		return false
+	}
+	if v == "" {
+		return true
+	}
+	if v, ok = strings.CutPrefix(v, "-rc"); ok {
+		v, ok = cutNum(v)
+		return ok && v == ""
+	}
+	if v, ok = strings.CutPrefix(v, "-"); ok {
+		return len(v) == 8
+	}
+	return false
+}
+
+// cutNum skips the leading text matching [0-9]+
+// in s, returning the rest and whether such text was found.
+func cutNum(s string) (rest string, ok bool) {
+	i := 0
+	for i < len(s) && '0' <= s[i] && s[i] <= '9' {
+		i++
+	}
+	return s[i:], i > 0
+}
+
+type GoarmFeatures struct {
+	Version   int
+	SoftFloat bool
+}
+
+func (g GoarmFeatures) String() string {
+	armStr := strconv.Itoa(g.Version)
+	if g.SoftFloat {
+		armStr += ",softfloat"
+	} else {
+		armStr += ",hardfloat"
+	}
+	return armStr
+}
+
+func goarm() (g GoarmFeatures) {
+	const (
+		softFloatOpt = ",softfloat"
+		hardFloatOpt = ",hardfloat"
+	)
+	def := DefaultGOARM
+	if GOOS == "android" && GOARCH == "arm" {
+		// Android arm devices always support GOARM=7.
+		def = "7"
+	}
+	v := envOr("GOARM", def)
+
+	floatSpecified := false
+	if strings.HasSuffix(v, softFloatOpt) {
+		g.SoftFloat = true
+		floatSpecified = true
+		v = v[:len(v)-len(softFloatOpt)]
+	}
+	if strings.HasSuffix(v, hardFloatOpt) {
+		floatSpecified = true
+		v = v[:len(v)-len(hardFloatOpt)]
+	}
+
+	switch v {
+	case "5":
+		g.Version = 5
+	case "6":
+		g.Version = 6
+	case "7":
+		g.Version = 7
+	default:
+		Error = fmt.Errorf("invalid GOARM: must start with 5, 6, or 7, and may optionally end in either %q or %q", hardFloatOpt, softFloatOpt)
+		g.Version = int(def[0] - '0')
+	}
+
+	// 5 defaults to softfloat. 6 and 7 default to hardfloat.
+	if !floatSpecified && g.Version == 5 {
+		g.SoftFloat = true
+	}
+	return
+}
+
+type Goarm64Features struct {
+	Version string
+	// Large Systems Extension
+	LSE bool
+	// ARM v8.0 Cryptographic Extension. It includes the following features:
+	// * FEAT_AES, which includes the AESD and AESE instructions.
+	// * FEAT_PMULL, which includes the PMULL, PMULL2 instructions.
+	// * FEAT_SHA1, which includes the SHA1* instructions.
+	// * FEAT_SHA256, which includes the SHA256* instructions.
+	Crypto bool
+}
+
+func (g Goarm64Features) String() string {
+	arm64Str := g.Version
+	if g.LSE {
+		arm64Str += ",lse"
+	}
+	if g.Crypto {
+		arm64Str += ",crypto"
+	}
+	return arm64Str
+}
+
+func ParseGoarm64(v string) (g Goarm64Features, e error) {
+	const (
+		lseOpt    = ",lse"
+		cryptoOpt = ",crypto"
+	)
+
+	g.LSE = false
+	g.Crypto = false
+	// We allow any combination of suffixes, in any order
+	for {
+		if strings.HasSuffix(v, lseOpt) {
+			g.LSE = true
+			v = v[:len(v)-len(lseOpt)]
+			continue
+		}
+
+		if strings.HasSuffix(v, cryptoOpt) {
+			g.Crypto = true
+			v = v[:len(v)-len(cryptoOpt)]
+			continue
+		}
+
+		break
+	}
+
+	switch v {
+	case "v8.0":
+		g.Version = v
+	case "v8.1", "v8.2", "v8.3", "v8.4", "v8.5", "v8.6", "v8.7", "v8.8", "v8.9",
+		"v9.0", "v9.1", "v9.2", "v9.3", "v9.4", "v9.5":
+		g.Version = v
+		// LSE extension is mandatory starting from 8.1
+		g.LSE = true
+	default:
+		e = fmt.Errorf("invalid GOARM64: must start with v8.{0-9} or v9.{0-5} and may optionally end in %q and/or %q",
+			lseOpt, cryptoOpt)
+		g.Version = DefaultGOARM64
+	}
+
+	return
+}
+
+func goarm64() (g Goarm64Features) {
+	g, Error = ParseGoarm64(envOr("GOARM64", DefaultGOARM64))
+	return
+}
+
+// Returns true if g supports giving ARM64 ISA
+// Note that this function doesn't accept / test suffixes (like ",lse" or ",crypto")
+func (g Goarm64Features) Supports(s string) bool {
+	// We only accept "v{8-9}.{0-9}. Everything else is malformed.
+	if len(s) != 4 {
+		return false
+	}
+
+	major := s[1]
+	minor := s[3]
+
+	// We only accept "v{8-9}.{0-9}. Everything else is malformed.
+	if major < '8' || major > '9' ||
+		minor < '0' || minor > '9' ||
+		s[0] != 'v' || s[2] != '.' {
+		return false
+	}
+
+	g_major := g.Version[1]
+	g_minor := g.Version[3]
+
+	if major == g_major {
+		return minor <= g_minor
+	} else if g_major == '9' {
+		// v9.0 diverged from v8.5. This means we should compare with g_minor increased by five.
+		return minor <= g_minor+5
+	} else {
+		return false
+	}
+}
+
+func gomips() string {
+	switch v := envOr("GOMIPS", DefaultGOMIPS); v {
+	case "hardfloat", "softfloat":
+		return v
+	}
+	Error = fmt.Errorf("invalid GOMIPS: must be hardfloat, softfloat")
+	return DefaultGOMIPS
+}
+
+func gomips64() string {
+	switch v := envOr("GOMIPS64", DefaultGOMIPS64); v {
+	case "hardfloat", "softfloat":
+		return v
+	}
+	Error = fmt.Errorf("invalid GOMIPS64: must be hardfloat, softfloat")
+	return DefaultGOMIPS64
+}
+
+func goppc64() int {
+	switch v := envOr("GOPPC64", DefaultGOPPC64); v {
+	case "power8":
+		return 8
+	case "power9":
+		return 9
+	case "power10":
+		return 10
+	}
+	Error = fmt.Errorf("invalid GOPPC64: must be power8, power9, power10")
+	return int(DefaultGOPPC64[len("power")] - '0')
+}
+
+func goriscv64() int {
+	switch v := envOr("GORISCV64", DefaultGORISCV64); v {
+	case "rva20u64":
+		return 20
+	case "rva22u64":
+		return 22
+	case "rva23u64":
+		return 23
+	}
+	Error = fmt.Errorf("invalid GORISCV64: must be rva20u64, rva22u64, rva23u64")
+	v := DefaultGORISCV64[len("rva"):]
+	i := strings.IndexFunc(v, func(r rune) bool {
+		return r < '0' || r > '9'
+	})
+	year, _ := strconv.Atoi(v[:i])
+	return year
+}
+
+type gowasmFeatures struct {
+	// Legacy features, now always enabled
+	//SatConv bool
+	//SignExt bool
+}
+
+func (f gowasmFeatures) String() string {
+	var flags []string
+	return strings.Join(flags, ",")
+}
+
+func gowasm() (f gowasmFeatures) {
+	for opt := range strings.SplitSeq(envOr("GOWASM", ""), ",") {
+		switch opt {
+		case "satconv":
+			// ignore, always enabled
+		case "signext":
+			// ignore, always enabled
+		case "":
+			// ignore
+		default:
+			Error = fmt.Errorf("invalid GOWASM: no such feature %q", opt)
+		}
+	}
+	return
+}
+
+func Getgoextlinkenabled() string {
+	return envOr("GO_EXTLINK_ENABLED", defaultGO_EXTLINK_ENABLED)
+}
+
+func toolTags() []string {
+	tags := experimentTags()
+	tags = append(tags, gogoarchTags()...)
+	return tags
+}
+
+func experimentTags() []string {
+	var list []string
+	// For each experiment that has been enabled in the toolchain, define a
+	// build tag with the same name but prefixed by "goexperiment." which can be
+	// used for compiling alternative files for the experiment. This allows
+	// changes for the experiment, like extra struct fields in the runtime,
+	// without affecting the base non-experiment code at all.
+	for _, exp := range Experiment.Enabled() {
+		list = append(list, "goexperiment."+exp)
+	}
+	return list
+}
+
+// GOGOARCH returns the name and value of the GO$GOARCH setting.
+// For example, if GOARCH is "amd64" it might return "GOAMD64", "v2".
+func GOGOARCH() (name, value string) {
+	switch GOARCH {
+	case "386":
+		return "GO386", GO386
+	case "amd64":
+		return "GOAMD64", fmt.Sprintf("v%d", GOAMD64)
+	case "arm":
+		return "GOARM", GOARM.String()
+	case "arm64":
+		return "GOARM64", GOARM64.String()
+	case "mips", "mipsle":
+		return "GOMIPS", GOMIPS
+	case "mips64", "mips64le":
+		return "GOMIPS64", GOMIPS64
+	case "ppc64", "ppc64le":
+		return "GOPPC64", fmt.Sprintf("power%d", GOPPC64)
+	case "riscv64":
+		return "GORISCV64", fmt.Sprintf("rva%du64", GORISCV64)
+	case "wasm":
+		return "GOWASM", GOWASM.String()
+	}
+	return "", ""
+}
+
+func gogoarchTags() []string {
+	switch GOARCH {
+	case "386":
+		return []string{GOARCH + "." + GO386}
+	case "amd64":
+		var list []string
+		for i := 1; i <= GOAMD64; i++ {
+			list = append(list, fmt.Sprintf("%s.v%d", GOARCH, i))
+		}
+		return list
+	case "arm":
+		var list []string
+		for i := 5; i <= GOARM.Version; i++ {
+			list = append(list, fmt.Sprintf("%s.%d", GOARCH, i))
+		}
+		return list
+	case "arm64":
+		var list []string
+		major := int(GOARM64.Version[1] - '0')
+		minor := int(GOARM64.Version[3] - '0')
+		for i := 0; i <= minor; i++ {
+			list = append(list, fmt.Sprintf("%s.v%d.%d", GOARCH, major, i))
+		}
+		// ARM64 v9.x also includes support of v8.x+5 (i.e. v9.1 includes v8.(1+5) = v8.6).
+		if major == 9 {
+			for i := 0; i <= minor+5 && i <= 9; i++ {
+				list = append(list, fmt.Sprintf("%s.v%d.%d", GOARCH, 8, i))
+			}
+		}
+		return list
+	case "mips", "mipsle":
+		return []string{GOARCH + "." + GOMIPS}
+	case "mips64", "mips64le":
+		return []string{GOARCH + "." + GOMIPS64}
+	case "ppc64", "ppc64le":
+		var list []string
+		for i := 8; i <= GOPPC64; i++ {
+			list = append(list, fmt.Sprintf("%s.power%d", GOARCH, i))
+		}
+		return list
+	case "riscv64":
+		list := []string{GOARCH + "." + "rva20u64"}
+		if GORISCV64 >= 22 {
+			list = append(list, GOARCH+"."+"rva22u64")
+		}
+		if GORISCV64 >= 23 {
+			list = append(list, GOARCH+"."+"rva23u64")
+		}
+		return list
+	case "wasm":
+		var list []string
+		// SatConv is always enabled
+		list = append(list, GOARCH+".satconv")
+		// SignExt is always enabled
+		list = append(list, GOARCH+".signext")
+		return list
+	}
+	return nil
+}

go/src/internal/buildcfg/cfg_test.go

@@ -0,0 +1,165 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package buildcfg
+
+import (
+	"os"
+	"testing"
+)
+
+func TestConfigFlags(t *testing.T) {
+	os.Setenv("GOAMD64", "v1")
+	if goamd64() != 1 {
+		t.Errorf("Wrong parsing of GOAMD64=v1")
+	}
+	os.Setenv("GOAMD64", "v4")
+	if goamd64() != 4 {
+		t.Errorf("Wrong parsing of GOAMD64=v4")
+	}
+	Error = nil
+	os.Setenv("GOAMD64", "1")
+	if goamd64(); Error == nil {
+		t.Errorf("Wrong parsing of GOAMD64=1")
+	}
+
+	os.Setenv("GORISCV64", "rva20u64")
+	if goriscv64() != 20 {
+		t.Errorf("Wrong parsing of RISCV64=rva20u64")
+	}
+	os.Setenv("GORISCV64", "rva22u64")
+	if goriscv64() != 22 {
+		t.Errorf("Wrong parsing of RISCV64=rva22u64")
+	}
+	os.Setenv("GORISCV64", "rva23u64")
+	if goriscv64() != 23 {
+		t.Errorf("Wrong parsing of RISCV64=rva23u64")
+	}
+	Error = nil
+	os.Setenv("GORISCV64", "rva22")
+	if _ = goriscv64(); Error == nil {
+		t.Errorf("Wrong parsing of RISCV64=rva22")
+	}
+	Error = nil
+	os.Setenv("GOARM64", "v7.0")
+	if _ = goarm64(); Error == nil {
+		t.Errorf("Wrong parsing of GOARM64=7.0")
+	}
+	Error = nil
+	os.Setenv("GOARM64", "8.0")
+	if _ = goarm64(); Error == nil {
+		t.Errorf("Wrong parsing of GOARM64=8.0")
+	}
+	Error = nil
+	os.Setenv("GOARM64", "v8.0,lsb")
+	if _ = goarm64(); Error == nil {
+		t.Errorf("Wrong parsing of GOARM64=v8.0,lsb")
+	}
+	os.Setenv("GOARM64", "v8.0,lse")
+	if goarm64().Version != "v8.0" || goarm64().LSE != true || goarm64().Crypto != false {
+		t.Errorf("Wrong parsing of GOARM64=v8.0,lse")
+	}
+	os.Setenv("GOARM64", "v8.0,crypto")
+	if goarm64().Version != "v8.0" || goarm64().LSE != false || goarm64().Crypto != true {
+		t.Errorf("Wrong parsing of GOARM64=v8.0,crypto")
+	}
+	os.Setenv("GOARM64", "v8.0,crypto,lse")
+	if goarm64().Version != "v8.0" || goarm64().LSE != true || goarm64().Crypto != true {
+		t.Errorf("Wrong parsing of GOARM64=v8.0,crypto,lse")
+	}
+	os.Setenv("GOARM64", "v8.0,lse,crypto")
+	if goarm64().Version != "v8.0" || goarm64().LSE != true || goarm64().Crypto != true {
+		t.Errorf("Wrong parsing of GOARM64=v8.0,lse,crypto")
+	}
+	os.Setenv("GOARM64", "v9.0")
+	if goarm64().Version != "v9.0" || goarm64().LSE != true || goarm64().Crypto != false {
+		t.Errorf("Wrong parsing of GOARM64=v9.0")
+	}
+}
+
+func TestGoarm64FeaturesSupports(t *testing.T) {
+	g, _ := ParseGoarm64("v9.3")
+
+	if !g.Supports("v9.3") {
+		t.Errorf("Wrong goarm64Features.Supports for v9.3, v9.3")
+	}
+
+	if g.Supports("v9.4") {
+		t.Errorf("Wrong goarm64Features.Supports for v9.3, v9.4")
+	}
+
+	if !g.Supports("v8.8") {
+		t.Errorf("Wrong goarm64Features.Supports for v9.3, v8.8")
+	}
+
+	if g.Supports("v8.9") {
+		t.Errorf("Wrong goarm64Features.Supports for v9.3, v8.9")
+	}
+
+	if g.Supports(",lse") {
+		t.Errorf("Wrong goarm64Features.Supports for v9.3, ,lse")
+	}
+}
+
+func TestGogoarchTags(t *testing.T) {
+	old_goarch := GOARCH
+	old_goarm64 := GOARM64
+
+	GOARCH = "arm64"
+
+	os.Setenv("GOARM64", "v9.5")
+	GOARM64 = goarm64()
+	tags := gogoarchTags()
+	want := []string{"arm64.v9.0", "arm64.v9.1", "arm64.v9.2", "arm64.v9.3", "arm64.v9.4", "arm64.v9.5",
+		"arm64.v8.0", "arm64.v8.1", "arm64.v8.2", "arm64.v8.3", "arm64.v8.4", "arm64.v8.5", "arm64.v8.6", "arm64.v8.7", "arm64.v8.8", "arm64.v8.9"}
+	if len(tags) != len(want) {
+		t.Errorf("Wrong number of tags for GOARM64=v9.5")
+	} else {
+		for i, v := range tags {
+			if v != want[i] {
+				t.Error("Wrong tags for GOARM64=v9.5")
+				break
+			}
+		}
+	}
+
+	GOARCH = old_goarch
+	GOARM64 = old_goarm64
+}
+
+var goodFIPS = []string{
+	"v1.0.0",
+	"v1.0.1",
+	"v1.2.0",
+	"v1.2.3",
+}
+
+var badFIPS = []string{
+	"v1.0.0-fips",
+	"v1.0.0+fips",
+	"1.0.0",
+	"x1.0.0",
+}
+
+func TestIsFIPSVersion(t *testing.T) {
+	// good
+	for _, s := range goodFIPS {
+		if !isFIPSVersion(s) {
+			t.Errorf("isFIPSVersion(%q) = false, want true", s)
+		}
+	}
+	// truncated
+	const v = "v1.2.3"
+	for i := 0; i < len(v); i++ {
+		if isFIPSVersion(v[:i]) {
+			t.Errorf("isFIPSVersion(%q) = true, want false", v[:i])
+		}
+	}
+	// bad
+	for _, s := range badFIPS {
+		if isFIPSVersion(s) {
+			t.Errorf("isFIPSVersion(%q) = true, want false", s)
+		}
+	}
+}

go/src/internal/buildcfg/exp.go

@@ -0,0 +1,203 @@
+// Copyright 2021 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package buildcfg
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+
+	"internal/goexperiment"
+)
+
+// ExperimentFlags represents a set of GOEXPERIMENT flags relative to a baseline
+// (platform-default) experiment configuration.
+type ExperimentFlags struct {
+	goexperiment.Flags
+	baseline goexperiment.Flags
+}
+
+// Experiment contains the toolchain experiments enabled for the
+// current build.
+//
+// (This is not necessarily the set of experiments the compiler itself
+// was built with.)
+//
+// Experiment.baseline specifies the experiment flags that are enabled by
+// default in the current toolchain. This is, in effect, the "control"
+// configuration and any variation from this is an experiment.
+var Experiment ExperimentFlags = func() ExperimentFlags {
+	flags, err := ParseGOEXPERIMENT(GOOS, GOARCH, envOr("GOEXPERIMENT", defaultGOEXPERIMENT))
+	if err != nil {
+		Error = err
+		return ExperimentFlags{}
+	}
+	return *flags
+}()
+
+// DefaultGOEXPERIMENT is the embedded default GOEXPERIMENT string.
+// It is not guaranteed to be canonical.
+const DefaultGOEXPERIMENT = defaultGOEXPERIMENT
+
+// FramePointerEnabled enables the use of platform conventions for
+// saving frame pointers.
+//
+// This used to be an experiment, but now it's always enabled on
+// platforms that support it.
+//
+// Note: must agree with runtime.framepointer_enabled.
+var FramePointerEnabled = GOARCH == "amd64" || GOARCH == "arm64"
+
+// ParseGOEXPERIMENT parses a (GOOS, GOARCH, GOEXPERIMENT)
+// configuration tuple and returns the enabled and baseline experiment
+// flag sets.
+//
+// TODO(mdempsky): Move to [internal/goexperiment].
+func ParseGOEXPERIMENT(goos, goarch, goexp string) (*ExperimentFlags, error) {
+	// regabiSupported is set to true on platforms where register ABI is
+	// supported and enabled by default.
+	// regabiAlwaysOn is set to true on platforms where register ABI is
+	// always on.
+	var regabiSupported, regabiAlwaysOn bool
+	switch goarch {
+	case "amd64", "arm64", "loong64", "ppc64le", "ppc64", "riscv64":
+		regabiAlwaysOn = true
+		regabiSupported = true
+	case "s390x":
+		regabiSupported = true
+	}
+
+	// Older versions (anything before V16) of dsymutil don't handle
+	// the .debug_rnglists section in DWARF5. See
+	// https://github.com/golang/go/issues/26379#issuecomment-2677068742
+	// for more context. This disables all DWARF5 on mac, which is not
+	// ideal (would be better to disable just for cases where we know
+	// the build will use external linking). In the GOOS=aix case, the
+	// XCOFF format (as far as can be determined) doesn't seem to
+	// support the necessary section subtypes for DWARF-specific
+	// things like .debug_addr (needed for DWARF 5).
+	dwarf5Supported := (goos != "darwin" && goos != "ios" && goos != "aix")
+
+	baseline := goexperiment.Flags{
+		RegabiWrappers:       regabiSupported,
+		RegabiArgs:           regabiSupported,
+		Dwarf5:               dwarf5Supported,
+		RandomizedHeapBase64: true,
+		GreenTeaGC:           true,
+	}
+	flags := &ExperimentFlags{
+		Flags:    baseline,
+		baseline: baseline,
+	}
+
+	// Pick up any changes to the baseline configuration from the
+	// GOEXPERIMENT environment. This can be set at make.bash time
+	// and overridden at build time.
+	if goexp != "" {
+		// Create a map of known experiment names.
+		names := make(map[string]func(bool))
+		rv := reflect.ValueOf(&flags.Flags).Elem()
+		rt := rv.Type()
+		for i := 0; i < rt.NumField(); i++ {
+			field := rv.Field(i)
+			names[strings.ToLower(rt.Field(i).Name)] = field.SetBool
+		}
+
+		// "regabi" is an alias for all working regabi
+		// subexperiments, and not an experiment itself. Doing
+		// this as an alias make both "regabi" and "noregabi"
+		// do the right thing.
+		names["regabi"] = func(v bool) {
+			flags.RegabiWrappers = v
+			flags.RegabiArgs = v
+		}
+
+		// Parse names.
+		for f := range strings.SplitSeq(goexp, ",") {
+			if f == "" {
+				continue
+			}
+			if f == "none" {
+				// GOEXPERIMENT=none disables all experiment flags.
+				// This is used by cmd/dist, which doesn't know how
+				// to build with any experiment flags.
+				flags.Flags = goexperiment.Flags{}
+				continue
+			}
+			val := true
+			if strings.HasPrefix(f, "no") {
+				f, val = f[2:], false
+			}
+			set, ok := names[f]
+			if !ok {
+				return nil, fmt.Errorf("unknown GOEXPERIMENT %s", f)
+			}
+			set(val)
+		}
+	}
+
+	if regabiAlwaysOn {
+		flags.RegabiWrappers = true
+		flags.RegabiArgs = true
+	}
+	// regabi is only supported on amd64, arm64, loong64, riscv64, s390x, ppc64 and ppc64le.
+	if !regabiSupported {
+		flags.RegabiWrappers = false
+		flags.RegabiArgs = false
+	}
+	// Check regabi dependencies.
+	if flags.RegabiArgs && !flags.RegabiWrappers {
+		return nil, fmt.Errorf("GOEXPERIMENT regabiargs requires regabiwrappers")
+	}
+	return flags, nil
+}
+
+// String returns the canonical GOEXPERIMENT string to enable this experiment
+// configuration. (Experiments in the same state as in the baseline are elided.)
+func (exp *ExperimentFlags) String() string {
+	return strings.Join(expList(&exp.Flags, &exp.baseline, false), ",")
+}
+
+// expList returns the list of lower-cased experiment names for
+// experiments that differ from base. base may be nil to indicate no
+// experiments. If all is true, then include all experiment flags,
+// regardless of base.
+func expList(exp, base *goexperiment.Flags, all bool) []string {
+	var list []string
+	rv := reflect.ValueOf(exp).Elem()
+	var rBase reflect.Value
+	if base != nil {
+		rBase = reflect.ValueOf(base).Elem()
+	}
+	rt := rv.Type()
+	for i := 0; i < rt.NumField(); i++ {
+		name := strings.ToLower(rt.Field(i).Name)
+		val := rv.Field(i).Bool()
+		baseVal := false
+		if base != nil {
+			baseVal = rBase.Field(i).Bool()
+		}
+		if all || val != baseVal {
+			if val {
+				list = append(list, name)
+			} else {
+				list = append(list, "no"+name)
+			}
+		}
+	}
+	return list
+}
+
+// Enabled returns a list of enabled experiments, as
+// lower-cased experiment names.
+func (exp *ExperimentFlags) Enabled() []string {
+	return expList(&exp.Flags, nil, false)
+}
+
+// All returns a list of all experiment settings.
+// Disabled experiments appear in the list prefixed by "no".
+func (exp *ExperimentFlags) All() []string {
+	return expList(&exp.Flags, nil, true)
+}

go/src/internal/buildcfg/zbootstrap.go

@@ -0,0 +1,22 @@
+// Code generated by go tool dist; DO NOT EDIT.
+
+package buildcfg
+
+import "runtime"
+
+const DefaultGO386 = `sse2`
+const DefaultGOAMD64 = `v1`
+const DefaultGOARM = `7`
+const DefaultGOARM64 = `v8.0`
+const DefaultGOMIPS = `hardfloat`
+const DefaultGOMIPS64 = `hardfloat`
+const DefaultGOPPC64 = `power8`
+const DefaultGORISCV64 = `rva20u64`
+const defaultGOEXPERIMENT = ``
+const defaultGO_EXTLINK_ENABLED = ``
+const defaultGO_LDSO = ``
+const version = `go1.26.3`
+const defaultGOOS = runtime.GOOS
+const defaultGOARCH = runtime.GOARCH
+const DefaultGOFIPS140 = `off`
+const DefaultCGO_ENABLED = ""

go/src/internal/bytealg/bytealg.go

@@ -0,0 +1,123 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package bytealg
+
+import (
+	"internal/cpu"
+	"unsafe"
+)
+
+// Offsets into internal/cpu records for use in assembly.
+const (
+	offsetPPC64HasPOWER9 = unsafe.Offsetof(cpu.PPC64.IsPOWER9)
+
+	offsetRISCV64HasV = unsafe.Offsetof(cpu.RISCV64.HasV)
+
+	offsetLOONG64HasLSX  = unsafe.Offsetof(cpu.Loong64.HasLSX)
+	offsetLOONG64HasLASX = unsafe.Offsetof(cpu.Loong64.HasLASX)
+
+	offsetS390xHasVX = unsafe.Offsetof(cpu.S390X.HasVX)
+
+	offsetX86HasSSE42  = unsafe.Offsetof(cpu.X86.HasSSE42)
+	offsetX86HasAVX2   = unsafe.Offsetof(cpu.X86.HasAVX2)
+	offsetX86HasPOPCNT = unsafe.Offsetof(cpu.X86.HasPOPCNT)
+)
+
+// MaxLen is the maximum length of the string to be searched for (argument b) in Index.
+// If MaxLen is not 0, make sure MaxLen >= 4.
+var MaxLen int
+
+// PrimeRK is the prime base used in Rabin-Karp algorithm.
+const PrimeRK = 16777619
+
+// HashStr returns the hash and the appropriate multiplicative
+// factor for use in Rabin-Karp algorithm.
+func HashStr[T string | []byte](sep T) (uint32, uint32) {
+	hash := uint32(0)
+	for i := 0; i < len(sep); i++ {
+		hash = hash*PrimeRK + uint32(sep[i])
+	}
+	var pow, sq uint32 = 1, PrimeRK
+	for i := len(sep); i > 0; i >>= 1 {
+		if i&1 != 0 {
+			pow *= sq
+		}
+		sq *= sq
+	}
+	return hash, pow
+}
+
+// HashStrRev returns the hash of the reverse of sep and the
+// appropriate multiplicative factor for use in Rabin-Karp algorithm.
+func HashStrRev[T string | []byte](sep T) (uint32, uint32) {
+	hash := uint32(0)
+	for i := len(sep) - 1; i >= 0; i-- {
+		hash = hash*PrimeRK + uint32(sep[i])
+	}
+	var pow, sq uint32 = 1, PrimeRK
+	for i := len(sep); i > 0; i >>= 1 {
+		if i&1 != 0 {
+			pow *= sq
+		}
+		sq *= sq
+	}
+	return hash, pow
+}
+
+// IndexRabinKarp uses the Rabin-Karp search algorithm to return the index of the
+// first occurrence of sep in s, or -1 if not present.
+func IndexRabinKarp[T string | []byte](s, sep T) int {
+	// Rabin-Karp search
+	hashss, pow := HashStr(sep)
+	n := len(sep)
+	var h uint32
+	for i := 0; i < n; i++ {
+		h = h*PrimeRK + uint32(s[i])
+	}
+	if h == hashss && string(s[:n]) == string(sep) {
+		return 0
+	}
+	for i := n; i < len(s); {
+		h *= PrimeRK
+		h += uint32(s[i])
+		h -= pow * uint32(s[i-n])
+		i++
+		if h == hashss && string(s[i-n:i]) == string(sep) {
+			return i - n
+		}
+	}
+	return -1
+}
+
+// LastIndexRabinKarp uses the Rabin-Karp search algorithm to return the last index of the
+// occurrence of sep in s, or -1 if not present.
+func LastIndexRabinKarp[T string | []byte](s, sep T) int {
+	// Rabin-Karp search from the end of the string
+	hashss, pow := HashStrRev(sep)
+	n := len(sep)
+	last := len(s) - n
+	var h uint32
+	for i := len(s) - 1; i >= last; i-- {
+		h = h*PrimeRK + uint32(s[i])
+	}
+	if h == hashss && string(s[last:]) == string(sep) {
+		return last
+	}
+	for i := last - 1; i >= 0; i-- {
+		h *= PrimeRK
+		h += uint32(s[i])
+		h -= pow * uint32(s[i+n])
+		if h == hashss && string(s[i:i+n]) == string(sep) {
+			return i
+		}
+	}
+	return -1
+}
+
+// MakeNoZero makes a slice of length n and capacity of at least n Bytes
+// without zeroing the bytes (including the bytes between len and cap).
+// It is the caller's responsibility to ensure uninitialized bytes
+// do not leak to the end user.
+func MakeNoZero(n int) []byte

go/src/internal/bytealg/compare_386.s

@@ -0,0 +1,144 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#include "go_asm.h"
+#include "textflag.h"
+
+TEXT ·Compare(SB),NOSPLIT,$0-28
+	MOVL	a_base+0(FP), SI
+	MOVL	a_len+4(FP), BX
+	MOVL	b_base+12(FP), DI
+	MOVL	b_len+16(FP), DX
+	LEAL	ret+24(FP), AX
+	JMP	cmpbody<>(SB)
+
+TEXT runtime·cmpstring(SB),NOSPLIT,$0-20
+	MOVL	a_base+0(FP), SI
+	MOVL	a_len+4(FP), BX
+	MOVL	b_base+8(FP), DI
+	MOVL	b_len+12(FP), DX
+	LEAL	ret+16(FP), AX
+	JMP	cmpbody<>(SB)
+
+// input:
+//   SI = a
+//   DI = b
+//   BX = alen
+//   DX = blen
+//   AX = address of return word (set to 1/0/-1)
+TEXT cmpbody<>(SB),NOSPLIT,$0-0
+	MOVL	DX, BP
+	SUBL	BX, DX // DX = blen-alen
+	JLE	2(PC)
+	MOVL	BX, BP // BP = min(alen, blen)
+	CMPL	SI, DI
+	JEQ	allsame
+	CMPL	BP, $4
+	JB	small
+#ifdef GO386_softfloat
+	JMP	mediumloop
+#endif
+largeloop:
+	CMPL	BP, $16
+	JB	mediumloop
+	MOVOU	(SI), X0
+	MOVOU	(DI), X1
+	PCMPEQB X0, X1
+	PMOVMSKB X1, BX
+	XORL	$0xffff, BX	// convert EQ to NE
+	JNE	diff16	// branch if at least one byte is not equal
+	ADDL	$16, SI
+	ADDL	$16, DI
+	SUBL	$16, BP
+	JMP	largeloop
+
+diff16:
+	BSFL	BX, BX	// index of first byte that differs
+	XORL	DX, DX
+	MOVB	(SI)(BX*1), CX
+	CMPB	CX, (DI)(BX*1)
+	SETHI	DX
+	LEAL	-1(DX*2), DX	// convert 1/0 to +1/-1
+	MOVL	DX, (AX)
+	RET
+
+mediumloop:
+	CMPL	BP, $4
+	JBE	_0through4
+	MOVL	(SI), BX
+	MOVL	(DI), CX
+	CMPL	BX, CX
+	JNE	diff4
+	ADDL	$4, SI
+	ADDL	$4, DI
+	SUBL	$4, BP
+	JMP	mediumloop
+
+_0through4:
+	MOVL	-4(SI)(BP*1), BX
+	MOVL	-4(DI)(BP*1), CX
+	CMPL	BX, CX
+	JEQ	allsame
+
+diff4:
+	BSWAPL	BX	// reverse order of bytes
+	BSWAPL	CX
+	XORL	BX, CX	// find bit differences
+	BSRL	CX, CX	// index of highest bit difference
+	SHRL	CX, BX	// move a's bit to bottom
+	ANDL	$1, BX	// mask bit
+	LEAL	-1(BX*2), BX // 1/0 => +1/-1
+	MOVL	BX, (AX)
+	RET
+
+	// 0-3 bytes in common
+small:
+	LEAL	(BP*8), CX
+	NEGL	CX
+	JEQ	allsame
+
+	// load si
+	CMPB	SI, $0xfc
+	JA	si_high
+	MOVL	(SI), SI
+	JMP	si_finish
+si_high:
+	MOVL	-4(SI)(BP*1), SI
+	SHRL	CX, SI
+si_finish:
+	SHLL	CX, SI
+
+	// same for di
+	CMPB	DI, $0xfc
+	JA	di_high
+	MOVL	(DI), DI
+	JMP	di_finish
+di_high:
+	MOVL	-4(DI)(BP*1), DI
+	SHRL	CX, DI
+di_finish:
+	SHLL	CX, DI
+
+	BSWAPL	SI	// reverse order of bytes
+	BSWAPL	DI
+	XORL	SI, DI	// find bit differences
+	JEQ	allsame
+	BSRL	DI, CX	// index of highest bit difference
+	SHRL	CX, SI	// move a's bit to bottom
+	ANDL	$1, SI	// mask bit
+	LEAL	-1(SI*2), BX // 1/0 => +1/-1
+	MOVL	BX, (AX)
+	RET
+
+	// all the bytes in common are the same, so we just need
+	// to compare the lengths.
+allsame:
+	XORL	BX, BX
+	XORL	CX, CX
+	TESTL	DX, DX
+	SETLT	BX	// 1 if alen > blen
+	SETEQ	CX	// 1 if alen == blen
+	LEAL	-1(CX)(BX*2), BX	// 1,0,-1 result
+	MOVL	BX, (AX)
+	RET

go/src/internal/bytealg/compare_amd64.s

@@ -0,0 +1,237 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#include "go_asm.h"
+#include "asm_amd64.h"
+#include "textflag.h"
+
+TEXT ·Compare<ABIInternal>(SB),NOSPLIT,$0-56
+	// AX = a_base (want in SI)
+	// BX = a_len  (want in BX)
+	// CX = a_cap  (unused)
+	// DI = b_base (want in DI)
+	// SI = b_len  (want in DX)
+	// R8 = b_cap  (unused)
+	MOVQ	SI, DX
+	MOVQ	AX, SI
+	JMP	cmpbody<>(SB)
+
+TEXT runtime·cmpstring<ABIInternal>(SB),NOSPLIT,$0-40
+	// AX = a_base (want in SI)
+	// BX = a_len  (want in BX)
+	// CX = b_base (want in DI)
+	// DI = b_len  (want in DX)
+	MOVQ	AX, SI
+	MOVQ	DI, DX
+	MOVQ	CX, DI
+	JMP	cmpbody<>(SB)
+
+// input:
+//   SI = a
+//   DI = b
+//   BX = alen
+//   DX = blen
+// output:
+//   AX = output (-1/0/1)
+TEXT cmpbody<>(SB),NOSPLIT,$0-0
+	CMPQ	SI, DI
+	JEQ	allsame
+	CMPQ	BX, DX
+	MOVQ	DX, R8
+	CMOVQLT	BX, R8 // R8 = min(alen, blen) = # of bytes to compare
+	CMPQ	R8, $8
+	JB	small
+
+	CMPQ	R8, $63
+	JBE	loop
+#ifndef hasAVX2
+	CMPB	internal∕cpu·X86+const_offsetX86HasAVX2(SB), $1
+	JEQ     big_loop_avx2
+	JMP	big_loop
+#else
+	JMP	big_loop_avx2
+#endif
+loop:
+	CMPQ	R8, $16
+	JBE	_0through16
+	MOVOU	(SI), X0
+	MOVOU	(DI), X1
+	PCMPEQB X0, X1
+	PMOVMSKB X1, AX
+	XORQ	$0xffff, AX	// convert EQ to NE
+	JNE	diff16	// branch if at least one byte is not equal
+	ADDQ	$16, SI
+	ADDQ	$16, DI
+	SUBQ	$16, R8
+	JMP	loop
+
+diff64:
+	ADDQ	$48, SI
+	ADDQ	$48, DI
+	JMP	diff16
+diff48:
+	ADDQ	$32, SI
+	ADDQ	$32, DI
+	JMP	diff16
+diff32:
+	ADDQ	$16, SI
+	ADDQ	$16, DI
+	// AX = bit mask of differences
+diff16:
+	BSFQ	AX, BX	// index of first byte that differs
+	XORQ	AX, AX
+	MOVB	(SI)(BX*1), CX
+	CMPB	CX, (DI)(BX*1)
+	SETHI	AX
+	LEAQ	-1(AX*2), AX	// convert 1/0 to +1/-1
+	RET
+
+	// 0 through 16 bytes left, alen>=8, blen>=8
+_0through16:
+	CMPQ	R8, $8
+	JBE	_0through8
+	MOVQ	(SI), AX
+	MOVQ	(DI), CX
+	CMPQ	AX, CX
+	JNE	diff8
+_0through8:
+	MOVQ	-8(SI)(R8*1), AX
+	MOVQ	-8(DI)(R8*1), CX
+	CMPQ	AX, CX
+	JEQ	allsame
+
+	// AX and CX contain parts of a and b that differ.
+diff8:
+	BSWAPQ	AX	// reverse order of bytes
+	BSWAPQ	CX
+	XORQ	AX, CX
+	BSRQ	CX, CX	// index of highest bit difference
+	SHRQ	CX, AX	// move a's bit to bottom
+	ANDQ	$1, AX	// mask bit
+	LEAQ	-1(AX*2), AX // 1/0 => +1/-1
+	RET
+
+	// 0-7 bytes in common
+small:
+	LEAQ	(R8*8), CX	// bytes left -> bits left
+	NEGQ	CX		//  - bits lift (== 64 - bits left mod 64)
+	JEQ	allsame
+
+	// load bytes of a into high bytes of AX
+	CMPB	SI, $0xf8
+	JA	si_high
+	MOVQ	(SI), SI
+	JMP	si_finish
+si_high:
+	MOVQ	-8(SI)(R8*1), SI
+	SHRQ	CX, SI
+si_finish:
+	SHLQ	CX, SI
+
+	// load bytes of b in to high bytes of BX
+	CMPB	DI, $0xf8
+	JA	di_high
+	MOVQ	(DI), DI
+	JMP	di_finish
+di_high:
+	MOVQ	-8(DI)(R8*1), DI
+	SHRQ	CX, DI
+di_finish:
+	SHLQ	CX, DI
+
+	BSWAPQ	SI	// reverse order of bytes
+	BSWAPQ	DI
+	XORQ	SI, DI	// find bit differences
+	JEQ	allsame
+	BSRQ	DI, CX	// index of highest bit difference
+	SHRQ	CX, SI	// move a's bit to bottom
+	ANDQ	$1, SI	// mask bit
+	LEAQ	-1(SI*2), AX // 1/0 => +1/-1
+	RET
+
+allsame:
+	XORQ	AX, AX
+	XORQ	CX, CX
+	CMPQ	BX, DX
+	SETGT	AX	// 1 if alen > blen
+	SETEQ	CX	// 1 if alen == blen
+	LEAQ	-1(CX)(AX*2), AX	// 1,0,-1 result
+	RET
+
+	// this works for >= 64 bytes of data.
+#ifndef hasAVX2
+big_loop:
+	MOVOU	(SI), X0
+	MOVOU	(DI), X1
+	PCMPEQB X0, X1
+	PMOVMSKB X1, AX
+	XORQ	$0xffff, AX
+	JNE	diff16
+
+	MOVOU	16(SI), X0
+	MOVOU	16(DI), X1
+	PCMPEQB X0, X1
+	PMOVMSKB X1, AX
+	XORQ	$0xffff, AX
+	JNE	diff32
+
+	MOVOU	32(SI), X0
+	MOVOU	32(DI), X1
+	PCMPEQB X0, X1
+	PMOVMSKB X1, AX
+	XORQ	$0xffff, AX
+	JNE	diff48
+
+	MOVOU	48(SI), X0
+	MOVOU	48(DI), X1
+	PCMPEQB X0, X1
+	PMOVMSKB X1, AX
+	XORQ	$0xffff, AX
+	JNE	diff64
+
+	ADDQ	$64, SI
+	ADDQ	$64, DI
+	SUBQ	$64, R8
+	CMPQ	R8, $64
+	JBE	loop
+	JMP	big_loop
+#endif
+
+	// Compare 64-bytes per loop iteration.
+	// Loop is unrolled and uses AVX2.
+big_loop_avx2:
+	VMOVDQU	(SI), Y2
+	VMOVDQU	(DI), Y3
+	VMOVDQU	32(SI), Y4
+	VMOVDQU	32(DI), Y5
+	VPCMPEQB Y2, Y3, Y0
+	VPMOVMSKB Y0, AX
+	XORL	$0xffffffff, AX
+	JNE	diff32_avx2
+	VPCMPEQB Y4, Y5, Y6
+	VPMOVMSKB Y6, AX
+	XORL	$0xffffffff, AX
+	JNE	diff64_avx2
+
+	ADDQ	$64, SI
+	ADDQ	$64, DI
+	SUBQ	$64, R8
+	CMPQ	R8, $64
+	JB	big_loop_avx2_exit
+	JMP	big_loop_avx2
+
+	// Avoid AVX->SSE transition penalty and search first 32 bytes of 64 byte chunk.
+diff32_avx2:
+	VZEROUPPER
+	JMP diff16
+
+	// Same as diff32_avx2, but for last 32 bytes.
+diff64_avx2:
+	VZEROUPPER
+	JMP diff48
+
+	// For <64 bytes remainder jump to normal loop.
+big_loop_avx2_exit:
+	VZEROUPPER
+	JMP loop

go/src/internal/bytealg/compare_arm.s

@@ -0,0 +1,86 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#include "go_asm.h"
+#include "textflag.h"
+
+TEXT ·Compare(SB),NOSPLIT|NOFRAME,$0-28
+	MOVW	a_base+0(FP), R2
+	MOVW	a_len+4(FP), R0
+	MOVW	b_base+12(FP), R3
+	MOVW	b_len+16(FP), R1
+	ADD	$28, R13, R7
+	B	cmpbody<>(SB)
+
+TEXT runtime·cmpstring(SB),NOSPLIT|NOFRAME,$0-20
+	MOVW	a_base+0(FP), R2
+	MOVW	a_len+4(FP), R0
+	MOVW	b_base+8(FP), R3
+	MOVW	b_len+12(FP), R1
+	ADD	$20, R13, R7
+	B	cmpbody<>(SB)
+
+// On entry:
+// R0 is the length of a
+// R1 is the length of b
+// R2 points to the start of a
+// R3 points to the start of b
+// R7 points to return value (-1/0/1 will be written here)
+//
+// On exit:
+// R4, R5, R6 and R8 are clobbered
+TEXT cmpbody<>(SB),NOSPLIT|NOFRAME,$0-0
+	CMP	R2, R3
+	BEQ	samebytes
+	CMP 	R0, R1
+	MOVW 	R0, R6
+	MOVW.LT	R1, R6		// R6 is min(R0, R1)
+
+	CMP	$0, R6
+	BEQ	samebytes
+	CMP	$4, R6
+	ADD	R2, R6		// R2 is current byte in a, R6 is the end of the range to compare
+	BLT	byte_loop	// length < 4
+	AND	$3, R2, R8
+	CMP	$0, R8
+	BNE	byte_loop	// unaligned a, use byte-wise compare (TODO: try to align a)
+aligned_a:
+	AND	$3, R3, R8
+	CMP	$0, R8
+	BNE	byte_loop	// unaligned b, use byte-wise compare
+	AND	$0xfffffffc, R6, R8
+	// length >= 4
+chunk4_loop:
+	MOVW.P	4(R2), R4
+	MOVW.P	4(R3), R5
+	CMP	R4, R5
+	BNE	cmp
+	CMP	R2, R8
+	BNE	chunk4_loop
+	CMP	R2, R6
+	BEQ	samebytes	// all compared bytes were the same; compare lengths
+byte_loop:
+	MOVBU.P	1(R2), R4
+	MOVBU.P	1(R3), R5
+	CMP	R4, R5
+	BNE	ret
+	CMP	R2, R6
+	BNE	byte_loop
+samebytes:
+	CMP	R0, R1
+	MOVW.LT	$1, R0
+	MOVW.GT	$-1, R0
+	MOVW.EQ	$0, R0
+	MOVW	R0, (R7)
+	RET
+ret:
+	// bytes differed
+	MOVW.LT	$1, R0
+	MOVW.GT	$-1, R0
+	MOVW	R0, (R7)
+	RET
+cmp:
+	SUB	$4, R2, R2
+	SUB	$4, R3, R3
+	B	byte_loop

go/src/internal/bytealg/compare_arm64.s

@@ -0,0 +1,125 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#include "go_asm.h"
+#include "textflag.h"
+
+TEXT ·Compare<ABIInternal>(SB),NOSPLIT|NOFRAME,$0-56
+	// R0 = a_base (want in R0)
+	// R1 = a_len  (want in R1)
+	// R2 = a_cap  (unused)
+	// R3 = b_base (want in R2)
+	// R4 = b_len  (want in R3)
+	// R5 = b_cap  (unused)
+	MOVD	R3, R2
+	MOVD	R4, R3
+	B	cmpbody<>(SB)
+
+TEXT runtime·cmpstring<ABIInternal>(SB),NOSPLIT|NOFRAME,$0-40
+	// R0 = a_base
+	// R1 = a_len
+	// R2 = b_base
+	// R3 = b_len
+	B	cmpbody<>(SB)
+
+// On entry:
+// R0 points to the start of a
+// R1 is the length of a
+// R2 points to the start of b
+// R3 is the length of b
+//
+// On exit:
+// R0 is the result
+// R4, R5, R6, R8, R9 and R10 are clobbered
+TEXT cmpbody<>(SB),NOSPLIT|NOFRAME,$0-0
+	CMP	R0, R2
+	BEQ	samebytes         // same starting pointers; compare lengths
+	CMP	R1, R3
+	CSEL	LT, R3, R1, R6    // R6 is min(R1, R3)
+
+	CBZ	R6, samebytes
+	BIC	$0xf, R6, R10
+	CBZ	R10, small        // length < 16
+	ADD	R0, R10           // end of chunk16
+	// length >= 16
+chunk16_loop:
+	LDP.P	16(R0), (R4, R8)
+	LDP.P	16(R2), (R5, R9)
+	CMP	R4, R5
+	BNE	cmp
+	CMP	R8, R9
+	BNE	cmpnext
+	CMP	R10, R0
+	BNE	chunk16_loop
+	AND	$0xf, R6, R6
+	CBZ	R6, samebytes
+	SUBS	$8, R6
+	BLT	tail
+	// the length of tail > 8 bytes
+	MOVD.P	8(R0), R4
+	MOVD.P	8(R2), R5
+	CMP	R4, R5
+	BNE	cmp
+	SUB	$8, R6
+	// compare last 8 bytes
+tail:
+	MOVD	(R0)(R6), R4
+	MOVD	(R2)(R6), R5
+	CMP	R4, R5
+	BEQ	samebytes
+cmp:
+	REV	R4, R4
+	REV	R5, R5
+	CMP	R4, R5
+ret:
+	MOVD	$1, R0
+	CNEG	HI, R0, R0
+	RET
+small:
+	TBZ	$3, R6, lt_8
+	MOVD	(R0), R4
+	MOVD	(R2), R5
+	CMP	R4, R5
+	BNE	cmp
+	SUBS	$8, R6
+	BEQ	samebytes
+	ADD	$8, R0
+	ADD	$8, R2
+	SUB	$8, R6
+	B	tail
+lt_8:
+	TBZ	$2, R6, lt_4
+	MOVWU	(R0), R4
+	MOVWU	(R2), R5
+	CMPW	R4, R5
+	BNE	cmp
+	SUBS	$4, R6
+	BEQ	samebytes
+	ADD	$4, R0
+	ADD	$4, R2
+lt_4:
+	TBZ	$1, R6, lt_2
+	MOVHU	(R0), R4
+	MOVHU	(R2), R5
+	CMPW	R4, R5
+	BNE	cmp
+	ADD	$2, R0
+	ADD	$2, R2
+lt_2:
+	TBZ	$0, R6, samebytes
+one:
+	MOVBU	(R0), R4
+	MOVBU	(R2), R5
+	CMPW	R4, R5
+	BNE	ret
+samebytes:
+	CMP	R3, R1
+	CSET	NE, R0
+	CNEG	LO, R0, R0
+	RET
+cmpnext:
+	REV	R8, R4
+	REV	R9, R5
+	CMP	R4, R5
+	B	ret

go/src/internal/bytealg/compare_generic.go

@@ -0,0 +1,76 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build !386 && !amd64 && !s390x && !arm && !arm64 && !loong64 && !ppc64 && !ppc64le && !mips && !mipsle && !wasm && !mips64 && !mips64le && !riscv64
+
+package bytealg
+
+import _ "unsafe" // for go:linkname
+
+func Compare(a, b []byte) int {
+	l := len(a)
+	if len(b) < l {
+		l = len(b)
+	}
+	if l == 0 || &a[0] == &b[0] {
+		goto samebytes
+	}
+	for i := 0; i < l; i++ {
+		c1, c2 := a[i], b[i]
+		if c1 < c2 {
+			return -1
+		}
+		if c1 > c2 {
+			return +1
+		}
+	}
+samebytes:
+	if len(a) < len(b) {
+		return -1
+	}
+	if len(a) > len(b) {
+		return +1
+	}
+	return 0
+}
+
+func CompareString(a, b string) int {
+	return runtime_cmpstring(a, b)
+}
+
+// runtime.cmpstring calls are emitted by the compiler.
+//
+// runtime.cmpstring should be an internal detail,
+// but widely used packages access it using linkname.
+// Notable members of the hall of shame include:
+//   - gitee.com/zhaochuninhefei/gmgo
+//   - github.com/bytedance/gopkg
+//   - github.com/songzhibin97/gkit
+//
+// Do not remove or change the type signature.
+// See go.dev/issue/67401.
+//
+//go:linkname runtime_cmpstring runtime.cmpstring
+func runtime_cmpstring(a, b string) int {
+	l := len(a)
+	if len(b) < l {
+		l = len(b)
+	}
+	for i := 0; i < l; i++ {
+		c1, c2 := a[i], b[i]
+		if c1 < c2 {
+			return -1
+		}
+		if c1 > c2 {
+			return +1
+		}
+	}
+	if len(a) < len(b) {
+		return -1
+	}
+	if len(a) > len(b) {
+		return +1
+	}
+	return 0
+}

go/src/internal/bytealg/compare_loong64.s

@@ -0,0 +1,363 @@
+// Copyright 2022 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#include "go_asm.h"
+#include "textflag.h"
+
+TEXT ·Compare<ABIInternal>(SB),NOSPLIT,$0-56
+	// R4 = a_base
+	// R5 = a_len
+	// R6 = a_cap (unused)
+	// R7 = b_base (want in R6)
+	// R8 = b_len (want in R7)
+	// R9 = b_cap (unused)
+	MOVV	R7, R6
+	MOVV	R8, R7
+	JMP	cmpbody<>(SB)
+
+TEXT runtime·cmpstring<ABIInternal>(SB),NOSPLIT,$0-40
+	// R4 = a_base
+	// R5 = a_len
+	// R6 = b_base
+	// R7 = b_len
+	JMP	cmpbody<>(SB)
+
+// input:
+//    R4: points to the start of a
+//    R5: length of a
+//    R6: points to the start of b
+//    R7: length of b
+// for regabi the return value (-1/0/1) in R4
+TEXT cmpbody<>(SB),NOSPLIT|NOFRAME,$0
+	BEQ	R4, R6, cmp_len	// same start of a and b, then compare lengths
+
+	SGTU	R5, R7, R9
+	BNE	R9, b_lt_a
+	MOVV	R5, R14
+	JMP	entry
+
+b_lt_a:
+	MOVV	R7, R14
+
+entry:
+	BEQ	R14, cmp_len	// minlength is 0
+
+	MOVV	$32, R15
+	BGE	R14, R15, lasx
+tail:
+	MOVV	$8, R15
+	BLT	R14, R15, lt_8
+generic8_loop:
+	MOVV	(R4), R10
+	MOVV	(R6), R11
+	BEQ	R10, R11, generic8_equal
+
+cmp8:
+	AND	$0xff, R10, R16
+	AND	$0xff, R11, R17
+	BNE	R16, R17, cmp_byte
+
+	BSTRPICKV	$15, R10, $8, R16
+	BSTRPICKV	$15, R11, $8, R17
+	BNE	R16, R17, cmp_byte
+
+	BSTRPICKV	$23, R10, $16, R16
+	BSTRPICKV	$23, R11, $16, R17
+	BNE	R16, R17, cmp_byte
+
+	BSTRPICKV	$31, R10, $24, R16
+	BSTRPICKV	$31, R11, $24, R17
+	BNE	R16, R17, cmp_byte
+
+	BSTRPICKV	$39, R10, $32, R16
+	BSTRPICKV	$39, R11, $32, R17
+	BNE	R16, R17, cmp_byte
+
+	BSTRPICKV	$47, R10, $40, R16
+	BSTRPICKV	$47, R11, $40, R17
+	BNE	R16, R17, cmp_byte
+
+	BSTRPICKV	$55, R10, $48, R16
+	BSTRPICKV	$55, R11, $48, R17
+	BNE	R16, R17, cmp_byte
+
+	BSTRPICKV	$63, R10, $56, R16
+	BSTRPICKV	$63, R11, $56, R17
+	BNE	R16, R17, cmp_byte
+
+generic8_equal:
+	ADDV	$-8, R14
+	BEQ	R14, cmp_len
+	ADDV	$8, R4
+	ADDV	$8, R6
+	BGE	R14, R15, generic8_loop
+
+lt_8:
+	MOVV	$4, R15
+	BLT	R14, R15, lt_4
+
+	MOVWU	(R4), R10
+	MOVWU	(R6), R11
+	BEQ	R10, R11, lt_8_equal
+
+	AND	$0xff, R10, R16
+	AND	$0xff, R11, R17
+	BNE	R16, R17, cmp_byte
+
+	BSTRPICKV	$15, R10, $8, R16
+	BSTRPICKV	$15, R11, $8, R17
+	BNE	R16, R17, cmp_byte
+
+	BSTRPICKV	$23, R10, $16, R16
+	BSTRPICKV	$23, R11, $16, R17
+	BNE	R16, R17, cmp_byte
+
+	BSTRPICKV	$31, R10, $24, R16
+	BSTRPICKV	$31, R11, $24, R17
+	BNE	R16, R17, cmp_byte
+
+lt_8_equal:
+	ADDV	$-4, R14
+	BEQ	R14, cmp_len
+	ADDV	$4, R4
+	ADDV	$4, R6
+
+lt_4:
+	MOVV	$2, R15
+	BLT	R14, R15, lt_2
+
+	MOVHU	(R4), R10
+	MOVHU	(R6), R11
+	BEQ	R10, R11, lt_4_equal
+
+	AND	$0xff, R10, R16
+	AND	$0xff, R11, R17
+	BNE	R16, R17, cmp_byte
+
+	BSTRPICKV	$15, R10, $8, R16
+	BSTRPICKV	$15, R11, $8, R17
+	BNE	R16, R17, cmp_byte
+
+lt_4_equal:
+	ADDV	$-2, R14
+	BEQ	R14, cmp_len
+	ADDV	$2, R4
+	ADDV	$2, R6
+
+lt_2:
+	MOVBU	(R4), R16
+	MOVBU	(R6), R17
+	BNE	R16, R17, cmp_byte
+	JMP	cmp_len
+
+	// Compare 1 byte taken from R16/R17 that are known to differ.
+cmp_byte:
+	SGTU	R16, R17, R4	// R4 = 1 if (R16 > R17)
+	BNE	R0, R4, ret
+	MOVV	$-1, R4
+	RET
+
+cmp_len:
+	SGTU	R5, R7, R8
+	SGTU	R7, R5, R9
+	SUBV	R9, R8, R4
+
+ret:
+	RET
+
+lasx:
+	MOVV	$64, R20
+	MOVBU	internal∕cpu·Loong64+const_offsetLOONG64HasLASX(SB), R9
+	BEQ	R9, lsx
+
+	MOVV	$128, R15
+	BLT	R14, R15, lasx32_loop
+lasx128_loop:
+	XVMOVQ	(R4), X0
+	XVMOVQ	(R6), X1
+	XVSEQB	X0, X1, X0
+	XVSETANYEQB	X0, FCC0
+	BFPT	lasx_found_0
+
+	XVMOVQ	32(R4), X0
+	XVMOVQ	32(R6), X1
+	XVSEQB	X0, X1, X0
+	XVSETANYEQB	X0, FCC0
+	BFPT	lasx_found_32
+
+	XVMOVQ	64(R4), X0
+	XVMOVQ	64(R6), X1
+	XVSEQB	X0, X1, X0
+	XVSETANYEQB	X0, FCC0
+	BFPT	lasx_found_64
+
+	XVMOVQ	96(R4), X0
+	XVMOVQ	96(R6), X1
+	XVSEQB	X0, X1, X0
+	XVSETANYEQB	X0, FCC0
+	BFPT	lasx_found_96
+
+	ADDV	$-128, R14
+	BEQ	R14, cmp_len
+	ADDV	$128, R4
+	ADDV	$128, R6
+	BGE	R14, R15, lasx128_loop
+
+	MOVV	$32, R15
+	BLT	R14, R15, tail
+lasx32_loop:
+	XVMOVQ	(R4), X0
+	XVMOVQ	(R6), X1
+	XVSEQB	X0, X1, X0
+	XVSETANYEQB	X0, FCC0
+	BFPT	lasx_found_0
+
+	ADDV	$-32, R14
+	BEQ	R14, cmp_len
+	ADDV	$32, R4
+	ADDV	$32, R6
+	BGE	R14, R15, lasx32_loop
+	JMP	tail
+
+lasx_found_0:
+	MOVV	R0, R11
+	JMP	lasx_find_byte
+
+lasx_found_32:
+	MOVV	$32, R11
+	JMP	lasx_find_byte
+
+lasx_found_64:
+	MOVV	$64, R11
+	JMP	lasx_find_byte
+
+lasx_found_96:
+	MOVV	$96, R11
+
+lasx_find_byte:
+	XVMOVQ	X0.V[0], R10
+	CTOV	R10, R10
+	BNE	R10, R20, find_byte
+	ADDV	$8, R11
+
+	XVMOVQ	X0.V[1], R10
+	CTOV	R10, R10
+	BNE	R10, R20, find_byte
+	ADDV	$8, R11
+
+	XVMOVQ	X0.V[2], R10
+	CTOV	R10, R10
+	BNE	R10, R20, find_byte
+	ADDV	$8, R11
+
+	XVMOVQ	X0.V[3], R10
+	CTOV	R10, R10
+	JMP	find_byte
+
+lsx:
+	MOVBU	internal∕cpu·Loong64+const_offsetLOONG64HasLSX(SB), R9
+	BEQ	R9, generic32_loop
+
+	MOVV	$64, R15
+	BLT	R14, R15, lsx16_loop
+lsx64_loop:
+	VMOVQ	(R4), V0
+	VMOVQ	(R6), V1
+	VSEQB	V0, V1, V0
+	VSETANYEQB	V0, FCC0
+	BFPT	lsx_found_0
+
+	VMOVQ	16(R4), V0
+	VMOVQ	16(R6), V1
+	VSEQB	V0, V1, V0
+	VSETANYEQB	V0, FCC0
+	BFPT	lsx_found_16
+
+	VMOVQ	32(R4), V0
+	VMOVQ	32(R6), V1
+	VSEQB	V0, V1, V0
+	VSETANYEQB	V0, FCC0
+	BFPT	lsx_found_32
+
+	VMOVQ	48(R4), V0
+	VMOVQ	48(R6), V1
+	VSEQB	V0, V1, V0
+	VSETANYEQB	V0, FCC0
+	BFPT	lsx_found_48
+
+	ADDV	$-64, R14
+	BEQ	R14, cmp_len
+	ADDV	$64, R4
+	ADDV	$64, R6
+	BGE	R14, R15, lsx64_loop
+
+	MOVV	$16, R15
+	BLT	R14, R15, tail
+lsx16_loop:
+	VMOVQ	(R4), V0
+	VMOVQ	(R6), V1
+	VSEQB	V0, V1, V0
+	VSETANYEQB	V0, FCC0
+	BFPT	lsx_found_0
+
+	ADDV	$-16, R14
+	BEQ	R14, cmp_len
+	ADDV	$16, R4
+	ADDV	$16, R6
+	BGE	R14, R15, lsx16_loop
+	JMP	tail
+
+lsx_found_0:
+	MOVV	R0, R11
+	JMP	lsx_find_byte
+
+lsx_found_16:
+	MOVV	$16, R11
+	JMP	lsx_find_byte
+
+lsx_found_32:
+	MOVV	$32, R11
+	JMP	lsx_find_byte
+
+lsx_found_48:
+	MOVV	$48, R11
+
+lsx_find_byte:
+	VMOVQ	V0.V[0], R10
+	CTOV	R10, R10
+	BNE	R10, R20, find_byte
+	ADDV	$8, R11
+
+	VMOVQ	V0.V[1], R10
+	CTOV	R10, R10
+
+find_byte:
+	SRLV	$3, R10
+	ADDV	R10, R11
+	ADDV	R11, R4
+	ADDV	R11, R6
+	MOVB	(R4), R16
+	MOVB	(R6), R17
+	JMP	cmp_byte
+
+generic32_loop:
+	MOVV	(R4), R10
+	MOVV	(R6), R11
+	BNE	R10, R11, cmp8
+	MOVV	8(R4), R10
+	MOVV	8(R6), R11
+	BNE	R10, R11, cmp8
+	MOVV	16(R4), R10
+	MOVV	16(R6), R11
+	BNE	R10, R11, cmp8
+	MOVV	24(R4), R10
+	MOVV	24(R6), R11
+	BNE	R10, R11, cmp8
+	ADDV	$-32, R14
+	BEQ	R14, cmp_len
+	ADDV	$32, R4
+	ADDV	$32, R6
+	MOVV	$32, R15
+	BGE	R14, R15, generic32_loop
+	JMP	tail

go/src/internal/bytealg/compare_mips64x.s

@@ -0,0 +1,88 @@
+// Copyright 2019 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build mips64 || mips64le
+
+#include "go_asm.h"
+#include "textflag.h"
+
+TEXT ·Compare(SB),NOSPLIT,$0-56
+	MOVV	a_base+0(FP), R3
+	MOVV	b_base+24(FP), R4
+	MOVV	a_len+8(FP), R1
+	MOVV	b_len+32(FP), R2
+	MOVV	$ret+48(FP), R9
+	JMP	cmpbody<>(SB)
+
+TEXT runtime·cmpstring(SB),NOSPLIT,$0-40
+	MOVV	a_base+0(FP), R3
+	MOVV	b_base+16(FP), R4
+	MOVV	a_len+8(FP), R1
+	MOVV	b_len+24(FP), R2
+	MOVV	$ret+32(FP), R9
+	JMP	cmpbody<>(SB)
+
+// On entry:
+// R1 length of a
+// R2 length of b
+// R3 points to the start of a
+// R4 points to the start of b
+// R9 points to the return value (-1/0/1)
+TEXT cmpbody<>(SB),NOSPLIT|NOFRAME,$0
+	BEQ	R3, R4, samebytes // same start of a and b
+
+	SGTU	R1, R2, R7
+	BNE	R0, R7, r2_lt_r1
+	MOVV	R1, R10
+	JMP	entry
+r2_lt_r1:
+	MOVV	R2, R10	// R10 is min(R1, R2)
+entry:
+	ADDV	R3, R10, R8	// R3 start of a, R8 end of a
+	BEQ	R3, R8, samebytes // length is 0
+
+	SRLV	$4, R10		// R10 is number of chunks
+	BEQ	R0, R10, byte_loop
+
+	// make sure both a and b are aligned.
+	OR	R3, R4, R11
+	AND	$7, R11
+	BNE	R0, R11, byte_loop
+
+chunk16_loop:
+	BEQ	R0, R10, byte_loop
+	MOVV	(R3), R6
+	MOVV	(R4), R7
+	BNE	R6, R7, byte_loop
+	MOVV	8(R3), R13
+	MOVV	8(R4), R14
+	ADDV	$16, R3
+	ADDV	$16, R4
+	SUBVU	$1, R10
+	BEQ	R13, R14, chunk16_loop
+	SUBV	$8, R3
+	SUBV	$8, R4
+
+byte_loop:
+	BEQ	R3, R8, samebytes
+	MOVBU	(R3), R6
+	ADDVU	$1, R3
+	MOVBU	(R4), R7
+	ADDVU	$1, R4
+	BEQ	R6, R7, byte_loop
+
+byte_cmp:
+	SGTU	R6, R7, R8 // R8 = 1 if (R6 > R7)
+	BNE	R0, R8, ret
+	MOVV	$-1, R8
+	JMP	ret
+
+samebytes:
+	SGTU	R1, R2, R6
+	SGTU	R2, R1, R7
+	SUBV	R7, R6, R8
+
+ret:
+	MOVV	R8, (R9)
+	RET

go/src/internal/bytealg/compare_mipsx.s

@@ -0,0 +1,72 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build mips || mipsle
+
+#include "go_asm.h"
+#include "textflag.h"
+
+TEXT ·Compare(SB),NOSPLIT,$0-28
+	MOVW	a_base+0(FP), R3
+	MOVW	b_base+12(FP), R4
+	MOVW	a_len+4(FP), R1
+	MOVW	b_len+16(FP), R2
+	BEQ	R3, R4, samebytes
+	SGTU	R1, R2, R7
+	MOVW	R1, R8
+	CMOVN	R7, R2, R8	// R8 is min(R1, R2)
+
+	ADDU	R3, R8	// R3 is current byte in a, R8 is last byte in a to compare
+loop:
+	BEQ	R3, R8, samebytes
+
+	MOVBU	(R3), R6
+	ADDU	$1, R3
+	MOVBU	(R4), R7
+	ADDU	$1, R4
+	BEQ	R6, R7 , loop
+
+	SGTU	R6, R7, R8
+	MOVW	$-1, R6
+	CMOVZ	R8, R6, R8
+	JMP	cmp_ret
+samebytes:
+	SGTU	R1, R2, R6
+	SGTU	R2, R1, R7
+	SUBU	R7, R6, R8
+cmp_ret:
+	MOVW	R8, ret+24(FP)
+	RET
+
+TEXT runtime·cmpstring(SB),NOSPLIT,$0-20
+	MOVW	a_base+0(FP), R3
+	MOVW	a_len+4(FP), R1
+	MOVW	b_base+8(FP), R4
+	MOVW	b_len+12(FP), R2
+	BEQ	R3, R4, samebytes
+	SGTU	R1, R2, R7
+	MOVW	R1, R8
+	CMOVN	R7, R2, R8	// R8 is min(R1, R2)
+
+	ADDU	R3, R8	// R3 is current byte in a, R8 is last byte in a to compare
+loop:
+	BEQ	R3, R8, samebytes	// all compared bytes were the same; compare lengths
+
+	MOVBU	(R3), R6
+	ADDU	$1, R3
+	MOVBU	(R4), R7
+	ADDU	$1, R4
+	BEQ	R6, R7 , loop
+	// bytes differed
+	SGTU	R6, R7, R8
+	MOVW	$-1, R6
+	CMOVZ	R8, R6, R8
+	JMP	cmp_ret
+samebytes:
+	SGTU	R1, R2, R6
+	SGTU	R2, R1, R7
+	SUBU	R7, R6, R8
+cmp_ret:
+	MOVW	R8, ret+16(FP)
+	RET

go/src/internal/bytealg/compare_native.go

@@ -0,0 +1,23 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build 386 || amd64 || s390x || arm || arm64 || loong64 || ppc64 || ppc64le || mips || mipsle || wasm || mips64 || mips64le || riscv64
+
+package bytealg
+
+import _ "unsafe" // For go:linkname
+
+//go:noescape
+func Compare(a, b []byte) int
+
+func CompareString(a, b string) int {
+	return abigen_runtime_cmpstring(a, b)
+}
+
+// The declaration below generates ABI wrappers for functions
+// implemented in assembly in this package but declared in another
+// package.
+
+//go:linkname abigen_runtime_cmpstring runtime.cmpstring
+func abigen_runtime_cmpstring(a, b string) int

go/src/internal/bytealg/compare_ppc64x.s

@@ -0,0 +1,342 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:build ppc64 || ppc64le
+
+#include "go_asm.h"
+#include "textflag.h"
+
+// Helper names for x-form loads in BE ordering.
+#ifdef  GOARCH_ppc64le
+#define _LDBEX	MOVDBR
+#define _LWBEX	MOVWBR
+#define _LHBEX	MOVHBR
+#else
+#define _LDBEX	MOVD
+#define _LWBEX	MOVW
+#define _LHBEX	MOVH
+#endif
+
+#ifdef GOPPC64_power9
+#define SETB_CR0(rout) SETB CR0, rout
+#define SETB_CR1(rout) SETB CR1, rout
+#define SETB_INIT()
+#define SETB_CR0_NE(rout) SETB_CR0(rout)
+#else
+// A helper macro to emulate SETB on P8. This assumes
+// -1 is in R20, and 1 is in R21. crxlt and crxeq must
+// also be the same CR field.
+#define _SETB(crxlt, crxeq, rout) \
+	ISEL	crxeq,R0,R21,rout \
+	ISEL	crxlt,R20,rout,rout
+
+// A special case when it is know the comparison
+// will always be not equal. The result must be -1 or 1.
+#define SETB_CR0_NE(rout) \
+	ISEL	CR0LT,R20,R21,rout
+
+#define SETB_CR0(rout) _SETB(CR0LT, CR0EQ, rout)
+#define SETB_CR1(rout) _SETB(CR1LT, CR1EQ, rout)
+#define SETB_INIT() \
+	MOVD	$-1,R20 \
+	MOVD	$1,R21
+#endif
+
+TEXT ·Compare<ABIInternal>(SB),NOSPLIT|NOFRAME,$0-56
+	// incoming:
+	// R3 a addr
+	// R4 a len
+	// R6 b addr
+	// R7 b len
+	//
+	// on entry to cmpbody:
+	// R3 return value if len(a) == len(b)
+	// R5 a addr
+	// R6 b addr
+	// R9 min(len(a),len(b))
+	SETB_INIT()
+	MOVD	R3,R5
+	CMP	R4,R7,CR0
+	CMP	R3,R6,CR7
+	ISEL	CR0LT,R4,R7,R9
+	SETB_CR0(R3)
+	BEQ	CR7,LR
+	BR	cmpbody<>(SB)
+
+TEXT runtime·cmpstring<ABIInternal>(SB),NOSPLIT|NOFRAME,$0-40
+	// incoming:
+	// R3 a addr -> R5
+	// R4 a len  -> R3
+	// R5 b addr -> R6
+	// R6 b len  -> R4
+	//
+	// on entry to cmpbody:
+	// R3 compare value if compared length is same.
+	// R5 a addr
+	// R6 b addr
+	// R9 min(len(a),len(b))
+	SETB_INIT()
+	CMP	R4,R6,CR0
+	CMP	R3,R5,CR7
+	ISEL	CR0LT,R4,R6,R9
+	MOVD	R5,R6
+	MOVD	R3,R5
+	SETB_CR0(R3)
+	BEQ	CR7,LR
+	BR	cmpbody<>(SB)
+
+#ifdef GOARCH_ppc64le
+DATA byteswap<>+0(SB)/8, $0x0706050403020100
+DATA byteswap<>+8(SB)/8, $0x0f0e0d0c0b0a0908
+GLOBL byteswap<>+0(SB), RODATA, $16
+#define SWAP V21
+#endif
+
+TEXT cmpbody<>(SB),NOSPLIT|NOFRAME,$0-0
+start:
+	CMP	R9,$16,CR0
+	CMP	R9,$32,CR1
+	CMP	R9,$64,CR2
+	MOVD	$16,R10
+	BLT	cmp8
+	BLT	CR1,cmp16
+	BLT	CR2,cmp32
+
+cmp64:	// >= 64B
+	DCBT	(R5)		// optimize for size>=64
+	DCBT	(R6)		// cache hint
+
+	SRD	$6,R9,R14	// There is at least one iteration.
+	MOVD	R14,CTR
+	ANDCC   $63,R9,R9
+	CMP	R9,$16,CR1	// Do setup for tail check early on.
+	CMP	R9,$32,CR2
+	CMP	R9,$48,CR3
+	ADD	$-16,R9,R9
+
+	MOVD	$32,R11		// set offsets to load into vector
+	MOVD	$48,R12		// set offsets to load into vector
+
+	PCALIGN	$16
+cmp64_loop:
+	LXVD2X	(R5)(R0),V3	// load bytes of A at offset 0 into vector
+	LXVD2X	(R6)(R0),V4	// load bytes of B at offset 0 into vector
+	VCMPEQUDCC	V3,V4,V1
+	BGE	CR6,different	// jump out if its different
+
+	LXVD2X	(R5)(R10),V3	// load bytes of A at offset 16 into vector
+	LXVD2X	(R6)(R10),V4	// load bytes of B at offset 16 into vector
+	VCMPEQUDCC	V3,V4,V1
+	BGE	CR6,different
+
+	LXVD2X	(R5)(R11),V3	// load bytes of A at offset 32 into vector
+	LXVD2X	(R6)(R11),V4	// load bytes of B at offset 32 into vector
+	VCMPEQUDCC	V3,V4,V1
+	BGE	CR6,different
+
+	LXVD2X	(R5)(R12),V3	// load bytes of A at offset 64 into vector
+	LXVD2X	(R6)(R12),V4	// load bytes of B at offset 64 into vector
+	VCMPEQUDCC	V3,V4,V1
+	BGE	CR6,different
+
+	ADD	$64,R5,R5	// increment to next 64 bytes of A
+	ADD	$64,R6,R6	// increment to next 64 bytes of B
+	BDNZ	cmp64_loop
+	BEQ	CR0,LR		// beqlr
+
+	// Finish out tail with minimal overlapped checking.
+	// Note, 0 tail is handled by beqlr above.
+	BLE	CR1,cmp64_tail_gt0
+	BLE	CR2,cmp64_tail_gt16
+	BLE	CR3,cmp64_tail_gt32
+
+cmp64_tail_gt48: // 49 - 63 B
+	LXVD2X	(R0)(R5),V3
+	LXVD2X	(R0)(R6),V4
+	VCMPEQUDCC	V3,V4,V1
+	BGE	CR6,different
+
+	LXVD2X	(R5)(R10),V3
+	LXVD2X	(R6)(R10),V4
+	VCMPEQUDCC	V3,V4,V1
+	BGE	CR6,different
+
+	LXVD2X	(R5)(R11),V3
+	LXVD2X	(R6)(R11),V4
+	VCMPEQUDCC	V3,V4,V1
+	BGE	CR6,different
+
+	BR cmp64_tail_gt0
+
+	PCALIGN $16
+cmp64_tail_gt32: // 33 - 48B
+	LXVD2X	(R0)(R5),V3
+	LXVD2X	(R0)(R6),V4
+	VCMPEQUDCC	V3,V4,V1
+	BGE	CR6,different
+
+	LXVD2X	(R5)(R10),V3
+	LXVD2X	(R6)(R10),V4
+	VCMPEQUDCC	V3,V4,V1
+	BGE	CR6,different
+
+	BR cmp64_tail_gt0
+
+	PCALIGN $16
+cmp64_tail_gt16: // 17 - 32B
+	LXVD2X	(R0)(R5),V3
+	LXVD2X	(R0)(R6),V4
+	VCMPEQUDCC	V3,V4,V1
+	BGE	CR6,different
+
+	BR cmp64_tail_gt0
+
+	PCALIGN $16
+cmp64_tail_gt0: // 1 - 16B
+	LXVD2X	(R5)(R9),V3
+	LXVD2X	(R6)(R9),V4
+	VCMPEQUDCC	V3,V4,V1
+	BGE	CR6,different
+
+	RET
+
+	PCALIGN $16
+cmp32:	// 32 - 63B
+	ANDCC	$31,R9,R9
+
+	LXVD2X	(R0)(R5),V3
+	LXVD2X	(R0)(R6),V4
+	VCMPEQUDCC	V3,V4,V1
+	BGE	CR6,different
+
+	LXVD2X	(R10)(R5),V3
+	LXVD2X	(R10)(R6),V4
+	VCMPEQUDCC	V3,V4,V1
+	BGE	CR6,different
+
+	BEQ	CR0,LR
+	ADD	R9,R10,R10
+
+	LXVD2X	(R9)(R5),V3
+	LXVD2X	(R9)(R6),V4
+	VCMPEQUDCC	V3,V4,V1
+	BGE	CR6,different
+
+	LXVD2X	(R10)(R5),V3
+	LXVD2X	(R10)(R6),V4
+	VCMPEQUDCC	V3,V4,V1
+	BGE	CR6,different
+	RET
+
+	PCALIGN $16
+cmp16:	// 16 - 31B
+	ANDCC	$15,R9,R9
+	LXVD2X	(R0)(R5),V3
+	LXVD2X	(R0)(R6),V4
+	VCMPEQUDCC	V3,V4,V1
+	BGE	CR6,different
+	BEQ	CR0,LR
+
+	LXVD2X	(R9)(R5),V3
+	LXVD2X	(R9)(R6),V4
+	VCMPEQUDCC	V3,V4,V1
+	BGE	CR6,different
+	RET
+
+	PCALIGN $16
+different:
+#ifdef	GOARCH_ppc64le
+	MOVD	$byteswap<>+00(SB),R16
+	LXVD2X	(R16)(R0),SWAP	// Set up swap string
+
+	VPERM	V3,V3,SWAP,V3
+	VPERM	V4,V4,SWAP,V4
+#endif
+
+	MFVSRD	VS35,R16	// move upper doublewords of A and B into GPR for comparison
+	MFVSRD	VS36,R10
+
+	CMPU	R16,R10
+	BEQ	lower
+	SETB_CR0_NE(R3)
+	RET
+
+	PCALIGN $16
+lower:
+	VSLDOI	$8,V3,V3,V3	// move lower doublewords of A and B into GPR for comparison
+	MFVSRD	VS35,R16
+	VSLDOI	$8,V4,V4,V4
+	MFVSRD	VS36,R10
+
+	CMPU	R16,R10
+	SETB_CR0_NE(R3)
+	RET
+
+	PCALIGN $16
+cmp8:	// 8 - 15B (0 - 15B if GOPPC64_power10)
+#ifdef GOPPC64_power10
+	SLD	$56,R9,R9
+	LXVLL	R5,R9,V3	// Load bytes starting from MSB to LSB, unused are zero filled.
+	LXVLL	R6,R9,V4
+	VCMPUQ	V3,V4,CR0	// Compare as a 128b integer.
+	SETB_CR0(R6)
+	ISEL	CR0EQ,R3,R6,R3	// If equal, length determines the return value.
+	RET
+#else
+	CMP	R9,$8
+	BLT	cmp4
+	ANDCC	$7,R9,R9
+	_LDBEX	(R0)(R5),R10
+	_LDBEX	(R0)(R6),R11
+	_LDBEX	(R9)(R5),R12
+	_LDBEX	(R9)(R6),R14
+	CMPU	R10,R11,CR0
+	SETB_CR0(R5)
+	CMPU	R12,R14,CR1
+	SETB_CR1(R6)
+	CRAND   CR0EQ,CR1EQ,CR1EQ // If both equal, length determines return value.
+	ISEL	CR0EQ,R6,R5,R4
+	ISEL	CR1EQ,R3,R4,R3
+	RET
+
+	PCALIGN	$16
+cmp4:	// 4 - 7B
+	CMP	R9,$4
+	BLT	cmp2
+	ANDCC	$3,R9,R9
+	_LWBEX	(R0)(R5),R10
+	_LWBEX	(R0)(R6),R11
+	_LWBEX	(R9)(R5),R12
+	_LWBEX	(R9)(R6),R14
+	RLDIMI	$32,R10,$0,R12
+	RLDIMI	$32,R11,$0,R14
+	CMPU	R12,R14
+	BR	cmp0
+
+	PCALIGN $16
+cmp2:	// 2 - 3B
+	CMP	R9,$2
+	BLT	cmp1
+	ANDCC	$1,R9,R9
+	_LHBEX	(R0)(R5),R10
+	_LHBEX	(R0)(R6),R11
+	_LHBEX	(R9)(R5),R12
+	_LHBEX	(R9)(R6),R14
+	RLDIMI	$32,R10,$0,R12
+	RLDIMI	$32,R11,$0,R14
+	CMPU	R12,R14
+	BR	cmp0
+
+	PCALIGN $16
+cmp1:
+	CMP	R9,$0
+	BEQ	cmp0
+	MOVBZ	(R5),R10
+	MOVBZ	(R6),R11
+	CMPU	R10,R11
+cmp0:
+	SETB_CR0(R6)
+	ISEL	CR0EQ,R3,R6,R3
+	RET
+#endif

go/src/internal/bytealg/compare_riscv64.s

@@ -0,0 +1,259 @@
+// Copyright 2022 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#include "asm_riscv64.h"
+#include "go_asm.h"
+#include "textflag.h"
+
+TEXT ·Compare<ABIInternal>(SB),NOSPLIT|NOFRAME,$0-56
+	// X10 = a_base
+	// X11 = a_len
+	// X12 = a_cap (unused)
+	// X13 = b_base (want in X12)
+	// X14 = b_len (want in X13)
+	// X15 = b_cap (unused)
+	MOV	X13, X12
+	MOV	X14, X13
+	JMP	compare<>(SB)
+
+TEXT runtime·cmpstring<ABIInternal>(SB),NOSPLIT|NOFRAME,$0-40
+	// X10 = a_base
+	// X11 = a_len
+	// X12 = b_base
+	// X13 = b_len
+	JMP	compare<>(SB)
+
+// On entry:
+// X10 points to start of a
+// X11 length of a
+// X12 points to start of b
+// X13 length of b
+// return value in X10 (-1/0/1)
+TEXT compare<>(SB),NOSPLIT|NOFRAME,$0
+	BEQ	X10, X12, cmp_len
+
+	MIN	X11, X13, X5
+	BEQZ	X5, cmp_len
+
+	MOV	$16, X6
+	BLT	X5, X6, check8_unaligned
+
+#ifndef hasV
+	MOVB	internal∕cpu·RISCV64+const_offsetRISCV64HasV(SB), X6
+	BEQZ	X6, compare_scalar
+#endif
+
+	// Use vector if not 8 byte aligned.
+	OR	X10, X12, X6
+	AND	$7, X6
+	BNEZ	X6, vector_loop
+
+	// Use scalar if 8 byte aligned and <= 128 bytes.
+	SUB	$128, X5, X6
+	BLEZ	X6, compare_scalar_aligned
+
+	PCALIGN	$16
+vector_loop:
+	VSETVLI	X5, E8, M8, TA, MA, X6
+	VLE8V	(X10), V8
+	VLE8V	(X12), V16
+	VMSNEVV	V8, V16, V0
+	VFIRSTM	V0, X7
+	BGEZ	X7, vector_not_eq
+	ADD	X6, X10
+	ADD	X6, X12
+	SUB	X6, X5
+	BNEZ	X5, vector_loop
+	JMP	cmp_len
+
+vector_not_eq:
+	// Load first differing bytes in X8/X9.
+	ADD	X7, X10
+	ADD	X7, X12
+	MOVBU	(X10), X8
+	MOVBU	(X12), X9
+	JMP	cmp
+
+compare_scalar:
+	MOV	$32, X6
+	BLT	X5, X6, check8_unaligned
+
+	// Check alignment - if alignment differs we have to do one byte at a time.
+	AND	$7, X10, X7
+	AND	$7, X12, X8
+	BNE	X7, X8, check8_unaligned
+	BEQZ	X7, compare32
+
+	// Check one byte at a time until we reach 8 byte alignment.
+	SUB	X7, X0, X7
+	ADD	$8, X7, X7
+	SUB	X7, X5, X5
+align:
+	SUB	$1, X7
+	MOVBU	0(X10), X8
+	MOVBU	0(X12), X9
+	BNE	X8, X9, cmp
+	ADD	$1, X10
+	ADD	$1, X12
+	BNEZ	X7, align
+
+compare_scalar_aligned:
+	MOV	$32, X6
+	BLT	X5, X6, check16
+compare32:
+	MOV	0(X10), X15
+	MOV	0(X12), X16
+	MOV	8(X10), X17
+	MOV	8(X12), X18
+	BNE	X15, X16, cmp8a
+	BNE	X17, X18, cmp8b
+	MOV	16(X10), X15
+	MOV	16(X12), X16
+	MOV	24(X10), X17
+	MOV	24(X12), X18
+	BNE	X15, X16, cmp8a
+	BNE	X17, X18, cmp8b
+	ADD	$32, X10
+	ADD	$32, X12
+	SUB	$32, X5
+	BGE	X5, X6, compare32
+	BEQZ	X5, cmp_len
+
+check16:
+	MOV	$16, X6
+	BLT	X5, X6, check8_unaligned
+compare16:
+	MOV	0(X10), X15
+	MOV	0(X12), X16
+	MOV	8(X10), X17
+	MOV	8(X12), X18
+	BNE	X15, X16, cmp8a
+	BNE	X17, X18, cmp8b
+	ADD	$16, X10
+	ADD	$16, X12
+	SUB	$16, X5
+	BEQZ	X5, cmp_len
+
+check8_unaligned:
+	MOV	$8, X6
+	BLT	X5, X6, check4_unaligned
+compare8_unaligned:
+	MOVBU	0(X10), X8
+	MOVBU	1(X10), X15
+	MOVBU	2(X10), X17
+	MOVBU	3(X10), X19
+	MOVBU	4(X10), X21
+	MOVBU	5(X10), X23
+	MOVBU	6(X10), X25
+	MOVBU	7(X10), X29
+	MOVBU	0(X12), X9
+	MOVBU	1(X12), X16
+	MOVBU	2(X12), X18
+	MOVBU	3(X12), X20
+	MOVBU	4(X12), X22
+	MOVBU	5(X12), X24
+	MOVBU	6(X12), X28
+	MOVBU	7(X12), X30
+	BNE	X8, X9, cmp1a
+	BNE	X15, X16, cmp1b
+	BNE	X17, X18, cmp1c
+	BNE	X19, X20, cmp1d
+	BNE	X21, X22, cmp1e
+	BNE	X23, X24, cmp1f
+	BNE	X25, X28, cmp1g
+	BNE	X29, X30, cmp1h
+	ADD	$8, X10
+	ADD	$8, X12
+	SUB	$8, X5
+	BGE	X5, X6, compare8_unaligned
+	BEQZ	X5, cmp_len
+
+check4_unaligned:
+	MOV	$4, X6
+	BLT	X5, X6, compare1
+compare4_unaligned:
+	MOVBU	0(X10), X8
+	MOVBU	1(X10), X15
+	MOVBU	2(X10), X17
+	MOVBU	3(X10), X19
+	MOVBU	0(X12), X9
+	MOVBU	1(X12), X16
+	MOVBU	2(X12), X18
+	MOVBU	3(X12), X20
+	BNE	X8, X9, cmp1a
+	BNE	X15, X16, cmp1b
+	BNE	X17, X18, cmp1c
+	BNE	X19, X20, cmp1d
+	ADD	$4, X10
+	ADD	$4, X12
+	SUB	$4, X5
+	BGE	X5, X6, compare4_unaligned
+
+compare1:
+	BEQZ	X5, cmp_len
+	MOVBU	0(X10), X8
+	MOVBU	0(X12), X9
+	BNE	X8, X9, cmp
+	ADD	$1, X10
+	ADD	$1, X12
+	SUB	$1, X5
+	JMP	compare1
+
+	// Compare 8 bytes of memory in X15/X16 that are known to differ.
+cmp8a:
+	MOV	X15, X17
+	MOV	X16, X18
+
+	// Compare 8 bytes of memory in X17/X18 that are known to differ.
+cmp8b:
+	MOV	$0xff, X19
+cmp8_loop:
+	AND	X17, X19, X8
+	AND	X18, X19, X9
+	BNE	X8, X9, cmp
+	SLLI	$8, X19
+	JMP	cmp8_loop
+
+cmp1a:
+	SLTU	X9, X8, X5
+	SLTU	X8, X9, X6
+	JMP	cmp_ret
+cmp1b:
+	SLTU	X16, X15, X5
+	SLTU	X15, X16, X6
+	JMP	cmp_ret
+cmp1c:
+	SLTU	X18, X17, X5
+	SLTU	X17, X18, X6
+	JMP	cmp_ret
+cmp1d:
+	SLTU	X20, X19, X5
+	SLTU	X19, X20, X6
+	JMP	cmp_ret
+cmp1e:
+	SLTU	X22, X21, X5
+	SLTU	X21, X22, X6
+	JMP	cmp_ret
+cmp1f:
+	SLTU	X24, X23, X5
+	SLTU	X23, X24, X6
+	JMP	cmp_ret
+cmp1g:
+	SLTU	X28, X25, X5
+	SLTU	X25, X28, X6
+	JMP	cmp_ret
+cmp1h:
+	SLTU	X30, X29, X5
+	SLTU	X29, X30, X6
+	JMP	cmp_ret
+
+cmp_len:
+	MOV	X11, X8
+	MOV	X13, X9
+cmp:
+	SLTU	X9, X8, X5
+	SLTU	X8, X9, X6
+cmp_ret:
+	SUB	X5, X6, X10
+	RET

go/src/internal/bytealg/compare_s390x.s

@@ -0,0 +1,97 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#include "go_asm.h"
+#include "textflag.h"
+
+TEXT ·Compare<ABIInternal>(SB),NOSPLIT|NOFRAME,$0-56
+#ifndef GOEXPERIMENT_regabiargs
+	MOVD	a_base+0(FP), R2
+	MOVD	a_len+8(FP), R3
+	MOVD	b_base+24(FP), R4
+	MOVD	b_len+32(FP), R5
+	LA	ret+48(FP), R6
+#else
+	// R2 = a_base
+	// R3 = a_len
+	// R4 = a_cap (unused)
+	// R5 = b_base (want in R4)
+	// R6 = b_len (want in R5)
+	// R7 = b_cap (unused)
+	MOVD	R5, R4
+	MOVD	R6, R5
+#endif
+	BR	cmpbody<>(SB)
+
+TEXT runtime·cmpstring<ABIInternal>(SB),NOSPLIT|NOFRAME,$0-40
+#ifndef GOEXPERIMENT_regabiargs
+	MOVD	a_base+0(FP), R2
+	MOVD	a_len+8(FP), R3
+	MOVD	b_base+16(FP), R4
+	MOVD	b_len+24(FP), R5
+	LA	ret+32(FP), R6
+#endif
+	// R2 = a_base
+	// R3 = a_len
+	// R4 = b_base
+	// R5 = b_len
+
+	BR	cmpbody<>(SB)
+
+// input:
+//   R2 = a
+//   R3 = alen
+//   R4 = b
+//   R5 = blen
+//   For regabiargs output value( -1/0/1 ) stored in R2
+//   For !regabiargs address of output word( stores -1/0/1 ) stored in R6
+TEXT cmpbody<>(SB),NOSPLIT|NOFRAME,$0-0
+	CMPBEQ	R2, R4, cmplengths
+	MOVD	R3, R7
+	CMPBLE	R3, R5, amin
+	MOVD	R5, R7
+amin:
+	CMPBEQ	R7, $0, cmplengths
+	CMP	R7, $256
+	BLE	tail
+loop:
+	CLC	$256, 0(R2), 0(R4)
+	BGT	gt
+	BLT	lt
+	SUB	$256, R7
+	MOVD	$256(R2), R2
+	MOVD	$256(R4), R4
+	CMP	R7, $256
+	BGT	loop
+tail:
+	SUB	$1, R7
+	EXRL	$cmpbodyclc<>(SB), R7
+	BGT	gt
+	BLT	lt
+cmplengths:
+	CMP	R3, R5
+	BEQ	eq
+	BLT	lt
+gt:
+	MOVD	$1, R2
+#ifndef GOEXPERIMENT_regabiargs
+	MOVD	R2, 0(R6)
+#endif
+	RET
+lt:
+	MOVD	$-1, R2
+#ifndef GOEXPERIMENT_regabiargs
+	MOVD	R2, 0(R6)
+#endif
+	RET
+eq:
+	MOVD	$0, R2
+#ifndef GOEXPERIMENT_regabiargs
+	MOVD	R2, 0(R6)
+#endif
+	RET
+
+TEXT cmpbodyclc<>(SB),NOSPLIT|NOFRAME,$0-0
+	CLC	$1, 0(R2), 0(R4)
+	RET

go/src/internal/bytealg/compare_wasm.s

@@ -0,0 +1,115 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#include "go_asm.h"
+#include "textflag.h"
+
+TEXT ·Compare(SB), NOSPLIT, $0-56
+	Get SP
+	I64Load a_base+0(FP)
+	I64Load a_len+8(FP)
+	I64Load b_base+24(FP)
+	I64Load b_len+32(FP)
+	Call cmpbody<>(SB)
+	I64Store ret+48(FP)
+	RET
+
+TEXT runtime·cmpstring(SB), NOSPLIT, $0-40
+	Get SP
+	I64Load a_base+0(FP)
+	I64Load a_len+8(FP)
+	I64Load b_base+16(FP)
+	I64Load b_len+24(FP)
+	Call cmpbody<>(SB)
+	I64Store ret+32(FP)
+	RET
+
+// params: a, alen, b, blen
+// ret: -1/0/1
+TEXT cmpbody<>(SB), NOSPLIT, $0-0
+	// len = min(alen, blen)
+	Get R1
+	Get R3
+	Get R1
+	Get R3
+	I64LtU
+	Select
+	Set R4
+
+	Get R0
+	I32WrapI64
+	Get R2
+	I32WrapI64
+	Get R4
+	I32WrapI64
+	Call memcmp<>(SB)
+	I64ExtendI32S
+	Tee R5
+
+	I64Eqz
+	If
+		// check length
+		Get R1
+		Get R3
+		I64Sub
+		Set R5
+	End
+
+	I64Const $0
+	I64Const $-1
+	I64Const $1
+	Get R5
+	I64Const $0
+	I64LtS
+	Select
+	Get R5
+	I64Eqz
+	Select
+	Return
+
+// compiled with emscripten
+// params: a, b, len
+// ret: <0/0/>0
+TEXT memcmp<>(SB), NOSPLIT, $0-0
+	Get R2
+	If $1
+	Loop
+	Get R0
+	I32Load8S $0
+	Tee R3
+	Get R1
+	I32Load8S $0
+	Tee R4
+	I32Eq
+	If
+	Get R0
+	I32Const $1
+	I32Add
+	Set R0
+	Get R1
+	I32Const $1
+	I32Add
+	Set R1
+	I32Const $0
+	Get R2
+	I32Const $-1
+	I32Add
+	Tee R2
+	I32Eqz
+	BrIf $3
+	Drop
+	Br $1
+	End
+	End
+	Get R3
+	I32Const $255
+	I32And
+	Get R4
+	I32Const $255
+	I32And
+	I32Sub
+	Else
+	I32Const $0
+	End
+	Return

go/src/internal/bytealg/count_amd64.s

@@ -0,0 +1,229 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#include "go_asm.h"
+#include "asm_amd64.h"
+#include "textflag.h"
+
+TEXT ·Count(SB),NOSPLIT,$0-40
+#ifndef hasPOPCNT
+	CMPB	internal∕cpu·X86+const_offsetX86HasPOPCNT(SB), $1
+	JEQ	2(PC)
+	JMP	·countGeneric(SB)
+#endif
+	MOVQ	b_base+0(FP), SI
+	MOVQ	b_len+8(FP), BX
+	MOVB	c+24(FP), AL
+	LEAQ	ret+32(FP), R8
+	JMP	countbody<>(SB)
+
+TEXT ·CountString(SB),NOSPLIT,$0-32
+#ifndef hasPOPCNT
+	CMPB	internal∕cpu·X86+const_offsetX86HasPOPCNT(SB), $1
+	JEQ	2(PC)
+	JMP	·countGenericString(SB)
+#endif
+	MOVQ	s_base+0(FP), SI
+	MOVQ	s_len+8(FP), BX
+	MOVB	c+16(FP), AL
+	LEAQ	ret+24(FP), R8
+	JMP	countbody<>(SB)
+
+// input:
+//   SI: data
+//   BX: data len
+//   AL: byte sought
+//   R8: address to put result
+// This function requires the POPCNT instruction.
+TEXT countbody<>(SB),NOSPLIT,$0
+	// Shuffle X0 around so that each byte contains
+	// the character we're looking for.
+	MOVD AX, X0
+	PUNPCKLBW X0, X0
+	PUNPCKLBW X0, X0
+	PSHUFL $0, X0, X0
+
+	CMPQ BX, $16
+	JLT small
+
+	MOVQ $0, R12 // Accumulator
+
+	MOVQ SI, DI
+
+	CMPQ BX, $64
+	JAE avx2
+sse:
+	LEAQ	-16(SI)(BX*1), AX	// AX = address of last 16 bytes
+	JMP	sseloopentry
+
+	PCALIGN $16
+sseloop:
+	// Move the next 16-byte chunk of the data into X1.
+	MOVOU	(DI), X1
+	// Compare bytes in X0 to X1.
+	PCMPEQB	X0, X1
+	// Take the top bit of each byte in X1 and put the result in DX.
+	PMOVMSKB X1, DX
+	// Count number of matching bytes
+	POPCNTL DX, DX
+	// Accumulate into R12
+	ADDQ DX, R12
+	// Advance to next block.
+	ADDQ	$16, DI
+sseloopentry:
+	CMPQ	DI, AX
+	JBE	sseloop
+
+	// Get the number of bytes to consider in the last 16 bytes
+	ANDQ $15, BX
+	JZ end
+
+	// Create mask to ignore overlap between previous 16 byte block
+	// and the next.
+	MOVQ $16,CX
+	SUBQ BX, CX
+	MOVQ $0xFFFF, R10
+	SARQ CL, R10
+	SALQ CL, R10
+
+	// Process the last 16-byte chunk. This chunk may overlap with the
+	// chunks we've already searched so we need to mask part of it.
+	MOVOU	(AX), X1
+	PCMPEQB	X0, X1
+	PMOVMSKB X1, DX
+	// Apply mask
+	ANDQ R10, DX
+	POPCNTL DX, DX
+	ADDQ DX, R12
+end:
+	MOVQ R12, (R8)
+	RET
+
+// handle for lengths < 16
+small:
+	TESTQ	BX, BX
+	JEQ	endzero
+
+	// Check if we'll load across a page boundary.
+	LEAQ	16(SI), AX
+	TESTW	$0xff0, AX
+	JEQ	endofpage
+
+	// We must ignore high bytes as they aren't part of our slice.
+	// Create mask.
+	MOVB BX, CX
+	MOVQ $1, R10
+	SALQ CL, R10
+	SUBQ $1, R10
+
+	// Load data
+	MOVOU	(SI), X1
+	// Compare target byte with each byte in data.
+	PCMPEQB	X0, X1
+	// Move result bits to integer register.
+	PMOVMSKB X1, DX
+	// Apply mask
+	ANDQ R10, DX
+	POPCNTL DX, DX
+	// Directly return DX, we don't need to accumulate
+	// since we have <16 bytes.
+	MOVQ	DX, (R8)
+	RET
+endzero:
+	MOVQ $0, (R8)
+	RET
+
+endofpage:
+	// We must ignore low bytes as they aren't part of our slice.
+	MOVQ $16,CX
+	SUBQ BX, CX
+	MOVQ $0xFFFF, R10
+	SARQ CL, R10
+	SALQ CL, R10
+
+	// Load data into the high end of X1.
+	MOVOU	-16(SI)(BX*1), X1
+	// Compare target byte with each byte in data.
+	PCMPEQB	X0, X1
+	// Move result bits to integer register.
+	PMOVMSKB X1, DX
+	// Apply mask
+	ANDQ R10, DX
+	// Directly return DX, we don't need to accumulate
+	// since we have <16 bytes.
+	POPCNTL DX, DX
+	MOVQ	DX, (R8)
+	RET
+
+avx2:
+#ifndef hasAVX2
+	CMPB   internal∕cpu·X86+const_offsetX86HasAVX2(SB), $1
+	JNE sse
+#endif
+	MOVD AX, X0
+	LEAQ -64(SI)(BX*1), R11
+	LEAQ (SI)(BX*1), R13
+	VPBROADCASTB  X0, Y1
+	PCALIGN $32
+avx2_loop:
+	VMOVDQU (DI), Y2
+	VMOVDQU 32(DI), Y4
+	VPCMPEQB Y1, Y2, Y3
+	VPCMPEQB Y1, Y4, Y5
+	VPMOVMSKB Y3, DX
+	VPMOVMSKB Y5, CX
+	POPCNTL DX, DX
+	POPCNTL CX, CX
+	ADDQ DX, R12
+	ADDQ CX, R12
+	ADDQ $64, DI
+	CMPQ DI, R11
+	JLE avx2_loop
+
+	// If last block is already processed,
+	// skip to the end.
+	//
+	// This check is NOT an optimization; if the input length is a
+	// multiple of 64, we must not go through the last leg of the
+	// function because the bit shift count passed to SALQ below would
+	// be 64, which is outside of the 0-63 range supported by those
+	// instructions.
+	//
+	// Tests in the bytes and strings packages with input lengths that
+	// are multiples of 64 will break if this condition were removed.
+	CMPQ DI, R13
+	JEQ endavx
+
+	// Load address of the last 64 bytes.
+	// There is an overlap with the previous block.
+	MOVQ R11, DI
+	VMOVDQU (DI), Y2
+	VMOVDQU 32(DI), Y4
+	VPCMPEQB Y1, Y2, Y3
+	VPCMPEQB Y1, Y4, Y5
+	VPMOVMSKB Y3, DX
+	VPMOVMSKB Y5, CX
+	// Exit AVX mode.
+	VZEROUPPER
+	SALQ $32, CX
+	ORQ CX, DX
+
+	// Create mask to ignore overlap between previous 64 byte block
+	// and the next.
+	ANDQ $63, BX
+	MOVQ $64, CX
+	SUBQ BX, CX
+	MOVQ $0xFFFFFFFFFFFFFFFF, R10
+	SALQ CL, R10
+	// Apply mask
+	ANDQ R10, DX
+	POPCNTQ DX, DX
+	ADDQ DX, R12
+	MOVQ R12, (R8)
+	RET
+endavx:
+	// Exit AVX mode.
+	VZEROUPPER
+	MOVQ R12, (R8)
+	RET

go/src/internal/bytealg/count_arm.s

@@ -0,0 +1,43 @@
+// Copyright 2019 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#include "go_asm.h"
+#include "textflag.h"
+
+TEXT ·Count(SB),NOSPLIT,$0-20
+	MOVW	b_base+0(FP), R0
+	MOVW	b_len+4(FP), R1
+	MOVBU	c+12(FP), R2
+	MOVW	$ret+16(FP), R7
+	B	countbytebody<>(SB)
+
+TEXT ·CountString(SB),NOSPLIT,$0-16
+	MOVW	s_base+0(FP), R0
+	MOVW	s_len+4(FP), R1
+	MOVBU	c+8(FP), R2
+	MOVW	$ret+12(FP), R7
+	B	countbytebody<>(SB)
+
+// Input:
+// R0: data
+// R1: data length
+// R2: byte to find
+// R7: address to put result
+//
+// On exit:
+// R4 and R8 are clobbered
+TEXT countbytebody<>(SB),NOSPLIT,$0
+	MOVW	$0, R8	// R8 = count of byte to search
+	CMP	$0, R1
+	B.EQ	done	// short path to handle 0-byte case
+	ADD	R0, R1	// R1 is the end of the range
+byte_loop:
+	MOVBU.P	1(R0), R4
+	CMP	R4, R2
+	ADD.EQ	$1, R8
+	CMP	R0, R1
+	B.NE	byte_loop
+done:
+	MOVW	R8, (R7)
+	RET

go/src/internal/bytealg/count_arm64.s

@@ -0,0 +1,94 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+#include "go_asm.h"
+#include "textflag.h"
+
+// func Count(b []byte, c byte) int
+// input:
+//   R0: b ptr
+//   R1: b len
+//   R2: b cap
+//   R3: c byte to search
+// return:
+//   R0: result
+TEXT ·Count<ABIInternal>(SB),NOSPLIT,$0-40
+	MOVD	R3, R2
+	B	·CountString<ABIInternal>(SB)
+
+// func CountString(s string, c byte) int
+// input:
+//   R0: s ptr
+//   R1: s len
+//   R2: c byte to search (due to ABIInternal upper bits can contain junk)
+// return:
+//   R0: result
+TEXT ·CountString<ABIInternal>(SB),NOSPLIT,$0-32
+	// R11 = count of byte to search
+	MOVD	$0, R11
+	// short path to handle 0-byte case
+	CBZ	R1, done
+	CMP	$0x20, R1
+	// jump directly to head if length >= 32
+	BHS	head
+tail:
+	// Work with tail shorter than 32 bytes
+	MOVBU.P	1(R0), R5
+	SUB	$1, R1, R1
+	CMP	R2.UXTB, R5
+	CINC	EQ, R11, R11
+	CBNZ	R1, tail
+done:
+	MOVD	R11, R0
+	RET
+	PCALIGN	$16
+head:
+	ANDS	$0x1f, R0, R9
+	BEQ	chunk
+	// Work with not 32-byte aligned head
+	BIC	$0x1f, R0, R3
+	ADD	$0x20, R3
+	PCALIGN $16
+head_loop:
+	MOVBU.P	1(R0), R5
+	CMP	R2.UXTB, R5
+	CINC	EQ, R11, R11
+	SUB	$1, R1, R1
+	CMP	R0, R3
+	BNE	head_loop
+chunk:
+	BIC	$0x1f, R1, R9
+	// The first chunk can also be the last
+	CBZ	R9, tail
+	// R3 = end of 32-byte chunks
+	ADD	R0, R9, R3
+	MOVD	$1, R5
+	VMOV	R5, V5.B16
+	// R1 = length of tail
+	SUB	R9, R1, R1
+	// Duplicate R2 (byte to search) to 16 1-byte elements of V0
+	VMOV	R2, V0.B16
+	// Clear the low 64-bit element of V7 and V8
+	VEOR	V7.B8, V7.B8, V7.B8
+	VEOR	V8.B8, V8.B8, V8.B8
+	PCALIGN $16
+	// Count the target byte in 32-byte chunk
+chunk_loop:
+	VLD1.P	(R0), [V1.B16, V2.B16]
+	CMP	R0, R3
+	VCMEQ	V0.B16, V1.B16, V3.B16
+	VCMEQ	V0.B16, V2.B16, V4.B16
+	// Clear the higher 7 bits
+	VAND	V5.B16, V3.B16, V3.B16
+	VAND	V5.B16, V4.B16, V4.B16
+	// Count lanes match the requested byte
+	VADDP	V4.B16, V3.B16, V6.B16 // 32B->16B
+	VUADDLV	V6.B16, V7
+	// Accumulate the count in low 64-bit element of V8 when inside the loop
+	VADD	V7, V8
+	BNE	chunk_loop
+	VMOV	V8.D[0], R6
+	ADD	R6, R11, R11
+	CBZ	R1, done
+	B	tail