cli/q
Code Issues 1 Pull Requests Activity

Fixed move instruction encoding on arm64

Browse Source
This commit is contained in:
Eduard Urbach
2025-03-15 13:49:30 +01:00
parent 99ef02bbd6
commit fea4e4cbe7
7 changed files with 108 additions and 74 deletions
Download Patch File Download Diff File Expand all files Collapse all files

105
src/arm/Move.go
View File

@ -1,10 +1,73 @@
package arm
import (
"encoding/binary"
"git.urbach.dev/cli/q/src/cpu"
"git.urbach.dev/cli/q/src/sizeof"
)
// MoveRegisterNumber moves a number into the given register.
func MoveRegisterNumber(code []byte, destination cpu.Register, number int) []byte {
instruction, encodable := MoveRegisterNumberSI(destination, number)
if encodable {
return binary.LittleEndian.AppendUint32(code, instruction)
}
return MoveRegisterNumberMI(code, destination, number)
}
// MoveRegisterNumberMI moves a number into the given register using movz and a series of movk instructions.
func MoveRegisterNumberMI(code []byte, destination cpu.Register, number int) []byte {
movz := MoveZero(destination, 0, uint16(number))
code = binary.LittleEndian.AppendUint32(code, movz)
halfword := 1
for {
number >>= 16
if number == 0 {
return code
}
movk := MoveKeep(destination, halfword, uint16(number))
code = binary.LittleEndian.AppendUint32(code, movk)
halfword++
}
}
// MoveRegisterNumberSI moves a number into the given register using a single instruction.
func MoveRegisterNumberSI(destination cpu.Register, number int) (uint32, bool) {
if sizeof.Signed(number) <= 2 {
if number < 0 {
return MoveInvertedWideImmediate(destination, uint16(^number), 0), true
}
return MoveZero(destination, 0, uint16(number)), true
}
if (number&0xFFFFFFFFFFFF == 0xFFFFFFFFFFFF) && sizeof.Signed(number>>48) <= 2 {
return MoveInvertedWideImmediate(destination, uint16((^number)>>48), 3), true
}
code, encodable := MoveBitmaskImmediate(destination, number)
if encodable {
return code, true
}
if (number&0xFFFFFFFF == 0xFFFFFFFF) && sizeof.Signed(number>>32) <= 2 {
return MoveInvertedWideImmediate(destination, uint16((^number)>>32), 2), true
}
if (number&0xFFFF == 0xFFFF) && sizeof.Signed(number>>16) <= 2 {
return MoveInvertedWideImmediate(destination, uint16((^number)>>16), 1), true
}
return 0, false
}
// MoveRegisterRegister copies a register to another register.
func MoveRegisterRegister(destination cpu.Register, source cpu.Register) uint32 {
if source == SP || destination == SP {
@ -14,58 +77,22 @@ func MoveRegisterRegister(destination cpu.Register, source cpu.Register) uint32
return OrRegisterRegister(destination, ZR, source)
}
// MoveRegisterNumber moves a number into the given register.
func MoveRegisterNumber(destination cpu.Register, number int) (uint32, bool) {
if number < 0 {
return MoveInvertedWideImmediate(destination, ^number, 0), true
}
if sizeof.Signed(number) <= 2 {
return MoveZero(destination, 0, uint16(number)), true
}
if (number&0xFFFFFFFFFFFF == 0xFFFFFFFFFFFF) && sizeof.Signed(number>>48) <= 2 {
return MoveInvertedWideImmediate(destination, (^number)>>48, 3), true
}
code, encodable := MoveBitmaskImmediate(destination, number)
if encodable {
return code, true
}
if (number&0xFFFFFFFF == 0xFFFFFFFF) && sizeof.Signed(number>>32) <= 2 {
return MoveInvertedWideImmediate(destination, (^number)>>32, 2), true
}
if (number&0xFFFF == 0xFFFF) && sizeof.Signed(number>>16) <= 2 {
return MoveInvertedWideImmediate(destination, (^number)>>16, 1), true
}
return 0, false
}
// MoveBitmaskImmediate moves a bitmask immediate value to a register.
func MoveBitmaskImmediate(destination cpu.Register, number int) (uint32, bool) {
return OrRegisterNumber(destination, ZR, number)
}
// MoveInvertedWideImmediate moves an inverted 16-bit immediate value to a register.
func MoveInvertedWideImmediate(destination cpu.Register, number int, shift uint32) uint32 {
func MoveInvertedWideImmediate(destination cpu.Register, number uint16, shift uint32) uint32 {
return 0b100100101<<23 | shift<<21 | regImm(destination, number)
}
// MoveKeep moves a 16-bit integer into the given register and keeps all other bits.
func MoveKeep(destination cpu.Register, halfword int, number uint16) uint32 {
return mov(0b11, halfword, number, destination)
return 0b111100101<<23 | regImmHw(destination, halfword, number)
}
// MoveZero moves a 16-bit integer into the given register and clears all other bits to zero.
func MoveZero(destination cpu.Register, halfword int, number uint16) uint32 {
return mov(0b10, halfword, number, destination)
}
// mov encodes a generic move instruction.
func mov(opCode uint32, halfword int, number uint16, destination cpu.Register) uint32 {
return 1<<31 | opCode<<29 | 0b100101<<23 | uint32(halfword<<21) | uint32(number<<5) | uint32(destination)
return 0b110100101<<23 | regImmHw(destination, halfword, number)
}

24
src/arm/Move_test.go
View File

@ -30,7 +30,24 @@ func TestMoveRegisterRegister(t *testing.T) {
func TestMoveRegisterNumber(t *testing.T) {
usagePatterns := []struct {
Register cpu.Register
Number int
Number uint64
Code []byte
}{
{arm.X0, 0xCAFEBABE, []byte{0xC0, 0x57, 0x97, 0xD2, 0xC0, 0x5F, 0xB9, 0xF2}},
{arm.X0, 0xDEADC0DE, []byte{0xC0, 0x1B, 0x98, 0xD2, 0xA0, 0xD5, 0xBB, 0xF2}},
}
for _, pattern := range usagePatterns {
t.Logf("mov %s, 0x%X", pattern.Register, pattern.Number)
code := arm.MoveRegisterNumber(nil, pattern.Register, int(pattern.Number))
assert.DeepEqual(t, code, pattern.Code)
}
}
func TestMoveRegisterNumberSI(t *testing.T) {
usagePatterns := []struct {
Register cpu.Register
Number uint64
Code uint32
}{
// MOVZ
@ -41,9 +58,10 @@ func TestMoveRegisterNumber(t *testing.T) {
{arm.X0, 0x1FFFF, 0xB24043E0},
{arm.X0, 0x7FFFFFFF, 0xB2407BE0},
{arm.X0, 0xFFFFFFFF, 0xB2407FE0},
{arm.X0, 0xC3FFFFFFC3FFFFFF, 0xB2026FE0},
// MOV (inverted wide immediate)
{arm.X0, -1, 0x92800000},
{arm.X0, 0xFFFFFFFFFFFFFFFF, 0x92800000},
{arm.X0, 0x7FFFFFFFFFFFFFFF, 0x92F00000},
{arm.X0, 0x2FFFFFFFF, 0x92DFFFA0}, // not encodable in the GNU assembler
{arm.X0, 0x2FFFF, 0x92BFFFA0}, // not encodable in the GNU assembler
@ -55,7 +73,7 @@ func TestMoveRegisterNumber(t *testing.T) {
for _, pattern := range usagePatterns {
t.Logf("mov %s, %d", pattern.Register, pattern.Number)
code, encodable := arm.MoveRegisterNumber(pattern.Register, pattern.Number)
code, encodable := arm.MoveRegisterNumberSI(pattern.Register, int(pattern.Number))
if pattern.Code != 0 {
assert.True(t, encodable)

11
src/arm/encode.go
View File

@ -23,13 +23,14 @@ func pair(reg1 cpu.Register, reg2 cpu.Register, base cpu.Register, imm7 int) uin
}
// regImm encodes an instruction with a register and an immediate.
func regImm(d cpu.Register, imm16 int) uint32 {
return uint32(imm16&mask16)<<5 | uint32(d)
func regImm(d cpu.Register, imm16 uint16) uint32 {
return uint32(imm16)<<5 | uint32(d)
}
// reg2 encodes an instruction with 2 registers.
func reg2(d cpu.Register, n cpu.Register) uint32 {
return uint32(n)<<5 | uint32(d)
// regImmHw encodes an instruction with a register, an immediate and
// the 2-bit halfword specifying which 16-bit region of the register is addressed.
func regImmHw(d cpu.Register, hw int, imm16 uint16) uint32 {
return uint32(hw)<<21 | uint32(imm16)<<5 | uint32(d)
}
// reg2Imm encodes an instruction with 2 registers and an immediate.

12
src/asmc/compileARM.go
View File

@ -77,7 +77,7 @@ func (c *compiler) compileARM(x asm.Instruction) {
if operands.Address.OffsetRegister < 0 {
tmp := arm.X28
c.moveRegisterNumberARM(tmp, operands.Number)
c.code = arm.MoveRegisterNumber(c.code, tmp, operands.Number)
c.append(arm.StoreRegister(tmp, operands.Address.Base, int(operands.Address.Offset), operands.Address.Length))
} else {
panic("not implemented")
@ -110,7 +110,7 @@ func (c *compiler) compileARM(x asm.Instruction) {
c.append(code)
} else {
tmp := arm.X28
c.moveRegisterNumberARM(tmp, operand.Number)
c.code = arm.MoveRegisterNumberMI(c.code, tmp, operand.Number)
c.append(arm.AndRegisterRegister(operand.Register, operand.Register, tmp))
}
case asm.TypeRegisterRegister:
@ -128,7 +128,7 @@ func (c *compiler) compileARM(x asm.Instruction) {
c.append(code)
} else {
tmp := arm.X28
c.moveRegisterNumberARM(tmp, operand.Number)
c.code = arm.MoveRegisterNumberMI(c.code, tmp, operand.Number)
c.append(arm.OrRegisterRegister(operand.Register, operand.Register, tmp))
}
case asm.TypeRegisterRegister:
@ -146,7 +146,7 @@ func (c *compiler) compileARM(x asm.Instruction) {
c.append(code)
} else {
tmp := arm.X28
c.moveRegisterNumberARM(tmp, operand.Number)
c.code = arm.MoveRegisterNumberMI(c.code, tmp, operand.Number)
c.append(arm.XorRegisterRegister(operand.Register, operand.Register, tmp))
}
case asm.TypeRegisterRegister:
@ -201,7 +201,7 @@ func (c *compiler) compileARM(x asm.Instruction) {
case asm.TypeRegisterNumber:
operand := c.assembler.Param.RegisterNumber[x.Index]
tmp := arm.X28
c.moveRegisterNumberARM(tmp, operand.Number)
c.code = arm.MoveRegisterNumber(c.code, tmp, operand.Number)
c.append(arm.MulRegisterRegister(operand.Register, operand.Register, tmp))
}
@ -227,7 +227,7 @@ func (c *compiler) compileARM(x asm.Instruction) {
case asm.TypeRegisterNumber:
operands := c.assembler.Param.RegisterNumber[x.Index]
c.moveRegisterNumberARM(operands.Register, operands.Number)
c.code = arm.MoveRegisterNumber(c.code, operands.Register, operands.Number)
case asm.TypeRegisterLabel:
operands := c.assembler.Param.RegisterLabel[x.Index]

16
src/asmc/movARM.go
View File

@ -1,16 +0,0 @@
package asmc
import (
"git.urbach.dev/cli/q/src/arm"
"git.urbach.dev/cli/q/src/cpu"
)
func (c *compiler) moveRegisterNumberARM(register cpu.Register, number int) {
code, encodable := arm.MoveRegisterNumber(register, number)
if encodable {
c.append(code)
} else {
panic("not implemented") // movz movk
}
}

10
src/sizeof/Unsigned.go
View File

@ -3,15 +3,17 @@ package sizeof
import "math"
// Unsigned tells you how many bytes are needed to encode this unsigned number.
func Unsigned(number uint64) int {
func Unsigned[T uint | uint8 | uint16 | uint32 | uint64 | int | int8 | int16 | int32 | int64](number T) int {
x := uint64(number)
switch {
case number <= math.MaxUint8:
case x <= math.MaxUint8:
return 1
case number <= math.MaxUint16:
case x <= math.MaxUint16:
return 2
case number <= math.MaxUint32:
case x <= math.MaxUint32:
return 4
default:

4
src/sizeof/Unsigned_test.go
View File

@ -11,7 +11,9 @@ import (
func TestUnsigned(t *testing.T) {
assert.Equal(t, sizeof.Unsigned(0), 1)
assert.Equal(t, sizeof.Unsigned(math.MaxUint8), 1)
assert.Equal(t, sizeof.Unsigned(math.MaxUint8+1), 2)
assert.Equal(t, sizeof.Unsigned(math.MaxUint16), 2)
assert.Equal(t, sizeof.Unsigned(math.MaxUint16+1), 4)
assert.Equal(t, sizeof.Unsigned(math.MaxUint32), 4)
assert.Equal(t, sizeof.Unsigned(math.MaxUint64), 8)
assert.Equal(t, sizeof.Unsigned(math.MaxUint32+1), 8)
}