| // 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. |
| |
| // Derive format specifications. |
| |
| package main |
| |
| import ( |
| "sort" |
| "strings" |
| ) |
| |
| func format(insts []*instruction) { |
| // Determine opcodes that come in multiple sizes |
| // and could need disambiguating suffixes. |
| // Mark those with multisize=true. |
| sort.Sort(bySyntax(insts)) |
| needSize := make(map[string]bool) |
| for i := 0; i < 2; i++ { |
| seen := make(map[string]bool) |
| for _, inst := range insts { |
| if hasTag(inst, "pseudo") || hasTag(inst, "pseudo64") { |
| continue |
| } |
| switch i { |
| case 0: |
| if inst.valid32 != "V" { |
| continue |
| } |
| case 1: |
| if inst.valid64 != "V" { |
| continue |
| } |
| } |
| unsized := stripSize.Replace(inst.syntax) |
| if seen[unsized] { |
| op, _ := splitSyntax(inst.syntax) |
| needSize[op] = true |
| } |
| seen[unsized] = true |
| } |
| } |
| |
| for _, inst := range insts { |
| op, _ := splitSyntax(inst.syntax) |
| if needSize[op] || forceNeedSize[op] { |
| inst.multisize = "Y" |
| } |
| } |
| |
| // Assign data sizes. |
| for _, inst := range insts { |
| if inst.multisize != "Y" { |
| continue |
| } |
| op, args := splitSyntax(inst.syntax) |
| Args: |
| for i := startArg[op]; i < len(args); i++ { |
| switch args[i] { |
| case "AL", "r8", "r8op", "r/m8": |
| inst.datasize = 8 |
| break Args |
| case "AX", "r16", "r16op", "r/m16": |
| inst.datasize = 16 |
| break Args |
| case "EAX", "r32", "r32op", "r/m32", "rmr32", "m32fp", "m32int": |
| inst.datasize = 32 |
| break Args |
| case "RAX", "r64", "r64op", "r/m64", "rmr64", "m64fp", "m64int": |
| inst.datasize = 64 |
| break Args |
| case "m80fp": |
| inst.datasize = 80 |
| break Args |
| case "xmm2/m128": |
| inst.datasize = 128 |
| break Args |
| case "ymm2/m256": |
| inst.datasize = 256 |
| break Args |
| } |
| } |
| } |
| |
| // Determine GNU syntax for instructions. |
| // With a few exceptions, it's the Intel opcode plus an optional suffix, |
| // followed by the reversed argument list. |
| for _, inst := range insts { |
| op, args := splitSyntax(inst.syntax) |
| intelOp := op |
| op = strings.ToLower(op) |
| if custom, ok := gnuOpcode[inst.syntax]; ok { |
| op = custom |
| } else { |
| if inst.multisize == "Y" { |
| suffix := defaultSizeSuffix[inst.datasize] |
| if custom, ok := gnuSizeSuffix[op]; ok { |
| suffix = custom[inst.datasize] |
| } |
| op += suffix |
| } |
| } |
| switch intelOp { |
| case "BOUND", "ENTER": |
| // no reversal |
| default: |
| for i, j := 0, len(args)-1; i < j; i, j = i+1, j-1 { |
| args[i], args[j] = args[j], args[i] |
| } |
| } |
| inst.gnuSyntax = joinSyntax(op, args) |
| } |
| |
| // Determine Go syntax for instructions. |
| // Similar to GNU syntax (really they are both similar to "AT&T" syntax) |
| // but upper case and not reversing the argument list for a few instructions, |
| // like comparisons. |
| for _, inst := range insts { |
| intelOp, args := splitSyntax(inst.syntax) |
| |
| // start with GNU op, because it has suffixes already |
| op, _ := splitSyntax(inst.gnuSyntax) |
| op = strings.ToUpper(op) |
| if custom, ok := goOpcode[inst.syntax]; ok { |
| op = custom |
| } else if custom, ok := goOpcode[intelOp]; ok { |
| op = custom |
| } else if custom, ok := goOpcode[op]; ok { |
| op = custom |
| } else if suffix, ok := goSizeSuffix[op]; ok { |
| op += suffix[inst.datasize] |
| } |
| |
| switch intelOp { |
| case "CMP": |
| // no reversal |
| case "CMPPD", "CMPPS", "CMPSD", "CMPSS": |
| // rotate destination to end but don't swap comparison operands |
| if len(args) == 3 { |
| args[0], args[1], args[2] = args[2], args[0], args[1] |
| break |
| } |
| fallthrough |
| default: |
| for i, j := 0, len(args)-1; i < j; i, j = i+1, j-1 { |
| args[i], args[j] = args[j], args[i] |
| } |
| } |
| inst.goSyntax = joinSyntax(op, args) |
| } |
| } |
| |
| var forceNeedSize = map[string]bool{ |
| "SAL": true, |
| } |
| |
| var stripSize = strings.NewReplacer( |
| "rel8", "rel8", // leave these alone |
| "rel16", "rel16", |
| "rel32", "rel32", |
| "8", "#", |
| "16", "#", |
| "32", "#", |
| "64", "#", |
| "xmm2/m128", "xy/#", |
| "ymm2/m256", "xy/#", |
| "EAX", "AX", |
| ) |
| |
| var defaultSizeSuffix = map[int]string{ |
| 8: "b", |
| 16: "w", |
| 32: "l", |
| 64: "q", |
| } |
| |
| var gnuSizeSuffix = map[string]map[int]string{ |
| "cvtsd2si": {64: "q"}, |
| "cvtss2si": {64: "q"}, |
| "cvttsd2si": {64: "q"}, |
| "cvttss2si": {64: "q"}, |
| "vcvtsd2si": {64: "q"}, |
| "vcvtss2si": {64: "q"}, |
| "vcvttsd2si": {64: "q"}, |
| "vcvttss2si": {64: "q"}, |
| |
| "vcvtpd2dq": {128: "x", 256: "y"}, |
| "vcvtpd2ps": {128: "x", 256: "y"}, |
| "vcvttpd2dq": {128: "x", 256: "y"}, |
| "vcvttpd2ps": {128: "x", 256: "y"}, |
| |
| "fadd": {32: "s", 64: "l"}, |
| "fcom": {32: "s", 64: "l"}, |
| "fcomp": {32: "s", 64: "l"}, |
| "fdiv": {32: "s", 64: "l"}, |
| "fdivr": {32: "s", 64: "l"}, |
| "fmul": {32: "s", 64: "l"}, |
| "fsub": {32: "s", 64: "l"}, |
| "fsubr": {32: "s", 64: "l"}, |
| |
| "fld": {32: "s", 64: "l", 80: "t"}, |
| "fst": {32: "s", 64: "l", 80: "t"}, |
| "fstp": {32: "s", 64: "l", 80: "t"}, |
| |
| "fiadd": {32: "l"}, |
| "ficom": {32: "l"}, |
| "ficomp": {32: "l"}, |
| "fidiv": {32: "l"}, |
| "fidivr": {32: "l"}, |
| "fimul": {32: "l"}, |
| "fist": {32: "l"}, |
| "fisub": {32: "l"}, |
| "fisubr": {32: "l"}, |
| |
| "fild": {32: "l", 64: "ll"}, |
| "fistp": {32: "l", 64: "ll"}, |
| "fisttp": {32: "l", 64: "ll"}, |
| |
| "fldenv": {64: "l"}, |
| |
| // These can be distinguished by register name (%rcx vs %ecx) |
| // and objdump refuses to put suffixes on them. |
| "bswap": {}, |
| "rdfsbase": {}, |
| "rdgsbase": {}, |
| "rdrand": {}, |
| "rdseed": {}, |
| "wrfsbase": {}, |
| "wrgsbase": {}, |
| } |
| |
| var gnuOpcode = map[string]string{ |
| // Simple name changes. |
| "CBW": "cbtw", |
| "CDQ": "cltd", |
| "CDQE": "cltq", |
| "CMPSD": "cmpsl", |
| "CQO": "cqto", |
| "CWD": "cwtd", |
| "CWDE": "cwtl", |
| "INSD": "insl", |
| "LODSD": "lodsl", |
| "MOVSD": "movsl", |
| "OUTSD": "outsl", |
| "PUSHAD": "pushal", |
| "PUSHFD": "pushfl", |
| "POPAD": "popal", |
| "POPFD": "popfl", |
| "STOSD": "stosl", |
| "XLATB": "xlat", |
| "POPA": "popaw", |
| "POPF": "popfw", |
| "PUSHA": "pushaw", |
| "PUSHF": "pushfw", |
| "SCASD": "scasl", |
| |
| // Two-operand FDIV and FDIVR are inverted, but only for the ST(i), ST(0) form. |
| // I think this is a bug in the GNU tools but perhaps one that must be historically maintained. |
| "FDIV ST(i), ST(0)": "fdivr", |
| "FDIVR ST(i), ST(0)": "fdiv", |
| "FDIVP ST(i), ST(0)": "fdivrp", |
| "FDIVRP ST(i), ST(0)": "fdivp", |
| "FSUB ST(i), ST(0)": "fsubr", |
| "FSUBR ST(i), ST(0)": "fsub", |
| "FSUBP ST(i), ST(0)": "fsubrp", |
| "FSUBRP ST(i), ST(0)": "fsubp", |
| |
| "MOV r64op, imm64": "movabsq", |
| "MOV moffs64, RAX": "movabsq", |
| "MOV RAX, moffs64": "movabsq", |
| |
| "MOV moffs8, AL": "movb/movb/movabsb", |
| "MOV AL, moffs8": "movb/movb/movabsb", |
| |
| "LGDT m16&32": "lgdtw/lgdtl", |
| "LIDT m16&32": "lidtw/lidtl", |
| "SGDT m": "sgdtw/sgdtl/sgdt", |
| "SIDT m": "sidtw/sidtl/sidt", |
| "LEAVE": "leavew/leavel/leaveq", |
| |
| "MOVBE r16, m16": "movbeww", |
| "MOVBE m16, r16": "movbeww", |
| "MOVBE m32, r32": "movbell", |
| "MOVBE r32, m32": "movbell", |
| "MOVBE m64, r64": "movbeqq", |
| "MOVBE r64, m64": "movbeqq", |
| |
| "MOVSX r16, r/m16": "movsww", |
| "MOVSX r16, r/m8": "movsbw", |
| "MOVSX r32, r/m16": "movswl", |
| "MOVSX r32, r/m8": "movsbl", |
| "MOVSX r64, r/m16": "movswq", |
| "MOVSX r64, r/m8": "movsbq", |
| "MOVSXD r64, r/m32": "movslq", |
| "MOVZX r16, r/m16": "movzww", |
| "MOVZX r16, r/m8": "movzbw", |
| "MOVZX r32, r/m16": "movzwl", |
| "MOVZX r32, r/m8": "movzbl", |
| "MOVZX r64, r/m16": "movzwq", |
| "MOVZX r64, r/m8": "movzbq", |
| |
| "CALL r/m16": "callw*", |
| "CALL r/m32": "calll*", |
| "CALL r/m64": "callq*", |
| |
| "JMP r/m16": "jmpw*", |
| "JMP r/m32": "jmpl*", |
| "JMP r/m64": "jmpq*", |
| |
| "CALL_FAR m16:16": "lcallw*", |
| "CALL_FAR m16:32": "lcalll*", |
| "CALL_FAR m16:64": "lcallq*", |
| |
| "JMP_FAR m16:16": "ljmpw*", |
| "JMP_FAR m16:32": "ljmpl*", |
| "JMP_FAR m16:64": "ljmpq*", |
| |
| "CALL_FAR ptr16:16": "lcallw", |
| "CALL_FAR ptr16:32": "lcalll", |
| "JMP_FAR ptr16:16": "ljmpw", |
| "JMP_FAR ptr16:32": "ljmpl", |
| |
| "STR r32/m16": "str{l/w}", |
| "SMSW r32/m16": "smsw{l/w}", |
| "SLDT r32/m16": "sldt{l/w}", |
| "MOV Sreg, r32/m16": "mov{l/w}", |
| "MOV r32/m16, Sreg": "mov{l/w}", |
| |
| "STR r64/m16": "str{q/w}", |
| "SMSW r64/m16": "smsw{q/w}", |
| "SLDT r64/m16": "sldt{q/w}", |
| "MOV Sreg, r64/m16": "mov{q/w}", |
| "MOV r64/m16, Sreg": "mov{q/w}", |
| |
| "FLDENV m14/28byte": "fldenvs/fldenvl", |
| "FNSAVE m94/108byte": "fnsaves/fnsavel", |
| "FNSTENV m14/28byte": "fnstenvs/fnstenvl", |
| "FRSTOR m94/108byte": "frstors/frstorl", |
| |
| "IRETD": "iretl", |
| "IRET": "iretw", |
| "RET_FAR imm16u": "lretw/lretl/lretl", |
| "RET_FAR": "lretw/lretl/lretl", |
| "ENTER imm16, imm8b": "enterw/enterl/enterq", |
| "RET": "retw/retl/retq", |
| "SYSRET": "sysretw/sysretl/sysretl", |
| |
| "RET imm16u": "retw/retl/retq", |
| |
| "PUSH CS": "pushw/pushl/pushq", |
| "PUSH DS": "pushw/pushl/pushq", |
| "PUSH ES": "pushw/pushl/pushq", |
| "PUSH FS": "pushw/pushl/pushq", |
| "PUSH GS": "pushw/pushl/pushq", |
| "PUSH SS": "pushw/pushl/pushq", |
| |
| "PUSH imm16": "pushw", |
| |
| "POP CS": "popw/popl/popq", |
| "POP DS": "popw/popl/popq", |
| "POP ES": "popw/popl/popq", |
| "POP FS": "popw/popl/popq", |
| "POP GS": "popw/popl/popq", |
| "POP SS": "popw/popl/popq", |
| |
| "PUSH imm32": "-/pushl/pushq", |
| "PUSH imm8": "pushw/pushl/pushq", |
| } |
| |
| var startArg = map[string]int{ |
| "CRC32": 1, |
| } |
| |
| var goSizeSuffix = map[string]map[int]string{ |
| "BSWAP": {16: "W", 32: "L", 64: "Q"}, |
| } |
| |
| var goOpcode = map[string]string{ |
| // Overriding the GNU rewrites. |
| "CBW": "CBW", |
| "CDQ": "CDQ", |
| "CDQE": "CDQE", |
| "CQO": "CQO", |
| "CWD": "CWD", |
| "CWDE": "CWDE", |
| "SYSRET": "SYSRET", |
| "MOVABSQ": "MOVQ", |
| |
| // Our own rewrites, of either GNU or Intel syntax. |
| "CVTPD2DQ": "CVTPD2PL", |
| "CVTDQ2PD": "CVTPL2PD", |
| "CVTDQ2PS": "CVTPL2PS", |
| "CVTPS2DQ": "CVTPS2PL", |
| "CVTSD2SI": "CVTSD2SL", |
| "CVTSD2SIQ": "CVTSD2SQ", |
| "CVTSI2SDL": "CVTSL2SD", |
| "CVTSI2SDQ": "CVTSQ2SD", |
| "CVTSI2SSL": "CVTSL2SS", |
| "CVTSI2SSQ": "CVTSQ2SS", |
| "CVTSS2SI": "CVTSS2SL", |
| "CVTSS2SIQ": "CVTSS2SQ", |
| "CVTTPD2DQ": "CVTTPD2PL", |
| "CVTTPS2DQ": "CVTTPS2PL", |
| "CVTTSD2SI": "CVTTSD2SL", |
| "CVTTSD2SIQ": "CVTTSD2SQ", |
| "CVTTSS2SI": "CVTTSS2SL", |
| "CVTTSS2SIQ": "CVTTSS2SQ", |
| |
| "LOOPE": "LOOPEQ", |
| "MASKMOVDQU": "MASKMOVOU", |
| "MOVDQA": "MOVO", |
| "MOVDQU": "MOVOU", |
| "MOVNTDQ": "MOVNTO", |
| "MOVQ2DQ": "MOVQOZX", |
| "MOVDQ2Q": "MOVQ", |
| "MOVSBL": "MOVBLSX", |
| "MOVSBQ": "MOVBQSX", |
| "MOVSBW": "MOVBWSX", |
| "MOVSLQ": "MOVLQSX", |
| "MOVSWL": "MOVWLSX", |
| "MOVSWQ": "MOVWQSX", |
| "MOVZBL": "MOVBLZX", |
| "MOVZBQ": "MOVBQZX", |
| "MOVZBW": "MOVBWZX", |
| "MOVZLQ": "MOVLQZX", |
| "MOVZWL": "MOVWLZX", |
| "MOVZWQ": "MOVWQZX", |
| "PACKSSDW": "PACKSSLW", |
| "PADDD": "PADDL", |
| "PCMPEQD": "PCMPEQL", |
| "PCMPGTD": "PCMPGTL", |
| "PMADDWD": "PMADDWL", |
| "PMULUDQ": "PMULULQ", |
| "PSLLD": "PSLLL", |
| "PSLLDQ": "PSLLO", |
| "PSRAD": "PSRAL", |
| "PSRLD": "PSRLL", |
| "PSRLDQ": "PSRLO", |
| "PSUBD": "PSUBL", |
| "PUNPCKLWD": "PUNPCKLWL", |
| "PUNPCKHDQ": "PUNPCKHLQ", |
| "PUNPCKHWD": "PUNPCKHWL", |
| "PUNPCKLDQ": "PUNPCKLLQ", |
| "PUSHA": "PUSHAW", |
| "PUSHAD": "PUSHAL", |
| "PUSHF": "PUSHFW", |
| "PUSHFD": "PUSHFL", |
| "RET_FAR": "RETFW/RETFL/RETFQ", |
| "CALLQ": "CALL", |
| "CALLL": "CALL", |
| "CALLW": "CALL", |
| "MOVSXDW": "MOVWQSX", |
| "MOVSXDL": "MOVLQSX", |
| |
| "SHLDW": "SHLW", |
| "SHLDL": "SHLL", |
| "SHLDQ": "SHLQ", |
| "SHRDW": "SHRW", |
| "SHRDL": "SHRL", |
| "SHRDQ": "SHRQ", |
| |
| "CMOVAW": "CMOVWHI", |
| "CMOVAEW": "CMOVWCC", |
| "CMOVBW": "CMOVWCS", |
| "CMOVBEW": "CMOVWLS", |
| "CMOVCW": "CMOVWCS", |
| "CMOVCCW": "CMOVWCC", |
| "CMOVCSW": "CMOVWCS", |
| "CMOVEW": "CMOVWEQ", |
| "CMOVEQW": "CMOVWEQ", |
| "CMOVGW": "CMOVWGT", |
| "CMOVGEW": "CMOVWGE", |
| "CMOVGTW": "CMOVWGT", |
| "CMOVHIW": "CMOVWHI", |
| "CMOVHSW": "CMOVWCC", |
| "CMOVLW": "CMOVWLT", |
| "CMOVLEW": "CMOVWLE", |
| "CMOVLSW": "CMOVWLS", |
| "CMOVLTW": "CMOVWLT", |
| "CMOVLOW": "CMOVWCS", |
| "CMOVMIW": "CMOVWMI", |
| "CMOVNAW": "CMOVWLS", |
| "CMOVNAEW": "CMOVWCS", |
| "CMOVNBW": "CMOVWCC", |
| "CMOVNBEW": "CMOVWHI", |
| "CMOVNCW": "CMOVWCC", |
| "CMOVNEW": "CMOVWNE", |
| "CMOVNGW": "CMOVWLE", |
| "CMOVNGEW": "CMOVWLT", |
| "CMOVNLW": "CMOVWGE", |
| "CMOVNLEW": "CMOVWGT", |
| "CMOVNOW": "CMOVWOC", |
| "CMOVNPW": "CMOVWPC", |
| "CMOVNSW": "CMOVWPL", |
| "CMOVNZW": "CMOVWNE", |
| "CMOVOW": "CMOVWOS", |
| "CMOVOCW": "CMOVWOC", |
| "CMOVOSW": "CMOVWOS", |
| "CMOVPW": "CMOVWPS", |
| "CMOVPCW": "CMOVWPC", |
| "CMOVPEW": "CMOVWPS", |
| "CMOVPOW": "CMOVWPC", |
| "CMOVPSW": "CMOVWPS", |
| "CMOVSW": "CMOVWMI", |
| "CMOVZW": "CMOVWEQ", |
| |
| "CMOVAL": "CMOVLHI", |
| "CMOVAEL": "CMOVLCC", |
| "CMOVBL": "CMOVLCS", |
| "CMOVBEL": "CMOVLLS", |
| "CMOVCL": "CMOVLCS", |
| "CMOVCCL": "CMOVLCC", |
| "CMOVCSL": "CMOVLCS", |
| "CMOVEL": "CMOVLEQ", |
| "CMOVEQL": "CMOVLEQ", |
| "CMOVGL": "CMOVLGT", |
| "CMOVGEL": "CMOVLGE", |
| "CMOVGTL": "CMOVLGT", |
| "CMOVHIL": "CMOVLHI", |
| "CMOVHSL": "CMOVLCC", |
| "CMOVLL": "CMOVLLT", |
| "CMOVLEL": "CMOVLLE", |
| "CMOVLSL": "CMOVLLS", |
| "CMOVLTL": "CMOVLLT", |
| "CMOVLOL": "CMOVLCS", |
| "CMOVMIL": "CMOVLMI", |
| "CMOVNAL": "CMOVLLS", |
| "CMOVNAEL": "CMOVLCS", |
| "CMOVNBL": "CMOVLCC", |
| "CMOVNBEL": "CMOVLHI", |
| "CMOVNCL": "CMOVLCC", |
| "CMOVNEL": "CMOVLNE", |
| "CMOVNGL": "CMOVLLE", |
| "CMOVNGEL": "CMOVLLT", |
| "CMOVNLL": "CMOVLGE", |
| "CMOVNLEL": "CMOVLGT", |
| "CMOVNOL": "CMOVLOC", |
| "CMOVNPL": "CMOVLPC", |
| "CMOVNSL": "CMOVLPL", |
| "CMOVNZL": "CMOVLNE", |
| "CMOVOL": "CMOVLOS", |
| "CMOVOCL": "CMOVLOC", |
| "CMOVOSL": "CMOVLOS", |
| "CMOVPL": "CMOVLPS", |
| "CMOVPCL": "CMOVLPC", |
| "CMOVPEL": "CMOVLPS", |
| "CMOVPOL": "CMOVLPC", |
| "CMOVPSL": "CMOVLPS", |
| "CMOVSL": "CMOVLMI", |
| "CMOVZL": "CMOVLEQ", |
| |
| "CMOVAQ": "CMOVQHI", |
| "CMOVAEQ": "CMOVQCC", |
| "CMOVBQ": "CMOVQCS", |
| "CMOVBEQ": "CMOVQLS", |
| "CMOVCQ": "CMOVQCS", |
| "CMOVCCQ": "CMOVQCC", |
| "CMOVCSQ": "CMOVQCS", |
| "CMOVEQ": "CMOVQEQ", |
| "CMOVEQQ": "CMOVQEQ", |
| "CMOVGQ": "CMOVQGT", |
| "CMOVGEQ": "CMOVQGE", |
| "CMOVGTQ": "CMOVQGT", |
| "CMOVHIQ": "CMOVQHI", |
| "CMOVHSQ": "CMOVQCC", |
| "CMOVLQ": "CMOVQLT", |
| "CMOVLEQ": "CMOVQLE", |
| "CMOVLSQ": "CMOVQLS", |
| "CMOVLTQ": "CMOVQLT", |
| "CMOVLOQ": "CMOVQCS", |
| "CMOVMIQ": "CMOVQMI", |
| "CMOVNAQ": "CMOVQLS", |
| "CMOVNAEQ": "CMOVQCS", |
| "CMOVNBQ": "CMOVQCC", |
| "CMOVNBEQ": "CMOVQHI", |
| "CMOVNCQ": "CMOVQCC", |
| "CMOVNEQ": "CMOVQNE", |
| "CMOVNGQ": "CMOVQLE", |
| "CMOVNGEQ": "CMOVQLT", |
| "CMOVNLQ": "CMOVQGE", |
| "CMOVNLEQ": "CMOVQGT", |
| "CMOVNOQ": "CMOVQOC", |
| "CMOVNPQ": "CMOVQPC", |
| "CMOVNSQ": "CMOVQPL", |
| "CMOVNZQ": "CMOVQNE", |
| "CMOVOQ": "CMOVQOS", |
| "CMOVOCQ": "CMOVQOC", |
| "CMOVOSQ": "CMOVQOS", |
| "CMOVPQ": "CMOVQPS", |
| "CMOVPCQ": "CMOVQPC", |
| "CMOVPEQ": "CMOVQPS", |
| "CMOVPOQ": "CMOVQPC", |
| "CMOVPSQ": "CMOVQPS", |
| "CMOVSQ": "CMOVQMI", |
| "CMOVZQ": "CMOVQEQ", |
| |
| "SETA": "SETHI", |
| "SETAE": "SETCC", |
| "SETB": "SETCS", |
| "SETBE": "SETLS", |
| "SETC": "SETCS", |
| "SETCC": "SETCC", |
| "SETCS": "SETCS", |
| "SETE": "SETEQ", |
| "SETEQ": "SETEQ", |
| "SETG": "SETGT", |
| "SETGE": "SETGE", |
| "SETGT": "SETGT", |
| "SETHI": "SETHI", |
| "SETHS": "SETCC", |
| "SETL": "SETLT", |
| "SETLE": "SETLE", |
| "SETLS": "SETLS", |
| "SETLT": "SETLT", |
| "SETLO": "SETCS", |
| "SETMI": "SETMI", |
| "SETNA": "SETLS", |
| "SETNAE": "SETCS", |
| "SETNB": "SETCC", |
| "SETNBE": "SETHI", |
| "SETNC": "SETCC", |
| "SETNE": "SETNE", |
| "SETNG": "SETLE", |
| "SETNGE": "SETLT", |
| "SETNL": "SETGE", |
| "SETNLE": "SETGT", |
| "SETNO": "SETOC", |
| "SETNP": "SETPC", |
| "SETNS": "SETPL", |
| "SETNZ": "SETNE", |
| "SETO": "SETOS", |
| "SETOC": "SETOC", |
| "SETOS": "SETOS", |
| "SETP": "SETPS", |
| "SETPC": "SETPC", |
| "SETPE": "SETPS", |
| "SETPO": "SETPC", |
| "SETPS": "SETPS", |
| "SETS": "SETMI", |
| "SETZ": "SETEQ", |
| |
| "FADD": "FADDD", |
| "FADDP": "FADDDP", |
| "FADDS": "FADDF", |
| "FCOM": "FCOMD", |
| "FCOMS": "FCOMF", |
| "FCOMPS": "FCOMFP", |
| "FDIV": "FDIVD", |
| "FDIVS": "FDIVF", |
| "FDIVRS": "FDIVFR", |
| } |
