runtime: add ctxt parameter to cgocallback called from Go

The cgocallback function picked up a ctxt parameter in CL 22508.
That CL updated the assembler implementation, but there are a few
mentions in Go code that were not updated. This CL fixes that.

Fixes #16326

Change-Id: I5f68e23565c6a0b11057aff476d13990bff54a66
Reviewed-on: https://go-review.googlesource.com/24848
Run-TryBot: Brad Fitzpatrick <bradfitz@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
Reviewed-by: Minux Ma <minux@golang.org>

diff --git a/src/runtime/cgocall.go b/src/runtime/cgocall.go
index 0f8386b10f54d50e26a569c5acd69f0a8f41e9ff..d7e20ebc1d94c2866abe40f5090ee47fa35e9718 100644 (file)
--- a/src/runtime/cgocall.go
+++ b/src/runtime/cgocall.go
@@ -44,7 +44,7 @@
 // call arbitrary Go code directly and must be careful not to allocate
 // memory or use up m->g0's stack.
 //
-// _cgoexp_GoF calls runtime.cgocallback(p.GoF, frame, framesize).
+// _cgoexp_GoF calls runtime.cgocallback(p.GoF, frame, framesize, ctxt).
 // (The reason for having _cgoexp_GoF instead of writing a crosscall3
 // to make this call directly is that _cgoexp_GoF, because it is compiled
 // with 6c instead of gcc, can refer to dotted names like

diff --git a/src/runtime/os_nacl.go b/src/runtime/os_nacl.go
index 6cbd16de159c8c24a709efcbcc082a0b046c53e5..1dacc1a49c014ed7edcf08b331a75c3424df29d6 100644 (file)
--- a/src/runtime/os_nacl.go
+++ b/src/runtime/os_nacl.go
@@ -246,7 +246,7 @@ func memlimit() uintptr {
 //go:norace
 //go:nowritebarrierrec
 func badsignal(sig uintptr) {
-       cgocallback(unsafe.Pointer(funcPC(badsignalgo)), noescape(unsafe.Pointer(&sig)), unsafe.Sizeof(sig))
+       cgocallback(unsafe.Pointer(funcPC(badsignalgo)), noescape(unsafe.Pointer(&sig)), unsafe.Sizeof(sig), 0)
 }
 
 func badsignalgo(sig uintptr) {

diff --git a/src/runtime/signal1_unix.go b/src/runtime/signal1_unix.go
index 5080202833e3d8fd16fcd381a8aae262303f06a1..101d16dc8e3185a3b2defa0202e3735181ed0a44 100644 (file)
--- a/src/runtime/signal1_unix.go
+++ b/src/runtime/signal1_unix.go
@@ -338,7 +338,7 @@ func sigNotOnStack(sig uint32) {
 //go:norace
 //go:nowritebarrierrec
 func badsignal(sig uintptr, c *sigctxt) {
-       cgocallback(unsafe.Pointer(funcPC(badsignalgo)), noescape(unsafe.Pointer(&sig)), unsafe.Sizeof(sig)+unsafe.Sizeof(c))
+       cgocallback(unsafe.Pointer(funcPC(badsignalgo)), noescape(unsafe.Pointer(&sig)), unsafe.Sizeof(sig)+unsafe.Sizeof(c), 0)
 }
 
 func badsignalgo(sig uintptr, c *sigctxt) {

diff --git a/src/runtime/signal_darwin.go b/src/runtime/signal_darwin.go
index c8534ff09bad785c3b768040e5969423b0120b08..fb06de5509bfe4d0effbce24f1151826dd71032f 100644 (file)
--- a/src/runtime/signal_darwin.go
+++ b/src/runtime/signal_darwin.go
@@ -70,12 +70,12 @@ func sigtrampgo(fn uintptr, infostyle, sig uint32, info *siginfo, ctx unsafe.Poi
                sigaltstack(nil, &st)
                if st.ss_flags&_SS_DISABLE != 0 {
                        setg(nil)
-                       cgocallback(unsafe.Pointer(funcPC(noSignalStack)), noescape(unsafe.Pointer(&sig)), unsafe.Sizeof(sig))
+                       cgocallback(unsafe.Pointer(funcPC(noSignalStack)), noescape(unsafe.Pointer(&sig)), unsafe.Sizeof(sig), 0)
                }
                stsp := uintptr(unsafe.Pointer(st.ss_sp))
                if sp < stsp || sp >= stsp+st.ss_size {
                        setg(nil)
-                       cgocallback(unsafe.Pointer(funcPC(sigNotOnStack)), noescape(unsafe.Pointer(&sig)), unsafe.Sizeof(sig))
+                       cgocallback(unsafe.Pointer(funcPC(sigNotOnStack)), noescape(unsafe.Pointer(&sig)), unsafe.Sizeof(sig), 0)
                }
                g.m.gsignal.stack.lo = stsp
                g.m.gsignal.stack.hi = stsp + st.ss_size

diff --git a/src/runtime/signal_freebsd.go b/src/runtime/signal_freebsd.go
index c4cb68720eb6ae3a4e84c2ca3693c9343fd8c007..c6c126983ddedd432df3a14fcab05c6d65d21ee6 100644 (file)
--- a/src/runtime/signal_freebsd.go
+++ b/src/runtime/signal_freebsd.go
@@ -66,12 +66,12 @@ func sigtrampgo(sig uint32, info *siginfo, ctx unsafe.Pointer) {
                sigaltstack(nil, &st)
                if st.ss_flags&_SS_DISABLE != 0 {
                        setg(nil)
-                       cgocallback(unsafe.Pointer(funcPC(noSignalStack)), noescape(unsafe.Pointer(&sig)), unsafe.Sizeof(sig))
+                       cgocallback(unsafe.Pointer(funcPC(noSignalStack)), noescape(unsafe.Pointer(&sig)), unsafe.Sizeof(sig), 0)
                }
                stsp := uintptr(unsafe.Pointer(st.ss_sp))
                if sp < stsp || sp >= stsp+st.ss_size {
                        setg(nil)
-                       cgocallback(unsafe.Pointer(funcPC(sigNotOnStack)), noescape(unsafe.Pointer(&sig)), unsafe.Sizeof(sig))
+                       cgocallback(unsafe.Pointer(funcPC(sigNotOnStack)), noescape(unsafe.Pointer(&sig)), unsafe.Sizeof(sig), 0)
                }
                g.m.gsignal.stack.lo = stsp
                g.m.gsignal.stack.hi = stsp + st.ss_size

diff --git a/src/runtime/signal_openbsd.go b/src/runtime/signal_openbsd.go
index 9275279860f4b6ed31d997e33d53c13f241c0d5d..efe30da5d962678477bdf1848350037e6fde503d 100644 (file)
--- a/src/runtime/signal_openbsd.go
+++ b/src/runtime/signal_openbsd.go
@@ -66,12 +66,12 @@ func sigtrampgo(sig uint32, info *siginfo, ctx unsafe.Pointer) {
                sigaltstack(nil, &st)
                if st.ss_flags&_SS_DISABLE != 0 {
                        setg(nil)
-                       cgocallback(unsafe.Pointer(funcPC(noSignalStack)), noescape(unsafe.Pointer(&sig)), unsafe.Sizeof(sig))
+                       cgocallback(unsafe.Pointer(funcPC(noSignalStack)), noescape(unsafe.Pointer(&sig)), unsafe.Sizeof(sig), 0)
                }
                stsp := uintptr(unsafe.Pointer(st.ss_sp))
                if sp < stsp || sp >= stsp+st.ss_size {
                        setg(nil)
-                       cgocallback(unsafe.Pointer(funcPC(sigNotOnStack)), noescape(unsafe.Pointer(&sig)), unsafe.Sizeof(sig))
+                       cgocallback(unsafe.Pointer(funcPC(sigNotOnStack)), noescape(unsafe.Pointer(&sig)), unsafe.Sizeof(sig), 0)
                }
                g.m.gsignal.stack.lo = stsp
                g.m.gsignal.stack.hi = stsp + st.ss_size

diff --git a/src/runtime/signal_sigtramp.go b/src/runtime/signal_sigtramp.go
index 3e0b10457863c4826b239223c05c0cf985ef98a3..dbbbcd0392b1fe252b76a06ce166f2b08926580f 100644 (file)
--- a/src/runtime/signal_sigtramp.go
+++ b/src/runtime/signal_sigtramp.go
@@ -37,12 +37,12 @@ func sigtrampgo(sig uint32, info *siginfo, ctx unsafe.Pointer) {
                sigaltstack(nil, &st)
                if st.ss_flags&_SS_DISABLE != 0 {
                        setg(nil)
-                       cgocallback(unsafe.Pointer(funcPC(noSignalStack)), noescape(unsafe.Pointer(&sig)), unsafe.Sizeof(sig))
+                       cgocallback(unsafe.Pointer(funcPC(noSignalStack)), noescape(unsafe.Pointer(&sig)), unsafe.Sizeof(sig), 0)
                }
                stsp := uintptr(unsafe.Pointer(st.ss_sp))
                if sp < stsp || sp >= stsp+st.ss_size {
                        setg(nil)
-                       cgocallback(unsafe.Pointer(funcPC(sigNotOnStack)), noescape(unsafe.Pointer(&sig)), unsafe.Sizeof(sig))
+                       cgocallback(unsafe.Pointer(funcPC(sigNotOnStack)), noescape(unsafe.Pointer(&sig)), unsafe.Sizeof(sig), 0)
                }
                g.m.gsignal.stack.lo = stsp
                g.m.gsignal.stack.hi = stsp + st.ss_size

diff --git a/src/runtime/stubs.go b/src/runtime/stubs.go
index 6c28fd2e782e7d2302859ce130b8fdaebdec2748..a594c1b7910f6ce5d80a3f2ef0f1c205ac8b78d3 100644 (file)
--- a/src/runtime/stubs.go
+++ b/src/runtime/stubs.go
@@ -98,7 +98,7 @@ func noescape(p unsafe.Pointer) unsafe.Pointer {
        return unsafe.Pointer(x ^ 0)
 }
 
-func cgocallback(fn, frame unsafe.Pointer, framesize uintptr)
+func cgocallback(fn, frame unsafe.Pointer, framesize, ctxt uintptr)
 func gogo(buf *gobuf)
 func gosave(buf *gobuf)
 func mincore(addr unsafe.Pointer, n uintptr, dst *byte) int32
@@ -143,7 +143,7 @@ func goexit(neverCallThisFunction)
 // cgocallback_gofunc is not called from go, only from cgocallback,
 // so the arguments will be found via cgocallback's pointer-declared arguments.
 // See the assembly implementations for more details.
-func cgocallback_gofunc(fv uintptr, frame uintptr, framesize uintptr)
+func cgocallback_gofunc(fv uintptr, frame uintptr, framesize, ctxt uintptr)
 
 // publicationBarrier performs a store/store barrier (a "publication"
 // or "export" barrier). Some form of synchronization is required