qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-23 19:50:06 -07:00
Code Releases Activity

[dev.cc] runtime: convert openbsd/amd64 port to Go

Browse Source 
LGTM=rsc
R=rsc, bradfitz
CC=golang-codereviews
https://golang.org/cl/171660043
This commit is contained in:
Joel Sing 2014-11-14 13:01:12 +11:00
parent b2ec4cf50c
commit ba603c3100
10 changed files with 409 additions and 457 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

72
src/runtime/defs_openbsd_amd64.go
View File

@ -85,45 +85,45 @@ const (
)
type tforkt struct {
tf_tcb *byte
tf_tcb unsafe.Pointer
tf_tid *int32
tf_stack *byte
tf_stack uintptr
}
type sigaltstackt struct {
ss_sp *byte
ss_sp uintptr
ss_size uint64
ss_flags int32
pad_cgo_0 [4]byte
}
type sigcontext struct {
sc_rdi int64
sc_rsi int64
sc_rdx int64
sc_rcx int64
sc_r8 int64
sc_r9 int64
sc_r10 int64
sc_r11 int64
sc_r12 int64
sc_r13 int64
sc_r14 int64
sc_r15 int64
sc_rbp int64
sc_rbx int64
sc_rax int64
sc_gs int64
sc_fs int64
sc_es int64
sc_ds int64
sc_trapno int64
sc_err int64
sc_rip int64
sc_cs int64
sc_rflags int64
sc_rsp int64
sc_ss int64
sc_rdi uint64
sc_rsi uint64
sc_rdx uint64
sc_rcx uint64
sc_r8 uint64
sc_r9 uint64
sc_r10 uint64
sc_r11 uint64
sc_r12 uint64
sc_r13 uint64
sc_r14 uint64
sc_r15 uint64
sc_rbp uint64
sc_rbx uint64
sc_rax uint64
sc_gs uint64
sc_fs uint64
sc_es uint64
sc_ds uint64
sc_trapno uint64
sc_err uint64
sc_rip uint64
sc_cs uint64
sc_rflags uint64
sc_rsp uint64
sc_ss uint64
sc_fpstate unsafe.Pointer
__sc_unused int32
sc_mask int32
@ -138,7 +138,7 @@ type siginfo struct {
}
type stackt struct {
ss_sp *byte
ss_sp uintptr
ss_size uint64
ss_flags int32
pad_cgo_0 [4]byte
@ -149,11 +149,23 @@ type timespec struct {
tv_nsec int64
}
func (ts *timespec) set_sec(x int32) {
ts.tv_sec = int64(x)
}
func (ts *timespec) set_nsec(x int32) {
ts.tv_nsec = int64(x)
}
type timeval struct {
tv_sec int64
tv_usec int64
}
func (tv *timeval) set_usec(x int32) {
tv.tv_usec = int64(x)
}
type itimerval struct {
it_interval timeval
it_value timeval

235
src/runtime/os1_openbsd.go Normal file
View File

@ -0,0 +1,235 @@
// Copyright 2011 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 "unsafe"
const (
ESRCH = 3
EAGAIN = 35
EWOULDBLOCK = EAGAIN
ENOTSUP = 91
// From OpenBSD's sys/time.h
CLOCK_REALTIME = 0
CLOCK_VIRTUAL = 1
CLOCK_PROF = 2
CLOCK_MONOTONIC = 3
)
var sigset_none = uint32(0)
var sigset_all = ^sigset_none
// From OpenBSD's <sys/sysctl.h>
const (
CTL_HW = 6
HW_NCPU = 3
)
func getncpu() int32 {
mib := [2]uint32{CTL_HW, HW_NCPU}
out := uint32(0)
nout := unsafe.Sizeof(out)
// Fetch hw.ncpu via sysctl.
ret := sysctl(&mib[0], 2, (*byte)(unsafe.Pointer(&out)), &nout, nil, 0)
if ret >= 0 {
return int32(out)
}
return 1
}
//go:nosplit
func semacreate() uintptr {
return 1
}
//go:nosplit
func semasleep(ns int64) int32 {
_g_ := getg()
// Compute sleep deadline.
var tsp *timespec
if ns >= 0 {
var ts timespec
var nsec int32
ns += nanotime()
ts.set_sec(timediv(ns, 1000000000, &nsec))
ts.set_nsec(nsec)
tsp = &ts
}
for {
// spin-mutex lock
for {
if xchg(&_g_.m.waitsemalock, 1) == 0 {
break
}
osyield()
}
if _g_.m.waitsemacount != 0 {
// semaphore is available.
_g_.m.waitsemacount--
// spin-mutex unlock
atomicstore(&_g_.m.waitsemalock, 0)
return 0 // semaphore acquired
}
// sleep until semaphore != 0 or timeout.
// thrsleep unlocks m.waitsemalock.
ret := thrsleep((uintptr)(unsafe.Pointer(&_g_.m.waitsemacount)), CLOCK_MONOTONIC, tsp, (uintptr)(unsafe.Pointer(&_g_.m.waitsemalock)), (*int32)(unsafe.Pointer(&_g_.m.waitsemacount)))
if ret == EWOULDBLOCK {
return -1
}
}
}
//go:nosplit
func semawakeup(mp *m) {
// spin-mutex lock
for {
if xchg(&mp.waitsemalock, 1) == 0 {
break
}
osyield()
}
mp.waitsemacount++
ret := thrwakeup(uintptr(unsafe.Pointer(&mp.waitsemacount)), 1)
if ret != 0 && ret != ESRCH {
// semawakeup can be called on signal stack.
systemstack(func() {
print("thrwakeup addr=", &mp.waitsemacount, " sem=", mp.waitsemacount, " ret=", ret, "\n")
})
}
// spin-mutex unlock
atomicstore(&mp.waitsemalock, 0)
}
func newosproc(mp *m, stk unsafe.Pointer) {
if false {
print("newosproc stk=", stk, " m=", mp, " g=", mp.g0, " id=", mp.id, "/", int32(mp.tls[0]), " ostk=", &mp, "\n")
}
mp.tls[0] = uintptr(mp.id) // so 386 asm can find it
param := tforkt{
tf_tcb: unsafe.Pointer(&mp.tls[0]),
tf_tid: (*int32)(unsafe.Pointer(&mp.procid)),
tf_stack: uintptr(stk),
}
oset := sigprocmask(_SIG_SETMASK, sigset_all)
ret := tfork(&param, unsafe.Sizeof(param), mp, mp.g0, funcPC(mstart))
sigprocmask(_SIG_SETMASK, oset)
if ret < 0 {
print("runtime: failed to create new OS thread (have ", mcount()-1, " already; errno=", -ret, ")\n")
if ret == -ENOTSUP {
print("runtime: is kern.rthreads disabled?\n")
}
gothrow("runtime.newosproc")
}
}
func osinit() {
ncpu = getncpu()
}
var urandom_data [_HashRandomBytes]byte
var urandom_dev = []byte("/dev/urandom\x00")
//go:nosplit
func get_random_data(rnd *unsafe.Pointer, rnd_len *int32) {
fd := open(&urandom_dev[0], 0 /* O_RDONLY */, 0)
if read(fd, unsafe.Pointer(&urandom_data), _HashRandomBytes) == _HashRandomBytes {
*rnd = unsafe.Pointer(&urandom_data[0])
*rnd_len = _HashRandomBytes
} else {
*rnd = nil
*rnd_len = 0
}
close(fd)
}
func goenvs() {
goenvs_unix()
}
// Called to initialize a new m (including the bootstrap m).
// Called on the parent thread (main thread in case of bootstrap), can allocate memory.
func mpreinit(mp *m) {
mp.gsignal = malg(32 * 1024)
mp.gsignal.m = mp
}
// Called to initialize a new m (including the bootstrap m).
// Called on the new thread, can not allocate memory.
func minit() {
_g_ := getg()
// m.procid is a uint64, but tfork writes an int32. Fix it up.
_g_.m.procid = uint64(*(*int32)(unsafe.Pointer(&_g_.m.procid)))
// Initialize signal handling
signalstack((*byte)(unsafe.Pointer(_g_.m.gsignal.stack.lo)), 32*1024)
sigprocmask(_SIG_SETMASK, sigset_none)
}
// Called from dropm to undo the effect of an minit.
func unminit() {
signalstack(nil, 0)
}
func memlimit() uintptr {
return 0
}
func sigtramp()
type sigactiont struct {
sa_sigaction uintptr
sa_mask uint32
sa_flags int32
}
func setsig(i int32, fn uintptr, restart bool) {
var sa sigactiont
sa.sa_flags = _SA_SIGINFO | _SA_ONSTACK
if restart {
sa.sa_flags |= _SA_RESTART
}
sa.sa_mask = sigset_all
if fn == funcPC(sighandler) {
fn = funcPC(sigtramp)
}
sa.sa_sigaction = fn
sigaction(i, &sa, nil)
}
func getsig(i int32) uintptr {
var sa sigactiont
sigaction(i, nil, &sa)
if sa.sa_sigaction == funcPC(sigtramp) {
return funcPC(sighandler)
}
return sa.sa_sigaction
}
func signalstack(p *byte, n int32) {
var st stackt
st.ss_sp = uintptr(unsafe.Pointer(p))
st.ss_size = uint64(n)
st.ss_flags = 0
if p == nil {
st.ss_flags = _SS_DISABLE
}
sigaltstack(&st, nil)
}
func unblocksignals() {
sigprocmask(_SIG_SETMASK, sigset_none)
}

14
src/runtime/os2_openbsd.go Normal file
View File

@ -0,0 +1,14 @@
// Copyright 2010 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
const (
_SS_DISABLE = 4
_SIG_BLOCK = 1
_SIG_UNBLOCK = 2
_SIG_SETMASK = 3
_NSIG = 33
_SI_USER = 0
)

309
src/runtime/os_openbsd.c
View File

@ -1,309 +0,0 @@
// Copyright 2011 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.
#include "runtime.h"
#include "defs_GOOS_GOARCH.h"
#include "os_GOOS.h"
#include "signal_unix.h"
#include "stack.h"
#include "textflag.h"
enum
{
ESRCH = 3,
EAGAIN = 35,
EWOULDBLOCK = EAGAIN,
ENOTSUP = 91,
// From OpenBSD's sys/time.h
CLOCK_REALTIME = 0,
CLOCK_VIRTUAL = 1,
CLOCK_PROF = 2,
CLOCK_MONOTONIC = 3
};
extern SigTab runtime·sigtab[];
static Sigset sigset_none;
static Sigset sigset_all = ~(Sigset)0;
extern int32 runtime·tfork(TforkT *param, uintptr psize, M *mp, G *gp, void (*fn)(void));
extern int32 runtime·thrsleep(void *ident, int32 clock_id, void *tsp, void *lock, const int32 *abort);
extern int32 runtime·thrwakeup(void *ident, int32 n);
// From OpenBSD's <sys/sysctl.h>
#define CTL_HW 6
#define HW_NCPU 3
static int32
getncpu(void)
{
uint32 mib[2];
uint32 out;
int32 ret;
uintptr nout;
// Fetch hw.ncpu via sysctl.
mib[0] = CTL_HW;
mib[1] = HW_NCPU;
nout = sizeof out;
out = 0;
ret = runtime·sysctl(mib, 2, (byte*)&out, &nout, nil, 0);
if(ret >= 0)
return out;
else
return 1;
}
#pragma textflag NOSPLIT
uintptr
runtime·semacreate(void)
{
return 1;
}
#pragma textflag NOSPLIT
int32
runtime·semasleep(int64 ns)
{
Timespec ts, *tsp = nil;
// Compute sleep deadline.
if(ns >= 0) {
int32 nsec;
ns += runtime·nanotime();
ts.tv_sec = runtime·timediv(ns, 1000000000, &nsec);
ts.tv_nsec = nsec; // tv_nsec is int64 on amd64
tsp = &ts;
}
for(;;) {
int32 ret;
// spin-mutex lock
while(runtime·xchg(&g->m->waitsemalock, 1))
runtime·osyield();
if(g->m->waitsemacount != 0) {
// semaphore is available.
g->m->waitsemacount--;
// spin-mutex unlock
runtime·atomicstore(&g->m->waitsemalock, 0);
return 0; // semaphore acquired
}
// sleep until semaphore != 0 or timeout.
// thrsleep unlocks m->waitsemalock.
ret = runtime·thrsleep(&g->m->waitsemacount, CLOCK_MONOTONIC, tsp, &g->m->waitsemalock, (int32 *)&g->m->waitsemacount);
if(ret == EWOULDBLOCK)
return -1;
}
}
static void badsemawakeup(void);
#pragma textflag NOSPLIT
void
runtime·semawakeup(M *mp)
{
uint32 ret;
void *oldptr;
uint32 oldscalar;
void (*fn)(void);
// spin-mutex lock
while(runtime·xchg(&mp->waitsemalock, 1))
runtime·osyield();
mp->waitsemacount++;
ret = runtime·thrwakeup(&mp->waitsemacount, 1);
if(ret != 0 && ret != ESRCH) {
// semawakeup can be called on signal stack.
// Save old ptrarg/scalararg so we can restore them.
oldptr = g->m->ptrarg[0];
oldscalar = g->m->scalararg[0];
g->m->ptrarg[0] = mp;
g->m->scalararg[0] = ret;
fn = badsemawakeup;
if(g == g->m->gsignal)
fn();
else
runtime·onM(&fn);
g->m->ptrarg[0] = oldptr;
g->m->scalararg[0] = oldscalar;
}
// spin-mutex unlock
runtime·atomicstore(&mp->waitsemalock, 0);
}
static void
badsemawakeup(void)
{
M *mp;
int32 ret;
mp = g->m->ptrarg[0];
g->m->ptrarg[0] = nil;
ret = g->m->scalararg[0];
g->m->scalararg[0] = 0;
runtime·printf("thrwakeup addr=%p sem=%d ret=%d\n", &mp->waitsemacount, mp->waitsemacount, ret);
}
void
runtime·newosproc(M *mp, void *stk)
{
TforkT param;
Sigset oset;
int32 ret;
if(0) {
runtime·printf(
"newosproc stk=%p m=%p g=%p id=%d/%d ostk=%p\n",
stk, mp, mp->g0, mp->id, (int32)mp->tls[0], &mp);
}
mp->tls[0] = mp->id; // so 386 asm can find it
param.tf_tcb = (byte*)&mp->tls[0];
param.tf_tid = (int32*)&mp->procid;
param.tf_stack = stk;
oset = runtime·sigprocmask(SIG_SETMASK, sigset_all);
ret = runtime·tfork(&param, sizeof(param), mp, mp->g0, runtime·mstart);
runtime·sigprocmask(SIG_SETMASK, oset);
if(ret < 0) {
runtime·printf("runtime: failed to create new OS thread (have %d already; errno=%d)\n", runtime·mcount() - 1, -ret);
if (ret == -ENOTSUP)
runtime·printf("runtime: is kern.rthreads disabled?\n");
runtime·throw("runtime.newosproc");
}
}
void
runtime·osinit(void)
{
runtime·ncpu = getncpu();
}
#pragma textflag NOSPLIT
void
runtime·get_random_data(byte **rnd, int32 *rnd_len)
{
#pragma dataflag NOPTR
static byte urandom_data[HashRandomBytes];
int32 fd;
fd = runtime·open("/dev/urandom", 0 /* O_RDONLY */, 0);
if(runtime·read(fd, urandom_data, HashRandomBytes) == HashRandomBytes) {
*rnd = urandom_data;
*rnd_len = HashRandomBytes;
} else {
*rnd = nil;
*rnd_len = 0;
}
runtime·close(fd);
}
void
runtime·goenvs(void)
{
runtime·goenvs_unix();
}
// Called to initialize a new m (including the bootstrap m).
// Called on the parent thread (main thread in case of bootstrap), can allocate memory.
void
runtime·mpreinit(M *mp)
{
mp->gsignal = runtime·malg(32*1024);
mp->gsignal->m = mp;
}
// Called to initialize a new m (including the bootstrap m).
// Called on the new thread, can not allocate memory.
void
runtime·minit(void)
{
// Initialize signal handling
runtime·signalstack((byte*)g->m->gsignal->stack.lo, 32*1024);
runtime·sigprocmask(SIG_SETMASK, sigset_none);
}
// Called from dropm to undo the effect of an minit.
void
runtime·unminit(void)
{
runtime·signalstack(nil, 0);
}
uintptr
runtime·memlimit(void)
{
return 0;
}
extern void runtime·sigtramp(void);
typedef struct sigaction {
union {
void (*__sa_handler)(int32);
void (*__sa_sigaction)(int32, Siginfo*, void *);
} __sigaction_u; /* signal handler */
uint32 sa_mask; /* signal mask to apply */
int32 sa_flags; /* see signal options below */
} SigactionT;
void
runtime·setsig(int32 i, GoSighandler *fn, bool restart)
{
SigactionT sa;
runtime·memclr((byte*)&sa, sizeof sa);
sa.sa_flags = SA_SIGINFO|SA_ONSTACK;
if(restart)
sa.sa_flags |= SA_RESTART;
sa.sa_mask = ~0U;
if(fn == runtime·sighandler)
fn = (void*)runtime·sigtramp;
sa.__sigaction_u.__sa_sigaction = (void*)fn;
runtime·sigaction(i, &sa, nil);
}
GoSighandler*
runtime·getsig(int32 i)
{
SigactionT sa;
runtime·memclr((byte*)&sa, sizeof sa);
runtime·sigaction(i, nil, &sa);
if((void*)sa.__sigaction_u.__sa_sigaction == runtime·sigtramp)
return runtime·sighandler;
return (void*)sa.__sigaction_u.__sa_sigaction;
}
void
runtime·signalstack(byte *p, int32 n)
{
StackT st;
st.ss_sp = (void*)p;
st.ss_size = n;
st.ss_flags = 0;
if(p == nil)
st.ss_flags = SS_DISABLE;
runtime·sigaltstack(&st, nil);
}
void
runtime·unblocksignals(void)
{
runtime·sigprocmask(SIG_SETMASK, sigset_none);
}
#pragma textflag NOSPLIT
int8*
runtime·signame(int32 sig)
{
return runtime·sigtab[sig].name;
}

30
src/runtime/os_openbsd.go
View File

@ -4,14 +4,30 @@
package runtime
import "unsafe"
//go:noescape
func setitimer(mode int32, new, old *itimerval)
func setitimer(mode int32, new, old unsafe.Pointer)
func sigaction(sig int32, new, old unsafe.Pointer)
func sigaltstack(new, old unsafe.Pointer)
//go:noescape
func sigaction(sig int32, new, old *sigactiont)
//go:noescape
func sigaltstack(new, old *stackt)
//go:noescape
func sigprocmask(mode int32, new uint32) uint32
//go:noescape
func sysctl(mib *uint32, miblen uint32, out *byte, size *uintptr, dst *byte, ndst uintptr) int32
func raise(sig int32)
func tfork(param unsafe.Pointer, psize uintptr, mm, gg, fn unsafe.Pointer) int32
func thrsleep(ident unsafe.Pointer, clock_id int32, tsp, lock, abort unsafe.Pointer) int32
func thrwakeup(ident unsafe.Pointer, n int32) int32
//go:noescape
func tfork(param *tforkt, psize uintptr, mm *m, gg *g, fn uintptr) int32
//go:noescape
func thrsleep(ident uintptr, clock_id int32, tsp *timespec, lock uintptr, abort *int32) int32
//go:noescape
func thrwakeup(ident uintptr, n int32) int32
func osyield()

26
src/runtime/os_openbsd.h
View File

@ -1,26 +0,0 @@
// Copyright 2010 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.
typedef byte* kevent_udata;
struct sigaction;
void runtime·sigpanic(void);
void runtime·setitimer(int32, Itimerval*, Itimerval*);
void runtime·sigaction(int32, struct sigaction*, struct sigaction*);
void runtime·sigaltstack(SigaltstackT*, SigaltstackT*);
Sigset runtime·sigprocmask(int32, Sigset);
void runtime·unblocksignals(void);
int32 runtime·sysctl(uint32*, uint32, byte*, uintptr*, byte*, uintptr);
enum {
SS_DISABLE = 4,
SIG_BLOCK = 1,
SIG_UNBLOCK = 2,
SIG_SETMASK = 3,
NSIG = 33,
SI_USER = 0,
};

46
src/runtime/signal_openbsd.go Normal file
View File

@ -0,0 +1,46 @@
// 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.
package runtime
type sigTabT struct {
flags int32
name string
}
var sigtable = [...]sigTabT{
/* 0 */ {0, "SIGNONE: no trap"},
/* 1 */ {_SigNotify + _SigKill, "SIGHUP: terminal line hangup"},
/* 2 */ {_SigNotify + _SigKill, "SIGINT: interrupt"},
/* 3 */ {_SigNotify + _SigThrow, "SIGQUIT: quit"},
/* 4 */ {_SigThrow, "SIGILL: illegal instruction"},
/* 5 */ {_SigThrow, "SIGTRAP: trace trap"},
/* 6 */ {_SigNotify + _SigThrow, "SIGABRT: abort"},
/* 7 */ {_SigThrow, "SIGEMT: emulate instruction executed"},
/* 8 */ {_SigPanic, "SIGFPE: floating-point exception"},
/* 9 */ {0, "SIGKILL: kill"},
/* 10 */ {_SigPanic, "SIGBUS: bus error"},
/* 11 */ {_SigPanic, "SIGSEGV: segmentation violation"},
/* 12 */ {_SigThrow, "SIGSYS: bad system call"},
/* 13 */ {_SigNotify, "SIGPIPE: write to broken pipe"},
/* 14 */ {_SigNotify, "SIGALRM: alarm clock"},
/* 15 */ {_SigNotify + _SigKill, "SIGTERM: termination"},
/* 16 */ {_SigNotify, "SIGURG: urgent condition on socket"},
/* 17 */ {0, "SIGSTOP: stop"},
/* 18 */ {_SigNotify + _SigDefault, "SIGTSTP: keyboard stop"},
/* 19 */ {0, "SIGCONT: continue after stop"},
/* 20 */ {_SigNotify, "SIGCHLD: child status has changed"},
/* 21 */ {_SigNotify + _SigDefault, "SIGTTIN: background read from tty"},
/* 22 */ {_SigNotify + _SigDefault, "SIGTTOU: background write to tty"},
/* 23 */ {_SigNotify, "SIGIO: i/o now possible"},
/* 24 */ {_SigNotify, "SIGXCPU: cpu limit exceeded"},
/* 25 */ {_SigNotify, "SIGXFSZ: file size limit exceeded"},
/* 26 */ {_SigNotify, "SIGVTALRM: virtual alarm clock"},
/* 27 */ {_SigNotify, "SIGPROF: profiling alarm clock"},
/* 28 */ {_SigNotify, "SIGWINCH: window size change"},
/* 29 */ {_SigNotify, "SIGINFO: status request from keyboard"},
/* 30 */ {_SigNotify, "SIGUSR1: user-defined signal 1"},
/* 31 */ {_SigNotify, "SIGUSR2: user-defined signal 2"},
/* 32 */ {_SigNotify, "SIGTHR: reserved"},
}

49
src/runtime/signal_openbsd_amd64.go Normal file
View File

@ -0,0 +1,49 @@
// Copyright 2013 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 "unsafe"
type sigctxt struct {
info *siginfo
ctxt unsafe.Pointer
}
func (c *sigctxt) regs() *sigcontext {
return (*sigcontext)(c.ctxt)
}
func (c *sigctxt) rax() uint64 { return c.regs().sc_rax }
func (c *sigctxt) rbx() uint64 { return c.regs().sc_rbx }
func (c *sigctxt) rcx() uint64 { return c.regs().sc_rcx }
func (c *sigctxt) rdx() uint64 { return c.regs().sc_rdx }
func (c *sigctxt) rdi() uint64 { return c.regs().sc_rdi }
func (c *sigctxt) rsi() uint64 { return c.regs().sc_rsi }
func (c *sigctxt) rbp() uint64 { return c.regs().sc_rbp }
func (c *sigctxt) rsp() uint64 { return c.regs().sc_rsp }
func (c *sigctxt) r8() uint64 { return c.regs().sc_r8 }
func (c *sigctxt) r9() uint64 { return c.regs().sc_r9 }
func (c *sigctxt) r10() uint64 { return c.regs().sc_r10 }
func (c *sigctxt) r11() uint64 { return c.regs().sc_r11 }
func (c *sigctxt) r12() uint64 { return c.regs().sc_r12 }
func (c *sigctxt) r13() uint64 { return c.regs().sc_r13 }
func (c *sigctxt) r14() uint64 { return c.regs().sc_r14 }
func (c *sigctxt) r15() uint64 { return c.regs().sc_r15 }
func (c *sigctxt) rip() uint64 { return c.regs().sc_rip }
func (c *sigctxt) rflags() uint64 { return c.regs().sc_rflags }
func (c *sigctxt) cs() uint64 { return c.regs().sc_cs }
func (c *sigctxt) fs() uint64 { return c.regs().sc_fs }
func (c *sigctxt) gs() uint64 { return c.regs().sc_gs }
func (c *sigctxt) sigcode() uint64 { return uint64(c.info.si_code) }
func (c *sigctxt) sigaddr() uint64 {
return *(*uint64)(add(unsafe.Pointer(c.info), 16))
}
func (c *sigctxt) set_rip(x uint64) { c.regs().sc_rip = x }
func (c *sigctxt) set_rsp(x uint64) { c.regs().sc_rsp = x }
func (c *sigctxt) set_sigcode(x uint64) { c.info.si_code = int32(x) }
func (c *sigctxt) set_sigaddr(x uint64) {
*(*uint64)(add(unsafe.Pointer(c.info), 16)) = x
}

31
src/runtime/signal_openbsd_amd64.h
View File

@ -1,31 +0,0 @@
// Copyright 2013 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.
#define SIG_REGS(ctxt) (*(Sigcontext*)(ctxt))
#define SIG_RAX(info, ctxt) (SIG_REGS(ctxt).sc_rax)
#define SIG_RBX(info, ctxt) (SIG_REGS(ctxt).sc_rbx)
#define SIG_RCX(info, ctxt) (SIG_REGS(ctxt).sc_rcx)
#define SIG_RDX(info, ctxt) (SIG_REGS(ctxt).sc_rdx)
#define SIG_RDI(info, ctxt) (SIG_REGS(ctxt).sc_rdi)
#define SIG_RSI(info, ctxt) (SIG_REGS(ctxt).sc_rsi)
#define SIG_RBP(info, ctxt) (SIG_REGS(ctxt).sc_rbp)
#define SIG_RSP(info, ctxt) (SIG_REGS(ctxt).sc_rsp)
#define SIG_R8(info, ctxt) (SIG_REGS(ctxt).sc_r8)
#define SIG_R9(info, ctxt) (SIG_REGS(ctxt).sc_r9)
#define SIG_R10(info, ctxt) (SIG_REGS(ctxt).sc_r10)
#define SIG_R11(info, ctxt) (SIG_REGS(ctxt).sc_r11)
#define SIG_R12(info, ctxt) (SIG_REGS(ctxt).sc_r12)
#define SIG_R13(info, ctxt) (SIG_REGS(ctxt).sc_r13)
#define SIG_R14(info, ctxt) (SIG_REGS(ctxt).sc_r14)
#define SIG_R15(info, ctxt) (SIG_REGS(ctxt).sc_r15)
#define SIG_RIP(info, ctxt) (SIG_REGS(ctxt).sc_rip)
#define SIG_RFLAGS(info, ctxt) (SIG_REGS(ctxt).sc_rflags)
#define SIG_CS(info, ctxt) (SIG_REGS(ctxt).sc_cs)
#define SIG_FS(info, ctxt) (SIG_REGS(ctxt).sc_fs)
#define SIG_GS(info, ctxt) (SIG_REGS(ctxt).sc_gs)
#define SIG_CODE0(info, ctxt) ((info)->si_code)
#define SIG_CODE1(info, ctxt) (*(uintptr*)((byte*)(info) + 16))

54
src/runtime/signals_openbsd.h
View File

@ -1,54 +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.
#include "textflag.h"
#define N SigNotify
#define K SigKill
#define T SigThrow
#define P SigPanic
#define D SigDefault
#pragma dataflag NOPTR
SigTab runtime·sigtab[] = {
/* 0 */ 0, "SIGNONE: no trap",
/* 1 */ N+K, "SIGHUP: terminal line hangup",
/* 2 */ N+K, "SIGINT: interrupt",
/* 3 */ N+T, "SIGQUIT: quit",
/* 4 */ T, "SIGILL: illegal instruction",
/* 5 */ T, "SIGTRAP: trace trap",
/* 6 */ N+T, "SIGABRT: abort",
/* 7 */ T, "SIGEMT: emulate instruction executed",
/* 8 */ P, "SIGFPE: floating-point exception",
/* 9 */ 0, "SIGKILL: kill",
/* 10 */ P, "SIGBUS: bus error",
/* 11 */ P, "SIGSEGV: segmentation violation",
/* 12 */ T, "SIGSYS: bad system call",
/* 13 */ N, "SIGPIPE: write to broken pipe",
/* 14 */ N, "SIGALRM: alarm clock",
/* 15 */ N+K, "SIGTERM: termination",
/* 16 */ N, "SIGURG: urgent condition on socket",
/* 17 */ 0, "SIGSTOP: stop",
/* 18 */ N+D, "SIGTSTP: keyboard stop",
/* 19 */ 0, "SIGCONT: continue after stop",
/* 20 */ N, "SIGCHLD: child status has changed",
/* 21 */ N+D, "SIGTTIN: background read from tty",
/* 22 */ N+D, "SIGTTOU: background write to tty",
/* 23 */ N, "SIGIO: i/o now possible",
/* 24 */ N, "SIGXCPU: cpu limit exceeded",
/* 25 */ N, "SIGXFSZ: file size limit exceeded",
/* 26 */ N, "SIGVTALRM: virtual alarm clock",
/* 27 */ N, "SIGPROF: profiling alarm clock",
/* 28 */ N, "SIGWINCH: window size change",
/* 29 */ N, "SIGINFO: status request from keyboard",
/* 30 */ N, "SIGUSR1: user-defined signal 1",
/* 31 */ N, "SIGUSR2: user-defined signal 2",
/* 32 */ N, "SIGTHR: reserved",
};
#undef N
#undef K
#undef T
#undef P
#undef D