// Copyright 2016 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package runtime import ( "runtime/internal/atomic" "unsafe" ) // For historical reasons these functions are called as though they // were in the syscall package. //go:linkname Cgocall syscall.Cgocall //go:linkname CgocallDone syscall.CgocallDone //go:linkname CgocallBack syscall.CgocallBack //go:linkname CgocallBackDone syscall.CgocallBackDone // A routine that may be called by SWIG. //go:linkname _cgo_panic _cgo_panic // iscgo is set to true if the cgo tool sets the C variable runtime_iscgo // to true. var iscgo bool // cgoHasExtraM is set on startup when an extra M is created for cgo. // The extra M must be created before any C/C++ code calls cgocallback. var cgoHasExtraM bool // cgoAlwaysFalse is a boolean value that is always false. // The cgo-generated code says if cgoAlwaysFalse { cgoUse(p) }. // The compiler cannot see that cgoAlwaysFalse is always false, // so it emits the test and keeps the call, giving the desired // escape analysis result. The test is cheaper than the call. var cgoAlwaysFalse bool // Cgocall prepares to call from code written in Go to code written in // C/C++. This takes the current goroutine out of the Go scheduler, as // though it were making a system call. Otherwise the program can // lookup if the C code blocks. The idea is to call this function, // then immediately call the C/C++ function. After the C/C++ function // returns, call cgocalldone. The usual Go code would look like // syscall.Cgocall() // defer syscall.Cgocalldone() // cfunction() func Cgocall() { mp := getg().m mp.ncgocall++ mp.ncgo++ entersyscall(0) mp.incgo = true } // CgocallDone prepares to return to Go code from C/C++ code. func CgocallDone() { gp := getg() if gp == nil { throw("no g in CgocallDone") } gp.m.incgo = false gp.m.ncgo-- // If we are invoked because the C function called _cgo_panic, // then _cgo_panic will already have exited syscall mode. if readgstatus(gp)&^_Gscan == _Gsyscall { exitsyscall(0) } } // CgocallBack is used when calling from C/C++ code into Go code. // The usual approach is // syscall.CgocallBack() // defer syscall.CgocallBackDone() // gofunction() //go:nosplit func CgocallBack() { gp := getg() if gp == nil || gp.m == nil { needm(0) gp = getg() mp := gp.m mp.dropextram = true } lockOSThread() exitsyscall(0) gp.m.incgo = false if gp.m.ncgo == 0 { // The C call to Go came from a thread created by C. // The C call to Go came from a thread not currently running // any Go. In the case of -buildmode=c-archive or c-shared, // this call may be coming in before package initialization // is complete. Wait until it is. <-main_init_done } mp := gp.m if mp.needextram || atomic.Load(&extraMWaiters) > 0 { mp.needextram = false newextram() } } // CgocallBackDone prepares to return to C/C++ code that has called // into Go code. func CgocallBackDone() { unlockOSThread() // If we are the top level Go function called from C/C++, then // we need to release the m. But don't release it if we are // panicing; since this is the top level, we are going to // crash the program, and we need the g and m to print the // panic values. // // Dropping the m is going to clear g. This function is being // called as a deferred function, so we will return to // deferreturn which will want to clear the _defer field. // As soon as we call dropm another thread may call needm and // start using g, so we must not tamper with the _defer field // after dropm. So clear _defer now. gp := getg() mp := gp.m drop := false if mp.dropextram && mp.ncgo == 0 && gp._panic == nil { d := gp._defer if d == nil || d.link != nil { throw("unexpected g._defer in CgocallBackDone") } gp._defer = nil freedefer(d) drop = true } gp.m.incgo = true entersyscall(0) if drop { mp.dropextram = false dropm() } } // _cgo_panic may be called by SWIG code to panic. func _cgo_panic(p *byte) { exitsyscall(0) panic(gostringnocopy(p)) } // cgo_yield exists in the gc toolchain to let TSAN deliver a signal. // gccgo does not need this. var cgo_yield = &_cgo_yield var _cgo_yield unsafe.Pointer