1. 30 Aug, 2018 13 commits
  2. 29 Aug, 2018 6 commits
    • Alexey Alexandrov's avatar
      runtime/pprof: compute memory profile block size using sampled values · f9a4ae01
      Alexey Alexandrov authored
      Fixes #26638.
      
      Change-Id: I3c18d1298d99af8ea8c00916303efd2b5a5effc7
      Reviewed-on: https://go-review.googlesource.com/126336Reviewed-by: 's avatarHyang-Ah Hana Kim <hyangah@gmail.com>
      Run-TryBot: Hyang-Ah Hana Kim <hyangah@gmail.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      f9a4ae01
    • Alberto Donizetti's avatar
      bytes: note that NewBuffer's initial size can change · c64006ab
      Alberto Donizetti authored
      bytes.NewBuffer's documentation says it can be used to set the initial
      size of the buffer. The current wording is:
      
      > It can also be used to size the internal buffer for writing.
      
      This may led users to believe that the buffer (its backing array) is
      fixed in size and won't grow, which isn't true (subsequent Write calls
      will expand the backing array as needed).
      
      Change the doc to make it clearer that NewBuffer just sets the initial
      size of the buffer.
      
      Fixes #27242
      
      Change-Id: I2a8cb5bee02ca2c1657ef59e2cf1434c7a9bd397
      Reviewed-on: https://go-review.googlesource.com/132035Reviewed-by: 's avatarDominik Honnef <dominik@honnef.co>
      Reviewed-by: 's avatarIan Lance Taylor <iant@golang.org>
      c64006ab
    • Daniel Martí's avatar
      text/template: fix newline counting in raw strings · 6fa08c0f
      Daniel Martí authored
      lexRawQuote already uses the next method, which keeps track of newlines
      on a character by character basis. Adding up newlines in emit again
      results in the newlines being counted twice, which can mean bad position
      information in error messages.
      
      Fix that, and add a test.
      
      Fixes #27319.
      
      Change-Id: Id803be065c541412dc808d388bc6d8a86a0de41e
      Reviewed-on: https://go-review.googlesource.com/131996
      Run-TryBot: Daniel Martí <mvdan@mvdan.cc>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: 's avatarIan Lance Taylor <iant@golang.org>
      6fa08c0f
    • Zheng Xu's avatar
      build: support frame-pointer for arm64 · 8f4fd3f3
      Zheng Xu authored
      Supporting frame-pointer makes Linux's perf and other profilers much more useful
      because it lets them gather a stack trace efficiently on profiling events. Major
      changes include:
      1. save FP on the word below where RSP is pointing to (proposed by Cherry and Austin)
      2. adjust some specific offsets in runtime assembly and wrapper code
      3. add support to FP in goroutine scheduler
      4. adjust link stack overflow check to take the extra word into account
      5. adjust nosplit test cases to enable frame sizes which are 16 bytes aligned
      
      Performance impacts on go1 benchmarks:
      
      Enable frame-pointer (by default)
      
      name                      old time/op    new time/op    delta
      BinaryTree17-46              5.94s ± 0%     6.00s ± 0%  +1.03%  (p=0.029 n=4+4)
      Fannkuch11-46                2.84s ± 1%     2.77s ± 0%  -2.58%  (p=0.008 n=5+5)
      FmtFprintfEmpty-46          55.0ns ± 1%    58.9ns ± 1%  +7.06%  (p=0.008 n=5+5)
      FmtFprintfString-46          102ns ± 0%     105ns ± 0%  +2.94%  (p=0.008 n=5+5)
      FmtFprintfInt-46             118ns ± 0%     117ns ± 1%  -1.19%  (p=0.000 n=4+5)
      FmtFprintfIntInt-46          181ns ± 0%     182ns ± 1%    ~     (p=0.444 n=5+5)
      FmtFprintfPrefixedInt-46     215ns ± 1%     214ns ± 0%    ~     (p=0.254 n=5+4)
      FmtFprintfFloat-46           292ns ± 0%     296ns ± 0%  +1.46%  (p=0.029 n=4+4)
      FmtManyArgs-46               720ns ± 0%     732ns ± 0%  +1.72%  (p=0.008 n=5+5)
      GobDecode-46                9.82ms ± 1%   10.03ms ± 2%  +2.10%  (p=0.008 n=5+5)
      GobEncode-46                8.14ms ± 0%    8.72ms ± 1%  +7.14%  (p=0.008 n=5+5)
      Gzip-46                      420ms ± 0%     424ms ± 0%  +0.92%  (p=0.008 n=5+5)
      Gunzip-46                   48.2ms ± 0%    48.4ms ± 0%  +0.41%  (p=0.008 n=5+5)
      HTTPClientServer-46          201µs ± 4%     201µs ± 0%    ~     (p=0.730 n=5+4)
      JSONEncode-46               17.1ms ± 0%    17.7ms ± 1%  +3.80%  (p=0.008 n=5+5)
      JSONDecode-46               88.0ms ± 0%    90.1ms ± 0%  +2.42%  (p=0.008 n=5+5)
      Mandelbrot200-46            5.06ms ± 0%    5.07ms ± 0%    ~     (p=0.310 n=5+5)
      GoParse-46                  5.04ms ± 0%    5.12ms ± 0%  +1.53%  (p=0.008 n=5+5)
      RegexpMatchEasy0_32-46       117ns ± 0%     117ns ± 0%    ~     (all equal)
      RegexpMatchEasy0_1K-46       332ns ± 0%     329ns ± 0%  -0.78%  (p=0.008 n=5+5)
      RegexpMatchEasy1_32-46       104ns ± 0%     113ns ± 0%  +8.65%  (p=0.029 n=4+4)
      RegexpMatchEasy1_1K-46       563ns ± 0%     569ns ± 0%  +1.10%  (p=0.008 n=5+5)
      RegexpMatchMedium_32-46      167ns ± 2%     177ns ± 1%  +5.74%  (p=0.008 n=5+5)
      RegexpMatchMedium_1K-46     49.5µs ± 0%    53.4µs ± 0%  +7.81%  (p=0.008 n=5+5)
      RegexpMatchHard_32-46       2.56µs ± 1%    2.72µs ± 0%  +6.01%  (p=0.008 n=5+5)
      RegexpMatchHard_1K-46       77.0µs ± 0%    81.8µs ± 0%  +6.24%  (p=0.016 n=5+4)
      Revcomp-46                   631ms ± 1%     627ms ± 1%    ~     (p=0.095 n=5+5)
      Template-46                 81.8ms ± 0%    86.3ms ± 0%  +5.55%  (p=0.008 n=5+5)
      TimeParse-46                 423ns ± 0%     432ns ± 0%  +2.32%  (p=0.008 n=5+5)
      TimeFormat-46                478ns ± 2%     497ns ± 1%  +3.89%  (p=0.008 n=5+5)
      [Geo mean]                  71.6µs         73.3µs       +2.45%
      
      name                      old speed      new speed      delta
      GobDecode-46              78.1MB/s ± 1%  76.6MB/s ± 2%  -2.04%  (p=0.008 n=5+5)
      GobEncode-46              94.3MB/s ± 0%  88.0MB/s ± 1%  -6.67%  (p=0.008 n=5+5)
      Gzip-46                   46.2MB/s ± 0%  45.8MB/s ± 0%  -0.91%  (p=0.008 n=5+5)
      Gunzip-46                  403MB/s ± 0%   401MB/s ± 0%  -0.41%  (p=0.008 n=5+5)
      JSONEncode-46              114MB/s ± 0%   109MB/s ± 1%  -3.66%  (p=0.008 n=5+5)
      JSONDecode-46             22.0MB/s ± 0%  21.5MB/s ± 0%  -2.35%  (p=0.008 n=5+5)
      GoParse-46                11.5MB/s ± 0%  11.3MB/s ± 0%  -1.51%  (p=0.008 n=5+5)
      RegexpMatchEasy0_32-46     272MB/s ± 0%   272MB/s ± 1%    ~     (p=0.190 n=4+5)
      RegexpMatchEasy0_1K-46    3.08GB/s ± 0%  3.11GB/s ± 0%  +0.77%  (p=0.008 n=5+5)
      RegexpMatchEasy1_32-46     306MB/s ± 0%   283MB/s ± 0%  -7.63%  (p=0.029 n=4+4)
      RegexpMatchEasy1_1K-46    1.82GB/s ± 0%  1.80GB/s ± 0%  -1.07%  (p=0.008 n=5+5)
      RegexpMatchMedium_32-46   5.99MB/s ± 0%  5.64MB/s ± 1%  -5.77%  (p=0.016 n=4+5)
      RegexpMatchMedium_1K-46   20.7MB/s ± 0%  19.2MB/s ± 0%  -7.25%  (p=0.008 n=5+5)
      RegexpMatchHard_32-46     12.5MB/s ± 1%  11.8MB/s ± 0%  -5.66%  (p=0.008 n=5+5)
      RegexpMatchHard_1K-46     13.3MB/s ± 0%  12.5MB/s ± 1%  -6.01%  (p=0.008 n=5+5)
      Revcomp-46                 402MB/s ± 1%   405MB/s ± 1%    ~     (p=0.095 n=5+5)
      Template-46               23.7MB/s ± 0%  22.5MB/s ± 0%  -5.25%  (p=0.008 n=5+5)
      [Geo mean]                82.2MB/s       79.6MB/s       -3.26%
      
      Disable frame-pointer (GOEXPERIMENT=noframepointer)
      
      name                      old time/op    new time/op    delta
      BinaryTree17-46              5.94s ± 0%     5.96s ± 0%  +0.39%  (p=0.029 n=4+4)
      Fannkuch11-46                2.84s ± 1%     2.79s ± 1%  -1.68%  (p=0.008 n=5+5)
      FmtFprintfEmpty-46          55.0ns ± 1%    55.2ns ± 3%    ~     (p=0.794 n=5+5)
      FmtFprintfString-46          102ns ± 0%     103ns ± 0%  +0.98%  (p=0.016 n=5+4)
      FmtFprintfInt-46             118ns ± 0%     115ns ± 0%  -2.54%  (p=0.029 n=4+4)
      FmtFprintfIntInt-46          181ns ± 0%     179ns ± 0%  -1.10%  (p=0.000 n=5+4)
      FmtFprintfPrefixedInt-46     215ns ± 1%     213ns ± 0%    ~     (p=0.143 n=5+4)
      FmtFprintfFloat-46           292ns ± 0%     300ns ± 0%  +2.83%  (p=0.029 n=4+4)
      FmtManyArgs-46               720ns ± 0%     739ns ± 0%  +2.64%  (p=0.008 n=5+5)
      GobDecode-46                9.82ms ± 1%    9.78ms ± 1%    ~     (p=0.151 n=5+5)
      GobEncode-46                8.14ms ± 0%    8.12ms ± 1%    ~     (p=0.690 n=5+5)
      Gzip-46                      420ms ± 0%     420ms ± 0%    ~     (p=0.548 n=5+5)
      Gunzip-46                   48.2ms ± 0%    48.0ms ± 0%  -0.33%  (p=0.032 n=5+5)
      HTTPClientServer-46          201µs ± 4%     199µs ± 3%    ~     (p=0.548 n=5+5)
      JSONEncode-46               17.1ms ± 0%    17.2ms ± 0%    ~     (p=0.056 n=5+5)
      JSONDecode-46               88.0ms ± 0%    88.6ms ± 0%  +0.64%  (p=0.008 n=5+5)
      Mandelbrot200-46            5.06ms ± 0%    5.07ms ± 0%    ~     (p=0.548 n=5+5)
      GoParse-46                  5.04ms ± 0%    5.07ms ± 0%  +0.65%  (p=0.008 n=5+5)
      RegexpMatchEasy0_32-46       117ns ± 0%     112ns ± 4%  -4.27%  (p=0.016 n=4+5)
      RegexpMatchEasy0_1K-46       332ns ± 0%     330ns ± 1%    ~     (p=0.095 n=5+5)
      RegexpMatchEasy1_32-46       104ns ± 0%     110ns ± 1%  +5.29%  (p=0.029 n=4+4)
      RegexpMatchEasy1_1K-46       563ns ± 0%     567ns ± 2%    ~     (p=0.151 n=5+5)
      RegexpMatchMedium_32-46      167ns ± 2%     166ns ± 0%    ~     (p=0.333 n=5+4)
      RegexpMatchMedium_1K-46     49.5µs ± 0%    49.6µs ± 0%    ~     (p=0.841 n=5+5)
      RegexpMatchHard_32-46       2.56µs ± 1%    2.49µs ± 0%  -2.81%  (p=0.008 n=5+5)
      RegexpMatchHard_1K-46       77.0µs ± 0%    75.8µs ± 0%  -1.55%  (p=0.008 n=5+5)
      Revcomp-46                   631ms ± 1%     628ms ± 0%    ~     (p=0.095 n=5+5)
      Template-46                 81.8ms ± 0%    84.3ms ± 1%  +3.05%  (p=0.008 n=5+5)
      TimeParse-46                 423ns ± 0%     425ns ± 0%  +0.52%  (p=0.008 n=5+5)
      TimeFormat-46                478ns ± 2%     478ns ± 1%    ~     (p=1.000 n=5+5)
      [Geo mean]                  71.6µs         71.6µs       -0.01%
      
      name                      old speed      new speed      delta
      GobDecode-46              78.1MB/s ± 1%  78.5MB/s ± 1%    ~     (p=0.151 n=5+5)
      GobEncode-46              94.3MB/s ± 0%  94.5MB/s ± 1%    ~     (p=0.690 n=5+5)
      Gzip-46                   46.2MB/s ± 0%  46.2MB/s ± 0%    ~     (p=0.571 n=5+5)
      Gunzip-46                  403MB/s ± 0%   404MB/s ± 0%  +0.33%  (p=0.032 n=5+5)
      JSONEncode-46              114MB/s ± 0%   113MB/s ± 0%    ~     (p=0.056 n=5+5)
      JSONDecode-46             22.0MB/s ± 0%  21.9MB/s ± 0%  -0.64%  (p=0.008 n=5+5)
      GoParse-46                11.5MB/s ± 0%  11.4MB/s ± 0%  -0.64%  (p=0.008 n=5+5)
      RegexpMatchEasy0_32-46     272MB/s ± 0%   285MB/s ± 4%  +4.74%  (p=0.016 n=4+5)
      RegexpMatchEasy0_1K-46    3.08GB/s ± 0%  3.10GB/s ± 1%    ~     (p=0.151 n=5+5)
      RegexpMatchEasy1_32-46     306MB/s ± 0%   290MB/s ± 1%  -5.21%  (p=0.029 n=4+4)
      RegexpMatchEasy1_1K-46    1.82GB/s ± 0%  1.81GB/s ± 2%    ~     (p=0.151 n=5+5)
      RegexpMatchMedium_32-46   5.99MB/s ± 0%  6.02MB/s ± 1%    ~     (p=0.063 n=4+5)
      RegexpMatchMedium_1K-46   20.7MB/s ± 0%  20.7MB/s ± 0%    ~     (p=0.659 n=5+5)
      RegexpMatchHard_32-46     12.5MB/s ± 1%  12.8MB/s ± 0%  +2.88%  (p=0.008 n=5+5)
      RegexpMatchHard_1K-46     13.3MB/s ± 0%  13.5MB/s ± 0%  +1.58%  (p=0.008 n=5+5)
      Revcomp-46                 402MB/s ± 1%   405MB/s ± 0%    ~     (p=0.095 n=5+5)
      Template-46               23.7MB/s ± 0%  23.0MB/s ± 1%  -2.95%  (p=0.008 n=5+5)
      [Geo mean]                82.2MB/s       82.3MB/s       +0.04%
      
      Frame-pointer is enabled on Linux by default but can be disabled by setting: GOEXPERIMENT=noframepointer.
      
      Fixes #10110
      
      Change-Id: I1bfaca6dba29a63009d7c6ab04ed7a1413d9479e
      Reviewed-on: https://go-review.googlesource.com/61511Reviewed-by: 's avatarCherry Zhang <cherryyz@google.com>
      Run-TryBot: Cherry Zhang <cherryyz@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      8f4fd3f3
    • Than McIntosh's avatar
      cmd/compile: remove var sorting from DWARF inline generation · 7b88b22a
      Than McIntosh authored
      When generation DWARF inline info records, the current implementation
      includes a sorting pass that reorders a subprogram's child variable
      DIEs based on class (param/auto) and name. This sorting is no longer
      needed, and can cause problems for a debugger (if we want to use the
      DWARF info for creating a call to an optimized function); this patch
      removes it.
      
      Ordering of DWARF subprogram variable/parameter DIEs is still
      deterministic with this change, since it is keyed off the order in
      which vars appear in the pre-inlining function "Dcl" list.
      
      Updates #27039
      
      Change-Id: I3b91290d11bb3b9b36fb61271d80b801841401ee
      Reviewed-on: https://go-review.googlesource.com/131895Reviewed-by: 's avatarHeschi Kreinick <heschi@google.com>
      7b88b22a
    • Ben Shi's avatar
      syscall: skip an unsupported test case on android · 225981f8
      Ben Shi authored
      Lookup is not supported on android, and the test
      syscall/exec_linux_test.go which relies on it will fail on
      android/arm64.
      
      Fixes #27327
      
      Change-Id: I6fdb8992d4634ac7e3689360ff114e9431b5e90c
      Reviewed-on: https://go-review.googlesource.com/131995Reviewed-by: 's avatarBrad Fitzpatrick <bradfitz@golang.org>
      225981f8
  3. 28 Aug, 2018 13 commits
  4. 27 Aug, 2018 3 commits
    • Ben Shi's avatar
      cmd/compile: optimize arm's comparison · 2b69ad0b
      Ben Shi authored
      The CMP/CMN/TST/TEQ perform similar to SUB/ADD/AND/XOR except
      the result is abondoned, and only NZCV flags are affected.
      
      This CL implements further optimization with them.
      
      1. A micro benchmark test gets more than 9% improvment.
      TSTTEQ-4                   6.99ms ± 0%    6.35ms ± 0%  -9.15%  (p=0.000 n=33+36)
      (https://github.com/benshi001/ugo1/blob/master/tstteq2_test.go)
      
      2. The go1 benckmark shows no regression, excluding noise.
      name                     old time/op    new time/op    delta
      BinaryTree17-4              25.7s ± 1%     25.7s ± 1%    ~     (p=0.830 n=40+40)
      Fannkuch11-4                13.3s ± 0%     13.2s ± 0%  -0.65%  (p=0.000 n=40+34)
      FmtFprintfEmpty-4           394ns ± 0%     394ns ± 0%    ~     (p=0.819 n=40+40)
      FmtFprintfString-4          677ns ± 0%     677ns ± 0%  +0.06%  (p=0.039 n=39+40)
      FmtFprintfInt-4             707ns ± 0%     706ns ± 0%  -0.14%  (p=0.000 n=40+39)
      FmtFprintfIntInt-4         1.04µs ± 0%    1.04µs ± 0%  +0.10%  (p=0.000 n=29+31)
      FmtFprintfPrefixedInt-4    1.10µs ± 0%    1.11µs ± 0%  +0.65%  (p=0.000 n=39+37)
      FmtFprintfFloat-4          2.27µs ± 0%    2.26µs ± 0%  -0.53%  (p=0.000 n=39+40)
      FmtManyArgs-4              3.96µs ± 0%    3.96µs ± 0%  +0.10%  (p=0.000 n=39+40)
      GobDecode-4                53.4ms ± 1%    52.8ms ± 2%  -1.10%  (p=0.000 n=39+39)
      GobEncode-4                50.3ms ± 3%    50.4ms ± 2%    ~     (p=0.089 n=40+39)
      Gzip-4                      2.62s ± 0%     2.64s ± 0%  +0.60%  (p=0.000 n=40+39)
      Gunzip-4                    312ms ± 0%     312ms ± 0%  +0.02%  (p=0.030 n=40+39)
      HTTPClientServer-4         1.01ms ± 7%    0.98ms ± 7%  -2.37%  (p=0.000 n=40+39)
      JSONEncode-4                126ms ± 1%     126ms ± 1%  -0.38%  (p=0.004 n=39+39)
      JSONDecode-4                423ms ± 0%     426ms ± 2%  +0.72%  (p=0.001 n=39+40)
      Mandelbrot200-4            18.4ms ± 0%    18.4ms ± 0%  +0.04%  (p=0.000 n=38+40)
      GoParse-4                  22.8ms ± 0%    22.6ms ± 0%  -0.68%  (p=0.000 n=35+40)
      RegexpMatchEasy0_32-4       699ns ± 0%     704ns ± 0%  +0.73%  (p=0.000 n=27+40)
      RegexpMatchEasy0_1K-4      4.27µs ± 0%    4.26µs ± 0%  -0.09%  (p=0.000 n=35+38)
      RegexpMatchEasy1_32-4       741ns ± 0%     735ns ± 0%  -0.85%  (p=0.000 n=40+35)
      RegexpMatchEasy1_1K-4      5.53µs ± 0%    5.49µs ± 0%  -0.69%  (p=0.000 n=39+40)
      RegexpMatchMedium_32-4     1.07µs ± 0%    1.04µs ± 2%  -2.34%  (p=0.000 n=40+40)
      RegexpMatchMedium_1K-4      261µs ± 0%     261µs ± 0%  -0.16%  (p=0.000 n=40+39)
      RegexpMatchHard_32-4       14.9µs ± 0%    14.9µs ± 0%  -0.18%  (p=0.000 n=39+40)
      RegexpMatchHard_1K-4        445µs ± 0%     446µs ± 0%  +0.09%  (p=0.000 n=36+34)
      Revcomp-4                  41.8ms ± 1%    41.8ms ± 1%    ~     (p=0.595 n=39+38)
      Template-4                  530ms ± 1%     528ms ± 1%  -0.49%  (p=0.000 n=40+40)
      TimeParse-4                3.39µs ± 0%    3.42µs ± 0%  +0.98%  (p=0.000 n=36+38)
      TimeFormat-4               6.12µs ± 0%    6.07µs ± 0%  -0.81%  (p=0.000 n=34+38)
      [Geo mean]                  384µs          383µs       -0.24%
      
      name                     old speed      new speed      delta
      GobDecode-4              14.4MB/s ± 1%  14.5MB/s ± 2%  +1.11%  (p=0.000 n=39+39)
      GobEncode-4              15.3MB/s ± 3%  15.2MB/s ± 2%    ~     (p=0.104 n=40+39)
      Gzip-4                   7.40MB/s ± 1%  7.36MB/s ± 0%  -0.60%  (p=0.000 n=40+39)
      Gunzip-4                 62.2MB/s ± 0%  62.1MB/s ± 0%  -0.02%  (p=0.047 n=40+39)
      JSONEncode-4             15.4MB/s ± 1%  15.4MB/s ± 2%  +0.39%  (p=0.002 n=39+39)
      JSONDecode-4             4.59MB/s ± 0%  4.56MB/s ± 2%  -0.71%  (p=0.000 n=39+40)
      GoParse-4                2.54MB/s ± 0%  2.56MB/s ± 0%  +0.72%  (p=0.000 n=26+40)
      RegexpMatchEasy0_32-4    45.8MB/s ± 0%  45.4MB/s ± 0%  -0.75%  (p=0.000 n=38+40)
      RegexpMatchEasy0_1K-4     240MB/s ± 0%   240MB/s ± 0%  +0.09%  (p=0.000 n=35+38)
      RegexpMatchEasy1_32-4    43.1MB/s ± 0%  43.5MB/s ± 0%  +0.84%  (p=0.000 n=40+39)
      RegexpMatchEasy1_1K-4     185MB/s ± 0%   186MB/s ± 0%  +0.69%  (p=0.000 n=39+40)
      RegexpMatchMedium_32-4    936kB/s ± 1%   959kB/s ± 2%  +2.38%  (p=0.000 n=40+40)
      RegexpMatchMedium_1K-4   3.92MB/s ± 0%  3.93MB/s ± 0%  +0.18%  (p=0.000 n=39+40)
      RegexpMatchHard_32-4     2.15MB/s ± 0%  2.15MB/s ± 0%  +0.19%  (p=0.000 n=40+40)
      RegexpMatchHard_1K-4     2.30MB/s ± 0%  2.30MB/s ± 0%    ~     (all equal)
      Revcomp-4                60.8MB/s ± 1%  60.8MB/s ± 1%    ~     (p=0.600 n=39+38)
      Template-4               3.66MB/s ± 1%  3.68MB/s ± 1%  +0.46%  (p=0.000 n=40+40)
      [Geo mean]               12.8MB/s       12.8MB/s       +0.27%
      
      Change-Id: I849161169ecf0876a04b7c1d3990fa8d1435215e
      Reviewed-on: https://go-review.googlesource.com/122855
      Run-TryBot: Cherry Zhang <cherryyz@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: 's avatarCherry Zhang <cherryyz@google.com>
      2b69ad0b
    • Ben Shi's avatar
      cmd/compile: add missing type information for some arm/arm64 rules · 096229b2
      Ben Shi authored
      Some indexed load/store rules lack of type information, and this
      CL adds that for them.
      
      Change-Id: Icac315ccb83a2f5bf30b056d4667d5b59eb4e5e2
      Reviewed-on: https://go-review.googlesource.com/128455Reviewed-by: 's avatarCherry Zhang <cherryyz@google.com>
      Run-TryBot: Cherry Zhang <cherryyz@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      096229b2
    • Benny Siegert's avatar
      cmd/dist: do not run race detector tests on netbsd · 7334904e
      Benny Siegert authored
      The race detector is not fully functional on NetBSD yet. Without
      this change, all.bash fails in TestOutput.
      
      This unbreaks the netbsd-amd64 builder.
      
      Update #26403
      Fixes #27268
      
      Change-Id: I2c7015692d3632aa1037f40155d4fc5c7bb1d8c3
      Reviewed-on: https://go-review.googlesource.com/131555Reviewed-by: 's avatarBrad Fitzpatrick <bradfitz@golang.org>
      Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      7334904e
  5. 26 Aug, 2018 5 commits
    • Alberto Donizetti's avatar
      cmd/compile: prevent overflow in walkinrange · 42cc4ca3
      Alberto Donizetti authored
      In the compiler frontend, walkinrange indiscriminately calls Int64()
      on const CTINT nodes, even though Int64's return value is undefined
      for anything over 2⁶³ (in practise, it'll return a negative number).
      
      This causes the introduction of bad constants during rewrites of
      unsigned expressions, which make the compiler reject valid Go
      programs.
      
      This change introduces a preliminary check that Int64() is safe to
      call on the consts on hand. If it isn't, walkinrange exits without
      doing any rewrite.
      
      Fixes #27143
      
      Change-Id: I2017073cae65468a521ff3262d4ea8ab0d7098d9
      Reviewed-on: https://go-review.googlesource.com/130735
      Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: 's avatarJosh Bleecher Snyder <josharian@gmail.com>
      42cc4ca3
    • Tobias Klauser's avatar
      Revert "syscall, os: use pipe2 syscall on DragonflyBSD instead of pipe" · a700ae98
      Tobias Klauser authored
      This reverts commit e6c15945.
      
      Reason for revert: breaks the Dragonfly builders.
      
      Fixes #27245
      
      Change-Id: I2c147a5726aec28647f6ef5eb8f9db5efa3a9fd0
      Reviewed-on: https://go-review.googlesource.com/131497
      Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: 's avatarBrad Fitzpatrick <bradfitz@golang.org>
      a700ae98
    • Daniel Martí's avatar
      encoding/json: fix handling of nil anonymous structs · 969b9d81
      Daniel Martí authored
      Given the following types:
      
      	type S2 struct{ Field string }
      	type S  struct{ *S2 }
      
      Marshalling a value of type T1 should result in "{}", as there's no way
      to access any value of T2.Field. This is how Go 1.10 and earlier
      versions behave.
      
      However, in the recent refactor golang.org/cl/125417 I broke this logic.
      When the encoder found an anonymous struct pointer field that was nil,
      it no longer skipped the embedded fields underneath it. This can be seen
      in the added test:
      
      	--- FAIL: TestAnonymousFields/EmbeddedFieldBehindNilPointer (0.00s)
      	    encode_test.go:430: Marshal() = "{\"Field\":\"\\u003c*json.S2 Value\\u003e\"}", want "{}"
      
      The human error was a misplaced label, meaning we weren't actually
      skipping the right loop iteration. Fix that.
      
      Change-Id: Iba8a4a77d358dac73dcba4018498fe4f81afa263
      Reviewed-on: https://go-review.googlesource.com/131376
      Run-TryBot: Daniel Martí <mvdan@mvdan.cc>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: 's avatarBrad Fitzpatrick <bradfitz@golang.org>
      969b9d81
    • Daniel Martí's avatar
      encoding/json: get rid of the stream_test.go TODOs · 21af0c16
      Daniel Martí authored
      TestRawMessage now passes without the need for the RawMessage field to
      be a pointer. The TODO dates all the way back to 2010, so I presume the
      issue has since been fixed.
      
      TestNullRawMessage tested the decoding of a JSON null into a
      *RawMessage. The existing behavior was correct, but for the sake of
      completeness a non-pointer RawMessage field has been added too. The
      non-pointer field behaves differently, as one can read in the docs:
      
      	To unmarshal JSON into a value implementing the Unmarshaler
      	interface, Unmarshal calls that value's UnmarshalJSON method,
      	including when the input is a JSON null.
      
      Change-Id: Iabaed75d4ed10ea427d135ee1b80c6e6b83b2e6e
      Reviewed-on: https://go-review.googlesource.com/131377
      Run-TryBot: Daniel Martí <mvdan@mvdan.cc>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: 's avatarBrad Fitzpatrick <bradfitz@golang.org>
      21af0c16
    • Martin Möhrmann's avatar
      internal/bytealg: replace use of runtime.support_sse2 with cpu.X86.HasSSE2 · eae5fc88
      Martin Möhrmann authored
      This makes the runtime.support_sse2 variable unused
      so it is removed in this CL too.
      
      Change-Id: Ia8b9ffee7ac97128179f74ef244b10315e44c234
      Reviewed-on: https://go-review.googlesource.com/131455
      Run-TryBot: Martin Möhrmann <moehrmann@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: 's avatarIan Lance Taylor <iant@golang.org>
      eae5fc88