cli/q
Code Issues 1 Pull Requests Activity

Simplified register names

Browse Source
This commit is contained in:
Eduard Urbach
2025-04-17 14:16:00 +02:00
parent df725a2b23
commit a023b058f8
33 changed files with 922 additions and 930 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
src/arm/Registers.go
View File

@ -44,20 +44,16 @@ const (
) )
var ( var (
GeneralRegisters = []cpu.Register{X9, X10, X11, X12, X13, X14, X15, X16, X17, X19, X20, X21, X22, X23, X24, X25, X26}
InputRegisters = []cpu.Register{X0, X1, X2, X3, X4, X5} InputRegisters = []cpu.Register{X0, X1, X2, X3, X4, X5}
OutputRegisters = InputRegisters
SyscallInputRegisters = []cpu.Register{X8, X0, X1, X2, X3, X4, X5}
SyscallOutputRegisters = []cpu.Register{X0, X1}
WindowsInputRegisters = []cpu.Register{X0, X1, X2, X3, X4, X5, X6, X7} WindowsInputRegisters = []cpu.Register{X0, X1, X2, X3, X4, X5, X6, X7}
WindowsOutputRegisters = []cpu.Register{X0, X1} WindowsOutputRegisters = []cpu.Register{X0, X1}
CPU = cpu.CPU{ CPU = cpu.CPU{
General: GeneralRegisters, General: []cpu.Register{X9, X10, X11, X12, X13, X14, X15, X16, X17, X19, X20, X21, X22, X23, X24, X25, X26},
Input: InputRegisters, Input: InputRegisters,
Output: OutputRegisters, Output: InputRegisters,
SyscallInput: SyscallInputRegisters, SyscallInput: []cpu.Register{X8, X0, X1, X2, X3, X4, X5},
SyscallOutput: SyscallOutputRegisters, SyscallOutput: []cpu.Register{X0, X1},
NumRegisters: 32, NumRegisters: 32,
} }
) )

2
src/arm/Registers_test.go
View File

@ -8,5 +8,5 @@ import (
) )
func TestRegisters(t *testing.T) { func TestRegisters(t *testing.T) {
assert.NotNil(t, arm.SyscallInputRegisters) assert.NotContains(t, arm.CPU.General, arm.SP)
} }

40
src/asmc/x86Compiler.go
View File

@ -241,29 +241,29 @@ func (c *x86Compiler) handleDivInstruction(instruction asm.Instruction) {
case asm.TypeRegisterNumber: case asm.TypeRegisterNumber:
operands := c.assembler.Param.RegisterNumber[instruction.Index] operands := c.assembler.Param.RegisterNumber[instruction.Index]
if operands.Register != x86.RAX { if operands.Register != x86.R0 {
c.code = x86.MoveRegisterRegister(c.code, x86.RAX, operands.Register) c.code = x86.MoveRegisterRegister(c.code, x86.R0, operands.Register)
} }
c.code = x86.MoveRegisterNumber(c.code, x86.TMP, operands.Number) c.code = x86.MoveRegisterNumber(c.code, x86.TMP, operands.Number)
c.code = x86.ExtendRAXToRDX(c.code) c.code = x86.ExtendR0ToR2(c.code)
c.code = x86.DivRegister(c.code, x86.TMP) c.code = x86.DivRegister(c.code, x86.TMP)
if operands.Register != x86.RAX { if operands.Register != x86.R0 {
c.code = x86.MoveRegisterRegister(c.code, operands.Register, x86.RAX) c.code = x86.MoveRegisterRegister(c.code, operands.Register, x86.R0)
} }
case asm.TypeRegisterRegister: case asm.TypeRegisterRegister:
operands := c.assembler.Param.RegisterRegister[instruction.Index] operands := c.assembler.Param.RegisterRegister[instruction.Index]
if operands.Destination != x86.RAX { if operands.Destination != x86.R0 {
c.code = x86.MoveRegisterRegister(c.code, x86.RAX, operands.Destination) c.code = x86.MoveRegisterRegister(c.code, x86.R0, operands.Destination)
} }
c.code = x86.ExtendRAXToRDX(c.code) c.code = x86.ExtendR0ToR2(c.code)
c.code = x86.DivRegister(c.code, operands.Source) c.code = x86.DivRegister(c.code, operands.Source)
if operands.Destination != x86.RAX { if operands.Destination != x86.R0 {
c.code = x86.MoveRegisterRegister(c.code, operands.Destination, x86.RAX) c.code = x86.MoveRegisterRegister(c.code, operands.Destination, x86.R0)
} }
} }
} }
@ -273,29 +273,29 @@ func (c *x86Compiler) handleModuloInstruction(instruction asm.Instruction) {
case asm.TypeRegisterNumber: case asm.TypeRegisterNumber:
operands := c.assembler.Param.RegisterNumber[instruction.Index] operands := c.assembler.Param.RegisterNumber[instruction.Index]
if operands.Register != x86.RAX { if operands.Register != x86.R0 {
c.code = x86.MoveRegisterRegister(c.code, x86.RAX, operands.Register) c.code = x86.MoveRegisterRegister(c.code, x86.R0, operands.Register)
} }
c.code = x86.MoveRegisterNumber(c.code, x86.TMP, operands.Number) c.code = x86.MoveRegisterNumber(c.code, x86.TMP, operands.Number)
c.code = x86.ExtendRAXToRDX(c.code) c.code = x86.ExtendR0ToR2(c.code)
c.code = x86.DivRegister(c.code, x86.TMP) c.code = x86.DivRegister(c.code, x86.TMP)
if operands.Register != x86.RDX { if operands.Register != x86.R2 {
c.code = x86.MoveRegisterRegister(c.code, operands.Register, x86.RDX) c.code = x86.MoveRegisterRegister(c.code, operands.Register, x86.R2)
} }
case asm.TypeRegisterRegister: case asm.TypeRegisterRegister:
operands := c.assembler.Param.RegisterRegister[instruction.Index] operands := c.assembler.Param.RegisterRegister[instruction.Index]
if operands.Destination != x86.RAX { if operands.Destination != x86.R0 {
c.code = x86.MoveRegisterRegister(c.code, x86.RAX, operands.Destination) c.code = x86.MoveRegisterRegister(c.code, x86.R0, operands.Destination)
} }
c.code = x86.ExtendRAXToRDX(c.code) c.code = x86.ExtendR0ToR2(c.code)
c.code = x86.DivRegister(c.code, operands.Source) c.code = x86.DivRegister(c.code, operands.Source)
if operands.Destination != x86.RDX { if operands.Destination != x86.R2 {
c.code = x86.MoveRegisterRegister(c.code, operands.Destination, x86.RDX) c.code = x86.MoveRegisterRegister(c.code, operands.Destination, x86.R2)
} }
} }
} }

12
src/core/CallExtern.go
View File

@ -30,15 +30,15 @@ func (f *Function) CallExtern(fn *Function, parameters []*expression.Expression)
return nil, err return nil, err
} }
f.Register(asm.PUSH, x86.RBP) f.Register(asm.PUSH, x86.R5)
f.RegisterRegister(asm.MOVE, x86.RBP, x86.RSP) f.RegisterRegister(asm.MOVE, x86.R5, x86.SP)
f.RegisterNumber(asm.AND, x86.RSP, -16) f.RegisterNumber(asm.AND, x86.SP, -16)
f.Number(asm.PUSH, 0) f.Number(asm.PUSH, 0)
f.Number(asm.PUSH, 0) f.Number(asm.PUSH, 0)
f.RegisterNumber(asm.SUB, x86.RSP, 32) f.RegisterNumber(asm.SUB, x86.SP, 32)
f.DLLCall(fn.UniqueName) f.DLLCall(fn.UniqueName)
f.RegisterRegister(asm.MOVE, x86.RSP, x86.RBP) f.RegisterRegister(asm.MOVE, x86.SP, x86.R5)
f.Register(asm.POP, x86.RBP) f.Register(asm.POP, x86.R5)
for _, register := range registers { for _, register := range registers {
f.FreeRegister(register) f.FreeRegister(register)

10
src/core/CompileAssignDivision.go
View File

@ -76,9 +76,9 @@ func (f *Function) CompileAssignDivision(expr *expression.Expression) error {
switch dividend := dividend.(type) { switch dividend := dividend.(type) {
case *eval.Number: case *eval.Number:
f.SaveRegister(x86.RAX) f.SaveRegister(x86.R0)
f.RegisterNumber(asm.MOVE, x86.RAX, dividend.Number) f.RegisterNumber(asm.MOVE, x86.R0, dividend.Number)
err = f.Execute(division.Token, x86.RAX, divisor) err = f.Execute(division.Token, x86.R0, divisor)
case *eval.Register: case *eval.Register:
if dividend.Register != quotientVariable.Value.Register && dividend.IsAlive() { if dividend.Register != quotientVariable.Value.Register && dividend.IsAlive() {
tmp := f.NewRegister() tmp := f.NewRegister()
@ -92,7 +92,7 @@ func (f *Function) CompileAssignDivision(expr *expression.Expression) error {
panic(fmt.Errorf("%s: not implemented: %v", f.UniqueName, dividend)) panic(fmt.Errorf("%s: not implemented: %v", f.UniqueName, dividend))
} }
f.RegisterRegister(asm.MOVE, quotientVariable.Value.Register, x86.RAX) f.RegisterRegister(asm.MOVE, quotientVariable.Value.Register, x86.R0)
f.RegisterRegister(asm.MOVE, remainderVariable.Value.Register, x86.RDX) f.RegisterRegister(asm.MOVE, remainderVariable.Value.Register, x86.R2)
return err return err
} }

4
src/core/ExecuteRegisterNumber.go
View File

@ -27,14 +27,14 @@ func (f *Function) ExecuteRegisterNumber(operation token.Token, register cpu.Reg
case token.Div, token.DivAssign: case token.Div, token.DivAssign:
if config.TargetArch == config.X86 { if config.TargetArch == config.X86 {
f.SaveRegister(x86.RDX) f.SaveRegister(x86.R2)
} }
f.RegisterNumber(asm.DIV, register, number) f.RegisterNumber(asm.DIV, register, number)
case token.Mod, token.ModAssign: case token.Mod, token.ModAssign:
if config.TargetArch == config.X86 { if config.TargetArch == config.X86 {
f.SaveRegister(x86.RDX) f.SaveRegister(x86.R2)
} }
f.RegisterNumber(asm.MODULO, register, number) f.RegisterNumber(asm.MODULO, register, number)

4
src/core/ExecuteRegisterRegister.go
View File

@ -27,14 +27,14 @@ func (f *Function) ExecuteRegisterRegister(operation token.Token, register cpu.R
case token.Div, token.DivAssign: case token.Div, token.DivAssign:
if config.TargetArch == config.X86 { if config.TargetArch == config.X86 {
f.SaveRegister(x86.RDX) f.SaveRegister(x86.R2)
} }
f.RegisterRegister(asm.DIV, register, operand) f.RegisterRegister(asm.DIV, register, operand)
case token.Mod, token.ModAssign: case token.Mod, token.ModAssign:
if config.TargetArch == config.X86 { if config.TargetArch == config.X86 {
f.SaveRegister(x86.RDX) f.SaveRegister(x86.R2)
} }
f.RegisterRegister(asm.MODULO, register, operand) f.RegisterRegister(asm.MODULO, register, operand)

64
src/x86/Add_test.go
View File

@ -14,14 +14,14 @@ func TestAddRegisterNumber(t *testing.T) {
Number int Number int
Code []byte Code []byte
}{ }{
{x86.RAX, 1, []byte{0x48, 0x83, 0xC0, 0x01}}, {x86.R0, 1, []byte{0x48, 0x83, 0xC0, 0x01}},
{x86.RCX, 1, []byte{0x48, 0x83, 0xC1, 0x01}}, {x86.R1, 1, []byte{0x48, 0x83, 0xC1, 0x01}},
{x86.RDX, 1, []byte{0x48, 0x83, 0xC2, 0x01}}, {x86.R2, 1, []byte{0x48, 0x83, 0xC2, 0x01}},
{x86.RBX, 1, []byte{0x48, 0x83, 0xC3, 0x01}}, {x86.R3, 1, []byte{0x48, 0x83, 0xC3, 0x01}},
{x86.RSP, 1, []byte{0x48, 0x83, 0xC4, 0x01}}, {x86.SP, 1, []byte{0x48, 0x83, 0xC4, 0x01}},
{x86.RBP, 1, []byte{0x48, 0x83, 0xC5, 0x01}}, {x86.R5, 1, []byte{0x48, 0x83, 0xC5, 0x01}},
{x86.RSI, 1, []byte{0x48, 0x83, 0xC6, 0x01}}, {x86.R6, 1, []byte{0x48, 0x83, 0xC6, 0x01}},
{x86.RDI, 1, []byte{0x48, 0x83, 0xC7, 0x01}}, {x86.R7, 1, []byte{0x48, 0x83, 0xC7, 0x01}},
{x86.R8, 1, []byte{0x49, 0x83, 0xC0, 0x01}}, {x86.R8, 1, []byte{0x49, 0x83, 0xC0, 0x01}},
{x86.R9, 1, []byte{0x49, 0x83, 0xC1, 0x01}}, {x86.R9, 1, []byte{0x49, 0x83, 0xC1, 0x01}},
{x86.R10, 1, []byte{0x49, 0x83, 0xC2, 0x01}}, {x86.R10, 1, []byte{0x49, 0x83, 0xC2, 0x01}},
@ -31,14 +31,14 @@ func TestAddRegisterNumber(t *testing.T) {
{x86.R14, 1, []byte{0x49, 0x83, 0xC6, 0x01}}, {x86.R14, 1, []byte{0x49, 0x83, 0xC6, 0x01}},
{x86.R15, 1, []byte{0x49, 0x83, 0xC7, 0x01}}, {x86.R15, 1, []byte{0x49, 0x83, 0xC7, 0x01}},
{x86.RAX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xC0, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R0, 0x7FFFFFFF, []byte{0x48, 0x81, 0xC0, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RCX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xC1, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R1, 0x7FFFFFFF, []byte{0x48, 0x81, 0xC1, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RDX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xC2, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R2, 0x7FFFFFFF, []byte{0x48, 0x81, 0xC2, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RBX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xC3, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R3, 0x7FFFFFFF, []byte{0x48, 0x81, 0xC3, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RSP, 0x7FFFFFFF, []byte{0x48, 0x81, 0xC4, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.SP, 0x7FFFFFFF, []byte{0x48, 0x81, 0xC4, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RBP, 0x7FFFFFFF, []byte{0x48, 0x81, 0xC5, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R5, 0x7FFFFFFF, []byte{0x48, 0x81, 0xC5, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RSI, 0x7FFFFFFF, []byte{0x48, 0x81, 0xC6, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R6, 0x7FFFFFFF, []byte{0x48, 0x81, 0xC6, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RDI, 0x7FFFFFFF, []byte{0x48, 0x81, 0xC7, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R7, 0x7FFFFFFF, []byte{0x48, 0x81, 0xC7, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.R8, 0x7FFFFFFF, []byte{0x49, 0x81, 0xC0, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R8, 0x7FFFFFFF, []byte{0x49, 0x81, 0xC0, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.R9, 0x7FFFFFFF, []byte{0x49, 0x81, 0xC1, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R9, 0x7FFFFFFF, []byte{0x49, 0x81, 0xC1, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.R10, 0x7FFFFFFF, []byte{0x49, 0x81, 0xC2, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R10, 0x7FFFFFFF, []byte{0x49, 0x81, 0xC2, 0xFF, 0xFF, 0xFF, 0x7F}},
@ -62,22 +62,22 @@ func TestAddRegisterRegister(t *testing.T) {
Right cpu.Register Right cpu.Register
Code []byte Code []byte
}{ }{
{x86.RAX, x86.R15, []byte{0x4C, 0x01, 0xF8}}, {x86.R0, x86.R15, []byte{0x4C, 0x01, 0xF8}},
{x86.RCX, x86.R14, []byte{0x4C, 0x01, 0xF1}}, {x86.R1, x86.R14, []byte{0x4C, 0x01, 0xF1}},
{x86.RDX, x86.R13, []byte{0x4C, 0x01, 0xEA}}, {x86.R2, x86.R13, []byte{0x4C, 0x01, 0xEA}},
{x86.RBX, x86.R12, []byte{0x4C, 0x01, 0xE3}}, {x86.R3, x86.R12, []byte{0x4C, 0x01, 0xE3}},
{x86.RSP, x86.R11, []byte{0x4C, 0x01, 0xDC}}, {x86.SP, x86.R11, []byte{0x4C, 0x01, 0xDC}},
{x86.RBP, x86.R10, []byte{0x4C, 0x01, 0xD5}}, {x86.R5, x86.R10, []byte{0x4C, 0x01, 0xD5}},
{x86.RSI, x86.R9, []byte{0x4C, 0x01, 0xCE}}, {x86.R6, x86.R9, []byte{0x4C, 0x01, 0xCE}},
{x86.RDI, x86.R8, []byte{0x4C, 0x01, 0xC7}}, {x86.R7, x86.R8, []byte{0x4C, 0x01, 0xC7}},
{x86.R8, x86.RDI, []byte{0x49, 0x01, 0xF8}}, {x86.R8, x86.R7, []byte{0x49, 0x01, 0xF8}},
{x86.R9, x86.RSI, []byte{0x49, 0x01, 0xF1}}, {x86.R9, x86.R6, []byte{0x49, 0x01, 0xF1}},
{x86.R10, x86.RBP, []byte{0x49, 0x01, 0xEA}}, {x86.R10, x86.R5, []byte{0x49, 0x01, 0xEA}},
{x86.R11, x86.RSP, []byte{0x49, 0x01, 0xE3}}, {x86.R11, x86.SP, []byte{0x49, 0x01, 0xE3}},
{x86.R12, x86.RBX, []byte{0x49, 0x01, 0xDC}}, {x86.R12, x86.R3, []byte{0x49, 0x01, 0xDC}},
{x86.R13, x86.RDX, []byte{0x49, 0x01, 0xD5}}, {x86.R13, x86.R2, []byte{0x49, 0x01, 0xD5}},
{x86.R14, x86.RCX, []byte{0x49, 0x01, 0xCE}}, {x86.R14, x86.R1, []byte{0x49, 0x01, 0xCE}},
{x86.R15, x86.RAX, []byte{0x49, 0x01, 0xC7}}, {x86.R15, x86.R0, []byte{0x49, 0x01, 0xC7}},
} }
for _, pattern := range usagePatterns { for _, pattern := range usagePatterns {

64
src/x86/And_test.go
View File

@ -14,14 +14,14 @@ func TestAndRegisterNumber(t *testing.T) {
Number int Number int
Code []byte Code []byte
}{ }{
{x86.RAX, 1, []byte{0x48, 0x83, 0xE0, 0x01}}, {x86.R0, 1, []byte{0x48, 0x83, 0xE0, 0x01}},
{x86.RCX, 1, []byte{0x48, 0x83, 0xE1, 0x01}}, {x86.R1, 1, []byte{0x48, 0x83, 0xE1, 0x01}},
{x86.RDX, 1, []byte{0x48, 0x83, 0xE2, 0x01}}, {x86.R2, 1, []byte{0x48, 0x83, 0xE2, 0x01}},
{x86.RBX, 1, []byte{0x48, 0x83, 0xE3, 0x01}}, {x86.R3, 1, []byte{0x48, 0x83, 0xE3, 0x01}},
{x86.RSP, 1, []byte{0x48, 0x83, 0xE4, 0x01}}, {x86.SP, 1, []byte{0x48, 0x83, 0xE4, 0x01}},
{x86.RBP, 1, []byte{0x48, 0x83, 0xE5, 0x01}}, {x86.R5, 1, []byte{0x48, 0x83, 0xE5, 0x01}},
{x86.RSI, 1, []byte{0x48, 0x83, 0xE6, 0x01}}, {x86.R6, 1, []byte{0x48, 0x83, 0xE6, 0x01}},
{x86.RDI, 1, []byte{0x48, 0x83, 0xE7, 0x01}}, {x86.R7, 1, []byte{0x48, 0x83, 0xE7, 0x01}},
{x86.R8, 1, []byte{0x49, 0x83, 0xE0, 0x01}}, {x86.R8, 1, []byte{0x49, 0x83, 0xE0, 0x01}},
{x86.R9, 1, []byte{0x49, 0x83, 0xE1, 0x01}}, {x86.R9, 1, []byte{0x49, 0x83, 0xE1, 0x01}},
{x86.R10, 1, []byte{0x49, 0x83, 0xE2, 0x01}}, {x86.R10, 1, []byte{0x49, 0x83, 0xE2, 0x01}},
@ -31,14 +31,14 @@ func TestAndRegisterNumber(t *testing.T) {
{x86.R14, 1, []byte{0x49, 0x83, 0xE6, 0x01}}, {x86.R14, 1, []byte{0x49, 0x83, 0xE6, 0x01}},
{x86.R15, 1, []byte{0x49, 0x83, 0xE7, 0x01}}, {x86.R15, 1, []byte{0x49, 0x83, 0xE7, 0x01}},
{x86.RAX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xE0, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R0, 0x7FFFFFFF, []byte{0x48, 0x81, 0xE0, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RCX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xE1, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R1, 0x7FFFFFFF, []byte{0x48, 0x81, 0xE1, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RDX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xE2, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R2, 0x7FFFFFFF, []byte{0x48, 0x81, 0xE2, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RBX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xE3, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R3, 0x7FFFFFFF, []byte{0x48, 0x81, 0xE3, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RSP, 0x7FFFFFFF, []byte{0x48, 0x81, 0xE4, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.SP, 0x7FFFFFFF, []byte{0x48, 0x81, 0xE4, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RBP, 0x7FFFFFFF, []byte{0x48, 0x81, 0xE5, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R5, 0x7FFFFFFF, []byte{0x48, 0x81, 0xE5, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RSI, 0x7FFFFFFF, []byte{0x48, 0x81, 0xE6, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R6, 0x7FFFFFFF, []byte{0x48, 0x81, 0xE6, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RDI, 0x7FFFFFFF, []byte{0x48, 0x81, 0xE7, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R7, 0x7FFFFFFF, []byte{0x48, 0x81, 0xE7, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.R8, 0x7FFFFFFF, []byte{0x49, 0x81, 0xE0, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R8, 0x7FFFFFFF, []byte{0x49, 0x81, 0xE0, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.R9, 0x7FFFFFFF, []byte{0x49, 0x81, 0xE1, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R9, 0x7FFFFFFF, []byte{0x49, 0x81, 0xE1, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.R10, 0x7FFFFFFF, []byte{0x49, 0x81, 0xE2, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R10, 0x7FFFFFFF, []byte{0x49, 0x81, 0xE2, 0xFF, 0xFF, 0xFF, 0x7F}},
@ -62,22 +62,22 @@ func TestAndRegisterRegister(t *testing.T) {
Right cpu.Register Right cpu.Register
Code []byte Code []byte
}{ }{
{x86.RAX, x86.R15, []byte{0x4C, 0x21, 0xF8}}, {x86.R0, x86.R15, []byte{0x4C, 0x21, 0xF8}},
{x86.RCX, x86.R14, []byte{0x4C, 0x21, 0xF1}}, {x86.R1, x86.R14, []byte{0x4C, 0x21, 0xF1}},
{x86.RDX, x86.R13, []byte{0x4C, 0x21, 0xEA}}, {x86.R2, x86.R13, []byte{0x4C, 0x21, 0xEA}},
{x86.RBX, x86.R12, []byte{0x4C, 0x21, 0xE3}}, {x86.R3, x86.R12, []byte{0x4C, 0x21, 0xE3}},
{x86.RSP, x86.R11, []byte{0x4C, 0x21, 0xDC}}, {x86.SP, x86.R11, []byte{0x4C, 0x21, 0xDC}},
{x86.RBP, x86.R10, []byte{0x4C, 0x21, 0xD5}}, {x86.R5, x86.R10, []byte{0x4C, 0x21, 0xD5}},
{x86.RSI, x86.R9, []byte{0x4C, 0x21, 0xCE}}, {x86.R6, x86.R9, []byte{0x4C, 0x21, 0xCE}},
{x86.RDI, x86.R8, []byte{0x4C, 0x21, 0xC7}}, {x86.R7, x86.R8, []byte{0x4C, 0x21, 0xC7}},
{x86.R8, x86.RDI, []byte{0x49, 0x21, 0xF8}}, {x86.R8, x86.R7, []byte{0x49, 0x21, 0xF8}},
{x86.R9, x86.RSI, []byte{0x49, 0x21, 0xF1}}, {x86.R9, x86.R6, []byte{0x49, 0x21, 0xF1}},
{x86.R10, x86.RBP, []byte{0x49, 0x21, 0xEA}}, {x86.R10, x86.R5, []byte{0x49, 0x21, 0xEA}},
{x86.R11, x86.RSP, []byte{0x49, 0x21, 0xE3}}, {x86.R11, x86.SP, []byte{0x49, 0x21, 0xE3}},
{x86.R12, x86.RBX, []byte{0x49, 0x21, 0xDC}}, {x86.R12, x86.R3, []byte{0x49, 0x21, 0xDC}},
{x86.R13, x86.RDX, []byte{0x49, 0x21, 0xD5}}, {x86.R13, x86.R2, []byte{0x49, 0x21, 0xD5}},
{x86.R14, x86.RCX, []byte{0x49, 0x21, 0xCE}}, {x86.R14, x86.R1, []byte{0x49, 0x21, 0xCE}},
{x86.R15, x86.RAX, []byte{0x49, 0x21, 0xC7}}, {x86.R15, x86.R0, []byte{0x49, 0x21, 0xC7}},
} }
for _, pattern := range usagePatterns { for _, pattern := range usagePatterns {

48
src/x86/Call_test.go
View File

@ -13,14 +13,14 @@ func TestCallRegister(t *testing.T) {
Register cpu.Register Register cpu.Register
Code []byte Code []byte
}{ }{
{x86.RAX, []byte{0xFF, 0xD0}}, {x86.R0, []byte{0xFF, 0xD0}},
{x86.RCX, []byte{0xFF, 0xD1}}, {x86.R1, []byte{0xFF, 0xD1}},
{x86.RDX, []byte{0xFF, 0xD2}}, {x86.R2, []byte{0xFF, 0xD2}},
{x86.RBX, []byte{0xFF, 0xD3}}, {x86.R3, []byte{0xFF, 0xD3}},
{x86.RSP, []byte{0xFF, 0xD4}}, {x86.SP, []byte{0xFF, 0xD4}},
{x86.RBP, []byte{0xFF, 0xD5}}, {x86.R5, []byte{0xFF, 0xD5}},
{x86.RSI, []byte{0xFF, 0xD6}}, {x86.R6, []byte{0xFF, 0xD6}},
{x86.RDI, []byte{0xFF, 0xD7}}, {x86.R7, []byte{0xFF, 0xD7}},
{x86.R8, []byte{0x41, 0xFF, 0xD0}}, {x86.R8, []byte{0x41, 0xFF, 0xD0}},
{x86.R9, []byte{0x41, 0xFF, 0xD1}}, {x86.R9, []byte{0x41, 0xFF, 0xD1}},
{x86.R10, []byte{0x41, 0xFF, 0xD2}}, {x86.R10, []byte{0x41, 0xFF, 0xD2}},
@ -44,14 +44,14 @@ func TestCallAtMemory(t *testing.T) {
Offset int8 Offset int8
Code []byte Code []byte
}{ }{
{x86.RAX, 0, []byte{0xFF, 0x10}}, {x86.R0, 0, []byte{0xFF, 0x10}},
{x86.RCX, 0, []byte{0xFF, 0x11}}, {x86.R1, 0, []byte{0xFF, 0x11}},
{x86.RDX, 0, []byte{0xFF, 0x12}}, {x86.R2, 0, []byte{0xFF, 0x12}},
{x86.RBX, 0, []byte{0xFF, 0x13}}, {x86.R3, 0, []byte{0xFF, 0x13}},
{x86.RSP, 0, []byte{0xFF, 0x14, 0x24}}, {x86.SP, 0, []byte{0xFF, 0x14, 0x24}},
{x86.RBP, 0, []byte{0xFF, 0x55, 0x00}}, {x86.R5, 0, []byte{0xFF, 0x55, 0x00}},
{x86.RSI, 0, []byte{0xFF, 0x16}}, {x86.R6, 0, []byte{0xFF, 0x16}},
{x86.RDI, 0, []byte{0xFF, 0x17}}, {x86.R7, 0, []byte{0xFF, 0x17}},
{x86.R8, 0, []byte{0x41, 0xFF, 0x10}}, {x86.R8, 0, []byte{0x41, 0xFF, 0x10}},
{x86.R9, 0, []byte{0x41, 0xFF, 0x11}}, {x86.R9, 0, []byte{0x41, 0xFF, 0x11}},
{x86.R10, 0, []byte{0x41, 0xFF, 0x12}}, {x86.R10, 0, []byte{0x41, 0xFF, 0x12}},
@ -61,14 +61,14 @@ func TestCallAtMemory(t *testing.T) {
{x86.R14, 0, []byte{0x41, 0xFF, 0x16}}, {x86.R14, 0, []byte{0x41, 0xFF, 0x16}},
{x86.R15, 0, []byte{0x41, 0xFF, 0x17}}, {x86.R15, 0, []byte{0x41, 0xFF, 0x17}},
{x86.RAX, 1, []byte{0xFF, 0x50, 0x01}}, {x86.R0, 1, []byte{0xFF, 0x50, 0x01}},
{x86.RCX, 1, []byte{0xFF, 0x51, 0x01}}, {x86.R1, 1, []byte{0xFF, 0x51, 0x01}},
{x86.RDX, 1, []byte{0xFF, 0x52, 0x01}}, {x86.R2, 1, []byte{0xFF, 0x52, 0x01}},
{x86.RBX, 1, []byte{0xFF, 0x53, 0x01}}, {x86.R3, 1, []byte{0xFF, 0x53, 0x01}},
{x86.RSP, 1, []byte{0xFF, 0x54, 0x24, 0x01}}, {x86.SP, 1, []byte{0xFF, 0x54, 0x24, 0x01}},
{x86.RBP, 1, []byte{0xFF, 0x55, 0x01}}, {x86.R5, 1, []byte{0xFF, 0x55, 0x01}},
{x86.RSI, 1, []byte{0xFF, 0x56, 0x01}}, {x86.R6, 1, []byte{0xFF, 0x56, 0x01}},
{x86.RDI, 1, []byte{0xFF, 0x57, 0x01}}, {x86.R7, 1, []byte{0xFF, 0x57, 0x01}},
{x86.R8, 1, []byte{0x41, 0xFF, 0x50, 0x01}}, {x86.R8, 1, []byte{0x41, 0xFF, 0x50, 0x01}},
{x86.R9, 1, []byte{0x41, 0xFF, 0x51, 0x01}}, {x86.R9, 1, []byte{0x41, 0xFF, 0x51, 0x01}},
{x86.R10, 1, []byte{0x41, 0xFF, 0x52, 0x01}}, {x86.R10, 1, []byte{0x41, 0xFF, 0x52, 0x01}},

64
src/x86/Compare_test.go
View File

@ -14,14 +14,14 @@ func TestCompareRegisterNumber(t *testing.T) {
Number int Number int
Code []byte Code []byte
}{ }{
{x86.RAX, 1, []byte{0x48, 0x83, 0xF8, 0x01}}, {x86.R0, 1, []byte{0x48, 0x83, 0xF8, 0x01}},
{x86.RCX, 1, []byte{0x48, 0x83, 0xF9, 0x01}}, {x86.R1, 1, []byte{0x48, 0x83, 0xF9, 0x01}},
{x86.RDX, 1, []byte{0x48, 0x83, 0xFA, 0x01}}, {x86.R2, 1, []byte{0x48, 0x83, 0xFA, 0x01}},
{x86.RBX, 1, []byte{0x48, 0x83, 0xFB, 0x01}}, {x86.R3, 1, []byte{0x48, 0x83, 0xFB, 0x01}},
{x86.RSP, 1, []byte{0x48, 0x83, 0xFC, 0x01}}, {x86.SP, 1, []byte{0x48, 0x83, 0xFC, 0x01}},
{x86.RBP, 1, []byte{0x48, 0x83, 0xFD, 0x01}}, {x86.R5, 1, []byte{0x48, 0x83, 0xFD, 0x01}},
{x86.RSI, 1, []byte{0x48, 0x83, 0xFE, 0x01}}, {x86.R6, 1, []byte{0x48, 0x83, 0xFE, 0x01}},
{x86.RDI, 1, []byte{0x48, 0x83, 0xFF, 0x01}}, {x86.R7, 1, []byte{0x48, 0x83, 0xFF, 0x01}},
{x86.R8, 1, []byte{0x49, 0x83, 0xF8, 0x01}}, {x86.R8, 1, []byte{0x49, 0x83, 0xF8, 0x01}},
{x86.R9, 1, []byte{0x49, 0x83, 0xF9, 0x01}}, {x86.R9, 1, []byte{0x49, 0x83, 0xF9, 0x01}},
{x86.R10, 1, []byte{0x49, 0x83, 0xFA, 0x01}}, {x86.R10, 1, []byte{0x49, 0x83, 0xFA, 0x01}},
@ -31,14 +31,14 @@ func TestCompareRegisterNumber(t *testing.T) {
{x86.R14, 1, []byte{0x49, 0x83, 0xFE, 0x01}}, {x86.R14, 1, []byte{0x49, 0x83, 0xFE, 0x01}},
{x86.R15, 1, []byte{0x49, 0x83, 0xFF, 0x01}}, {x86.R15, 1, []byte{0x49, 0x83, 0xFF, 0x01}},
{x86.RAX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xF8, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R0, 0x7FFFFFFF, []byte{0x48, 0x81, 0xF8, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RCX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xF9, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R1, 0x7FFFFFFF, []byte{0x48, 0x81, 0xF9, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RDX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xFA, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R2, 0x7FFFFFFF, []byte{0x48, 0x81, 0xFA, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RBX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xFB, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R3, 0x7FFFFFFF, []byte{0x48, 0x81, 0xFB, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RSP, 0x7FFFFFFF, []byte{0x48, 0x81, 0xFC, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.SP, 0x7FFFFFFF, []byte{0x48, 0x81, 0xFC, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RBP, 0x7FFFFFFF, []byte{0x48, 0x81, 0xFD, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R5, 0x7FFFFFFF, []byte{0x48, 0x81, 0xFD, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RSI, 0x7FFFFFFF, []byte{0x48, 0x81, 0xFE, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R6, 0x7FFFFFFF, []byte{0x48, 0x81, 0xFE, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RDI, 0x7FFFFFFF, []byte{0x48, 0x81, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R7, 0x7FFFFFFF, []byte{0x48, 0x81, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.R8, 0x7FFFFFFF, []byte{0x49, 0x81, 0xF8, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R8, 0x7FFFFFFF, []byte{0x49, 0x81, 0xF8, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.R9, 0x7FFFFFFF, []byte{0x49, 0x81, 0xF9, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R9, 0x7FFFFFFF, []byte{0x49, 0x81, 0xF9, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.R10, 0x7FFFFFFF, []byte{0x49, 0x81, 0xFA, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R10, 0x7FFFFFFF, []byte{0x49, 0x81, 0xFA, 0xFF, 0xFF, 0xFF, 0x7F}},
@ -62,22 +62,22 @@ func TestCompareRegisterRegister(t *testing.T) {
Right cpu.Register Right cpu.Register
Code []byte Code []byte
}{ }{
{x86.RAX, x86.R15, []byte{0x4C, 0x39, 0xF8}}, {x86.R0, x86.R15, []byte{0x4C, 0x39, 0xF8}},
{x86.RCX, x86.R14, []byte{0x4C, 0x39, 0xF1}}, {x86.R1, x86.R14, []byte{0x4C, 0x39, 0xF1}},
{x86.RDX, x86.R13, []byte{0x4C, 0x39, 0xEA}}, {x86.R2, x86.R13, []byte{0x4C, 0x39, 0xEA}},
{x86.RBX, x86.R12, []byte{0x4C, 0x39, 0xE3}}, {x86.R3, x86.R12, []byte{0x4C, 0x39, 0xE3}},
{x86.RSP, x86.R11, []byte{0x4C, 0x39, 0xDC}}, {x86.SP, x86.R11, []byte{0x4C, 0x39, 0xDC}},
{x86.RBP, x86.R10, []byte{0x4C, 0x39, 0xD5}}, {x86.R5, x86.R10, []byte{0x4C, 0x39, 0xD5}},
{x86.RSI, x86.R9, []byte{0x4C, 0x39, 0xCE}}, {x86.R6, x86.R9, []byte{0x4C, 0x39, 0xCE}},
{x86.RDI, x86.R8, []byte{0x4C, 0x39, 0xC7}}, {x86.R7, x86.R8, []byte{0x4C, 0x39, 0xC7}},
{x86.R8, x86.RDI, []byte{0x49, 0x39, 0xF8}}, {x86.R8, x86.R7, []byte{0x49, 0x39, 0xF8}},
{x86.R9, x86.RSI, []byte{0x49, 0x39, 0xF1}}, {x86.R9, x86.R6, []byte{0x49, 0x39, 0xF1}},
{x86.R10, x86.RBP, []byte{0x49, 0x39, 0xEA}}, {x86.R10, x86.R5, []byte{0x49, 0x39, 0xEA}},
{x86.R11, x86.RSP, []byte{0x49, 0x39, 0xE3}}, {x86.R11, x86.SP, []byte{0x49, 0x39, 0xE3}},
{x86.R12, x86.RBX, []byte{0x49, 0x39, 0xDC}}, {x86.R12, x86.R3, []byte{0x49, 0x39, 0xDC}},
{x86.R13, x86.RDX, []byte{0x49, 0x39, 0xD5}}, {x86.R13, x86.R2, []byte{0x49, 0x39, 0xD5}},
{x86.R14, x86.RCX, []byte{0x49, 0x39, 0xCE}}, {x86.R14, x86.R1, []byte{0x49, 0x39, 0xCE}},
{x86.R15, x86.RAX, []byte{0x49, 0x39, 0xC7}}, {x86.R15, x86.R0, []byte{0x49, 0x39, 0xC7}},
} }
for _, pattern := range usagePatterns { for _, pattern := range usagePatterns {

16
src/x86/Div_test.go
View File

@ -13,14 +13,14 @@ func TestDivRegister(t *testing.T) {
Register cpu.Register Register cpu.Register
Code []byte Code []byte
}{ }{
{x86.RAX, []byte{0x48, 0xF7, 0xF8}}, {x86.R0, []byte{0x48, 0xF7, 0xF8}},
{x86.RCX, []byte{0x48, 0xF7, 0xF9}}, {x86.R1, []byte{0x48, 0xF7, 0xF9}},
{x86.RDX, []byte{0x48, 0xF7, 0xFA}}, {x86.R2, []byte{0x48, 0xF7, 0xFA}},
{x86.RBX, []byte{0x48, 0xF7, 0xFB}}, {x86.R3, []byte{0x48, 0xF7, 0xFB}},
{x86.RSP, []byte{0x48, 0xF7, 0xFC}}, {x86.SP, []byte{0x48, 0xF7, 0xFC}},
{x86.RBP, []byte{0x48, 0xF7, 0xFD}}, {x86.R5, []byte{0x48, 0xF7, 0xFD}},
{x86.RSI, []byte{0x48, 0xF7, 0xFE}}, {x86.R6, []byte{0x48, 0xF7, 0xFE}},
{x86.RDI, []byte{0x48, 0xF7, 0xFF}}, {x86.R7, []byte{0x48, 0xF7, 0xFF}},
{x86.R8, []byte{0x49, 0xF7, 0xF8}}, {x86.R8, []byte{0x49, 0xF7, 0xF8}},
{x86.R9, []byte{0x49, 0xF7, 0xF9}}, {x86.R9, []byte{0x49, 0xF7, 0xF9}},
{x86.R10, []byte{0x49, 0xF7, 0xFA}}, {x86.R10, []byte{0x49, 0xF7, 0xFA}},

4
src/x86/ExtendRAXToRDX.go
View File

@ -1,7 +1,7 @@
package x86 package x86
// ExtendRAXToRDX doubles the size of RAX by sign-extending it to RDX. // ExtendR0ToR2 doubles the size of R0 (RAX) by sign-extending it to R2 (RDX).
// This is also known as CQO. // This is also known as CQO.
func ExtendRAXToRDX(code []byte) []byte { func ExtendR0ToR2(code []byte) []byte {
return append(code, 0x48, 0x99) return append(code, 0x48, 0x99)
} }

16
src/x86/LoadAddress_test.go
View File

@ -14,14 +14,14 @@ func TestLoadAddress(t *testing.T) {
Offset int Offset int
Code []byte Code []byte
}{ }{
{x86.RAX, 0, []byte{0x48, 0x8D, 0x05, 0x00, 0x00, 0x00, 0x00}}, {x86.R0, 0, []byte{0x48, 0x8D, 0x05, 0x00, 0x00, 0x00, 0x00}},
{x86.RCX, 0, []byte{0x48, 0x8D, 0x0D, 0x00, 0x00, 0x00, 0x00}}, {x86.R1, 0, []byte{0x48, 0x8D, 0x0D, 0x00, 0x00, 0x00, 0x00}},
{x86.RDX, 0, []byte{0x48, 0x8D, 0x15, 0x00, 0x00, 0x00, 0x00}}, {x86.R2, 0, []byte{0x48, 0x8D, 0x15, 0x00, 0x00, 0x00, 0x00}},
{x86.RBX, 0, []byte{0x48, 0x8D, 0x1D, 0x00, 0x00, 0x00, 0x00}}, {x86.R3, 0, []byte{0x48, 0x8D, 0x1D, 0x00, 0x00, 0x00, 0x00}},
{x86.RSP, 0, []byte{0x48, 0x8D, 0x25, 0x00, 0x00, 0x00, 0x00}}, {x86.SP, 0, []byte{0x48, 0x8D, 0x25, 0x00, 0x00, 0x00, 0x00}},
{x86.RBP, 0, []byte{0x48, 0x8D, 0x2D, 0x00, 0x00, 0x00, 0x00}}, {x86.R5, 0, []byte{0x48, 0x8D, 0x2D, 0x00, 0x00, 0x00, 0x00}},
{x86.RSI, 0, []byte{0x48, 0x8D, 0x35, 0x00, 0x00, 0x00, 0x00}}, {x86.R6, 0, []byte{0x48, 0x8D, 0x35, 0x00, 0x00, 0x00, 0x00}},
{x86.RDI, 0, []byte{0x48, 0x8D, 0x3D, 0x00, 0x00, 0x00, 0x00}}, {x86.R7, 0, []byte{0x48, 0x8D, 0x3D, 0x00, 0x00, 0x00, 0x00}},
{x86.R8, 0, []byte{0x4C, 0x8D, 0x05, 0x00, 0x00, 0x00, 0x00}}, {x86.R8, 0, []byte{0x4C, 0x8D, 0x05, 0x00, 0x00, 0x00, 0x00}},
{x86.R9, 0, []byte{0x4C, 0x8D, 0x0D, 0x00, 0x00, 0x00, 0x00}}, {x86.R9, 0, []byte{0x4C, 0x8D, 0x0D, 0x00, 0x00, 0x00, 0x00}},
{x86.R10, 0, []byte{0x4C, 0x8D, 0x15, 0x00, 0x00, 0x00, 0x00}}, {x86.R10, 0, []byte{0x4C, 0x8D, 0x15, 0x00, 0x00, 0x00, 0x00}},

128
src/x86/LoadDynamic_test.go
View File

@ -16,70 +16,70 @@ func TestLoadDynamicRegister(t *testing.T) {
OffsetRegister cpu.Register OffsetRegister cpu.Register
Code []byte Code []byte
}{ }{
{x86.R15, 8, x86.RAX, x86.R15, []byte{0x4E, 0x8B, 0x3C, 0x38}}, {x86.R15, 8, x86.R0, x86.R15, []byte{0x4E, 0x8B, 0x3C, 0x38}},
{x86.R15, 4, x86.RAX, x86.R15, []byte{0x46, 0x8B, 0x3C, 0x38}}, {x86.R15, 4, x86.R0, x86.R15, []byte{0x46, 0x8B, 0x3C, 0x38}},
{x86.R15, 2, x86.RAX, x86.R15, []byte{0x66, 0x46, 0x8B, 0x3C, 0x38}}, {x86.R15, 2, x86.R0, x86.R15, []byte{0x66, 0x46, 0x8B, 0x3C, 0x38}},
{x86.R15, 1, x86.RAX, x86.R15, []byte{0x46, 0x8A, 0x3C, 0x38}}, {x86.R15, 1, x86.R0, x86.R15, []byte{0x46, 0x8A, 0x3C, 0x38}},
{x86.R14, 8, x86.RCX, x86.R14, []byte{0x4E, 0x8B, 0x34, 0x31}}, {x86.R14, 8, x86.R1, x86.R14, []byte{0x4E, 0x8B, 0x34, 0x31}},
{x86.R14, 4, x86.RCX, x86.R14, []byte{0x46, 0x8B, 0x34, 0x31}}, {x86.R14, 4, x86.R1, x86.R14, []byte{0x46, 0x8B, 0x34, 0x31}},
{x86.R14, 2, x86.RCX, x86.R14, []byte{0x66, 0x46, 0x8B, 0x34, 0x31}}, {x86.R14, 2, x86.R1, x86.R14, []byte{0x66, 0x46, 0x8B, 0x34, 0x31}},
{x86.R14, 1, x86.RCX, x86.R14, []byte{0x46, 0x8A, 0x34, 0x31}}, {x86.R14, 1, x86.R1, x86.R14, []byte{0x46, 0x8A, 0x34, 0x31}},
{x86.R13, 8, x86.RDX, x86.R13, []byte{0x4E, 0x8B, 0x2C, 0x2A}}, {x86.R13, 8, x86.R2, x86.R13, []byte{0x4E, 0x8B, 0x2C, 0x2A}},
{x86.R13, 4, x86.RDX, x86.R13, []byte{0x46, 0x8B, 0x2C, 0x2A}}, {x86.R13, 4, x86.R2, x86.R13, []byte{0x46, 0x8B, 0x2C, 0x2A}},
{x86.R13, 2, x86.RDX, x86.R13, []byte{0x66, 0x46, 0x8B, 0x2C, 0x2A}}, {x86.R13, 2, x86.R2, x86.R13, []byte{0x66, 0x46, 0x8B, 0x2C, 0x2A}},
{x86.R13, 1, x86.RDX, x86.R13, []byte{0x46, 0x8A, 0x2C, 0x2A}}, {x86.R13, 1, x86.R2, x86.R13, []byte{0x46, 0x8A, 0x2C, 0x2A}},
{x86.R12, 8, x86.RBX, x86.R12, []byte{0x4E, 0x8B, 0x24, 0x23}}, {x86.R12, 8, x86.R3, x86.R12, []byte{0x4E, 0x8B, 0x24, 0x23}},
{x86.R12, 4, x86.RBX, x86.R12, []byte{0x46, 0x8B, 0x24, 0x23}}, {x86.R12, 4, x86.R3, x86.R12, []byte{0x46, 0x8B, 0x24, 0x23}},
{x86.R12, 2, x86.RBX, x86.R12, []byte{0x66, 0x46, 0x8B, 0x24, 0x23}}, {x86.R12, 2, x86.R3, x86.R12, []byte{0x66, 0x46, 0x8B, 0x24, 0x23}},
{x86.R12, 1, x86.RBX, x86.R12, []byte{0x46, 0x8A, 0x24, 0x23}}, {x86.R12, 1, x86.R3, x86.R12, []byte{0x46, 0x8A, 0x24, 0x23}},
{x86.R11, 8, x86.RSP, x86.R11, []byte{0x4E, 0x8B, 0x1C, 0x1C}}, {x86.R11, 8, x86.SP, x86.R11, []byte{0x4E, 0x8B, 0x1C, 0x1C}},
{x86.R11, 4, x86.RSP, x86.R11, []byte{0x46, 0x8B, 0x1C, 0x1C}}, {x86.R11, 4, x86.SP, x86.R11, []byte{0x46, 0x8B, 0x1C, 0x1C}},
{x86.R11, 2, x86.RSP, x86.R11, []byte{0x66, 0x46, 0x8B, 0x1C, 0x1C}}, {x86.R11, 2, x86.SP, x86.R11, []byte{0x66, 0x46, 0x8B, 0x1C, 0x1C}},
{x86.R11, 1, x86.RSP, x86.R11, []byte{0x46, 0x8A, 0x1C, 0x1C}}, {x86.R11, 1, x86.SP, x86.R11, []byte{0x46, 0x8A, 0x1C, 0x1C}},
{x86.R10, 8, x86.RBP, x86.R10, []byte{0x4E, 0x8B, 0x54, 0x15, 0x00}}, {x86.R10, 8, x86.R5, x86.R10, []byte{0x4E, 0x8B, 0x54, 0x15, 0x00}},
{x86.R10, 4, x86.RBP, x86.R10, []byte{0x46, 0x8B, 0x54, 0x15, 0x00}}, {x86.R10, 4, x86.R5, x86.R10, []byte{0x46, 0x8B, 0x54, 0x15, 0x00}},
{x86.R10, 2, x86.RBP, x86.R10, []byte{0x66, 0x46, 0x8B, 0x54, 0x15, 0x00}}, {x86.R10, 2, x86.R5, x86.R10, []byte{0x66, 0x46, 0x8B, 0x54, 0x15, 0x00}},
{x86.R10, 1, x86.RBP, x86.R10, []byte{0x46, 0x8A, 0x54, 0x15, 0x00}}, {x86.R10, 1, x86.R5, x86.R10, []byte{0x46, 0x8A, 0x54, 0x15, 0x00}},
{x86.R9, 8, x86.RSI, x86.R9, []byte{0x4E, 0x8B, 0x0C, 0x0E}}, {x86.R9, 8, x86.R6, x86.R9, []byte{0x4E, 0x8B, 0x0C, 0x0E}},
{x86.R9, 4, x86.RSI, x86.R9, []byte{0x46, 0x8B, 0x0C, 0x0E}}, {x86.R9, 4, x86.R6, x86.R9, []byte{0x46, 0x8B, 0x0C, 0x0E}},
{x86.R9, 2, x86.RSI, x86.R9, []byte{0x66, 0x46, 0x8B, 0x0C, 0x0E}}, {x86.R9, 2, x86.R6, x86.R9, []byte{0x66, 0x46, 0x8B, 0x0C, 0x0E}},
{x86.R9, 1, x86.RSI, x86.R9, []byte{0x46, 0x8A, 0x0C, 0x0E}}, {x86.R9, 1, x86.R6, x86.R9, []byte{0x46, 0x8A, 0x0C, 0x0E}},
{x86.R8, 8, x86.RDI, x86.R8, []byte{0x4E, 0x8B, 0x04, 0x07}}, {x86.R8, 8, x86.R7, x86.R8, []byte{0x4E, 0x8B, 0x04, 0x07}},
{x86.R8, 4, x86.RDI, x86.R8, []byte{0x46, 0x8B, 0x04, 0x07}}, {x86.R8, 4, x86.R7, x86.R8, []byte{0x46, 0x8B, 0x04, 0x07}},
{x86.R8, 2, x86.RDI, x86.R8, []byte{0x66, 0x46, 0x8B, 0x04, 0x07}}, {x86.R8, 2, x86.R7, x86.R8, []byte{0x66, 0x46, 0x8B, 0x04, 0x07}},
{x86.R8, 1, x86.RDI, x86.R8, []byte{0x46, 0x8A, 0x04, 0x07}}, {x86.R8, 1, x86.R7, x86.R8, []byte{0x46, 0x8A, 0x04, 0x07}},
{x86.RDI, 8, x86.R8, x86.RDI, []byte{0x49, 0x8B, 0x3C, 0x38}}, {x86.R7, 8, x86.R8, x86.R7, []byte{0x49, 0x8B, 0x3C, 0x38}},
{x86.RDI, 4, x86.R8, x86.RDI, []byte{0x41, 0x8B, 0x3C, 0x38}}, {x86.R7, 4, x86.R8, x86.R7, []byte{0x41, 0x8B, 0x3C, 0x38}},
{x86.RDI, 2, x86.R8, x86.RDI, []byte{0x66, 0x41, 0x8B, 0x3C, 0x38}}, {x86.R7, 2, x86.R8, x86.R7, []byte{0x66, 0x41, 0x8B, 0x3C, 0x38}},
{x86.RDI, 1, x86.R8, x86.RDI, []byte{0x41, 0x8A, 0x3C, 0x38}}, {x86.R7, 1, x86.R8, x86.R7, []byte{0x41, 0x8A, 0x3C, 0x38}},
{x86.RSI, 8, x86.R9, x86.RSI, []byte{0x49, 0x8B, 0x34, 0x31}}, {x86.R6, 8, x86.R9, x86.R6, []byte{0x49, 0x8B, 0x34, 0x31}},
{x86.RSI, 4, x86.R9, x86.RSI, []byte{0x41, 0x8B, 0x34, 0x31}}, {x86.R6, 4, x86.R9, x86.R6, []byte{0x41, 0x8B, 0x34, 0x31}},
{x86.RSI, 2, x86.R9, x86.RSI, []byte{0x66, 0x41, 0x8B, 0x34, 0x31}}, {x86.R6, 2, x86.R9, x86.R6, []byte{0x66, 0x41, 0x8B, 0x34, 0x31}},
{x86.RSI, 1, x86.R9, x86.RSI, []byte{0x41, 0x8A, 0x34, 0x31}}, {x86.R6, 1, x86.R9, x86.R6, []byte{0x41, 0x8A, 0x34, 0x31}},
{x86.RBP, 8, x86.R10, x86.RBP, []byte{0x49, 0x8B, 0x2C, 0x2A}}, {x86.R5, 8, x86.R10, x86.R5, []byte{0x49, 0x8B, 0x2C, 0x2A}},
{x86.RBP, 4, x86.R10, x86.RBP, []byte{0x41, 0x8B, 0x2C, 0x2A}}, {x86.R5, 4, x86.R10, x86.R5, []byte{0x41, 0x8B, 0x2C, 0x2A}},
{x86.RBP, 2, x86.R10, x86.RBP, []byte{0x66, 0x41, 0x8B, 0x2C, 0x2A}}, {x86.R5, 2, x86.R10, x86.R5, []byte{0x66, 0x41, 0x8B, 0x2C, 0x2A}},
{x86.RBP, 1, x86.R10, x86.RBP, []byte{0x41, 0x8A, 0x2C, 0x2A}}, {x86.R5, 1, x86.R10, x86.R5, []byte{0x41, 0x8A, 0x2C, 0x2A}},
{x86.RSP, 8, x86.R11, x86.RSP, []byte{0x4A, 0x8B, 0x24, 0x1C}}, {x86.SP, 8, x86.R11, x86.SP, []byte{0x4A, 0x8B, 0x24, 0x1C}},
{x86.RSP, 4, x86.R11, x86.RSP, []byte{0x42, 0x8B, 0x24, 0x1C}}, {x86.SP, 4, x86.R11, x86.SP, []byte{0x42, 0x8B, 0x24, 0x1C}},
{x86.RSP, 2, x86.R11, x86.RSP, []byte{0x66, 0x42, 0x8B, 0x24, 0x1C}}, {x86.SP, 2, x86.R11, x86.SP, []byte{0x66, 0x42, 0x8B, 0x24, 0x1C}},
{x86.RSP, 1, x86.R11, x86.RSP, []byte{0x42, 0x8A, 0x24, 0x1C}}, {x86.SP, 1, x86.R11, x86.SP, []byte{0x42, 0x8A, 0x24, 0x1C}},
{x86.RBX, 8, x86.R12, x86.RBX, []byte{0x49, 0x8B, 0x1C, 0x1C}}, {x86.R3, 8, x86.R12, x86.R3, []byte{0x49, 0x8B, 0x1C, 0x1C}},
{x86.RBX, 4, x86.R12, x86.RBX, []byte{0x41, 0x8B, 0x1C, 0x1C}}, {x86.R3, 4, x86.R12, x86.R3, []byte{0x41, 0x8B, 0x1C, 0x1C}},
{x86.RBX, 2, x86.R12, x86.RBX, []byte{0x66, 0x41, 0x8B, 0x1C, 0x1C}}, {x86.R3, 2, x86.R12, x86.R3, []byte{0x66, 0x41, 0x8B, 0x1C, 0x1C}},
{x86.RBX, 1, x86.R12, x86.RBX, []byte{0x41, 0x8A, 0x1C, 0x1C}}, {x86.R3, 1, x86.R12, x86.R3, []byte{0x41, 0x8A, 0x1C, 0x1C}},
{x86.RDX, 8, x86.R13, x86.RDX, []byte{0x49, 0x8B, 0x54, 0x15, 0x00}}, {x86.R2, 8, x86.R13, x86.R2, []byte{0x49, 0x8B, 0x54, 0x15, 0x00}},
{x86.RDX, 4, x86.R13, x86.RDX, []byte{0x41, 0x8B, 0x54, 0x15, 0x00}}, {x86.R2, 4, x86.R13, x86.R2, []byte{0x41, 0x8B, 0x54, 0x15, 0x00}},
{x86.RDX, 2, x86.R13, x86.RDX, []byte{0x66, 0x41, 0x8B, 0x54, 0x15, 0x00}}, {x86.R2, 2, x86.R13, x86.R2, []byte{0x66, 0x41, 0x8B, 0x54, 0x15, 0x00}},
{x86.RDX, 1, x86.R13, x86.RDX, []byte{0x41, 0x8A, 0x54, 0x15, 0x00}}, {x86.R2, 1, x86.R13, x86.R2, []byte{0x41, 0x8A, 0x54, 0x15, 0x00}},
{x86.RCX, 8, x86.R14, x86.RCX, []byte{0x49, 0x8B, 0x0C, 0x0E}}, {x86.R1, 8, x86.R14, x86.R1, []byte{0x49, 0x8B, 0x0C, 0x0E}},
{x86.RCX, 4, x86.R14, x86.RCX, []byte{0x41, 0x8B, 0x0C, 0x0E}}, {x86.R1, 4, x86.R14, x86.R1, []byte{0x41, 0x8B, 0x0C, 0x0E}},
{x86.RCX, 2, x86.R14, x86.RCX, []byte{0x66, 0x41, 0x8B, 0x0C, 0x0E}}, {x86.R1, 2, x86.R14, x86.R1, []byte{0x66, 0x41, 0x8B, 0x0C, 0x0E}},
{x86.RCX, 1, x86.R14, x86.RCX, []byte{0x41, 0x8A, 0x0C, 0x0E}}, {x86.R1, 1, x86.R14, x86.R1, []byte{0x41, 0x8A, 0x0C, 0x0E}},
{x86.RAX, 8, x86.R15, x86.RAX, []byte{0x49, 0x8B, 0x04, 0x07}}, {x86.R0, 8, x86.R15, x86.R0, []byte{0x49, 0x8B, 0x04, 0x07}},
{x86.RAX, 4, x86.R15, x86.RAX, []byte{0x41, 0x8B, 0x04, 0x07}}, {x86.R0, 4, x86.R15, x86.R0, []byte{0x41, 0x8B, 0x04, 0x07}},
{x86.RAX, 2, x86.R15, x86.RAX, []byte{0x66, 0x41, 0x8B, 0x04, 0x07}}, {x86.R0, 2, x86.R15, x86.R0, []byte{0x66, 0x41, 0x8B, 0x04, 0x07}},
{x86.RAX, 1, x86.R15, x86.RAX, []byte{0x41, 0x8A, 0x04, 0x07}}, {x86.R0, 1, x86.R15, x86.R0, []byte{0x41, 0x8A, 0x04, 0x07}},
} }
for _, pattern := range usagePatterns { for _, pattern := range usagePatterns {

256
src/x86/Load_test.go
View File

@ -17,136 +17,136 @@ func TestLoadRegister(t *testing.T) {
Code []byte Code []byte
}{ }{
// No offset // No offset
{x86.RAX, x86.R15, 0, 8, []byte{0x49, 0x8B, 0x07}}, {x86.R0, x86.R15, 0, 8, []byte{0x49, 0x8B, 0x07}},
{x86.RAX, x86.R15, 0, 4, []byte{0x41, 0x8B, 0x07}}, {x86.R0, x86.R15, 0, 4, []byte{0x41, 0x8B, 0x07}},
{x86.RAX, x86.R15, 0, 2, []byte{0x66, 0x41, 0x8B, 0x07}}, {x86.R0, x86.R15, 0, 2, []byte{0x66, 0x41, 0x8B, 0x07}},
{x86.RAX, x86.R15, 0, 1, []byte{0x41, 0x8A, 0x07}}, {x86.R0, x86.R15, 0, 1, []byte{0x41, 0x8A, 0x07}},
{x86.RCX, x86.R14, 0, 8, []byte{0x49, 0x8B, 0x0E}}, {x86.R1, x86.R14, 0, 8, []byte{0x49, 0x8B, 0x0E}},
{x86.RCX, x86.R14, 0, 4, []byte{0x41, 0x8B, 0x0E}}, {x86.R1, x86.R14, 0, 4, []byte{0x41, 0x8B, 0x0E}},
{x86.RCX, x86.R14, 0, 2, []byte{0x66, 0x41, 0x8B, 0x0E}}, {x86.R1, x86.R14, 0, 2, []byte{0x66, 0x41, 0x8B, 0x0E}},
{x86.RCX, x86.R14, 0, 1, []byte{0x41, 0x8A, 0x0E}}, {x86.R1, x86.R14, 0, 1, []byte{0x41, 0x8A, 0x0E}},
{x86.RDX, x86.R13, 0, 8, []byte{0x49, 0x8B, 0x55, 0x00}}, {x86.R2, x86.R13, 0, 8, []byte{0x49, 0x8B, 0x55, 0x00}},
{x86.RDX, x86.R13, 0, 4, []byte{0x41, 0x8B, 0x55, 0x00}}, {x86.R2, x86.R13, 0, 4, []byte{0x41, 0x8B, 0x55, 0x00}},
{x86.RDX, x86.R13, 0, 2, []byte{0x66, 0x41, 0x8B, 0x55, 0x00}}, {x86.R2, x86.R13, 0, 2, []byte{0x66, 0x41, 0x8B, 0x55, 0x00}},
{x86.RDX, x86.R13, 0, 1, []byte{0x41, 0x8A, 0x55, 0x00}}, {x86.R2, x86.R13, 0, 1, []byte{0x41, 0x8A, 0x55, 0x00}},
{x86.RBX, x86.R12, 0, 8, []byte{0x49, 0x8B, 0x1C, 0x24}}, {x86.R3, x86.R12, 0, 8, []byte{0x49, 0x8B, 0x1C, 0x24}},
{x86.RBX, x86.R12, 0, 4, []byte{0x41, 0x8B, 0x1C, 0x24}}, {x86.R3, x86.R12, 0, 4, []byte{0x41, 0x8B, 0x1C, 0x24}},
{x86.RBX, x86.R12, 0, 2, []byte{0x66, 0x41, 0x8B, 0x1C, 0x24}}, {x86.R3, x86.R12, 0, 2, []byte{0x66, 0x41, 0x8B, 0x1C, 0x24}},
{x86.RBX, x86.R12, 0, 1, []byte{0x41, 0x8A, 0x1C, 0x24}}, {x86.R3, x86.R12, 0, 1, []byte{0x41, 0x8A, 0x1C, 0x24}},
{x86.RSP, x86.R11, 0, 8, []byte{0x49, 0x8B, 0x23}}, {x86.SP, x86.R11, 0, 8, []byte{0x49, 0x8B, 0x23}},
{x86.RSP, x86.R11, 0, 4, []byte{0x41, 0x8B, 0x23}}, {x86.SP, x86.R11, 0, 4, []byte{0x41, 0x8B, 0x23}},
{x86.RSP, x86.R11, 0, 2, []byte{0x66, 0x41, 0x8B, 0x23}}, {x86.SP, x86.R11, 0, 2, []byte{0x66, 0x41, 0x8B, 0x23}},
{x86.RSP, x86.R11, 0, 1, []byte{0x41, 0x8A, 0x23}}, {x86.SP, x86.R11, 0, 1, []byte{0x41, 0x8A, 0x23}},
{x86.RBP, x86.R10, 0, 8, []byte{0x49, 0x8B, 0x2A}}, {x86.R5, x86.R10, 0, 8, []byte{0x49, 0x8B, 0x2A}},
{x86.RBP, x86.R10, 0, 4, []byte{0x41, 0x8B, 0x2A}}, {x86.R5, x86.R10, 0, 4, []byte{0x41, 0x8B, 0x2A}},
{x86.RBP, x86.R10, 0, 2, []byte{0x66, 0x41, 0x8B, 0x2A}}, {x86.R5, x86.R10, 0, 2, []byte{0x66, 0x41, 0x8B, 0x2A}},
{x86.RBP, x86.R10, 0, 1, []byte{0x41, 0x8A, 0x2A}}, {x86.R5, x86.R10, 0, 1, []byte{0x41, 0x8A, 0x2A}},
{x86.RSI, x86.R9, 0, 8, []byte{0x49, 0x8B, 0x31}}, {x86.R6, x86.R9, 0, 8, []byte{0x49, 0x8B, 0x31}},
{x86.RSI, x86.R9, 0, 4, []byte{0x41, 0x8B, 0x31}}, {x86.R6, x86.R9, 0, 4, []byte{0x41, 0x8B, 0x31}},
{x86.RSI, x86.R9, 0, 2, []byte{0x66, 0x41, 0x8B, 0x31}}, {x86.R6, x86.R9, 0, 2, []byte{0x66, 0x41, 0x8B, 0x31}},
{x86.RSI, x86.R9, 0, 1, []byte{0x41, 0x8A, 0x31}}, {x86.R6, x86.R9, 0, 1, []byte{0x41, 0x8A, 0x31}},
{x86.RDI, x86.R8, 0, 8, []byte{0x49, 0x8B, 0x38}}, {x86.R7, x86.R8, 0, 8, []byte{0x49, 0x8B, 0x38}},
{x86.RDI, x86.R8, 0, 4, []byte{0x41, 0x8B, 0x38}}, {x86.R7, x86.R8, 0, 4, []byte{0x41, 0x8B, 0x38}},
{x86.RDI, x86.R8, 0, 2, []byte{0x66, 0x41, 0x8B, 0x38}}, {x86.R7, x86.R8, 0, 2, []byte{0x66, 0x41, 0x8B, 0x38}},
{x86.RDI, x86.R8, 0, 1, []byte{0x41, 0x8A, 0x38}}, {x86.R7, x86.R8, 0, 1, []byte{0x41, 0x8A, 0x38}},
{x86.R8, x86.RDI, 0, 8, []byte{0x4C, 0x8B, 0x07}}, {x86.R8, x86.R7, 0, 8, []byte{0x4C, 0x8B, 0x07}},
{x86.R8, x86.RDI, 0, 4, []byte{0x44, 0x8B, 0x07}}, {x86.R8, x86.R7, 0, 4, []byte{0x44, 0x8B, 0x07}},
{x86.R8, x86.RDI, 0, 2, []byte{0x66, 0x44, 0x8B, 0x07}}, {x86.R8, x86.R7, 0, 2, []byte{0x66, 0x44, 0x8B, 0x07}},
{x86.R8, x86.RDI, 0, 1, []byte{0x44, 0x8A, 0x07}}, {x86.R8, x86.R7, 0, 1, []byte{0x44, 0x8A, 0x07}},
{x86.R9, x86.RSI, 0, 8, []byte{0x4C, 0x8B, 0x0E}}, {x86.R9, x86.R6, 0, 8, []byte{0x4C, 0x8B, 0x0E}},
{x86.R9, x86.RSI, 0, 4, []byte{0x44, 0x8B, 0x0E}}, {x86.R9, x86.R6, 0, 4, []byte{0x44, 0x8B, 0x0E}},
{x86.R9, x86.RSI, 0, 2, []byte{0x66, 0x44, 0x8B, 0x0E}}, {x86.R9, x86.R6, 0, 2, []byte{0x66, 0x44, 0x8B, 0x0E}},
{x86.R9, x86.RSI, 0, 1, []byte{0x44, 0x8A, 0x0E}}, {x86.R9, x86.R6, 0, 1, []byte{0x44, 0x8A, 0x0E}},
{x86.R10, x86.RBP, 0, 8, []byte{0x4C, 0x8B, 0x55, 0x00}}, {x86.R10, x86.R5, 0, 8, []byte{0x4C, 0x8B, 0x55, 0x00}},
{x86.R10, x86.RBP, 0, 4, []byte{0x44, 0x8B, 0x55, 0x00}}, {x86.R10, x86.R5, 0, 4, []byte{0x44, 0x8B, 0x55, 0x00}},
{x86.R10, x86.RBP, 0, 2, []byte{0x66, 0x44, 0x8B, 0x55, 0x00}}, {x86.R10, x86.R5, 0, 2, []byte{0x66, 0x44, 0x8B, 0x55, 0x00}},
{x86.R10, x86.RBP, 0, 1, []byte{0x44, 0x8A, 0x55, 0x00}}, {x86.R10, x86.R5, 0, 1, []byte{0x44, 0x8A, 0x55, 0x00}},
{x86.R11, x86.RSP, 0, 8, []byte{0x4C, 0x8B, 0x1C, 0x24}}, {x86.R11, x86.SP, 0, 8, []byte{0x4C, 0x8B, 0x1C, 0x24}},
{x86.R11, x86.RSP, 0, 4, []byte{0x44, 0x8B, 0x1C, 0x24}}, {x86.R11, x86.SP, 0, 4, []byte{0x44, 0x8B, 0x1C, 0x24}},
{x86.R11, x86.RSP, 0, 2, []byte{0x66, 0x44, 0x8B, 0x1C, 0x24}}, {x86.R11, x86.SP, 0, 2, []byte{0x66, 0x44, 0x8B, 0x1C, 0x24}},
{x86.R11, x86.RSP, 0, 1, []byte{0x44, 0x8A, 0x1C, 0x24}}, {x86.R11, x86.SP, 0, 1, []byte{0x44, 0x8A, 0x1C, 0x24}},
{x86.R12, x86.RBX, 0, 8, []byte{0x4C, 0x8B, 0x23}}, {x86.R12, x86.R3, 0, 8, []byte{0x4C, 0x8B, 0x23}},
{x86.R12, x86.RBX, 0, 4, []byte{0x44, 0x8B, 0x23}}, {x86.R12, x86.R3, 0, 4, []byte{0x44, 0x8B, 0x23}},
{x86.R12, x86.RBX, 0, 2, []byte{0x66, 0x44, 0x8B, 0x23}}, {x86.R12, x86.R3, 0, 2, []byte{0x66, 0x44, 0x8B, 0x23}},
{x86.R12, x86.RBX, 0, 1, []byte{0x44, 0x8A, 0x23}}, {x86.R12, x86.R3, 0, 1, []byte{0x44, 0x8A, 0x23}},
{x86.R13, x86.RDX, 0, 8, []byte{0x4C, 0x8B, 0x2A}}, {x86.R13, x86.R2, 0, 8, []byte{0x4C, 0x8B, 0x2A}},
{x86.R13, x86.RDX, 0, 4, []byte{0x44, 0x8B, 0x2A}}, {x86.R13, x86.R2, 0, 4, []byte{0x44, 0x8B, 0x2A}},
{x86.R13, x86.RDX, 0, 2, []byte{0x66, 0x44, 0x8B, 0x2A}}, {x86.R13, x86.R2, 0, 2, []byte{0x66, 0x44, 0x8B, 0x2A}},
{x86.R13, x86.RDX, 0, 1, []byte{0x44, 0x8A, 0x2A}}, {x86.R13, x86.R2, 0, 1, []byte{0x44, 0x8A, 0x2A}},
{x86.R14, x86.RCX, 0, 8, []byte{0x4C, 0x8B, 0x31}}, {x86.R14, x86.R1, 0, 8, []byte{0x4C, 0x8B, 0x31}},
{x86.R14, x86.RCX, 0, 4, []byte{0x44, 0x8B, 0x31}}, {x86.R14, x86.R1, 0, 4, []byte{0x44, 0x8B, 0x31}},
{x86.R14, x86.RCX, 0, 2, []byte{0x66, 0x44, 0x8B, 0x31}}, {x86.R14, x86.R1, 0, 2, []byte{0x66, 0x44, 0x8B, 0x31}},
{x86.R14, x86.RCX, 0, 1, []byte{0x44, 0x8A, 0x31}}, {x86.R14, x86.R1, 0, 1, []byte{0x44, 0x8A, 0x31}},
{x86.R15, x86.RAX, 0, 8, []byte{0x4C, 0x8B, 0x38}}, {x86.R15, x86.R0, 0, 8, []byte{0x4C, 0x8B, 0x38}},
{x86.R15, x86.RAX, 0, 4, []byte{0x44, 0x8B, 0x38}}, {x86.R15, x86.R0, 0, 4, []byte{0x44, 0x8B, 0x38}},
{x86.R15, x86.RAX, 0, 2, []byte{0x66, 0x44, 0x8B, 0x38}}, {x86.R15, x86.R0, 0, 2, []byte{0x66, 0x44, 0x8B, 0x38}},
{x86.R15, x86.RAX, 0, 1, []byte{0x44, 0x8A, 0x38}}, {x86.R15, x86.R0, 0, 1, []byte{0x44, 0x8A, 0x38}},
// Offset of 1 // Offset of 1
{x86.RAX, x86.R15, 1, 8, []byte{0x49, 0x8B, 0x47, 0x01}}, {x86.R0, x86.R15, 1, 8, []byte{0x49, 0x8B, 0x47, 0x01}},
{x86.RAX, x86.R15, 1, 4, []byte{0x41, 0x8B, 0x47, 0x01}}, {x86.R0, x86.R15, 1, 4, []byte{0x41, 0x8B, 0x47, 0x01}},
{x86.RAX, x86.R15, 1, 2, []byte{0x66, 0x41, 0x8B, 0x47, 0x01}}, {x86.R0, x86.R15, 1, 2, []byte{0x66, 0x41, 0x8B, 0x47, 0x01}},
{x86.RAX, x86.R15, 1, 1, []byte{0x41, 0x8A, 0x47, 0x01}}, {x86.R0, x86.R15, 1, 1, []byte{0x41, 0x8A, 0x47, 0x01}},
{x86.RCX, x86.R14, 1, 8, []byte{0x49, 0x8B, 0x4E, 0x01}}, {x86.R1, x86.R14, 1, 8, []byte{0x49, 0x8B, 0x4E, 0x01}},
{x86.RCX, x86.R14, 1, 4, []byte{0x41, 0x8B, 0x4E, 0x01}}, {x86.R1, x86.R14, 1, 4, []byte{0x41, 0x8B, 0x4E, 0x01}},
{x86.RCX, x86.R14, 1, 2, []byte{0x66, 0x41, 0x8B, 0x4E, 0x01}}, {x86.R1, x86.R14, 1, 2, []byte{0x66, 0x41, 0x8B, 0x4E, 0x01}},
{x86.RCX, x86.R14, 1, 1, []byte{0x41, 0x8A, 0x4E, 0x01}}, {x86.R1, x86.R14, 1, 1, []byte{0x41, 0x8A, 0x4E, 0x01}},
{x86.RDX, x86.R13, 1, 8, []byte{0x49, 0x8B, 0x55, 0x01}}, {x86.R2, x86.R13, 1, 8, []byte{0x49, 0x8B, 0x55, 0x01}},
{x86.RDX, x86.R13, 1, 4, []byte{0x41, 0x8B, 0x55, 0x01}}, {x86.R2, x86.R13, 1, 4, []byte{0x41, 0x8B, 0x55, 0x01}},
{x86.RDX, x86.R13, 1, 2, []byte{0x66, 0x41, 0x8B, 0x55, 0x01}}, {x86.R2, x86.R13, 1, 2, []byte{0x66, 0x41, 0x8B, 0x55, 0x01}},
{x86.RDX, x86.R13, 1, 1, []byte{0x41, 0x8A, 0x55, 0x01}}, {x86.R2, x86.R13, 1, 1, []byte{0x41, 0x8A, 0x55, 0x01}},
{x86.RBX, x86.R12, 1, 8, []byte{0x49, 0x8B, 0x5C, 0x24, 0x01}}, {x86.R3, x86.R12, 1, 8, []byte{0x49, 0x8B, 0x5C, 0x24, 0x01}},
{x86.RBX, x86.R12, 1, 4, []byte{0x41, 0x8B, 0x5C, 0x24, 0x01}}, {x86.R3, x86.R12, 1, 4, []byte{0x41, 0x8B, 0x5C, 0x24, 0x01}},
{x86.RBX, x86.R12, 1, 2, []byte{0x66, 0x41, 0x8B, 0x5C, 0x24, 0x01}}, {x86.R3, x86.R12, 1, 2, []byte{0x66, 0x41, 0x8B, 0x5C, 0x24, 0x01}},
{x86.RBX, x86.R12, 1, 1, []byte{0x41, 0x8A, 0x5C, 0x24, 0x01}}, {x86.R3, x86.R12, 1, 1, []byte{0x41, 0x8A, 0x5C, 0x24, 0x01}},
{x86.RSP, x86.R11, 1, 8, []byte{0x49, 0x8B, 0x63, 0x01}}, {x86.SP, x86.R11, 1, 8, []byte{0x49, 0x8B, 0x63, 0x01}},
{x86.RSP, x86.R11, 1, 4, []byte{0x41, 0x8B, 0x63, 0x01}}, {x86.SP, x86.R11, 1, 4, []byte{0x41, 0x8B, 0x63, 0x01}},
{x86.RSP, x86.R11, 1, 2, []byte{0x66, 0x41, 0x8B, 0x63, 0x01}}, {x86.SP, x86.R11, 1, 2, []byte{0x66, 0x41, 0x8B, 0x63, 0x01}},
{x86.RSP, x86.R11, 1, 1, []byte{0x41, 0x8A, 0x63, 0x01}}, {x86.SP, x86.R11, 1, 1, []byte{0x41, 0x8A, 0x63, 0x01}},
{x86.RBP, x86.R10, 1, 8, []byte{0x49, 0x8B, 0x6A, 0x01}}, {x86.R5, x86.R10, 1, 8, []byte{0x49, 0x8B, 0x6A, 0x01}},
{x86.RBP, x86.R10, 1, 4, []byte{0x41, 0x8B, 0x6A, 0x01}}, {x86.R5, x86.R10, 1, 4, []byte{0x41, 0x8B, 0x6A, 0x01}},
{x86.RBP, x86.R10, 1, 2, []byte{0x66, 0x41, 0x8B, 0x6A, 0x01}}, {x86.R5, x86.R10, 1, 2, []byte{0x66, 0x41, 0x8B, 0x6A, 0x01}},
{x86.RBP, x86.R10, 1, 1, []byte{0x41, 0x8A, 0x6A, 0x01}}, {x86.R5, x86.R10, 1, 1, []byte{0x41, 0x8A, 0x6A, 0x01}},
{x86.RSI, x86.R9, 1, 8, []byte{0x49, 0x8B, 0x71, 0x01}}, {x86.R6, x86.R9, 1, 8, []byte{0x49, 0x8B, 0x71, 0x01}},
{x86.RSI, x86.R9, 1, 4, []byte{0x41, 0x8B, 0x71, 0x01}}, {x86.R6, x86.R9, 1, 4, []byte{0x41, 0x8B, 0x71, 0x01}},
{x86.RSI, x86.R9, 1, 2, []byte{0x66, 0x41, 0x8B, 0x71, 0x01}}, {x86.R6, x86.R9, 1, 2, []byte{0x66, 0x41, 0x8B, 0x71, 0x01}},
{x86.RSI, x86.R9, 1, 1, []byte{0x41, 0x8A, 0x71, 0x01}}, {x86.R6, x86.R9, 1, 1, []byte{0x41, 0x8A, 0x71, 0x01}},
{x86.RDI, x86.R8, 1, 8, []byte{0x49, 0x8B, 0x78, 0x01}}, {x86.R7, x86.R8, 1, 8, []byte{0x49, 0x8B, 0x78, 0x01}},
{x86.RDI, x86.R8, 1, 4, []byte{0x41, 0x8B, 0x78, 0x01}}, {x86.R7, x86.R8, 1, 4, []byte{0x41, 0x8B, 0x78, 0x01}},
{x86.RDI, x86.R8, 1, 2, []byte{0x66, 0x41, 0x8B, 0x78, 0x01}}, {x86.R7, x86.R8, 1, 2, []byte{0x66, 0x41, 0x8B, 0x78, 0x01}},
{x86.RDI, x86.R8, 1, 1, []byte{0x41, 0x8A, 0x78, 0x01}}, {x86.R7, x86.R8, 1, 1, []byte{0x41, 0x8A, 0x78, 0x01}},
{x86.R8, x86.RDI, 1, 8, []byte{0x4C, 0x8B, 0x47, 0x01}}, {x86.R8, x86.R7, 1, 8, []byte{0x4C, 0x8B, 0x47, 0x01}},
{x86.R8, x86.RDI, 1, 4, []byte{0x44, 0x8B, 0x47, 0x01}}, {x86.R8, x86.R7, 1, 4, []byte{0x44, 0x8B, 0x47, 0x01}},
{x86.R8, x86.RDI, 1, 2, []byte{0x66, 0x44, 0x8B, 0x47, 0x01}}, {x86.R8, x86.R7, 1, 2, []byte{0x66, 0x44, 0x8B, 0x47, 0x01}},
{x86.R8, x86.RDI, 1, 1, []byte{0x44, 0x8A, 0x47, 0x01}}, {x86.R8, x86.R7, 1, 1, []byte{0x44, 0x8A, 0x47, 0x01}},
{x86.R9, x86.RSI, 1, 8, []byte{0x4C, 0x8B, 0x4E, 0x01}}, {x86.R9, x86.R6, 1, 8, []byte{0x4C, 0x8B, 0x4E, 0x01}},
{x86.R9, x86.RSI, 1, 4, []byte{0x44, 0x8B, 0x4E, 0x01}}, {x86.R9, x86.R6, 1, 4, []byte{0x44, 0x8B, 0x4E, 0x01}},
{x86.R9, x86.RSI, 1, 2, []byte{0x66, 0x44, 0x8B, 0x4E, 0x01}}, {x86.R9, x86.R6, 1, 2, []byte{0x66, 0x44, 0x8B, 0x4E, 0x01}},
{x86.R9, x86.RSI, 1, 1, []byte{0x44, 0x8A, 0x4E, 0x01}}, {x86.R9, x86.R6, 1, 1, []byte{0x44, 0x8A, 0x4E, 0x01}},
{x86.R10, x86.RBP, 1, 8, []byte{0x4C, 0x8B, 0x55, 0x01}}, {x86.R10, x86.R5, 1, 8, []byte{0x4C, 0x8B, 0x55, 0x01}},
{x86.R10, x86.RBP, 1, 4, []byte{0x44, 0x8B, 0x55, 0x01}}, {x86.R10, x86.R5, 1, 4, []byte{0x44, 0x8B, 0x55, 0x01}},
{x86.R10, x86.RBP, 1, 2, []byte{0x66, 0x44, 0x8B, 0x55, 0x01}}, {x86.R10, x86.R5, 1, 2, []byte{0x66, 0x44, 0x8B, 0x55, 0x01}},
{x86.R10, x86.RBP, 1, 1, []byte{0x44, 0x8A, 0x55, 0x01}}, {x86.R10, x86.R5, 1, 1, []byte{0x44, 0x8A, 0x55, 0x01}},
{x86.R11, x86.RSP, 1, 8, []byte{0x4C, 0x8B, 0x5C, 0x24, 0x01}}, {x86.R11, x86.SP, 1, 8, []byte{0x4C, 0x8B, 0x5C, 0x24, 0x01}},
{x86.R11, x86.RSP, 1, 4, []byte{0x44, 0x8B, 0x5C, 0x24, 0x01}}, {x86.R11, x86.SP, 1, 4, []byte{0x44, 0x8B, 0x5C, 0x24, 0x01}},
{x86.R11, x86.RSP, 1, 2, []byte{0x66, 0x44, 0x8B, 0x5C, 0x24, 0x01}}, {x86.R11, x86.SP, 1, 2, []byte{0x66, 0x44, 0x8B, 0x5C, 0x24, 0x01}},
{x86.R11, x86.RSP, 1, 1, []byte{0x44, 0x8A, 0x5C, 0x24, 0x01}}, {x86.R11, x86.SP, 1, 1, []byte{0x44, 0x8A, 0x5C, 0x24, 0x01}},
{x86.R12, x86.RBX, 1, 8, []byte{0x4C, 0x8B, 0x63, 0x01}}, {x86.R12, x86.R3, 1, 8, []byte{0x4C, 0x8B, 0x63, 0x01}},
{x86.R12, x86.RBX, 1, 4, []byte{0x44, 0x8B, 0x63, 0x01}}, {x86.R12, x86.R3, 1, 4, []byte{0x44, 0x8B, 0x63, 0x01}},
{x86.R12, x86.RBX, 1, 2, []byte{0x66, 0x44, 0x8B, 0x63, 0x01}}, {x86.R12, x86.R3, 1, 2, []byte{0x66, 0x44, 0x8B, 0x63, 0x01}},
{x86.R12, x86.RBX, 1, 1, []byte{0x44, 0x8A, 0x63, 0x01}}, {x86.R12, x86.R3, 1, 1, []byte{0x44, 0x8A, 0x63, 0x01}},
{x86.R13, x86.RDX, 1, 8, []byte{0x4C, 0x8B, 0x6A, 0x01}}, {x86.R13, x86.R2, 1, 8, []byte{0x4C, 0x8B, 0x6A, 0x01}},
{x86.R13, x86.RDX, 1, 4, []byte{0x44, 0x8B, 0x6A, 0x01}}, {x86.R13, x86.R2, 1, 4, []byte{0x44, 0x8B, 0x6A, 0x01}},
{x86.R13, x86.RDX, 1, 2, []byte{0x66, 0x44, 0x8B, 0x6A, 0x01}}, {x86.R13, x86.R2, 1, 2, []byte{0x66, 0x44, 0x8B, 0x6A, 0x01}},
{x86.R13, x86.RDX, 1, 1, []byte{0x44, 0x8A, 0x6A, 0x01}}, {x86.R13, x86.R2, 1, 1, []byte{0x44, 0x8A, 0x6A, 0x01}},
{x86.R14, x86.RCX, 1, 8, []byte{0x4C, 0x8B, 0x71, 0x01}}, {x86.R14, x86.R1, 1, 8, []byte{0x4C, 0x8B, 0x71, 0x01}},
{x86.R14, x86.RCX, 1, 4, []byte{0x44, 0x8B, 0x71, 0x01}}, {x86.R14, x86.R1, 1, 4, []byte{0x44, 0x8B, 0x71, 0x01}},
{x86.R14, x86.RCX, 1, 2, []byte{0x66, 0x44, 0x8B, 0x71, 0x01}}, {x86.R14, x86.R1, 1, 2, []byte{0x66, 0x44, 0x8B, 0x71, 0x01}},
{x86.R14, x86.RCX, 1, 1, []byte{0x44, 0x8A, 0x71, 0x01}}, {x86.R14, x86.R1, 1, 1, []byte{0x44, 0x8A, 0x71, 0x01}},
{x86.R15, x86.RAX, 1, 8, []byte{0x4C, 0x8B, 0x78, 0x01}}, {x86.R15, x86.R0, 1, 8, []byte{0x4C, 0x8B, 0x78, 0x01}},
{x86.R15, x86.RAX, 1, 4, []byte{0x44, 0x8B, 0x78, 0x01}}, {x86.R15, x86.R0, 1, 4, []byte{0x44, 0x8B, 0x78, 0x01}},
{x86.R15, x86.RAX, 1, 2, []byte{0x66, 0x44, 0x8B, 0x78, 0x01}}, {x86.R15, x86.R0, 1, 2, []byte{0x66, 0x44, 0x8B, 0x78, 0x01}},
{x86.R15, x86.RAX, 1, 1, []byte{0x44, 0x8A, 0x78, 0x01}}, {x86.R15, x86.R0, 1, 1, []byte{0x44, 0x8A, 0x78, 0x01}},
} }
for _, pattern := range usagePatterns { for _, pattern := range usagePatterns {

80
src/x86/Move_test.go
View File

@ -15,14 +15,14 @@ func TestMoveRegisterNumber(t *testing.T) {
Code []byte Code []byte
}{ }{
// 32 bits // 32 bits
{x86.RAX, 0x7FFFFFFF, []byte{0xB8, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R0, 0x7FFFFFFF, []byte{0xB8, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RCX, 0x7FFFFFFF, []byte{0xB9, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R1, 0x7FFFFFFF, []byte{0xB9, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RDX, 0x7FFFFFFF, []byte{0xBA, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R2, 0x7FFFFFFF, []byte{0xBA, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RBX, 0x7FFFFFFF, []byte{0xBB, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R3, 0x7FFFFFFF, []byte{0xBB, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RSP, 0x7FFFFFFF, []byte{0xBC, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.SP, 0x7FFFFFFF, []byte{0xBC, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RBP, 0x7FFFFFFF, []byte{0xBD, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R5, 0x7FFFFFFF, []byte{0xBD, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RSI, 0x7FFFFFFF, []byte{0xBE, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R6, 0x7FFFFFFF, []byte{0xBE, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RDI, 0x7FFFFFFF, []byte{0xBF, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R7, 0x7FFFFFFF, []byte{0xBF, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.R8, 0x7FFFFFFF, []byte{0x41, 0xB8, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R8, 0x7FFFFFFF, []byte{0x41, 0xB8, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.R9, 0x7FFFFFFF, []byte{0x41, 0xB9, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R9, 0x7FFFFFFF, []byte{0x41, 0xB9, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.R10, 0x7FFFFFFF, []byte{0x41, 0xBA, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R10, 0x7FFFFFFF, []byte{0x41, 0xBA, 0xFF, 0xFF, 0xFF, 0x7F}},
@ -33,14 +33,14 @@ func TestMoveRegisterNumber(t *testing.T) {
{x86.R15, 0x7FFFFFFF, []byte{0x41, 0xBF, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R15, 0x7FFFFFFF, []byte{0x41, 0xBF, 0xFF, 0xFF, 0xFF, 0x7F}},
// 64 bits // 64 bits
{x86.RAX, 0x7FFFFFFFFFFFFFFF, []byte{0x48, 0xB8, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R0, 0x7FFFFFFFFFFFFFFF, []byte{0x48, 0xB8, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RCX, 0x7FFFFFFFFFFFFFFF, []byte{0x48, 0xB9, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R1, 0x7FFFFFFFFFFFFFFF, []byte{0x48, 0xB9, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RDX, 0x7FFFFFFFFFFFFFFF, []byte{0x48, 0xBA, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R2, 0x7FFFFFFFFFFFFFFF, []byte{0x48, 0xBA, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RBX, 0x7FFFFFFFFFFFFFFF, []byte{0x48, 0xBB, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R3, 0x7FFFFFFFFFFFFFFF, []byte{0x48, 0xBB, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RSP, 0x7FFFFFFFFFFFFFFF, []byte{0x48, 0xBC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.SP, 0x7FFFFFFFFFFFFFFF, []byte{0x48, 0xBC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RBP, 0x7FFFFFFFFFFFFFFF, []byte{0x48, 0xBD, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R5, 0x7FFFFFFFFFFFFFFF, []byte{0x48, 0xBD, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RSI, 0x7FFFFFFFFFFFFFFF, []byte{0x48, 0xBE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R6, 0x7FFFFFFFFFFFFFFF, []byte{0x48, 0xBE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RDI, 0x7FFFFFFFFFFFFFFF, []byte{0x48, 0xBF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R7, 0x7FFFFFFFFFFFFFFF, []byte{0x48, 0xBF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.R8, 0x7FFFFFFFFFFFFFFF, []byte{0x49, 0xB8, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R8, 0x7FFFFFFFFFFFFFFF, []byte{0x49, 0xB8, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.R9, 0x7FFFFFFFFFFFFFFF, []byte{0x49, 0xB9, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R9, 0x7FFFFFFFFFFFFFFF, []byte{0x49, 0xB9, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.R10, 0x7FFFFFFFFFFFFFFF, []byte{0x49, 0xBA, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R10, 0x7FFFFFFFFFFFFFFF, []byte{0x49, 0xBA, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
@ -51,14 +51,14 @@ func TestMoveRegisterNumber(t *testing.T) {
{x86.R15, 0x7FFFFFFFFFFFFFFF, []byte{0x49, 0xBF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R15, 0x7FFFFFFFFFFFFFFF, []byte{0x49, 0xBF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
// Negative numbers // Negative numbers
{x86.RAX, -1, []byte{0x48, 0xC7, 0xC0, 0xFF, 0xFF, 0xFF, 0xFF}}, {x86.R0, -1, []byte{0x48, 0xC7, 0xC0, 0xFF, 0xFF, 0xFF, 0xFF}},
{x86.RCX, -1, []byte{0x48, 0xC7, 0xC1, 0xFF, 0xFF, 0xFF, 0xFF}}, {x86.R1, -1, []byte{0x48, 0xC7, 0xC1, 0xFF, 0xFF, 0xFF, 0xFF}},
{x86.RDX, -1, []byte{0x48, 0xC7, 0xC2, 0xFF, 0xFF, 0xFF, 0xFF}}, {x86.R2, -1, []byte{0x48, 0xC7, 0xC2, 0xFF, 0xFF, 0xFF, 0xFF}},
{x86.RBX, -1, []byte{0x48, 0xC7, 0xC3, 0xFF, 0xFF, 0xFF, 0xFF}}, {x86.R3, -1, []byte{0x48, 0xC7, 0xC3, 0xFF, 0xFF, 0xFF, 0xFF}},
{x86.RSP, -1, []byte{0x48, 0xC7, 0xC4, 0xFF, 0xFF, 0xFF, 0xFF}}, {x86.SP, -1, []byte{0x48, 0xC7, 0xC4, 0xFF, 0xFF, 0xFF, 0xFF}},
{x86.RBP, -1, []byte{0x48, 0xC7, 0xC5, 0xFF, 0xFF, 0xFF, 0xFF}}, {x86.R5, -1, []byte{0x48, 0xC7, 0xC5, 0xFF, 0xFF, 0xFF, 0xFF}},
{x86.RSI, -1, []byte{0x48, 0xC7, 0xC6, 0xFF, 0xFF, 0xFF, 0xFF}}, {x86.R6, -1, []byte{0x48, 0xC7, 0xC6, 0xFF, 0xFF, 0xFF, 0xFF}},
{x86.RDI, -1, []byte{0x48, 0xC7, 0xC7, 0xFF, 0xFF, 0xFF, 0xFF}}, {x86.R7, -1, []byte{0x48, 0xC7, 0xC7, 0xFF, 0xFF, 0xFF, 0xFF}},
{x86.R8, -1, []byte{0x49, 0xC7, 0xC0, 0xFF, 0xFF, 0xFF, 0xFF}}, {x86.R8, -1, []byte{0x49, 0xC7, 0xC0, 0xFF, 0xFF, 0xFF, 0xFF}},
{x86.R9, -1, []byte{0x49, 0xC7, 0xC1, 0xFF, 0xFF, 0xFF, 0xFF}}, {x86.R9, -1, []byte{0x49, 0xC7, 0xC1, 0xFF, 0xFF, 0xFF, 0xFF}},
{x86.R10, -1, []byte{0x49, 0xC7, 0xC2, 0xFF, 0xFF, 0xFF, 0xFF}}, {x86.R10, -1, []byte{0x49, 0xC7, 0xC2, 0xFF, 0xFF, 0xFF, 0xFF}},
@ -82,22 +82,22 @@ func TestMoveRegisterRegister(t *testing.T) {
Right cpu.Register Right cpu.Register
Code []byte Code []byte
}{ }{
{x86.RAX, x86.R15, []byte{0x4C, 0x89, 0xF8}}, {x86.R0, x86.R15, []byte{0x4C, 0x89, 0xF8}},
{x86.RCX, x86.R14, []byte{0x4C, 0x89, 0xF1}}, {x86.R1, x86.R14, []byte{0x4C, 0x89, 0xF1}},
{x86.RDX, x86.R13, []byte{0x4C, 0x89, 0xEA}}, {x86.R2, x86.R13, []byte{0x4C, 0x89, 0xEA}},
{x86.RBX, x86.R12, []byte{0x4C, 0x89, 0xE3}}, {x86.R3, x86.R12, []byte{0x4C, 0x89, 0xE3}},
{x86.RSP, x86.R11, []byte{0x4C, 0x89, 0xDC}}, {x86.SP, x86.R11, []byte{0x4C, 0x89, 0xDC}},
{x86.RBP, x86.R10, []byte{0x4C, 0x89, 0xD5}}, {x86.R5, x86.R10, []byte{0x4C, 0x89, 0xD5}},
{x86.RSI, x86.R9, []byte{0x4C, 0x89, 0xCE}}, {x86.R6, x86.R9, []byte{0x4C, 0x89, 0xCE}},
{x86.RDI, x86.R8, []byte{0x4C, 0x89, 0xC7}}, {x86.R7, x86.R8, []byte{0x4C, 0x89, 0xC7}},
{x86.R8, x86.RDI, []byte{0x49, 0x89, 0xF8}}, {x86.R8, x86.R7, []byte{0x49, 0x89, 0xF8}},
{x86.R9, x86.RSI, []byte{0x49, 0x89, 0xF1}}, {x86.R9, x86.R6, []byte{0x49, 0x89, 0xF1}},
{x86.R10, x86.RBP, []byte{0x49, 0x89, 0xEA}}, {x86.R10, x86.R5, []byte{0x49, 0x89, 0xEA}},
{x86.R11, x86.RSP, []byte{0x49, 0x89, 0xE3}}, {x86.R11, x86.SP, []byte{0x49, 0x89, 0xE3}},
{x86.R12, x86.RBX, []byte{0x49, 0x89, 0xDC}}, {x86.R12, x86.R3, []byte{0x49, 0x89, 0xDC}},
{x86.R13, x86.RDX, []byte{0x49, 0x89, 0xD5}}, {x86.R13, x86.R2, []byte{0x49, 0x89, 0xD5}},
{x86.R14, x86.RCX, []byte{0x49, 0x89, 0xCE}}, {x86.R14, x86.R1, []byte{0x49, 0x89, 0xCE}},
{x86.R15, x86.RAX, []byte{0x49, 0x89, 0xC7}}, {x86.R15, x86.R0, []byte{0x49, 0x89, 0xC7}},
} }
for _, pattern := range usagePatterns { for _, pattern := range usagePatterns {

64
src/x86/Mul_test.go
View File

@ -14,14 +14,14 @@ func TestMulRegisterNumber(t *testing.T) {
Number int Number int
Code []byte Code []byte
}{ }{
{x86.RAX, 1, []byte{0x48, 0x6B, 0xC0, 0x01}}, {x86.R0, 1, []byte{0x48, 0x6B, 0xC0, 0x01}},
{x86.RCX, 1, []byte{0x48, 0x6B, 0xC9, 0x01}}, {x86.R1, 1, []byte{0x48, 0x6B, 0xC9, 0x01}},
{x86.RDX, 1, []byte{0x48, 0x6B, 0xD2, 0x01}}, {x86.R2, 1, []byte{0x48, 0x6B, 0xD2, 0x01}},
{x86.RBX, 1, []byte{0x48, 0x6B, 0xDB, 0x01}}, {x86.R3, 1, []byte{0x48, 0x6B, 0xDB, 0x01}},
{x86.RSP, 1, []byte{0x48, 0x6B, 0xE4, 0x01}}, {x86.SP, 1, []byte{0x48, 0x6B, 0xE4, 0x01}},
{x86.RBP, 1, []byte{0x48, 0x6B, 0xED, 0x01}}, {x86.R5, 1, []byte{0x48, 0x6B, 0xED, 0x01}},
{x86.RSI, 1, []byte{0x48, 0x6B, 0xF6, 0x01}}, {x86.R6, 1, []byte{0x48, 0x6B, 0xF6, 0x01}},
{x86.RDI, 1, []byte{0x48, 0x6B, 0xFF, 0x01}}, {x86.R7, 1, []byte{0x48, 0x6B, 0xFF, 0x01}},
{x86.R8, 1, []byte{0x4D, 0x6B, 0xC0, 0x01}}, {x86.R8, 1, []byte{0x4D, 0x6B, 0xC0, 0x01}},
{x86.R9, 1, []byte{0x4D, 0x6B, 0xC9, 0x01}}, {x86.R9, 1, []byte{0x4D, 0x6B, 0xC9, 0x01}},
{x86.R10, 1, []byte{0x4D, 0x6B, 0xD2, 0x01}}, {x86.R10, 1, []byte{0x4D, 0x6B, 0xD2, 0x01}},
@ -31,14 +31,14 @@ func TestMulRegisterNumber(t *testing.T) {
{x86.R14, 1, []byte{0x4D, 0x6B, 0xF6, 0x01}}, {x86.R14, 1, []byte{0x4D, 0x6B, 0xF6, 0x01}},
{x86.R15, 1, []byte{0x4D, 0x6B, 0xFF, 0x01}}, {x86.R15, 1, []byte{0x4D, 0x6B, 0xFF, 0x01}},
{x86.RAX, 0x7FFFFFFF, []byte{0x48, 0x69, 0xC0, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R0, 0x7FFFFFFF, []byte{0x48, 0x69, 0xC0, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RCX, 0x7FFFFFFF, []byte{0x48, 0x69, 0xC9, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R1, 0x7FFFFFFF, []byte{0x48, 0x69, 0xC9, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RDX, 0x7FFFFFFF, []byte{0x48, 0x69, 0xD2, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R2, 0x7FFFFFFF, []byte{0x48, 0x69, 0xD2, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RBX, 0x7FFFFFFF, []byte{0x48, 0x69, 0xDB, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R3, 0x7FFFFFFF, []byte{0x48, 0x69, 0xDB, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RSP, 0x7FFFFFFF, []byte{0x48, 0x69, 0xE4, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.SP, 0x7FFFFFFF, []byte{0x48, 0x69, 0xE4, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RBP, 0x7FFFFFFF, []byte{0x48, 0x69, 0xED, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R5, 0x7FFFFFFF, []byte{0x48, 0x69, 0xED, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RSI, 0x7FFFFFFF, []byte{0x48, 0x69, 0xF6, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R6, 0x7FFFFFFF, []byte{0x48, 0x69, 0xF6, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RDI, 0x7FFFFFFF, []byte{0x48, 0x69, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R7, 0x7FFFFFFF, []byte{0x48, 0x69, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.R8, 0x7FFFFFFF, []byte{0x4D, 0x69, 0xC0, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R8, 0x7FFFFFFF, []byte{0x4D, 0x69, 0xC0, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.R9, 0x7FFFFFFF, []byte{0x4D, 0x69, 0xC9, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R9, 0x7FFFFFFF, []byte{0x4D, 0x69, 0xC9, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.R10, 0x7FFFFFFF, []byte{0x4D, 0x69, 0xD2, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R10, 0x7FFFFFFF, []byte{0x4D, 0x69, 0xD2, 0xFF, 0xFF, 0xFF, 0x7F}},
@ -62,22 +62,22 @@ func TestMulRegisterRegister(t *testing.T) {
Right cpu.Register Right cpu.Register
Code []byte Code []byte
}{ }{
{x86.RAX, x86.R15, []byte{0x49, 0x0F, 0xAF, 0xC7}}, {x86.R0, x86.R15, []byte{0x49, 0x0F, 0xAF, 0xC7}},
{x86.RCX, x86.R14, []byte{0x49, 0x0F, 0xAF, 0xCE}}, {x86.R1, x86.R14, []byte{0x49, 0x0F, 0xAF, 0xCE}},
{x86.RDX, x86.R13, []byte{0x49, 0x0F, 0xAF, 0xD5}}, {x86.R2, x86.R13, []byte{0x49, 0x0F, 0xAF, 0xD5}},
{x86.RBX, x86.R12, []byte{0x49, 0x0F, 0xAF, 0xDC}}, {x86.R3, x86.R12, []byte{0x49, 0x0F, 0xAF, 0xDC}},
{x86.RSP, x86.R11, []byte{0x49, 0x0F, 0xAF, 0xE3}}, {x86.SP, x86.R11, []byte{0x49, 0x0F, 0xAF, 0xE3}},
{x86.RBP, x86.R10, []byte{0x49, 0x0F, 0xAF, 0xEA}}, {x86.R5, x86.R10, []byte{0x49, 0x0F, 0xAF, 0xEA}},
{x86.RSI, x86.R9, []byte{0x49, 0x0F, 0xAF, 0xF1}}, {x86.R6, x86.R9, []byte{0x49, 0x0F, 0xAF, 0xF1}},
{x86.RDI, x86.R8, []byte{0x49, 0x0F, 0xAF, 0xF8}}, {x86.R7, x86.R8, []byte{0x49, 0x0F, 0xAF, 0xF8}},
{x86.R8, x86.RDI, []byte{0x4C, 0x0F, 0xAF, 0xC7}}, {x86.R8, x86.R7, []byte{0x4C, 0x0F, 0xAF, 0xC7}},
{x86.R9, x86.RSI, []byte{0x4C, 0x0F, 0xAF, 0xCE}}, {x86.R9, x86.R6, []byte{0x4C, 0x0F, 0xAF, 0xCE}},
{x86.R10, x86.RBP, []byte{0x4C, 0x0F, 0xAF, 0xD5}}, {x86.R10, x86.R5, []byte{0x4C, 0x0F, 0xAF, 0xD5}},
{x86.R11, x86.RSP, []byte{0x4C, 0x0F, 0xAF, 0xDC}}, {x86.R11, x86.SP, []byte{0x4C, 0x0F, 0xAF, 0xDC}},
{x86.R12, x86.RBX, []byte{0x4C, 0x0F, 0xAF, 0xE3}}, {x86.R12, x86.R3, []byte{0x4C, 0x0F, 0xAF, 0xE3}},
{x86.R13, x86.RDX, []byte{0x4C, 0x0F, 0xAF, 0xEA}}, {x86.R13, x86.R2, []byte{0x4C, 0x0F, 0xAF, 0xEA}},
{x86.R14, x86.RCX, []byte{0x4C, 0x0F, 0xAF, 0xF1}}, {x86.R14, x86.R1, []byte{0x4C, 0x0F, 0xAF, 0xF1}},
{x86.R15, x86.RAX, []byte{0x4C, 0x0F, 0xAF, 0xF8}}, {x86.R15, x86.R0, []byte{0x4C, 0x0F, 0xAF, 0xF8}},
} }
for _, pattern := range usagePatterns { for _, pattern := range usagePatterns {

16
src/x86/Negate_test.go
View File

@ -13,14 +13,14 @@ func TestNegateRegister(t *testing.T) {
Register cpu.Register Register cpu.Register
Code []byte Code []byte
}{ }{
{x86.RAX, []byte{0x48, 0xF7, 0xD8}}, {x86.R0, []byte{0x48, 0xF7, 0xD8}},
{x86.RCX, []byte{0x48, 0xF7, 0xD9}}, {x86.R1, []byte{0x48, 0xF7, 0xD9}},
{x86.RDX, []byte{0x48, 0xF7, 0xDA}}, {x86.R2, []byte{0x48, 0xF7, 0xDA}},
{x86.RBX, []byte{0x48, 0xF7, 0xDB}}, {x86.R3, []byte{0x48, 0xF7, 0xDB}},
{x86.RSP, []byte{0x48, 0xF7, 0xDC}}, {x86.SP, []byte{0x48, 0xF7, 0xDC}},
{x86.RBP, []byte{0x48, 0xF7, 0xDD}}, {x86.R5, []byte{0x48, 0xF7, 0xDD}},
{x86.RSI, []byte{0x48, 0xF7, 0xDE}}, {x86.R6, []byte{0x48, 0xF7, 0xDE}},
{x86.RDI, []byte{0x48, 0xF7, 0xDF}}, {x86.R7, []byte{0x48, 0xF7, 0xDF}},
{x86.R8, []byte{0x49, 0xF7, 0xD8}}, {x86.R8, []byte{0x49, 0xF7, 0xD8}},
{x86.R9, []byte{0x49, 0xF7, 0xD9}}, {x86.R9, []byte{0x49, 0xF7, 0xD9}},
{x86.R10, []byte{0x49, 0xF7, 0xDA}}, {x86.R10, []byte{0x49, 0xF7, 0xDA}},

64
src/x86/Or_test.go
View File

@ -14,14 +14,14 @@ func TestOrRegisterNumber(t *testing.T) {
Number int Number int
Code []byte Code []byte
}{ }{
{x86.RAX, 1, []byte{0x48, 0x83, 0xC8, 0x01}}, {x86.R0, 1, []byte{0x48, 0x83, 0xC8, 0x01}},
{x86.RCX, 1, []byte{0x48, 0x83, 0xC9, 0x01}}, {x86.R1, 1, []byte{0x48, 0x83, 0xC9, 0x01}},
{x86.RDX, 1, []byte{0x48, 0x83, 0xCA, 0x01}}, {x86.R2, 1, []byte{0x48, 0x83, 0xCA, 0x01}},
{x86.RBX, 1, []byte{0x48, 0x83, 0xCB, 0x01}}, {x86.R3, 1, []byte{0x48, 0x83, 0xCB, 0x01}},
{x86.RSP, 1, []byte{0x48, 0x83, 0xCC, 0x01}}, {x86.SP, 1, []byte{0x48, 0x83, 0xCC, 0x01}},
{x86.RBP, 1, []byte{0x48, 0x83, 0xCD, 0x01}}, {x86.R5, 1, []byte{0x48, 0x83, 0xCD, 0x01}},
{x86.RSI, 1, []byte{0x48, 0x83, 0xCE, 0x01}}, {x86.R6, 1, []byte{0x48, 0x83, 0xCE, 0x01}},
{x86.RDI, 1, []byte{0x48, 0x83, 0xCF, 0x01}}, {x86.R7, 1, []byte{0x48, 0x83, 0xCF, 0x01}},
{x86.R8, 1, []byte{0x49, 0x83, 0xC8, 0x01}}, {x86.R8, 1, []byte{0x49, 0x83, 0xC8, 0x01}},
{x86.R9, 1, []byte{0x49, 0x83, 0xC9, 0x01}}, {x86.R9, 1, []byte{0x49, 0x83, 0xC9, 0x01}},
{x86.R10, 1, []byte{0x49, 0x83, 0xCA, 0x01}}, {x86.R10, 1, []byte{0x49, 0x83, 0xCA, 0x01}},
@ -31,14 +31,14 @@ func TestOrRegisterNumber(t *testing.T) {
{x86.R14, 1, []byte{0x49, 0x83, 0xCE, 0x01}}, {x86.R14, 1, []byte{0x49, 0x83, 0xCE, 0x01}},
{x86.R15, 1, []byte{0x49, 0x83, 0xCF, 0x01}}, {x86.R15, 1, []byte{0x49, 0x83, 0xCF, 0x01}},
{x86.RAX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xC8, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R0, 0x7FFFFFFF, []byte{0x48, 0x81, 0xC8, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RCX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xC9, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R1, 0x7FFFFFFF, []byte{0x48, 0x81, 0xC9, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RDX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xCA, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R2, 0x7FFFFFFF, []byte{0x48, 0x81, 0xCA, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RBX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xCB, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R3, 0x7FFFFFFF, []byte{0x48, 0x81, 0xCB, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RSP, 0x7FFFFFFF, []byte{0x48, 0x81, 0xCC, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.SP, 0x7FFFFFFF, []byte{0x48, 0x81, 0xCC, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RBP, 0x7FFFFFFF, []byte{0x48, 0x81, 0xCD, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R5, 0x7FFFFFFF, []byte{0x48, 0x81, 0xCD, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RSI, 0x7FFFFFFF, []byte{0x48, 0x81, 0xCE, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R6, 0x7FFFFFFF, []byte{0x48, 0x81, 0xCE, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RDI, 0x7FFFFFFF, []byte{0x48, 0x81, 0xCF, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R7, 0x7FFFFFFF, []byte{0x48, 0x81, 0xCF, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.R8, 0x7FFFFFFF, []byte{0x49, 0x81, 0xC8, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R8, 0x7FFFFFFF, []byte{0x49, 0x81, 0xC8, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.R9, 0x7FFFFFFF, []byte{0x49, 0x81, 0xC9, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R9, 0x7FFFFFFF, []byte{0x49, 0x81, 0xC9, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.R10, 0x7FFFFFFF, []byte{0x49, 0x81, 0xCA, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R10, 0x7FFFFFFF, []byte{0x49, 0x81, 0xCA, 0xFF, 0xFF, 0xFF, 0x7F}},
@ -62,22 +62,22 @@ func TestOrRegisterRegister(t *testing.T) {
Right cpu.Register Right cpu.Register
Code []byte Code []byte
}{ }{
{x86.RAX, x86.R15, []byte{0x4C, 0x09, 0xF8}}, {x86.R0, x86.R15, []byte{0x4C, 0x09, 0xF8}},
{x86.RCX, x86.R14, []byte{0x4C, 0x09, 0xF1}}, {x86.R1, x86.R14, []byte{0x4C, 0x09, 0xF1}},
{x86.RDX, x86.R13, []byte{0x4C, 0x09, 0xEA}}, {x86.R2, x86.R13, []byte{0x4C, 0x09, 0xEA}},
{x86.RBX, x86.R12, []byte{0x4C, 0x09, 0xE3}}, {x86.R3, x86.R12, []byte{0x4C, 0x09, 0xE3}},
{x86.RSP, x86.R11, []byte{0x4C, 0x09, 0xDC}}, {x86.SP, x86.R11, []byte{0x4C, 0x09, 0xDC}},
{x86.RBP, x86.R10, []byte{0x4C, 0x09, 0xD5}}, {x86.R5, x86.R10, []byte{0x4C, 0x09, 0xD5}},
{x86.RSI, x86.R9, []byte{0x4C, 0x09, 0xCE}}, {x86.R6, x86.R9, []byte{0x4C, 0x09, 0xCE}},
{x86.RDI, x86.R8, []byte{0x4C, 0x09, 0xC7}}, {x86.R7, x86.R8, []byte{0x4C, 0x09, 0xC7}},
{x86.R8, x86.RDI, []byte{0x49, 0x09, 0xF8}}, {x86.R8, x86.R7, []byte{0x49, 0x09, 0xF8}},
{x86.R9, x86.RSI, []byte{0x49, 0x09, 0xF1}}, {x86.R9, x86.R6, []byte{0x49, 0x09, 0xF1}},
{x86.R10, x86.RBP, []byte{0x49, 0x09, 0xEA}}, {x86.R10, x86.R5, []byte{0x49, 0x09, 0xEA}},
{x86.R11, x86.RSP, []byte{0x49, 0x09, 0xE3}}, {x86.R11, x86.SP, []byte{0x49, 0x09, 0xE3}},
{x86.R12, x86.RBX, []byte{0x49, 0x09, 0xDC}}, {x86.R12, x86.R3, []byte{0x49, 0x09, 0xDC}},
{x86.R13, x86.RDX, []byte{0x49, 0x09, 0xD5}}, {x86.R13, x86.R2, []byte{0x49, 0x09, 0xD5}},
{x86.R14, x86.RCX, []byte{0x49, 0x09, 0xCE}}, {x86.R14, x86.R1, []byte{0x49, 0x09, 0xCE}},
{x86.R15, x86.RAX, []byte{0x49, 0x09, 0xC7}}, {x86.R15, x86.R0, []byte{0x49, 0x09, 0xC7}},
} }
for _, pattern := range usagePatterns { for _, pattern := range usagePatterns {

16
src/x86/Pop_test.go
View File

@ -13,14 +13,14 @@ func TestPopRegister(t *testing.T) {
Register cpu.Register Register cpu.Register
Code []byte Code []byte
}{ }{
{x86.RAX, []byte{0x58}}, {x86.R0, []byte{0x58}},
{x86.RCX, []byte{0x59}}, {x86.R1, []byte{0x59}},
{x86.RDX, []byte{0x5A}}, {x86.R2, []byte{0x5A}},
{x86.RBX, []byte{0x5B}}, {x86.R3, []byte{0x5B}},
{x86.RSP, []byte{0x5C}}, {x86.SP, []byte{0x5C}},
{x86.RBP, []byte{0x5D}}, {x86.R5, []byte{0x5D}},
{x86.RSI, []byte{0x5E}}, {x86.R6, []byte{0x5E}},
{x86.RDI, []byte{0x5F}}, {x86.R7, []byte{0x5F}},
{x86.R8, []byte{0x41, 0x58}}, {x86.R8, []byte{0x41, 0x58}},
{x86.R9, []byte{0x41, 0x59}}, {x86.R9, []byte{0x41, 0x59}},
{x86.R10, []byte{0x41, 0x5A}}, {x86.R10, []byte{0x41, 0x5A}},

16
src/x86/Push_test.go
View File

@ -35,14 +35,14 @@ func TestPushRegister(t *testing.T) {
Register cpu.Register Register cpu.Register
Code []byte Code []byte
}{ }{
{x86.RAX, []byte{0x50}}, {x86.R0, []byte{0x50}},
{x86.RCX, []byte{0x51}}, {x86.R1, []byte{0x51}},
{x86.RDX, []byte{0x52}}, {x86.R2, []byte{0x52}},
{x86.RBX, []byte{0x53}}, {x86.R3, []byte{0x53}},
{x86.RSP, []byte{0x54}}, {x86.SP, []byte{0x54}},
{x86.RBP, []byte{0x55}}, {x86.R5, []byte{0x55}},
{x86.RSI, []byte{0x56}}, {x86.R6, []byte{0x56}},
{x86.RDI, []byte{0x57}}, {x86.R7, []byte{0x57}},
{x86.R8, []byte{0x41, 0x50}}, {x86.R8, []byte{0x41, 0x50}},
{x86.R9, []byte{0x41, 0x51}}, {x86.R9, []byte{0x41, 0x51}},
{x86.R10, []byte{0x41, 0x52}}, {x86.R10, []byte{0x41, 0x52}},

38
src/x86/Registers.go
View File

@ -3,14 +3,14 @@ package x86
import "git.urbach.dev/cli/q/src/cpu" import "git.urbach.dev/cli/q/src/cpu"
const ( const (
RAX cpu.Register = iota R0 cpu.Register = iota // RAX
RCX R1 // RCX
RDX R2 // RDX
RBX R3 // RBX
RSP SP // Stack pointer
RBP R5 // RBP
RSI R6 // RSI
RDI R7 // RDI
R8 R8
R9 R9
R10 R10
@ -19,25 +19,21 @@ const (
R13 R13
R14 R14
R15 R15
TMP = RCX TMP = R1
) )
var ( var (
SyscallInputRegisters = []cpu.Register{RAX, RDI, RSI, RDX, R10, R8, R9} SyscallInputRegisters = []cpu.Register{R0, R7, R6, R2, R10, R8, R9}
SyscallOutputRegisters = []cpu.Register{RAX, RCX, R11} WindowsInputRegisters = []cpu.Register{R1, R2, R8, R9}
GeneralRegisters = []cpu.Register{RBX, R12, R13, R14, R15, R11} WindowsOutputRegisters = []cpu.Register{R0}
InputRegisters = SyscallInputRegisters WindowsVolatileRegisters = []cpu.Register{R1, R2, R8, R9, R10, R11}
OutputRegisters = SyscallInputRegisters
WindowsInputRegisters = []cpu.Register{RCX, RDX, R8, R9}
WindowsOutputRegisters = []cpu.Register{RAX}
WindowsVolatileRegisters = []cpu.Register{RCX, RDX, R8, R9, R10, R11}
CPU = cpu.CPU{ CPU = cpu.CPU{
General: GeneralRegisters, General: []cpu.Register{R3, R12, R13, R14, R15, R11},
Input: InputRegisters, Input: SyscallInputRegisters,
Output: OutputRegisters, Output: SyscallInputRegisters,
SyscallInput: SyscallInputRegisters, SyscallInput: SyscallInputRegisters,
SyscallOutput: SyscallOutputRegisters, SyscallOutput: []cpu.Register{R0, R1, R11},
NumRegisters: 16, NumRegisters: 16,
} }
) )

2
src/x86/Registers_test.go
View File

@ -8,5 +8,5 @@ import (
) )
func TestRegisters(t *testing.T) { func TestRegisters(t *testing.T) {
assert.NotContains(t, x86.GeneralRegisters, x86.RSP) assert.NotContains(t, x86.CPU.General, x86.SP)
} }

32
src/x86/Shift_test.go
View File

@ -14,14 +14,14 @@ func TestShiftLeftNumber(t *testing.T) {
Number int Number int
Code []byte Code []byte
}{ }{
{x86.RAX, 1, []byte{0x48, 0xC1, 0xE0, 0x01}}, {x86.R0, 1, []byte{0x48, 0xC1, 0xE0, 0x01}},
{x86.RCX, 1, []byte{0x48, 0xC1, 0xE1, 0x01}}, {x86.R1, 1, []byte{0x48, 0xC1, 0xE1, 0x01}},
{x86.RDX, 1, []byte{0x48, 0xC1, 0xE2, 0x01}}, {x86.R2, 1, []byte{0x48, 0xC1, 0xE2, 0x01}},
{x86.RBX, 1, []byte{0x48, 0xC1, 0xE3, 0x01}}, {x86.R3, 1, []byte{0x48, 0xC1, 0xE3, 0x01}},
{x86.RSP, 1, []byte{0x48, 0xC1, 0xE4, 0x01}}, {x86.SP, 1, []byte{0x48, 0xC1, 0xE4, 0x01}},
{x86.RBP, 1, []byte{0x48, 0xC1, 0xE5, 0x01}}, {x86.R5, 1, []byte{0x48, 0xC1, 0xE5, 0x01}},
{x86.RSI, 1, []byte{0x48, 0xC1, 0xE6, 0x01}}, {x86.R6, 1, []byte{0x48, 0xC1, 0xE6, 0x01}},
{x86.RDI, 1, []byte{0x48, 0xC1, 0xE7, 0x01}}, {x86.R7, 1, []byte{0x48, 0xC1, 0xE7, 0x01}},
{x86.R8, 1, []byte{0x49, 0xC1, 0xE0, 0x01}}, {x86.R8, 1, []byte{0x49, 0xC1, 0xE0, 0x01}},
{x86.R9, 1, []byte{0x49, 0xC1, 0xE1, 0x01}}, {x86.R9, 1, []byte{0x49, 0xC1, 0xE1, 0x01}},
{x86.R10, 1, []byte{0x49, 0xC1, 0xE2, 0x01}}, {x86.R10, 1, []byte{0x49, 0xC1, 0xE2, 0x01}},
@ -45,14 +45,14 @@ func TestShiftRightSignedNumber(t *testing.T) {
Number int Number int
Code []byte Code []byte
}{ }{
{x86.RAX, 1, []byte{0x48, 0xC1, 0xF8, 0x01}}, {x86.R0, 1, []byte{0x48, 0xC1, 0xF8, 0x01}},
{x86.RCX, 1, []byte{0x48, 0xC1, 0xF9, 0x01}}, {x86.R1, 1, []byte{0x48, 0xC1, 0xF9, 0x01}},
{x86.RDX, 1, []byte{0x48, 0xC1, 0xFA, 0x01}}, {x86.R2, 1, []byte{0x48, 0xC1, 0xFA, 0x01}},
{x86.RBX, 1, []byte{0x48, 0xC1, 0xFB, 0x01}}, {x86.R3, 1, []byte{0x48, 0xC1, 0xFB, 0x01}},
{x86.RSP, 1, []byte{0x48, 0xC1, 0xFC, 0x01}}, {x86.SP, 1, []byte{0x48, 0xC1, 0xFC, 0x01}},
{x86.RBP, 1, []byte{0x48, 0xC1, 0xFD, 0x01}}, {x86.R5, 1, []byte{0x48, 0xC1, 0xFD, 0x01}},
{x86.RSI, 1, []byte{0x48, 0xC1, 0xFE, 0x01}}, {x86.R6, 1, []byte{0x48, 0xC1, 0xFE, 0x01}},
{x86.RDI, 1, []byte{0x48, 0xC1, 0xFF, 0x01}}, {x86.R7, 1, []byte{0x48, 0xC1, 0xFF, 0x01}},
{x86.R8, 1, []byte{0x49, 0xC1, 0xF8, 0x01}}, {x86.R8, 1, []byte{0x49, 0xC1, 0xF8, 0x01}},
{x86.R9, 1, []byte{0x49, 0xC1, 0xF9, 0x01}}, {x86.R9, 1, []byte{0x49, 0xC1, 0xF9, 0x01}},
{x86.R10, 1, []byte{0x49, 0xC1, 0xFA, 0x01}}, {x86.R10, 1, []byte{0x49, 0xC1, 0xFA, 0x01}},

256
src/x86/StoreDynamic_test.go
View File

@ -16,70 +16,70 @@ func TestStoreDynamicNumber(t *testing.T) {
Number int Number int
Code []byte Code []byte
}{ }{
{x86.RAX, x86.R15, 8, 0x7F, []byte{0x4A, 0xC7, 0x04, 0x38, 0x7F, 0x00, 0x00, 0x00}}, {x86.R0, x86.R15, 8, 0x7F, []byte{0x4A, 0xC7, 0x04, 0x38, 0x7F, 0x00, 0x00, 0x00}},
{x86.RAX, x86.R15, 4, 0x7F, []byte{0x42, 0xC7, 0x04, 0x38, 0x7F, 0x00, 0x00, 0x00}}, {x86.R0, x86.R15, 4, 0x7F, []byte{0x42, 0xC7, 0x04, 0x38, 0x7F, 0x00, 0x00, 0x00}},
{x86.RAX, x86.R15, 2, 0x7F, []byte{0x66, 0x42, 0xC7, 0x04, 0x38, 0x7F, 0x00}}, {x86.R0, x86.R15, 2, 0x7F, []byte{0x66, 0x42, 0xC7, 0x04, 0x38, 0x7F, 0x00}},
{x86.RAX, x86.R15, 1, 0x7F, []byte{0x42, 0xC6, 0x04, 0x38, 0x7F}}, {x86.R0, x86.R15, 1, 0x7F, []byte{0x42, 0xC6, 0x04, 0x38, 0x7F}},
{x86.RCX, x86.R14, 8, 0x7F, []byte{0x4A, 0xC7, 0x04, 0x31, 0x7F, 0x00, 0x00, 0x00}}, {x86.R1, x86.R14, 8, 0x7F, []byte{0x4A, 0xC7, 0x04, 0x31, 0x7F, 0x00, 0x00, 0x00}},
{x86.RCX, x86.R14, 4, 0x7F, []byte{0x42, 0xC7, 0x04, 0x31, 0x7F, 0x00, 0x00, 0x00}}, {x86.R1, x86.R14, 4, 0x7F, []byte{0x42, 0xC7, 0x04, 0x31, 0x7F, 0x00, 0x00, 0x00}},
{x86.RCX, x86.R14, 2, 0x7F, []byte{0x66, 0x42, 0xC7, 0x04, 0x31, 0x7F, 0x00}}, {x86.R1, x86.R14, 2, 0x7F, []byte{0x66, 0x42, 0xC7, 0x04, 0x31, 0x7F, 0x00}},
{x86.RCX, x86.R14, 1, 0x7F, []byte{0x42, 0xC6, 0x04, 0x31, 0x7F}}, {x86.R1, x86.R14, 1, 0x7F, []byte{0x42, 0xC6, 0x04, 0x31, 0x7F}},
{x86.RDX, x86.R13, 8, 0x7F, []byte{0x4A, 0xC7, 0x04, 0x2A, 0x7F, 0x00, 0x00, 0x00}}, {x86.R2, x86.R13, 8, 0x7F, []byte{0x4A, 0xC7, 0x04, 0x2A, 0x7F, 0x00, 0x00, 0x00}},
{x86.RDX, x86.R13, 4, 0x7F, []byte{0x42, 0xC7, 0x04, 0x2A, 0x7F, 0x00, 0x00, 0x00}}, {x86.R2, x86.R13, 4, 0x7F, []byte{0x42, 0xC7, 0x04, 0x2A, 0x7F, 0x00, 0x00, 0x00}},
{x86.RDX, x86.R13, 2, 0x7F, []byte{0x66, 0x42, 0xC7, 0x04, 0x2A, 0x7F, 0x00}}, {x86.R2, x86.R13, 2, 0x7F, []byte{0x66, 0x42, 0xC7, 0x04, 0x2A, 0x7F, 0x00}},
{x86.RDX, x86.R13, 1, 0x7F, []byte{0x42, 0xC6, 0x04, 0x2A, 0x7F}}, {x86.R2, x86.R13, 1, 0x7F, []byte{0x42, 0xC6, 0x04, 0x2A, 0x7F}},
{x86.RBX, x86.R12, 8, 0x7F, []byte{0x4A, 0xC7, 0x04, 0x23, 0x7F, 0x00, 0x00, 0x00}}, {x86.R3, x86.R12, 8, 0x7F, []byte{0x4A, 0xC7, 0x04, 0x23, 0x7F, 0x00, 0x00, 0x00}},
{x86.RBX, x86.R12, 4, 0x7F, []byte{0x42, 0xC7, 0x04, 0x23, 0x7F, 0x00, 0x00, 0x00}}, {x86.R3, x86.R12, 4, 0x7F, []byte{0x42, 0xC7, 0x04, 0x23, 0x7F, 0x00, 0x00, 0x00}},
{x86.RBX, x86.R12, 2, 0x7F, []byte{0x66, 0x42, 0xC7, 0x04, 0x23, 0x7F, 0x00}}, {x86.R3, x86.R12, 2, 0x7F, []byte{0x66, 0x42, 0xC7, 0x04, 0x23, 0x7F, 0x00}},
{x86.RBX, x86.R12, 1, 0x7F, []byte{0x42, 0xC6, 0x04, 0x23, 0x7F}}, {x86.R3, x86.R12, 1, 0x7F, []byte{0x42, 0xC6, 0x04, 0x23, 0x7F}},
{x86.RSP, x86.R11, 8, 0x7F, []byte{0x4A, 0xC7, 0x04, 0x1C, 0x7F, 0x00, 0x00, 0x00}}, {x86.SP, x86.R11, 8, 0x7F, []byte{0x4A, 0xC7, 0x04, 0x1C, 0x7F, 0x00, 0x00, 0x00}},
{x86.RSP, x86.R11, 4, 0x7F, []byte{0x42, 0xC7, 0x04, 0x1C, 0x7F, 0x00, 0x00, 0x00}}, {x86.SP, x86.R11, 4, 0x7F, []byte{0x42, 0xC7, 0x04, 0x1C, 0x7F, 0x00, 0x00, 0x00}},
{x86.RSP, x86.R11, 2, 0x7F, []byte{0x66, 0x42, 0xC7, 0x04, 0x1C, 0x7F, 0x00}}, {x86.SP, x86.R11, 2, 0x7F, []byte{0x66, 0x42, 0xC7, 0x04, 0x1C, 0x7F, 0x00}},
{x86.RSP, x86.R11, 1, 0x7F, []byte{0x42, 0xC6, 0x04, 0x1C, 0x7F}}, {x86.SP, x86.R11, 1, 0x7F, []byte{0x42, 0xC6, 0x04, 0x1C, 0x7F}},
{x86.RBP, x86.R10, 8, 0x7F, []byte{0x4A, 0xC7, 0x44, 0x15, 0x00, 0x7F, 0x00, 0x00, 0x00}}, {x86.R5, x86.R10, 8, 0x7F, []byte{0x4A, 0xC7, 0x44, 0x15, 0x00, 0x7F, 0x00, 0x00, 0x00}},
{x86.RBP, x86.R10, 4, 0x7F, []byte{0x42, 0xC7, 0x44, 0x15, 0x00, 0x7F, 0x00, 0x00, 0x00}}, {x86.R5, x86.R10, 4, 0x7F, []byte{0x42, 0xC7, 0x44, 0x15, 0x00, 0x7F, 0x00, 0x00, 0x00}},
{x86.RBP, x86.R10, 2, 0x7F, []byte{0x66, 0x42, 0xC7, 0x44, 0x15, 0x00, 0x7F, 0x00}}, {x86.R5, x86.R10, 2, 0x7F, []byte{0x66, 0x42, 0xC7, 0x44, 0x15, 0x00, 0x7F, 0x00}},
{x86.RBP, x86.R10, 1, 0x7F, []byte{0x42, 0xC6, 0x44, 0x15, 0x00, 0x7F}}, {x86.R5, x86.R10, 1, 0x7F, []byte{0x42, 0xC6, 0x44, 0x15, 0x00, 0x7F}},
{x86.RSI, x86.R9, 8, 0x7F, []byte{0x4A, 0xC7, 0x04, 0x0E, 0x7F, 0x00, 0x00, 0x00}}, {x86.R6, x86.R9, 8, 0x7F, []byte{0x4A, 0xC7, 0x04, 0x0E, 0x7F, 0x00, 0x00, 0x00}},
{x86.RSI, x86.R9, 4, 0x7F, []byte{0x42, 0xC7, 0x04, 0x0E, 0x7F, 0x00, 0x00, 0x00}}, {x86.R6, x86.R9, 4, 0x7F, []byte{0x42, 0xC7, 0x04, 0x0E, 0x7F, 0x00, 0x00, 0x00}},
{x86.RSI, x86.R9, 2, 0x7F, []byte{0x66, 0x42, 0xC7, 0x04, 0x0E, 0x7F, 0x00}}, {x86.R6, x86.R9, 2, 0x7F, []byte{0x66, 0x42, 0xC7, 0x04, 0x0E, 0x7F, 0x00}},
{x86.RSI, x86.R9, 1, 0x7F, []byte{0x42, 0xC6, 0x04, 0x0E, 0x7F}}, {x86.R6, x86.R9, 1, 0x7F, []byte{0x42, 0xC6, 0x04, 0x0E, 0x7F}},
{x86.RDI, x86.R8, 8, 0x7F, []byte{0x4A, 0xC7, 0x04, 0x07, 0x7F, 0x00, 0x00, 0x00}}, {x86.R7, x86.R8, 8, 0x7F, []byte{0x4A, 0xC7, 0x04, 0x07, 0x7F, 0x00, 0x00, 0x00}},
{x86.RDI, x86.R8, 4, 0x7F, []byte{0x42, 0xC7, 0x04, 0x07, 0x7F, 0x00, 0x00, 0x00}}, {x86.R7, x86.R8, 4, 0x7F, []byte{0x42, 0xC7, 0x04, 0x07, 0x7F, 0x00, 0x00, 0x00}},
{x86.RDI, x86.R8, 2, 0x7F, []byte{0x66, 0x42, 0xC7, 0x04, 0x07, 0x7F, 0x00}}, {x86.R7, x86.R8, 2, 0x7F, []byte{0x66, 0x42, 0xC7, 0x04, 0x07, 0x7F, 0x00}},
{x86.RDI, x86.R8, 1, 0x7F, []byte{0x42, 0xC6, 0x04, 0x07, 0x7F}}, {x86.R7, x86.R8, 1, 0x7F, []byte{0x42, 0xC6, 0x04, 0x07, 0x7F}},
{x86.R8, x86.RDI, 8, 0x7F, []byte{0x49, 0xC7, 0x04, 0x38, 0x7F, 0x00, 0x00, 0x00}}, {x86.R8, x86.R7, 8, 0x7F, []byte{0x49, 0xC7, 0x04, 0x38, 0x7F, 0x00, 0x00, 0x00}},
{x86.R8, x86.RDI, 4, 0x7F, []byte{0x41, 0xC7, 0x04, 0x38, 0x7F, 0x00, 0x00, 0x00}}, {x86.R8, x86.R7, 4, 0x7F, []byte{0x41, 0xC7, 0x04, 0x38, 0x7F, 0x00, 0x00, 0x00}},
{x86.R8, x86.RDI, 2, 0x7F, []byte{0x66, 0x41, 0xC7, 0x04, 0x38, 0x7F, 0x00}}, {x86.R8, x86.R7, 2, 0x7F, []byte{0x66, 0x41, 0xC7, 0x04, 0x38, 0x7F, 0x00}},
{x86.R8, x86.RDI, 1, 0x7F, []byte{0x41, 0xC6, 0x04, 0x38, 0x7F}}, {x86.R8, x86.R7, 1, 0x7F, []byte{0x41, 0xC6, 0x04, 0x38, 0x7F}},
{x86.R9, x86.RSI, 8, 0x7F, []byte{0x49, 0xC7, 0x04, 0x31, 0x7F, 0x00, 0x00, 0x00}}, {x86.R9, x86.R6, 8, 0x7F, []byte{0x49, 0xC7, 0x04, 0x31, 0x7F, 0x00, 0x00, 0x00}},
{x86.R9, x86.RSI, 4, 0x7F, []byte{0x41, 0xC7, 0x04, 0x31, 0x7F, 0x00, 0x00, 0x00}}, {x86.R9, x86.R6, 4, 0x7F, []byte{0x41, 0xC7, 0x04, 0x31, 0x7F, 0x00, 0x00, 0x00}},
{x86.R9, x86.RSI, 2, 0x7F, []byte{0x66, 0x41, 0xC7, 0x04, 0x31, 0x7F, 0x00}}, {x86.R9, x86.R6, 2, 0x7F, []byte{0x66, 0x41, 0xC7, 0x04, 0x31, 0x7F, 0x00}},
{x86.R9, x86.RSI, 1, 0x7F, []byte{0x41, 0xC6, 0x04, 0x31, 0x7F}}, {x86.R9, x86.R6, 1, 0x7F, []byte{0x41, 0xC6, 0x04, 0x31, 0x7F}},
{x86.R10, x86.RBP, 8, 0x7F, []byte{0x49, 0xC7, 0x04, 0x2A, 0x7F, 0x00, 0x00, 0x00}}, {x86.R10, x86.R5, 8, 0x7F, []byte{0x49, 0xC7, 0x04, 0x2A, 0x7F, 0x00, 0x00, 0x00}},
{x86.R10, x86.RBP, 4, 0x7F, []byte{0x41, 0xC7, 0x04, 0x2A, 0x7F, 0x00, 0x00, 0x00}}, {x86.R10, x86.R5, 4, 0x7F, []byte{0x41, 0xC7, 0x04, 0x2A, 0x7F, 0x00, 0x00, 0x00}},
{x86.R10, x86.RBP, 2, 0x7F, []byte{0x66, 0x41, 0xC7, 0x04, 0x2A, 0x7F, 0x00}}, {x86.R10, x86.R5, 2, 0x7F, []byte{0x66, 0x41, 0xC7, 0x04, 0x2A, 0x7F, 0x00}},
{x86.R10, x86.RBP, 1, 0x7F, []byte{0x41, 0xC6, 0x04, 0x2A, 0x7F}}, {x86.R10, x86.R5, 1, 0x7F, []byte{0x41, 0xC6, 0x04, 0x2A, 0x7F}},
{x86.R11, x86.RSP, 8, 0x7F, []byte{0x4A, 0xC7, 0x04, 0x1C, 0x7F, 0x00, 0x00, 0x00}}, {x86.R11, x86.SP, 8, 0x7F, []byte{0x4A, 0xC7, 0x04, 0x1C, 0x7F, 0x00, 0x00, 0x00}},
{x86.R11, x86.RSP, 4, 0x7F, []byte{0x42, 0xC7, 0x04, 0x1C, 0x7F, 0x00, 0x00, 0x00}}, {x86.R11, x86.SP, 4, 0x7F, []byte{0x42, 0xC7, 0x04, 0x1C, 0x7F, 0x00, 0x00, 0x00}},
{x86.R11, x86.RSP, 2, 0x7F, []byte{0x66, 0x42, 0xC7, 0x04, 0x1C, 0x7F, 0x00}}, {x86.R11, x86.SP, 2, 0x7F, []byte{0x66, 0x42, 0xC7, 0x04, 0x1C, 0x7F, 0x00}},
{x86.R11, x86.RSP, 1, 0x7F, []byte{0x42, 0xC6, 0x04, 0x1C, 0x7F}}, {x86.R11, x86.SP, 1, 0x7F, []byte{0x42, 0xC6, 0x04, 0x1C, 0x7F}},
{x86.R12, x86.RBX, 8, 0x7F, []byte{0x49, 0xC7, 0x04, 0x1C, 0x7F, 0x00, 0x00, 0x00}}, {x86.R12, x86.R3, 8, 0x7F, []byte{0x49, 0xC7, 0x04, 0x1C, 0x7F, 0x00, 0x00, 0x00}},
{x86.R12, x86.RBX, 4, 0x7F, []byte{0x41, 0xC7, 0x04, 0x1C, 0x7F, 0x00, 0x00, 0x00}}, {x86.R12, x86.R3, 4, 0x7F, []byte{0x41, 0xC7, 0x04, 0x1C, 0x7F, 0x00, 0x00, 0x00}},
{x86.R12, x86.RBX, 2, 0x7F, []byte{0x66, 0x41, 0xC7, 0x04, 0x1C, 0x7F, 0x00}}, {x86.R12, x86.R3, 2, 0x7F, []byte{0x66, 0x41, 0xC7, 0x04, 0x1C, 0x7F, 0x00}},
{x86.R12, x86.RBX, 1, 0x7F, []byte{0x41, 0xC6, 0x04, 0x1C, 0x7F}}, {x86.R12, x86.R3, 1, 0x7F, []byte{0x41, 0xC6, 0x04, 0x1C, 0x7F}},
{x86.R13, x86.RDX, 8, 0x7F, []byte{0x49, 0xC7, 0x44, 0x15, 0x00, 0x7F, 0x00, 0x00, 0x00}}, {x86.R13, x86.R2, 8, 0x7F, []byte{0x49, 0xC7, 0x44, 0x15, 0x00, 0x7F, 0x00, 0x00, 0x00}},
{x86.R13, x86.RDX, 4, 0x7F, []byte{0x41, 0xC7, 0x44, 0x15, 0x00, 0x7F, 0x00, 0x00, 0x00}}, {x86.R13, x86.R2, 4, 0x7F, []byte{0x41, 0xC7, 0x44, 0x15, 0x00, 0x7F, 0x00, 0x00, 0x00}},
{x86.R13, x86.RDX, 2, 0x7F, []byte{0x66, 0x41, 0xC7, 0x44, 0x15, 0x00, 0x7F, 0x00}}, {x86.R13, x86.R2, 2, 0x7F, []byte{0x66, 0x41, 0xC7, 0x44, 0x15, 0x00, 0x7F, 0x00}},
{x86.R13, x86.RDX, 1, 0x7F, []byte{0x41, 0xC6, 0x44, 0x15, 0x00, 0x7F}}, {x86.R13, x86.R2, 1, 0x7F, []byte{0x41, 0xC6, 0x44, 0x15, 0x00, 0x7F}},
{x86.R14, x86.RCX, 8, 0x7F, []byte{0x49, 0xC7, 0x04, 0x0E, 0x7F, 0x00, 0x00, 0x00}}, {x86.R14, x86.R1, 8, 0x7F, []byte{0x49, 0xC7, 0x04, 0x0E, 0x7F, 0x00, 0x00, 0x00}},
{x86.R14, x86.RCX, 4, 0x7F, []byte{0x41, 0xC7, 0x04, 0x0E, 0x7F, 0x00, 0x00, 0x00}}, {x86.R14, x86.R1, 4, 0x7F, []byte{0x41, 0xC7, 0x04, 0x0E, 0x7F, 0x00, 0x00, 0x00}},
{x86.R14, x86.RCX, 2, 0x7F, []byte{0x66, 0x41, 0xC7, 0x04, 0x0E, 0x7F, 0x00}}, {x86.R14, x86.R1, 2, 0x7F, []byte{0x66, 0x41, 0xC7, 0x04, 0x0E, 0x7F, 0x00}},
{x86.R14, x86.RCX, 1, 0x7F, []byte{0x41, 0xC6, 0x04, 0x0E, 0x7F}}, {x86.R14, x86.R1, 1, 0x7F, []byte{0x41, 0xC6, 0x04, 0x0E, 0x7F}},
{x86.R15, x86.RAX, 8, 0x7F, []byte{0x49, 0xC7, 0x04, 0x07, 0x7F, 0x00, 0x00, 0x00}}, {x86.R15, x86.R0, 8, 0x7F, []byte{0x49, 0xC7, 0x04, 0x07, 0x7F, 0x00, 0x00, 0x00}},
{x86.R15, x86.RAX, 4, 0x7F, []byte{0x41, 0xC7, 0x04, 0x07, 0x7F, 0x00, 0x00, 0x00}}, {x86.R15, x86.R0, 4, 0x7F, []byte{0x41, 0xC7, 0x04, 0x07, 0x7F, 0x00, 0x00, 0x00}},
{x86.R15, x86.RAX, 2, 0x7F, []byte{0x66, 0x41, 0xC7, 0x04, 0x07, 0x7F, 0x00}}, {x86.R15, x86.R0, 2, 0x7F, []byte{0x66, 0x41, 0xC7, 0x04, 0x07, 0x7F, 0x00}},
{x86.R15, x86.RAX, 1, 0x7F, []byte{0x41, 0xC6, 0x04, 0x07, 0x7F}}, {x86.R15, x86.R0, 1, 0x7F, []byte{0x41, 0xC6, 0x04, 0x07, 0x7F}},
} }
for _, pattern := range usagePatterns { for _, pattern := range usagePatterns {
@ -97,70 +97,70 @@ func TestStoreDynamicRegister(t *testing.T) {
RegisterFrom cpu.Register RegisterFrom cpu.Register
Code []byte Code []byte
}{ }{
{x86.RAX, x86.R15, 8, x86.R15, []byte{0x4E, 0x89, 0x3C, 0x38}}, {x86.R0, x86.R15, 8, x86.R15, []byte{0x4E, 0x89, 0x3C, 0x38}},
{x86.RAX, x86.R15, 4, x86.R15, []byte{0x46, 0x89, 0x3C, 0x38}}, {x86.R0, x86.R15, 4, x86.R15, []byte{0x46, 0x89, 0x3C, 0x38}},
{x86.RAX, x86.R15, 2, x86.R15, []byte{0x66, 0x46, 0x89, 0x3C, 0x38}}, {x86.R0, x86.R15, 2, x86.R15, []byte{0x66, 0x46, 0x89, 0x3C, 0x38}},
{x86.RAX, x86.R15, 1, x86.R15, []byte{0x46, 0x88, 0x3C, 0x38}}, {x86.R0, x86.R15, 1, x86.R15, []byte{0x46, 0x88, 0x3C, 0x38}},
{x86.RCX, x86.R14, 8, x86.R14, []byte{0x4E, 0x89, 0x34, 0x31}}, {x86.R1, x86.R14, 8, x86.R14, []byte{0x4E, 0x89, 0x34, 0x31}},
{x86.RCX, x86.R14, 4, x86.R14, []byte{0x46, 0x89, 0x34, 0x31}}, {x86.R1, x86.R14, 4, x86.R14, []byte{0x46, 0x89, 0x34, 0x31}},
{x86.RCX, x86.R14, 2, x86.R14, []byte{0x66, 0x46, 0x89, 0x34, 0x31}}, {x86.R1, x86.R14, 2, x86.R14, []byte{0x66, 0x46, 0x89, 0x34, 0x31}},
{x86.RCX, x86.R14, 1, x86.R14, []byte{0x46, 0x88, 0x34, 0x31}}, {x86.R1, x86.R14, 1, x86.R14, []byte{0x46, 0x88, 0x34, 0x31}},
{x86.RDX, x86.R13, 8, x86.R13, []byte{0x4E, 0x89, 0x2C, 0x2A}}, {x86.R2, x86.R13, 8, x86.R13, []byte{0x4E, 0x89, 0x2C, 0x2A}},
{x86.RDX, x86.R13, 4, x86.R13, []byte{0x46, 0x89, 0x2C, 0x2A}}, {x86.R2, x86.R13, 4, x86.R13, []byte{0x46, 0x89, 0x2C, 0x2A}},
{x86.RDX, x86.R13, 2, x86.R13, []byte{0x66, 0x46, 0x89, 0x2C, 0x2A}}, {x86.R2, x86.R13, 2, x86.R13, []byte{0x66, 0x46, 0x89, 0x2C, 0x2A}},
{x86.RDX, x86.R13, 1, x86.R13, []byte{0x46, 0x88, 0x2C, 0x2A}}, {x86.R2, x86.R13, 1, x86.R13, []byte{0x46, 0x88, 0x2C, 0x2A}},
{x86.RBX, x86.R12, 8, x86.R12, []byte{0x4E, 0x89, 0x24, 0x23}}, {x86.R3, x86.R12, 8, x86.R12, []byte{0x4E, 0x89, 0x24, 0x23}},
{x86.RBX, x86.R12, 4, x86.R12, []byte{0x46, 0x89, 0x24, 0x23}}, {x86.R3, x86.R12, 4, x86.R12, []byte{0x46, 0x89, 0x24, 0x23}},
{x86.RBX, x86.R12, 2, x86.R12, []byte{0x66, 0x46, 0x89, 0x24, 0x23}}, {x86.R3, x86.R12, 2, x86.R12, []byte{0x66, 0x46, 0x89, 0x24, 0x23}},
{x86.RBX, x86.R12, 1, x86.R12, []byte{0x46, 0x88, 0x24, 0x23}}, {x86.R3, x86.R12, 1, x86.R12, []byte{0x46, 0x88, 0x24, 0x23}},
{x86.RSP, x86.R11, 8, x86.R11, []byte{0x4E, 0x89, 0x1C, 0x1C}}, {x86.SP, x86.R11, 8, x86.R11, []byte{0x4E, 0x89, 0x1C, 0x1C}},
{x86.RSP, x86.R11, 4, x86.R11, []byte{0x46, 0x89, 0x1C, 0x1C}}, {x86.SP, x86.R11, 4, x86.R11, []byte{0x46, 0x89, 0x1C, 0x1C}},
{x86.RSP, x86.R11, 2, x86.R11, []byte{0x66, 0x46, 0x89, 0x1C, 0x1C}}, {x86.SP, x86.R11, 2, x86.R11, []byte{0x66, 0x46, 0x89, 0x1C, 0x1C}},
{x86.RSP, x86.R11, 1, x86.R11, []byte{0x46, 0x88, 0x1C, 0x1C}}, {x86.SP, x86.R11, 1, x86.R11, []byte{0x46, 0x88, 0x1C, 0x1C}},
{x86.RBP, x86.R10, 8, x86.R10, []byte{0x4E, 0x89, 0x54, 0x15, 0x00}}, {x86.R5, x86.R10, 8, x86.R10, []byte{0x4E, 0x89, 0x54, 0x15, 0x00}},
{x86.RBP, x86.R10, 4, x86.R10, []byte{0x46, 0x89, 0x54, 0x15, 0x00}}, {x86.R5, x86.R10, 4, x86.R10, []byte{0x46, 0x89, 0x54, 0x15, 0x00}},
{x86.RBP, x86.R10, 2, x86.R10, []byte{0x66, 0x46, 0x89, 0x54, 0x15, 0x00}}, {x86.R5, x86.R10, 2, x86.R10, []byte{0x66, 0x46, 0x89, 0x54, 0x15, 0x00}},
{x86.RBP, x86.R10, 1, x86.R10, []byte{0x46, 0x88, 0x54, 0x15, 0x00}}, {x86.R5, x86.R10, 1, x86.R10, []byte{0x46, 0x88, 0x54, 0x15, 0x00}},
{x86.RSI, x86.R9, 8, x86.R9, []byte{0x4E, 0x89, 0x0C, 0x0E}}, {x86.R6, x86.R9, 8, x86.R9, []byte{0x4E, 0x89, 0x0C, 0x0E}},
{x86.RSI, x86.R9, 4, x86.R9, []byte{0x46, 0x89, 0x0C, 0x0E}}, {x86.R6, x86.R9, 4, x86.R9, []byte{0x46, 0x89, 0x0C, 0x0E}},
{x86.RSI, x86.R9, 2, x86.R9, []byte{0x66, 0x46, 0x89, 0x0C, 0x0E}}, {x86.R6, x86.R9, 2, x86.R9, []byte{0x66, 0x46, 0x89, 0x0C, 0x0E}},
{x86.RSI, x86.R9, 1, x86.R9, []byte{0x46, 0x88, 0x0C, 0x0E}}, {x86.R6, x86.R9, 1, x86.R9, []byte{0x46, 0x88, 0x0C, 0x0E}},
{x86.RDI, x86.R8, 8, x86.R8, []byte{0x4E, 0x89, 0x04, 0x07}}, {x86.R7, x86.R8, 8, x86.R8, []byte{0x4E, 0x89, 0x04, 0x07}},
{x86.RDI, x86.R8, 4, x86.R8, []byte{0x46, 0x89, 0x04, 0x07}}, {x86.R7, x86.R8, 4, x86.R8, []byte{0x46, 0x89, 0x04, 0x07}},
{x86.RDI, x86.R8, 2, x86.R8, []byte{0x66, 0x46, 0x89, 0x04, 0x07}}, {x86.R7, x86.R8, 2, x86.R8, []byte{0x66, 0x46, 0x89, 0x04, 0x07}},
{x86.RDI, x86.R8, 1, x86.R8, []byte{0x46, 0x88, 0x04, 0x07}}, {x86.R7, x86.R8, 1, x86.R8, []byte{0x46, 0x88, 0x04, 0x07}},
{x86.R8, x86.RDI, 8, x86.RDI, []byte{0x49, 0x89, 0x3C, 0x38}}, {x86.R8, x86.R7, 8, x86.R7, []byte{0x49, 0x89, 0x3C, 0x38}},
{x86.R8, x86.RDI, 4, x86.RDI, []byte{0x41, 0x89, 0x3C, 0x38}}, {x86.R8, x86.R7, 4, x86.R7, []byte{0x41, 0x89, 0x3C, 0x38}},
{x86.R8, x86.RDI, 2, x86.RDI, []byte{0x66, 0x41, 0x89, 0x3C, 0x38}}, {x86.R8, x86.R7, 2, x86.R7, []byte{0x66, 0x41, 0x89, 0x3C, 0x38}},
{x86.R8, x86.RDI, 1, x86.RDI, []byte{0x41, 0x88, 0x3C, 0x38}}, {x86.R8, x86.R7, 1, x86.R7, []byte{0x41, 0x88, 0x3C, 0x38}},
{x86.R9, x86.RSI, 8, x86.RSI, []byte{0x49, 0x89, 0x34, 0x31}}, {x86.R9, x86.R6, 8, x86.R6, []byte{0x49, 0x89, 0x34, 0x31}},
{x86.R9, x86.RSI, 4, x86.RSI, []byte{0x41, 0x89, 0x34, 0x31}}, {x86.R9, x86.R6, 4, x86.R6, []byte{0x41, 0x89, 0x34, 0x31}},
{x86.R9, x86.RSI, 2, x86.RSI, []byte{0x66, 0x41, 0x89, 0x34, 0x31}}, {x86.R9, x86.R6, 2, x86.R6, []byte{0x66, 0x41, 0x89, 0x34, 0x31}},
{x86.R9, x86.RSI, 1, x86.RSI, []byte{0x41, 0x88, 0x34, 0x31}}, {x86.R9, x86.R6, 1, x86.R6, []byte{0x41, 0x88, 0x34, 0x31}},
{x86.R10, x86.RBP, 8, x86.RBP, []byte{0x49, 0x89, 0x2C, 0x2A}}, {x86.R10, x86.R5, 8, x86.R5, []byte{0x49, 0x89, 0x2C, 0x2A}},
{x86.R10, x86.RBP, 4, x86.RBP, []byte{0x41, 0x89, 0x2C, 0x2A}}, {x86.R10, x86.R5, 4, x86.R5, []byte{0x41, 0x89, 0x2C, 0x2A}},
{x86.R10, x86.RBP, 2, x86.RBP, []byte{0x66, 0x41, 0x89, 0x2C, 0x2A}}, {x86.R10, x86.R5, 2, x86.R5, []byte{0x66, 0x41, 0x89, 0x2C, 0x2A}},
{x86.R10, x86.RBP, 1, x86.RBP, []byte{0x41, 0x88, 0x2C, 0x2A}}, {x86.R10, x86.R5, 1, x86.R5, []byte{0x41, 0x88, 0x2C, 0x2A}},
{x86.R11, x86.RSP, 8, x86.RSP, []byte{0x4A, 0x89, 0x24, 0x1C}}, {x86.R11, x86.SP, 8, x86.SP, []byte{0x4A, 0x89, 0x24, 0x1C}},
{x86.R11, x86.RSP, 4, x86.RSP, []byte{0x42, 0x89, 0x24, 0x1C}}, {x86.R11, x86.SP, 4, x86.SP, []byte{0x42, 0x89, 0x24, 0x1C}},
{x86.R11, x86.RSP, 2, x86.RSP, []byte{0x66, 0x42, 0x89, 0x24, 0x1C}}, {x86.R11, x86.SP, 2, x86.SP, []byte{0x66, 0x42, 0x89, 0x24, 0x1C}},
{x86.R11, x86.RSP, 1, x86.RSP, []byte{0x42, 0x88, 0x24, 0x1C}}, {x86.R11, x86.SP, 1, x86.SP, []byte{0x42, 0x88, 0x24, 0x1C}},
{x86.R12, x86.RBX, 8, x86.RBX, []byte{0x49, 0x89, 0x1C, 0x1C}}, {x86.R12, x86.R3, 8, x86.R3, []byte{0x49, 0x89, 0x1C, 0x1C}},
{x86.R12, x86.RBX, 4, x86.RBX, []byte{0x41, 0x89, 0x1C, 0x1C}}, {x86.R12, x86.R3, 4, x86.R3, []byte{0x41, 0x89, 0x1C, 0x1C}},
{x86.R12, x86.RBX, 2, x86.RBX, []byte{0x66, 0x41, 0x89, 0x1C, 0x1C}}, {x86.R12, x86.R3, 2, x86.R3, []byte{0x66, 0x41, 0x89, 0x1C, 0x1C}},
{x86.R12, x86.RBX, 1, x86.RBX, []byte{0x41, 0x88, 0x1C, 0x1C}}, {x86.R12, x86.R3, 1, x86.R3, []byte{0x41, 0x88, 0x1C, 0x1C}},
{x86.R13, x86.RDX, 8, x86.RDX, []byte{0x49, 0x89, 0x54, 0x15, 0x00}}, {x86.R13, x86.R2, 8, x86.R2, []byte{0x49, 0x89, 0x54, 0x15, 0x00}},
{x86.R13, x86.RDX, 4, x86.RDX, []byte{0x41, 0x89, 0x54, 0x15, 0x00}}, {x86.R13, x86.R2, 4, x86.R2, []byte{0x41, 0x89, 0x54, 0x15, 0x00}},
{x86.R13, x86.RDX, 2, x86.RDX, []byte{0x66, 0x41, 0x89, 0x54, 0x15, 0x00}}, {x86.R13, x86.R2, 2, x86.R2, []byte{0x66, 0x41, 0x89, 0x54, 0x15, 0x00}},
{x86.R13, x86.RDX, 1, x86.RDX, []byte{0x41, 0x88, 0x54, 0x15, 0x00}}, {x86.R13, x86.R2, 1, x86.R2, []byte{0x41, 0x88, 0x54, 0x15, 0x00}},
{x86.R14, x86.RCX, 8, x86.RCX, []byte{0x49, 0x89, 0x0C, 0x0E}}, {x86.R14, x86.R1, 8, x86.R1, []byte{0x49, 0x89, 0x0C, 0x0E}},
{x86.R14, x86.RCX, 4, x86.RCX, []byte{0x41, 0x89, 0x0C, 0x0E}}, {x86.R14, x86.R1, 4, x86.R1, []byte{0x41, 0x89, 0x0C, 0x0E}},
{x86.R14, x86.RCX, 2, x86.RCX, []byte{0x66, 0x41, 0x89, 0x0C, 0x0E}}, {x86.R14, x86.R1, 2, x86.R1, []byte{0x66, 0x41, 0x89, 0x0C, 0x0E}},
{x86.R14, x86.RCX, 1, x86.RCX, []byte{0x41, 0x88, 0x0C, 0x0E}}, {x86.R14, x86.R1, 1, x86.R1, []byte{0x41, 0x88, 0x0C, 0x0E}},
{x86.R15, x86.RAX, 8, x86.RAX, []byte{0x49, 0x89, 0x04, 0x07}}, {x86.R15, x86.R0, 8, x86.R0, []byte{0x49, 0x89, 0x04, 0x07}},
{x86.R15, x86.RAX, 4, x86.RAX, []byte{0x41, 0x89, 0x04, 0x07}}, {x86.R15, x86.R0, 4, x86.R0, []byte{0x41, 0x89, 0x04, 0x07}},
{x86.R15, x86.RAX, 2, x86.RAX, []byte{0x66, 0x41, 0x89, 0x04, 0x07}}, {x86.R15, x86.R0, 2, x86.R0, []byte{0x66, 0x41, 0x89, 0x04, 0x07}},
{x86.R15, x86.RAX, 1, x86.RAX, []byte{0x41, 0x88, 0x04, 0x07}}, {x86.R15, x86.R0, 1, x86.R0, []byte{0x41, 0x88, 0x04, 0x07}},
} }
for _, pattern := range usagePatterns { for _, pattern := range usagePatterns {

384
src/x86/Store_test.go
View File

@ -17,38 +17,38 @@ func TestStoreNumber(t *testing.T) {
Code []byte Code []byte
}{ }{
// No offset // No offset
{x86.RAX, 0, 8, 0x7F, []byte{0x48, 0xC7, 0x00, 0x7F, 0x00, 0x00, 0x00}}, {x86.R0, 0, 8, 0x7F, []byte{0x48, 0xC7, 0x00, 0x7F, 0x00, 0x00, 0x00}},
{x86.RAX, 0, 4, 0x7F, []byte{0xC7, 0x00, 0x7F, 0x00, 0x00, 0x00}}, {x86.R0, 0, 4, 0x7F, []byte{0xC7, 0x00, 0x7F, 0x00, 0x00, 0x00}},
{x86.RAX, 0, 2, 0x7F, []byte{0x66, 0xC7, 0x00, 0x7F, 0x00}}, {x86.R0, 0, 2, 0x7F, []byte{0x66, 0xC7, 0x00, 0x7F, 0x00}},
{x86.RAX, 0, 1, 0x7F, []byte{0xC6, 0x00, 0x7F}}, {x86.R0, 0, 1, 0x7F, []byte{0xC6, 0x00, 0x7F}},
{x86.RCX, 0, 8, 0x7F, []byte{0x48, 0xC7, 0x01, 0x7F, 0x00, 0x00, 0x00}}, {x86.R1, 0, 8, 0x7F, []byte{0x48, 0xC7, 0x01, 0x7F, 0x00, 0x00, 0x00}},
{x86.RCX, 0, 4, 0x7F, []byte{0xC7, 0x01, 0x7F, 0x00, 0x00, 0x00}}, {x86.R1, 0, 4, 0x7F, []byte{0xC7, 0x01, 0x7F, 0x00, 0x00, 0x00}},
{x86.RCX, 0, 2, 0x7F, []byte{0x66, 0xC7, 0x01, 0x7F, 0x00}}, {x86.R1, 0, 2, 0x7F, []byte{0x66, 0xC7, 0x01, 0x7F, 0x00}},
{x86.RCX, 0, 1, 0x7F, []byte{0xC6, 0x01, 0x7F}}, {x86.R1, 0, 1, 0x7F, []byte{0xC6, 0x01, 0x7F}},
{x86.RDX, 0, 8, 0x7F, []byte{0x48, 0xC7, 0x02, 0x7F, 0x00, 0x00, 0x00}}, {x86.R2, 0, 8, 0x7F, []byte{0x48, 0xC7, 0x02, 0x7F, 0x00, 0x00, 0x00}},
{x86.RDX, 0, 4, 0x7F, []byte{0xC7, 0x02, 0x7F, 0x00, 0x00, 0x00}}, {x86.R2, 0, 4, 0x7F, []byte{0xC7, 0x02, 0x7F, 0x00, 0x00, 0x00}},
{x86.RDX, 0, 2, 0x7F, []byte{0x66, 0xC7, 0x02, 0x7F, 0x00}}, {x86.R2, 0, 2, 0x7F, []byte{0x66, 0xC7, 0x02, 0x7F, 0x00}},
{x86.RDX, 0, 1, 0x7F, []byte{0xC6, 0x02, 0x7F}}, {x86.R2, 0, 1, 0x7F, []byte{0xC6, 0x02, 0x7F}},
{x86.RBX, 0, 8, 0x7F, []byte{0x48, 0xC7, 0x03, 0x7F, 0x00, 0x00, 0x00}}, {x86.R3, 0, 8, 0x7F, []byte{0x48, 0xC7, 0x03, 0x7F, 0x00, 0x00, 0x00}},
{x86.RBX, 0, 4, 0x7F, []byte{0xC7, 0x03, 0x7F, 0x00, 0x00, 0x00}}, {x86.R3, 0, 4, 0x7F, []byte{0xC7, 0x03, 0x7F, 0x00, 0x00, 0x00}},
{x86.RBX, 0, 2, 0x7F, []byte{0x66, 0xC7, 0x03, 0x7F, 0x00}}, {x86.R3, 0, 2, 0x7F, []byte{0x66, 0xC7, 0x03, 0x7F, 0x00}},
{x86.RBX, 0, 1, 0x7F, []byte{0xC6, 0x03, 0x7F}}, {x86.R3, 0, 1, 0x7F, []byte{0xC6, 0x03, 0x7F}},
{x86.RSP, 0, 8, 0x7F, []byte{0x48, 0xC7, 0x04, 0x24, 0x7F, 0x00, 0x00, 0x00}}, {x86.SP, 0, 8, 0x7F, []byte{0x48, 0xC7, 0x04, 0x24, 0x7F, 0x00, 0x00, 0x00}},
{x86.RSP, 0, 4, 0x7F, []byte{0xC7, 0x04, 0x24, 0x7F, 0x00, 0x00, 0x00}}, {x86.SP, 0, 4, 0x7F, []byte{0xC7, 0x04, 0x24, 0x7F, 0x00, 0x00, 0x00}},
{x86.RSP, 0, 2, 0x7F, []byte{0x66, 0xC7, 0x04, 0x24, 0x7F, 0x00}}, {x86.SP, 0, 2, 0x7F, []byte{0x66, 0xC7, 0x04, 0x24, 0x7F, 0x00}},
{x86.RSP, 0, 1, 0x7F, []byte{0xC6, 0x04, 0x24, 0x7F}}, {x86.SP, 0, 1, 0x7F, []byte{0xC6, 0x04, 0x24, 0x7F}},
{x86.RBP, 0, 8, 0x7F, []byte{0x48, 0xC7, 0x45, 0x00, 0x7F, 0x00, 0x00, 0x00}}, {x86.R5, 0, 8, 0x7F, []byte{0x48, 0xC7, 0x45, 0x00, 0x7F, 0x00, 0x00, 0x00}},
{x86.RBP, 0, 4, 0x7F, []byte{0xC7, 0x45, 0x00, 0x7F, 0x00, 0x00, 0x00}}, {x86.R5, 0, 4, 0x7F, []byte{0xC7, 0x45, 0x00, 0x7F, 0x00, 0x00, 0x00}},
{x86.RBP, 0, 2, 0x7F, []byte{0x66, 0xC7, 0x45, 0x00, 0x7F, 0x00}}, {x86.R5, 0, 2, 0x7F, []byte{0x66, 0xC7, 0x45, 0x00, 0x7F, 0x00}},
{x86.RBP, 0, 1, 0x7F, []byte{0xC6, 0x45, 0x00, 0x7F}}, {x86.R5, 0, 1, 0x7F, []byte{0xC6, 0x45, 0x00, 0x7F}},
{x86.RSI, 0, 8, 0x7F, []byte{0x48, 0xC7, 0x06, 0x7F, 0x00, 0x00, 0x00}}, {x86.R6, 0, 8, 0x7F, []byte{0x48, 0xC7, 0x06, 0x7F, 0x00, 0x00, 0x00}},
{x86.RSI, 0, 4, 0x7F, []byte{0xC7, 0x06, 0x7F, 0x00, 0x00, 0x00}}, {x86.R6, 0, 4, 0x7F, []byte{0xC7, 0x06, 0x7F, 0x00, 0x00, 0x00}},
{x86.RSI, 0, 2, 0x7F, []byte{0x66, 0xC7, 0x06, 0x7F, 0x00}}, {x86.R6, 0, 2, 0x7F, []byte{0x66, 0xC7, 0x06, 0x7F, 0x00}},
{x86.RSI, 0, 1, 0x7F, []byte{0xC6, 0x06, 0x7F}}, {x86.R6, 0, 1, 0x7F, []byte{0xC6, 0x06, 0x7F}},
{x86.RDI, 0, 8, 0x7F, []byte{0x48, 0xC7, 0x07, 0x7F, 0x00, 0x00, 0x00}}, {x86.R7, 0, 8, 0x7F, []byte{0x48, 0xC7, 0x07, 0x7F, 0x00, 0x00, 0x00}},
{x86.RDI, 0, 4, 0x7F, []byte{0xC7, 0x07, 0x7F, 0x00, 0x00, 0x00}}, {x86.R7, 0, 4, 0x7F, []byte{0xC7, 0x07, 0x7F, 0x00, 0x00, 0x00}},
{x86.RDI, 0, 2, 0x7F, []byte{0x66, 0xC7, 0x07, 0x7F, 0x00}}, {x86.R7, 0, 2, 0x7F, []byte{0x66, 0xC7, 0x07, 0x7F, 0x00}},
{x86.RDI, 0, 1, 0x7F, []byte{0xC6, 0x07, 0x7F}}, {x86.R7, 0, 1, 0x7F, []byte{0xC6, 0x07, 0x7F}},
{x86.R8, 0, 8, 0x7F, []byte{0x49, 0xC7, 0x00, 0x7F, 0x00, 0x00, 0x00}}, {x86.R8, 0, 8, 0x7F, []byte{0x49, 0xC7, 0x00, 0x7F, 0x00, 0x00, 0x00}},
{x86.R8, 0, 4, 0x7F, []byte{0x41, 0xC7, 0x00, 0x7F, 0x00, 0x00, 0x00}}, {x86.R8, 0, 4, 0x7F, []byte{0x41, 0xC7, 0x00, 0x7F, 0x00, 0x00, 0x00}},
{x86.R8, 0, 2, 0x7F, []byte{0x66, 0x41, 0xC7, 0x00, 0x7F, 0x00}}, {x86.R8, 0, 2, 0x7F, []byte{0x66, 0x41, 0xC7, 0x00, 0x7F, 0x00}},
@ -83,38 +83,38 @@ func TestStoreNumber(t *testing.T) {
{x86.R15, 0, 1, 0x7F, []byte{0x41, 0xC6, 0x07, 0x7F}}, {x86.R15, 0, 1, 0x7F, []byte{0x41, 0xC6, 0x07, 0x7F}},
// Offset of 1 // Offset of 1
{x86.RAX, 1, 8, 0x7F, []byte{0x48, 0xC7, 0x40, 0x01, 0x7F, 0x00, 0x00, 0x00}}, {x86.R0, 1, 8, 0x7F, []byte{0x48, 0xC7, 0x40, 0x01, 0x7F, 0x00, 0x00, 0x00}},
{x86.RAX, 1, 4, 0x7F, []byte{0xC7, 0x40, 0x01, 0x7F, 0x00, 0x00, 0x00}}, {x86.R0, 1, 4, 0x7F, []byte{0xC7, 0x40, 0x01, 0x7F, 0x00, 0x00, 0x00}},
{x86.RAX, 1, 2, 0x7F, []byte{0x66, 0xC7, 0x40, 0x01, 0x7F, 0x00}}, {x86.R0, 1, 2, 0x7F, []byte{0x66, 0xC7, 0x40, 0x01, 0x7F, 0x00}},
{x86.RAX, 1, 1, 0x7F, []byte{0xC6, 0x40, 0x01, 0x7F}}, {x86.R0, 1, 1, 0x7F, []byte{0xC6, 0x40, 0x01, 0x7F}},
{x86.RCX, 1, 8, 0x7F, []byte{0x48, 0xC7, 0x41, 0x01, 0x7F, 0x00, 0x00, 0x00}}, {x86.R1, 1, 8, 0x7F, []byte{0x48, 0xC7, 0x41, 0x01, 0x7F, 0x00, 0x00, 0x00}},
{x86.RCX, 1, 4, 0x7F, []byte{0xC7, 0x41, 0x01, 0x7F, 0x00, 0x00, 0x00}}, {x86.R1, 1, 4, 0x7F, []byte{0xC7, 0x41, 0x01, 0x7F, 0x00, 0x00, 0x00}},
{x86.RCX, 1, 2, 0x7F, []byte{0x66, 0xC7, 0x41, 0x01, 0x7F, 0x00}}, {x86.R1, 1, 2, 0x7F, []byte{0x66, 0xC7, 0x41, 0x01, 0x7F, 0x00}},
{x86.RCX, 1, 1, 0x7F, []byte{0xC6, 0x41, 0x01, 0x7F}}, {x86.R1, 1, 1, 0x7F, []byte{0xC6, 0x41, 0x01, 0x7F}},
{x86.RDX, 1, 8, 0x7F, []byte{0x48, 0xC7, 0x42, 0x01, 0x7F, 0x00, 0x00, 0x00}}, {x86.R2, 1, 8, 0x7F, []byte{0x48, 0xC7, 0x42, 0x01, 0x7F, 0x00, 0x00, 0x00}},
{x86.RDX, 1, 4, 0x7F, []byte{0xC7, 0x42, 0x01, 0x7F, 0x00, 0x00, 0x00}}, {x86.R2, 1, 4, 0x7F, []byte{0xC7, 0x42, 0x01, 0x7F, 0x00, 0x00, 0x00}},
{x86.RDX, 1, 2, 0x7F, []byte{0x66, 0xC7, 0x42, 0x01, 0x7F, 0x00}}, {x86.R2, 1, 2, 0x7F, []byte{0x66, 0xC7, 0x42, 0x01, 0x7F, 0x00}},
{x86.RDX, 1, 1, 0x7F, []byte{0xC6, 0x42, 0x01, 0x7F}}, {x86.R2, 1, 1, 0x7F, []byte{0xC6, 0x42, 0x01, 0x7F}},
{x86.RBX, 1, 8, 0x7F, []byte{0x48, 0xC7, 0x43, 0x01, 0x7F, 0x00, 0x00, 0x00}}, {x86.R3, 1, 8, 0x7F, []byte{0x48, 0xC7, 0x43, 0x01, 0x7F, 0x00, 0x00, 0x00}},
{x86.RBX, 1, 4, 0x7F, []byte{0xC7, 0x43, 0x01, 0x7F, 0x00, 0x00, 0x00}}, {x86.R3, 1, 4, 0x7F, []byte{0xC7, 0x43, 0x01, 0x7F, 0x00, 0x00, 0x00}},
{x86.RBX, 1, 2, 0x7F, []byte{0x66, 0xC7, 0x43, 0x01, 0x7F, 0x00}}, {x86.R3, 1, 2, 0x7F, []byte{0x66, 0xC7, 0x43, 0x01, 0x7F, 0x00}},
{x86.RBX, 1, 1, 0x7F, []byte{0xC6, 0x43, 0x01, 0x7F}}, {x86.R3, 1, 1, 0x7F, []byte{0xC6, 0x43, 0x01, 0x7F}},
{x86.RSP, 1, 8, 0x7F, []byte{0x48, 0xC7, 0x44, 0x24, 0x01, 0x7F, 0x00, 0x00, 0x00}}, {x86.SP, 1, 8, 0x7F, []byte{0x48, 0xC7, 0x44, 0x24, 0x01, 0x7F, 0x00, 0x00, 0x00}},
{x86.RSP, 1, 4, 0x7F, []byte{0xC7, 0x44, 0x24, 0x01, 0x7F, 0x00, 0x00, 0x00}}, {x86.SP, 1, 4, 0x7F, []byte{0xC7, 0x44, 0x24, 0x01, 0x7F, 0x00, 0x00, 0x00}},
{x86.RSP, 1, 2, 0x7F, []byte{0x66, 0xC7, 0x44, 0x24, 0x01, 0x7F, 0x00}}, {x86.SP, 1, 2, 0x7F, []byte{0x66, 0xC7, 0x44, 0x24, 0x01, 0x7F, 0x00}},
{x86.RSP, 1, 1, 0x7F, []byte{0xC6, 0x44, 0x24, 0x01, 0x7F}}, {x86.SP, 1, 1, 0x7F, []byte{0xC6, 0x44, 0x24, 0x01, 0x7F}},
{x86.RBP, 1, 8, 0x7F, []byte{0x48, 0xC7, 0x45, 0x01, 0x7F, 0x00, 0x00, 0x00}}, {x86.R5, 1, 8, 0x7F, []byte{0x48, 0xC7, 0x45, 0x01, 0x7F, 0x00, 0x00, 0x00}},
{x86.RBP, 1, 4, 0x7F, []byte{0xC7, 0x45, 0x01, 0x7F, 0x00, 0x00, 0x00}}, {x86.R5, 1, 4, 0x7F, []byte{0xC7, 0x45, 0x01, 0x7F, 0x00, 0x00, 0x00}},
{x86.RBP, 1, 2, 0x7F, []byte{0x66, 0xC7, 0x45, 0x01, 0x7F, 0x00}}, {x86.R5, 1, 2, 0x7F, []byte{0x66, 0xC7, 0x45, 0x01, 0x7F, 0x00}},
{x86.RBP, 1, 1, 0x7F, []byte{0xC6, 0x45, 0x01, 0x7F}}, {x86.R5, 1, 1, 0x7F, []byte{0xC6, 0x45, 0x01, 0x7F}},
{x86.RSI, 1, 8, 0x7F, []byte{0x48, 0xC7, 0x46, 0x01, 0x7F, 0x00, 0x00, 0x00}}, {x86.R6, 1, 8, 0x7F, []byte{0x48, 0xC7, 0x46, 0x01, 0x7F, 0x00, 0x00, 0x00}},
{x86.RSI, 1, 4, 0x7F, []byte{0xC7, 0x46, 0x01, 0x7F, 0x00, 0x00, 0x00}}, {x86.R6, 1, 4, 0x7F, []byte{0xC7, 0x46, 0x01, 0x7F, 0x00, 0x00, 0x00}},
{x86.RSI, 1, 2, 0x7F, []byte{0x66, 0xC7, 0x46, 0x01, 0x7F, 0x00}}, {x86.R6, 1, 2, 0x7F, []byte{0x66, 0xC7, 0x46, 0x01, 0x7F, 0x00}},
{x86.RSI, 1, 1, 0x7F, []byte{0xC6, 0x46, 0x01, 0x7F}}, {x86.R6, 1, 1, 0x7F, []byte{0xC6, 0x46, 0x01, 0x7F}},
{x86.RDI, 1, 8, 0x7F, []byte{0x48, 0xC7, 0x47, 0x01, 0x7F, 0x00, 0x00, 0x00}}, {x86.R7, 1, 8, 0x7F, []byte{0x48, 0xC7, 0x47, 0x01, 0x7F, 0x00, 0x00, 0x00}},
{x86.RDI, 1, 4, 0x7F, []byte{0xC7, 0x47, 0x01, 0x7F, 0x00, 0x00, 0x00}}, {x86.R7, 1, 4, 0x7F, []byte{0xC7, 0x47, 0x01, 0x7F, 0x00, 0x00, 0x00}},
{x86.RDI, 1, 2, 0x7F, []byte{0x66, 0xC7, 0x47, 0x01, 0x7F, 0x00}}, {x86.R7, 1, 2, 0x7F, []byte{0x66, 0xC7, 0x47, 0x01, 0x7F, 0x00}},
{x86.RDI, 1, 1, 0x7F, []byte{0xC6, 0x47, 0x01, 0x7F}}, {x86.R7, 1, 1, 0x7F, []byte{0xC6, 0x47, 0x01, 0x7F}},
{x86.R8, 1, 8, 0x7F, []byte{0x49, 0xC7, 0x40, 0x01, 0x7F, 0x00, 0x00, 0x00}}, {x86.R8, 1, 8, 0x7F, []byte{0x49, 0xC7, 0x40, 0x01, 0x7F, 0x00, 0x00, 0x00}},
{x86.R8, 1, 4, 0x7F, []byte{0x41, 0xC7, 0x40, 0x01, 0x7F, 0x00, 0x00, 0x00}}, {x86.R8, 1, 4, 0x7F, []byte{0x41, 0xC7, 0x40, 0x01, 0x7F, 0x00, 0x00, 0x00}},
{x86.R8, 1, 2, 0x7F, []byte{0x66, 0x41, 0xC7, 0x40, 0x01, 0x7F, 0x00}}, {x86.R8, 1, 2, 0x7F, []byte{0x66, 0x41, 0xC7, 0x40, 0x01, 0x7F, 0x00}},
@ -165,136 +165,136 @@ func TestStoreRegister(t *testing.T) {
Code []byte Code []byte
}{ }{
// No offset // No offset
{x86.RAX, 0, 8, x86.R15, []byte{0x4C, 0x89, 0x38}}, {x86.R0, 0, 8, x86.R15, []byte{0x4C, 0x89, 0x38}},
{x86.RAX, 0, 4, x86.R15, []byte{0x44, 0x89, 0x38}}, {x86.R0, 0, 4, x86.R15, []byte{0x44, 0x89, 0x38}},
{x86.RAX, 0, 2, x86.R15, []byte{0x66, 0x44, 0x89, 0x38}}, {x86.R0, 0, 2, x86.R15, []byte{0x66, 0x44, 0x89, 0x38}},
{x86.RAX, 0, 1, x86.R15, []byte{0x44, 0x88, 0x38}}, {x86.R0, 0, 1, x86.R15, []byte{0x44, 0x88, 0x38}},
{x86.RCX, 0, 8, x86.R14, []byte{0x4C, 0x89, 0x31}}, {x86.R1, 0, 8, x86.R14, []byte{0x4C, 0x89, 0x31}},
{x86.RCX, 0, 4, x86.R14, []byte{0x44, 0x89, 0x31}}, {x86.R1, 0, 4, x86.R14, []byte{0x44, 0x89, 0x31}},
{x86.RCX, 0, 2, x86.R14, []byte{0x66, 0x44, 0x89, 0x31}}, {x86.R1, 0, 2, x86.R14, []byte{0x66, 0x44, 0x89, 0x31}},
{x86.RCX, 0, 1, x86.R14, []byte{0x44, 0x88, 0x31}}, {x86.R1, 0, 1, x86.R14, []byte{0x44, 0x88, 0x31}},
{x86.RDX, 0, 8, x86.R13, []byte{0x4C, 0x89, 0x2A}}, {x86.R2, 0, 8, x86.R13, []byte{0x4C, 0x89, 0x2A}},
{x86.RDX, 0, 4, x86.R13, []byte{0x44, 0x89, 0x2A}}, {x86.R2, 0, 4, x86.R13, []byte{0x44, 0x89, 0x2A}},
{x86.RDX, 0, 2, x86.R13, []byte{0x66, 0x44, 0x89, 0x2A}}, {x86.R2, 0, 2, x86.R13, []byte{0x66, 0x44, 0x89, 0x2A}},
{x86.RDX, 0, 1, x86.R13, []byte{0x44, 0x88, 0x2A}}, {x86.R2, 0, 1, x86.R13, []byte{0x44, 0x88, 0x2A}},
{x86.RBX, 0, 8, x86.R12, []byte{0x4C, 0x89, 0x23}}, {x86.R3, 0, 8, x86.R12, []byte{0x4C, 0x89, 0x23}},
{x86.RBX, 0, 4, x86.R12, []byte{0x44, 0x89, 0x23}}, {x86.R3, 0, 4, x86.R12, []byte{0x44, 0x89, 0x23}},
{x86.RBX, 0, 2, x86.R12, []byte{0x66, 0x44, 0x89, 0x23}}, {x86.R3, 0, 2, x86.R12, []byte{0x66, 0x44, 0x89, 0x23}},
{x86.RBX, 0, 1, x86.R12, []byte{0x44, 0x88, 0x23}}, {x86.R3, 0, 1, x86.R12, []byte{0x44, 0x88, 0x23}},
{x86.RSP, 0, 8, x86.R11, []byte{0x4C, 0x89, 0x1C, 0x24}}, {x86.SP, 0, 8, x86.R11, []byte{0x4C, 0x89, 0x1C, 0x24}},
{x86.RSP, 0, 4, x86.R11, []byte{0x44, 0x89, 0x1C, 0x24}}, {x86.SP, 0, 4, x86.R11, []byte{0x44, 0x89, 0x1C, 0x24}},
{x86.RSP, 0, 2, x86.R11, []byte{0x66, 0x44, 0x89, 0x1C, 0x24}}, {x86.SP, 0, 2, x86.R11, []byte{0x66, 0x44, 0x89, 0x1C, 0x24}},
{x86.RSP, 0, 1, x86.R11, []byte{0x44, 0x88, 0x1C, 0x24}}, {x86.SP, 0, 1, x86.R11, []byte{0x44, 0x88, 0x1C, 0x24}},
{x86.RBP, 0, 8, x86.R10, []byte{0x4C, 0x89, 0x55, 0x00}}, {x86.R5, 0, 8, x86.R10, []byte{0x4C, 0x89, 0x55, 0x00}},
{x86.RBP, 0, 4, x86.R10, []byte{0x44, 0x89, 0x55, 0x00}}, {x86.R5, 0, 4, x86.R10, []byte{0x44, 0x89, 0x55, 0x00}},
{x86.RBP, 0, 2, x86.R10, []byte{0x66, 0x44, 0x89, 0x55, 0x00}}, {x86.R5, 0, 2, x86.R10, []byte{0x66, 0x44, 0x89, 0x55, 0x00}},
{x86.RBP, 0, 1, x86.R10, []byte{0x44, 0x88, 0x55, 0x00}}, {x86.R5, 0, 1, x86.R10, []byte{0x44, 0x88, 0x55, 0x00}},
{x86.RSI, 0, 8, x86.R9, []byte{0x4C, 0x89, 0x0E}}, {x86.R6, 0, 8, x86.R9, []byte{0x4C, 0x89, 0x0E}},
{x86.RSI, 0, 4, x86.R9, []byte{0x44, 0x89, 0x0E}}, {x86.R6, 0, 4, x86.R9, []byte{0x44, 0x89, 0x0E}},
{x86.RSI, 0, 2, x86.R9, []byte{0x66, 0x44, 0x89, 0x0E}}, {x86.R6, 0, 2, x86.R9, []byte{0x66, 0x44, 0x89, 0x0E}},
{x86.RSI, 0, 1, x86.R9, []byte{0x44, 0x88, 0x0E}}, {x86.R6, 0, 1, x86.R9, []byte{0x44, 0x88, 0x0E}},
{x86.RDI, 0, 8, x86.R8, []byte{0x4C, 0x89, 0x07}}, {x86.R7, 0, 8, x86.R8, []byte{0x4C, 0x89, 0x07}},
{x86.RDI, 0, 4, x86.R8, []byte{0x44, 0x89, 0x07}}, {x86.R7, 0, 4, x86.R8, []byte{0x44, 0x89, 0x07}},
{x86.RDI, 0, 2, x86.R8, []byte{0x66, 0x44, 0x89, 0x07}}, {x86.R7, 0, 2, x86.R8, []byte{0x66, 0x44, 0x89, 0x07}},
{x86.RDI, 0, 1, x86.R8, []byte{0x44, 0x88, 0x07}}, {x86.R7, 0, 1, x86.R8, []byte{0x44, 0x88, 0x07}},
{x86.R8, 0, 8, x86.RDI, []byte{0x49, 0x89, 0x38}}, {x86.R8, 0, 8, x86.R7, []byte{0x49, 0x89, 0x38}},
{x86.R8, 0, 4, x86.RDI, []byte{0x41, 0x89, 0x38}}, {x86.R8, 0, 4, x86.R7, []byte{0x41, 0x89, 0x38}},
{x86.R8, 0, 2, x86.RDI, []byte{0x66, 0x41, 0x89, 0x38}}, {x86.R8, 0, 2, x86.R7, []byte{0x66, 0x41, 0x89, 0x38}},
{x86.R8, 0, 1, x86.RDI, []byte{0x41, 0x88, 0x38}}, {x86.R8, 0, 1, x86.R7, []byte{0x41, 0x88, 0x38}},
{x86.R9, 0, 8, x86.RSI, []byte{0x49, 0x89, 0x31}}, {x86.R9, 0, 8, x86.R6, []byte{0x49, 0x89, 0x31}},
{x86.R9, 0, 4, x86.RSI, []byte{0x41, 0x89, 0x31}}, {x86.R9, 0, 4, x86.R6, []byte{0x41, 0x89, 0x31}},
{x86.R9, 0, 2, x86.RSI, []byte{0x66, 0x41, 0x89, 0x31}}, {x86.R9, 0, 2, x86.R6, []byte{0x66, 0x41, 0x89, 0x31}},
{x86.R9, 0, 1, x86.RSI, []byte{0x41, 0x88, 0x31}}, {x86.R9, 0, 1, x86.R6, []byte{0x41, 0x88, 0x31}},
{x86.R10, 0, 8, x86.RBP, []byte{0x49, 0x89, 0x2A}}, {x86.R10, 0, 8, x86.R5, []byte{0x49, 0x89, 0x2A}},
{x86.R10, 0, 4, x86.RBP, []byte{0x41, 0x89, 0x2A}}, {x86.R10, 0, 4, x86.R5, []byte{0x41, 0x89, 0x2A}},
{x86.R10, 0, 2, x86.RBP, []byte{0x66, 0x41, 0x89, 0x2A}}, {x86.R10, 0, 2, x86.R5, []byte{0x66, 0x41, 0x89, 0x2A}},
{x86.R10, 0, 1, x86.RBP, []byte{0x41, 0x88, 0x2A}}, {x86.R10, 0, 1, x86.R5, []byte{0x41, 0x88, 0x2A}},
{x86.R11, 0, 8, x86.RSP, []byte{0x49, 0x89, 0x23}}, {x86.R11, 0, 8, x86.SP, []byte{0x49, 0x89, 0x23}},
{x86.R11, 0, 4, x86.RSP, []byte{0x41, 0x89, 0x23}}, {x86.R11, 0, 4, x86.SP, []byte{0x41, 0x89, 0x23}},
{x86.R11, 0, 2, x86.RSP, []byte{0x66, 0x41, 0x89, 0x23}}, {x86.R11, 0, 2, x86.SP, []byte{0x66, 0x41, 0x89, 0x23}},
{x86.R11, 0, 1, x86.RSP, []byte{0x41, 0x88, 0x23}}, {x86.R11, 0, 1, x86.SP, []byte{0x41, 0x88, 0x23}},
{x86.R12, 0, 8, x86.RBX, []byte{0x49, 0x89, 0x1C, 0x24}}, {x86.R12, 0, 8, x86.R3, []byte{0x49, 0x89, 0x1C, 0x24}},
{x86.R12, 0, 4, x86.RBX, []byte{0x41, 0x89, 0x1C, 0x24}}, {x86.R12, 0, 4, x86.R3, []byte{0x41, 0x89, 0x1C, 0x24}},
{x86.R12, 0, 2, x86.RBX, []byte{0x66, 0x41, 0x89, 0x1C, 0x24}}, {x86.R12, 0, 2, x86.R3, []byte{0x66, 0x41, 0x89, 0x1C, 0x24}},
{x86.R12, 0, 1, x86.RBX, []byte{0x41, 0x88, 0x1C, 0x24}}, {x86.R12, 0, 1, x86.R3, []byte{0x41, 0x88, 0x1C, 0x24}},
{x86.R13, 0, 8, x86.RDX, []byte{0x49, 0x89, 0x55, 0x00}}, {x86.R13, 0, 8, x86.R2, []byte{0x49, 0x89, 0x55, 0x00}},
{x86.R13, 0, 4, x86.RDX, []byte{0x41, 0x89, 0x55, 0x00}}, {x86.R13, 0, 4, x86.R2, []byte{0x41, 0x89, 0x55, 0x00}},
{x86.R13, 0, 2, x86.RDX, []byte{0x66, 0x41, 0x89, 0x55, 0x00}}, {x86.R13, 0, 2, x86.R2, []byte{0x66, 0x41, 0x89, 0x55, 0x00}},
{x86.R13, 0, 1, x86.RDX, []byte{0x41, 0x88, 0x55, 0x00}}, {x86.R13, 0, 1, x86.R2, []byte{0x41, 0x88, 0x55, 0x00}},
{x86.R14, 0, 8, x86.RCX, []byte{0x49, 0x89, 0x0E}}, {x86.R14, 0, 8, x86.R1, []byte{0x49, 0x89, 0x0E}},
{x86.R14, 0, 4, x86.RCX, []byte{0x41, 0x89, 0x0E}}, {x86.R14, 0, 4, x86.R1, []byte{0x41, 0x89, 0x0E}},
{x86.R14, 0, 2, x86.RCX, []byte{0x66, 0x41, 0x89, 0x0E}}, {x86.R14, 0, 2, x86.R1, []byte{0x66, 0x41, 0x89, 0x0E}},
{x86.R14, 0, 1, x86.RCX, []byte{0x41, 0x88, 0x0E}}, {x86.R14, 0, 1, x86.R1, []byte{0x41, 0x88, 0x0E}},
{x86.R15, 0, 8, x86.RAX, []byte{0x49, 0x89, 0x07}}, {x86.R15, 0, 8, x86.R0, []byte{0x49, 0x89, 0x07}},
{x86.R15, 0, 4, x86.RAX, []byte{0x41, 0x89, 0x07}}, {x86.R15, 0, 4, x86.R0, []byte{0x41, 0x89, 0x07}},
{x86.R15, 0, 2, x86.RAX, []byte{0x66, 0x41, 0x89, 0x07}}, {x86.R15, 0, 2, x86.R0, []byte{0x66, 0x41, 0x89, 0x07}},
{x86.R15, 0, 1, x86.RAX, []byte{0x41, 0x88, 0x07}}, {x86.R15, 0, 1, x86.R0, []byte{0x41, 0x88, 0x07}},
// Offset of 1 // Offset of 1
{x86.RAX, 1, 8, x86.R15, []byte{0x4C, 0x89, 0x78, 0x01}}, {x86.R0, 1, 8, x86.R15, []byte{0x4C, 0x89, 0x78, 0x01}},
{x86.RAX, 1, 4, x86.R15, []byte{0x44, 0x89, 0x78, 0x01}}, {x86.R0, 1, 4, x86.R15, []byte{0x44, 0x89, 0x78, 0x01}},
{x86.RAX, 1, 2, x86.R15, []byte{0x66, 0x44, 0x89, 0x78, 0x01}}, {x86.R0, 1, 2, x86.R15, []byte{0x66, 0x44, 0x89, 0x78, 0x01}},
{x86.RAX, 1, 1, x86.R15, []byte{0x44, 0x88, 0x78, 0x01}}, {x86.R0, 1, 1, x86.R15, []byte{0x44, 0x88, 0x78, 0x01}},
{x86.RCX, 1, 8, x86.R14, []byte{0x4C, 0x89, 0x71, 0x01}}, {x86.R1, 1, 8, x86.R14, []byte{0x4C, 0x89, 0x71, 0x01}},
{x86.RCX, 1, 4, x86.R14, []byte{0x44, 0x89, 0x71, 0x01}}, {x86.R1, 1, 4, x86.R14, []byte{0x44, 0x89, 0x71, 0x01}},
{x86.RCX, 1, 2, x86.R14, []byte{0x66, 0x44, 0x89, 0x71, 0x01}}, {x86.R1, 1, 2, x86.R14, []byte{0x66, 0x44, 0x89, 0x71, 0x01}},
{x86.RCX, 1, 1, x86.R14, []byte{0x44, 0x88, 0x71, 0x01}}, {x86.R1, 1, 1, x86.R14, []byte{0x44, 0x88, 0x71, 0x01}},
{x86.RDX, 1, 8, x86.R13, []byte{0x4C, 0x89, 0x6A, 0x01}}, {x86.R2, 1, 8, x86.R13, []byte{0x4C, 0x89, 0x6A, 0x01}},
{x86.RDX, 1, 4, x86.R13, []byte{0x44, 0x89, 0x6A, 0x01}}, {x86.R2, 1, 4, x86.R13, []byte{0x44, 0x89, 0x6A, 0x01}},
{x86.RDX, 1, 2, x86.R13, []byte{0x66, 0x44, 0x89, 0x6A, 0x01}}, {x86.R2, 1, 2, x86.R13, []byte{0x66, 0x44, 0x89, 0x6A, 0x01}},
{x86.RDX, 1, 1, x86.R13, []byte{0x44, 0x88, 0x6A, 0x01}}, {x86.R2, 1, 1, x86.R13, []byte{0x44, 0x88, 0x6A, 0x01}},
{x86.RBX, 1, 8, x86.R12, []byte{0x4C, 0x89, 0x63, 0x01}}, {x86.R3, 1, 8, x86.R12, []byte{0x4C, 0x89, 0x63, 0x01}},
{x86.RBX, 1, 4, x86.R12, []byte{0x44, 0x89, 0x63, 0x01}}, {x86.R3, 1, 4, x86.R12, []byte{0x44, 0x89, 0x63, 0x01}},
{x86.RBX, 1, 2, x86.R12, []byte{0x66, 0x44, 0x89, 0x63, 0x01}}, {x86.R3, 1, 2, x86.R12, []byte{0x66, 0x44, 0x89, 0x63, 0x01}},
{x86.RBX, 1, 1, x86.R12, []byte{0x44, 0x88, 0x63, 0x01}}, {x86.R3, 1, 1, x86.R12, []byte{0x44, 0x88, 0x63, 0x01}},
{x86.RSP, 1, 8, x86.R11, []byte{0x4C, 0x89, 0x5C, 0x24, 0x01}}, {x86.SP, 1, 8, x86.R11, []byte{0x4C, 0x89, 0x5C, 0x24, 0x01}},
{x86.RSP, 1, 4, x86.R11, []byte{0x44, 0x89, 0x5C, 0x24, 0x01}}, {x86.SP, 1, 4, x86.R11, []byte{0x44, 0x89, 0x5C, 0x24, 0x01}},
{x86.RSP, 1, 2, x86.R11, []byte{0x66, 0x44, 0x89, 0x5C, 0x24, 0x01}}, {x86.SP, 1, 2, x86.R11, []byte{0x66, 0x44, 0x89, 0x5C, 0x24, 0x01}},
{x86.RSP, 1, 1, x86.R11, []byte{0x44, 0x88, 0x5C, 0x24, 0x01}}, {x86.SP, 1, 1, x86.R11, []byte{0x44, 0x88, 0x5C, 0x24, 0x01}},
{x86.RBP, 1, 8, x86.R10, []byte{0x4C, 0x89, 0x55, 0x01}}, {x86.R5, 1, 8, x86.R10, []byte{0x4C, 0x89, 0x55, 0x01}},
{x86.RBP, 1, 4, x86.R10, []byte{0x44, 0x89, 0x55, 0x01}}, {x86.R5, 1, 4, x86.R10, []byte{0x44, 0x89, 0x55, 0x01}},
{x86.RBP, 1, 2, x86.R10, []byte{0x66, 0x44, 0x89, 0x55, 0x01}}, {x86.R5, 1, 2, x86.R10, []byte{0x66, 0x44, 0x89, 0x55, 0x01}},
{x86.RBP, 1, 1, x86.R10, []byte{0x44, 0x88, 0x55, 0x01}}, {x86.R5, 1, 1, x86.R10, []byte{0x44, 0x88, 0x55, 0x01}},
{x86.RSI, 1, 8, x86.R9, []byte{0x4C, 0x89, 0x4E, 0x01}}, {x86.R6, 1, 8, x86.R9, []byte{0x4C, 0x89, 0x4E, 0x01}},
{x86.RSI, 1, 4, x86.R9, []byte{0x44, 0x89, 0x4E, 0x01}}, {x86.R6, 1, 4, x86.R9, []byte{0x44, 0x89, 0x4E, 0x01}},
{x86.RSI, 1, 2, x86.R9, []byte{0x66, 0x44, 0x89, 0x4E, 0x01}}, {x86.R6, 1, 2, x86.R9, []byte{0x66, 0x44, 0x89, 0x4E, 0x01}},
{x86.RSI, 1, 1, x86.R9, []byte{0x44, 0x88, 0x4E, 0x01}}, {x86.R6, 1, 1, x86.R9, []byte{0x44, 0x88, 0x4E, 0x01}},
{x86.RDI, 1, 8, x86.R8, []byte{0x4C, 0x89, 0x47, 0x01}}, {x86.R7, 1, 8, x86.R8, []byte{0x4C, 0x89, 0x47, 0x01}},
{x86.RDI, 1, 4, x86.R8, []byte{0x44, 0x89, 0x47, 0x01}}, {x86.R7, 1, 4, x86.R8, []byte{0x44, 0x89, 0x47, 0x01}},
{x86.RDI, 1, 2, x86.R8, []byte{0x66, 0x44, 0x89, 0x47, 0x01}}, {x86.R7, 1, 2, x86.R8, []byte{0x66, 0x44, 0x89, 0x47, 0x01}},
{x86.RDI, 1, 1, x86.R8, []byte{0x44, 0x88, 0x47, 0x01}}, {x86.R7, 1, 1, x86.R8, []byte{0x44, 0x88, 0x47, 0x01}},
{x86.R8, 1, 8, x86.RDI, []byte{0x49, 0x89, 0x78, 0x01}}, {x86.R8, 1, 8, x86.R7, []byte{0x49, 0x89, 0x78, 0x01}},
{x86.R8, 1, 4, x86.RDI, []byte{0x41, 0x89, 0x78, 0x01}}, {x86.R8, 1, 4, x86.R7, []byte{0x41, 0x89, 0x78, 0x01}},
{x86.R8, 1, 2, x86.RDI, []byte{0x66, 0x41, 0x89, 0x78, 0x01}}, {x86.R8, 1, 2, x86.R7, []byte{0x66, 0x41, 0x89, 0x78, 0x01}},
{x86.R8, 1, 1, x86.RDI, []byte{0x41, 0x88, 0x78, 0x01}}, {x86.R8, 1, 1, x86.R7, []byte{0x41, 0x88, 0x78, 0x01}},
{x86.R9, 1, 8, x86.RSI, []byte{0x49, 0x89, 0x71, 0x01}}, {x86.R9, 1, 8, x86.R6, []byte{0x49, 0x89, 0x71, 0x01}},
{x86.R9, 1, 4, x86.RSI, []byte{0x41, 0x89, 0x71, 0x01}}, {x86.R9, 1, 4, x86.R6, []byte{0x41, 0x89, 0x71, 0x01}},
{x86.R9, 1, 2, x86.RSI, []byte{0x66, 0x41, 0x89, 0x71, 0x01}}, {x86.R9, 1, 2, x86.R6, []byte{0x66, 0x41, 0x89, 0x71, 0x01}},
{x86.R9, 1, 1, x86.RSI, []byte{0x41, 0x88, 0x71, 0x01}}, {x86.R9, 1, 1, x86.R6, []byte{0x41, 0x88, 0x71, 0x01}},
{x86.R10, 1, 8, x86.RBP, []byte{0x49, 0x89, 0x6A, 0x01}}, {x86.R10, 1, 8, x86.R5, []byte{0x49, 0x89, 0x6A, 0x01}},
{x86.R10, 1, 4, x86.RBP, []byte{0x41, 0x89, 0x6A, 0x01}}, {x86.R10, 1, 4, x86.R5, []byte{0x41, 0x89, 0x6A, 0x01}},
{x86.R10, 1, 2, x86.RBP, []byte{0x66, 0x41, 0x89, 0x6A, 0x01}}, {x86.R10, 1, 2, x86.R5, []byte{0x66, 0x41, 0x89, 0x6A, 0x01}},
{x86.R10, 1, 1, x86.RBP, []byte{0x41, 0x88, 0x6A, 0x01}}, {x86.R10, 1, 1, x86.R5, []byte{0x41, 0x88, 0x6A, 0x01}},
{x86.R11, 1, 8, x86.RSP, []byte{0x49, 0x89, 0x63, 0x01}}, {x86.R11, 1, 8, x86.SP, []byte{0x49, 0x89, 0x63, 0x01}},
{x86.R11, 1, 4, x86.RSP, []byte{0x41, 0x89, 0x63, 0x01}}, {x86.R11, 1, 4, x86.SP, []byte{0x41, 0x89, 0x63, 0x01}},
{x86.R11, 1, 2, x86.RSP, []byte{0x66, 0x41, 0x89, 0x63, 0x01}}, {x86.R11, 1, 2, x86.SP, []byte{0x66, 0x41, 0x89, 0x63, 0x01}},
{x86.R11, 1, 1, x86.RSP, []byte{0x41, 0x88, 0x63, 0x01}}, {x86.R11, 1, 1, x86.SP, []byte{0x41, 0x88, 0x63, 0x01}},
{x86.R12, 1, 8, x86.RBX, []byte{0x49, 0x89, 0x5C, 0x24, 0x01}}, {x86.R12, 1, 8, x86.R3, []byte{0x49, 0x89, 0x5C, 0x24, 0x01}},
{x86.R12, 1, 4, x86.RBX, []byte{0x41, 0x89, 0x5C, 0x24, 0x01}}, {x86.R12, 1, 4, x86.R3, []byte{0x41, 0x89, 0x5C, 0x24, 0x01}},
{x86.R12, 1, 2, x86.RBX, []byte{0x66, 0x41, 0x89, 0x5C, 0x24, 0x01}}, {x86.R12, 1, 2, x86.R3, []byte{0x66, 0x41, 0x89, 0x5C, 0x24, 0x01}},
{x86.R12, 1, 1, x86.RBX, []byte{0x41, 0x88, 0x5C, 0x24, 01}}, {x86.R12, 1, 1, x86.R3, []byte{0x41, 0x88, 0x5C, 0x24, 01}},
{x86.R13, 1, 8, x86.RDX, []byte{0x49, 0x89, 0x55, 0x01}}, {x86.R13, 1, 8, x86.R2, []byte{0x49, 0x89, 0x55, 0x01}},
{x86.R13, 1, 4, x86.RDX, []byte{0x41, 0x89, 0x55, 0x01}}, {x86.R13, 1, 4, x86.R2, []byte{0x41, 0x89, 0x55, 0x01}},
{x86.R13, 1, 2, x86.RDX, []byte{0x66, 0x41, 0x89, 0x55, 0x01}}, {x86.R13, 1, 2, x86.R2, []byte{0x66, 0x41, 0x89, 0x55, 0x01}},
{x86.R13, 1, 1, x86.RDX, []byte{0x41, 0x88, 0x55, 0x01}}, {x86.R13, 1, 1, x86.R2, []byte{0x41, 0x88, 0x55, 0x01}},
{x86.R14, 1, 8, x86.RCX, []byte{0x49, 0x89, 0x4E, 0x01}}, {x86.R14, 1, 8, x86.R1, []byte{0x49, 0x89, 0x4E, 0x01}},
{x86.R14, 1, 4, x86.RCX, []byte{0x41, 0x89, 0x4E, 0x01}}, {x86.R14, 1, 4, x86.R1, []byte{0x41, 0x89, 0x4E, 0x01}},
{x86.R14, 1, 2, x86.RCX, []byte{0x66, 0x41, 0x89, 0x4E, 0x01}}, {x86.R14, 1, 2, x86.R1, []byte{0x66, 0x41, 0x89, 0x4E, 0x01}},
{x86.R14, 1, 1, x86.RCX, []byte{0x41, 0x88, 0x4E, 0x01}}, {x86.R14, 1, 1, x86.R1, []byte{0x41, 0x88, 0x4E, 0x01}},
{x86.R15, 1, 8, x86.RAX, []byte{0x49, 0x89, 0x47, 0x01}}, {x86.R15, 1, 8, x86.R0, []byte{0x49, 0x89, 0x47, 0x01}},
{x86.R15, 1, 4, x86.RAX, []byte{0x41, 0x89, 0x47, 0x01}}, {x86.R15, 1, 4, x86.R0, []byte{0x41, 0x89, 0x47, 0x01}},
{x86.R15, 1, 2, x86.RAX, []byte{0x66, 0x41, 0x89, 0x47, 0x01}}, {x86.R15, 1, 2, x86.R0, []byte{0x66, 0x41, 0x89, 0x47, 0x01}},
{x86.R15, 1, 1, x86.RAX, []byte{0x41, 0x88, 0x47, 0x01}}, {x86.R15, 1, 1, x86.R0, []byte{0x41, 0x88, 0x47, 0x01}},
} }
for _, pattern := range usagePatterns { for _, pattern := range usagePatterns {

64
src/x86/Sub_test.go
View File

@ -14,14 +14,14 @@ func TestSubRegisterNumber(t *testing.T) {
Number int Number int
Code []byte Code []byte
}{ }{
{x86.RAX, 1, []byte{0x48, 0x83, 0xE8, 0x01}}, {x86.R0, 1, []byte{0x48, 0x83, 0xE8, 0x01}},
{x86.RCX, 1, []byte{0x48, 0x83, 0xE9, 0x01}}, {x86.R1, 1, []byte{0x48, 0x83, 0xE9, 0x01}},
{x86.RDX, 1, []byte{0x48, 0x83, 0xEA, 0x01}}, {x86.R2, 1, []byte{0x48, 0x83, 0xEA, 0x01}},
{x86.RBX, 1, []byte{0x48, 0x83, 0xEB, 0x01}}, {x86.R3, 1, []byte{0x48, 0x83, 0xEB, 0x01}},
{x86.RSP, 1, []byte{0x48, 0x83, 0xEC, 0x01}}, {x86.SP, 1, []byte{0x48, 0x83, 0xEC, 0x01}},
{x86.RBP, 1, []byte{0x48, 0x83, 0xED, 0x01}}, {x86.R5, 1, []byte{0x48, 0x83, 0xED, 0x01}},
{x86.RSI, 1, []byte{0x48, 0x83, 0xEE, 0x01}}, {x86.R6, 1, []byte{0x48, 0x83, 0xEE, 0x01}},
{x86.RDI, 1, []byte{0x48, 0x83, 0xEF, 0x01}}, {x86.R7, 1, []byte{0x48, 0x83, 0xEF, 0x01}},
{x86.R8, 1, []byte{0x49, 0x83, 0xE8, 0x01}}, {x86.R8, 1, []byte{0x49, 0x83, 0xE8, 0x01}},
{x86.R9, 1, []byte{0x49, 0x83, 0xE9, 0x01}}, {x86.R9, 1, []byte{0x49, 0x83, 0xE9, 0x01}},
{x86.R10, 1, []byte{0x49, 0x83, 0xEA, 0x01}}, {x86.R10, 1, []byte{0x49, 0x83, 0xEA, 0x01}},
@ -31,14 +31,14 @@ func TestSubRegisterNumber(t *testing.T) {
{x86.R14, 1, []byte{0x49, 0x83, 0xEE, 0x01}}, {x86.R14, 1, []byte{0x49, 0x83, 0xEE, 0x01}},
{x86.R15, 1, []byte{0x49, 0x83, 0xEF, 0x01}}, {x86.R15, 1, []byte{0x49, 0x83, 0xEF, 0x01}},
{x86.RAX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xE8, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R0, 0x7FFFFFFF, []byte{0x48, 0x81, 0xE8, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RCX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xE9, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R1, 0x7FFFFFFF, []byte{0x48, 0x81, 0xE9, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RDX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xEA, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R2, 0x7FFFFFFF, []byte{0x48, 0x81, 0xEA, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RBX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xEB, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R3, 0x7FFFFFFF, []byte{0x48, 0x81, 0xEB, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RSP, 0x7FFFFFFF, []byte{0x48, 0x81, 0xEC, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.SP, 0x7FFFFFFF, []byte{0x48, 0x81, 0xEC, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RBP, 0x7FFFFFFF, []byte{0x48, 0x81, 0xED, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R5, 0x7FFFFFFF, []byte{0x48, 0x81, 0xED, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RSI, 0x7FFFFFFF, []byte{0x48, 0x81, 0xEE, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R6, 0x7FFFFFFF, []byte{0x48, 0x81, 0xEE, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RDI, 0x7FFFFFFF, []byte{0x48, 0x81, 0xEF, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R7, 0x7FFFFFFF, []byte{0x48, 0x81, 0xEF, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.R8, 0x7FFFFFFF, []byte{0x49, 0x81, 0xE8, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R8, 0x7FFFFFFF, []byte{0x49, 0x81, 0xE8, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.R9, 0x7FFFFFFF, []byte{0x49, 0x81, 0xE9, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R9, 0x7FFFFFFF, []byte{0x49, 0x81, 0xE9, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.R10, 0x7FFFFFFF, []byte{0x49, 0x81, 0xEA, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R10, 0x7FFFFFFF, []byte{0x49, 0x81, 0xEA, 0xFF, 0xFF, 0xFF, 0x7F}},
@ -62,22 +62,22 @@ func TestSubRegisterRegister(t *testing.T) {
Right cpu.Register Right cpu.Register
Code []byte Code []byte
}{ }{
{x86.RAX, x86.R15, []byte{0x4C, 0x29, 0xF8}}, {x86.R0, x86.R15, []byte{0x4C, 0x29, 0xF8}},
{x86.RCX, x86.R14, []byte{0x4C, 0x29, 0xF1}}, {x86.R1, x86.R14, []byte{0x4C, 0x29, 0xF1}},
{x86.RDX, x86.R13, []byte{0x4C, 0x29, 0xEA}}, {x86.R2, x86.R13, []byte{0x4C, 0x29, 0xEA}},
{x86.RBX, x86.R12, []byte{0x4C, 0x29, 0xE3}}, {x86.R3, x86.R12, []byte{0x4C, 0x29, 0xE3}},
{x86.RSP, x86.R11, []byte{0x4C, 0x29, 0xDC}}, {x86.SP, x86.R11, []byte{0x4C, 0x29, 0xDC}},
{x86.RBP, x86.R10, []byte{0x4C, 0x29, 0xD5}}, {x86.R5, x86.R10, []byte{0x4C, 0x29, 0xD5}},
{x86.RSI, x86.R9, []byte{0x4C, 0x29, 0xCE}}, {x86.R6, x86.R9, []byte{0x4C, 0x29, 0xCE}},
{x86.RDI, x86.R8, []byte{0x4C, 0x29, 0xC7}}, {x86.R7, x86.R8, []byte{0x4C, 0x29, 0xC7}},
{x86.R8, x86.RDI, []byte{0x49, 0x29, 0xF8}}, {x86.R8, x86.R7, []byte{0x49, 0x29, 0xF8}},
{x86.R9, x86.RSI, []byte{0x49, 0x29, 0xF1}}, {x86.R9, x86.R6, []byte{0x49, 0x29, 0xF1}},
{x86.R10, x86.RBP, []byte{0x49, 0x29, 0xEA}}, {x86.R10, x86.R5, []byte{0x49, 0x29, 0xEA}},
{x86.R11, x86.RSP, []byte{0x49, 0x29, 0xE3}}, {x86.R11, x86.SP, []byte{0x49, 0x29, 0xE3}},
{x86.R12, x86.RBX, []byte{0x49, 0x29, 0xDC}}, {x86.R12, x86.R3, []byte{0x49, 0x29, 0xDC}},
{x86.R13, x86.RDX, []byte{0x49, 0x29, 0xD5}}, {x86.R13, x86.R2, []byte{0x49, 0x29, 0xD5}},
{x86.R14, x86.RCX, []byte{0x49, 0x29, 0xCE}}, {x86.R14, x86.R1, []byte{0x49, 0x29, 0xCE}},
{x86.R15, x86.RAX, []byte{0x49, 0x29, 0xC7}}, {x86.R15, x86.R0, []byte{0x49, 0x29, 0xC7}},
} }
for _, pattern := range usagePatterns { for _, pattern := range usagePatterns {

64
src/x86/Xor_test.go
View File

@ -14,14 +14,14 @@ func TestXorRegisterNumber(t *testing.T) {
Number int Number int
Code []byte Code []byte
}{ }{
{x86.RAX, 1, []byte{0x48, 0x83, 0xF0, 0x01}}, {x86.R0, 1, []byte{0x48, 0x83, 0xF0, 0x01}},
{x86.RCX, 1, []byte{0x48, 0x83, 0xF1, 0x01}}, {x86.R1, 1, []byte{0x48, 0x83, 0xF1, 0x01}},
{x86.RDX, 1, []byte{0x48, 0x83, 0xF2, 0x01}}, {x86.R2, 1, []byte{0x48, 0x83, 0xF2, 0x01}},
{x86.RBX, 1, []byte{0x48, 0x83, 0xF3, 0x01}}, {x86.R3, 1, []byte{0x48, 0x83, 0xF3, 0x01}},
{x86.RSP, 1, []byte{0x48, 0x83, 0xF4, 0x01}}, {x86.SP, 1, []byte{0x48, 0x83, 0xF4, 0x01}},
{x86.RBP, 1, []byte{0x48, 0x83, 0xF5, 0x01}}, {x86.R5, 1, []byte{0x48, 0x83, 0xF5, 0x01}},
{x86.RSI, 1, []byte{0x48, 0x83, 0xF6, 0x01}}, {x86.R6, 1, []byte{0x48, 0x83, 0xF6, 0x01}},
{x86.RDI, 1, []byte{0x48, 0x83, 0xF7, 0x01}}, {x86.R7, 1, []byte{0x48, 0x83, 0xF7, 0x01}},
{x86.R8, 1, []byte{0x49, 0x83, 0xF0, 0x01}}, {x86.R8, 1, []byte{0x49, 0x83, 0xF0, 0x01}},
{x86.R9, 1, []byte{0x49, 0x83, 0xF1, 0x01}}, {x86.R9, 1, []byte{0x49, 0x83, 0xF1, 0x01}},
{x86.R10, 1, []byte{0x49, 0x83, 0xF2, 0x01}}, {x86.R10, 1, []byte{0x49, 0x83, 0xF2, 0x01}},
@ -31,14 +31,14 @@ func TestXorRegisterNumber(t *testing.T) {
{x86.R14, 1, []byte{0x49, 0x83, 0xF6, 0x01}}, {x86.R14, 1, []byte{0x49, 0x83, 0xF6, 0x01}},
{x86.R15, 1, []byte{0x49, 0x83, 0xF7, 0x01}}, {x86.R15, 1, []byte{0x49, 0x83, 0xF7, 0x01}},
{x86.RAX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xF0, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R0, 0x7FFFFFFF, []byte{0x48, 0x81, 0xF0, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RCX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xF1, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R1, 0x7FFFFFFF, []byte{0x48, 0x81, 0xF1, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RDX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xF2, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R2, 0x7FFFFFFF, []byte{0x48, 0x81, 0xF2, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RBX, 0x7FFFFFFF, []byte{0x48, 0x81, 0xF3, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R3, 0x7FFFFFFF, []byte{0x48, 0x81, 0xF3, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RSP, 0x7FFFFFFF, []byte{0x48, 0x81, 0xF4, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.SP, 0x7FFFFFFF, []byte{0x48, 0x81, 0xF4, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RBP, 0x7FFFFFFF, []byte{0x48, 0x81, 0xF5, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R5, 0x7FFFFFFF, []byte{0x48, 0x81, 0xF5, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RSI, 0x7FFFFFFF, []byte{0x48, 0x81, 0xF6, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R6, 0x7FFFFFFF, []byte{0x48, 0x81, 0xF6, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.RDI, 0x7FFFFFFF, []byte{0x48, 0x81, 0xF7, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R7, 0x7FFFFFFF, []byte{0x48, 0x81, 0xF7, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.R8, 0x7FFFFFFF, []byte{0x49, 0x81, 0xF0, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R8, 0x7FFFFFFF, []byte{0x49, 0x81, 0xF0, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.R9, 0x7FFFFFFF, []byte{0x49, 0x81, 0xF1, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R9, 0x7FFFFFFF, []byte{0x49, 0x81, 0xF1, 0xFF, 0xFF, 0xFF, 0x7F}},
{x86.R10, 0x7FFFFFFF, []byte{0x49, 0x81, 0xF2, 0xFF, 0xFF, 0xFF, 0x7F}}, {x86.R10, 0x7FFFFFFF, []byte{0x49, 0x81, 0xF2, 0xFF, 0xFF, 0xFF, 0x7F}},
@ -62,22 +62,22 @@ func TestXorRegisterRegister(t *testing.T) {
Right cpu.Register Right cpu.Register
Code []byte Code []byte
}{ }{
{x86.RAX, x86.R15, []byte{0x4C, 0x31, 0xF8}}, {x86.R0, x86.R15, []byte{0x4C, 0x31, 0xF8}},
{x86.RCX, x86.R14, []byte{0x4C, 0x31, 0xF1}}, {x86.R1, x86.R14, []byte{0x4C, 0x31, 0xF1}},
{x86.RDX, x86.R13, []byte{0x4C, 0x31, 0xEA}}, {x86.R2, x86.R13, []byte{0x4C, 0x31, 0xEA}},
{x86.RBX, x86.R12, []byte{0x4C, 0x31, 0xE3}}, {x86.R3, x86.R12, []byte{0x4C, 0x31, 0xE3}},
{x86.RSP, x86.R11, []byte{0x4C, 0x31, 0xDC}}, {x86.SP, x86.R11, []byte{0x4C, 0x31, 0xDC}},
{x86.RBP, x86.R10, []byte{0x4C, 0x31, 0xD5}}, {x86.R5, x86.R10, []byte{0x4C, 0x31, 0xD5}},
{x86.RSI, x86.R9, []byte{0x4C, 0x31, 0xCE}}, {x86.R6, x86.R9, []byte{0x4C, 0x31, 0xCE}},
{x86.RDI, x86.R8, []byte{0x4C, 0x31, 0xC7}}, {x86.R7, x86.R8, []byte{0x4C, 0x31, 0xC7}},
{x86.R8, x86.RDI, []byte{0x49, 0x31, 0xF8}}, {x86.R8, x86.R7, []byte{0x49, 0x31, 0xF8}},
{x86.R9, x86.RSI, []byte{0x49, 0x31, 0xF1}}, {x86.R9, x86.R6, []byte{0x49, 0x31, 0xF1}},
{x86.R10, x86.RBP, []byte{0x49, 0x31, 0xEA}}, {x86.R10, x86.R5, []byte{0x49, 0x31, 0xEA}},
{x86.R11, x86.RSP, []byte{0x49, 0x31, 0xE3}}, {x86.R11, x86.SP, []byte{0x49, 0x31, 0xE3}},
{x86.R12, x86.RBX, []byte{0x49, 0x31, 0xDC}}, {x86.R12, x86.R3, []byte{0x49, 0x31, 0xDC}},
{x86.R13, x86.RDX, []byte{0x49, 0x31, 0xD5}}, {x86.R13, x86.R2, []byte{0x49, 0x31, 0xD5}},
{x86.R14, x86.RCX, []byte{0x49, 0x31, 0xCE}}, {x86.R14, x86.R1, []byte{0x49, 0x31, 0xCE}},
{x86.R15, x86.RAX, []byte{0x49, 0x31, 0xC7}}, {x86.R15, x86.R0, []byte{0x49, 0x31, 0xC7}},
} }
for _, pattern := range usagePatterns { for _, pattern := range usagePatterns {

2
src/x86/encode.go
View File

@ -23,7 +23,7 @@ func encode(code []byte, mod AddressMode, reg cpu.Register, rm cpu.Register, num
rm &= 0b111 rm &= 0b111
} }
if w != 0 || r != 0 || x != 0 || b != 0 || (numBytes == 1 && (reg == RSP || reg == RBP || reg == RSI || reg == RDI)) { if w != 0 || r != 0 || x != 0 || b != 0 || (numBytes == 1 && (reg == SP || reg == R5 || reg == R6 || reg == R7)) {
code = append(code, REX(w, r, x, b)) code = append(code, REX(w, r, x, b))
} }

4
src/x86/memoryAccess.go
View File

@ -12,7 +12,7 @@ func memoryAccess(code []byte, opCode8 byte, opCode32 byte, register cpu.Registe
mod := AddressMemory mod := AddressMemory
if offset != 0 || base == RBP || base == R13 { if offset != 0 || base == R5 || base == R13 {
mod = AddressMemoryOffset8 mod = AddressMemoryOffset8
} }
@ -22,7 +22,7 @@ func memoryAccess(code []byte, opCode8 byte, opCode32 byte, register cpu.Registe
code = encode(code, mod, register, base, length, opCode) code = encode(code, mod, register, base, length, opCode)
if base == RSP || base == R12 { if base == SP || base == R12 {
code = append(code, SIB(Scale1, 0b100, 0b100)) code = append(code, SIB(Scale1, 0b100, 0b100))
} }

4
src/x86/memoryAccessDynamic.go
View File

@ -17,7 +17,7 @@ func memoryAccessDynamic(code []byte, opCode8 byte, opCode32 byte, register cpu.
opCode = opCode8 opCode = opCode8
} }
if offset == RSP { if offset == SP {
offset, base = base, offset offset, base = base, offset
} }
@ -40,7 +40,7 @@ func memoryAccessDynamic(code []byte, opCode8 byte, opCode32 byte, register cpu.
base &= 0b111 base &= 0b111
} }
if base == RBP || base == R13 { if base == R5 || base == R13 {
mod = AddressMemoryOffset8 mod = AddressMemoryOffset8
} }

2
src/x86/x86_test.go
View File

@ -10,7 +10,7 @@ import (
func TestX86(t *testing.T) { func TestX86(t *testing.T) {
assert.DeepEqual(t, x86.Call(nil, 1), []byte{0xE8, 0x01, 0x00, 0x00, 0x00}) assert.DeepEqual(t, x86.Call(nil, 1), []byte{0xE8, 0x01, 0x00, 0x00, 0x00})
assert.DeepEqual(t, x86.CallAt(nil, 1), []byte{0xFF, 0x15, 0x01, 0x00, 0x00, 0x00}) assert.DeepEqual(t, x86.CallAt(nil, 1), []byte{0xFF, 0x15, 0x01, 0x00, 0x00, 0x00})
assert.DeepEqual(t, x86.ExtendRAXToRDX(nil), []byte{0x48, 0x99}) assert.DeepEqual(t, x86.ExtendR0ToR2(nil), []byte{0x48, 0x99})
assert.DeepEqual(t, x86.MoveRegisterNumber(nil, 0, 1), []byte{0xB8, 0x01, 0x00, 0x00, 0x00}) assert.DeepEqual(t, x86.MoveRegisterNumber(nil, 0, 1), []byte{0xB8, 0x01, 0x00, 0x00, 0x00})
assert.DeepEqual(t, x86.MoveRegisterNumber(nil, 1, 1), []byte{0xB9, 0x01, 0x00, 0x00, 0x00}) assert.DeepEqual(t, x86.MoveRegisterNumber(nil, 1, 1), []byte{0xB9, 0x01, 0x00, 0x00, 0x00})
assert.DeepEqual(t, x86.Return(nil), []byte{0xC3}) assert.DeepEqual(t, x86.Return(nil), []byte{0xC3})