From aec3c6a33162e73546d2109059faef2df73fe469 Mon Sep 17 00:00:00 2001
From: Rob Pike <r@golang.org>
Date: Thu, 14 Aug 2014 12:30:17 -0700
Subject: [PATCH] go.sys/unix: just jump to syscall.Syscall etc. Don't
 re-implement these functions.

LGTM=rsc
R=rsc
CC=golang-codereviews
https://golang.org/cl/124390043
---
 unix/asm_darwin_386.s      | 129 ++--------------------------
 unix/asm_darwin_amd64.s    |  94 ++------------------
 unix/asm_dragonfly_386.s   | 126 ++-------------------------
 unix/asm_dragonfly_amd64.s | 120 ++------------------------
 unix/asm_freebsd_386.s     | 129 ++--------------------------
 unix/asm_freebsd_amd64.s   | 128 ++-------------------------
 unix/asm_freebsd_arm.s     | 116 ++-----------------------
 unix/asm_linux_386.s       | 171 ++-----------------------------------
 unix/asm_linux_amd64.s     | 113 ++----------------------
 unix/asm_linux_arm.s       | 148 +++-----------------------------
 unix/asm_netbsd_386.s      | 129 ++--------------------------
 unix/asm_netbsd_amd64.s    | 122 ++------------------------
 unix/asm_netbsd_arm.s      | 113 ++----------------------
 unix/asm_openbsd_386.s     | 129 ++--------------------------
 unix/asm_openbsd_amd64.s   | 122 ++------------------------
 15 files changed, 109 insertions(+), 1780 deletions(-)

diff --git a/unix/asm_darwin_386.s b/unix/asm_darwin_386.s
index dfe94fb5..f9338dad 100644
--- a/unix/asm_darwin_386.s
+++ b/unix/asm_darwin_386.s
@@ -2,141 +2,26 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// TODO(rsc): Rewrite all nn(SP) references into name+(nn-8)(FP)
-// so that go vet can check that they are correct.
-
 #include "textflag.h"
 
 //
 // System call support for 386, Darwin
 //
 
-// func Syscall(trap int32, a1, a2, a3 int32) (r1, r2, err int32);
-// func Syscall6(trap int32, a1, a2, a3, a4, a5, a6 int32) (r1, r2, err int32);
-// Trap # in AX, args on stack above caller pc.
+// Just jump to package syscall's implementation for all these functions.
+// The runtime may know about them.
 
 TEXT	·Syscall(SB),NOSPLIT,$0-28
-	CALL	runtime·entersyscall(SB)
-	MOVL	4(SP), AX	// syscall entry
-	// slide args down on top of system call number
-	LEAL		8(SP), SI
-	LEAL		4(SP), DI
-	CLD
-	MOVSL
-	MOVSL
-	MOVSL
-	INT	$0x80
-	JAE	ok
-	MOVL	$-1, 20(SP)	// r1
-	MOVL	$-1, 24(SP)	// r2
-	MOVL	AX, 28(SP)		// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
-ok:
-	MOVL	AX, 20(SP)	// r1
-	MOVL	DX, 24(SP)	// r2
-	MOVL	$0, 28(SP)	// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
+	JMP	syscall·Syscall(SB)
 
 TEXT	·Syscall6(SB),NOSPLIT,$0-40
-	CALL	runtime·entersyscall(SB)
-	MOVL	4(SP), AX	// syscall entry
-	// slide args down on top of system call number
-	LEAL		8(SP), SI
-	LEAL		4(SP), DI
-	CLD
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	INT	$0x80
-	JAE	ok6
-	MOVL	$-1, 32(SP)	// r1
-	MOVL	$-1, 36(SP)	// r2
-	MOVL	AX, 40(SP)		// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
-ok6:
-	MOVL	AX, 32(SP)	// r1
-	MOVL	DX, 36(SP)	// r2
-	MOVL	$0, 40(SP)	// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
+	JMP	syscall·Syscall6(SB)
 
 TEXT	·Syscall9(SB),NOSPLIT,$0-52
-	CALL	runtime·entersyscall(SB)
-	MOVL	4(SP), AX	// syscall entry
-	// slide args down on top of system call number
-	LEAL		8(SP), SI
-	LEAL		4(SP), DI
-	CLD
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	INT	$0x80
-	JAE	ok9
-	MOVL	$-1, 44(SP)	// r1
-	MOVL	$-1, 48(SP)	// r2
-	MOVL	AX, 52(SP)		// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
-ok9:
-	MOVL	AX, 44(SP)	// r1
-	MOVL	DX, 48(SP)	// r2
-	MOVL	$0, 52(SP)	// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
+	JMP	syscall·Syscall9(SB)
 
 TEXT ·RawSyscall(SB),NOSPLIT,$0-28
-	MOVL	4(SP), AX	// syscall entry
-	// slide args down on top of system call number
-	LEAL		8(SP), SI
-	LEAL		4(SP), DI
-	CLD
-	MOVSL
-	MOVSL
-	MOVSL
-	INT	$0x80
-	JAE	ok1
-	MOVL	$-1, 20(SP)	// r1
-	MOVL	$-1, 24(SP)	// r2
-	MOVL	AX, 28(SP)		// errno
-	RET
-ok1:
-	MOVL	AX, 20(SP)	// r1
-	MOVL	DX, 24(SP)	// r2
-	MOVL	$0, 28(SP)	// errno
-	RET
+	JMP	syscall·RawSyscall(SB)
 
 TEXT	·RawSyscall6(SB),NOSPLIT,$0-40
-	MOVL	4(SP), AX	// syscall entry
-	// slide args down on top of system call number
-	LEAL		8(SP), SI
-	LEAL		4(SP), DI
-	CLD
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	INT	$0x80
-	JAE	ok2
-	MOVL	$-1, 32(SP)	// r1
-	MOVL	$-1, 36(SP)	// r2
-	MOVL	AX, 40(SP)		// errno
-	RET
-ok2:
-	MOVL	AX, 32(SP)	// r1
-	MOVL	DX, 36(SP)	// r2
-	MOVL	$0, 40(SP)	// errno
-	RET
+	JMP	syscall·RawSyscall6(SB)
diff --git a/unix/asm_darwin_amd64.s b/unix/asm_darwin_amd64.s
index d6f1c96f..9adb6523 100644
--- a/unix/asm_darwin_amd64.s
+++ b/unix/asm_darwin_amd64.s
@@ -2,105 +2,23 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// TODO(rsc): Rewrite all nn(SP) references into name+(nn-8)(FP)
-// so that go vet can check that they are correct.
-
 #include "textflag.h"
 
 //
 // System call support for AMD64, Darwin
 //
 
-// func Syscall(trap int64, a1, a2, a3 int64) (r1, r2, err int64);
-// func Syscall6(trap int64, a1, a2, a3, a4, a5, a6 int64) (r1, r2, err int64);
-// Trap # in AX, args in DI SI DX, return in AX DX
+// Just jump to package syscall's implementation for all these functions.
+// The runtime may know about them.
 
 TEXT	·Syscall(SB),NOSPLIT,$0-56
-	CALL	runtime·entersyscall(SB)
-	MOVQ	16(SP), DI
-	MOVQ	24(SP), SI
-	MOVQ	32(SP), DX
-	MOVQ	$0, R10
-	MOVQ	$0, R8
-	MOVQ	$0, R9
-	MOVQ	8(SP), AX	// syscall entry
-	ADDQ	$0x2000000, AX
-	SYSCALL
-	JCC	ok
-	MOVQ	$-1, 40(SP)	// r1
-	MOVQ	$0, 48(SP)	// r2
-	MOVQ	AX, 56(SP)  // errno
-	CALL	runtime·exitsyscall(SB)
-	RET
-ok:
-	MOVQ	AX, 40(SP)	// r1
-	MOVQ	DX, 48(SP)	// r2
-	MOVQ	$0, 56(SP)	// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
+	JMP	syscall·Syscall(SB)
 
 TEXT	·Syscall6(SB),NOSPLIT,$0-80
-	CALL	runtime·entersyscall(SB)
-	MOVQ	16(SP), DI
-	MOVQ	24(SP), SI
-	MOVQ	32(SP), DX
-	MOVQ	40(SP), R10
-	MOVQ	48(SP), R8
-	MOVQ	56(SP), R9
-	MOVQ	8(SP), AX	// syscall entry
-	ADDQ	$0x2000000, AX
-	SYSCALL
-	JCC	ok6
-	MOVQ	$-1, 64(SP)	// r1
-	MOVQ	$0, 72(SP)	// r2
-	MOVQ	AX, 80(SP)  // errno
-	CALL	runtime·exitsyscall(SB)
-	RET
-ok6:
-	MOVQ	AX, 64(SP)	// r1
-	MOVQ	DX, 72(SP)	// r2
-	MOVQ	$0, 80(SP)	// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
+	JMP	syscall·Syscall6(SB)
 
 TEXT ·RawSyscall(SB),NOSPLIT,$0-56
-	MOVQ	16(SP), DI
-	MOVQ	24(SP), SI
-	MOVQ	32(SP), DX
-	MOVQ	$0, R10
-	MOVQ	$0, R8
-	MOVQ	$0, R9
-	MOVQ	8(SP), AX	// syscall entry
-	ADDQ	$0x2000000, AX
-	SYSCALL
-	JCC	ok1
-	MOVQ	$-1, 40(SP)	// r1
-	MOVQ	$0, 48(SP)	// r2
-	MOVQ	AX, 56(SP)  // errno
-	RET
-ok1:
-	MOVQ	AX, 40(SP)	// r1
-	MOVQ	DX, 48(SP)	// r2
-	MOVQ	$0, 56(SP)	// errno
-	RET
+	JMP	syscall·RawSyscall(SB)
 
 TEXT	·RawSyscall6(SB),NOSPLIT,$0-80
-	MOVQ	16(SP), DI
-	MOVQ	24(SP), SI
-	MOVQ	32(SP), DX
-	MOVQ	40(SP), R10
-	MOVQ	48(SP), R8
-	MOVQ	56(SP), R9
-	MOVQ	8(SP), AX	// syscall entry
-	ADDQ	$0x2000000, AX
-	SYSCALL
-	JCC	ok2
-	MOVQ	$-1, 64(SP)	// r1
-	MOVQ	$0, 72(SP)	// r2
-	MOVQ	AX, 80(SP)  // errno
-	RET
-ok2:
-	MOVQ	AX, 64(SP)	// r1
-	MOVQ	DX, 72(SP)	// r2
-	MOVQ	$0, 80(SP)	// errno
-	RET
+	JMP	syscall·RawSyscall6(SB)
diff --git a/unix/asm_dragonfly_386.s b/unix/asm_dragonfly_386.s
index 37d655fb..68aa5e4d 100644
--- a/unix/asm_dragonfly_386.s
+++ b/unix/asm_dragonfly_386.s
@@ -8,132 +8,20 @@
 // System call support for 386, FreeBSD
 //
 
-// func Syscall(trap int32, a1, a2, a3 int32) (r1, r2, err int32);
-// func Syscall6(trap int32, a1, a2, a3, a4, a5, a6 int32) (r1, r2, err int32);
-// Trap # in AX, args on stack above caller pc.
+// Just jump to package syscall's implementation for all these functions.
+// The runtime may know about them.
 
 TEXT	·Syscall(SB),NOSPLIT,$0-32
-	CALL	runtime·entersyscall(SB)
-	MOVL	4(SP), AX	// syscall entry
-	// slide args down on top of system call number
-	LEAL		8(SP), SI
-	LEAL		4(SP), DI
-	CLD
-	MOVSL
-	MOVSL
-	MOVSL
-	INT	$0x80
-	JAE	ok
-	MOVL	$-1, 20(SP)	// r1
-	MOVL	$-1, 24(SP)	// r2
-	MOVL	AX, 28(SP)		// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
-ok:
-	MOVL	AX, 20(SP)	// r1
-	MOVL	DX, 24(SP)	// r2
-	MOVL	$0, 28(SP)	// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
+	JMP	syscall·Syscall(SB)
 
 TEXT	·Syscall6(SB),NOSPLIT,$0-44
-	CALL	runtime·entersyscall(SB)
-	MOVL	4(SP), AX	// syscall entry
-	// slide args down on top of system call number
-	LEAL		8(SP), SI
-	LEAL		4(SP), DI
-	CLD
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	INT	$0x80
-	JAE	ok6
-	MOVL	$-1, 32(SP)	// r1
-	MOVL	$-1, 36(SP)	// r2
-	MOVL	AX, 40(SP)		// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
-ok6:
-	MOVL	AX, 32(SP)	// r1
-	MOVL	DX, 36(SP)	// r2
-	MOVL	$0, 40(SP)	// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
+	JMP	syscall·Syscall6(SB)
 
 TEXT	·Syscall9(SB),NOSPLIT,$0-56
-	CALL	runtime·entersyscall(SB)
-	MOVL	4(SP), AX	// syscall entry
-	// slide args down on top of system call number
-	LEAL		8(SP), SI
-	LEAL		4(SP), DI
-	CLD
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	INT	$0x80
-	JAE	ok9
-	MOVL	$-1, 44(SP)	// r1
-	MOVL	$-1, 48(SP)	// r2
-	MOVL	AX, 52(SP)		// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
-ok9:
-	MOVL	AX, 44(SP)	// r1
-	MOVL	DX, 48(SP)	// r2
-	MOVL	$0, 52(SP)	// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
+	JMP	syscall·Syscall9(SB)
 
 TEXT ·RawSyscall(SB),NOSPLIT,$0-32
-	MOVL	4(SP), AX	// syscall entry
-	// slide args down on top of system call number
-	LEAL		8(SP), SI
-	LEAL		4(SP), DI
-	CLD
-	MOVSL
-	MOVSL
-	MOVSL
-	INT	$0x80
-	JAE	ok1
-	MOVL	$-1, 20(SP)	// r1
-	MOVL	$-1, 24(SP)	// r2
-	MOVL	AX, 28(SP)		// errno
-	RET
-ok1:
-	MOVL	AX, 20(SP)	// r1
-	MOVL	DX, 24(SP)	// r2
-	MOVL	$0, 28(SP)	// errno
-	RET
+	JMP	syscall·RawSyscall(SB)
 
 TEXT	·RawSyscall6(SB),NOSPLIT,$0-44
-	MOVL	4(SP), AX	// syscall entry
-	// slide args down on top of system call number
-	LEAL		8(SP), SI
-	LEAL		4(SP), DI
-	CLD
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	INT	$0x80
-	JAE	ok2
-	MOVL	$-1, 32(SP)	// r1
-	MOVL	$-1, 36(SP)	// r2
-	MOVL	AX, 40(SP)		// errno
-	RET
-ok2:
-	MOVL	AX, 32(SP)	// r1
-	MOVL	DX, 36(SP)	// r2
-	MOVL	$0, 40(SP)	// errno
-	RET
+	JMP	syscall·RawSyscall6(SB)
diff --git a/unix/asm_dragonfly_amd64.s b/unix/asm_dragonfly_amd64.s
index c8434f96..77b1bf92 100644
--- a/unix/asm_dragonfly_amd64.s
+++ b/unix/asm_dragonfly_amd64.s
@@ -8,126 +8,20 @@
 // System call support for AMD64, DragonFly
 //
 
-// func Syscall(trap int64, a1, a2, a3 int64) (r1, r2, err int64);
-// func Syscall6(trap int64, a1, a2, a3, a4, a5, a6 int64) (r1, r2, err int64);
-// func Syscall9(trap int64, a1, a2, a3, a4, a5, a6, a7, a8, a9 int64) (r1, r2, err int64)
-// Trap # in AX, args in DI SI DX, return in AX DX
+// Just jump to package syscall's implementation for all these functions.
+// The runtime may know about them.
 
 TEXT	·Syscall(SB),NOSPLIT,$0-64
-	CALL	runtime·entersyscall(SB)
-	MOVQ	16(SP), DI
-	MOVQ	24(SP), SI
-	MOVQ	32(SP), DX
-	MOVQ	$0, R10
-	MOVQ	$0, R8
-	MOVQ	$0, R9
-	MOVQ	8(SP), AX	// syscall entry
-	SYSCALL
-	JCC	ok
-	MOVQ	$-1, 40(SP)	// r1
-	MOVQ	$0, 48(SP)	// r2
-	MOVQ	AX, 56(SP)  // errno
-	CALL	runtime·exitsyscall(SB)
-	RET
-ok:
-	MOVQ	AX, 40(SP)	// r1
-	MOVQ	DX, 48(SP)	// r2
-	MOVQ	$0, 56(SP)	// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
+	JMP	syscall·Syscall(SB)
 
 TEXT	·Syscall6(SB),NOSPLIT,$0-88
-	CALL	runtime·entersyscall(SB)
-	MOVQ	16(SP), DI
-	MOVQ	24(SP), SI
-	MOVQ	32(SP), DX
-	MOVQ	40(SP), R10
-	MOVQ	48(SP), R8
-	MOVQ	56(SP), R9
-	MOVQ	8(SP), AX	// syscall entry
-	SYSCALL
-	JCC	ok6
-	MOVQ	$-1, 64(SP)	// r1
-	MOVQ	$0, 72(SP)	// r2
-	MOVQ	AX, 80(SP)  // errno
-	CALL	runtime·exitsyscall(SB)
-	RET
-ok6:
-	MOVQ	AX, 64(SP)	// r1
-	MOVQ	DX, 72(SP)	// r2
-	MOVQ	$0, 80(SP)	// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
+	JMP	syscall·Syscall6(SB)
 
 TEXT	·Syscall9(SB),NOSPLIT,$0-112
-	CALL	runtime·entersyscall(SB)
-	MOVQ	8(SP), AX
-	MOVQ	16(SP), DI
-	MOVQ	24(SP), SI
-	MOVQ	32(SP), DX
-	MOVQ	40(SP),	R10
-	MOVQ	48(SP), R8
-	MOVQ	56(SP), R9
-
-	// shift around the last three arguments so they're at the
-	// top of the stack when the syscall is called.
-	MOVQ	64(SP), R11 // arg 7
-	MOVQ	R11, 8(SP)
-	MOVQ	72(SP), R11 // arg 8
-	MOVQ	R11, 16(SP)
-	MOVQ	80(SP), R11 // arg 9
-	MOVQ	R11, 24(SP)
-
-	SYSCALL
-	JCC	ok9
-	MOVQ	$-1, 88(SP)	// r1
-	MOVQ	$0, 96(SP)	// r2
-	MOVQ	AX, 104(SP)  // errno
-	CALL	runtime·exitsyscall(SB)
-	RET
-ok9:
-	MOVQ	AX, 88(SP)	// r1
-	MOVQ	DX, 96(SP)	// r2
-	MOVQ	$0, 104(SP)	// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
+	JMP	syscall·Syscall9(SB)
 
 TEXT ·RawSyscall(SB),NOSPLIT,$0-64
-	MOVQ	16(SP), DI
-	MOVQ	24(SP), SI
-	MOVQ	32(SP), DX
-	MOVQ	$0, R10
-	MOVQ	$0, R8
-	MOVQ	$0, R9
-	MOVQ	8(SP), AX	// syscall entry
-	SYSCALL
-	JCC	ok1
-	MOVQ	$-1, 40(SP)	// r1
-	MOVQ	$0, 48(SP)	// r2
-	MOVQ	AX, 56(SP)  // errno
-	RET
-ok1:
-	MOVQ	AX, 40(SP)	// r1
-	MOVQ	DX, 48(SP)	// r2
-	MOVQ	$0, 56(SP)	// errno
-	RET
+	JMP	syscall·RawSyscall(SB)
 
 TEXT	·RawSyscall6(SB),NOSPLIT,$0-88
-	MOVQ	16(SP), DI
-	MOVQ	24(SP), SI
-	MOVQ	32(SP), DX
-	MOVQ	40(SP), R10
-	MOVQ	48(SP), R8
-	MOVQ	56(SP), R9
-	MOVQ	8(SP), AX	// syscall entry
-	SYSCALL
-	JCC	ok2
-	MOVQ	$-1, 64(SP)	// r1
-	MOVQ	$0, 72(SP)	// r2
-	MOVQ	AX, 80(SP)  // errno
-	RET
-ok2:
-	MOVQ	AX, 64(SP)	// r1
-	MOVQ	DX, 72(SP)	// r2
-	MOVQ	$0, 80(SP)	// errno
-	RET
+	JMP	syscall·RawSyscall6(SB)
diff --git a/unix/asm_freebsd_386.s b/unix/asm_freebsd_386.s
index f50b5a09..1146f0bc 100644
--- a/unix/asm_freebsd_386.s
+++ b/unix/asm_freebsd_386.s
@@ -2,141 +2,26 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// TODO(rsc): Rewrite all nn(SP) references into name+(nn-8)(FP)
-// so that go vet can check that they are correct.
-
 #include "textflag.h"
 
 //
 // System call support for 386, FreeBSD
 //
 
-// func Syscall(trap int32, a1, a2, a3 int32) (r1, r2, err int32);
-// func Syscall6(trap int32, a1, a2, a3, a4, a5, a6 int32) (r1, r2, err int32);
-// Trap # in AX, args on stack above caller pc.
+// Just jump to package syscall's implementation for all these functions.
+// The runtime may know about them.
 
 TEXT	·Syscall(SB),NOSPLIT,$0-28
-	CALL	runtime·entersyscall(SB)
-	MOVL	4(SP), AX	// syscall entry
-	// slide args down on top of system call number
-	LEAL		8(SP), SI
-	LEAL		4(SP), DI
-	CLD
-	MOVSL
-	MOVSL
-	MOVSL
-	INT	$0x80
-	JAE	ok
-	MOVL	$-1, 20(SP)	// r1
-	MOVL	$-1, 24(SP)	// r2
-	MOVL	AX, 28(SP)		// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
-ok:
-	MOVL	AX, 20(SP)	// r1
-	MOVL	DX, 24(SP)	// r2
-	MOVL	$0, 28(SP)	// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
+	JMP	syscall·Syscall(SB)
 
 TEXT	·Syscall6(SB),NOSPLIT,$0-40
-	CALL	runtime·entersyscall(SB)
-	MOVL	4(SP), AX	// syscall entry
-	// slide args down on top of system call number
-	LEAL		8(SP), SI
-	LEAL		4(SP), DI
-	CLD
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	INT	$0x80
-	JAE	ok6
-	MOVL	$-1, 32(SP)	// r1
-	MOVL	$-1, 36(SP)	// r2
-	MOVL	AX, 40(SP)		// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
-ok6:
-	MOVL	AX, 32(SP)	// r1
-	MOVL	DX, 36(SP)	// r2
-	MOVL	$0, 40(SP)	// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
+	JMP	syscall·Syscall6(SB)
 
 TEXT	·Syscall9(SB),NOSPLIT,$0-52
-	CALL	runtime·entersyscall(SB)
-	MOVL	4(SP), AX	// syscall entry
-	// slide args down on top of system call number
-	LEAL		8(SP), SI
-	LEAL		4(SP), DI
-	CLD
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	INT	$0x80
-	JAE	ok9
-	MOVL	$-1, 44(SP)	// r1
-	MOVL	$-1, 48(SP)	// r2
-	MOVL	AX, 52(SP)		// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
-ok9:
-	MOVL	AX, 44(SP)	// r1
-	MOVL	DX, 48(SP)	// r2
-	MOVL	$0, 52(SP)	// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
+	JMP	syscall·Syscall9(SB)
 
 TEXT ·RawSyscall(SB),NOSPLIT,$0-28
-	MOVL	4(SP), AX	// syscall entry
-	// slide args down on top of system call number
-	LEAL		8(SP), SI
-	LEAL		4(SP), DI
-	CLD
-	MOVSL
-	MOVSL
-	MOVSL
-	INT	$0x80
-	JAE	ok1
-	MOVL	$-1, 20(SP)	// r1
-	MOVL	$-1, 24(SP)	// r2
-	MOVL	AX, 28(SP)		// errno
-	RET
-ok1:
-	MOVL	AX, 20(SP)	// r1
-	MOVL	DX, 24(SP)	// r2
-	MOVL	$0, 28(SP)	// errno
-	RET
+	JMP	syscall·RawSyscall(SB)
 
 TEXT	·RawSyscall6(SB),NOSPLIT,$0-40
-	MOVL	4(SP), AX	// syscall entry
-	// slide args down on top of system call number
-	LEAL		8(SP), SI
-	LEAL		4(SP), DI
-	CLD
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	INT	$0x80
-	JAE	ok2
-	MOVL	$-1, 32(SP)	// r1
-	MOVL	$-1, 36(SP)	// r2
-	MOVL	AX, 40(SP)		// errno
-	RET
-ok2:
-	MOVL	AX, 32(SP)	// r1
-	MOVL	DX, 36(SP)	// r2
-	MOVL	$0, 40(SP)	// errno
-	RET
+	JMP	syscall·RawSyscall6(SB)
diff --git a/unix/asm_freebsd_amd64.s b/unix/asm_freebsd_amd64.s
index 58cbfe1a..d80fd12a 100644
--- a/unix/asm_freebsd_amd64.s
+++ b/unix/asm_freebsd_amd64.s
@@ -2,140 +2,26 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// TODO(rsc): Rewrite all nn(SP) references into name+(nn-8)(FP)
-// so that go vet can check that they are correct.
-
 #include "textflag.h"
 
 //
 // System call support for AMD64, FreeBSD
 //
 
-// The SYSCALL variant for invoking system calls is broken in FreeBSD.
-// See comment at top of ../runtime/sys_freebsd_amd64.c and
-// golang.org/issue/6372.
-#define SYSCALL MOVQ R10, CX; INT $0x80
-
-// func Syscall(trap int64, a1, a2, a3 int64) (r1, r2, err int64);
-// func Syscall6(trap int64, a1, a2, a3, a4, a5, a6 int64) (r1, r2, err int64);
-// func Syscall9(trap int64, a1, a2, a3, a4, a5, a6, a7, a8, a9 int64) (r1, r2, err int64)
-// Trap # in AX, args in DI SI DX, return in AX DX
+// Just jump to package syscall's implementation for all these functions.
+// The runtime may know about them.
 
 TEXT	·Syscall(SB),NOSPLIT,$0-56
-	CALL	runtime·entersyscall(SB)
-	MOVQ	16(SP), DI
-	MOVQ	24(SP), SI
-	MOVQ	32(SP), DX
-	MOVQ	$0, R10
-	MOVQ	$0, R8
-	MOVQ	$0, R9
-	MOVQ	8(SP), AX	// syscall entry
-	SYSCALL
-	JCC	ok
-	MOVQ	$-1, 40(SP)	// r1
-	MOVQ	$0, 48(SP)	// r2
-	MOVQ	AX, 56(SP)  // errno
-	CALL	runtime·exitsyscall(SB)
-	RET
-ok:
-	MOVQ	AX, 40(SP)	// r1
-	MOVQ	DX, 48(SP)	// r2
-	MOVQ	$0, 56(SP)	// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
+	JMP	syscall·Syscall(SB)
 
 TEXT	·Syscall6(SB),NOSPLIT,$0-80
-	CALL	runtime·entersyscall(SB)
-	MOVQ	16(SP), DI
-	MOVQ	24(SP), SI
-	MOVQ	32(SP), DX
-	MOVQ	40(SP), R10
-	MOVQ	48(SP), R8
-	MOVQ	56(SP), R9
-	MOVQ	8(SP), AX	// syscall entry
-	SYSCALL
-	JCC	ok6
-	MOVQ	$-1, 64(SP)	// r1
-	MOVQ	$0, 72(SP)	// r2
-	MOVQ	AX, 80(SP)  // errno
-	CALL	runtime·exitsyscall(SB)
-	RET
-ok6:
-	MOVQ	AX, 64(SP)	// r1
-	MOVQ	DX, 72(SP)	// r2
-	MOVQ	$0, 80(SP)	// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
+	JMP	syscall·Syscall6(SB)
 
 TEXT	·Syscall9(SB),NOSPLIT,$0-104
-	CALL	runtime·entersyscall(SB)
-	MOVQ	8(SP), AX
-	MOVQ	16(SP), DI
-	MOVQ	24(SP), SI
-	MOVQ	32(SP), DX
-	MOVQ	40(SP),	R10
-	MOVQ	48(SP), R8
-	MOVQ	56(SP), R9
-
-	// shift around the last three arguments so they're at the
-	// top of the stack when the syscall is called.
-	MOVQ	64(SP), R11 // arg 7
-	MOVQ	R11, 8(SP)
-	MOVQ	72(SP), R11 // arg 8
-	MOVQ	R11, 16(SP)
-	MOVQ	80(SP), R11 // arg 9
-	MOVQ	R11, 24(SP)
-
-	SYSCALL
-	JCC	ok9
-	MOVQ	$-1, 88(SP)	// r1
-	MOVQ	$0, 96(SP)	// r2
-	MOVQ	AX, 104(SP)  // errno
-	CALL	runtime·exitsyscall(SB)
-	RET
-ok9:
-	MOVQ	AX, 88(SP)	// r1
-	MOVQ	DX, 96(SP)	// r2
-	MOVQ	$0, 104(SP)	// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
+	JMP	syscall·Syscall9(SB)
 
 TEXT ·RawSyscall(SB),NOSPLIT,$0-56
-	MOVQ	16(SP), DI
-	MOVQ	24(SP), SI
-	MOVQ	32(SP), DX
-	MOVQ	$0, R10
-	MOVQ	$0, R8
-	MOVQ	$0, R9
-	MOVQ	8(SP), AX	// syscall entry
-	SYSCALL
-	JCC	ok1
-	MOVQ	$-1, 40(SP)	// r1
-	MOVQ	$0, 48(SP)	// r2
-	MOVQ	AX, 56(SP)  // errno
-	RET
-ok1:
-	MOVQ	AX, 40(SP)	// r1
-	MOVQ	DX, 48(SP)	// r2
-	MOVQ	$0, 56(SP)	// errno
-	RET
+	JMP	syscall·RawSyscall(SB)
 
 TEXT	·RawSyscall6(SB),NOSPLIT,$0-80
-	MOVQ	16(SP), DI
-	MOVQ	24(SP), SI
-	MOVQ	32(SP), DX
-	MOVQ	40(SP), R10
-	MOVQ	48(SP), R8
-	MOVQ	56(SP), R9
-	MOVQ	8(SP), AX	// syscall entry
-	SYSCALL
-	JCC	ok2
-	MOVQ	$-1, 64(SP)	// r1
-	MOVQ	$0, 72(SP)	// r2
-	MOVQ	AX, 80(SP)  // errno
-	RET
-ok2:
-	MOVQ	AX, 64(SP)	// r1
-	MOVQ	DX, 72(SP)	// r2
-	MOVQ	$0, 80(SP)	// errno
-	RET
+	JMP	syscall·RawSyscall6(SB)
diff --git a/unix/asm_freebsd_arm.s b/unix/asm_freebsd_arm.s
index 5eb40334..0cbb53d9 100644
--- a/unix/asm_freebsd_arm.s
+++ b/unix/asm_freebsd_arm.s
@@ -8,122 +8,20 @@
 // System call support for ARM, FreeBSD
 //
 
-// func Syscall(trap, a1, a2, a3 uintptr) (r1, r2, errno uintptr);
-// func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, errno uintptr);
-// func Syscall9(trap, a1, a2, a3, a4, a5, a6, a7, a8, a9 uintptr) (r1, r2, errno uintptr)
+// Just jump to package syscall's implementation for all these functions.
+// The runtime may know about them.
 
 TEXT	·Syscall(SB),NOSPLIT,$0-28
-	BL runtime·entersyscall(SB)
-	MOVW 0(FP), R7 // syscall number
-	MOVW 4(FP), R0 // a1
-	MOVW 8(FP), R1 // a2
-	MOVW 12(FP), R2 // a3
-	SWI $0 // syscall
-	MOVW $0, R2
-	BCS error
-	MOVW R0, 16(FP) // r1
-	MOVW R1, 20(FP) // r2
-	MOVW R2, 24(FP) // errno
-	BL runtime·exitsyscall(SB)
-	RET
-error:
-	MOVW $-1, R3
-	MOVW R3, 16(FP) // r1
-	MOVW R2, 20(FP) // r2
-	MOVW R0, 24(FP) // errno
-	BL runtime·exitsyscall(SB)
-	RET
+	JMP	syscall·Syscall(SB)
 
 TEXT	·Syscall6(SB),NOSPLIT,$0-40
-	BL runtime·entersyscall(SB)
-	MOVW 0(FP), R7 // syscall number
-	MOVW 4(FP), R0 // a1
-	MOVW 8(FP), R1 // a2
-	MOVW 12(FP), R2 // a3
-	MOVW 16(FP), R3 // a4
-	MOVW R13, R4
-	MOVW $20(FP), R13 // a5 to a6 are passed on stack
-	SWI $0 // syscall
-	MOVW R4, R13
-	MOVW $0, R2
-	BCS error6
-	MOVW R0, 28(FP) // r1
-	MOVW R1, 32(FP) // r2
-	MOVW R2, 36(FP) // errno
-	BL runtime·exitsyscall(SB)
-	RET
-error6:
-	MOVW $-1, R3
-	MOVW R3, 28(FP) // r1
-	MOVW R2, 32(FP) // r2
-	MOVW R0, 36(FP) // errno
-	BL runtime·exitsyscall(SB)
-	RET
+	JMP	syscall·Syscall6(SB)
 
 TEXT	·Syscall9(SB),NOSPLIT,$0-52
-	BL runtime·entersyscall(SB)
-	MOVW 0(FP), R7 // syscall number
-	MOVW 4(FP), R0 // a1
-	MOVW 8(FP), R1 // a2
-	MOVW 12(FP), R2 // a3
-	MOVW 16(FP), R3 // a4
-	MOVW R13, R4
-	MOVW $20(FP), R13 // a5 to a9 are passed on stack
-	SWI $0 // syscall
-	MOVW R4, R13
-	MOVW $0, R2
-	BCS error9
-	MOVW R0, 40(FP) // r1
-	MOVW R1, 44(FP) // r2
-	MOVW R2, 48(FP) // errno
-	BL runtime·exitsyscall(SB)
-	RET
-error9:
-	MOVW $-1, R3
-	MOVW R3, 40(FP) // r1
-	MOVW R2, 44(FP) // r2
-	MOVW R0, 48(FP) // errno
-	BL runtime·exitsyscall(SB)
-	RET
+	JMP	syscall·Syscall9(SB)
 
 TEXT	·RawSyscall(SB),NOSPLIT,$0-28
-	MOVW 0(FP), R7 // syscall number
-	MOVW 4(FP), R0 // a1
-	MOVW 8(FP), R1 // a2
-	MOVW 12(FP), R2 // a3
-	SWI $0 // syscall
-	MOVW $0, R2
-	BCS errorr
-	MOVW R0, 16(FP) // r1
-	MOVW R1, 20(FP) // r2
-	MOVW R2, 24(FP) // errno
-	RET
-errorr:
-	MOVW $-1, R3
-	MOVW R3, 16(FP) // r1
-	MOVW R2, 20(FP) // r2
-	MOVW R0, 24(FP) // errno
-	RET
+	JMP	syscall·RawSyscall(SB)
 
 TEXT	·RawSyscall6(SB),NOSPLIT,$0-40
-	MOVW 0(FP), R7 // syscall number
-	MOVW 4(FP), R0 // a1
-	MOVW 8(FP), R1 // a2
-	MOVW 12(FP), R2 // a3
-	MOVW 16(FP), R3 // a4
-	MOVW R13, R4
-	MOVW $20(FP), R13 // a5 to a6 are passed on stack
-	SWI $0 // syscall
-	MOVW R4, R13
-	MOVW $0, R2
-	BCS errorr6
-	MOVW R0, 28(FP) // r1
-	MOVW R1, 32(FP) // r2
-	MOVW R2, 36(FP) // errno
-	RET
-errorr6:
-	MOVW $-1, R3
-	MOVW R3, 28(FP) // r1
-	MOVW R2, 32(FP) // r2
-	MOVW R0, 36(FP) // errno
-	RET
+	JMP	syscall·RawSyscall6(SB)
diff --git a/unix/asm_linux_386.s b/unix/asm_linux_386.s
index 05cf89aa..5d3ad9ad 100644
--- a/unix/asm_linux_386.s
+++ b/unix/asm_linux_386.s
@@ -2,185 +2,32 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// TODO(rsc): Rewrite all nn(SP) references into name+(nn-8)(FP)
-// so that go vet can check that they are correct.
-
 #include "textflag.h"
 
 //
 // System calls for 386, Linux
 //
 
-// func Syscall(trap uintptr, a1, a2, a3 uintptr) (r1, r2, err uintptr);
-// Trap # in AX, args in BX CX DX SI DI, return in AX
+// Just jump to package syscall's implementation for all these functions.
+// The runtime may know about them.
 
 TEXT	·Syscall(SB),NOSPLIT,$0-28
-	CALL	runtime·entersyscall(SB)
-	MOVL	4(SP), AX	// syscall entry
-	MOVL	8(SP), BX
-	MOVL	12(SP), CX
-	MOVL	16(SP), DX
-	MOVL	$0, SI
-	MOVL	$0,  DI
-	CALL	*runtime·_vdso(SB)
-	CMPL	AX, $0xfffff001
-	JLS	ok
-	MOVL	$-1, 20(SP)	// r1
-	MOVL	$0, 24(SP)	// r2
-	NEGL	AX
-	MOVL	AX, 28(SP)  // errno
-	CALL	runtime·exitsyscall(SB)
-	RET
-ok:
-	MOVL	AX, 20(SP)	// r1
-	MOVL	DX, 24(SP)	// r2
-	MOVL	$0, 28(SP)	// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
+	JMP	syscall·Syscall(SB)
 
-// func Syscall6(trap uintptr, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr);
 TEXT	·Syscall6(SB),NOSPLIT,$0-40
-	CALL	runtime·entersyscall(SB)
-	MOVL	4(SP), AX	// syscall entry
-	MOVL	8(SP), BX
-	MOVL	12(SP), CX
-	MOVL	16(SP), DX
-	MOVL	20(SP), SI
-	MOVL	24(SP), DI
-	MOVL	28(SP), BP
-	CALL	*runtime·_vdso(SB)
-	CMPL	AX, $0xfffff001
-	JLS	ok6
-	MOVL	$-1, 32(SP)	// r1
-	MOVL	$0, 36(SP)	// r2
-	NEGL	AX
-	MOVL	AX, 40(SP)  // errno
-	CALL	runtime·exitsyscall(SB)
-	RET
-ok6:
-	MOVL	AX, 32(SP)	// r1
-	MOVL	DX, 36(SP)	// r2
-	MOVL	$0, 40(SP)	// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
+	JMP	syscall·Syscall6(SB)
 
-// func RawSyscall(trap uintptr, a1, a2, a3 uintptr) (r1, r2, err uintptr);
 TEXT ·RawSyscall(SB),NOSPLIT,$0-28
-	MOVL	4(SP), AX	// syscall entry
-	MOVL	8(SP), BX
-	MOVL	12(SP), CX
-	MOVL	16(SP), DX
-	MOVL	$0, SI
-	MOVL	$0,  DI
-	CALL	*runtime·_vdso(SB)
-	CMPL	AX, $0xfffff001
-	JLS	ok1
-	MOVL	$-1, 20(SP)	// r1
-	MOVL	$0, 24(SP)	// r2
-	NEGL	AX
-	MOVL	AX, 28(SP)  // errno
-	RET
-ok1:
-	MOVL	AX, 20(SP)	// r1
-	MOVL	DX, 24(SP)	// r2
-	MOVL	$0, 28(SP)	// errno
-	RET
+	JMP	syscall·RawSyscall(SB)
 
-// func RawSyscall6(trap uintptr, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr);
 TEXT	·RawSyscall6(SB),NOSPLIT,$0-40
-	MOVL	4(SP), AX	// syscall entry
-	MOVL	8(SP), BX
-	MOVL	12(SP), CX
-	MOVL	16(SP), DX
-	MOVL	20(SP), SI
-	MOVL	24(SP), DI
-	MOVL	28(SP), BP
-	CALL	*runtime·_vdso(SB)
-	CMPL	AX, $0xfffff001
-	JLS	ok2
-	MOVL	$-1, 32(SP)	// r1
-	MOVL	$0, 36(SP)	// r2
-	NEGL	AX
-	MOVL	AX, 40(SP)  // errno
-	RET
-ok2:
-	MOVL	AX, 32(SP)	// r1
-	MOVL	DX, 36(SP)	// r2
-	MOVL	$0, 40(SP)	// errno
-	RET
+	JMP	syscall·RawSyscall6(SB)
 
-#define SYS_SOCKETCALL 102	/* from zsysnum_linux_386.go */
-
-// func socketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (n int, errno int)
-// Kernel interface gets call sub-number and pointer to a0.
 TEXT ·socketcall(SB),NOSPLIT,$0-36
-	CALL	runtime·entersyscall(SB)
-	MOVL	$SYS_SOCKETCALL, AX	// syscall entry
-	MOVL	4(SP), BX	// socket call number
-	LEAL		8(SP), CX	// pointer to call arguments
-	MOVL	$0, DX
-	MOVL	$0, SI
-	MOVL	$0,  DI
-	CALL	*runtime·_vdso(SB)
-	CMPL	AX, $0xfffff001
-	JLS	oksock
-	MOVL	$-1, 32(SP)	// n
-	NEGL	AX
-	MOVL	AX, 36(SP)  // errno
-	CALL	runtime·exitsyscall(SB)
-	RET
-oksock:
-	MOVL	AX, 32(SP)	// n
-	MOVL	$0, 36(SP)	// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
+	JMP	syscall·socketcall(SB)
 
-// func rawsocketcall(call int, a0, a1, a2, a3, a4, a5 uintptr) (n int, errno int)
-// Kernel interface gets call sub-number and pointer to a0.
 TEXT ·rawsocketcall(SB),NOSPLIT,$0-36
-	MOVL	$SYS_SOCKETCALL, AX	// syscall entry
-	MOVL	4(SP), BX	// socket call number
-	LEAL		8(SP), CX	// pointer to call arguments
-	MOVL	$0, DX
-	MOVL	$0, SI
-	MOVL	$0,  DI
-	CALL	*runtime·_vdso(SB)
-	CMPL	AX, $0xfffff001
-	JLS	oksock1
-	MOVL	$-1, 32(SP)	// n
-	NEGL	AX
-	MOVL	AX, 36(SP)  // errno
-	RET
-oksock1:
-	MOVL	AX, 32(SP)	// n
-	MOVL	$0, 36(SP)	// errno
-	RET
+	JMP	syscall·rawsocketcall(SB)
 
-#define SYS__LLSEEK 140	/* from zsysnum_linux_386.go */
-// func Seek(fd int, offset int64, whence int) (newoffset int64, errno int)
-// Implemented in assembly to avoid allocation when
-// taking the address of the return value newoffset.
-// Underlying system call is
-//	llseek(int fd, int offhi, int offlo, int64 *result, int whence)
 TEXT ·seek(SB),NOSPLIT,$0-28
-	CALL	runtime·entersyscall(SB)
-	MOVL	$SYS__LLSEEK, AX	// syscall entry
-	MOVL	4(SP), BX	// fd
-	MOVL	12(SP), CX	// offset-high
-	MOVL	8(SP), DX	// offset-low
-	LEAL	20(SP), SI	// result pointer
-	MOVL	16(SP),  DI	// whence
-	CALL	*runtime·_vdso(SB)
-	CMPL	AX, $0xfffff001
-	JLS	okseek
-	MOVL	$-1, 20(SP)	// newoffset low
-	MOVL	$-1, 24(SP)	// newoffset high
-	NEGL	AX
-	MOVL	AX, 28(SP)  // errno
-	CALL	runtime·exitsyscall(SB)
-	RET
-okseek:
-	// system call filled in newoffset already
-	MOVL	$0, 28(SP)	// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
+	JMP	syscall·seek(SB)
diff --git a/unix/asm_linux_amd64.s b/unix/asm_linux_amd64.s
index 51469328..0c8c7786 100644
--- a/unix/asm_linux_amd64.s
+++ b/unix/asm_linux_amd64.s
@@ -2,125 +2,26 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// TODO(rsc): Rewrite all nn(SP) references into name+(nn-8)(FP)
-// so that go vet can check that they are correct.
-
 #include "textflag.h"
 
 //
 // System calls for AMD64, Linux
 //
 
-// func Syscall(trap int64, a1, a2, a3 int64) (r1, r2, err int64);
-// Trap # in AX, args in DI SI DX R10 R8 R9, return in AX DX
-// Note that this differs from "standard" ABI convention, which
-// would pass 4th arg in CX, not R10.
+// Just jump to package syscall's implementation for all these functions.
+// The runtime may know about them.
 
 TEXT	·Syscall(SB),NOSPLIT,$0-56
-	CALL	runtime·entersyscall(SB)
-	MOVQ	16(SP), DI
-	MOVQ	24(SP), SI
-	MOVQ	32(SP), DX
-	MOVQ	$0, R10
-	MOVQ	$0, R8
-	MOVQ	$0, R9
-	MOVQ	8(SP), AX	// syscall entry
-	SYSCALL
-	CMPQ	AX, $0xfffffffffffff001
-	JLS	ok
-	MOVQ	$-1, 40(SP)	// r1
-	MOVQ	$0, 48(SP)	// r2
-	NEGQ	AX
-	MOVQ	AX, 56(SP)  // errno
-	CALL	runtime·exitsyscall(SB)
-	RET
-ok:
-	MOVQ	AX, 40(SP)	// r1
-	MOVQ	DX, 48(SP)	// r2
-	MOVQ	$0, 56(SP)	// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
+	JMP	syscall·Syscall(SB)
 
 TEXT ·Syscall6(SB),NOSPLIT,$0-80
-	CALL	runtime·entersyscall(SB)
-	MOVQ	16(SP), DI
-	MOVQ	24(SP), SI
-	MOVQ	32(SP), DX
-	MOVQ	40(SP), R10
-	MOVQ	48(SP), R8
-	MOVQ	56(SP), R9
-	MOVQ	8(SP), AX	// syscall entry
-	SYSCALL
-	CMPQ	AX, $0xfffffffffffff001
-	JLS	ok6
-	MOVQ	$-1, 64(SP)	// r1
-	MOVQ	$0, 72(SP)	// r2
-	NEGQ	AX
-	MOVQ	AX, 80(SP)  // errno
-	CALL	runtime·exitsyscall(SB)
-	RET
-ok6:
-	MOVQ	AX, 64(SP)	// r1
-	MOVQ	DX, 72(SP)	// r2
-	MOVQ	$0, 80(SP)	// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
+	JMP	syscall·Syscall6(SB)
 
 TEXT ·RawSyscall(SB),NOSPLIT,$0-56
-	MOVQ	16(SP), DI
-	MOVQ	24(SP), SI
-	MOVQ	32(SP), DX
-	MOVQ	$0, R10
-	MOVQ	$0, R8
-	MOVQ	$0, R9
-	MOVQ	8(SP), AX	// syscall entry
-	SYSCALL
-	CMPQ	AX, $0xfffffffffffff001
-	JLS	ok1
-	MOVQ	$-1, 40(SP)	// r1
-	MOVQ	$0, 48(SP)	// r2
-	NEGQ	AX
-	MOVQ	AX, 56(SP)  // errno
-	RET
-ok1:
-	MOVQ	AX, 40(SP)	// r1
-	MOVQ	DX, 48(SP)	// r2
-	MOVQ	$0, 56(SP)	// errno
-	RET
+	JMP	syscall·RawSyscall(SB)
 
 TEXT ·RawSyscall6(SB),NOSPLIT,$0-80
-	MOVQ	16(SP), DI
-	MOVQ	24(SP), SI
-	MOVQ	32(SP), DX
-	MOVQ	40(SP), R10
-	MOVQ	48(SP), R8
-	MOVQ	56(SP), R9
-	MOVQ	8(SP), AX	// syscall entry
-	SYSCALL
-	CMPQ	AX, $0xfffffffffffff001
-	JLS	ok2
-	MOVQ	$-1, 64(SP)	// r1
-	MOVQ	$0, 72(SP)	// r2
-	NEGQ	AX
-	MOVQ	AX, 80(SP)  // errno
-	RET
-ok2:
-	MOVQ	AX, 64(SP)	// r1
-	MOVQ	DX, 72(SP)	// r2
-	MOVQ	$0, 80(SP)	// errno
-	RET
+	JMP	syscall·RawSyscall6(SB)
 
 TEXT ·gettimeofday(SB),NOSPLIT,$0-16
-	MOVQ	8(SP), DI
-	MOVQ	$0, SI
-	MOVQ	runtime·__vdso_gettimeofday_sym(SB), AX
-	CALL	AX
-
-	CMPQ	AX, $0xfffffffffffff001
-	JLS	ok7
-	NEGQ	AX
-	MOVQ	AX, 16(SP)  // errno
-	RET
-ok7:
-	MOVQ	$0, 16(SP)  // errno
-	RET
+	JMP	syscall·gettimeofday(SB)
diff --git a/unix/asm_linux_arm.s b/unix/asm_linux_arm.s
index 014fa618..054927a7 100644
--- a/unix/asm_linux_arm.s
+++ b/unix/asm_linux_arm.s
@@ -8,148 +8,20 @@
 // System calls for arm, Linux
 //
 
-// TODO(kaib): handle error returns
-
-// func Syscall(syscall uintptr, a1, a2, a3 uintptr) (r1, r2, err uintptr);
+// Just jump to package syscall's implementation for all these functions.
+// The runtime may know about them.
 
 TEXT	·Syscall(SB),NOSPLIT,$0-28
-	BL		runtime·entersyscall(SB)
-	MOVW	4(SP), R7
-	MOVW	8(SP), R0
-	MOVW	12(SP), R1
-	MOVW	16(SP), R2
-	SWI		$0
-	MOVW	$0xfffff001, R1
-	CMP		R1, R0
-	BLS		ok
-	MOVW	$-1, R1
-	MOVW	R1, 20(SP)	// r1
-	MOVW	$0, R2
-	MOVW	R2, 24(SP)	// r2
-	RSB		$0, R0, R0
-	MOVW	R0, 28(SP)	// errno
-	BL		runtime·exitsyscall(SB)
-	RET
-ok:
-	MOVW	R0, 20(SP) // r1
-	MOVW	$0, R0
-	MOVW	R0, 24(SP)	// r2
-	MOVW	R0, 28(SP)	// errno
-	BL		runtime·exitsyscall(SB)
-	RET
+	JMP	syscall·Syscall(SB)
 
-// func Syscall6(trap uintptr, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr);
-// Actually Syscall5 but the rest of the code expects it to be named Syscall6.
 TEXT	·Syscall6(SB),NOSPLIT,$0-40
-	BL		runtime·entersyscall(SB)
-	MOVW	4(SP), R7	// syscall entry
-	MOVW	8(SP), R0
-	MOVW	12(SP), R1
-	MOVW	16(SP), R2
-	MOVW	20(SP), R3
-	MOVW	24(SP), R4
-	MOVW	28(SP), R5
-	SWI		$0
-	MOVW	$0xfffff001, R6
-	CMP		R6, R0
-	BLS		ok6
-	MOVW	$-1, R1
-	MOVW	R1, 32(SP)	// r1
-	MOVW	$0, R2
-	MOVW	R2, 36(SP)	// r2
-	RSB		$0, R0, R0
-	MOVW	R0, 40(SP)	// errno
-	BL		runtime·exitsyscall(SB)
-	RET
-ok6:
-	MOVW	R0, 32(SP) // r1
-	MOVW	R1, 36(SP)	// r2
-	MOVW	$0, R0
-	MOVW	R0, 40(SP)	// errno
-	BL		runtime·exitsyscall(SB)
-	RET
+	JMP	syscall·Syscall6(SB)
 
-// func RawSyscall6(trap uintptr, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2, err uintptr);
-// Actually RawSyscall5 but the rest of the code expects it to be named RawSyscall6.
-TEXT	·RawSyscall6(SB),NOSPLIT,$0-40
-	MOVW	4(SP), R7	// syscall entry
-	MOVW	8(SP), R0
-	MOVW	12(SP), R1
-	MOVW	16(SP), R2
-	MOVW	20(SP), R3
-	MOVW	24(SP), R4
-	MOVW	28(SP), R5
-	SWI		$0
-	MOVW	$0xfffff001, R6
-	CMP		R6, R0
-	BLS		ok2
-	MOVW	$-1, R1
-	MOVW	R1, 32(SP)	// r1
-	MOVW	$0, R2
-	MOVW	R2, 36(SP)	// r2
-	RSB		$0, R0, R0
-	MOVW	R0, 40(SP)	// errno
-	RET
-ok2:
-	MOVW	R0, 32(SP) // r1
-	MOVW	R1, 36(SP)	// r2
-	MOVW	$0, R0
-	MOVW	R0, 40(SP)	// errno
-	RET
-
-#define SYS__LLSEEK 140  /* from zsysnum_linux_arm.go */
-// func seek(fd int, offset int64, whence int) (newoffset int64, errno int)
-// Implemented in assembly to avoid allocation when
-// taking the address of the return value newoffset.
-// Underlying system call is
-//	llseek(int fd, int offhi, int offlo, int64 *result, int whence)
-TEXT ·seek(SB),NOSPLIT,$0-32
-	BL	runtime·entersyscall(SB)
-	MOVW	$SYS__LLSEEK, R7	// syscall entry
-	MOVW	4(SP), R0	// fd
-	MOVW	12(SP), R1	// offset-high
-	MOVW	8(SP), R2	// offset-low
-	MOVW	$20(SP), R3
-	MOVW	16(SP), R4	// whence
-	SWI	$0
-	MOVW	$0xfffff001, R6
-	CMP	R6, R0
-	BLS	okseek
-	MOVW	$0, R1
-	MOVW	R1, 20(SP)
-	MOVW	R1, 24(SP)
-	RSB	$0, R0, R0
-	MOVW	R0, 28(SP)	// errno
-	BL	runtime·exitsyscall(SB)
-	RET
-okseek:
-	// system call filled in newoffset already
-	MOVW	$0, R0
-	MOVW	R0, 28(SP)	// errno
-	BL	runtime·exitsyscall(SB)
-	RET	
-
-// func RawSyscall(trap uintptr, a1, a2, a3 uintptr) (r1, r2, err uintptr);
 TEXT ·RawSyscall(SB),NOSPLIT,$0-28
-	MOVW	4(SP), R7	// syscall entry
-	MOVW	8(SP), R0
-	MOVW	12(SP), R1
-	MOVW	16(SP), R2
-	SWI		$0
-	MOVW	$0xfffff001, R1
-	CMP		R1, R0
-	BLS		ok1
-	MOVW	$-1, R1
-	MOVW	R1, 20(SP)	// r1
-	MOVW	$0, R2
-	MOVW	R2, 24(SP)	// r2
-	RSB		$0, R0, R0
-	MOVW	R0, 28(SP)	// errno
-	RET
-ok1:
-	MOVW	R0, 20(SP) // r1
-	MOVW	$0, R0
-	MOVW	R0, 24(SP)	// r2
-	MOVW	R0, 28(SP)	// errno
-	RET
+	JMP	syscall·RawSyscall(SB)
 
+TEXT	·RawSyscall6(SB),NOSPLIT,$0-40
+	JMP	syscall·RawSyscall6(SB)
+
+TEXT ·seek(SB),NOSPLIT,$0-32
+	JMP	syscall·seek(SB)
diff --git a/unix/asm_netbsd_386.s b/unix/asm_netbsd_386.s
index c5826325..682e4bd5 100644
--- a/unix/asm_netbsd_386.s
+++ b/unix/asm_netbsd_386.s
@@ -2,141 +2,26 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// TODO(rsc): Rewrite all nn(SP) references into name+(nn-8)(FP)
-// so that go vet can check that they are correct.
-
 #include "textflag.h"
 
 //
 // System call support for 386, NetBSD
 //
 
-// func Syscall(trap int32, a1, a2, a3 int32) (r1, r2, err int32);
-// func Syscall6(trap int32, a1, a2, a3, a4, a5, a6 int32) (r1, r2, err int32);
-// Trap # in AX, args on stack above caller pc.
+// Just jump to package syscall's implementation for all these functions.
+// The runtime may know about them.
 
 TEXT	·Syscall(SB),NOSPLIT,$0-28
-	CALL	runtime·entersyscall(SB)
-	MOVL	4(SP), AX	// syscall entry
-	// slide args down on top of system call number
-	LEAL		8(SP), SI
-	LEAL		4(SP), DI
-	CLD
-	MOVSL
-	MOVSL
-	MOVSL
-	INT	$0x80
-	JAE	ok
-	MOVL	$-1, 20(SP)	// r1
-	MOVL	$-1, 24(SP)	// r2
-	MOVL	AX, 28(SP)		// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
-ok:
-	MOVL	AX, 20(SP)	// r1
-	MOVL	DX, 24(SP)	// r2
-	MOVL	$0, 28(SP)	// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
+	JMP	syscall·Syscall(SB)
 
 TEXT	·Syscall6(SB),NOSPLIT,$0-40
-	CALL	runtime·entersyscall(SB)
-	MOVL	4(SP), AX	// syscall entry
-	// slide args down on top of system call number
-	LEAL		8(SP), SI
-	LEAL		4(SP), DI
-	CLD
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	INT	$0x80
-	JAE	ok6
-	MOVL	$-1, 32(SP)	// r1
-	MOVL	$-1, 36(SP)	// r2
-	MOVL	AX, 40(SP)		// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
-ok6:
-	MOVL	AX, 32(SP)	// r1
-	MOVL	DX, 36(SP)	// r2
-	MOVL	$0, 40(SP)	// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
+	JMP	syscall·Syscall6(SB)
 
 TEXT	·Syscall9(SB),NOSPLIT,$0-52
-	CALL	runtime·entersyscall(SB)
-	MOVL	4(SP), AX	// syscall entry
-	// slide args down on top of system call number
-	LEAL		8(SP), SI
-	LEAL		4(SP), DI
-	CLD
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	INT	$0x80
-	JAE	ok9
-	MOVL	$-1, 44(SP)	// r1
-	MOVL	$-1, 48(SP)	// r2
-	MOVL	AX, 52(SP)		// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
-ok9:
-	MOVL	AX, 44(SP)	// r1
-	MOVL	DX, 48(SP)	// r2
-	MOVL	$0, 52(SP)	// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
+	JMP	syscall·Syscall9(SB)
 
 TEXT ·RawSyscall(SB),NOSPLIT,$0-28
-	MOVL	4(SP), AX	// syscall entry
-	// slide args down on top of system call number
-	LEAL		8(SP), SI
-	LEAL		4(SP), DI
-	CLD
-	MOVSL
-	MOVSL
-	MOVSL
-	INT	$0x80
-	JAE	ok1
-	MOVL	$-1, 20(SP)	// r1
-	MOVL	$-1, 24(SP)	// r2
-	MOVL	AX, 28(SP)		// errno
-	RET
-ok1:
-	MOVL	AX, 20(SP)	// r1
-	MOVL	DX, 24(SP)	// r2
-	MOVL	$0, 28(SP)	// errno
-	RET
+	JMP	syscall·RawSyscall(SB)
 
 TEXT	·RawSyscall6(SB),NOSPLIT,$0-40
-	MOVL	4(SP), AX	// syscall entry
-	// slide args down on top of system call number
-	LEAL		8(SP), SI
-	LEAL		4(SP), DI
-	CLD
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	INT	$0x80
-	JAE	ok2
-	MOVL	$-1, 32(SP)	// r1
-	MOVL	$-1, 36(SP)	// r2
-	MOVL	AX, 40(SP)		// errno
-	RET
-ok2:
-	MOVL	AX, 32(SP)	// r1
-	MOVL	DX, 36(SP)	// r2
-	MOVL	$0, 40(SP)	// errno
-	RET
+	JMP	syscall·RawSyscall6(SB)
diff --git a/unix/asm_netbsd_amd64.s b/unix/asm_netbsd_amd64.s
index 8285382c..e80eaddb 100644
--- a/unix/asm_netbsd_amd64.s
+++ b/unix/asm_netbsd_amd64.s
@@ -2,134 +2,26 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// TODO(rsc): Rewrite all nn(SP) references into name+(nn-8)(FP)
-// so that go vet can check that they are correct.
-
 #include "textflag.h"
 
 //
 // System call support for AMD64, NetBSD
 //
 
-// func Syscall(trap int64, a1, a2, a3 int64) (r1, r2, err int64);
-// func Syscall6(trap int64, a1, a2, a3, a4, a5, a6 int64) (r1, r2, err int64);
-// func Syscall9(trap int64, a1, a2, a3, a4, a5, a6, a7, a8, a9 int64) (r1, r2, err int64);
-// Trap # in AX, args in DI SI DX, return in AX DX
+// Just jump to package syscall's implementation for all these functions.
+// The runtime may know about them.
 
 TEXT	·Syscall(SB),NOSPLIT,$0-56
-	CALL	runtime·entersyscall(SB)
-	MOVQ	8(SP), AX	// syscall entry
-	MOVQ	16(SP), DI
-	MOVQ	24(SP), SI
-	MOVQ	32(SP), DX
-	MOVQ	$0, R10
-	MOVQ	$0, R8
-	MOVQ	$0, R9
-	SYSCALL
-	JCC	ok
-	MOVQ	$-1, 40(SP)	// r1
-	MOVQ	$0, 48(SP)	// r2
-	MOVQ	AX, 56(SP)	// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
-ok:
-	MOVQ	AX, 40(SP)	// r1
-	MOVQ	DX, 48(SP)	// r2
-	MOVQ	$0, 56(SP)	// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
+	JMP	syscall·Syscall(SB)
 
 TEXT	·Syscall6(SB),NOSPLIT,$0-80
-	CALL	runtime·entersyscall(SB)
-	MOVQ	8(SP), AX	// syscall entry
-	MOVQ	16(SP), DI
-	MOVQ	24(SP), SI
-	MOVQ	32(SP), DX
-	MOVQ	40(SP), R10
-	MOVQ	48(SP), R8
-	MOVQ	56(SP), R9
-	SYSCALL
-	JCC	ok6
-	MOVQ	$-1, 64(SP)	// r1
-	MOVQ	$0, 72(SP)	// r2
-	MOVQ	AX, 80(SP)  	// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
-ok6:
-	MOVQ	AX, 64(SP)	// r1
-	MOVQ	DX, 72(SP)	// r2
-	MOVQ	$0, 80(SP)	// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
+	JMP	syscall·Syscall6(SB)
 
 TEXT	·Syscall9(SB),NOSPLIT,$0-104
-	CALL	runtime·entersyscall(SB)
-	MOVQ	8(SP), AX	// syscall entry
-	MOVQ	16(SP), DI
-	MOVQ	24(SP), SI
-	MOVQ	32(SP), DX
-	MOVQ	40(SP), R10
-	MOVQ	48(SP), R8
-	MOVQ	56(SP), R9
-	MOVQ	64(SP), R11
-	MOVQ	72(SP), R12
-	MOVQ	80(SP), R13
-	SUBQ    $32, SP
-	MOVQ	R11, 8(SP)	// arg 7
-	MOVQ	R12, 16(SP)	// arg 8
-	MOVQ	R13, 24(SP)	// arg 9
-	SYSCALL
-	JCC	ok9
-	ADDQ    $32, SP
-	MOVQ	$-1, 88(SP)	// r1
-	MOVQ	$0, 96(SP)	// r2
-	MOVQ	AX, 104(SP)	// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
-ok9:
-	ADDQ    $32, SP
-	MOVQ	AX, 88(SP)	// r1
-	MOVQ	DX, 96(SP)	// r2
-	MOVQ	$0, 104(SP)	// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
+	JMP	syscall·Syscall9(SB)
 
 TEXT	·RawSyscall(SB),NOSPLIT,$0-56
-	MOVQ	16(SP), DI
-	MOVQ	24(SP), SI
-	MOVQ	32(SP), DX
-	MOVQ	$0, R10
-	MOVQ	$0, R8
-	MOVQ	$0, R9
-	MOVQ	8(SP), AX	// syscall entry
-	SYSCALL
-	JCC	ok1
-	MOVQ	$-1, 40(SP)	// r1
-	MOVQ	$0, 48(SP)	// r2
-	MOVQ	AX, 56(SP)	// errno
-	RET
-ok1:
-	MOVQ	AX, 40(SP)	// r1
-	MOVQ	DX, 48(SP)	// r2
-	MOVQ	$0, 56(SP)	// errno
-	RET
+	JMP	syscall·RawSyscall(SB)
 
 TEXT	·RawSyscall6(SB),NOSPLIT,$0-80
-	MOVQ	16(SP), DI
-	MOVQ	24(SP), SI
-	MOVQ	32(SP), DX
-	MOVQ	40(SP), R10
-	MOVQ	48(SP), R8
-	MOVQ	56(SP), R9
-	MOVQ	8(SP), AX	// syscall entry
-	SYSCALL
-	JCC	ok2
-	MOVQ	$-1, 64(SP)	// r1
-	MOVQ	$0, 72(SP)	// r2
-	MOVQ	AX, 80(SP)	// errno
-	RET
-ok2:
-	MOVQ	AX, 64(SP)	// r1
-	MOVQ	DX, 72(SP)	// r2
-	MOVQ	$0, 80(SP)	// errno
-	RET
+	JMP	syscall·RawSyscall6(SB)
diff --git a/unix/asm_netbsd_arm.s b/unix/asm_netbsd_arm.s
index b0611804..11b5ab9c 100644
--- a/unix/asm_netbsd_arm.s
+++ b/unix/asm_netbsd_arm.s
@@ -8,119 +8,20 @@
 // System call support for ARM, NetBSD
 //
 
-// func Syscall(trap int32, a1, a2, a3 int32) (r1, r2, err int32);
-// func Syscall6(trap int32, a1, a2, a3, a4, a5, a6 int32) (r1, r2, err int32);
-// func Syscall9(trap int32, a1, a2, a3, a4, a5, a6, a7, a8, a9 int64) (r1, r2, err int32)
+// Just jump to package syscall's implementation for all these functions.
+// The runtime may know about them.
 
 TEXT	·Syscall(SB),NOSPLIT,$0-28
-	BL runtime·entersyscall(SB)
-	MOVW 0(FP), R0 // sigcall num
-	MOVW 4(FP), R1 // a1
-	MOVW 8(FP), R2 // a2
-	MOVW 12(FP), R3 // a3
-	SWI $0 // syscall
-	MOVW $0, R2
-	BCS error
-	MOVW R0, 16(FP) // r1
-	MOVW R1, 20(FP) // r2
-	MOVW R2, 24(FP) // err
-	BL runtime·exitsyscall(SB)
-	RET
-error:
-	MOVW $-1, R3
-	MOVW R3, 16(FP) // r1
-	MOVW R2, 20(FP) // r2
-	MOVW R0, 24(FP) // err
-	BL runtime·exitsyscall(SB)
-	RET
+	JMP	syscall·Syscall(SB)
 
 TEXT	·Syscall6(SB),NOSPLIT,$0-40
-	BL runtime·entersyscall(SB)
-	MOVW 0(FP), R0 // sigcall num
-	MOVW 4(FP), R1 // a1
-	MOVW 8(FP), R2 // a2
-	MOVW 12(FP), R3 // a3
-	MOVW R13, R4
-	MOVW $16(FP), R13 // a4 to a6 are passed on stack
-	SWI $0 // syscall
-	MOVW R4, R13
-	MOVW $0, R2
-	BCS error6
-	MOVW R0, 28(FP) // r1
-	MOVW R1, 32(FP) // r2
-	MOVW R2, 36(FP) // err
-	BL runtime·exitsyscall(SB)
-	RET
-error6:
-	MOVW $-1, R3
-	MOVW R3, 28(FP) // r1
-	MOVW R2, 32(FP) // r2
-	MOVW R0, 36(FP) // err
-	BL runtime·exitsyscall(SB)
-	RET
+	JMP	syscall·Syscall6(SB)
 
 TEXT	·Syscall9(SB),NOSPLIT,$0-52
-	BL runtime·entersyscall(SB)
-	MOVW 0(FP), R0 // sigcall num
-	MOVW 4(FP), R1 // a1
-	MOVW 8(FP), R2 // a2
-	MOVW 12(FP), R3 // a3
-	MOVW R13, R4
-	MOVW $16(FP), R13 // a4 to a9 are passed on stack
-	SWI $0 // syscall
-	MOVW R4, R13
-	MOVW $0, R2
-	BCS error9
-	MOVW R0, 40(FP) // r1
-	MOVW R1, 44(FP) // r2
-	MOVW R2, 48(FP) // err
-	BL runtime·exitsyscall(SB)
-	RET
-error9:
-	MOVW $-1, R3
-	MOVW R3, 40(FP) // r1
-	MOVW R2, 44(FP) // r2
-	MOVW R0, 48(FP) // err
-	BL runtime·exitsyscall(SB)
-	RET
+	JMP	syscall·Syscall9(SB)
 
 TEXT	·RawSyscall(SB),NOSPLIT,$0-28
-	MOVW 0(FP), R0 // sigcall num
-	MOVW 4(FP), R1 // a1
-	MOVW 8(FP), R2 // a2
-	MOVW 12(FP), R3 // a3
-	SWI $0 // syscall
-	MOVW $0, R2
-	BCS errorr
-	MOVW R0, 16(FP) // r1
-	MOVW R1, 20(FP) // r2
-	MOVW R2, 24(FP) // err
-	RET
-errorr:
-	MOVW $-1, R3
-	MOVW R3, 16(FP) // r1
-	MOVW R2, 20(FP) // r2
-	MOVW R0, 24(FP) // err
-	RET
+	JMP	syscall·RawSyscall(SB)
 
 TEXT	·RawSyscall6(SB),NOSPLIT,$0-40
-	MOVW 0(FP), R0 // sigcall num
-	MOVW 4(FP), R1 // a1
-	MOVW 8(FP), R2 // a2
-	MOVW 12(FP), R3 // a3
-	MOVW R13, R4
-	MOVW $16(FP), R13 // a4 to a9 are passed on stack
-	SWI $0 // syscall
-	MOVW R4, R13
-	MOVW $0, R2
-	BCS errorr6
-	MOVW R0, 28(FP) // r1
-	MOVW R1, 32(FP) // r2
-	MOVW R2, 36(FP) // err
-	RET
-errorr6:
-	MOVW $-1, R3
-	MOVW R3, 28(FP) // r1
-	MOVW R2, 32(FP) // r2
-	MOVW R0, 36(FP) // err
-	RET
+	JMP	syscall·RawSyscall6(SB)
diff --git a/unix/asm_openbsd_386.s b/unix/asm_openbsd_386.s
index 17fbb65c..65b0e42f 100644
--- a/unix/asm_openbsd_386.s
+++ b/unix/asm_openbsd_386.s
@@ -2,141 +2,26 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// TODO(rsc): Rewrite all nn(SP) references into name+(nn-8)(FP)
-// so that go vet can check that they are correct.
-
 #include "textflag.h"
 
 //
 // System call support for 386, OpenBSD
 //
 
-// func Syscall(trap int32, a1, a2, a3 int32) (r1, r2, err int32);
-// func Syscall6(trap int32, a1, a2, a3, a4, a5, a6 int32) (r1, r2, err int32);
-// Trap # in AX, args on stack above caller pc.
+// Just jump to package syscall's implementation for all these functions.
+// The runtime may know about them.
 
 TEXT	·Syscall(SB),NOSPLIT,$0-28
-	CALL	runtime·entersyscall(SB)
-	MOVL	4(SP), AX	// syscall entry
-	// slide args down on top of system call number
-	LEAL		8(SP), SI
-	LEAL		4(SP), DI
-	CLD
-	MOVSL
-	MOVSL
-	MOVSL
-	INT	$0x80
-	JAE	ok
-	MOVL	$-1, 20(SP)	// r1
-	MOVL	$-1, 24(SP)	// r2
-	MOVL	AX, 28(SP)		// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
-ok:
-	MOVL	AX, 20(SP)	// r1
-	MOVL	DX, 24(SP)	// r2
-	MOVL	$0, 28(SP)	// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
+	JMP	syscall·Syscall(SB)
 
 TEXT	·Syscall6(SB),NOSPLIT,$0-40
-	CALL	runtime·entersyscall(SB)
-	MOVL	4(SP), AX	// syscall entry
-	// slide args down on top of system call number
-	LEAL		8(SP), SI
-	LEAL		4(SP), DI
-	CLD
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	INT	$0x80
-	JAE	ok6
-	MOVL	$-1, 32(SP)	// r1
-	MOVL	$-1, 36(SP)	// r2
-	MOVL	AX, 40(SP)		// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
-ok6:
-	MOVL	AX, 32(SP)	// r1
-	MOVL	DX, 36(SP)	// r2
-	MOVL	$0, 40(SP)	// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
+	JMP	syscall·Syscall6(SB)
 
 TEXT	·Syscall9(SB),NOSPLIT,$0-52
-	CALL	runtime·entersyscall(SB)
-	MOVL	4(SP), AX	// syscall entry
-	// slide args down on top of system call number
-	LEAL		8(SP), SI
-	LEAL		4(SP), DI
-	CLD
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	INT	$0x80
-	JAE	ok9
-	MOVL	$-1, 44(SP)	// r1
-	MOVL	$-1, 48(SP)	// r2
-	MOVL	AX, 52(SP)		// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
-ok9:
-	MOVL	AX, 44(SP)	// r1
-	MOVL	DX, 48(SP)	// r2
-	MOVL	$0, 52(SP)	// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
+	JMP	syscall·Syscall9(SB)
 
 TEXT ·RawSyscall(SB),NOSPLIT,$0-28
-	MOVL	4(SP), AX	// syscall entry
-	// slide args down on top of system call number
-	LEAL		8(SP), SI
-	LEAL		4(SP), DI
-	CLD
-	MOVSL
-	MOVSL
-	MOVSL
-	INT	$0x80
-	JAE	ok1
-	MOVL	$-1, 20(SP)	// r1
-	MOVL	$-1, 24(SP)	// r2
-	MOVL	AX, 28(SP)		// errno
-	RET
-ok1:
-	MOVL	AX, 20(SP)	// r1
-	MOVL	DX, 24(SP)	// r2
-	MOVL	$0, 28(SP)	// errno
-	RET
+	JMP	syscall·RawSyscall(SB)
 
 TEXT	·RawSyscall6(SB),NOSPLIT,$0-40
-	MOVL	4(SP), AX	// syscall entry
-	// slide args down on top of system call number
-	LEAL		8(SP), SI
-	LEAL		4(SP), DI
-	CLD
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	MOVSL
-	INT	$0x80
-	JAE	ok2
-	MOVL	$-1, 32(SP)	// r1
-	MOVL	$-1, 36(SP)	// r2
-	MOVL	AX, 40(SP)		// errno
-	RET
-ok2:
-	MOVL	AX, 32(SP)	// r1
-	MOVL	DX, 36(SP)	// r2
-	MOVL	$0, 40(SP)	// errno
-	RET
+	JMP	syscall·RawSyscall6(SB)
diff --git a/unix/asm_openbsd_amd64.s b/unix/asm_openbsd_amd64.s
index fe61482c..55aada19 100644
--- a/unix/asm_openbsd_amd64.s
+++ b/unix/asm_openbsd_amd64.s
@@ -2,134 +2,26 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
-// TODO(rsc): Rewrite all nn(SP) references into name+(nn-8)(FP)
-// so that go vet can check that they are correct.
-
 #include "textflag.h"
 
 //
 // System call support for AMD64, OpenBSD
 //
 
-// func Syscall(trap int64, a1, a2, a3 int64) (r1, r2, err int64);
-// func Syscall6(trap int64, a1, a2, a3, a4, a5, a6 int64) (r1, r2, err int64);
-// func Syscall9(trap int64, a1, a2, a3, a4, a5, a6, a7, a8, a9 int64) (r1, r2, err int64);
-// Trap # in AX, args in DI SI DX, return in AX DX
+// Just jump to package syscall's implementation for all these functions.
+// The runtime may know about them.
 
 TEXT	·Syscall(SB),NOSPLIT,$0-56
-	CALL	runtime·entersyscall(SB)
-	MOVQ	8(SP), AX	// syscall entry
-	MOVQ	16(SP), DI
-	MOVQ	24(SP), SI
-	MOVQ	32(SP), DX
-	MOVQ	$0, R10
-	MOVQ	$0, R8
-	MOVQ	$0, R9
-	SYSCALL
-	JCC	ok
-	MOVQ	$-1, 40(SP)	// r1
-	MOVQ	$0, 48(SP)	// r2
-	MOVQ	AX, 56(SP)	// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
-ok:
-	MOVQ	AX, 40(SP)	// r1
-	MOVQ	DX, 48(SP)	// r2
-	MOVQ	$0, 56(SP)	// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
+	JMP	syscall·Syscall(SB)
 
 TEXT	·Syscall6(SB),NOSPLIT,$0-80
-	CALL	runtime·entersyscall(SB)
-	MOVQ	8(SP), AX	// syscall entry
-	MOVQ	16(SP), DI
-	MOVQ	24(SP), SI
-	MOVQ	32(SP), DX
-	MOVQ	40(SP), R10
-	MOVQ	48(SP), R8
-	MOVQ	56(SP), R9
-	SYSCALL
-	JCC	ok6
-	MOVQ	$-1, 64(SP)	// r1
-	MOVQ	$0, 72(SP)	// r2
-	MOVQ	AX, 80(SP)  	// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
-ok6:
-	MOVQ	AX, 64(SP)	// r1
-	MOVQ	DX, 72(SP)	// r2
-	MOVQ	$0, 80(SP)	// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
+	JMP	syscall·Syscall6(SB)
 
 TEXT	·Syscall9(SB),NOSPLIT,$0-104
-	CALL	runtime·entersyscall(SB)
-	MOVQ	8(SP), AX	// syscall entry
-	MOVQ	16(SP), DI
-	MOVQ	24(SP), SI
-	MOVQ	32(SP), DX
-	MOVQ	40(SP), R10
-	MOVQ	48(SP), R8
-	MOVQ	56(SP), R9
-	MOVQ	64(SP), R11
-	MOVQ	72(SP), R12
-	MOVQ	80(SP), R13
-	SUBQ    $32, SP
-	MOVQ	R11, 8(SP)	// arg 7
-	MOVQ	R12, 16(SP)	// arg 8
-	MOVQ	R13, 24(SP)	// arg 9
-	SYSCALL
-	JCC	ok9
-	ADDQ    $32, SP
-	MOVQ	$-1, 88(SP)	// r1
-	MOVQ	$0, 96(SP)	// r2
-	MOVQ	AX, 104(SP)	// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
-ok9:
-	ADDQ    $32, SP
-	MOVQ	AX, 88(SP)	// r1
-	MOVQ	DX, 96(SP)	// r2
-	MOVQ	$0, 104(SP)	// errno
-	CALL	runtime·exitsyscall(SB)
-	RET
+	JMP	syscall·Syscall9(SB)
 
 TEXT	·RawSyscall(SB),NOSPLIT,$0-56
-	MOVQ	16(SP), DI
-	MOVQ	24(SP), SI
-	MOVQ	32(SP), DX
-	MOVQ	$0, R10
-	MOVQ	$0, R8
-	MOVQ	$0, R9
-	MOVQ	8(SP), AX	// syscall entry
-	SYSCALL
-	JCC	ok1
-	MOVQ	$-1, 40(SP)	// r1
-	MOVQ	$0, 48(SP)	// r2
-	MOVQ	AX, 56(SP)	// errno
-	RET
-ok1:
-	MOVQ	AX, 40(SP)	// r1
-	MOVQ	DX, 48(SP)	// r2
-	MOVQ	$0, 56(SP)	// errno
-	RET
+	JMP	syscall·RawSyscall(SB)
 
 TEXT	·RawSyscall6(SB),NOSPLIT,$0-80
-	MOVQ	16(SP), DI
-	MOVQ	24(SP), SI
-	MOVQ	32(SP), DX
-	MOVQ	40(SP), R10
-	MOVQ	48(SP), R8
-	MOVQ	56(SP), R9
-	MOVQ	8(SP), AX	// syscall entry
-	SYSCALL
-	JCC	ok2
-	MOVQ	$-1, 64(SP)	// r1
-	MOVQ	$0, 72(SP)	// r2
-	MOVQ	AX, 80(SP)	// errno
-	RET
-ok2:
-	MOVQ	AX, 64(SP)	// r1
-	MOVQ	DX, 72(SP)	// r2
-	MOVQ	$0, 80(SP)	// errno
-	RET
+	JMP	syscall·RawSyscall6(SB)