e0f69f36ea
Previously the libgo Makefile explicitly listed the set of files to
compile for each package. For packages that use build tags, this
required a lot of awkward automake conditionals in the Makefile.
This CL changes the build to look at the build tags in the files.
The new shell script libgo/match.sh does the matching. This required
adjusting a lot of build tags, and removing some files that are never
used. I verified that the exact same sets of files are compiled on
amd64 GNU/Linux. I also tested the build on i386 Solaris.
Writing match.sh revealed some bugs in the build tag handling that
already exists, in a slightly different form, in the gotest shell
script. This CL fixes those problems as well.
The old code used automake conditionals to handle systems that were
missing strerror_r and wait4. Rather than deal with those in Go, those
functions are now implemented in runtime/go-nosys.c when necessary, so
the Go code can simply assume that they exist.
The os testsuite looked for dir_unix.go, which was never built for gccgo
and has now been removed. I changed the testsuite to look for dir.go
instead.
Reviewed-on: https://go-review.googlesource.com/25546
From-SVN: r239189
61 lines
1.7 KiB
Go
61 lines
1.7 KiB
Go
// Copyright 2009 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.
|
|
|
|
// +build ignore
|
|
|
|
// +build dragonfly linux netbsd
|
|
|
|
package runtime
|
|
|
|
import "unsafe"
|
|
|
|
// Continuation of the (assembly) sigtramp() logic.
|
|
// This may be called with the world stopped.
|
|
//go:nosplit
|
|
//go:nowritebarrierrec
|
|
func sigtrampgo(sig uint32, info *siginfo, ctx unsafe.Pointer) {
|
|
if sigfwdgo(sig, info, ctx) {
|
|
return
|
|
}
|
|
g := getg()
|
|
if g == nil {
|
|
if sig == _SIGPROF {
|
|
// Ignore profiling signals that arrive on
|
|
// non-Go threads. On some systems they will
|
|
// be handled directly by the signal handler,
|
|
// by calling sigprofNonGo, in which case we won't
|
|
// get here anyhow.
|
|
return
|
|
}
|
|
badsignal(uintptr(sig), &sigctxt{info, ctx})
|
|
return
|
|
}
|
|
|
|
// If some non-Go code called sigaltstack, adjust.
|
|
sp := uintptr(unsafe.Pointer(&sig))
|
|
if sp < g.m.gsignal.stack.lo || sp >= g.m.gsignal.stack.hi {
|
|
var st sigaltstackt
|
|
sigaltstack(nil, &st)
|
|
if st.ss_flags&_SS_DISABLE != 0 {
|
|
setg(nil)
|
|
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), 0)
|
|
}
|
|
g.m.gsignal.stack.lo = stsp
|
|
g.m.gsignal.stack.hi = stsp + st.ss_size
|
|
g.m.gsignal.stackguard0 = stsp + _StackGuard
|
|
g.m.gsignal.stackguard1 = stsp + _StackGuard
|
|
g.m.gsignal.stackAlloc = st.ss_size
|
|
g.m.gsignal.stktopsp = getcallersp(unsafe.Pointer(&sig))
|
|
}
|
|
|
|
setg(g.m.gsignal)
|
|
sighandler(sig, info, ctx, g)
|
|
setg(g)
|
|
}
|