1. 04 Oct, 2019 8 commits
  2. 03 Oct, 2019 17 commits
    • David Chase's avatar
      cmd/compile: run deadcode before nilcheck for better statement relocation · adc4d2cc
      David Chase authored
      Nilcheck would move statements from NilCheck values to others that
      turned out were already dead, which leads to lost statements.  Better
      to eliminate the dead code first.
      
      One "error" is removed from test/prove.go because the code is
      actually dead, and the additional deadcode pass removes it before
      prove can run.
      
      Change-Id: If75926ca1acbb59c7ab9c8ef14d60a02a0a94f8b
      Reviewed-on: https://go-review.googlesource.com/c/go/+/198479
      Run-TryBot: David Chase <drchase@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarJeremy Faller <jeremy@golang.org>
      adc4d2cc
    • David Chase's avatar
      cmd/compile: make nilcheck more careful about statement relocations · 08a87938
      David Chase authored
      The earlier code was picking nodes that were "poor choices" and
      thus sometimes losing statements altogether.
      
      Change-Id: Ibe5ed800ffbd3c926c0ab1bc10c77d72d3042e45
      Reviewed-on: https://go-review.googlesource.com/c/go/+/198478
      Run-TryBot: David Chase <drchase@google.com>
      Reviewed-by: default avatarJeremy Faller <jeremy@golang.org>
      08a87938
    • David Chase's avatar
      cmd/compile: classify more nodes as "poor choices" for statements · 53bd9151
      David Chase authored
      Aggregate-making nodes that are later decomposed
      are poor choices for statements, because the decomposition
      phase turns them into multiple sub-values, some of which may be
      dead.  Better to look elsewhere for a statement mark.
      
      Change-Id: Ibd9584138ab3d1384548686896a28580a2e43f54
      Reviewed-on: https://go-review.googlesource.com/c/go/+/198477
      Run-TryBot: David Chase <drchase@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarJeremy Faller <jeremy@golang.org>
      Reviewed-by: default avatarCherry Zhang <cherryyz@google.com>
      53bd9151
    • David Chase's avatar
      cmd/compile: pick position of implicit break statements more carefully · 6139019e
      David Chase authored
      The previous version used the position of the switch statement,
      which makes for potentially jumpy stepping and introduces a large
      number of statements repeating the line (tricky for inserting
      breaks).  It also shared a single OBREAK node and this was not
      really a syntax "tree".
      
      This improves both the nostmt test (by 6 lines) and
      reduces the total badness score from dwarf-goodness (by about 200).
      
      Change-Id: I1f71b231a26f152bdb6ce9bc8f95828bb222f665
      Reviewed-on: https://go-review.googlesource.com/c/go/+/188218
      Run-TryBot: David Chase <drchase@google.com>
      Reviewed-by: default avatarJeremy Faller <jeremy@golang.org>
      6139019e
    • David Chase's avatar
      cmd/compile: refine statement marking in numberlines · f7f85bdc
      David Chase authored
      1) An empty block is treated as not-a-statement unless its line differs
      from at least one of its predecessors (it might make sense to
      rearrange branches in predecessors, but that is a different issue).
      
      2) When iterating forward to choose a "good" place for a statement,
      actually check that the chosen place is in fact good.
      
      3) Refactor same line and same file into methods on XPos and Pos.
      
      This reduces the failure rate of ssa/stmtlines_test by 7-ish lines.
      (And interacts favorably with later debugging CLs.)
      
      Change-Id: Idb7cca7068f6fc9fbfdbe25bc0da15bcfc7b9d4a
      Reviewed-on: https://go-review.googlesource.com/c/go/+/188217
      Run-TryBot: David Chase <drchase@google.com>
      Reviewed-by: default avatarJeremy Faller <jeremy@golang.org>
      f7f85bdc
    • Matthew Dempsky's avatar
      cmd/compile: change size diagnostic to use benchmark format · 3ad35082
      Matthew Dempsky authored
      Makes it easier to run
      
          go build -a -gcflags=-d=export std |& grep ^BenchmarkExportSize
      
      and get useful output for feeding into benchstat.
      
      Change-Id: I2b52e8f5ff33b7ccb6c25b18e464513344bd9ad9
      Reviewed-on: https://go-review.googlesource.com/c/go/+/198698Reviewed-by: default avatarRobert Griesemer <gri@golang.org>
      3ad35082
    • Meng Zhuo's avatar
      internal/bytealg: (re)adding mips64x compare implementation · a1b1ba7d
      Meng Zhuo authored
      The original CL of mips64x compare function has been reverted due to wrong
      implement for little endian.
      Original CL: https://go-review.googlesource.com/c/go/+/196837
      
      name                         old time/op    new time/op    delta
      BytesCompare/1                 28.9ns ± 4%    22.1ns ± 0%    -23.60%  (p=0.000 n=9+8)
      BytesCompare/2                 34.6ns ± 0%    23.1ns ± 0%    -33.25%  (p=0.000 n=8+10)
      BytesCompare/4                 54.6ns ± 0%    40.8ns ± 0%    -25.27%  (p=0.000 n=8+8)
      BytesCompare/8                 73.9ns ± 0%    49.1ns ± 0%    -33.56%  (p=0.000 n=8+8)
      BytesCompare/16                 113ns ± 0%      24ns ± 0%    -79.20%  (p=0.000 n=9+9)
      BytesCompare/32                 190ns ± 0%      26ns ± 0%    -86.53%  (p=0.000 n=10+10)
      BytesCompare/64                 345ns ± 0%      44ns ± 0%    -87.19%  (p=0.000 n=10+8)
      BytesCompare/128                654ns ± 0%      52ns ± 0%    -91.97%  (p=0.000 n=9+8)
      BytesCompare/256               1.27µs ± 0%    0.07µs ± 0%    -94.14%  (p=0.001 n=8+9)
      BytesCompare/512               2.51µs ± 0%    0.12µs ± 0%    -95.26%  (p=0.000 n=9+10)
      BytesCompare/1024              4.99µs ± 0%    0.21µs ± 0%    -95.85%  (p=0.000 n=8+10)
      BytesCompare/2048              9.94µs ± 0%    0.38µs ± 0%    -96.14%  (p=0.000 n=8+8)
      CompareBytesEqual               105ns ± 0%      64ns ± 0%    -39.43%  (p=0.000 n=10+9)
      CompareBytesToNil              34.8ns ± 1%    38.6ns ± 3%    +11.01%  (p=0.000 n=10+10)
      CompareBytesEmpty              33.6ns ± 3%    36.6ns ± 0%     +8.77%  (p=0.000 n=10+8)
      CompareBytesIdentical          29.7ns ± 0%    40.5ns ± 1%    +36.45%  (p=0.000 n=10+8)
      CompareBytesSameLength         69.1ns ± 0%    51.8ns ± 0%    -25.04%  (p=0.000 n=10+9)
      CompareBytesDifferentLength    69.8ns ± 0%    52.5ns ± 0%    -24.79%  (p=0.000 n=10+8)
      CompareBytesBigUnaligned       5.15ms ± 0%    2.19ms ± 0%    -57.59%  (p=0.000 n=9+9)
      CompareBytesBig                5.28ms ± 0%    0.28ms ± 0%    -94.64%  (p=0.000 n=8+8)
      CompareBytesBigIdentical       29.7ns ± 0%    36.9ns ± 2%    +24.11%  (p=0.000 n=8+10)
      
      name                         old speed      new speed      delta
      CompareBytesBigUnaligned      204MB/s ± 0%   480MB/s ± 0%   +135.77%  (p=0.000 n=9+9)
      CompareBytesBig               198MB/s ± 0%  3704MB/s ± 0%  +1765.97%  (p=0.000 n=8+8)
      CompareBytesBigIdentical     35.3TB/s ± 0%  28.4TB/s ± 2%    -19.44%  (p=0.000 n=8+10)
      
      Fixes #34549
      
      Change-Id: I2ef29f13cdd4229745ac2d018bb53c76f2ff1209
      Reviewed-on: https://go-review.googlesource.com/c/go/+/197557Reviewed-by: default avatarCherry Zhang <cherryyz@google.com>
      Run-TryBot: Cherry Zhang <cherryyz@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      a1b1ba7d
    • Meng Zhuo's avatar
      cmd/asm: add VLD[1-4]R vector instructions on arm64 · 2bf7a925
      Meng Zhuo authored
      This change adds VLD1R, VLD2R, VLD3R, VLD4R
      
      Change-Id: Ie19e9ae02fdfc94b9344acde8c9938849efb0bf0
      Reviewed-on: https://go-review.googlesource.com/c/go/+/181697
      Run-TryBot: Cherry Zhang <cherryyz@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarCherry Zhang <cherryyz@google.com>
      2bf7a925
    • Bryan C. Mills's avatar
      Revert "cmd/compile: walk the progs to generate debug_lines" · 5fe3b49a
      Bryan C. Mills authored
      This reverts CL 196661.
      
      Reason for revert: broke TestGdb* tests on mips64le, ppc64le, and s390x builders.
      
      Change-Id: I3b5c97c840819a0d407b943f7cf7e2d97f06042d
      Reviewed-on: https://go-review.googlesource.com/c/go/+/198697
      Run-TryBot: Bryan C. Mills <bcmills@google.com>
      Reviewed-by: default avatarBrad Fitzpatrick <bradfitz@golang.org>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      5fe3b49a
    • Matthew Dempsky's avatar
      cmd/compile: don't statically copy string-typed variables · c33d45a8
      Matthew Dempsky authored
      During package initialization, the compiler tries to optimize:
      
          var A = "foo"
          var B = A
      
      into
      
          var A = "foo"
          var B = "foo"
      
      so that we can statically initialize both A and B and skip emitting
      dynamic initialization code to assign "B = A".
      
      However, this isn't safe in the presence of cmd/link's -X flag, which
      might overwrite an initialized string-typed variable at link time. In
      particular, if cmd/link changes A's static initialization, it won't
      know it also needs to change B's static initialization.
      
      To address this, this CL disables this optimization for string-typed
      variables.
      
      Fixes #34675.
      
      Change-Id: I1c18f3b855f6d7114aeb39f96aaaf1b452b88236
      Reviewed-on: https://go-review.googlesource.com/c/go/+/198657
      Run-TryBot: Matthew Dempsky <mdempsky@google.com>
      Reviewed-by: default avatarCuong Manh Le <cuong.manhle.vn@gmail.com>
      Reviewed-by: default avatarBrad Fitzpatrick <bradfitz@golang.org>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      c33d45a8
    • Jason A. Donenfeld's avatar
      runtime: iterate ms via allm linked list to avoid race · 6b85fa80
      Jason A. Donenfeld authored
      It's pointless to reach all ms via allgs, and doing so introduces a
      race, since the m member of a g can change underneath it. Instead
      iterate directly through the allm linked list.
      
      Updates: #31528
      Updates: #34130
      
      Change-Id: I34b88402b44339b0a5b4cd76eafd0ce6e43e2be1
      Reviewed-on: https://go-review.googlesource.com/c/go/+/198417
      Run-TryBot: Jason A. Donenfeld <Jason@zx2c4.com>
      Reviewed-by: default avatarAlex Brainman <alex.brainman@gmail.com>
      Reviewed-by: default avatarAustin Clements <austin@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      6b85fa80
    • Jeremy Faller's avatar
      cmd/compile: walk the progs to generate debug_lines · 9e6a84f2
      Jeremy Faller authored
      Rather than use the pcln tables, walk progs while generating
      debug_lines.  This code slightly increases the number of is_stmt toggles
      in the debug information due to a previous bug in how the pcline walking
      worked. (Previous versions of the line walking code wouldn't return the
      old_value, instead returning 0. This behavior might lose is_stmt toggles
      in the line table.)
      
      We suspected there would be a speedup with this change, but benchmarking
      hasn't shown this to be true (but has been noisy enough to not really
      show any large differences either way). These benchmarks are comparing
      non-prog walking code with this prog-walking code:
      
      name                      old time/op       new time/op       delta
      Template                        321ms ± 4%        316ms ± 3%     ~     (p=0.165 n=10+10)
      Unicode                         146ms ± 5%        142ms ± 4%     ~     (p=0.063 n=10+10)
      GoTypes                         1.06s ± 2%        1.07s ± 2%     ~     (p=0.280 n=10+10)
      Compiler                        4.07s ± 1%        4.06s ± 1%     ~     (p=0.549 n=10+9)
      SSA                             12.6s ± 2%        12.7s ± 2%   +1.27%  (p=0.019 n=10+10)
      Flate                           201ms ± 7%        202ms ± 4%     ~     (p=0.436 n=10+10)
      GoParser                        248ms ± 4%        250ms ± 2%     ~     (p=0.356 n=9+10)
      Reflect                         679ms ± 5%        678ms ± 4%     ~     (p=0.971 n=10+10)
      Tar                             281ms ± 2%        283ms ± 3%     ~     (p=0.222 n=9+9)
      XML                             381ms ± 3%        384ms ± 5%     ~     (p=0.393 n=10+10)
      LinkCompiler                    1.08s ± 2%        1.10s ± 2%   +1.89%  (p=0.009 n=10+10)
      ExternalLinkCompiler            2.23s ± 4%        2.23s ± 1%     ~     (p=1.000 n=10+8)
      LinkWithoutDebugCompiler        654ms ± 4%        673ms ± 4%   +2.94%  (p=0.019 n=10+10)
      StdCmd                          13.6s ± 2%        13.9s ± 1%   +2.00%  (p=0.000 n=10+10)
      
      name                      old user-time/op  new user-time/op  delta
      Template                        582ms ±11%        575ms ±14%     ~     (p=0.631 n=10+10)
      Unicode                         431ms ±24%        390ms ±38%     ~     (p=0.315 n=10+10)
      GoTypes                         2.47s ±11%        2.51s ± 4%     ~     (p=0.280 n=10+10)
      Compiler                        9.09s ± 3%        9.04s ± 5%     ~     (p=0.684 n=10+10)
      SSA                             25.8s ± 4%        26.0s ± 3%     ~     (p=0.529 n=10+10)
      Flate                           318ms ±14%        322ms ±13%     ~     (p=0.912 n=10+10)
      GoParser                        386ms ± 6%        386ms ± 5%     ~     (p=0.888 n=9+8)
      Reflect                         1.42s ±20%        1.32s ±24%     ~     (p=0.393 n=10+10)
      Tar                             476ms ±19%        471ms ±25%     ~     (p=1.000 n=10+10)
      XML                             681ms ±25%        745ms ±21%     ~     (p=0.143 n=10+10)
      LinkCompiler                    1.75s ±13%        1.86s ±12%     ~     (p=0.075 n=10+10)
      ExternalLinkCompiler            2.98s ±18%        3.41s ±13%  +14.48%  (p=0.003 n=10+10)
      LinkWithoutDebugCompiler        1.05s ±12%        1.08s ±16%     ~     (p=0.739 n=10+10)
      
      name                      old alloc/op      new alloc/op      delta
      Template                       36.4MB ± 0%       36.4MB ± 0%   -0.11%  (p=0.000 n=10+10)
      Unicode                        28.6MB ± 0%       28.5MB ± 0%   -0.06%  (p=0.029 n=10+10)
      GoTypes                         121MB ± 0%        121MB ± 0%   -0.09%  (p=0.000 n=9+9)
      Compiler                        548MB ± 0%        547MB ± 0%   -0.10%  (p=0.000 n=10+10)
      SSA                            1.87GB ± 0%       1.87GB ± 0%   -0.13%  (p=0.000 n=10+10)
      Flate                          23.0MB ± 0%       22.9MB ± 0%   -0.09%  (p=0.000 n=9+10)
      GoParser                       27.9MB ± 0%       27.8MB ± 0%   -0.12%  (p=0.000 n=10+10)
      Reflect                        77.7MB ± 0%       77.6MB ± 0%   -0.12%  (p=0.000 n=8+10)
      Tar                            34.5MB ± 0%       34.5MB ± 0%   -0.07%  (p=0.003 n=10+10)
      XML                            44.4MB ± 0%       44.4MB ± 0%   -0.07%  (p=0.000 n=10+10)
      LinkCompiler                    236MB ± 0%        240MB ± 0%   +1.72%  (p=0.000 n=10+10)
      ExternalLinkCompiler            246MB ± 0%        254MB ± 0%   +3.02%  (p=0.000 n=10+10)
      LinkWithoutDebugCompiler        159MB ± 0%        164MB ± 0%   +3.35%  (p=0.000 n=10+10)
      
      name                      old allocs/op     new allocs/op     delta
      Template                         372k ± 0%         371k ± 0%   -0.23%  (p=0.000 n=10+10)
      Unicode                          340k ± 0%         340k ± 0%   -0.05%  (p=0.000 n=10+10)
      GoTypes                         1.33M ± 0%        1.32M ± 0%   -0.20%  (p=0.000 n=9+10)
      Compiler                        5.37M ± 0%        5.36M ± 0%   -0.17%  (p=0.000 n=10+10)
      SSA                             17.9M ± 0%        17.9M ± 0%   -0.15%  (p=0.000 n=10+10)
      Flate                            234k ± 0%         233k ± 0%   -0.24%  (p=0.000 n=9+10)
      GoParser                         309k ± 0%         309k ± 0%   -0.21%  (p=0.000 n=10+10)
      Reflect                          969k ± 0%         966k ± 0%   -0.30%  (p=0.000 n=9+10)
      Tar                              348k ± 0%         347k ± 0%   -0.22%  (p=0.000 n=10+9)
      XML                              426k ± 0%         425k ± 0%   -0.15%  (p=0.000 n=9+10)
      LinkCompiler                     638k ± 0%         637k ± 0%   -0.07%  (p=0.000 n=10+10)
      ExternalLinkCompiler            1.69M ± 0%        1.69M ± 0%   -0.05%  (p=0.000 n=10+10)
      LinkWithoutDebugCompiler         222k ± 0%         221k ± 0%   -0.03%  (p=0.007 n=10+9)
      
      name                      old object-bytes  new object-bytes  delta
      Template                        559kB ± 0%        560kB ± 0%   +0.23%  (p=0.000 n=10+10)
      Unicode                         216kB ± 0%        216kB ± 0%   +0.01%  (p=0.000 n=10+10)
      GoTypes                        2.03MB ± 0%       2.04MB ± 0%   +0.31%  (p=0.000 n=10+10)
      Compiler                       8.07MB ± 0%       8.10MB ± 0%   +0.35%  (p=0.000 n=10+10)
      SSA                            27.1MB ± 0%       27.3MB ± 0%   +0.72%  (p=0.000 n=10+10)
      Flate                           343kB ± 0%        344kB ± 0%   +0.22%  (p=0.000 n=10+10)
      GoParser                        441kB ± 0%        442kB ± 0%   +0.34%  (p=0.000 n=10+10)
      Reflect                        1.36MB ± 0%       1.36MB ± 0%   +0.23%  (p=0.000 n=10+10)
      Tar                             487kB ± 0%        488kB ± 0%   +0.21%  (p=0.000 n=10+10)
      XML                             632kB ± 0%        634kB ± 0%   +0.35%  (p=0.000 n=10+10)
      
      name                      old export-bytes  new export-bytes  delta
      Template                       18.5kB ± 0%       18.5kB ± 0%     ~     (all equal)
      Unicode                        7.92kB ± 0%       7.92kB ± 0%     ~     (all equal)
      GoTypes                        35.0kB ± 0%       35.0kB ± 0%     ~     (all equal)
      Compiler                        109kB ± 0%        109kB ± 0%   +0.00%  (p=0.000 n=10+10)
      SSA                             137kB ± 0%        137kB ± 0%   +0.00%  (p=0.000 n=10+10)
      Flate                          4.89kB ± 0%       4.89kB ± 0%     ~     (all equal)
      GoParser                       8.49kB ± 0%       8.49kB ± 0%     ~     (all equal)
      Reflect                        11.4kB ± 0%       11.4kB ± 0%     ~     (all equal)
      Tar                            10.5kB ± 0%       10.5kB ± 0%     ~     (all equal)
      XML                            16.7kB ± 0%       16.7kB ± 0%     ~     (all equal)
      
      name                      old text-bytes    new text-bytes    delta
      HelloSize                       760kB ± 0%        760kB ± 0%     ~     (all equal)
      CmdGoSize                      10.8MB ± 0%       10.8MB ± 0%     ~     (all equal)
      
      name                      old data-bytes    new data-bytes    delta
      HelloSize                      10.7kB ± 0%       10.7kB ± 0%     ~     (all equal)
      CmdGoSize                       312kB ± 0%        312kB ± 0%     ~     (all equal)
      
      name                      old bss-bytes     new bss-bytes     delta
      HelloSize                       122kB ± 0%        122kB ± 0%     ~     (all equal)
      CmdGoSize                       146kB ± 0%        146kB ± 0%     ~     (all equal)
      
      name                      old exe-bytes     new exe-bytes     delta
      HelloSize                      1.13MB ± 0%       1.13MB ± 0%     ~     (all equal)
      CmdGoSize                      15.0MB ± 0%       15.1MB ± 0%   +0.22%  (p=0.000 n=10+10)
      
      Change-Id: If6e0982cd1398062a88e6c0c7513e141f9503531
      Reviewed-on: https://go-review.googlesource.com/c/go/+/196661
      Run-TryBot: Jeremy Faller <jeremy@golang.org>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarDavid Chase <drchase@google.com>
      9e6a84f2
    • Tobias Klauser's avatar
      cmd/go/internal/modfetch: update TestCodeRepo for gopkg.in/yaml.v2 again · 64785bf9
      Tobias Klauser authored
      Update the expected data to fix the longtest builder.
      
      Updates #28856
      
      Change-Id: I7fb6ee72e8469d974561b4b4057f40142f5b3654
      Reviewed-on: https://go-review.googlesource.com/c/go/+/198557
      Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarDmitri Shuralyov <dmitshur@golang.org>
      64785bf9
    • Utkarsh Dixit's avatar
      C: update email address for utkarsh-extc · 3d437ac6
      Utkarsh Dixit authored
      Change-Id: If657dab2df19d3b0c2ff9869a64e3a97446646ac
      GitHub-Last-Rev: b921b01cf4e5bcbbc65fb1fb0b5cd836bda73596
      GitHub-Pull-Request: golang/go#34637
      Reviewed-on: https://go-review.googlesource.com/c/go/+/198041Reviewed-by: default avatarDmitri Shuralyov <dmitshur@golang.org>
      3d437ac6
    • Robert Griesemer's avatar
      cmd/compile: better error message for language version errors · 27fc32ff
      Robert Griesemer authored
      Fixes #33753.
      Updates #31747.
      
      Change-Id: Icc42b23405ead4f7f17b0ffa3611405454b6b271
      Reviewed-on: https://go-review.googlesource.com/c/go/+/198491
      Run-TryBot: Robert Griesemer <gri@golang.org>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarIan Lance Taylor <iant@golang.org>
      27fc32ff
    • Matthew Dempsky's avatar
      runtime: use efaceOf where applicable · 64e598f7
      Matthew Dempsky authored
      Prepared with gofmt -r.
      
      Change-Id: Ifea325c209d800b5692d318955930b10debb548b
      Reviewed-on: https://go-review.googlesource.com/c/go/+/198494
      Run-TryBot: Matthew Dempsky <mdempsky@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarIan Lance Taylor <iant@golang.org>
      64e598f7
    • Ariel Mashraki's avatar
      text/template/parse: speed up nodes printing · debbb1e7
      Ariel Mashraki authored
      This CL is a follow up for 198080.
      Added a private writeTo method to the Node interface,
      in order to use the same builder for printing all nodes
      in the tree. Benchmark output against master:
      
      benchmark                     old ns/op     new ns/op     delta
      BenchmarkParseLarge-8         24594994      25292054      +2.83%
      BenchmarkVariableString-8     117           118           +0.85%
      BenchmarkListString-8         10475         3353          -67.99%
      
      benchmark                     old allocs     new allocs     delta
      BenchmarkVariableString-8     3              3              +0.00%
      BenchmarkListString-8         149            31             -79.19%
      
      benchmark                     old bytes     new bytes     delta
      BenchmarkVariableString-8     72            72            +0.00%
      BenchmarkListString-8         5698          1608          -71.78%
      
      Change-Id: I2b1cf07cda65c1b80083fb99671289423700feba
      Reviewed-on: https://go-review.googlesource.com/c/go/+/198278Reviewed-by: default avatarRob Pike <r@golang.org>
      Run-TryBot: Rob Pike <r@golang.org>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      debbb1e7
  3. 02 Oct, 2019 10 commits
    • Michael Hendricks's avatar
      net: avoid an infinite loop in LookupAddr · f0e940eb
      Michael Hendricks authored
      If a request for a PTR record returned a response with a non-PTR
      answer, goLookupPTR would loop forever.  Skipping non-PTR answers
      guarantees progress through the DNS response.
      
      Fixes #34660
      
      Change-Id: I56f9d21e5342d07e7d843d253267e93a29707904
      Reviewed-on: https://go-review.googlesource.com/c/go/+/198460
      Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarBrad Fitzpatrick <bradfitz@golang.org>
      f0e940eb
    • Egon Elbre's avatar
      cmd/cgo: optimize cgoCheckPointer call · e85ffec7
      Egon Elbre authored
      Currently cgoCheckPointer is only used with one optional argument.
      Using a slice for the optional arguments is quite expensive, hence
      replace it with a single interface{}. This results in ~30% improvement.
      
      When checking struct fields, they quite often end up being without
      pointers. Check this before calling cgoCheckPointer, which results in
      additional ~20% improvement.
      
      Inline some p == nil checks from cgoIsGoPointer which gives
      additional ~15% improvement.
      
      All of this translates to:
      
      name                             old time/op  new time/op  delta
      CgoCall/add-int-32               46.9ns ± 1%  46.6ns ± 1%   -0.75%  (p=0.000 n=18+20)
      CgoCall/one-pointer-32            143ns ± 1%    87ns ± 1%  -38.96%  (p=0.000 n=20+20)
      CgoCall/eight-pointers-32         767ns ± 0%   327ns ± 1%  -57.30%  (p=0.000 n=18+16)
      CgoCall/eight-pointers-nil-32     110ns ± 1%    89ns ± 2%  -19.10%  (p=0.000 n=19+19)
      CgoCall/eight-pointers-array-32  5.09µs ± 1%  3.56µs ± 2%  -30.09%  (p=0.000 n=19+19)
      CgoCall/eight-pointers-slice-32  3.92µs ± 0%  2.57µs ± 2%  -34.48%  (p=0.000 n=20+20)
      
      Change-Id: I2aa9f5ae8962a9a41a7fb1db0c300893109d0d75
      Reviewed-on: https://go-review.googlesource.com/c/go/+/198081
      Run-TryBot: Ian Lance Taylor <iant@golang.org>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarIan Lance Taylor <iant@golang.org>
      e85ffec7
    • W. Trevor King's avatar
      crypto/x509: add Detail to Expired errors · 30d7b640
      W. Trevor King authored
      Because errors like:
      
          certificate has expired or is not yet valid
      
      make it difficult to distinguish between "certificate has expired" and
      "my local clock is skewed".  Including our idea of the local time
      makes it easier to identify the clock-skew case, and including the
      violated certificate constraint saves folks the trouble of looking it
      up in the target certificate.
      
      Change-Id: I52e0e71705ee36f6afde1bb5a47b9b42ed5ead5b
      GitHub-Last-Rev: db2ca4029c1e0b17363772d9824e3042d5501d48
      GitHub-Pull-Request: golang/go#34646
      Reviewed-on: https://go-review.googlesource.com/c/go/+/198046Reviewed-by: default avatarFilippo Valsorda <filippo@golang.org>
      Run-TryBot: Filippo Valsorda <filippo@golang.org>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      30d7b640
    • Dan Scales's avatar
      cmd/compile: add an explicit test for compile of arch.ZeroRange · 0000f0be
      Dan Scales authored
      Add a test that causes generation of arch.ZeroRange calls of various sizes 8-136
      bytes in the compiler. This is to test that ZeroRanges of various sizes actually
      compile on different architectures, but is not testing runtime correctness (which
      is hard to do).
      
      Updates #34604
      
      Change-Id: I4131eb86669bdfe8d4e36f4ae5c2a7b069abd6c4
      Reviewed-on: https://go-review.googlesource.com/c/go/+/198045
      Run-TryBot: Dan Scales <danscales@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarCherry Zhang <cherryyz@google.com>
      0000f0be
    • Brad Fitzpatrick's avatar
      net/http: document that Request.Host includes HTTP/2 :authority · 0ba0ea17
      Brad Fitzpatrick authored
      Fixes #34640
      
      Change-Id: I4a6c9414fe369cd5e9915472331c4bd8a21d8b0e
      Reviewed-on: https://go-review.googlesource.com/c/go/+/198457Reviewed-by: default avatarFilippo Valsorda <filippo@golang.org>
      0ba0ea17
    • Ruixin(Peter) Bao's avatar
      cmd/compile/internal/gc: intrinsify mulWW on s390x · ac2ceba0
      Ruixin(Peter) Bao authored
      SSA rule have already been added previously to intrisinfy Mul/Mul64 on s390x. In this CL,
      we want to let mulWW use that SSA rule as well. Also removed an extra line for formatting.
      
      Benchmarks:
      QuoRem-18                            3.59µs ±15%    2.94µs ± 3%  -18.06%  (p=0.000 n=8+8)
      ModSqrt225_Tonelli-18                 806µs ± 0%     800µs ± 0%   -0.85%  (p=0.000 n=7+8)
      ModSqrt225_3Mod4-18                   245µs ± 1%     243µs ± 0%   -0.81%  (p=0.001 n=8+8)
      ModSqrt231_Tonelli-18                 837µs ± 0%     834µs ± 1%   -0.36%  (p=0.028 n=8+8)
      ModSqrt231_5Mod8-18                   282µs ± 0%     280µs ± 0%   -0.76%  (p=0.000 n=8+8)
      Sqrt-18                              45.8µs ± 2%    38.6µs ± 0%  -15.63%  (p=0.000 n=8+8)
      IntSqr/1-18                          19.1ns ± 0%    13.1ns ± 0%  -31.41%  (p=0.000 n=8+8)
      IntSqr/2-18                          48.3ns ± 2%    48.2ns ± 0%     ~     (p=0.094 n=8+8)
      IntSqr/3-18                          70.5ns ± 1%    70.7ns ± 0%     ~     (p=0.428 n=8+8)
      IntSqr/5-18                           119ns ± 1%     118ns ± 0%   -1.02%  (p=0.000 n=7+8)
      IntSqr/8-18                           215ns ± 1%     215ns ± 0%     ~     (p=0.320 n=8+7)
      IntSqr/10-18                          302ns ± 1%     301ns ± 0%     ~     (p=0.148 n=8+7)
      IntSqr/20-18                          952ns ± 1%     807ns ± 0%  -15.28%  (p=0.000 n=8+8)
      IntSqr/30-18                         1.74µs ± 0%    1.53µs ± 0%  -11.93%  (p=0.000 n=8+8)
      IntSqr/50-18                         3.91µs ± 0%    3.57µs ± 0%   -8.64%  (p=0.000 n=7+8)
      IntSqr/80-18                         8.66µs ± 1%    8.11µs ± 0%   -6.39%  (p=0.000 n=8+8)
      IntSqr/100-18                        12.8µs ± 0%    12.2µs ± 0%   -5.19%  (p=0.000 n=8+8)
      IntSqr/200-18                        46.0µs ± 0%    44.5µs ± 0%   -3.06%  (p=0.000 n=8+8)
      IntSqr/300-18                        81.4µs ± 0%    78.4µs ± 0%   -3.71%  (p=0.000 n=7+8)
      IntSqr/500-18                         212µs ± 1%     206µs ± 0%   -2.66%  (p=0.000 n=8+8)
      IntSqr/800-18                         419µs ± 1%     406µs ± 0%   -3.07%  (p=0.000 n=8+8)
      IntSqr/1000-18                        635µs ± 0%     621µs ± 0%   -2.13%  (p=0.000 n=8+8)
      
      Change-Id: Ib097857186932b902601ab087cbeff3fc9555c3e
      Reviewed-on: https://go-review.googlesource.com/c/go/+/197639
      Run-TryBot: Emmanuel Odeke <emm.odeke@gmail.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarKeith Randall <khr@golang.org>
      ac2ceba0
    • Michael Munday's avatar
      cmd/compile: allow multiple SSA block control values · 9c2e7e8b
      Michael Munday authored
      Control values are used to choose which successor of a block is
      jumped to. Typically a control value takes the form of a 'flags'
      value that represents the result of a comparison. Some
      architectures however use a variable in a register as a control
      value.
      
      Up until now we have managed with a single control value per block.
      However some architectures (e.g. s390x and riscv64) have combined
      compare-and-branch instructions that take two variables in registers
      as parameters. To generate these instructions we need to support 2
      control values per block.
      
      This CL allows up to 2 control values to be used in a block in
      order to support the addition of compare-and-branch instructions.
      I have implemented s390x compare-and-branch instructions in a
      different CL.
      
      Passes toolstash-check -all.
      
      Results of compilebench:
      
      name                      old time/op       new time/op       delta
      Template                        208ms ± 1%        209ms ± 1%    ~     (p=0.289 n=20+20)
      Unicode                        83.7ms ± 1%       83.3ms ± 3%  -0.49%  (p=0.017 n=18+18)
      GoTypes                         748ms ± 1%        748ms ± 0%    ~     (p=0.460 n=20+18)
      Compiler                        3.47s ± 1%        3.48s ± 1%    ~     (p=0.070 n=19+18)
      SSA                             11.5s ± 1%        11.7s ± 1%  +1.64%  (p=0.000 n=19+18)
      Flate                           130ms ± 1%        130ms ± 1%    ~     (p=0.588 n=19+20)
      GoParser                        160ms ± 1%        161ms ± 1%    ~     (p=0.211 n=20+20)
      Reflect                         465ms ± 1%        467ms ± 1%  +0.42%  (p=0.007 n=20+20)
      Tar                             184ms ± 1%        185ms ± 2%    ~     (p=0.087 n=18+20)
      XML                             253ms ± 1%        253ms ± 1%    ~     (p=0.377 n=20+18)
      LinkCompiler                    769ms ± 2%        774ms ± 2%    ~     (p=0.070 n=19+19)
      ExternalLinkCompiler            3.59s ±11%        3.68s ± 6%    ~     (p=0.072 n=20+20)
      LinkWithoutDebugCompiler        446ms ± 5%        454ms ± 3%  +1.79%  (p=0.002 n=19+20)
      StdCmd                          26.0s ± 2%        26.0s ± 2%    ~     (p=0.799 n=20+20)
      
      name                      old user-time/op  new user-time/op  delta
      Template                        238ms ± 5%        240ms ± 5%    ~     (p=0.142 n=20+20)
      Unicode                         105ms ±11%        106ms ±10%    ~     (p=0.512 n=20+20)
      GoTypes                         876ms ± 2%        873ms ± 4%    ~     (p=0.647 n=20+19)
      Compiler                        4.17s ± 2%        4.19s ± 1%    ~     (p=0.093 n=20+18)
      SSA                             13.9s ± 1%        14.1s ± 1%  +1.45%  (p=0.000 n=18+18)
      Flate                           145ms ±13%        146ms ± 5%    ~     (p=0.851 n=20+18)
      GoParser                        185ms ± 5%        188ms ± 7%    ~     (p=0.174 n=20+20)
      Reflect                         534ms ± 3%        538ms ± 2%    ~     (p=0.105 n=20+18)
      Tar                             215ms ± 4%        211ms ± 9%    ~     (p=0.079 n=19+20)
      XML                             295ms ± 6%        295ms ± 5%    ~     (p=0.968 n=20+20)
      LinkCompiler                    832ms ± 4%        837ms ± 7%    ~     (p=0.707 n=17+20)
      ExternalLinkCompiler            1.58s ± 8%        1.60s ± 4%    ~     (p=0.296 n=20+19)
      LinkWithoutDebugCompiler        478ms ±12%        489ms ±10%    ~     (p=0.429 n=20+20)
      
      name                      old object-bytes  new object-bytes  delta
      Template                        559kB ± 0%        559kB ± 0%    ~     (all equal)
      Unicode                         216kB ± 0%        216kB ± 0%    ~     (all equal)
      GoTypes                        2.03MB ± 0%       2.03MB ± 0%    ~     (all equal)
      Compiler                       8.07MB ± 0%       8.07MB ± 0%  -0.06%  (p=0.000 n=20+20)
      SSA                            27.1MB ± 0%       27.3MB ± 0%  +0.89%  (p=0.000 n=20+20)
      Flate                           343kB ± 0%        343kB ± 0%    ~     (all equal)
      GoParser                        441kB ± 0%        441kB ± 0%    ~     (all equal)
      Reflect                        1.36MB ± 0%       1.36MB ± 0%    ~     (all equal)
      Tar                             487kB ± 0%        487kB ± 0%    ~     (all equal)
      XML                             632kB ± 0%        632kB ± 0%    ~     (all equal)
      
      name                      old export-bytes  new export-bytes  delta
      Template                       18.5kB ± 0%       18.5kB ± 0%    ~     (all equal)
      Unicode                        7.92kB ± 0%       7.92kB ± 0%    ~     (all equal)
      GoTypes                        35.0kB ± 0%       35.0kB ± 0%    ~     (all equal)
      Compiler                        109kB ± 0%        110kB ± 0%  +0.72%  (p=0.000 n=20+20)
      SSA                             137kB ± 0%        138kB ± 0%  +0.58%  (p=0.000 n=20+20)
      Flate                          4.89kB ± 0%       4.89kB ± 0%    ~     (all equal)
      GoParser                       8.49kB ± 0%       8.49kB ± 0%    ~     (all equal)
      Reflect                        11.4kB ± 0%       11.4kB ± 0%    ~     (all equal)
      Tar                            10.5kB ± 0%       10.5kB ± 0%    ~     (all equal)
      XML                            16.7kB ± 0%       16.7kB ± 0%    ~     (all equal)
      
      name                      old text-bytes    new text-bytes    delta
      HelloSize                       761kB ± 0%        761kB ± 0%    ~     (all equal)
      CmdGoSize                      10.8MB ± 0%       10.8MB ± 0%    ~     (all equal)
      
      name                      old data-bytes    new data-bytes    delta
      HelloSize                      10.7kB ± 0%       10.7kB ± 0%    ~     (all equal)
      CmdGoSize                       312kB ± 0%        312kB ± 0%    ~     (all equal)
      
      name                      old bss-bytes     new bss-bytes     delta
      HelloSize                       122kB ± 0%        122kB ± 0%    ~     (all equal)
      CmdGoSize                       146kB ± 0%        146kB ± 0%    ~     (all equal)
      
      name                      old exe-bytes     new exe-bytes     delta
      HelloSize                      1.13MB ± 0%       1.13MB ± 0%    ~     (all equal)
      CmdGoSize                      15.1MB ± 0%       15.1MB ± 0%    ~     (all equal)
      
      Change-Id: I3cc2f9829a109543d9a68be4a21775d2d3e9801f
      Reviewed-on: https://go-review.googlesource.com/c/go/+/196557
      Run-TryBot: Michael Munday <mike.munday@ibm.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarDaniel Martí <mvdan@mvdan.cc>
      Reviewed-by: default avatarKeith Randall <khr@golang.org>
      9c2e7e8b
    • Jason A. Donenfeld's avatar
      cmd/link: implement Msync for Windows using FlushViewOfFile · 274f4cef
      Jason A. Donenfeld authored
      CL 196846 implemented memory mapped output files but forgot to provide
      an implementation for Msync. This rectifies that with a simple call to
      FlushViewOfFile.
      
      Change-Id: I5aebef9baf3a2a6ad54ceda096952a5d7d660bfe
      Reviewed-on: https://go-review.googlesource.com/c/go/+/198418
      Run-TryBot: Jason A. Donenfeld <Jason@zx2c4.com>
      Reviewed-by: default avatarAlex Brainman <alex.brainman@gmail.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      274f4cef
    • Kyohei Kadota's avatar
      net/http/cgi: skip tests if not functional perl · 148ec3e3
      Kyohei Kadota authored
      TestEnvOverride sets PATH to /wibble before executing a CGI.
      So customized Perl that is starting with '#!/usr/bin/env bash' will fail
      because /usr/bin/env can't lookup bash.
      
      Fixes #27790
      
      Change-Id: I25e433061a7ff9da8c86429e934418fc15f12f90
      Reviewed-on: https://go-review.googlesource.com/c/go/+/196845Reviewed-by: default avatarBrad Fitzpatrick <bradfitz@golang.org>
      Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      148ec3e3
    • Emmanuel T Odeke's avatar
      os/signal: lazily start signal watch loop only on Notify · e79b57d6
      Emmanuel T Odeke authored
      By lazily starting the signal watch loop only on Notify,
      we are able to have deadlock detection even when
      "os/signal" is imported.
      
      Thanks to Ian Lance Taylor for the solution and discussion.
      
      With this change in, fix a runtime gorountine count test that
      assumed that os/signal.init would unconditionally start the
      signal watching goroutine, but alas no more.
      
      Fixes #21576.
      
      Change-Id: I6eecf82a887f59f2ec8897f1bcd67ca311ca42ff
      Reviewed-on: https://go-review.googlesource.com/c/go/+/101036
      Run-TryBot: Emmanuel Odeke <emm.odeke@gmail.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarIan Lance Taylor <iant@golang.org>
      e79b57d6
  4. 01 Oct, 2019 5 commits