runtime: Remove now unnecessary pad field from ParFor.

    
    It is not needed due to the removal of the ctx field.
    
    Reviewed-on: https://go-review.googlesource.com/16525

From-SVN: r229616

1 files changed, 0 insertions, 182 deletions

diff --git a/libgo/go/runtime/sigqueue.go b/libgo/go/runtime/sigqueue.go
deleted file mode 100644
index fed4560fe33..00000000000
--- a/libgo/go/runtime/sigqueue.go
+++ /dev/null
@@ -1,182 +0,0 @@
-// 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.
-
-// This file implements runtime support for signal handling.
-//
-// Most synchronization primitives are not available from
-// the signal handler (it cannot block, allocate memory, or use locks)
-// so the handler communicates with a processing goroutine
-// via struct sig, below.
-//
-// sigsend is called by the signal handler to queue a new signal.
-// signal_recv is called by the Go program to receive a newly queued signal.
-// Synchronization between sigsend and signal_recv is based on the sig.state
-// variable.  It can be in 3 states: sigIdle, sigReceiving and sigSending.
-// sigReceiving means that signal_recv is blocked on sig.Note and there are no
-// new pending signals.
-// sigSending means that sig.mask *may* contain new pending signals,
-// signal_recv can't be blocked in this state.
-// sigIdle means that there are no new pending signals and signal_recv is not blocked.
-// Transitions between states are done atomically with CAS.
-// When signal_recv is unblocked, it resets sig.Note and rechecks sig.mask.
-// If several sigsends and signal_recv execute concurrently, it can lead to
-// unnecessary rechecks of sig.mask, but it cannot lead to missed signals
-// nor deadlocks.
-
-package runtime
-
-import "unsafe"
-
-var sig struct {
-	note   note
-	mask   [(_NSIG + 31) / 32]uint32
-	wanted [(_NSIG + 31) / 32]uint32
-	recv   [(_NSIG + 31) / 32]uint32
-	state  uint32
-	inuse  bool
-}
-
-const (
-	sigIdle = iota
-	sigReceiving
-	sigSending
-)
-
-// Called from sighandler to send a signal back out of the signal handling thread.
-// Reports whether the signal was sent. If not, the caller typically crashes the program.
-func sigsend(s int32) bool {
-	bit := uint32(1) << uint(s&31)
-	if !sig.inuse || s < 0 || int(s) >= 32*len(sig.wanted) || sig.wanted[s/32]&bit == 0 {
-		return false
-	}
-
-	// Add signal to outgoing queue.
-	for {
-		mask := sig.mask[s/32]
-		if mask&bit != 0 {
-			return true // signal already in queue
-		}
-		if cas(&sig.mask[s/32], mask, mask|bit) {
-			break
-		}
-	}
-
-	// Notify receiver that queue has new bit.
-Send:
-	for {
-		switch atomicload(&sig.state) {
-		default:
-			gothrow("sigsend: inconsistent state")
-		case sigIdle:
-			if cas(&sig.state, sigIdle, sigSending) {
-				break Send
-			}
-		case sigSending:
-			// notification already pending
-			break Send
-		case sigReceiving:
-			if cas(&sig.state, sigReceiving, sigIdle) {
-				notewakeup(&sig.note)
-				break Send
-			}
-		}
-	}
-
-	return true
-}
-
-// Called to receive the next queued signal.
-// Must only be called from a single goroutine at a time.
-func signal_recv() uint32 {
-	for {
-		// Serve any signals from local copy.
-		for i := uint32(0); i < _NSIG; i++ {
-			if sig.recv[i/32]&(1<<(i&31)) != 0 {
-				sig.recv[i/32] &^= 1 << (i & 31)
-				return i
-			}
-		}
-
-		// Wait for updates to be available from signal sender.
-	Receive:
-		for {
-			switch atomicload(&sig.state) {
-			default:
-				gothrow("signal_recv: inconsistent state")
-			case sigIdle:
-				if cas(&sig.state, sigIdle, sigReceiving) {
-					notetsleepg(&sig.note, -1)
-					noteclear(&sig.note)
-					break Receive
-				}
-			case sigSending:
-				if cas(&sig.state, sigSending, sigIdle) {
-					break Receive
-				}
-			}
-		}
-
-		// Incorporate updates from sender into local copy.
-		for i := range sig.mask {
-			sig.recv[i] = xchg(&sig.mask[i], 0)
-		}
-	}
-}
-
-// Must only be called from a single goroutine at a time.
-func signal_enable(s uint32) {
-	if !sig.inuse {
-		// The first call to signal_enable is for us
-		// to use for initialization.  It does not pass
-		// signal information in m.
-		sig.inuse = true // enable reception of signals; cannot disable
-		noteclear(&sig.note)
-		return
-	}
-
-	if int(s) >= len(sig.wanted)*32 {
-		return
-	}
-	sig.wanted[s/32] |= 1 << (s & 31)
-	sigenable_go(s)
-}
-
-// Must only be called from a single goroutine at a time.
-func signal_disable(s uint32) {
-	if int(s) >= len(sig.wanted)*32 {
-		return
-	}
-	sig.wanted[s/32] &^= 1 << (s & 31)
-	sigdisable_go(s)
-}
-
-// This runs on a foreign stack, without an m or a g.  No stack split.
-//go:nosplit
-func badsignal(sig uintptr) {
-	// Some external libraries, for example, OpenBLAS, create worker threads in
-	// a global constructor. If we're doing cpu profiling, and the SIGPROF signal
-	// comes to one of the foreign threads before we make our first cgo call, the
-	// call to cgocallback below will bring down the whole process.
-	// It's better to miss a few SIGPROF signals than to abort in this case.
-	// See http://golang.org/issue/9456.
-	if _SIGPROF != 0 && sig == _SIGPROF && needextram != 0 {
-		return
-	}
-	cgocallback(unsafe.Pointer(funcPC(sigsend)), noescape(unsafe.Pointer(&sig)), unsafe.Sizeof(sig))
-}
-
-func sigenable_m()
-func sigdisable_m()
-
-func sigenable_go(s uint32) {
-	g := getg()
-	g.m.scalararg[0] = uintptr(s)
-	onM(sigenable_m)
-}
-
-func sigdisable_go(s uint32) {
-	g := getg()
-	g.m.scalararg[0] = uintptr(s)
-	onM(sigdisable_m)
-}