From ab04129b5a4a835b9c9c3dc3ecf0fcade347820a Mon Sep 17 00:00:00 2001
From: Philip Silva <philip.silva@protonmail.com>
Date: Wed, 28 Dec 2022 15:14:32 +0000
Subject: [PATCH 01/19] Port to plan9/arm64

---
 src/cmd/dist/build.go                         |   1 +
 src/cmd/go/internal/work/exec.go              |   1 +
 src/cmd/internal/obj/objfile.go               |   1 -
 src/cmd/internal/objfile/plan9obj.go          |   2 +
 src/cmd/link/internal/arm64/obj.go            |  11 +-
 src/cmd/link/internal/ld/main.go              |   2 +-
 src/cmd/link/internal/ld/symtab.go            |   2 +-
 .../golang.org/x/sys/plan9/asm_plan9_arm64.s  |  24 ++
 .../x/sys/plan9/zsyscall_plan9_arm64.go       | 286 ++++++++++++++++++
 src/debug/buildinfo/buildinfo.go              |   2 +-
 src/debug/plan9obj/file.go                    |   2 +-
 src/debug/plan9obj/plan9obj.go                |   1 +
 src/runtime/defs_plan9_arm64.go               |  99 ++++++
 src/runtime/os_plan9_arm64.go                 |   8 +
 src/runtime/rt0_plan9_arm64.s                 |  12 +
 src/runtime/sys_plan9_arm64.s                 | 269 ++++++++++++++++
 src/runtime/tls_arm64.h                       |   4 +
 src/syscall/asm_plan9_arm.s                   |   2 +
 src/syscall/asm_plan9_arm64.s                 | 210 +++++++++++++
 src/syscall/zsyscall_plan9_arm64.go           | 284 +++++++++++++++++
 20 files changed, 1216 insertions(+), 7 deletions(-)
 create mode 100644 src/cmd/vendor/golang.org/x/sys/plan9/asm_plan9_arm64.s
 create mode 100644 src/cmd/vendor/golang.org/x/sys/plan9/zsyscall_plan9_arm64.go
 create mode 100644 src/runtime/defs_plan9_arm64.go
 create mode 100644 src/runtime/os_plan9_arm64.go
 create mode 100644 src/runtime/rt0_plan9_arm64.s
 create mode 100644 src/runtime/sys_plan9_arm64.s
 create mode 100644 src/syscall/asm_plan9_arm64.s
 create mode 100644 src/syscall/zsyscall_plan9_arm64.go

diff --git a/src/cmd/dist/build.go b/src/cmd/dist/build.go
index 2b382a1c025649..2b4818cc893198 100644
--- a/src/cmd/dist/build.go
+++ b/src/cmd/dist/build.go
@@ -1811,6 +1811,7 @@ var cgoEnabled = map[string]bool{
 	"plan9/386":       false,
 	"plan9/amd64":     false,
 	"plan9/arm":       false,
+	"plan9/arm64":     false,
 	"solaris/amd64":   true,
 	"windows/386":     true,
 	"windows/amd64":   true,
diff --git a/src/cmd/go/internal/work/exec.go b/src/cmd/go/internal/work/exec.go
index 0c9e96aebbf080..ce078ffd2b1f99 100644
--- a/src/cmd/go/internal/work/exec.go
+++ b/src/cmd/go/internal/work/exec.go
@@ -2075,6 +2075,7 @@ var objectMagic = [][]byte{
 	{0x00, 0x00, 0x01, 0xEB},                  // Plan 9 i386
 	{0x00, 0x00, 0x8a, 0x97},                  // Plan 9 amd64
 	{0x00, 0x00, 0x06, 0x47},                  // Plan 9 arm
+	{0x00, 0x00, 0x8c, 0x47},                  // Plan 9 arm64
 	{0x00, 0x61, 0x73, 0x6D},                  // WASM
 	{0x01, 0xDF},                              // XCOFF 32bit
 	{0x01, 0xF7},                              // XCOFF 64bit
diff --git a/src/cmd/internal/obj/objfile.go b/src/cmd/internal/obj/objfile.go
index 4401f1bb74e0a9..1aaa15764d7c35 100644
--- a/src/cmd/internal/obj/objfile.go
+++ b/src/cmd/internal/obj/objfile.go
@@ -30,7 +30,6 @@ const UnlinkablePkg = "<unlinkable>" // invalid package path, used when compiled
 
 // Entry point of writing new object file.
 func WriteObjFile(ctxt *Link, b *bio.Writer) {
-
 	debugAsmEmit(ctxt)
 
 	genFuncInfoSyms(ctxt)
diff --git a/src/cmd/internal/objfile/plan9obj.go b/src/cmd/internal/objfile/plan9obj.go
index edd40230cec0c2..f9801c07aaa9c2 100644
--- a/src/cmd/internal/objfile/plan9obj.go
+++ b/src/cmd/internal/objfile/plan9obj.go
@@ -137,6 +137,8 @@ func (f *plan9File) goarch() string {
 		return "amd64"
 	case plan9obj.MagicARM:
 		return "arm"
+	case plan9obj.MagicARM64:
+		return "arm64"
 	}
 	return ""
 }
diff --git a/src/cmd/link/internal/arm64/obj.go b/src/cmd/link/internal/arm64/obj.go
index 3d358155badbca..45d3317780dd1e 100644
--- a/src/cmd/link/internal/arm64/obj.go
+++ b/src/cmd/link/internal/arm64/obj.go
@@ -47,6 +47,9 @@ func Init() (*sys.Arch, ld.Arch) {
 		Dwarfreglr: dwarfRegLR,
 		TrampLimit: 0x7c00000, // 26-bit signed offset * 4, leave room for PLT etc.
 
+		Plan9Magic:  0x8c47,
+		Plan9_64Bit: true,
+
 		Adddynrel:        adddynrel,
 		Archinit:         archinit,
 		Archreloc:        archreloc,
@@ -85,9 +88,13 @@ func archinit(ctxt *ld.Link) {
 		ld.Exitf("unknown -H option: %v", ctxt.HeadType)
 
 	case objabi.Hplan9: /* plan 9 */
-		ld.HEADR = 32
+		ld.HEADR = 32 + 8
+
+		if *ld.FlagTextAddr == -1 {
+			*ld.FlagTextAddr = 0x10000 + int64(ld.HEADR)
+		}
 		if *ld.FlagRound == -1 {
-			*ld.FlagRound = 4096
+			*ld.FlagRound = 0x10000
 		}
 		if *ld.FlagTextAddr == -1 {
 			*ld.FlagTextAddr = ld.Rnd(4096, *ld.FlagRound) + int64(ld.HEADR)
diff --git a/src/cmd/link/internal/ld/main.go b/src/cmd/link/internal/ld/main.go
index d913953944bc43..8fee98190c40f5 100644
--- a/src/cmd/link/internal/ld/main.go
+++ b/src/cmd/link/internal/ld/main.go
@@ -193,7 +193,7 @@ func Main(arch *sys.Arch, theArch Arch) {
 	addstrdata1(ctxt, "runtime.buildVersion="+buildVersion)
 
 	// TODO(matloob): define these above and then check flag values here
-	if ctxt.Arch.Family == sys.AMD64 && buildcfg.GOOS == "plan9" {
+	if (ctxt.Arch.Family == sys.AMD64 || ctxt.Arch.Family == sys.ARM64) && buildcfg.GOOS == "plan9" {
 		flag.BoolVar(&flag8, "8", false, "use 64-bit addresses in symbol table")
 	}
 	flagHeadType := flag.String("H", "", "set header `type`")
diff --git a/src/cmd/link/internal/ld/symtab.go b/src/cmd/link/internal/ld/symtab.go
index a0345ca1c7b7b7..dd2a16bd956283 100644
--- a/src/cmd/link/internal/ld/symtab.go
+++ b/src/cmd/link/internal/ld/symtab.go
@@ -294,7 +294,7 @@ func putplan9sym(ctxt *Link, ldr *loader.Loader, s loader.Sym, char SymbolType)
 	}
 	l := 4
 	addr := ldr.SymValue(s)
-	if ctxt.IsAMD64() && !flag8 {
+	if (ctxt.IsAMD64() || ctxt.IsARM64()) && !flag8 {
 		ctxt.Out.Write32b(uint32(addr >> 32))
 		l = 8
 	}
diff --git a/src/cmd/vendor/golang.org/x/sys/plan9/asm_plan9_arm64.s b/src/cmd/vendor/golang.org/x/sys/plan9/asm_plan9_arm64.s
new file mode 100644
index 00000000000000..f215c739b670df
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/sys/plan9/asm_plan9_arm64.s
@@ -0,0 +1,24 @@
+#include "textflag.h"
+
+// System call support for plan9 on arm64
+
+// Just jump to package syscall's implementation for all these functions.
+// The runtime may know about them.
+
+TEXT ·Syscall(SB),NOSPLIT,$0-64
+	JMP	syscall·Syscall(SB)
+
+TEXT ·Syscall6(SB),NOSPLIT,$0-88
+	JMP	syscall·Syscall6(SB)
+
+TEXT ·RawSyscall(SB),NOSPLIT,$0-56
+	JMP	syscall·RawSyscall(SB)
+
+TEXT ·RawSyscall6(SB),NOSPLIT,$0-80
+	JMP	syscall·RawSyscall6(SB)
+
+TEXT ·seek(SB),NOSPLIT,$0-56
+	JMP	syscall·seek(SB)
+
+TEXT ·exit(SB),NOSPLIT,$8-8
+	JMP	syscall·exit(SB)
diff --git a/src/cmd/vendor/golang.org/x/sys/plan9/zsyscall_plan9_arm64.go b/src/cmd/vendor/golang.org/x/sys/plan9/zsyscall_plan9_arm64.go
new file mode 100644
index 00000000000000..dd0265ac7aedf6
--- /dev/null
+++ b/src/cmd/vendor/golang.org/x/sys/plan9/zsyscall_plan9_arm64.go
@@ -0,0 +1,286 @@
+// go run mksyscall.go -l32 -plan9 -tags plan9,arm64 syscall_plan9.go
+// Code generated by the command above; DO NOT EDIT.
+
+//go:build plan9 && arm64
+// +build plan9,arm64
+
+package plan9
+
+import "unsafe"
+
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func fd2path(fd int, buf []byte) (err error) {
+	var _p0 unsafe.Pointer
+	if len(buf) > 0 {
+		_p0 = unsafe.Pointer(&buf[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := Syscall(SYS_FD2PATH, uintptr(fd), uintptr(_p0), uintptr(len(buf)))
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func pipe(p *[2]int32) (err error) {
+	r0, _, e1 := Syscall(SYS_PIPE, uintptr(unsafe.Pointer(p)), 0, 0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func await(s []byte) (n int, err error) {
+	var _p0 unsafe.Pointer
+	if len(s) > 0 {
+		_p0 = unsafe.Pointer(&s[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := Syscall(SYS_AWAIT, uintptr(_p0), uintptr(len(s)), 0)
+	n = int(r0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func open(path string, mode int) (fd int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall(SYS_OPEN, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+	fd = int(r0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func create(path string, mode int, perm uint32) (fd int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall(SYS_CREATE, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
+	fd = int(r0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func remove(path string) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall(SYS_REMOVE, uintptr(unsafe.Pointer(_p0)), 0, 0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func stat(path string, edir []byte) (n int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	var _p1 unsafe.Pointer
+	if len(edir) > 0 {
+		_p1 = unsafe.Pointer(&edir[0])
+	} else {
+		_p1 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := Syscall(SYS_STAT, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(edir)))
+	n = int(r0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func bind(name string, old string, flag int) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(name)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(old)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall(SYS_BIND, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(flag))
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func mount(fd int, afd int, old string, flag int, aname string) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(old)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(aname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_MOUNT, uintptr(fd), uintptr(afd), uintptr(unsafe.Pointer(_p0)), uintptr(flag), uintptr(unsafe.Pointer(_p1)), 0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func wstat(path string, edir []byte) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	var _p1 unsafe.Pointer
+	if len(edir) > 0 {
+		_p1 = unsafe.Pointer(&edir[0])
+	} else {
+		_p1 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := Syscall(SYS_WSTAT, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(edir)))
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func chdir(path string) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall(SYS_CHDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Dup(oldfd int, newfd int) (fd int, err error) {
+	r0, _, e1 := Syscall(SYS_DUP, uintptr(oldfd), uintptr(newfd), 0)
+	fd = int(r0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Pread(fd int, p []byte, offset int64) (n int, err error) {
+	var _p0 unsafe.Pointer
+	if len(p) > 0 {
+		_p0 = unsafe.Pointer(&p[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := Syscall6(SYS_PREAD, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
+	n = int(r0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
+	var _p0 unsafe.Pointer
+	if len(p) > 0 {
+		_p0 = unsafe.Pointer(&p[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := Syscall6(SYS_PWRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
+	n = int(r0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Close(fd int) (err error) {
+	r0, _, e1 := Syscall(SYS_CLOSE, uintptr(fd), 0, 0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Fstat(fd int, edir []byte) (n int, err error) {
+	var _p0 unsafe.Pointer
+	if len(edir) > 0 {
+		_p0 = unsafe.Pointer(&edir[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := Syscall(SYS_FSTAT, uintptr(fd), uintptr(_p0), uintptr(len(edir)))
+	n = int(r0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Fwstat(fd int, edir []byte) (err error) {
+	var _p0 unsafe.Pointer
+	if len(edir) > 0 {
+		_p0 = unsafe.Pointer(&edir[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := Syscall(SYS_FWSTAT, uintptr(fd), uintptr(_p0), uintptr(len(edir)))
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
diff --git a/src/debug/buildinfo/buildinfo.go b/src/debug/buildinfo/buildinfo.go
index d202d5050a2786..3ceb23cfffe546 100644
--- a/src/debug/buildinfo/buildinfo.go
+++ b/src/debug/buildinfo/buildinfo.go
@@ -274,7 +274,7 @@ func hasPlan9Magic(magic []byte) bool {
 	if len(magic) >= 4 {
 		m := binary.BigEndian.Uint32(magic)
 		switch m {
-		case plan9obj.Magic386, plan9obj.MagicAMD64, plan9obj.MagicARM:
+		case plan9obj.Magic386, plan9obj.MagicAMD64, plan9obj.MagicARM, plan9obj.MagicARM64:
 			return true
 		}
 	}
diff --git a/src/debug/plan9obj/file.go b/src/debug/plan9obj/file.go
index 0880c3cc182003..022c74427101aa 100644
--- a/src/debug/plan9obj/file.go
+++ b/src/debug/plan9obj/file.go
@@ -130,7 +130,7 @@ func (f *File) Close() error {
 func parseMagic(magic []byte) (uint32, error) {
 	m := binary.BigEndian.Uint32(magic)
 	switch m {
-	case Magic386, MagicAMD64, MagicARM:
+	case Magic386, MagicAMD64, MagicARM, MagicARM64:
 		return m, nil
 	}
 	return 0, &formatError{0, "bad magic number", magic}
diff --git a/src/debug/plan9obj/plan9obj.go b/src/debug/plan9obj/plan9obj.go
index 7a194514c2c719..98e97a26820240 100644
--- a/src/debug/plan9obj/plan9obj.go
+++ b/src/debug/plan9obj/plan9obj.go
@@ -33,4 +33,5 @@ const (
 	Magic386   = (4*11+0)*11 + 7
 	MagicAMD64 = (4*26+0)*26 + 7 + Magic64
 	MagicARM   = (4*20+0)*20 + 7
+	MagicARM64 = (4*28+0)*28 + 7 + Magic64
 )
diff --git a/src/runtime/defs_plan9_arm64.go b/src/runtime/defs_plan9_arm64.go
new file mode 100644
index 00000000000000..8d979ccef2565b
--- /dev/null
+++ b/src/runtime/defs_plan9_arm64.go
@@ -0,0 +1,99 @@
+package runtime
+
+const _PAGESHIFT = 16
+const _PAGESIZE = 1 << _PAGESHIFT
+
+type ureg struct {
+	/* AArch64 registers */
+	r0  uint64 /* general registers */
+	r1  uint64 /* ... */
+	r2  uint64 /* ... */
+	r3  uint64 /* ... */
+	r4  uint64 /* ... */
+	r5  uint64 /* ... */
+	r6  uint64 /* ... */
+	r7  uint64 /* ... */
+	r8  uint64 /* ... */
+	r9  uint64 /* ... */
+	r10 uint64 /* ... */
+	r11 uint64 /* ... */
+	r12 uint64 /* ... */
+	r13 uint64 /* ... */
+	r14 uint64 /* ... */
+	r15 uint64 /* ... */
+	r16 uint64 /* ... */
+	r17 uint64 /* ... */
+	r18 uint64 /* ... */
+	r19 uint64 /* ... */
+	r20 uint64 /* ... */
+	r21 uint64 /* ... */
+	r22 uint64 /* ... */
+	r23 uint64 /* ... */
+	r24 uint64 /* ... */
+	r25 uint64 /* ... */
+	r26 uint64 /* ... */
+	r27 uint64 /* ... */
+	r28 uint64 /* ... */
+	r29 uint64 /* ... */
+	r30 uint64 /* link (lr) */
+	sp  uint64
+	pc  uint64 /* interrupted addr */
+	psr uint64
+	typ uint64 /* of exception */
+}
+
+type sigctxt struct {
+	u *ureg
+}
+
+//go:nosplit
+//go:nowritebarrierrec
+func (c *sigctxt) pc() uintptr { return uintptr(c.u.pc) }
+
+func (c *sigctxt) sp() uintptr { return uintptr(c.u.sp) }
+func (c *sigctxt) lr() uintptr { return uintptr(c.u.r30) }
+
+func (c *sigctxt) setpc(x uintptr)  { c.u.pc = uint64(x) }
+func (c *sigctxt) setsp(x uintptr)  { c.u.sp = uint64(x) }
+func (c *sigctxt) setlr(x uintptr)  { c.u.r30 = uint64(x) }
+func (c *sigctxt) savelr(x uintptr) { c.u.r0 = uint64(x) }
+
+func dumpregs(u *ureg) {
+	print("r0    ", hex(u.r0), "\n")
+	print("r1    ", hex(u.r1), "\n")
+	print("r2    ", hex(u.r2), "\n")
+	print("r3    ", hex(u.r3), "\n")
+	print("r4    ", hex(u.r4), "\n")
+	print("r5    ", hex(u.r5), "\n")
+	print("r6    ", hex(u.r6), "\n")
+	print("r7    ", hex(u.r7), "\n")
+	print("r8    ", hex(u.r8), "\n")
+	print("r9    ", hex(u.r9), "\n")
+	print("r10   ", hex(u.r10), "\n")
+	print("r11   ", hex(u.r11), "\n")
+	print("r12   ", hex(u.r12), "\n")
+	print("r13    ", hex(u.r13), "\n")
+	print("r14    ", hex(u.r14), "\n")
+	print("r15    ", hex(u.r15), "\n")
+	print("r16    ", hex(u.r16), "\n")
+	print("r17    ", hex(u.r17), "\n")
+	print("r18    ", hex(u.r18), "\n")
+	print("r19    ", hex(u.r19), "\n")
+	print("r20   ", hex(u.r20), "\n")
+	print("r21   ", hex(u.r21), "\n")
+	print("r22   ", hex(u.r22), "\n")
+	print("r23    ", hex(u.r23), "\n")
+	print("r24    ", hex(u.r24), "\n")
+	print("r25    ", hex(u.r25), "\n")
+	print("r26    ", hex(u.r26), "\n")
+	print("r27    ", hex(u.r27), "\n")
+	print("r28    ", hex(u.r28), "\n")
+	print("r29    ", hex(u.r29), "\n")
+	print("r30   ", hex(u.r30), "\n")
+	print("sp    ", hex(u.sp), "\n")
+	print("pc  ", hex(u.pc), "\n")
+	print("psr   ", hex(u.psr), "\n")
+	print("type    ", hex(u.typ), "\n")
+}
+
+func sigpanictramp()
diff --git a/src/runtime/os_plan9_arm64.go b/src/runtime/os_plan9_arm64.go
new file mode 100644
index 00000000000000..5ce48beb18b825
--- /dev/null
+++ b/src/runtime/os_plan9_arm64.go
@@ -0,0 +1,8 @@
+package runtime
+
+//go:nosplit
+func cputicks() int64 {
+	// Currently cputicks() is used in blocking profiler and to seed runtime·fastrand().
+	// runtime·nanotime() is a poor approximation of CPU ticks that is enough for the profiler.
+	return nanotime()
+}
diff --git a/src/runtime/rt0_plan9_arm64.s b/src/runtime/rt0_plan9_arm64.s
new file mode 100644
index 00000000000000..f4cff8515b8b12
--- /dev/null
+++ b/src/runtime/rt0_plan9_arm64.s
@@ -0,0 +1,12 @@
+#include "textflag.h"
+
+//in plan 9 argc is at top of stack followed by ptrs to arguments
+
+TEXT _rt0_arm64_plan9(SB),NOSPLIT|NOFRAME,$0
+	MOVD	R0, _tos(SB)
+	MOVD	0(RSP), R0
+	MOVD	$8(RSP), R1
+	MOVD	$runtime·rt0_go(SB), R2
+	BL	(R2)
+
+GLOBL _tos(SB), NOPTR, $8
diff --git a/src/runtime/sys_plan9_arm64.s b/src/runtime/sys_plan9_arm64.s
new file mode 100644
index 00000000000000..e0025e73825e2c
--- /dev/null
+++ b/src/runtime/sys_plan9_arm64.s
@@ -0,0 +1,269 @@
+#include "go_asm.h"
+#include "go_tls.h"
+#include "textflag.h"
+
+// from ../syscall/zsysnum_plan9.go
+
+#define SYS_SYSR1       0
+#define SYS_BIND        2
+#define SYS_CHDIR       3
+#define SYS_CLOSE       4
+#define SYS_DUP         5
+#define SYS_ALARM       6
+#define SYS_EXEC        7
+#define SYS_EXITS       8
+#define SYS_FAUTH       10
+#define SYS_SEGBRK      12
+#define SYS_OPEN        14
+#define SYS_OSEEK       16
+#define SYS_SLEEP       17
+#define SYS_RFORK       19
+#define SYS_PIPE        21
+#define SYS_CREATE      22
+#define SYS_FD2PATH     23
+#define SYS_BRK_        24
+#define SYS_REMOVE      25
+#define SYS_NOTIFY      28
+#define SYS_NOTED       29
+#define SYS_SEGATTACH   30
+#define SYS_SEGDETACH   31
+#define SYS_SEGFREE     32
+#define SYS_SEGFLUSH    33
+#define SYS_RENDEZVOUS  34
+#define SYS_UNMOUNT     35
+#define SYS_SEMACQUIRE  37
+#define SYS_SEMRELEASE  38
+#define SYS_SEEK        39
+#define SYS_FVERSION    40
+#define SYS_ERRSTR      41
+#define SYS_STAT        42
+#define SYS_FSTAT       43
+#define SYS_WSTAT       44
+#define SYS_FWSTAT      45
+#define SYS_MOUNT       46
+#define SYS_AWAIT       47
+#define SYS_PREAD       50
+#define SYS_PWRITE      51
+#define SYS_TSEMACQUIRE 52
+#define SYS_NSEC        53
+
+//func open(name *byte, mode int, perm int32) int
+TEXT runtime·open(SB),NOSPLIT,$0-20
+	MOVD    $SYS_OPEN, R0
+	SVC	$0
+	MOVWU	R0, ret+16(FP)
+	RET
+
+//func pread(fd int32, buf unsafe.Pointer, nbytes int32, offset int64) int32
+TEXT runtime·pread(SB),NOSPLIT,$0-36
+	MOVD    $SYS_PREAD, R0
+	SVC	$0
+	MOVWU	R0, ret+32(FP)
+	RET
+
+//func pwrite(fd int64, buf unsafe.Pointer, nbytes int64, offset int64) int
+TEXT runtime·pwrite(SB),NOSPLIT,$0-36
+	MOVD    $SYS_PWRITE, R0
+	SVC	$0
+	MOVWU	R0, ret+32(FP)
+	RET
+
+//func seek(fd int64, offset int64, whence int32) int64
+// the actual syscall:
+// // int32 _seek(int64*, int32, int64, int32)
+TEXT runtime·seek(SB),NOSPLIT,$0-32
+	MOVD	$ret+24(FP), R0
+	MOVWU	fd+0(FP), R2
+	MOVD	offset+8(FP), R3
+	MOVWU	whence+16(FP), R4
+
+	MOVD    $sysargs-0(SP), R1
+
+	MOVD	R0, 8(R1)
+	MOVWU	R2, 16(R1)
+	MOVD	R3, 24(R1)
+	MOVWU	R4, 32(R1)
+
+	MOVD	$SYS_SEEK, R0
+	SVC	$0
+
+	CMP	$-1, R0
+	BNE	2(PC)
+	MOVD	R0, ret+24(FP)
+	RET
+
+//func closefd(fd int64) int64
+TEXT runtime·closefd(SB),NOSPLIT,$0-12
+	MOVD	$SYS_CLOSE, R0
+	SVC	$0
+	MOVWU	R0, ret+8(FP)
+	RET
+
+//func exits(msg *byte)
+TEXT runtime·exits(SB),NOSPLIT,$0-8
+	MOVD    $SYS_EXITS, R0
+	SVC	$0
+	RET
+
+//func brk_(addr unsafe.Pointer) int32
+TEXT runtime·brk_(SB),NOSPLIT,$0-12
+	MOVD    $SYS_BRK_, R0
+	SVC	$0
+	MOVD	R0, ret+8(FP)
+	RET
+
+//func sleep(ms int32) int32
+TEXT runtime·sleep(SB),NOSPLIT,$0-12
+	MOVD    $SYS_SLEEP, R0
+	SVC	$0
+	MOVD	R0, ret+8(FP)
+	RET
+
+//func plan9_semacquire(addr *uint64, block int64) int64
+TEXT runtime·plan9_semacquire(SB),NOSPLIT,$0-20
+	MOVD	$SYS_SEMACQUIRE, R0
+	SVC	$0
+	MOVD	R0, ret+16(FP)
+	RET
+
+//func plan9_tsemacquire(addr *uint64, ms int32) int64
+TEXT runtime·plan9_tsemacquire(SB),NOSPLIT,$0-20
+	MOVD	$SYS_TSEMACQUIRE, R0
+	SVC	$0
+	MOVD	R0, ret+16(FP)
+	RET
+
+//func nsec(*int64) int64
+TEXT runtime·nsec(SB),NOSPLIT|NOFRAME,$0-16
+	MOVD	$SYS_NSEC, R0
+	SVC	$0
+	MOVD	R0, ret+8(FP)
+	RET
+
+// func walltime() (sec int64, nsec int32)
+TEXT runtime·walltime(SB),NOSPLIT,$16-12
+	// use nsec system call to get current time in nanoseconds
+
+	MOVD	$SYS_NSEC, R0
+	SVC	$0
+
+	MOVD	R0, R1
+	MOVD	$1000000000, R2
+	UDIV	R2, R1
+
+	MOVD	R1, R3
+	MUL	R3, R2
+	SUB	R2, R0
+
+	MOVD	R1,sec+0(FP)
+	MOVD	R0,nsec+8(FP)
+	RET
+
+//func notify(fn unsafe.Pointer) int32
+TEXT runtime·notify(SB),NOSPLIT,$0-12
+	MOVD	$SYS_NOTIFY, R0
+	SVC	$0
+	MOVWU	R0, ret+8(FP)
+	RET
+
+//func noted(mode int64) int64
+TEXT runtime·noted(SB),NOSPLIT,$0-12
+	MOVD	$SYS_NOTED, R0
+	SVC	$0
+	MOVWU	R0, ret+8(FP)
+	RET
+
+//func plan9_semrelease(addr *uint64, count int64) int64
+TEXT runtime·plan9_semrelease(SB),NOSPLIT,$0-20
+	MOVD	$SYS_SEMRELEASE, R0
+	SVC	$0
+	MOVWU	R0, ret+16(FP)
+	RET
+
+//func rfork(flags int64) int64
+TEXT runtime·rfork(SB),NOSPLIT,$0-12
+	MOVD	$SYS_RFORK, R0
+	SVC	$0
+	MOVWU	R0, ret+8(FP)
+	RET
+
+//func tstart_plan9(newm *m)
+TEXT runtime·tstart_plan9(SB),NOSPLIT,$8-8
+	MOVD	newm+0(FP), R1
+	MOVD	m_g0(R1), g
+
+	// Layout new m scheduler stack on os stack.
+	MOVD	RSP, R0
+	MOVD	R0, g_stack+stack_hi(g)
+	SUB	$(64*1024), R0
+	MOVD	R0, (g_stack+stack_lo)(g)
+	MOVD	R0, g_stackguard0(g)
+	MOVD	R0, g_stackguard1(g)
+
+	// Initialize procid from TOS struct.
+	MOVD	_tos(SB), R0
+	MOVWU	64(R0), R0
+	MOVD	R0, m_procid(R1)	// save pid as m->procid
+
+	BL	runtime·mstart(SB)
+
+	// Exit the thread.
+	MOVD	$0, R0
+	MOVD	R0, 8(RSP)
+	CALL	runtime·exits(SB)
+	JMP	0(PC)
+
+//func sigtramp(ureg, note unsafe.Pointer)
+TEXT runtime·sigtramp(SB),NOSPLIT,$0-16
+	// check that g and m exist
+	CMP	$0, g
+	BEQ	4(PC)
+	MOVD	g_m(g), R0
+	CMP 	$0, R0
+	BNE	2(PC)
+	BL	runtime·badsignal2(SB)	// will exit
+
+	// save args
+	MOVD	ureg+0(FP), R1
+	MOVD	note+8(FP), R2
+
+	// change stack
+	MOVD	m_gsignal(R0), R3
+	MOVD	(g_stack+stack_hi)(R3), R4
+	MOVD	R4, RSP
+
+	// make room for args, retval and g
+	SUB	$128, RSP
+
+	// save g
+	MOVD	g, R3
+	MOVD	R3, 32(RSP)
+
+	// g = m->gsignal
+	MOVD	m_gsignal(R0), g
+
+	// load args and call sighandler
+	MOVD R1, 8(RSP)
+	MOVD R2, 16(RSP)
+	MOVD R3, 24(RSP)
+
+	BL	runtime·sighandler(SB)
+	MOVWU	32(RSP), R0			// retval
+
+	// restore g
+	MOVD	40(RSP), g
+
+	// call noted(R0)
+	MOVD	R0, 8(RSP)
+	BL	runtime·noted(SB)
+	RET
+
+//func sigpanictramp()
+TEXT  runtime·sigpanictramp(SB),NOSPLIT,$0-0
+	MOVD.W	$0, -16(RSP)	// create a call frame on g0 (saved LR; keep 16-aligned)
+	B	runtime·sigpanic(SB)
+
+//func setfpmasks()
+// Mask all SSE floating-point exceptions (only amd64?)
+TEXT runtime·setfpmasks(SB),NOSPLIT,$0
+	RET
diff --git a/src/runtime/tls_arm64.h b/src/runtime/tls_arm64.h
index 3aa8c63d39d7b2..afa6cf639f01d5 100644
--- a/src/runtime/tls_arm64.h
+++ b/src/runtime/tls_arm64.h
@@ -36,6 +36,10 @@
 #define MRS_TPIDR_R0 WORD $0xd53bd040 // MRS TPIDR_EL0, R0
 #endif
 
+#ifdef GOOS_plan9
+#define MRS_TPIDR_R0 WORD $0xd53bd040 // MRS TPIDR_EL0, R0
+#endif
+
 #ifdef GOOS_windows
 #define TLS_windows
 #endif
diff --git a/src/syscall/asm_plan9_arm.s b/src/syscall/asm_plan9_arm.s
index d193614affba03..bb713a6540e0f7 100644
--- a/src/syscall/asm_plan9_arm.s
+++ b/src/syscall/asm_plan9_arm.s
@@ -11,6 +11,8 @@
 // System call support for plan9 on arm
 
 //func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err ErrorString)
+// 144: frame size
+//  32: arg size (4 addrs and doubled?!)
 TEXT	·Syscall(SB),NOSPLIT,$144-32
 	NO_LOCAL_POINTERS
 	BL		runtime·entersyscall(SB)
diff --git a/src/syscall/asm_plan9_arm64.s b/src/syscall/asm_plan9_arm64.s
new file mode 100644
index 00000000000000..42b9e7b76c8ffe
--- /dev/null
+++ b/src/syscall/asm_plan9_arm64.s
@@ -0,0 +1,210 @@
+#include "textflag.h"
+#include "funcdata.h"
+
+#define SYS_ERRSTR 41	/* from zsysnum_plan9.go */
+#define SYS_SEEK 39		/* from zsysnum_plan9.go */
+
+// System call support for plan9 on arm64
+
+//func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err ErrorString)
+TEXT	·Syscall(SB),NOSPLIT,$168-64
+	NO_LOCAL_POINTERS
+	BL		runtime·entersyscall(SB)
+
+	MOVD	trap+0(FP), R0
+	MOVD	a1+8(FP), R2
+	MOVD	a2+16(FP), R3
+	MOVD	a3+24(FP), R4
+
+	// move to syscall args
+	MOVD	R2, sysargs-192(FP)
+	MOVD	R3, sysargs-184(FP)
+	MOVD	R4, sysargs-176(FP)
+
+	SVC		$0
+
+	// put return values into r1, r2, err
+	MOVD	R0, r1+32(FP)
+	MOVD	R1, r2+40(FP)
+	MOVD	ZR, err+48(FP)
+
+	// put error if needed
+	CMP	$-1, R0
+	BEQ	syscallerr
+	BL	runtime·exitsyscall(SB)
+	MOVD	$·emptystring+0(SB), R2
+	B	syscallok
+syscallerr:
+	MOVD	$errbuf-128(SP), R2
+	MOVD	$128, R3
+
+	MOVD	$SYS_ERRSTR, R0
+	MOVD	R2, err-192(FP)
+	MOVD	R3, nerr-184(FP)
+	SVC	$0
+
+	BL	runtime·exitsyscall(SB)
+	BL	runtime·gostring(SB)
+	MOVD	$str-160(SP), R2
+syscallok:
+	MOVD	$err+48(FP), R1
+	MOVD	0(R2), R3
+	MOVD	8(R2), R4
+	MOVD	R3, 0(R1)
+	MOVD	R4, 8(R1)
+	RET
+
+
+//func Syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err ErrorString)
+// Actually Syscall5 but the rest of the code expects it to be named Syscall6.
+TEXT	·Syscall6(SB),NOSPLIT,$168-88
+	NO_LOCAL_POINTERS
+	BL	runtime·entersyscall(SB)
+
+	MOVD	trap+0(FP), R1
+	MOVD	a1+8(FP), R2
+	MOVD	a2+16(FP), R3
+	MOVD	a3+24(FP), R4
+	MOVD	a4+32(FP), R5
+	MOVD	a5+40(FP), R6
+	MOVD	a6+48(FP), R7
+
+	// dereference pointers
+	MOVD	R1, R0
+	MOVD	R2, sysargs-192(FP)
+	MOVD	R3, sysargs-184(FP)
+	MOVD	R4, sysargs-176(FP)
+	MOVD	R5, sysargs-168(FP)
+	MOVD	R6, sysargs-160(FP)
+	MOVD	R7, sysargs-152(FP)
+
+	SVC	$0
+
+	// put return value into r1, r2, err
+	MOVD	R0, r1+56(FP)
+	MOVD	R1, r2+64(FP)
+	MOVD	ZR, err+72(FP)
+	
+	// put error if needed
+	CMP	$-1, R0
+	BEQ syscall6err
+	BL	runtime·exitsyscall(SB)
+	MOVD	$·emptystring+0(SB), R2
+	B	syscall6ok
+syscall6err:
+	MOVD	$errbuf-128(SP), R2
+	MOVD	$128, R3
+
+	MOVD	$SYS_ERRSTR, R0
+	MOVD	R2, err-192(FP)
+	MOVD	R3, nerr-184(FP)
+	SVC	$0
+
+	BL	runtime·exitsyscall(SB)
+	BL	runtime·gostring(SB)
+	MOVD	$str-160(SP), R2
+syscall6ok:
+	MOVD	$err+72(FP), R1
+	MOVD	0(R2), R3
+	MOVD	8(R2), R4
+	MOVD	R3, 0(R1)
+	MOVD	R4, 8(R1)
+	RET
+
+//func RawSyscall(trap, a1, a2, a3 uintptr) (r1, r2, err uintptr)
+TEXT ·RawSyscall(SB),NOSPLIT,$24-56
+	MOVD	trap+0(FP), R1
+	MOVD	a1+8(FP), R2
+	MOVD	a2+16(FP), R3
+	MOVD	a3+24(FP), R4
+
+	// move to syscall args
+	MOVD	R1, R0
+	MOVD	R2, sysargs-48(FP)
+	MOVD	R3, sysargs-40(FP)
+	MOVD	R4, sysargs-32(FP)
+
+	SVC	$0
+
+	// put return values into r1, r2, err
+	MOVD	R0, r1+32(FP)
+	MOVD	R0, r2+40(FP)
+	MOVD	R0, err+48(FP)
+
+	RET
+
+//func RawSyscall6(trap, 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,$48-80
+	MOVD	trap+0(FP), R1
+	MOVD	a1+8(FP), R2
+	MOVD	a2+16(FP), R3
+	MOVD	a3+24(FP), R4
+	MOVD	a4+32(FP), R5
+	MOVD	a5+40(FP), R6
+	MOVD	a6+48(FP), R7
+
+	// move to syscall args
+	MOVD	R1, R0
+	MOVD	R2, sysargs-64(FP)
+	MOVD	R3, sysargs-56(FP)
+	MOVD	R4, sysargs-48(FP)
+	MOVD	R5, sysargs-40(FP)
+	MOVD	R6, sysargs-32(FP)
+	MOVD	R7, sysargs-24(FP)
+
+	SVC	$0
+
+	// put return values into r1, r2, err
+	MOVD	R0, r1+56(FP)
+	MOVD	R1, r2+64(FP)
+	MOVD	ZR, err+72(FP)
+
+	RET
+
+//func seek(placeholder uintptr, fd int, offset int64, whence int) (newoffset int64, err string)
+TEXT ·seek(SB),NOSPLIT,$168-56
+	NO_LOCAL_POINTERS
+
+	MOVD	$newoffset+32(FP), R0
+	MOVWU	fd+8(FP), R2
+	MOVD	offset+16(FP), R3
+	MOVWU	whence+24(FP), R4
+
+	// move to syscall args
+	MOVD	R0, sysargs-192(FP)
+	MOVWU	R2, sysargs-184(FP)
+	MOVD	R3, sysargs-176(FP)
+	MOVWU	R4, sysargs-168(FP)
+
+	MOVD	$SYS_SEEK, R0
+	SVC	$0
+
+	// put err
+	MOVD	ZR, err+40(FP)
+
+	// put error if needed
+	CMP	$-1, R0
+	BEQ	syscallerr
+	MOVD	$·emptystring+0(SB), R2
+	B	syscallok
+syscallerr:
+	MOVD	$errbuf-128(SP), R2
+	MOVD	$128, R3
+
+	MOVD	$SYS_ERRSTR, R0
+	MOVD	R2, err-192(FP)
+	MOVD	R3, nerr-184(FP)
+	SVC	$0
+
+	BL	runtime·gostring(SB)
+	MOVD	$str-160(SP), R2
+syscallok:
+	MOVD	$err+40(FP), R1
+	MOVD	0(R2), R3
+	MOVD	8(R2), R4
+	MOVD	R3, 0(R1)
+	MOVD	R4, 8(R1)
+	RET
+
+
diff --git a/src/syscall/zsyscall_plan9_arm64.go b/src/syscall/zsyscall_plan9_arm64.go
new file mode 100644
index 00000000000000..2be5bd9a75771e
--- /dev/null
+++ b/src/syscall/zsyscall_plan9_arm64.go
@@ -0,0 +1,284 @@
+// mksyscall.pl -l32 -plan9 -tags plan9,arm64 syscall_plan9.go
+// Code generated by the command above; DO NOT EDIT.
+
+//go:build plan9 && arm64
+
+package syscall
+
+import "unsafe"
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func fd2path(fd int, buf []byte) (err error) {
+	var _p0 unsafe.Pointer
+	if len(buf) > 0 {
+		_p0 = unsafe.Pointer(&buf[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := Syscall(SYS_FD2PATH, uintptr(fd), uintptr(_p0), uintptr(len(buf)))
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func pipe(p *[2]int32) (err error) {
+	r0, _, e1 := Syscall(SYS_PIPE, uintptr(unsafe.Pointer(p)), 0, 0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func await(s []byte) (n int, err error) {
+	var _p0 unsafe.Pointer
+	if len(s) > 0 {
+		_p0 = unsafe.Pointer(&s[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := Syscall(SYS_AWAIT, uintptr(_p0), uintptr(len(s)), 0)
+	n = int(r0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func open(path string, mode int) (fd int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall(SYS_OPEN, uintptr(unsafe.Pointer(_p0)), uintptr(mode), 0)
+	fd = int(r0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func create(path string, mode int, perm uint32) (fd int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall(SYS_CREATE, uintptr(unsafe.Pointer(_p0)), uintptr(mode), uintptr(perm))
+	fd = int(r0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func remove(path string) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall(SYS_REMOVE, uintptr(unsafe.Pointer(_p0)), 0, 0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func stat(path string, edir []byte) (n int, err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	var _p1 unsafe.Pointer
+	if len(edir) > 0 {
+		_p1 = unsafe.Pointer(&edir[0])
+	} else {
+		_p1 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := Syscall(SYS_STAT, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(edir)))
+	n = int(r0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func bind(name string, old string, flag int) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(name)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(old)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall(SYS_BIND, uintptr(unsafe.Pointer(_p0)), uintptr(unsafe.Pointer(_p1)), uintptr(flag))
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func mount(fd int, afd int, old string, flag int, aname string) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(old)
+	if err != nil {
+		return
+	}
+	var _p1 *byte
+	_p1, err = BytePtrFromString(aname)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall6(SYS_MOUNT, uintptr(fd), uintptr(afd), uintptr(unsafe.Pointer(_p0)), uintptr(flag), uintptr(unsafe.Pointer(_p1)), 0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func wstat(path string, edir []byte) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	var _p1 unsafe.Pointer
+	if len(edir) > 0 {
+		_p1 = unsafe.Pointer(&edir[0])
+	} else {
+		_p1 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := Syscall(SYS_WSTAT, uintptr(unsafe.Pointer(_p0)), uintptr(_p1), uintptr(len(edir)))
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func chdir(path string) (err error) {
+	var _p0 *byte
+	_p0, err = BytePtrFromString(path)
+	if err != nil {
+		return
+	}
+	r0, _, e1 := Syscall(SYS_CHDIR, uintptr(unsafe.Pointer(_p0)), 0, 0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Dup(oldfd int, newfd int) (fd int, err error) {
+	r0, _, e1 := Syscall(SYS_DUP, uintptr(oldfd), uintptr(newfd), 0)
+	fd = int(r0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Pread(fd int, p []byte, offset int64) (n int, err error) {
+	var _p0 unsafe.Pointer
+	if len(p) > 0 {
+		_p0 = unsafe.Pointer(&p[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := Syscall6(SYS_PREAD, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
+	n = int(r0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Pwrite(fd int, p []byte, offset int64) (n int, err error) {
+	var _p0 unsafe.Pointer
+	if len(p) > 0 {
+		_p0 = unsafe.Pointer(&p[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := Syscall6(SYS_PWRITE, uintptr(fd), uintptr(_p0), uintptr(len(p)), uintptr(offset), uintptr(offset>>32), 0)
+	n = int(r0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Close(fd int) (err error) {
+	r0, _, e1 := Syscall(SYS_CLOSE, uintptr(fd), 0, 0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Fstat(fd int, edir []byte) (n int, err error) {
+	var _p0 unsafe.Pointer
+	if len(edir) > 0 {
+		_p0 = unsafe.Pointer(&edir[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := Syscall(SYS_FSTAT, uintptr(fd), uintptr(_p0), uintptr(len(edir)))
+	n = int(r0)
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}
+
+// THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT
+
+func Fwstat(fd int, edir []byte) (err error) {
+	var _p0 unsafe.Pointer
+	if len(edir) > 0 {
+		_p0 = unsafe.Pointer(&edir[0])
+	} else {
+		_p0 = unsafe.Pointer(&_zero)
+	}
+	r0, _, e1 := Syscall(SYS_FWSTAT, uintptr(fd), uintptr(_p0), uintptr(len(edir)))
+	if int32(r0) == -1 {
+		err = e1
+	}
+	return
+}

From a663821a15eac584eeda96659d6cc18fcdb13189 Mon Sep 17 00:00:00 2001
From: Philip Silva <philip.silva@protonmail.com>
Date: Fri, 30 Dec 2022 12:09:46 +0000
Subject: [PATCH 02/19] fix start of text for objdump

---
 src/debug/plan9obj/file.go                   |   8 ++++++--
 src/debug/plan9obj/file_test.go              |  11 +++++++++++
 src/debug/plan9obj/testdata/arm64-plan9-exec | Bin 0 -> 34942 bytes
 3 files changed, 17 insertions(+), 2 deletions(-)
 create mode 100755 src/debug/plan9obj/testdata/arm64-plan9-exec

diff --git a/src/debug/plan9obj/file.go b/src/debug/plan9obj/file.go
index 022c74427101aa..d89c6cd78b36ba 100644
--- a/src/debug/plan9obj/file.go
+++ b/src/debug/plan9obj/file.go
@@ -145,7 +145,7 @@ func NewFile(r io.ReaderAt) (*File, error) {
 	if _, err := r.ReadAt(magic[:], 0); err != nil {
 		return nil, err
 	}
-	_, err := parseMagic(magic[:])
+	m, err := parseMagic(magic[:])
 	if err != nil {
 		return nil, err
 	}
@@ -169,7 +169,11 @@ func NewFile(r io.ReaderAt) (*File, error) {
 			return nil, err
 		}
 		f.PtrSize = 8
-		f.LoadAddress = 0x200000
+		if m == MagicARM64 {
+			f.LoadAddress = 0x10000
+		} else {
+			f.LoadAddress = 0x200000
+		}
 		f.HdrSize += 8
 	}
 
diff --git a/src/debug/plan9obj/file_test.go b/src/debug/plan9obj/file_test.go
index 7e107bca2f52d8..75498fcb5fe4eb 100644
--- a/src/debug/plan9obj/file_test.go
+++ b/src/debug/plan9obj/file_test.go
@@ -38,6 +38,17 @@ var fileTests = []fileTest{
 			{"pcsz", 0xca0, 0x7947},
 		},
 	},
+	{
+		"testdata/arm64-plan9-exec",
+		FileHeader{MagicARM64, 0x408, 0x1003c, 8, 0x10000, 40},
+		[]*SectionHeader{
+			{"text", 0x4a00, 0x28},
+			{"data", 0xaa0, 0x4a28},
+			{"syms", 0x294a, 0x54c8},
+			{"spsz", 0x0, 0x7e12},
+			{"pcsz", 0xa6c, 0x7e12},
+		},
+	},
 }
 
 func TestOpen(t *testing.T) {
diff --git a/src/debug/plan9obj/testdata/arm64-plan9-exec b/src/debug/plan9obj/testdata/arm64-plan9-exec
new file mode 100755
index 0000000000000000000000000000000000000000..3fa2c423e5b943d662f9357faee15d6767e46c25
GIT binary patch
literal 34942
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
JMv0EA|36okkFWp$

literal 0
HcmV?d00001


From 64d7abd42200a50e08b6ee62ae08342e2344ed21 Mon Sep 17 00:00:00 2001
From: Philip Silva <philip.silva@protonmail.com>
Date: Fri, 30 Dec 2022 19:19:04 +0000
Subject: [PATCH 03/19] fix syscall.TestPlan9Syserr

---
 src/syscall/asm_plan9_arm64.s | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/syscall/asm_plan9_arm64.s b/src/syscall/asm_plan9_arm64.s
index 42b9e7b76c8ffe..dcb846933c905b 100644
--- a/src/syscall/asm_plan9_arm64.s
+++ b/src/syscall/asm_plan9_arm64.s
@@ -189,6 +189,8 @@ TEXT ·seek(SB),NOSPLIT,$168-56
 	MOVD	$·emptystring+0(SB), R2
 	B	syscallok
 syscallerr:
+	MOVD	R0, newoffset+32(FP)
+
 	MOVD	$errbuf-128(SP), R2
 	MOVD	$128, R3
 

From d2478c58e40ef54ad692cf5588c7a125bf30c7a7 Mon Sep 17 00:00:00 2001
From: Philip Silva <philip.silva@protonmail.com>
Date: Sun, 1 Jan 2023 16:21:48 +0000
Subject: [PATCH 04/19] update comments and indentation

---
 src/cmd/internal/obj/objfile.go               |  1 +
 .../golang.org/x/sys/plan9/asm_plan9_arm64.s  |  4 +++
 src/runtime/defs_plan9_arm64.go               | 36 ++++++++++---------
 src/runtime/os_plan9_arm64.go                 |  4 +++
 src/runtime/rt0_plan9_arm64.s                 |  4 +++
 src/runtime/sys_plan9_arm64.s                 | 22 ++++++------
 src/syscall/asm_plan9_arm.s                   |  2 --
 src/syscall/asm_plan9_arm64.s                 | 14 +++++---
 8 files changed, 54 insertions(+), 33 deletions(-)

diff --git a/src/cmd/internal/obj/objfile.go b/src/cmd/internal/obj/objfile.go
index 1aaa15764d7c35..4401f1bb74e0a9 100644
--- a/src/cmd/internal/obj/objfile.go
+++ b/src/cmd/internal/obj/objfile.go
@@ -30,6 +30,7 @@ const UnlinkablePkg = "<unlinkable>" // invalid package path, used when compiled
 
 // Entry point of writing new object file.
 func WriteObjFile(ctxt *Link, b *bio.Writer) {
+
 	debugAsmEmit(ctxt)
 
 	genFuncInfoSyms(ctxt)
diff --git a/src/cmd/vendor/golang.org/x/sys/plan9/asm_plan9_arm64.s b/src/cmd/vendor/golang.org/x/sys/plan9/asm_plan9_arm64.s
index f215c739b670df..9014318d4d6047 100644
--- a/src/cmd/vendor/golang.org/x/sys/plan9/asm_plan9_arm64.s
+++ b/src/cmd/vendor/golang.org/x/sys/plan9/asm_plan9_arm64.s
@@ -1,3 +1,7 @@
+// 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"
 
 // System call support for plan9 on arm64
diff --git a/src/runtime/defs_plan9_arm64.go b/src/runtime/defs_plan9_arm64.go
index 8d979ccef2565b..e6803c9adff5bf 100644
--- a/src/runtime/defs_plan9_arm64.go
+++ b/src/runtime/defs_plan9_arm64.go
@@ -1,3 +1,7 @@
+// Copyright 2015 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 _PAGESHIFT = 16
@@ -72,28 +76,28 @@ func dumpregs(u *ureg) {
 	print("r10   ", hex(u.r10), "\n")
 	print("r11   ", hex(u.r11), "\n")
 	print("r12   ", hex(u.r12), "\n")
-	print("r13    ", hex(u.r13), "\n")
-	print("r14    ", hex(u.r14), "\n")
-	print("r15    ", hex(u.r15), "\n")
-	print("r16    ", hex(u.r16), "\n")
-	print("r17    ", hex(u.r17), "\n")
-	print("r18    ", hex(u.r18), "\n")
-	print("r19    ", hex(u.r19), "\n")
+	print("r13   ", hex(u.r13), "\n")
+	print("r14   ", hex(u.r14), "\n")
+	print("r15   ", hex(u.r15), "\n")
+	print("r16   ", hex(u.r16), "\n")
+	print("r17   ", hex(u.r17), "\n")
+	print("r18   ", hex(u.r18), "\n")
+	print("r19   ", hex(u.r19), "\n")
 	print("r20   ", hex(u.r20), "\n")
 	print("r21   ", hex(u.r21), "\n")
 	print("r22   ", hex(u.r22), "\n")
-	print("r23    ", hex(u.r23), "\n")
-	print("r24    ", hex(u.r24), "\n")
-	print("r25    ", hex(u.r25), "\n")
-	print("r26    ", hex(u.r26), "\n")
-	print("r27    ", hex(u.r27), "\n")
-	print("r28    ", hex(u.r28), "\n")
-	print("r29    ", hex(u.r29), "\n")
+	print("r23   ", hex(u.r23), "\n")
+	print("r24   ", hex(u.r24), "\n")
+	print("r25   ", hex(u.r25), "\n")
+	print("r26   ", hex(u.r26), "\n")
+	print("r27   ", hex(u.r27), "\n")
+	print("r28   ", hex(u.r28), "\n")
+	print("r29   ", hex(u.r29), "\n")
 	print("r30   ", hex(u.r30), "\n")
 	print("sp    ", hex(u.sp), "\n")
-	print("pc  ", hex(u.pc), "\n")
+	print("pc    ", hex(u.pc), "\n")
 	print("psr   ", hex(u.psr), "\n")
-	print("type    ", hex(u.typ), "\n")
+	print("type  ", hex(u.typ), "\n")
 }
 
 func sigpanictramp()
diff --git a/src/runtime/os_plan9_arm64.go b/src/runtime/os_plan9_arm64.go
index 5ce48beb18b825..3d3dd7e4117dd8 100644
--- a/src/runtime/os_plan9_arm64.go
+++ b/src/runtime/os_plan9_arm64.go
@@ -1,3 +1,7 @@
+// Copyright 2015 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
 
 //go:nosplit
diff --git a/src/runtime/rt0_plan9_arm64.s b/src/runtime/rt0_plan9_arm64.s
index f4cff8515b8b12..192ff382ef5d7a 100644
--- a/src/runtime/rt0_plan9_arm64.s
+++ b/src/runtime/rt0_plan9_arm64.s
@@ -1,3 +1,7 @@
+// Copyright 2015 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"
 
 //in plan 9 argc is at top of stack followed by ptrs to arguments
diff --git a/src/runtime/sys_plan9_arm64.s b/src/runtime/sys_plan9_arm64.s
index e0025e73825e2c..00305f29eb3cb4 100644
--- a/src/runtime/sys_plan9_arm64.s
+++ b/src/runtime/sys_plan9_arm64.s
@@ -1,3 +1,7 @@
+// Copyright 2015 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 "go_asm.h"
 #include "go_tls.h"
 #include "textflag.h"
@@ -61,16 +65,14 @@ TEXT runtime·pread(SB),NOSPLIT,$0-36
 	MOVWU	R0, ret+32(FP)
 	RET
 
-//func pwrite(fd int64, buf unsafe.Pointer, nbytes int64, offset int64) int
+//func pwrite(fd int32, buf unsafe.Pointer, nbytes int32, offset int64) int32
 TEXT runtime·pwrite(SB),NOSPLIT,$0-36
 	MOVD    $SYS_PWRITE, R0
 	SVC	$0
 	MOVWU	R0, ret+32(FP)
 	RET
 
-//func seek(fd int64, offset int64, whence int32) int64
-// the actual syscall:
-// // int32 _seek(int64*, int32, int64, int32)
+//func seek(fd int32, offset int64, whence int32) int64
 TEXT runtime·seek(SB),NOSPLIT,$0-32
 	MOVD	$ret+24(FP), R0
 	MOVWU	fd+0(FP), R2
@@ -92,7 +94,7 @@ TEXT runtime·seek(SB),NOSPLIT,$0-32
 	MOVD	R0, ret+24(FP)
 	RET
 
-//func closefd(fd int64) int64
+//func closefd(fd int32) int32
 TEXT runtime·closefd(SB),NOSPLIT,$0-12
 	MOVD	$SYS_CLOSE, R0
 	SVC	$0
@@ -119,14 +121,14 @@ TEXT runtime·sleep(SB),NOSPLIT,$0-12
 	MOVD	R0, ret+8(FP)
 	RET
 
-//func plan9_semacquire(addr *uint64, block int64) int64
+//func plan9_semacquire(addr *uint32, block int32) int32
 TEXT runtime·plan9_semacquire(SB),NOSPLIT,$0-20
 	MOVD	$SYS_SEMACQUIRE, R0
 	SVC	$0
 	MOVD	R0, ret+16(FP)
 	RET
 
-//func plan9_tsemacquire(addr *uint64, ms int32) int64
+//func plan9_tsemacquire(addr *uint32, ms int32) int32
 TEXT runtime·plan9_tsemacquire(SB),NOSPLIT,$0-20
 	MOVD	$SYS_TSEMACQUIRE, R0
 	SVC	$0
@@ -166,21 +168,21 @@ TEXT runtime·notify(SB),NOSPLIT,$0-12
 	MOVWU	R0, ret+8(FP)
 	RET
 
-//func noted(mode int64) int64
+//func noted(mode int32) int32
 TEXT runtime·noted(SB),NOSPLIT,$0-12
 	MOVD	$SYS_NOTED, R0
 	SVC	$0
 	MOVWU	R0, ret+8(FP)
 	RET
 
-//func plan9_semrelease(addr *uint64, count int64) int64
+//func plan9_semrelease(addr *uint32, count int32) int32
 TEXT runtime·plan9_semrelease(SB),NOSPLIT,$0-20
 	MOVD	$SYS_SEMRELEASE, R0
 	SVC	$0
 	MOVWU	R0, ret+16(FP)
 	RET
 
-//func rfork(flags int64) int64
+//func rfork(flags int32) int32
 TEXT runtime·rfork(SB),NOSPLIT,$0-12
 	MOVD	$SYS_RFORK, R0
 	SVC	$0
diff --git a/src/syscall/asm_plan9_arm.s b/src/syscall/asm_plan9_arm.s
index bb713a6540e0f7..d193614affba03 100644
--- a/src/syscall/asm_plan9_arm.s
+++ b/src/syscall/asm_plan9_arm.s
@@ -11,8 +11,6 @@
 // System call support for plan9 on arm
 
 //func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err ErrorString)
-// 144: frame size
-//  32: arg size (4 addrs and doubled?!)
 TEXT	·Syscall(SB),NOSPLIT,$144-32
 	NO_LOCAL_POINTERS
 	BL		runtime·entersyscall(SB)
diff --git a/src/syscall/asm_plan9_arm64.s b/src/syscall/asm_plan9_arm64.s
index dcb846933c905b..6605fb49a0b8f6 100644
--- a/src/syscall/asm_plan9_arm64.s
+++ b/src/syscall/asm_plan9_arm64.s
@@ -1,15 +1,19 @@
+// 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"
 #include "funcdata.h"
 
 #define SYS_ERRSTR 41	/* from zsysnum_plan9.go */
-#define SYS_SEEK 39		/* from zsysnum_plan9.go */
+#define SYS_SEEK 39	/* from zsysnum_plan9.go */
 
 // System call support for plan9 on arm64
 
 //func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err ErrorString)
 TEXT	·Syscall(SB),NOSPLIT,$168-64
 	NO_LOCAL_POINTERS
-	BL		runtime·entersyscall(SB)
+	BL	runtime·entersyscall(SB)
 
 	MOVD	trap+0(FP), R0
 	MOVD	a1+8(FP), R2
@@ -21,7 +25,7 @@ TEXT	·Syscall(SB),NOSPLIT,$168-64
 	MOVD	R3, sysargs-184(FP)
 	MOVD	R4, sysargs-176(FP)
 
-	SVC		$0
+	SVC	$0
 
 	// put return values into r1, r2, err
 	MOVD	R0, r1+32(FP)
@@ -84,10 +88,10 @@ TEXT	·Syscall6(SB),NOSPLIT,$168-88
 	MOVD	R0, r1+56(FP)
 	MOVD	R1, r2+64(FP)
 	MOVD	ZR, err+72(FP)
-	
+
 	// put error if needed
 	CMP	$-1, R0
-	BEQ syscall6err
+	BEQ	syscall6err
 	BL	runtime·exitsyscall(SB)
 	MOVD	$·emptystring+0(SB), R2
 	B	syscall6ok

From 17e350a836bf421bdcad464d24eae4997289ed39 Mon Sep 17 00:00:00 2001
From: Philip Silva <philip.silva@protonmail.com>
Date: Mon, 2 Jan 2023 23:14:13 +0000
Subject: [PATCH 05/19] fix runtime.TestBreakpoint

---
 src/runtime/sys_plan9_arm64.s | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/runtime/sys_plan9_arm64.s b/src/runtime/sys_plan9_arm64.s
index 00305f29eb3cb4..68d18b994dcd71 100644
--- a/src/runtime/sys_plan9_arm64.s
+++ b/src/runtime/sys_plan9_arm64.s
@@ -262,7 +262,7 @@ TEXT runtime·sigtramp(SB),NOSPLIT,$0-16
 
 //func sigpanictramp()
 TEXT  runtime·sigpanictramp(SB),NOSPLIT,$0-0
-	MOVD.W	$0, -16(RSP)	// create a call frame on g0 (saved LR; keep 16-aligned)
+	MOVD.W	R0, -8(RSP)
 	B	runtime·sigpanic(SB)
 
 //func setfpmasks()

From 0cc2b275f04ce27d7639d7e9c54cf9053321f6c4 Mon Sep 17 00:00:00 2001
From: Philip Silva <philip.silva@protonmail.com>
Date: Tue, 3 Jan 2023 21:46:17 +0000
Subject: [PATCH 06/19] fix reflect and recover

---
 src/runtime/sys_plan9_arm64.s | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/runtime/sys_plan9_arm64.s b/src/runtime/sys_plan9_arm64.s
index 68d18b994dcd71..1ba121053da47b 100644
--- a/src/runtime/sys_plan9_arm64.s
+++ b/src/runtime/sys_plan9_arm64.s
@@ -111,28 +111,28 @@ TEXT runtime·exits(SB),NOSPLIT,$0-8
 TEXT runtime·brk_(SB),NOSPLIT,$0-12
 	MOVD    $SYS_BRK_, R0
 	SVC	$0
-	MOVD	R0, ret+8(FP)
+	MOVWU	R0, ret+8(FP)
 	RET
 
 //func sleep(ms int32) int32
 TEXT runtime·sleep(SB),NOSPLIT,$0-12
 	MOVD    $SYS_SLEEP, R0
 	SVC	$0
-	MOVD	R0, ret+8(FP)
+	MOVWU	R0, ret+8(FP)
 	RET
 
 //func plan9_semacquire(addr *uint32, block int32) int32
 TEXT runtime·plan9_semacquire(SB),NOSPLIT,$0-20
 	MOVD	$SYS_SEMACQUIRE, R0
 	SVC	$0
-	MOVD	R0, ret+16(FP)
+	MOVWU	R0, ret+16(FP)
 	RET
 
 //func plan9_tsemacquire(addr *uint32, ms int32) int32
 TEXT runtime·plan9_tsemacquire(SB),NOSPLIT,$0-20
 	MOVD	$SYS_TSEMACQUIRE, R0
 	SVC	$0
-	MOVD	R0, ret+16(FP)
+	MOVWU	R0, ret+16(FP)
 	RET
 
 //func nsec(*int64) int64
@@ -158,7 +158,7 @@ TEXT runtime·walltime(SB),NOSPLIT,$16-12
 	SUB	R2, R0
 
 	MOVD	R1,sec+0(FP)
-	MOVD	R0,nsec+8(FP)
+	MOVWU	R0,nsec+8(FP)
 	RET
 
 //func notify(fn unsafe.Pointer) int32
@@ -235,11 +235,11 @@ TEXT runtime·sigtramp(SB),NOSPLIT,$0-16
 	MOVD	R4, RSP
 
 	// make room for args, retval and g
-	SUB	$128, RSP
+	SUB	$48, RSP
 
 	// save g
 	MOVD	g, R3
-	MOVD	R3, 32(RSP)
+	MOVD	R3, 40(RSP)
 
 	// g = m->gsignal
 	MOVD	m_gsignal(R0), g
@@ -262,7 +262,7 @@ TEXT runtime·sigtramp(SB),NOSPLIT,$0-16
 
 //func sigpanictramp()
 TEXT  runtime·sigpanictramp(SB),NOSPLIT,$0-0
-	MOVD.W	R0, -8(RSP)
+	MOVD.W	R0, -16(RSP)
 	B	runtime·sigpanic(SB)
 
 //func setfpmasks()

From 8f78ebc53dc693489eb9490e596d2390faa88364 Mon Sep 17 00:00:00 2001
From: Philip Silva <philip.silva@protonmail.com>
Date: Fri, 6 Jan 2023 18:21:19 +0000
Subject: [PATCH 07/19] cmd/go: fix TestScript/work_env

---
 src/cmd/go/testdata/script/work_env.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/cmd/go/testdata/script/work_env.txt b/src/cmd/go/testdata/script/work_env.txt
index 8b1779ea703725..54e51dae0fddb6 100644
--- a/src/cmd/go/testdata/script/work_env.txt
+++ b/src/cmd/go/testdata/script/work_env.txt
@@ -1,7 +1,7 @@
 go env GOWORK
 stdout '^'$GOPATH'[\\/]src[\\/]go.work$'
 go env
-stdout '^(set )?GOWORK=''?'$GOPATH'[\\/]src[\\/]go.work''?$'
+stdout '^(set )?GOWORK=["'']?'$GOPATH'[\\/]src[\\/]go.work["'']?$'
 
 cd ..
 go env GOWORK

From dc0d02aed1b5f94a7f6914f303fb4d933d39b639 Mon Sep 17 00:00:00 2001
From: Philip Silva <philip.silva@protonmail.com>
Date: Mon, 9 Jan 2023 16:45:20 +0000
Subject: [PATCH 08/19] net: skip IPv6->IPv4 test on Plan 9

---
 src/net/udpsock_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/net/udpsock_test.go b/src/net/udpsock_test.go
index a79e9f83c11098..a0cedb748b021f 100644
--- a/src/net/udpsock_test.go
+++ b/src/net/udpsock_test.go
@@ -679,7 +679,7 @@ func TestIPv6WriteMsgUDPAddrPortTargetAddrIPVersion(t *testing.T) {
 	}
 
 	switch runtime.GOOS {
-	case "dragonfly", "openbsd":
+	case "dragonfly", "openbsd", "plan9":
 		// DragonflyBSD's IPv6 sockets are always IPv6-only, according to the man page:
 		// https://www.dragonflybsd.org/cgi/web-man?command=ip6 (search for IPV6_V6ONLY).
 		// OpenBSD's IPv6 sockets are always IPv6-only, according to the man page:

From 9de456f4f4086a3e51f70134e592dea6b7b118cf Mon Sep 17 00:00:00 2001
From: Philip Silva <philip.silva@protonmail.com>
Date: Mon, 16 Jan 2023 22:45:13 +0000
Subject: [PATCH 09/19] improve flakiness of fs based tests

---
 src/syscall/pwd_plan9.go | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/syscall/pwd_plan9.go b/src/syscall/pwd_plan9.go
index b81018873f9c8f..5f24cf22a715e7 100644
--- a/src/syscall/pwd_plan9.go
+++ b/src/syscall/pwd_plan9.go
@@ -29,6 +29,8 @@ var (
 // rescheduling on a different thread (potentially with a different
 // working directory) before the syscall is executed.
 func Fixwd() {
+	runtime.LockOSThread()
+	defer runtime.UnlockOSThread()
 	wdmu.Lock()
 	defer wdmu.Unlock()
 	fixwdLocked()
@@ -72,6 +74,8 @@ func getwd() (wd string, err error) {
 }
 
 func Getwd() (wd string, err error) {
+	runtime.LockOSThread()
+	defer runtime.UnlockOSThread()
 	wdmu.Lock()
 	defer wdmu.Unlock()
 

From dc5d3bf37ee1017dd047d5850661092bd1fd0715 Mon Sep 17 00:00:00 2001
From: Philip Silva <philip.silva@protonmail.com>
Date: Sun, 29 Jan 2023 12:48:43 +0000
Subject: [PATCH 10/19] internal/testenv: update CPUIsSlow

---
 src/internal/testenv/testenv.go | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/internal/testenv/testenv.go b/src/internal/testenv/testenv.go
index 96eacc60a3a07d..c8244c86b0367b 100644
--- a/src/internal/testenv/testenv.go
+++ b/src/internal/testenv/testenv.go
@@ -442,7 +442,8 @@ func CPUIsSlow() bool {
 	case "arm", "mips", "mipsle", "mips64", "mips64le", "wasm":
 		return true
 	}
-	return false
+
+	return runtime.GOARCH == "arm64" && runtime.GOOS == "plan9"
 }
 
 // SkipIfShortAndSlow skips t if -short is set and the CPU running the test is

From 8c639fd095b6a5bd5cb42ace8eb130be20d01ed4 Mon Sep 17 00:00:00 2001
From: Philip Silva <philip.silva@protonmail.com>
Date: Tue, 31 Jan 2023 20:02:10 +0000
Subject: [PATCH 11/19] net/http: deflake TestServerEmptyBodyRace

---
 src/net/http/serve_test.go | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/net/http/serve_test.go b/src/net/http/serve_test.go
index 4a16ba02af6cee..22aa48b947a751 100644
--- a/src/net/http/serve_test.go
+++ b/src/net/http/serve_test.go
@@ -4562,7 +4562,11 @@ func testServerEmptyBodyRace(t *testing.T, mode testMode) {
 			if err != nil {
 				// Try to deflake spurious "connection reset by peer" under load.
 				// See golang.org/issue/22540.
-				time.Sleep(10 * time.Millisecond)
+				deflake := 10 * time.Millisecond
+				if runtime.GOOS == "plan9" && runtime.GOARCH == "arm64" {
+					deflake = 100 * time.Millisecond
+				}
+				time.Sleep(deflake)
 				res, err = cst.c.Get(cst.ts.URL)
 				if err != nil {
 					t.Error(err)

From 3288fa60cc740cc3818c27f5362eebf5a006b153 Mon Sep 17 00:00:00 2001
From: Philip Silva <philip.silva@protonmail.com>
Date: Sun, 26 Feb 2023 21:28:40 +0000
Subject: [PATCH 12/19] net/http: deflake TestServerEmptyBodyRace also on amd64

---
 src/net/http/serve_test.go | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/net/http/serve_test.go b/src/net/http/serve_test.go
index 22aa48b947a751..361beb1b7e32e4 100644
--- a/src/net/http/serve_test.go
+++ b/src/net/http/serve_test.go
@@ -4563,7 +4563,7 @@ func testServerEmptyBodyRace(t *testing.T, mode testMode) {
 				// Try to deflake spurious "connection reset by peer" under load.
 				// See golang.org/issue/22540.
 				deflake := 10 * time.Millisecond
-				if runtime.GOOS == "plan9" && runtime.GOARCH == "arm64" {
+				if runtime.GOOS == "plan9" {
 					deflake = 100 * time.Millisecond
 				}
 				time.Sleep(deflake)

From 2d5af1a10f07a38dba8407d7fd715d88b1c446b9 Mon Sep 17 00:00:00 2001
From: Rafael Diniz <rafael@riseup.net>
Date: Tue, 11 Nov 2025 23:44:05 +0000
Subject: [PATCH 13/19] Harmonize implementation of plan9 arm64 obj with other
 archs

---
 src/cmd/link/internal/arm64/obj.go | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/src/cmd/link/internal/arm64/obj.go b/src/cmd/link/internal/arm64/obj.go
index 45d3317780dd1e..cc3b113fabc95d 100644
--- a/src/cmd/link/internal/arm64/obj.go
+++ b/src/cmd/link/internal/arm64/obj.go
@@ -89,15 +89,11 @@ func archinit(ctxt *ld.Link) {
 
 	case objabi.Hplan9: /* plan 9 */
 		ld.HEADR = 32 + 8
-
-		if *ld.FlagTextAddr == -1 {
-			*ld.FlagTextAddr = 0x10000 + int64(ld.HEADR)
-		}
 		if *ld.FlagRound == -1 {
 			*ld.FlagRound = 0x10000
 		}
 		if *ld.FlagTextAddr == -1 {
-			*ld.FlagTextAddr = ld.Rnd(4096, *ld.FlagRound) + int64(ld.HEADR)
+			*ld.FlagTextAddr = ld.Rnd(0x10000, *ld.FlagRound) + int64(ld.HEADR)
 		}
 
 	case objabi.Hlinux, /* arm64 elf */

From 5e4074777f73ba9cfa7004cb4cee6b71cd4818ff Mon Sep 17 00:00:00 2001
From: Rafael Diniz <rafael@riseup.net>
Date: Wed, 12 Nov 2025 00:02:45 +0000
Subject: [PATCH 14/19] Add plan9 arm64 to list of supported platforms

---
 src/internal/platform/zosarch.go | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/internal/platform/zosarch.go b/src/internal/platform/zosarch.go
index a2f5b22ea9a656..a81735caca5baa 100644
--- a/src/internal/platform/zosarch.go
+++ b/src/internal/platform/zosarch.go
@@ -53,6 +53,7 @@ var List = []OSArch{
 	{"plan9", "386"},
 	{"plan9", "amd64"},
 	{"plan9", "arm"},
+	{"plan9", "arm64"},
 	{"solaris", "amd64"},
 	{"wasip1", "wasm"},
 	{"windows", "386"},
@@ -106,6 +107,7 @@ var distInfo = map[OSArch]osArchInfo{
 	{"plan9", "386"}:       {},
 	{"plan9", "amd64"}:     {},
 	{"plan9", "arm"}:       {},
+	{"plan9", "arm64"}:     {},
 	{"solaris", "amd64"}:   {CgoSupported: true},
 	{"wasip1", "wasm"}:     {},
 	{"windows", "386"}:     {CgoSupported: true, FirstClass: true},

From 3077302590df3249ad3d45e29bbbf600fac8b63c Mon Sep 17 00:00:00 2001
From: Rafael Diniz <rafael@riseup.net>
Date: Wed, 12 Nov 2025 00:54:05 +0000
Subject: [PATCH 15/19] Fill in missing functions for plan9 port

---
 src/runtime/os_plan9.go       |  7 -------
 src/runtime/os_plan9_386.go   | 12 ++++++++++++
 src/runtime/os_plan9_amd64.go | 12 ++++++++++++
 src/runtime/os_plan9_arm.go   |  7 +++++++
 src/runtime/sys_plan9_arm64.s | 27 +++++++++++++++++++++++++++
 5 files changed, 58 insertions(+), 7 deletions(-)
 create mode 100644 src/runtime/os_plan9_386.go
 create mode 100644 src/runtime/os_plan9_amd64.go

diff --git a/src/runtime/os_plan9.go b/src/runtime/os_plan9.go
index 80c101f1a18c6f..f7381012ea5f84 100644
--- a/src/runtime/os_plan9.go
+++ b/src/runtime/os_plan9.go
@@ -587,10 +587,3 @@ func nanotime1() int64 {
 	// fall back to unix time
 	return int64(frombe(t[0]))
 }
-
-//go:nosplit
-func walltime() (sec int64, nsec int32) {
-	var t [1]uint64
-	readtime(&t[0], 1, 1)
-	return timesplit(frombe(t[0]))
-}
diff --git a/src/runtime/os_plan9_386.go b/src/runtime/os_plan9_386.go
new file mode 100644
index 00000000000000..66f09f4c43e939
--- /dev/null
+++ b/src/runtime/os_plan9_386.go
@@ -0,0 +1,12 @@
+// Copyright 2025 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
+
+//go:nosplit
+func walltime() (sec int64, nsec int32) {
+	var t [1]uint64
+	readtime(&t[0], 1, 1)
+	return timesplit(frombe(t[0]))
+}
diff --git a/src/runtime/os_plan9_amd64.go b/src/runtime/os_plan9_amd64.go
new file mode 100644
index 00000000000000..66f09f4c43e939
--- /dev/null
+++ b/src/runtime/os_plan9_amd64.go
@@ -0,0 +1,12 @@
+// Copyright 2025 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
+
+//go:nosplit
+func walltime() (sec int64, nsec int32) {
+	var t [1]uint64
+	readtime(&t[0], 1, 1)
+	return timesplit(frombe(t[0]))
+}
diff --git a/src/runtime/os_plan9_arm.go b/src/runtime/os_plan9_arm.go
index cce622932361ac..2e9530eb9a621e 100644
--- a/src/runtime/os_plan9_arm.go
+++ b/src/runtime/os_plan9_arm.go
@@ -13,3 +13,10 @@ func cputicks() int64 {
 	// runtime·nanotime() is a poor approximation of CPU ticks that is enough for the profiler.
 	return nanotime()
 }
+
+//go:nosplit
+func walltime() (sec int64, nsec int32) {
+	var t [1]uint64
+	readtime(&t[0], 1, 1)
+	return timesplit(frombe(t[0]))
+}
diff --git a/src/runtime/sys_plan9_arm64.s b/src/runtime/sys_plan9_arm64.s
index 1ba121053da47b..f4d3a2597082fc 100644
--- a/src/runtime/sys_plan9_arm64.s
+++ b/src/runtime/sys_plan9_arm64.s
@@ -101,6 +101,13 @@ TEXT runtime·closefd(SB),NOSPLIT,$0-12
 	MOVWU	R0, ret+8(FP)
 	RET
 
+//func dupfd(old, new int32) int32
+TEXT runtime·dupfd(SB),NOSPLIT,$0-12
+	MOVD	$SYS_DUP, R0
+	SVC	$0
+	MOVWU	R0, ret+8(FP)
+	RET
+
 //func exits(msg *byte)
 TEXT runtime·exits(SB),NOSPLIT,$0-8
 	MOVD    $SYS_EXITS, R0
@@ -135,6 +142,26 @@ TEXT runtime·plan9_tsemacquire(SB),NOSPLIT,$0-20
 	MOVWU	R0, ret+16(FP)
 	RET
 
+// func timesplit(u uint64) (sec int64, nsec int32)
+TEXT runtime·timesplit(SB),NOSPLIT,$0-16
+	// load u (nanoseconds)
+	MOVD	u+0(FP), R0
+
+	// compute sec = u / 1e9
+	MOVD	R0, R1
+	MOVD	$1000000000, R2
+	UDIV	R2, R1		// R1 = R1 / R2  -> seconds
+
+	// compute rem = u - sec * 1e9
+	MOVD	R1, R3
+	MUL	R3, R2		// R2 = sec * 1e9
+	SUB	R2, R0		// R0 = u - (sec*1e9) -> remainder (nsec)
+
+	// store results
+	MOVD	R1, sec+0(FP)
+	MOVWU	R0, nsec+8(FP)
+	RET
+
 //func nsec(*int64) int64
 TEXT runtime·nsec(SB),NOSPLIT|NOFRAME,$0-16
 	MOVD	$SYS_NSEC, R0

From 652c10b85ba772fa2a3802d64238425318e722d4 Mon Sep 17 00:00:00 2001
From: Rafael Diniz <rafael@riseup.net>
Date: Wed, 12 Nov 2025 01:04:04 +0000
Subject: [PATCH 16/19] Revert previous specific plan9 arm64 cruft

---
 src/internal/testenv/testenv.go | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/internal/testenv/testenv.go b/src/internal/testenv/testenv.go
index c8244c86b0367b..96eacc60a3a07d 100644
--- a/src/internal/testenv/testenv.go
+++ b/src/internal/testenv/testenv.go
@@ -442,8 +442,7 @@ func CPUIsSlow() bool {
 	case "arm", "mips", "mipsle", "mips64", "mips64le", "wasm":
 		return true
 	}
-
-	return runtime.GOARCH == "arm64" && runtime.GOOS == "plan9"
+	return false
 }
 
 // SkipIfShortAndSlow skips t if -short is set and the CPU running the test is

From 09830347320ed27c7c8cc5b23acd81d8e200acaa Mon Sep 17 00:00:00 2001
From: Rafael Diniz <rafael@riseup.net>
Date: Wed, 12 Nov 2025 01:10:07 +0000
Subject: [PATCH 17/19] Revert left-overs from previous plan9 arm64 port commit

---
 src/syscall/pwd_plan9.go | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/src/syscall/pwd_plan9.go b/src/syscall/pwd_plan9.go
index 5f24cf22a715e7..b81018873f9c8f 100644
--- a/src/syscall/pwd_plan9.go
+++ b/src/syscall/pwd_plan9.go
@@ -29,8 +29,6 @@ var (
 // rescheduling on a different thread (potentially with a different
 // working directory) before the syscall is executed.
 func Fixwd() {
-	runtime.LockOSThread()
-	defer runtime.UnlockOSThread()
 	wdmu.Lock()
 	defer wdmu.Unlock()
 	fixwdLocked()
@@ -74,8 +72,6 @@ func getwd() (wd string, err error) {
 }
 
 func Getwd() (wd string, err error) {
-	runtime.LockOSThread()
-	defer runtime.UnlockOSThread()
 	wdmu.Lock()
 	defer wdmu.Unlock()
 

From 1a4f82ca20da686b9d8df716869aa3ef576afdbc Mon Sep 17 00:00:00 2001
From: Rafael Diniz <rafael@riseup.net>
Date: Wed, 12 Nov 2025 20:02:03 +0000
Subject: [PATCH 18/19] Revert Plan9 workaround

---
 src/net/http/serve_test.go | 6 +-----
 1 file changed, 1 insertion(+), 5 deletions(-)

diff --git a/src/net/http/serve_test.go b/src/net/http/serve_test.go
index 361beb1b7e32e4..4a16ba02af6cee 100644
--- a/src/net/http/serve_test.go
+++ b/src/net/http/serve_test.go
@@ -4562,11 +4562,7 @@ func testServerEmptyBodyRace(t *testing.T, mode testMode) {
 			if err != nil {
 				// Try to deflake spurious "connection reset by peer" under load.
 				// See golang.org/issue/22540.
-				deflake := 10 * time.Millisecond
-				if runtime.GOOS == "plan9" {
-					deflake = 100 * time.Millisecond
-				}
-				time.Sleep(deflake)
+				time.Sleep(10 * time.Millisecond)
 				res, err = cst.c.Get(cst.ts.URL)
 				if err != nil {
 					t.Error(err)

From d993ecc6e99f1d17e48ec0583fa93f8f1a877f5b Mon Sep 17 00:00:00 2001
From: Rafael Diniz <rafael@riseup.net>
Date: Wed, 12 Nov 2025 20:34:21 +0000
Subject: [PATCH 19/19] Improved timesplit arm64 assembly without UDIV

---
 src/runtime/sys_plan9_arm64.s | 51 ++++++++++++++++++++++-------------
 1 file changed, 33 insertions(+), 18 deletions(-)

diff --git a/src/runtime/sys_plan9_arm64.s b/src/runtime/sys_plan9_arm64.s
index f4d3a2597082fc..618aafb02e7431 100644
--- a/src/runtime/sys_plan9_arm64.s
+++ b/src/runtime/sys_plan9_arm64.s
@@ -143,23 +143,39 @@ TEXT runtime·plan9_tsemacquire(SB),NOSPLIT,$0-20
 	RET
 
 // func timesplit(u uint64) (sec int64, nsec int32)
-TEXT runtime·timesplit(SB),NOSPLIT,$0-16
-	// load u (nanoseconds)
-	MOVD	u+0(FP), R0
-
-	// compute sec = u / 1e9
-	MOVD	R0, R1
-	MOVD	$1000000000, R2
-	UDIV	R2, R1		// R1 = R1 / R2  -> seconds
-
-	// compute rem = u - sec * 1e9
-	MOVD	R1, R3
-	MUL	R3, R2		// R2 = sec * 1e9
-	SUB	R2, R0		// R0 = u - (sec*1e9) -> remainder (nsec)
-
-	// store results
-	MOVD	R1, sec+0(FP)
-	MOVWU	R0, nsec+8(FP)
+TEXT runtime·timesplit(SB), NOSPLIT, $0
+	// R1 = u (nanoseconds)
+	MOVD	u+0(FP), R1
+
+	// --- reciprocal multiply to get seconds ---
+	MOVW	$0x89705f41, R2      // reciprocal constant ≈ 2^61 / 1e9
+	UMULH	R1, R2, R3           // high 64 bits of (u * constant)
+	LSR	$29, R3, R4          // R4 = seconds (int64)
+
+	// --- compute remainder = u - sec*1e9 ---
+	MOVD	$1000000000, R5
+	MUL	R4, R5, R6
+	SUB	R6, R1, R1           // R1 = remainder
+
+	// --- branchless correction ---
+	// if remainder >= 1e9:
+	//    remainder -= 1e9
+	//    sec += 1
+
+	SUB	R5, R1, R7           // R7 = remainder - 1e9
+	LSR	$63, R7, R8          // R8 = 1 if remainder < 1e9, else 0
+	EOR	$1, R8               // invert: R8 = 1 if remainder >= 1e9, else 0
+
+	// remainder -= R8 * 1e9
+	NEG	R8, R9               // R9 = -R8 (0 or -1)
+	MADD	R9, R5, R1, R1       // R1 = R1 + R9*R5 → subtract 1e9 if flag=1
+
+	// sec += R8
+	ADD	R8, R4, R4
+
+	// --- store results ---
+	MOVD	R4, sec+0(FP)
+	MOVW	R1, nsec+8(FP)
 	RET
 
 //func nsec(*int64) int64
@@ -172,7 +188,6 @@ TEXT runtime·nsec(SB),NOSPLIT|NOFRAME,$0-16
 // func walltime() (sec int64, nsec int32)
 TEXT runtime·walltime(SB),NOSPLIT,$16-12
 	// use nsec system call to get current time in nanoseconds
-
 	MOVD	$SYS_NSEC, R0
 	SVC	$0