[release-branch.go1.19] go1.19.11

Change-Id: Ic6685cba7c4cf96dfc0c837df90002f557e9e86a
Reviewed-on: https://go-review.googlesource.com/c/go/+/508837
TryBot-Result: Gopher Robot <gobot@golang.org>
Run-TryBot: Gopher Robot <gobot@golang.org>
Reviewed-by: Cherry Mui <cherryyz@google.com>
Reviewed-by: Heschi Kreinick <heschi@google.com>
Auto-Submit: Gopher Robot <gobot@golang.org>

.github/ISSUE_TEMPLATE/01-pkgsite.md

@@ -34,8 +34,6 @@ Please paste a screenshot of the page.
 
 <!--
 If possible, provide a recipe for reproducing the error.
-
-Starting with a Private/Incognito tab/window may help rule out problematic browser extensions.
 -->
 
 

.github/ISSUE_TEMPLATE/02-pkgsite-removal.md

@@ -2,7 +2,7 @@
 name: Pkg.go.dev package removal request
 about: Request a package be removed from the documentation site (pkg.go.dev)
 title: "x/pkgsite: package removal request for [type path here]"
-labels: pkgsite/package-removal
+labels: pkgsite
 ---
 
 <!--

.github/ISSUE_TEMPLATE/04-vuln.md

@@ -1,51 +0,0 @@
----
-name: Go vulnerability management - bugs and feature requests
-about: Issues or feature requests about Go vulnerability management
-title: "x/vuln: "
-labels: "vulncheck or vulndb"
----
-
-<!--
-Please answer these questions before submitting your issue. Thanks!
-
-To add a new vulnerability to the Go vulnerability database
-(https://vuln.go.dev), see https://go.dev/s/vulndb-report-new.
-
-To report an issue about a report, see https://go.dev/s/vulndb-report-feedback.
--->
-
-### What version of Go are you using (`go version`)?
-
-<pre>
-$ go version
-
-</pre>
-
-### Does this issue reproduce at the latest version of golang.org/x/vuln?
-
-
-
-### What operating system and processor architecture are you using (`go env`)?
-
-<details><summary><code>go env</code> Output</summary><br><pre>
-$ go env
-
-</pre></details>
-
-### What did you do?
-
-<!--
-If possible, provide a recipe for reproducing the error.
-A complete runnable program is good.
-A link on go.dev/play is best.
--->
-
-
-
-### What did you expect to see?
-
-
-
-### What did you see instead?
-
-

.github/SUPPORT.md

@@ -1,5 +1,5 @@
 Unlike many projects on GitHub, the Go project does not use its bug tracker for general discussion or asking questions.
-We only use our bug tracker for tracking bugs and tracking proposals going through the [Proposal Process](https://go.dev/s/proposal-process).
+We only use our bug tracker for tracking bugs and tracking proposals going through the [Proposal Process](https://golang.org/s/proposal-process).
 
 For asking questions, see:
 

.gitignore

@@ -33,13 +33,13 @@ _testmain.go
 /src/cmd/cgo/zdefaultcc.go
 /src/cmd/dist/dist
 /src/cmd/go/internal/cfg/zdefaultcc.go
+/src/cmd/go/internal/cfg/zosarch.go
 /src/cmd/internal/objabi/zbootstrap.go
 /src/go/build/zcgo.go
 /src/go/doc/headscan
 /src/internal/buildcfg/zbootstrap.go
 /src/runtime/internal/sys/zversion.go
 /src/unicode/maketables
-/src/time/tzdata/zzipdata.go
 /test.out
 /test/garbage/*.out
 /test/pass.out

CONTRIBUTING.md

@@ -24,7 +24,7 @@ Otherwise, when filing an issue, make sure to answer these five questions:
 4. What did you expect to see?
 5. What did you see instead?
 
-For change proposals, see [Proposing Changes To Go](https://go.dev/s/proposal-process).
+For change proposals, see [Proposing Changes To Go](https://github.com/golang/proposal/).
 
 ## Contributing code
 

README.md

@@ -4,7 +4,7 @@ Go is an open source programming language that makes it easy to build simple,
 reliable, and efficient software.
 
 ![Gopher image](https://golang.org/doc/gopher/fiveyears.jpg)
-*Gopher image by [Renee French][rf], licensed under [Creative Commons 4.0 Attributions license][cc4-by].*
+*Gopher image by [Renee French][rf], licensed under [Creative Commons 3.0 Attributions license][cc3-by].*
 
 Our canonical Git repository is located at https://go.googlesource.com/go.
 There is a mirror of the repository at https://github.com/golang/go.
@@ -39,4 +39,4 @@ proposals only. See https://go.dev/wiki/Questions for a list of
 places to ask questions about the Go language.
 
 [rf]: https://reneefrench.blogspot.com/
-[cc4-by]: https://creativecommons.org/licenses/by/4.0/
+[cc3-by]: https://creativecommons.org/licenses/by/3.0/

VERSION

@@ -0,0 +1 @@
+go1.19.11

api/except.txt

@@ -1,5 +1,3 @@
-pkg crypto/tls, type ConnectionState struct, TLSUnique //deprecated
-pkg debug/elf, const R_PPC64_SECTOFF_LO_DS = 61
 pkg encoding/json, method (*RawMessage) MarshalJSON() ([]uint8, error)
 pkg math, const MaxFloat64 = 1.79769e+308  // 179769313486231570814527423731704356798100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
 pkg math, const SmallestNonzeroFloat32 = 1.4013e-45  // 17516230804060213386546619791123951641/12500000000000000000000000000000000000000000000000000000000000000000000000000000000
@@ -502,7 +500,6 @@ pkg text/template/parse, type Node interface { Copy, String, Type }
 pkg unicode, const Version = "10.0.0"
 pkg unicode, const Version = "11.0.0"
 pkg unicode, const Version = "12.0.0"
-pkg unicode, const Version = "13.0.0"
 pkg unicode, const Version = "6.2.0"
 pkg unicode, const Version = "6.3.0"
 pkg unicode, const Version = "7.0.0"
@@ -510,91 +507,3 @@ pkg unicode, const Version = "8.0.0"
 pkg unicode, const Version = "9.0.0"
 pkg html/template, method (*Template) Funcs(FuncMap) *Template
 pkg html/template, type FuncMap map[string]interface{}
-pkg syscall (freebsd-386), const SYS_FSTAT = 189
-pkg syscall (freebsd-386), const SYS_FSTATAT = 493
-pkg syscall (freebsd-386), const SYS_FSTATFS = 397
-pkg syscall (freebsd-386), const SYS_GETDIRENTRIES = 196
-pkg syscall (freebsd-386), const SYS_GETFSSTAT = 395
-pkg syscall (freebsd-386), const SYS_LSTAT = 190
-pkg syscall (freebsd-386), const SYS_LSTAT ideal-int
-pkg syscall (freebsd-386), const SYS_MKNODAT = 498
-pkg syscall (freebsd-386), const SYS_STAT = 188
-pkg syscall (freebsd-386), const SYS_STAT ideal-int
-pkg syscall (freebsd-386), const SYS_STATFS = 396
-pkg syscall (freebsd-386-cgo), const SYS_FSTAT = 189
-pkg syscall (freebsd-386-cgo), const SYS_FSTATAT = 493
-pkg syscall (freebsd-386-cgo), const SYS_FSTATFS = 397
-pkg syscall (freebsd-386-cgo), const SYS_GETDIRENTRIES = 196
-pkg syscall (freebsd-386-cgo), const SYS_GETFSSTAT = 395
-pkg syscall (freebsd-386-cgo), const SYS_LSTAT = 190
-pkg syscall (freebsd-386-cgo), const SYS_LSTAT ideal-int
-pkg syscall (freebsd-386-cgo), const SYS_MKNODAT = 498
-pkg syscall (freebsd-386-cgo), const SYS_STAT = 188
-pkg syscall (freebsd-386-cgo), const SYS_STAT ideal-int
-pkg syscall (freebsd-386-cgo), const SYS_STATFS = 396
-pkg syscall (freebsd-amd64), const SYS_FSTAT = 189
-pkg syscall (freebsd-amd64), const SYS_FSTATAT = 493
-pkg syscall (freebsd-amd64), const SYS_FSTATFS = 397
-pkg syscall (freebsd-amd64), const SYS_GETDIRENTRIES = 196
-pkg syscall (freebsd-amd64), const SYS_GETFSSTAT = 395
-pkg syscall (freebsd-amd64), const SYS_LSTAT = 190
-pkg syscall (freebsd-amd64), const SYS_LSTAT ideal-int
-pkg syscall (freebsd-amd64), const SYS_MKNODAT = 498
-pkg syscall (freebsd-amd64), const SYS_STAT = 188
-pkg syscall (freebsd-amd64), const SYS_STAT ideal-int
-pkg syscall (freebsd-amd64), const SYS_STATFS = 396
-pkg syscall (freebsd-amd64-cgo), const SYS_FSTAT = 189
-pkg syscall (freebsd-amd64-cgo), const SYS_FSTATAT = 493
-pkg syscall (freebsd-amd64-cgo), const SYS_FSTATFS = 397
-pkg syscall (freebsd-amd64-cgo), const SYS_GETDIRENTRIES = 196
-pkg syscall (freebsd-amd64-cgo), const SYS_GETFSSTAT = 395
-pkg syscall (freebsd-amd64-cgo), const SYS_LSTAT = 190
-pkg syscall (freebsd-amd64-cgo), const SYS_LSTAT ideal-int
-pkg syscall (freebsd-amd64-cgo), const SYS_MKNODAT = 498
-pkg syscall (freebsd-amd64-cgo), const SYS_STAT = 188
-pkg syscall (freebsd-amd64-cgo), const SYS_STAT ideal-int
-pkg syscall (freebsd-amd64-cgo), const SYS_STATFS = 396
-pkg syscall (freebsd-arm), const SYS_FSTAT = 189
-pkg syscall (freebsd-arm), const SYS_FSTATAT = 493
-pkg syscall (freebsd-arm), const SYS_FSTATFS = 397
-pkg syscall (freebsd-arm), const SYS_GETDIRENTRIES = 196
-pkg syscall (freebsd-arm), const SYS_GETFSSTAT = 395
-pkg syscall (freebsd-arm), const SYS_LSTAT = 190
-pkg syscall (freebsd-arm), const SYS_LSTAT ideal-int
-pkg syscall (freebsd-arm), const SYS_MKNODAT = 498
-pkg syscall (freebsd-arm), const SYS_STAT = 188
-pkg syscall (freebsd-arm), const SYS_STAT ideal-int
-pkg syscall (freebsd-arm), const SYS_STATFS = 396
-pkg syscall (freebsd-arm-cgo), const SYS_FSTAT = 189
-pkg syscall (freebsd-arm-cgo), const SYS_FSTATAT = 493
-pkg syscall (freebsd-arm-cgo), const SYS_FSTATFS = 397
-pkg syscall (freebsd-arm-cgo), const SYS_GETDIRENTRIES = 196
-pkg syscall (freebsd-arm-cgo), const SYS_GETFSSTAT = 395
-pkg syscall (freebsd-arm-cgo), const SYS_LSTAT = 190
-pkg syscall (freebsd-arm-cgo), const SYS_LSTAT ideal-int
-pkg syscall (freebsd-arm-cgo), const SYS_MKNODAT = 498
-pkg syscall (freebsd-arm-cgo), const SYS_STAT = 188
-pkg syscall (freebsd-arm-cgo), const SYS_STAT ideal-int
-pkg syscall (freebsd-arm-cgo), const SYS_STATFS = 396
-pkg syscall (freebsd-arm64), const SYS_FSTAT = 189
-pkg syscall (freebsd-arm64), const SYS_FSTATAT = 493
-pkg syscall (freebsd-arm64), const SYS_FSTATFS = 397
-pkg syscall (freebsd-arm64), const SYS_GETDIRENTRIES = 196
-pkg syscall (freebsd-arm64), const SYS_GETFSSTAT = 395
-pkg syscall (freebsd-arm64), const SYS_LSTAT = 190
-pkg syscall (freebsd-arm64), const SYS_LSTAT ideal-int
-pkg syscall (freebsd-arm64), const SYS_MKNODAT = 498
-pkg syscall (freebsd-arm64), const SYS_STAT = 188
-pkg syscall (freebsd-arm64), const SYS_STAT ideal-int
-pkg syscall (freebsd-arm64), const SYS_STATFS = 396
-pkg syscall (freebsd-arm64-cgo), const SYS_FSTAT = 189
-pkg syscall (freebsd-arm64-cgo), const SYS_FSTATAT = 493
-pkg syscall (freebsd-arm64-cgo), const SYS_FSTATFS = 397
-pkg syscall (freebsd-arm64-cgo), const SYS_GETDIRENTRIES = 196
-pkg syscall (freebsd-arm64-cgo), const SYS_GETFSSTAT = 395
-pkg syscall (freebsd-arm64-cgo), const SYS_LSTAT = 190
-pkg syscall (freebsd-arm64-cgo), const SYS_LSTAT ideal-int
-pkg syscall (freebsd-arm64-cgo), const SYS_MKNODAT = 498
-pkg syscall (freebsd-arm64-cgo), const SYS_STAT = 188
-pkg syscall (freebsd-arm64-cgo), const SYS_STAT ideal-int
-pkg syscall (freebsd-arm64-cgo), const SYS_STATFS = 396

api/go1.17.txt

@@ -69,12 +69,6 @@ pkg math (darwin-amd64), const MinInt = -9223372036854775808
 pkg math (darwin-amd64-cgo), const MaxInt = 9223372036854775807
 pkg math (darwin-amd64-cgo), const MaxUint = 18446744073709551615
 pkg math (darwin-amd64-cgo), const MinInt = -9223372036854775808
-pkg math (darwin-arm64), const MaxInt = 9223372036854775807
-pkg math (darwin-arm64), const MaxUint = 18446744073709551615
-pkg math (darwin-arm64), const MinInt = -9223372036854775808
-pkg math (darwin-arm64-cgo), const MaxInt = 9223372036854775807
-pkg math (darwin-arm64-cgo), const MaxUint = 18446744073709551615
-pkg math (darwin-arm64-cgo), const MinInt = -9223372036854775808
 pkg math (freebsd-386), const MaxInt = 2147483647
 pkg math (freebsd-386), const MaxUint = 4294967295
 pkg math (freebsd-386), const MinInt = -2147483648
@@ -93,12 +87,6 @@ pkg math (freebsd-arm), const MinInt = -2147483648
 pkg math (freebsd-arm-cgo), const MaxInt = 2147483647
 pkg math (freebsd-arm-cgo), const MaxUint = 4294967295
 pkg math (freebsd-arm-cgo), const MinInt = -2147483648
-pkg math (freebsd-arm64), const MaxInt = 9223372036854775807
-pkg math (freebsd-arm64), const MaxUint = 18446744073709551615
-pkg math (freebsd-arm64), const MinInt = -9223372036854775808
-pkg math (freebsd-arm64-cgo), const MaxInt = 9223372036854775807
-pkg math (freebsd-arm64-cgo), const MaxUint = 18446744073709551615
-pkg math (freebsd-arm64-cgo), const MinInt = -9223372036854775808
 pkg math (linux-386), const MaxInt = 2147483647
 pkg math (linux-386), const MaxUint = 4294967295
 pkg math (linux-386), const MinInt = -2147483648
@@ -174,15 +162,10 @@ pkg reflect, func VisibleFields(Type) []StructField
 pkg reflect, method (Method) IsExported() bool
 pkg reflect, method (StructField) IsExported() bool
 pkg reflect, method (Value) CanConvert(Type) bool
-pkg reflect, method (Value) InterfaceData //deprecated
 pkg runtime/cgo (darwin-amd64-cgo), func NewHandle(interface{}) Handle
 pkg runtime/cgo (darwin-amd64-cgo), method (Handle) Delete()
 pkg runtime/cgo (darwin-amd64-cgo), method (Handle) Value() interface{}
 pkg runtime/cgo (darwin-amd64-cgo), type Handle uintptr
-pkg runtime/cgo (darwin-arm64-cgo), func NewHandle(interface{}) Handle
-pkg runtime/cgo (darwin-arm64-cgo), method (Handle) Delete()
-pkg runtime/cgo (darwin-arm64-cgo), method (Handle) Value() interface{}
-pkg runtime/cgo (darwin-arm64-cgo), type Handle uintptr
 pkg runtime/cgo (freebsd-386-cgo), func NewHandle(interface{}) Handle
 pkg runtime/cgo (freebsd-386-cgo), method (Handle) Delete()
 pkg runtime/cgo (freebsd-386-cgo), method (Handle) Value() interface{}
@@ -195,10 +178,6 @@ pkg runtime/cgo (freebsd-arm-cgo), func NewHandle(interface{}) Handle
 pkg runtime/cgo (freebsd-arm-cgo), method (Handle) Delete()
 pkg runtime/cgo (freebsd-arm-cgo), method (Handle) Value() interface{}
 pkg runtime/cgo (freebsd-arm-cgo), type Handle uintptr
-pkg runtime/cgo (freebsd-arm64-cgo), func NewHandle(interface{}) Handle
-pkg runtime/cgo (freebsd-arm64-cgo), method (Handle) Delete()
-pkg runtime/cgo (freebsd-arm64-cgo), method (Handle) Value() interface{}
-pkg runtime/cgo (freebsd-arm64-cgo), type Handle uintptr
 pkg runtime/cgo (linux-386-cgo), func NewHandle(interface{}) Handle
 pkg runtime/cgo (linux-386-cgo), method (Handle) Delete()
 pkg runtime/cgo (linux-386-cgo), method (Handle) Value() interface{}
@@ -278,14 +257,8 @@ pkg syscall (openbsd-amd64), const MSG_CMSG_CLOEXEC = 2048
 pkg syscall (openbsd-amd64), const MSG_CMSG_CLOEXEC ideal-int
 pkg syscall (openbsd-amd64-cgo), const MSG_CMSG_CLOEXEC = 2048
 pkg syscall (openbsd-amd64-cgo), const MSG_CMSG_CLOEXEC ideal-int
-pkg syscall (windows-386), func CreateIoCompletionPort //deprecated
-pkg syscall (windows-386), func GetQueuedCompletionStatus //deprecated
-pkg syscall (windows-386), func PostQueuedCompletionStatus //deprecated
 pkg syscall (windows-386), type SysProcAttr struct, AdditionalInheritedHandles []Handle
 pkg syscall (windows-386), type SysProcAttr struct, ParentProcess Handle
-pkg syscall (windows-amd64), func CreateIoCompletionPort //deprecated
-pkg syscall (windows-amd64), func GetQueuedCompletionStatus //deprecated
-pkg syscall (windows-amd64), func PostQueuedCompletionStatus //deprecated
 pkg syscall (windows-amd64), type SysProcAttr struct, AdditionalInheritedHandles []Handle
 pkg syscall (windows-amd64), type SysProcAttr struct, ParentProcess Handle
 pkg testing, method (*B) Setenv(string, string)

api/go1.18.txt

@@ -1,17 +1,14 @@
 pkg bufio, method (*Writer) AvailableBuffer() []uint8
 pkg bufio, method (ReadWriter) AvailableBuffer() []uint8
 pkg bytes, func Cut([]uint8, []uint8) ([]uint8, []uint8, bool)
-pkg bytes, func Title //deprecated
 pkg crypto/tls, method (*Conn) NetConn() net.Conn
-pkg crypto/tls, type Config struct, PreferServerCipherSuites //deprecated
-pkg crypto/x509, method (*CertPool) Subjects //deprecated
 pkg debug/buildinfo, func Read(io.ReaderAt) (*debug.BuildInfo, error)
 pkg debug/buildinfo, func ReadFile(string) (*debug.BuildInfo, error)
 pkg debug/buildinfo, type BuildInfo = debug.BuildInfo
-pkg debug/dwarf, type BasicType struct, DataBitOffset int64
-pkg debug/dwarf, type StructField struct, DataBitOffset int64
 pkg debug/elf, const R_PPC64_RELATIVE = 22
 pkg debug/elf, const R_PPC64_RELATIVE R_PPC64
+pkg debug/dwarf, type BasicType struct, DataBitOffset int64
+pkg debug/dwarf, type StructField struct, DataBitOffset int64
 pkg debug/plan9obj, var ErrNoSymbols error
 pkg go/ast, method (*IndexListExpr) End() token.Pos
 pkg go/ast, method (*IndexListExpr) Pos() token.Pos
@@ -27,7 +24,6 @@ pkg go/token, const TILDE = 88
 pkg go/token, const TILDE Token
 pkg go/types, func Instantiate(*Context, Type, []Type, bool) (Type, error)
 pkg go/types, func NewContext() *Context
-pkg go/types, func NewSignature //deprecated
 pkg go/types, func NewSignatureType(*Var, []*TypeParam, []*TypeParam, *Tuple, *Tuple, bool) *Signature
 pkg go/types, func NewTerm(bool, Type) *Term
 pkg go/types, func NewTypeParam(*TypeName, Type) *TypeParam
@@ -85,7 +81,6 @@ pkg net, method (*UDPConn) ReadFromUDPAddrPort([]uint8) (int, netip.AddrPort, er
 pkg net, method (*UDPConn) ReadMsgUDPAddrPort([]uint8, []uint8) (int, int, int, netip.AddrPort, error)
 pkg net, method (*UDPConn) WriteMsgUDPAddrPort([]uint8, []uint8, netip.AddrPort) (int, int, error)
 pkg net, method (*UDPConn) WriteToUDPAddrPort([]uint8, netip.AddrPort) (int, error)
-pkg net, type Error interface, Temporary //deprecated
 pkg net/http, func MaxBytesHandler(Handler, int64) Handler
 pkg net/http, method (*Cookie) Valid() error
 pkg net/netip, func AddrFrom16([16]uint8) Addr
@@ -179,7 +174,6 @@ pkg runtime/debug, type BuildSetting struct, Key string
 pkg runtime/debug, type BuildSetting struct, Value string
 pkg strings, func Clone(string) string
 pkg strings, func Cut(string, string) (string, string, bool)
-pkg strings, func Title //deprecated
 pkg sync, method (*Mutex) TryLock() bool
 pkg sync, method (*RWMutex) TryLock() bool
 pkg sync, method (*RWMutex) TryRLock() bool
@@ -189,21 +183,7 @@ pkg syscall (freebsd-amd64), type SysProcAttr struct, Pdeathsig Signal
 pkg syscall (freebsd-amd64-cgo), type SysProcAttr struct, Pdeathsig Signal
 pkg syscall (freebsd-arm), type SysProcAttr struct, Pdeathsig Signal
 pkg syscall (freebsd-arm-cgo), type SysProcAttr struct, Pdeathsig Signal
-pkg syscall (freebsd-arm64), type SysProcAttr struct, Pdeathsig Signal
-pkg syscall (freebsd-arm64-cgo), type SysProcAttr struct, Pdeathsig Signal
-pkg syscall (windows-386), func Syscall //deprecated
-pkg syscall (windows-386), func Syscall12 //deprecated
-pkg syscall (windows-386), func Syscall15 //deprecated
-pkg syscall (windows-386), func Syscall18 //deprecated
-pkg syscall (windows-386), func Syscall6 //deprecated
-pkg syscall (windows-386), func Syscall9 //deprecated
 pkg syscall (windows-386), func SyscallN(uintptr, ...uintptr) (uintptr, uintptr, Errno)
-pkg syscall (windows-amd64), func Syscall //deprecated
-pkg syscall (windows-amd64), func Syscall12 //deprecated
-pkg syscall (windows-amd64), func Syscall15 //deprecated
-pkg syscall (windows-amd64), func Syscall18 //deprecated
-pkg syscall (windows-amd64), func Syscall6 //deprecated
-pkg syscall (windows-amd64), func Syscall9 //deprecated
 pkg syscall (windows-amd64), func SyscallN(uintptr, ...uintptr) (uintptr, uintptr, Errno)
 pkg testing, func MainStart(testDeps, []InternalTest, []InternalBenchmark, []InternalFuzzTarget, []InternalExample) *M
 pkg testing, method (*F) Add(...interface{})

api/go1.19.txt

@@ -290,20 +290,3 @@ pkg sync/atomic, type Uint64 struct #50860
 pkg sync/atomic, type Uintptr struct #50860
 pkg time, method (Duration) Abs() Duration #51414
 pkg time, method (Time) ZoneBounds() (Time, Time) #50062
-pkg crypto/x509, func ParseCRL //deprecated #50674
-pkg crypto/x509, func ParseDERCRL //deprecated #50674
-pkg crypto/x509, method (*Certificate) CheckCRLSignature //deprecated #50674
-pkg crypto/x509, method (*Certificate) CreateCRL //deprecated #50674
-pkg crypto/x509/pkix, type CertificateList //deprecated #50674
-pkg crypto/x509/pkix, type TBSCertificateList //deprecated #50674
-pkg go/doc, func Synopsis //deprecated #51082
-pkg go/doc, func ToHTML //deprecated #51082
-pkg go/doc, func ToText //deprecated #51082
-pkg io/ioutil, func NopCloser //deprecated #42026
-pkg io/ioutil, func ReadAll //deprecated #42026
-pkg io/ioutil, func ReadDir //deprecated #42026
-pkg io/ioutil, func ReadFile //deprecated #42026
-pkg io/ioutil, func TempDir //deprecated #42026
-pkg io/ioutil, func TempFile //deprecated #42026
-pkg io/ioutil, func WriteFile //deprecated #42026
-pkg io/ioutil, var Discard //deprecated #42026

api/go1.21.txt

@@ -1,421 +0,0 @@
-pkg bytes, func ContainsFunc([]uint8, func(int32) bool) bool #54386
-pkg bytes, method (*Buffer) AvailableBuffer() []uint8 #53685
-pkg bytes, method (*Buffer) Available() int #53685
-pkg cmp, func Compare[$0 Ordered]($0, $0) int #59488
-pkg cmp, func Less[$0 Ordered]($0, $0) bool #59488
-pkg cmp, type Ordered interface {} #59488
-pkg context, func AfterFunc(Context, func()) func() bool #57928
-pkg context, func WithDeadlineCause(Context, time.Time, error) (Context, CancelFunc) #56661
-pkg context, func WithoutCancel(Context) Context #40221
-pkg context, func WithTimeoutCause(Context, time.Duration, error) (Context, CancelFunc) #56661
-pkg crypto/elliptic, func GenerateKey //deprecated #52221
-pkg crypto/elliptic, func Marshal //deprecated #52221
-pkg crypto/elliptic, func Unmarshal //deprecated #52221
-pkg crypto/elliptic, method (*CurveParams) Add //deprecated #34648
-pkg crypto/elliptic, method (*CurveParams) Double //deprecated #34648
-pkg crypto/elliptic, method (*CurveParams) IsOnCurve //deprecated #34648
-pkg crypto/elliptic, method (*CurveParams) ScalarBaseMult //deprecated #34648
-pkg crypto/elliptic, method (*CurveParams) ScalarMult //deprecated #34648
-pkg crypto/elliptic, type Curve interface, Add //deprecated #52221
-pkg crypto/elliptic, type Curve interface, Double //deprecated #52221
-pkg crypto/elliptic, type Curve interface, IsOnCurve //deprecated #52221
-pkg crypto/elliptic, type Curve interface, ScalarBaseMult //deprecated #52221
-pkg crypto/elliptic, type Curve interface, ScalarMult //deprecated #52221
-pkg crypto/rsa, func GenerateMultiPrimeKey //deprecated #56921
-pkg crypto/rsa, type PrecomputedValues struct, CRTValues //deprecated #56921
-pkg crypto/tls, const QUICEncryptionLevelApplication = 3 #44886
-pkg crypto/tls, const QUICEncryptionLevelApplication QUICEncryptionLevel #44886
-pkg crypto/tls, const QUICEncryptionLevelEarly = 1 #60107
-pkg crypto/tls, const QUICEncryptionLevelEarly QUICEncryptionLevel #60107
-pkg crypto/tls, const QUICEncryptionLevelHandshake = 2 #44886
-pkg crypto/tls, const QUICEncryptionLevelHandshake QUICEncryptionLevel #44886
-pkg crypto/tls, const QUICEncryptionLevelInitial = 0 #44886
-pkg crypto/tls, const QUICEncryptionLevelInitial QUICEncryptionLevel #44886
-pkg crypto/tls, const QUICHandshakeDone = 7 #44886
-pkg crypto/tls, const QUICHandshakeDone QUICEventKind #44886
-pkg crypto/tls, const QUICNoEvent = 0 #44886
-pkg crypto/tls, const QUICNoEvent QUICEventKind #44886
-pkg crypto/tls, const QUICRejectedEarlyData = 6 #60107
-pkg crypto/tls, const QUICRejectedEarlyData QUICEventKind #60107
-pkg crypto/tls, const QUICSetReadSecret = 1 #44886
-pkg crypto/tls, const QUICSetReadSecret QUICEventKind #44886
-pkg crypto/tls, const QUICSetWriteSecret = 2 #44886
-pkg crypto/tls, const QUICSetWriteSecret QUICEventKind #44886
-pkg crypto/tls, const QUICTransportParameters = 4 #44886
-pkg crypto/tls, const QUICTransportParameters QUICEventKind #44886
-pkg crypto/tls, const QUICTransportParametersRequired = 5 #44886
-pkg crypto/tls, const QUICTransportParametersRequired QUICEventKind #44886
-pkg crypto/tls, const QUICWriteData = 3 #44886
-pkg crypto/tls, const QUICWriteData QUICEventKind #44886
-pkg crypto/tls, func NewResumptionState([]uint8, *SessionState) (*ClientSessionState, error) #60105
-pkg crypto/tls, func ParseSessionState([]uint8) (*SessionState, error) #60105
-pkg crypto/tls, func QUICClient(*QUICConfig) *QUICConn #44886
-pkg crypto/tls, func QUICServer(*QUICConfig) *QUICConn #44886
-pkg crypto/tls, func VersionName(uint16) string #46308
-pkg crypto/tls, method (AlertError) Error() string #44886
-pkg crypto/tls, method (*ClientSessionState) ResumptionState() ([]uint8, *SessionState, error) #60105
-pkg crypto/tls, method (*Config) DecryptTicket([]uint8, ConnectionState) (*SessionState, error) #60105
-pkg crypto/tls, method (*Config) EncryptTicket(ConnectionState, *SessionState) ([]uint8, error) #60105
-pkg crypto/tls, method (*QUICConn) Close() error #44886
-pkg crypto/tls, method (*QUICConn) ConnectionState() ConnectionState #44886
-pkg crypto/tls, method (*QUICConn) HandleData(QUICEncryptionLevel, []uint8) error #44886
-pkg crypto/tls, method (*QUICConn) NextEvent() QUICEvent #44886
-pkg crypto/tls, method (*QUICConn) SendSessionTicket(bool) error #60107
-pkg crypto/tls, method (*QUICConn) SetTransportParameters([]uint8) #44886
-pkg crypto/tls, method (*QUICConn) Start(context.Context) error #44886
-pkg crypto/tls, method (QUICEncryptionLevel) String() string #44886
-pkg crypto/tls, method (*SessionState) Bytes() ([]uint8, error) #60105
-pkg crypto/tls, type AlertError uint8 #44886
-pkg crypto/tls, type Config struct, UnwrapSession func([]uint8, ConnectionState) (*SessionState, error) #60105
-pkg crypto/tls, type Config struct, WrapSession func(ConnectionState, *SessionState) ([]uint8, error) #60105
-pkg crypto/tls, type QUICConfig struct #44886
-pkg crypto/tls, type QUICConfig struct, TLSConfig *Config #44886
-pkg crypto/tls, type QUICConn struct #44886
-pkg crypto/tls, type QUICEncryptionLevel int #44886
-pkg crypto/tls, type QUICEventKind int #44886
-pkg crypto/tls, type QUICEvent struct #44886
-pkg crypto/tls, type QUICEvent struct, Data []uint8 #44886
-pkg crypto/tls, type QUICEvent struct, Kind QUICEventKind #44886
-pkg crypto/tls, type QUICEvent struct, Level QUICEncryptionLevel #44886
-pkg crypto/tls, type QUICEvent struct, Suite uint16 #44886
-pkg crypto/tls, type SessionState struct #60105
-pkg crypto/tls, type SessionState struct, EarlyData bool #60107
-pkg crypto/tls, type SessionState struct, Extra [][]uint8 #60539
-pkg crypto/x509, type RevocationListEntry struct #53573
-pkg crypto/x509, type RevocationListEntry struct, Extensions []pkix.Extension #53573
-pkg crypto/x509, type RevocationListEntry struct, ExtraExtensions []pkix.Extension #53573
-pkg crypto/x509, type RevocationListEntry struct, Raw []uint8 #53573
-pkg crypto/x509, type RevocationListEntry struct, ReasonCode int #53573
-pkg crypto/x509, type RevocationListEntry struct, RevocationTime time.Time #53573
-pkg crypto/x509, type RevocationListEntry struct, SerialNumber *big.Int #53573
-pkg crypto/x509, type RevocationList struct, RevokedCertificateEntries []RevocationListEntry #53573
-pkg crypto/x509, type RevocationList struct, RevokedCertificates //deprecated #53573
-pkg debug/elf, const COMPRESS_ZSTD = 2 #55107
-pkg debug/elf, const COMPRESS_ZSTD CompressionType #55107
-pkg debug/elf, const DF_1_CONFALT = 8192 #56887
-pkg debug/elf, const DF_1_CONFALT DynFlag1 #56887
-pkg debug/elf, const DF_1_DIRECT = 256 #56887
-pkg debug/elf, const DF_1_DIRECT DynFlag1 #56887
-pkg debug/elf, const DF_1_DISPRELDNE = 32768 #56887
-pkg debug/elf, const DF_1_DISPRELDNE DynFlag1 #56887
-pkg debug/elf, const DF_1_DISPRELPND = 65536 #56887
-pkg debug/elf, const DF_1_DISPRELPND DynFlag1 #56887
-pkg debug/elf, const DF_1_EDITED = 2097152 #56887
-pkg debug/elf, const DF_1_EDITED DynFlag1 #56887
-pkg debug/elf, const DF_1_ENDFILTEE = 16384 #56887
-pkg debug/elf, const DF_1_ENDFILTEE DynFlag1 #56887
-pkg debug/elf, const DF_1_GLOBAL = 2 #56887
-pkg debug/elf, const DF_1_GLOBAL DynFlag1 #56887
-pkg debug/elf, const DF_1_GLOBAUDIT = 16777216 #56887
-pkg debug/elf, const DF_1_GLOBAUDIT DynFlag1 #56887
-pkg debug/elf, const DF_1_GROUP = 4 #56887
-pkg debug/elf, const DF_1_GROUP DynFlag1 #56887
-pkg debug/elf, const DF_1_IGNMULDEF = 262144 #56887
-pkg debug/elf, const DF_1_IGNMULDEF DynFlag1 #56887
-pkg debug/elf, const DF_1_INITFIRST = 32 #56887
-pkg debug/elf, const DF_1_INITFIRST DynFlag1 #56887
-pkg debug/elf, const DF_1_INTERPOSE = 1024 #56887
-pkg debug/elf, const DF_1_INTERPOSE DynFlag1 #56887
-pkg debug/elf, const DF_1_KMOD = 268435456 #56887
-pkg debug/elf, const DF_1_KMOD DynFlag1 #56887
-pkg debug/elf, const DF_1_LOADFLTR = 16 #56887
-pkg debug/elf, const DF_1_LOADFLTR DynFlag1 #56887
-pkg debug/elf, const DF_1_NOCOMMON = 1073741824 #56887
-pkg debug/elf, const DF_1_NOCOMMON DynFlag1 #56887
-pkg debug/elf, const DF_1_NODEFLIB = 2048 #56887
-pkg debug/elf, const DF_1_NODEFLIB DynFlag1 #56887
-pkg debug/elf, const DF_1_NODELETE = 8 #56887
-pkg debug/elf, const DF_1_NODELETE DynFlag1 #56887
-pkg debug/elf, const DF_1_NODIRECT = 131072 #56887
-pkg debug/elf, const DF_1_NODIRECT DynFlag1 #56887
-pkg debug/elf, const DF_1_NODUMP = 4096 #56887
-pkg debug/elf, const DF_1_NODUMP DynFlag1 #56887
-pkg debug/elf, const DF_1_NOHDR = 1048576 #56887
-pkg debug/elf, const DF_1_NOHDR DynFlag1 #56887
-pkg debug/elf, const DF_1_NOKSYMS = 524288 #56887
-pkg debug/elf, const DF_1_NOKSYMS DynFlag1 #56887
-pkg debug/elf, const DF_1_NOOPEN = 64 #56887
-pkg debug/elf, const DF_1_NOOPEN DynFlag1 #56887
-pkg debug/elf, const DF_1_NORELOC = 4194304 #56887
-pkg debug/elf, const DF_1_NORELOC DynFlag1 #56887
-pkg debug/elf, const DF_1_NOW = 1 #56887
-pkg debug/elf, const DF_1_NOW DynFlag1 #56887
-pkg debug/elf, const DF_1_ORIGIN = 128 #56887
-pkg debug/elf, const DF_1_ORIGIN DynFlag1 #56887
-pkg debug/elf, const DF_1_PIE = 134217728 #56887
-pkg debug/elf, const DF_1_PIE DynFlag1 #56887
-pkg debug/elf, const DF_1_SINGLETON = 33554432 #56887
-pkg debug/elf, const DF_1_SINGLETON DynFlag1 #56887
-pkg debug/elf, const DF_1_STUB = 67108864 #56887
-pkg debug/elf, const DF_1_STUB DynFlag1 #56887
-pkg debug/elf, const DF_1_SYMINTPOSE = 8388608 #56887
-pkg debug/elf, const DF_1_SYMINTPOSE DynFlag1 #56887
-pkg debug/elf, const DF_1_TRANS = 512 #56887
-pkg debug/elf, const DF_1_TRANS DynFlag1 #56887
-pkg debug/elf, const DF_1_WEAKFILTER = 536870912 #56887
-pkg debug/elf, const DF_1_WEAKFILTER DynFlag1 #56887
-pkg debug/elf, const R_PPC64_REL24_P9NOTOC = 124 #60348
-pkg debug/elf, const R_PPC64_REL24_P9NOTOC R_PPC64 #60348
-pkg debug/elf, method (DynFlag1) GoString() string #56887
-pkg debug/elf, method (DynFlag1) String() string #56887
-pkg debug/elf, method (*File) DynValue(DynTag) ([]uint64, error) #56892
-pkg debug/elf, type DynFlag1 uint32 #56887
-pkg encoding/binary, var NativeEndian nativeEndian #57237
-pkg errors, var ErrUnsupported error #41198
-pkg flag, func BoolFunc(string, string, func(string) error) #53747
-pkg flag, method (*FlagSet) BoolFunc(string, string, func(string) error) #53747
-pkg go/ast, func IsGenerated(*File) bool #28089
-pkg go/ast, type File struct, GoVersion string #59033
-pkg go/build/constraint, func GoVersion(Expr) string #59033
-pkg go/build, type Directive struct #56986
-pkg go/build, type Directive struct, Pos token.Position #56986
-pkg go/build, type Directive struct, Text string #56986
-pkg go/build, type Package struct, Directives []Directive #56986
-pkg go/build, type Package struct, TestDirectives []Directive #56986
-pkg go/build, type Package struct, XTestDirectives []Directive #56986
-pkg go/token, method (*File) Lines() []int #57708
-pkg go/types, method (*Package) GoVersion() string #61175
-pkg html/template, const ErrJSTemplate = 12 #59584
-pkg html/template, const ErrJSTemplate ErrorCode #59584
-pkg io/fs, func FormatDirEntry(DirEntry) string #54451
-pkg io/fs, func FormatFileInfo(FileInfo) string #54451
-pkg log/slog, const KindAny = 0 #56345
-pkg log/slog, const KindAny Kind #56345
-pkg log/slog, const KindBool = 1 #56345
-pkg log/slog, const KindBool Kind #56345
-pkg log/slog, const KindDuration = 2 #56345
-pkg log/slog, const KindDuration Kind #56345
-pkg log/slog, const KindFloat64 = 3 #56345
-pkg log/slog, const KindFloat64 Kind #56345
-pkg log/slog, const KindGroup = 8 #56345
-pkg log/slog, const KindGroup Kind #56345
-pkg log/slog, const KindInt64 = 4 #56345
-pkg log/slog, const KindInt64 Kind #56345
-pkg log/slog, const KindLogValuer = 9 #56345
-pkg log/slog, const KindLogValuer Kind #56345
-pkg log/slog, const KindString = 5 #56345
-pkg log/slog, const KindString Kind #56345
-pkg log/slog, const KindTime = 6 #56345
-pkg log/slog, const KindTime Kind #56345
-pkg log/slog, const KindUint64 = 7 #56345
-pkg log/slog, const KindUint64 Kind #56345
-pkg log/slog, const LevelDebug = -4 #56345
-pkg log/slog, const LevelDebug Level #56345
-pkg log/slog, const LevelError = 8 #56345
-pkg log/slog, const LevelError Level #56345
-pkg log/slog, const LevelInfo = 0 #56345
-pkg log/slog, const LevelInfo Level #56345
-pkg log/slog, const LevelKey ideal-string #56345
-pkg log/slog, const LevelKey = "level" #56345
-pkg log/slog, const LevelWarn = 4 #56345
-pkg log/slog, const LevelWarn Level #56345
-pkg log/slog, const MessageKey ideal-string #56345
-pkg log/slog, const MessageKey = "msg" #56345
-pkg log/slog, const SourceKey ideal-string #56345
-pkg log/slog, const SourceKey = "source" #56345
-pkg log/slog, const TimeKey ideal-string #56345
-pkg log/slog, const TimeKey = "time" #56345
-pkg log/slog, func Any(string, interface{}) Attr #56345
-pkg log/slog, func AnyValue(interface{}) Value #56345
-pkg log/slog, func Bool(string, bool) Attr #56345
-pkg log/slog, func BoolValue(bool) Value #56345
-pkg log/slog, func DebugCtx(context.Context, string, ...interface{}) #56345
-pkg log/slog, func Debug(string, ...interface{}) #56345
-pkg log/slog, func Default() *Logger #56345
-pkg log/slog, func Duration(string, time.Duration) Attr #56345
-pkg log/slog, func DurationValue(time.Duration) Value #56345
-pkg log/slog, func ErrorCtx(context.Context, string, ...interface{}) #56345
-pkg log/slog, func Error(string, ...interface{}) #56345
-pkg log/slog, func Float64(string, float64) Attr #56345
-pkg log/slog, func Float64Value(float64) Value #56345
-pkg log/slog, func Group(string, ...interface{}) Attr #59204
-pkg log/slog, func GroupValue(...Attr) Value #56345
-pkg log/slog, func InfoCtx(context.Context, string, ...interface{}) #56345
-pkg log/slog, func Info(string, ...interface{}) #56345
-pkg log/slog, func Int64(string, int64) Attr #56345
-pkg log/slog, func Int64Value(int64) Value #56345
-pkg log/slog, func Int(string, int) Attr #56345
-pkg log/slog, func IntValue(int) Value #56345
-pkg log/slog, func LogAttrs(context.Context, Level, string, ...Attr) #56345
-pkg log/slog, func Log(context.Context, Level, string, ...interface{}) #56345
-pkg log/slog, func New(Handler) *Logger #56345
-pkg log/slog, func NewJSONHandler(io.Writer, *HandlerOptions) *JSONHandler #59339
-pkg log/slog, func NewLogLogger(Handler, Level) *log.Logger #56345
-pkg log/slog, func NewRecord(time.Time, Level, string, uintptr) Record #56345
-pkg log/slog, func NewTextHandler(io.Writer, *HandlerOptions) *TextHandler #59339
-pkg log/slog, func SetDefault(*Logger) #56345
-pkg log/slog, func String(string, string) Attr #56345
-pkg log/slog, func StringValue(string) Value #56345
-pkg log/slog, func Time(string, time.Time) Attr #56345
-pkg log/slog, func TimeValue(time.Time) Value #56345
-pkg log/slog, func Uint64(string, uint64) Attr #56345
-pkg log/slog, func Uint64Value(uint64) Value #56345
-pkg log/slog, func WarnCtx(context.Context, string, ...interface{}) #56345
-pkg log/slog, func Warn(string, ...interface{}) #56345
-pkg log/slog, func With(...interface{}) *Logger #56345
-pkg log/slog, method (Attr) Equal(Attr) bool #56345
-pkg log/slog, method (Attr) String() string #56345
-pkg log/slog, method (*JSONHandler) Enabled(context.Context, Level) bool #56345
-pkg log/slog, method (*JSONHandler) Handle(context.Context, Record) error #56345
-pkg log/slog, method (*JSONHandler) WithAttrs([]Attr) Handler #56345
-pkg log/slog, method (*JSONHandler) WithGroup(string) Handler #56345
-pkg log/slog, method (Kind) String() string #56345
-pkg log/slog, method (Level) Level() Level #56345
-pkg log/slog, method (Level) MarshalJSON() ([]uint8, error) #56345
-pkg log/slog, method (Level) MarshalText() ([]uint8, error) #56345
-pkg log/slog, method (Level) String() string #56345
-pkg log/slog, method (*Level) UnmarshalJSON([]uint8) error #56345
-pkg log/slog, method (*Level) UnmarshalText([]uint8) error #56345
-pkg log/slog, method (*LevelVar) Level() Level #56345
-pkg log/slog, method (*LevelVar) MarshalText() ([]uint8, error) #56345
-pkg log/slog, method (*LevelVar) Set(Level) #56345
-pkg log/slog, method (*LevelVar) String() string #56345
-pkg log/slog, method (*LevelVar) UnmarshalText([]uint8) error #56345
-pkg log/slog, method (*Logger) DebugCtx(context.Context, string, ...interface{}) #56345
-pkg log/slog, method (*Logger) Debug(string, ...interface{}) #56345
-pkg log/slog, method (*Logger) Enabled(context.Context, Level) bool #56345
-pkg log/slog, method (*Logger) ErrorCtx(context.Context, string, ...interface{}) #56345
-pkg log/slog, method (*Logger) Error(string, ...interface{}) #56345
-pkg log/slog, method (*Logger) Handler() Handler #56345
-pkg log/slog, method (*Logger) InfoCtx(context.Context, string, ...interface{}) #56345
-pkg log/slog, method (*Logger) Info(string, ...interface{}) #56345
-pkg log/slog, method (*Logger) LogAttrs(context.Context, Level, string, ...Attr) #56345
-pkg log/slog, method (*Logger) Log(context.Context, Level, string, ...interface{}) #56345
-pkg log/slog, method (*Logger) WarnCtx(context.Context, string, ...interface{}) #56345
-pkg log/slog, method (*Logger) Warn(string, ...interface{}) #56345
-pkg log/slog, method (*Logger) WithGroup(string) *Logger #56345
-pkg log/slog, method (*Logger) With(...interface{}) *Logger #56345
-pkg log/slog, method (*Record) AddAttrs(...Attr) #56345
-pkg log/slog, method (*Record) Add(...interface{}) #56345
-pkg log/slog, method (Record) Attrs(func(Attr) bool) #59060
-pkg log/slog, method (Record) Clone() Record #56345
-pkg log/slog, method (Record) NumAttrs() int #56345
-pkg log/slog, method (*TextHandler) Enabled(context.Context, Level) bool #56345
-pkg log/slog, method (*TextHandler) Handle(context.Context, Record) error #56345
-pkg log/slog, method (*TextHandler) WithAttrs([]Attr) Handler #56345
-pkg log/slog, method (*TextHandler) WithGroup(string) Handler #56345
-pkg log/slog, method (Value) Any() interface{} #56345
-pkg log/slog, method (Value) Bool() bool #56345
-pkg log/slog, method (Value) Duration() time.Duration #56345
-pkg log/slog, method (Value) Equal(Value) bool #56345
-pkg log/slog, method (Value) Float64() float64 #56345
-pkg log/slog, method (Value) Group() []Attr #56345
-pkg log/slog, method (Value) Int64() int64 #56345
-pkg log/slog, method (Value) Kind() Kind #56345
-pkg log/slog, method (Value) LogValuer() LogValuer #56345
-pkg log/slog, method (Value) Resolve() Value #56345
-pkg log/slog, method (Value) String() string #56345
-pkg log/slog, method (Value) Time() time.Time #56345
-pkg log/slog, method (Value) Uint64() uint64 #56345
-pkg log/slog, type Attr struct #56345
-pkg log/slog, type Attr struct, Key string #56345
-pkg log/slog, type Attr struct, Value Value #56345
-pkg log/slog, type Handler interface, Enabled(context.Context, Level) bool #56345
-pkg log/slog, type Handler interface { Enabled, Handle, WithAttrs, WithGroup } #56345
-pkg log/slog, type Handler interface, Handle(context.Context, Record) error #56345
-pkg log/slog, type Handler interface, WithAttrs([]Attr) Handler #56345
-pkg log/slog, type Handler interface, WithGroup(string) Handler #56345
-pkg log/slog, type HandlerOptions struct #56345
-pkg log/slog, type HandlerOptions struct, AddSource bool #56345
-pkg log/slog, type HandlerOptions struct, Level Leveler #56345
-pkg log/slog, type HandlerOptions struct, ReplaceAttr func([]string, Attr) Attr #56345
-pkg log/slog, type JSONHandler struct #56345
-pkg log/slog, type Kind int #56345
-pkg log/slog, type Leveler interface { Level } #56345
-pkg log/slog, type Leveler interface, Level() Level #56345
-pkg log/slog, type Level int #56345
-pkg log/slog, type LevelVar struct #56345
-pkg log/slog, type Logger struct #56345
-pkg log/slog, type LogValuer interface { LogValue } #56345
-pkg log/slog, type LogValuer interface, LogValue() Value #56345
-pkg log/slog, type Record struct #56345
-pkg log/slog, type Record struct, Level Level #56345
-pkg log/slog, type Record struct, Message string #56345
-pkg log/slog, type Record struct, PC uintptr #56345
-pkg log/slog, type Record struct, Time time.Time #56345
-pkg log/slog, type Source struct #59280
-pkg log/slog, type Source struct, File string #59280
-pkg log/slog, type Source struct, Function string #59280
-pkg log/slog, type Source struct, Line int #59280
-pkg log/slog, type TextHandler struct #56345
-pkg log/slog, type Value struct #56345
-pkg maps, func Clone[$0 interface{ ~map[$1]$2 }, $1 comparable, $2 interface{}]($0) $0 #57436
-pkg maps, func Copy[$0 interface{ ~map[$2]$3 }, $1 interface{ ~map[$2]$3 }, $2 comparable, $3 interface{}]($0, $1) #57436
-pkg maps, func DeleteFunc[$0 interface{ ~map[$1]$2 }, $1 comparable, $2 interface{}]($0, func($1, $2) bool) #57436
-pkg maps, func Equal[$0 interface{ ~map[$2]$3 }, $1 interface{ ~map[$2]$3 }, $2 comparable, $3 comparable]($0, $1) bool #57436
-pkg maps, func EqualFunc[$0 interface{ ~map[$2]$3 }, $1 interface{ ~map[$2]$4 }, $2 comparable, $3 interface{}, $4 interface{}]($0, $1, func($3, $4) bool) bool #57436
-pkg maps, func Keys[$0 interface{ ~map[$1]$2 }, $1 comparable, $2 interface{}]($0) []$1 #57436
-pkg maps, func Values[$0 interface{ ~map[$1]$2 }, $1 comparable, $2 interface{}]($0) []$2 #57436
-pkg math/big, method (*Int) Float64() (float64, Accuracy) #56984
-pkg net/http, method (*ProtocolError) Is(error) bool #41198
-pkg net/http, method (*ResponseController) EnableFullDuplex() error #57786
-pkg net/http, var ErrSchemeMismatch error #44855
-pkg net, method (*Dialer) MultipathTCP() bool #56539
-pkg net, method (*Dialer) SetMultipathTCP(bool) #56539
-pkg net, method (*ListenConfig) MultipathTCP() bool #56539
-pkg net, method (*ListenConfig) SetMultipathTCP(bool) #56539
-pkg net, method (*TCPConn) MultipathTCP() (bool, error) #59166
-pkg reflect, method (Value) Clear() #55002
-pkg reflect, type SliceHeader //deprecated #56906
-pkg reflect, type StringHeader //deprecated #56906
-pkg regexp, method (*Regexp) MarshalText() ([]uint8, error) #46159
-pkg regexp, method (*Regexp) UnmarshalText([]uint8) error #46159
-pkg runtime, method (*PanicNilError) Error() string #25448
-pkg runtime, method (*PanicNilError) RuntimeError() #25448
-pkg runtime, method (*Pinner) Pin(interface{}) #46787
-pkg runtime, method (*Pinner) Unpin() #46787
-pkg runtime, type PanicNilError struct #25448
-pkg runtime, type Pinner struct #46787
-pkg slices, func BinarySearch[$0 interface{ ~[]$1 }, $1 cmp.Ordered]($0, $1) (int, bool) #60091
-pkg slices, func BinarySearchFunc[$0 interface{ ~[]$1 }, $1 interface{}, $2 interface{}]($0, $2, func($1, $2) int) (int, bool) #60091
-pkg slices, func Clip[$0 interface{ ~[]$1 }, $1 interface{}]($0) $0 #57433
-pkg slices, func Clone[$0 interface{ ~[]$1 }, $1 interface{}]($0) $0 #57433
-pkg slices, func Compact[$0 interface{ ~[]$1 }, $1 comparable]($0) $0 #57433
-pkg slices, func CompactFunc[$0 interface{ ~[]$1 }, $1 interface{}]($0, func($1, $1) bool) $0 #57433
-pkg slices, func Compare[$0 interface{ ~[]$1 }, $1 cmp.Ordered]($0, $0) int #60091
-pkg slices, func CompareFunc[$0 interface{ ~[]$2 }, $1 interface{ ~[]$3 }, $2 interface{}, $3 interface{}]($0, $1, func($2, $3) int) int #60091
-pkg slices, func Contains[$0 interface{ ~[]$1 }, $1 comparable]($0, $1) bool #57433
-pkg slices, func ContainsFunc[$0 interface{ ~[]$1 }, $1 interface{}]($0, func($1) bool) bool #57433
-pkg slices, func Delete[$0 interface{ ~[]$1 }, $1 interface{}]($0, int, int) $0 #57433
-pkg slices, func DeleteFunc[$0 interface{ ~[]$1 }, $1 interface{}]($0, func($1) bool) $0 #54768
-pkg slices, func Equal[$0 interface{ ~[]$1 }, $1 comparable]($0, $0) bool #57433
-pkg slices, func EqualFunc[$0 interface{ ~[]$2 }, $1 interface{ ~[]$3 }, $2 interface{}, $3 interface{}]($0, $1, func($2, $3) bool) bool #57433
-pkg slices, func Grow[$0 interface{ ~[]$1 }, $1 interface{}]($0, int) $0 #57433
-pkg slices, func Index[$0 interface{ ~[]$1 }, $1 comparable]($0, $1) int #57433
-pkg slices, func IndexFunc[$0 interface{ ~[]$1 }, $1 interface{}]($0, func($1) bool) int #57433
-pkg slices, func Insert[$0 interface{ ~[]$1 }, $1 interface{}]($0, int, ...$1) $0 #57433
-pkg slices, func IsSorted[$0 interface{ ~[]$1 }, $1 cmp.Ordered]($0) bool #60091
-pkg slices, func IsSortedFunc[$0 interface{ ~[]$1 }, $1 interface{}]($0, func($1, $1) int) bool #60091
-pkg slices, func Max[$0 interface{ ~[]$1 }, $1 cmp.Ordered]($0) $1 #60091
-pkg slices, func MaxFunc[$0 interface{ ~[]$1 }, $1 interface{}]($0, func($1, $1) int) $1 #60091
-pkg slices, func Min[$0 interface{ ~[]$1 }, $1 cmp.Ordered]($0) $1 #60091
-pkg slices, func MinFunc[$0 interface{ ~[]$1 }, $1 interface{}]($0, func($1, $1) int) $1 #60091
-pkg slices, func Replace[$0 interface{ ~[]$1 }, $1 interface{}]($0, int, int, ...$1) $0 #57433
-pkg slices, func Reverse[$0 interface{ ~[]$1 }, $1 interface{}]($0) #58565
-pkg slices, func Sort[$0 interface{ ~[]$1 }, $1 cmp.Ordered]($0) #60091
-pkg slices, func SortFunc[$0 interface{ ~[]$1 }, $1 interface{}]($0, func($1, $1) int) #60091
-pkg slices, func SortStableFunc[$0 interface{ ~[]$1 }, $1 interface{}]($0, func($1, $1) int) #60091
-pkg strings, func ContainsFunc(string, func(int32) bool) bool #54386
-pkg sync, func OnceFunc(func()) func() #56102
-pkg sync, func OnceValue[$0 interface{}](func() $0) func() $0 #56102
-pkg sync, func OnceValues[$0 interface{}, $1 interface{}](func() ($0, $1)) func() ($0, $1) #56102
-pkg syscall (freebsd-386-cgo), type SysProcAttr struct, Jail int #46259
-pkg syscall (freebsd-386), type SysProcAttr struct, Jail int #46259
-pkg syscall (freebsd-amd64-cgo), type SysProcAttr struct, Jail int #46259
-pkg syscall (freebsd-amd64), type SysProcAttr struct, Jail int #46259
-pkg syscall (freebsd-arm64-cgo), type SysProcAttr struct, Jail int #46259
-pkg syscall (freebsd-arm64), type SysProcAttr struct, Jail int #46259
-pkg syscall (freebsd-arm-cgo), type SysProcAttr struct, Jail int #46259
-pkg syscall (freebsd-arm), type SysProcAttr struct, Jail int #46259
-pkg syscall (freebsd-riscv64-cgo), type SysProcAttr struct, Jail int #46259
-pkg syscall (freebsd-riscv64), type SysProcAttr struct, Jail int #46259
-pkg testing, func Testing() bool #52600
-pkg testing/slogtest, func TestHandler(slog.Handler, func() []map[string]interface{}) error #56345
-pkg unicode, const Version = "15.0.0" #55079
-pkg unicode, var Cypro_Minoan *RangeTable #55079
-pkg unicode, var Kawi *RangeTable #55079
-pkg unicode, var Nag_Mundari *RangeTable #55079
-pkg unicode, var Old_Uyghur *RangeTable #55079
-pkg unicode, var Tangsa *RangeTable #55079
-pkg unicode, var Toto *RangeTable #55079
-pkg unicode, var Vithkuqi *RangeTable #55079

codereview.cfg

@@ -1,2 +1,2 @@
-branch: dev.inline
+branch: release-branch.go1.19
 parent-branch: master

doc/godebug.md

@@ -1,201 +0,0 @@
----
-title: "Go, Backwards Compatibility, and GODEBUG"
-layout: article
----
-
-<!--
-This document is kept in the Go repo, not x/website,
-because it documents the full list of known GODEBUG settings,
-which are tied to a specific release.
--->
-
-## Introduction {#intro}
-
-Go's emphasis on backwards compatibility is one of its key strengths.
-There are, however, times when we cannot maintain complete compatibility.
-If code depends on buggy (including insecure) behavior,
-then fixing the bug will break that code.
-New features can also have similar impacts:
-enabling the HTTP/2 use by the HTTP client broke programs
-connecting to servers with buggy HTTP/2 implementations.
-These kinds of changes are unavoidable and
-[permitted by the Go 1 compatibility rules](/doc/go1compat).
-Even so, Go provides a mechanism called GODEBUG to
-reduce the impact such changes have on Go developers
-using newer toolchains to compile old code.
-
-A GODEBUG setting is a `key=value` pair
-that controls the execution of certain parts of a Go program.
-The environment variable `GODEBUG`
-can hold a comma-separated list of these settings.
-For example, if a Go program is running in an environment that contains
-
-	GODEBUG=http2client=0,http2server=0
-
-then that Go program will disable the use of HTTP/2 by default in both
-the HTTP client and the HTTP server.
-It is also possible to set the default `GODEBUG` for a given program
-(discussed below).
-
-When preparing any change that is permitted by Go 1 compatibility
-but may nonetheless break some existing programs,
-we first engineer the change to keep as many existing programs working as possible.
-For the remaining programs,
-we define a new GODEBUG setting that
-allows individual programs to opt back in to the old behavior.
-A GODEBUG setting may not be added if doing so is infeasible,
-but that should be extremely rare.
-
-GODEBUG settings added for compatibility will be maintained
-for a minimum of two years (four Go releases).
-Some, such as `http2client` and `http2server`,
-will be maintained much longer, even indefinitely.
-
-When possible, each GODEBUG setting has an associated
-[runtime/metrics](/pkg/runtime/metrics/) counter
-named `/godebug/non-default-behavior/<name>:events`
-that counts the number of times a particular program's
-behavior has changed based on a non-default value
-for that setting.
-For example, when `GODEBUG=http2client=0` is set,
-`/godebug/non-default-behavior/http2client:events`
-counts the number of HTTP transports that the program
-has configured without HTTP/2 support.
-
-## Default GODEBUG Values {#default}
-
-When a GODEBUG setting is not listed in the environment variable,
-its value is derived from three sources:
-the defaults for the Go toolchain used to build the program,
-amended to match the Go version listed in `go.mod`,
-and then overridden by explicit `//go:debug` lines in the program.
-
-The [GODEBUG History](#history) gives the exact defaults for each Go toolchain version.
-For example, Go 1.21 introduces the `panicnil` setting,
-controlling whether `panic(nil)` is allowed;
-it defaults to `panicnil=0`, making `panic(nil)` a run-time error.
-Using `panicnil=1` restores the behavior of Go 1.20 and earlier.
-
-When compiling a work module or workspace that declares
-an older Go version, the Go toolchain amends its defaults
-to match that older Go version as closely as possible.
-For example, when a Go 1.21 toolchain compiles a program,
-if the work module's `go.mod` or the workspace's `go.work`
-says `go` `1.20`, then the program defaults to `panicnil=1`,
-matching Go 1.20 instead of Go 1.21.
-
-Because this method of setting GODEBUG defaults was introduced only in Go 1.21,
-programs listing versions of Go earlier than Go 1.20 are configured to match Go 1.20,
-not the older version.
-
-To override these defaults, a main package's source files
-can include one or more `//go:debug` directives at the top of the file
-(preceding the `package` statement).
-Continuing the `panicnil` example, if the module or workspace is updated
-to say `go` `1.21`, the program can opt back into the old `panic(nil)`
-behavior by including this directive:
-
-	//go:debug panicnil=1
-
-Starting in Go 1.21, the Go toolchain treats a `//go:debug` directive
-with an unrecognized GODEBUG setting as an invalid program.
-Programs with more than one `//go:debug` line for a given setting
-are also treated as invalid.
-(Older toolchains ignore `//go:debug` directives entirely.)
-
-The defaults that will be compiled into a main package
-are reported by the command:
-
-{{raw `
-	go list -f '{{.DefaultGODEBUG}}' my/main/package
-`}}
-
-Only differences from the base Go toolchain defaults are reported.
-
-When testing a package, `//go:debug` lines in the `*_test.go`
-files are treated as directives for the test's main package.
-In any other context, `//go:debug` lines are ignored by the toolchain;
-`go` `vet` reports such lines as misplaced.
-
-## GODEBUG History {#history}
-
-This section documents the GODEBUG settings introduced and removed in each major Go release
-for compatibility reasons.
-Packages or programs may define additional settings for internal debugging purposes;
-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.21
-
-Go 1.21 made it a run-time error to call `panic` with a nil interface value,
-controlled by the [`panicnil` setting](/pkg/builtin/#panic).
-
-Go 1.21 made it an error for html/template actions to appear inside of an ECMAScript 6
-template literal, controlled by the
-[`jstmpllitinterp` setting](/pkg/html/template#hdr-Security_Model).
-This behavior was backported to Go 1.19.8+ and Go 1.20.3+.
-
-Go 1.21 introduced a limit on the maximum number of MIME headers and multipart
-forms, controlled by the
-[`multipartmaxheaders` and `multipartmaxparts` settings](/pkg/mime/multipart#hdr-Limits)
-respectively.
-This behavior was backported to Go 1.19.8+ and Go 1.20.3+.
-
-There is no plan to remove any of these settings.
-
-### Go 1.20
-
-Go 1.20 introduced support for rejecting insecure paths in tar and zip archives,
-controlled by the [`tarinsecurepath` setting](/pkg/archive/tar/#Reader.Next)
-and the [`zipinsecurepath` setting](/pkg/archive/zip/#NewReader).
-These default to `tarinsecurepath=1` and `zipinsecurepath=1`,
-preserving the behavior of earlier versions of Go.
-A future version of Go may change the defaults to
-`tarinsecurepath=0` and `zipinsecurepath=0`.
-
-Go 1.20 introduced automatic seeding of the
-[`math/rand`](/pkg/math/rand) global random number generator,
-controlled by the [`randautoseed` setting](/pkg/math/rand/#Seed).
-
-Go 1.20 introduced the concept of fallback roots for use during certificate verification,
-controlled by the [`x509usefallbackroots` setting](/pkg/crypto/x509/#SetFallbackRoots).
-
-Go 1.20 removed the preinstalled `.a` files for the standard library
-from the Go distribution.
-Installations now build and cache the standard library like
-packages in other modules.
-The [`installgoroot` setting](/cmd/go#hdr-Compile_and_install_packages_and_dependencies)
-restores the installation and use of preinstalled `.a` files.
-
-There is no plan to remove any of these settings.
-
-### Go 1.19
-
-Go 1.19 made it an error for path lookups to resolve to binaries in the current directory,
-controlled by the [`execerrdot` setting](/pkg/os/exec#hdr-Executables_in_the_current_directory).
-There is no plan to remove this setting.
-
-### Go 1.18
-
-Go 1.18 removed support for SHA1 in most X.509 certificates,
-controlled by the [`x509sha1` setting](/crypto/x509#InsecureAlgorithmError).
-This setting will be removed in a future release, Go 1.22 at the earliest.
-
-### Go 1.10
-
-Go 1.10 changed how build caching worked and added test caching, along
-with the [`gocacheverify`, `gocachehash`, and `gocachetest` settings](/cmd/go/#hdr-Build_and_test_caching).
-There is no plan to remove these settings.
-
-### Go 1.6
-
-Go 1.6 introduced transparent support for HTTP/2,
-controlled by the [`http2client`, `http2server`, and `http2debug` settings](/pkg/net/http/#hdr-HTTP_2).
-There is no plan to remove these settings.
-
-### Go 1.5
-
-Go 1.5 introduced a pure Go DNS resolver,
-controlled by the [`netdns` setting](/pkg/net/#hdr-Name_Resolution).
-There is no plan to remove this setting.

go.env

@@ -1,12 +0,0 @@
-# This file contains the initial defaults for go command configuration.
-# Values set by 'go env -w' and written to the user's go/env file override these.
-# The environment overrides everything else.
-
-# Use the Go module mirror and checksum database by default.
-# See https://proxy.golang.org for details.
-GOPROXY=https://proxy.golang.org,direct
-GOSUMDB=sum.golang.org
-
-# Automatically download newer toolchains as directed by go.mod files.
-# See https://go.dev/doc/toolchain for details.
-GOTOOLCHAIN=auto

lib/time/mkzip.go

@@ -1,94 +0,0 @@
-// Copyright 2022 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-//go:build ignore
-
-// Mkzip writes a zoneinfo.zip with the content of the current directory
-// and its subdirectories, with no compression, suitable for package time.
-//
-// Usage:
-//
-//	go run ../../mkzip.go ../../zoneinfo.zip
-//
-// We use this program instead of 'zip -0 -r ../../zoneinfo.zip *' to get
-// a reproducible generator that does not depend on which version of the
-// external zip tool is used or the ordering of file names in a directory
-// or the current time.
-package main
-
-import (
-	"archive/zip"
-	"bytes"
-	"flag"
-	"fmt"
-	"hash/crc32"
-	"io/fs"
-	"log"
-	"os"
-	"path/filepath"
-	"strings"
-)
-
-func usage() {
-	fmt.Fprintf(os.Stderr, "usage: go run mkzip.go ../../zoneinfo.zip\n")
-	os.Exit(2)
-}
-
-func main() {
-	log.SetPrefix("mkzip: ")
-	log.SetFlags(0)
-	flag.Usage = usage
-	flag.Parse()
-	args := flag.Args()
-	if len(args) != 1 || !strings.HasSuffix(args[0], ".zip") {
-		usage()
-	}
-
-	var zb bytes.Buffer
-	zw := zip.NewWriter(&zb)
-	seen := make(map[string]bool)
-	err := filepath.WalkDir(".", func(path string, d fs.DirEntry, err error) error {
-		if d.IsDir() {
-			return nil
-		}
-		data, err := os.ReadFile(path)
-		if err != nil {
-			log.Fatal(err)
-		}
-		if strings.HasSuffix(path, ".zip") {
-			log.Fatalf("unexpected file during walk: %s", path)
-		}
-		name := filepath.ToSlash(path)
-		w, err := zw.CreateRaw(&zip.FileHeader{
-			Name:               name,
-			Method:             zip.Store,
-			CompressedSize64:   uint64(len(data)),
-			UncompressedSize64: uint64(len(data)),
-			CRC32:              crc32.ChecksumIEEE(data),
-		})
-		if err != nil {
-			log.Fatal(err)
-		}
-		if _, err := w.Write(data); err != nil {
-			log.Fatal(err)
-		}
-		seen[name] = true
-		return nil
-	})
-	if err != nil {
-		log.Fatal(err)
-	}
-	if err := zw.Close(); err != nil {
-		log.Fatal(err)
-	}
-	if len(seen) == 0 {
-		log.Fatalf("did not find any files to add")
-	}
-	if !seen["US/Eastern"] {
-		log.Fatalf("did not find US/Eastern to add")
-	}
-	if err := os.WriteFile(args[0], zb.Bytes(), 0666); err != nil {
-		log.Fatal(err)
-	}
-}

lib/time/update.bash

@@ -5,82 +5,35 @@
 
 # This script rebuilds the time zone files using files
 # downloaded from the ICANN/IANA distribution.
-#
-# To prepare an update for a new Go release,
-# consult https://www.iana.org/time-zones for the latest versions,
-# update CODE and DATA below, and then run
-#
-#	./update.bash -commit
-#
-# That will prepare the files and create the commit.
-#
-# To review such a commit (as the reviewer), use:
-#
-#	git codereview change NNNNNN   # CL number
-#	cd lib/time
-#	./update.bash
-#
-# If it prints "No updates needed.", then the generated files
-# in the CL match the update.bash in the CL.
+# Consult https://www.iana.org/time-zones for the latest versions.
 
 # Versions to use.
-CODE=2023c
-DATA=2023c
+CODE=2022a
+DATA=2022a
 
 set -e
-
-cd $(dirname $0)
 rm -rf work
 mkdir work
-go build -o work/mkzip mkzip.go # build now for correct paths in build errors
 cd work
 mkdir zoneinfo
-curl -sS -L -O https://www.iana.org/time-zones/repository/releases/tzcode$CODE.tar.gz
-curl -sS -L -O https://www.iana.org/time-zones/repository/releases/tzdata$DATA.tar.gz
+curl -L -O https://www.iana.org/time-zones/repository/releases/tzcode$CODE.tar.gz
+curl -L -O https://www.iana.org/time-zones/repository/releases/tzdata$DATA.tar.gz
 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
-	cat make.out
-	exit 2
-fi
+make CFLAGS=-DSTD_INSPIRED AWK=awk TZDIR=zoneinfo posix_only
 
 cd zoneinfo
-../mkzip ../../zoneinfo.zip
+rm -f ../../zoneinfo.zip
+zip -0 -r ../../zoneinfo.zip *
 cd ../..
 
-files="update.bash zoneinfo.zip"
-modified=true
-if git diff --quiet $files; then
-	modified=false
-fi
+go generate time/tzdata
 
+echo
 if [ "$1" = "-work" ]; then
 	echo Left workspace behind in work/.
-	shift
 else
 	rm -rf work
 fi
-
-if ! $modified; then
-	echo No updates needed.
-	exit 0
-fi
-
-echo Updated for $CODE/$DATA: $files
-
-commitmsg="lib/time: update to $CODE/$DATA
-
-Commit generated by update.bash.
-
-For #22487.
-"
-
-if [ "$1" = "-commit" ]; then
-	echo "Creating commit. Run 'git reset HEAD^' to undo commit."
-	echo
-	git commit -m "$commitmsg" $files
-	echo
-	git log -n1 --stat
-	echo
-fi
+echo New time zone files in zoneinfo.zip.

misc/android/go_android_exec.go

@@ -0,0 +1,341 @@
+// Copyright 2014 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 ignore
+// +build ignore
+
+// This program can be used as go_android_GOARCH_exec by the Go tool.
+// It executes binaries on an android device using adb.
+package main
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"go/build"
+	"io"
+	"log"
+	"os"
+	"os/exec"
+	"os/signal"
+	"path/filepath"
+	"runtime"
+	"strconv"
+	"strings"
+	"syscall"
+)
+
+func run(args ...string) (string, error) {
+	cmd := adbCmd(args...)
+	buf := new(bytes.Buffer)
+	cmd.Stdout = io.MultiWriter(os.Stdout, buf)
+	// If the adb subprocess somehow hangs, go test will kill this wrapper
+	// and wait for our os.Stderr (and os.Stdout) to close as a result.
+	// However, if the os.Stderr (or os.Stdout) file descriptors are
+	// passed on, the hanging adb subprocess will hold them open and
+	// go test will hang forever.
+	//
+	// Avoid that by wrapping stderr, breaking the short circuit and
+	// forcing cmd.Run to use another pipe and goroutine to pass
+	// along stderr from adb.
+	cmd.Stderr = struct{ io.Writer }{os.Stderr}
+	err := cmd.Run()
+	if err != nil {
+		return "", fmt.Errorf("adb %s: %v", strings.Join(args, " "), err)
+	}
+	return buf.String(), nil
+}
+
+func adb(args ...string) error {
+	if out, err := adbCmd(args...).CombinedOutput(); err != nil {
+		fmt.Fprintf(os.Stderr, "adb %s\n%s", strings.Join(args, " "), out)
+		return err
+	}
+	return nil
+}
+
+func adbCmd(args ...string) *exec.Cmd {
+	if flags := os.Getenv("GOANDROID_ADB_FLAGS"); flags != "" {
+		args = append(strings.Split(flags, " "), args...)
+	}
+	return exec.Command("adb", args...)
+}
+
+const (
+	deviceRoot   = "/data/local/tmp/go_android_exec"
+	deviceGoroot = deviceRoot + "/goroot"
+)
+
+func main() {
+	log.SetFlags(0)
+	log.SetPrefix("go_android_exec: ")
+	exitCode, err := runMain()
+	if err != nil {
+		log.Fatal(err)
+	}
+	os.Exit(exitCode)
+}
+
+func runMain() (int, error) {
+	// Concurrent use of adb is flaky, so serialize adb commands.
+	// See https://github.com/golang/go/issues/23795 or
+	// https://issuetracker.google.com/issues/73230216.
+	lockPath := filepath.Join(os.TempDir(), "go_android_exec-adb-lock")
+	lock, err := os.OpenFile(lockPath, os.O_CREATE|os.O_RDWR, 0666)
+	if err != nil {
+		return 0, err
+	}
+	defer lock.Close()
+	if err := syscall.Flock(int(lock.Fd()), syscall.LOCK_EX); err != nil {
+		return 0, err
+	}
+
+	// In case we're booting a device or emulator alongside all.bash, wait for
+	// it to be ready. adb wait-for-device is not enough, we have to
+	// wait for sys.boot_completed.
+	if err := adb("wait-for-device", "exec-out", "while [[ -z $(getprop sys.boot_completed) ]]; do sleep 1; done;"); err != nil {
+		return 0, err
+	}
+
+	// Done once per make.bash.
+	if err := adbCopyGoroot(); err != nil {
+		return 0, err
+	}
+
+	// Prepare a temporary directory that will be cleaned up at the end.
+	// Binary names can conflict.
+	// E.g. template.test from the {html,text}/template packages.
+	binName := filepath.Base(os.Args[1])
+	deviceGotmp := fmt.Sprintf(deviceRoot+"/%s-%d", binName, os.Getpid())
+	deviceGopath := deviceGotmp + "/gopath"
+	defer adb("exec-out", "rm", "-rf", deviceGotmp) // Clean up.
+
+	// Determine the package by examining the current working
+	// directory, which will look something like
+	// "$GOROOT/src/mime/multipart" or "$GOPATH/src/golang.org/x/mobile".
+	// We extract everything after the $GOROOT or $GOPATH to run on the
+	// same relative directory on the target device.
+	subdir, inGoRoot, err := subdir()
+	if err != nil {
+		return 0, err
+	}
+	deviceCwd := filepath.Join(deviceGopath, subdir)
+	if inGoRoot {
+		deviceCwd = filepath.Join(deviceGoroot, subdir)
+	} else {
+		if err := adb("exec-out", "mkdir", "-p", deviceCwd); err != nil {
+			return 0, err
+		}
+		if err := adbCopyTree(deviceCwd, subdir); err != nil {
+			return 0, err
+		}
+
+		// Copy .go files from the package.
+		goFiles, err := filepath.Glob("*.go")
+		if err != nil {
+			return 0, err
+		}
+		if len(goFiles) > 0 {
+			args := append(append([]string{"push"}, goFiles...), deviceCwd)
+			if err := adb(args...); err != nil {
+				return 0, err
+			}
+		}
+	}
+
+	deviceBin := fmt.Sprintf("%s/%s", deviceGotmp, binName)
+	if err := adb("push", os.Args[1], deviceBin); err != nil {
+		return 0, err
+	}
+
+	// Forward SIGQUIT from the go command to show backtraces from
+	// the binary instead of from this wrapper.
+	quit := make(chan os.Signal, 1)
+	signal.Notify(quit, syscall.SIGQUIT)
+	go func() {
+		for range quit {
+			// We don't have the PID of the running process; use the
+			// binary name instead.
+			adb("exec-out", "killall -QUIT "+binName)
+		}
+	}()
+	// In light of
+	// https://code.google.com/p/android/issues/detail?id=3254
+	// dont trust the exitcode of adb. Instead, append the exitcode to
+	// the output and parse it from there.
+	const exitstr = "exitcode="
+	cmd := `export TMPDIR="` + deviceGotmp + `"` +
+		`; export GOROOT="` + deviceGoroot + `"` +
+		`; export GOPATH="` + deviceGopath + `"` +
+		`; export CGO_ENABLED=0` +
+		`; export GOPROXY=` + os.Getenv("GOPROXY") +
+		`; export GOCACHE="` + deviceRoot + `/gocache"` +
+		`; export PATH=$PATH:"` + deviceGoroot + `/bin"` +
+		`; cd "` + deviceCwd + `"` +
+		"; '" + deviceBin + "' " + strings.Join(os.Args[2:], " ") +
+		"; echo -n " + exitstr + "$?"
+	output, err := run("exec-out", cmd)
+	signal.Reset(syscall.SIGQUIT)
+	close(quit)
+	if err != nil {
+		return 0, err
+	}
+
+	exitIdx := strings.LastIndex(output, exitstr)
+	if exitIdx == -1 {
+		return 0, fmt.Errorf("no exit code: %q", output)
+	}
+	code, err := strconv.Atoi(output[exitIdx+len(exitstr):])
+	if err != nil {
+		return 0, fmt.Errorf("bad exit code: %v", err)
+	}
+	return code, nil
+}
+
+// subdir determines the package based on the current working directory,
+// and returns the path to the package source relative to $GOROOT (or $GOPATH).
+func subdir() (pkgpath string, underGoRoot bool, err error) {
+	cwd, err := os.Getwd()
+	if err != nil {
+		return "", false, err
+	}
+	cwd, err = filepath.EvalSymlinks(cwd)
+	if err != nil {
+		return "", false, err
+	}
+	goroot, err := filepath.EvalSymlinks(runtime.GOROOT())
+	if err != nil {
+		return "", false, err
+	}
+	if subdir, err := filepath.Rel(goroot, cwd); err == nil {
+		if !strings.Contains(subdir, "..") {
+			return subdir, true, nil
+		}
+	}
+
+	for _, p := range filepath.SplitList(build.Default.GOPATH) {
+		pabs, err := filepath.EvalSymlinks(p)
+		if err != nil {
+			return "", false, err
+		}
+		if subdir, err := filepath.Rel(pabs, cwd); err == nil {
+			if !strings.Contains(subdir, "..") {
+				return subdir, false, nil
+			}
+		}
+	}
+	return "", false, fmt.Errorf("the current path %q is not in either GOROOT(%q) or GOPATH(%q)",
+		cwd, runtime.GOROOT(), build.Default.GOPATH)
+}
+
+// adbCopyTree copies testdata, go.mod, go.sum files from subdir
+// and from parent directories all the way up to the root of subdir.
+// go.mod and go.sum files are needed for the go tool modules queries,
+// and the testdata directories for tests.  It is common for tests to
+// reach out into testdata from parent packages.
+func adbCopyTree(deviceCwd, subdir string) error {
+	dir := ""
+	for {
+		for _, path := range []string{"testdata", "go.mod", "go.sum"} {
+			path := filepath.Join(dir, path)
+			if _, err := os.Stat(path); err != nil {
+				continue
+			}
+			devicePath := filepath.Join(deviceCwd, dir)
+			if err := adb("exec-out", "mkdir", "-p", devicePath); err != nil {
+				return err
+			}
+			if err := adb("push", path, devicePath); err != nil {
+				return err
+			}
+		}
+		if subdir == "." {
+			break
+		}
+		subdir = filepath.Dir(subdir)
+		dir = filepath.Join(dir, "..")
+	}
+	return nil
+}
+
+// adbCopyGoroot clears deviceRoot for previous versions of GOROOT, GOPATH
+// and temporary data. Then, it copies relevant parts of GOROOT to the device,
+// including the go tool built for android.
+// A lock file ensures this only happens once, even with concurrent exec
+// wrappers.
+func adbCopyGoroot() error {
+	// Also known by cmd/dist. The bootstrap command deletes the file.
+	statPath := filepath.Join(os.TempDir(), "go_android_exec-adb-sync-status")
+	stat, err := os.OpenFile(statPath, os.O_CREATE|os.O_RDWR, 0666)
+	if err != nil {
+		return err
+	}
+	defer stat.Close()
+	// Serialize check and copying.
+	if err := syscall.Flock(int(stat.Fd()), syscall.LOCK_EX); err != nil {
+		return err
+	}
+	s, err := io.ReadAll(stat)
+	if err != nil {
+		return err
+	}
+	if string(s) == "done" {
+		return nil
+	}
+	// Delete GOROOT, GOPATH and any leftover test data.
+	if err := adb("exec-out", "rm", "-rf", deviceRoot); err != nil {
+		return err
+	}
+	deviceBin := filepath.Join(deviceGoroot, "bin")
+	if err := adb("exec-out", "mkdir", "-p", deviceBin); err != nil {
+		return err
+	}
+	goroot := runtime.GOROOT()
+	// Build go for android.
+	goCmd := filepath.Join(goroot, "bin", "go")
+	tmpGo, err := os.CreateTemp("", "go_android_exec-cmd-go-*")
+	if err != nil {
+		return err
+	}
+	tmpGo.Close()
+	defer os.Remove(tmpGo.Name())
+
+	if out, err := exec.Command(goCmd, "build", "-o", tmpGo.Name(), "cmd/go").CombinedOutput(); err != nil {
+		return fmt.Errorf("failed to build go tool for device: %s\n%v", out, err)
+	}
+	deviceGo := filepath.Join(deviceBin, "go")
+	if err := adb("push", tmpGo.Name(), deviceGo); err != nil {
+		return err
+	}
+	for _, dir := range []string{"src", "test", "lib", "api"} {
+		if err := adb("push", filepath.Join(goroot, dir), filepath.Join(deviceGoroot)); err != nil {
+			return err
+		}
+	}
+
+	// Copy only the relevant from pkg.
+	if err := adb("exec-out", "mkdir", "-p", filepath.Join(deviceGoroot, "pkg", "tool")); err != nil {
+		return err
+	}
+	if err := adb("push", filepath.Join(goroot, "pkg", "include"), filepath.Join(deviceGoroot, "pkg")); err != nil {
+		return err
+	}
+	runtimea, err := exec.Command(goCmd, "list", "-f", "{{.Target}}", "runtime").Output()
+	pkgdir := filepath.Dir(string(runtimea))
+	if pkgdir == "" {
+		return errors.New("could not find android pkg dir")
+	}
+	if err := adb("push", pkgdir, filepath.Join(deviceGoroot, "pkg")); err != nil {
+		return err
+	}
+	tooldir := filepath.Join(goroot, "pkg", "tool", filepath.Base(pkgdir))
+	if err := adb("push", tooldir, filepath.Join(deviceGoroot, "pkg", "tool")); err != nil {
+		return err
+	}
+
+	if _, err := stat.Write([]byte("done")); err != nil {
+		return err
+	}
+	return nil
+}

misc/arm/a

@@ -0,0 +1,58 @@
+#!/usr/bin/env bash
+
+# Copyright 2010 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 is a small script for executing go binaries on the android platform.
+#
+# example:
+# ./a 5.out foo bar baz
+#
+# The script exports the local values of GOARCH, GOTRACEBACK and GOGC
+# to the android environment.
+#
+# Known issues:
+# The script fails unless the last character output by the program is "\n"
+#
+# TODO(kaib): add gdb bridge support
+
+exp ()
+{
+	if [ ${!1} ]; then
+		echo "export $1=\"${!1}\"; "
+	fi
+}
+
+# adb does not correctly return the exit value of the executed program. use this
+# wrapper to manually extract the exit value
+rloc=/data/local/tmp/retval
+rsize=$(adb shell "ls -l $rloc"|tr -s ' '|cut -d' ' -f4)
+rcheck=38
+if [ "$rsize" != "$rcheck" ]; then
+#	echo "debug: retval size incorrect want $rcheck, got $rsize. uploading"
+	echo  >/tmp/adb.retval '#!/system/bin/sh
+"$@"
+echo RETVAL: $?' 
+	adb push /tmp/adb.retval $rloc >/dev/null 2>&1
+	adb shell chmod 755 $rloc
+fi
+
+# run the main binary
+if [ "-g" == "$1" ]; then
+	adb forward tcp:$2 tcp:$2
+	args=$(echo $*| cut -d' ' -f4-)
+	adb push $3 /data/local/tmp/$3 >/dev/null 2>&1
+	adb shell "$(exp GOARCH) $(exp GOTRACEBACK) $(exp GOGC) \
+		gdbserver :$2 /data/local/tmp/retval /data/local/tmp/$3 $args" \
+		2>&1|tr -d '\r' |tee /tmp/adb.out|grep -v RETVAL
+else
+	if [ "$*" != "$1" ]; then
+		args=$(echo $*| cut -d' ' -f2-)
+	fi
+	adb push $1 /data/local/tmp/$1 >/dev/null 2>&1
+	adb shell "$(exp GOARCH) $(exp GOTRACEBACK) $(exp GOGC) \
+		/data/local/tmp/retval /data/local/tmp/$1 $args" \
+		2>&1|tr -d '\r' |tee /tmp/adb.out|grep -v RETVAL
+fi
+exit $(grep RETVAL /tmp/adb.out|tr -d '\n\r'| cut -d' ' -f2)

misc/cgo/errors/argposition_test.go

@@ -12,7 +12,7 @@ import (
 	"go/ast"
 	"go/parser"
 	"go/token"
-	"internal/testenv"
+	"io/ioutil"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -66,9 +66,6 @@ func (v *Visitor) Visit(node ast.Node) ast.Visitor {
 }
 
 func TestArgumentsPositions(t *testing.T) {
-	testenv.MustHaveCGO(t)
-	testenv.MustHaveExec(t)
-
 	testdata, err := filepath.Abs("testdata")
 	if err != nil {
 		t.Fatal(err)
@@ -91,7 +88,7 @@ func TestArgumentsPositions(t *testing.T) {
 	if err != nil {
 		t.Fatalf("%s: %v\n%s", cmd, err, cmd.Stderr)
 	}
-	mainProcessed, err := os.ReadFile(filepath.Join(dir, "issue42580.cgo1.go"))
+	mainProcessed, err := ioutil.ReadFile(filepath.Join(dir, "issue42580.cgo1.go"))
 	if err != nil {
 		t.Fatal(err)
 	}

misc/cgo/errors/badsym_test.go

@@ -6,8 +6,6 @@ package errorstest
 
 import (
 	"bytes"
-	"cmd/internal/quoted"
-	"internal/testenv"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -41,9 +39,6 @@ func main() {
 `
 
 func TestBadSymbol(t *testing.T) {
-	testenv.MustHaveGoBuild(t)
-	testenv.MustHaveCGO(t)
-
 	dir := t.TempDir()
 
 	mkdir := func(base string) string {
@@ -172,14 +167,7 @@ func TestBadSymbol(t *testing.T) {
 }
 
 func cCompilerCmd(t *testing.T) []string {
-	cc, err := quoted.Split(goEnv(t, "CC"))
-	if err != nil {
-		t.Skipf("parsing go env CC: %s", err)
-	}
-	if len(cc) == 0 {
-		t.Skipf("no C compiler")
-	}
-	testenv.MustHaveExecPath(t, cc[0])
+	cc := []string{goEnv(t, "CC")}
 
 	out := goEnv(t, "GOGCCFLAGS")
 	quote := '\000'

misc/cgo/errors/errors_test.go

@@ -7,7 +7,6 @@ package errorstest
 import (
 	"bytes"
 	"fmt"
-	"internal/testenv"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -23,8 +22,6 @@ func path(file string) string {
 
 func check(t *testing.T, file string) {
 	t.Run(file, func(t *testing.T) {
-		testenv.MustHaveGoBuild(t)
-		testenv.MustHaveCGO(t)
 		t.Parallel()
 
 		contents, err := os.ReadFile(path(file))
@@ -92,8 +89,6 @@ func expect(t *testing.T, file string, errors []*regexp.Regexp) {
 }
 
 func sizeofLongDouble(t *testing.T) int {
-	testenv.MustHaveGoRun(t)
-	testenv.MustHaveCGO(t)
 	cmd := exec.Command("go", "run", path("long_double_size.go"))
 	out, err := cmd.CombinedOutput()
 	if err != nil {
@@ -139,8 +134,6 @@ func TestToleratesOptimizationFlag(t *testing.T) {
 	} {
 		cflags := cflags
 		t.Run(cflags, func(t *testing.T) {
-			testenv.MustHaveGoBuild(t)
-			testenv.MustHaveCGO(t)
 			t.Parallel()
 
 			cmd := exec.Command("go", "build", path("issue14669.go"))
@@ -154,8 +147,6 @@ func TestToleratesOptimizationFlag(t *testing.T) {
 }
 
 func TestMallocCrashesOnNil(t *testing.T) {
-	testenv.MustHaveCGO(t)
-	testenv.MustHaveGoRun(t)
 	t.Parallel()
 
 	cmd := exec.Command("go", "run", path("malloc.go"))

misc/cgo/errors/ptr_test.go

@@ -10,12 +10,9 @@ import (
 	"bytes"
 	"flag"
 	"fmt"
-	"internal/testenv"
 	"os"
 	"os/exec"
 	"path/filepath"
-	"runtime"
-	"slices"
 	"strings"
 	"sync/atomic"
 	"testing"
@@ -164,17 +161,6 @@ var ptrTests = []ptrTest{
 		fail:      true,
 		expensive: true,
 	},
-	{
-		// Storing a pinned Go pointer into C memory should succeed.
-		name: "barrierpinnedok",
-		c: `#include <stdlib.h>
-		    char **f14a2() { return malloc(sizeof(char*)); }
-		    void f14b2(char **p) {}`,
-		imports:   []string{"runtime"},
-		body:      `var pinr runtime.Pinner; p := C.f14a2(); x := new(C.char); pinr.Pin(x); *p = x; C.f14b2(p); pinr.Unpin()`,
-		fail:      false,
-		expensive: true,
-	},
 	{
 		// Storing a Go pointer into C memory by assigning a
 		// large value should fail.
@@ -445,54 +431,10 @@ var ptrTests = []ptrTest{
 		body:    `s := &S40{p: new(int)}; C.f40((*C.struct_S40i)(&s.a))`,
 		fail:    false,
 	},
-	{
-		// Test that we handle unsafe.StringData.
-		name:    "stringdata",
-		c:       `void f41(void* p) {}`,
-		imports: []string{"unsafe"},
-		body:    `s := struct { a [4]byte; p *int }{p: new(int)}; str := unsafe.String(&s.a[0], 4); C.f41(unsafe.Pointer(unsafe.StringData(str)))`,
-		fail:    false,
-	},
-	{
-		name:    "slicedata",
-		c:       `void f42(void* p) {}`,
-		imports: []string{"unsafe"},
-		body:    `s := []*byte{nil, new(byte)}; C.f42(unsafe.Pointer(unsafe.SliceData(s)))`,
-		fail:    true,
-	},
-	{
-		name:    "slicedata2",
-		c:       `void f43(void* p) {}`,
-		imports: []string{"unsafe"},
-		body:    `s := struct { a [4]byte; p *int }{p: new(int)}; C.f43(unsafe.Pointer(unsafe.SliceData(s.a[:])))`,
-		fail:    false,
-	},
 }
 
 func TestPointerChecks(t *testing.T) {
-	testenv.MustHaveGoBuild(t)
-	testenv.MustHaveCGO(t)
-	if runtime.GOOS == "windows" {
-		// TODO: Skip just the cases that fail?
-		t.Skipf("some tests fail to build on %s", runtime.GOOS)
-	}
-
-	var gopath string
-	var dir string
-	if *tmp != "" {
-		gopath = *tmp
-		dir = ""
-	} else {
-		d, err := os.MkdirTemp("", filepath.Base(t.Name()))
-		if err != nil {
-			t.Fatal(err)
-		}
-		dir = d
-		gopath = d
-	}
-
-	exe := buildPtrTests(t, gopath, false)
-	exe2 := buildPtrTests(t, gopath, true)
+	dir, exe := buildPtrTests(t)
 
 	// We (TestPointerChecks) return before the parallel subtest functions do,
 	// so we can't just defer os.RemoveAll(dir). Instead we have to wait for
@@ -509,18 +451,30 @@ func TestPointerChecks(t *testing.T) {
 					os.RemoveAll(dir)
 				}
 			}()
-			testOne(t, pt, exe, exe2)
+			testOne(t, pt, exe)
 		})
 	}
 }
 
-func buildPtrTests(t *testing.T, gopath string, cgocheck2 bool) (exe string) {
+func buildPtrTests(t *testing.T) (dir, exe string) {
+	var gopath string
+	if *tmp != "" {
+		gopath = *tmp
+		dir = ""
+	} else {
+		d, err := os.MkdirTemp("", filepath.Base(t.Name()))
+		if err != nil {
+			t.Fatal(err)
+		}
+		dir = d
+		gopath = d
+	}
 
 	src := filepath.Join(gopath, "src", "ptrtest")
 	if err := os.MkdirAll(src, 0777); err != nil {
 		t.Fatal(err)
 	}
-	if err := os.WriteFile(filepath.Join(src, "go.mod"), []byte("module ptrtest\ngo 1.20"), 0666); err != nil {
+	if err := os.WriteFile(filepath.Join(src, "go.mod"), []byte("module ptrtest"), 0666); err != nil {
 		t.Fatal(err)
 	}
 
@@ -587,38 +541,15 @@ func buildPtrTests(t *testing.T, gopath string, cgocheck2 bool) (exe string) {
 		t.Fatal(err)
 	}
 
-	exeName := "ptrtest.exe"
-	if cgocheck2 {
-		exeName = "ptrtest2.exe"
-	}
-	cmd := exec.Command("go", "build", "-o", exeName)
+	cmd := exec.Command("go", "build", "-o", "ptrtest.exe")
 	cmd.Dir = src
 	cmd.Env = append(os.Environ(), "GOPATH="+gopath)
-
-	// Set or remove cgocheck2 from the environment.
-	goexperiment := strings.Split(os.Getenv("GOEXPERIMENT"), ",")
-	if len(goexperiment) == 1 && goexperiment[0] == "" {
-		goexperiment = nil
-	}
-	i := slices.Index(goexperiment, "cgocheck2")
-	changed := false
-	if cgocheck2 && i < 0 {
-		goexperiment = append(goexperiment, "cgocheck2")
-		changed = true
-	} else if !cgocheck2 && i >= 0 {
-		goexperiment = append(goexperiment[:i], goexperiment[i+1:]...)
-		changed = true
-	}
-	if changed {
-		cmd.Env = append(cmd.Env, "GOEXPERIMENT="+strings.Join(goexperiment, ","))
-	}
-
 	out, err := cmd.CombinedOutput()
 	if err != nil {
 		t.Fatalf("go build: %v\n%s", err, out)
 	}
 
-	return filepath.Join(src, exeName)
+	return dir, filepath.Join(src, "ptrtest.exe")
 }
 
 const ptrTestMain = `
@@ -635,7 +566,7 @@ func main() {
 
 var csem = make(chan bool, 16)
 
-func testOne(t *testing.T, pt ptrTest, exe, exe2 string) {
+func testOne(t *testing.T, pt ptrTest, exe string) {
 	t.Parallel()
 
 	// Run the tests in parallel, but don't run too many
@@ -643,12 +574,7 @@ func testOne(t *testing.T, pt ptrTest, exe, exe2 string) {
 	runcmd := func(cgocheck string) ([]byte, error) {
 		csem <- true
 		defer func() { <-csem }()
-		x := exe
-		if cgocheck == "2" {
-			x = exe2
-			cgocheck = "1"
-		}
-		cmd := exec.Command(x, pt.name)
+		cmd := exec.Command(exe, pt.name)
 		cmd.Env = append(os.Environ(), "GODEBUG=cgocheck="+cgocheck)
 		return cmd.CombinedOutput()
 	}

misc/cgo/fortran/fortran.go

@@ -2,20 +2,11 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-package main
+package fortran
 
 // int the_answer();
 import "C"
-import "os"
 
 func TheAnswer() int {
 	return int(C.the_answer())
 }
-
-func main() {
-	if a := TheAnswer(); a != 42 {
-		println("Unexpected result for The Answer. Got:", a, " Want: 42")
-		os.Exit(1)
-	}
-	println("ok")
-}

misc/cgo/fortran/fortran_test.go

@@ -0,0 +1,13 @@
+// Copyright 2016 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 fortran
+
+import "testing"
+
+func TestFortran(t *testing.T) {
+	if a := TheAnswer(); a != 42 {
+		t.Errorf("Unexpected result for The Answer. Got: %d Want: 42", a)
+	}
+}

misc/cgo/fortran/test.bash

@@ -0,0 +1,44 @@
+#!/usr/bin/env bash
+# Copyright 2016 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 directory is intended to test the use of Fortran with cgo.
+
+set -e
+
+FC=$1
+
+goos=$(go env GOOS)
+
+libext="so"
+if [ "$goos" = "darwin" ]; then
+	libext="dylib"
+elif [ "$goos" = "aix" ]; then
+	libtext="a"
+fi
+
+case "$FC" in
+*gfortran*)
+  libpath=$(dirname $($FC -print-file-name=libgfortran.$libext))
+  if [ "$goos" != "aix" ]; then
+	  RPATH_FLAG="-Wl,-rpath,$libpath"
+  fi
+  export CGO_LDFLAGS="$CGO_LDFLAGS $RPATH_FLAG -L $libpath"
+  ;;
+esac
+
+if ! $FC helloworld/helloworld.f90 -o /dev/null >& /dev/null; then
+  echo "skipping Fortran test: could not build helloworld.f90 with $FC"
+  exit 0
+fi
+rm -f main.exe
+
+status=0
+
+if ! go test; then
+  echo "FAIL: go test"
+  status=1
+fi
+
+exit $status

misc/cgo/gmp/fib.go

@@ -3,6 +3,7 @@
 // license that can be found in the LICENSE file.
 
 //go:build ignore
+// +build ignore
 
 // Compute Fibonacci numbers with two goroutines
 // that pass integers back and forth.  No actual

misc/cgo/gmp/pi.go

@@ -3,6 +3,7 @@
 // license that can be found in the LICENSE file.
 
 //go:build ignore
+// +build ignore
 
 package main
 

misc/cgo/life/life_test.go

@@ -6,12 +6,11 @@ package life_test
 
 import (
 	"bytes"
-	"cmd/cgo/internal/cgotest"
-	"internal/testenv"
 	"log"
 	"os"
 	"os/exec"
 	"path/filepath"
+	"strings"
 	"testing"
 )
 
@@ -31,7 +30,7 @@ func testMain(m *testing.M) int {
 	// Copy testdata into GOPATH/src/cgolife, along with a go.mod file
 	// declaring the same path.
 	modRoot := filepath.Join(GOPATH, "src", "cgolife")
-	if err := cgotest.OverlayDir(modRoot, "testdata"); err != nil {
+	if err := overlayDir(modRoot, "testdata"); err != nil {
 		log.Panic(err)
 	}
 	if err := os.Chdir(modRoot); err != nil {
@@ -45,21 +44,20 @@ func testMain(m *testing.M) int {
 	return m.Run()
 }
 
-// TestTestRun runs a test case for cgo //export.
 func TestTestRun(t *testing.T) {
-	testenv.MustHaveGoRun(t)
-	testenv.MustHaveCGO(t)
+	if os.Getenv("GOOS") == "android" {
+		t.Skip("the go tool runs with CGO_ENABLED=0 on the android device")
+	}
+	out, err := exec.Command("go", "env", "GOROOT").Output()
+	if err != nil {
+		t.Fatal(err)
+	}
+	GOROOT := string(bytes.TrimSpace(out))
 
-	cmd := exec.Command("go", "run", "main.go")
-	got, err := cmd.CombinedOutput()
+	cmd := exec.Command("go", "run", filepath.Join(GOROOT, "test", "run.go"), "-", ".")
+	out, err = cmd.CombinedOutput()
 	if err != nil {
-		t.Fatalf("%v: %s\n%s", cmd, err, got)
-	}
-	want, err := os.ReadFile("main.out")
-	if err != nil {
-		t.Fatal("reading golden output:", err)
-	}
-	if !bytes.Equal(got, want) {
-		t.Errorf("'%v' output does not match expected in main.out. Instead saw:\n%s", cmd, got)
+		t.Fatalf("%s: %s\n%s", strings.Join(cmd.Args, " "), err, out)
 	}
+	t.Logf("%s:\n%s", strings.Join(cmd.Args, " "), out)
 }

misc/cgo/life/overlaydir_test.go

@@ -0,0 +1,78 @@
+// Copyright 2019 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package life_test
+
+import (
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+// overlayDir makes a minimal-overhead copy of srcRoot in which new files may be added.
+//
+// TODO: Once we no longer need to support the misc module in GOPATH mode,
+// factor this function out into a package to reduce duplication.
+func overlayDir(dstRoot, srcRoot string) error {
+	dstRoot = filepath.Clean(dstRoot)
+	if err := os.MkdirAll(dstRoot, 0777); err != nil {
+		return err
+	}
+
+	srcRoot, err := filepath.Abs(srcRoot)
+	if err != nil {
+		return err
+	}
+
+	return filepath.Walk(srcRoot, func(srcPath string, info os.FileInfo, err error) error {
+		if err != nil || srcPath == srcRoot {
+			return err
+		}
+
+		suffix := strings.TrimPrefix(srcPath, srcRoot)
+		for len(suffix) > 0 && suffix[0] == filepath.Separator {
+			suffix = suffix[1:]
+		}
+		dstPath := filepath.Join(dstRoot, suffix)
+
+		perm := info.Mode() & os.ModePerm
+		if info.Mode()&os.ModeSymlink != 0 {
+			info, err = os.Stat(srcPath)
+			if err != nil {
+				return err
+			}
+			perm = info.Mode() & os.ModePerm
+		}
+
+		// Always copy directories (don't symlink them).
+		// If we add a file in the overlay, we don't want to add it in the original.
+		if info.IsDir() {
+			return os.MkdirAll(dstPath, perm|0200)
+		}
+
+		// If the OS supports symlinks, use them instead of copying bytes.
+		if err := os.Symlink(srcPath, dstPath); err == nil {
+			return nil
+		}
+
+		// Otherwise, copy the bytes.
+		src, err := os.Open(srcPath)
+		if err != nil {
+			return err
+		}
+		defer src.Close()
+
+		dst, err := os.OpenFile(dstPath, os.O_WRONLY|os.O_CREATE|os.O_EXCL, perm)
+		if err != nil {
+			return err
+		}
+
+		_, err = io.Copy(dst, src)
+		if closeErr := dst.Close(); err == nil {
+			err = closeErr
+		}
+		return err
+	})
+}

misc/cgo/life/testdata/life.go

@@ -1,3 +1,5 @@
+// skip
+
 // Copyright 2010 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.
@@ -20,9 +22,8 @@ func Run(gen, x, y int, a []int32) {
 // Keep the channels visible from Go.
 var chans [4]chan bool
 
-// Double return value is just for testing.
-//
 //export GoStart
+// Double return value is just for testing.
 func GoStart(i, xdim, ydim, xstart, xend, ystart, yend C.int, a *C.int, n *C.int) (int, int) {
 	c := make(chan bool, int(C.MYCONST))
 	go func() {

misc/cgo/life/testdata/main.go

@@ -1,8 +1,10 @@
+// run -tags=use_go_run
+
 // Copyright 2010 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 test_run
+// +build test_run
 
 // Run the game of life in C using Go for parallelization.
 

misc/cgo/stdio/overlaydir_test.go

@@ -0,0 +1,78 @@
+// Copyright 2019 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package stdio_test
+
+import (
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+// overlayDir makes a minimal-overhead copy of srcRoot in which new files may be added.
+//
+// TODO: Once we no longer need to support the misc module in GOPATH mode,
+// factor this function out into a package to reduce duplication.
+func overlayDir(dstRoot, srcRoot string) error {
+	dstRoot = filepath.Clean(dstRoot)
+	if err := os.MkdirAll(dstRoot, 0777); err != nil {
+		return err
+	}
+
+	srcRoot, err := filepath.Abs(srcRoot)
+	if err != nil {
+		return err
+	}
+
+	return filepath.Walk(srcRoot, func(srcPath string, info os.FileInfo, err error) error {
+		if err != nil || srcPath == srcRoot {
+			return err
+		}
+
+		suffix := strings.TrimPrefix(srcPath, srcRoot)
+		for len(suffix) > 0 && suffix[0] == filepath.Separator {
+			suffix = suffix[1:]
+		}
+		dstPath := filepath.Join(dstRoot, suffix)
+
+		perm := info.Mode() & os.ModePerm
+		if info.Mode()&os.ModeSymlink != 0 {
+			info, err = os.Stat(srcPath)
+			if err != nil {
+				return err
+			}
+			perm = info.Mode() & os.ModePerm
+		}
+
+		// Always copy directories (don't symlink them).
+		// If we add a file in the overlay, we don't want to add it in the original.
+		if info.IsDir() {
+			return os.MkdirAll(dstPath, perm|0200)
+		}
+
+		// If the OS supports symlinks, use them instead of copying bytes.
+		if err := os.Symlink(srcPath, dstPath); err == nil {
+			return nil
+		}
+
+		// Otherwise, copy the bytes.
+		src, err := os.Open(srcPath)
+		if err != nil {
+			return err
+		}
+		defer src.Close()
+
+		dst, err := os.OpenFile(dstPath, os.O_WRONLY|os.O_CREATE|os.O_EXCL, perm)
+		if err != nil {
+			return err
+		}
+
+		_, err = io.Copy(dst, src)
+		if closeErr := dst.Close(); err == nil {
+			err = closeErr
+		}
+		return err
+	})
+}

misc/cgo/stdio/stdio_test.go

@@ -6,8 +6,6 @@ package stdio_test
 
 import (
 	"bytes"
-	"cmd/cgo/internal/cgotest"
-	"internal/testenv"
 	"log"
 	"os"
 	"os/exec"
@@ -32,7 +30,7 @@ func testMain(m *testing.M) int {
 	// Copy testdata into GOPATH/src/cgostdio, along with a go.mod file
 	// declaring the same path.
 	modRoot := filepath.Join(GOPATH, "src", "cgostdio")
-	if err := cgotest.OverlayDir(modRoot, "testdata"); err != nil {
+	if err := overlayDir(modRoot, "testdata"); err != nil {
 		log.Panic(err)
 	}
 	if err := os.Chdir(modRoot); err != nil {
@@ -46,32 +44,20 @@ func testMain(m *testing.M) int {
 	return m.Run()
 }
 
-// TestTestRun runs a cgo test that doesn't depend on non-standard libraries.
 func TestTestRun(t *testing.T) {
-	testenv.MustHaveGoRun(t)
-	testenv.MustHaveCGO(t)
-
-	for _, file := range [...]string{
-		"chain.go",
-		"fib.go",
-		"hello.go",
-	} {
-		file := file
-		wantFile := strings.Replace(file, ".go", ".out", 1)
-		t.Run(file, func(t *testing.T) {
-			cmd := exec.Command("go", "run", file)
-			got, err := cmd.CombinedOutput()
-			if err != nil {
-				t.Fatalf("%v: %s\n%s", cmd, err, got)
-			}
-			got = bytes.ReplaceAll(got, []byte("\r\n"), []byte("\n"))
-			want, err := os.ReadFile(wantFile)
-			if err != nil {
-				t.Fatal("reading golden output:", err)
-			}
-			if !bytes.Equal(got, want) {
-				t.Errorf("'%v' output does not match expected in %s. Instead saw:\n%s", cmd, wantFile, got)
-			}
-		})
+	if os.Getenv("GOOS") == "android" {
+		t.Skip("subpackage stdio is not available on android")
 	}
+	out, err := exec.Command("go", "env", "GOROOT").Output()
+	if err != nil {
+		t.Fatal(err)
+	}
+	GOROOT := string(bytes.TrimSpace(out))
+
+	cmd := exec.Command("go", "run", filepath.Join(GOROOT, "test", "run.go"), "-", ".")
+	out, err = cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("%s: %s\n%s", strings.Join(cmd.Args, " "), err, out)
+	}
+	t.Logf("%s:\n%s", strings.Join(cmd.Args, " "), out)
 }

misc/cgo/stdio/testdata/chain.go

@@ -1,8 +1,10 @@
+// run -tags=use_go_run
+
 // Copyright 2009 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 test_run
+// +build test_run
 
 // Pass numbers along a chain of threads.
 

misc/cgo/stdio/testdata/fib.go

@@ -1,8 +1,10 @@
+// run -tags=use_go_run
+
 // Copyright 2009 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 test_run
+// +build test_run
 
 // Compute Fibonacci numbers with two goroutines
 // that pass integers back and forth.  No actual

misc/cgo/stdio/testdata/hello.go

@@ -1,8 +1,10 @@
+// run -tags=use_go_run
+
 // Copyright 2009 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 test_run
+// +build test_run
 
 package main
 

misc/cgo/stdio/testdata/run.out

@@ -0,0 +1,150 @@
+* hello
+hello, world
+* fib
+0
+1
+1
+2
+3
+5
+8
+13
+21
+34
+55
+89
+144
+233
+377
+610
+987
+1597
+2584
+4181
+6765
+10946
+17711
+28657
+46368
+75025
+121393
+196418
+317811
+514229
+832040
+1346269
+2178309
+3524578
+5702887
+9227465
+14930352
+24157817
+39088169
+63245986
+102334155
+165580141
+267914296
+433494437
+701408733
+1134903170
+1836311903
+2971215073
+4807526976
+7778742049
+12586269025
+20365011074
+32951280099
+53316291173
+86267571272
+139583862445
+225851433717
+365435296162
+591286729879
+956722026041
+1548008755920
+2504730781961
+4052739537881
+6557470319842
+10610209857723
+17167680177565
+27777890035288
+44945570212853
+72723460248141
+117669030460994
+190392490709135
+308061521170129
+498454011879264
+806515533049393
+1304969544928657
+2111485077978050
+3416454622906707
+5527939700884757
+8944394323791464
+14472334024676221
+23416728348467685
+37889062373143906
+61305790721611591
+99194853094755497
+160500643816367088
+259695496911122585
+420196140727489673
+679891637638612258
+1100087778366101931
+1779979416004714189
+2880067194370816120
+* chain
+0
+1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+0
+1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+0
+1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+0
+1
+2
+3
+4
+5
+6
+7
+8
+9
+10
+0
+1
+2
+3
+4
+5
+6
+7
+8
+9
+10

misc/cgo/stdio/testdata/stdio/file.go

@@ -1,3 +1,5 @@
+// skip
+
 // Copyright 2009 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.
@@ -5,7 +7,7 @@
 /*
 A trivial example of wrapping a C library in Go.
 For a more complex example and explanation,
-see misc/cgo/gmp/gmp.go.
+see ../gmp/gmp.go.
 */
 
 package stdio

misc/cgo/stdio/testdata/stdio/stdio.go

@@ -1,3 +1,5 @@
+// skip
+
 // Copyright 2009 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.

misc/cgo/test/callback.go

@@ -211,7 +211,7 @@ func testCallbackCallers(t *testing.T) {
 		}
 		// In module mode, this package has a fully-qualified import path.
 		// Remove it if present.
-		fname = strings.TrimPrefix(fname, "cmd/cgo/internal/")
+		fname = strings.TrimPrefix(fname, "misc/cgo/")
 
 		namei := ""
 		if i < len(name) {

misc/cgo/test/callback_c_gc.c

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build gc
+// +build gc
 
 #include "_cgo_export.h"
 #include <stdint.h>

misc/cgo/test/callback_c_gccgo.c

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build gccgo
+// +build gccgo
 
 #include "_cgo_export.h"
 #include <stdint.h>

misc/cgo/test/cgo_linux_test.go

@@ -0,0 +1,28 @@
+// Copyright 2012 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 cgotest
+
+import (
+	"runtime"
+	"testing"
+)
+
+func TestSetgid(t *testing.T) {
+	if runtime.GOOS == "android" {
+		t.Skip("unsupported on Android")
+	}
+	testSetgid(t)
+}
+
+func TestSetgidStress(t *testing.T) {
+	if runtime.GOOS == "android" {
+		t.Skip("unsupported on Android")
+	}
+	testSetgidStress(t)
+}
+
+func Test1435(t *testing.T)    { test1435(t) }
+func Test6997(t *testing.T)    { test6997(t) }
+func TestBuildID(t *testing.T) { testBuildID(t) }

misc/cgo/test/cgo_test.go

@@ -2,8 +2,6 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build cgo
-
 package cgotest
 
 import "testing"
@@ -36,10 +34,7 @@ func Test7978(t *testing.T)                  { test7978(t) }
 func Test8092(t *testing.T)                  { test8092(t) }
 func Test8517(t *testing.T)                  { test8517(t) }
 func Test8694(t *testing.T)                  { test8694(t) }
-func Test8756(t *testing.T)                  { test8756(t) }
 func Test8811(t *testing.T)                  { test8811(t) }
-func Test9026(t *testing.T)                  { test9026(t) }
-func Test9510(t *testing.T)                  { test9510(t) }
 func Test9557(t *testing.T)                  { test9557(t) }
 func Test10303(t *testing.T)                 { test10303(t, 10) }
 func Test11925(t *testing.T)                 { test11925(t) }
@@ -50,7 +45,6 @@ func Test17537(t *testing.T)                 { test17537(t) }
 func Test18126(t *testing.T)                 { test18126(t) }
 func Test18720(t *testing.T)                 { test18720(t) }
 func Test20129(t *testing.T)                 { test20129(t) }
-func Test20266(t *testing.T)                 { test20266(t) }
 func Test20369(t *testing.T)                 { test20369(t) }
 func Test20910(t *testing.T)                 { test20910(t) }
 func Test21708(t *testing.T)                 { test21708(t) }
@@ -61,7 +55,6 @@ func Test23356(t *testing.T)                 { test23356(t) }
 func Test24206(t *testing.T)                 { test24206(t) }
 func Test25143(t *testing.T)                 { test25143(t) }
 func Test26066(t *testing.T)                 { test26066(t) }
-func Test26213(t *testing.T)                 { test26213(t) }
 func Test27660(t *testing.T)                 { test27660(t) }
 func Test28896(t *testing.T)                 { test28896(t) }
 func Test30065(t *testing.T)                 { test30065(t) }
@@ -91,7 +84,6 @@ func TestNamedEnum(t *testing.T)             { testNamedEnum(t) }
 func TestCastToEnum(t *testing.T)            { testCastToEnum(t) }
 func TestErrno(t *testing.T)                 { testErrno(t) }
 func TestFpVar(t *testing.T)                 { testFpVar(t) }
-func TestGCC68255(t *testing.T)              { testGCC68255(t) }
 func TestHandle(t *testing.T)                { testHandle(t) }
 func TestHelpers(t *testing.T)               { testHelpers(t) }
 func TestLibgcc(t *testing.T)                { testLibgcc(t) }
@@ -106,7 +98,6 @@ func TestThreadLock(t *testing.T)            { testThreadLockFunc(t) }
 func TestUnsignedInt(t *testing.T)           { testUnsignedInt(t) }
 func TestZeroArgCallback(t *testing.T)       { testZeroArgCallback(t) }
 
-func BenchmarkCgoCall(b *testing.B)      { benchCgoCall(b) }
-func BenchmarkGoString(b *testing.B)     { benchGoString(b) }
-func BenchmarkCGoCallback(b *testing.B)  { benchCallback(b) }
-func BenchmarkCGoInCThread(b *testing.B) { benchCGoInCthread(b) }
+func BenchmarkCgoCall(b *testing.B)     { benchCgoCall(b) }
+func BenchmarkGoString(b *testing.B)    { benchGoString(b) }
+func BenchmarkCGoCallback(b *testing.B) { benchCallback(b) }

misc/cgo/test/cgo_thread_lock.go

@@ -2,25 +2,22 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build linux
+//go:build linux && freebsd && openbsd
+// +build linux,freebsd,openbsd
 
 package cgotest
 
 /*
 #include <unistd.h>
-#include <stdbool.h>
 #include <sys/syscall.h>
 void Gosched(void);
-static bool Ctid(void) {
-	long tid1 = syscall(SYS_gettid);
-	Gosched();
-	return tid1 == syscall(SYS_gettid);
-}
+static int Ctid(void) { Gosched(); return syscall(SYS_gettid); }
 */
 import "C"
 
 import (
 	"runtime"
+	"syscall"
 	"testing"
 	"time"
 )
@@ -50,7 +47,7 @@ func testThreadLock(t *testing.T) {
 	defer close(stop)
 
 	for i := 0; i < 1000; i++ {
-		if !C.Ctid() {
+		if C.int(syscall.Gettid()) != C.Ctid() {
 			t.Fatalf("cgo has not locked OS thread")
 		}
 	}

misc/cgo/test/cgo_unix_test.go

@@ -2,7 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build cgo && !windows
+//go:build !windows
+// +build !windows
 
 package cgotest
 

misc/cgo/test/cthread_unix.c

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build aix || darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
+// +build aix darwin dragonfly freebsd linux netbsd openbsd solaris
 
 #include <pthread.h>
 #include "_cgo_export.h"
@@ -32,27 +32,3 @@ doAdd(int max, int nthread)
 	for(i=0; i<nthread; i++)
 		pthread_join(thread_id[i], 0);		
 }
-
-static void*
-goDummyCallbackThread(void* p)
-{
-	int i, max;
-
-	max = *(int*)p;
-	for(i=0; i<max; i++)
-		goDummy();
-	return NULL;
-}
-
-int
-callGoInCThread(int max)
-{
-	pthread_t thread;
-
-	if (pthread_create(&thread, NULL, goDummyCallbackThread, (void*)(&max)) != 0)
-		return -1;
-	if (pthread_join(thread, NULL) != 0)
-		return -1;
-
-	return max;
-}

misc/cgo/test/cthread_windows.c

@@ -35,25 +35,3 @@ doAdd(int max, int nthread)
 		CloseHandle((HANDLE)thread_id[i]);
 	}
 }
-
-__stdcall
-static unsigned int
-goDummyCallbackThread(void* p)
-{
-	int i, max;
-
-	max = *(int*)p;
-	for(i=0; i<max; i++)
-		goDummy();
-	return 0;
-}
-
-int
-callGoInCThread(int max)
-{
-	uintptr_t thread_id;
-	thread_id = _beginthreadex(0, 0, goDummyCallbackThread, &max, 0, 0);
-	WaitForSingleObject((HANDLE)thread_id, INFINITE);
-	CloseHandle((HANDLE)thread_id);
-	return max;
-}

misc/cgo/test/issue1435.go

@@ -3,13 +3,13 @@
 // license that can be found in the LICENSE file.
 
 //go:build linux && cgo
+// +build linux,cgo
 
 package cgotest
 
 import (
 	"fmt"
 	"os"
-	"runtime"
 	"sort"
 	"strings"
 	"syscall"
@@ -145,11 +145,6 @@ func test1435(t *testing.T) {
 	if syscall.Getuid() != 0 {
 		t.Skip("skipping root only test")
 	}
-	if runtime.GOOS == "linux" {
-		if _, err := os.Stat("/etc/alpine-release"); err == nil {
-			t.Skip("skipping failing test on alpine - go.dev/issue/19938")
-		}
-	}
 
 	// Launch some threads in C.
 	const cts = 5

misc/cgo/test/issue18146.go

@@ -2,7 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build cgo && !windows
+//go:build !windows
+// +build !windows
 
 // Issue 18146: pthread_create failure during syscall.Exec.
 

misc/cgo/test/issue21897.go

@@ -3,6 +3,7 @@
 // license that can be found in the LICENSE file.
 
 //go:build darwin && cgo && !internal
+// +build darwin,cgo,!internal
 
 package cgotest
 

misc/cgo/test/issue21897b.go

@@ -3,6 +3,7 @@
 // license that can be found in the LICENSE file.
 
 //go:build !darwin || !cgo || internal
+// +build !darwin !cgo internal
 
 package cgotest
 

misc/cgo/test/issue4029.c

@@ -2,7 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-//go:build !windows && !static && (!darwin || (!internal_pie && !arm64))
+// +build !windows,!static
+// +build !darwin !internal_pie,!arm64
 
 #include <stdint.h>
 #include <dlfcn.h>

misc/cgo/test/issue4029.go

@@ -3,6 +3,9 @@
 // license that can be found in the LICENSE file.
 
 //go:build !windows && !static && (!darwin || (!internal_pie && !arm64))
+// +build !windows
+// +build !static
+// +build !darwin !internal_pie,!arm64
 
 // Excluded in darwin internal linking PIE mode, as dynamic export is not
 // supported.

misc/cgo/test/issue4029w.go

@@ -3,6 +3,7 @@
 // license that can be found in the LICENSE file.
 
 //go:build windows || static || (darwin && internal_pie) || (darwin && arm64)
+// +build windows static darwin,internal_pie darwin,arm64
 
 package cgotest
 

misc/cgo/test/issue42018.go

@@ -3,6 +3,7 @@
 // license that can be found in the LICENSE file.
 
 //go:build !windows
+// +build !windows
 
 package cgotest