sword-smith/hfasto

Implementing a compiler for the fuctional programming language fasto in Haskell

hfasto's Issues

Create folder structure appropriate for testing

Troels: Can you make a folder structure which is appropriate for testing? I would like to run unit tests on various function in the different modules located in src/ but when I create test modules in T/, I cannot get those modules to import the modules found in src/

Loading of 4+ registers and register allocation

When a function is called with more than four arguments the arguments are loaded from the stack. Currently, the instructions to load these arguments is located in the function loadRegistersH in MipsCodeGenerator.hs. But spilling, which is handled in the MipsRegAlloc, may wrap the entire body in instructions that move the stack pointer and the code generated by loadRegistersH is considered part of the body.

The solution is probably to give the code generated by the loadRegisters function a special place in the mipsFunction record and then rewrite all the load instructions when it is known how much the register allocator moves the stack pointer before the loadRegisters code is executed.

Some of the relevant parts of the code are presented below

saveArgRegs :: [] String -> [] Mips.Instruction
saveArgRegs args = saveArgRegsH 0 args

saveArgRegsH :: Int -> [] String -> [] Mips.Instruction
saveArgRegsH _ []         = []
saveArgRegsH i (arg:args) = if i < 4
                            then Mips.XOR ("$a" ++ show i) arg zero :
                                 Mips.SW arg "$sp" (show (i*4)) :
                                 saveArgRegsH (i+1) args
                            else Mips.SW arg "$sp" (show (i*4)) :
                                 saveArgRegsH (i+1) args

-- Atm, no proper liveness analysis is done with these "string:strings"
loadRegisters :: [] String -> [] Mips.Instruction
loadRegisters args = loadRegistersH 0 args

-- The "8" in the below function cannot be hardcoded since the register allocator
-- may invalidate that number.
-- The solution may be to introduce a loadRegisters value with which the
-- register allocator may shift all the special, symbolic lw operations?
-- They can also just be rewritten if the are part of the loadArgs part of the
-- MipsFunction struct.
loadRegistersH :: Int -> [] String -> [] Mips.Instruction
loadRegistersH _ []         = []
loadRegistersH i (arg:args) = if i < 4
                              then Mips.XOR arg ("$a" ++ (show i)) zero :
                                   loadRegistersH (i + 1) args
                              else Mips.LW arg "$sp" (show (i*4 + 8)) :
                                   loadRegistersH (i + 1) args

regAllocInst spillingRewrite vtable (Mips.JAL l) = do-- Here the store and load stuff should be handled. Potentially in a monade?
  regEnv <- get
  i <- incr
  let sliveRegs = S.toList $ (livenessInSets regEnv !! i)
  rliveRegs <- mapM (mapReg vtable) sliveRegs
  store <- storeLive (rliveRegs ++ ["$ra"])
  load  <- loadLive $ rliveRegs  ++ ["$ra"]
  if spillingRewrite
    then return [Mips.JAL l]
    else return $ store ++ [Mips.JAL l] ++ load