packages feed

x86-64bit 0.4.6.1 → 0.4.6.2

raw patch · 2 files changed

+7/−6 lines, 2 filesdep ~basePVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependency ranges changed: base

API changes (from Hackage documentation)

- CodeGen.X86: pattern NLE :: () => () => Condition
+ CodeGen.X86: pattern A :: Condition
+ CodeGen.X86: pattern B :: Condition
+ CodeGen.X86: pattern BE :: Condition
+ CodeGen.X86: pattern C :: Condition
+ CodeGen.X86: pattern E :: Condition
+ CodeGen.X86: pattern G :: Condition
+ CodeGen.X86: pattern L :: Condition
+ CodeGen.X86: pattern LE :: Condition
+ CodeGen.X86: pattern N :: Condition -> Condition
+ CodeGen.X86: pattern NA :: Condition
+ CodeGen.X86: pattern NB :: Condition
+ CodeGen.X86: pattern NBE :: Condition
+ CodeGen.X86: pattern NC :: Condition
+ CodeGen.X86: pattern NE :: Condition
+ CodeGen.X86: pattern NG :: Condition
+ CodeGen.X86: pattern NL :: Condition
+ CodeGen.X86: pattern NLE :: Condition
+ CodeGen.X86: pattern NO :: Condition
+ CodeGen.X86: pattern NP :: Condition
+ CodeGen.X86: pattern NS :: Condition
+ CodeGen.X86: pattern NZ :: Condition
+ CodeGen.X86: pattern O :: Condition
+ CodeGen.X86: pattern P :: Condition
+ CodeGen.X86: pattern S :: Condition
+ CodeGen.X86: pattern Z :: Condition
+ CodeGen.X86.Asm: Addr :: BaseReg s -> Displacement -> IndexReg s -> Addr s
+ CodeGen.X86.Asm: Condition :: Word8 -> Condition
+ CodeGen.X86.Asm: Immediate :: a -> Immediate a
+ CodeGen.X86.Asm: IndexReg :: Scale -> Reg s -> IndexReg s
+ CodeGen.X86.Asm: Label :: Int -> Label
+ CodeGen.X86.Asm: LabelRelValue :: Size -> Label -> Immediate a
+ CodeGen.X86.Asm: NoIndex :: IndexReg s
+ CodeGen.X86.Asm: R :: Access
+ CodeGen.X86.Asm: RW :: Access
+ CodeGen.X86.Asm: S1 :: Size
+ CodeGen.X86.Asm: S128 :: Size
+ CodeGen.X86.Asm: S16 :: Size
+ CodeGen.X86.Asm: S32 :: Size
+ CodeGen.X86.Asm: S64 :: Size
+ CodeGen.X86.Asm: S8 :: Size
+ CodeGen.X86.Asm: Scale :: Word8 -> Scale
+ CodeGen.X86.Asm: [Add_, Or_, Adc_, Sbb_, And_, Sub_, Xor_, Cmp_, Test_, Mov_, Bsf, Bsr] :: IsSize s => Operand RW s -> Operand r s -> CodeLine
+ CodeGen.X86.Asm: [Address] :: [(Int, Reg s)] -> Int -> Address s
+ CodeGen.X86.Asm: [Align_] :: Int -> CodeLine
+ CodeGen.X86.Asm: [Bt] :: IsSize s => Operand r s -> Operand RW s -> CodeLine
+ CodeGen.X86.Asm: [Call_] :: Operand r S64 -> CodeLine
+ CodeGen.X86.Asm: [Cmov_] :: IsSize s => Condition -> Operand RW s -> Operand RW s -> CodeLine
+ CodeGen.X86.Asm: [Data_] :: Bytes -> CodeLine
+ CodeGen.X86.Asm: [HighReg] :: Word8 -> Reg S8
+ CodeGen.X86.Asm: [IPMemOp] :: Immediate Int32 -> Operand rw s
+ CodeGen.X86.Asm: [ImmOp] :: Immediate Int64 -> Operand R s
+ CodeGen.X86.Asm: [Inc_, Dec_, Not_, Neg_, Bswap] :: IsSize s => Operand RW s -> CodeLine
+ CodeGen.X86.Asm: [J_] :: Condition -> Maybe Size -> Label -> CodeLine
+ CodeGen.X86.Asm: [Jmp_] :: Maybe Size -> Label -> CodeLine
+ CodeGen.X86.Asm: [Jmpq_] :: Operand r S64 -> CodeLine
+ CodeGen.X86.Asm: [Label_] :: CodeLine
+ CodeGen.X86.Asm: [Lea_] :: (IsSize s, IsSize s') => Operand RW s -> Operand RW s' -> CodeLine
+ CodeGen.X86.Asm: [MemOp] :: IsSize s' => Addr s' -> Operand rw s
+ CodeGen.X86.Asm: [Movd_, Movq_] :: (IsSize s, IsSize s') => Operand RW s -> Operand r s' -> CodeLine
+ CodeGen.X86.Asm: [Movdqa_, Paddb_, Paddw_, Paddd_, Paddq_, Psubb_, Psubw_, Psubd_, Psubq_, Pxor_] :: Operand RW S128 -> Operand r S128 -> CodeLine
+ CodeGen.X86.Asm: [NormalReg] :: Word8 -> Reg s
+ CodeGen.X86.Asm: [Pop_] :: Operand RW S64 -> CodeLine
+ CodeGen.X86.Asm: [Psllw_, Pslld_, Psllq_, Pslldq_, Psrlw_, Psrld_, Psrlq_, Psrldq_, Psraw_, Psrad_] :: Operand RW S128 -> Operand r S8 -> CodeLine
+ CodeGen.X86.Asm: [Push_] :: Operand r S64 -> CodeLine
+ CodeGen.X86.Asm: [Refl] :: EqT s s
+ CodeGen.X86.Asm: [RegOp] :: Reg s -> Operand rw s
+ CodeGen.X86.Asm: [Ret_, Nop_, PushF_, PopF_, Cmc_, Clc_, Stc_, Cli_, Sti_, Cld_, Std_] :: CodeLine
+ CodeGen.X86.Asm: [Rol_, Ror_, Rcl_, Rcr_, Shl_, Shr_, Sar_] :: IsSize s => Operand RW s -> Operand r S8 -> CodeLine
+ CodeGen.X86.Asm: [SSize128] :: SSize S128
+ CodeGen.X86.Asm: [SSize16] :: SSize S16
+ CodeGen.X86.Asm: [SSize1] :: SSize S1
+ CodeGen.X86.Asm: [SSize32] :: SSize S32
+ CodeGen.X86.Asm: [SSize64] :: SSize S64
+ CodeGen.X86.Asm: [SSize8] :: SSize S8
+ CodeGen.X86.Asm: [XMM] :: Word8 -> Reg S128
+ CodeGen.X86.Asm: [Xchg_] :: IsSize s => Operand RW s -> Operand RW s -> CodeLine
+ CodeGen.X86.Asm: [baseReg] :: Addr s -> BaseReg s
+ CodeGen.X86.Asm: [displacement] :: Addr s -> Displacement
+ CodeGen.X86.Asm: [indexReg] :: Addr s -> IndexReg s
+ CodeGen.X86.Asm: [unLabel] :: Label -> Int
+ CodeGen.X86.Asm: addr :: IsSize s => Address s -> Operand rw s'
+ CodeGen.X86.Asm: addr16 :: IsSize s => Address s -> Operand rw S16
+ CodeGen.X86.Asm: addr32 :: IsSize s => Address s -> Operand rw S32
+ CodeGen.X86.Asm: addr64 :: IsSize s => Address s -> Operand rw S64
+ CodeGen.X86.Asm: addr8 :: IsSize s => Address s -> Operand rw S8
+ CodeGen.X86.Asm: ah :: FromReg c => c S8
+ CodeGen.X86.Asm: al :: FromReg c => c S8
+ CodeGen.X86.Asm: ax :: FromReg c => c S16
+ CodeGen.X86.Asm: base :: Reg s -> Addr s
+ CodeGen.X86.Asm: bh :: FromReg c => c S8
+ CodeGen.X86.Asm: bl :: FromReg c => c S8
+ CodeGen.X86.Asm: bp :: FromReg c => c S16
+ CodeGen.X86.Asm: bpl :: FromReg c => c S8
+ CodeGen.X86.Asm: bx :: FromReg c => c S16
+ CodeGen.X86.Asm: ch :: FromReg c => c S8
+ CodeGen.X86.Asm: cl :: FromReg c => c S8
+ CodeGen.X86.Asm: class FromReg c
+ CodeGen.X86.Asm: class HasBytes a
+ CodeGen.X86.Asm: class HasSize a
+ CodeGen.X86.Asm: class IsSize (s :: Size)
+ CodeGen.X86.Asm: codeLine :: (MonadWriter m, WriterType m ~ [a]) => a -> m ()
+ CodeGen.X86.Asm: cx :: FromReg c => c S16
+ CodeGen.X86.Asm: data Access
+ CodeGen.X86.Asm: data Addr s
+ CodeGen.X86.Asm: data Address :: Size -> *
+ CodeGen.X86.Asm: data CodeLine
+ CodeGen.X86.Asm: data EqT s s'
+ CodeGen.X86.Asm: data Immediate a
+ CodeGen.X86.Asm: data IndexReg s
+ CodeGen.X86.Asm: data Operand :: Access -> Size -> *
+ CodeGen.X86.Asm: data Reg :: Size -> *
+ CodeGen.X86.Asm: data SSize (s :: Size)
+ CodeGen.X86.Asm: data Size
+ CodeGen.X86.Asm: dh :: FromReg c => c S8
+ CodeGen.X86.Asm: di :: FromReg c => c S16
+ CodeGen.X86.Asm: dil :: FromReg c => c S8
+ CodeGen.X86.Asm: disp :: (Bits a, Integral a) => a -> Addr s
+ CodeGen.X86.Asm: dl :: FromReg c => c S8
+ CodeGen.X86.Asm: dx :: FromReg c => c S16
+ CodeGen.X86.Asm: eax :: FromReg c => c S32
+ CodeGen.X86.Asm: ebp :: FromReg c => c S32
+ CodeGen.X86.Asm: ebx :: FromReg c => c S32
+ CodeGen.X86.Asm: ecx :: FromReg c => c S32
+ CodeGen.X86.Asm: edi :: FromReg c => c S32
+ CodeGen.X86.Asm: edx :: FromReg c => c S32
+ CodeGen.X86.Asm: esi :: FromReg c => c S32
+ CodeGen.X86.Asm: esp :: FromReg c => c S32
+ CodeGen.X86.Asm: everyNth :: Int -> [a] -> [[a]]
+ CodeGen.X86.Asm: fromReg :: FromReg c => Reg s -> c s
+ CodeGen.X86.Asm: index :: Scale -> Reg s -> Addr s
+ CodeGen.X86.Asm: index' :: Int -> Reg s -> Addr s
+ CodeGen.X86.Asm: index1 :: forall (s :: Size). Reg s -> Addr s
+ CodeGen.X86.Asm: index2 :: forall (s :: Size). Reg s -> Addr s
+ CodeGen.X86.Asm: index4 :: forall (s :: Size). Reg s -> Addr s
+ CodeGen.X86.Asm: index8 :: forall (s :: Size). Reg s -> Addr s
+ CodeGen.X86.Asm: instance (rw GHC.Types.~ 'CodeGen.X86.Asm.R) => GHC.Num.Num (CodeGen.X86.Asm.Operand rw s)
+ CodeGen.X86.Asm: instance CodeGen.X86.Asm.FromReg (CodeGen.X86.Asm.Operand r)
+ CodeGen.X86.Asm: instance CodeGen.X86.Asm.FromReg CodeGen.X86.Asm.Address
+ CodeGen.X86.Asm: instance CodeGen.X86.Asm.FromReg CodeGen.X86.Asm.Reg
+ CodeGen.X86.Asm: instance CodeGen.X86.Asm.HasBytes GHC.Int.Int16
+ CodeGen.X86.Asm: instance CodeGen.X86.Asm.HasBytes GHC.Int.Int32
+ CodeGen.X86.Asm: instance CodeGen.X86.Asm.HasBytes GHC.Int.Int64
+ CodeGen.X86.Asm: instance CodeGen.X86.Asm.HasBytes GHC.Int.Int8
+ CodeGen.X86.Asm: instance CodeGen.X86.Asm.HasBytes GHC.Word.Word16
+ CodeGen.X86.Asm: instance CodeGen.X86.Asm.HasBytes GHC.Word.Word32
+ CodeGen.X86.Asm: instance CodeGen.X86.Asm.HasBytes GHC.Word.Word64
+ CodeGen.X86.Asm: instance CodeGen.X86.Asm.HasBytes GHC.Word.Word8
+ CodeGen.X86.Asm: instance CodeGen.X86.Asm.HasSize (CodeGen.X86.Asm.SSize s)
+ CodeGen.X86.Asm: instance CodeGen.X86.Asm.HasSize GHC.Int.Int16
+ CodeGen.X86.Asm: instance CodeGen.X86.Asm.HasSize GHC.Int.Int32
+ CodeGen.X86.Asm: instance CodeGen.X86.Asm.HasSize GHC.Int.Int64
+ CodeGen.X86.Asm: instance CodeGen.X86.Asm.HasSize GHC.Int.Int8
+ CodeGen.X86.Asm: instance CodeGen.X86.Asm.HasSize GHC.Word.Word16
+ CodeGen.X86.Asm: instance CodeGen.X86.Asm.HasSize GHC.Word.Word32
+ CodeGen.X86.Asm: instance CodeGen.X86.Asm.HasSize GHC.Word.Word64
+ CodeGen.X86.Asm: instance CodeGen.X86.Asm.HasSize GHC.Word.Word8
+ CodeGen.X86.Asm: instance CodeGen.X86.Asm.IsSize 'CodeGen.X86.Asm.S1
+ CodeGen.X86.Asm: instance CodeGen.X86.Asm.IsSize 'CodeGen.X86.Asm.S128
+ CodeGen.X86.Asm: instance CodeGen.X86.Asm.IsSize 'CodeGen.X86.Asm.S16
+ CodeGen.X86.Asm: instance CodeGen.X86.Asm.IsSize 'CodeGen.X86.Asm.S32
+ CodeGen.X86.Asm: instance CodeGen.X86.Asm.IsSize 'CodeGen.X86.Asm.S64
+ CodeGen.X86.Asm: instance CodeGen.X86.Asm.IsSize 'CodeGen.X86.Asm.S8
+ CodeGen.X86.Asm: instance CodeGen.X86.Asm.IsSize s => CodeGen.X86.Asm.HasSize (CodeGen.X86.Asm.Addr s)
+ CodeGen.X86.Asm: instance CodeGen.X86.Asm.IsSize s => CodeGen.X86.Asm.HasSize (CodeGen.X86.Asm.Address s)
+ CodeGen.X86.Asm: instance CodeGen.X86.Asm.IsSize s => CodeGen.X86.Asm.HasSize (CodeGen.X86.Asm.BaseReg s)
+ CodeGen.X86.Asm: instance CodeGen.X86.Asm.IsSize s => CodeGen.X86.Asm.HasSize (CodeGen.X86.Asm.IndexReg s)
+ CodeGen.X86.Asm: instance CodeGen.X86.Asm.IsSize s => CodeGen.X86.Asm.HasSize (CodeGen.X86.Asm.Operand a s)
+ CodeGen.X86.Asm: instance CodeGen.X86.Asm.IsSize s => CodeGen.X86.Asm.HasSize (CodeGen.X86.Asm.Reg s)
+ CodeGen.X86.Asm: instance CodeGen.X86.Asm.IsSize s => GHC.Show.Show (CodeGen.X86.Asm.Addr s)
+ CodeGen.X86.Asm: instance CodeGen.X86.Asm.IsSize s => GHC.Show.Show (CodeGen.X86.Asm.Operand a s)
+ CodeGen.X86.Asm: instance CodeGen.X86.Asm.IsSize s => GHC.Show.Show (CodeGen.X86.Asm.Reg s)
+ CodeGen.X86.Asm: instance GHC.Base.Monoid (CodeGen.X86.Asm.Addr s)
+ CodeGen.X86.Asm: instance GHC.Base.Monoid (CodeGen.X86.Asm.IndexReg s)
+ CodeGen.X86.Asm: instance GHC.Base.Semigroup (CodeGen.X86.Asm.Addr s)
+ CodeGen.X86.Asm: instance GHC.Base.Semigroup (CodeGen.X86.Asm.IndexReg s)
+ CodeGen.X86.Asm: instance GHC.Classes.Eq (CodeGen.X86.Asm.Addr s)
+ CodeGen.X86.Asm: instance GHC.Classes.Eq (CodeGen.X86.Asm.IndexReg s)
+ CodeGen.X86.Asm: instance GHC.Classes.Eq (CodeGen.X86.Asm.Reg s)
+ CodeGen.X86.Asm: instance GHC.Classes.Eq CodeGen.X86.Asm.Scale
+ CodeGen.X86.Asm: instance GHC.Classes.Eq CodeGen.X86.Asm.Size
+ CodeGen.X86.Asm: instance GHC.Classes.Ord (CodeGen.X86.Asm.Reg s)
+ CodeGen.X86.Asm: instance GHC.Classes.Ord CodeGen.X86.Asm.Size
+ CodeGen.X86.Asm: instance GHC.Num.Num (CodeGen.X86.Asm.Address s)
+ CodeGen.X86.Asm: instance GHC.Show.Show CodeGen.X86.Asm.Condition
+ CodeGen.X86.Asm: instance GHC.Show.Show CodeGen.X86.Asm.Label
+ CodeGen.X86.Asm: instance GHC.Show.Show CodeGen.X86.Asm.Size
+ CodeGen.X86.Asm: instance GHC.Show.Show a => GHC.Show.Show (CodeGen.X86.Asm.Immediate a)
+ CodeGen.X86.Asm: ipRel :: Label -> Operand rw s
+ CodeGen.X86.Asm: ipRel8 :: Label -> Operand rw S8
+ CodeGen.X86.Asm: ipRelValue :: forall (s :: Size). Label -> Operand 'R s
+ CodeGen.X86.Asm: isMemOp :: forall (a :: Access) (b :: Size). Operand a b -> Bool
+ CodeGen.X86.Asm: makeAddr :: Address s -> Addr s
+ CodeGen.X86.Asm: mkSize :: (Eq a, Num a) => a -> Size
+ CodeGen.X86.Asm: newLabel :: (MonadState m, StateType m ~ Int) => m Label
+ CodeGen.X86.Asm: newtype Condition
+ CodeGen.X86.Asm: newtype Label
+ CodeGen.X86.Asm: newtype Scale
+ CodeGen.X86.Asm: notCond :: Condition -> Condition
+ CodeGen.X86.Asm: pattern A :: Condition
+ CodeGen.X86.Asm: pattern B :: Condition
+ CodeGen.X86.Asm: pattern BE :: Condition
+ CodeGen.X86.Asm: pattern C :: Condition
+ CodeGen.X86.Asm: pattern Disp :: a -> Maybe a
+ CodeGen.X86.Asm: pattern E :: Condition
+ CodeGen.X86.Asm: pattern G :: Condition
+ CodeGen.X86.Asm: pattern L :: Condition
+ CodeGen.X86.Asm: pattern LE :: Condition
+ CodeGen.X86.Asm: pattern MemLike :: Operand a b
+ CodeGen.X86.Asm: pattern N :: Condition -> Condition
+ CodeGen.X86.Asm: pattern NA :: Condition
+ CodeGen.X86.Asm: pattern NB :: Condition
+ CodeGen.X86.Asm: pattern NBE :: Condition
+ CodeGen.X86.Asm: pattern NC :: Condition
+ CodeGen.X86.Asm: pattern NE :: Condition
+ CodeGen.X86.Asm: pattern NG :: Condition
+ CodeGen.X86.Asm: pattern NL :: Condition
+ CodeGen.X86.Asm: pattern NLE :: Condition
+ CodeGen.X86.Asm: pattern NO :: Condition
+ CodeGen.X86.Asm: pattern NP :: Condition
+ CodeGen.X86.Asm: pattern NS :: Condition
+ CodeGen.X86.Asm: pattern NZ :: Condition
+ CodeGen.X86.Asm: pattern NoDisp :: Maybe a
+ CodeGen.X86.Asm: pattern O :: Condition
+ CodeGen.X86.Asm: pattern P :: Condition
+ CodeGen.X86.Asm: pattern RegA :: Operand a b
+ CodeGen.X86.Asm: pattern RegCl :: Operand r S8
+ CodeGen.X86.Asm: pattern S :: Condition
+ CodeGen.X86.Asm: pattern Z :: Condition
+ CodeGen.X86.Asm: pattern Integral :: (Integral a, Integral b, Bits a, Bits b) => b -> a
+ CodeGen.X86.Asm: r10 :: FromReg c => c S64
+ CodeGen.X86.Asm: r10b :: FromReg c => c S8
+ CodeGen.X86.Asm: r10d :: FromReg c => c S32
+ CodeGen.X86.Asm: r10w :: FromReg c => c S16
+ CodeGen.X86.Asm: r11 :: FromReg c => c S64
+ CodeGen.X86.Asm: r11b :: FromReg c => c S8
+ CodeGen.X86.Asm: r11d :: FromReg c => c S32
+ CodeGen.X86.Asm: r11w :: FromReg c => c S16
+ CodeGen.X86.Asm: r12 :: FromReg c => c S64
+ CodeGen.X86.Asm: r12b :: FromReg c => c S8
+ CodeGen.X86.Asm: r12d :: FromReg c => c S32
+ CodeGen.X86.Asm: r12w :: FromReg c => c S16
+ CodeGen.X86.Asm: r13 :: FromReg c => c S64
+ CodeGen.X86.Asm: r13b :: FromReg c => c S8
+ CodeGen.X86.Asm: r13d :: FromReg c => c S32
+ CodeGen.X86.Asm: r13w :: FromReg c => c S16
+ CodeGen.X86.Asm: r14 :: FromReg c => c S64
+ CodeGen.X86.Asm: r14b :: FromReg c => c S8
+ CodeGen.X86.Asm: r14d :: FromReg c => c S32
+ CodeGen.X86.Asm: r14w :: FromReg c => c S16
+ CodeGen.X86.Asm: r15 :: FromReg c => c S64
+ CodeGen.X86.Asm: r15b :: FromReg c => c S8
+ CodeGen.X86.Asm: r15d :: FromReg c => c S32
+ CodeGen.X86.Asm: r15w :: FromReg c => c S16
+ CodeGen.X86.Asm: r8 :: FromReg c => c S64
+ CodeGen.X86.Asm: r8b :: FromReg c => c S8
+ CodeGen.X86.Asm: r8d :: FromReg c => c S32
+ CodeGen.X86.Asm: r8w :: FromReg c => c S16
+ CodeGen.X86.Asm: r9 :: FromReg c => c S64
+ CodeGen.X86.Asm: r9b :: FromReg c => c S8
+ CodeGen.X86.Asm: r9d :: FromReg c => c S32
+ CodeGen.X86.Asm: r9w :: FromReg c => c S16
+ CodeGen.X86.Asm: rax :: FromReg c => c S64
+ CodeGen.X86.Asm: rbp :: FromReg c => c S64
+ CodeGen.X86.Asm: rbx :: FromReg c => c S64
+ CodeGen.X86.Asm: rcx :: FromReg c => c S64
+ CodeGen.X86.Asm: rdi :: FromReg c => c S64
+ CodeGen.X86.Asm: rdx :: FromReg c => c S64
+ CodeGen.X86.Asm: reg :: forall c (s :: Size). FromReg c => Word8 -> c s
+ CodeGen.X86.Asm: resizeOperand :: IsSize s' => Operand RW s -> Operand RW s'
+ CodeGen.X86.Asm: resizeRegCode :: Reg s -> Reg s'
+ CodeGen.X86.Asm: rsi :: FromReg c => c S64
+ CodeGen.X86.Asm: rsp :: FromReg c => c S64
+ CodeGen.X86.Asm: s1 :: Scale
+ CodeGen.X86.Asm: s2 :: Scale
+ CodeGen.X86.Asm: s4 :: Scale
+ CodeGen.X86.Asm: s8 :: Scale
+ CodeGen.X86.Asm: scaleAddress :: (Int -> Int) -> Address s -> Address s
+ CodeGen.X86.Asm: scaleFactor :: Num p => Scale -> p
+ CodeGen.X86.Asm: showByte :: (Integral a, Bits a) => a -> [Char]
+ CodeGen.X86.Asm: showCodeLine :: CodeLine -> StateT Int (Writer [String]) ()
+ CodeGen.X86.Asm: showHex' :: (Integral a, Show a) => a -> [Char]
+ CodeGen.X86.Asm: showNibble :: (Integral a, Bits a) => Int -> a -> Char
+ CodeGen.X86.Asm: showOp :: (MonadWriter m, WriterType m ~ [[Char]]) => [Char] -> [Char] -> m ()
+ CodeGen.X86.Asm: showOp0 :: (MonadWriter m, WriterType m ~ [a]) => a -> m ()
+ CodeGen.X86.Asm: showOp1 :: (MonadWriter m, Show a, WriterType m ~ [[Char]]) => [Char] -> a -> m ()
+ CodeGen.X86.Asm: showOp2 :: (MonadWriter m, Show a1, Show a2, WriterType m ~ [[Char]]) => [Char] -> a1 -> a2 -> m ()
+ CodeGen.X86.Asm: si :: FromReg c => c S16
+ CodeGen.X86.Asm: sil :: FromReg c => c S8
+ CodeGen.X86.Asm: size :: HasSize a => a -> Size
+ CodeGen.X86.Asm: sizeEqCheck :: forall s s' f g. (IsSize s, IsSize s') => f s -> g s' -> Maybe (EqT s s')
+ CodeGen.X86.Asm: sizeLen :: Num p => Size -> p
+ CodeGen.X86.Asm: sp :: FromReg c => c S16
+ CodeGen.X86.Asm: spl :: FromReg c => c S8
+ CodeGen.X86.Asm: ssize :: IsSize s => SSize s
+ CodeGen.X86.Asm: toBytes :: HasBytes a => a -> Bytes
+ CodeGen.X86.Asm: toScale :: (Eq a, Num a) => a -> Scale
+ CodeGen.X86.Asm: type BaseReg s = Maybe (Reg s)
+ CodeGen.X86.Asm: type Bytes = [Word8]
+ CodeGen.X86.Asm: type Displacement = Maybe Int32
+ CodeGen.X86.Asm: xmm0 :: FromReg c => c S128
+ CodeGen.X86.Asm: xmm1 :: FromReg c => c S128
+ CodeGen.X86.Asm: xmm2 :: FromReg c => c S128
+ CodeGen.X86.Asm: xmm3 :: FromReg c => c S128
+ CodeGen.X86.Asm: xmm4 :: FromReg c => c S128
+ CodeGen.X86.Asm: xmm5 :: FromReg c => c S128
+ CodeGen.X86.Asm: xmm6 :: FromReg c => c S128
+ CodeGen.X86.Asm: xmm7 :: FromReg c => c S128
- CodeGen.X86: adc :: IsSize s => Operand RW s -> Operand r s -> Code
+ CodeGen.X86: adc :: forall (s :: Size) (r :: Access). IsSize s => Operand 'RW s -> Operand r s -> Code
- CodeGen.X86: add :: IsSize s => Operand RW s -> Operand r s -> Code
+ CodeGen.X86: add :: forall (s :: Size) (r :: Access). IsSize s => Operand 'RW s -> Operand r s -> Code
- CodeGen.X86: and_ :: IsSize s => Operand RW s -> Operand r s -> Code
+ CodeGen.X86: and_ :: forall (s :: Size) (r :: Access). IsSize s => Operand 'RW s -> Operand r s -> Code
- CodeGen.X86: arg1 :: FromReg c => c S64
+ CodeGen.X86: arg1 :: FromReg c => c 'S64
- CodeGen.X86: arg2 :: FromReg c => c S64
+ CodeGen.X86: arg2 :: FromReg c => c 'S64
- CodeGen.X86: arg3 :: FromReg c => c S64
+ CodeGen.X86: arg3 :: FromReg c => c 'S64
- CodeGen.X86: arg4 :: FromReg c => c S64
+ CodeGen.X86: arg4 :: FromReg c => c 'S64
- CodeGen.X86: bsf :: IsSize s => Operand RW s -> Operand r s -> Code
+ CodeGen.X86: bsf :: forall (s :: Size) (r :: Access). IsSize s => Operand 'RW s -> Operand r s -> Code
- CodeGen.X86: bsr :: IsSize s => Operand RW s -> Operand r s -> Code
+ CodeGen.X86: bsr :: forall (s :: Size) (r :: Access). IsSize s => Operand 'RW s -> Operand r s -> Code
- CodeGen.X86: bswap :: IsSize s => Operand RW s -> Code
+ CodeGen.X86: bswap :: forall (s :: Size). IsSize s => Operand 'RW s -> Code
- CodeGen.X86: bt :: IsSize s => Operand r s -> Operand RW s -> Code
+ CodeGen.X86: bt :: forall (s :: Size) (r :: Access). IsSize s => Operand r s -> Operand 'RW s -> Code
- CodeGen.X86: call :: () => Operand r S64 -> Code
+ CodeGen.X86: call :: forall (r :: Access). Operand r 'S64 -> Code
- CodeGen.X86: cmov :: IsSize s => Condition -> Operand RW s -> Operand RW s -> Code
+ CodeGen.X86: cmov :: forall (s :: Size). IsSize s => Condition -> Operand 'RW s -> Operand 'RW s -> Code
- CodeGen.X86: cmp :: IsSize s => Operand RW s -> Operand r s -> Code
+ CodeGen.X86: cmp :: forall (s :: Size) (r :: Access). IsSize s => Operand 'RW s -> Operand r s -> Code
- CodeGen.X86: dec :: IsSize s => Operand RW s -> Code
+ CodeGen.X86: dec :: forall (s :: Size). IsSize s => Operand 'RW s -> Code
- CodeGen.X86: doWhile :: () => Condition -> CodeM a -> CodeM ()
+ CodeGen.X86: doWhile :: Condition -> CodeM a -> CodeM ()
- CodeGen.X86: if_ :: () => Condition -> CodeM a1 -> CodeM a2 -> CodeM ()
+ CodeGen.X86: if_ :: Condition -> CodeM a1 -> CodeM a2 -> CodeM ()
- CodeGen.X86: inc :: IsSize s => Operand RW s -> Code
+ CodeGen.X86: inc :: forall (s :: Size). IsSize s => Operand 'RW s -> Code
- CodeGen.X86: ipRelValue :: () => Label -> Operand R s
+ CodeGen.X86: ipRelValue :: forall (s :: Size). Label -> Operand 'R s
- CodeGen.X86: jmpq :: () => Operand r S64 -> Code
+ CodeGen.X86: jmpq :: forall (r :: Access). Operand r 'S64 -> Code
- CodeGen.X86: lea :: (IsSize s, IsSize s') => Operand RW s -> Operand RW s' -> Code
+ CodeGen.X86: lea :: forall (s :: Size) (s' :: Size). (IsSize s, IsSize s') => Operand 'RW s -> Operand 'RW s' -> Code
- CodeGen.X86: leaData :: (IsSize s, HasBytes a) => Operand RW s -> a -> CodeM ()
+ CodeGen.X86: leaData :: forall (s :: Size) a. (IsSize s, HasBytes a) => Operand 'RW s -> a -> CodeM ()
- CodeGen.X86: mov :: IsSize s => Operand RW s -> Operand r s -> Code
+ CodeGen.X86: mov :: forall (s :: Size) (r :: Access). IsSize s => Operand 'RW s -> Operand r s -> Code
- CodeGen.X86: movd :: (IsSize s, IsSize s') => Operand RW s -> Operand r s' -> Code
+ CodeGen.X86: movd :: forall (s :: Size) (s' :: Size) (r :: Access). (IsSize s, IsSize s') => Operand 'RW s -> Operand r s' -> Code
- CodeGen.X86: movdqa :: () => Operand RW S128 -> Operand r S128 -> Code
+ CodeGen.X86: movdqa :: forall (r :: Access). Operand 'RW 'S128 -> Operand r 'S128 -> Code
- CodeGen.X86: movq :: (IsSize s, IsSize s') => Operand RW s -> Operand r s' -> Code
+ CodeGen.X86: movq :: forall (s :: Size) (s' :: Size) (r :: Access). (IsSize s, IsSize s') => Operand 'RW s -> Operand r s' -> Code
- CodeGen.X86: neg :: IsSize s => Operand RW s -> Code
+ CodeGen.X86: neg :: forall (s :: Size). IsSize s => Operand 'RW s -> Code
- CodeGen.X86: not_ :: IsSize s => Operand RW s -> Code
+ CodeGen.X86: not_ :: forall (s :: Size). IsSize s => Operand 'RW s -> Code
- CodeGen.X86: or_ :: IsSize s => Operand RW s -> Operand r s -> Code
+ CodeGen.X86: or_ :: forall (s :: Size) (r :: Access). IsSize s => Operand 'RW s -> Operand r s -> Code
- CodeGen.X86: paddb :: () => Operand RW S128 -> Operand r S128 -> Code
+ CodeGen.X86: paddb :: forall (r :: Access). Operand 'RW 'S128 -> Operand r 'S128 -> Code
- CodeGen.X86: paddd :: () => Operand RW S128 -> Operand r S128 -> Code
+ CodeGen.X86: paddd :: forall (r :: Access). Operand 'RW 'S128 -> Operand r 'S128 -> Code
- CodeGen.X86: paddq :: () => Operand RW S128 -> Operand r S128 -> Code
+ CodeGen.X86: paddq :: forall (r :: Access). Operand 'RW 'S128 -> Operand r 'S128 -> Code
- CodeGen.X86: paddw :: () => Operand RW S128 -> Operand r S128 -> Code
+ CodeGen.X86: paddw :: forall (r :: Access). Operand 'RW 'S128 -> Operand r 'S128 -> Code
- CodeGen.X86: pop :: Operand RW S64 -> Code
+ CodeGen.X86: pop :: Operand 'RW 'S64 -> Code
- CodeGen.X86: pslld :: () => Operand RW S128 -> Operand r S8 -> Code
+ CodeGen.X86: pslld :: forall (r :: Access). Operand 'RW 'S128 -> Operand r 'S8 -> Code
- CodeGen.X86: pslldq :: () => Operand RW S128 -> Operand r S8 -> Code
+ CodeGen.X86: pslldq :: forall (r :: Access). Operand 'RW 'S128 -> Operand r 'S8 -> Code
- CodeGen.X86: psllq :: () => Operand RW S128 -> Operand r S8 -> Code
+ CodeGen.X86: psllq :: forall (r :: Access). Operand 'RW 'S128 -> Operand r 'S8 -> Code
- CodeGen.X86: psllw :: () => Operand RW S128 -> Operand r S8 -> Code
+ CodeGen.X86: psllw :: forall (r :: Access). Operand 'RW 'S128 -> Operand r 'S8 -> Code
- CodeGen.X86: psrad :: () => Operand RW S128 -> Operand r S8 -> Code
+ CodeGen.X86: psrad :: forall (r :: Access). Operand 'RW 'S128 -> Operand r 'S8 -> Code
- CodeGen.X86: psraw :: () => Operand RW S128 -> Operand r S8 -> Code
+ CodeGen.X86: psraw :: forall (r :: Access). Operand 'RW 'S128 -> Operand r 'S8 -> Code
- CodeGen.X86: psrld :: () => Operand RW S128 -> Operand r S8 -> Code
+ CodeGen.X86: psrld :: forall (r :: Access). Operand 'RW 'S128 -> Operand r 'S8 -> Code
- CodeGen.X86: psrldq :: () => Operand RW S128 -> Operand r S8 -> Code
+ CodeGen.X86: psrldq :: forall (r :: Access). Operand 'RW 'S128 -> Operand r 'S8 -> Code
- CodeGen.X86: psrlq :: () => Operand RW S128 -> Operand r S8 -> Code
+ CodeGen.X86: psrlq :: forall (r :: Access). Operand 'RW 'S128 -> Operand r 'S8 -> Code
- CodeGen.X86: psrlw :: () => Operand RW S128 -> Operand r S8 -> Code
+ CodeGen.X86: psrlw :: forall (r :: Access). Operand 'RW 'S128 -> Operand r 'S8 -> Code
- CodeGen.X86: psubb :: () => Operand RW S128 -> Operand r S128 -> Code
+ CodeGen.X86: psubb :: forall (r :: Access). Operand 'RW 'S128 -> Operand r 'S128 -> Code
- CodeGen.X86: psubd :: () => Operand RW S128 -> Operand r S128 -> Code
+ CodeGen.X86: psubd :: forall (r :: Access). Operand 'RW 'S128 -> Operand r 'S128 -> Code
- CodeGen.X86: psubq :: () => Operand RW S128 -> Operand r S128 -> Code
+ CodeGen.X86: psubq :: forall (r :: Access). Operand 'RW 'S128 -> Operand r 'S128 -> Code
- CodeGen.X86: psubw :: () => Operand RW S128 -> Operand r S128 -> Code
+ CodeGen.X86: psubw :: forall (r :: Access). Operand 'RW 'S128 -> Operand r 'S128 -> Code
- CodeGen.X86: push :: () => Operand r S64 -> Code
+ CodeGen.X86: push :: forall (r :: Access). Operand r 'S64 -> Code
- CodeGen.X86: pxor :: () => Operand RW S128 -> Operand r S128 -> Code
+ CodeGen.X86: pxor :: forall (r :: Access). Operand 'RW 'S128 -> Operand r 'S128 -> Code
- CodeGen.X86: rcl :: IsSize s => Operand RW s -> Operand r S8 -> Code
+ CodeGen.X86: rcl :: forall (s :: Size) (r :: Access). IsSize s => Operand 'RW s -> Operand r 'S8 -> Code
- CodeGen.X86: rcr :: IsSize s => Operand RW s -> Operand r S8 -> Code
+ CodeGen.X86: rcr :: forall (s :: Size) (r :: Access). IsSize s => Operand 'RW s -> Operand r 'S8 -> Code
- CodeGen.X86: result :: FromReg c => c S64
+ CodeGen.X86: result :: FromReg c => c 'S64
- CodeGen.X86: rol :: IsSize s => Operand RW s -> Operand r S8 -> Code
+ CodeGen.X86: rol :: forall (s :: Size) (r :: Access). IsSize s => Operand 'RW s -> Operand r 'S8 -> Code
- CodeGen.X86: ror :: IsSize s => Operand RW s -> Operand r S8 -> Code
+ CodeGen.X86: ror :: forall (s :: Size) (r :: Access). IsSize s => Operand 'RW s -> Operand r 'S8 -> Code
- CodeGen.X86: sar :: IsSize s => Operand RW s -> Operand r S8 -> Code
+ CodeGen.X86: sar :: forall (s :: Size) (r :: Access). IsSize s => Operand 'RW s -> Operand r 'S8 -> Code
- CodeGen.X86: sbb :: IsSize s => Operand RW s -> Operand r s -> Code
+ CodeGen.X86: sbb :: forall (s :: Size) (r :: Access). IsSize s => Operand 'RW s -> Operand r s -> Code
- CodeGen.X86: shl :: IsSize s => Operand RW s -> Operand r S8 -> Code
+ CodeGen.X86: shl :: forall (s :: Size) (r :: Access). IsSize s => Operand 'RW s -> Operand r 'S8 -> Code
- CodeGen.X86: shr :: IsSize s => Operand RW s -> Operand r S8 -> Code
+ CodeGen.X86: shr :: forall (s :: Size) (r :: Access). IsSize s => Operand 'RW s -> Operand r 'S8 -> Code
- CodeGen.X86: sub :: IsSize s => Operand RW s -> Operand r s -> Code
+ CodeGen.X86: sub :: forall (s :: Size) (r :: Access). IsSize s => Operand 'RW s -> Operand r s -> Code
- CodeGen.X86: test :: IsSize s => Operand RW s -> Operand r s -> Code
+ CodeGen.X86: test :: forall (s :: Size) (r :: Access). IsSize s => Operand 'RW s -> Operand r s -> Code
- CodeGen.X86: unless :: () => Condition -> CodeM a -> CodeM ()
+ CodeGen.X86: unless :: Condition -> CodeM a -> CodeM ()
- CodeGen.X86: xchg :: IsSize s => Operand RW s -> Operand RW s -> Code
+ CodeGen.X86: xchg :: forall (s :: Size). IsSize s => Operand 'RW s -> Operand 'RW s -> Code
- CodeGen.X86: xor_ :: IsSize s => Operand RW s -> Operand r s -> Code
+ CodeGen.X86: xor_ :: forall (s :: Size) (r :: Access). IsSize s => Operand 'RW s -> Operand r s -> Code

Files

CodeGen/X86/Tests.hs view
@@ -14,7 +14,7 @@ {-# language FlexibleInstances #-} {-# language GeneralizedNewtypeDeriving #-} {-# language RecursiveDo #-}-{-# LANGUAGE TemplateHaskell #-}+{-# language TemplateHaskell #-} module CodeGen.X86.Tests   ( runTests   )
x86-64bit.cabal view
@@ -1,5 +1,5 @@ name:                x86-64bit-version:             0.4.6.1+version:             0.4.6.2 homepage:            https://github.com/divipp/x86-64 synopsis:            Runtime code generation for x86 64 bit machine code description:         The primary goal of x86-64bit is to provide a lightweight assembler for machine generated 64 bit x86 assembly instructions. See README.md for further details.@@ -21,10 +21,11 @@   location: https://github.com/divipp/x86-64  library-  exposed-modules: CodeGen.X86+  exposed-modules:+    CodeGen.X86+    CodeGen.X86.Asm   other-modules:     Control.DeeperSeq-    CodeGen.X86.Asm     CodeGen.X86.CodeGen     CodeGen.X86.CallConv     CodeGen.X86.FFI@@ -53,7 +54,7 @@     ScopedTypeVariables    build-depends:-    base       >= 4.8  && <4.15,+    base       >= 4.8  && <4.17,     monads-tf  >= 0.1  && <0.2,     tardis     >= 0.4  && <0.5,     vector     >= 0.11 && <0.13,@@ -75,7 +76,7 @@     CodeGen.X86.Tests    build-depends:-    base       >= 4.8  && <4.15,+    base       >= 4.8  && <4.17,     monads-tf  >= 0.1  && <0.2,     tardis     >= 0.4  && <0.5,     vector     >= 0.11 && <0.13,