Code generation.

[snipe.git] / optimize / optimizer.sml

signature OPTIMIZER =
sig
  datatype optfunc =
    IRPROG of (Tree.program -> Tree.program) |
    IRFUNC of (Tree.func -> Tree.func) |
    IRSTM of (Tree.stm -> Tree.stm list) |
    IREXP of (Tree.exp -> Tree.exp) |
    PRELIVENESS of (Blarg.insn list -> Blarg.insn list) |
    FINAL of (Blarg.insn list -> Blarg.insn list)
  
  type optimization = {
    shortname : string,
    description : string,
    func : optfunc
    }
  
  val optimize_ir : optimization list -> Tree.program -> Tree.program
  val optimize_preliveness : optimization list -> Blarg.insn list -> Blarg.insn list
  val optimize_final : optimization list -> Blarg.insn list -> Blarg.insn list
end

structure Optimizer :> OPTIMIZER =
struct
  structure T = Tree
  
  datatype optfunc =
    IRPROG of (Tree.program -> Tree.program) |
    IRFUNC of (Tree.func -> Tree.func) |
    IRSTM of (Tree.stm -> Tree.stm list) |
    IREXP of (Tree.exp -> Tree.exp) |
    PRELIVENESS of (Blarg.insn list -> Blarg.insn list) |
    FINAL of (Blarg.insn list -> Blarg.insn list)
  
  type optimization = {
    shortname : string,
    description : string,
    func : optfunc
    }
  
  fun foldfunc f (T.FUNCTION (id, stml)) = T.FUNCTION (id, List.concat (List.map f stml))
  fun expfunc f (T.MOVE (e1, e2)) = [T.MOVE (f e1, f e2)]
    | expfunc f (T.RETURN (e, s)) = [T.RETURN (f e, s)]
    | expfunc f (T.EFFECT e) = [T.EFFECT (f e)]
    | expfunc f (a as T.LABEL _) = [a]
    | expfunc f (T.JUMPIFN (e, l)) = [T.JUMPIFN (f e, l)]
    | expfunc f (a as T.JUMP _) = [a]
  
  fun optimize_ir ol prog =
    foldr (
      fn (IRPROG f, prog) => f prog
       | (IRFUNC f, prog) => List.map f prog
       | (IRSTM  f, prog) => List.map (foldfunc (f)) prog
       | (IREXP  f, prog) => List.map (foldfunc (expfunc f)) prog
       | (_, prog) => prog)
      prog
      (map (fn (x : optimization) => #func x) ol)
  
  fun optimize_preliveness ol assem =
    foldr (
      fn (PRELIVENESS f, assem) => f assem
       | (_, assem) => assem)
      assem
      (map (fn (x : optimization) => #func x) ol)
  
  fun optimize_final ol assem =
    foldr (
      fn (FINAL f, assem) => f assem
       | (_, assem) => assem)
      assem
      (map (fn (x : optimization) => #func x) ol)
end

signature OPTIMIZATION =
sig
  val optimizer : Optimizer.optimization
end