93 lines
2.2 KiB
Go
93 lines
2.2 KiB
Go
package asm
|
|
|
|
import (
|
|
"encoding/binary"
|
|
|
|
"git.akyoto.dev/cli/q/src/config"
|
|
"git.akyoto.dev/cli/q/src/log"
|
|
"git.akyoto.dev/cli/q/src/register"
|
|
"git.akyoto.dev/cli/q/src/x64"
|
|
)
|
|
|
|
// Assembler contains a list of instructions.
|
|
type Assembler struct {
|
|
Instructions []Instruction
|
|
}
|
|
|
|
// New creates a new assembler.
|
|
func New() *Assembler {
|
|
return &Assembler{
|
|
Instructions: make([]Instruction, 0, 8),
|
|
}
|
|
}
|
|
|
|
// Finalize generates the final machine code.
|
|
func (a *Assembler) Finalize() ([]byte, []byte) {
|
|
code := make([]byte, 0, len(a.Instructions)*8)
|
|
data := make(Data, 0, 16)
|
|
pointers := []Pointer{}
|
|
|
|
for _, x := range a.Instructions {
|
|
switch x.Mnemonic {
|
|
case MOV:
|
|
code = x64.MoveRegNum32(code, uint8(x.Destination), uint32(x.Number))
|
|
|
|
case MOVDATA:
|
|
code = x64.MoveRegNum32(code, uint8(x.Destination), 0)
|
|
|
|
pointers = append(pointers, Pointer{
|
|
Position: Address(len(code) - 4),
|
|
Address: data.Add(x.Data),
|
|
})
|
|
|
|
case SYSCALL:
|
|
code = x64.Syscall(code)
|
|
}
|
|
}
|
|
|
|
if config.Verbose {
|
|
for _, x := range a.Instructions {
|
|
log.Info.Println(x.String())
|
|
}
|
|
}
|
|
|
|
dataStart := config.BaseAddress + config.CodeOffset + Address(len(code))
|
|
|
|
for _, pointer := range pointers {
|
|
slice := code[pointer.Position : pointer.Position+4]
|
|
address := dataStart + pointer.Address
|
|
binary.LittleEndian.PutUint32(slice, address)
|
|
}
|
|
|
|
return code, data
|
|
}
|
|
|
|
// Merge combines the contents of this assembler with another one.
|
|
func (a *Assembler) Merge(b *Assembler) {
|
|
a.Instructions = append(a.Instructions, b.Instructions...)
|
|
}
|
|
|
|
// MoveRegisterData moves a data section address into the given register.
|
|
func (a *Assembler) MoveRegisterData(reg register.ID, data []byte) {
|
|
a.Instructions = append(a.Instructions, Instruction{
|
|
Mnemonic: MOVDATA,
|
|
Destination: reg,
|
|
Data: data,
|
|
})
|
|
}
|
|
|
|
// MoveRegisterNumber moves a number into the given register.
|
|
func (a *Assembler) MoveRegisterNumber(reg register.ID, number uint64) {
|
|
a.Instructions = append(a.Instructions, Instruction{
|
|
Mnemonic: MOV,
|
|
Destination: reg,
|
|
Number: number,
|
|
})
|
|
}
|
|
|
|
// Syscall executes a kernel function.
|
|
func (a *Assembler) Syscall() {
|
|
a.Instructions = append(a.Instructions, Instruction{
|
|
Mnemonic: SYSCALL,
|
|
})
|
|
}
|