1. 08 Oct, 2019 8 commits
    • Robert Griesemer's avatar
      go/types: fix cycle detection · 37a22900
      Robert Griesemer authored
      For Go 1.13, we rewrote the go/types cycle detection scheme. Unfortunately,
      it was a bit too clever and introduced a bug (#34333). Here's an example:
      
      type A struct {
      	f1 *B
      	f2 B
      }
      
      type B A
      
      When type-checking this code, the first cycle A->*B->B->A (via field f1)
      is ok because there's a pointer indirection. Though in the process B is
      considered "type-checked" (and painted/marked from "grey" to black").
      When type-checking f2, since B is already completely set up, go/types
      doesn't complain about the invalid cycle A->B->A (via field f2) anymore.
      On the other hand, with the fields f1, f2 swapped:
      
      type A struct {
      	f2 B
      	f1 *B
      }
      
      go/types reports an error because the cycle A->B->A is type-checked first.
      In general, we cannot know the "right" order in which types need to be
      type-checked.
      
      This CL fixes the issue as follows:
      
      1) The global object path cycle detection does not take (pointer, function,
         reference type) indirections into account anymore for cycle detection.
         That mechanism was incorrect to start with and the primary cause for this
         issue. As a consequence we don't need Checker.indirectType and indir anymore.
      
      2) After processing type declarations, Checker.validType is called to
         verify that a type doesn't expand indefinitively. This corresponds
         essentially to cmd/compile's dowidth computation (without size computation).
      
      3) Cycles involving only defined types (e.g.: type (A B; B C; C A))
         require separate attention as those must now be detected when resolving
         "forward chains" of type declarations. Checker.underlying was changed
         to detect these cycles.
      
      All three cycle detection mechanism use an object path ([]Object) to
      report cycles. The cycle error reporting mechanism is now factored out
      into Checker.cycleError and used by all three mechanisms. It also makes
      an attempt to report the cycle starting with the "first" (earliest in the
      source) object.
      
      Fixes #34333.
      
      Change-Id: I2c6446445e47344cc2cd034d3c74b1c345b8c1e6
      Reviewed-on: https://go-review.googlesource.com/c/go/+/196338
      Run-TryBot: Robert Griesemer <gri@golang.org>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarMatthew Dempsky <mdempsky@google.com>
      37a22900
    • Lynn Boger's avatar
      cmd/compile: use vsx loads and stores for LoweredMove, LoweredZero on ppc64x · 816ff444
      Lynn Boger authored
      This improves the code generated for LoweredMove and LoweredZero by
      using LXVD2X and STXVD2X to move 16 bytes at a time. These instructions
      are now used if the size to be moved or zeroed is >= 64. These same
      instructions have already been used in the asm implementations for
      memmove and memclr.
      
      Some examples where this shows an improvement on power8:
      
      MakeSlice/Byte                                  27.3ns ± 1%     25.2ns ± 0%    -7.69%
      MakeSlice/Int16                                 40.2ns ± 0%     35.2ns ± 0%   -12.39%
      MakeSlice/Int                                   94.9ns ± 1%     77.9ns ± 0%   -17.92%
      MakeSlice/Ptr                                    129ns ± 1%      103ns ± 0%   -20.16%
      MakeSlice/Struct/24                              176ns ± 1%      131ns ± 0%   -25.67%
      MakeSlice/Struct/32                              200ns ± 1%      142ns ± 0%   -29.09%
      MakeSlice/Struct/40                              220ns ± 2%      156ns ± 0%   -28.82%
      GrowSlice/Byte                                  81.4ns ± 0%     73.4ns ± 0%    -9.88%
      GrowSlice/Int16                                  118ns ± 1%       98ns ± 0%   -17.03%
      GrowSlice/Int                                    178ns ± 1%      134ns ± 1%   -24.65%
      GrowSlice/Ptr                                    249ns ± 4%      212ns ± 0%   -14.94%
      GrowSlice/Struct/24                              294ns ± 5%      215ns ± 0%   -27.08%
      GrowSlice/Struct/32                              315ns ± 1%      248ns ± 0%   -21.49%
      GrowSlice/Struct/40                              382ns ± 4%      289ns ± 1%   -24.38%
      ExtendSlice/IntSlice                             109ns ± 1%       90ns ± 1%   -17.51%
      ExtendSlice/PointerSlice                         142ns ± 2%      118ns ± 0%   -16.75%
      ExtendSlice/NoGrow                              6.02ns ± 0%     5.88ns ± 0%    -2.33%
      Append                                          27.2ns ± 0%     27.6ns ± 0%    +1.38%
      AppendGrowByte                                  4.20ms ± 3%     2.60ms ± 0%   -38.18%
      AppendGrowString                                 134ms ± 3%      102ms ± 2%   -23.62%
      AppendSlice/1Bytes                              5.65ns ± 0%     5.67ns ± 0%    +0.35%
      AppendSlice/4Bytes                              6.40ns ± 0%     6.55ns ± 0%    +2.34%
      AppendSlice/7Bytes                              8.74ns ± 0%     8.84ns ± 0%    +1.14%
      AppendSlice/8Bytes                              5.68ns ± 0%     5.70ns ± 0%    +0.40%
      AppendSlice/15Bytes                             9.31ns ± 0%     9.39ns ± 0%    +0.86%
      AppendSlice/16Bytes                             14.0ns ± 0%      5.8ns ± 0%   -58.32%
      AppendSlice/32Bytes                             5.72ns ± 0%     5.68ns ± 0%    -0.66%
      AppendSliceLarge/1024Bytes                       918ns ± 8%      615ns ± 1%   -33.00%
      AppendSliceLarge/4096Bytes                      3.25µs ± 1%     1.92µs ± 1%   -40.84%
      AppendSliceLarge/16384Bytes                     8.70µs ± 2%     4.69µs ± 0%   -46.08%
      AppendSliceLarge/65536Bytes                     18.1µs ± 3%      7.9µs ± 0%   -56.30%
      AppendSliceLarge/262144Bytes                    69.8µs ± 2%     25.9µs ± 0%   -62.91%
      AppendSliceLarge/1048576Bytes                    258µs ± 1%       93µs ± 0%   -63.96%
      
      Change-Id: I21625dbe231a2029ddb9f7d73f5a6417b35c1e49
      Reviewed-on: https://go-review.googlesource.com/c/go/+/199639
      Run-TryBot: Lynn Boger <laboger@linux.vnet.ibm.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarCherry Zhang <cherryyz@google.com>
      816ff444
    • diaxu01's avatar
      cmd/internal/obj/arm64: add error checking for system registers. · 9ce5cad0
      diaxu01 authored
      This CL adds system register error checking test cases. There're two kinds of
      error test cases:
      
      1. illegal combination.
      MRS should be used in this way: MRS <system register>, <general register>.
      MSR should be used in this way: MSR <general register>, <system register>.
      Error usage examples:
      MRS     R8, VTCR_EL2    // ERROR "illegal combination"
      MSR     VTCR_EL2, R8    // ERROR "illegal combination"
      
      2. illegal read or write access.
      Error usage examples:
      MSR     R7, MIDR_EL1    // ERROR "expected writable system register or pstate"
      MRS     OSLAR_EL1, R3   // ERROR "expected readable system register"
      
      This CL reads system registers readable and writeable property to check whether
      they're used with legal read or write access. This property is named AccessFlags
      in sysRegEnc.go, and it is automatically generated by modifing the system register
      generator.
      
      Change-Id: Ic83d5f372de38d1ecd0df1ca56b354ee157f16b4
      Reviewed-on: https://go-review.googlesource.com/c/go/+/194917Reviewed-by: default avatarCherry Zhang <cherryyz@google.com>
      Run-TryBot: Cherry Zhang <cherryyz@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      9ce5cad0
    • Tobias Klauser's avatar
      cmd/compile: regenerate known formats in fmtmap_test.go · d458b868
      Tobias Klauser authored
      This fixes TestFormats after CL 198037
      
      Change-Id: I3fb7d667f7c2a1fd88a320482310d33b75e068c4
      Reviewed-on: https://go-review.googlesource.com/c/go/+/199777
      Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
      Reviewed-by: default avatarMichael Munday <mike.munday@ibm.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      d458b868
    • Tobias Klauser's avatar
      syscall: don't use deprecated syscalls on linux/arm64 · cedb5616
      Tobias Klauser authored
      Reimplement syscall wrappers for linux/arm64 in terms of supported
      syscalls (or in case of Ustat make it return ENOSYS) and remove the
      manually added SYS_* consts for the deprecated syscalls. Adapted from
      golang.org/x/sys/unix where this is already done since CL 119655.
      
      Change-Id: I94ab48a4645924df3822497d0575f1a1573d509f
      Reviewed-on: https://go-review.googlesource.com/c/go/+/199140
      Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarIan Lance Taylor <iant@golang.org>
      cedb5616
    • Michael Munday's avatar
      cmd/compile: add SSA rules for s390x compare-and-branch instructions · 6ec4c71e
      Michael Munday authored
      This commit adds SSA rules for the s390x combined compare-and-branch
      instructions. These have a shorter encoding than separate compare
      and branch instructions and they also don't clobber the condition
      code (a.k.a. flag register) reducing pressure on the flag allocator.
      
      I have deleted the 'loop_test.go' file and replaced it with a new
      codegen test which performs a wider range of checks.
      
      Object sizes from compilebench:
      
      name                      old object-bytes  new object-bytes  delta
      Template                        562kB ± 0%        561kB ± 0%   -0.28%  (p=0.000 n=10+10)
      Unicode                         217kB ± 0%        217kB ± 0%   -0.17%  (p=0.000 n=10+10)
      GoTypes                        2.03MB ± 0%       2.02MB ± 0%   -0.59%  (p=0.000 n=10+10)
      Compiler                       8.16MB ± 0%       8.11MB ± 0%   -0.62%  (p=0.000 n=10+10)
      SSA                            27.4MB ± 0%       27.0MB ± 0%   -1.45%  (p=0.000 n=10+10)
      Flate                           356kB ± 0%        356kB ± 0%   -0.12%  (p=0.000 n=10+10)
      GoParser                        438kB ± 0%        436kB ± 0%   -0.51%  (p=0.000 n=10+10)
      Reflect                        1.37MB ± 0%       1.37MB ± 0%   -0.42%  (p=0.000 n=10+10)
      Tar                             485kB ± 0%        483kB ± 0%   -0.39%  (p=0.000 n=10+10)
      XML                             630kB ± 0%        621kB ± 0%   -1.45%  (p=0.000 n=10+10)
      [Geo mean]                     1.14MB            1.13MB        -0.60%
      
      name                      old text-bytes    new text-bytes    delta
      HelloSize                       763kB ± 0%        754kB ± 0%   -1.30%  (p=0.000 n=10+10)
      CmdGoSize                      10.7MB ± 0%       10.6MB ± 0%   -0.91%  (p=0.000 n=10+10)
      [Geo mean]                     2.86MB            2.82MB        -1.10%
      
      Change-Id: Ibca55d9c0aa1254aee69433731ab5d26a43a7c18
      Reviewed-on: https://go-review.googlesource.com/c/go/+/198037
      Run-TryBot: Michael Munday <mike.munday@ibm.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarKeith Randall <khr@golang.org>
      6ec4c71e
    • Cuong Manh Le's avatar
      cmd/compile: don't use statictmps for small object in slice literal · 77f5adba
      Cuong Manh Le authored
      Fixes #21561
      
      Change-Id: I89c59752060dd9570d17d73acbbaceaefce5d8ce
      Reviewed-on: https://go-review.googlesource.com/c/go/+/197560
      Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
      Run-TryBot: Keith Randall <khr@golang.org>
      Reviewed-by: default avatarKeith Randall <khr@golang.org>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      77f5adba
    • Richard Musiol's avatar
      syscall: on wasm, do not panic if "process" global is not defined · ecba8352
      Richard Musiol authored
      When running wasm in the browser, the "process" global is not defined.
      This causes functions like os.Getpid() to panic, which is unusual.
      For example on Windows os.Getpid() returns -1 and does not panic.
      
      This change adds a dummy polyfill for "process" which returns -1 or an
      error. It also extends the polyfill for "fs".
      
      Fixes #34627
      Replaces CL 199357
      
      Change-Id: Ifeb12fe7e152c517848933a9ab5f6f749896dcef
      Reviewed-on: https://go-review.googlesource.com/c/go/+/199698
      Run-TryBot: Richard Musiol <neelance@gmail.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarBrad Fitzpatrick <bradfitz@golang.org>
      ecba8352
  2. 07 Oct, 2019 13 commits
    • David Chase's avatar
      cmd/compile: suppress statement marks on interior of switch tree · 01ff213a
      David Chase authored
      The lines on nodes within the IF-tree generated for switch
      statements looks like control flow so the lines get marked
      as statement boundaries.  Except for the first/root comparison,
      explicitly disable the marks.
      
      Change-Id: I64b966ed8e427cdc6b816ff6b6a2eb754346edc7
      Reviewed-on: https://go-review.googlesource.com/c/go/+/198738
      Run-TryBot: David Chase <drchase@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarJeremy Faller <jeremy@golang.org>
      01ff213a
    • Matthew Dempsky's avatar
      cmd/compile: remove useless block-indirection in type switch · ab00f89c
      Matthew Dempsky authored
      Previously, when emitting type switches without an explicit "case nil"
      clause, we would emit:
      
          if x == nil { goto Lnil }
          ...
          Lnil: goto Ldefault
      
      But we can instead just emit:
      
          if x == nil { goto Ldefault }
      
      Doesn't pass toolstash-check; seems like it causes some harmless
      instruction scheduling changes.
      
      Change-Id: Ie233dda26756911e93a08b3db40407ba38694c62
      Reviewed-on: https://go-review.googlesource.com/c/go/+/199644
      Run-TryBot: Matthew Dempsky <mdempsky@google.com>
      Reviewed-by: default avatarKeith Randall <khr@golang.org>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      ab00f89c
    • Ben Schwartz's avatar
      runtime: speed up receive on empty closed channel · e1446d9c
      Ben Schwartz authored
      Currently, nonblocking receive on an open channel is about
      700 times faster than nonblocking receive on a closed channel.
      This change makes closed channels equally fast.
      
      Fixes #32529
      
      relevant benchstat output:
      name                       old time/op    new time/op    delta
      MakeChan/Byte-40            140ns ± 4%     137ns ± 7%   -2.38%  (p=0.023 n=17+19)
      MakeChan/Int-40             174ns ± 5%     173ns ± 6%     ~     (p=0.437 n=18+19)
      MakeChan/Ptr-40             315ns ±15%     301ns ±15%     ~     (p=0.051 n=20+20)
      MakeChan/Struct/0-40        123ns ± 8%      99ns ±11%  -19.18%  (p=0.000 n=20+17)
      MakeChan/Struct/32-40       297ns ± 8%     241ns ±18%  -19.13%  (p=0.000 n=20+20)
      MakeChan/Struct/40-40       344ns ± 5%     273ns ±23%  -20.49%  (p=0.000 n=20+20)
      ChanNonblocking-40         0.32ns ± 2%    0.32ns ± 2%   -1.25%  (p=0.000 n=19+18)
      SelectUncontended-40       5.72ns ± 1%    5.71ns ± 2%     ~     (p=0.326 n=19+19)
      SelectSyncContended-40     10.9µs ±10%    10.6µs ± 3%   -2.77%  (p=0.009 n=20+16)
      SelectAsyncContended-40    1.00µs ± 0%    1.10µs ± 0%  +10.75%  (p=0.000 n=18+19)
      SelectNonblock-40          1.22ns ± 2%    1.21ns ± 4%     ~     (p=0.141 n=18+19)
      ChanUncontended-40          240ns ± 4%     233ns ± 4%   -2.82%  (p=0.000 n=20+20)
      ChanContended-40           86.7µs ± 0%    82.7µs ± 0%   -4.64%  (p=0.000 n=20+19)
      ChanSync-40                 294ns ± 7%     284ns ± 9%   -3.44%  (p=0.006 n=20+20)
      ChanSyncWork-40            38.4µs ±19%    34.0µs ± 4%  -11.33%  (p=0.000 n=20+18)
      ChanProdCons0-40           1.50µs ± 1%    1.63µs ± 0%   +8.53%  (p=0.000 n=19+19)
      ChanProdCons10-40          1.17µs ± 0%    1.18µs ± 1%   +0.44%  (p=0.000 n=19+20)
      ChanProdCons100-40          985ns ± 0%     959ns ± 1%   -2.64%  (p=0.000 n=20+20)
      ChanProdConsWork0-40       1.50µs ± 0%    1.60µs ± 2%   +6.54%  (p=0.000 n=18+20)
      ChanProdConsWork10-40      1.26µs ± 0%    1.26µs ± 2%   +0.40%  (p=0.015 n=20+19)
      ChanProdConsWork100-40     1.27µs ± 0%    1.22µs ± 0%   -4.15%  (p=0.000 n=20+19)
      SelectProdCons-40          1.50µs ± 1%    1.53µs ± 1%   +1.95%  (p=0.000 n=20+20)
      ChanCreation-40            82.1ns ± 5%    81.6ns ± 7%     ~     (p=0.483 n=19+19)
      ChanSem-40                  877ns ± 0%     719ns ± 0%  -17.98%  (p=0.000 n=18+19)
      ChanPopular-40             1.75ms ± 2%    1.78ms ± 3%   +1.76%  (p=0.002 n=20+19)
      ChanClosed-40               215ns ± 1%       0ns ± 6%  -99.82%  (p=0.000 n=20+18)
      
      Change-Id: I6d5ca4f1530cc9e1a9f3ef553bbda3504a036448
      Reviewed-on: https://go-review.googlesource.com/c/go/+/181543
      Run-TryBot: Keith Randall <khr@golang.org>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarKeith Randall <khr@golang.org>
      e1446d9c
    • Matthew Dempsky's avatar
      cmd/compile: reimplement parameter leak encoding · a0894ea5
      Matthew Dempsky authored
      Currently, escape analysis is able to record at most one dereference
      when a parameter leaks to the heap; that is, at call sites, it can't
      distinguish between any of these three functions:
      
          func x1(p ****int) { sink = *p }
          func x2(p ****int) { sink = **p }
          func x3(p ****int) { sink = ***p }
      
      Similarly, it's limited to recording parameter leaks to only the first
      4 parameters, and only up to 6 dereferences.
      
      All of these limitations are due to the awkward encoding scheme used
      at the moment.
      
      This CL replaces the encoding scheme with a simple [8]uint8 array,
      which can handle up to the first 7 parameters, and up to 254
      dereferences, which ought to be enough for anyone. And if not, it's
      much more easily increased.
      
      Shrinks export data size geometric mean for Kubernetes by 0.07%.
      
      Fixes #33981.
      
      Change-Id: I10a94b9accac9a0c91490e0d6d458316f5ca1e13
      Reviewed-on: https://go-review.googlesource.com/c/go/+/197680Reviewed-by: default avatarCherry Zhang <cherryyz@google.com>
      a0894ea5
    • Matthew Dempsky's avatar
      cmd/compile: introduce EscLeaks abstraction · 05a805a6
      Matthew Dempsky authored
      This CL better abstracts away the parameter leak info that was
      directly encoded into the uint16 value. Followup CL will rewrite the
      implementation.
      
      Passes toolstash-check.
      
      Updates #33981.
      
      Change-Id: I27f81d26f5dd2d85f5b0e5250ca529819a1f11c2
      Reviewed-on: https://go-review.googlesource.com/c/go/+/197679
      Run-TryBot: Matthew Dempsky <mdempsky@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarCherry Zhang <cherryyz@google.com>
      05a805a6
    • Richard Musiol's avatar
      runtime: do not omit stack trace of goroutine that handles async events · 1c8e6077
      Richard Musiol authored
      On wasm there is a special goroutine that handles asynchronous events.
      Blocking this goroutine often causes a deadlock. However, the stack
      trace of this goroutine was omitted when printing the deadlock error.
      
      This change adds an exception so the goroutine is not considered as
      an internal system goroutine and the stack trace gets printed, which
      helps with debugging the deadlock.
      
      Updates #32764
      
      Change-Id: Icc8f5ba3ca5a485d557b7bdd76bf2f1ffb92eb3e
      Reviewed-on: https://go-review.googlesource.com/c/go/+/199537
      Run-TryBot: Richard Musiol <neelance@gmail.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarCherry Zhang <cherryyz@google.com>
      1c8e6077
    • Richard Musiol's avatar
      cmd/link: produce valid binaries with large data section on wasm · 30521d51
      Richard Musiol authored
      CL 170950 had a regression that makes the compiler produce
      an invalid wasm binary if the data section is too large.
      Loading such a binary gives the following error:
      "LinkError: WebAssembly.instantiate(): data segment is out of bounds"
      
      This change fixes the issue by ensuring that the minimum size of the
      linear memory is larger than the end of the data section.
      
      Fixes #34395.
      
      Change-Id: I0c8629de7ffd0d85895ad31bf8c9d45fef197a57
      Reviewed-on: https://go-review.googlesource.com/c/go/+/199358Reviewed-by: default avatarCherry Zhang <cherryyz@google.com>
      Run-TryBot: Cherry Zhang <cherryyz@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      30521d51
    • Keith Randall's avatar
      cmd/compile: improve write barrier removal · 30da79d9
      Keith Randall authored
      We're allowed to remove a write barrier when both the old
      value in memory and the new value we're writing are not heap pointers.
      
      Improve both those checks a little bit.
      
      A pointer is known to not be a heap pointer if it is read from
      read-only memory. This sometimes happens for loads of pointers
      from string constants in read-only memory.
      
      Do a better job of tracking which parts of memory are known to be
      zero.  Before we just kept track of a range of offsets in the most
      recently allocated object. For code that initializes the new object's
      fields in a nonstandard order, that tracking is imprecise. Instead,
      keep a bit map of the first 64 words of that object, so we can track
      precisely what we know to be zeroed.
      
      The new scheme is only precise up to the first 512 bytes of the object.
      After that, we'll use write barriers unnecessarily. Hopefully most
      initializers of large objects will use typedmemmove, which does only one
      write barrier check for the whole initialization.
      
      Fixes #34723
      Update #21561
      
      Change-Id: Idf6e1b7d525042fb67961302d4fc6f941393cac8
      Reviewed-on: https://go-review.googlesource.com/c/go/+/199558
      Run-TryBot: Keith Randall <khr@golang.org>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarCherry Zhang <cherryyz@google.com>
      30da79d9
    • Cuong Manh Le's avatar
      internal/reflectlite: add missing copyright header · 54001652
      Cuong Manh Le authored
      Change-Id: Id43870de6608ef2e8c0ebef82fd710b2c3061e66
      Reviewed-on: https://go-review.googlesource.com/c/go/+/199599Reviewed-by: default avatarBrad Fitzpatrick <bradfitz@golang.org>
      Reviewed-by: default avatarTobias Klauser <tobias.klauser@gmail.com>
      54001652
    • Keith Randall's avatar
      cmd/compile: reuse dead register before reusing register holding constant · 72dc9ab1
      Keith Randall authored
      For commuting ops, check whether the second argument is dead before
      checking if the first argument is rematerializeable. Reusing the register
      holding a dead value is always best.
      
      Fixes #33580
      
      Change-Id: I7372cfc03d514e6774d2d9cc727a3e6bf6ce2657
      Reviewed-on: https://go-review.googlesource.com/c/go/+/199559
      Run-TryBot: Keith Randall <khr@golang.org>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarDavid Chase <drchase@google.com>
      72dc9ab1
    • Meng Zhuo's avatar
      bytes: add endian base compare test · fc2915fa
      Meng Zhuo authored
      The current bytes test suit didn't come with endian based test
      which causing #34549 can passed the try-bot.
      This test will failed when little endian architecture simply using
      load and compare uint.
      
      Update #34549
      
      Change-Id: I0973c2cd505ce21c2bed1deeb7d526f1e872118d
      Reviewed-on: https://go-review.googlesource.com/c/go/+/198358Reviewed-by: default avatarCherry Zhang <cherryyz@google.com>
      Run-TryBot: Cherry Zhang <cherryyz@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      fc2915fa
    • Cuong Manh Le's avatar
      internal/reflectlite: add type mirror with reflect test · 8b391060
      Cuong Manh Le authored
      Add test to check that struct type in reflectlite is mirror of reflect.
      Note that the test does not check the field types, only check for number
      of fields and field name are the same.
      
      Updates #34486
      
      Change-Id: Id5f9b26d35faec97863dd1fe7e5eab37d4913181
      Reviewed-on: https://go-review.googlesource.com/c/go/+/199280
      Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarKeith Randall <khr@golang.org>
      8b391060
    • Michael Munday's avatar
      cmd/compile: reduce amount of code generated for block rewrite rules · c7d81bc0
      Michael Munday authored
      Add a Reset method to blocks that allows us to reduce the amount of
      code we generate for block rewrite rules.
      
      Thanks to Cherry for suggesting a similar fix to this in CL 196557.
      
      Compilebench result:
      
      name                      old time/op       new time/op       delta
      Template                        211ms ± 1%        211ms ± 1%   -0.30%  (p=0.028 n=19+20)
      Unicode                        83.7ms ± 3%       83.0ms ± 2%   -0.79%  (p=0.029 n=18+19)
      GoTypes                         757ms ± 1%        755ms ± 1%   -0.31%  (p=0.034 n=19+19)
      Compiler                        3.51s ± 1%        3.50s ± 1%   -0.20%  (p=0.013 n=18+18)
      SSA                             11.7s ± 1%        11.7s ± 1%   -0.38%  (p=0.000 n=19+19)
      Flate                           131ms ± 1%        130ms ± 1%   -0.32%  (p=0.024 n=18+18)
      GoParser                        162ms ± 1%        162ms ± 1%     ~     (p=0.059 n=20+18)
      Reflect                         471ms ± 0%        470ms ± 0%   -0.24%  (p=0.045 n=20+17)
      Tar                             187ms ± 1%        186ms ± 1%     ~     (p=0.157 n=20+20)
      XML                             255ms ± 1%        255ms ± 1%     ~     (p=0.461 n=19+20)
      LinkCompiler                    754ms ± 2%        755ms ± 2%     ~     (p=0.919 n=17+17)
      ExternalLinkCompiler            2.82s ±16%        2.37s ±10%  -15.94%  (p=0.000 n=20+20)
      LinkWithoutDebugCompiler        439ms ± 4%        442ms ± 6%     ~     (p=0.461 n=18+19)
      StdCmd                          25.8s ± 2%        25.5s ± 1%   -0.95%  (p=0.000 n=20+20)
      
      name                      old user-time/op  new user-time/op  delta
      Template                        240ms ± 8%        238ms ± 7%     ~     (p=0.301 n=20+20)
      Unicode                         107ms ±18%        104ms ±13%     ~     (p=0.149 n=20+20)
      GoTypes                         883ms ± 3%        888ms ± 2%     ~     (p=0.211 n=20+20)
      Compiler                        4.22s ± 1%        4.20s ± 1%     ~     (p=0.077 n=20+18)
      SSA                             14.1s ± 1%        14.1s ± 2%     ~     (p=0.192 n=20+20)
      Flate                           145ms ±10%        148ms ± 5%     ~     (p=0.126 n=20+18)
      GoParser                        186ms ± 7%        186ms ± 7%     ~     (p=0.779 n=20+20)
      Reflect                         538ms ± 3%        541ms ± 3%     ~     (p=0.192 n=20+20)
      Tar                             218ms ± 4%        217ms ± 6%     ~     (p=0.835 n=19+20)
      XML                             298ms ± 5%        298ms ± 5%     ~     (p=0.749 n=19+20)
      LinkCompiler                    818ms ± 5%        825ms ± 8%     ~     (p=0.461 n=20+20)
      ExternalLinkCompiler            1.55s ± 4%        1.53s ± 5%     ~     (p=0.063 n=20+18)
      LinkWithoutDebugCompiler        460ms ±12%        460ms ± 7%     ~     (p=0.925 n=20+20)
      
      name                      old object-bytes  new object-bytes  delta
      Template                        554kB ± 0%        554kB ± 0%     ~     (all equal)
      Unicode                         215kB ± 0%        215kB ± 0%     ~     (all equal)
      GoTypes                        2.01MB ± 0%       2.01MB ± 0%     ~     (all equal)
      Compiler                       7.97MB ± 0%       7.97MB ± 0%   +0.00%  (p=0.000 n=20+20)
      SSA                            26.8MB ± 0%       26.9MB ± 0%   +0.27%  (p=0.000 n=20+20)
      Flate                           340kB ± 0%        340kB ± 0%     ~     (all equal)
      GoParser                        434kB ± 0%        434kB ± 0%     ~     (all equal)
      Reflect                        1.34MB ± 0%       1.34MB ± 0%     ~     (all equal)
      Tar                             480kB ± 0%        480kB ± 0%     ~     (all equal)
      XML                             622kB ± 0%        622kB ± 0%     ~     (all equal)
      
      name                      old export-bytes  new export-bytes  delta
      Template                       20.4kB ± 0%       20.4kB ± 0%     ~     (all equal)
      Unicode                        8.21kB ± 0%       8.21kB ± 0%     ~     (all equal)
      GoTypes                        36.6kB ± 0%       36.6kB ± 0%     ~     (all equal)
      Compiler                        115kB ± 0%        115kB ± 0%   +0.08%  (p=0.000 n=20+20)
      SSA                             141kB ± 0%        141kB ± 0%   +0.07%  (p=0.000 n=20+20)
      Flate                          5.11kB ± 0%       5.11kB ± 0%     ~     (all equal)
      GoParser                       8.93kB ± 0%       8.93kB ± 0%     ~     (all equal)
      Reflect                        11.8kB ± 0%       11.8kB ± 0%     ~     (all equal)
      Tar                            10.9kB ± 0%       10.9kB ± 0%     ~     (all equal)
      XML                            17.4kB ± 0%       17.4kB ± 0%     ~     (all equal)
      
      name                      old text-bytes    new text-bytes    delta
      HelloSize                       742kB ± 0%        742kB ± 0%     ~     (all equal)
      CmdGoSize                      10.7MB ± 0%       10.7MB ± 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.10MB ± 0%       1.10MB ± 0%     ~     (all equal)
      CmdGoSize                      14.9MB ± 0%       14.9MB ± 0%     ~     (all equal)
      
      Change-Id: Ic89a8e62423b3d9fd9391159e0663acf450803b5
      Reviewed-on: https://go-review.googlesource.com/c/go/+/198419
      Run-TryBot: Michael Munday <mike.munday@ibm.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarCherry Zhang <cherryyz@google.com>
      Reviewed-by: default avatarDaniel Martí <mvdan@mvdan.cc>
      c7d81bc0
  3. 06 Oct, 2019 2 commits
  4. 05 Oct, 2019 7 commits
  5. 04 Oct, 2019 10 commits