errors: document that the target of Is must be comparable

If target is not comparable, then errors.Is(err, target) can panic.
(Put another way, if target == target panics, then Is can panic.)

Document that the target must be comparable.

For #74488

Change-Id: I694dc4c91a608b80f044f06dd1c6ac32b8e77c9c
Reviewed-on: https://go-review.googlesource.com/c/go/+/715440
Reviewed-by: Alan Donovan <adonovan@google.com>
Auto-Submit: Damien Neil <dneil@google.com>
TryBot-Bypass: Damien Neil <dneil@google.com>

go/types, types2: pull up package-level object sort to a separate phase

This step allows future additional phases to reuse the sorted object
list. Preparation for upcoming CLs.

Change-Id: I22eaffd5bbe39c7cc101c6d860011dc3cb98ce37
Reviewed-on: https://go-review.googlesource.com/c/go/+/715480
Reviewed-by: Robert Griesemer <gri@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Auto-Submit: Mark Freeman <markfreeman@google.com>

go/types, types2: reduce locks held at once in resolveUnderlying

There is no need to hold locks for the entire chain of Named types in
resolveUnderlying. This change moves the locking / unlocking right to
where t.underlying is set.

This change consolidates logic into resolveUnderlying where possible
and makes minor stylistic / documentation adjustments.

Change-Id: Ic5ec5a7e9a0da8bc34954bf456e4e23a28df296d
Reviewed-on: https://go-review.googlesource.com/c/go/+/714403
Reviewed-by: Michael Pratt <mpratt@google.com>
Reviewed-by: Robert Griesemer <gri@google.com>
Auto-Submit: Mark Freeman <markfreeman@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

cmd/compile: rewrite proved multiplies by 0 or 1 into CondSelect

Updates #76056

Change-Id: I64fe631ab381c74f902f877392530d7cc91860ab
Reviewed-on: https://go-review.googlesource.com/c/go/+/715044
Reviewed-by: Michael Knyszek <mknyszek@google.com>
Auto-Submit: Jorropo <jorropo.pgm@gmail.com>
Reviewed-by: Keith Randall <khr@google.com>
Reviewed-by: Keith Randall <khr@golang.org>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

cmd/compile: move branchelim supported arches to Config

Change-Id: I8d10399ba71e5fa97ead06a717fc972c806c0856
Reviewed-on: https://go-review.googlesource.com/c/go/+/715042
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Keith Randall <khr@golang.org>
Auto-Submit: Jorropo <jorropo.pgm@gmail.com>
Reviewed-by: Keith Randall <khr@google.com>
Reviewed-by: Michael Pratt <mpratt@google.com>

crypto/subtle,cmd/compile: add intrinsics for ConstantTimeSelect and *Eq

Targeting crypto/subtle rather than
crypto/internal/fips140/subtle after discussion with Filippo.

goos: linux
goarch: amd64
pkg: crypto/subtle
cpu: AMD Ryzen 5 3600 6-Core Processor
                        │ /tmp/old.logs │            /tmp/new.logs             │
                        │    sec/op     │    sec/op     vs base                │
ConstantTimeSelect-12      0.5246n ± 1%   0.5217n ± 2%        ~ (p=0.118 n=10)
ConstantTimeByteEq-12      1.0415n ± 1%   0.5202n ± 2%  -50.05% (p=0.000 n=10)
ConstantTimeEq-12          0.7813n ± 2%   0.7819n ± 0%        ~ (p=0.897 n=10)
ConstantTimeLessOrEq-12    1.0415n ± 3%   0.7813n ± 1%  -24.98% (p=0.000 n=10)
geomean                    0.8166n        0.6381n       -21.86%

The last three will become 1 lat-cycle (0.25ns) faster once #76066 is fixed.

The Select being that fast with the old code is really impressive.
I am pretty sure this happens because my CPU has BMI1&2 support and
a fusing unit able to translate non BMI code into BMI code.
This benchmark doesn't capture the CACHE gains from the shorter assembly.

It currently compiles as:
v17 = TESTQ <flags> v31 v31 // v != 0
v20 = CMOVQNE <int> v32 v33 v17 (y[int])

It is possible to remove the `TESTQ` by compiletime fusing it with the
compare in a pattern like this:
subtle.ConstantTimeSelect(subtle.ConstantTimeLessOrEq(left, right), right, left)

Saving 2 latency-cycles (1 with #76066 fixed).

Updates #76056

Change-Id: I61a1df99e97a1506f75dae13db529f43846d8f1e
Reviewed-on: https://go-review.googlesource.com/c/go/+/715045
Reviewed-by: Keith Randall <khr@golang.org>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
Reviewed-by: Keith Randall <khr@google.com>

cmd/compile: add generic rules to remove bool → int → bool roundtrips

Change-Id: I8b0a3b64c89fe167d304f901a5d38470f35400ab
Reviewed-on: https://go-review.googlesource.com/c/go/+/715200
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Keith Randall <khr@google.com>
Auto-Submit: Jorropo <jorropo.pgm@gmail.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
Reviewed-by: Keith Randall <khr@golang.org>

cmd/compile: do not Zext bools to 64bits in amd64 CMOV generation rules

Change-Id: I77b714ed767e50d13183f4307f65e47ca7577f9f
Reviewed-on: https://go-review.googlesource.com/c/go/+/715380
Reviewed-by: Keith Randall <khr@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
Auto-Submit: Jorropo <jorropo.pgm@gmail.com>
Reviewed-by: Keith Randall <khr@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

cmd/compile: introduce bytesizeToConst to cleanup switches in prove

Change-Id: I32b45d9632a8131911cb9bd6eff075eb8312ccfd
Reviewed-on: https://go-review.googlesource.com/c/go/+/715043
Auto-Submit: Jorropo <jorropo.pgm@gmail.com>
Reviewed-by: Keith Randall <khr@google.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Keith Randall <khr@golang.org>

cmd/link: internal linking support for windows/arm64

The internal linker was missing some pieces to support windows/arm64.

Closes #75485

Cq-Include-Trybots: luci.golang.try:gotip-windows-arm64
Change-Id: I5c18a47e63e09b8ae22c9b24832249b54f544b7e
Reviewed-on: https://go-review.googlesource.com/c/go/+/704295
Reviewed-by: Cherry Mui <cherryyz@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>

internal/runtime/gc/scan: correct size class size check

This check intends to skip size classes that are too big for scanSpan,
but it compares the size class index with a byte size. It must do the
conversion first.

For #73581.

Change-Id: I6a6a636c8d19fa3bf2a2b609870d67d33f47f66e
Reviewed-on: https://go-review.googlesource.com/c/go/+/715460
Auto-Submit: Michael Pratt <mpratt@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>

cmd/compile: add position info to sccp debug messages

Change-Id: Ic568dd3b2e3ebebb1b6aaa41ee78a12d4e8d3f06
Reviewed-on: https://go-review.googlesource.com/c/go/+/714221
Reviewed-by: Michael Knyszek <mknyszek@google.com>
Auto-Submit: Jorropo <jorropo.pgm@gmail.com>
Reviewed-by: Keith Randall <khr@golang.org>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Keith Randall <khr@google.com>

cmd/compile: teach prove about unsigned rounding-up divide

Change-Id: Ia7b5242c723f83ba85d12e4ca64a19fbbd126016
Reviewed-on: https://go-review.googlesource.com/c/go/+/714622
Auto-Submit: Jorropo <jorropo.pgm@gmail.com>
Reviewed-by: Keith Randall <khr@golang.org>
Reviewed-by: Keith Randall <khr@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>

cmd/compile: change !l.nonzero() into l.maybezero()

  if l.maybezero()
is easier to read than
  if !l.nonzero()

Change-Id: I1183b0c0dc51fa1eed26dfc7a5a996783806a991
Reviewed-on: https://go-review.googlesource.com/c/go/+/714621
Reviewed-by: Keith Randall <khr@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Auto-Submit: Jorropo <jorropo.pgm@gmail.com>
Reviewed-by: Keith Randall <khr@golang.org>
Reviewed-by: Michael Knyszek <mknyszek@google.com>

cmd/compile: optimize Add64carry with unused carries into plain Add64

Change-Id: I8a63f567cfc574bb066ad6269eec6929760cb9c3
Reviewed-on: https://go-review.googlesource.com/c/go/+/656338
Reviewed-by: Michael Knyszek <mknyszek@google.com>
Auto-Submit: Jorropo <jorropo.pgm@gmail.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Keith Randall <khr@golang.org>
Reviewed-by: Keith Randall <khr@google.com>

cmd/compile: remove 68857 ModU flowLimit workaround in prove

We can know this is correct because all the testcases added by CL 605156 are still passing.
Partial revert of CL 605156 (everything but the testcases).

Change-Id: I5d8daadb4cb35a9de29daaabc22baee642511fe0
Reviewed-on: https://go-review.googlesource.com/c/go/+/714941
Reviewed-by: Keith Randall <khr@google.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
Auto-Submit: Jorropo <jorropo.pgm@gmail.com>
Reviewed-by: Keith Randall <khr@golang.org>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

cmd/compile: remove 68857 min & max flowLimit workaround in prove

We can know this is correct because all the testcases added by CL 656157 are still passing.
Partial revert of CL 656157 (everything but the testcases).

Change-Id: I24931fa1affba7e9e92233b3de74ebade3d48a09
Reviewed-on: https://go-review.googlesource.com/c/go/+/714921
Auto-Submit: Jorropo <jorropo.pgm@gmail.com>
Reviewed-by: Keith Randall <khr@google.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
Reviewed-by: Keith Randall <khr@golang.org>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

cmd/compile: use topo-sort in prove to correctly learn facts while walking once

Fixes #68857

Change-Id: Ideb359cc6f1550afb4c79f02d25a00d0ae5e5c50
Reviewed-on: https://go-review.googlesource.com/c/go/+/714920
Reviewed-by: Michael Knyszek <mknyszek@google.com>
Reviewed-by: Keith Randall <khr@golang.org>
Auto-Submit: Jorropo <jorropo.pgm@gmail.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Keith Randall <khr@google.com>

runtime: avoid bound check in freebsd binuptime

Fixes #76062

Change-Id: I683c1232aaeac12b0b3688472bb277adb95ad542
Reviewed-on: https://go-review.googlesource.com/c/go/+/715180
Reviewed-by: Keith Randall <khr@golang.org>
Auto-Submit: Cuong Manh Le <cuong.manhle.vn@gmail.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Keith Randall <khr@google.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
Reviewed-by: Meng Zhuo <mengzhuo1203@gmail.com>

cmd/internal/obj, cmd/asm: reclassify the offset of memory access operations on loong64

This CL also fixes the encoding error of LL/SC[V] instruction and
adds the handling of offset greater than 16 bits in MOV{W/V}P instructions.

Change-Id: I7a8fab4b68a6839da81c5e59af1f42289d00ef61
Reviewed-on: https://go-review.googlesource.com/c/go/+/706435
Reviewed-by: David Chase <drchase@google.com>
Reviewed-by: Meidan Li <limeidan@loongson.cn>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: abner chenc <chenguoqi@loongson.cn>
Reviewed-by: Michael Knyszek <mknyszek@google.com>

cmd/go: remove global loader state variable

Prior commits have removed all dependencies on the global module
loader state variable, so it is now unnecessary and thus removed.

This commit is part of the overall effort to eliminate global
modloader state.

Change-Id: Idaf033ee703a18ffd29e40fad80ef13c7b33dbec
Reviewed-on: https://go-review.googlesource.com/c/go/+/711139
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Michael Matloob <matloob@google.com>
Reviewed-by: Michael Matloob <matloob@golang.org>

cmd/go: use local state for telemetry

This change adds a new loader state to satisfy the requirements for
the (currently unused) telemetry stats for the go command.

This commit is part of the overall effort to eliminate global
modloader state.

Change-Id: I6d4e38c91e5413d7649dfc6301e3ba35ee36c9b9
Reviewed-on: https://go-review.googlesource.com/c/go/+/711136
Reviewed-by: Michael Matloob <matloob@golang.org>
Reviewed-by: Michael Matloob <matloob@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

cmd/go: use tagged switch

Minor modernization to use a tagged switch statement in lieu of
if-else chain.

Change-Id: I132d279d421b4a609403f85f9f1ddfc2605a5399
Reviewed-on: https://go-review.googlesource.com/c/go/+/715341
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: David Chase <drchase@google.com>

cmd/go: increase stmt threshold on amd64

This change slightly increases the stmt threshold on the amd64
platform.

Change-Id: I87e39753b52d6d72f2cd77f1cb8015b1e550921a
Reviewed-on: https://go-review.googlesource.com/c/go/+/715340
Reviewed-by: David Chase <drchase@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

cmd/go: removed unused code in toolchain.Exec

This change removes the unused module loader state in the function
`toolchain.Exec`.

This commit is part of the overall effort to eliminate global
modloader state.

Change-Id: I8935f14447db4669457becc5a96db7f45132772f
Reviewed-on: https://go-review.googlesource.com/c/go/+/709980
Reviewed-by: Michael Matloob <matloob@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Michael Matloob <matloob@golang.org>

go/types, types2: clarify docs for resolveUnderlying

The resolveUnderlying method only detects cycles among type names, where
no type literal or predeclared type can be found (which would yield an
underlying type).

Change-Id: I203f3856eaf63a8a9d317c22521755390f9c1023
Reviewed-on: https://go-review.googlesource.com/c/go/+/714402
Reviewed-by: Robert Griesemer <gri@google.com>
Auto-Submit: Mark Freeman <markfreeman@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

go/types, types2: wrap Named.fromRHS into Named.rhs

In debug mode, the Named.rhs method asserts that Named is in a state
with Named.fromRHS populated.

This caught a missing call to Named.unpack in validtype, which has been
added.

Change-Id: Id3f95f78f03d98a6efe87af6ac24f2ac2e285f96
Reviewed-on: https://go-review.googlesource.com/c/go/+/714242
Auto-Submit: Mark Freeman <markfreeman@google.com>
Reviewed-by: Robert Griesemer <gri@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

go/types, types2: verify stateMask transitions in debug mode

Recently, we've changed the representation of Named type state from
an integer to a bit mask, which is a bit more complicated. To make
sure we uphold state invariants, we are adding a verification step
on each state transition.

This uncovered a few places where we do not uphold the transition
invariants; those are patched in this CL.

Change-Id: I76569e4326b2d362d7a1f078641029ffb3dca531
Reviewed-on: https://go-review.googlesource.com/c/go/+/714241
Auto-Submit: Mark Freeman <markfreeman@google.com>
Reviewed-by: Robert Griesemer <gri@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

net/url: further speed up escape and unescape

This change is a follow-up to CL 712200. It further simplifies and speeds up
functions escape and unescape.

Here are some benchmark results (no change to allocations):

goos: darwin
goarch: amd64
pkg: net/url
cpu: Intel(R) Core(TM) i7-6700HQ CPU @ 2.60GHz
                    │ go/src/old  │             go/src/new             │
                    │   sec/op    │   sec/op     vs base               │
QueryEscape/#00-8     34.58n ± 1%   31.97n ± 1%  -7.55% (p=0.000 n=20)
QueryEscape/#01-8     92.92n ± 0%   94.63n ± 0%  +1.84% (p=0.000 n=20)
QueryEscape/#02-8     75.44n ± 0%   73.32n ± 0%  -2.80% (p=0.000 n=20)
QueryEscape/#03-8     143.4n ± 0%   136.6n ± 0%  -4.71% (p=0.000 n=20)
QueryEscape/#04-8     918.8n ± 1%   838.3n ± 0%  -8.76% (p=0.000 n=20)
PathEscape/#00-8      43.93n ± 0%   42.86n ± 0%  -2.44% (p=0.000 n=20)
PathEscape/#01-8      94.99n ± 0%   95.86n ± 0%  +0.91% (p=0.000 n=20)
PathEscape/#02-8      75.40n ± 1%   71.50n ± 1%  -5.18% (p=0.000 n=20)
PathEscape/#03-8      143.4n ± 0%   136.2n ± 0%  -4.99% (p=0.000 n=20)
PathEscape/#04-8      871.8n ± 0%   822.7n ± 0%  -5.63% (p=0.000 n=20)
QueryUnescape/#00-8   52.64n ± 1%   51.19n ± 0%  -2.75% (p=0.000 n=20)
QueryUnescape/#01-8   137.4n ± 1%   137.9n ± 1%       ~ (p=0.297 n=20)
QueryUnescape/#02-8   114.0n ± 0%   122.3n ± 1%  +7.24% (p=0.000 n=20)
QueryUnescape/#03-8   271.8n ± 0%   260.7n ± 1%  -4.08% (p=0.000 n=20)
QueryUnescape/#04-8   1.390µ ± 1%   1.355µ ± 0%  -2.52% (p=0.000 n=20)
PathUnescape/#00-8    52.45n ± 1%   53.03n ± 1%  +1.10% (p=0.008 n=20)
PathUnescape/#01-8    138.5n ± 1%   141.3n ± 0%  +2.06% (p=0.000 n=20)
PathUnescape/#02-8    114.0n ± 0%   121.5n ± 0%  +6.62% (p=0.000 n=20)
PathUnescape/#03-8    273.1n ± 1%   260.1n ± 0%  -4.76% (p=0.000 n=20)
PathUnescape/#04-8    1.431µ ± 1%   1.359µ ± 0%  -5.07% (p=0.000 n=20)
geomean               160.4n        156.9n       -2.14%

Updates #17860

Change-Id: If64ac3e9c62c41f672db06cfd7eab7357e934e6d
GitHub-Last-Rev: 1da047ac75f9a710baf75a45d105db4dc7b81810
GitHub-Pull-Request: golang/go#76048
Reviewed-on: https://go-review.googlesource.com/c/go/+/714900
Reviewed-by: Michael Knyszek <mknyszek@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: David Chase <drchase@google.com>

runtime: remove unused cgoCheckUsingType function

The only calls to it were removed in CL 616255.

Change-Id: I6c6b01e2e98d54300b6323fd74ccc45fa1d433dd
Reviewed-on: https://go-review.googlesource.com/c/go/+/714820
Reviewed-by: Tobias Klauser <tobias.klauser@gmail.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
Reviewed-by: David Chase <drchase@google.com>
Auto-Submit: Ian Lance Taylor <iant@golang.org>

time: rewrite IsZero method to use wall and ext fields

Using wall and ext fields will be more efficient.

Fixes #76001

Change-Id: If2b9f597562e0d0d3f8ab300556fa559926480a0
GitHub-Last-Rev: 4a91948413079047cb6c382ed29844f456f3064d
GitHub-Pull-Request: golang/go#76006
Reviewed-on: https://go-review.googlesource.com/c/go/+/713720
Reviewed-by: Ian Lance Taylor <iant@golang.org>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Keith Randall <khr@google.com>
Reviewed-by: David Chase <drchase@google.com>

cmd/go: reorder parameters so that context is first

This change simply reorders parameters so that the context.Context is
the first, as per standard practice.

This commit is part of the overall effort to eliminate global
modloader state.

Change-Id: I22d366fb2d2457f44d668409da3fe76fb87180cc
Reviewed-on: https://go-review.googlesource.com/c/go/+/714780
Reviewed-by: Michael Matloob <matloob@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Michael Matloob <matloob@golang.org>

sync: update comments for Once.done

Sync with CL 666895.

Change-Id: I49c4a7f88d87cee9c30a858facd3cd8348efdf94
GitHub-Last-Rev: 88ac1c9c4131aa3f5dfb9c7923e49e46808c409d
GitHub-Pull-Request: golang/go#76026
Reviewed-on: https://go-review.googlesource.com/c/go/+/714360
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Auto-Submit: Jorropo <jorropo.pgm@gmail.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
Reviewed-by: David Chase <drchase@google.com>
Reviewed-by: Jorropo <jorropo.pgm@gmail.com>

runtime: add GOEXPERIMENT=runtimefree

This CL is part of a series of CLs to triangulate between the runtime,
compiler, and standard library to reduce how much work the GC must do.

An overall design document is in CL 700255.

This CL stack implements a runtime.free within the runtime, and
then uses it via automatic calls inserted by the compiler when
the compiler proves it is safe to do so. In the future, we can
also consider possibly a limited set of explicit calls from certain
low-level portions of the standard library.

When called, runtime.free allows immediate reuse of memory
without waiting for a GC cycle. The goals include less overall
CPU usage by the GC, longer times between GC cycles
(with less overall time with the write barrier enabled),
and more cache-friendly allocations for user code.

Here, we just add the GOEXPERIMENT=runtimefree flag. It currently
defaults to on, but can be disabled with GOEXPERIMENT=noruntimefree.

The actual implementation starts in CL 673695.

Updates #74299

Change-Id: I2f1f04dbdca51f4aaa735fd65bb2719c298d922e
Reviewed-on: https://go-review.googlesource.com/c/go/+/700235
Reviewed-by: David Chase <drchase@google.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

cmd/compile: use MOV(D|F) with const for Const(64|32)F on riscv64

The original Const64F using: AUIPC + LD + FMVDX to load
float64 const, we can use AUIPC + FLD instead, same as Const32F.

Change-Id: I8ca0a0e90d820a26e69b74cd25df3cc662132bf7
Reviewed-on: https://go-review.googlesource.com/c/go/+/703215
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Joel Sing <joel@sing.id.au>
Reviewed-by: David Chase <drchase@google.com>
Reviewed-by: Dmitri Shuralyov <dmitshur@google.com>

internal/chacha8rand: provide vector implementation for riscv64

Provide a vector implementation of chacha8rand for riscv64,
which improves performance.

goos: linux
goarch: riscv64
pkg: internal/chacha8rand
cpu: Spacemit(R) X60
      │ /root/chacha8.rand.old.log │     /root/chacha8.rand.new.log      │
      │           sec/op           │   sec/op     vs base                │
Block                  1.640µ ± 0%   1.294µ ± 0%  -21.10% (p=0.000 n=10)

      │ /root/chacha8.rand.old.log │      /root/chacha8.rand.new.log      │
      │            B/s             │     B/s       vs base                │
Block                 148.9Mi ± 0%   188.6Mi ± 0%  +26.72% (p=0.000 n=10)

Change-Id: I1e04c5c44e5ce0c78814a6a48c5ab65e4d758937
Reviewed-on: https://go-review.googlesource.com/c/go/+/710035
Reviewed-by: Joel Sing <joel@sing.id.au>
Reviewed-by: David Chase <drchase@google.com>
Reviewed-by: Dmitri Shuralyov <dmitshur@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

cmd/go: use local loader state in test

This change converts the import test to use a local module loader
state variable, instead of the dependency on global state.

This commit is part of the overall effort to eliminate global
modloader state.

Change-Id: I5687090c160bf64ce36356768f7cf74333fab724
Reviewed-on: https://go-review.googlesource.com/c/go/+/711138
Reviewed-by: Michael Matloob <matloob@google.com>
Reviewed-by: Michael Matloob <matloob@golang.org>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

cmd/go: remove loaderstate dependency

This change removes the dependency on the module loader state from the
`QueryMatchesMainModulesError.Error()` method.

This commit is part of the overall effort to eliminate global
modloader state.

Change-Id: I47241587a0bf9b578931628f35ed3b936a0cb04a
Reviewed-on: https://go-review.googlesource.com/c/go/+/714700
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Michael Matloob <matloob@google.com>
Reviewed-by: Michael Matloob <matloob@golang.org>

cmd/go: remove unused loader state

This test file does not make any use of the module loader state.

This commit is part of the overall effort to eliminate global
modloader state.

Change-Id: I198c76aef9d9a87ae1a2299230f8a06d7a87767a
Reviewed-on: https://go-review.googlesource.com/c/go/+/711137
Reviewed-by: Michael Matloob <matloob@golang.org>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Michael Matloob <matloob@google.com>

cmd/go: remove temporary rf cleanup script

This commit is part of the overall effort to eliminate global
modloader state.

Change-Id: I9d2deebafbbb374de2a1f9bae99e9caf417313a0
Reviewed-on: https://go-review.googlesource.com/c/go/+/709991
Reviewed-by: Michael Matloob <matloob@golang.org>
Reviewed-by: Michael Matloob <matloob@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

cmd/compile: allow unaligned load/store on Wasm

Wasm supports unaligned load/store instructions. Use them.

This speeds up map hashing slightly (among others):
goos: js
goarch: wasm
pkg: runtime
                     │   old.txt   │               new.txt               │
                     │   sec/op    │   sec/op     vs base                │
Hash5                  14.06n ± 2%   13.83n ± 5%        ~ (p=0.186 n=10)
Hash16                 17.52n ± 1%   17.04n ± 1%   -2.71% (p=0.000 n=10)
Hash64                 28.68n ± 1%   26.61n ± 1%   -7.18% (p=0.000 n=10)
Hash1024               271.4n ± 0%   243.6n ± 1%  -10.21% (p=0.000 n=10)
Hash65536              16.66µ ± 0%   15.74µ ± 1%   -5.49% (p=0.000 n=10)
HashStringSpeed        29.23n ± 1%   28.70n ± 1%   -1.83% (p=0.000 n=10)
HashBytesSpeed         46.11n ± 4%   45.17n ± 5%   -2.04% (p=0.008 n=10)
HashInt32Speed         20.39n ± 1%   20.24n ± 5%        ~ (p=0.239 n=10)
HashInt64Speed         20.81n ± 7%   20.58n ± 7%        ~ (p=0.238 n=10)
HashStringArraySpeed   76.65n ± 2%   73.72n ± 1%   -3.83% (p=0.000 n=10)
FastrandHashiter       87.65n ± 1%   87.58n ± 1%        ~ (p=0.725 n=10)
geomean                67.03n        64.75n        -3.40%

Change-Id: I7fd1817c74323f628f310393b0330a0a51ffa3a7
Reviewed-on: https://go-review.googlesource.com/c/go/+/714720
Reviewed-by: Michael Knyszek <mknyszek@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

cmd/go: use local state object in work.runBuild and work.runInstall

This commit modifies `runBuild` and `runInstall` to construct a new
modload.State object using the new constructor instead of the current
global `modload.LoaderState` variable.

This commit is part of the overall effort to eliminate global
modloader state.

[git-generate]
cd src/cmd/go/internal/work
rf '
  add build.go:/func runBuild\(/-0 var moduleLoaderState *modload.State
  ex {
    import "cmd/go/internal/modload";
    modload.LoaderState -> moduleLoaderState
  }
  add runBuild://+0 moduleLoaderState := modload.NewState()
  add runInstall://+0 moduleLoaderState := modload.NewState()
  rm build.go:/var moduleLoaderState \*modload.State/
'

Change-Id: I1137e0b898a5bda8697dce8713f96f238ae8b76c
Reviewed-on: https://go-review.googlesource.com/c/go/+/711135
Reviewed-by: Michael Matloob <matloob@golang.org>
Reviewed-by: Michael Matloob <matloob@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

runtime: add ppc and s390 to 32 build constraints for gccgo

Theses are not supported by the go compiler but it may helps porting to gccgo.

I have no idea if this change is correct, but it is weird that
os_linux32.go and os_linux64.go should have ppc & s390 but not all other
files gated to 32bits in the same package.

Change-Id: I0bb70cdb88c19096386320d02d546942263e009d
Reviewed-on: https://go-review.googlesource.com/c/go/+/714082
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: David Chase <drchase@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Auto-Submit: Jorropo <jorropo.pgm@gmail.com>
Reviewed-by: Dmitri Shuralyov <dmitshur@google.com>

runtime: add ppc and s390 to linux 32 bits syscall build constraints for gccgo

Theses are not supported by the go compiler but it may helps porting to gccgo.

This is similar to reverting CL 712740 however unlike reverting:
- it fixes the build tags so that 32 & 64 bits
  constraints are complement of each other
- it applies the same changes to os_linux_settime32.go and
  os_linux_settime64.go since the four files are the exact same
  fix of the same bug to different parts of the codebase.
  It does not make sense for them to be different.

Change-Id: I08cdcb07e837a5e06ee6f04b7868a4c57b07dd56
Reviewed-on: https://go-review.googlesource.com/c/go/+/714080
Reviewed-by: David Chase <drchase@google.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

cmd/go: use local state object in `generate.runGenerate`

This commit modifies `generate.runGenerate` to construct a new
modload.State object using the new constructor instead of the current
global `modload.LoaderState` variable.

This commit is part of the overall effort to eliminate global
modloader state.

[git-generate]
cd src/cmd/go/internal/generate
rf '
  add generate.go:/func runGenerate\(/-0 var moduleLoaderState *modload.State
  ex {
    import "cmd/go/internal/modload";
    modload.LoaderState -> moduleLoaderState
  }
  add runGenerate://+0 moduleLoaderState := modload.NewState()
  rm generate.go:/var moduleLoaderState \*modload.State/
'

Change-Id: Iea9d662ba47657aa5daa70d32117cdf52fd02b7e
Reviewed-on: https://go-review.googlesource.com/c/go/+/711132
Reviewed-by: Michael Matloob <matloob@golang.org>
Reviewed-by: Michael Matloob <matloob@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

cmd/go: use local state object in `env.runEnv`

This commit modifies `env.runEnv` to construct a new modload.State
object using the new constructor instead of the current global
`modload.LoaderState` variable.

This commit is part of the overall effort to eliminate global
modloader state.

[git-generate]
cd src/cmd/go/internal/envcmd
rf '
  add env.go:/func runEnv\(/-0 var moduleLoaderState *modload.State
  ex {
    import "cmd/go/internal/modload";
    modload.LoaderState -> moduleLoaderState
  }
  add runEnv://+0 moduleLoaderState := modload.NewState()
  rm env.go:/var moduleLoaderState \*modload.State/
'

Change-Id: I1177df5d09a6ee642eade6cfa4278bb1629843a8
Reviewed-on: https://go-review.googlesource.com/c/go/+/711131
Reviewed-by: Michael Matloob <matloob@golang.org>
Reviewed-by: Michael Matloob <matloob@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

cmd/go: use local state object in `vet.runVet`

This commit modifies `vet.runVet` to construct a new modload.State
object using the new constructor instead of the current global
`modload.LoaderState` variable.

This commit is part of the overall effort to eliminate global
modloader state.

[git-generate]
cd src/cmd/go/internal/vet
rf '
  add vet.go:/func run\(/-0 var moduleLoaderState *modload.State
  ex {
    import "cmd/go/internal/modload";
    modload.LoaderState -> moduleLoaderState
  }
  add run://+0 moduleLoaderState := modload.NewState()
  rm vet.go:/var moduleLoaderState \*modload.State/
'

Change-Id: I31c7f3ea8d301b9210f5afeb632afb5b53e93e46
Reviewed-on: https://go-review.googlesource.com/c/go/+/711130
Reviewed-by: Michael Matloob <matloob@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Michael Matloob <matloob@golang.org>

cmd/go: use local state object in pkg `workcmd`

This commit modifies package `workcmd` to construct a new
modload.State object using the new constructor instead of the current
global `modload.LoaderState` variable.

This commit is part of the overall effort to eliminate global
modloader state.

[git-generate]
cd src/cmd/go/internal/workcmd
rf '
  inject modload.LoaderState runUse
  add sync.go:/func runSync\(/-0 var moduleLoaderState *modload.State
  ex {
    import "cmd/go/internal/modload";
    modload.LoaderState -> moduleLoaderState
  }
  add runSync://+0 moduleLoaderState := modload.NewState()
  add runEditwork://+0 moduleLoaderState := modload.NewState()
  add runInit://+0 moduleLoaderState := modload.NewState()
  add runUse://+0 moduleLoaderState := modload.NewState()
  add runVendor://+0 moduleLoaderState := modload.NewState()
  rm sync.go:/var moduleLoaderState \*modload.State/
'

Change-Id: Iadc4ffd19d15f80a694285c86adfc01f0d26bac7
Reviewed-on: https://go-review.googlesource.com/c/go/+/711129
Reviewed-by: Michael Matloob <matloob@golang.org>
Reviewed-by: Michael Matloob <matloob@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

cmd/go: use local state object in `tool.runTool`

This commit modifies `tool.runTool` to construct a new modload.State
object using the new constructor instead of the current global
`modload.LoaderState` variable.

This commit is part of the overall effort to eliminate global
modloader state.

[git-generate]
cd src/cmd/go/internal/tool
rf '
  add tool.go:/func runTool\(/-0 var moduleLoaderState *modload.State
  ex {
    import "cmd/go/internal/modload";
    modload.LoaderState -> moduleLoaderState
  }
  add runTool://+0 moduleLoaderState := modload.NewState()
  rm tool.go:/var moduleLoaderState \*modload.State/
'

Change-Id: I0aff1bc2b57d973c258510dc52fb877fa824355c
Reviewed-on: https://go-review.googlesource.com/c/go/+/711128
Reviewed-by: Michael Matloob <matloob@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Michael Matloob <matloob@golang.org>

cmd/go: use local state object in `test.runTest`

This commit modifies `test.runTest` to construct a new modload.State
object using the new constructor instead of the current global
`modload.LoaderState` variable.

This commit is part of the overall effort to eliminate global
modloader state.

[git-generate]
cd src/cmd/go/internal/test
rf '
  add test.go:/func runTest\(/-0 var moduleLoaderState *modload.State
  ex {
    import "cmd/go/internal/modload";
    modload.LoaderState -> moduleLoaderState
  }
  add runTest://+0 moduleLoaderState := modload.NewState()
  rm test.go:/var moduleLoaderState \*modload.State/
'

Change-Id: Ia387160f30818714ab578c5b78713e532cd394df
Reviewed-on: https://go-review.googlesource.com/c/go/+/711127
Reviewed-by: Michael Matloob <matloob@golang.org>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Michael Matloob <matloob@google.com>

cmd/go: use local state object in `modget.runGet`

This commit modifies `modget.runGet` to construct a new modload.State
object using the new constructor instead of the current global
`modload.LoaderState` variable.

This commit is part of the overall effort to eliminate global
modloader state.

[git-generate]
cd src/cmd/go/internal/modget
rf '
  add get.go:/func runGet\(/-0 var moduleLoaderState *modload.State
  ex {
    import "cmd/go/internal/modload";
    modload.LoaderState -> moduleLoaderState
  }
  add runGet://+0 moduleLoaderState := modload.NewState()
  rm get.go:/var moduleLoaderState \*modload.State/
'

Change-Id: I977c3f57c00b60d383ffd2c2c0d7bc90813c7988
Reviewed-on: https://go-review.googlesource.com/c/go/+/711126
Reviewed-by: Michael Matloob <matloob@golang.org>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Michael Matloob <matloob@google.com>

cmd/go: use local state object in pkg `modcmd`

This commit modifies `modcmd.runDownload` to construct a new
modload.State object using the new constructor instead of the current
global `modload.LoaderState` variable.

This commit is part of the overall effort to eliminate global
modloader state.

[git-generate]
cd src/cmd/go/internal/modcmd
rf '
  add download.go:/func runDownload\(/-0 var moduleLoaderState *modload.State
  ex {
    import "cmd/go/internal/modload";
    modload.LoaderState -> moduleLoaderState
  }
  add runDownload://+0 moduleLoaderState := modload.NewState()
  add runEdit://+0 moduleLoaderState := modload.NewState()
  add runGraph://+0 moduleLoaderState := modload.NewState()
  add runInit://+0 moduleLoaderState := modload.NewState()
  add runTidy://+0 moduleLoaderState := modload.NewState()
  add runVendor://+0 moduleLoaderState := modload.NewState()
  add runVerify://+0 moduleLoaderState := modload.NewState()
  add runWhy://+0 moduleLoaderState := modload.NewState()
  rm download.go:/var moduleLoaderState \*modload.State/
'

Change-Id: Id69deba173032a4d6da228eae28e38bd87176db5
Reviewed-on: https://go-review.googlesource.com/c/go/+/711125
Reviewed-by: Michael Matloob <matloob@google.com>
Reviewed-by: Michael Matloob <matloob@golang.org>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

cmd/go: use local state object in `list.runList`

This commit modifies `list.runList` to construct a new modload.State
object using the new constructor instead of the current global
`modload.LoaderState` variable.

This commit is part of the overall effort to eliminate global
modloader state.

[git-generate]
cd src/cmd/go/internal/list
rf '
  add list.go:/func runList\(/-0 var moduleLoaderState *modload.State
  ex {
    import "cmd/go/internal/modload";
    modload.LoaderState -> moduleLoaderState
  }
  add runList://+0 moduleLoaderState := modload.NewState()
  rm list.go:/var moduleLoaderState \*modload.State/
'

Change-Id: I7f45205c1c946189eb05c6178d14ce74ae259547
Reviewed-on: https://go-review.googlesource.com/c/go/+/711124
Reviewed-by: Michael Matloob <matloob@google.com>
Reviewed-by: Michael Matloob <matloob@golang.org>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

cmd/go: use local state object in `bug.runBug`

This commit modifies `bug.runBug` to construct a new modload.State
object using the new constructor instead of the current global
`modload.LoaderState` variable.

This commit is part of the overall effort to eliminate global
modloader state.

[git-generate]
cd src/cmd/go/internal/bug
rf '
  add bug.go:/func runBug\(/-0 var moduleLoaderState *modload.State
  ex {
    import "cmd/go/internal/modload";
    modload.LoaderState -> moduleLoaderState
  }
  add runBug://+0 moduleLoaderState := modload.NewState()
  rm bug.go:/var moduleLoaderState \*modload.State/
'

Change-Id: Ic4f74d2127f667491136ee4bad4388b4d606821e
Reviewed-on: https://go-review.googlesource.com/c/go/+/711123
Reviewed-by: Michael Matloob <matloob@golang.org>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Michael Matloob <matloob@google.com>

cmd/go: use local state object in `run.runRun`

This commit modifies `run.runRun` to construct a new modload.State
object using the new constructor instead of the current global
`modload.LoaderState` variable.

This commit is part of the overall effort to eliminate global
modloader state.

[git-generate]
cd src/cmd/go/internal/run
rf '
  add run.go:/func runRun\(/-0 var moduleLoaderState *modload.State
  ex {
    import "cmd/go/internal/modload";
    modload.LoaderState -> moduleLoaderState
  }
  add runRun://+0 moduleLoaderState := modload.NewState()
  rm run.go:/var moduleLoaderState \*modload.State/
'

Change-Id: I76e56798b2e0d23a0fefe65d997740e3e411d99d
Reviewed-on: https://go-review.googlesource.com/c/go/+/711116
Reviewed-by: Michael Matloob <matloob@golang.org>
Reviewed-by: Michael Matloob <matloob@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

cmd/go: add loaderstate as field on `mvsReqs`

This change modifies the type `mvsReqs` to have an additional field to
store the current module loader state.  The field is used to break the
dependency on the global `modload.LoaderState` variable.

This commit is part of the overall effort to eliminate global
modloader state.

Change-Id: Id6bd96bc5de68bf327f9e78a778173634e1d15d2
Reviewed-on: https://go-review.googlesource.com/c/go/+/711122
Reviewed-by: Michael Matloob <matloob@golang.org>
Reviewed-by: Michael Matloob <matloob@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

cmd/go: make ImportMissingError work with local state

This change adds fields to the type `ImportMissingError` so
that the `Error()` method can be called without accessing the global
`LoaderState` variable.

This commit is part of the overall effort to eliminate global
modloader state.

Change-Id: Ib313faeb27ae44e9ac68086313633ce742f596dd
Reviewed-on: https://go-review.googlesource.com/c/go/+/711121
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Michael Matloob <matloob@golang.org>
Reviewed-by: Michael Matloob <matloob@google.com>

debug/pe: check for zdebug_gdb_scripts section in testDWARF

The debug_gdb_scripts sectino may or may not be compressed. Check
for both.

For #76022.

Change-Id: I7541e0aa2b90f6b3b694e02d3dfa99f9019a9e5a
Reviewed-on: https://go-review.googlesource.com/c/go/+/714461
Reviewed-by: David Chase <drchase@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>

runtime: use 32-bit hash for maps on Wasm

Currently we use 64-bit hash calculations on Wasm. The 64-bit hash
calculation make intensive uses of 64x64->128 bit multiplications,
which on many 64-bit platforms are compiler intrinsics and can be
compiled to one or two instructions. This is not the case on Wasm,
so it is not very performant.

This CL makes it use 32-bit hashes on Wasm, just like other 32-bit
architectures. The 32-bit hash calculation only uses 32x32->64 bit
multiplications, which can be compiled efficiently on Wasm.

Using 32-bit hashes may increase the chance of collisions. But it
is the same as 32-bit architectures like 386. And our Wasm port
supports only 32-bit address space (like 386), so this is not too
bad.

Runtime Hash benchmark results
goos: js
goarch: wasm
pkg: runtime
                     │   0h.txt    │               1h.txt                │
                     │   sec/op    │   sec/op     vs base                │
Hash5                  20.45n ± 9%   14.06n ± 2%  -31.21% (p=0.000 n=10)
Hash16                 22.34n ± 7%   17.52n ± 1%  -21.62% (p=0.000 n=10)
Hash64                 47.47n ± 3%   28.68n ± 1%  -39.59% (p=0.000 n=10)
Hash1024               475.4n ± 1%   271.4n ± 0%  -42.92% (p=0.000 n=10)
Hash65536              28.42µ ± 1%   16.66µ ± 0%  -41.40% (p=0.000 n=10)
HashStringSpeed        40.07n ± 7%   29.23n ± 1%  -27.05% (p=0.000 n=10)
HashBytesSpeed         62.01n ± 3%   46.11n ± 4%  -25.64% (p=0.000 n=10)
HashInt32Speed         24.31n ± 2%   20.39n ± 1%  -16.13% (p=0.000 n=10)
HashInt64Speed         25.48n ± 7%   20.81n ± 7%  -18.29% (p=0.000 n=10)
HashStringArraySpeed   87.69n ± 4%   76.65n ± 2%  -12.58% (p=0.000 n=10)
FastrandHashiter       87.65n ± 1%   87.65n ± 1%        ~ (p=0.896 n=10)
geomean                90.82n        67.03n       -26.19%

Map benchmarks are too many to post here. The speedups are around
0-40%.

Change-Id: I2f7a68cfc446ab5a547fdb6a40aea07854516d51
Reviewed-on: https://go-review.googlesource.com/c/go/+/714600
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Michael Pratt <mpratt@google.com>

encoding/json/v2: fix typo in documentation about errors.AsType

CL 708495 mass migrated the stdlib to use errors.AsType.
It rewrote the documentation, but uses the non-pointer type
of SemanticError or SyntacticError, which is invalid since
the Error method is declared on the pointer receiver.

Also, call errors.AsType on a separate line for readability.

Change-Id: I2eaf59614e2b58aa4bc8669ab81ce64168c54f13
Reviewed-on: https://go-review.googlesource.com/c/go/+/714660
Reviewed-by: David Chase <drchase@google.com>
Reviewed-by: Dmitri Shuralyov <dmitshur@google.com>
Reviewed-by: Johan Brandhorst-Satzkorn <johan.brandhorst@gmail.com>
Auto-Submit: Joseph Tsai <joetsai@digital-static.net>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

cmd/link: remove pointless assignment in SetSymAlign

This code path became useless after CL 231220.

Change-Id: I35c25368652eeb107350dcd9d1b283429ad3d5e4
Reviewed-on: https://go-review.googlesource.com/c/go/+/714500
Auto-Submit: Ian Lance Taylor <iant@golang.org>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: David Chase <drchase@google.com>
Reviewed-by: Cherry Mui <cherryyz@google.com>

crypto/x509: move constraint checking after chain building

The standard approach to constraint checking involves checking the
constraints during chain building. This is typically done as most chain
building algorithms want to find a single chain. We don't do this, and
instead build every valid chain we can find. Because of this, we don't
_need_ to do constraint checking during the chain building stage, and
instead can defer it until we have built all of the potentially valid
chains (we already do this for EKU nesting and policy checking).

This allows us to limit the constraints we check to only chains issued
by trusted roots, which reduces the attack surface for constraint
checking, which is an annoyingly algorithmically complex process (for
now).

To maintain previous behavior, if we see an error during constraint
checking, and we end up with no valid chains, we return the first
constraint checking error, instead of a more verbose error indicating
if there were different problems during filtering. At some point we
probably should come up with a more unified error type for chain
building that can contain information about multiple failure modes.

Change-Id: I5780b3adce8538eb4c3b56ddec52f0723d39009e
Reviewed-on: https://go-review.googlesource.com/c/go/+/713240
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Dmitri Shuralyov <dmitshur@google.com>
Auto-Submit: Roland Shoemaker <roland@golang.org>
Reviewed-by: Daniel McCarney <daniel@binaryparadox.net>

encoding/json/jsontext: avoid pinning application data in pools

Previously, we put a jsontext.Encoder (or Decoder)
back into a pool with minimal reset logic.
This was semantically safe since we always did a full reset
after obtaining an Encoder/Decoder back out of the pool.

However, this meant that so long as an Encoder/Decoder was
alive in the pool, any application data referenced by the coder
would be kept alive longer than necessary.
Explicitly, clear such fields so that application data
can be more aggressively garbage collected.

Performance:

name               old time/op    new time/op    delta
Unmarshal/Bool-32    52.0ns ± 3%    50.3ns ± 3%  -3.30%  (p=0.001 n=10+10)
Marshal/Bool-32      55.4ns ± 3%    54.4ns ± 2%  -1.75%  (p=0.006 n=10+9)

This only impacts the performance of discrete Marshal/Unmarshal calls.
For the simplest possible call (i.e., to marsha/unmarshal a bool),
there is a 1-2ns slow down. This is an appropriate slowdown
for an improvement in memory utilization.

Change-Id: I5e7d7827473773e53a9dcb3d7fe9052a75481e9f
Reviewed-on: https://go-review.googlesource.com/c/go/+/713640
Reviewed-by: Damien Neil <dneil@google.com>
Reviewed-by: Johan Brandhorst-Satzkorn <johan.brandhorst@gmail.com>
TryBot-Bypass: Damien Neil <dneil@google.com>
Reviewed-by: Dmitri Shuralyov <dmitshur@google.com>
Reviewed-by: Daniel Martí <mvdan@mvdan.cc>
Auto-Submit: Damien Neil <dneil@google.com>

encoding/json/v2: use slices.Sort directly

This is semantically identical and just a cleanup.

Prior to #63397, JSON object names were sorted according to UTF-16
to match the semantic of RFC 8785, but there were a number of
objections in the discussion to using that as the sorting order.

In https://github.com/go-json-experiment/json/pull/121,
we switched to sorting by UTF-8, which matches the behavior
of v1 and avoids an option to toggle the behavior.
However, we should have deleted the stringSlice.Sort method
and just directly called slices.Sort.

From a principled perspective, both UTF-16 and UTF-8 are
reasonable ways to sort JSON object names.
RFC 8259 specifies that the entire JSON text is encoded as UTF-8.
However, the way JSON strings are encoded requires escaping
Unicode codepoints according to UTF-16 surragate halves
(a quirk of JavaScript inherited by JSON).
Thus, JSON is inconsistently both UTF-8 and UTF-16.

Change-Id: Id92b5cc20efe4201827e9d3fccf24ccf894d3e60
Reviewed-on: https://go-review.googlesource.com/c/go/+/713522
Reviewed-by: Johan Brandhorst-Satzkorn <johan.brandhorst@gmail.com>
Reviewed-by: Dmitri Shuralyov <dmitshur@google.com>
TryBot-Bypass: Damien Neil <dneil@google.com>
Auto-Submit: Damien Neil <dneil@google.com>
Reviewed-by: Daniel Martí <mvdan@mvdan.cc>
Reviewed-by: Damien Neil <dneil@google.com>

crypto/x509: simplify candidate chain filtering

Use slices.DeleteFunc to remove chains with invalid policies and
incompatible key usage, instead of iterating over the chains and
reconstructing the slice.

Change-Id: I8ad2bc1ac2469d0d18b2c090e3d4f702b1b577cb
Reviewed-on: https://go-review.googlesource.com/c/go/+/708415
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Daniel McCarney <daniel@binaryparadox.net>
Reviewed-by: David Chase <drchase@google.com>

cmd/go: refactor injection of modload.LoaderState

This change refactors the injection of the global
`modload.LoaderState` variable such that the injection can occur later
in the chain of function calls.  This allows us to keep the behavior
of the global PerPackageFlags (e.g. BuildGcFlags, etc) consistent and
avoid introducing a dependency on the module loader state there.

This commit is part of the overall effort to eliminate global
modloader state.

Change-Id: I1a0cc07173a1804426392581ba8de4ae1e30cdef
Reviewed-on: https://go-review.googlesource.com/c/go/+/711115
Reviewed-by: Michael Matloob <matloob@golang.org>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Michael Matloob <matloob@google.com>

cmd/go: make ErrNoModRoot work with local state

This change reworks the sentinel error value ErrNoModRoot and the type
noMainModulesError so that we can determine the appropriate error
message to display based on the loader state without depending on the
state directly.

This commit is part of the overall effort to eliminate global
modloader state.

Change-Id: I64de433faca96ed90fad4c153766c50575a72157
Reviewed-on: https://go-review.googlesource.com/c/go/+/711120
Reviewed-by: Michael Matloob <matloob@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Michael Matloob <matloob@golang.org>

cmd/go: add modload.State parameter to AllowedFunc

This change makes the following functions methods on the State:
  * CheckAllowed
  * CheckExclusions
  * CheckRetractions

Doing so allows us to reduce the use of the global state variable in
downstream function calls.

This commit is part of the overall effort to eliminate global
modloader state.

Change-Id: I97147311d9de16ecac8c122c2b6bdde94bad9d8f
Reviewed-on: https://go-review.googlesource.com/c/go/+/711119
Reviewed-by: Michael Matloob <matloob@golang.org>
Reviewed-by: Michael Matloob <matloob@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

cmd/go: add loaderstate as field on `QueryMatchesMainModulesError`

This change modifies the type `QueryMatchesMainModulesError` to have
an additional field to store the current module loader state.  The
field is used to break the dependency on the global
`modload.LoaderState` variable.

This commit is part of the overall effort to eliminate global
modloader state.

Change-Id: Ia2066fab9f3ec4ffdd3d7393dacdf65c0fd35b92
Reviewed-on: https://go-review.googlesource.com/c/go/+/711118
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: David Chase <drchase@google.com>
Reviewed-by: Michael Matloob <matloob@golang.org>

cmd/go: remove module loader state from ccompile

This commit is part of the overall effort to eliminate global
modloader state.

Change-Id: Iff90d83b440b39df3d598f5a999e270baa893e24
Reviewed-on: https://go-review.googlesource.com/c/go/+/711134
Reviewed-by: Michael Matloob <matloob@golang.org>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Michael Matloob <matloob@google.com>

cmd/go: inject vendor dir into builder struct

This change adds a new field to the Builder struct to store a function
to retrieve the current vendor directory.  This allows us to delay the
determination of the vendor directory until later, which is currently
necessary to successful interaction with the module loader state.
This behavior will be changed in a future CL and the Builder field
will then be removed.

In addition, a new method to get the vendor dir from the module loader
state is added that will return the empty string instead of panicing.

This commit is part of the overall effort to eliminate global
modloader state.

Change-Id: Ib0165edb9502d98ddfa986acf5579c1b746a026f
Reviewed-on: https://go-review.googlesource.com/c/go/+/711133
Reviewed-by: David Chase <drchase@google.com>
Reviewed-by: Michael Matloob <matloob@golang.org>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

crypto/pbkdf2: add missing error return value in example

This function returns two values, one was missing in the example.

Change-Id: I738597f959011260f666c29b7d3ffad8e5cdc473
GitHub-Last-Rev: 5d99e04f7e1168fd0627e965508181bdb9d1ac25
GitHub-Pull-Request: golang/go#76032
Reviewed-on: https://go-review.googlesource.com/c/go/+/714420
Reviewed-by: Daniel McCarney <daniel@binaryparadox.net>
Reviewed-by: Roland Shoemaker <roland@golang.org>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Auto-Submit: Sean Liao <sean@liao.dev>
Reviewed-by: Dmitri Shuralyov <dmitshur@google.com>
Reviewed-by: Sean Liao <sean@liao.dev>

unique: fix inconsistent panic prefix in canonmap cleanup path

Other panic messages in the file use the "unique.canonMap"
prefix, but this one used "internal/sync.HashTrieMap",
looks like it was copied from the "internal/sync" package.

Change-Id: Ic3e85154eb5a593d41c19013d5696afed2178b7e
Reviewed-on: https://go-review.googlesource.com/c/go/+/713660
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Sean Liao <sean@liao.dev>
Auto-Submit: Sean Liao <sean@liao.dev>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
Reviewed-by: David Chase <drchase@google.com>

go/types, types2: rename Named.resolve to unpack

Named.resolve normalizes a named type's representation so that type
operations have a uniform surface to work with, regardless of how
the type was created.

This often gives the type a heavier footprint, such as when filling
in a lazy-loaded type from UIR, or expanding the RHS of an
instantiated type.

For that reason, it seems more appropriate to call this "unpacking"
the type, as it hints to this heavier form. The term "resolving"
is used in many contexts, and generally suggests that we are
trying to figure out what a name means.

Change-Id: Ia733fd68656380b2be4f7433b7b971b7c1422783
Reviewed-on: https://go-review.googlesource.com/c/go/+/713285
Auto-Submit: Mark Freeman <markfreeman@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Robert Griesemer <gri@google.com>

go/types, types2: rename loaded namedState to lazyLoaded

This is a minor renaming to help differentiate the two kinds of loading
that can happen for named types (eager and lazy).

Use of the term "loaded" suggests that it might also apply to types
which are eagerly-loaded, which is not the case. This change uses
"lazyLoaded" instead to mark this difference.

Change-Id: Iee170024246d9adf3eed978bde2b0500f6d490b7
Reviewed-on: https://go-review.googlesource.com/c/go/+/713282
Reviewed-by: Robert Griesemer <gri@google.com>
Auto-Submit: Mark Freeman <markfreeman@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

go/types, types2: rename complete namedState to hasMethods

The complete namedState tracks whether an instantiated named type has
expanded all of its methods. In the past, this was the terminal state
of a linear lifecycle, and so a term like "complete" made sense.

Now that we've expanded the lifecycle of named types to a tree structure,
the complete namedState is no longer a terminal state, and so the term
"complete" is now a bit confusing.

This change a) makes the expansion aspect of the complete namedState more
explicit and b) removes a misleading suggestion of terminality by changing
the name from complete to hasMethods.

To take a similar naming convention with the underlying namedState, which
signals presence of Named.underlying, we rename the underlying namedState
to hasUnder.

Change-Id: I29fee26efea3de88c7c1240f2dc53df218acf8b4
Reviewed-on: https://go-review.googlesource.com/c/go/+/713280
Reviewed-by: Robert Griesemer <gri@google.com>
Auto-Submit: Mark Freeman <markfreeman@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

go/types, types2: set t.underlying exactly once in resolveUnderlying

While the locking in Named.resolveUnderlying is mostly fine, we do not
perform an atomic read before the write to underlying.

If resolveUnderlying returns and another thread was waiting on the lock,
it can perform a second (in this case identical) write to t.underlying.
A reader thread on n.underlying can thus observe either of those writes,
tripping the race detector.

Michael was kind enough to provide a diagram:

   T1                                   T2
1. t.stateHas(underlying) // false
2.                                      t.stateHas(underlying) // false
3. t.mu.Lock() // acquired
4.                                      t.mu.Lock() // blocked
5. t.underlying = u
6. t.setState(underlying)
7. t.mu.Unlock()
8.                                      t.underlying = u // overwritten
9.                                      t.setState(underlying)
10.                                     t.mu.Unlock()

Adding a second check before setting t.underlying prevents the write on
line 8.

Change-Id: Ia43a6d3ba751caef436b9926c6ece2a71dfb9d38
Reviewed-on: https://go-review.googlesource.com/c/go/+/714300
Auto-Submit: Mark Freeman <markfreeman@google.com>
Reviewed-by: Michael Pratt <mpratt@google.com>
Reviewed-by: Robert Griesemer <gri@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

net/url: speed up escape and unescape

This change adds a generated 8-bit bitmask for use in functions shouldEscape and ishex.

Function shouldEscape is now inlineable. Function escape is now much faster;
function unescape is a bit faster. Here are some benchmark results (no change
to allocations):

goos: darwin
goarch: amd64
pkg: net/url
cpu: Intel(R) Core(TM) i7-6700HQ CPU @ 2.60GHz
                    │     old      │                 new                 │
                    │    sec/op    │   sec/op     vs base                │
QueryEscape/#00-8      58.38n ± 1%   35.98n ± 1%  -38.38% (p=0.000 n=20)
QueryEscape/#01-8     303.50n ± 0%   94.77n ± 0%  -68.77% (p=0.000 n=20)
QueryEscape/#02-8     202.90n ± 0%   78.66n ± 1%  -61.23% (p=0.000 n=20)
QueryEscape/#03-8      444.5n ± 0%   145.9n ± 0%  -67.17% (p=0.000 n=20)
QueryEscape/#04-8     2678.0n ± 0%   913.7n ± 0%  -65.88% (p=0.000 n=20)
PathEscape/#00-8       81.34n ± 0%   44.64n ± 1%  -45.12% (p=0.000 n=20)
PathEscape/#01-8      307.65n ± 0%   96.71n ± 1%  -68.56% (p=0.000 n=20)
PathEscape/#02-8      200.80n ± 1%   78.25n ± 0%  -61.03% (p=0.000 n=20)
PathEscape/#03-8       450.1n ± 1%   145.5n ± 0%  -67.67% (p=0.000 n=20)
PathEscape/#04-8      2663.5n ± 0%   876.5n ± 0%  -67.09% (p=0.000 n=20)
QueryUnescape/#00-8    53.32n ± 1%   51.67n ± 1%   -3.09% (p=0.000 n=20)
QueryUnescape/#01-8    161.0n ± 1%   136.2n ± 1%  -15.40% (p=0.000 n=20)
QueryUnescape/#02-8    126.1n ± 1%   118.3n ± 1%   -6.23% (p=0.000 n=20)
QueryUnescape/#03-8    294.6n ± 0%   273.1n ± 0%   -7.30% (p=0.000 n=20)
QueryUnescape/#04-8    1.511µ ± 0%   1.411µ ± 0%   -6.62% (p=0.000 n=20)
PathUnescape/#00-8     63.84n ± 1%   53.59n ± 1%  -16.05% (p=0.000 n=20)
PathUnescape/#01-8     163.6n ± 3%   137.9n ± 1%  -15.71% (p=0.000 n=20)
PathUnescape/#02-8     126.4n ± 1%   119.1n ± 1%   -5.78% (p=0.000 n=20)
PathUnescape/#03-8     294.2n ± 0%   273.3n ± 0%   -7.12% (p=0.000 n=20)
PathUnescape/#04-8     1.554µ ± 0%   1.417µ ± 0%   -8.78% (p=0.000 n=20)
geomean                277.8n        162.7n       -41.44%

This change draws heavy inspiration from CL 174998, which showed promise but stalled years ago.

Updates #17860

Change-Id: Idcbb1696608998b9e2fc91e1f2a488d8f1f6028c
GitHub-Last-Rev: ff360c2f1b51b1e725d10c0864a6b698d3a5ffc3
GitHub-Pull-Request: golang/go#75914
Reviewed-on: https://go-review.googlesource.com/c/go/+/712200
Reviewed-by: David Chase <drchase@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
Reviewed-by: Jorropo <jorropo.pgm@gmail.com>
Reviewed-by: Takuto Nagami <logica0419@gmail.com>
Reviewed-by: Dmitri Shuralyov <dmitshur@google.com>

go/build: use slices.Equal

Change-Id: Id10293b6fe7a5916599fd4684430d694bb8c8920
Reviewed-on: https://go-review.googlesource.com/c/go/+/690615
Reviewed-by: Sean Liao <sean@liao.dev>
Reviewed-by: David Chase <drchase@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Dmitri Shuralyov <dmitshur@google.com>
Auto-Submit: Sean Liao <sean@liao.dev>

encoding/pem: properly calculate end indexes

When a block is missing the END line trailer, calculate the indexes of
the end and end trailer _before_ continuing the loop, making the
reslicing at the start of the loop work as expected.

Change-Id: If45c8cb473315623618f02cc7609f517a72d232d
Reviewed-on: https://go-review.googlesource.com/c/go/+/714200
Auto-Submit: Roland Shoemaker <roland@golang.org>
Reviewed-by: Damien Neil <dneil@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

cmd: update golang.org/x/arch for riscv64 disassembler

Update to a newer version of golang.org/x/arch, in order to bring in
changes to the riscv64 disassembler, including support for vector and
zicond instructions:

  go get golang.org/x/arch@fea4a9e
  go mod tidy
  go mod vendor

Change-Id: I19623f76a63cee7d0f83d9f6c2305554ed5d5efb
Reviewed-on: https://go-review.googlesource.com/c/go/+/714140
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Auto-Submit: Alan Donovan <adonovan@google.com>
Reviewed-by: Alan Donovan <adonovan@google.com>
Reviewed-by: Dmitri Shuralyov <dmitshur@google.com>
Auto-Submit: Joel Sing <joel@sing.id.au>

all: replace Split in loops with more efficient SplitSeq

Find these replacements through https://pkg.go.dev/golang.org/x/tools/gopls/internal/analysis/modernize.

Change-Id: If88fe0e109b7c7557bfb3d3ffc15271af1ab5856
Reviewed-on: https://go-review.googlesource.com/c/go/+/668437
Reviewed-by: Sean Liao <sean@liao.dev>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Dmitri Shuralyov <dmitshur@google.com>
Auto-Submit: Sean Liao <sean@liao.dev>
Reviewed-by: David Chase <drchase@google.com>

internal/goroot: replace HasPrefix+TrimPrefix with CutPrefix

Change-Id: I97305df6babbede57bb0c3b48c89c96cb74307f7
Reviewed-on: https://go-review.googlesource.com/c/go/+/668456
Auto-Submit: Sean Liao <sean@liao.dev>
Reviewed-by: David Chase <drchase@google.com>
Reviewed-by: Sean Liao <sean@liao.dev>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Dmitri Shuralyov <dmitshur@google.com>

strconv: optimize int-to-decimal and use consistently

Integer-to-decimal conversion is hand-written in multiple
places in this package, with different incomplete optimizations
in  different copies. This CL establishes a single implementation,
formatBase10, accurately optimized for a variety of systems,
and then uses it consistently.

Removed the fastSmalls const, which has been true since 2017.
Also renamed smallsString to smalls.

benchmark \ host                    local  linux-arm64       s7  linux-amd64  linux-ppc64le  linux-s390x  linux-arm  s7:GOARCH=386  linux-386
                                  vs base      vs base  vs base      vs base        vs base      vs base    vs base        vs base    vs base
AppendFloat/Decimal                     ~            ~        ~            ~              ~            ~     +0.99%              ~          ~
AppendFloat/Float                       ~            ~        ~       +2.67%              ~            ~     -0.17%              ~          ~
AppendFloat/Exp                         ~            ~        ~            ~         -5.01%       -0.88%     -0.14%              ~          ~
AppendFloat/NegExp                      ~            ~        ~       +1.80%              ~       -1.55%     -0.67%              ~          ~
AppendFloat/LongExp                     ~            ~        ~       -1.36%         -2.34%            ~     +0.41%              ~          ~
AppendFloat/Big                         ~            ~        ~       -3.94%         -2.66%       -0.61%     +1.01%              ~          ~
AppendFloat/BinaryExp              -5.86%       -2.20%   -3.27%      -17.16%         -6.89%            ~    -61.81%        -33.80%    -27.61%
AppendFloat/32Integer                   ~            ~        ~            ~              ~            ~     +0.74%              ~          ~
AppendFloat/32ExactFraction             ~            ~        ~       +2.96%              ~            ~     +0.09%         +1.62%          ~
AppendFloat/32Point                     ~            ~        ~            ~              ~            ~     +1.31%              ~          ~
AppendFloat/32Exp                       ~            ~        ~            ~         -4.05%            ~     -0.05%              ~          ~
AppendFloat/32NegExp                    ~            ~        ~       -0.86%         -4.97%            ~     +0.23%              ~          ~
AppendFloat/32Shortest                  ~            ~        ~            ~              ~            ~     +0.72%              ~          ~
AppendFloat/32Fixed8Hard           +4.58%       +1.94%   +2.77%       -4.39%              ~       +4.39%     -9.36%        -11.97%    -15.71%
AppendFloat/32Fixed9Hard           +4.52%       +5.41%   +4.13%       +3.10%         -4.84%      +14.34%     -3.83%         -1.84%     -6.42%
AppendFloat/64Fixed1               +3.37%       +3.45%   +1.31%            ~         +6.93%       +4.79%     -2.99%         -2.07%     -5.51%
AppendFloat/64Fixed2               +3.44%       +3.46%   +0.80%            ~         +6.03%       +6.51%     -3.07%         -2.23%     -6.47%
AppendFloat/64Fixed3               +5.27%       +3.06%        ~       +2.08%              ~       +6.20%     -2.85%         -3.07%     -6.21%
AppendFloat/64Fixed4               +7.82%       +3.70%   +2.25%       +2.01%         +5.18%       +5.68%     -2.18%         -1.31%     -3.55%
AppendFloat/64Fixed12              +3.81%       +3.67%        ~       +3.91%              ~       +5.71%     -9.49%        -12.13%    -11.63%
AppendFloat/64Fixed16              -6.26%       -1.42%   -3.37%       -3.15%         -2.03%       +1.15%    -16.18%        -21.43%    -20.40%
AppendFloat/64Fixed12Hard               ~       +2.34%   -1.44%            ~         -1.99%       +9.96%    -10.34%        -13.89%    -13.23%
AppendFloat/64Fixed17Hard          -3.86%       -0.96%   -3.23%       -2.85%         -5.54%       +9.12%    -15.76%        -19.37%    -18.01%
AppendFloat/64Fixed18Hard               ~            ~   -1.34%            ~              ~            ~          ~              ~          ~
AppendFloat/Slowpath64                  ~            ~        ~            ~              ~       -0.63%     +0.94%              ~          ~
AppendFloat/SlowpathDenormal64          ~            ~        ~       -0.96%              ~       -0.53%     +0.65%         +1.08%          ~
AppendUint                         -5.10%       +2.64%   -4.21%       -8.75%         -1.69%       -9.73%    -60.54%        -18.30%    -22.34%
AppendUintVarlen/digits=1          +2.91%       +4.79%   -7.80%            ~         +7.60%            ~     -4.13%              ~     +3.56%
AppendUintVarlen/digits=2               ~       -0.36%        ~            ~              ~       +0.99%     -5.45%              ~     +2.71%
AppendUintVarlen/digits=3          -3.69%       -9.19%   -5.28%      -11.24%        -12.90%      -28.62%    -42.12%        -43.20%    -32.72%
AppendUintVarlen/digits=4          -5.18%      -14.79%   -6.11%      -11.44%        -17.82%      -31.59%    -39.66%        -40.86%    -27.99%
AppendUintVarlen/digits=5               ~       -8.76%  -11.18%      -15.73%         -6.94%      -16.84%    -37.31%        -40.43%    -29.18%
AppendUintVarlen/digits=6          -1.48%       -8.18%  -11.67%      -15.29%         -5.74%      -16.51%    -38.73%        -39.42%    -26.00%
AppendUintVarlen/digits=7          -9.34%       -9.38%  -14.86%      -18.42%         -4.30%      -12.42%    -35.23%        -38.90%    -26.84%
AppendUintVarlen/digits=8         -10.37%       -8.50%  -17.32%      -17.57%         -6.52%      -21.17%    -35.56%        -37.64%    -22.88%
AppendUintVarlen/digits=9         -15.94%      -10.40%  -16.51%      -21.68%         -8.14%      -12.55%    -33.50%        -36.50%    -23.86%
AppendUintVarlen/digits=10         -4.16%       +7.58%   -6.11%       -7.51%         -5.73%       -7.21%    -40.04%        -26.20%    -25.59%
AppendUintVarlen/digits=11         -9.66%       -3.38%  -12.55%      -14.52%         -5.92%      -16.85%    -46.87%        -34.70%    -32.89%
AppendUintVarlen/digits=12         -7.75%       +3.13%   -5.16%      -11.19%         -5.28%       -9.87%    -52.39%        -33.95%    -33.40%
AppendUintVarlen/digits=13        -14.43%       -6.62%  -12.24%      -16.02%         -3.26%      -18.73%    -57.28%        -33.80%    -31.58%
AppendUintVarlen/digits=14         -8.62%       +0.74%   -7.87%      -13.63%         -3.57%      -10.55%    -62.94%        -34.30%    -35.06%
AppendUintVarlen/digits=15        -14.52%       -6.86%  -14.08%      -17.37%         -4.55%      -23.38%    -61.99%        -33.33%    -32.28%
AppendUintVarlen/digits=16        -10.77%       -2.06%   -7.70%      -15.64%         -4.43%      -13.30%    -64.95%        -33.08%    -32.25%
AppendUintVarlen/digits=17        -14.18%       -8.84%  -12.96%      -18.62%         -7.55%      -21.40%    -66.71%        -31.96%    -31.40%
AppendUintVarlen/digits=18        -11.04%       -3.66%   -8.43%      -16.19%         -5.77%      -11.42%    -71.09%        -31.44%    -32.31%
AppendUintVarlen/digits=19         -8.62%       +0.33%   -9.66%      -12.56%         -5.37%      -11.96%    -71.30%        -23.09%    -31.52%
AppendUintVarlen/digits=20         -9.26%       +0.36%   -6.55%      -12.95%         -6.83%      -13.41%    -74.49%        -31.80%    -38.76%

host: local
                                 │ 428dc15ab39 │             c6ec0aa13de             │
                                 │   sec/op    │   sec/op     vs base                │
AppendFloat/Decimal-4              40.13n ± 2%   40.15n ± 2%        ~ (p=0.773 n=40)
AppendFloat/Float-4                56.98n ± 1%   57.27n ± 1%        ~ (p=0.394 n=40)
AppendFloat/Exp-4                  61.46n ± 1%   61.52n ± 1%        ~ (p=0.829 n=40)
AppendFloat/NegExp-4               60.24n ± 1%   59.99n ± 2%        ~ (p=0.912 n=40)
AppendFloat/LongExp-4              62.09n ± 2%   62.37n ± 2%        ~ (p=0.394 n=40)
AppendFloat/Big-4                  67.41n ± 1%   66.99n ± 1%        ~ (p=0.292 n=40)
AppendFloat/BinaryExp-4            32.27n ± 2%   30.38n ± 2%   -5.86% (p=0.000 n=40)
AppendFloat/32Integer-4            39.68n ± 1%   39.34n ± 1%        ~ (p=0.233 n=40)
AppendFloat/32ExactFraction-4      57.95n ± 1%   57.88n ± 2%        ~ (p=0.900 n=40)
AppendFloat/32Point-4              56.40n ± 1%   56.58n ± 2%        ~ (p=0.196 n=40)
AppendFloat/32Exp-4                63.12n ± 2%   63.39n ± 1%        ~ (p=0.082 n=40)
AppendFloat/32NegExp-4             59.64n ± 1%   60.29n ± 1%        ~ (p=0.192 n=40)
AppendFloat/32Shortest-4           51.58n ± 1%   51.98n ± 0%        ~ (p=0.082 n=40)
AppendFloat/32Fixed8Hard-4         39.91n ± 1%   41.74n ± 1%   +4.58% (p=0.000 n=40)
AppendFloat/32Fixed9Hard-4         43.56n ± 1%   45.53n ± 1%   +4.52% (p=0.000 n=40)
AppendFloat/64Fixed1-4             34.61n ± 2%   35.77n ± 2%   +3.37% (p=0.000 n=40)
AppendFloat/64Fixed2-4             33.91n ± 1%   35.07n ± 1%   +3.44% (p=0.000 n=40)
AppendFloat/64Fixed3-4             35.36n ± 1%   37.23n ± 1%   +5.27% (p=0.000 n=40)
AppendFloat/64Fixed4-4             33.95n ± 1%   36.60n ± 1%   +7.82% (p=0.000 n=40)
AppendFloat/64Fixed12-4            57.03n ± 1%   59.20n ± 2%   +3.81% (p=0.000 n=40)
AppendFloat/64Fixed16-4            51.82n ± 1%   48.58n ± 0%   -6.26% (p=0.000 n=40)
AppendFloat/64Fixed12Hard-4        48.32n ± 1%   49.00n ± 0%        ~ (p=0.118 n=40)
AppendFloat/64Fixed17Hard-4        57.40n ± 2%   55.18n ± 5%   -3.86% (p=0.000 n=40)
AppendFloat/64Fixed18Hard-4        3.298µ ± 1%   3.291µ ± 1%        ~ (p=0.927 n=40)
AppendFloat/Slowpath64-4           61.94n ± 3%   62.08n ± 3%        ~ (p=0.324 n=40)
AppendFloat/SlowpathDenormal64-4   59.94n ± 1%   59.82n ± 1%        ~ (p=0.288 n=40)
AppendUint-4                       180.6n ± 2%   171.3n ± 2%   -5.10% (p=0.000 n=40)
AppendUintVarlen/digits=1-4        4.475n ± 0%   4.605n ± 0%   +2.91% (p=0.000 n=40)
AppendUintVarlen/digits=2-4        4.424n ± 1%   4.486n ± 1%        ~ (p=0.025 n=40)
AppendUintVarlen/digits=3-4        12.46n ± 4%   12.00n ± 4%   -3.69% (p=0.000 n=40)
AppendUintVarlen/digits=4-4        11.68n ± 2%   11.08n ± 2%   -5.18% (p=0.000 n=40)
AppendUintVarlen/digits=5-4        11.89n ± 0%   11.82n ± 0%        ~ (p=0.001 n=40)
AppendUintVarlen/digits=6-4        12.18n ± 0%   12.00n ± 0%   -1.48% (p=0.000 n=40)
AppendUintVarlen/digits=7-4        13.49n ± 2%   12.23n ± 2%   -9.34% (p=0.000 n=40)
AppendUintVarlen/digits=8-4        13.21n ± 1%   11.84n ± 2%  -10.37% (p=0.000 n=40)
AppendUintVarlen/digits=9-4        15.21n ± 2%   12.79n ± 2%  -15.94% (p=0.000 n=40)
AppendUintVarlen/digits=10-4       15.49n ± 3%   14.85n ± 2%   -4.16% (p=0.000 n=40)
AppendUintVarlen/digits=11-4       16.82n ± 1%   15.20n ± 1%   -9.66% (p=0.000 n=40)
AppendUintVarlen/digits=12-4       17.42n ± 2%   16.07n ± 3%   -7.75% (p=0.000 n=40)
AppendUintVarlen/digits=13-4       18.75n ± 2%   16.05n ± 2%  -14.43% (p=0.000 n=40)
AppendUintVarlen/digits=14-4       18.90n ± 1%   17.27n ± 2%   -8.62% (p=0.000 n=40)
AppendUintVarlen/digits=15-4       20.49n ± 2%   17.52n ± 1%  -14.52% (p=0.000 n=40)
AppendUintVarlen/digits=16-4       21.08n ± 1%   18.81n ± 1%  -10.77% (p=0.000 n=40)
AppendUintVarlen/digits=17-4       22.64n ± 1%   19.43n ± 1%  -14.18% (p=0.000 n=40)
AppendUintVarlen/digits=18-4       22.96n ± 2%   20.42n ± 3%  -11.04% (p=0.000 n=40)
AppendUintVarlen/digits=19-4       24.58n ± 0%   22.46n ± 0%   -8.62% (p=0.000 n=40)
AppendUintVarlen/digits=20-4       25.23n ± 2%   22.89n ± 0%   -9.26% (p=0.000 n=40)
geomean                            33.23n        32.17n        -3.18%

host: linux-arm64
                                 │  428dc15ab39  │              c6ec0aa13de              │
                                 │    sec/op     │    sec/op      vs base                │
AppendFloat/Decimal-4              61.13n ± 0% ¹   61.15n ± 0% ¹        ~ (p=0.006 n=40)
AppendFloat/Float-4                88.90n ± 0% ¹   88.88n ± 0% ¹        ~ (p=0.528 n=40)
AppendFloat/Exp-4                  92.87n ± 0% ¹   92.87n ± 0% ¹        ~ (p=0.795 n=40)
AppendFloat/NegExp-4               93.06n ± 0% ¹   93.10n ± 0% ¹        ~ (p=0.031 n=40)
AppendFloat/LongExp-4              100.3n ± 0% ¹   100.3n ± 0% ¹        ~ (p=0.184 n=40)
AppendFloat/Big-4                  105.5n ± 0% ¹   105.6n ± 0% ¹        ~ (p=0.007 n=40)
AppendFloat/BinaryExp-4            47.80n ± 0% ¹   46.75n ± 0% ¹   -2.20% (p=0.000 n=40)
AppendFloat/32Integer-4            61.24n ± 0% ¹   61.24n ± 0% ¹        ~ (p=0.809 n=40)
AppendFloat/32ExactFraction-4      85.63n ± 0% ¹   85.69n ± 0% ¹        ~ (p=0.002 n=40)
AppendFloat/32Point-4              83.23n ± 0% ¹   83.24n ± 0% ¹        ~ (p=0.410 n=40)
AppendFloat/32Exp-4                92.18n ± 0% ¹   92.19n ± 0% ¹        ~ (p=0.104 n=40)
AppendFloat/32NegExp-4             87.69n ± 0% ¹   87.70n ± 0% ¹        ~ (p=0.106 n=40)
AppendFloat/32Shortest-4           77.13n ± 0% ¹   77.12n ± 0% ¹        ~ (p=0.599 n=40)
AppendFloat/32Fixed8Hard-4         54.55n ± 0% ¹   55.61n ± 0% ¹   +1.94% (p=0.000 n=40)
AppendFloat/32Fixed9Hard-4         60.91n ± 0% ¹   64.21n ± 0% ¹   +5.41% (p=0.000 n=40)
AppendFloat/64Fixed1-4             51.37n ± 0% ¹   53.14n ± 0% ¹   +3.45% (p=0.000 n=40)
AppendFloat/64Fixed2-4             50.34n ± 0% ¹   52.08n ± 0% ¹   +3.46% (p=0.000 n=40)
AppendFloat/64Fixed3-4             50.91n ± 0% ¹   52.47n ± 0% ¹   +3.06% (p=0.000 n=40)
AppendFloat/64Fixed4-4             48.59n ± 0% ¹   50.39n ± 0% ¹   +3.70% (p=0.000 n=40)
AppendFloat/64Fixed12-4            81.00n ± 0% ¹   83.98n ± 0% ¹   +3.67% (p=0.000 n=40)
AppendFloat/64Fixed16-4            71.60n ± 0% ¹   70.59n ± 0% ¹   -1.42% (p=0.000 n=40)
AppendFloat/64Fixed12Hard-4        66.07n ± 0% ¹   67.62n ± 0% ¹   +2.34% (p=0.000 n=40)
AppendFloat/64Fixed17Hard-4        79.00n ± 0% ¹   78.24n ± 0% ¹   -0.96% (p=0.000 n=40)
AppendFloat/64Fixed18Hard-4        4.290µ ± 0% ¹   4.291µ ± 0% ¹        ~ (p=0.674 n=40)
AppendFloat/Slowpath64-4           97.87n ± 0% ¹   97.88n ± 0% ¹        ~ (p=0.847 n=40)
AppendFloat/SlowpathDenormal64-4   95.66n ± 0% ¹   95.66n ± 0% ¹        ~ (p=0.519 n=40)
AppendUint-4                       269.2n ± 0% ¹   276.3n ± 0% ¹   +2.64% (p=0.000 n=40)
AppendUintVarlen/digits=1-4        6.106n ± 0% ¹   6.398n ± 0% ¹   +4.79% (p=0.000 n=40)
AppendUintVarlen/digits=2-4        6.082n ± 0% ¹   6.060n ± 0% ¹   -0.36% (p=0.000 n=40)
AppendUintVarlen/digits=3-4        13.39n ± 0% ¹   12.16n ± 0% ¹   -9.19% (p=0.000 n=40)
AppendUintVarlen/digits=4-4        15.01n ± 0% ¹   12.79n ± 0% ¹  -14.79% (p=0.000 n=40)
AppendUintVarlen/digits=5-4        15.92n ± 0% ¹   14.52n ± 0% ¹   -8.76% (p=0.000 n=40)
AppendUintVarlen/digits=6-4        16.25n ± 0% ¹   14.92n ± 0% ¹   -8.18% (p=0.000 n=40)
AppendUintVarlen/digits=7-4        18.71n ± 0% ¹   16.96n ± 0% ¹   -9.38% (p=0.000 n=40)
AppendUintVarlen/digits=8-4        18.94n ± 0% ¹   17.33n ± 0% ¹   -8.50% (p=0.000 n=40)
AppendUintVarlen/digits=9-4        21.73n ± 0% ¹   19.47n ± 0% ¹  -10.40% (p=0.000 n=40)
AppendUintVarlen/digits=10-4       22.02n ± 0% ¹   23.69n ± 0% ¹   +7.58% (p=0.000 n=40)
AppendUintVarlen/digits=11-4       24.85n ± 0% ¹   24.01n ± 0% ¹   -3.38% (p=0.000 n=40)
AppendUintVarlen/digits=12-4       25.21n ± 0% ¹   26.00n ± 0% ¹   +3.13% (p=0.000 n=40)
AppendUintVarlen/digits=13-4       28.01n ± 0% ¹   26.15n ± 0% ¹   -6.62% (p=0.000 n=40)
AppendUintVarlen/digits=14-4       28.36n ± 0% ¹   28.57n ± 0% ¹   +0.74% (p=0.000 n=40)
AppendUintVarlen/digits=15-4       31.20n ± 0% ¹   29.06n ± 0% ¹   -6.86% (p=0.000 n=40)
AppendUintVarlen/digits=16-4       31.55n ± 0% ¹   30.90n ± 0% ¹   -2.06% (p=0.000 n=40)
AppendUintVarlen/digits=17-4       35.05n ± 0% ¹   31.95n ± 0% ¹   -8.84% (p=0.000 n=40)
AppendUintVarlen/digits=18-4       35.50n ± 0% ¹   34.20n ± 0% ¹   -3.66% (p=0.000 n=40)
AppendUintVarlen/digits=19-4       38.22n ± 0% ¹   38.34n ± 0% ¹   +0.33% (p=0.000 n=40)
AppendUintVarlen/digits=20-4       38.68n ± 0% ¹   38.82n ± 0% ¹   +0.36% (p=0.000 n=40)
geomean                            48.25n          47.59n          -1.36%
¹ benchmarks vary in cpu

host: s7
                                 │ 428dc15ab39  │             c6ec0aa13de             │
                                 │    sec/op    │   sec/op     vs base                │
AppendFloat/Decimal-4               23.81n ± 1%   23.76n ± 1%        ~ (p=0.885 n=40)
AppendFloat/Float-4                 36.85n ± 1%   36.97n ± 1%        ~ (p=0.002 n=40)
AppendFloat/Exp-4                   36.82n ± 1%   36.59n ± 1%        ~ (p=0.292 n=40)
AppendFloat/NegExp-4                37.44n ± 1%   37.41n ± 1%        ~ (p=0.596 n=40)
AppendFloat/LongExp-4               39.82n ± 1%   39.78n ± 1%        ~ (p=0.025 n=40)
AppendFloat/Big-4                   41.94n ± 1%   41.81n ± 1%        ~ (p=0.054 n=40)
AppendFloat/BinaryExp-4             20.18n ± 1%   19.52n ± 0%   -3.27% (p=0.000 n=40)
AppendFloat/32Integer-4             23.88n ± 0%   23.92n ± 0%        ~ (p=0.408 n=40)
AppendFloat/32ExactFraction-4       36.45n ± 1%   36.26n ± 0%        ~ (p=0.088 n=40)
AppendFloat/32Point-4               35.23n ± 1%   35.33n ± 1%        ~ (p=0.470 n=40)
AppendFloat/32Exp-4                 38.04n ± 1%   37.89n ± 1%        ~ (p=0.885 n=40)
AppendFloat/32NegExp-4              36.20n ± 0%   36.21n ± 1%        ~ (p=0.923 n=40)
AppendFloat/32Shortest-4            32.55n ± 0%   32.42n ± 1%        ~ (p=0.238 n=40)
AppendFloat/32Fixed8Hard-4          24.70n ± 0%   25.38n ± 1%   +2.77% (p=0.000 n=40)
AppendFloat/32Fixed9Hard-4          27.13n ± 0%   28.25n ± 1%   +4.13% (p=0.000 n=40)
AppendFloat/64Fixed1-4              21.40n ± 0%   21.68n ± 1%   +1.31% (p=0.000 n=40)
AppendFloat/64Fixed2-4              21.17n ± 0%   21.33n ± 1%   +0.80% (p=0.001 n=40)
AppendFloat/64Fixed3-4              22.09n ± 1%   22.29n ± 1%        ~ (p=0.003 n=40)
AppendFloat/64Fixed4-4              21.38n ± 1%   21.86n ± 1%   +2.25% (p=0.000 n=40)
AppendFloat/64Fixed12-4             35.17n ± 0%   35.28n ± 1%        ~ (p=0.125 n=40)
AppendFloat/64Fixed16-4             32.02n ± 1%   30.94n ± 1%   -3.37% (p=0.000 n=40)
AppendFloat/64Fixed12Hard-4         29.79n ± 1%   29.36n ± 0%   -1.44% (p=0.000 n=40)
AppendFloat/64Fixed17Hard-4         34.79n ± 1%   33.66n ± 0%   -3.23% (p=0.000 n=40)
AppendFloat/64Fixed18Hard-4         1.983µ ± 1%   1.956µ ± 1%   -1.34% (p=0.000 n=40)
AppendFloat/Slowpath64-4            38.15n ± 0%   37.84n ± 1%        ~ (p=0.039 n=40)
AppendFloat/SlowpathDenormal64-4    38.06n ± 1%   38.24n ± 1%        ~ (p=0.025 n=40)
AppendUint-4                        121.0n ± 0%   115.9n ± 1%   -4.21% (p=0.000 n=40)
AppendUintVarlen/digits=1-4         2.557n ± 1%   2.358n ± 4%   -7.80% (p=0.000 n=40)
AppendUintVarlen/digits=2-4         2.387n ± 4%   2.405n ± 4%        ~ (p=0.149 n=40)
AppendUintVarlen/digits=3-4         6.198n ± 1%   5.871n ± 1%   -5.28% (p=0.000 n=40)
AppendUintVarlen/digits=4-4         6.196n ± 0%   5.817n ± 1%   -6.11% (p=0.000 n=40)
AppendUintVarlen/digits=5-4         6.773n ± 1%   6.016n ± 1%  -11.18% (p=0.000 n=40)
AppendUintVarlen/digits=6-4         6.948n ± 1%   6.136n ± 1%  -11.67% (p=0.000 n=40)
AppendUintVarlen/digits=7-4         8.157n ± 1%   6.944n ± 1%  -14.86% (p=0.000 n=40)
AppendUintVarlen/digits=8-4         8.364n ± 1%   6.915n ± 0%  -17.32% (p=0.000 n=40)
AppendUintVarlen/digits=9-4         9.740n ± 1%   8.132n ± 1%  -16.51% (p=0.000 n=40)
AppendUintVarlen/digits=10-4        9.836n ± 1%   9.235n ± 1%   -6.11% (p=0.000 n=40)
AppendUintVarlen/digits=11-4       11.000n ± 1%   9.620n ± 0%  -12.55% (p=0.000 n=40)
AppendUintVarlen/digits=12-4        11.14n ± 1%   10.57n ± 1%   -5.16% (p=0.000 n=40)
AppendUintVarlen/digits=13-4        12.30n ± 1%   10.79n ± 1%  -12.24% (p=0.000 n=40)
AppendUintVarlen/digits=14-4        12.44n ± 1%   11.46n ± 0%   -7.87% (p=0.000 n=40)
AppendUintVarlen/digits=15-4        13.71n ± 1%   11.78n ± 1%  -14.08% (p=0.000 n=40)
AppendUintVarlen/digits=16-4        13.82n ± 1%   12.76n ± 1%   -7.70% (p=0.000 n=40)
AppendUintVarlen/digits=17-4        14.97n ± 1%   13.03n ± 0%  -12.96% (p=0.000 n=40)
AppendUintVarlen/digits=18-4        15.36n ± 1%   14.06n ± 1%   -8.43% (p=0.000 n=40)
AppendUintVarlen/digits=19-4        16.40n ± 1%   14.81n ± 1%   -9.66% (p=0.000 n=40)
AppendUintVarlen/digits=20-4        16.48n ± 0%   15.40n ± 1%   -6.55% (p=0.000 n=40)
geomean                             20.56n        19.65n        -4.42%

host: linux-amd64
                                 │ 428dc15ab39 │             c6ec0aa13de             │
                                 │   sec/op    │   sec/op     vs base                │
AppendFloat/Decimal-4              64.49n ± 0%   64.79n ± 2%        ~ (p=0.169 n=40)
AppendFloat/Float-4                95.98n ± 4%   98.54n ± 4%   +2.67% (p=0.000 n=40)
AppendFloat/Exp-4                  97.10n ± 1%   97.99n ± 4%        ~ (p=0.002 n=40)
AppendFloat/NegExp-4               98.10n ± 0%   99.87n ± 4%   +1.80% (p=0.000 n=40)
AppendFloat/LongExp-4              106.7n ± 4%   105.3n ± 4%   -1.36% (p=0.001 n=40)
AppendFloat/Big-4                  116.8n ± 3%   112.3n ± 4%   -3.94% (p=0.001 n=40)
AppendFloat/BinaryExp-4            57.70n ± 3%   47.79n ± 3%  -17.16% (p=0.000 n=40)
AppendFloat/32Integer-4            64.75n ± 3%   64.71n ± 3%        ~ (p=0.700 n=40)
AppendFloat/32ExactFraction-4      91.48n ± 2%   94.19n ± 3%   +2.96% (p=0.000 n=40)
AppendFloat/32Point-4              92.48n ± 2%   92.73n ± 4%        ~ (p=0.389 n=40)
AppendFloat/32Exp-4                103.6n ± 2%   103.4n ± 1%        ~ (p=0.069 n=40)
AppendFloat/32NegExp-4             95.16n ± 1%   94.33n ± 0%   -0.86% (p=0.001 n=40)
AppendFloat/32Shortest-4           85.43n ± 4%   84.89n ± 1%        ~ (p=0.082 n=40)
AppendFloat/32Fixed8Hard-4         64.42n ± 3%   61.59n ± 0%   -4.39% (p=0.000 n=40)
AppendFloat/32Fixed9Hard-4         69.74n ± 3%   71.91n ± 4%   +3.10% (p=0.000 n=40)
AppendFloat/64Fixed1-4             59.70n ± 3%   59.16n ± 4%        ~ (p=0.051 n=40)
AppendFloat/64Fixed2-4             58.73n ± 2%   58.03n ± 0%        ~ (p=0.110 n=40)
AppendFloat/64Fixed3-4             57.92n ± 4%   59.13n ± 4%   +2.08% (p=0.000 n=40)
AppendFloat/64Fixed4-4             55.21n ± 3%   56.33n ± 4%   +2.01% (p=0.000 n=40)
AppendFloat/64Fixed12-4            87.98n ± 3%   91.42n ± 1%   +3.91% (p=0.000 n=40)
AppendFloat/64Fixed16-4            80.05n ± 3%   77.52n ± 4%   -3.15% (p=0.000 n=40)
AppendFloat/64Fixed12Hard-4        75.03n ± 4%   74.99n ± 0%        ~ (p=0.641 n=40)
AppendFloat/64Fixed17Hard-4        87.45n ± 1%   84.96n ± 2%   -2.85% (p=0.000 n=40)
AppendFloat/64Fixed18Hard-4        4.903µ ± 3%   4.912µ ± 3%        ~ (p=0.829 n=40)
AppendFloat/Slowpath64-4           101.8n ± 1%   101.4n ± 4%        ~ (p=0.268 n=40)
AppendFloat/SlowpathDenormal64-4   101.0n ± 4%   100.1n ± 3%   -0.96% (p=0.000 n=40)
AppendUint-4                       336.7n ± 1%   307.2n ± 0%   -8.75% (p=0.000 n=40)
AppendUintVarlen/digits=1-4        6.069n ± 1%   6.069n ± 1%        ~ (p=0.904 n=40)
AppendUintVarlen/digits=2-4        5.920n ± 3%   5.925n ± 3%        ~ (p=0.010 n=40)
AppendUintVarlen/digits=3-4        16.33n ± 1%   14.49n ± 2%  -11.24% (p=0.000 n=40)
AppendUintVarlen/digits=4-4        16.70n ± 2%   14.79n ± 2%  -11.44% (p=0.000 n=40)
AppendUintVarlen/digits=5-4        19.33n ± 1%   16.29n ± 1%  -15.73% (p=0.000 n=40)
AppendUintVarlen/digits=6-4        20.15n ± 2%   17.07n ± 1%  -15.29% (p=0.000 n=40)
AppendUintVarlen/digits=7-4        22.78n ± 2%   18.58n ± 1%  -18.42% (p=0.000 n=40)
AppendUintVarlen/digits=8-4        23.56n ± 3%   19.43n ± 2%  -17.57% (p=0.000 n=40)
AppendUintVarlen/digits=9-4        27.12n ± 3%   21.24n ± 3%  -21.68% (p=0.000 n=40)
AppendUintVarlen/digits=10-4       27.10n ± 2%   25.07n ± 3%   -7.51% (p=0.000 n=40)
AppendUintVarlen/digits=11-4       29.72n ± 3%   25.41n ± 3%  -14.52% (p=0.000 n=40)
AppendUintVarlen/digits=12-4       30.35n ± 3%   26.95n ± 4%  -11.19% (p=0.000 n=40)
AppendUintVarlen/digits=13-4       32.98n ± 0%   27.70n ± 3%  -16.02% (p=0.000 n=40)
AppendUintVarlen/digits=14-4       33.89n ± 2%   29.28n ± 3%  -13.63% (p=0.000 n=40)
AppendUintVarlen/digits=15-4       36.45n ± 3%   30.11n ± 1%  -17.37% (p=0.000 n=40)
AppendUintVarlen/digits=16-4       37.12n ± 0%   31.31n ± 1%  -15.64% (p=0.000 n=40)
AppendUintVarlen/digits=17-4       39.84n ± 1%   32.42n ± 0%  -18.62% (p=0.000 n=40)
AppendUintVarlen/digits=18-4       40.53n ± 0%   33.97n ± 3%  -16.19% (p=0.000 n=40)
AppendUintVarlen/digits=19-4       43.20n ± 4%   37.78n ± 0%  -12.56% (p=0.000 n=40)
AppendUintVarlen/digits=20-4       43.87n ± 1%   38.19n ± 0%  -12.95% (p=0.000 n=40)
geomean                            54.70n        51.10n        -6.58%

host: linux-ppc64le
                                 │ 428dc15ab39  │             c6ec0aa13de             │
                                 │    sec/op    │   sec/op     vs base                │
AppendFloat/Decimal-4               55.69n ± 3%   56.06n ± 3%        ~ (p=0.821 n=40)
AppendFloat/Float-4                 79.23n ± 1%   77.13n ± 3%        ~ (p=0.019 n=40)
AppendFloat/Exp-4                   91.14n ± 2%   86.58n ± 2%   -5.01% (p=0.000 n=40)
AppendFloat/NegExp-4                90.77n ± 1%   85.43n ± 6%        ~ (p=0.003 n=40)
AppendFloat/LongExp-4               93.40n ± 2%   91.21n ± 2%   -2.34% (p=0.000 n=40)
AppendFloat/Big-4                  101.55n ± 3%   98.84n ± 2%   -2.66% (p=0.000 n=40)
AppendFloat/BinaryExp-4             45.16n ± 3%   42.05n ± 2%   -6.89% (p=0.000 n=40)
AppendFloat/32Integer-4             56.50n ± 3%   57.45n ± 2%        ~ (p=0.821 n=40)
AppendFloat/32ExactFraction-4       80.94n ± 2%   80.60n ± 1%        ~ (p=0.106 n=40)
AppendFloat/32Point-4               77.03n ± 3%   76.69n ± 2%        ~ (p=0.242 n=40)
AppendFloat/32Exp-4                 92.44n ± 1%   88.70n ± 1%   -4.05% (p=0.000 n=40)
AppendFloat/32NegExp-4              89.50n ± 2%   85.06n ± 2%   -4.97% (p=0.000 n=40)
AppendFloat/32Shortest-4            74.63n ± 2%   72.75n ± 4%        ~ (p=0.042 n=40)
AppendFloat/32Fixed8Hard-4          58.18n ± 2%   56.86n ± 1%        ~ (p=0.002 n=40)
AppendFloat/32Fixed9Hard-4          64.17n ± 1%   61.06n ± 1%   -4.84% (p=0.000 n=40)
AppendFloat/64Fixed1-4              47.56n ± 2%   50.86n ± 1%   +6.93% (p=0.000 n=40)
AppendFloat/64Fixed2-4              47.87n ± 4%   50.75n ± 2%   +6.03% (p=0.000 n=40)
AppendFloat/64Fixed3-4              50.84n ± 2%   51.68n ± 1%        ~ (p=0.014 n=40)
AppendFloat/64Fixed4-4              46.29n ± 3%   48.69n ± 4%   +5.18% (p=0.000 n=40)
AppendFloat/64Fixed12-4             79.97n ± 1%   85.03n ± 4%        ~ (p=0.001 n=40)
AppendFloat/64Fixed16-4             73.18n ± 1%   71.70n ± 2%   -2.03% (p=0.000 n=40)
AppendFloat/64Fixed12Hard-4         68.41n ± 4%   67.06n ± 1%   -1.99% (p=0.000 n=40)
AppendFloat/64Fixed17Hard-4         81.02n ± 1%   76.54n ± 1%   -5.54% (p=0.000 n=40)
AppendFloat/64Fixed18Hard-4         5.184µ ± 0%   5.215µ ± 1%        ~ (p=0.056 n=40)
AppendFloat/Slowpath64-4            89.16n ± 2%   88.85n ± 2%        ~ (p=0.405 n=40)
AppendFloat/SlowpathDenormal64-4    84.27n ± 3%   84.38n ± 1%        ~ (p=0.424 n=40)
AppendUint-4                        277.5n ± 1%   272.9n ± 1%   -1.69% (p=0.000 n=40)
AppendUintVarlen/digits=1-4         5.044n ± 3%   5.428n ± 1%   +7.60% (p=0.000 n=40)
AppendUintVarlen/digits=2-4         5.051n ± 1%   5.038n ± 2%        ~ (p=0.613 n=40)
AppendUintVarlen/digits=3-4         12.13n ± 4%   10.57n ± 2%  -12.90% (p=0.000 n=40)
AppendUintVarlen/digits=4-4         13.33n ± 3%   10.95n ± 1%  -17.82% (p=0.000 n=40)
AppendUintVarlen/digits=5-4         14.05n ± 2%   13.08n ± 3%   -6.94% (p=0.000 n=40)
AppendUintVarlen/digits=6-4         14.46n ± 2%   13.63n ± 2%   -5.74% (p=0.000 n=40)
AppendUintVarlen/digits=7-4         17.11n ± 4%   16.38n ± 1%   -4.30% (p=0.000 n=40)
AppendUintVarlen/digits=8-4         17.34n ± 5%   16.20n ± 1%   -6.52% (p=0.000 n=40)
AppendUintVarlen/digits=9-4         21.06n ± 2%   19.34n ± 2%   -8.14% (p=0.000 n=40)
AppendUintVarlen/digits=10-4        21.11n ± 2%   19.90n ± 1%   -5.73% (p=0.000 n=40)
AppendUintVarlen/digits=11-4        24.25n ± 4%   22.81n ± 1%   -5.92% (p=0.000 n=40)
AppendUintVarlen/digits=12-4        24.53n ± 3%   23.23n ± 2%   -5.28% (p=0.000 n=40)
AppendUintVarlen/digits=13-4        27.14n ± 5%   26.26n ± 1%   -3.26% (p=0.000 n=40)
AppendUintVarlen/digits=14-4        27.72n ± 6%   26.73n ± 0%   -3.57% (p=0.000 n=40)
AppendUintVarlen/digits=15-4        31.23n ± 3%   29.80n ± 1%   -4.55% (p=0.000 n=40)
AppendUintVarlen/digits=16-4        30.78n ± 3%   29.41n ± 1%   -4.43% (p=0.000 n=40)
AppendUintVarlen/digits=17-4        35.04n ± 1%   32.39n ± 0%   -7.55% (p=0.000 n=40)
AppendUintVarlen/digits=18-4        35.10n ± 7%   33.08n ± 0%   -5.77% (p=0.000 n=40)
AppendUintVarlen/digits=19-4        38.26n ± 6%   36.21n ± 0%   -5.37% (p=0.000 n=40)
AppendUintVarlen/digits=20-4        39.24n ± 3%   36.56n ± 0%   -6.83% (p=0.000 n=40)
geomean                             46.39n        44.95n        -3.11%

host: linux-s390x
                                 │  428dc15ab39  │              c6ec0aa13de               │
                                 │    sec/op     │     sec/op      vs base                │
AppendFloat/Decimal-4              70.92n ± 0% ¹    70.81n ± 1% ¹        ~ (p=0.668 n=40)
AppendFloat/Float-4                111.5n ± 0% ¹    111.8n ± 0% ¹        ~ (p=0.143 n=40)
AppendFloat/Exp-4                  119.1n ± 1% ¹    118.1n ± 1% ¹   -0.88% (p=0.000 n=40)
AppendFloat/NegExp-4               119.7n ± 0% ¹    117.8n ± 0% ¹   -1.55% (p=0.000 n=40)
AppendFloat/LongExp-4              128.1n ± 0% ¹    127.8n ± 1% ¹        ~ (p=0.181 n=40)
AppendFloat/Big-4                  131.3n ± 1% ¹    130.5n ± 1% ¹   -0.61% (p=0.001 n=40)
AppendFloat/BinaryExp-4            58.47n ± 0% ¹    58.29n ± 0% ¹        ~ (p=0.189 n=40)
AppendFloat/32Integer-4            72.66n ± 0% ¹    72.31n ± 1% ¹        ~ (p=0.012 n=40)
AppendFloat/32ExactFraction-4      108.6n ± 0% ¹    108.5n ± 1% ¹        ~ (p=0.754 n=40)
AppendFloat/32Point-4              108.6n ± 1% ¹    108.2n ± 0% ¹        ~ (p=0.073 n=40)
AppendFloat/32Exp-4                116.9n ± 1% ¹    117.8n ± 0% ¹        ~ (p=0.008 n=40)
AppendFloat/32NegExp-4             117.9n ± 0% ¹    118.0n ± 0% ¹        ~ (p=0.954 n=40)
AppendFloat/32Shortest-4           107.7n ± 1% ¹    107.0n ± 1% ¹        ~ (p=0.106 n=40)
AppendFloat/32Fixed8Hard-4         71.77n ± 1% ¹    74.92n ± 1% ¹   +4.39% (p=0.000 n=40)
AppendFloat/32Fixed9Hard-4         73.49n ± 0% ¹    84.03n ± 0% ¹  +14.34% (p=0.000 n=40)
AppendFloat/64Fixed1-4             63.55n ± 1% ¹    66.59n ± 1% ¹   +4.79% (p=0.000 n=40)
AppendFloat/64Fixed2-4             61.74n ± 1% ¹    65.77n ± 1% ¹   +6.51% (p=0.000 n=40)
AppendFloat/64Fixed3-4             63.84n ± 2% ¹    67.80n ± 1% ¹   +6.20% (p=0.000 n=40)
AppendFloat/64Fixed4-4             60.41n ± 1% ¹    63.84n ± 1% ¹   +5.68% (p=0.000 n=40)
AppendFloat/64Fixed12-4            98.06n ± 0% ¹   103.65n ± 0% ¹   +5.71% (p=0.000 n=40)
AppendFloat/64Fixed16-4            86.71n ± 0% ¹    87.70n ± 0% ¹   +1.15% (p=0.000 n=40)
AppendFloat/64Fixed12Hard-4        80.62n ± 1% ¹    88.65n ± 1% ¹   +9.96% (p=0.000 n=40)
AppendFloat/64Fixed17Hard-4        89.77n ± 1% ¹    97.96n ± 1% ¹   +9.12% (p=0.000 n=40)
AppendFloat/64Fixed18Hard-4        4.791µ ± 0% ¹    4.790µ ± 0% ¹        ~ (p=0.973 n=40)
AppendFloat/Slowpath64-4           126.0n ± 0% ¹    125.2n ± 0% ¹   -0.63% (p=0.000 n=40)
AppendFloat/SlowpathDenormal64-4   121.7n ± 0% ¹    121.1n ± 0% ¹   -0.53% (p=0.001 n=40)
AppendUint-4                       374.6n ± 1% ¹    338.2n ± 0% ¹   -9.73% (p=0.000 n=40)
AppendUintVarlen/digits=1-4        5.433n ± 0% ¹    5.416n ± 0% ¹        ~ (p=0.032 n=40)
AppendUintVarlen/digits=2-4        5.357n ± 0% ¹    5.410n ± 0% ¹   +0.99% (p=0.000 n=40)
AppendUintVarlen/digits=3-4        17.45n ± 0% ¹    12.46n ± 0% ¹  -28.62% (p=0.000 n=40)
AppendUintVarlen/digits=4-4        17.38n ± 0% ¹    11.89n ± 0% ¹  -31.59% (p=0.000 n=40)
AppendUintVarlen/digits=5-4        21.38n ± 0% ¹    17.78n ± 1% ¹  -16.84% (p=0.000 n=40)
AppendUintVarlen/digits=6-4        21.60n ± 0% ¹    18.03n ± 1% ¹  -16.51% (p=0.000 n=40)
AppendUintVarlen/digits=7-4        26.44n ± 0% ¹    23.15n ± 0% ¹  -12.42% (p=0.000 n=40)
AppendUintVarlen/digits=8-4        26.60n ± 0% ¹    20.97n ± 1% ¹  -21.17% (p=0.000 n=40)
AppendUintVarlen/digits=9-4        31.44n ± 0% ¹    27.49n ± 0% ¹  -12.55% (p=0.000 n=40)
AppendUintVarlen/digits=10-4       31.26n ± 1% ¹    29.00n ± 0% ¹   -7.21% (p=0.000 n=40)
AppendUintVarlen/digits=11-4       35.90n ± 0% ¹    29.84n ± 0% ¹  -16.85% (p=0.000 n=40)
AppendUintVarlen/digits=12-4       35.95n ± 0% ¹    32.40n ± 0% ¹   -9.87% (p=0.000 n=40)
AppendUintVarlen/digits=13-4       40.98n ± 0% ¹    33.31n ± 0% ¹  -18.73% (p=0.000 n=40)
AppendUintVarlen/digits=14-4       38.96n ± 0% ¹    34.85n ± 0% ¹  -10.55% (p=0.000 n=40)
AppendUintVarlen/digits=15-4       45.51n ± 0% ¹    34.87n ± 0% ¹  -23.38% (p=0.000 n=40)
AppendUintVarlen/digits=16-4       45.05n ± 0% ¹    39.05n ± 0% ¹  -13.30% (p=0.000 n=40)
AppendUintVarlen/digits=17-4       50.76n ± 0% ¹    39.89n ± 0% ¹  -21.40% (p=0.000 n=40)
AppendUintVarlen/digits=18-4       49.86n ± 1% ¹    44.16n ± 0% ¹  -11.42% (p=0.000 n=40)
AppendUintVarlen/digits=19-4       54.68n ± 0% ¹    48.14n ± 0% ¹  -11.96% (p=0.000 n=40)
AppendUintVarlen/digits=20-4       55.48n ± 0% ¹    48.04n ± 0% ¹  -13.41% (p=0.000 n=40)
geomean                            62.00n           58.40n          -5.80%
¹ benchmarks vary in cpu

host: linux-arm
                                 │ 428dc15ab39  │             c6ec0aa13de             │
                                 │    sec/op    │   sec/op     vs base                │
AppendFloat/Decimal-4               121.6n ± 0%   122.8n ± 0%   +0.99% (p=0.000 n=40)
AppendFloat/Float-4                 209.1n ± 0%   208.8n ± 0%   -0.17% (p=0.000 n=40)
AppendFloat/Exp-4                   208.8n ± 0%   208.5n ± 0%   -0.14% (p=0.000 n=40)
AppendFloat/NegExp-4                210.1n ± 0%   208.7n ± 0%   -0.67% (p=0.000 n=40)
AppendFloat/LongExp-4               217.5n ± 0%   218.4n ± 0%   +0.41% (p=0.000 n=40)
AppendFloat/Big-4                   237.8n ± 0%   240.2n ± 0%   +1.01% (p=0.000 n=40)
AppendFloat/BinaryExp-4            226.90n ± 0%   86.66n ± 0%  -61.81% (p=0.000 n=40)
AppendFloat/32Integer-4             121.9n ± 0%   122.8n ± 0%   +0.74% (p=0.000 n=40)
AppendFloat/32ExactFraction-4       174.0n ± 0%   174.1n ± 0%   +0.09% (p=0.000 n=40)
AppendFloat/32Point-4               171.9n ± 0%   174.2n ± 0%   +1.31% (p=0.000 n=40)
AppendFloat/32Exp-4                 195.4n ± 0%   195.3n ± 0%   -0.05% (p=0.000 n=40)
AppendFloat/32NegExp-4              174.0n ± 0%   174.4n ± 0%   +0.23% (p=0.000 n=40)
AppendFloat/32Shortest-4            167.5n ± 0%   168.7n ± 0%   +0.72% (p=0.000 n=40)
AppendFloat/32Fixed8Hard-4          115.4n ± 0%   104.6n ± 0%   -9.36% (p=0.000 n=40)
AppendFloat/32Fixed9Hard-4          144.9n ± 0%   139.3n ± 0%   -3.83% (p=0.000 n=40)
AppendFloat/64Fixed1-4              127.3n ± 0%   123.5n ± 0%   -2.99% (p=0.000 n=40)
AppendFloat/64Fixed2-4              123.6n ± 0%   119.8n ± 0%   -3.07% (p=0.000 n=40)
AppendFloat/64Fixed3-4              122.8n ± 0%   119.3n ± 0%   -2.85% (p=0.000 n=40)
AppendFloat/64Fixed4-4              114.5n ± 0%   112.0n ± 0%   -2.18% (p=0.000 n=40)
AppendFloat/64Fixed12-4             161.3n ± 0%   146.0n ± 0%   -9.49% (p=0.000 n=40)
AppendFloat/64Fixed16-4             168.7n ± 0%   141.4n ± 0%  -16.18% (p=0.000 n=40)
AppendFloat/64Fixed12Hard-4         152.3n ± 0%   136.6n ± 0%  -10.34% (p=0.000 n=40)
AppendFloat/64Fixed17Hard-4         182.7n ± 0%   153.9n ± 0%  -15.76% (p=0.000 n=40)
AppendFloat/64Fixed18Hard-4         7.976µ ± 0%   7.977µ ± 0%        ~ (p=0.093 n=40)
AppendFloat/Slowpath64-4            213.4n ± 0%   215.4n ± 0%   +0.94% (p=0.000 n=40)
AppendFloat/SlowpathDenormal64-4    214.0n ± 0%   215.4n ± 0%   +0.65% (p=0.000 n=40)
AppendUint-4                       1526.0n ± 0%   602.1n ± 0%  -60.54% (p=0.000 n=40)
AppendUintVarlen/digits=1-4         9.338n ± 0%   8.953n ± 0%   -4.13% (p=0.000 n=40)
AppendUintVarlen/digits=2-4         9.789n ± 0%   9.256n ± 0%   -5.45% (p=0.000 n=40)
AppendUintVarlen/digits=3-4         46.42n ± 0%   26.87n ± 0%  -42.12% (p=0.000 n=40)
AppendUintVarlen/digits=4-4         49.23n ± 0%   29.70n ± 0%  -39.66% (p=0.000 n=40)
AppendUintVarlen/digits=5-4         51.45n ± 0%   32.25n ± 0%  -37.31% (p=0.000 n=40)
AppendUintVarlen/digits=6-4         51.02n ± 0%   31.26n ± 0%  -38.73% (p=0.000 n=40)
AppendUintVarlen/digits=7-4         55.45n ± 0%   35.91n ± 0%  -35.23% (p=0.000 n=40)
AppendUintVarlen/digits=8-4         57.11n ± 0%   36.80n ± 0%  -35.56% (p=0.000 n=40)
AppendUintVarlen/digits=9-4         59.28n ± 0%   39.42n ± 0%  -33.50% (p=0.000 n=40)
AppendUintVarlen/digits=10-4        71.62n ± 0%   42.94n ± 0%  -40.04% (p=0.000 n=40)
AppendUintVarlen/digits=11-4        91.41n ± 0%   48.57n ± 0%  -46.87% (p=0.000 n=40)
AppendUintVarlen/digits=12-4       106.50n ± 0%   50.70n ± 0%  -52.39% (p=0.000 n=40)
AppendUintVarlen/digits=13-4       121.90n ± 0%   52.07n ± 0%  -57.28% (p=0.000 n=40)
AppendUintVarlen/digits=14-4       129.70n ± 0%   48.07n ± 0%  -62.94% (p=0.000 n=40)
AppendUintVarlen/digits=15-4       148.50n ± 0%   56.45n ± 0%  -61.99% (p=0.000 n=40)
AppendUintVarlen/digits=16-4       167.40n ± 0%   58.67n ± 0%  -64.95% (p=0.000 n=40)
AppendUintVarlen/digits=17-4       179.70n ± 0%   59.83n ± 0%  -66.71% (p=0.000 n=40)
AppendUintVarlen/digits=18-4       186.00n ± 0%   53.78n ± 0%  -71.09% (p=0.000 n=40)
AppendUintVarlen/digits=19-4       216.50n ± 0%   62.13n ± 0%  -71.30% (p=0.000 n=40)
AppendUintVarlen/digits=20-4       246.80n ± 0%   62.96n ± 0%  -74.49% (p=0.000 n=40)
geomean                             136.3n        95.52n       -29.95%

host: s7:GOARCH=386
                                 │ 428dc15ab39  │             c6ec0aa13de              │
                                 │    sec/op    │    sec/op     vs base                │
AppendFloat/Decimal-4               51.07n ± 1%    51.05n ± 0%        ~ (p=0.346 n=40)
AppendFloat/Float-4                 94.44n ± 1%    95.05n ± 0%        ~ (p=0.343 n=40)
AppendFloat/Exp-4                   97.89n ± 0%    98.59n ± 0%        ~ (p=0.271 n=40)
AppendFloat/NegExp-4                98.22n ± 1%    99.27n ± 0%        ~ (p=0.283 n=40)
AppendFloat/LongExp-4               100.3n ± 0%    101.4n ± 0%        ~ (p=0.001 n=40)
AppendFloat/Big-4                   109.1n ± 0%    110.0n ± 1%        ~ (p=0.141 n=40)
AppendFloat/BinaryExp-4             53.98n ± 1%    35.74n ± 1%  -33.80% (p=0.000 n=40)
AppendFloat/32Integer-4             49.90n ± 0%    50.41n ± 0%        ~ (p=0.005 n=40)
AppendFloat/32ExactFraction-4       78.22n ± 0%    79.49n ± 0%   +1.62% (p=0.000 n=40)
AppendFloat/32Point-4               75.75n ± 1%    75.90n ± 0%        ~ (p=0.119 n=40)
AppendFloat/32Exp-4                 89.74n ± 1%    90.58n ± 0%        ~ (p=0.088 n=40)
AppendFloat/32NegExp-4              79.34n ± 1%    80.22n ± 0%        ~ (p=0.005 n=40)
AppendFloat/32Shortest-4            74.46n ± 1%    74.43n ± 1%        ~ (p=1.000 n=40)
AppendFloat/32Fixed8Hard-4          47.28n ± 1%    41.62n ± 0%  -11.97% (p=0.000 n=40)
AppendFloat/32Fixed9Hard-4          64.92n ± 1%    63.72n ± 1%   -1.84% (p=0.000 n=40)
AppendFloat/64Fixed1-4              58.40n ± 1%    57.19n ± 1%   -2.07% (p=0.000 n=40)
AppendFloat/64Fixed2-4              55.79n ± 1%    54.55n ± 1%   -2.23% (p=0.000 n=40)
AppendFloat/64Fixed3-4              56.70n ± 1%    54.95n ± 0%   -3.07% (p=0.000 n=40)
AppendFloat/64Fixed4-4              51.85n ± 1%    51.18n ± 0%   -1.31% (p=0.000 n=40)
AppendFloat/64Fixed12-4             74.00n ± 0%    65.02n ± 0%  -12.13% (p=0.000 n=40)
AppendFloat/64Fixed16-4             80.23n ± 1%    63.04n ± 0%  -21.43% (p=0.000 n=40)
AppendFloat/64Fixed12Hard-4         70.64n ± 1%    60.83n ± 1%  -13.89% (p=0.000 n=40)
AppendFloat/64Fixed17Hard-4         86.02n ± 1%    69.36n ± 0%  -19.37% (p=0.000 n=40)
AppendFloat/64Fixed18Hard-4         3.736µ ± 1%    3.795µ ± 0%        ~ (p=0.010 n=40)
AppendFloat/Slowpath64-4            99.18n ± 1%   100.25n ± 0%        ~ (p=0.003 n=40)
AppendFloat/SlowpathDenormal64-4    97.35n ± 1%    98.41n ± 0%   +1.08% (p=0.001 n=40)
AppendUint-4                        356.3n ± 1%    291.2n ± 0%  -18.30% (p=0.000 n=40)
AppendUintVarlen/digits=1-4         3.923n ± 0%    3.919n ± 1%        ~ (p=0.061 n=40)
AppendUintVarlen/digits=2-4         3.917n ± 1%    3.924n ± 0%        ~ (p=0.048 n=40)
AppendUintVarlen/digits=3-4        17.205n ± 0%    9.772n ± 0%  -43.20% (p=0.000 n=40)
AppendUintVarlen/digits=4-4         17.18n ± 0%    10.16n ± 1%  -40.86% (p=0.000 n=40)
AppendUintVarlen/digits=5-4         18.33n ± 1%    10.92n ± 0%  -40.43% (p=0.000 n=40)
AppendUintVarlen/digits=6-4         18.67n ± 1%    11.31n ± 0%  -39.42% (p=0.000 n=40)
AppendUintVarlen/digits=7-4         19.77n ± 1%    12.08n ± 0%  -38.90% (p=0.000 n=40)
AppendUintVarlen/digits=8-4         19.95n ± 1%    12.44n ± 1%  -37.64% (p=0.000 n=40)
AppendUintVarlen/digits=9-4         21.44n ± 1%    13.61n ± 1%  -36.50% (p=0.000 n=40)
AppendUintVarlen/digits=10-4        24.31n ± 0%    17.94n ± 0%  -26.20% (p=0.000 n=40)
AppendUintVarlen/digits=11-4        27.75n ± 1%    18.12n ± 0%  -34.70% (p=0.000 n=40)
AppendUintVarlen/digits=12-4        28.76n ± 1%    18.99n ± 0%  -33.95% (p=0.000 n=40)
AppendUintVarlen/digits=13-4        29.12n ± 1%    19.28n ± 0%  -33.80% (p=0.000 n=40)
AppendUintVarlen/digits=14-4        30.56n ± 0%    20.07n ± 1%  -34.30% (p=0.000 n=40)
AppendUintVarlen/digits=15-4        30.71n ± 1%    20.48n ± 0%  -33.33% (p=0.000 n=40)
AppendUintVarlen/digits=16-4        31.86n ± 0%    21.32n ± 0%  -33.08% (p=0.000 n=40)
AppendUintVarlen/digits=17-4        31.51n ± 1%    21.43n ± 1%  -31.96% (p=0.000 n=40)
AppendUintVarlen/digits=18-4        32.46n ± 0%    22.26n ± 1%  -31.44% (p=0.000 n=40)
AppendUintVarlen/digits=19-4        35.42n ± 1%    27.25n ± 1%  -23.09% (p=0.000 n=40)
AppendUintVarlen/digits=20-4        39.50n ± 2%    26.94n ± 1%  -31.80% (p=0.000 n=40)
geomean                             48.59n         39.98n       -17.73%

host: linux-386
                                 │ 428dc15ab39  │             c6ec0aa13de             │
                                 │    sec/op    │   sec/op     vs base                │
AppendFloat/Decimal-4               148.4n ± 2%   147.8n ± 1%        ~ (p=0.053 n=40)
AppendFloat/Float-4                 284.1n ± 2%   281.9n ± 1%        ~ (p=0.001 n=40)
AppendFloat/Exp-4                   294.5n ± 3%   292.7n ± 1%        ~ (p=0.035 n=40)
AppendFloat/NegExp-4                295.4n ± 1%   295.9n ± 3%        ~ (p=0.799 n=40)
AppendFloat/LongExp-4               305.8n ± 2%   304.9n ± 2%        ~ (p=0.186 n=40)
AppendFloat/Big-4                   340.1n ± 3%   340.8n ± 4%        ~ (p=0.069 n=40)
AppendFloat/BinaryExp-4             139.1n ± 0%   100.7n ± 1%  -27.61% (p=0.000 n=40)
AppendFloat/32Integer-4             149.2n ± 2%   148.4n ± 3%        ~ (p=0.450 n=40)
AppendFloat/32ExactFraction-4       247.1n ± 4%   249.9n ± 3%        ~ (p=0.005 n=40)
AppendFloat/32Point-4               231.5n ± 4%   233.9n ± 2%        ~ (p=0.288 n=40)
AppendFloat/32Exp-4                 286.9n ± 3%   284.5n ± 0%        ~ (p=0.015 n=40)
AppendFloat/32NegExp-4              244.5n ± 1%   244.3n ± 4%        ~ (p=0.637 n=40)
AppendFloat/32Shortest-4            227.4n ± 0%   227.2n ± 1%        ~ (p=0.161 n=40)
AppendFloat/32Fixed8Hard-4          146.8n ± 1%   123.7n ± 2%  -15.71% (p=0.000 n=40)
AppendFloat/32Fixed9Hard-4          218.7n ± 3%   204.7n ± 1%   -6.42% (p=0.000 n=40)
AppendFloat/64Fixed1-4              194.3n ± 0%   183.7n ± 3%   -5.51% (p=0.000 n=40)
AppendFloat/64Fixed2-4              184.8n ± 1%   172.8n ± 0%   -6.47% (p=0.000 n=40)
AppendFloat/64Fixed3-4              186.1n ± 3%   174.6n ± 3%   -6.21% (p=0.000 n=40)
AppendFloat/64Fixed4-4              164.9n ± 3%   159.1n ± 3%   -3.55% (p=0.000 n=40)
AppendFloat/64Fixed12-4             233.9n ± 2%   206.7n ± 3%  -11.63% (p=0.000 n=40)
AppendFloat/64Fixed16-4             253.2n ± 4%   201.5n ± 1%  -20.40% (p=0.000 n=40)
AppendFloat/64Fixed12Hard-4         224.0n ± 1%   194.4n ± 1%  -13.23% (p=0.000 n=40)
AppendFloat/64Fixed17Hard-4         282.4n ± 2%   231.5n ± 4%  -18.01% (p=0.000 n=40)
AppendFloat/64Fixed18Hard-4         15.92µ ± 3%   15.73µ ± 2%        ~ (p=0.172 n=40)
AppendFloat/Slowpath64-4            305.2n ± 2%   300.0n ± 3%        ~ (p=0.016 n=40)
AppendFloat/SlowpathDenormal64-4    297.1n ± 2%   294.0n ± 1%        ~ (p=0.075 n=40)
AppendUint-4                       1218.5n ± 1%   946.2n ± 1%  -22.34% (p=0.000 n=40)
AppendUintVarlen/digits=1-4         8.735n ± 2%   9.046n ± 3%   +3.56% (p=0.000 n=40)
AppendUintVarlen/digits=2-4         8.752n ± 1%   8.990n ± 1%   +2.71% (p=0.000 n=40)
AppendUintVarlen/digits=3-4         32.45n ± 2%   21.84n ± 1%  -32.72% (p=0.000 n=40)
AppendUintVarlen/digits=4-4         33.23n ± 1%   23.93n ± 3%  -27.99% (p=0.000 n=40)
AppendUintVarlen/digits=5-4         39.00n ± 3%   27.61n ± 2%  -29.18% (p=0.000 n=40)
AppendUintVarlen/digits=6-4         38.87n ± 2%   28.76n ± 2%  -26.00% (p=0.000 n=40)
AppendUintVarlen/digits=7-4         42.55n ± 1%   31.13n ± 3%  -26.84% (p=0.000 n=40)
AppendUintVarlen/digits=8-4         43.13n ± 3%   33.26n ± 1%  -22.88% (p=0.000 n=40)
AppendUintVarlen/digits=9-4         48.54n ± 3%   36.96n ± 1%  -23.86% (p=0.000 n=40)
AppendUintVarlen/digits=10-4        68.81n ± 1%   51.20n ± 1%  -25.59% (p=0.000 n=40)
AppendUintVarlen/digits=11-4        78.96n ± 1%   52.99n ± 1%  -32.89% (p=0.000 n=40)
AppendUintVarlen/digits=12-4        83.14n ± 2%   55.37n ± 2%  -33.40% (p=0.000 n=40)
AppendUintVarlen/digits=13-4        83.74n ± 1%   57.30n ± 2%  -31.58% (p=0.000 n=40)
AppendUintVarlen/digits=14-4        90.47n ± 1%   58.75n ± 3%  -35.06% (p=0.000 n=40)
AppendUintVarlen/digits=15-4        90.35n ± 3%   61.18n ± 1%  -32.28% (p=0.000 n=40)
AppendUintVarlen/digits=16-4        94.12n ± 1%   63.77n ± 2%  -32.25% (p=0.000 n=40)
AppendUintVarlen/digits=17-4        93.81n ± 0%   64.35n ± 3%  -31.40% (p=0.000 n=40)
AppendUintVarlen/digits=18-4        99.25n ± 1%   67.18n ± 3%  -32.31% (p=0.000 n=40)
AppendUintVarlen/digits=19-4       118.70n ± 0%   81.28n ± 1%  -31.52% (p=0.000 n=40)
AppendUintVarlen/digits=20-4       135.90n ± 1%   83.23n ± 1%  -38.76% (p=0.000 n=40)
geomean                             140.3n        117.7n       -16.12%

Change-Id: If5e2151c397701b23dbc69f20e57b99728898e90
Reviewed-on: https://go-review.googlesource.com/c/go/+/712662
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Alan Donovan <adonovan@google.com>

cmd/internal/obj/riscv: simplify validation and encoding of raw instructions

Use wantImmU/immU rather than handrolling the same code. This also corrects
the validation output - add tests to ensure this is the case.

Change-Id: Id48f459c7c0de09ddde7a10506f66a3a269f325f
Reviewed-on: https://go-review.googlesource.com/c/go/+/702396
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: David Chase <drchase@google.com>
Reviewed-by: Cherry Mui <cherryyz@google.com>

doc/next: improve new(expr) release note

One reader pointed out that the example isn't compelling because
&age would have worked just as well. This CL changes the example
to use a nontrivial expression. Don't nitpick the arithmetic.

For #45624

Change-Id: Icc745f5ee7000c1d3559da1388c6a5596c4d1f46
Reviewed-on: https://go-review.googlesource.com/c/go/+/714040
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Auto-Submit: Alan Donovan <adonovan@google.com>
Reviewed-by: Robert Griesemer <gri@google.com>

runtime: cleanup pagetrace

pagetrace functionality was removed with CL 583379.

Change-Id: I8e8718e6cf5415e326ec127fb294588866ee4e6a
Reviewed-on: https://go-review.googlesource.com/c/go/+/713260
Reviewed-by: Michael Knyszek <mknyszek@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: David Chase <drchase@google.com>

crypto/internal/fips140test: add entropy SHA2-384 testing

The crypto/internal/fips140/entropy package vendors a minimal
implementation of SHA2-384 to insulate it from changes in the FIPS
module implementation. This means it also requires ACVP testing separate
from the FIPS module implementation. This commit implements the
required ACVP testing support.

There's no way via the ACVP protocol, or acvptool, to specify that we
want to test a specific SHA2-384 implementation compared to normal. We
use a new environment variable (GOENTROPYSOURCEACVP=1) to make that
distinction.

The capabilities we advertise when testing the entropy SHA2-384
implementation are limited to something that best describes the
input sizes that the entropy module's implementation supports within the
requirements imposed by ACVP. We allow 144 byte messages (3*digest size)
to support MCT and in particular the "standard" MCT algorithm, and allow
1024 byte messages as the production supported message size used by the
entropy module itself.

Change-Id: I6e693a3fa23efba35d8a7d029ddf0b11036621c3
Reviewed-on: https://go-review.googlesource.com/c/go/+/711740
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Auto-Submit: Daniel McCarney <daniel@binaryparadox.net>
Reviewed-by: David Chase <drchase@google.com>
Reviewed-by: Filippo Valsorda <filippo@golang.org>
Reviewed-by: Roland Shoemaker <roland@golang.org>

runtime/cgo: fix cgoCheckArg description

The description is misleading: cgoCheckArg is called by both
cgoCheckPointer and cgoCheckResult.

Mention cgoCheckResult in the cgoCheckArg description. Remove extra
spaces between words.

For #75856

Change-Id: I6780cda76b5cb7b4f9af3fbaa37a6c5099cc8d7d
GitHub-Last-Rev: 531928b679ab138bf9bfe47a1bf6470d582776f3
GitHub-Pull-Request: golang/go#75992
Reviewed-on: https://go-review.googlesource.com/c/go/+/713520
Reviewed-by: Keith Randall <khr@google.com>
Reviewed-by: Keith Randall <khr@golang.org>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: David Chase <drchase@google.com>

runtime: use backoff and ISB instruction to reduce contention in (*lfstack).pop and (*spanSet).pop on arm64

When profiling CPU usage LiveKit on AArch64/x86 (AWS), the graphs show
CPU spikes that was repeating in a semi-periodic manner and spikes occur
when the GC(garbage collector) is active.

Our analysis found that the getempty function accounted for 10.54% of the
overhead, which was mainly caused by the work.empty.pop() function. And
listing pop shows that the majority of the time, with a 10.29% overhead,
is spent on atomic.Cas64((*uint64)(head), old, next).

This patch adds a backoff approach to reduce the high overhead of the
atomic operation primarily occurs when contention over a specific memory
address increases, typically with the rise in the number of threads.

Note that on paltforms other than arm64, the initial value of backoff is zero.

This patch rewrites the implementation of procyield() on arm64, which is an
Armv8.0-A compatible delay function using the counter-timer.

The garbage collector benchmark:

                           │    master       │               opt                        │
                           │   sec/op        │        sec/op     vs base                │
Garbage/benchmem-MB=64-160   3.782m ± 4%        2.264m ± 2%      -40.12% (p=0.000 n=10)
                           │ user+sys-sec/op │ user+sys-sec/op   vs base                │
Garbage/benchmem-MB=64-160   433.5m ± 4%        255.4m ± 2%      -41.08% (p=0.000 n=10)

Reference for backoff mechianism:
https://community.arm.com/arm-community-blogs/b/architectures-and-processors-blog/posts/multi-threaded-applications-arm

Change-Id: Ie8128a2243ceacbb82ab2a88941acbb8428bad94
Reviewed-on: https://go-review.googlesource.com/c/go/+/654895
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
Reviewed-by: Michael Pratt <mpratt@google.com>

strconv: clean up powers-of-10 table, tests

Both Eisel-Lemire and Ryu depend on a table of
truncated 128-bit mantissas of powers of 10,
and so will Dragonbox.

This CL:
 - Moves the table to a separate file, so it doesn't look tied to Eisel-Lemire.
 - Introduces a uint128 type in math.go for the table values,
   since .Hi and .Lo are clearer than [1] and [0].
 - Generates the table from a standalone generator pow10gen.go.
 - Adds a new pow10 function in math.go to handle table access details.
 - Factors a 64x128->192-bit multiply into umul192 in math.go.
 - Moves multiplication by log₁₀ 2 and log₂ 10 into math.go.
 - Introduces an import_test.go to avoid having to type differently
   cased names in test code versus regular code.
 - Introduces named constants for the floating-point size parameters.
   Previously these were only in the floatInfo global variables.
 - Changes the BenchmarkAppendUintVarlen subtest names
   to be more useful.

Change-Id: I9826ee5f41c5c19be3b6a7c3c5f277ec6c23b39a
Reviewed-on: https://go-review.googlesource.com/c/go/+/712661
Reviewed-by: Alan Donovan <adonovan@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: David Chase <drchase@google.com>

cmd/go: check if build output should overwrite files with renames

CopyFile has a check to ensure that only object files are overwritten.
Extend this to moveOrCopyFile, so the check also happens when the source
and destination file are on the same filesystem (when renames are a
valid way of moving files).

Fixes #75970

Change-Id: Ie667301f1c9c00b114cfd91cdf8053ac20fd817b
Reviewed-on: https://go-review.googlesource.com/c/go/+/712960
Reviewed-by: Laurent Demailly <ldemailly@gmail.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Michael Matloob <matloob@google.com>
Reviewed-by: Ian Alexander <jitsu@google.com>
Reviewed-by: Michael Matloob <matloob@golang.org>

comment: change slice to string in function comment/help

Comment is outdated, it should say a string is returned

Change-Id: I7d40135aac22845dbc1f91e02e5776cc7d58eda7
GitHub-Last-Rev: 08ee556f0803dc0e2a765d431ac10758b4f26146
GitHub-Pull-Request: golang/go#75980
Reviewed-on: https://go-review.googlesource.com/c/go/+/713040
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Keith Randall <khr@golang.org>
Reviewed-by: Robert Griesemer <gri@google.com>
Auto-Submit: Robert Griesemer <gri@google.com>
Reviewed-by: Keith Randall <khr@google.com>

go/types, types2: simplify locking in Named.resolveUnderlying

Avoid calling Named.resolveUnderlying in the first place (there
is only one caller) if Named.underlying exists already.

In Named.resolveUnderlying remove initial atomic check because
of the check in Named.Underlying. Also, remove a 2nd atomic
check after acquiring the lock as it likely won't help much.

Change-Id: Ife87218fa2549d0903a10218f4dd7a70f85d6c7c
Reviewed-on: https://go-review.googlesource.com/c/go/+/713521
Auto-Submit: Robert Griesemer <gri@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Robert Griesemer <gri@google.com>
Reviewed-by: Mark Freeman <markfreeman@google.com>

go/types, types2: in resolveUnderlying, only compute path when needed

When following a RHS chain, the (TypeName) Object path is only needed
when there is a cycle (i.e., an error), in which case we can be slow.
Rather than always compute the path, only compute it in the error case.
In the same vain, allocate the seen map lazily, only when needed.

This code could use a test (it doesn't seem to be encountered by our
test suite), but I haven't found a case to provoke the error yet.

Change-Id: Iff6313394442a251adc56580f746928ec13450fd
Reviewed-on: https://go-review.googlesource.com/c/go/+/712321
Auto-Submit: Robert Griesemer <gri@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Mark Freeman <markfreeman@google.com>
Reviewed-by: Robert Griesemer <gri@google.com>

go/types, types2: rename Named.under to Named.resolveUnderlying

Named.resolveUnderlying is now just a helper function for Underlying
and only called from there. The name makes is clearer what this function
does; it also doesn't need to return a result anymore.

While at it, slightly simplify the function body.

Change-Id: I167c4be89b1bfcc69f6b528ddb6ed4c90481194a
Reviewed-on: https://go-review.googlesource.com/c/go/+/712521
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Mark Freeman <markfreeman@google.com>
Auto-Submit: Robert Griesemer <gri@google.com>
Reviewed-by: Robert Griesemer <gri@google.com>

go/build, cmd/go: use ast.ParseDirective for go:embed

Currently, "//go:embed" directives are read by bespoke parsers in
go/build and cmd/go/internal/modindex. Replace these bespoke parsers
with scanner.Scanner for finding these directives and
ast.ParseDirective for parsing them.

It's not clear why we had a bespoke parser just for finding
"//go:embed" directives in the first place. We have a bespoke parser
for reading imports in order to avoid having to read the entire source
file into memory, but if we're parsing embeds, we wind up reading the
entire source file into memory anyway. Using scanner.Scanner instead
eliminates some truly confusing code.

This also demonstrates that ast.ParseDirective as proposed in #68021
achieves useful API coverage.

Updates #68021.

Change-Id: Ieb68738121dcff605a6a704a8045ddd2ff35df35
Reviewed-on: https://go-review.googlesource.com/c/go/+/704836
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Auto-Submit: Austin Clements <austin@google.com>
Reviewed-by: Alan Donovan <adonovan@google.com>

go/ast: add ParseDirective for parsing directive comments

This adds an ast.Directive API for parsing directive comments such as
"//go:build" and "//go:embed".

This will help tools standardize the syntax of these directive
comments. Even within the standard Go tools there's little agreement
on the finer details of the syntax of directives today.

Fixes #68021.

Change-Id: I84a988a667682c9ac70632df6e925461ac95e381
Reviewed-on: https://go-review.googlesource.com/c/go/+/704835
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Auto-Submit: Austin Clements <austin@google.com>
Reviewed-by: Mateusz Poliwczak <mpoliwczak34@gmail.com>
Reviewed-by: Alan Donovan <adonovan@google.com>

go/types, types2: only report version errors if new(expr) is ok otherwise

If new(expr) is used before Go 1.26, don't report version errors if there
are other problems with the expression.

While at it, implement multiple missing type checks for new(expr) and
add corresponding test cases that were missed in CL 704935 (tests for
no value expressions, generic types, untyped nil).

Reorganize/rename builtins0.go tests for new to match existing test case
patterns again.

Fixes #75986.
For #45624.

Change-Id: I39e5516d3f8d191cc390a4d8b9911c312bbb177c
Reviewed-on: https://go-review.googlesource.com/c/go/+/713241
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Mark Freeman <markfreeman@google.com>
Reviewed-by: Robert Griesemer <gri@google.com>
Auto-Submit: Robert Griesemer <gri@google.com>

path/filepath: reword documentation for Rel

The existing func Rel's API documentation was presented in a rather
dense way without a lot of organization that oriented around topical
flow, so the documentation has been cleaned up to present the
function's behavior more clearly and concisely.

Fixes #75893

Change-Id: I6c8f6ef508250397be9d0127a15508e7335f18c4
Reviewed-on: https://go-review.googlesource.com/c/go/+/712440
Reviewed-by: David Chase <drchase@google.com>
Auto-Submit: Dmitri Shuralyov <dmitshur@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@google.com>
TryBot-Bypass: Dmitri Shuralyov <dmitshur@golang.org>
Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>