{-# LANGUAGE DeriveGeneric #-}

module Data.X86.Register where

import Data.Size

import qualified Data.Serialize as Cereal hiding (get,put)
import Control.DeepSeq
import GHC.Generics

data Register =
        RegNone
      | Reg8 GPR RegHalf
      | Reg16 GPR
      | Reg32 GPR
      | Reg64 GPR
      | Reg128 SSEReg
      | RegSeg SReg
      | RegFPU FPUReg
      | RegTemp
    deriving (Register -> Register -> Bool
(Register -> Register -> Bool)
-> (Register -> Register -> Bool) -> Eq Register
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Register -> Register -> Bool
== :: Register -> Register -> Bool
$c/= :: Register -> Register -> Bool
/= :: Register -> Register -> Bool
Eq, Eq Register
Eq Register =>
(Register -> Register -> Ordering)
-> (Register -> Register -> Bool)
-> (Register -> Register -> Bool)
-> (Register -> Register -> Bool)
-> (Register -> Register -> Bool)
-> (Register -> Register -> Register)
-> (Register -> Register -> Register)
-> Ord Register
Register -> Register -> Bool
Register -> Register -> Ordering
Register -> Register -> Register
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Register -> Register -> Ordering
compare :: Register -> Register -> Ordering
$c< :: Register -> Register -> Bool
< :: Register -> Register -> Bool
$c<= :: Register -> Register -> Bool
<= :: Register -> Register -> Bool
$c> :: Register -> Register -> Bool
> :: Register -> Register -> Bool
$c>= :: Register -> Register -> Bool
>= :: Register -> Register -> Bool
$cmax :: Register -> Register -> Register
max :: Register -> Register -> Register
$cmin :: Register -> Register -> Register
min :: Register -> Register -> Register
Ord, (forall x. Register -> Rep Register x)
-> (forall x. Rep Register x -> Register) -> Generic Register
forall x. Rep Register x -> Register
forall x. Register -> Rep Register x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Register -> Rep Register x
from :: forall x. Register -> Rep Register x
$cto :: forall x. Rep Register x -> Register
to :: forall x. Rep Register x -> Register
Generic)

instance Show Register where
  show :: Register -> String
show Register
RegNone          = String
"NONE"

  show (Reg8 GPR
RIP RegHalf
HalfL) = String
"IPL"
  show (Reg16 GPR
RIP)      = String
"IP"
  show (Reg32 GPR
RIP)      = String
"EIP"
  show (Reg64 GPR
RIP)      = String
"RIP"

  show (Reg8 GPR
RAX RegHalf
HalfL) = String
"AL"
  show (Reg8 GPR
RAX RegHalf
HalfH) = String
"AH"
  show (Reg16 GPR
RAX)      = String
"AX"
  show (Reg32 GPR
RAX)      = String
"EAX"
  show (Reg64 GPR
RAX)      = String
"RAX"

  show (Reg8 GPR
RBX RegHalf
HalfL) = String
"BL"
  show (Reg8 GPR
RBX RegHalf
HalfH) = String
"BH"
  show (Reg16 GPR
RBX)      = String
"BX"
  show (Reg32 GPR
RBX)      = String
"EBX"
  show (Reg64 GPR
RBX)      = String
"RBX"

  show (Reg8 GPR
RCX RegHalf
HalfL) = String
"CL"
  show (Reg8 GPR
RCX RegHalf
HalfH) = String
"CH"
  show (Reg16 GPR
RCX)      = String
"CX"
  show (Reg32 GPR
RCX)      = String
"ECX"
  show (Reg64 GPR
RCX)      = String
"RCX"

  show (Reg8 GPR
RDX RegHalf
HalfL) = String
"DL"
  show (Reg8 GPR
RDX RegHalf
HalfH) = String
"DH"
  show (Reg16 GPR
RDX)      = String
"DX"
  show (Reg32 GPR
RDX)      = String
"EDX"
  show (Reg64 GPR
RDX)      = String
"RDX"

  show (Reg8 GPR
RSP RegHalf
HalfL) = String
"SPL"
  show (Reg16 GPR
RSP)      = String
"SP"
  show (Reg32 GPR
RSP)      = String
"ESP"
  show (Reg64 GPR
RSP)      = String
"RSP"

  show (Reg8 GPR
RBP RegHalf
HalfL) = String
"BPL"
  show (Reg16 GPR
RBP)      = String
"BP"
  show (Reg32 GPR
RBP)      = String
"EBP"
  show (Reg64 GPR
RBP)      = String
"RBP"

  show (Reg8 GPR
RDI RegHalf
HalfL) = String
"DIL"
  show (Reg16 GPR
RDI)      = String
"DI"
  show (Reg32 GPR
RDI)      = String
"EDI"
  show (Reg64 GPR
RDI)      = String
"RDI"

  show (Reg8 GPR
RSI RegHalf
HalfL) = String
"SIL"
  show (Reg16 GPR
RSI)      = String
"SI"
  show (Reg32 GPR
RSI)      = String
"ESI"
  show (Reg64 GPR
RSI)      = String
"RSI"

  show (Reg8 GPR
R8 RegHalf
HalfL)  = String
"R8B"
  show (Reg16 GPR
R8)       = String
"R8W"
  show (Reg32 GPR
R8)       = String
"R8D"
  show (Reg64 GPR
R8)       = String
"R8"

  show (Reg8 GPR
R9 RegHalf
HalfL)  = String
"R9B"
  show (Reg16 GPR
R9)       = String
"R9W"
  show (Reg32 GPR
R9)       = String
"R9D"
  show (Reg64 GPR
R9)       = String
"R9"

  show (Reg8 GPR
R10 RegHalf
HalfL) = String
"R10B"
  show (Reg16 GPR
R10)      = String
"R10W"
  show (Reg32 GPR
R10)      = String
"R10D"
  show (Reg64 GPR
R10)      = String
"R10"

  show (Reg8 GPR
R11 RegHalf
HalfL) = String
"R11B"
  show (Reg16 GPR
R11)      = String
"R11W"
  show (Reg32 GPR
R11)      = String
"R11D"
  show (Reg64 GPR
R11)      = String
"R11"

  show (Reg8 GPR
R12 RegHalf
HalfL) = String
"R12B"
  show (Reg16 GPR
R12)      = String
"R12W"
  show (Reg32 GPR
R12)      = String
"R12D"
  show (Reg64 GPR
R12)      = String
"R12"

  show (Reg8 GPR
R13 RegHalf
HalfL) = String
"R13B"
  show (Reg16 GPR
R13)      = String
"R13W"
  show (Reg32 GPR
R13)      = String
"R13D"
  show (Reg64 GPR
R13)      = String
"R13"

  show (Reg8 GPR
R14 RegHalf
HalfL) = String
"R14B"
  show (Reg16 GPR
R14)      = String
"R14W"
  show (Reg32 GPR
R14)      = String
"R14D"
  show (Reg64 GPR
R14)      = String
"R14"

  show (Reg8 GPR
R15 RegHalf
HalfL) = String
"R15B"
  show (Reg16 GPR
R15)      = String
"R15W"
  show (Reg32 GPR
R15)      = String
"R15D"
  show (Reg64 GPR
R15)      = String
"R15"

  show (RegSeg SReg
r)       = SReg -> String
forall a. Show a => a -> String
show SReg
r
  show (RegFPU FPUReg
r)       = FPUReg -> String
forall a. Show a => a -> String
show FPUReg
r
  show (Reg128 SSEReg
r)       = SSEReg -> String
forall a. Show a => a -> String
show SSEReg
r
  show (Register
RegTemp)        = String
"TEMP"



data GPR = RAX | RCX | RDX | RBX | RSP | RBP | RSI | RDI | R8 | R9 | R10 | R11 | R12 | R13 | R14 | R15 | RIP
    deriving (Int -> GPR -> ShowS
[GPR] -> ShowS
GPR -> String
(Int -> GPR -> ShowS)
-> (GPR -> String) -> ([GPR] -> ShowS) -> Show GPR
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> GPR -> ShowS
showsPrec :: Int -> GPR -> ShowS
$cshow :: GPR -> String
show :: GPR -> String
$cshowList :: [GPR] -> ShowS
showList :: [GPR] -> ShowS
Show, GPR -> GPR -> Bool
(GPR -> GPR -> Bool) -> (GPR -> GPR -> Bool) -> Eq GPR
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GPR -> GPR -> Bool
== :: GPR -> GPR -> Bool
$c/= :: GPR -> GPR -> Bool
/= :: GPR -> GPR -> Bool
Eq, Eq GPR
Eq GPR =>
(GPR -> GPR -> Ordering)
-> (GPR -> GPR -> Bool)
-> (GPR -> GPR -> Bool)
-> (GPR -> GPR -> Bool)
-> (GPR -> GPR -> Bool)
-> (GPR -> GPR -> GPR)
-> (GPR -> GPR -> GPR)
-> Ord GPR
GPR -> GPR -> Bool
GPR -> GPR -> Ordering
GPR -> GPR -> GPR
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: GPR -> GPR -> Ordering
compare :: GPR -> GPR -> Ordering
$c< :: GPR -> GPR -> Bool
< :: GPR -> GPR -> Bool
$c<= :: GPR -> GPR -> Bool
<= :: GPR -> GPR -> Bool
$c> :: GPR -> GPR -> Bool
> :: GPR -> GPR -> Bool
$c>= :: GPR -> GPR -> Bool
>= :: GPR -> GPR -> Bool
$cmax :: GPR -> GPR -> GPR
max :: GPR -> GPR -> GPR
$cmin :: GPR -> GPR -> GPR
min :: GPR -> GPR -> GPR
Ord, (forall x. GPR -> Rep GPR x)
-> (forall x. Rep GPR x -> GPR) -> Generic GPR
forall x. Rep GPR x -> GPR
forall x. GPR -> Rep GPR x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. GPR -> Rep GPR x
from :: forall x. GPR -> Rep GPR x
$cto :: forall x. Rep GPR x -> GPR
to :: forall x. Rep GPR x -> GPR
Generic)

data SReg = ES | CS | SS | DS | FS | GS | SR6 | SR7
    deriving (Int -> SReg -> ShowS
[SReg] -> ShowS
SReg -> String
(Int -> SReg -> ShowS)
-> (SReg -> String) -> ([SReg] -> ShowS) -> Show SReg
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SReg -> ShowS
showsPrec :: Int -> SReg -> ShowS
$cshow :: SReg -> String
show :: SReg -> String
$cshowList :: [SReg] -> ShowS
showList :: [SReg] -> ShowS
Show, SReg -> SReg -> Bool
(SReg -> SReg -> Bool) -> (SReg -> SReg -> Bool) -> Eq SReg
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SReg -> SReg -> Bool
== :: SReg -> SReg -> Bool
$c/= :: SReg -> SReg -> Bool
/= :: SReg -> SReg -> Bool
Eq, Eq SReg
Eq SReg =>
(SReg -> SReg -> Ordering)
-> (SReg -> SReg -> Bool)
-> (SReg -> SReg -> Bool)
-> (SReg -> SReg -> Bool)
-> (SReg -> SReg -> Bool)
-> (SReg -> SReg -> SReg)
-> (SReg -> SReg -> SReg)
-> Ord SReg
SReg -> SReg -> Bool
SReg -> SReg -> Ordering
SReg -> SReg -> SReg
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: SReg -> SReg -> Ordering
compare :: SReg -> SReg -> Ordering
$c< :: SReg -> SReg -> Bool
< :: SReg -> SReg -> Bool
$c<= :: SReg -> SReg -> Bool
<= :: SReg -> SReg -> Bool
$c> :: SReg -> SReg -> Bool
> :: SReg -> SReg -> Bool
$c>= :: SReg -> SReg -> Bool
>= :: SReg -> SReg -> Bool
$cmax :: SReg -> SReg -> SReg
max :: SReg -> SReg -> SReg
$cmin :: SReg -> SReg -> SReg
min :: SReg -> SReg -> SReg
Ord, (forall x. SReg -> Rep SReg x)
-> (forall x. Rep SReg x -> SReg) -> Generic SReg
forall x. Rep SReg x -> SReg
forall x. SReg -> Rep SReg x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SReg -> Rep SReg x
from :: forall x. SReg -> Rep SReg x
$cto :: forall x. Rep SReg x -> SReg
to :: forall x. Rep SReg x -> SReg
Generic)

data FPUReg = ST0 | ST1 | ST2 | ST3 | ST4 | ST5 | ST6 | ST7
    deriving (Int -> FPUReg -> ShowS
[FPUReg] -> ShowS
FPUReg -> String
(Int -> FPUReg -> ShowS)
-> (FPUReg -> String) -> ([FPUReg] -> ShowS) -> Show FPUReg
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FPUReg -> ShowS
showsPrec :: Int -> FPUReg -> ShowS
$cshow :: FPUReg -> String
show :: FPUReg -> String
$cshowList :: [FPUReg] -> ShowS
showList :: [FPUReg] -> ShowS
Show, FPUReg -> FPUReg -> Bool
(FPUReg -> FPUReg -> Bool)
-> (FPUReg -> FPUReg -> Bool) -> Eq FPUReg
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: FPUReg -> FPUReg -> Bool
== :: FPUReg -> FPUReg -> Bool
$c/= :: FPUReg -> FPUReg -> Bool
/= :: FPUReg -> FPUReg -> Bool
Eq, Eq FPUReg
Eq FPUReg =>
(FPUReg -> FPUReg -> Ordering)
-> (FPUReg -> FPUReg -> Bool)
-> (FPUReg -> FPUReg -> Bool)
-> (FPUReg -> FPUReg -> Bool)
-> (FPUReg -> FPUReg -> Bool)
-> (FPUReg -> FPUReg -> FPUReg)
-> (FPUReg -> FPUReg -> FPUReg)
-> Ord FPUReg
FPUReg -> FPUReg -> Bool
FPUReg -> FPUReg -> Ordering
FPUReg -> FPUReg -> FPUReg
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: FPUReg -> FPUReg -> Ordering
compare :: FPUReg -> FPUReg -> Ordering
$c< :: FPUReg -> FPUReg -> Bool
< :: FPUReg -> FPUReg -> Bool
$c<= :: FPUReg -> FPUReg -> Bool
<= :: FPUReg -> FPUReg -> Bool
$c> :: FPUReg -> FPUReg -> Bool
> :: FPUReg -> FPUReg -> Bool
$c>= :: FPUReg -> FPUReg -> Bool
>= :: FPUReg -> FPUReg -> Bool
$cmax :: FPUReg -> FPUReg -> FPUReg
max :: FPUReg -> FPUReg -> FPUReg
$cmin :: FPUReg -> FPUReg -> FPUReg
min :: FPUReg -> FPUReg -> FPUReg
Ord, (forall x. FPUReg -> Rep FPUReg x)
-> (forall x. Rep FPUReg x -> FPUReg) -> Generic FPUReg
forall x. Rep FPUReg x -> FPUReg
forall x. FPUReg -> Rep FPUReg x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. FPUReg -> Rep FPUReg x
from :: forall x. FPUReg -> Rep FPUReg x
$cto :: forall x. Rep FPUReg x -> FPUReg
to :: forall x. Rep FPUReg x -> FPUReg
Generic)

data SSEReg = XMM0 | XMM1 | XMM2 | XMM3 | XMM4 | XMM5 | XMM6 | XMM7 | XMM8 | XMM9 | XMM10 | XMM11 | XMM12 | XMM13 | XMM14 | XMM15
    deriving (Int -> SSEReg -> ShowS
[SSEReg] -> ShowS
SSEReg -> String
(Int -> SSEReg -> ShowS)
-> (SSEReg -> String) -> ([SSEReg] -> ShowS) -> Show SSEReg
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SSEReg -> ShowS
showsPrec :: Int -> SSEReg -> ShowS
$cshow :: SSEReg -> String
show :: SSEReg -> String
$cshowList :: [SSEReg] -> ShowS
showList :: [SSEReg] -> ShowS
Show, SSEReg -> SSEReg -> Bool
(SSEReg -> SSEReg -> Bool)
-> (SSEReg -> SSEReg -> Bool) -> Eq SSEReg
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SSEReg -> SSEReg -> Bool
== :: SSEReg -> SSEReg -> Bool
$c/= :: SSEReg -> SSEReg -> Bool
/= :: SSEReg -> SSEReg -> Bool
Eq, Eq SSEReg
Eq SSEReg =>
(SSEReg -> SSEReg -> Ordering)
-> (SSEReg -> SSEReg -> Bool)
-> (SSEReg -> SSEReg -> Bool)
-> (SSEReg -> SSEReg -> Bool)
-> (SSEReg -> SSEReg -> Bool)
-> (SSEReg -> SSEReg -> SSEReg)
-> (SSEReg -> SSEReg -> SSEReg)
-> Ord SSEReg
SSEReg -> SSEReg -> Bool
SSEReg -> SSEReg -> Ordering
SSEReg -> SSEReg -> SSEReg
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: SSEReg -> SSEReg -> Ordering
compare :: SSEReg -> SSEReg -> Ordering
$c< :: SSEReg -> SSEReg -> Bool
< :: SSEReg -> SSEReg -> Bool
$c<= :: SSEReg -> SSEReg -> Bool
<= :: SSEReg -> SSEReg -> Bool
$c> :: SSEReg -> SSEReg -> Bool
> :: SSEReg -> SSEReg -> Bool
$c>= :: SSEReg -> SSEReg -> Bool
>= :: SSEReg -> SSEReg -> Bool
$cmax :: SSEReg -> SSEReg -> SSEReg
max :: SSEReg -> SSEReg -> SSEReg
$cmin :: SSEReg -> SSEReg -> SSEReg
min :: SSEReg -> SSEReg -> SSEReg
Ord, (forall x. SSEReg -> Rep SSEReg x)
-> (forall x. Rep SSEReg x -> SSEReg) -> Generic SSEReg
forall x. Rep SSEReg x -> SSEReg
forall x. SSEReg -> Rep SSEReg x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SSEReg -> Rep SSEReg x
from :: forall x. SSEReg -> Rep SSEReg x
$cto :: forall x. Rep SSEReg x -> SSEReg
to :: forall x. Rep SSEReg x -> SSEReg
Generic)

data RegHalf = HalfL | HalfH
    deriving (Int -> RegHalf -> ShowS
[RegHalf] -> ShowS
RegHalf -> String
(Int -> RegHalf -> ShowS)
-> (RegHalf -> String) -> ([RegHalf] -> ShowS) -> Show RegHalf
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RegHalf -> ShowS
showsPrec :: Int -> RegHalf -> ShowS
$cshow :: RegHalf -> String
show :: RegHalf -> String
$cshowList :: [RegHalf] -> ShowS
showList :: [RegHalf] -> ShowS
Show, RegHalf -> RegHalf -> Bool
(RegHalf -> RegHalf -> Bool)
-> (RegHalf -> RegHalf -> Bool) -> Eq RegHalf
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: RegHalf -> RegHalf -> Bool
== :: RegHalf -> RegHalf -> Bool
$c/= :: RegHalf -> RegHalf -> Bool
/= :: RegHalf -> RegHalf -> Bool
Eq, Eq RegHalf
Eq RegHalf =>
(RegHalf -> RegHalf -> Ordering)
-> (RegHalf -> RegHalf -> Bool)
-> (RegHalf -> RegHalf -> Bool)
-> (RegHalf -> RegHalf -> Bool)
-> (RegHalf -> RegHalf -> Bool)
-> (RegHalf -> RegHalf -> RegHalf)
-> (RegHalf -> RegHalf -> RegHalf)
-> Ord RegHalf
RegHalf -> RegHalf -> Bool
RegHalf -> RegHalf -> Ordering
RegHalf -> RegHalf -> RegHalf
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: RegHalf -> RegHalf -> Ordering
compare :: RegHalf -> RegHalf -> Ordering
$c< :: RegHalf -> RegHalf -> Bool
< :: RegHalf -> RegHalf -> Bool
$c<= :: RegHalf -> RegHalf -> Bool
<= :: RegHalf -> RegHalf -> Bool
$c> :: RegHalf -> RegHalf -> Bool
> :: RegHalf -> RegHalf -> Bool
$c>= :: RegHalf -> RegHalf -> Bool
>= :: RegHalf -> RegHalf -> Bool
$cmax :: RegHalf -> RegHalf -> RegHalf
max :: RegHalf -> RegHalf -> RegHalf
$cmin :: RegHalf -> RegHalf -> RegHalf
min :: RegHalf -> RegHalf -> RegHalf
Ord, (forall x. RegHalf -> Rep RegHalf x)
-> (forall x. Rep RegHalf x -> RegHalf) -> Generic RegHalf
forall x. Rep RegHalf x -> RegHalf
forall x. RegHalf -> Rep RegHalf x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. RegHalf -> Rep RegHalf x
from :: forall x. RegHalf -> Rep RegHalf x
$cto :: forall x. Rep RegHalf x -> RegHalf
to :: forall x. Rep RegHalf x -> RegHalf
Generic)



real_reg :: Register -> Register
real_reg (Reg8 GPR
r RegHalf
_) = GPR -> Register
Reg64 GPR
r
real_reg (Reg16 GPR
r)  = GPR -> Register
Reg64 GPR
r
real_reg (Reg32 GPR
r)  = GPR -> Register
Reg64 GPR
r
real_reg Register
r          = Register
r

regSize :: Register -> ByteSize
regSize (Reg8 GPR
_ RegHalf
_) = Int -> ByteSize
ByteSize Int
1
regSize (Reg16 GPR
_) = Int -> ByteSize
ByteSize Int
2
regSize (Reg32 GPR
_) = Int -> ByteSize
ByteSize Int
4
regSize (Reg64 GPR
_) = Int -> ByteSize
ByteSize Int
8
regSize (Reg128 SSEReg
_) = Int -> ByteSize
ByteSize Int
16
regSize (RegSeg SReg
_) = Int -> ByteSize
ByteSize Int
8
regSize (Register
RegTemp) = Int -> ByteSize
ByteSize Int
8
regSize (RegFPU FPUReg
_) = Int -> ByteSize
ByteSize Int
10
regSize Register
r = String -> ByteSize
forall a. HasCallStack => String -> a
error (String -> ByteSize) -> String -> ByteSize
forall a b. (a -> b) -> a -> b
$ Register -> String
forall a. Show a => a -> String
show Register
r



instance Cereal.Serialize SReg
instance Cereal.Serialize FPUReg
instance Cereal.Serialize SSEReg
instance Cereal.Serialize GPR
instance Cereal.Serialize RegHalf
instance Cereal.Serialize Register

instance NFData SReg
instance NFData FPUReg
instance NFData SSEReg
instance NFData GPR
instance NFData RegHalf
instance NFData Register