aboutsummaryrefslogtreecommitdiff
path: root/src/cmd/cgo/doc.go
AgeCommit message (Collapse)Author
2025-12-08cmd/cgo: use doc link for cgo.HandleAriel Otilibili
Change-Id: If6af9842f563fe9233de0563d356e925a7b912f8 GitHub-Last-Rev: e8422e9a5aa9ca3140c96f7abfa4fa4482d709ab GitHub-Pull-Request: golang/go#76727 Reviewed-on: https://go-review.googlesource.com/c/go/+/727581 LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Reviewed-by: David Chase <drchase@google.com> Reviewed-by: Dmitri Shuralyov <dmitshur@google.com> Reviewed-by: Ian Lance Taylor <iant@golang.org> Reviewed-by: Sean Liao <sean@liao.dev> Auto-Submit: Sean Liao <sean@liao.dev>
2025-11-03all: remove extra space in the commentscuishuang
Change-Id: I26302d801732f40b1fe6b30ff69d222047bca490 Reviewed-on: https://go-review.googlesource.com/c/go/+/716740 Reviewed-by: Robert Griesemer <gri@google.com> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Reviewed-by: Michael Knyszek <mknyszek@google.com>
2024-12-11cmd/cgo: use full prototype for main in C codeIan Lance Taylor
Avoids pedantic errors from modern C compilers. Fixes #70769 Change-Id: Ibe0d9960e998eb0346b97d7bd69eb7de0d0e6c60 Reviewed-on: https://go-review.googlesource.com/c/go/+/635095 Reviewed-by: Robert Griesemer <gri@google.com> Reviewed-by: Mauri de Souza Meneguzzo <mauri870@gmail.com> Reviewed-by: Ian Lance Taylor <iant@google.com> Auto-Submit: Ian Lance Taylor <iant@google.com> Commit-Queue: Ian Lance Taylor <iant@google.com> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
2024-10-01cmd/cgo: add srcdir & trimpath docs, sort optionsIan Lance Taylor
Update the package docs: * The -srcdir docs were accidentally lost in CL 68590. * The -trimpath option was added in CL 266358 but not documented. * The options were not sorted correctly. Fixes #69730 Change-Id: I97320e0f4fb6aa47cb03d451f028d3d9d9b560f7 Reviewed-on: https://go-review.googlesource.com/c/go/+/616699 Auto-Submit: Ian Lance Taylor <iant@google.com> Reviewed-by: Ian Lance Taylor <iant@google.com> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Reviewed-by: Michael Knyszek <mknyszek@google.com>
2024-10-01cmd/cgo: document errno value semanticsBrian Palmer
Added a section about errno values vs normal go error value semantics, and checking the return value of C functions for error before looking at errno. Fixes #63485 Change-Id: Id0132a9f11e4127f4adc14e010b7e17f57a0f7d3 Reviewed-on: https://go-review.googlesource.com/c/go/+/616264 Reviewed-by: Michael Knyszek <mknyszek@google.com> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Auto-Submit: Ian Lance Taylor <iant@google.com> Reviewed-by: Ian Lance Taylor <iant@google.com>
2024-08-16cmd/cgo: enable #cgo noescape/nocallbackdoujiang24
In Go 1.22 we added code to the go/build package to ignore #cgo noescape and nocallback directives. That permits us to enable these directives in Go 1.24. Also, this fixed a Bug in CL 497837: After retiring _Cgo_use for parameters, the compiler will treat the parameters, start from the second, as non-alive. Then, they will be marked as scalar in stackmap, which means the pointer won't be copied correctly in copystack. Fixes #56378. Fixes #63739. Change-Id: I46e773240f8a467c3c4ba201dc5b4ee473cf6e3e GitHub-Last-Rev: 42fcc506d6a7681ef24ac36a5904b57bda4b15cd GitHub-Pull-Request: golang/go#66879 Reviewed-on: https://go-review.googlesource.com/c/go/+/579955 Auto-Submit: Ian Lance Taylor <iant@google.com> Reviewed-by: Ian Lance Taylor <iant@google.com> Reviewed-by: Carlos Amedee <carlos@golang.org> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
2024-08-12cmd/cgo: clarify that strings and slices may contain C pointersIan Lance Taylor
Fixes #68832 Change-Id: I74b6aad9a18953c263cbbe795268017a72261f7f Reviewed-on: https://go-review.googlesource.com/c/go/+/604715 Reviewed-by: Cherry Mui <cherryyz@google.com> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Auto-Submit: Ian Lance Taylor <iant@google.com> Reviewed-by: Ian Lance Taylor <iant@google.com> Reviewed-by: Carlos Amedee <carlos@golang.org> Commit-Queue: Ian Lance Taylor <iant@google.com>
2024-07-31cmd/cgo: document workaround for C struct_stat functionIan Lance Taylor
For #68682 Change-Id: I13b61f915925a9ee510e0a42e95da7a83678b3b5 Reviewed-on: https://go-review.googlesource.com/c/go/+/602215 Reviewed-by: Cherry Mui <cherryyz@google.com> Auto-Submit: Ian Lance Taylor <iant@google.com> Reviewed-by: Ian Lance Taylor <iant@google.com> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
2024-05-13cmd/cgo, cmd/go: add cgo -ldflags option, use it in cmd/goIan Lance Taylor
This will automatically use a response file if ldflags is long, avoiding "argument list too long" errors with a very large CGO_LDFLAGS. Fixes #66456 Change-Id: I5f9ee86e03b4e6d6430f7f9d8357ef37a9c22465 Reviewed-on: https://go-review.googlesource.com/c/go/+/584655 Reviewed-by: Michael Matloob <matloob@golang.org> Reviewed-by: Ian Lance Taylor <iant@google.com> Commit-Queue: Ian Lance Taylor <iant@google.com> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Auto-Submit: Ian Lance Taylor <iant@google.com>
2024-03-31cmd/cgo: update outdated docs about cgocheck2Kévin Dunglas
Setting GODEBUG=cgocheck=2 now panics with a message such as "fatal error: cgocheck > 1 mode is no longer supported at runtime. Use GOEXPERIMENT=cgocheck2 at build time instead." Change-Id: If9a5a96933973e14a1a60b8e9fb6a1f4a818cf59 GitHub-Last-Rev: 787d62454c31565d0828777bf5ba24c99345af4d GitHub-Pull-Request: golang/go#65224 Reviewed-on: https://go-review.googlesource.com/c/go/+/557597 Reviewed-by: Ian Lance Taylor <iant@google.com> Reviewed-by: qiulaidongfeng <2645477756@qq.com> Reviewed-by: Keith Randall <khr@google.com> Reviewed-by: Keith Randall <khr@golang.org> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
2023-11-02cmd/cgo: disable #cgo noescape/nocallback until Go 1.23Russ Cox
Go 1.21 and earlier do not understand this line, causing "go mod vendor" of //go:build go1.22-tagged code that uses this feature to fail. The solution is to include the go/build change to skip over the line in Go 1.22 (making "go mod vendor" from Go 1.22 onward work with this change) and then wait to deploy the cgo change until Go 1.23, at which point Go 1.21 and earlier will be unsupported. For #56378. Fixes #63293. Change-Id: Ifa08b134eac5a6aa15d67dad0851f00e15e1e58b Reviewed-on: https://go-review.googlesource.com/c/go/+/539235 LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Reviewed-by: Cherry Mui <cherryyz@google.com> Reviewed-by: Bryan Mills <bcmills@google.com>
2023-08-30cmd/cgo: only write _cgo_flags for gccgoIan Lance Taylor
We only use it for gccgo. Also only write out LDFLAGS, as that is all that cmd/go uses. Fixes #60642 Change-Id: I6ccc419a17a433583d9868dd63aa7ec41c2b22c4 Reviewed-on: https://go-review.googlesource.com/c/go/+/524556 Auto-Submit: Ian Lance Taylor <iant@google.com> Commit-Queue: Ian Lance Taylor <iant@google.com> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Reviewed-by: Ian Lance Taylor <iant@google.com> Reviewed-by: Bryan Mills <bcmills@google.com>
2023-08-25cmd/cgo: add #cgo noescape/nocallback annotationsdoujiang24
When passing pointers of Go objects from Go to C, the cgo command generate _Cgo_use(pN) for the unsafe.Pointer type arguments, so that the Go compiler will escape these object to heap. Since the C function may callback to Go, then the Go stack might grow/shrink, that means the pointers that the C function have will be invalid. After adding the #cgo noescape annotation for a C function, the cgo command won't generate _Cgo_use(pN), and the Go compiler won't force the object escape to heap. After adding the #cgo nocallback annotation for a C function, which means the C function won't callback to Go, if it do callback to Go, the Go process will crash. Fixes #56378 Change-Id: Ifdca070584e0d349c7b12276270e50089e481f7a GitHub-Last-Rev: f1a17b08b0590eca2670e404bbfedad5461df72f GitHub-Pull-Request: golang/go#60399 Reviewed-on: https://go-review.googlesource.com/c/go/+/497837 Reviewed-by: Ian Lance Taylor <iant@google.com> Reviewed-by: Bryan Mills <bcmills@google.com> Run-TryBot: Bryan Mills <bcmills@google.com> Auto-Submit: Bryan Mills <bcmills@google.com> TryBot-Result: Gopher Robot <gobot@golang.org>
2023-05-30cmd/cgo: rewrite pointer passing rules in terms of pinningMichael Anthony Knyszek
With the introduction of runtime.Pinner, we need to update the cgo pointer passing rules to accomodate the new functionality. These rule changes are easier to describe if the rest of the pointer passing rules are described in terms of pinning as well (Go memory is implicitly pinned when a pointer to it is passed to a C function, and implicitly unpinned when that function returns). For #46787. Change-Id: I263f03412bc9165f19c9ada72fb005ed0483a8ee Reviewed-on: https://go-review.googlesource.com/c/go/+/498116 Reviewed-by: Austin Clements <austin@google.com> Reviewed-by: Ian Lance Taylor <iant@golang.org> Run-TryBot: Michael Knyszek <mknyszek@google.com> TryBot-Result: Gopher Robot <gobot@golang.org> Auto-Submit: Michael Knyszek <mknyszek@google.com>
2023-05-12misc/cgo: move easy tests to cmd/cgo/internalAustin Clements
This moves most misc/cgo tests to cmd/cgo/internal. This is mostly a trivial rename and updating dist/test.go for the new paths, plus excluding these packages from regular dist test registration. A few tests were sensitive to what path they ran in, so we update those. This will let these tests access facilities in internal/testenv. For #37486. Change-Id: I3ed417c7c22d9b667f2767c0cb1f59118fcd4af6 Reviewed-on: https://go-review.googlesource.com/c/go/+/492720 Run-TryBot: Austin Clements <austin@google.com> Reviewed-by: Dmitri Shuralyov <dmitshur@google.com> Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org> Reviewed-by: Bryan Mills <bcmills@google.com> TryBot-Result: Gopher Robot <gobot@golang.org>
2022-11-16cmd/go: automatically disable cgo on systems with no C compilerRuss Cox
The documentation for cgo has always said: > The cgo tool is enabled by default for native builds > on systems where it is expected to work. Following the spirit of that rule, this CL disables cgo by default on systems where $CC is unset and the default C compiler (clang or gcc) is not found in $PATH. This CL makes builds of Go code on systems with no C compiler installed automatically fall back to non-cgo mode. For example, if building a Go program using package net in a stripped down Linux container, that build will now run with cgo disabled, instead of attempting the build with cgo enabled and only succeeding if the right pre-compiled .a files happen to be loaded into the container. This CL makes it safe to drop the pre-compiled .a files from the Go distribution. Systems that don't have a C compiler will simply disable cgo when building new .a files for that system. In general keeping the pre-compiled .a files working in cgo mode on systems without C compilers has had only mixed success due to the precise build cache. Today we have had to disable various checks in the precise build cache so that distributed .a files look up-to-date even if the current machine's C compiler is a different version than the one used when packaging the distribution. Each time we improve precision we have a decent chance of re-invalidating the files. This CL, combined with dropping the .a files entirely, will let us re-enable those checks and ensure that the .a files used in a build actually match the C compiler being used. On macOS, the distributed .a files for cgo-dependent packages have been stale (not actually used by the go command) since the release of Go 1.14 in February 2020, due to CL 216304 setting a CGO_CFLAGS environment variable that won't match the default setting on users machines. (To keep the distributed .a files working, that CL should have instead changed the default in the go command.) The effect is that for the past six Go releases (!!!), the go command has been unable to build basic programs like src/net/http/triv.go on macOS without either disabling cgo or installing Xcode's C compiler. This CL fixes that problem by disabling cgo when there's no C compiler. Now it will once again be possible to build basic programs with just a Go toolchain installed. In the past, disabling cgo on macOS would have resulted in subpar implementations of crypto/x509, net, and os/user, but as of CL 449316 those packages have all been updated to use libc calls directly, so they now provide the same implementation whether or not cgo is enabled. In the past, disabling cgo on macOS would also have made the race detector unusable, but CL 451055 makes the race detector work on macOS even when cgo is disabled. On Windows, none of the standard library uses cgo today, so all the necessary .a files can be rebuilt without a C toolchain, and there is no loss of functionality in the standard library when cgo is disabled. After this CL, the race detector won't work on Windows without a C toolchain installed, but that turns out to be true already: when linking race-enabled programs, even if the Go linker does not invoke the host linker, it still attempts to read some of the host C toolchain's .a files to resolve undefined references. On Unix systems, disabling cgo when a C compiler is not present will mean that builds get the pure Go net resolver, which is used by default even in cgo builds when /etc/resolv.conf is simple enough. It will also mean they get the pure os/user code, which reads /etc/passwd and /etc/group instead of using shared libraries, and therefore it may miss out on other sources of user information such as LDAP. The race detector also will not work without a C compiler. This would be dire except that nearly all Unix systems have a C compiler installed by default, and on those that don't it is trivial to add one. In particular, the vast majority of Go developers running on Linux and other Unix systems will already have a C compiler and will be unaffected. Change-Id: I491e8a022fe3a64022e9dc593850d483a0d353fa Reviewed-on: https://go-review.googlesource.com/c/go/+/450739 Reviewed-by: Bryan Mills <bcmills@google.com> Auto-Submit: Russ Cox <rsc@golang.org> Run-TryBot: Russ Cox <rsc@golang.org> TryBot-Result: Gopher Robot <gobot@golang.org>
2022-10-29cmd/go, cmd/cgo: support older versions of gccgo that lack cgo.IncompleteIan Lance Taylor
Test whether gccgo/GoLLVM supports cgo.Incomplete. If it doesn't, use a local definition rather than importing it. Roll back 426496, which skipped a gccgo test, as it now works. For #46731 Fixes #54761 Change-Id: I8bb2ad84c317094495405e178bf5c9694f82af56 Reviewed-on: https://go-review.googlesource.com/c/go/+/446260 Reviewed-by: Bryan Mills <bcmills@google.com> Run-TryBot: Ian Lance Taylor <iant@google.com> Auto-Submit: Ian Lance Taylor <iant@google.com> Reviewed-by: Ian Lance Taylor <iant@google.com> Run-TryBot: Bryan Mills <bcmills@google.com> TryBot-Result: Gopher Robot <gobot@golang.org>
2022-09-20cmd/cgo: mention //go:build line in godocTobias Klauser
Say "//go:build" instead of "// +build" in the package level godoc comment. Change-Id: I4700227a03197ffbe29e4de04d068b4c63bb5bf0 Reviewed-on: https://go-review.googlesource.com/c/go/+/431856 Auto-Submit: Tobias Klauser <tobias.klauser@gmail.com> Reviewed-by: Cherry Mui <cherryyz@google.com> Run-TryBot: Tobias Klauser <tobias.klauser@gmail.com> Reviewed-by: Ian Lance Taylor <iant@google.com> TryBot-Result: Gopher Robot <gobot@golang.org> Run-TryBot: Ian Lance Taylor <iant@google.com>
2022-06-22cmd/go, cmd/link: support failure to create _cgo_import.goIan Lance Taylor
For a package that uses cgo, the file _cgo_import.go is created to record information required for internal linking: the non-Go dynamic symbols and libraries that the package depends on. Generating this information sometimes fails, because it can require recreating all the dependencies of all transitively imported packages. And the information is rarely needed, since by default we use external linking when there are packages outside of the standard library that use cgo. With this CL, if generating _cgo_import.go fails, we don't report an error. Instead, we mark the package as requiring external linking, by adding an empty file named "dynimportfail" into the generated archive. If the linker sees a file with that name, it rejects an attempt to use internal linking. Fixes #52863 Change-Id: Ie586e6753a5b67e49bb14533cd7603d9defcf0ea Reviewed-on: https://go-review.googlesource.com/c/go/+/413460 Run-TryBot: Ian Lance Taylor <iant@golang.org> Reviewed-by: Bryan Mills <bcmills@google.com> Auto-Submit: Ian Lance Taylor <iant@golang.org> Reviewed-by: Cherry Mui <cherryyz@google.com> TryBot-Result: Gopher Robot <gobot@golang.org>
2022-04-11all: gofmt main repoRuss Cox
[This CL is part of a sequence implementing the proposal #51082. The design doc is at https://go.dev/s/godocfmt-design.] Run the updated gofmt, which reformats doc comments, on the main repository. Vendored files are excluded. For #51082. Change-Id: I7332f099b60f716295fb34719c98c04eb1a85407 Reviewed-on: https://go-review.googlesource.com/c/go/+/384268 Reviewed-by: Jonathan Amsterdam <jba@google.com> Reviewed-by: Ian Lance Taylor <iant@golang.org>
2021-04-06runtime/cgo: add Handle for managing (c)go pointersChangkun Ou
A non-trivial Cgo program may need to use callbacks and interact with go objects per goroutine. Because of the rules for passing pointers between Go and C, such a program needs to store handles to associated Go values. This often causes much extra effort to figure out a way to correctly deal with: 1) map collision; 2) identifying leaks and 3) concurrency. This CL implements a Handle representation in runtime/cgo package, and related methods such as Value, Delete, etc. which allows Go users can use a standard way to handle the above difficulties. In addition, the CL allows a Go value to have multiple handles, and the NewHandle always returns a different handle compare to the previously returned handles. In comparison, CL 294670 implements a different behavior of NewHandle that returns a unique handle when the Go value is referring to the same object. Benchmark: name time/op Handle/non-concurrent-16 487ns ± 1% Handle/concurrent-16 674ns ± 1% Fixes #37033 Change-Id: I0eadb9d44332fffef8fb567c745246a49dd6d4c1 Reviewed-on: https://go-review.googlesource.com/c/go/+/295369 Run-TryBot: Ian Lance Taylor <iant@golang.org> TryBot-Result: Go Bot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org> Trust: Cherry Zhang <cherryyz@google.com>
2020-10-26runtime,cmd/cgo: simplify C -> Go call pathAustin Clements
This redesigns the way calls work from C to exported Go functions. It removes several steps from the call path, makes cmd/cgo no longer sensitive to the Go calling convention, and eliminates the use of reflectcall from cgo. In order to avoid generating a large amount of FFI glue between the C and Go ABIs, the cgo tool has long depended on generating a C function that marshals the arguments into a struct, and then the actual ABI switch happens in functions with fixed signatures that simply take a pointer to this struct. In a way, this CL simply pushes this idea further. Currently, the cgo tool generates this argument struct in the exact layout of the Go stack frame and depends on reflectcall to unpack it into the appropriate Go call (even though it's actually reflectcall'ing a function generated by cgo). In this CL, we decouple this struct from the Go stack layout. Instead, cgo generates a Go function that takes the struct, unpacks it, and calls the exported function. Since this generated function has a generic signature (like the rest of the call path), we don't need reflectcall and can instead depend on the Go compiler itself to implement the call to the exported Go function. One complication is that syscall.NewCallback on Windows, which converts a Go function into a C function pointer, depends on cgocallback's current dynamic calling approach since the signatures of the callbacks aren't known statically. For this specific case, we continue to depend on reflectcall. Really, the current approach makes some overly simplistic assumptions about translating the C ABI to the Go ABI. Now we're at least in a much better position to do a proper ABI translation. For comparison, the current cgo call path looks like: GoF (generated C function) -> crosscall2 (in cgo/asm_*.s) -> _cgoexp_GoF (generated Go function) -> cgocallback (in asm_*.s) -> cgocallback_gofunc (in asm_*.s) -> cgocallbackg (in cgocall.go) -> cgocallbackg1 (in cgocall.go) -> reflectcall (in asm_*.s) -> _cgoexpwrap_GoF (generated Go function) -> p.GoF Now the call path looks like: GoF (generated C function) -> crosscall2 (in cgo/asm_*.s) -> cgocallback (in asm_*.s) -> cgocallbackg (in cgocall.go) -> cgocallbackg1 (in cgocall.go) -> _cgoexp_GoF (generated Go function) -> p.GoF Notably: 1. We combine _cgoexp_GoF and _cgoexpwrap_GoF and move the combined operation to the end of the sequence. This combined function also handles reflectcall's previous role. 2. We combined cgocallback and cgocallback_gofunc since the only purpose of having both was to convert a raw PC into a Go function value. We instead construct the Go function value in cgocallbackg1. 3. cgocallbackg1 no longer reaches backwards through the stack to get the arguments to cgocallback_gofunc. Instead, we just pass the arguments down. 4. Currently, we need an explicit msanwrite to mark the results struct as written because reflectcall doesn't do this. Now, the results are written by regular Go assignments, so the Go compiler generates the necessary MSAN annotations. This also means we no longer need to track the size of the arguments frame. Updates #40724, since now we don't need to teach cgo about the register ABI or change how it uses reflectcall. Change-Id: I7840489a2597962aeb670e0c1798a16a7359c94f Reviewed-on: https://go-review.googlesource.com/c/go/+/258938 Trust: Austin Clements <austin@google.com> Run-TryBot: Austin Clements <austin@google.com> TryBot-Result: Go Bot <gobot@golang.org> Reviewed-by: Cherry Zhang <cherryyz@google.com>
2020-09-01cmd/cgo: document #include <> search path behaviourKJ Tsanaktsidis
cgo effectively prepends -I${SRCDIR} to the header include path of all preambles it processes, so when an #include <> matches a header file both in the source directory and also another include directory, the local copy will be used in preference. This behaviour is surprising but unfortunately also longstanding and relied upon by packages in the wild, so the best we can do is to document it. Fixes #41059 Change-Id: If6d2818294b2bd94ea0fe5fd6ce77e54b3e167a6 Reviewed-on: https://go-review.googlesource.com/c/go/+/251758 Reviewed-by: Ian Lance Taylor <iant@golang.org>
2020-06-08all: replace usages of whitelist/blacklist and master/slaveFilippo Valsorda
There's been plenty of discussion on the usage of these terms in tech. I'm not trying to have yet another debate. It's clear that there are people who are hurt by them and who are made to feel unwelcome by their use due not to technical reasons but to their historical and social context. That's simply enough reason to replace them. Anyway, allowlist and blocklist are more self-explanatory than whitelist and blacklist, so this change has negative cost. Didn't change vendored, bundled, and minified files. Nearly all changes are tests or comments, with a couple renames in cmd/link and cmd/oldlink which are extremely safe. This should be fine to land during the freeze without even asking for an exception. Change-Id: I8fc54a3c8f9cc1973b710bbb9558a9e45810b896 Reviewed-on: https://go-review.googlesource.com/c/go/+/236857 Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org> Reviewed-by: Khosrow Moossavi <khos2ow@gmail.com> Reviewed-by: Leigh McCulloch <leighmcc@gmail.com> Reviewed-by: Urban Ishimwe <urbainishimwe@gmail.com>
2020-05-31cmd/cgo,cmd/fix,misc/cgo: map the EGLConfig C type to uintptr in GoElias Naur
Similarly to EGLDisplay, EGLConfig is declared as a pointer but may contain non-pointer values. I believe this is the root cause of https://todo.sr.ht/~eliasnaur/gio/121. Change-Id: I412c4fbc2eef4aa028534d68bda95db98e3a365d Reviewed-on: https://go-review.googlesource.com/c/go/+/235817 Run-TryBot: Elias Naur <mail@eliasnaur.com> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org>
2019-10-20go/build: recognize '.sx' as equivalent of '.S'Umang Parmar
On case insensitive filesystems, '.S' is interpreted as '.s' so, providing option to use '.sx' extension for '.S' files as an alternative. Fixes #32434 Change-Id: Ie2f7e5e2f3f12690ce18659e30ca94252a8f7bfc GitHub-Last-Rev: dcca989ec41ddc1d06ea509b78dce7d70bc996ed GitHub-Pull-Request: golang/go#32557 Reviewed-on: https://go-review.googlesource.com/c/go/+/181699 Run-TryBot: Ian Lance Taylor <iant@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org>
2019-10-20cmd/go: allow passing -U flag in cgo CFLAGSUmang Parmar
Fixes #34730 Change-Id: I2a16bbbd7af386e0abf59e1cc4b7d6e4ca3047c6 GitHub-Last-Rev: 096ff5a59ace36ac6ed5a0c87b4eef061be6b937 GitHub-Pull-Request: golang/go#34899 Reviewed-on: https://go-review.googlesource.com/c/go/+/201039 Run-TryBot: Ian Lance Taylor <iant@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org>
2019-06-05cmd/cgo: roll back "use C exact-width integer types to represent Go types"Ian Lance Taylor
Roll back CL 159258 and CL 168337. Those changes broke existing code. I can't see any way to keep existing code working while also producing good error messages for types like C.ulong (such as the ones already tested for in misc/cgo/errors). This is not an exact roll back because parts of the code have changed since those CLs. Updates #29878 Fixes #31093 Change-Id: I56fe76c167ff0ab381ed273b9ca4b952402e1434 Reviewed-on: https://go-review.googlesource.com/c/go/+/180357 Run-TryBot: Ian Lance Taylor <iant@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Dmitri Shuralyov <dmitshur@golang.org>
2019-03-18cmd/cgo: use C exact-width integer types to represent Go typesPhilipp Stephani
The exact-width integer types are required to use two’s complement representation and may not have padding bits, cf. §7.20.1.1/1 in the C11 standard or https://en.cppreference.com/w/c/types/integer. This ensures that they have the same domain and representation as the corresponding Go types. Fixes #29878 Change-Id: Ie8a51e91666dfd89731c7859abe47356c94ca1be GitHub-Last-Rev: 546a2cc3f1e22dc282757f73c01c91b00899d911 GitHub-Pull-Request: golang/go#29907 Reviewed-on: https://go-review.googlesource.com/c/go/+/159258 Run-TryBot: Ian Lance Taylor <iant@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org>
2019-03-08cmd/cgo: add missing parameter list for function _cgo_wait_runtime_init_donePhilipp Stephani
Fixes #29879 Change-Id: Id2061a5eab67bb90a8116dc4f16073be1c9a09a9 GitHub-Last-Rev: 186863ab6aa9481744f276a7afbd87bd53c9f863 GitHub-Pull-Request: golang/go#29900 Reviewed-on: https://go-review.googlesource.com/c/go/+/159178 Reviewed-by: Philipp Stephani <phst@google.com> Reviewed-by: Emmanuel Odeke <emm.odeke@gmail.com> Reviewed-by: Ian Lance Taylor <iant@golang.org> Run-TryBot: Emmanuel Odeke <emm.odeke@gmail.com> TryBot-Result: Gobot Gobot <gobot@golang.org>
2018-12-19cmd/cgo,doc/go1.12.html: document breaking EGLDisplay changeElias Naur
Change-Id: I3c8ba5fdb05b6b1324648622656cc10071c70a34 Reviewed-on: https://go-review.googlesource.com/c/154997 Reviewed-by: Ian Lance Taylor <iant@golang.org>
2018-11-06cmd/compile/internal/gc: update cgo_import_dynamic for AIXClément Chigot
On AIX, cmd/link needs two information in order to generate a dynamic import, the library and its object needed. Currently, cmd/link isn't able to retrieve this object only with the name of the library. Therefore, the library pattern in cgo_import_dynamic must be "lib.a/obj.o". Change-Id: Ib8b8aaa9807c9fa6af46ece4e312d58073ed6ec1 Reviewed-on: https://go-review.googlesource.com/c/146957 Run-TryBot: Ian Lance Taylor <iant@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org>
2018-07-28cmd/cgo: document that #including source files in subdirectories is a bad ideaRuss Cox
Suggested in discussion on #26366. Change-Id: Id9ad2e429a915f88b4c4b30fc415c722eebe0ea4 Reviewed-on: https://go-review.googlesource.com/125297 Reviewed-by: Ian Lance Taylor <iant@golang.org>
2018-07-16cmd/cgo: add note about bug writing C pointers to uninitialized C memoryIan Lance Taylor
Describe the problem as a bug, since it is not implied by the rest of the pointer passing rules, and it may be possible to fix it. Updates #19928 Change-Id: I2d336e7336b2a215c0b8cf909a203201ef1b054e Reviewed-on: https://go-review.googlesource.com/123658 Reviewed-by: Austin Clements <austin@google.com>
2018-06-26cmd/cgo: mention character restrictions on #cgo linesIan Lance Taylor
Fixes #26025 Change-Id: I43b3c9019ca8d2844e4d664c2090e506b2171077 Reviewed-on: https://go-review.googlesource.com/120975 Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
2018-06-13cgo: update documentation on calling C variadic functionsSabin Mihai Rapan
The current implementation does not support calling C variadic functions (as discussed in #975). Document that. Fixes #23537 Change-Id: If4c684a3d135f3c2782a720374dc4c07ea66dcbb Reviewed-on: https://go-review.googlesource.com/90415 Reviewed-by: Ian Lance Taylor <iant@golang.org>
2018-02-26cmd/cgo: clarify implicit "cgo" build constraintRens Rikkerink
When using the special import "C", the "cgo" build constraint is implied for the go file, potentially triggering unclear "undefined" error messages. Explicitly explain this in the documentation. Updates #24068 Change-Id: Ib656ceccd52c749ffe7fb2d3db9ac144f17abb32 GitHub-Last-Rev: 5a13f00a9b917e51246a5fbb642c4e9ed55aa21d GitHub-Pull-Request: golang/go#24072 Reviewed-on: https://go-review.googlesource.com/96655 Reviewed-by: Ian Lance Taylor <iant@golang.org>
2018-02-07cmd/go: accept only limited compiler and linker flags in #cgo directivesRuss Cox
Both gcc and clang accept an option -fplugin=code.so to load a plugin from the ELF shared object file code.so. Obviously that plugin can then do anything it wants during the build. This is contrary to the goal of "go get" never running untrusted code during the build. (What happens if you choose to run the result of the build is your responsibility.) Disallow this behavior by only allowing a small set of known command-line flags in #cgo CFLAGS directives (and #cgo LDFLAGS, etc). The new restrictions can be adjusted by the environment variables CGO_CFLAGS_ALLOW, CGO_CFLAGS_DISALLOW, and so on. See the documentation. In addition to excluding cgo-defined flags, we also have to make sure that when we pass file names on the command line, they don't look like flags. So we now refuse to build packages containing suspicious file names like -x.go. A wrinkle in all this is that GNU binutils uniformly accept @foo on the command line to mean "if the file foo exists, then substitute its contents for @foo in the command line". So we must also reject @x.go, flags and flag arguments beginning with @, and so on. Fixes #23672, CVE-2018-6574. Change-Id: I59e7c1355155c335a5c5ae0d2cf8fa7aa313940a Reviewed-on: https://team-review.git.corp.google.com/209949 Reviewed-by: Ian Lance Taylor <iant@google.com>
2018-01-17cmd/cgo: rewrite CFTypeRef and subytes on Darwin to uintptrKeith Randall
Cgo currently maps CFTypeRef and its subtypes to unsafe.Pointer or a pointer to a named empty struct. However, Darwin sometimes encodes some of CFTypeRef's subtypes as a few int fields packed in a pointer wrapper. This hackery confuses the Go runtime as the pointers can look like they point to things that shouldn't be pointed at. Switch CFTypeRef and its subtypes to map to uintptr. Detecting the affected set of types is tricky, there are over 200 of them, and the set isn't static across Darwin versions. Fortunately, downcasting from CFTypeRef to a subtype requires calling CFGetTypeID, getting a CFTypeID token, and comparing that with a known id from a *GetTypeID() call. So we can find all the type names by detecting all the *GetTypeID() prototypes and rewriting the corresponding *Ref types to uintptr. This strategy covers all the cases I've checked and is unlikely to have a false positive. Update #23091. Change-Id: I487eb4105c9b4785ba564de9c38d472c8c9a76ac Reviewed-on: https://go-review.googlesource.com/87615 Run-TryBot: Keith Randall <khr@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org>
2017-12-08doc: add doc about C types that we map to uintptr instead of ptrKeith Randall
Update #22906 Update #21897 Change-Id: I73709b2fdac6981d4bc2f7dab0767f2dd7be3be5 Reviewed-on: https://go-review.googlesource.com/82917 Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
2017-11-17cmd/cgo: special case C ptr types to use uintptrKeith Randall
Some C types are declared as pointers, but C code stores non-pointers in them. When the Go garbage collector sees such a pointer, it gets unhappy. Instead, for these types represent them on the Go side with uintptr. We need this change to handle Apple's CoreFoundation CF*Ref types. Users of these types might need to update their code like we do in root_cgo_darwin.go. The only change that is required under normal circumstances is converting some nils to 0. A go fix module is provided to help. Fixes #21897 RELNOTE=yes Change-Id: I9716cfb255dc918792625f42952aa171cd31ec1b Reviewed-on: https://go-review.googlesource.com/66332 Run-TryBot: Keith Randall <khr@golang.org> Reviewed-by: Robert Griesemer <gri@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org>
2017-11-15cmd/cgo: permit passing string values directly between Go and CIan Lance Taylor
Permit the C preamble to use the _GoString_ type. Permit Go code to pass string values directly to those C types. Add accessors for C code to retrieve sizes and pointers. Fixes #6907 Change-Id: I190c88319ec88a3ef0ddb99f342a843ba69fcaa3 Reviewed-on: https://go-review.googlesource.com/70890 Run-TryBot: Ian Lance Taylor <iant@golang.org> Reviewed-by: Austin Clements <austin@google.com>
2017-11-06cmd/dist, cmd/cgo, cmd/go: allow per-goos/goarch default CCRuss Cox
Even though cmd/dist has historically distinguished "CC for gohostos/gohostarch" from "CC for target goos/goarch", it has not recorded that distinction for later use by cmd/cgo and cmd/go. Now that content-based staleness includes the CC setting in the decision about when to rebuild packages, the go command needs to know the details of which CC to use when. Otherwise lots of things look out of date and (worse) may be rebuilt with the wrong CC. A related issue is that users may want to be able to build a toolchain capable of cross-compiling for two different non-host targets, and to date we've required that CC_FOR_TARGET apply to both. This CL introduces CC_FOR_${GOOS}_${GOARCH}, so that you can (for example) set CC_FOR_linux_arm and CC_FOR_linux_arm64 separately on a linux/ppc64 host and be able to cross-compile to either arm or arm64 with the right toolchain. Fixes #8161. Half of a fix for #22509. Change-Id: I7a43769f39d859f659d31bc96980918ba102fb83 Reviewed-on: https://go-review.googlesource.com/76018 Run-TryBot: Russ Cox <rsc@golang.org> Reviewed-by: David Crawshaw <crawshaw@golang.org>
2017-10-06cmd/asm, cmd/cgo, cmd/compile, cmd/cover, cmd/link: use standard -V outputRuss Cox
Also add -V=full to print a unique identifier of the specific tool being invoked. This will be used for content-based staleness. Also sort and clean up a few of the flag doc comments. Change-Id: I786fe50be0b8e5f77af809d8d2dab721185c2abd Reviewed-on: https://go-review.googlesource.com/68590 Run-TryBot: Russ Cox <rsc@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: David Crawshaw <crawshaw@golang.org>
2017-09-01cmd/cgo: support large unsigned macro againHiroshi Ioka
The approach of https://golang.org/cl/43476 turned out incorrect. The problem is that the sniff introduced by the CL only work for simple expression. And when it fails it fallback to uint64, not int64, which breaks backward compatibility. In this CL, we use DWARF for guessing kind instead. That should be more reliable than previous approach. And importanly, it fallbacks to int64 even if it fails to guess kind. Fixes #21708 Change-Id: I39a18cb2efbe4faa9becdcf53d5ac68dba180d46 Reviewed-on: https://go-review.googlesource.com/60510 Run-TryBot: Ian Lance Taylor <iant@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org>
2017-08-29cmd/cgo: update documentation on implementation detailsHiroshi Ioka
Change-Id: Iec771d5bbdf510b6c5ec17a614da90e7974a6348 Reviewed-on: https://go-review.googlesource.com/59870 Reviewed-by: Ian Lance Taylor <iant@golang.org>
2017-08-08cmd/cgo: document that structs and arrays don't work with //exportIan Lance Taylor
Fixes #18412 Change-Id: Ib457eeced7820517aa35df9e7dfda1c0de4ac004 Reviewed-on: https://go-review.googlesource.com/52852 Reviewed-by: Avelino <t@avelino.xxx> Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
2017-06-09all: single space after periodBrad Fitzpatrick
Done with grep & interactive search & replace, to double-check replacements. Not many remained after CL 20022. Fixes #18572 Change-Id: Idbe90ba3b584f9b9661d2bbd141607daaadfa41a Reviewed-on: https://go-review.googlesource.com/45270 Reviewed-by: Joe Tsai <thebrokentoaster@gmail.com>
2016-10-30cmd/cgo: add -srcdir optionIan Lance Taylor
This is convenient for direct use of `go tool cgo`. We can also use it from the go tool to reduce the length of the file names that cgo generates. Update #17070. Change-Id: I8466a0a2cc68a732d17d07319e303497715bac8c Reviewed-on: https://go-review.googlesource.com/32354 Run-TryBot: Ian Lance Taylor <iant@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Russ Cox <rsc@golang.org>
2016-10-24cmd/cgo: document C.malloc behaviorRuss Cox
Fixes #16309. Change-Id: Ifcd28b0746e1af30e2519a7b118485aecfb12396 Reviewed-on: https://go-review.googlesource.com/31811 Run-TryBot: Russ Cox <rsc@golang.org> TryBot-Result: Gobot Gobot <gobot@golang.org> Reviewed-by: Ian Lance Taylor <iant@golang.org>
generated by cgit v1.3 (git 2.53.0) at 2026-04-16 14:46:11 +0000