From 74fba4d8069c946c1ba12b9ac4d4026aaf14118b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C4=99drzej=20Nowacki?= Date: Tue, 29 Jan 2013 14:20:50 +0100 Subject: Say hello to QtV4 module. Change-Id: I507cd5707b7d7223a0d901cf939896fb2649b684 Reviewed-by: Lars Knoll --- src/3rdparty/masm/disassembler/Disassembler.cpp | 43 + src/3rdparty/masm/disassembler/Disassembler.h | 52 + .../masm/disassembler/UDis86Disassembler.cpp | 63 + .../masm/disassembler/udis86/differences.txt | 24 + src/3rdparty/masm/disassembler/udis86/itab.py | 360 + src/3rdparty/masm/disassembler/udis86/optable.xml | 8959 ++++++++++++++++++++ src/3rdparty/masm/disassembler/udis86/ud_opcode.py | 235 + .../masm/disassembler/udis86/ud_optable.py | 103 + src/3rdparty/masm/disassembler/udis86/udis86.c | 183 + src/3rdparty/masm/disassembler/udis86/udis86.h | 33 + .../masm/disassembler/udis86/udis86_decode.c | 1142 +++ .../masm/disassembler/udis86/udis86_decode.h | 258 + .../masm/disassembler/udis86/udis86_extern.h | 88 + .../masm/disassembler/udis86/udis86_input.c | 263 + .../masm/disassembler/udis86/udis86_input.h | 67 + .../masm/disassembler/udis86/udis86_itab_holder.c | 34 + .../masm/disassembler/udis86/udis86_syn-att.c | 253 + .../masm/disassembler/udis86/udis86_syn-intel.c | 279 + src/3rdparty/masm/disassembler/udis86/udis86_syn.c | 87 + src/3rdparty/masm/disassembler/udis86/udis86_syn.h | 47 + .../masm/disassembler/udis86/udis86_types.h | 238 + 21 files changed, 12811 insertions(+) create mode 100644 src/3rdparty/masm/disassembler/Disassembler.cpp create mode 100644 src/3rdparty/masm/disassembler/Disassembler.h create mode 100644 src/3rdparty/masm/disassembler/UDis86Disassembler.cpp create mode 100644 src/3rdparty/masm/disassembler/udis86/differences.txt create mode 100644 src/3rdparty/masm/disassembler/udis86/itab.py create mode 100644 src/3rdparty/masm/disassembler/udis86/optable.xml create mode 100644 src/3rdparty/masm/disassembler/udis86/ud_opcode.py create mode 100644 src/3rdparty/masm/disassembler/udis86/ud_optable.py create mode 100644 src/3rdparty/masm/disassembler/udis86/udis86.c create mode 100644 src/3rdparty/masm/disassembler/udis86/udis86.h create mode 100644 src/3rdparty/masm/disassembler/udis86/udis86_decode.c create mode 100644 src/3rdparty/masm/disassembler/udis86/udis86_decode.h create mode 100644 src/3rdparty/masm/disassembler/udis86/udis86_extern.h create mode 100644 src/3rdparty/masm/disassembler/udis86/udis86_input.c create mode 100644 src/3rdparty/masm/disassembler/udis86/udis86_input.h create mode 100644 src/3rdparty/masm/disassembler/udis86/udis86_itab_holder.c create mode 100644 src/3rdparty/masm/disassembler/udis86/udis86_syn-att.c create mode 100644 src/3rdparty/masm/disassembler/udis86/udis86_syn-intel.c create mode 100644 src/3rdparty/masm/disassembler/udis86/udis86_syn.c create mode 100644 src/3rdparty/masm/disassembler/udis86/udis86_syn.h create mode 100644 src/3rdparty/masm/disassembler/udis86/udis86_types.h (limited to 'src/3rdparty/masm/disassembler') diff --git a/src/3rdparty/masm/disassembler/Disassembler.cpp b/src/3rdparty/masm/disassembler/Disassembler.cpp new file mode 100644 index 0000000000..3fed2cdab8 --- /dev/null +++ b/src/3rdparty/masm/disassembler/Disassembler.cpp @@ -0,0 +1,43 @@ +/* + * Copyright (C) 2012 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "Disassembler.h" + +#include "MacroAssemblerCodeRef.h" +#include + +namespace JSC { + +void disassemble(const MacroAssemblerCodePtr& codePtr, size_t size, const char* prefix, PrintStream& out) +{ + if (tryToDisassemble(codePtr, size, prefix, out)) + return; + + out.printf("%sdisassembly not available for range %p...%p\n", prefix, codePtr.executableAddress(), static_cast(codePtr.executableAddress()) + size); +} + +} // namespace JSC + diff --git a/src/3rdparty/masm/disassembler/Disassembler.h b/src/3rdparty/masm/disassembler/Disassembler.h new file mode 100644 index 0000000000..a087a657b3 --- /dev/null +++ b/src/3rdparty/masm/disassembler/Disassembler.h @@ -0,0 +1,52 @@ +/* + * Copyright (C) 2012 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef Disassembler_h +#define Disassembler_h + +#include +#include + +namespace JSC { + +class MacroAssemblerCodePtr; + +#if ENABLE(DISASSEMBLER) +bool tryToDisassemble(const MacroAssemblerCodePtr&, size_t, const char* prefix, PrintStream&); +#else +inline bool tryToDisassemble(const MacroAssemblerCodePtr&, size_t, const char*, PrintStream&) +{ + return false; +} +#endif + +// Prints either the disassembly, or a line of text indicating that disassembly failed and +// the range of machine code addresses. +void disassemble(const MacroAssemblerCodePtr&, size_t, const char* prefix, PrintStream& out); + +} // namespace JSC + +#endif // Disassembler_h + diff --git a/src/3rdparty/masm/disassembler/UDis86Disassembler.cpp b/src/3rdparty/masm/disassembler/UDis86Disassembler.cpp new file mode 100644 index 0000000000..63c235b920 --- /dev/null +++ b/src/3rdparty/masm/disassembler/UDis86Disassembler.cpp @@ -0,0 +1,63 @@ +/* + * Copyright (C) 2012 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include "Disassembler.h" + +#if USE(UDIS86) + +#include "MacroAssemblerCodeRef.h" +#include "udis86.h" + +namespace JSC { + +bool tryToDisassemble(const MacroAssemblerCodePtr& codePtr, size_t size, const char* prefix, PrintStream& out) +{ + ud_t disassembler; + ud_init(&disassembler); + ud_set_input_buffer(&disassembler, static_cast(codePtr.executableAddress()), size); +#if CPU(X86_64) + ud_set_mode(&disassembler, 64); +#else + ud_set_mode(&disassembler, 32); +#endif + ud_set_pc(&disassembler, bitwise_cast(codePtr.executableAddress())); + ud_set_syntax(&disassembler, UD_SYN_ATT); + + uint64_t currentPC = disassembler.pc; + while (ud_disassemble(&disassembler)) { + char pcString[20]; + snprintf(pcString, sizeof(pcString), "0x%lx", static_cast(currentPC)); + out.printf("%s%16s: %s\n", prefix, pcString, ud_insn_asm(&disassembler)); + currentPC = disassembler.pc; + } + + return true; +} + +} // namespace JSC + +#endif // USE(UDIS86) + diff --git a/src/3rdparty/masm/disassembler/udis86/differences.txt b/src/3rdparty/masm/disassembler/udis86/differences.txt new file mode 100644 index 0000000000..dc225b6ffe --- /dev/null +++ b/src/3rdparty/masm/disassembler/udis86/differences.txt @@ -0,0 +1,24 @@ +This documents the differences between the stock version of udis86 and the one found +here: + +- All files not named "udis86" were prefixed with "udis86". + +- assert() has been changed to ASSERT() + +- Mass rename of udis86_input.h inp_ prefixed functions and macros to ud_inp_ to + avoid namespace pollution. + +- Removal of KERNEL checks. + +- Added #include of udis86_extern.h in udis86_decode.c. + +- Removed s_ie__pause and s_ie__nop from udis86_decode.c, since they weren't used. + +- Made udis86_syn.h use WTF_ATTRIBUTE_PRINTF. This required making a bunch of little + fixes to make the compiler's format string warnings go away. + +- Made the code in udis86_syn.h use vsnprintf() instead of vsprintf(). + +- Fixed udis86_syn-att.c's jump destination printing to work correctly in 64-bit mode. + +- Add --outputDir option to itab.py. diff --git a/src/3rdparty/masm/disassembler/udis86/itab.py b/src/3rdparty/masm/disassembler/udis86/itab.py new file mode 100644 index 0000000000..07e20a6e10 --- /dev/null +++ b/src/3rdparty/masm/disassembler/udis86/itab.py @@ -0,0 +1,360 @@ +# udis86 - scripts/itab.py +# +# Copyright (c) 2009 Vivek Thampi +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without modification, +# are permitted provided that the following conditions are met: +# +# * Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR +# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +from optparse import OptionParser +import os +import sys + +sys.path.append( '../scripts' ); + +import ud_optable +import ud_opcode + +class UdItabGenerator( ud_opcode.UdOpcodeTables ): + + OperandDict = { + "Ap" : [ "OP_A" , "SZ_P" ], + "E" : [ "OP_E" , "SZ_NA" ], + "Eb" : [ "OP_E" , "SZ_B" ], + "Ew" : [ "OP_E" , "SZ_W" ], + "Ev" : [ "OP_E" , "SZ_V" ], + "Ed" : [ "OP_E" , "SZ_D" ], + "Eq" : [ "OP_E" , "SZ_Q" ], + "Ez" : [ "OP_E" , "SZ_Z" ], + "Ex" : [ "OP_E" , "SZ_MDQ" ], + "Ep" : [ "OP_E" , "SZ_P" ], + "G" : [ "OP_G" , "SZ_NA" ], + "Gb" : [ "OP_G" , "SZ_B" ], + "Gw" : [ "OP_G" , "SZ_W" ], + "Gv" : [ "OP_G" , "SZ_V" ], + "Gy" : [ "OP_G" , "SZ_MDQ" ], + "Gy" : [ "OP_G" , "SZ_MDQ" ], + "Gd" : [ "OP_G" , "SZ_D" ], + "Gq" : [ "OP_G" , "SZ_Q" ], + "Gx" : [ "OP_G" , "SZ_MDQ" ], + "Gz" : [ "OP_G" , "SZ_Z" ], + "M" : [ "OP_M" , "SZ_NA" ], + "Mb" : [ "OP_M" , "SZ_B" ], + "Mw" : [ "OP_M" , "SZ_W" ], + "Ms" : [ "OP_M" , "SZ_W" ], + "Md" : [ "OP_M" , "SZ_D" ], + "Mq" : [ "OP_M" , "SZ_Q" ], + "Mt" : [ "OP_M" , "SZ_T" ], + "Mo" : [ "OP_M" , "SZ_O" ], + "MwRv" : [ "OP_MR" , "SZ_WV" ], + "MdRy" : [ "OP_MR" , "SZ_DY" ], + "MbRv" : [ "OP_MR" , "SZ_BV" ], + "I1" : [ "OP_I1" , "SZ_NA" ], + "I3" : [ "OP_I3" , "SZ_NA" ], + "Ib" : [ "OP_I" , "SZ_B" ], + "Isb" : [ "OP_I" , "SZ_SB" ], + "Iw" : [ "OP_I" , "SZ_W" ], + "Iv" : [ "OP_I" , "SZ_V" ], + "Iz" : [ "OP_I" , "SZ_Z" ], + "Jv" : [ "OP_J" , "SZ_V" ], + "Jz" : [ "OP_J" , "SZ_Z" ], + "Jb" : [ "OP_J" , "SZ_B" ], + "R" : [ "OP_R" , "SZ_RDQ" ], + "C" : [ "OP_C" , "SZ_NA" ], + "D" : [ "OP_D" , "SZ_NA" ], + "S" : [ "OP_S" , "SZ_NA" ], + "Ob" : [ "OP_O" , "SZ_B" ], + "Ow" : [ "OP_O" , "SZ_W" ], + "Ov" : [ "OP_O" , "SZ_V" ], + "V" : [ "OP_V" , "SZ_O" ], + "W" : [ "OP_W" , "SZ_O" ], + "Wsd" : [ "OP_W" , "SZ_O" ], + "Wss" : [ "OP_W" , "SZ_O" ], + "P" : [ "OP_P" , "SZ_Q" ], + "Q" : [ "OP_Q" , "SZ_Q" ], + "VR" : [ "OP_VR" , "SZ_O" ], + "PR" : [ "OP_PR" , "SZ_Q" ], + "AL" : [ "OP_AL" , "SZ_NA" ], + "CL" : [ "OP_CL" , "SZ_NA" ], + "DL" : [ "OP_DL" , "SZ_NA" ], + "BL" : [ "OP_BL" , "SZ_NA" ], + "AH" : [ "OP_AH" , "SZ_NA" ], + "CH" : [ "OP_CH" , "SZ_NA" ], + "DH" : [ "OP_DH" , "SZ_NA" ], + "BH" : [ "OP_BH" , "SZ_NA" ], + "AX" : [ "OP_AX" , "SZ_NA" ], + "CX" : [ "OP_CX" , "SZ_NA" ], + "DX" : [ "OP_DX" , "SZ_NA" ], + "BX" : [ "OP_BX" , "SZ_NA" ], + "SI" : [ "OP_SI" , "SZ_NA" ], + "DI" : [ "OP_DI" , "SZ_NA" ], + "SP" : [ "OP_SP" , "SZ_NA" ], + "BP" : [ "OP_BP" , "SZ_NA" ], + "eAX" : [ "OP_eAX" , "SZ_NA" ], + "eCX" : [ "OP_eCX" , "SZ_NA" ], + "eDX" : [ "OP_eDX" , "SZ_NA" ], + "eBX" : [ "OP_eBX" , "SZ_NA" ], + "eSI" : [ "OP_eSI" , "SZ_NA" ], + "eDI" : [ "OP_eDI" , "SZ_NA" ], + "eSP" : [ "OP_eSP" , "SZ_NA" ], + "eBP" : [ "OP_eBP" , "SZ_NA" ], + "rAX" : [ "OP_rAX" , "SZ_NA" ], + "rCX" : [ "OP_rCX" , "SZ_NA" ], + "rBX" : [ "OP_rBX" , "SZ_NA" ], + "rDX" : [ "OP_rDX" , "SZ_NA" ], + "rSI" : [ "OP_rSI" , "SZ_NA" ], + "rDI" : [ "OP_rDI" , "SZ_NA" ], + "rSP" : [ "OP_rSP" , "SZ_NA" ], + "rBP" : [ "OP_rBP" , "SZ_NA" ], + "ES" : [ "OP_ES" , "SZ_NA" ], + "CS" : [ "OP_CS" , "SZ_NA" ], + "DS" : [ "OP_DS" , "SZ_NA" ], + "SS" : [ "OP_SS" , "SZ_NA" ], + "GS" : [ "OP_GS" , "SZ_NA" ], + "FS" : [ "OP_FS" , "SZ_NA" ], + "ST0" : [ "OP_ST0" , "SZ_NA" ], + "ST1" : [ "OP_ST1" , "SZ_NA" ], + "ST2" : [ "OP_ST2" , "SZ_NA" ], + "ST3" : [ "OP_ST3" , "SZ_NA" ], + "ST4" : [ "OP_ST4" , "SZ_NA" ], + "ST5" : [ "OP_ST5" , "SZ_NA" ], + "ST6" : [ "OP_ST6" , "SZ_NA" ], + "ST7" : [ "OP_ST7" , "SZ_NA" ], + "NONE" : [ "OP_NONE" , "SZ_NA" ], + "ALr8b" : [ "OP_ALr8b" , "SZ_NA" ], + "CLr9b" : [ "OP_CLr9b" , "SZ_NA" ], + "DLr10b" : [ "OP_DLr10b" , "SZ_NA" ], + "BLr11b" : [ "OP_BLr11b" , "SZ_NA" ], + "AHr12b" : [ "OP_AHr12b" , "SZ_NA" ], + "CHr13b" : [ "OP_CHr13b" , "SZ_NA" ], + "DHr14b" : [ "OP_DHr14b" , "SZ_NA" ], + "BHr15b" : [ "OP_BHr15b" , "SZ_NA" ], + "rAXr8" : [ "OP_rAXr8" , "SZ_NA" ], + "rCXr9" : [ "OP_rCXr9" , "SZ_NA" ], + "rDXr10" : [ "OP_rDXr10" , "SZ_NA" ], + "rBXr11" : [ "OP_rBXr11" , "SZ_NA" ], + "rSPr12" : [ "OP_rSPr12" , "SZ_NA" ], + "rBPr13" : [ "OP_rBPr13" , "SZ_NA" ], + "rSIr14" : [ "OP_rSIr14" , "SZ_NA" ], + "rDIr15" : [ "OP_rDIr15" , "SZ_NA" ], + "jWP" : [ "OP_J" , "SZ_WP" ], + "jDP" : [ "OP_J" , "SZ_DP" ], + + } + + # + # opcode prefix dictionary + # + PrefixDict = { + "aso" : "P_aso", + "oso" : "P_oso", + "rexw" : "P_rexw", + "rexb" : "P_rexb", + "rexx" : "P_rexx", + "rexr" : "P_rexr", + "seg" : "P_seg", + "inv64" : "P_inv64", + "def64" : "P_def64", + "depM" : "P_depM", + "cast1" : "P_c1", + "cast2" : "P_c2", + "cast3" : "P_c3", + "cast" : "P_cast", + "sext" : "P_sext" + } + + InvalidEntryIdx = 0 + InvalidEntry = { 'type' : 'invalid', + 'mnemonic' : 'invalid', + 'operands' : '', + 'prefixes' : '', + 'meta' : '' } + + Itab = [] # instruction table + ItabIdx = 1 # instruction table index + GtabIdx = 0 # group table index + GtabMeta = [] + + ItabLookup = {} + + MnemonicAliases = ( "invalid", "3dnow", "none", "db", "pause" ) + + def __init__( self, outputDir ): + # first itab entry (0) is Invalid + self.Itab.append( self.InvalidEntry ) + self.MnemonicsTable.extend( self.MnemonicAliases ) + self.outputDir = outputDir + + def toGroupId( self, id ): + return 0x8000 | id + + def genLookupTable( self, table, scope = '' ): + idxArray = [ ] + ( tabIdx, self.GtabIdx ) = ( self.GtabIdx, self.GtabIdx + 1 ) + self.GtabMeta.append( { 'type' : table[ 'type' ], 'meta' : table[ 'meta' ] } ) + + for _idx in range( self.sizeOfTable( table[ 'type' ] ) ): + idx = "%02x" % _idx + + e = self.InvalidEntry + i = self.InvalidEntryIdx + + if idx in table[ 'entries' ].keys(): + e = table[ 'entries' ][ idx ] + + # leaf node (insn) + if e[ 'type' ] == 'insn': + ( i, self.ItabIdx ) = ( self.ItabIdx, self.ItabIdx + 1 ) + self.Itab.append( e ) + elif e[ 'type' ] != 'invalid': + i = self.genLookupTable( e, 'static' ) + + idxArray.append( i ) + + name = "ud_itab__%s" % tabIdx + self.ItabLookup[ tabIdx ] = name + + self.ItabC.write( "\n" ); + if len( scope ): + self.ItabC.write( scope + ' ' ) + self.ItabC.write( "const uint16_t %s[] = {\n" % name ) + for i in range( len( idxArray ) ): + if i > 0 and i % 4 == 0: + self.ItabC.write( "\n" ) + if ( i%4 == 0 ): + self.ItabC.write( " /* %2x */" % i) + if idxArray[ i ] >= 0x8000: + self.ItabC.write( "%12s," % ("GROUP(%d)" % ( ~0x8000 & idxArray[ i ] ))) + else: + self.ItabC.write( "%12d," % ( idxArray[ i ] )) + self.ItabC.write( "\n" ) + self.ItabC.write( "};\n" ) + + return self.toGroupId( tabIdx ) + + def genLookupTableList( self ): + self.ItabC.write( "\n\n" ); + self.ItabC.write( "struct ud_lookup_table_list_entry ud_lookup_table_list[] = {\n" ) + for i in range( len( self.GtabMeta ) ): + f0 = self.ItabLookup[ i ] + "," + f1 = ( self.nameOfTable( self.GtabMeta[ i ][ 'type' ] ) ) + "," + f2 = "\"%s\"" % self.GtabMeta[ i ][ 'meta' ] + self.ItabC.write( " /* %03d */ { %s %s %s },\n" % ( i, f0, f1, f2 ) ) + self.ItabC.write( "};" ) + + def genInsnTable( self ): + self.ItabC.write( "struct ud_itab_entry ud_itab[] = {\n" ); + idx = 0 + for e in self.Itab: + opr_c = [ "O_NONE", "O_NONE", "O_NONE" ] + pfx_c = [] + opr = e[ 'operands' ] + for i in range(len(opr)): + if not (opr[i] in self.OperandDict.keys()): + print "error: invalid operand declaration: %s\n" % opr[i] + opr_c[i] = "O_" + opr[i] + opr = "%s %s %s" % (opr_c[0] + ",", opr_c[1] + ",", opr_c[2]) + + for p in e['prefixes']: + if not ( p in self.PrefixDict.keys() ): + print "error: invalid prefix specification: %s \n" % pfx + pfx_c.append( self.PrefixDict[p] ) + if len(e['prefixes']) == 0: + pfx_c.append( "P_none" ) + pfx = "|".join( pfx_c ) + + self.ItabC.write( " /* %04d */ { UD_I%s %s, %s },\n" \ + % ( idx, e[ 'mnemonic' ] + ',', opr, pfx ) ) + idx += 1 + self.ItabC.write( "};\n" ) + + self.ItabC.write( "\n\n" ); + self.ItabC.write( "const char * ud_mnemonics_str[] = {\n" ) + self.ItabC.write( ",\n ".join( [ "\"%s\"" % m for m in self.MnemonicsTable ] ) ) + self.ItabC.write( "\n};\n" ) + + + def genItabH( self ): + self.ItabH = open( os.path.join(self.outputDir, "udis86_itab.h"), "w" ) + + # Generate Table Type Enumeration + self.ItabH.write( "#ifndef UD_ITAB_H\n" ) + self.ItabH.write( "#define UD_ITAB_H\n\n" ) + + # table type enumeration + self.ItabH.write( "/* ud_table_type -- lookup table types (see lookup.c) */\n" ) + self.ItabH.write( "enum ud_table_type {\n " ) + enum = [ self.TableInfo[ k ][ 'name' ] for k in self.TableInfo.keys() ] + self.ItabH.write( ",\n ".join( enum ) ) + self.ItabH.write( "\n};\n\n" ); + + # mnemonic enumeration + self.ItabH.write( "/* ud_mnemonic -- mnemonic constants */\n" ) + enum = "enum ud_mnemonic_code {\n " + enum += ",\n ".join( [ "UD_I%s" % m for m in self.MnemonicsTable ] ) + enum += "\n} UD_ATTR_PACKED;\n" + self.ItabH.write( enum ) + self.ItabH.write( "\n" ) + + self.ItabH.write("\n/* itab entry operand definitions */\n"); + operands = self.OperandDict.keys() + operands.sort() + for o in operands: + self.ItabH.write("#define O_%-7s { %-12s %-8s }\n" % + (o, self.OperandDict[o][0] + ",", self.OperandDict[o][1])); + self.ItabH.write("\n\n"); + + self.ItabH.write( "extern const char * ud_mnemonics_str[];\n" ) + + self.ItabH.write( "#define GROUP(n) (0x8000 | (n))" ) + + self.ItabH.write( "\n#endif /* UD_ITAB_H */\n" ) + + self.ItabH.close() + + + def genItabC( self ): + self.ItabC = open( os.path.join(self.outputDir, "udis86_itab.c"), "w" ) + self.ItabC.write( "/* itab.c -- generated by itab.py, do no edit" ) + self.ItabC.write( " */\n" ); + self.ItabC.write( "#include \"udis86_decode.h\"\n\n" ); + + self.genLookupTable( self.OpcodeTable0 ) + self.genLookupTableList() + self.genInsnTable() + + self.ItabC.close() + + def genItab( self ): + self.genItabC() + self.genItabH() + +def main(): + parser = OptionParser() + parser.add_option("--outputDir", dest="outputDir", default="") + options, args = parser.parse_args() + generator = UdItabGenerator(os.path.normpath(options.outputDir)) + optableXmlParser = ud_optable.UdOptableXmlParser() + optableXmlParser.parse( args[ 0 ], generator.addInsnDef ) + + generator.genItab() + +if __name__ == '__main__': + main() diff --git a/src/3rdparty/masm/disassembler/udis86/optable.xml b/src/3rdparty/masm/disassembler/udis86/optable.xml new file mode 100644 index 0000000000..14b4ac5935 --- /dev/null +++ b/src/3rdparty/masm/disassembler/udis86/optable.xml @@ -0,0 +1,8959 @@ + + + + + + aaa + + 37 + inv64 + + + + + aad + + d5 + Ib + inv64 + + + + + aam + + d4 + Ib + inv64 + + + + + aas + + 3f + inv64 + + + + + adc + + aso rexr rexx rexb + 10 + Eb Gb + + + aso oso rexw rexr rexx rexb + 11 + Ev Gv + + + aso rexr rexx rexb + 12 + Gb Eb + + + aso oso rexw rexr rexx rexb + 13 + Gv Ev + + + 14 + AL Ib + + + oso rexw + 15 + rAX Iz + sext + + + aso rexr rexx rexb + 80 /reg=2 + Eb Ib + + + aso rexr rexx rexb + 82 /reg=2 + Eb Ib + inv64 + + + aso oso rexw rexr rexx rexb + 81 /reg=2 + Ev Iz + sext + + + aso oso rexw rexr rexx rexb + 83 /reg=2 + Ev Ib + sext + + + + + add + + aso rexr rexx rexb + 00 + Eb Gb + + + aso oso rexw rexr rexx rexb + 01 + Ev Gv + + + aso rexr rexx rexb + 02 + Gb Eb + + + aso oso rexw rexr rexx rexb + 03 + Gv Ev + + + 04 + AL Ib + + + oso rexw + 05 + rAX Iz + sext + + + aso rexr rexx rexb + 80 /reg=0 + Eb Ib + + + aso rexr rexx rexb + 82 /reg=0 + Eb Ib + inv64 + + + aso oso rexw rexr rexx rexb + 81 /reg=0 + Ev Iz + sext + + + aso oso rexw rexr rexx rexb + 83 /reg=0 + Ev Ib + sext + + + + + + + addpd + + aso rexr rexx rexb + sse66 0f 58 + V W + + + + + addps + + aso rexr rexx rexb + 0f 58 + V W + + + + + addsd + + aso rexr rexx rexb + ssef2 0f 58 + V W + + + + + addss + + aso rexr rexx rexb + ssef3 0f 58 + V W + + + + + and + + aso rexr rexx rexb + 20 + Eb Gb + + + aso oso rexw rexr rexx rexb + 21 + Ev Gv + + + aso rexr rexx rexb + 22 + Gb Eb + + + aso oso rexw rexr rexx rexb + 23 + Gv Ev + + + 24 + AL Ib + + + oso rexw + 25 + rAX Iz + sext + + + aso rexw rexr rexx rexb + 80 /reg=4 + Eb Ib + + + aso rexr rexx rexb + 82 /reg=4 + Eb Ib + inv64 + + + aso oso rexw rexr rexx rexb + 81 /reg=4 + Ev Iz + sext + + + aso oso rexw rexr rexx rexb + 83 /reg=4 + Ev Ib + sext + + + + + andpd + + aso rexr rexx rexb + sse66 0f 54 + V W + + + + + andps + + aso rexr rexx rexb + 0f 54 + V W + + + + + andnpd + + aso rexr rexx rexb + sse66 0f 55 + V W + + + + + andnps + + aso rexr rexx rexb + 0f 55 + V W + + + + + arpl + + aso + 63 /m=16 + Ew Gw + inv64 + + + aso + 63 /m=32 + Ew Gw + inv64 + + + + + movsxd + + aso oso rexw rexx rexr rexb + 63 /m=64 + Gv Ed + + + + + bound + + aso oso + 62 + Gv M + inv64 + + + + + bsf + + aso oso rexw rexr rexx rexb + 0f bc + Gv Ev + + + + + bsr + + aso oso rexw rexr rexx rexb + 0f bd + Gv Ev + + + + + bswap + + oso rexw rexb + 0f c8 + rAXr8 + + + oso rexw rexb + 0f c9 + rCXr9 + + + oso rexw rexb + 0f ca + rDXr10 + + + oso rexw rexb + 0f cb + rBXr11 + + + oso rexw rexb + 0f cc + rSPr12 + + + oso rexw rexb + 0f cd + rBPr13 + + + oso rexw rexb + 0f ce + rSIr14 + + + oso rexw rexb + 0f cf + rDIr15 + + + + + bt + + aso oso rexw rexr rexx rexb + 0f ba /reg=4 + Ev Ib + + + aso oso rexw rexr rexx rexb + 0f a3 + Ev Gv + + + + + btc + + aso oso rexw rexr rexx rexb + 0f bb + Ev Gv + + + aso oso rexw rexr rexx rexb + 0f ba /reg=7 + Ev Ib + + + + + btr + + aso oso rexw rexr rexx rexb + 0f b3 + Ev Gv + + + aso oso rexw rexr rexx rexb + 0f ba /reg=6 + Ev Ib + + + + + bts + + aso oso rexw rexr rexx rexb + 0f ab + Ev Gv + + + aso oso rexw rexr rexx rexb + 0f ba /reg=5 + Ev Ib + + + + + call + + aso oso rexw rexr rexx rexb + ff /reg=2 + Ev + def64 + + + aso oso rexw rexr rexx rexb + ff /reg=3 + Ep + + + oso + e8 + Jz + def64 + + + oso + 9a + Ap + inv64 + + + + + cbw + + oso rexw + 98 /o=16 + + + + + cwde + + oso rexw + 98 /o=32 + + + + + cdqe + + oso rexw + 98 /o=64 + + + + + clc + + f8 + + + + + cld + + fc + + + + + clflush + + aso rexw rexr rexx rexb + 0f ae /reg=7 /mod=!11 + M + + + + + clgi + amd + + 0f 01 /reg=3 /mod=11 /rm=5 + + + + + cli + + fa + + + + + clts + + 0f 06 + + + + + cmc + + f5 + + + + + cmovo + + aso oso rexw rexr rexx rexb + 0f 40 + Gv Ev + + + + + cmovno + + aso oso rexw rexr rexx rexb + 0f 41 + Gv Ev + + + + + cmovb + + aso oso rexw rexr rexx rexb + 0f 42 + Gv Ev + + + + + cmovae + + aso oso rexw rexr rexx rexb + 0f 43 + Gv Ev + + + + + cmovz + + aso oso rexw rexr rexx rexb + 0f 44 + Gv Ev + + + + + cmovnz + + aso oso rexw rexr rexx rexb + 0f 45 + Gv Ev + + + + + cmovbe + + aso oso rexw rexr rexx rexb + 0f 46 + Gv Ev + + + + + cmova + + aso oso rexw rexr rexx rexb + 0f 47 + Gv Ev + + + + + cmovs + + aso oso rexw rexr rexx rexb + 0f 48 + Gv Ev + + + + + cmovns + + aso oso rexw rexr rexx rexb + 0f 49 + Gv Ev + + + + + cmovp + + aso oso rexw rexr rexx rexb + 0f 4a + Gv Ev + + + + + cmovnp + + aso oso rexw rexr rexx rexb + 0f 4b + Gv Ev + + + + + cmovl + + aso oso rexw rexr rexx rexb + 0f 4c + Gv Ev + + + + + cmovge + + aso oso rexw rexr rexx rexb + 0f 4d + Gv Ev + + + + + cmovle + + aso oso rexw rexr rexx rexb + 0f 4e + Gv Ev + + + + + cmovg + + aso oso rexw rexr rexx rexb + 0f 4f + Gv Ev + + + + + cmp + + aso rexr rexx rexb + 38 + Eb Gb + + + aso oso rexw rexr rexx rexb + 39 + Ev Gv + + + aso rexr rexx rexb + 3a + Gb Eb + + + aso oso rexw rexr rexx rexb + 3b + Gv Ev + + + 3c + AL Ib + + + oso rexw + 3d + rAX Iz + + + aso rexr rexx rexb + 80 /reg=7 + Eb Ib + + + aso rexr rexx rexb + 82 /reg=7 + Eb Ib + inv64 + + + aso oso rexw rexr rexx rexb + 81 /reg=7 + Ev Iz + + + aso oso rexw rexr rexx rexb + 83 /reg=7 + Ev Ib + + + + + cmppd + + aso rexr rexx rexb + sse66 0f c2 + V W Ib + + + + + cmpps + + aso rexr rexx rexb + 0f c2 + V W Ib + + + + + cmpsb + + a6 + + + + + cmpsw + + oso rexw + a7 /o=16 + + + + + cmpsd + + oso rexw + a7 /o=32 + + + aso rexr rexx rexb + ssef2 0f c2 + V W Ib + + + + + cmpsq + + oso rexw + a7 /o=64 + + + + + cmpss + + aso rexr rexx rexb + ssef3 0f c2 + V W Ib + + + + + cmpxchg + + aso rexr rexx rexb + 0f b0 + Eb Gb + + + aso oso rexw rexr rexx rexb + 0f b1 + Ev Gv + + + + + cmpxchg8b + + aso rexr rexx rexb + 0f c7 /reg=1 + M + + + + + comisd + + aso rexr rexx rexb + sse66 0f 2f + V W + + + + + comiss + + aso rexr rexx rexb + 0f 2f + V W + + + + + cpuid + + 0f a2 + + + + + cvtdq2pd + + aso rexr rexx rexb + ssef3 0f e6 + V W + + + + + cvtdq2ps + + aso rexr rexx rexb + 0f 5b + V W + + + + + cvtpd2dq + + aso rexr rexx rexb + ssef2 0f e6 + V W + + + + + cvtpd2pi + + aso rexr rexx rexb + sse66 0f 2d + P W + + + + + cvtpd2ps + + aso rexr rexx rexb + sse66 0f 5a + V W + + + + + cvtpi2ps + + aso rexr rexx rexb + 0f 2a + V Q + + + + + cvtpi2pd + + aso rexr rexx rexb + sse66 0f 2a + V Q + + + + + cvtps2dq + + aso rexr rexx rexb + sse66 0f 5b + V W + + + + + cvtps2pi + + aso rexr rexx rexb + 0f 2d + P W + + + + + cvtps2pd + + aso rexr rexx rexb + 0f 5a + V W + + + + + cvtsd2si + + aso rexw rexr rexx rexb + ssef2 0f 2d + Gy W + + + + + cvtsd2ss + + aso rexr rexx rexb + ssef2 0f 5a + V W + + + + + cvtsi2ss + + aso rexw rexr rexx rexb + ssef3 0f 2a + V Ex + + + + + cvtss2si + + aso rexw rexr rexx rexb + ssef3 0f 2d + Gy W + + + + + cvtss2sd + + aso rexr rexx rexb + ssef3 0f 5a + V W + + + + + cvttpd2pi + + aso rexr rexx rexb + sse66 0f 2c + P W + + + + + cvttpd2dq + + aso rexr rexx rexb + sse66 0f e6 + V W + + + + + cvttps2dq + + aso rexr rexx rexb + ssef3 0f 5b + V W + + + + + cvttps2pi + + aso rexr rexx rexb + 0f 2c + P W + + + + + cvttsd2si + + aso rexw rexr rexx rexb + ssef2 0f 2c + Gy Wsd + + + + + cvtsi2sd + + aso rexw rexr rexx rexb + ssef2 0f 2a + V Ex + + + + + cvttss2si + + aso rexw rexr rexx rexb + ssef3 0f 2c + Gy Wsd + + + + + cwd + + oso rexw + 99 /o=16 + + + + + cdq + + oso rexw + 99 /o=32 + + + + + cqo + + oso rexw + 99 /o=64 + + + + + daa + + 27 + inv64 + + + + + das + + 2f + inv64 + + + + + dec + + oso + 48 + eAX + + + oso + 49 + eCX + + + oso + 4a + eDX + + + oso + 4b + eBX + + + oso + 4c + eSP + + + oso + 4d + eBP + + + oso + 4e + eSI + + + oso + 4f + eDI + + + aso rexw rexr rexx rexb + fe /reg=1 + Eb + + + aso oso rexw rexr rexx rexb + ff /reg=1 + Ev + + + + + div + + aso oso rexw rexr rexx rexb + f7 /reg=6 + Ev + + + aso rexw rexr rexx rexb + f6 /reg=6 + Eb + + + + + divpd + + aso rexr rexx rexb + sse66 0f 5e + V W + + + + + divps + + aso rexr rexx rexb + 0f 5e + V W + + + + + divsd + + aso rexr rexx rexb + ssef2 0f 5e + V W + + + + + divss + + aso rexr rexx rexb + ssef3 0f 5e + V W + + + + + emms + + 0f 77 + + + + + enter + + c8 + Iw Ib + def64 depM + + + + + f2xm1 + X87 + + d9 /mod=11 /x87=30 + + + + + fabs + X87 + + d9 /mod=11 /x87=21 + + + + + fadd + X87 + + aso rexr rexx rexb + dc /mod=!11 /reg=0 + Mq + + + aso rexr rexx rexb + d8 /mod=!11 /reg=0 + Md + + + dc /mod=11 /x87=00 + ST0 ST0 + + + dc /mod=11 /x87=01 + ST1 ST0 + + + dc /mod=11 /x87=02 + ST2 ST0 + + + dc /mod=11 /x87=03 + ST3 ST0 + + + dc /mod=11 /x87=04 + ST4 ST0 + + + dc /mod=11 /x87=05 + ST5 ST0 + + + dc /mod=11 /x87=06 + ST6 ST0 + + + dc /mod=11 /x87=07 + ST7 ST0 + + + d8 /mod=11 /x87=00 + ST0 ST0 + + + d8 /mod=11 /x87=01 + ST0 ST1 + + + d8 /mod=11 /x87=02 + ST0 ST2 + + + d8 /mod=11 /x87=03 + ST0 ST3 + + + d8 /mod=11 /x87=04 + ST0 ST4 + + + d8 /mod=11 /x87=05 + ST0 ST5 + + + d8 /mod=11 /x87=06 + ST0 ST6 + + + d8 /mod=11 /x87=07 + ST0 ST7 + + + + + faddp + X87 + + de /mod=11 /x87=00 + ST0 ST0 + + + de /mod=11 /x87=01 + ST1 ST0 + + + de /mod=11 /x87=02 + ST2 ST0 + + + de /mod=11 /x87=03 + ST3 ST0 + + + de /mod=11 /x87=04 + ST4 ST0 + + + de /mod=11 /x87=05 + ST5 ST0 + + + de /mod=11 /x87=06 + ST6 ST0 + + + de /mod=11 /x87=07 + ST7 ST0 + + + + + fbld + X87 + + aso rexr rexx rexb + df /mod=!11 /reg=4 + Mt + + + + + fbstp + X87 + + aso rexr rexx rexb + df /mod=!11 /reg=6 + Mt + + + + + fchs + X87 + + d9 /mod=11 /x87=20 + + + + + fclex + X87 + + db /mod=11 /x87=22 + + + + + fcmovb + X87 + + da /mod=11 /x87=00 + ST0 ST0 + + + da /mod=11 /x87=01 + ST0 ST1 + + + da /mod=11 /x87=02 + ST0 ST2 + + + da /mod=11 /x87=03 + ST0 ST3 + + + da /mod=11 /x87=04 + ST0 ST4 + + + da /mod=11 /x87=05 + ST0 ST5 + + + da /mod=11 /x87=06 + ST0 ST6 + + + da /mod=11 /x87=07 + ST0 ST7 + + + + + fcmove + X87 + + da /mod=11 /x87=08 + ST0 ST0 + + + da /mod=11 /x87=09 + ST0 ST1 + + + da /mod=11 /x87=0a + ST0 ST2 + + + da /mod=11 /x87=0b + ST0 ST3 + + + da /mod=11 /x87=0c + ST0 ST4 + + + da /mod=11 /x87=0d + ST0 ST5 + + + da /mod=11 /x87=0e + ST0 ST6 + + + da /mod=11 /x87=0f + ST0 ST7 + + + + + fcmovbe + X87 + + da /mod=11 /x87=10 + ST0 ST0 + + + da /mod=11 /x87=11 + ST0 ST1 + + + da /mod=11 /x87=12 + ST0 ST2 + + + da /mod=11 /x87=13 + ST0 ST3 + + + da /mod=11 /x87=14 + ST0 ST4 + + + da /mod=11 /x87=15 + ST0 ST5 + + + da /mod=11 /x87=16 + ST0 ST6 + + + da /mod=11 /x87=17 + ST0 ST7 + + + + + fcmovu + X87 + + da /mod=11 /x87=18 + ST0 ST0 + + + da /mod=11 /x87=19 + ST0 ST1 + + + da /mod=11 /x87=1a + ST0 ST2 + + + da /mod=11 /x87=1b + ST0 ST3 + + + da /mod=11 /x87=1c + ST0 ST4 + + + da /mod=11 /x87=1d + ST0 ST5 + + + da /mod=11 /x87=1e + ST0 ST6 + + + da /mod=11 /x87=1f + ST0 ST7 + + + + + fcmovnb + X87 + + db /mod=11 /x87=00 + ST0 ST0 + + + db /mod=11 /x87=01 + ST0 ST1 + + + db /mod=11 /x87=02 + ST0 ST2 + + + db /mod=11 /x87=03 + ST0 ST3 + + + db /mod=11 /x87=04 + ST0 ST4 + + + db /mod=11 /x87=05 + ST0 ST5 + + + db /mod=11 /x87=06 + ST0 ST6 + + + db /mod=11 /x87=07 + ST0 ST7 + + + + + fcmovne + X87 + + db /mod=11 /x87=08 + ST0 ST0 + + + db /mod=11 /x87=09 + ST0 ST1 + + + db /mod=11 /x87=0a + ST0 ST2 + + + db /mod=11 /x87=0b + ST0 ST3 + + + db /mod=11 /x87=0c + ST0 ST4 + + + db /mod=11 /x87=0d + ST0 ST5 + + + db /mod=11 /x87=0e + ST0 ST6 + + + db /mod=11 /x87=0f + ST0 ST7 + + + + + fcmovnbe + X87 + + db /mod=11 /x87=10 + ST0 ST0 + + + db /mod=11 /x87=11 + ST0 ST1 + + + db /mod=11 /x87=12 + ST0 ST2 + + + db /mod=11 /x87=13 + ST0 ST3 + + + db /mod=11 /x87=14 + ST0 ST4 + + + db /mod=11 /x87=15 + ST0 ST5 + + + db /mod=11 /x87=16 + ST0 ST6 + + + db /mod=11 /x87=17 + ST0 ST7 + + + + + fcmovnu + X87 + + db /mod=11 /x87=18 + ST0 ST0 + + + db /mod=11 /x87=19 + ST0 ST1 + + + db /mod=11 /x87=1a + ST0 ST2 + + + db /mod=11 /x87=1b + ST0 ST3 + + + db /mod=11 /x87=1c + ST0 ST4 + + + db /mod=11 /x87=1d + ST0 ST5 + + + db /mod=11 /x87=1e + ST0 ST6 + + + db /mod=11 /x87=1f + ST0 ST7 + + + + + fucomi + X87 + + db /mod=11 /x87=28 + ST0 ST0 + + + db /mod=11 /x87=29 + ST0 ST1 + + + db /mod=11 /x87=2a + ST0 ST2 + + + db /mod=11 /x87=2b + ST0 ST3 + + + db /mod=11 /x87=2c + ST0 ST4 + + + db /mod=11 /x87=2d + ST0 ST5 + + + db /mod=11 /x87=2e + ST0 ST6 + + + db /mod=11 /x87=2f + ST0 ST7 + + + + + fcom + X87 + + aso rexr rexx rexb + d8 /mod=!11 /reg=2 + Md + + + aso rexr rexx rexb + dc /mod=!11 /reg=2 + Mq + + + d8 /mod=11 /x87=10 + ST0 ST0 + + + d8 /mod=11 /x87=11 + ST0 ST1 + + + d8 /mod=11 /x87=12 + ST0 ST2 + + + d8 /mod=11 /x87=13 + ST0 ST3 + + + d8 /mod=11 /x87=14 + ST0 ST4 + + + d8 /mod=11 /x87=15 + ST0 ST5 + + + d8 /mod=11 /x87=16 + ST0 ST6 + + + d8 /mod=11 /x87=17 + ST0 ST7 + + + + + fcom2 + X87 UNDOC + + dc /mod=11 /x87=10 + ST0 + + + dc /mod=11 /x87=11 + ST1 + + + dc /mod=11 /x87=12 + ST2 + + + dc /mod=11 /x87=13 + ST3 + + + dc /mod=11 /x87=14 + ST4 + + + dc /mod=11 /x87=15 + ST5 + + + dc /mod=11 /x87=16 + ST6 + + + dc /mod=11 /x87=17 + ST7 + + + + + fcomp3 + X87 UNDOC + + dc /mod=11 /x87=18 + ST0 + + + dc /mod=11 /x87=19 + ST1 + + + dc /mod=11 /x87=1a + ST2 + + + dc /mod=11 /x87=1b + ST3 + + + dc /mod=11 /x87=1c + ST4 + + + dc /mod=11 /x87=1d + ST5 + + + dc /mod=11 /x87=1e + ST6 + + + dc /mod=11 /x87=1f + ST7 + + + + + fcomi + X87 + + db /mod=11 /x87=30 + ST0 ST0 + + + db /mod=11 /x87=31 + ST0 ST1 + + + db /mod=11 /x87=32 + ST0 ST2 + + + db /mod=11 /x87=33 + ST0 ST3 + + + db /mod=11 /x87=34 + ST0 ST4 + + + db /mod=11 /x87=35 + ST0 ST5 + + + db /mod=11 /x87=36 + ST0 ST6 + + + db /mod=11 /x87=37 + ST0 ST7 + + + + + fucomip + X87 + + df /mod=11 /x87=28 + ST0 ST0 + + + df /mod=11 /x87=29 + ST0 ST1 + + + df /mod=11 /x87=2a + ST0 ST2 + + + df /mod=11 /x87=2b + ST0 ST3 + + + df /mod=11 /x87=2c + ST0 ST4 + + + df /mod=11 /x87=2d + ST0 ST5 + + + df /mod=11 /x87=2e + ST0 ST6 + + + df /mod=11 /x87=2f + ST0 ST7 + + + + + fcomip + X87 + + df /mod=11 /x87=30 + ST0 ST0 + + + df /mod=11 /x87=31 + ST0 ST1 + + + df /mod=11 /x87=32 + ST0 ST2 + + + df /mod=11 /x87=33 + ST0 ST3 + + + df /mod=11 /x87=34 + ST0 ST4 + + + df /mod=11 /x87=35 + ST0 ST5 + + + df /mod=11 /x87=36 + ST0 ST6 + + + df /mod=11 /x87=37 + ST0 ST7 + + + + + fcomp + X87 + + aso rexr rexx rexb + d8 /mod=!11 /reg=3 + Md + + + aso rexr rexx rexb + dc /mod=!11 /reg=3 + Mq + + + d8 /mod=11 /x87=18 + ST0 ST0 + + + d8 /mod=11 /x87=19 + ST0 ST1 + + + d8 /mod=11 /x87=1a + ST0 ST2 + + + d8 /mod=11 /x87=1b + ST0 ST3 + + + d8 /mod=11 /x87=1c + ST0 ST4 + + + d8 /mod=11 /x87=1d + ST0 ST5 + + + d8 /mod=11 /x87=1e + ST0 ST6 + + + d8 /mod=11 /x87=1f + ST0 ST7 + + + + + fcomp5 + X87 UNDOC + + de /mod=11 /x87=10 + ST0 + + + de /mod=11 /x87=11 + ST1 + + + de /mod=11 /x87=12 + ST2 + + + de /mod=11 /x87=13 + ST3 + + + de /mod=11 /x87=14 + ST4 + + + de /mod=11 /x87=15 + ST5 + + + de /mod=11 /x87=16 + ST6 + + + de /mod=11 /x87=17 + ST7 + + + + + fcompp + X87 + + de /mod=11 /x87=19 + + + + + fcos + X87 + + d9 /mod=11 /x87=3f + + + + + fdecstp + X87 + + d9 /mod=11 /x87=36 + + + + + fdiv + X87 + + aso rexr rexx rexb + dc /mod=!11 /reg=6 + Mq + + + dc /mod=11 /x87=38 + ST0 ST0 + + + dc /mod=11 /x87=39 + ST1 ST0 + + + dc /mod=11 /x87=3a + ST2 ST0 + + + dc /mod=11 /x87=3b + ST3 ST0 + + + dc /mod=11 /x87=3c + ST4 ST0 + + + dc /mod=11 /x87=3d + ST5 ST0 + + + dc /mod=11 /x87=3e + ST6 ST0 + + + dc /mod=11 /x87=3f + ST7 ST0 + + + aso rexr rexx rexb + d8 /mod=!11 /reg=6 + Md + + + d8 /mod=11 /x87=30 + ST0 ST0 + + + d8 /mod=11 /x87=31 + ST0 ST1 + + + d8 /mod=11 /x87=32 + ST0 ST2 + + + d8 /mod=11 /x87=33 + ST0 ST3 + + + d8 /mod=11 /x87=34 + ST0 ST4 + + + d8 /mod=11 /x87=35 + ST0 ST5 + + + d8 /mod=11 /x87=36 + ST0 ST6 + + + d8 /mod=11 /x87=37 + ST0 ST7 + + + + + fdivp + X87 + + de /mod=11 /x87=38 + ST0 ST0 + + + de /mod=11 /x87=39 + ST1 ST0 + + + de /mod=11 /x87=3a + ST2 ST0 + + + de /mod=11 /x87=3b + ST3 ST0 + + + de /mod=11 /x87=3c + ST4 ST0 + + + de /mod=11 /x87=3d + ST5 ST0 + + + de /mod=11 /x87=3e + ST6 ST0 + + + de /mod=11 /x87=3f + ST7 ST0 + + + + + fdivr + X87 + + aso rexr rexx rexb + dc /mod=!11 /reg=7 + Mq + + + dc /mod=11 /x87=30 + ST0 ST0 + + + dc /mod=11 /x87=31 + ST1 ST0 + + + dc /mod=11 /x87=32 + ST2 ST0 + + + dc /mod=11 /x87=33 + ST3 ST0 + + + dc /mod=11 /x87=34 + ST4 ST0 + + + dc /mod=11 /x87=35 + ST5 ST0 + + + dc /mod=11 /x87=36 + ST6 ST0 + + + dc /mod=11 /x87=37 + ST7 ST0 + + + aso rexr rexx rexb + d8 /mod=!11 /reg=7 + Md + + + d8 /mod=11 /x87=38 + ST0 ST0 + + + d8 /mod=11 /x87=39 + ST0 ST1 + + + d8 /mod=11 /x87=3a + ST0 ST2 + + + d8 /mod=11 /x87=3b + ST0 ST3 + + + d8 /mod=11 /x87=3c + ST0 ST4 + + + d8 /mod=11 /x87=3d + ST0 ST5 + + + d8 /mod=11 /x87=3e + ST0 ST6 + + + d8 /mod=11 /x87=3f + ST0 ST7 + + + + + fdivrp + X87 + + de /mod=11 /x87=30 + ST0 ST0 + + + de /mod=11 /x87=31 + ST1 ST0 + + + de /mod=11 /x87=32 + ST2 ST0 + + + de /mod=11 /x87=33 + ST3 ST0 + + + de /mod=11 /x87=34 + ST4 ST0 + + + de /mod=11 /x87=35 + ST5 ST0 + + + de /mod=11 /x87=36 + ST6 ST0 + + + de /mod=11 /x87=37 + ST7 ST0 + + + + + femms + + 0f 0e + + + + + ffree + X87 + + dd /mod=11 /x87=00 + ST0 + + + dd /mod=11 /x87=01 + ST1 + + + dd /mod=11 /x87=02 + ST2 + + + dd /mod=11 /x87=03 + ST3 + + + dd /mod=11 /x87=04 + ST4 + + + dd /mod=11 /x87=05 + ST5 + + + dd /mod=11 /x87=06 + ST6 + + + dd /mod=11 /x87=07 + ST7 + + + + + ffreep + X87 + + df /mod=11 /x87=00 + ST0 + + + df /mod=11 /x87=01 + ST1 + + + df /mod=11 /x87=02 + ST2 + + + df /mod=11 /x87=03 + ST3 + + + df /mod=11 /x87=04 + ST4 + + + df /mod=11 /x87=05 + ST5 + + + df /mod=11 /x87=06 + ST6 + + + df /mod=11 /x87=07 + ST7 + + + + + ficom + X87 + + aso rexr rexx rexb + de /mod=!11 /reg=2 + Mw + + + aso rexr rexx rexb + da /mod=!11 /reg=2 + Md + + + + + ficomp + X87 + + aso rexr rexx rexb + de /mod=!11 /reg=3 + Mw + + + aso rexr rexx rexb + da /mod=!11 /reg=3 + Md + + + + + fild + X87 + + aso rexr rexx rexb + df /mod=!11 /reg=0 + Mw + + + aso rexr rexx rexb + df /mod=!11 /reg=5 + Mq + + + aso rexr rexx rexb + db /mod=!11 /reg=0 + Md + + + + + fncstp + X87 + + d9 /mod=11 /x87=37 + + + + + fninit + X87 + + db /mod=11 /x87=23 + + + + + fiadd + X87 + + aso rexr rexx rexb + da /mod=!11 /reg=0 + Md + + + aso rexr rexx rexb + de /mod=!11 /reg=0 + Mw + + + + + fidivr + X87 + + aso rexr rexx rexb + da /mod=!11 /reg=7 + Md + + + aso rexr rexx rexb + de /mod=!11 /reg=7 + Mw + + + + + fidiv + X87 + + aso rexr rexx rexb + da /mod=!11 /reg=6 + Md + + + aso rexr rexx rexb + de /mod=!11 /reg=6 + Mw + + + + + fisub + X87 + + aso rexr rexx rexb + da /mod=!11 /reg=4 + Md + + + aso rexr rexx rexb + de /mod=!11 /reg=4 + Mw + + + + + fisubr + X87 + + aso rexr rexx rexb + da /mod=!11 /reg=5 + Md + + + aso rexr rexx rexb + de /mod=!11 /reg=5 + Mw + + + + + fist + X87 + + aso rexr rexx rexb + df /mod=!11 /reg=2 + Mw + + + aso rexr rexx rexb + db /mod=!11 /reg=2 + Md + + + + + fistp + X87 + + aso rexr rexx rexb + df /mod=!11 /reg=3 + Mw + + + aso rexr rexx rexb + df /mod=!11 /reg=7 + Mq + + + aso rexr rexx rexb + db /mod=!11 /reg=3 + Md + + + + + fisttp + X87 + + aso rexr rexx rexb + db /mod=!11 /reg=1 + Md + + + aso rexr rexx rexb + dd /mod=!11 /reg=1 + Mq + + + aso rexr rexx rexb + df /mod=!11 /reg=1 + Mw + + + + + fld + X87 + + aso rexr rexx rexb + db /mod=!11 /reg=5 + Mt + + + aso rexr rexx rexb + dd /mod=!11 /reg=0 + Mq + + + aso rexr rexx rexb + d9 /mod=!11 /reg=0 + Md + + + d9 /mod=11 /x87=00 + ST0 + + + d9 /mod=11 /x87=01 + ST1 + + + d9 /mod=11 /x87=02 + ST2 + + + d9 /mod=11 /x87=03 + ST3 + + + d9 /mod=11 /x87=04 + ST4 + + + d9 /mod=11 /x87=05 + ST5 + + + d9 /mod=11 /x87=06 + ST6 + + + d9 /mod=11 /x87=07 + ST7 + + + + + fld1 + X87 + + d9 /mod=11 /x87=28 + + + + + fldl2t + X87 + + d9 /mod=11 /x87=29 + + + + + fldl2e + X87 + + d9 /mod=11 /x87=2a + + + + + fldlpi + X87 + + d9 /mod=11 /x87=2b + + + + + fldlg2 + X87 + + d9 /mod=11 /x87=2c + + + + + fldln2 + X87 + + d9 /mod=11 /x87=2d + + + + + fldz + X87 + + d9 /mod=11 /x87=2e + + + + + fldcw + X87 + + aso rexr rexx rexb + d9 /mod=!11 /reg=5 + Mw + + + + + fldenv + X87 + + aso rexr rexx rexb + d9 /mod=!11 /reg=4 + M + + + + + fmul + X87 + + aso rexr rexx rexb + dc /mod=!11 /reg=1 + Mq + + + dc /mod=11 /x87=08 + ST0 ST0 + + + dc /mod=11 /x87=09 + ST1 ST0 + + + dc /mod=11 /x87=0a + ST2 ST0 + + + dc /mod=11 /x87=0b + ST3 ST0 + + + dc /mod=11 /x87=0c + ST4 ST0 + + + dc /mod=11 /x87=0d + ST5 ST0 + + + dc /mod=11 /x87=0e + ST6 ST0 + + + dc /mod=11 /x87=0f + ST7 ST0 + + + aso rexr rexx rexb + d8 /mod=!11 /reg=1 + Md + + + d8 /mod=11 /x87=08 + ST0 ST0 + + + d8 /mod=11 /x87=09 + ST0 ST1 + + + d8 /mod=11 /x87=0a + ST0 ST2 + + + d8 /mod=11 /x87=0b + ST0 ST3 + + + d8 /mod=11 /x87=0c + ST0 ST4 + + + d8 /mod=11 /x87=0d + ST0 ST5 + + + d8 /mod=11 /x87=0e + ST0 ST6 + + + d8 /mod=11 /x87=0f + ST0 ST7 + + + + + fmulp + X87 + + de /mod=11 /x87=08 + ST0 ST0 + + + de /mod=11 /x87=09 + ST1 ST0 + + + de /mod=11 /x87=0a + ST2 ST0 + + + de /mod=11 /x87=0b + ST3 ST0 + + + de /mod=11 /x87=0c + ST4 ST0 + + + de /mod=11 /x87=0d + ST5 ST0 + + + de /mod=11 /x87=0e + ST6 ST0 + + + de /mod=11 /x87=0f + ST7 ST0 + + + + + fimul + X87 + + aso rexr rexx rexb + da /mod=!11 /reg=1 + Md + + + aso rexr rexx rexb + de /mod=!11 /reg=1 + Mw + + + + + fnop + X87 + + d9 /mod=11 /x87=10 + + + + + fpatan + X87 + + d9 /mod=11 /x87=33 + + + + + fprem + X87 + + d9 /mod=11 /x87=38 + + + + + fprem1 + X87 + + d9 /mod=11 /x87=35 + + + + + fptan + X87 + + d9 /mod=11 /x87=32 + + + + + frndint + X87 + + d9 /mod=11 /x87=3c + + + + + frstor + X87 + + aso rexr rexx rexb + dd /mod=!11 /reg=4 + M + + + + + fnsave + X87 + + aso rexr rexx rexb + dd /mod=!11 /reg=6 + M + + + + + fscale + X87 + + d9 /mod=11 /x87=3d + + + + + fsin + X87 + + d9 /mod=11 /x87=3e + + + + + fsincos + X87 + + d9 /mod=11 /x87=3b + + + + + fsqrt + X87 + + d9 /mod=11 /x87=3a + + + + + fstp + X87 + + aso rexr rexx rexb + db /mod=!11 /reg=7 + Mt + + + aso rexr rexx rexb + dd /mod=!11 /reg=3 + Mq + + + aso rexr rexx rexb + d9 /mod=!11 /reg=3 + Md + + + dd /mod=11 /x87=18 + ST0 + + + dd /mod=11 /x87=19 + ST1 + + + dd /mod=11 /x87=1a + ST2 + + + dd /mod=11 /x87=1b + ST3 + + + dd /mod=11 /x87=1c + ST4 + + + dd /mod=11 /x87=1d + ST5 + + + dd /mod=11 /x87=1e + ST6 + + + dd /mod=11 /x87=1f + ST7 + + + + + fstp1 + + d9 /mod=11 /x87=18 + ST0 + + + d9 /mod=11 /x87=19 + ST1 + + + d9 /mod=11 /x87=1a + ST2 + + + d9 /mod=11 /x87=1b + ST3 + + + d9 /mod=11 /x87=1c + ST4 + + + d9 /mod=11 /x87=1d + ST5 + + + d9 /mod=11 /x87=1e + ST6 + + + d9 /mod=11 /x87=1f + ST7 + + + + + fstp8 + + df /mod=11 /x87=10 + ST0 + + + df /mod=11 /x87=11 + ST1 + + + df /mod=11 /x87=12 + ST2 + + + df /mod=11 /x87=13 + ST3 + + + df /mod=11 /x87=14 + ST4 + + + df /mod=11 /x87=15 + ST5 + + + df /mod=11 /x87=16 + ST6 + + + df /mod=11 /x87=17 + ST7 + + + + + fstp9 + + df /mod=11 /x87=18 + ST0 + + + df /mod=11 /x87=19 + ST1 + + + df /mod=11 /x87=1a + ST2 + + + df /mod=11 /x87=1b + ST3 + + + df /mod=11 /x87=1c + ST4 + + + df /mod=11 /x87=1d + ST5 + + + df /mod=11 /x87=1e + ST6 + + + df /mod=11 /x87=1f + ST7 + + + + + fst + X87 + + aso rexr rexx rexb + d9 /mod=!11 /reg=2 + Md + + + aso rexr rexx rexb + dd /mod=!11 /reg=2 + Mq + + + dd /mod=11 /x87=10 + ST0 + + + dd /mod=11 /x87=11 + ST1 + + + dd /mod=11 /x87=12 + ST2 + + + dd /mod=11 /x87=13 + ST3 + + + dd /mod=11 /x87=14 + ST4 + + + dd /mod=11 /x87=15 + ST5 + + + dd /mod=11 /x87=16 + ST6 + + + dd /mod=11 /x87=17 + ST7 + + + + + fnstcw + X87 + + aso rexr rexx rexb + d9 /mod=!11 /reg=7 + Mw + + + + + fnstenv + X87 + + aso rexr rexx rexb + d9 /mod=!11 /reg=6 + M + + + + + fnstsw + X87 + + aso rexr rexx rexb + dd /mod=!11 /reg=7 + Mw + + + df /mod=11 /x87=20 + AX + + + + + fsub + X87 + + aso rexr rexx rexb + d8 /mod=!11 /reg=4 + Md + + + aso rexr rexx rexb + dc /mod=!11 /reg=4 + Mq + + + d8 /mod=11 /x87=20 + ST0 ST0 + + + d8 /mod=11 /x87=21 + ST0 ST1 + + + d8 /mod=11 /x87=22 + ST0 ST2 + + + d8 /mod=11 /x87=23 + ST0 ST3 + + + d8 /mod=11 /x87=24 + ST0 ST4 + + + d8 /mod=11 /x87=25 + ST0 ST5 + + + d8 /mod=11 /x87=26 + ST0 ST6 + + + d8 /mod=11 /x87=27 + ST0 ST7 + + + dc /mod=11 /x87=28 + ST0 ST0 + + + dc /mod=11 /x87=29 + ST1 ST0 + + + dc /mod=11 /x87=2a + ST2 ST0 + + + dc /mod=11 /x87=2b + ST3 ST0 + + + dc /mod=11 /x87=2c + ST4 ST0 + + + dc /mod=11 /x87=2d + ST5 ST0 + + + dc /mod=11 /x87=2e + ST6 ST0 + + + dc /mod=11 /x87=2f + ST7 ST0 + + + + + fsubp + X87 + + de /mod=11 /x87=28 + ST0 ST0 + + + de /mod=11 /x87=29 + ST1 ST0 + + + de /mod=11 /x87=2a + ST2 ST0 + + + de /mod=11 /x87=2b + ST3 ST0 + + + de /mod=11 /x87=2c + ST4 ST0 + + + de /mod=11 /x87=2d + ST5 ST0 + + + de /mod=11 /x87=2e + ST6 ST0 + + + de /mod=11 /x87=2f + ST7 ST0 + + + + + fsubr + X87 + + aso rexr rexx rexb + dc /mod=!11 /reg=5 + Mq + + + d8 /mod=11 /x87=28 + ST0 ST0 + + + d8 /mod=11 /x87=29 + ST0 ST1 + + + d8 /mod=11 /x87=2a + ST0 ST2 + + + d8 /mod=11 /x87=2b + ST0 ST3 + + + d8 /mod=11 /x87=2c + ST0 ST4 + + + d8 /mod=11 /x87=2d + ST0 ST5 + + + d8 /mod=11 /x87=2e + ST0 ST6 + + + d8 /mod=11 /x87=2f + ST0 ST7 + + + dc /mod=11 /x87=20 + ST0 ST0 + + + dc /mod=11 /x87=21 + ST1 ST0 + + + dc /mod=11 /x87=22 + ST2 ST0 + + + dc /mod=11 /x87=23 + ST3 ST0 + + + dc /mod=11 /x87=24 + ST4 ST0 + + + dc /mod=11 /x87=25 + ST5 ST0 + + + dc /mod=11 /x87=26 + ST6 ST0 + + + dc /mod=11 /x87=27 + ST7 ST0 + + + aso rexr rexx rexb + d8 /mod=!11 /reg=5 + Md + + + + + fsubrp + X87 + + de /mod=11 /x87=20 + ST0 ST0 + + + de /mod=11 /x87=21 + ST1 ST0 + + + de /mod=11 /x87=22 + ST2 ST0 + + + de /mod=11 /x87=23 + ST3 ST0 + + + de /mod=11 /x87=24 + ST4 ST0 + + + de /mod=11 /x87=25 + ST5 ST0 + + + de /mod=11 /x87=26 + ST6 ST0 + + + de /mod=11 /x87=27 + ST7 ST0 + + + + + ftst + X87 + + d9 /mod=11 /x87=24 + + + + + fucom + X87 + + dd /mod=11 /x87=20 + ST0 + + + dd /mod=11 /x87=21 + ST1 + + + dd /mod=11 /x87=22 + ST2 + + + dd /mod=11 /x87=23 + ST3 + + + dd /mod=11 /x87=24 + ST4 + + + dd /mod=11 /x87=25 + ST5 + + + dd /mod=11 /x87=26 + ST6 + + + dd /mod=11 /x87=27 + ST7 + + + + + fucomp + X87 + + dd /mod=11 /x87=28 + ST0 + + + dd /mod=11 /x87=29 + ST1 + + + dd /mod=11 /x87=2a + ST2 + + + dd /mod=11 /x87=2b + ST3 + + + dd /mod=11 /x87=2c + ST4 + + + dd /mod=11 /x87=2d + ST5 + + + dd /mod=11 /x87=2e + ST6 + + + dd /mod=11 /x87=2f + ST7 + + + + + fucompp + X87 + + da /mod=11 /x87=29 + + + + + fxam + X87 + + d9 /mod=11 /x87=25 + + + + + fxch + X87 + + d9 /mod=11 /x87=08 + ST0 ST0 + + + d9 /mod=11 /x87=09 + ST0 ST1 + + + d9 /mod=11 /x87=0a + ST0 ST2 + + + d9 /mod=11 /x87=0b + ST0 ST3 + + + d9 /mod=11 /x87=0c + ST0 ST4 + + + d9 /mod=11 /x87=0d + ST0 ST5 + + + d9 /mod=11 /x87=0e + ST0 ST6 + + + d9 /mod=11 /x87=0f + ST0 ST7 + + + + + fxch4 + X87 + + dd /mod=11 /x87=08 + ST0 + + + dd /mod=11 /x87=09 + ST1 + + + dd /mod=11 /x87=0a + ST2 + + + dd /mod=11 /x87=0b + ST3 + + + dd /mod=11 /x87=0c + ST4 + + + dd /mod=11 /x87=0d + ST5 + + + dd /mod=11 /x87=0e + ST6 + + + dd /mod=11 /x87=0f + ST7 + + + + + fxch7 + X87 + + df /mod=11 /x87=08 + ST0 + + + df /mod=11 /x87=09 + ST1 + + + df /mod=11 /x87=0a + ST2 + + + df /mod=11 /x87=0b + ST3 + + + df /mod=11 /x87=0c + ST4 + + + df /mod=11 /x87=0d + ST5 + + + df /mod=11 /x87=0e + ST6 + + + df /mod=11 /x87=0f + ST7 + + + + + fxrstor + + aso rexw rexr rexx rexb + 0f ae /mod=11 /reg=1 + M + + + + + fxsave + + aso rexw rexr rexx rexb + 0f ae /mod=11 /reg=0 + M + + + + + fpxtract + X87 + + d9 /mod=11 /x87=34 + + + + + fyl2x + X87 + + d9 /mod=11 /x87=31 + + + + + fyl2xp1 + X87 + + d9 /mod=11 /x87=39 + + + + + hlt + + f4 + + + + + idiv + + aso oso rexw rexr rexx rexb + f7 /reg=7 + Ev + + + aso rexw rexr rexx rexb + f6 /reg=7 + Eb + + + + + in + + e4 + AL Ib + + + oso + e5 + eAX Ib + + + ec + AL DX + + + oso + ed + eAX DX + + + + + imul + + aso oso rexw rexr rexx rexb + 0f af + Gv Ev + + + aso rexw rexr rexx rexb + f6 /reg=5 + Eb + + + aso oso rexw rexr rexx rexb + f7 /reg=5 + Ev + + + aso oso rexw rexr rexx rexb + 69 + Gv Ev Iz + sext + + + aso oso rexw rexr rexx rexb + 6b + Gv Ev Ib + sext + + + + + inc + + oso + 40 + eAX + + + oso + 41 + eCX + + + oso + 42 + eDX + + + oso + 43 + eBX + + + oso + 44 + eSP + + + oso + 45 + eBP + + + oso + 46 + eSI + + + oso + 47 + eDI + + + aso oso rexw rexr rexx rexb + ff /reg=0 + Ev + + + aso rexw rexr rexx rexb + fe /reg=0 + Eb + + + + + insb + + 6c + + + + + insw + + oso + 6d /o=16 + + + + + insd + + oso + 6d /o=32 + + + + + int1 + + f1 + + + + + int3 + + cc + + + + + int + + cd + Ib + + + + + into + + ce + inv64 + + + + + invd + + 0f 08 + + + + + invept + intel + + sse66 0f 38 80 /m=32 + Gd Mo + + + sse66 0f 38 80 /m=64 + Gq Mo + + + + + invlpg + + aso rexr rexx rexb + 0f 01 /reg=7 /mod=!11 + M + + + + + invlpga + amd + + 0f 01 /reg=3 /mod=11 /rm=7 + + + + + invvpid + intel + + sse66 0f 38 81 /m=32 + Gd Mo + + + sse66 0f 38 81 /m=64 + Gq Mo + + + + + iretw + + oso rexw + cf /o=16 + + + + + iretd + + oso rexw + cf /o=32 + + + + + iretq + + oso rexw + cf /o=64 + + + + + jo + + 70 + Jb + + + oso + 0f 80 + Jz + def64 depM + + + + + jno + + 71 + Jb + + + oso + 0f 81 + Jz + def64 depM + + + + + jb + + 72 + Jb + + + oso + 0f 82 + Jz + def64 depM + + + + + jae + + 73 + Jb + + + oso + 0f 83 + Jz + def64 depM + + + + + jz + + 74 + Jb + + + oso + 0f 84 + Jz + def64 depM + + + + + jnz + + 75 + Jb + + + oso + 0f 85 + Jz + def64 depM + + + + + jbe + + 76 + Jb + + + oso + 0f 86 + Jz + def64 depM + + + + + ja + + 77 + Jb + + + oso + 0f 87 + Jz + def64 depM + + + + + js + + 78 + Jb + + + oso + 0f 88 + Jz + def64 depM + + + + + jns + + 79 + Jb + + + oso + 0f 89 + Jz + def64 depM + + + + + jp + + 7a + Jb + + + oso + 0f 8a + Jz + def64 depM + + + + + jnp + + 7b + Jb + + + oso + 0f 8b + Jz + def64 depM + + + + + jl + + 7c + Jb + + + oso + 0f 8c + Jz + def64 depM + + + + + jge + + 7d + Jb + + + oso + 0f 8d + Jz + def64 depM + + + + + jle + + 7e + Jb + + + oso + 0f 8e + Jz + def64 depM + + + + + jg + + 7f + Jb + + + oso + 0f 8f + Jz + def64 depM + + + + + jcxz + + aso + e3 /a=16 + Jb + + + + + jecxz + + aso + e3 /a=32 + Jb + + + + + jrcxz + + aso + e3 /a=64 + Jb + + + + + jmp + + aso oso rexw rexr rexx rexb + ff /reg=4 + Ev + def64 depM + + + aso oso rexw rexr rexx rexb + ff /reg=5 + Ep + + + oso + e9 + Jz + def64 depM + cast + + + ea + Ap + inv64 + + + eb + Jb + + + + + lahf + + 9f + + + + + lar + + aso oso rexw rexr rexx rexb + 0f 02 + Gv Ew + + + + + lddqu + + aso rexr rexx rexb + ssef2 0f f0 + V M + + + + + ldmxcsr + + aso rexw rexr rexx rexb + 0f ae /reg=2 /mod=11 + Md + + + + + lds + + aso oso + c5 + Gv M + inv64 + + + + + lea + + aso oso rexw rexr rexx rexb + 8d + Gv M + + + + + les + + aso oso + c4 + Gv M + inv64 + + + + + lfs + + aso oso rexw rexr rexx rexb + 0f b4 + Gz M + + + + + lgs + + aso oso rexw rexr rexx rexb + 0f b5 + Gz M + + + + + lidt + + aso rexr rexx rexb + 0f 01 /reg=3 /mod=!11 + M + + + + + lss + + aso oso rexw rexr rexx rexb + 0f b2 + Gz M + + + + + leave + + c9 + + + + + lfence + + 0f ae /reg=5 /mod=11 /rm=0 + + + 0f ae /reg=5 /mod=11 /rm=1 + + + 0f ae /reg=5 /mod=11 /rm=2 + + + 0f ae /reg=5 /mod=11 /rm=3 + + + 0f ae /reg=5 /mod=11 /rm=4 + + + 0f ae /reg=5 /mod=11 /rm=5 + + + 0f ae /reg=5 /mod=11 /rm=6 + + + 0f ae /reg=5 /mod=11 /rm=7 + + + + + lgdt + + aso rexr rexx rexb + 0f 01 /reg=2 /mod=!11 + M + + + + + lldt + + aso rexr rexx rexb + 0f 00 /reg=2 + Ew + + + + + lmsw + + aso rexr rexx rexb + 0f 01 /reg=6 /mod=!11 + Ew + + + + + lock + + f0 + + + + + lodsb + + seg + ac + + + + + lodsw + + seg oso rexw + ad /o=16 + + + + + lodsd + + seg oso rexw + ad /o=32 + + + + + lodsq + + seg oso rexw + ad /o=64 + + + + + loopnz + + e0 + Jb + + + + + loope + + e1 + Jb + + + + + loop + + e2 + Jb + + + + + lsl + + aso oso rexw rexr rexx rexb + 0f 03 + Gv Ew + + + + + ltr + + aso rexr rexx rexb + 0f 00 /reg=3 + Ew + + + + + maskmovq + + aso rexr rexx rexb + 0f f7 + P PR + + + + + maxpd + + aso rexr rexx rexb + sse66 0f 5f + V W + + + + + maxps + + aso rexr rexx rexb + 0f 5f + V W + + + + + maxsd + + aso rexr rexx rexb + ssef2 0f 5f + V W + + + + + maxss + + aso rexr rexx rexb + ssef3 0f 5f + V W + + + + + mfence + + 0f ae /reg=6 /mod=11 /rm=0 + + + 0f ae /reg=6 /mod=11 /rm=1 + + + 0f ae /reg=6 /mod=11 /rm=2 + + + 0f ae /reg=6 /mod=11 /rm=3 + + + 0f ae /reg=6 /mod=11 /rm=4 + + + 0f ae /reg=6 /mod=11 /rm=5 + + + 0f ae /reg=6 /mod=11 /rm=6 + + + 0f ae /reg=6 /mod=11 /rm=7 + + + + + minpd + + aso rexr rexx rexb + sse66 0f 5d + V W + + + + + minps + + aso rexr rexx rexb + 0f 5d + V W + + + + + minsd + + aso rexr rexx rexb + ssef2 0f 5d + V W + + + + + minss + + aso rexr rexx rexb + ssef3 0f 5d + V W + + + + + monitor + + 0f 01 /reg=1 /mod=11 /rm=0 + + + + + montmul + + 0f a6 /mod=11 /rm=0 /reg=0 + + + + + mov + + aso rexw rexr rexx rexb + c6 /reg=0 + Eb Ib + + + aso oso rexw rexr rexx rexb + c7 /reg=0 + Ev Iz + + + aso rexr rexx rexb + 88 + Eb Gb + + + aso oso rexw rexr rexx rexb + 89 + Ev Gv + + + aso rexr rexx rexb + 8a + Gb Eb + + + aso oso rexw rexr rexx rexb + 8b + Gv Ev + + + aso oso rexr rexx rexb + 8c + Ev S + + + aso oso rexr rexx rexb + 8e + S Ev + + + a0 + AL Ob + + + aso oso rexw + a1 + rAX Ov + + + a2 + Ob AL + + + aso oso rexw + a3 + Ov rAX + + + rexb + b0 + ALr8b Ib + + + rexb + b1 + CLr9b Ib + + + rexb + b2 + DLr10b Ib + + + rexb + b3 + BLr11b Ib + + + rexb + b4 + AHr12b Ib + + + rexb + b5 + CHr13b Ib + + + rexb + b6 + DHr14b Ib + + + rexb + b7 + BHr15b Ib + + + oso rexw rexb + b8 + rAXr8 Iv + + + oso rexw rexb + b9 + rCXr9 Iv + + + oso rexw rexb + ba + rDXr10 Iv + + + oso rexw rexb + bb + rBXr11 Iv + + + oso rexw rexb + bc + rSPr12 Iv + + + oso rexw rexb + bd + rBPr13 Iv + + + oso rexw rexb + be + rSIr14 Iv + + + oso rexw rexb + bf + rDIr15 Iv + + + rexr + 0f 20 + R C + + + rexr + 0f 21 + R D + + + rexr + 0f 22 + C R + + + rexr + 0f 23 + D R + + + + + movapd + + aso rexr rexx rexb + sse66 0f 28 + V W + + + aso rexr rexx rexb + sse66 0f 29 + W V + + + + + movaps + + aso rexr rexx rexb + 0f 28 + V W + + + aso rexr rexx rexb + 0f 29 + W V + + + + + movd + + aso rexw rexr rexx rexb + sse66 0f 6e + V Ex + + + aso rexr rexx rexb + 0f 6e + P Ex + + + aso rexw rexr rexx rexb + sse66 0f 7e + Ex V + + + aso rexr rexx rexb + 0f 7e + Ex P + + + + + movhpd + + aso rexr rexx rexb + sse66 0f 16 /mod=!11 + V M + + + aso rexr rexx rexb + sse66 0f 17 + M V + + + + + movhps + + aso rexr rexx rexb + 0f 16 /mod=!11 + V M + + + aso rexr rexx rexb + 0f 17 + M V + + + + + movlhps + + aso rexr rexx rexb + 0f 16 /mod=11 + V VR + + + + + movlpd + + aso rexr rexx rexb + sse66 0f 12 /mod=!11 + V M + + + aso rexr rexx rexb + sse66 0f 13 + M V + + + + + movlps + + aso rexr rexx rexb + 0f 12 /mod=!11 + V M + + + aso rexr rexx rexb + 0f 13 + M V + + + + + movhlps + + aso rexr rexx rexb + 0f 12 /mod=11 + V VR + + + + + movmskpd + + oso rexr rexb + sse66 0f 50 + Gd VR + + + + + movmskps + + oso rexr rexb + 0f 50 + Gd VR + + + + + movntdq + + aso rexr rexx rexb + sse66 0f e7 + M V + + + + + movnti + + aso rexw rexr rexx rexb + 0f c3 + M Gy + + + + + movntpd + + aso rexr rexx rexb + sse66 0f 2b + M V + + + + + movntps + + aso rexr rexx rexb + 0f 2b + M V + + + + + movntq + + 0f e7 + M P + + + + + movq + + aso rexr rexx rexb + 0f 6f + P Q + + + aso rexr rexx rexb + sse66 0f d6 + W V + + + aso rexr rexx rexb + ssef3 0f 7e + V W + + + aso rexr rexx rexb + 0f 7f + Q P + + + + + movsb + + seg + a4 + + + + + movsw + + seg oso rexw + a5 /o=16 + + + + + movsd + + seg oso rexw + a5 /o=32 + + + aso rexr rexx rexb + ssef2 0f 10 + V W + + + aso rexr rexx rexb + ssef2 0f 11 + W V + + + + + movsq + + seg oso rexw + a5 /o=64 + + + + + movss + + aso rexr rexx rexb + ssef3 0f 10 + V W + + + aso rexr rexx rexb + ssef3 0f 11 + W V + + + + + movsx + + aso oso rexw rexr rexx rexb + 0f be + Gv Eb + + + aso oso rexw rexr rexx rexb + 0f bf + Gv Ew + + + + + movupd + + aso rexr rexx rexb + sse66 0f 10 + V W + + + aso rexr rexx rexb + sse66 0f 11 + W V + + + + + movups + + aso rexr rexx rexb + 0f 10 + V W + + + aso rexr rexx rexb + 0f 11 + W V + + + + + movzx + + aso oso rexw rexr rexx rexb + 0f b6 + Gv Eb + + + aso oso rexw rexr rexx rexb + 0f b7 + Gv Ew + + + + + mul + + aso rexw rexr rexx rexb + f6 /reg=4 + Eb + + + aso oso rexw rexr rexx rexb + f7 /reg=4 + Ev + + + + + mulpd + + aso rexr rexx rexb + sse66 0f 59 + V W + + + + + mulps + + aso rexr rexx rexb + 0f 59 + V W + + + + + mulsd + + aso rexr rexx rexb + ssef2 0f 59 + V W + + + + + mulss + + aso rexr rexx rexb + ssef3 0f 59 + V W + + + + + mwait + + 0f 01 /reg=1 /mod=11 /rm=1 + + + + + neg + + aso rexw rexr rexx rexb + f6 /reg=3 + Eb + + + aso oso rexw rexr rexx rexb + f7 /reg=3 + Ev + + + + + nop + + 90 + + + aso rexr rexx rexb + 0f 19 + M + + + aso rexr rexx rexb + 0f 1a + M + + + aso rexr rexx rexb + 0f 1b + M + + + aso rexr rexx rexb + 0f 1c + M + + + aso rexr rexx rexb + 0f 1d + M + + + aso rexr rexx rexb + 0f 1e + M + + + aso rexr rexx rexb + 0f 1f + M + + + + + not + + aso rexw rexr rexx rexb + f6 /reg=2 + Eb + + + aso oso rexw rexr rexx rexb + f7 /reg=2 + Ev + + + + + or + + aso rexr rexx rexb + 08 + Eb Gb + + + aso oso rexw rexr rexx rexb + 09 + Ev Gv + + + aso rexr rexx rexb + 0a + Gb Eb + + + aso oso rexw rexr rexx rexb + 0b + Gv Ev + + + 0c + AL Ib + + + oso rexw + 0d + rAX Iz + sext + + + aso rexr rexx rexb + 80 /reg=1 + Eb Ib + + + aso oso rexw rexr rexx rexb + 81 /reg=1 + Ev Iz + sext + + + aso rexr rexx rexb + 82 /reg=1 + Eb Ib + inv64 + + + aso oso rexw rexr rexx rexb + 83 /reg=1 + Ev Ib + sext + + + + + orpd + + aso rexr rexx rexb + sse66 0f 56 + V W + + + + + orps + + aso rexr rexx rexb + 0f 56 + V W + + + + + out + + e6 + Ib AL + + + oso + e7 + Ib eAX + + + ee + DX AL + + + oso + ef + DX eAX + + + + + outsb + + 6e + + + + + outsw + + oso + 6f /o=16 + + + + + outsd + + oso + 6f /o=32 + + + + + outsq + + oso + 6f /o=64 + + + + + packsswb + + aso rexr rexx rexb + sse66 0f 63 + V W + + + aso rexr rexx rexb + 0f 63 + P Q + + + + + packssdw + + aso rexr rexx rexb + sse66 0f 6b + V W + + + aso rexr rexx rexb + 0f 6b + P Q + + + + + packuswb + + aso rexr rexx rexb + sse66 0f 67 + V W + + + aso rexr rexx rexb + 0f 67 + P Q + + + + + paddb + + aso rexr rexx rexb + sse66 0f fc + V W + + + aso rexr rexx rexb + 0f fc + P Q + + + + + paddw + + aso rexr rexx rexb + 0f fd + P Q + + + aso rexr rexx rexb + sse66 0f fd + V W + + + + + paddd + + aso rexr rexx rexb + 0f fe + P Q + + + aso rexr rexx rexb + sse66 0f fe + V W + + + + + + paddsb + + aso rexr rexx rexb + 0f ec + P Q + + + aso rexr rexx rexb + sse66 0f ec + V W + + + + + paddsw + + aso rexr rexx rexb + 0f ed + P Q + + + aso rexr rexx rexb + sse66 0f ed + V W + + + + + paddusb + + aso rexr rexx rexb + 0f dc + P Q + + + aso rexr rexx rexb + sse66 0f dc + V W + + + + + paddusw + + aso rexr rexx rexb + 0f dd + P Q + + + aso rexr rexx rexb + sse66 0f dd + V W + + + + + pand + + aso rexr rexx rexb + sse66 0f db + V W + + + aso rexr rexx rexb + 0f db + P Q + + + + + pandn + + aso rexr rexx rexb + sse66 0f df + V W + + + aso rexr rexx rexb + 0f df + P Q + + + + + pavgb + + aso rexr rexx rexb + sse66 0f e0 + V W + + + aso rexr rexx rexb + 0f e0 + P Q + + + + + pavgw + + aso rexr rexx rexb + sse66 0f e3 + V W + + + aso rexr rexx rexb + 0f e3 + P Q + + + + + pcmpeqb + + aso rexr rexx rexb + 0f 74 + P Q + + + aso rexr rexx rexb + sse66 0f 74 + V W + + + + + pcmpeqw + + aso rexr rexx rexb + 0f 75 + P Q + + + aso rexr rexx rexb + sse66 0f 75 + V W + + + + + pcmpeqd + + aso rexr rexx rexb + 0f 76 + P Q + + + aso rexr rexx rexb + sse66 0f 76 + V W + + + + + pcmpgtb + + aso rexr rexx rexb + sse66 0f 64 + V W + + + aso rexr rexx rexb + 0f 64 + P Q + + + + + pcmpgtw + + aso rexr rexx rexb + sse66 0f 65 + V W + + + aso rexr rexx rexb + 0f 65 + P Q + + + + + pcmpgtd + + aso rexr rexx rexb + sse66 0f 66 + V W + + + aso rexr rexx rexb + 0f 66 + P Q + + + + + pextrb + + aso rexr rexb + sse66 0f 3a 14 + MbRv V Ib + def64 + + + + + pextrd + + aso rexr rexw rexb + sse66 0f 3a 16 /o=16 + Ev V Ib + + + aso rexr rexw rexb + sse66 0f 3a 16 /o=32 + Ev V Ib + + + + + pextrq + + aso rexr rexw rexb + sse66 0f 3a 16 /o=64 + Ev V Ib + def64 + + + + + pextrw + + aso rexr rexb + sse66 0f c5 + Gd VR Ib + + + aso oso rexw rexr rexx rexb + 0f c5 + Gd PR Ib + + + + + pinsrw + + aso oso rexw rexr rexx rexb + 0f c4 + P Ew Ib + + + aso rexw rexr rexx rexb + sse66 0f c4 + V Ew Ib + + + + + pmaddwd + + aso rexr rexx rexb + 0f f5 + P Q + + + aso rexr rexx rexb + sse66 0f f5 + V W + + + + + pmaxsw + + aso rexr rexx rexb + sse66 0f ee + V W + + + aso rexr rexx rexb + 0f ee + P Q + + + + + pmaxub + + aso rexr rexx rexb + 0f de + P Q + + + aso rexr rexx rexb + sse66 0f de + V W + + + + + pminsw + + aso rexr rexx rexb + sse66 0f ea + V W + + + aso rexr rexx rexb + 0f ea + P Q + + + + + pminub + + aso rexr rexx rexb + sse66 0f da + V W + + + aso rexr rexx rexb + 0f da + P Q + + + + + pmovmskb + + rexr rexb + sse66 0f d7 + Gd VR + + + oso rexr rexb + 0f d7 + Gd PR + + + + + pmulhuw + + aso rexr rexx rexb + 0f e4 + P Q + + + aso rexr rexx rexb + sse66 0f e4 + V W + + + + + pmulhw + + aso rexr rexx rexb + sse66 0f e5 + V W + + + aso rexr rexx rexb + 0f e5 + P Q + + + + + pmullw + + aso rexr rexx rexb + 0f d5 + P Q + + + aso rexr rexx rexb + sse66 0f d5 + V W + + + + + pop + + 07 + ES + inv64 + + + 17 + SS + inv64 + + + 1f + DS + inv64 + + + 0f a9 + GS + + + 0f a1 + FS + + + oso rexb + 58 + rAXr8 + def64 depM + + + oso rexb + 59 + rCXr9 + def64 depM + + + oso rexb + 5a + rDXr10 + def64 depM + + + oso rexb + 5b + rBXr11 + def64 depM + + + oso rexb + 5c + rSPr12 + def64 depM + + + oso rexb + 5d + rBPr13 + def64 depM + + + oso rexb + 5e + rSIr14 + def64 depM + + + oso rexb + 5f + rDIr15 + def64 depM + + + aso oso rexw rexr rexx rexb + 8f /reg=0 + Ev + def64 depM + + + + + popa + + oso + 61 /o=16 + inv64 + + + + + popad + + oso + 61 /o=32 + inv64 + + + + + popfw + + oso + 9d /m=32 /o=16 + def64 depM + + + oso + 9d /m=16 /o=16 + def64 depM + + + + + popfd + + oso + 9d /m=16 /o=32 + def64 depM + + + oso + 9d /m=32 /o=32 + def64 depM + + + + + popfq + + oso + 9d /m=64 /o=64 + def64 depM + + + + + por + + aso rexr rexx rexb + sse66 0f eb + V W + + + aso rexr rexx rexb + 0f eb + P Q + + + + + prefetch + + aso rexw rexr rexx rexb + 0f 0d /reg=0 + M + + + aso rexw rexr rexx rexb + 0f 0d /reg=1 + M + + + aso rexw rexr rexx rexb + 0f 0d /reg=2 + M + + + aso rexw rexr rexx rexb + 0f 0d /reg=3 + M + + + aso rexw rexr rexx rexb + 0f 0d /reg=4 + M + + + aso rexw rexr rexx rexb + 0f 0d /reg=5 + M + + + aso rexw rexr rexx rexb + 0f 0d /reg=6 + M + + + aso rexw rexr rexx rexb + 0f 0d /reg=7 + M + + + + + prefetchnta + + aso rexw rexr rexx rexb + 0f 18 /reg=0 + M + + + + + prefetcht0 + + aso rexw rexr rexx rexb + 0f 18 /reg=1 + M + + + + + prefetcht1 + + aso rexw rexr rexx rexb + 0f 18 /reg=2 + M + + + + + prefetcht2 + + aso rexw rexr rexx rexb + 0f 18 /reg=3 + M + + + + + psadbw + + aso rexr rexx rexb + sse66 0f f6 + V W + + + aso rexr rexx rexb + 0f f6 + P Q + + + + + pshufw + + aso rexr rexx rexb + 0f 70 + P Q Ib + + + + + psllw + + aso rexr rexx rexb + sse66 0f f1 + V W + + + aso rexr rexx rexb + 0f f1 + P Q + + + rexb + sse66 0f 71 /reg=6 + VR Ib + + + 0f 71 /reg=6 + PR Ib + + + + + pslld + + aso rexr rexx rexb + sse66 0f f2 + V W + + + aso rexr rexx rexb + 0f f2 + P Q + + + rexb + sse66 0f 72 /reg=6 + VR Ib + + + 0f 72 /reg=6 + PR Ib + + + + + psllq + + aso rexr rexx rexb + sse66 0f f3 + V W + + + aso rexr rexx rexb + 0f f3 + P Q + + + rexb + sse66 0f 73 /reg=6 + VR Ib + + + 0f 73 /reg=6 + PR Ib + + + + + psraw + + aso rexr rexx rexb + 0f e1 + P Q + + + aso rexr rexx rexb + sse66 0f e1 + V W + + + rexb + sse66 0f 71 /reg=4 + VR Ib + + + 0f 71 /reg=4 + PR Ib + + + + + psrad + + 0f 72 /reg=4 + PR Ib + + + aso rexr rexx rexb + sse66 0f e2 + V W + + + aso rexr rexx rexb + 0f e2 + P Q + + + rexb + sse66 0f 72 /reg=4 + VR Ib + + + + + psrlw + + 0f 71 /reg=2 + PR Ib + + + aso rexr rexx rexb + 0f d1 + P Q + + + aso rexr rexx rexb + sse66 0f d1 + V W + + + rexb + sse66 0f 71 /reg=2 + VR Ib + + + + + psrld + + 0f 72 /reg=2 + PR Ib + + + aso rexr rexx rexb + 0f d2 + P Q + + + aso rexr rexx rexb + sse66 0f d2 + V W + + + rexb + sse66 0f 72 /reg=2 + VR Ib + + + + + psrlq + + 0f 73 /reg=2 + PR Ib + + + aso rexr rexx rexb + 0f d3 + P Q + + + aso rexr rexx rexb + sse66 0f d3 + V W + + + rexb + sse66 0f 73 /reg=2 + VR Ib + + + + + psubb + + aso rexr rexx rexb + sse66 0f f8 + V W + + + aso rexr rexx rexb + 0f f8 + P Q + + + + + psubw + + aso rexr rexx rexb + sse66 0f f9 + V W + + + aso rexr rexx rexb + 0f f9 + P Q + + + + + psubd + + aso rexr rexx rexb + 0f fa + P Q + + + aso rexr rexx rexb + sse66 0f fa + V W + + + + + psubsb + + aso rexr rexx rexb + 0f e8 + P Q + + + aso rexr rexx rexb + sse66 0f e8 + V W + + + + + psubsw + + aso rexr rexx rexb + 0f e9 + P Q + + + aso rexr rexx rexb + sse66 0f e9 + V W + + + + + psubusb + + aso rexr rexx rexb + 0f d8 + P Q + + + aso rexr rexx rexb + sse66 0f d8 + V W + + + + + psubusw + + aso rexr rexx rexb + 0f d9 + P Q + + + aso rexr rexx rexb + sse66 0f d9 + V W + + + + + punpckhbw + + aso rexr rexx rexb + sse66 0f 68 + V W + + + aso rexr rexx rexb + 0f 68 + P Q + + + + + punpckhwd + + aso rexr rexx rexb + sse66 0f 69 + V W + + + aso rexr rexx rexb + 0f 69 + P Q + + + + + punpckhdq + + aso rexr rexx rexb + sse66 0f 6a + V W + + + aso rexr rexx rexb + 0f 6a + P Q + + + + + punpcklbw + + aso rexr rexx rexb + sse66 0f 60 + V W + + + aso rexr rexx rexb + 0f 60 + P Q + + + + + punpcklwd + + aso rexr rexx rexb + sse66 0f 61 + V W + + + aso rexr rexx rexb + 0f 61 + P Q + + + + + punpckldq + + aso rexr rexx rexb + sse66 0f 62 + V W + + + aso rexr rexx rexb + 0f 62 + P Q + + + + + pi2fw + + 0f 0f /3dnow=0c + P Q + + + + + pi2fd + + 0f 0f /3dnow=0d + P Q + + + + + pf2iw + + 0f 0f /3dnow=1c + P Q + + + + + pf2id + + 0f 0f /3dnow=1d + P Q + + + + + pfnacc + + 0f 0f /3dnow=8a + P Q + + + + + pfpnacc + + 0f 0f /3dnow=8e + P Q + + + + + pfcmpge + + 0f 0f /3dnow=90 + P Q + + + + + pfmin + + 0f 0f /3dnow=94 + P Q + + + + + pfrcp + + 0f 0f /3dnow=96 + P Q + + + + + pfrsqrt + + 0f 0f /3dnow=97 + P Q + + + + + pfsub + + 0f 0f /3dnow=9a + P Q + + + + + pfadd + + 0f 0f /3dnow=9e + P Q + + + + + pfcmpgt + + 0f 0f /3dnow=a0 + P Q + + + + + pfmax + + 0f 0f /3dnow=a4 + P Q + + + + + pfrcpit1 + + 0f 0f /3dnow=a6 + P Q + + + + + pfrsqit1 + + 0f 0f /3dnow=a7 + P Q + + + + + pfsubr + + 0f 0f /3dnow=aa + P Q + + + + + pfacc + + 0f 0f /3dnow=ae + P Q + + + + + pfcmpeq + + 0f 0f /3dnow=b0 + P Q + + + + + pfmul + + 0f 0f /3dnow=b4 + P Q + + + + + pfrcpit2 + + 0f 0f /3dnow=b6 + P Q + + + + + pmulhrw + + 0f 0f /3dnow=b7 + P Q + + + + + pswapd + + 0f 0f /3dnow=bb + P Q + + + + + pavgusb + + 0f 0f /3dnow=bf + P Q + + + + + push + + 06 + ES + inv64 + + + 0e + CS + inv64 + + + 16 + SS + inv64 + + + 1e + DS + inv64 + + + 0f a8 + GS + + + 0f a0 + FS + + + oso rexb + 50 + rAXr8 + def64 depM + + + oso rexb + 51 + rCXr9 + def64 depM + + + oso rexb + 52 + rDXr10 + def64 depM + + + oso rexb + 53 + rBXr11 + def64 depM + + + oso rexb + 54 + rSPr12 + def64 depM + + + oso rexb + 55 + rBPr13 + def64 depM + + + oso rexb + 56 + rSIr14 + def64 depM + + + oso rexb + 57 + rDIr15 + def64 depM + + + oso + 68 + Iz + cast + + + aso oso rexw rexr rexx rexb + ff /reg=6 + Ev + def64 + + + 6a + Ib + sext + + + + + pusha + + oso + 60 /o=16 + inv64 + + + + + pushad + + oso + 60 /o=32 + inv64 + + + + + pushfw + + oso + 9c /m=32 /o=16 + def64 + + + oso + 9c /m=16 /o=16 + def64 + + + oso rexw + 9c /m=64 /o=16 + def64 + + + + + pushfd + + oso + 9c /m=16 /o=32 + def64 + + + oso + 9c /m=32 /o=32 + def64 + + + + + pushfq + + oso rexw + 9c /m=64 /o=32 + def64 + + + oso rexw + 9c /m=64 /o=64 + def64 + + + + + pxor + + aso rexr rexx rexb + sse66 0f ef + V W + + + aso rexr rexx rexb + 0f ef + P Q + + + + + rcl + + aso rexw rexr rexx rexb + c0 /reg=2 + Eb Ib + + + aso oso rexw rexr rexx rexb + c1 /reg=2 + Ev Ib + + + aso rexw rexr rexx rexb + d0 /reg=2 + Eb I1 + + + aso rexw rexr rexx rexb + d2 /reg=2 + Eb CL + cast + + + aso oso rexw rexr rexx rexb + d3 /reg=2 + Ev CL + cast + + + aso oso rexw rexr rexx rexb + d1 /reg=2 + Ev I1 + + + + + rcr + + aso rexw rexr rexx rexb + d0 /reg=3 + Eb I1 + + + aso oso rexw rexr rexx rexb + c1 /reg=3 + Ev Ib + + + aso rexw rexr rexx rexb + c0 /reg=3 + Eb Ib + + + aso oso rexw rexr rexx rexb + d1 /reg=3 + Ev I1 + + + aso rexw rexr rexx rexb + d2 /reg=3 + Eb CL + cast + + + aso oso rexw rexr rexx rexb + d3 /reg=3 + Ev CL + cast + + + + + rol + + aso rexw rexr rexx rexb + c0 /reg=0 + Eb Ib + + + aso rexw rexr rexx rexb + d0 /reg=0 + Eb I1 + + + aso oso rexw rexr rexx rexb + d1 /reg=0 + Ev I1 + + + aso rexw rexr rexx rexb + d2 /reg=0 + Eb CL + cast + + + aso oso rexw rexr rexx rexb + d3 /reg=0 + Ev CL + cast + + + aso oso rexw rexr rexx rexb + c1 /reg=0 + Ev Ib + + + + + ror + + aso rexw rexr rexx rexb + d0 /reg=1 + Eb I1 + + + aso rexw rexr rexx rexb + c0 /reg=1 + Eb Ib + + + aso oso rexw rexr rexx rexb + c1 /reg=1 + Ev Ib + + + aso oso rexw rexr rexx rexb + d1 /reg=1 + Ev I1 + + + aso rexw rexr rexx rexb + d2 /reg=1 + Eb CL + cast + + + aso oso rexw rexr rexx rexb + d3 /reg=1 + Ev CL + cast + + + + + rcpps + + aso rexr rexx rexb + 0f 53 + V W + + + + + rcpss + + aso rexr rexx rexb + ssef3 0f 53 + V W + + + + + rdmsr + + 0f 32 + + + + + rdpmc + + 0f 33 + + + + + rdtsc + + 0f 31 + + + + + rdtscp + amd + + 0f 01 /reg=7 /mod=11 /rm=1 + + + + + repne + + f2 + + + + + rep + + f3 + + + + + ret + + c2 + Iw + + + c3 + + + + + retf + + ca + Iw + + + cb + + + + + rsm + + 0f aa + + + + + rsqrtps + + aso rexr rexx rexb + 0f 52 + V W + + + + + rsqrtss + + aso rexr rexx rexb + ssef3 0f 52 + V W + + + + + sahf + + 9e + + + + + sal + + + + salc + + d6 + inv64 + + + + + sar + + aso oso rexw rexr rexx rexb + d1 /reg=7 + Ev I1 + + + aso rexw rexr rexx rexb + c0 /reg=7 + Eb Ib + + + aso rexw rexr rexx rexb + d0 /reg=7 + Eb I1 + + + aso oso rexw rexr rexx rexb + c1 /reg=7 + Ev Ib + + + aso rexw rexr rexx rexb + d2 /reg=7 + Eb CL + cast + + + aso oso rexw rexr rexx rexb + d3 /reg=7 + Ev CL + cast + + + + + shl + + aso rexw rexr rexx rexb + c0 /reg=6 + Eb Ib + + + aso oso rexw rexr rexx rexb + c1 /reg=6 + Ev Ib + + + aso rexw rexr rexx rexb + d0 /reg=6 + Eb I1 + + + aso rexw rexr rexx rexb + d2 /reg=6 + Eb CL + cast + + + aso oso rexw rexr rexx rexb + d3 /reg=6 + Ev CL + cast + + + aso oso rexw rexr rexx rexb + c1 /reg=4 + Ev Ib + + + aso rexr rexx rexb + d2 /reg=4 + Eb CL + cast + + + aso oso rexw rexr rexx rexb + d1 /reg=4 + Ev I1 + + + aso rexw rexr rexx rexb + d0 /reg=4 + Eb I1 + + + aso rexw rexr rexx rexb + c0 /reg=4 + Eb Ib + + + aso oso rexw rexr rexx rexb + d3 /reg=4 + Ev CL + + + aso oso rexw rexr rexx rexb + d1 /reg=6 + Ev I1 + + + + + shr + + aso oso rexw rexr rexx rexb + c1 /reg=5 + Ev Ib + + + aso rexw rexr rexx rexb + d2 /reg=5 + Eb CL + cast + + + aso oso rexw rexr rexx rexb + d1 /reg=5 + Ev I1 + + + aso rexw rexr rexx rexb + d0 /reg=5 + Eb I1 + + + aso rexw rexr rexx rexb + c0 /reg=5 + Eb Ib + + + aso oso rexw rexr rexx rexb + d3 /reg=5 + Ev CL + cast + + + + + sbb + + aso rexr rexx rexb + 18 + Eb Gb + + + aso oso rexw rexr rexx rexb + 19 + Ev Gv + + + aso rexr rexx rexb + 1a + Gb Eb + + + aso oso rexw rexr rexx rexb + 1b + Gv Ev + + + 1c + AL Ib + + + oso rexw + 1d + rAX Iz + sext + + + aso rexr rexx rexb + 80 /reg=3 + Eb Ib + + + aso oso rexw rexr rexx rexb + 81 /reg=3 + Ev Iz + sext + + + aso rexr rexx rexb + 82 /reg=3 + Eb Ib + inv64 + + + aso oso rexw rexr rexx rexb + 83 /reg=3 + Ev Ib + sext + + + + + scasb + + ae + + + + + scasw + + oso rexw + af /o=16 + + + + + scasd + + oso rexw + af /o=32 + + + + + scasq + + oso rexw + af /o=64 + + + + + seto + + aso rexr rexx rexb + 0f 90 + Eb + + + + + setno + + aso rexr rexx rexb + 0f 91 + Eb + + + + + setb + + aso rexr rexx rexb + 0f 92 + Eb + + + + + setnb + + aso rexr rexx rexb + 0f 93 + Eb + + + + + setz + + aso rexr rexx rexb + 0f 94 + Eb + + + + + setnz + + aso rexr rexx rexb + 0f 95 + Eb + + + + + setbe + + aso rexr rexx rexb + 0f 96 + Eb + + + + + seta + + aso rexr rexx rexb + 0f 97 + Eb + + + + + sets + + aso rexr rexx rexb + 0f 98 + Eb + + + + + setns + + aso rexr rexx rexb + 0f 99 + Eb + + + + + setp + + aso rexr rexx rexb + 0f 9a + Eb + + + + + setnp + + aso rexr rexx rexb + 0f 9b + Eb + + + + + setl + + aso rexr rexx rexb + 0f 9c + Eb + + + + + setge + + aso rexr rexx rexb + 0f 9d + Eb + + + + + setle + + aso rexr rexx rexb + 0f 9e + Eb + + + + + setg + + aso rexr rexx rexb + 0f 9f + Eb + + + + + sfence + + 0f ae /reg=7 /mod=11 /rm=0 + + + 0f ae /reg=7 /mod=11 /rm=1 + + + 0f ae /reg=7 /mod=11 /rm=2 + + + 0f ae /reg=7 /mod=11 /rm=3 + + + 0f ae /reg=7 /mod=11 /rm=4 + + + 0f ae /reg=7 /mod=11 /rm=5 + + + 0f ae /reg=7 /mod=11 /rm=6 + + + 0f ae /reg=7 /mod=11 /rm=7 + + + + + sgdt + + aso rexr rexx rexb + 0f 01 /reg=0 /mod=!11 + M + + + + + shld + + aso oso rexw rexr rexx rexb + 0f a4 + Ev Gv Ib + + + aso oso rexw rexr rexx rexb + 0f a5 + Ev Gv CL + + + + + shrd + + aso oso rexw rexr rexx rexb + 0f ac + Ev Gv Ib + + + aso oso rexw rexr rexx rexb + 0f ad + Ev Gv CL + + + + + shufpd + + aso rexr rexx rexb + sse66 0f c6 + V W Ib + + + + + shufps + + aso rexr rexx rexb + 0f c6 + V W Ib + + + + + sidt + + aso rexr rexx rexb + 0f 01 /reg=1 /mod=!11 + M + + + + + sldt + + aso oso rexr rexx rexb + 0f 00 /reg=0 + MwRv + + + + + smsw + + aso rexr rexx rexb + 0f 01 /reg=4 /mod=!11 + M + + + + + sqrtps + + aso rexr rexx rexb + 0f 51 + V W + + + + + sqrtpd + + aso rexr rexx rexb + sse66 0f 51 + V W + + + + + sqrtsd + + aso rexr rexx rexb + ssef2 0f 51 + V W + + + + + sqrtss + + aso rexr rexx rexb + ssef3 0f 51 + V W + + + + + stc + + f9 + + + + + std + + fd + + + + + stgi + amd + + 0f 01 /reg=3 /mod=11 /rm=4 + + + + + sti + + fb + + + + + skinit + amd + + 0f 01 /reg=3 /mod=11 /rm=6 + + + + + stmxcsr + + aso rexw rexr rexx rexb + 0f ae /mod=11 /reg=3 + Md + + + + + stosb + + seg + aa + + + + + stosw + + seg oso rexw + ab /o=16 + + + + + stosd + + seg oso rexw + ab /o=32 + + + + + stosq + + seg oso rexw + ab /o=64 + + + + + str + + aso oso rexr rexx rexb + 0f 00 /reg=1 + Ev + + + + + sub + + aso rexr rexx rexb + 28 + Eb Gb + + + aso oso rexw rexr rexx rexb + 29 + Ev Gv + + + aso rexr rexx rexb + 2a + Gb Eb + + + aso oso rexw rexr rexx rexb + 2b + Gv Ev + + + 2c + AL Ib + + + oso rexw + 2d + rAX Iz + sext + + + aso rexr rexx rexb + 80 /reg=5 + Eb Ib + + + aso oso rexw rexr rexx rexb + 81 /reg=5 + Ev Iz + sext + + + aso rexr rexx rexb + 82 /reg=5 + Eb Ib + inv64 + + + aso oso rexw rexr rexx rexb + 83 /reg=5 + Ev Ib + sext + + + + + subpd + + aso rexr rexx rexb + sse66 0f 5c + V W + + + + + subps + + aso rexr rexx rexb + 0f 5c + V W + + + + + subsd + + aso rexr rexx rexb + ssef2 0f 5c + V W + + + + + subss + + aso rexr rexx rexb + ssef3 0f 5c + V W + + + + + swapgs + + 0f 01 /reg=7 /mod=11 /rm=0 + + + + + syscall + + 0f 05 + + + + + sysenter + + 0f 34 + inv64 + + + + + sysexit + + 0f 35 + + + + + sysret + + 0f 07 + + + + + test + + aso rexw rexr rexx rexb + f6 /reg=0 + Eb Ib + + + aso rexr rexx rexb + 84 + Eb Gb + + + aso oso rexw rexr rexx rexb + 85 + Ev Gv + + + a8 + AL Ib + + + oso rexw + a9 + rAX Iz + sext + + + aso rexw rexr rexx rexb + f6 /reg=1 + Eb Ib + + + aso oso rexw rexr rexx rexb + f7 /reg=0 + Ev Iz + sext + + + aso oso rexw rexr rexx rexb + f7 /reg=1 + Ev Iz + sext + + + + + ucomisd + + aso rexr rexx rexb + sse66 0f 2e + V W + + + + + ucomiss + + aso rexr rexx rexb + 0f 2e + V W + + + + + ud2 + + 0f 0b + + + + + unpckhpd + + aso rexr rexx rexb + sse66 0f 15 + V W + + + + + unpckhps + + aso rexr rexx rexb + 0f 15 + V W + + + + + unpcklps + + aso rexr rexx rexb + 0f 14 + V W + + + + + unpcklpd + + aso rexr rexx rexb + sse66 0f 14 + V W + + + + + verr + + aso rexr rexx rexb + 0f 00 /reg=4 + Ew + + + + + verw + + aso rexr rexx rexb + 0f 00 /reg=5 + Ew + + + + + vmcall + intel + + 0f 01 /reg=0 /mod=11 /rm=1 + + + + + vmclear + intel + + aso rexr rexx rexb + sse66 0f c7 /reg=6 + Mq + + + + + vmxon + intel + + aso rexr rexx rexb + ssef3 0f c7 /reg=6 + Mq + + + + + vmptrld + intel + + aso rexr rexx rexb + 0f c7 /reg=6 + Mq + + + + + vmptrst + intel + + aso rexr rexx rexb + 0f c7 /reg=7 + Mq + + + + + vmlaunch + intel + + 0f 01 /reg=0 /mod=11 /rm=2 + + + + + vmresume + intel + + 0f 01 /reg=0 /mod=11 /rm=3 + + + + + vmxoff + intel + + 0f 01 /reg=0 /mod=11 /rm=4 + + + + + vmread + intel + + aso rexr rexx rexb + 0f 78 /m=16 + Ed Gd + def64 + + + aso rexr rexx rexb + 0f 78 /m=32 + Ed Gd + def64 + + + aso rexr rexx rexb + 0f 78 /m=64 + Eq Gq + def64 + + + + + vmwrite + intel + + aso rexr rexx rexb + 0f 79 /m=16 + Gd Ed + def64 + + + aso rexr rexx rexb + 0f 79 /m=32 + Gd Ed + def64 + + + aso rexr rexx rexb + 0f 79 /m=64 + Gq Eq + def64 + + + + + vmrun + amd + + 0f 01 /reg=3 /mod=11 /rm=0 + + + + + vmmcall + amd + + 0f 01 /reg=3 /mod=11 /rm=1 + + + + + vmload + amd + + 0f 01 /reg=3 /mod=11 /rm=2 + + + + + vmsave + amd + + 0f 01 /reg=3 /mod=11 /rm=3 + + + + + wait + + 9b + + + + + wbinvd + + 0f 09 + + + + + wrmsr + + 0f 30 + + + + + xadd + + aso oso rexr rexx rexb + 0f c0 + Eb Gb + + + aso oso rexw rexr rexx rexb + 0f c1 + Ev Gv + + + + + xchg + + aso rexr rexx rexb + 86 + Eb Gb + + + aso oso rexw rexr rexx rexb + 87 + Ev Gv + + + oso rexw rexb + 90 + rAXr8 rAX + + + oso rexw rexb + 91 + rCXr9 rAX + + + oso rexw rexb + 92 + rDXr10 rAX + + + oso rexw rexb + 93 + rBXr11 rAX + + + oso rexw rexb + 94 + rSPr12 rAX + + + oso rexw rexb + 95 + rBPr13 rAX + + + oso rexw rexb + 96 + rSIr14 rAX + + + oso rexw rexb + 97 + rDIr15 rAX + + + + + xlatb + + rexw + d7 + + + + + xor + + aso rexr rexx rexb + 30 + Eb Gb + + + aso oso rexw rexr rexx rexb + 31 + Ev Gv + + + aso rexr rexx rexb + 32 + Gb Eb + + + aso oso rexw rexr rexx rexb + 33 + Gv Ev + + + 34 + AL Ib + + + oso rexw + 35 + rAX Iz + sext + + + aso rexr rexx rexb + 80 /reg=6 + Eb Ib + + + aso oso rexw rexr rexx rexb + 81 /reg=6 + Ev Iz + sext + + + aso rexr rexx rexb + 82 /reg=6 + Eb Ib + inv64 + + + aso oso rexw rexr rexx rexb + 83 /reg=6 + Ev Ib + sext + + + + + xorpd + + aso rexr rexx rexb + sse66 0f 57 + V W + + + + + xorps + + aso rexr rexx rexb + 0f 57 + V W + + + + + xcryptecb + + 0f a7 /mod=11 /rm=0 /reg=1 + + + + + xcryptcbc + + 0f a7 /mod=11 /rm=0 /reg=2 + + + + + xcryptctr + + 0f a7 /mod=11 /rm=0 /reg=3 + + + + + xcryptcfb + + 0f a7 /mod=11 /rm=0 /reg=4 + + + + + xcryptofb + + 0f a7 /mod=11 /rm=0 /reg=5 + + + + + xsha1 + + 0f a6 /mod=11 /rm=0 /reg=1 + + + + + xsha256 + + 0f a6 /mod=11 /rm=0 /reg=2 + + + + + xstore + + 0f a7 /mod=11 /rm=0 /reg=0 + + + + + db + + + + + + movdqa + + aso rexr rexx rexb + sse66 0f 7f + W V + + + aso rexr rexx rexb + sse66 0f 6f + V W + + + + + movdq2q + + aso rexb + ssef2 0f d6 + P VR + + + + + movdqu + + aso rexr rexx rexb + ssef3 0f 6f + V W + + + aso rexr rexx rexb + ssef3 0f 7f + W V + + + + + movq2dq + + aso + ssef3 0f d6 + V PR + + + + + paddq + + aso rexr rexx rexb + 0f d4 + P Q + + + aso rexr rexx rexb + sse66 0f d4 + V W + + + + + psubq + + aso rexr rexx rexb + sse66 0f fb + V W + + + aso rexr rexx rexb + 0f fb + P Q + + + + + pmuludq + + aso rexr rexx rexb + 0f f4 + P Q + + + aso rexr rexx rexb + sse66 0f f4 + V W + + + + + pshufhw + + aso rexr rexx rexb + ssef3 0f 70 + V W Ib + + + + + pshuflw + + aso rexr rexx rexb + ssef2 0f 70 + V W Ib + + + + + pshufd + + aso rexr rexx rexb + sse66 0f 70 + V W Ib + + + + + pslldq + + rexb + sse66 0f 73 /reg=7 + VR Ib + + + + + psrldq + + rexb + sse66 0f 73 /reg=3 + VR Ib + + + + + punpckhqdq + + aso rexr rexx rexb + sse66 0f 6d + V W + + + + + punpcklqdq + + aso rexr rexx rexb + sse66 0f 6c + V W + + + + + + + addsubpd + + aso rexr rexx rexb + sse66 0f d0 + V W + + + + + addsubps + + aso rexr rexx rexb + ssef2 0f d0 + V W + + + + + haddpd + + aso rexr rexx rexb + sse66 0f 7c + V W + + + + + haddps + + aso rexr rexx rexb + ssef2 0f 7c + V W + + + + + hsubpd + + aso rexr rexx rexb + sse66 0f 7d + V W + + + + + hsubps + + aso rexr rexx rexb + ssef2 0f 7d + V W + + + + + movddup + + aso rexr rexx rexb + ssef2 0f 12 /mod=11 + V W + + + aso rexr rexx rexb + ssef2 0f 12 /mod=!11 + V W + + + + + movshdup + + aso rexr rexx rexb + ssef3 0f 16 /mod=11 + V W + + + aso rexr rexx rexb + ssef3 0f 16 /mod=!11 + V W + + + + + movsldup + + aso rexr rexx rexb + ssef3 0f 12 /mod=11 + V W + + + aso rexr rexx rexb + ssef3 0f 12 /mod=!11 + V W + + + + + + + pabsb + + aso rexr rexx rexb + 0f 38 1c + P Q + + + aso rexr rexx rexb + sse66 0f 38 1c + V W + + + + + pabsw + + aso rexr rexx rexb + 0f 38 1d + P Q + + + aso rexr rexx rexb + sse66 0f 38 1d + V W + + + + + pabsd + + aso rexr rexx rexb + 0f 38 1e + P Q + + + aso rexr rexx rexb + sse66 0f 38 1e + V W + + + + + psignb + + aso rexr rexx rexb + 0f 38 00 + P Q + + + aso rexr rexx rexb + sse66 0f 38 00 + V W + + + + + phaddw + + aso rexr rexx rexb + 0f 38 01 + P Q + + + aso rexr rexx rexb + sse66 0f 38 01 + V W + + + + + phaddd + + aso rexr rexx rexb + 0f 38 02 + P Q + + + aso rexr rexx rexb + sse66 0f 38 02 + V W + + + + + phaddsw + + aso rexr rexx rexb + 0f 38 03 + P Q + + + aso rexr rexx rexb + sse66 0f 38 03 + V W + + + + + pmaddubsw + + aso rexr rexx rexb + 0f 38 04 + P Q + + + aso rexr rexx rexb + sse66 0f 38 04 + V W + + + + + phsubw + + aso rexr rexx rexb + 0f 38 05 + P Q + + + aso rexr rexx rexb + sse66 0f 38 05 + V W + + + + + phsubd + + aso rexr rexx rexb + 0f 38 06 + P Q + + + aso rexr rexx rexb + sse66 0f 38 06 + V W + + + + + phsubsw + + aso rexr rexx rexb + 0f 38 07 + P Q + + + aso rexr rexx rexb + sse66 0f 38 07 + V W + + + + + psignb + + aso rexr rexx rexb + 0f 38 08 + P Q + + + aso rexr rexx rexb + sse66 0f 38 08 + V W + + + + + psignd + + aso rexr rexx rexb + 0f 38 0a + P Q + + + aso rexr rexx rexb + sse66 0f 38 0a + V W + + + + + psignw + + aso rexr rexx rexb + 0f 38 09 + P Q + + + aso rexr rexx rexb + sse66 0f 38 09 + V W + + + + + pmulhrsw + + aso rexr rexx rexb + 0f 38 0b + P Q + + + aso rexr rexx rexb + sse66 0f 38 0b + V W + + + + + palignr + + aso rexr rexx rexb + 0f 3a 0f + P Q Ib + + + aso rexr rexx rexb + sse66 0f 3a 0f + V W Ib + + + + + + + pblendvb + + aso rexr rexx rexb + sse66 0f 38 10 + V W + + + + + pmuldq + + aso rexr rexx rexb + sse66 0f 38 28 + V W + + + + + pminsb + + aso rexr rexx rexb + sse66 0f 38 38 + V W + + + + + pminsd + + aso rexr rexx rexb + sse66 0f 38 39 + V W + + + + + pminuw + + aso rexr rexx rexb + sse66 0f 38 3a + V W + + + + + pminud + + aso rexr rexx rexb + sse66 0f 38 3b + V W + + + + + pmaxsb + + aso rexr rexx rexb + sse66 0f 38 3c + V W + + + + + pmaxsd + + aso rexr rexx rexb + sse66 0f 38 3d + V W + + + + + pmaxud + + aso rexr rexx rexb + sse66 0f 38 3f + V W + + + + + pmulld + + aso rexr rexx rexb + sse66 0f 38 40 + V W + + + + + phminposuw + + aso rexr rexx rexb + sse66 0f 38 41 + V W + + + + + roundps + + aso rexr rexx rexb + sse66 0f 3a 08 + V W Ib + + + + + roundpd + + aso rexr rexx rexb + sse66 0f 3a 09 + V W Ib + + + + + roundss + + aso rexr rexx rexb + sse66 0f 3a 0a + V W Ib + + + + + roundsd + + aso rexr rexx rexb + sse66 0f 3a 0b + V W Ib + + + + + blendpd + + aso rexr rexx rexb + sse66 0f 3a 0d + V W Ib + + + + + pblendw + + aso rexr rexx rexb + sse66 0f 3a 0e + V W Ib + + + + + blendps + + aso rexr rexx rexb + sse66 0f 3a 0c + V W Ib + + + + + blendvpd + + aso rexr rexx rexb + sse66 0f 38 15 + V W + + + + + blendvps + + aso rexr rexx rexb + sse66 0f 38 14 + V W + + + + + dpps + + aso rexr rexx rexb + sse66 0f 3a 40 + V W Ib + + + + + dppd + + aso rexr rexx rexb + sse66 0f 3a 41 + V W Ib + + + + + mpsadbw + + aso rexr rexx rexb + sse66 0f 3a 42 + V W Ib + + + + + extractps + + aso rexr rexw rexb + sse66 0f 3a 17 + MdRy V Ib + + + + + invalid + + + diff --git a/src/3rdparty/masm/disassembler/udis86/ud_opcode.py b/src/3rdparty/masm/disassembler/udis86/ud_opcode.py new file mode 100644 index 0000000000..f301b52461 --- /dev/null +++ b/src/3rdparty/masm/disassembler/udis86/ud_opcode.py @@ -0,0 +1,235 @@ +# udis86 - scripts/ud_opcode.py +# +# Copyright (c) 2009 Vivek Thampi +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without modification, +# are permitted provided that the following conditions are met: +# +# * Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR +# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +class UdOpcodeTables: + + TableInfo = { + 'opctbl' : { 'name' : 'UD_TAB__OPC_TABLE', 'size' : 256 }, + '/sse' : { 'name' : 'UD_TAB__OPC_SSE', 'size' : 4 }, + '/reg' : { 'name' : 'UD_TAB__OPC_REG', 'size' : 8 }, + '/rm' : { 'name' : 'UD_TAB__OPC_RM', 'size' : 8 }, + '/mod' : { 'name' : 'UD_TAB__OPC_MOD', 'size' : 2 }, + '/m' : { 'name' : 'UD_TAB__OPC_MODE', 'size' : 3 }, + '/x87' : { 'name' : 'UD_TAB__OPC_X87', 'size' : 64 }, + '/a' : { 'name' : 'UD_TAB__OPC_ASIZE', 'size' : 3 }, + '/o' : { 'name' : 'UD_TAB__OPC_OSIZE', 'size' : 3 }, + '/3dnow' : { 'name' : 'UD_TAB__OPC_3DNOW', 'size' : 256 }, + 'vendor' : { 'name' : 'UD_TAB__OPC_VENDOR', 'size' : 3 }, + } + + OpcodeTable0 = { + 'type' : 'opctbl', + 'entries' : {}, + 'meta' : 'table0' + } + + OpcExtIndex = { + + # ssef2, ssef3, sse66 + 'sse': { + 'none' : '00', + 'f2' : '01', + 'f3' : '02', + '66' : '03' + }, + + # /mod= + 'mod': { + '!11' : '00', + '11' : '01' + }, + + # /m=, /o=, /a= + 'mode': { + '16' : '00', + '32' : '01', + '64' : '02' + }, + + 'vendor' : { + 'amd' : '00', + 'intel' : '01', + 'any' : '02' + } + } + + InsnTable = [] + MnemonicsTable = [] + + ThreeDNowTable = {} + + def sizeOfTable( self, t ): + return self.TableInfo[ t ][ 'size' ] + + def nameOfTable( self, t ): + return self.TableInfo[ t ][ 'name' ] + + # + # Updates a table entry: If the entry doesn't exist + # it will create the entry, otherwise, it will walk + # while validating the path. + # + def updateTable( self, table, index, type, meta ): + if not index in table[ 'entries' ]: + table[ 'entries' ][ index ] = { 'type' : type, 'entries' : {}, 'meta' : meta } + if table[ 'entries' ][ index ][ 'type' ] != type: + raise NameError( "error: violation in opcode mapping (overwrite) %s with %s." % + ( table[ 'entries' ][ index ][ 'type' ], type) ) + return table[ 'entries' ][ index ] + + class Insn: + """An abstract type representing an instruction in the opcode map. + """ + + # A mapping of opcode extensions to their representational + # values used in the opcode map. + OpcExtMap = { + '/rm' : lambda v: "%02x" % int(v, 16), + '/x87' : lambda v: "%02x" % int(v, 16), + '/3dnow' : lambda v: "%02x" % int(v, 16), + '/reg' : lambda v: "%02x" % int(v, 16), + # modrm.mod + # (!11, 11) => (00, 01) + '/mod' : lambda v: '00' if v == '!11' else '01', + # Mode extensions: + # (16, 32, 64) => (00, 01, 02) + '/o' : lambda v: "%02x" % (int(v) / 32), + '/a' : lambda v: "%02x" % (int(v) / 32), + '/m' : lambda v: "%02x" % (int(v) / 32), + '/sse' : lambda v: UdOpcodeTables.OpcExtIndex['sse'][v] + } + + def __init__(self, prefixes, mnemonic, opcodes, operands, vendor): + self.opcodes = opcodes + self.prefixes = prefixes + self.mnemonic = mnemonic + self.operands = operands + self.vendor = vendor + self.opcext = {} + + ssePrefix = None + if self.opcodes[0] in ('ssef2', 'ssef3', 'sse66'): + ssePrefix = self.opcodes[0][3:] + self.opcodes.pop(0) + + # do some preliminary decoding of the instruction type + # 1byte, 2byte or 3byte instruction? + self.nByteInsn = 1 + if self.opcodes[0] == '0f': # 2byte + # 2+ byte opcodes are always disambiguated by an + # sse prefix, unless it is a 3d now instruction + # which is 0f 0f ... + if self.opcodes[1] != '0f' and ssePrefix is None: + ssePrefix = 'none' + if self.opcodes[1] in ('38', '3a'): # 3byte + self.nByteInsn = 3 + else: + self.nByteInsn = 2 + + # The opcode that indexes into the opcode table. + self.opcode = self.opcodes[self.nByteInsn - 1] + + # Record opcode extensions + for opcode in self.opcodes[self.nByteInsn:]: + arg, val = opcode.split('=') + self.opcext[arg] = self.OpcExtMap[arg](val) + + # Record sse extension: the reason sse extension is handled + # separately is that historically sse was handled as a first + # class opcode, not as an extension. Now that sse is handled + # as an extension, we do the manual conversion here, as opposed + # to modifying the opcode xml file. + if ssePrefix is not None: + self.opcext['/sse'] = self.OpcExtMap['/sse'](ssePrefix) + + def parse(self, table, insn): + index = insn.opcodes[0]; + if insn.nByteInsn > 1: + assert index == '0f' + table = self.updateTable(table, index, 'opctbl', '0f') + index = insn.opcodes[1] + + if insn.nByteInsn == 3: + table = self.updateTable(table, index, 'opctbl', index) + index = insn.opcodes[2] + + # Walk down the tree, create levels as needed, for opcode + # extensions. The order is important, and determines how + # well the opcode table is packed. Also note, /sse must be + # before /o, because /sse may consume operand size prefix + # affect the outcome of /o. + for ext in ('/mod', '/x87', '/reg', '/rm', '/sse', + '/o', '/a', '/m', '/3dnow'): + if ext in insn.opcext: + table = self.updateTable(table, index, ext, ext) + index = insn.opcext[ext] + + # additional table for disambiguating vendor + if len(insn.vendor): + table = self.updateTable(table, index, 'vendor', insn.vendor) + index = self.OpcExtIndex['vendor'][insn.vendor] + + # make leaf node entries + leaf = self.updateTable(table, index, 'insn', '') + + leaf['mnemonic'] = insn.mnemonic + leaf['prefixes'] = insn.prefixes + leaf['operands'] = insn.operands + + # add instruction to linear table of instruction forms + self.InsnTable.append({ 'prefixes' : insn.prefixes, + 'mnemonic' : insn.mnemonic, + 'operands' : insn.operands }) + + # add mnemonic to mnemonic table + if not insn.mnemonic in self.MnemonicsTable: + self.MnemonicsTable.append(insn.mnemonic) + + + # Adds an instruction definition to the opcode tables + def addInsnDef( self, prefixes, mnemonic, opcodes, operands, vendor ): + insn = self.Insn(prefixes=prefixes, + mnemonic=mnemonic, + opcodes=opcodes, + operands=operands, + vendor=vendor) + self.parse(self.OpcodeTable0, insn) + + def print_table( self, table, pfxs ): + print "%s |" % pfxs + keys = table[ 'entries' ].keys() + if ( len( keys ) ): + keys.sort() + for idx in keys: + e = table[ 'entries' ][ idx ] + if e[ 'type' ] == 'insn': + print "%s |-<%s>" % ( pfxs, idx ), + print "%s %s" % ( e[ 'mnemonic' ], ' '.join( e[ 'operands'] ) ) + else: + print "%s |-<%s> %s" % ( pfxs, idx, e['type'] ) + self.print_table( e, pfxs + ' |' ) + + def print_tree( self ): + self.print_table( self.OpcodeTable0, '' ) diff --git a/src/3rdparty/masm/disassembler/udis86/ud_optable.py b/src/3rdparty/masm/disassembler/udis86/ud_optable.py new file mode 100644 index 0000000000..5b5c55d3b8 --- /dev/null +++ b/src/3rdparty/masm/disassembler/udis86/ud_optable.py @@ -0,0 +1,103 @@ +# udis86 - scripts/ud_optable.py (optable.xml parser) +# +# Copyright (c) 2009 Vivek Thampi +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without modification, +# are permitted provided that the following conditions are met: +# +# * Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# * Redistributions in binary form must reproduce the above copyright notice, +# this list of conditions and the following disclaimer in the documentation +# and/or other materials provided with the distribution. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR +# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +# ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +import os +import sys +from xml.dom import minidom + +class UdOptableXmlParser: + + def parseDef( self, node ): + ven = '' + pfx = [] + opc = [] + opr = [] + for def_node in node.childNodes: + if not def_node.localName: + continue + if def_node.localName == 'pfx': + pfx = def_node.firstChild.data.split(); + elif def_node.localName == 'opc': + opc = def_node.firstChild.data.split(); + elif def_node.localName == 'opr': + opr = def_node.firstChild.data.split(); + elif def_node.localName == 'mode': + pfx.extend( def_node.firstChild.data.split() ); + elif def_node.localName == 'syn': + pfx.extend( def_node.firstChild.data.split() ); + elif def_node.localName == 'vendor': + ven = ( def_node.firstChild.data ); + else: + print "warning: invalid node - %s" % def_node.localName + continue + return ( pfx, opc, opr, ven ) + + def parse( self, xml, fn ): + xmlDoc = minidom.parse( xml ) + self.TlNode = xmlDoc.firstChild + + while self.TlNode and self.TlNode.localName != "x86optable": + self.TlNode = self.TlNode.nextSibling + + for insnNode in self.TlNode.childNodes: + if not insnNode.localName: + continue + if insnNode.localName != "instruction": + print "warning: invalid insn node - %s" % insnNode.localName + continue + + mnemonic = insnNode.getElementsByTagName( 'mnemonic' )[ 0 ].firstChild.data + vendor = '' + + for node in insnNode.childNodes: + if node.localName == 'vendor': + vendor = node.firstChild.data + elif node.localName == 'def': + ( prefixes, opcodes, operands, local_vendor ) = \ + self.parseDef( node ) + if ( len( local_vendor ) ): + vendor = local_vendor + # callback + fn( prefixes, mnemonic, opcodes, operands, vendor ) + + +def printFn( pfx, mnm, opc, opr, ven ): + print 'def: ', + if len( pfx ): + print ' '.join( pfx ), + print "%s %s %s %s" % \ + ( mnm, ' '.join( opc ), ' '.join( opr ), ven ) + + +def parse( xml, callback ): + parser = UdOptableXmlParser() + parser.parse( xml, callback ) + +def main(): + parser = UdOptableXmlParser() + parser.parse( sys.argv[ 1 ], printFn ) + +if __name__ == "__main__": + main() diff --git a/src/3rdparty/masm/disassembler/udis86/udis86.c b/src/3rdparty/masm/disassembler/udis86/udis86.c new file mode 100644 index 0000000000..fbf76707a0 --- /dev/null +++ b/src/3rdparty/masm/disassembler/udis86/udis86.c @@ -0,0 +1,183 @@ +/* udis86 - libudis86/udis86.c + * + * Copyright (c) 2002-2009 Vivek Thampi + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include + +#if USE(UDIS86) + +#include "udis86_input.h" +#include "udis86_extern.h" + +#ifndef __UD_STANDALONE__ +# include +# include +#endif /* __UD_STANDALONE__ */ + +/* ============================================================================= + * ud_init() - Initializes ud_t object. + * ============================================================================= + */ +extern void +ud_init(struct ud* u) +{ + memset((void*)u, 0, sizeof(struct ud)); + ud_set_mode(u, 16); + u->mnemonic = UD_Iinvalid; + ud_set_pc(u, 0); +#ifndef __UD_STANDALONE__ + ud_set_input_file(u, stdin); +#endif /* __UD_STANDALONE__ */ +} + +/* ============================================================================= + * ud_disassemble() - disassembles one instruction and returns the number of + * bytes disassembled. A zero means end of disassembly. + * ============================================================================= + */ +extern unsigned int +ud_disassemble(struct ud* u) +{ + if (ud_input_end(u)) + return 0; + + + u->insn_buffer[0] = u->insn_hexcode[0] = 0; + + + if (ud_decode(u) == 0) + return 0; + if (u->translator) + u->translator(u); + return ud_insn_len(u); +} + +/* ============================================================================= + * ud_set_mode() - Set Disassemly Mode. + * ============================================================================= + */ +extern void +ud_set_mode(struct ud* u, uint8_t m) +{ + switch(m) { + case 16: + case 32: + case 64: u->dis_mode = m ; return; + default: u->dis_mode = 16; return; + } +} + +/* ============================================================================= + * ud_set_vendor() - Set vendor. + * ============================================================================= + */ +extern void +ud_set_vendor(struct ud* u, unsigned v) +{ + switch(v) { + case UD_VENDOR_INTEL: + u->vendor = v; + break; + case UD_VENDOR_ANY: + u->vendor = v; + break; + default: + u->vendor = UD_VENDOR_AMD; + } +} + +/* ============================================================================= + * ud_set_pc() - Sets code origin. + * ============================================================================= + */ +extern void +ud_set_pc(struct ud* u, uint64_t o) +{ + u->pc = o; +} + +/* ============================================================================= + * ud_set_syntax() - Sets the output syntax. + * ============================================================================= + */ +extern void +ud_set_syntax(struct ud* u, void (*t)(struct ud*)) +{ + u->translator = t; +} + +/* ============================================================================= + * ud_insn() - returns the disassembled instruction + * ============================================================================= + */ +extern char* +ud_insn_asm(struct ud* u) +{ + return u->insn_buffer; +} + +/* ============================================================================= + * ud_insn_offset() - Returns the offset. + * ============================================================================= + */ +extern uint64_t +ud_insn_off(struct ud* u) +{ + return u->insn_offset; +} + + +/* ============================================================================= + * ud_insn_hex() - Returns hex form of disassembled instruction. + * ============================================================================= + */ +extern char* +ud_insn_hex(struct ud* u) +{ + return u->insn_hexcode; +} + +/* ============================================================================= + * ud_insn_ptr() - Returns code disassembled. + * ============================================================================= + */ +extern uint8_t* +ud_insn_ptr(struct ud* u) +{ + return u->inp_sess; +} + +/* ============================================================================= + * ud_insn_len() - Returns the count of bytes disassembled. + * ============================================================================= + */ +extern unsigned int +ud_insn_len(struct ud* u) +{ + return u->inp_ctr; +} + +#endif // USE(UDIS86) diff --git a/src/3rdparty/masm/disassembler/udis86/udis86.h b/src/3rdparty/masm/disassembler/udis86/udis86.h new file mode 100644 index 0000000000..baaf495e04 --- /dev/null +++ b/src/3rdparty/masm/disassembler/udis86/udis86.h @@ -0,0 +1,33 @@ +/* udis86 - udis86.h + * + * Copyright (c) 2002-2009 Vivek Thampi + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +#ifndef UDIS86_H +#define UDIS86_H + +#include "udis86_types.h" +#include "udis86_extern.h" +#include "udis86_itab.h" + +#endif diff --git a/src/3rdparty/masm/disassembler/udis86/udis86_decode.c b/src/3rdparty/masm/disassembler/udis86/udis86_decode.c new file mode 100644 index 0000000000..a3fd576655 --- /dev/null +++ b/src/3rdparty/masm/disassembler/udis86/udis86_decode.c @@ -0,0 +1,1142 @@ +/* udis86 - libudis86/decode.c + * + * Copyright (c) 2002-2009 Vivek Thampi + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include + +#if USE(UDIS86) + +#include "udis86_extern.h" +#include "udis86_types.h" +#include "udis86_input.h" +#include "udis86_decode.h" +#include + +#define dbg(x, n...) +/* #define dbg printf */ + +#ifndef __UD_STANDALONE__ +# include +#endif /* __UD_STANDALONE__ */ + +/* The max number of prefixes to an instruction */ +#define MAX_PREFIXES 15 + +/* instruction aliases and special cases */ +static struct ud_itab_entry s_ie__invalid = + { UD_Iinvalid, O_NONE, O_NONE, O_NONE, P_none }; + +static int +decode_ext(struct ud *u, uint16_t ptr); + + +static inline int +eff_opr_mode(int dis_mode, int rex_w, int pfx_opr) +{ + if (dis_mode == 64) { + return rex_w ? 64 : (pfx_opr ? 16 : 32); + } else if (dis_mode == 32) { + return pfx_opr ? 16 : 32; + } else { + ASSERT(dis_mode == 16); + return pfx_opr ? 32 : 16; + } +} + + +static inline int +eff_adr_mode(int dis_mode, int pfx_adr) +{ + if (dis_mode == 64) { + return pfx_adr ? 32 : 64; + } else if (dis_mode == 32) { + return pfx_adr ? 16 : 32; + } else { + ASSERT(dis_mode == 16); + return pfx_adr ? 32 : 16; + } +} + + +/* Looks up mnemonic code in the mnemonic string table + * Returns NULL if the mnemonic code is invalid + */ +const char * ud_lookup_mnemonic( enum ud_mnemonic_code c ) +{ + return ud_mnemonics_str[ c ]; +} + + +/* + * decode_prefixes + * + * Extracts instruction prefixes. + */ +static int +decode_prefixes(struct ud *u) +{ + unsigned int have_pfx = 1; + unsigned int i; + uint8_t curr; + + /* if in error state, bail out */ + if ( u->error ) + return -1; + + /* keep going as long as there are prefixes available */ + for ( i = 0; have_pfx ; ++i ) { + + /* Get next byte. */ + ud_inp_next(u); + if ( u->error ) + return -1; + curr = ud_inp_curr( u ); + + /* rex prefixes in 64bit mode */ + if ( u->dis_mode == 64 && ( curr & 0xF0 ) == 0x40 ) { + u->pfx_rex = curr; + } else { + switch ( curr ) + { + case 0x2E : + u->pfx_seg = UD_R_CS; + u->pfx_rex = 0; + break; + case 0x36 : + u->pfx_seg = UD_R_SS; + u->pfx_rex = 0; + break; + case 0x3E : + u->pfx_seg = UD_R_DS; + u->pfx_rex = 0; + break; + case 0x26 : + u->pfx_seg = UD_R_ES; + u->pfx_rex = 0; + break; + case 0x64 : + u->pfx_seg = UD_R_FS; + u->pfx_rex = 0; + break; + case 0x65 : + u->pfx_seg = UD_R_GS; + u->pfx_rex = 0; + break; + case 0x67 : /* adress-size override prefix */ + u->pfx_adr = 0x67; + u->pfx_rex = 0; + break; + case 0xF0 : + u->pfx_lock = 0xF0; + u->pfx_rex = 0; + break; + case 0x66: + /* the 0x66 sse prefix is only effective if no other sse prefix + * has already been specified. + */ + if ( !u->pfx_insn ) u->pfx_insn = 0x66; + u->pfx_opr = 0x66; + u->pfx_rex = 0; + break; + case 0xF2: + u->pfx_insn = 0xF2; + u->pfx_repne = 0xF2; + u->pfx_rex = 0; + break; + case 0xF3: + u->pfx_insn = 0xF3; + u->pfx_rep = 0xF3; + u->pfx_repe = 0xF3; + u->pfx_rex = 0; + break; + default : + /* No more prefixes */ + have_pfx = 0; + break; + } + } + + /* check if we reached max instruction length */ + if ( i + 1 == MAX_INSN_LENGTH ) { + u->error = 1; + break; + } + } + + /* return status */ + if ( u->error ) + return -1; + + /* rewind back one byte in stream, since the above loop + * stops with a non-prefix byte. + */ + ud_inp_back(u); + return 0; +} + + +static inline unsigned int modrm( struct ud * u ) +{ + if ( !u->have_modrm ) { + u->modrm = ud_inp_next( u ); + u->have_modrm = 1; + } + return u->modrm; +} + + +static unsigned int resolve_operand_size( const struct ud * u, unsigned int s ) +{ + switch ( s ) + { + case SZ_V: + return ( u->opr_mode ); + case SZ_Z: + return ( u->opr_mode == 16 ) ? 16 : 32; + case SZ_P: + return ( u->opr_mode == 16 ) ? SZ_WP : SZ_DP; + case SZ_MDQ: + return ( u->opr_mode == 16 ) ? 32 : u->opr_mode; + case SZ_RDQ: + return ( u->dis_mode == 64 ) ? 64 : 32; + default: + return s; + } +} + + +static int resolve_mnemonic( struct ud* u ) +{ + /* far/near flags */ + u->br_far = 0; + u->br_near = 0; + /* readjust operand sizes for call/jmp instrcutions */ + if ( u->mnemonic == UD_Icall || u->mnemonic == UD_Ijmp ) { + /* WP: 16:16 pointer */ + if ( u->operand[ 0 ].size == SZ_WP ) { + u->operand[ 0 ].size = 16; + u->br_far = 1; + u->br_near= 0; + /* DP: 32:32 pointer */ + } else if ( u->operand[ 0 ].size == SZ_DP ) { + u->operand[ 0 ].size = 32; + u->br_far = 1; + u->br_near= 0; + } else { + u->br_far = 0; + u->br_near= 1; + } + /* resolve 3dnow weirdness. */ + } else if ( u->mnemonic == UD_I3dnow ) { + u->mnemonic = ud_itab[ u->le->table[ ud_inp_curr( u ) ] ].mnemonic; + } + /* SWAPGS is only valid in 64bits mode */ + if ( u->mnemonic == UD_Iswapgs && u->dis_mode != 64 ) { + u->error = 1; + return -1; + } + + if (u->mnemonic == UD_Ixchg) { + if ((u->operand[0].type == UD_OP_REG && u->operand[0].base == UD_R_AX && + u->operand[1].type == UD_OP_REG && u->operand[1].base == UD_R_AX) || + (u->operand[0].type == UD_OP_REG && u->operand[0].base == UD_R_EAX && + u->operand[1].type == UD_OP_REG && u->operand[1].base == UD_R_EAX)) { + u->operand[0].type = UD_NONE; + u->operand[1].type = UD_NONE; + u->mnemonic = UD_Inop; + } + } + + if (u->mnemonic == UD_Inop && u->pfx_rep) { + u->pfx_rep = 0; + u->mnemonic = UD_Ipause; + } + return 0; +} + + +/* ----------------------------------------------------------------------------- + * decode_a()- Decodes operands of the type seg:offset + * ----------------------------------------------------------------------------- + */ +static void +decode_a(struct ud* u, struct ud_operand *op) +{ + if (u->opr_mode == 16) { + /* seg16:off16 */ + op->type = UD_OP_PTR; + op->size = 32; + op->lval.ptr.off = ud_inp_uint16(u); + op->lval.ptr.seg = ud_inp_uint16(u); + } else { + /* seg16:off32 */ + op->type = UD_OP_PTR; + op->size = 48; + op->lval.ptr.off = ud_inp_uint32(u); + op->lval.ptr.seg = ud_inp_uint16(u); + } +} + +/* ----------------------------------------------------------------------------- + * decode_gpr() - Returns decoded General Purpose Register + * ----------------------------------------------------------------------------- + */ +static enum ud_type +decode_gpr(register struct ud* u, unsigned int s, unsigned char rm) +{ + s = resolve_operand_size(u, s); + + switch (s) { + case 64: + return UD_R_RAX + rm; + case SZ_DP: + case 32: + return UD_R_EAX + rm; + case SZ_WP: + case 16: + return UD_R_AX + rm; + case 8: + if (u->dis_mode == 64 && u->pfx_rex) { + if (rm >= 4) + return UD_R_SPL + (rm-4); + return UD_R_AL + rm; + } else return UD_R_AL + rm; + default: + return 0; + } +} + +/* ----------------------------------------------------------------------------- + * resolve_gpr64() - 64bit General Purpose Register-Selection. + * ----------------------------------------------------------------------------- + */ +static enum ud_type +resolve_gpr64(struct ud* u, enum ud_operand_code gpr_op, enum ud_operand_size * size) +{ + if (gpr_op >= OP_rAXr8 && gpr_op <= OP_rDIr15) + gpr_op = (gpr_op - OP_rAXr8) | (REX_B(u->pfx_rex) << 3); + else gpr_op = (gpr_op - OP_rAX); + + if (u->opr_mode == 16) { + *size = 16; + return gpr_op + UD_R_AX; + } + if (u->dis_mode == 32 || + (u->opr_mode == 32 && ! (REX_W(u->pfx_rex) || u->default64))) { + *size = 32; + return gpr_op + UD_R_EAX; + } + + *size = 64; + return gpr_op + UD_R_RAX; +} + +/* ----------------------------------------------------------------------------- + * resolve_gpr32 () - 32bit General Purpose Register-Selection. + * ----------------------------------------------------------------------------- + */ +static enum ud_type +resolve_gpr32(struct ud* u, enum ud_operand_code gpr_op) +{ + gpr_op = gpr_op - OP_eAX; + + if (u->opr_mode == 16) + return gpr_op + UD_R_AX; + + return gpr_op + UD_R_EAX; +} + +/* ----------------------------------------------------------------------------- + * resolve_reg() - Resolves the register type + * ----------------------------------------------------------------------------- + */ +static enum ud_type +resolve_reg(struct ud* u, unsigned int type, unsigned char i) +{ + switch (type) { + case T_MMX : return UD_R_MM0 + (i & 7); + case T_XMM : return UD_R_XMM0 + i; + case T_CRG : return UD_R_CR0 + i; + case T_DBG : return UD_R_DR0 + i; + case T_SEG : { + /* + * Only 6 segment registers, anything else is an error. + */ + if ((i & 7) > 5) { + u->error = 1; + } else { + return UD_R_ES + (i & 7); + } + } + case T_NONE: + default: return UD_NONE; + } +} + +/* ----------------------------------------------------------------------------- + * decode_imm() - Decodes Immediate values. + * ----------------------------------------------------------------------------- + */ +static void +decode_imm(struct ud* u, unsigned int s, struct ud_operand *op) +{ + op->size = resolve_operand_size(u, s); + op->type = UD_OP_IMM; + + switch (op->size) { + case 8: op->lval.sbyte = ud_inp_uint8(u); break; + case 16: op->lval.uword = ud_inp_uint16(u); break; + case 32: op->lval.udword = ud_inp_uint32(u); break; + case 64: op->lval.uqword = ud_inp_uint64(u); break; + default: return; + } +} + + +/* + * decode_modrm_reg + * + * Decodes reg field of mod/rm byte + * + */ +static void +decode_modrm_reg(struct ud *u, + struct ud_operand *operand, + unsigned int type, + unsigned int size) +{ + uint8_t reg = (REX_R(u->pfx_rex) << 3) | MODRM_REG(modrm(u)); + operand->type = UD_OP_REG; + operand->size = resolve_operand_size(u, size); + + if (type == T_GPR) { + operand->base = decode_gpr(u, operand->size, reg); + } else { + operand->base = resolve_reg(u, type, reg); + } +} + + +/* + * decode_modrm_rm + * + * Decodes rm field of mod/rm byte + * + */ +static void +decode_modrm_rm(struct ud *u, + struct ud_operand *op, + unsigned char type, + unsigned int size) + +{ + unsigned char mod, rm, reg; + + /* get mod, r/m and reg fields */ + mod = MODRM_MOD(modrm(u)); + rm = (REX_B(u->pfx_rex) << 3) | MODRM_RM(modrm(u)); + reg = (REX_R(u->pfx_rex) << 3) | MODRM_REG(modrm(u)); + + op->size = resolve_operand_size(u, size); + + /* + * If mod is 11b, then the modrm.rm specifies a register. + * + */ + if (mod == 3) { + op->type = UD_OP_REG; + if (type == T_GPR) { + op->base = decode_gpr(u, op->size, rm); + } else { + op->base = resolve_reg(u, type, (REX_B(u->pfx_rex) << 3) | (rm & 7)); + } + return; + } + + + /* + * !11 => Memory Address + */ + op->type = UD_OP_MEM; + + if (u->adr_mode == 64) { + op->base = UD_R_RAX + rm; + if (mod == 1) { + op->offset = 8; + } else if (mod == 2) { + op->offset = 32; + } else if (mod == 0 && (rm & 7) == 5) { + op->base = UD_R_RIP; + op->offset = 32; + } else { + op->offset = 0; + } + /* + * Scale-Index-Base (SIB) + */ + if ((rm & 7) == 4) { + ud_inp_next(u); + + op->scale = (1 << SIB_S(ud_inp_curr(u))) & ~1; + op->index = UD_R_RAX + (SIB_I(ud_inp_curr(u)) | (REX_X(u->pfx_rex) << 3)); + op->base = UD_R_RAX + (SIB_B(ud_inp_curr(u)) | (REX_B(u->pfx_rex) << 3)); + + /* special conditions for base reference */ + if (op->index == UD_R_RSP) { + op->index = UD_NONE; + op->scale = UD_NONE; + } + + if (op->base == UD_R_RBP || op->base == UD_R_R13) { + if (mod == 0) { + op->base = UD_NONE; + } + if (mod == 1) { + op->offset = 8; + } else { + op->offset = 32; + } + } + } + } else if (u->adr_mode == 32) { + op->base = UD_R_EAX + rm; + if (mod == 1) { + op->offset = 8; + } else if (mod == 2) { + op->offset = 32; + } else if (mod == 0 && rm == 5) { + op->base = UD_NONE; + op->offset = 32; + } else { + op->offset = 0; + } + + /* Scale-Index-Base (SIB) */ + if ((rm & 7) == 4) { + ud_inp_next(u); + + op->scale = (1 << SIB_S(ud_inp_curr(u))) & ~1; + op->index = UD_R_EAX + (SIB_I(ud_inp_curr(u)) | (REX_X(u->pfx_rex) << 3)); + op->base = UD_R_EAX + (SIB_B(ud_inp_curr(u)) | (REX_B(u->pfx_rex) << 3)); + + if (op->index == UD_R_ESP) { + op->index = UD_NONE; + op->scale = UD_NONE; + } + + /* special condition for base reference */ + if (op->base == UD_R_EBP) { + if (mod == 0) { + op->base = UD_NONE; + } + if (mod == 1) { + op->offset = 8; + } else { + op->offset = 32; + } + } + } + } else { + const unsigned int bases[] = { UD_R_BX, UD_R_BX, UD_R_BP, UD_R_BP, + UD_R_SI, UD_R_DI, UD_R_BP, UD_R_BX }; + const unsigned int indices[] = { UD_R_SI, UD_R_DI, UD_R_SI, UD_R_DI, + UD_NONE, UD_NONE, UD_NONE, UD_NONE }; + op->base = bases[rm & 7]; + op->index = indices[rm & 7]; + if (mod == 0 && rm == 6) { + op->offset= 16; + op->base = UD_NONE; + } else if (mod == 1) { + op->offset = 8; + } else if (mod == 2) { + op->offset = 16; + } + } + + /* + * extract offset, if any + */ + switch (op->offset) { + case 8 : op->lval.ubyte = ud_inp_uint8(u); break; + case 16: op->lval.uword = ud_inp_uint16(u); break; + case 32: op->lval.udword = ud_inp_uint32(u); break; + case 64: op->lval.uqword = ud_inp_uint64(u); break; + default: break; + } +} + +/* ----------------------------------------------------------------------------- + * decode_o() - Decodes offset + * ----------------------------------------------------------------------------- + */ +static void +decode_o(struct ud* u, unsigned int s, struct ud_operand *op) +{ + switch (u->adr_mode) { + case 64: + op->offset = 64; + op->lval.uqword = ud_inp_uint64(u); + break; + case 32: + op->offset = 32; + op->lval.udword = ud_inp_uint32(u); + break; + case 16: + op->offset = 16; + op->lval.uword = ud_inp_uint16(u); + break; + default: + return; + } + op->type = UD_OP_MEM; + op->size = resolve_operand_size(u, s); +} + +/* ----------------------------------------------------------------------------- + * decode_operands() - Disassembles Operands. + * ----------------------------------------------------------------------------- + */ +static int +decode_operand(struct ud *u, + struct ud_operand *operand, + enum ud_operand_code type, + unsigned int size) +{ + switch (type) { + case OP_A : + decode_a(u, operand); + break; + case OP_MR: + if (MODRM_MOD(modrm(u)) == 3) { + decode_modrm_rm(u, operand, T_GPR, + size == SZ_DY ? SZ_MDQ : SZ_V); + } else if (size == SZ_WV) { + decode_modrm_rm( u, operand, T_GPR, SZ_W); + } else if (size == SZ_BV) { + decode_modrm_rm( u, operand, T_GPR, SZ_B); + } else if (size == SZ_DY) { + decode_modrm_rm( u, operand, T_GPR, SZ_D); + } else { + ASSERT(!"unexpected size"); + } + break; + case OP_M: + if (MODRM_MOD(modrm(u)) == 3) { + u->error = 1; + } + /* intended fall through */ + case OP_E: + decode_modrm_rm(u, operand, T_GPR, size); + break; + break; + case OP_G: + decode_modrm_reg(u, operand, T_GPR, size); + break; + case OP_I: + decode_imm(u, size, operand); + break; + case OP_I1: + operand->type = UD_OP_CONST; + operand->lval.udword = 1; + break; + case OP_PR: + if (MODRM_MOD(modrm(u)) != 3) { + u->error = 1; + } + decode_modrm_rm(u, operand, T_MMX, size); + break; + case OP_P: + decode_modrm_reg(u, operand, T_MMX, size); + break; + case OP_VR: + if (MODRM_MOD(modrm(u)) != 3) { + u->error = 1; + } + /* intended fall through */ + case OP_W: + decode_modrm_rm(u, operand, T_XMM, size); + break; + case OP_V: + decode_modrm_reg(u, operand, T_XMM, size); + break; + case OP_S: + decode_modrm_reg(u, operand, T_SEG, size); + break; + case OP_AL: + case OP_CL: + case OP_DL: + case OP_BL: + case OP_AH: + case OP_CH: + case OP_DH: + case OP_BH: + operand->type = UD_OP_REG; + operand->base = UD_R_AL + (type - OP_AL); + operand->size = 8; + break; + case OP_DX: + operand->type = UD_OP_REG; + operand->base = UD_R_DX; + operand->size = 16; + break; + case OP_O: + decode_o(u, size, operand); + break; + case OP_rAXr8: + case OP_rCXr9: + case OP_rDXr10: + case OP_rBXr11: + case OP_rSPr12: + case OP_rBPr13: + case OP_rSIr14: + case OP_rDIr15: + case OP_rAX: + case OP_rCX: + case OP_rDX: + case OP_rBX: + case OP_rSP: + case OP_rBP: + case OP_rSI: + case OP_rDI: + operand->type = UD_OP_REG; + operand->base = resolve_gpr64(u, type, &operand->size); + break; + case OP_ALr8b: + case OP_CLr9b: + case OP_DLr10b: + case OP_BLr11b: + case OP_AHr12b: + case OP_CHr13b: + case OP_DHr14b: + case OP_BHr15b: { + ud_type_t gpr = (type - OP_ALr8b) + UD_R_AL + + (REX_B(u->pfx_rex) << 3); + if (UD_R_AH <= gpr && u->pfx_rex) { + gpr = gpr + 4; + } + operand->type = UD_OP_REG; + operand->base = gpr; + break; + } + case OP_eAX: + case OP_eCX: + case OP_eDX: + case OP_eBX: + case OP_eSP: + case OP_eBP: + case OP_eSI: + case OP_eDI: + operand->type = UD_OP_REG; + operand->base = resolve_gpr32(u, type); + operand->size = u->opr_mode == 16 ? 16 : 32; + break; + case OP_ES: + case OP_CS: + case OP_DS: + case OP_SS: + case OP_FS: + case OP_GS: + /* in 64bits mode, only fs and gs are allowed */ + if (u->dis_mode == 64) { + if (type != OP_FS && type != OP_GS) { + u->error= 1; + } + } + operand->type = UD_OP_REG; + operand->base = (type - OP_ES) + UD_R_ES; + operand->size = 16; + break; + case OP_J : + decode_imm(u, size, operand); + operand->type = UD_OP_JIMM; + break ; + case OP_Q: + decode_modrm_rm(u, operand, T_MMX, size); + break; + case OP_R : + decode_modrm_rm(u, operand, T_GPR, size); + break; + case OP_C: + decode_modrm_reg(u, operand, T_CRG, size); + break; + case OP_D: + decode_modrm_reg(u, operand, T_DBG, size); + break; + case OP_I3 : + operand->type = UD_OP_CONST; + operand->lval.sbyte = 3; + break; + case OP_ST0: + case OP_ST1: + case OP_ST2: + case OP_ST3: + case OP_ST4: + case OP_ST5: + case OP_ST6: + case OP_ST7: + operand->type = UD_OP_REG; + operand->base = (type - OP_ST0) + UD_R_ST0; + operand->size = 0; + break; + case OP_AX: + operand->type = UD_OP_REG; + operand->base = UD_R_AX; + operand->size = 16; + break; + default : + operand->type = UD_NONE; + break; + } + return 0; +} + + +/* + * decode_operands + * + * Disassemble upto 3 operands of the current instruction being + * disassembled. By the end of the function, the operand fields + * of the ud structure will have been filled. + */ +static int +decode_operands(struct ud* u) +{ + decode_operand(u, &u->operand[0], + u->itab_entry->operand1.type, + u->itab_entry->operand1.size); + decode_operand(u, &u->operand[1], + u->itab_entry->operand2.type, + u->itab_entry->operand2.size); + decode_operand(u, &u->operand[2], + u->itab_entry->operand3.type, + u->itab_entry->operand3.size); + return 0; +} + +/* ----------------------------------------------------------------------------- + * clear_insn() - clear instruction structure + * ----------------------------------------------------------------------------- + */ +static void +clear_insn(register struct ud* u) +{ + u->error = 0; + u->pfx_seg = 0; + u->pfx_opr = 0; + u->pfx_adr = 0; + u->pfx_lock = 0; + u->pfx_repne = 0; + u->pfx_rep = 0; + u->pfx_repe = 0; + u->pfx_rex = 0; + u->pfx_insn = 0; + u->mnemonic = UD_Inone; + u->itab_entry = NULL; + u->have_modrm = 0; + + memset( &u->operand[ 0 ], 0, sizeof( struct ud_operand ) ); + memset( &u->operand[ 1 ], 0, sizeof( struct ud_operand ) ); + memset( &u->operand[ 2 ], 0, sizeof( struct ud_operand ) ); +} + +static int +resolve_mode( struct ud* u ) +{ + /* if in error state, bail out */ + if ( u->error ) return -1; + + /* propagate prefix effects */ + if ( u->dis_mode == 64 ) { /* set 64bit-mode flags */ + + /* Check validity of instruction m64 */ + if ( P_INV64( u->itab_entry->prefix ) ) { + u->error = 1; + return -1; + } + + /* effective rex prefix is the effective mask for the + * instruction hard-coded in the opcode map. + */ + u->pfx_rex = ( u->pfx_rex & 0x40 ) | + ( u->pfx_rex & REX_PFX_MASK( u->itab_entry->prefix ) ); + + /* whether this instruction has a default operand size of + * 64bit, also hardcoded into the opcode map. + */ + u->default64 = P_DEF64( u->itab_entry->prefix ); + /* calculate effective operand size */ + if ( REX_W( u->pfx_rex ) ) { + u->opr_mode = 64; + } else if ( u->pfx_opr ) { + u->opr_mode = 16; + } else { + /* unless the default opr size of instruction is 64, + * the effective operand size in the absence of rex.w + * prefix is 32. + */ + u->opr_mode = ( u->default64 ) ? 64 : 32; + } + + /* calculate effective address size */ + u->adr_mode = (u->pfx_adr) ? 32 : 64; + } else if ( u->dis_mode == 32 ) { /* set 32bit-mode flags */ + u->opr_mode = ( u->pfx_opr ) ? 16 : 32; + u->adr_mode = ( u->pfx_adr ) ? 16 : 32; + } else if ( u->dis_mode == 16 ) { /* set 16bit-mode flags */ + u->opr_mode = ( u->pfx_opr ) ? 32 : 16; + u->adr_mode = ( u->pfx_adr ) ? 32 : 16; + } + + /* These flags determine which operand to apply the operand size + * cast to. + */ + u->c1 = ( P_C1( u->itab_entry->prefix ) ) ? 1 : 0; + u->c2 = ( P_C2( u->itab_entry->prefix ) ) ? 1 : 0; + u->c3 = ( P_C3( u->itab_entry->prefix ) ) ? 1 : 0; + + /* set flags for implicit addressing */ + u->implicit_addr = P_IMPADDR( u->itab_entry->prefix ); + + return 0; +} + +static int gen_hex( struct ud *u ) +{ + unsigned int i; + unsigned char *src_ptr = ud_inp_sess( u ); + char* src_hex; + + /* bail out if in error stat. */ + if ( u->error ) return -1; + /* output buffer pointe */ + src_hex = ( char* ) u->insn_hexcode; + /* for each byte used to decode instruction */ + for ( i = 0; i < u->inp_ctr; ++i, ++src_ptr) { + sprintf( src_hex, "%02x", *src_ptr & 0xFF ); + src_hex += 2; + } + return 0; +} + + +static inline int +decode_insn(struct ud *u, uint16_t ptr) +{ + ASSERT((ptr & 0x8000) == 0); + u->itab_entry = &ud_itab[ ptr ]; + u->mnemonic = u->itab_entry->mnemonic; + return (resolve_mode(u) == 0 && + decode_operands(u) == 0 && + resolve_mnemonic(u) == 0) ? 0 : -1; +} + + +/* + * decode_3dnow() + * + * Decoding 3dnow is a little tricky because of its strange opcode + * structure. The final opcode disambiguation depends on the last + * byte that comes after the operands have been decoded. Fortunately, + * all 3dnow instructions have the same set of operand types. So we + * go ahead and decode the instruction by picking an arbitrarily chosen + * valid entry in the table, decode the operands, and read the final + * byte to resolve the menmonic. + */ +static inline int +decode_3dnow(struct ud* u) +{ + uint16_t ptr; + ASSERT(u->le->type == UD_TAB__OPC_3DNOW); + ASSERT(u->le->table[0xc] != 0); + decode_insn(u, u->le->table[0xc]); + ud_inp_next(u); + if (u->error) { + return -1; + } + ptr = u->le->table[ud_inp_curr(u)]; + ASSERT((ptr & 0x8000) == 0); + u->mnemonic = ud_itab[ptr].mnemonic; + return 0; +} + + +static int +decode_ssepfx(struct ud *u) +{ + uint8_t idx = ((u->pfx_insn & 0xf) + 1) / 2; + if (u->le->table[idx] == 0) { + idx = 0; + } + if (idx && u->le->table[idx] != 0) { + /* + * "Consume" the prefix as a part of the opcode, so it is no + * longer exported as an instruction prefix. + */ + switch (u->pfx_insn) { + case 0xf2: + u->pfx_repne = 0; + break; + case 0xf3: + u->pfx_rep = 0; + u->pfx_repe = 0; + break; + case 0x66: + u->pfx_opr = 0; + break; + } + } + return decode_ext(u, u->le->table[idx]); +} + + +/* + * decode_ext() + * + * Decode opcode extensions (if any) + */ +static int +decode_ext(struct ud *u, uint16_t ptr) +{ + uint8_t idx = 0; + if ((ptr & 0x8000) == 0) { + return decode_insn(u, ptr); + } + u->le = &ud_lookup_table_list[(~0x8000 & ptr)]; + if (u->le->type == UD_TAB__OPC_3DNOW) { + return decode_3dnow(u); + } + + switch (u->le->type) { + case UD_TAB__OPC_MOD: + /* !11 = 0, 11 = 1 */ + idx = (MODRM_MOD(modrm(u)) + 1) / 4; + break; + /* disassembly mode/operand size/address size based tables. + * 16 = 0,, 32 = 1, 64 = 2 + */ + case UD_TAB__OPC_MODE: + idx = u->dis_mode / 32; + break; + case UD_TAB__OPC_OSIZE: + idx = eff_opr_mode(u->dis_mode, REX_W(u->pfx_rex), u->pfx_opr) / 32; + break; + case UD_TAB__OPC_ASIZE: + idx = eff_adr_mode(u->dis_mode, u->pfx_adr) / 32; + break; + case UD_TAB__OPC_X87: + idx = modrm(u) - 0xC0; + break; + case UD_TAB__OPC_VENDOR: + if (u->vendor == UD_VENDOR_ANY) { + /* choose a valid entry */ + idx = (u->le->table[idx] != 0) ? 0 : 1; + } else if (u->vendor == UD_VENDOR_AMD) { + idx = 0; + } else { + idx = 1; + } + break; + case UD_TAB__OPC_RM: + idx = MODRM_RM(modrm(u)); + break; + case UD_TAB__OPC_REG: + idx = MODRM_REG(modrm(u)); + break; + case UD_TAB__OPC_SSE: + return decode_ssepfx(u); + default: + ASSERT(!"not reached"); + break; + } + + return decode_ext(u, u->le->table[idx]); +} + + +static inline int +decode_opcode(struct ud *u) +{ + uint16_t ptr; + ASSERT(u->le->type == UD_TAB__OPC_TABLE); + ud_inp_next(u); + if (u->error) { + return -1; + } + ptr = u->le->table[ud_inp_curr(u)]; + if (ptr & 0x8000) { + u->le = &ud_lookup_table_list[ptr & ~0x8000]; + if (u->le->type == UD_TAB__OPC_TABLE) { + return decode_opcode(u); + } + } + return decode_ext(u, ptr); +} + + +/* ============================================================================= + * ud_decode() - Instruction decoder. Returns the number of bytes decoded. + * ============================================================================= + */ +unsigned int +ud_decode(struct ud *u) +{ + ud_inp_start(u); + clear_insn(u); + u->le = &ud_lookup_table_list[0]; + u->error = decode_prefixes(u) == -1 || + decode_opcode(u) == -1 || + u->error; + /* Handle decode error. */ + if (u->error) { + /* clear out the decode data. */ + clear_insn(u); + /* mark the sequence of bytes as invalid. */ + u->itab_entry = & s_ie__invalid; + u->mnemonic = u->itab_entry->mnemonic; + } + + /* maybe this stray segment override byte + * should be spewed out? + */ + if ( !P_SEG( u->itab_entry->prefix ) && + u->operand[0].type != UD_OP_MEM && + u->operand[1].type != UD_OP_MEM ) + u->pfx_seg = 0; + + u->insn_offset = u->pc; /* set offset of instruction */ + u->insn_fill = 0; /* set translation buffer index to 0 */ + u->pc += u->inp_ctr; /* move program counter by bytes decoded */ + gen_hex( u ); /* generate hex code */ + + /* return number of bytes disassembled. */ + return u->inp_ctr; +} + +/* +vim: set ts=2 sw=2 expandtab +*/ + +#endif // USE(UDIS86) diff --git a/src/3rdparty/masm/disassembler/udis86/udis86_decode.h b/src/3rdparty/masm/disassembler/udis86/udis86_decode.h new file mode 100644 index 0000000000..940ed5ad6f --- /dev/null +++ b/src/3rdparty/masm/disassembler/udis86/udis86_decode.h @@ -0,0 +1,258 @@ +/* udis86 - libudis86/decode.h + * + * Copyright (c) 2002-2009 Vivek Thampi + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +#ifndef UD_DECODE_H +#define UD_DECODE_H + +#include "udis86_types.h" +#include "udis86_itab.h" + +#define MAX_INSN_LENGTH 15 + +/* register classes */ +#define T_NONE 0 +#define T_GPR 1 +#define T_MMX 2 +#define T_CRG 3 +#define T_DBG 4 +#define T_SEG 5 +#define T_XMM 6 + +/* itab prefix bits */ +#define P_none ( 0 ) +#define P_cast ( 1 << 0 ) +#define P_CAST(n) ( ( n >> 0 ) & 1 ) +#define P_c1 ( 1 << 0 ) +#define P_C1(n) ( ( n >> 0 ) & 1 ) +#define P_rexb ( 1 << 1 ) +#define P_REXB(n) ( ( n >> 1 ) & 1 ) +#define P_depM ( 1 << 2 ) +#define P_DEPM(n) ( ( n >> 2 ) & 1 ) +#define P_c3 ( 1 << 3 ) +#define P_C3(n) ( ( n >> 3 ) & 1 ) +#define P_inv64 ( 1 << 4 ) +#define P_INV64(n) ( ( n >> 4 ) & 1 ) +#define P_rexw ( 1 << 5 ) +#define P_REXW(n) ( ( n >> 5 ) & 1 ) +#define P_c2 ( 1 << 6 ) +#define P_C2(n) ( ( n >> 6 ) & 1 ) +#define P_def64 ( 1 << 7 ) +#define P_DEF64(n) ( ( n >> 7 ) & 1 ) +#define P_rexr ( 1 << 8 ) +#define P_REXR(n) ( ( n >> 8 ) & 1 ) +#define P_oso ( 1 << 9 ) +#define P_OSO(n) ( ( n >> 9 ) & 1 ) +#define P_aso ( 1 << 10 ) +#define P_ASO(n) ( ( n >> 10 ) & 1 ) +#define P_rexx ( 1 << 11 ) +#define P_REXX(n) ( ( n >> 11 ) & 1 ) +#define P_ImpAddr ( 1 << 12 ) +#define P_IMPADDR(n) ( ( n >> 12 ) & 1 ) +#define P_seg ( 1 << 13 ) +#define P_SEG(n) ( ( n >> 13 ) & 1 ) +#define P_sext ( 1 << 14 ) +#define P_SEXT(n) ( ( n >> 14 ) & 1 ) + +/* rex prefix bits */ +#define REX_W(r) ( ( 0xF & ( r ) ) >> 3 ) +#define REX_R(r) ( ( 0x7 & ( r ) ) >> 2 ) +#define REX_X(r) ( ( 0x3 & ( r ) ) >> 1 ) +#define REX_B(r) ( ( 0x1 & ( r ) ) >> 0 ) +#define REX_PFX_MASK(n) ( ( P_REXW(n) << 3 ) | \ + ( P_REXR(n) << 2 ) | \ + ( P_REXX(n) << 1 ) | \ + ( P_REXB(n) << 0 ) ) + +/* scable-index-base bits */ +#define SIB_S(b) ( ( b ) >> 6 ) +#define SIB_I(b) ( ( ( b ) >> 3 ) & 7 ) +#define SIB_B(b) ( ( b ) & 7 ) + +/* modrm bits */ +#define MODRM_REG(b) ( ( ( b ) >> 3 ) & 7 ) +#define MODRM_NNN(b) ( ( ( b ) >> 3 ) & 7 ) +#define MODRM_MOD(b) ( ( ( b ) >> 6 ) & 3 ) +#define MODRM_RM(b) ( ( b ) & 7 ) + +/* operand type constants -- order is important! */ + +enum ud_operand_code { + OP_NONE, + + OP_A, OP_E, OP_M, OP_G, + OP_I, + + OP_AL, OP_CL, OP_DL, OP_BL, + OP_AH, OP_CH, OP_DH, OP_BH, + + OP_ALr8b, OP_CLr9b, OP_DLr10b, OP_BLr11b, + OP_AHr12b, OP_CHr13b, OP_DHr14b, OP_BHr15b, + + OP_AX, OP_CX, OP_DX, OP_BX, + OP_SI, OP_DI, OP_SP, OP_BP, + + OP_rAX, OP_rCX, OP_rDX, OP_rBX, + OP_rSP, OP_rBP, OP_rSI, OP_rDI, + + OP_rAXr8, OP_rCXr9, OP_rDXr10, OP_rBXr11, + OP_rSPr12, OP_rBPr13, OP_rSIr14, OP_rDIr15, + + OP_eAX, OP_eCX, OP_eDX, OP_eBX, + OP_eSP, OP_eBP, OP_eSI, OP_eDI, + + OP_ES, OP_CS, OP_SS, OP_DS, + OP_FS, OP_GS, + + OP_ST0, OP_ST1, OP_ST2, OP_ST3, + OP_ST4, OP_ST5, OP_ST6, OP_ST7, + + OP_J, OP_S, OP_O, + OP_I1, OP_I3, + + OP_V, OP_W, OP_Q, OP_P, + + OP_R, OP_C, OP_D, OP_VR, OP_PR, + + OP_MR +} UD_ATTR_PACKED; + + +/* operand size constants */ + +enum ud_operand_size { + SZ_NA = 0, + SZ_Z = 1, + SZ_V = 2, + SZ_P = 3, + SZ_WP = 4, + SZ_DP = 5, + SZ_MDQ = 6, + SZ_RDQ = 7, + + /* the following values are used as is, + * and thus hard-coded. changing them + * will break internals + */ + SZ_B = 8, + SZ_W = 16, + SZ_D = 32, + SZ_Q = 64, + SZ_T = 80, + SZ_O = 128, + + SZ_WV = 17, + SZ_BV = 18, + SZ_DY = 19 + +} UD_ATTR_PACKED; + + +/* A single operand of an entry in the instruction table. + * (internal use only) + */ +struct ud_itab_entry_operand +{ + enum ud_operand_code type; + enum ud_operand_size size; +}; + + +/* A single entry in an instruction table. + *(internal use only) + */ +struct ud_itab_entry +{ + enum ud_mnemonic_code mnemonic; + struct ud_itab_entry_operand operand1; + struct ud_itab_entry_operand operand2; + struct ud_itab_entry_operand operand3; + uint32_t prefix; +}; + +struct ud_lookup_table_list_entry { + const uint16_t *table; + enum ud_table_type type; + const char *meta; +}; + + +static inline unsigned int sse_pfx_idx( const unsigned int pfx ) +{ + /* 00 = 0 + * f2 = 1 + * f3 = 2 + * 66 = 3 + */ + return ( ( pfx & 0xf ) + 1 ) / 2; +} + +static inline unsigned int mode_idx( const unsigned int mode ) +{ + /* 16 = 0 + * 32 = 1 + * 64 = 2 + */ + return ( mode / 32 ); +} + +static inline unsigned int modrm_mod_idx( const unsigned int mod ) +{ + /* !11 = 0 + * 11 = 1 + */ + return ( mod + 1 ) / 4; +} + +static inline unsigned int vendor_idx( const unsigned int vendor ) +{ + switch ( vendor ) { + case UD_VENDOR_AMD: return 0; + case UD_VENDOR_INTEL: return 1; + case UD_VENDOR_ANY: return 2; + default: return 2; + } +} + +static inline unsigned int is_group_ptr( uint16_t ptr ) +{ + return ( 0x8000 & ptr ); +} + +static inline unsigned int group_idx( uint16_t ptr ) +{ + return ( ~0x8000 & ptr ); +} + + +extern struct ud_itab_entry ud_itab[]; +extern struct ud_lookup_table_list_entry ud_lookup_table_list[]; + +#endif /* UD_DECODE_H */ + +/* vim:cindent + * vim:expandtab + * vim:ts=4 + * vim:sw=4 + */ diff --git a/src/3rdparty/masm/disassembler/udis86/udis86_extern.h b/src/3rdparty/masm/disassembler/udis86/udis86_extern.h new file mode 100644 index 0000000000..8e87721e8c --- /dev/null +++ b/src/3rdparty/masm/disassembler/udis86/udis86_extern.h @@ -0,0 +1,88 @@ +/* udis86 - libudis86/extern.h + * + * Copyright (c) 2002-2009 Vivek Thampi + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +#ifndef UD_EXTERN_H +#define UD_EXTERN_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include "udis86_types.h" + +/* ============================= PUBLIC API ================================= */ + +extern void ud_init(struct ud*); + +extern void ud_set_mode(struct ud*, uint8_t); + +extern void ud_set_pc(struct ud*, uint64_t); + +extern void ud_set_input_hook(struct ud*, int (*)(struct ud*)); + +extern void ud_set_input_buffer(struct ud*, uint8_t*, size_t); + +#ifndef __UD_STANDALONE__ +extern void ud_set_input_file(struct ud*, FILE*); +#endif /* __UD_STANDALONE__ */ + +extern void ud_set_vendor(struct ud*, unsigned); + +extern void ud_set_syntax(struct ud*, void (*)(struct ud*)); + +extern void ud_input_skip(struct ud*, size_t); + +extern int ud_input_end(struct ud*); + +extern unsigned int ud_decode(struct ud*); + +extern unsigned int ud_disassemble(struct ud*); + +extern void ud_translate_intel(struct ud*); + +extern void ud_translate_att(struct ud*); + +extern char* ud_insn_asm(struct ud* u); + +extern uint8_t* ud_insn_ptr(struct ud* u); + +extern uint64_t ud_insn_off(struct ud*); + +extern char* ud_insn_hex(struct ud*); + +extern unsigned int ud_insn_len(struct ud* u); + +extern const char* ud_lookup_mnemonic(enum ud_mnemonic_code c); + +extern void ud_set_user_opaque_data(struct ud*, void*); + +extern void *ud_get_user_opaque_data(struct ud*); + +/* ========================================================================== */ + +#ifdef __cplusplus +} +#endif +#endif diff --git a/src/3rdparty/masm/disassembler/udis86/udis86_input.c b/src/3rdparty/masm/disassembler/udis86/udis86_input.c new file mode 100644 index 0000000000..76c6cccf36 --- /dev/null +++ b/src/3rdparty/masm/disassembler/udis86/udis86_input.c @@ -0,0 +1,263 @@ +/* udis86 - libudis86/input.c + * + * Copyright (c) 2002-2009 Vivek Thampi + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +#include "config.h" +#include + +#if USE(UDIS86) + +#include "udis86_extern.h" +#include "udis86_types.h" +#include "udis86_input.h" + +/* ----------------------------------------------------------------------------- + * inp_buff_hook() - Hook for buffered inputs. + * ----------------------------------------------------------------------------- + */ +static int +inp_buff_hook(struct ud* u) +{ + if (u->inp_buff < u->inp_buff_end) + return *u->inp_buff++; + else return -1; +} + +#ifndef __UD_STANDALONE__ +/* ----------------------------------------------------------------------------- + * inp_file_hook() - Hook for FILE inputs. + * ----------------------------------------------------------------------------- + */ +static int +inp_file_hook(struct ud* u) +{ + return fgetc(u->inp_file); +} +#endif /* __UD_STANDALONE__*/ + +/* ============================================================================= + * ud_inp_set_hook() - Sets input hook. + * ============================================================================= + */ +extern void +ud_set_input_hook(register struct ud* u, int (*hook)(struct ud*)) +{ + u->inp_hook = hook; + ud_inp_init(u); +} + +extern void +ud_set_user_opaque_data( struct ud * u, void * opaque ) +{ + u->user_opaque_data = opaque; +} + +extern void * +ud_get_user_opaque_data( struct ud * u ) +{ + return u->user_opaque_data; +} + +/* ============================================================================= + * ud_inp_set_buffer() - Set buffer as input. + * ============================================================================= + */ +extern void +ud_set_input_buffer(register struct ud* u, uint8_t* buf, size_t len) +{ + u->inp_hook = inp_buff_hook; + u->inp_buff = buf; + u->inp_buff_end = buf + len; + ud_inp_init(u); +} + +#ifndef __UD_STANDALONE__ +/* ============================================================================= + * ud_input_set_file() - Set buffer as input. + * ============================================================================= + */ +extern void +ud_set_input_file(register struct ud* u, FILE* f) +{ + u->inp_hook = inp_file_hook; + u->inp_file = f; + ud_inp_init(u); +} +#endif /* __UD_STANDALONE__ */ + +/* ============================================================================= + * ud_input_skip() - Skip n input bytes. + * ============================================================================= + */ +extern void +ud_input_skip(struct ud* u, size_t n) +{ + while (n--) { + u->inp_hook(u); + } +} + +/* ============================================================================= + * ud_input_end() - Test for end of input. + * ============================================================================= + */ +extern int +ud_input_end(struct ud* u) +{ + return (u->inp_curr == u->inp_fill) && u->inp_end; +} + +/* ----------------------------------------------------------------------------- + * ud_inp_next() - Loads and returns the next byte from input. + * + * inp_curr and inp_fill are pointers to the cache. The program is written based + * on the property that they are 8-bits in size, and will eventually wrap around + * forming a circular buffer. So, the size of the cache is 256 in size, kind of + * unnecessary yet optimized. + * + * A buffer inp_sess stores the bytes disassembled for a single session. + * ----------------------------------------------------------------------------- + */ +extern uint8_t ud_inp_next(struct ud* u) +{ + int c = -1; + /* if current pointer is not upto the fill point in the + * input cache. + */ + if ( u->inp_curr != u->inp_fill ) { + c = u->inp_cache[ ++u->inp_curr ]; + /* if !end-of-input, call the input hook and get a byte */ + } else if ( u->inp_end || ( c = u->inp_hook( u ) ) == -1 ) { + /* end-of-input, mark it as an error, since the decoder, + * expected a byte more. + */ + u->error = 1; + /* flag end of input */ + u->inp_end = 1; + return 0; + } else { + /* increment pointers, we have a new byte. */ + u->inp_curr = ++u->inp_fill; + /* add the byte to the cache */ + u->inp_cache[ u->inp_fill ] = c; + } + /* record bytes input per decode-session. */ + u->inp_sess[ u->inp_ctr++ ] = c; + /* return byte */ + return ( uint8_t ) c; +} + +/* ----------------------------------------------------------------------------- + * ud_inp_back() - Move back a single byte in the stream. + * ----------------------------------------------------------------------------- + */ +extern void +ud_inp_back(struct ud* u) +{ + if ( u->inp_ctr > 0 ) { + --u->inp_curr; + --u->inp_ctr; + } +} + +/* ----------------------------------------------------------------------------- + * ud_inp_peek() - Peek into the next byte in source. + * ----------------------------------------------------------------------------- + */ +extern uint8_t +ud_inp_peek(struct ud* u) +{ + uint8_t r = ud_inp_next(u); + if ( !u->error ) ud_inp_back(u); /* Don't backup if there was an error */ + return r; +} + +/* ----------------------------------------------------------------------------- + * ud_inp_move() - Move ahead n input bytes. + * ----------------------------------------------------------------------------- + */ +extern void +ud_inp_move(struct ud* u, size_t n) +{ + while (n--) + ud_inp_next(u); +} + +/*------------------------------------------------------------------------------ + * ud_inp_uintN() - return uintN from source. + *------------------------------------------------------------------------------ + */ +extern uint8_t +ud_inp_uint8(struct ud* u) +{ + return ud_inp_next(u); +} + +extern uint16_t +ud_inp_uint16(struct ud* u) +{ + uint16_t r, ret; + + ret = ud_inp_next(u); + r = ud_inp_next(u); + return ret | (r << 8); +} + +extern uint32_t +ud_inp_uint32(struct ud* u) +{ + uint32_t r, ret; + + ret = ud_inp_next(u); + r = ud_inp_next(u); + ret = ret | (r << 8); + r = ud_inp_next(u); + ret = ret | (r << 16); + r = ud_inp_next(u); + return ret | (r << 24); +} + +extern uint64_t +ud_inp_uint64(struct ud* u) +{ + uint64_t r, ret; + + ret = ud_inp_next(u); + r = ud_inp_next(u); + ret = ret | (r << 8); + r = ud_inp_next(u); + ret = ret | (r << 16); + r = ud_inp_next(u); + ret = ret | (r << 24); + r = ud_inp_next(u); + ret = ret | (r << 32); + r = ud_inp_next(u); + ret = ret | (r << 40); + r = ud_inp_next(u); + ret = ret | (r << 48); + r = ud_inp_next(u); + return ret | (r << 56); +} + +#endif // USE(UDIS86) diff --git a/src/3rdparty/masm/disassembler/udis86/udis86_input.h b/src/3rdparty/masm/disassembler/udis86/udis86_input.h new file mode 100644 index 0000000000..96865a88b5 --- /dev/null +++ b/src/3rdparty/masm/disassembler/udis86/udis86_input.h @@ -0,0 +1,67 @@ +/* udis86 - libudis86/input.h + * + * Copyright (c) 2002-2009 Vivek Thampi + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +#ifndef UD_INPUT_H +#define UD_INPUT_H + +#include "udis86_types.h" + +uint8_t ud_inp_next(struct ud*); +uint8_t ud_inp_peek(struct ud*); +uint8_t ud_inp_uint8(struct ud*); +uint16_t ud_inp_uint16(struct ud*); +uint32_t ud_inp_uint32(struct ud*); +uint64_t ud_inp_uint64(struct ud*); +void ud_inp_move(struct ud*, size_t); +void ud_inp_back(struct ud*); + +/* ud_inp_init() - Initializes the input system. */ +#define ud_inp_init(u) \ +do { \ + u->inp_curr = 0; \ + u->inp_fill = 0; \ + u->inp_ctr = 0; \ + u->inp_end = 0; \ +} while (0) + +/* ud_inp_start() - Should be called before each de-code operation. */ +#define ud_inp_start(u) u->inp_ctr = 0 + +/* ud_inp_back() - Resets the current pointer to its position before the current + * instruction disassembly was started. + */ +#define ud_inp_reset(u) \ +do { \ + u->inp_curr -= u->inp_ctr; \ + u->inp_ctr = 0; \ +} while (0) + +/* ud_inp_sess() - Returns the pointer to current session. */ +#define ud_inp_sess(u) (u->inp_sess) + +/* inp_cur() - Returns the current input byte. */ +#define ud_inp_curr(u) ((u)->inp_cache[(u)->inp_curr]) + +#endif diff --git a/src/3rdparty/masm/disassembler/udis86/udis86_itab_holder.c b/src/3rdparty/masm/disassembler/udis86/udis86_itab_holder.c new file mode 100644 index 0000000000..d5d8726d6a --- /dev/null +++ b/src/3rdparty/masm/disassembler/udis86/udis86_itab_holder.c @@ -0,0 +1,34 @@ +/* + * Copyright (C) 2012 Apple Inc. All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, + * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, + * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY + * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE + * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include + +#if USE(UDIS86) + +#include "udis86_itab.c" + +#endif + diff --git a/src/3rdparty/masm/disassembler/udis86/udis86_syn-att.c b/src/3rdparty/masm/disassembler/udis86/udis86_syn-att.c new file mode 100644 index 0000000000..155a34ca29 --- /dev/null +++ b/src/3rdparty/masm/disassembler/udis86/udis86_syn-att.c @@ -0,0 +1,253 @@ +/* udis86 - libudis86/syn-att.c + * + * Copyright (c) 2002-2009 Vivek Thampi + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +#include "config.h" +#include + +#if USE(UDIS86) + +#include "udis86_types.h" +#include "udis86_extern.h" +#include "udis86_decode.h" +#include "udis86_itab.h" +#include "udis86_syn.h" + +/* ----------------------------------------------------------------------------- + * opr_cast() - Prints an operand cast. + * ----------------------------------------------------------------------------- + */ +static void +opr_cast(struct ud* u, struct ud_operand* op) +{ + switch(op->size) { + case 16 : case 32 : + mkasm(u, "*"); break; + default: break; + } +} + +/* ----------------------------------------------------------------------------- + * gen_operand() - Generates assembly output for each operand. + * ----------------------------------------------------------------------------- + */ +static void +gen_operand(struct ud* u, struct ud_operand* op) +{ + switch(op->type) { + case UD_OP_REG: + mkasm(u, "%%%s", ud_reg_tab[op->base - UD_R_AL]); + break; + + case UD_OP_MEM: + if (u->br_far) opr_cast(u, op); + if (u->pfx_seg) + mkasm(u, "%%%s:", ud_reg_tab[u->pfx_seg - UD_R_AL]); + if (op->offset == 8) { + if (op->lval.sbyte < 0) + mkasm(u, "-0x%x", (-op->lval.sbyte) & 0xff); + else mkasm(u, "0x%x", op->lval.sbyte); + } + else if (op->offset == 16) + mkasm(u, "0x%x", op->lval.uword); + else if (op->offset == 32) + mkasm(u, "0x%lx", (unsigned long)op->lval.udword); + else if (op->offset == 64) + mkasm(u, "0x" FMT64 "x", op->lval.uqword); + + if (op->base) + mkasm(u, "(%%%s", ud_reg_tab[op->base - UD_R_AL]); + if (op->index) { + if (op->base) + mkasm(u, ","); + else mkasm(u, "("); + mkasm(u, "%%%s", ud_reg_tab[op->index - UD_R_AL]); + } + if (op->scale) + mkasm(u, ",%d", op->scale); + if (op->base || op->index) + mkasm(u, ")"); + break; + + case UD_OP_IMM: { + int64_t imm = 0; + uint64_t sext_mask = 0xffffffffffffffffull; + unsigned sext_size = op->size; + + switch (op->size) { + case 8: imm = op->lval.sbyte; break; + case 16: imm = op->lval.sword; break; + case 32: imm = op->lval.sdword; break; + case 64: imm = op->lval.sqword; break; + } + if ( P_SEXT( u->itab_entry->prefix ) ) { + sext_size = u->operand[ 0 ].size; + if ( u->mnemonic == UD_Ipush ) + /* push sign-extends to operand size */ + sext_size = u->opr_mode; + } + if ( sext_size < 64 ) + sext_mask = ( 1ull << sext_size ) - 1; + mkasm( u, "$0x" FMT64 "x", imm & sext_mask ); + + break; + } + + case UD_OP_JIMM: + switch (op->size) { + case 8: + mkasm(u, "0x" FMT64 "x", u->pc + op->lval.sbyte); + break; + case 16: + mkasm(u, "0x" FMT64 "x", (u->pc + op->lval.sword) & 0xffff ); + break; + case 32: + if (u->dis_mode == 32) + mkasm(u, "0x" FMT64 "x", (u->pc + op->lval.sdword) & 0xffffffff); + else + mkasm(u, "0x" FMT64 "x", u->pc + op->lval.sdword); + break; + default:break; + } + break; + + case UD_OP_PTR: + switch (op->size) { + case 32: + mkasm(u, "$0x%x, $0x%x", op->lval.ptr.seg, + op->lval.ptr.off & 0xFFFF); + break; + case 48: + mkasm(u, "$0x%x, $0x%lx", op->lval.ptr.seg, + (unsigned long)op->lval.ptr.off); + break; + } + break; + + default: return; + } +} + +/* ============================================================================= + * translates to AT&T syntax + * ============================================================================= + */ +extern void +ud_translate_att(struct ud *u) +{ + int size = 0; + + /* check if P_OSO prefix is used */ + if (! P_OSO(u->itab_entry->prefix) && u->pfx_opr) { + switch (u->dis_mode) { + case 16: + mkasm(u, "o32 "); + break; + case 32: + case 64: + mkasm(u, "o16 "); + break; + } + } + + /* check if P_ASO prefix was used */ + if (! P_ASO(u->itab_entry->prefix) && u->pfx_adr) { + switch (u->dis_mode) { + case 16: + mkasm(u, "a32 "); + break; + case 32: + mkasm(u, "a16 "); + break; + case 64: + mkasm(u, "a32 "); + break; + } + } + + if (u->pfx_lock) + mkasm(u, "lock "); + if (u->pfx_rep) + mkasm(u, "rep "); + if (u->pfx_repne) + mkasm(u, "repne "); + + /* special instructions */ + switch (u->mnemonic) { + case UD_Iretf: + mkasm(u, "lret "); + break; + case UD_Idb: + mkasm(u, ".byte 0x%x", u->operand[0].lval.ubyte); + return; + case UD_Ijmp: + case UD_Icall: + if (u->br_far) mkasm(u, "l"); + mkasm(u, "%s", ud_lookup_mnemonic(u->mnemonic)); + break; + case UD_Ibound: + case UD_Ienter: + if (u->operand[0].type != UD_NONE) + gen_operand(u, &u->operand[0]); + if (u->operand[1].type != UD_NONE) { + mkasm(u, ","); + gen_operand(u, &u->operand[1]); + } + return; + default: + mkasm(u, "%s", ud_lookup_mnemonic(u->mnemonic)); + } + + if (u->c1) + size = u->operand[0].size; + else if (u->c2) + size = u->operand[1].size; + else if (u->c3) + size = u->operand[2].size; + + if (size == 8) + mkasm(u, "b"); + else if (size == 16) + mkasm(u, "w"); + else if (size == 64) + mkasm(u, "q"); + + mkasm(u, " "); + + if (u->operand[2].type != UD_NONE) { + gen_operand(u, &u->operand[2]); + mkasm(u, ", "); + } + + if (u->operand[1].type != UD_NONE) { + gen_operand(u, &u->operand[1]); + mkasm(u, ", "); + } + + if (u->operand[0].type != UD_NONE) + gen_operand(u, &u->operand[0]); +} + +#endif // USE(UDIS86) + diff --git a/src/3rdparty/masm/disassembler/udis86/udis86_syn-intel.c b/src/3rdparty/masm/disassembler/udis86/udis86_syn-intel.c new file mode 100644 index 0000000000..d250bd449c --- /dev/null +++ b/src/3rdparty/masm/disassembler/udis86/udis86_syn-intel.c @@ -0,0 +1,279 @@ +/* udis86 - libudis86/syn-intel.c + * + * Copyright (c) 2002-2009 Vivek Thampi + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +#include "config.h" +#include + +#if USE(UDIS86) + +#include "udis86_types.h" +#include "udis86_extern.h" +#include "udis86_decode.h" +#include "udis86_itab.h" +#include "udis86_syn.h" + +/* ----------------------------------------------------------------------------- + * opr_cast() - Prints an operand cast. + * ----------------------------------------------------------------------------- + */ +static void +opr_cast(struct ud* u, struct ud_operand* op) +{ + switch(op->size) { + case 8: mkasm(u, "byte " ); break; + case 16: mkasm(u, "word " ); break; + case 32: mkasm(u, "dword "); break; + case 64: mkasm(u, "qword "); break; + case 80: mkasm(u, "tword "); break; + default: break; + } + if (u->br_far) + mkasm(u, "far "); +} + +/* ----------------------------------------------------------------------------- + * gen_operand() - Generates assembly output for each operand. + * ----------------------------------------------------------------------------- + */ +static void gen_operand(struct ud* u, struct ud_operand* op, int syn_cast) +{ + switch(op->type) { + case UD_OP_REG: + mkasm(u, "%s", ud_reg_tab[op->base - UD_R_AL]); + break; + + case UD_OP_MEM: { + + int op_f = 0; + + if (syn_cast) + opr_cast(u, op); + + mkasm(u, "["); + + if (u->pfx_seg) + mkasm(u, "%s:", ud_reg_tab[u->pfx_seg - UD_R_AL]); + + if (op->base) { + mkasm(u, "%s", ud_reg_tab[op->base - UD_R_AL]); + op_f = 1; + } + + if (op->index) { + if (op_f) + mkasm(u, "+"); + mkasm(u, "%s", ud_reg_tab[op->index - UD_R_AL]); + op_f = 1; + } + + if (op->scale) + mkasm(u, "*%d", op->scale); + + if (op->offset == 8) { + if (op->lval.sbyte < 0) + mkasm(u, "-0x%x", -op->lval.sbyte); + else mkasm(u, "%s0x%x", (op_f) ? "+" : "", op->lval.sbyte); + } + else if (op->offset == 16) + mkasm(u, "%s0x%x", (op_f) ? "+" : "", op->lval.uword); + else if (op->offset == 32) { + if (u->adr_mode == 64) { + if (op->lval.sdword < 0) + mkasm(u, "-0x%x", -op->lval.sdword); + else mkasm(u, "%s0x%x", (op_f) ? "+" : "", op->lval.sdword); + } + else mkasm(u, "%s0x%lx", (op_f) ? "+" : "", (unsigned long)op->lval.udword); + } + else if (op->offset == 64) + mkasm(u, "%s0x" FMT64 "x", (op_f) ? "+" : "", op->lval.uqword); + + mkasm(u, "]"); + break; + } + + case UD_OP_IMM: { + int64_t imm = 0; + uint64_t sext_mask = 0xffffffffffffffffull; + unsigned sext_size = op->size; + + if (syn_cast) + opr_cast(u, op); + switch (op->size) { + case 8: imm = op->lval.sbyte; break; + case 16: imm = op->lval.sword; break; + case 32: imm = op->lval.sdword; break; + case 64: imm = op->lval.sqword; break; + } + if ( P_SEXT( u->itab_entry->prefix ) ) { + sext_size = u->operand[ 0 ].size; + if ( u->mnemonic == UD_Ipush ) + /* push sign-extends to operand size */ + sext_size = u->opr_mode; + } + if ( sext_size < 64 ) + sext_mask = ( 1ull << sext_size ) - 1; + mkasm( u, "0x" FMT64 "x", imm & sext_mask ); + + break; + } + + + case UD_OP_JIMM: + if (syn_cast) opr_cast(u, op); + switch (op->size) { + case 8: + mkasm(u, "0x" FMT64 "x", u->pc + op->lval.sbyte); + break; + case 16: + mkasm(u, "0x" FMT64 "x", ( u->pc + op->lval.sword ) & 0xffff ); + break; + case 32: + mkasm(u, "0x" FMT64 "x", ( u->pc + op->lval.sdword ) & 0xfffffffful ); + break; + default:break; + } + break; + + case UD_OP_PTR: + switch (op->size) { + case 32: + mkasm(u, "word 0x%x:0x%x", op->lval.ptr.seg, + op->lval.ptr.off & 0xFFFF); + break; + case 48: + mkasm(u, "dword 0x%x:0x%lx", op->lval.ptr.seg, + (unsigned long)op->lval.ptr.off); + break; + } + break; + + case UD_OP_CONST: + if (syn_cast) opr_cast(u, op); + mkasm(u, "%d", op->lval.udword); + break; + + default: return; + } +} + +/* ============================================================================= + * translates to intel syntax + * ============================================================================= + */ +extern void ud_translate_intel(struct ud* u) +{ + /* -- prefixes -- */ + + /* check if P_OSO prefix is used */ + if (! P_OSO(u->itab_entry->prefix) && u->pfx_opr) { + switch (u->dis_mode) { + case 16: + mkasm(u, "o32 "); + break; + case 32: + case 64: + mkasm(u, "o16 "); + break; + } + } + + /* check if P_ASO prefix was used */ + if (! P_ASO(u->itab_entry->prefix) && u->pfx_adr) { + switch (u->dis_mode) { + case 16: + mkasm(u, "a32 "); + break; + case 32: + mkasm(u, "a16 "); + break; + case 64: + mkasm(u, "a32 "); + break; + } + } + + if ( u->pfx_seg && + u->operand[0].type != UD_OP_MEM && + u->operand[1].type != UD_OP_MEM ) { + mkasm(u, "%s ", ud_reg_tab[u->pfx_seg - UD_R_AL]); + } + if (u->pfx_lock) + mkasm(u, "lock "); + if (u->pfx_rep) + mkasm(u, "rep "); + if (u->pfx_repne) + mkasm(u, "repne "); + + /* print the instruction mnemonic */ + mkasm(u, "%s ", ud_lookup_mnemonic(u->mnemonic)); + + /* operand 1 */ + if (u->operand[0].type != UD_NONE) { + int cast = 0; + if ( u->operand[0].type == UD_OP_IMM && + u->operand[1].type == UD_NONE ) + cast = u->c1; + if ( u->operand[0].type == UD_OP_MEM ) { + cast = u->c1; + if ( u->operand[1].type == UD_OP_IMM || + u->operand[1].type == UD_OP_CONST ) + cast = 1; + if ( u->operand[1].type == UD_NONE ) + cast = 1; + if ( ( u->operand[0].size != u->operand[1].size ) && u->operand[1].size ) + cast = 1; + } else if ( u->operand[ 0 ].type == UD_OP_JIMM ) { + if ( u->operand[ 0 ].size > 8 ) cast = 1; + } + gen_operand(u, &u->operand[0], cast); + } + /* operand 2 */ + if (u->operand[1].type != UD_NONE) { + int cast = 0; + mkasm(u, ", "); + if ( u->operand[1].type == UD_OP_MEM ) { + cast = u->c1; + + if ( u->operand[0].type != UD_OP_REG ) + cast = 1; + if ( u->operand[0].size != u->operand[1].size && u->operand[1].size ) + cast = 1; + if ( u->operand[0].type == UD_OP_REG && + u->operand[0].base >= UD_R_ES && + u->operand[0].base <= UD_R_GS ) + cast = 0; + } + gen_operand(u, &u->operand[1], cast ); + } + + /* operand 3 */ + if (u->operand[2].type != UD_NONE) { + mkasm(u, ", "); + gen_operand(u, &u->operand[2], u->c3); + } +} + +#endif // USE(UDIS86) + diff --git a/src/3rdparty/masm/disassembler/udis86/udis86_syn.c b/src/3rdparty/masm/disassembler/udis86/udis86_syn.c new file mode 100644 index 0000000000..80391b4a08 --- /dev/null +++ b/src/3rdparty/masm/disassembler/udis86/udis86_syn.c @@ -0,0 +1,87 @@ +/* udis86 - libudis86/syn.c + * + * Copyright (c) 2002-2009 Vivek Thampi + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include "config.h" +#include + +#if USE(UDIS86) + +/* ----------------------------------------------------------------------------- + * Intel Register Table - Order Matters (types.h)! + * ----------------------------------------------------------------------------- + */ +const char* ud_reg_tab[] = +{ + "al", "cl", "dl", "bl", + "ah", "ch", "dh", "bh", + "spl", "bpl", "sil", "dil", + "r8b", "r9b", "r10b", "r11b", + "r12b", "r13b", "r14b", "r15b", + + "ax", "cx", "dx", "bx", + "sp", "bp", "si", "di", + "r8w", "r9w", "r10w", "r11w", + "r12w", "r13W" , "r14w", "r15w", + + "eax", "ecx", "edx", "ebx", + "esp", "ebp", "esi", "edi", + "r8d", "r9d", "r10d", "r11d", + "r12d", "r13d", "r14d", "r15d", + + "rax", "rcx", "rdx", "rbx", + "rsp", "rbp", "rsi", "rdi", + "r8", "r9", "r10", "r11", + "r12", "r13", "r14", "r15", + + "es", "cs", "ss", "ds", + "fs", "gs", + + "cr0", "cr1", "cr2", "cr3", + "cr4", "cr5", "cr6", "cr7", + "cr8", "cr9", "cr10", "cr11", + "cr12", "cr13", "cr14", "cr15", + + "dr0", "dr1", "dr2", "dr3", + "dr4", "dr5", "dr6", "dr7", + "dr8", "dr9", "dr10", "dr11", + "dr12", "dr13", "dr14", "dr15", + + "mm0", "mm1", "mm2", "mm3", + "mm4", "mm5", "mm6", "mm7", + + "st0", "st1", "st2", "st3", + "st4", "st5", "st6", "st7", + + "xmm0", "xmm1", "xmm2", "xmm3", + "xmm4", "xmm5", "xmm6", "xmm7", + "xmm8", "xmm9", "xmm10", "xmm11", + "xmm12", "xmm13", "xmm14", "xmm15", + + "rip" +}; + +#endif // USE(UDIS86) + diff --git a/src/3rdparty/masm/disassembler/udis86/udis86_syn.h b/src/3rdparty/masm/disassembler/udis86/udis86_syn.h new file mode 100644 index 0000000000..e8636163ef --- /dev/null +++ b/src/3rdparty/masm/disassembler/udis86/udis86_syn.h @@ -0,0 +1,47 @@ +/* udis86 - libudis86/syn.h + * + * Copyright (c) 2002-2009 + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +#ifndef UD_SYN_H +#define UD_SYN_H + +#include "udis86_types.h" +#include + +#ifndef __UD_STANDALONE__ +# include +#endif /* __UD_STANDALONE__ */ + +extern const char* ud_reg_tab[]; + +static void mkasm(struct ud* u, const char* fmt, ...) WTF_ATTRIBUTE_PRINTF(2, 3); +static void mkasm(struct ud* u, const char* fmt, ...) +{ + va_list ap; + va_start(ap, fmt); + u->insn_fill += vsnprintf((char*) u->insn_buffer + u->insn_fill, UD_STRING_BUFFER_SIZE - u->insn_fill, fmt, ap); + va_end(ap); +} + +#endif diff --git a/src/3rdparty/masm/disassembler/udis86/udis86_types.h b/src/3rdparty/masm/disassembler/udis86/udis86_types.h new file mode 100644 index 0000000000..320d1ca491 --- /dev/null +++ b/src/3rdparty/masm/disassembler/udis86/udis86_types.h @@ -0,0 +1,238 @@ +/* udis86 - libudis86/types.h + * + * Copyright (c) 2002-2009 Vivek Thampi + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without modification, + * are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR + * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + * ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ +#ifndef UD_TYPES_H +#define UD_TYPES_H + +#ifndef __UD_STANDALONE__ +# include +#endif /* __UD_STANDALONE__ */ + +/* gcc specific extensions */ +#ifdef __GNUC__ +# define UD_ATTR_PACKED __attribute__((packed)) +#else +# define UD_ATTR_PACKED +#endif /* UD_ATTR_PACKED */ + +#ifdef _MSC_VER +# define FMT64 "%I64" + typedef unsigned __int8 uint8_t; + typedef unsigned __int16 uint16_t; + typedef unsigned __int32 uint32_t; + typedef unsigned __int64 uint64_t; + typedef __int8 int8_t; + typedef __int16 int16_t; + typedef __int32 int32_t; + typedef __int64 int64_t; +#else +# define FMT64 "%ll" +# ifndef __UD_STANDALONE__ +# include +# endif /* __UD_STANDALONE__ */ +#endif + +/* ----------------------------------------------------------------------------- + * All possible "types" of objects in udis86. Order is Important! + * ----------------------------------------------------------------------------- + */ +enum ud_type +{ + UD_NONE, + + /* 8 bit GPRs */ + UD_R_AL, UD_R_CL, UD_R_DL, UD_R_BL, + UD_R_AH, UD_R_CH, UD_R_DH, UD_R_BH, + UD_R_SPL, UD_R_BPL, UD_R_SIL, UD_R_DIL, + UD_R_R8B, UD_R_R9B, UD_R_R10B, UD_R_R11B, + UD_R_R12B, UD_R_R13B, UD_R_R14B, UD_R_R15B, + + /* 16 bit GPRs */ + UD_R_AX, UD_R_CX, UD_R_DX, UD_R_BX, + UD_R_SP, UD_R_BP, UD_R_SI, UD_R_DI, + UD_R_R8W, UD_R_R9W, UD_R_R10W, UD_R_R11W, + UD_R_R12W, UD_R_R13W, UD_R_R14W, UD_R_R15W, + + /* 32 bit GPRs */ + UD_R_EAX, UD_R_ECX, UD_R_EDX, UD_R_EBX, + UD_R_ESP, UD_R_EBP, UD_R_ESI, UD_R_EDI, + UD_R_R8D, UD_R_R9D, UD_R_R10D, UD_R_R11D, + UD_R_R12D, UD_R_R13D, UD_R_R14D, UD_R_R15D, + + /* 64 bit GPRs */ + UD_R_RAX, UD_R_RCX, UD_R_RDX, UD_R_RBX, + UD_R_RSP, UD_R_RBP, UD_R_RSI, UD_R_RDI, + UD_R_R8, UD_R_R9, UD_R_R10, UD_R_R11, + UD_R_R12, UD_R_R13, UD_R_R14, UD_R_R15, + + /* segment registers */ + UD_R_ES, UD_R_CS, UD_R_SS, UD_R_DS, + UD_R_FS, UD_R_GS, + + /* control registers*/ + UD_R_CR0, UD_R_CR1, UD_R_CR2, UD_R_CR3, + UD_R_CR4, UD_R_CR5, UD_R_CR6, UD_R_CR7, + UD_R_CR8, UD_R_CR9, UD_R_CR10, UD_R_CR11, + UD_R_CR12, UD_R_CR13, UD_R_CR14, UD_R_CR15, + + /* debug registers */ + UD_R_DR0, UD_R_DR1, UD_R_DR2, UD_R_DR3, + UD_R_DR4, UD_R_DR5, UD_R_DR6, UD_R_DR7, + UD_R_DR8, UD_R_DR9, UD_R_DR10, UD_R_DR11, + UD_R_DR12, UD_R_DR13, UD_R_DR14, UD_R_DR15, + + /* mmx registers */ + UD_R_MM0, UD_R_MM1, UD_R_MM2, UD_R_MM3, + UD_R_MM4, UD_R_MM5, UD_R_MM6, UD_R_MM7, + + /* x87 registers */ + UD_R_ST0, UD_R_ST1, UD_R_ST2, UD_R_ST3, + UD_R_ST4, UD_R_ST5, UD_R_ST6, UD_R_ST7, + + /* extended multimedia registers */ + UD_R_XMM0, UD_R_XMM1, UD_R_XMM2, UD_R_XMM3, + UD_R_XMM4, UD_R_XMM5, UD_R_XMM6, UD_R_XMM7, + UD_R_XMM8, UD_R_XMM9, UD_R_XMM10, UD_R_XMM11, + UD_R_XMM12, UD_R_XMM13, UD_R_XMM14, UD_R_XMM15, + + UD_R_RIP, + + /* Operand Types */ + UD_OP_REG, UD_OP_MEM, UD_OP_PTR, UD_OP_IMM, + UD_OP_JIMM, UD_OP_CONST +}; + +#include "udis86_itab.h" + +/* ----------------------------------------------------------------------------- + * struct ud_operand - Disassembled instruction Operand. + * ----------------------------------------------------------------------------- + */ +struct ud_operand +{ + enum ud_type type; + uint8_t size; + union { + int8_t sbyte; + uint8_t ubyte; + int16_t sword; + uint16_t uword; + int32_t sdword; + uint32_t udword; + int64_t sqword; + uint64_t uqword; + + struct { + uint16_t seg; + uint32_t off; + } ptr; + } lval; + + enum ud_type base; + enum ud_type index; + uint8_t offset; + uint8_t scale; +}; + +#define UD_STRING_BUFFER_SIZE 64 + +/* ----------------------------------------------------------------------------- + * struct ud - The udis86 object. + * ----------------------------------------------------------------------------- + */ +struct ud +{ + int (*inp_hook) (struct ud*); + uint8_t inp_curr; + uint8_t inp_fill; +#ifndef __UD_STANDALONE__ + FILE* inp_file; +#endif + uint8_t inp_ctr; + uint8_t* inp_buff; + uint8_t* inp_buff_end; + uint8_t inp_end; + void (*translator)(struct ud*); + uint64_t insn_offset; + char insn_hexcode[32]; + char insn_buffer[UD_STRING_BUFFER_SIZE]; + unsigned int insn_fill; + uint8_t dis_mode; + uint64_t pc; + uint8_t vendor; + struct map_entry* mapen; + enum ud_mnemonic_code mnemonic; + struct ud_operand operand[3]; + uint8_t error; + uint8_t pfx_rex; + uint8_t pfx_seg; + uint8_t pfx_opr; + uint8_t pfx_adr; + uint8_t pfx_lock; + uint8_t pfx_rep; + uint8_t pfx_repe; + uint8_t pfx_repne; + uint8_t pfx_insn; + uint8_t default64; + uint8_t opr_mode; + uint8_t adr_mode; + uint8_t br_far; + uint8_t br_near; + uint8_t implicit_addr; + uint8_t c1; + uint8_t c2; + uint8_t c3; + uint8_t inp_cache[256]; + uint8_t inp_sess[64]; + uint8_t have_modrm; + uint8_t modrm; + void * user_opaque_data; + struct ud_itab_entry * itab_entry; + struct ud_lookup_table_list_entry *le; +}; + +/* ----------------------------------------------------------------------------- + * Type-definitions + * ----------------------------------------------------------------------------- + */ +typedef enum ud_type ud_type_t; +typedef enum ud_mnemonic_code ud_mnemonic_code_t; + +typedef struct ud ud_t; +typedef struct ud_operand ud_operand_t; + +#define UD_SYN_INTEL ud_translate_intel +#define UD_SYN_ATT ud_translate_att +#define UD_EOI -1 +#define UD_INP_CACHE_SZ 32 +#define UD_VENDOR_AMD 0 +#define UD_VENDOR_INTEL 1 +#define UD_VENDOR_ANY 2 + +#define bail_out(ud,error_code) longjmp( (ud)->bailout, error_code ) +#define try_decode(ud) if ( setjmp( (ud)->bailout ) == 0 ) +#define catch_error() else + +#endif -- cgit v1.2.3