runtime: switch runtime to libc for openbsd/386

Use libc rather than performing direct system calls for the runtime on
openbsd/386.

Updates #36435

Change-Id: I0cd65368bc824c81f5f98ea24e4f82db5468b170
Reviewed-on: https://go-review.googlesource.com/c/go/+/287653
Trust: Joel Sing <joel@sing.id.au>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
This commit is contained in:
Joel Sing 2021-01-28 23:43:33 +11:00
parent 0bbfc5c31e
commit faff49aae6
5 changed files with 364 additions and 278 deletions

View file

@ -32,6 +32,11 @@ const (
_PTHREAD_CREATE_DETACHED = 0x1 _PTHREAD_CREATE_DETACHED = 0x1
_F_SETFD = 0x2
_F_GETFL = 0x3
_F_SETFL = 0x4
_FD_CLOEXEC = 0x1
_SIGHUP = 0x1 _SIGHUP = 0x1
_SIGINT = 0x2 _SIGINT = 0x2
_SIGQUIT = 0x3 _SIGQUIT = 0x3

View file

@ -2,8 +2,8 @@
// Use of this source code is governed by a BSD-style // Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file. // license that can be found in the LICENSE file.
//go:build openbsd && !amd64 && !arm64 //go:build openbsd && !386 && !amd64 && !arm64
// +build openbsd,!amd64,!arm64 // +build openbsd,!386,!amd64,!arm64
package runtime package runtime

View file

@ -1303,7 +1303,7 @@ func usesLibcall() bool {
case "aix", "darwin", "illumos", "ios", "solaris", "windows": case "aix", "darwin", "illumos", "ios", "solaris", "windows":
return true return true
case "openbsd": case "openbsd":
return GOARCH == "amd64" || GOARCH == "arm64" return GOARCH == "386" || GOARCH == "amd64" || GOARCH == "arm64"
} }
return false return false
} }

View file

@ -2,8 +2,8 @@
// Use of this source code is governed by a BSD-style // Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file. // license that can be found in the LICENSE file.
//go:build (openbsd && amd64) || (openbsd && arm64) //go:build (openbsd && 386) || (openbsd && amd64) || (openbsd && arm64)
// +build openbsd,amd64 openbsd,arm64 // +build openbsd,386 openbsd,amd64 openbsd,arm64
package runtime package runtime

View file

@ -169,6 +169,21 @@ TEXT runtime·pthread_create_trampoline(SB),NOSPLIT,$0
POPL BP POPL BP
RET RET
TEXT runtime·thrkill_trampoline(SB),NOSPLIT,$0
PUSHL BP
MOVL SP, BP
SUBL $12, SP
MOVL 20(SP), DX // pointer to args
MOVL 0(DX), AX
MOVL 4(DX), BX
MOVL AX, 0(SP) // arg 1 - tid
MOVL BX, 4(SP) // arg 2 - signal
MOVL $0, 8(SP) // arg 3 - tcb
CALL libc_thrkill(SB)
MOVL BP, SP
POPL BP
RET
TEXT runtime·thrsleep_trampoline(SB),NOSPLIT,$0 TEXT runtime·thrsleep_trampoline(SB),NOSPLIT,$0
PUSHL BP PUSHL BP
MOVL SP, BP MOVL SP, BP
@ -203,6 +218,42 @@ TEXT runtime·thrwakeup_trampoline(SB),NOSPLIT,$0
POPL BP POPL BP
RET RET
TEXT runtime·exit_trampoline(SB),NOSPLIT,$0
PUSHL BP
MOVL SP, BP
SUBL $4, SP
MOVL 12(SP), DX // pointer to args
MOVL 0(DX), AX
MOVL AX, 0(SP) // arg 1 - status
CALL libc_exit(SB)
MOVL $0xf1, 0xf1 // crash on failure
MOVL BP, SP
POPL BP
RET
TEXT runtime·getthrid_trampoline(SB),NOSPLIT,$0
PUSHL BP
CALL libc_getthrid(SB)
NOP SP // tell vet SP changed - stop checking offsets
MOVL 8(SP), DX // pointer to return value
MOVL AX, 0(DX)
POPL BP
RET
TEXT runtime·raiseproc_trampoline(SB),NOSPLIT,$0
PUSHL BP
MOVL SP, BP
SUBL $8, SP
MOVL 16(SP), DX
MOVL 0(DX), BX
CALL libc_getpid(SB)
MOVL AX, 0(SP) // arg 1 - pid
MOVL BX, 4(SP) // arg 2 - signal
CALL libc_kill(SB)
MOVL BP, SP
POPL BP
RET
TEXT runtime·sched_yield_trampoline(SB),NOSPLIT,$0 TEXT runtime·sched_yield_trampoline(SB),NOSPLIT,$0
PUSHL BP PUSHL BP
MOVL SP, BP MOVL SP, BP
@ -211,308 +262,338 @@ TEXT runtime·sched_yield_trampoline(SB),NOSPLIT,$0
POPL BP POPL BP
RET RET
// Exit the entire program (like C exit) TEXT runtime·mmap_trampoline(SB),NOSPLIT,$0
TEXT runtime·exit(SB),NOSPLIT,$-4 PUSHL BP
MOVL $1, AX MOVL SP, BP
INT $0x80 SUBL $32, SP
MOVL $0xf1, 0xf1 // crash MOVL 40(SP), DX // pointer to args
RET MOVL 0(DX), AX
MOVL 4(DX), BX
// func exitThread(wait *uint32) MOVL 8(DX), CX
TEXT runtime·exitThread(SB),NOSPLIT,$0-4 MOVL AX, 0(SP) // arg 1 - addr
MOVL $302, AX // sys___threxit MOVL BX, 4(SP) // arg 2 - len
INT $0x80 MOVL CX, 8(SP) // arg 3 - prot
MOVL $0xf1, 0xf1 // crash MOVL 12(DX), AX
JMP 0(PC) MOVL 16(DX), BX
MOVL 20(DX), CX
TEXT runtime·open(SB),NOSPLIT,$-4 MOVL AX, 12(SP) // arg 4 - flags
MOVL $5, AX MOVL BX, 16(SP) // arg 5 - fid
INT $0x80 MOVL $0, 20(SP) // pad
JAE 2(PC) MOVL CX, 24(SP) // arg 6 - offset (low 32 bits)
MOVL $-1, AX MOVL $0, 28(SP) // offset (high 32 bits)
MOVL AX, ret+12(FP) CALL libc_mmap(SB)
RET MOVL $0, BX
CMPL AX, $-1
TEXT runtime·closefd(SB),NOSPLIT,$-4 JNE ok
MOVL $6, AX CALL libc_errno(SB)
INT $0x80 MOVL (AX), BX
JAE 2(PC)
MOVL $-1, AX
MOVL AX, ret+4(FP)
RET
TEXT runtime·read(SB),NOSPLIT,$-4
MOVL $3, AX
INT $0x80
JAE 2(PC)
NEGL AX // caller expects negative errno
MOVL AX, ret+12(FP)
RET
// func pipe() (r, w int32, errno int32)
TEXT runtime·pipe(SB),NOSPLIT,$8-12
MOVL $263, AX
LEAL r+0(FP), BX
MOVL BX, 4(SP)
INT $0x80
MOVL AX, errno+8(FP)
RET
// func pipe2(flags int32) (r, w int32, errno int32)
TEXT runtime·pipe2(SB),NOSPLIT,$12-16
MOVL $101, AX
LEAL r+4(FP), BX
MOVL BX, 4(SP)
MOVL flags+0(FP), BX
MOVL BX, 8(SP)
INT $0x80
MOVL AX, errno+12(FP)
RET
TEXT runtime·write1(SB),NOSPLIT,$-4
MOVL $4, AX // sys_write
INT $0x80
JAE 2(PC)
NEGL AX // caller expects negative errno
MOVL AX, ret+12(FP)
RET
TEXT runtime·usleep(SB),NOSPLIT,$24
MOVL $0, DX
MOVL usec+0(FP), AX
MOVL $1000000, CX
DIVL CX
MOVL AX, 12(SP) // tv_sec - l32
MOVL $0, 16(SP) // tv_sec - h32
MOVL $1000, AX
MULL DX
MOVL AX, 20(SP) // tv_nsec
MOVL $0, 0(SP)
LEAL 12(SP), AX
MOVL AX, 4(SP) // arg 1 - rqtp
MOVL $0, 8(SP) // arg 2 - rmtp
MOVL $91, AX // sys_nanosleep
INT $0x80
RET
TEXT runtime·getthrid(SB),NOSPLIT,$0-4
MOVL $299, AX // sys_getthrid
INT $0x80
MOVL AX, ret+0(FP)
RET
TEXT runtime·thrkill(SB),NOSPLIT,$16-8
MOVL $0, 0(SP)
MOVL tid+0(FP), AX
MOVL AX, 4(SP) // arg 1 - tid
MOVL sig+4(FP), AX
MOVL AX, 8(SP) // arg 2 - signum
MOVL $0, 12(SP) // arg 3 - tcb
MOVL $119, AX // sys_thrkill
INT $0x80
RET
TEXT runtime·raiseproc(SB),NOSPLIT,$12
MOVL $20, AX // sys_getpid
INT $0x80
MOVL $0, 0(SP)
MOVL AX, 4(SP) // arg 1 - pid
MOVL sig+0(FP), AX
MOVL AX, 8(SP) // arg 2 - signum
MOVL $122, AX // sys_kill
INT $0x80
RET
TEXT runtime·mmap(SB),NOSPLIT,$36
LEAL addr+0(FP), SI
LEAL 4(SP), DI
CLD
MOVSL // arg 1 - addr
MOVSL // arg 2 - len
MOVSL // arg 3 - prot
MOVSL // arg 4 - flags
MOVSL // arg 5 - fd
MOVL $0, AX MOVL $0, AX
STOSL // arg 6 - pad
MOVSL // arg 7 - offset
MOVL $0, AX // top 32 bits of file offset
STOSL
MOVL $197, AX // sys_mmap
INT $0x80
JAE ok
MOVL $0, p+24(FP)
MOVL AX, err+28(FP)
RET
ok: ok:
MOVL AX, p+24(FP) MOVL 40(SP), DX
MOVL $0, err+28(FP) MOVL AX, 24(DX)
MOVL BX, 28(DX)
MOVL BP, SP
POPL BP
RET RET
TEXT runtime·munmap(SB),NOSPLIT,$-4 TEXT runtime·munmap_trampoline(SB),NOSPLIT,$0
MOVL $73, AX // sys_munmap PUSHL BP
INT $0x80 MOVL SP, BP
JAE 2(PC) SUBL $8, SP
MOVL $0xf1, 0xf1 // crash MOVL 16(SP), DX // pointer to args
MOVL 0(DX), AX
MOVL 4(DX), BX
MOVL AX, 0(SP) // arg 1 - addr
MOVL BX, 4(SP) // arg 2 - len
CALL libc_munmap(SB)
CMPL AX, $-1
JNE 2(PC)
MOVL $0xf1, 0xf1 // crash on failure
MOVL BP, SP
POPL BP
RET RET
TEXT runtime·madvise(SB),NOSPLIT,$-4 TEXT runtime·madvise_trampoline(SB),NOSPLIT,$0
MOVL $75, AX // sys_madvise PUSHL BP
INT $0x80 MOVL SP, BP
JAE 2(PC) SUBL $12, SP
MOVL $-1, AX MOVL 20(SP), DX // pointer to args
MOVL AX, ret+12(FP) MOVL 0(DX), AX
MOVL 4(DX), BX
MOVL 8(DX), CX
MOVL AX, 0(SP) // arg 1 - addr
MOVL BX, 4(SP) // arg 2 - len
MOVL CX, 8(SP) // arg 3 - advice
CALL libc_madvise(SB)
// ignore failure - maybe pages are locked
MOVL BP, SP
POPL BP
RET RET
TEXT runtime·setitimer(SB),NOSPLIT,$-4 TEXT runtime·open_trampoline(SB),NOSPLIT,$0
MOVL $69, AX PUSHL BP
INT $0x80 MOVL SP, BP
SUBL $16, SP
MOVL 24(SP), DX // pointer to args
MOVL 0(DX), AX
MOVL 4(DX), BX
MOVL 8(DX), CX
MOVL AX, 0(SP) // arg 1 - path
MOVL BX, 4(SP) // arg 2 - flags
MOVL CX, 8(SP) // arg 3 - mode
MOVL $0, 12(SP) // vararg
CALL libc_open(SB)
MOVL BP, SP
POPL BP
RET RET
// func walltime() (sec int64, nsec int32) TEXT runtime·close_trampoline(SB),NOSPLIT,$0
TEXT runtime·walltime(SB), NOSPLIT, $32 PUSHL BP
LEAL 12(SP), BX MOVL SP, BP
MOVL $0, 4(SP) // arg 1 - clock_id SUBL $4, SP
MOVL BX, 8(SP) // arg 2 - tp MOVL 12(SP), DX
MOVL $87, AX // sys_clock_gettime MOVL 0(DX), AX
INT $0x80 MOVL AX, 0(SP) // arg 1 - fd
CALL libc_close(SB)
MOVL 12(SP), AX // sec - l32 MOVL BP, SP
MOVL AX, sec_lo+0(FP) POPL BP
MOVL 16(SP), AX // sec - h32
MOVL AX, sec_hi+4(FP)
MOVL 20(SP), BX // nsec
MOVL BX, nsec+8(FP)
RET RET
// int64 nanotime1(void) so really TEXT runtime·read_trampoline(SB),NOSPLIT,$0
// void nanotime1(int64 *nsec) PUSHL BP
TEXT runtime·nanotime1(SB),NOSPLIT,$32 MOVL SP, BP
LEAL 12(SP), BX SUBL $12, SP
MOVL CLOCK_MONOTONIC, 4(SP) // arg 1 - clock_id MOVL 20(SP), DX // pointer to args
MOVL BX, 8(SP) // arg 2 - tp MOVL 0(DX), AX
MOVL $87, AX // sys_clock_gettime MOVL 4(DX), BX
INT $0x80 MOVL 8(DX), CX
MOVL AX, 0(SP) // arg 1 - fd
MOVL 16(SP), CX // sec - h32 MOVL BX, 4(SP) // arg 2 - buf
IMULL $1000000000, CX MOVL CX, 8(SP) // arg 3 - count
CALL libc_read(SB)
MOVL 12(SP), AX // sec - l32 CMPL AX, $-1
MOVL $1000000000, BX JNE noerr
MULL BX // result in dx:ax CALL libc_errno(SB)
MOVL (AX), AX
MOVL 20(SP), BX // nsec NEGL AX // caller expects negative errno
ADDL BX, AX noerr:
ADCL CX, DX // add high bits with carry MOVL BP, SP
POPL BP
MOVL AX, ret_lo+0(FP)
MOVL DX, ret_hi+4(FP)
RET RET
TEXT runtime·sigaction(SB),NOSPLIT,$-4 TEXT runtime·write_trampoline(SB),NOSPLIT,$0
MOVL $46, AX // sys_sigaction PUSHL BP
INT $0x80 MOVL SP, BP
JAE 2(PC) SUBL $12, SP
MOVL $0xf1, 0xf1 // crash MOVL 20(SP), DX // pointer to args
MOVL 0(DX), AX
MOVL 4(DX), BX
MOVL 8(DX), CX
MOVL AX, 0(SP) // arg 1 - fd
MOVL BX, 4(SP) // arg 2 - buf
MOVL CX, 8(SP) // arg 3 - count
CALL libc_write(SB)
CMPL AX, $-1
JNE noerr
CALL libc_errno(SB)
MOVL (AX), AX
NEGL AX // caller expects negative errno
noerr:
MOVL BP, SP
POPL BP
RET RET
TEXT runtime·obsdsigprocmask(SB),NOSPLIT,$-4 TEXT runtime·pipe2_trampoline(SB),NOSPLIT,$0
MOVL $48, AX // sys_sigprocmask PUSHL BP
INT $0x80 MOVL SP, BP
JAE 2(PC) SUBL $8, SP
MOVL $0xf1, 0xf1 // crash MOVL 16(SP), DX // pointer to args
MOVL AX, ret+8(FP) MOVL 0(DX), AX
MOVL 4(DX), BX
MOVL AX, 0(SP) // arg 1 - fds
MOVL BX, 4(SP) // arg 2 - flags
CALL libc_pipe2(SB)
CMPL AX, $-1
JNE noerr
CALL libc_errno(SB)
MOVL (AX), AX
NEGL AX // caller expects negative errno
noerr:
MOVL BP, SP
POPL BP
RET RET
TEXT runtime·sigaltstack(SB),NOSPLIT,$-8 TEXT runtime·setitimer_trampoline(SB),NOSPLIT,$0
MOVL $288, AX // sys_sigaltstack PUSHL BP
MOVL new+0(FP), BX MOVL SP, BP
MOVL old+4(FP), CX SUBL $12, SP
INT $0x80 MOVL 20(SP), DX // pointer to args
CMPL AX, $0xfffff001 MOVL 0(DX), AX
JLS 2(PC) MOVL 4(DX), BX
INT $3 MOVL 8(DX), CX
MOVL AX, 0(SP) // arg 1 - which
MOVL BX, 4(SP) // arg 2 - new
MOVL CX, 8(SP) // arg 3 - old
CALL libc_setitimer(SB)
MOVL BP, SP
POPL BP
RET RET
TEXT set_tcb<>(SB),NOSPLIT,$8 TEXT runtime·usleep_trampoline(SB),NOSPLIT,$0
// adjust for ELF: wants to use -4(GS) for g PUSHL BP
MOVL tlsbase+0(FP), CX MOVL SP, BP
ADDL $4, CX SUBL $4, SP
MOVL $0, 0(SP) // syscall gap MOVL 12(SP), DX // pointer to args
MOVL CX, 4(SP) // arg 1 - tcb MOVL 0(DX), AX
MOVL $329, AX // sys___set_tcb MOVL AX, 0(SP)
INT $0x80 CALL libc_usleep(SB)
JCC 2(PC) MOVL BP, SP
MOVL $0xf1, 0xf1 // crash POPL BP
RET RET
TEXT runtime·sysctl(SB),NOSPLIT,$28 TEXT runtime·sysctl_trampoline(SB),NOSPLIT,$0
LEAL mib+0(FP), SI PUSHL BP
LEAL 4(SP), DI MOVL SP, BP
CLD SUBL $24, SP
MOVSL // arg 1 - name MOVL 32(SP), DX // pointer to args
MOVSL // arg 2 - namelen MOVL 0(DX), AX
MOVSL // arg 3 - oldp MOVL 4(DX), BX
MOVSL // arg 4 - oldlenp MOVL 8(DX), CX
MOVSL // arg 5 - newp MOVL AX, 0(SP) // arg 1 - name
MOVSL // arg 6 - newlen MOVL BX, 4(SP) // arg 2 - namelen
MOVL $202, AX // sys___sysctl MOVL CX, 8(SP) // arg 3 - old
INT $0x80 MOVL 12(DX), AX
JCC 4(PC) MOVL 16(DX), BX
NEGL AX MOVL 20(DX), CX
MOVL AX, ret+24(FP) MOVL AX, 12(SP) // arg 4 - oldlenp
RET MOVL BX, 16(SP) // arg 5 - newp
MOVL $0, AX MOVL CX, 20(SP) // arg 6 - newlen
MOVL AX, ret+24(FP) CALL libc_sysctl(SB)
MOVL BP, SP
POPL BP
RET RET
// int32 runtime·kqueue(void); TEXT runtime·kqueue_trampoline(SB),NOSPLIT,$0
TEXT runtime·kqueue(SB),NOSPLIT,$0 PUSHL BP
MOVL $269, AX MOVL SP, BP
INT $0x80 CALL libc_kqueue(SB)
JAE 2(PC) MOVL BP, SP
NEGL AX POPL BP
MOVL AX, ret+0(FP)
RET RET
// int32 runtime·kevent(int kq, Kevent *changelist, int nchanges, Kevent *eventlist, int nevents, Timespec *timeout); TEXT runtime·kevent_trampoline(SB),NOSPLIT,$0
TEXT runtime·kevent(SB),NOSPLIT,$0 PUSHL BP
MOVL $72, AX // sys_kevent MOVL SP, BP
INT $0x80 SUBL $24, SP
JAE 2(PC) MOVL 32(SP), DX // pointer to args
NEGL AX MOVL 0(DX), AX
MOVL AX, ret+24(FP) MOVL 4(DX), BX
MOVL 8(DX), CX
MOVL AX, 0(SP) // arg 1 - kq
MOVL BX, 4(SP) // arg 2 - keventt
MOVL CX, 8(SP) // arg 3 - nch
MOVL 12(DX), AX
MOVL 16(DX), BX
MOVL 20(DX), CX
MOVL AX, 12(SP) // arg 4 - ev
MOVL BX, 16(SP) // arg 5 - nev
MOVL CX, 20(SP) // arg 6 - ts
CALL libc_kevent(SB)
CMPL AX, $-1
JNE noerr
CALL libc_errno(SB)
MOVL (AX), AX
NEGL AX // caller expects negative errno
noerr:
MOVL BP, SP
POPL BP
RET RET
// int32 runtime·closeonexec(int32 fd); TEXT runtime·clock_gettime_trampoline(SB),NOSPLIT,$0
TEXT runtime·closeonexec(SB),NOSPLIT,$32 PUSHL BP
MOVL $92, AX // sys_fcntl MOVL SP, BP
// 0(SP) is where the caller PC would be; kernel skips it SUBL $8, SP
MOVL fd+0(FP), BX MOVL 16(SP), DX // pointer to args
MOVL BX, 4(SP) // fd MOVL 0(DX), AX
MOVL $2, 8(SP) // F_SETFD MOVL 4(DX), BX
MOVL $1, 12(SP) // FD_CLOEXEC MOVL AX, 0(SP) // arg 1 - tp
INT $0x80 MOVL BX, 4(SP) // arg 2 - clock_id
JAE 2(PC) CALL libc_clock_gettime(SB)
NEGL AX CMPL AX, $-1
JNE 2(PC)
MOVL $0xf1, 0xf1 // crash on failure
MOVL BP, SP
POPL BP
RET RET
// func runtime·setNonblock(fd int32) TEXT runtime·fcntl_trampoline(SB),NOSPLIT,$0
TEXT runtime·setNonblock(SB),NOSPLIT,$16-4 PUSHL BP
MOVL $92, AX // fcntl MOVL SP, BP
MOVL fd+0(FP), BX // fd SUBL $16, SP
MOVL BX, 4(SP) MOVL 24(SP), DX // pointer to args
MOVL $3, 8(SP) // F_GETFL MOVL 0(DX), AX
MOVL $0, 12(SP) MOVL 4(DX), BX
INT $0x80 MOVL 8(DX), CX
MOVL fd+0(FP), BX // fd MOVL AX, 0(SP) // arg 1 - fd
MOVL BX, 4(SP) MOVL BX, 4(SP) // arg 2 - cmd
MOVL $4, 8(SP) // F_SETFL MOVL CX, 8(SP) // arg 3 - arg
ORL $4, AX // O_NONBLOCK MOVL $0, 12(SP) // vararg
MOVL AX, 12(SP) CALL libc_fcntl(SB)
MOVL $92, AX // fcntl MOVL BP, SP
INT $0x80 POPL BP
RET RET
GLOBL runtime·tlsoffset(SB),NOPTR,$4 TEXT runtime·sigaction_trampoline(SB),NOSPLIT,$0
PUSHL BP
MOVL SP, BP
SUBL $12, SP
MOVL 20(SP), DX // pointer to args
MOVL 0(DX), AX
MOVL 4(DX), BX
MOVL 8(DX), CX
MOVL AX, 0(SP) // arg 1 - sig
MOVL BX, 4(SP) // arg 2 - new
MOVL CX, 8(SP) // arg 3 - old
CALL libc_sigaction(SB)
CMPL AX, $-1
JNE 2(PC)
MOVL $0xf1, 0xf1 // crash on failure
MOVL BP, SP
POPL BP
RET
TEXT runtime·sigprocmask_trampoline(SB),NOSPLIT,$0
PUSHL BP
MOVL SP, BP
SUBL $12, SP
MOVL 20(SP), DX // pointer to args
MOVL 0(DX), AX
MOVL 4(DX), BX
MOVL 8(DX), CX
MOVL AX, 0(SP) // arg 1 - how
MOVL BX, 4(SP) // arg 2 - new
MOVL CX, 8(SP) // arg 3 - old
CALL libc_pthread_sigmask(SB)
CMPL AX, $-1
JNE 2(PC)
MOVL $0xf1, 0xf1 // crash on failure
MOVL BP, SP
POPL BP
RET
TEXT runtime·sigaltstack_trampoline(SB),NOSPLIT,$0
PUSHL BP
MOVL SP, BP
SUBL $8, SP
MOVL 16(SP), DX // pointer to args
MOVL 0(DX), AX
MOVL 4(DX), BX
MOVL AX, 0(SP) // arg 1 - new
MOVL BX, 4(SP) // arg 2 - old
CALL libc_sigaltstack(SB)
CMPL AX, $-1
JNE 2(PC)
MOVL $0xf1, 0xf1 // crash on failure
MOVL BP, SP
POPL BP
RET