872 lines
39 KiB
Go
872 lines
39 KiB
Go
// Copyright (c) 2026 Petr Balvín <opensource@petrbalvin.org> (https://petrbalvin.org)
|
||
// SPDX-License-Identifier: BSD-3-Clause
|
||
|
||
package asm
|
||
|
||
import (
|
||
"fmt"
|
||
"strings"
|
||
"testing"
|
||
|
||
"golang.org/x/arch/x86/x86asm"
|
||
)
|
||
|
||
// decode encodes an instruction and decodes it back, returning the decoded
|
||
// instruction and its Intel-syntax rendering.
|
||
func decode(t *testing.T, mnemonic string, ops ...Operand) (x86asm.Inst, string) {
|
||
t.Helper()
|
||
code, err := Encode(mnemonic, ops...)
|
||
if err != nil {
|
||
t.Fatalf("Encode(%s): %v", mnemonic, err)
|
||
}
|
||
inst, err := x86asm.Decode(code, 64)
|
||
if err != nil {
|
||
t.Fatalf("Decode(%x) of %s: %v", code, mnemonic, err)
|
||
}
|
||
if inst.Len != len(code) {
|
||
t.Fatalf("Decode consumed %d of %d bytes for %s (%x)", inst.Len, len(code), mnemonic, code)
|
||
}
|
||
return inst, x86asm.IntelSyntax(inst, 0, nil)
|
||
}
|
||
|
||
// checkSyntax asserts an instruction encodes and decodes to the expected
|
||
// Intel-syntax string.
|
||
func checkSyntax(t *testing.T, want, mnemonic string, ops ...Operand) {
|
||
t.Helper()
|
||
_, got := decode(t, mnemonic, ops...)
|
||
if got != want {
|
||
t.Errorf("%s: got %q, want %q", mnemonic, got, want)
|
||
}
|
||
}
|
||
|
||
// checkOp asserts the decoded opcode (used for relative jumps, whose rendered
|
||
// target depends on the program counter).
|
||
func checkOp(t *testing.T, want x86asm.Op, mnemonic string, ops ...Operand) {
|
||
t.Helper()
|
||
inst, _ := decode(t, mnemonic, ops...)
|
||
if inst.Op != want {
|
||
t.Errorf("%s: got op %v, want %v", mnemonic, inst.Op, want)
|
||
}
|
||
}
|
||
|
||
func TestMov(t *testing.T) {
|
||
checkSyntax(t, "mov rbx, rax", "MOVQ", AX, BX)
|
||
checkSyntax(t, "mov ebx, eax", "MOVL", AX, BX)
|
||
checkSyntax(t, "mov bl, al", "MOVB", AL, BL)
|
||
checkSyntax(t, "mov rax, rbx", "MOVQ", BX, AX)
|
||
checkSyntax(t, "mov rbx, qword ptr [rax]", "MOVQ", Ptr(AX, 0, 8), BX)
|
||
checkSyntax(t, "mov qword ptr [rbx], rax", "MOVQ", AX, Ptr(BX, 0, 8))
|
||
checkSyntax(t, "mov rbx, qword ptr [rax+0x10]", "MOVQ", Ptr(AX, 0x10, 8), BX)
|
||
checkSyntax(t, "mov rbx, qword ptr [rsi+4*rbx]", "MOVQ", Idx(SI, BX, 4, 0, 8), BX)
|
||
// A small positive immediate compresses to the 32-bit zero-extending
|
||
// form (matching go tool asm), so the disassembler renders the 32-bit
|
||
// register name even for MOVQ.
|
||
checkSyntax(t, "mov eax, 0x5", "MOVQ", Imm(5), AX)
|
||
checkSyntax(t, "mov r8d, 0x5", "MOVQ", Imm(5), Reg{idx: 8, size: 8})
|
||
checkSyntax(t, "mov qword ptr [rax], 0x5", "MOVQ", Imm(5), Ptr(AX, 0, 8))
|
||
checkSyntax(t, "mov r12, r13", "MOVQ", Reg{idx: 13, size: 8}, Reg{idx: 12, size: 8})
|
||
}
|
||
|
||
func TestALU(t *testing.T) {
|
||
checkSyntax(t, "add rbx, rax", "ADDQ", AX, BX)
|
||
checkSyntax(t, "add rax, 0x1", "ADDQ", Imm(1), AX)
|
||
checkSyntax(t, "add rax, 0x12c", "ADDQ", Imm(300), AX)
|
||
checkSyntax(t, "sub rdx, rcx", "SUBQ", CX, DX)
|
||
checkSyntax(t, "and rbx, 0x7", "ANDQ", Imm(7), BX)
|
||
checkSyntax(t, "or rcx, rbx", "ORQ", BX, CX)
|
||
checkSyntax(t, "xor rax, rax", "XORQ", AX, AX)
|
||
checkSyntax(t, "cmp rsi, r10", "CMPQ", SI, Reg{idx: 10, size: 8})
|
||
checkSyntax(t, "add rbx, qword ptr [rax]", "ADDQ", Ptr(AX, 0, 8), BX)
|
||
checkSyntax(t, "add qword ptr [rax], rbx", "ADDQ", BX, Ptr(AX, 0, 8))
|
||
// The Go assembler rejects the immediate-first CMP spelling outright,
|
||
// so Encode errors instead of silently emitting the swapped form.
|
||
if _, err := Encode("CMPQ", Imm(-32), BX); err == nil {
|
||
t.Errorf("Encode(CMPQ imm-first) should error, got success")
|
||
}
|
||
// The Go assembler's own spelling: immediate second.
|
||
checkSyntax(t, "cmp ecx, 0x1f", "CMPL", CX, Imm(31))
|
||
checkSyntax(t, "cmp ecx, -0x80000000", "CMPL", CX, Imm(-2147483648))
|
||
checkSyntax(t, "cmp r9, -0x80000000", "CMPQ", Reg{idx: 9, size: 8}, Imm(-2147483648))
|
||
}
|
||
|
||
// TestScalarXmmRegMoves pins the Go-assembler byte forms of scalar
|
||
// MOVQ/MOVL between GPRs and XMM registers (66 REX.W 0F 6E/0F 7E) and the
|
||
// memory forms (F3 0F 7E load, 66 0F D6 store), all byte-for-byte.
|
||
func TestScalarXmmRegMoves(t *testing.T) {
|
||
cases := []struct {
|
||
name string
|
||
mnem string
|
||
ops []Operand
|
||
want string
|
||
}{
|
||
{"MOVQ AX,X1", "MOVQ", []Operand{AX, vreg(t, "X1")}, "66480f6ec8"},
|
||
{"MOVQ DX,X2", "MOVQ", []Operand{DX, vreg(t, "X2")}, "66480f6ed2"},
|
||
{"MOVQ X1,AX", "MOVQ", []Operand{vreg(t, "X1"), AX}, "66480f7ec8"},
|
||
{"MOVQ X0,DX", "MOVQ", []Operand{vreg(t, "X0"), DX}, "66480f7ec2"},
|
||
{"MOVL AX,X1", "MOVL", []Operand{AX, vreg(t, "X1")}, "660f6ec8"},
|
||
{"MOVL X1,AX", "MOVL", []Operand{vreg(t, "X1"), AX}, "660f7ec8"},
|
||
{"MOVQ (SI),X1", "MOVQ", []Operand{Ptr(SI, 0, 8), vreg(t, "X1")}, "f30f7e0e"},
|
||
{"MOVQ X3,(DI)", "MOVQ", []Operand{vreg(t, "X3"), Ptr(DI, 0, 8)}, "660fd61f"},
|
||
}
|
||
for _, c := range cases {
|
||
code, err := Encode(c.mnem, c.ops...)
|
||
if err != nil {
|
||
t.Errorf("%s: %v", c.name, err)
|
||
continue
|
||
}
|
||
if got := fmt.Sprintf("%x", code); got != c.want {
|
||
t.Errorf("%s: got %s, want %s", c.name, got, c.want)
|
||
}
|
||
}
|
||
}
|
||
|
||
// TestBadScale pins the go-tool-asm parity of rejecting SIB scales the
|
||
// hardware cannot encode.
|
||
func TestBadScale(t *testing.T) {
|
||
for _, sc := range []int{3, 5, 16, 32} {
|
||
if _, err := Encode("LEAQ", Idx(SI, BX, sc, 0, 8), AX); err == nil {
|
||
t.Errorf("LEAQ scale %d: expected error, got success", sc)
|
||
}
|
||
}
|
||
for _, sc := range []int{1, 2, 4, 8} {
|
||
if _, err := Encode("LEAQ", Idx(SI, BX, sc, 0, 8), AX); err != nil {
|
||
t.Errorf("LEAQ scale %d: %v", sc, err)
|
||
}
|
||
}
|
||
}
|
||
|
||
func TestLea(t *testing.T) {
|
||
checkSyntax(t, "lea r9, ptr [rsi+4*rbx]", "LEAQ", Idx(SI, BX, 4, 0, 8), Reg{idx: 9, size: 8})
|
||
checkSyntax(t, "lea rax, ptr [rbx+0x8]", "LEAQ", Ptr(BX, 0x8, 8), AX)
|
||
}
|
||
|
||
func TestTest(t *testing.T) {
|
||
checkSyntax(t, "test rax, rax", "TESTQ", AX, AX)
|
||
checkSyntax(t, "test rbx, 0x7", "TESTQ", Imm(7), BX)
|
||
}
|
||
|
||
func TestPushPop(t *testing.T) {
|
||
checkSyntax(t, "push rbx", "PUSHQ", BX)
|
||
checkSyntax(t, "pop r12", "POPQ", Reg{idx: 12, size: 8})
|
||
checkSyntax(t, "push 0x5", "PUSHQ", Imm(5))
|
||
// The W spelling carries the 0x66 operand-size prefix, byte for byte
|
||
// with go tool asm; the L and B spellings are illegal in 64-bit mode
|
||
// there and rejected here rather than silently widened.
|
||
cases := []struct {
|
||
name string
|
||
mnem string
|
||
ops []Operand
|
||
want string
|
||
}{
|
||
{"PUSHW AX", "PUSHW", []Operand{AX}, "6650"},
|
||
{"POPW AX", "POPW", []Operand{AX}, "6658"},
|
||
{"PUSHW $5", "PUSHW", []Operand{Imm(5)}, "666a05"},
|
||
{"PUSHW (AX)", "PUSHW", []Operand{Ptr(AX, 0, 2)}, "66ff30"},
|
||
{"PUSHQ AX", "PUSHQ", []Operand{AX}, "50"},
|
||
}
|
||
for _, c := range cases {
|
||
code, err := Encode(c.mnem, c.ops...)
|
||
if err != nil {
|
||
t.Errorf("%s: %v", c.name, err)
|
||
continue
|
||
}
|
||
if got := fmt.Sprintf("%x", code); got != c.want {
|
||
t.Errorf("%s: bytes %s, want %s", c.name, got, c.want)
|
||
}
|
||
}
|
||
for _, c := range []struct {
|
||
name string
|
||
mnem string
|
||
ops []Operand
|
||
}{
|
||
{"PUSHL AX", "PUSHL", []Operand{AX}},
|
||
{"PUSHL R8", "PUSHL", []Operand{Reg{idx: 8, size: 8}}},
|
||
{"POPL BX", "POPL", []Operand{BX}},
|
||
{"PUSHB AX", "PUSHB", []Operand{AX}},
|
||
} {
|
||
if _, err := Encode(c.mnem, c.ops...); err == nil {
|
||
t.Errorf("%s: expected an error, got none", c.name)
|
||
}
|
||
}
|
||
}
|
||
|
||
func TestUnary(t *testing.T) {
|
||
checkSyntax(t, "inc rax", "INCQ", AX)
|
||
checkSyntax(t, "dec rbx", "DECQ", BX)
|
||
checkSyntax(t, "neg rcx", "NEGQ", CX)
|
||
checkSyntax(t, "not rdx", "NOTQ", DX)
|
||
}
|
||
|
||
func TestShift(t *testing.T) {
|
||
checkSyntax(t, "shl rdx, 0x2", "SHLQ", Imm(2), DX)
|
||
checkSyntax(t, "shl rdx, cl", "SHLQ", CL, DX)
|
||
checkSyntax(t, "shl rdx, 0x1", "SHLQ", Imm(1), DX)
|
||
checkSyntax(t, "sar rcx, 0x1f", "SARQ", Imm(31), CX)
|
||
}
|
||
|
||
func TestImul(t *testing.T) {
|
||
checkSyntax(t, "imul rdx, rcx", "IMULQ", CX, DX)
|
||
checkSyntax(t, "imul edx, edx, 0x3", "IMULL", Imm(3), DX, DX)
|
||
checkSyntax(t, "imul rdx, rcx, 0x100", "IMULQ", Imm(256), CX, DX)
|
||
}
|
||
|
||
func TestControl(t *testing.T) {
|
||
checkSyntax(t, "ret", "RET")
|
||
checkSyntax(t, "nop", "NOP")
|
||
checkOp(t, x86asm.JMP, "JMP", Imm(0))
|
||
checkOp(t, x86asm.CALL, "CALL", Imm(0))
|
||
checkOp(t, x86asm.JGE, "JGE", Imm(0))
|
||
checkOp(t, x86asm.JNE, "JNE", Imm(0))
|
||
checkOp(t, x86asm.JBE, "JLS", Imm(0))
|
||
}
|
||
|
||
// TestIndirectControlFlow pins the indirect JMP/CALL forms: FF /4 for JMP and
|
||
// FF /2 for CALL through a register or memory. A REX appears only for the
|
||
// extended registers, never REX.W: the branch operand size is fixed at 64
|
||
// bits in long mode.
|
||
func TestIndirectControlFlow(t *testing.T) {
|
||
cases := []struct {
|
||
name string
|
||
mnem string
|
||
ops []Operand
|
||
want string
|
||
}{
|
||
{"JMP AX", "JMP", []Operand{AX}, "ffe0"},
|
||
{"CALL AX", "CALL", []Operand{AX}, "ffd0"},
|
||
{"JMP (BX)", "JMP", []Operand{Ptr(BX, 0, 8)}, "ff23"},
|
||
{"CALL (BX)", "CALL", []Operand{Ptr(BX, 0, 8)}, "ff13"},
|
||
{"JMP 8(BX)", "JMP", []Operand{Ptr(BX, 8, 8)}, "ff6308"},
|
||
{"CALL -16(BX)", "CALL", []Operand{Ptr(BX, -16, 8)}, "ff53f0"},
|
||
{"JMP R8", "JMP", []Operand{Reg{idx: 8, size: 2}}, "41ffe0"},
|
||
{"CALL R9", "CALL", []Operand{Reg{idx: 9, size: 2}}, "41ffd1"},
|
||
{"JMP R15", "JMP", []Operand{Reg{idx: 15, size: 2}}, "41ffe7"},
|
||
}
|
||
for _, c := range cases {
|
||
code, err := Encode(c.mnem, c.ops...)
|
||
if err != nil {
|
||
t.Errorf("%s: %v", c.name, err)
|
||
continue
|
||
}
|
||
if got := fmt.Sprintf("%x", code); got != c.want {
|
||
t.Errorf("%s: got %s, want %s", c.name, got, c.want)
|
||
}
|
||
}
|
||
}
|
||
|
||
// TestSSEMoveGroundTruth checks the legacy (non-VEX) SSE moves byte for byte
|
||
// against the Go assembler. wantOp is the decoder's name, which differs from
|
||
// the Plan 9 spelling for the octa moves (MOVOU = MOVDQU, MOVO = MOVDQA).
|
||
func TestSSEMoveGroundTruth(t *testing.T) {
|
||
cases := []struct {
|
||
name string
|
||
mnem string
|
||
ops []Operand
|
||
want string
|
||
wantOp string
|
||
}{
|
||
{"MOVOU (SI),X1", "MOVOU", []Operand{Ptr(SI, 0, 16), vreg(t, "X1")}, "f30f6f0e", "MOVDQU"},
|
||
{"MOVOU X3,(DI)", "MOVOU", []Operand{vreg(t, "X3"), Ptr(DI, 0, 16)}, "f30f7f1f", "MOVDQU"},
|
||
{"MOVOU X1,X2", "MOVOU", []Operand{vreg(t, "X1"), vreg(t, "X2")}, "f30f6fd1", "MOVDQU"},
|
||
{"MOVOU (SI)(BX*4),X9", "MOVOU", []Operand{Idx(SI, BX, 4, 0, 16), vreg(t, "X9")}, "f3440f6f0c9e", "MOVDQU"},
|
||
{"MOVO (SI),X1", "MOVO", []Operand{Ptr(SI, 0, 16), vreg(t, "X1")}, "660f6f0e", "MOVDQA"},
|
||
{"MOVO X3,(DI)", "MOVO", []Operand{vreg(t, "X3"), Ptr(DI, 0, 16)}, "660f7f1f", "MOVDQA"},
|
||
{"MOVUPS (SI),X1", "MOVUPS", []Operand{Ptr(SI, 0, 16), vreg(t, "X1")}, "0f100e", "MOVUPS"},
|
||
{"MOVAPS X3,(DI)", "MOVAPS", []Operand{vreg(t, "X3"), Ptr(DI, 0, 16)}, "0f291f", "MOVAPS"},
|
||
{"MOVUPD (SI),X1", "MOVUPD", []Operand{Ptr(SI, 0, 16), vreg(t, "X1")}, "660f100e", "MOVUPD"},
|
||
{"MOVAPD X3,(DI)", "MOVAPD", []Operand{vreg(t, "X3"), Ptr(DI, 0, 16)}, "660f291f", "MOVAPD"},
|
||
{"MOVSD (SI),X1", "MOVSD", []Operand{Ptr(SI, 0, 8), vreg(t, "X1")}, "f20f100e", "MOVSD_XMM"},
|
||
{"MOVSD X1,X2", "MOVSD", []Operand{vreg(t, "X1"), vreg(t, "X2")}, "f20f10d1", "MOVSD_XMM"},
|
||
{"MOVSS X3,(DI)", "MOVSS", []Operand{vreg(t, "X3"), Ptr(DI, 0, 4)}, "f30f111f", "MOVSS"},
|
||
}
|
||
for _, c := range cases {
|
||
code, err := Encode(c.mnem, c.ops...)
|
||
if err != nil {
|
||
t.Errorf("%s: Encode: %v", c.name, err)
|
||
continue
|
||
}
|
||
if got := hexCompact(code); got != c.want {
|
||
t.Errorf("%s: bytes %s, want %s", c.name, got, c.want)
|
||
continue
|
||
}
|
||
inst, err := x86asm.Decode(code, 64)
|
||
if err != nil {
|
||
t.Errorf("%s: Decode(%x): %v", c.name, code, err)
|
||
continue
|
||
}
|
||
if inst.Op.String() != c.wantOp {
|
||
t.Errorf("%s: decoded as %s", c.name, inst.Op.String())
|
||
}
|
||
}
|
||
}
|
||
|
||
// TestGoFlacScalarTail encodes the scalar tail of an analyze kernel to confirm
|
||
// the encoder handles a realistic instruction sequence.
|
||
func TestGoFlacScalarTail(t *testing.T) {
|
||
// MOVQ swin_base+0(FP), SI; modelled as MOVQ disp(reg), reg.
|
||
checkSyntax(t, "mov rsi, qword ptr [rax+0x10]", "MOVQ", Ptr(AX, 0x10, 8), SI)
|
||
checkSyntax(t, "lea r9, ptr [rsi+4*rbx]", "LEAQ", Idx(SI, BX, 4, 0, 8), Reg{idx: 9, size: 8})
|
||
checkSyntax(t, "and r10, -0x8", "ANDQ", Imm(-8), Reg{idx: 10, size: 8})
|
||
}
|
||
|
||
// TestScalarGroundTruth checks the scalar instruction families the go-flac
|
||
// kernels use beyond the basic set, byte for byte against the Go assembler's
|
||
// machine code. wantOp is the x86 decoder's name, which differs from the
|
||
// Plan 9 spelling for some of these (CMOVLGT → CMOVG, MOVBLZX → MOVZX, …).
|
||
func TestScalarGroundTruth(t *testing.T) {
|
||
r8 := Reg{idx: 8, size: 8}
|
||
r9 := Reg{idx: 9, size: 8}
|
||
r9w := Reg{idx: 9, size: 2}
|
||
r8w := Reg{idx: 8, size: 2}
|
||
r13 := Reg{idx: 13, size: 8}
|
||
cases := []struct {
|
||
name string
|
||
mnem string
|
||
ops []Operand
|
||
want string
|
||
wantOp string
|
||
}{
|
||
{"LZCNTL AX,CX", "LZCNTL", []Operand{AX, CX}, "f30fbdc8", "LZCNT"},
|
||
{"LZCNTQ R8,R9", "LZCNTQ", []Operand{r8, r9}, "f34d0fbdc8", "LZCNT"},
|
||
{"LZCNTW AX,CX", "LZCNTW", []Operand{AX, CX}, "66f30fbdc8", "LZCNT"},
|
||
{"TZCNTL AX,CX", "TZCNTL", []Operand{AX, CX}, "f30fbcc8", "TZCNT"},
|
||
// Bit scan: BSF/BSR are the unprefixed forms of TZCNT/LZCNT's map.
|
||
{"BSFL AX,CX", "BSFL", []Operand{AX, CX}, "0fbcc8", "BSF"},
|
||
{"BSFQ R8,R9", "BSFQ", []Operand{r8, r9}, "4d0fbcc8", "BSF"},
|
||
{"BSFW AX,CX", "BSFW", []Operand{AX, CX}, "660fbcc8", "BSF"},
|
||
{"BSRL AX,CX", "BSRL", []Operand{AX, CX}, "0fbdc8", "BSR"},
|
||
{"BSRQ AX,CX", "BSRQ", []Operand{AX, CX}, "480fbdc8", "BSR"},
|
||
{"POPCNTL AX,CX", "POPCNTL", []Operand{AX, CX}, "f30fb8c8", "POPCNT"},
|
||
{"POPCNTQ R8,R9", "POPCNTQ", []Operand{r8, r9}, "f34d0fb8c8", "POPCNT"},
|
||
// A 64-bit immediate that fits a signed int32 is compressed exactly
|
||
// as the Go assembler does: positive via B8+rd without REX.W
|
||
// (zero-extended), negative via REX.W C7 /0 (sign-extended).
|
||
{"MOVQ $4,BX", "MOVQ", []Operand{Imm(4), BX}, "bb04000000", "MOV"},
|
||
{"MOVQ $4,R8", "MOVQ", []Operand{Imm(4), r8}, "41b804000000", "MOV"},
|
||
{"MOVQ $-1,BX", "MOVQ", []Operand{Imm(-1), BX}, "48c7c3ffffffff", "MOV"},
|
||
{"MOVQ big,BX", "MOVQ", []Operand{Imm(0x1122334455667788), BX}, "48bb8877665544332211", "MOV"},
|
||
{"CMOVLGT CX,AX", "CMOVLGT", []Operand{CX, AX}, "0f4fc1", "CMOVG"},
|
||
{"CMOVLEQ CX,AX", "CMOVLEQ", []Operand{CX, AX}, "0f44c1", "CMOVE"},
|
||
{"CMOVQGT R9,R8", "CMOVQGT", []Operand{r9, r8}, "4d0f4fc1", "CMOVG"},
|
||
{"CMOVWLS R9W,R8W", "CMOVWLS", []Operand{r9w, r8w}, "66450f46c1", "CMOVBE"},
|
||
{"SETNE AL", "SETNE", []Operand{AL}, "0f95c0", "SETNE"},
|
||
{"SETNE (AX)", "SETNE", []Operand{Ptr(AX, 0, 1)}, "0f9500", "SETNE"},
|
||
{"MOVBLZX AL,CX", "MOVBLZX", []Operand{AL, CX}, "0fb6c8", "MOVZX"},
|
||
{"MOVBLZX (SI),CX", "MOVBLZX", []Operand{Ptr(SI, 0, 1), CX}, "0fb60e", "MOVZX"},
|
||
{"MOVWLSX (SI)(AX*1),CX", "MOVWLSX", []Operand{Idx(SI, AX, 1, 0, 2), CX}, "0fbf0c06", "MOVSX"},
|
||
{"MOVLQSX CX,R8", "MOVLQSX", []Operand{CX, r8}, "4c63c1", "MOVSXD"},
|
||
{"MOVBQZX AL,R8", "MOVBQZX", []Operand{AL, r8}, "4c0fb6c0", "MOVZX"},
|
||
{"MOVWLZX AX,CX", "MOVWLZX", []Operand{AX, CX}, "0fb7c8", "MOVZX"},
|
||
{"MOVWQZX AX,R8", "MOVWQZX", []Operand{AX, r8}, "4c0fb7c0", "MOVZX"},
|
||
// The width pairs the toolchain accepts and GOROOT uses; bytes
|
||
// pinned from go tool asm (see testdata/verify/widen_amd64.s).
|
||
{"MOVBWZX (BX),R11W", "MOVBWZX", []Operand{Ptr(BX, 0, 1), Reg{idx: 11, size: 2}}, "66440fb61b", "MOVZX"},
|
||
{"MOVBWSX (BX),R11W", "MOVBWSX", []Operand{Ptr(BX, 0, 1), Reg{idx: 11, size: 2}}, "66440fbe1b", "MOVSX"},
|
||
{"MOVBLSX (BX),AX", "MOVBLSX", []Operand{Ptr(BX, 0, 1), AX}, "0fbe03", "MOVSX"},
|
||
{"MOVBQSX (BX),R8", "MOVBQSX", []Operand{Ptr(BX, 0, 1), r8}, "4c0fbe03", "MOVSX"},
|
||
{"MOVWQSX (BX),R9", "MOVWQSX", []Operand{Ptr(BX, 0, 2), r9}, "4c0fbf0b", "MOVSX"},
|
||
// A long to quad zero-extend is a plain 32-bit move.
|
||
{"MOVLQZX (BX),DX", "MOVLQZX", []Operand{Ptr(BX, 0, 4), DX}, "8b13", "MOV"},
|
||
{"MOVLQZX AX,DX", "MOVLQZX", []Operand{AX, DX}, "8bd0", "MOV"},
|
||
{"PMOVMSKB X1,AX", "PMOVMSKB", []Operand{vreg(t, "X1"), AX}, "660fd7c1", "PMOVMSKB"},
|
||
{"PMOVMSKB X11,CX", "PMOVMSKB", []Operand{vreg(t, "X11"), CX}, "66410fd7cb", "PMOVMSKB"},
|
||
{"CVTSL2SD R8,X13", "CVTSL2SD", []Operand{r8, vreg(t, "X13")}, "f2450f2ae8", "CVTSI2SD"},
|
||
{"CVTSL2SD AX,X0", "CVTSL2SD", []Operand{AX, vreg(t, "X0")}, "f20f2ac0", "CVTSI2SD"},
|
||
{"CVTSQ2SD R8,X13", "CVTSQ2SD", []Operand{r8, vreg(t, "X13")}, "f24d0f2ae8", "CVTSI2SD"},
|
||
{"INCW (R13)(AX*2)", "INCW", []Operand{Idx(r13, AX, 2, 0, 2)}, "6641ff444500", "INC"},
|
||
// The traditional three-operand IMUL spelling.
|
||
{"IMUL3L $31,CX,DX", "IMUL3L", []Operand{Imm(31), CX, DX}, "6bd11f", "IMUL"},
|
||
{"IMUL3L $256,CX,DX", "IMUL3L", []Operand{Imm(256), CX, DX}, "69d100010000", "IMUL"},
|
||
{"IMUL3Q $7,R9,R8", "IMUL3Q", []Operand{Imm(7), r9, r8}, "4d6bc107", "IMUL"},
|
||
{"IMUL3W $5,CX,DX", "IMUL3W", []Operand{Imm(5), CX, DX}, "666bd105", "IMUL"},
|
||
// Negative displacement with base + index (regression: the parser
|
||
// used to drop the whole address).
|
||
{"LEAQ -4(DX)(R9*4),R9", "LEAQ", []Operand{Idx(DX, r9, 4, -4, 8), r9}, "4e8d4c8afc", "LEA"},
|
||
{"LEAQ 16(SI)(BX*4),R10", "LEAQ", []Operand{Idx(SI, BX, 4, 16, 8), Reg{idx: 10, size: 8}}, "4c8d549e10", "LEA"},
|
||
// Register-to-register MOV uses the r/m←r opcode (reg = source), the
|
||
// Go assembler's choice.
|
||
{"MOVQ BX,R10", "MOVQ", []Operand{BX, Reg{idx: 10, size: 8}}, "4989da", "MOV"},
|
||
{"MOVQ AX,BX", "MOVQ", []Operand{AX, BX}, "4889c3", "MOV"},
|
||
{"MOVL AX,BX", "MOVL", []Operand{AX, BX}, "89c3", "MOV"},
|
||
{"MOVB AL,BL", "MOVB", []Operand{AL, BL}, "88c3", "MOV"},
|
||
{"MOVW AX,BX", "MOVW", []Operand{AX, BX}, "6689c3", "MOV"},
|
||
{"MOVQ R12,R13", "MOVQ", []Operand{Reg{idx: 12, size: 8}, Reg{idx: 13, size: 8}}, "4d89e5", "MOV"},
|
||
// CMP must record first − second: with a register second operand the
|
||
// first goes in r/m, with a memory second operand the first goes in reg.
|
||
{"CMPQ SI,R10", "CMPQ", []Operand{SI, Reg{idx: 10, size: 8}}, "4c39d6", "CMP"},
|
||
{"CMPQ SI,(AX)", "CMPQ", []Operand{SI, Ptr(AX, 0, 8)}, "483b30", "CMP"},
|
||
{"CMPQ (AX),SI", "CMPQ", []Operand{Ptr(AX, 0, 8), SI}, "483930", "CMP"},
|
||
{"CMPL CX,(AX)", "CMPL", []Operand{CX, Ptr(AX, 0, 4)}, "3b08", "CMP"},
|
||
{"CMPB AL,(BX)", "CMPB", []Operand{AL, Ptr(BX, 0, 1)}, "3a03", "CMP"},
|
||
{"CMPW AX,BX", "CMPW", []Operand{AX, BX}, "6639d8", "CMP"},
|
||
}
|
||
for _, c := range cases {
|
||
code, err := Encode(c.mnem, c.ops...)
|
||
if err != nil {
|
||
t.Errorf("%s: Encode: %v", c.name, err)
|
||
continue
|
||
}
|
||
if got := strings.ReplaceAll(hexBytes(code), " ", ""); got != c.want {
|
||
t.Errorf("%s: bytes %s, want %s", c.name, got, c.want)
|
||
continue
|
||
}
|
||
inst, err := x86asm.Decode(code, 64)
|
||
if err != nil {
|
||
t.Errorf("%s: Decode(% x): %v", c.name, code, err)
|
||
continue
|
||
}
|
||
if inst.Op.String() != c.wantOp {
|
||
t.Errorf("%s: decoded as %s", c.name, inst.Op.String())
|
||
}
|
||
}
|
||
}
|
||
|
||
// TestScalarErrors checks that malformed conditional / extend / convert
|
||
// instructions are rejected.
|
||
func TestScalarErrors(t *testing.T) {
|
||
cases := []struct {
|
||
name string
|
||
mnem string
|
||
ops []Operand
|
||
}{
|
||
{"CMOV arity", "CMOVLGT", []Operand{AX}},
|
||
{"CMOV bare", "CMOV", []Operand{AX, BX}},
|
||
{"CMOV bad size", "CMOVBGT", []Operand{AX, BX}},
|
||
{"CMOV bad condition", "CMOVLXX", []Operand{AX, BX}},
|
||
{"CMOV mem dst", "CMOVLGT", []Operand{AX, Ptr(BX, 0, 4)}},
|
||
{"SET arity", "SETNE", []Operand{AL, BL}},
|
||
{"SET bad condition", "SETXX", []Operand{AL}},
|
||
{"SET bare", "SET", []Operand{AL}},
|
||
{"LZCNT arity", "LZCNTL", []Operand{AX}},
|
||
{"LZCNT mem dst", "LZCNTL", []Operand{AX, Ptr(BX, 0, 4)}},
|
||
{"MOVBLZX mem dst", "MOVBLZX", []Operand{AL, Ptr(BX, 0, 4)}},
|
||
{"CVTSL2SD gpr dst", "CVTSL2SD", []Operand{AX, BX}},
|
||
}
|
||
for _, c := range cases {
|
||
if _, err := Encode(c.mnem, c.ops...); err == nil {
|
||
t.Errorf("%s: expected an error, got none", c.name)
|
||
}
|
||
}
|
||
}
|
||
|
||
// TestImmediateOutOfRange pins the go-tool-asm parity of the immediate and
|
||
// displacement spans: a scalar immediate must fit a signed or unsigned 32-bit
|
||
// word (only MOVQ reg, $imm takes the full int64), a scalar shift count must
|
||
// be an unsigned byte, and a displacement must fit int32. Every rejected
|
||
// shape here is rejected by `go tool asm` too; every accepted one encodes the
|
||
// same bytes.
|
||
func TestImmediateOutOfRange(t *testing.T) {
|
||
cases := []struct {
|
||
name string
|
||
mnem string
|
||
ops []Operand
|
||
}{
|
||
{"SHLQ count 300", "SHLQ", []Operand{Imm(300), AX}},
|
||
{"SHLQ count -1", "SHLQ", []Operand{Imm(-1), AX}},
|
||
{"SHLW count 256", "SHLW", []Operand{Imm(256), DX}},
|
||
{"SHLB count 300", "SHLB", []Operand{Imm(300), BL}},
|
||
{"MOVL imm32+", "MOVL", []Operand{Imm(4294967296), AX}},
|
||
{"MOVL imm32-", "MOVL", []Operand{Imm(-2147483649), AX}},
|
||
{"MOVW imm32+", "MOVW", []Operand{Imm(4294967296), AX}},
|
||
{"MOVB imm32+", "MOVB", []Operand{Imm(4294967296), AL}},
|
||
{"ADDB imm32+", "ADDB", []Operand{Imm(4294967296), AL}},
|
||
{"ADDL imm32+", "ADDL", []Operand{Imm(4294967296), AX}},
|
||
{"ADDQ imm32+", "ADDQ", []Operand{Imm(8589934592), AX}},
|
||
{"CMPQ imm32+", "CMPQ", []Operand{AX, Imm(4294967296)}},
|
||
{"CMPQ imm32-", "CMPQ", []Operand{AX, Imm(-2147483649)}},
|
||
{"TESTL imm32+", "TESTL", []Operand{Imm(4294967296), AX}},
|
||
{"IMUL3L imm32+", "IMUL3L", []Operand{Imm(4294967296), CX, DX}},
|
||
{"PUSHQ imm32+", "PUSHQ", []Operand{Imm(4294967296)}},
|
||
{"MOVQ mem imm32+", "MOVQ", []Operand{Imm(4294967296), Ptr(AX, 0, 8)}},
|
||
{"disp32+", "MOVQ", []Operand{Ptr(AX, 4294967296, 8), BX}},
|
||
{"disp32+ max", "MOVQ", []Operand{Ptr(AX, 2147483648, 8), BX}},
|
||
{"disp32-", "MOVQ", []Operand{Ptr(AX, -2147483649, 8), BX}},
|
||
{"VEX disp32+", "VMOVDQU", []Operand{Ptr(AX, 4294967296, 32), vreg(t, "Y1")}},
|
||
{"EVEX disp32+", "VMOVDQU32", []Operand{Ptr(AX, 4294967296, 64), vreg(t, "Z1")}},
|
||
}
|
||
for _, c := range cases {
|
||
if _, err := Encode(c.mnem, c.ops...); err == nil {
|
||
t.Errorf("%s: expected an error, got none", c.name)
|
||
}
|
||
}
|
||
}
|
||
|
||
// TestImmediateTruncation pins the toolchain-matching truncations inside the
|
||
// accepted 32-bit span: the narrower fields take the low bits silently, byte
|
||
// for byte with `go tool asm` (which rejects none of these).
|
||
func TestImmediateTruncation(t *testing.T) {
|
||
cases := []struct {
|
||
name string
|
||
mnem string
|
||
ops []Operand
|
||
want string
|
||
}{
|
||
{"ADDB $256,BL", "ADDB", []Operand{Imm(256), BL}, "80c300"},
|
||
{"ADDB $1000,BL", "ADDB", []Operand{Imm(1000), BL}, "80c3e8"},
|
||
{"MOVB $256,AL", "MOVB", []Operand{Imm(256), AL}, "b000"},
|
||
{"MOVB $-129,AL", "MOVB", []Operand{Imm(-129), AL}, "b07f"},
|
||
{"MOVW $65536,AX", "MOVW", []Operand{Imm(65536), AX}, "66b80000"},
|
||
{"MOVW $65535,AX", "MOVW", []Operand{Imm(65535), AX}, "66b8ffff"},
|
||
{"MOVW $-32769,AX", "MOVW", []Operand{Imm(-32769), AX}, "66b8ff7f"},
|
||
{"MOVL $4294967295,AX", "MOVL", []Operand{Imm(4294967295), AX}, "b8ffffffff"},
|
||
{"ADDQ $4294967295,AX", "ADDQ", []Operand{Imm(4294967295), AX}, "4805ffffffff"},
|
||
{"CMPB BL,$255", "CMPB", []Operand{BL, Imm(255)}, "80fbff"},
|
||
{"CMPQ AX,$4294967295", "CMPQ", []Operand{AX, Imm(4294967295)}, "483dffffffff"},
|
||
{"MOVQ $4294967295,0(AX)", "MOVQ", []Operand{Imm(4294967295), Ptr(AX, 0, 8)}, "48c700ffffffff"},
|
||
{"SHLQ $255,AX", "SHLQ", []Operand{Imm(255), AX}, "48c1e0ff"},
|
||
{"SHLQ $0,AX", "SHLQ", []Operand{Imm(0), AX}, "48c1e000"},
|
||
// The one form beyond the 32-bit span: the imm64 MOVQ register move.
|
||
{"MOVQ $4294967296,AX", "MOVQ", []Operand{Imm(4294967296), AX}, "48b80000000001000000"},
|
||
{"MOVQ disp32 max", "MOVQ", []Operand{Ptr(AX, 2147483647, 8), BX}, "488b98ffffff7f"},
|
||
}
|
||
for _, c := range cases {
|
||
code, err := Encode(c.mnem, c.ops...)
|
||
if err != nil {
|
||
t.Errorf("%s: %v", c.name, err)
|
||
continue
|
||
}
|
||
if got := fmt.Sprintf("%x", code); got != c.want {
|
||
t.Errorf("%s: bytes %s, want %s", c.name, got, c.want)
|
||
}
|
||
}
|
||
}
|
||
|
||
// TestEncodableCmovSize pins the linter contract for CMOVcc: Encodable must
|
||
// reject the spellings Encode rejects, so a mnemonic like CMOVBGT (no size
|
||
// letter) is not reported as encodable.
|
||
func TestEncodableCmovSize(t *testing.T) {
|
||
for _, m := range []string{"CMOVBGT", "CMOVXEQ", "CMOVB", "CMOV", "CMOVWXX"} {
|
||
if Encodable(m) {
|
||
t.Errorf("Encodable(%q) = true, want false", m)
|
||
}
|
||
}
|
||
for _, m := range []string{"CMOVLGT", "CMOVQGT", "CMOVWLS", "CMOVLEQ"} {
|
||
if !Encodable(m) {
|
||
t.Errorf("Encodable(%q) = false, want true", m)
|
||
}
|
||
}
|
||
}
|
||
|
||
// TestCarryShiftMulGroundTruth pins the carry-flag ALU family (ADC/SBB with
|
||
// their accumulator immediate forms), the rotate family, MUL/DIV/IDIV and the
|
||
// bit-test family byte for byte against go tool asm (see
|
||
// testdata/verify/scalar_amd64.s).
|
||
func TestCarryShiftMulGroundTruth(t *testing.T) {
|
||
cases := []struct {
|
||
name string
|
||
mnem string
|
||
ops []Operand
|
||
want string
|
||
}{
|
||
{"ADCQ AX,BX", "ADCQ", []Operand{AX, BX}, "4811c3"},
|
||
{"ADCL AX,BX", "ADCL", []Operand{AX, BX}, "11c3"},
|
||
{"ADCB AL,BL", "ADCB", []Operand{AL, BL}, "10c3"},
|
||
{"ADCW AX,BX", "ADCW", []Operand{AX, BX}, "6611c3"},
|
||
{"SBBQ AX,BX", "SBBQ", []Operand{AX, BX}, "4819c3"},
|
||
{"ADCQ $5,BX", "ADCQ", []Operand{Imm(5), BX}, "4883d305"},
|
||
{"ADCQ $300,BX", "ADCQ", []Operand{Imm(300), BX}, "4881d32c010000"},
|
||
{"ADCQ $300,AX", "ADCQ", []Operand{Imm(300), AX}, "48152c010000"},
|
||
{"ADCB $5,AL", "ADCB", []Operand{Imm(5), AL}, "1405"},
|
||
{"SBBQ $300,AX", "SBBQ", []Operand{Imm(300), AX}, "481d2c010000"},
|
||
{"ADCQ AX,(BX)", "ADCQ", []Operand{AX, Ptr(BX, 0, 8)}, "481103"},
|
||
{"ROLQ $3,AX", "ROLQ", []Operand{Imm(3), AX}, "48c1c003"},
|
||
{"ROLL CX,BX", "ROLL", []Operand{CL, BX}, "d3c3"},
|
||
{"RORQ CL,AX", "RORQ", []Operand{CL, AX}, "48d3c8"},
|
||
{"RCRQ $1,BX", "RCRQ", []Operand{Imm(1), BX}, "48d1db"},
|
||
{"RCLQ $3,AX", "RCLQ", []Operand{Imm(3), AX}, "48c1d003"},
|
||
{"RORB CL,BL", "RORB", []Operand{CL, BL}, "d2cb"},
|
||
{"SALQ $2,AX", "SALQ", []Operand{Imm(2), AX}, "48c1e002"},
|
||
{"ROLW $1,AX", "ROLW", []Operand{Imm(1), AX}, "66d1c0"},
|
||
{"MULQ CX", "MULQ", []Operand{CX}, "48f7e1"},
|
||
{"MULL CX", "MULL", []Operand{CX}, "f7e1"},
|
||
{"MULB CL", "MULB", []Operand{CL}, "f6e1"},
|
||
{"DIVL CX", "DIVL", []Operand{CX}, "f7f1"},
|
||
{"IDIVQ CX", "IDIVQ", []Operand{CX}, "48f7f9"},
|
||
{"MULW CX", "MULW", []Operand{CX}, "66f7e1"},
|
||
{"BTQ AX,DX", "BTQ", []Operand{AX, DX}, "480fa3c2"},
|
||
{"BTL AX,DX", "BTL", []Operand{AX, DX}, "0fa3c2"},
|
||
{"BTW AX,DX", "BTW", []Operand{AX, DX}, "660fa3c2"},
|
||
{"BTQ $3,BX", "BTQ", []Operand{Imm(3), BX}, "480fbae303"},
|
||
{"BTQ $3,(AX)", "BTQ", []Operand{Imm(3), Ptr(AX, 0, 8)}, "480fba2003"},
|
||
{"BTSQ $5,BX", "BTSQ", []Operand{Imm(5), BX}, "480fbaeb05"},
|
||
{"BTCQ AX,BX", "BTCQ", []Operand{AX, BX}, "480fbbc3"},
|
||
{"BTRQ $7,BX", "BTRQ", []Operand{Imm(7), BX}, "480fbaf307"},
|
||
}
|
||
for _, c := range cases {
|
||
code, err := Encode(c.mnem, c.ops...)
|
||
if err != nil {
|
||
t.Errorf("%s: Encode: %v", c.name, err)
|
||
continue
|
||
}
|
||
if got := fmt.Sprintf("%x", code); got != c.want {
|
||
t.Errorf("%s = %s, want %s", c.name, got, c.want)
|
||
}
|
||
}
|
||
// The bit-test immediate is an unsigned bit index with the negative
|
||
// spelling accepted, the shuffle convention: BTQ $300 must be rejected.
|
||
if _, err := Encode("BTQ", Imm(300), AX); err == nil {
|
||
t.Errorf("BTQ $300: expected an error, got none")
|
||
}
|
||
}
|
||
|
||
// TestAtomicSystemGroundTruth pins the exchange/compare-exchange/accumulate
|
||
// family, the string primitives, the flag and system instructions, the MXCSR
|
||
// pair, the scalar float-to-int conversions and the x87 FMOVD byte for byte
|
||
// against go tool asm (see testdata/verify/atomics_amd64.s and
|
||
// testdata/verify/system_amd64.s).
|
||
func TestAtomicSystemGroundTruth(t *testing.T) {
|
||
r8 := Reg{idx: 8, size: 8}
|
||
cases := []struct {
|
||
name string
|
||
mnem string
|
||
ops []Operand
|
||
want string
|
||
}{
|
||
{"XCHGQ AX,BX", "XCHGQ", []Operand{AX, BX}, "4893"},
|
||
{"XCHGQ BX,AX", "XCHGQ", []Operand{BX, AX}, "4893"},
|
||
{"XCHGL AX,BX", "XCHGL", []Operand{AX, BX}, "93"},
|
||
{"XCHGB AL,BL", "XCHGB", []Operand{AL, BL}, "86c3"},
|
||
{"XCHGW AX,BX", "XCHGW", []Operand{AX, BX}, "6693"},
|
||
{"XCHGQ R8,R9", "XCHGQ", []Operand{r8, Reg{idx: 9, size: 8}}, "4d87c1"},
|
||
{"XCHGQ BX,(AX)", "XCHGQ", []Operand{BX, Ptr(AX, 0, 8)}, "488718"},
|
||
{"XCHGQ (AX),BX", "XCHGQ", []Operand{Ptr(AX, 0, 8), BX}, "488718"},
|
||
{"XCHGQ AX,(BX)", "XCHGQ", []Operand{AX, Ptr(BX, 0, 8)}, "488703"},
|
||
{"CMPXCHGL AX,BX", "CMPXCHGL", []Operand{AX, BX}, "0fb1c3"},
|
||
{"CMPXCHGQ AX,(BX)", "CMPXCHGQ", []Operand{AX, Ptr(BX, 0, 8)}, "480fb103"},
|
||
{"CMPXCHGB AL,(BX)", "CMPXCHGB", []Operand{AL, Ptr(BX, 0, 1)}, "0fb003"},
|
||
{"CMPXCHGW AX,BX", "CMPXCHGW", []Operand{AX, BX}, "660fb1c3"},
|
||
{"XADDL AX,BX", "XADDL", []Operand{AX, BX}, "0fc1c3"},
|
||
{"XADDQ AX,(BX)", "XADDQ", []Operand{AX, Ptr(BX, 0, 8)}, "480fc103"},
|
||
{"XADDB AL,(BX)", "XADDB", []Operand{AL, Ptr(BX, 0, 1)}, "0fc003"},
|
||
{"XADDW AX,BX", "XADDW", []Operand{AX, BX}, "660fc1c3"},
|
||
{"ADCXL AX,CX", "ADCXL", []Operand{AX, CX}, "660f38f6c8"},
|
||
{"ADCXQ AX,CX", "ADCXQ", []Operand{AX, CX}, "66480f38f6c8"},
|
||
{"ADOXL AX,CX", "ADOXL", []Operand{AX, CX}, "f30f38f6c8"},
|
||
{"ADOXQ AX,CX", "ADOXQ", []Operand{AX, CX}, "f3480f38f6c8"},
|
||
{"CRC32B AX,CX", "CRC32B", []Operand{AX, CX}, "f20f38f0c8"},
|
||
{"CRC32W AX,CX", "CRC32W", []Operand{AX, CX}, "66f20f38f1c8"},
|
||
{"CRC32L AX,CX", "CRC32L", []Operand{AX, CX}, "f20f38f1c8"},
|
||
{"CRC32Q AX,CX", "CRC32Q", []Operand{AX, CX}, "f2480f38f1c8"},
|
||
{"CRC32L (AX),CX", "CRC32L", []Operand{Ptr(AX, 0, 4), CX}, "f20f38f108"},
|
||
{"MOVSQ", "MOVSQ", []Operand{}, "48a5"},
|
||
{"MOVSL", "MOVSL", []Operand{}, "a5"},
|
||
{"MOVSB", "MOVSB", []Operand{}, "a4"},
|
||
{"MOVSW", "MOVSW", []Operand{}, "66a5"},
|
||
{"STOSB", "STOSB", []Operand{}, "aa"},
|
||
{"STOSQ", "STOSQ", []Operand{}, "48ab"},
|
||
{"STOSL", "STOSL", []Operand{}, "ab"},
|
||
{"STOSW", "STOSW", []Operand{}, "66ab"},
|
||
{"CLD", "CLD", []Operand{}, "fc"},
|
||
{"STD", "STD", []Operand{}, "fd"},
|
||
{"POPFQ", "POPFQ", []Operand{}, "9d"},
|
||
{"PUSHFQ", "PUSHFQ", []Operand{}, "9c"},
|
||
{"CPUID", "CPUID", []Operand{}, "0fa2"},
|
||
{"RDTSC", "RDTSC", []Operand{}, "0f31"},
|
||
{"RDTSCP", "RDTSCP", []Operand{}, "0f01f9"},
|
||
{"SYSCALL", "SYSCALL", []Operand{}, "0f05"},
|
||
{"XGETBV", "XGETBV", []Operand{}, "0f01d0"},
|
||
{"PAUSE", "PAUSE", []Operand{}, "f390"},
|
||
{"LFENCE", "LFENCE", []Operand{}, "0faee8"},
|
||
{"MFENCE", "MFENCE", []Operand{}, "0faef0"},
|
||
{"SFENCE", "SFENCE", []Operand{}, "0faef8"},
|
||
{"UNDEF", "UNDEF", []Operand{}, "0f0b"},
|
||
{"INT $3", "INT", []Operand{Imm(3)}, "cd03"},
|
||
{"LDMXCSR (AX)", "LDMXCSR", []Operand{Ptr(AX, 0, 4)}, "0fae10"},
|
||
{"STMXCSR (AX)", "STMXCSR", []Operand{Ptr(AX, 0, 4)}, "0fae18"},
|
||
{"CVTSD2SL X0,AX", "CVTSD2SL", []Operand{vreg(t, "X0"), AX}, "f20f2dc0"},
|
||
{"CVTTSD2SQ X0,AX", "CVTTSD2SQ", []Operand{vreg(t, "X0"), AX}, "f2480f2cc0"},
|
||
{"CVTTSD2SL X0,AX", "CVTTSD2SL", []Operand{vreg(t, "X0"), AX}, "f20f2cc0"},
|
||
{"CVTSS2SQ X0,AX", "CVTSS2SQ", []Operand{vreg(t, "X0"), AX}, "f3480f2dc0"},
|
||
{"FMOVD (AX),F0", "FMOVD", []Operand{Ptr(AX, 0, 8), vreg(t, "F0")}, "dd00"},
|
||
{"FMOVD F0,(AX)", "FMOVD", []Operand{vreg(t, "F0"), Ptr(AX, 0, 8)}, "dd10"},
|
||
{"FMOVD F0,F1", "FMOVD", []Operand{vreg(t, "F0"), vreg(t, "F1")}, "ddd1"},
|
||
{"MOVD AX,X0", "MOVD", []Operand{AX, vreg(t, "X0")}, "66480f6ec0"},
|
||
{"MOVD X0,AX", "MOVD", []Operand{vreg(t, "X0"), AX}, "66480f7ec0"},
|
||
{"MOVD X0,X1", "MOVD", []Operand{vreg(t, "X0"), vreg(t, "X1")}, "f30f7ec8"},
|
||
{"MOVD (AX),X0", "MOVD", []Operand{Ptr(AX, 0, 8), vreg(t, "X0")}, "f30f7e00"},
|
||
{"MOVD X0,(AX)", "MOVD", []Operand{vreg(t, "X0"), Ptr(AX, 0, 8)}, "660fd600"},
|
||
}
|
||
for _, c := range cases {
|
||
code, err := Encode(c.mnem, c.ops...)
|
||
if err != nil {
|
||
t.Errorf("%s: Encode: %v", c.name, err)
|
||
continue
|
||
}
|
||
if got := fmt.Sprintf("%x", code); got != c.want {
|
||
t.Errorf("%s = %s, want %s", c.name, got, c.want)
|
||
}
|
||
}
|
||
// LDMXCSR/STMXCSR take a memory operand only.
|
||
if _, err := Encode("LDMXCSR", AX); err == nil {
|
||
t.Errorf("LDMXCSR AX: expected an error, got none")
|
||
}
|
||
}
|
||
|
||
// TestSSEGapsGroundTruth pins the legacy SSE gap families: the scalar
|
||
// compare and square root, the Plan 9 packed spellings, the imm8-controlled
|
||
// shuffles, the lane extracts and inserts, the packed integer shifts and the
|
||
// AES/SHA round instructions, byte for byte against go tool asm (see
|
||
// testdata/verify/crypto_amd64.s and testdata/verify/sse_amd64.s).
|
||
func TestSSEGapsGroundTruth(t *testing.T) {
|
||
cases := []struct {
|
||
name string
|
||
mnem string
|
||
ops []Operand
|
||
want string
|
||
}{
|
||
{"ANDNPD X0,X1", "ANDNPD", []Operand{vreg(t, "X0"), vreg(t, "X1")}, "660f55c8"},
|
||
{"ANDNPS X0,X1", "ANDNPS", []Operand{vreg(t, "X0"), vreg(t, "X1")}, "0f55c8"},
|
||
{"COMISD X0,X1", "COMISD", []Operand{vreg(t, "X0"), vreg(t, "X1")}, "660f2fc8"},
|
||
{"SQRTSD X0,X1", "SQRTSD", []Operand{vreg(t, "X0"), vreg(t, "X1")}, "f20f51c8"},
|
||
{"PSHUFL $3,X0,X1", "PSHUFL", []Operand{Imm(3), vreg(t, "X0"), vreg(t, "X1")}, "660f70c803"},
|
||
{"PALIGNR $2,X0,X1", "PALIGNR", []Operand{Imm(2), vreg(t, "X0"), vreg(t, "X1")}, "660f3a0fc802"},
|
||
{"PBLENDW $3,X0,X1", "PBLENDW", []Operand{Imm(3), vreg(t, "X0"), vreg(t, "X1")}, "660f3a0ec803"},
|
||
{"PCMPESTRI $1,X0,X1", "PCMPESTRI", []Operand{Imm(1), vreg(t, "X0"), vreg(t, "X1")}, "660f3a61c801"},
|
||
{"PCLMULQDQ $0,X0,X1", "PCLMULQDQ", []Operand{Imm(0), vreg(t, "X0"), vreg(t, "X1")}, "660f3a44c800"},
|
||
{"PCLMULQDQ $0,(AX),X1", "PCLMULQDQ", []Operand{Imm(0), Ptr(AX, 0, 16), vreg(t, "X1")}, "660f3a440800"},
|
||
{"PEXTRB $1,X0,AX", "PEXTRB", []Operand{Imm(1), vreg(t, "X0"), AX}, "660f3a14c001"},
|
||
{"PEXTRD $1,X0,AX", "PEXTRD", []Operand{Imm(1), vreg(t, "X0"), AX}, "660f3a16c001"},
|
||
{"PEXTRQ $1,X0,AX", "PEXTRQ", []Operand{Imm(1), vreg(t, "X0"), AX}, "66480f3a16c001"},
|
||
{"PEXTRW $1,X0,AX", "PEXTRW", []Operand{Imm(1), vreg(t, "X0"), AX}, "660fc5c001"},
|
||
{"PEXTRW $1,X0,(AX)", "PEXTRW", []Operand{Imm(1), vreg(t, "X0"), Ptr(AX, 0, 2)}, "660f3a150001"},
|
||
{"PINSRB $1,AX,X0", "PINSRB", []Operand{Imm(1), AX, vreg(t, "X0")}, "660f3a20c001"},
|
||
{"PINSRD $1,AX,X0", "PINSRD", []Operand{Imm(1), AX, vreg(t, "X0")}, "660f3a22c001"},
|
||
{"PINSRQ $1,AX,X0", "PINSRQ", []Operand{Imm(1), AX, vreg(t, "X0")}, "66480f3a22c001"},
|
||
{"PINSRW $1,AX,X0", "PINSRW", []Operand{Imm(1), AX, vreg(t, "X0")}, "660fc4c001"},
|
||
{"PINSRW $1,(AX),X0", "PINSRW", []Operand{Imm(1), Ptr(AX, 0, 2), vreg(t, "X0")}, "660fc40001"},
|
||
{"PSLLL $2,X0", "PSLLL", []Operand{Imm(2), vreg(t, "X0")}, "660f72f002"},
|
||
{"PSRAL $2,X0", "PSRAL", []Operand{Imm(2), vreg(t, "X0")}, "660f72e002"},
|
||
{"PSRLL $2,X0", "PSRLL", []Operand{Imm(2), vreg(t, "X0")}, "660f72d002"},
|
||
{"PSRLQ $2,X0", "PSRLQ", []Operand{Imm(2), vreg(t, "X0")}, "660f73d002"},
|
||
{"PSLLQ $2,X0", "PSLLQ", []Operand{Imm(2), vreg(t, "X0")}, "660f73f002"},
|
||
{"PSLLW $2,X0", "PSLLW", []Operand{Imm(2), vreg(t, "X0")}, "660f71f002"},
|
||
{"PSRLW $2,X0", "PSRLW", []Operand{Imm(2), vreg(t, "X0")}, "660f71d002"},
|
||
{"PSRAW $2,X0", "PSRAW", []Operand{Imm(2), vreg(t, "X0")}, "660f71e002"},
|
||
{"PSLLDQ $2,X0", "PSLLDQ", []Operand{Imm(2), vreg(t, "X0")}, "660f73f802"},
|
||
{"PSRLDQ $2,X0", "PSRLDQ", []Operand{Imm(2), vreg(t, "X0")}, "660f73d802"},
|
||
{"PSLLL X0,X1", "PSLLL", []Operand{vreg(t, "X0"), vreg(t, "X1")}, "660ff2c8"},
|
||
{"PSRLQ X0,X1", "PSRLQ", []Operand{vreg(t, "X0"), vreg(t, "X1")}, "660fd3c8"},
|
||
{"PSLLL (AX),X1", "PSLLL", []Operand{Ptr(AX, 0, 16), vreg(t, "X1")}, "660ff208"},
|
||
{"PSUBL X0,X1", "PSUBL", []Operand{vreg(t, "X0"), vreg(t, "X1")}, "660ffac8"},
|
||
{"PADDL X0,X1", "PADDL", []Operand{vreg(t, "X0"), vreg(t, "X1")}, "660ffec8"},
|
||
{"PCMPEQL X0,X1", "PCMPEQL", []Operand{vreg(t, "X0"), vreg(t, "X1")}, "660f76c8"},
|
||
{"PUNPCKLBW X0,X1", "PUNPCKLBW", []Operand{vreg(t, "X0"), vreg(t, "X1")}, "660f60c8"},
|
||
{"MOVOA X0,X1", "MOVOA", []Operand{vreg(t, "X0"), vreg(t, "X1")}, "660f6fc8"},
|
||
{"MOVOA (AX),X1", "MOVOA", []Operand{Ptr(AX, 0, 16), vreg(t, "X1")}, "660f6f08"},
|
||
{"MOVOA X0,(AX)", "MOVOA", []Operand{vreg(t, "X0"), Ptr(AX, 0, 16)}, "660f7f00"},
|
||
{"AESIMC X0,X1", "AESIMC", []Operand{vreg(t, "X0"), vreg(t, "X1")}, "660f38dbc8"},
|
||
{"AESIMC (AX),X1", "AESIMC", []Operand{Ptr(AX, 0, 16), vreg(t, "X1")}, "660f38db08"},
|
||
{"AESENC X0,X1", "AESENC", []Operand{vreg(t, "X0"), vreg(t, "X1")}, "660f38dcc8"},
|
||
{"AESENCLAST X0,X1", "AESENCLAST", []Operand{vreg(t, "X0"), vreg(t, "X1")}, "660f38ddc8"},
|
||
{"AESDEC X0,X1", "AESDEC", []Operand{vreg(t, "X0"), vreg(t, "X1")}, "660f38dec8"},
|
||
{"AESDECLAST X0,X1", "AESDECLAST", []Operand{vreg(t, "X0"), vreg(t, "X1")}, "660f38dfc8"},
|
||
{"AESKEYGENASSIST $0,X0,X1", "AESKEYGENASSIST", []Operand{Imm(0), vreg(t, "X0"), vreg(t, "X1")}, "660f3adfc800"},
|
||
{"SHA1MSG1 X0,X1", "SHA1MSG1", []Operand{vreg(t, "X0"), vreg(t, "X1")}, "0f38c9c8"},
|
||
{"SHA1MSG2 X0,X1", "SHA1MSG2", []Operand{vreg(t, "X0"), vreg(t, "X1")}, "0f38cac8"},
|
||
{"SHA1NEXTE X0,X1", "SHA1NEXTE", []Operand{vreg(t, "X0"), vreg(t, "X1")}, "0f38c8c8"},
|
||
{"SHA1RNDS4 $0,X0,X1", "SHA1RNDS4", []Operand{Imm(0), vreg(t, "X0"), vreg(t, "X1")}, "0f3accc800"},
|
||
{"SHA256MSG1 X0,X1", "SHA256MSG1", []Operand{vreg(t, "X0"), vreg(t, "X1")}, "0f38ccc8"},
|
||
{"SHA256MSG2 X0,X1", "SHA256MSG2", []Operand{vreg(t, "X0"), vreg(t, "X1")}, "0f38cdc8"},
|
||
{"SHA256RNDS2 X0,X1,X2", "SHA256RNDS2", []Operand{vreg(t, "X0"), vreg(t, "X1"), vreg(t, "X2")}, "0f38cbd1"},
|
||
}
|
||
for _, c := range cases {
|
||
code, err := Encode(c.mnem, c.ops...)
|
||
if err != nil {
|
||
t.Errorf("%s: Encode: %v", c.name, err)
|
||
continue
|
||
}
|
||
if got := fmt.Sprintf("%x", code); got != c.want {
|
||
t.Errorf("%s = %s, want %s", c.name, got, c.want)
|
||
}
|
||
}
|
||
// SHA256RNDS2's first operand must be the literal X0.
|
||
if _, err := Encode("SHA256RNDS2", vreg(t, "X1"), vreg(t, "X2"), vreg(t, "X3")); err == nil {
|
||
t.Errorf("SHA256RNDS2 X1,...: expected an error, got none")
|
||
}
|
||
// PSLLDQ has no variable-count form.
|
||
if _, err := Encode("PSLLDQ", vreg(t, "X0"), vreg(t, "X1")); err == nil {
|
||
t.Errorf("PSLLDQ X0,X1: expected an error, got none")
|
||
}
|
||
}
|
||
|
||
// TestSSEBinGroundTruth checks the legacy packed/scalar binary family
|
||
// byte for byte (no prefix / 66 / F2 / F3 variants).
|
||
func TestSSEBinGroundTruth(t *testing.T) {
|
||
cases := []struct {
|
||
name string
|
||
mnem string
|
||
ops []Operand
|
||
want string
|
||
}{
|
||
{"MULPS X0,X1", "MULPS", []Operand{vreg(t, "X0"), vreg(t, "X1")}, "0f59c8"},
|
||
{"MULPS (DI),X1", "MULPS", []Operand{Ptr(DI, 0, 16), vreg(t, "X1")}, "0f590f"},
|
||
{"ADDPD X1,X2", "ADDPD", []Operand{vreg(t, "X1"), vreg(t, "X2")}, "660f58d1"},
|
||
{"XORPS X0,X0", "XORPS", []Operand{vreg(t, "X0"), vreg(t, "X0")}, "0f57c0"},
|
||
{"UNPCKLPS X0,X0", "UNPCKLPS", []Operand{vreg(t, "X0"), vreg(t, "X0")}, "0f14c0"},
|
||
{"MULSD X1,X2", "MULSD", []Operand{vreg(t, "X1"), vreg(t, "X2")}, "f20f59d1"},
|
||
{"ADDSS (DI),X0", "ADDSS", []Operand{Ptr(DI, 0, 4), vreg(t, "X0")}, "f30f5807"},
|
||
}
|
||
for _, c := range cases {
|
||
code, err := Encode(c.mnem, c.ops...)
|
||
if err != nil {
|
||
t.Errorf("%s: %v", c.name, err)
|
||
continue
|
||
}
|
||
if got := fmt.Sprintf("%x", code); got != c.want {
|
||
t.Errorf("%s = %s, want %s", c.name, got, c.want)
|
||
}
|
||
}
|
||
}
|
||
|
||
// TestSSEShuffleGroundTruth checks the imm8 shuffle family: immediate
|
||
// first in Plan 9 order, encoded last on the wire.
|
||
func TestSSEShuffleGroundTruth(t *testing.T) {
|
||
cases := []struct {
|
||
name string
|
||
mnem string
|
||
ops []Operand
|
||
want string
|
||
}{
|
||
{"SHUFPS $0,X0,X0", "SHUFPS", []Operand{Imm(0), vreg(t, "X0"), vreg(t, "X0")}, "0fc6c000"},
|
||
{"SHUFPS $27,X1,X2", "SHUFPS", []Operand{Imm(27), vreg(t, "X1"), vreg(t, "X2")}, "0fc6d11b"},
|
||
{"PSHUFD $0,X0,X0", "PSHUFD", []Operand{Imm(0), vreg(t, "X0"), vreg(t, "X0")}, "660f70c000"},
|
||
{"PSHUFLW $3,(DI),X1", "PSHUFLW", []Operand{Imm(3), Ptr(DI, 0, 8), vreg(t, "X1")}, "f20f700f03"},
|
||
{"PSHUFHW $2,X1,X2", "PSHUFHW", []Operand{Imm(2), vreg(t, "X1"), vreg(t, "X2")}, "f30f70d102"},
|
||
}
|
||
for _, c := range cases {
|
||
code, err := Encode(c.mnem, c.ops...)
|
||
if err != nil {
|
||
t.Errorf("%s: %v", c.name, err)
|
||
continue
|
||
}
|
||
if got := fmt.Sprintf("%x", code); got != c.want {
|
||
t.Errorf("%s = %s, want %s", c.name, got, c.want)
|
||
}
|
||
}
|
||
}
|
||
|
||
// TestMOVQXMMGroundTruth pins the SSE2 packed-quadword move encodings:
|
||
// loads and register moves on F3 0F 7E, stores on 66 0F D6; the forms
|
||
// the GPR-move fallback silently corrupted.
|
||
func TestMOVQXMMGroundTruth(t *testing.T) {
|
||
cases := []struct {
|
||
name string
|
||
mnem string
|
||
ops []Operand
|
||
want string
|
||
}{
|
||
{"MOVQ (DI),X0", "MOVQ", []Operand{Ptr(DI, 0, 8), vreg(t, "X0")}, "f30f7e07"},
|
||
{"MOVQ X1,X2", "MOVQ", []Operand{vreg(t, "X1"), vreg(t, "X2")}, "f30f7ed1"},
|
||
{"MOVQ X0,(DI)", "MOVQ", []Operand{vreg(t, "X0"), Ptr(DI, 0, 8)}, "660fd607"},
|
||
}
|
||
for _, c := range cases {
|
||
code, err := Encode(c.mnem, c.ops...)
|
||
if err != nil {
|
||
t.Errorf("%s: %v", c.name, err)
|
||
continue
|
||
}
|
||
if got := fmt.Sprintf("%x", code); got != c.want {
|
||
t.Errorf("%s = %s, want %s", c.name, got, c.want)
|
||
}
|
||
}
|
||
}
|