Hello,
I'm making an assembly language DSEL in Haskell (just for fun) very
similar to the one from Russel O' Conner in [1]
I'm trying to specify a 'mov' instruction. A 'mov' instruction has two
operands: a destination and a source. There are various constraints on
the operands. They have to be of the same size (8-, 16- or 32-bit) and
they have to be in a specific format:
mov reg reg
mov reg mem
mov mem reg
mov reg imm
mov mem imm
where reg, mem and imm are register, memmory and immediate values respectively.
I would like the type system to check as many constraints as possible.
I've managed to get the size constraints working. See the source below
this mail. For example the following are all type-correct:
valid1 = mov EAX EBX
valid2 = mov BX DX
valid3 = mov AH AL
And the following doesn't pass the type checker:
invalid1 = mov EAX BX -- Couldn't match expected type `Bit16' against
inferred type `Bit32'
I would also like to get the formatting constraints working. However
the solution in the code below gives a Duplicate instance
declarations error. If I -fallow-overlapping-instances than the type
checker goes into an infinite loop.
I would like to know why this is happening and if there's a way to fix it.
Thanks in advance,
Bas van Dijk
[1] The Monad.Reader Issue 6, Russel O' Conner, Assembly: Circular
Programming with Recursive do,
http://haskell.org/sitewiki/images/1/14/TMR-Issue6.pdf
\begin{code}
{-# OPTIONS_GHC -fglasgow-exts -fallow-undecidable-instances #-}
module ASM where
import Data.Word
-- TODO: Not finished yet...
-- This is the type of instructions.
-- It's going to be a Monad like the one from Russel O'Conner:
data AsmM = AsmM deriving Show
-- Sizes of registers, memmory or immediate values
data Bit32
data Bit16
data Bit8
-- A type-level function that determines the size of a value
class Size x size | x - size
-- Types of values
class Reg reg
class Mem mem
class Imm imm
-- General Purpose Registers
-- Accumulator
data EAX = EAX; instance Reg EAX; instance Size EAX Bit32
data AX = AX; instance Reg AX; instance Size AX Bit16
data AH = AH; instance Reg AH; instance Size AH Bit8
data AL = AL; instance Reg AL; instance Size AL Bit8
-- Base
data EBX = EBX; instance Reg EBX; instance Size EBX Bit32
data BX = BX; instance Reg BX; instance Size BX Bit16
data BH = BH; instance Reg BH; instance Size BH Bit8
data BL = BL; instance Reg BL; instance Size BL Bit8
-- Counter
data ECX = ECX; instance Reg ECX; instance Size ECX Bit32
data CX = CX; instance Reg CX; instance Size CX Bit16
data CH = CH; instance Reg CH; instance Size CH Bit8
data CL = CL; instance Reg CL; instance Size CL Bit8
-- Data
data EDX = EDX; instance Reg EDX; instance Size EDX Bit32
data DX = DX; instance Reg DX; instance Size DX Bit16
data DH = DH; instance Reg DH; instance Size DH Bit8
data DL = DL; instance Reg DL; instance Size DL Bit8
-- Memmory
data Mem32 = Mem32 Word32; instance Mem Mem32; instance Size Mem32 Bit32
data Mem16 = Mem16 Word32; instance Mem Mem16; instance Size Mem16 Bit16
-- Instructions
class Mov dest src where mov :: dest - src - AsmM
instance ( Size dest size
, Size src size
, MovFormat dest src
) = Mov dest src
where
mov d s = AsmM -- TODO: Not finished yet...
class MovFormat dest src
-- If I have more than one MovFormat instance than I get a
-- Duplicate instance declaration error:
instance (Reg dest, Reg src) = MovFormat dest src
instance (Reg dest, Mem src) = MovFormat dest src
instance (Mem dest, Reg src) = MovFormat dest src
instance (Mem dest, Imm src) = MovFormat dest src
instance (Reg dest, Imm src) = MovFormat dest src
-- Tests
valid1 = mov EAX EBX
valid2 = mov BX DX
valid3 = mov AH AL
-- invalid1 = mov EAX BX -- Couldn't match expected type `Bit16'
against inferred type `Bit32'
-- invalid2 = mov EAX (Mem32 0) -- No instance for (Reg Mem32)
\end{code}
___
Haskell-Cafe mailing list
Haskell-Cafe@haskell.org
http://www.haskell.org/mailman/listinfo/haskell-cafe
