cli/q
Code Issues Pull Requests Activity

Implemented 64-bit move

Browse Source
This commit is contained in:
Eduard Urbach 2024-07-26 16:19:13 +02:00
parent 123738f88c
commit bf80551a15
Signed by: akyoto
GPG Key ID: C874F672B1AF20C0
8 changed files with 62 additions and 29 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
examples/itoa/itoa.q
View File

@ -1,5 +1,5 @@
import io import log
main() { main() {
io.printNum(2147483647) log.number(9223372036854775807)
} }

2
lib/io/io.q → lib/log/number.q
View File

@ -1,7 +1,7 @@
import mem import mem
import sys import sys
printNum(x) { number(x) {
length := 20 length := 20
buffer := mem.alloc(length) buffer := mem.alloc(length)
end := buffer + length end := buffer + length

30
src/build/arch/x64/Move.go
View File

@ -6,18 +6,34 @@ import (
"git.akyoto.dev/cli/q/src/build/cpu" "git.akyoto.dev/cli/q/src/build/cpu"
) )
// MoveRegisterNumber32 moves a 32 bit integer into the given register. // MoveRegisterNumber moves an integer into the given register.
func MoveRegisterNumber32(code []byte, destination cpu.Register, number uint32) []byte { func MoveRegisterNumber(code []byte, destination cpu.Register, number int) []byte {
w := byte(0)
b := byte(0)
if SizeOf(int64(number)) == 8 {
w = 1
}
if destination > 0b111 { if destination > 0b111 {
code = append(code, REX(0, 0, 0, 1)) b = 1
destination &= 0b111 destination &= 0b111
} }
code = append(code, 0xb8+byte(destination)) if w != 0 || b != 0 {
return binary.LittleEndian.AppendUint32(code, number) code = append(code, REX(w, 0, 0, b))
} }
// MoveRegisterRegister64 moves a register value into another register. code = append(code, 0xB8+byte(destination))
func MoveRegisterRegister64(code []byte, destination cpu.Register, source cpu.Register) []byte {
if w == 1 {
return binary.LittleEndian.AppendUint64(code, uint64(number))
} else {
return binary.LittleEndian.AppendUint32(code, uint32(number))
}
}
// MoveRegisterRegister moves a register value into another register.
func MoveRegisterRegister(code []byte, destination cpu.Register, source cpu.Register) []byte {
return encode(code, AddressDirect, source, destination, 8, 0x89) return encode(code, AddressDirect, source, destination, 8, 0x89)
} }

21
src/build/arch/x64/Move_test.go
View File

@ -30,11 +30,28 @@ func TestMoveRegisterNumber(t *testing.T) {
{x64.R13, 0x7FFFFFFF, []byte{0x41, 0xBD, 0xFF, 0xFF, 0xFF, 0x7F}}, {x64.R13, 0x7FFFFFFF, []byte{0x41, 0xBD, 0xFF, 0xFF, 0xFF, 0x7F}},
{x64.R14, 0x7FFFFFFF, []byte{0x41, 0xBE, 0xFF, 0xFF, 0xFF, 0x7F}}, {x64.R14, 0x7FFFFFFF, []byte{0x41, 0xBE, 0xFF, 0xFF, 0xFF, 0x7F}},
{x64.R15, 0x7FFFFFFF, []byte{0x41, 0xBF, 0xFF, 0xFF, 0xFF, 0x7F}}, {x64.R15, 0x7FFFFFFF, []byte{0x41, 0xBF, 0xFF, 0xFF, 0xFF, 0x7F}},
{x64.RAX, 0x7FFFFFFFFFFFFFFF, []byte{0x48, 0xB8, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
{x64.RCX, 0x7FFFFFFFFFFFFFFF, []byte{0x48, 0xB9, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
{x64.RDX, 0x7FFFFFFFFFFFFFFF, []byte{0x48, 0xBA, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
{x64.RBX, 0x7FFFFFFFFFFFFFFF, []byte{0x48, 0xBB, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
{x64.RSP, 0x7FFFFFFFFFFFFFFF, []byte{0x48, 0xBC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
{x64.RBP, 0x7FFFFFFFFFFFFFFF, []byte{0x48, 0xBD, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
{x64.RSI, 0x7FFFFFFFFFFFFFFF, []byte{0x48, 0xBE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
{x64.RDI, 0x7FFFFFFFFFFFFFFF, []byte{0x48, 0xBF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
{x64.R8, 0x7FFFFFFFFFFFFFFF, []byte{0x49, 0xB8, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
{x64.R9, 0x7FFFFFFFFFFFFFFF, []byte{0x49, 0xB9, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
{x64.R10, 0x7FFFFFFFFFFFFFFF, []byte{0x49, 0xBA, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
{x64.R11, 0x7FFFFFFFFFFFFFFF, []byte{0x49, 0xBB, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
{x64.R12, 0x7FFFFFFFFFFFFFFF, []byte{0x49, 0xBC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
{x64.R13, 0x7FFFFFFFFFFFFFFF, []byte{0x49, 0xBD, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
{x64.R14, 0x7FFFFFFFFFFFFFFF, []byte{0x49, 0xBE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
{x64.R15, 0x7FFFFFFFFFFFFFFF, []byte{0x49, 0xBF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
} }
for _, pattern := range usagePatterns { for _, pattern := range usagePatterns {
t.Logf("mov %s, %x", pattern.Register, pattern.Number) t.Logf("mov %s, %x", pattern.Register, pattern.Number)
code := x64.MoveRegisterNumber32(nil, pattern.Register, uint32(pattern.Number)) code := x64.MoveRegisterNumber(nil, pattern.Register, pattern.Number)
assert.DeepEqual(t, code, pattern.Code) assert.DeepEqual(t, code, pattern.Code)
} }
} }
@ -65,7 +82,7 @@ func TestMoveRegisterRegister(t *testing.T) {
for _, pattern := range usagePatterns { for _, pattern := range usagePatterns {
t.Logf("mov %s, %s", pattern.Left, pattern.Right) t.Logf("mov %s, %s", pattern.Left, pattern.Right)
code := x64.MoveRegisterRegister64(nil, pattern.Left, pattern.Right) code := x64.MoveRegisterRegister(nil, pattern.Left, pattern.Right)
assert.DeepEqual(t, code, pattern.Code) assert.DeepEqual(t, code, pattern.Code)
} }
} }

4
src/build/arch/x64/x64_test.go
View File

@ -9,8 +9,8 @@ import (
func TestX64(t *testing.T) { func TestX64(t *testing.T) {
assert.DeepEqual(t, x64.Call(nil, 1), []byte{0xe8, 0x01, 0x00, 0x00, 0x00}) assert.DeepEqual(t, x64.Call(nil, 1), []byte{0xe8, 0x01, 0x00, 0x00, 0x00})
assert.DeepEqual(t, x64.MoveRegisterNumber32(nil, 0, 1), []byte{0xb8, 0x01, 0x00, 0x00, 0x00}) assert.DeepEqual(t, x64.MoveRegisterNumber(nil, 0, 1), []byte{0xb8, 0x01, 0x00, 0x00, 0x00})
assert.DeepEqual(t, x64.MoveRegisterNumber32(nil, 1, 1), []byte{0xb9, 0x01, 0x00, 0x00, 0x00}) assert.DeepEqual(t, x64.MoveRegisterNumber(nil, 1, 1), []byte{0xb9, 0x01, 0x00, 0x00, 0x00})
assert.DeepEqual(t, x64.Return(nil), []byte{0xc3}) assert.DeepEqual(t, x64.Return(nil), []byte{0xc3})
assert.DeepEqual(t, x64.Syscall(nil), []byte{0x0f, 0x05}) assert.DeepEqual(t, x64.Syscall(nil), []byte{0x0f, 0x05})
assert.DeepEqual(t, x64.ExtendRAXToRDX(nil), []byte{0x48, 0x99}) assert.DeepEqual(t, x64.ExtendRAXToRDX(nil), []byte{0x48, 0x99})

6
src/build/asm/Finalize.go
View File

@ -133,14 +133,14 @@ func (a Assembler) Finalize() ([]byte, []byte) {
case MOVE: case MOVE:
switch operands := x.Data.(type) { switch operands := x.Data.(type) {
case *RegisterNumber: case *RegisterNumber:
code = x64.MoveRegisterNumber32(code, operands.Register, uint32(operands.Number)) code = x64.MoveRegisterNumber(code, operands.Register, operands.Number)
case *RegisterRegister: case *RegisterRegister:
code = x64.MoveRegisterRegister64(code, operands.Destination, operands.Source) code = x64.MoveRegisterRegister(code, operands.Destination, operands.Source)
case *RegisterLabel: case *RegisterLabel:
start := len(code) start := len(code)
code = x64.MoveRegisterNumber32(code, operands.Register, 0x00_00_00_00) code = x64.MoveRegisterNumber(code, operands.Register, 0x00_00_00_00)
size := 4 size := 4
opSize := len(code) - size - start opSize := len(code) - size - start
regLabel := x.Data.(*RegisterLabel) regLabel := x.Data.(*RegisterLabel)

22
src/build/asm/divide.go
View File

@ -7,15 +7,15 @@ func divide(code []byte, data any) []byte {
switch operands := data.(type) { switch operands := data.(type) {
case *RegisterNumber: case *RegisterNumber:
if operands.Register == x64.RAX { if operands.Register == x64.RAX {
code = x64.MoveRegisterNumber32(code, x64.RCX, uint32(operands.Number)) code = x64.MoveRegisterNumber(code, x64.RCX, operands.Number)
code = x64.ExtendRAXToRDX(code) code = x64.ExtendRAXToRDX(code)
code = x64.DivRegister(code, x64.RCX) code = x64.DivRegister(code, x64.RCX)
} else { } else {
code = x64.MoveRegisterRegister64(code, x64.RAX, operands.Register) code = x64.MoveRegisterRegister(code, x64.RAX, operands.Register)
code = x64.MoveRegisterNumber32(code, operands.Register, uint32(operands.Number)) code = x64.MoveRegisterNumber(code, operands.Register, operands.Number)
code = x64.ExtendRAXToRDX(code) code = x64.ExtendRAXToRDX(code)
code = x64.DivRegister(code, operands.Register) code = x64.DivRegister(code, operands.Register)
code = x64.MoveRegisterRegister64(code, operands.Register, x64.RAX) code = x64.MoveRegisterRegister(code, operands.Register, x64.RAX)
} }
case *RegisterRegister: case *RegisterRegister:
@ -23,11 +23,11 @@ func divide(code []byte, data any) []byte {
code = x64.ExtendRAXToRDX(code) code = x64.ExtendRAXToRDX(code)
code = x64.DivRegister(code, operands.Source) code = x64.DivRegister(code, operands.Source)
} else { } else {
code = x64.MoveRegisterRegister64(code, x64.RAX, operands.Destination) code = x64.MoveRegisterRegister(code, x64.RAX, operands.Destination)
code = x64.ExtendRAXToRDX(code) code = x64.ExtendRAXToRDX(code)
code = x64.DivRegister(code, operands.Source) code = x64.DivRegister(code, operands.Source)
code = x64.MoveRegisterRegister64(code, operands.Destination, x64.RAX) code = x64.MoveRegisterRegister(code, operands.Destination, x64.RAX)
} }
} }
return code return code
@ -37,17 +37,17 @@ func divide(code []byte, data any) []byte {
func modulo(code []byte, data any) []byte { func modulo(code []byte, data any) []byte {
switch operands := data.(type) { switch operands := data.(type) {
case *RegisterNumber: case *RegisterNumber:
code = x64.MoveRegisterRegister64(code, x64.RAX, operands.Register) code = x64.MoveRegisterRegister(code, x64.RAX, operands.Register)
code = x64.MoveRegisterNumber32(code, operands.Register, uint32(operands.Number)) code = x64.MoveRegisterNumber(code, operands.Register, operands.Number)
code = x64.ExtendRAXToRDX(code) code = x64.ExtendRAXToRDX(code)
code = x64.DivRegister(code, operands.Register) code = x64.DivRegister(code, operands.Register)
code = x64.MoveRegisterRegister64(code, operands.Register, x64.RDX) code = x64.MoveRegisterRegister(code, operands.Register, x64.RDX)
case *RegisterRegister: case *RegisterRegister:
code = x64.MoveRegisterRegister64(code, x64.RAX, operands.Destination) code = x64.MoveRegisterRegister(code, x64.RAX, operands.Destination)
code = x64.ExtendRAXToRDX(code) code = x64.ExtendRAXToRDX(code)
code = x64.DivRegister(code, operands.Source) code = x64.DivRegister(code, operands.Source)
code = x64.MoveRegisterRegister64(code, operands.Destination, x64.RDX) code = x64.MoveRegisterRegister(code, operands.Destination, x64.RDX)
} }
return code return code

2
tests/examples_test.go
View File

@ -18,7 +18,7 @@ var examples = []struct {
{"factorial", "", "", 120}, {"factorial", "", "", 120},
{"fibonacci", "", "", 55}, {"fibonacci", "", "", 55},
{"array", "", "Hello", 0}, {"array", "", "Hello", 0},
{"itoa", "", "2147483647", 0}, {"itoa", "", "9223372036854775807", 0},
} }
func TestExamples(t *testing.T) { func TestExamples(t *testing.T) {