Added asm for callout, final asm for program

Author: RedDocMD

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

@@ -1,6 +1,7 @@
 package deep.decaf.low.amd64
 
 import deep.decaf.ir.*
+import java.lang.IllegalArgumentException
 import java.lang.IllegalStateException
 
 class AsmProgramInfo {
@@ -14,6 +15,7 @@ class AsmProgramInfo {
     private val globalArrays = mutableMapOf<String, Int>() // name -> size
     private val variableStacks = mutableListOf<MutableMap<String, MemLoc>>()
     private val methodFormalParamsStack = mutableListOf<Map<String, Location>>()
+    val globalText = mutableMapOf<String, String>()
 
     fun addGlobalVariable(name: String, type: Type) {
         globalVariables[name] = type
@@ -53,7 +55,7 @@ class AsmProgramInfo {
         if (name in methodFormalParamsStack.last()) {
             return methodFormalParamsStack.last()[name]!! as MemLoc
         }
-        if (name in globalVariables)  {
+        if (name in globalVariables) {
             return MemLoc(
                 Register.instructionPointer(),
                 StringOffset(name)
@@ -77,6 +79,12 @@ class AsmProgramInfo {
     fun popMethodArgs() {
         methodFormalParamsStack.removeAt(methodFormalParamsStack.size - 1)
     }
+
+    fun addGlobalString(value: String): String {
+        val label = "LOC${globalText.size}"
+        globalText[label] = value
+        return label
+    }
 }
 
 fun irExprToLow(expr: IRExpr, info: AsmProgramInfo): List<Instruction> {
@@ -114,7 +122,46 @@ fun irExprToLow(expr: IRExpr, info: AsmProgramInfo): List<Instruction> {
                 instructions.add(MoveInstruction(Register.returnRegister(), tmp))
                 tmp
             }
-            is IRCallOutExpr -> TODO()
+            is IRCallOutExpr -> {
+                for ((i, arg) in expr.argList.withIndex()) {
+                    val register = when (i) {
+                        0 -> Register("rdi")
+                        1 -> Register("rsi")
+                        2 -> Register("rdx")
+                        3 -> Register("rcx")
+                        4 -> Register("r8")
+                        5 -> Register("r9")
+                        else -> throw IllegalArgumentException("too many arguments to callout expression")
+                    }
+                    when (arg) {
+                        is StringCallOutArg -> {
+                            val loc = info.addGlobalString(arg.arg)
+                            instructions.add(
+                                MoveInstruction(
+                                    MemLoc(Register.basePointer(), StringOffset(loc)),
+                                    register
+                                )
+                            )
+                        }
+                        is ExprCallOutArg -> {
+                            val loc = traverse(arg.arg)
+                            instructions.add(MoveInstruction(loc, register))
+                        }
+                    }
+                }
+                val mustPush = info.stackSize % 2 == 1
+                if (mustPush) {
+                    instructions.add(PushInstruction(Register.r10()))
+                }
+                instructions.add(CallInstruction(expr.name))
+                if (mustPush) {
+                    instructions.add(PopInstruction(Register.r10()))
+                }
+                val tmp = info.addVariable(getUUID())
+                instructions.add(PushInstruction(ImmediateVal(0)))
+                instructions.add(MoveInstruction(Register.returnRegister(), tmp))
+                tmp
+            }
             is IRBinOpExpr -> {
                 val leftLocation = traverse(expr.left)
                 val rightLocation = traverse(expr.right)
@@ -467,5 +514,21 @@ fun irMethodToLow(method: IRMethodDeclaration, info: AsmProgramInfo): Method {
     convert(method.block, blocks[0])
     info.popMethodArgs()
 
-    return Method(argMap, blocks)
+    return Method(argMap, blocks, method.name)
+}
+
+fun irProgramToLow(program: IRProgram): Program {
+    val info = AsmProgramInfo()
+    program.fieldDeclarations.forEach {
+        when (it) {
+            is IRRegularFieldDeclaration -> info.addGlobalVariable(it.name, it.type)
+            is IRArrayFieldDeclaration -> info.addGlobalArray(it.name, it.size)
+        }
+    }
+    val methods = program.methodDeclarations.map { irMethodToLow(it, info) }
+    val globalVariables = program.fieldDeclarations.filterIsInstance<IRRegularFieldDeclaration>().map { it.name }
+    val globalArrays = mutableMapOf<String, Int>()
+    program.fieldDeclarations.filterIsInstance<IRArrayFieldDeclaration>().forEach { globalArrays[it.name] = it.size }
+
+    return Program(globalVariables, globalArrays, info.globalText, methods)
 }

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

@@ -241,6 +241,7 @@ data class Block(val label: String?, val instructions: MutableList<Instruction>)
 data class Method(
     val formalParams: Map<String, Location>,
     val blocks: List<Block>,
+    val name: String
 ) {
     init {
         blocks[0].instructions.add(0, EnterInstruction(0))
@@ -257,7 +258,37 @@ data class Method(
 }
 
 data class Program(
-    var globalVars: List<String>,
-    var globalArrays: List<String>,
-    var methods: List<Method>
-)
+    val globalVars: List<String>,
+    val globalArrays: Map<String, Int>,
+    val globalText: Map<String, String>,
+    val methods: List<Method>
+) {
+    override fun toString(): String {
+        val stringBuilder = StringBuilder()
+        stringBuilder.append(".section .rodata").append("\n")
+        for (text in globalText.keys)  {
+            stringBuilder.append("${globalText[text]}:").append("\n")
+            stringBuilder.append("\t").append(".string \"$text\"").append("\n")
+        }
+
+        stringBuilder.append(".section .text").append("\n")
+        stringBuilder.append("\t").append(".global main").append("\n")
+        for (method in methods)  {
+            if (method.name == "main") {
+                stringBuilder.append(method.toString())
+            }
+        }
+        for (method in methods)  {
+            if (method.name != "main") {
+                stringBuilder.append(method.toString())
+            }
+        }
+        globalVars.forEach {
+            stringBuilder.append(".comm $it, 8, 8").append("\n")
+        }
+        globalArrays.keys.forEach {
+            stringBuilder.append(".comm $it, 8*${globalArrays[it]}, 8")
+        }
+        return stringBuilder.toString()
+    }
+}

src/main/kotlin/deep/decaf/tester/LowMethodTester.kt

@@ -16,14 +16,7 @@ fun main() {
         val errors = checkSemantics(irTree)
         if (errors.isNotEmpty())
             throw RuntimeException("Invalid program")
-        for (method in irTree.methodDeclarations) {
-            if (method.name == "main") {
-                val info = AsmProgramInfo()
-                val methodAsm = irMethodToLow(method, info)
-                println(file.absolutePath)
-                println(methodAsm)
-                println()
-            }
-        }
+        val program = irProgramToLow(irTree)
+        println(program)
     }
 }