-- This file is a modification of the code found at:
-- https://github.com/ab9rf/disasm86
--
-- The license is the BSD-3-Clause license
-- The modification includes support for SSE/SSE2 instructions.


{--
Copyright Kelly Kinkade (c) 2016

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.

    * Neither the name of Kelly Kinkade nor the names of other
      contributors may be used to endorse or promote products derived
      from this software without specific prior written permission.

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.
--}


module Disassembler.Disassembler
    (
          disassemble0
    ) where

import Base

import Data.Size
import Data.X86.Opcode
import Data.X86.Instruction
import Data.X86.Register

import Control.Monad (join)
import Control.Monad.Extra (whenM)
import Control.Monad.Trans.Class (lift)
import Control.Monad.Trans.State.Lazy
import Data.ByteString.Lazy (ByteString)
import Data.Word (Word64, Word32, Word16, Word8)
import Data.Int (Int64)
import Data.Bits
import Data.List (find)
import Data.Maybe (isJust, isNothing, fromJust, listToMaybe, mapMaybe, catMaybes, fromMaybe, maybeToList)
import Control.Applicative ( (<|>) )
import Data.Attoparsec.ByteString.Lazy hiding (take)

import qualified Data.Map.Lazy as Map
import qualified Data.ByteString.Lazy as B
import qualified Data.ByteString as BS
import qualified Data.Binary.Get as G
import Data.Attoparsec.ByteString.Lazy as A

import Data.Char (ord, toUpper)

import Debug.Trace

show_bytestring :: ByteString -> [Char]
show_bytestring = [Word8] -> [Char]
forall {a}. Integral a => [a] -> [Char]
showHex_list ([Word8] -> [Char])
-> (ByteString -> [Word8]) -> ByteString -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> [Word8]
B.unpack


disassemble0 :: Word64 -> ByteString -> Maybe (Instruction)
disassemble0 :: Word64 -> ByteString -> Maybe Instruction
disassemble0 Word64
a ByteString
s = 
  case Parser (ByteString, Instruction)
-> ByteString -> Result (ByteString, Instruction)
forall a. Parser a -> ByteString -> Result a
parse (Word64 -> Parser (ByteString, Instruction)
disassemble1 Word64
a) ByteString
s of 
    Fail ByteString
_ [[Char]]
_ [Char]
_   -> Maybe Instruction
forall a. Maybe a
Nothing  -- trace ("Fail@ " ++ showHex a ++ ": " ++ show_bytestring s) $ Nothing
    Done ByteString
r (ByteString
b,Instruction
i) -> -- trace ("Disassembled: " ++ show (i {inAddress = a, inSize = BS.length b})) $ 
                    Instruction -> Maybe Instruction
forall a. a -> Maybe a
Just (Instruction -> Maybe Instruction)
-> Instruction -> Maybe Instruction
forall a b. (a -> b) -> a -> b
$ Instruction
i {inAddress = a, inSize = BS.length b}


disassemble :: Word64 -> ByteString -> ([Instruction], ByteString)
disassemble :: Word64 -> ByteString -> ([Instruction], ByteString)
disassemble Word64
ofs ByteString
s = case (Parser (ByteString, Instruction)
-> ByteString -> Result (ByteString, Instruction)
forall a. Parser a -> ByteString -> Result a
parse (Word64 -> Parser (ByteString, Instruction)
disassemble1 Word64
ofs) ByteString
s) of
                    Fail ByteString
_ [[Char]]
_ [Char]
_   -> ([], ByteString
s)
                    Done ByteString
r (ByteString
b,Instruction
i) -> let l :: Word64
l = Int -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral (ByteString -> Int
BS.length ByteString
b)
                                        ([Instruction]
i',ByteString
r') = Word64 -> ByteString -> ([Instruction], ByteString)
disassemble (Word64
ofsWord64 -> Word64 -> Word64
forall a. Num a => a -> a -> a
+Word64
l) ByteString
r
                                      in (Instruction
iInstruction -> [Instruction] -> [Instruction]
forall a. a -> [a] -> [a]
:[Instruction]
i', ByteString
r')

disassemble1 :: Word64 -> Parser (BS.ByteString, Instruction)
disassemble1 :: Word64 -> Parser (ByteString, Instruction)
disassemble1 Word64
ofs = let st :: DisassemblerState
st = Word64 -> DisassemblerState
dsInitial Word64
ofs
                       res :: Parser Instruction
res = StateT DisassemblerState Parser Instruction
-> DisassemblerState -> Parser Instruction
forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m a
evalStateT StateT DisassemblerState Parser Instruction
disassemble1' DisassemblerState
st
                     in Parser Instruction -> Parser (ByteString, Instruction)
forall a. Parser a -> Parser (ByteString, a)
match Parser Instruction
res

type Disassembler a = StateT DisassemblerState Parser a

data DisassemblerState = DisassemblerState {
      DisassemblerState -> Word64
dsOffset :: Word64
    , DisassemblerState -> Bool
dsLock :: Bool
    , DisassemblerState -> Bool
dsRepNE :: Bool
    , DisassemblerState -> Bool
dsRep :: Bool
    , DisassemblerState -> Maybe SReg
dsSegOverride :: Maybe SReg
    , DisassemblerState -> Maybe Word8
dsRex :: Maybe Word8
    , DisassemblerState -> Bool
dsOpWidthOverride :: Bool
    , DisassemblerState -> Bool
dsAdWidthOverride :: Bool
    , DisassemblerState -> Int
dsOpWidth :: Int
    , DisassemblerState -> Int
dsAdWidth :: Int
    , DisassemblerState -> Maybe ModRM
dsModRM :: Maybe ModRM
    , DisassemblerState -> Maybe Operand
dsImmed :: Maybe Operand
    , DisassemblerState -> Maybe Operand
dsMoffset :: Maybe Operand
}

dsInitial :: Word64 -> DisassemblerState
dsInitial Word64
ofs = DisassemblerState { dsOffset :: Word64
dsOffset = Word64
ofs,
                                    dsLock :: Bool
dsLock = Bool
False, dsRepNE :: Bool
dsRepNE = Bool
False, dsRep :: Bool
dsRep = Bool
False,
                                    dsSegOverride :: Maybe SReg
dsSegOverride = Maybe SReg
forall a. Maybe a
Nothing,
                                    dsRex :: Maybe Word8
dsRex = Maybe Word8
forall a. Maybe a
Nothing,
                                    dsOpWidthOverride :: Bool
dsOpWidthOverride = Bool
False,
                                    dsAdWidthOverride :: Bool
dsAdWidthOverride = Bool
False,
                                    dsOpWidth :: Int
dsOpWidth = Int
32, dsAdWidth :: Int
dsAdWidth = Int
64,
                                    dsModRM :: Maybe ModRM
dsModRM = Maybe ModRM
forall a. Maybe a
Nothing, dsImmed :: Maybe Operand
dsImmed = Maybe Operand
forall a. Maybe a
Nothing, dsMoffset :: Maybe Operand
dsMoffset = Maybe Operand
forall a. Maybe a
Nothing
                                  }

adv :: Int -> Disassembler ()
adv :: Int -> Disassembler ()
adv Int
n = (DisassemblerState -> DisassemblerState) -> Disassembler ()
forall (m :: * -> *) s. Monad m => (s -> s) -> StateT s m ()
modify (\DisassemblerState
x -> DisassemblerState
x { dsOffset = (dsOffset x) + (fromIntegral n) })

mask :: Word8 -> Word8 -> Disassembler Word8
mask :: Word8 -> Word8 -> Disassembler Word8
mask Word8
m Word8
v = (Parser ByteString Word8 -> Disassembler Word8
forall (m :: * -> *) a.
Monad m =>
m a -> StateT DisassemblerState m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (Parser ByteString Word8 -> Disassembler Word8)
-> Parser ByteString Word8 -> Disassembler Word8
forall a b. (a -> b) -> a -> b
$ (Word8 -> Bool) -> Parser ByteString Word8
satisfy (\Word8
x -> (Word8
x Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
m) Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
v)) Disassembler Word8 -> Disassembler () -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Int -> Disassembler ()
adv Int
1

opcode :: Word8 -> Disassembler Word8
opcode :: Word8 -> Disassembler Word8
opcode Word8
v = (Parser ByteString Word8 -> Disassembler Word8
forall (m :: * -> *) a.
Monad m =>
m a -> StateT DisassemblerState m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (Parser ByteString Word8 -> Disassembler Word8)
-> Parser ByteString Word8 -> Disassembler Word8
forall a b. (a -> b) -> a -> b
$ Word8 -> Parser ByteString Word8
word8 Word8
v) Disassembler Word8 -> Disassembler () -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Int -> Disassembler ()
adv Int
1

disassemble1' :: Disassembler Instruction
disassemble1' :: StateT DisassemblerState Parser Instruction
disassemble1' = [StateT DisassemblerState Parser Instruction]
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a. Alternative f => [f a] -> f a
choice [
--            option () (many' segover >> pure ()) >> option () (mask 0xf1 0x40 >> pure()) >> opcode 0x90 >> instr "nop" []
            StateT DisassemblerState Parser Instruction
endbr64,
            StateT DisassemblerState Parser Instruction
general
          ]

endbr64 :: StateT DisassemblerState Parser Instruction
endbr64 = do
  ByteString
bs <- Int -> Disassembler ByteString
readBytes Int
4
  if ByteString -> [Word8]
B.unpack ByteString
bs [Word8] -> [Word8] -> Bool
forall a. Eq a => a -> a -> Bool
== [Word8
0xf3,Word8
0x0f,Word8
0x1e,Word8
0xfa] then -- TODO MOVE
    [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"endbr64" [] 
  else
    [Char] -> StateT DisassemblerState Parser Instruction
forall a. [Char] -> StateT DisassemblerState Parser a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"endbr64"

general :: StateT DisassemblerState Parser Instruction
general = do Disassembler () -> StateT DisassemblerState Parser [()]
forall (m :: * -> *) a. MonadPlus m => m a -> m [a]
many' ([Disassembler ()] -> Disassembler ()
forall (f :: * -> *) a. Alternative f => [f a] -> f a
choice [Disassembler ()
lockrep, Disassembler ()
segover, Disassembler ()
opsize, Disassembler ()
adsize])
             () -> Disassembler () -> Disassembler ()
forall (f :: * -> *) a. Alternative f => a -> f a -> f a
option () Disassembler ()
rex
             StateT DisassemblerState Parser Instruction
baseOpcode

lockrep :: Disassembler ()
lockrep :: Disassembler ()
lockrep = [Disassembler ()] -> Disassembler ()
forall (f :: * -> *) a. Alternative f => [f a] -> f a
choice [ Word8 -> Disassembler Word8
opcode Word8
0xf0 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (DisassemblerState -> DisassemblerState) -> Disassembler ()
forall (m :: * -> *) s. Monad m => (s -> s) -> StateT s m ()
modify (\DisassemblerState
x -> DisassemblerState
x { dsLock = True }),
                   Word8 -> Disassembler Word8
opcode Word8
0xf2 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (DisassemblerState -> DisassemblerState) -> Disassembler ()
forall (m :: * -> *) s. Monad m => (s -> s) -> StateT s m ()
modify (\DisassemblerState
x -> DisassemblerState
x { dsRepNE = True }),
                   Word8 -> Disassembler Word8
opcode Word8
0xf3 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (DisassemblerState -> DisassemblerState) -> Disassembler ()
forall (m :: * -> *) s. Monad m => (s -> s) -> StateT s m ()
modify (\DisassemblerState
x -> DisassemblerState
x { dsRep = True }) ]

segover :: Disassembler ()
segover :: Disassembler ()
segover = [Disassembler ()] -> Disassembler ()
forall (f :: * -> *) a. Alternative f => [f a] -> f a
choice [
                    Word8 -> Disassembler Word8
opcode Word8
0x2e Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (DisassemblerState -> DisassemblerState) -> Disassembler ()
forall (m :: * -> *) s. Monad m => (s -> s) -> StateT s m ()
modify (\DisassemblerState
x -> DisassemblerState
x { dsSegOverride = Just CS }),
                    Word8 -> Disassembler Word8
opcode Word8
0x36 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (DisassemblerState -> DisassemblerState) -> Disassembler ()
forall (m :: * -> *) s. Monad m => (s -> s) -> StateT s m ()
modify (\DisassemblerState
x -> DisassemblerState
x { dsSegOverride = Just SS }),
                    Word8 -> Disassembler Word8
opcode Word8
0x3e Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (DisassemblerState -> DisassemblerState) -> Disassembler ()
forall (m :: * -> *) s. Monad m => (s -> s) -> StateT s m ()
modify (\DisassemblerState
x -> DisassemblerState
x { dsSegOverride = Just DS }),
                    Word8 -> Disassembler Word8
opcode Word8
0x26 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (DisassemblerState -> DisassemblerState) -> Disassembler ()
forall (m :: * -> *) s. Monad m => (s -> s) -> StateT s m ()
modify (\DisassemblerState
x -> DisassemblerState
x { dsSegOverride = Just ES }),
                    Word8 -> Disassembler Word8
opcode Word8
0x64 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (DisassemblerState -> DisassemblerState) -> Disassembler ()
forall (m :: * -> *) s. Monad m => (s -> s) -> StateT s m ()
modify (\DisassemblerState
x -> DisassemblerState
x { dsSegOverride = Just FS }),
                    Word8 -> Disassembler Word8
opcode Word8
0x65 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (DisassemblerState -> DisassemblerState) -> Disassembler ()
forall (m :: * -> *) s. Monad m => (s -> s) -> StateT s m ()
modify (\DisassemblerState
x -> DisassemblerState
x { dsSegOverride = Just GS })
                  ]

opsize :: Disassembler ()
opsize :: Disassembler ()
opsize = Word8 -> Disassembler Word8
opcode Word8
0x66 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (DisassemblerState -> DisassemblerState) -> Disassembler ()
forall (m :: * -> *) s. Monad m => (s -> s) -> StateT s m ()
modify ( \DisassemblerState
x -> DisassemblerState
x { dsOpWidthOverride = True } )

adsize :: Disassembler ()
adsize :: Disassembler ()
adsize = Word8 -> Disassembler Word8
opcode Word8
0x67 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (DisassemblerState -> DisassemblerState) -> Disassembler ()
forall (m :: * -> *) s. Monad m => (s -> s) -> StateT s m ()
modify ( \DisassemblerState
x -> DisassemblerState
x { dsAdWidthOverride = True } )

rex :: Disassembler ()
rex :: Disassembler ()
rex = do Word8
o <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xf0 Word8
0x40
         (DisassemblerState -> DisassemblerState) -> Disassembler ()
forall (m :: * -> *) s. Monad m => (s -> s) -> StateT s m ()
modify (\DisassemblerState
st -> DisassemblerState
st { dsRex = Just o })
         () -> Disassembler ()
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()

baseOpcode :: Disassembler Instruction
baseOpcode :: StateT DisassemblerState Parser Instruction
baseOpcode = [StateT DisassemblerState Parser Instruction]
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a. Alternative f => [f a] -> f a
choice [
                [Char] -> StateT DisassemblerState Parser Instruction
forall a. [Char] -> StateT DisassemblerState Parser a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"dunsel"
-- 0x00
                , do Word8
i <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xc7 Word8
0x00; Disassembler ()
opWidthB; Disassembler ()
modrm; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr (Word8 -> [Char]
forall {a}. (Integral a, Bits a) => a -> [Char]
ext1A' Word8
i) [Disassembler Operand
modrm_rm, Disassembler Operand
modrm_reg]
                , do Word8
i <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xc7 Word8
0x01; Disassembler ()
opWidthW; Disassembler ()
modrm; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr (Word8 -> [Char]
forall {a}. (Integral a, Bits a) => a -> [Char]
ext1A' Word8
i) [Disassembler Operand
modrm_rm, Disassembler Operand
modrm_reg]
                , do Word8
i <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xc7 Word8
0x02; Disassembler ()
opWidthB; Disassembler ()
modrm; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr (Word8 -> [Char]
forall {a}. (Integral a, Bits a) => a -> [Char]
ext1A' Word8
i) [Disassembler Operand
modrm_reg, Disassembler Operand
modrm_rm]
                , do Word8
i <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xc7 Word8
0x03; Disassembler ()
opWidthW; Disassembler ()
modrm; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr (Word8 -> [Char]
forall {a}. (Integral a, Bits a) => a -> [Char]
ext1A' Word8
i) [Disassembler Operand
modrm_reg, Disassembler Operand
modrm_rm]
                , do Word8
i <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xc7 Word8
0x04; Disassembler ()
opWidthB;   Disassembler ()
imm; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr (Word8 -> [Char]
forall {a}. (Integral a, Bits a) => a -> [Char]
ext1A' Word8
i) [Disassembler Operand
accum, Disassembler Operand
immed]
                , do Word8
i <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xc7 Word8
0x05; Disassembler ()
opWidthW;   Disassembler ()
imm; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr (Word8 -> [Char]
forall {a}. (Integral a, Bits a) => a -> [Char]
ext1A' Word8
i) [Disassembler Operand
accum, Disassembler Operand
immed]
-- 0x40 (REX prefixes handled above)
-- 0x50
                , do Word8
r <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xf8 Word8
0x50; Int -> Int -> Disassembler ()
opWidthX' Int
64 Int
16; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"push" [Word8 -> (Int -> Int) -> Disassembler Operand
reg (Word8
r Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0x07) Int -> Int
forall a. a -> a
id]
                , do Word8
r <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xf8 Word8
0x58; Int -> Int -> Disassembler ()
opWidthX' Int
64 Int
16; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"pop" [Word8 -> (Int -> Int) -> Disassembler Operand
reg (Word8
r Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0x07) Int -> Int
forall a. a -> a
id]
-- 0x60
                , Word8 -> Disassembler Word8
opcode Word8
0x63 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthW Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"movsxd" [Disassembler Operand
modrm_reg, Int -> Disassembler ()
opWidthF Int
32 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0x68 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Int -> Disassembler ()
opWidthX' Int
32 Int
16 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
imm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"push" [Disassembler Operand
immed]
                , Word8 -> Disassembler Word8
opcode Word8
0x69 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthW Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
imm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"imul" [Disassembler Operand
modrm_reg, Disassembler Operand
modrm_rm, Disassembler Operand
immed]
                , Word8 -> Disassembler Word8
opcode Word8
0x6a Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthB Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
imm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"push" [Disassembler Operand
immed]
                , Word8 -> Disassembler Word8
opcode Word8
0x6b Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthW Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
immB Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"imul" [Disassembler Operand
modrm_reg, Disassembler Operand
modrm_rm, Disassembler Operand
immed]
                , Word8 -> Disassembler Word8
opcode Word8
0x6c Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"insb" []
                , Word8 -> Disassembler Word8
opcode Word8
0x6d Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {b}.
StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forkX ([Char] -> StateT DisassemblerState Parser Instruction
forall a. [Char] -> StateT DisassemblerState Parser a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"invalid") ([Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"insd" []) ([Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"insw" [])
                , Word8 -> Disassembler Word8
opcode Word8
0x6e Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"outsb" []
                , Word8 -> Disassembler Word8
opcode Word8
0x6f Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {b}.
StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forkX ([Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"outsq" []) ([Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"outsd" []) ([Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"outsw" [])
-- 0x70
                , do Word8
i <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xf0 Word8
0x70; Operand
d <- Disassembler Operand
displ; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr (Word8 -> [Char]
forall {a}. (Integral a, Bits a) => a -> [Char]
shortjmp Word8
i) [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Operand
d]
-- 0x80
                , do Word8 -> Disassembler Word8
opcode Word8
0x80; Disassembler ()
opWidthB; Disassembler ()
modrm; Word8
i <- Disassembler Word8
modopcode; Disassembler ()
imm; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr (Word8 -> [Char]
forall {a}. Integral a => a -> [Char]
ext1A Word8
i) [Disassembler Operand
modrm_rm, Disassembler Operand
immed]
                , do Word8 -> Disassembler Word8
opcode Word8
0x81; Disassembler ()
opWidthW; Disassembler ()
modrm; Word8
i <- Disassembler Word8
modopcode; Disassembler ()
imm; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr (Word8 -> [Char]
forall {a}. Integral a => a -> [Char]
ext1A Word8
i) [Disassembler Operand
modrm_rm, Disassembler Operand
immed]
                , do Word8 -> Disassembler Word8
opcode Word8
0x83; Disassembler ()
opWidthW; Disassembler ()
modrm; Word8
i <- Disassembler Word8
modopcode; Disassembler ()
immB; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr (Word8 -> [Char]
forall {a}. Integral a => a -> [Char]
ext1A Word8
i) [Disassembler Operand
modrm_rm, Disassembler Operand
immed]
                , Word8 -> Disassembler Word8
opcode Word8
0x84 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthB Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"test" [Disassembler Operand
modrm_rm, Disassembler Operand
modrm_reg]
                , Word8 -> Disassembler Word8
opcode Word8
0x85 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthW Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"test" [Disassembler Operand
modrm_rm, Disassembler Operand
modrm_reg]
                , Word8 -> Disassembler Word8
opcode Word8
0x86 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthB Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"xchg" [Disassembler Operand
modrm_rm, Disassembler Operand
modrm_reg]
                , Word8 -> Disassembler Word8
opcode Word8
0x87 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthW Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"xchg" [Disassembler Operand
modrm_rm, Disassembler Operand
modrm_reg]
                , Word8 -> Disassembler Word8
opcode Word8
0x88 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthB Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"mov" [Disassembler Operand
modrm_rm, Disassembler Operand
modrm_reg]
                , Word8 -> Disassembler Word8
opcode Word8
0x89 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthW Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"mov" [Disassembler Operand
modrm_rm, Disassembler Operand
modrm_reg]
                , Word8 -> Disassembler Word8
opcode Word8
0x8a Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthB Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"mov" [Disassembler Operand
modrm_reg, Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0x8b Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthW Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"mov" [Disassembler Operand
modrm_reg, Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0x8c Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Int -> Int -> Disassembler ()
opWidthX Int
32 Int
32 Int
16 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"mov" [Disassembler Operand
modrm_rm, Disassembler Operand
modrm_sreg] -- intel says otherwise
                , Word8 -> Disassembler Word8
opcode Word8
0x8e Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Int -> Int -> Disassembler ()
opWidthX Int
32 Int
32 Int
16 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"mov" [Disassembler Operand
modrm_sreg, Disassembler Operand
modrm_rm] -- intel says otherwise
                , Word8 -> Disassembler Word8
opcode Word8
0x8d Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthW Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opmodnot3 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"lea" [Disassembler Operand
modrm_reg, Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0x8f Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
0 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
64 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"pop" [Disassembler Operand
modrm_rm]
-- 0x90
                , Word8 -> Disassembler Word8
opcode Word8
0x90 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> StateT DisassemblerState Parser Instruction
nop
                , do Word8
r <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xf8 Word8
0x90; Disassembler ()
opWidthW; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"xchg" [Word8 -> (Int -> Int) -> Disassembler Operand
reg (Word8
r Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0x07) Int -> Int
forall a. a -> a
id, Disassembler Operand
accum]
                , Word8 -> Disassembler Word8
opcode Word8
0x98 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {b}.
StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forkX ([Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"cdqe" []) ([Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"cwde" []) ([Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"cbw" [])
                , Word8 -> Disassembler Word8
opcode Word8
0x99 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {b}.
StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forkX ([Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"cqo" [])  ([Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"cdq" [])  ([Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"cwd" [])
                , Word8 -> Disassembler Word8
opcode Word8
0x9b Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"wait" []
                , Word8 -> Disassembler Word8
opcode Word8
0x9c Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {b}.
StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forkX ([Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"pushfq" []) ([Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"pushfq" []) ([Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"pushfq" []) -- intel says otherwise
                , Word8 -> Disassembler Word8
opcode Word8
0x9d Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {b}.
StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forkX ([Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"popfq" []) ([Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"popfq" []) ([Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"popf" [])
                , Word8 -> Disassembler Word8
opcode Word8
0x9e Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"sahf" []
                , Word8 -> Disassembler Word8
opcode Word8
0x9f Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"lahf" []
-- 0xa0
                , Word8 -> Disassembler Word8
opcode Word8
0xa0 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthB Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
moffs Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"mov" [Disassembler Operand
accum, Disassembler Operand
moffset]
                , Word8 -> Disassembler Word8
opcode Word8
0xa1 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthW Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
moffs Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"mov" [Disassembler Operand
accum, Disassembler Operand
moffset]
                , Word8 -> Disassembler Word8
opcode Word8
0xa2 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthB Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
moffs Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"mov" [Disassembler Operand
moffset, Disassembler Operand
accum]
                , Word8 -> Disassembler Word8
opcode Word8
0xa3 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthW Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
moffs Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"mov" [Disassembler Operand
moffset, Disassembler Operand
accum]
                , Word8 -> Disassembler Word8
opcode Word8
0xa4 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"movsb" []
                , Word8 -> Disassembler Word8
opcode Word8
0xa5 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {b}.
StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forkX ([Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"movsq" []) ([Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"movsd" []) ([Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"movsw" [])
                , Word8 -> Disassembler Word8
opcode Word8
0xa6 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"cmpsb" []
                , Word8 -> Disassembler Word8
opcode Word8
0xa7 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {b}.
StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forkX ([Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"cmpsq" []) ([Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"cmpsd" []) ([Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"cmpsw" [])
                , Word8 -> Disassembler Word8
opcode Word8
0xa8 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthB Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
imm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"test" [Disassembler Operand
accum, Disassembler Operand
immed]
                , Word8 -> Disassembler Word8
opcode Word8
0xa9 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthW Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
imm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"test" [Disassembler Operand
accum, Disassembler Operand
immed]
                , Word8 -> Disassembler Word8
opcode Word8
0xaa Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"stosb" []
                , Word8 -> Disassembler Word8
opcode Word8
0xab Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {b}.
StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forkX ([Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"stosq" []) ([Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"stosd" []) ([Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"stosw" [])
                , Word8 -> Disassembler Word8
opcode Word8
0xac Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"lodsb" []
                , Word8 -> Disassembler Word8
opcode Word8
0xad Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {b}.
StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forkX ([Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"lodsq" []) ([Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"lodsd" []) ([Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"lodsw" [])
                , Word8 -> Disassembler Word8
opcode Word8
0xae Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"scasb" []
                , Word8 -> Disassembler Word8
opcode Word8
0xaf Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {b}.
StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forkX ([Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"scasq" []) ([Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"scasd" []) ([Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"scasw" [])
-- 0xb0
                , do Word8
r <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xf8 Word8
0xb0; Disassembler ()
opWidthB; Disassembler ()
immL; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"mov" [Word8 -> (Int -> Int) -> Disassembler Operand
reg (Word8
r Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0x07) Int -> Int
forall a. a -> a
id, Disassembler Operand
immed]
                , do Word8
r <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xf8 Word8
0xb8; Disassembler ()
opWidthW; Disassembler ()
immL; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"mov" [Word8 -> (Int -> Int) -> Disassembler Operand
reg (Word8
r Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0x07) Int -> Int
forall a. a -> a
id, Disassembler Operand
immed]
-- 0xc0
                , do Word8 -> Disassembler Word8
opcode Word8
0xc0; Disassembler ()
opWidthB; Disassembler ()
modrm; [Char]
i <- StateT DisassemblerState Parser [Char]
ext2A; Disassembler ()
immB; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
i [Disassembler Operand
modrm_rm, Disassembler Operand
immed]
                , do Word8 -> Disassembler Word8
opcode Word8
0xc1; Disassembler ()
opWidthW; Disassembler ()
modrm; [Char]
i <- StateT DisassemblerState Parser [Char]
ext2A; Disassembler ()
immB; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
i [Disassembler Operand
modrm_rm, Disassembler Operand
immed]
                , Word8 -> Disassembler Word8
opcode Word8
0xc2 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
immW Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"ret" [Disassembler Operand
immed]
                , Word8 -> Disassembler Word8
opcode Word8
0xc3 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"ret" []
                , Word8 -> Disassembler Word8
opcode Word8
0xc6 Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xf8 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
immB Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"xabort" [Disassembler Operand
immed]
                , Word8 -> Disassembler Word8
opcode Word8
0xc6 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
0 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthB Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
imm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"mov" [Disassembler Operand
modrm_rm, Disassembler Operand
immed]
                , Word8 -> Disassembler Word8
opcode Word8
0xc7 Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xf8 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
immB Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"xflush" [Disassembler Operand
immed]
                , Word8 -> Disassembler Word8
opcode Word8
0xc7 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
0 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthW Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
imm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"mov" [Disassembler Operand
modrm_rm, Disassembler Operand
immed]
                , do Word8 -> Disassembler Word8
opcode Word8
0xc8; Int -> Disassembler ()
opWidthF Int
16; Disassembler ()
imm; Word64
i <- Disassembler Word64
imm''; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"enter" [Disassembler Operand
immed, Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> Operand -> Disassembler Operand
forall a b. (a -> b) -> a -> b
$ Immediate -> Operand
Op_Imm (Immediate -> Operand) -> Immediate -> Operand
forall a b. (a -> b) -> a -> b
$ BitSize -> Word64 -> Immediate
Immediate (Int -> BitSize
BitSize Int
8) Word64
i]
                , Word8 -> Disassembler Word8
opcode Word8
0xc9 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"leave" []
                , Word8 -> Disassembler Word8
opcode Word8
0xca Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
16 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
imm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"retf" [Disassembler Operand
immed]
                , Word8 -> Disassembler Word8
opcode Word8
0xcb Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"retf" []
                , Word8 -> Disassembler Word8
opcode Word8
0xcc Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"int3" []
                , Word8 -> Disassembler Word8
opcode Word8
0xcd Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthB Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
imm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"int" [Disassembler Operand
immed]
                , Word8 -> Disassembler Word8
opcode Word8
0xcf Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {b}.
StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forkX ([Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"iretq" []) ([Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"iretd" []) ([Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"iretw" [])
-- 0xd0
                , do Word8 -> Disassembler Word8
opcode Word8
0xd0; Disassembler ()
opWidthB; Disassembler ()
modrm; [Char]
i <- StateT DisassemblerState Parser [Char]
ext2A; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
i [Disassembler Operand
modrm_rm, Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Int -> Operand
Op_Const Int
1)]
                , do Word8 -> Disassembler Word8
opcode Word8
0xd1; Disassembler ()
opWidthW; Disassembler ()
modrm; [Char]
i <- StateT DisassemblerState Parser [Char]
ext2A; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
i [Disassembler Operand
modrm_rm, Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Int -> Operand
Op_Const Int
1)]
                , do Word8 -> Disassembler Word8
opcode Word8
0xd2; Disassembler ()
opWidthB; Disassembler ()
modrm; [Char]
i <- StateT DisassemblerState Parser [Char]
ext2A; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
i [Disassembler Operand
modrm_rm, Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Register -> Operand
Op_Reg (GPR -> RegHalf -> Register
Reg8 GPR
RCX RegHalf
HalfL))]
                , do Word8 -> Disassembler Word8
opcode Word8
0xd3; Disassembler ()
opWidthW; Disassembler ()
modrm; [Char]
i <- StateT DisassemblerState Parser [Char]
ext2A; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
i [Disassembler Operand
modrm_rm, Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Register -> Operand
Op_Reg (GPR -> RegHalf -> Register
Reg8 GPR
RCX RegHalf
HalfL))]
                , Word8 -> Disassembler Word8
opcode Word8
0xd7 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"xlatb" []
-- fpu: 0xd8
                , StateT DisassemblerState Parser Instruction
fpu
-- 0xe0
                , do Word8 -> Disassembler Word8
opcode Word8
0xe0; Operand
d <- Disassembler Operand
displ; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"loopnz" [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Operand
d]
                , do Word8 -> Disassembler Word8
opcode Word8
0xe1; Operand
d <- Disassembler Operand
displ; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"loope" [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Operand
d]
                , do Word8 -> Disassembler Word8
opcode Word8
0xe2; Operand
d <- Disassembler Operand
displ; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"loop" [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Operand
d]
                , do Word8 -> Disassembler Word8
opcode Word8
0xe3; Operand
d <- Disassembler Operand
displ; StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {b}.
StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forkA ([Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"jrcxz" [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Operand
d]) ([Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"jecxz" [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Operand
d])
                , Word8 -> Disassembler Word8
opcode Word8
0xe4 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthB Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
immB Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"in" [Disassembler Operand
accum, Disassembler Operand
immed]
                , Word8 -> Disassembler Word8
opcode Word8
0xe5 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Int -> Disassembler ()
opWidthX' Int
32 Int
16 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
immB Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"in" [Disassembler Operand
accum, Disassembler Operand
immed]
                , Word8 -> Disassembler Word8
opcode Word8
0xe6 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthB Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
immB Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"out" [Disassembler Operand
immed, Disassembler Operand
accum]
                , Word8 -> Disassembler Word8
opcode Word8
0xe7 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Int -> Disassembler ()
opWidthX' Int
32 Int
16 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
immB Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"out" [Disassembler Operand
immed, Disassembler Operand
accum]
                , do Word8 -> Disassembler Word8
opcode Word8
0xe8; Operand
d <- Disassembler Operand
-> Disassembler Operand -> Disassembler Operand
forall {b}.
StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forkX' Disassembler Operand
displD Disassembler Operand
displW; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"call" [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Operand
d]
                , do Word8 -> Disassembler Word8
opcode Word8
0xe9; Operand
d <- Disassembler Operand
-> Disassembler Operand -> Disassembler Operand
forall {b}.
StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forkX' Disassembler Operand
displD Disassembler Operand
displW; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"jmp" [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Operand
d]
                , do Word8 -> Disassembler Word8
opcode Word8
0xeb; Operand
d <- Disassembler Operand
displ; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"jmp" [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Operand
d]
                , Word8 -> Disassembler Word8
opcode Word8
0xec Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthB Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"in" [Disassembler Operand
accum, Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Register -> Operand
Op_Reg (GPR -> Register
Reg16 GPR
RDX))]
                , Word8 -> Disassembler Word8
opcode Word8
0xed Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Int -> Disassembler ()
opWidthX' Int
32 Int
16 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"in" [Disassembler Operand
accum, Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Register -> Operand
Op_Reg (GPR -> Register
Reg16 GPR
RDX))]
                , Word8 -> Disassembler Word8
opcode Word8
0xee Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthB Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"out" [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Register -> Operand
Op_Reg (GPR -> Register
Reg16 GPR
RDX)), Disassembler Operand
accum]
                , Word8 -> Disassembler Word8
opcode Word8
0xef Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Int -> Disassembler ()
opWidthX' Int
32 Int
16 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"out" [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Register -> Operand
Op_Reg (GPR -> Register
Reg16 GPR
RDX)), Disassembler Operand
accum]
-- 0x0f, 0x40
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (do Word8
i <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xf0 Word8
0x40; Disassembler ()
opWidthW ; Disassembler ()
modrm; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr (Word8 -> [Char]
forall {a}. (Integral a, Bits a) => a -> [Char]
cmov Word8
i) [Disassembler Operand
modrm_reg, Disassembler Operand
modrm_rm])
-- 0x0f, 0x80
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (do Word8
i <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xf0 Word8
0x80; Operand
d <- Disassembler Operand
displD; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr (Word8 -> [Char]
forall {a}. (Integral a, Bits a) => a -> [Char]
shortjmp Word8
i) [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Operand
d])



-- 0xf0
                , Word8 -> Disassembler Word8
opcode Word8
0xf1 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"int1" [] -- not in intel spec
                , Word8 -> Disassembler Word8
opcode Word8
0xf4 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"hlt" []
                , Word8 -> Disassembler Word8
opcode Word8
0xf5 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"cmc" []
                , Word8 -> Disassembler Word8
opcode Word8
0xf6 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthB Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
0 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
imm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"test" [Disassembler Operand
modrm_rm, Disassembler Operand
immed]
                , Word8 -> Disassembler Word8
opcode Word8
0xf6 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthB Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
1 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
imm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"test" [Disassembler Operand
modrm_rm, Disassembler Operand
immed] -- not intel spec
                , Word8 -> Disassembler Word8
opcode Word8
0xf6 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthB Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
2 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"not" [Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0xf6 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthB Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
3 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"neg" [Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0xf6 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthB Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
4 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"mul" [Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0xf6 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthB Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
5 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"imul" [Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0xf6 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthB Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
6 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"div" [Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0xf6 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthB Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
7 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"idiv" [Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0xf7 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthW Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
0 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
imm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"test" [Disassembler Operand
modrm_rm, Disassembler Operand
immed]
                , Word8 -> Disassembler Word8
opcode Word8
0xf7 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthW Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
1 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
imm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"test" [Disassembler Operand
modrm_rm, Disassembler Operand
immed] -- not intel spec
                , Word8 -> Disassembler Word8
opcode Word8
0xf7 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthW Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
2 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"not" [Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0xf7 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthW Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
3 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"neg" [Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0xf7 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthW Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
4 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"mul" [Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0xf7 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthW Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
5 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"imul" [Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0xf7 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthW Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
6 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"div" [Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0xf7 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthW Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
7 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"idiv" [Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0xf8 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"clc" []
                , Word8 -> Disassembler Word8
opcode Word8
0xf9 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"stc" []
                , Word8 -> Disassembler Word8
opcode Word8
0xfa Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"cli" []
                , Word8 -> Disassembler Word8
opcode Word8
0xfb Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"sti" []
                , Word8 -> Disassembler Word8
opcode Word8
0xfc Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"cld" []
                , Word8 -> Disassembler Word8
opcode Word8
0xfd Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"std" []
                , Word8 -> Disassembler Word8
opcode Word8
0xfe Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthB Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
0 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"inc" [Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0xfe Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthB Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
1 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"dec" [Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0xff Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthW Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
0 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"inc" [Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0xff Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthW Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
1 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"dec" [Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0xff Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
64 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
2 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"call" [Operand -> Operand
Op_Near (Operand -> Operand)
-> Disassembler Operand -> Disassembler Operand
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0xff Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Int -> Disassembler ()
opWidthX' Int
32 Int
16 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
3 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"call" [Operand -> Operand
Op_Far (Operand -> Operand)
-> Disassembler Operand -> Disassembler Operand
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0xff Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
64 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
4 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"jmp" [Operand -> Operand
Op_Near (Operand -> Operand)
-> Disassembler Operand -> Disassembler Operand
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0xff Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
32 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
5 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"jmp" [Operand -> Operand
Op_Far (Operand -> Operand)
-> Disassembler Operand -> Disassembler Operand
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0xff Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
64 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
6 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"push" [Disassembler Operand
modrm_rm]

                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x00 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
0 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"sldt" [Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x00 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
1 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"str" [Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x00 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
2 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"lldt" [Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x00 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
3 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"ltr" [Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x00 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
4 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"verr" [Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x00 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
5 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"verw" [Disassembler Operand
modrm_rm]

                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x01 Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xc1 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"vmcall" []
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x01 Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xc2 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"vmlaunch" []
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x01 Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xc3 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"vmresume" []
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x01 Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xc4 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"vmxoff" []
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x01 Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xc8 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"monitor" []
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x01 Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xc9 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"mwait" []
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x01 Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xca Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"clac" []
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x01 Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xcb Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"stac" []
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x01 Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xcf Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"encls" []
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x01 Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xd0 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"xgetbv" []
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x01 Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xd1 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"xsetbv" []
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x01 Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xd4 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"vmfunc" []
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x01 Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xd5 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"xend" []
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x01 Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xd6 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"xtest" []
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x01 Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xd7 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"enclu" []

                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x0b Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"ud2" []

                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x90 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"seto" [Disassembler ()
opWidthB Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x91 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"setno" [Disassembler ()
opWidthB Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x92 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"setb" [Disassembler ()
opWidthB Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x93 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"setnb" [Disassembler ()
opWidthB Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x94 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"sete" [Disassembler ()
opWidthB Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x95 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"setne" [Disassembler ()
opWidthB Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x96 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"setbe" [Disassembler ()
opWidthB Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x97 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"setnbe" [Disassembler ()
opWidthB Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x98 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"sets" [Disassembler ()
opWidthB Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x99 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"setns" [Disassembler ()
opWidthB Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x9a Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"setp" [Disassembler ()
opWidthB Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x9b Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"setnp" [Disassembler ()
opWidthB Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x9c Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"setl" [Disassembler ()
opWidthB Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x9d Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"setnl" [Disassembler ()
opWidthB Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x9e Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"setle" [Disassembler ()
opWidthB Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x9f Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"setnle" [Disassembler ()
opWidthB Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_rm]

                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xa3 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthW Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"bt" [Disassembler Operand
modrm_rm, Disassembler Operand
modrm_reg]
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xab Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthW Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"bts" [Disassembler Operand
modrm_rm, Disassembler Operand
modrm_reg]
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xaf Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthW Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"imul" [Disassembler Operand
modrm_reg, Disassembler Operand
modrm_rm]


                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xba Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthW Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
4 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
immB Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"bt" [Disassembler Operand
modrm_rm, Disassembler Operand
immed]
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xba Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthW Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
5 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
immB Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"bts" [Disassembler Operand
modrm_rm, Disassembler Operand
immed]
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xba Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthW Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
6 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
immB Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"btr" [Disassembler Operand
modrm_rm, Disassembler Operand
immed]
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xba Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthW Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
7 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
immB Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"btc" [Disassembler Operand
modrm_rm, Disassembler Operand
immed]
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xbb Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthW Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"btc" [Disassembler Operand
modrm_rm, Disassembler Operand
modrm_reg]
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xbc Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthW Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"bsf" [Disassembler Operand
modrm_reg, Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xbd Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthW Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"bsr" [Disassembler Operand
modrm_reg, Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xbe Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"movsx" [Disassembler Operand
modrm_reg, Disassembler ()
opWidthB Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xbf Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"movsx" [Disassembler Operand
modrm_reg, Int -> Disassembler ()
opWidthF Int
16 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xb6 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"movzx" [Disassembler Operand
modrm_reg, Disassembler ()
opWidthB Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_rm]
                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xb7 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"movzx" [Disassembler Operand
modrm_reg, Int -> Disassembler ()
opWidthF Int
16 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_rm]

                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xc1 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opWidthW Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"xadd" [Disassembler Operand
modrm_rm, Disassembler Operand
modrm_reg]

                , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>  (do Word8
r <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xf8 Word8
0xc8; Disassembler ()
opWidthW ; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"bswap" [Word8 -> (Int -> Int) -> Disassembler Operand
reg (Word8
r Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0x07) Int -> Int
forall a. a -> a
id])

                , StateT DisassemblerState Parser Instruction
mmx_sse
                , StateT DisassemblerState Parser Instruction
nops


     ]
fpu :: StateT DisassemblerState Parser Instruction
fpu = [StateT DisassemblerState Parser Instruction]
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a. Alternative f => [f a] -> f a
choice [ [Char] -> StateT DisassemblerState Parser Instruction
forall a. [Char] -> StateT DisassemblerState Parser a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"dunsel"
            , do Word8 -> Disassembler Word8
opcode Word8
0xd8; Word8
r <- (Parser ByteString Word8 -> Disassembler Word8
forall (m :: * -> *) a.
Monad m =>
m a -> StateT DisassemblerState m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (Parser ByteString Word8 -> Disassembler Word8)
-> Parser ByteString Word8 -> Disassembler Word8
forall a b. (a -> b) -> a -> b
$ (Word8 -> Bool) -> Parser ByteString Word8
satisfy (Word8 -> Word8 -> Bool
forall a. Ord a => a -> a -> Bool
>=Word8
0xc0)); Int -> Disassembler ()
adv Int
1; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr (Word8 -> [Char]
forall {a}. Integral a => a -> [Char]
fpuD8 (Int -> Int -> Word8 -> Word8
forall a. (Integral a, Bits a) => Int -> Int -> a -> a
bits Int
3 Int
3 Word8
r)) [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Register -> Operand
Op_Reg (FPUReg -> Register
RegFPU FPUReg
ST0)), Word8 -> Disassembler Operand
freg (Word8
r Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
7)]
            , do Word8 -> Disassembler Word8
opcode Word8
0xd8; Disassembler ()
modrm; Disassembler ()
opmodnot3; Word8
i <- Disassembler Word8
modopcode; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr (Word8 -> [Char]
forall {a}. Integral a => a -> [Char]
fpuD8 Word8
i) [Disassembler Operand
modrm_rm]

            , do Word8 -> Disassembler Word8
opcode Word8
0xd9; Word8
r <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xf8 Word8
0xc0; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fld" [Word8 -> Disassembler Operand
freg (Word8
r Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
7)]
            , do Word8 -> Disassembler Word8
opcode Word8
0xd9; Word8
r <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xf8 Word8
0xc8; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fxch" [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Register -> Operand
Op_Reg (FPUReg -> Register
RegFPU FPUReg
ST0)), Word8 -> Disassembler Operand
freg (Word8
r Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
7)]
            , Word8 -> Disassembler Word8
opcode Word8
0xd9 Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xd0 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fnop" []
            , Word8 -> Disassembler Word8
opcode Word8
0xd9 Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xe0 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fchs" []
            , Word8 -> Disassembler Word8
opcode Word8
0xd9 Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xe1 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fabs" []
            , Word8 -> Disassembler Word8
opcode Word8
0xd9 Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xe4 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"ftst" []
            , Word8 -> Disassembler Word8
opcode Word8
0xd9 Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xe5 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fxam" []
            , Word8 -> Disassembler Word8
opcode Word8
0xd9 Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xf0 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"f2xm1" []
            , Word8 -> Disassembler Word8
opcode Word8
0xd9 Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xf1 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fyl2x" []
            , Word8 -> Disassembler Word8
opcode Word8
0xd9 Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xf2 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fptan" []
            , Word8 -> Disassembler Word8
opcode Word8
0xd9 Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xf3 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fpatan" []
            , Word8 -> Disassembler Word8
opcode Word8
0xd9 Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xf4 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fxtract" []
            , Word8 -> Disassembler Word8
opcode Word8
0xd9 Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xf5 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fprem1" []
            , Word8 -> Disassembler Word8
opcode Word8
0xd9 Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xf6 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fdecstp" []
            , Word8 -> Disassembler Word8
opcode Word8
0xd9 Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xf7 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fincstp" []
            , Word8 -> Disassembler Word8
opcode Word8
0xd9 Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xe8 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fld1" []
            , Word8 -> Disassembler Word8
opcode Word8
0xd9 Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xe9 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fldl2t" []
            , Word8 -> Disassembler Word8
opcode Word8
0xd9 Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xea Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fldl2e" []
            , Word8 -> Disassembler Word8
opcode Word8
0xd9 Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xeb Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fldpi" []
            , Word8 -> Disassembler Word8
opcode Word8
0xd9 Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xec Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fldlg2" []
            , Word8 -> Disassembler Word8
opcode Word8
0xd9 Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xed Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fldln2" []
            , Word8 -> Disassembler Word8
opcode Word8
0xd9 Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xee Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fldz" []
            , Word8 -> Disassembler Word8
opcode Word8
0xd9 Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xf8 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fprem" []
            , Word8 -> Disassembler Word8
opcode Word8
0xd9 Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xf9 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fyl2xp1" []
            , Word8 -> Disassembler Word8
opcode Word8
0xd9 Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xfa Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fsqrt" []
            , Word8 -> Disassembler Word8
opcode Word8
0xd9 Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xfb Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fsincos" []
            , Word8 -> Disassembler Word8
opcode Word8
0xd9 Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xfc Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"frndint" []
            , Word8 -> Disassembler Word8
opcode Word8
0xd9 Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xfd Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fscale" []
            , Word8 -> Disassembler Word8
opcode Word8
0xd9 Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xfe Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fsin" []
            , Word8 -> Disassembler Word8
opcode Word8
0xd9 Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xff Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fcos" []
            , Word8 -> Disassembler Word8
opcode Word8
0xd9 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opmodnot3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
0 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
32 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fld" [Disassembler Operand
modrm_rm]
            , Word8 -> Disassembler Word8
opcode Word8
0xd9 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opmodnot3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
2 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
32 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fst" [Disassembler Operand
modrm_rm]
            , Word8 -> Disassembler Word8
opcode Word8
0xd9 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opmodnot3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
32 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fstp" [Disassembler Operand
modrm_rm]
            , Word8 -> Disassembler Word8
opcode Word8
0xd9 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opmodnot3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
4 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
32 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fldenv" [Disassembler Operand
modrm_rm]
            , Word8 -> Disassembler Word8
opcode Word8
0xd9 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opmodnot3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
5 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
16 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fldcw" [Disassembler Operand
modrm_rm]
            , Word8 -> Disassembler Word8
opcode Word8
0xd9 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opmodnot3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
6 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
32 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fnstenv" [Disassembler Operand
modrm_rm]
            , Word8 -> Disassembler Word8
opcode Word8
0xd9 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opmodnot3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
7 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
16 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fnstcw" [Disassembler Operand
modrm_rm]

            , do Word8 -> Disassembler Word8
opcode Word8
0xda; Word8
r <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xf8 Word8
0xc0; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fcmovb" [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Register -> Operand
Op_Reg (FPUReg -> Register
RegFPU FPUReg
ST0)), Word8 -> Disassembler Operand
freg (Word8
r Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
7)]
            , do Word8 -> Disassembler Word8
opcode Word8
0xda; Word8
r <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xf8 Word8
0xc8; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fcmove" [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Register -> Operand
Op_Reg (FPUReg -> Register
RegFPU FPUReg
ST0)), Word8 -> Disassembler Operand
freg (Word8
r Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
7)]
            , do Word8 -> Disassembler Word8
opcode Word8
0xda; Word8
r <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xf8 Word8
0xd0; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fcmovbe" [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Register -> Operand
Op_Reg (FPUReg -> Register
RegFPU FPUReg
ST0)), Word8 -> Disassembler Operand
freg (Word8
r Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
7)]
            , do Word8 -> Disassembler Word8
opcode Word8
0xda; Word8
r <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xf8 Word8
0xd8; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fcmovu" [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Register -> Operand
Op_Reg (FPUReg -> Register
RegFPU FPUReg
ST0)), Word8 -> Disassembler Operand
freg (Word8
r Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
7)]
            , Word8 -> Disassembler Word8
opcode Word8
0xda Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xe9 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fucompp" []
            , Word8 -> Disassembler Word8
opcode Word8
0xda Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opmodnot3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
0 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
32 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fiadd" [Disassembler Operand
modrm_rm]
            , Word8 -> Disassembler Word8
opcode Word8
0xda Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opmodnot3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
1 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
32 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fimul" [Disassembler Operand
modrm_rm]
            , Word8 -> Disassembler Word8
opcode Word8
0xda Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opmodnot3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
2 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
32 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"ficom" [Disassembler Operand
modrm_rm]
            , Word8 -> Disassembler Word8
opcode Word8
0xda Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opmodnot3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
32 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"ficomp" [Disassembler Operand
modrm_rm]
            , Word8 -> Disassembler Word8
opcode Word8
0xda Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opmodnot3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
4 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
32 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fisub" [Disassembler Operand
modrm_rm]
            , Word8 -> Disassembler Word8
opcode Word8
0xda Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opmodnot3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
5 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
32 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fisubr" [Disassembler Operand
modrm_rm]
            , Word8 -> Disassembler Word8
opcode Word8
0xda Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opmodnot3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
6 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
32 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fidiv" [Disassembler Operand
modrm_rm]
            , Word8 -> Disassembler Word8
opcode Word8
0xda Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opmodnot3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
7 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
32 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fidivr" [Disassembler Operand
modrm_rm]

            , do Word8 -> Disassembler Word8
opcode Word8
0xdb; Word8
r <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xf8 Word8
0xc0; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fcmovnb" [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Register -> Operand
Op_Reg (FPUReg -> Register
RegFPU FPUReg
ST0)), Word8 -> Disassembler Operand
freg (Word8
r Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
7)]
            , do Word8 -> Disassembler Word8
opcode Word8
0xdb; Word8
r <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xf8 Word8
0xc8; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fcmovne" [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Register -> Operand
Op_Reg (FPUReg -> Register
RegFPU FPUReg
ST0)), Word8 -> Disassembler Operand
freg (Word8
r Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
7)]
            , do Word8 -> Disassembler Word8
opcode Word8
0xdb; Word8
r <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xf8 Word8
0xd0; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fcmovnbe" [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Register -> Operand
Op_Reg (FPUReg -> Register
RegFPU FPUReg
ST0)), Word8 -> Disassembler Operand
freg (Word8
r Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
7)]
            , do Word8 -> Disassembler Word8
opcode Word8
0xdb; Word8
r <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xf8 Word8
0xd8; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fcmovnu" [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Register -> Operand
Op_Reg (FPUReg -> Register
RegFPU FPUReg
ST0)), Word8 -> Disassembler Operand
freg (Word8
r Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
7)]
            , do Word8 -> Disassembler Word8
opcode Word8
0xdb; Word8
r <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xf8 Word8
0xe8; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fucomi" [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Register -> Operand
Op_Reg (FPUReg -> Register
RegFPU FPUReg
ST0)), Word8 -> Disassembler Operand
freg (Word8
r Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
7)]
            , do Word8 -> Disassembler Word8
opcode Word8
0xdb; Word8
r <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xf8 Word8
0xf0; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fcomi" [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Register -> Operand
Op_Reg (FPUReg -> Register
RegFPU FPUReg
ST0)), Word8 -> Disassembler Operand
freg (Word8
r Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
7)]
            , Word8 -> Disassembler Word8
opcode Word8
0xdb Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xe2 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fclex" []
            , Word8 -> Disassembler Word8
opcode Word8
0xdb Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xe3 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"finit" []
            , Word8 -> Disassembler Word8
opcode Word8
0xdb Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opmodnot3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
0 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
32 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fild" [Disassembler Operand
modrm_rm]
            , Word8 -> Disassembler Word8
opcode Word8
0xdb Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opmodnot3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
1 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
32 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fisttp" [Disassembler Operand
modrm_rm]
            , Word8 -> Disassembler Word8
opcode Word8
0xdb Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opmodnot3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
2 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
32 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fist" [Disassembler Operand
modrm_rm]
            , Word8 -> Disassembler Word8
opcode Word8
0xdb Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opmodnot3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
32 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fistp" [Disassembler Operand
modrm_rm]
            , Word8 -> Disassembler Word8
opcode Word8
0xdb Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opmodnot3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
5 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
80 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fld" [Disassembler Operand
modrm_rm]
            , Word8 -> Disassembler Word8
opcode Word8
0xdb Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opmodnot3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
7 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
80 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fstp" [Disassembler Operand
modrm_rm]

            , do Word8 -> Disassembler Word8
opcode Word8
0xdc; Word8
r <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xf8 Word8
0xc0; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fadd" [Word8 -> Disassembler Operand
freg (Word8
r Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
7), Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Register -> Operand
Op_Reg (FPUReg -> Register
RegFPU FPUReg
ST0))]
            , do Word8 -> Disassembler Word8
opcode Word8
0xdc; Word8
r <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xf8 Word8
0xc8; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fmul" [Word8 -> Disassembler Operand
freg (Word8
r Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
7), Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Register -> Operand
Op_Reg (FPUReg -> Register
RegFPU FPUReg
ST0))]
            , do Word8 -> Disassembler Word8
opcode Word8
0xdc; Word8
r <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xf8 Word8
0xd0; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fcom2" [Word8 -> Disassembler Operand
freg (Word8
r Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
7), Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Register -> Operand
Op_Reg (FPUReg -> Register
RegFPU FPUReg
ST0))] -- not in intel spec
            , do Word8 -> Disassembler Word8
opcode Word8
0xdc; Word8
r <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xf8 Word8
0xe0; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fsubr" [Word8 -> Disassembler Operand
freg (Word8
r Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
7), Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Register -> Operand
Op_Reg (FPUReg -> Register
RegFPU FPUReg
ST0))]
            , do Word8 -> Disassembler Word8
opcode Word8
0xdc; Word8
r <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xf8 Word8
0xe8; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fsub" [Word8 -> Disassembler Operand
freg (Word8
r Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
7), Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Register -> Operand
Op_Reg (FPUReg -> Register
RegFPU FPUReg
ST0))]
            , do Word8 -> Disassembler Word8
opcode Word8
0xdc; Word8
r <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xf8 Word8
0xf0; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fdivr" [Word8 -> Disassembler Operand
freg (Word8
r Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
7), Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Register -> Operand
Op_Reg (FPUReg -> Register
RegFPU FPUReg
ST0))]
            , do Word8 -> Disassembler Word8
opcode Word8
0xdc; Word8
r <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xf8 Word8
0xf8; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fdiv" [Word8 -> Disassembler Operand
freg (Word8
r Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
7), Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Register -> Operand
Op_Reg (FPUReg -> Register
RegFPU FPUReg
ST0))]
            , do Word8 -> Disassembler Word8
opcode Word8
0xdc; Disassembler ()
modrm; Disassembler ()
opmodnot3; Word8
i <- Disassembler Word8
modopcode; Int -> Disassembler ()
opWidthF Int
64 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr (Word8 -> [Char]
forall {a}. Integral a => a -> [Char]
fpuD8 Word8
i) [Disassembler Operand
modrm_rm]

            , do Word8 -> Disassembler Word8
opcode Word8
0xdd; Word8
r <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xf8 Word8
0xc0; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"ffree" [Word8 -> Disassembler Operand
freg (Word8
r Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
7)]
            , do Word8 -> Disassembler Word8
opcode Word8
0xdd; Word8
r <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xf8 Word8
0xd0; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fst" [Word8 -> Disassembler Operand
freg (Word8
r Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
7)]
            , do Word8 -> Disassembler Word8
opcode Word8
0xdd; Word8
r <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xf8 Word8
0xd8; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fstp" [Word8 -> Disassembler Operand
freg (Word8
r Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
7)]
            , do Word8 -> Disassembler Word8
opcode Word8
0xdd; Word8
r <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xf8 Word8
0xe0; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fucom" [Word8 -> Disassembler Operand
freg (Word8
r Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
7), Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Register -> Operand
Op_Reg (FPUReg -> Register
RegFPU FPUReg
ST0))]
            , do Word8 -> Disassembler Word8
opcode Word8
0xdd; Word8
r <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xf8 Word8
0xe8; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fucomp" [Word8 -> Disassembler Operand
freg (Word8
r Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
7)]
            , Word8 -> Disassembler Word8
opcode Word8
0xdd Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opmodnot3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
0 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
64 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fld" [Disassembler Operand
modrm_rm]
            , Word8 -> Disassembler Word8
opcode Word8
0xdd Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opmodnot3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
1 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
64 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fisttp" [Disassembler Operand
modrm_rm]
            , Word8 -> Disassembler Word8
opcode Word8
0xdd Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opmodnot3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
2 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
64 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fst" [Disassembler Operand
modrm_rm]
            , Word8 -> Disassembler Word8
opcode Word8
0xdd Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opmodnot3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
64 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fstp" [Disassembler Operand
modrm_rm]
            , Word8 -> Disassembler Word8
opcode Word8
0xdd Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opmodnot3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
4 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
64 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"frstor" [Disassembler Operand
modrm_rm]
            , Word8 -> Disassembler Word8
opcode Word8
0xdd Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opmodnot3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
6 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
64 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fnsave" [Disassembler Operand
modrm_rm]
            , Word8 -> Disassembler Word8
opcode Word8
0xdd Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opmodnot3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
7 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
16 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fnstsw" [Disassembler Operand
modrm_rm]

            , do Word8 -> Disassembler Word8
opcode Word8
0xde; Word8
r <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xf8 Word8
0xc0; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"faddp" [Word8 -> Disassembler Operand
freg (Word8
r Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
7), Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Register -> Operand
Op_Reg (FPUReg -> Register
RegFPU FPUReg
ST0))]
            , do Word8 -> Disassembler Word8
opcode Word8
0xde; Word8
r <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xf8 Word8
0xc8; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fmulp" [Word8 -> Disassembler Operand
freg (Word8
r Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
7), Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Register -> Operand
Op_Reg (FPUReg -> Register
RegFPU FPUReg
ST0))]
            , do Word8 -> Disassembler Word8
opcode Word8
0xde; Word8
r <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xf8 Word8
0xe0; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fsubrp" [Word8 -> Disassembler Operand
freg (Word8
r Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
7), Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Register -> Operand
Op_Reg (FPUReg -> Register
RegFPU FPUReg
ST0))]
            , do Word8 -> Disassembler Word8
opcode Word8
0xde; Word8
r <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xf8 Word8
0xe8; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fsubp" [Word8 -> Disassembler Operand
freg (Word8
r Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
7), Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Register -> Operand
Op_Reg (FPUReg -> Register
RegFPU FPUReg
ST0))]
            , do Word8 -> Disassembler Word8
opcode Word8
0xde; Word8
r <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xf8 Word8
0xf0; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fdivrp" [Word8 -> Disassembler Operand
freg (Word8
r Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
7), Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Register -> Operand
Op_Reg (FPUReg -> Register
RegFPU FPUReg
ST0))]
            , do Word8 -> Disassembler Word8
opcode Word8
0xde; Word8
r <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xf8 Word8
0xf8; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fdivp" [Word8 -> Disassembler Operand
freg (Word8
r Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
7), Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Register -> Operand
Op_Reg (FPUReg -> Register
RegFPU FPUReg
ST0))]
            , Word8 -> Disassembler Word8
opcode Word8
0xde Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xd9 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fcompp" []
            , Word8 -> Disassembler Word8
opcode Word8
0xde Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opmodnot3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
0 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
16 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fiadd" [Disassembler Operand
modrm_rm]
            , Word8 -> Disassembler Word8
opcode Word8
0xde Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opmodnot3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
1 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
16 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fimul" [Disassembler Operand
modrm_rm]
            , Word8 -> Disassembler Word8
opcode Word8
0xde Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opmodnot3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
2 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
16 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"ficom" [Disassembler Operand
modrm_rm]
            , Word8 -> Disassembler Word8
opcode Word8
0xde Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opmodnot3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
16 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"ficomp" [Disassembler Operand
modrm_rm]
            , Word8 -> Disassembler Word8
opcode Word8
0xde Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opmodnot3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
4 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
16 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fisub" [Disassembler Operand
modrm_rm]
            , Word8 -> Disassembler Word8
opcode Word8
0xde Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opmodnot3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
5 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
16 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fisubr" [Disassembler Operand
modrm_rm]
            , Word8 -> Disassembler Word8
opcode Word8
0xde Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opmodnot3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
6 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
16 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fidiv" [Disassembler Operand
modrm_rm]
            , Word8 -> Disassembler Word8
opcode Word8
0xde Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opmodnot3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
7 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
16 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fidivr" [Disassembler Operand
modrm_rm]

            , Word8 -> Disassembler Word8
opcode Word8
0xdf Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xe0 Disassembler Word8
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fnstsw" [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Register -> Operand
Op_Reg (GPR -> Register
Reg16 GPR
RAX))]
            , do Word8 -> Disassembler Word8
opcode Word8
0xdf; Word8
r <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xf8 Word8
0xe8; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fucomip" [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Register -> Operand
Op_Reg (FPUReg -> Register
RegFPU FPUReg
ST0)), Word8 -> Disassembler Operand
freg (Word8
r Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
7)]
            , do Word8 -> Disassembler Word8
opcode Word8
0xdf; Word8
r <- Word8 -> Word8 -> Disassembler Word8
mask Word8
0xf8 Word8
0xf0; [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fcomip" [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Register -> Operand
Op_Reg (FPUReg -> Register
RegFPU FPUReg
ST0)), Word8 -> Disassembler Operand
freg (Word8
r Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
7)]
            , Word8 -> Disassembler Word8
opcode Word8
0xdf Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opmodnot3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
0 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
16 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fild" [Disassembler Operand
modrm_rm]
            , Word8 -> Disassembler Word8
opcode Word8
0xdf Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opmodnot3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
1 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
16 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fisttp" [Disassembler Operand
modrm_rm]
            , Word8 -> Disassembler Word8
opcode Word8
0xdf Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opmodnot3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
2 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
16 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fist" [Disassembler Operand
modrm_rm]
            , Word8 -> Disassembler Word8
opcode Word8
0xdf Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opmodnot3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
16 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fistp" [Disassembler Operand
modrm_rm]
            , Word8 -> Disassembler Word8
opcode Word8
0xdf Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opmodnot3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
4 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
16 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fbld" [Disassembler Operand
modrm_rm]
            , Word8 -> Disassembler Word8
opcode Word8
0xdf Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opmodnot3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
5 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
16 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fild" [Disassembler Operand
modrm_rm]
            , Word8 -> Disassembler Word8
opcode Word8
0xdf Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opmodnot3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
6 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
16 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fbstp" [Disassembler Operand
modrm_rm]
            , Word8 -> Disassembler Word8
opcode Word8
0xdf Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
opmodnot3 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler ()
opcodeMatch Word8
7 Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
16 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"fistp" [Disassembler Operand
modrm_rm]
            ]



prefixSet :: Int -> Disassembler ()
prefixSet :: Int -> Disassembler ()
prefixSet Int
0xf0 = StateT DisassemblerState Parser Bool
-> Disassembler () -> Disassembler ()
forall (m :: * -> *). Monad m => m Bool -> m () -> m ()
whenM (Bool -> Bool
not (Bool -> Bool)
-> StateT DisassemblerState Parser Bool
-> StateT DisassemblerState Parser Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (DisassemblerState -> Bool) -> StateT DisassemblerState Parser Bool
forall (m :: * -> *) s a. Monad m => (s -> a) -> StateT s m a
gets DisassemblerState -> Bool
dsLock) (Disassembler () -> Disassembler ())
-> Disassembler () -> Disassembler ()
forall a b. (a -> b) -> a -> b
$ [Char] -> Disassembler ()
forall a. [Char] -> StateT DisassemblerState Parser a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"prefixNotSet"
prefixSet Int
0xf2 = StateT DisassemblerState Parser Bool
-> Disassembler () -> Disassembler ()
forall (m :: * -> *). Monad m => m Bool -> m () -> m ()
whenM (Bool -> Bool
not (Bool -> Bool)
-> StateT DisassemblerState Parser Bool
-> StateT DisassemblerState Parser Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (DisassemblerState -> Bool) -> StateT DisassemblerState Parser Bool
forall (m :: * -> *) s a. Monad m => (s -> a) -> StateT s m a
gets DisassemblerState -> Bool
dsRepNE) (Disassembler () -> Disassembler ())
-> Disassembler () -> Disassembler ()
forall a b. (a -> b) -> a -> b
$ [Char] -> Disassembler ()
forall a. [Char] -> StateT DisassemblerState Parser a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"prefixNotSet"
prefixSet Int
0xf3 = StateT DisassemblerState Parser Bool
-> Disassembler () -> Disassembler ()
forall (m :: * -> *). Monad m => m Bool -> m () -> m ()
whenM (Bool -> Bool
not (Bool -> Bool)
-> StateT DisassemblerState Parser Bool
-> StateT DisassemblerState Parser Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (DisassemblerState -> Bool) -> StateT DisassemblerState Parser Bool
forall (m :: * -> *) s a. Monad m => (s -> a) -> StateT s m a
gets DisassemblerState -> Bool
dsRep) (Disassembler () -> Disassembler ())
-> Disassembler () -> Disassembler ()
forall a b. (a -> b) -> a -> b
$ [Char] -> Disassembler ()
forall a. [Char] -> StateT DisassemblerState Parser a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"prefixNotSet"
prefixSet Int
0x66 = StateT DisassemblerState Parser Bool
-> Disassembler () -> Disassembler ()
forall (m :: * -> *). Monad m => m Bool -> m () -> m ()
whenM (Bool -> Bool
not (Bool -> Bool)
-> StateT DisassemblerState Parser Bool
-> StateT DisassemblerState Parser Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (DisassemblerState -> Bool) -> StateT DisassemblerState Parser Bool
forall (m :: * -> *) s a. Monad m => (s -> a) -> StateT s m a
gets DisassemblerState -> Bool
dsOpWidthOverride) (Disassembler () -> Disassembler ())
-> Disassembler () -> Disassembler ()
forall a b. (a -> b) -> a -> b
$ [Char] -> Disassembler ()
forall a. [Char] -> StateT DisassemblerState Parser a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"prefixNotSet"
prefixSet Int
0x67 = StateT DisassemblerState Parser Bool
-> Disassembler () -> Disassembler ()
forall (m :: * -> *). Monad m => m Bool -> m () -> m ()
whenM (Bool -> Bool
not (Bool -> Bool)
-> StateT DisassemblerState Parser Bool
-> StateT DisassemblerState Parser Bool
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (DisassemblerState -> Bool) -> StateT DisassemblerState Parser Bool
forall (m :: * -> *) s a. Monad m => (s -> a) -> StateT s m a
gets DisassemblerState -> Bool
dsAdWidthOverride) (Disassembler () -> Disassembler ())
-> Disassembler () -> Disassembler ()
forall a b. (a -> b) -> a -> b
$ [Char] -> Disassembler ()
forall a. [Char] -> StateT DisassemblerState Parser a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"prefixNotSet"
prefixSet Int
_    = [Char] -> Disassembler ()
forall a. [Char] -> StateT DisassemblerState Parser a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"prefixSet"
  
noPrefix :: Instruction -> Instruction
noPrefix (Instruction Word64
a [Prefix]
_ Opcode
op Maybe Operand
dst [Operand]
srcs Int
si) = Word64
-> [Prefix]
-> Opcode
-> Maybe Operand
-> [Operand]
-> Int
-> Instruction
Instruction Word64
a [] Opcode
op Maybe Operand
dst [Operand]
srcs Int
si

-- http://ref.x86asm.net/coder64.html#modrm_byte_32_64
--
-- Column o = opcodeMatch (see IDIV). If column o == r then use modrm
-- Operand = r/m16/32/64 means opWidthW


--TODO
mmx_sse :: StateT DisassemblerState Parser Instruction
mmx_sse = [StateT DisassemblerState Parser Instruction]
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a. Alternative f => [f a] -> f a
choice
  [ [Char] -> StateT DisassemblerState Parser Instruction
forall a. [Char] -> StateT DisassemblerState Parser a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"sse"
  , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x10 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Instruction -> Instruction
noPrefix (Instruction -> Instruction)
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Int, StateT DisassemblerState Parser Instruction)]
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {a}.
[(Int, StateT DisassemblerState Parser a)]
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser a
forkPrefixes [ (Int
0xf3, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"movss" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
32 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m])
                                                                     , (Int
0x66, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"movupd" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m])
                                                                     , (Int
0xf2, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"movsd" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
64 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m]) ]
                                                                     (        [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"movups" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m] )
  , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x11 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Instruction -> Instruction
noPrefix (Instruction -> Instruction)
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Int, StateT DisassemblerState Parser Instruction)]
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {a}.
[(Int, StateT DisassemblerState Parser a)]
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser a
forkPrefixes [ (Int
0xf3, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"movss" [Int -> Disassembler ()
opWidthF Int
32 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m, Disassembler Operand
modrm_xmm])
                                                                     , (Int
0x66, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"movupd" [Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m, Disassembler Operand
modrm_xmm])
                                                                     , (Int
0xf2, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"movsd" [Int -> Disassembler ()
opWidthF Int
64 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m, Disassembler Operand
modrm_xmm]) ]
                                                                     (        [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"movups" [Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m, Disassembler Operand
modrm_xmm] )

  , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x28 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Instruction -> Instruction
noPrefix (Instruction -> Instruction)
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Int, StateT DisassemblerState Parser Instruction)]
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {a}.
[(Int, StateT DisassemblerState Parser a)]
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser a
forkPrefixes [ (Int
0x66, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"movapd" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m]) ]
                                                                     (        [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"movaps" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m] )
  , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x29 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Instruction -> Instruction
noPrefix (Instruction -> Instruction)
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Int, StateT DisassemblerState Parser Instruction)]
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {a}.
[(Int, StateT DisassemblerState Parser a)]
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser a
forkPrefixes [ (Int
0x66, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"movapd" [Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m, Disassembler Operand
modrm_xmm]) ]
                                                                     (        [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"movaps" [Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m, Disassembler Operand
modrm_xmm] )
  , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x2a Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Instruction -> Instruction
noPrefix (Instruction -> Instruction)
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Int, StateT DisassemblerState Parser Instruction)]
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {a}.
[(Int, StateT DisassemblerState Parser a)]
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser a
forkPrefixes [ (Int
0xf3, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"CVTSI2SS" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
ifRexW Int
64 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_rm])
                                                                     , (Int
0x66, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"CVTPI2PD" [Disassembler Operand
modrm_xmm, Disassembler Operand
modrm_rm])
                                                                     , (Int
0xf2, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"CVTSI2SD" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
ifRexW Int
64 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_rm]) ]
                                                                     (        [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"CVTPI2PS" [Disassembler Operand
modrm_xmm, Disassembler Operand
modrm_rm] )
  , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x2c Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Instruction -> Instruction
noPrefix (Instruction -> Instruction)
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Int, StateT DisassemblerState Parser Instruction)]
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {a}.
[(Int, StateT DisassemblerState Parser a)]
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser a
forkPrefixes [ (Int
0xf3, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"CVTTSS2SI" [Int -> Disassembler ()
ifRexW Int
64 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_reg,Int -> Disassembler ()
opWidthF Int
32 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m])
                                                                     , (Int
0x66, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"CVTTPD2PI" [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> Operand -> Disassembler Operand
forall a b. (a -> b) -> a -> b
$ Register -> Operand
Op_Reg Register
RegNone,Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m]) -- TODO ST registers
                                                                     , (Int
0xf2, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"CVTTSD2SI" [Int -> Disassembler ()
ifRexW Int
64 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_reg,Int -> Disassembler ()
opWidthF Int
64 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m]) ]
                                                                     (        [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"CVTTPS2PI" [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> Operand -> Disassembler Operand
forall a b. (a -> b) -> a -> b
$ Register -> Operand
Op_Reg Register
RegNone,Int -> Disassembler ()
opWidthF Int
64 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m] ) -- TODO ST registers
  , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x2e Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Instruction -> Instruction
noPrefix (Instruction -> Instruction)
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Int, StateT DisassemblerState Parser Instruction)]
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {a}.
[(Int, StateT DisassemblerState Parser a)]
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser a
forkPrefixes [ (Int
0x66, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"ucomisd" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
64 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m]) ]
                                                                     (        [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"ucomiss" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
32 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m] )
  , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x2f Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Instruction -> Instruction
noPrefix (Instruction -> Instruction)
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Int, StateT DisassemblerState Parser Instruction)]
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {a}.
[(Int, StateT DisassemblerState Parser a)]
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser a
forkPrefixes [ (Int
0x66, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"comisd" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
64 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m]) ]
                                                                     (        [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"comiss" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
32 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m] )


  , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x51 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Instruction -> Instruction
noPrefix (Instruction -> Instruction)
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Int, StateT DisassemblerState Parser Instruction)]
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {a}.
[(Int, StateT DisassemblerState Parser a)]
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser a
forkPrefixes [ (Int
0xf3, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"sqrtss" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
32 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m])
                                                                     , (Int
0x66, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"sqrtpd" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m])
                                                                     , (Int
0xf2, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"sqrtsd" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
64 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m]) ]
                                                                     (        [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"sqrtps" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m] )
  , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x52 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Instruction -> Instruction
noPrefix (Instruction -> Instruction)
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Int, StateT DisassemblerState Parser Instruction)]
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {a}.
[(Int, StateT DisassemblerState Parser a)]
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser a
forkPrefixes [ (Int
0xf3, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"rsqrtss" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
32 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m]) ]
                                                                     (        [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"rsqrtps" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m] )
  , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x53 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Instruction -> Instruction
noPrefix (Instruction -> Instruction)
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Int, StateT DisassemblerState Parser Instruction)]
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {a}.
[(Int, StateT DisassemblerState Parser a)]
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser a
forkPrefixes [ (Int
0xf3, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"rcpps" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
32 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m]) ]
                                                                     (        [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"rcpss" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m] )
  , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x54 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Instruction -> Instruction
noPrefix (Instruction -> Instruction)
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Int, StateT DisassemblerState Parser Instruction)]
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {a}.
[(Int, StateT DisassemblerState Parser a)]
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser a
forkPrefixes [ (Int
0x66, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"andpd" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m]) ]
                                                                     (        [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"andps" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m] )
  , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x55 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Instruction -> Instruction
noPrefix (Instruction -> Instruction)
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Int, StateT DisassemblerState Parser Instruction)]
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {a}.
[(Int, StateT DisassemblerState Parser a)]
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser a
forkPrefixes [ (Int
0x66, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"andnpd" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m]) ]
                                                                     (        [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"andnps" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m] )
  , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x56 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Instruction -> Instruction
noPrefix (Instruction -> Instruction)
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Int, StateT DisassemblerState Parser Instruction)]
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {a}.
[(Int, StateT DisassemblerState Parser a)]
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser a
forkPrefixes [ (Int
0x66, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"orpd" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m]) ]
                                                                     (        [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"orps" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m] )
  , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x57 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Instruction -> Instruction
noPrefix (Instruction -> Instruction)
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Int, StateT DisassemblerState Parser Instruction)]
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {a}.
[(Int, StateT DisassemblerState Parser a)]
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser a
forkPrefixes [ (Int
0x66, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"xorpd" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m]) ]
                                                                     (        [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"xorps" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m] )
  , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x58 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Instruction -> Instruction
noPrefix (Instruction -> Instruction)
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Int, StateT DisassemblerState Parser Instruction)]
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {a}.
[(Int, StateT DisassemblerState Parser a)]
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser a
forkPrefixes [ (Int
0xf3, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"addss" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
32 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m])
                                                                     , (Int
0x66, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"addpd" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m])
                                                                     , (Int
0xf2, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"addsd" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
64 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m]) ]
                                                                     (        [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"addps" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m] )
  , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x59 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Instruction -> Instruction
noPrefix (Instruction -> Instruction)
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Int, StateT DisassemblerState Parser Instruction)]
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {a}.
[(Int, StateT DisassemblerState Parser a)]
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser a
forkPrefixes [ (Int
0xf3, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"mulss" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
32 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m])
                                                                     , (Int
0x66, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"mulpd" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m])
                                                                     , (Int
0xf2, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"mulsd" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
64 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m]) ]
                                                                     (        [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"mulps" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m] )
  , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x5a Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Instruction -> Instruction
noPrefix (Instruction -> Instruction)
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Int, StateT DisassemblerState Parser Instruction)]
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {a}.
[(Int, StateT DisassemblerState Parser a)]
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser a
forkPrefixes [ (Int
0xf3, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"CVTSS2SD" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
32 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m])
                                                                     , (Int
0x66, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"CVTPD2PS" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m])
                                                                     , (Int
0xf2, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"CVTSD2SS" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
64 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m]) ]
                                                                     (        [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"CVTPS2PD" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m] )
  , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x5b Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Instruction -> Instruction
noPrefix (Instruction -> Instruction)
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Int, StateT DisassemblerState Parser Instruction)]
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {a}.
[(Int, StateT DisassemblerState Parser a)]
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser a
forkPrefixes [ (Int
0xf3, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"CVTTPS2DQ" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m])
                                                                     , (Int
0x66, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"CVTPS2DQ" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m]) ]
                                                                     (        [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"CVTDQ2PS" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m] )
  , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x5c Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Instruction -> Instruction
noPrefix (Instruction -> Instruction)
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Int, StateT DisassemblerState Parser Instruction)]
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {a}.
[(Int, StateT DisassemblerState Parser a)]
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser a
forkPrefixes [ (Int
0xf3, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"subss" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
32 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m])
                                                                     , (Int
0x66, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"subpd" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m])
                                                                     , (Int
0xf2, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"subsd" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
64 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m]) ]
                                                                     (        [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"subps" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m] )
  , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x5d Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Instruction -> Instruction
noPrefix (Instruction -> Instruction)
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Int, StateT DisassemblerState Parser Instruction)]
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {a}.
[(Int, StateT DisassemblerState Parser a)]
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser a
forkPrefixes [ (Int
0xf3, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"minss" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
32 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m])
                                                                     , (Int
0x66, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"minpd" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m])
                                                                     , (Int
0xf2, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"minsd" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
64 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m]) ]
                                                                     (        [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"minps" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m] )
  , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x5e Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Instruction -> Instruction
noPrefix (Instruction -> Instruction)
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Int, StateT DisassemblerState Parser Instruction)]
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {a}.
[(Int, StateT DisassemblerState Parser a)]
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser a
forkPrefixes [ (Int
0xf3, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"divss" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
32 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m])
                                                                     , (Int
0x66, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"divpd" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m])
                                                                     , (Int
0xf2, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"divsd" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
64 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m]) ]
                                                                     (        [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"divps" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m] )
  , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x5f Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Instruction -> Instruction
noPrefix (Instruction -> Instruction)
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Int, StateT DisassemblerState Parser Instruction)]
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {a}.
[(Int, StateT DisassemblerState Parser a)]
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser a
forkPrefixes [ (Int
0xf3, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"maxss" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
32 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m])
                                                                     , (Int
0x66, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"maxpd" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m])
                                                                     , (Int
0xf2, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"maxsd" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
64 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m]) ]
                                                                     (        [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"maxps" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m] )

  , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x60 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Instruction -> Instruction
noPrefix (Instruction -> Instruction)
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Int, StateT DisassemblerState Parser Instruction)]
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {a}.
[(Int, StateT DisassemblerState Parser a)]
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser a
forkPrefixes [ (Int
0x66, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"PUNPCKLBW" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m]) ]
                                                                     (        [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"PUNPCKLBW" [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> Operand -> Disassembler Operand
forall a b. (a -> b) -> a -> b
$ Register -> Operand
Op_Reg Register
RegNone, Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> Operand -> Disassembler Operand
forall a b. (a -> b) -> a -> b
$ Register -> Operand
Op_Reg Register
RegNone] ) -- TODO ST register
  , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x61 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Instruction -> Instruction
noPrefix (Instruction -> Instruction)
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Int, StateT DisassemblerState Parser Instruction)]
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {a}.
[(Int, StateT DisassemblerState Parser a)]
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser a
forkPrefixes [ (Int
0x66, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"PUNPCKLWD" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m]) ]
                                                                     (        [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"PUNPCKLWD" [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> Operand -> Disassembler Operand
forall a b. (a -> b) -> a -> b
$ Register -> Operand
Op_Reg Register
RegNone, Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> Operand -> Disassembler Operand
forall a b. (a -> b) -> a -> b
$ Register -> Operand
Op_Reg Register
RegNone] ) -- TODO ST register
  , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x62 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Instruction -> Instruction
noPrefix (Instruction -> Instruction)
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Int, StateT DisassemblerState Parser Instruction)]
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {a}.
[(Int, StateT DisassemblerState Parser a)]
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser a
forkPrefixes [ (Int
0x66, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"PUNPCKLDQ" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m]) ]
                                                                     (        [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"PUNPCKLDQ" [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> Operand -> Disassembler Operand
forall a b. (a -> b) -> a -> b
$ Register -> Operand
Op_Reg Register
RegNone, Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> Operand -> Disassembler Operand
forall a b. (a -> b) -> a -> b
$ Register -> Operand
Op_Reg Register
RegNone] ) -- TODO ST register
  , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x63 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Instruction -> Instruction
noPrefix (Instruction -> Instruction)
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Int, StateT DisassemblerState Parser Instruction)]
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {a}.
[(Int, StateT DisassemblerState Parser a)]
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser a
forkPrefixes [ (Int
0x66, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"PACKSSWB" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m]) ]
                                                                     (        [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"PACKSSWB" [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> Operand -> Disassembler Operand
forall a b. (a -> b) -> a -> b
$ Register -> Operand
Op_Reg Register
RegNone, Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> Operand -> Disassembler Operand
forall a b. (a -> b) -> a -> b
$ Register -> Operand
Op_Reg Register
RegNone] ) -- TODO ST register
  , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x64 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Instruction -> Instruction
noPrefix (Instruction -> Instruction)
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Int, StateT DisassemblerState Parser Instruction)]
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {a}.
[(Int, StateT DisassemblerState Parser a)]
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser a
forkPrefixes [ (Int
0x66, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"PCMPGTB" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m]) ]
                                                                     (        [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"PCMPGTB" [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> Operand -> Disassembler Operand
forall a b. (a -> b) -> a -> b
$ Register -> Operand
Op_Reg Register
RegNone, Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> Operand -> Disassembler Operand
forall a b. (a -> b) -> a -> b
$ Register -> Operand
Op_Reg Register
RegNone] ) -- TODO ST register
  , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x65 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Instruction -> Instruction
noPrefix (Instruction -> Instruction)
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Int, StateT DisassemblerState Parser Instruction)]
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {a}.
[(Int, StateT DisassemblerState Parser a)]
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser a
forkPrefixes [ (Int
0x66, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"PCMPGTW" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m]) ]
                                                                     (        [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"PCMPGTW" [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> Operand -> Disassembler Operand
forall a b. (a -> b) -> a -> b
$ Register -> Operand
Op_Reg Register
RegNone, Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> Operand -> Disassembler Operand
forall a b. (a -> b) -> a -> b
$ Register -> Operand
Op_Reg Register
RegNone] ) -- TODO ST register
  , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x66 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Instruction -> Instruction
noPrefix (Instruction -> Instruction)
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Int, StateT DisassemblerState Parser Instruction)]
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {a}.
[(Int, StateT DisassemblerState Parser a)]
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser a
forkPrefixes [ (Int
0x66, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"PCMPGTD" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m]) ]
                                                                     (        [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"PCMPGTD" [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> Operand -> Disassembler Operand
forall a b. (a -> b) -> a -> b
$ Register -> Operand
Op_Reg Register
RegNone, Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> Operand -> Disassembler Operand
forall a b. (a -> b) -> a -> b
$ Register -> Operand
Op_Reg Register
RegNone] ) -- TODO ST register
  , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x67 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Instruction -> Instruction
noPrefix (Instruction -> Instruction)
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Int, StateT DisassemblerState Parser Instruction)]
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {a}.
[(Int, StateT DisassemblerState Parser a)]
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser a
forkPrefixes [ (Int
0x66, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"PACKUSWB" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m]) ]
                                                                     (        [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"PACKUSWB" [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> Operand -> Disassembler Operand
forall a b. (a -> b) -> a -> b
$ Register -> Operand
Op_Reg Register
RegNone, Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> Operand -> Disassembler Operand
forall a b. (a -> b) -> a -> b
$ Register -> Operand
Op_Reg Register
RegNone] ) -- TODO ST register
  , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x68 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Instruction -> Instruction
noPrefix (Instruction -> Instruction)
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Int, StateT DisassemblerState Parser Instruction)]
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {a}.
[(Int, StateT DisassemblerState Parser a)]
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser a
forkPrefixes [ (Int
0x66, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"PUNPCKHBW" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m]) ]
                                                                     (        [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"PUNPCKHBW" [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> Operand -> Disassembler Operand
forall a b. (a -> b) -> a -> b
$ Register -> Operand
Op_Reg Register
RegNone, Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> Operand -> Disassembler Operand
forall a b. (a -> b) -> a -> b
$ Register -> Operand
Op_Reg Register
RegNone] ) -- TODO ST register
  , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x69 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Instruction -> Instruction
noPrefix (Instruction -> Instruction)
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Int, StateT DisassemblerState Parser Instruction)]
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {a}.
[(Int, StateT DisassemblerState Parser a)]
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser a
forkPrefixes [ (Int
0x66, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"PUNPCKHWD" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m]) ]
                                                                     (        [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"PUNPCKHWD" [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> Operand -> Disassembler Operand
forall a b. (a -> b) -> a -> b
$ Register -> Operand
Op_Reg Register
RegNone, Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> Operand -> Disassembler Operand
forall a b. (a -> b) -> a -> b
$ Register -> Operand
Op_Reg Register
RegNone] ) -- TODO ST register
  , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x6a Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Instruction -> Instruction
noPrefix (Instruction -> Instruction)
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Int, StateT DisassemblerState Parser Instruction)]
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {a}.
[(Int, StateT DisassemblerState Parser a)]
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser a
forkPrefixes [ (Int
0x66, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"PUNPCKHDQ" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m]) ]
                                                                     (        [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"PUNPCKHDQ" [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> Operand -> Disassembler Operand
forall a b. (a -> b) -> a -> b
$ Register -> Operand
Op_Reg Register
RegNone, Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> Operand -> Disassembler Operand
forall a b. (a -> b) -> a -> b
$ Register -> Operand
Op_Reg Register
RegNone] ) -- TODO ST register
  , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x6b Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Instruction -> Instruction
noPrefix (Instruction -> Instruction)
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>                       [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"PACKSSDW" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m]
  , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x6c Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Instruction -> Instruction
noPrefix (Instruction -> Instruction)
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>                       [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"PUNPCKLQDQ" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m]
  , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x6d Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Instruction -> Instruction
noPrefix (Instruction -> Instruction)
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>                       [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"PUNPCKHQDQ" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m]
  , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x6e Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Instruction -> Instruction
noPrefix (Instruction -> Instruction)
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Int, StateT DisassemblerState Parser Instruction)]
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {a}.
[(Int, StateT DisassemblerState Parser a)]
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser a
forkPrefixes [ (Int
0x66, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"movq" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
64 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_rm]) ]
                                                                     (        [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"movq" [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> Operand -> Disassembler Operand
forall a b. (a -> b) -> a -> b
$ Register -> Operand
Op_Reg Register
RegNone, Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> Operand -> Disassembler Operand
forall a b. (a -> b) -> a -> b
$ Register -> Operand
Op_Reg Register
RegNone] ) -- TODO ST registe
  , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x6f Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Instruction -> Instruction
noPrefix (Instruction -> Instruction)
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Int, StateT DisassemblerState Parser Instruction)]
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {a}.
[(Int, StateT DisassemblerState Parser a)]
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser a
forkPrefixes [ (Int
0xf3, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"movdqu" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m])
                                                                     , (Int
0x66, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"movdqa" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m]) ]
                                                                     (        [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"movq" [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> Operand -> Disassembler Operand
forall a b. (a -> b) -> a -> b
$ Register -> Operand
Op_Reg Register
RegNone, Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> Operand -> Disassembler Operand
forall a b. (a -> b) -> a -> b
$ Register -> Operand
Op_Reg Register
RegNone] ) -- TODO ST register


  , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x74 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Instruction -> Instruction
noPrefix (Instruction -> Instruction)
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Int, StateT DisassemblerState Parser Instruction)]
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {a}.
[(Int, StateT DisassemblerState Parser a)]
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser a
forkPrefixes [ (Int
0x66, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"PCMPEQB" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m]) ]
                                                                     (        [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"PCMPEQB" [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> Operand -> Disassembler Operand
forall a b. (a -> b) -> a -> b
$ Register -> Operand
Op_Reg Register
RegNone, Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> Operand -> Disassembler Operand
forall a b. (a -> b) -> a -> b
$ Register -> Operand
Op_Reg Register
RegNone] )
  , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x75 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Instruction -> Instruction
noPrefix (Instruction -> Instruction)
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Int, StateT DisassemblerState Parser Instruction)]
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {a}.
[(Int, StateT DisassemblerState Parser a)]
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser a
forkPrefixes [ (Int
0x66, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"PCMPEQW" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m]) ]
                                                                     (        [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"PCMPEQW" [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> Operand -> Disassembler Operand
forall a b. (a -> b) -> a -> b
$ Register -> Operand
Op_Reg Register
RegNone, Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> Operand -> Disassembler Operand
forall a b. (a -> b) -> a -> b
$ Register -> Operand
Op_Reg Register
RegNone] )
  , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x76 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Instruction -> Instruction
noPrefix (Instruction -> Instruction)
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Int, StateT DisassemblerState Parser Instruction)]
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {a}.
[(Int, StateT DisassemblerState Parser a)]
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser a
forkPrefixes [ (Int
0x66, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"PCMPEQD" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m]) ]
                                                                     (        [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"PCMPEQD" [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> Operand -> Disassembler Operand
forall a b. (a -> b) -> a -> b
$ Register -> Operand
Op_Reg Register
RegNone, Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> Operand -> Disassembler Operand
forall a b. (a -> b) -> a -> b
$ Register -> Operand
Op_Reg Register
RegNone] )

  , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x7e Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Instruction -> Instruction
noPrefix (Instruction -> Instruction)
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Int, StateT DisassemblerState Parser Instruction)]
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {a}.
[(Int, StateT DisassemblerState Parser a)]
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser a
forkPrefixes [ (Int
0xf3, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"movq" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
64 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m])
                                                                     , (Int
0x66, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"movq" [Int -> Disassembler ()
opWidthF Int
64 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_rm, Disassembler Operand
modrm_xmm]) ]
                                                                     (        [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"movq" [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> Operand -> Disassembler Operand
forall a b. (a -> b) -> a -> b
$ Register -> Operand
Op_Reg Register
RegNone, Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> Operand -> Disassembler Operand
forall a b. (a -> b) -> a -> b
$ Register -> Operand
Op_Reg Register
RegNone] ) -- TODO ST registe
  , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x7f Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Instruction -> Instruction
noPrefix (Instruction -> Instruction)
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Int, StateT DisassemblerState Parser Instruction)]
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {a}.
[(Int, StateT DisassemblerState Parser a)]
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser a
forkPrefixes [ (Int
0xf3, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"movdqu" [Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m, Disassembler Operand
modrm_xmm])
                                                                     , (Int
0x66, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"movdqa" [Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m, Disassembler Operand
modrm_xmm]) ]
                                                                     (        [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"movq" [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> Operand -> Disassembler Operand
forall a b. (a -> b) -> a -> b
$ Register -> Operand
Op_Reg Register
RegNone, Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> Operand -> Disassembler Operand
forall a b. (a -> b) -> a -> b
$ Register -> Operand
Op_Reg Register
RegNone] ) -- TODO ST register


  , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xc2 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
immB Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Instruction -> Instruction
noPrefix (Instruction -> Instruction)
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Int, StateT DisassemblerState Parser Instruction)]
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {a}.
[(Int, StateT DisassemblerState Parser a)]
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser a
forkPrefixes [ (Int
0xf3, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"cmpss" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
32 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m, Disassembler Operand
immed])
                                                                             , (Int
0x66, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"cmppd" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m, Disassembler Operand
immed])
                                                                             , (Int
0xf2, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"cmpsd" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
64 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m, Disassembler Operand
immed]) ]
                                                                             (        [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"cmpps" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m, Disassembler Operand
immed] )


  , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xd6 Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
immB Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Instruction -> Instruction
noPrefix (Instruction -> Instruction)
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [(Int, StateT DisassemblerState Parser Instruction)]
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall {a}.
[(Int, StateT DisassemblerState Parser a)]
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser a
forkPrefixes [ (Int
0xf3, [Char] -> StateT DisassemblerState Parser Instruction
forall a. [Char] -> StateT DisassemblerState Parser a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"MOVQ2DQ")
                                                                             , (Int
0x66, [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"movq"  [Int -> Disassembler ()
opWidthF Int
64 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m, Disassembler Operand
modrm_xmm])
                                                                             , (Int
0xf2, [Char] -> StateT DisassemblerState Parser Instruction
forall a. [Char] -> StateT DisassemblerState Parser a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"MOVDQ2Q") ]
                                                                             (        [Char] -> StateT DisassemblerState Parser Instruction
forall a. [Char] -> StateT DisassemblerState Parser a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"" )

  , Int -> Disassembler ()
prefixSet Int
0x66 Disassembler () -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xef Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Instruction -> Instruction
noPrefix (Instruction -> Instruction)
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"pxor" [Disassembler Operand
modrm_xmm, Int -> Disassembler ()
opWidthF Int
128 Disassembler () -> Disassembler Operand -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler Operand
modrm_xmm_m]
  ,                   Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0xef Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>              [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"pxor" [Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> Operand -> Disassembler Operand
forall a b. (a -> b) -> a -> b
$ Register -> Operand
Op_Reg Register
RegNone, Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> Operand -> Disassembler Operand
forall a b. (a -> b) -> a -> b
$ Register -> Operand
Op_Reg Register
RegNone] -- TODO ST registers




  ]


--TODO
nops :: StateT DisassemblerState Parser Instruction
nops = [StateT DisassemblerState Parser Instruction]
-> StateT DisassemblerState Parser Instruction
forall (f :: * -> *) a. Alternative f => [f a] -> f a
choice
  [ [Char] -> StateT DisassemblerState Parser Instruction
forall a. [Char] -> StateT DisassemblerState Parser a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"nop"
  , Word8 -> Disassembler Word8
opcode Word8
0x0f Disassembler Word8 -> Disassembler Word8 -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Word8 -> Disassembler Word8
opcode Word8
0x1f Disassembler Word8 -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Disassembler ()
modrm Disassembler () -> Disassembler () -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Int -> Disassembler ()
opWidthF Int
32 Disassembler ()
-> StateT DisassemblerState Parser Instruction
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"nop" []
  ]



modrm_xmm :: Disassembler Operand
modrm_xmm :: Disassembler Operand
modrm_xmm = do Word8
b'reg <- ModRM -> Word8
modRM_breg (ModRM -> Word8) -> (Maybe ModRM -> ModRM) -> Maybe ModRM -> Word8
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe ModRM -> ModRM
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe ModRM -> Word8)
-> StateT DisassemblerState Parser (Maybe ModRM)
-> Disassembler Word8
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((DisassemblerState -> Maybe ModRM)
-> StateT DisassemblerState Parser (Maybe ModRM)
forall (m :: * -> *) s a. Monad m => (s -> a) -> StateT s m a
gets DisassemblerState -> Maybe ModRM
dsModRM)
               Word8
rexR <- Disassembler Word8
dsRexR
               let reg :: Register
reg = Word8 -> Word8 -> Register
select_xmm Word8
rexR Word8
b'reg
                 in Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> Operand -> Disassembler Operand
forall a b. (a -> b) -> a -> b
$ Register -> Operand
Op_Reg Register
reg

-- see table Registers at https://wiki.osdev.org/X86-64_Instruction_Encoding
modrm_xmm_m :: Disassembler Operand
modrm_xmm_m :: Disassembler Operand
modrm_xmm_m = do Int -> (Word8 -> Register) -> Operand
rm <- ModRM -> Int -> (Word8 -> Register) -> Operand
modRM_rm (ModRM -> Int -> (Word8 -> Register) -> Operand)
-> (Maybe ModRM -> ModRM)
-> Maybe ModRM
-> Int
-> (Word8 -> Register)
-> Operand
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe ModRM -> ModRM
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe ModRM -> Int -> (Word8 -> Register) -> Operand)
-> StateT DisassemblerState Parser (Maybe ModRM)
-> StateT
     DisassemblerState Parser (Int -> (Word8 -> Register) -> Operand)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (DisassemblerState -> Maybe ModRM)
-> StateT DisassemblerState Parser (Maybe ModRM)
forall (m :: * -> *) s a. Monad m => (s -> a) -> StateT s m a
gets DisassemblerState -> Maybe ModRM
dsModRM
                 Int
ow <- (DisassemblerState -> Int) -> StateT DisassemblerState Parser Int
forall (m :: * -> *) s a. Monad m => (s -> a) -> StateT s m a
gets DisassemblerState -> Int
dsOpWidth
                 Word8
rexB <- Disassembler Word8
dsRexB
                 let sr :: Word8 -> Register
sr = Word8 -> Word8 -> Register
select_xmm Word8
rexB
                   in Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Int -> (Word8 -> Register) -> Operand
rm Int
ow Word8 -> Register
sr)

select_xmm :: Word8 -> Word8 -> Register
select_xmm :: Word8 -> Word8 -> Register
select_xmm Word8
rex Word8
reg = let
                rvec' :: [SSEReg]
rvec' = case Word8
rex of
                        Word8
1 -> [SSEReg
XMM8, SSEReg
XMM9, SSEReg
XMM10, SSEReg
XMM11, SSEReg
XMM12, SSEReg
XMM13, SSEReg
XMM14, SSEReg
XMM15]
                        Word8
0 -> [SSEReg
XMM0, SSEReg
XMM1, SSEReg
XMM2 , SSEReg
XMM3,  SSEReg
XMM4,  SSEReg
XMM5,  SSEReg
XMM6,  SSEReg
XMM7 ]
                rvec :: [Register]
rvec = (SSEReg -> Register) -> [SSEReg] -> [Register]
forall a b. (a -> b) -> [a] -> [b]
map SSEReg -> Register
Reg128 [SSEReg]
rvec'
            in [Register]
rvec [Register] -> Int -> Register
forall a. HasCallStack => [a] -> Int -> a
!! (Word8 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word8
reg)




selectXmm :: a -> SSEReg
selectXmm a
0 = SSEReg
XMM0
selectXmm a
1 = SSEReg
XMM1
selectXmm a
2 = SSEReg
XMM2
selectXmm a
3 = SSEReg
XMM3
selectXmm a
4 = SSEReg
XMM4
selectXmm a
5 = SSEReg
XMM5
selectXmm a
6 = SSEReg
XMM6
selectXmm a
7 = SSEReg
XMM7
selectXmm a
8 = SSEReg
XMM8
selectXmm a
9 = SSEReg
XMM8
selectXmm a
10 = SSEReg
XMM10
selectXmm a
11 = SSEReg
XMM11
selectXmm a
12 = SSEReg
XMM12
selectXmm a
13 = SSEReg
XMM13
selectXmm a
14 = SSEReg
XMM14
selectXmm a
15 = SSEReg
XMM15


ifRexW :: Int -> Disassembler ()
ifRexW Int
w = do
  Word8
rexW <- Disassembler Word8
dsRexW
  if Word8
rexW Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
1 then Int -> Disassembler ()
opWidthF Int
w else () -> Disassembler ()
forall a. a -> StateT DisassemblerState Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ()


nop :: StateT DisassemblerState Parser Instruction
nop = do Word8
b <- Disassembler Word8
dsRexB
         Bool
rep <- ((DisassemblerState -> Bool) -> StateT DisassemblerState Parser Bool
forall (m :: * -> *) s a. Monad m => (s -> a) -> StateT s m a
gets DisassemblerState -> Bool
dsRep)
         if Word8
b Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
1 then [Char] -> StateT DisassemblerState Parser Instruction
forall a. [Char] -> StateT DisassemblerState Parser a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"not nop"
            else if Bool
rep then [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"pause" []
                else [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
"nop" []

ext1A :: a -> [Char]
ext1A a
i = [[Char]
"add", [Char]
"or", [Char]
"adc", [Char]
"sbb", [Char]
"and", [Char]
"sub", [Char]
"xor", [Char]
"cmp"] [[Char]] -> Int -> [Char]
forall a. HasCallStack => [a] -> Int -> a
!! (a -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral a
i)
ext1A' :: a -> [Char]
ext1A' a
i = Integer -> [Char]
forall {a}. Integral a => a -> [Char]
ext1A (a -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Int -> a -> a
forall a. (Integral a, Bits a) => Int -> Int -> a -> a
bits Int
3 Int
3 a
i))

fpuD8 :: a -> [Char]
fpuD8 a
i = [ [Char]
"fadd", [Char]
"fmul", [Char]
"fcom", [Char]
"fcomp", [Char]
"fsub", [Char]
"fsubr", [Char]
"fdiv", [Char]
"fdivr"] [[Char]] -> Int -> [Char]
forall a. HasCallStack => [a] -> Int -> a
!! (a -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral a
i)

shortjmp :: a -> [Char]
shortjmp a
i = [[Char]
"jo", [Char]
"jno", [Char]
"jb", [Char]
"jae", [Char]
"jz", [Char]
"jnz", [Char]
"jbe", [Char]
"ja", [Char]
"js", [Char]
"jns", [Char]
"jp", [Char]
"jnp", [Char]
"jl", [Char]
"jge", [Char]
"jle", [Char]
"jg"]
                        [[Char]] -> Int -> [Char]
forall a. HasCallStack => [a] -> Int -> a
!! (a -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Int -> a -> a
forall a. (Integral a, Bits a) => Int -> Int -> a -> a
bits Int
0 Int
4 a
i))

cmov :: a -> [Char]
cmov a
i = [[Char]
"cmovo", [Char]
"cmovno", [Char]
"cmovb", [Char]
"cmovae", [Char]
"cmovz", [Char]
"cmovnz", [Char]
"cmovbe", [Char]
"cmova", [Char]
"cmovs", [Char]
"cmovns", [Char]
"cmovp", [Char]
"cmovnp", [Char]
"cmovl", [Char]
"cmovge", [Char]
"cmovle", [Char]
"cmovg"]
                        [[Char]] -> Int -> [Char]
forall a. HasCallStack => [a] -> Int -> a
!! (a -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Int -> a -> a
forall a. (Integral a, Bits a) => Int -> Int -> a -> a
bits Int
0 Int
4 a
i))

ext2A :: StateT DisassemblerState Parser [Char]
ext2A = do Word8
i <- Disassembler Word8
modopcode
           case Word8
i of Word8
0 -> [Char] -> StateT DisassemblerState Parser [Char]
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Char]
"rol"
                     Word8
1 -> [Char] -> StateT DisassemblerState Parser [Char]
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Char]
"ror"
                     Word8
2 -> [Char] -> StateT DisassemblerState Parser [Char]
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Char]
"rcl"
                     Word8
3 -> [Char] -> StateT DisassemblerState Parser [Char]
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Char]
"rcr"
                     Word8
4 -> [Char] -> StateT DisassemblerState Parser [Char]
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Char]
"shl"
                     Word8
5 -> [Char] -> StateT DisassemblerState Parser [Char]
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Char]
"shr"
                     Word8
6 -> [Char] -> StateT DisassemblerState Parser [Char]
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Char]
"shl" -- intel says 6 is invalid but reportedly it's also shl
                     Word8
7 -> [Char] -> StateT DisassemblerState Parser [Char]
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Char]
"sar"

opWidthB :: Disassembler ()
opWidthB = Int -> Int -> Int -> Disassembler ()
opWidthX Int
8 Int
8 Int
8
opWidthW :: Disassembler ()
opWidthW = Int -> Int -> Int -> Disassembler ()
opWidthX Int
64 Int
32 Int
16
opWidthF :: Int -> Disassembler ()
opWidthF Int
n = Int -> Int -> Int -> Disassembler ()
opWidthX Int
n Int
n Int
n

forkPrefixes :: [(Int, StateT DisassemblerState Parser a)]
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser a
forkPrefixes [] StateT DisassemblerState Parser a
a' = StateT DisassemblerState Parser a
a'
forkPrefixes ((Int
p,StateT DisassemblerState Parser a
a):[(Int, StateT DisassemblerState Parser a)]
ps) StateT DisassemblerState Parser a
a' = [StateT DisassemblerState Parser a]
-> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Alternative f => [f a] -> f a
choice [Int -> Disassembler ()
prefixSet Int
p Disassembler ()
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser a
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> StateT DisassemblerState Parser a
a, [(Int, StateT DisassemblerState Parser a)]
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser a
forkPrefixes [(Int, StateT DisassemblerState Parser a)]
ps StateT DisassemblerState Parser a
a']

  

  

forkX :: StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forkX StateT DisassemblerState Parser b
q StateT DisassemblerState Parser b
d StateT DisassemblerState Parser b
w = do Bool
o16 <- StateT DisassemblerState Parser Bool
dsO16
                 Word8
rexW <- Disassembler Word8
dsRexW
                 case (Bool
o16, Word8
rexW) of (Bool
_, Word8
1) -> StateT DisassemblerState Parser b
q; (Bool
True, Word8
0) -> StateT DisassemblerState Parser b
w; (Bool
False, Word8
0) -> StateT DisassemblerState Parser b
d

forkX' :: StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forkX' StateT DisassemblerState Parser b
d StateT DisassemblerState Parser b
w = do Bool
o16 <- StateT DisassemblerState Parser Bool
dsO16
                case (Bool
o16) of (Bool
True) -> StateT DisassemblerState Parser b
w; (Bool
False) -> StateT DisassemblerState Parser b
d


forkA :: StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser b
forkA StateT DisassemblerState Parser b
q StateT DisassemblerState Parser b
d  = do Bool
a32 <- StateT DisassemblerState Parser Bool
dsA32
                case (Bool
a32) of (Bool
True) -> StateT DisassemblerState Parser b
d; (Bool
False) -> StateT DisassemblerState Parser b
q

opWidthX :: Int -> Int -> Int -> Disassembler ()
opWidthX Int
q Int
d Int
w = do Bool
o16 <- StateT DisassemblerState Parser Bool
dsO16
                    Word8
rexW <- Disassembler Word8
dsRexW
                    let ow :: Int
ow = case (Bool
o16, Word8
rexW) of (Bool
_, Word8
1) -> Int
q; (Bool
True, Word8
0) -> Int
w; (Bool
False, Word8
0) -> Int
d
                      in (DisassemblerState -> DisassemblerState) -> Disassembler ()
forall (m :: * -> *) s. Monad m => (s -> s) -> StateT s m ()
modify (\DisassemblerState
x -> DisassemblerState
x { dsOpWidth = ow })

opWidthX' :: Int -> Int -> Disassembler ()
opWidthX' Int
d Int
w = do Bool
o16 <- StateT DisassemblerState Parser Bool
dsO16
                   let ow :: Int
ow = case (Bool
o16) of (Bool
True) -> Int
w; (Bool
False) -> Int
d
                     in (DisassemblerState -> DisassemblerState) -> Disassembler ()
forall (m :: * -> *) s. Monad m => (s -> s) -> StateT s m ()
modify (\DisassemblerState
x -> DisassemblerState
x { dsOpWidth = ow })

adWidth :: Int -> Int -> Disassembler ()
adWidth Int
n1 Int
n2 = StateT DisassemblerState Parser Bool
dsA32 StateT DisassemblerState Parser Bool
-> (Bool -> Disassembler ()) -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> (a -> StateT DisassemblerState Parser b)
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (\Bool
f -> (DisassemblerState -> DisassemblerState) -> Disassembler ()
forall (m :: * -> *) s. Monad m => (s -> s) -> StateT s m ()
modify (\DisassemblerState
x -> DisassemblerState
x { dsAdWidth = if f then n1 else n2 } ) )

instr :: String -> [Disassembler Operand] -> Disassembler Instruction
instr :: [Char]
-> [Disassembler Operand]
-> StateT DisassemblerState Parser Instruction
instr [Char]
i [Disassembler Operand]
ops = Word64
-> [Prefix]
-> Opcode
-> Maybe Operand
-> [Operand]
-> Int
-> Instruction
Instruction (Word64
 -> [Prefix]
 -> Opcode
 -> Maybe Operand
 -> [Operand]
 -> Int
 -> Instruction)
-> Disassembler Word64
-> StateT
     DisassemblerState
     Parser
     ([Prefix]
      -> Opcode -> Maybe Operand -> [Operand] -> Int -> Instruction)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Word64 -> Disassembler Word64
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Word64
0 StateT
  DisassemblerState
  Parser
  ([Prefix]
   -> Opcode -> Maybe Operand -> [Operand] -> Int -> Instruction)
-> StateT DisassemblerState Parser [Prefix]
-> StateT
     DisassemblerState
     Parser
     (Opcode -> Maybe Operand -> [Operand] -> Int -> Instruction)
forall a b.
StateT DisassemblerState Parser (a -> b)
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> StateT DisassemblerState Parser [Prefix]
pfx StateT
  DisassemblerState
  Parser
  (Opcode -> Maybe Operand -> [Operand] -> Int -> Instruction)
-> StateT DisassemblerState Parser Opcode
-> StateT
     DisassemblerState
     Parser
     (Maybe Operand -> [Operand] -> Int -> Instruction)
forall a b.
StateT DisassemblerState Parser (a -> b)
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Opcode -> StateT DisassemblerState Parser Opcode
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ([Char] -> Opcode
read_opcode ([Char] -> Opcode) -> [Char] -> Opcode
forall a b. (a -> b) -> a -> b
$ (Char -> Char) -> [Char] -> [Char]
forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
toUpper [Char]
i) StateT
  DisassemblerState
  Parser
  (Maybe Operand -> [Operand] -> Int -> Instruction)
-> StateT DisassemblerState Parser (Maybe Operand)
-> StateT
     DisassemblerState Parser ([Operand] -> Int -> Instruction)
forall a b.
StateT DisassemblerState Parser (a -> b)
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Maybe Operand -> StateT DisassemblerState Parser (Maybe Operand)
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Operand
forall a. Maybe a
Nothing StateT DisassemblerState Parser ([Operand] -> Int -> Instruction)
-> StateT DisassemblerState Parser [Operand]
-> StateT DisassemblerState Parser (Int -> Instruction)
forall a b.
StateT DisassemblerState Parser (a -> b)
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> [Disassembler Operand] -> StateT DisassemblerState Parser [Operand]
forall (t :: * -> *) (m :: * -> *) a.
(Traversable t, Monad m) =>
t (m a) -> m (t a)
forall (m :: * -> *) a. Monad m => [m a] -> m [a]
sequence [Disassembler Operand]
ops StateT DisassemblerState Parser (Int -> Instruction)
-> StateT DisassemblerState Parser Int
-> StateT DisassemblerState Parser Instruction
forall a b.
StateT DisassemblerState Parser (a -> b)
-> StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Int -> StateT DisassemblerState Parser Int
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Int
0

readBytes :: Int -> Disassembler ByteString
readBytes :: Int -> Disassembler ByteString
readBytes Int
n = (Parser ByteString -> Disassembler ByteString
forall (m :: * -> *) a.
Monad m =>
m a -> StateT DisassemblerState m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (Parser ByteString -> Disassembler ByteString)
-> Parser ByteString -> Disassembler ByteString
forall a b. (a -> b) -> a -> b
$ (ByteString -> ByteString
B.fromStrict (ByteString -> ByteString)
-> Parser ByteString ByteString -> Parser ByteString
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Parser ByteString ByteString
A.take Int
n)) Disassembler ByteString
-> Disassembler () -> Disassembler ByteString
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Int -> Disassembler ()
adv Int
n

modopcode :: Disassembler Word8
modopcode :: Disassembler Word8
modopcode = ((DisassemblerState -> Maybe ModRM)
-> StateT DisassemblerState Parser (Maybe ModRM)
forall (m :: * -> *) s a. Monad m => (s -> a) -> StateT s m a
gets DisassemblerState -> Maybe ModRM
dsModRM) StateT DisassemblerState Parser (Maybe ModRM)
-> (Maybe ModRM -> Disassembler Word8) -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> (a -> StateT DisassemblerState Parser b)
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Word8 -> Disassembler Word8
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Word8 -> Disassembler Word8)
-> (Maybe ModRM -> Word8) -> Maybe ModRM -> Disassembler Word8
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ModRM -> Word8
modRM_breg (ModRM -> Word8) -> (Maybe ModRM -> ModRM) -> Maybe ModRM -> Word8
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe ModRM -> ModRM
forall a. HasCallStack => Maybe a -> a
fromJust

opcodeMatch :: Word8 -> Disassembler ()
opcodeMatch Word8
c = do Word8
o <- Disassembler Word8
modopcode; if Word8
o Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
c then () -> Disassembler ()
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure () else [Char] -> Disassembler ()
forall a. [Char] -> StateT DisassemblerState Parser a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"no match"
opmodmatch :: Word8 -> StateT DisassemblerState m ()
opmodmatch Word8
c = do Word8
o <- ModRM -> Word8
modRM_mod (ModRM -> Word8) -> (Maybe ModRM -> ModRM) -> Maybe ModRM -> Word8
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe ModRM -> ModRM
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe ModRM -> Word8)
-> StateT DisassemblerState m (Maybe ModRM)
-> StateT DisassemblerState m Word8
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((DisassemblerState -> Maybe ModRM)
-> StateT DisassemblerState m (Maybe ModRM)
forall (m :: * -> *) s a. Monad m => (s -> a) -> StateT s m a
gets DisassemblerState -> Maybe ModRM
dsModRM); if Word8
o Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
c then () -> StateT DisassemblerState m ()
forall a. a -> StateT DisassemblerState m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure () else [Char] -> StateT DisassemblerState m ()
forall a. [Char] -> StateT DisassemblerState m a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"no match"
opmodnot3 :: Disassembler ()
opmodnot3 = do Word8
o <- ModRM -> Word8
modRM_mod (ModRM -> Word8) -> (Maybe ModRM -> ModRM) -> Maybe ModRM -> Word8
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe ModRM -> ModRM
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe ModRM -> Word8)
-> StateT DisassemblerState Parser (Maybe ModRM)
-> Disassembler Word8
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((DisassemblerState -> Maybe ModRM)
-> StateT DisassemblerState Parser (Maybe ModRM)
forall (m :: * -> *) s a. Monad m => (s -> a) -> StateT s m a
gets DisassemblerState -> Maybe ModRM
dsModRM); if Word8
o Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
3 then [Char] -> Disassembler ()
forall a. [Char] -> StateT DisassemblerState Parser a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"no match" else () -> Disassembler ()
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ()

imm :: Disassembler ()
imm :: Disassembler ()
imm = do
    Int
ow <- (DisassemblerState -> Int) -> StateT DisassemblerState Parser Int
forall (m :: * -> *) s a. Monad m => (s -> a) -> StateT s m a
gets DisassemblerState -> Int
dsOpWidth
    case Int
ow of  Int
8 ->  (Int -> Disassembler ByteString
readBytes Int
1) Disassembler ByteString
-> (ByteString -> Disassembler Word64) -> Disassembler Word64
forall a b.
StateT DisassemblerState Parser a
-> (a -> StateT DisassemblerState Parser b)
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Word64 -> Disassembler Word64
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Word64 -> Disassembler Word64)
-> (ByteString -> Word64) -> ByteString -> Disassembler Word64
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\ByteString
s -> Word8 -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Get Word8 -> ByteString -> Word8
forall a. Get a -> ByteString -> a
G.runGet Get Word8
G.getWord8 (ByteString
s)))
                Int
16 -> (Int -> Disassembler ByteString
readBytes Int
2) Disassembler ByteString
-> (ByteString -> Disassembler Word64) -> Disassembler Word64
forall a b.
StateT DisassemblerState Parser a
-> (a -> StateT DisassemblerState Parser b)
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Word64 -> Disassembler Word64
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Word64 -> Disassembler Word64)
-> (ByteString -> Word64) -> ByteString -> Disassembler Word64
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\ByteString
s -> Word16 -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Get Word16 -> ByteString -> Word16
forall a. Get a -> ByteString -> a
G.runGet Get Word16
G.getWord16le (ByteString
s)))
                Int
32 -> (Int -> Disassembler ByteString
readBytes Int
4) Disassembler ByteString
-> (ByteString -> Disassembler Word64) -> Disassembler Word64
forall a b.
StateT DisassemblerState Parser a
-> (a -> StateT DisassemblerState Parser b)
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Word64 -> Disassembler Word64
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Word64 -> Disassembler Word64)
-> (ByteString -> Word64) -> ByteString -> Disassembler Word64
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\ByteString
s -> Word32 -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Get Word32 -> ByteString -> Word32
forall a. Get a -> ByteString -> a
G.runGet Get Word32
G.getWord32le (ByteString
s)))
                Int
64 -> (Int -> Disassembler ByteString
readBytes Int
4) Disassembler ByteString
-> (ByteString -> Disassembler Word64) -> Disassembler Word64
forall a b.
StateT DisassemblerState Parser a
-> (a -> StateT DisassemblerState Parser b)
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Word64 -> Disassembler Word64
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Word64 -> Disassembler Word64)
-> (ByteString -> Word64) -> ByteString -> Disassembler Word64
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\ByteString
s -> Word32 -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Get Word32 -> ByteString -> Word32
forall a. Get a -> ByteString -> a
G.runGet Get Word32
G.getWord32le (ByteString
s)))
      Disassembler Word64
-> (Word64 -> Disassembler ()) -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> (a -> StateT DisassemblerState Parser b)
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Word64
i -> (DisassemblerState -> DisassemblerState) -> Disassembler ()
forall (m :: * -> *) s. Monad m => (s -> s) -> StateT s m ()
modify (\DisassemblerState
x -> DisassemblerState
x { dsImmed = Just $ Op_Imm (Immediate (BitSize $ min ow 32) (i)) } )

immL :: Disassembler ()
immL :: Disassembler ()
immL = do
    Int
ow <- (DisassemblerState -> Int) -> StateT DisassemblerState Parser Int
forall (m :: * -> *) s a. Monad m => (s -> a) -> StateT s m a
gets DisassemblerState -> Int
dsOpWidth
    case Int
ow of  Int
8 ->  (Int -> Disassembler ByteString
readBytes Int
1) Disassembler ByteString
-> (ByteString -> Disassembler Word64) -> Disassembler Word64
forall a b.
StateT DisassemblerState Parser a
-> (a -> StateT DisassemblerState Parser b)
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Word64 -> Disassembler Word64
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Word64 -> Disassembler Word64)
-> (ByteString -> Word64) -> ByteString -> Disassembler Word64
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\ByteString
s -> Word8 -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Get Word8 -> ByteString -> Word8
forall a. Get a -> ByteString -> a
G.runGet Get Word8
G.getWord8 (ByteString
s)))
                Int
16 -> (Int -> Disassembler ByteString
readBytes Int
2) Disassembler ByteString
-> (ByteString -> Disassembler Word64) -> Disassembler Word64
forall a b.
StateT DisassemblerState Parser a
-> (a -> StateT DisassemblerState Parser b)
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Word64 -> Disassembler Word64
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Word64 -> Disassembler Word64)
-> (ByteString -> Word64) -> ByteString -> Disassembler Word64
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\ByteString
s -> Word16 -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Get Word16 -> ByteString -> Word16
forall a. Get a -> ByteString -> a
G.runGet Get Word16
G.getWord16le (ByteString
s)))
                Int
32 -> (Int -> Disassembler ByteString
readBytes Int
4) Disassembler ByteString
-> (ByteString -> Disassembler Word64) -> Disassembler Word64
forall a b.
StateT DisassemblerState Parser a
-> (a -> StateT DisassemblerState Parser b)
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Word64 -> Disassembler Word64
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Word64 -> Disassembler Word64)
-> (ByteString -> Word64) -> ByteString -> Disassembler Word64
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\ByteString
s -> Word32 -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Get Word32 -> ByteString -> Word32
forall a. Get a -> ByteString -> a
G.runGet Get Word32
G.getWord32le (ByteString
s)))
                Int
64 -> (Int -> Disassembler ByteString
readBytes Int
8) Disassembler ByteString
-> (ByteString -> Disassembler Word64) -> Disassembler Word64
forall a b.
StateT DisassemblerState Parser a
-> (a -> StateT DisassemblerState Parser b)
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Word64 -> Disassembler Word64
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Word64 -> Disassembler Word64)
-> (ByteString -> Word64) -> ByteString -> Disassembler Word64
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\ByteString
s -> Word64 -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Get Word64 -> ByteString -> Word64
forall a. Get a -> ByteString -> a
G.runGet Get Word64
G.getWord64le (ByteString
s)))
      Disassembler Word64
-> (Word64 -> Disassembler ()) -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> (a -> StateT DisassemblerState Parser b)
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Word64
i -> (DisassemblerState -> DisassemblerState) -> Disassembler ()
forall (m :: * -> *) s. Monad m => (s -> s) -> StateT s m ()
modify (\DisassemblerState
x -> DisassemblerState
x { dsImmed = Just $ Op_Imm (Immediate (BitSize ow) (i)) } )

imm'' :: Disassembler Word64
imm'' :: Disassembler Word64
imm'' = Word8 -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word8 -> Word64) -> Disassembler Word8 -> Disassembler Word64
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Parser ByteString Word8 -> Disassembler Word8
forall (m :: * -> *) a.
Monad m =>
m a -> StateT DisassemblerState m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift Parser ByteString Word8
anyWord8) Disassembler Word64 -> Disassembler () -> Disassembler Word64
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Int -> Disassembler ()
adv Int
1

moffs :: Disassembler ()
moffs :: Disassembler ()
moffs = do
    Int
aw <- (\Bool
x -> if Bool
x then Int
32 :: Int else Int
64 :: Int) (Bool -> Int)
-> StateT DisassemblerState Parser Bool
-> StateT DisassemblerState Parser Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT DisassemblerState Parser Bool
dsA32
    Int
ow <- (DisassemblerState -> Int) -> StateT DisassemblerState Parser Int
forall (m :: * -> *) s a. Monad m => (s -> a) -> StateT s m a
gets DisassemblerState -> Int
dsOpWidth
    Maybe SReg
seg <- (DisassemblerState -> Maybe SReg)
-> StateT DisassemblerState Parser (Maybe SReg)
forall (m :: * -> *) s a. Monad m => (s -> a) -> StateT s m a
gets DisassemblerState -> Maybe SReg
dsSegOverride
    case Int
aw of Int
32 -> (Int -> Disassembler ByteString
readBytes Int
4) Disassembler ByteString
-> (ByteString -> StateT DisassemblerState Parser Int)
-> StateT DisassemblerState Parser Int
forall a b.
StateT DisassemblerState Parser a
-> (a -> StateT DisassemblerState Parser b)
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Int -> StateT DisassemblerState Parser Int
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Int -> StateT DisassemblerState Parser Int)
-> (ByteString -> Int)
-> ByteString
-> StateT DisassemblerState Parser Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\ByteString
s -> Word32 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Get Word32 -> ByteString -> Word32
forall a. Get a -> ByteString -> a
G.runGet Get Word32
G.getWord32le (ByteString
s)))
               Int
64 -> (Int -> Disassembler ByteString
readBytes Int
8) Disassembler ByteString
-> (ByteString -> StateT DisassemblerState Parser Int)
-> StateT DisassemblerState Parser Int
forall a b.
StateT DisassemblerState Parser a
-> (a -> StateT DisassemblerState Parser b)
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Int -> StateT DisassemblerState Parser Int
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Int -> StateT DisassemblerState Parser Int)
-> (ByteString -> Int)
-> ByteString
-> StateT DisassemblerState Parser Int
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\ByteString
s -> Word64 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Get Word64 -> ByteString -> Word64
forall a. Get a -> ByteString -> a
G.runGet Get Word64
G.getWord64le (ByteString
s)))
      StateT DisassemblerState Parser Int
-> (Int -> Disassembler ()) -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> (a -> StateT DisassemblerState Parser b)
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Int
disp -> (DisassemblerState -> DisassemblerState) -> Disassembler ()
forall (m :: * -> *) s. Monad m => (s -> s) -> StateT s m ()
modify (\DisassemblerState
x -> DisassemblerState
x {
                dsMoffset = Just $ Op_Mem (BitSize ow) (BitSize aw) RegNone RegNone 0 disp seg
                })

moffset :: Disassembler Operand
moffset :: Disassembler Operand
moffset = ((DisassemblerState -> Maybe Operand)
-> StateT DisassemblerState Parser (Maybe Operand)
forall (m :: * -> *) s a. Monad m => (s -> a) -> StateT s m a
gets DisassemblerState -> Maybe Operand
dsMoffset) StateT DisassemblerState Parser (Maybe Operand)
-> (Maybe Operand -> Disassembler Operand) -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> (a -> StateT DisassemblerState Parser b)
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> (Maybe Operand -> Operand)
-> Maybe Operand
-> Disassembler Operand
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe Operand -> Operand
forall a. HasCallStack => Maybe a -> a
fromJust


immB :: Disassembler ()
immB :: Disassembler ()
immB = Int -> Get Word8 -> Disassembler ()
forall t. Integral t => Int -> Get t -> Disassembler ()
imm' Int
1 Get Word8
G.getWord8

immW :: Disassembler ()
immW :: Disassembler ()
immW = Int -> Get Word16 -> Disassembler ()
forall t. Integral t => Int -> Get t -> Disassembler ()
imm' Int
2 Get Word16
G.getWord16le

imm' :: (Integral t) => Int -> G.Get t -> Disassembler ()
imm' :: forall t. Integral t => Int -> Get t -> Disassembler ()
imm' Int
b Get t
f = (Int -> Disassembler ByteString
readBytes Int
b) Disassembler ByteString
-> (ByteString -> Disassembler Word64) -> Disassembler Word64
forall a b.
StateT DisassemblerState Parser a
-> (a -> StateT DisassemblerState Parser b)
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Word64 -> Disassembler Word64
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Word64 -> Disassembler Word64)
-> (ByteString -> Word64) -> ByteString -> Disassembler Word64
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\ByteString
s -> t -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Get t -> ByteString -> t
forall a. Get a -> ByteString -> a
G.runGet Get t
f (ByteString
s)))
                         Disassembler Word64
-> (Word64 -> Disassembler ()) -> Disassembler ()
forall a b.
StateT DisassemblerState Parser a
-> (a -> StateT DisassemblerState Parser b)
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Word64
i -> (DisassemblerState -> DisassemblerState) -> Disassembler ()
forall (m :: * -> *) s. Monad m => (s -> s) -> StateT s m ()
modify (\DisassemblerState
x -> DisassemblerState
x { dsImmed = Just $ Op_Imm $ Immediate (BitSize $ 8 * b) i } )

displ :: Disassembler Operand
displ :: Disassembler Operand
displ = do  ByteString
s <- (Int -> Disassembler ByteString
readBytes Int
1)
            Word64
disp <- Word64 -> Disassembler Word64
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Int8 -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Get Int8 -> ByteString -> Int8
forall a. Get a -> ByteString -> a
G.runGet Get Int8
G.getInt8 (ByteString
s)))
            Word64
eip <- (DisassemblerState -> Word64) -> Disassembler Word64
forall (m :: * -> *) s a. Monad m => (s -> a) -> StateT s m a
gets DisassemblerState -> Word64
dsOffset
            let iv :: Word64
iv = Int -> Int -> Word64 -> Word64
forall a. (Integral a, Bits a) => Int -> Int -> a -> a
bits Int
0 Int
64 (Word64
eip Word64 -> Word64 -> Word64
forall a. Num a => a -> a -> a
+ Word64
disp)
                imm :: Immediate
imm = BitSize -> Word64 -> Immediate
Immediate (Int -> BitSize
BitSize Int
64) Word64
iv
              in Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Immediate -> Operand
Op_Jmp Immediate
imm)

displW :: Disassembler Operand
displW :: Disassembler Operand
displW = do ByteString
s <- (Int -> Disassembler ByteString
readBytes Int
2)
            Word64
disp <- Word64 -> Disassembler Word64
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Int16 -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Get Int16 -> ByteString -> Int16
forall a. Get a -> ByteString -> a
G.runGet Get Int16
G.getInt16le (ByteString
s)))
            Word64
eip <- (DisassemblerState -> Word64) -> Disassembler Word64
forall (m :: * -> *) s a. Monad m => (s -> a) -> StateT s m a
gets DisassemblerState -> Word64
dsOffset
            let iv :: Word64
iv = Int -> Int -> Word64 -> Word64
forall a. (Integral a, Bits a) => Int -> Int -> a -> a
bits Int
0 Int
64 (Word64
eip Word64 -> Word64 -> Word64
forall a. Num a => a -> a -> a
+ Word64
disp)
                imm :: Immediate
imm = BitSize -> Word64 -> Immediate
Immediate (Int -> BitSize
BitSize Int
64) Word64
iv
              in Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Immediate -> Operand
Op_Jmp Immediate
imm)

displD :: Disassembler Operand
displD :: Disassembler Operand
displD = do ByteString
s <- (Int -> Disassembler ByteString
readBytes Int
4)
            Word64
disp <- Word64 -> Disassembler Word64
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Int32 -> Word64
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Get Int32 -> ByteString -> Int32
forall a. Get a -> ByteString -> a
G.runGet Get Int32
G.getInt32le (ByteString
s)))
            Word64
eip <- (DisassemblerState -> Word64) -> Disassembler Word64
forall (m :: * -> *) s a. Monad m => (s -> a) -> StateT s m a
gets DisassemblerState -> Word64
dsOffset
            let iv :: Word64
iv = Int -> Int -> Word64 -> Word64
forall a. (Integral a, Bits a) => Int -> Int -> a -> a
bits Int
0 Int
64 (Word64
eip Word64 -> Word64 -> Word64
forall a. Num a => a -> a -> a
+ Word64
disp)
                imm :: Immediate
imm = BitSize -> Word64 -> Immediate
Immediate (Int -> BitSize
BitSize Int
64) Word64
iv
              in Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Immediate -> Operand
Op_Jmp Immediate
imm)

pfx :: Disassembler [Prefix]
pfx :: StateT DisassemblerState Parser [Prefix]
pfx = do DisassemblerState
st <- StateT DisassemblerState Parser DisassemblerState
forall (m :: * -> *) s. Monad m => StateT s m s
get
         let ff :: (DisassemblerState -> Bool) -> a -> [a]
ff DisassemblerState -> Bool
a a
b = if (DisassemblerState -> Bool
a DisassemblerState
st) then [a
b] else []
             pfx :: [Prefix]
pfx = ((DisassemblerState -> Bool) -> Prefix -> [Prefix]
forall {a}. (DisassemblerState -> Bool) -> a -> [a]
ff DisassemblerState -> Bool
dsLock Prefix
PrefixLock)
                [Prefix] -> [Prefix] -> [Prefix]
forall a. [a] -> [a] -> [a]
++ ((DisassemblerState -> Bool) -> Prefix -> [Prefix]
forall {a}. (DisassemblerState -> Bool) -> a -> [a]
ff DisassemblerState -> Bool
dsRepNE Prefix
PrefixRepNE)
                [Prefix] -> [Prefix] -> [Prefix]
forall a. [a] -> [a] -> [a]
++ ((DisassemblerState -> Bool) -> Prefix -> [Prefix]
forall {a}. (DisassemblerState -> Bool) -> a -> [a]
ff DisassemblerState -> Bool
dsRep Prefix
PrefixRep)
                [Prefix] -> [Prefix] -> [Prefix]
forall a. [a] -> [a] -> [a]
++ ((DisassemblerState -> Bool) -> Prefix -> [Prefix]
forall {a}. (DisassemblerState -> Bool) -> a -> [a]
ff DisassemblerState -> Bool
dsOpWidthOverride Prefix
PrefixO16)
                [Prefix] -> [Prefix] -> [Prefix]
forall a. [a] -> [a] -> [a]
++ ((DisassemblerState -> Bool) -> Prefix -> [Prefix]
forall {a}. (DisassemblerState -> Bool) -> a -> [a]
ff DisassemblerState -> Bool
dsAdWidthOverride Prefix
PrefixA32)
                [Prefix] -> [Prefix] -> [Prefix]
forall a. [a] -> [a] -> [a]
++ ([Prefix] -> (SReg -> [Prefix]) -> Maybe SReg -> [Prefix]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] ((Prefix -> [Prefix] -> [Prefix]
forall a. a -> [a] -> [a]
:[]) (Prefix -> [Prefix]) -> (SReg -> Prefix) -> SReg -> [Prefix]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SReg -> Prefix
PrefixSeg) (DisassemblerState -> Maybe SReg
dsSegOverride DisassemblerState
st))
                [Prefix] -> [Prefix] -> [Prefix]
forall a. [a] -> [a] -> [a]
++ ([Prefix] -> (Word8 -> [Prefix]) -> Maybe Word8 -> [Prefix]
forall b a. b -> (a -> b) -> Maybe a -> b
maybe [] ((Prefix -> [Prefix] -> [Prefix]
forall a. a -> [a] -> [a]
:[]) (Prefix -> [Prefix]) -> (Word8 -> Prefix) -> Word8 -> [Prefix]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Word8 -> Prefix
PrefixRex) (DisassemblerState -> Maybe Word8
dsRex DisassemblerState
st))
            in [Prefix] -> StateT DisassemblerState Parser [Prefix]
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Prefix]
pfx

modrm_rm :: Disassembler Operand
modrm_rm :: Disassembler Operand
modrm_rm = do Int -> (Word8 -> Register) -> Operand
rm <- ModRM -> Int -> (Word8 -> Register) -> Operand
modRM_rm (ModRM -> Int -> (Word8 -> Register) -> Operand)
-> (Maybe ModRM -> ModRM)
-> Maybe ModRM
-> Int
-> (Word8 -> Register)
-> Operand
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe ModRM -> ModRM
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe ModRM -> Int -> (Word8 -> Register) -> Operand)
-> StateT DisassemblerState Parser (Maybe ModRM)
-> StateT
     DisassemblerState Parser (Int -> (Word8 -> Register) -> Operand)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (DisassemblerState -> Maybe ModRM)
-> StateT DisassemblerState Parser (Maybe ModRM)
forall (m :: * -> *) s a. Monad m => (s -> a) -> StateT s m a
gets DisassemblerState -> Maybe ModRM
dsModRM
              Int
ow <- (DisassemblerState -> Int) -> StateT DisassemblerState Parser Int
forall (m :: * -> *) s a. Monad m => (s -> a) -> StateT s m a
gets DisassemblerState -> Int
dsOpWidth
              Word8
rexB <- Disassembler Word8
dsRexB
              Maybe Word8
rex <- (DisassemblerState -> Maybe Word8)
-> StateT DisassemblerState Parser (Maybe Word8)
forall (m :: * -> *) s a. Monad m => (s -> a) -> StateT s m a
gets DisassemblerState -> Maybe Word8
dsRex
              let sr :: Word8 -> Register
sr = Int -> Word8 -> Maybe Word8 -> Word8 -> Register
selectreg Int
ow Word8
rexB Maybe Word8
rex
                in Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Int -> (Word8 -> Register) -> Operand
rm Int
ow Word8 -> Register
sr)

modrm_reg :: Disassembler Operand
modrm_reg :: Disassembler Operand
modrm_reg = do Word8
b'reg <- ModRM -> Word8
modRM_breg (ModRM -> Word8) -> (Maybe ModRM -> ModRM) -> Maybe ModRM -> Word8
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe ModRM -> ModRM
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe ModRM -> Word8)
-> StateT DisassemblerState Parser (Maybe ModRM)
-> Disassembler Word8
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((DisassemblerState -> Maybe ModRM)
-> StateT DisassemblerState Parser (Maybe ModRM)
forall (m :: * -> *) s a. Monad m => (s -> a) -> StateT s m a
gets DisassemblerState -> Maybe ModRM
dsModRM)
               Int
opWidth <- (DisassemblerState -> Int) -> StateT DisassemblerState Parser Int
forall (m :: * -> *) s a. Monad m => (s -> a) -> StateT s m a
gets DisassemblerState -> Int
dsOpWidth
               Word8
rexR <- Disassembler Word8
dsRexR
               Maybe Word8
rex <- (DisassemblerState -> Maybe Word8)
-> StateT DisassemblerState Parser (Maybe Word8)
forall (m :: * -> *) s a. Monad m => (s -> a) -> StateT s m a
gets DisassemblerState -> Maybe Word8
dsRex
               let reg :: Register
reg = Int -> Word8 -> Maybe Word8 -> Word8 -> Register
selectreg Int
opWidth Word8
rexR Maybe Word8
rex Word8
b'reg
                 in Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> Operand -> Disassembler Operand
forall a b. (a -> b) -> a -> b
$ Register -> Operand
Op_Reg Register
reg

modrm_sreg :: Disassembler Operand
modrm_sreg :: Disassembler Operand
modrm_sreg = do Word8
b'reg <- ModRM -> Word8
modRM_breg (ModRM -> Word8) -> (Maybe ModRM -> ModRM) -> Maybe ModRM -> Word8
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe ModRM -> ModRM
forall a. HasCallStack => Maybe a -> a
fromJust (Maybe ModRM -> Word8)
-> StateT DisassemblerState Parser (Maybe ModRM)
-> Disassembler Word8
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ((DisassemblerState -> Maybe ModRM)
-> StateT DisassemblerState Parser (Maybe ModRM)
forall (m :: * -> *) s a. Monad m => (s -> a) -> StateT s m a
gets DisassemblerState -> Maybe ModRM
dsModRM)
                case Word8
b'reg of Word8
0 -> Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Register -> Operand
Op_Reg (Register -> Operand) -> Register -> Operand
forall a b. (a -> b) -> a -> b
$ SReg -> Register
RegSeg SReg
ES)
                              Word8
1 -> Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Register -> Operand
Op_Reg (Register -> Operand) -> Register -> Operand
forall a b. (a -> b) -> a -> b
$ SReg -> Register
RegSeg SReg
CS)
                              Word8
2 -> Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Register -> Operand
Op_Reg (Register -> Operand) -> Register -> Operand
forall a b. (a -> b) -> a -> b
$ SReg -> Register
RegSeg SReg
SS)
                              Word8
3 -> Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Register -> Operand
Op_Reg (Register -> Operand) -> Register -> Operand
forall a b. (a -> b) -> a -> b
$ SReg -> Register
RegSeg SReg
DS)
                              Word8
4 -> Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Register -> Operand
Op_Reg (Register -> Operand) -> Register -> Operand
forall a b. (a -> b) -> a -> b
$ SReg -> Register
RegSeg SReg
FS)
                              Word8
5 -> Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Register -> Operand
Op_Reg (Register -> Operand) -> Register -> Operand
forall a b. (a -> b) -> a -> b
$ SReg -> Register
RegSeg SReg
GS)
                              Word8
6 -> Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Register -> Operand
Op_Reg (Register -> Operand) -> Register -> Operand
forall a b. (a -> b) -> a -> b
$ SReg -> Register
RegSeg SReg
SR6) -- not in Intel spec
                              Word8
7 -> Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Register -> Operand
Op_Reg (Register -> Operand) -> Register -> Operand
forall a b. (a -> b) -> a -> b
$ SReg -> Register
RegSeg SReg
SR7) -- not in Intel spec
                              Word8
_ -> [Char] -> Disassembler Operand
forall a. [Char] -> StateT DisassemblerState Parser a
forall (m :: * -> *) a. MonadFail m => [Char] -> m a
fail [Char]
"invalid"

immed :: Disassembler Operand
immed :: Disassembler Operand
immed = ((DisassemblerState -> Maybe Operand)
-> StateT DisassemblerState Parser (Maybe Operand)
forall (m :: * -> *) s a. Monad m => (s -> a) -> StateT s m a
gets DisassemblerState -> Maybe Operand
dsImmed) StateT DisassemblerState Parser (Maybe Operand)
-> (Maybe Operand -> Disassembler Operand) -> Disassembler Operand
forall a b.
StateT DisassemblerState Parser a
-> (a -> StateT DisassemblerState Parser b)
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> (Maybe Operand -> Operand)
-> Maybe Operand
-> Disassembler Operand
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe Operand -> Operand
forall a. HasCallStack => Maybe a -> a
fromJust

reg :: Word8 -> (Int -> Int) -> Disassembler Operand
reg :: Word8 -> (Int -> Int) -> Disassembler Operand
reg Word8
rr Int -> Int
ov = do
    Int
ow <- (DisassemblerState -> Int) -> StateT DisassemblerState Parser Int
forall (m :: * -> *) s a. Monad m => (s -> a) -> StateT s m a
gets DisassemblerState -> Int
dsOpWidth
    Maybe Word8
rex <- (DisassemblerState -> Maybe Word8)
-> StateT DisassemblerState Parser (Maybe Word8)
forall (m :: * -> *) s a. Monad m => (s -> a) -> StateT s m a
gets DisassemblerState -> Maybe Word8
dsRex
    Word8
rexB <- Disassembler Word8
dsRexB
    let r :: Register
r = Int -> Word8 -> Maybe Word8 -> Word8 -> Register
selectreg (Int -> Int
ov Int
ow) Word8
rexB Maybe Word8
rex Word8
rr
      in Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> Operand -> Disassembler Operand
forall a b. (a -> b) -> a -> b
$ Register -> Operand
Op_Reg Register
r

freg :: Word8 -> Disassembler Operand
freg :: Word8 -> Disassembler Operand
freg Word8
rr = (Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> (FPUReg -> Operand) -> FPUReg -> Disassembler Operand
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Register -> Operand
Op_Reg (Register -> Operand) -> (FPUReg -> Register) -> FPUReg -> Operand
forall b c a. (b -> c) -> (a -> b) -> a -> c
. FPUReg -> Register
RegFPU) ( [FPUReg
ST0, FPUReg
ST1, FPUReg
ST2, FPUReg
ST3, FPUReg
ST4, FPUReg
ST5, FPUReg
ST6, FPUReg
ST7] [FPUReg] -> Int -> FPUReg
forall a. HasCallStack => [a] -> Int -> a
!! (Word8 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word8
rr) )

accum :: Disassembler Operand
accum :: Disassembler Operand
accum = do
    Int
ow <- (DisassemblerState -> Int) -> StateT DisassemblerState Parser Int
forall (m :: * -> *) s a. Monad m => (s -> a) -> StateT s m a
gets DisassemblerState -> Int
dsOpWidth
    Maybe Word8
rex <- (DisassemblerState -> Maybe Word8)
-> StateT DisassemblerState Parser (Maybe Word8)
forall (m :: * -> *) s a. Monad m => (s -> a) -> StateT s m a
gets DisassemblerState -> Maybe Word8
dsRex
    let r :: Register
r = Int -> Word8 -> Maybe Word8 -> Word8 -> Register
selectreg Int
ow Word8
0 Maybe Word8
forall a. Maybe a
Nothing Word8
0
      in Operand -> Disassembler Operand
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Operand -> Disassembler Operand)
-> Operand -> Disassembler Operand
forall a b. (a -> b) -> a -> b
$ Register -> Operand
Op_Reg Register
r

-- type DisassemblerSingle = Word8 -> DisassemblerState -> Get Instruction
-- type OpcodeMap = Map.Map Word8 DisassemblerSingle
--
dsO16 :: Disassembler Bool
dsO16 :: StateT DisassemblerState Parser Bool
dsO16 = (DisassemblerState -> Bool) -> StateT DisassemblerState Parser Bool
forall (m :: * -> *) s a. Monad m => (s -> a) -> StateT s m a
gets DisassemblerState -> Bool
dsOpWidthOverride
dsA32 :: Disassembler Bool
dsA32 :: StateT DisassemblerState Parser Bool
dsA32 = (DisassemblerState -> Bool) -> StateT DisassemblerState Parser Bool
forall (m :: * -> *) s a. Monad m => (s -> a) -> StateT s m a
gets DisassemblerState -> Bool
dsAdWidthOverride

dsRexW :: Disassembler Word8
dsRexW :: Disassembler Word8
dsRexW = (DisassemblerState -> Maybe Word8)
-> StateT DisassemblerState Parser (Maybe Word8)
forall (m :: * -> *) s a. Monad m => (s -> a) -> StateT s m a
gets DisassemblerState -> Maybe Word8
dsRex StateT DisassemblerState Parser (Maybe Word8)
-> (Maybe Word8 -> Disassembler Word8) -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> (a -> StateT DisassemblerState Parser b)
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Maybe Word8
rex -> Word8 -> Disassembler Word8
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Word8 -> Disassembler Word8) -> Word8 -> Disassembler Word8
forall a b. (a -> b) -> a -> b
$ Int -> Int -> Word8 -> Word8
forall a. (Integral a, Bits a) => Int -> Int -> a -> a
bits Int
3 Int
1 (Word8 -> Maybe Word8 -> Word8
forall a. a -> Maybe a -> a
fromMaybe Word8
0 Maybe Word8
rex)
dsRexR :: Disassembler Word8
dsRexR :: Disassembler Word8
dsRexR = (DisassemblerState -> Maybe Word8)
-> StateT DisassemblerState Parser (Maybe Word8)
forall (m :: * -> *) s a. Monad m => (s -> a) -> StateT s m a
gets DisassemblerState -> Maybe Word8
dsRex StateT DisassemblerState Parser (Maybe Word8)
-> (Maybe Word8 -> Disassembler Word8) -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> (a -> StateT DisassemblerState Parser b)
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Maybe Word8
rex -> Word8 -> Disassembler Word8
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Word8 -> Disassembler Word8) -> Word8 -> Disassembler Word8
forall a b. (a -> b) -> a -> b
$ Int -> Int -> Word8 -> Word8
forall a. (Integral a, Bits a) => Int -> Int -> a -> a
bits Int
2 Int
1 (Word8 -> Maybe Word8 -> Word8
forall a. a -> Maybe a -> a
fromMaybe Word8
0 Maybe Word8
rex)
dsRexX :: Disassembler Word8
dsRexX :: Disassembler Word8
dsRexX = (DisassemblerState -> Maybe Word8)
-> StateT DisassemblerState Parser (Maybe Word8)
forall (m :: * -> *) s a. Monad m => (s -> a) -> StateT s m a
gets DisassemblerState -> Maybe Word8
dsRex StateT DisassemblerState Parser (Maybe Word8)
-> (Maybe Word8 -> Disassembler Word8) -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> (a -> StateT DisassemblerState Parser b)
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Maybe Word8
rex -> Word8 -> Disassembler Word8
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Word8 -> Disassembler Word8) -> Word8 -> Disassembler Word8
forall a b. (a -> b) -> a -> b
$ Int -> Int -> Word8 -> Word8
forall a. (Integral a, Bits a) => Int -> Int -> a -> a
bits Int
1 Int
1 (Word8 -> Maybe Word8 -> Word8
forall a. a -> Maybe a -> a
fromMaybe Word8
0 Maybe Word8
rex)
dsRexB :: Disassembler Word8
dsRexB :: Disassembler Word8
dsRexB = (DisassemblerState -> Maybe Word8)
-> StateT DisassemblerState Parser (Maybe Word8)
forall (m :: * -> *) s a. Monad m => (s -> a) -> StateT s m a
gets DisassemblerState -> Maybe Word8
dsRex StateT DisassemblerState Parser (Maybe Word8)
-> (Maybe Word8 -> Disassembler Word8) -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> (a -> StateT DisassemblerState Parser b)
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Maybe Word8
rex -> Word8 -> Disassembler Word8
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Word8 -> Disassembler Word8) -> Word8 -> Disassembler Word8
forall a b. (a -> b) -> a -> b
$ Int -> Int -> Word8 -> Word8
forall a. (Integral a, Bits a) => Int -> Int -> a -> a
bits Int
0 Int
1 (Word8 -> Maybe Word8 -> Word8
forall a. a -> Maybe a -> a
fromMaybe Word8
0 Maybe Word8
rex)

dsSeg :: Disassembler (Maybe SReg)
dsSeg :: StateT DisassemblerState Parser (Maybe SReg)
dsSeg = (DisassemblerState -> Maybe SReg)
-> StateT DisassemblerState Parser (Maybe SReg)
forall (m :: * -> *) s a. Monad m => (s -> a) -> StateT s m a
gets DisassemblerState -> Maybe SReg
dsSegOverride

-- dsA32 ds = PrefixA32 `elem` (dsPfx ds)
-- dsRep ds = PrefixRep `elem` (dsPfx ds)
-- dsSeg ds = listToMaybe (catMaybes (map (\p -> case p of (PrefixSeg s) -> Just s; _ -> Nothing) (dsPfx ds)))

modrm :: Disassembler ()
modrm :: Disassembler ()
modrm = do
    Word8
val      <- (Parser ByteString Word8 -> Disassembler Word8
forall (m :: * -> *) a.
Monad m =>
m a -> StateT DisassemblerState m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (Parser ByteString Word8 -> Disassembler Word8)
-> Parser ByteString Word8 -> Disassembler Word8
forall a b. (a -> b) -> a -> b
$ Parser ByteString Word8
anyWord8) Disassembler Word8 -> Disassembler () -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Int -> Disassembler ()
adv Int
1
    Int
aWidth   <- (\Bool
x -> if Bool
x then Int
32 :: Int else Int
64 :: Int) (Bool -> Int)
-> StateT DisassemblerState Parser Bool
-> StateT DisassemblerState Parser Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT DisassemblerState Parser Bool
dsA32
    Maybe Word8
rex      <- (DisassemblerState -> Maybe Word8)
-> StateT DisassemblerState Parser (Maybe Word8)
forall (m :: * -> *) s a. Monad m => (s -> a) -> StateT s m a
gets DisassemblerState -> Maybe Word8
dsRex
    Word8
rexR     <- Disassembler Word8
dsRexR
    Word8
rexX     <- Disassembler Word8
dsRexX
    Word8
rexB     <- Disassembler Word8
dsRexB
    Int
opWidth  <- (DisassemblerState -> Int) -> StateT DisassemblerState Parser Int
forall (m :: * -> *) s a. Monad m => (s -> a) -> StateT s m a
gets DisassemblerState -> Int
dsOpWidth
    Maybe SReg
so       <- StateT DisassemblerState Parser (Maybe SReg)
dsSeg
    let b'mod :: Word8
b'mod = Int -> Int -> Word8 -> Word8
forall a. (Integral a, Bits a) => Int -> Int -> a -> a
bits Int
6 Int
2 Word8
val
        b'reg :: Word8
b'reg = Int -> Int -> Word8 -> Word8
forall a. (Integral a, Bits a) => Int -> Int -> a -> a
bits Int
3 Int
3 Word8
val
        b'rm :: Word8
b'rm  = Int -> Int -> Word8 -> Word8
forall a. (Integral a, Bits a) => Int -> Int -> a -> a
bits Int
0 Int
3 Word8
val
        hasSib :: Bool
hasSib = (Word8
b'mod Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
/= Word8
3 Bool -> Bool -> Bool
&& Word8
b'rm Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
4)
        dispSize :: Maybe Integer
dispSize = case (Word8
b'mod, Word8
b'rm) of
            (Word8
0,Word8
5) -> Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
32
            (Word8
1,Word8
_) -> Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
8
            (Word8
2,Word8
_) -> Integer -> Maybe Integer
forall a. a -> Maybe a
Just Integer
32
            (Word8, Word8)
_     -> Maybe Integer
forall a. Maybe a
Nothing
      in do
        ((Register, Register, Word8)
sib,Maybe Integer
dispSize') <- if Bool
hasSib then (Word8
-> Maybe Integer
-> Maybe Word8
-> Word8
-> Word8
-> Int
-> Word8
-> ((Register, Register, Word8), Maybe Integer)
forall {a} {a} {c}.
(Eq a, Num a, Num a, Num c) =>
a
-> Maybe a
-> Maybe Word8
-> Word8
-> Word8
-> Int
-> Word8
-> ((Register, Register, c), Maybe a)
parseSib Word8
b'mod Maybe Integer
dispSize Maybe Word8
rex Word8
rexB Word8
rexX Int
aWidth) (Word8 -> ((Register, Register, Word8), Maybe Integer))
-> Disassembler Word8
-> StateT
     DisassemblerState
     Parser
     ((Register, Register, Word8), Maybe Integer)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Disassembler Word8
getWord8
                                     else ((Register, Register, Word8), Maybe Integer)
-> StateT
     DisassemblerState
     Parser
     ((Register, Register, Word8), Maybe Integer)
forall a. a -> StateT DisassemblerState Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return ((Register
RegNone,Register
RegNone,Word8
0),Maybe Integer
dispSize)
        Int
disp <- case Maybe Integer
dispSize' of
                    Just Integer
8 -> Int8 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int8 -> Int)
-> StateT DisassemblerState Parser Int8
-> StateT DisassemblerState Parser Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT DisassemblerState Parser Int8
getInt8
                    Just Integer
32 -> Int32 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int32 -> Int)
-> StateT DisassemblerState Parser Int32
-> StateT DisassemblerState Parser Int
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT DisassemblerState Parser Int32
getInt32le
                    Maybe Integer
_  -> Int -> StateT DisassemblerState Parser Int
forall a. a -> StateT DisassemblerState Parser a
forall (m :: * -> *) a. Monad m => a -> m a
return Int
0
        let rm :: Int -> (Word8 -> Register) -> Operand
rm = case (Word8
b'mod, Word8
b'rm) of
                (Word8
3,Word8
_) -> \Int
ow Word8 -> Register
sr -> Register -> Operand
Op_Reg (Word8 -> Register
sr Word8
b'rm)
                (Word8
0,Word8
5) -> \Int
ow Word8 -> Register
sr -> BitSize
-> BitSize
-> Register
-> Register
-> Word8
-> Int
-> Maybe SReg
-> Operand
Op_Mem (Int -> BitSize
BitSize Int
ow) (Int -> BitSize
BitSize Int
aWidth) ((if Int
aWidth Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
64 then GPR -> Register
Reg64 else GPR -> Register
Reg32) GPR
RIP) Register
RegNone Word8
0 Int
disp Maybe SReg
so
                (Word8
0,Word8
4) -> \Int
ow Word8 -> Register
sr -> let (Register
br, Register
ir, Word8
sc) = (Register, Register, Word8)
sib in BitSize
-> BitSize
-> Register
-> Register
-> Word8
-> Int
-> Maybe SReg
-> Operand
Op_Mem (Int -> BitSize
BitSize Int
ow) (Int -> BitSize
BitSize Int
aWidth) Register
br Register
ir Word8
sc Int
disp Maybe SReg
so
                (Word8
1,Word8
4) -> \Int
ow Word8 -> Register
sr -> let (Register
br, Register
ir, Word8
sc) = (Register, Register, Word8)
sib in BitSize
-> BitSize
-> Register
-> Register
-> Word8
-> Int
-> Maybe SReg
-> Operand
Op_Mem (Int -> BitSize
BitSize Int
ow) (Int -> BitSize
BitSize Int
aWidth) Register
br Register
ir Word8
sc Int
disp Maybe SReg
so
                (Word8
2,Word8
4) -> \Int
ow Word8 -> Register
sr -> let (Register
br, Register
ir, Word8
sc) = (Register, Register, Word8)
sib in BitSize
-> BitSize
-> Register
-> Register
-> Word8
-> Int
-> Maybe SReg
-> Operand
Op_Mem (Int -> BitSize
BitSize Int
ow) (Int -> BitSize
BitSize Int
aWidth) Register
br Register
ir Word8
sc Int
disp Maybe SReg
so
                (Word8
_,Word8
_) -> \Int
ow Word8 -> Register
sr -> BitSize
-> BitSize
-> Register
-> Register
-> Word8
-> Int
-> Maybe SReg
-> Operand
Op_Mem (Int -> BitSize
BitSize Int
ow) (Int -> BitSize
BitSize Int
aWidth) (Int -> Word8 -> Maybe Word8 -> Word8 -> Register
selectreg Int
aWidth Word8
rexB Maybe Word8
rex Word8
b'rm ) Register
RegNone Word8
0 Int
disp Maybe SReg
so
          in
            (DisassemblerState -> DisassemblerState) -> Disassembler ()
forall (m :: * -> *) s. Monad m => (s -> s) -> StateT s m ()
modify ((DisassemblerState -> DisassemblerState) -> Disassembler ())
-> (DisassemblerState -> DisassemblerState) -> Disassembler ()
forall a b. (a -> b) -> a -> b
$ \DisassemblerState
x -> DisassemblerState
x { dsModRM = Just $ ModRM rm b'reg b'mod b'rm }
    where
        getWord8 :: Disassembler Word8
getWord8   = (Parser ByteString Word8 -> Disassembler Word8
forall (m :: * -> *) a.
Monad m =>
m a -> StateT DisassemblerState m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (Parser ByteString Word8 -> Disassembler Word8)
-> Parser ByteString Word8 -> Disassembler Word8
forall a b. (a -> b) -> a -> b
$ Parser ByteString Word8
anyWord8) Disassembler Word8 -> Disassembler () -> Disassembler Word8
forall a b.
StateT DisassemblerState Parser a
-> StateT DisassemblerState Parser b
-> StateT DisassemblerState Parser a
forall (f :: * -> *) a b. Applicative f => f a -> f b -> f a
<* Int -> Disassembler ()
adv Int
1
        getInt8 :: StateT DisassemblerState Parser Int8
getInt8    = (Int -> Disassembler ByteString
readBytes Int
1) Disassembler ByteString
-> (ByteString -> StateT DisassemblerState Parser Int8)
-> StateT DisassemblerState Parser Int8
forall a b.
StateT DisassemblerState Parser a
-> (a -> StateT DisassemblerState Parser b)
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \ByteString
s -> Int8 -> StateT DisassemblerState Parser Int8
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Get Int8 -> ByteString -> Int8
forall a. Get a -> ByteString -> a
G.runGet Get Int8
G.getInt8 (ByteString
s))
        getInt32le :: StateT DisassemblerState Parser Int32
getInt32le = (Int -> Disassembler ByteString
readBytes Int
4) Disassembler ByteString
-> (ByteString -> StateT DisassemblerState Parser Int32)
-> StateT DisassemblerState Parser Int32
forall a b.
StateT DisassemblerState Parser a
-> (a -> StateT DisassemblerState Parser b)
-> StateT DisassemblerState Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \ByteString
s -> Int32 -> StateT DisassemblerState Parser Int32
forall a. a -> StateT DisassemblerState Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Get Int32 -> ByteString -> Int32
forall a. Get a -> ByteString -> a
G.runGet Get Int32
G.getInt32le (ByteString
s))

        parseSib :: a
-> Maybe a
-> Maybe Word8
-> Word8
-> Word8
-> Int
-> Word8
-> ((Register, Register, c), Maybe a)
parseSib a
m Maybe a
dispSize Maybe Word8
rex Word8
rexB Word8
rexX Int
aw Word8
sib = let
                                 br :: Word8
br = (Int -> Int -> Word8 -> Word8
forall a. (Integral a, Bits a) => Int -> Int -> a -> a
bits Int
0 Int
3 Word8
sib)
                                 ir :: Word8
ir = (Int -> Int -> Word8 -> Word8
forall a. (Integral a, Bits a) => Int -> Int -> a -> a
bits Int
3 Int
3 Word8
sib)
                                 ss :: Word8
ss = (Int -> Int -> Word8 -> Word8
forall a. (Integral a, Bits a) => Int -> Int -> a -> a
bits Int
6 Int
2 Word8
sib)
                                 sp :: Register
sp = (case Int
aw of Int
16 -> GPR -> Register
Reg16; Int
32 -> GPR -> Register
Reg32; Int
64 -> GPR -> Register
Reg64) GPR
RSP
                                 breg :: Register
breg = Int -> Word8 -> Maybe Word8 -> Word8 -> Register
selectreg Int
aw Word8
rexB Maybe Word8
rex Word8
br
                                 ireg :: Register
ireg = Int -> Word8 -> Maybe Word8 -> Word8 -> Register
selectreg Int
aw Word8
rexX Maybe Word8
rex Word8
ir
                                 sf :: c
sf = case Word8
ss of { Word8
0 -> c
1; Word8
1 -> c
2; Word8
2 -> c
4; Word8
3 -> c
8 }
                            in case (a
m, Word8
br) of (a
0, Word8
5) -> ((Register
RegNone, if Register
ireg Register -> Register -> Bool
forall a. Eq a => a -> a -> Bool
== Register
sp then Register
RegNone else Register
ireg, c
sf), a -> Maybe a
forall a. a -> Maybe a
Just a
32)
                                               (a, Word8)
_      -> ((Register
breg, if Register
ireg Register -> Register -> Bool
forall a. Eq a => a -> a -> Bool
== Register
sp then Register
RegNone else Register
ireg, c
sf), Maybe a
dispSize)

selectreg :: Int -> Word8 -> Maybe Word8 -> Word8 -> Register
selectreg :: Int -> Word8 -> Maybe Word8 -> Word8 -> Register
selectreg Int
opWidth Word8
rex Maybe Word8
rex' Word8
reg = let
                rvec' :: [GPR]
rvec' = case Word8
rex of
                        Word8
1 -> [GPR
R8, GPR
R9, GPR
R10, GPR
R11, GPR
R12, GPR
R13, GPR
R14, GPR
R15]
                        Word8
0 -> [GPR
RAX, GPR
RCX, GPR
RDX, GPR
RBX, GPR
RSP, GPR
RBP, GPR
RSI, GPR
RDI]
                rvec :: [Register]
rvec = case (Int
opWidth, Maybe Word8
rex') of
                        (Int
8, Just Word8
_)  -> (GPR -> Register) -> [GPR] -> [Register]
forall a b. (a -> b) -> [a] -> [b]
map (\GPR
i -> GPR -> RegHalf -> Register
Reg8 GPR
i RegHalf
HalfL) [GPR]
rvec'
                        (Int
8, Maybe Word8
Nothing) -> [GPR -> RegHalf -> Register
Reg8 GPR
RAX RegHalf
HalfL, GPR -> RegHalf -> Register
Reg8 GPR
RCX RegHalf
HalfL, GPR -> RegHalf -> Register
Reg8 GPR
RDX RegHalf
HalfL, GPR -> RegHalf -> Register
Reg8 GPR
RBX RegHalf
HalfL,
                                         GPR -> RegHalf -> Register
Reg8 GPR
RAX RegHalf
HalfH, GPR -> RegHalf -> Register
Reg8 GPR
RCX RegHalf
HalfH, GPR -> RegHalf -> Register
Reg8 GPR
RDX RegHalf
HalfH, GPR -> RegHalf -> Register
Reg8 GPR
RBX RegHalf
HalfH]
                        (Int
16, Maybe Word8
_) -> (GPR -> Register) -> [GPR] -> [Register]
forall a b. (a -> b) -> [a] -> [b]
map GPR -> Register
Reg16 [GPR]
rvec'
                        (Int
32, Maybe Word8
_) -> (GPR -> Register) -> [GPR] -> [Register]
forall a b. (a -> b) -> [a] -> [b]
map GPR -> Register
Reg32 [GPR]
rvec'
                        (Int
64, Maybe Word8
_) -> (GPR -> Register) -> [GPR] -> [Register]
forall a b. (a -> b) -> [a] -> [b]
map GPR -> Register
Reg64 [GPR]
rvec'
                        (Int, Maybe Word8)
_ -> [Char] -> [Register]
forall a. HasCallStack => [Char] -> a
error([Char] -> [Register]) -> [Char] -> [Register]
forall a b. (a -> b) -> a -> b
$ ([Register], [GPR], Int, Word8, Maybe Word8, Word8) -> [Char]
forall a. Show a => a -> [Char]
show ([Register]
rvec,[GPR]
rvec',Int
opWidth,Word8
rex,Maybe Word8
rex',Word8
reg)
            in [Register]
rvec [Register] -> Int -> Register
forall a. HasCallStack => [a] -> Int -> a
!! (Word8 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word8
reg)

bits :: (Integral a, Bits a) => Int-> Int -> a -> a
bits :: forall a. (Integral a, Bits a) => Int -> Int -> a -> a
bits Int
s Int
l a
i = a -> a
forall a b. (Integral a, Num b) => a -> b
fromIntegral (a -> a) -> a -> a
forall a b. (a -> b) -> a -> b
$ (a
i a -> Int -> a
forall a. Bits a => a -> Int -> a
`shiftR` Int
s) a -> a -> a
forall a. Bits a => a -> a -> a
.&. ((a
1 a -> Int -> a
forall a. Bits a => a -> Int -> a
`shiftL` Int
l) a -> a -> a
forall a. Num a => a -> a -> a
- a
1)

bitTest :: Int -> Maybe Prefix -> Bool
bitTest :: Int -> Maybe Prefix -> Bool
bitTest Int
i Maybe Prefix
v = case Maybe Prefix
v of
                Maybe Prefix
Nothing -> Bool
False
                Just (PrefixRex Word8
n) -> Word8
n Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. (Int -> Word8
forall a. Bits a => Int -> a
bit Int
i) Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
/= Word8
0


data ModRM = ModRM {
        ModRM -> Int -> (Word8 -> Register) -> Operand
modRM_rm :: Int -> (Word8 -> Register) -> Operand
      , ModRM -> Word8
modRM_breg :: Word8
      , ModRM -> Word8
modRM_mod :: Word8
      , ModRM -> Word8
modRM_brm :: Word8
      }