test/codegen: test negation with add/sub on riscv64

Change-Id: Ic0eca86d3c93707ebd7c716e774ebda55af4f196
Reviewed-on: https://go-review.googlesource.com/c/go/+/703755
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Julian Zhu <jz531210@gmail.com>
Reviewed-by: Cherry Mui <cherryyz@google.com>
Reviewed-by: Dmitri Shuralyov <dmitshur@google.com>
Reviewed-by: Joel Sing <joel@sing.id.au>

.gitignore

@@ -30,6 +30,7 @@ _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

api/go1.25.txt

@@ -0,0 +1,111 @@
+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

api/go1.26.txt

@@ -0,0 +1,185 @@
+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 database/sql/driver, type RowsColumnScanner interface { Close, Columns, Next, ScanColumn } #67546
+pkg database/sql/driver, type RowsColumnScanner interface, Close() error #67546
+pkg database/sql/driver, type RowsColumnScanner interface, Columns() []string #67546
+pkg database/sql/driver, type RowsColumnScanner interface, Next([]Value) error #67546
+pkg database/sql/driver, type RowsColumnScanner interface, ScanColumn(interface{}, int) error #67546
+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

doc/asm.html

@@ -1039,6 +1039,12 @@ 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>

doc/go_mem.html

@@ -231,7 +231,7 @@ do exactly this.
 
 <p>
 A read of an array, struct, or complex number
-may by implemented as a read of each individual sub-value
+may be 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 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.
+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.
 </p>
 
 <p>

doc/go_spec.html

@@ -1,6 +1,6 @@
 <!--{
 	"Title": "The Go Programming Language Specification",
-	"Subtitle": "Language version go1.24 (Dec 30, 2024)",
+	"Subtitle": "Language version go1.26 (Dec 2, 2025)",
 	"Path": "/ref/spec"
 }-->
 
@@ -8,8 +8,6 @@
 
 <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>
 
@@ -1858,110 +1856,10 @@ 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> or <i>different</i>.
+Two types are either <i>identical</i> ("the same") or <i>different</i>.
 </p>
 
 <p>
@@ -2589,11 +2487,15 @@ type set[P comparable] = map[P]bool
 </pre>
 
 <p>
-In an alias declaration the given type cannot be a type parameter.
+In an alias declaration the given type cannot be a type parameter declared in the same declaration.
 </p>
 
 <pre>
-type A[P any] = P    // illegal: P is a type parameter
+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
+}
 </pre>
 
 <h4 id="Type_definitions">Type definitions</h4>
@@ -2703,8 +2605,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[T any]() {
-	type L T   // illegal: T is a type parameter declared by the enclosing function
+func f[P any]() {
+	type L P   // illegal: P is a type parameter declared by the enclosing function
 }
 </pre>
 
@@ -2788,22 +2690,6 @@ 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>
@@ -3255,7 +3141,8 @@ math.Sin // denotes the Sin function in package math
 <h3 id="Composite_literals">Composite literals</h3>
 
 <p>
-Composite literals construct new composite values each time they are evaluated.
+Composite literals construct new values for structs, arrays, slices, and maps
+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>
@@ -3273,10 +3160,14 @@ Element      = Expression | LiteralValue .
 </pre>
 
 <p>
-The LiteralType's <a href="#Core_types">core type</a> <code>T</code>
+Unless the LiteralType is a type parameter,
+its <a href="#Underlying_types">underlying type</a>
 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.
@@ -3461,7 +3352,6 @@ noteFrequency := map[string]float32{
 }
 </pre>
 
-
 <h3 id="Function_literals">Function literals</h3>
 
 <p>
@@ -3934,11 +3824,12 @@ The following rules apply:
 </p>
 
 <p>
-If <code>a</code> is neither a map nor a type parameter:
+If <code>a</code> is neither a map nor a <a href="#Type_parameter_declarations">type parameter</a>:
 </p>
 <ul>
-	<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>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>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>
@@ -4052,14 +3943,26 @@ 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. There are two variants: a simple form that specifies a low
+to array, or slice operand.
+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>
-The primary expression
+For a string, array, pointer to array, or slice <code>a</code>, the primary expression
 </p>
 
 <pre>
@@ -4067,9 +3970,7 @@ a[low : high]
 </pre>
 
 <p>
-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>.
+constructs a substring or slice.
 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
@@ -4149,7 +4050,7 @@ s3 := s[:0]    // s3 == nil
 <h4>Full slice expressions</h4>
 
 <p>
-The primary expression
+For an array, pointer to array, or slice <code>a</code> (but not a string), the primary expression
 </p>
 
 <pre>
@@ -4160,8 +4061,6 @@ 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>
 
@@ -4267,8 +4166,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> with a <a href="#Core_types">core type</a>
-<code>F</code> of <a href="#Function_types">function type</a>,
+Given an expression <code>f</code> of <a href="#Function_types">function type</a>
+<code>F</code>,
 </p>
 
 <pre>
@@ -4298,6 +4197,12 @@ 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>.
@@ -4811,17 +4716,28 @@ more complicated:
 
 <ul>
 <li>
-	If <code>C</code> has a <a href="#Core_types">core type</a>
-	<code>core(C)</code>
+	If all types in <code>C</code>'s type set have the same
+	underlying type <code>U</code>,
 	and <code>P</code> has a known type argument <code>A</code>,
-	<code>core(C)</code> and <code>A</code> must unify loosely.
+	<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>
 	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 core type
+	If <code>C</code> does not have a type <code>U</code>
+	as described above
 	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.
@@ -4945,7 +4861,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)) && ((<-chanInt) > 0)
+x == y+1 &amp;&amp; &lt;-chanInt &gt; 0  // (x == (y+1)) &amp;&amp; ((&lt;-chanInt) > 0)
 </pre>
 
 
@@ -5372,10 +5288,10 @@ var x *int = nil
 <h3 id="Receive_operator">Receive operator</h3>
 
 <p>
-For an operand <code>ch</code> whose <a href="#Core_types">core type</a> is a
-<a href="#Channel_types">channel</a>,
+For an operand <code>ch</code> of <a href="#Channel_types">channel type</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.
@@ -5391,6 +5307,12 @@ 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>
@@ -6126,8 +6048,7 @@ len("foo")  // illegal if len is the built-in function
 
 <p>
 A send statement sends a value on a channel.
-The channel expression's <a href="#Core_types">core type</a>
-must be a <a href="#Channel_types">channel</a>,
+The channel expression must be of <a href="#Channel_types">channel type</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.
@@ -6151,6 +6072,13 @@ 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>
 
@@ -6695,7 +6623,7 @@ iteration's variable at that moment.
 
 <pre>
 var prints []func()
-for i := 0; i < 5; i++ {
+for i := 0; i &lt; 5; i++ {
 	prints = append(prints, func() { println(i) })
 	i++
 }
@@ -6743,8 +6671,7 @@ RangeClause = [ ExpressionList "=" | IdentifierList ":=" ] "range" Expression .
 
 <p>
 The expression on the right in the "range" clause is called the <i>range expression</i>,
-its <a href="#Core_types">core type</a> must be
-an array, pointer to an array, slice, string, map, channel permitting
+which may 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
@@ -6833,7 +6760,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>
@@ -6944,7 +6871,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) && yield(t.key, t.value) && t.right.walk(yield)
+	return t == nil || t.left.walk(yield) &amp;&amp; yield(t.key, t.value) &amp;&amp; t.right.walk(yield)
 }
 
 func (t *Tree[K, V]) Walk(yield func(key K, val V) bool) {
@@ -6958,6 +6885,12 @@ 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>
 
@@ -7431,23 +7364,28 @@ 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>
-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>.
+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>.
 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, 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.
+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.
 </p>
 
 <pre class="grammar">
-append(s S, x ...E) S  // core type of S is []E
+append(s S, x ...E) S  // E is the element type of S
 </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
@@ -7473,14 +7411,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.
-The <a href="#Core_types">core types</a> of both arguments must be slices
-with <a href="#Type_identity">identical</a> element type.
+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 number of elements copied is the minimum of
 <code>len(src)</code> and <code>len(dst)</code>.
-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.
+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.
 </p>
 
 <pre class="grammar">
@@ -7488,6 +7426,11 @@ 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>
@@ -7538,8 +7481,7 @@ If the map or slice is <code>nil</code>, <code>clear</code> is a no-op.
 <h3 id="Close">Close</h3>
 
 <p>
-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>
+For a channel <code>ch</code>, the built-in function <code>close(ch)</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>.
@@ -7551,6 +7493,12 @@ 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>
 
@@ -7720,16 +7668,15 @@ 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             Core type    Result
+Call             Type T            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
@@ -7739,8 +7686,18 @@ make(T, n)       map          map of type T with initial space for approximately
 
 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
 </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,
@@ -7830,27 +7787,39 @@ compared lexically byte-wise:
 </p>
 
 <pre>
-min(x, y)    == if x <= y then x else y
+min(x, y)    == if x &lt;= 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> 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>.
+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.
 </p>
 
-<pre class="grammar">
-new(T)
-</pre>
+<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>
 
 <p>
-For instance
+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
 </p>
 
 <pre>
@@ -7859,13 +7828,12 @@ new(S)
 </pre>
 
 <p>
-allocates storage for a variable of type <code>S</code>,
+allocates 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 location.
+of the variable.
 </p>
 
-
 <h3 id="Handling_panics">Handling panics</h3>
 
 <p> Two built-in functions, <code>panic</code> and <code>recover</code>,
@@ -7925,7 +7893,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 raised by <code>g</code>.
+run-time panics caused by <code>g</code>.
 </p>
 
 <pre>
@@ -8483,17 +8451,14 @@ 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="#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.
+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.
 The effect of converting between <code>Pointer</code> and <code>uintptr</code> is implementation-defined.
 </p>
 
@@ -8847,9 +8812,9 @@ following conditions is true:
 </li>
 <li>
 	Exactly one type is an <a href="#Type_inference">unbound</a>
-	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>
+	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>
 	(loose unification at the top level and exact unification
 	for element types).
 </li>

doc/godebug.md

@@ -109,7 +109,9 @@ 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.)
+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.
 
 The defaults from the `go` and `godebug` lines apply to all main
 packages that are built. For more fine-grained control,
@@ -151,8 +153,90 @@ 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
+Cryptographic Module operates in FIPS 140-3 mode.
+The possible values are:
+- "off": no special support for FIPS 140-3 mode. This is the default.
+- "on": the Go Cryptographic Module operates in FIPS 140-3 mode.
+- "only": like "on", but cryptographic algorithms not approved by
+  FIPS 140-3 return an error or panic.
+For more information, see [FIPS 140-3 Compliance](/doc/security/fips140).
+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.24 changed the global [`math/rand.Seed`](/pkg/math/rand/#Seed) to be a
 no-op. This behavior is controlled by the `randseednop` setting.
 For Go 1.24 it defaults to `randseednop=1`.
@@ -206,6 +290,8 @@ 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)
@@ -220,7 +306,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 may be removed in a future release, Go 1.27 at the earliest.
+This setting will be removed in Go 1.27.
 
 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.
@@ -242,6 +328,8 @@ 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
@@ -255,6 +343,7 @@ 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
@@ -262,6 +351,7 @@ 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),
@@ -295,28 +385,31 @@ 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 a future release, Go 1.27 at the earliest.
+This setting will be removed in Go 1.27.
 
 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_Variable).
+[`disablethp` setting](/pkg/runtime#hdr-Environment_Variables).
 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
@@ -328,7 +421,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_Variable). These stack traces have
+setting](/pkg/runtime#hdr-Environment_Variables). 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)
@@ -337,7 +430,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

doc/initial/6-stdlib/99-minor/0-heading.md

@@ -1,3 +1 @@
 ### Minor changes to the library {#minor_library_changes}
-
-

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 and unpacked
+# make v1.2.3.rm removes the zip file and unpacked
 # copy from the module cache.
 v%.rm:
 	rm -f v$*.zip

lib/fips140/fips140.sum

@@ -9,4 +9,4 @@
 #
 #	go test cmd/go/internal/fips140 -update
 #
-v1.0.0.zip b50508feaeff05d22516b21e1fd210bbf5d6a1e422eaf2cfa23fe379342713b8
+v1.0.0-c2097c7c.zip daf3614e0406f67ae6323c902db3f953a1effb199142362a039e7526dfb9368b

lib/fips140/inprocess.txt

@@ -0,0 +1 @@
+v1.0.0-c2097c7c

lib/fips140/v1.0.0.txt

@@ -0,0 +1 @@
+v1.0.0-c2097c7c

lib/hg/goreposum.py

@@ -0,0 +1,64 @@
+# 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'))

lib/time/update.bash

@@ -24,8 +24,8 @@
 # in the CL match the update.bash in the CL.
 
 # Versions to use.
-CODE=2025a
-DATA=2025a
+CODE=2025b
+DATA=2025b
 
 set -e
 
@@ -40,7 +40,12 @@ 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
 
-if ! make CFLAGS=-DSTD_INSPIRED AWK=awk TZDIR=zoneinfo posix_only >make.out 2>&1; then
+# 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
 	cat make.out
 	exit 2
 fi

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=1048576 ${GOWASIRUNTIMEARGS:-} "$1" "${@:2}"
+		exec wasmtime run --dir=/ --env PWD="$PWD" --env PATH="$PATH" -W max-wasm-stack=8388608 ${GOWASIRUNTIMEARGS:-} "$1" "${@:2}"
 		;;
 	*)
 		echo "Unknown Go WASI runtime specified: $GOWASIRUNTIME"

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.Split(finalPkgpath, string(filepath.Separator)) {
+	for element := range strings.SplitSeq(finalPkgpath, string(filepath.Separator)) {
 		if debug {
 			log.Printf("copying %s", pkgpath)
 		}

misc/linkcheck/linkcheck.go

@@ -1,191 +0,0 @@
-// 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)
-	}
-}

src/all.bash

@@ -10,4 +10,4 @@ if [ ! -f make.bash ]; then
 fi
 . ./make.bash "$@" --no-banner
 bash run.bash --no-rebuild
-"$GOTOOLDIR/dist" banner  # print build info
+../bin/go tool dist banner # print build info

src/all.bat

@@ -6,17 +6,11 @@
 
 setlocal
 
-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
+if not exist make.bat (
+    echo all.bat must be run from go\src
+    exit /b 1
+)
 
-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%
+call .\make.bat --no-banner || exit /b 1
+call .\run.bat --no-rebuild || exit /b 1
+..\bin\go tool dist banner

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
-$GOTOOLDIR/dist banner  # print build info
+../bin/go tool dist banner # print build info

src/archive/tar/common.go

@@ -39,6 +39,7 @@ 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

src/archive/tar/reader.go

@@ -531,12 +531,17 @@ 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
 			}
@@ -569,8 +574,8 @@ func readGNUSparseMap1x0(r io.Reader) (sparseDatas, error) {
 	}
 
 	// Parse for all member entries.
-	// numEntries is trusted after this since a potential attacker must have
-	// committed resources proportional to what this library used.
+	// numEntries is trusted after this since feedTokens limits the number of
+	// tokens based on maxSpecialFileSize.
 	if err := feedTokens(2 * numEntries); err != nil {
 		return nil, err
 	}

src/archive/tar/reader_test.go

@@ -621,6 +621,11 @@ 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 {

src/archive/tar/strconv.go

@@ -213,15 +213,17 @@ func parsePAXTime(s string) (time.Time, error) {
 	}
 
 	// Parse the nanoseconds.
-	if strings.Trim(sn, "0123456789") != "" {
+	// 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 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
+	nsecs, _ := strconv.ParseInt(string(nanoDigits[:]), 10, 64) // Must succeed after validation
 	if len(ss) > 0 && ss[0] == '-' {
 		return time.Unix(secs, -1*nsecs), nil // Negative correction
 	}

src/archive/tar/strconv_test.go

@@ -439,3 +439,66 @@ 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)
+				}
+			}
+		})
+	}
+}

src/archive/tar/writer.go

@@ -415,11 +415,17 @@ func (tw *Writer) AddFS(fsys fs.FS) error {
 		if err != nil {
 			return err
 		}
-		// TODO(#49580): Handle symlinks when fs.ReadLinkFS is available.
-		if !d.IsDir() && !info.Mode().IsRegular() {
+		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 {
 			return errors.New("tar: cannot add non-regular file")
 		}
-		h, err := FileInfoHeader(info, "")
+		h, err := FileInfoHeader(info, linkTarget)
 		if err != nil {
 			return err
 		}
@@ -430,7 +436,7 @@ func (tw *Writer) AddFS(fsys fs.FS) error {
 		if err := tw.WriteHeader(h); err != nil {
 			return err
 		}
-		if d.IsDir() {
+		if !d.Type().IsRegular() {
 			return nil
 		}
 		f, err := fsys.Open(name)

src/archive/tar/writer_test.go

@@ -1342,6 +1342,7 @@ 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.
 	}
@@ -1370,7 +1371,7 @@ func TestWriterAddFS(t *testing.T) {
 	for _, name := range names {
 		entriesLeft--
 
-		entryInfo, err := fsys.Stat(name)
+		entryInfo, err := fsys.Lstat(name)
 		if err != nil {
 			t.Fatalf("getting entry info error: %v", err)
 		}
@@ -1396,18 +1397,23 @@ func TestWriterAddFS(t *testing.T) {
 				name, entryInfo.Mode(), hdr.FileInfo().Mode())
 		}
 
-		if entryInfo.IsDir() {
-			continue
+		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",
-				data, origdata)
+				t.Fatalf("test fs has file content %v; archive header has %v", origdata, data)
+			}
 		}
 	}
 	if entriesLeft > 0 {

src/archive/zip/reader.go

@@ -8,6 +8,7 @@ import (
 	"bufio"
 	"encoding/binary"
 	"errors"
+	"fmt"
 	"hash"
 	"hash/crc32"
 	"internal/godebug"
@@ -804,6 +805,9 @@ 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.
@@ -985,6 +989,12 @@ 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
 	}

src/archive/zip/reader_test.go

@@ -8,6 +8,7 @@ import (
 	"bytes"
 	"encoding/binary"
 	"encoding/hex"
+	"errors"
 	"internal/obscuretestdata"
 	"io"
 	"io/fs"
@@ -1212,7 +1213,6 @@ 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,7 +1246,6 @@ func TestFSWalk(t *testing.T) {
 			wantErr: true,
 		},
 	} {
-		test := test
 		t.Run(test.file, func(t *testing.T) {
 			t.Parallel()
 			z, err := OpenReader(test.file)
@@ -1281,6 +1280,49 @@ 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")

src/bufio/bufio.go

@@ -311,10 +311,7 @@ func (b *Reader) ReadRune() (r rune, size int, err error) {
 	if b.r == b.w {
 		return 0, 0, b.readErr()
 	}
-	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
@@ -519,10 +516,12 @@ 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
 		}
+	}
 
 	if r, ok := b.rd.(io.WriterTo); ok {
 		m, err := r.WriteTo(w)

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.ErrClosedPipe},
+	{0, 0, io.ErrUnexpectedEOF, io.ErrClosedPipe, io.ErrUnexpectedEOF},
 	{0, 1, io.EOF, nil, nil},
 }
 

src/bufio/net_test.go

@@ -0,0 +1,96 @@
+// 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))
+	}
+}

src/bufio/scan.go

@@ -260,8 +260,11 @@ func (s *Scanner) setErr(err error) {
 	}
 }
 
-// Buffer sets the initial buffer to use when scanning
+// Buffer controls memory allocation by the Scanner.
+// It 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.
 //

src/bytes/buffer.go

@@ -21,6 +21,12 @@ 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
@@ -71,6 +77,18 @@ 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 }
 

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,6 +531,40 @@ 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
 

src/bytes/bytes.go

@@ -451,7 +451,9 @@ 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.
+// 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.
 func Fields(s []byte) [][]byte {
 	// First count the fields.
 	// This is an exact count if s is ASCII, otherwise it is an approximation.
@@ -505,7 +507,9 @@ 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.
+// 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.
 //
 // 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.
@@ -524,11 +528,7 @@ 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); {
-		size := 1
-		r := rune(s[i])
-		if r >= utf8.RuneSelf {
-			r, size = utf8.DecodeRune(s[i:])
-		}
+		r, size := utf8.DecodeRune(s[i:])
 		if f(r) {
 			if start >= 0 {
 				spans = append(spans, span{start, i})
@@ -610,11 +610,7 @@ 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); {
-		wid := 1
-		r := rune(s[i])
-		if r >= utf8.RuneSelf {
-			r, wid = utf8.DecodeRune(s[i:])
-		}
+		r, wid := utf8.DecodeRune(s[i:])
 		r = mapping(r)
 		if r >= 0 {
 			b = utf8.AppendRune(b, r)
@@ -913,11 +909,7 @@ 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) {
-		wid := 1
-		r := rune(s[start])
-		if r >= utf8.RuneSelf {
-			r, wid = utf8.DecodeRune(s[start:])
-		}
+		r, wid := utf8.DecodeRune(s[start:])
 		if f(r) == truth {
 			return start
 		}
@@ -1048,10 +1040,7 @@ func trimLeftASCII(s []byte, as *asciiSet) []byte {
 
 func trimLeftUnicode(s []byte, cutset string) []byte {
 	for len(s) > 0 {
-		r, n := rune(s[0]), 1
-		if r >= utf8.RuneSelf {
-			r, n = utf8.DecodeRune(s)
-		}
+		r, n := utf8.DecodeRune(s)
 		if !containsRune(cutset, r) {
 			break
 		}
@@ -1113,41 +1102,34 @@ 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
-	start := 0
-	for ; start < len(s); start++ {
-		c := s[start]
+	// Fast path for ASCII: look for the first ASCII non-space byte.
+	for lo, c := range s {
 		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[start:], unicode.IsSpace)
+			// slower unicode-aware method on the remaining bytes.
+			return TrimFunc(s[lo:], unicode.IsSpace)
 		}
-		if asciiSpace[c] == 0 {
-			break
+		if asciiSpace[c] != 0 {
+			continue
 		}
-	}
-
-	// Now look for the first ASCII non-space byte from the end
-	stop := len(s)
-	for ; stop > start; stop-- {
-		c := s[stop-1]
+		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[start:stop], unicode.IsSpace)
+				return TrimFunc(s[:hi+1], unicode.IsSpace)
 			}
 			if asciiSpace[c] == 0 {
-			break
+				// 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]
+			}
 		}
 	}
-
-	// 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.
@@ -1188,20 +1170,23 @@ func Replace(s, old, new []byte, n int) []byte {
 	t := make([]byte, len(s)+n*(len(new)-len(old)))
 	w := 0
 	start := 0
-	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)
-		}
+	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)
 		}
+	} else { // len(old) == 0
+		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
+		}
+	}
 	w += copy(t[w:], s[start:])
 	return t[0:w]
 }
@@ -1221,7 +1206,7 @@ func ReplaceAll(s, old, new []byte) []byte {
 func EqualFold(s, t []byte) bool {
 	// ASCII fast path
 	i := 0
-	for ; i < len(s) && i < len(t); i++ {
+	for n := min(len(s), len(t)); i < n; i++ {
 		sr := s[i]
 		tr := t[i]
 		if sr|tr >= utf8.RuneSelf {
@@ -1251,19 +1236,10 @@ hasUnicode:
 	t = t[i:]
 	for len(s) != 0 && len(t) != 0 {
 		// Extract first rune from each.
-		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:]
-		}
+		sr, size := utf8.DecodeRune(s)
+		s = s[size:]
+		tr, size := utf8.DecodeRune(t)
+		t = t[size:]
 
 		// If they match, keep going; if not, return false.
 

src/bytes/bytes_test.go

@@ -7,6 +7,7 @@ package bytes_test
 import (
 	. "bytes"
 	"fmt"
+	"internal/asan"
 	"internal/testenv"
 	"iter"
 	"math"
@@ -692,14 +693,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, rune(r))
+				rs = append(rs, 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, rune(r))
+				rs = append(rs, r)
 			}
 		}
 	}
@@ -890,9 +891,7 @@ func BenchmarkCountSingle(b *testing.B) {
 				b.Fatal("bad count", j, expect)
 			}
 		}
-		for i := 0; i < len(buf); i++ {
-			buf[i] = 0
-		}
+		clear(buf)
 	})
 }
 
@@ -1786,9 +1785,20 @@ var ReplaceTests = []ReplaceTest{
 
 func TestReplace(t *testing.T) {
 	for _, tt := range ReplaceTests {
-		in := append([]byte(tt.in), "<spare>"...)
+		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 = in[:len(tt.in)]
-		out := Replace(in, []byte(tt.old), []byte(tt.new), tt.n)
+		out := Replace(in, old, 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)
 		}
@@ -1796,7 +1806,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, []byte(tt.old), []byte(tt.new))
+			out := ReplaceAll(in, old, 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)
 			}
@@ -1804,6 +1814,69 @@ 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
 }
@@ -2053,8 +2126,9 @@ 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 rand.Intn(10) {
+		switch r.Intn(10) {
 		case 0:
 			x[i] = ' '
 		case 1:
@@ -2073,8 +2147,9 @@ 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 rand.Intn(10) == 0 {
+		if r.Intn(10) == 0 {
 			x[i] = ' '
 		} else {
 			x[i] = 'x'
@@ -2171,8 +2246,9 @@ func makeBenchInputHard() []byte {
 		"hello", "world",
 	}
 	x := make([]byte, 0, 1<<20)
+	r := rand.New(rand.NewSource(99))
 	for {
-		i := rand.Intn(len(tokens))
+		i := r.Intn(len(tokens))
 		if len(x)+len(tokens[i]) >= 1<<20 {
 			break
 		}

src/bytes/example_test.go

@@ -245,9 +245,9 @@ func ExampleCut() {
 }
 
 func ExampleCutPrefix() {
-	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 := 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("Gopher", "Go")
 	show("Gopher", "ph")
@@ -257,9 +257,9 @@ func ExampleCutPrefix() {
 }
 
 func ExampleCutSuffix() {
-	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 := 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("Gopher", "Go")
 	show("Gopher", "er")
@@ -628,3 +628,93 @@ 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"
+}

src/bytes/iter.go

@@ -28,13 +28,14 @@ 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] {
+// 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] {
 	return func(yield func([]byte) bool) {
+		if len(sep) == 0 {
 			for len(s) > 0 {
 				_, size := utf8.DecodeRune(s)
 				if !yield(s[:size:size]) {
@@ -42,16 +43,8 @@ func explodeSeq(s []byte) iter.Seq[[]byte] {
 				}
 				s = s[size:]
 			}
+			return
 		}
-}
-
-// 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) {
 		for {
 			i := Index(s, sep)
 			if i < 0 {
@@ -67,26 +60,26 @@ func splitSeq(s, sep []byte, sepSave int) iter.Seq[[]byte] {
 	}
 }
 
-// SplitSeq returns an iterator over all substrings of s separated by sep.
-// The iterator yields the same strings that would be returned by [Split](s, sep),
-// but without constructing the slice.
+// SplitSeq returns an iterator over all subslices of s separated by sep.
+// The iterator yields the same subslices that would be returned by [Split](s, sep),
+// but without constructing a new slice containing the subslices.
 // It returns a single-use iterator.
 func SplitSeq(s, sep []byte) iter.Seq[[]byte] {
 	return splitSeq(s, sep, 0)
 }
 
-// SplitAfterSeq returns an iterator over substrings of s split after each instance of sep.
-// The iterator yields the same strings that would be returned by [SplitAfter](s, sep),
-// but without constructing the slice.
+// SplitAfterSeq returns an iterator over subslices of s split after each instance of sep.
+// The iterator yields the same subslices that would be returned by [SplitAfter](s, sep),
+// but without constructing a new slice containing the subslices.
 // It returns a single-use iterator.
 func SplitAfterSeq(s, sep []byte) iter.Seq[[]byte] {
 	return splitSeq(s, sep, len(sep))
 }
 
-// FieldsSeq returns an iterator over substrings of s split around runs of
+// FieldsSeq returns an iterator over subslices of s split around runs of
 // whitespace characters, as defined by [unicode.IsSpace].
-// The iterator yields the same strings that would be returned by [Fields](s),
-// but without constructing the slice.
+// The iterator yields the same subslices that would be returned by [Fields](s),
+// but without constructing a new slice containing the subslices.
 func FieldsSeq(s []byte) iter.Seq[[]byte] {
 	return func(yield func([]byte) bool) {
 		start := -1
@@ -116,19 +109,15 @@ func FieldsSeq(s []byte) iter.Seq[[]byte] {
 	}
 }
 
-// FieldsFuncSeq returns an iterator over substrings of s split around runs of
+// FieldsFuncSeq returns an iterator over subslices of s split around runs of
 // Unicode code points satisfying f(c).
-// The iterator yields the same strings that would be returned by [FieldsFunc](s),
-// but without constructing the slice.
+// The iterator yields the same subslices that would be returned by [FieldsFunc](s),
+// but without constructing a new slice containing the subslices.
 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); {
-			size := 1
-			r := rune(s[i])
-			if r >= utf8.RuneSelf {
-				r, size = utf8.DecodeRune(s[i:])
-			}
+			r, size := utf8.DecodeRune(s[i:])
 			if f(r) {
 				if start >= 0 {
 					if !yield(s[start:i:i]) {

src/bytes/iter_test.go

@@ -0,0 +1,56 @@
+// 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) {
+		}
+	}
+}

src/clean.bat

@@ -6,27 +6,16 @@
 
 setlocal
 
-set GOBUILDFAIL=0
-
-go tool dist env -w -p >env.bat
-if errorlevel 1 goto fail
+go tool dist env -w -p >env.bat || exit /b 1
 call .\env.bat
 del env.bat
 echo.
 
-if exist %GOTOOLDIR%\dist.exe goto distok
-echo cannot find %GOTOOLDIR%\dist; nothing to clean
-goto fail
-:distok
+if not exist %GOTOOLDIR%\dist.exe (
+    echo cannot find %GOTOOLDIR%\dist.exe; nothing to clean
+    exit /b 1
+)
 
 "%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%

src/cmd/api/api_test.go

@@ -99,6 +99,11 @@ 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
@@ -180,6 +185,11 @@ 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
@@ -294,14 +304,20 @@ 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)

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.Type().(*types.Signature)))
+		w.emitf("%s%s", m.Name(), w.signatureString(m.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.Type().(*types.Signature)
+	sig := f.Signature()
 	if sig.Recv() != nil {
 		panic("method considered a regular function: " + f.String())
 	}

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(int8, int16, int64)
 pkg p1, method (*S2) SMethod //deprecated
+pkg p1, method (*S2) SMethod(int8, int16, int64)
 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(string) int64
 pkg p1, type I interface, Get //deprecated
+pkg p1, type I interface, Get(string) int64
 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 struct
 pkg p1, type URL //deprecated
+pkg p1, type URL struct
 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 Error
 pkg p1, var VError //deprecated
+pkg p1, var VError Error
 pkg p1, var X I
 pkg p1, var X0 int64
 pkg p1, var Y int

src/cmd/api/testdata/src/pkg/p2/golden.txt

@@ -1,8 +1,7 @@
-pkg p2, func F() string
 pkg p2, func F //deprecated
+pkg p2, func F() string
 pkg p2, func G() Twoer
 pkg p2, func NewError(string) error
 pkg p2, type Twoer interface { PackageTwoMeth }
-pkg p2, type Twoer interface, PackageTwoMeth()
 pkg p2, type Twoer interface, PackageTwoMeth //deprecated
-
+pkg p2, type Twoer interface, PackageTwoMeth()

src/cmd/api/testdata/src/pkg/p4/golden.txt

@@ -1,6 +1,6 @@
-pkg p4, func NewPair[$0 interface{ M }, $1 interface{ ~int }]($0, $1) Pair[$0, $1]
-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
+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, type Pair[$0 interface{ M }, $1 interface{ ~int }] struct

src/cmd/asm/internal/arch/arch.go

@@ -92,7 +92,8 @@ 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", "JAL", "JALR", "JMP":
+		"BLT", "BLTU", "BLTZ", "BNE", "BNEZ", "CALL", "CBEQZ", "CBNEZ", "CJ", "CJALR", "CJR",
+		"JAL", "JALR", "JMP":
 		return true
 	}
 	return false

src/cmd/asm/internal/arch/arm64.go

@@ -59,10 +59,10 @@ func jumpArm64(word string) bool {
 
 var arm64SpecialOperand map[string]arm64.SpecialOperand
 
-// GetARM64SpecialOperand returns the internal representation of a special operand.
-func GetARM64SpecialOperand(name string) arm64.SpecialOperand {
+// ARM64SpecialOperand returns the internal representation of a special operand.
+func ARM64SpecialOperand(name string) arm64.SpecialOperand {
 	if arm64SpecialOperand == nil {
-		// Generate the mapping automatically when the first time the function is called.
+		// Generate mapping when function is first called.
 		arm64SpecialOperand = map[string]arm64.SpecialOperand{}
 		for opd := arm64.SPOP_BEGIN; opd < arm64.SPOP_END; opd++ {
 			arm64SpecialOperand[opd.String()] = opd
@@ -195,149 +195,6 @@ 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

src/cmd/asm/internal/arch/loong64.go

@@ -23,18 +23,6 @@ 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.
@@ -46,6 +34,14 @@ 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)
 }

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 the op (as defined by a riscv.A*
-// constant) is one of the AMO instructions that requires special
-// handling.
+// IsRISCV64AMO reports whether op is an AMO instruction 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,3 +26,59 @@ 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
+}

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, int(sz), valueAddr.Offset)
+			nameAddr.Sym.WriteInt(p.ctxt, nameAddr.Offset, 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, int(sz), valueAddr.Val.(string))
+		nameAddr.Sym.WriteString(p.ctxt, nameAddr.Offset, sz, valueAddr.Val.(string))
 	case obj.TYPE_ADDR:
 		if sz == p.arch.PtrSize {
-			nameAddr.Sym.WriteAddr(p.ctxt, nameAddr.Offset, int(sz), valueAddr.Sym, valueAddr.Offset)
+			nameAddr.Sym.WriteAddr(p.ctxt, nameAddr.Offset, sz, valueAddr.Sym, valueAddr.Offset)
 		} else {
 			p.errorf("bad addr size for DATA argument: %d", sz)
 		}
@@ -654,6 +654,12 @@ 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]
@@ -670,6 +676,11 @@ 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])
@@ -771,6 +782,21 @@ 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]
@@ -915,6 +941,19 @@ 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))
@@ -950,14 +989,6 @@ 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 {
@@ -965,3 +996,11 @@ 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
+}

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 ...interface{}) {
+	ctxt.DiagFunc = func(format string, args ...any) {
 		failed = true
 		t.Errorf(format, args...)
 	}
@@ -193,7 +193,7 @@ Diff:
 	top := pList.Firstpc
 	var text *obj.LSym
 	ok = true
-	ctxt.DiagFunc = func(format string, args ...interface{}) {
+	ctxt.DiagFunc = func(format string, args ...any) {
 		t.Errorf(format, args...)
 		ok = false
 	}
@@ -294,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 ...interface{}) {
+	ctxt.DiagFunc = func(format string, args ...any) {
 		failed = true
 		s := fmt.Sprintf(format, args...)
 		if !strings.HasSuffix(s, "\n") {
@@ -465,9 +465,16 @@ 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} {
@@ -487,6 +494,10 @@ func TestRISCVErrors(t *testing.T) {
 	testErrors(t, "riscv64", "riscv64error")
 }
 
+func TestRISCVValidation(t *testing.T) {
+	testErrors(t, "riscv64", "riscv64validation")
+}
+
 func TestS390XEndToEnd(t *testing.T) {
 	testEndToEnd(t, "s390x", "s390x")
 }

src/cmd/asm/internal/asm/parse.go

@@ -21,6 +21,7 @@ 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"
@@ -77,7 +78,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 ...interface{}) {
+func (p *Parser) errorf(format string, args ...any) {
 	if panicOnError {
 		panic(fmt.Errorf(format, args...))
 	}
@@ -89,7 +90,7 @@ func (p *Parser) errorf(format string, args ...interface{}) {
 	if p.lex != nil {
 		// Put file and line information on head of message.
 		format = "%s:%d: " + format + "\n"
-		args = append([]interface{}{p.lex.File(), p.lineNum}, args...)
+		args = append([]any{p.lex.File(), p.lineNum}, args...)
 	}
 	fmt.Fprintf(p.errorWriter, format, args...)
 	p.errorCount++
@@ -398,16 +399,21 @@ 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:
-			// arm64 special operands.
-			if opd := arch.GetARM64SpecialOperand(name); opd != arm64.SPOP_END {
+			if opd := arch.ARM64SpecialOperand(name); opd != arm64.SPOP_END {
 				a.Type = obj.TYPE_SPECIAL
 				a.Offset = int64(opd)
-				break
 			}
-			fallthrough
-		default:
+		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 {
 			// We have a symbol. Parse $sym±offset(symkind)
 			p.symbolReference(a, p.qualifySymbol(name), prefix)
 		}
@@ -769,7 +775,7 @@ func (p *Parser) registerExtension(a *obj.Addr, name string, prefix rune) {
 
 	switch p.arch.Family {
 	case sys.ARM64:
-		err := arch.ARM64RegisterExtension(a, ext, reg, num, isAmount, isIndex)
+		err := arm64.ARM64RegisterExtension(a, ext, reg, num, isAmount, isIndex)
 		if err != nil {
 			p.errorf("%v", err)
 		}

src/cmd/asm/internal/asm/testdata/amd64dynlinkerror.s

@@ -169,3 +169,8 @@ 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

src/cmd/asm/internal/asm/testdata/amd64enc_extra.s

@@ -1059,5 +1059,7 @@ TEXT asmtest(SB),DUPOK|NOSPLIT,$0
 	RDPID DX                                // f30fc7fa
 	RDPID R11                               // f3410fc7fb
 
+	ENDBR64					// f30f1efa
+
 	// End of tests.
 	RET

src/cmd/asm/internal/asm/testdata/arm64.s

@@ -400,6 +400,8 @@ 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
@@ -630,6 +632,8 @@ 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
@@ -643,6 +647,8 @@ 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
@@ -1888,4 +1894,18 @@ 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

src/cmd/asm/internal/asm/testdata/arm64error.s

@@ -420,4 +420,12 @@ 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

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			// 1e048002c4a71401
+	MOVW	$1, F4			// 1e048003c4a71401
 	TEQ	$4, R4, R5		// 8508005c04002a00
 	TEQ	$4, R4			// 0408005c04002a00
 	TNE	$4, R4, R5		// 8508005804002a00
@@ -21,6 +21,10 @@ 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
@@ -37,10 +41,6 @@ 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,3 +77,49 @@ 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

src/cmd/asm/internal/asm/testdata/loong64enc3.s

@@ -11,12 +11,16 @@ 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
@@ -42,8 +46,10 @@ 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)			// 1e020014de971000c4030021
-	SC	R4, 4096(R5)	   		// 3e000014de971000c4030021
+	SC	R4, 65536(R5)			// 1e040010de971000c4030021
+	SCV	R4, 65536(R5)			// 1e040010de971000c4030023
+	LL	65536(R5), R4			// 1e040010de971000c4030020
+	LLV	65536(R5), R4			// 1e040010de971000c4030022
 	MOVW	y+65540(FP), R4			// 1e020014de8f1000c4338028
 	MOVWU	y+65540(FP), R4			// 1e020014de8f1000c433802a
 	MOVV	y+65540(FP), R4			// 1e020014de8f1000c433c028
@@ -105,10 +111,6 @@ 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
@@ -121,3 +123,83 @@ 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

src/cmd/asm/internal/asm/testdata/loong64enc4.s

@@ -0,0 +1,42 @@
+// 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

src/cmd/asm/internal/asm/testdata/loong64enc5.s

@@ -0,0 +1,22 @@
+// 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
+

src/cmd/asm/internal/asm/testdata/loong64enc6.s

@@ -0,0 +1,12 @@
+// 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

src/cmd/asm/internal/asm/testdata/loong64error.s

@@ -0,0 +1,14 @@
+// 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."
+

src/cmd/asm/internal/asm/testdata/riscv64error.s

@@ -3,6 +3,27 @@
 // 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"
@@ -30,6 +51,8 @@ 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"
@@ -43,7 +66,355 @@ 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

src/cmd/asm/internal/asm/testdata/riscv64validation.s

@@ -0,0 +1,601 @@
+// 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

src/cmd/asm/internal/asm/testdata/s390x.s

@@ -263,10 +263,15 @@ 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
-	MVC	$256, 8192(R1), 8192(R2) // b90400a2c2a800002000b90400b1c2b800002000d2ffa000b000
+	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
 
 	CMP	R1, R2                 // b9200012
 	CMP	R3, $32767             // a73f7fff
@@ -401,6 +406,7 @@ 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
@@ -534,6 +540,18 @@ 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)

src/cmd/asm/internal/flags/flags.go

@@ -29,6 +29,7 @@ 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"`
 }
@@ -47,6 +48,8 @@ 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.

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 ...interface{}) {
+func (in *Input) Error(args ...any) {
 	if panicOnError {
 		panic(fmt.Errorf("%s:%d: %s", in.File(), in.Line(), fmt.Sprintln(args...)))
 	}
@@ -77,7 +77,7 @@ func (in *Input) Error(args ...interface{}) {
 }
 
 // expectText is like Error but adds "got XXX" where XXX is a quoted representation of the most recent token.
-func (in *Input) expectText(args ...interface{}) {
+func (in *Input) expectText(args ...any) {
 	in.Error(append(args, "; got", strconv.Quote(in.Stack.Text()))...)
 }
 

src/cmd/asm/main.go

@@ -40,6 +40,7 @@ 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
@@ -49,6 +50,7 @@ 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)
@@ -57,7 +59,7 @@ func main() {
 		// nothing
 	case "index":
 		// known to compiler; ignore here so people can use
-		// the same list with -gcflags=-spectre=LIST and -asmflags=-spectrre=LIST
+		// the same list with -gcflags=-spectre=LIST and -asmflags=-spectre=LIST
 	case "all", "ret":
 		ctxt.Retpoline = true
 	}
@@ -92,7 +94,7 @@ func main() {
 	for _, f := range flag.Args() {
 		lexer := lex.NewLexer(f)
 		parser := asm.NewParser(ctxt, architecture, lexer)
-		ctxt.DiagFunc = func(format string, args ...interface{}) {
+		ctxt.DiagFunc = func(format string, args ...any) {
 			diag = true
 			log.Printf(format, args...)
 		}

src/cmd/cgo/ast.go

@@ -199,7 +199,7 @@ func commentText(g *ast.CommentGroup) string {
 	return strings.Join(pieces, "")
 }
 
-func (f *File) validateIdents(x interface{}, context astContext) {
+func (f *File) validateIdents(x any, 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 interface{}, context astContext) {
 }
 
 // Save various references we are going to need later.
-func (f *File) saveExprs(x interface{}, context astContext) {
+func (f *File) saveExprs(x any, 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 interface{}, context astContext) {
+func (f *File) saveExport(x any, context astContext) {
 	n, ok := x.(*ast.FuncDecl)
 	if !ok {
 		return
@@ -318,7 +318,7 @@ func (f *File) saveExport(x interface{}, context astContext) {
 }
 
 // Make f.ExpFunc[i] point at the Func from this AST instead of the other one.
-func (f *File) saveExport2(x interface{}, context astContext) {
+func (f *File) saveExport2(x any, 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 interface{}, context astContext, visit func(*File, interface{}, astContext)) {
+func (f *File) walk(x any, context astContext, visit func(*File, any, astContext)) {
 	visit(f, x, context)
 	switch n := x.(type) {
 	case *ast.Expr:
@@ -363,7 +363,8 @@ func (f *File) walk(x interface{}, context astContext, visit func(*File, interfa
 
 	// everything else just recurs
 	default:
-		f.walkUnexpected(x, context, visit)
+		error_(token.NoPos, "unexpected type %T in walk", x)
+		panic("unexpected type")
 
 	case nil:
 
@@ -396,6 +397,9 @@ func (f *File) walk(x interface{}, context astContext, visit func(*File, interfa
 	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 {
@@ -434,8 +438,8 @@ func (f *File) walk(x interface{}, context astContext, visit func(*File, interfa
 	case *ast.StructType:
 		f.walk(n.Fields, ctxField, visit)
 	case *ast.FuncType:
-		if tparams := funcTypeTypeParams(n); tparams != nil {
-			f.walk(tparams, ctxParam, visit)
+		if n.TypeParams != nil {
+			f.walk(n.TypeParams, ctxParam, visit)
 		}
 		f.walk(n.Params, ctxParam, visit)
 		if n.Results != nil {
@@ -524,8 +528,8 @@ func (f *File) walk(x interface{}, context astContext, visit func(*File, interfa
 			f.walk(n.Values, ctxExpr, visit)
 		}
 	case *ast.TypeSpec:
-		if tparams := typeSpecTypeParams(n); tparams != nil {
-			f.walk(tparams, ctxParam, visit)
+		if n.TypeParams != nil {
+			f.walk(n.TypeParams, ctxParam, visit)
 		}
 		f.walk(&n.Type, ctxType, visit)
 

src/cmd/cgo/ast_go1.go

@@ -1,25 +0,0 @@
-// 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
-}

src/cmd/cgo/ast_go118.go

@@ -1,32 +0,0 @@
-// 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
-}

src/cmd/cgo/gcc.go

@@ -27,6 +27,7 @@ import (
 	"slices"
 	"strconv"
 	"strings"
+	"sync/atomic"
 	"unicode"
 	"unicode/utf8"
 
@@ -182,25 +183,22 @@ func splitQuoted(s string) (r []string, err error) {
 	return args, err
 }
 
-// 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) {
+// 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) {
 	for _, cref := range f.Ref {
 		// Convert C.ulong to C.unsigned long, etc.
 		cref.Name.C = cname(cref.Name.Go)
 	}
 
-	var conv typeConv
-	conv.Init(p.PtrSize, p.IntSize)
-
-	p.typedefs = map[string]bool{}
-	p.typedefList = nil
+	ft := fileTypedefs{typedefs: make(map[string]bool)}
 	numTypedefs := -1
-	for len(p.typedefs) > numTypedefs {
-		numTypedefs = len(p.typedefs)
+	for len(ft.typedefs) > numTypedefs {
+		numTypedefs = len(ft.typedefs)
 		// Also ask about any typedefs we've seen so far.
-		for _, info := range p.typedefList {
+		for _, info := range ft.typedefList {
 			if f.Name[info.typedef] != nil {
 				continue
 			}
@@ -213,7 +211,7 @@ func (p *Package) Translate(f *File) {
 		}
 		needType := p.guessKinds(f)
 		if len(needType) > 0 {
-			p.loadDWARF(f, &conv, needType)
+			f.debugs = append(f.debugs, p.loadDWARF(f, &ft, needType))
 		}
 
 		// In godefs mode we're OK with the typedefs, which
@@ -223,6 +221,18 @@ func (p *Package) Translate(f *File) {
 			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.
@@ -241,7 +251,7 @@ func (f *File) loadDefines(gccOptions []string) bool {
 	stdout := gccDefines(b.Bytes(), gccOptions)
 
 	var gccIsClang bool
-	for _, line := range strings.Split(stdout, "\n") {
+	for line := range strings.SplitSeq(stdout, "\n") {
 		if len(line) < 9 || line[0:7] != "#define" {
 			continue
 		}
@@ -279,6 +289,7 @@ 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.
@@ -417,7 +428,7 @@ func (p *Package) guessKinds(f *File) []*Name {
 		notDeclared
 	)
 	sawUnmatchedErrors := false
-	for _, line := range strings.Split(stderr, "\n") {
+	for line := range strings.SplitSeq(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
@@ -522,7 +533,8 @@ 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.
-func (p *Package) loadDWARF(f *File, conv *typeConv, names []*Name) {
+// loadDwarf is called concurrently with different files.
+func (p *Package) loadDWARF(f *File, ft *fileTypedefs, names []*Name) *debug {
 	// 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
@@ -636,13 +648,28 @@ func (p *Package) loadDWARF(f *File, conv *typeConv, names []*Name) {
 				fatalf("malformed __cgo__ name: %s", name)
 			}
 			types[i] = t.Type
-			p.recordTypedefs(t.Type, f.NamePos[names[i]])
+			ft.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" {
@@ -701,12 +728,17 @@ func (p *Package) loadDWARF(f *File, conv *typeConv, names []*Name) {
 	}
 }
 
-// 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{})
+type fileTypedefs struct {
+	typedefs    map[string]bool // type names that appear in the types of the objects we're interested in
+	typedefList []typedefInfo
 }
 
-func (p *Package) recordTypedefs1(dtype dwarf.Type, pos token.Pos, visited 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) {
 	if dtype == nil {
 		return
 	}
@@ -720,25 +752,25 @@ func (p *Package) recordTypedefs1(dtype dwarf.Type, pos token.Pos, visited map[d
 			// Don't look inside builtin types. There be dragons.
 			return
 		}
-		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)
+		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)
 		}
 	case *dwarf.PtrType:
-		p.recordTypedefs1(dt.Type, pos, visited)
+		ft.recordTypedefs1(dt.Type, pos, visited)
 	case *dwarf.ArrayType:
-		p.recordTypedefs1(dt.Type, pos, visited)
+		ft.recordTypedefs1(dt.Type, pos, visited)
 	case *dwarf.QualType:
-		p.recordTypedefs1(dt.Type, pos, visited)
+		ft.recordTypedefs1(dt.Type, pos, visited)
 	case *dwarf.FuncType:
-		p.recordTypedefs1(dt.ReturnType, pos, visited)
+		ft.recordTypedefs1(dt.ReturnType, pos, visited)
 		for _, a := range dt.ParamType {
-			p.recordTypedefs1(a, pos, visited)
+			ft.recordTypedefs1(a, pos, visited)
 		}
 	case *dwarf.StructType:
-		for _, f := range dt.Field {
-			p.recordTypedefs1(f.Type, pos, visited)
+		for _, l := range dt.Field {
+			ft.recordTypedefs1(l.Type, pos, visited)
 		}
 	}
 }
@@ -1089,6 +1121,9 @@ 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
 		}
@@ -1126,7 +1161,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 interface{}, context astContext) {
+	f.walk(arg, ctxExpr, func(f *File, arg any, context astContext) {
 		px, ok := arg.(*ast.Expr)
 		if !ok {
 			return
@@ -1756,17 +1791,21 @@ func gccMachine() []string {
 	return nil
 }
 
+var n atomic.Int64
+
 func gccTmp() string {
-	return *objDir + "_cgo_.o"
+	c := strconv.Itoa(int(n.Add(1)))
+	return *objDir + "_cgo_" + c + ".o"
 }
 
 // gccCmd returns the gcc command line to use for compiling
 // the input.
-func (p *Package) gccCmd() []string {
+// gccCommand is called concurrently for different files.
+func (p *Package) gccCmd(ofile string) []string {
 	c := append(gccBaseCmd,
 		"-w",         // no warnings
 		"-Wno-error", // warnings are not errors
-		"-o"+gccTmp(), // write object to tmp
+		"-o"+ofile,   // write object to tmp
 		"-gdwarf-2",  // generate DWARF v2 debugging symbols
 		"-c",         // do not link
 		"-xc",        // input language is C
@@ -1805,8 +1844,10 @@ func (p *Package) gccCmd() []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) {
-	runGcc(stdin, p.gccCmd())
+	ofile := gccTmp()
+	runGcc(stdin, p.gccCmd(ofile))
 
 	isDebugInts := func(s string) bool {
 		// Some systems use leading _ to denote non-assembly symbols.
@@ -1856,11 +1897,11 @@ func (p *Package) gccDebug(stdin []byte, nnames int) (d *dwarf.Data, ints []int6
 		}
 	}
 
-	if f, err := macho.Open(gccTmp()); err == nil {
+	if f, err := macho.Open(ofile); err == nil {
 		defer f.Close()
 		d, err := f.DWARF()
 		if err != nil {
-			fatalf("cannot load DWARF output from %s: %v", gccTmp(), err)
+			fatalf("cannot load DWARF output from %s: %v", ofile, err)
 		}
 		bo := f.ByteOrder
 		if f.Symtab != nil {
@@ -1934,11 +1975,11 @@ func (p *Package) gccDebug(stdin []byte, nnames int) (d *dwarf.Data, ints []int6
 		return d, ints, floats, strs
 	}
 
-	if f, err := elf.Open(gccTmp()); err == nil {
+	if f, err := elf.Open(ofile); err == nil {
 		defer f.Close()
 		d, err := f.DWARF()
 		if err != nil {
-			fatalf("cannot load DWARF output from %s: %v", gccTmp(), err)
+			fatalf("cannot load DWARF output from %s: %v", ofile, err)
 		}
 		bo := f.ByteOrder
 		symtab, err := f.Symbols()
@@ -2034,11 +2075,11 @@ func (p *Package) gccDebug(stdin []byte, nnames int) (d *dwarf.Data, ints []int6
 		return d, ints, floats, strs
 	}
 
-	if f, err := pe.Open(gccTmp()); err == nil {
+	if f, err := pe.Open(ofile); err == nil {
 		defer f.Close()
 		d, err := f.DWARF()
 		if err != nil {
-			fatalf("cannot load DWARF output from %s: %v", gccTmp(), err)
+			fatalf("cannot load DWARF output from %s: %v", ofile, err)
 		}
 		bo := binary.LittleEndian
 		for _, s := range f.Symbols {
@@ -2106,17 +2147,17 @@ func (p *Package) gccDebug(stdin []byte, nnames int) (d *dwarf.Data, ints []int6
 		return d, ints, floats, strs
 	}
 
-	if f, err := xcoff.Open(gccTmp()); err == nil {
+	if f, err := xcoff.Open(ofile); err == nil {
 		defer f.Close()
 		d, err := f.DWARF()
 		if err != nil {
-			fatalf("cannot load DWARF output from %s: %v", gccTmp(), err)
+			fatalf("cannot load DWARF output from %s: %v", ofile, err)
 		}
 		bo := binary.BigEndian
 		for _, s := range f.Symbols {
 			switch {
 			case isDebugInts(s.Name):
-				if i := int(s.SectionNumber) - 1; 0 <= i && i < len(f.Sections) {
+				if i := 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 {
@@ -2129,7 +2170,7 @@ func (p *Package) gccDebug(stdin []byte, nnames int) (d *dwarf.Data, ints []int6
 					}
 				}
 			case isDebugFloats(s.Name):
-				if i := int(s.SectionNumber) - 1; 0 <= i && i < len(f.Sections) {
+				if i := 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 {
@@ -2143,7 +2184,7 @@ func (p *Package) gccDebug(stdin []byte, nnames int) (d *dwarf.Data, ints []int6
 				}
 			default:
 				if n := indexOfDebugStr(s.Name); n != -1 {
-					if i := int(s.SectionNumber) - 1; 0 <= i && i < len(f.Sections) {
+					if i := 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 {
@@ -2155,7 +2196,7 @@ func (p *Package) gccDebug(stdin []byte, nnames int) (d *dwarf.Data, ints []int6
 					break
 				}
 				if n := indexOfDebugStrlen(s.Name); n != -1 {
-					if i := int(s.SectionNumber) - 1; 0 <= i && i < len(f.Sections) {
+					if i := 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 {
@@ -2176,7 +2217,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", gccTmp())
+	fatalf("cannot parse gcc output %s as ELF, Mach-O, PE, XCOFF object", ofile)
 	panic("not reached")
 }
 
@@ -2194,9 +2235,10 @@ 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()
+	args := p.gccCmd(gccTmp())
 
 	// Optimization options can confuse the error messages; remove them.
 	nargs := make([]string, 0, len(args)+len(extraArgs))
@@ -2400,7 +2442,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 ...interface{}) {
+func (tr *TypeRepr) Set(repr string, fargs ...any) {
 	tr.Repr = repr
 	tr.FormatArgs = fargs
 }
@@ -2674,7 +2716,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", []interface{}{dt.Kind, tag}}
+			tt.C = &TypeRepr{"%s %s", []any{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
@@ -2704,7 +2746,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", []interface{}{tag}}
+				tt.C = &TypeRepr{"struct %s", []any{tag}}
 			}
 			tt.Go = g
 			if c.incompleteStructs[tag] {
@@ -2863,7 +2905,7 @@ func (c *typeConv) loadType(dtype dwarf.Type, pos token.Pos, parent string) *Typ
 			if ss, ok := dwarfToName[s]; ok {
 				s = ss
 			}
-			s = strings.Replace(s, " ", "", -1)
+			s = strings.ReplaceAll(s, " ", "")
 			name := c.Ident("_Ctype_" + s)
 			tt := *t
 			typedef[name.Name] = &tt

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 interface{}) string {
+func gofmt(n any) string {
 	gofmtBuf.Reset()
 	err := printer.Fprint(&gofmtBuf, fset, n)
 	if err != nil {

src/cmd/cgo/internal/swig/swig_test.go

@@ -40,8 +40,9 @@ 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("go", runArgs...)
+	cmd := exec.Command(testenv.GoToolPath(t), runArgs...)
 	cmd.Dir = dir
 	if lto {
 		// On the builders we're using the default /usr/bin/ld, but
@@ -68,7 +69,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("go", "env", "CXX").CombinedOutput()
+	cxx, err := exec.Command(testenv.GoToolPath(t), "env", "CXX").CombinedOutput()
 	if err != nil {
 		t.Fatalf("go env CXX failed: %s", err)
 	}
@@ -79,7 +80,7 @@ func mustHaveCxx(t *testing.T) {
 	if len(args) == 0 {
 		t.Skip("no C++ compiler")
 	}
-	testenv.MustHaveExecPath(t, string(args[0]))
+	testenv.MustHaveExecPath(t, args[0])
 }
 
 var (

src/cmd/cgo/internal/test/cgo_darwin_test.go

@@ -0,0 +1,11 @@
+// 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) }

src/cmd/cgo/internal/test/cgo_test.go

@@ -106,6 +106,7 @@ 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 BenchmarkCgoCall(b *testing.B)      { benchCgoCall(b) }
 func BenchmarkGoString(b *testing.B)     { benchGoString(b) }

src/cmd/cgo/internal/test/issue18146.go

@@ -11,6 +11,7 @@ package cgotest
 import (
 	"bytes"
 	"crypto/md5"
+	"internal/testenv"
 	"os"
 	"os/exec"
 	"runtime"
@@ -73,7 +74,7 @@ func test18146(t *testing.T) {
 		}
 		runtime.GOMAXPROCS(threads)
 		argv := append(os.Args, "-test.run=^$")
-		if err := syscall.Exec(os.Args[0], argv, os.Environ()); err != nil {
+		if err := syscall.Exec(testenv.Executable(t), argv, os.Environ()); err != nil {
 			t.Fatal(err)
 		}
 	}
@@ -87,7 +88,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(os.Args[0], args...)
+		cmd := exec.Command(testenv.Executable(t), args...)
 		cmd.Env = append(os.Environ(), "test18146=exec")
 		buf := bytes.NewBuffer(nil)
 		cmd.Stdout = buf

src/cmd/cgo/internal/test/issue4029.go

@@ -11,6 +11,7 @@ package cgotest
 
 /*
 #include <stdint.h>
+#include <stdlib.h>
 #include <dlfcn.h>
 #cgo linux LDFLAGS: -ldl
 
@@ -24,6 +25,7 @@ import "C"
 
 import (
 	"testing"
+	"unsafe"
 )
 
 var callbacks int
@@ -66,7 +68,9 @@ func loadThySelf(t *testing.T, symbol string) {
 	}
 	defer C.dlclose4029(this_process)
 
-	symbol_address := C.dlsym4029(this_process, C.CString(symbol))
+	symCStr := C.CString(symbol)
+	defer C.free(unsafe.Pointer(symCStr))
+	symbol_address := C.dlsym4029(this_process, symCStr)
 	if symbol_address == 0 {
 		t.Error("dlsym:", C.GoString(C.dlerror()))
 		return

src/cmd/cgo/internal/test/issue42018_windows.go

@@ -27,6 +27,7 @@ func test42018(t *testing.T) {
 	recurseHWND(400, hwnd, uintptr(unsafe.Pointer(&i)))
 }
 
+//go:noinline
 func recurseHANDLE(n int, p C.HANDLE, v uintptr) {
 	if n > 0 {
 		recurseHANDLE(n-1, p, v)
@@ -36,6 +37,7 @@ func recurseHANDLE(n int, p C.HANDLE, v uintptr) {
 	}
 }
 
+//go:noinline
 func recurseHWND(n int, p C.HWND, v uintptr) {
 	if n > 0 {
 		recurseHWND(n-1, p, v)

src/cmd/cgo/internal/test/issue76023.go

@@ -0,0 +1,27 @@
+// 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 darwin
+
+package cgotest
+
+/*
+#cgo LDFLAGS: -Wl,-undefined,dynamic_lookup
+
+extern void __gotest_cgo_null_api(void) __attribute__((weak_import));
+
+int issue76023(void) {
+    if (__gotest_cgo_null_api) return 1;
+    return 0;
+}
+*/
+import "C"
+import "testing"
+
+func issue76023(t *testing.T) {
+	r := C.issue76023()
+	if r != 0 {
+		t.Error("found __gotest_cgo_null_api")
+	}
+}

src/cmd/cgo/internal/test/test.go

@@ -245,7 +245,7 @@ static void *thread(void *p) {
 	return NULL;
 }
 void testSendSIG() {
-	const int N = 20;
+	enum { N = 20 };
 	int i;
 	pthread_t tid[N];
 	for (i = 0; i < N; i++) {
@@ -953,6 +953,24 @@ typedef struct {
 } issue69086struct;
 static int issue690861(issue69086struct* p) { p->b = 1234; return p->c; }
 static int issue690862(unsigned long ul1, unsigned long ul2, unsigned int u, issue69086struct s) { return (int)(s.b); }
+
+char issue75751v = 1;
+char * const issue75751p = &issue75751v;
+#define issue75751m issue75751p
+char * const volatile issue75751p2 = &issue75751v;
+#define issue75751m2 issue75751p2
+
+typedef struct { void *t; void *v; } GoInterface;
+extern int exportAny76340Param(GoInterface);
+extern GoInterface exportAny76340Return(int);
+
+int issue76340testFromC(GoInterface obj) {
+	return exportAny76340Param(obj);
+}
+
+GoInterface issue76340returnFromC(int val) {
+	return exportAny76340Return(val);
+}
 */
 import "C"
 
@@ -1096,8 +1114,15 @@ func testErrno(t *testing.T) {
 }
 
 func testMultipleAssign(t *testing.T) {
+	if runtime.GOOS == "windows" && usesUCRT(t) {
+		// UCRT's strtol throws an unrecoverable crash when
+		// using an invalid base (that is, not 0 or 2..36).
+		// See go.dev/issue/62887.
+		t.Skip("skipping test on Windows when linking with UCRT")
+	}
 	p := C.CString("234")
 	n, m := C.strtol(p, nil, 345), C.strtol(p, nil, 10)
+	defer C.free(unsafe.Pointer(p))
 	if runtime.GOOS == "openbsd" {
 		// Bug in OpenBSD strtol(3) - base > 36 succeeds.
 		if (n != 0 && n != 239089) || m != 234 {
@@ -1106,7 +1131,6 @@ func testMultipleAssign(t *testing.T) {
 	} else if n != 0 || m != 234 {
 		t.Fatal("Strtol x2: ", n, m)
 	}
-	C.free(unsafe.Pointer(p))
 }
 
 var (
@@ -1632,7 +1656,9 @@ func testNaming(t *testing.T) {
 
 func test6907(t *testing.T) {
 	want := "yarn"
-	if got := C.GoString(C.Issue6907CopyString(want)); got != want {
+	s := C.Issue6907CopyString(want)
+	defer C.free(unsafe.Pointer(s))
+	if got := C.GoString(s); got != want {
 		t.Errorf("C.GoString(C.Issue6907CopyString(%q)) == %q, want %q", want, got, want)
 	}
 }
@@ -1881,6 +1907,7 @@ func test17537(t *testing.T) {
 	}
 
 	p := (*C.char)(C.malloc(1))
+	defer C.free(unsafe.Pointer(p))
 	*p = 17
 	if got, want := C.F17537(&p), C.int(17); got != want {
 		t.Errorf("got %d, want %d", got, want)
@@ -2387,3 +2414,27 @@ func test69086(t *testing.T) {
 		t.Errorf("call: got %d, want 1234", got)
 	}
 }
+
+// Issue 75751: no runtime test, just make sure it compiles.
+func test75751() int {
+	return int(*C.issue75751m) + int(*C.issue75751m2)
+}
+
+// Issue 76340.
+func test76340(t *testing.T) {
+	var emptyInterface C.GoInterface
+	r1 := C.issue76340testFromC(emptyInterface)
+	if r1 != 0 {
+		t.Errorf("issue76340testFromC with nil interface: got %d, want 0", r1)
+	}
+
+	r2 := C.issue76340returnFromC(42)
+	if r2.t == nil && r2.v == nil {
+		t.Error("issue76340returnFromC(42) returned nil interface")
+	}
+
+	r3 := C.issue76340returnFromC(0)
+	if r3.t != nil || r3.v != nil {
+		t.Errorf("issue76340returnFromC(0) returned non-nil interface: got %v, want nil", r3)
+	}
+}

src/cmd/cgo/internal/test/test_unix.go

@@ -6,6 +6,13 @@
 
 package cgotest
 
-import "syscall"
+import (
+	"syscall"
+	"testing"
+)
 
 var syscall_dot_SIGCHLD = syscall.SIGCHLD
+
+func usesUCRT(t *testing.T) bool {
+	return false
+}

src/cmd/cgo/internal/test/test_windows.go

@@ -4,6 +4,20 @@
 
 package cgotest
 
-import "syscall"
+import (
+	"internal/syscall/windows"
+	"syscall"
+	"testing"
+)
 
 var syscall_dot_SIGCHLD syscall.Signal
+
+// usesUCRT reports whether the test is using the Windows UCRT (Universal C Runtime).
+func usesUCRT(t *testing.T) bool {
+	name, err := syscall.UTF16PtrFromString("ucrtbase.dll")
+	if err != nil {
+		t.Fatal(err)
+	}
+	h, err := windows.GetModuleHandle(name)
+	return err == nil && h != 0
+}

src/cmd/cgo/internal/test/testx.go

@@ -447,7 +447,7 @@ func issue7978check(t *testing.T, wantFunc string, badFunc string, depth int) {
 	runtime.GC()
 	buf := make([]byte, 65536)
 	trace := string(buf[:runtime.Stack(buf, true)])
-	for _, goroutine := range strings.Split(trace, "\n\n") {
+	for goroutine := range strings.SplitSeq(trace, "\n\n") {
 		if strings.Contains(goroutine, "test.issue7978go") {
 			trace := strings.Split(goroutine, "\n")
 			// look for the expected function in the stack
@@ -595,3 +595,21 @@ func test49633(t *testing.T) {
 		t.Errorf("msg = %q, want 'hello'", v.msg)
 	}
 }
+
+//export exportAny76340Param
+func exportAny76340Param(obj any) C.int {
+	if obj == nil {
+		return 0
+	}
+
+	return 1
+}
+
+//export exportAny76340Return
+func exportAny76340Return(val C.int) any {
+	if val == 0 {
+		return nil
+	}
+
+	return int(val)
+}

src/cmd/cgo/internal/testcarchive/carchive_test.go

@@ -58,7 +58,7 @@ func TestMain(m *testing.M) {
 }
 
 func testMain(m *testing.M) int {
-	if testing.Short() && os.Getenv("GO_BUILDER_NAME") == "" {
+	if testing.Short() && testenv.Builder() == "" {
 		globalSkip = func(t testing.TB) { t.Skip("short mode and $GO_BUILDER_NAME not set") }
 		return m.Run()
 	}
@@ -102,14 +102,14 @@ func testMain(m *testing.M) int {
 	bin = cmdToRun("./testp")
 
 	ccOut := goEnv("CC")
-	cc = []string{string(ccOut)}
+	cc = []string{ccOut}
 
 	out := goEnv("GOGCCFLAGS")
 	quote := '\000'
 	start := 0
 	lastSpace := true
 	backslash := false
-	s := string(out)
+	s := out
 	for i, c := range s {
 		if quote == '\000' && unicode.IsSpace(c) {
 			if !lastSpace {
@@ -218,7 +218,7 @@ func genHeader(t *testing.T, header, dir string) {
 		t.Fatal(err)
 	}
 
-	cmd := exec.Command("go", "tool", "cgo",
+	cmd := exec.Command(testenv.GoToolPath(t), "tool", "cgo",
 		"-objdir", objDir,
 		"-exportheader", header)
 	cmd.Args = append(cmd.Args, files...)
@@ -524,7 +524,7 @@ func TestEarlySignalHandler(t *testing.T) {
 		}()
 	}
 
-	cmd := exec.Command("go", "build", "-buildmode=c-archive", "-o", "libgo2.a", "./libgo2")
+	cmd := exec.Command(testenv.GoToolPath(t), "build", "-buildmode=c-archive", "-o", "libgo2.a", "./libgo2")
 	if out, err := cmd.CombinedOutput(); err != nil {
 		t.Logf("%s", out)
 		t.Fatal(err)
@@ -674,7 +674,7 @@ func buildSignalForwardingTest(t *testing.T) {
 	}
 
 	t.Log("go build -buildmode=c-archive -o libgo2.a ./libgo2")
-	cmd := exec.Command("go", "build", "-buildmode=c-archive", "-o", "libgo2.a", "./libgo2")
+	cmd := exec.Command(testenv.GoToolPath(t), "build", "-buildmode=c-archive", "-o", "libgo2.a", "./libgo2")
 	out, err := cmd.CombinedOutput()
 	if len(out) > 0 {
 		t.Logf("%s", out)
@@ -801,7 +801,7 @@ func TestOsSignal(t *testing.T) {
 		}()
 	}
 
-	cmd := exec.Command("go", "build", "-buildmode=c-archive", "-o", "libgo3.a", "./libgo3")
+	cmd := exec.Command(testenv.GoToolPath(t), "build", "-buildmode=c-archive", "-o", "libgo3.a", "./libgo3")
 	if out, err := cmd.CombinedOutput(); err != nil {
 		t.Logf("%s", out)
 		t.Fatal(err)
@@ -843,7 +843,7 @@ func TestSigaltstack(t *testing.T) {
 		}()
 	}
 
-	cmd := exec.Command("go", "build", "-buildmode=c-archive", "-o", "libgo4.a", "./libgo4")
+	cmd := exec.Command(testenv.GoToolPath(t), "build", "-buildmode=c-archive", "-o", "libgo4.a", "./libgo4")
 	if out, err := cmd.CombinedOutput(); err != nil {
 		t.Logf("%s", out)
 		t.Fatal(err)
@@ -908,7 +908,7 @@ func TestExtar(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	cmd := exec.Command("go", "build", "-buildmode=c-archive", "-ldflags=-extar="+filepath.Join(dir, "testar"), "-o", "libgo4.a", "./libgo4")
+	cmd := exec.Command(testenv.GoToolPath(t), "build", "-buildmode=c-archive", "-ldflags=-extar="+filepath.Join(dir, "testar"), "-o", "libgo4.a", "./libgo4")
 	if out, err := cmd.CombinedOutput(); err != nil {
 		t.Logf("%s", out)
 		t.Fatal(err)
@@ -955,7 +955,7 @@ func TestPIE(t *testing.T) {
 	// be running this test in a GOROOT owned by root.)
 	genHeader(t, "p.h", "./p")
 
-	cmd := exec.Command("go", "build", "-buildmode=c-archive", "./libgo")
+	cmd := exec.Command(testenv.GoToolPath(t), "build", "-buildmode=c-archive", "./libgo")
 	if out, err := cmd.CombinedOutput(); err != nil {
 		t.Logf("%s", out)
 		t.Fatal(err)
@@ -1042,7 +1042,7 @@ func TestSIGPROF(t *testing.T) {
 		}()
 	}
 
-	cmd := exec.Command("go", "build", "-buildmode=c-archive", "-o", "libgo6.a", "./libgo6")
+	cmd := exec.Command(testenv.GoToolPath(t), "build", "-buildmode=c-archive", "-o", "libgo6.a", "./libgo6")
 	out, err := cmd.CombinedOutput()
 	t.Logf("%v\n%s", cmd.Args, out)
 	if err != nil {
@@ -1089,7 +1089,7 @@ func TestCompileWithoutShared(t *testing.T) {
 		}()
 	}
 
-	cmd := exec.Command("go", "build", "-buildmode=c-archive", "-gcflags=-shared=false", "-o", "libgo2.a", "./libgo2")
+	cmd := exec.Command(testenv.GoToolPath(t), "build", "-buildmode=c-archive", "-gcflags=-shared=false", "-o", "libgo2.a", "./libgo2")
 	out, err := cmd.CombinedOutput()
 	t.Logf("%v\n%s", cmd.Args, out)
 	if err != nil {
@@ -1204,7 +1204,7 @@ func TestManyCalls(t *testing.T) {
 		}()
 	}
 
-	cmd := exec.Command("go", "build", "-buildmode=c-archive", "-o", "libgo7.a", "./libgo7")
+	cmd := exec.Command(testenv.GoToolPath(t), "build", "-buildmode=c-archive", "-o", "libgo7.a", "./libgo7")
 	out, err := cmd.CombinedOutput()
 	t.Logf("%v\n%s", cmd.Args, out)
 	if err != nil {
@@ -1259,7 +1259,7 @@ func TestPreemption(t *testing.T) {
 		}()
 	}
 
-	cmd := exec.Command("go", "build", "-buildmode=c-archive", "-o", "libgo8.a", "./libgo8")
+	cmd := exec.Command(testenv.GoToolPath(t), "build", "-buildmode=c-archive", "-o", "libgo8.a", "./libgo8")
 	out, err := cmd.CombinedOutput()
 	t.Logf("%v\n%s", cmd.Args, out)
 	if err != nil {
@@ -1309,7 +1309,7 @@ func TestDeepStack(t *testing.T) {
 		}()
 	}
 
-	cmd := exec.Command("go", "build", "-buildmode=c-archive", "-o", "libgo9.a", "./libgo9")
+	cmd := exec.Command(testenv.GoToolPath(t), "build", "-buildmode=c-archive", "-o", "libgo9.a", "./libgo9")
 	out, err := cmd.CombinedOutput()
 	t.Logf("%v\n%s", cmd.Args, out)
 	if err != nil {
@@ -1372,7 +1372,7 @@ func BenchmarkCgoCallbackMainThread(b *testing.B) {
 		}()
 	}
 
-	cmd := exec.Command("go", "build", "-buildmode=c-archive", "-o", "libgo10.a", "./libgo10")
+	cmd := exec.Command(testenv.GoToolPath(b), "build", "-buildmode=c-archive", "-o", "libgo10.a", "./libgo10")
 	out, err := cmd.CombinedOutput()
 	b.Logf("%v\n%s", cmd.Args, out)
 	if err != nil {
@@ -1414,7 +1414,7 @@ func TestSharedObject(t *testing.T) {
 		}()
 	}
 
-	cmd := exec.Command("go", "build", "-buildmode=c-archive", "-o", "libgo_s.a", "./libgo")
+	cmd := exec.Command(testenv.GoToolPath(t), "build", "-buildmode=c-archive", "-o", "libgo_s.a", "./libgo")
 	out, err := cmd.CombinedOutput()
 	t.Logf("%v\n%s", cmd.Args, out)
 	if err != nil {

src/cmd/cgo/internal/testcshared/cshared_test.go

@@ -8,6 +8,7 @@ import (
 	"bufio"
 	"bytes"
 	"cmd/cgo/internal/cgotest"
+	"cmp"
 	"debug/elf"
 	"debug/pe"
 	"encoding/binary"
@@ -44,7 +45,7 @@ func TestMain(m *testing.M) {
 func testMain(m *testing.M) int {
 	log.SetFlags(log.Lshortfile)
 	flag.Parse()
-	if testing.Short() && os.Getenv("GO_BUILDER_NAME") == "" {
+	if testing.Short() && testenv.Builder() == "" {
 		globalSkip = func(t *testing.T) { t.Skip("short mode and $GO_BUILDER_NAME not set") }
 		return m.Run()
 	}
@@ -75,7 +76,7 @@ func testMain(m *testing.M) int {
 	start := 0
 	lastSpace := true
 	backslash := false
-	s := string(out)
+	s := out
 	for i, c := range s {
 		if quote == '\000' && unicode.IsSpace(c) {
 			if !lastSpace {
@@ -272,7 +273,7 @@ func createHeaders() error {
 		// which results in the linkers output implib getting overwritten at each step. So instead build the
 		// import library the traditional way, using a def file.
 		err = os.WriteFile("libgo.def",
-			[]byte("LIBRARY libgo.dll\nEXPORTS\n\tDidInitRun\n\tDidMainRun\n\tDivu\n\tFromPkg\n\t_cgo_dummy_export\n"),
+			[]byte("LIBRARY libgo.dll\nEXPORTS\n\tDidInitRun\n\tDidMainRun\n\tDivu\n\tFromPkg\n"),
 			0644)
 		if err != nil {
 			return fmt.Errorf("unable to write def file: %v", err)
@@ -375,27 +376,22 @@ func TestExportedSymbols(t *testing.T) {
 	}
 }
 
-func checkNumberOfExportedFunctionsWindows(t *testing.T, exportAllSymbols bool) {
-	const prog = `
+func checkNumberOfExportedSymbolsWindows(t *testing.T, exportedSymbols int, wantAll bool) {
+	t.Parallel()
+	tmpdir := t.TempDir()
+
+	prog := `
 package main
-
 import "C"
-
-//export GoFunc
-func GoFunc() {
-	println(42)
-}
-
-//export GoFunc2
-func GoFunc2() {
-	println(24)
-}
-
-func main() {
-}
+func main() {}
 `
 
-	tmpdir := t.TempDir()
+	for i := range exportedSymbols {
+		prog += fmt.Sprintf(`
+//export GoFunc%d
+func GoFunc%d() {}
+`, i, i)
+	}
 
 	srcfile := filepath.Join(tmpdir, "test.go")
 	objfile := filepath.Join(tmpdir, "test.dll")
@@ -403,11 +399,11 @@ func main() {
 		t.Fatal(err)
 	}
 	argv := []string{"build", "-buildmode=c-shared"}
-	if exportAllSymbols {
+	if wantAll {
 		argv = append(argv, "-ldflags", "-extldflags=-Wl,--export-all-symbols")
 	}
 	argv = append(argv, "-o", objfile, srcfile)
-	out, err := exec.Command("go", argv...).CombinedOutput()
+	out, err := exec.Command(testenv.GoToolPath(t), argv...).CombinedOutput()
 	if err != nil {
 		t.Fatalf("build failure: %s\n%s\n", err, string(out))
 	}
@@ -417,11 +413,37 @@ func main() {
 		t.Fatalf("pe.Open failed: %v", err)
 	}
 	defer f.Close()
-	section := f.Section(".edata")
-	if section == nil {
-		t.Skip(".edata section is not present")
+
+	_, pe64 := f.OptionalHeader.(*pe.OptionalHeader64)
+	// grab the export data directory entry
+	var idd pe.DataDirectory
+	if pe64 {
+		idd = f.OptionalHeader.(*pe.OptionalHeader64).DataDirectory[pe.IMAGE_DIRECTORY_ENTRY_EXPORT]
+	} else {
+		idd = f.OptionalHeader.(*pe.OptionalHeader32).DataDirectory[pe.IMAGE_DIRECTORY_ENTRY_EXPORT]
 	}
 
+	// figure out which section contains the import directory table
+	var section *pe.Section
+	for _, s := range f.Sections {
+		if s.Offset == 0 {
+			continue
+		}
+		if s.VirtualAddress <= idd.VirtualAddress && idd.VirtualAddress-s.VirtualAddress < s.VirtualSize {
+			section = s
+			break
+		}
+	}
+	if section == nil {
+		t.Fatal("no section contains export directory")
+	}
+	d, err := section.Data()
+	if err != nil {
+		t.Fatal(err)
+	}
+	// seek to the virtual address specified in the export data directory
+	d = d[idd.VirtualAddress-section.VirtualAddress:]
+
 	// TODO: deduplicate this struct from cmd/link/internal/ld/pe.go
 	type IMAGE_EXPORT_DIRECTORY struct {
 		_                 [2]uint32
@@ -432,26 +454,23 @@ func main() {
 		_                 [3]uint32
 	}
 	var e IMAGE_EXPORT_DIRECTORY
-	if err := binary.Read(section.Open(), binary.LittleEndian, &e); err != nil {
+	if err := binary.Read(bytes.NewReader(d), binary.LittleEndian, &e); err != nil {
 		t.Fatalf("binary.Read failed: %v", err)
 	}
 
-	// Only the two exported functions and _cgo_dummy_export should be exported
-	expectedNumber := uint32(3)
+	exportedSymbols = cmp.Or(exportedSymbols, 1) // _cgo_stub_export is exported if there are no other symbols exported
 
-	if exportAllSymbols {
-		if e.NumberOfFunctions <= expectedNumber {
-			t.Fatalf("missing exported functions: %v", e.NumberOfFunctions)
-		}
-		if e.NumberOfNames <= expectedNumber {
-			t.Fatalf("missing exported names: %v", e.NumberOfNames)
+	// NumberOfNames is the number of functions exported with a unique name.
+	// NumberOfFunctions can be higher than that because it also counts
+	// functions exported only by ordinal, a unique number asigned by the linker,
+	// and linkers might add an unknown number of their own ordinal-only functions.
+	if wantAll {
+		if e.NumberOfNames <= uint32(exportedSymbols) {
+			t.Errorf("got %d exported names, want > %d", e.NumberOfNames, exportedSymbols)
 		}
 	} else {
-		if e.NumberOfFunctions != expectedNumber {
-			t.Fatalf("got %d exported functions; want %d", e.NumberOfFunctions, expectedNumber)
-		}
-		if e.NumberOfNames != expectedNumber {
-			t.Fatalf("got %d exported names; want %d", e.NumberOfNames, expectedNumber)
+		if e.NumberOfNames != uint32(exportedSymbols) {
+			t.Errorf("got %d exported names, want %d", e.NumberOfNames, exportedSymbols)
 		}
 	}
 }
@@ -467,12 +486,14 @@ func TestNumberOfExportedFunctions(t *testing.T) {
 
 	t.Parallel()
 
-	t.Run("OnlyExported", func(t *testing.T) {
-		checkNumberOfExportedFunctionsWindows(t, false)
+	for i := range 3 {
+		t.Run(fmt.Sprintf("OnlyExported/%d", i), func(t *testing.T) {
+			checkNumberOfExportedSymbolsWindows(t, i, false)
 		})
-	t.Run("All", func(t *testing.T) {
-		checkNumberOfExportedFunctionsWindows(t, true)
+		t.Run(fmt.Sprintf("All/%d", i), func(t *testing.T) {
+			checkNumberOfExportedSymbolsWindows(t, i, true)
 		})
+	}
 }
 
 // test1: shared library can be dynamically loaded and exported symbols are accessible.
@@ -880,3 +901,44 @@ func TestIssue36233(t *testing.T) {
 		t.Error("missing functions")
 	}
 }
+
+func TestIssue68411(t *testing.T) {
+	globalSkip(t)
+	testenv.MustHaveCGO(t)
+
+	t.Parallel()
+
+	// Test that the export header uses a void function parameter for
+	// exported Go functions with no parameters.
+
+	tmpdir := t.TempDir()
+
+	const exportHeader = "issue68411.h"
+
+	run(t, nil, "go", "tool", "cgo", "-exportheader", exportHeader, "-objdir", tmpdir, "./issue68411/issue68411.go")
+	data, err := os.ReadFile(exportHeader)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	funcs := []struct{ name, signature string }{
+		{"exportFuncWithNoParams", "void exportFuncWithNoParams(void)"},
+		{"exportFuncWithParams", "exportFuncWithParams(GoInt a, GoInt b)"},
+	}
+
+	var found int
+	for line := range bytes.Lines(data) {
+		for _, fn := range funcs {
+			if bytes.Contains(line, []byte(fn.name)) {
+				found++
+				if !bytes.Contains(line, []byte(fn.signature)) {
+					t.Errorf("function signature mismatch; got %q, want %q", line, fn.signature)
+				}
+			}
+		}
+	}
+
+	if found != len(funcs) {
+		t.Error("missing functions")
+	}
+}

src/cmd/cgo/internal/testcshared/testdata/issue68411/issue68411.go

@@ -0,0 +1,15 @@
+// Copyright 2025 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import "C"
+
+//export exportFuncWithNoParams
+func exportFuncWithNoParams() {}
+
+//export exportFuncWithParams
+func exportFuncWithParams(a, b int) {}
+
+func main() {}

src/cmd/cgo/internal/testerrors/argposition_test.go

@@ -81,7 +81,7 @@ func TestArgumentsPositions(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	cmd := exec.Command("go", "tool", "cgo",
+	cmd := exec.Command(testenv.GoToolPath(t), "tool", "cgo",
 		"-srcdir", testdata,
 		"-objdir", dir,
 		"issue42580.go")

src/cmd/cgo/internal/testerrors/badsym_test.go

@@ -136,7 +136,7 @@ func TestBadSymbol(t *testing.T) {
 	makeFile(godir, "go.mod", "module badsym")
 
 	// Try to build our little package.
-	cmd := exec.Command("go", "build", "-ldflags=-v")
+	cmd := exec.Command(testenv.GoToolPath(t), "build", "-ldflags=-v")
 	cmd.Dir = godir
 	output, err := cmd.CombinedOutput()
 
@@ -186,7 +186,7 @@ func cCompilerCmd(t *testing.T) []string {
 	start := 0
 	lastSpace := true
 	backslash := false
-	s := string(out)
+	s := out
 	for i, c := range s {
 		if quote == '\000' && unicode.IsSpace(c) {
 			if !lastSpace {

src/cmd/cgo/internal/testerrors/errors_test.go

@@ -76,7 +76,7 @@ func expect(t *testing.T, errors []*regexp.Regexp, files ...string) {
 	for _, file := range files {
 		args = append(args, path(file))
 	}
-	cmd := exec.Command("go", args...)
+	cmd := exec.Command(testenv.GoToolPath(t), args...)
 	out, err := cmd.CombinedOutput()
 	if err == nil {
 		t.Errorf("expected cgo to fail but it succeeded")
@@ -105,10 +105,10 @@ func expect(t *testing.T, errors []*regexp.Regexp, files ...string) {
 func sizeofLongDouble(t *testing.T) int {
 	testenv.MustHaveGoRun(t)
 	testenv.MustHaveCGO(t)
-	cmd := exec.Command("go", "run", path("long_double_size.go"))
+	cmd := exec.Command(testenv.GoToolPath(t), "run", path("long_double_size.go"))
 	out, err := cmd.CombinedOutput()
 	if err != nil {
-		t.Fatalf("%#q: %v:\n%s", strings.Join(cmd.Args, " "), err, out)
+		t.Fatalf("%#q: %v:\n%s", cmd, err, out)
 	}
 
 	i, err := strconv.Atoi(strings.TrimSpace(string(out)))
@@ -158,11 +158,11 @@ func TestToleratesOptimizationFlag(t *testing.T) {
 			testenv.MustHaveCGO(t)
 			t.Parallel()
 
-			cmd := exec.Command("go", "build", path("issue14669.go"))
+			cmd := exec.Command(testenv.GoToolPath(t), "build", path("issue14669.go"))
 			cmd.Env = append(os.Environ(), "CGO_CFLAGS="+cflags)
 			out, err := cmd.CombinedOutput()
 			if err != nil {
-				t.Errorf("%#q: %v:\n%s", strings.Join(cmd.Args, " "), err, out)
+				t.Errorf("%#q: %v:\n%s", cmd, err, out)
 			}
 		})
 	}
@@ -173,10 +173,10 @@ func TestMallocCrashesOnNil(t *testing.T) {
 	testenv.MustHaveGoRun(t)
 	t.Parallel()
 
-	cmd := exec.Command("go", "run", path("malloc.go"))
+	cmd := exec.Command(testenv.GoToolPath(t), "run", path("malloc.go"))
 	out, err := cmd.CombinedOutput()
 	if err == nil {
-		t.Logf("%#q:\n%s", strings.Join(cmd.Args, " "), out)
+		t.Logf("%#q:\n%s", cmd, out)
 		t.Fatalf("succeeded unexpectedly")
 	}
 }

src/cmd/cgo/internal/testerrors/ptr_test.go

@@ -14,6 +14,7 @@ import (
 	"os"
 	"os/exec"
 	"path/filepath"
+	"regexp"
 	"slices"
 	"strings"
 	"sync/atomic"
@@ -33,6 +34,7 @@ type ptrTest struct {
 	extra         []extra  // extra files
 	fail          bool     // whether the test should fail
 	expensive     bool     // whether the test requires the expensive check
+	errTextRegexp string   // error text regexp; if empty, use the pattern `.*unpinned Go.*`
 }
 
 type extra struct {
@@ -489,6 +491,27 @@ var ptrTests = []ptrTest{
 		body:    `i := 0; a := &[2]unsafe.Pointer{nil, unsafe.Pointer(&i)}; C.f45(&a[0])`,
 		fail:    true,
 	},
+	{
+		// Passing a Go map as argument to C.
+		name:          "argmap",
+		c:             `void f46(void* p) {}`,
+		imports:       []string{"unsafe"},
+		body:          `m := map[int]int{0: 1,}; C.f46(unsafe.Pointer(&m))`,
+		fail:          true,
+		errTextRegexp: `.*argument of cgo function has Go pointer to unpinned Go map`,
+	},
+	{
+		// Returning a Go map to C.
+		name: "retmap",
+		c:    `extern void f47();`,
+		support: `//export GoMap47
+		          func GoMap47() map[int]int { return map[int]int{0: 1,} }`,
+		body: `C.f47()`,
+		c1: `extern void* GoMap47();
+		     void f47() { GoMap47(); }`,
+		fail:          true,
+		errTextRegexp: `.*result of Go function GoMap47 called from cgo is unpinned Go map or points to unpinned Go map.*`,
+	},
 }
 
 func TestPointerChecks(t *testing.T) {
@@ -519,7 +542,6 @@ func TestPointerChecks(t *testing.T) {
 	// after testOne finishes.
 	var pending int32
 	for _, pt := range ptrTests {
-		pt := pt
 		t.Run(pt.name, func(t *testing.T) {
 			atomic.AddInt32(&pending, +1)
 			defer func() {
@@ -609,7 +631,7 @@ func buildPtrTests(t *testing.T, gopath string, cgocheck2 bool) (exe string) {
 	if cgocheck2 {
 		exeName = "ptrtest2.exe"
 	}
-	cmd := exec.Command("go", "build", "-o", exeName)
+	cmd := exec.Command(testenv.GoToolPath(t), "build", "-o", exeName)
 	cmd.Dir = src
 	cmd.Env = append(os.Environ(), "GOPATH="+gopath)
 
@@ -690,11 +712,17 @@ func testOne(t *testing.T, pt ptrTest, exe, exe2 string) {
 	}
 
 	buf, err := runcmd(cgocheck)
+
+	var pattern string = pt.errTextRegexp
+	if pt.errTextRegexp == "" {
+		pattern = `.*unpinned Go.*`
+	}
+
 	if pt.fail {
 		if err == nil {
 			t.Logf("%s", buf)
 			t.Fatalf("did not fail as expected")
-		} else if !bytes.Contains(buf, []byte("Go pointer")) {
+		} else if ok, _ := regexp.Match(pattern, buf); !ok {
 			t.Logf("%s", buf)
 			t.Fatalf("did not print expected error (failed with %v)", err)
 		}

src/cmd/cgo/internal/testfortran/fortran_test.go

@@ -75,7 +75,7 @@ func TestFortran(t *testing.T) {
 	// Finally, run the actual test.
 	t.Log("go", "run", "./testdata/testprog")
 	var stdout, stderr strings.Builder
-	cmd := exec.Command("go", "run", "./testdata/testprog")
+	cmd := exec.Command(testenv.GoToolPath(t), "run", "./testdata/testprog")
 	cmd.Stdout = &stdout
 	cmd.Stderr = &stderr
 	err := cmd.Run()

src/cmd/cgo/internal/testgodefs/testgodefs_test.go

@@ -51,7 +51,7 @@ func TestGoDefs(t *testing.T) {
 	}
 
 	for _, fp := range filePrefixes {
-		cmd := exec.Command("go", "tool", "cgo",
+		cmd := exec.Command(testenv.GoToolPath(t), "tool", "cgo",
 			"-godefs",
 			"-srcdir", testdata,
 			"-objdir", dir,
@@ -60,7 +60,7 @@ func TestGoDefs(t *testing.T) {
 
 		out, err := cmd.Output()
 		if err != nil {
-			t.Fatalf("%s: %v\n%s", strings.Join(cmd.Args, " "), err, cmd.Stderr)
+			t.Fatalf("%#q: %v\n%s", cmd, err, cmd.Stderr)
 		}
 
 		fn := fp + "_defs.go"
@@ -107,10 +107,10 @@ func TestGoDefs(t *testing.T) {
 	// instead of invoking 'go build' and the resulting binary separately, so that
 	// this test can pass on mobile builders, which do not copy artifacts back
 	// from remote invocations.
-	cmd := exec.Command("go", "run", ".")
+	cmd := exec.Command(testenv.GoToolPath(t), "run", ".")
 	cmd.Env = append(os.Environ(), "GOPATH="+gopath)
 	cmd.Dir = dir
 	if out, err := cmd.CombinedOutput(); err != nil {
-		t.Fatalf("%s [%s]: %v\n%s", strings.Join(cmd.Args, " "), dir, err, out)
+		t.Fatalf("%#q [%s]: %v\n%s", cmd, dir, err, out)
 	}
 }