[release-branch.go1.24] go1.24.1

Change-Id: I774fcee39151f830ad58fd1677239bc0207c6679 Reviewed-on: https://go-review.googlesource.com/c/go/+/654319 Auto-Submit: Gopher Robot <gobot@golang.org> Auto-Submit: Junyang Shao <shaojunyang@google.com> Reviewed-by: Michael Pratt <mpratt@google.com> Reviewed-by: Junyang Shao <shaojunyang@google.com> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
[release-branch.go1.24] all: updated vendored x/net with security fix
2026-01-30 15:42:04 +03:00 · 2025-03-04 11:27:08 -08:00 · 2025-03-04 10:41:47 -08:00 · 2025-02-26 14:41:34 -08:00 · 2025-02-26 12:15:08 -08:00 · 2025-02-26 12:04:21 -08:00
4058 changed files with 132981 additions and 490661 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -30,7 +30,6 @@ _testmain.go
 /misc/cgo/testso/main
 /pkg/
 /src/*.*/
-/src/_artifacts/
 /src/cmd/cgo/zdefaultcc.go
 /src/cmd/dist/dist
 /src/cmd/go/internal/cfg/zdefaultcc.go
--- a/2
+++ b/2
@@ -0,0 +1,2 @@
+go1.24.1
+time 2025-02-27T17:57:18Z
--- a/api/go1.25.txt
+++ b/api/go1.25.txt
@@ -1,111 +0,0 @@
-pkg crypto, func SignMessage(Signer, io.Reader, []uint8, SignerOpts) ([]uint8, error) #63405
-pkg crypto, type MessageSigner interface { Public, Sign, SignMessage } #63405
-pkg crypto, type MessageSigner interface, Public() PublicKey #63405
-pkg crypto, type MessageSigner interface, Sign(io.Reader, []uint8, SignerOpts) ([]uint8, error) #63405
-pkg crypto, type MessageSigner interface, SignMessage(io.Reader, []uint8, SignerOpts) ([]uint8, error) #63405
-pkg crypto/ecdsa, func ParseRawPrivateKey(elliptic.Curve, []uint8) (*PrivateKey, error) #63963
-pkg crypto/ecdsa, func ParseUncompressedPublicKey(elliptic.Curve, []uint8) (*PublicKey, error) #63963
-pkg crypto/ecdsa, method (*PrivateKey) Bytes() ([]uint8, error) #63963
-pkg crypto/ecdsa, method (*PublicKey) Bytes() ([]uint8, error) #63963
-pkg crypto/sha3, method (*SHA3) Clone() (hash.Cloner, error) #69521
-pkg crypto/tls, type Config struct, GetEncryptedClientHelloKeys func(*ClientHelloInfo) ([]EncryptedClientHelloKey, error) #71920
-pkg crypto/tls, type ConnectionState struct, CurveID CurveID #67516
-pkg debug/elf, const PT_RISCV_ATTRIBUTES = 1879048195 #72843
-pkg debug/elf, const PT_RISCV_ATTRIBUTES ProgType #72843
-pkg debug/elf, const SHT_RISCV_ATTRIBUTES = 1879048195 #72843
-pkg debug/elf, const SHT_RISCV_ATTRIBUTES SectionType #72843
-pkg go/ast, const FilterFuncDuplicates //deprecated #73088
-pkg go/ast, const FilterImportDuplicates //deprecated #73088
-pkg go/ast, const FilterUnassociatedComments //deprecated #73088
-pkg go/ast, func FilterPackage //deprecated #73088
-pkg go/ast, func MergePackageFiles //deprecated #73088
-pkg go/ast, func PackageExports //deprecated #73088
-pkg go/ast, func PreorderStack(Node, []Node, func(Node, []Node) bool) #73319
-pkg go/ast, type MergeMode //deprecated #73088
-pkg go/parser, func ParseDir //deprecated #71122
-pkg go/token, method (*FileSet) AddExistingFiles(...*File) #73205
-pkg go/types, const FieldVar = 6 #70250
-pkg go/types, const FieldVar VarKind #70250
-pkg go/types, const LocalVar = 2 #70250
-pkg go/types, const LocalVar VarKind #70250
-pkg go/types, const PackageVar = 1 #70250
-pkg go/types, const PackageVar VarKind #70250
-pkg go/types, const ParamVar = 4 #70250
-pkg go/types, const ParamVar VarKind #70250
-pkg go/types, const RecvVar = 3 #70250
-pkg go/types, const RecvVar VarKind #70250
-pkg go/types, const ResultVar = 5 #70250
-pkg go/types, const ResultVar VarKind #70250
-pkg go/types, func LookupSelection(Type, bool, *Package, string) (Selection, bool) #70737
-pkg go/types, method (*Var) Kind() VarKind #70250
-pkg go/types, method (*Var) SetKind(VarKind) #70250
-pkg go/types, method (VarKind) String() string #70250
-pkg go/types, type VarKind uint8 #70250
-pkg hash, type Cloner interface { BlockSize, Clone, Reset, Size, Sum, Write } #69521
-pkg hash, type Cloner interface, BlockSize() int #69521
-pkg hash, type Cloner interface, Clone() (Cloner, error) #69521
-pkg hash, type Cloner interface, Reset() #69521
-pkg hash, type Cloner interface, Size() int #69521
-pkg hash, type Cloner interface, Sum([]uint8) []uint8 #69521
-pkg hash, type Cloner interface, Write([]uint8) (int, error) #69521
-pkg hash, type XOF interface { BlockSize, Read, Reset, Write } #69518
-pkg hash, type XOF interface, BlockSize() int #69518
-pkg hash, type XOF interface, Read([]uint8) (int, error) #69518
-pkg hash, type XOF interface, Reset() #69518
-pkg hash, type XOF interface, Write([]uint8) (int, error) #69518
-pkg hash/maphash, method (*Hash) Clone() (hash.Cloner, error) #69521
-pkg io/fs, func Lstat(FS, string) (FileInfo, error) #49580
-pkg io/fs, func ReadLink(FS, string) (string, error) #49580
-pkg io/fs, type ReadLinkFS interface { Lstat, Open, ReadLink } #49580
-pkg io/fs, type ReadLinkFS interface, Lstat(string) (FileInfo, error) #49580
-pkg io/fs, type ReadLinkFS interface, Open(string) (File, error) #49580
-pkg io/fs, type ReadLinkFS interface, ReadLink(string) (string, error) #49580
-pkg log/slog, func GroupAttrs(string, ...Attr) Attr #66365
-pkg log/slog, method (Record) Source() *Source #70280
-pkg mime/multipart, func FileContentDisposition(string, string) string #46771
-pkg net/http, func NewCrossOriginProtection() *CrossOriginProtection #73626
-pkg net/http, method (*CrossOriginProtection) AddInsecureBypassPattern(string) #73626
-pkg net/http, method (*CrossOriginProtection) AddTrustedOrigin(string) error #73626
-pkg net/http, method (*CrossOriginProtection) Check(*Request) error #73626
-pkg net/http, method (*CrossOriginProtection) Handler(Handler) Handler #73626
-pkg net/http, method (*CrossOriginProtection) SetDenyHandler(Handler) #73626
-pkg net/http, type CrossOriginProtection struct #73626
-pkg os, method (*Root) Chmod(string, fs.FileMode) error #67002
-pkg os, method (*Root) Chown(string, int, int) error #67002
-pkg os, method (*Root) Chtimes(string, time.Time, time.Time) error #67002
-pkg os, method (*Root) Lchown(string, int, int) error #67002
-pkg os, method (*Root) Link(string, string) error #67002
-pkg os, method (*Root) MkdirAll(string, fs.FileMode) error #67002
-pkg os, method (*Root) ReadFile(string) ([]uint8, error) #73126
-pkg os, method (*Root) Readlink(string) (string, error) #67002
-pkg os, method (*Root) RemoveAll(string) error #67002
-pkg os, method (*Root) Rename(string, string) error #67002
-pkg os, method (*Root) Symlink(string, string) error #67002
-pkg os, method (*Root) WriteFile(string, []uint8, fs.FileMode) error #73126
-pkg reflect, func TypeAssert[$0 interface{}](Value) ($0, bool) #62121
-pkg runtime, func SetDefaultGOMAXPROCS() #73193
-pkg runtime/trace, func NewFlightRecorder(FlightRecorderConfig) *FlightRecorder #63185
-pkg runtime/trace, method (*FlightRecorder) Enabled() bool #63185
-pkg runtime/trace, method (*FlightRecorder) Start() error #63185
-pkg runtime/trace, method (*FlightRecorder) Stop() #63185
-pkg runtime/trace, method (*FlightRecorder) WriteTo(io.Writer) (int64, error) #63185
-pkg runtime/trace, type FlightRecorder struct #63185
-pkg runtime/trace, type FlightRecorderConfig struct #63185
-pkg runtime/trace, type FlightRecorderConfig struct, MaxBytes uint64 #63185
-pkg runtime/trace, type FlightRecorderConfig struct, MinAge time.Duration #63185
-pkg sync, method (*WaitGroup) Go(func()) #63796
-pkg testing, method (*B) Attr(string, string) #43936
-pkg testing, method (*B) Output() io.Writer #59928
-pkg testing, method (*F) Attr(string, string) #43936
-pkg testing, method (*F) Output() io.Writer #59928
-pkg testing, method (*T) Attr(string, string) #43936
-pkg testing, method (*T) Output() io.Writer #59928
-pkg testing, type TB interface, Attr(string, string) #43936
-pkg testing, type TB interface, Output() io.Writer #59928
-pkg testing/fstest, method (MapFS) Lstat(string) (fs.FileInfo, error) #49580
-pkg testing/fstest, method (MapFS) ReadLink(string) (string, error) #49580
-pkg testing/synctest, func Test(*testing.T, func(*testing.T)) #67434
-pkg testing/synctest, func Wait() #67434
-pkg unicode, var CategoryAliases map[string]string #70780
-pkg unicode, var Cn *RangeTable #70780
-pkg unicode, var LC *RangeTable #70780
--- a/api/go1.26.txt
+++ b/api/go1.26.txt
@@ -1,180 +0,0 @@
-pkg bytes, method (*Buffer) Peek(int) ([]uint8, error) #73794
-pkg crypto, type Decapsulator interface { Decapsulate, Encapsulator } #75300
-pkg crypto, type Decapsulator interface, Decapsulate([]uint8) ([]uint8, error) #75300
-pkg crypto, type Decapsulator interface, Encapsulator() Encapsulator #75300
-pkg crypto, type Encapsulator interface { Bytes, Encapsulate } #75300
-pkg crypto, type Encapsulator interface, Bytes() []uint8 #75300
-pkg crypto, type Encapsulator interface, Encapsulate() ([]uint8, []uint8) #75300
-pkg crypto/ecdh, type KeyExchanger interface { Curve, ECDH, PublicKey } #75300
-pkg crypto/ecdh, type KeyExchanger interface, Curve() Curve #75300
-pkg crypto/ecdh, type KeyExchanger interface, ECDH(*PublicKey) ([]uint8, error) #75300
-pkg crypto/ecdh, type KeyExchanger interface, PublicKey() *PublicKey #75300
-pkg crypto/ecdsa, type PrivateKey struct, D //deprecated #63963
-pkg crypto/ecdsa, type PublicKey struct, X //deprecated #63963
-pkg crypto/ecdsa, type PublicKey struct, Y //deprecated #63963
-pkg crypto/fips140, func Enforced() bool #74630
-pkg crypto/fips140, func Version() string #75301
-pkg crypto/fips140, func WithoutEnforcement(func()) #74630
-pkg crypto/hpke, func AES128GCM() AEAD #75300
-pkg crypto/hpke, func AES256GCM() AEAD #75300
-pkg crypto/hpke, func ChaCha20Poly1305() AEAD #75300
-pkg crypto/hpke, func DHKEM(ecdh.Curve) KEM #75300
-pkg crypto/hpke, func ExportOnly() AEAD #75300
-pkg crypto/hpke, func HKDFSHA256() KDF #75300
-pkg crypto/hpke, func HKDFSHA384() KDF #75300
-pkg crypto/hpke, func HKDFSHA512() KDF #75300
-pkg crypto/hpke, func MLKEM1024() KEM #75300
-pkg crypto/hpke, func MLKEM1024P384() KEM #75300
-pkg crypto/hpke, func MLKEM768() KEM #75300
-pkg crypto/hpke, func MLKEM768P256() KEM #75300
-pkg crypto/hpke, func MLKEM768X25519() KEM #75300
-pkg crypto/hpke, func NewAEAD(uint16) (AEAD, error) #75300
-pkg crypto/hpke, func NewDHKEMPrivateKey(ecdh.KeyExchanger) (PrivateKey, error) #75300
-pkg crypto/hpke, func NewDHKEMPublicKey(*ecdh.PublicKey) (PublicKey, error) #75300
-pkg crypto/hpke, func NewHybridPrivateKey(crypto.Decapsulator, ecdh.KeyExchanger) (PrivateKey, error) #75300
-pkg crypto/hpke, func NewHybridPublicKey(crypto.Encapsulator, *ecdh.PublicKey) (PublicKey, error) #75300
-pkg crypto/hpke, func NewKDF(uint16) (KDF, error) #75300
-pkg crypto/hpke, func NewKEM(uint16) (KEM, error) #75300
-pkg crypto/hpke, func NewMLKEMPrivateKey(crypto.Decapsulator) (PrivateKey, error) #75300
-pkg crypto/hpke, func NewMLKEMPublicKey(crypto.Encapsulator) (PublicKey, error) #75300
-pkg crypto/hpke, func NewRecipient([]uint8, PrivateKey, KDF, AEAD, []uint8) (*Recipient, error) #75300
-pkg crypto/hpke, func NewSender(PublicKey, KDF, AEAD, []uint8) ([]uint8, *Sender, error) #75300
-pkg crypto/hpke, func Open(PrivateKey, KDF, AEAD, []uint8, []uint8) ([]uint8, error) #75300
-pkg crypto/hpke, func SHAKE128() KDF #75300
-pkg crypto/hpke, func SHAKE256() KDF #75300
-pkg crypto/hpke, func Seal(PublicKey, KDF, AEAD, []uint8, []uint8) ([]uint8, error) #75300
-pkg crypto/hpke, method (*Recipient) Export(string, int) ([]uint8, error) #75300
-pkg crypto/hpke, method (*Recipient) Open([]uint8, []uint8) ([]uint8, error) #75300
-pkg crypto/hpke, method (*Sender) Export(string, int) ([]uint8, error) #75300
-pkg crypto/hpke, method (*Sender) Seal([]uint8, []uint8) ([]uint8, error) #75300
-pkg crypto/hpke, type AEAD interface, ID() uint16 #75300
-pkg crypto/hpke, type AEAD interface, unexported methods #75300
-pkg crypto/hpke, type KDF interface, ID() uint16 #75300
-pkg crypto/hpke, type KDF interface, unexported methods #75300
-pkg crypto/hpke, type KEM interface, DeriveKeyPair([]uint8) (PrivateKey, error) #75300
-pkg crypto/hpke, type KEM interface, GenerateKey() (PrivateKey, error) #75300
-pkg crypto/hpke, type KEM interface, ID() uint16 #75300
-pkg crypto/hpke, type KEM interface, NewPrivateKey([]uint8) (PrivateKey, error) #75300
-pkg crypto/hpke, type KEM interface, NewPublicKey([]uint8) (PublicKey, error) #75300
-pkg crypto/hpke, type KEM interface, unexported methods #75300
-pkg crypto/hpke, type PrivateKey interface, Bytes() ([]uint8, error) #75300
-pkg crypto/hpke, type PrivateKey interface, KEM() KEM #75300
-pkg crypto/hpke, type PrivateKey interface, PublicKey() PublicKey #75300
-pkg crypto/hpke, type PrivateKey interface, unexported methods #75300
-pkg crypto/hpke, type PublicKey interface, Bytes() []uint8 #75300
-pkg crypto/hpke, type PublicKey interface, KEM() KEM #75300
-pkg crypto/hpke, type PublicKey interface, unexported methods #75300
-pkg crypto/hpke, type Recipient struct #75300
-pkg crypto/hpke, type Sender struct #75300
-pkg crypto/mlkem, method (*DecapsulationKey1024) Encapsulator() crypto.Encapsulator #75300
-pkg crypto/mlkem, method (*DecapsulationKey768) Encapsulator() crypto.Encapsulator #75300
-pkg crypto/mlkem/mlkemtest, func Encapsulate1024(*mlkem.EncapsulationKey1024, []uint8) ([]uint8, []uint8, error) #73627
-pkg crypto/mlkem/mlkemtest, func Encapsulate768(*mlkem.EncapsulationKey768, []uint8) ([]uint8, []uint8, error) #73627
-pkg crypto/rsa, func DecryptPKCS1v15 //deprecated #75302
-pkg crypto/rsa, func DecryptPKCS1v15SessionKey //deprecated #75302
-pkg crypto/rsa, func EncryptOAEPWithOptions(io.Reader, *PublicKey, []uint8, *OAEPOptions) ([]uint8, error) #65716
-pkg crypto/rsa, func EncryptPKCS1v15 //deprecated #75302
-pkg crypto/rsa, type PKCS1v15DecryptOptions //deprecated #75302
-pkg crypto/tls, const QUICErrorEvent = 10 #75108
-pkg crypto/tls, const QUICErrorEvent QUICEventKind #75108
-pkg crypto/tls, const SecP256r1MLKEM768 = 4587 #71206
-pkg crypto/tls, const SecP256r1MLKEM768 CurveID #71206
-pkg crypto/tls, const SecP384r1MLKEM1024 = 4589 #71206
-pkg crypto/tls, const SecP384r1MLKEM1024 CurveID #71206
-pkg crypto/tls, type ClientHelloInfo struct, HelloRetryRequest bool #74425
-pkg crypto/tls, type ConnectionState struct, HelloRetryRequest bool #74425
-pkg crypto/tls, type QUICEvent struct, Err error #75108
-pkg crypto/x509, func OIDFromASN1OID(asn1.ObjectIdentifier) (OID, error) #75325
-pkg crypto/x509, method (ExtKeyUsage) OID() OID #75325
-pkg crypto/x509, method (ExtKeyUsage) String() string #56866
-pkg crypto/x509, method (KeyUsage) String() string #56866
-pkg debug/elf, const R_LARCH_CALL36 = 110 #75562
-pkg debug/elf, const R_LARCH_CALL36 R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_DESC32 = 13 #75562
-pkg debug/elf, const R_LARCH_TLS_DESC32 R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_DESC64 = 14 #75562
-pkg debug/elf, const R_LARCH_TLS_DESC64 R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_DESC64_HI12 = 118 #75562
-pkg debug/elf, const R_LARCH_TLS_DESC64_HI12 R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_DESC64_LO20 = 117 #75562
-pkg debug/elf, const R_LARCH_TLS_DESC64_LO20 R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_DESC64_PC_HI12 = 114 #75562
-pkg debug/elf, const R_LARCH_TLS_DESC64_PC_HI12 R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_DESC64_PC_LO20 = 113 #75562
-pkg debug/elf, const R_LARCH_TLS_DESC64_PC_LO20 R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_DESC_CALL = 120 #75562
-pkg debug/elf, const R_LARCH_TLS_DESC_CALL R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_DESC_HI20 = 115 #75562
-pkg debug/elf, const R_LARCH_TLS_DESC_HI20 R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_DESC_LD = 119 #75562
-pkg debug/elf, const R_LARCH_TLS_DESC_LD R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_DESC_LO12 = 116 #75562
-pkg debug/elf, const R_LARCH_TLS_DESC_LO12 R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_DESC_PCREL20_S2 = 126 #75562
-pkg debug/elf, const R_LARCH_TLS_DESC_PCREL20_S2 R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_DESC_PC_HI20 = 111 #75562
-pkg debug/elf, const R_LARCH_TLS_DESC_PC_HI20 R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_DESC_PC_LO12 = 112 #75562
-pkg debug/elf, const R_LARCH_TLS_DESC_PC_LO12 R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_GD_PCREL20_S2 = 125 #75562
-pkg debug/elf, const R_LARCH_TLS_GD_PCREL20_S2 R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_LD_PCREL20_S2 = 124 #75562
-pkg debug/elf, const R_LARCH_TLS_LD_PCREL20_S2 R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_LE_ADD_R = 122 #75562
-pkg debug/elf, const R_LARCH_TLS_LE_ADD_R R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_LE_HI20_R = 121 #75562
-pkg debug/elf, const R_LARCH_TLS_LE_HI20_R R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_LE_LO12_R = 123 #75562
-pkg debug/elf, const R_LARCH_TLS_LE_LO12_R R_LARCH #75562
-pkg errors, func AsType[$0 error](error) ($0, bool) #51945
-pkg go/ast, func ParseDirective(token.Pos, string) (Directive, bool) #68021
-pkg go/ast, method (*Directive) End() token.Pos #68021
-pkg go/ast, method (*Directive) ParseArgs() ([]DirectiveArg, error) #68021
-pkg go/ast, method (*Directive) Pos() token.Pos #68021
-pkg go/ast, type BasicLit struct, ValueEnd token.Pos #76031
-pkg go/ast, type Directive struct #68021
-pkg go/ast, type Directive struct, Args string #68021
-pkg go/ast, type Directive struct, ArgsPos token.Pos #68021
-pkg go/ast, type Directive struct, Name string #68021
-pkg go/ast, type Directive struct, Slash token.Pos #68021
-pkg go/ast, type Directive struct, Tool string #68021
-pkg go/ast, type DirectiveArg struct #68021
-pkg go/ast, type DirectiveArg struct, Arg string #68021
-pkg go/ast, type DirectiveArg struct, Pos token.Pos #68021
-pkg go/token, method (*File) End() Pos #75849
-pkg log/slog, func NewMultiHandler(...Handler) *MultiHandler #65954
-pkg log/slog, method (*MultiHandler) Enabled(context.Context, Level) bool #65954
-pkg log/slog, method (*MultiHandler) Handle(context.Context, Record) error #65954
-pkg log/slog, method (*MultiHandler) WithAttrs([]Attr) Handler #65954
-pkg log/slog, method (*MultiHandler) WithGroup(string) Handler #65954
-pkg log/slog, type MultiHandler struct #65954
-pkg net, method (*Dialer) DialIP(context.Context, string, netip.Addr, netip.Addr) (*IPConn, error) #49097
-pkg net, method (*Dialer) DialTCP(context.Context, string, netip.AddrPort, netip.AddrPort) (*TCPConn, error) #49097
-pkg net, method (*Dialer) DialUDP(context.Context, string, netip.AddrPort, netip.AddrPort) (*UDPConn, error) #49097
-pkg net, method (*Dialer) DialUnix(context.Context, string, *UnixAddr, *UnixAddr) (*UnixConn, error) #49097
-pkg net/http, method (*ClientConn) Available() int #75772
-pkg net/http, method (*ClientConn) Close() error #75772
-pkg net/http, method (*ClientConn) Err() error #75772
-pkg net/http, method (*ClientConn) InFlight() int #75772
-pkg net/http, method (*ClientConn) Release() #75772
-pkg net/http, method (*ClientConn) Reserve() error #75772
-pkg net/http, method (*ClientConn) RoundTrip(*Request) (*Response, error) #75772
-pkg net/http, method (*ClientConn) SetStateHook(func(*ClientConn)) #75772
-pkg net/http, method (*Transport) NewClientConn(context.Context, string, string) (*ClientConn, error) #75772
-pkg net/http, type ClientConn struct #75772
-pkg net/http, type HTTP2Config struct, StrictMaxConcurrentRequests bool #67813
-pkg net/http/httputil, type ReverseProxy struct, Director //deprecated #73161
-pkg net/netip, method (Prefix) Compare(Prefix) int #61642
-pkg os, method (*Process) WithHandle(func(uintptr)) error #70352
-pkg os, var ErrNoHandle error #70352
-pkg reflect, method (Value) Fields() iter.Seq2[StructField, Value] #66631
-pkg reflect, method (Value) Methods() iter.Seq2[Method, Value] #66631
-pkg reflect, type Type interface, Fields() iter.Seq[StructField] #66631
-pkg reflect, type Type interface, Ins() iter.Seq[Type] #66631
-pkg reflect, type Type interface, Methods() iter.Seq[Method] #66631
-pkg reflect, type Type interface, Outs() iter.Seq[Type] #66631
-pkg testing, method (*B) ArtifactDir() string #71287
-pkg testing, method (*F) ArtifactDir() string #71287
-pkg testing, method (*T) ArtifactDir() string #71287
-pkg testing, type TB interface, ArtifactDir() string #71287
-pkg testing/cryptotest, func SetGlobalRandom(*testing.T, uint64) #70942
--- a/codereview.cfg
+++ b/codereview.cfg
@@ -1,2 +1,2 @@
-branch: dev.simd
+branch: release-branch.go1.24
 parent-branch: master
--- a/doc/asm.html
+++ b/doc/asm.html
@@ -1039,12 +1039,6 @@ The value of <code>GOMIPS64</code> environment variable (<code>hardfloat</code>
 <code>GOMIPS64_hardfloat</code> or <code>GOMIPS64_softfloat</code>.
 </p>

-<h3 id="riscv64">RISCV64</h3>
-
-<p>
-Reference: <a href="/pkg/cmd/internal/obj/riscv">Go RISCV64 Assembly Instructions Reference Manual</a>
-</p>
-
 <h3 id="unsupported_opcodes">Unsupported opcodes</h3>

 <p>
--- a/doc/go1.17_spec.html
+++ b/doc/go1.17_spec.html
--- a/doc/go_mem.html
+++ b/doc/go_mem.html
@@ -231,7 +231,7 @@ do exactly this.

 <p>
 A read of an array, struct, or complex number
-may be implemented as a read of each individual sub-value
+may by implemented as a read of each individual sub-value
 (array element, struct field, or real/imaginary component),
 in any order.
 Similarly, a write of an array, struct, or complex number
@@ -453,7 +453,7 @@ crash, or do something else.)
 </p>

 <p class="rule">
-The <i>k</i>th receive from a channel with capacity <i>C</i> is synchronized before the completion of the <i>k</i>+<i>C</i>th send on that channel.
+The <i>k</i>th receive on a channel with capacity <i>C</i> is synchronized before the completion of the <i>k</i>+<i>C</i>th send from that channel completes.
 </p>

 <p>
--- a/doc/go_spec.html
+++ b/doc/go_spec.html
@@ -1,6 +1,6 @@
 <!--{
 	"Title": "The Go Programming Language Specification",
-	"Subtitle": "Language version go1.26 (Dec 2, 2025)",
+	"Subtitle": "Language version go1.24 (Dec 30, 2024)",
 	"Path": "/ref/spec"
 }-->

@@ -8,6 +8,8 @@

 <p>
 This is the reference manual for the Go programming language.
+The pre-Go1.18 version, without generics, can be found
+<a href="/doc/go1.17_spec.html">here</a>.
 For more information and other documents, see <a href="/">go.dev</a>.
 </p>

@@ -1856,10 +1858,110 @@ The underlying type of <code>[]B1</code>, <code>B3</code>, and <code>B4</code> i
 The underlying type of <code>P</code> is <code>interface{}</code>.
 </p>

+<h3 id="Core_types">Core types</h3>
+
+<p>
+Each non-interface type <code>T</code> has a <i>core type</i>, which is the same as the
+<a href="#Underlying_types">underlying type</a> of <code>T</code>.
+</p>
+
+<p>
+An interface <code>T</code> has a core type if one of the following
+conditions is satisfied:
+</p>
+
+<ol>
+<li>
+There is a single type <code>U</code> which is the <a href="#Underlying_types">underlying type</a>
+of all types in the <a href="#Interface_types">type set</a> of <code>T</code>; or
+</li>
+<li>
+the type set of <code>T</code> contains only <a href="#Channel_types">channel types</a>
+with identical element type <code>E</code>, and all directional channels have the same
+direction.
+</li>
+</ol>
+
+<p>
+No other interfaces have a core type.
+</p>
+
+<p>
+The core type of an interface is, depending on the condition that is satisfied, either:
+</p>
+
+<ol>
+<li>
+the type <code>U</code>; or
+</li>
+<li>
+the type <code>chan E</code> if <code>T</code> contains only bidirectional
+channels, or the type <code>chan&lt;- E</code> or <code>&lt;-chan E</code>
+depending on the direction of the directional channels present.
+</li>
+</ol>
+
+<p>
+By definition, a core type is never a <a href="#Type_definitions">defined type</a>,
+<a href="#Type_parameter_declarations">type parameter</a>, or
+<a href="#Interface_types">interface type</a>.
+</p>
+
+<p>
+Examples of interfaces with core types:
+</p>
+
+<pre>
+type Celsius float32
+type Kelvin  float32
+
+interface{ int }                          // int
+interface{ Celsius|Kelvin }               // float32
+interface{ ~chan int }                    // chan int
+interface{ ~chan int|~chan&lt;- int }        // chan&lt;- int
+interface{ ~[]*data; String() string }    // []*data
+</pre>
+
+<p>
+Examples of interfaces without core types:
+</p>
+
+<pre>
+interface{}                               // no single underlying type
+interface{ Celsius|float64 }              // no single underlying type
+interface{ chan int | chan&lt;- string }     // channels have different element types
+interface{ &lt;-chan int | chan&lt;- int }      // directional channels have different directions
+</pre>
+
+<p>
+Some operations (<a href="#Slice_expressions">slice expressions</a>,
+<a href="#Appending_and_copying_slices"><code>append</code> and <code>copy</code></a>)
+rely on a slightly more loose form of core types which accept byte slices and strings.
+Specifically, if there are exactly two types, <code>[]byte</code> and <code>string</code>,
+which are the underlying types of all types in the type set of interface <code>T</code>,
+the core type of <code>T</code> is called <code>bytestring</code>.
+</p>
+
+<p>
+Examples of interfaces with <code>bytestring</code> core types:
+</p>
+
+<pre>
+interface{ int }                          // int (same as ordinary core type)
+interface{ []byte | string }              // bytestring
+interface{ ~[]byte | myString }           // bytestring
+</pre>
+
+<p>
+Note that <code>bytestring</code> is not a real type; it cannot be used to declare
+variables or compose other types. It exists solely to describe the behavior of some
+operations that read from a sequence of bytes, which may be a byte slice or a string.
+</p>
+
 <h3 id="Type_identity">Type identity</h3>

 <p>
-Two types are either <i>identical</i> ("the same") or <i>different</i>.
+Two types are either <i>identical</i> or <i>different</i>.
 </p>

 <p>
@@ -2487,15 +2589,11 @@ type set[P comparable] = map[P]bool
 </pre>

 <p>
-In an alias declaration the given type cannot be a type parameter declared in the same declaration.
+In an alias declaration the given type cannot be a type parameter.
 </p>

 <pre>
-type A[P any] = P   // illegal: P is a type parameter declared in the declaration of A
-
-func f[P any]() {
-	type A = P  // ok: T is a type parameter declared by the enclosing function
-}
+type A[P any] = P    // illegal: P is a type parameter
 </pre>

 <h4 id="Type_definitions">Type definitions</h4>
@@ -2605,8 +2703,8 @@ In a type definition the given type cannot be a type parameter.
 <pre>
 type T[P any] P    // illegal: P is a type parameter

-func f[P any]() {
-	type L P   // illegal: P is a type parameter declared by the enclosing function
+func f[T any]() {
+	type L T   // illegal: T is a type parameter declared by the enclosing function
 }
 </pre>

@@ -2690,6 +2788,22 @@ of a <a href="#Method_declarations">method declaration</a> associated
 with a generic type.
 </p>

+<p>
+Within a type parameter list of a generic type <code>T</code>, a type constraint
+may not (directly, or indirectly through the type parameter list of another
+generic type) refer to <code>T</code>.
+</p>
+
+<pre>
+type T1[P T1[P]] …                    // illegal: T1 refers to itself
+type T2[P interface{ T2[int] }] …     // illegal: T2 refers to itself
+type T3[P interface{ m(T3[int])}] …   // illegal: T3 refers to itself
+type T4[P T5[P]] …                    // illegal: T4 refers to T5 and
+type T5[P T4[P]] …                    //          T5 refers to T4
+
+type T6[P int] struct{ f *T6[P] }     // ok: reference to T6 is not in type parameter list
+</pre>
+
 <h4 id="Type_constraints">Type constraints</h4>

 <p>
@@ -3141,8 +3255,7 @@ math.Sin // denotes the Sin function in package math
 <h3 id="Composite_literals">Composite literals</h3>

 <p>
-Composite literals construct new values for structs, arrays, slices, and maps
-each time they are evaluated.
+Composite literals construct new composite values each time they are evaluated.
 They consist of the type of the literal followed by a brace-bound list of elements.
 Each element may optionally be preceded by a corresponding key.
 </p>
@@ -3160,14 +3273,10 @@ Element      = Expression | LiteralValue .
 </pre>

 <p>
-Unless the LiteralType is a type parameter,
-its <a href="#Underlying_types">underlying type</a>
+The LiteralType's <a href="#Core_types">core type</a> <code>T</code>
 must be a struct, array, slice, or map type
 (the syntax enforces this constraint except when the type is given
 as a TypeName).
-If the LiteralType is a type parameter, all types in its type set
-must have the same underlying type which must be
-a valid composite literal type.
 The types of the elements and keys must be <a href="#Assignability">assignable</a>
 to the respective field, element, and key types of type <code>T</code>;
 there is no additional conversion.
@@ -3352,6 +3461,7 @@ noteFrequency := map[string]float32{
 }
 </pre>

+
 <h3 id="Function_literals">Function literals</h3>

 <p>
@@ -3824,12 +3934,11 @@ The following rules apply:
 </p>

 <p>
-If <code>a</code> is neither a map nor a <a href="#Type_parameter_declarations">type parameter</a>:
+If <code>a</code> is neither a map nor a type parameter:
 </p>
 <ul>
-	<li>the index <code>x</code> must be an untyped constant, or its type must be
-	    an <a href="#Numeric_types">integer</a> or a type parameter whose type set
-	    contains only integer types</li>
+	<li>the index <code>x</code> must be an untyped constant or its
+	    <a href="#Core_types">core type</a> must be an <a href="#Numeric_types">integer</a></li>
 	<li>a constant index must be non-negative and
 	    <a href="#Representability">representable</a> by a value of type <code>int</code></li>
 	<li>a constant index that is untyped is given type <code>int</code></li>
@@ -3943,26 +4052,14 @@ Assigning to an element of a <code>nil</code> map causes a

 <p>
 Slice expressions construct a substring or slice from a string, array, pointer
-to array, or slice operand.
-There are two variants: a simple form that specifies a low
+to array, or slice. There are two variants: a simple form that specifies a low
 and high bound, and a full form that also specifies a bound on the capacity.
 </p>

-<p>
-If the operand type is a <a href="#Type_parameter_declarations">type parameter</a>,
-unless its type set contains string types,
-all types in the type set must have the same underlying type, and the slice expression
-must be valid for an operand of that type.
-If the type set contains string types it may also contain byte slices with underlying
-type <code>[]byte</code>.
-In this case, the slice expression must be valid for an operand of <code>string</code>
-type.
-</p>
-
 <h4>Simple slice expressions</h4>

 <p>
-For a string, array, pointer to array, or slice <code>a</code>, the primary expression
+The primary expression
 </p>

 <pre>
@@ -3970,7 +4067,9 @@ a[low : high]
 </pre>

 <p>
-constructs a substring or slice.
+constructs a substring or slice. The <a href="#Core_types">core type</a> of
+<code>a</code> must be a string, array, pointer to array, slice, or a
+<a href="#Core_types"><code>bytestring</code></a>.
 The <i>indices</i> <code>low</code> and
 <code>high</code> select which elements of operand <code>a</code> appear
 in the result. The result has indices starting at 0 and length equal to
@@ -4050,7 +4149,7 @@ s3 := s[:0]    // s3 == nil
 <h4>Full slice expressions</h4>

 <p>
-For an array, pointer to array, or slice <code>a</code> (but not a string), the primary expression
+The primary expression
 </p>

 <pre>
@@ -4061,6 +4160,8 @@ a[low : high : max]
 constructs a slice of the same type, and with the same length and elements as the simple slice
 expression <code>a[low : high]</code>. Additionally, it controls the resulting slice's capacity
 by setting it to <code>max - low</code>. Only the first index may be omitted; it defaults to 0.
+The <a href="#Core_types">core type</a> of <code>a</code> must be an array, pointer to array,
+or slice (but not a string).
 After slicing the array <code>a</code>
 </p>

@@ -4166,8 +4267,8 @@ No <a href="#Run_time_panics">run-time panic</a> occurs in this case.
 <h3 id="Calls">Calls</h3>

 <p>
-Given an expression <code>f</code> of <a href="#Function_types">function type</a>
-<code>F</code>,
+Given an expression <code>f</code> with a <a href="#Core_types">core type</a>
+<code>F</code> of <a href="#Function_types">function type</a>,
 </p>

 <pre>
@@ -4197,12 +4298,6 @@ If <code>f</code> denotes a generic function, it must be
 or used as a function value.
 </p>

-<p>
-If the type of <code>f</code> is a <a href="#Type_parameter_declarations">type parameter</a>,
-all types in its type set must have the same underlying type, which must be a function type,
-and the function call must be valid for that type.
-</p>
-
 <p>
 In a function call, the function value and arguments are evaluated in
 <a href="#Order_of_evaluation">the usual order</a>.
@@ -4716,28 +4811,17 @@ more complicated:

 <ul>
 <li>
-	If all types in <code>C</code>'s type set have the same
-	underlying type <code>U</code>,
+	If <code>C</code> has a <a href="#Core_types">core type</a>
+	<code>core(C)</code>
 	and <code>P</code> has a known type argument <code>A</code>,
-	<code>U</code> and <code>A</code> must unify loosely.
-</li>
-<li>
-	Similarly, if all types in <code>C</code>'s type set are
-	channel types with the same element type and non-conflicting
-	channel directions,
-	and <code>P</code> has a known type argument <code>A</code>,
-	the most restrictive channel type in <code>C</code>'s type
-	set and <code>A</code> must unify loosely.
-</li>
-<li>
+	<code>core(C)</code> and <code>A</code> must unify loosely.
 	If <code>P</code> does not have a known type argument
 	and <code>C</code> contains exactly one type term <code>T</code>
 	that is not an underlying (tilde) type, unification adds the
 	mapping <code>P ➞ T</code> to the map.
 </li>
 <li>
-	If <code>C</code> does not have a type <code>U</code>
-	as described above
+	If <code>C</code> does not have a core type
 	and <code>P</code> has a known type argument <code>A</code>,
 	<code>A</code> must have all methods of <code>C</code>, if any,
 	and corresponding method types must unify exactly.
@@ -4861,7 +4945,7 @@ For instance, <code>x / y * z</code> is the same as <code>(x / y) * z</code>.
 x &lt;= f()                   // x &lt;= f()
 ^a &gt;&gt; b                    // (^a) >> b
 f() || g()                 // f() || g()
-x == y+1 &amp;&amp; &lt;-chanInt &gt; 0  // (x == (y+1)) &amp;&amp; ((&lt;-chanInt) > 0)
+x == y+1 &amp;&amp; &lt;-chanInt &gt; 0  // (x == (y+1)) && ((<-chanInt) > 0)
 </pre>


@@ -5288,10 +5372,10 @@ var x *int = nil
 <h3 id="Receive_operator">Receive operator</h3>

 <p>
-For an operand <code>ch</code> of <a href="#Channel_types">channel type</a>,
+For an operand <code>ch</code> whose <a href="#Core_types">core type</a> is a
+<a href="#Channel_types">channel</a>,
 the value of the receive operation <code>&lt;-ch</code> is the value received
-from the channel <code>ch</code>.
-The channel direction must permit receive operations,
+from the channel <code>ch</code>. The channel direction must permit receive operations,
 and the type of the receive operation is the element type of the channel.
 The expression blocks until a value is available.
 Receiving from a <code>nil</code> channel blocks forever.
@@ -5307,12 +5391,6 @@ f(&lt;-ch)
 &lt;-strobe  // wait until clock pulse and discard received value
 </pre>

-<p>
-If the operand type is a <a href="#Type_parameter_declarations">type parameter</a>,
-all types in its type set must be channel types that permit receive operations, and
-they must all have the same element type, which is the type of the receive operation.
-</p>
-
 <p>
 A receive expression used in an <a href="#Assignment_statements">assignment statement</a> or initialization of the special form
 </p>
@@ -6048,7 +6126,8 @@ len("foo")  // illegal if len is the built-in function

 <p>
 A send statement sends a value on a channel.
-The channel expression must be of <a href="#Channel_types">channel type</a>,
+The channel expression's <a href="#Core_types">core type</a>
+must be a <a href="#Channel_types">channel</a>,
 the channel direction must permit send operations,
 and the type of the value to be sent must be <a href="#Assignability">assignable</a>
 to the channel's element type.
@@ -6072,13 +6151,6 @@ A send on a <code>nil</code> channel blocks forever.
 ch &lt;- 3  // send value 3 to channel ch
 </pre>

-<p>
-If the type of the channel expression is a
-<a href="#Type_parameter_declarations">type parameter</a>,
-all types in its type set must be channel types that permit send operations,
-they must all have the same element type,
-and the type of the value to be sent must be assignable to that element type.
-</p>

 <h3 id="IncDec_statements">IncDec statements</h3>

@@ -6623,7 +6695,7 @@ iteration's variable at that moment.

 <pre>
 var prints []func()
-for i := 0; i &lt; 5; i++ {
+for i := 0; i < 5; i++ {
 	prints = append(prints, func() { println(i) })
 	i++
 }
@@ -6671,7 +6743,8 @@ RangeClause = [ ExpressionList "=" | IdentifierList ":=" ] "range" Expression .

 <p>
 The expression on the right in the "range" clause is called the <i>range expression</i>,
-which may be an array, pointer to an array, slice, string, map, channel permitting
+its <a href="#Core_types">core type</a> must be
+an array, pointer to an array, slice, string, map, channel permitting
 <a href="#Receive_operator">receive operations</a>, an integer, or
 a function with specific signature (see below).
 As with an assignment, if present the operands on the left must be
@@ -6760,7 +6833,7 @@ if the iteration variable is preexisting, the type of the iteration values is th
 variable, which must be of integer type.
 Otherwise, if the iteration variable is declared by the "range" clause or is absent,
 the type of the iteration values is the <a href="#Constants">default type</a> for <code>n</code>.
-If <code>n</code> &lt;= 0, the loop does not run any iterations.
+If <code>n</code> &lt= 0, the loop does not run any iterations.
 </li>

 <li>
@@ -6871,7 +6944,7 @@ type Tree[K cmp.Ordered, V any] struct {
 }

 func (t *Tree[K, V]) walk(yield func(key K, val V) bool) bool {
-	return t == nil || t.left.walk(yield) &amp;&amp; yield(t.key, t.value) &amp;&amp; t.right.walk(yield)
+	return t == nil || t.left.walk(yield) && yield(t.key, t.value) && t.right.walk(yield)
 }

 func (t *Tree[K, V]) Walk(yield func(key K, val V) bool) {
@@ -6885,12 +6958,6 @@ for k, v := range t.Walk {
 }
 </pre>

-<p>
-If the type of the range expression is a <a href="#Type_parameter_declarations">type parameter</a>,
-all types in its type set must have the same underlying type and the range expression must be valid
-for that type, or, if the type set contains channel types, it must only contain channel types with
-identical element types, and all channel types must permit receive operations.
-</p>

 <h3 id="Go_statements">Go statements</h3>

@@ -7364,28 +7431,23 @@ by the arguments overlaps.

 <p>
 The <a href="#Function_types">variadic</a> function <code>append</code>
-appends zero or more values <code>x</code> to a slice <code>s</code> of
-type <code>S</code> and returns the resulting slice, also of type
-<code>S</code>.
+appends zero or more values <code>x</code> to a slice <code>s</code>
+and returns the resulting slice of the same type as <code>s</code>.
+The <a href="#Core_types">core type</a> of <code>s</code> must be a slice
+of type <code>[]E</code>.
 The values <code>x</code> are passed to a parameter of type <code>...E</code>
-where <code>E</code> is the element type of <code>S</code>
 and the respective <a href="#Passing_arguments_to_..._parameters">parameter
 passing rules</a> apply.
-As a special case, <code>append</code> also accepts a slice whose type is assignable to
-type <code>[]byte</code> with a second argument of <code>string</code> type followed by
-<code>...</code>.
-This form appends the bytes of the string.
+As a special case, if the core type of <code>s</code> is <code>[]byte</code>,
+<code>append</code> also accepts a second argument with core type
+<a href="#Core_types"><code>bytestring</code></a> followed by <code>...</code>.
+This form appends the bytes of the byte slice or string.
 </p>

 <pre class="grammar">
-append(s S, x ...E) S  // E is the element type of S
+append(s S, x ...E) S  // core type of S is []E
 </pre>

-<p>
-If <code>S</code> is a <a href="#Type_parameter_declarations">type parameter</a>,
-all types in its type set must have the same underlying slice type <code>[]E</code>.
-</p>
-
 <p>
 If the capacity of <code>s</code> is not large enough to fit the additional
 values, <code>append</code> <a href="#Allocation">allocates</a> a new, sufficiently large underlying
@@ -7411,14 +7473,14 @@ b = append(b, "bar"...)            // append string contents      b is []byte{'b
 The function <code>copy</code> copies slice elements from
 a source <code>src</code> to a destination <code>dst</code> and returns the
 number of elements copied.
-Both arguments must have <a href="#Type_identity">identical</a> element type
-<code>E</code> and must be assignable to a slice of type <code>[]E</code>.
+The <a href="#Core_types">core types</a> of both arguments must be slices
+with <a href="#Type_identity">identical</a> element type.
 The number of elements copied is the minimum of
 <code>len(src)</code> and <code>len(dst)</code>.
-As a special case, <code>copy</code> also accepts a destination argument
-assignable to type <code>[]byte</code> with a source argument of a
-<code>string</code> type.
-This form copies the bytes from the string into the byte slice.
+As a special case, if the destination's core type is <code>[]byte</code>,
+<code>copy</code> also accepts a source argument with core type
+<a href="#Core_types"><code>bytestring</code></a>.
+This form copies the bytes from the byte slice or string into the byte slice.
 </p>

 <pre class="grammar">
@@ -7426,11 +7488,6 @@ copy(dst, src []T) int
 copy(dst []byte, src string) int
 </pre>

-<p>
-If the type of one or both arguments is a <a href="#Type_parameter_declarations">type parameter</a>,
-all types in their respective type sets must have the same underlying slice type <code>[]E</code>.
-</p>
-
 <p>
 Examples:
 </p>
@@ -7481,7 +7538,8 @@ If the map or slice is <code>nil</code>, <code>clear</code> is a no-op.
 <h3 id="Close">Close</h3>

 <p>
-For a channel <code>ch</code>, the built-in function <code>close(ch)</code>
+For an argument <code>ch</code> with a <a href="#Core_types">core type</a>
+that is a <a href="#Channel_types">channel</a>, the built-in function <code>close</code>
 records that no more values will be sent on the channel.
 It is an error if <code>ch</code> is a receive-only channel.
 Sending to or closing a closed channel causes a <a href="#Run_time_panics">run-time panic</a>.
@@ -7493,12 +7551,6 @@ The multi-valued <a href="#Receive_operator">receive operation</a>
 returns a received value along with an indication of whether the channel is closed.
 </p>

-<p>
-If the type of the argument to <code>close</code> is a
-<a href="#Type_parameter_declarations">type parameter</a>,
-all types in its type set must be channels.
-It is an error if any of those channels is a receive-only channel.
-</p>

 <h3 id="Complex_numbers">Manipulating complex numbers</h3>

@@ -7668,36 +7720,27 @@ var z complex128

 <p>
 The built-in function <code>make</code> takes a type <code>T</code>,
-which must be a slice, map or channel type, or a type parameter,
 optionally followed by a type-specific list of expressions.
+The <a href="#Core_types">core type</a> of <code>T</code> must
+be a slice, map or channel.
 It returns a value of type <code>T</code> (not <code>*T</code>).
 The memory is initialized as described in the section on
 <a href="#The_zero_value">initial values</a>.
 </p>

 <pre class="grammar">
-Call             Type T            Result
+Call             Core type    Result

-make(T, n)       slice             slice of type T with length n and capacity n
-make(T, n, m)    slice             slice of type T with length n and capacity m
+make(T, n)       slice        slice of type T with length n and capacity n
+make(T, n, m)    slice        slice of type T with length n and capacity m

-make(T)          map               map of type T
-make(T, n)       map               map of type T with initial space for approximately n elements
+make(T)          map          map of type T
+make(T, n)       map          map of type T with initial space for approximately n elements

-make(T)          channel           unbuffered channel of type T
-make(T, n)       channel           buffered channel of type T, buffer size n
-
-make(T, n)       type parameter    see below
-make(T, n, m)    type parameter    see below
+make(T)          channel      unbuffered channel of type T
+make(T, n)       channel      buffered channel of type T, buffer size n
 </pre>

-<p>
-If the first argument is a <a href="#Type_parameter_declarations">type parameter</a>,
-all types in its type set must have the same underlying type, which must be a slice
-or map type, or, if there are channel types, there must only be channel types, they
-must all have the same element type, and the channel directions must not conflict.
-</p>
-
 <p>
 Each of the size arguments <code>n</code> and <code>m</code> must be of <a href="#Numeric_types">integer type</a>,
 have a <a href="#Interface_types">type set</a> containing only integer types,
@@ -7787,39 +7830,27 @@ compared lexically byte-wise:
 </p>

 <pre>
-min(x, y)    == if x &lt;= y then x else y
+min(x, y)    == if x <= y then x else y
 min(x, y, z) == min(min(x, y), z)
 </pre>

 <h3 id="Allocation">Allocation</h3>

 <p>
-The built-in function <code>new</code> creates a new, initialized
-<a href="#Variables">variable</a> and returns
-a <a href="#Pointer_types">pointer</a> to it.
-It accepts a single argument, which may be either a type or an expression.
+The built-in function <code>new</code> takes a type <code>T</code>,
+allocates storage for a <a href="#Variables">variable</a> of that type
+at run time, and returns a value of type <code>*T</code>
+<a href="#Pointer_types">pointing</a> to it.
+The variable is initialized as described in the section on
+<a href="#The_zero_value">initial values</a>.
 </p>

-<p>
-If the argument is a type <code>T</code>, then <code>new(T)</code>
-allocates a variable of type <code>T</code> initialized to its
-<a href="#The_zero_value">zero value</a>.
-</p>
+<pre class="grammar">
+new(T)
+</pre>

 <p>
-If the argument is an expression <code>x</code>, then <code>new(x)</code>
-allocates a variable of the type of <code>x</code> initialized to the value of <code>x</code>.
-If that value is an untyped constant, it is first implicitly <a href="#Conversions">converted</a>
-to its <a href="#Constants">default type</a>;
-if it is an untyped boolean value, it is first implicitly converted to type bool.
-The predeclared identifier <code>nil</code> cannot be used as an argument to <code>new</code>.
-</p>
-
-<p>
-For example, <code>new(int)</code> and <code>new(123)</code> each
-return a pointer to a new variable of type <code>int</code>.
-The value of the first variable is <code>0</code>, and the value
-of the second is <code>123</code>. Similarly
+For instance
 </p>

 <pre>
@@ -7828,12 +7859,13 @@ new(S)
 </pre>

 <p>
-allocates a variable of type <code>S</code>,
+allocates storage for a variable of type <code>S</code>,
 initializes it (<code>a=0</code>, <code>b=0.0</code>),
 and returns a value of type <code>*S</code> containing the address
-of the variable.
+of the location.
 </p>

+
 <h3 id="Handling_panics">Handling panics</h3>

 <p> Two built-in functions, <code>panic</code> and <code>recover</code>,
@@ -7893,7 +7925,7 @@ causes a <a href="#Run_time_panics">run-time panic</a>.
 <p>
 The <code>protect</code> function in the example below invokes
 the function argument <code>g</code> and protects callers from
-run-time panics caused by <code>g</code>.
+run-time panics raised by <code>g</code>.
 </p>

 <pre>
@@ -8451,14 +8483,17 @@ func String(ptr *byte, len IntegerType) string
 func StringData(str string) *byte
 </pre>

+<!--
+These conversions also apply to type parameters with suitable core types.
+Determine if we can simply use core type instead of underlying type here,
+of if the general conversion rules take care of this.
+-->
+
 <p>
 A <code>Pointer</code> is a <a href="#Pointer_types">pointer type</a> but a <code>Pointer</code>
 value may not be <a href="#Address_operators">dereferenced</a>.
-Any pointer or value of <a href="#Underlying_types">underlying type</a> <code>uintptr</code> can be
-<a href="#Conversions">converted</a> to a type of underlying type <code>Pointer</code> and vice versa.
-If the respective types are <a href="#Type_parameter_declarations">type parameters</a>, all types in
-their respective type sets must have the same underlying type, which must be <code>uintptr</code> and
-<code>Pointer</code>, respectively.
+Any pointer or value of <a href="#Core_types">core type</a> <code>uintptr</code> can be
+<a href="#Conversions">converted</a> to a type of core type <code>Pointer</code> and vice versa.
 The effect of converting between <code>Pointer</code> and <code>uintptr</code> is implementation-defined.
 </p>

@@ -8812,9 +8847,9 @@ following conditions is true:
 </li>
 <li>
 	Exactly one type is an <a href="#Type_inference">unbound</a>
-	type parameter, and all the types in its type set unify with
-	the other type
-	per the unification rules for <code>≡<sub>A</sub></code>
+	type parameter with a <a href="#Core_types">core type</a>,
+	and that core type unifies with the other type per the
+	unification rules for <code>≡<sub>A</sub></code>
 	(loose unification at the top level and exact unification
 	for element types).
 </li>
--- a/doc/godebug.md
+++ b/doc/godebug.md
@@ -109,9 +109,7 @@ Only the work module's `go.mod` is consulted for `godebug` directives.
 Any directives in required dependency modules are ignored.
 It is an error to list a `godebug` with an unrecognized setting.
 (Toolchains older than Go 1.23 reject all `godebug` lines, since they do not
-understand `godebug` at all.) When a workspace is in use, `godebug`
-directives in `go.mod` files are ignored, and `go.work` will be consulted
-for `godebug` directives instead.
+understand `godebug` at all.)

 The defaults from the `go` and `godebug` lines apply to all main
 packages that are built. For more fine-grained control,
@@ -153,77 +151,6 @@ for example,
 see the [runtime documentation](/pkg/runtime#hdr-Environment_Variables)
 and the [go command documentation](/cmd/go#hdr-Build_and_test_caching).

-### Go 1.26
-
-Go 1.26 added a new `httpcookiemaxnum` setting that controls the maximum number
-of cookies that net/http will accept when parsing HTTP headers. If the number of
-cookie in a header exceeds the number set in `httpcookiemaxnum`, cookie parsing
-will fail early. The default value is `httpcookiemaxnum=3000`. Setting
-`httpcookiemaxnum=0` will allow the cookie parsing to accept an indefinite
-number of cookies. To avoid denial of service attacks, this setting and default
-was backported to Go 1.25.2 and Go 1.24.8.
-
-Go 1.26 added a new `urlstrictcolons` setting that controls whether `net/url.Parse`
-allows malformed hostnames containing colons outside of a bracketed IPv6 address.
-The default `urlstrictcolons=1` rejects URLs such as `http://localhost:1:2` or `http://::1/`.
-Colons are permitted as part of a bracketed IPv6 address, such as `http://[::1]/`.
-
-Go 1.26 enabled two additional post-quantum key exchange mechanisms:
-SecP256r1MLKEM768 and SecP384r1MLKEM1024. The default can be reverted using the
-[`tlssecpmlkem` setting](/pkg/crypto/tls/#Config.CurvePreferences).
-
-Go 1.26 added a new `tracebacklabels` setting that controls the inclusion of
-goroutine labels set through the the `runtime/pprof` package. Setting `tracebacklabels=1`
-includes these key/value pairs in the goroutine status header of runtime
-tracebacks and debug=2 runtime/pprof stack dumps. This format may change in the future.
-(see go.dev/issue/76349)
-
-Go 1.26 added a new `cryptocustomrand` setting that controls whether most crypto/...
-APIs ignore the random `io.Reader` parameter. For Go 1.26, it defaults
-to `cryptocustomrand=0`, ignoring the random parameters. Using `cryptocustomrand=1`
-reverts to the pre-Go 1.26 behavior.
-
-### Go 1.25
-
-Go 1.25 added a new `decoratemappings` setting that controls whether the Go
-runtime annotates OS anonymous memory mappings with context about their
-purpose. These annotations appear in /proc/self/maps and /proc/self/smaps as
-"[anon: Go: ...]". This setting is only used on Linux. For Go 1.25, it defaults
-to `decoratemappings=1`, enabling annotations. Using `decoratemappings=0`
-reverts to the pre-Go 1.25 behavior. This setting is fixed at program startup
-time, and can't be modified by changing the `GODEBUG` environment variable
-after the program starts.
-
-Go 1.25 added a new `embedfollowsymlinks` setting that controls whether the
-Go command will follow symlinks to regular files embedding files.
-The default value `embedfollowsymlinks=0` does not allow following
-symlinks. `embedfollowsymlinks=1` will allow following symlinks.
-
-Go 1.25 added a new `containermaxprocs` setting that controls whether the Go
-runtime will consider cgroup CPU limits when setting the default GOMAXPROCS.
-The default value `containermaxprocs=1` will use cgroup limits in addition to
-the total logical CPU count and CPU affinity. `containermaxprocs=0` will
-disable consideration of cgroup limits. This setting only affects Linux.
-
-Go 1.25 added a new `updatemaxprocs` setting that controls whether the Go
-runtime will periodically update GOMAXPROCS for new CPU affinity or cgroup
-limits. The default value `updatemaxprocs=1` will enable periodic updates.
-`updatemaxprocs=0` will disable periodic updates.
-
-Go 1.25 disabled SHA-1 signature algorithms in TLS 1.2 according to RFC 9155.
-The default can be reverted using the `tlssha1=1` setting.
-
-Go 1.25 switched to SHA-256 to fill in missing SubjectKeyId in
-crypto/x509.CreateCertificate. The setting `x509sha256skid=0` reverts to SHA-1.
-
-Go 1.25 corrected the semantics of contention reports for runtime-internal locks,
-and so removed the [`runtimecontentionstacks` setting](/pkg/runtime#hdr-Environment_Variables).
-
-Go 1.25 (starting with Go 1.25 RC 2) disabled build information stamping when
-multiple VCS are detected due to concerns around VCS injection attacks. This
-behavior and setting was backported to Go 1.24.5 and Go 1.23.11. This behavior
-can be renabled with the setting `allowmultiplevcs=1`.
-
 ### Go 1.24

 Go 1.24 added a new `fips140` setting that controls whether the Go
@@ -290,8 +217,6 @@ field by default.
 Go 1.24 enabled the post-quantum key exchange mechanism
 X25519MLKEM768 by default. The default can be reverted using the
 [`tlsmlkem` setting](/pkg/crypto/tls/#Config.CurvePreferences).
-This can be useful when dealing with buggy TLS servers that do not handle large records correctly,
-causing a timeout during the handshake (see [TLS post-quantum TL;DR fail](https://tldr.fail/)).
 Go 1.24 also removed X25519Kyber768Draft00 and the Go 1.23 `tlskyber` setting.

 Go 1.24 made [`ParsePKCS1PrivateKey`](/pkg/crypto/x509/#ParsePKCS1PrivateKey)
@@ -306,7 +231,7 @@ Go 1.23 changed the channels created by package time to be unbuffered
 and [`Timer.Reset`](/pkg/time/#Timer.Reset) method results much easier.
 The [`asynctimerchan` setting](/pkg/time/#NewTimer) disables this change.
 There are no runtime metrics for this change,
-This setting will be removed in Go 1.27.
+This setting may be removed in a future release, Go 1.27 at the earliest.

 Go 1.23 changed the mode bits reported by [`os.Lstat`](/pkg/os#Lstat) and [`os.Stat`](/pkg/os#Stat)
 for reparse points, which can be controlled with the `winsymlink` setting.
@@ -328,8 +253,6 @@ Previous versions default to `winreadlinkvolume=0`.
 Go 1.23 enabled the experimental post-quantum key exchange mechanism
 X25519Kyber768Draft00 by default. The default can be reverted using the
 [`tlskyber` setting](/pkg/crypto/tls/#Config.CurvePreferences).
-This can be useful when dealing with buggy TLS servers that do not handle large records correctly,
-causing a timeout during the handshake (see [TLS post-quantum TL;DR fail](https://tldr.fail/)).

 Go 1.23 changed the behavior of
 [crypto/x509.ParseCertificate](/pkg/crypto/x509/#ParseCertificate) to reject
@@ -343,7 +266,6 @@ any effect.
 Go 1.23 changed the default TLS cipher suites used by clients and servers when
 not explicitly configured, removing 3DES cipher suites. The default can be reverted
 using the [`tls3des` setting](/pkg/crypto/tls/#Config.CipherSuites).
-This setting will be removed in Go 1.27.

 Go 1.23 changed the behavior of [`tls.X509KeyPair`](/pkg/crypto/tls#X509KeyPair)
 and [`tls.LoadX509KeyPair`](/pkg/crypto/tls#LoadX509KeyPair) to populate the
@@ -351,7 +273,6 @@ Leaf field of the returned [`tls.Certificate`](/pkg/crypto/tls#Certificate).
 This behavior is controlled by the `x509keypairleaf` setting. For Go 1.23, it
 defaults to `x509keypairleaf=1`. Previous versions default to
 `x509keypairleaf=0`.
-This setting will be removed in Go 1.27.

 Go 1.23 changed
 [`net/http.ServeContent`](/pkg/net/http#ServeContent),
@@ -385,31 +306,28 @@ Whether the type checker produces `Alias` types or not is controlled by the
 [`gotypesalias` setting](/pkg/go/types#Alias).
 For Go 1.22 it defaults to `gotypesalias=0`.
 For Go 1.23, `gotypesalias=1` will become the default.
-This setting will be removed in Go 1.27.
+This setting will be removed in a future release, Go 1.27 at the earliest.

 Go 1.22 changed the default minimum TLS version supported by both servers
 and clients to TLS 1.2. The default can be reverted to TLS 1.0 using the
 [`tls10server` setting](/pkg/crypto/tls/#Config).
-This setting will be removed in Go 1.27.

 Go 1.22 changed the default TLS cipher suites used by clients and servers when
 not explicitly configured, removing the cipher suites which used RSA based key
 exchange. The default can be reverted using the [`tlsrsakex` setting](/pkg/crypto/tls/#Config).
-This setting will be removed in Go 1.27.

 Go 1.22 disabled
 [`ConnectionState.ExportKeyingMaterial`](/pkg/crypto/tls/#ConnectionState.ExportKeyingMaterial)
 when the connection supports neither TLS 1.3 nor Extended Master Secret
 (implemented in Go 1.21). It can be reenabled with the [`tlsunsafeekm`
 setting](/pkg/crypto/tls/#ConnectionState.ExportKeyingMaterial).
-This setting will be removed in Go 1.27.

 Go 1.22 changed how the runtime interacts with transparent huge pages on Linux.
 In particular, a common default Linux kernel configuration can result in
 significant memory overheads, and Go 1.22 no longer works around this default.
 To work around this issue without adjusting kernel settings, transparent huge
 pages can be disabled for Go memory with the
-[`disablethp` setting](/pkg/runtime#hdr-Environment_Variables).
+[`disablethp` setting](/pkg/runtime#hdr-Environment_Variable).
 This behavior was backported to Go 1.21.1, but the setting is only available
 starting with Go 1.21.6.
 This setting may be removed in a future release, and users impacted by this issue
@@ -421,7 +339,7 @@ Go 1.22 added contention on runtime-internal locks to the [`mutex`
 profile](/pkg/runtime/pprof#Profile). Contention on these locks is always
 reported at `runtime._LostContendedRuntimeLock`. Complete stack traces of
 runtime locks can be enabled with the [`runtimecontentionstacks`
-setting](/pkg/runtime#hdr-Environment_Variables). These stack traces have
+setting](/pkg/runtime#hdr-Environment_Variable). These stack traces have
 non-standard semantics, see setting documentation for details.

 Go 1.22 added a new [`crypto/x509.Certificate`](/pkg/crypto/x509/#Certificate)
@@ -430,7 +348,7 @@ certificate policy OIDs with components larger than 31 bits. By default this
 field is only used during parsing, when it is populated with policy OIDs, but
 not used during marshaling. It can be used to marshal these larger OIDs, instead
 of the existing PolicyIdentifiers field, by using the
-[`x509usepolicies` setting](/pkg/crypto/x509/#CreateCertificate).
+[`x509usepolicies` setting.](/pkg/crypto/x509/#CreateCertificate).


 ### Go 1.21
--- a/doc/initial/6-stdlib/99-minor/0-heading.md
+++ b/doc/initial/6-stdlib/99-minor/0-heading.md
@@ -1 +1,3 @@
 ### Minor changes to the library {#minor_library_changes}
+
+
--- a/lib/fips140/Makefile
+++ b/lib/fips140/Makefile
@@ -30,7 +30,7 @@ v%.zip:
 	go run ../../src/cmd/go/internal/fips140/mkzip.go v$*

 # normally mkzip refuses to overwrite an existing zip file.
-# make v1.2.3.rm removes the zip file and unpacked
+# make v1.2.3.rm removes the zip file and and unpacked
 # copy from the module cache.
 v%.rm:
 	rm -f v$*.zip
--- a/lib/fips140/fips140.sum
+++ b/lib/fips140/fips140.sum
@@ -9,5 +9,4 @@
 #
 #	go test cmd/go/internal/fips140 -update
 #
-v1.0.0-c2097c7c.zip daf3614e0406f67ae6323c902db3f953a1effb199142362a039e7526dfb9368b
-v1.1.0-rc1.zip ea94f8c3885294c9efe1bd8f9b6e86daeb25b6aff2aeb20707cd9a5101f6f54e
+v1.0.0.zip b50508feaeff05d22516b21e1fd210bbf5d6a1e422eaf2cfa23fe379342713b8
--- a/lib/fips140/inprocess.txt
+++ b/lib/fips140/inprocess.txt
@@ -1 +0,0 @@
-v1.0.0-c2097c7c
--- a/lib/fips140/v1.0.0.txt
+++ b/lib/fips140/v1.0.0.txt
@@ -1 +0,0 @@
-v1.0.0-c2097c7c
--- a/lib/fips140/v1.0.0-c2097c7c.zip
+++ b/lib/fips140/v1.0.0-c2097c7c.zip
--- a/lib/fips140/v1.1.0-rc1.zip
+++ b/lib/fips140/v1.1.0-rc1.zip
--- a/lib/hg/goreposum.py
+++ b/lib/hg/goreposum.py
@@ -1,64 +0,0 @@
-# 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.
-
-# Mercurial extension to add a 'goreposum' command that
-# computes a hash of a remote repo's tag state.
-# Tag definitions can come from the .hgtags file stored in
-# any head of any branch, and the server protocol does not
-# expose the tags directly. However, the protocol does expose
-# the hashes of all the branch heads, so we can use a hash of
-# all those branch names and heads as a conservative snapshot
-# of the entire remote repo state, and use that as the tag sum.
-# Any change on the server then invalidates the tag sum,
-# even if it didn't have anything to do with tags, but at least
-# we will avoid re-cloning a server when there have been no
-# changes at all.
-#
-# Separately, this extension also adds a 'golookup' command that
-# returns the hash of a specific reference, like 'default' or a tag.
-# And golookup of a hash confirms that it still exists on the server.
-# We can use that to revalidate that specific versions still exist and
-# have the same meaning they did the last time we checked.
-#
-# Usage:
-#
-#	hg --config "extensions.goreposum=$GOROOT/lib/hg/goreposum.py" goreposum REPOURL
-
-import base64, hashlib, sys
-from mercurial import registrar, ui, hg, node
-from mercurial.i18n import _
-cmdtable = {}
-command = registrar.command(cmdtable)
-@command(b'goreposum', [], _('url'), norepo=True)
-def goreposum(ui, url):
-  """
-  goreposum computes a checksum of all the named state in the remote repo.
-  It hashes together all the branch names and hashes
-  and then all the bookmark names and hashes.
-  Tags are stored in .hgtags files in any of the branches,
-  so the branch metadata includes the tags as well.
-  """
-  h = hashlib.sha256()
-  peer = hg.peer(ui, {}, url)
-  for name, revs in peer.branchmap().items():
-    h.update(name)
-    for r in revs:
-      h.update(b' ')
-      h.update(r)
-    h.update(b'\n')
-  if (b'bookmarks' in peer.listkeys(b'namespaces')):
-    for name, rev in peer.listkeys(b'bookmarks').items():
-      h.update(name)
-      h.update(b'=')
-      h.update(rev)
-      h.update(b'\n')
-  print('r1:'+base64.standard_b64encode(h.digest()).decode('utf-8'))
-
-@command(b'golookup', [], _('url rev'), norepo=True)
-def golookup(ui, url, rev):
-  """
-  golookup looks up a single identifier in the repo,
-  printing its hash.
-  """
-  print(node.hex(hg.peer(ui, {}, url).lookup(rev)).decode('utf-8'))
--- a/lib/time/update.bash
+++ b/lib/time/update.bash
@@ -24,8 +24,8 @@
 # in the CL match the update.bash in the CL.

 # Versions to use.
-CODE=2025c
-DATA=2025c
+CODE=2025a
+DATA=2025a

 set -e

@@ -40,12 +40,7 @@ curl -sS -L -O https://www.iana.org/time-zones/repository/releases/tzdata$DATA.t
 tar xzf tzcode$CODE.tar.gz
 tar xzf tzdata$DATA.tar.gz

-# The PACKRATLIST and PACKRATDATA options are copied from Ubuntu:
-# https://git.launchpad.net/ubuntu/+source/tzdata/tree/debian/rules?h=debian/sid
-#
-# You can see the description of these make variables in the tzdata Makefile:
-# https://github.com/eggert/tz/blob/main/Makefile
-if ! make CFLAGS=-DSTD_INSPIRED AWK=awk TZDIR=zoneinfo PACKRATDATA=backzone PACKRATLIST=zone.tab posix_only >make.out 2>&1; then
+if ! make CFLAGS=-DSTD_INSPIRED AWK=awk TZDIR=zoneinfo posix_only >make.out 2>&1; then
 	cat make.out
 	exit 2
 fi
--- a/lib/time/zoneinfo.zip
+++ b/lib/time/zoneinfo.zip
--- a/lib/wasm/go_wasip1_wasm_exec
+++ b/lib/wasm/go_wasip1_wasm_exec
@@ -14,7 +14,7 @@ case "$GOWASIRUNTIME" in
 		exec wazero run -mount /:/ -env-inherit -cachedir "${TMPDIR:-/tmp}"/wazero ${GOWASIRUNTIMEARGS:-} "$1" "${@:2}"
 		;;
 	"wasmtime" | "")
-		exec wasmtime run --dir=/ --env PWD="$PWD" --env PATH="$PATH" -W max-wasm-stack=8388608 ${GOWASIRUNTIMEARGS:-} "$1" "${@:2}"
+		exec wasmtime run --dir=/ --env PWD="$PWD" --env PATH="$PATH" -W max-wasm-stack=1048576 ${GOWASIRUNTIMEARGS:-} "$1" "${@:2}"
 		;;
 	*)
 		echo "Unknown Go WASI runtime specified: $GOWASIRUNTIME"
--- a/misc/ios/go_ios_exec.go
+++ b/misc/ios/go_ios_exec.go
@@ -212,7 +212,7 @@ func copyLocalData(dstbase string) (pkgpath string, err error) {
 	// Copy all immediate files and testdata directories between
 	// the package being tested and the source root.
 	pkgpath = ""
-	for element := range strings.SplitSeq(finalPkgpath, string(filepath.Separator)) {
+	for _, element := range strings.Split(finalPkgpath, string(filepath.Separator)) {
 		if debug {
 			log.Printf("copying %s", pkgpath)
 		}
--- a/misc/linkcheck/linkcheck.go
+++ b/misc/linkcheck/linkcheck.go
@@ -0,0 +1,191 @@
+// Copyright 2013 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.
+
+// The linkcheck command finds missing links in the godoc website.
+// It crawls a URL recursively and notes URLs and URL fragments
+// that it's seen and prints a report of missing links at the end.
+package main
+
+import (
+	"errors"
+	"flag"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"os"
+	"regexp"
+	"strings"
+	"sync"
+)
+
+var (
+	root    = flag.String("root", "http://localhost:6060", "Root to crawl")
+	verbose = flag.Bool("verbose", false, "verbose")
+)
+
+var wg sync.WaitGroup        // outstanding fetches
+var urlq = make(chan string) // URLs to crawl
+
+// urlFrag is a URL and its optional #fragment (without the #)
+type urlFrag struct {
+	url, frag string
+}
+
+var (
+	mu          sync.Mutex
+	crawled     = make(map[string]bool)      // URL without fragment -> true
+	neededFrags = make(map[urlFrag][]string) // URL#frag -> who needs it
+)
+
+var aRx = regexp.MustCompile(`<a href=['"]?(/[^\s'">]+)`)
+
+// Owned by crawlLoop goroutine:
+var (
+	linkSources = make(map[string][]string) // url no fragment -> sources
+	fragExists  = make(map[urlFrag]bool)
+	problems    []string
+)
+
+func localLinks(body string) (links []string) {
+	seen := map[string]bool{}
+	mv := aRx.FindAllStringSubmatch(body, -1)
+	for _, m := range mv {
+		ref := m[1]
+		if strings.HasPrefix(ref, "/src/") {
+			continue
+		}
+		if !seen[ref] {
+			seen[ref] = true
+			links = append(links, m[1])
+		}
+	}
+	return
+}
+
+var idRx = regexp.MustCompile(`\bid=['"]?([^\s'">]+)`)
+
+func pageIDs(body string) (ids []string) {
+	mv := idRx.FindAllStringSubmatch(body, -1)
+	for _, m := range mv {
+		ids = append(ids, m[1])
+	}
+	return
+}
+
+// url may contain a #fragment, and the fragment is then noted as needing to exist.
+func crawl(url string, sourceURL string) {
+	if strings.Contains(url, "/devel/release") {
+		return
+	}
+	mu.Lock()
+	defer mu.Unlock()
+	if u, frag, ok := strings.Cut(url, "#"); ok {
+		url = u
+		if frag != "" {
+			uf := urlFrag{url, frag}
+			neededFrags[uf] = append(neededFrags[uf], sourceURL)
+		}
+	}
+	if crawled[url] {
+		return
+	}
+	crawled[url] = true
+
+	wg.Add(1)
+	go func() {
+		urlq <- url
+	}()
+}
+
+func addProblem(url, errmsg string) {
+	msg := fmt.Sprintf("Error on %s: %s (from %s)", url, errmsg, linkSources[url])
+	if *verbose {
+		log.Print(msg)
+	}
+	problems = append(problems, msg)
+}
+
+func crawlLoop() {
+	for url := range urlq {
+		if err := doCrawl(url); err != nil {
+			addProblem(url, err.Error())
+		}
+	}
+}
+
+func doCrawl(url string) error {
+	defer wg.Done()
+
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return err
+	}
+	res, err := http.DefaultTransport.RoundTrip(req)
+	if err != nil {
+		return err
+	}
+	// Handle redirects.
+	if res.StatusCode/100 == 3 {
+		newURL, err := res.Location()
+		if err != nil {
+			return fmt.Errorf("resolving redirect: %v", err)
+		}
+		if !strings.HasPrefix(newURL.String(), *root) {
+			// Skip off-site redirects.
+			return nil
+		}
+		crawl(newURL.String(), url)
+		return nil
+	}
+	if res.StatusCode != 200 {
+		return errors.New(res.Status)
+	}
+	slurp, err := io.ReadAll(res.Body)
+	res.Body.Close()
+	if err != nil {
+		log.Fatalf("Error reading %s body: %v", url, err)
+	}
+	if *verbose {
+		log.Printf("Len of %s: %d", url, len(slurp))
+	}
+	body := string(slurp)
+	for _, ref := range localLinks(body) {
+		if *verbose {
+			log.Printf("  links to %s", ref)
+		}
+		dest := *root + ref
+		linkSources[dest] = append(linkSources[dest], url)
+		crawl(dest, url)
+	}
+	for _, id := range pageIDs(body) {
+		if *verbose {
+			log.Printf(" url %s has #%s", url, id)
+		}
+		fragExists[urlFrag{url, id}] = true
+	}
+	return nil
+}
+
+func main() {
+	flag.Parse()
+
+	go crawlLoop()
+	crawl(*root, "")
+
+	wg.Wait()
+	close(urlq)
+	for uf, needers := range neededFrags {
+		if !fragExists[uf] {
+			problems = append(problems, fmt.Sprintf("Missing fragment for %+v from %v", uf, needers))
+		}
+	}
+
+	for _, s := range problems {
+		fmt.Println(s)
+	}
+	if len(problems) > 0 {
+		os.Exit(1)
+	}
+}
--- a/src/all.bash
+++ b/src/all.bash
@@ -10,4 +10,4 @@ if [ ! -f make.bash ]; then
 fi
 . ./make.bash "$@" --no-banner
 bash run.bash --no-rebuild
-../bin/go tool dist banner # print build info
+"$GOTOOLDIR/dist" banner  # print build info
--- a/src/all.bat
+++ b/src/all.bat
@@ -6,11 +6,17 @@

 setlocal

-if not exist make.bat (
-    echo all.bat must be run from go\src
-    exit /b 1
-)
+if exist make.bat goto ok
+echo all.bat must be run from go\src
+:: cannot exit: would kill parent command interpreter
+goto end
+:ok

-call .\make.bat --no-banner || exit /b 1
-call .\run.bat --no-rebuild || exit /b 1
-..\bin\go tool dist banner
+call .\make.bat --no-banner --no-local
+if %GOBUILDFAIL%==1 goto end
+call .\run.bat --no-rebuild --no-local
+if %GOBUILDFAIL%==1 goto end
+"%GOTOOLDIR%/dist" banner
+
+:end
+if x%GOBUILDEXIT%==x1 exit %GOBUILDFAIL%
--- a/src/all.rc
+++ b/src/all.rc
@@ -13,4 +13,4 @@ if(! test -f make.rc){
 . ./make.rc --no-banner $*
 bind -b $GOROOT/bin /bin
 ./run.rc --no-rebuild
-../bin/go tool dist banner # print build info
+$GOTOOLDIR/dist banner  # print build info
--- a/src/archive/tar/common.go
+++ b/src/archive/tar/common.go
@@ -39,7 +39,6 @@ var (
 	errMissData        = errors.New("archive/tar: sparse file references non-existent data")
 	errUnrefData       = errors.New("archive/tar: sparse file contains unreferenced data")
 	errWriteHole       = errors.New("archive/tar: write non-NUL byte in sparse hole")
-	errSparseTooLong   = errors.New("archive/tar: sparse map too long")
 )

 type headerError []string
--- a/src/archive/tar/reader.go
+++ b/src/archive/tar/reader.go
@@ -531,17 +531,12 @@ func readGNUSparseMap1x0(r io.Reader) (sparseDatas, error) {
 		cntNewline int64
 		buf        bytes.Buffer
 		blk        block
-		totalSize  int
 	)

 	// feedTokens copies data in blocks from r into buf until there are
 	// at least cnt newlines in buf. It will not read more blocks than needed.
 	feedTokens := func(n int64) error {
 		for cntNewline < n {
-			totalSize += len(blk)
-			if totalSize > maxSpecialFileSize {
-				return errSparseTooLong
-			}
 			if _, err := mustReadFull(r, blk[:]); err != nil {
 				return err
 			}
@@ -574,8 +569,8 @@ func readGNUSparseMap1x0(r io.Reader) (sparseDatas, error) {
 	}

 	// Parse for all member entries.
-	// numEntries is trusted after this since feedTokens limits the number of
-	// tokens based on maxSpecialFileSize.
+	// numEntries is trusted after this since a potential attacker must have
+	// committed resources proportional to what this library used.
 	if err := feedTokens(2 * numEntries); err != nil {
 		return nil, err
 	}
--- a/src/archive/tar/reader_test.go
+++ b/src/archive/tar/reader_test.go
@@ -10,7 +10,6 @@ import (
 	"errors"
 	"fmt"
 	"hash/crc32"
-	"internal/obscuretestdata"
 	"io"
 	"maps"
 	"math"
@@ -26,11 +25,10 @@ import (

 func TestReader(t *testing.T) {
 	vectors := []struct {
-		file     string    // Test input file
-		obscured bool      // Obscured with obscuretestdata package
-		headers  []*Header // Expected output headers
-		chksums  []string  // CRC32 checksum of files, leave as nil if not checked
-		err      error     // Expected error to occur
+		file    string    // Test input file
+		headers []*Header // Expected output headers
+		chksums []string  // CRC32 checksum of files, leave as nil if not checked
+		err     error     // Expected error to occur
 	}{{
 		file: "testdata/gnu.tar",
 		headers: []*Header{{
@@ -525,9 +523,8 @@ func TestReader(t *testing.T) {
 		file: "testdata/pax-nul-path.tar",
 		err:  ErrHeader,
 	}, {
-		file:     "testdata/neg-size.tar.base64",
-		obscured: true,
-		err:      ErrHeader,
+		file: "testdata/neg-size.tar",
+		err:  ErrHeader,
 	}, {
 		file: "testdata/issue10968.tar",
 		err:  ErrHeader,
@@ -624,32 +621,18 @@ func TestReader(t *testing.T) {
 			},
 			Format: FormatPAX,
 		}},
-	}, {
-		// Small compressed file that uncompresses to
-		// a file with a very large GNU 1.0 sparse map.
-		file: "testdata/gnu-sparse-many-zeros.tar.bz2",
-		err:  errSparseTooLong,
 	}}

 	for _, v := range vectors {
-		t.Run(strings.TrimSuffix(path.Base(v.file), ".base64"), func(t *testing.T) {
-			path := v.file
-			if v.obscured {
-				tf, err := obscuretestdata.DecodeToTempFile(path)
-				if err != nil {
-					t.Fatalf("obscuredtestdata.DecodeToTempFile(%s): %v", path, err)
-				}
-				path = tf
-			}
-
-			f, err := os.Open(path)
+		t.Run(path.Base(v.file), func(t *testing.T) {
+			f, err := os.Open(v.file)
 			if err != nil {
 				t.Fatalf("unexpected error: %v", err)
 			}
 			defer f.Close()

 			var fr io.Reader = f
-			if strings.HasSuffix(v.file, ".bz2") || strings.HasSuffix(v.file, ".bz2.base64") {
+			if strings.HasSuffix(v.file, ".bz2") {
 				fr = bzip2.NewReader(fr)
 			}

@@ -787,7 +770,7 @@ type readBadSeeker struct{ io.ReadSeeker }

 func (rbs *readBadSeeker) Seek(int64, int) (int64, error) { return 0, fmt.Errorf("illegal seek") }

-// TestReadTruncation tests the ending condition on various truncated files and
+// TestReadTruncation test the ending condition on various truncated files and
 // that truncated files are still detected even if the underlying io.Reader
 // satisfies io.Seeker.
 func TestReadTruncation(t *testing.T) {
--- a/src/archive/tar/stat_unix.go
+++ b/src/archive/tar/stat_unix.go
@@ -19,7 +19,7 @@ func init() {
 	sysStat = statUnix
 }

-// userMap and groupMap cache UID and GID lookups for performance reasons.
+// userMap and groupMap caches UID and GID lookups for performance reasons.
 // The downside is that renaming uname or gname by the OS never takes effect.
 var userMap, groupMap sync.Map // map[int]string

--- a/src/archive/tar/strconv.go
+++ b/src/archive/tar/strconv.go
@@ -213,17 +213,15 @@ func parsePAXTime(s string) (time.Time, error) {
 	}

 	// Parse the nanoseconds.
-	// Initialize an array with '0's to handle right padding automatically.
-	nanoDigits := [maxNanoSecondDigits]byte{'0', '0', '0', '0', '0', '0', '0', '0', '0'}
-	for i := range len(sn) {
-		switch c := sn[i]; {
-		case c < '0' || c > '9':
-			return time.Time{}, ErrHeader
-		case i < len(nanoDigits):
-			nanoDigits[i] = c
-		}
+	if strings.Trim(sn, "0123456789") != "" {
+		return time.Time{}, ErrHeader
 	}
-	nsecs, _ := strconv.ParseInt(string(nanoDigits[:]), 10, 64) // Must succeed after validation
+	if len(sn) < maxNanoSecondDigits {
+		sn += strings.Repeat("0", maxNanoSecondDigits-len(sn)) // Right pad
+	} else {
+		sn = sn[:maxNanoSecondDigits] // Right truncate
+	}
+	nsecs, _ := strconv.ParseInt(sn, 10, 64) // Must succeed
 	if len(ss) > 0 && ss[0] == '-' {
 		return time.Unix(secs, -1*nsecs), nil // Negative correction
 	}
@@ -312,7 +310,7 @@ func formatPAXRecord(k, v string) (string, error) {
 //	"%d %s=%s\n" % (size, key, value)
 //
 // Keys and values should be UTF-8, but the number of bad writers out there
-// forces us to be more liberal.
+// forces us to be a more liberal.
 // Thus, we only reject all keys with NUL, and only reject NULs in values
 // for the PAX version of the USTAR string fields.
 // The key must not contain an '=' character.
--- a/src/archive/tar/strconv_test.go
+++ b/src/archive/tar/strconv_test.go
@@ -439,66 +439,3 @@ func TestFormatPAXRecord(t *testing.T) {
 		}
 	}
 }
-
-func BenchmarkParsePAXTime(b *testing.B) {
-	tests := []struct {
-		name string
-		in   string
-		want time.Time
-		ok   bool
-	}{
-		{
-			name: "NoNanos",
-			in:   "123456",
-			want: time.Unix(123456, 0),
-			ok:   true,
-		},
-		{
-			name: "ExactNanos",
-			in:   "1.123456789",
-			want: time.Unix(1, 123456789),
-			ok:   true,
-		},
-		{
-			name: "WithNanoPadding",
-			in:   "1.123",
-			want: time.Unix(1, 123000000),
-			ok:   true,
-		},
-		{
-			name: "WithNanoTruncate",
-			in:   "1.123456789123",
-			want: time.Unix(1, 123456789),
-			ok:   true,
-		},
-		{
-			name: "TrailingError",
-			in:   "1.123abc",
-			want: time.Time{},
-			ok:   false,
-		},
-		{
-			name: "LeadingError",
-			in:   "1.abc123",
-			want: time.Time{},
-			ok:   false,
-		},
-	}
-	for _, tt := range tests {
-		b.Run(tt.name, func(b *testing.B) {
-			b.ReportAllocs()
-			for b.Loop() {
-				ts, err := parsePAXTime(tt.in)
-				if (err == nil) != tt.ok {
-					if err != nil {
-						b.Fatal(err)
-					}
-					b.Fatal("expected error")
-				}
-				if !ts.Equal(tt.want) {
-					b.Fatalf("time mismatch: got %v, want %v", ts, tt.want)
-				}
-			}
-		})
-	}
-}
--- a/src/archive/tar/testdata/gnu-sparse-big.tar
+++ b/src/archive/tar/testdata/gnu-sparse-big.tar
--- a/src/archive/tar/testdata/gnu-sparse-big.tar.base64
+++ b/src/archive/tar/testdata/gnu-sparse-big.tar.base64
@@ -1,90 +0,0 @@
-Z251LXNwYXJzZQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwMDAwMDAAMDAwMDAw
-MAAwMDAwMDAwADAwMDAwMDA2MDAwADAwMDAwMDAwMDAwADAyMjIyNwAgUwAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB1c3RhciAgAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMDAwMDAwADAwMDAw
-MDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACAAAAAAAAAAlQL4gAw
-MDAwMDAwMTAwMACAAAAAAAAABKgXxgAwMDAwMDAwMTAwMACAAAAAAAAABvwjqgAwMDAwMDAwMTAw
-MACAAAAAAAAACVAvjgAwMDAwMDAwMTAwMAABgAAAAAAAAA34R1gAAAAAAAAAAAAAAAAAAAAAAACA
-AAAAAAAAC6Q7cgAwMDAwMDAwMTAwMACAAAAAAAAADfhHVgAwMDAwMDAwMTAwMAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAwMTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1
-Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5AAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAADAxMjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2
-Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAMDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3
-ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OQAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAwMTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4
-OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5AAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAADAxMjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5
-MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAMDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkw
-MTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OQAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=
--- a/src/archive/tar/testdata/gnu-sparse-many-zeros.tar.bz2
+++ b/src/archive/tar/testdata/gnu-sparse-many-zeros.tar.bz2
--- a/src/archive/tar/testdata/neg-size.tar
+++ b/src/archive/tar/testdata/neg-size.tar
--- a/src/archive/tar/testdata/neg-size.tar.base64
+++ b/src/archive/tar/testdata/neg-size.tar.base64
@@ -1,9 +0,0 @@
-EwMwMBMDLTgyMTk1MDI5NnQTE4NzfINzEzAwcXfhZrsDMDAwAAAAEDAxMRNz9DEwMTAwdBMTg3N8
-g3NzADATc3yDc3P0eFMTc/QxMDEwMHQTE4NzfINzc/QwE3N8g3Nz9HFTMNR0MBMwMHEw9DAAAAAQ
-MDGAABAwMTETc/QxMDH0MHQTMDBx1OFmuwMAAAD/gICAADExNTYyMQAgMBP///+AMTAwdHhTMDB0
-MBMwMHF3MDEwMTAwdBMTg3N8g3Nz9HhTMDB0MBMwMHF34Wa7AzAwMAAAABAwMTETc/QxMDEwMHQT
-E4NzfINzc/QwE3N8g3Nz9HhTE3P0MTAxMDB0ExODc3yDc3MwMBNzfINzczB4UzAwdDATMDBxMDAA
-gAAAEDAxc/QxMDEwMHQTAAAAIOFmuwMwNAAAABAwMTET////gDEwMHR4UzAwdDATMDBxd+FmuwMw
-MDAAAAAQMDExE3ODc3P0eFMTc/QxMDEwMHQTE4NzfINzc/QzMTEwMzM2MjQ4NDYxMjgzODBzfINz
-c/R4UzAwdDATMDBxMDAwAAAAEDAxAAAQMDExE3P0MTAxMDB0EzAwcdThZrsDMDQAAAAQg3N8g3Nz
-9DATc3yDc3P0eFMwMHQwEzAwcTAwMAAAABAwMQAAEDAxMRNz9DEwMTAwdBMwMHgw4Wa7AwAAEDA=
--- a/src/archive/tar/testdata/pax-sparse-big.tar
+++ b/src/archive/tar/testdata/pax-sparse-big.tar
--- a/src/archive/tar/testdata/pax-sparse-big.tar.base64
+++ b/src/archive/tar/testdata/pax-sparse-big.tar.base64
@@ -1,108 +0,0 @@
-UGF4SGVhZGVycy4wL3BheC1zcGFyc2UAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAADAwMDAwMDAAMDAwMDAw
-MAAwMDAwMDAwADAwMDAwMDAwMTcyADAwMDAwMDAwMDAwADAxMjIyNwAgeAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB1c3RhcgAwMAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAy
-MiBHTlUuc3BhcnNlLm1ham9yPTEKMjIgR05VLnNwYXJzZS5taW5vcj0wCjMwIEdOVS5zcGFyc2Uu
-bmFtZT1wYXgtc3BhcnNlCjM1IEdOVS5zcGFyc2UucmVhbHNpemU9NjAwMDAwMDAwMDAKMTMgc2l6
-ZT0zNTg0CgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEdO
-VVNwYXJzZUZpbGUuMC9wYXgtc3BhcnNlAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwMDAwMDAwADAwMDAwMDAA
-MDAwMDAwMAAwMDAwMDAwNzAwMAAwMDAwMDAwMDAwMAAwMTM3MzcAIDAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAdXN0YXIAMDAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAwMDAwMAAwMDAwMDAw
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAANgo5
-OTk5OTk5NDg4CjUxMgoxOTk5OTk5OTQ4OAo1MTIKMjk5OTk5OTk0ODgKNTEyCjM5OTk5OTk5NDg4
-CjUxMgo0OTk5OTk5OTQ4OAo1MTIKNTk5OTk5OTk0ODgKNTEyCgAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAMDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3
-ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OQAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAwMTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4
-OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5AAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAADAxMjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5
-MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAMDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkw
-MTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OQAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAwMTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OTAx
-MjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5AAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAADAxMjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDEy
-MzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDEyMzQ1Njc4OTAxMjM0NTY3ODkAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
--- a/src/archive/tar/testdata/writer-big-long.tar
+++ b/src/archive/tar/testdata/writer-big-long.tar
--- a/src/archive/tar/testdata/writer-big-long.tar.base64
+++ b/src/archive/tar/testdata/writer-big-long.tar.base64
@@ -1,27 +0,0 @@
-bG9uZ25hbWUvbG9uZ25hbWUvbG9uZ25hbWUvbG9uZ25hbWUvbG9uZ25hbWUvbG9uZ25hbWUvbG9u
-Z25hbWUvbG9uZ25hbWUvbG9uZ25hbWUvbG9uZ25hbWUvbG9uZ25hbWUvbDAwMDAwMDAAMDAwMDAw
-MAAwMDAwMDAwADAwMDAwMDAwMjU2ADAwMDAwMDAwMDAwADAzMTQyMAAgeAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAB1c3RhcgAwMAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAx
-NTQgcGF0aD1sb25nbmFtZS9sb25nbmFtZS9sb25nbmFtZS9sb25nbmFtZS9sb25nbmFtZS9sb25n
-bmFtZS9sb25nbmFtZS9sb25nbmFtZS9sb25nbmFtZS9sb25nbmFtZS9sb25nbmFtZS9sb25nbmFt
-ZS9sb25nbmFtZS9sb25nbmFtZS9sb25nbmFtZS8xNmdpZy50eHQKMjAgc2l6ZT0xNzE3OTg2OTE4
-NAoAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAGxv
-bmduYW1lL2xvbmduYW1lL2xvbmduYW1lL2xvbmduYW1lL2xvbmduYW1lL2xvbmduYW1lL2xvbmdu
-YW1lL2xvbmduYW1lL2xvbmduYW1lL2xvbmduYW1lL2xvbmduYW1lL2wwMDAwNjQ0ADAwMDE3NTAA
-MDAwMTc1MAAwMDAwMDAwMDAwMAAxMjMzMjc3MDUwNwAwMzY0NjIAIDAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAdXN0YXIAMDBndWlsbGF1bWUAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAGd1aWxsYXVtZQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMDAwMDAwMAAwMDAwMDAw
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
-AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
--- a/src/archive/tar/writer.go
+++ b/src/archive/tar/writer.go
@@ -415,17 +415,11 @@ func (tw *Writer) AddFS(fsys fs.FS) error {
 		if err != nil {
 			return err
 		}
-		linkTarget := ""
-		if typ := d.Type(); typ == fs.ModeSymlink {
-			var err error
-			linkTarget, err = fs.ReadLink(fsys, name)
-			if err != nil {
-				return err
-			}
-		} else if !typ.IsRegular() && typ != fs.ModeDir {
+		// TODO(#49580): Handle symlinks when fs.ReadLinkFS is available.
+		if !d.IsDir() && !info.Mode().IsRegular() {
 			return errors.New("tar: cannot add non-regular file")
 		}
-		h, err := FileInfoHeader(info, linkTarget)
+		h, err := FileInfoHeader(info, "")
 		if err != nil {
 			return err
 		}
@@ -436,7 +430,7 @@ func (tw *Writer) AddFS(fsys fs.FS) error {
 		if err := tw.WriteHeader(h); err != nil {
 			return err
 		}
-		if !d.Type().IsRegular() {
+		if d.IsDir() {
 			return nil
 		}
 		f, err := fsys.Open(name)
--- a/src/archive/tar/writer_test.go
+++ b/src/archive/tar/writer_test.go
@@ -8,7 +8,6 @@ import (
 	"bytes"
 	"encoding/hex"
 	"errors"
-	"internal/obscuretestdata"
 	"io"
 	"io/fs"
 	"maps"
@@ -75,9 +74,8 @@ func TestWriter(t *testing.T) {
 	)

 	vectors := []struct {
-		file     string // Optional filename of expected output
-		obscured bool   // Whether file is obscured
-		tests    []testFnc
+		file  string // Optional filename of expected output
+		tests []testFnc
 	}{{
 		// The writer test file was produced with this command:
 		// tar (GNU tar) 1.26
@@ -153,8 +151,7 @@ func TestWriter(t *testing.T) {
 		//  bsdtar -xvf writer-big-long.tar
 		//
 		// This file is in PAX format.
-		file:     "testdata/writer-big-long.tar.base64",
-		obscured: true,
+		file: "testdata/writer-big-long.tar",
 		tests: []testFnc{
 			testHeader{Header{
 				Typeflag: TypeReg,
@@ -396,8 +393,7 @@ func TestWriter(t *testing.T) {
 					testClose{},
 				},
 			}, {
-				file:     "testdata/gnu-sparse-big.tar.base64",
-				obscured: true,
+				file: "testdata/gnu-sparse-big.tar",
 				tests: []testFnc{
 					testHeader{Header{
 						Typeflag: TypeGNUSparse,
@@ -429,8 +425,7 @@ func TestWriter(t *testing.T) {
 					testClose{nil},
 				},
 			}, {
-				file:     "testdata/pax-sparse-big.tar.base64",
-				obscured: true,
+				file: "testdata/pax-sparse-big.tar",
 				tests: []testFnc{
 					testHeader{Header{
 						Typeflag: TypeReg,
@@ -488,7 +483,7 @@ func TestWriter(t *testing.T) {
 		return x == y
 	}
 	for _, v := range vectors {
-		t.Run(strings.TrimSuffix(path.Base(v.file), ".base64"), func(t *testing.T) {
+		t.Run(path.Base(v.file), func(t *testing.T) {
 			const maxSize = 10 << 10 // 10KiB
 			buf := new(bytes.Buffer)
 			tw := NewWriter(iotest.TruncateWriter(buf, maxSize))
@@ -527,16 +522,7 @@ func TestWriter(t *testing.T) {
 			}

 			if v.file != "" {
-				path := v.file
-				if v.obscured {
-					tf, err := obscuretestdata.DecodeToTempFile(path)
-					if err != nil {
-						t.Fatalf("obscuretestdata.DecodeToTempFile(%s): %v", path, err)
-					}
-					path = tf
-				}
-
-				want, err := os.ReadFile(path)
+				want, err := os.ReadFile(v.file)
 				if err != nil {
 					t.Fatalf("ReadFile() = %v, want nil", err)
 				}
@@ -1356,7 +1342,6 @@ func TestWriterAddFS(t *testing.T) {
 		"emptyfolder":          {Mode: 0o755 | os.ModeDir},
 		"file.go":              {Data: []byte("hello")},
 		"subfolder/another.go": {Data: []byte("world")},
-		"symlink.go":           {Mode: 0o777 | os.ModeSymlink, Data: []byte("file.go")},
 		// Notably missing here is the "subfolder" directory. This makes sure even
 		// if we don't have a subfolder directory listed.
 	}
@@ -1385,7 +1370,7 @@ func TestWriterAddFS(t *testing.T) {
 	for _, name := range names {
 		entriesLeft--

-		entryInfo, err := fsys.Lstat(name)
+		entryInfo, err := fsys.Stat(name)
 		if err != nil {
 			t.Fatalf("getting entry info error: %v", err)
 		}
@@ -1411,23 +1396,18 @@ func TestWriterAddFS(t *testing.T) {
 				name, entryInfo.Mode(), hdr.FileInfo().Mode())
 		}

-		switch entryInfo.Mode().Type() {
-		case fs.ModeDir:
-			// No additional checks necessary.
-		case fs.ModeSymlink:
-			origtarget := string(fsys[name].Data)
-			if hdr.Linkname != origtarget {
-				t.Fatalf("test fs has link content %s; archive header %v", origtarget, hdr.Linkname)
-			}
-		default:
-			data, err := io.ReadAll(tr)
-			if err != nil {
-				t.Fatal(err)
-			}
-			origdata := fsys[name].Data
-			if string(data) != string(origdata) {
-				t.Fatalf("test fs has file content %v; archive header has %v", origdata, data)
-			}
+		if entryInfo.IsDir() {
+			continue
+		}
+
+		data, err := io.ReadAll(tr)
+		if err != nil {
+			t.Fatal(err)
+		}
+		origdata := fsys[name].Data
+		if string(data) != string(origdata) {
+			t.Fatalf("test fs has file content %v; archive header has %v",
+				data, origdata)
 		}
 	}
 	if entriesLeft > 0 {
--- a/src/archive/zip/reader.go
+++ b/src/archive/zip/reader.go
@@ -8,7 +8,6 @@ import (
 	"bufio"
 	"encoding/binary"
 	"errors"
-	"fmt"
 	"hash"
 	"hash/crc32"
 	"internal/godebug"
@@ -805,9 +804,6 @@ func toValidName(name string) string {

 func (r *Reader) initFileList() {
 	r.fileListOnce.Do(func() {
-		// Preallocate the minimum size of the index.
-		// We may also synthesize additional directory entries.
-		r.fileList = make([]fileListEntry, 0, len(r.File))
 		// files and knownDirs map from a file/directory name
 		// to an index into the r.fileList entry that we are
 		// building. They are used to mark duplicate entries.
@@ -989,12 +985,6 @@ func (d *openDir) ReadDir(count int) ([]fs.DirEntry, error) {
 		s, err := d.files[d.offset+i].stat()
 		if err != nil {
 			return nil, err
-		} else if s.Name() == "." || !fs.ValidPath(s.Name()) {
-			return nil, &fs.PathError{
-				Op:   "readdir",
-				Path: d.e.name,
-				Err:  fmt.Errorf("invalid file name: %v", d.files[d.offset+i].name),
-			}
 		}
 		list[i] = s
 	}
--- a/src/archive/zip/reader_test.go
+++ b/src/archive/zip/reader_test.go
@@ -8,7 +8,6 @@ import (
 	"bytes"
 	"encoding/binary"
 	"encoding/hex"
-	"errors"
 	"internal/obscuretestdata"
 	"io"
 	"io/fs"
@@ -1213,6 +1212,7 @@ func TestFS(t *testing.T) {
 			[]string{"a/b/c"},
 		},
 	} {
+		test := test
 		t.Run(test.file, func(t *testing.T) {
 			t.Parallel()
 			z, err := OpenReader(test.file)
@@ -1246,6 +1246,7 @@ func TestFSWalk(t *testing.T) {
 			wantErr: true,
 		},
 	} {
+		test := test
 		t.Run(test.file, func(t *testing.T) {
 			t.Parallel()
 			z, err := OpenReader(test.file)
@@ -1280,49 +1281,6 @@ func TestFSWalk(t *testing.T) {
 	}
 }

-func TestFSWalkBadFile(t *testing.T) {
-	t.Parallel()
-
-	var buf bytes.Buffer
-	zw := NewWriter(&buf)
-	hdr := &FileHeader{Name: "."}
-	hdr.SetMode(fs.ModeDir | 0o755)
-	w, err := zw.CreateHeader(hdr)
-	if err != nil {
-		t.Fatalf("create zip header: %v", err)
-	}
-	_, err = w.Write([]byte("some data"))
-	if err != nil {
-		t.Fatalf("write zip contents: %v", err)
-
-	}
-	err = zw.Close()
-	if err != nil {
-		t.Fatalf("close zip writer: %v", err)
-
-	}
-
-	zr, err := NewReader(bytes.NewReader(buf.Bytes()), int64(buf.Len()))
-	if err != nil {
-		t.Fatalf("create zip reader: %v", err)
-
-	}
-	var count int
-	var errRepeat = errors.New("repeated call to path")
-	err = fs.WalkDir(zr, ".", func(p string, d fs.DirEntry, err error) error {
-		count++
-		if count > 2 { // once for directory read, once for the error
-			return errRepeat
-		}
-		return err
-	})
-	if err == nil {
-		t.Fatalf("expected error from invalid file name")
-	} else if errors.Is(err, errRepeat) {
-		t.Fatal(err)
-	}
-}
-
 func TestFSModTime(t *testing.T) {
 	t.Parallel()
 	z, err := OpenReader("testdata/subdir.zip")
--- a/src/bufio/bufio.go
+++ b/src/bufio/bufio.go
@@ -311,7 +311,10 @@ func (b *Reader) ReadRune() (r rune, size int, err error) {
 	if b.r == b.w {
 		return 0, 0, b.readErr()
 	}
-	r, size = utf8.DecodeRune(b.buf[b.r:b.w])
+	r, size = rune(b.buf[b.r]), 1
+	if r >= utf8.RuneSelf {
+		r, size = utf8.DecodeRune(b.buf[b.r:b.w])
+	}
 	b.r += size
 	b.lastByte = int(b.buf[b.r-1])
 	b.lastRuneSize = size
@@ -516,11 +519,9 @@ func (b *Reader) WriteTo(w io.Writer) (n int64, err error) {
 	b.lastByte = -1
 	b.lastRuneSize = -1

-	if b.r < b.w {
-		n, err = b.writeBuf(w)
-		if err != nil {
-			return
-		}
+	n, err = b.writeBuf(w)
+	if err != nil {
+		return
 	}

 	if r, ok := b.rd.(io.WriterTo); ok {
--- a/src/bufio/bufio_test.go
+++ b/src/bufio/bufio_test.go
@@ -1149,7 +1149,7 @@ func (w errorWriterToTest) Write(p []byte) (int, error) {
 var errorWriterToTests = []errorWriterToTest{
 	{1, 0, nil, io.ErrClosedPipe, io.ErrClosedPipe},
 	{0, 1, io.ErrClosedPipe, nil, io.ErrClosedPipe},
-	{0, 0, io.ErrUnexpectedEOF, io.ErrClosedPipe, io.ErrUnexpectedEOF},
+	{0, 0, io.ErrUnexpectedEOF, io.ErrClosedPipe, io.ErrClosedPipe},
 	{0, 1, io.EOF, nil, nil},
 }

--- a/src/bufio/net_test.go
+++ b/src/bufio/net_test.go
@@ -1,96 +0,0 @@
-// 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 unix
-
-package bufio_test
-
-import (
-	"bufio"
-	"io"
-	"net"
-	"path/filepath"
-	"strings"
-	"sync"
-	"testing"
-)
-
-// TestCopyUnixpacket tests that we can use bufio when copying
-// across a unixpacket socket. This used to fail due to an unnecessary
-// empty Write call that was interpreted as an EOF.
-func TestCopyUnixpacket(t *testing.T) {
-	tmpDir := t.TempDir()
-	socket := filepath.Join(tmpDir, "unixsock")
-
-	// Start a unixpacket server.
-	addr := &net.UnixAddr{
-		Name: socket,
-		Net:  "unixpacket",
-	}
-	server, err := net.ListenUnix("unixpacket", addr)
-	if err != nil {
-		t.Skipf("skipping test because opening a unixpacket socket failed: %v", err)
-	}
-
-	// Start a goroutine for the server to accept one connection
-	// and read all the data sent on the connection,
-	// reporting the number of bytes read on ch.
-	ch := make(chan int, 1)
-	var wg sync.WaitGroup
-	wg.Add(1)
-	go func() {
-		defer wg.Done()
-
-		tot := 0
-		defer func() {
-			ch <- tot
-		}()
-
-		serverConn, err := server.Accept()
-		if err != nil {
-			t.Error(err)
-			return
-		}
-
-		buf := make([]byte, 1024)
-		for {
-			n, err := serverConn.Read(buf)
-			tot += n
-			if err == io.EOF {
-				return
-			}
-			if err != nil {
-				t.Error(err)
-				return
-			}
-		}
-	}()
-
-	clientConn, err := net.DialUnix("unixpacket", nil, addr)
-	if err != nil {
-		// Leaves the server goroutine hanging. Oh well.
-		t.Fatal(err)
-	}
-
-	defer wg.Wait()
-	defer clientConn.Close()
-
-	const data = "data"
-	r := bufio.NewReader(strings.NewReader(data))
-	n, err := io.Copy(clientConn, r)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	if n != int64(len(data)) {
-		t.Errorf("io.Copy returned %d, want %d", n, len(data))
-	}
-
-	clientConn.Close()
-	tot := <-ch
-
-	if tot != len(data) {
-		t.Errorf("server read %d, want %d", tot, len(data))
-	}
-}
--- a/src/bufio/scan.go
+++ b/src/bufio/scan.go
@@ -260,11 +260,8 @@ func (s *Scanner) setErr(err error) {
 	}
 }

-// Buffer controls memory allocation by the Scanner.
-// It sets the initial buffer to use when scanning
+// Buffer sets the initial buffer to use when scanning
 // and the maximum size of buffer that may be allocated during scanning.
-// The contents of the buffer are ignored.
-//
 // The maximum token size must be less than the larger of max and cap(buf).
 // If max <= cap(buf), [Scanner.Scan] will use this buffer only and do no allocation.
 //
--- a/src/bytes/buffer.go
+++ b/src/bytes/buffer.go
@@ -21,12 +21,6 @@ type Buffer struct {
 	buf      []byte // contents are the bytes buf[off : len(buf)]
 	off      int    // read at &buf[off], write at &buf[len(buf)]
 	lastRead readOp // last read operation, so that Unread* can work correctly.
-
-	// Copying and modifying a non-zero Buffer is prone to error,
-	// but we cannot employ the noCopy trick used by WaitGroup and Mutex,
-	// which causes vet's copylocks checker to report misuse, as vet
-	// cannot reliably distinguish the zero and non-zero cases.
-	// See #26462, #25907, #47276, #48398 for history.
 }

 // The readOp constants describe the last action performed on
@@ -77,18 +71,6 @@ func (b *Buffer) String() string {
 	return string(b.buf[b.off:])
 }

-// Peek returns the next n bytes without advancing the buffer.
-// If Peek returns fewer than n bytes, it also returns [io.EOF].
-// The slice is only valid until the next call to a read or write method.
-// The slice aliases the buffer content at least until the next buffer modification,
-// so immediate changes to the slice will affect the result of future reads.
-func (b *Buffer) Peek(n int) ([]byte, error) {
-	if b.Len() < n {
-		return b.buf[b.off:], io.EOF
-	}
-	return b.buf[b.off : b.off+n], nil
-}
-
 // empty reports whether the unread portion of the buffer is empty.
 func (b *Buffer) empty() bool { return len(b.buf) <= b.off }

--- a/src/bytes/buffer_test.go
+++ b/src/bytes/buffer_test.go
@@ -354,7 +354,7 @@ func TestWriteAppend(t *testing.T) {
 		got.Write(b)
 	}
 	if !Equal(got.Bytes(), want) {
-		t.Fatalf("Bytes() = %q, want %q", &got, want)
+		t.Fatalf("Bytes() = %q, want %q", got, want)
 	}

 	// With a sufficiently sized buffer, there should be no allocations.
@@ -531,40 +531,6 @@ func TestReadString(t *testing.T) {
 	}
 }

-var peekTests = []struct {
-	buffer   string
-	skip     int
-	n        int
-	expected string
-	err      error
-}{
-	{"", 0, 0, "", nil},
-	{"aaa", 0, 3, "aaa", nil},
-	{"foobar", 0, 2, "fo", nil},
-	{"a", 0, 2, "a", io.EOF},
-	{"helloworld", 4, 3, "owo", nil},
-	{"helloworld", 5, 5, "world", nil},
-	{"helloworld", 5, 6, "world", io.EOF},
-	{"helloworld", 10, 1, "", io.EOF},
-}
-
-func TestPeek(t *testing.T) {
-	for _, test := range peekTests {
-		buf := NewBufferString(test.buffer)
-		buf.Next(test.skip)
-		bytes, err := buf.Peek(test.n)
-		if string(bytes) != test.expected {
-			t.Errorf("expected %q, got %q", test.expected, bytes)
-		}
-		if err != test.err {
-			t.Errorf("expected error %v, got %v", test.err, err)
-		}
-		if buf.Len() != len(test.buffer)-test.skip {
-			t.Errorf("bad length after peek: %d, want %d", buf.Len(), len(test.buffer)-test.skip)
-		}
-	}
-}
-
 func BenchmarkReadString(b *testing.B) {
 	const n = 32 << 10

--- a/src/bytes/bytes.go
+++ b/src/bytes/bytes.go
@@ -451,9 +451,7 @@ var asciiSpace = [256]uint8{'\t': 1, '\n': 1, '\v': 1, '\f': 1, '\r': 1, ' ': 1}
 // Fields interprets s as a sequence of UTF-8-encoded code points.
 // It splits the slice s around each instance of one or more consecutive white space
 // characters, as defined by [unicode.IsSpace], returning a slice of subslices of s or an
-// empty slice if s contains only white space. Every element of the returned slice is
-// non-empty. Unlike [Split], leading and trailing runs of white space characters
-// are discarded.
+// empty slice if s contains only white space.
 func Fields(s []byte) [][]byte {
 	// First count the fields.
 	// This is an exact count if s is ASCII, otherwise it is an approximation.
@@ -507,9 +505,7 @@ func Fields(s []byte) [][]byte {
 // FieldsFunc interprets s as a sequence of UTF-8-encoded code points.
 // It splits the slice s at each run of code points c satisfying f(c) and
 // returns a slice of subslices of s. If all code points in s satisfy f(c), or
-// len(s) == 0, an empty slice is returned. Every element of the returned slice is
-// non-empty. Unlike [Split], leading and trailing runs of code points
-// satisfying f(c) are discarded.
+// len(s) == 0, an empty slice is returned.
 //
 // FieldsFunc makes no guarantees about the order in which it calls f(c)
 // and assumes that f always returns the same value for a given c.
@@ -528,7 +524,11 @@ func FieldsFunc(s []byte, f func(rune) bool) [][]byte {
 	// more efficient, possibly due to cache effects.
 	start := -1 // valid span start if >= 0
 	for i := 0; i < len(s); {
-		r, size := utf8.DecodeRune(s[i:])
+		size := 1
+		r := rune(s[i])
+		if r >= utf8.RuneSelf {
+			r, size = utf8.DecodeRune(s[i:])
+		}
 		if f(r) {
 			if start >= 0 {
 				spans = append(spans, span{start, i})
@@ -610,7 +610,11 @@ func Map(mapping func(r rune) rune, s []byte) []byte {
 	// fine. It could also shrink but that falls out naturally.
 	b := make([]byte, 0, len(s))
 	for i := 0; i < len(s); {
-		r, wid := utf8.DecodeRune(s[i:])
+		wid := 1
+		r := rune(s[i])
+		if r >= utf8.RuneSelf {
+			r, wid = utf8.DecodeRune(s[i:])
+		}
 		r = mapping(r)
 		if r >= 0 {
 			b = utf8.AppendRune(b, r)
@@ -909,7 +913,11 @@ func LastIndexFunc(s []byte, f func(r rune) bool) int {
 func indexFunc(s []byte, f func(r rune) bool, truth bool) int {
 	start := 0
 	for start < len(s) {
-		r, wid := utf8.DecodeRune(s[start:])
+		wid := 1
+		r := rune(s[start])
+		if r >= utf8.RuneSelf {
+			r, wid = utf8.DecodeRune(s[start:])
+		}
 		if f(r) == truth {
 			return start
 		}
@@ -1040,7 +1048,10 @@ func trimLeftASCII(s []byte, as *asciiSet) []byte {

 func trimLeftUnicode(s []byte, cutset string) []byte {
 	for len(s) > 0 {
-		r, n := utf8.DecodeRune(s)
+		r, n := rune(s[0]), 1
+		if r >= utf8.RuneSelf {
+			r, n = utf8.DecodeRune(s)
+		}
 		if !containsRune(cutset, r) {
 			break
 		}
@@ -1102,34 +1113,41 @@ func trimRightUnicode(s []byte, cutset string) []byte {
 // TrimSpace returns a subslice of s by slicing off all leading and
 // trailing white space, as defined by Unicode.
 func TrimSpace(s []byte) []byte {
-	// Fast path for ASCII: look for the first ASCII non-space byte.
-	for lo, c := range s {
+	// Fast path for ASCII: look for the first ASCII non-space byte
+	start := 0
+	for ; start < len(s); start++ {
+		c := s[start]
 		if c >= utf8.RuneSelf {
 			// If we run into a non-ASCII byte, fall back to the
-			// slower unicode-aware method on the remaining bytes.
-			return TrimFunc(s[lo:], unicode.IsSpace)
+			// slower unicode-aware method on the remaining bytes
+			return TrimFunc(s[start:], unicode.IsSpace)
 		}
-		if asciiSpace[c] != 0 {
-			continue
-		}
-		s = s[lo:]
-		// Now look for the first ASCII non-space byte from the end.
-		for hi := len(s) - 1; hi >= 0; hi-- {
-			c := s[hi]
-			if c >= utf8.RuneSelf {
-				return TrimFunc(s[:hi+1], unicode.IsSpace)
-			}
-			if asciiSpace[c] == 0 {
-				// At this point, s[:hi+1] starts and ends with ASCII
-				// non-space bytes, so we're done. Non-ASCII cases have
-				// already been handled above.
-				return s[:hi+1]
-			}
+		if asciiSpace[c] == 0 {
+			break
 		}
 	}
-	// Special case to preserve previous TrimLeftFunc behavior,
-	// returning nil instead of empty slice if all spaces.
-	return nil
+
+	// Now look for the first ASCII non-space byte from the end
+	stop := len(s)
+	for ; stop > start; stop-- {
+		c := s[stop-1]
+		if c >= utf8.RuneSelf {
+			return TrimFunc(s[start:stop], unicode.IsSpace)
+		}
+		if asciiSpace[c] == 0 {
+			break
+		}
+	}
+
+	// At this point s[start:stop] starts and ends with an ASCII
+	// non-space bytes, so we're done. Non-ASCII cases have already
+	// been handled above.
+	if start == stop {
+		// Special case to preserve previous TrimLeftFunc behavior,
+		// returning nil instead of empty slice if all spaces.
+		return nil
+	}
+	return s[start:stop]
 }

 // Runes interprets s as a sequence of UTF-8-encoded code points.
@@ -1170,22 +1188,19 @@ func Replace(s, old, new []byte, n int) []byte {
 	t := make([]byte, len(s)+n*(len(new)-len(old)))
 	w := 0
 	start := 0
-	if len(old) > 0 {
-		for range n {
-			j := start + Index(s[start:], old)
-			w += copy(t[w:], s[start:j])
-			w += copy(t[w:], new)
-			start = j + len(old)
+	for i := 0; i < n; i++ {
+		j := start
+		if len(old) == 0 {
+			if i > 0 {
+				_, wid := utf8.DecodeRune(s[start:])
+				j += wid
+			}
+		} else {
+			j += Index(s[start:], old)
 		}
-	} else { // len(old) == 0
+		w += copy(t[w:], s[start:j])
 		w += copy(t[w:], new)
-		for range n - 1 {
-			_, wid := utf8.DecodeRune(s[start:])
-			j := start + wid
-			w += copy(t[w:], s[start:j])
-			w += copy(t[w:], new)
-			start = j
-		}
+		start = j + len(old)
 	}
 	w += copy(t[w:], s[start:])
 	return t[0:w]
@@ -1206,7 +1221,7 @@ func ReplaceAll(s, old, new []byte) []byte {
 func EqualFold(s, t []byte) bool {
 	// ASCII fast path
 	i := 0
-	for n := min(len(s), len(t)); i < n; i++ {
+	for ; i < len(s) && i < len(t); i++ {
 		sr := s[i]
 		tr := t[i]
 		if sr|tr >= utf8.RuneSelf {
@@ -1236,10 +1251,19 @@ hasUnicode:
 	t = t[i:]
 	for len(s) != 0 && len(t) != 0 {
 		// Extract first rune from each.
-		sr, size := utf8.DecodeRune(s)
-		s = s[size:]
-		tr, size := utf8.DecodeRune(t)
-		t = t[size:]
+		var sr, tr rune
+		if s[0] < utf8.RuneSelf {
+			sr, s = rune(s[0]), s[1:]
+		} else {
+			r, size := utf8.DecodeRune(s)
+			sr, s = r, s[size:]
+		}
+		if t[0] < utf8.RuneSelf {
+			tr, t = rune(t[0]), t[1:]
+		} else {
+			r, size := utf8.DecodeRune(t)
+			tr, t = r, t[size:]
+		}

 		// If they match, keep going; if not, return false.

--- a/src/bytes/bytes_test.go
+++ b/src/bytes/bytes_test.go
@@ -7,7 +7,6 @@ package bytes_test
 import (
 	. "bytes"
 	"fmt"
-	"internal/asan"
 	"internal/testenv"
 	"iter"
 	"math"
@@ -693,14 +692,14 @@ func bmIndexRuneUnicode(rt *unicode.RangeTable, needle rune) func(b *testing.B,
 	for _, r16 := range rt.R16 {
 		for r := rune(r16.Lo); r <= rune(r16.Hi); r += rune(r16.Stride) {
 			if r != needle {
-				rs = append(rs, r)
+				rs = append(rs, rune(r))
 			}
 		}
 	}
 	for _, r32 := range rt.R32 {
 		for r := rune(r32.Lo); r <= rune(r32.Hi); r += rune(r32.Stride) {
 			if r != needle {
-				rs = append(rs, r)
+				rs = append(rs, rune(r))
 			}
 		}
 	}
@@ -891,7 +890,9 @@ func BenchmarkCountSingle(b *testing.B) {
 				b.Fatal("bad count", j, expect)
 			}
 		}
-		clear(buf)
+		for i := 0; i < len(buf); i++ {
+			buf[i] = 0
+		}
 	})
 }

@@ -961,7 +962,7 @@ func TestSplit(t *testing.T) {
 		if tt.n < 0 {
 			b := sliceOfString(Split([]byte(tt.s), []byte(tt.sep)))
 			if !slices.Equal(result, b) {
-				t.Errorf("Split disagrees with SplitN(%q, %q, %d) = %v; want %v", tt.s, tt.sep, tt.n, b, a)
+				t.Errorf("Split disagrees withSplitN(%q, %q, %d) = %v; want %v", tt.s, tt.sep, tt.n, b, a)
 			}
 		}
 		if len(a) > 0 {
@@ -1023,7 +1024,7 @@ func TestSplitAfter(t *testing.T) {
 		if tt.n < 0 {
 			b := sliceOfString(SplitAfter([]byte(tt.s), []byte(tt.sep)))
 			if !slices.Equal(result, b) {
-				t.Errorf("SplitAfter disagrees with SplitAfterN(%q, %q, %d) = %v; want %v", tt.s, tt.sep, tt.n, b, a)
+				t.Errorf("SplitAfter disagrees withSplitAfterN(%q, %q, %d) = %v; want %v", tt.s, tt.sep, tt.n, b, a)
 			}
 		}
 	}
@@ -1224,7 +1225,7 @@ func TestMap(t *testing.T) {
 	// Run a couple of awful growth/shrinkage tests
 	a := tenRunes('a')

-	// 1. Grow. This triggers two reallocations in Map.
+	// 1.  Grow. This triggers two reallocations in Map.
 	maxRune := func(r rune) rune { return unicode.MaxRune }
 	m := Map(maxRune, []byte(a))
 	expect := tenRunes(unicode.MaxRune)
@@ -1785,20 +1786,9 @@ var ReplaceTests = []ReplaceTest{

 func TestReplace(t *testing.T) {
 	for _, tt := range ReplaceTests {
-		var (
-			in  = []byte(tt.in)
-			old = []byte(tt.old)
-			new = []byte(tt.new)
-		)
-		if !asan.Enabled {
-			allocs := testing.AllocsPerRun(10, func() { Replace(in, old, new, tt.n) })
-			if allocs > 1 {
-				t.Errorf("Replace(%q, %q, %q, %d) allocates %.2f objects", tt.in, tt.old, tt.new, tt.n, allocs)
-			}
-		}
-		in = append(in, "<spare>"...)
+		in := append([]byte(tt.in), "<spare>"...)
 		in = in[:len(tt.in)]
-		out := Replace(in, old, new, tt.n)
+		out := Replace(in, []byte(tt.old), []byte(tt.new), tt.n)
 		if s := string(out); s != tt.out {
 			t.Errorf("Replace(%q, %q, %q, %d) = %q, want %q", tt.in, tt.old, tt.new, tt.n, s, tt.out)
 		}
@@ -1806,7 +1796,7 @@ func TestReplace(t *testing.T) {
 			t.Errorf("Replace(%q, %q, %q, %d) didn't copy", tt.in, tt.old, tt.new, tt.n)
 		}
 		if tt.n == -1 {
-			out := ReplaceAll(in, old, new)
+			out := ReplaceAll(in, []byte(tt.old), []byte(tt.new))
 			if s := string(out); s != tt.out {
 				t.Errorf("ReplaceAll(%q, %q, %q) = %q, want %q", tt.in, tt.old, tt.new, s, tt.out)
 			}
@@ -1814,69 +1804,6 @@ func TestReplace(t *testing.T) {
 	}
 }

-func FuzzReplace(f *testing.F) {
-	for _, tt := range ReplaceTests {
-		f.Add([]byte(tt.in), []byte(tt.old), []byte(tt.new), tt.n)
-	}
-	f.Fuzz(func(t *testing.T, in, old, new []byte, n int) {
-		differentImpl := func(in, old, new []byte, n int) []byte {
-			var out Buffer
-			if n < 0 {
-				n = math.MaxInt
-			}
-			for i := 0; i < len(in); {
-				if n == 0 {
-					out.Write(in[i:])
-					break
-				}
-				if HasPrefix(in[i:], old) {
-					out.Write(new)
-					i += len(old)
-					n--
-					if len(old) != 0 {
-						continue
-					}
-					if i == len(in) {
-						break
-					}
-				}
-				if len(old) == 0 {
-					_, length := utf8.DecodeRune(in[i:])
-					out.Write(in[i : i+length])
-					i += length
-				} else {
-					out.WriteByte(in[i])
-					i++
-				}
-			}
-			if len(old) == 0 && n != 0 {
-				out.Write(new)
-			}
-			return out.Bytes()
-		}
-		if simple, replace := differentImpl(in, old, new, n), Replace(in, old, new, n); !slices.Equal(simple, replace) {
-			t.Errorf("The two implementations do not match %q != %q for Replace(%q, %q, %q, %d)", simple, replace, in, old, new, n)
-		}
-	})
-}
-
-func BenchmarkReplace(b *testing.B) {
-	for _, tt := range ReplaceTests {
-		desc := fmt.Sprintf("%q %q %q %d", tt.in, tt.old, tt.new, tt.n)
-		var (
-			in  = []byte(tt.in)
-			old = []byte(tt.old)
-			new = []byte(tt.new)
-		)
-		b.Run(desc, func(b *testing.B) {
-			b.ReportAllocs()
-			for b.Loop() {
-				Replace(in, old, new, tt.n)
-			}
-		})
-	}
-}
-
 type TitleTest struct {
 	in, out string
 }
@@ -2126,9 +2053,8 @@ func TestContainsFunc(t *testing.T) {
 var makeFieldsInput = func() []byte {
 	x := make([]byte, 1<<20)
 	// Input is ~10% space, ~10% 2-byte UTF-8, rest ASCII non-space.
-	r := rand.New(rand.NewSource(99))
 	for i := range x {
-		switch r.Intn(10) {
+		switch rand.Intn(10) {
 		case 0:
 			x[i] = ' '
 		case 1:
@@ -2147,9 +2073,8 @@ var makeFieldsInput = func() []byte {
 var makeFieldsInputASCII = func() []byte {
 	x := make([]byte, 1<<20)
 	// Input is ~10% space, rest ASCII non-space.
-	r := rand.New(rand.NewSource(99))
 	for i := range x {
-		if r.Intn(10) == 0 {
+		if rand.Intn(10) == 0 {
 			x[i] = ' '
 		} else {
 			x[i] = 'x'
@@ -2246,9 +2171,8 @@ func makeBenchInputHard() []byte {
 		"hello", "world",
 	}
 	x := make([]byte, 0, 1<<20)
-	r := rand.New(rand.NewSource(99))
 	for {
-		i := r.Intn(len(tokens))
+		i := rand.Intn(len(tokens))
 		if len(x)+len(tokens[i]) >= 1<<20 {
 			break
 		}
--- a/src/bytes/example_test.go
+++ b/src/bytes/example_test.go
@@ -245,9 +245,9 @@ func ExampleCut() {
 }

 func ExampleCutPrefix() {
-	show := func(s, prefix string) {
-		after, found := bytes.CutPrefix([]byte(s), []byte(prefix))
-		fmt.Printf("CutPrefix(%q, %q) = %q, %v\n", s, prefix, after, found)
+	show := func(s, sep string) {
+		after, found := bytes.CutPrefix([]byte(s), []byte(sep))
+		fmt.Printf("CutPrefix(%q, %q) = %q, %v\n", s, sep, after, found)
 	}
 	show("Gopher", "Go")
 	show("Gopher", "ph")
@@ -257,9 +257,9 @@ func ExampleCutPrefix() {
 }

 func ExampleCutSuffix() {
-	show := func(s, suffix string) {
-		before, found := bytes.CutSuffix([]byte(s), []byte(suffix))
-		fmt.Printf("CutSuffix(%q, %q) = %q, %v\n", s, suffix, before, found)
+	show := func(s, sep string) {
+		before, found := bytes.CutSuffix([]byte(s), []byte(sep))
+		fmt.Printf("CutSuffix(%q, %q) = %q, %v\n", s, sep, before, found)
 	}
 	show("Gopher", "Go")
 	show("Gopher", "er")
@@ -628,93 +628,3 @@ func ExampleToUpperSpecial() {
 	// Original : ahoj vývojári golang
 	// ToUpper : AHOJ VÝVOJÁRİ GOLANG
 }
-
-func ExampleLines() {
-	text := []byte("Hello\nWorld\nGo Programming\n")
-	for line := range bytes.Lines(text) {
-		fmt.Printf("%q\n", line)
-	}
-
-	// Output:
-	// "Hello\n"
-	// "World\n"
-	// "Go Programming\n"
-}
-
-func ExampleSplitSeq() {
-	s := []byte("a,b,c,d")
-	for part := range bytes.SplitSeq(s, []byte(",")) {
-		fmt.Printf("%q\n", part)
-	}
-
-	// Output:
-	// "a"
-	// "b"
-	// "c"
-	// "d"
-}
-
-func ExampleSplitAfterSeq() {
-	s := []byte("a,b,c,d")
-	for part := range bytes.SplitAfterSeq(s, []byte(",")) {
-		fmt.Printf("%q\n", part)
-	}
-
-	// Output:
-	// "a,"
-	// "b,"
-	// "c,"
-	// "d"
-}
-
-func ExampleFieldsSeq() {
-	text := []byte("The quick brown fox")
-	fmt.Println("Split byte slice into fields:")
-	for word := range bytes.FieldsSeq(text) {
-		fmt.Printf("%q\n", word)
-	}
-
-	textWithSpaces := []byte("  lots   of   spaces  ")
-	fmt.Println("\nSplit byte slice with multiple spaces:")
-	for word := range bytes.FieldsSeq(textWithSpaces) {
-		fmt.Printf("%q\n", word)
-	}
-
-	// Output:
-	// Split byte slice into fields:
-	// "The"
-	// "quick"
-	// "brown"
-	// "fox"
-	//
-	// Split byte slice with multiple spaces:
-	// "lots"
-	// "of"
-	// "spaces"
-}
-
-func ExampleFieldsFuncSeq() {
-	text := []byte("The quick brown fox")
-	fmt.Println("Split on whitespace(similar to FieldsSeq):")
-	for word := range bytes.FieldsFuncSeq(text, unicode.IsSpace) {
-		fmt.Printf("%q\n", word)
-	}
-
-	mixedText := []byte("abc123def456ghi")
-	fmt.Println("\nSplit on digits:")
-	for word := range bytes.FieldsFuncSeq(mixedText, unicode.IsDigit) {
-		fmt.Printf("%q\n", word)
-	}
-
-	// Output:
-	// Split on whitespace(similar to FieldsSeq):
-	// "The"
-	// "quick"
-	// "brown"
-	// "fox"
-	//
-	// Split on digits:
-	// "abc"
-	// "def"
-	// "ghi"
-}
--- a/src/bytes/iter.go
+++ b/src/bytes/iter.go
@@ -28,23 +28,30 @@ func Lines(s []byte) iter.Seq[[]byte] {
 				return
 			}
 		}
+		return
+	}
+}
+
+// explodeSeq returns an iterator over the runes in s.
+func explodeSeq(s []byte) iter.Seq[[]byte] {
+	return func(yield func([]byte) bool) {
+		for len(s) > 0 {
+			_, size := utf8.DecodeRune(s)
+			if !yield(s[:size:size]) {
+				return
+			}
+			s = s[size:]
+		}
 	}
 }

 // splitSeq is SplitSeq or SplitAfterSeq, configured by how many
 // bytes of sep to include in the results (none or all).
 func splitSeq(s, sep []byte, sepSave int) iter.Seq[[]byte] {
+	if len(sep) == 0 {
+		return explodeSeq(s)
+	}
 	return func(yield func([]byte) bool) {
-		if len(sep) == 0 {
-			for len(s) > 0 {
-				_, size := utf8.DecodeRune(s)
-				if !yield(s[:size:size]) {
-					return
-				}
-				s = s[size:]
-			}
-			return
-		}
 		for {
 			i := Index(s, sep)
 			if i < 0 {
@@ -117,7 +124,11 @@ func FieldsFuncSeq(s []byte, f func(rune) bool) iter.Seq[[]byte] {
 	return func(yield func([]byte) bool) {
 		start := -1
 		for i := 0; i < len(s); {
-			r, size := utf8.DecodeRune(s[i:])
+			size := 1
+			r := rune(s[i])
+			if r >= utf8.RuneSelf {
+				r, size = utf8.DecodeRune(s[i:])
+			}
 			if f(r) {
 				if start >= 0 {
 					if !yield(s[start:i:i]) {
--- a/src/bytes/iter_test.go
+++ b/src/bytes/iter_test.go
@@ -1,56 +0,0 @@
-// 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 bytes_test
-
-import (
-	. "bytes"
-	"testing"
-)
-
-func BenchmarkSplitSeqEmptySeparator(b *testing.B) {
-	for range b.N {
-		for range SplitSeq(benchInputHard, nil) {
-		}
-	}
-}
-
-func BenchmarkSplitSeqSingleByteSeparator(b *testing.B) {
-	sep := []byte("/")
-	for range b.N {
-		for range SplitSeq(benchInputHard, sep) {
-		}
-	}
-}
-
-func BenchmarkSplitSeqMultiByteSeparator(b *testing.B) {
-	sep := []byte("hello")
-	for range b.N {
-		for range SplitSeq(benchInputHard, sep) {
-		}
-	}
-}
-
-func BenchmarkSplitAfterSeqEmptySeparator(b *testing.B) {
-	for range b.N {
-		for range SplitAfterSeq(benchInputHard, nil) {
-		}
-	}
-}
-
-func BenchmarkSplitAfterSeqSingleByteSeparator(b *testing.B) {
-	sep := []byte("/")
-	for range b.N {
-		for range SplitAfterSeq(benchInputHard, sep) {
-		}
-	}
-}
-
-func BenchmarkSplitAfterSeqMultiByteSeparator(b *testing.B) {
-	sep := []byte("hello")
-	for range b.N {
-		for range SplitAfterSeq(benchInputHard, sep) {
-		}
-	}
-}
--- a/src/clean.bat
+++ b/src/clean.bat
@@ -6,16 +6,27 @@

 setlocal

-go tool dist env -w -p >env.bat || exit /b 1
+set GOBUILDFAIL=0
+
+go tool dist env -w -p >env.bat
+if errorlevel 1 goto fail
 call .\env.bat
 del env.bat
 echo.

-if not exist %GOTOOLDIR%\dist.exe (
-    echo cannot find %GOTOOLDIR%\dist.exe; nothing to clean
-    exit /b 1
-)
+if exist %GOTOOLDIR%\dist.exe goto distok
+echo cannot find %GOTOOLDIR%\dist; nothing to clean
+goto fail
+:distok

 "%GOBIN%\go" clean -i std
 "%GOBIN%\go" tool dist clean
 "%GOBIN%\go" clean -i cmd
+
+goto end
+
+:fail
+set GOBUILDFAIL=1
+
+:end
+if x%GOBUILDEXIT%==x1 exit %GOBUILDFAIL%
--- a/src/cmd/api/api_test.go
+++ b/src/cmd/api/api_test.go
@@ -99,11 +99,6 @@ func TestGolden(t *testing.T) {
 }

 func TestCompareAPI(t *testing.T) {
-	if *flagCheck {
-		// not worth repeating in -check
-		t.Skip("skipping with -check set")
-	}
-
 	tests := []struct {
 		name                          string
 		features, required, exception []string
@@ -185,11 +180,6 @@ func TestCompareAPI(t *testing.T) {
 }

 func TestSkipInternal(t *testing.T) {
-	if *flagCheck {
-		// not worth repeating in -check
-		t.Skip("skipping with -check set")
-	}
-
 	tests := []struct {
 		pkg  string
 		want bool
@@ -304,20 +294,14 @@ func TestIssue41358(t *testing.T) {
 }

 func TestIssue64958(t *testing.T) {
-	if testing.Short() {
-		t.Skip("skipping with -short")
-	}
-	if *flagCheck {
-		// slow, not worth repeating in -check
-		t.Skip("skipping with -check set")
-	}
-	testenv.MustHaveGoBuild(t)
-
 	defer func() {
 		if x := recover(); x != nil {
 			t.Errorf("expected no panic; recovered %v", x)
 		}
 	}()
+
+	testenv.MustHaveGoBuild(t)
+
 	for _, context := range contexts {
 		w := NewWalker(context, "testdata/src/issue64958")
 		pkg, err := w.importFrom("p", "", 0)
--- a/src/cmd/api/main_test.go
+++ b/src/cmd/api/main_test.go
@@ -1058,7 +1058,7 @@ func (w *Walker) emitIfaceType(name string, typ *types.Interface) {
 		if w.isDeprecated(m) {
 			w.emitf("%s //deprecated", m.Name())
 		}
-		w.emitf("%s%s", m.Name(), w.signatureString(m.Signature()))
+		w.emitf("%s%s", m.Name(), w.signatureString(m.Type().(*types.Signature)))
 	}

 	if !complete {
@@ -1088,7 +1088,7 @@ func (w *Walker) emitIfaceType(name string, typ *types.Interface) {
 }

 func (w *Walker) emitFunc(f *types.Func) {
-	sig := f.Signature()
+	sig := f.Type().(*types.Signature)
 	if sig.Recv() != nil {
 		panic("method considered a regular function: " + f.String())
 	}
--- a/src/cmd/api/testdata/src/pkg/p1/golden.txt
+++ b/src/cmd/api/testdata/src/pkg/p1/golden.txt
@@ -1,6 +1,6 @@
-pkg p1, const A //deprecated
 pkg p1, const A = 1
 pkg p1, const A ideal-int
+pkg p1, const A //deprecated
 pkg p1, const A64 = 1
 pkg p1, const A64 int64
 pkg p1, const AIsLowerA = 11
@@ -25,8 +25,8 @@ pkg p1, func TakesFunc(func(int) int)
 pkg p1, method (*B) JustOnB()
 pkg p1, method (*B) OnBothTandBPtr()
 pkg p1, method (*Embedded) OnEmbedded()
-pkg p1, method (*S2) SMethod //deprecated
 pkg p1, method (*S2) SMethod(int8, int16, int64)
+pkg p1, method (*S2) SMethod //deprecated
 pkg p1, method (*T) JustOnT()
 pkg p1, method (*T) OnBothTandBPtr()
 pkg p1, method (B) OnBothTandBVal()
@@ -53,8 +53,8 @@ pkg p1, type Error interface { Error, Temporary }
 pkg p1, type Error interface, Error() string
 pkg p1, type Error interface, Temporary() bool
 pkg p1, type FuncType func(int, int, string) (*B, error)
-pkg p1, type I interface, Get //deprecated
 pkg p1, type I interface, Get(string) int64
+pkg p1, type I interface, Get //deprecated
 pkg p1, type I interface, GetNamed(string) int64
 pkg p1, type I interface, Name() string
 pkg p1, type I interface, PackageTwoMeth()
@@ -63,9 +63,9 @@ pkg p1, type I interface, unexported methods
 pkg p1, type MyInt int
 pkg p1, type Namer interface { Name }
 pkg p1, type Namer interface, Name() string
-pkg p1, type Private //deprecated
 pkg p1, type Private interface, X()
 pkg p1, type Private interface, unexported methods
+pkg p1, type Private //deprecated
 pkg p1, type Public interface { X, Y }
 pkg p1, type Public interface, X()
 pkg p1, type Public interface, Y()
@@ -84,8 +84,8 @@ pkg p1, type TPtrExported struct
 pkg p1, type TPtrExported struct, embedded *Embedded
 pkg p1, type TPtrUnexported struct
 pkg p1, type Time struct
-pkg p1, type URL //deprecated
 pkg p1, type URL struct
+pkg p1, type URL //deprecated
 pkg p1, var Byte uint8
 pkg p1, var ByteConv []uint8
 pkg p1, var ByteFunc func(uint8) int32
@@ -97,8 +97,8 @@ pkg p1, var StrConv string
 pkg p1, var V string
 pkg p1, var V1 uint64
 pkg p1, var V2 p2.Twoer
-pkg p1, var VError //deprecated
 pkg p1, var VError Error
+pkg p1, var VError //deprecated
 pkg p1, var X I
 pkg p1, var X0 int64
 pkg p1, var Y int
--- a/src/cmd/api/testdata/src/pkg/p2/golden.txt
+++ b/src/cmd/api/testdata/src/pkg/p2/golden.txt
@@ -1,7 +1,8 @@
-pkg p2, func F //deprecated
 pkg p2, func F() string
+pkg p2, func F //deprecated
 pkg p2, func G() Twoer
 pkg p2, func NewError(string) error
 pkg p2, type Twoer interface { PackageTwoMeth }
-pkg p2, type Twoer interface, PackageTwoMeth //deprecated
 pkg p2, type Twoer interface, PackageTwoMeth()
+pkg p2, type Twoer interface, PackageTwoMeth //deprecated
+
--- a/src/cmd/api/testdata/src/pkg/p4/golden.txt
+++ b/src/cmd/api/testdata/src/pkg/p4/golden.txt
@@ -1,6 +1,6 @@
-pkg p4, func Clone //deprecated
-pkg p4, func Clone[$0 interface{ ~[]$1 }, $1 interface{}]($0) $0
 pkg p4, func NewPair[$0 interface{ M }, $1 interface{ ~int }]($0, $1) Pair[$0, $1]
-pkg p4, method (Pair[$0, $1]) First() $0
 pkg p4, method (Pair[$0, $1]) Second() $1
+pkg p4, method (Pair[$0, $1]) First() $0
 pkg p4, type Pair[$0 interface{ M }, $1 interface{ ~int }] struct
+pkg p4, func Clone[$0 interface{ ~[]$1 }, $1 interface{}]($0) $0
+pkg p4, func Clone //deprecated
--- a/src/cmd/asm/internal/arch/arch.go
+++ b/src/cmd/asm/internal/arch/arch.go
@@ -92,8 +92,7 @@ func jumpX86(word string) bool {
 func jumpRISCV(word string) bool {
 	switch word {
 	case "BEQ", "BEQZ", "BGE", "BGEU", "BGEZ", "BGT", "BGTU", "BGTZ", "BLE", "BLEU", "BLEZ",
-		"BLT", "BLTU", "BLTZ", "BNE", "BNEZ", "CALL", "CBEQZ", "CBNEZ", "CJ", "CJALR", "CJR",
-		"JAL", "JALR", "JMP":
+		"BLT", "BLTU", "BLTZ", "BNE", "BNEZ", "CALL", "JAL", "JALR", "JMP":
 		return true
 	}
 	return false
--- a/src/cmd/asm/internal/arch/arm64.go
+++ b/src/cmd/asm/internal/arch/arm64.go
@@ -59,10 +59,10 @@ func jumpArm64(word string) bool {

 var arm64SpecialOperand map[string]arm64.SpecialOperand

-// ARM64SpecialOperand returns the internal representation of a special operand.
-func ARM64SpecialOperand(name string) arm64.SpecialOperand {
+// GetARM64SpecialOperand returns the internal representation of a special operand.
+func GetARM64SpecialOperand(name string) arm64.SpecialOperand {
 	if arm64SpecialOperand == nil {
-		// Generate mapping when function is first called.
+		// Generate the mapping automatically when the first time the function is called.
 		arm64SpecialOperand = map[string]arm64.SpecialOperand{}
 		for opd := arm64.SPOP_BEGIN; opd < arm64.SPOP_END; opd++ {
 			arm64SpecialOperand[opd.String()] = opd
@@ -195,6 +195,149 @@ func ARM64RegisterShift(reg, op, count int16) (int64, error) {
 	return int64(reg&31)<<16 | int64(op)<<22 | int64(uint16(count)), nil
 }

+// ARM64RegisterExtension constructs an ARM64 register with extension or arrangement.
+func ARM64RegisterExtension(a *obj.Addr, ext string, reg, num int16, isAmount, isIndex bool) error {
+	Rnum := (reg & 31) + int16(num<<5)
+	if isAmount {
+		if num < 0 || num > 7 {
+			return errors.New("index shift amount is out of range")
+		}
+	}
+	if reg <= arm64.REG_R31 && reg >= arm64.REG_R0 {
+		if !isAmount {
+			return errors.New("invalid register extension")
+		}
+		switch ext {
+		case "UXTB":
+			if a.Type == obj.TYPE_MEM {
+				return errors.New("invalid shift for the register offset addressing mode")
+			}
+			a.Reg = arm64.REG_UXTB + Rnum
+		case "UXTH":
+			if a.Type == obj.TYPE_MEM {
+				return errors.New("invalid shift for the register offset addressing mode")
+			}
+			a.Reg = arm64.REG_UXTH + Rnum
+		case "UXTW":
+			// effective address of memory is a base register value and an offset register value.
+			if a.Type == obj.TYPE_MEM {
+				a.Index = arm64.REG_UXTW + Rnum
+			} else {
+				a.Reg = arm64.REG_UXTW + Rnum
+			}
+		case "UXTX":
+			if a.Type == obj.TYPE_MEM {
+				return errors.New("invalid shift for the register offset addressing mode")
+			}
+			a.Reg = arm64.REG_UXTX + Rnum
+		case "SXTB":
+			if a.Type == obj.TYPE_MEM {
+				return errors.New("invalid shift for the register offset addressing mode")
+			}
+			a.Reg = arm64.REG_SXTB + Rnum
+		case "SXTH":
+			if a.Type == obj.TYPE_MEM {
+				return errors.New("invalid shift for the register offset addressing mode")
+			}
+			a.Reg = arm64.REG_SXTH + Rnum
+		case "SXTW":
+			if a.Type == obj.TYPE_MEM {
+				a.Index = arm64.REG_SXTW + Rnum
+			} else {
+				a.Reg = arm64.REG_SXTW + Rnum
+			}
+		case "SXTX":
+			if a.Type == obj.TYPE_MEM {
+				a.Index = arm64.REG_SXTX + Rnum
+			} else {
+				a.Reg = arm64.REG_SXTX + Rnum
+			}
+		case "LSL":
+			a.Index = arm64.REG_LSL + Rnum
+		default:
+			return errors.New("unsupported general register extension type: " + ext)
+
+		}
+	} else if reg <= arm64.REG_V31 && reg >= arm64.REG_V0 {
+		switch ext {
+		case "B8":
+			if isIndex {
+				return errors.New("invalid register extension")
+			}
+			a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_8B & 15) << 5)
+		case "B16":
+			if isIndex {
+				return errors.New("invalid register extension")
+			}
+			a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_16B & 15) << 5)
+		case "H4":
+			if isIndex {
+				return errors.New("invalid register extension")
+			}
+			a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_4H & 15) << 5)
+		case "H8":
+			if isIndex {
+				return errors.New("invalid register extension")
+			}
+			a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_8H & 15) << 5)
+		case "S2":
+			if isIndex {
+				return errors.New("invalid register extension")
+			}
+			a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_2S & 15) << 5)
+		case "S4":
+			if isIndex {
+				return errors.New("invalid register extension")
+			}
+			a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_4S & 15) << 5)
+		case "D1":
+			if isIndex {
+				return errors.New("invalid register extension")
+			}
+			a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_1D & 15) << 5)
+		case "D2":
+			if isIndex {
+				return errors.New("invalid register extension")
+			}
+			a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_2D & 15) << 5)
+		case "Q1":
+			if isIndex {
+				return errors.New("invalid register extension")
+			}
+			a.Reg = arm64.REG_ARNG + (reg & 31) + ((arm64.ARNG_1Q & 15) << 5)
+		case "B":
+			if !isIndex {
+				return nil
+			}
+			a.Reg = arm64.REG_ELEM + (reg & 31) + ((arm64.ARNG_B & 15) << 5)
+			a.Index = num
+		case "H":
+			if !isIndex {
+				return nil
+			}
+			a.Reg = arm64.REG_ELEM + (reg & 31) + ((arm64.ARNG_H & 15) << 5)
+			a.Index = num
+		case "S":
+			if !isIndex {
+				return nil
+			}
+			a.Reg = arm64.REG_ELEM + (reg & 31) + ((arm64.ARNG_S & 15) << 5)
+			a.Index = num
+		case "D":
+			if !isIndex {
+				return nil
+			}
+			a.Reg = arm64.REG_ELEM + (reg & 31) + ((arm64.ARNG_D & 15) << 5)
+			a.Index = num
+		default:
+			return errors.New("unsupported simd register extension type: " + ext)
+		}
+	} else {
+		return errors.New("invalid register and extension combination")
+	}
+	return nil
+}
+
 // ARM64RegisterArrangement constructs an ARM64 vector register arrangement.
 func ARM64RegisterArrangement(reg int16, name, arng string) (int64, error) {
 	var curQ, curSize uint16
--- a/src/cmd/asm/internal/arch/loong64.go
+++ b/src/cmd/asm/internal/arch/loong64.go
@@ -23,6 +23,18 @@ func jumpLoong64(word string) bool {
 	return false
 }

+// IsLoong64MUL reports whether the op (as defined by an loong64.A* constant) is
+// one of the MUL/DIV/REM instructions that require special handling.
+func IsLoong64MUL(op obj.As) bool {
+	switch op {
+	case loong64.AMUL, loong64.AMULU, loong64.AMULV, loong64.AMULVU,
+		loong64.ADIV, loong64.ADIVU, loong64.ADIVV, loong64.ADIVVU,
+		loong64.AREM, loong64.AREMU, loong64.AREMV, loong64.AREMVU:
+		return true
+	}
+	return false
+}
+
 // IsLoong64RDTIME reports whether the op (as defined by an loong64.A*
 // constant) is one of the RDTIMELW/RDTIMEHW/RDTIMED instructions that
 // require special handling.
@@ -34,14 +46,6 @@ func IsLoong64RDTIME(op obj.As) bool {
 	return false
 }

-func IsLoong64PRELD(op obj.As) bool {
-	switch op {
-	case loong64.APRELD, loong64.APRELDX:
-		return true
-	}
-	return false
-}
-
 func IsLoong64AMO(op obj.As) bool {
 	return loong64.IsAtomicInst(op)
 }
--- a/src/cmd/asm/internal/arch/riscv64.go
+++ b/src/cmd/asm/internal/arch/riscv64.go
@@ -11,11 +11,11 @@ package arch
 import (
 	"cmd/internal/obj"
 	"cmd/internal/obj/riscv"
-	"fmt"
 )

-// IsRISCV64AMO reports whether op is an AMO instruction that requires
-// special handling.
+// IsRISCV64AMO reports whether the op (as defined by a riscv.A*
+// constant) is one of the AMO instructions that requires special
+// handling.
 func IsRISCV64AMO(op obj.As) bool {
 	switch op {
 	case riscv.ASCW, riscv.ASCD, riscv.AAMOSWAPW, riscv.AAMOSWAPD, riscv.AAMOADDW, riscv.AAMOADDD,
@@ -26,59 +26,3 @@ func IsRISCV64AMO(op obj.As) bool {
 	}
 	return false
 }
-
-// IsRISCV64VTypeI reports whether op is a vtype immediate instruction that
-// requires special handling.
-func IsRISCV64VTypeI(op obj.As) bool {
-	return op == riscv.AVSETVLI || op == riscv.AVSETIVLI
-}
-
-// IsRISCV64CSRO reports whether the op is an instruction that uses
-// CSR symbolic names and whether that instruction expects a register
-// or an immediate source operand.
-func IsRISCV64CSRO(op obj.As) (imm bool, ok bool) {
-	switch op {
-	case riscv.ACSRRCI, riscv.ACSRRSI, riscv.ACSRRWI:
-		imm = true
-		fallthrough
-	case riscv.ACSRRC, riscv.ACSRRS, riscv.ACSRRW:
-		ok = true
-	}
-	return
-}
-
-var riscv64SpecialOperand map[string]riscv.SpecialOperand
-
-// RISCV64SpecialOperand returns the internal representation of a special operand.
-func RISCV64SpecialOperand(name string) riscv.SpecialOperand {
-	if riscv64SpecialOperand == nil {
-		// Generate mapping when function is first called.
-		riscv64SpecialOperand = map[string]riscv.SpecialOperand{}
-		for opd := riscv.SPOP_RVV_BEGIN; opd < riscv.SPOP_RVV_END; opd++ {
-			riscv64SpecialOperand[opd.String()] = opd
-		}
-		// Add the CSRs
-		for csrCode, csrName := range riscv.CSRs {
-			// The set of RVV special operand names and the set of CSR special operands
-			// names are disjoint and so can safely share a single namespace. However,
-			// it's possible that a future update to the CSRs in inst.go could introduce
-			// a conflict. This check ensures that such a conflict does not go
-			// unnoticed.
-			if _, ok := riscv64SpecialOperand[csrName]; ok {
-				panic(fmt.Sprintf("riscv64 special operand %q redefined", csrName))
-			}
-			riscv64SpecialOperand[csrName] = riscv.SpecialOperand(int(csrCode) + int(riscv.SPOP_CSR_BEGIN))
-		}
-	}
-	if opd, ok := riscv64SpecialOperand[name]; ok {
-		return opd
-	}
-	return riscv.SPOP_END
-}
-
-// RISCV64ValidateVectorType reports whether the given configuration is a
-// valid vector type.
-func RISCV64ValidateVectorType(vsew, vlmul, vtail, vmask int64) error {
-	_, err := riscv.EncodeVectorType(vsew, vlmul, vtail, vmask)
-	return err
-}
--- a/src/cmd/asm/internal/asm/asm.go
+++ b/src/cmd/asm/internal/asm/asm.go
@@ -248,7 +248,7 @@ func (p *Parser) asmData(operands [][]lex.Token) {
 	case obj.TYPE_CONST:
 		switch sz {
 		case 1, 2, 4, 8:
-			nameAddr.Sym.WriteInt(p.ctxt, nameAddr.Offset, sz, valueAddr.Offset)
+			nameAddr.Sym.WriteInt(p.ctxt, nameAddr.Offset, int(sz), valueAddr.Offset)
 		default:
 			p.errorf("bad int size for DATA argument: %d", sz)
 		}
@@ -262,10 +262,10 @@ func (p *Parser) asmData(operands [][]lex.Token) {
 			p.errorf("bad float size for DATA argument: %d", sz)
 		}
 	case obj.TYPE_SCONST:
-		nameAddr.Sym.WriteString(p.ctxt, nameAddr.Offset, sz, valueAddr.Val.(string))
+		nameAddr.Sym.WriteString(p.ctxt, nameAddr.Offset, int(sz), valueAddr.Val.(string))
 	case obj.TYPE_ADDR:
 		if sz == p.arch.PtrSize {
-			nameAddr.Sym.WriteAddr(p.ctxt, nameAddr.Offset, sz, valueAddr.Sym, valueAddr.Offset)
+			nameAddr.Sym.WriteAddr(p.ctxt, nameAddr.Offset, int(sz), valueAddr.Sym, valueAddr.Offset)
 		} else {
 			p.errorf("bad addr size for DATA argument: %d", sz)
 		}
@@ -654,12 +654,6 @@ func (p *Parser) asmInstruction(op obj.As, cond string, a []obj.Addr) {
 				prog.RegTo2 = a[1].Reg
 				break
 			}
-
-			if arch.IsLoong64PRELD(op) {
-				prog.From = a[0]
-				prog.AddRestSource(a[1])
-				break
-			}
 		}
 		prog.From = a[0]
 		prog.To = a[1]
@@ -676,11 +670,6 @@ func (p *Parser) asmInstruction(op obj.As, cond string, a []obj.Addr) {
 				prog.From = a[0]
 				prog.To = a[1]
 				prog.RegTo2 = a[2].Reg
-
-			case arch.IsLoong64PRELD(op):
-				prog.From = a[0]
-				prog.AddRestSourceArgs([]obj.Addr{a[1], a[2]})
-
 			default:
 				prog.From = a[0]
 				prog.Reg = p.getRegister(prog, op, &a[1])
@@ -782,21 +771,6 @@ func (p *Parser) asmInstruction(op obj.As, cond string, a []obj.Addr) {
 				prog.RegTo2 = a[2].Reg
 				break
 			}
-			// RISCV64 instructions that reference CSRs with symbolic names.
-			if isImm, ok := arch.IsRISCV64CSRO(op); ok {
-				if a[0].Type != obj.TYPE_CONST && isImm {
-					p.errorf("invalid value for first operand to %s instruction, must be a 5 bit unsigned immediate", op)
-					return
-				}
-				if a[1].Type != obj.TYPE_SPECIAL {
-					p.errorf("invalid value for second operand to %s instruction, must be a CSR name", op)
-					return
-				}
-				prog.AddRestSourceArgs([]obj.Addr{a[1]})
-				prog.From = a[0]
-				prog.To = a[2]
-				break
-			}
 			prog.From = a[0]
 			prog.Reg = p.getRegister(prog, op, &a[1])
 			prog.To = a[2]
@@ -941,19 +915,6 @@ func (p *Parser) asmInstruction(op obj.As, cond string, a []obj.Addr) {
 			prog.To = a[5]
 			break
 		}
-		if p.arch.Family == sys.RISCV64 && arch.IsRISCV64VTypeI(op) {
-			prog.From = a[0]
-			vsew := p.getSpecial(prog, op, &a[1])
-			vlmul := p.getSpecial(prog, op, &a[2])
-			vtail := p.getSpecial(prog, op, &a[3])
-			vmask := p.getSpecial(prog, op, &a[4])
-			if err := arch.RISCV64ValidateVectorType(vsew, vlmul, vtail, vmask); err != nil {
-				p.errorf("invalid vtype: %v", err)
-			}
-			prog.AddRestSourceArgs([]obj.Addr{a[1], a[2], a[3], a[4]})
-			prog.To = a[5]
-			break
-		}
 		fallthrough
 	default:
 		p.errorf("can't handle %s instruction with %d operands", op, len(a))
@@ -989,6 +950,14 @@ func (p *Parser) getConstant(prog *obj.Prog, op obj.As, addr *obj.Addr) int64 {
 	return addr.Offset
 }

+// getImmediate checks that addr represents an immediate constant and returns its value.
+func (p *Parser) getImmediate(prog *obj.Prog, op obj.As, addr *obj.Addr) int64 {
+	if addr.Type != obj.TYPE_CONST || addr.Name != 0 || addr.Reg != 0 || addr.Index != 0 {
+		p.errorf("%s: expected immediate constant; found %s", op, obj.Dconv(prog, addr))
+	}
+	return addr.Offset
+}
+
 // getRegister checks that addr represents a register and returns its value.
 func (p *Parser) getRegister(prog *obj.Prog, op obj.As, addr *obj.Addr) int16 {
 	if addr.Type != obj.TYPE_REG || addr.Offset != 0 || addr.Name != 0 || addr.Index != 0 {
@@ -996,11 +965,3 @@ func (p *Parser) getRegister(prog *obj.Prog, op obj.As, addr *obj.Addr) int16 {
 	}
 	return addr.Reg
 }
-
-// getSpecial checks that addr represents a special operand and returns its value.
-func (p *Parser) getSpecial(prog *obj.Prog, op obj.As, addr *obj.Addr) int64 {
-	if addr.Type != obj.TYPE_SPECIAL || addr.Name != 0 || addr.Reg != 0 || addr.Index != 0 {
-		p.errorf("%s: expected special operand; found %s", op, obj.Dconv(prog, addr))
-	}
-	return addr.Offset
-}
--- a/src/cmd/asm/internal/asm/endtoend_test.go
+++ b/src/cmd/asm/internal/asm/endtoend_test.go
@@ -38,7 +38,7 @@ func testEndToEnd(t *testing.T, goarch, file string) {
 	ctxt.IsAsm = true
 	defer ctxt.Bso.Flush()
 	failed := false
-	ctxt.DiagFunc = func(format string, args ...any) {
+	ctxt.DiagFunc = func(format string, args ...interface{}) {
 		failed = true
 		t.Errorf(format, args...)
 	}
@@ -193,17 +193,12 @@ Diff:
 	top := pList.Firstpc
 	var text *obj.LSym
 	ok = true
-	ctxt.DiagFunc = func(format string, args ...any) {
+	ctxt.DiagFunc = func(format string, args ...interface{}) {
 		t.Errorf(format, args...)
 		ok = false
 	}
 	obj.Flushplist(ctxt, pList, nil)

-	if !ok {
-		// If we've encountered errors, the output is unlikely to be sane.
-		t.FailNow()
-	}
-
 	for p := top; p != nil; p = p.Link {
 		if p.As == obj.ATEXT {
 			text = p.From.Sym
@@ -299,7 +294,7 @@ func testErrors(t *testing.T, goarch, file string, flags ...string) {
 	failed := false
 	var errBuf bytes.Buffer
 	parser.errorWriter = &errBuf
-	ctxt.DiagFunc = func(format string, args ...any) {
+	ctxt.DiagFunc = func(format string, args ...interface{}) {
 		failed = true
 		s := fmt.Sprintf(format, args...)
 		if !strings.HasSuffix(s, "\n") {
@@ -470,16 +465,9 @@ func TestLOONG64Encoder(t *testing.T) {
 	testEndToEnd(t, "loong64", "loong64enc1")
 	testEndToEnd(t, "loong64", "loong64enc2")
 	testEndToEnd(t, "loong64", "loong64enc3")
-	testEndToEnd(t, "loong64", "loong64enc4")
-	testEndToEnd(t, "loong64", "loong64enc5")
-	testEndToEnd(t, "loong64", "loong64enc6")
 	testEndToEnd(t, "loong64", "loong64")
 }

-func TestLOONG64Errors(t *testing.T) {
-	testErrors(t, "loong64", "loong64error")
-}
-
 func TestPPC64EndToEnd(t *testing.T) {
 	defer func(old int) { buildcfg.GOPPC64 = old }(buildcfg.GOPPC64)
 	for _, goppc64 := range []int{8, 9, 10} {
@@ -491,35 +479,12 @@ func TestPPC64EndToEnd(t *testing.T) {
 	}
 }

-func testRISCV64AllProfiles(t *testing.T, testFn func(t *testing.T)) {
-	t.Helper()
-
-	defer func(orig int) { buildcfg.GORISCV64 = orig }(buildcfg.GORISCV64)
-
-	for _, goriscv64 := range []int{20, 22, 23} {
-		t.Run(fmt.Sprintf("rva%vu64", goriscv64), func(t *testing.T) {
-			buildcfg.GORISCV64 = goriscv64
-			testFn(t)
-		})
-	}
+func TestRISCVEndToEnd(t *testing.T) {
+	testEndToEnd(t, "riscv64", "riscv64")
 }

-func TestRISCV64EndToEnd(t *testing.T) {
-	testRISCV64AllProfiles(t, func(t *testing.T) {
-		testEndToEnd(t, "riscv64", "riscv64")
-	})
-}
-
-func TestRISCV64Errors(t *testing.T) {
-	testRISCV64AllProfiles(t, func(t *testing.T) {
-		testErrors(t, "riscv64", "riscv64error")
-	})
-}
-
-func TestRISCV64Validation(t *testing.T) {
-	testRISCV64AllProfiles(t, func(t *testing.T) {
-		testErrors(t, "riscv64", "riscv64validation")
-	})
+func TestRISCVErrors(t *testing.T) {
+	testErrors(t, "riscv64", "riscv64error")
 }

 func TestS390XEndToEnd(t *testing.T) {
--- a/src/cmd/asm/internal/asm/parse.go
+++ b/src/cmd/asm/internal/asm/parse.go
@@ -21,7 +21,6 @@ import (
 	"cmd/asm/internal/lex"
 	"cmd/internal/obj"
 	"cmd/internal/obj/arm64"
-	"cmd/internal/obj/riscv"
 	"cmd/internal/obj/x86"
 	"cmd/internal/objabi"
 	"cmd/internal/src"
@@ -78,7 +77,7 @@ func NewParser(ctxt *obj.Link, ar *arch.Arch, lexer lex.TokenReader) *Parser {
 // and turn it into a recoverable panic.
 var panicOnError bool

-func (p *Parser) errorf(format string, args ...any) {
+func (p *Parser) errorf(format string, args ...interface{}) {
 	if panicOnError {
 		panic(fmt.Errorf(format, args...))
 	}
@@ -90,7 +89,7 @@ func (p *Parser) errorf(format string, args ...any) {
 	if p.lex != nil {
 		// Put file and line information on head of message.
 		format = "%s:%d: " + format + "\n"
-		args = append([]any{p.lex.File(), p.lineNum}, args...)
+		args = append([]interface{}{p.lex.File(), p.lineNum}, args...)
 	}
 	fmt.Fprintf(p.errorWriter, format, args...)
 	p.errorCount++
@@ -399,21 +398,16 @@ func (p *Parser) operand(a *obj.Addr) {
 	tok := p.next()
 	name := tok.String()
 	if tok.ScanToken == scanner.Ident && !p.atStartOfRegister(name) {
-		// See if this is an architecture specific special operand.
 		switch p.arch.Family {
 		case sys.ARM64:
-			if opd := arch.ARM64SpecialOperand(name); opd != arm64.SPOP_END {
+			// arm64 special operands.
+			if opd := arch.GetARM64SpecialOperand(name); opd != arm64.SPOP_END {
 				a.Type = obj.TYPE_SPECIAL
 				a.Offset = int64(opd)
+				break
 			}
-		case sys.RISCV64:
-			if opd := arch.RISCV64SpecialOperand(name); opd != riscv.SPOP_END {
-				a.Type = obj.TYPE_SPECIAL
-				a.Offset = int64(opd)
-			}
-		}
-
-		if a.Type != obj.TYPE_SPECIAL {
+			fallthrough
+		default:
 			// We have a symbol. Parse $sym±offset(symkind)
 			p.symbolReference(a, p.qualifySymbol(name), prefix)
 		}
@@ -775,7 +769,7 @@ func (p *Parser) registerExtension(a *obj.Addr, name string, prefix rune) {

 	switch p.arch.Family {
 	case sys.ARM64:
-		err := arm64.ARM64RegisterExtension(a, ext, reg, num, isAmount, isIndex)
+		err := arch.ARM64RegisterExtension(a, ext, reg, num, isAmount, isIndex)
 		if err != nil {
 			p.errorf("%v", err)
 		}
--- a/src/cmd/asm/internal/asm/testdata/amd64dynlinkerror.s
+++ b/src/cmd/asm/internal/asm/testdata/amd64dynlinkerror.s
@@ -169,8 +169,3 @@ TEXT ·a34(SB), 0, $0-0
 	SHLXQ AX, CX, R15
 	ADDQ $1, R15
 	RET
-
-// Ensure from3 get GOT-rewritten without errors.
-TEXT ·a35(SB), 0, $0-0
-	VGF2P8AFFINEQB	$0, runtime·writeBarrier(SB), Z1, Z1
-	RET
--- a/src/cmd/asm/internal/asm/testdata/amd64enc_extra.s
+++ b/src/cmd/asm/internal/asm/testdata/amd64enc_extra.s
@@ -1059,7 +1059,5 @@ TEXT asmtest(SB),DUPOK|NOSPLIT,$0
 	RDPID DX                                // f30fc7fa
 	RDPID R11                               // f3410fc7fb

-	ENDBR64					// f30f1efa
-
 	// End of tests.
 	RET
--- a/src/cmd/asm/internal/asm/testdata/arm64.s
+++ b/src/cmd/asm/internal/asm/testdata/arm64.s
@@ -400,8 +400,6 @@ TEXT	foo(SB), DUPOK|NOSPLIT, $-8
 	MOVD	$0x11110000, R1               // MOVD	$286326784, R1              // 2122a2d2
 	MOVD	$0xaaaa0000aaaa1111, R1       // MOVD	$-6149102338357718767, R1   // 212282d24155b5f24155f5f2
 	MOVD	$0x1111ffff1111aaaa, R1       // MOVD	$1230045644216969898, R1    // a1aa8a922122a2f22122e2f2
-	MOVD	$0xaaaaaaaaaaaaaaab, R1       // MOVD	$-6148914691236517205, R1   // e1f301b2615595f2
-	MOVD	$0x0ff019940ff00ff0, R1       // MOVD	$1148446028692721648, R1    // e19f0cb28132c3f2
 	MOVD	$0, R1                        // e1031faa
 	MOVD	$-1, R1                       // 01008092
 	MOVD	$0x210000, R0                 // MOVD	$2162688, R0                // 2004a0d2
@@ -632,8 +630,6 @@ TEXT	foo(SB), DUPOK|NOSPLIT, $-8
 	FMOVS	F1, 0x44332211(R2)	// FMOVS	F1, 1144201745(R2)
 	FMOVD	F1, 0x1007000(R2)	// FMOVD	F1, 16805888(R2)
 	FMOVD	F1, 0x44332211(R2)	// FMOVD	F1, 1144201745(R2)
-	FMOVQ	F1, 0x1003000(R2)	// FMOVQ	F1, 16789504(R2)
-	FMOVQ	F1, 0x44332211(R2)	// FMOVQ	F1, 1144201745(R2)

 	MOVB	0x1000000(R1), R2	// MOVB		16777216(R1), R2
 	MOVB	0x44332211(R1), R2	// MOVB		1144201745(R1), R2
@@ -647,8 +643,6 @@ TEXT	foo(SB), DUPOK|NOSPLIT, $-8
 	FMOVS	0x44332211(R1), F2	// FMOVS	1144201745(R1), F2
 	FMOVD	0x1000000(R1), F2	// FMOVD	16777216(R1), F2
 	FMOVD	0x44332211(R1), F2	// FMOVD	1144201745(R1), F2
-	FMOVQ	0x1000000(R1), F2	// FMOVQ	16777216(R1), F2
-	FMOVQ	0x44332211(R1), F2	// FMOVQ	1144201745(R1), F2

 // shifted or extended register offset.
 	MOVD	(R2)(R6.SXTW), R4               // 44c866f8
@@ -1894,18 +1888,4 @@ next:
 	DC	CIGDVAC, R25                       // b97e0bd5
 	DC	CVAP, R26                          // 3a7c0bd5
 	DC	CVADP, R27                         // 3b7d0bd5
-
-// Branch Target Identification
-	BTI	C                                  // 5f2403d5
-	BTI	J                                  // 9f2403d5
-	BTI	JC                                 // df2403d5
-
-// Pointer Authentication Codes (PAC)
-	PACIASP                                    // 3f2303d5
-	AUTIASP                                    // bf2303d5
-	PACIBSP                                    // 7f2303d5
-	AUTIBSP                                    // ff2303d5
-	AUTIA1716                                  // 9f2103d5
-	AUTIB1716                                  // df2103d5
-
 	END
--- a/src/cmd/asm/internal/asm/testdata/arm64error.s
+++ b/src/cmd/asm/internal/asm/testdata/arm64error.s
@@ -420,12 +420,4 @@ TEXT errors(SB),$0
 	AESE	V1.B16, V2.B8                                    // ERROR "invalid arrangement"
 	SHA256SU1	V1.S4, V2.B16, V3.S4                     // ERROR "invalid arrangement"
 	SHA1H	V1.B16, V2.B16                                   // ERROR "invalid operands"
-	BTI                                       		 // ERROR "missing operand"
-	BTI	PLDL1KEEP					 // ERROR "illegal argument"
-	PACIASP	C                                                // ERROR "illegal combination"
-	AUTIASP	R2                                               // ERROR "illegal combination"
-	PACIBSP	R0                                               // ERROR "illegal combination"
-	AUTIBSP	C                                                // ERROR "illegal combination"
-	AUTIA1716	$45                                      // ERROR "illegal combination"
-	AUTIB1716	R0                                       // ERROR "illegal combination"
 	RET
--- a/src/cmd/asm/internal/asm/testdata/loong64enc1.s
+++ b/src/cmd/asm/internal/asm/testdata/loong64enc1.s
--- a/src/cmd/asm/internal/asm/testdata/loong64enc2.s
+++ b/src/cmd/asm/internal/asm/testdata/loong64enc2.s
@@ -12,7 +12,7 @@ TEXT asmtest(SB),DUPOK|NOSPLIT,$0
 	AND	$-1, R4, R5		// 1efcbf0285f81400
 	AND	$-1, R4			// 1efcbf0284f81400
 	MOVW	$-1, F4			// 1efcbf02c4a71401
-	MOVW	$1, F4			// 1e048003c4a71401
+	MOVW	$1, F4			// 1e048002c4a71401
 	TEQ	$4, R4, R5		// 8508005c04002a00
 	TEQ	$4, R4			// 0408005c04002a00
 	TNE	$4, R4, R5		// 8508005804002a00
@@ -21,10 +21,6 @@ TEXT asmtest(SB),DUPOK|NOSPLIT,$0
 	ADD	$4096, R4, R5		// 3e00001485781000
 	ADD	$65536, R4		// 1e02001484781000
 	ADD	$4096, R4		// 3e00001484781000
-	ADDW	$65536, R4, R5		// 1e02001485781000
-	ADDW	$4096, R4, R5		// 3e00001485781000
-	ADDW	$65536, R4		// 1e02001484781000
-	ADDW	$4096, R4		// 3e00001484781000
 	ADDV	$65536, R4, R5		// 1e02001485f81000
 	ADDV	$4096, R4, R5		// 3e00001485f81000
 	ADDV	$65536, R4		// 1e02001484f81000
@@ -41,6 +37,10 @@ TEXT asmtest(SB),DUPOK|NOSPLIT,$0
 	SGTU	$4096, R4, R5		// 3e00001485f81200
 	SGTU	$65536, R4		// 1e02001484f81200
 	SGTU	$4096, R4		// 3e00001484f81200
+	ADDU	$65536, R4, R5		// 1e02001485781000
+	ADDU	$4096, R4, R5		// 3e00001485781000
+	ADDU	$65536, R4		// 1e02001484781000
+	ADDU	$4096, R4		// 3e00001484781000
 	ADDVU	$65536, R4, R5		// 1e02001485f81000
 	ADDVU	$4096, R4, R5		// 3e00001485f81000
 	ADDVU	$65536, R4		// 1e02001484f81000
@@ -77,49 +77,3 @@ TEXT asmtest(SB),DUPOK|NOSPLIT,$0
 	MOVH	name(SB), R4		// 1e00001ac4034028
 	MOVHU	R4, name(SB)		// 1e00001ac4034029
 	MOVHU	name(SB), R4		// 1e00001ac403402a
-
-	// MOVV C_DCON12_20S, r
-	MOVV    $0x273fffff80000000, R4         // MOVV	$2828260563841187840, R4        // 0400001584cc0903
-	MOVV    $0xf73fffff80000000, R4         // MOVV	$-630503949979353088, R4        // 0400001584cc3d03
-
-	// MOVV C_DCON20S_20, r
-	MOVV    $0xfff800000f000000, R4         // MOVV	$-2251799562027008, R4          // 04001e1404000017
-
-	// MOVV C_DCON12_12S, r
-	MOVV    $0x273ffffffffff800, R4         // MOVV	$2828260565988669440, R4        // 0400e00284cc0903
-	MOVV    $0xf73ffffffffff800, R4         // MOVV	$-630503947831871488, R4        // 0400e00284cc3d03
-
-	// MOVV C_DCON20S_12S, r
-	MOVV    $0xfff80000fffff800, R4         // MOVV	$-2251795518720000, R4          // 0400a00204000017
-	MOVV    $0xfff8000000000000, R4         // MOVV	$-2251799813685248, R4          // 0400800204000017
-
-	// MOVV C_DCON12_12U, r
-	MOVV    $0x2730000000000800, R4         // MOVV	$2823756966361303040, R4        // 0400a00384cc0903
-	MOVV    $0xf730000000000800, R4         // MOVV	$-635007547459237888, R4        // 0400a00384cc3d03
-
-	// MOVV C_DCON20S_12U, r
-	MOVV    $0xfff8000000000800, R4         // MOVV	$-2251799813683200, R4          // 0400a00304000017
-
-	// ADDV/AND C_DCON12_0, [r1], r2
-	ADDV	$0x3210000000000000, R4		// ADDV	$3607383301523767296, R4	// 1e840c0384f81000
-	ADDV	$0x3210000000000000, R5, R4	// ADDV	$3607383301523767296, R5, R4	// 1e840c03a4f81000
-	ADDV	$0xc210000000000000, R4		// ADDV	$-4463067230724161536, R4	// 1e84300384f81000
-	ADDV	$0xc210000000000000, R5, R4	// ADDV	$-4463067230724161536, R5, R4	// 1e843003a4f81000
-	AND	$0x3210000000000000, R4		// AND	$3607383301523767296, R4	// 1e840c0384f81400
-	AND	$0x3210000000000000, R5, R4	// AND	$3607383301523767296, R5, R4	// 1e840c03a4f81400
-	AND	$0xc210000000000000, R4		// AND	$-4463067230724161536, R4	// 1e84300384f81400
-	AND	$0xc210000000000000, R5, R4	// AND	$-4463067230724161536, R5, R4	// 1e843003a4f81400
-
-	// ADDV/AND C_UCON, [r1], r2
-	ADDV	$0x43210000, R4			// ADDV	$1126236160, R4			// 1e42861484f81000
-	ADDV	$0x43210000, R5, R4		// ADDV	$1126236160, R5, R4		// 1e428614a4f81000
-	ADDV	$0xffffffffc3210000, R4		// ADDV	$-1021247488, R4		// 1e42861584f81000
-	ADDV	$0xffffffffc3210000, R5, R4	// ADDV	$-1021247488, R5, R4		// 1e428615a4f81000
-	AND	$0x43210000, R4			// AND	$1126236160, R4			// 1e42861484f81400
-	AND	$0x43210000, R5, R4		// AND	$1126236160, R5, R4		// 1e428614a4f81400
-	AND	$0xffffffffc3210000, R4		// AND	$-1021247488, R4		// 1e42861584f81400
-	AND	$0xffffffffc3210000, R5, R4	// AND	$-1021247488, R5, R4		// 1e428615a4f81400
-
-	// AND C_ADDCON, [r1], r2
-	AND	$0xfffffffffffffc21, R4		// AND	$-991, R4			// 1e84b00284f81400
-	AND	$0xfffffffffffffc21, R5, R4	// AND	$-991, R5, R4			// 1e84b002a4f81400
--- a/src/cmd/asm/internal/asm/testdata/loong64enc3.s
+++ b/src/cmd/asm/internal/asm/testdata/loong64enc3.s
@@ -11,16 +11,12 @@ TEXT asmtest(SB),DUPOK|NOSPLIT,$0
 	MOVV	$4096(R4), R5			// 3e000014de03800385f81000
 	ADD	$74565, R4			// 5e020014de178d0384781000
 	ADD	$4097, R4  			// 3e000014de07800384781000
-	ADDW	$74565, R4			// 5e020014de178d0384781000
-	ADDW	$4097, R4  			// 3e000014de07800384781000
 	ADDV	$74565, R4			// 5e020014de178d0384f81000
 	ADDV	$4097, R4 			// 3e000014de07800384f81000
 	AND	$74565, R4			// 5e020014de178d0384f81400
 	AND	$4097, R4 		 	// 3e000014de07800384f81400
 	ADD	$74565, R4, R5			// 5e020014de178d0385781000
 	ADD	$4097, R4, R5  			// 3e000014de07800385781000
-	ADDW	$74565, R4, R5			// 5e020014de178d0385781000
-	ADDW	$4097, R4, R5  			// 3e000014de07800385781000
 	ADDV	$74565, R4, R5			// 5e020014de178d0385f81000
 	ADDV	$4097, R4, R5 			// 3e000014de07800385f81000
 	AND	$74565, R4, R5			// 5e020014de178d0385f81400
@@ -46,10 +42,8 @@ TEXT asmtest(SB),DUPOK|NOSPLIT,$0
 	MOVB	R4, 4096(R5)			// 3e000014de971000c4030029
 	MOVBU	R4, 65536(R5)			// 1e020014de971000c4030029
 	MOVBU	R4, 4096(R5)			// 3e000014de971000c4030029
-	SC	R4, 65536(R5)			// 1e040010de971000c4030021
-	SCV	R4, 65536(R5)			// 1e040010de971000c4030023
-	LL	65536(R5), R4			// 1e040010de971000c4030020
-	LLV	65536(R5), R4			// 1e040010de971000c4030022
+	SC	R4, 65536(R5)			// 1e020014de971000c4030021
+	SC	R4, 4096(R5)	   		// 3e000014de971000c4030021
 	MOVW	y+65540(FP), R4			// 1e020014de8f1000c4338028
 	MOVWU	y+65540(FP), R4			// 1e020014de8f1000c433802a
 	MOVV	y+65540(FP), R4			// 1e020014de8f1000c433c028
@@ -111,6 +105,10 @@ TEXT asmtest(SB),DUPOK|NOSPLIT,$0
 	SGTU	$74565, R4, R5 			// 5e020014de178d0385f81200
 	SGTU	$4097, R4 			// 3e000014de07800384f81200
 	SGTU	$4097, R4, R5 			// 3e000014de07800385f81200
+	ADDU	$74565, R4 			// 5e020014de178d0384781000
+	ADDU	$74565, R4, R5 			// 5e020014de178d0385781000
+	ADDU	$4097, R4 			// 3e000014de07800384781000
+	ADDU	$4097, R4, R5 			// 3e000014de07800385781000
 	ADDVU	$4097, R4			// 3e000014de07800384f81000
 	ADDVU	$4097, R4, R5 			// 3e000014de07800385f81000
 	ADDVU	$74565, R4			// 5e020014de178d0384f81000
@@ -123,83 +121,3 @@ TEXT asmtest(SB),DUPOK|NOSPLIT,$0
 	XOR	$74565, R4, R5			// 5e020014de178d0385f81500
 	XOR	$4097, R4			// 3e000014de07800384f81500
 	XOR	$4097, R4, R5			// 3e000014de07800385f81500
-
-	MOVWP	R5, -32768(R4)			// 1efcff13de931000c5038025
-	MOVWP	R5, 32768(R4)			// 1e000010de931000c5038025
-	MOVWP	R5, 65536(R4)			// 1e040010de931000c5030025
-	MOVWP	R5, 1048576(R4)			// 1e400010de931000c5030025
-	MOVVP	R5, -32768(R4)			// 1efcff13de931000c5038027
-	MOVVP	R5, 65536(R4)			// 1e040010de931000c5030027
-	MOVVP	R5, 1048576(R4)			// 1e400010de931000c5030027
-	MOVWP	-32768(R5), R4			// 1efcff13de971000c4038024
-	MOVWP	2229248(R5), R4			// 1e880010de971000c4030424
-	MOVWP	-2145518592(R5), R4		// 1e740012de971000c403fc24
-	MOVVP	-32768(R5), R4			// 1efcff13de971000c4038026
-	MOVVP	2229248(R5), R4			// 1e880010de971000c4030426
-	MOVVP	-2145518592(R5), R4		// 1e740012de971000c403fc26
-
-
-	// MOVV C_DCON32_12S, r
-	MOVV    $0x27312345fffff800, R4         // MOVV	$2824077224892692480, R4        // 0400a002a468241684cc0903
-	MOVV    $0xf7312345fffff800, R4         // MOVV	$-634687288927848448, R4        // 0400a002a468241684cc3d03
-
-	// MOVV C_DCON32_0, r
-	MOVV    $0x2731234500000000, R4         // MOVV	$2824077220597727232, R4        // 04008002a468241684cc0903
-	MOVV    $0xf731234500000000, R4         // MOVV	$-634687293222813696, R4        // 04008002a468241684cc3d03
-
-	// MOVV C_DCON32_20, r
-	MOVV    $0x2731234512345000, R4         // MOVV	$2824077220903145472, R4        // a4682414a468241684cc0903
-	MOVV    $0xf731234512345000, R4         // MOVV	$-634687292917395456, R4        // a4682414a468241684cc3d03
-
-	// MOVV C_DCON12_32S, r
-	MOVV    $0x273fffff80000800, R4         // MOVV	$2828260563841189888, R4        // 040000158400a00384cc0903
-	MOVV    $0xf73fffff80000800, R4         // MOVV	$-630503949979351040, R4        // 040000158400a00384cc3d03
-
-	// MOVV C_DCON20S_32, r
-	MOVV    $0xfff8000080000800, R4         // MOVV	$-2251797666199552, R4          // 040000158400a00304000017
-
-	// MOVV C_DCON32_12U, r
-	MOVV    $0x2731234500000800, R4         // MOVV	$2824077220597729280, R4        // 0400a003a468241684cc0903
-	MOVV    $0xf731234500000800, R4         // MOVV	$-634687293222811648, R4        // 0400a003a468241684cc3d03
-
-	// ADDV/AND C_DCON12_20S, [r1], r2
-	ADDV    $0x273fffff80000000, R4         // ADDV	$2828260563841187840, R4        // 1e000015decf090384f81000
-	ADDV    $0x273fffff80000000, R4, R5     // ADDV	$2828260563841187840, R4, R5    // 1e000015decf090385f81000
-	AND     $0x273fffff80000000, R4         // AND	$2828260563841187840, R4        // 1e000015decf090384f81400
-	AND     $0x273fffff80000000, R4, R5     // AND	$2828260563841187840, R4, R5    // 1e000015decf090385f81400
-
-	// ADDV/AND C_DCON20S_20, [r1], r2
-	ADDV    $0xfff800000f000000, R4         // ADDV	$-2251799562027008, R4          // 1e001e141e00001784f81000
-	ADDV    $0xfff800000f000000, R4, R5     // ADDV	$-2251799562027008, R4, R5      // 1e001e141e00001785f81000
-	AND     $0xfff800000f000000, R4         // AND	$-2251799562027008, R4          // 1e001e141e00001784f81400
-	AND     $0xfff800000f000000, R4, R5     // AND	$-2251799562027008, R4, R5      // 1e001e141e00001785f81400
-
-	// ADDV/AND C_DCON12_12S, [r1], r2
-	ADDV    $0x273ffffffffff800, R4         // ADDV	$2828260565988669440, R4        // 1e00e002decf090384f81000
-	ADDV    $0x273ffffffffff800, R4, R5     // ADDV	$2828260565988669440, R4, R5    // 1e00e002decf090385f81000
-	AND     $0x273ffffffffff800, R4         // AND	$2828260565988669440, R4        // 1e00e002decf090384f81400
-	AND     $0x273ffffffffff800, R4, R5     // AND	$2828260565988669440, R4, R5    // 1e00e002decf090385f81400
-
-	// ADDV/AND C_DCON20S_12S, [r1], r2
-	ADDV    $0xfff80000fffff800, R4         // ADDV	$-2251795518720000, R4          // 1e00a0021e00001784f81000
-	ADDV    $0xfff80000fffff800, R4, R5     // ADDV	$-2251795518720000, R4, R5      // 1e00a0021e00001785f81000
-	AND     $0xfff80000fffff800, R4         // AND	$-2251795518720000, R4          // 1e00a0021e00001784f81400
-	AND     $0xfff80000fffff800, R4, R5     // AND	$-2251795518720000, R4, R5      // 1e00a0021e00001785f81400
-
-	// ADDV/AND C_DCON20S_0, [r1], r2
-	ADDV    $0xfff8000000000000, R4         // ADDV	$-2251799813685248, R4          // 1e0080021e00001784f81000
-	ADDV    $0xfff8000000000000, R4, R5     // ADDV	$-2251799813685248, R4, R5      // 1e0080021e00001785f81000
-	AND     $0xfff8000000000000, R4         // AND	$-2251799813685248, R4          // 1e0080021e00001784f81400
-	AND     $0xfff8000000000000, R4, R5     // AND	$-2251799813685248, R4, R5      // 1e0080021e00001785f81400
-
-	// ADDV/AND C_DCON12_12U, [r1], r2
-	ADDV    $0x2730000000000800, R4         // ADDV	$2823756966361303040, R4        // 1e00a003decf090384f81000
-	ADDV    $0x2730000000000800, R4, R5     // ADDV	$2823756966361303040, R4, R5    // 1e00a003decf090385f81000
-	AND     $0x2730000000000800, R4         // AND	$2823756966361303040, R4        // 1e00a003decf090384f81400
-	AND     $0x2730000000000800, R4, R5     // AND	$2823756966361303040, R4, R5    // 1e00a003decf090385f81400
-
-	// ADDV/AND C_DCON20S_12U, [r1], r2
-	ADDV    $0xfff8000000000800, R4         // ADDV	$-2251799813683200, R4          // 1e00a0031e00001784f81000
-	ADDV    $0xfff8000000000800, R4, R5     // ADDV	$-2251799813683200, R4, R5      // 1e00a0031e00001785f81000
-	AND     $0xfff8000000000800, R4         // AND	$-2251799813683200, R4          // 1e00a0031e00001784f81400
-	AND     $0xfff8000000000800, R4, R5     // AND	$-2251799813683200, R4, R5      // 1e00a0031e00001785f81400
--- a/src/cmd/asm/internal/asm/testdata/loong64enc4.s
+++ b/src/cmd/asm/internal/asm/testdata/loong64enc4.s
@@ -1,42 +0,0 @@
-// 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.
-
-#include "../../../../../runtime/textflag.h"
-
-TEXT asmtest(SB),DUPOK|NOSPLIT,$0
-	// ADDV/AND C_DCON32_12S, [r1], r2
-	ADDV    $0x27312345fffff800, R4         // ADDV	$2824077224892692480, R4        // 1e00a002be682416decf090384f81000
-	ADDV    $0x27312345fffff800, R4, R5     // ADDV	$2824077224892692480, R4, R5    // 1e00a002be682416decf090385f81000
-	AND     $0x27312345fffff800, R4         // AND	$2824077224892692480, R4        // 1e00a002be682416decf090384f81400
-	AND     $0x27312345fffff800, R4, R5     // AND	$2824077224892692480, R4, R5    // 1e00a002be682416decf090385f81400
-
-	// ADDV/AND C_DCON32_0, [r1], r2
-	ADDV    $0x2731234500000000, R4         // ADDV	$2824077220597727232, R4        // 1e008002be682416decf090384f81000
-	ADDV    $0x2731234500000000, R4, R5     // ADDV	$2824077220597727232, R4, R5    // 1e008002be682416decf090385f81000
-	AND     $0x2731234500000000, R4         // AND	$2824077220597727232, R4        // 1e008002be682416decf090384f81400
-	AND     $0x2731234500000000, R4, R5     // AND	$2824077220597727232, R4, R5    // 1e008002be682416decf090385f81400
-
-	// ADDV/AND C_DCON32_20, [r1], r2
-	ADDV    $0x2731234512345000, R4         // ADDV	$2824077220903145472, R4        // be682414be682416decf090384f81000
-	ADDV    $0x2731234512345000, R4, R5     // ADDV	$2824077220903145472, R4, R5    // be682414be682416decf090385f81000
-	AND     $0x2731234512345000, R4         // AND	$2824077220903145472, R4        // be682414be682416decf090384f81400
-	AND     $0x2731234512345000, R4, R5     // AND	$2824077220903145472, R4, R5    // be682414be682416decf090385f81400
-
-	// ADDV/AND C_DCON12_32S, [r1], r2
-	ADDV    $0x273fffff80000800, R4         // ADDV	$2828260563841189888, R4        // 1e000015de03a003decf090384f81000
-	ADDV    $0x273fffff80000800, R4, R5     // ADDV	$2828260563841189888, R4, R5    // 1e000015de03a003decf090385f81000
-	AND     $0x273fffff80000800, R4         // AND	$2828260563841189888, R4        // 1e000015de03a003decf090384f81400
-	AND     $0x273fffff80000800, R4, R5     // AND	$2828260563841189888, R4, R5    // 1e000015de03a003decf090385f81400
-
-	// ADDV/AND C_DCON20S_32, [r1], r2
-	ADDV    $0xfff8000080000800, R4         // ADDV	$-2251797666199552, R4          // 1e000015de03a0031e00001784f81000
-	ADDV    $0xfff8000080000800, R4, R5     // ADDV	$-2251797666199552, R4, R5      // 1e000015de03a0031e00001785f81000
-	AND     $0xfff8000080000800, R4         // AND	$-2251797666199552, R4          // 1e000015de03a0031e00001784f81400
-	AND     $0xfff8000080000800, R4, R5     // AND	$-2251797666199552, R4, R5      // 1e000015de03a0031e00001785f81400
-
-	// ADDV/AND C_DCON32_12U, [r1], r2
-	ADDV    $0x2731234500000800, R4         // ADDV	$2824077220597729280, R4        // 1e00a003be682416decf090384f81000
-	ADDV    $0x2731234500000800, R4, R5     // ADDV	$2824077220597729280, R4, R5    // 1e00a003be682416decf090385f81000
-	AND     $0x2731234500000800, R4         // AND	$2824077220597729280, R4        // 1e00a003be682416decf090384f81400
-	AND     $0x2731234500000800, R4, R5     // AND	$2824077220597729280, R4, R5    // 1e00a003be682416decf090385f81400
--- a/src/cmd/asm/internal/asm/testdata/loong64enc5.s
+++ b/src/cmd/asm/internal/asm/testdata/loong64enc5.s
@@ -1,22 +0,0 @@
-// 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.
-
-#include "../../../../../runtime/textflag.h"
-
-TEXT asmtest(SB),DUPOK|NOSPLIT,$0
-	// ADDV/AND C_DCON, [r1], r2
-	ADDV	$0xfedcba9876543210, R4		// ADDV	$-81985529216486896, R4		// 7ea8ec14de4388031e539717deb73f0384f81000
-	ADDV	$0xfedcba9876543210, R5, R4	// ADDV	$-81985529216486896, R5, R4	// 7ea8ec14de4388031e539717deb73f03a4f81000
-	ADDV	$0x4edcba9876543210, R4		// ADDV	$5682621993817747984, R4	// 7ea8ec14de4388031e539717deb7130384f81000
-	ADDV	$0x4edcba9876543210, R5, R4	// ADDV	$5682621993817747984, R5, R4	// 7ea8ec14de4388031e539717deb71303a4f81000
-	AND	$0x4edcba9876543210, R4		// AND	$5682621993817747984, R4	// 7ea8ec14de4388031e539717deb7130384f81400
-	AND	$0x4edcba9876543210, R5, R4	// AND	$5682621993817747984, R5, R4	// 7ea8ec14de4388031e539717deb71303a4f81400
-	AND	$0xfedcba9876543210, R4		// AND	$-81985529216486896, R4		// 7ea8ec14de4388031e539717deb73f0384f81400
-	AND	$0xfedcba9876543210, R5, R4	// AND	$-81985529216486896, R5, R4	// 7ea8ec14de4388031e539717deb73f03a4f81400
-
-	PRELDX	0(R7), $0x80001021, $0		// PRELDX (R7), $2147487777, $0		// 1e020014de0380031e000016de130003e0782c38
-	PRELDX	-1(R7), $0x1021, $2		// PRELDX -1(R7), $4129, $2		// fe030014deffbf031e000016de030003e2782c38
-	PRELDX	8(R7), $0x80100800, $31		// PRELDX 8(R7), $2148534272, $31	// 1ee00714de238003fe1f0016de130003ff782c38
-	PRELDX	16(R7), $0x202040, $1		// PRELDX 16(R7), $2105408, $1		// 1e200014de4380033e000216de030003e1782c38
-
--- a/src/cmd/asm/internal/asm/testdata/loong64enc6.s
+++ b/src/cmd/asm/internal/asm/testdata/loong64enc6.s
@@ -1,12 +0,0 @@
-// 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.
-
-#include "../../../../../runtime/textflag.h"
-
-TEXT asmtest(SB),DUPOK|NOSPLIT,$0
-	// MOVWP LOREG_64(Rx), Ry
-	MOVWP	81985529216486896(R4), R5	// 9e571315dec3b703feac6816de4b000384f8100085000025
-	MOVWP	-81985529216486896(R4), R5	// 7ea8ec14de4388031e539717deb73f0384f8100085000025
-	MOVWP	R4, 81985529216486896(R5)	// 9e571315dec3b703feac6816de4b0003a5f81000a4000025
-	MOVWP	R4, -81985529216486896(R5)	// 7ea8ec14de4388031e539717deb73f03a5f81000a4000025
--- a/src/cmd/asm/internal/asm/testdata/loong64error.s
+++ b/src/cmd/asm/internal/asm/testdata/loong64error.s
@@ -1,14 +0,0 @@
-// 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.
-
-TEXT errors(SB),$0
-	VSHUF4IV	$16, V1, V2	// ERROR "operand out of range 0 to 15"
-	XVSHUF4IV	$16, X1, X2	// ERROR "operand out of range 0 to 15"
-	ADDV16		$1, R4, R5	// ERROR "the constant must be a multiple of 65536."
-	ADDV16		$65535, R4, R5	// ERROR "the constant must be a multiple of 65536."
-	SC		R4, 1(R5)	// ERROR "offset must be a multiple of 4."
-	SCV		R4, 1(R5)	// ERROR "offset must be a multiple of 4."
-	LL		1(R5), R4	// ERROR "offset must be a multiple of 4."
-	LLV		1(R5), R4	// ERROR "offset must be a multiple of 4."
-
--- a/src/cmd/asm/internal/asm/testdata/riscv64.s
+++ b/src/cmd/asm/internal/asm/testdata/riscv64.s
--- a/src/cmd/asm/internal/asm/testdata/riscv64error.s
+++ b/src/cmd/asm/internal/asm/testdata/riscv64error.s
@@ -3,27 +3,6 @@
 // license that can be found in the LICENSE file.

 TEXT errors(SB),$0
-	CSRRC	(X10), CYCLE, X5		// ERROR "integer register or immediate expected for 1st operand"
-	CSRRC	X0, TU, X5			// ERROR "unknown CSR"
-	CSRRC	X0, CYCLE			// ERROR "missing CSR name"
-	CSRRC	X0, CYCLE, (X10)		// ERROR "needs an integer register output"
-	CSRRC	$-1, TIME, X15			// ERROR "immediate out of range 0 to 31"
-	CSRRCI	$32, TIME, X15			// ERROR "immediate out of range 0 to 31"
-	CSRRCI	$1, TIME, (X15)			// ERROR "needs an integer register output"
-	CSRRS	(X10), CYCLE, X5		// ERROR "integer register or immediate expected for 1st operand"
-	CSRRS	X0, CYCLE, (X10)		// ERROR "needs an integer register output"
-	CSRRS	X0, TU, X5			// ERROR "unknown CSR"
-	CSRRS	X0, CYCLE			// ERROR "missing CSR name"
-	CSRRS	$-1, TIME, X15			// ERROR "immediate out of range 0 to 31"
-	CSRRSI	$32, TIME, X15			// ERROR "immediate out of range 0 to 31"
-	CSRRSI	$1, TIME, (X15)			// ERROR "needs an integer register output"
-	CSRRW	(X10), CYCLE, X5		// ERROR "integer register or immediate expected for 1st operand"
-	CSRRW	X0, TU, X5			// ERROR "unknown CSR"
-	CSRRW	X0, CYCLE			// ERROR "missing CSR name"
-	CSRRW	X0, CYCLE, (X5)			// ERROR "needs an integer register output"
-	CSRRW	$-1, TIME, X15			// ERROR "immediate out of range 0 to 31"
-	CSRRWI	$32, TIME, X15			// ERROR "immediate out of range 0 to 31"
-	CSRRWI	$1, TIME, (X15)			// ERROR "needs an integer register output"
 	MOV	$errors(SB), (X5)		// ERROR "address load must target register"
 	MOV	$8(SP), (X5)			// ERROR "address load must target register"
 	MOVB	$8(SP), X5			// ERROR "unsupported address load"
@@ -51,8 +30,6 @@ TEXT errors(SB),$0
 	SLLI	$64, X5, X6			// ERROR "immediate out of range 0 to 63"
 	SRLI	$64, X5, X6			// ERROR "immediate out of range 0 to 63"
 	SRAI	$64, X5, X6			// ERROR "immediate out of range 0 to 63"
-	BEQ	X5, X6, $1			// ERROR "instruction with branch-like opcode lacks destination"
-	BEQ	X5, X6, 31(X10)			// ERROR "instruction with branch-like opcode lacks destination"
 	RORI	$-1, X5, X6			// ERROR "immediate out of range 0 to 63"
 	SLLI	$-1, X5, X6			// ERROR "immediate out of range 0 to 63"
 	SRLI	$-1, X5, X6			// ERROR "immediate out of range 0 to 63"
@@ -66,355 +43,7 @@ TEXT errors(SB),$0
 	SRLIW	$-1, X5, X6			// ERROR "immediate out of range 0 to 31"
 	SRAIW	$-1, X5, X6			// ERROR "immediate out of range 0 to 31"
 	SD	X5, 4294967296(X6)		// ERROR "constant 4294967296 too large"
+	SRLI	$1, X5, F1			// ERROR "expected integer register in rd position but got non-integer register F1"
+	SRLI	$1, F1, X5			// ERROR "expected integer register in rs1 position but got non-integer register F1"
 	FNES	F1, (X5)			// ERROR "needs an integer register output"
-
-	//
-	// "V" Standard Extension for Vector Operations, Version 1.0
-	//
-	VSETIVLI	X10, E32, M2, TA, MA, X12	// ERROR "expected immediate value"
-	VLE8V		(X10), V1, V3			// ERROR "invalid vector mask register"
-	VLE8FFV		(X10), V1, V3			// ERROR "invalid vector mask register"
-	VSE8V		V3, V1, (X10)			// ERROR "invalid vector mask register"
-	VLSE8V		(X10), X10, V1, V3		// ERROR "invalid vector mask register"
-	VSSE8V		V3, X11, V1, (X10)		// ERROR "invalid vector mask register"
-	VLUXEI8V	(X10), V2, V1, V3		// ERROR "invalid vector mask register"
-	VSUXEI8V	V3, V2, V1, (X10)		// ERROR "invalid vector mask register"
-	VLOXEI8V	(X10), V2, V1, V3		// ERROR "invalid vector mask register"
-	VSOXEI8V	V3, V2, V1, (X10)		// ERROR "invalid vector mask register"
-	VLSEG2E8V	(X10), V1, V3			// ERROR "invalid vector mask register"
-	VLSEG2E8FFV	(X10), V1, V3			// ERROR "invalid vector mask register"
-	VSSEG2E8V	V3, V1, (X10)			// ERROR "invalid vector mask register"
-	VLSSEG2E8V	(X10), X10, V1, V3		// ERROR "invalid vector mask register"
-	VSSSEG2E8V	V3, X11, V1, (X10)		// ERROR "invalid vector mask register"
-	VLUXSEG2EI8V	(X10), V2, V1, V3		// ERROR "invalid vector mask register"
-	VSUXSEG2EI8V	V3, V2, V1, (X10)		// ERROR "invalid vector mask register"
-	VLOXSEG2EI8V	(X10), V2, V1, V3		// ERROR "invalid vector mask register"
-	VSOXSEG2EI8V	V3, V2, V1, (X10)		// ERROR "invalid vector mask register"
-	VL1RV		(X10), V0, V3			// ERROR "too many operands for instruction"
-	VS1RV		V3, V0, (X11)			// ERROR "too many operands for instruction"
-	VADDVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VADDVX		X10, V2, V1, V3			// ERROR "invalid vector mask register"
-	VADDVI		$15, V4, V1, V2			// ERROR "invalid vector mask register"
-	VSUBVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VSUBVX		X10, V2, V1, V3			// ERROR "invalid vector mask register"
-	VRSUBVX		X10, V2, V1, V3			// ERROR "invalid vector mask register"
-	VRSUBVI		$15, V4, V1, V2			// ERROR "invalid vector mask register"
-	VNEGV		V2, V3, V4			// ERROR "invalid vector mask register"
-	VWADDUVV	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VWADDUVX	X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VWSUBUVV	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VWSUBUVX	X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VWADDVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VWADDVX		X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VWSUBVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VWSUBVX		X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VWADDUWV	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VWADDUWX	X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VWSUBUWV	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VWSUBUWX	X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VWADDWV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VWADDWX		X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VWSUBWV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VWSUBWX		X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VWCVTXXV	V2, V1, V3			// ERROR "invalid vector mask register"
-	VWCVTUXXV	V2, V1, V3			// ERROR "invalid vector mask register"
-	VZEXTVF2	V2, V3, V4			// ERROR "invalid vector mask register"
-	VSEXTVF2	V2, V3, V4			// ERROR "invalid vector mask register"
-	VZEXTVF4	V2, V3, V4			// ERROR "invalid vector mask register"
-	VSEXTVF4	V2, V3, V4			// ERROR "invalid vector mask register"
-	VZEXTVF8	V2, V3, V4			// ERROR "invalid vector mask register"
-	VSEXTVF8	V2, V3, V4			// ERROR "invalid vector mask register"
-	VADCVVM		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VADCVVM		V1, V2, V3			// ERROR "invalid vector mask register"
-	VADCVVM		V1, V2, V0, V0			// ERROR "invalid destination register V0"
-	VADCVXM		X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VADCVXM		X10, V2, V3			// ERROR "invalid vector mask register"
-	VADCVXM		X10, V2, V0, V0			// ERROR "invalid destination register V0"
-	VADCVIM		$15, V2, V1, V3			// ERROR "invalid vector mask register"
-	VADCVIM		$15, V2, V3			// ERROR "invalid vector mask register"
-	VADCVIM		$15, V2, V0, V0			// ERROR "invalid destination register V0"
-	VMADCVVM	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMADCVVM	V1, V2, V3			// ERROR "invalid vector mask register"
-	VMADCVXM	X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMADCVXM	X10, V2, V3			// ERROR "invalid vector mask register"
-	VMADCVIM	$15, V2, V1, V3			// ERROR "invalid vector mask register"
-	VMADCVIM	$15, V2, V3			// ERROR "invalid vector mask register"
-	VSBCVVM		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VSBCVVM		V1, V2, V3			// ERROR "invalid vector mask register"
-	VSBCVVM		V1, V2, V0, V0			// ERROR "invalid destination register V0"
-	VSBCVXM		X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VSBCVXM		X10, V2, V3			// ERROR "invalid vector mask register"
-	VSBCVXM		X10, V2, V0, V0			// ERROR "invalid destination register V0"
-	VMSBCVVM	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMSBCVVM	V1, V2, V3			// ERROR "invalid vector mask register"
-	VMSBCVXM	X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMSBCVXM	X10, V2, V3			// ERROR "invalid vector mask register"
-	VANDVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VANDVX		X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VANDVI		$15, V2, V4, V3			// ERROR "invalid vector mask register"
-	VORVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VORVX		X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VORVI		$15, V2, V4, V3			// ERROR "invalid vector mask register"
-	VXORVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VXORVX		X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VXORVI		$15, V2, V4, V3			// ERROR "invalid vector mask register"
-	VNOTV		V1, V2, V3			// ERROR "invalid vector mask register"
-	VSLLVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VSLLVX		X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VSLLVI		$15, V2, V4, V3			// ERROR "invalid vector mask register"
-	VSRLVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VSRLVX		X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VSRLVI		$15, V2, V4, V3			// ERROR "invalid vector mask register"
-	VSRAVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VSRAVX		X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VSRAVI		$15, V2, V4, V3			// ERROR "invalid vector mask register"
-	VNSRLWV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VNSRLWX		X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VNSRLWI		$31, V2, V4, V3			// ERROR "invalid vector mask register"
-	VNSRAWV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VNSRAWX		X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VNSRAWI		$31, V2, V4, V3			// ERROR "invalid vector mask register"
-	VNCVTXXW	V2, V4, V3			// ERROR "invalid vector mask register"
-	VMSEQVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMSEQVX		X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMSEQVI		$15, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMSNEVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMSNEVX		X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMSNEVI		$15, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMSLTUVV	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMSLTUVX	X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMSLTVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMSLTVX		X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMSLEUVV	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMSLEUVX	X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMSLEUVI	$15, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMSLEVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMSLEVX		X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMSLEVI		$15, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMSGTUVV	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMSGTUVX	X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMSGTUVI	$15, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMSGTVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMSGTVX		X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMSGTVI		$15, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMSGEVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMSGEUVV	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMSLTVI		$15, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMSLTUVI	$15, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMSGEVI		$15, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMSGEUVI	$15, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMINUVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMINUVX		X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMINVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMINVX		X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMAXUVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMAXUVX		X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMAXVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMAXVX		X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMULVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMULVX		X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMULHVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMULHVX		X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMULHUVV	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMULHUVX	X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMULHSUVV	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMULHSUVX	X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VDIVUVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VDIVUVX		X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VDIVVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VDIVVX		X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VREMUVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VREMUVX		X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VREMVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VREMVX		X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VWMULVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VWMULVX		X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VWMULUVV	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VWMULUVX	X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VWMULSUVV	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VWMULSUVX	X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMACCVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMACCVX		X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VNMSACVV	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VNMSACVX	X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMADDVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMADDVX		X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VNMSUBVV	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VNMSUBVX	X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VWMACCUVV	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VWMACCUVX	X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VWMACCVV	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VWMACCVX	X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VWMACCSUVV	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VWMACCSUVX	X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VWMACCUSVX	X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMERGEVVM	V1, V2, V3			// ERROR "invalid vector mask register"
-	VMERGEVVM	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMERGEVXM	X10, V2, V3			// ERROR "invalid vector mask register"
-	VMERGEVXM	X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMERGEVIM	$15, V2, V3			// ERROR "invalid vector mask register"
-	VMERGEVIM	$15, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMVVV		V1, V2, V3			// ERROR "too many operands for instruction"
-	VMVVX		X10, V2, V3			// ERROR "too many operands for instruction"
-	VMVVI		$15, V2, V3			// ERROR "too many operands for instruction"
-	VSADDUVV	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VSADDUVX	X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VSADDUVI	$15, V2, V4, V3			// ERROR "invalid vector mask register"
-	VSADDVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VSADDVX		X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VSADDVI		$15, V2, V4, V3			// ERROR "invalid vector mask register"
-	VSSUBUVV	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VSSUBUVX	X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VSSUBVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VSSUBVX		X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VAADDUVV	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VAADDUVX	X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VAADDVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VAADDVX		X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VASUBUVV	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VASUBUVX	X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VASUBVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VASUBVX		X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VSMULVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VSMULVX		X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VSSRLVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VSSRLVX		X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VSSRLVI		$15, V2, V4, V3			// ERROR "invalid vector mask register"
-	VSSRAVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VSSRAVX		X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VSSRAVI		$15, V2, V4, V3			// ERROR "invalid vector mask register"
-	VNCLIPUWV	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VNCLIPUWX	X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VNCLIPUWI	$16, V2, V4, V3			// ERROR "invalid vector mask register"
-	VNCLIPWV	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VNCLIPWX	X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VNCLIPWI	$16, V2, V4, V3			// ERROR "invalid vector mask register"
-	VFADDVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VFADDVF		F10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VFSUBVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VFSUBVF		F10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VFRSUBVF	F10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VFWADDVV	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VFWADDVF	F10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VFWSUBVV	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VFWSUBVF	F10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VFWADDWV	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VFWADDWF	F10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VFWSUBWV	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VFWSUBWF	F10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VFMULVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VFMULVF		F10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VFDIVVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VFDIVVF		F10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VFRDIVVF	F10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VFWMULVV	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VFWMULVF	F10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VFMACCVV	V2, V1, V4, V3			// ERROR "invalid vector mask register"
-	VFMACCVF	V2, F10, V4, V3			// ERROR "invalid vector mask register"
-	VFNMACCVV	V2, V1, V4, V3			// ERROR "invalid vector mask register"
-	VFNMACCVF	V2, F10, V4, V3			// ERROR "invalid vector mask register"
-	VFMSACVV	V2, V1, V4, V3			// ERROR "invalid vector mask register"
-	VFMSACVF	V2, F10, V4, V3			// ERROR "invalid vector mask register"
-	VFNMSACVV	V2, V1, V4, V3			// ERROR "invalid vector mask register"
-	VFNMSACVF	V2, F10, V4, V3			// ERROR "invalid vector mask register"
-	VFMADDVV	V2, V1, V4, V3			// ERROR "invalid vector mask register"
-	VFMADDVF	V2, F10, V4, V3			// ERROR "invalid vector mask register"
-	VFNMADDVV	V2, V1, V4, V3			// ERROR "invalid vector mask register"
-	VFNMADDVF	V2, F10, V4, V3			// ERROR "invalid vector mask register"
-	VFMSUBVV	V2, V1, V4, V3			// ERROR "invalid vector mask register"
-	VFMSUBVF	V2, F10, V4, V3			// ERROR "invalid vector mask register"
-	VFNMSUBVV	V2, V1, V4, V3			// ERROR "invalid vector mask register"
-	VFNMSUBVF	V2, F10, V4, V3			// ERROR "invalid vector mask register"
-	VFWMACCVV	V2, V1, V4, V3			// ERROR "invalid vector mask register"
-	VFWMACCVF	V2, F10, V4, V3			// ERROR "invalid vector mask register"
-	VFWNMACCVV	V2, V1, V4, V3			// ERROR "invalid vector mask register"
-	VFWNMACCVF	V2, F10, V4, V3			// ERROR "invalid vector mask register"
-	VFWMSACVV	V2, V1, V4, V3			// ERROR "invalid vector mask register"
-	VFWMSACVF	V2, F10, V4, V3			// ERROR "invalid vector mask register"
-	VFWNMSACVV	V2, V1, V4, V3			// ERROR "invalid vector mask register"
-	VFWNMSACVF	V2, F10, V4, V3			// ERROR "invalid vector mask register"
-	VFSQRTV		V2, V4, V3			// ERROR "invalid vector mask register"
-	VFRSQRT7V	V2, V4, V3			// ERROR "invalid vector mask register"
-	VFREC7V		V2, V4, V3			// ERROR "invalid vector mask register"
-	VFMINVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VFMINVF		F10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VFMAXVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VFMAXVF		F10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VFSGNJVV	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VFSGNJVF	F10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VFSGNJNVV	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VFSGNJNVF	F10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VFSGNJXVV	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VFSGNJXVF	F10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VFNEGV		V2, V4, V3			// ERROR "invalid vector mask register"
-	VFABSV		V2, V4, V3			// ERROR "invalid vector mask register"
-	VMFEQVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMFEQVF		F10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMFNEVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMFNEVF		F10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMFLTVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMFLTVF		F10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMFLEVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMFLEVF		F10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMFGTVF		F10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMFGEVF		F10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMFGTVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VMFGEVV		V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VFMERGEVFM	X10, V2, V3			// ERROR "invalid vector mask register"
-	VFMERGEVFM	F10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VFCVTXUFV	V2, V4, V3			// ERROR "invalid vector mask register"
-	VFCVTXFV	V2, V4, V3			// ERROR "invalid vector mask register"
-	VFCVTRTZXUFV	V2, V4, V3			// ERROR "invalid vector mask register"
-	VFCVTRTZXFV	V2, V4, V3			// ERROR "invalid vector mask register"
-	VFCVTFXUV	V2, V4, V3			// ERROR "invalid vector mask register"
-	VFCVTFXV	V2, V4, V3			// ERROR "invalid vector mask register"
-	VFWCVTXUFV	V2, V4, V3			// ERROR "invalid vector mask register"
-	VFWCVTXFV	V2, V4, V3			// ERROR "invalid vector mask register"
-	VFWCVTRTZXUFV	V2, V4, V3			// ERROR "invalid vector mask register"
-	VFWCVTRTZXFV	V2, V4, V3			// ERROR "invalid vector mask register"
-	VFWCVTFXUV	V2, V4, V3			// ERROR "invalid vector mask register"
-	VFWCVTFXV	V2, V4, V3			// ERROR "invalid vector mask register"
-	VFWCVTFFV	V2, V4, V3			// ERROR "invalid vector mask register"
-	VFNCVTXUFW	V2, V4, V3			// ERROR "invalid vector mask register"
-	VFNCVTXFW	V2, V4, V3			// ERROR "invalid vector mask register"
-	VFNCVTRTZXUFW	V2, V4, V3			// ERROR "invalid vector mask register"
-	VFNCVTRTZXFW	V2, V4, V3			// ERROR "invalid vector mask register"
-	VFNCVTFXUW	V2, V4, V3			// ERROR "invalid vector mask register"
-	VFNCVTFXW	V2, V4, V3			// ERROR "invalid vector mask register"
-	VFNCVTFFW	V2, V4, V3			// ERROR "invalid vector mask register"
-	VFNCVTRODFFW	V2, V4, V3			// ERROR "invalid vector mask register"
-	VREDSUMVS	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VREDMAXUVS	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VREDMAXVS	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VREDMINUVS	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VREDMINVS	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VREDANDVS	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VREDORVS	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VREDXORVS	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VWREDSUMUVS	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VWREDSUMVS	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VFREDOSUMVS	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VFREDUSUMVS	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VFREDMAXVS	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VFREDMINVS	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VFWREDOSUMVS	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VCPOPM		V2, V4, X10			// ERROR "invalid vector mask register"
-	VFIRSTM		V2, V4, X10			// ERROR "invalid vector mask register"
-	VMSBFM		V2, V4, V3			// ERROR "invalid vector mask register"
-	VMSIFM		V2, V4, V3			// ERROR "invalid vector mask register"
-	VMSOFM		V2, V4, V3			// ERROR "invalid vector mask register"
-	VIOTAM		V2, V4, V3			// ERROR "invalid vector mask register"
-	VSLIDEUPVX	X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VSLIDEUPVI	$16, V2, V4, V3			// ERROR "invalid vector mask register"
-	VSLIDEDOWNVX	X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VSLIDEDOWNVI	$16, V2, V4, V3			// ERROR "invalid vector mask register"
-	VSLIDE1UPVX	X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VFSLIDE1UPVF	F10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VSLIDE1DOWNVX	X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VFSLIDE1DOWNVF	F10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VRGATHERVV	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VRGATHEREI16VV	V1, V2, V4, V3			// ERROR "invalid vector mask register"
-	VRGATHERVX	X10, V2, V4, V3			// ERROR "invalid vector mask register"
-	VRGATHERVI	$16, V2, V4, V3			// ERROR "invalid vector mask register"
-
 	RET
--- a/src/cmd/asm/internal/asm/testdata/riscv64validation.s
+++ b/src/cmd/asm/internal/asm/testdata/riscv64validation.s
@@ -1,601 +0,0 @@
-// 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.
-
-// This file is for validation errors only, i.e., errors reported by the validate function.
-// Negative test cases for errors generated earlier in the assembler's preprocess stage
-// should be added to riscv64error.s.  If they are added to this file, they will prevent
-// the validate function from being run and TestRISCVValidation will report missing
-// errors.
-
-TEXT validation(SB),$0
-	SRLI	$1, X5, F1			// ERROR "expected integer register in rd position but got non-integer register F1"
-	SRLI	$1, F1, X5			// ERROR "expected integer register in rs1 position but got non-integer register F1"
-
-	WORD	$-1				// ERROR "must be in range [0x0, 0xffffffff]"
-	WORD	$0x100000000			// ERROR "must be in range [0x0, 0xffffffff]"
-
-	//
-	// "C" Extension for Compressed Instructions, Version 2.0
-	//
-	CLWSP	20(X5), X10				// ERROR "rs2 must be SP/X2"
-	CLWSP	20(SP), X0				// ERROR "cannot use register X0"
-	CLWSP	20(SP), F10				// ERROR "expected integer register in rd position"
-	CLWSP	22(SP), X10				// ERROR "must be a multiple of 4"
-	CLDSP	24(X5), X10				// ERROR "rs2 must be SP/X2"
-	CLDSP	24(SP), X0				// ERROR "cannot use register X0"
-	CLDSP	24(SP), F10				// ERROR "expected integer register in rd position"
-	CLDSP	28(SP), X10				// ERROR "must be a multiple of 8"
-	CFLDSP	32(X5), F10				// ERROR "rs2 must be SP/X2"
-	CFLDSP	32(SP), X10				// ERROR "expected float register in rd position"
-	CFLDSP	36(SP), F10				// ERROR "must be a multiple of 8"
-	CSWSP	X10, 20(X5)				// ERROR "rd must be SP/X2"
-	CSWSP	F10, 20(SP)				// ERROR "expected integer register in rs2 position"
-	CSWSP	X10, 22(SP)				// ERROR "must be a multiple of 4"
-	CSDSP	X10, 24(X5)				// ERROR "rd must be SP/X2"
-	CSDSP	F10, 24(SP)				// ERROR "expected integer register in rs2 position"
-	CSDSP	X10, 28(SP)				// ERROR "must be a multiple of 8"
-	CFSDSP	F10, 32(X5)				// ERROR "rd must be SP/X2"
-	CFSDSP	X10, 32(SP)				// ERROR "expected float register in rs2 position"
-	CFSDSP	F10, 36(SP)				// ERROR "must be a multiple of 8"
-	CLW	20(X10), F11				// ERROR "expected integer prime register in rd position"
-	CLW	20(X5), X11				// ERROR "expected integer prime register in rs1 position"
-	CLW	20(X10), X5				// ERROR "expected integer prime register in rd position"
-	CLW	-1(X10), X11				// ERROR "must be in range [0, 127]"
-	CLW	22(X10), X11				// ERROR "must be a multiple of 4"
-	CLW	128(X10), X11				// ERROR "must be in range [0, 127]"
-	CLD	24(X10), F11				// ERROR "expected integer prime register in rd position"
-	CLD	24(X5), X11				// ERROR "expected integer prime register in rs1 position"
-	CLD	-1(X10), X11				// ERROR "must be in range [0, 255]"
-	CLD	30(X10), X11				// ERROR "must be a multiple of 8"
-	CLD	256(X10), X11				// ERROR "must be in range [0, 255]"
-	CFLD	32(X10), X11				// ERROR "expected float prime register in rd position"
-	CFLD	32(X5), F11				// ERROR "expected integer prime register in rs1 position"
-	CFLD	-1(X10), F11				// ERROR "must be in range [0, 255]"
-	CFLD	34(X10), F11				// ERROR "must be a multiple of 8"
-	CFLD	256(X10), F11				// ERROR "must be in range [0, 255]"
-	CSW	F11, 20(X10)				// ERROR "expected integer prime register in rs2 position"
-	CSW	X11, -1(X10)				// ERROR "must be in range [0, 127]"
-	CSW	X11, 22(X10)				// ERROR "must be a multiple of 4"
-	CSW	X11, 128(X10)				// ERROR "must be in range [0, 127]"
-	CSD	F11, 24(X10)				// ERROR "expected integer prime register in rs2 position"
-	CSD	X11, -1(X10)				// ERROR "must be in range [0, 255]"
-	CSD	X11, 28(X10)				// ERROR "must be a multiple of 8"
-	CSD	X11, 256(X10)				// ERROR "must be in range [0, 255]"
-	CFSD	X11, 32(X10)				// ERROR "expected float prime register in rs2 position"
-	CFSD	F11, -1(X10)				// ERROR "must be in range [0, 255]"
-	CFSD	F11, 36(X10)				// ERROR "must be a multiple of 8"
-	CFSD	F11, 256(X10)				// ERROR "must be in range [0, 255]"
-	CJR	X0					// ERROR "cannot use register X0 in rs1"
-	CJR	X10, X11				// ERROR "expected no register in rs2"
-	CJALR	X0					// ERROR "cannot use register X0 in rs1"
-	CJALR	X10, X11				// ERROR "expected no register in rd"
-	CBEQZ	X5, 1(PC)				// ERROR "expected integer prime register in rs1"
-	CBNEZ	X5, 1(PC)				// ERROR "expected integer prime register in rs1"
-	CLI	$3, X0					// ERROR "cannot use register X0 in rd"
-	CLI	$-33, X5				// ERROR "must be in range [-32, 31]"
-	CLI	$32, X5					// ERROR "must be in range [-32, 31]"
-	CLUI	$0, X5					// ERROR "immediate cannot be zero"
-	CLUI	$3, X0					// ERROR "cannot use register X0 in rd"
-	CLUI	$3, X2					// ERROR "cannot use register SP/X2 in rd"
-	CLUI	$-33, X5				// ERROR "must be in range [-32, 31]"
-	CLUI	$32, X5					// ERROR "must be in range [-32, 31]"
-	CADD	$31, X5, X6				// ERROR "rd must be the same as rs1"
-	CADD	$-33, X5				// ERROR "must be in range [-32, 31]"
-	CADD	$32, X5					// ERROR "must be in range [-32, 31]"
-	CADDI	$0, X5					// ERROR "immediate cannot be zero"
-	CADDI	$31, X5, X6				// ERROR "rd must be the same as rs1"
-	CADDI	$-33, X5				// ERROR "must be in range [-32, 31]"
-	CADDI	$32, X5					// ERROR "must be in range [-32, 31]"
-	CADDW	$-33, X5				// ERROR "must be in range [-32, 31]"
-	CADDW	$32, X5					// ERROR "must be in range [-32, 31]"
-	CADDIW	$-33, X5				// ERROR "must be in range [-32, 31]"
-	CADDIW	$32, X5					// ERROR "must be in range [-32, 31]"
-	CADDI16SP $0, SP				// ERROR "immediate cannot be zero"
-	CADDI16SP $16, X5				// ERROR "rd must be SP/X2"
-	CADDI16SP $-513, SP				// ERROR "must be in range [-512, 511]"
-	CADDI16SP $20, SP				// ERROR "must be a multiple of 16"
-	CADDI16SP $512, SP				// ERROR "must be in range [-512, 511]"
-	CADDI4SPN $4, SP, X5				// ERROR "expected integer prime register in rd"
-	CADDI4SPN $4, X5, X10				// ERROR "SP/X2 must be in rs1"
-	CADDI4SPN $-1, SP, X10				// ERROR "must be in range [0, 1023]"
-	CADDI4SPN $0, SP, X10				// ERROR "immediate cannot be zero"
-	CADDI4SPN $6, SP, X10				// ERROR "must be a multiple of 4"
-	CADDI4SPN $1024, SP, X10			// ERROR "must be in range [0, 1023]"
-	CSLLI	$63, X5, X6				// ERROR "rd must be the same as rs1"
-	CSLLI	$-1, X5					// ERROR "must be in range [0, 63]"
-	CSLLI	$0, X5					// ERROR "immediate cannot be zero"
-	CSLLI	$64, X5					// ERROR "must be in range [0, 63]"
-	CSRLI	$63, X10, X11				// ERROR "rd must be the same as rs1"
-	CSRLI	$63, X5					// ERROR "expected integer prime register in rd"
-	CSRLI	$-1, X10				// ERROR "must be in range [0, 63]"
-	CSRLI	$0, X10					// ERROR "immediate cannot be zero"
-	CSRLI	$64, X10				// ERROR "must be in range [0, 63]"
-	CSRAI	$63, X10, X11				// ERROR "rd must be the same as rs1"
-	CSRAI	$63, X5					// ERROR "expected integer prime register in rd"
-	CSRAI	$-1, X10				// ERROR "must be in range [0, 63]"
-	CSRAI	$0, X10					// ERROR "immediate cannot be zero"
-	CSRAI	$64, X10				// ERROR "must be in range [0, 63]"
-	CAND	$1, X10, X11				// ERROR "rd must be the same as rs1"
-	CAND	$1, X5					// ERROR "expected integer prime register in rd"
-	CAND	$-64, X10				// ERROR "must be in range [-32, 31]"
-	CAND	$63, X10				// ERROR "must be in range [-32, 31]"
-	CANDI	$1, X10, X11				// ERROR "rd must be the same as rs1"
-	CANDI	$1, X5					// ERROR "expected integer prime register in rd"
-	CANDI	$-64, X10				// ERROR "must be in range [-32, 31]"
-	CANDI	$63, X10				// ERROR "must be in range [-32, 31]"
-	CMV	X0, X5					// ERROR "cannot use register X0 in rs2"
-	CMV	X5, X6, X7				// ERROR "expected no register in rs1"
-	CMV	X5, X0					// ERROR "cannot use register X0 in rd"
-	CMV	F1, X5					// ERROR "expected integer register in rs2"
-	CMV	X5, F1					// ERROR "expected integer register in rd"
-	CADD	X5, X6, X7				// ERROR "rd must be the same as rs1"
-	CADD	X0, X8					// ERROR "cannot use register X0 in rs2"
-	CADD	X8, X0					// ERROR "cannot use register X0 in rd"
-	CAND	X10, X11, X12				// ERROR "rd must be the same as rs1"
-	CAND	X5, X11					// ERROR "expected integer prime register in rs2"
-	CAND	X10, X5					// ERROR "expected integer prime register in rd"
-	COR	X10, X11, X12				// ERROR "rd must be the same as rs1"
-	COR	X5, X11					// ERROR "expected integer prime register in rs2"
-	COR	X10, X5					// ERROR "expected integer prime register in rd"
-	CXOR	X10, X11, X12				// ERROR "rd must be the same as rs1"
-	CXOR	X5, X11					// ERROR "expected integer prime register in rs2"
-	CXOR	X10, X5					// ERROR "expected integer prime register in rd"
-	CSUB	X10, X11, X12				// ERROR "rd must be the same as rs1"
-	CSUB	X5, X11					// ERROR "expected integer prime register in rs2"
-	CSUB	X10, X5					// ERROR "expected integer prime register in rd"
-	CADDW	X10, X11, X12				// ERROR "rd must be the same as rs1"
-	CADDW	X5, X11					// ERROR "expected integer prime register in rs2"
-	CADDW	X10, X5					// ERROR "expected integer prime register in rd"
-	CSUBW	X10, X11, X12				// ERROR "rd must be the same as rs1"
-	CSUBW	X5, X11					// ERROR "expected integer prime register in rs2"
-	CSUBW	X10, X5					// ERROR "expected integer prime register in rd"
-	CNOP	X10					// ERROR "expected no register in rs2"
-	CEBREAK	X10					// ERROR "expected no register in rs2"
-
-	//
-	// "V" Standard Extension for Vector Operations, Version 1.0
-	//
-	VSETVLI		$32, E16, M1, TU, MU, X12	// ERROR "must be in range [0, 31] (5 bits)"
-	VSETVLI		$-1, E32, M2, TA, MA, X12	// ERROR "must be in range [0, 31] (5 bits)"
-	VSETVL		X10, X11			// ERROR "expected integer register in rs1 position"
-	VLE8V		(X10), X10			// ERROR "expected vector register in vd position"
-	VLE8V		(V1), V3			// ERROR "expected integer register in rs1 position"
-	VLE8FFV		(X10), X10			// ERROR "expected vector register in vd position"
-	VLE8FFV		(V1), V3			// ERROR "expected integer register in rs1 position"
-	VSE8V		X10, (X10)			// ERROR "expected vector register in vs1 position"
-	VSE8V		V3, (V1)			// ERROR "expected integer register in rd position"
-	VLSE8V		(X10), V3			// ERROR "expected integer register in rs2 position"
-	VLSE8V		(X10), X10, X11			// ERROR "expected vector register in vd position"
-	VLSE8V		(V1), X10, V3			// ERROR "expected integer register in rs1 position"
-	VLSE8V		(X10), V1, V0, V3		// ERROR "expected integer register in rs2 position"
-	VSSE8V		V3, (X10)			// ERROR "expected integer register in rs2 position"
-	VSSE8V		X10, X11, (X10)			// ERROR "expected vector register in vd position"
-	VSSE8V		V3, X11, (V1)			// ERROR "expected integer register in rs1 position"
-	VSSE8V		V3, V1, V0, (X10)		// ERROR "expected integer register in rs2 position"
-	VLUXEI8V	(X10), V2, X11			// ERROR "expected vector register in vd position"
-	VLUXEI8V	(X10), V2, X11			// ERROR "expected vector register in vd position"
-	VLUXEI8V	(V1), V2, V3			// ERROR "expected integer register in rs1 position"
-	VLUXEI8V	(X10), X11, V0, V3		// ERROR "expected vector register in vs2 position"
-	VSUXEI8V	X10, V2, (X10)			// ERROR "expected vector register in vd position"
-	VSUXEI8V	V3, V2, (V1)			// ERROR "expected integer register in rs1 position"
-	VSUXEI8V	V3, X11, V0, (X10)		// ERROR "expected vector register in vs2 position"
-	VLOXEI8V	(X10), V2, X11			// ERROR "expected vector register in vd position"
-	VLOXEI8V	(V1), V2, V3			// ERROR "expected integer register in rs1 position"
-	VLOXEI8V	(X10), X11, V0, V3		// ERROR "expected vector register in vs2 position"
-	VSOXEI8V	X10, V2, (X10)			// ERROR "expected vector register in vd position"
-	VSOXEI8V	V3, V2, (V1)			// ERROR "expected integer register in rs1 position"
-	VSOXEI8V	V3, X11, V0, (X10)		// ERROR "expected vector register in vs2 position"
-	VLSEG2E8V	(X10), X10			// ERROR "expected vector register in vd position"
-	VLSEG2E8V	(V1), V3			// ERROR "expected integer register in rs1 position"
-	VLSEG2E8FFV	(X10), X10			// ERROR "expected vector register in vd position"
-	VLSEG2E8FFV	(V1), V3			// ERROR "expected integer register in rs1 position"
-	VSSEG2E8V	X10, (X10)			// ERROR "expected vector register in vs1 position"
-	VSSEG2E8V	V3, (V1)			// ERROR "expected integer register in rd position"
-	VLSSEG2E8V	(X10), V3			// ERROR "expected integer register in rs2 position"
-	VLSSEG2E8V	(X10), X10, X11			// ERROR "expected vector register in vd position"
-	VLSSEG2E8V	(V1), X10, V3			// ERROR "expected integer register in rs1 position"
-	VLSSEG2E8V	(X10), V1, V0, V3		// ERROR "expected integer register in rs2 position"
-	VSSSEG2E8V	V3, (X10)			// ERROR "expected integer register in rs2 position"
-	VSSSEG2E8V	X10, X11, (X10)			// ERROR "expected vector register in vd position"
-	VSSSEG2E8V	V3, X11, (V1)			// ERROR "expected integer register in rs1 position"
-	VSSSEG2E8V	V3, V1, V0, (X10)		// ERROR "expected integer register in rs2 position"
-	VLUXSEG2EI8V	(X10), V2, X11			// ERROR "expected vector register in vd position"
-	VLUXSEG2EI8V	(X10), V2, X11			// ERROR "expected vector register in vd position"
-	VLUXSEG2EI8V	(V1), V2, V3			// ERROR "expected integer register in rs1 position"
-	VLUXSEG2EI8V	(X10), X11, V0, V3		// ERROR "expected vector register in vs2 position"
-	VSUXSEG2EI8V	X10, V2, (X10)			// ERROR "expected vector register in vd position"
-	VSUXSEG2EI8V	V3, V2, (V1)			// ERROR "expected integer register in rs1 position"
-	VSUXSEG2EI8V	V3, X11, V0, (X10)		// ERROR "expected vector register in vs2 position"
-	VLOXSEG2EI8V	(X10), V2, X11			// ERROR "expected vector register in vd position"
-	VLOXSEG2EI8V	(V1), V2, V3			// ERROR "expected integer register in rs1 position"
-	VLOXSEG2EI8V	(X10), X11, V0, V3		// ERROR "expected vector register in vs2 position"
-	VSOXSEG2EI8V	X10, V2, (X10)			// ERROR "expected vector register in vd position"
-	VSOXSEG2EI8V	V3, V2, (V1)			// ERROR "expected integer register in rs1 position"
-	VSOXSEG2EI8V	V3, X11, V0, (X10)		// ERROR "expected vector register in vs2 position"
-	VL1RV		(X10), X10			// ERROR "expected vector register in vd position"
-	VL1RV		(V1), V3			// ERROR "expected integer register in rs1 position"
-	VS1RV		X11, (X11)			// ERROR "expected vector register in vs1 position"
-	VS1RV		V3, (V1)			// ERROR "expected integer register in rd position"
-	VADDVV		V1, X10, V3			// ERROR "expected vector register in vs2 position"
-	VADDVX		V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VADDVI		$16, V4, V2			// ERROR "signed immediate 16 must be in range [-16, 15] (5 bits)"
-	VADDVI		$-17, V4, V2			// ERROR "signed immediate -17 must be in range [-16, 15] (5 bits)"
-	VSUBVV		V1, X10, V3			// ERROR "expected vector register in vs2 position"
-	VSUBVX		V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VRSUBVX		V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VRSUBVI		$16, V4, V2			// ERROR "signed immediate 16 must be in range [-16, 15] (5 bits)"
-	VRSUBVI		$-17, V4, V2			// ERROR "signed immediate -17 must be in range [-16, 15] (5 bits)"
-	VNEGV		X10, V3				// ERROR "expected vector register in vs2 position"
-	VNEGV		V2				// ERROR "expected vector register in vd position"
-	VWADDUVV	X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VWADDUVX	V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VWSUBUVV	X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VWSUBUVX	V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VWADDVV		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VWADDVX		V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VWSUBVV		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VWSUBVX		V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VWADDUWV	X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VWADDUWX	V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VWSUBUWV	X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VWSUBUWX	V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VWADDWV		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VWADDWX		V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VWSUBWV		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VWSUBWX		V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VWCVTXXV	X10, V3				// ERROR "expected vector register in vs2 position"
-	VWCVTUXXV	X10, V3				// ERROR "expected vector register in vs2 position"
-	VZEXTVF2	V2, V0, V3, V4			// ERROR "expected no register in rs3"
-	VZEXTVF2	X10, V3				// ERROR "expected vector register in vs2 position"
-	VSEXTVF2	V2, V0, V3, V4			// ERROR "expected no register in rs3"
-	VSEXTVF2	X10, V3				// ERROR "expected vector register in vs2 position"
-	VZEXTVF4	V2, V0, V3, V4			// ERROR "expected no register in rs3"
-	VZEXTVF4	X10, V3				// ERROR "expected vector register in vs2 position"
-	VSEXTVF4	V2, V0, V3, V4			// ERROR "expected no register in rs3"
-	VSEXTVF4	X10, V3				// ERROR "expected vector register in vs2 position"
-	VZEXTVF8	V2, V0, V3, V4			// ERROR "expected no register in rs3"
-	VZEXTVF8	X10, V3				// ERROR "expected vector register in vs2 position"
-	VSEXTVF8	V2, V0, V3, V4			// ERROR "expected no register in rs3"
-	VSEXTVF8	X10, V3				// ERROR "expected vector register in vs2 position"
-	VADCVVM		X10, V2, V0, V3			// ERROR "expected vector register in vs1 position"
-	VADCVXM		V1, V2, V0, V3			// ERROR "expected integer register in rs1 position"
-	VADCVIM		$16, V2, V0, V3			// ERROR "signed immediate 16 must be in range [-16, 15]"
-	VADCVIM		$-17, V2, V0, V3		// ERROR "signed immediate -17 must be in range [-16, 15]"
-	VMADCVVM	X10, V2, V0, V3			// ERROR "expected vector register in vs1 position"
-	VMADCVXM	V1, V2, V0, V3			// ERROR "expected integer register in rs1 position"
-	VMADCVIM	$16, V2, V0, V3			// ERROR "signed immediate 16 must be in range [-16, 15]"
-	VMADCVIM	$-17, V2, V0, V3		// ERROR "signed immediate -17 must be in range [-16, 15]"
-	VMADCVV		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VMADCVV		V1, V2, V0, V3			// ERROR "expected no register in rs3"
-	VMADCVX		V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VMADCVX		X10, V2, V0, V3			// ERROR "expected no register in rs3"
-	VMADCVI		$16, V2, V3			// ERROR "signed immediate 16 must be in range [-16, 15]"
-	VMADCVI		$-17, V2, V3			// ERROR "signed immediate -17 must be in range [-16, 15]"
-	VMADCVI		$15, V2, V0, V3			// ERROR "expected no register in rs3"
-	VSBCVVM		X10, V2, V0, V3			// ERROR "expected vector register in vs1 position"
-	VSBCVXM		V1, V2, V0, V3			// ERROR "expected integer register in rs1 position"
-	VMSBCVVM	X10, V2, V0, V3			// ERROR "expected vector register in vs1 position"
-	VMSBCVXM	V1, V2, V0, V3			// ERROR "expected integer register in rs1 position"
-	VMSBCVV		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VMSBCVV		V1, V2, V0, V3			// ERROR "expected no register in rs3"
-	VMSBCVX		V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VMSBCVX		X10, V2, V0, V3			// ERROR "expected no register in rs3"
-	VANDVV		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VANDVX		V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VANDVI		$16, V2, V3			// ERROR "signed immediate 16 must be in range [-16, 15]"
-	VANDVI		$-17, V2, V3			// ERROR "signed immediate -17 must be in range [-16, 15]"
-	VORVV		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VORVX		V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VORVI		$16, V2, V3			// ERROR "signed immediate 16 must be in range [-16, 15]"
-	VORVI		$-17, V2, V3			// ERROR "signed immediate -17 must be in range [-16, 15]"
-	VXORVV		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VXORVX		V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VXORVI		$16, V2, V3			// ERROR "signed immediate 16 must be in range [-16, 15]"
-	VXORVI		$-17, V2, V3			// ERROR "signed immediate -17 must be in range [-16, 15]"
-	VNOTV		V3				// ERROR "expected vector register in vd position"
-	VNOTV		X10, V3				// ERROR "expected vector register in vs2 position"
-	VSLLVV		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VSLLVX		V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VSLLVI		$32, V2, V3			// ERROR "unsigned immediate 32 must be in range [0, 31]"
-	VSLLVI		$-1, V2, V3			// ERROR "unsigned immediate -1 must be in range [0, 31]"
-	VSRLVV		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VSRLVX		V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VSRLVI		$32, V2, V3			// ERROR "unsigned immediate 32 must be in range [0, 31]"
-	VSRLVI		$-1, V2, V3			// ERROR "unsigned immediate -1 must be in range [0, 31]"
-	VSRAVV		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VSRAVX		V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VSRAVI		$32, V2, V3			// ERROR "unsigned immediate 32 must be in range [0, 31]"
-	VSRAVI		$-1, V2, V3			// ERROR "unsigned immediate -1 must be in range [0, 31]"
-	VNSRLWV		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VNSRLWX		V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VNSRLWI		$32, V2, V3			// ERROR "unsigned immediate 32 must be in range [0, 31]"
-	VNSRLWI		$-1, V2, V3			// ERROR "unsigned immediate -1 must be in range [0, 31]"
-	VNSRAWV		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VNSRAWX		V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VNSRAWI		$32, V2, V3			// ERROR "unsigned immediate 32 must be in range [0, 31]"
-	VNSRAWI		$-1, V2, V3			// ERROR "unsigned immediate -1 must be in range [0, 31]"
-	VNCVTXXW	X10, V3				// ERROR "expected vector register in vs2 position"
-	VMSEQVV		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VMSEQVX		V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VMSEQVI		$16, V2, V3			// ERROR "signed immediate 16 must be in range [-16, 15]"
-	VMSEQVI		$-17, V2, V3			// ERROR "signed immediate -17 must be in range [-16, 15]"
-	VMSNEVV		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VMSNEVX		V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VMSNEVI		$16, V2, V3			// ERROR "signed immediate 16 must be in range [-16, 15]"
-	VMSNEVI		$-17, V2, V3			// ERROR "signed immediate -17 must be in range [-16, 15]"
-	VMSLTUVV	X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VMSLTUVX	V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VMSLTVV		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VMSLTVX		V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VMSLEUVV	X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VMSLEUVX	V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VMSLEUVI	$16, V2, V3			// ERROR "signed immediate 16 must be in range [-16, 15]"
-	VMSLEUVI	$-17, V2, V3			// ERROR "signed immediate -17 must be in range [-16, 15]"
-	VMSLEVV		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VMSLEVX		V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VMSLEVI		$16, V2, V3			// ERROR "signed immediate 16 must be in range [-16, 15]"
-	VMSLEVI		$-17, V2, V3			// ERROR "signed immediate -17 must be in range [-16, 15]"
-	VMSGTUVV	X10, V2, V3			// ERROR "expected vector register in vs2 position"
-	VMSGTUVX	V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VMSGTUVI	$16, V2, V3			// ERROR "signed immediate 16 must be in range [-16, 15]"
-	VMSGTUVI	$-17, V2, V3			// ERROR "signed immediate -17 must be in range [-16, 15]"
-	VMSGTVV		X10, V2, V3			// ERROR "expected vector register in vs2 position"
-	VMSGTVX		V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VMSGTVI		$16, V2, V3			// ERROR "signed immediate 16 must be in range [-16, 15]"
-	VMSGTVI		$-17, V2, V3			// ERROR "signed immediate -17 must be in range [-16, 15]"
-	VMSGEVV		X10, V2, V3			// ERROR "expected vector register in vs2 position"
-	VMSGEUVV	X10, V2, V3			// ERROR "expected vector register in vs2 position"
-	VMSLTVI		$17, V2, V3			// ERROR "signed immediate 16 must be in range [-16, 15]"
-	VMSLTVI		$-16, V2, V3			// ERROR "signed immediate -17 must be in range [-16, 15]"
-	VMSLTUVI	$17, V2, V3			// ERROR "signed immediate 16 must be in range [-16, 15]"
-	VMSLTUVI	$-16, V2, V3			// ERROR "signed immediate -17 must be in range [-16, 15]"
-	VMSGEVI		$17, V2, V3			// ERROR "signed immediate 16 must be in range [-16, 15]"
-	VMSGEVI		$-16, V2, V3			// ERROR "signed immediate -17 must be in range [-16, 15]"
-	VMSGEUVI	$17, V2, V3			// ERROR "signed immediate 16 must be in range [-16, 15]"
-	VMSGEUVI	$-16, V2, V3			// ERROR "signed immediate -17 must be in range [-16, 15]"
-	VMINUVV		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VMINUVX		V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VMINVV		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VMINVX		V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VMAXUVV		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VMAXUVX		V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VMAXVV		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VMAXVX		V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VMULVV		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VMULVX		V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VMULHVV		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VMULHVX		V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VMULHUVV	X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VMULHUVX	V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VMULHSUVV	X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VMULHSUVX	V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VDIVUVV		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VDIVUVX		V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VDIVVV		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VDIVVX		V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VREMUVV		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VREMUVX		V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VREMVV		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VREMVX		V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VWMULVV		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VWMULVX		V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VWMULUVV	X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VWMULUVX	V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VWMULSUVV	X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VWMULSUVX	V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VMACCVV		V2, X10, V3			// ERROR "expected vector register in vs1 position"
-	VMACCVX		V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VNMSACVV	V2, X10, V3			// ERROR "expected vector register in vs1 position"
-	VNMSACVX	V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VMADDVV		V2, X10, V3			// ERROR "expected vector register in vs1 position"
-	VMADDVX		V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VNMSUBVV	V2, X10, V3			// ERROR "expected vector register in vs1 position"
-	VNMSUBVX	V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VWMACCUVV	V2, X10, V3			// ERROR "expected vector register in vs1 position"
-	VWMACCUVX	V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VWMACCVV	V2, X10, V3			// ERROR "expected vector register in vs1 position"
-	VWMACCVX	V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VWMACCSUVV	V2, X10, V3			// ERROR "expected vector register in vs1 position"
-	VWMACCSUVX	V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VWMACCUSVX	V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VMERGEVVM	X10, V2, V0, V3			// ERROR "expected vector register in vs1 position"
-	VMERGEVXM	V1, V2, V0, V3			// ERROR "expected integer register in rs1 position"
-	VMERGEVIM	$16, V2, V0, V3			// ERROR "signed immediate 16 must be in range [-16, 15]"
-	VMERGEVIM	$-17, V2, V0, V3		// ERROR "signed immediate -17 must be in range [-16, 15]"
-	VMVVV		X10, V3				// ERROR "expected vector register in vs1 position"
-	VMVVX		V1, V2				// ERROR "expected integer register in rs1 position"
-	VMVVI		$16, V2				// ERROR "signed immediate 16 must be in range [-16, 15]"
-	VMVVI		$-17, V2			// ERROR "signed immediate -17 must be in range [-16, 15]"
-	VSADDUVV	X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VSADDUVX	V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VSADDUVI	$16, V2, V3			// ERROR "signed immediate 16 must be in range [-16, 15]"
-	VSADDUVI	$-17, V2, V3			// ERROR "signed immediate -17 must be in range [-16, 15]"
-	VSSUBUVV	X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VSSUBUVX	V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VAADDUVV	X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VAADDUVX	V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VAADDVV		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VAADDVX		V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VASUBUVV	X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VASUBUVX	V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VASUBVV		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VASUBVX		V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VSMULVV		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VSMULVX		V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VSSRLVV		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VSSRLVX		V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VSSRLVI		$32, V2, V3			// ERROR "signed immediate 32 must be in range [0, 31]"
-	VSSRLVI		$-1, V2, V3			// ERROR "signed immediate -1 must be in range [0, 31]"
-	VSSRAVV		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VSSRAVX		V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VSSRAVI		$32, V2, V3			// ERROR "signed immediate 32 must be in range [0, 31]"
-	VSSRAVI		$-1, V2, V3			// ERROR "signed immediate -1 must be in range [0, 31]"
-	VNCLIPUWV	X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VNCLIPUWX	V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VNCLIPUWI	$32, V2, V3			// ERROR "signed immediate 32 must be in range [0, 31]"
-	VNCLIPUWI	$-1, V2, V3			// ERROR "signed immediate -1 must be in range [0, 31]"
-	VNCLIPWV	X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VNCLIPWX	V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VNCLIPWI	$32, V2, V3			// ERROR "signed immediate 32 must be in range [0, 31]"
-	VNCLIPWI	$-1, V2, V3			// ERROR "signed immediate -1 must be in range [0, 31]"
-	VFADDVV		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VFADDVF		X10, V2, V3			// ERROR "expected float register in rs1 position"
-	VFSUBVV		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VFSUBVF		X10, V2, V3			// ERROR "expected float register in rs1 position"
-	VFRSUBVF	X10, V2, V3			// ERROR "expected float register in rs1 position"
-	VFWADDVV	X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VFWADDVF	X10, V2, V3			// ERROR "expected float register in rs1 position"
-	VFWSUBVV	X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VFWSUBVF	X10, V2, V3			// ERROR "expected float register in rs1 position"
-	VFWADDWV	X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VFWADDWF	X10, V2, V3			// ERROR "expected float register in rs1 position"
-	VFWSUBWV	X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VFWSUBWF	X10, V2, V3			// ERROR "expected float register in rs1 position"
-	VFMULVV		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VFMULVF		X10, V2, V3			// ERROR "expected float register in rs1 position"
-	VFDIVVV		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VFDIVVF		X10, V2, V3			// ERROR "expected float register in rs1 position"
-	VFRDIVVF	X10, V2, V3			// ERROR "expected float register in rs1 position"
-	VFWMULVV	X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VFWMULVF	X10, V2, V3			// ERROR "expected float register in rs1 position"
-	VFMACCVV	V2, X10, V3			// ERROR "expected vector register in vs1 position"
-	VFMACCVF	V2, X10, V3			// ERROR "expected float register in rs1 position"
-	VFNMACCVV	V2, X10, V3			// ERROR "expected vector register in vs1 position"
-	VFNMACCVF	V2, X10, V3			// ERROR "expected float register in rs1 position"
-	VFMSACVV	V2, X10, V3			// ERROR "expected vector register in vs1 position"
-	VFMSACVF	V2, X10, V3			// ERROR "expected float register in rs1 position"
-	VFNMSACVV	V2, X10, V3			// ERROR "expected vector register in vs1 position"
-	VFNMSACVF	V2, X10, V3			// ERROR "expected float register in rs1 position"
-	VFMADDVV	V2, X10, V3			// ERROR "expected vector register in vs1 position"
-	VFMADDVF	V2, X10, V3			// ERROR "expected float register in rs1 position"
-	VFNMADDVV	V2, X10, V3			// ERROR "expected vector register in vs1 position"
-	VFNMADDVF	V2, X10, V3			// ERROR "expected float register in rs1 position"
-	VFMSUBVV	V2, X10, V3			// ERROR "expected vector register in vs1 position"
-	VFMSUBVF	V2, X10, V3			// ERROR "expected float register in rs1 position"
-	VFNMSUBVV	V2, X10, V3			// ERROR "expected vector register in vs1 position"
-	VFNMSUBVF	V2, X10, V3			// ERROR "expected float register in rs1 position"
-	VFWMACCVV	V2, X10, V3			// ERROR "expected vector register in vs1 position"
-	VFWMACCVF	V2, X10, V3			// ERROR "expected float register in rs1 position"
-	VFWNMACCVV	V2, X10, V3			// ERROR "expected vector register in vs1 position"
-	VFWNMACCVF	V2, X10, V3			// ERROR "expected float register in rs1 position"
-	VFWMSACVV	V2, X10, V3			// ERROR "expected vector register in vs1 position"
-	VFWMSACVF	V2, X10, V3			// ERROR "expected float register in rs1 position"
-	VFWNMSACVV	V2, X10, V3			// ERROR "expected vector register in vs1 position"
-	VFWNMSACVF	V2, X10, V3			// ERROR "expected float register in rs1 position"
-	VFSQRTV		X10, V3				// ERROR "expected vector register in vs2 position"
-	VFRSQRT7V	X10, V3				// ERROR "expected vector register in vs2 position"
-	VFREC7V		X10, V3				// ERROR "expected vector register in vs2 position"
-	VFMINVV		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VFMINVF		X10, V2, V3			// ERROR "expected float register in rs1 position"
-	VFMAXVV		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VFMAXVF		X10, V2, V3			// ERROR "expected float register in rs1 position"
-	VFSGNJVV	X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VFSGNJVF	X10, V2, V3			// ERROR "expected float register in rs1 position"
-	VFSGNJNVV	X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VFSGNJNVF	X10, V2, V3			// ERROR "expected float register in rs1 position"
-	VFSGNJXVV	X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VFSGNJXVF	X10, V2, V3			// ERROR "expected float register in rs1 position"
-	VFNEGV		V2, X10				// ERROR "expected vector register in vd position"
-	VFABSV		V2, X10				// ERROR "expected vector register in vd position"
-	VMFEQVV		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VMFEQVF		X10, V2, V3			// ERROR "expected float register in rs1 position"
-	VMFNEVV		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VMFNEVF		X10, V2, V3			// ERROR "expected float register in rs1 position"
-	VMFLTVV		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VMFLTVF		X10, V2, V3			// ERROR "expected float register in rs1 position"
-	VMFLEVV		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VMFLEVF		X10, V2, V3			// ERROR "expected float register in rs1 position"
-	VMFGTVF		X10, V2, V3			// ERROR "expected float register in rs1 position"
-	VMFGEVF		X10, V2, V3			// ERROR "expected float register in rs1 position"
-	VMFGTVV		X10, V2, V3			// ERROR "expected vector register in vs2 position"
-	VMFGEVV		X10, V2, V3			// ERROR "expected vector register in vs2 position"
-	VFCLASSV	X10, V3				// ERROR "expected vector register in vs2 position"
-	VFMERGEVFM	X10, V2, V0, V3			// ERROR "expected float register in rs1 position"
-	VFMVVF		X10, V3				// ERROR "expected float register in rs1 position"
-	VFCVTXUFV	X10, V3				// ERROR "expected vector register in vs2 position"
-	VFCVTXFV	X10, V3				// ERROR "expected vector register in vs2 position"
-	VFCVTRTZXUFV	X10, V3				// ERROR "expected vector register in vs2 position"
-	VFCVTRTZXFV	X10, V3				// ERROR "expected vector register in vs2 position"
-	VFCVTFXUV	X10, V3				// ERROR "expected vector register in vs2 position"
-	VFCVTFXV	X10, V3				// ERROR "expected vector register in vs2 position"
-	VFWCVTXUFV	X10, V3				// ERROR "expected vector register in vs2 position"
-	VFWCVTXFV	X10, V3				// ERROR "expected vector register in vs2 position"
-	VFWCVTRTZXUFV	X10, V3				// ERROR "expected vector register in vs2 position"
-	VFWCVTRTZXFV	X10, V3				// ERROR "expected vector register in vs2 position"
-	VFWCVTFXUV	X10, V3				// ERROR "expected vector register in vs2 position"
-	VFWCVTFXV	X10, V3				// ERROR "expected vector register in vs2 position"
-	VFWCVTFFV	X10, V3				// ERROR "expected vector register in vs2 position"
-	VFNCVTXUFW	X10, V3				// ERROR "expected vector register in vs2 position"
-	VFNCVTXFW	X10, V3				// ERROR "expected vector register in vs2 position"
-	VFNCVTRTZXUFW	X10, V3				// ERROR "expected vector register in vs2 position"
-	VFNCVTRTZXFW	X10, V3				// ERROR "expected vector register in vs2 position"
-	VFNCVTFXUW	X10, V3				// ERROR "expected vector register in vs2 position"
-	VFNCVTFXW	X10, V3				// ERROR "expected vector register in vs2 position"
-	VFNCVTFFW	X10, V3				// ERROR "expected vector register in vs2 position"
-	VFNCVTRODFFW	X10, V3				// ERROR "expected vector register in vs2 position"
-	VREDSUMVS	X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VREDMAXUVS	X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VREDMAXVS	X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VREDMINUVS	X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VREDMINVS	X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VREDANDVS	X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VREDORVS	X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VREDXORVS	X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VWREDSUMUVS	X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VWREDSUMVS	X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VFREDOSUMVS	X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VFREDUSUMVS	X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VFREDMAXVS	X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VFREDMINVS	X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VFWREDOSUMVS	X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VFWREDUSUMVS	X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VMANDMM		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VMNANDMM	X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VMANDNMM	X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VMXORMM		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VMORMM		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VMNORMM		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VMORNMM		X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VMXNORMM	X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VMMVM		V3, X10				// ERROR "expected vector register in vd position"
-	VMNOTM		V3, X10				// ERROR "expected vector register in vd position"
-	VCPOPM		V2, V1				// ERROR "expected integer register in rd position"
-	VCPOPM		X11, X10			// ERROR "expected vector register in vs2 position"
-	VFIRSTM		V2, V1				// ERROR "expected integer register in rd position"
-	VFIRSTM		X11, X10			// ERROR "expected vector register in vs2 position"
-	VMSBFM		X10, V3				// ERROR "expected vector register in vs2 position"
-	VMSIFM		X10, V3				// ERROR "expected vector register in vs2 position"
-	VMSOFM		X10, V3				// ERROR "expected vector register in vs2 position"
-	VIOTAM		X10, V3				// ERROR "expected vector register in vs2 position"
-	VIDV		X10				// ERROR "expected vector register in vd position"
-	VMVXS		X11, X10			// ERROR "expected vector register in vs2 position"
-	VMVXS		V2, V1				// ERROR "expected integer register in rd position"
-	VMVSX		X11, X10			// ERROR "expected vector register in vd position"
-	VMVSX		V2, V1				// ERROR "expected integer register in rs2 position"
-	VFMVFS		X10, F10			// ERROR "expected vector register in vs2 position"
-	VFMVFS		V2, V1				// ERROR "expected float register in rd position"
-	VFMVSF		X10, V2				// ERROR "expected float register in rs2 position"
-	VFMVSF		V2, V1				// ERROR "expected float register in rs2 position"
-	VSLIDEUPVX	V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VSLIDEUPVI	$-1, V2, V3			// ERROR "unsigned immediate -1 must be in range [0, 31]"
-	VSLIDEUPVI	$32, V2, V3			// ERROR "unsigned immediate 32 must be in range [0, 31]"
-	VSLIDEDOWNVX	V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VSLIDEDOWNVI	$-1, V2, V3			// ERROR "unsigned immediate -1 must be in range [0, 31]"
-	VSLIDEDOWNVI	$32, V2, V3			// ERROR "unsigned immediate 32 must be in range [0, 31]"
-	VSLIDE1UPVX	V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VFSLIDE1UPVF	V1, V2, V3			// ERROR "expected float register in rs1 position"
-	VSLIDE1DOWNVX	V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VFSLIDE1DOWNVF	V1, V2, V3			// ERROR "expected float register in rs1 position"
-	VRGATHERVV	X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VRGATHEREI16VV	X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VRGATHERVX	V1, V2, V3			// ERROR "expected integer register in rs1 position"
-	VRGATHERVI	$-1, V2, V3			// ERROR "unsigned immediate -1 must be in range [0, 31]"
-	VRGATHERVI	$32, V2, V3			// ERROR "unsigned immediate 32 must be in range [0, 31]"
-	VCOMPRESSVM	X10, V2, V3			// ERROR "expected vector register in vs1 position"
-	VMV1RV		X10, V1				// ERROR "expected vector register in vs2 position"
-	VMV2RV		X10, V10			// ERROR "expected vector register in vs2 position"
-	VMV4RV		X10, V4				// ERROR "expected vector register in vs2 position"
-	VMV8RV		X10, V0				// ERROR "expected vector register in vs2 position"
-
-	RET
--- a/src/cmd/asm/internal/asm/testdata/s390x.s
+++ b/src/cmd/asm/internal/asm/testdata/s390x.s
@@ -263,15 +263,10 @@ TEXT main·foo(SB),DUPOK|NOSPLIT,$16-0 // TEXT main.foo(SB), DUPOK|NOSPLIT, $16-
 	NC	$8, (R15), n-8(SP)       // d407f010f000
 	OC	$8, (R15), n-8(SP)       // d607f010f000
 	MVC	$8, (R15), n-8(SP)       // d207f010f000
-	MVC	$256, 8192(R1), 8192(R2) // b90400a2c2a800002000b90400b1c2b800002000d2ffa000b000
 	MVCIN	$8, (R15), n-8(SP)       // e807f010f000
 	CLC	$8, (R15), n-8(SP)       // d507f000f010
 	XC	$256, -8(R15), -8(R15)   // b90400afc2a8fffffff8d7ffa000a000
-	MVCLE   0, R4, R6                // a8640000
-	MVCLE   4095, R4, R6             // a8640fff
-	MVCLE   $4095, R4, R6            // a8640fff
-	MVCLE   (R3), R4, R6             // a8643000
-	MVCLE   10(R3), R4, R6           // a864300a
+	MVC	$256, 8192(R1), 8192(R2) // b90400a2c2a800002000b90400b1c2b800002000d2ffa000b000

 	CMP	R1, R2                 // b9200012
 	CMP	R3, $32767             // a73f7fff
@@ -406,7 +401,6 @@ TEXT main·foo(SB),DUPOK|NOSPLIT,$16-0 // TEXT main.foo(SB), DUPOK|NOSPLIT, $16-
 	FMADDS	F1, F2, F3             // b30e3012
 	FMSUB	F4, F5, F5             // b31f5045
 	FMSUBS	F6, F6, F7             // b30f7066
-	LCDBR	F0, F2                 // b3130020
 	LPDFR	F1, F2                 // b3700021
 	LNDFR	F3, F4                 // b3710043
 	CPSDR	F5, F6, F7             // b3725076
@@ -426,8 +420,8 @@ TEXT main·foo(SB),DUPOK|NOSPLIT,$16-0 // TEXT main.foo(SB), DUPOK|NOSPLIT, $16-
 	KLMD	R2, R8                 // b93f0028
 	KIMD	R0, R4                 // b93e0004
 	KDSA	R0, R8                 // b93a0008
-	KMA	R2, R6, R4             // b9296024
-	KMCTR   R2, R6, R4             // b92d6024
+	KMA	R2, R6, R4              // b9296024
+	KMCTR   R2, R6, R4              // b92d6024

 	// vector add and sub instructions
 	VAB	V3, V4, V4              // e743400000f3
@@ -540,18 +534,6 @@ TEXT main·foo(SB),DUPOK|NOSPLIT,$16-0 // TEXT main.foo(SB), DUPOK|NOSPLIT, $16-
 	VSTRCZBS V18, V20, V22, V24	// e78240306f8a
 	VSTRCZHS V18, V20, V22, V24	// e78241306f8a
 	VSTRCZFS V18, V20, V22, V24	// e78242306f8a
-	VFMAXSB	$1, V2, V3, V4          // e742301020ef
-	WFMAXSB	$2, V5, V6, V7          // e775602820ef
-	WFMAXSB	$2, F5, F6, F7          // e775602820ef
-	VFMAXDB	$3, V8, V9, V10		// e7a8903030ef
-	WFMAXDB	$4, V11, V12, V13	// e7dbc04830ef
-	WFMAXDB	$4, F11, F12, F13	// e7dbc04830ef
-	VFMINSB	$7, V14, V15, V16	// e70ef07028ee
-	WFMINSB	$8, V17, V18, V19	// e73120882eee
-	WFMINSB	$8, F1, F2, F3		// e731208820ee
-	VFMINDB	$9, V20, V21, V22	// e76450903eee
-	WFMINDB	$10, V23, V24, V25	// e79780a83eee
-	WFMINDB	$10, F7, F8, F9		// e79780a830ee

 	RET
 	RET	foo(SB)
--- a/src/cmd/asm/internal/flags/flags.go
+++ b/src/cmd/asm/internal/flags/flags.go
@@ -29,9 +29,8 @@ var (
 )

 var DebugFlags struct {
-	CompressInstructions int    `help:"use compressed instructions when possible (if supported by architecture)"`
-	MayMoreStack         string `help:"call named function before all stack growth checks"`
-	PCTab                string `help:"print named pc-value table\nOne of: pctospadj, pctofile, pctoline, pctoinline, pctopcdata"`
+	MayMoreStack string `help:"call named function before all stack growth checks"`
+	PCTab        string `help:"print named pc-value table\nOne of: pctospadj, pctofile, pctoline, pctoinline, pctopcdata"`
 }

 var (
@@ -48,8 +47,6 @@ func init() {
 	flag.Var(objabi.NewDebugFlag(&DebugFlags, nil), "d", "enable debugging settings; try -d help")
 	objabi.AddVersionFlag() // -V
 	objabi.Flagcount("S", "print assembly and machine code", &PrintOut)
-
-	DebugFlags.CompressInstructions = 1
 }

 // MultiFlag allows setting a value multiple times to collect a list, as in -I=dir1 -I=dir2.
--- a/src/cmd/asm/internal/lex/input.go
+++ b/src/cmd/asm/internal/lex/input.go
@@ -68,7 +68,7 @@ func predefine(defines flags.MultiFlag) map[string]*Macro {

 var panicOnError bool // For testing.

-func (in *Input) Error(args ...any) {
+func (in *Input) Error(args ...interface{}) {
 	if panicOnError {
 		panic(fmt.Errorf("%s:%d: %s", in.File(), in.Line(), fmt.Sprintln(args...)))
 	}
@@ -77,7 +77,7 @@ func (in *Input) Error(args ...any) {
 }

 // expectText is like Error but adds "got XXX" where XXX is a quoted representation of the most recent token.
-func (in *Input) expectText(args ...any) {
+func (in *Input) expectText(args ...interface{}) {
 	in.Error(append(args, "; got", strconv.Quote(in.Stack.Text()))...)
 }

--- a/src/cmd/asm/main.go
+++ b/src/cmd/asm/main.go
@@ -40,7 +40,6 @@ func main() {
 		log.Fatalf("unrecognized architecture %s", GOARCH)
 	}
 	ctxt := obj.Linknew(architecture.LinkArch)
-	ctxt.CompressInstructions = flags.DebugFlags.CompressInstructions != 0
 	ctxt.Debugasm = flags.PrintOut
 	ctxt.Debugvlog = flags.DebugV
 	ctxt.Flag_dynlink = *flags.Dynlink
@@ -50,7 +49,6 @@ func main() {
 	ctxt.Debugpcln = flags.DebugFlags.PCTab
 	ctxt.IsAsm = true
 	ctxt.Pkgpath = *flags.Importpath
-	ctxt.DwTextCount = objabi.DummyDwarfFunctionCountForAssembler()
 	switch *flags.Spectre {
 	default:
 		log.Printf("unknown setting -spectre=%s", *flags.Spectre)
@@ -59,7 +57,7 @@ func main() {
 		// nothing
 	case "index":
 		// known to compiler; ignore here so people can use
-		// the same list with -gcflags=-spectre=LIST and -asmflags=-spectre=LIST
+		// the same list with -gcflags=-spectre=LIST and -asmflags=-spectrre=LIST
 	case "all", "ret":
 		ctxt.Retpoline = true
 	}
@@ -94,7 +92,7 @@ func main() {
 	for _, f := range flag.Args() {
 		lexer := lex.NewLexer(f)
 		parser := asm.NewParser(ctxt, architecture, lexer)
-		ctxt.DiagFunc = func(format string, args ...any) {
+		ctxt.DiagFunc = func(format string, args ...interface{}) {
 			diag = true
 			log.Printf(format, args...)
 		}
--- a/src/cmd/cgo/ast.go
+++ b/src/cmd/cgo/ast.go
@@ -199,7 +199,7 @@ func commentText(g *ast.CommentGroup) string {
 	return strings.Join(pieces, "")
 }

-func (f *File) validateIdents(x any, context astContext) {
+func (f *File) validateIdents(x interface{}, context astContext) {
 	if x, ok := x.(*ast.Ident); ok {
 		if f.isMangledName(x.Name) {
 			error_(x.Pos(), "identifier %q may conflict with identifiers generated by cgo", x.Name)
@@ -208,7 +208,7 @@ func (f *File) validateIdents(x any, context astContext) {
 }

 // Save various references we are going to need later.
-func (f *File) saveExprs(x any, context astContext) {
+func (f *File) saveExprs(x interface{}, context astContext) {
 	switch x := x.(type) {
 	case *ast.Expr:
 		switch (*x).(type) {
@@ -278,7 +278,7 @@ func (f *File) saveCall(call *ast.CallExpr, context astContext) {
 }

 // If a function should be exported add it to ExpFunc.
-func (f *File) saveExport(x any, context astContext) {
+func (f *File) saveExport(x interface{}, context astContext) {
 	n, ok := x.(*ast.FuncDecl)
 	if !ok {
 		return
@@ -318,7 +318,7 @@ func (f *File) saveExport(x any, context astContext) {
 }

 // Make f.ExpFunc[i] point at the Func from this AST instead of the other one.
-func (f *File) saveExport2(x any, context astContext) {
+func (f *File) saveExport2(x interface{}, context astContext) {
 	n, ok := x.(*ast.FuncDecl)
 	if !ok {
 		return
@@ -355,7 +355,7 @@ const (
 )

 // walk walks the AST x, calling visit(f, x, context) for each node.
-func (f *File) walk(x any, context astContext, visit func(*File, any, astContext)) {
+func (f *File) walk(x interface{}, context astContext, visit func(*File, interface{}, astContext)) {
 	visit(f, x, context)
 	switch n := x.(type) {
 	case *ast.Expr:
@@ -363,8 +363,7 @@ func (f *File) walk(x any, context astContext, visit func(*File, any, astContext

 	// everything else just recurs
 	default:
-		error_(token.NoPos, "unexpected type %T in walk", x)
-		panic("unexpected type")
+		f.walkUnexpected(x, context, visit)

 	case nil:

@@ -397,9 +396,6 @@ func (f *File) walk(x any, context astContext, visit func(*File, any, astContext
 	case *ast.IndexExpr:
 		f.walk(&n.X, ctxExpr, visit)
 		f.walk(&n.Index, ctxExpr, visit)
-	case *ast.IndexListExpr:
-		f.walk(&n.X, ctxExpr, visit)
-		f.walk(n.Indices, ctxExpr, visit)
 	case *ast.SliceExpr:
 		f.walk(&n.X, ctxExpr, visit)
 		if n.Low != nil {
@@ -438,8 +434,8 @@ func (f *File) walk(x any, context astContext, visit func(*File, any, astContext
 	case *ast.StructType:
 		f.walk(n.Fields, ctxField, visit)
 	case *ast.FuncType:
-		if n.TypeParams != nil {
-			f.walk(n.TypeParams, ctxParam, visit)
+		if tparams := funcTypeTypeParams(n); tparams != nil {
+			f.walk(tparams, ctxParam, visit)
 		}
 		f.walk(n.Params, ctxParam, visit)
 		if n.Results != nil {
@@ -528,8 +524,8 @@ func (f *File) walk(x any, context astContext, visit func(*File, any, astContext
 			f.walk(n.Values, ctxExpr, visit)
 		}
 	case *ast.TypeSpec:
-		if n.TypeParams != nil {
-			f.walk(n.TypeParams, ctxParam, visit)
+		if tparams := typeSpecTypeParams(n); tparams != nil {
+			f.walk(tparams, ctxParam, visit)
 		}
 		f.walk(&n.Type, ctxType, visit)

--- a/src/cmd/cgo/ast_go1.go
+++ b/src/cmd/cgo/ast_go1.go
@@ -0,0 +1,25 @@
+// 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 compiler_bootstrap
+
+package main
+
+import (
+	"go/ast"
+	"go/token"
+)
+
+func (f *File) walkUnexpected(x interface{}, context astContext, visit func(*File, interface{}, astContext)) {
+	error_(token.NoPos, "unexpected type %T in walk", x)
+	panic("unexpected type")
+}
+
+func funcTypeTypeParams(n *ast.FuncType) *ast.FieldList {
+	return nil
+}
+
+func typeSpecTypeParams(n *ast.TypeSpec) *ast.FieldList {
+	return nil
+}
--- a/src/cmd/cgo/ast_go118.go
+++ b/src/cmd/cgo/ast_go118.go
@@ -0,0 +1,32 @@
+// 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 !compiler_bootstrap
+
+package main
+
+import (
+	"go/ast"
+	"go/token"
+)
+
+func (f *File) walkUnexpected(x interface{}, context astContext, visit func(*File, interface{}, astContext)) {
+	switch n := x.(type) {
+	default:
+		error_(token.NoPos, "unexpected type %T in walk", x)
+		panic("unexpected type")
+
+	case *ast.IndexListExpr:
+		f.walk(&n.X, ctxExpr, visit)
+		f.walk(n.Indices, ctxExpr, visit)
+	}
+}
+
+func funcTypeTypeParams(n *ast.FuncType) *ast.FieldList {
+	return n.TypeParams
+}
+
+func typeSpecTypeParams(n *ast.TypeSpec) *ast.FieldList {
+	return n.TypeParams
+}
--- a/src/cmd/cgo/doc.go
+++ b/src/cmd/cgo/doc.go
@@ -127,7 +127,7 @@ environment variable when running the go tool: set it to 1 to enable
 the use of cgo, and to 0 to disable it. The go tool will set the
 build constraint "cgo" if cgo is enabled. The special import "C"
 implies the "cgo" build constraint, as though the file also said
-"//go:build cgo". Therefore, if cgo is disabled, files that import
+"//go:build cgo".  Therefore, if cgo is disabled, files that import
 "C" will not be built by the go tool. (For more about build constraints
 see https://golang.org/pkg/go/build/#hdr-Build_Constraints).

@@ -425,8 +425,8 @@ and of course there is nothing stopping the C code from doing anything
 it likes. However, programs that break these rules are likely to fail
 in unexpected and unpredictable ways.

-The type [runtime/cgo.Handle] can be used to safely pass Go values
-between Go and C.
+The runtime/cgo.Handle type can be used to safely pass Go values
+between Go and C. See the runtime/cgo package documentation for details.

 Note: the current implementation has a bug. While Go code is permitted
 to write nil or a C pointer (but not a Go pointer) to C memory, the
--- a/src/cmd/cgo/gcc.go
+++ b/src/cmd/cgo/gcc.go
@@ -27,7 +27,6 @@ import (
 	"slices"
 	"strconv"
 	"strings"
-	"sync/atomic"
 	"unicode"
 	"unicode/utf8"

@@ -183,22 +182,25 @@ func splitQuoted(s string) (r []string, err error) {
 	return args, err
 }

-// loadDebug runs gcc to load debug information for the File. The debug
-// information will be saved to the debugs field of the file, and be
-// processed when Translate is called on the file later.
-// loadDebug is called concurrently with different files.
-func (f *File) loadDebug(p *Package) {
+// Translate rewrites f.AST, the original Go input, to remove
+// references to the imported package C, replacing them with
+// references to the equivalent Go types, functions, and variables.
+func (p *Package) Translate(f *File) {
 	for _, cref := range f.Ref {
 		// Convert C.ulong to C.unsigned long, etc.
 		cref.Name.C = cname(cref.Name.Go)
 	}

-	ft := fileTypedefs{typedefs: make(map[string]bool)}
+	var conv typeConv
+	conv.Init(p.PtrSize, p.IntSize)
+
+	p.typedefs = map[string]bool{}
+	p.typedefList = nil
 	numTypedefs := -1
-	for len(ft.typedefs) > numTypedefs {
-		numTypedefs = len(ft.typedefs)
+	for len(p.typedefs) > numTypedefs {
+		numTypedefs = len(p.typedefs)
 		// Also ask about any typedefs we've seen so far.
-		for _, info := range ft.typedefList {
+		for _, info := range p.typedefList {
 			if f.Name[info.typedef] != nil {
 				continue
 			}
@@ -211,7 +213,7 @@ func (f *File) loadDebug(p *Package) {
 		}
 		needType := p.guessKinds(f)
 		if len(needType) > 0 {
-			f.debugs = append(f.debugs, p.loadDWARF(f, &ft, needType))
+			p.loadDWARF(f, &conv, needType)
 		}

 		// In godefs mode we're OK with the typedefs, which
@@ -221,18 +223,6 @@ func (f *File) loadDebug(p *Package) {
 			break
 		}
 	}
-}
-
-// Translate rewrites f.AST, the original Go input, to remove
-// references to the imported package C, replacing them with
-// references to the equivalent Go types, functions, and variables.
-// Preconditions: File.loadDebug must be called prior to translate.
-func (p *Package) Translate(f *File) {
-	var conv typeConv
-	conv.Init(p.PtrSize, p.IntSize)
-	for _, d := range f.debugs {
-		p.recordTypes(f, d, &conv)
-	}
 	p.prepareNames(f)
 	if p.rewriteCalls(f) {
 		// Add `import _cgo_unsafe "unsafe"` after the package statement.
@@ -251,7 +241,7 @@ func (f *File) loadDefines(gccOptions []string) bool {
 	stdout := gccDefines(b.Bytes(), gccOptions)

 	var gccIsClang bool
-	for line := range strings.SplitSeq(stdout, "\n") {
+	for _, line := range strings.Split(stdout, "\n") {
 		if len(line) < 9 || line[0:7] != "#define" {
 			continue
 		}
@@ -289,7 +279,6 @@ func (f *File) loadDefines(gccOptions []string) bool {
 // guessKinds tricks gcc into revealing the kind of each
 // name xxx for the references C.xxx in the Go input.
 // The kind is either a constant, type, or variable.
-// guessKinds is called concurrently with different files.
 func (p *Package) guessKinds(f *File) []*Name {
 	// Determine kinds for names we already know about,
 	// like #defines or 'struct foo', before bothering with gcc.
@@ -428,7 +417,7 @@ func (p *Package) guessKinds(f *File) []*Name {
 		notDeclared
 	)
 	sawUnmatchedErrors := false
-	for line := range strings.SplitSeq(stderr, "\n") {
+	for _, line := range strings.Split(stderr, "\n") {
 		// Ignore warnings and random comments, with one
 		// exception: newer GCC versions will sometimes emit
 		// an error on a macro #define with a note referring
@@ -533,8 +522,7 @@ func (p *Package) guessKinds(f *File) []*Name {
 // loadDWARF parses the DWARF debug information generated
 // by gcc to learn the details of the constants, variables, and types
 // being referred to as C.xxx.
-// loadDwarf is called concurrently with different files.
-func (p *Package) loadDWARF(f *File, ft *fileTypedefs, names []*Name) *debug {
+func (p *Package) loadDWARF(f *File, conv *typeConv, names []*Name) {
 	// Extract the types from the DWARF section of an object
 	// from a well-formed C program. Gcc only generates DWARF info
 	// for symbols in the object file, so it is not enough to print the
@@ -648,28 +636,13 @@ func (p *Package) loadDWARF(f *File, ft *fileTypedefs, names []*Name) *debug {
 				fatalf("malformed __cgo__ name: %s", name)
 			}
 			types[i] = t.Type
-			ft.recordTypedefs(t.Type, f.NamePos[names[i]])
+			p.recordTypedefs(t.Type, f.NamePos[names[i]])
 		}
 		if e.Tag != dwarf.TagCompileUnit {
 			r.SkipChildren()
 		}
 	}

-	return &debug{names, types, ints, floats, strs}
-}
-
-// debug is the data extracted by running an iteration of loadDWARF on a file.
-type debug struct {
-	names  []*Name
-	types  []dwarf.Type
-	ints   []int64
-	floats []float64
-	strs   []string
-}
-
-func (p *Package) recordTypes(f *File, data *debug, conv *typeConv) {
-	names, types, ints, floats, strs := data.names, data.types, data.ints, data.floats, data.strs
-
 	// Record types and typedef information.
 	for i, n := range names {
 		if strings.HasSuffix(n.Go, "GetTypeID") && types[i].String() == "func() CFTypeID" {
@@ -728,17 +701,12 @@ func (p *Package) recordTypes(f *File, data *debug, conv *typeConv) {
 	}
 }

-type fileTypedefs struct {
-	typedefs    map[string]bool // type names that appear in the types of the objects we're interested in
-	typedefList []typedefInfo
+// recordTypedefs remembers in p.typedefs all the typedefs used in dtypes and its children.
+func (p *Package) recordTypedefs(dtype dwarf.Type, pos token.Pos) {
+	p.recordTypedefs1(dtype, pos, map[dwarf.Type]bool{})
 }

-// recordTypedefs remembers in ft.typedefs all the typedefs used in dtypes and its children.
-func (ft *fileTypedefs) recordTypedefs(dtype dwarf.Type, pos token.Pos) {
-	ft.recordTypedefs1(dtype, pos, map[dwarf.Type]bool{})
-}
-
-func (ft *fileTypedefs) recordTypedefs1(dtype dwarf.Type, pos token.Pos, visited map[dwarf.Type]bool) {
+func (p *Package) recordTypedefs1(dtype dwarf.Type, pos token.Pos, visited map[dwarf.Type]bool) {
 	if dtype == nil {
 		return
 	}
@@ -752,25 +720,25 @@ func (ft *fileTypedefs) recordTypedefs1(dtype dwarf.Type, pos token.Pos, visited
 			// Don't look inside builtin types. There be dragons.
 			return
 		}
-		if !ft.typedefs[dt.Name] {
-			ft.typedefs[dt.Name] = true
-			ft.typedefList = append(ft.typedefList, typedefInfo{dt.Name, pos})
-			ft.recordTypedefs1(dt.Type, pos, visited)
+		if !p.typedefs[dt.Name] {
+			p.typedefs[dt.Name] = true
+			p.typedefList = append(p.typedefList, typedefInfo{dt.Name, pos})
+			p.recordTypedefs1(dt.Type, pos, visited)
 		}
 	case *dwarf.PtrType:
-		ft.recordTypedefs1(dt.Type, pos, visited)
+		p.recordTypedefs1(dt.Type, pos, visited)
 	case *dwarf.ArrayType:
-		ft.recordTypedefs1(dt.Type, pos, visited)
+		p.recordTypedefs1(dt.Type, pos, visited)
 	case *dwarf.QualType:
-		ft.recordTypedefs1(dt.Type, pos, visited)
+		p.recordTypedefs1(dt.Type, pos, visited)
 	case *dwarf.FuncType:
-		ft.recordTypedefs1(dt.ReturnType, pos, visited)
+		p.recordTypedefs1(dt.ReturnType, pos, visited)
 		for _, a := range dt.ParamType {
-			ft.recordTypedefs1(a, pos, visited)
+			p.recordTypedefs1(a, pos, visited)
 		}
 	case *dwarf.StructType:
-		for _, l := range dt.Field {
-			ft.recordTypedefs1(l.Type, pos, visited)
+		for _, f := range dt.Field {
+			p.recordTypedefs1(f.Type, pos, visited)
 		}
 	}
 }
@@ -1056,7 +1024,7 @@ func (p *Package) rewriteCall(f *File, call *Call) (string, bool) {
 func (p *Package) needsPointerCheck(f *File, t ast.Expr, arg ast.Expr) bool {
 	// An untyped nil does not need a pointer check, and when
 	// _cgoCheckPointer returns the untyped nil the type assertion we
-	// are going to insert will fail. Easier to just skip nil arguments.
+	// are going to insert will fail.  Easier to just skip nil arguments.
 	// TODO: Note that this fails if nil is shadowed.
 	if id, ok := arg.(*ast.Ident); ok && id.Name == "nil" {
 		return false
@@ -1121,9 +1089,6 @@ func (p *Package) hasPointer(f *File, t ast.Expr, top bool) bool {
 		if t.Name == "error" {
 			return true
 		}
-		if t.Name == "any" {
-			return true
-		}
 		if goTypes[t.Name] != nil {
 			return false
 		}
@@ -1161,7 +1126,7 @@ func (p *Package) hasPointer(f *File, t ast.Expr, top bool) bool {
 // If addPosition is true, add position info to the idents of C names in arg.
 func (p *Package) mangle(f *File, arg *ast.Expr, addPosition bool) (ast.Expr, bool) {
 	needsUnsafe := false
-	f.walk(arg, ctxExpr, func(f *File, arg any, context astContext) {
+	f.walk(arg, ctxExpr, func(f *File, arg interface{}, context astContext) {
 		px, ok := arg.(*ast.Expr)
 		if !ok {
 			return
@@ -1791,24 +1756,20 @@ func gccMachine() []string {
 	return nil
 }

-var n atomic.Int64
-
 func gccTmp() string {
-	c := strconv.Itoa(int(n.Add(1)))
-	return *objDir + "_cgo_" + c + ".o"
+	return *objDir + "_cgo_.o"
 }

 // gccCmd returns the gcc command line to use for compiling
 // the input.
-// gccCommand is called concurrently for different files.
-func (p *Package) gccCmd(ofile string) []string {
+func (p *Package) gccCmd() []string {
 	c := append(gccBaseCmd,
-		"-w",         // no warnings
-		"-Wno-error", // warnings are not errors
-		"-o"+ofile,   // write object to tmp
-		"-gdwarf-2",  // generate DWARF v2 debugging symbols
-		"-c",         // do not link
-		"-xc",        // input language is C
+		"-w",          // no warnings
+		"-Wno-error",  // warnings are not errors
+		"-o"+gccTmp(), // write object to tmp
+		"-gdwarf-2",   // generate DWARF v2 debugging symbols
+		"-c",          // do not link
+		"-xc",         // input language is C
 	)
 	if p.GccIsClang {
 		c = append(c,
@@ -1844,10 +1805,8 @@ func (p *Package) gccCmd(ofile string) []string {

 // gccDebug runs gcc -gdwarf-2 over the C program stdin and
 // returns the corresponding DWARF data and, if present, debug data block.
-// gccDebug is called concurrently with different C programs.
 func (p *Package) gccDebug(stdin []byte, nnames int) (d *dwarf.Data, ints []int64, floats []float64, strs []string) {
-	ofile := gccTmp()
-	runGcc(stdin, p.gccCmd(ofile))
+	runGcc(stdin, p.gccCmd())

 	isDebugInts := func(s string) bool {
 		// Some systems use leading _ to denote non-assembly symbols.
@@ -1897,11 +1856,11 @@ func (p *Package) gccDebug(stdin []byte, nnames int) (d *dwarf.Data, ints []int6
 		}
 	}

-	if f, err := macho.Open(ofile); err == nil {
+	if f, err := macho.Open(gccTmp()); err == nil {
 		defer f.Close()
 		d, err := f.DWARF()
 		if err != nil {
-			fatalf("cannot load DWARF output from %s: %v", ofile, err)
+			fatalf("cannot load DWARF output from %s: %v", gccTmp(), err)
 		}
 		bo := f.ByteOrder
 		if f.Symtab != nil {
@@ -1975,11 +1934,11 @@ func (p *Package) gccDebug(stdin []byte, nnames int) (d *dwarf.Data, ints []int6
 		return d, ints, floats, strs
 	}

-	if f, err := elf.Open(ofile); err == nil {
+	if f, err := elf.Open(gccTmp()); err == nil {
 		defer f.Close()
 		d, err := f.DWARF()
 		if err != nil {
-			fatalf("cannot load DWARF output from %s: %v", ofile, err)
+			fatalf("cannot load DWARF output from %s: %v", gccTmp(), err)
 		}
 		bo := f.ByteOrder
 		symtab, err := f.Symbols()
@@ -2075,11 +2034,11 @@ func (p *Package) gccDebug(stdin []byte, nnames int) (d *dwarf.Data, ints []int6
 		return d, ints, floats, strs
 	}

-	if f, err := pe.Open(ofile); err == nil {
+	if f, err := pe.Open(gccTmp()); err == nil {
 		defer f.Close()
 		d, err := f.DWARF()
 		if err != nil {
-			fatalf("cannot load DWARF output from %s: %v", ofile, err)
+			fatalf("cannot load DWARF output from %s: %v", gccTmp(), err)
 		}
 		bo := binary.LittleEndian
 		for _, s := range f.Symbols {
@@ -2147,17 +2106,17 @@ func (p *Package) gccDebug(stdin []byte, nnames int) (d *dwarf.Data, ints []int6
 		return d, ints, floats, strs
 	}

-	if f, err := xcoff.Open(ofile); err == nil {
+	if f, err := xcoff.Open(gccTmp()); err == nil {
 		defer f.Close()
 		d, err := f.DWARF()
 		if err != nil {
-			fatalf("cannot load DWARF output from %s: %v", ofile, err)
+			fatalf("cannot load DWARF output from %s: %v", gccTmp(), err)
 		}
 		bo := binary.BigEndian
 		for _, s := range f.Symbols {
 			switch {
 			case isDebugInts(s.Name):
-				if i := s.SectionNumber - 1; 0 <= i && i < len(f.Sections) {
+				if i := int(s.SectionNumber) - 1; 0 <= i && i < len(f.Sections) {
 					sect := f.Sections[i]
 					if s.Value < sect.Size {
 						if sdat, err := sect.Data(); err == nil {
@@ -2170,7 +2129,7 @@ func (p *Package) gccDebug(stdin []byte, nnames int) (d *dwarf.Data, ints []int6
 					}
 				}
 			case isDebugFloats(s.Name):
-				if i := s.SectionNumber - 1; 0 <= i && i < len(f.Sections) {
+				if i := int(s.SectionNumber) - 1; 0 <= i && i < len(f.Sections) {
 					sect := f.Sections[i]
 					if s.Value < sect.Size {
 						if sdat, err := sect.Data(); err == nil {
@@ -2184,7 +2143,7 @@ func (p *Package) gccDebug(stdin []byte, nnames int) (d *dwarf.Data, ints []int6
 				}
 			default:
 				if n := indexOfDebugStr(s.Name); n != -1 {
-					if i := s.SectionNumber - 1; 0 <= i && i < len(f.Sections) {
+					if i := int(s.SectionNumber) - 1; 0 <= i && i < len(f.Sections) {
 						sect := f.Sections[i]
 						if s.Value < sect.Size {
 							if sdat, err := sect.Data(); err == nil {
@@ -2196,7 +2155,7 @@ func (p *Package) gccDebug(stdin []byte, nnames int) (d *dwarf.Data, ints []int6
 					break
 				}
 				if n := indexOfDebugStrlen(s.Name); n != -1 {
-					if i := s.SectionNumber - 1; 0 <= i && i < len(f.Sections) {
+					if i := int(s.SectionNumber) - 1; 0 <= i && i < len(f.Sections) {
 						sect := f.Sections[i]
 						if s.Value < sect.Size {
 							if sdat, err := sect.Data(); err == nil {
@@ -2217,7 +2176,7 @@ func (p *Package) gccDebug(stdin []byte, nnames int) (d *dwarf.Data, ints []int6
 		buildStrings()
 		return d, ints, floats, strs
 	}
-	fatalf("cannot parse gcc output %s as ELF, Mach-O, PE, XCOFF object", ofile)
+	fatalf("cannot parse gcc output %s as ELF, Mach-O, PE, XCOFF object", gccTmp())
 	panic("not reached")
 }

@@ -2235,10 +2194,9 @@ func gccDefines(stdin []byte, gccOptions []string) string {
 // gccErrors runs gcc over the C program stdin and returns
 // the errors that gcc prints. That is, this function expects
 // gcc to fail.
-// gccErrors is called concurrently with different C programs.
 func (p *Package) gccErrors(stdin []byte, extraArgs ...string) string {
 	// TODO(rsc): require failure
-	args := p.gccCmd(gccTmp())
+	args := p.gccCmd()

 	// Optimization options can confuse the error messages; remove them.
 	nargs := make([]string, 0, len(args)+len(extraArgs))
@@ -2442,7 +2400,7 @@ func (tr *TypeRepr) Empty() bool {
 // Set modifies the type representation.
 // If fargs are provided, repr is used as a format for fmt.Sprintf.
 // Otherwise, repr is used unprocessed as the type representation.
-func (tr *TypeRepr) Set(repr string, fargs ...any) {
+func (tr *TypeRepr) Set(repr string, fargs ...interface{}) {
 	tr.Repr = repr
 	tr.FormatArgs = fargs
 }
@@ -2716,7 +2674,7 @@ func (c *typeConv) loadType(dtype dwarf.Type, pos token.Pos, parent string) *Typ
 			// so execute the basic things that the struct case would do
 			// other than try to determine a Go representation.
 			tt := *t
-			tt.C = &TypeRepr{"%s %s", []any{dt.Kind, tag}}
+			tt.C = &TypeRepr{"%s %s", []interface{}{dt.Kind, tag}}
 			// We don't know what the representation of this struct is, so don't let
 			// anyone allocate one on the Go side. As a side effect of this annotation,
 			// pointers to this type will not be considered pointers in Go. They won't
@@ -2746,7 +2704,7 @@ func (c *typeConv) loadType(dtype dwarf.Type, pos token.Pos, parent string) *Typ
 			t.Align = align
 			tt := *t
 			if tag != "" {
-				tt.C = &TypeRepr{"struct %s", []any{tag}}
+				tt.C = &TypeRepr{"struct %s", []interface{}{tag}}
 			}
 			tt.Go = g
 			if c.incompleteStructs[tag] {
@@ -2905,7 +2863,7 @@ func (c *typeConv) loadType(dtype dwarf.Type, pos token.Pos, parent string) *Typ
 			if ss, ok := dwarfToName[s]; ok {
 				s = ss
 			}
-			s = strings.ReplaceAll(s, " ", "")
+			s = strings.Replace(s, " ", "", -1)
 			name := c.Ident("_Ctype_" + s)
 			tt := *t
 			typedef[name.Name] = &tt
@@ -3013,7 +2971,7 @@ func (c *typeConv) FuncType(dtype *dwarf.FuncType, pos token.Pos) *FuncType {
 	for i, f := range dtype.ParamType {
 		// gcc's DWARF generator outputs a single DotDotDotType parameter for
 		// function pointers that specify no parameters (e.g. void
-		// (*__cgo_0)()). Treat this special case as void. This case is
+		// (*__cgo_0)()).  Treat this special case as void. This case is
 		// invalid according to ISO C anyway (i.e. void (*__cgo_1)(...) is not
 		// legal).
 		if _, ok := f.(*dwarf.DotDotDotType); ok && i == 0 {
@@ -3084,7 +3042,7 @@ func (c *typeConv) Struct(dt *dwarf.StructType, pos token.Pos) (expr *ast.Struct
 	off := int64(0)

 	// Rename struct fields that happen to be named Go keywords into
-	// _{keyword}. Create a map from C ident -> Go ident. The Go ident will
+	// _{keyword}.  Create a map from C ident -> Go ident. The Go ident will
 	// be mangled. Any existing identifier that already has the same name on
 	// the C-side will cause the Go-mangled version to be prefixed with _.
 	// (e.g. in a struct with fields '_type' and 'type', the latter would be
@@ -3312,7 +3270,7 @@ func godefsFields(fld []*ast.Field) {
 // fieldPrefix returns the prefix that should be removed from all the
 // field names when generating the C or Go code. For generated
 // C, we leave the names as is (tv_sec, tv_usec), since that's what
-// people are used to seeing in C. For generated Go code, such as
+// people are used to seeing in C.  For generated Go code, such as
 // package syscall's data structures, we drop a common prefix
 // (so sec, usec, which will get turned into Sec, Usec for exporting).
 func fieldPrefix(fld []*ast.Field) string {
@@ -3459,7 +3417,7 @@ func (c *typeConv) badCFType(dt *dwarf.TypedefType) bool {
 // Tagged pointer support
 // Low-bit set means tagged object, next 3 bits (currently)
 // define the tagged object class, next 4 bits are for type
-// information for the specific tagged object class. Thus,
+// information for the specific tagged object class.  Thus,
 // the low byte is for type info, and the rest of a pointer
 // (32 or 64-bit) is for payload, whatever the tagged class.
 //
--- a/src/cmd/cgo/godefs.go
+++ b/src/cmd/cgo/godefs.go
@@ -117,7 +117,7 @@ func (p *Package) godefs(f *File, args []string) string {
 var gofmtBuf strings.Builder

 // gofmt returns the gofmt-formatted string for an AST node.
-func gofmt(n any) string {
+func gofmt(n interface{}) string {
 	gofmtBuf.Reset()
 	err := printer.Fprint(&gofmtBuf, fset, n)
 	if err != nil {
--- a/src/cmd/cgo/internal/swig/swig_test.go
+++ b/src/cmd/cgo/internal/swig/swig_test.go
@@ -40,9 +40,8 @@ func TestCallback(t *testing.T) {
 }

 func run(t *testing.T, dir string, lto bool, args ...string) {
-	testenv.MustHaveGoRun(t)
 	runArgs := append([]string{"run", "."}, args...)
-	cmd := exec.Command(testenv.GoToolPath(t), runArgs...)
+	cmd := exec.Command("go", runArgs...)
 	cmd.Dir = dir
 	if lto {
 		// On the builders we're using the default /usr/bin/ld, but
@@ -69,7 +68,7 @@ func run(t *testing.T, dir string, lto bool, args ...string) {

 func mustHaveCxx(t *testing.T) {
 	// Ask the go tool for the CXX it's configured to use.
-	cxx, err := exec.Command(testenv.GoToolPath(t), "env", "CXX").CombinedOutput()
+	cxx, err := exec.Command("go", "env", "CXX").CombinedOutput()
 	if err != nil {
 		t.Fatalf("go env CXX failed: %s", err)
 	}
@@ -80,7 +79,7 @@ func mustHaveCxx(t *testing.T) {
 	if len(args) == 0 {
 		t.Skip("no C++ compiler")
 	}
-	testenv.MustHaveExecPath(t, args[0])
+	testenv.MustHaveExecPath(t, string(args[0]))
 }

 var (
--- a/src/cmd/cgo/internal/test/buildid_linux.go
+++ b/src/cmd/cgo/internal/test/buildid_linux.go
@@ -4,9 +4,9 @@

 package cgotest

-// Test that we have no more than one build ID. In the past we used
+// Test that we have no more than one build ID.  In the past we used
 // to generate a separate build ID for each package using cgo, and the
-// linker concatenated them all. We don't want that--we only want
+// linker concatenated them all.  We don't want that--we only want
 // one.

 import (
@@ -42,7 +42,7 @@ sections:
 		for len(d) > 0 {

 			// ELF standards differ as to the sizes in
-			// note sections. Both the GNU linker and
+			// note sections.  Both the GNU linker and
 			// gold always generate 32-bit sizes, so that
 			// is what we assume here.

--- a/src/cmd/cgo/internal/test/callback.go
+++ b/src/cmd/cgo/internal/test/callback.go
@@ -40,7 +40,7 @@ func nestedCall(f func()) {
 	callbackMutex.Unlock()

 	// Pass the address of i because the C function was written to
-	// take a pointer. We could pass an int if we felt like
+	// take a pointer.  We could pass an int if we felt like
 	// rewriting the C code.
 	C.callback(unsafe.Pointer(&i))

--- a/src/cmd/cgo/internal/test/cgo_darwin_test.go
+++ b/src/cmd/cgo/internal/test/cgo_darwin_test.go
@@ -1,11 +0,0 @@
-// 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 cgo && darwin
-
-package cgotest
-
-import "testing"
-
-func TestIssue76023(t *testing.T) { issue76023(t) }
--- a/src/cmd/cgo/internal/test/cgo_test.go
+++ b/src/cmd/cgo/internal/test/cgo_test.go
@@ -12,105 +12,100 @@ import "testing"
 // so that they can use cgo (import "C").
 // These wrappers are here for gotest to find.

-func Test1328(t *testing.T)                     { test1328(t) }
-func Test1560(t *testing.T)                     { test1560(t) }
-func Test1635(t *testing.T)                     { test1635(t) }
-func Test3250(t *testing.T)                     { test3250(t) }
-func Test3729(t *testing.T)                     { test3729(t) }
-func Test3775(t *testing.T)                     { test3775(t) }
-func Test4029(t *testing.T)                     { test4029(t) }
-func Test4339(t *testing.T)                     { test4339(t) }
-func Test5227(t *testing.T)                     { test5227(t) }
-func Test5242(t *testing.T)                     { test5242(t) }
-func Test5337(t *testing.T)                     { test5337(t) }
-func Test5548(t *testing.T)                     { test5548(t) }
-func Test5603(t *testing.T)                     { test5603(t) }
-func Test5986(t *testing.T)                     { test5986(t) }
-func Test6390(t *testing.T)                     { test6390(t) }
-func Test6833(t *testing.T)                     { test6833(t) }
-func Test6907(t *testing.T)                     { test6907(t) }
-func Test6907Go(t *testing.T)                   { test6907Go(t) }
-func Test7560(t *testing.T)                     { test7560(t) }
-func Test7665(t *testing.T)                     { test7665(t) }
-func Test7978(t *testing.T)                     { test7978(t) }
-func Test8092(t *testing.T)                     { test8092(t) }
-func Test8517(t *testing.T)                     { test8517(t) }
-func Test8694(t *testing.T)                     { test8694(t) }
-func Test8756(t *testing.T)                     { test8756(t) }
-func Test8811(t *testing.T)                     { test8811(t) }
-func Test9026(t *testing.T)                     { test9026(t) }
-func Test9510(t *testing.T)                     { test9510(t) }
-func Test9557(t *testing.T)                     { test9557(t) }
-func Test10303(t *testing.T)                    { test10303(t, 10) }
-func Test11925(t *testing.T)                    { test11925(t) }
-func Test12030(t *testing.T)                    { test12030(t) }
-func Test14838(t *testing.T)                    { test14838(t) }
-func Test17065(t *testing.T)                    { test17065(t) }
-func Test17537(t *testing.T)                    { test17537(t) }
-func Test18126(t *testing.T)                    { test18126(t) }
-func Test18720(t *testing.T)                    { test18720(t) }
-func Test20129(t *testing.T)                    { test20129(t) }
-func Test20266(t *testing.T)                    { test20266(t) }
-func Test20369(t *testing.T)                    { test20369(t) }
-func Test20910(t *testing.T)                    { test20910(t) }
-func Test21708(t *testing.T)                    { test21708(t) }
-func Test21809(t *testing.T)                    { test21809(t) }
-func Test21897(t *testing.T)                    { test21897(t) }
-func Test22906(t *testing.T)                    { test22906(t) }
-func Test23356(t *testing.T)                    { test23356(t) }
-func Test24206(t *testing.T)                    { test24206(t) }
-func Test25143(t *testing.T)                    { test25143(t) }
-func Test26066(t *testing.T)                    { test26066(t) }
-func Test26213(t *testing.T)                    { test26213(t) }
-func Test27660(t *testing.T)                    { test27660(t) }
-func Test28896(t *testing.T)                    { test28896(t) }
-func Test30065(t *testing.T)                    { test30065(t) }
-func Test32579(t *testing.T)                    { test32579(t) }
-func Test31891(t *testing.T)                    { test31891(t) }
-func Test42018(t *testing.T)                    { test42018(t) }
-func Test45451(t *testing.T)                    { test45451(t) }
-func Test49633(t *testing.T)                    { test49633(t) }
-func Test69086(t *testing.T)                    { test69086(t) }
-func TestAlign(t *testing.T)                    { testAlign(t) }
-func TestAtol(t *testing.T)                     { testAtol(t) }
-func TestBlocking(t *testing.T)                 { testBlocking(t) }
-func TestBoolAlign(t *testing.T)                { testBoolAlign(t) }
-func TestCallGoWithString(t *testing.T)         { testCallGoWithString(t) }
-func TestCallback(t *testing.T)                 { testCallback(t) }
-func TestCallbackCallers(t *testing.T)          { testCallbackCallers(t) }
-func TestCallbackGC(t *testing.T)               { testCallbackGC(t) }
-func TestCallbackPanic(t *testing.T)            { testCallbackPanic(t) }
-func TestCallbackPanicLocked(t *testing.T)      { testCallbackPanicLocked(t) }
-func TestCallbackPanicLoop(t *testing.T)        { testCallbackPanicLoop(t) }
-func TestCallbackStack(t *testing.T)            { testCallbackStack(t) }
-func TestCflags(t *testing.T)                   { testCflags(t) }
-func TestCheckConst(t *testing.T)               { testCheckConst(t) }
-func TestConst(t *testing.T)                    { testConst(t) }
-func TestCthread(t *testing.T)                  { testCthread(t) }
-func TestEnum(t *testing.T)                     { testEnum(t) }
-func TestNamedEnum(t *testing.T)                { testNamedEnum(t) }
-func TestCastToEnum(t *testing.T)               { testCastToEnum(t) }
-func TestErrno(t *testing.T)                    { testErrno(t) }
-func TestFpVar(t *testing.T)                    { testFpVar(t) }
-func TestGCC68255(t *testing.T)                 { testGCC68255(t) }
-func TestHandle(t *testing.T)                   { testHandle(t) }
-func TestHelpers(t *testing.T)                  { testHelpers(t) }
-func TestLibgcc(t *testing.T)                   { testLibgcc(t) }
-func TestMultipleAssign(t *testing.T)           { testMultipleAssign(t) }
-func TestNaming(t *testing.T)                   { testNaming(t) }
-func TestPanicFromC(t *testing.T)               { testPanicFromC(t) }
-func TestPrintf(t *testing.T)                   { testPrintf(t) }
-func TestReturnAfterGrow(t *testing.T)          { testReturnAfterGrow(t) }
-func TestReturnAfterGrowFromGo(t *testing.T)    { testReturnAfterGrowFromGo(t) }
-func TestSetEnv(t *testing.T)                   { testSetEnv(t) }
-func TestThreadLock(t *testing.T)               { testThreadLockFunc(t) }
-func TestUnsignedInt(t *testing.T)              { testUnsignedInt(t) }
-func TestZeroArgCallback(t *testing.T)          { testZeroArgCallback(t) }
-func Test76340(t *testing.T)                    { test76340(t) }
-func TestDITCgo(t *testing.T)                   { testDITCgo(t) }
-func TestDITCgoCallback(t *testing.T)           { testDITCgoCallback(t) }
-func TestDITCgoCallbackEnableDIT(t *testing.T)  { testDITCgoCallbackEnableDIT(t) }
-func TestDITCgoCallbackDisableDIT(t *testing.T) { testDITCgoCallbackDisableDIT(t) }
+func Test1328(t *testing.T)                  { test1328(t) }
+func Test1560(t *testing.T)                  { test1560(t) }
+func Test1635(t *testing.T)                  { test1635(t) }
+func Test3250(t *testing.T)                  { test3250(t) }
+func Test3729(t *testing.T)                  { test3729(t) }
+func Test3775(t *testing.T)                  { test3775(t) }
+func Test4029(t *testing.T)                  { test4029(t) }
+func Test4339(t *testing.T)                  { test4339(t) }
+func Test5227(t *testing.T)                  { test5227(t) }
+func Test5242(t *testing.T)                  { test5242(t) }
+func Test5337(t *testing.T)                  { test5337(t) }
+func Test5548(t *testing.T)                  { test5548(t) }
+func Test5603(t *testing.T)                  { test5603(t) }
+func Test5986(t *testing.T)                  { test5986(t) }
+func Test6390(t *testing.T)                  { test6390(t) }
+func Test6833(t *testing.T)                  { test6833(t) }
+func Test6907(t *testing.T)                  { test6907(t) }
+func Test6907Go(t *testing.T)                { test6907Go(t) }
+func Test7560(t *testing.T)                  { test7560(t) }
+func Test7665(t *testing.T)                  { test7665(t) }
+func Test7978(t *testing.T)                  { test7978(t) }
+func Test8092(t *testing.T)                  { test8092(t) }
+func Test8517(t *testing.T)                  { test8517(t) }
+func Test8694(t *testing.T)                  { test8694(t) }
+func Test8756(t *testing.T)                  { test8756(t) }
+func Test8811(t *testing.T)                  { test8811(t) }
+func Test9026(t *testing.T)                  { test9026(t) }
+func Test9510(t *testing.T)                  { test9510(t) }
+func Test9557(t *testing.T)                  { test9557(t) }
+func Test10303(t *testing.T)                 { test10303(t, 10) }
+func Test11925(t *testing.T)                 { test11925(t) }
+func Test12030(t *testing.T)                 { test12030(t) }
+func Test14838(t *testing.T)                 { test14838(t) }
+func Test17065(t *testing.T)                 { test17065(t) }
+func Test17537(t *testing.T)                 { test17537(t) }
+func Test18126(t *testing.T)                 { test18126(t) }
+func Test18720(t *testing.T)                 { test18720(t) }
+func Test20129(t *testing.T)                 { test20129(t) }
+func Test20266(t *testing.T)                 { test20266(t) }
+func Test20369(t *testing.T)                 { test20369(t) }
+func Test20910(t *testing.T)                 { test20910(t) }
+func Test21708(t *testing.T)                 { test21708(t) }
+func Test21809(t *testing.T)                 { test21809(t) }
+func Test21897(t *testing.T)                 { test21897(t) }
+func Test22906(t *testing.T)                 { test22906(t) }
+func Test23356(t *testing.T)                 { test23356(t) }
+func Test24206(t *testing.T)                 { test24206(t) }
+func Test25143(t *testing.T)                 { test25143(t) }
+func Test26066(t *testing.T)                 { test26066(t) }
+func Test26213(t *testing.T)                 { test26213(t) }
+func Test27660(t *testing.T)                 { test27660(t) }
+func Test28896(t *testing.T)                 { test28896(t) }
+func Test30065(t *testing.T)                 { test30065(t) }
+func Test32579(t *testing.T)                 { test32579(t) }
+func Test31891(t *testing.T)                 { test31891(t) }
+func Test42018(t *testing.T)                 { test42018(t) }
+func Test45451(t *testing.T)                 { test45451(t) }
+func Test49633(t *testing.T)                 { test49633(t) }
+func Test69086(t *testing.T)                 { test69086(t) }
+func TestAlign(t *testing.T)                 { testAlign(t) }
+func TestAtol(t *testing.T)                  { testAtol(t) }
+func TestBlocking(t *testing.T)              { testBlocking(t) }
+func TestBoolAlign(t *testing.T)             { testBoolAlign(t) }
+func TestCallGoWithString(t *testing.T)      { testCallGoWithString(t) }
+func TestCallback(t *testing.T)              { testCallback(t) }
+func TestCallbackCallers(t *testing.T)       { testCallbackCallers(t) }
+func TestCallbackGC(t *testing.T)            { testCallbackGC(t) }
+func TestCallbackPanic(t *testing.T)         { testCallbackPanic(t) }
+func TestCallbackPanicLocked(t *testing.T)   { testCallbackPanicLocked(t) }
+func TestCallbackPanicLoop(t *testing.T)     { testCallbackPanicLoop(t) }
+func TestCallbackStack(t *testing.T)         { testCallbackStack(t) }
+func TestCflags(t *testing.T)                { testCflags(t) }
+func TestCheckConst(t *testing.T)            { testCheckConst(t) }
+func TestConst(t *testing.T)                 { testConst(t) }
+func TestCthread(t *testing.T)               { testCthread(t) }
+func TestEnum(t *testing.T)                  { testEnum(t) }
+func TestNamedEnum(t *testing.T)             { testNamedEnum(t) }
+func TestCastToEnum(t *testing.T)            { testCastToEnum(t) }
+func TestErrno(t *testing.T)                 { testErrno(t) }
+func TestFpVar(t *testing.T)                 { testFpVar(t) }
+func TestGCC68255(t *testing.T)              { testGCC68255(t) }
+func TestHandle(t *testing.T)                { testHandle(t) }
+func TestHelpers(t *testing.T)               { testHelpers(t) }
+func TestLibgcc(t *testing.T)                { testLibgcc(t) }
+func TestMultipleAssign(t *testing.T)        { testMultipleAssign(t) }
+func TestNaming(t *testing.T)                { testNaming(t) }
+func TestPanicFromC(t *testing.T)            { testPanicFromC(t) }
+func TestPrintf(t *testing.T)                { testPrintf(t) }
+func TestReturnAfterGrow(t *testing.T)       { testReturnAfterGrow(t) }
+func TestReturnAfterGrowFromGo(t *testing.T) { testReturnAfterGrowFromGo(t) }
+func TestSetEnv(t *testing.T)                { testSetEnv(t) }
+func TestThreadLock(t *testing.T)            { testThreadLockFunc(t) }
+func TestUnsignedInt(t *testing.T)           { testUnsignedInt(t) }
+func TestZeroArgCallback(t *testing.T)       { testZeroArgCallback(t) }

 func BenchmarkCgoCall(b *testing.B)      { benchCgoCall(b) }
 func BenchmarkGoString(b *testing.B)     { benchGoString(b) }
--- a/src/cmd/cgo/internal/test/gcc68255/a.go
+++ b/src/cmd/cgo/internal/test/gcc68255/a.go
@@ -3,7 +3,7 @@
 // license that can be found in the LICENSE file.

 // Test that it's OK to have C code that does nothing other than
-// initialize a global variable. This used to fail with gccgo.
+// initialize a global variable.  This used to fail with gccgo.

 package gcc68255

--- a/src/cmd/cgo/internal/test/issue18146.go
+++ b/src/cmd/cgo/internal/test/issue18146.go
@@ -11,7 +11,6 @@ package cgotest
 import (
 	"bytes"
 	"crypto/md5"
-	"internal/testenv"
 	"os"
 	"os/exec"
 	"runtime"
@@ -74,7 +73,7 @@ func test18146(t *testing.T) {
 		}
 		runtime.GOMAXPROCS(threads)
 		argv := append(os.Args, "-test.run=^$")
-		if err := syscall.Exec(testenv.Executable(t), argv, os.Environ()); err != nil {
+		if err := syscall.Exec(os.Args[0], argv, os.Environ()); err != nil {
 			t.Fatal(err)
 		}
 	}
@@ -88,7 +87,7 @@ func test18146(t *testing.T) {

 	args := append(append([]string(nil), os.Args[1:]...), "-test.run=^Test18146$")
 	for n := attempts; n > 0; n-- {
-		cmd := exec.Command(testenv.Executable(t), args...)
+		cmd := exec.Command(os.Args[0], args...)
 		cmd.Env = append(os.Environ(), "test18146=exec")
 		buf := bytes.NewBuffer(nil)
 		cmd.Stdout = buf
--- a/Show More
+++ b/Show More
				`@@ -1 +1,3 @@`
				`### Minor changes to the library {#minor_library_changes}`