[dev.boringcrypto.go1.17] all: merge go1.17.13 into dev.boringcrypto.go1.17

Change-Id: Iaf4f2cb506aab9e22a5df5b937c38fc108f1e1c1

.github/ISSUE_TEMPLATE

@@ -0,0 +1,38 @@
+<!--
+Please answer these questions before submitting your issue. Thanks!
+For questions please use one of our forums: https://github.com/golang/go/wiki/Questions
+-->
+
+### What version of Go are you using (`go version`)?
+
+<pre>
+$ go version
+
+</pre>
+
+### Does this issue reproduce with the latest release?
+
+
+
+### 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 play.golang.org is best.
+-->
+
+
+
+### What did you expect to see?
+
+
+
+### What did you see instead?

.github/ISSUE_TEMPLATE/00-bug.yml

@@ -1,94 +0,0 @@
-# https://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/configuring-issue-templates-for-your-repository#creating-issue-forms
-# https://docs.github.com/en/communities/using-templates-to-encourage-useful-issues-and-pull-requests/syntax-for-githubs-form-schema
-name: Bugs
-description: The go command, standard library, or anything else
-title: "import/path: issue title"
-
-body:
-  - type: markdown
-    attributes:
-      value: |
-        Thanks for helping us improve! 🙏 Please answer these questions and provide as much information as possible about your problem.
-
-  - type: input
-    id: go-version
-    attributes:
-      label: Go version
-      description: |
-        What version of Go are you using (`go version`)?
-
-        Note: we only [support](https://go.dev/doc/devel/release#policy) the two most recent major releases.
-      placeholder: ex. go version go1.20.7 darwin/arm64
-    validations:
-      required: true
-
-  - type: textarea
-    id: go-env
-    attributes:
-      label: "Output of `go env` in your module/workspace:"
-      placeholder: |
-        GO111MODULE=""
-        GOARCH="arm64"
-        GOBIN="/Users/gopher/go/bin"
-        GOCACHE="/Users/gopher/go/cache"
-        GOENV="/Users/gopher/Library/Application Support/go/env"
-        GOEXE=""
-        GOEXPERIMENT=""
-        GOFLAGS=""
-        GOHOSTARCH="arm64"
-        GOHOSTOS="darwin"
-        GOINSECURE=""
-        GOMODCACHE="/Users/gopher/go/pkg/mod"
-        GONOPROXY=""
-        GONOSUMDB=""
-        GOOS="darwin"
-        GOPATH="/Users/gopher/go"
-        GOPRIVATE=""
-        GOPROXY="https://proxy.golang.org,direct"
-        GOROOT="/usr/local/go"
-        GOSUMDB="sum.golang.org"
-        GOTMPDIR=""
-        GOTOOLDIR="/usr/local/go/pkg/tool/darwin_arm64"
-        GOVCS=""
-        GOVERSION="go1.20.7"
-        GCCGO="gccgo"
-        AR="ar"
-        CC="clang"
-        CXX="clang++"
-        CGO_ENABLED="1"
-        GOMOD="/dev/null"
-        GOWORK=""
-        CGO_CFLAGS="-O2 -g"
-        CGO_CPPFLAGS=""
-        CGO_CXXFLAGS="-O2 -g"
-        CGO_FFLAGS="-O2 -g"
-        CGO_LDFLAGS="-O2 -g"
-        PKG_CONFIG="pkg-config"
-        GOGCCFLAGS="-fPIC -arch arm64 -pthread -fno-caret-diagnostics -Qunused-arguments -fmessage-length=0 -fdebug-prefix-map=/var/folders/44/nbbyll_10jd0z8rj_qxm43740000gn/T/go-build2331607515=/tmp/go-build -gno-record-gcc-switches -fno-common"
-      render: shell
-    validations:
-      required: true
-
-  - type: textarea
-    id: what-did-you-do
-    attributes:
-      label: "What did you do?"
-      description: "If possible, provide a recipe for reproducing the error. A complete runnable program is good. A link on [go.dev/play](https://go.dev/play) is best."
-    validations:
-      required: true
-
-  - type: textarea
-    id: actual-behavior
-    attributes:
-      label: "What did you see happen?"
-      description: Command invocations and their associated output, functions with their arguments and return results, full stacktraces for panics (upload a file if it is very long), etc. Prefer copying text output over using screenshots.
-    validations:
-      required: true
-
-  - type: textarea
-    id: expected-behavior
-    attributes:
-      label: "What did you expect to see?"
-      description: Why is the current output incorrect, and any additional context we may need to understand the issue.
-    validations:
-      required: true

.github/ISSUE_TEMPLATE/01-pkgsite.yml

@@ -1,47 +0,0 @@
-name: Pkg.go.dev bugs or feature requests
-description: Issues or feature requests for the documentation site
-title: "x/pkgsite: issue title"
-labels: ["pkgsite"]
-body:
-  - type: markdown
-    attributes:
-      value: "Please answer these questions before submitting your issue. Thanks!"
-  - type: input
-    id: url
-    attributes:
-      label: "What is the URL of the page with the issue?"
-    validations:
-      required: true
-  - type: input
-    id: user-agent
-    attributes:
-      label: "What is your user agent?"
-      description: "You can find your user agent here: https://www.google.com/search?q=what+is+my+user+agent"
-    validations:
-      required: true
-  - type: textarea
-    id: screenshot
-    attributes:
-      label: "Screenshot"
-      description: "Please paste a screenshot of the page."
-    validations:
-      required: false
-  - type: textarea
-    id: what-did-you-do
-    attributes:
-      label: "What did you do?"
-      description: "If possible, provide a recipe for reproducing the error. Starting with a Private/Incognito tab/window may help rule out problematic browser extensions."
-    validations:
-      required: true
-  - type: textarea
-    id: actual-behavior
-    attributes:
-      label: "What did you see happen?"
-    validations:
-      required: true
-  - type: textarea
-    id: expected-behavior
-    attributes:
-      label: "What did you expect to see?"
-    validations:
-      required: true

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

@@ -1,42 +0,0 @@
-name: Pkg.go.dev package removal request
-description: 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"]
-body:
-  - type: markdown
-    attributes:
-      value: "Please answer these questions before submitting your issue. Thanks!"
-  - type: input
-    id: package-path
-    attributes:
-      label: "What is the path of the package that you would like to have removed?"
-      description: |
-        We can remove packages with a shared path prefix.
-        For example, a request for 'github.com/author' would remove all pkg.go.dev pages with that package path prefix.
-    validations:
-      required: true
-  - type: textarea
-    id: package-owner
-    attributes:
-      label: "Are you the owner of this package?"
-      description: |
-        Only the package owners can request to have their packages removed from pkg.go.dev.
-        If the package path doesn't include your github username, please provide some other form of proof of ownership.
-    validations:
-      required: true
-  - type: textarea
-    id: retraction-reason
-    attributes:
-      label: "What is the reason that you could not retract this package instead?"
-      description: |
-        Requesting we remove a module here only hides the generated documentation on pkg.go.dev.
-        It does not affect the behaviour of proxy.golang.org or the go command.
-        Instead we recommend using the retract directive which will be processed by all 3 of the above.
-
-        If you have deleted your repo, please recreate it and publish a retraction.
-
-        Retracting a module version involves adding a retract directive to your go.mod file and publishing a new version.
-        For example: https://github.com/jba/retract-demo/blob/main/go.mod#L5-L8.
-        See https://pkg.go.dev/about#removing-a-package for additional tips on retractions.
-    validations:
-      required: true

.github/ISSUE_TEMPLATE/03-gopls.yml

@@ -1,56 +0,0 @@
-name: Gopls bugs or feature requests
-description: Issues or feature requests for the Go language server (gopls)
-title: "x/tools/gopls: issue title"
-labels: ["gopls", "Tools"]
-body:
-  - type: markdown
-    attributes:
-      value: "Please answer these questions before submitting your issue. Thanks!"
-  - type: textarea
-    id: gopls-version
-    attributes:
-      label: "gopls version"
-      description: "Output of `gopls -v version` on the command line"
-    validations:
-      required: true
-  - type: textarea
-    id: go-env
-    attributes:
-      label: "go env"
-      description: "Output of `go env` on the command line in your workspace directory"
-      render: shell
-    validations:
-      required: true
-  - type: textarea
-    id: what-did-you-do
-    attributes:
-      label: "What did you do?"
-      description: "If possible, provide a recipe for reproducing the error. A complete runnable program is good. A link on [go.dev/play](https://go.dev/play) is better. A failing unit test is the best."
-    validations:
-      required: true
-  - type: textarea
-    id: actual-behavior
-    attributes:
-      label: "What did you see happen?"
-    validations:
-      required: true
-  - type: textarea
-    id: expected-behavior
-    attributes:
-      label: "What did you expect to see?"
-    validations:
-      required: true
-  - type: textarea
-    id: editor-and-settings
-    attributes:
-      label: "Editor and settings"
-      description: "Your editor and any settings you have configured (for example, your VSCode settings.json file)"
-    validations:
-      required: false
-  - type: textarea
-    id: logs
-    attributes:
-      label: "Logs"
-      description: "If possible please include gopls logs. Instructions for capturing them can be found here: https://github.com/golang/tools/blob/master/gopls/doc/troubleshooting.md#capture-logs"
-    validations:
-      required: false

.github/ISSUE_TEMPLATE/04-vuln.yml

@@ -1,52 +0,0 @@
-name: Go vulnerability management - bugs and feature requests
-description: Issues or feature requests about Go vulnerability management
-title: "x/vuln: issue title"
-labels: ["vulncheck or vulndb"]
-body:
-  - type: markdown
-    attributes:
-      value: "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."
-  - type: textarea
-    id: govulncheck-version
-    attributes:
-      label: govulncheck version
-      description: What version of govulncheck are you using (`govulncheck -version`)?
-      placeholder: |
-        Go: devel go1.22-0262ea1ff9 Thu Oct 26 18:46:50 2023 +0000
-        Scanner: govulncheck@v1.0.2-0.20231108200754-fcf7dff7b242
-        DB: https://vuln.go.dev
-        DB updated: 2023-11-21 15:39:17 +0000 UTC
-    validations:
-      required: true
-  - type: textarea
-    id: reproduce-latest-version
-    attributes:
-      label: "Does this issue reproduce at the latest version of golang.org/x/vuln?"
-    validations:
-      required: true
-  - type: textarea
-    id: go-env
-    attributes:
-      label: "Output of `go env` in your module/workspace:"
-      render: shell
-    validations:
-      required: true
-  - type: textarea
-    id: what-did-you-do
-    attributes:
-      label: "What did you do?"
-      description: "If possible, provide a recipe for reproducing the error. A complete runnable program is good. A link on [go.dev/play](https://go.dev/play) is best."
-    validations:
-      required: true
-  - type: textarea
-    id: actual-behavior
-    attributes:
-      label: "What did you see happen?"
-    validations:
-      required: true
-  - type: textarea
-    id: expected-behavior
-    attributes:
-      label: "What did you expect to see?"
-    validations:
-      required: true

.github/ISSUE_TEMPLATE/10-proposal.yml

@@ -1,15 +0,0 @@
-name: Proposals
-description: New external API or other notable changes
-title: "proposal: import/path: proposal title"
-labels: ["Proposal"]
-body:
-  - type: markdown
-    attributes:
-      value: "Our proposal process is documented here: https://go.dev/s/proposal-process"
-  - type: textarea
-    id: proposal-details
-    attributes:
-      label: "Proposal Details"
-      description: "Please provide the details of your proposal here."
-    validations:
-      required: true

.github/ISSUE_TEMPLATE/11-language-change.yml

@@ -1,165 +0,0 @@
-name: Language Change Proposals
-description: Changes to the language
-labels: ["Proposal", "LanguageChange", "LanguageChangeReview"]
-title: "proposal: spec: proposal title"
-
-
-body:
-  - type: markdown
-    attributes:
-      value: |
-       ## Our process for evaluating language changes can be found [here](https://go.googlesource.com/proposal/+/refs/heads/master#language-changes)
-
-  - type: dropdown
-    id: author-go-experience
-    attributes:
-      label: "Go Programming Experience"
-      description: "Would you consider yourself a novice, intermediate, or experienced Go programmer?"
-      options:
-        - "Novice"
-        - "Intermediate"
-        - "Experienced"
-      default: 1
-
-  - type: input
-    id: author-other-languages-experience
-    attributes:
-      label: "Other Languages Experience"
-      description: "What other languages do you have experience with?"
-      placeholder: "Go, Python, JS, Rust"
-    validations:
-      required: false
-
-  - type: checkboxes
-    id: related-idea
-    attributes:
-      label: "Related Idea"
-      options:
-        - label: "Has this idea, or one like it, been proposed before?"
-        - label: "Does this affect error handling?"
-        - label: "Is this about generics?"
-        - label: "Is this change backward compatible? Breaking the Go 1 compatibility guarantee is a large cost and requires a large benefit"
-
-  - type: textarea
-    id: related-proposals
-    attributes:
-      label: Has this idea, or one like it, been proposed before?
-      description: If so, how does this proposal differ?
-      placeholder: |
-       Yes or No
-
-       If yes, 
-        1. Mention the related proposals 
-        2. then describe how this proposal differs       
-    validations:
-      required: true
-
-  - type: textarea
-    id: error-handling-proposal
-    attributes:
-      label: Does this affect error handling?
-      description: If so, how does this differ from previous error handling proposals?
-      placeholder: |
-       Yes or No
-
-       If yes, 
-        1.how does this differ from previous error handling proposals?
-
-    validations:
-      required: true
-
-  - type: textarea
-    id: generics-proposal
-    attributes:
-      label: Is this about generics?
-      description: If so, how does this relate to the accepted design and other generics proposals?
-      placeholder: |
-       Yes or No
-
-       If yes, 
-        1. how does this relate to the accepted design and other generics proposals?
-
-    validations:
-      required: true
-
-  - type: textarea
-    id: proposal
-    attributes:
-      label: "Proposal"
-      description: "What is the proposed change? Who does this proposal help, and why? Please describe as precisely as possible the change to the language."
-    validations:
-      required: true
-
-  - type: textarea
-    id: language-spec-changes
-    attributes:
-      label: "Language Spec Changes"
-      description: "What would change in the language spec?"
-    validations:
-      required: false
-
-  - type: textarea
-    id: informal-change
-    attributes:
-      label: "Informal Change"
-      description: "Please also describe the change informally, as in a class teaching Go."
-    validations:
-      required: false
-
-  - type: textarea
-    id: go-backwards-compatiblity
-    attributes:
-      label: Is this change backward compatible?
-      description: Breaking the Go 1 compatibility guarantee is a large cost and requires a large benefit.
-      placeholder: |
-       Yes or No
-
-       If yes, 
-        1. Show example code before and after the change.
-
-    validations:
-      required: true
-
-  - type: textarea
-    id: orthogonality
-    attributes:
-      label: "Orthogonality: How does this change interact or overlap with existing features?"
-      description: "Is the goal of this change a performance improvement? If so, what quantifiable improvement should we expect? How would we measure it?"
-    validations:
-      required: false
-
-  - type: textarea
-    id: learning-curve
-    attributes:
-      label: "Would this change make Go easier or harder to learn, and why?"
-
-  - type: textarea
-    id: cost-description
-    attributes:
-      label: "Cost Description"
-      description: "What is the cost of this proposal? (Every language change has a cost)"
-
-  - type: input
-    id: go-toolchain
-    attributes:
-      label: Changes to Go ToolChain
-      description: "How many tools (such as vet, gopls, gofmt, goimports, etc.) would be affected? "
-    validations:
-      required: false
-
-  - type: input
-    id: perf-costs
-    attributes:
-      label: Performance Costs
-      description: "What is the compile time cost? What is the run time cost? "
-    validations:
-      required: false
-
-  - type: textarea
-    id: prototype
-    attributes:
-      label: "Prototype"
-      description: "Can you describe a possible implementation?"
-    validations:
-      required: false
-

.github/ISSUE_TEMPLATE/12-telemetry.yml

@@ -1,30 +0,0 @@
-name: Go Telemetry Proposals
-description: Changes to the telemetry upload configuration
-title: "x/telemetry/config: proposal title"
-labels: ["Telemetry-Proposal"]
-projects: ["golang/29"]
-body:
-- type: textarea
-  attributes:
-    label: Summary
-    description: >
-      What change are you proposing to the upload configuration, and why?
-      For new upload configuration, which new counters will be collected, what
-      do they measure, and why is it important to collect them?
-      Note that uploaded data must not carry sensitive user information.
-      See [go.dev/doc/telemetry#proposals](https://go.dev/doc/telemetry#proposals)
-      for more details on telemetry proposals.
-  validations:
-    required: true
-- type: input
-  attributes:
-    label: Proposed Config Change
-    description: >
-      A CL containing proposed changes to the
-      [config.txt](https://go.googlesource.com/telemetry/+/master/internal/chartconfig/config.txt)
-      chart configuration.
-      See the [chartconfig](https://pkg.go.dev/golang.org/x/telemetry/internal/chartconfig)
-      package for an explanation of the chart config format.
-      For an example change, see [CL 564619](https://go.dev/cl/564619).
-  validations:
-    required: true

.github/ISSUE_TEMPLATE/config.yml

@@ -1,5 +0,0 @@
-blank_issues_enabled: true
-contact_links:
-  - name: Questions
-    about: Please use one of the forums for questions or general discussions
-    url:  https://go.dev/wiki/Questions

.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:
 
@@ -11,4 +11,4 @@ For asking questions, see:
 
 * [Stack Overflow](https://stackoverflow.com/questions/tagged/go) with questions tagged "go"
 
-* **IRC** channel #go-nuts on Libera
+* **IRC** channel #go-nuts on Freenode

.gitignore

@@ -30,17 +30,16 @@ _testmain.go
 /misc/cgo/testso/main
 /pkg/
 /src/*.*/
-/src/_artifacts/
 /src/cmd/cgo/zdefaultcc.go
 /src/cmd/dist/dist
 /src/cmd/go/internal/cfg/zdefaultcc.go
+/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/internal/runtime/sys/zversion.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
 

LICENSE

@@ -1,4 +1,4 @@
-Copyright 2009 The Go Authors.
+Copyright (c) 2009 The Go Authors. All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are
@@ -10,7 +10,7 @@ notice, this list of conditions and the following disclaimer.
 copyright notice, this list of conditions and the following disclaimer
 in the documentation and/or other materials provided with the
 distribution.
-   * Neither the name of Google LLC nor the names of its
+   * Neither the name of Google Inc. nor the names of its
 contributors may be used to endorse or promote products derived from
 this software without specific prior written permission.
 

README.boringcrypto.md

@@ -0,0 +1,20 @@
+# dev.boringcrypto branch
+
+We have been working inside Google on a fork of Go that uses
+BoringCrypto (the core of [BoringSSL][]) for various crypto
+primitives, in furtherance of some [work related to FIPS 140-2][sp].
+We have heard that some external users of Go would be interested in
+this code as well, so this branch holds the patches to make Go use
+BoringCrypto.
+
+[BoringSSL]: https://boringssl.googlesource.com/boringssl/
+[sp]: https://csrc.nist.gov/CSRC/media/projects/cryptographic-module-validation-program/documents/security-policies/140sp3678.pdf
+
+Unlike typical dev branches, we do not intend any eventual merge of
+this code into the master branch. Instead we intend to maintain in
+this branch the latest release plus BoringCrypto patches.
+
+To be clear, we are not making any statements or representations about
+the suitability of this code in relation to the FIPS 140-2 standard.
+Interested users will have to evaluate for themselves whether the code
+is useful for their own purposes.

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 Attribution 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.
@@ -16,27 +16,27 @@ BSD-style license found in the LICENSE file.
 
 #### Binary Distributions
 
-Official binary distributions are available at https://go.dev/dl/.
+Official binary distributions are available at https://golang.org/dl/.
 
-After downloading a binary release, visit https://go.dev/doc/install
+After downloading a binary release, visit https://golang.org/doc/install
 for installation instructions.
 
 #### Install From Source
 
 If a binary distribution is not available for your combination of
 operating system and architecture, visit
-https://go.dev/doc/install/source
+https://golang.org/doc/install/source
 for source installation instructions.
 
 ### Contributing
 
 Go is the work of thousands of contributors. We appreciate your help!
 
-To contribute, please read the contribution guidelines at https://go.dev/doc/contribute.
+To contribute, please read the contribution guidelines at https://golang.org/doc/contribute.html.
 
 Note that the Go project uses the issue tracker for bug reports and
-proposals only. See https://go.dev/wiki/Questions for a list of
+proposals only. See https://golang.org/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/

SECURITY.md

@@ -2,12 +2,12 @@
 
 ## Supported Versions
 
-We support the past two Go releases (for example, Go 1.17.x and Go 1.18.x when Go 1.18.x is the latest stable release).
+We support the past two Go releases (for example, Go 1.12.x and Go 1.13.x).
 
-See https://go.dev/wiki/Go-Release-Cycle and in particular the
-[Release Maintenance](https://go.dev/wiki/Go-Release-Cycle#release-maintenance)
+See https://golang.org/wiki/Go-Release-Cycle and in particular the
+[Release Maintenance](https://github.com/golang/go/wiki/Go-Release-Cycle#release-maintenance)
 part of that page.
 
 ## Reporting a Vulnerability
 
-See https://go.dev/security/policy for how to report a vulnerability.
+See https://golang.org/security for how to report a vulnerability.

api/README

@@ -8,19 +8,6 @@ shipped. Each file adds new lines but does not remove any.
 except.txt lists features that may disappear without breaking true
 compatibility.
 
-Starting with go1.19.txt, each API feature line must end in "#nnnnn"
-giving the GitHub issue number of the proposal issue that accepted
-the new API. This helps with our end-of-cycle audit of new APIs.
-The same requirement applies to next/* (described below), which will
-become a go1.XX.txt for XX >= 19.
-
-The next/ directory contains the only files intended to be mutated.
-Each file in that directory contains a list of features that may be added
-to the next release of Go. The files in this directory only affect the
-warning output from the go api tool. Each file should be named
-nnnnn.txt, after the issue number for the accepted proposal.
-(The #nnnnn suffix must also appear at the end of each line in the file;
-that will be preserved when next/*.txt is concatenated into go1.XX.txt.)
-
-When you add a file to the api/next directory, you must add at least one file
-under doc/next. See doc/README.md for details.
+next.txt is the only file intended to be mutated. It's a list of
+features that may be added to the next version. It only affects
+warning output from the go api tool.

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
@@ -494,7 +492,6 @@ pkg syscall (windows-amd64), type CertRevocationInfo struct, OidSpecificInfo uin
 pkg syscall (windows-amd64), type CertSimpleChain struct, TrustListInfo uintptr
 pkg syscall (windows-amd64), type RawSockaddrAny struct, Pad [96]int8
 pkg testing, func MainStart(func(string, string) (bool, error), []InternalTest, []InternalBenchmark, []InternalExample) *M
-pkg testing, func MainStart(testDeps, []InternalTest, []InternalBenchmark, []InternalExample) *M
 pkg testing, func RegisterCover(Cover)
 pkg text/scanner, const GoTokens = 1012
 pkg text/template/parse, type DotNode bool
@@ -502,103 +499,8 @@ 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"
 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
-pkg syscall (openbsd-386), const ELAST = 91
-pkg syscall (openbsd-386-cgo), const ELAST = 91
-pkg syscall (openbsd-amd64), const ELAST = 91
-pkg syscall (openbsd-amd64-cgo), const ELAST = 91

api/go1.1.txt

@@ -371,7 +371,7 @@ pkg debug/elf, const ELFCLASSNONE = 0
 pkg debug/elf, const ELFDATA2LSB = 1
 pkg debug/elf, const ELFDATA2MSB = 2
 pkg debug/elf, const ELFDATANONE = 0
-pkg debug/elf, const ELFMAG = "\x7fELF"
+pkg debug/elf, const ELFMAG = "\u007fELF"
 pkg debug/elf, const ELFOSABI_86OPEN = 5
 pkg debug/elf, const ELFOSABI_AIX = 7
 pkg debug/elf, const ELFOSABI_ARM = 97
@@ -2603,34 +2603,7 @@ pkg runtime/debug, type GCStats struct, Pause []time.Duration
 pkg runtime/debug, type GCStats struct, PauseQuantiles []time.Duration
 pkg runtime/debug, type GCStats struct, PauseTotal time.Duration
 pkg sort, func Reverse(Interface) Interface
-pkg strconv (darwin-amd64), const IntSize = 64
-pkg strconv (darwin-amd64-cgo), const IntSize = 64
-pkg strconv (freebsd-386), const IntSize = 32
-pkg strconv (freebsd-386-cgo), const IntSize = 32
-pkg strconv (freebsd-amd64), const IntSize = 64
-pkg strconv (freebsd-amd64-cgo), const IntSize = 64
-pkg strconv (freebsd-arm), const IntSize = 32
-pkg strconv (freebsd-arm-cgo), const IntSize = 32
-pkg strconv (linux-386), const IntSize = 32
-pkg strconv (linux-386-cgo), const IntSize = 32
-pkg strconv (linux-amd64), const IntSize = 64
-pkg strconv (linux-amd64-cgo), const IntSize = 64
-pkg strconv (linux-arm), const IntSize = 32
-pkg strconv (linux-arm-cgo), const IntSize = 32
-pkg strconv (netbsd-386), const IntSize = 32
-pkg strconv (netbsd-386-cgo), const IntSize = 32
-pkg strconv (netbsd-amd64), const IntSize = 64
-pkg strconv (netbsd-amd64-cgo), const IntSize = 64
-pkg strconv (netbsd-arm), const IntSize = 32
-pkg strconv (netbsd-arm-cgo), const IntSize = 32
-pkg strconv (netbsd-arm64), const IntSize = 64
-pkg strconv (netbsd-arm64-cgo), const IntSize = 64
-pkg strconv (openbsd-386), const IntSize = 32
-pkg strconv (openbsd-386-cgo), const IntSize = 32
-pkg strconv (openbsd-amd64), const IntSize = 64
-pkg strconv (openbsd-amd64-cgo), const IntSize = 64
-pkg strconv (windows-386), const IntSize = 32
-pkg strconv (windows-amd64), const IntSize = 64
+pkg strconv, const IntSize = 64
 pkg strings, func TrimPrefix(string, string) string
 pkg strings, func TrimSuffix(string, string) string
 pkg strings, method (*Reader) WriteTo(io.Writer) (int64, error)
@@ -49393,7 +49366,7 @@ pkg syscall (windows-386), const IP_MULTICAST_TTL = 10
 pkg syscall (windows-386), const IP_TOS = 3
 pkg syscall (windows-386), const IP_TTL = 4
 pkg syscall (windows-386), const ImplementsGetwd = true
-pkg syscall (windows-386), const InvalidHandle = 4294967295
+pkg syscall (windows-386), const InvalidHandle = 18446744073709551615
 pkg syscall (windows-386), const KEY_ALL_ACCESS = 983103
 pkg syscall (windows-386), const KEY_CREATE_LINK = 32
 pkg syscall (windows-386), const KEY_CREATE_SUB_KEY = 4

api/go1.17.txt

@@ -63,105 +63,12 @@ pkg image/draw, type RGBA64Image interface, RGBA64At(int, int) color.RGBA64
 pkg image/draw, type RGBA64Image interface, Set(int, int, color.Color)
 pkg image/draw, type RGBA64Image interface, SetRGBA64(int, int, color.RGBA64)
 pkg io/fs, func FileInfoToDirEntry(FileInfo) DirEntry
-pkg math (darwin-amd64), const MaxInt = 9223372036854775807
-pkg math (darwin-amd64), const MaxUint = 18446744073709551615
-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
-pkg math (freebsd-386-cgo), const MaxInt = 2147483647
-pkg math (freebsd-386-cgo), const MaxUint = 4294967295
-pkg math (freebsd-386-cgo), const MinInt = -2147483648
-pkg math (freebsd-amd64), const MaxInt = 9223372036854775807
-pkg math (freebsd-amd64), const MaxUint = 18446744073709551615
-pkg math (freebsd-amd64), const MinInt = -9223372036854775808
-pkg math (freebsd-amd64-cgo), const MaxInt = 9223372036854775807
-pkg math (freebsd-amd64-cgo), const MaxUint = 18446744073709551615
-pkg math (freebsd-amd64-cgo), const MinInt = -9223372036854775808
-pkg math (freebsd-arm), const MaxInt = 2147483647
-pkg math (freebsd-arm), const MaxUint = 4294967295
-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
-pkg math (linux-386-cgo), const MaxInt = 2147483647
-pkg math (linux-386-cgo), const MaxUint = 4294967295
-pkg math (linux-386-cgo), const MinInt = -2147483648
-pkg math (linux-amd64), const MaxInt = 9223372036854775807
-pkg math (linux-amd64), const MaxUint = 18446744073709551615
-pkg math (linux-amd64), const MinInt = -9223372036854775808
-pkg math (linux-amd64-cgo), const MaxInt = 9223372036854775807
-pkg math (linux-amd64-cgo), const MaxUint = 18446744073709551615
-pkg math (linux-amd64-cgo), const MinInt = -9223372036854775808
-pkg math (linux-arm), const MaxInt = 2147483647
-pkg math (linux-arm), const MaxUint = 4294967295
-pkg math (linux-arm), const MinInt = -2147483648
-pkg math (linux-arm-cgo), const MaxInt = 2147483647
-pkg math (linux-arm-cgo), const MaxUint = 4294967295
-pkg math (linux-arm-cgo), const MinInt = -2147483648
-pkg math (netbsd-386), const MaxInt = 2147483647
-pkg math (netbsd-386), const MaxUint = 4294967295
-pkg math (netbsd-386), const MinInt = -2147483648
-pkg math (netbsd-386-cgo), const MaxInt = 2147483647
-pkg math (netbsd-386-cgo), const MaxUint = 4294967295
-pkg math (netbsd-386-cgo), const MinInt = -2147483648
-pkg math (netbsd-amd64), const MaxInt = 9223372036854775807
-pkg math (netbsd-amd64), const MaxUint = 18446744073709551615
-pkg math (netbsd-amd64), const MinInt = -9223372036854775808
-pkg math (netbsd-amd64-cgo), const MaxInt = 9223372036854775807
-pkg math (netbsd-amd64-cgo), const MaxUint = 18446744073709551615
-pkg math (netbsd-amd64-cgo), const MinInt = -9223372036854775808
-pkg math (netbsd-arm), const MaxInt = 2147483647
-pkg math (netbsd-arm), const MaxUint = 4294967295
-pkg math (netbsd-arm), const MinInt = -2147483648
-pkg math (netbsd-arm-cgo), const MaxInt = 2147483647
-pkg math (netbsd-arm-cgo), const MaxUint = 4294967295
-pkg math (netbsd-arm-cgo), const MinInt = -2147483648
-pkg math (netbsd-arm64), const MaxInt = 9223372036854775807
-pkg math (netbsd-arm64), const MaxUint = 18446744073709551615
-pkg math (netbsd-arm64), const MinInt = -9223372036854775808
-pkg math (netbsd-arm64-cgo), const MaxInt = 9223372036854775807
-pkg math (netbsd-arm64-cgo), const MaxUint = 18446744073709551615
-pkg math (netbsd-arm64-cgo), const MinInt = -9223372036854775808
-pkg math (openbsd-386), const MaxInt = 2147483647
-pkg math (openbsd-386), const MaxUint = 4294967295
-pkg math (openbsd-386), const MinInt = -2147483648
-pkg math (openbsd-386-cgo), const MaxInt = 2147483647
-pkg math (openbsd-386-cgo), const MaxUint = 4294967295
-pkg math (openbsd-386-cgo), const MinInt = -2147483648
-pkg math (openbsd-amd64), const MaxInt = 9223372036854775807
-pkg math (openbsd-amd64), const MaxUint = 18446744073709551615
-pkg math (openbsd-amd64), const MinInt = -9223372036854775808
-pkg math (openbsd-amd64-cgo), const MaxInt = 9223372036854775807
-pkg math (openbsd-amd64-cgo), const MaxUint = 18446744073709551615
-pkg math (openbsd-amd64-cgo), const MinInt = -9223372036854775808
-pkg math (windows-386), const MaxInt = 2147483647
-pkg math (windows-386), const MaxUint = 4294967295
-pkg math (windows-386), const MinInt = -2147483648
-pkg math (windows-amd64), const MaxInt = 9223372036854775807
-pkg math (windows-amd64), const MaxUint = 18446744073709551615
-pkg math (windows-amd64), const MinInt = -9223372036854775808
 pkg math, const MaxFloat64 = 1.79769e+308  // 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878171540458953514382464234321326889464182768467546703537516986049910576551282076245490090389328944075868508455133942304583236903222948165808559332123348274797826204144723168738177180919299881250404026184124858368
+pkg math, const MaxInt = 9223372036854775807
 pkg math, const MaxInt ideal-int
+pkg math, const MaxUint = 18446744073709551615
 pkg math, const MaxUint ideal-int
+pkg math, const MinInt = -9223372036854775808
 pkg math, const MinInt ideal-int
 pkg math, const SmallestNonzeroFloat32 = 1.4013e-45  // 1/713623846352979940529142984724747568191373312
 pkg math, const SmallestNonzeroFloat64 = 4.94066e-324  // 1/202402253307310618352495346718917307049556649764142118356901358027430339567995346891960383701437124495187077864316811911389808737385793476867013399940738509921517424276566361364466907742093216341239767678472745068562007483424692698618103355649159556340810056512358769552333414615230502532186327508646006263307707741093494784
@@ -174,15 +81,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 +97,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 +176,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,253 +0,0 @@
-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/plan9obj, var ErrNoSymbols error
-pkg go/ast, method (*IndexListExpr) End() token.Pos
-pkg go/ast, method (*IndexListExpr) Pos() token.Pos
-pkg go/ast, type FuncType struct, TypeParams *FieldList
-pkg go/ast, type IndexListExpr struct
-pkg go/ast, type IndexListExpr struct, Indices []Expr
-pkg go/ast, type IndexListExpr struct, Lbrack token.Pos
-pkg go/ast, type IndexListExpr struct, Rbrack token.Pos
-pkg go/ast, type IndexListExpr struct, X Expr
-pkg go/ast, type TypeSpec struct, TypeParams *FieldList
-pkg go/constant, method (Kind) String() string
-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
-pkg go/types, func NewUnion([]*Term) *Union
-pkg go/types, method (*ArgumentError) Error() string
-pkg go/types, method (*ArgumentError) Unwrap() error
-pkg go/types, method (*Interface) IsComparable() bool
-pkg go/types, method (*Interface) IsImplicit() bool
-pkg go/types, method (*Interface) IsMethodSet() bool
-pkg go/types, method (*Interface) MarkImplicit()
-pkg go/types, method (*Named) Origin() *Named
-pkg go/types, method (*Named) SetTypeParams([]*TypeParam)
-pkg go/types, method (*Named) TypeArgs() *TypeList
-pkg go/types, method (*Named) TypeParams() *TypeParamList
-pkg go/types, method (*Signature) RecvTypeParams() *TypeParamList
-pkg go/types, method (*Signature) TypeParams() *TypeParamList
-pkg go/types, method (*Term) String() string
-pkg go/types, method (*Term) Tilde() bool
-pkg go/types, method (*Term) Type() Type
-pkg go/types, method (*TypeList) At(int) Type
-pkg go/types, method (*TypeList) Len() int
-pkg go/types, method (*TypeParam) Constraint() Type
-pkg go/types, method (*TypeParam) Index() int
-pkg go/types, method (*TypeParam) Obj() *TypeName
-pkg go/types, method (*TypeParam) SetConstraint(Type)
-pkg go/types, method (*TypeParam) String() string
-pkg go/types, method (*TypeParam) Underlying() Type
-pkg go/types, method (*TypeParamList) At(int) *TypeParam
-pkg go/types, method (*TypeParamList) Len() int
-pkg go/types, method (*Union) Len() int
-pkg go/types, method (*Union) String() string
-pkg go/types, method (*Union) Term(int) *Term
-pkg go/types, method (*Union) Underlying() Type
-pkg go/types, type ArgumentError struct
-pkg go/types, type ArgumentError struct, Err error
-pkg go/types, type ArgumentError struct, Index int
-pkg go/types, type Config struct, Context *Context
-pkg go/types, type Config struct, GoVersion string
-pkg go/types, type Context struct
-pkg go/types, type Info struct, Instances map[*ast.Ident]Instance
-pkg go/types, type Instance struct
-pkg go/types, type Instance struct, Type Type
-pkg go/types, type Instance struct, TypeArgs *TypeList
-pkg go/types, type Term struct
-pkg go/types, type TypeList struct
-pkg go/types, type TypeParam struct
-pkg go/types, type TypeParamList struct
-pkg go/types, type Union struct
-pkg net, func TCPAddrFromAddrPort(netip.AddrPort) *TCPAddr
-pkg net, func UDPAddrFromAddrPort(netip.AddrPort) *UDPAddr
-pkg net, method (*Resolver) LookupNetIP(context.Context, string, string) ([]netip.Addr, error)
-pkg net, method (*TCPAddr) AddrPort() netip.AddrPort
-pkg net, method (*UDPAddr) AddrPort() netip.AddrPort
-pkg net, method (*UDPConn) ReadFromUDPAddrPort([]uint8) (int, netip.AddrPort, error)
-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
-pkg net/netip, func AddrFrom4([4]uint8) Addr
-pkg net/netip, func AddrFromSlice([]uint8) (Addr, bool)
-pkg net/netip, func AddrPortFrom(Addr, uint16) AddrPort
-pkg net/netip, func IPv4Unspecified() Addr
-pkg net/netip, func IPv6LinkLocalAllNodes() Addr
-pkg net/netip, func IPv6Unspecified() Addr
-pkg net/netip, func MustParseAddr(string) Addr
-pkg net/netip, func MustParseAddrPort(string) AddrPort
-pkg net/netip, func MustParsePrefix(string) Prefix
-pkg net/netip, func ParseAddr(string) (Addr, error)
-pkg net/netip, func ParseAddrPort(string) (AddrPort, error)
-pkg net/netip, func ParsePrefix(string) (Prefix, error)
-pkg net/netip, func PrefixFrom(Addr, int) Prefix
-pkg net/netip, method (*Addr) UnmarshalBinary([]uint8) error
-pkg net/netip, method (*Addr) UnmarshalText([]uint8) error
-pkg net/netip, method (*AddrPort) UnmarshalBinary([]uint8) error
-pkg net/netip, method (*AddrPort) UnmarshalText([]uint8) error
-pkg net/netip, method (*Prefix) UnmarshalBinary([]uint8) error
-pkg net/netip, method (*Prefix) UnmarshalText([]uint8) error
-pkg net/netip, method (Addr) AppendTo([]uint8) []uint8
-pkg net/netip, method (Addr) As16() [16]uint8
-pkg net/netip, method (Addr) As4() [4]uint8
-pkg net/netip, method (Addr) AsSlice() []uint8
-pkg net/netip, method (Addr) BitLen() int
-pkg net/netip, method (Addr) Compare(Addr) int
-pkg net/netip, method (Addr) Is4() bool
-pkg net/netip, method (Addr) Is4In6() bool
-pkg net/netip, method (Addr) Is6() bool
-pkg net/netip, method (Addr) IsGlobalUnicast() bool
-pkg net/netip, method (Addr) IsInterfaceLocalMulticast() bool
-pkg net/netip, method (Addr) IsLinkLocalMulticast() bool
-pkg net/netip, method (Addr) IsLinkLocalUnicast() bool
-pkg net/netip, method (Addr) IsLoopback() bool
-pkg net/netip, method (Addr) IsMulticast() bool
-pkg net/netip, method (Addr) IsPrivate() bool
-pkg net/netip, method (Addr) IsUnspecified() bool
-pkg net/netip, method (Addr) IsValid() bool
-pkg net/netip, method (Addr) Less(Addr) bool
-pkg net/netip, method (Addr) MarshalBinary() ([]uint8, error)
-pkg net/netip, method (Addr) MarshalText() ([]uint8, error)
-pkg net/netip, method (Addr) Next() Addr
-pkg net/netip, method (Addr) Prefix(int) (Prefix, error)
-pkg net/netip, method (Addr) Prev() Addr
-pkg net/netip, method (Addr) String() string
-pkg net/netip, method (Addr) StringExpanded() string
-pkg net/netip, method (Addr) Unmap() Addr
-pkg net/netip, method (Addr) WithZone(string) Addr
-pkg net/netip, method (Addr) Zone() string
-pkg net/netip, method (AddrPort) Addr() Addr
-pkg net/netip, method (AddrPort) AppendTo([]uint8) []uint8
-pkg net/netip, method (AddrPort) IsValid() bool
-pkg net/netip, method (AddrPort) MarshalBinary() ([]uint8, error)
-pkg net/netip, method (AddrPort) MarshalText() ([]uint8, error)
-pkg net/netip, method (AddrPort) Port() uint16
-pkg net/netip, method (AddrPort) String() string
-pkg net/netip, method (Prefix) Addr() Addr
-pkg net/netip, method (Prefix) AppendTo([]uint8) []uint8
-pkg net/netip, method (Prefix) Bits() int
-pkg net/netip, method (Prefix) Contains(Addr) bool
-pkg net/netip, method (Prefix) IsSingleIP() bool
-pkg net/netip, method (Prefix) IsValid() bool
-pkg net/netip, method (Prefix) MarshalBinary() ([]uint8, error)
-pkg net/netip, method (Prefix) MarshalText() ([]uint8, error)
-pkg net/netip, method (Prefix) Masked() Prefix
-pkg net/netip, method (Prefix) Overlaps(Prefix) bool
-pkg net/netip, method (Prefix) String() string
-pkg net/netip, type Addr struct
-pkg net/netip, type AddrPort struct
-pkg net/netip, type Prefix struct
-pkg reflect, const Pointer = 22
-pkg reflect, const Pointer Kind
-pkg reflect, func PointerTo(Type) Type
-pkg reflect, method (*MapIter) Reset(Value)
-pkg reflect, method (Value) CanComplex() bool
-pkg reflect, method (Value) CanFloat() bool
-pkg reflect, method (Value) CanInt() bool
-pkg reflect, method (Value) CanUint() bool
-pkg reflect, method (Value) FieldByIndexErr([]int) (Value, error)
-pkg reflect, method (Value) SetIterKey(*MapIter)
-pkg reflect, method (Value) SetIterValue(*MapIter)
-pkg reflect, method (Value) UnsafePointer() unsafe.Pointer
-pkg runtime/debug, func ParseBuildInfo(string) (*BuildInfo, error)
-pkg runtime/debug, method (*BuildInfo) String() string
-pkg runtime/debug, type BuildInfo struct, GoVersion string
-pkg runtime/debug, type BuildInfo struct, Settings []BuildSetting
-pkg runtime/debug, type BuildSetting struct
-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
-pkg syscall (freebsd-386), type SysProcAttr struct, Pdeathsig Signal
-pkg syscall (freebsd-386-cgo), type SysProcAttr struct, Pdeathsig Signal
-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{})
-pkg testing, method (*F) Cleanup(func())
-pkg testing, method (*F) Error(...interface{})
-pkg testing, method (*F) Errorf(string, ...interface{})
-pkg testing, method (*F) Fail()
-pkg testing, method (*F) FailNow()
-pkg testing, method (*F) Failed() bool
-pkg testing, method (*F) Fatal(...interface{})
-pkg testing, method (*F) Fatalf(string, ...interface{})
-pkg testing, method (*F) Fuzz(interface{})
-pkg testing, method (*F) Helper()
-pkg testing, method (*F) Log(...interface{})
-pkg testing, method (*F) Logf(string, ...interface{})
-pkg testing, method (*F) Name() string
-pkg testing, method (*F) Setenv(string, string)
-pkg testing, method (*F) Skip(...interface{})
-pkg testing, method (*F) SkipNow()
-pkg testing, method (*F) Skipf(string, ...interface{})
-pkg testing, method (*F) Skipped() bool
-pkg testing, method (*F) TempDir() string
-pkg testing, type F struct
-pkg testing, type InternalFuzzTarget struct
-pkg testing, type InternalFuzzTarget struct, Fn func(*F)
-pkg testing, type InternalFuzzTarget struct, Name string
-pkg text/template/parse, const NodeBreak = 21
-pkg text/template/parse, const NodeBreak NodeType
-pkg text/template/parse, const NodeContinue = 22
-pkg text/template/parse, const NodeContinue NodeType
-pkg text/template/parse, method (*BreakNode) Copy() Node
-pkg text/template/parse, method (*BreakNode) String() string
-pkg text/template/parse, method (*ContinueNode) Copy() Node
-pkg text/template/parse, method (*ContinueNode) String() string
-pkg text/template/parse, method (BreakNode) Position() Pos
-pkg text/template/parse, method (BreakNode) Type() NodeType
-pkg text/template/parse, method (ContinueNode) Position() Pos
-pkg text/template/parse, method (ContinueNode) Type() NodeType
-pkg text/template/parse, type BreakNode struct
-pkg text/template/parse, type BreakNode struct, Line int
-pkg text/template/parse, type BreakNode struct, embedded NodeType
-pkg text/template/parse, type BreakNode struct, embedded Pos
-pkg text/template/parse, type ContinueNode struct
-pkg text/template/parse, type ContinueNode struct, Line int
-pkg text/template/parse, type ContinueNode struct, embedded NodeType
-pkg text/template/parse, type ContinueNode struct, embedded Pos
-pkg unicode/utf8, func AppendRune([]uint8, int32) []uint8

api/go1.19.txt

@@ -1,309 +0,0 @@
-pkg crypto/x509, func ParseRevocationList([]uint8) (*RevocationList, error) #50674
-pkg crypto/x509, method (*CertPool) Clone() *CertPool #35044
-pkg crypto/x509, method (*CertPool) Equal(*CertPool) bool #46057
-pkg crypto/x509, method (*RevocationList) CheckSignatureFrom(*Certificate) error #50674
-pkg crypto/x509, type RevocationList struct, AuthorityKeyId []uint8 #50674
-pkg crypto/x509, type RevocationList struct, Extensions []pkix.Extension #50674
-pkg crypto/x509, type RevocationList struct, Issuer pkix.Name #50674
-pkg crypto/x509, type RevocationList struct, Raw []uint8 #50674
-pkg crypto/x509, type RevocationList struct, RawIssuer []uint8 #50674
-pkg crypto/x509, type RevocationList struct, RawTBSRevocationList []uint8 #50674
-pkg crypto/x509, type RevocationList struct, Signature []uint8 #50674
-pkg debug/elf, const EM_LOONGARCH = 258 #46229
-pkg debug/elf, const EM_LOONGARCH Machine #46229
-pkg debug/elf, const R_LARCH_32 = 1 #46229
-pkg debug/elf, const R_LARCH_32 R_LARCH #46229
-pkg debug/elf, const R_LARCH_64 = 2 #46229
-pkg debug/elf, const R_LARCH_64 R_LARCH #46229
-pkg debug/elf, const R_LARCH_ADD16 = 48 #46229
-pkg debug/elf, const R_LARCH_ADD16 R_LARCH #46229
-pkg debug/elf, const R_LARCH_ADD24 = 49 #46229
-pkg debug/elf, const R_LARCH_ADD24 R_LARCH #46229
-pkg debug/elf, const R_LARCH_ADD32 = 50 #46229
-pkg debug/elf, const R_LARCH_ADD32 R_LARCH #46229
-pkg debug/elf, const R_LARCH_ADD64 = 51 #46229
-pkg debug/elf, const R_LARCH_ADD64 R_LARCH #46229
-pkg debug/elf, const R_LARCH_ADD8 = 47 #46229
-pkg debug/elf, const R_LARCH_ADD8 R_LARCH #46229
-pkg debug/elf, const R_LARCH_COPY = 4 #46229
-pkg debug/elf, const R_LARCH_COPY R_LARCH #46229
-pkg debug/elf, const R_LARCH_IRELATIVE = 12 #46229
-pkg debug/elf, const R_LARCH_IRELATIVE R_LARCH #46229
-pkg debug/elf, const R_LARCH_JUMP_SLOT = 5 #46229
-pkg debug/elf, const R_LARCH_JUMP_SLOT R_LARCH #46229
-pkg debug/elf, const R_LARCH_MARK_LA = 20 #46229
-pkg debug/elf, const R_LARCH_MARK_LA R_LARCH #46229
-pkg debug/elf, const R_LARCH_MARK_PCREL = 21 #46229
-pkg debug/elf, const R_LARCH_MARK_PCREL R_LARCH #46229
-pkg debug/elf, const R_LARCH_NONE = 0 #46229
-pkg debug/elf, const R_LARCH_NONE R_LARCH #46229
-pkg debug/elf, const R_LARCH_RELATIVE = 3 #46229
-pkg debug/elf, const R_LARCH_RELATIVE R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_ADD = 35 #46229
-pkg debug/elf, const R_LARCH_SOP_ADD R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_AND = 36 #46229
-pkg debug/elf, const R_LARCH_SOP_AND R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_ASSERT = 30 #46229
-pkg debug/elf, const R_LARCH_SOP_ASSERT R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_IF_ELSE = 37 #46229
-pkg debug/elf, const R_LARCH_SOP_IF_ELSE R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_NOT = 31 #46229
-pkg debug/elf, const R_LARCH_SOP_NOT R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_POP_32_S_0_10_10_16_S2 = 45 #46229
-pkg debug/elf, const R_LARCH_SOP_POP_32_S_0_10_10_16_S2 R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_POP_32_S_0_5_10_16_S2 = 44 #46229
-pkg debug/elf, const R_LARCH_SOP_POP_32_S_0_5_10_16_S2 R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_POP_32_S_10_12 = 40 #46229
-pkg debug/elf, const R_LARCH_SOP_POP_32_S_10_12 R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_POP_32_S_10_16 = 41 #46229
-pkg debug/elf, const R_LARCH_SOP_POP_32_S_10_16 R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_POP_32_S_10_16_S2 = 42 #46229
-pkg debug/elf, const R_LARCH_SOP_POP_32_S_10_16_S2 R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_POP_32_S_10_5 = 38 #46229
-pkg debug/elf, const R_LARCH_SOP_POP_32_S_10_5 R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_POP_32_S_5_20 = 43 #46229
-pkg debug/elf, const R_LARCH_SOP_POP_32_S_5_20 R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_POP_32_U = 46 #46229
-pkg debug/elf, const R_LARCH_SOP_POP_32_U R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_POP_32_U_10_12 = 39 #46229
-pkg debug/elf, const R_LARCH_SOP_POP_32_U_10_12 R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_PUSH_ABSOLUTE = 23 #46229
-pkg debug/elf, const R_LARCH_SOP_PUSH_ABSOLUTE R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_PUSH_DUP = 24 #46229
-pkg debug/elf, const R_LARCH_SOP_PUSH_DUP R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_PUSH_GPREL = 25 #46229
-pkg debug/elf, const R_LARCH_SOP_PUSH_GPREL R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_PUSH_PCREL = 22 #46229
-pkg debug/elf, const R_LARCH_SOP_PUSH_PCREL R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_PUSH_PLT_PCREL = 29 #46229
-pkg debug/elf, const R_LARCH_SOP_PUSH_PLT_PCREL R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_PUSH_TLS_GD = 28 #46229
-pkg debug/elf, const R_LARCH_SOP_PUSH_TLS_GD R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_PUSH_TLS_GOT = 27 #46229
-pkg debug/elf, const R_LARCH_SOP_PUSH_TLS_GOT R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_PUSH_TLS_TPREL = 26 #46229
-pkg debug/elf, const R_LARCH_SOP_PUSH_TLS_TPREL R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_SL = 33 #46229
-pkg debug/elf, const R_LARCH_SOP_SL R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_SR = 34 #46229
-pkg debug/elf, const R_LARCH_SOP_SR R_LARCH #46229
-pkg debug/elf, const R_LARCH_SOP_SUB = 32 #46229
-pkg debug/elf, const R_LARCH_SOP_SUB R_LARCH #46229
-pkg debug/elf, const R_LARCH_SUB16 = 53 #46229
-pkg debug/elf, const R_LARCH_SUB16 R_LARCH #46229
-pkg debug/elf, const R_LARCH_SUB24 = 54 #46229
-pkg debug/elf, const R_LARCH_SUB24 R_LARCH #46229
-pkg debug/elf, const R_LARCH_SUB32 = 55 #46229
-pkg debug/elf, const R_LARCH_SUB32 R_LARCH #46229
-pkg debug/elf, const R_LARCH_SUB64 = 56 #46229
-pkg debug/elf, const R_LARCH_SUB64 R_LARCH #46229
-pkg debug/elf, const R_LARCH_SUB8 = 52 #46229
-pkg debug/elf, const R_LARCH_SUB8 R_LARCH #46229
-pkg debug/elf, const R_LARCH_TLS_DTPMOD32 = 6 #46229
-pkg debug/elf, const R_LARCH_TLS_DTPMOD32 R_LARCH #46229
-pkg debug/elf, const R_LARCH_TLS_DTPMOD64 = 7 #46229
-pkg debug/elf, const R_LARCH_TLS_DTPMOD64 R_LARCH #46229
-pkg debug/elf, const R_LARCH_TLS_DTPREL32 = 8 #46229
-pkg debug/elf, const R_LARCH_TLS_DTPREL32 R_LARCH #46229
-pkg debug/elf, const R_LARCH_TLS_DTPREL64 = 9 #46229
-pkg debug/elf, const R_LARCH_TLS_DTPREL64 R_LARCH #46229
-pkg debug/elf, const R_LARCH_TLS_TPREL32 = 10 #46229
-pkg debug/elf, const R_LARCH_TLS_TPREL32 R_LARCH #46229
-pkg debug/elf, const R_LARCH_TLS_TPREL64 = 11 #46229
-pkg debug/elf, const R_LARCH_TLS_TPREL64 R_LARCH #46229
-pkg debug/elf, method (R_LARCH) GoString() string #46229
-pkg debug/elf, method (R_LARCH) String() string #46229
-pkg debug/elf, type R_LARCH int #46229
-pkg debug/pe, const IMAGE_COMDAT_SELECT_ANY = 2 #51868
-pkg debug/pe, const IMAGE_COMDAT_SELECT_ANY ideal-int #51868
-pkg debug/pe, const IMAGE_COMDAT_SELECT_ASSOCIATIVE = 5 #51868
-pkg debug/pe, const IMAGE_COMDAT_SELECT_ASSOCIATIVE ideal-int #51868
-pkg debug/pe, const IMAGE_COMDAT_SELECT_EXACT_MATCH = 4 #51868
-pkg debug/pe, const IMAGE_COMDAT_SELECT_EXACT_MATCH ideal-int #51868
-pkg debug/pe, const IMAGE_COMDAT_SELECT_LARGEST = 6 #51868
-pkg debug/pe, const IMAGE_COMDAT_SELECT_LARGEST ideal-int #51868
-pkg debug/pe, const IMAGE_COMDAT_SELECT_NODUPLICATES = 1 #51868
-pkg debug/pe, const IMAGE_COMDAT_SELECT_NODUPLICATES ideal-int #51868
-pkg debug/pe, const IMAGE_COMDAT_SELECT_SAME_SIZE = 3 #51868
-pkg debug/pe, const IMAGE_COMDAT_SELECT_SAME_SIZE ideal-int #51868
-pkg debug/pe, const IMAGE_FILE_MACHINE_LOONGARCH32 = 25138 #46229
-pkg debug/pe, const IMAGE_FILE_MACHINE_LOONGARCH32 ideal-int #46229
-pkg debug/pe, const IMAGE_FILE_MACHINE_LOONGARCH64 = 25188 #46229
-pkg debug/pe, const IMAGE_FILE_MACHINE_LOONGARCH64 ideal-int #46229
-pkg debug/pe, const IMAGE_SCN_CNT_CODE = 32 #51868
-pkg debug/pe, const IMAGE_SCN_CNT_CODE ideal-int #51868
-pkg debug/pe, const IMAGE_SCN_CNT_INITIALIZED_DATA = 64 #51868
-pkg debug/pe, const IMAGE_SCN_CNT_INITIALIZED_DATA ideal-int #51868
-pkg debug/pe, const IMAGE_SCN_CNT_UNINITIALIZED_DATA = 128 #51868
-pkg debug/pe, const IMAGE_SCN_CNT_UNINITIALIZED_DATA ideal-int #51868
-pkg debug/pe, const IMAGE_SCN_LNK_COMDAT = 4096 #51868
-pkg debug/pe, const IMAGE_SCN_LNK_COMDAT ideal-int #51868
-pkg debug/pe, const IMAGE_SCN_MEM_DISCARDABLE = 33554432 #51868
-pkg debug/pe, const IMAGE_SCN_MEM_DISCARDABLE ideal-int #51868
-pkg debug/pe, const IMAGE_SCN_MEM_EXECUTE = 536870912 #51868
-pkg debug/pe, const IMAGE_SCN_MEM_EXECUTE ideal-int #51868
-pkg debug/pe, const IMAGE_SCN_MEM_READ = 1073741824 #51868
-pkg debug/pe, const IMAGE_SCN_MEM_READ ideal-int #51868
-pkg debug/pe, const IMAGE_SCN_MEM_WRITE = 2147483648 #51868
-pkg debug/pe, const IMAGE_SCN_MEM_WRITE ideal-int #51868
-pkg debug/pe, method (*File) COFFSymbolReadSectionDefAux(int) (*COFFSymbolAuxFormat5, error) #51868
-pkg debug/pe, type COFFSymbolAuxFormat5 struct #51868
-pkg debug/pe, type COFFSymbolAuxFormat5 struct, Checksum uint32 #51868
-pkg debug/pe, type COFFSymbolAuxFormat5 struct, NumLineNumbers uint16 #51868
-pkg debug/pe, type COFFSymbolAuxFormat5 struct, NumRelocs uint16 #51868
-pkg debug/pe, type COFFSymbolAuxFormat5 struct, SecNum uint16 #51868
-pkg debug/pe, type COFFSymbolAuxFormat5 struct, Selection uint8 #51868
-pkg debug/pe, type COFFSymbolAuxFormat5 struct, Size uint32 #51868
-pkg encoding/binary, func AppendUvarint([]uint8, uint64) []uint8 #51644
-pkg encoding/binary, func AppendVarint([]uint8, int64) []uint8 #51644
-pkg encoding/binary, type AppendByteOrder interface { AppendUint16, AppendUint32, AppendUint64, String } #50601
-pkg encoding/binary, type AppendByteOrder interface, AppendUint16([]uint8, uint16) []uint8 #50601
-pkg encoding/binary, type AppendByteOrder interface, AppendUint32([]uint8, uint32) []uint8 #50601
-pkg encoding/binary, type AppendByteOrder interface, AppendUint64([]uint8, uint64) []uint8 #50601
-pkg encoding/binary, type AppendByteOrder interface, String() string #50601
-pkg encoding/csv, method (*Reader) InputOffset() int64 #43401
-pkg encoding/xml, method (*Decoder) InputPos() (int, int) #45628
-pkg flag, func TextVar(encoding.TextUnmarshaler, string, encoding.TextMarshaler, string) #45754
-pkg flag, method (*FlagSet) TextVar(encoding.TextUnmarshaler, string, encoding.TextMarshaler, string) #45754
-pkg fmt, func Append([]uint8, ...interface{}) []uint8 #47579
-pkg fmt, func Appendf([]uint8, string, ...interface{}) []uint8 #47579
-pkg fmt, func Appendln([]uint8, ...interface{}) []uint8 #47579
-pkg go/doc, method (*Package) HTML(string) []uint8 #51082
-pkg go/doc, method (*Package) Markdown(string) []uint8 #51082
-pkg go/doc, method (*Package) Parser() *comment.Parser #51082
-pkg go/doc, method (*Package) Printer() *comment.Printer #51082
-pkg go/doc, method (*Package) Synopsis(string) string #51082
-pkg go/doc, method (*Package) Text(string) []uint8 #51082
-pkg go/doc/comment, func DefaultLookupPackage(string) (string, bool) #51082
-pkg go/doc/comment, method (*DocLink) DefaultURL(string) string #51082
-pkg go/doc/comment, method (*Heading) DefaultID() string #51082
-pkg go/doc/comment, method (*List) BlankBefore() bool #51082
-pkg go/doc/comment, method (*List) BlankBetween() bool #51082
-pkg go/doc/comment, method (*Parser) Parse(string) *Doc #51082
-pkg go/doc/comment, method (*Printer) Comment(*Doc) []uint8 #51082
-pkg go/doc/comment, method (*Printer) HTML(*Doc) []uint8 #51082
-pkg go/doc/comment, method (*Printer) Markdown(*Doc) []uint8 #51082
-pkg go/doc/comment, method (*Printer) Text(*Doc) []uint8 #51082
-pkg go/doc/comment, type Block interface, unexported methods #51082
-pkg go/doc/comment, type Code struct #51082
-pkg go/doc/comment, type Code struct, Text string #51082
-pkg go/doc/comment, type Doc struct #51082
-pkg go/doc/comment, type Doc struct, Content []Block #51082
-pkg go/doc/comment, type Doc struct, Links []*LinkDef #51082
-pkg go/doc/comment, type DocLink struct #51082
-pkg go/doc/comment, type DocLink struct, ImportPath string #51082
-pkg go/doc/comment, type DocLink struct, Name string #51082
-pkg go/doc/comment, type DocLink struct, Recv string #51082
-pkg go/doc/comment, type DocLink struct, Text []Text #51082
-pkg go/doc/comment, type Heading struct #51082
-pkg go/doc/comment, type Heading struct, Text []Text #51082
-pkg go/doc/comment, type Italic string #51082
-pkg go/doc/comment, type Link struct #51082
-pkg go/doc/comment, type Link struct, Auto bool #51082
-pkg go/doc/comment, type Link struct, Text []Text #51082
-pkg go/doc/comment, type Link struct, URL string #51082
-pkg go/doc/comment, type LinkDef struct #51082
-pkg go/doc/comment, type LinkDef struct, Text string #51082
-pkg go/doc/comment, type LinkDef struct, URL string #51082
-pkg go/doc/comment, type LinkDef struct, Used bool #51082
-pkg go/doc/comment, type List struct #51082
-pkg go/doc/comment, type List struct, ForceBlankBefore bool #51082
-pkg go/doc/comment, type List struct, ForceBlankBetween bool #51082
-pkg go/doc/comment, type List struct, Items []*ListItem #51082
-pkg go/doc/comment, type ListItem struct #51082
-pkg go/doc/comment, type ListItem struct, Content []Block #51082
-pkg go/doc/comment, type ListItem struct, Number string #51082
-pkg go/doc/comment, type Paragraph struct #51082
-pkg go/doc/comment, type Paragraph struct, Text []Text #51082
-pkg go/doc/comment, type Parser struct #51082
-pkg go/doc/comment, type Parser struct, LookupPackage func(string) (string, bool) #51082
-pkg go/doc/comment, type Parser struct, LookupSym func(string, string) bool #51082
-pkg go/doc/comment, type Parser struct, Words map[string]string #51082
-pkg go/doc/comment, type Plain string #51082
-pkg go/doc/comment, type Printer struct #51082
-pkg go/doc/comment, type Printer struct, DocLinkBaseURL string #51082
-pkg go/doc/comment, type Printer struct, DocLinkURL func(*DocLink) string #51082
-pkg go/doc/comment, type Printer struct, HeadingID func(*Heading) string #51082
-pkg go/doc/comment, type Printer struct, HeadingLevel int #51082
-pkg go/doc/comment, type Printer struct, TextCodePrefix string #51082
-pkg go/doc/comment, type Printer struct, TextPrefix string #51082
-pkg go/doc/comment, type Printer struct, TextWidth int #51082
-pkg go/doc/comment, type Text interface, unexported methods #51082
-pkg go/types, method (*Func) Origin() *Func #51682
-pkg go/types, method (*Var) Origin() *Var #51682
-pkg hash/maphash, func Bytes(Seed, []uint8) uint64 #42710
-pkg hash/maphash, func String(Seed, string) uint64 #42710
-pkg html/template, method (*Template) Funcs(template.FuncMap) *Template #46121
-pkg html/template, type FuncMap = template.FuncMap #46121
-pkg net/http, method (*MaxBytesError) Error() string #30715
-pkg net/http, type MaxBytesError struct #30715
-pkg net/http, type MaxBytesError struct, Limit int64 #30715
-pkg net/url, func JoinPath(string, ...string) (string, error) #47005
-pkg net/url, method (*URL) JoinPath(...string) *URL #47005
-pkg net/url, type URL struct, OmitHost bool #46059
-pkg os/exec, method (*Cmd) Environ() []string #50599
-pkg os/exec, type Cmd struct, Err error #43724
-pkg os/exec, var ErrDot error #43724
-pkg regexp/syntax, const ErrNestingDepth = "expression nests too deeply" #51684
-pkg regexp/syntax, const ErrNestingDepth ErrorCode #51684
-pkg runtime/debug, func SetMemoryLimit(int64) int64 #48409
-pkg sort, func Find(int, func(int) int) (int, bool) #50340
-pkg sync/atomic, method (*Bool) CompareAndSwap(bool, bool) bool #50860
-pkg sync/atomic, method (*Bool) Load() bool #50860
-pkg sync/atomic, method (*Bool) Store(bool) #50860
-pkg sync/atomic, method (*Bool) Swap(bool) bool #50860
-pkg sync/atomic, method (*Int32) Add(int32) int32 #50860
-pkg sync/atomic, method (*Int32) CompareAndSwap(int32, int32) bool #50860
-pkg sync/atomic, method (*Int32) Load() int32 #50860
-pkg sync/atomic, method (*Int32) Store(int32) #50860
-pkg sync/atomic, method (*Int32) Swap(int32) int32 #50860
-pkg sync/atomic, method (*Int64) Add(int64) int64 #50860
-pkg sync/atomic, method (*Int64) CompareAndSwap(int64, int64) bool #50860
-pkg sync/atomic, method (*Int64) Load() int64 #50860
-pkg sync/atomic, method (*Int64) Store(int64) #50860
-pkg sync/atomic, method (*Int64) Swap(int64) int64 #50860
-pkg sync/atomic, method (*Pointer[$0]) CompareAndSwap(*$0, *$0) bool #50860
-pkg sync/atomic, method (*Pointer[$0]) Load() *$0 #50860
-pkg sync/atomic, method (*Pointer[$0]) Store(*$0) #50860
-pkg sync/atomic, method (*Pointer[$0]) Swap(*$0) *$0 #50860
-pkg sync/atomic, method (*Uint32) Add(uint32) uint32 #50860
-pkg sync/atomic, method (*Uint32) CompareAndSwap(uint32, uint32) bool #50860
-pkg sync/atomic, method (*Uint32) Load() uint32 #50860
-pkg sync/atomic, method (*Uint32) Store(uint32) #50860
-pkg sync/atomic, method (*Uint32) Swap(uint32) uint32 #50860
-pkg sync/atomic, method (*Uint64) Add(uint64) uint64 #50860
-pkg sync/atomic, method (*Uint64) CompareAndSwap(uint64, uint64) bool #50860
-pkg sync/atomic, method (*Uint64) Load() uint64 #50860
-pkg sync/atomic, method (*Uint64) Store(uint64) #50860
-pkg sync/atomic, method (*Uint64) Swap(uint64) uint64 #50860
-pkg sync/atomic, method (*Uintptr) Add(uintptr) uintptr #50860
-pkg sync/atomic, method (*Uintptr) CompareAndSwap(uintptr, uintptr) bool #50860
-pkg sync/atomic, method (*Uintptr) Load() uintptr #50860
-pkg sync/atomic, method (*Uintptr) Store(uintptr) #50860
-pkg sync/atomic, method (*Uintptr) Swap(uintptr) uintptr #50860
-pkg sync/atomic, type Bool struct #50860
-pkg sync/atomic, type Int32 struct #50860
-pkg sync/atomic, type Int64 struct #50860
-pkg sync/atomic, type Pointer[$0 interface{}] struct #50860
-pkg sync/atomic, type Uint32 struct #50860
-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,426 +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(QUICSessionTicketOptions) error #60107
-pkg crypto/tls, type QUICSessionTicketOptions struct #60107
-pkg crypto/tls, type QUICSessionTicketOptions struct, EarlyData bool #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, func NewPackage //deprecated #52463
-pkg go/ast, type File struct, GoVersion string #59033
-pkg go/ast, type Importer //deprecated #52463
-pkg go/ast, type Object //deprecated #52463
-pkg go/ast, type Package //deprecated #52463
-pkg go/ast, type Scope //deprecated #52463
-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 DebugContext(context.Context, string, ...interface{}) #61200
-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 ErrorContext(context.Context, string, ...interface{}) #61200
-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 InfoContext(context.Context, string, ...interface{}) #61200
-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 WarnContext(context.Context, string, ...interface{})  #61200
-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) DebugContext(context.Context, string, ...interface{}) #61200
-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) ErrorContext(context.Context, string, ...interface{}) #61200
-pkg log/slog, method (*Logger) Error(string, ...interface{}) #56345
-pkg log/slog, method (*Logger) Handler() Handler #56345
-pkg log/slog, method (*Logger) InfoContext(context.Context, string, ...interface{}) #61200
-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) WarnContext(context.Context, string, ...interface{}) #61200
-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 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

api/go1.22.txt

@@ -1,135 +0,0 @@
-pkg archive/tar, method (*Writer) AddFS(fs.FS) error #58000
-pkg archive/zip, method (*Writer) AddFS(fs.FS) error #54898
-pkg cmp, func Or[$0 comparable](...$0) $0 #60204
-pkg crypto/x509, func OIDFromInts([]uint64) (OID, error) #60665
-pkg crypto/x509, method (*CertPool) AddCertWithConstraint(*Certificate, func([]*Certificate) error) #57178
-pkg crypto/x509, method (OID) Equal(OID) bool #60665
-pkg crypto/x509, method (OID) EqualASN1OID(asn1.ObjectIdentifier) bool #60665
-pkg crypto/x509, method (OID) String() string #60665
-pkg crypto/x509, type Certificate struct, Policies []OID #60665
-pkg crypto/x509, type OID struct #60665
-pkg database/sql, method (*Null[$0]) Scan(interface{}) error #60370
-pkg database/sql, method (Null[$0]) Value() (driver.Value, error) #60370
-pkg database/sql, type Null[$0 interface{}] struct #60370
-pkg database/sql, type Null[$0 interface{}] struct, V $0 #60370
-pkg database/sql, type Null[$0 interface{}] struct, Valid bool #60370
-pkg debug/elf, const R_LARCH_64_PCREL = 109 #63725
-pkg debug/elf, const R_LARCH_64_PCREL R_LARCH #63725
-pkg debug/elf, const R_LARCH_ADD6 = 105 #63725
-pkg debug/elf, const R_LARCH_ADD6 R_LARCH #63725
-pkg debug/elf, const R_LARCH_ADD_ULEB128 = 107 #63725
-pkg debug/elf, const R_LARCH_ADD_ULEB128 R_LARCH #63725
-pkg debug/elf, const R_LARCH_ALIGN = 102 #63725
-pkg debug/elf, const R_LARCH_ALIGN R_LARCH #63725
-pkg debug/elf, const R_LARCH_CFA = 104 #63725
-pkg debug/elf, const R_LARCH_CFA R_LARCH #63725
-pkg debug/elf, const R_LARCH_DELETE = 101 #63725
-pkg debug/elf, const R_LARCH_DELETE R_LARCH #63725
-pkg debug/elf, const R_LARCH_PCREL20_S2 = 103 #63725
-pkg debug/elf, const R_LARCH_PCREL20_S2 R_LARCH #63725
-pkg debug/elf, const R_LARCH_SUB6 = 106 #63725
-pkg debug/elf, const R_LARCH_SUB6 R_LARCH #63725
-pkg debug/elf, const R_LARCH_SUB_ULEB128 = 108 #63725
-pkg debug/elf, const R_LARCH_SUB_ULEB128 R_LARCH #63725
-pkg debug/elf, const R_MIPS_PC32 = 248 #61974
-pkg debug/elf, const R_MIPS_PC32 R_MIPS #61974
-pkg encoding/base32, method (*Encoding) AppendDecode([]uint8, []uint8) ([]uint8, error) #53693
-pkg encoding/base32, method (*Encoding) AppendEncode([]uint8, []uint8) []uint8 #53693
-pkg encoding/base64, method (*Encoding) AppendDecode([]uint8, []uint8) ([]uint8, error) #53693
-pkg encoding/base64, method (*Encoding) AppendEncode([]uint8, []uint8) []uint8 #53693
-pkg encoding/hex, func AppendDecode([]uint8, []uint8) ([]uint8, error) #53693
-pkg encoding/hex, func AppendEncode([]uint8, []uint8) []uint8 #53693
-pkg go/ast, func NewPackage //deprecated #52463
-pkg go/ast, func Unparen(Expr) Expr #60061
-pkg go/ast, type Importer //deprecated #52463
-pkg go/ast, type Object //deprecated #52463
-pkg go/ast, type Package //deprecated #52463
-pkg go/ast, type Scope //deprecated #52463
-pkg go/types, func NewAlias(*TypeName, Type) *Alias #63223
-pkg go/types, func Unalias(Type) Type #63223
-pkg go/types, method (*Alias) Obj() *TypeName #63223
-pkg go/types, method (*Alias) String() string #63223
-pkg go/types, method (*Alias) Underlying() Type #63223
-pkg go/types, method (*Info) PkgNameOf(*ast.ImportSpec) *PkgName #62037
-pkg go/types, method (Checker) PkgNameOf(*ast.ImportSpec) *PkgName #62037
-pkg go/types, type Alias struct #63223
-pkg go/types, type Info struct, FileVersions map[*ast.File]string #62605
-pkg go/version, func Compare(string, string) int #62039
-pkg go/version, func IsValid(string) bool #62039
-pkg go/version, func Lang(string) string #62039
-pkg html/template, const ErrJSTemplate //deprecated #61619
-pkg io, method (*SectionReader) Outer() (ReaderAt, int64, int64) #61870
-pkg log/slog, func SetLogLoggerLevel(Level) Level #62418
-pkg math/big, method (*Rat) FloatPrec() (int, bool) #50489
-pkg math/rand/v2, func ExpFloat64() float64 #61716
-pkg math/rand/v2, func Float32() float32 #61716
-pkg math/rand/v2, func Float64() float64 #61716
-pkg math/rand/v2, func Int() int #61716
-pkg math/rand/v2, func Int32() int32 #61716
-pkg math/rand/v2, func Int32N(int32) int32 #61716
-pkg math/rand/v2, func Int64() int64 #61716
-pkg math/rand/v2, func Int64N(int64) int64 #61716
-pkg math/rand/v2, func IntN(int) int #61716
-pkg math/rand/v2, func N[$0 intType]($0) $0 #61716
-pkg math/rand/v2, func New(Source) *Rand #61716
-pkg math/rand/v2, func NewChaCha8([32]uint8) *ChaCha8 #61716
-pkg math/rand/v2, func NewPCG(uint64, uint64) *PCG #61716
-pkg math/rand/v2, func NewZipf(*Rand, float64, float64, uint64) *Zipf #61716
-pkg math/rand/v2, func NormFloat64() float64 #61716
-pkg math/rand/v2, func Perm(int) []int #61716
-pkg math/rand/v2, func Shuffle(int, func(int, int)) #61716
-pkg math/rand/v2, func Uint32() uint32 #61716
-pkg math/rand/v2, func Uint32N(uint32) uint32 #61716
-pkg math/rand/v2, func Uint64() uint64 #61716
-pkg math/rand/v2, func Uint64N(uint64) uint64 #61716
-pkg math/rand/v2, func UintN(uint) uint #61716
-pkg math/rand/v2, method (*ChaCha8) MarshalBinary() ([]uint8, error) #61716
-pkg math/rand/v2, method (*ChaCha8) Seed([32]uint8) #61716
-pkg math/rand/v2, method (*ChaCha8) Uint64() uint64 #61716
-pkg math/rand/v2, method (*ChaCha8) UnmarshalBinary([]uint8) error #61716
-pkg math/rand/v2, method (*PCG) MarshalBinary() ([]uint8, error) #61716
-pkg math/rand/v2, method (*PCG) Seed(uint64, uint64) #61716
-pkg math/rand/v2, method (*PCG) Uint64() uint64 #61716
-pkg math/rand/v2, method (*PCG) UnmarshalBinary([]uint8) error #61716
-pkg math/rand/v2, method (*Rand) ExpFloat64() float64 #61716
-pkg math/rand/v2, method (*Rand) Float32() float32 #61716
-pkg math/rand/v2, method (*Rand) Float64() float64 #61716
-pkg math/rand/v2, method (*Rand) Int() int #61716
-pkg math/rand/v2, method (*Rand) Int32() int32 #61716
-pkg math/rand/v2, method (*Rand) Int32N(int32) int32 #61716
-pkg math/rand/v2, method (*Rand) Int64() int64 #61716
-pkg math/rand/v2, method (*Rand) Int64N(int64) int64 #61716
-pkg math/rand/v2, method (*Rand) IntN(int) int #61716
-pkg math/rand/v2, method (*Rand) NormFloat64() float64 #61716
-pkg math/rand/v2, method (*Rand) Perm(int) []int #61716
-pkg math/rand/v2, method (*Rand) Shuffle(int, func(int, int)) #61716
-pkg math/rand/v2, method (*Rand) Uint32() uint32 #61716
-pkg math/rand/v2, method (*Rand) Uint32N(uint32) uint32 #61716
-pkg math/rand/v2, method (*Rand) Uint64() uint64 #61716
-pkg math/rand/v2, method (*Rand) Uint64N(uint64) uint64 #61716
-pkg math/rand/v2, method (*Rand) UintN(uint) uint #61716
-pkg math/rand/v2, method (*Zipf) Uint64() uint64 #61716
-pkg math/rand/v2, type ChaCha8 struct #61716
-pkg math/rand/v2, type PCG struct #61716
-pkg math/rand/v2, type Rand struct #61716
-pkg math/rand/v2, type Source interface { Uint64 } #61716
-pkg math/rand/v2, type Source interface, Uint64() uint64 #61716
-pkg math/rand/v2, type Zipf struct #61716
-pkg net, method (*TCPConn) WriteTo(io.Writer) (int64, error) #58808
-pkg net/http, func FileServerFS(fs.FS) Handler #51971
-pkg net/http, func NewFileTransportFS(fs.FS) RoundTripper #51971
-pkg net/http, func ServeFileFS(ResponseWriter, *Request, fs.FS, string) #51971
-pkg net/http, method (*Request) PathValue(string) string #61410
-pkg net/http, method (*Request) SetPathValue(string, string) #61410
-pkg net/netip, method (AddrPort) Compare(AddrPort) int #61642
-pkg os, method (*File) WriteTo(io.Writer) (int64, error) #58808
-pkg reflect, func PtrTo //deprecated #59599
-pkg reflect, func TypeFor[$0 interface{}]() Type #60088
-pkg slices, func Concat[$0 interface{ ~[]$1 }, $1 interface{}](...$0) $0 #56353
-pkg syscall (linux-386), type SysProcAttr struct, PidFD *int #51246
-pkg syscall (linux-386-cgo), type SysProcAttr struct, PidFD *int #51246
-pkg syscall (linux-amd64), type SysProcAttr struct, PidFD *int #51246
-pkg syscall (linux-amd64-cgo), type SysProcAttr struct, PidFD *int #51246
-pkg syscall (linux-arm), type SysProcAttr struct, PidFD *int #51246
-pkg syscall (linux-arm-cgo), type SysProcAttr struct, PidFD *int #51246
-pkg testing/slogtest, func Run(*testing.T, func(*testing.T) slog.Handler, func(*testing.T) map[string]interface{}) #61758

api/go1.23.txt

@@ -1,158 +0,0 @@
-pkg archive/tar, type FileInfoNames interface { Gname, IsDir, ModTime, Mode, Name, Size, Sys, Uname } #50102
-pkg archive/tar, type FileInfoNames interface, Gname() (string, error) #50102
-pkg archive/tar, type FileInfoNames interface, IsDir() bool #50102
-pkg archive/tar, type FileInfoNames interface, ModTime() time.Time #50102
-pkg archive/tar, type FileInfoNames interface, Mode() fs.FileMode #50102
-pkg archive/tar, type FileInfoNames interface, Name() string #50102
-pkg archive/tar, type FileInfoNames interface, Size() int64 #50102
-pkg archive/tar, type FileInfoNames interface, Sys() interface{} #50102
-pkg archive/tar, type FileInfoNames interface, Uname() (string, error) #50102
-pkg crypto/tls, const QUICResumeSession = 8 #63691
-pkg crypto/tls, const QUICResumeSession QUICEventKind #63691
-pkg crypto/tls, const QUICStoreSession = 9 #63691
-pkg crypto/tls, const QUICStoreSession QUICEventKind #63691
-pkg crypto/tls, method (*ECHRejectionError) Error() string #63369
-pkg crypto/tls, method (*QUICConn) StoreSession(*SessionState) error #63691
-pkg crypto/tls, type Config struct, EncryptedClientHelloConfigList []uint8 #63369
-pkg crypto/tls, type Config struct, EncryptedClientHelloRejectionVerify func(ConnectionState) error #63369
-pkg crypto/tls, type ConnectionState struct, ECHAccepted bool #63369
-pkg crypto/tls, type ECHRejectionError struct #63369
-pkg crypto/tls, type ECHRejectionError struct, RetryConfigList []uint8 #63369
-pkg crypto/tls, type QUICConfig struct, EnableSessionEvents bool #63691
-pkg crypto/tls, type QUICEvent struct, SessionState *SessionState #63691
-pkg crypto/tls, type QUICSessionTicketOptions struct, Extra [][]uint8 #63691
-pkg crypto/x509, func ParseOID(string) (OID, error) #66249
-pkg crypto/x509, method (*OID) UnmarshalBinary([]uint8) error #66249
-pkg crypto/x509, method (*OID) UnmarshalText([]uint8) error #66249
-pkg crypto/x509, method (OID) MarshalBinary() ([]uint8, error) #66249
-pkg crypto/x509, method (OID) MarshalText() ([]uint8, error) #66249
-pkg debug/elf, const PT_OPENBSD_NOBTCFI = 1705237480 #66054
-pkg debug/elf, const PT_OPENBSD_NOBTCFI ProgType #66054
-pkg debug/elf, const STT_GNU_IFUNC = 10 #66836
-pkg debug/elf, const STT_GNU_IFUNC SymType #66836
-pkg debug/elf, const STT_RELC = 8 #66836
-pkg debug/elf, const STT_RELC SymType #66836
-pkg debug/elf, const STT_SRELC = 9 #66836
-pkg debug/elf, const STT_SRELC SymType #66836
-pkg encoding/binary, func Append([]uint8, ByteOrder, interface{}) ([]uint8, error) #60023
-pkg encoding/binary, func Decode([]uint8, ByteOrder, interface{}) (int, error) #60023
-pkg encoding/binary, func Encode([]uint8, ByteOrder, interface{}) (int, error) #60023
-pkg go/ast, func Preorder(Node) iter.Seq[Node] #66339
-pkg go/types, method (*Alias) Origin() *Alias #67143
-pkg go/types, method (*Alias) Rhs() Type #66559
-pkg go/types, method (*Alias) SetTypeParams([]*TypeParam) #67143
-pkg go/types, method (*Alias) TypeArgs() *TypeList #67143
-pkg go/types, method (*Alias) TypeParams() *TypeParamList #67143
-pkg go/types, method (*Func) Signature() *Signature #65772
-pkg iter, func Pull2[$0 interface{}, $1 interface{}](Seq2[$0, $1]) (func() ($0, $1, bool), func()) #61897
-pkg iter, func Pull[$0 interface{}](Seq[$0]) (func() ($0, bool), func()) #61897
-pkg iter, type Seq2[$0 interface{}, $1 interface{}] func(func($0, $1) bool) #61897
-pkg iter, type Seq[$0 interface{}] func(func($0) bool) #61897
-pkg maps, func All[$0 interface{ ~map[$1]$2 }, $1 comparable, $2 interface{}]($0) iter.Seq2[$1, $2] #61900
-pkg maps, func Collect[$0 comparable, $1 interface{}](iter.Seq2[$0, $1]) map[$0]$1 #61900
-pkg maps, func Insert[$0 interface{ ~map[$1]$2 }, $1 comparable, $2 interface{}]($0, iter.Seq2[$1, $2]) #61900
-pkg maps, func Keys[$0 interface{ ~map[$1]$2 }, $1 comparable, $2 interface{}]($0) iter.Seq[$1] #61900
-pkg maps, func Values[$0 interface{ ~map[$1]$2 }, $1 comparable, $2 interface{}]($0) iter.Seq[$2] #61900
-pkg math/rand/v2, func Uint() uint #61716
-pkg math/rand/v2, method (*ChaCha8) Read([]uint8) (int, error) #67059
-pkg math/rand/v2, method (*Rand) Uint() uint #61716
-pkg net, method (*DNSError) Unwrap() error #63116
-pkg net, method (*TCPConn) SetKeepAliveConfig(KeepAliveConfig) error #62254
-pkg net, type DNSError struct, UnwrapErr error #63116
-pkg net, type Dialer struct, KeepAliveConfig KeepAliveConfig #62254
-pkg net, type KeepAliveConfig struct #62254
-pkg net, type KeepAliveConfig struct, Count int #62254
-pkg net, type KeepAliveConfig struct, Enable bool #62254
-pkg net, type KeepAliveConfig struct, Idle time.Duration #62254
-pkg net, type KeepAliveConfig struct, Interval time.Duration #62254
-pkg net, type ListenConfig struct, KeepAliveConfig KeepAliveConfig #62254
-pkg net/http, func ParseCookie(string) ([]*Cookie, error) #66008
-pkg net/http, func ParseSetCookie(string) (*Cookie, error) #66008
-pkg net/http, method (*Request) CookiesNamed(string) []*Cookie #61472
-pkg net/http, type Cookie struct, Partitioned bool #62490
-pkg net/http, type Cookie struct, Quoted bool #46443
-pkg net/http, type Request struct, Pattern string #66405
-pkg net/http/httptest, func NewRequestWithContext(context.Context, string, string, io.Reader) *http.Request #59473
-pkg os, func CopyFS(string, fs.FS) error #62484
-pkg path/filepath, func Localize(string) (string, error) #57151
-pkg reflect, func SliceAt(Type, unsafe.Pointer, int) Value #61308
-pkg reflect, method (Value) Seq() iter.Seq[Value] #66056
-pkg reflect, method (Value) Seq2() iter.Seq2[Value, Value] #66056
-pkg reflect, type Type interface, CanSeq() bool #66056
-pkg reflect, type Type interface, CanSeq2() bool #66056
-pkg reflect, type Type interface, OverflowComplex(complex128) bool #60427
-pkg reflect, type Type interface, OverflowFloat(float64) bool #60427
-pkg reflect, type Type interface, OverflowInt(int64) bool #60427
-pkg reflect, type Type interface, OverflowUint(uint64) bool #60427
-pkg runtime/debug, func SetCrashOutput(*os.File, CrashOptions) error #42888
-pkg runtime/debug, type CrashOptions struct #67182
-pkg slices, func All[$0 interface{ ~[]$1 }, $1 interface{}]($0) iter.Seq2[int, $1] #61899
-pkg slices, func AppendSeq[$0 interface{ ~[]$1 }, $1 interface{}]($0, iter.Seq[$1]) $0 #61899
-pkg slices, func Backward[$0 interface{ ~[]$1 }, $1 interface{}]($0) iter.Seq2[int, $1] #61899
-pkg slices, func Chunk[$0 interface{ ~[]$1 }, $1 interface{}]($0, int) iter.Seq[$0] #53987
-pkg slices, func Collect[$0 interface{}](iter.Seq[$0]) []$0 #61899
-pkg slices, func Repeat[$0 interface{ ~[]$1 }, $1 interface{}]($0, int) $0 #65238
-pkg slices, func SortedFunc[$0 interface{}](iter.Seq[$0], func($0, $0) int) []$0 #61899
-pkg slices, func SortedStableFunc[$0 interface{}](iter.Seq[$0], func($0, $0) int) []$0 #61899
-pkg slices, func Sorted[$0 cmp.Ordered](iter.Seq[$0]) []$0 #61899
-pkg slices, func Values[$0 interface{ ~[]$1 }, $1 interface{}]($0) iter.Seq[$1] #61899
-pkg structs, type HostLayout struct #66408
-pkg sync, method (*Map) Clear() #61696
-pkg sync/atomic, func AndInt32(*int32, int32) int32 #61395
-pkg sync/atomic, func AndInt64(*int64, int64) int64 #61395
-pkg sync/atomic, func AndUint32(*uint32, uint32) uint32 #61395
-pkg sync/atomic, func AndUint64(*uint64, uint64) uint64 #61395
-pkg sync/atomic, func AndUintptr(*uintptr, uintptr) uintptr #61395
-pkg sync/atomic, func OrInt32(*int32, int32) int32 #61395
-pkg sync/atomic, func OrInt64(*int64, int64) int64 #61395
-pkg sync/atomic, func OrUint32(*uint32, uint32) uint32 #61395
-pkg sync/atomic, func OrUint64(*uint64, uint64) uint64 #61395
-pkg sync/atomic, func OrUintptr(*uintptr, uintptr) uintptr #61395
-pkg sync/atomic, method (*Int32) And(int32) int32 #61395
-pkg sync/atomic, method (*Int32) Or(int32) int32 #61395
-pkg sync/atomic, method (*Int64) And(int64) int64 #61395
-pkg sync/atomic, method (*Int64) Or(int64) int64 #61395
-pkg sync/atomic, method (*Uint32) And(uint32) uint32 #61395
-pkg sync/atomic, method (*Uint32) Or(uint32) uint32 #61395
-pkg sync/atomic, method (*Uint64) And(uint64) uint64 #61395
-pkg sync/atomic, method (*Uint64) Or(uint64) uint64 #61395
-pkg sync/atomic, method (*Uintptr) And(uintptr) uintptr #61395
-pkg sync/atomic, method (*Uintptr) Or(uintptr) uintptr #61395
-pkg syscall (openbsd-386), const EBADMSG = 92 #67998
-pkg syscall (openbsd-386), const ELAST = 95 #67998
-pkg syscall (openbsd-386), const ENOTRECOVERABLE = 93 #67998
-pkg syscall (openbsd-386), const ENOTRECOVERABLE Errno #67998
-pkg syscall (openbsd-386), const EOWNERDEAD = 94 #67998
-pkg syscall (openbsd-386), const EOWNERDEAD Errno #67998
-pkg syscall (openbsd-386), const EPROTO = 95 #67998
-pkg syscall (openbsd-386-cgo), const EBADMSG = 92 #67998
-pkg syscall (openbsd-386-cgo), const ELAST = 95 #67998
-pkg syscall (openbsd-386-cgo), const ENOTRECOVERABLE = 93 #67998
-pkg syscall (openbsd-386-cgo), const ENOTRECOVERABLE Errno #67998
-pkg syscall (openbsd-386-cgo), const EOWNERDEAD = 94 #67998
-pkg syscall (openbsd-386-cgo), const EOWNERDEAD Errno #67998
-pkg syscall (openbsd-386-cgo), const EPROTO = 95 #67998
-pkg syscall (openbsd-amd64), const EBADMSG = 92 #67998
-pkg syscall (openbsd-amd64), const ELAST = 95 #67998
-pkg syscall (openbsd-amd64), const ENOTRECOVERABLE = 93 #67998
-pkg syscall (openbsd-amd64), const ENOTRECOVERABLE Errno #67998
-pkg syscall (openbsd-amd64), const EOWNERDEAD = 94 #67998
-pkg syscall (openbsd-amd64), const EOWNERDEAD Errno #67998
-pkg syscall (openbsd-amd64), const EPROTO = 95 #67998
-pkg syscall (openbsd-amd64-cgo), const EBADMSG = 92 #67998
-pkg syscall (openbsd-amd64-cgo), const ELAST = 95 #67998
-pkg syscall (openbsd-amd64-cgo), const ENOTRECOVERABLE = 93 #67998
-pkg syscall (openbsd-amd64-cgo), const ENOTRECOVERABLE Errno #67998
-pkg syscall (openbsd-amd64-cgo), const EOWNERDEAD = 94 #67998
-pkg syscall (openbsd-amd64-cgo), const EOWNERDEAD Errno #67998
-pkg syscall (openbsd-amd64-cgo), const EPROTO = 95 #67998
-pkg syscall (windows-386), const WSAENOPROTOOPT = 10042 #62254
-pkg syscall (windows-386), const WSAENOPROTOOPT Errno #62254
-pkg syscall (windows-amd64), const WSAENOPROTOOPT = 10042 #62254
-pkg syscall (windows-amd64), const WSAENOPROTOOPT Errno #62254
-pkg syscall, const EBADMSG Errno #67998
-pkg syscall, const EPROTO Errno #67998
-pkg unicode/utf16, func RuneLen(int32) int #44940
-pkg unique, func Make[$0 comparable]($0) Handle[$0] #62483
-pkg unique, method (Handle[$0]) Value() $0 #62483
-pkg unique, type Handle[$0 comparable] struct #62483

api/go1.24.txt

@@ -1,223 +0,0 @@
-pkg bytes, func FieldsFuncSeq([]uint8, func(int32) bool) iter.Seq[[]uint8] #61901
-pkg bytes, func FieldsSeq([]uint8) iter.Seq[[]uint8] #61901
-pkg bytes, func Lines([]uint8) iter.Seq[[]uint8] #61901
-pkg bytes, func SplitAfterSeq([]uint8, []uint8) iter.Seq[[]uint8] #61901
-pkg bytes, func SplitSeq([]uint8, []uint8) iter.Seq[[]uint8] #61901
-pkg crypto/cipher, func NewCFBDecrypter //deprecated #69445
-pkg crypto/cipher, func NewCFBEncrypter //deprecated #69445
-pkg crypto/cipher, func NewGCMWithRandomNonce(Block) (AEAD, error) #69981
-pkg crypto/cipher, func NewOFB //deprecated #69445
-pkg crypto/fips140, func Enabled() bool #70123
-pkg crypto/hkdf, func Expand[$0 hash.Hash](func() $0, []uint8, string, int) ([]uint8, error) #61477
-pkg crypto/hkdf, func Extract[$0 hash.Hash](func() $0, []uint8, []uint8) ([]uint8, error) #61477
-pkg crypto/hkdf, func Key[$0 hash.Hash](func() $0, []uint8, []uint8, string, int) ([]uint8, error) #61477
-pkg crypto/mlkem, const CiphertextSize1024 = 1568 #70122
-pkg crypto/mlkem, const CiphertextSize1024 ideal-int #70122
-pkg crypto/mlkem, const CiphertextSize768 = 1088 #70122
-pkg crypto/mlkem, const CiphertextSize768 ideal-int #70122
-pkg crypto/mlkem, const EncapsulationKeySize1024 = 1568 #70122
-pkg crypto/mlkem, const EncapsulationKeySize1024 ideal-int #70122
-pkg crypto/mlkem, const EncapsulationKeySize768 = 1184 #70122
-pkg crypto/mlkem, const EncapsulationKeySize768 ideal-int #70122
-pkg crypto/mlkem, const SeedSize = 64 #70122
-pkg crypto/mlkem, const SeedSize ideal-int #70122
-pkg crypto/mlkem, const SharedKeySize = 32 #70122
-pkg crypto/mlkem, const SharedKeySize ideal-int #70122
-pkg crypto/mlkem, func GenerateKey1024() (*DecapsulationKey1024, error) #70122
-pkg crypto/mlkem, func GenerateKey768() (*DecapsulationKey768, error) #70122
-pkg crypto/mlkem, func NewDecapsulationKey1024([]uint8) (*DecapsulationKey1024, error) #70122
-pkg crypto/mlkem, func NewDecapsulationKey768([]uint8) (*DecapsulationKey768, error) #70122
-pkg crypto/mlkem, func NewEncapsulationKey1024([]uint8) (*EncapsulationKey1024, error) #70122
-pkg crypto/mlkem, func NewEncapsulationKey768([]uint8) (*EncapsulationKey768, error) #70122
-pkg crypto/mlkem, method (*DecapsulationKey1024) Bytes() []uint8 #70122
-pkg crypto/mlkem, method (*DecapsulationKey1024) Decapsulate([]uint8) ([]uint8, error) #70122
-pkg crypto/mlkem, method (*DecapsulationKey1024) EncapsulationKey() *EncapsulationKey1024 #70122
-pkg crypto/mlkem, method (*DecapsulationKey768) Bytes() []uint8 #70122
-pkg crypto/mlkem, method (*DecapsulationKey768) Decapsulate([]uint8) ([]uint8, error) #70122
-pkg crypto/mlkem, method (*DecapsulationKey768) EncapsulationKey() *EncapsulationKey768 #70122
-pkg crypto/mlkem, method (*EncapsulationKey1024) Bytes() []uint8 #70122
-pkg crypto/mlkem, method (*EncapsulationKey1024) Encapsulate() ([]uint8, []uint8) #70122
-pkg crypto/mlkem, method (*EncapsulationKey768) Bytes() []uint8 #70122
-pkg crypto/mlkem, method (*EncapsulationKey768) Encapsulate() ([]uint8, []uint8) #70122
-pkg crypto/mlkem, type DecapsulationKey1024 struct #70122
-pkg crypto/mlkem, type DecapsulationKey768 struct #70122
-pkg crypto/mlkem, type EncapsulationKey1024 struct #70122
-pkg crypto/mlkem, type EncapsulationKey768 struct #70122
-pkg crypto/pbkdf2, func Key[$0 hash.Hash](func() $0, string, []uint8, int, int) ([]uint8, error) #69488
-pkg crypto/rand, func Text() string #67057
-pkg crypto/sha3, func New224() *SHA3 #69982
-pkg crypto/sha3, func New256() *SHA3 #69982
-pkg crypto/sha3, func New384() *SHA3 #69982
-pkg crypto/sha3, func New512() *SHA3 #69982
-pkg crypto/sha3, func NewCSHAKE128([]uint8, []uint8) *SHAKE #69982
-pkg crypto/sha3, func NewCSHAKE256([]uint8, []uint8) *SHAKE #69982
-pkg crypto/sha3, func NewSHAKE128() *SHAKE #69982
-pkg crypto/sha3, func NewSHAKE256() *SHAKE #69982
-pkg crypto/sha3, func Sum224([]uint8) [28]uint8 #69982
-pkg crypto/sha3, func Sum256([]uint8) [32]uint8 #69982
-pkg crypto/sha3, func Sum384([]uint8) [48]uint8 #69982
-pkg crypto/sha3, func Sum512([]uint8) [64]uint8 #69982
-pkg crypto/sha3, func SumSHAKE128([]uint8, int) []uint8 #69982
-pkg crypto/sha3, func SumSHAKE256([]uint8, int) []uint8 #69982
-pkg crypto/sha3, method (*SHA3) AppendBinary([]uint8) ([]uint8, error) #69982
-pkg crypto/sha3, method (*SHA3) BlockSize() int #69982
-pkg crypto/sha3, method (*SHA3) MarshalBinary() ([]uint8, error) #69982
-pkg crypto/sha3, method (*SHA3) Reset() #69982
-pkg crypto/sha3, method (*SHA3) Size() int #69982
-pkg crypto/sha3, method (*SHA3) Sum([]uint8) []uint8 #69982
-pkg crypto/sha3, method (*SHA3) UnmarshalBinary([]uint8) error #69982
-pkg crypto/sha3, method (*SHA3) Write([]uint8) (int, error) #69982
-pkg crypto/sha3, method (*SHAKE) AppendBinary([]uint8) ([]uint8, error) #69982
-pkg crypto/sha3, method (*SHAKE) BlockSize() int #69982
-pkg crypto/sha3, method (*SHAKE) MarshalBinary() ([]uint8, error) #69982
-pkg crypto/sha3, method (*SHAKE) Read([]uint8) (int, error) #69982
-pkg crypto/sha3, method (*SHAKE) Reset() #69982
-pkg crypto/sha3, method (*SHAKE) UnmarshalBinary([]uint8) error #69982
-pkg crypto/sha3, method (*SHAKE) Write([]uint8) (int, error) #69982
-pkg crypto/sha3, type SHA3 struct #69982
-pkg crypto/sha3, type SHAKE struct #69982
-pkg crypto/subtle, func WithDataIndependentTiming(func()) #66450
-pkg crypto/tls, const X25519MLKEM768 = 4588 #69985
-pkg crypto/tls, const X25519MLKEM768 CurveID #69985
-pkg crypto/tls, type ClientHelloInfo struct, Extensions []uint16 #32936
-pkg crypto/tls, type Config struct, EncryptedClientHelloKeys []EncryptedClientHelloKey #68500
-pkg crypto/tls, type EncryptedClientHelloKey struct #68500
-pkg crypto/tls, type EncryptedClientHelloKey struct, Config []uint8 #68500
-pkg crypto/tls, type EncryptedClientHelloKey struct, PrivateKey []uint8 #68500
-pkg crypto/tls, type EncryptedClientHelloKey struct, SendAsRetry bool #68500
-pkg crypto/x509, const NoValidChains = 10 #68484
-pkg crypto/x509, const NoValidChains InvalidReason #68484
-pkg crypto/x509, method (OID) AppendBinary([]uint8) ([]uint8, error) #62384
-pkg crypto/x509, method (OID) AppendText([]uint8) ([]uint8, error) #62384
-pkg crypto/x509, type Certificate struct, InhibitAnyPolicy int #68484
-pkg crypto/x509, type Certificate struct, InhibitAnyPolicyZero bool #68484
-pkg crypto/x509, type Certificate struct, InhibitPolicyMapping int #68484
-pkg crypto/x509, type Certificate struct, InhibitPolicyMappingZero bool #68484
-pkg crypto/x509, type Certificate struct, PolicyMappings []PolicyMapping #68484
-pkg crypto/x509, type Certificate struct, RequireExplicitPolicy int #68484
-pkg crypto/x509, type Certificate struct, RequireExplicitPolicyZero bool #68484
-pkg crypto/x509, type PolicyMapping struct #68484
-pkg crypto/x509, type PolicyMapping struct, IssuerDomainPolicy OID #68484
-pkg crypto/x509, type PolicyMapping struct, SubjectDomainPolicy OID #68484
-pkg crypto/x509, type VerifyOptions struct, CertificatePolicies []OID #68484
-pkg debug/elf, const VER_FLG_BASE = 1 #63952
-pkg debug/elf, const VER_FLG_BASE DynamicVersionFlag #63952
-pkg debug/elf, const VER_FLG_INFO = 4 #63952
-pkg debug/elf, const VER_FLG_INFO DynamicVersionFlag #63952
-pkg debug/elf, const VER_FLG_WEAK = 2 #63952
-pkg debug/elf, const VER_FLG_WEAK DynamicVersionFlag #63952
-pkg debug/elf, method (*File) DynamicVersionNeeds() ([]DynamicVersionNeed, error) #63952
-pkg debug/elf, method (*File) DynamicVersions() ([]DynamicVersion, error) #63952
-pkg debug/elf, type DynamicVersion struct #63952
-pkg debug/elf, type DynamicVersion struct, Deps []string #63952
-pkg debug/elf, type DynamicVersion struct, Flags DynamicVersionFlag #63952
-pkg debug/elf, type DynamicVersion struct, Name string #63952
-pkg debug/elf, type DynamicVersion struct, Index uint16 #63952
-pkg debug/elf, type DynamicVersionDep struct #63952
-pkg debug/elf, type DynamicVersionDep struct, Dep string #63952
-pkg debug/elf, type DynamicVersionDep struct, Flags DynamicVersionFlag #63952
-pkg debug/elf, type DynamicVersionDep struct, Index uint16 #63952
-pkg debug/elf, type DynamicVersionFlag uint16 #63952
-pkg debug/elf, type DynamicVersionNeed struct #63952
-pkg debug/elf, type DynamicVersionNeed struct, Name string #63952
-pkg debug/elf, type DynamicVersionNeed struct, Needs []DynamicVersionDep #63952
-pkg debug/elf, type Symbol struct, HasVersion bool #63952
-pkg debug/elf, type Symbol struct, VersionIndex VersionIndex #63952
-pkg debug/elf, method (VersionIndex) Index() uint16 #63952
-pkg debug/elf, method (VersionIndex) IsHidden() bool #63952
-pkg debug/elf, type VersionIndex uint16 #63952
-pkg encoding, type BinaryAppender interface { AppendBinary } #62384
-pkg encoding, type BinaryAppender interface, AppendBinary([]uint8) ([]uint8, error) #62384
-pkg encoding, type TextAppender interface { AppendText } #62384
-pkg encoding, type TextAppender interface, AppendText([]uint8) ([]uint8, error) #62384
-pkg go/types, method (*Interface) EmbeddedTypes() iter.Seq[Type] #66626
-pkg go/types, method (*Interface) ExplicitMethods() iter.Seq[*Func] #66626
-pkg go/types, method (*Interface) Methods() iter.Seq[*Func] #66626
-pkg go/types, method (*MethodSet) Methods() iter.Seq[*Selection] #66626
-pkg go/types, method (*Named) Methods() iter.Seq[*Func] #66626
-pkg go/types, method (*Scope) Children() iter.Seq[*Scope] #66626
-pkg go/types, method (*Struct) Fields() iter.Seq[*Var] #66626
-pkg go/types, method (*Tuple) Variables() iter.Seq[*Var] #66626
-pkg go/types, method (*TypeList) Types() iter.Seq[Type] #66626
-pkg go/types, method (*TypeParamList) TypeParams() iter.Seq[*TypeParam] #66626
-pkg go/types, method (*Union) Terms() iter.Seq[*Term] #66626
-pkg hash/maphash, func Comparable[$0 comparable](Seed, $0) uint64 #54670
-pkg hash/maphash, func WriteComparable[$0 comparable](*Hash, $0) #54670
-pkg log/slog, method (*LevelVar) AppendText([]uint8) ([]uint8, error) #62384
-pkg log/slog, method (Level) AppendText([]uint8) ([]uint8, error) #62384
-pkg log/slog, var DiscardHandler Handler #62005
-pkg math/big, method (*Float) AppendText([]uint8) ([]uint8, error) #62384
-pkg math/big, method (*Int) AppendText([]uint8) ([]uint8, error) #62384
-pkg math/big, method (*Rat) AppendText([]uint8) ([]uint8, error) #62384
-pkg math/rand/v2, method (*ChaCha8) AppendBinary([]uint8) ([]uint8, error) #62384
-pkg math/rand/v2, method (*PCG) AppendBinary([]uint8) ([]uint8, error) #62384
-pkg net, method (IP) AppendText([]uint8) ([]uint8, error) #62384
-pkg net/http, method (*Protocols) SetHTTP1(bool) #67814
-pkg net/http, method (*Protocols) SetHTTP2(bool) #67814
-pkg net/http, method (*Protocols) SetUnencryptedHTTP2(bool) #67816
-pkg net/http, method (Protocols) HTTP1() bool #67814
-pkg net/http, method (Protocols) HTTP2() bool #67814
-pkg net/http, method (Protocols) String() string #67814
-pkg net/http, method (Protocols) UnencryptedHTTP2() bool #67816
-pkg net/http, type HTTP2Config struct #67813
-pkg net/http, type HTTP2Config struct, CountError func(string) #67813
-pkg net/http, type HTTP2Config struct, MaxConcurrentStreams int #67813
-pkg net/http, type HTTP2Config struct, MaxDecoderHeaderTableSize int #67813
-pkg net/http, type HTTP2Config struct, MaxEncoderHeaderTableSize int #67813
-pkg net/http, type HTTP2Config struct, MaxReadFrameSize int #67813
-pkg net/http, type HTTP2Config struct, MaxReceiveBufferPerConnection int #67813
-pkg net/http, type HTTP2Config struct, MaxReceiveBufferPerStream int #67813
-pkg net/http, type HTTP2Config struct, PermitProhibitedCipherSuites bool #67813
-pkg net/http, type HTTP2Config struct, PingTimeout time.Duration #67813
-pkg net/http, type HTTP2Config struct, SendPingTimeout time.Duration #67813
-pkg net/http, type HTTP2Config struct, WriteByteTimeout time.Duration #67813
-pkg net/http, type Protocols struct #67814
-pkg net/http, type Server struct, HTTP2 *HTTP2Config #67813
-pkg net/http, type Server struct, Protocols *Protocols #67814
-pkg net/http, type Transport struct, HTTP2 *HTTP2Config #67813
-pkg net/http, type Transport struct, Protocols *Protocols #67814
-pkg net/netip, method (Addr) AppendBinary([]uint8) ([]uint8, error) #62384
-pkg net/netip, method (Addr) AppendText([]uint8) ([]uint8, error) #62384
-pkg net/netip, method (AddrPort) AppendBinary([]uint8) ([]uint8, error) #62384
-pkg net/netip, method (AddrPort) AppendText([]uint8) ([]uint8, error) #62384
-pkg net/netip, method (Prefix) AppendBinary([]uint8) ([]uint8, error) #62384
-pkg net/netip, method (Prefix) AppendText([]uint8) ([]uint8, error) #62384
-pkg net/url, method (*URL) AppendBinary([]uint8) ([]uint8, error) #62384
-pkg os, func OpenInRoot(string, string) (*File, error) #67002
-pkg os, func OpenRoot(string) (*Root, error) #67002
-pkg os, method (*Root) Close() error #67002
-pkg os, method (*Root) Create(string) (*File, error) #67002
-pkg os, method (*Root) FS() fs.FS #67002
-pkg os, method (*Root) Lstat(string) (fs.FileInfo, error) #67002
-pkg os, method (*Root) Mkdir(string, fs.FileMode) error #67002
-pkg os, method (*Root) Name() string #67002
-pkg os, method (*Root) Open(string) (*File, error) #67002
-pkg os, method (*Root) OpenFile(string, int, fs.FileMode) (*File, error) #67002
-pkg os, method (*Root) OpenRoot(string) (*Root, error) #67002
-pkg os, method (*Root) Remove(string) error #67002
-pkg os, method (*Root) Stat(string) (fs.FileInfo, error) #67002
-pkg os, type Root struct #67002
-pkg regexp, method (*Regexp) AppendText([]uint8) ([]uint8, error) #62384
-pkg runtime, func AddCleanup[$0 interface{}, $1 interface{}](*$0, func($1), $1) Cleanup #67535
-pkg runtime, func GOROOT //deprecated #51473
-pkg runtime, method (Cleanup) Stop() #67535
-pkg runtime, type Cleanup struct #67535
-pkg strings, func FieldsFuncSeq(string, func(int32) bool) iter.Seq[string] #61901
-pkg strings, func FieldsSeq(string) iter.Seq[string] #61901
-pkg strings, func Lines(string) iter.Seq[string] #61901
-pkg strings, func SplitAfterSeq(string, string) iter.Seq[string] #61901
-pkg strings, func SplitSeq(string, string) iter.Seq[string] #61901
-pkg testing, method (*B) Chdir(string) #62516
-pkg testing, method (*B) Context() context.Context #36532
-pkg testing, method (*B) Loop() bool #61515
-pkg testing, method (*F) Chdir(string) #62516
-pkg testing, method (*F) Context() context.Context #36532
-pkg testing, method (*T) Chdir(string) #62516
-pkg testing, method (*T) Context() context.Context #36532
-pkg testing, type TB interface, Chdir(string) #62516
-pkg testing, type TB interface, Context() context.Context #36532
-pkg time, method (Time) AppendBinary([]uint8) ([]uint8, error) #62384
-pkg time, method (Time) AppendText([]uint8) ([]uint8, error) #62384
-pkg weak, func Make[$0 interface{}](*$0) Pointer[$0] #67552
-pkg weak, method (Pointer[$0]) Value() *$0 #67552
-pkg weak, type Pointer[$0 interface{}] struct #67552

api/go1.25.txt

@@ -1,111 +0,0 @@
-pkg crypto, func SignMessage(Signer, io.Reader, []uint8, SignerOpts) ([]uint8, error) #63405
-pkg crypto, type MessageSigner interface { Public, Sign, SignMessage } #63405
-pkg crypto, type MessageSigner interface, Public() PublicKey #63405
-pkg crypto, type MessageSigner interface, Sign(io.Reader, []uint8, SignerOpts) ([]uint8, error) #63405
-pkg crypto, type MessageSigner interface, SignMessage(io.Reader, []uint8, SignerOpts) ([]uint8, error) #63405
-pkg crypto/ecdsa, func ParseRawPrivateKey(elliptic.Curve, []uint8) (*PrivateKey, error) #63963
-pkg crypto/ecdsa, func ParseUncompressedPublicKey(elliptic.Curve, []uint8) (*PublicKey, error) #63963
-pkg crypto/ecdsa, method (*PrivateKey) Bytes() ([]uint8, error) #63963
-pkg crypto/ecdsa, method (*PublicKey) Bytes() ([]uint8, error) #63963
-pkg crypto/sha3, method (*SHA3) Clone() (hash.Cloner, error) #69521
-pkg crypto/tls, type Config struct, GetEncryptedClientHelloKeys func(*ClientHelloInfo) ([]EncryptedClientHelloKey, error) #71920
-pkg crypto/tls, type ConnectionState struct, CurveID CurveID #67516
-pkg debug/elf, const PT_RISCV_ATTRIBUTES = 1879048195 #72843
-pkg debug/elf, const PT_RISCV_ATTRIBUTES ProgType #72843
-pkg debug/elf, const SHT_RISCV_ATTRIBUTES = 1879048195 #72843
-pkg debug/elf, const SHT_RISCV_ATTRIBUTES SectionType #72843
-pkg go/ast, const FilterFuncDuplicates //deprecated #73088
-pkg go/ast, const FilterImportDuplicates //deprecated #73088
-pkg go/ast, const FilterUnassociatedComments //deprecated #73088
-pkg go/ast, func FilterPackage //deprecated #73088
-pkg go/ast, func MergePackageFiles //deprecated #73088
-pkg go/ast, func PackageExports //deprecated #73088
-pkg go/ast, func PreorderStack(Node, []Node, func(Node, []Node) bool) #73319
-pkg go/ast, type MergeMode //deprecated #73088
-pkg go/parser, func ParseDir //deprecated #71122
-pkg go/token, method (*FileSet) AddExistingFiles(...*File) #73205
-pkg go/types, const FieldVar = 6 #70250
-pkg go/types, const FieldVar VarKind #70250
-pkg go/types, const LocalVar = 2 #70250
-pkg go/types, const LocalVar VarKind #70250
-pkg go/types, const PackageVar = 1 #70250
-pkg go/types, const PackageVar VarKind #70250
-pkg go/types, const ParamVar = 4 #70250
-pkg go/types, const ParamVar VarKind #70250
-pkg go/types, const RecvVar = 3 #70250
-pkg go/types, const RecvVar VarKind #70250
-pkg go/types, const ResultVar = 5 #70250
-pkg go/types, const ResultVar VarKind #70250
-pkg go/types, func LookupSelection(Type, bool, *Package, string) (Selection, bool) #70737
-pkg go/types, method (*Var) Kind() VarKind #70250
-pkg go/types, method (*Var) SetKind(VarKind) #70250
-pkg go/types, method (VarKind) String() string #70250
-pkg go/types, type VarKind uint8 #70250
-pkg hash, type Cloner interface { BlockSize, Clone, Reset, Size, Sum, Write } #69521
-pkg hash, type Cloner interface, BlockSize() int #69521
-pkg hash, type Cloner interface, Clone() (Cloner, error) #69521
-pkg hash, type Cloner interface, Reset() #69521
-pkg hash, type Cloner interface, Size() int #69521
-pkg hash, type Cloner interface, Sum([]uint8) []uint8 #69521
-pkg hash, type Cloner interface, Write([]uint8) (int, error) #69521
-pkg hash, type XOF interface { BlockSize, Read, Reset, Write } #69518
-pkg hash, type XOF interface, BlockSize() int #69518
-pkg hash, type XOF interface, Read([]uint8) (int, error) #69518
-pkg hash, type XOF interface, Reset() #69518
-pkg hash, type XOF interface, Write([]uint8) (int, error) #69518
-pkg hash/maphash, method (*Hash) Clone() (hash.Cloner, error) #69521
-pkg io/fs, func Lstat(FS, string) (FileInfo, error) #49580
-pkg io/fs, func ReadLink(FS, string) (string, error) #49580
-pkg io/fs, type ReadLinkFS interface { Lstat, Open, ReadLink } #49580
-pkg io/fs, type ReadLinkFS interface, Lstat(string) (FileInfo, error) #49580
-pkg io/fs, type ReadLinkFS interface, Open(string) (File, error) #49580
-pkg io/fs, type ReadLinkFS interface, ReadLink(string) (string, error) #49580
-pkg log/slog, func GroupAttrs(string, ...Attr) Attr #66365
-pkg log/slog, method (Record) Source() *Source #70280
-pkg mime/multipart, func FileContentDisposition(string, string) string #46771
-pkg net/http, func NewCrossOriginProtection() *CrossOriginProtection #73626
-pkg net/http, method (*CrossOriginProtection) AddInsecureBypassPattern(string) #73626
-pkg net/http, method (*CrossOriginProtection) AddTrustedOrigin(string) error #73626
-pkg net/http, method (*CrossOriginProtection) Check(*Request) error #73626
-pkg net/http, method (*CrossOriginProtection) Handler(Handler) Handler #73626
-pkg net/http, method (*CrossOriginProtection) SetDenyHandler(Handler) #73626
-pkg net/http, type CrossOriginProtection struct #73626
-pkg os, method (*Root) Chmod(string, fs.FileMode) error #67002
-pkg os, method (*Root) Chown(string, int, int) error #67002
-pkg os, method (*Root) Chtimes(string, time.Time, time.Time) error #67002
-pkg os, method (*Root) Lchown(string, int, int) error #67002
-pkg os, method (*Root) Link(string, string) error #67002
-pkg os, method (*Root) MkdirAll(string, fs.FileMode) error #67002
-pkg os, method (*Root) ReadFile(string) ([]uint8, error) #73126
-pkg os, method (*Root) Readlink(string) (string, error) #67002
-pkg os, method (*Root) RemoveAll(string) error #67002
-pkg os, method (*Root) Rename(string, string) error #67002
-pkg os, method (*Root) Symlink(string, string) error #67002
-pkg os, method (*Root) WriteFile(string, []uint8, fs.FileMode) error #73126
-pkg reflect, func TypeAssert[$0 interface{}](Value) ($0, bool) #62121
-pkg runtime, func SetDefaultGOMAXPROCS() #73193
-pkg runtime/trace, func NewFlightRecorder(FlightRecorderConfig) *FlightRecorder #63185
-pkg runtime/trace, method (*FlightRecorder) Enabled() bool #63185
-pkg runtime/trace, method (*FlightRecorder) Start() error #63185
-pkg runtime/trace, method (*FlightRecorder) Stop() #63185
-pkg runtime/trace, method (*FlightRecorder) WriteTo(io.Writer) (int64, error) #63185
-pkg runtime/trace, type FlightRecorder struct #63185
-pkg runtime/trace, type FlightRecorderConfig struct #63185
-pkg runtime/trace, type FlightRecorderConfig struct, MaxBytes uint64 #63185
-pkg runtime/trace, type FlightRecorderConfig struct, MinAge time.Duration #63185
-pkg sync, method (*WaitGroup) Go(func()) #63796
-pkg testing, method (*B) Attr(string, string) #43936
-pkg testing, method (*B) Output() io.Writer #59928
-pkg testing, method (*F) Attr(string, string) #43936
-pkg testing, method (*F) Output() io.Writer #59928
-pkg testing, method (*T) Attr(string, string) #43936
-pkg testing, method (*T) Output() io.Writer #59928
-pkg testing, type TB interface, Attr(string, string) #43936
-pkg testing, type TB interface, Output() io.Writer #59928
-pkg testing/fstest, method (MapFS) Lstat(string) (fs.FileInfo, error) #49580
-pkg testing/fstest, method (MapFS) ReadLink(string) (string, error) #49580
-pkg testing/synctest, func Test(*testing.T, func(*testing.T)) #67434
-pkg testing/synctest, func Wait() #67434
-pkg unicode, var CategoryAliases map[string]string #70780
-pkg unicode, var Cn *RangeTable #70780
-pkg unicode, var LC *RangeTable #70780

api/go1.26.txt

@@ -1,180 +0,0 @@
-pkg bytes, method (*Buffer) Peek(int) ([]uint8, error) #73794
-pkg crypto, type Decapsulator interface { Decapsulate, Encapsulator } #75300
-pkg crypto, type Decapsulator interface, Decapsulate([]uint8) ([]uint8, error) #75300
-pkg crypto, type Decapsulator interface, Encapsulator() Encapsulator #75300
-pkg crypto, type Encapsulator interface { Bytes, Encapsulate } #75300
-pkg crypto, type Encapsulator interface, Bytes() []uint8 #75300
-pkg crypto, type Encapsulator interface, Encapsulate() ([]uint8, []uint8) #75300
-pkg crypto/ecdh, type KeyExchanger interface { Curve, ECDH, PublicKey } #75300
-pkg crypto/ecdh, type KeyExchanger interface, Curve() Curve #75300
-pkg crypto/ecdh, type KeyExchanger interface, ECDH(*PublicKey) ([]uint8, error) #75300
-pkg crypto/ecdh, type KeyExchanger interface, PublicKey() *PublicKey #75300
-pkg crypto/ecdsa, type PrivateKey struct, D //deprecated #63963
-pkg crypto/ecdsa, type PublicKey struct, X //deprecated #63963
-pkg crypto/ecdsa, type PublicKey struct, Y //deprecated #63963
-pkg crypto/fips140, func Enforced() bool #74630
-pkg crypto/fips140, func Version() string #75301
-pkg crypto/fips140, func WithoutEnforcement(func()) #74630
-pkg crypto/hpke, func AES128GCM() AEAD #75300
-pkg crypto/hpke, func AES256GCM() AEAD #75300
-pkg crypto/hpke, func ChaCha20Poly1305() AEAD #75300
-pkg crypto/hpke, func DHKEM(ecdh.Curve) KEM #75300
-pkg crypto/hpke, func ExportOnly() AEAD #75300
-pkg crypto/hpke, func HKDFSHA256() KDF #75300
-pkg crypto/hpke, func HKDFSHA384() KDF #75300
-pkg crypto/hpke, func HKDFSHA512() KDF #75300
-pkg crypto/hpke, func MLKEM1024() KEM #75300
-pkg crypto/hpke, func MLKEM1024P384() KEM #75300
-pkg crypto/hpke, func MLKEM768() KEM #75300
-pkg crypto/hpke, func MLKEM768P256() KEM #75300
-pkg crypto/hpke, func MLKEM768X25519() KEM #75300
-pkg crypto/hpke, func NewAEAD(uint16) (AEAD, error) #75300
-pkg crypto/hpke, func NewDHKEMPrivateKey(ecdh.KeyExchanger) (PrivateKey, error) #75300
-pkg crypto/hpke, func NewDHKEMPublicKey(*ecdh.PublicKey) (PublicKey, error) #75300
-pkg crypto/hpke, func NewHybridPrivateKey(crypto.Decapsulator, ecdh.KeyExchanger) (PrivateKey, error) #75300
-pkg crypto/hpke, func NewHybridPublicKey(crypto.Encapsulator, *ecdh.PublicKey) (PublicKey, error) #75300
-pkg crypto/hpke, func NewKDF(uint16) (KDF, error) #75300
-pkg crypto/hpke, func NewKEM(uint16) (KEM, error) #75300
-pkg crypto/hpke, func NewMLKEMPrivateKey(crypto.Decapsulator) (PrivateKey, error) #75300
-pkg crypto/hpke, func NewMLKEMPublicKey(crypto.Encapsulator) (PublicKey, error) #75300
-pkg crypto/hpke, func NewRecipient([]uint8, PrivateKey, KDF, AEAD, []uint8) (*Recipient, error) #75300
-pkg crypto/hpke, func NewSender(PublicKey, KDF, AEAD, []uint8) ([]uint8, *Sender, error) #75300
-pkg crypto/hpke, func Open(PrivateKey, KDF, AEAD, []uint8, []uint8) ([]uint8, error) #75300
-pkg crypto/hpke, func SHAKE128() KDF #75300
-pkg crypto/hpke, func SHAKE256() KDF #75300
-pkg crypto/hpke, func Seal(PublicKey, KDF, AEAD, []uint8, []uint8) ([]uint8, error) #75300
-pkg crypto/hpke, method (*Recipient) Export(string, int) ([]uint8, error) #75300
-pkg crypto/hpke, method (*Recipient) Open([]uint8, []uint8) ([]uint8, error) #75300
-pkg crypto/hpke, method (*Sender) Export(string, int) ([]uint8, error) #75300
-pkg crypto/hpke, method (*Sender) Seal([]uint8, []uint8) ([]uint8, error) #75300
-pkg crypto/hpke, type AEAD interface, ID() uint16 #75300
-pkg crypto/hpke, type AEAD interface, unexported methods #75300
-pkg crypto/hpke, type KDF interface, ID() uint16 #75300
-pkg crypto/hpke, type KDF interface, unexported methods #75300
-pkg crypto/hpke, type KEM interface, DeriveKeyPair([]uint8) (PrivateKey, error) #75300
-pkg crypto/hpke, type KEM interface, GenerateKey() (PrivateKey, error) #75300
-pkg crypto/hpke, type KEM interface, ID() uint16 #75300
-pkg crypto/hpke, type KEM interface, NewPrivateKey([]uint8) (PrivateKey, error) #75300
-pkg crypto/hpke, type KEM interface, NewPublicKey([]uint8) (PublicKey, error) #75300
-pkg crypto/hpke, type KEM interface, unexported methods #75300
-pkg crypto/hpke, type PrivateKey interface, Bytes() ([]uint8, error) #75300
-pkg crypto/hpke, type PrivateKey interface, KEM() KEM #75300
-pkg crypto/hpke, type PrivateKey interface, PublicKey() PublicKey #75300
-pkg crypto/hpke, type PrivateKey interface, unexported methods #75300
-pkg crypto/hpke, type PublicKey interface, Bytes() []uint8 #75300
-pkg crypto/hpke, type PublicKey interface, KEM() KEM #75300
-pkg crypto/hpke, type PublicKey interface, unexported methods #75300
-pkg crypto/hpke, type Recipient struct #75300
-pkg crypto/hpke, type Sender struct #75300
-pkg crypto/mlkem, method (*DecapsulationKey1024) Encapsulator() crypto.Encapsulator #75300
-pkg crypto/mlkem, method (*DecapsulationKey768) Encapsulator() crypto.Encapsulator #75300
-pkg crypto/mlkem/mlkemtest, func Encapsulate1024(*mlkem.EncapsulationKey1024, []uint8) ([]uint8, []uint8, error) #73627
-pkg crypto/mlkem/mlkemtest, func Encapsulate768(*mlkem.EncapsulationKey768, []uint8) ([]uint8, []uint8, error) #73627
-pkg crypto/rsa, func DecryptPKCS1v15 //deprecated #75302
-pkg crypto/rsa, func DecryptPKCS1v15SessionKey //deprecated #75302
-pkg crypto/rsa, func EncryptOAEPWithOptions(io.Reader, *PublicKey, []uint8, *OAEPOptions) ([]uint8, error) #65716
-pkg crypto/rsa, func EncryptPKCS1v15 //deprecated #75302
-pkg crypto/rsa, type PKCS1v15DecryptOptions //deprecated #75302
-pkg crypto/tls, const QUICErrorEvent = 10 #75108
-pkg crypto/tls, const QUICErrorEvent QUICEventKind #75108
-pkg crypto/tls, const SecP256r1MLKEM768 = 4587 #71206
-pkg crypto/tls, const SecP256r1MLKEM768 CurveID #71206
-pkg crypto/tls, const SecP384r1MLKEM1024 = 4589 #71206
-pkg crypto/tls, const SecP384r1MLKEM1024 CurveID #71206
-pkg crypto/tls, type ClientHelloInfo struct, HelloRetryRequest bool #74425
-pkg crypto/tls, type ConnectionState struct, HelloRetryRequest bool #74425
-pkg crypto/tls, type QUICEvent struct, Err error #75108
-pkg crypto/x509, func OIDFromASN1OID(asn1.ObjectIdentifier) (OID, error) #75325
-pkg crypto/x509, method (ExtKeyUsage) OID() OID #75325
-pkg crypto/x509, method (ExtKeyUsage) String() string #56866
-pkg crypto/x509, method (KeyUsage) String() string #56866
-pkg debug/elf, const R_LARCH_CALL36 = 110 #75562
-pkg debug/elf, const R_LARCH_CALL36 R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_DESC32 = 13 #75562
-pkg debug/elf, const R_LARCH_TLS_DESC32 R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_DESC64 = 14 #75562
-pkg debug/elf, const R_LARCH_TLS_DESC64 R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_DESC64_HI12 = 118 #75562
-pkg debug/elf, const R_LARCH_TLS_DESC64_HI12 R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_DESC64_LO20 = 117 #75562
-pkg debug/elf, const R_LARCH_TLS_DESC64_LO20 R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_DESC64_PC_HI12 = 114 #75562
-pkg debug/elf, const R_LARCH_TLS_DESC64_PC_HI12 R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_DESC64_PC_LO20 = 113 #75562
-pkg debug/elf, const R_LARCH_TLS_DESC64_PC_LO20 R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_DESC_CALL = 120 #75562
-pkg debug/elf, const R_LARCH_TLS_DESC_CALL R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_DESC_HI20 = 115 #75562
-pkg debug/elf, const R_LARCH_TLS_DESC_HI20 R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_DESC_LD = 119 #75562
-pkg debug/elf, const R_LARCH_TLS_DESC_LD R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_DESC_LO12 = 116 #75562
-pkg debug/elf, const R_LARCH_TLS_DESC_LO12 R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_DESC_PCREL20_S2 = 126 #75562
-pkg debug/elf, const R_LARCH_TLS_DESC_PCREL20_S2 R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_DESC_PC_HI20 = 111 #75562
-pkg debug/elf, const R_LARCH_TLS_DESC_PC_HI20 R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_DESC_PC_LO12 = 112 #75562
-pkg debug/elf, const R_LARCH_TLS_DESC_PC_LO12 R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_GD_PCREL20_S2 = 125 #75562
-pkg debug/elf, const R_LARCH_TLS_GD_PCREL20_S2 R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_LD_PCREL20_S2 = 124 #75562
-pkg debug/elf, const R_LARCH_TLS_LD_PCREL20_S2 R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_LE_ADD_R = 122 #75562
-pkg debug/elf, const R_LARCH_TLS_LE_ADD_R R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_LE_HI20_R = 121 #75562
-pkg debug/elf, const R_LARCH_TLS_LE_HI20_R R_LARCH #75562
-pkg debug/elf, const R_LARCH_TLS_LE_LO12_R = 123 #75562
-pkg debug/elf, const R_LARCH_TLS_LE_LO12_R R_LARCH #75562
-pkg errors, func AsType[$0 error](error) ($0, bool) #51945
-pkg go/ast, func ParseDirective(token.Pos, string) (Directive, bool) #68021
-pkg go/ast, method (*Directive) End() token.Pos #68021
-pkg go/ast, method (*Directive) ParseArgs() ([]DirectiveArg, error) #68021
-pkg go/ast, method (*Directive) Pos() token.Pos #68021
-pkg go/ast, type BasicLit struct, ValueEnd token.Pos #76031
-pkg go/ast, type Directive struct #68021
-pkg go/ast, type Directive struct, Args string #68021
-pkg go/ast, type Directive struct, ArgsPos token.Pos #68021
-pkg go/ast, type Directive struct, Name string #68021
-pkg go/ast, type Directive struct, Slash token.Pos #68021
-pkg go/ast, type Directive struct, Tool string #68021
-pkg go/ast, type DirectiveArg struct #68021
-pkg go/ast, type DirectiveArg struct, Arg string #68021
-pkg go/ast, type DirectiveArg struct, Pos token.Pos #68021
-pkg go/token, method (*File) End() Pos #75849
-pkg log/slog, func NewMultiHandler(...Handler) *MultiHandler #65954
-pkg log/slog, method (*MultiHandler) Enabled(context.Context, Level) bool #65954
-pkg log/slog, method (*MultiHandler) Handle(context.Context, Record) error #65954
-pkg log/slog, method (*MultiHandler) WithAttrs([]Attr) Handler #65954
-pkg log/slog, method (*MultiHandler) WithGroup(string) Handler #65954
-pkg log/slog, type MultiHandler struct #65954
-pkg net, method (*Dialer) DialIP(context.Context, string, netip.Addr, netip.Addr) (*IPConn, error) #49097
-pkg net, method (*Dialer) DialTCP(context.Context, string, netip.AddrPort, netip.AddrPort) (*TCPConn, error) #49097
-pkg net, method (*Dialer) DialUDP(context.Context, string, netip.AddrPort, netip.AddrPort) (*UDPConn, error) #49097
-pkg net, method (*Dialer) DialUnix(context.Context, string, *UnixAddr, *UnixAddr) (*UnixConn, error) #49097
-pkg net/http, method (*ClientConn) Available() int #75772
-pkg net/http, method (*ClientConn) Close() error #75772
-pkg net/http, method (*ClientConn) Err() error #75772
-pkg net/http, method (*ClientConn) InFlight() int #75772
-pkg net/http, method (*ClientConn) Release() #75772
-pkg net/http, method (*ClientConn) Reserve() error #75772
-pkg net/http, method (*ClientConn) RoundTrip(*Request) (*Response, error) #75772
-pkg net/http, method (*ClientConn) SetStateHook(func(*ClientConn)) #75772
-pkg net/http, method (*Transport) NewClientConn(context.Context, string, string) (*ClientConn, error) #75772
-pkg net/http, type ClientConn struct #75772
-pkg net/http, type HTTP2Config struct, StrictMaxConcurrentRequests bool #67813
-pkg net/http/httputil, type ReverseProxy struct, Director //deprecated #73161
-pkg net/netip, method (Prefix) Compare(Prefix) int #61642
-pkg os, method (*Process) WithHandle(func(uintptr)) error #70352
-pkg os, var ErrNoHandle error #70352
-pkg reflect, method (Value) Fields() iter.Seq2[StructField, Value] #66631
-pkg reflect, method (Value) Methods() iter.Seq2[Method, Value] #66631
-pkg reflect, type Type interface, Fields() iter.Seq[StructField] #66631
-pkg reflect, type Type interface, Ins() iter.Seq[Type] #66631
-pkg reflect, type Type interface, Methods() iter.Seq[Method] #66631
-pkg reflect, type Type interface, Outs() iter.Seq[Type] #66631
-pkg testing, method (*B) ArtifactDir() string #71287
-pkg testing, method (*F) ArtifactDir() string #71287
-pkg testing, method (*T) ArtifactDir() string #71287
-pkg testing, type TB interface, ArtifactDir() string #71287
-pkg testing/cryptotest, func SetGlobalRandom(*testing.T, uint64) #70942

api/go1.9.txt

@@ -7,6 +7,7 @@ pkg crypto, const BLAKE2b_512 Hash
 pkg crypto, const BLAKE2s_256 = 16
 pkg crypto, const BLAKE2s_256 Hash
 pkg crypto/x509, type Certificate struct, ExcludedDNSDomains []string
+pkg crypto/x509, type VerifyOptions struct, IsBoring func(*Certificate) bool
 pkg database/sql, method (*Conn) BeginTx(context.Context, *TxOptions) (*Tx, error)
 pkg database/sql, method (*Conn) Close() error
 pkg database/sql, method (*Conn) ExecContext(context.Context, string, ...interface{}) (Result, error)
@@ -49,34 +50,7 @@ pkg image/png, type EncoderBufferPool interface, Put(*EncoderBuffer)
 pkg math/big, method (*Int) IsInt64() bool
 pkg math/big, method (*Int) IsUint64() bool
 pkg math/big, type Word uint
-pkg math/bits (darwin-amd64), const UintSize = 64
-pkg math/bits (darwin-amd64-cgo), const UintSize = 64
-pkg math/bits (freebsd-386), const UintSize = 32
-pkg math/bits (freebsd-386-cgo), const UintSize = 32
-pkg math/bits (freebsd-amd64), const UintSize = 64
-pkg math/bits (freebsd-amd64-cgo), const UintSize = 64
-pkg math/bits (freebsd-arm), const UintSize = 32
-pkg math/bits (freebsd-arm-cgo), const UintSize = 32
-pkg math/bits (linux-386), const UintSize = 32
-pkg math/bits (linux-386-cgo), const UintSize = 32
-pkg math/bits (linux-amd64), const UintSize = 64
-pkg math/bits (linux-amd64-cgo), const UintSize = 64
-pkg math/bits (linux-arm), const UintSize = 32
-pkg math/bits (linux-arm-cgo), const UintSize = 32
-pkg math/bits (netbsd-386), const UintSize = 32
-pkg math/bits (netbsd-386-cgo), const UintSize = 32
-pkg math/bits (netbsd-amd64), const UintSize = 64
-pkg math/bits (netbsd-amd64-cgo), const UintSize = 64
-pkg math/bits (netbsd-arm), const UintSize = 32
-pkg math/bits (netbsd-arm-cgo), const UintSize = 32
-pkg math/bits (netbsd-arm64), const UintSize = 64
-pkg math/bits (netbsd-arm64-cgo), const UintSize = 64
-pkg math/bits (openbsd-386), const UintSize = 32
-pkg math/bits (openbsd-386-cgo), const UintSize = 32
-pkg math/bits (openbsd-amd64), const UintSize = 64
-pkg math/bits (openbsd-amd64-cgo), const UintSize = 64
-pkg math/bits (windows-386), const UintSize = 32
-pkg math/bits (windows-amd64), const UintSize = 64
+pkg math/bits, const UintSize = 64
 pkg math/bits, const UintSize ideal-int
 pkg math/bits, func LeadingZeros(uint) int
 pkg math/bits, func LeadingZeros16(uint16) int

codereview.cfg

@@ -1,2 +1 @@
-branch: dev.simd
-parent-branch: master
+branch: dev.boringcrypto.go1.17

doc/README.md

@@ -1,75 +0,0 @@
-# Release Notes
-
-The `initial` and `next` subdirectories of this directory are for release notes.
-
-## For developers
-
-Release notes should be added to `next` by editing existing files or creating
-new files. **Do not add RELNOTE=yes comments in CLs.** Instead, add a file to
-the CL (or ask the author to do so).
-
-At the end of the development cycle, the files will be merged by being
-concatenated in sorted order by pathname. Files in the directory matching the
-glob "*stdlib/*minor" are treated specially. They should be in subdirectories
-corresponding to standard library package paths, and headings for those package
-paths will be generated automatically.
-
-Files in this repo's `api/next` directory must have corresponding files in
-`doc/next/*stdlib/*minor`.
-The files should be in the subdirectory for the package with the new
-API, and should be named after the issue number of the API proposal.
-For example, if the directory `6-stdlib/99-minor` is present,
-then an `api/next` file with the line
-
-    pkg net/http, function F #12345
-
-should have a corresponding file named `doc/next/6-stdlib/99-minor/net/http/12345.md`.
-At a minimum, that file should contain either a full sentence or a TODO,
-ideally referring to a person with the responsibility to complete the note.
-
-If your CL addresses an accepted proposal, mention the proposal issue number in
-your release note in the form `/issue/NUMBER`. A link to the issue in the text
-will have this form (see below). If you don't want to mention the issue in the
-text, add it as a comment:
-```
-<!-- go.dev/issue/12345 -->
-```
-If an accepted proposal is mentioned in a CL but not in the release notes, it will be
-flagged as a TODO by the automated tooling. That is true even for proposals that add API.
-
-Use the following forms in your markdown:
-
-	[http.Request]                     # symbol documentation; auto-linked as in Go doc strings
-	[Request]                          # short form, for symbols in the package being documented
-	[net/http]                         # package link
-	[#12345](/issue/12345)             # GitHub issues
-	[CL 6789](/cl/6789)                # Gerrit changelists
-
-To preview `next` content in merged form using a local instance of the website, run:
-
-```
-go run golang.org/x/website/cmd/golangorg@latest -goroot=..
-```
-
-Then open http://localhost:6060/doc/next. Refresh the page to see your latest edits.
-
-## For the release team
-
-The `relnote` tool, at `golang.org/x/build/cmd/relnote`, operates on the files
-in `doc/next`.
-
-As a release cycle nears completion, run `relnote todo` to get a list of
-unfinished release note work.
-
-To prepare the release notes for a release, run `relnote generate`.
-That will merge the `.md` files in `next` into a single file.
-Atomically (as close to it as possible) add that file to `_content/doc` directory
-of the website repository and remove the `doc/next` directory in this repository.
-
-To begin the next release development cycle, populate the contents of `next`
-with those of `initial`. From the repo root:
-
-    > cd doc
-    > cp -R initial/ next
-
-Then edit `next/1-intro.md` to refer to the next version.

doc/asm.html

@@ -125,8 +125,8 @@ it is a distinct program, so there are some differences.
 One is in constant evaluation.
 Constant expressions in the assembler are parsed using Go's operator
 precedence, not the C-like precedence of the original.
-Thus <code>3&amp;1&lt;&lt;2</code> is 4, not 0—it parses as <code>(3&amp;1)&lt;&lt;2</code>
-not <code>3&amp;(1&lt;&lt;2)</code>.
+Thus <code>3&amp;1<<2</code> is 4, not 0—it parses as <code>(3&amp;1)<<2</code>
+not <code>3&amp;(1<<2)</code>.
 Also, constants are always evaluated as 64-bit unsigned integers.
 Thus <code>-2</code> is not the integer value minus two,
 but the unsigned 64-bit integer with the same bit pattern.
@@ -464,23 +464,6 @@ Function is the outermost frame of the call stack. Traceback should stop at this
 </li>
 </ul>
 
-<h3 id="special-instructions">Special instructions</h3>
-
-<p>
-The <code>PCALIGN</code> pseudo-instruction is used to indicate that the next instruction should be aligned
-to a specified boundary by padding with no-op instructions.
-</p>
-
-<p>
-It is currently supported on arm64, amd64, ppc64, loong64 and riscv64.
-
-For example, the start of the <code>MOVD</code> instruction below is aligned to 32 bytes:
-<pre>
-PCALIGN $32
-MOVD $2, R0
-</pre>
-</p>
-
 <h3 id="data-offsets">Interacting with Go types and constants</h3>
 
 <p>
@@ -931,6 +914,8 @@ This assembler is used by GOARCH values ppc64 and ppc64le.
 Reference: <a href="/pkg/cmd/internal/obj/ppc64">Go PPC64 Assembly Instructions Reference Manual</a>
 </p>
 
+</ul>
+
 <h3 id="s390x">IBM z/Architecture, a.k.a. s390x</h3>
 
 <p>
@@ -1039,12 +1024,6 @@ The value of <code>GOMIPS64</code> environment variable (<code>hardfloat</code>
 <code>GOMIPS64_hardfloat</code> or <code>GOMIPS64_softfloat</code>.
 </p>
 
-<h3 id="riscv64">RISCV64</h3>
-
-<p>
-Reference: <a href="/pkg/cmd/internal/obj/riscv">Go RISCV64 Assembly Instructions Reference Manual</a>
-</p>
-
 <h3 id="unsupported_opcodes">Unsupported opcodes</h3>
 
 <p>

doc/go_mem.html

@@ -1,6 +1,6 @@
 <!--{
 	"Title": "The Go Memory Model",
-	"Subtitle": "Version of June 6, 2022",
+	"Subtitle": "Version of May 31, 2014",
 	"Path": "/ref/mem"
 }-->
 
@@ -8,9 +8,12 @@
 p.rule {
   font-style: italic;
 }
+span.event {
+  font-style: italic;
+}
 </style>
 
-<h2 id="introduction">Introduction</h2>
+<h2>Introduction</h2>
 
 <p>
 The Go memory model specifies the conditions under which
@@ -19,7 +22,7 @@ observe values produced by writes to the same variable in a different goroutine.
 </p>
 
 
-<h3 id="advice">Advice</h3>
+<h2>Advice</h2>
 
 <p>
 Programs that modify data being simultaneously accessed by multiple goroutines
@@ -41,249 +44,90 @@ you are being too clever.
 Don't be clever.
 </p>
 
-<h3 id="overview">Informal Overview</h3>
+<h2>Happens Before</h2>
 
 <p>
-Go approaches its memory model in much the same way as the rest of the language,
-aiming to keep the semantics simple, understandable, and useful.
-This section gives a general overview of the approach and should suffice for most programmers.
-The memory model is specified more formally in the next section.
+Within a single goroutine, reads and writes must behave
+as if they executed in the order specified by the program.
+That is, compilers and processors may reorder the reads and writes
+executed within a single goroutine only when the reordering
+does not change the behavior within that goroutine
+as defined by the language specification.
+Because of this reordering, the execution order observed
+by one goroutine may differ from the order perceived
+by another.  For example, if one goroutine
+executes <code>a = 1; b = 2;</code>, another might observe
+the updated value of <code>b</code> before the updated value of <code>a</code>.
 </p>
 
 <p>
-A <em>data race</em> is defined as
-a write to a memory location happening concurrently with another read or write to that same location,
-unless all the accesses involved are atomic data accesses as provided by the <code>sync/atomic</code> package.
-As noted already, programmers are strongly encouraged to use appropriate synchronization
-to avoid data races.
-In the absence of data races, Go programs behave as if all the goroutines
-were multiplexed onto a single processor.
-This property is sometimes referred to as DRF-SC: data-race-free programs
-execute in a sequentially consistent manner.
+To specify the requirements of reads and writes, we define
+<i>happens before</i>, a partial order on the execution
+of memory operations in a Go program.  If event <span class="event">e<sub>1</sub></span> happens
+before event <span class="event">e<sub>2</sub></span>, then we say that <span class="event">e<sub>2</sub></span> happens after <span class="event">e<sub>1</sub></span>.
+Also, if <span class="event">e<sub>1</sub></span> does not happen before <span class="event">e<sub>2</sub></span> and does not happen
+after <span class="event">e<sub>2</sub></span>, then we say that <span class="event">e<sub>1</sub></span> and <span class="event">e<sub>2</sub></span> happen concurrently.
+</p>
+
+<p class="rule">
+Within a single goroutine, the happens-before order is the
+order expressed by the program.
 </p>
 
 <p>
-While programmers should write Go programs without data races,
-there are limitations to what a Go implementation can do in response to a data race.
-An implementation may always react to a data race by reporting the race and terminating the program.
-Otherwise, each read of a single-word-sized or sub-word-sized memory location
-must observe a value actually written to that location (perhaps by a concurrent executing goroutine)
-and not yet overwritten.
-These implementation constraints make Go more like Java or JavaScript,
-in that most races have a limited number of outcomes,
-and less like C and C++, where the meaning of any program with a race
-is entirely undefined, and the compiler may do anything at all.
-Go's approach aims to make errant programs more reliable and easier to debug,
-while still insisting that races are errors and that tools can diagnose and report them.
-</p>
-
-<h2 id="model">Memory Model</h2>
-
-<p>
-The following formal definition of Go's memory model closely follows
-the approach presented by Hans-J. Boehm and Sarita V. Adve in
-“<a href="https://dl.acm.org/doi/10.1145/1375581.1375591">Foundations of the C++ Concurrency Memory Model</a>”,
-published in PLDI 2008.
-The definition of data-race-free programs and the guarantee of sequential consistency
-for race-free programs are equivalent to the ones in that work.
-</p>
-
-<p>
-The memory model describes the requirements on program executions,
-which are made up of goroutine executions,
-which in turn are made up of memory operations.
-</p>
-
-<p>
-A <i>memory operation</i> is modeled by four details:
-</p>
-<ul>
-	<li>its kind, indicating whether it is an ordinary data read, an ordinary data write,
-    or a <i>synchronizing operation</i> such as an atomic data access,
-	a mutex operation, or a channel operation,</li>
-	<li>its location in the program,</li>
-	<li>the memory location or variable being accessed, and</li>
-	<li>the values read or written by the operation.</li>
-</ul>
-<p>
-Some memory operations are <i>read-like</i>, including read, atomic read, mutex lock, and channel receive.
-Other memory operations are <i>write-like</i>, including write, atomic write, mutex unlock, channel send, and channel close.
-Some, such as atomic compare-and-swap, are both read-like and write-like.
-</p>
-
-<p>
-A <i>goroutine execution</i> is modeled as a set of memory operations executed by a single goroutine.
-</p>
-
-<p>
-<b>Requirement 1</b>:
-The memory operations in each goroutine must correspond to a correct sequential execution of that goroutine,
-given the values read from and written to memory.
-That execution must be consistent with the <i>sequenced before</i> relation,
-defined as the partial order requirements set out by the <a href="/ref/spec">Go language specification</a>
-for Go's control flow constructs as well as the <a href="/ref/spec#Order_of_evaluation">order of evaluation for expressions</a>.
-</p>
-
-<p>
-A Go <i>program execution</i> is modeled as a set of goroutine executions,
-together with a mapping <i>W</i> that specifies the write-like operation that each read-like operation reads from.
-(Multiple executions of the same program can have different program executions.)
-</p>
-
-<p>
-<b>Requirement 2</b>:
-For a given program execution, the mapping <i>W</i>, when limited to synchronizing operations,
-must be explainable by some implicit total order of the synchronizing operations
-that is consistent with sequencing and the values read and written by those operations.
-</p>
-
-<p>
-The <i>synchronized before</i> relation is a partial order on synchronizing memory operations,
-derived from <i>W</i>.
-If a synchronizing read-like memory operation <i>r</i>
-observes a synchronizing write-like memory operation <i>w</i>
-(that is, if <i>W</i>(<i>r</i>) = <i>w</i>),
-then <i>w</i> is synchronized before <i>r</i>.
-Informally, the synchronized before relation is a subset of the implied total order
-mentioned in the previous paragraph,
-limited to the information that <i>W</i> directly observes.
-</p>
-
-<p>
-The <i>happens before</i> relation is defined as the transitive closure of the
-union of the sequenced before and synchronized before relations.
-</p>
-
-<p>
-<b>Requirement 3</b>:
-For an ordinary (non-synchronizing) data read <i>r</i> on a memory location <i>x</i>,
-<i>W</i>(<i>r</i>) must be a write <i>w</i> that is <i>visible</i> to <i>r</i>,
-where visible means that both of the following hold:
+A read <span class="event">r</span> of a variable <code>v</code> is <i>allowed</i> to observe a write <span class="event">w</span> to <code>v</code>
+if both of the following hold:
 </p>
 
 <ol>
-	<li><i>w</i> happens before <i>r</i>.</li>
-	<li><i>w</i> does not happen before any other write <i>w'</i> (to <i>x</i>) that happens before <i>r</i>.</li>
+<li><span class="event">r</span> does not happen before <span class="event">w</span>.</li>
+<li>There is no other write <span class="event">w'</span> to <code>v</code> that happens
+    after <span class="event">w</span> but before <span class="event">r</span>.</li>
 </ol>
 
 <p>
-A <i>read-write data race</i> on memory location <i>x</i>
-consists of a read-like memory operation <i>r</i> on <i>x</i>
-and a write-like memory operation <i>w</i> on <i>x</i>,
-at least one of which is non-synchronizing,
-which are unordered by happens before
-(that is, neither <i>r</i> happens before <i>w</i>
-nor <i>w</i> happens before <i>r</i>).
+To guarantee that a read <span class="event">r</span> of a variable <code>v</code> observes a
+particular write <span class="event">w</span> to <code>v</code>, ensure that <span class="event">w</span> is the only
+write <span class="event">r</span> is allowed to observe.
+That is, <span class="event">r</span> is <i>guaranteed</i> to observe <span class="event">w</span> if both of the following hold:
+</p>
+
+<ol>
+<li><span class="event">w</span> happens before <span class="event">r</span>.</li>
+<li>Any other write to the shared variable <code>v</code>
+either happens before <span class="event">w</span> or after <span class="event">r</span>.</li>
+</ol>
+
+<p>
+This pair of conditions is stronger than the first pair;
+it requires that there are no other writes happening
+concurrently with <span class="event">w</span> or <span class="event">r</span>.
 </p>
 
 <p>
-A <i>write-write data race</i> on memory location <i>x</i>
-consists of two write-like memory operations <i>w</i> and <i>w'</i> on <i>x</i>,
-at least one of which is non-synchronizing,
-which are unordered by happens before.
+Within a single goroutine,
+there is no concurrency, so the two definitions are equivalent:
+a read <span class="event">r</span> observes the value written by the most recent write <span class="event">w</span> to <code>v</code>.
+When multiple goroutines access a shared variable <code>v</code>,
+they must use synchronization events to establish
+happens-before conditions that ensure reads observe the
+desired writes.
 </p>
 
 <p>
-Note that if there are no read-write or write-write data races on memory location <i>x</i>,
-then any read <i>r</i> on <i>x</i> has only one possible <i>W</i>(<i>r</i>):
-the single <i>w</i> that immediately precedes it in the happens before order.
+The initialization of variable <code>v</code> with the zero value
+for <code>v</code>'s type behaves as a write in the memory model.
 </p>
 
 <p>
-More generally, it can be shown that any Go program that is data-race-free,
-meaning it has no program executions with read-write or write-write data races,
-can only have outcomes explained by some sequentially consistent interleaving
-of the goroutine executions.
-(The proof is the same as Section 7 of Boehm and Adve's paper cited above.)
-This property is called DRF-SC.
+Reads and writes of values larger than a single machine word
+behave as multiple machine-word-sized operations in an
+unspecified order.
 </p>
 
-<p>
-The intent of the formal definition is to match
-the DRF-SC guarantee provided to race-free programs
-by other languages, including C, C++, Java, JavaScript, Rust, and Swift.
-</p>
+<h2>Synchronization</h2>
 
-<p>
-Certain Go language operations such as goroutine creation and memory allocation
-act as synchronization operations.
-The effect of these operations on the synchronized-before partial order
-is documented in the “Synchronization” section below.
-Individual packages are responsible for providing similar documentation
-for their own operations.
-</p>
-
-<h2 id="restrictions">Implementation Restrictions for Programs Containing Data Races</h2>
-
-<p>
-The preceding section gave a formal definition of data-race-free program execution.
-This section informally describes the semantics that implementations must provide
-for programs that do contain races.
-</p>
-
-<p>
-Any implementation can, upon detecting a data race,
-report the race and halt execution of the program.
-Implementations using ThreadSanitizer
-(accessed with “<code>go</code> <code>build</code> <code>-race</code>”)
-do exactly this.
-</p>
-
-<p>
-A read of an array, struct, or complex number
-may be implemented as a read of each individual sub-value
-(array element, struct field, or real/imaginary component),
-in any order.
-Similarly, a write of an array, struct, or complex number
-may be implemented as a write of each individual sub-value,
-in any order.
-</p>
-
-<p>
-A read <i>r</i> of a memory location <i>x</i>
-holding a value
-that is not larger than a machine word must observe
-some write <i>w</i> such that <i>r</i> does not happen before <i>w</i>
-and there is no write <i>w'</i> such that <i>w</i> happens before <i>w'</i>
-and <i>w'</i> happens before <i>r</i>.
-That is, each read must observe a value written by a preceding or concurrent write.
-</p>
-
-<p>
-Additionally, observation of acausal and “out of thin air” writes is disallowed.
-</p>
-
-<p>
-Reads of memory locations larger than a single machine word
-are encouraged but not required to meet the same semantics
-as word-sized memory locations,
-observing a single allowed write <i>w</i>.
-For performance reasons,
-implementations may instead treat larger operations
-as a set of individual machine-word-sized operations
-in an unspecified order.
-This means that races on multiword data structures
-can lead to inconsistent values not corresponding to a single write.
-When the values depend on the consistency
-of internal (pointer, length) or (pointer, type) pairs,
-as can be the case for interface values, maps,
-slices, and strings in most Go implementations,
-such races can in turn lead to arbitrary memory corruption.
-</p>
-
-<p>
-Examples of incorrect synchronization are given in the
-“Incorrect synchronization” section below.
-</p>
-
-<p>
-Examples of the limitations on implementations are given in the
-“Incorrect compilation” section below.
-</p>
-
-<h2 id="synchronization">Synchronization</h2>
-
-<h3 id="init">Initialization</h3>
+<h3>Initialization</h3>
 
 <p>
 Program initialization runs in a single goroutine,
@@ -297,15 +141,15 @@ If a package <code>p</code> imports package <code>q</code>, the completion of
 </p>
 
 <p class="rule">
-The completion of all <code>init</code> functions is synchronized before
-the start of the function <code>main.main</code>.
+The start of the function <code>main.main</code> happens after
+all <code>init</code> functions have finished.
 </p>
 
-<h3 id="go">Goroutine creation</h3>
+<h3>Goroutine creation</h3>
 
 <p class="rule">
 The <code>go</code> statement that starts a new goroutine
-is synchronized before the start of the goroutine's execution.
+happens before the goroutine's execution begins.
 </p>
 
 <p>
@@ -330,12 +174,11 @@ calling <code>hello</code> will print <code>"hello, world"</code>
 at some point in the future (perhaps after <code>hello</code> has returned).
 </p>
 
-<h3 id="goexit">Goroutine destruction</h3>
+<h3>Goroutine destruction</h3>
 
 <p>
-The exit of a goroutine is not guaranteed to be synchronized before
-any event in the program.
-For example, in this program:
+The exit of a goroutine is not guaranteed to happen before
+any event in the program.  For example, in this program:
 </p>
 
 <pre>
@@ -360,7 +203,7 @@ use a synchronization mechanism such as a lock or channel
 communication to establish a relative ordering.
 </p>
 
-<h3 id="chan">Channel communication</h3>
+<h3>Channel communication</h3>
 
 <p>
 Channel communication is the main method of synchronization
@@ -370,8 +213,8 @@ usually in a different goroutine.
 </p>
 
 <p class="rule">
-A send on a channel is synchronized before the completion of the
-corresponding receive from that channel.
+A send on a channel happens before the corresponding
+receive from that channel completes.
 </p>
 
 <p>
@@ -396,13 +239,13 @@ func main() {
 
 <p>
 is guaranteed to print <code>"hello, world"</code>.  The write to <code>a</code>
-is sequenced before the send on <code>c</code>, which is synchronized before
-the corresponding receive on <code>c</code> completes, which is sequenced before
+happens before the send on <code>c</code>, which happens before
+the corresponding receive on <code>c</code> completes, which happens before
 the <code>print</code>.
 </p>
 
 <p class="rule">
-The closing of a channel is synchronized before a receive that returns a zero value
+The closing of a channel happens before a receive that returns a zero value
 because the channel is closed.
 </p>
 
@@ -413,8 +256,8 @@ yields a program with the same guaranteed behavior.
 </p>
 
 <p class="rule">
-A receive from an unbuffered channel is synchronized before the completion of
-the corresponding send on that channel.
+A receive from an unbuffered channel happens before
+the send on that channel completes.
 </p>
 
 <p>
@@ -440,8 +283,8 @@ func main() {
 
 <p>
 is also guaranteed to print <code>"hello, world"</code>.  The write to <code>a</code>
-is sequenced before the receive on <code>c</code>, which is synchronized before
-the corresponding send on <code>c</code> completes, which is sequenced
+happens before the receive on <code>c</code>, which happens before
+the corresponding send on <code>c</code> completes, which happens
 before the <code>print</code>.
 </p>
 
@@ -453,7 +296,7 @@ crash, or do something else.)
 </p>
 
 <p class="rule">
-The <i>k</i>th receive from a channel with capacity <i>C</i> is synchronized before the completion of the <i>k</i>+<i>C</i>th send on that channel.
+The <i>k</i>th receive on a channel with capacity <i>C</i> happens before the <i>k</i>+<i>C</i>th send from that channel completes.
 </p>
 
 <p>
@@ -487,7 +330,7 @@ func main() {
 }
 </pre>
 
-<h3 id="locks">Locks</h3>
+<h3>Locks</h3>
 
 <p>
 The <code>sync</code> package implements two lock data types,
@@ -496,7 +339,7 @@ The <code>sync</code> package implements two lock data types,
 
 <p class="rule">
 For any <code>sync.Mutex</code> or <code>sync.RWMutex</code> variable <code>l</code> and <i>n</i> &lt; <i>m</i>,
-call <i>n</i> of <code>l.Unlock()</code> is synchronized before call <i>m</i> of <code>l.Lock()</code> returns.
+call <i>n</i> of <code>l.Unlock()</code> happens before call <i>m</i> of <code>l.Lock()</code> returns.
 </p>
 
 <p>
@@ -522,29 +365,19 @@ func main() {
 
 <p>
 is guaranteed to print <code>"hello, world"</code>.
-The first call to <code>l.Unlock()</code> (in <code>f</code>) is synchronized
+The first call to <code>l.Unlock()</code> (in <code>f</code>) happens
 before the second call to <code>l.Lock()</code> (in <code>main</code>) returns,
-which is sequenced before the <code>print</code>.
+which happens before the <code>print</code>.
 </p>
 
 <p class="rule">
 For any call to <code>l.RLock</code> on a <code>sync.RWMutex</code> variable <code>l</code>,
-there is an <i>n</i> such that the <i>n</i>th call to <code>l.Unlock</code>
-is synchronized before the return from <code>l.RLock</code>,
-and the matching call to <code>l.RUnlock</code> is synchronized before the return from call <i>n</i>+1 to <code>l.Lock</code>.
+there is an <i>n</i> such that the <code>l.RLock</code> happens (returns) after call <i>n</i> to
+<code>l.Unlock</code> and the matching <code>l.RUnlock</code> happens
+before call <i>n</i>+1 to <code>l.Lock</code>.
 </p>
 
-<p class="rule">
-A successful call to <code>l.TryLock</code> (or <code>l.TryRLock</code>)
-is equivalent to a call to <code>l.Lock</code> (or <code>l.RLock</code>).
-An unsuccessful call has no synchronizing effect at all.
-As far as the memory model is concerned,
-<code>l.TryLock</code> (or <code>l.TryRLock</code>)
-may be considered to be able to return false
-even when the mutex <i>l</i> is unlocked.
-</p>
-
-<h3 id="once">Once</h3>
+<h3>Once</h3>
 
 <p>
 The <code>sync</code> package provides a safe mechanism for
@@ -556,8 +389,7 @@ until <code>f()</code> has returned.
 </p>
 
 <p class="rule">
-The completion of a single call of <code>f()</code> from <code>once.Do(f)</code>
-is synchronized before the return of any call of <code>once.Do(f)</code>.
+A single call of <code>f()</code> from <code>once.Do(f)</code> happens (returns) before any call of <code>once.Do(f)</code> returns.
 </p>
 
 <p>
@@ -592,60 +424,13 @@ The result will be that <code>"hello, world"</code> will be printed
 twice.
 </p>
 
-<h3 id="atomic">Atomic Values</h3>
+<h2>Incorrect synchronization</h2>
 
 <p>
-The APIs in the <a href="/pkg/sync/atomic/"><code>sync/atomic</code></a>
-package are collectively “atomic operations”
-that can be used to synchronize the execution of different goroutines.
-If the effect of an atomic operation <i>A</i> is observed by atomic operation <i>B</i>,
-then <i>A</i> is synchronized before <i>B</i>.
-All the atomic operations executed in a program behave as though executed
-in some sequentially consistent order.
-</p>
-
-<p>
-The preceding definition has the same semantics as C++’s sequentially consistent atomics
-and Java’s <code>volatile</code> variables.
-</p>
-
-<h3 id="finalizer">Finalizers</h3>
-
-<p>
-The <a href="/pkg/runtime/"><code>runtime</code></a> package provides
-a <code>SetFinalizer</code> function that adds a finalizer to be called when
-a particular object is no longer reachable by the program.
-A call to <code>SetFinalizer(x, f)</code> is synchronized before the finalization call <code>f(x)</code>.
-</p>
-
-<h3 id="more">Additional Mechanisms</h3>
-
-<p>
-The <code>sync</code> package provides additional synchronization abstractions,
-including <a href="/pkg/sync/#Cond">condition variables</a>,
-<a href="/pkg/sync/#Map">lock-free maps</a>,
-<a href="/pkg/sync/#Pool">allocation pools</a>,
-and
-<a href="/pkg/sync/#WaitGroup">wait groups</a>.
-The documentation for each of these specifies the guarantees it
-makes concerning synchronization.
-</p>
-
-<p>
-Other packages that provide synchronization abstractions
-should document the guarantees they make too.
-</p>
-
-
-<h2 id="badsync">Incorrect synchronization</h2>
-
-<p>
-Programs with races are incorrect and
-can exhibit non-sequentially consistent executions.
-In particular, note that a read <i>r</i> may observe the value written by any write <i>w</i>
-that executes concurrently with <i>r</i>.
-Even if this occurs, it does not imply that reads happening after <i>r</i>
-will observe writes that happened before <i>w</i>.
+Note that a read <span class="event">r</span> may observe the value written by a write <span class="event">w</span>
+that happens concurrently with <span class="event">r</span>.
+Even if this occurs, it does not imply that reads happening after <span class="event">r</span>
+will observe writes that happened before <span class="event">w</span>.
 </p>
 
 <p>
@@ -781,197 +566,3 @@ value for <code>g.msg</code>.
 In all these examples, the solution is the same:
 use explicit synchronization.
 </p>
-
-<h2 id="badcompiler">Incorrect compilation</h2>
-
-<p>
-The Go memory model restricts compiler optimizations as much as it does Go programs.
-Some compiler optimizations that would be valid in single-threaded programs are not valid in all Go programs.
-In particular, a compiler must not introduce writes that do not exist in the original program,
-it must not allow a single read to observe multiple values,
-and it must not allow a single write to write multiple values.
-</p>
-
-<p>
-All the following examples assume that `*p` and `*q` refer to
-memory locations accessible to multiple goroutines.
-</p>
-
-<p>
-Not introducing data races into race-free programs means not moving
-writes out of conditional statements in which they appear.
-For example, a compiler must not invert the conditional in this program:
-</p>
-
-<pre>
-*p = 1
-if cond {
-	*p = 2
-}
-</pre>
-
-<p>
-That is, the compiler must not rewrite the program into this one:
-</p>
-
-<pre>
-*p = 2
-if !cond {
-	*p = 1
-}
-</pre>
-
-<p>
-If <code>cond</code> is false and another goroutine is reading <code>*p</code>,
-then in the original program, the other goroutine can only observe any prior value of <code>*p</code> and <code>1</code>.
-In the rewritten program, the other goroutine can observe <code>2</code>, which was previously impossible.
-</p>
-
-<p>
-Not introducing data races also means not assuming that loops terminate.
-For example, a compiler must in general not move the accesses to <code>*p</code> or <code>*q</code>
-ahead of the loop in this program:
-</p>
-
-<pre>
-n := 0
-for e := list; e != nil; e = e.next {
-	n++
-}
-i := *p
-*q = 1
-</pre>
-
-<p>
-If <code>list</code> pointed to a cyclic list,
-then the original program would never access <code>*p</code> or <code>*q</code>,
-but the rewritten program would.
-(Moving `*p` ahead would be safe if the compiler can prove `*p` will not panic;
-moving `*q` ahead would also require the compiler proving that no other
-goroutine can access `*q`.)
-</p>
-
-<p>
-Not introducing data races also means not assuming that called functions
-always return or are free of synchronization operations.
-For example, a compiler must not move the accesses to <code>*p</code> or <code>*q</code>
-ahead of the function call in this program
-(at least not without direct knowledge of the precise behavior of <code>f</code>):
-</p>
-
-<pre>
-f()
-i := *p
-*q = 1
-</pre>
-
-<p>
-If the call never returned, then once again the original program
-would never access <code>*p</code> or <code>*q</code>, but the rewritten program would.
-And if the call contained synchronizing operations, then the original program
-could establish happens before edges preceding the accesses
-to <code>*p</code> and <code>*q</code>, but the rewritten program would not.
-</p>
-
-<p>
-Not allowing a single read to observe multiple values means
-not reloading local variables from shared memory.
-For example, a compiler must not discard <code>i</code> and reload it
-a second time from <code>*p</code> in this program:
-</p>
-
-<pre>
-i := *p
-if i &lt; 0 || i &gt;= len(funcs) {
-	panic("invalid function index")
-}
-... complex code ...
-// compiler must NOT reload i = *p here
-funcs[i]()
-</pre>
-
-<p>
-If the complex code needs many registers, a compiler for single-threaded programs
-could discard <code>i</code> without saving a copy and then reload
-<code>i = *p</code> just before
-<code>funcs[i]()</code>.
-A Go compiler must not, because the value of <code>*p</code> may have changed.
-(Instead, the compiler could spill <code>i</code> to the stack.)
-</p>
-
-<p>
-Not allowing a single write to write multiple values also means not using
-the memory where a local variable will be written as temporary storage before the write.
-For example, a compiler must not use <code>*p</code> as temporary storage in this program:
-</p>
-
-<pre>
-*p = i + *p/2
-</pre>
-
-<p>
-That is, it must not rewrite the program into this one:
-</p>
-
-<pre>
-*p /= 2
-*p += i
-</pre>
-
-<p>
-If <code>i</code> and <code>*p</code> start equal to 2,
-the original code does <code>*p = 3</code>,
-so a racing thread can read only 2 or 3 from <code>*p</code>.
-The rewritten code does <code>*p = 1</code> and then <code>*p = 3</code>,
-allowing a racing thread to read 1 as well.
-</p>
-
-<p>
-Note that all these optimizations are permitted in C/C++ compilers:
-a Go compiler sharing a back end with a C/C++ compiler must take care
-to disable optimizations that are invalid for Go.
-</p>
-
-<p>
-Note that the prohibition on introducing data races
-does not apply if the compiler can prove that the races
-do not affect correct execution on the target platform.
-For example, on essentially all CPUs, it is valid to rewrite
-</p>
-
-<pre>
-n := 0
-for i := 0; i < m; i++ {
-	n += *shared
-}
-</pre>
-
-into:
-
-<pre>
-n := 0
-local := *shared
-for i := 0; i < m; i++ {
-	n += local
-}
-</pre>
-
-<p>
-provided it can be proved that <code>*shared</code> will not fault on access,
-because the potential added read will not affect any existing concurrent reads or writes.
-On the other hand, the rewrite would not be valid in a source-to-source translator.
-</p>
-
-<h2 id="conclusion">Conclusion</h2>
-
-<p>
-Go programmers writing data-race-free programs can rely on
-sequentially consistent execution of those programs,
-just as in essentially all other modern programming languages.
-</p>
-
-<p>
-When it comes to programs with races,
-both programmers and compilers should remember the advice:
-don't be clever.
-</p>

doc/godebug.md

@@ -1,519 +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.
-Unrecognized settings in the `GODEBUG` environment variable are ignored.
-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, starting in Go 1.23, the work module's `go.mod`
-or the workspace's `go.work` can list one or more `godebug` lines:
-
-	godebug (
-		default=go1.21
-		panicnil=1
-		asynctimerchan=0
-	)
-
-The special key `default` indicates a Go version to take unspecified
-settings from. This allows setting the GODEBUG defaults separately
-from the Go language version in the module.
-In this example, the program is asking for Go 1.21 semantics and
-then asking for the old pre-Go 1.21 `panic(nil)` behavior and the
-new Go 1.23 `asynctimerchan=0` behavior.
-
-Only the work module's `go.mod` is consulted for `godebug` directives.
-Any directives in required dependency modules are ignored.
-It is an error to list a `godebug` with an unrecognized setting.
-(Toolchains older than Go 1.23 reject all `godebug` lines, since they do not
-understand `godebug` at all.) When a workspace is in use, `godebug`
-directives in `go.mod` files are ignored, and `go.work` will be consulted
-for `godebug` directives instead.
-
-The defaults from the `go` and `godebug` lines apply to all main
-packages that are built. For more fine-grained control,
-starting in Go 1.21, a main package's source files
-can include one or more `//go:debug` directives at the top of the file
-(preceding the `package` statement).
-The `godebug` lines in the previous example would be written:
-
-	//go:debug default=go1.21
-	//go:debug panicnil=1
-	//go:debug asynctimerchan=0
-
-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.26
-
-Go 1.26 added a new `httpcookiemaxnum` setting that controls the maximum number
-of cookies that net/http will accept when parsing HTTP headers. If the number of
-cookie in a header exceeds the number set in `httpcookiemaxnum`, cookie parsing
-will fail early. The default value is `httpcookiemaxnum=3000`. Setting
-`httpcookiemaxnum=0` will allow the cookie parsing to accept an indefinite
-number of cookies. To avoid denial of service attacks, this setting and default
-was backported to Go 1.25.2 and Go 1.24.8.
-
-Go 1.26 added a new `urlstrictcolons` setting that controls whether `net/url.Parse`
-allows malformed hostnames containing colons outside of a bracketed IPv6 address.
-The default `urlstrictcolons=1` rejects URLs such as `http://localhost:1:2` or `http://::1/`.
-Colons are permitted as part of a bracketed IPv6 address, such as `http://[::1]/`.
-
-Go 1.26 enabled two additional post-quantum key exchange mechanisms:
-SecP256r1MLKEM768 and SecP384r1MLKEM1024. The default can be reverted using the
-[`tlssecpmlkem` setting](/pkg/crypto/tls/#Config.CurvePreferences).
-
-Go 1.26 added a new `tracebacklabels` setting that controls the inclusion of
-goroutine labels set through the the `runtime/pprof` package. Setting `tracebacklabels=1`
-includes these key/value pairs in the goroutine status header of runtime
-tracebacks and debug=2 runtime/pprof stack dumps. This format may change in the future.
-(see go.dev/issue/76349)
-
-Go 1.26 added a new `cryptocustomrand` setting that controls whether most crypto/...
-APIs ignore the random `io.Reader` parameter. For Go 1.26, it defaults
-to `cryptocustomrand=0`, ignoring the random parameters. Using `cryptocustomrand=1`
-reverts to the pre-Go 1.26 behavior.
-
-### Go 1.25
-
-Go 1.25 added a new `decoratemappings` setting that controls whether the Go
-runtime annotates OS anonymous memory mappings with context about their
-purpose. These annotations appear in /proc/self/maps and /proc/self/smaps as
-"[anon: Go: ...]". This setting is only used on Linux. For Go 1.25, it defaults
-to `decoratemappings=1`, enabling annotations. Using `decoratemappings=0`
-reverts to the pre-Go 1.25 behavior. This setting is fixed at program startup
-time, and can't be modified by changing the `GODEBUG` environment variable
-after the program starts.
-
-Go 1.25 added a new `embedfollowsymlinks` setting that controls whether the
-Go command will follow symlinks to regular files embedding files.
-The default value `embedfollowsymlinks=0` does not allow following
-symlinks. `embedfollowsymlinks=1` will allow following symlinks.
-
-Go 1.25 added a new `containermaxprocs` setting that controls whether the Go
-runtime will consider cgroup CPU limits when setting the default GOMAXPROCS.
-The default value `containermaxprocs=1` will use cgroup limits in addition to
-the total logical CPU count and CPU affinity. `containermaxprocs=0` will
-disable consideration of cgroup limits. This setting only affects Linux.
-
-Go 1.25 added a new `updatemaxprocs` setting that controls whether the Go
-runtime will periodically update GOMAXPROCS for new CPU affinity or cgroup
-limits. The default value `updatemaxprocs=1` will enable periodic updates.
-`updatemaxprocs=0` will disable periodic updates.
-
-Go 1.25 disabled SHA-1 signature algorithms in TLS 1.2 according to RFC 9155.
-The default can be reverted using the `tlssha1=1` setting.
-
-Go 1.25 switched to SHA-256 to fill in missing SubjectKeyId in
-crypto/x509.CreateCertificate. The setting `x509sha256skid=0` reverts to SHA-1.
-
-Go 1.25 corrected the semantics of contention reports for runtime-internal locks,
-and so removed the [`runtimecontentionstacks` setting](/pkg/runtime#hdr-Environment_Variables).
-
-Go 1.25 (starting with Go 1.25 RC 2) disabled build information stamping when
-multiple VCS are detected due to concerns around VCS injection attacks. This
-behavior and setting was backported to Go 1.24.5 and Go 1.23.11. This behavior
-can be renabled with the setting `allowmultiplevcs=1`.
-
-### Go 1.24
-
-Go 1.24 added a new `fips140` setting that controls whether the Go
-Cryptographic Module operates in FIPS 140-3 mode.
-The possible values are:
-- "off": no special support for FIPS 140-3 mode. This is the default.
-- "on": the Go Cryptographic Module operates in FIPS 140-3 mode.
-- "only": like "on", but cryptographic algorithms not approved by
-  FIPS 140-3 return an error or panic.
-For more information, see [FIPS 140-3 Compliance](/doc/security/fips140).
-This setting is fixed at program startup time, and can't be modified
-by changing the `GODEBUG` environment variable after the program starts.
-
-Go 1.24 changed the global [`math/rand.Seed`](/pkg/math/rand/#Seed) to be a
-no-op. This behavior is controlled by the `randseednop` setting.
-For Go 1.24 it defaults to `randseednop=1`.
-Using `randseednop=0` reverts to the pre-Go 1.24 behavior.
-
-Go 1.24 added new values for the `multipathtcp` setting.
-The possible values for `multipathtcp` are now:
-- "0": disable MPTCP on dialers and listeners by default
-- "1": enable MPTCP on dialers and listeners by default
-- "2": enable MPTCP on listeners only by default
-- "3": enable MPTCP on dialers only by default
-
-For Go 1.24, it now defaults to multipathtcp="2", thus
-enabled by default on listeners. Using multipathtcp="0" reverts to the
-pre-Go 1.24 behavior.
-
-Go 1.24 changed the behavior of `go test -json` to emit build errors as JSON
-instead of text.
-These new JSON events are distinguished by new `Action` values,
-but can still cause problems with CI systems that aren't robust to these events.
-This behavior can be controlled with the `gotestjsonbuildtext` setting.
-Using `gotestjsonbuildtext=1` restores the 1.23 behavior.
-This setting will be removed in a future release, Go 1.28 at the earliest.
-
-Go 1.24 changed [`crypto/rsa`](/pkg/crypto/rsa) to require RSA keys to be at
-least 1024 bits. This behavior can be controlled with the `rsa1024min` setting.
-Using `rsa1024min=0` restores the Go 1.23 behavior.
-
-Go 1.24 introduced a mechanism for enabling platform specific Data Independent
-Timing (DIT) modes in the [`crypto/subtle`](/pkg/crypto/subtle) package. This
-mode can be enabled for an entire program with the `dataindependenttiming` setting.
-For Go 1.24 it defaults to `dataindependenttiming=0`. There is no change in default
-behavior from Go 1.23 when `dataindependenttiming` is unset.
-Using `dataindependenttiming=1` enables the DIT mode for the entire Go program.
-When enabled, DIT will be enabled when calling into C from Go. When enabled,
-calling into Go code from C will enable DIT, and disable it before returning to
-C if it was not enabled when Go code was entered.
-This currently only affects arm64 programs. For all other platforms it is a no-op.
-
-Go 1.24 removed the `x509sha1` setting.  `crypto/x509` no longer supports verifying
-signatures on certificates that use SHA-1 based signature algorithms.
-
-Go 1.24 changes the default value of the [`x509usepolicies`
-setting.](/pkg/crypto/x509/#CreateCertificate) from `0` to `1`. When marshalling
-certificates, policies are now taken from the
-[`Certificate.Policies`](/pkg/crypto/x509/#Certificate.Policies) field rather
-than the
-[`Certificate.PolicyIdentifiers`](/pkg/crypto/x509/#Certificate.PolicyIdentifiers)
-field by default.
-
-Go 1.24 enabled the post-quantum key exchange mechanism
-X25519MLKEM768 by default. The default can be reverted using the
-[`tlsmlkem` setting](/pkg/crypto/tls/#Config.CurvePreferences).
-This can be useful when dealing with buggy TLS servers that do not handle large records correctly,
-causing a timeout during the handshake (see [TLS post-quantum TL;DR fail](https://tldr.fail/)).
-Go 1.24 also removed X25519Kyber768Draft00 and the Go 1.23 `tlskyber` setting.
-
-Go 1.24 made [`ParsePKCS1PrivateKey`](/pkg/crypto/x509/#ParsePKCS1PrivateKey)
-use and validate the CRT parameters in the encoded private key. This behavior
-can be controlled with the `x509rsacrt` setting. Using `x509rsacrt=0` restores
-the Go 1.23 behavior.
-
-### Go 1.23
-
-Go 1.23 changed the channels created by package time to be unbuffered
-(synchronous), which makes correct use of the [`Timer.Stop`](/pkg/time/#Timer.Stop)
-and [`Timer.Reset`](/pkg/time/#Timer.Reset) method results much easier.
-The [`asynctimerchan` setting](/pkg/time/#NewTimer) disables this change.
-There are no runtime metrics for this change,
-This setting will be removed in Go 1.27.
-
-Go 1.23 changed the mode bits reported by [`os.Lstat`](/pkg/os#Lstat) and [`os.Stat`](/pkg/os#Stat)
-for reparse points, which can be controlled with the `winsymlink` setting.
-As of Go 1.23 (`winsymlink=1`), mount points no longer have [`os.ModeSymlink`](/pkg/os#ModeSymlink)
-set, and reparse points that are not symlinks, Unix sockets, or dedup files now
-always have [`os.ModeIrregular`](/pkg/os#ModeIrregular) set. As a result of these changes,
-[`filepath.EvalSymlinks`](/pkg/path/filepath#EvalSymlinks) no longer evaluates
-mount points, which was a source of many inconsistencies and bugs.
-At previous versions (`winsymlink=0`), mount points are treated as symlinks,
-and other reparse points with non-default [`os.ModeType`](/pkg/os#ModeType) bits
-(such as [`os.ModeDir`](/pkg/os#ModeDir)) do not have the `ModeIrregular` bit set.
-
-Go 1.23 changed [`os.Readlink`](/pkg/os#Readlink) and [`filepath.EvalSymlinks`](/pkg/path/filepath#EvalSymlinks)
-to avoid trying to normalize volumes to drive letters, which was not always even possible.
-This behavior is controlled by the `winreadlinkvolume` setting.
-For Go 1.23, it defaults to `winreadlinkvolume=1`.
-Previous versions default to `winreadlinkvolume=0`.
-
-Go 1.23 enabled the experimental post-quantum key exchange mechanism
-X25519Kyber768Draft00 by default. The default can be reverted using the
-[`tlskyber` setting](/pkg/crypto/tls/#Config.CurvePreferences).
-This can be useful when dealing with buggy TLS servers that do not handle large records correctly,
-causing a timeout during the handshake (see [TLS post-quantum TL;DR fail](https://tldr.fail/)).
-
-Go 1.23 changed the behavior of
-[crypto/x509.ParseCertificate](/pkg/crypto/x509/#ParseCertificate) to reject
-serial numbers that are negative. This change can be reverted with
-the [`x509negativeserial` setting](/pkg/crypto/x509/#ParseCertificate).
-
-Go 1.23 re-enabled support in html/template for ECMAScript 6 template literals by default.
-The [`jstmpllitinterp` setting](/pkg/html/template#hdr-Security_Model) no longer has
-any effect.
-
-Go 1.23 changed the default TLS cipher suites used by clients and servers when
-not explicitly configured, removing 3DES cipher suites. The default can be reverted
-using the [`tls3des` setting](/pkg/crypto/tls/#Config.CipherSuites).
-This setting will be removed in Go 1.27.
-
-Go 1.23 changed the behavior of [`tls.X509KeyPair`](/pkg/crypto/tls#X509KeyPair)
-and [`tls.LoadX509KeyPair`](/pkg/crypto/tls#LoadX509KeyPair) to populate the
-Leaf field of the returned [`tls.Certificate`](/pkg/crypto/tls#Certificate).
-This behavior is controlled by the `x509keypairleaf` setting. For Go 1.23, it
-defaults to `x509keypairleaf=1`. Previous versions default to
-`x509keypairleaf=0`.
-This setting will be removed in Go 1.27.
-
-Go 1.23 changed
-[`net/http.ServeContent`](/pkg/net/http#ServeContent),
-[`net/http.ServeFile`](/pkg/net/http#ServeFile), and
-[`net/http.ServeFS`](/pkg/net/http#ServeFS) to
-remove Cache-Control, Content-Encoding, Etag, and Last-Modified headers
-when serving an error. This behavior is controlled by
-the [`httpservecontentkeepheaders` setting](/pkg/net/http#ServeContent).
-Using `httpservecontentkeepheaders=1` restores the pre-Go 1.23 behavior.
-
-### Go 1.22
-
-Go 1.22 adds a configurable limit to control the maximum acceptable RSA key size
-that can be used in TLS handshakes, controlled by the [`tlsmaxrsasize` setting](/pkg/crypto/tls#Conn.Handshake).
-The default is tlsmaxrsasize=8192, limiting RSA to 8192-bit keys. To avoid
-denial of service attacks, this setting and default was backported to Go
-1.19.13, Go 1.20.8, and Go 1.21.1.
-
-Go 1.22 made it an error for a request or response read by a net/http
-client or server to have an empty Content-Length header.
-This behavior is controlled by the `httplaxcontentlength` setting.
-
-Go 1.22 changed the behavior of ServeMux to accept extended
-patterns and unescape both patterns and request paths by segment.
-This behavior can be controlled by the
-[`httpmuxgo121` setting](/pkg/net/http/#ServeMux).
-
-Go 1.22 added the [Alias type](/pkg/go/types#Alias) to [go/types](/pkg/go/types)
-for the explicit representation of [type aliases](/ref/spec#Type_declarations).
-Whether the type checker produces `Alias` types or not is controlled by the
-[`gotypesalias` setting](/pkg/go/types#Alias).
-For Go 1.22 it defaults to `gotypesalias=0`.
-For Go 1.23, `gotypesalias=1` will become the default.
-This setting will be removed in Go 1.27.
-
-Go 1.22 changed the default minimum TLS version supported by both servers
-and clients to TLS 1.2. The default can be reverted to TLS 1.0 using the
-[`tls10server` setting](/pkg/crypto/tls/#Config).
-This setting will be removed in Go 1.27.
-
-Go 1.22 changed the default TLS cipher suites used by clients and servers when
-not explicitly configured, removing the cipher suites which used RSA based key
-exchange. The default can be reverted using the [`tlsrsakex` setting](/pkg/crypto/tls/#Config).
-This setting will be removed in Go 1.27.
-
-Go 1.22 disabled
-[`ConnectionState.ExportKeyingMaterial`](/pkg/crypto/tls/#ConnectionState.ExportKeyingMaterial)
-when the connection supports neither TLS 1.3 nor Extended Master Secret
-(implemented in Go 1.21). It can be reenabled with the [`tlsunsafeekm`
-setting](/pkg/crypto/tls/#ConnectionState.ExportKeyingMaterial).
-This setting will be removed in Go 1.27.
-
-Go 1.22 changed how the runtime interacts with transparent huge pages on Linux.
-In particular, a common default Linux kernel configuration can result in
-significant memory overheads, and Go 1.22 no longer works around this default.
-To work around this issue without adjusting kernel settings, transparent huge
-pages can be disabled for Go memory with the
-[`disablethp` setting](/pkg/runtime#hdr-Environment_Variables).
-This behavior was backported to Go 1.21.1, but the setting is only available
-starting with Go 1.21.6.
-This setting may be removed in a future release, and users impacted by this issue
-should adjust their Linux configuration according to the recommendations in the
-[GC guide](/doc/gc-guide#Linux_transparent_huge_pages), or switch to a Linux
-distribution that disables transparent huge pages altogether.
-
-Go 1.22 added contention on runtime-internal locks to the [`mutex`
-profile](/pkg/runtime/pprof#Profile). Contention on these locks is always
-reported at `runtime._LostContendedRuntimeLock`. Complete stack traces of
-runtime locks can be enabled with the [`runtimecontentionstacks`
-setting](/pkg/runtime#hdr-Environment_Variables). These stack traces have
-non-standard semantics, see setting documentation for details.
-
-Go 1.22 added a new [`crypto/x509.Certificate`](/pkg/crypto/x509/#Certificate)
-field, [`Policies`](/pkg/crypto/x509/#Certificate.Policies), which supports
-certificate policy OIDs with components larger than 31 bits. By default this
-field is only used during parsing, when it is populated with policy OIDs, but
-not used during marshaling. It can be used to marshal these larger OIDs, instead
-of the existing PolicyIdentifiers field, by using the
-[`x509usepolicies` setting](/pkg/crypto/x509/#CreateCertificate).
-
-
-### 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+.
-
-Go 1.21 adds the support of Multipath TCP but it is only used if the application
-explicitly asked for it. This behavior can be controlled by the
-[`multipathtcp` setting](/pkg/net#Dialer.SetMultipathTCP).
-
-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.19 started sending EDNS0 additional headers on DNS requests.
-This can reportedly break the DNS server provided on some routers,
-such as CenturyLink Zyxel C3000Z.
-This can be changed by the [`netedns0` setting](/pkg/net#hdr-Name_Resolution).
-This setting is available in Go 1.21.12, Go 1.22.5, Go 1.23, and later.
-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](/pkg/crypto/x509#InsecureAlgorithmError).
-This setting was removed in Go 1.24.
-
-### 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.

doc/initial/1-intro.md

@@ -1,8 +0,0 @@
-<style>
-  main ul li { margin: 0.5em 0; }
-</style>
-
-## DRAFT RELEASE NOTES — Introduction to Go 1.N {#introduction}
-
-**Go 1.N is not yet released. These are work-in-progress release notes.
-Go 1.N is expected to be released in {Month} {Year}.**

doc/initial/2-language.md

@@ -1,3 +0,0 @@
-## Changes to the language {#language}
-
-

doc/initial/3-tools.md

@@ -1,6 +0,0 @@
-## Tools {#tools}
-
-### Go command {#go-command}
-
-### Cgo {#cgo}
-

doc/initial/4-runtime.md

@@ -1 +0,0 @@
-## Runtime {#runtime}

doc/initial/5-toolchain.md

@@ -1,7 +0,0 @@
-## Compiler {#compiler}
-
-## Assembler {#assembler}
-
-## Linker {#linker}
-
-

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

@@ -1,2 +0,0 @@
-## Standard library {#library}
-

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

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

doc/initial/6-stdlib/99-minor/README

@@ -1 +0,0 @@
-API changes and other small changes to the standard library go here.

doc/initial/7-ports.md

@@ -1,2 +0,0 @@
-## Ports {#ports}
-

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/fips140/Makefile

@@ -1,46 +0,0 @@
-# Copyright 2024 The Go Authors. All rights reserved.
-# Use of this source code is governed by a BSD-style
-# license that can be found in the LICENSE file.
-
-# Rules for building and testing new FIPS snapshots.
-# For example:
-#
-#	make v1.2.3.zip
-#	make v1.2.3.test
-#
-# and then if changes are needed, check them into master
-# and run 'make v1.2.3.rm' and repeat.
-#
-# Note that once published a snapshot zip file should never
-# be modified. We record the sha256 hashes of the zip files
-# in fips140.sum, and the cmd/go/internal/fips140 test checks
-# that the zips match.
-#
-# When the zip file is finalized, run 'make updatesum' to update
-# fips140.sum.
-
-default:
-	@echo nothing to make
-
-# make v1.2.3.zip builds a v1.2.3.zip file
-# from the current origin/master.
-# copy and edit the 'go run' command by hand to use a different branch.
-v%.zip:
-	git fetch origin master
-	go run ../../src/cmd/go/internal/fips140/mkzip.go v$*
-
-# normally mkzip refuses to overwrite an existing zip file.
-# make v1.2.3.rm removes the zip file and unpacked
-# copy from the module cache.
-v%.rm:
-	rm -f v$*.zip
-	chmod -R u+w $$(go env GOMODCACHE)/golang.org/fips140@v$* 2>/dev/null || true
-	rm -rf $$(go env GOMODCACHE)/golang.org/fips140@v$*
-
-# make v1.2.3.test runs the crypto tests using that snapshot.
-v%.test:
-	GOFIPS140=v$* go test -short crypto...
-
-# make updatesum updates the fips140.sum file.
-updatesum:
-	go test cmd/go/internal/fips140 -update

lib/fips140/README.md

@@ -1,9 +0,0 @@
-This directory holds snapshots of the crypto/internal/fips140 tree
-that are being validated and certified for FIPS-140 use.
-The file x.txt (for example, inprocess.txt, certified.txt)
-defines the meaning of the FIPS version alias x, listing
-the exact version to use.
-
-The zip files are created by cmd/go/internal/fips140/mkzip.go.
-The fips140.sum file lists checksums for the zip files.
-See the Makefile for recipes.

lib/fips140/fips140.sum

@@ -1,13 +0,0 @@
-# SHA256 checksums of snapshot zip files in this directory.
-# These checksums are included in the FIPS security policy
-# (validation instructions sent to the lab) and MUST NOT CHANGE.
-# That is, the zip files themselves must not change.
-#
-# It is okay to add new zip files to the list, and it is okay to
-# remove zip files from the list when they are removed from
-# this directory. To update this file:
-#
-#	go test cmd/go/internal/fips140 -update
-#
-v1.0.0-c2097c7c.zip daf3614e0406f67ae6323c902db3f953a1effb199142362a039e7526dfb9368b
-v1.1.0-rc1.zip ea94f8c3885294c9efe1bd8f9b6e86daeb25b6aff2aeb20707cd9a5101f6f54e

lib/fips140/inprocess.txt

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

lib/fips140/v1.0.0.txt

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

lib/hg/goreposum.py

@@ -1,64 +0,0 @@
-# Copyright 2025 The Go Authors. All rights reserved.
-# Use of this source code is governed by a BSD-style
-# license that can be found in the LICENSE file.
-
-# Mercurial extension to add a 'goreposum' command that
-# computes a hash of a remote repo's tag state.
-# Tag definitions can come from the .hgtags file stored in
-# any head of any branch, and the server protocol does not
-# expose the tags directly. However, the protocol does expose
-# the hashes of all the branch heads, so we can use a hash of
-# all those branch names and heads as a conservative snapshot
-# of the entire remote repo state, and use that as the tag sum.
-# Any change on the server then invalidates the tag sum,
-# even if it didn't have anything to do with tags, but at least
-# we will avoid re-cloning a server when there have been no
-# changes at all.
-#
-# Separately, this extension also adds a 'golookup' command that
-# returns the hash of a specific reference, like 'default' or a tag.
-# And golookup of a hash confirms that it still exists on the server.
-# We can use that to revalidate that specific versions still exist and
-# have the same meaning they did the last time we checked.
-#
-# Usage:
-#
-#	hg --config "extensions.goreposum=$GOROOT/lib/hg/goreposum.py" goreposum REPOURL
-
-import base64, hashlib, sys
-from mercurial import registrar, ui, hg, node
-from mercurial.i18n import _
-cmdtable = {}
-command = registrar.command(cmdtable)
-@command(b'goreposum', [], _('url'), norepo=True)
-def goreposum(ui, url):
-  """
-  goreposum computes a checksum of all the named state in the remote repo.
-  It hashes together all the branch names and hashes
-  and then all the bookmark names and hashes.
-  Tags are stored in .hgtags files in any of the branches,
-  so the branch metadata includes the tags as well.
-  """
-  h = hashlib.sha256()
-  peer = hg.peer(ui, {}, url)
-  for name, revs in peer.branchmap().items():
-    h.update(name)
-    for r in revs:
-      h.update(b' ')
-      h.update(r)
-    h.update(b'\n')
-  if (b'bookmarks' in peer.listkeys(b'namespaces')):
-    for name, rev in peer.listkeys(b'bookmarks').items():
-      h.update(name)
-      h.update(b'=')
-      h.update(rev)
-      h.update(b'\n')
-  print('r1:'+base64.standard_b64encode(h.digest()).decode('utf-8'))
-
-@command(b'golookup', [], _('url rev'), norepo=True)
-def golookup(ui, url, rev):
-  """
-  golookup looks up a single identifier in the repo,
-  printing its hash.
-  """
-  print(node.hex(hg.peer(ui, {}, url).lookup(rev)).decode('utf-8'))

lib/time/README

@@ -4,7 +4,7 @@ The IANA asserts that the database is in the public domain.
 
 For more information, see
 https://www.iana.org/time-zones
-ftp://ftp.iana.org/tz/code/tz-link.html
-https://datatracker.ietf.org/doc/html/rfc6557
+ftp://ftp.iana.org/tz/code/tz-link.htm
+http://tools.ietf.org/html/rfc6557
 
 To rebuild the archive, read and run update.bash.

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,87 +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=2025c
-DATA=2025c
+CODE=2021a
+DATA=2021a
 
 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
 
-# The PACKRATLIST and PACKRATDATA options are copied from Ubuntu:
-# https://git.launchpad.net/ubuntu/+source/tzdata/tree/debian/rules?h=debian/sid
-#
-# You can see the description of these make variables in the tzdata Makefile:
-# https://github.com/eggert/tz/blob/main/Makefile
-if ! make CFLAGS=-DSTD_INSPIRED AWK=awk TZDIR=zoneinfo PACKRATDATA=backzone PACKRATLIST=zone.tab posix_only >make.out 2>&1; then
-	cat make.out
-	exit 2
-fi
+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.

lib/wasm/go_js_wasm_exec

@@ -1,17 +0,0 @@
-#!/usr/bin/env bash
-# Copyright 2018 The Go Authors. All rights reserved.
-# Use of this source code is governed by a BSD-style
-# license that can be found in the LICENSE file.
-
-SOURCE="${BASH_SOURCE[0]}"
-while [ -h "$SOURCE" ]; do
-	DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"
-	SOURCE="$(readlink "$SOURCE")"
-	[[ $SOURCE != /* ]] && SOURCE="$DIR/$SOURCE"
-done
-DIR="$( cd -P "$( dirname "$SOURCE" )" && pwd )"
-
-# Increase the V8 stack size from the default of 984K
-# to 8192K to ensure all tests can pass without hitting
-# stack size limits.
-exec node --stack-size=8192 "$DIR/wasm_exec_node.js" "$@"

lib/wasm/go_wasip1_wasm_exec

@@ -1,23 +0,0 @@
-#!/usr/bin/env bash
-# Copyright 2023 The Go Authors. All rights reserved.
-# Use of this source code is governed by a BSD-style
-# license that can be found in the LICENSE file.
-
-case "$GOWASIRUNTIME" in
-	"wasmedge")
-		exec wasmedge --dir=/ --env PWD="$PWD" --env PATH="$PATH" ${GOWASIRUNTIMEARGS:-} "$1" "${@:2}"
-		;;
-	"wasmer")
-		exec wasmer run --dir=/ --env PWD="$PWD" --env PATH="$PATH" ${GOWASIRUNTIMEARGS:-} "$1" -- "${@:2}"
-		;;
-	"wazero")
-		exec wazero run -mount /:/ -env-inherit -cachedir "${TMPDIR:-/tmp}"/wazero ${GOWASIRUNTIMEARGS:-} "$1" "${@:2}"
-		;;
-	"wasmtime" | "")
-		exec wasmtime run --dir=/ --env PWD="$PWD" --env PATH="$PATH" -W max-wasm-stack=8388608 ${GOWASIRUNTIMEARGS:-} "$1" "${@:2}"
-		;;
-	*)
-		echo "Unknown Go WASI runtime specified: $GOWASIRUNTIME"
-		exit 1
-		;;
-esac

lib/wasm/wasm_exec_node.js

@@ -1,40 +0,0 @@
-// Copyright 2021 The Go Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style
-// license that can be found in the LICENSE file.
-
-"use strict";
-
-if (process.argv.length < 3) {
-	console.error("usage: go_js_wasm_exec [wasm binary] [arguments]");
-	process.exit(1);
-}
-
-globalThis.require = require;
-globalThis.fs = require("fs");
-globalThis.path = require("path");
-globalThis.TextEncoder = require("util").TextEncoder;
-globalThis.TextDecoder = require("util").TextDecoder;
-
-globalThis.performance ??= require("performance");
-
-globalThis.crypto ??= require("crypto");
-
-require("./wasm_exec");
-
-const go = new Go();
-go.argv = process.argv.slice(2);
-go.env = Object.assign({ TMPDIR: require("os").tmpdir() }, process.env);
-go.exit = process.exit;
-WebAssembly.instantiate(fs.readFileSync(process.argv[2]), go.importObject).then((result) => {
-	process.on("exit", (code) => { // Node.js exits if no event handler is pending
-		if (code === 0 && !go.exited) {
-			// deadlock, make Go print error and stack traces
-			go._pendingEvent = { id: 0 };
-			go._resume();
-		}
-	});
-	return go.run(result.instance);
-}).catch((err) => {
-	console.error(err);
-	process.exit(1);
-});

misc/android/go_android_exec.go

@@ -0,0 +1,340 @@
+// 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.
+
+// +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/boring/README.md

@@ -0,0 +1,108 @@
+# README.md
+
+This directory holds build scripts for unofficial, unsupported
+distributions of Go+BoringCrypto.
+
+## Version strings
+
+The distribution name for a Go+BoringCrypto release has the form `<GoVersion>b<BoringCryptoVersion>`,
+where `<GoVersion>` is the Go version the release is based on, and `<BoringCryptoVersion>` is
+an integer that increments each time there is a new release with different BoringCrypto bits.
+The `<BoringCryptoVersion>` is stored in the `VERSION` file in this directory.
+
+For example, the first release is based on Go 1.8.3 is `go1.8.3b1`.
+If the BoringCrypto bits are updated, the next would be `go1.8.3b2`.
+If, after that, Go 1.9 is released and the same BoringCrypto code added to it,
+that would result in `go1.9b2`. There would likely not be a `go1.9b1`,
+since that would indicate Go 1.9 with the older BoringCrypto code.
+
+## Releases
+
+The `build.release` script prepares a binary release and publishes it in Google Cloud Storage
+at `gs://go-boringcrypto/`, making it available for download at
+`https://go-boringcrypto.storage.googleapis.com/<FILE>`.
+The script records each published release in the `RELEASES` file in this directory.
+
+The `build.docker` script, which must be run after `build.release`, prepares a Docker image
+and publishes it on hub.docker.com in the goboring organization.
+`go1.8.3b1` is published as `goboring/golang:1.8.3b1`.
+
+## Release process
+
+Development is done on the dev.boringcrypto branch, which tracks
+master. Releases are cut from dev.boringcrypto.go1.X branches,
+which are BoringCrypto backported to the Go 1.X release branches.
+To issue new BoringCrypto releases based on Go 1.X:
+
+1. If the BoringCrypto bits have been updated, increment the
+   number in `VERSION`, send that change out as a CL for review,
+   get it committed to dev.boringcrypto, and run `git sync`.
+
+2. Change to the dev.boringcrypto.go1.X branch and cherry-pick
+   all BoringCrypto updates, including the update of the
+   `VERSION` file. If desired, merge release-branch.go1.X into
+   dev.boringcrypto.go1.X. Mail them out and get them committed.
+
+3. **Back on the dev.boringcrypto branch**, run `git fetch`,
+   `make.bash` and then `build.release dev.boringcrypto.go1.X`.
+   The script will determine the base Go version and the
+   BoringCrypto version, build a release, and upload it.
+
+4. Run `build.docker`, which will build and upload a Docker image
+   from the latest release.
+
+5. Send out a CL with the updated `RELEASES` file and get it
+   committed to dev.boringcrypto.
+
+## Building from Docker
+
+A Dockerfile that starts with `FROM golang:1.8.3` can switch
+to `FROM goboring/golang:1.8.3b2` (see [goboring/golang on Docker Hub](https://hub.docker.com/r/goboring/golang/))
+and should need no other modifications.
+
+## Building from Bazel
+
+Starting from [bazelbuild/rules_go](https://github.com/bazelbuild/rules_go)
+tag 0.7.1, simply download the BoringCrypto-enabled Go SDK using
+`go_download_sdk()` before calling `go_register_toolchains()`.
+
+For example, to use Go 1.9.3 with BoringCrypto on Linux, use the following lines
+in `WORKSPACE`:
+```python
+load("@io_bazel_rules_go//go:def.bzl", "go_rules_dependencies", "go_download_sdk", "go_register_toolchains")
+
+go_rules_dependencies()
+
+go_download_sdk(
+    name = "go_sdk",
+    sdks = {
+       "linux_amd64": ("go1.9.3b4.linux-amd64.tar.gz", "db1997b2454a2f27669b849d2d2cafb247a55128d53da678f06cb409310d6660"),
+    },
+    urls = ["https://storage.googleapis.com/go-boringcrypto/{}"],
+)
+
+go_register_toolchains()
+```
+
+**Note**: you must *not* enable `pure` mode, since cgo must be enabled. To
+ensure that binaries are linked with BoringCrypto, you can set `pure = "off"` on
+all relevant `go_binary` rules.
+
+## Caveat
+
+BoringCrypto is used for a given build only in limited circumstances:
+
+  - The build must be GOOS=linux, GOARCH=amd64.
+  - The build must have cgo enabled.
+  - The android build tag must not be specified.
+  - The cmd_go_bootstrap build tag must not be specified.
+
+The version string reported by `runtime.Version` does not indicate that BoringCrypto
+was actually used for the build. For example, linux/386 and non-cgo linux/amd64 binaries
+will report a version of `go1.8.3b2` but not be using BoringCrypto.
+
+To check whether a given binary is using BoringCrypto, run `go tool nm` on it and check
+that it has symbols named `*_Cfunc__goboringcrypto_*`.
+
+The program [rsc.io/goversion](https://godoc.org/rsc.io/goversion) will report the
+crypto implementation used by a given binary when invoked with the `-crypto` flag.

misc/boring/RELEASES

@@ -0,0 +1,153 @@
+# This file lists published Go+BoringCrypto releases.
+# Each line describes a single release: <version> <git commit> <target> <URL> <sha256sum>
+go1.9rc2b2 91753387bdf7 linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.9rc2b2.linux-amd64.tar.gz 59355a45e6970e8013060851ddb3f079afe8db52e90db520a0826a13f1b5ae5b
+go1.8.3b3 f6ff81bac156 linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.8.3b3.linux-amd64.tar.gz 6287ad971cd268bb2684fb8b1275dea928ad527823062bc057e73036c419e7af
+go1.9rc2b4 c339bc4e07a6 linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.9rc2b4.linux-amd64.tar.gz a8f677d48dc93920065fca4dca1a55bf7110aba132489c47e25d26d55c67eb32
+go1.9b4 e6ad24cde71e linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.9b4.linux-amd64.tar.gz 6592e36a05df8e7c59812328a3a4bfa6c4eed72132fc31245951c3ade3ef2a8a
+go1.9b4 e6ad24cde71e src https://go-boringcrypto.storage.googleapis.com/go1.9b4.src.tar.gz c85f31dc743fee0e8ce0c6ffc286e27c1f51b66c9b923afafb43cdc378a41091
+go1.8.3b4 42cb4dcdb59a linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.8.3b4.linux-amd64.tar.gz 4011c86e6175925e1c63dc7c19a51f825be53bbe7b08260918e5107b0fbd4f85
+go1.8.3b4 42cb4dcdb59a src https://go-boringcrypto.storage.googleapis.com/go1.8.3b4.src.tar.gz 2531ca8918aa024aed8f4a6c9e5c3b25bc8777623f1efa66aec7214601d474e4
+go1.9.2b4 cda3c6f91d7c linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.9.2b4.linux-amd64.tar.gz 7c5e9a033ddc3ab36646e3bac7fd16962742710c70c18122e44a9ab56cdd3cf7
+go1.9.2b4 cda3c6f91d7c src https://go-boringcrypto.storage.googleapis.com/go1.9.2b4.src.tar.gz 38a2260b64a6a5ab20f8972d08b4765bad116721356433f39aebd29c7598218c
+go1.9.3b4 f4e5ebdf35c8 linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.9.3b4.linux-amd64.tar.gz db1997b2454a2f27669b849d2d2cafb247a55128d53da678f06cb409310d6660
+go1.9.3b4 f4e5ebdf35c8 src https://go-boringcrypto.storage.googleapis.com/go1.9.3b4.src.tar.gz 7485e1fc53a9fab9cf34f71de74d69f4c50f9d11a449647de40ee04b59bf8a5b
+go1.9.7b4 0bad1bef406e linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.9.7b4.linux-amd64.tar.gz 9e33a0deb8fed3bd7fa3d122bb5143be9e0a974a422ab4ddac5e765fa1310a6f
+go1.9.7b4 0bad1bef406e src https://go-boringcrypto.storage.googleapis.com/go1.9.7b4.src.tar.gz ad9fb6e22a27382c468467ecade4937f725b33818852f1c1da0d09b471e7486c
+go1.10.3b4 35ba5284935c linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.10.3b4.linux-amd64.tar.gz 6754729d78a375bd1debd980b1e3e7fd49198a980d0bbd8f39e89569aa001942
+go1.10.3b4 35ba5284935c src https://go-boringcrypto.storage.googleapis.com/go1.10.3b4.src.tar.gz f3e75c60a835c11b97e30429b63917ceb31f799b2ba7e2001d99db908fb8e28f
+go1.10.4b4 2e2a04a605b6 linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.10.4b4.linux-amd64.tar.gz 17c275ff448686fe1908ecbea5d11ad6f4f7caa288d1786b756439703b12b8b2
+go1.10.4b4 2e2a04a605b6 src https://go-boringcrypto.storage.googleapis.com/go1.10.4b4.src.tar.gz f9cc38e194edabebf338fb74c22f597dc847560618d5d7d4d6cdc28139efa772
+go1.11b4 685dc1638240 linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.11b4.linux-amd64.tar.gz d53417b2071af0104fbc15a957000bccdcb5bbc094df0401f67d51968f7f2e4e
+go1.11b4 685dc1638240 src https://go-boringcrypto.storage.googleapis.com/go1.11b4.src.tar.gz 39896f0decd6721e81324cb2bb19540706ca97152c6800a6c8ad15a4e4162184
+go1.11.2b4 35cf0d9f6bbd linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.11.2b4.linux-amd64.tar.gz a9ceb6d0b4413d81ccc94c6460f60ca0c4f36b5dcbf659e1be582cd40c0edfbd
+go1.11.2b4 35cf0d9f6bbd src https://go-boringcrypto.storage.googleapis.com/go1.11.2b4.src.tar.gz 8e12a8df1428f00239dc67dd438a81f72c9925982e90b6899f66270971bddc1c
+go1.10.7b4 8b246fe0f595 linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.10.7b4.linux-amd64.tar.gz 31917ab96004b9b482399b46928f5c10cdadefed5fda6f4de262efe2c3c7533e
+go1.10.7b4 8b246fe0f595 src https://go-boringcrypto.storage.googleapis.com/go1.10.7b4.src.tar.gz 323a184c77e3a377f5ed993b04946ee7b1a8e3350aba2894c0944f1e313636f1
+go1.11.4b4 572c4bce6792 linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.11.4b4.linux-amd64.tar.gz e708ef7ecaf17a3e8e6deceadfa167cc1162f710f97ea4bc124d3837d6e2eaa1
+go1.11.4b4 572c4bce6792 src https://go-boringcrypto.storage.googleapis.com/go1.11.4b4.src.tar.gz ea963b80e218a34470e14e6e997fe06b8c5bf3f9c9bb0c801f7d8ef63b9bcb73
+go1.10.8b4 4b76b996cb0a linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.10.8b4.linux-amd64.tar.gz 6d7d3323030851b595ba7ed66931c352b63de6dfe1ab3e6d6243987765d09819
+go1.10.8b4 4b76b996cb0a src https://go-boringcrypto.storage.googleapis.com/go1.10.8b4.src.tar.gz c1f5df50a4be3d0cb3aed7b80728f2b23c18deff0383636274742a38c145f939
+go1.11.5b4 3fb9dafacc45 linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.11.5b4.linux-amd64.tar.gz 9b5b2972b452da9ba6bba65bab18fb9e8fbda31b5c489275710e5429d76f568c
+go1.11.5b4 3fb9dafacc45 src https://go-boringcrypto.storage.googleapis.com/go1.11.5b4.src.tar.gz 1c5801e2af25c9299d9fd94c64f9ec11fd35777c45d5d0f398c0a9884b1cfbbf
+go1.12.1b4 88e20e81a61f linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.12.1b4.linux-amd64.tar.gz b71886e0d65e5efea2e0a3cbd0c3cd0daf84c437078e755ecde25f4ac0bbed2f
+go1.12.1b4 88e20e81a61f src https://go-boringcrypto.storage.googleapis.com/go1.12.1b4.src.tar.gz d44be1396eb2854b5d9c4d8e8ed0cf9fea1e9dc5a02d8f53b41ba571951a329f
+go1.11.6b4 7be8a5843a9b linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.11.6b4.linux-amd64.tar.gz b704f61b8979e64a46da8884c90cd2b0e2d54e802d55e5f56d7c93752334c197
+go1.11.6b4 7be8a5843a9b src https://go-boringcrypto.storage.googleapis.com/go1.11.6b4.src.tar.gz a56b45e24b61ad7b3c90dfd906cd22426a4de9e2e697b4c9ef07a2af047bcb0d
+go1.12.5b4 ad495d31d908 linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.12.5b4.linux-amd64.tar.gz df0e64958cf90f27a65b2175eb80bc34a601136eed8e5559bed2a9e349e33707
+go1.12.5b4 ad495d31d908 src https://go-boringcrypto.storage.googleapis.com/go1.12.5b4.src.tar.gz 054d482896a77ae2d7d24c7adf08da5a4401b938871e61a5cdabc735c54cea9f
+go1.11.11b4 346babe6a67f linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.11.11b4.linux-amd64.tar.gz c4dd44fa00f491b3d2ea808af8a6c234f915adb27c014512d725bafc4784d75f
+go1.11.11b4 346babe6a67f src https://go-boringcrypto.storage.googleapis.com/go1.11.11b4.src.tar.gz 57a724a72f0ba8620cbb48288f39c86ed513c241509ddf73231f4c8cd2a983ac
+go1.12.6b4 6b86b09ad4d3 linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.12.6b4.linux-amd64.tar.gz eebc2e7f37555760adb361985b861d0cd34f9401cf7456d8d2f2f3082a60eee1
+go1.12.6b4 6b86b09ad4d3 src https://go-boringcrypto.storage.googleapis.com/go1.12.6b4.src.tar.gz 0e6e9aaf2c72a7e61280ce1e77b2ea24f01a59f4c1e6f0aa72b753206724fd3a
+go1.11.12b4 845e947ae34f linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.11.12b4.linux-amd64.tar.gz 91808261fc357855fba920df01a933d6104e907793014317de00b92802d494d9
+go1.11.12b4 845e947ae34f src https://go-boringcrypto.storage.googleapis.com/go1.11.12b4.src.tar.gz 7b64d9e56ea627138d87c7533df8f9932a79ff900f150a8d8e6a3edc2d0066ec
+go1.12.7b4 bd126d0ad256 linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.12.7b4.linux-amd64.tar.gz 7f0c73cd397bccad48ab4df4188d3651c25bf33102275848c6e67b882e11f680
+go1.12.7b4 bd126d0ad256 src https://go-boringcrypto.storage.googleapis.com/go1.12.7b4.src.tar.gz 0c48d7b81ef2b948980011fad1d176d6b10636a4016e3aed7438d86e046d816b
+go1.11.13b4 4f8e7223f936 linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.11.13b4.linux-amd64.tar.gz eeb232577065732f5d57a4c77b7d73aa60231ee6fd6496daf7558993e92e403f
+go1.11.13b4 4f8e7223f936 src https://go-boringcrypto.storage.googleapis.com/go1.11.13b4.src.tar.gz 107da8846803a0a735766ca0947de6cd15cd23d8c584002f06e7ac5f81ecb114
+go1.12.8b4 55186ba70c1a linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.12.8b4.linux-amd64.tar.gz 63f278abfc1e98546bc0ffc87f000d9aae2b06c0700212cb55ffd17d059fb8e1
+go1.12.8b4 55186ba70c1a src https://go-boringcrypto.storage.googleapis.com/go1.12.8b4.src.tar.gz c12b1d56ba4e0572f85a08681e05c66293ad53f04b11ce74c688d78fcb882061
+go1.12.9b4 ee88e5b118b5 linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.12.9b4.linux-amd64.tar.gz d90989cba1db647b795400a9520eab2fa30f8dea50f4189b18d53f757a4bac44
+go1.12.9b4 ee88e5b118b5 src https://go-boringcrypto.storage.googleapis.com/go1.12.9b4.src.tar.gz 9d4efed8e13fa5ebdadd4fc22f9e35e67bfb34322570c83a15a0879472412e13
+go1.13b4 28e8a0c21e00 linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.13b4.linux-amd64.tar.gz 4a909f34bc487badb5ec11646c471ae690393d3f7835b8fbef8466d04ee23cba
+go1.13b4 28e8a0c21e00 src https://go-boringcrypto.storage.googleapis.com/go1.13b4.src.tar.gz 3c2dbe1bfcd7299b5be4b75529425c0a67b8d6b76f81f993b84ae0d173934257
+go1.12.10b4 5827153a1db7 linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.12.10b4.linux-amd64.tar.gz 20963fde89fd20eebee9d89003e52702f0379fdb04a68754f9fadf2c302166e3
+go1.12.10b4 5827153a1db7 src https://go-boringcrypto.storage.googleapis.com/go1.12.10b4.src.tar.gz f5cfe73cfeaaa67619ff4a4bbc587e622d63a6aaa7145253e6583bd59072b323
+go1.13.1b4 2da1832ad494 linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.13.1b4.linux-amd64.tar.gz 70be1bae05feb67d0560f39767e80707343d96554c5a611fbb93b04ce5913693
+go1.13.1b4 2da1832ad494 src https://go-boringcrypto.storage.googleapis.com/go1.13.1b4.src.tar.gz cf94520325f376ecaf420b7d25756cdecbed52510a1a079eca67c2c86c3cf39b
+go1.12.11b4 c5a4ae8c8c1b linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.12.11b4.linux-amd64.tar.gz a2d90aa130d45b36dd94a7e70accc94e2585eb45823fb7b07ae182ac8bc4a8ca
+go1.12.11b4 c5a4ae8c8c1b src https://go-boringcrypto.storage.googleapis.com/go1.12.11b4.src.tar.gz c334b70c9af0380fb9d397e89af1e2e2ac03380b5cc7c3327f56536c2f68bf8d
+go1.13.2b4 6a1c22797f9c linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.13.2b4.linux-amd64.tar.gz 888c1f6331862af388e730fab4926aa1cb2d4ffc5417e32f9e6d2af7953f0e29
+go1.13.2b4 6a1c22797f9c src https://go-boringcrypto.storage.googleapis.com/go1.13.2b4.src.tar.gz fc44c7713fcd84fe0587594ae5ee1a1d318a0da18b1156e1f9645c6ffa0335bc
+go1.12.12b4 cab2e4707a42 linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.12.12b4.linux-amd64.tar.gz 983e996e8f60c78a400fed0edfd16c1718d704e15389c48b4a8b2d835c0d00f2
+go1.12.12b4 cab2e4707a42 src https://go-boringcrypto.storage.googleapis.com/go1.12.12b4.src.tar.gz 2d653a74c14cde1e414ac558e0bdd182ccbe1198bbff8cd22c8e423552d5e24d
+go1.13.3b4 cba6efa89376 linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.13.3b4.linux-amd64.tar.gz 9ba0b7696f14dc7ecc912aae6587491853637fab30c4c005339fe36751bfd185
+go1.13.3b4 cba6efa89376 src https://go-boringcrypto.storage.googleapis.com/go1.13.3b4.src.tar.gz ba83d7e18fa49dc6e4319806e7b5cdee5eb046eb8e9fb38f3034378c4f80944a
+go1.12.13b4 5d9d84d037da linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.12.13b4.linux-amd64.tar.gz af3e0d2b9996c632b010da6700b7b8ec52bd3065b3facc478709209a854664eb
+go1.12.13b4 5d9d84d037da src https://go-boringcrypto.storage.googleapis.com/go1.12.13b4.src.tar.gz d1bae336ea076a0b2bfc984477f4a216a475e134068227e6d9b44faf239bcfb8
+go1.13.4b4 fa3f24e5c294 linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.13.4b4.linux-amd64.tar.gz 23579d1bea65b2510e507bb0698ec66777bd34674c91dfe617ed130728791dc7
+go1.13.4b4 fa3f24e5c294 src https://go-boringcrypto.storage.googleapis.com/go1.13.4b4.src.tar.gz 8d82df5b4332acd5a274ac029ee5b5ff073b2a4247e2325610986221858b819d
+go1.12.16b4 f74e68136cf1 linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.12.16b4.linux-amd64.tar.gz fd70cee8ca9438f99cc71b3586b11a03a36239a5bccbf1c4d06e7206b88bd77d
+go1.12.16b4 f74e68136cf1 src https://go-boringcrypto.storage.googleapis.com/go1.12.16b4.src.tar.gz 2ae0823cefc34f280d4f4ba0d665ff247ba1429cb43198d10e3bc316d3f29a8d
+go1.13.7b4 71468339f763 linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.13.7b4.linux-amd64.tar.gz 85945502ad43f506902927f69b514b34a85a20e2bd1020cce87c551645194aa3
+go1.13.7b4 71468339f763 src https://go-boringcrypto.storage.googleapis.com/go1.13.7b4.src.tar.gz d30fa252de75763adb5886125e19e8bab68dbe8dbad33b0faf09a6be98b12d96
+go1.12.17b4 9e5b1367cb45 linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.12.17b4.linux-amd64.tar.gz ee3a72dc1cfd8a34f32aaa5ddb05076fcb39434fd1bd25aa318234f72b462e31
+go1.12.17b4 9e5b1367cb45 src https://go-boringcrypto.storage.googleapis.com/go1.12.17b4.src.tar.gz ffb653ec8f4cc33e1e7c308d89c695f322a76f3107e0fc8c639affc6148261bf
+go1.13.8b4 fdf5e5b5905f linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.13.8b4.linux-amd64.tar.gz eac505df92aa6d6b76041f4b485d230f839159b8567c96d7980a06ef476ab3df
+go1.13.8b4 fdf5e5b5905f src https://go-boringcrypto.storage.googleapis.com/go1.13.8b4.src.tar.gz 1aa28fe37a704e94bb34e23578fd07ebbc6a025e9be9b45a898967b84405c41b
+go1.14b4 99da8fa53467 linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.14b4.linux-amd64.tar.gz a617e03a6c8813c53b813b865a2e185e12dbfaa76c703c1c48e57ad89651556b
+go1.14b4 99da8fa53467 src https://go-boringcrypto.storage.googleapis.com/go1.14b4.src.tar.gz ee292639b24923f519f1f0fe1ceaeca8d46feb8c15cf88e228346398c5848380
+go1.13.9b4 bb8a1014a32c linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.13.9b4.linux-amd64.tar.gz 565e1a3c62dfc2586471b6ae189ada053a86fc51d88d2eac883a03731071bf77
+go1.13.9b4 bb8a1014a32c src https://go-boringcrypto.storage.googleapis.com/go1.13.9b4.src.tar.gz 536f0549e7bbdad32270a17d8a282667560b6da2d27a5e3580714338e70185ad
+go1.14.1b4 e784c3f4d925 linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.14.1b4.linux-amd64.tar.gz 6570991396d531fb628e4c01d697eeee395104147d406aec5a8ba00a213ef63f
+go1.14.1b4 e784c3f4d925 src https://go-boringcrypto.storage.googleapis.com/go1.14.1b4.src.tar.gz 2c267c3114fa4683f51c281d216d3754b38d5d08144c3acc318cf37165b1b2da
+go1.13.10b4 b129f40bb33f linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.13.10b4.linux-amd64.tar.gz a511b2e6ee7b71ca1411d6e4bb07ec33bb5b6974fd1dded77e00520d24d9d000
+go1.13.10b4 b129f40bb33f src https://go-boringcrypto.storage.googleapis.com/go1.13.10b4.src.tar.gz 5dfa44eea19b0be0c9c394fbbf89b2a14f84380a9d7b87e21eacba3ba030c44b
+go1.14.2b4 2b0d842f4b24 linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.14.2b4.linux-amd64.tar.gz 82449a7ce57733c0cd3fa7feac89214706ff2b04e387b62619b8e2b8b388ffd9
+go1.14.2b4 2b0d842f4b24 src https://go-boringcrypto.storage.googleapis.com/go1.14.2b4.src.tar.gz bfcb44fa329d6a2eb5c4ef58bfa114d65b078bf69a361bb77e3ea52ec8975d14
+go1.13.12b4 488ca930b24a linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.13.12b4.linux-amd64.tar.gz 63193aa2290af5d65d2d6bbddcd11d835d437a4e835954d605863f5b27a7661d
+go1.13.12b4 488ca930b24a src https://go-boringcrypto.storage.googleapis.com/go1.13.12b4.src.tar.gz 5b0aefb44ba2a08fedb5be0144810bc47559d7d8a6e61638c09dd261706d650e
+go1.14.4b4 fcdb6aa6ee5d linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.14.4b4.linux-amd64.tar.gz 682f2167b3d619690b1385196776822b1d2c497607f67e2d19d92faf2bea0b4a
+go1.14.4b4 fcdb6aa6ee5d src https://go-boringcrypto.storage.googleapis.com/go1.14.4b4.src.tar.gz 2fb759023360f0d42ba434f0409da2460ff4386cab062557f97fe15122b4b4cd
+go1.13.14b4 852ccd9de7d1 linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.13.14b4.linux-amd64.tar.gz 49c67d3a67fac60e18a264555392aa5925126a75ef0ba152ec315cc874eccb43
+go1.13.14b4 852ccd9de7d1 src https://go-boringcrypto.storage.googleapis.com/go1.13.14b4.src.tar.gz 7b7dfc62286a07d438370b09f38845acae99c592c6e147722b8f3c098ab8756a
+go1.14.6b4 8f53ffb15fd5 linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.14.6b4.linux-amd64.tar.gz 953322287806a42d4a73e096aea45511a51a0a323086e98119edcb0dae866c9d
+go1.14.6b4 8f53ffb15fd5 src https://go-boringcrypto.storage.googleapis.com/go1.14.6b4.src.tar.gz 75fea7a60da4ca225473b500b2d5ce7c302ca7d22eedfdbd3444cd01e6b9f392
+go1.15b5 a15df605fc4a linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.15b5.linux-amd64.tar.gz ebcb2212bdb645a16ffc05a1d9b77c94553ed19a6ccbbc73e4868c64777eb70a
+go1.15b5 a15df605fc4a src https://go-boringcrypto.storage.googleapis.com/go1.15b5.src.tar.gz 7107665853228b2c18f56fec73e217fa3494ccf52c609be839cf6945d501c0f0
+go1.13.15b4 5622128a77b4 linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.13.15b4.linux-amd64.tar.gz 8b45ec0e578dc0a0bc483c2d12c08fee5adbfb39f0854fbe9d45f7d628ed1697
+go1.13.15b4 5622128a77b4 src https://go-boringcrypto.storage.googleapis.com/go1.13.15b4.src.tar.gz 21eab29a61a43078cd8bcdbbbb4c82ca049a7e2e211aca0c95f6a306e288db4f
+go1.14.9b4 62cd3338eed7 linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.14.9b4.linux-amd64.tar.gz c81946294cbefa7a3abdf47733c720c3454418d6881c137a2e28f18ea40977aa
+go1.14.9b4 62cd3338eed7 src https://go-boringcrypto.storage.googleapis.com/go1.14.9b4.src.tar.gz e9c13c4daa10f6aac80b703f61f7e931af92e92146c8b140ae79e20e4af6bccd
+go1.15.2b5 dbc5602d1839 linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.15.2b5.linux-amd64.tar.gz 30c04d854fc8990017ee8c180c1407a4f26c016e3a4134161bbf41c9d16452e3
+go1.15.2b5 dbc5602d1839 src https://go-boringcrypto.storage.googleapis.com/go1.15.2b5.src.tar.gz 67432c0b0a02aa6cc0c49ab285f1c6935a16dadfebd77dfabca7e31907240bc9
+go1.14.10b4 b5fc12785be4 linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.14.10b4.linux-amd64.tar.gz d3aa38fb5108b43b155c21529190e73789df6ca0b37feafd43438aefe42f936e
+go1.14.10b4 b5fc12785be4 src https://go-boringcrypto.storage.googleapis.com/go1.14.10b4.src.tar.gz daf7603babc49935efdea5befb2ecad823771523a84d1ba6c0e8c10fac982d59
+go1.15.3b5 ed9dc25d693c linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.15.3b5.linux-amd64.tar.gz 34ec7ec094f5e9349f1612b5f6d8f014b3a7b37b6986aeedcd0fe7cf2dc76a62
+go1.15.3b5 ed9dc25d693c src https://go-boringcrypto.storage.googleapis.com/go1.15.3b5.src.tar.gz bc37727287366aabb47594717cebd0a759147d8b2eb4cd3a45a19317af199fe9
+go1.14.12b4 21ba30ad409a linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.14.12b4.linux-amd64.tar.gz 7f9fb67a3c59fff24e3c51fa2a7435f4195cfb33844c9c2def27c162cc23604b
+go1.14.12b4 21ba30ad409a src https://go-boringcrypto.storage.googleapis.com/go1.14.12b4.src.tar.gz 948d7a77a4a890a7258102bcc7b63890f238061dfb6a4c06033660e727e87fcf
+go1.15.5b5 11087322f85d linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.15.5b5.linux-amd64.tar.gz 9c97488137f1f560b3fff0d8a2a9c45d2de8790fb8952a42b46cc4633528fc48
+go1.15.5b5 11087322f85d src https://go-boringcrypto.storage.googleapis.com/go1.15.5b5.src.tar.gz ee933cb1a4b591794dbcce99740032506af25ee202765dcc6979feb5abc114fc
+go1.14.13b4 2bb8e5a94e8a linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.14.13b4.linux-amd64.tar.gz 8fb6e1cefe5535ab704e1b4e26725095dcca0060490842a54dd93e7cd8b206cd
+go1.14.13b4 2bb8e5a94e8a src https://go-boringcrypto.storage.googleapis.com/go1.14.13b4.src.tar.gz 02e0c4871d12813aee1019bf189b77ccec99dab3a1d5b95ce6abdf85b1810703
+go1.15.6b5 f78276931172 linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.15.6b5.linux-amd64.tar.gz 245c500f7da70fb2abd1a6021436ed48e2b97dbbdb394a759b0601dc69cf4e77
+go1.15.6b5 f78276931172 src https://go-boringcrypto.storage.googleapis.com/go1.15.6b5.src.tar.gz 6576a29d019405b14fdc98883fed33c766de2028fbbd3a743a241275275cc7e5
+go1.14.14b4 9cf003256bc3 linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.14.14b4.linux-amd64.tar.gz 7df65366d26a13c5be16f87f64e832e86db3b8b9ca1b5c6385e0e20bf79dc82f
+go1.14.14b4 9cf003256bc3 src https://go-boringcrypto.storage.googleapis.com/go1.14.14b4.src.tar.gz aaeda57e2b68ac72783c7aacded814ec660a91c1010c3139156c8e7def86f145
+go1.15.7b5 79ea7a16d7e3 linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.15.7b5.linux-amd64.tar.gz cb08962897e3802cda96f4ee915ed20fbde7d5d85e688759ef523d2e6ae44851
+go1.15.7b5 79ea7a16d7e3 src https://go-boringcrypto.storage.googleapis.com/go1.15.7b5.src.tar.gz aa7cb4beff82881cbff4a66e9e07a4004e49384a8fcc95204db9b2f48c12a235
+go1.15.8b5 2a0dd053ecfa linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.15.8b5.linux-amd64.tar.gz 9d897bf42a962b064cfc9bed182c18ade0a3f5857d6a075d93b73ca8fe3b1f3a
+go1.15.8b5 2a0dd053ecfa src https://go-boringcrypto.storage.googleapis.com/go1.15.8b5.src.tar.gz 57964e7762ab03f0ad17bc787585b1709decccf095b7f7d2e9fca61a71e09010
+go1.14.15b4 47419f9cac61 linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.14.15b4.linux-amd64.tar.gz 82ba7297d26afcdade439de5621bdcb16e5261877f204aa60d03b5e07223a5c8
+go1.14.15b4 47419f9cac61 src https://go-boringcrypto.storage.googleapis.com/go1.14.15b4.src.tar.gz bf77b15f1d905753648db2d91e39c3a740b67b03dfff511aa25a360a78f9742a
+go1.16b7 67a0be0b437e linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.16b7.linux-amd64.tar.gz 56d4e41d55baece6b98bc66bdf772b0eb17518dd287f27c533225cd154ee0a38
+go1.16b7 67a0be0b437e src https://go-boringcrypto.storage.googleapis.com/go1.16b7.src.tar.gz 7d063cf1cbd252da8b2db54947e5f2f1402ac792e1ea6de76e05ab233f5badbd
+go1.15.9b5 055f1da6e6b9 linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.15.9b5.linux-amd64.tar.gz 8e44de7d9d36d68e01c0454841f1becb93d4932bb16a623ed6d4de15ecba1239
+go1.15.9b5 055f1da6e6b9 src https://go-boringcrypto.storage.googleapis.com/go1.15.9b5.src.tar.gz dba0290da6ae46df8d68c6d027b7d6b4775d6dcf8ff9f3cb8a26dbd5b757e696
+go1.16.1b7 b9bd851b1452 linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.16.1b7.linux-amd64.tar.gz 963f6a4fb8c5ff7668fb17ba52c3d905466058266556844aee79139f7e3c9521
+go1.16.1b7 b9bd851b1452 src https://go-boringcrypto.storage.googleapis.com/go1.16.1b7.src.tar.gz 8e6849010ae5f3280fea0f6fa6e5b07831ac6e6524a636fab41c0e4f77b529ba
+go1.15.10b5 229a39e34717 linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.15.10b5.linux-amd64.tar.gz 7533b0307fd995deb9ef68d67899582c336a3c62387d19d03d10202129e9fad3
+go1.15.10b5 229a39e34717 src https://go-boringcrypto.storage.googleapis.com/go1.15.10b5.src.tar.gz adbaff96b2392a9ab5a20d15fec959983861ec6e554c3c9cd14aec586a0928b3
+go1.16.2b7 6d5f0ffc93e5 linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.16.2b7.linux-amd64.tar.gz 2871d90630706eba9d3bd2838ec1c0a367c78c2c4f40e74ed75c294e2c5aa358
+go1.16.2b7 6d5f0ffc93e5 src https://go-boringcrypto.storage.googleapis.com/go1.16.2b7.src.tar.gz 8991c28e30bdd9b34076c2871ab69aac7f306dba08d202aa7301f3adb54ad9f3
+go1.15.11b5 be25192f119e linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.15.11b5.linux-amd64.tar.gz c5aa34a83631b3736bc1ab37027bc4fc22eca2353035586a6255be7e29251f43
+go1.15.11b5 be25192f119e src https://go-boringcrypto.storage.googleapis.com/go1.15.11b5.src.tar.gz 05408824d64ac8ebb6c1d895017e605d45a2c4ebee28995136fe12f4833652d2
+go1.16.3b7 fcee6b930a01 linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.16.3b7.linux-amd64.tar.gz afe15efce3c1fecc60994d7ba0d41daaa029fa5810c98737121dde7b38a5e2ac
+go1.16.3b7 fcee6b930a01 src https://go-boringcrypto.storage.googleapis.com/go1.16.3b7.src.tar.gz 5c86175ed86e6ae3826eb827cc51bdda770f22ffaf3258b11135a268153b5057
+go1.16.4b7 25aff96f4b49 linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.16.4b7.linux-amd64.tar.gz de60f0620f46b1872813f72646fdece76be94f43c1abe84b69033c26f823a31f
+go1.16.4b7 25aff96f4b49 src https://go-boringcrypto.storage.googleapis.com/go1.16.4b7.src.tar.gz 5b537cf5598bc968764885f4d1f9820578d05d104a6cd7107bb3e443217f4983
+go1.15.12b5 03a15201e7e0 linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.15.12b5.linux-amd64.tar.gz 9fadc65da7df036bfe702b3f9980e2ca2b184f13d09e8094244f58a866a2f6ee
+go1.15.12b5 03a15201e7e0 src https://go-boringcrypto.storage.googleapis.com/go1.15.12b5.src.tar.gz 81ec958d893f4ecf90111d09ceb79b36492266a39d1918a22e80443e1d399561
+go1.16.5b7 e4feea2ce841 linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.16.5b7.linux-amd64.tar.gz 2085b246d7d6908f504d0f33c655c31c3ec6e1ae3d13a020ba58abcf1b6ea7a4
+go1.16.5b7 e4feea2ce841 src https://go-boringcrypto.storage.googleapis.com/go1.16.5b7.src.tar.gz cfe6cc16eb205d61414338c2b42fa2c4278831785b29e6b79712669418852ef4
+go1.15.13b5 9647f89f2ac2 linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.15.13b5.linux-amd64.tar.gz 1ad1edeaf3b6bc7696978d4137f55c0b38b8d796a607b89f7f010004aaef60a6
+go1.15.13b5 9647f89f2ac2 src https://go-boringcrypto.storage.googleapis.com/go1.15.13b5.src.tar.gz 6cc9c5d23947a9dccc0e1afdff5d433398b09df1c5170596a826aac326ece457
+go1.15.14b5 ddf078e08dc6 linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.15.14b5.linux-amd64.tar.gz 8c4dbdc91e36f3d1db7f14b234973bfcb3b685fe4a6cb2e326ba9cf73a4260c2
+go1.15.14b5 ddf078e08dc6 src https://go-boringcrypto.storage.googleapis.com/go1.15.14b5.src.tar.gz 0022b68f04a5d8553cfd838d3fe226f18e7095194300b2be4fc49a689daf0e1b
+go1.16.6b7 6a6b41a8441e linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.16.6b7.linux-amd64.tar.gz f7f33064643ce0ab8ac1cede100e7eee8509a970178f5be961d9fba331226067
+go1.16.6b7 6a6b41a8441e src https://go-boringcrypto.storage.googleapis.com/go1.16.6b7.src.tar.gz a1079dd2df6aad3bad584c4187dab98a264075b56b1d257ba27d956340ff7bbf
+go1.15.15b5 dd96ded6c86b linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.15.15b5.linux-amd64.tar.gz 719d818f70c6eb1e753910fe21624832cf3f719540f22f89863e959ff68c0001
+go1.15.15b5 dd96ded6c86b src https://go-boringcrypto.storage.googleapis.com/go1.15.15b5.src.tar.gz af2d44c8eef02e093c077c085fbe6964af0ca715f95f4bcea0809fa211cc4ded
+go1.16.7b7 0d02a0d966b6 linux-amd64 https://go-boringcrypto.storage.googleapis.com/go1.16.7b7.linux-amd64.tar.gz d4ca2906640edd9299d12d8204aae0d848b497b79b92424d8705ae748e16f3c5
+go1.16.7b7 0d02a0d966b6 src https://go-boringcrypto.storage.googleapis.com/go1.16.7b7.src.tar.gz f65503abf459ba1d2f77d4d023fcebd19c62e7c34d3ffd0f1aebb598ffa153d9

misc/boring/VERSION

@@ -0,0 +1 @@
+7

misc/boring/build.docker

@@ -0,0 +1,56 @@
+#!/bin/bash
+# Copyright 2017 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.
+
+# build.docker builds and publishes a Docker image for
+# a given Go+BoringCrypto release.
+
+set -e
+
+# With no arguments, use the most recent linux-amd64 release in the RELEASES file.
+case "$#" in
+0)
+	version=$(grep linux-amd64 RELEASES | tail -1 | awk '{print $1}');;
+1)
+	version="$1";;
+*)
+	echo 'usage: build.docker [version]' >&2
+	exit 2
+esac
+
+url="$(grep "^$version .* linux-amd64 " RELEASES | awk '{print $4}')"
+sha256="$(grep "^$version .* linux-amd64 " RELEASES | awk '{print $5}')"
+if [ "$sha256" = "" ]; then
+	echo "cannot find $version in RELEASES file" >&2
+	exit 2
+fi
+
+# Build a temporary directory with a Dockerfile.
+dir=$(mktemp -d)
+trap "rm -rf $dir" EXIT
+
+if echo "$url" | grep '!' >/dev/null; then
+	# ! is sed delimiter below. Should never happen.
+	echo "URL contains an exclamation mark!" >&2
+	exit 2
+fi
+
+dversion=$(echo "$version" | sed 's/^go//')
+sed "s!UUU!$url!; s/SSS/$sha256/; s/VVV/$dversion/" dockerfile.in >$dir/Dockerfile
+
+docker build --pull -t goboring/golang:$dversion $dir
+docker run goboring/golang:$dversion go version
+docker run goboring/golang:$dversion go tool nm /usr/local/go/bin/go >$dir/nm
+if ! grep crypto/internal/boring/sig.BoringCrypto $dir/nm >/dev/null; then
+	echo 'built docker image but did NOT find sig.BoringCrypto in go command!' >&2
+	exit 2
+fi
+if egrep 'crypto/sha256\.\(\*digest\)' $dir/nm >/dev/null; then
+	echo 'built docker image but DID find sha256.(*digest) in go command unexpectedly!' >&2
+	exit 2
+fi
+docker push goboring/golang:$dversion
+
+echo
+echo published as goboring/golang:$dversion

misc/boring/build.release

@@ -0,0 +1,102 @@
+#!/bin/bash
+# Copyright 2017 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.
+
+# build.release builds and publishes a new Go+BoringCrypto release.
+# After running this script, the change to the RELEASES file should be
+# sent out for review and committed to the repository (but the release
+# is already done, so there's not much to review).
+
+set -e
+
+case "$#" in
+0)
+	rev=HEAD;;
+1)
+	rev="$1";;
+*)
+	echo 'usage: build.release [git-rev]' >&2
+	exit 2
+esac
+
+# Determine commit to use.
+commit=$(git rev-parse "$rev" | awk '{print substr($1, 1, 12)}')
+if [ "$commit" = "" ]; then
+	echo 'cannot find commit in git history' >&2
+	exit 2
+fi
+
+# Determine base Go release from tags.
+base=$(git log --decorate=short --oneline "$rev" | grep 'tag: go' | sed 1q | sed 's/[),].*//; s/.*tag: //')
+if [ "$base" = "" ]; then
+	echo "cannot find go release tag in git history for $rev" >&2
+	exit 2
+fi
+
+# Determine boring crypto version from file.
+boring=$(git show "$commit:misc/boring/VERSION")
+if [ "$boring" = "" ]; then
+	echo "missing BORINGVERSION file in $commit" >&2
+	exit 2
+fi
+
+# Make sure we're not redefining a published release.
+version="${base}b${boring}"
+if grep "^$version " RELEASES >/dev/null; then
+	echo "found $version in RELEASES - not rereleasing" >&2
+	exit 2
+fi
+
+# Show what's going on, while the release builds.
+# Good time for user to type ^C if something is wrong.
+echo >&2
+echo "building $version from $commit" >&2
+echo >&2
+git log -n1 "$commit" >&2
+echo >&2
+
+# Build the release tool in a temporary directory.
+dir=$(mktemp -d)
+trap "rm -rf $dir" EXIT
+GOBIN="$dir" go install golang.org/x/build/cmd/release@latest
+
+# Build the release.
+sha() {
+    if hash sha256sum 2>/dev/null; then
+        sha256sum "$@"
+    else
+        shasum -a 256 "$@"
+    fi
+}
+shortgo=$(echo "$base" | perl -pe 's/(go\d+\.\d+)(\.\d+|rc\d+)/$1/')
+$dir/release -target linux-amd64 -rev "$commit" -version "$version"
+$dir/release -target src -rev "$commit" -version "$version"
+output="$version.linux-amd64.tar.gz"
+ls -l "$output"
+sha256=$(sha "$output" | awk '{print $1}')
+outputsrc="$version.src.tar.gz"
+ls -l "$outputsrc"
+sha256src=$(sha "$outputsrc" | awk '{print $1}')
+
+trap "rm -f /tmp/go.release.$$ /tmp/go.nm.$$" EXIT
+tar -xzf "$output" -O go/bin/go >/tmp/go.release.$$
+go tool nm /tmp/go.release.$$ >/tmp/go.nm.$$
+if ! grep crypto/internal/boring/sig.BoringCrypto /tmp/go.nm.$$ >/dev/null; then
+	echo 'built release but did NOT find sig.BoringCrypto in go command!' >&2
+	exit 2
+fi
+if egrep 'crypto/sha256\.\(\*digest\)' /tmp/go.nm.$$ >/dev/null; then
+	echo 'built release but DID find sha256.(*digest) in go command unexpectedly!' >&2
+	exit 2
+fi
+
+# Publish the release.
+gsutil cp "$output" gs://go-boringcrypto/
+url="https://go-boringcrypto.storage.googleapis.com/$output"
+gsutil cp "$outputsrc" gs://go-boringcrypto/
+urlsrc="https://go-boringcrypto.storage.googleapis.com/$outputsrc"
+
+# Record that it was published.
+echo "$version $commit linux-amd64 $url $sha256" >>RELEASES
+echo "$version $commit src $urlsrc $sha256src" >>RELEASES

misc/boring/dockerfile.in

@@ -0,0 +1,31 @@
+# Template for Dockerfile, used in build.docker script.
+# Based on https://github.com/docker-library/golang/blob/7e3d99a803/1.13/buster/Dockerfile
+FROM buildpack-deps:buster-scm
+
+# gcc for cgo
+RUN apt-get update && apt-get install -y --no-install-recommends \
+		g++ \
+		gcc \
+		libc6-dev \
+		make \
+		pkg-config \
+	&& rm -rf /var/lib/apt/lists/*
+
+ENV GOLANG_VERSION VVV
+
+RUN set -eux; \
+	\
+	url="UUU"; \
+	wget -O go.tgz "$url"; \
+	echo "SSS go.tgz" | sha256sum -c -; \
+	tar -C /usr/local -xzf go.tgz; \
+	rm go.tgz; \
+	\
+	export PATH="/usr/local/go/bin:$PATH"; \
+	go version
+
+ENV GOPATH /go
+ENV PATH $GOPATH/bin:/usr/local/go/bin:$PATH
+
+RUN mkdir -p "$GOPATH/src" "$GOPATH/bin" && chmod -R 777 "$GOPATH"
+WORKDIR $GOPATH

misc/boring/merge.sh

@@ -0,0 +1,34 @@
+#! /bin/bash
+set -euo pipefail
+
+if [ "$#" -ne 2 ]; then
+    echo "usage: merge.sh <target branch> <source revision>"
+    echo ""
+    echo "example: merge.sh dev.boringcrypto master"
+    echo "         merge.sh dev.boringcrypto.go1.10 go1.10.7"
+    exit 1
+fi
+
+TARGET="$1"
+SOURCE="$2"
+WORKTREE="$(mktemp -d)"
+BRANCH="boring/merge-$TARGET-$(date +%Y%m%d%H%M%S)"
+
+git fetch
+git worktree add --track -b "$BRANCH" "$WORKTREE" "origin/$TARGET"
+
+cd "$WORKTREE"
+export GIT_GOFMT_HOOK=off
+git merge --no-commit --no-stat "$SOURCE" || echo "Ignoring conflict..."
+[[ -f VERSION ]] && git rm -f VERSION
+git checkout --ours codereview.cfg && git add codereview.cfg
+git commit -m "all: merge $SOURCE into $TARGET"
+
+if ! git log --format=%B -n 1 | grep "\[$TARGET\] "; then
+    echo "The commit does not seem to be targeting the BoringCrypto branch."
+    echo "(Or you are missing the git-codereview hooks.)"
+    exit 1
+fi
+
+git codereview mail -r katie@golang.org,roland@golang.org,filippo@golang.org -trybot -trust HEAD
+cd - && git worktree remove "$WORKTREE"

misc/boring/release.sh

@@ -0,0 +1,34 @@
+#! /bin/bash
+set -euo pipefail
+
+if [ "$#" -eq 0 ]; then
+    echo "usage: <target branch> [<target branch> ...]"
+    echo ""
+    echo "example: release.sh dev.boringcrypto.go1.11 dev.boringcrypto.go1.12"
+    exit 1
+fi
+
+# Check that the Docker daemon is available.
+docker ps > /dev/null
+
+WORKTREE="$(mktemp -d)"
+BRANCH="boring/release-$(date +%Y%m%d%H%M%S)"
+
+git fetch
+git worktree add --track -b "$BRANCH" "$WORKTREE" origin/dev.boringcrypto
+
+cd "$WORKTREE/src"
+./make.bash
+
+cd ../misc/boring
+for branch in "$@"; do
+    ./build.release "origin/$branch"
+    ./build.docker
+done
+
+git add RELEASES
+git commit -m "misc/boring: add new releases to RELEASES file"
+git codereview mail -r katie@golang.org,roland@golang.org,filippo@golang.org -trust
+
+rm *.tar.gz
+cd - && git worktree remove "$WORKTREE"

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"
@@ -41,16 +41,16 @@ func (v *Visitor) Visit(node ast.Node) ast.Visitor {
 			var errorMessage strings.Builder
 			for caseIndex, expectedPos := range expectedPositions {
 				actualPosition := v.fset.PositionFor(ident.Pos(), true)
-				errorOccurred := false
+				errorOccured := false
 				if expectedPos.Line != actualPosition.Line {
 					fmt.Fprintf(&errorMessage, "wrong line number for ident %s: expected: %d got: %d\n", ident.Name, expectedPos.Line, actualPosition.Line)
-					errorOccurred = true
+					errorOccured = true
 				}
 				if expectedPos.Column != actualPosition.Column {
 					fmt.Fprintf(&errorMessage, "wrong column number for ident %s: expected: %d got: %d\n", ident.Name, expectedPos.Column, actualPosition.Column)
-					errorOccurred = true
+					errorOccured = true
 				}
-				if errorOccurred {
+				if errorOccured {
 					continue
 				}
 				gotMatch = true
@@ -58,7 +58,7 @@ func (v *Visitor) Visit(node ast.Node) ast.Visitor {
 			}
 
 			if !gotMatch {
-				v.t.Error(errorMessage.String())
+				v.t.Errorf(errorMessage.String())
 			}
 		}
 	}
@@ -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)
@@ -81,7 +78,7 @@ func TestArgumentsPositions(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	cmd := exec.Command(testenv.GoToolPath(t), "tool", "cgo",
+	cmd := exec.Command("go", "tool", "cgo",
 		"-srcdir", testdata,
 		"-objdir", dir,
 		"issue42580.go")
@@ -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 {
@@ -136,7 +131,7 @@ func TestBadSymbol(t *testing.T) {
 	makeFile(godir, "go.mod", "module badsym")
 
 	// Try to build our little package.
-	cmd := exec.Command(testenv.GoToolPath(t), "build", "-ldflags=-v")
+	cmd := exec.Command("go", "build", "-ldflags=-v")
 	cmd.Dir = godir
 	output, err := cmd.CombinedOutput()
 
@@ -172,21 +167,14 @@ 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'
 	start := 0
 	lastSpace := true
 	backslash := false
-	s := out
+	s := string(out)
 	for i, c := range s {
 		if quote == '\000' && unicode.IsSpace(c) {
 			if !lastSpace {
@@ -213,10 +201,6 @@ func cCompilerCmd(t *testing.T) []string {
 	if !lastSpace {
 		cc = append(cc, s[start:])
 	}
-
-	// Force reallocation (and avoid aliasing bugs) for tests that append to cc.
-	cc = cc[:len(cc):len(cc)]
-
 	return cc
 }
 

misc/cgo/errors/errors_test.go

@@ -0,0 +1,158 @@
+// Copyright 2017 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 errorstest
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func path(file string) string {
+	return filepath.Join("testdata", file)
+}
+
+func check(t *testing.T, file string) {
+	t.Run(file, func(t *testing.T) {
+		t.Parallel()
+
+		contents, err := os.ReadFile(path(file))
+		if err != nil {
+			t.Fatal(err)
+		}
+		var errors []*regexp.Regexp
+		for i, line := range bytes.Split(contents, []byte("\n")) {
+			if bytes.HasSuffix(line, []byte("ERROR HERE")) {
+				re := regexp.MustCompile(regexp.QuoteMeta(fmt.Sprintf("%s:%d:", file, i+1)))
+				errors = append(errors, re)
+				continue
+			}
+
+			frags := bytes.SplitAfterN(line, []byte("ERROR HERE: "), 2)
+			if len(frags) == 1 {
+				continue
+			}
+			frag := fmt.Sprintf(":%d:.*%s", i+1, frags[1])
+			re, err := regexp.Compile(frag)
+			if err != nil {
+				t.Errorf("Invalid regexp after `ERROR HERE: `: %#q", frags[1])
+				continue
+			}
+			errors = append(errors, re)
+		}
+		if len(errors) == 0 {
+			t.Fatalf("cannot find ERROR HERE")
+		}
+		expect(t, file, errors)
+	})
+}
+
+func expect(t *testing.T, file string, errors []*regexp.Regexp) {
+	dir, err := os.MkdirTemp("", filepath.Base(t.Name()))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(dir)
+
+	dst := filepath.Join(dir, strings.TrimSuffix(file, ".go"))
+	cmd := exec.Command("go", "build", "-gcflags=-L -e", "-o="+dst, path(file)) // TODO(gri) no need for -gcflags=-L if go tool is adjusted
+	out, err := cmd.CombinedOutput()
+	if err == nil {
+		t.Errorf("expected cgo to fail but it succeeded")
+	}
+
+	lines := bytes.Split(out, []byte("\n"))
+	for _, re := range errors {
+		found := false
+		for _, line := range lines {
+			if re.Match(line) {
+				t.Logf("found match for %#q: %q", re, line)
+				found = true
+				break
+			}
+		}
+		if !found {
+			t.Errorf("expected error output to contain %#q", re)
+		}
+	}
+
+	if t.Failed() {
+		t.Logf("actual output:\n%s", out)
+	}
+}
+
+func sizeofLongDouble(t *testing.T) int {
+	cmd := exec.Command("go", "run", path("long_double_size.go"))
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		t.Fatalf("%#q: %v:\n%s", strings.Join(cmd.Args, " "), err, out)
+	}
+
+	i, err := strconv.Atoi(strings.TrimSpace(string(out)))
+	if err != nil {
+		t.Fatalf("long_double_size.go printed invalid size: %s", out)
+	}
+	return i
+}
+
+func TestReportsTypeErrors(t *testing.T) {
+	for _, file := range []string{
+		"err1.go",
+		"err2.go",
+		"issue11097a.go",
+		"issue11097b.go",
+		"issue18452.go",
+		"issue18889.go",
+		"issue28721.go",
+		"issue33061.go",
+	} {
+		check(t, file)
+	}
+
+	if sizeofLongDouble(t) > 8 {
+		for _, file := range []string{
+			"err4.go",
+			"issue28069.go",
+		} {
+			check(t, file)
+		}
+	}
+}
+
+func TestToleratesOptimizationFlag(t *testing.T) {
+	for _, cflags := range []string{
+		"",
+		"-O",
+	} {
+		cflags := cflags
+		t.Run(cflags, func(t *testing.T) {
+			t.Parallel()
+
+			cmd := exec.Command("go", "build", path("issue14669.go"))
+			cmd.Env = append(os.Environ(), "CGO_CFLAGS="+cflags)
+			out, err := cmd.CombinedOutput()
+			if err != nil {
+				t.Errorf("%#q: %v:\n%s", strings.Join(cmd.Args, " "), err, out)
+			}
+		})
+	}
+}
+
+func TestMallocCrashesOnNil(t *testing.T) {
+	t.Parallel()
+
+	cmd := exec.Command("go", "run", path("malloc.go"))
+	out, err := cmd.CombinedOutput()
+	if err == nil {
+		t.Logf("%#q:\n%s", strings.Join(cmd.Args, " "), out)
+		t.Fatalf("succeeded unexpectedly")
+	}
+}

misc/cgo/errors/ptr_test.go

@@ -10,12 +10,9 @@ import (
 	"bytes"
 	"flag"
 	"fmt"
-	"internal/testenv"
 	"os"
 	"os/exec"
 	"path/filepath"
-	"regexp"
-	"slices"
 	"strings"
 	"sync/atomic"
 	"testing"
@@ -25,16 +22,15 @@ var tmp = flag.String("tmp", "", "use `dir` for temporary files and do not clean
 
 // ptrTest is the tests without the boilerplate.
 type ptrTest struct {
-	name          string   // for reporting
-	c             string   // the cgo comment
-	c1            string   // cgo comment forced into non-export cgo file
-	imports       []string // a list of imports
-	support       string   // supporting functions
-	body          string   // the body of the main function
-	extra         []extra  // extra files
-	fail          bool     // whether the test should fail
-	expensive     bool     // whether the test requires the expensive check
-	errTextRegexp string   // error text regexp; if empty, use the pattern `.*unpinned Go.*`
+	name      string   // for reporting
+	c         string   // the cgo comment
+	c1        string   // cgo comment forced into non-export cgo file
+	imports   []string // a list of imports
+	support   string   // supporting functions
+	body      string   // the body of the main function
+	extra     []extra  // extra files
+	fail      bool     // whether the test should fail
+	expensive bool     // whether the test requires the expensive check
 }
 
 type extra struct {
@@ -165,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.
@@ -254,10 +239,7 @@ var ptrTests = []ptrTest{
 	{
 		// Exported functions may not return Go pointers.
 		name: "export1",
-		c: `#ifdef _WIN32
-		    __declspec(dllexport)
-			#endif
-		    extern unsigned char *GoFn21();`,
+		c:    `extern unsigned char *GoFn21();`,
 		support: `//export GoFn21
 		          func GoFn21() *byte { return new(byte) }`,
 		body: `C.GoFn21()`,
@@ -267,9 +249,6 @@ var ptrTests = []ptrTest{
 		// Returning a C pointer is fine.
 		name: "exportok",
 		c: `#include <stdlib.h>
-		    #ifdef _WIN32
-		    __declspec(dllexport)
-			#endif
 		    extern unsigned char *GoFn22();`,
 		support: `//export GoFn22
 		          func GoFn22() *byte { return (*byte)(C.malloc(1)) }`,
@@ -452,74 +431,33 @@ 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,
-	},
-	{
-		// Passing the address of an element of a pointer-to-array.
-		name:    "arraypointer",
-		c:       `void f44(void* p) {}`,
-		imports: []string{"unsafe"},
-		body:    `a := new([10]byte); C.f44(unsafe.Pointer(&a[0]))`,
-		fail:    false,
-	},
-	{
-		// Passing the address of an element of a pointer-to-array
-		// that contains a Go pointer.
-		name:    "arraypointer2",
-		c:       `void f45(void** p) {}`,
-		imports: []string{"unsafe"},
-		body:    `i := 0; a := &[2]unsafe.Pointer{nil, unsafe.Pointer(&i)}; C.f45(&a[0])`,
-		fail:    true,
-	},
-	{
-		// Passing a Go map as argument to C.
-		name:          "argmap",
-		c:             `void f46(void* p) {}`,
-		imports:       []string{"unsafe"},
-		body:          `m := map[int]int{0: 1,}; C.f46(unsafe.Pointer(&m))`,
-		fail:          true,
-		errTextRegexp: `.*argument of cgo function has Go pointer to unpinned Go map`,
-	},
-	{
-		// Returning a Go map to C.
-		name: "retmap",
-		c:    `extern void f47();`,
-		support: `//export GoMap47
-		          func GoMap47() map[int]int { return map[int]int{0: 1,} }`,
-		body: `C.f47()`,
-		c1: `extern void* GoMap47();
-		     void f47() { GoMap47(); }`,
-		fail:          true,
-		errTextRegexp: `.*result of Go function GoMap47 called from cgo is unpinned Go map or points to unpinned Go map.*`,
-	},
 }
 
 func TestPointerChecks(t *testing.T) {
-	testenv.MustHaveGoBuild(t)
-	testenv.MustHaveCGO(t)
+	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
+	// the parallel subtests to finish. This code looks racy but is not:
+	// the add +1 run in serial before testOne blocks. The -1 run in parallel
+	// after testOne finishes.
+	var pending int32
+	for _, pt := range ptrTests {
+		pt := pt
+		t.Run(pt.name, func(t *testing.T) {
+			atomic.AddInt32(&pending, +1)
+			defer func() {
+				if atomic.AddInt32(&pending, -1) == 0 {
+					os.RemoveAll(dir)
+				}
+			}()
+			testOne(t, pt, exe)
+		})
+	}
+}
+
+func buildPtrTests(t *testing.T) (dir, exe string) {
 	var gopath string
-	var dir string
 	if *tmp != "" {
 		gopath = *tmp
 		dir = ""
@@ -532,35 +470,11 @@ func TestPointerChecks(t *testing.T) {
 		gopath = d
 	}
 
-	exe := buildPtrTests(t, gopath, false)
-	exe2 := buildPtrTests(t, gopath, true)
-
-	// We (TestPointerChecks) return before the parallel subtest functions do,
-	// so we can't just defer os.RemoveAll(dir). Instead we have to wait for
-	// the parallel subtests to finish. This code looks racy but is not:
-	// the add +1 run in serial before testOne blocks. The -1 run in parallel
-	// after testOne finishes.
-	var pending int32
-	for _, pt := range ptrTests {
-		t.Run(pt.name, func(t *testing.T) {
-			atomic.AddInt32(&pending, +1)
-			defer func() {
-				if atomic.AddInt32(&pending, -1) == 0 {
-					os.RemoveAll(dir)
-				}
-			}()
-			testOne(t, pt, exe, exe2)
-		})
-	}
-}
-
-func buildPtrTests(t *testing.T, gopath string, cgocheck2 bool) (exe string) {
-
 	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)
 	}
 
@@ -627,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(testenv.GoToolPath(t), "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 = slices.Delete(goexperiment, i, 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 = `
@@ -675,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
@@ -683,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()
 	}
@@ -712,17 +598,11 @@ func testOne(t *testing.T, pt ptrTest, exe, exe2 string) {
 	}
 
 	buf, err := runcmd(cgocheck)
-
-	var pattern string = pt.errTextRegexp
-	if pt.errTextRegexp == "" {
-		pattern = `.*unpinned Go.*`
-	}
-
 	if pt.fail {
 		if err == nil {
 			t.Logf("%s", buf)
 			t.Fatalf("did not fail as expected")
-		} else if ok, _ := regexp.Match(pattern, buf); !ok {
+		} else if !bytes.Contains(buf, []byte("Go pointer")) {
 			t.Logf("%s", buf)
 			t.Fatalf("did not print expected error (failed with %v)", err)
 		}

misc/cgo/errors/testdata/err2.go

@@ -91,18 +91,10 @@ func main() {
 
 	// issue 26745
 	_ = func(i int) int {
-		// typecheck reports at column 14 ('+'), but types2 reports at
-		// column 10 ('C').
-		// TODO(mdempsky): Investigate why, and see if types2 can be
-		// updated to match typecheck behavior.
-		return C.i + 1 // ERROR HERE: \b(10|14)\b
+		return C.i + 1 // ERROR HERE: 14
 	}
 	_ = func(i int) {
-		// typecheck reports at column 7 ('('), but types2 reports at
-		// column 8 ('i'). The types2 position is more correct, but
-		// updating typecheck here is fundamentally challenging because of
-		// IR limitations.
-		C.fi(i) // ERROR HERE: \b(7|8)\b
+		C.fi(i) // ERROR HERE: 7
 	}
 
 	C.fi = C.fi // ERROR HERE

misc/cgo/fortran/fortran.go

@@ -0,0 +1,12 @@
+// 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
+
+// int the_answer();
+import "C"
+
+func TheAnswer() int {
+	return int(C.the_answer())
+}

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)
+	}
+}