impl and test backend

Author: paulzfm

src/main/java/decaf/lowlevel/log/Log.java

@@ -141,6 +141,7 @@ public static void ifLoggable(Level level, Consumer<IndentPrinter> action) {
         if (L.isLoggable(level)) {
             var printer = new IndentPrinter(outs, true);
             action.accept(printer);
+            printer.flush();
         }
     }
 }

src/main/scala/decaf/backend/asm/Asm.scala

@@ -0,0 +1,53 @@
+package decaf.backend.asm
+
+import java.io.PrintWriter
+import java.util.logging.Level
+
+import decaf.backend.dataflow.{CFG, LivenessAnalyzer}
+import decaf.backend.reg.RegAlloc
+import decaf.driver.{Config, Phase}
+import decaf.lowlevel.instr.PseudoInstr
+import decaf.lowlevel.log.Log
+import decaf.lowlevel.tac.TacProg
+import decaf.printing.PrettyCFG
+import decaf.util.Conversions._
+
+/**
+  * The assembly code generation phase: translate a TAC program to assembly code.
+  *
+  * @param emitter  helper assembly code emitter
+  * @param regAlloc register allocator
+  */
+class Asm(val emitter: AsmEmitter, val regAlloc: RegAlloc) extends Phase[TacProg, String]("asm: " + emitter) {
+
+  override def transform(prog: TacProg): String = {
+    Log.info("phase: asm")
+    val analyzer = new LivenessAnalyzer[PseudoInstr]
+
+    for (vtbl <- prog.vtables) {
+      Log.info("emit vtable for %s", vtbl.className)
+      emitter.emitVTable(vtbl)
+    }
+
+    emitter.emitSubroutineBegin()
+    for (func <- prog.funcs) {
+      Log.info("emit func for %s", func.entry.prettyString)
+      val (instrSeq, info) = emitter.selectInstr(func)
+      val cfg = CFG.buildFrom(instrSeq)
+      analyzer(cfg)
+      Log.ifLoggable(Level.FINE, printer => new PrettyCFG[PseudoInstr](printer).pretty(cfg))
+      regAlloc(cfg, info)
+    }
+
+    emitter.emitEnd()
+  }
+
+  override def post(code: String)(implicit config: Config): Unit = {
+    if (config.target.equals(Config.Target.PA5)) {
+      val path = config.dstDir / config.sourceBaseName + ".s"
+      val printer = new PrintWriter(path)
+      printer.print(code)
+      printer.close()
+    }
+  }
+}

src/main/scala/decaf/backend/asm/AsmEmitter.scala

@@ -0,0 +1,59 @@
+package decaf.backend.asm
+
+import decaf.lowlevel.AsmCodePrinter
+import decaf.lowlevel.instr.{PseudoInstr, Reg}
+import decaf.lowlevel.tac.{TacFunc, VTable}
+
+
+/**
+  * Emit assembly code.
+  *
+  * @param platformName    target platform name
+  * @param allocatableRegs platform-specific registers accounted for register allocation, i.e. general registers
+  * @param callerSaveRegs  platform-specific registers that need be saved by caller.
+  */
+abstract class AsmEmitter(val platformName: String, val allocatableRegs: Array[Reg], val callerSaveRegs: Array[Reg]) {
+  /**
+    * Emit assembly code for a virtual table.
+    *
+    * @param vtbl virtual table
+    */
+  def emitVTable(vtbl: VTable): Unit
+
+  /**
+    * Instruction selection for a TAC function.
+    * <p>
+    * Since no register allocation is done, the generated instructions may still contain pseudo registers (temps).
+    *
+    * @param func TAC function
+    * @return a pair of the instruction sequence, and the basic info of the function
+    */
+  def selectInstr(func: TacFunc): (List[PseudoInstr], SubroutineInfo)
+
+  /**
+    * Call this when all virtual tables are done, and you want to emit code for subroutines.
+    */
+  def emitSubroutineBegin(): Unit
+
+  /**
+    * Begin to emit code for a subroutine.
+    *
+    * @param info basic info of this subroutine
+    * @return emitter of this subroutine
+    */
+  def emitSubroutine(info: SubroutineInfo): SubroutineEmitter
+
+  /**
+    * Call this when all subroutines are done, and you want to finish.
+    *
+    * @return string representation of the emitted assembly code
+    */
+  def emitEnd(): String
+
+  override def toString: String = platformName
+
+  /**
+    * Assembly code pretty printer.
+    */
+  final protected[asm] val printer = new AsmCodePrinter
+}

src/main/scala/decaf/backend/asm/Holes.scala

@@ -0,0 +1,21 @@
+package decaf.backend.asm
+
+import decaf.lowlevel.instr.{PseudoInstr, Temp}
+
+/**
+  * A trick to encode some holes as normal pseudo instructions.
+  *
+  * @see [[decaf.backend.asm.Holes.CallerSave]]
+  * @see [[decaf.backend.asm.Holes.CallerRestore]]
+  */
+object Holes {
+
+  object CallerSave extends PseudoInstr(new Array[Temp](0), new Array[Temp](0)) {
+    override def toString: String = "# TODO: caller save"
+  }
+
+  object CallerRestore extends PseudoInstr(new Array[Temp](0), new Array[Temp](0)) {
+    override def toString: String = "# TODO: caller restore"
+  }
+
+}

src/main/scala/decaf/backend/asm/SubroutineEmitter.scala

@@ -0,0 +1,64 @@
+package decaf.backend.asm
+
+import decaf.lowlevel.AsmCodePrinter
+import decaf.lowlevel.instr.{NativeInstr, Reg, Temp}
+import decaf.lowlevel.label.Label
+
+/**
+  * Emit assembly code for a subroutine.
+  *
+  * @param emitter attached [[AsmEmitter]]
+  * @param info    basic info of this subroutine
+  */
+abstract class SubroutineEmitter protected(val emitter: AsmEmitter, var info: SubroutineInfo) {
+  /**
+    * Append an assembly instruction that stores the value of a register to stack.
+    *
+    * @param src  source register
+    * @param temp the bound temp of `src`
+    */
+  def emitStoreToStack(src: Reg, temp: Temp): Unit
+
+  /**
+    * Append an assembly instruction that loads a value from stack to a register.
+    *
+    * @param dst destination register
+    * @param src source temp
+    */
+  def emitLoadFromStack(dst: Reg, src: Temp): Unit
+
+  /**
+    * Append an assembly instruction that copies value between two registers.
+    *
+    * @param dst destination register
+    * @param src source register
+    */
+  def emitMove(dst: Reg, src: Reg): Unit
+
+  /**
+    * Append a given assembly instruction.
+    *
+    * @param instr assembly instruction
+    */
+  def emitNative(instr: NativeInstr): Unit
+
+  /**
+    * Append a label.
+    *
+    * @param label label
+    */
+  def emitLabel(label: Label): Unit
+
+  /**
+    * Call this when you have appended all user and synthetic (by register allocation algorithm) instructions of
+    * this subroutine.
+    *
+    * @param used used registers during register allocation
+    */
+  def emitEnd(used: Set[Reg]): Unit
+
+  /**
+    * Assembly code pretty printer.
+    */
+  protected var printer: AsmCodePrinter = emitter.printer
+}

src/main/scala/decaf/backend/asm/SubroutineInfo.scala

@@ -0,0 +1,13 @@
+package decaf.backend.asm
+
+import decaf.lowlevel.label.FuncLabel
+
+/**
+  * Basic info of subroutine.
+  *
+  * @param funcLabel label of the function entry
+  * @param numArgs   number of arguments
+  * @param hasCalls  does this subroutine call others?
+  * @param argsSize  max. stack size needed to store arguments
+  */
+case class SubroutineInfo(funcLabel: FuncLabel, numArgs: Int, hasCalls: Boolean, argsSize: Int)