Simplified file structure

src/asm/Assembler.go

@@ -0,0 +1,28 @@
+package asm
+
+import (
+	"maps"
+
+	"git.akyoto.dev/cli/q/src/data"
+)
+
+// Assembler contains a list of instructions.
+type Assembler struct {
+	Data         data.Data
+	Instructions []Instruction
+}
+
+// Merge combines the contents of this assembler with another one.
+func (a *Assembler) Merge(b Assembler) {
+	maps.Copy(a.Data, b.Data)
+	a.Instructions = append(a.Instructions, b.Instructions...)
+}
+
+// SetData sets the data for the given label.
+func (a *Assembler) SetData(label string, bytes []byte) {
+	if a.Data == nil {
+		a.Data = data.Data{}
+	}
+
+	a.Data[label] = bytes
+}

src/asm/Finalize.go

@@ -0,0 +1,350 @@
+package asm
+
+import (
+	"encoding/binary"
+	"fmt"
+	"slices"
+	"strings"
+
+	"git.akyoto.dev/cli/q/src/arch/x64"
+	"git.akyoto.dev/cli/q/src/config"
+	"git.akyoto.dev/cli/q/src/elf"
+	"git.akyoto.dev/cli/q/src/sizeof"
+)
+
+// Finalize generates the final machine code.
+func (a Assembler) Finalize() ([]byte, []byte) {
+	var (
+		code         = make([]byte, 0, len(a.Instructions)*8)
+		data         []byte
+		codeLabels   = map[string]Address{}
+		dataLabels   map[string]Address
+		codePointers []*Pointer
+		dataPointers []*Pointer
+	)
+
+	for _, x := range a.Instructions {
+		switch x.Mnemonic {
+		case ADD:
+			switch operands := x.Data.(type) {
+			case *RegisterNumber:
+				code = x64.AddRegisterNumber(code, operands.Register, operands.Number)
+			case *RegisterRegister:
+				code = x64.AddRegisterRegister(code, operands.Destination, operands.Source)
+			}
+
+		case AND:
+			switch operands := x.Data.(type) {
+			case *RegisterNumber:
+				code = x64.AndRegisterNumber(code, operands.Register, operands.Number)
+			case *RegisterRegister:
+				code = x64.AndRegisterRegister(code, operands.Destination, operands.Source)
+			}
+
+		case SUB:
+			switch operands := x.Data.(type) {
+			case *RegisterNumber:
+				code = x64.SubRegisterNumber(code, operands.Register, operands.Number)
+			case *RegisterRegister:
+				code = x64.SubRegisterRegister(code, operands.Destination, operands.Source)
+			}
+
+		case MUL:
+			switch operands := x.Data.(type) {
+			case *RegisterNumber:
+				code = x64.MulRegisterNumber(code, operands.Register, operands.Number)
+			case *RegisterRegister:
+				code = x64.MulRegisterRegister(code, operands.Destination, operands.Source)
+			}
+
+		case DIV:
+			switch operands := x.Data.(type) {
+			case *RegisterRegister:
+				if operands.Destination != x64.RAX {
+					code = x64.MoveRegisterRegister(code, x64.RAX, operands.Destination)
+				}
+
+				code = x64.ExtendRAXToRDX(code)
+				code = x64.DivRegister(code, operands.Source)
+
+				if operands.Destination != x64.RAX {
+					code = x64.MoveRegisterRegister(code, operands.Destination, x64.RAX)
+				}
+			}
+
+		case MODULO:
+			switch operands := x.Data.(type) {
+			case *RegisterRegister:
+				if operands.Destination != x64.RAX {
+					code = x64.MoveRegisterRegister(code, x64.RAX, operands.Destination)
+				}
+
+				code = x64.ExtendRAXToRDX(code)
+				code = x64.DivRegister(code, operands.Source)
+
+				if operands.Destination != x64.RDX {
+					code = x64.MoveRegisterRegister(code, operands.Destination, x64.RDX)
+				}
+			}
+
+		case CALL:
+			code = x64.Call(code, 0x00_00_00_00)
+			size := 4
+			label := x.Data.(*Label)
+
+			pointer := &Pointer{
+				Position: Address(len(code) - size),
+				OpSize:   1,
+				Size:     uint8(size),
+			}
+
+			pointer.Resolve = func() Address {
+				destination, exists := codeLabels[label.Name]
+
+				if !exists {
+					panic("unknown jump label")
+				}
+
+				distance := destination - (pointer.Position + Address(pointer.Size))
+				return Address(distance)
+			}
+
+			codePointers = append(codePointers, pointer)
+
+		case COMMENT:
+			continue
+
+		case COMPARE:
+			switch operands := x.Data.(type) {
+			case *RegisterNumber:
+				code = x64.CompareRegisterNumber(code, operands.Register, operands.Number)
+			case *RegisterRegister:
+				code = x64.CompareRegisterRegister(code, operands.Destination, operands.Source)
+			}
+
+		case JE, JNE, JG, JGE, JL, JLE, JUMP:
+			switch x.Mnemonic {
+			case JE:
+				code = x64.Jump8IfEqual(code, 0x00)
+			case JNE:
+				code = x64.Jump8IfNotEqual(code, 0x00)
+			case JG:
+				code = x64.Jump8IfGreater(code, 0x00)
+			case JGE:
+				code = x64.Jump8IfGreaterOrEqual(code, 0x00)
+			case JL:
+				code = x64.Jump8IfLess(code, 0x00)
+			case JLE:
+				code = x64.Jump8IfLessOrEqual(code, 0x00)
+			case JUMP:
+				code = x64.Jump8(code, 0x00)
+			}
+
+			size := 1
+			label := x.Data.(*Label)
+
+			pointer := &Pointer{
+				Position: Address(len(code) - size),
+				OpSize:   1,
+				Size:     uint8(size),
+			}
+
+			pointer.Resolve = func() Address {
+				destination, exists := codeLabels[label.Name]
+
+				if !exists {
+					panic("unknown jump label")
+				}
+
+				distance := destination - (pointer.Position + Address(pointer.Size))
+				return Address(distance)
+			}
+
+			codePointers = append(codePointers, pointer)
+
+		case LABEL:
+			codeLabels[x.Data.(*Label).Name] = Address(len(code))
+
+		case LOAD:
+			switch operands := x.Data.(type) {
+			case *MemoryRegister:
+				code = x64.LoadRegister(code, operands.Register, operands.Address.Offset, operands.Address.Length, operands.Address.Base)
+			}
+
+		case MOVE:
+			switch operands := x.Data.(type) {
+			case *RegisterNumber:
+				code = x64.MoveRegisterNumber(code, operands.Register, operands.Number)
+
+			case *RegisterRegister:
+				code = x64.MoveRegisterRegister(code, operands.Destination, operands.Source)
+
+			case *RegisterLabel:
+				start := len(code)
+				code = x64.MoveRegisterNumber(code, operands.Register, 0x00_00_00_00)
+				size := 4
+				opSize := len(code) - size - start
+				regLabel := x.Data.(*RegisterLabel)
+
+				if !strings.HasPrefix(regLabel.Label, "data_") {
+					panic("non-data moves not implemented yet")
+				}
+
+				dataPointers = append(dataPointers, &Pointer{
+					Position: Address(len(code) - size),
+					OpSize:   uint8(opSize),
+					Size:     uint8(size),
+					Resolve: func() Address {
+						destination, exists := dataLabels[regLabel.Label]
+
+						if !exists {
+							panic("unknown label")
+						}
+
+						return Address(destination)
+					},
+				})
+			}
+
+		case NEGATE:
+			switch operands := x.Data.(type) {
+			case *Register:
+				code = x64.NegateRegister(code, operands.Register)
+			}
+
+		case OR:
+			switch operands := x.Data.(type) {
+			case *RegisterNumber:
+				code = x64.OrRegisterNumber(code, operands.Register, operands.Number)
+			case *RegisterRegister:
+				code = x64.OrRegisterRegister(code, operands.Destination, operands.Source)
+			}
+
+		case POP:
+			switch operands := x.Data.(type) {
+			case *Register:
+				code = x64.PopRegister(code, operands.Register)
+			}
+
+		case PUSH:
+			switch operands := x.Data.(type) {
+			case *Register:
+				code = x64.PushRegister(code, operands.Register)
+			}
+
+		case RETURN:
+			code = x64.Return(code)
+
+		case SHIFTL:
+			switch operands := x.Data.(type) {
+			case *RegisterNumber:
+				code = x64.ShiftLeftNumber(code, operands.Register, byte(operands.Number)&0b111111)
+			}
+
+		case SHIFTRS:
+			switch operands := x.Data.(type) {
+			case *RegisterNumber:
+				code = x64.ShiftRightSignedNumber(code, operands.Register, byte(operands.Number)&0b111111)
+			}
+
+		case STORE:
+			switch operands := x.Data.(type) {
+			case *MemoryNumber:
+				code = x64.StoreNumber(code, operands.Address.Base, operands.Address.Offset, operands.Address.Length, operands.Number)
+			case *MemoryRegister:
+				code = x64.StoreRegister(code, operands.Address.Base, operands.Address.Offset, operands.Address.Length, operands.Register)
+			}
+
+		case SYSCALL:
+			code = x64.Syscall(code)
+
+		case XOR:
+			switch operands := x.Data.(type) {
+			case *RegisterNumber:
+				code = x64.XorRegisterNumber(code, operands.Register, operands.Number)
+			case *RegisterRegister:
+				code = x64.XorRegisterRegister(code, operands.Destination, operands.Source)
+			}
+
+		default:
+			panic("unknown mnemonic: " + x.Mnemonic.String())
+		}
+	}
+
+restart:
+	for i, pointer := range codePointers {
+		address := pointer.Resolve()
+
+		if sizeof.Signed(int64(address)) > int(pointer.Size) {
+			left := code[:pointer.Position-Address(pointer.OpSize)]
+			right := code[pointer.Position+Address(pointer.Size):]
+			size := pointer.Size + pointer.OpSize
+			opCode := code[pointer.Position-Address(pointer.OpSize)]
+
+			var jump []byte
+
+			switch opCode {
+			case 0x74: // JE
+				jump = []byte{0x0F, 0x84}
+			case 0x75: // JNE
+				jump = []byte{0x0F, 0x85}
+			case 0x7C: // JL
+				jump = []byte{0x0F, 0x8C}
+			case 0x7D: // JGE
+				jump = []byte{0x0F, 0x8D}
+			case 0x7E: // JLE
+				jump = []byte{0x0F, 0x8E}
+			case 0x7F: // JG
+				jump = []byte{0x0F, 0x8F}
+			case 0xEB: // JMP
+				jump = []byte{0xE9}
+			default:
+				panic(fmt.Errorf("failed to increase pointer size for instruction 0x%x", opCode))
+			}
+
+			pointer.Position += Address(len(jump) - int(pointer.OpSize))
+			pointer.OpSize = uint8(len(jump))
+			pointer.Size = 4
+			jump = binary.LittleEndian.AppendUint32(jump, uint32(address))
+			offset := Address(len(jump)) - Address(size)
+
+			for _, following := range codePointers[i+1:] {
+				following.Position += offset
+			}
+
+			for key, address := range codeLabels {
+				if address > pointer.Position {
+					codeLabels[key] += offset
+				}
+			}
+
+			code = slices.Concat(left, jump, right)
+			goto restart
+		}
+
+		slice := code[pointer.Position : pointer.Position+Address(pointer.Size)]
+
+		switch pointer.Size {
+		case 1:
+			slice[0] = uint8(address)
+		case 2:
+			binary.LittleEndian.PutUint16(slice, uint16(address))
+		case 4:
+			binary.LittleEndian.PutUint32(slice, uint32(address))
+		case 8:
+			binary.LittleEndian.PutUint64(slice, uint64(address))
+		}
+	}
+
+	data, dataLabels = a.Data.Finalize()
+	dataStart := config.BaseAddress + config.CodeOffset + Address(len(code))
+	dataStart += int32(elf.Padding(int64(dataStart), config.Align))
+
+	for _, pointer := range dataPointers {
+		address := dataStart + pointer.Resolve()
+		slice := code[pointer.Position : pointer.Position+4]
+		binary.LittleEndian.PutUint32(slice, uint32(address))
+	}
+
+	return code, data
+}

src/asm/Instruction.go

@@ -0,0 +1,9 @@
+package asm
+
+import "fmt"
+
+// Instruction represents a single instruction which can be converted to machine code.
+type Instruction struct {
+	Data     fmt.Stringer
+	Mnemonic Mnemonic
+}

src/asm/Instructions.go

@@ -0,0 +1,39 @@
+package asm
+
+// Comment adds a comment at the current position.
+func (a *Assembler) Comment(text string) {
+	a.Instructions = append(a.Instructions, Instruction{
+		Mnemonic: COMMENT,
+		Data: &Label{
+			Name: text,
+		},
+	})
+}
+
+// Call calls a function whose position is identified by a label.
+func (a *Assembler) Call(name string) {
+	a.Instructions = append(a.Instructions, Instruction{
+		Mnemonic: CALL,
+		Data: &Label{
+			Name: name,
+		},
+	})
+}
+
+// Return returns back to the caller.
+func (a *Assembler) Return() {
+	if len(a.Instructions) > 0 {
+		lastMnemonic := a.Instructions[len(a.Instructions)-1].Mnemonic
+
+		if lastMnemonic == RETURN || lastMnemonic == JUMP {
+			return
+		}
+	}
+
+	a.Instructions = append(a.Instructions, Instruction{Mnemonic: RETURN})
+}
+
+// Syscall executes a kernel function.
+func (a *Assembler) Syscall() {
+	a.Instructions = append(a.Instructions, Instruction{Mnemonic: SYSCALL})
+}

src/asm/Label.go

@@ -0,0 +1,21 @@
+package asm
+
+// Label represents a jump label.
+type Label struct {
+	Name string
+}
+
+// String returns a human readable version.
+func (data *Label) String() string {
+	return data.Name
+}
+
+// Label adds an instruction using a label.
+func (a *Assembler) Label(mnemonic Mnemonic, name string) {
+	a.Instructions = append(a.Instructions, Instruction{
+		Mnemonic: mnemonic,
+		Data: &Label{
+			Name: name,
+		},
+	})
+}

src/asm/Memory.go

@@ -0,0 +1,9 @@
+package asm
+
+import "git.akyoto.dev/cli/q/src/cpu"
+
+type Memory struct {
+	Base   cpu.Register
+	Offset byte
+	Length byte
+}

src/asm/MemoryNumber.go

@@ -0,0 +1,27 @@
+package asm
+
+import (
+	"fmt"
+)
+
+// MemoryNumber operates with a memory address and a number.
+type MemoryNumber struct {
+	Address Memory
+	Number  int
+}
+
+// String returns a human readable version.
+func (data *MemoryNumber) String() string {
+	return fmt.Sprintf("%dB [%s+%d], %d", data.Address.Length, data.Address.Base, data.Address.Offset, data.Number)
+}
+
+// MemoryNumber adds an instruction with a memory address and a number.
+func (a *Assembler) MemoryNumber(mnemonic Mnemonic, address Memory, number int) {
+	a.Instructions = append(a.Instructions, Instruction{
+		Mnemonic: mnemonic,
+		Data: &MemoryNumber{
+			Address: address,
+			Number:  number,
+		},
+	})
+}

src/asm/MemoryRegister.go

@@ -0,0 +1,29 @@
+package asm
+
+import (
+	"fmt"
+
+	"git.akyoto.dev/cli/q/src/cpu"
+)
+
+// MemoryRegister operates with a memory address and a number.
+type MemoryRegister struct {
+	Address  Memory
+	Register cpu.Register
+}
+
+// String returns a human readable version.
+func (data *MemoryRegister) String() string {
+	return fmt.Sprintf("%dB [%s+%d], %s", data.Address.Length, data.Address.Base, data.Address.Offset, data.Register)
+}
+
+// MemoryRegister adds an instruction with a memory address and a number.
+func (a *Assembler) MemoryRegister(mnemonic Mnemonic, address Memory, register cpu.Register) {
+	a.Instructions = append(a.Instructions, Instruction{
+		Mnemonic: mnemonic,
+		Data: &MemoryRegister{
+			Address:  address,
+			Register: register,
+		},
+	})
+}

src/asm/Mnemonic.go

@@ -0,0 +1,112 @@
+package asm
+
+type Mnemonic uint8
+
+const (
+	NONE Mnemonic = iota
+
+	// Arithmetic
+	ADD
+	DIV
+	MODULO
+	MUL
+	NEGATE
+	SUB
+
+	// Bitwise operations
+	AND
+	OR
+	SHIFTL
+	SHIFTRS
+	XOR
+
+	// Data movement
+	MOVE
+	LOAD
+	POP
+	PUSH
+	STORE
+
+	// Control flow
+	CALL
+	JE
+	JNE
+	JG
+	JGE
+	JL
+	JLE
+	JUMP
+	LABEL
+	RETURN
+	SYSCALL
+
+	// Others
+	COMMENT
+	COMPARE
+)
+
+// String returns a human readable version.
+func (m Mnemonic) String() string {
+	switch m {
+	case ADD:
+		return "add"
+	case AND:
+		return "and"
+	case CALL:
+		return "call"
+	case COMMENT:
+		return "comment"
+	case COMPARE:
+		return "compare"
+	case DIV:
+		return "div"
+	case JUMP:
+		return "jump"
+	case JE:
+		return "jump if =="
+	case JNE:
+		return "jump if !="
+	case JL:
+		return "jump if <"
+	case JG:
+		return "jump if >"
+	case JLE:
+		return "jump if <="
+	case JGE:
+		return "jump if >="
+	case LABEL:
+		return "label"
+	case LOAD:
+		return "load"
+	case MODULO:
+		return "mod"
+	case MOVE:
+		return "move"
+	case MUL:
+		return "mul"
+	case NEGATE:
+		return "negate"
+	case OR:
+		return "or"
+	case POP:
+		return "pop"
+	case PUSH:
+		return "push"
+	case RETURN:
+		return "return"
+	case SHIFTL:
+		return "shift l"
+	case SHIFTRS:
+		return "shift rs"
+	case SUB:
+		return "sub"
+	case STORE:
+		return "store"
+	case SYSCALL:
+		return "syscall"
+	case XOR:
+		return "xor"
+	default:
+		return ""
+	}
+}

src/asm/Optimizer.go

@@ -0,0 +1,30 @@
+package asm
+
+import "git.akyoto.dev/cli/q/src/cpu"
+
+// unnecessary returns true if the register/register operation can be skipped.
+func (a *Assembler) unnecessary(mnemonic Mnemonic, left cpu.Register, right cpu.Register) bool {
+	if len(a.Instructions) == 0 {
+		return false
+	}
+
+	last := a.Instructions[len(a.Instructions)-1]
+
+	if mnemonic == MOVE && last.Mnemonic == MOVE {
+		data, isRegReg := last.Data.(*RegisterRegister)
+
+		if !isRegReg {
+			return false
+		}
+
+		if data.Destination == left && data.Source == right {
+			return true
+		}
+
+		if data.Destination == right && data.Source == left {
+			return true
+		}
+	}
+
+	return false
+}

src/asm/Pointer.go

@@ -0,0 +1,14 @@
+package asm
+
+// Address represents a memory address.
+type Address = int32
+
+// Pointer stores a relative memory address that we can later turn into an absolute one.
+// Position: The machine code offset where the address was inserted.
+// Resolve:  The function that will return the final address.
+type Pointer struct {
+	Resolve  func() Address
+	Position Address
+	OpSize   uint8
+	Size     uint8
+}

src/asm/Register.go

@@ -0,0 +1,25 @@
+package asm
+
+import (
+	"git.akyoto.dev/cli/q/src/cpu"
+)
+
+// Register operates with a single register.
+type Register struct {
+	Register cpu.Register
+}
+
+// String returns a human readable version.
+func (data *Register) String() string {
+	return data.Register.String()
+}
+
+// Register adds an instruction using a single register.
+func (a *Assembler) Register(mnemonic Mnemonic, register cpu.Register) {
+	a.Instructions = append(a.Instructions, Instruction{
+		Mnemonic: mnemonic,
+		Data: &Register{
+			Register: register,
+		},
+	})
+}

src/asm/RegisterLabel.go

@@ -0,0 +1,29 @@
+package asm
+
+import (
+	"fmt"
+
+	"git.akyoto.dev/cli/q/src/cpu"
+)
+
+// RegisterLabel operates with a register and a label.
+type RegisterLabel struct {
+	Label    string
+	Register cpu.Register
+}
+
+// String returns a human readable version.
+func (data *RegisterLabel) String() string {
+	return fmt.Sprintf("%s, %s", data.Register, data.Label)
+}
+
+// RegisterLabel adds an instruction with a register and a label.
+func (a *Assembler) RegisterLabel(mnemonic Mnemonic, reg cpu.Register, label string) {
+	a.Instructions = append(a.Instructions, Instruction{
+		Mnemonic: mnemonic,
+		Data: &RegisterLabel{
+			Register: reg,
+			Label:    label,
+		},
+	})
+}

src/asm/RegisterNumber.go

@@ -0,0 +1,29 @@
+package asm
+
+import (
+	"fmt"
+
+	"git.akyoto.dev/cli/q/src/cpu"
+)
+
+// RegisterNumber operates with a register and a number.
+type RegisterNumber struct {
+	Register cpu.Register
+	Number   int
+}
+
+// String returns a human readable version.
+func (data *RegisterNumber) String() string {
+	return fmt.Sprintf("%s, %d", data.Register, data.Number)
+}
+
+// RegisterNumber adds an instruction with a register and a number.
+func (a *Assembler) RegisterNumber(mnemonic Mnemonic, reg cpu.Register, number int) {
+	a.Instructions = append(a.Instructions, Instruction{
+		Mnemonic: mnemonic,
+		Data: &RegisterNumber{
+			Register: reg,
+			Number:   number,
+		},
+	})
+}

src/asm/RegisterRegister.go

@@ -0,0 +1,33 @@
+package asm
+
+import (
+	"fmt"
+
+	"git.akyoto.dev/cli/q/src/cpu"
+)
+
+// RegisterRegister operates with two registers.
+type RegisterRegister struct {
+	Destination cpu.Register
+	Source      cpu.Register
+}
+
+// String returns a human readable version.
+func (data *RegisterRegister) String() string {
+	return fmt.Sprintf("%s, %s", data.Destination, data.Source)
+}
+
+// RegisterRegister adds an instruction using two registers.
+func (a *Assembler) RegisterRegister(mnemonic Mnemonic, left cpu.Register, right cpu.Register) {
+	if a.unnecessary(mnemonic, left, right) {
+		return
+	}
+
+	a.Instructions = append(a.Instructions, Instruction{
+		Mnemonic: mnemonic,
+		Data: &RegisterRegister{
+			Destination: left,
+			Source:      right,
+		},
+	})
+}