build: add GOOS=illumos #20603

sean- · 2017-06-07T20:36:36Z

Disambiguating `solaris` vs `illumos`

SunOS/Solaris has a storied and complicated history. In [2010] Illumos forked from OpenSolaris and has continued its life in the open (, and now spent the majority of its life, as Illumos (not Solaris).

The solaris build tag is "mostly" compatible with Illumos and Illumos-based distributions (e.g. SmartOS, Nexenta, Open Indiana, Delphix, etc), however Illumos has diverged significantly from Solaris. In order to detect and support Illumos-native functionality, I propose:

illumos be added as a new GOOS build tag
The illumos build tag be distinct from solaris.

We considered extending the life of the solaris build target to include the illumos target for the period of one release but decided against this because it would taint community code with:

// +build !solaris
// +build illumos

that would need to be cleaned up at the end of the transition period. Backwards compatibility for the sake of backwards compatibility isn't something we're interested in maintaining.

Semi-related: it would be nice if there was a way of specifying and targeting distributions at build time. cgo on Linux and alpine vs glibc comes to mind as another area that would benefit from a distribution-specific build target.

The text was updated successfully, but these errors were encountered:

bradfitz · 2017-06-07T21:14:47Z

/cc @4ad @binarycrusader @jtsylve for opinions too.

ianlancetaylor · 2017-06-08T01:07:45Z

Can you outline the differences relevant to the Go standard library between solaris and illumos?

binarycrusader · 2017-06-08T03:14:56Z

Illumos didn't fork in 2007, which would be especially hard since OpenSolaris didn't have it's first release until 2008. I suspect the submitter meant 2010.

However, many of the other points made are true -- for reasons that are beyond the control of engineering, the OpenSolaris program was discontinued in 2010. There are roughly seven years of divergence at this point. Solaris has changed significantly in that time for any new interfaces that were added or updated after the initial fork, etc.

Both Solaris and OpenSolaris-based derivatives (such as Illumos) added or updated existing interfaces after the fork; these interfaces, even though they have the same names, may not be compatible as they sometimes use different constant values in system headers, accept a different number of parameters, or one version accepts values the others does not.

With that said, any interface that existed before the fork will generally be compatible because Solaris has strong guarantees for backwards compatibility at the binary level (although this is not strictly guaranteed at the source level). The only catch would be new parameter values that functions may not have supported in an older release.

For the vast majority of the Go standard library, there are no appreciable differences -- they can continue to be treated as equivalent platforms. This is part of why I have not yet approached the Go development team about trying to resolve this. However, there are some important differences, most of which affect packages such as golang.org/x/sys/unix or anything that uses native system interfaces.

I've mainly been waiting for the right time to approach the golang-dev mailing list about how we should account for the differences since they are starting to matter. For example, if you run the mkall.sh script in syscall, you'll find a number of differences: https://gist.github.com/binarycrusader/1c57088d65c8f4071853af5efa37271e

Looking over those differences, you'll see what I said earlier matches up -- some of the error constants are different, Solaris has many that Illumos does not, and Illumos has a few options Solaris intentionally doesn't support (such as MAP_32BIT for mmap()), etc. The next release of Solaris also supports the xpg7 standard, which Illumos doesn't support yet as far as I know, so there are some new interfaces there as well.

More important differences in constants are things such as TCP_KEEPCNT, etc. that both Illumos and Solaris support but have different values for.

The small remaining differences are things such as different text for particular errnos, or the Bits in FdSet being uint64 instead of int64 on Solaris (bug fix) and don't typically matter in practice.

Now as for the pull request that was referenced, yes, there are big differences there. Solaris does actually have all of those statistics available, but using a completely different set of interfaces. Although both Solaris and OpenSolaris-based derivatives have the kstat general interface, the set of stats available is different. Additionally, the next release of Solaris has a completely new statistics subsystem, so being able to differentiate between Solaris and OpenSolaris-based derivatives is likely important.

There are other considerations as well when adding new interfaces to packages such as golang.org/x/sys/unix; by a quick and hacky estimation, Solaris libc has easily hundreds of additional private/public interfaces not present in OpenSolaris-based derivatives and OpenSolaris-based derivatives have a few that Solaris does not as well. Generally speaking, those differences won't affect the Go standard library, the primary points of contention are around networking-related interfaces, and some memory-related interfaces (such as mmap). There are other differences as well when it comes to the system linker (/usr/bin/ld) and what it supports, etc. but I don't think those are particularly relevant (yet).

In short, I've only recently become concerned that this is a problem worth solving somehow, and the amount of divergence that affects Go itself is fairly small.

For the record, Go is important to Solaris, and we've tried hard to remain compatible with OpenSolaris-based derivatives. I've spent roughly two years now working on porting Go to Solaris and on a port of Go to sparcv9 with Aram which should be ready to integrate in the Go 1.10 timeframe. As such, we're very interested to workout an acceptable solution with all parties involved.

sean- · 2017-06-08T03:30:26Z

@ianlancetaylor There are a number of new syscalls that only exist in Illumos. A quick of changes includes:

brand(2)
getrandom(2)
epoll(2)
preadv(2) and pwritev(2)

[/me deletes most of his reply, thank you @binarycrusader for that excellent reply - my history with Go on Illumos is only a handful of months. I used 2007 as the date based on the head of a series of reflog entries and my memory of the acquisition, but 2010 is the correct date. ]

Internally we were concerned about maintaining portability but know these are going to continue to diverge, but given our use of Go, it's clear that this will be problematic going forward as additional syscalls show up in x/sys/unix. I'm going to hand-wave past any already present divergence that I suspect is being carpeted over by the fact that we rebuild Go internally and there isn't much crossover between binaries created on Illumos and run on Solaris (though I have heard several anecdotal reports of some binaries not working but not verified this myself). I'm sure some of the kstats referenced work, though others don't (yet?/ever?).

I think there is a lot of history and shared work that could be leveraged going forward, too, but fundamentally the two OSes have diverged to the point that there is a need for a discrete build tag in order to make appropriate decisions at compile time.

binarycrusader · 2017-06-08T03:40:23Z

getrandom(2)

Solaris 11.3 added this:
https://docs.oracle.com/cd/E86824_01/html/E54765/getrandom-2.html

As for the other functions, they are not yet available in Solaris (intentionally or because they haven't been implemented yet). But yes, those are good examples.

4ad · 2017-06-08T10:46:38Z

Having a way to distinguish illumos and Oracle Solaris targets based on build tags seems fine. I don't think that having incompatible solaris and illumos build tags is a good idea. It breaks a lot of existing code for no benefit.

Let's add two new build tags, solaris11x and illumos, and keep the solaris build tag around. By default, the solaris build tag will match both illumos and Oracle Solaris targets, which is what you want in 99% of cases anyway, and it doesn't break any existing code.

When one wants specific support for a particular Solaris variant, either one of solaris11x or illumos build tags is to be used.

(Don't get bogged on the specific names I chose for this example, the names don't matter, we can use other names like oraclesolaris and illumos, or whatever).

sean- · 2017-06-08T13:48:49Z

At the end of the day something needs to change as it is disingenuousness to users if we keep with the status quo and expect a GOOS="solaris" binary to run on either Oracle Solaris or Illumos.

If Oracle Solaris is moving to its own build tag (i.e. oraclesolaris), then sharing the solaris build tag with illumos seems fine. I think this is fine, but don'g want to obligate the Oracle community to this.

If Oracle Solaris is not going to use a new build tag, then I would object to having the solaris build tag be inclusive of illumos.

That said, we're decidedly 👍 to having Oracle Solaris get its own, new, and dedicated build tag to resolve any ambiguity going forward.

binarycrusader · 2017-06-08T23:12:03Z

I dislike bike-shedding, but for the record, I would discourage any build tag containing something that implies a "version" of some sort such as "11x", etc. While that may seem tempting, the public version is used for marketing purposes and isn't reliable as a way to discern differences in technical interfaces.

In particular, Solaris often "backports" functionality to the previous release while the next release is in development. As an example, Solaris 11.3 sometimes receives new functionality from what Solaris calls "SRUs" (the monthly updates that contain security fixes and other improvements) that are from the current in-development release.

As such, on Solaris, feature-test based builds are ideal. Unfortunately, Go's architecture (as far as I can tell) assumes runtime-based feature tests instead of build-time feature tests (unlike rust's build.rs) so that makes this difficult.

In an ideal world, I feel like the original build tag for solaris probably should have been "sunos", with the Sun/Oracle specific variant being "solaris" and "opensolaris" for the community derivatives. This makes sense too because "Solaris 11.3" is technically the marketing name and marketing version for the current release of SunOS 5.11.

However, since we don't live in an ideal world, I'd suggest "sunos" and "illumos" as the two new tags going forward; they're version-agnostic and reasonably accurate.

jtsylve · 2017-06-09T01:46:45Z

I'd suggest "sunos" and "illumos" as the two new tags going forward; they're version-agnostic and reasonably accurate.

This seems like a reasonable suggestion to me for all of the reason that @binarycrusader mentioned in his last comment.

jen20 · 2017-06-09T16:51:08Z

I am very much opposed to a system which tries to maintain compatibility between Oracle Solaris and Illumos distributions in a manner which would differ from every other GOOS. In my opinion we should keep the existing solaris build tag as referring to Oracle Solaris, and introduce illumos.

This reflects the way that the various BSDs operate, and therefore imposes no additional cognitive overhead on people who don't care about operating systems other than Linux and Darwin (which is, let's face it, most people!)

The short-term pain which will be experienced by the Illumos community to go through and add build tags to things outside the standard library is not to be minimised - but on the other hand nor is the cognitive overhead of a three-tier GOOS system on the rest of the world. I think we in the Illumos community should just deal with this short-term problem.

sean- · 2017-06-09T20:22:54Z

Given there appears to be no debate surrounding the illumos build tag, can we move forward with that?

@binarycrusader , if there is a desire to have Oracle Solaris be tagged with its own build tag, can that be submitted and addressed independently?

@bradfitz , short of a PR, what would you like the next steps to be?

binarycrusader · 2017-06-09T20:30:04Z

@sean- I'm not requesting a separate build tag for Solaris, I had only suggested it as a way to ease the transition for OpenSolaris-based derivatives. My current employer has sponsored much of the work done on Solaris at this point for Go, and I've pushed hard to maintain compatibility with OpenSolaris-based derivatives.

As such, I leave the decision on build tags up to the Go maintainers.

bradfitz · 2017-06-09T20:34:24Z

As such, I leave the decision on build tags up to the Go maintainers.

We (the Go maintainers) are not active Solaris or Illumos users. Ideally we'd prefer if the Solaris & Illumos would agree on a solution that solves the problems at hand. Maybe that's a new GOOS value. (A full fork, e.g. GOOS=freebsd vs GOOS=dragonfly) Maybe that's a build tag only for now.

Is it a goal (or non-goal) for binaries built for Solaris to run on Illumos, or vice versa?

binarycrusader · 2017-06-09T20:39:29Z

Solaris only guarantees binary compatibility for binaries built on an older version of the operating system so that it can run on a newer version. Because the standard libraries (libc) and the linkers are now significantly different, it's highly unlikely to work. With that in mind, I would assert that it is not a goal for binaries built for Solaris to run on OpenSolaris-based derivatives such as Illumos or vice/versa.

Both share a common set of system interfaces (many decades worth), but we're also nearing one decade of divergence. It's unclear to me what the intent is with Go's build tags vs. GOOS, so I can't say which should be the answer.

jen20 · 2017-06-09T20:39:36Z

@bradfitz I would treat it as a non goal for binaries built with (say) GOOS=solaris to work on Illumos and vice versa, though if they do it would be a happy accident.

IMO things would be best served moving forwards by treating Solaris and Illumos in the same manner as FreeBSD vs DragonflyBSD. Assuming @binarycrusader et al have no problem with that, it seems to be the path of least confusion, though admittedly with some short term pain.

sean- · 2017-06-09T20:42:35Z

@bradfitz Are you good with that agreement? It sounds like we have a consensus that everyone is happy with.

bradfitz · 2017-06-09T20:45:36Z

We'd like to do Go 1.9beta1 next week, and I don't think we can really do this before Go 1.10.

If we do GOOS=illumos, we'd need a GOOS=solaris builder first (#15072, which has been open for some time).

jen20 · 2017-06-09T20:50:02Z

@bradfitz I'm not sure on how a Solaris builder can be supplied beyond VirtualBox (perhaps @binarycrusader can help there), but I'm sure we at Joyent can run any necessary Illumos builders without issue. (cc @bcantrill).

bradfitz · 2017-06-09T21:00:28Z

We currently run Illumos builders on Joyent already. (but would love help improving our setup, if somebody has some time) It's the Solaris ones where we lack coverage.

binarycrusader · 2017-06-09T21:01:52Z

Solaris amd64 currently only supports Xen-based virtualization, Solaris-based virtualization (kernel zones), full virtualization (VirtualBox/VMWare), or bare metal provisioning. It does not have the virtio/virtnet drivers required by GCE (?).

bradfitz · 2017-06-09T21:20:46Z

We have 10 VMWare nodes. But I'd rather discuss on #15072.

rsc · 2017-06-19T20:58:35Z

Based on discussion above, switching to GOOS=illumos for Go 1.10 is fine. There's no need to have Solaris builders before then, although of course if we get further into the cycle with no Solaris builders we might reconsider GOOS=solaris entirely (golang.org/wiki/PortingPolicy). But that's just exposing a current problem (no Solaris builders, only Illumos ones), not introducing a new problem.

-rsc for @golang/proposal-review

bradfitz · 2019-04-26T21:07:16Z

I sent https://go-review.googlesource.com/c/go/+/174083/ as an example CL of what would be required to do this. Anybody want to pick it up, test it, and finish it?

You have a few days before Go 1.13 goes into freeze.

jclulow · 2019-04-26T21:31:19Z

@bradfitz Hi Brad! I can take a look at it, though that timeline is obviously a little tight as I don't have a strong background on all of the infrastructure here. When is the exact date of the freeze, and if we miss this round does that mean we're effectively waiting for Go 1.14? (When is that?)

As an aside, I have a rough prototype of a Virtio SCSI driver and some other changes required to get illumos running under GCE directly. I'm learning a bit more about how to parcel up and share a useful GCE image that others can consume.

bradfitz · 2019-04-26T21:34:14Z

Freezing May 1st. Tree opens again 3 months after that. https://golang.org/wiki/Go-Release-Cycle

jclulow · 2019-04-26T21:36:34Z

Thanks!

jclulow · 2019-04-27T19:01:39Z

@bradfitz I spent some time on this yesterday. I took your initial CL (thanks for the push in the right direction!) and have added in a bunch of extra changes, in parts using the android/linux split as a guide.

I have been able to cross build an illumos/amd64 toolchain using a stock solaris/amd64 1.12.1 toolchain I had available already. Using this cross built toolchain, I was then able to bootstrap a native build of the illumos/amd64 toolchain. All of the tests appear to pass on the final toolchain in this sequence.

I've enrolled my work gsuite account in the Gerrit instance, and I've kicked off the CLA signing process. My boss has signed it this morning, but I'm not sure how long it will take to show up in the system -- I can't see it yet.

Will I be able to adopt your existing CL and push an updated change to that, or should I start a new CL with the git codereview tool?

Like GOOS=android which implies the "linux" build tag, GOOS=illumos implies the "solaris" build tag. This lets the existing ecosystem of packages still work on illumos, but still permits packages to start differentiating between solaris and illumos. Fixes golang#20603 Change-Id: I8f4eabf1a66060538dca15d7658c1fbc6c826622

jclulow · 2019-04-29T21:01:16Z

@bradfitz I'd really like to get this in before the gate closes on May 1st. I've pushed the change that I have so far (which I feel is ready to go) to a branch on Github: TritonDataCenter@9ee73d2

I believe I've done all the right things with the HTTP cookies file and Gerrit, but I still can't appear to submit a CL:

$ git codereview pending -c
illumos 2b8cbc3..9ee73d2764 (current branch, 1 behind)
+ 9ee73d2764
	all: add new GOOS=illumos, split out of GOOS=solaris
	
	Like GOOS=android which implies the "linux" build tag, GOOS=illumos
	implies the "solaris" build tag. This lets the existing ecosystem of
	packages still work on illumos, but still permits packages to start
	differentiating between solaris and illumos.
	
	Fixes #20603
	
	Change-Id: I8f4eabf1a66060538dca15d7658c1fbc6c826622

	Files in this change:
		misc/cgo/test/sigaltstack.go
		misc/cgo/testcarchive/carchive_test.go
		misc/cgo/testcshared/cshared_test.go
		src/cmd/dist/build.go
		src/cmd/dist/main.go
		src/cmd/go/go_test.go
		src/cmd/go/internal/bug/bug.go
		src/cmd/go/internal/imports/build.go
		src/cmd/go/internal/lockedfile/internal/filelock/filelock_test.go
		src/cmd/go/internal/work/buildid.go
		src/cmd/go/internal/work/exec.go
		src/cmd/go/internal/work/init.go
		src/cmd/internal/objabi/head.go
		src/cmd/link/internal/ld/dwarf_test.go
		src/cmd/vendor/golang.org/x/sys/unix/sockcmsg_unix.go
		src/debug/gosym/pclntab_test.go
		src/go/build/build.go
		src/go/build/doc.go
		src/go/build/syslist.go
		src/net/error_test.go
		src/net/fd_unix.go
		src/net/interface_test.go
		src/net/listen_test.go
		src/net/tcpsock_test.go
		src/os/exec/exec_test.go
		src/os/os_test.go
		src/os/removeall_test.go
		src/os/user/user_test.go
		src/runtime/asm_amd64.s
		src/runtime/cgocall.go
		src/runtime/crash_unix_test.go
		src/runtime/internal/sys/gengoos.go
		src/runtime/internal/sys/zgoos_aix.go
		src/runtime/internal/sys/zgoos_android.go
		src/runtime/internal/sys/zgoos_darwin.go
		src/runtime/internal/sys/zgoos_dragonfly.go
		src/runtime/internal/sys/zgoos_freebsd.go
		src/runtime/internal/sys/zgoos_hurd.go
		src/runtime/internal/sys/zgoos_illumos.go
		src/runtime/internal/sys/zgoos_js.go
		src/runtime/internal/sys/zgoos_linux.go
		src/runtime/internal/sys/zgoos_nacl.go
		src/runtime/internal/sys/zgoos_netbsd.go
		src/runtime/internal/sys/zgoos_openbsd.go
		src/runtime/internal/sys/zgoos_plan9.go
		src/runtime/internal/sys/zgoos_solaris.go
		src/runtime/internal/sys/zgoos_windows.go
		src/runtime/internal/sys/zgoos_zos.go
		src/runtime/mem_bsd.go
		src/runtime/netpoll.go
		src/runtime/pprof/pprof_test.go
		src/runtime/proc.go
		src/runtime/rt0_illumos_amd64.s
		src/syscall/exec_unix.go
		src/syscall/sockcmsg_unix.go
		src/syscall/syscall_unix.go

$ git codereview mail
fatal: remote error: PERMISSION_DENIED The caller does not have permission
(running: git push -q origin HEAD:refs/for/master)
/home/jclulow/bin/git-codereview: exit status 128

We're having a bit of trouble with the CLA process. It seems a departed Joyent employee might have signed a CLA in the past, and we're struggling through the process of adopting/reactivating it at the moment. Would that prevent my being able to submit to Gerrit?

Smithx10 · 2019-04-29T23:09:54Z

@jclulow Whoa! This is great news! Hopefully @bradfitz can help clear up the CLA before the deadline and Illumos may finally have it's own tag. Definitely a win for both communities. Can't wait!

bradfitz · 2019-04-30T04:17:29Z

We're having a bit of trouble with the CLA process. It seems a departed Joyent employee might have signed a CLA in the past, and we're struggling through the process of adopting/reactivating it at the moment. Would that prevent my being able to submit to Gerrit?

There are two ways to submit code to Go: using Gerrit, or using GitHub PRs. Both require the same CLA process. We can't accept code without a CLA.

It looks like you need to join the go-contributors@$YOUR_COMPANY_DOMAIN mailing list.

jclulow · 2019-04-30T04:28:42Z

Thanks, Brad. I'll follow up with our internal IT folks tomorrow to see if we have one of those.

bradfitz · 2019-04-30T04:35:30Z

My guess is that it's a Google Group, so the URL would be:

https://groups.google.com/a/joyent.com/d/forum/go-contributors
or
https://groups.google.com/a/joyent.com/forum/#!forum/go-contributors

... which I think are identical.

gopherbot · 2019-04-30T04:45:55Z

Change https://golang.org/cl/174457 mentions this issue: all: add new GOOS=illumos, split out of GOOS=solaris

jclulow · 2019-04-30T04:46:07Z

@bradfitz, you're a steely-eyed missile man!

I've uploaded a CL: https://go-review.googlesource.com/c/go/+/174457

gopherbot · 2019-05-02T14:35:25Z

Change https://golang.org/cl/174958 mentions this issue: unix: add illumos case

From CL 174457 which modified this file's vendored copy in the "go" repo. Updates golang/go#20603 Change-Id: Ic89b2e772120a08ac0fa3a56acb93a8ee96ba337 Reviewed-on: https://go-review.googlesource.com/c/sys/+/174958 Reviewed-by: Tobias Klauser <tobias.klauser@gmail.com>

* cmd/compile: add unsigned divisibility rules "Division by invariant integers using multiplication" paper by Granlund and Montgomery contains a method for directly computing divisibility (x%c == 0 for c constant) by means of the modular inverse. The method is further elaborated in "Hacker's Delight" by Warren Section 10-17 This general rule can compute divisibilty by one multiplication and a compare for odd divisors and an additional rotate for even divisors. To apply the divisibility rule, we must take into account the rules to rewrite x%c = x-((x/c)*c) and (x/c) for c constant on the first optimization pass "opt". This complicates the matching as we want to match only in the cases where the result of (x/c) is not also available. So, we must match on the expanded form of (x/c) in the expression x == c*(x/c) in the "late opt" pass after common subexpresion elimination. Note, that if there is an intermediate opt pass introduced in the future we could simplify these rules by delaying the magic division rewrite to "late opt" and matching directly on (x/c) in the intermediate opt pass. Additional rules to lower the generic RotateLeft* ops were also applied. On amd64, the divisibility check is 25-50% faster. name old time/op new time/op delta DivconstI64-4 2.08ns ± 0% 2.08ns ± 1% ~ (p=0.881 n=5+5) DivisibleconstI64-4 2.67ns ± 0% 2.67ns ± 1% ~ (p=1.000 n=5+5) DivisibleWDivconstI64-4 2.67ns ± 0% 2.67ns ± 0% ~ (p=0.683 n=5+5) DivconstU64-4 2.08ns ± 1% 2.08ns ± 1% ~ (p=1.000 n=5+5) DivisibleconstU64-4 2.77ns ± 1% 1.55ns ± 2% -43.90% (p=0.008 n=5+5) DivisibleWDivconstU64-4 2.99ns ± 1% 2.99ns ± 1% ~ (p=1.000 n=5+5) DivconstI32-4 1.53ns ± 2% 1.53ns ± 0% ~ (p=1.000 n=5+5) DivisibleconstI32-4 2.23ns ± 0% 2.25ns ± 3% ~ (p=0.167 n=5+5) DivisibleWDivconstI32-4 2.27ns ± 1% 2.27ns ± 1% ~ (p=0.429 n=5+5) DivconstU32-4 1.78ns ± 0% 1.78ns ± 1% ~ (p=1.000 n=4+5) DivisibleconstU32-4 2.52ns ± 2% 1.26ns ± 0% -49.96% (p=0.000 n=5+4) DivisibleWDivconstU32-4 2.63ns ± 0% 2.85ns ±10% +8.29% (p=0.016 n=4+5) DivconstI16-4 1.54ns ± 0% 1.54ns ± 0% ~ (p=0.333 n=4+5) DivisibleconstI16-4 2.10ns ± 0% 2.10ns ± 1% ~ (p=0.571 n=4+5) DivisibleWDivconstI16-4 2.22ns ± 0% 2.23ns ± 1% ~ (p=0.556 n=4+5) DivconstU16-4 1.09ns ± 0% 1.01ns ± 1% -7.74% (p=0.000 n=4+5) DivisibleconstU16-4 1.83ns ± 0% 1.26ns ± 0% -31.52% (p=0.008 n=5+5) DivisibleWDivconstU16-4 1.88ns ± 0% 1.89ns ± 1% ~ (p=0.365 n=5+5) DivconstI8-4 1.54ns ± 1% 1.54ns ± 1% ~ (p=1.000 n=5+5) DivisibleconstI8-4 2.10ns ± 0% 2.11ns ± 0% ~ (p=0.238 n=5+4) DivisibleWDivconstI8-4 2.22ns ± 0% 2.23ns ± 2% ~ (p=0.762 n=5+5) DivconstU8-4 0.92ns ± 1% 0.94ns ± 1% +2.65% (p=0.008 n=5+5) DivisibleconstU8-4 1.66ns ± 0% 1.26ns ± 1% -24.28% (p=0.008 n=5+5) DivisibleWDivconstU8-4 1.79ns ± 0% 1.80ns ± 1% ~ (p=0.079 n=4+5) A follow-up change will address the signed division case. Updates #30282 Change-Id: I7e995f167179aa5c76bb10fbcbeb49c520943403 Reviewed-on: https://go-review.googlesource.com/c/go/+/168037 Run-TryBot: Brian Kessler <brian.m.kessler@gmail.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Keith Randall <khr@golang.org> * cmd/link/internal/ld: consolidate macho platform setup Determine the macho platform once and use that the two places that need it. This makes it easier to add a third platform check for a follow-up change. Updates #31447 Change-Id: I522a5fface647ab8e608f816c5832d531534df7a Reviewed-on: https://go-review.googlesource.com/c/go/+/174198 Run-TryBot: Elias Naur <mail@eliasnaur.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Keith Randall <khr@golang.org> * cmd/link/internal/ld,syscall: drop $INODE64 suffixes on simulators Some libc functions are suffixed with "$INODE64" on macOS. Unfortunately, the iOS simulator doesn't have the suffixes, so we can't use GOARCH to distinguish the two platform. Add linker support for adding the suffix, using the macho platform to determine whether it is needed. While here, add the correct suffix for fdopendir on 386. It's "$INODE64$UNIX2003", believe it or not. Without the suffix, GOARCH=386 go test -short syscall crashes on my Mojave machine. Fixes #31447 Change-Id: I9bd3de40ece7df62f744bc24cd00909e56b00b78 Reviewed-on: https://go-review.googlesource.com/c/go/+/174199 TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Keith Randall <khr@golang.org> * cmd/link/internal/ld,syscall: replace getfsstat64 with getfsstat getfsstat64 is deprecated but not yet caught by the App Store checks. Use the supported getfsstat$INODE64 form instead to ensure forward compatibility. Change-Id: I0d97e8a8b254debb3de1cfcb3778dbed3702c249 Reviewed-on: https://go-review.googlesource.com/c/go/+/174200 Run-TryBot: Elias Naur <mail@eliasnaur.com> Reviewed-by: Keith Randall <khr@golang.org> * cmd/go/internal/renameio: use ERROR_ACCESS_DENIED to check for errors CL 172418 added code to check for "Access is denied" error. But "Access is denied" error will be spelled differently on non-English version of Windows. Check if error is ERROR_ACCESS_DENIED instead. Updates #31247 Change-Id: I7b1633013d563f7c06c1f12a9be75122106834f9 Reviewed-on: https://go-review.googlesource.com/c/go/+/174123 Reviewed-by: Emmanuel Odeke <emm.odeke@gmail.com> * syscall: allow setting security attributes on processes This allows creating processes that can only be debugged/accessed by certain tokens, according to a particular security descriptor. We already had everything ready for this but just neglected to pass through the value from the user-accessible SysProcAttr. Change-Id: I4a3fcc9f5078aa0058b26c103355c984093ae03f Reviewed-on: https://go-review.googlesource.com/c/go/+/174197 Run-TryBot: Jason Donenfeld <Jason@zx2c4.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Alex Brainman <alex.brainman@gmail.com> * runtime: remove spurious register loads for openbsd/amd64 kqueue The kqueue system call takes no arguments, hence there should be no need to zero the registers used for the first syscall arguments. Change-Id: Ia79b2d4f4d568bb6795cb885e1464cf1fc2bf7c7 Reviewed-on: https://go-review.googlesource.com/c/go/+/174128 Run-TryBot: Benny Siegert <bsiegert@gmail.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Benny Siegert <bsiegert@gmail.com> * cmd/compile: intrinsify math/bits.Add64 for ppc64x This change creates an intrinsic for Add64 for ppc64x and adds a testcase for it. name old time/op new time/op delta Add64-160 1.90ns ±40% 2.29ns ± 0% ~ (p=0.119 n=5+5) Add64multiple-160 6.69ns ± 2% 2.45ns ± 4% -63.47% (p=0.016 n=4+5) Change-Id: I9abe6fb023fdf62eea3c9b46a1820f60bb0a7f97 Reviewed-on: https://go-review.googlesource.com/c/go/+/173758 Reviewed-by: Lynn Boger <laboger@linux.vnet.ibm.com> Run-TryBot: Carlos Eduardo Seo <cseo@linux.vnet.ibm.com> * runtime: whitelist debugCall32..debugCall65536 in debugCallCheck Whitelists functions debugCall32 through debugCall65536 in runtime.debugCallCheck so that any instruction inside those functions is considered a safe point. This is useful for implementing nested function calls. For example when evaluating: f(g(x)) The debugger should: 1. initiate the call to 'f' until the entry point of 'f', 2. complete the call to 'g(x)' 3. copy the return value of 'g(x)' in the arguments of 'f' 4. complete the call to 'f' Similarly for: f().amethod() The debugger should initiate the call to '.amethod()', then initiate and complete the call to f(), copy the return value to the arguments of '.amethod()' and finish its call. However in this example, unlike the other example, it may be impossible to determine the entry point of '.amethod()' until after 'f()' is evaluated, which means that the call to 'f()' needs to be initiated while stopped inside a debugCall... function. Change-Id: I575c23542709cedb1a171d63576f7e11069c7674 Reviewed-on: https://go-review.googlesource.com/c/go/+/161137 TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Heschi Kreinick <heschi@google.com> * strconv: Document ParseFloat's special cases Updates #30990 Change-Id: I968fb13251ab3796328089046a3f0fc5c7eb9df9 Reviewed-on: https://go-review.googlesource.com/c/go/+/174204 Reviewed-by: Benny Siegert <bsiegert@gmail.com> Run-TryBot: Benny Siegert <bsiegert@gmail.com> TryBot-Result: Gobot Gobot <gobot@golang.org> * cmd/go: implement Go checksum database support This CL adds support for consulting the Go checksum database when downloading a module that is not already listed in go.sum. The overall system is described at golang.org/design/25530-sumdb, and this CL implements the functionality described specifically in golang.org/design/25530-sumdb#command-client. Although the eventual plan is to set GOPROXY and GOSUMDB to default to a Google-run proxy serving the public Go ecosystem, this CL leaves them off by default. Fixes #30601. Change-Id: Ie46140f93c6cc2d85573fbce0878a258819ff44d Reviewed-on: https://go-review.googlesource.com/c/go/+/173951 Run-TryBot: Russ Cox <rsc@golang.org> Reviewed-by: Emmanuel Odeke <emm.odeke@gmail.com> Reviewed-by: Jay Conrod <jayconrod@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> * encoding/json: add a Fuzz function Adds a sample Fuzz test function to package encoding/json following the guidelines defined in #31309, based on https://github.com/dvyukov/go-fuzz-corpus/blob/master/json/json.go Fixes #31309 Updates #19109 Change-Id: I5fe04d9a5f41c0de339f8518dae30896ec14e356 Reviewed-on: https://go-review.googlesource.com/c/go/+/174058 Reviewed-by: Dmitry Vyukov <dvyukov@google.com> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Run-TryBot: Dmitry Vyukov <dvyukov@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> * all: remove a few unused parameters I recently modified tabwriter to reduce the number of defers due to flush calls. However, I forgot to notice that the new function flushNoDefers can no longer return an error, due to the lack of the defer. In crypto/tls, hashForServerKeyExchange never returned a non-nil error, so simplify the code. Finally, in go/types and net we can find a few trivially unused parameters, so remove them. Change-Id: I54c8de83fbc944df432453b55c93008d7e810e61 Reviewed-on: https://go-review.googlesource.com/c/go/+/174131 Run-TryBot: Daniel Martí <mvdan@mvdan.cc> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Benny Siegert <bsiegert@gmail.com> * net/http: remove "number:" from Response.Status string The behavior of Value.String method on non-string JavaScript types has changed after CL 169757. Update the implementation of Transport.RoundTrip method to construct the Response.Status string without relying on result.Get("status").String(), since that now returns strings like "<number: 200>" instead of "200". Fixes #31736 Change-Id: I27b3e6cc95aa65fd1918b1400e88478a154aad12 Reviewed-on: https://go-review.googlesource.com/c/go/+/174218 Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Reviewed-by: Richard Musiol <neelance@gmail.com> * cmd/link/internal/s390x: fix s390x build Fix breakage from CL 173437 Change-Id: If218ffaa1259fbdee641143ffbe4b38030c373b9 Reviewed-on: https://go-review.googlesource.com/c/go/+/174278 Reviewed-by: Michael Munday <mike.munday@ibm.com> Reviewed-by: Cherry Zhang <cherryyz@google.com> * net: correct docs of KeepAlive field in Dialer type KeepAlive field used to report the wording "keep-alive period" which may be misleading. This field does not represent the whole TCP keepalive time, that is the inactivity period upon which one endpoint starts probing the other end. But it acctually specifies the keepalive interval, that is the time between two keepalive probes. Fixes #29089 Change-Id: If99b38ba108830d0e5fe527171a2f5c96a3bcde7 Reviewed-on: https://go-review.googlesource.com/c/go/+/155960 Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> * misc/wasm: fix command line arguments containing multi-byte characters Command line arguments containing multi-byte characters were causing go_js_wasm_exec to crash (RangeError: Source is too large), because their byte length was not handled correctly. This change fixes the bug. Fixes #31645. Change-Id: I7860ebf5b12da37d9d0f43d4b6a22d326a90edaf Reviewed-on: https://go-review.googlesource.com/c/go/+/173877 Run-TryBot: Richard Musiol <neelance@gmail.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Emmanuel Odeke <emm.odeke@gmail.com> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> * runtime: initialise cpu.HWCap on openbsd/arm64 OpenBSD does not provide auxv, however we still need to initialise cpu.HWCap. For now initialise it to the bare minimum, until some form of CPU capability detection is implemented or becomes available - see issue #31746. Updates #31656 Change-Id: I68c3c069319fe60dc873f46def2a67c9f3d937d5 Reviewed-on: https://go-review.googlesource.com/c/go/+/174129 TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> * runtime: support all as parameter in gdb goroutine commands. For example, can use `goroutine all bt` to dump all goroutines' information. Change-Id: I51b547c2b837913e4bdabf0f45b28f09250a3e34 GitHub-Last-Rev: d04dcd4f581f97e35ee45969a864f1270d79e49b GitHub-Pull-Request: golang/go#26283 Reviewed-on: https://go-review.googlesource.com/c/go/+/122589 Run-TryBot: Emmanuel Odeke <emm.odeke@gmail.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Emmanuel Odeke <emm.odeke@gmail.com> Reviewed-by: David Chase <drchase@google.com> * os/exec: always set SYSTEMROOT on Windows if not listed in Cmd.Env Fixes #25210 Change-Id: If27b61776154dae9b9b67bf4e4f5faa785d98105 Reviewed-on: https://go-review.googlesource.com/c/go/+/174318 Reviewed-by: Ian Lance Taylor <iant@golang.org> * runtime/cgo: ignore missing Info.plist files on iOS When running Go programs on Corellium virtual iPhones, the Info.plist files might not exist. Ignore the error. Updates #31722 Change-Id: Id2e315c09346b69dda9e10cf29fb5dba6743aac4 Reviewed-on: https://go-review.googlesource.com/c/go/+/174202 Run-TryBot: Elias Naur <mail@eliasnaur.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> * syscall: don't return EINVAL on zero Chmod mode on Windows Fixes #20858 Change-Id: I45c397795426aaa276b20f5cbeb80270c95b920c Reviewed-on: https://go-review.googlesource.com/c/go/+/174320 Reviewed-by: Ian Lance Taylor <iant@golang.org> Run-TryBot: Ian Lance Taylor <iant@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> * testing: delay flag registration; move to an Init function Any code that imports the testing package forces the testing flags to be defined, even in non-test binaries. People work around this today by defining a copy of the testing.TB interface just to avoid importing testing. Fix this by moving flag registration into a new function, testing.Init. Delay calling Init until the testing binary begins to run, in testing.MainStart. Init is exported for cases where users need the testing flags to be defined outside of a "go test" context. In particular, this may be needed where testing.Benchmark is called outside of a test. Fixes #21051 Change-Id: Ib7e02459e693c26ae1ba71bbae7d455a91118ee3 Reviewed-on: https://go-review.googlesource.com/c/go/+/173722 Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> * runtime: make mmap return 0 instead of -1 on aix/ppc64 Most of the platforms are returning 0 instead of -1 when mmap syscalls is failing. This patch corrects it for AIX in order to fix TestMmapErrorSign and to improve AIX compatibility. Change-Id: I1dad88d0e69163ad55c504b2b4a997892fd876cd Reviewed-on: https://go-review.googlesource.com/c/go/+/174297 Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org> * cmd/go: add XCOFF format handler for go version Change-Id: Ib102ae95acfd89fc3c9942a4ec82c74362f62045 Reviewed-on: https://go-review.googlesource.com/c/go/+/174299 Run-TryBot: Ian Lance Taylor <iant@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org> * runtime: account for callbacks in checkdead on Windows When a callback runs on a different thread in Windows, as in the runtime package test TestCallbackInAnotherThread, it will use the extra M. That can cause the test in checkdead to fail incorrectly. Check whether there actually is an extra M before expecting it. I think this is a general problem unrelated to timers. I think the test was passing previously because the timer goroutine was using an M. But I haven't proved that. This change seems correct, and it avoids the test failure when using the new timers on Windows. Updates #27707 Change-Id: Ieb31c04ff0354d6fae7e173b59bcfadb8b0464cd Reviewed-on: https://go-review.googlesource.com/c/go/+/174037 Reviewed-by: Keith Randall <khr@golang.org> * cmd,runtime: enable cgo for openbsd/arm64 Updates #31656. Change-Id: Ide6f829282fcdf20c67998b766a201a6a92c3035 Reviewed-on: https://go-review.googlesource.com/c/go/+/174132 Run-TryBot: Ian Lance Taylor <iant@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org> * cmd/compile: evaluate map initializers incrementally For the code: m := map[int]int { a(): b(), c(): d(), e(): f(), } We used to do: t1 := a() t2 := b() t3 := c() t4 := d() t5 := e() t6 := f() m := map[int]int{} m[t1] = t2 m[t3] = t4 m[t5] = t6 After this CL we do: m := map[int]int{} t1 := a() t2 := b() m[t1] = t2 t3 := c() t4 := d() m[t3] = t4 t5 := e() t6 := f() m[t5] = t6 Ordering the initialization this way limits the lifetime of the temporaries involved. In particular, for large maps the number of simultaneously live temporaries goes from ~2*len(m) to ~2. This change makes the compiler (regalloc, mostly) a lot happier. The compiler runs faster and uses a lot less memory. For #26546, changes compile time of a big map from 8 sec to 0.5 sec. Fixes #26552 Update #26546 Change-Id: Ib7d202dead3feaf493a464779fd9611c63fcc25f Reviewed-on: https://go-review.googlesource.com/c/go/+/174417 Run-TryBot: Keith Randall <khr@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com> * cmd/go: add test of $GONOPROXY, $GONOSUMDB behavior Change-Id: I8a4917ce14ea22d5991226e485d43a9c9312950e Reviewed-on: https://go-review.googlesource.com/c/go/+/174219 Run-TryBot: Russ Cox <rsc@golang.org> Reviewed-by: Jay Conrod <jayconrod@google.com> * encoding/json: fix Unmarshal hang on recursive pointers indirect walks down v until it gets to a non-pointer. But it does not handle the case when v is a pointer to itself, like in: var v interface{} v = &v Unmarshal(b, v) So just stop immediately if we see v is a pointer to itself. Fixes #31740 Change-Id: Ie396264119e24d70284cd9bf76dcb2050babb069 Reviewed-on: https://go-review.googlesource.com/c/go/+/174337 Run-TryBot: Daniel Martí <mvdan@mvdan.cc> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Daniel Martí <mvdan@mvdan.cc> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> * runtime: do not use heap arena hints on wasm The address space of WebAssembly's linear memory is contiguous, so requesting specific addresses is not supported. Do not use heap arena hints so we do not have unused memory ranges. This fixes go1 benchmarks on wasm which ran out of memory since https://golang.org/cl/170950. Change-Id: I70115b18dbe43abe16dd5f57996343d97bf94760 Reviewed-on: https://go-review.googlesource.com/c/go/+/174203 Run-TryBot: Richard Musiol <neelance@gmail.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Cherry Zhang <cherryyz@google.com> * cmd/internal/obj/wasm: cache SP in a local We use Wasm global variables extensively for simulating registers, especially SP. V8 does not handle global variables efficiently. This CL reduces global variable accesses by caching the global SP in a local variable in each function. The local cache is set on function entry and updated after each call (where the stack could have moved). Within a function, the SP access will use the local variable. Supersedes https://golang.org/cl/173979. Running on Chrome Version 73.0.3683.103 on darwin/amd64: name old time/op new time/op delta BinaryTree17 15.3s ± 2% 14.5s ± 3% -5.20% (p=0.000 n=9+10) Fannkuch11 8.91s ± 2% 9.48s ± 2% +6.41% (p=0.000 n=9+10) FmtFprintfEmpty 197ns ± 5% 165ns ± 3% -16.09% (p=0.000 n=9+8) FmtFprintfString 354ns ± 8% 325ns ± 7% -8.33% (p=0.001 n=10+10) FmtFprintfInt 400ns ± 4% 368ns ± 6% -8.01% (p=0.000 n=10+10) FmtFprintfIntInt 618ns ± 3% 587ns ± 6% -4.97% (p=0.001 n=10+10) FmtFprintfPrefixedInt 637ns ± 4% 606ns ± 4% -4.88% (p=0.000 n=10+10) FmtFprintfFloat 965ns ± 7% 898ns ± 4% -6.97% (p=0.000 n=10+10) FmtManyArgs 2.34µs ± 1% 2.24µs ± 3% -4.40% (p=0.000 n=9+10) GobDecode 29.8ms ± 3% 28.8ms ± 6% -3.60% (p=0.006 n=9+10) GobEncode 20.5ms ± 8% 17.6ms ± 3% -14.32% (p=0.000 n=10+10) Gzip 714ms ± 3% 718ms ± 8% ~ (p=0.971 n=10+10) Gunzip 148ms ± 3% 136ms ± 3% -7.99% (p=0.000 n=10+9) HTTPClientServer 219µs ± 3% 215µs ± 4% ~ (p=0.190 n=10+10) JSONEncode 35.1ms ± 2% 31.8ms ±13% -9.52% (p=0.002 n=10+10) JSONDecode 220ms ± 3% 207ms ± 5% -5.87% (p=0.000 n=10+10) Mandelbrot200 5.22ms ± 1% 5.11ms ± 4% -2.11% (p=0.027 n=8+10) GoParse 17.2ms ± 6% 16.1ms ± 5% -6.63% (p=0.000 n=10+9) RegexpMatchEasy0_32 375ns ± 3% 340ns ± 3% -9.25% (p=0.000 n=10+10) RegexpMatchEasy0_1K 2.70µs ± 3% 2.65µs ± 4% ~ (p=0.118 n=10+10) RegexpMatchEasy1_32 341ns ± 2% 305ns ± 4% -10.62% (p=0.000 n=9+10) RegexpMatchEasy1_1K 3.20µs ± 3% 2.99µs ± 3% -6.35% (p=0.000 n=10+10) RegexpMatchMedium_32 520ns ± 3% 501ns ± 4% -3.64% (p=0.002 n=9+10) RegexpMatchMedium_1K 145µs ± 7% 128µs ± 3% -11.57% (p=0.000 n=9+10) RegexpMatchHard_32 7.88µs ± 3% 7.01µs ± 5% -10.97% (p=0.000 n=10+10) RegexpMatchHard_1K 237µs ± 5% 207µs ± 4% -12.71% (p=0.000 n=9+10) Revcomp 2.34s ± 1% 2.31s ± 5% ~ (p=0.230 n=7+10) Template 261ms ± 7% 246ms ± 5% -5.93% (p=0.007 n=10+10) TimeParse 1.47µs ± 3% 1.39µs ± 5% -5.75% (p=0.000 n=9+10) TimeFormat 1.52µs ± 3% 1.43µs ± 4% -6.42% (p=0.000 n=8+10) name old speed new speed delta GobDecode 25.7MB/s ± 3% 26.7MB/s ± 5% +3.77% (p=0.006 n=9+10) GobEncode 37.5MB/s ± 8% 43.7MB/s ± 3% +16.61% (p=0.000 n=10+10) Gzip 27.2MB/s ± 3% 27.0MB/s ± 7% ~ (p=0.971 n=10+10) Gunzip 131MB/s ± 3% 142MB/s ± 5% +8.07% (p=0.000 n=10+10) JSONEncode 55.2MB/s ± 2% 61.2MB/s ±12% +10.80% (p=0.002 n=10+10) JSONDecode 8.84MB/s ± 3% 9.39MB/s ± 5% +6.28% (p=0.000 n=10+10) GoParse 3.37MB/s ± 6% 3.61MB/s ± 5% +7.09% (p=0.000 n=10+9) RegexpMatchEasy0_32 85.3MB/s ± 3% 94.0MB/s ± 3% +10.20% (p=0.000 n=10+10) RegexpMatchEasy0_1K 379MB/s ± 3% 387MB/s ± 4% ~ (p=0.123 n=10+10) RegexpMatchEasy1_32 93.9MB/s ± 2% 105.1MB/s ± 4% +11.96% (p=0.000 n=9+10) RegexpMatchEasy1_1K 320MB/s ± 3% 342MB/s ± 3% +6.79% (p=0.000 n=10+10) RegexpMatchMedium_32 1.92MB/s ± 2% 2.00MB/s ± 3% +3.94% (p=0.001 n=9+10) RegexpMatchMedium_1K 7.09MB/s ± 6% 8.01MB/s ± 3% +13.00% (p=0.000 n=9+10) RegexpMatchHard_32 4.06MB/s ± 3% 4.56MB/s ± 5% +12.38% (p=0.000 n=10+10) RegexpMatchHard_1K 4.32MB/s ± 4% 4.96MB/s ± 4% +14.60% (p=0.000 n=9+10) Revcomp 109MB/s ± 1% 110MB/s ± 5% ~ (p=0.219 n=7+10) Template 7.44MB/s ± 8% 7.91MB/s ± 5% +6.30% (p=0.007 n=10+10) Change-Id: I5828cf6b23ce104c02addc2642aba48dd6c48aab Reviewed-on: https://go-review.googlesource.com/c/go/+/174062 Run-TryBot: Richard Musiol <neelance@gmail.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Cherry Zhang <cherryyz@google.com> * cmd/go/internal/modfetch: fix concurrent read/write race in modfetch On Windows systems, the failure rate for cmd/go's TestScript/mod_concurrent is somewhere around 3-10% without this change. With the change, I have yet to see a failure. Fixes #31744. Change-Id: Ib321ebb9556dd8438086cf329dfa083a9e051732 Reviewed-on: https://go-review.googlesource.com/c/go/+/174439 Run-TryBot: Russ Cox <rsc@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> * encoding/csv: add a Fuzz function Adds a sample Fuzz test function to package encoding/csv based on https://github.com/dvyukov/go-fuzz-corpus/blob/master/csv/main.go Updates #19109 Updates #31309 Change-Id: Ieb0cb6caa1df72dbb7e29df4bdeed0bfa91187d3 Reviewed-on: https://go-review.googlesource.com/c/go/+/174302 Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> * cmd/go: say to confirm import path when it's not found Fixes #31366. Change-Id: Ief26f53e7fe94bedb7db79d3d7130c4cdcec4281 Reviewed-on: https://go-review.googlesource.com/c/go/+/174179 Run-TryBot: Jay Conrod <jayconrod@google.com> Reviewed-by: Jay Conrod <jayconrod@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> * html: add a Fuzz function Adds a sample Fuzz test function to package html based on https://github.com/dvyukov/go-fuzz-corpus/blob/master/stdhtml/main.go Updates #19109 Updates #31309 Change-Id: I8c49fff8f70fc8a8813daf1abf0044752003adbb Reviewed-on: https://go-review.googlesource.com/c/go/+/174301 Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> * cmd/dist: disable cgo for darwin/386 Fixes #31751 Change-Id: Id002f14557a34accc3597cb1b9a42e838a027da4 Reviewed-on: https://go-review.googlesource.com/c/go/+/174497 Reviewed-by: Keith Randall <khr@golang.org> Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> * runtime: implement pthread functions for darwin/arm64 They were not needed when Go only produced binaries with cgo suppport. Now that Go is about to run self-hosted on iOS we do need these. Updates #31722 Change-Id: If233aa2b31edc7b1c2dcac68974f9fba0604f9a3 Reviewed-on: https://go-review.googlesource.com/c/go/+/174300 Run-TryBot: Elias Naur <mail@eliasnaur.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Keith Randall <khr@golang.org> * cmd/link: add .go.buildinfo in XCOFF symbol table .go.buildinfo must be added to the symbol table on AIX. Otherwise, ld won't be able to handle its relocations. This patch also make ".data" the default section for all symbols inside the data segment. Change-Id: I83ac2bf1050e0ef6ef9c96ff793efd4ddc8e98d7 Reviewed-on: https://go-review.googlesource.com/c/go/+/174298 Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> * all: add new GOOS=illumos, split out of GOOS=solaris Like GOOS=android which implies the "linux" build tag, GOOS=illumos implies the "solaris" build tag. This lets the existing ecosystem of packages still work on illumos, but still permits packages to start differentiating between solaris and illumos. Fixes #20603 Change-Id: I8f4eabf1a66060538dca15d7658c1fbc6c826622 Reviewed-on: https://go-review.googlesource.com/c/go/+/174457 Run-TryBot: Benny Siegert <bsiegert@gmail.com> Reviewed-by: Benny Siegert <bsiegert@gmail.com> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> * runtime: fix data sizes for res_search results The return values are 32 bit, not 64 bit. I don't think this would be the cause of any problems, but it can't hurt to fix it. Change-Id: Icdd50606360ab9d74070271f9d1721d5fe640bc7 Reviewed-on: https://go-review.googlesource.com/c/go/+/174518 Run-TryBot: Keith Randall <khr@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> * cmd/go/internal/modcmd: allow mod download without go.mod Fixes #29522 Change-Id: I48f3a945d24c23c7c7ef5c7f1fe5046b6b2898e9 Reviewed-on: https://go-review.googlesource.com/c/go/+/157937 Run-TryBot: Bryan C. Mills <bcmills@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Bryan C. Mills <bcmills@google.com> * all: refer to map elements as elements instead of values The spec carefully and consistently uses "key" and "element" as map terminology. The implementation, not so much. This change attempts to make the implementation consistently hew to the spec's terminology. Beyond consistency, this has the advantage of avoid some confusion and naming collisions, since v and value are very generic and commonly used terms. I believe that I found all everything, but there are a lot of non-obvious places for these to hide, and grepping for them is hard. Hopefully this change changes enough of them that we will start using elem going forward. Any remaining hidden cases can be removed ad hoc as they are discovered. The only externally-facing part of this change is in package reflect, where there is a minor doc change and a function parameter name change. Updates #27167 Change-Id: I2f2d78f16c360dc39007b9966d5c2046a29d3701 Reviewed-on: https://go-review.googlesource.com/c/go/+/174523 Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> * encoding/gob: adding missing fuzz skip to one of the fuzz tests It's slow & often times out randomly on longtest builders. Not useful. Fixes #31517 Change-Id: Icedbb0c94fbe43d04e8b47d5785ac61c5e2d8750 Reviewed-on: https://go-review.googlesource.com/c/go/+/174522 Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org> Reviewed-by: Bryan C. Mills <bcmills@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> * cmd/dist: set the default external linker on platforms without gcc The go tool already sets -extld to the appropriate compiler. This CL changes cmd/dist to do the same, to fix bootstrapping on platforms that only have clang (Android and iOS). Updates #31722 Change-Id: I8a4fd227f85a768053a8946198eab68bbbdf9ae5 Reviewed-on: https://go-review.googlesource.com/c/go/+/174305 Run-TryBot: Elias Naur <mail@eliasnaur.com> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> * cmd/dist: detect GOHOSTARCH on iOS cmd/dist defaults to GOHOSTARCH=amd64 on darwin because no other darwin host could build Go. With the upcoming self-hosted iOS builders, GOHOSTARCH=arm64 is also possible. Updates #31722 Change-Id: I9af47d9f8c57ea45475ce498acefbfe6bf4815b9 Reviewed-on: https://go-review.googlesource.com/c/go/+/174306 Run-TryBot: Elias Naur <mail@eliasnaur.com> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> * cmd/go: derive executable name from package path in 'go run' Change name of temporary executable on go run . to directory name. Fixes #31571 Change-Id: I0a0ce74154e76205bb43805c95bd7fb8fd2dfd01 GitHub-Last-Rev: e0964983e18a1d45b55f7098c7489059708c7e5e GitHub-Pull-Request: golang/go#31614 Reviewed-on: https://go-review.googlesource.com/c/go/+/173297 Run-TryBot: Jay Conrod <jayconrod@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Jay Conrod <jayconrod@google.com> * time: look for zoneinfo.zip in GOROOT The zoneinfo.zip file will be in the $GOROOT in self-hsoted builds on iOS. Updates #31722 Change-Id: I991fae92e3dc50581b099a2d8901aed36ecc7cef Reviewed-on: https://go-review.googlesource.com/c/go/+/174310 Run-TryBot: Elias Naur <mail@eliasnaur.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> * cmd/go: query modules in parallel Refactor modload.QueryPackage and modload.QueryPattern to share code. Fine-tune error reporting and make it consistent between QueryPackage and QueryPattern. Expand tests for pattern errors. Update a TODO in modget/get.go and add a test case that demonstrates it. Updates #26232 Change-Id: I900ca8de338ef9a51b7f85ed93d8bcf837621646 Reviewed-on: https://go-review.googlesource.com/c/go/+/173017 Run-TryBot: Bryan C. Mills <bcmills@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Jay Conrod <jayconrod@google.com> * net/http: make Server return 501 for unsupported transfer-encodings Ensures that our HTTP/1.X Server properly responds with a 501 Unimplemented as mandated by the spec at RFC 7230 Section 3.3.1, which says: A server that receives a request message with a transfer coding it does not understand SHOULD respond with 501 (Unimplemented). Fixes #30710 Change-Id: I096904e6df053cd1e4b551774cc27523ff3d09f6 Reviewed-on: https://go-review.googlesource.com/c/go/+/167017 Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> * cmd/go,cmd/internal/sys,cmd/link: skip Go build ids for externally linked tools cmd/go already skips build ids on Android where buildmode=pie is forced. Expand the check to all externally linked tools. Necessary for self-hosted iOS builds where PIE is not forced but external linking is. Updates #31722 Change-Id: Iad796a9411a37eb0c44d365b70a3c5907537e461 Reviewed-on: https://go-review.googlesource.com/c/go/+/174307 Run-TryBot: Elias Naur <mail@eliasnaur.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org> * cmd/go/internal/modfetch/codehost: disable fetch of server-resolved commit hash We cannot rely on the server to filter out the refs we don't want (we only want refs/heads/* and refs/tags/*), so do not give it the full hash. Fixes #31191. Change-Id: If1208c35954228aa6e8734f8d5f1725d0ec79c87 Reviewed-on: https://go-review.googlesource.com/c/go/+/174517 Run-TryBot: Russ Cox <rsc@golang.org> Reviewed-by: Bryan C. Mills <bcmills@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> * cmd/compile: remove dynamic entry handling from sinit/maplit The order pass now handles all the dynamic entries. Update #26552 Followup to CL 174417 Change-Id: Ie924cadb0e0ba36c423868f654f13040100b44c6 Reviewed-on: https://go-review.googlesource.com/c/go/+/174498 Run-TryBot: Keith Randall <khr@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com> * os: fix tests on self-hosted Go builds Updates #31722 Change-Id: I467bb2539f993fad642abf96388a58a263fbe007 Reviewed-on: https://go-review.googlesource.com/c/go/+/174311 Run-TryBot: Elias Naur <mail@eliasnaur.com> Reviewed-by: Ian Lance Taylor <iant@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> * cmd/asm: reject BSWAPW on amd64 Since BSWAP operation on 16-bit registers is undefined, forbid the usage of BSWAPW. Users should rely on XCHGB instead. This behavior is consistent with what GAS does. Fixes #29167 Change-Id: I3b31e3dd2acfd039f7564a1c17e6068617bcde8d Reviewed-on: https://go-review.googlesource.com/c/go/+/174312 Run-TryBot: Iskander Sharipov <quasilyte@gmail.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> * cmd/compile: fix line numbers for index panics In the statement x = a[i], the index panic should appear to come from the line number of the '['. Previous to this CL we sometimes used the line number of the '=' instead. Fixes #29504 Change-Id: Ie718fd303c1ac2aee33e88d52c9ba9bcf220dea1 Reviewed-on: https://go-review.googlesource.com/c/go/+/174617 Run-TryBot: Keith Randall <khr@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> * cmd/compile: add signed divisibility rules "Division by invariant integers using multiplication" paper by Granlund and Montgomery contains a method for directly computing divisibility (x%c == 0 for c constant) by means of the modular inverse. The method is further elaborated in "Hacker's Delight" by Warren Section 10-17 This general rule can compute divisibilty by one multiplication, and add and a compare for odd divisors and an additional rotate for even divisors. To apply the divisibility rule, we must take into account the rules to rewrite x%c = x-((x/c)*c) and (x/c) for c constant on the first optimization pass "opt". This complicates the matching as we want to match only in the cases where the result of (x/c) is not also needed. So, we must match on the expanded form of (x/c) in the expression x == c*(x/c) in the "late opt" pass after common subexpresion elimination. Note, that if there is an intermediate opt pass introduced in the future we could simplify these rules by delaying the magic division rewrite to "late opt" and matching directly on (x/c) in the intermediate opt pass. On amd64, the divisibility check is 30-45% faster. name old time/op new time/op delta` DivisiblePow2constI64-4 0.83ns ± 1% 0.82ns ± 0% ~ (p=0.079 n=5+4) DivisibleconstI64-4 2.68ns ± 1% 1.87ns ± 0% -30.33% (p=0.000 n=5+4) DivisibleWDivconstI64-4 2.69ns ± 1% 2.71ns ± 3% ~ (p=1.000 n=5+5) DivisiblePow2constI32-4 1.15ns ± 1% 1.15ns ± 0% ~ (p=0.238 n=5+4) DivisibleconstI32-4 2.24ns ± 1% 1.20ns ± 0% -46.48% (p=0.016 n=5+4) DivisibleWDivconstI32-4 2.27ns ± 1% 2.27ns ± 1% ~ (p=0.683 n=5+5) DivisiblePow2constI16-4 0.81ns ± 1% 0.82ns ± 1% ~ (p=0.135 n=5+5) DivisibleconstI16-4 2.11ns ± 2% 1.20ns ± 1% -42.99% (p=0.008 n=5+5) DivisibleWDivconstI16-4 2.23ns ± 0% 2.27ns ± 2% +1.79% (p=0.029 n=4+4) DivisiblePow2constI8-4 0.81ns ± 1% 0.81ns ± 1% ~ (p=0.286 n=5+5) DivisibleconstI8-4 2.13ns ± 3% 1.19ns ± 1% -43.84% (p=0.008 n=5+5) DivisibleWDivconstI8-4 2.23ns ± 1% 2.25ns ± 1% ~ (p=0.183 n=5+5) Fixes #30282 Fixes #15806 Change-Id: Id20d78263a4fdfe0509229ae4dfa2fede83fc1d0 Reviewed-on: https://go-review.googlesource.com/c/go/+/173998 Run-TryBot: Brian Kessler <brian.m.kessler@gmail.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Keith Randall <khr@golang.org> * cmd/go: make get -u upgrade only modules providing packages Currently, 'go get -u' upgrades modules matching command line arguments and any modules they transitively require. 'go get -u' with no positional arguments upgrades all modules transitively required by the main module. This usually adds a large number of indirect requirements, which is surprising to users. With this change, 'go get' will load packages specified by its arguments using a similar process to other commands ('go build', etc). Only modules providing packages will be upgraded. 'go get -u' now upgrades modules providing packages transitively imported by the command-line arguments. 'go get -u' without arguments will only upgrade modules needed by the package in the current directory. 'go get -m' will load all packages within a module. 'go get -m -u' without arguments will upgrade modules needed by the main module. It is equivalent to 'go get -u all'. Neither command will upgrade modules that are required but not used. Note that 'go get -m' and 'go get -d' both download modules in order to load packages. Fixes #26902 Change-Id: I2bad686b3ca8c9de985a81fb42b16a36bb4cc3ea Reviewed-on: https://go-review.googlesource.com/c/go/+/174099 Run-TryBot: Jay Conrod <jayconrod@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Russ Cox <rsc@golang.org> * syscall: on wasm, do not use typed array asynchronously The underlying buffer of a typed array becomes invalid as soon as we grow the WebAssembly memory, which can happen at any time while Go code runs. This is a known limitation, see https://golang.org/cl/155778. As a consequence, using a typed array with one of the asynchronous read/write operations of Node.js' fs module is dangerous, since it may become invalid while the asynchronous operation has not finished yet. The result of this situation is most likely undefined. I am not aware of any nice solution to this issue, so this change adds a workaround of using an additional typed array which is not backed by WebAssembly memory and copying the bytes between the two typed arrays. Maybe WebAssembly will come up with a better solution in the future. Fixes #31702. Change-Id: Iafc2a0fa03c81db414520bd45a1a17c00080b61e Reviewed-on: https://go-review.googlesource.com/c/go/+/174304 Run-TryBot: Richard Musiol <neelance@gmail.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Cherry Zhang <cherryyz@google.com> * net/http: add Transport.ReadBufferSize and WriteBufferSize Previously transport was using the hardcoded bufio.defaultBufSize (4096), limiting throughput and increasing cpu usage when uploading or downloading large files. Add options to allow users to configure the buffer sizes as needed. I tested the maximum benefit of this change by uploading data from /dev/zero to a server discarding the bytes. Here is an example upload using the default buffer size: $ time ./upload 10 https://localhost:8000/ Uploaded 10.00g in 25.13 seconds (407.49m/s) real 0m25.135s user 0m5.167s sys 0m11.643s With this change, using 128k buffer size: $ time ./upload 10 https://localhost:8000/ Uploaded 10.00g in 7.93 seconds (1291.51m/s) real 0m7.935s user 0m4.517s sys 0m2.603s In real world usage the difference will be smaller, depending on the local and remote storage and the network. See https://github.com/nirs/http-bench for more info. Fixes #22618 Change-Id: Iac99ed839c7b95d6dc66602ba8fe1fc5b500c47c Reviewed-on: https://go-review.googlesource.com/c/go/+/76410 Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> * net/http: make Transport.MaxConnsPerHost work for HTTP/2 Treat HTTP/2 connections as an ongoing persistent connection. When we are told there is no cached connections, cleanup the associated connection and host connection count. Fixes #27753 Change-Id: I6b7bd915fc7819617cb5d3b35e46e225c75eda29 Reviewed-on: https://go-review.googlesource.com/c/go/+/140357 Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> * internal/cpu: add detection for the new ECDSA and EDDSA capabilities on s390x This CL will check for the Message-Security-Assist Extension 9 facility which enables the KDSA instruction. Change-Id: I659aac09726e0999ec652ef1f5983072c8131a48 Reviewed-on: https://go-review.googlesource.com/c/go/+/174529 Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> * net: set DNSError.IsTemporary from addrinfoErrno errors Today it is not possible (AFAICT) to detect if a DNSError if of type EAI_AGAIN, i.e. if it is something temporary that should be retried. This information is available inside addrinfoErrno but when the DNSError is created this information is lost. This PR fixes this so that the addinfoErrno.Temporary information is added to DNSError as well. With that a user who gets a DNSError can check now is its a temporary error (for errors that resulted from a addrinfoErrno this is EAI_AGAIN). Change-Id: I64badb2ebd904e41fc2e0755416f7f32560534d8 GitHub-Last-Rev: ced7238a6597039fb23f36f372bd1cf33d60d4a6 GitHub-Pull-Request: golang/go#31676 Reviewed-on: https://go-review.googlesource.com/c/go/+/174557 Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> * os,time: fix tests on iOS When fixing tests for for self-hosted iOS builds, I broke hosted builds. Updates #31722 Change-Id: Id4e7d234fbd86cb2d29d320d75f4441efd663d12 Reviewed-on: https://go-review.googlesource.com/c/go/+/174698 Run-TryBot: Elias Naur <mail@eliasnaur.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> * test: enable more memcombine tests for ppc64le This enables more of the testcases in memcombine for ppc64le, and adds more detail to some existing. Change-Id: Ic522a1175bed682b546909c96f9ea758f8db247c Reviewed-on: https://go-review.googlesource.com/c/go/+/174737 Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> * runtime: change the span allocation policy to first-fit This change modifies the treap implementation to be address-ordered instead of size-ordered, and further augments it so it may be used for allocation. It then modifies the find method to implement a first-fit allocation policy. This change to the treap implementation consequently makes it so that spans are scavenged in highest-address-first order without any additional changes to the scavenging code. Because the treap itself is now address ordered, and the scavenging code iterates over it in reverse, the highest address is now chosen instead of the largest span. This change also renames the now wrongly-named "scavengeLargest" method on mheap to just "scavengeLocked" and also fixes up logic in that method which made assumptions about size. For #30333. Change-Id: I94b6f3209211cc1bfdc8cdaea04152a232cfbbb4 Reviewed-on: https://go-review.googlesource.com/c/go/+/164101 Run-TryBot: Michael Knyszek <mknyszek@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Austin Clements <austin@google.com> * go/internal/gccgoimporter: skip new test with aliases with old gccgo Add the issue31540 test to the list of tests that needs to be skipped with old copies of gccgo. Along the way, add an explicit field to the importer test struct that can be used to tag the test (as opposed to having special cases by name in the test routine), so as to make it easier to remember to tag testcases correctly. Fixes #31764. Change-Id: Ib9d98fea2df8ce0b51e5a886fb2c4acd6db490ff Reviewed-on: https://go-review.googlesource.com/c/go/+/174738 Reviewed-by: Ian Lance Taylor <iant@golang.org> Run-TryBot: Ian Lance Taylor <iant@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> * cmd/compile/internal/ppc64: improve naming for ginsnop2 This is a follow up from a review comment at the end of the last Go release, to provide a more meaningful name for ginsnop2. Updates #30475 Change-Id: Ice9efd763bf2204a9e8c55ae230d3e8a80210108 Reviewed-on: https://go-review.googlesource.com/c/go/+/174757 Run-TryBot: Lynn Boger <laboger@linux.vnet.ibm.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Keith Randall <khr@golang.org> * index/suffixarray: add 32-bit implementation The original index/suffixarray used 32-bit ints on 64-bit machines, because that's what 'int' meant in Go at the time. When we changed the meaning of int, that doubled the space overhead of suffix arrays for all uses, even though the vast majority of them describe less than 2 GB of text. The space overhead of a suffix array compared to the text is not insignificant: there's a big difference for many uses between 4X and 8X. This CL adjusts names in qsufsort.go so that a global search and replace s/32/64/g produces a working 64-bit implementation, and then it modifies suffixarray.go to choose between the 32-bit and 64-bit implementation as appropriate depending on the input size. The 64-bit implementation is generated by 'go generate'. This CL also restructures the benchmarks, to test different input sizes, different input texts, and 32-bit vs 64-bit. The serialized form uses varint-encoded numbers and is unchanged, so on-disk suffix arrays written by older versions of Go will be readable by this version, and vice versa. The 32-bit version runs a up to 17% faster than the 64-bit version on real inputs, but more importantly it uses 50% less memory. I have a followup CL that also implements a faster algorithm on top of these improvements, but these are a good first step. name 64-bit speed 32-bit speed delta New/text=opticks/size=100K/bits=*-12 4.44MB/s ± 0% 4.64MB/s ± 0% +4.41% (p=0.008 n=5+5) New/text=opticks/size=500K/bits=*-12 3.70MB/s ± 1% 3.82MB/s ± 0% +3.30% (p=0.008 n=5+5) New/text=go/size=100K/bits=*-12 4.40MB/s ± 0% 4.61MB/s ± 0% +4.82% (p=0.008 n=5+5) New/text=go/size=500K/bits=*-12 3.66MB/s ± 0% 3.77MB/s ± 0% +3.01% (p=0.016 n=4+5) New/text=go/size=1M/bits=*-12 3.29MB/s ± 0% 3.55MB/s ± 0% +7.90% (p=0.016 n=5+4) New/text=go/size=5M/bits=*-12 2.25MB/s ± 1% 2.65MB/s ± 0% +17.81% (p=0.008 n=5+5) New/text=go/size=10M/bits=*-12 1.82MB/s ± 0% 2.09MB/s ± 1% +14.36% (p=0.008 n=5+5) New/text=go/size=50M/bits=*-12 1.35MB/s ± 0% 1.51MB/s ± 1% +12.33% (p=0.008 n=5+5) New/text=zero/size=100K/bits=*-12 3.42MB/s ± 0% 3.32MB/s ± 0% -2.74% (p=0.000 n=5+4) New/text=zero/size=500K/bits=*-12 3.00MB/s ± 1% 2.97MB/s ± 0% -1.13% (p=0.016 n=5+4) New/text=zero/size=1M/bits=*-12 2.81MB/s ± 0% 2.78MB/s ± 2% ~ (p=0.167 n=5+5) New/text=zero/size=5M/bits=*-12 2.46MB/s ± 0% 2.53MB/s ± 0% +3.18% (p=0.008 n=5+5) New/text=zero/size=10M/bits=*-12 2.35MB/s ± 0% 2.42MB/s ± 0% +2.98% (p=0.016 n=4+5) New/text=zero/size=50M/bits=*-12 2.12MB/s ± 0% 2.18MB/s ± 0% +3.02% (p=0.008 n=5+5) New/text=rand/size=100K/bits=*-12 6.98MB/s ± 0% 7.22MB/s ± 0% +3.38% (p=0.016 n=4+5) New/text=rand/size=500K/bits=*-12 5.53MB/s ± 0% 5.64MB/s ± 0% +1.92% (p=0.008 n=5+5) New/text=rand/size=1M/bits=*-12 4.62MB/s ± 1% 5.06MB/s ± 0% +9.61% (p=0.008 n=5+5) New/text=rand/size=5M/bits=*-12 3.09MB/s ± 0% 3.43MB/s ± 0% +10.94% (p=0.016 n=4+5) New/text=rand/size=10M/bits=*-12 2.68MB/s ± 0% 2.95MB/s ± 0% +10.39% (p=0.008 n=5+5) New/text=rand/size=50M/bits=*-12 1.92MB/s ± 0% 2.06MB/s ± 1% +7.41% (p=0.008 n=5+5) SaveRestore/bits=*-12 243MB/s ± 1% 259MB/s ± 0% +6.68% (p=0.000 n=9+10) name 64-bit alloc/op 32-bit alloc/op delta New/text=opticks/size=100K/bits=*-12 1.62MB ± 0% 0.81MB ± 0% -50.00% (p=0.000 n=5+4) New/text=opticks/size=500K/bits=*-12 8.07MB ± 0% 4.04MB ± 0% -49.89% (p=0.008 n=5+5) New/text=go/size=100K/bits=*-12 1.62MB ± 0% 0.81MB ± 0% -50.00% (p=0.008 n=5+5) New/text=go/size=500K/bits=*-12 8.07MB ± 0% 4.04MB ± 0% -49.89% (p=0.029 n=4+4) New/text=go/size=1M/bits=*-12 16.1MB ± 0% 8.1MB ± 0% -49.95% (p=0.008 n=5+5) New/text=go/size=5M/bits=*-12 80.3MB ± 0% 40.2MB ± 0% ~ (p=0.079 n=4+5) New/text=go/size=10M/bits=*-12 160MB ± 0% 80MB ± 0% -50.00% (p=0.008 n=5+5) New/text=go/size=50M/bits=*-12 805MB ± 0% 402MB ± 0% -50.06% (p=0.029 n=4+4) New/text=zero/size=100K/bits=*-12 3.02MB ± 0% 1.46MB ± 0% ~ (p=0.079 n=4+5) New/text=zero/size=500K/bits=*-12 19.7MB ± 0% 8.7MB ± 0% -55.98% (p=0.008 n=5+5) New/text=zero/size=1M/bits=*-12 39.0MB ± 0% 19.7MB ± 0% -49.60% (p=0.000 n=5+4) New/text=zero/size=5M/bits=*-12 169MB ± 0% 85MB ± 0% -49.46% (p=0.029 n=4+4) New/text=zero/size=10M/bits=*-12 333MB ± 0% 169MB ± 0% -49.43% (p=0.000 n=5+4) New/text=zero/size=50M/bits=*-12 1.63GB ± 0% 0.74GB ± 0% -54.61% (p=0.008 n=5+5) New/text=rand/size=100K/bits=*-12 1.61MB ± 0% 0.81MB ± 0% -50.00% (p=0.000 n=5+4) New/text=rand/size=500K/bits=*-12 8.07MB ± 0% 4.04MB ± 0% -49.89% (p=0.000 n=5+4) New/text=rand/size=1M/bits=*-12 16.1MB ± 0% 8.1MB ± 0% -49.95% (p=0.029 n=4+4) New/text=rand/size=5M/bits=*-12 80.7MB ± 0% 40.3MB ± 0% -50.06% (p=0.008 n=5+5) New/text=rand/size=10M/bits=*-12 161MB ± 0% 81MB ± 0% -50.03% (p=0.008 n=5+5) New/text=rand/size=50M/bits=*-12 806MB ± 0% 403MB ± 0% -50.00% (p=0.016 n=4+5) SaveRestore/bits=*-12 9.47MB ± 0% 5.28MB ± 0% -44.29% (p=0.000 n=9+8) https://perf.golang.org/search?q=upload:20190126.1+|+bits:64+vs+bits:32 Fixes #6816. Change-Id: Ied2fbea519a202ecc43719debcd233344ce38847 Reviewed-on: https://go-review.googlesource.com/c/go/+/174097 Run-TryBot: Russ Cox <rsc@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> * runtime: look for idle p to run current goroutine when switching to GC or traceReader This repairs one of the several causes of pauses uncovered by a GC microbenchmark. A pause can occur when a goroutine's quantum expires "at the same time" a GC is needed. The current M switches to running a GC worker, which means that the amount of available work has expanded by one. The GC worker, however, does not call ready, and does not itself conditionally wake a P (a "normal" thread would do this). This is also true if M switches to a traceReader. This is problem 4 in this list: https://github.com/golang/go/issues/27732#issuecomment-423301252 Updates #27732. Change-Id: I6905365cac8504cde6faab2420f4421536551f0b Reviewed-on: https://go-review.googlesource.com/c/go/+/146817 Run-TryBot: David Chase <drchase@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Austin Clements <austin@google.com> * cmd/go/internal/modfetch/codehost: fix pseudoversions for non-semver tags and tags on other branches Pseudoversion determination depends in part on the results from gitRepo.RecentTag, which currently invokes: git describe --first-parent --always --abbrev=0 --match <prefix>v[0-9]*.[0-9]*.[0-9]* --tags <rev> The comment at https://github.com/golang/go/issues/27171#issuecomment-470134255 describes some problems with the current approach. One problem is Docker and other repos can have tags that are not valid semver tags but that still match a glob pattern of v[0-9]*.[0-9]*.[0-9]* which are found by 'git describe' but then rejected by cmd/go, and hence those repos currently can end up with v0.0.0 pseudoversions instead of finding a proper semver tag to use as input to building a pseudoversion (when then causes problems when the v0.0.0 pseudoversion is fed into MVS). An example problematic tag is a date-based tag such as 'v18.06.16', which matches the glob pattern, but is not a valid semver tag (due to the leading 0 in '06'). Issues #31673, #31287, and #27171 also describe problems where the '--first-parent' argument to 'git describe' cause the current approach to miss relevant semver tags that were created on a separate branch and then subsequently merged to master. In #27171, Bryan described the base tag that is supposed to be used for pseudoversions as: "It is intended to be the semantically-latest tag that appears on any commit that is a (transitive) parent of the commit with the given hash, regardless of branches. (The pseudo-version is supposed to sort after every version — tagged or otherwise — that came before it, but before the next tag that a human might plausibly want to apply to the branch.)" This CL solves the glob problem and tags-on-other-branches problem more directly than the current approach: this CL gets the full list of tags that have been merged into the specific revision of interest, and then sorts and filters the results in cmd/go to select the semantically-latest valid semver tag. Fixes #31673 Fixes #31287 Updates #27171 Change-Id: I7c3e6b46b2b21dd60562cf2893b6bd2afaae61d5 Reviewed-on: https://go-review.googlesource.com/c/go/+/174061 Run-TryBot: Jay Conrod <jayconrod@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Jay Conrod <jayconrod@google.com> * cmd/go/internal/get: fix strayed verbose output on stdout Fixes #31768 Change-Id: I3cc0ebc4be34d7c2d2d4fd655bfd0c2515ff3021 Reviewed-on: https://go-review.googlesource.com/c/go/+/174739 Reviewed-by: Jay Conrod <jayconrod@google.com> Run-TryBot: Jay Conrod <jayconrod@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> * cmd/dist: only build exec wrappers when cross compiling Updates #31722 Change-Id: Ib44b46e628e364fff6eacda2b26541db2f0a4261 Reviewed-on: https://go-review.googlesource.com/c/go/+/174701 Run-TryBot: Elias Naur <mail@eliasnaur.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> * misc/cgo/testcarchive: skip TestExtar on self-hosted iOS iOS cannot (directly) run shell scripts. Updates #31722 Change-Id: I69473e9339c50a77338d391c73b4e146bce3fa89 Reviewed-on: https://go-review.googlesource.com/c/go/+/174700 Run-TryBot: Elias Naur <mail@eliasnaur.com> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> * strings, bytes: add ToValidUTF8 The newly added functions create a copy of their input with all bytes in invalid UTF-8 byte sequences mapped to the UTF-8 byte sequence given as replacement parameter. Fixes #25805 Change-Id: Iaf65f65b40c0581c6bb000f1590408d6628321d0 Reviewed-on: https://go-review.googlesource.com/c/go/+/142003 Run-TryBot: Martin Möhrmann <moehrmann@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> * cmd/go: sort vendor/modules.txt package lists Right now they are in a deterministic order but one that depends on the shape of the import graph. Sort them instead. Change-Id: Ia0c076a0d6677a511e52acf01f38353e9895dec2 Reviewed-on: https://go-review.googlesource.com/c/go/+/174527 Run-TryBot: Russ Cox <rsc@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Reviewed-by: Jay Conrod <jayconrod@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> * cmd/compile: fix maplit init panics for dynamic entry golang.org/cl/174498 removes dynamic map entry handling in maplit, by filtering the static entry only. It panics if it see a dynamic entry. It relies on order to remove all dynamic entries. But after recursively call order on the statics, some static entries become dynamic, e.g OCONVIFACE node: type i interface { j() } type s struct{} func (s) j() {} type foo map[string]i var f = foo{ "1": s{}, } To fix it, we recursively call order on each static entry, if it changed to dynamic, put entry to dynamic then. Fixes #31777 Change-Id: I1004190ac8f2d1eaa4beb6beab989db74099b025 Reviewed-on: https://go-review.googlesource.com/c/go/+/174777 Run-TryBot: Matthew Dempsky <mdempsky@google.com> Reviewed-by: Keith Randall <khr@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> * cmd/go/internal/web: fix log message The web package is now used for proxy fetches, so its logs shouldn't start with "Parsing meta tags". Change-Id: I22a7dce09e3a681544ee4b860f93c63336e547ca Reviewed-on: https://go-review.googlesource.com/c/go/+/174740 Run-TryBot: Heschi Kreinick <heschi@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> * cmd/compile: disable Go1.13 language features for -lang=go1.12 and below Fixes #31747. Updates #19308. Updates #12711. Updates #29008. Updates #28493. Updates #19113. Change-Id: I76d2fdbc7698cc4e0f31b7ae24cbb4d28afbb6a3 Reviewed-on: https://go-review.googlesource.com/c/go/+/174897 Run-TryBot: Robert Griesemer <gri@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Matthew Dempsky <mdempsky@google.com> * errors: fix comment referencing the Wrapper interface The Unwrap function performs a type assertion looking for the Wrapper interface. The method of that interface is called Unwrap but the interface itself is called Wrapper. Change-Id: Ie3bf296f93b773d36015bcab2a0e6585d39783c7 GitHub-Last-Rev: 32b1a0c2f8bf8f3eaebf6de252571d82313e86e0 GitHub-Pull-Request: golang/go#31794 Reviewed-on: https://go-review.googlesource.com/c/go/+/174917 Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> * doc/go1.13: start doc, note macOS, FreeBSD deprecations For #23011. For #27619. Change-Id: Id1f280993ecdfb07a7420926ca1c0f5b7872afbb Reviewed-on: https://go-review.googlesource.com/c/go/+/174521 Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> * cmd/compile: remove outdate TODO in inl.go Mid-stack inlining is enable now, see #19348, but we still can not remove the special case for runtime.heapBits.nextArena, because runtime.heapBits.next is too complex to be inlined (cost 96 exceeds budget 80). Change-Id: I04ea86509074afdc83a3f70d68b8a1a8829763d1 Reviewed-on: https://go-review.googlesource.com/c/go/+/174839 Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> * cmd/go: make modconv test more robust Change-Id: I3e75201c56779eda1bcd725691c72d384da56f73 Reviewed-on: https://go-review.googlesource.com/c/go/+/174840 Run-TryBot: Baokun Lee <nototon@gmail.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Jay Conrod <jayconrod@google.com> * cmd/go/internal/modload: make 'list -u' consider current pseudoversion As pointed out by thepudds in #30634, the 'list -u' documentation states that the current version should be considered for upgrade: The -u flag adds information about available upgrades. When the latest version of a given module is newer than the current one, list -u sets the Module's Update field to information about the newer module. In go 1.12.4 (and current tip), an older version will be suggested as upgrade to a newer pseudo version. Updates: #30634 Change-Id: If2c8887198884b8e7ccb3a604908065aa1f1878a Reviewed-on: https://go-review.googlesource.com/c/go/+/174206 Run-TryBot: Jay Conrod <jayconrod@google.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Jay Conrod <jayconrod@google.com> * cmd/dist: don't generate exec wrappers for compatible cross compiles This change will allow android/arm64 hosts to build for android/arm, and likewise for iOS. Updates #31722 Change-Id: Id410bd112abbab585ebb13b61fe4d3a38a1a81fb Reviewed-on: https://go-review.googlesource.com/c/go/+/174705 Run-TryBot: Elias Naur <mail@eliasnaur.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> * cmd/link: support PIE mode with internal link on linux arm64 This CL improves internal link to provide basic support for cgo and PIE: 1, add support for GOT, PLT and GOTPLT. 2, add support for following ELF relocation types which have been used by std packages: R_AARCH64_ADR_GOT_PAGE R_AARCH64_LD64_GOT_LO12_NC R_AARCH64_ADR_PREL_PG_HI21 R_AARCH64_ADD_ABS_LO12_NC R_AARCH64_LDST8_ABS_LO12_NC R_AARCH64_LDST32_ABS_LO12_NC R_AARCH64_LDST64_ABS_LO12_NC R_AARCH64_JUMP26 R_AARCH64_ABS64 R_AARCH64_PREL32 R_AARCH64_PREL64 With this change, Go toolchain can be built in internal linking mode, and pure Go programs can be built with PIE mode in internal linking mode on arm64. Updates #10373 The prototype of this CL is contributed by Wei Xiao <wei.xiao@arm.com> Change-Id: I2253923c69e855fd1524d54def309a961dce6247 Reviewed-on: https://go-review.googlesource.com/c/go/+/163579 Reviewed-by: Cherry Zhang <cherryyz@google.com> Run-TryBot: Cherry Zhang <cherryyz@google.com> * sort: simplify bootstrap We compile package sort as part of the compiler bootstrap, to make sure the compiler uses a consistent sort algorithm no matter what version of Go it is compiled against. (This matters for elements that compare "equal" but are distinguishab…

gopherbot · 2019-06-01T23:03:19Z

Change https://golang.org/cl/179997 mentions this issue: cmd/go/internal/imports: match solaris files for illumos

Like the android/linux pair, match files with GOOS=solaris if GOOS=illumos Follow-up for CL 174457 Fixes #32370 Updates #20603 Change-Id: Id01de8bb3990d7bbb22f735a4abed2b3cf8b4062 Reviewed-on: https://go-review.googlesource.com/c/go/+/179997 Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Benny Siegert <bsiegert@gmail.com> Reviewed-by: Bryan C. Mills <bcmills@google.com>

bcmills · 2019-10-16T14:20:31Z

The Illumos builder was removed due to the upcoming Joyent Public Cloud turndown.

If folks want to maintain support for the illumos port, it needs a builder. See #15581.

jclulow · 2019-10-16T17:52:51Z

I'll take a look!

gopherbot added this to the Proposal milestone Jun 7, 2017

gopherbot added the Proposal label Jun 7, 2017

sean- mentioned this issue Jun 7, 2017

Add CPU and Disk stats support to Illumos shirou/gopsutil#378

Closed

bradfitz added the OS-Solaris label Jun 7, 2017

rsc modified the milestones: Go1.10, Proposal Jun 19, 2017

rsc added the Proposal-Accepted label Jun 19, 2017

rsc changed the title ~~Proposal: New build tag for illumos~~ build: add GOOS=illumos Jun 19, 2017

gopherbot closed this as completed in f686a28 Apr 30, 2019

bcmills mentioned this issue Apr 30, 2019

cmd/go/internal/lockedfile: use F_OFD_SETLK on Illumos #31765

Closed

Smithx10 mentioned this issue May 7, 2019

Solaris Support? hashicorp/nomad#5650

Open

bradfitz mentioned this issue May 29, 2019

x/build/env/illumos-amd64-joyent: add illumos builder #32308

Closed

jclulow mentioned this issue May 31, 2019

cmd/go: "cannot find module golang.org/x/sys/unix" when GOOS=illumos #32370

Closed

Roasbeef mentioned this issue Aug 26, 2019

Unable to build on SmartOS lightningnetwork/lnd#3431

Closed

davepacheco mentioned this issue Sep 4, 2020

Build failing on illumos again prometheus/node_exporter#1836

Closed

golang locked and limited conversation to collaborators Oct 15, 2020

gopherbot added the FrozenDueToAge label Oct 15, 2020

build: add GOOS=illumos #20603

build: add GOOS=illumos #20603

Comments

sean- commented Jun 7, 2017 • edited

Disambiguating solaris vs illumos

bradfitz commented Jun 7, 2017

ianlancetaylor commented Jun 8, 2017

binarycrusader commented Jun 8, 2017 • edited

sean- commented Jun 8, 2017

binarycrusader commented Jun 8, 2017

4ad commented Jun 8, 2017 • edited

sean- commented Jun 8, 2017

binarycrusader commented Jun 8, 2017

jtsylve commented Jun 9, 2017

jen20 commented Jun 9, 2017

sean- commented Jun 9, 2017

binarycrusader commented Jun 9, 2017 • edited

bradfitz commented Jun 9, 2017

binarycrusader commented Jun 9, 2017 • edited

jen20 commented Jun 9, 2017

sean- commented Jun 9, 2017

bradfitz commented Jun 9, 2017 • edited

jen20 commented Jun 9, 2017

bradfitz commented Jun 9, 2017

binarycrusader commented Jun 9, 2017

bradfitz commented Jun 9, 2017

rsc commented Jun 19, 2017

bradfitz commented Apr 26, 2019

jclulow commented Apr 26, 2019

bradfitz commented Apr 26, 2019

jclulow commented Apr 26, 2019

jclulow commented Apr 27, 2019

jclulow commented Apr 29, 2019

Smithx10 commented Apr 29, 2019

bradfitz commented Apr 30, 2019 • edited

jclulow commented Apr 30, 2019

bradfitz commented Apr 30, 2019

gopherbot commented Apr 30, 2019

jclulow commented Apr 30, 2019

gopherbot commented May 2, 2019

gopherbot commented Jun 1, 2019

bcmills commented Oct 16, 2019

jclulow commented Oct 16, 2019

sean- commented Jun 7, 2017 •

edited

Disambiguating `solaris` vs `illumos`

binarycrusader commented Jun 8, 2017 •

edited

4ad commented Jun 8, 2017 •

edited

binarycrusader commented Jun 9, 2017 •

edited

binarycrusader commented Jun 9, 2017 •

edited

bradfitz commented Jun 9, 2017 •

edited

bradfitz commented Apr 30, 2019 •

edited