doc: fix typo in FAQ

Change-Id: I956d6d1dbf8516cb65eb3a0686a3b0584b4a6840
GitHub-Last-Rev: 1c928f3c67eceae424cbcd6b0935605a78728604
GitHub-Pull-Request: golang/go#28991
Reviewed-on: https://go-review.googlesource.com/c/151324
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>

plugin: fix build constraint to disable test on linux/arm64

CL 151478 was suppose to fix the build failure on linux/arm64 but the
build constraint didn't exclude linux/arm64 properly.

Fixes #28982

Change-Id: Ia80265b0adba0384cd28bc2deb1726418664975a
Reviewed-on: https://go-review.googlesource.com/c/151303
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Andrew Bonventre <andybons@golang.org>

math/big: allocate less for single-Word nats

For many uses of math/big, most numbers are small in practice.
Prior to this change, big.NewInt allocated a minimum of five Words:
one to hold the value, and four as extra capacity.
In most cases, this extra capacity is waste.
Worse, allocating a single Word uses a fast malloc path for tiny allocs;
allocating five Words is more expensive in CPU as well as memory.

This change is a simple fix: Treat a request for one Word at its word.
I experimented with more complicated fixes and did not find anything
that outperformed this easy fix.

On some real world programs, this is a clear win.

The compiler:

name        old alloc/op      new alloc/op      delta
Template         37.1MB ± 0%       37.0MB ± 0%  -0.23%  (p=0.008 n=5+5)
Unicode          29.2MB ± 0%       28.5MB ± 0%  -2.48%  (p=0.008 n=5+5)
GoTypes           133MB ± 0%        133MB ± 0%  -0.05%  (p=0.008 n=5+5)
Compiler          628MB ± 0%        628MB ± 0%  -0.06%  (p=0.008 n=5+5)
SSA              2.04GB ± 0%       2.03GB ± 0%  -0.14%  (p=0.008 n=5+5)
Flate            24.7MB ± 0%       24.6MB ± 0%  -0.23%  (p=0.008 n=5+5)
GoParser         29.6MB ± 0%       29.6MB ± 0%  -0.07%  (p=0.008 n=5+5)
Reflect          82.3MB ± 0%       82.2MB ± 0%  -0.05%  (p=0.008 n=5+5)
Tar              36.2MB ± 0%       36.2MB ± 0%  -0.12%  (p=0.008 n=5+5)
XML              49.5MB ± 0%       49.4MB ± 0%  -0.23%  (p=0.008 n=5+5)
[Geo mean]       85.1MB            84.8MB       -0.37%

name        old allocs/op     new allocs/op     delta
Template           364k ± 0%         364k ± 0%    ~     (p=0.476 n=5+5)
Unicode            341k ± 0%         341k ± 0%    ~     (p=0.690 n=5+5)
GoTypes           1.37M ± 0%        1.37M ± 0%    ~     (p=0.444 n=5+5)
Compiler          5.50M ± 0%        5.50M ± 0%  +0.02%  (p=0.008 n=5+5)
SSA               16.0M ± 0%        16.0M ± 0%  +0.01%  (p=0.008 n=5+5)
Flate              238k ± 0%         238k ± 0%    ~     (p=0.222 n=5+5)
GoParser           305k ± 0%         305k ± 0%    ~     (p=0.841 n=5+5)
Reflect            976k ± 0%         976k ± 0%    ~     (p=0.222 n=5+5)
Tar                354k ± 0%         354k ± 0%    ~     (p=0.103 n=5+5)
XML                450k ± 0%         450k ± 0%    ~     (p=0.151 n=5+5)
[Geo mean]         837k              837k       +0.01%

go.skylark.net (at ea6d2813de75ded8d157b9540bc3d3ad0b688623):

name                     old alloc/op   new alloc/op   delta
Hashtable-8                 456kB ± 0%     299kB ± 0%  -34.33%  (p=0.000 n=9+9)
/bench_builtin_method-8     220kB ± 0%     190kB ± 0%  -13.55%  (p=0.000 n=9+10)

name                     old allocs/op  new allocs/op  delta
Hashtable-8                 7.84k ± 0%     7.84k ± 0%     ~     (all equal)
/bench_builtin_method-8     7.49k ± 0%     7.49k ± 0%     ~     (all equal)

The math/big benchmarks are messy, which is predictable, since they
naturally exercise the bigger-than-one-word code more.
Also worth noting is that many of the benchmarks have very high variance.
I've omitted the opVV and opVW benchmarks, as they are unrelated.

name                              old time/op    new time/op    delta
DecimalConversion-8                 92.5µs ± 1%    90.6µs ± 0%   -2.12%  (p=0.000 n=17+19)
FloatString/100-8                    867ns ± 0%     871ns ± 0%   +0.50%  (p=0.000 n=18+18)
FloatString/1000-8                  26.4µs ± 1%    26.5µs ± 1%     ~     (p=0.396 n=20+19)
FloatString/10000-8                 2.15ms ± 2%    2.16ms ± 2%     ~     (p=0.089 n=19+20)
FloatString/100000-8                 209ms ± 1%     209ms ± 1%     ~     (p=0.583 n=19+19)
FloatAdd/10-8                       63.5ns ± 2%    64.1ns ± 6%     ~     (p=0.389 n=19+19)
FloatAdd/100-8                      66.0ns ± 2%    65.8ns ± 2%     ~     (p=0.825 n=20+20)
FloatAdd/1000-8                     93.9ns ± 1%    94.3ns ± 1%     ~     (p=0.273 n=19+20)
FloatAdd/10000-8                     347ns ± 2%     342ns ± 1%   -1.50%  (p=0.000 n=18+18)
FloatAdd/100000-8                   2.78µs ± 1%    2.78µs ± 2%     ~     (p=0.961 n=20+19)
FloatSub/10-8                       56.9ns ± 2%    57.8ns ± 3%   +1.59%  (p=0.001 n=19+19)
FloatSub/100-8                      58.2ns ± 2%    58.9ns ± 2%   +1.25%  (p=0.004 n=20+20)
FloatSub/1000-8                     74.9ns ± 1%    74.4ns ± 1%   -0.76%  (p=0.000 n=19+20)
FloatSub/10000-8                     223ns ± 1%     220ns ± 2%   -1.29%  (p=0.000 n=16+20)
FloatSub/100000-8                   1.66µs ± 1%    1.66µs ± 2%     ~     (p=0.147 n=20+20)
ParseFloatSmallExp-8                8.38µs ± 0%    8.59µs ± 0%   +2.48%  (p=0.000 n=19+19)
ParseFloatLargeExp-8                31.1µs ± 0%    32.0µs ± 0%   +3.04%  (p=0.000 n=16+17)
GCD10x10/WithoutXY-8                 115ns ± 1%      99ns ± 3%  -14.07%  (p=0.000 n=20+20)
GCD10x10/WithXY-8                    322ns ± 0%     312ns ± 0%   -3.11%  (p=0.000 n=18+13)
GCD10x100/WithoutXY-8                233ns ± 1%     219ns ± 1%   -5.73%  (p=0.000 n=19+17)
GCD10x100/WithXY-8                   709ns ± 0%     759ns ± 0%   +7.04%  (p=0.000 n=19+19)
GCD10x1000/WithoutXY-8               653ns ± 1%     642ns ± 1%   -1.69%  (p=0.000 n=17+20)
GCD10x1000/WithXY-8                 1.35µs ± 0%    1.35µs ± 1%     ~     (p=0.255 n=20+16)
GCD10x10000/WithoutXY-8             4.57µs ± 1%    4.61µs ± 1%   +0.95%  (p=0.000 n=18+17)
GCD10x10000/WithXY-8                6.82µs ± 0%    6.84µs ± 0%   +0.27%  (p=0.000 n=16+17)
GCD10x100000/WithoutXY-8            43.9µs ± 1%    44.0µs ± 1%   +0.28%  (p=0.000 n=18+17)
GCD10x100000/WithXY-8               60.6µs ± 0%    60.6µs ± 0%     ~     (p=0.907 n=18+18)
GCD100x100/WithoutXY-8              1.13µs ± 0%    1.21µs ± 0%   +6.39%  (p=0.000 n=19+19)
GCD100x100/WithXY-8                 1.82µs ± 0%    1.92µs ± 0%   +5.24%  (p=0.000 n=19+17)
GCD100x1000/WithoutXY-8             2.00µs ± 0%    2.03µs ± 1%   +1.61%  (p=0.000 n=18+16)
GCD100x1000/WithXY-8                3.22µs ± 0%    3.20µs ± 1%   -0.83%  (p=0.000 n=19+19)
GCD100x10000/WithoutXY-8            9.28µs ± 1%    9.17µs ± 1%   -1.25%  (p=0.000 n=18+19)
GCD100x10000/WithXY-8               13.5µs ± 0%    13.3µs ± 0%   -1.12%  (p=0.000 n=18+19)
GCD100x100000/WithoutXY-8           80.4µs ± 0%    78.6µs ± 0%   -2.25%  (p=0.000 n=19+19)
GCD100x100000/WithXY-8               114µs ± 0%     112µs ± 0%   -1.46%  (p=0.000 n=19+17)
GCD1000x1000/WithoutXY-8            12.9µs ± 1%    12.9µs ± 2%   -0.50%  (p=0.014 n=20+19)
GCD1000x1000/WithXY-8               19.6µs ± 1%    19.6µs ± 2%   -0.28%  (p=0.040 n=17+18)
GCD1000x10000/WithoutXY-8           22.4µs ± 0%    22.4µs ± 2%     ~     (p=0.220 n=19+19)
GCD1000x10000/WithXY-8              57.0µs ± 0%    56.5µs ± 0%   -0.87%  (p=0.000 n=20+20)
GCD1000x100000/WithoutXY-8           116µs ± 0%     115µs ± 0%   -0.49%  (p=0.000 n=18+19)
GCD1000x100000/WithXY-8              410µs ± 0%     411µs ± 0%     ~     (p=0.052 n=19+19)
GCD10000x10000/WithoutXY-8           247µs ± 1%     244µs ± 1%   -0.92%  (p=0.000 n=19+19)
GCD10000x10000/WithXY-8              476µs ± 1%     473µs ± 1%   -0.48%  (p=0.009 n=19+19)
GCD10000x100000/WithoutXY-8          573µs ± 1%     571µs ± 1%   -0.45%  (p=0.012 n=20+20)
GCD10000x100000/WithXY-8            3.35ms ± 1%    3.35ms ± 1%     ~     (p=0.444 n=20+19)
GCD100000x100000/WithoutXY-8        12.0ms ± 2%    11.9ms ± 2%     ~     (p=0.276 n=18+20)
GCD100000x100000/WithXY-8           27.3ms ± 1%    27.3ms ± 1%     ~     (p=0.792 n=20+19)
Hilbert-8                            672µs ± 0%     611µs ± 0%   -9.02%  (p=0.000 n=19+19)
Binomial-8                          1.40µs ± 0%    1.18µs ± 0%  -15.69%  (p=0.000 n=16+14)
QuoRem-8                            2.20µs ± 1%    2.17µs ± 1%   -1.13%  (p=0.000 n=19+19)
Exp-8                               4.10ms ± 1%    4.11ms ± 1%     ~     (p=0.296 n=20+19)
Exp2-8                              4.11ms ± 1%    4.12ms ± 1%     ~     (p=0.429 n=20+20)
Bitset-8                            8.67ns ± 6%    8.74ns ± 4%     ~     (p=0.139 n=19+17)
BitsetNeg-8                         43.6ns ± 1%    43.8ns ± 2%   +0.61%  (p=0.036 n=20+20)
BitsetOrig-8                        77.5ns ± 1%    68.4ns ± 1%  -11.77%  (p=0.000 n=19+20)
BitsetNegOrig-8                      145ns ± 1%     141ns ± 1%   -2.87%  (p=0.000 n=19+20)
ModSqrt225_Tonelli-8                 324µs ± 1%     324µs ± 1%     ~     (p=0.409 n=18+20)
ModSqrt225_3Mod4-8                  98.9µs ± 1%    99.1µs ± 1%     ~     (p=0.298 n=19+18)
ModSqrt231_Tonelli-8                 337µs ± 1%     337µs ± 1%     ~     (p=0.718 n=20+18)
ModSqrt231_5Mod8-8                   115µs ± 1%     114µs ± 1%   -0.22%  (p=0.050 n=20+20)
ModInverse-8                         895ns ± 0%     869ns ± 1%   -2.83%  (p=0.000 n=17+17)
Sqrt-8                              28.1µs ± 1%    28.1µs ± 0%   -0.28%  (p=0.000 n=16+20)
IntSqr/1-8                          10.8ns ± 3%    10.5ns ± 3%   -2.51%  (p=0.000 n=19+17)
IntSqr/2-8                          30.5ns ± 2%    30.3ns ± 4%   -0.71%  (p=0.035 n=18+18)
IntSqr/3-8                          40.1ns ± 1%    40.1ns ± 1%     ~     (p=0.710 n=20+17)
IntSqr/5-8                          65.3ns ± 1%    65.4ns ± 2%     ~     (p=0.744 n=19+19)
IntSqr/8-8                           101ns ± 1%     102ns ± 0%     ~     (p=0.234 n=19+20)
IntSqr/10-8                          138ns ± 0%     138ns ± 2%     ~     (p=0.827 n=18+18)
IntSqr/20-8                          378ns ± 1%     378ns ± 1%     ~     (p=0.479 n=18+18)
IntSqr/30-8                          637ns ± 0%     638ns ± 1%     ~     (p=0.051 n=18+20)
IntSqr/50-8                         1.34µs ± 2%    1.34µs ± 1%     ~     (p=0.970 n=18+19)
IntSqr/80-8                         2.78µs ± 0%    2.78µs ± 1%   -0.18%  (p=0.006 n=19+17)
IntSqr/100-8                        3.98µs ± 0%    3.98µs ± 0%     ~     (p=0.057 n=17+19)
IntSqr/200-8                        13.5µs ± 0%    13.5µs ± 1%   -0.33%  (p=0.000 n=19+17)
IntSqr/300-8                        25.3µs ± 1%    25.3µs ± 1%     ~     (p=0.361 n=19+20)
IntSqr/500-8                        62.9µs ± 0%    62.9µs ± 1%     ~     (p=0.899 n=17+17)
IntSqr/800-8                         128µs ± 1%     127µs ± 1%   -0.32%  (p=0.016 n=18+20)
IntSqr/1000-8                        192µs ± 0%     192µs ± 1%     ~     (p=0.916 n=17+18)
Div/20/10-8                         34.9ns ± 2%    35.6ns ± 1%   +2.01%  (p=0.000 n=20+20)
Div/200/100-8                        218ns ± 1%     215ns ± 2%   -1.43%  (p=0.000 n=18+18)
Div/2000/1000-8                     1.16µs ± 1%    1.15µs ± 1%   -1.04%  (p=0.000 n=19+20)
Div/20000/10000-8                   35.7µs ± 1%    35.4µs ± 1%   -0.69%  (p=0.000 n=19+18)
Div/200000/100000-8                 2.89ms ± 1%    2.88ms ± 1%   -0.62%  (p=0.007 n=19+20)
Mul-8                               9.28ms ± 1%    9.27ms ± 1%     ~     (p=0.563 n=18+18)
ZeroShifts/Shl-8                     712ns ± 6%     716ns ± 7%     ~     (p=0.597 n=20+20)
ZeroShifts/ShlSame-8                4.00ns ± 1%    4.06ns ± 5%     ~     (p=0.162 n=18+20)
ZeroShifts/Shr-8                     714ns ±10%   1285ns ±156%     ~     (p=0.250 n=20+20)
ZeroShifts/ShrSame-8                4.00ns ± 1%    4.09ns ±10%   +2.34%  (p=0.048 n=16+19)
Exp3Power/0x10-8                     154ns ± 0%     159ns ±13%     ~     (p=0.197 n=14+20)
Exp3Power/0x40-8                     171ns ± 1%     175ns ± 8%     ~     (p=0.058 n=16+19)
Exp3Power/0x100-8                    287ns ± 0%     316ns ± 4%  +10.03%  (p=0.000 n=17+19)
Exp3Power/0x400-8                    698ns ± 1%     801ns ± 6%  +14.75%  (p=0.000 n=19+20)
Exp3Power/0x1000-8                  2.87µs ± 0%    3.65µs ± 6%  +27.24%  (p=0.000 n=18+18)
Exp3Power/0x4000-8                  21.9µs ± 1%    28.7µs ± 8%  +31.09%  (p=0.000 n=18+20)
Exp3Power/0x10000-8                  204µs ± 0%     267µs ± 9%  +30.81%  (p=0.000 n=20+20)
Exp3Power/0x40000-8                 1.86ms ± 0%    2.26ms ± 5%  +21.68%  (p=0.000 n=18+19)
Exp3Power/0x100000-8                17.5ms ± 1%    20.7ms ± 7%  +18.39%  (p=0.000 n=19+20)
Exp3Power/0x400000-8                 156ms ± 0%     172ms ± 6%  +10.54%  (p=0.000 n=19+20)
Fibo-8                              26.9ms ± 1%    27.5ms ± 3%   +2.32%  (p=0.000 n=19+19)
NatSqr/1-8                          31.0ns ± 4%    39.5ns ±29%  +27.25%  (p=0.000 n=20+19)
NatSqr/2-8                          54.1ns ± 1%    69.0ns ±28%  +27.52%  (p=0.000 n=20+20)
NatSqr/3-8                          66.6ns ± 1%    83.0ns ±25%  +24.59%  (p=0.000 n=20+20)
NatSqr/5-8                          97.1ns ± 1%   119.9ns ±12%  +23.50%  (p=0.000 n=16+20)
NatSqr/8-8                           138ns ± 1%     171ns ± 9%  +24.20%  (p=0.000 n=19+20)
NatSqr/10-8                          182ns ± 0%     225ns ± 9%  +23.50%  (p=0.000 n=16+20)
NatSqr/20-8                          447ns ± 1%     624ns ± 6%  +39.64%  (p=0.000 n=19+19)
NatSqr/30-8                          736ns ± 2%     986ns ± 9%  +33.94%  (p=0.000 n=19+20)
NatSqr/50-8                         1.51µs ± 2%    1.97µs ± 9%  +30.42%  (p=0.000 n=20+20)
NatSqr/80-8                         3.03µs ± 1%    3.67µs ± 7%  +21.08%  (p=0.000 n=20+20)
NatSqr/100-8                        4.31µs ± 1%    5.20µs ± 7%  +20.52%  (p=0.000 n=19+20)
NatSqr/200-8                        14.2µs ± 0%    16.3µs ± 4%  +14.92%  (p=0.000 n=19+20)
NatSqr/300-8                        27.8µs ± 1%    33.2µs ± 7%  +19.28%  (p=0.000 n=20+18)
NatSqr/500-8                        66.6µs ± 1%    74.5µs ± 3%  +11.87%  (p=0.000 n=18+18)
NatSqr/800-8                         135µs ± 1%     165µs ± 7%  +22.33%  (p=0.000 n=20+20)
NatSqr/1000-8                        200µs ± 0%     228µs ± 3%  +14.39%  (p=0.000 n=19+20)
NatSetBytes/8-8                     8.87ns ± 4%    8.77ns ± 2%   -1.17%  (p=0.020 n=20+16)
NatSetBytes/24-8                    38.6ns ± 3%    49.5ns ±29%  +28.32%  (p=0.000 n=18+19)
NatSetBytes/128-8                   75.2ns ± 1%   120.7ns ±29%  +60.60%  (p=0.000 n=17+20)
NatSetBytes/7-8                     16.2ns ± 2%    16.5ns ± 2%   +1.76%  (p=0.000 n=20+20)
NatSetBytes/23-8                    46.5ns ± 1%    60.2ns ±24%  +29.59%  (p=0.000 n=20+20)
NatSetBytes/127-8                   83.1ns ± 1%   118.2ns ±20%  +42.33%  (p=0.000 n=18+20)
ScanPi-8                            89.1µs ± 1%   117.4µs ±12%  +31.75%  (p=0.000 n=18+20)
StringPiParallel-8                  35.1µs ± 9%    40.2µs ±12%  +14.53%  (p=0.000 n=20+20)
Scan/10/Base2-8                      410ns ±14%     429ns ±10%   +4.47%  (p=0.018 n=19+20)
Scan/100/Base2-8                    3.05µs ±20%    2.97µs ±14%     ~     (p=0.449 n=20+20)
Scan/1000/Base2-8                   29.3µs ± 8%    30.1µs ±23%     ~     (p=0.355 n=20+20)
Scan/10000/Base2-8                   402µs ±13%     395µs ±14%     ~     (p=0.355 n=20+20)
Scan/100000/Base2-8                 11.8ms ±10%    11.6ms ± 1%     ~     (p=0.245 n=17+18)
Scan/10/Base8-8                      194ns ± 6%     196ns ±12%     ~     (p=0.829 n=20+19)
Scan/100/Base8-8                    1.11µs ±15%    1.11µs ±12%     ~     (p=0.743 n=20+20)
Scan/1000/Base8-8                   11.7µs ±10%    11.7µs ±12%     ~     (p=0.904 n=20+20)
Scan/10000/Base8-8                   209µs ± 7%     210µs ± 8%     ~     (p=0.478 n=20+20)
Scan/100000/Base8-8                 10.6ms ± 7%    10.4ms ± 6%     ~     (p=0.112 n=20+18)
Scan/10/Base10-8                     182ns ±12%     188ns ±11%   +3.52%  (p=0.044 n=20+20)
Scan/100/Base10-8                   1.01µs ± 8%    1.00µs ±13%     ~     (p=0.588 n=20+20)
Scan/1000/Base10-8                  10.7µs ±20%    10.6µs ±14%     ~     (p=0.560 n=20+20)
Scan/10000/Base10-8                  195µs ±10%     194µs ± 9%     ~     (p=0.883 n=20+20)
Scan/100000/Base10-8                10.6ms ± 2%    10.6ms ± 2%     ~     (p=0.495 n=20+20)
Scan/10/Base16-8                     166ns ±10%     174ns ±17%     ~     (p=0.072 n=20+20)
Scan/100/Base16-8                    836ns ±10%     826ns ±12%     ~     (p=0.562 n=20+17)
Scan/1000/Base16-8                  8.96µs ±13%    8.65µs ± 9%     ~     (p=0.203 n=20+18)
Scan/10000/Base16-8                  198µs ± 3%     198µs ± 5%     ~     (p=0.718 n=20+20)
Scan/100000/Base16-8                11.1ms ± 3%    11.0ms ± 4%     ~     (p=0.512 n=20+20)
String/10/Base2-8                   88.1ns ± 7%    94.1ns ±11%   +6.80%  (p=0.000 n=19+20)
String/100/Base2-8                   577ns ± 4%     598ns ± 5%   +3.72%  (p=0.000 n=20+20)
String/1000/Base2-8                 5.25µs ± 2%    5.62µs ± 5%   +7.04%  (p=0.000 n=19+20)
String/10000/Base2-8                55.6µs ± 1%    60.1µs ± 2%   +8.12%  (p=0.000 n=19+19)
String/100000/Base2-8                519µs ± 2%     560µs ± 2%   +7.91%  (p=0.000 n=18+17)
String/10/Base8-8                   52.2ns ± 8%    53.3ns ±12%     ~     (p=0.188 n=20+18)
String/100/Base8-8                   218ns ± 3%     232ns ±10%   +6.66%  (p=0.000 n=20+20)
String/1000/Base8-8                 1.84µs ± 3%    1.94µs ± 4%   +5.07%  (p=0.000 n=20+18)
String/10000/Base8-8                18.1µs ± 2%    19.1µs ± 3%   +5.84%  (p=0.000 n=20+19)
String/100000/Base8-8                184µs ± 2%     197µs ± 1%   +7.15%  (p=0.000 n=19+19)
String/10/Base10-8                   158ns ± 7%     146ns ± 6%   -7.65%  (p=0.000 n=20+19)
String/100/Base10-8                  807ns ± 2%     845ns ± 4%   +4.79%  (p=0.000 n=20+19)
String/1000/Base10-8                3.99µs ± 3%    3.99µs ± 7%     ~     (p=0.920 n=20+20)
String/10000/Base10-8               20.8µs ± 6%    22.1µs ±10%   +6.11%  (p=0.000 n=19+20)
String/100000/Base10-8              5.60ms ± 2%    5.59ms ± 2%     ~     (p=0.749 n=20+19)
String/10/Base16-8                  49.0ns ±13%    49.3ns ±16%     ~     (p=0.581 n=19+20)
String/100/Base16-8                  173ns ± 5%     185ns ± 6%   +6.63%  (p=0.000 n=20+18)
String/1000/Base16-8                1.38µs ± 3%    1.49µs ±10%   +8.27%  (p=0.000 n=19+20)
String/10000/Base16-8               13.5µs ± 2%    14.5µs ± 3%   +7.08%  (p=0.000 n=20+20)
String/100000/Base16-8               138µs ± 4%     148µs ± 4%   +7.57%  (p=0.000 n=19+20)
LeafSize/0-8                        2.74ms ± 1%    2.79ms ± 2%   +2.00%  (p=0.000 n=19+19)
LeafSize/1-8                        24.8µs ± 4%    26.1µs ± 8%   +5.33%  (p=0.000 n=18+19)
LeafSize/2-8                        24.9µs ± 7%    25.0µs ± 8%     ~     (p=0.989 n=20+19)
LeafSize/3-8                        97.6µs ± 3%   100.2µs ± 5%   +2.66%  (p=0.001 n=20+19)
LeafSize/4-8                        25.2µs ± 5%    25.4µs ± 5%     ~     (p=0.173 n=19+20)
LeafSize/5-8                         118µs ± 2%     119µs ± 5%     ~     (p=0.478 n=20+20)
LeafSize/6-8                        97.6µs ± 3%   100.1µs ± 8%   +2.65%  (p=0.021 n=20+19)
LeafSize/7-8                        65.6µs ± 5%    67.5µs ± 6%   +2.92%  (p=0.003 n=20+19)
LeafSize/8-8                        25.5µs ± 5%    25.6µs ± 6%     ~     (p=0.461 n=19+20)
LeafSize/9-8                         134µs ± 4%     136µs ± 5%     ~     (p=0.194 n=19+20)
LeafSize/10-8                        119µs ± 3%     122µs ± 3%   +2.52%  (p=0.000 n=20+19)
LeafSize/11-8                        115µs ± 5%     116µs ± 5%     ~     (p=0.158 n=20+19)
LeafSize/12-8                       97.4µs ± 4%   100.3µs ± 5%   +2.91%  (p=0.003 n=19+20)
LeafSize/13-8                       93.1µs ± 4%    93.0µs ± 6%     ~     (p=0.698 n=20+20)
LeafSize/14-8                       67.0µs ± 3%    69.7µs ± 6%   +4.10%  (p=0.000 n=20+20)
LeafSize/15-8                       48.3µs ± 2%    49.3µs ± 6%   +1.91%  (p=0.014 n=19+20)
LeafSize/16-8                       25.6µs ± 5%    25.6µs ± 6%     ~     (p=0.947 n=20+20)
LeafSize/32-8                       30.1µs ± 4%    30.3µs ± 5%     ~     (p=0.685 n=18+19)
LeafSize/64-8                       53.4µs ± 2%    54.0µs ± 3%     ~     (p=0.053 n=19+19)
ProbablyPrime/n=0-8                 3.59ms ± 1%    3.55ms ± 1%   -1.12%  (p=0.000 n=20+18)
ProbablyPrime/n=1-8                 4.21ms ± 2%    4.17ms ± 2%   -0.73%  (p=0.018 n=20+19)
ProbablyPrime/n=5-8                 6.74ms ± 1%    6.72ms ± 1%     ~     (p=0.102 n=20+20)
ProbablyPrime/n=10-8                9.91ms ± 1%    9.89ms ± 2%     ~     (p=0.322 n=19+20)
ProbablyPrime/n=20-8                16.2ms ± 1%    16.1ms ± 2%   -0.52%  (p=0.006 n=19+19)
ProbablyPrime/Lucas-8               2.94ms ± 1%    2.95ms ± 1%   +0.52%  (p=0.002 n=18+19)
ProbablyPrime/MillerRabinBase2-8     641µs ± 2%     640µs ± 2%     ~     (p=0.607 n=19+20)
FloatSqrt/64-8                       653ns ± 5%     704ns ± 5%   +7.82%  (p=0.000 n=19+20)
FloatSqrt/128-8                     1.32µs ± 3%    1.42µs ± 5%   +7.29%  (p=0.000 n=18+20)
FloatSqrt/256-8                     1.44µs ± 2%    1.45µs ± 4%     ~     (p=0.089 n=19+19)
FloatSqrt/1000-8                    3.36µs ± 3%    3.42µs ± 5%   +1.82%  (p=0.012 n=20+20)
FloatSqrt/10000-8                   25.5µs ± 2%    27.5µs ± 7%   +7.91%  (p=0.000 n=18+19)
FloatSqrt/100000-8                   629µs ± 6%     663µs ± 9%   +5.32%  (p=0.000 n=18+20)
FloatSqrt/1000000-8                 46.4ms ± 2%    46.6ms ± 5%     ~     (p=0.351 n=20+19)
[Geo mean]                          9.60µs        10.01µs        +4.28%

name                              old alloc/op   new alloc/op   delta
DecimalConversion-8                 54.0kB ± 0%    43.6kB ± 0%  -19.40%  (p=0.000 n=20+20)
FloatString/100-8                     400B ± 0%      400B ± 0%     ~     (all equal)
FloatString/1000-8                  3.10kB ± 0%    3.10kB ± 0%     ~     (all equal)
FloatString/10000-8                 52.1kB ± 0%    52.1kB ± 0%     ~     (p=0.153 n=20+20)
FloatString/100000-8                 582kB ± 0%     582kB ± 0%     ~     (all equal)
FloatAdd/10-8                        0.00B          0.00B          ~     (all equal)
FloatAdd/100-8                       0.00B          0.00B          ~     (all equal)
FloatAdd/1000-8                      0.00B          0.00B          ~     (all equal)
FloatAdd/10000-8                     0.00B          0.00B          ~     (all equal)
FloatAdd/100000-8                    0.00B          0.00B          ~     (all equal)
FloatSub/10-8                        0.00B          0.00B          ~     (all equal)
FloatSub/100-8                       0.00B          0.00B          ~     (all equal)
FloatSub/1000-8                      0.00B          0.00B          ~     (all equal)
FloatSub/10000-8                     0.00B          0.00B          ~     (all equal)
FloatSub/100000-8                    0.00B          0.00B          ~     (all equal)
ParseFloatSmallExp-8                4.18kB ± 0%    3.60kB ± 0%  -13.79%  (p=0.000 n=20+20)
ParseFloatLargeExp-8                18.9kB ± 0%    19.3kB ± 0%   +2.25%  (p=0.000 n=20+20)
GCD10x10/WithoutXY-8                 96.0B ± 0%     16.0B ± 0%  -83.33%  (p=0.000 n=20+20)
GCD10x10/WithXY-8                     240B ± 0%       88B ± 0%  -63.33%  (p=0.000 n=20+20)
GCD10x100/WithoutXY-8                 192B ± 0%      112B ± 0%  -41.67%  (p=0.000 n=20+20)
GCD10x100/WithXY-8                    464B ± 0%      424B ± 0%   -8.62%  (p=0.000 n=20+20)
GCD10x1000/WithoutXY-8                416B ± 0%      336B ± 0%  -19.23%  (p=0.000 n=20+20)
GCD10x1000/WithXY-8                 1.25kB ± 0%    1.10kB ± 0%  -12.18%  (p=0.000 n=20+20)
GCD10x10000/WithoutXY-8             2.91kB ± 0%    2.83kB ± 0%   -2.75%  (p=0.000 n=20+20)
GCD10x10000/WithXY-8                8.70kB ± 0%    8.55kB ± 0%   -1.76%  (p=0.000 n=16+16)
GCD10x100000/WithoutXY-8            27.2kB ± 0%    27.2kB ± 0%   -0.29%  (p=0.000 n=20+20)
GCD10x100000/WithXY-8               82.4kB ± 0%    82.3kB ± 0%   -0.17%  (p=0.000 n=20+19)
GCD100x100/WithoutXY-8                288B ± 0%      384B ± 0%  +33.33%  (p=0.000 n=20+20)
GCD100x100/WithXY-8                   464B ± 0%      576B ± 0%  +24.14%  (p=0.000 n=20+20)
GCD100x1000/WithoutXY-8               640B ± 0%      688B ± 0%   +7.50%  (p=0.000 n=20+20)
GCD100x1000/WithXY-8                1.52kB ± 0%    1.46kB ± 0%   -3.68%  (p=0.000 n=20+20)
GCD100x10000/WithoutXY-8            4.24kB ± 0%    4.29kB ± 0%   +1.13%  (p=0.000 n=20+20)
GCD100x10000/WithXY-8               11.1kB ± 0%    11.0kB ± 0%   -0.51%  (p=0.000 n=15+20)
GCD100x100000/WithoutXY-8           40.9kB ± 0%    40.9kB ± 0%   +0.12%  (p=0.000 n=20+19)
GCD100x100000/WithXY-8               110kB ± 0%     109kB ± 0%   -0.08%  (p=0.000 n=20+20)
GCD1000x1000/WithoutXY-8            1.22kB ± 0%    1.06kB ± 0%  -13.16%  (p=0.000 n=20+20)
GCD1000x1000/WithXY-8               2.37kB ± 0%    2.11kB ± 0%  -10.83%  (p=0.000 n=20+20)
GCD1000x10000/WithoutXY-8           4.71kB ± 0%    4.63kB ± 0%   -1.70%  (p=0.000 n=20+19)
GCD1000x10000/WithXY-8              28.2kB ± 0%    28.0kB ± 0%   -0.43%  (p=0.000 n=20+15)
GCD1000x100000/WithoutXY-8          41.3kB ± 0%    41.2kB ± 0%   -0.20%  (p=0.000 n=20+16)
GCD1000x100000/WithXY-8              301kB ± 0%     301kB ± 0%   -0.13%  (p=0.000 n=20+20)
GCD10000x10000/WithoutXY-8          8.64kB ± 0%    8.48kB ± 0%   -1.85%  (p=0.000 n=20+20)
GCD10000x10000/WithXY-8             57.2kB ± 0%    57.7kB ± 0%   +0.80%  (p=0.000 n=20+20)
GCD10000x100000/WithoutXY-8         43.8kB ± 0%    43.7kB ± 0%   -0.19%  (p=0.000 n=20+18)
GCD10000x100000/WithXY-8            2.08MB ± 0%    2.08MB ± 0%   -0.02%  (p=0.000 n=15+19)
GCD100000x100000/WithoutXY-8        81.6kB ± 0%    81.4kB ± 0%   -0.20%  (p=0.000 n=20+20)
GCD100000x100000/WithXY-8           4.32MB ± 0%    4.33MB ± 0%   +0.12%  (p=0.000 n=20+20)
Hilbert-8                            653kB ± 0%     313kB ± 0%  -52.13%  (p=0.000 n=19+20)
Binomial-8                          1.82kB ± 0%    1.02kB ± 0%  -43.86%  (p=0.000 n=20+20)
QuoRem-8                             0.00B          0.00B          ~     (all equal)
Exp-8                               11.1kB ± 0%    11.0kB ± 0%   -0.34%  (p=0.000 n=19+20)
Exp2-8                              11.3kB ± 0%    11.3kB ± 0%   -0.35%  (p=0.000 n=19+20)
Bitset-8                             0.00B          0.00B          ~     (all equal)
BitsetNeg-8                          0.00B          0.00B          ~     (all equal)
BitsetOrig-8                          103B ± 0%       63B ± 0%  -38.83%  (p=0.000 n=20+20)
BitsetNegOrig-8                       215B ± 0%      175B ± 0%  -18.60%  (p=0.000 n=20+20)
ModSqrt225_Tonelli-8                11.3kB ± 0%    11.0kB ± 0%   -2.76%  (p=0.000 n=20+17)
ModSqrt225_3Mod4-8                  3.57kB ± 0%    3.53kB ± 0%   -1.12%  (p=0.000 n=20+20)
ModSqrt231_Tonelli-8                11.0kB ± 0%    10.7kB ± 0%   -2.55%  (p=0.000 n=20+20)
ModSqrt231_5Mod8-8                  4.21kB ± 0%    4.09kB ± 0%   -2.85%  (p=0.000 n=16+20)
ModInverse-8                        1.44kB ± 0%    1.28kB ± 0%  -11.11%  (p=0.000 n=20+20)
Sqrt-8                              6.00kB ± 0%    6.00kB ± 0%     ~     (all equal)
IntSqr/1-8                           0.00B          0.00B          ~     (all equal)
IntSqr/2-8                           0.00B          0.00B          ~     (all equal)
IntSqr/3-8                           0.00B          0.00B          ~     (all equal)
IntSqr/5-8                           0.00B          0.00B          ~     (all equal)
IntSqr/8-8                           0.00B          0.00B          ~     (all equal)
IntSqr/10-8                          0.00B          0.00B          ~     (all equal)
IntSqr/20-8                           320B ± 0%      320B ± 0%     ~     (all equal)
IntSqr/30-8                           480B ± 0%      480B ± 0%     ~     (all equal)
IntSqr/50-8                           896B ± 0%      896B ± 0%     ~     (all equal)
IntSqr/80-8                         1.28kB ± 0%    1.28kB ± 0%     ~     (all equal)
IntSqr/100-8                        1.79kB ± 0%    1.79kB ± 0%     ~     (all equal)
IntSqr/200-8                        3.20kB ± 0%    3.20kB ± 0%     ~     (all equal)
IntSqr/300-8                        8.06kB ± 0%    8.06kB ± 0%     ~     (all equal)
IntSqr/500-8                        12.3kB ± 0%    12.3kB ± 0%     ~     (all equal)
IntSqr/800-8                        28.8kB ± 0%    28.8kB ± 0%     ~     (all equal)
IntSqr/1000-8                       36.9kB ± 0%    36.9kB ± 0%     ~     (all equal)
Div/20/10-8                          0.00B          0.00B          ~     (all equal)
Div/200/100-8                        0.00B          0.00B          ~     (all equal)
Div/2000/1000-8                      0.00B          0.00B          ~     (all equal)
Div/20000/10000-8                    0.00B          0.00B          ~     (all equal)
Div/200000/100000-8                   690B ± 0%      690B ± 0%     ~     (all equal)
Mul-8                                565kB ± 0%     565kB ± 0%     ~     (all equal)
ZeroShifts/Shl-8                    6.53kB ± 0%    6.53kB ± 0%     ~     (all equal)
ZeroShifts/ShlSame-8                 0.00B          0.00B          ~     (all equal)
ZeroShifts/Shr-8                    6.53kB ± 0%    6.53kB ± 0%     ~     (all equal)
ZeroShifts/ShrSame-8                 0.00B          0.00B          ~     (all equal)
Exp3Power/0x10-8                      192B ± 0%      112B ± 0%  -41.67%  (p=0.000 n=20+20)
Exp3Power/0x40-8                      192B ± 0%      112B ± 0%  -41.67%  (p=0.000 n=20+20)
Exp3Power/0x100-8                     288B ± 0%      208B ± 0%  -27.78%  (p=0.000 n=20+20)
Exp3Power/0x400-8                     672B ± 0%      592B ± 0%  -11.90%  (p=0.000 n=20+20)
Exp3Power/0x1000-8                  3.33kB ± 0%    3.25kB ± 0%   -2.40%  (p=0.000 n=20+20)
Exp3Power/0x4000-8                  13.8kB ± 0%    13.7kB ± 0%   -0.58%  (p=0.000 n=20+20)
Exp3Power/0x10000-8                  117kB ± 0%     117kB ± 0%   -0.07%  (p=0.000 n=20+20)
Exp3Power/0x40000-8                  755kB ± 0%     755kB ± 0%   -0.01%  (p=0.000 n=19+20)
Exp3Power/0x100000-8                5.22MB ± 0%    5.22MB ± 0%   -0.00%  (p=0.000 n=20+20)
Exp3Power/0x400000-8                39.8MB ± 0%    39.8MB ± 0%   -0.00%  (p=0.000 n=20+19)
Fibo-8                              3.09MB ± 0%    3.08MB ± 0%   -0.28%  (p=0.000 n=20+16)
NatSqr/1-8                           48.0B ± 0%     48.0B ± 0%     ~     (all equal)
NatSqr/2-8                           64.0B ± 0%     64.0B ± 0%     ~     (all equal)
NatSqr/3-8                           80.0B ± 0%     80.0B ± 0%     ~     (all equal)
NatSqr/5-8                            112B ± 0%      112B ± 0%     ~     (all equal)
NatSqr/8-8                            160B ± 0%      160B ± 0%     ~     (all equal)
NatSqr/10-8                           192B ± 0%      192B ± 0%     ~     (all equal)
NatSqr/20-8                           672B ± 0%      672B ± 0%     ~     (all equal)
NatSqr/30-8                           992B ± 0%      992B ± 0%     ~     (all equal)
NatSqr/50-8                         1.79kB ± 0%    1.79kB ± 0%     ~     (all equal)
NatSqr/80-8                         2.69kB ± 0%    2.69kB ± 0%     ~     (all equal)
NatSqr/100-8                        3.58kB ± 0%    3.58kB ± 0%     ~     (all equal)
NatSqr/200-8                        6.66kB ± 0%    6.66kB ± 0%     ~     (all equal)
NatSqr/300-8                        24.4kB ± 0%    24.4kB ± 0%     ~     (all equal)
NatSqr/500-8                        36.9kB ± 0%    36.9kB ± 0%     ~     (all equal)
NatSqr/800-8                        69.8kB ± 0%    69.8kB ± 0%     ~     (all equal)
NatSqr/1000-8                       86.0kB ± 0%    86.0kB ± 0%     ~     (all equal)
NatSetBytes/8-8                      0.00B          0.00B          ~     (all equal)
NatSetBytes/24-8                     64.0B ± 0%     64.0B ± 0%     ~     (all equal)
NatSetBytes/128-8                     160B ± 0%      160B ± 0%     ~     (all equal)
NatSetBytes/7-8                      0.00B          0.00B          ~     (all equal)
NatSetBytes/23-8                     64.0B ± 0%     64.0B ± 0%     ~     (all equal)
NatSetBytes/127-8                     160B ± 0%      160B ± 0%     ~     (all equal)
ScanPi-8                            75.4kB ± 0%    75.7kB ± 0%   +0.41%  (p=0.000 n=20+20)
StringPiParallel-8                  20.4kB ± 0%    20.4kB ± 0%     ~     (p=0.223 n=20+20)
Scan/10/Base2-8                      48.0B ± 0%     48.0B ± 0%     ~     (all equal)
Scan/100/Base2-8                     48.0B ± 0%     48.0B ± 0%     ~     (all equal)
Scan/1000/Base2-8                    48.0B ± 0%     48.0B ± 0%     ~     (all equal)
Scan/10000/Base2-8                   48.0B ± 0%     48.0B ± 0%     ~     (all equal)
Scan/100000/Base2-8                  48.0B ± 0%     48.0B ± 0%     ~     (all equal)
Scan/10/Base8-8                      48.0B ± 0%     48.0B ± 0%     ~     (all equal)
Scan/100/Base8-8                     48.0B ± 0%     48.0B ± 0%     ~     (all equal)
Scan/1000/Base8-8                    48.0B ± 0%     48.0B ± 0%     ~     (all equal)
Scan/10000/Base8-8                   48.0B ± 0%     48.0B ± 0%     ~     (all equal)
Scan/100000/Base8-8                  48.0B ± 0%     48.0B ± 0%     ~     (all equal)
Scan/10/Base10-8                     48.0B ± 0%     48.0B ± 0%     ~     (all equal)
Scan/100/Base10-8                    48.0B ± 0%     48.0B ± 0%     ~     (all equal)
Scan/1000/Base10-8                   48.0B ± 0%     48.0B ± 0%     ~     (all equal)
Scan/10000/Base10-8                  48.0B ± 0%     48.0B ± 0%     ~     (all equal)
Scan/100000/Base10-8                 48.0B ± 0%     48.0B ± 0%     ~     (all equal)
Scan/10/Base16-8                     48.0B ± 0%     48.0B ± 0%     ~     (all equal)
Scan/100/Base16-8                    48.0B ± 0%     48.0B ± 0%     ~     (all equal)
Scan/1000/Base16-8                   48.0B ± 0%     48.0B ± 0%     ~     (all equal)
Scan/10000/Base16-8                  48.0B ± 0%     48.0B ± 0%     ~     (all equal)
Scan/100000/Base16-8                 48.0B ± 0%     48.0B ± 0%     ~     (all equal)
String/10/Base2-8                    48.0B ± 0%     48.0B ± 0%     ~     (all equal)
String/100/Base2-8                    352B ± 0%      352B ± 0%     ~     (all equal)
String/1000/Base2-8                 3.46kB ± 0%    3.46kB ± 0%     ~     (all equal)
String/10000/Base2-8                41.0kB ± 0%    41.0kB ± 0%     ~     (all equal)
String/100000/Base2-8                336kB ± 0%     336kB ± 0%     ~     (all equal)
String/10/Base8-8                    16.0B ± 0%     16.0B ± 0%     ~     (all equal)
String/100/Base8-8                    112B ± 0%      112B ± 0%     ~     (all equal)
String/1000/Base8-8                 1.15kB ± 0%    1.15kB ± 0%     ~     (all equal)
String/10000/Base8-8                12.3kB ± 0%    12.3kB ± 0%     ~     (all equal)
String/100000/Base8-8                115kB ± 0%     115kB ± 0%     ~     (all equal)
String/10/Base10-8                   64.0B ± 0%     24.0B ± 0%  -62.50%  (p=0.000 n=20+20)
String/100/Base10-8                   192B ± 0%      192B ± 0%     ~     (all equal)
String/1000/Base10-8                1.95kB ± 0%    1.95kB ± 0%     ~     (all equal)
String/10000/Base10-8               20.0kB ± 0%    20.0kB ± 0%     ~     (p=0.983 n=19+20)
String/100000/Base10-8               210kB ± 1%     211kB ± 1%   +0.82%  (p=0.000 n=19+20)
String/10/Base16-8                   16.0B ± 0%     16.0B ± 0%     ~     (all equal)
String/100/Base16-8                  96.0B ± 0%     96.0B ± 0%     ~     (all equal)
String/1000/Base16-8                  896B ± 0%      896B ± 0%     ~     (all equal)
String/10000/Base16-8               9.47kB ± 0%    9.47kB ± 0%     ~     (all equal)
String/100000/Base16-8              90.1kB ± 0%    90.1kB ± 0%     ~     (all equal)
LeafSize/0-8                        16.9kB ± 0%    16.8kB ± 0%   -0.44%  (p=0.000 n=20+20)
LeafSize/1-8                        22.4kB ± 0%    22.3kB ± 0%   -0.34%  (p=0.000 n=20+19)
LeafSize/2-8                        22.4kB ± 0%    22.3kB ± 0%   -0.34%  (p=0.000 n=20+19)
LeafSize/3-8                        22.4kB ± 0%    22.3kB ± 0%   -0.34%  (p=0.000 n=20+17)
LeafSize/4-8                        22.4kB ± 0%    22.3kB ± 0%   -0.34%  (p=0.000 n=20+19)
LeafSize/5-8                        22.4kB ± 0%    22.3kB ± 0%   -0.33%  (p=0.000 n=20+20)
LeafSize/6-8                        22.3kB ± 0%    22.2kB ± 0%   -0.34%  (p=0.000 n=20+20)
LeafSize/7-8                        22.3kB ± 0%    22.2kB ± 0%   -0.35%  (p=0.000 n=20+20)
LeafSize/8-8                        22.3kB ± 0%    22.2kB ± 0%   -0.34%  (p=0.000 n=16+20)
LeafSize/9-8                        22.3kB ± 0%    22.2kB ± 0%   -0.33%  (p=0.000 n=20+20)
LeafSize/10-8                       22.3kB ± 0%    22.2kB ± 0%   -0.33%  (p=0.000 n=20+20)
LeafSize/11-8                       22.3kB ± 0%    22.2kB ± 0%   -0.33%  (p=0.000 n=20+20)
LeafSize/12-8                       22.3kB ± 0%    22.2kB ± 0%   -0.33%  (p=0.000 n=20+20)
LeafSize/13-8                       22.3kB ± 0%    22.2kB ± 0%   -0.34%  (p=0.000 n=20+15)
LeafSize/14-8                       22.3kB ± 0%    22.2kB ± 0%   -0.33%  (p=0.000 n=20+20)
LeafSize/15-8                       22.3kB ± 0%    22.2kB ± 0%   -0.33%  (p=0.000 n=20+20)
LeafSize/16-8                       22.3kB ± 0%    22.2kB ± 0%   -0.33%  (p=0.000 n=19+20)
LeafSize/32-8                       22.3kB ± 0%    22.2kB ± 0%   -0.32%  (p=0.000 n=20+20)
LeafSize/64-8                       21.8kB ± 0%    21.7kB ± 0%   -0.33%  (p=0.000 n=18+19)
ProbablyPrime/n=0-8                 15.3kB ± 0%    14.9kB ± 0%   -2.35%  (p=0.000 n=20+20)
ProbablyPrime/n=1-8                 21.0kB ± 0%    20.7kB ± 0%   -1.71%  (p=0.000 n=20+20)
ProbablyPrime/n=5-8                 43.4kB ± 0%    42.9kB ± 0%   -1.20%  (p=0.000 n=20+20)
ProbablyPrime/n=10-8                71.5kB ± 0%    70.7kB ± 0%   -1.01%  (p=0.000 n=19+20)
ProbablyPrime/n=20-8                 127kB ± 0%     126kB ± 0%   -0.88%  (p=0.000 n=20+20)
ProbablyPrime/Lucas-8               3.07kB ± 0%    2.79kB ± 0%   -9.12%  (p=0.000 n=20+20)
ProbablyPrime/MillerRabinBase2-8    12.1kB ± 0%    12.0kB ± 0%   -0.66%  (p=0.000 n=20+20)
FloatSqrt/64-8                        416B ± 0%      360B ± 0%  -13.46%  (p=0.000 n=20+20)
FloatSqrt/128-8                       640B ± 0%      584B ± 0%   -8.75%  (p=0.000 n=20+20)
FloatSqrt/256-8                       512B ± 0%      472B ± 0%   -7.81%  (p=0.000 n=20+20)
FloatSqrt/1000-8                    1.47kB ± 0%    1.43kB ± 0%   -2.72%  (p=0.000 n=20+20)
FloatSqrt/10000-8                   18.2kB ± 0%    18.1kB ± 0%   -0.22%  (p=0.000 n=20+20)
FloatSqrt/100000-8                   204kB ± 0%     204kB ± 0%   -0.02%  (p=0.000 n=20+20)
FloatSqrt/1000000-8                 6.37MB ± 0%    6.37MB ± 0%   -0.00%  (p=0.000 n=19+20)
[Geo mean]                          3.42kB         3.24kB        -5.33%

name                              old allocs/op  new allocs/op  delta
DecimalConversion-8                  1.65k ± 0%     1.65k ± 0%     ~     (all equal)
FloatString/100-8                     8.00 ± 0%      8.00 ± 0%     ~     (all equal)
FloatString/1000-8                    9.00 ± 0%      9.00 ± 0%     ~     (all equal)
FloatString/10000-8                   22.0 ± 0%      22.0 ± 0%     ~     (all equal)
FloatString/100000-8                   136 ± 0%       136 ± 0%     ~     (all equal)
FloatAdd/10-8                         0.00           0.00          ~     (all equal)
FloatAdd/100-8                        0.00           0.00          ~     (all equal)
FloatAdd/1000-8                       0.00           0.00          ~     (all equal)
FloatAdd/10000-8                      0.00           0.00          ~     (all equal)
FloatAdd/100000-8                     0.00           0.00          ~     (all equal)
FloatSub/10-8                         0.00           0.00          ~     (all equal)
FloatSub/100-8                        0.00           0.00          ~     (all equal)
FloatSub/1000-8                       0.00           0.00          ~     (all equal)
FloatSub/10000-8                      0.00           0.00          ~     (all equal)
FloatSub/100000-8                     0.00           0.00          ~     (all equal)
ParseFloatSmallExp-8                   110 ± 0%       130 ± 0%  +18.18%  (p=0.000 n=20+20)
ParseFloatLargeExp-8                   319 ± 0%       371 ± 0%  +16.30%  (p=0.000 n=20+20)
GCD10x10/WithoutXY-8                  2.00 ± 0%      2.00 ± 0%     ~     (all equal)
GCD10x10/WithXY-8                     5.00 ± 0%      6.00 ± 0%  +20.00%  (p=0.000 n=20+20)
GCD10x100/WithoutXY-8                 4.00 ± 0%      4.00 ± 0%     ~     (all equal)
GCD10x100/WithXY-8                    9.00 ± 0%     12.00 ± 0%  +33.33%  (p=0.000 n=20+20)
GCD10x1000/WithoutXY-8                4.00 ± 0%      4.00 ± 0%     ~     (all equal)
GCD10x1000/WithXY-8                   11.0 ± 0%      12.0 ± 0%   +9.09%  (p=0.000 n=20+20)
GCD10x10000/WithoutXY-8               4.00 ± 0%      4.00 ± 0%     ~     (all equal)
GCD10x10000/WithXY-8                  11.0 ± 0%      12.0 ± 0%   +9.09%  (p=0.000 n=20+20)
GCD10x100000/WithoutXY-8              4.00 ± 0%      4.00 ± 0%     ~     (all equal)
GCD10x100000/WithXY-8                 11.0 ± 0%      12.0 ± 0%   +9.09%  (p=0.000 n=20+20)
GCD100x100/WithoutXY-8                6.00 ± 0%     10.00 ± 0%  +66.67%  (p=0.000 n=20+20)
GCD100x100/WithXY-8                   9.00 ± 0%     15.00 ± 0%  +66.67%  (p=0.000 n=20+20)
GCD100x1000/WithoutXY-8               6.00 ± 0%      8.00 ± 0%  +33.33%  (p=0.000 n=20+20)
GCD100x1000/WithXY-8                  12.0 ± 0%      13.0 ± 0%   +8.33%  (p=0.000 n=20+20)
GCD100x10000/WithoutXY-8              6.00 ± 0%      8.00 ± 0%  +33.33%  (p=0.000 n=20+20)
GCD100x10000/WithXY-8                 12.0 ± 0%      13.0 ± 0%   +8.33%  (p=0.000 n=20+20)
GCD100x100000/WithoutXY-8             6.00 ± 0%      8.00 ± 0%  +33.33%  (p=0.000 n=20+20)
GCD100x100000/WithXY-8                12.0 ± 0%      13.0 ± 0%   +8.33%  (p=0.000 n=20+20)
GCD1000x1000/WithoutXY-8              10.0 ± 0%      10.0 ± 0%     ~     (all equal)
GCD1000x1000/WithXY-8                 19.0 ± 0%      20.0 ± 0%   +5.26%  (p=0.000 n=20+20)
GCD1000x10000/WithoutXY-8             8.00 ± 0%      8.00 ± 0%     ~     (all equal)
GCD1000x10000/WithXY-8                26.0 ± 0%      26.0 ± 0%     ~     (all equal)
GCD1000x100000/WithoutXY-8            8.00 ± 0%      8.00 ± 0%     ~     (all equal)
GCD1000x100000/WithXY-8               27.0 ± 0%      27.0 ± 0%     ~     (all equal)
GCD10000x10000/WithoutXY-8            10.0 ± 0%      10.0 ± 0%     ~     (all equal)
GCD10000x10000/WithXY-8               76.0 ± 0%      78.0 ± 0%   +2.63%  (p=0.000 n=20+20)
GCD10000x100000/WithoutXY-8           8.00 ± 0%      8.00 ± 0%     ~     (all equal)
GCD10000x100000/WithXY-8               174 ± 0%       174 ± 0%     ~     (all equal)
GCD100000x100000/WithoutXY-8          10.0 ± 0%      10.0 ± 0%     ~     (all equal)
GCD100000x100000/WithXY-8              645 ± 0%       647 ± 0%   +0.31%  (p=0.000 n=20+20)
Hilbert-8                            14.1k ± 0%     14.3k ± 0%   +0.92%  (p=0.000 n=20+20)
Binomial-8                            38.0 ± 0%      38.0 ± 0%     ~     (all equal)
QuoRem-8                              0.00           0.00          ~     (all equal)
Exp-8                                 21.0 ± 0%      21.0 ± 0%     ~     (all equal)
Exp2-8                                22.0 ± 0%      22.0 ± 0%     ~     (all equal)
Bitset-8                              0.00           0.00          ~     (all equal)
BitsetNeg-8                           0.00           0.00          ~     (all equal)
BitsetOrig-8                          1.00 ± 0%      1.00 ± 0%     ~     (all equal)
BitsetNegOrig-8                       2.00 ± 0%      2.00 ± 0%     ~     (all equal)
ModSqrt225_Tonelli-8                  85.0 ± 0%      86.0 ± 0%   +1.18%  (p=0.000 n=20+20)
ModSqrt225_3Mod4-8                    25.0 ± 0%      25.0 ± 0%     ~     (all equal)
ModSqrt231_Tonelli-8                  80.0 ± 0%      80.0 ± 0%     ~     (all equal)
ModSqrt231_5Mod8-8                    32.0 ± 0%      32.0 ± 0%     ~     (all equal)
ModInverse-8                          11.0 ± 0%      11.0 ± 0%     ~     (all equal)
Sqrt-8                                13.0 ± 0%      13.0 ± 0%     ~     (all equal)
IntSqr/1-8                            0.00           0.00          ~     (all equal)
IntSqr/2-8                            0.00           0.00          ~     (all equal)
IntSqr/3-8                            0.00           0.00          ~     (all equal)
IntSqr/5-8                            0.00           0.00          ~     (all equal)
IntSqr/8-8                            0.00           0.00          ~     (all equal)
IntSqr/10-8                           0.00           0.00          ~     (all equal)
IntSqr/20-8                           1.00 ± 0%      1.00 ± 0%     ~     (all equal)
IntSqr/30-8                           1.00 ± 0%      1.00 ± 0%     ~     (all equal)
IntSqr/50-8                           1.00 ± 0%      1.00 ± 0%     ~     (all equal)
IntSqr/80-8                           1.00 ± 0%      1.00 ± 0%     ~     (all equal)
IntSqr/100-8                          1.00 ± 0%      1.00 ± 0%     ~     (all equal)
IntSqr/200-8                          1.00 ± 0%      1.00 ± 0%     ~     (all equal)
IntSqr/300-8                          3.00 ± 0%      3.00 ± 0%     ~     (all equal)
IntSqr/500-8                          3.00 ± 0%      3.00 ± 0%     ~     (all equal)
IntSqr/800-8                          9.00 ± 0%      9.00 ± 0%     ~     (all equal)
IntSqr/1000-8                         9.00 ± 0%      9.00 ± 0%     ~     (all equal)
Div/20/10-8                           0.00           0.00          ~     (all equal)
Div/200/100-8                         0.00           0.00          ~     (all equal)
Div/2000/1000-8                       0.00           0.00          ~     (all equal)
Div/20000/10000-8                     0.00           0.00          ~     (all equal)
Div/200000/100000-8                   0.00           0.00          ~     (all equal)
Mul-8                                 2.00 ± 0%      2.00 ± 0%     ~     (all equal)
ZeroShifts/Shl-8                      1.00 ± 0%      1.00 ± 0%     ~     (all equal)
ZeroShifts/ShlSame-8                  0.00           0.00          ~     (all equal)
ZeroShifts/Shr-8                      1.00 ± 0%      1.00 ± 0%     ~     (all equal)
ZeroShifts/ShrSame-8                  0.00           0.00          ~     (all equal)
Exp3Power/0x10-8                      4.00 ± 0%      4.00 ± 0%     ~     (all equal)
Exp3Power/0x40-8                      4.00 ± 0%      4.00 ± 0%     ~     (all equal)
Exp3Power/0x100-8                     5.00 ± 0%      5.00 ± 0%     ~     (all equal)
Exp3Power/0x400-8                     7.00 ± 0%      7.00 ± 0%     ~     (all equal)
Exp3Power/0x1000-8                    11.0 ± 0%      11.0 ± 0%     ~     (all equal)
Exp3Power/0x4000-8                    15.0 ± 0%      15.0 ± 0%     ~     (all equal)
Exp3Power/0x10000-8                   29.0 ± 0%      29.0 ± 0%     ~     (all equal)
Exp3Power/0x40000-8                    140 ± 0%       140 ± 0%     ~     (all equal)
Exp3Power/0x100000-8                 1.12k ± 0%     1.12k ± 0%     ~     (all equal)
Exp3Power/0x400000-8                 9.88k ± 0%     9.88k ± 0%     ~     (p=0.747 n=17+19)
Fibo-8                                 739 ± 0%       743 ± 0%   +0.54%  (p=0.000 n=20+20)
NatSqr/1-8                            1.00 ± 0%      1.00 ± 0%     ~     (all equal)
NatSqr/2-8                            1.00 ± 0%      1.00 ± 0%     ~     (all equal)
NatSqr/3-8                            1.00 ± 0%      1.00 ± 0%     ~     (all equal)
NatSqr/5-8                            1.00 ± 0%      1.00 ± 0%     ~     (all equal)
NatSqr/8-8                            1.00 ± 0%      1.00 ± 0%     ~     (all equal)
NatSqr/10-8                           1.00 ± 0%      1.00 ± 0%     ~     (all equal)
NatSqr/20-8                           2.00 ± 0%      2.00 ± 0%     ~     (all equal)
NatSqr/30-8                           2.00 ± 0%      2.00 ± 0%     ~     (all equal)
NatSqr/50-8                           2.00 ± 0%      2.00 ± 0%     ~     (all equal)
NatSqr/80-8                           2.00 ± 0%      2.00 ± 0%     ~     (all equal)
NatSqr/100-8                          2.00 ± 0%      2.00 ± 0%     ~     (all equal)
NatSqr/200-8                          2.00 ± 0%      2.00 ± 0%     ~     (all equal)
NatSqr/300-8                          4.00 ± 0%      4.00 ± 0%     ~     (all equal)
NatSqr/500-8                          4.00 ± 0%      4.00 ± 0%     ~     (all equal)
NatSqr/800-8                          10.0 ± 0%      10.0 ± 0%     ~     (all equal)
NatSqr/1000-8                         10.0 ± 0%      10.0 ± 0%     ~     (all equal)
NatSetBytes/8-8                       0.00           0.00          ~     (all equal)
NatSetBytes/24-8                      1.00 ± 0%      1.00 ± 0%     ~     (all equal)
NatSetBytes/128-8                     1.00 ± 0%      1.00 ± 0%     ~     (all equal)
NatSetBytes/7-8                       0.00           0.00          ~     (all equal)
NatSetBytes/23-8                      1.00 ± 0%      1.00 ± 0%     ~     (all equal)
NatSetBytes/127-8                     1.00 ± 0%      1.00 ± 0%     ~     (all equal)
ScanPi-8                              60.0 ± 0%      61.0 ± 0%   +1.67%  (p=0.000 n=20+20)
StringPiParallel-8                    24.0 ± 0%      24.0 ± 0%     ~     (all equal)
Scan/10/Base2-8                       1.00 ± 0%      1.00 ± 0%     ~     (all equal)
Scan/100/Base2-8                      1.00 ± 0%      1.00 ± 0%     ~     (all equal)
Scan/1000/Base2-8                     1.00 ± 0%      1.00 ± 0%     ~     (all equal)
Scan/10000/Base2-8                    1.00 ± 0%      1.00 ± 0%     ~     (all equal)
Scan/100000/Base2-8                   1.00 ± 0%      1.00 ± 0%     ~     (all equal)
Scan/10/Base8-8                       1.00 ± 0%      1.00 ± 0%     ~     (all equal)
Scan/100/Base8-8                      1.00 ± 0%      1.00 ± 0%     ~     (all equal)
Scan/1000/Base8-8                     1.00 ± 0%      1.00 ± 0%     ~     (all equal)
Scan/10000/Base8-8                    1.00 ± 0%      1.00 ± 0%     ~     (all equal)
Scan/100000/Base8-8                   1.00 ± 0%      1.00 ± 0%     ~     (all equal)
Scan/10/Base10-8                      1.00 ± 0%      1.00 ± 0%     ~     (all equal)
Scan/100/Base10-8                     1.00 ± 0%      1.00 ± 0%     ~     (all equal)
Scan/1000/Base10-8                    1.00 ± 0%      1.00 ± 0%     ~     (all equal)
Scan/10000/Base10-8                   1.00 ± 0%      1.00 ± 0%     ~     (all equal)
Scan/100000/Base10-8                  1.00 ± 0%      1.00 ± 0%     ~     (all equal)
Scan/10/Base16-8                      1.00 ± 0%      1.00 ± 0%     ~     (all equal)
Scan/100/Base16-8                     1.00 ± 0%      1.00 ± 0%     ~     (all equal)
Scan/1000/Base16-8                    1.00 ± 0%      1.00 ± 0%     ~     (all equal)
Scan/10000/Base16-8                   1.00 ± 0%      1.00 ± 0%     ~     (all equal)
Scan/100000/Base16-8                  1.00 ± 0%      1.00 ± 0%     ~     (all equal)
String/10/Base2-8                     1.00 ± 0%      1.00 ± 0%     ~     (all equal)
String/100/Base2-8                    1.00 ± 0%      1.00 ± 0%     ~     (all equal)
String/1000/Base2-8                   1.00 ± 0%      1.00 ± 0%     ~     (all equal)
String/10000/Base2-8                  1.00 ± 0%      1.00 ± 0%     ~     (all equal)
String/100000/Base2-8                 1.00 ± 0%      1.00 ± 0%     ~     (all equal)
String/10/Base8-8                     1.00 ± 0%      1.00 ± 0%     ~     (all equal)
String/100/Base8-8                    1.00 ± 0%      1.00 ± 0%     ~     (all equal)
String/1000/Base8-8                   1.00 ± 0%      1.00 ± 0%     ~     (all equal)
String/10000/Base8-8                  1.00 ± 0%      1.00 ± 0%     ~     (all equal)
String/100000/Base8-8                 1.00 ± 0%      1.00 ± 0%     ~     (all equal)
String/10/Base10-8                    2.00 ± 0%      2.00 ± 0%     ~     (all equal)
String/100/Base10-8                   2.00 ± 0%      2.00 ± 0%     ~     (all equal)
String/1000/Base10-8                  3.00 ± 0%      3.00 ± 0%     ~     (all equal)
String/10000/Base10-8                 3.00 ± 0%      3.00 ± 0%     ~     (all equal)
String/100000/Base10-8                3.00 ± 0%      3.00 ± 0%     ~     (all equal)
String/10/Base16-8                    1.00 ± 0%      1.00 ± 0%     ~     (all equal)
String/100/Base16-8                   1.00 ± 0%      1.00 ± 0%     ~     (all equal)
String/1000/Base16-8                  1.00 ± 0%      1.00 ± 0%     ~     (all equal)
String/10000/Base16-8                 1.00 ± 0%      1.00 ± 0%     ~     (all equal)
String/100000/Base16-8                1.00 ± 0%      1.00 ± 0%     ~     (all equal)
LeafSize/0-8                          10.0 ± 0%      10.0 ± 0%     ~     (all equal)
LeafSize/1-8                          13.0 ± 0%      13.0 ± 0%     ~     (all equal)
LeafSize/2-8                          13.0 ± 0%      13.0 ± 0%     ~     (all equal)
LeafSize/3-8                          13.0 ± 0%      13.0 ± 0%     ~     (all equal)
LeafSize/4-8                          13.0 ± 0%      13.0 ± 0%     ~     (all equal)
LeafSize/5-8                          13.0 ± 0%      13.0 ± 0%     ~     (all equal)
LeafSize/6-8                          12.0 ± 0%      12.0 ± 0%     ~     (all equal)
LeafSize/7-8                          12.0 ± 0%      12.0 ± 0%     ~     (all equal)
LeafSize/8-8                          12.0 ± 0%      12.0 ± 0%     ~     (all equal)
LeafSize/9-8                          12.0 ± 0%      12.0 ± 0%     ~     (all equal)
LeafSize/10-8                         12.0 ± 0%      12.0 ± 0%     ~     (all equal)
LeafSize/11-8                         12.0 ± 0%      12.0 ± 0%     ~     (all equal)
LeafSize/12-8                         12.0 ± 0%      12.0 ± 0%     ~     (all equal)
LeafSize/13-8                         12.0 ± 0%      12.0 ± 0%     ~     (all equal)
LeafSize/14-8                         12.0 ± 0%      12.0 ± 0%     ~     (all equal)
LeafSize/15-8                         12.0 ± 0%      12.0 ± 0%     ~     (all equal)
LeafSize/16-8                         12.0 ± 0%      12.0 ± 0%     ~     (all equal)
LeafSize/32-8                         12.0 ± 0%      12.0 ± 0%     ~     (all equal)
LeafSize/64-8                         11.0 ± 0%      11.0 ± 0%     ~     (all equal)
ProbablyPrime/n=0-8                   52.0 ± 0%      52.0 ± 0%     ~     (all equal)
ProbablyPrime/n=1-8                   73.0 ± 0%      73.0 ± 0%     ~     (all equal)
ProbablyPrime/n=5-8                    157 ± 0%       157 ± 0%     ~     (all equal)
ProbablyPrime/n=10-8                   262 ± 0%       262 ± 0%     ~     (all equal)
ProbablyPrime/n=20-8                   472 ± 0%       472 ± 0%     ~     (all equal)
ProbablyPrime/Lucas-8                 22.0 ± 0%      22.0 ± 0%     ~     (all equal)
ProbablyPrime/MillerRabinBase2-8      29.0 ± 0%      29.0 ± 0%     ~     (all equal)
FloatSqrt/64-8                        9.00 ± 0%     10.00 ± 0%  +11.11%  (p=0.000 n=20+20)
FloatSqrt/128-8                       12.0 ± 0%      13.0 ± 0%   +8.33%  (p=0.000 n=20+20)
FloatSqrt/256-8                       8.00 ± 0%      8.00 ± 0%     ~     (all equal)
FloatSqrt/1000-8                      9.00 ± 0%      9.00 ± 0%     ~     (all equal)
FloatSqrt/10000-8                     14.0 ± 0%      14.0 ± 0%     ~     (all equal)
FloatSqrt/100000-8                    33.0 ± 0%      33.0 ± 0%     ~     (all equal)
FloatSqrt/1000000-8                  1.16k ± 0%     1.16k ± 0%     ~     (all equal)
[Geo mean]                            6.62           6.76        +2.09%

Change-Id: Id9df4157cac1e07721e35cff7fcdefe60703873a
Reviewed-on: https://go-review.googlesource.com/c/150999
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
Reviewed-by: Alan Donovan <adonovan@google.com>
Reviewed-by: Robert Griesemer <gri@golang.org>

doc: update go1.12.html using latest output from relnote tool

Change-Id: I6b20c3fd7f15f35d2288d9a0fd6512c541a62c92
Reviewed-on: https://go-review.googlesource.com/c/151558
Reviewed-by: Bryan C. Mills <bcmills@google.com>

cmd/compile: randomize value order in block for testing

A little bit of compiler stress testing. Randomize the order
of the values in a block before every phase. This randomization
makes sure that we're not implicitly depending on that order.

Currently the random seed is a hash of the function name.
It provides determinism, but sacrifices some coverage.
Other arrangements are possible (env var, ...) but require
more setup.

Fixes #20178

Change-Id: Idae792a23264bd9a3507db6ba49b6d591a608e83
Reviewed-on: https://go-review.googlesource.com/c/33909
Reviewed-by: Cherry Zhang <cherryyz@google.com>

cmd/compile: order nil checks by source position

There's nothing enforcing ordering between redundant nil checks when
they may occur during the same memory state. Commit to using the
earliest one in source order.

Otherwise the choice of which to remove depends on the ordering of
values in a block (before scheduling). That's unfortunate when trying
to ensure that the compiler doesn't depend on that ordering for
anything.

Update #20178

Change-Id: I2cdd5be10618accd9d91fa07406c90cbd023ffba
Reviewed-on: https://go-review.googlesource.com/c/151517
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: David Chase <drchase@google.com>
Reviewed-by: Cherry Zhang <cherryyz@google.com>

vendor: update x/net/internal/nettest for aix support

Update golang.org/x/net/internal/nettest to x/net git rev 9b4f9f5ad519
for:

   internal/nettest: add AIX operating system
   https://golang.org/cl/144077

This fixes the build failure of the vendored x/net/internal/nettest on
aix/ppc64.

Additionally this also pulls in:

  all: re-adjust build constraints for JS and NaCl
  https://golang.org/cl/122539

Updates #25893

Change-Id: I9abefc7d4ad158e9e68913362f7f1320321d6f5f
Reviewed-on: https://go-review.googlesource.com/c/151301
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>

doc: fix formatting for Darwin entry

Updates #23011

Change-Id: I38360501c772ddf7cc4bd1b5d7b0225387ead535
Reviewed-on: https://go-review.googlesource.com/c/151361
Reviewed-by: Tobias Klauser <tobias.klauser@gmail.com>

plugin: skip building tests on linux/arm64

It appears that linux/arm64

https://build.golang.org/log/6808dbded6aebadf68cb65a0e30e4d1a62cd687b

fails with

/workdir/go/pkg/tool/linux_arm64/link: running gcc failed: exit status 1
/usr/bin/ld.gold: internal error in global, at ../../gold/aarch64.cc:4973
collect2: error: ld returned 1 exit status
FAIL plugin [build failed]

error. So stop building these tests on linux/arm64.

Fixes linux/arm64 build

Change-Id: I41eb3d9659f7967d80136513899a5203bbf03fb1
Reviewed-on: https://go-review.googlesource.com/c/151478
Run-TryBot: Alex Brainman <alex.brainman@gmail.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>

lib/time: update tzdata to 2018g

Now that the tree has been frozen for some time, update the tzdata
database to version 2018g (released 2018-10-26) for Go 1.12.

Updates #22487

Change-Id: I9e82bcdaef28d308643c08c9fd3472e4c14a196e
Reviewed-on: https://go-review.googlesource.com/c/151299
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>

unicode: improve generated comments for categories

The comments on the category range tables in the unicode package are fairly
redundent and require an external source to translate into human readable
category names.

This adds a look up table with the category descriptions and uses it if
available when generating the comments for the range tables.

Fixes #28954

Change-Id: I853e2d270def6492c2c1dd2ad0ec761a74c04e5d
Reviewed-on: https://go-review.googlesource.com/c/151297
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org>

doc: preannounce dropping macOS 10.10 support

Updates #23011

Change-Id: I0eccea5d08a8758585f183540787b78fb80aa36a
Reviewed-on: https://go-review.googlesource.com/c/151360
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>

net: use .invalid for an invalid domain name

Fixes #25370

Change-Id: I12da0cc17f433ca12c85fb986d65ac9ecb2c3f20
Reviewed-on: https://go-review.googlesource.com/c/151359
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>

cmd: fix symbols addressing for aix/ppc64

This commit changes the code generated for addressing symbols on AIX
operating system.

On AIX, every symbol accesses must be done via another symbol near the TOC,
named TOC anchor or TOC entry. This TOC anchor is a pointer to the symbol
address.
During Progedit function, when a symbol access is detected, its instructions
are modified to create a load on its TOC anchor and retrieve the symbol.

Change-Id: I00cf8f49c13004bc99fa8af13d549a709320f797
Reviewed-on: https://go-review.googlesource.com/c/151039
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>

cmd/link: improve XCOFF dynamic symbols generation

This commit fixes and improves the generation of dynamic symbols for
XCOFF files.
This mainly adds for every dynamic symbols a new symbol named
s.Extname().

Change-Id: I5b788f076d9a05e5d42f08eb1a74fd3e3efa9a86
Reviewed-on: https://go-review.googlesource.com/c/151038
Run-TryBot: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>

go/printer: print parenthesized declarations if len(d.Specs) > 1

Parenthesized declaration must be printed if len(d.Specs) > 1 even if d.Lparen==token.NoPos. This happens if the node tree is created programmatically. Otherwise, all but the first specifications just silently disappear from the output.

Change-Id: I17ab24bb1cd56fe1e611199698535ca60a97f5ea
GitHub-Last-Rev: 2f168dc7ad4a29149685efc70f180987523271e4
GitHub-Pull-Request: golang/go#28533
Reviewed-on: https://go-review.googlesource.com/c/146657
Run-TryBot: Robert Griesemer <gri@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>

cmd/compile: don't use CMOV ops to compute load addresses

We want to issue loads as soon as possible, especially when they
are going to miss in the cache. Using a conditional move (CMOV) here:

i := ...
if cond {
   i++
}
... = a[i]

means that we have to wait for cond to be computed before the load
is issued. Without a CMOV, if the branch is predicted correctly the
load can be issued in parallel with computing cond.
Even if the branch is predicted incorrectly, maybe the speculative
load is close to the real load, and we get a prefetch for free.
In the worst case, when the prediction is wrong and the address is
way off, we only lose by the time difference between the CMOV
latency (~2 cycles) and the mispredict restart latency (~15 cycles).

We only squash CMOVs that affect load addresses. Results of CMOVs
that are used for other things (store addresses, store values) we
use as before.

Fixes #26306

Change-Id: I82ca14b664bf05e1d45e58de8c4d9c775a127ca1
Reviewed-on: https://go-review.googlesource.com/c/145717
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Josh Bleecher Snyder <josharian@gmail.com>

test: fix nilptr5 for AIX

This commit fixes a mistake made in CL 144538.
This nilcheck can be removed because OpPPC64LoweredMove will fault if
arg0 is nil, as it's used to store. Further information can be found in
cmd/compile/internal/ssa/nilcheck.go.

Change-Id: Ifec0080c00eb1f94a8c02f8bf60b93308e71b119
Reviewed-on: https://go-review.googlesource.com/c/151298
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>

cmd/link/internal/ld: omit deprecated linker argument for iOS builds

After CL 151139 introduced a plugin test, the macOS linker for iOS
outputs:

ld: warning: -flat_namespace is deprecated on iOS

Omit the -flat_namespace flag on iOS; plugins are not supported on
iOS, and unlikely to ever be.

Change-Id: I2d08f8b984efcfd442d572b4a0f3a2c95c551b9f
Reviewed-on: https://go-review.googlesource.com/c/151300
Run-TryBot: Elias Naur <elias.naur@gmail.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>

debug/pe: correct TestImportTableInUnknownSection error message

TestImportTableInUnknownSection uses kernel32.dll file, but the error
message mentions atmfd.dll. Adjust error message to match the test.

This change should have been part of CL 151137.

Updates #27904

Change-Id: Ifc31a12134b328472191122f8426ab6ed234fbd4
Reviewed-on: https://go-review.googlesource.com/c/151477
Run-TryBot: Alex Brainman <alex.brainman@gmail.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Tobias Klauser <tobias.klauser@gmail.com>

cmd/link: do not use _GLOBAL_OFFSET_TABLE_ on windows/386

When building windows/386 executable that imports "plugin" package,
cmd/link adds reference to DLL with blank name. Running

objdump -x a.exe

reports

...
The Import Tables (interpreted .idata section contents)
...
DLL Name:
vma:  Hint/Ord Member-Name Bound-To
25308a     0  _GLOBAL_OFFSET_TABLE_
...

So, obviously, executable cannot run, because Windows complains
that it cannot find DLL when trying to run it.

Stop using _GLOBAL_OFFSET_TABLE_ on windows/386.

Fixes #28789

Change-Id: Idd489eafd998f6e329f40c5d90a2a8965ab1d873
Reviewed-on: https://go-review.googlesource.com/c/151139
Run-TryBot: Alex Brainman <alex.brainman@gmail.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>

cmd/go/internal/imports: resolve symlinks in ScanDir

We were using the mode reported by ReadDir to decide whether each
entry is a file, but in the case of symlinks that isn't sufficient: a
symlink could point to either a file or a directory, and if it is a
file we should treat it as such.

Fixes #28107

Change-Id: Icf6e495dce427a7b1124c9cc9f085e40a215c169
Reviewed-on: https://go-review.googlesource.com/c/141097
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Russ Cox <rsc@golang.org>

math/bits: define Div to panic when y<=hi

Div panics when y<=hi because either the quotient overflows
the size of the output or division by zero occurs when y==0.
This provides a uniform behavior for all implementations.

Fixes #28316

Change-Id: If23aeb10e0709ee1a60b7d614afc9103d674a980
Reviewed-on: https://go-review.googlesource.com/c/149517
Reviewed-by: Robert Griesemer <gri@golang.org>

cmd/compile: intrinsify math/bits.Div on amd64

Note that the intrinsic implementation panics separately for overflow and
divide by zero, which matches the behavior of the pure go implementation.
There is a modest performance improvement after intrinsic implementation.

name     old time/op  new time/op  delta
Div-4    53.0ns ± 1%  47.0ns ± 0%  -11.28%  (p=0.008 n=5+5)
Div32-4  18.4ns ± 0%  18.5ns ± 1%     ~     (p=0.444 n=5+5)
Div64-4  53.3ns ± 0%  47.5ns ± 4%  -10.77%  (p=0.008 n=5+5)

Updates #28273

Change-Id: Ic1688ecc0964acace2e91bf44ef16f5fb6b6bc82
Reviewed-on: https://go-review.googlesource.com/c/144378
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>

math/bits: panic when y<=hi in Div

Explicitly check for divide-by-zero/overflow and panic with the appropriate
runtime error.  The additional checks have basically no effect on performance
since the branch is easily predicted.

name     old time/op  new time/op  delta
Div-4    53.9ns ± 1%  53.0ns ± 1%  -1.59%  (p=0.016 n=4+5)
Div32-4  17.9ns ± 0%  18.4ns ± 0%  +2.56%  (p=0.008 n=5+5)
Div64-4  53.5ns ± 0%  53.3ns ± 0%    ~     (p=0.095 n=5+5)

Updates #28316

Change-Id: I36297ee9946cbbc57fefb44d1730283b049ecf57
Reviewed-on: https://go-review.googlesource.com/c/144377
Run-TryBot: Keith Randall <khr@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>

cmd/compile: don't convert non-Go-constants to OLITERALs

Don't convert values that aren't Go constants, like
uintptr(unsafe.Pointer(nil)), to a literal constant. This avoids
assuming they are constants for things like indexing, array sizes,
case duplication, etc.

Also, nil is an allowed duplicate in switches. CTNILs aren't Go constants.

Fixes #28078
Fixes #28079

Change-Id: I9ab8af47098651ea09ef10481787eae2ae2fb445
Reviewed-on: https://go-review.googlesource.com/c/151320
Run-TryBot: Keith Randall <khr@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>

cmd/link: fix XCOFF sections

XCOFF files can't have multiples text or data sections. The name
of each type section must be .text, .data and .bss.

This commit also updates cmd/internal/objfile/xcoff.go to retrieve Go
sections using runtime symbols.

Change-Id: Ib6315f19dad2d154a4531fc6508e7cbd8bc94743
Reviewed-on: https://go-review.googlesource.com/c/151037
Run-TryBot: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>

runtime: improve godoc formatting of memclrNoHeapPointers comment

Fixes #28955

Change-Id: I738ad0c76f7bf8fc504a48cf55d3becd5ed7a9d6
Reviewed-on: https://go-review.googlesource.com/c/151337
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>

cmd/link/internal/ld: remove R_ADDR relocations inside XCOFF text sections

On XCOFF, it is forbidden relocation of a DATA pointer to a text
section. It happens when a RODATA symbol needs a DATA symbol's address.
This commit moves every RODATA symbols with a R_ADDR on a data symbol to
.data sections to avoid these relocations.

Change-Id: I7f34d8e0ebdc8352a74e6b40e4c893d8d9419f4d
Reviewed-on: https://go-review.googlesource.com/c/146977
Reviewed-by: Ian Lance Taylor <iant@golang.org>

cmd/compile: initialize sparse slice literals dynamically

When a slice composite literal is sparse, initialize it dynamically
instead of statically.

s := []int{5:5, 20:20}

To initialize the backing store for s, use 2 constant writes instead
of copying from a static array with 21 entries.

This CL also fixes pathologies in the compiler when the slice is
*very* sparse.

Fixes #23780

Change-Id: Iae95c6e6f6a0e2994675cbc750d7a4dd6436b13b
Reviewed-on: https://go-review.googlesource.com/c/151319
Run-TryBot: Keith Randall <khr@golang.org>
Reviewed-by: Robert Griesemer <gri@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>

cmd/compile: don't constant-fold non-Go constants in the frontend

Abort evconst if its argument isn't a Go constant. The SSA backend
will do the optimizations in question later. They tend to be weird
cases, like uintptr(unsafe.Pointer(uintptr(1))).

Fix OADDSTR and OCOMPLEX cases in isGoConst.
OADDSTR has its arguments in n.List, not n.Left and n.Right.
OCOMPLEX might have a 2-result function as its arg in List[0]
(in which case it isn't a Go constant).

Fixes #24760

Change-Id: Iab312d994240d99b3f69bfb33a443607e872b01d
Reviewed-on: https://go-review.googlesource.com/c/151338
Run-TryBot: Keith Randall <khr@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>

cmd/compile: remove CLOBBERDEAD experiment

This experiment is less effective and less needed since the
introduction of stack objects.

We can't clobber stack objects because we don't know statically
whether they are live or not.

We don't really need this experiment that much any more, as it was
primarily used to test the complicated ambiguously-live logic in the
liveness analysis, which has been removed in favor of stack objects.

It is also ~infeasible to maintain once we have safepoints everywhere.

Fixes #27326

Change-Id: I3bdde480b93dd508d048703055d4586b496176af
Reviewed-on: https://go-review.googlesource.com/c/151317
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>

go/internal/gccgoimporter: enhance for new export data, fix test issues

This patch merges in support for reading indexed type export data,
from the gofrontend CL https://golang.org/cl/143022 (which includes
a change in the export data version number from V2 to V3).

Also fixes the key tests to insure that they run both in gccgo builds
and main Go repo builds if "gccgo" is present (prior to this the tests
were not running in either scenario); this required fixing up some of
the expected results.

Fixes #28961.

Change-Id: I644d171f2a46be9160f89dada06ab3c20468bab7
Reviewed-on: https://go-review.googlesource.com/c/149957
Run-TryBot: Than McIntosh <thanm@google.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>

cmd/compile: allow bodyless function if it is linkname'd

In assembly free packages (aka "complete" or "pure go"), allow
bodyless functions if they are linkname'd to something else.

Presumably the thing the function is linkname'd to has a definition.
If not, the linker will complain. And linkname is unsafe, so we expect
users to know what they are doing.

Note this handles only one direction, where the linkname directive
is in the local package. If the linkname directive is in the remote
package, this CL won't help. (See os/signal/sig.s for an example.)

Fixes #23311

Change-Id: I824361b4b582ee05976d94812e5b0e8b0f7a18a6
Reviewed-on: https://go-review.googlesource.com/c/151318
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>

runtime: windows/arm fix tracebacks printed from sigpanic

The exception handler modifies the stack and continuation context so
it looks like the faulting code calls sigpanic() directly. The call was
not set up correctly on ARM, because it did not handle the link register
correctly. This change handles the link register correctly for ARM.

Updates #28854

Change-Id: I7ccf838adfc05cd968a5edd7d19ebba6a2478360
Reviewed-on: https://go-review.googlesource.com/c/150957
Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org>
Reviewed-by: Austin Clements <austin@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>

cmd/compile: fix nilcheck for AIX

This commit adapts compile tool to create correct nilchecks for AIX.

AIX allows to load a nil pointer. Therefore, the default nilcheck
which issues a load must be replaced by a CMP instruction followed by a
store at 0x0 if the value is nil. The store will trigger a SIGSEGV as on
others OS.

The nilcheck algorithm must be adapted to do not remove nilcheck if it's
only a read. Stores are detected with v.Type.IsMemory().

Tests related to nilptr must be adapted to the previous changements.
nilptr.go cannot be used as it's because the AIX address space starts at
1<<32.

Change-Id: I9f5aaf0b7e185d736a9b119c0ed2fe4e5bd1e7af
Reviewed-on: https://go-review.googlesource.com/c/144538
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>

runtime: handle 64bits addresses for AIX

This commit allows the runtime to handle 64bits addresses returned by
mmap syscall on AIX.

Mmap syscall returns addresses on 59bits on AIX. But the Arena
implementation only allows addresses with less than 48 bits.
This commit increases the arena size up to 1<<60 for aix/ppc64.

Update: #25893

Change-Id: Iea72e8a944d10d4f00be915785e33ae82dd6329e
Reviewed-on: https://go-review.googlesource.com/c/138736
Reviewed-by: Austin Clements <austin@google.com>

fmt: update formatting example for maps

Now that maps are printed in deterministic order, the map example
can have multiple keys without breaking the build.

Change-Id: Iccec0cd76a3d41c75d8d4eb768ec0ac09ad9f2ad
Reviewed-on: https://go-review.googlesource.com/c/151218
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org>

doc: improve the interface example in Effective Go

The String method is n-squared and overwrites its receiver.
Fix both issues, with only a slight loss of clarity.

Fixes #28773

Change-Id: I588f69d4cbd72931b28b984671512834473bd466
Reviewed-on: https://go-review.googlesource.com/c/151217
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>

debug/pe: use kernel32.dll in TestImportTableInUnknownSection

TestImportTableInUnknownSection was introduced in CL 110555 to
test PE executable with import table located in section other than
".idata". We used atmfd.dll for that purpose, but it seems
atmfd.dll is not present on some systems.

Use kernel32.dll instead. kernel32.dll import table is located in
".rdata" section, so it should do the job. And every Windows
system has kernel32.dll file.

Also make TestImportTableInUnknownSection run on windows-arm,
since windows-arm should also have kernel32.dll file.

Updates #27904

Change-Id: Ie005ee10e46ae0c06e83929d581e89f86c051eea
Reviewed-on: https://go-review.googlesource.com/c/151137
Run-TryBot: Alex Brainman <alex.brainman@gmail.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>

cmd/compile: decompose composite OpArg before decomposeUser

This makes it easier to track names of function arguments
for debugging purposes.

Change-Id: Ic34856fe0b910005e1c7bc051d769d489a4b158e
Reviewed-on: https://go-review.googlesource.com/c/150098
Run-TryBot: David Chase <drchase@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>

cmd/compile: make ssa blocks collapsable in ssa.html

This CL adds a button that collapses values list of a block.
Button is displayed for every block with non-empty values.

Change-Id: I4b65af81e25349f38341df487d42698c9d006a00
Reviewed-on: https://go-review.googlesource.com/c/144557
Run-TryBot: Yury Smolsky <yury@smolsky.by>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>

cmd/go: more cross-package references from internal/syscall/unix

On some platforms, assembly in internal/syscall/unix references
unexported runtime symbols. Catch these references so the compiler can
generate the necessary ABI wrappers.

Fixes #28769.
Updates #27539.

Change-Id: I118eebfb8b3d907b4c3562198e6afb49854f5827
Reviewed-on: https://go-review.googlesource.com/c/149817
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Tobias Klauser <tobias.klauser@gmail.com>
Reviewed-by: Clément Chigot <clement.chigot@atos.net>
Reviewed-by: Keith Randall <khr@golang.org>

cmd/compile: use correct store types in softfloat

When using softfloat, floating point ops are rewritten to integer
ops. The types of store ops were not rewritten. This may lower
to floating point stores, which are problematic. This CL fixes
this by rewriting the store types as well.

This fixes test/fixedbugs/issue28688.go on Wasm. Softfloat mode
is not used by default on Wasm, and it is not needed as Wasm spec
supports floating points. But it is nice to have the correct
types.

Change-Id: Ib5e19e19fa9491b15c2f60320f8724cace5cefb5
Reviewed-on: https://go-review.googlesource.com/c/149965
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>

os: return an error from UserHomeDir to match UserCacheDir

UserHomeDir used to return an empty string if the corresponding
environment variable was not set. Changed it to return an error if the
variable is not set, to have the same signature and behaviour as UserCacheDir.

Fixes #28562

Change-Id: I42c497e8011ecfbbadebe7de1751575273be221c
Reviewed-on: https://go-review.googlesource.com/c/150418
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>

cmd/trace: revert internal/traceparser

The performance improvement is not as big as we hoped.
Until the API is feature complete, we postpone the release
and avoid added complexity.

This change was prepared by reverting all the changes affected
src/cmd/trace and src/internal/traceparser packages after
golang.org/cl/137635, and then bringing back MMU computation
APIs (originally in src/internal/traceparser) to the
src/internal/trace package.

Revert "cmd/trace: use new traceparser to parse the raw trace files"
This reverts https://golang.org/cl/145457
  (commit 08816cb8d7ed16b9c804587ff02c1ad1c3af6cd5).

Revert "internal/traceparser: provide parser that uses less space and parses segments of runtime trace files"
This reverts https://golang.org/cl/137635
  (commit daaf361f74c3665bcb364356c5a9dd9f536c78c3).

Change-Id: Ic2a068a7dbaf4053cd9674ca7bde9c58e74385b4
Reviewed-on: https://go-review.googlesource.com/c/150517
Run-TryBot: Hyang-Ah Hana Kim <hyangah@gmail.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Austin Clements <austin@google.com>

os: prevent RemoveAll to remove "." on Plan 9

CL 150497 enabled TestRemoveAllDot on "noat" systems.

However, this test is failing on Plan 9 because the rmdir
system call allows to remove "." on Plan 9.

This change prevents the "noat" implementation of RemoveAll to
remove ".", so it remains consistent with the "at" implementation.

Fixes #28903.

Change-Id: Ifc8fe36bdd8053a4e416f0590663c844c97ce72a
Reviewed-on: https://go-review.googlesource.com/c/150621
Run-TryBot: David du Colombier <0intro@gmail.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>

cmd/compile: for non-SSA-typed params, emit simple vars.

This case was missed entirely and caused such params to be
unprintable.  This change gives them stack addresses
for the entire function (which is correct).

Change-Id: Ia4f706450219e48bce65b6395d3d9792df142fb5
Reviewed-on: https://go-review.googlesource.com/c/150657
Run-TryBot: David Chase <drchase@google.com>
Reviewed-by: Heschi Kreinick <heschi@google.com>

cmd/compile: fix TestFormats by using valid formats

CL 142517 has used some formats incorrectly. This change fixes it
by using %v for errors and invoking Block.Kind.String().
Format map stays intact.

Updates #28177

Change-Id: If53b6cc54ba3c1ffc17b005225787e3b546de404
Reviewed-on: https://go-review.googlesource.com/c/150798
Run-TryBot: Yury Smolsky <yury@smolsky.by>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: David Chase <drchase@google.com>

runtime: debug code to catch bad gcWork.puts

This adds a debug check to throw immediately if any pointers are added
to the gcWork buffer after the mark completion barrier. The intent is
to catch the source of the cached GC work that occasionally produces
"P has cached GC work at end of mark termination" failures.

The result should be that we get "throwOnGCWork" throws instead of "P
has cached GC work at end of mark termination" throws, but with useful
stack traces.

This should be reverted before the release. I've been unable to
reproduce this issue locally, but this issue appears fairly regularly
on the builders, so the intent is to catch it on the builders.

This probably slows down the GC slightly.

For #27993.

Change-Id: I5035e14058ad313bfbd3d68c41ec05179147a85c
Reviewed-on: https://go-review.googlesource.com/c/149969
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>

runtime: improve "P has cached GC work" debug info

For #27993.

Change-Id: I20127e8a9844c2c488f38e1ab1f8f5a27a5df03e
Reviewed-on: https://go-review.googlesource.com/c/149968
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>

net/http: fix spelling mistake in a comment

Fixes #28904

Change-Id: I8d416c47479a266735a39c926fd2f0f2bb25d57b
GitHub-Last-Rev: 3a7865a5be27937833cf4f65c242c639e51665c4
GitHub-Pull-Request: golang/go#28907
Reviewed-on: https://go-review.googlesource.com/c/150737
Reviewed-by: Daniel Martí <mvdan@mvdan.cc>
Run-TryBot: Daniel Martí <mvdan@mvdan.cc>
TryBot-Result: Gobot Gobot <gobot@golang.org>

cmd/compile: add control flow graphs to ssa.html

This CL adds CFGs to ssa.html.
It execs dot to generate SVG,
which then gets inlined into the html.
Some standard naming and javascript hacks
enable integration with the rest of ssa.html.
Clicking on blocks highlights the relevant
part of the CFG, and vice versa.

Sample output and screenshots can be seen in #28177.

CFGs can be turned on with the suffix mask:
:*            - dump CFG for every phase
:lower        - just the lower phase
:lower-layout - lower through layout
:w,x-y        - phases w and x through y

Calling dot after every pass is noticeably slow,
instead use the range of phases.

Dead blocks are not displayed on CFG.

User can zoom and pan individual CFG
when the automatic adjustment has failed.

Dot-related errors are reported
without bringing down the process.

Fixes #28177

Change-Id: Id52c42d86c4559ca737288aa10561b67a119c63d
Reviewed-on: https://go-review.googlesource.com/c/142517
Run-TryBot: Yury Smolsky <yury@smolsky.by>
Reviewed-by: David Chase <drchase@google.com>

runtime: add arg maps for sync/atomic functions in ARM64 race mode

In race mode, these functions are defined and declared in
different packages, which therefore don't have implicit arg maps.
When they are defer'd, and the stack needs to move, the runtime
fails with missing stack maps. This CL adds arg maps (FUNCDATA)
to them.

Updates #28848

Change-Id: I0271563b7e78e7797ce2990c303dced957efaa86
Reviewed-on: https://go-review.googlesource.com/c/150457
Run-TryBot: Cherry Zhang <cherryyz@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>

misc/wasm: add stub for fs.read on browsers

Using fmt.Scanln in a browser environment caused a panic, since there
was no stub for fs.read. This commit adds a stub that returns ENOSYS.

Fixes #27773.

Change-Id: I79b019039e4bc90da51d71a4edddf3bd7809ff45
Reviewed-on: https://go-review.googlesource.com/c/150617
Run-TryBot: Richard Musiol <neelance@gmail.com>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>

go/doc: disable playground for examples that use syscall/js

The playground is not using GOOS=js, so it is not able to use the
package syscall/js. Examples that depend on syscall/js should not
show a "Run" button.

Fixes #28526.

Change-Id: I8b2fcdd0c0ee517a5c3864bf459f813129542389
Reviewed-on: https://go-review.googlesource.com/c/148918
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>

os: return PathError on RemoveAll with trailing dots

Return a PathError instead of an unwrapped syscall.EINVAL if the path
ends with dots.

As suggested by Roger Peppe in CL 150158.

Change-Id: I4d82a6ff64a979b67a843a1cc4fea58ed9326aed
Reviewed-on: https://go-review.googlesource.com/c/150160
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>

os: permit RemoveAll with paths that end in ".."

Prohibiting RemoveAll with paths that end in ".." was added with
CL 137442 in this release cycle, but it worked before and it should
continue to work.

Also run TestRemoveAllDot on all systems; the test is not specific to
the use of unlinkat and friends.

Change-Id: I277784c8915cd748fec318d2936062440d5d1fde
Reviewed-on: https://go-review.googlesource.com/c/150497
Reviewed-by: Tobias Klauser <tobias.klauser@gmail.com>

mime: remove allocation introduced in recent fix

CL 150417 was submitted before I could recommend this change to remove
an unnecessary allocation.

Updates #28849

Change-Id: I4cd655f62bb3d00eda6c997f074785385bceee0c
Reviewed-on: https://go-review.googlesource.com/c/150498
Reviewed-by: Ian Lance Taylor <iant@golang.org>
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>

syscall: add dummy SIGTERM constant to js/wasm

The js/wasm architecture does not support signals at all, but there are
already some signal constants defined because of stdlib dependencies.
This change adds a dummy constant for syscall.SIGTERM as well, to make
js/wasm compatible with more existing Go code.

There is the Go proverb "Syscall must always be guarded with build
tags.", so code should not expect syscall.SIGTERM to exist. Still,
adding SIGTERM should do more good than harm.

Fixes #28719.

Change-Id: I3554b484f96a21427491c04eb1dd57e7af5bd62f
Reviewed-on: https://go-review.googlesource.com/c/150477
Run-TryBot: Richard Musiol <neelance@gmail.com>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>

misc/wasm: use temporary directory provided by Node.js

os.TempDir() did not return a proper directory on Windows with js/wasm,
because js/wasm only uses the Unix variant of TempDir.

This commit passes the temporary directory provided by Node.js to the
Go runtime by adding it as a default value for the TMPDIR environment
variable. It makes TempDir compatible with all platforms.

Fixes #27306.

Change-Id: I8b17e44cfb2ca41939ab2a4f918698fe330cb8bc
Reviewed-on: https://go-review.googlesource.com/c/150437
Run-TryBot: Richard Musiol <neelance@gmail.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>

cmd/link, runtime: add initial cgo support for ppc64

We should be able to build docker after this get applied.

Updates #13192

Change-Id: I5378d3518fac52d6bd4c97828884c1b382b7ace5
GitHub-Last-Rev: 210b7bc2e172f641f1102982e04542bf73a1aa46
GitHub-Pull-Request: golang/go#28546
Reviewed-on: https://go-review.googlesource.com/c/146898
Reviewed-by: Jiang Ma <ma.jiang@zte.com.cn>
Reviewed-by: Clément Chigot <clement.chigot@atos.net>
Reviewed-by: Lynn Boger <laboger@linux.vnet.ibm.com>
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
Run-TryBot: Lynn Boger <laboger@linux.vnet.ibm.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>

mime: correctly detect non-ASCII characters in FormatMediaType

FormatMediaType used rune&0x80==0 to check if parameter values consisted
of valid ascii charaters. Comparing strings using their runes instead of
their bytes leads to some non-ascii strings to pass as valid.

E.g. the rune for 'Ą' is 0x104, 0x104 & 0x80 => 0. Its byte
representation is 0xc4 0x84, both of which result in non zero values
when masked with 0x80

Fixes #28849

Change-Id: Ib9fb4968bcbbec0197d81136f380d40a2a56c14b
Reviewed-on: https://go-review.googlesource.com/c/150417
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>

syscall/js: document ValueOf() panic

ValueOf() panics if x is not one of the expected types.

Change-Id: I1105e46bd09a5ab13c162b77c1c50cc45bce27a2
GitHub-Last-Rev: 34a88ce8206954d94f0a884ab7f6494116c54a2d
GitHub-Pull-Request: golang/go#28846
Reviewed-on: https://go-review.googlesource.com/c/150138
Reviewed-by: Richard Musiol <neelance@gmail.com>

regexp: use backquotes for all regular expression examples

This commit performs replace double quote to backquote,
so now all examples looks consistent.

Change-Id: I8cf760ce1bdeff9619a88e531161b9516385241b
GitHub-Last-Rev: e3e636cebbf41528b8a73f9a3fe5afa10876f964
GitHub-Pull-Request: golang/go#28879
Reviewed-on: https://go-review.googlesource.com/c/150397
Reviewed-by: Rob Pike <r@golang.org>
Run-TryBot: Rob Pike <r@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>

doc/go1.12: announce deprecation of support for FreeBSD 10.x

Fixes #27619

Change-Id: If18df696c0778efe894a4a249d4964db1b02e5d6
Reviewed-on: https://go-review.googlesource.com/c/150159
Reviewed-by: Yuval Pavel Zholkover <paulzhol@gmail.com>
Reviewed-by: Ian Lance Taylor <iant@golang.org>

encoding/pem: test getLine does not include trailing whitespace

Change-Id: I7a1046f5e0aedbbdd1106a616de410fe4e0cb7d8
Reviewed-on: https://go-review.googlesource.com/c/92295
Run-TryBot: Ian Lance Taylor <iant@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>

regexp: add matching and finding examples

This commit adds examples for Match, Find,
FindAllSubmatch, FindSubmatch and Match functions.

Change-Id: I2bdf8c3cee6e89d618109397378c1fc91aaf1dfb
GitHub-Last-Rev: 33f34b7adca2911a4fff9638c93e846fb0021465
GitHub-Pull-Request: golang/go#28837
Reviewed-on: https://go-review.googlesource.com/c/150020
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>

cmd/link: directly get max pc value in findfunctab

Change-Id: I70afd2f7b6783926174c4e66565b711cffeb97c5
Reviewed-on: https://go-review.googlesource.com/c/150141
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>

cmd/go: parse dot-separated identifiers in build metadata

Per https://semver.org/#spec-item-10, build metadata may include
a series of dot separated identifiers.

Fixes #28647

Change-Id: I98655c62584a822953df71fba32b4a2cafe7a04b
Reviewed-on: https://go-review.googlesource.com/c/148835
Reviewed-by: Bryan C. Mills <bcmills@google.com>

cmd/vendor: eliminate vet-lite

cmd/vet, now simplified to a single function call is now authoritative,
not a copy of vet-lite.

The update-xtools.sh script now uses the imports of cmd/vet as the
roots for vendoring.

Change-Id: I4faef3fcf3db10b3a3930726e8d0720a3c8395da
Reviewed-on: https://go-review.googlesource.com/c/150297
Run-TryBot: Alan Donovan <adonovan@google.com>
Reviewed-by: Daniel Martí <mvdan@mvdan.cc>

cmd/go: improve go vet documentation

- restore and rework cmd/vet/doc.go, which was clobbered during the vet-lite switch.
- document go vet -vettool=prog flag and how to run an alternative checker.
- make 'go vet -help' show how to list vet tool's flags.  Example:

$ go vet -help
usage: go vet [-n] [-x] [-vettool prog] [build flags] [vet flags] [packages]
Run 'go help vet' for details.
Run 'go tool vet help' for the vet tool's flags.

$ go vet -vettool=~/bin/myvet -help
usage: go vet [-n] [-x] [-vettool prog] [build flags] [vet flags] [packages]
Run 'go help vet' for details.
Run '~/bin/myvet help' for the vet tool's flags.

Updates #28840

Change-Id: Ieb79dfe29e1df074f865bc9a9d47b44199675d7d
Reviewed-on: https://go-review.googlesource.com/c/147018
Reviewed-by: Daniel Martí <mvdan@mvdan.cc>
Run-TryBot: Daniel Martí <mvdan@mvdan.cc>
TryBot-Result: Gobot Gobot <gobot@golang.org>

cmd/vendor: update to golang.org/x/tools@139d099f

Mainly to pull the fix for the regression in #28792.

Change-Id: If71ae783fd9a9e3935186b49fdf501ba098235a2
Reviewed-on: https://go-review.googlesource.com/c/150161
Run-TryBot: Daniel Martí <mvdan@mvdan.cc>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Alan Donovan <adonovan@google.com>

cmd/compile: bulk rename

This change does a bulk rename of several identifiers in the compiler.
See #27167 and https://docs.google.com/document/d/19_ExiylD9MRfeAjKIfEsMU1_RGhuxB9sA0b5Zv7byVI/
for context and for discussion of these particular renames.

Commands run to generate this change:

gorename -from '"cmd/compile/internal/gc".OPROC' -to OGO
gorename -from '"cmd/compile/internal/gc".OCOM' -to OBITNOT
gorename -from '"cmd/compile/internal/gc".OMINUS' -to ONEG
gorename -from '"cmd/compile/internal/gc".OIND' -to ODEREF
gorename -from '"cmd/compile/internal/gc".OARRAYBYTESTR' -to OBYTES2STR
gorename -from '"cmd/compile/internal/gc".OARRAYBYTESTRTMP' -to OBYTES2STRTMP
gorename -from '"cmd/compile/internal/gc".OARRAYRUNESTR' -to ORUNES2STR
gorename -from '"cmd/compile/internal/gc".OSTRARRAYBYTE' -to OSTR2BYTES
gorename -from '"cmd/compile/internal/gc".OSTRARRAYBYTETMP' -to OSTR2BYTESTMP
gorename -from '"cmd/compile/internal/gc".OSTRARRAYRUNE' -to OSTR2RUNES

gorename -from '"cmd/compile/internal/gc".Etop' -to ctxStmt
gorename -from '"cmd/compile/internal/gc".Erv' -to ctxExpr
gorename -from '"cmd/compile/internal/gc".Ecall' -to ctxCallee
gorename -from '"cmd/compile/internal/gc".Efnstruct' -to ctxMultiOK
gorename -from '"cmd/compile/internal/gc".Easgn' -to ctxAssign
gorename -from '"cmd/compile/internal/gc".Ecomplit' -to ctxCompLit

Not altered: parameters and local variables (mostly in typecheck.go) named top,
which should probably now be called ctx (and which should probably have a named type).
Also not altered: Field called Top in gc.Func.

gorename -from '"cmd/compile/internal/gc".Node.Isddd' -to IsDDD
gorename -from '"cmd/compile/internal/gc".Node.SetIsddd' -to SetIsDDD
gorename -from '"cmd/compile/internal/gc".nodeIsddd' -to nodeIsDDD
gorename -from '"cmd/compile/internal/types".Field.Isddd' -to IsDDD
gorename -from '"cmd/compile/internal/types".Field.SetIsddd' -to SetIsDDD
gorename -from '"cmd/compile/internal/types".fieldIsddd' -to fieldIsDDD

Not altered: function gc.hasddd, params and local variables called isddd
Also not altered: fmt.go prints nodes using "isddd(%v)".

cd cmd/compile/internal/gc; go generate

I then manually found impacted comments using exact string match
and fixed them up by hand. The comment changes were trivial.

Passes toolstash-check.

Fixes #27167. If this experiment is deemed a success,
we will open a new tracking issue for renames to do
at the end of the 1.13 cycles.

Change-Id: I2dc541533d2ab0d06cb3d31d65df205ecfb151e8
Reviewed-on: https://go-review.googlesource.com/c/150140
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>

cmd/go: packages that use SWIG depend on "unsafe"

Fixes #28834

Change-Id: I95d6874e62d36974415f43843881a4ae85b3c7ce
Reviewed-on: https://go-review.googlesource.com/c/149964
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Emmanuel Odeke <emm.odeke@gmail.com>
Reviewed-by: Alan Donovan <adonovan@google.com>
Reviewed-by: Josh Bleecher Snyder <josharian@gmail.com>

os: make RemoveAll("") fail silently on unix

CL 146020 changed the behavior of RemoveAll("") on unix systems using
the *at functions to return syscall.EINVAL instead of nil. Adjust the
*at implementation to retain this behavior as is the case on the *noat
systems.

Additionally, also make sure RemoveAll("") on systems not using the "at
functions (e.g. nacl and js/wasm) follow the same behavior (which wasn't
the case previously).

Fixes #28830

Change-Id: I8383c1423fefe871d18ff49134a1d23077ec6867
Reviewed-on: https://go-review.googlesource.com/c/150158
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
Reviewed-by: roger peppe <rogpeppe@gmail.com>

crypto/hmac: rename CheckHMAC to ValidHMAC in package docs

Procedure names should reflect what they do; function names
should reflect what they return. Functions are used in
expressions, often in things like if's, so they need
to read appropriately.

        if CheckHMAC(a, b, key)

is unhelpful because we can't deduce whether CheckHMAC
returns true on error or non­-error; instead

        if ValidHMAC(a, b, key)

makes the point clear and makes a future mistake
in using the routine less likely.

https://www.lysator.liu.se/c/pikestyle.html

Change-Id: I7c4b1981c90c8d7475ddd8ec18dee3db2e0f42df
GitHub-Last-Rev: 32199a418b5e5507259fa4b6715da8a9c185f90a
GitHub-Pull-Request: golang/go#28823
Reviewed-on: https://go-review.googlesource.com/c/149857
Reviewed-by: Filippo Valsorda <filippo@golang.org>

runtime: don't use thread local storage before it is set up on iOS

CL 138675 added a call to runtime.save_g which uses thread local
storage to store g. On iOS however, that storage was not initialized
 yet. Move the call to below _cgo_init where it is set up.

Change-Id: I14538d3e7d56ff35a6fa02c47bca306d24c38010
Reviewed-on: https://go-review.googlesource.com/c/150157
Run-TryBot: Elias Naur <elias.naur@gmail.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>

cmd/vet: remove pkgfact analyzer, left in by mistake

Also, document process for updating vendored x/tools.

Change-Id: I826744603ae0752e508a6db7334a2bf9adaf1289
Reviewed-on: https://go-review.googlesource.com/c/149963
Run-TryBot: Alan Donovan <adonovan@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>

cmd/cgo: recognized untyped Go constants as untyped constants

Fixes #28772

Change-Id: I9446d95fb73fbcbb1cd9a4d2156ebc91bc9e91cb
Reviewed-on: https://go-review.googlesource.com/c/149858
Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>

cmd/asm: rename -symabis to -gensymabis

Currently, both asm and compile have a -symabis flag, but in asm it's
a boolean flag that means to generate a symbol ABIs file and in the
compiler its a string flag giving the path of the symbol ABIs file to
consume. I'm worried about this false symmetry biting us in the
future, so rename asm's flag to -gensymabis.

Updates #27539.

Change-Id: I8b9c18a852d2838099718f8989813f19d82e7434
Reviewed-on: https://go-review.googlesource.com/c/149818
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>

cmd/vet/all: remove skip when x/tools isn't in $GOPATH

Now that the build system has been updated to install x/tools in
$GOPATH (CL 149658), depend on it being there and don't ignore
failures to build the tool.

Update to CL 149097.

Change-Id: I72fde347217533697068b6a6773696cc2b83e9ed
Reviewed-on: https://go-review.googlesource.com/c/150017
Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Alan Donovan <adonovan@google.com>

cmd/vet: basic tests of go vet -json -c=N flags

Change-Id: I787592a5d92ff9329ecdfcf879e491af66c8b749
Reviewed-on: https://go-review.googlesource.com/c/149962
Run-TryBot: Alan Donovan <adonovan@google.com>
Reviewed-by: Michael Matloob <matloob@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>

cmd/vendor: update to golang.org/x/tools@8e5aba0a

- Adds 'go vet -json' and 'go vet -c=1' flags
- Removes the pkgfact analyzer, included by mistake.

Change-Id: Id3f1879af479efc567ea0508a1de7a37db5bee89
Reviewed-on: https://go-review.googlesource.com/c/149961
Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org>
Run-TryBot: Michael Matloob <matloob@golang.org>
Reviewed-by: Michael Matloob <matloob@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>

cmd/go: accept @hash/branch in mod download

Go get in mod-enabled packages lets you do go get "pkg@<hash>" or "pkg@<branch>".
Go internally will switch the hash or branch into a pseudo version.
Go mod download should do the same. The bug lay in the fact that the disk cache
was not being written when Go converted the hash/branch into a pseudo version.

Fixes #27947

Change-Id: I94c29a5c95f69ab18a9cd7a2ecade128047c5e36
GitHub-Last-Rev: 668634b3e70206c6eadabae5969fca1b03093b0d
GitHub-Pull-Request: golang/go#28042
Reviewed-on: https://go-review.googlesource.com/c/140257
Reviewed-by: Bryan C. Mills <bcmills@google.com>
Run-TryBot: Bryan C. Mills <bcmills@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>

cmd/go: vet: provide package ID to the vet tool

This field, which matches the IDs used by go list, will enable all vet
drivers to produce JSON output in a consistent format (a map from
package ID to analysis name to result).

Change-Id: Icac703b944de55df42c996dc2f672005014ad57a
Reviewed-on: https://go-review.googlesource.com/c/149960
Reviewed-by: Russ Cox <rsc@golang.org>

build: clear GO111MODULE during make.bash etc

The standard build assumes the variable is unset.
Make it so, like we do for GOFLAGS, GOBIN, and so on.

Change-Id: I4ad5695f8021b08bd1a35dd99112970a813d247c
Reviewed-on: https://go-review.googlesource.com/c/149959
Run-TryBot: Russ Cox <rsc@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>

cmd/vet: reenable cgo test

The reason the 386 trybot was happy but 'GOARCH=386 go test cmd/vet'
was not is that CgoEnabled defaults to false in a cross build;
I have no idea why. Now we ask the go command for the effective
value so that the test works in both cases.

Also, remove stale comment.

Fixes #28829

Change-Id: I1210af34da6986f47924059de5c1f08b2824ace9
Reviewed-on: https://go-review.googlesource.com/c/149958
Run-TryBot: Alan Donovan <adonovan@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>

doc/go_spec: tweak wording to avoid 'explicit assignment' misreading

This text changed in CL 139099 to add "explicit" in front of "conversion".
But now "explicit conversion or assignment" reads like it might mean
"explicit [conversion or assignment]" when what is meant is
"[explicit conversion] or assignment". To make clear that explicit does
not apply to assignment, use "assignment or explicit conversion".

Change-Id: I8ff7a5b3ecd9f562793502fa6808242f22264f28
Reviewed-on: https://go-review.googlesource.com/c/149340
Reviewed-by: Robert Griesemer <gri@golang.org>

cmd/go: fix experiment isolation in cache key

In general we don't assume that the go command knows the
specific version of the compiler being used, including which
experiments the compiler was built with. Let the compiler tell us,
instead of importing cmd/internal/objabi from cmd/go.

Replacement for CL 128735.

Change-Id: Iaa07f46e19764d0fb14a1c89979bea7bb7139b9c
Reviewed-on: https://go-review.googlesource.com/c/149338
Reviewed-by: Bryan C. Mills <bcmills@google.com>

cmd/go: fix detection of unexpected files in downloaded zips

A bug in the old code was indirectly causing a confusing print,
but CL 131635 fixed the print instead of the surrounding code.
Fix the surrounding code, restore the old print, and test that the
error is actually reported (it was being ignored in a direct go get
but displaying in go build).

Change-Id: I03c21380fce481060c443b0cc820f3617497fdd9
Reviewed-on: https://go-review.googlesource.com/c/149317
Reviewed-by: Bryan C. Mills <bcmills@google.com>

cmd/compile: provide updating mechanism for format test

The compiler's Format test verifies that the correct format
strings for the given arguments are used in the compiler
sources. The format strings are fairly specialized which is
why we cannot use go vet; and the mapping is based on a
hard-wired map.

In the past, if that map got out of sync with the compiler
sources, it was necessary to manually update the map. This
change introduces an update mechanism which simply requires
the test to be run with the -u flag.

(Formerly, the -u flag was used to automatically rewrite
format strings; now we use -r for that.)

Change-Id: I9259566a6120a13cf34b143875975ada62697890
Reviewed-on: https://go-review.googlesource.com/c/149460
Run-TryBot: Robert Griesemer <gri@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Austin Clements <austin@google.com>

database/sql: add examples for opening and testing a DB pool

Show two larger application examples. One example that
could be used in a CLI, the other in a long running
service. These demonstarates different strategies for
handling DB.Ping errors in context.

Fixes #23738

Change-Id: Id01213caf1f47917239a7506b01d30e37db74d31
Reviewed-on: https://go-review.googlesource.com/c/101216
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>

testing: add example to package doc

The package doc for the testing package doesn't have a simple
example demonstrating how to write a test with an expectation. The doc
has simple examples for benchmarks, examples, and skipping, and it would be
useful for people new to writing tests in Go.

Also moved the skip example further down because it references tests and
benchmarks but benchmarks haven't been discussed in detail until the
next section. Skip is also a less used feature and it seems misplaced to
sit so high up in the package documentation. As an example, Skip is used
570 times the Go code repository which is significantly less than Error
and Fatal that are used 23,303 times.

Also changed 'sample' to 'simple' in other places in the package documentation
to keep the language used consistent when describing the small examples.

Fixes #27839

Change-Id: Ie01a3751986ee61adf2a2f2eda59cc182342baa7
GitHub-Last-Rev: 7357bfdcd29ed1dc1719c9436b5d5420020610ee
GitHub-Pull-Request: golang/go#27840
Reviewed-on: https://go-review.googlesource.com/c/137175
Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
Reviewed-by: Emmanuel Odeke <emm.odeke@gmail.com>

net/http: fix typo in the SameSite docs

Fixes #28244

Change-Id: I3ca36fd513f5543af0c8af254d267254c7d5e803
GitHub-Last-Rev: 83b16fac4e221a249ed036c034367d6f680ae578
GitHub-Pull-Request: golang/go#28302
Reviewed-on: https://go-review.googlesource.com/c/143480
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>

cmd/vet: fix two failing test cases

Select linux/arm64 for the asm test.

Disable the cgo test for now.
Will fix properly in a follow-up.
Filed Issue 28829 to track it.

Updates #28829

Change-Id: Ic05f619700b06e91c43f8c150b089b8e77d92c85
Reviewed-on: https://go-review.googlesource.com/c/149937
Run-TryBot: Alan Donovan <adonovan@google.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>

reflect: add comment for String method of Kind struct

On reflect documentation page only this function
doesn't have description, this commit add simple description.

Change-Id: Idcda89ddd1f6fdd1938c4030e89ebdc186255ce6
GitHub-Last-Rev: 1553b834bb4f7a49efc7ff81763a255bc51bbf17
GitHub-Pull-Request: golang/go#28818
Reviewed-on: https://go-review.googlesource.com/c/149721
Reviewed-by: Ian Lance Taylor <iant@golang.org>

misc/cgo/testsanitizers: gofmt

Change-Id: I4e7328bb89f504dbca3948b8565d22c44d41db3d
Reviewed-on: https://go-review.googlesource.com/c/149917
Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>

cmd/cgo: fix comment grammar

Change-Id: I9c881943685177ce14841da53ccaed301c4955dd
Reviewed-on: https://go-review.googlesource.com/c/149859
Reviewed-by: Tobias Klauser <tobias.klauser@gmail.com>

cmd/go: correctly suggest tidy instead of nonexistent fix for -fix

CL 129682 removed go mod fix but unfortunately
we hadn't updated the source code hence running
   go mod -fix
would suggest
   go mod fix
which is a nonexistent command.

This change fixes that to instead suggest
   go mod tidy

Change-Id: Ie0d7c90805034e9fe6df24afaa15340c44d4f426
GitHub-Last-Rev: 5ae1340954c5f6b8535f837755a7bd79ebc7109d
GitHub-Pull-Request: golang/go#28402
Reviewed-on: https://go-review.googlesource.com/c/144838
Reviewed-by: Emmanuel Odeke <emm.odeke@gmail.com>
Run-TryBot: Emmanuel Odeke <emm.odeke@gmail.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>