Partial implementation of cfg to low conversion

Author: RedDocMD

src/main/kotlin/deep/decaf/low/amd64/LowIRClasses.kt

@@ -1,6 +1,7 @@
 package deep.decaf.low.amd64
 
 import deep.decaf.ir.*
+import deep.decaf.low.*
 import java.lang.IllegalStateException
 import java.util.*
 
@@ -212,7 +213,7 @@ data class PushInstruction(val src: Location) : Instruction() {
     override fun toString() = "push $src"
 }
 
-data class PopInstruction(val src: Location?) : Instruction() {
+data class PopInstruction(val src: Location) : Instruction() {
     override fun toString() = "pop ${src ?: ""}"
 }
 
@@ -224,7 +225,7 @@ data class EnterInstruction(val size: ImmediateVal) : Instruction() {
     override fun toString() = "enter \$($size*8), $0"
 }
 
-data class Block(val label: String?, val instructions: List<Instruction>)
+data class Block(val label: String?, val instructions: MutableList<Instruction>)
 
 data class Method(
     var stackSize: Int,
@@ -252,7 +253,7 @@ fun irExprToLow(expr: IRExpr): List<Instruction> {
                 argLocations.forEach { instructions.add(PushInstruction(it)) }
                 instructions.add(CallInstruction(expr.name))
                 for (i in 1..expr.argList.size) {
-                    instructions.add(PopInstruction(null))
+                    instructions.add(PopInstruction(Register.r10()))
                 }
                 Register.returnRegister()
             }
@@ -454,4 +455,56 @@ fun irStatementToLow(statement: IRStatement): List<Instruction> {
     }
 
     return instructions
+}
+
+fun methodCFGToLow(name: String, cfg: CFG, blockCountStart: Int = 0) {
+    val blocks = mutableListOf<Block>()
+    var stackSize = 0
+    var blockCounts = blockCountStart
+
+    val visited = mutableMapOf<String, Boolean>()
+    fun convert(node: CFGNode, block: Block) {
+        val done = visited[node.uuid] ?: false
+        if (!done) {
+            visited[node.uuid] = true
+            when (node) {
+                is RegularNode -> {
+                    for (statement in node.statements) {
+                        block.instructions.addAll(irStatementToLow(statement))
+                    }
+                    if (node.next != null) {
+                        convert(node.next!!, block)
+                    }
+                }
+                is BlockEntryNode -> {
+                    if (node.next != null) {
+                        convert(node.next!!, block)
+                    }
+                }
+                is BlockExitNode -> {
+                    if (node.next != null) {
+                        convert(node.next!!, block)
+                    }
+                }
+                is ConditionalNode -> {
+                    val instructions = irExprToLow(node.condition)
+                    val res = (instructions.last() as MoveInstruction).dest
+                    blockCounts++
+                    val newLabel = "BLOCK$blockCounts"
+                    block.instructions.add(MoveInstruction(res, Register.r10()))
+                    block.instructions.add(CmpInstruction(Register.r10(), ImmediateVal(1)))
+                    block.instructions.add(JumpInstruction(AsmJumpOp.JNE, newLabel))
+                    if (node.truePath != null) {
+                        convert(node.truePath!!, block)
+                    }
+                    val newBlock = Block(newLabel, mutableListOf())
+                    if (node.falsePath != null) {
+                        convert(node.falsePath!!, newBlock)
+                    }
+                    blocks.add(newBlock)
+                }
+                else -> throw IllegalStateException("wrong CFG")
+            }
+        }
+    }
 }