Reorganized file structure

src/build/arch/arm64/Syscall.go

@@ -0,0 +1,9 @@
+package register
+
+import "git.akyoto.dev/cli/q/src/build/cpu"
+
+const (
+	SyscallReturn = 0
+)
+
+var SyscallArgs = []cpu.Register{8, 0, 1, 2, 3, 4, 5}

src/build/arch/x64/Call.go

@@ -0,0 +1,14 @@
+package x64
+
+// Call places the return address on the top of the stack and continues
+// program flow at the new address. The address is relative to the next instruction.
+func Call(code []byte, address uint32) []byte {
+	return append(
+		code,
+		0xe8,
+		byte(address),
+		byte(address>>8),
+		byte(address>>16),
+		byte(address>>24),
+	)
+}

src/build/arch/x64/Move.go

@@ -0,0 +1,13 @@
+package x64
+
+// MoveRegNum32 moves a 32 bit integer into the given register.
+func MoveRegNum32(code []byte, register uint8, number uint32) []byte {
+	return append(
+		code,
+		0xb8+register,
+		byte(number),
+		byte(number>>8),
+		byte(number>>16),
+		byte(number>>24),
+	)
+}

src/build/arch/x64/Return.go

@@ -0,0 +1,7 @@
+package x64
+
+// Return transfers program control to a return address located on the top of the stack.
+// The address is usually placed on the stack by a Call instruction.
+func Return(code []byte) []byte {
+	return append(code, 0xc3)
+}

src/build/arch/x64/Syscall.go

@@ -0,0 +1,14 @@
+package x64
+
+import "git.akyoto.dev/cli/q/src/build/cpu"
+
+const (
+	SyscallReturn = 0 // rax
+)
+
+var SyscallArgs = []cpu.Register{0, 7, 6, 2, 10, 8, 9}
+
+// Syscall is the primary way to communicate with the OS kernel.
+func Syscall(code []byte) []byte {
+	return append(code, 0x0f, 0x05)
+}

src/build/arch/x64/x64_test.go

@@ -0,0 +1,16 @@
+package x64_test
+
+import (
+	"testing"
+
+	"git.akyoto.dev/cli/q/src/build/arch/x64"
+	"git.akyoto.dev/go/assert"
+)
+
+func TestX64(t *testing.T) {
+	assert.DeepEqual(t, x64.Call([]byte{}, 1), []byte{0xe8, 0x01, 0x00, 0x00, 0x00})
+	assert.DeepEqual(t, x64.MoveRegNum32([]byte{}, 0, 1), []byte{0xb8, 0x01, 0x00, 0x00, 0x00})
+	assert.DeepEqual(t, x64.MoveRegNum32([]byte{}, 1, 1), []byte{0xb9, 0x01, 0x00, 0x00, 0x00})
+	assert.DeepEqual(t, x64.Return([]byte{}), []byte{0xc3})
+	assert.DeepEqual(t, x64.Syscall([]byte{}), []byte{0x0f, 0x05})
+}