CodeGen.X86.Asm

Documentation

everyNth :: Int -> [a] -> [[a]]

showNibble :: (Integral a, Bits a) => Int -> a -> Char

showByte :: (Integral a, Bits a) => a -> [Char]

showHex' :: (Integral a, Show a) => a -> [Char]

pattern Integral :: (Integral a, Integral b, Bits a, Bits b) => b -> a

type Bytes = [Word8]

class HasBytes a where

Methods

toBytes :: a -> Bytes

Instances

HasBytes Int16

Defined in CodeGen.X86.Asm

Methods

toBytes :: Int16 -> Bytes

HasBytes Int32

Defined in CodeGen.X86.Asm

Methods

toBytes :: Int32 -> Bytes

HasBytes Int64

Defined in CodeGen.X86.Asm

Methods

toBytes :: Int64 -> Bytes

HasBytes Int8

Defined in CodeGen.X86.Asm

Methods

toBytes :: Int8 -> Bytes

HasBytes Word16

Defined in CodeGen.X86.Asm

Methods

toBytes :: Word16 -> Bytes

HasBytes Word32

Defined in CodeGen.X86.Asm

Methods

toBytes :: Word32 -> Bytes

HasBytes Word64

Defined in CodeGen.X86.Asm

Methods

toBytes :: Word64 -> Bytes

HasBytes Word8

Defined in CodeGen.X86.Asm

Methods

toBytes :: Word8 -> Bytes

HasBytes CString

Defined in CodeGen.X86.Utils

Methods

toBytes :: CString -> Bytes

data Size

The size of a register (in bits)

Constructors

S1

S8

S16

S32

S64

S128

Instances

Show Size

Defined in CodeGen.X86.Asm

Methods

showsPrec :: Int -> Size -> ShowS

show :: Size -> String

showList :: [Size] -> ShowS

Eq Size

Defined in CodeGen.X86.Asm

Methods

(==) :: Size -> Size -> Bool

(/=) :: Size -> Size -> Bool

Ord Size

Defined in CodeGen.X86.Asm

Methods

compare :: Size -> Size -> Ordering

(<) :: Size -> Size -> Bool

(<=) :: Size -> Size -> Bool

(>) :: Size -> Size -> Bool

(>=) :: Size -> Size -> Bool

max :: Size -> Size -> Size

min :: Size -> Size -> Size

mkSize :: (Eq a, Num a) => a -> Size

sizeLen :: Num a => Size -> a

class HasSize a where

Methods

size :: a -> Size

Instances

HasSize Int16

Defined in CodeGen.X86.Asm

Methods

size :: Int16 -> Size

HasSize Int32

Defined in CodeGen.X86.Asm

Methods

size :: Int32 -> Size

HasSize Int64

Defined in CodeGen.X86.Asm

Methods

size :: Int64 -> Size

HasSize Int8

Defined in CodeGen.X86.Asm

Methods

size :: Int8 -> Size

HasSize Word16

Defined in CodeGen.X86.Asm

Methods

size :: Word16 -> Size

HasSize Word32

Defined in CodeGen.X86.Asm

Methods

size :: Word32 -> Size

HasSize Word64

Defined in CodeGen.X86.Asm

Methods

size :: Word64 -> Size

HasSize Word8

Defined in CodeGen.X86.Asm

Methods

size :: Word8 -> Size

IsSize s => HasSize (Addr s)

Defined in CodeGen.X86.Asm

Methods

size :: Addr s -> Size

IsSize s => HasSize (Address s)

Defined in CodeGen.X86.Asm

Methods

size :: Address s -> Size

IsSize s => HasSize (BaseReg s)

Defined in CodeGen.X86.Asm

Methods

size :: BaseReg s -> Size

IsSize s => HasSize (IndexReg s)

Defined in CodeGen.X86.Asm

Methods

size :: IndexReg s -> Size

IsSize s => HasSize (Reg s)

Defined in CodeGen.X86.Asm

Methods

size :: Reg s -> Size

HasSize (SSize s)

Defined in CodeGen.X86.Asm

Methods

size :: SSize s -> Size

IsSize s => HasSize (Operand a s)

Defined in CodeGen.X86.Asm

Methods

size :: Operand a s -> Size

data SSize (s :: Size) where

Singleton type for size

Constructors

SSize1 :: SSize S1

SSize8 :: SSize S8

SSize16 :: SSize S16

SSize32 :: SSize S32

SSize64 :: SSize S64

SSize128 :: SSize S128

Instances

HasSize (SSize s)

Defined in CodeGen.X86.Asm

Methods

size :: SSize s -> Size

class IsSize (s :: Size) where

Methods

ssize :: SSize s

Instances

IsSize 'S1

Defined in CodeGen.X86.Asm

Methods

ssize :: SSize 'S1

IsSize 'S128

Defined in CodeGen.X86.Asm

Methods

ssize :: SSize 'S128

IsSize 'S16

Defined in CodeGen.X86.Asm

Methods

ssize :: SSize 'S16

IsSize 'S32

Defined in CodeGen.X86.Asm

Methods

ssize :: SSize 'S32

IsSize 'S64

Defined in CodeGen.X86.Asm

Methods

ssize :: SSize 'S64

IsSize 'S8

Defined in CodeGen.X86.Asm

Methods

ssize :: SSize 'S8

data EqT s s' where

Constructors

Refl :: EqT s s

sizeEqCheck :: forall s s' f g. (IsSize s, IsSize s') => f s -> g s' -> Maybe (EqT s s')

newtype Scale

The scaling of an index. (replace with Size?)

Constructors

Scale Word8

Instances

Eq Scale

Defined in CodeGen.X86.Asm

Methods

(==) :: Scale -> Scale -> Bool

(/=) :: Scale -> Scale -> Bool

s1 :: Scale

s2 :: Scale

s4 :: Scale

s8 :: Scale

toScale :: (Eq a, Num a) => a -> Scale

scaleFactor :: Num a => Scale -> a

data Operand :: Access -> Size -> * where

An operand can be an immediate, a register, a memory address or RIP-relative (memory address relative to the instruction pointer)

Constructors

ImmOp :: Immediate Int64 -> Operand R s

RegOp :: Reg s -> Operand rw s

MemOp :: IsSize s' => Addr s' -> Operand rw s

IPMemOp :: Immediate Int32 -> Operand rw s

Instances

FromReg (Operand r)

Defined in CodeGen.X86.Asm

Methods

fromReg :: forall (s :: Size). Reg s -> Operand r s

rw ~ 'R => Num (Operand rw s)

Defined in CodeGen.X86.Asm

Methods

(+) :: Operand rw s -> Operand rw s -> Operand rw s

(-) :: Operand rw s -> Operand rw s -> Operand rw s

(*) :: Operand rw s -> Operand rw s -> Operand rw s

negate :: Operand rw s -> Operand rw s

abs :: Operand rw s -> Operand rw s

signum :: Operand rw s -> Operand rw s

fromInteger :: Integer -> Operand rw s

IsSize s => Show (Operand a s)

Defined in CodeGen.X86.Asm

Methods

showsPrec :: Int -> Operand a s -> ShowS

show :: Operand a s -> String

showList :: [Operand a s] -> ShowS

IsSize s => HasSize (Operand a s)

Defined in CodeGen.X86.Asm

Methods

size :: Operand a s -> Size

addr :: IsSize s => Address s -> Operand rw s'

addr8 :: IsSize s => Address s -> Operand rw S8

addr with specialized type

addr16 :: IsSize s => Address s -> Operand rw S16

addr with specialized type

addr32 :: IsSize s => Address s -> Operand rw S32

addr with specialized type

addr64 :: IsSize s => Address s -> Operand rw S64

addr with specialized type

data Immediate a

Constructors

Immediate a

LabelRelValue Size Label

Instances

Show a => Show (Immediate a)

Defined in CodeGen.X86.Asm

Methods

showsPrec :: Int -> Immediate a -> ShowS

show :: Immediate a -> String

showList :: [Immediate a] -> ShowS

newtype Label

Constructors

Label

Fields

• unLabel :: Int

Instances

Show Label

Defined in CodeGen.X86.Asm

Methods

showsPrec :: Int -> Label -> ShowS

show :: Label -> String

showList :: [Label] -> ShowS

data Access

Operand access modes

Constructors

R

readable operand

RW

readable and writeable operand

data Reg :: Size -> * where

A register.

Constructors

NormalReg :: Word8 -> Reg s

HighReg :: Word8 -> Reg S8

XMM :: Word8 -> Reg S128

Instances

FromReg Reg

Defined in CodeGen.X86.Asm

Methods

fromReg :: forall (s :: Size). Reg s -> Reg s

IsSize s => Show (Reg s)

Defined in CodeGen.X86.Asm

Methods

showsPrec :: Int -> Reg s -> ShowS

show :: Reg s -> String

showList :: [Reg s] -> ShowS

Eq (Reg s)

Defined in CodeGen.X86.Asm

Methods

(==) :: Reg s -> Reg s -> Bool

(/=) :: Reg s -> Reg s -> Bool

Ord (Reg s)

Defined in CodeGen.X86.Asm

Methods

compare :: Reg s -> Reg s -> Ordering

(<) :: Reg s -> Reg s -> Bool

(<=) :: Reg s -> Reg s -> Bool

(>) :: Reg s -> Reg s -> Bool

(>=) :: Reg s -> Reg s -> Bool

max :: Reg s -> Reg s -> Reg s

min :: Reg s -> Reg s -> Reg s

IsSize s => HasSize (BaseReg s)

Defined in CodeGen.X86.Asm

Methods

size :: BaseReg s -> Size

IsSize s => HasSize (Reg s)

Defined in CodeGen.X86.Asm

Methods

size :: Reg s -> Size

data Addr s

A (relative) address is made up base a base register, a displacement, and a (scaled) index. For example in [eax+4*ecx+20] the base register is eax, the displacement is 20 and the index is 4*ecx.

Constructors

Addr

Fields

• baseReg :: BaseReg s
• displacement :: Displacement
• indexReg :: IndexReg s

Instances

Monoid (Addr s)

Defined in CodeGen.X86.Asm

Methods

mempty :: Addr s

mappend :: Addr s -> Addr s -> Addr s

mconcat :: [Addr s] -> Addr s

Semigroup (Addr s)

Defined in CodeGen.X86.Asm

Methods

(<>) :: Addr s -> Addr s -> Addr s

sconcat :: NonEmpty (Addr s) -> Addr s

stimes :: Integral b => b -> Addr s -> Addr s

IsSize s => Show (Addr s)

Defined in CodeGen.X86.Asm

Methods

showsPrec :: Int -> Addr s -> ShowS

show :: Addr s -> String

showList :: [Addr s] -> ShowS

Eq (Addr s)

Defined in CodeGen.X86.Asm

Methods

(==) :: Addr s -> Addr s -> Bool

(/=) :: Addr s -> Addr s -> Bool

IsSize s => HasSize (Addr s)

Defined in CodeGen.X86.Asm

Methods

size :: Addr s -> Size

type BaseReg s = Maybe (Reg s)

data IndexReg s

Constructors

NoIndex

IndexReg Scale (Reg s)

Instances

Monoid (IndexReg s)

Defined in CodeGen.X86.Asm

Methods

mempty :: IndexReg s

mappend :: IndexReg s -> IndexReg s -> IndexReg s

mconcat :: [IndexReg s] -> IndexReg s

Semigroup (IndexReg s)

Defined in CodeGen.X86.Asm

Methods

(<>) :: IndexReg s -> IndexReg s -> IndexReg s

sconcat :: NonEmpty (IndexReg s) -> IndexReg s

stimes :: Integral b => b -> IndexReg s -> IndexReg s

Eq (IndexReg s)

Defined in CodeGen.X86.Asm

Methods

(==) :: IndexReg s -> IndexReg s -> Bool

(/=) :: IndexReg s -> IndexReg s -> Bool

IsSize s => HasSize (IndexReg s)

Defined in CodeGen.X86.Asm

Methods

size :: IndexReg s -> Size

type Displacement = Maybe Int32

pattern NoDisp :: Maybe a

pattern Disp :: a -> Maybe a

ipRel :: Label -> Operand rw s

intruction pointer (RIP) relative address

ipRelValue :: forall {s :: Size}. Label -> Operand 'R s

ipRel8 :: Label -> Operand rw S8

ipRel with specialized type

base :: Reg s -> Addr s

index :: Scale -> Reg s -> Addr s

index' :: Int -> Reg s -> Addr s

index1 :: forall {s :: Size}. Reg s -> Addr s

index2 :: forall {s :: Size}. Reg s -> Addr s

index4 :: forall {s :: Size}. Reg s -> Addr s

index8 :: forall {s :: Size}. Reg s -> Addr s

disp :: (Bits a, Integral a) => a -> Addr s

data Address :: Size -> * where

Constructors

Address :: [(Int, Reg s)] -> Int -> Address s

Instances

FromReg Address

Defined in CodeGen.X86.Asm

Methods

fromReg :: forall (s :: Size). Reg s -> Address s

Num (Address s)

Defined in CodeGen.X86.Asm

Methods

(+) :: Address s -> Address s -> Address s

(-) :: Address s -> Address s -> Address s

(*) :: Address s -> Address s -> Address s

negate :: Address s -> Address s

abs :: Address s -> Address s

signum :: Address s -> Address s

fromInteger :: Integer -> Address s

IsSize s => HasSize (Address s)

Defined in CodeGen.X86.Asm

Methods

size :: Address s -> Size

scaleAddress :: (Int -> Int) -> Address s -> Address s

makeAddr :: Address s -> Addr s

class FromReg c where

Methods

fromReg :: Reg s -> c s

Instances

FromReg Address

Defined in CodeGen.X86.Asm

Methods

fromReg :: forall (s :: Size). Reg s -> Address s

FromReg Reg

Defined in CodeGen.X86.Asm

Methods

fromReg :: forall (s :: Size). Reg s -> Reg s

FromReg (Operand r)

Defined in CodeGen.X86.Asm

Methods

fromReg :: forall (s :: Size). Reg s -> Operand r s

reg :: forall {c} {s :: Size}. FromReg c => Word8 -> c s

rax :: FromReg c => c S64

rcx :: FromReg c => c S64

rdx :: FromReg c => c S64

rbx :: FromReg c => c S64

rsp :: FromReg c => c S64

rbp :: FromReg c => c S64

rsi :: FromReg c => c S64

rdi :: FromReg c => c S64

r8 :: FromReg c => c S64

r9 :: FromReg c => c S64

r10 :: FromReg c => c S64

r11 :: FromReg c => c S64

r12 :: FromReg c => c S64

r13 :: FromReg c => c S64

r14 :: FromReg c => c S64

r15 :: FromReg c => c S64

eax :: FromReg c => c S32

ecx :: FromReg c => c S32

edx :: FromReg c => c S32

ebx :: FromReg c => c S32

esp :: FromReg c => c S32

ebp :: FromReg c => c S32

esi :: FromReg c => c S32

edi :: FromReg c => c S32

r8d :: FromReg c => c S32

r9d :: FromReg c => c S32

r10d :: FromReg c => c S32

r11d :: FromReg c => c S32

r12d :: FromReg c => c S32

r13d :: FromReg c => c S32

r14d :: FromReg c => c S32

r15d :: FromReg c => c S32

ax :: FromReg c => c S16

cx :: FromReg c => c S16

dx :: FromReg c => c S16

bx :: FromReg c => c S16

sp :: FromReg c => c S16

bp :: FromReg c => c S16

si :: FromReg c => c S16

di :: FromReg c => c S16

r8w :: FromReg c => c S16

r9w :: FromReg c => c S16

r10w :: FromReg c => c S16

r11w :: FromReg c => c S16

r12w :: FromReg c => c S16

r13w :: FromReg c => c S16

r14w :: FromReg c => c S16

r15w :: FromReg c => c S16

al :: FromReg c => c S8

cl :: FromReg c => c S8

dl :: FromReg c => c S8

bl :: FromReg c => c S8

spl :: FromReg c => c S8

bpl :: FromReg c => c S8

sil :: FromReg c => c S8

dil :: FromReg c => c S8

r8b :: FromReg c => c S8

r9b :: FromReg c => c S8

r10b :: FromReg c => c S8

r11b :: FromReg c => c S8

r12b :: FromReg c => c S8

r13b :: FromReg c => c S8

r14b :: FromReg c => c S8

r15b :: FromReg c => c S8

ah :: FromReg c => c S8

ch :: FromReg c => c S8

dh :: FromReg c => c S8

bh :: FromReg c => c S8

xmm0 :: FromReg c => c S128

xmm1 :: FromReg c => c S128

xmm2 :: FromReg c => c S128

xmm3 :: FromReg c => c S128

xmm4 :: FromReg c => c S128

xmm5 :: FromReg c => c S128

xmm6 :: FromReg c => c S128

xmm7 :: FromReg c => c S128

pattern RegA :: Operand a b

pattern RegCl :: Operand r S8

resizeOperand :: IsSize s' => Operand RW s -> Operand RW s'

resizeRegCode :: Reg s -> Reg s'

pattern MemLike :: Operand a b

isMemOp :: forall {a :: Access} {b :: Size}. Operand a b -> Bool

newtype Condition

Constructors

Condition Word8

Instances

Show Condition

Defined in CodeGen.X86.Asm

Methods

showsPrec :: Int -> Condition -> ShowS

show :: Condition -> String

showList :: [Condition] -> ShowS

pattern O :: Condition

pattern NO :: Condition

pattern B :: Condition

pattern C :: Condition

pattern NB :: Condition

pattern NC :: Condition

pattern E :: Condition

pattern Z :: Condition

pattern NE :: Condition

pattern NZ :: Condition

pattern NA :: Condition

pattern BE :: Condition

pattern A :: Condition

pattern NBE :: Condition

pattern S :: Condition

pattern NS :: Condition

pattern P :: Condition

pattern NP :: Condition

pattern L :: Condition

pattern NL :: Condition

pattern NG :: Condition

pattern LE :: Condition

pattern G :: Condition

pattern NLE :: Condition

pattern N :: Condition -> Condition

notCond :: Condition -> Condition

data CodeLine where

Constructors

Ret_, Nop_, PushF_, PopF_, Cmc_, Clc_, Stc_, Cli_, Sti_, Cld_, Std_ :: CodeLine

Inc_, Dec_, Not_, Neg_, Bswap :: IsSize s => Operand RW s -> CodeLine

Add_, Or_, Adc_, Sbb_, And_, Sub_, Xor_, Cmp_, Test_, Mov_, Bsf, Bsr :: IsSize s => Operand RW s -> Operand r s -> CodeLine

Rol_, Ror_, Rcl_, Rcr_, Shl_, Shr_, Sar_ :: IsSize s => Operand RW s -> Operand r S8 -> CodeLine

Bt :: IsSize s => Operand r s -> Operand RW s -> CodeLine

Movdqa_, Paddb_, Paddw_, Paddd_, Paddq_, Psubb_, Psubw_, Psubd_, Psubq_, Pxor_ :: Operand RW S128 -> Operand r S128 -> CodeLine

Psllw_, Pslld_, Psllq_, Pslldq_, Psrlw_, Psrld_, Psrlq_, Psrldq_, Psraw_, Psrad_ :: Operand RW S128 -> Operand r S8 -> CodeLine

Movd_, Movq_ :: (IsSize s, IsSize s') => Operand RW s -> Operand r s' -> CodeLine

Cmov_ :: IsSize s => Condition -> Operand RW s -> Operand RW s -> CodeLine

Xchg_ :: IsSize s => Operand RW s -> Operand RW s -> CodeLine

Lea_ :: (IsSize s, IsSize s') => Operand RW s -> Operand RW s' -> CodeLine

Pop_ :: Operand RW S64 -> CodeLine

Push_ :: Operand r S64 -> CodeLine

Call_ :: Operand r S64 -> CodeLine

Jmpq_ :: Operand r S64 -> CodeLine

J_ :: Condition -> Maybe Size -> Label -> CodeLine

Jmp_ :: Maybe Size -> Label -> CodeLine

Label_ :: CodeLine

Data_ :: Bytes -> CodeLine

Align_ :: Int -> CodeLine

newLabel :: (StateType m ~ Int, MonadState m) => m Label

codeLine :: (WriterType m ~ [a], MonadWriter m) => a -> m ()

showOp0 :: (WriterType m ~ [a], MonadWriter m) => a -> m ()

showOp :: (WriterType m ~ [[Char]], MonadWriter m) => [Char] -> [Char] -> m ()

showOp1 :: (WriterType m ~ [[Char]], MonadWriter m, Show a) => [Char] -> a -> m ()

showOp2 :: (WriterType m ~ [[Char]], MonadWriter m, Show a, Show a) => [Char] -> a -> a -> m ()

showCodeLine :: CodeLine -> StateT Int (Writer [String]) ()