1 files changed, 0 insertions, 337 deletions
diff --git a/libgo/go/runtime/signal1_unix.go b/libgo/go/runtime/signal1_unix.go
deleted file mode 100644
index 181aebe64b3..00000000000
--- a/libgo/go/runtime/signal1_unix.go
+++ /dev/null
@@ -1,337 +0,0 @@
-// Copyright 2012 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 darwin dragonfly freebsd linux netbsd openbsd solaris
-
-package runtime
-
-import (
-	_ "unsafe" // For go:linkname.
-)
-
-// Temporary for gccgo's C code to call:
-//go:linkname initsig runtime.initsig
-//go:linkname crash runtime.crash
-//go:linkname resetcpuprofiler runtime.resetcpuprofiler
-
-//extern setitimer
-func setitimer(which int32, new *_itimerval, old *_itimerval) int32
-
-type sigTabT struct {
-	flags int32
-	name  string
-}
-
-const (
-	_SIG_DFL uintptr = 0
-	_SIG_IGN uintptr = 1
-)
-
-// Stores the signal handlers registered before Go installed its own.
-// These signal handlers will be invoked in cases where Go doesn't want to
-// handle a particular signal (e.g., signal occurred on a non-Go thread).
-// See sigfwdgo() for more information on when the signals are forwarded.
-//
-// Signal forwarding is currently available only on Darwin and Linux.
-var fwdSig [_NSIG]uintptr
-
-// sigmask represents a general signal mask compatible with the GOOS
-// specific sigset types: the signal numbered x is represented by bit x-1
-// to match the representation expected by sigprocmask.
-type sigmask [(_NSIG + 31) / 32]uint32
-
-// channels for synchronizing signal mask updates with the signal mask
-// thread
-var (
-	disableSigChan  chan uint32
-	enableSigChan   chan uint32
-	maskUpdatedChan chan struct{}
-)
-
-func init() {
-	// _NSIG is the number of signals on this operating system.
-	// sigtable should describe what to do for all the possible signals.
-	if len(sigtable) != _NSIG {
-		print("runtime: len(sigtable)=", len(sigtable), " _NSIG=", _NSIG, "\n")
-		throw("bad sigtable len")
-	}
-}
-
-var signalsOK bool
-
-// Initialize signals.
-// Called by libpreinit so runtime may not be initialized.
-//go:nosplit
-//go:nowritebarrierrec
-func initsig(preinit bool) {
-	if preinit {
-		// preinit is only passed as true if isarchive should be true.
-		isarchive = true
-	}
-
-	if !preinit {
-		// It's now OK for signal handlers to run.
-		signalsOK = true
-	}
-
-	// For c-archive/c-shared this is called by libpreinit with
-	// preinit == true.
-	if (isarchive || islibrary) && !preinit {
-		return
-	}
-
-	for i := int32(0); i < _NSIG; i++ {
-		t := &sigtable[i]
-		if t.flags == 0 || t.flags&_SigDefault != 0 {
-			continue
-		}
-		fwdSig[i] = getsig(i)
-
-		if !sigInstallGoHandler(i) {
-			// Even if we are not installing a signal handler,
-			// set SA_ONSTACK if necessary.
-			if fwdSig[i] != _SIG_DFL && fwdSig[i] != _SIG_IGN {
-				setsigstack(i)
-			}
-			continue
-		}
-
-		t.flags |= _SigHandling
-		setsig(i, getSigtramp(), true)
-	}
-}
-
-//go:nosplit
-//go:nowritebarrierrec
-func sigInstallGoHandler(sig int32) bool {
-	// For some signals, we respect an inherited SIG_IGN handler
-	// rather than insist on installing our own default handler.
-	// Even these signals can be fetched using the os/signal package.
-	switch sig {
-	case _SIGHUP, _SIGINT:
-		if fwdSig[sig] == _SIG_IGN {
-			return false
-		}
-	}
-
-	t := &sigtable[sig]
-	if t.flags&_SigSetStack != 0 {
-		return false
-	}
-
-	// When built using c-archive or c-shared, only install signal
-	// handlers for synchronous signals.
-	if (isarchive || islibrary) && t.flags&_SigPanic == 0 {
-		return false
-	}
-
-	return true
-}
-
-func sigenable(sig uint32) {
-	if sig >= uint32(len(sigtable)) {
-		return
-	}
-
-	t := &sigtable[sig]
-	if t.flags&_SigNotify != 0 {
-		ensureSigM()
-		enableSigChan <- sig
-		<-maskUpdatedChan
-		if t.flags&_SigHandling == 0 {
-			t.flags |= _SigHandling
-			fwdSig[sig] = getsig(int32(sig))
-			setsig(int32(sig), getSigtramp(), true)
-		}
-	}
-}
-
-func sigdisable(sig uint32) {
-	if sig >= uint32(len(sigtable)) {
-		return
-	}
-
-	t := &sigtable[sig]
-	if t.flags&_SigNotify != 0 {
-		ensureSigM()
-		disableSigChan <- sig
-		<-maskUpdatedChan
-
-		// If initsig does not install a signal handler for a
-		// signal, then to go back to the state before Notify
-		// we should remove the one we installed.
-		if !sigInstallGoHandler(int32(sig)) {
-			t.flags &^= _SigHandling
-			setsig(int32(sig), fwdSig[sig], true)
-		}
-	}
-}
-
-func sigignore(sig uint32) {
-	if sig >= uint32(len(sigtable)) {
-		return
-	}
-
-	t := &sigtable[sig]
-	if t.flags&_SigNotify != 0 {
-		t.flags &^= _SigHandling
-		setsig(int32(sig), _SIG_IGN, true)
-	}
-}
-
-func resetcpuprofiler(hz int32) {
-	var it _itimerval
-	if hz == 0 {
-		setitimer(_ITIMER_PROF, &it, nil)
-	} else {
-		it.it_interval.tv_sec = 0
-		it.it_interval.set_usec(1000000 / hz)
-		it.it_value = it.it_interval
-		setitimer(_ITIMER_PROF, &it, nil)
-	}
-	_g_ := getg()
-	_g_.m.profilehz = hz
-}
-
-func sigpipe() {
-	if sigsend(_SIGPIPE) {
-		return
-	}
-	dieFromSignal(_SIGPIPE)
-}
-
-// dieFromSignal kills the program with a signal.
-// This provides the expected exit status for the shell.
-// This is only called with fatal signals expected to kill the process.
-//go:nosplit
-//go:nowritebarrierrec
-func dieFromSignal(sig int32) {
-	setsig(sig, _SIG_DFL, false)
-	updatesigmask(sigmask{})
-	raise(sig)
-
-	// That should have killed us. On some systems, though, raise
-	// sends the signal to the whole process rather than to just
-	// the current thread, which means that the signal may not yet
-	// have been delivered. Give other threads a chance to run and
-	// pick up the signal.
-	osyield()
-	osyield()
-	osyield()
-
-	// If we are still somehow running, just exit with the wrong status.
-	exit(2)
-}
-
-// raisebadsignal is called when a signal is received on a non-Go
-// thread, and the Go program does not want to handle it (that is, the
-// program has not called os/signal.Notify for the signal).
-func raisebadsignal(sig int32, c *sigctxt) {
-	if sig == _SIGPROF {
-		// Ignore profiling signals that arrive on non-Go threads.
-		return
-	}
-
-	var handler uintptr
-	if sig >= _NSIG {
-		handler = _SIG_DFL
-	} else {
-		handler = fwdSig[sig]
-	}
-
-	// Reset the signal handler and raise the signal.
-	// We are currently running inside a signal handler, so the
-	// signal is blocked. We need to unblock it before raising the
-	// signal, or the signal we raise will be ignored until we return
-	// from the signal handler. We know that the signal was unblocked
-	// before entering the handler, or else we would not have received
-	// it. That means that we don't have to worry about blocking it
-	// again.
-	unblocksig(sig)
-	setsig(sig, handler, false)
-
-	// If we're linked into a non-Go program we want to try to
-	// avoid modifying the original context in which the signal
-	// was raised. If the handler is the default, we know it
-	// is non-recoverable, so we don't have to worry about
-	// re-installing sighandler. At this point we can just
-	// return and the signal will be re-raised and caught by
-	// the default handler with the correct context.
-	if (isarchive || islibrary) && handler == _SIG_DFL && c.sigcode() != _SI_USER {
-		return
-	}
-
-	raise(sig)
-
-	// If the signal didn't cause the program to exit, restore the
-	// Go signal handler and carry on.
-	//
-	// We may receive another instance of the signal before we
-	// restore the Go handler, but that is not so bad: we know
-	// that the Go program has been ignoring the signal.
-	setsig(sig, getSigtramp(), true)
-}
-
-func crash() {
-	dieFromSignal(_SIGABRT)
-}
-
-// ensureSigM starts one global, sleeping thread to make sure at least one thread
-// is available to catch signals enabled for os/signal.
-func ensureSigM() {
-	if maskUpdatedChan != nil {
-		return
-	}
-	maskUpdatedChan = make(chan struct{})
-	disableSigChan = make(chan uint32)
-	enableSigChan = make(chan uint32)
-	go func() {
-		// Signal masks are per-thread, so make sure this goroutine stays on one
-		// thread.
-		LockOSThread()
-		defer UnlockOSThread()
-		// The sigBlocked mask contains the signals not active for os/signal,
-		// initially all signals except the essential. When signal.Notify()/Stop is called,
-		// sigenable/sigdisable in turn notify this thread to update its signal
-		// mask accordingly.
-		var sigBlocked sigmask
-		for i := range sigBlocked {
-			sigBlocked[i] = ^uint32(0)
-		}
-		for i := range sigtable {
-			if sigtable[i].flags&_SigUnblock != 0 {
-				sigBlocked[(i-1)/32] &^= 1 << ((uint32(i) - 1) & 31)
-			}
-		}
-		updatesigmask(sigBlocked)
-		for {
-			select {
-			case sig := <-enableSigChan:
-				if b := sig - 1; sig > 0 {
-					sigBlocked[b/32] &^= (1 << (b & 31))
-				}
-			case sig := <-disableSigChan:
-				if b := sig - 1; sig > 0 {
-					sigBlocked[b/32] |= (1 << (b & 31))
-				}
-			}
-			updatesigmask(sigBlocked)
-			maskUpdatedChan <- struct{}{}
-		}
-	}()
-}
-
-// This runs on a foreign stack, without an m or a g. No stack split.
-//go:nosplit
-//go:norace
-//go:nowritebarrierrec
-func badsignal(sig uintptr, c *sigctxt) {
-	needm(0)
-	if !sigsend(uint32(sig)) {
-		// A foreign thread received the signal sig, and the
-		// Go code does not want to handle it.
-		raisebadsignal(int32(sig), c)
-	}
-	dropm()
-}