cli/q
Code Issues 1 Pull Requests Activity

Implemented simple expressions

Browse Source
This commit is contained in:
Eduard Urbach
2024-06-25 20:50:06 +02:00
parent 2569c1bf63
commit e6462266ef
12 changed files with 232 additions and 52 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
src/build/arch/x64/Add.go
View File

@ -6,5 +6,37 @@ import (
// AddRegNum adds a number to the given register.
func AddRegNum(code []byte, destination cpu.Register, number int) []byte {
return numRegReg(code, 0x83, 0x81, 0, byte(destination), number)
return numRegReg(code, 0, byte(destination), number, 0x83, 0x81)
}
// AddRegReg adds a number to the given register.
func AddRegReg(code []byte, destination cpu.Register, operand cpu.Register) []byte {
return regReg(code, byte(operand), byte(destination), 0x01)
}
func regReg(code []byte, reg byte, rm byte, opCodes ...byte) []byte {
w := byte(1) // Indicates a 64-bit register.
r := byte(0) // Extension to the "reg" field in ModRM.
x := byte(0) // Extension to the SIB index field.
b := byte(0) // Extension to the "rm" field in ModRM or the SIB base (r8 up to r15 use this).
mod := byte(0b11) // Direct addressing mode, no register offsets.
if reg > 0b111 {
r = 1
reg &= 0b111
}
if rm > 0b111 {
b = 1
rm &= 0b111
}
rex := REX(w, r, x, b)
modRM := ModRM(mod, reg, rm)
code = append(code, rex)
code = append(code, opCodes...)
code = append(code, modRM)
return code
}

31
src/build/arch/x64/Add_test.go
View File

@ -55,3 +55,34 @@ func TestAddRegisterNumber(t *testing.T) {
assert.DeepEqual(t, code, pattern.Code)
}
}
func TestAddRegisterRegister(t *testing.T) {
usagePatterns := []struct {
Left cpu.Register
Right cpu.Register
Code []byte
}{
{x64.RAX, x64.R15, []byte{0x4C, 0x01, 0xF8}},
{x64.RCX, x64.R14, []byte{0x4C, 0x01, 0xF1}},
{x64.RDX, x64.R13, []byte{0x4C, 0x01, 0xEA}},
{x64.RBX, x64.R12, []byte{0x4C, 0x01, 0xE3}},
{x64.RSP, x64.R11, []byte{0x4C, 0x01, 0xDC}},
{x64.RBP, x64.R10, []byte{0x4C, 0x01, 0xD5}},
{x64.RSI, x64.R9, []byte{0x4C, 0x01, 0xCE}},
{x64.RDI, x64.R8, []byte{0x4C, 0x01, 0xC7}},
{x64.R8, x64.RDI, []byte{0x49, 0x01, 0xF8}},
{x64.R9, x64.RSI, []byte{0x49, 0x01, 0xF1}},
{x64.R10, x64.RBP, []byte{0x49, 0x01, 0xEA}},
{x64.R11, x64.RSP, []byte{0x49, 0x01, 0xE3}},
{x64.R12, x64.RBX, []byte{0x49, 0x01, 0xDC}},
{x64.R13, x64.RDX, []byte{0x49, 0x01, 0xD5}},
{x64.R14, x64.RCX, []byte{0x49, 0x01, 0xCE}},
{x64.R15, x64.RAX, []byte{0x49, 0x01, 0xC7}},
}
for _, pattern := range usagePatterns {
t.Logf("add %s, %s", pattern.Left, pattern.Right)
code := x64.AddRegReg(nil, pattern.Left, pattern.Right)
assert.DeepEqual(t, code, pattern.Code)
}
}

7
src/build/arch/x64/Mul.go
View File

@ -4,5 +4,10 @@ import "git.akyoto.dev/cli/q/src/build/cpu"
// MulRegNum multiplies a register with a number.
func MulRegNum(code []byte, destination cpu.Register, number int) []byte {
return numRegReg(code, 0x6B, 0x69, byte(destination), byte(destination), number)
return numRegReg(code, byte(destination), byte(destination), number, 0x6B, 0x69)
}
// MulRegReg multiplies a register with another register.
func MulRegReg(code []byte, destination cpu.Register, operand cpu.Register) []byte {
return regReg(code, byte(destination), byte(operand), 0x0F, 0xAF)
}

31
src/build/arch/x64/Mul_test.go
View File

@ -55,3 +55,34 @@ func TestMulRegisterNumber(t *testing.T) {
assert.DeepEqual(t, code, pattern.Code)
}
}
func TestMulRegisterRegister(t *testing.T) {
usagePatterns := []struct {
Left cpu.Register
Right cpu.Register
Code []byte
}{
{x64.RAX, x64.R15, []byte{0x49, 0x0F, 0xAF, 0xC7}},
{x64.RCX, x64.R14, []byte{0x49, 0x0F, 0xAF, 0xCE}},
{x64.RDX, x64.R13, []byte{0x49, 0x0F, 0xAF, 0xD5}},
{x64.RBX, x64.R12, []byte{0x49, 0x0F, 0xAF, 0xDC}},
{x64.RSP, x64.R11, []byte{0x49, 0x0F, 0xAF, 0xE3}},
{x64.RBP, x64.R10, []byte{0x49, 0x0F, 0xAF, 0xEA}},
{x64.RSI, x64.R9, []byte{0x49, 0x0F, 0xAF, 0xF1}},
{x64.RDI, x64.R8, []byte{0x49, 0x0F, 0xAF, 0xF8}},
{x64.R8, x64.RDI, []byte{0x4C, 0x0F, 0xAF, 0xC7}},
{x64.R9, x64.RSI, []byte{0x4C, 0x0F, 0xAF, 0xCE}},
{x64.R10, x64.RBP, []byte{0x4C, 0x0F, 0xAF, 0xD5}},
{x64.R11, x64.RSP, []byte{0x4C, 0x0F, 0xAF, 0xDC}},
{x64.R12, x64.RBX, []byte{0x4C, 0x0F, 0xAF, 0xE3}},
{x64.R13, x64.RDX, []byte{0x4C, 0x0F, 0xAF, 0xEA}},
{x64.R14, x64.RCX, []byte{0x4C, 0x0F, 0xAF, 0xF1}},
{x64.R15, x64.RAX, []byte{0x4C, 0x0F, 0xAF, 0xF8}},
}
for _, pattern := range usagePatterns {
t.Logf("mul %s, %s", pattern.Left, pattern.Right)
code := x64.MulRegReg(nil, pattern.Left, pattern.Right)
assert.DeepEqual(t, code, pattern.Code)
}
}

7
src/build/arch/x64/Sub.go
View File

@ -6,5 +6,10 @@ import (
// SubRegNum subtracts a number from the given register.
func SubRegNum(code []byte, destination cpu.Register, number int) []byte {
return numRegReg(code, 0x83, 0x81, 0b101, byte(destination), number)
return numRegReg(code, 0b101, byte(destination), number, 0x83, 0x81)
}
// SubRegReg subtracts a register value from another register.
func SubRegReg(code []byte, destination cpu.Register, operand cpu.Register) []byte {
return regReg(code, byte(operand), byte(destination), 0x29)
}

34
src/build/arch/x64/numRegReg.go
View File

@ -1,41 +1,15 @@
package x64
// numRegReg encodes an instruction with up to two registers and a number parameter.
func numRegReg(code []byte, opCode8 byte, opCode32 byte, reg byte, rm byte, number int) []byte {
w := byte(1) // Indicates a 64-bit register.
r := byte(0) // Extension to the "reg" field in ModRM.
x := byte(0) // Extension to the SIB index field.
b := byte(0) // Extension to the "rm" field in ModRM or the SIB base (r8 up to r15 use this).
mod := byte(0b11) // Direct addressing mode, no register offsets.
if reg > 0b111 {
r = 1
reg &= 0b111
}
if rm > 0b111 {
b = 1
rm &= 0b111
}
rex := REX(w, r, x, b)
modRM := ModRM(mod, reg, rm)
func numRegReg(code []byte, reg byte, rm byte, number int, opCode8 byte, opCode32 byte) []byte {
if sizeOf(number) == 1 {
return append(
code,
rex,
opCode8,
modRM,
byte(number),
)
code = regReg(code, reg, rm, opCode8)
return append(code, byte(number))
}
code = regReg(code, reg, rm, opCode32)
return append(
code,
rex,
opCode32,
modRM,
byte(number),
byte(number>>8),
byte(number>>16),