An error occurred fetching the project authors.
  1. 07 Mar, 2018 1 commit
  2. 27 Feb, 2018 1 commit
  3. 26 Feb, 2018 1 commit
    • Robert Griesemer's avatar
      cmd/compile/internal/syntax: remove dependency on cmd/internal/src · 5c08b9e8
      Robert Griesemer authored
      For dependency reasons, the data structure implementing source
      positions in the compiler is in cmd/internal/src. It contains
      highly compiler specific details (e.g. inlining index).
      
      This change introduces a parallel but simpler position
      representation, defined in the syntax package, which removes
      that package's dependency on cmd/internal/src, and also removes
      the need to deal with certain filename-specific operations
      (defined by the needs of the compiler) in the syntax package.
      As a result, the syntax package becomes again a compiler-
      independent, stand-alone package that at some point might
      replace (or augment) the existing top-level go/* syntax-related
      packages.
      
      Additionally, line directives that update column numbers
      are now correctly tracked through the syntax package, with
      additional tests added. (The respective changes also need to
      be made in cmd/internal/src; i.e., the compiler accepts but
      still ignores column numbers in line directives.)
      
      This change comes at the cost of a new position translation
      step, but that step is cheap because it only needs to do real
      work if the position base changed (i.e., if there is a new file,
      or new line directive).
      
      There is no noticeable impact on overall compiler performance
      measured with `compilebench -count 5 -alloc`:
      
      name       old time/op       new time/op       delta
      Template         220ms ± 8%        228ms ±18%    ~     (p=0.548 n=5+5)
      Unicode          119ms ±11%        113ms ± 5%    ~     (p=0.056 n=5+5)
      GoTypes          684ms ± 6%        677ms ± 3%    ~     (p=0.841 n=5+5)
      Compiler         3.19s ± 7%        3.01s ± 1%    ~     (p=0.095 n=5+5)
      SSA              7.92s ± 8%        7.79s ± 1%    ~     (p=0.690 n=5+5)
      Flate            141ms ± 7%        139ms ± 4%    ~     (p=0.548 n=5+5)
      GoParser         173ms ±12%        171ms ± 4%    ~     (p=1.000 n=5+5)
      Reflect          417ms ± 5%        411ms ± 3%    ~     (p=0.548 n=5+5)
      Tar              205ms ± 5%        198ms ± 2%    ~     (p=0.690 n=5+5)
      XML              232ms ± 4%        229ms ± 4%    ~     (p=0.690 n=5+5)
      StdCmd           28.7s ± 5%        28.2s ± 2%    ~     (p=0.421 n=5+5)
      
      name       old user-time/op  new user-time/op  delta
      Template         269ms ± 4%        265ms ± 5%    ~     (p=0.421 n=5+5)
      Unicode          153ms ± 7%        149ms ± 3%    ~     (p=0.841 n=5+5)
      GoTypes          850ms ± 7%        862ms ± 4%    ~     (p=0.841 n=5+5)
      Compiler         4.01s ± 5%        3.86s ± 0%    ~     (p=0.190 n=5+4)
      SSA              10.9s ± 4%        10.8s ± 2%    ~     (p=0.548 n=5+5)
      Flate            166ms ± 7%        167ms ± 6%    ~     (p=1.000 n=5+5)
      GoParser         204ms ± 8%        206ms ± 7%    ~     (p=0.841 n=5+5)
      Reflect          514ms ± 5%        508ms ± 4%    ~     (p=0.548 n=5+5)
      Tar              245ms ± 6%        244ms ± 3%    ~     (p=0.690 n=5+5)
      XML              280ms ± 4%        278ms ± 4%    ~     (p=0.841 n=5+5)
      
      name       old alloc/op      new alloc/op      delta
      Template        37.9MB ± 0%       37.9MB ± 0%    ~     (p=0.841 n=5+5)
      Unicode         28.8MB ± 0%       28.8MB ± 0%    ~     (p=0.841 n=5+5)
      GoTypes          113MB ± 0%        113MB ± 0%    ~     (p=0.151 n=5+5)
      Compiler         468MB ± 0%        468MB ± 0%  -0.01%  (p=0.032 n=5+5)
      SSA             1.50GB ± 0%       1.50GB ± 0%    ~     (p=0.548 n=5+5)
      Flate           24.4MB ± 0%       24.4MB ± 0%    ~     (p=1.000 n=5+5)
      GoParser        30.7MB ± 0%       30.7MB ± 0%    ~     (p=1.000 n=5+5)
      Reflect         76.5MB ± 0%       76.5MB ± 0%    ~     (p=0.548 n=5+5)
      Tar             38.9MB ± 0%       38.9MB ± 0%    ~     (p=0.222 n=5+5)
      XML             41.6MB ± 0%       41.6MB ± 0%    ~     (p=0.548 n=5+5)
      
      name       old allocs/op     new allocs/op     delta
      Template          382k ± 0%         382k ± 0%  +0.01%  (p=0.008 n=5+5)
      Unicode           343k ± 0%         343k ± 0%    ~     (p=0.841 n=5+5)
      GoTypes          1.19M ± 0%        1.19M ± 0%  +0.01%  (p=0.008 n=5+5)
      Compiler         4.53M ± 0%        4.53M ± 0%  +0.03%  (p=0.008 n=5+5)
      SSA              12.4M ± 0%        12.4M ± 0%  +0.00%  (p=0.008 n=5+5)
      Flate             235k ± 0%         235k ± 0%    ~     (p=0.079 n=5+5)
      GoParser          318k ± 0%         318k ± 0%    ~     (p=0.730 n=5+5)
      Reflect           978k ± 0%         978k ± 0%    ~     (p=1.000 n=5+5)
      Tar               393k ± 0%         393k ± 0%    ~     (p=0.056 n=5+5)
      XML               405k ± 0%         405k ± 0%    ~     (p=0.548 n=5+5)
      
      name       old text-bytes    new text-bytes    delta
      HelloSize        672kB ± 0%        672kB ± 0%    ~     (all equal)
      CmdGoSize       7.12MB ± 0%       7.12MB ± 0%    ~     (all equal)
      
      name       old data-bytes    new data-bytes    delta
      HelloSize        133kB ± 0%        133kB ± 0%    ~     (all equal)
      CmdGoSize        390kB ± 0%        390kB ± 0%    ~     (all equal)
      
      name       old exe-bytes     new exe-bytes     delta
      HelloSize       1.07MB ± 0%       1.07MB ± 0%    ~     (all equal)
      CmdGoSize       11.2MB ± 0%       11.2MB ± 0%    ~     (all equal)
      
      Passes toolstash compare.
      
      For #22662.
      
      Change-Id: I19edb53dd9675af57f7122cb7dba2a6d8bdcc3da
      Reviewed-on: https://go-review.googlesource.com/94515Reviewed-by: default avatarMatthew Dempsky <mdempsky@google.com>
      5c08b9e8
  4. 20 Feb, 2018 1 commit
    • philhofer's avatar
      cmd/compile/internal/ssa: emit csel on arm64 · 2d0172c3
      philhofer authored
      Introduce a new SSA pass to generate CondSelect intstrutions,
      and add CondSelect lowering rules for arm64.
      
      In order to make the CSEL instruction easier to optimize,
      and to simplify the introduction of CSNEG, CSINC, and CSINV
      in the future, modify the CSEL instruction to accept a condition
      code in the aux field.
      
      Notably, this change makes the go1 Gzip benchmark
      more than 10% faster.
      
      Benchmarks on a Cavium ThunderX:
      
      name                      old time/op    new time/op    delta
      BinaryTree17-96              15.9s ± 6%     16.0s ± 4%     ~     (p=0.968 n=10+9)
      Fannkuch11-96                7.17s ± 0%     7.00s ± 0%   -2.43%  (p=0.000 n=8+9)
      FmtFprintfEmpty-96           208ns ± 1%     207ns ± 0%     ~     (p=0.152 n=10+8)
      FmtFprintfString-96          379ns ± 0%     375ns ± 0%   -0.95%  (p=0.000 n=10+9)
      FmtFprintfInt-96             385ns ± 0%     383ns ± 0%   -0.52%  (p=0.000 n=9+10)
      FmtFprintfIntInt-96          591ns ± 0%     586ns ± 0%   -0.85%  (p=0.006 n=7+9)
      FmtFprintfPrefixedInt-96     656ns ± 0%     667ns ± 0%   +1.71%  (p=0.000 n=10+10)
      FmtFprintfFloat-96           967ns ± 0%     984ns ± 0%   +1.78%  (p=0.000 n=10+10)
      FmtManyArgs-96              2.35µs ± 0%    2.25µs ± 0%   -4.63%  (p=0.000 n=9+8)
      GobDecode-96                31.0ms ± 0%    30.8ms ± 0%   -0.36%  (p=0.006 n=9+9)
      GobEncode-96                24.4ms ± 0%    24.5ms ± 0%   +0.30%  (p=0.000 n=9+9)
      Gzip-96                      1.60s ± 0%     1.43s ± 0%  -10.58%  (p=0.000 n=9+10)
      Gunzip-96                    167ms ± 0%     169ms ± 0%   +0.83%  (p=0.000 n=8+9)
      HTTPClientServer-96          311µs ± 1%     308µs ± 0%   -0.75%  (p=0.000 n=10+10)
      JSONEncode-96               65.0ms ± 0%    64.8ms ± 0%   -0.25%  (p=0.000 n=9+8)
      JSONDecode-96                262ms ± 1%     261ms ± 1%     ~     (p=0.579 n=10+10)
      Mandelbrot200-96            18.0ms ± 0%    18.1ms ± 0%   +0.17%  (p=0.000 n=8+10)
      GoParse-96                  14.0ms ± 0%    14.1ms ± 1%   +0.42%  (p=0.003 n=9+10)
      RegexpMatchEasy0_32-96       644ns ± 2%     645ns ± 2%     ~     (p=0.836 n=10+10)
      RegexpMatchEasy0_1K-96      3.70µs ± 0%    3.49µs ± 0%   -5.58%  (p=0.000 n=10+10)
      RegexpMatchEasy1_32-96       662ns ± 2%     657ns ± 2%     ~     (p=0.137 n=10+10)
      RegexpMatchEasy1_1K-96      4.47µs ± 0%    4.31µs ± 0%   -3.48%  (p=0.000 n=10+10)
      RegexpMatchMedium_32-96      844ns ± 2%     849ns ± 1%     ~     (p=0.208 n=10+10)
      RegexpMatchMedium_1K-96      179µs ± 0%     182µs ± 0%   +1.20%  (p=0.000 n=10+10)
      RegexpMatchHard_32-96       10.0µs ± 0%    10.1µs ± 0%   +0.48%  (p=0.000 n=10+9)
      RegexpMatchHard_1K-96        297µs ± 0%     297µs ± 0%   -0.14%  (p=0.000 n=10+10)
      Revcomp-96                   3.08s ± 0%     3.13s ± 0%   +1.56%  (p=0.000 n=9+9)
      Template-96                  276ms ± 2%     275ms ± 1%     ~     (p=0.393 n=10+10)
      TimeParse-96                1.37µs ± 0%    1.36µs ± 0%   -0.53%  (p=0.000 n=10+7)
      TimeFormat-96               1.40µs ± 0%    1.42µs ± 0%   +0.97%  (p=0.000 n=10+10)
      [Geo mean]                   264µs          262µs        -0.77%
      
      Change-Id: Ie54eee4b3092af53e6da3baa6d1755098f57f3a2
      Reviewed-on: https://go-review.googlesource.com/55670
      Run-TryBot: Philip Hofer <phofer@umich.edu>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarCherry Zhang <cherryyz@google.com>
      Reviewed-by: default avatarKeith Randall <khr@golang.org>
      2d0172c3
  5. 11 Oct, 2017 2 commits
  6. 10 Oct, 2017 1 commit
    • Daniel Martí's avatar
      cmd/compile: make bad Ctypes be only 0 · f14f7b31
      Daniel Martí authored
      Before, -1 meant a node being nil or not an OLITERAL, and 0 meant an
      OLITERAL missing a Val.
      
      However, the use of this value was confusing and led to some issues,
      such as swt.go checking for < 0 instead of <= 0, causing panics.
      
      We never need to differentiate these two cases, so collapse both into 0.
      To make it clear that negative values can no longer happen, make Ctype
      an uint8.
      
      With this change, we can now get rid of the two n.Type == nil checks
      in swt.go added to fix a couple of these panics.
      
      Thanks to Matthew Dempsky for spotting this inconsistency.
      
      Fixes #22001.
      
      Change-Id: I51c65a76f38a3e16788b6a3b57932dad3436dc7e
      Reviewed-on: https://go-review.googlesource.com/69510
      Run-TryBot: Daniel Martí <mvdan@mvdan.cc>
      Reviewed-by: default avatarMatthew Dempsky <mdempsky@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      f14f7b31
  7. 03 Oct, 2017 1 commit
  8. 27 Sep, 2017 1 commit
  9. 24 Sep, 2017 1 commit
  10. 19 Sep, 2017 1 commit
    • Matthew Dempsky's avatar
      cmd/compile: eliminate OXFALL · 4347baac
      Matthew Dempsky authored
      Previously, we used OXFALL vs OFALL to distinguish fallthrough
      statements that had been validated. Because in the Node AST we flatten
      statement blocks, OXCASE and OXFALL needed to keep track of their
      block scopes for this purpose.
      
      Now that we have an AST that keeps these separate, we can just perform
      the validation earlier.
      
      Passes toolstash-check.
      
      Fixes #14540.
      
      Change-Id: I8421eaba16c2b3b72c9c5483b5cf20b14261385e
      Reviewed-on: https://go-review.googlesource.com/61130
      Run-TryBot: Matthew Dempsky <mdempsky@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarRobert Griesemer <gri@golang.org>
      4347baac
  11. 15 Aug, 2017 1 commit
  12. 19 May, 2017 1 commit
    • Daniel Martí's avatar
      cmd/compile: make duplicate expr cases readable · 495f55d2
      Daniel Martí authored
      Instead of just printing the value, print the original node to make the
      error more human-friendly. Also print the value if its string form is
      different than the original node, to make sure it's obvious what value
      was duplicated.
      
      This means that "case '@', '@':", which used to print:
      
      	duplicate case 64 in switch
      
      Will now print:
      
      	duplicate case '@' (value 64) in switch
      
      Factor this logic out into its own function to reuse it in range cases
      and any other place where we might want to print a node and its value in
      the future.
      
      Also needed to split the errorcheck files because expression switch case
      duplicates are now detected earlier, so they stop the compiler before it
      gets to generating the AST and detecting the type switch case
      duplicates.
      
      Fixes #20112.
      
      Change-Id: I9009b50dec0d0e705e5de9c9ccb08f1dce8a5a99
      Reviewed-on: https://go-review.googlesource.com/41852
      Run-TryBot: Daniel Martí <mvdan@mvdan.cc>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarMatthew Dempsky <mdempsky@google.com>
      495f55d2
  13. 30 Apr, 2017 1 commit
  14. 26 Apr, 2017 1 commit
  15. 07 Apr, 2017 1 commit
    • Robert Griesemer's avatar
      cmd/compile: factor out Pkg, Sym, and Type into package types · f68f2928
      Robert Griesemer authored
      - created new package cmd/compile/internal/types
      - moved Pkg, Sym, Type to new package
      - to break cycles, for now we need the (ugly) types/utils.go
        file which contains a handful of functions that must be installed
        early by the gc frontend
      - to break cycles, for now we need two functions to convert between
        *gc.Node and *types.Node (the latter is a dummy type)
      - adjusted the gc's code to use the new package and the conversion
        functions as needed
      - made several Pkg, Sym, and Type methods functions as needed
      - renamed constructors typ, typPtr, typArray, etc. to types.New,
        types.NewPtr, types.NewArray, etc.
      
      Passes toolstash-check -all.
      
      Change-Id: I8adfa5e85c731645d0a7fd2030375ed6ebf54b72
      Reviewed-on: https://go-review.googlesource.com/39855Reviewed-by: default avatarMatthew Dempsky <mdempsky@google.com>
      f68f2928
  16. 06 Apr, 2017 1 commit
  17. 01 Apr, 2017 1 commit
  18. 27 Mar, 2017 1 commit
  19. 14 Mar, 2017 1 commit
  20. 03 Mar, 2017 1 commit
    • Aliaksandr Valialkin's avatar
      cmd/compile: pack bool fields in Node, Name, Func and Type structs to bitsets · ed70f37e
      Aliaksandr Valialkin authored
      This reduces compiler memory usage by up to 4% - see compilebench
      results below.
      
      name       old time/op     new time/op     delta
      Template       245ms ± 4%      241ms ± 2%  -1.88%  (p=0.029 n=10+10)
      Unicode        126ms ± 3%      124ms ± 3%    ~     (p=0.105 n=10+10)
      GoTypes        805ms ± 2%      813ms ± 3%    ~     (p=0.515 n=8+10)
      Compiler       3.95s ± 2%      3.83s ± 1%  -2.96%  (p=0.000 n=9+10)
      MakeBash       47.4s ± 4%      46.6s ± 1%  -1.59%  (p=0.028 n=9+10)
      
      name       old user-ns/op  new user-ns/op  delta
      Template        324M ± 5%       326M ± 3%    ~     (p=0.935 n=10+10)
      Unicode         186M ± 5%       178M ±10%    ~     (p=0.067 n=9+10)
      GoTypes        1.08G ± 7%      1.09G ± 4%    ~     (p=0.956 n=10+10)
      Compiler       5.34G ± 4%      5.31G ± 1%    ~     (p=0.501 n=10+8)
      
      name       old alloc/op    new alloc/op    delta
      Template      41.0MB ± 0%     39.8MB ± 0%  -3.03%  (p=0.000 n=10+10)
      Unicode       32.3MB ± 0%     31.0MB ± 0%  -4.13%  (p=0.000 n=10+10)
      GoTypes        119MB ± 0%      116MB ± 0%  -2.39%  (p=0.000 n=10+10)
      Compiler       499MB ± 0%      487MB ± 0%  -2.48%  (p=0.000 n=10+10)
      
      name       old allocs/op   new allocs/op   delta
      Template        380k ± 1%       379k ± 1%    ~     (p=0.436 n=10+10)
      Unicode         324k ± 1%       324k ± 0%    ~     (p=0.853 n=10+10)
      GoTypes        1.15M ± 0%      1.15M ± 0%    ~     (p=0.481 n=10+10)
      Compiler       4.41M ± 0%      4.41M ± 0%  -0.12%  (p=0.007 n=10+10)
      
      name       old text-bytes  new text-bytes  delta
      HelloSize       623k ± 0%       623k ± 0%    ~     (all equal)
      CmdGoSize      6.64M ± 0%      6.64M ± 0%    ~     (all equal)
      
      name       old data-bytes  new data-bytes  delta
      HelloSize      5.81k ± 0%      5.81k ± 0%    ~     (all equal)
      CmdGoSize       238k ± 0%       238k ± 0%    ~     (all equal)
      
      name       old bss-bytes   new bss-bytes   delta
      HelloSize       134k ± 0%       134k ± 0%    ~     (all equal)
      CmdGoSize       152k ± 0%       152k ± 0%    ~     (all equal)
      
      name       old exe-bytes   new exe-bytes   delta
      HelloSize       967k ± 0%       967k ± 0%    ~     (all equal)
      CmdGoSize      10.2M ± 0%      10.2M ± 0%    ~     (all equal)
      
      Change-Id: I1f40af738254892bd6c8ba2eb43390b175753d52
      Reviewed-on: https://go-review.googlesource.com/37445Reviewed-by: default avatarMatthew Dempsky <mdempsky@google.com>
      Run-TryBot: Matthew Dempsky <mdempsky@google.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      ed70f37e
  21. 24 Feb, 2017 1 commit
  22. 13 Feb, 2017 1 commit
  23. 02 Feb, 2017 1 commit
  24. 08 Dec, 2016 1 commit
  25. 16 Nov, 2016 1 commit
  26. 21 Oct, 2016 1 commit
  27. 26 Sep, 2016 1 commit
    • Alberto Donizetti's avatar
      cmd/compile: fix bogus "fallthrough statement out of place" · 375092bd
      Alberto Donizetti authored
      When processing a fallthrough, the casebody function in swt.go
      checks that the last statement has indeed Op == OXFALL (not-processed
      fallthrough) before setting it to OFALL (processed fallthrough).
      
      Unfortunately, sometimes the fallthrough statement won't be in the
      last node. For example, in
      
      case 0:
      	 return func() int {return 1}()
      	 fallthrough
      
      the compiler generates
      
      autotmp_0 = (func literal)(); return autotmp_0; fallthrough; <node VARKILL>
      
      with an OVARKILL node in the last position. casebody will find that
      last.Op != OXFALL, won't mark the fallthrough as processed, and the
      fallthrough line will cause a "fallthrough statement out of place" error.
      
      To fix this, we change casebody so that it searches for the fallthrough
      statement backwards in the statements list, without assuming that it'll
      be in the last position.
      
      Fixes #13262
      
      Change-Id: I366c6caa7fd7442d365bd7a08cc66a552212d9b2
      Reviewed-on: https://go-review.googlesource.com/22921
      Run-TryBot: Quentin Smith <quentin@golang.org>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarQuentin Smith <quentin@golang.org>
      375092bd
  28. 16 Sep, 2016 1 commit
  29. 15 Sep, 2016 2 commits
  30. 14 Sep, 2016 1 commit
  31. 13 Sep, 2016 1 commit
    • Robert Griesemer's avatar
      cmd/compile: reduce allocs some more · 0cd3ecb0
      Robert Griesemer authored
      Also: update fmt_test.go.
      
      Together with the previous commits, we are now at or below c85b77c2
      levels in terms of allocation for the benchmark described in #16897
      (old = c85b77c2, new = this commit):
      
      name       old time/op     new time/op     delta
      Template       297ms ± 5%      284ms ± 3%  -4.53%  (p=0.000 n=27+29)
      Unicode        159ms ± 5%      151ms ± 5%  -4.91%  (p=0.000 n=28+30)
      GoTypes        985ms ± 5%      935ms ± 2%  -5.13%  (p=0.000 n=28+29)
      
      name       old alloc/op    new alloc/op    delta
      Template      46.8MB ± 0%     45.7MB ± 0%  -2.37%  (p=0.000 n=30+30)
      Unicode       37.8MB ± 0%     37.9MB ± 0%  +0.29%  (p=0.000 n=29+30)
      GoTypes        143MB ± 0%      138MB ± 0%  -3.64%  (p=0.000 n=29+30)
      
      name       old allocs/op   new allocs/op   delta
      Template        444k ± 0%       440k ± 0%  -0.94%  (p=0.000 n=30+30)
      Unicode         369k ± 0%       369k ± 0%  +0.19%  (p=0.000 n=29+30)
      GoTypes        1.35M ± 0%      1.34M ± 0%  -1.24%  (p=0.000 n=30+30)
      
      For #16897.
      
      Change-Id: Iedbeb408e2f1e68dd4a3201bf8813c8066ebf7ed
      Reviewed-on: https://go-review.googlesource.com/29089Reviewed-by: default avatarMatthew Dempsky <mdempsky@google.com>
      0cd3ecb0
  32. 12 Sep, 2016 1 commit
  33. 08 Sep, 2016 2 commits
  34. 30 Aug, 2016 1 commit
    • Josh Bleecher Snyder's avatar
      cmd/compile: recognize integer ranges in switch statements · 8c85e230
      Josh Bleecher Snyder authored
      Consider a switch statement like:
      
      switch x {
      case 1:
        // ...
      case 2, 3, 4, 5, 6:
        // ...
      case 5:
        // ...
      }
      
      Prior to this CL, the generated code treated
      2, 3, 4, 5, and 6 independently in a binary search.
      With this CL, the generated code checks whether
      2 <= x && x <= 6.
      walkinrange then optimizes that range check
      into a single unsigned comparison.
      
      Experiments suggest that the best min range size
      is 2, using binary size as a proxy for optimization.
      
      Binary sizes before/after this CL:
      
      cmd/compile: 14209728 / 14165360
      cmd/go:       9543100 /  9539004
      
      Change-Id: If2f7fb97ca80468fa70351ef540866200c4c996c
      Reviewed-on: https://go-review.googlesource.com/26770
      Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
      TryBot-Result: Gobot Gobot <gobot@golang.org>
      Reviewed-by: default avatarMatthew Dempsky <mdempsky@google.com>
      8c85e230
  35. 23 Aug, 2016 3 commits