gasm-sdk/asm/encodable.go

// Copyright (c) 2026 Petr Balvín <opensource@petrbalvin.org> (https://petrbalvin.org)
// SPDX-License-Identifier: BSD-3-Clause

package asm

import "strings"

// Encodable reports whether the amd64 encoder knows how to encode the
// mnemonic.  It mirrors the dispatch in (*enc).encode: the fixed-name
// instructions, conditional jumps, the CMOV/SET condition families, the
// VEX/EVEX/opmask/gather/scatter vector paths, the legacy SSE tables and the
// explicit scalar cases.  A mnemonic that parses (is in the architecture
// table) but is not encodable would otherwise surface only at assembly time,
// deep inside a build; the linter uses this predicate to flag it at edit
// time.
func Encodable(mnemonic string) bool {
	upper := strings.ToUpper(mnemonic)

	// The corpus families first, mirroring encode()'s dispatch order: a
	// family owning the name decides encodability whatever the suffix split
	// would make of it.
	if amd64FamilyEncodable(upper) {
		return true
	}

	// Fixed-name instructions (no size suffix).
	switch upper {
	case "RET", "NOP", "CALL", "JMP",
		"POPFQ", "PUSHFQ", "INT", "LDMXCSR", "STMXCSR", "CMPSD", "SHA256RNDS2",
		// The SSE compare family sharing CMPSD's predicate-last shape, the
		// far return with its stack pop, the loop family, the bank-crossing
		// MMX moves and the one-operand system controls.
		"CMPSS", "CMPPS", "CMPPD", "RETFL",
		"LOOP", "LOOPE", "LOOPNE",
		"MOVDQ2Q", "MOVQ2DQ",
		"ENDBR64", "CLWB", "TPAUSE", "UMONITOR", "UMWAIT", "RDPID", "CLDEMOTE",
		// The literal-data pseudo-ops, the accepted-and-ignored END and
		// bookkeeping statements, and the SP adjust.
		"BYTE", "WORD", "LONG", "QUAD", "END", "ADJSP", "FUNCDATA", "PCDATA":
		return true
	}
	if _, ok := sysUnaryTable[upper]; ok {
		return true
	}
	if _, ok := sseStoreOnly[upper]; ok {
		return true
	}
	if _, ok := noOperandTable[upper]; ok {
		return true
	}
	if _, ok := condCode(upper); ok {
		return true
	}

	// VEX/EVEX and friends: the trailing B/W/L/Q/D is part of the mnemonic.
	base, _, err := parseEvexSuffix(upper)
	if err != nil {
		return false
	}
	if isVex(base) || isEvex(base) || isKOp(base) || isGather(base) || isScatter(base) ||
		base == "KMOVW" || base == "KMOVQ" || base == "KMOVB" || base == "KMOVD" {
		return true
	}

	// CMOV carries size then condition (CMOVLGT); SET carries the condition
	// alone (SETNE).  The size letter is checked exactly as encodeCmov does,
	// so a spelling like CMOVBGT is not reported encodable when Encode
	// would reject it.
	if rest, ok := strings.CutPrefix(upper, "CMOV"); ok && len(rest) >= 2 {
		switch rest[0] {
		case 'W', 'L', 'Q':
			if _, ok := jccMap[rest[1:]]; ok {
				return true
			}
		}
	}
	if rest, ok := strings.CutPrefix(upper, "SET"); ok {
		if _, ok := jccMap[rest]; ok {
			return true
		}
	}

	// Legacy SSE shuffles and packed binaries dispatch on the full name; so
	// do the imm8-controlled instructions, the lane extracts and inserts and
	// the packed integer shifts (their trailing width letters belong to the
	// mnemonic).
	if _, ok := sseShufTable[upper]; ok {
		return true
	}
	if _, ok := sseBinTable[upper]; ok {
		return true
	}
	if _, ok := sseImm3Table[upper]; ok {
		return true
	}
	if _, ok := sseExtractTable[upper]; ok {
		return true
	}
	if _, ok := sseInsertTable[upper]; ok {
		return true
	}
	if _, ok := sseShiftImm[upper]; ok {
		return true
	}

	// The size-suffix split: retry the tables and the scalar switch on the
	// base.
	base2, size := splitSize(upper)
	if size == 0 {
		size = 8
	}
	_ = size
	if base2 != upper {
		if _, ok := sseBinTable[base2]; ok {
			return true
		}
	}
	switch base2 {
	case "MOV", "MOVD",
		"ADD", "SUB", "AND", "OR", "XOR", "CMP", "ADC", "SBB",
		"TEST",
		"LEA",
		"INC", "DEC", "NEG", "NOT", "MUL", "DIV", "IDIV",
		"SHL", "SHR", "SAR", "SAL", "ROL", "ROR", "RCL", "RCR",
		"BT", "BTS", "BTR", "BTC",
		"XCHG", "CMPXCHG", "XADD", "CRC32", "ADCX", "ADOX",
		"MOVS", "STOS",
		"IMUL", "IMUL3",
		"PUSH", "POP",
		"BSF", "BSR", "LZCNT", "TZCNT", "POPCNT",
		"BSWAP",
		"PREFETCHNTA", "PREFETCHT0", "PREFETCHT1", "PREFETCHT2",
		"MOVBLZX", "MOVBQZX", "MOVWLZX", "MOVWQZX", "MOVWLSX", "MOVLQSX",
		"MOVBWZX", "MOVBWSX", "MOVBLSX", "MOVBQSX", "MOVWQSX", "MOVLQZX",
		"CVTSL2SD", "CVTSQ2SD",
		"CVTSD2S", "CVTTSD2S", "CVTSS2S", "CVTTSS2S",
		"FMOVD",
		"MOVOU", "MOVO", "MOVOA", "MOVUPS", "MOVAPS", "MOVUPD", "MOVAPD", "MOVSD", "MOVSS":
		return true
	}
	// Full-name dispatches the size split would eat (a trailing width
	// letter that is part of the mnemonic).
	switch upper {
	case "PMOVMSKB":
		return true
	}
	return false
}