Language.Pck.Cpu.State

Evaluation monad (State monad)

type EvalCpu a = State CpuState a

the cpu eval monad

Cpu state type

data CpuState

the cpu state (processor internal state)

This is the result type from run function.

get each values by pcFromCpuState, grFromCpuState, flFromCpuState, imemFromCpuState, dmemFromCpuState, dumpCpuState

Instances

Eq CpuState

Show CpuState

pcFromCpuState :: CpuState -> Int

 > pcFromCpuState $ run [(0,[MOVI R0 7, HALT])] []
 1

grFromCpuState :: CpuState -> [Int]

 > grFromCpuState $ run [(0,[MOVI R0 7, HALT])] []
 [7,0,0,0,0,0,0,0]

flFromCpuState :: CpuState -> [Bool]

 > flFromCpuState $ run [(0,[MOVI R0 7, HALT])] []
 [False,False]

imemFromCpuState :: CpuState -> InstImage

 > imemFromCpuState $ run [(0,[MOVI R0 7, HALT])] []
 [(0,[MOVI R0 7,HALT,UNDEF,UNDEF,...])]

dmemFromCpuState :: CpuState -> DataImage

 > dmemFromCpuState $ run [(0,[MOVI R0 0, MOVI R1 10, ST R0 R1, HALT])] []
 [(0,[10,0,0,0,0,...])]

dumpCpuState :: CpuState -> String

dump Cpu state (without instruction image)

 > putStr $ dumpCpuState $ run [(0,[MOVI R0 7, HALT])] []
 pc : 1
 gr : [7,0,0,0,0,0,0,0]
 fl : [False,False]
 dm : [(0,[7,0,0,0,0,...])]

initCpuState :: CpuState

a default CpuState

initCpuStateMem :: InstImage -> DataImage -> CpuState

initialize CpuState by inst and data image

Result type

data ResultStat

the result state

Constructors

RsNormal

normal result

RsHalt

cpu halt(stop)

RsDbgBrk

debugger triggered

RsErr String

execution error

Instances

Eq ResultStat

Show ResultStat

access for the Cpu state

PC(program counter)

readPc :: EvalCpu Int

read the pc

updatePc :: Int -> EvalCpu ResultStat

update the pc

Example:

 jumpRI :: Int -> EvalCpu ResultStat
 jumpRI ad = do pc <- readPc
                updatePc (pc + ad)

incPc :: EvalCpu ResultStat

increment the pc

General purpose registers

readGReg :: GReg -> EvalCpu Int

read a general purpose register

Example:

 jump :: GReg -> EvalCpu ResultStat
 jump reg = do ad <- readGReg reg
               updatePc ad

readGReg2 :: GReg -> GReg -> EvalCpu (Int, Int)

read general purpose register pair

updateGReg :: GReg -> Int -> EvalCpu ()

update a general purpose register

Example:

 movpc :: GReg -> EvalCpu ResultStat
 movpc reg = do pc <- readPc
                updateGReg reg pc

Flags

readFlags :: EvalCpu FlagArray

read flag registers

Example:

 branchRI :: FCond -> Int -> EvalCpu ResultStat
 branchRI fcond ad  = do flags <- readFlags
                         if judgeFCond flags fcond
                            then jumpRI ad
                            else incPc

updateFlag :: Flag -> Bool -> EvalCpu ()

update a flag

Example:

 cmpRR :: GReg -> GReg -> EvalCpu ResultStat
 cmpRR ra rb = do (ra', rb') <- readGReg2 ra rb
                  updateFlag FLZ (ra' == rb')
                  updateFlag FLC (ra' <  rb')

Instruction memory

fetchInst :: EvalCpu Inst

fetch an instruction from the instruction memory

Data memory

readDmem :: Int -> EvalCpu Int

read a data value from the data memory

Example:

 load :: GReg -> GReg -> EvalCpu ResultStat
 load ra rb = do rb' <- readGReg rb
                 ra' <- readDmem rb'
                 updateGReg ra ra'

updateDmem :: Int -> Int -> EvalCpu ()

update the data memory

Example:

 store :: GReg -> GReg -> EvalCpu ResultStat
 store ra rb = do (ra', rb') <- readGReg2 ra rb
                  updateDmem ra' rb'