golang.org/x/arch@v0.17.0/x86/x86spec/cleanup.go

// Copyright 2016 The Go Authors.  All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package main

import (
	"fmt"
	"os"
	"sort"
	"strings"
)

// Clean up the data from the Intel manual for correctness
// and to annotate details relevant to decoding or encoding,
// such as whether an instruction is valid only in certain
// operand size modes.

// encodeReplace maps (argument, encoding) pairs to the corrected argument.
// We use a suffix 1 for the register and 2 for the r/m in the modrm byte.
// We use a suffix V for a register number specified in the VEX.vvvv bits.
var encodeReplace = map[[2]string]string{
	{"mm", "ModRM:reg"}:        "mm1",
	{"mm", "ModRM:r/m"}:        "mm2",
	{"mm1", "ModRM:r/m"}:       "mm2",
	{"mm2", "ModRM:reg"}:       "mm1",
	{"mm/m32", "ModRM:r/m"}:    "mm2/m32",
	{"mm/m64", "ModRM:r/m"}:    "mm2/m64",
	{"xmm", "ModRM:reg"}:       "xmm1",
	{"xmm", "ModRM:r/m"}:       "xmm2",
	{"xmm/m64", "ModRM:r/m"}:   "xmm2/m64",
	{"xmm0", "ModRM:reg"}:      "xmm1",
	{"xmm1", "ModRM:r/m"}:      "xmm2",
	{"xmm1/m16", "ModRM:r/m"}:  "xmm2/m16",
	{"xmm1/m32", "ModRM:r/m"}:  "xmm2/m32",
	{"xmm1/m64", "ModRM:r/m"}:  "xmm2/m64",
	{"xmm1/m128", "ModRM:r/m"}: "xmm2/m128",
	{"xmm1/m256", "ModRM:r/m"}: "xmm2/m256",
	{"xmm/m16", "ModRM:r/m"}:   "xmm2/m16",
	{"xmm/m32", "ModRM:r/m"}:   "xmm2/m32",
	{"xmm/m64", "ModRM:r/m"}:   "xmm2/m64",
	{"xmm/m128", "ModRM:r/m"}:  "xmm2/m128",
	{"xmm/m256", "ModRM:r/m"}:  "xmm2/m256",
	{"xmm3", "ModRM:reg"}:      "xmm1",
	{"xmm3", "ModRM:r/m"}:      "xmm2",
	{"xmm3/m16", "ModRM:r/m"}:  "xmm2/m16",
	{"xmm3/m32", "ModRM:r/m"}:  "xmm2/m32",
	{"xmm3/m64", "ModRM:r/m"}:  "xmm2/m64",
	{"xmm3/m128", "ModRM:r/m"}: "xmm2/m128",
	{"xmm3/m256", "ModRM:r/m"}: "xmm2/m256",
	{"xmm2", "ModRM:reg"}:      "xmm1",
	{"xmm2/m16", "ModRM:reg"}:  "xmm1/m16",
	{"xmm2/m32", "ModRM:reg"}:  "xmm1/m32",
	{"xmm2/m64", "ModRM:reg"}:  "xmm1/m64",
	{"xmm2/m128", "ModRM:reg"}: "xmm1/m128",
	{"xmm2/m256", "ModRM:reg"}: "xmm1/m256",
	{"ymm", "ModRM:reg"}:       "ymm1",
	{"ymm", "ModRM:r/m"}:       "ymm2",
	{"ymm0", "ModRM:reg"}:      "ymm1",
	{"ymm1", "ModRM:r/m"}:      "ymm2",
	{"ymm1/m16", "ModRM:r/m"}:  "ymm2/m16",
	{"ymm1/m32", "ModRM:r/m"}:  "ymm2/m32",
	{"ymm1/m64", "ModRM:r/m"}:  "ymm2/m64",
	{"ymm1/m128", "ModRM:r/m"}: "ymm2/m128",
	{"ymm1/m256", "ModRM:r/m"}: "ymm2/m256",
	{"ymm3", "ModRM:reg"}:      "ymm1",
	{"ymm3", "ModRM:r/m"}:      "ymm2",
	{"ymm3/m16", "ModRM:r/m"}:  "ymm2/m16",
	{"ymm3/m32", "ModRM:r/m"}:  "ymm2/m32",
	{"ymm3/m64", "ModRM:r/m"}:  "ymm2/m64",
	{"ymm3/m128", "ModRM:r/m"}: "ymm2/m128",
	{"ymm3/m256", "ModRM:r/m"}: "ymm2/m256",
	{"ymm2", "ModRM:reg"}:      "ymm1",
	{"ymm2/m16", "ModRM:reg"}:  "ymm1/m16",
	{"ymm2/m32", "ModRM:reg"}:  "ymm1/m32",
	{"ymm2/m64", "ModRM:reg"}:  "ymm1/m64",
	{"ymm2/m128", "ModRM:reg"}: "ymm1/m128",
	{"ymm2/m256", "ModRM:reg"}: "ymm1/m256",
	{"xmm1", "VEX.vvvv"}:       "xmmV",
	{"xmm2", "VEX.vvvv"}:       "xmmV",
	{"ymm1", "VEX.vvvv"}:       "ymmV",
	{"ymm2", "VEX.vvvv"}:       "ymmV",
	{"xmm4", "imm8[7:4]"}:      "xmmIH",
	{"ymm4", "imm8[7:4]"}:      "ymmIH",
	{"r8", "opcode + rd"}:      "r8op",
	{"r16", "opcode + rd"}:     "r16op",
	{"r32", "opcode + rd"}:     "r32op",
	{"r64", "opcode + rd"}:     "r64op",
	{"reg/m32", "ModRM:r/m"}:   "r/m32",
	{"reg/m16", "ModRM:r/m"}:   "r32/m16",
	{"bnd", "ModRM:reg"}:       "bnd1",
	{"bnd2", "ModRM:reg"}:      "bnd1",
	{"bnd1/m64", "ModRM:r/m"}:  "bnd2/m64",
	{"bnd1/m128", "ModRM:r/m"}: "bnd2/m128",
	{"r32a", "ModRM:reg"}:      "r32",
	{"r64a", "ModRM:reg"}:      "r64",
	{"r32", "VEX.vvvv"}:        "r32V",
	{"r64", "VEX.vvvv"}:        "r64V",
	{"r32b", "VEX.vvvv"}:       "r32V",
	{"r64b", "VEX.vvvv"}:       "r64V",
	{"r64", "VEX.vvvv"}:        "r64V",
	{"ST", "ST(0)"}:            "ST(0)",
}

// A few instructions do not have the usual encoding descriptions.
// Supply them.
var encodings = map[string][]string{
	"FADD m32fp":            {"ModRM:r/m (r)"},
	"FADD m64fp":            {"ModRM:r/m (r)"},
	"FADD ST(0), ST(i)":     {"ST(0) (r, w)", "ST(i) (r)"},
	"FADD ST(i), ST(0)":     {"ST(i) (r, w)", "ST(0) (r)"},
	"FADDP ST(i), ST(0)":    {"ST(i) (r, w)", "ST(0) (r)"},
	"FIADD m32int":          {"ModRM:r/m (r)"},
	"FIADD m16int":          {"ModRM:r/m (r)"},
	"FBLD m80dec":           {"ModRM:r/m (r)"},
	"FBSTP m80bcd":          {"ModRM:r/m (w)"},
	"FCMOVB ST(0), ST(i)":   {"ST(0) (r, w)", "ST(i) (r)"},
	"FCMOVE ST(0), ST(i)":   {"ST(0) (r, w)", "ST(i) (r)"},
	"FCMOVBE ST(0), ST(i)":  {"ST(0) (r, w)", "ST(i) (r)"},
	"FCMOVU ST(0), ST(i)":   {"ST(0) (r, w)", "ST(i) (r)"},
	"FCMOVNB ST(0), ST(i)":  {"ST(0) (r, w)", "ST(i) (r)"},
	"FCMOVNE ST(0), ST(i)":  {"ST(0) (r, w)", "ST(i) (r)"},
	"FCMOVNBE ST(0), ST(i)": {"ST(0) (r, w)", "ST(i) (r)"},
	"FCMOVNU ST(0), ST(i)":  {"ST(0) (r, w)", "ST(i) (r)"},
	"FCOM m32fp":            {"ModRM:r/m (r)"},
	"FCOM m64fp":            {"ModRM:r/m (r)"},
	"FCOM ST(i)":            {"ST(i) (r)"},
	"FCOMP m32fp":           {"ModRM:r/m (r)"},
	"FCOMP m64fp":           {"ModRM:r/m (r)"},
	"FCOMP ST(i)":           {"ST(i) (r)"},
	"FCOMI ST, ST(i)":       {"ST(0) (r)", "ST(i) (r)"},
	"FCOMIP ST, ST(i)":      {"ST(0) (r)", "ST(i) (r)"},
	"FUCOMI ST, ST(i)":      {"ST(0) (r)", "ST(i) (r)"},
	"FUCOMIP ST, ST(i)":     {"ST(0) (r)", "ST(i) (r)"},
	"FDIV m32fp":            {"ModRM:r/m (r)"},
	"FDIV m64fp":            {"ModRM:r/m (r)"},
	"FDIV ST(0), ST(i)":     {"ST(0) (r, w)", "ST(i) (r)"},
	"FDIV ST(i), ST(0)":     {"ST(i) (r, w)", "ST(0) (r)"},
	"FDIVP ST(i), ST(0)":    {"ST(i) (r, w)", "ST(0) (r)"},
	"FIDIV m16int":          {"ModRM:r/m (r)"},
	"FIDIV m32int":          {"ModRM:r/m (r)"},
	"FIDIV m64int":          {"ModRM:r/m (r)"},
	"FDIVR m32fp":           {"ModRM:r/m (r)"},
	"FDIVR m64fp":           {"ModRM:r/m (r)"},
	"FDIVR ST(0), ST(i)":    {"ST(0) (r, w)", "ST(i) (r)"},
	"FDIVR ST(i), ST(0)":    {"ST(i) (r, w)", "ST(0) (r)"},
	"FDIVRP ST(i), ST(0)":   {"ST(i) (r, w)", "ST(0) (r)"},
	"FIDIVR m16int":         {"ModRM:r/m (r)"},
	"FIDIVR m32int":         {"ModRM:r/m (r)"},
	"FIDIVR m64int":         {"ModRM:r/m (r)"},
	"FFREE ST(i)":           {"ST(i) (w)"},
	"FICOM m16int":          {"ModRM:r/m (r)"},
	"FICOM m32int":          {"ModRM:r/m (r)"},
	"FICOMP m16int":         {"ModRM:r/m (r)"},
	"FICOMP m32int":         {"ModRM:r/m (r)"},
	"FILD m16int":           {"ModRM:r/m (r)"},
	"FILD m32int":           {"ModRM:r/m (r)"},
	"FILD m64int":           {"ModRM:r/m (r)"},
	"FIST m16int":           {"ModRM:r/m (w)"},
	"FIST m32int":           {"ModRM:r/m (w)"},
	"FISTP m16int":          {"ModRM:r/m (w)"},
	"FISTP m32int":          {"ModRM:r/m (w)"},
	"FISTP m64int":          {"ModRM:r/m (w)"},
	"FISTTP m16int":         {"ModRM:r/m (w)"},
	"FISTTP m32int":         {"ModRM:r/m (w)"},
	"FISTTP m64int":         {"ModRM:r/m (w)"},
	"FLD m32fp":             {"ModRM:r/m (r)"},
	"FLD m64fp":             {"ModRM:r/m (r)"},
	"FLD m80fp":             {"ModRM:r/m (r)"},
	"FLD ST(i)":             {"ST(i) (r)"},
	"FLDCW m2byte":          {"ModRM:r/m (r)"},
	"FLDENV m14/28byte":     {"ModRM:r/m (r)"},
	"FMUL m32fp":            {"ModRM:r/m (r)"},
	"FMUL m64fp":            {"ModRM:r/m (r)"},
	"FMUL ST(0), ST(i)":     {"ST(0) (r, w)", "ST(i) (r)"},
	"FMUL ST(i), ST(0)":     {"ST(i) (r, w)", "ST(0) (r)"},
	"FMULP ST(i), ST(0)":    {"ST(i) (r, w)", "ST(0) (r)"},
	"FIMUL m16int":          {"ModRM:r/m (r)"},
	"FIMUL m32int":          {"ModRM:r/m (r)"},
	"FRSTOR m94/108byte":    {"ModRM:r/m (r)"},
	"FSAVE m94/108byte":     {"ModRM:r/m (w)"},
	"FNSAVE m94/108byte":    {"ModRM:r/m (w)"},
	"FST m32fp":             {"ModRM:r/m (w)"},
	"FST m64fp":             {"ModRM:r/m (w)"},
	"FST m80fp":             {"ModRM:r/m (w)"},
	"FST ST(i)":             {"ST(i) (w)"},
	"FSTP m32fp":            {"ModRM:r/m (w)"},
	"FSTP m64fp":            {"ModRM:r/m (w)"},
	"FSTP m80fp":            {"ModRM:r/m (w)"},
	"FSTP ST(i)":            {"ST(i) (w)"},
	"FSTCW m2byte":          {"ModRM:r/m (w)"},
	"FNSTCW m2byte":         {"ModRM:r/m (w)"},
	"FSTENV m14/28byte":     {"ModRM:r/m (w)"},
	"FNSTENV m14/28byte":    {"ModRM:r/m (w)"},
	"FSTSW m2byte":          {"ModRM:r/m (w)"},
	"FSTSW AX":              {"AX (w)"},
	"FNSTSW m2byte":         {"ModRM:r/m (w)"},
	"FNSTSW AX":             {"AX (w)"},
	"FSUB m32fp":            {"ModRM:r/m (r)"},
	"FSUB m64fp":            {"ModRM:r/m (r)"},
	"FSUB ST(0), ST(i)":     {"ST(0) (r, w)", "ST(i) (r)"},
	"FSUB ST(i), ST(0)":     {"ST(i) (r, w)", "ST(0) (r)"},
	"FSUBP ST(i), ST(0)":    {"ST(i) (r, w)", "ST(0) (r)"},
	"FISUB m16int":          {"ModRM:r/m (r)"},
	"FISUB m32int":          {"ModRM:r/m (r)"},
	"FSUBR m32fp":           {"ModRM:r/m (r)"},
	"FSUBR m64fp":           {"ModRM:r/m (r)"},
	"FSUBR ST(0), ST(i)":    {"ST(0) (r, w)", "ST(i) (r)"},
	"FSUBR ST(i), ST(0)":    {"ST(i) (r, w)", "ST(0) (r)"},
	"FSUBRP ST(i), ST(0)":   {"ST(i) (r, w)", "ST(0) (r)"},
	"FISUBR m16int":         {"ModRM:r/m (r)"},
	"FISUBR m32int":         {"ModRM:r/m (r)"},
	"FISUBR m64int":         {"ModRM:r/m (r)"},
	"FUCOM ST(i)":           {"ST(i) (r)"},
	"FUCOMP ST(i)":          {"ST(i) (r)"},
	"FXCH ST(i)":            {"ST(i) (r, w)"},
	"POP DS":                {"DS (w)"},
	"POP ES":                {"ES (w)"},
	"POP FS":                {"FS (w)"},
	"POP GS":                {"GS (w)"},
	"POP SS":                {"SS (w)"},
	"POP CS":                {"CS (w)"},
	"PUSH CS":               {"CS (r)"},
	"PUSH DS":               {"DS (r)"},
	"PUSH ES":               {"ES (r)"},
	"PUSH FS":               {"FS (r)"},
	"PUSH GS":               {"GS (r)"},
	"PUSH SS":               {"SS (r)"},
	"INT 3":                 {"3 (r)"},

	// In manual but hard to parse
	"BNDLDX bnd, mib": {"ModRM:reg (w)", "ModRM:r/m (r)"},
	"BNDSTX mib, bnd": {"ModRM:r/m (r)", "ModRM:reg (r)"},

	// In manual but wrong
	"CALL rel16":    {"Offset"},
	"CALL rel32":    {"Offset"},
	"IN AL, imm8":   {"AL (w)", "imm8 (r)"},
	"IN AX, imm8":   {"AX (w)", "imm8 (r)"},
	"IN EAX, imm8":  {"EAX (w)", "imm8 (r)"},
	"IN AL, DX":     {"AL (w)", "DX (r)"},
	"IN AX, DX":     {"AX (w)", "DX (r)"},
	"IN EAX, DX":    {"EAX (w)", "DX (r)"},
	"OUT DX, AL":    {"DX (r)", "AL (r)"},
	"OUT DX, AX":    {"DX (r)", "AX (r)"},
	"OUT DX, EAX":   {"DX (r)", "EAX (r)"},
	"OUT imm8, AL":  {"imm8 (r)", "AL (r)"},
	"OUT imm8, AX":  {"imm8 (r)", "AX (r)"},
	"OUT imm8, EAX": {"imm8 (r)", "EAX (r)"},
	"XCHG AX, r16":  {"AX (r, w)", "opcode + rd (r, w)"},
	"XCHG EAX, r32": {"EAX (r, w)", "opcode + rd (r, w)"},
	"XCHG RAX, r64": {"RAX (r, w)", "opcode + rd (r, w)"},

	// Encoding not listed.
	"INVEPT r32, m128":   {"ModRM:reg (r)", "ModRM:r/m (r)"},
	"INVEPT r64, m128":   {"ModRM:reg (r)", "ModRM:r/m (r)"},
	"INVVPID r32, m128":  {"ModRM:reg (r)", "ModRM:r/m (r)"},
	"INVVPID r64, m128":  {"ModRM:reg (r)", "ModRM:r/m (r)"},
	"VMREAD r/m32, r32":  {"ModRM:r/m (w)", "ModRM:reg (r)"},
	"VMREAD r/m64, r64":  {"ModRM:r/m (w)", "ModRM:reg (r)"},
	"VMWRITE r32, r/m32": {"ModRM:reg (r)", "ModRM:r/m (r)"},
	"VMWRITE r64, r/m64": {"ModRM:reg (r)", "ModRM:r/m (r)"},
	"VMCLEAR m64":        {"ModRM:r/m (w)"},
	"VMPTRLD m64":        {"ModRM:r/m (r)"},
	"VMPTRST m64":        {"ModRM:r/m (w)"},
	"VMXON m64":          {"ModRM:r/m (r)"},
}

// opAction lists the read/write actions for individual opcodes,
// where the manual does not.
var opAction = map[string][]string{
	"ADC":         {"rw", "r"},
	"ADD":         {"rw", "r"},
	"AND":         {"rw", "r"},
	"BLENDVPD":    {"rw", "r", "r"},
	"BLENDVPS":    {"rw", "r", "r"},
	"IN":          {"w", "r"},
	"MOV":         {"w", "r"},
	"OR":          {"rw", "r"},
	"OUT":         {"r", "r"},
	"PBLENDVB":    {"rw", "r", "r"},
	"RCL":         {"rw", "r"},
	"RCR":         {"rw", "r"},
	"ROL":         {"rw", "r"},
	"ROR":         {"rw", "r"},
	"SAL":         {"rw", "r"},
	"SAR":         {"rw", "r"},
	"SBB":         {"rw", "r"},
	"SHL":         {"rw", "r"},
	"SHLD":        {"rw", "r", "r"},
	"SHR":         {"rw", "r"},
	"SHRD":        {"rw", "r", "r"},
	"SUB":         {"rw", "r", "r"},
	"TEST":        {"r", "r"},
	"VBLENDVPD":   {"rw", "r", "r"},
	"VBLENDVPS":   {"rw", "r", "r"},
	"VPBLENDVB":   {"rw", "r", "r"},
	"VPMASKMOVD":  {"w", "r", "r"},
	"VPMASKMOVQ":  {"w", "r", "r"},
	"VPSLLVD":     {"w", "r", "r"},
	"VPSRAVD":     {"w", "r", "r"},
	"VPSRLVD":     {"w", "r", "r"},
	"VPSRLVQ":     {"w", "r", "r"},
	"VINSERTI128": {"w", "r", "r"},
	"VPBLENDD":    {"w", "r", "r"},
	"VPERMD":      {"w", "r", "r"},
	"VPERMPS":     {"w", "r", "r"},
	"VPERM2I128":  {"w", "r", "r"},
	"VPSLLVQ":     {"w", "r", "r"},
	"XCHG":        {"rw", "rw"},
	"XOR":         {"rw", "r"},
}

// encodeOK lists valid arg, encoding pairs.
// Any pair not listed gets a warning.
var encodeOK = map[[2]string]bool{
	{"0", "imm8"}:                true,
	{"1", "1"}:                   true,
	{"1", "imm8"}:                true,
	{"<XMM0>", "<XMM0>"}:         true,
	{"<XMM0>", "implicit XMM0"}:  true,
	{"AL", "AL"}:                 true,
	{"AL", "AL/AX/EAX/RAX"}:      true,
	{"AX", "AL/AX/EAX/RAX"}:      true,
	{"AX", "AX"}:                 true,
	{"AX", "AX/EAX/RAX"}:         true,
	{"CL", "CL"}:                 true,
	{"CR0-CR7", "ModRM:reg"}:     true,
	{"CR8", ""}:                  true,
	{"CS", "CS"}:                 true,
	{"DR0-DR7", "ModRM:reg"}:     true,
	{"DS", "DS"}:                 true,
	{"DX", "DX"}:                 true,
	{"EAX", "AL/AX/EAX/RAX"}:     true,
	{"EAX", "AX/EAX/RAX"}:        true,
	{"EAX", "EAX"}:               true,
	{"ES", "ES"}:                 true,
	{"FS", "FS"}:                 true,
	{"GS", "GS"}:                 true,
	{"RAX", "AL/AX/EAX/RAX"}:     true,
	{"RAX", "AX/EAX/RAX"}:        true,
	{"RAX", "RAX"}:               true,
	{"ST", "ST(0)"}:              true,
	{"ST(0)", "ST(0)"}:           true,
	{"ST(i)", "ST(i)"}:           true,
	{"Sreg", "ModRM:reg"}:        true,
	{"bnd1", "ModRM:reg"}:        true,
	{"bnd2/m128", "ModRM:r/m"}:   true,
	{"bnd2/m64", "ModRM:r/m"}:    true,
	{"imm16", "imm16"}:           true,
	{"imm16", "imm8"}:            true,
	{"imm16", "imm8/16/32"}:      true,
	{"imm16", "imm8/16/32"}:      true,
	{"imm16", "imm8/16/32/64"}:   true,
	{"imm16", "iw"}:              true,
	{"imm32", "imm8"}:            true,
	{"imm32", "imm8/16/32"}:      true,
	{"imm32", "imm8/16/32"}:      true,
	{"imm32", "imm8/16/32/64"}:   true,
	{"imm64", "imm8/16/32/64"}:   true,
	{"imm8", "imm8"}:             true,
	{"imm8", "imm8/16/32"}:       true,
	{"imm8", "imm8/16/32"}:       true,
	{"imm8", "imm8/16/32/64"}:    true,
	{"imm8", "imm8[3:0]"}:        true,
	{"m", "ModRM:r/m"}:           true,
	{"m128", "ModRM:r/m"}:        true,
	{"m14/28byte", "ModRM:r/m"}:  true,
	{"m16", "ModRM:r/m"}:         true,
	{"m16&16", "ModRM:r/m"}:      true,
	{"m16&32", "ModRM:r/m"}:      true,
	{"m16&64", "ModRM:r/m"}:      true,
	{"m16:16", "ModRM:r/m"}:      true,
	{"m16:16", "Offset"}:         true,
	{"m16:32", "ModRM:r/m"}:      true,
	{"m16:32", "Offset"}:         true,
	{"m16:64", "ModRM:r/m"}:      true,
	{"m16:64", "Offset"}:         true,
	{"m16int", "ModRM:r/m"}:      true,
	{"m256", "ModRM:r/m"}:        true,
	{"m2byte", "ModRM:r/m"}:      true,
	{"m32", "ModRM:r/m"}:         true,
	{"m32&32", "ModRM:r/m"}:      true,
	{"m32fp", "ModRM:r/m"}:       true,
	{"m32int", "ModRM:r/m"}:      true,
	{"m512byte", "ModRM:r/m"}:    true,
	{"m64", "ModRM:r/m"}:         true,
	{"m64fp", "ModRM:r/m"}:       true,
	{"m64int", "ModRM:r/m"}:      true,
	{"m8", "ModRM:r/m"}:          true,
	{"m80bcd", "ModRM:r/m"}:      true,
	{"m80dec", "ModRM:r/m"}:      true,
	{"m80fp", "ModRM:r/m"}:       true,
	{"m94/108byte", "ModRM:r/m"}: true,
	{"mem", "ModRM:r/m"}:         true,
	{"mib", "ModRM:r/m"}:         true,
	{"mm/m32", "ModRM:r/m"}:      true,
	{"mm1", "ModRM:reg"}:         true,
	{"mm2", "ModRM:r/m"}:         true,
	{"mm2/m32", "ModRM:r/m"}:     true,
	{"mm2/m64", "ModRM:r/m"}:     true,
	{"moffs16", "Moffs"}:         true,
	{"moffs32", "Moffs"}:         true,
	{"moffs64", "Moffs"}:         true,
	{"moffs8", "Moffs"}:          true,
	{"ptr16:16", "Offset"}:       true,
	{"ptr16:32", "Offset"}:       true,
	{"r/m16", "ModRM:r/m"}:       true,
	{"r/m32", "ModRM:r/m"}:       true,
	{"r/m64", "ModRM:r/m"}:       true,
	{"r/m8", "ModRM:r/m"}:        true,
	{"r16", "ModRM:reg"}:         true,
	{"r16op", "opcode + rd"}:     true,
	{"r32", "ModRM:reg"}:         true,
	{"r32", "VEX.vvvv"}:          true,
	{"r32/m16", "ModRM:r/m"}:     true,
	{"r32/m8", "ModRM:r/m"}:      true,
	{"r32V", "VEX.vvvv"}:         true,
	{"r32op", "opcode + rd"}:     true,
	{"r64", "ModRM:reg"}:         true,
	{"r64/m16", "ModRM:r/m"}:     true,
	{"r64V", "VEX.vvvv"}:         true,
	{"r64op", "opcode + rd"}:     true,
	{"r8", "ModRM:reg"}:          true,
	{"r8op", "opcode + rd"}:      true,
	{"rel16", "Offset"}:          true,
	{"rel32", "Offset"}:          true,
	{"rel8", "Offset"}:           true,
	{"rmr16", "ModRM:r/m"}:       true,
	{"rmr32", "ModRM:r/m"}:       true,
	{"rmr64", "ModRM:r/m"}:       true,
	{"xmm/m128", "ModRM:r/m"}:    true,
	{"xmm/m32", "ModRM:r/m"}:     true,
	{"xmm1", "ModRM:reg"}:        true,
	{"xmm2", "ModRM:r/m"}:        true,
	{"xmm2/m128", "ModRM:r/m"}:   true,
	{"xmm2/m16", "ModRM:r/m"}:    true,
	{"xmm2/m32", "ModRM:r/m"}:    true,
	{"xmm2/m64", "ModRM:r/m"}:    true,
	{"xmm2/m8", "ModRM:r/m"}:     true,
	{"xmmIH", "imm8[7:4]"}:       true,
	{"xmmV", "VEX.vvvv"}:         true,
	{"ymm1", "ModRM:reg"}:        true,
	{"ymm2", "ModRM:r/m"}:        true,
	{"ymm2/m256", "ModRM:r/m"}:   true,
	{"ymmIH", "imm8[7:4]"}:       true,
	{"ymmV", "VEX.vvvv"}:         true,
	{"vm32x", "vsib"}:            true,
	{"vm64x", "vsib"}:            true,
	{"vm32y", "vsib"}:            true,
	{"vm64y", "vsib"}:            true,
	{"SS", "SS"}:                 true,
	{"3", "3"}:                   true,
}

// instBlacklist lists the instruction syntaxes to ignore when parsing.
// We exclude Intel's general forms for these not-actually-general instructions.
// The syntax makes it look like arbitrary memory operands can be used when in fact
// the exact address is fixed in all cases - [DI] or [SI], for example
var instBlacklist = map[string]bool{
	"CMPS m16, m16":       true,
	"CMPS m32, m32":       true,
	"CMPS m64, m64":       true,
	"CMPS m8, m8":         true,
	"INS m16, DX":         true,
	"INS m32, DX":         true,
	"INS m8, DX":          true,
	"LODS m16":            true,
	"LODS m32":            true,
	"LODS m64":            true,
	"LODS m8":             true,
	"MOVS m16, m16":       true,
	"MOVS m32, m32":       true,
	"MOVS m64, m64":       true,
	"MOVS m8, m8":         true,
	"OUTS DX, m16":        true,
	"OUTS DX, m32":        true,
	"OUTS DX, m8":         true,
	"REP INS m16, DX":     true,
	"REP INS m32, DX":     true,
	"REP INS m8, DX":      true,
	"REP INS r/m32, DX":   true,
	"REP LODS AL":         true,
	"REP LODS AX":         true,
	"REP LODS EAX":        true,
	"REP LODS RAX":        true,
	"REP MOVS m16, m16":   true,
	"REP MOVS m32, m32":   true,
	"REP MOVS m64, m64":   true,
	"REP MOVS m8, m8":     true,
	"REP OUTS DX, m16":    true,
	"REP OUTS DX, m32":    true,
	"REP OUTS DX, m8":     true,
	"REP OUTS DX, r/m16":  true,
	"REP OUTS DX, r/m32":  true,
	"REP OUTS DX, r/m8":   true,
	"REP STOS m16":        true,
	"REP STOS m32":        true,
	"REP STOS m64":        true,
	"REP STOS m8":         true,
	"REPE CMPS m16, m16":  true,
	"REPE CMPS m32, m32":  true,
	"REPE CMPS m64, m64":  true,
	"REPE CMPS m8, m8":    true,
	"REPE SCAS m16":       true,
	"REPE SCAS m32":       true,
	"REPE SCAS m64":       true,
	"REPE SCAS m8":        true,
	"REPNE CMPS m16, m16": true,
	"REPNE CMPS m32, m32": true,
	"REPNE CMPS m64, m64": true,
	"REPNE CMPS m8, m8":   true,
	"REPNE SCAS m16":      true,
	"REPNE SCAS m32":      true,
	"REPNE SCAS m64":      true,
	"REPNE SCAS m8":       true,
	"SCAS m16":            true,
	"SCAS m32":            true,
	"SCAS m64":            true,
	"SCAS m8":             true,
	"STOS m16":            true,
	"STOS m32":            true,
	"STOS m64":            true,
	"STOS m8":             true,
	"XLAT m8":             true,
}

// condPrefs lists preferences for condition code suffixes.
// The first suffix in each pair takes priority over the second.
var condPrefs = [][2]string{
	{"B", "C"},
	{"B", "NAE"},
	{"AE", "NB"},
	{"AE", "NC"},
	{"E", "Z"},
	{"NE", "NZ"},
	{"BE", "NA"},
	{"A", "NBE"},
	{"P", "PE"},
	{"NP", "PO"},
	{"L", "NGE"},
	{"GE", "NL"},
	{"LE", "NG"},
	{"G", "NLE"},
}

// conv16 specifies replacements to turn a 16-bit syntax into a 32-bit syntax.
// If the conv16 can be applied to one form to create a new form with the same
// fixed instruction prefix, the pair is tagged as operand16 and operand32
// respectively.
var conv16 = strings.NewReplacer(
	"16:16", "16:32",
	"16", "32",
	"AX", "EAX",
	"CBW", "CWDE",
	"CMPSW", "CMPSD",
	"CWD", "CDQ",
	"INSW", "INSD",
	"IRET", "IRETD",
	"LODSW", "LODSD",
	"MOVSW", "MOVSD",
	"OUTSW", "OUTSD",
	"POPA", "POPAD",
	"POPF", "POPFD",
	"PUSHA", "PUSHAD",
	"PUSHF", "PUSHFD",
	"SCASW", "SCASD",
	"STOSW", "STOSD",
)

// fixup records additional modifications needed that are not derived
// from the instructions in the manual. It is keyed by the syntax and opcode.
var fixup = map[[2]string][]fixer{
	// NOP is a very special case overloading XCHG AX, AX.
	// The decoder handles it in custom code; exclude from the usual tables.
	{"NOP", "90"}: {fixAddTag("pseudo")},

	// PAUSE is a special case of NOP.
	{"PAUSE", "F3 90"}: {fixAddTag("pseudo")}, // used to add 'keepop' tag but not sure what that means

	// Far CALL, JMP, RET are given L prefix (long) for disambiguation.
	{"CALL m16:16", "FF /3"}:       {fixRename("CALL_FAR")},
	{"CALL m16:32", "FF /3"}:       {fixRename("CALL_FAR")},
	{"CALL m16:64", "REX.W FF /3"}: {fixRename("CALL_FAR")},
	{"CALL ptr16:16", "9A cd"}:     {fixRename("CALL_FAR")},
	{"CALL ptr16:32", "9A cp"}:     {fixRename("CALL_FAR")},
	{"JMP m16:16", "FF /5"}:        {fixRename("JMP_FAR")},
	{"JMP m16:32", "FF /5"}:        {fixRename("JMP_FAR")},
	{"JMP m16:64", "REX.W FF /5"}:  {fixRename("JMP_FAR")},
	{"JMP ptr16:16", "EA cd"}:      {fixRename("JMP_FAR")},
	{"JMP ptr16:32", "EA cp"}:      {fixRename("JMP_FAR")},
	{"RET imm16", "CA iw"}:         {fixRename("RET_FAR"), fixArg(0, "imm16u")},
	{"RET", "CB"}:                  {fixRename("RET_FAR")},

	// Unsigned immediates. (RET far imm16 handled above.)
	// Some of these are just preferences for disassembling.
	{"ENTER imm16, imm8", "C8 iw ib"}:  {fixArg(1, "imm8b")},
	{"RET imm16", "C2 iw"}:             {fixArg(0, "imm16u")},
	{"IN AL, imm8", "E4 ib"}:           {fixArg(1, "imm8u")},
	{"IN AX, imm8", "E5 ib"}:           {fixArg(1, "imm8u")},
	{"IN EAX, imm8", "E5 ib"}:          {fixArg(1, "imm8u"), fixAddTag("operand64")},
	{"OUT imm8, AL", "E6 ib"}:          {fixArg(0, "imm8u")},
	{"OUT imm8, AX", "E7 ib"}:          {fixArg(0, "imm8u")},
	{"OUT imm8, EAX", "E7 ib"}:         {fixArg(0, "imm8u"), fixAddTag("operand64")},
	{"MOV r8op, imm8", "B0+rb ib"}:     {fixArg(1, "imm8u")},
	{"MOV r8op, imm8", "REX B0+rb ib"}: {fixArg(1, "imm8u"), fixAddTag("pseudo64")},
	{"MOV r/m8, imm8", "C6 /0 ib"}:     {fixArg(1, "imm8u")},
	{"MOV r/m8, imm8", "REX C6 /0 ib"}: {fixArg(1, "imm8u"), fixAddTag("pseudo64")},

	// The listings for MOVSX and MOVSXD do not list some variants that
	// assemblers seem to allow.
	// As a result, this instruction got the wrong tag.
	// The other instructions are listed in extraInsts.
	{"MOVSX r32, r/m16", "0F BF /r"}: {fixRemoveTag("operand16"), fixAddTag("operand32")},
	{"MOVZX r32, r/m16", "0F B7 /r"}: {fixRemoveTag("operand16")},

	// Listings are incomplete or incorrect. Fix tags to adjust for new instructions below.
	{"SLDT r/m16", "0F 00 /0"}:             {fixRemoveTag("operand32")},
	{"STR r/m16", "0F 00 /1"}:              {fixAddTag("operand16")},
	{"BSWAP r32op", "0F C8+rd"}:            {fixRemoveTag("operand16")},
	{"MOV Sreg, r/m16", "8E /r"}:           {fixRemoveTag("operand32")},
	{"MOV Sreg, r/m64", "REX.W 8E /r"}:     {fixArg(1, "r/m16")},
	{"MOV r/m64, Sreg", "REX.W 8C /r"}:     {fixArg(0, "r/m16")},
	{"MOV r/m16, Sreg", "8C /r"}:           {fixRemoveTag("operand32")},
	{"MOV r/m64, imm32", "REX.W C7 /0 io"}: {fixOpcode("REX.W C7 /0 id")},

	// On 64-bit, these ignore 64-bit mode change.
	{"POP FS", "0F A1"}: {fixIfValid("N.E.", "V", fixAddTag("operand64"))},
	{"POP GS", "0F A9"}: {fixIfValid("N.E.", "V", fixAddTag("operand64"))},
	{"LEAVE", "C9"}:     {fixIfValid("N.E.", "V", fixAddTag("operand64"))},

	{"IN EAX, DX", "ED"}:         {fixAddTag("operand64")},
	{"INSD", "6D"}:               {fixAddTag("operand64")},
	{"OUT DX, EAX", "EF"}:        {fixAddTag("operand64")},
	{"OUTSD", "6F"}:              {fixAddTag("operand64")},
	{"XBEGIN rel32", "C7 F8 cd"}: {fixAddTag("operand64")},

	// Treat FWAIT, not WAIT, as canonical.
	{"FWAIT", "9B"}: {fixRemoveTag("pseudo")},
	{"WAIT", "9B"}:  {fixAddTag("pseudo")},

	// LAHF and SAHF are listed as "Invalid*" for 64-bit mode.
	// They are actually defined, so Valid from our point of view.
	// It's just that only a very few 64-bit processors allowed them.
	{"LAHF", "9F"}: {fixValid("V", "V")},
	{"SAHF", "9E"}: {fixValid("V", "V")},

	// The JZ forms are listed twice in the table, which confuses things.
	{"JZ rel16", "0F 84 cw"}: {fixAddTag("operand16"), fixRemoveTag("operand32")},
	{"JZ rel32", "0F 84 cd"}: {fixAddTag("operand32"), fixRemoveTag("operand16")},

	// XCHG has two of every instruction, which makes things bad.
	// The XX hack below takes care of most problems but this one remains.
	{"XCHG r/m16, r16", "87 /r"}: {fixRemoveTag("pseudo")},

	// MOV CR8 is just the obvious extension of the MOV CR0-CR7 form.
	{"MOV rmr64, CR8", "REX.R + 0F 20 /0"}: {fixAddTag("pseudo")},
	{"MOV CR8, rmr64", "REX.R + 0F 22 /0"}: {fixAddTag("pseudo")},

	// TODO: EXPLAIN ALL THESE
	{"ADCX r32, r/m32", "66 0F 38 F6 /r"}: {fixAddTag("operand16"), fixAddTag("operand32")},
	{"ADOX r32, r/m32", "F3 0F 38 F6 /r"}: {fixAddTag("operand16"), fixAddTag("operand32")},
	{"POPFQ", "9D"}:                       {fixAddTag("operand32"), fixAddTag("operand64")},
	{"PUSHFQ", "9C"}:                      {fixAddTag("operand32"), fixAddTag("operand64")},
	{"JCXZ rel8", "E3 cb"}:                {fixAddTag("address16")},
	{"JECXZ rel8", "E3 cb"}:               {fixAddTag("address32")},
	{"JRCXZ rel8", "E3 cb"}:               {fixAddTag("address64")},
	{"PUSH r64op", "50+rd"}:               {fixAddTag("operand32"), fixAddTag("operand64")},
	{"PUSH r/m64", "FF /6"}:               {fixAddTag("operand32"), fixAddTag("operand64")},
	{"POP r64op", "58+rd"}:                {fixAddTag("operand32"), fixAddTag("operand64")},
	{"POP r/m64", "8F /0"}:                {fixAddTag("operand32"), fixAddTag("operand64")},
	{"SMSW r/m16", "0F 01 /4"}:            {fixAddTag("operand16")},
	{"SMSW r32/m16", "0F 01 /4"}:          {fixRemoveTag("operand16"), fixAddTag("operand32")},

	// Express to the decoder that the rel16 only applies in 16-bit operand mode.
	{"JA rel16", "0F 87 cw"}:  {fixAddTag("operand16")},
	{"JAE rel16", "0F 83 cw"}: {fixAddTag("operand16")},
	{"JB rel16", "0F 82 cw"}:  {fixAddTag("operand16")},
	{"JBE rel16", "0F 86 cw"}: {fixAddTag("operand16")},
	{"JE rel16", "0F 84 cw"}:  {fixAddTag("operand16")},
	{"JG rel16", "0F 8F cw"}:  {fixAddTag("operand16")},
	{"JGE rel16", "0F 8D cw"}: {fixAddTag("operand16")},
	{"JL rel16", "0F 8C cw"}:  {fixAddTag("operand16")},
	{"JLE rel16", "0F 8E cw"}: {fixAddTag("operand16")},
	{"JNE rel16", "0F 85 cw"}: {fixAddTag("operand16")},
	{"JNO rel16", "0F 81 cw"}: {fixAddTag("operand16")},
	{"JNP rel16", "0F 8B cw"}: {fixAddTag("operand16")},
	{"JNS rel16", "0F 89 cw"}: {fixAddTag("operand16")},
	{"JO rel16", "0F 80 cw"}:  {fixAddTag("operand16")},
	{"JP rel16", "0F 8A cw"}:  {fixAddTag("operand16")},
	{"JS rel16", "0F 88 cw"}:  {fixAddTag("operand16")},

	{"JA rel32", "0F 87 cd"}:  {fixAddTag("operand32")},
	{"JAE rel32", "0F 83 cd"}: {fixAddTag("operand32")},
	{"JB rel32", "0F 82 cd"}:  {fixAddTag("operand32")},
	{"JBE rel32", "0F 86 cd"}: {fixAddTag("operand32")},
	{"JE rel32", "0F 84 cd"}:  {fixAddTag("operand32")},
	{"JG rel32", "0F 8F cd"}:  {fixAddTag("operand32")},
	{"JGE rel32", "0F 8D cd"}: {fixAddTag("operand32")},
	{"JL rel32", "0F 8C cd"}:  {fixAddTag("operand32")},
	{"JLE rel32", "0F 8E cd"}: {fixAddTag("operand32")},
	{"JNE rel32", "0F 85 cd"}: {fixAddTag("operand32")},
	{"JNO rel32", "0F 81 cd"}: {fixAddTag("operand32")},
	{"JNP rel32", "0F 8B cd"}: {fixAddTag("operand32")},
	{"JNS rel32", "0F 89 cd"}: {fixAddTag("operand32")},
	{"JO rel32", "0F 80 cd"}:  {fixAddTag("operand32")},
	{"JP rel32", "0F 8A cd"}:  {fixAddTag("operand32")},
	{"JS rel32", "0F 88 cd"}:  {fixAddTag("operand32")},

	{"LSL r16, r/m16", "0F 03 /r"}: {fixAddTag("operand16")},
}

var extraInsts = []*instruction{
	// Undocumented.
	{syntax: "ICEBP", opcode: "F1", valid32: "V", valid64: "V"},
	{syntax: "UD1", opcode: "0F B9", valid32: "V", valid64: "V"},
	{syntax: "FFREEP ST(i)", opcode: "DF C0+i", valid32: "V", valid64: "V", action: "w"},

	// Where did these come from? They were in version 0.01 of the csv table.
	{syntax: "MOVNTSD m64, xmm1", opcode: "F2 0F 2B /r", valid32: "V", valid64: "V", cpuid: "SSE", action: "w,r"},
	{syntax: "MOVNTSS m32, xmm1", opcode: "F3 0F 2B /r", valid32: "V", valid64: "V", cpuid: "SSE", action: "w,r"},

	// These express to the decoder that in 64-bit mode
	// an operand prefix does not affect the size of the relative offset.
	{syntax: "CALL rel32", opcode: "E8 cd", valid32: "N.S.", valid64: "V", tags: []string{"operand16", "operand64"}, action: "r"},
	{syntax: "JMP rel32", opcode: "E9 cd", valid32: "N.S.", valid64: "V", tags: []string{"operand16", "operand64"}, action: "r"},
	{syntax: "JA rel32", opcode: "0F 87 cd", valid32: "N.S.", valid64: "V", tags: []string{"operand16", "operand64"}, action: "r"},
	{syntax: "JAE rel32", opcode: "0F 83 cd", valid32: "N.S.", valid64: "V", tags: []string{"operand16", "operand64"}, action: "r"},
	{syntax: "JB rel32", opcode: "0F 82 cd", valid32: "N.S.", valid64: "V", tags: []string{"operand16", "operand64"}, action: "r"},
	{syntax: "JBE rel32", opcode: "0F 86 cd", valid32: "N.S.", valid64: "V", tags: []string{"operand16", "operand64"}, action: "r"},
	{syntax: "JE rel32", opcode: "0F 84 cd", valid32: "N.S.", valid64: "V", tags: []string{"operand16", "operand64"}, action: "r"},
	{syntax: "JG rel32", opcode: "0F 8F cd", valid32: "N.S.", valid64: "V", tags: []string{"operand16", "operand64"}, action: "r"},
	{syntax: "JGE rel32", opcode: "0F 8D cd", valid32: "N.S.", valid64: "V", tags: []string{"operand16", "operand64"}, action: "r"},
	{syntax: "JL rel32", opcode: "0F 8C cd", valid32: "N.S.", valid64: "V", tags: []string{"operand16", "operand64"}, action: "r"},
	{syntax: "JLE rel32", opcode: "0F 8E cd", valid32: "N.S.", valid64: "V", tags: []string{"operand16", "operand64"}, action: "r"},
	{syntax: "JNE rel32", opcode: "0F 85 cd", valid32: "N.S.", valid64: "V", tags: []string{"operand16", "operand64"}, action: "r"},
	{syntax: "JNO rel32", opcode: "0F 81 cd", valid32: "N.S.", valid64: "V", tags: []string{"operand16", "operand64"}, action: "r"},
	{syntax: "JNP rel32", opcode: "0F 8B cd", valid32: "N.S.", valid64: "V", tags: []string{"operand16", "operand64"}, action: "r"},
	{syntax: "JNS rel32", opcode: "0F 89 cd", valid32: "N.S.", valid64: "V", tags: []string{"operand16", "operand64"}, action: "r"},
	{syntax: "JO rel32", opcode: "0F 80 cd", valid32: "N.S.", valid64: "V", tags: []string{"operand16", "operand64"}, action: "r"},
	{syntax: "JP rel32", opcode: "0F 8A cd", valid32: "N.S.", valid64: "V", tags: []string{"operand16", "operand64"}, action: "r"},
	{syntax: "JS rel32", opcode: "0F 88 cd", valid32: "N.S.", valid64: "V", tags: []string{"operand16", "operand64"}, action: "r"},

	// Disassemblers recognize these, but they're not in the manual.
	// Not sure if they really exist.

	// The 16-16 and 32-32 forms don't really make sense since there's nothing to extend.
	{syntax: "MOVSX r16, r/m16", opcode: "0F BF /r", valid32: "V", valid64: "V", tags: []string{"operand16"}, action: "w,r"},
	{syntax: "MOVSXD r16, r/m32", opcode: "63 /r", valid32: "N.E.", valid64: "V", tags: []string{"operand16"}, action: "w,r"},
	{syntax: "MOVSXD r32, r/m32", opcode: "63 /r", valid32: "N.E.", valid64: "V", tags: []string{"operand32"}, action: "w,r"},
	{syntax: "MOVZX r16, r/m16", opcode: "0F B7 /r", valid32: "V", valid64: "V", tags: []string{"operand16"}, action: "w,r"},

	{syntax: "LAR r64, r/m16", opcode: "REX.W 0F 02 /r", valid32: "N.E.", valid64: "V", action: "w,r"},
	{syntax: "SLDT r32/m16", opcode: "0F 00 /0", valid32: "V", valid64: "V", tags: []string{"operand32"}, action: "w"},
	{syntax: "STR r32/m16", opcode: "0F 00 /1", valid32: "V", valid64: "V", tags: []string{"operand32"}, action: "w"},
	{syntax: "STR r64/m16", opcode: "REX.W 0F 00 /1", valid32: "N.E.", valid64: "V", action: "w"},

	{syntax: "BSWAP r16op", opcode: "0F C8+rd", valid32: "V", valid64: "V", tags: []string{"operand16"}, action: "rw"},

	// Do these exist?
	// I am not sure where they came from, and xed doesn't recognize them.
	//{syntax: "MOV TR0-TR7, rmr32", opcode: "0F 26 /r", valid32: "V", valid64: "N.E.", tags: []string{"modrm_regonly"}, action: "w,r"},
	//{syntax: "MOV TR0-TR7, rmr64", opcode: "0F 26 /r", valid32: "N.E.", valid64: "V", tags: []string{"modrm_regonly"}, action: "w,r"},
	//{syntax: "MOV rmr32, TR0-TR7", opcode: "0F 24 /r", valid32: "V", valid64: "N.E.", tags: []string{"modrm_regonly"}, action: "w,r"},
	//{syntax: "MOV rmr64, TR0-TR7", opcode: "0F 24 /r", valid32: "N.E.", valid64: "V", tags: []string{"modrm_regonly"}, action: "w,r"},
	{syntax: "MOV Sreg, r32/m16", opcode: "8E /r", valid32: "V", valid64: "V", tags: []string{"operand32"}, action: "w,r"},
	{syntax: "MOV r/m32, Sreg", opcode: "8C /r", valid32: "V", valid64: "V", tags: []string{"operand32"}, action: "w,r"},
}

type fixer func(*instruction)

func fixAddTag(tag string) fixer {
	return func(inst *instruction) {
		addTag(inst, tag)
	}
}

func fixRemoveTag(tag string) fixer {
	return func(inst *instruction) {
		removeTag(inst, tag)
	}
}

func fixRename(op string) fixer {
	return func(inst *instruction) {
		_, args := splitSyntax(inst.syntax)
		inst.syntax = joinSyntax(op, args)
	}
}

func fixArg(i int, arg string) fixer {
	return func(inst *instruction) {
		op, args := splitSyntax(inst.syntax)
		args[i] = arg
		inst.syntax = joinSyntax(op, args)
	}
}

func fixIfValid(valid32, valid64 string, fix fixer) fixer {
	return func(inst *instruction) {
		if inst.valid32 == valid32 && inst.valid64 == valid64 {
			fix(inst)
		}
	}
}

func fixValid(valid32, valid64 string) fixer {
	return func(inst *instruction) {
		inst.valid32 = valid32
		inst.valid64 = valid64
	}
}

func fixOpcode(opcode string) fixer {
	return func(inst *instruction) {
		inst.opcode = opcode
	}
}

func cleanup(insts []*instruction) []*instruction {
	var haveOp map[string]bool
	if onlySomePages {
		haveOp = map[string]bool{}
	}

	// Clean individual instruction encodings and opcode sequences.
	sawJZ := map[string]bool{}
	out := insts[:0]
	for seq, inst := range insts {
		inst.seq = seq

		// There are two copies each of JZ rel16 and JZ rel32. Delete the second.
		if strings.HasPrefix(inst.syntax, "JZ rel") {
			if sawJZ[inst.syntax] {
				continue
			}
			sawJZ[inst.syntax] = true
		}
		out = append(out, inst)

		// Intel CMPXCHG16B and CMPXCHG8B have surprise "m64" or " m128" at end of encoding.
		surprises := []string{
			" m64",
			" m128",
		}
		for _, s := range surprises {
			if strings.HasSuffix(inst.syntax, s) && strings.HasSuffix(inst.opcode, s) {
				inst.opcode = strings.TrimSuffix(inst.opcode, s)
			}
		}

		op, args := splitSyntax(inst.syntax)
		op = strings.TrimRight(op, "*")
		inst.syntax = joinSyntax(op, args)

		// Check argument names in syntax against encoding details.
		if enc, ok := encodings[inst.syntax]; ok {
			inst.args = enc
		}
		if len(args) == len(inst.args)+1 && args[len(args)-1] == "imm8" {
			fixed := make([]string, len(args))
			copy(fixed, inst.args)
			fixed[len(args)-1] = "imm8"
			inst.args = fixed
		} else if len(args) == 0 && len(inst.args) == 1 && inst.args[0] == "NA" {
			inst.args = []string{}
		} else if len(args) != len(inst.args) {
			fmt.Fprintf(os.Stderr, "p.%d: %s has %d args but %d encoding details:\n\t%s\n", inst.page, inst.syntax, len(args), len(inst.args), strings.Join(inst.args, "; "))
			inst.syntax = joinSyntax(op, args)
			continue
		}

		var action []string
		for i, arg := range args {
			arg = strings.TrimSpace(arg)
			arg = strings.TrimRight(arg, "*")
			if (arg == "reg" || strings.HasPrefix(arg, "reg/")) && containsAll(inst.desc, "upper bits", "r64", "zero") {
				arg = "r32" + strings.TrimPrefix(arg, "reg")
			}

			enc := inst.args[i]
			enc = strings.TrimSpace(enc)
			switch {
			case strings.HasSuffix(enc, " (r))"):
				enc = strings.TrimSuffix(enc, ")")
			case strings.HasSuffix(enc, " (R)"):
				enc = strings.TrimSuffix(enc, " (R)") + " (r)"
			case strings.HasSuffix(enc, " (W)"):
				enc = strings.TrimSuffix(enc, " (W)") + " (w)"
			case strings.HasSuffix(enc, " (r,w)"):
				enc = strings.TrimSuffix(enc, " (r,w)") + " (r, w)"
			case enc == "Imm8":
				enc = "imm8"
			case enc == "imm8/26/32":
				enc = "imm8/16/32"
			case enc == "BaseReg (R): VSIB:base, VectorReg(R): VSIB:index":
				enc = "vsib (r)"
			}
			inst.args[i] = enc

			switch {
			case strings.HasSuffix(enc, " (r)"):
				action = append(action, "r")
				enc = strings.TrimSuffix(enc, " (r)")
			case strings.HasSuffix(enc, " (w)"):
				action = append(action, "w")
				enc = strings.TrimSuffix(enc, " (w)")
			case strings.HasSuffix(enc, " (r, w)"):
				action = append(action, "rw")
				enc = strings.TrimSuffix(enc, " (r, w)")
			case strings.HasPrefix(enc, "imm"), enc == "Offset", enc == "iw", arg == "1", arg == "0", arg == "3":
				action = append(action, "r")
			case i < len(opAction[op]):
				action = append(action, opAction[op][i])
			default:
				fmt.Fprintf(os.Stderr, "p.%d: %s has encoding %s for %s but no r/w annotations\n", inst.page, inst.syntax, enc, arg)
				action = append(action, "?")
			}

			if arg == "mem" && op == "LDDQU" {
				arg = "m128"
			}
			if arg == "reg" && op == "LAR" {
				arg = "r32"
			}
			if actual := encodeReplace[[2]string{arg, enc}]; actual != "" {
				arg = actual
			}

			if (arg == "r8" || arg == "r16" || arg == "r32" || arg == "r64") && enc == "ModRM:r/m" {
				addTag(inst, "modrm_regonly")
				arg = "rmr" + arg[1:]
			}
			if (arg == "xmm2" || arg == "ymm2") && enc == "ModRM:r/m" {
				addTag(inst, "modrm_regonly")
			}

			if (arg == "m8" || arg == "m16" || arg == "m32" || arg == "m64" || arg == "m128" || arg == "m256") && enc == "ModRM:r/m" {
				addTag(inst, "modrm_memonly")
			}

			if arg == "r64" && (inst.syntax == "MOV r64, CR8" || inst.syntax == "MOV CR8, r64") {
				arg = "rmr64"
				addTag(inst, "modrm_regonly")
			}
			if arg == "CR8" {
				enc = ""
			}

			if !encodeOK[[2]string{arg, enc}] {
				fmt.Fprintf(os.Stderr, "p.%d: %s has invalid encoding %s for %s\n\t{%q, %q}: true,\n", inst.page, inst.syntax, enc, arg, arg, enc)
			}

			args[i] = arg

			// Intel SETcc and others are missing the /r.
			// But CALL rel16 and CALL rel32 have a bad encoding table so ignore the ModRM there.
			if strings.HasPrefix(enc, "ModRM") && !strings.Contains(inst.opcode, " /") && op != "CALL" {
				inst.opcode += " /r"
			}
			if strings.HasPrefix(enc, "ModRM:reg") && !strings.Contains(inst.opcode, "/r") {
				// The opcode is taken up with something else. Bug in table.
				fmt.Fprintf(os.Stderr, "p.%d: %s has invalid encoding %s: no reg field in %s\n", inst.page, inst.syntax, arg, inst.opcode)
			}
			// XBEGIN is missing cw cd.
			if enc == "Offset" && arg == "rel16" && !strings.Contains(inst.opcode, " cw") {
				inst.opcode += " cw"
			}
			if enc == "Offset" && arg == "rel32" && !strings.Contains(inst.opcode, " cd") {
				inst.opcode += " cd"
			}
			if enc == "Moffs" && !strings.Contains(inst.opcode, "cm") {
				inst.opcode += " cm"
			}

			inst.action = strings.Join(action, ",")
		}

		inst.syntax = joinSyntax(op, args)

		// The Intel manual lists each XCHG form with arguments in both orders.
		// While this is technically correct, it confuses lots of the analysis.
		// Change half of them to start with a fake "XX" byte.
		if op == "XCHG" && !strings.HasPrefix(args[0], "r/") && !strings.HasSuffix(args[0], "op") {
			inst.opcode = "XX " + inst.opcode
		}

		// Intel manual is not great about disabling REX instructions on 32-bit systems.
		if strings.Contains(inst.opcode, "REX") && inst.valid32 == "V" {
			inst.valid32 = "N.E."
		}

		if inst.valid32 == "V" {
			switch {
			case containsAll(inst.compat, "not supported", "earlier than the Intel486"):
				inst.cpuid = "486"
			case containsAll(inst.compat, "not supported", "earlier than the Pentium"),
				containsAll(inst.compat, "were introduced", "with the Pentium"):
				inst.cpuid = "Pentium"
			case containsAll(inst.compat, "were introduced", "in the Pentium II"):
				inst.cpuid = "PentiumII"
			case containsAll(inst.compat, "were introduced", "in the P6 family"),
				containsAll(inst.compat, "were introduced in P6 family"):
				addTag(inst, "P6")
			}
		}

		if onlySomePages {
			op, _ := splitSyntax(inst.syntax)
			haveOp[op] = true
		}
	}

	insts = out
	sort.Sort(byOpcode(insts))

	// Detect operand size dependencies.
	var last *instruction
	for _, inst := range insts {
		if last != nil {
			f1, _ := splitOpcode(last.opcode)
			f2, _ := splitOpcode(inst.opcode)
			if f1 == f2 {
				// Conflict: cannot distinguish instructions based on fixed prefix.
				if is16vs32pair(last, inst) {
					addTag(last, "operand16")
					addTag(inst, "operand32")
					continue
				}
				if is16vs32pair(inst, last) {
					addTag(last, "operand32")
					addTag(inst, "operand16")
					last = inst
					continue
				}
			}
		}
		last = inst
	}

	// Detect pseudo-ops, defined as opcode entries subsumed by more general ones.
	seen := map[string]*instruction{}
	for _, inst := range insts {
		if strings.HasPrefix(inst.opcode, "9B ") { // FWAIT prefix
			addTag(inst, "pseudo")
			continue
		}
		if inst.opcode == "F0" || inst.opcode == "F2" || inst.opcode == "F3" {
			addTag(inst, "pseudo")
			continue
		}
		if strings.HasPrefix(inst.syntax, "REP ") || strings.HasPrefix(inst.syntax, "REPE ") || strings.HasPrefix(inst.syntax, "REPNE ") {
			addTag(inst, "pseudo")
			continue
		}
		if strings.HasPrefix(inst.syntax, "SAL ") { // SHL is canonical
			addTag(inst, "pseudo")
			continue
		}
		if old := seen[inst.opcode]; old != nil {
			if condLess(old.syntax, inst.syntax) {
				addTag(inst, "pseudo")
				continue
			}
			if xchgLess(inst.syntax, old.syntax) {
				old.tags = append(old.tags, "pseudo")
				seen[inst.opcode] = inst
				continue
			}
		}

		seen[inst.opcode] = inst

		if last != nil && canGenerate(last.opcode, inst.opcode) {
			addTag(inst, "pseudo")
			continue
		}
		last = inst
	}
	for _, inst := range insts {
		if strings.Contains(inst.opcode, "REX ") {
			if old := seen[strings.Replace(inst.opcode, "REX ", "", 1)]; old != nil && old.syntax == inst.syntax {
				addTag(inst, "pseudo64")
				continue
			} else if old != nil && hasTag(old, "pseudo") {
				addTag(inst, "pseudo")
				continue
			}
		}
		if strings.Contains(inst.opcode, "REX.W ") {
			if old := seen[strings.Replace(inst.opcode, "REX.W ", "", -1)]; old != nil && old.syntax == inst.syntax {
				addTag(old, "ignoreREXW")
				addTag(inst, "pseudo")
				continue
			} else if old != nil && hasTag(old, "pseudo") {
				addTag(inst, "pseudo")
				continue
			} else if old != nil && !hasTag(old, "operand16") && !hasTag(old, "operand32") {
				// There is a 64-bit form of this instruction.
				// Mark this one as only valid in the non-64-bit operand modes.
				addTag(old, "operand16")
				addTag(old, "operand32")
				continue
			}
		}
	}

	// Undo XCHG hack above.
	for _, inst := range insts {
		if strings.HasPrefix(inst.opcode, "XX ") {
			inst.opcode = strings.TrimPrefix(inst.opcode, "XX ")
			addTag(inst, "pseudo")
			removeTag(inst, "pseudo64")
		}
	}

	// Last ditch effort. Manual fixes.
	// Some things are too hard to infer.
	for _, inst := range insts {
		for _, fix := range fixup[[2]string{inst.syntax, inst.opcode}] {
			fix(inst)
		}
		sort.Strings(inst.tags)
	}

	sort.Sort(bySeq(insts))

	if onlySomePages {
		for _, inst := range extraInsts {
			op, _ := splitSyntax(inst.syntax)
			if haveOp[op] {
				insts = append(insts, inst)
			}
		}
	} else {
		insts = append(insts, extraInsts...)
	}
	return insts
}

func hasTag(inst *instruction, tag string) bool {
	for _, t := range inst.tags {
		if t == tag {
			return true
		}
	}
	return false
}

func removeTag(inst *instruction, tag string) {
	if !hasTag(inst, tag) {
		return
	}
	out := inst.tags[:0]
	for _, t := range inst.tags {
		if t != tag {
			out = append(out, t)
		}
	}
	inst.tags = out
}

func addTag(inst *instruction, tag string) {
	if !hasTag(inst, tag) {
		inst.tags = append(inst.tags, tag)
	}
}

type byOpcode []*instruction

func (x byOpcode) Len() int      { return len(x) }
func (x byOpcode) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
func (x byOpcode) Less(i, j int) bool {
	if x[i].opcode != x[j].opcode {
		return opcodeLess(x[i].opcode, x[j].opcode)
	}
	if condLess(x[i].syntax, x[j].syntax) {
		return true
	}
	if condLess(x[j].syntax, x[i].syntax) {
		return false
	}
	if x[i].syntax != x[j].syntax {
		return x[i].syntax < x[j].syntax
	}
	return x[i].seq < x[j].seq
}

type bySeq []*instruction

func (x bySeq) Len() int      { return len(x) }
func (x bySeq) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
func (x bySeq) Less(i, j int) bool {
	return x[i].seq < x[j].seq
}

type bySyntax []*instruction

func (x bySyntax) Len() int      { return len(x) }
func (x bySyntax) Swap(i, j int) { x[i], x[j] = x[j], x[i] }
func (x bySyntax) Less(i, j int) bool {
	if x[i].syntax != x[j].syntax {
		return x[i].syntax < x[j].syntax
	}
	return x[i].opcode < x[j].opcode
}

// condLess reports whether the conditional instruction syntax
// x should be considered less than y.
// We sort condition codes we prefer ahead of condition codes we don't,
// so that the latter are recorded as the pseudo-operations.
func condLess(x, y string) bool {
	x, _ = splitSyntax(x)
	y, _ = splitSyntax(y)
	for _, pref := range condPrefs {
		if strings.HasSuffix(x, pref[0]) && strings.HasSuffix(y, pref[1]) && strings.TrimSuffix(x, pref[0]) == strings.TrimSuffix(y, pref[1]) {
			return true
		}
	}
	return false
}

// xchgLess reports whether the xchg instruction x should be considered less than y.
func xchgLess(x, y string) bool {
	return strings.HasPrefix(x, "XCHG ") && x > y
}

// opcodeLess reports whether opcode string x should be considered less than y.
// We sort wildcard fields like "ib" before literal bytes like "0A".
func opcodeLess(x, y string) bool {
	for i := 0; i < len(x) || i < len(y); i++ {
		if i >= len(x) {
			return true
		}
		if i >= len(y) {
			return false
		}
		if x[i] != y[i] {
			// sort word before doubleword
			if x[i] == 'w' && y[i] == 'd' {
				return true
			}
			if x[i] == 'd' && y[i] == 'w' {
				return false
			}
			// Sort lower-case before non-lower-case.
			// This sorts "ib" before literal bytes like "0A", for example.
			return x[i]-'a' < y[i]-'a'
		}
	}
	return false
}

// splitOpcode splits an opcode into its fixed and variable portions.
// For example "05 iw" splits into "05" and "iw".
func splitOpcode(x string) (fixed, variable string) {
	i := 0
	for i < len(x) {
		c := x[i]
		if '0' <= c && c <= '9' || 'A' <= c && c <= 'Z' || c == ' ' || c == '.' || c == '+' {
			i++
			continue
		}
		if i+2 <= len(x) && c == '/' {
			i += 2
			continue
		}
		break
	}
	return strings.TrimSpace(x[:i]), x[i:]
}

// canGenerate reports whether opcode string x can generate opcode string y.
// For example "D5 ib" can generate "D5 0A".
// Any string x is not considered to generate itself.
func canGenerate(x, y string) bool {
	i := 0
	for i < len(x) && i < len(y) && x[i] == y[i] {
		i++
	}
	if i == len(x) || i == len(y) {
		return false
	}
	switch x[i:] {
	case "ib":
		return len(y[i:]) == 2 && allHex(y[i:])
	case "0+i":
		return len(y[i:]) == 1 && '0' <= y[i] && y[i] <= '7'
	case "8+i":
		return len(y[i:]) == 1 && (y[i] == '8' || y[i] == '9' || 'A' <= y[i] && y[i] <= 'F')
	}
	return false
}

// allHex reports whether s is entirely hex digits.
func allHex(s string) bool {
	for _, c := range s {
		if '0' <= c && c <= '9' || 'A' <= c && c <= 'F' {
			continue
		}
		return false
	}
	return true
}

// is16vs32pair reports whether x and y are the 16- and 32-bit variants of the same instruction,
// based on analysis of the mnemonic syntax.
func is16vs32pair(x, y *instruction) bool {
	return conv16.Replace(x.syntax) == y.syntax ||
		strings.Replace(x.syntax, "r16, r/", "r32, r32/", -1) == y.syntax || // LSL etc
		strings.Replace(x.syntax, "r16", "r32", 1) == y.syntax // MOVSXD, MOVSX, etc
}

func containsAll(x string, targ ...string) bool {
	for _, y := range targ {
		i := strings.Index(x, y)
		if i < 0 {
			return false
		}
		x = x[i+len(y):]
	}
	return true
}