src/main/wacc/backend/RuntimeError.scala

@@ -17,21 +17,10 @@ sealed trait RuntimeError {
 }
 
 object RuntimeError {
-
-  // TODO: Refactor to mitigate imports and redeclared vals perhaps
-
   import wacc.asmGenerator.stackAlign
-  import assemblyIR.Size._
-  import assemblyIR.RegName._
+  import assemblyIR.commonRegisters._
 
-  // private val RAX = Register(Q64, AX)
-  // private val EAX = Register(D32, AX)
-  private val RDI = Register(Q64, DI)
-  private val RIP = Register(Q64, IP)
-  // private val RBP = Register(Q64, BP)
-  private val RSI = Register(Q64, SI)
-  // private val RDX = Register(Q64, DX)
-  // private val RCX = Register(Q64, CX)
+  private val ERROR_CODE = 255
 
   case object ZeroDivError extends RuntimeError {
     val name = "errDivZero"
@@ -56,7 +45,7 @@ object RuntimeError {
       stackAlign,
       Load(RDI, IndexAddress(RIP, getErrLabel)),
       assemblyIR.Call(CLibFunc.PrintF),
-      Move(RDI, ImmediateVal(255)),
+      Move(RDI, ImmediateVal(ERROR_CODE)),
       assemblyIR.Call(CLibFunc.Exit)
     )
 
@@ -70,7 +59,7 @@ object RuntimeError {
       stackAlign,
       Load(RDI, IndexAddress(RIP, getErrLabel)),
       assemblyIR.Call(CLibFunc.PrintF),
-      Move(RDI, ImmediateVal(255)),
+      Move(RDI, ImmediateVal(ERROR_CODE)),
       assemblyIR.Call(CLibFunc.Exit)
     )
 
@@ -84,7 +73,7 @@ object RuntimeError {
       stackAlign,
       Load(RDI, IndexAddress(RIP, getErrLabel)),
       assemblyIR.Call(CLibFunc.PrintF),
-      Move(RDI, ImmediateVal(255)),
+      Move(RDI, ImmediateVal(ERROR_CODE)),
       assemblyIR.Call(CLibFunc.Exit)
     )
 
@@ -95,15 +84,29 @@ object RuntimeError {
     protected val errStr = "fatal error: array index %d out of bounds"
 
     protected def generateHandler(using labelGenerator: LabelGenerator): Chain[AsmLine] = Chain(
-      Move(RSI, Register(Q64, CX)),
+      Move(RSI, RCX),
       stackAlign,
       Load(RDI, IndexAddress(RIP, getErrLabel)),
       assemblyIR.Call(CLibFunc.PrintF),
-      Move(RDI, ImmediateVal(255)),
+      Move(RDI, ImmediateVal(ERROR_CODE)),
+      assemblyIR.Call(CLibFunc.Exit)
+    )
+  }
+
+  case object OutOfMemoryError extends RuntimeError {
+    val name = "errOutOfMemory"
+    protected val errStr = "fatal error: out of memory"
+
+    def generateHandler(using labelGenerator: LabelGenerator): Chain[AsmLine] = Chain(
+      stackAlign,
+      Load(RDI, IndexAddress(RIP, getErrLabel)),
+      assemblyIR.Call(CLibFunc.PrintF),
+      Move(RDI, ImmediateVal(ERROR_CODE)),
       assemblyIR.Call(CLibFunc.Exit)
     )
   }
 
   val all: Chain[RuntimeError] =
-    Chain(ZeroDivError, BadChrError, NullPtrError, OverflowError, OutOfBoundsError)
+    Chain(ZeroDivError, BadChrError, NullPtrError, OverflowError, OutOfBoundsError,
+      OutOfMemoryError)
 }

src/main/wacc/backend/asmGenerator.scala

@@ -7,26 +7,28 @@ import wacc.RuntimeError._
 object asmGenerator {
   import microWacc._
   import assemblyIR._
+  import assemblyIR.commonRegisters._
   import assemblyIR.Size._
   import assemblyIR.RegName._
   import types._
   import sizeExtensions._
   import lexer.escapedChars
 
-  private val RAX = Register(Q64, AX)
-  private val EAX = Register(D32, AX)
-  private val RDI = Register(Q64, DI)
-  private val RIP = Register(Q64, IP)
-  private val RBP = Register(Q64, BP)
-  private val RSI = Register(Q64, SI)
-  private val RDX = Register(Q64, DX)
-  private val RCX = Register(Q64, CX)
-  private val ECX = Register(D32, CX)
   private val argRegs = List(DI, SI, DX, CX, R8, R9)
 
+  private val _7_BIT_MASK = 0x7f
+
   extension [T](chain: Chain[T])
     def +(item: T): Chain[T] = chain.append(item)
 
+    /** Concatenates multiple `Chain[T]` instances into a single `Chain[T]`, appending them to the
+      * current `Chain`.
+      *
+      * @param chains
+      *   A variable number of `Chain[T]` instances to concatenate.
+      * @return
+      *   A new `Chain[T]` containing all elements from `chain` concatenated with `chains`.
+      */
     def concatAll(chains: Chain[T]*): Chain[T] =
       chains.foldLeft(chain)(_ ++ _)
 
@@ -60,11 +62,11 @@ object asmGenerator {
       stack: Stack,
       labelGenerator: LabelGenerator
   ): Chain[AsmLine] = {
-    var chain = Chain.one[AsmLine](labelGenerator.getLabelDef(builtin))
-    chain ++= funcPrologue()
-    chain ++= funcBody
-    chain ++= funcEpilogue()
-    chain
+    var asm = Chain.one[AsmLine](labelGenerator.getLabelDef(builtin))
+    asm ++= funcPrologue()
+    asm ++= funcBody
+    asm ++= funcEpilogue()
+    asm
   }
 
   private def generateUserFunc(func: FuncDecl)(using
@@ -74,29 +76,29 @@ object asmGenerator {
     // Setup the stack with param 7 and up
     func.params.drop(argRegs.size).foreach(stack.reserve(_))
     stack.reserve(Q64) // Reserve return pointer slot
-    var chain = Chain.one[AsmLine](labelGenerator.getLabelDef(func.name))
-    chain ++= funcPrologue()
+    var asm = Chain.one[AsmLine](labelGenerator.getLabelDef(func.name))
+    asm ++= funcPrologue()
     // Push the rest of params onto the stack for simplicity
     argRegs.zip(func.params).foreach { (reg, param) =>
-      chain += stack.push(param, Register(Q64, reg))
+      asm += stack.push(param, Register(Q64, reg))
     }
-    chain ++= func.body.foldMap(generateStmt(_))
+    asm ++= func.body.foldMap(generateStmt(_))
     // No need for epilogue here since all user functions must return explicitly
-    chain
+    asm
   }
 
   private def generateBuiltInFuncs()(using
       stack: Stack,
       labelGenerator: LabelGenerator
   ): Chain[AsmLine] = {
-    var chain = Chain.empty[AsmLine]
+    var asm = Chain.empty[AsmLine]
 
-    chain ++= wrapBuiltinFunc(
+    asm ++= wrapBuiltinFunc(
       Builtin.Exit,
       Chain(stackAlign, assemblyIR.Call(CLibFunc.Exit))
     )
 
-    chain ++= wrapBuiltinFunc(
+    asm ++= wrapBuiltinFunc(
       Builtin.Printf,
       Chain(
         stackAlign,
@@ -106,7 +108,7 @@ object asmGenerator {
       )
     )
 
-    chain ++= wrapBuiltinFunc(
+    asm ++= wrapBuiltinFunc(
       Builtin.PrintCharArray,
       Chain(
         stackAlign,
@@ -118,13 +120,18 @@ object asmGenerator {
       )
     )
 
-    chain ++= wrapBuiltinFunc(
+    asm ++= wrapBuiltinFunc(
       Builtin.Malloc,
-      Chain(stackAlign, assemblyIR.Call(CLibFunc.Malloc))
-      // Out of memory check is optional
+      Chain(
+        stackAlign,
+        assemblyIR.Call(CLibFunc.Malloc),
+        // Out of memory check
+        Compare(RAX, ImmediateVal(0)),
+        Jump(labelGenerator.getLabelArg(OutOfMemoryError), Cond.Equal)
+      )
     )
 
-    chain ++= wrapBuiltinFunc(
+    asm ++= wrapBuiltinFunc(
       Builtin.Free,
       Chain(
         stackAlign,
@@ -135,7 +142,7 @@ object asmGenerator {
       )
     )
 
-    chain ++= wrapBuiltinFunc(
+    asm ++= wrapBuiltinFunc(
       Builtin.Read,
       Chain(
         stackAlign,
@@ -147,39 +154,39 @@ object asmGenerator {
       )
     )
 
-    chain
+    asm
   }
 
   private def generateStmt(stmt: Stmt)(using
       stack: Stack,
       labelGenerator: LabelGenerator
   ): Chain[AsmLine] = {
-    var chain = Chain.empty[AsmLine]
+    var asm = Chain.empty[AsmLine]
     stmt match {
       case Assign(lhs, rhs) =>
         lhs match {
           case ident: Ident =>
-            if (!stack.contains(ident)) chain += stack.reserve(ident)
-            chain ++= evalExprOntoStack(rhs)
-            chain += stack.pop(RAX)
-            chain += Move(stack.accessVar(ident), RAX)
+            if (!stack.contains(ident)) asm += stack.reserve(ident)
+            asm ++= evalExprOntoStack(rhs)
+            asm += stack.pop(RAX)
+            asm += Move(stack.accessVar(ident), RAX)
           case ArrayElem(x, i) =>
-            chain ++= evalExprOntoStack(rhs)
-            chain ++= evalExprOntoStack(i)
-            chain += stack.pop(RCX)
-            chain += Compare(ECX, ImmediateVal(0))
-            chain += Jump(labelGenerator.getLabelArg(OutOfBoundsError), Cond.Less)
-            chain += stack.push(Q64, RCX)
-            chain ++= evalExprOntoStack(x)
-            chain += stack.pop(RAX)
-            chain += stack.pop(RCX)
-            chain += Compare(EAX, ImmediateVal(0))
-            chain += Jump(labelGenerator.getLabelArg(NullPtrError), Cond.Equal)
-            chain += Compare(MemLocation(RAX, D32), ECX)
-            chain += Jump(labelGenerator.getLabelArg(OutOfBoundsError), Cond.LessEqual)
-            chain += stack.pop(RDX)
+            asm ++= evalExprOntoStack(rhs)
+            asm ++= evalExprOntoStack(i)
+            asm += stack.pop(RCX)
+            asm += Compare(ECX, ImmediateVal(0))
+            asm += Jump(labelGenerator.getLabelArg(OutOfBoundsError), Cond.Less)
+            asm += stack.push(Q64, RCX)
+            asm ++= evalExprOntoStack(x)
+            asm += stack.pop(RAX)
+            asm += stack.pop(RCX)
+            asm += Compare(EAX, ImmediateVal(0))
+            asm += Jump(labelGenerator.getLabelArg(NullPtrError), Cond.Equal)
+            asm += Compare(MemLocation(RAX, D32), ECX)
+            asm += Jump(labelGenerator.getLabelArg(OutOfBoundsError), Cond.LessEqual)
+            asm += stack.pop(RDX)
 
-            chain += Move(
+            asm += Move(
               IndexAddress(RAX, KnownType.Int.size.toInt, RCX, x.ty.elemSize.toInt),
               Register(x.ty.elemSize, DX)
             )
@@ -189,250 +196,257 @@ object asmGenerator {
         val elseLabel = labelGenerator.getLabel()
         val endLabel = labelGenerator.getLabel()
 
-        chain ++= evalExprOntoStack(cond)
-        chain += stack.pop(RAX)
-        chain += Compare(RAX, ImmediateVal(0))
-        chain += Jump(LabelArg(elseLabel), Cond.Equal)
+        asm ++= evalExprOntoStack(cond)
+        asm += stack.pop(RAX)
+        asm += Compare(RAX, ImmediateVal(0))
+        asm += Jump(LabelArg(elseLabel), Cond.Equal)
 
-        chain ++= stack.withScope(() => thenBranch.foldMap(generateStmt))
-        chain += Jump(LabelArg(endLabel))
-        chain += LabelDef(elseLabel)
+        asm ++= stack.withScope(() => thenBranch.foldMap(generateStmt))
+        asm += Jump(LabelArg(endLabel))
+        asm += LabelDef(elseLabel)
 
-        chain ++= stack.withScope(() => elseBranch.foldMap(generateStmt))
-        chain += LabelDef(endLabel)
+        asm ++= stack.withScope(() => elseBranch.foldMap(generateStmt))
+        asm += LabelDef(endLabel)
 
       case While(cond, body) =>
         val startLabel = labelGenerator.getLabel()
         val endLabel = labelGenerator.getLabel()
 
-        chain += LabelDef(startLabel)
-        chain ++= evalExprOntoStack(cond)
-        chain += stack.pop(RAX)
-        chain += Compare(RAX, ImmediateVal(0))
-        chain += Jump(LabelArg(endLabel), Cond.Equal)
+        asm += LabelDef(startLabel)
+        asm ++= evalExprOntoStack(cond)
+        asm += stack.pop(RAX)
+        asm += Compare(RAX, ImmediateVal(0))
+        asm += Jump(LabelArg(endLabel), Cond.Equal)
 
-        chain ++= stack.withScope(() => body.foldMap(generateStmt))
-        chain += Jump(LabelArg(startLabel))
-        chain += LabelDef(endLabel)
+        asm ++= stack.withScope(() => body.foldMap(generateStmt))
+        asm += Jump(LabelArg(startLabel))
+        asm += LabelDef(endLabel)
 
       case call: microWacc.Call =>
-        chain ++= generateCall(call, isTail = false)
+        asm ++= generateCall(call, isTail = false)
 
       case microWacc.Return(expr) =>
         expr match {
           case call: microWacc.Call =>
-            chain ++= generateCall(call, isTail = true) // tco
+            asm ++= generateCall(call, isTail = true) // tco
           case _ =>
-            chain ++= evalExprOntoStack(expr)
-            chain += stack.pop(RAX)
-            chain ++= funcEpilogue()
+            asm ++= evalExprOntoStack(expr)
+            asm += stack.pop(RAX)
+            asm ++= funcEpilogue()
         }
     }
 
-    chain
+    asm
   }
 
   private def evalExprOntoStack(expr: Expr)(using
       stack: Stack,
       labelGenerator: LabelGenerator
   ): Chain[AsmLine] = {
-    var chain = Chain.empty[AsmLine]
+    var asm = Chain.empty[AsmLine]
     val stackSizeStart = stack.size
     expr match {
-      case IntLiter(v)  => chain += stack.push(KnownType.Int.size, ImmediateVal(v))
-      case CharLiter(v) => chain += stack.push(KnownType.Char.size, ImmediateVal(v.toInt))
-      case ident: Ident => chain += stack.push(ident.ty.size, stack.accessVar(ident))
+      case IntLiter(v)  => asm += stack.push(KnownType.Int.size, ImmediateVal(v))
+      case CharLiter(v) => asm += stack.push(KnownType.Char.size, ImmediateVal(v.toInt))
+      case ident: Ident => asm += stack.push(ident.ty.size, stack.accessVar(ident))
 
       case array @ ArrayLiter(elems) =>
         expr.ty match {
           case KnownType.String =>
             val str = elems.collect { case CharLiter(v) => v }.mkString
-            chain += Load(RAX, IndexAddress(RIP, labelGenerator.getLabelArg(str)))
-            chain += stack.push(Q64, RAX)
+            asm += Load(RAX, IndexAddress(RIP, labelGenerator.getLabelArg(str)))
+            asm += stack.push(Q64, RAX)
           case ty =>
-            chain ++= generateCall(
+            asm ++= generateCall(
               microWacc.Call(Builtin.Malloc, List(IntLiter(array.heapSize))),
               isTail = false
             )
-            chain += stack.push(Q64, RAX)
+            asm += stack.push(Q64, RAX)
             // Store the length of the array at the start
-            chain += Move(MemLocation(RAX, D32), ImmediateVal(elems.size))
+            asm += Move(MemLocation(RAX, D32), ImmediateVal(elems.size))
             elems.zipWithIndex.foldMap { (elem, i) =>
-              chain ++= evalExprOntoStack(elem)
-              chain += stack.pop(RCX)
-              chain += stack.pop(RAX)
-              chain += Move(IndexAddress(RAX, 4 + i * ty.elemSize.toInt), Register(ty.elemSize, CX))
-              chain += stack.push(Q64, RAX)
+              asm ++= evalExprOntoStack(elem)
+              asm += stack.pop(RCX)
+              asm += stack.pop(RAX)
+              asm += Move(IndexAddress(RAX, 4 + i * ty.elemSize.toInt), Register(ty.elemSize, CX))
+              asm += stack.push(Q64, RAX)
             }
         }
 
       case BoolLiter(true) =>
-        chain += stack.push(KnownType.Bool.size, ImmediateVal(1))
+        asm += stack.push(KnownType.Bool.size, ImmediateVal(1))
       case BoolLiter(false) =>
-        chain += Xor(RAX, RAX)
-        chain += stack.push(KnownType.Bool.size, RAX)
+        asm += Xor(RAX, RAX)
+        asm += stack.push(KnownType.Bool.size, RAX)
       case NullLiter() =>
-        chain += stack.push(KnownType.Pair(?, ?).size, ImmediateVal(0))
+        asm += stack.push(KnownType.Pair(?, ?).size, ImmediateVal(0))
       case ArrayElem(x, i) =>
-        chain ++= evalExprOntoStack(x)
-        chain ++= evalExprOntoStack(i)
-        chain += stack.pop(RCX)
-        chain += Compare(RCX, ImmediateVal(0))
-        chain += Jump(labelGenerator.getLabelArg(OutOfBoundsError), Cond.Less)
-        chain += stack.pop(RAX)
-        chain += Compare(EAX, ImmediateVal(0))
-        chain += Jump(labelGenerator.getLabelArg(NullPtrError), Cond.Equal)
-        chain += Compare(MemLocation(RAX, D32), ECX)
-        chain += Jump(labelGenerator.getLabelArg(OutOfBoundsError), Cond.LessEqual)
+        asm ++= evalExprOntoStack(x)
+        asm ++= evalExprOntoStack(i)
+        asm += stack.pop(RCX)
+        asm += Compare(RCX, ImmediateVal(0))
+        asm += Jump(labelGenerator.getLabelArg(OutOfBoundsError), Cond.Less)
+        asm += stack.pop(RAX)
+        asm += Compare(EAX, ImmediateVal(0))
+        asm += Jump(labelGenerator.getLabelArg(NullPtrError), Cond.Equal)
+        asm += Compare(MemLocation(RAX, D32), ECX)
+        asm += Jump(labelGenerator.getLabelArg(OutOfBoundsError), Cond.LessEqual)
         // + Int because we store the length of the array at the start
-        chain += Move(
+        asm += Move(
           Register(x.ty.elemSize, AX),
           IndexAddress(RAX, KnownType.Int.size.toInt, RCX, x.ty.elemSize.toInt)
         )
-        chain += stack.push(x.ty.elemSize, RAX)
+        asm += stack.push(x.ty.elemSize, RAX)
       case UnaryOp(x, op) =>
-        chain ++= evalExprOntoStack(x)
+        asm ++= evalExprOntoStack(x)
         op match {
           case UnaryOperator.Chr =>
-            chain += Move(EAX, stack.head)
-            chain += And(EAX, ImmediateVal(-128))
-            chain += Compare(EAX, ImmediateVal(0))
-            chain += Jump(labelGenerator.getLabelArg(BadChrError), Cond.NotEqual)
+            asm += Move(EAX, stack.head)
+            asm += And(EAX, ImmediateVal(~_7_BIT_MASK))
+            asm += Compare(EAX, ImmediateVal(0))
+            asm += Jump(labelGenerator.getLabelArg(BadChrError), Cond.NotEqual)
           case UnaryOperator.Ord => // No op needed
           case UnaryOperator.Len =>
-            chain += stack.pop(RAX)
-            chain += Move(EAX, MemLocation(RAX, D32))
-            chain += stack.push(D32, RAX)
+            asm += stack.pop(RAX)
+            asm += Move(EAX, MemLocation(RAX, D32))
+            asm += stack.push(D32, RAX)
           case UnaryOperator.Negate =>
-            chain += Xor(EAX, EAX)
-            chain += Subtract(EAX, stack.head)
-            chain += Jump(labelGenerator.getLabelArg(OverflowError), Cond.Overflow)
-            chain += stack.drop()
-            chain += stack.push(Q64, RAX)
+            asm += Xor(EAX, EAX)
+            asm += Subtract(EAX, stack.head)
+            asm += Jump(labelGenerator.getLabelArg(OverflowError), Cond.Overflow)
+            asm += stack.drop()
+            asm += stack.push(Q64, RAX)
           case UnaryOperator.Not =>
-            chain += Xor(stack.head, ImmediateVal(1))
+            asm += Xor(stack.head, ImmediateVal(1))
         }
 
       case BinaryOp(x, y, op) =>
         val destX = Register(x.ty.size, AX)
-        chain ++= evalExprOntoStack(y)
-        chain ++= evalExprOntoStack(x)
-        chain += stack.pop(RAX)
+        asm ++= evalExprOntoStack(y)
+        asm ++= evalExprOntoStack(x)
+        asm += stack.pop(RAX)
 
         op match {
           case BinaryOperator.Add =>
-            chain += Add(stack.head, destX)
-            chain += Jump(labelGenerator.getLabelArg(OverflowError), Cond.Overflow)
+            asm += Add(stack.head, destX)
+            asm += Jump(labelGenerator.getLabelArg(OverflowError), Cond.Overflow)
           case BinaryOperator.Sub =>
-            chain += Subtract(destX, stack.head)
-            chain += Jump(labelGenerator.getLabelArg(OverflowError), Cond.Overflow)
-            chain += stack.drop()
-            chain += stack.push(destX.size, RAX)
+            asm += Subtract(destX, stack.head)
+            asm += Jump(labelGenerator.getLabelArg(OverflowError), Cond.Overflow)
+            asm += stack.drop()
+            asm += stack.push(destX.size, RAX)
           case BinaryOperator.Mul =>
-            chain += Multiply(destX, stack.head)
-            chain += Jump(labelGenerator.getLabelArg(OverflowError), Cond.Overflow)
-            chain += stack.drop()
-            chain += stack.push(destX.size, RAX)
+            asm += Multiply(destX, stack.head)
+            asm += Jump(labelGenerator.getLabelArg(OverflowError), Cond.Overflow)
+            asm += stack.drop()
+            asm += stack.push(destX.size, RAX)
 
           case BinaryOperator.Div =>
-            chain += Compare(stack.head, ImmediateVal(0))
-            chain += Jump(labelGenerator.getLabelArg(ZeroDivError), Cond.Equal)
-            chain += CDQ()
-            chain += Divide(stack.head)
-            chain += stack.drop()
-            chain += stack.push(destX.size, RAX)
+            asm += Compare(stack.head, ImmediateVal(0))
+            asm += Jump(labelGenerator.getLabelArg(ZeroDivError), Cond.Equal)
+            asm += CDQ()
+            asm += Divide(stack.head)
+            asm += stack.drop()
+            asm += stack.push(destX.size, RAX)
 
           case BinaryOperator.Mod =>
-            chain += Compare(stack.head, ImmediateVal(0))
-            chain += Jump(labelGenerator.getLabelArg(ZeroDivError), Cond.Equal)
-            chain += CDQ()
-            chain += Divide(stack.head)
-            chain += stack.drop()
-            chain += stack.push(destX.size, RDX)
+            asm += Compare(stack.head, ImmediateVal(0))
+            asm += Jump(labelGenerator.getLabelArg(ZeroDivError), Cond.Equal)
+            asm += CDQ()
+            asm += Divide(stack.head)
+            asm += stack.drop()
+            asm += stack.push(destX.size, RDX)
 
-          case BinaryOperator.Eq        => chain ++= generateComparison(destX, Cond.Equal)
-          case BinaryOperator.Neq       => chain ++= generateComparison(destX, Cond.NotEqual)
-          case BinaryOperator.Greater   => chain ++= generateComparison(destX, Cond.Greater)
-          case BinaryOperator.GreaterEq => chain ++= generateComparison(destX, Cond.GreaterEqual)
-          case BinaryOperator.Less      => chain ++= generateComparison(destX, Cond.Less)
-          case BinaryOperator.LessEq    => chain ++= generateComparison(destX, Cond.LessEqual)
-          case BinaryOperator.And       => chain += And(stack.head, destX)
-          case BinaryOperator.Or        => chain += Or(stack.head, destX)
+          case BinaryOperator.Eq        => asm ++= generateComparison(destX, Cond.Equal)
+          case BinaryOperator.Neq       => asm ++= generateComparison(destX, Cond.NotEqual)
+          case BinaryOperator.Greater   => asm ++= generateComparison(destX, Cond.Greater)
+          case BinaryOperator.GreaterEq => asm ++= generateComparison(destX, Cond.GreaterEqual)
+          case BinaryOperator.Less      => asm ++= generateComparison(destX, Cond.Less)
+          case BinaryOperator.LessEq    => asm ++= generateComparison(destX, Cond.LessEqual)
+          case BinaryOperator.And       => asm += And(stack.head, destX)
+          case BinaryOperator.Or        => asm += Or(stack.head, destX)
         }
 
       case call: microWacc.Call =>
-        chain ++= generateCall(call, isTail = false)
-        chain += stack.push(call.ty.size, RAX)
+        asm ++= generateCall(call, isTail = false)
+        asm += stack.push(call.ty.size, RAX)
     }
 
-    assert(stack.size == stackSizeStart + 1)
-    chain ++= zeroRest(MemLocation(stack.head.pointer, Q64), expr.ty.size)
-    chain
+    assert(
+      stack.size == stackSizeStart + 1,
+      "Sanity check: ONLY the evaluated expression should have been pushed onto the stack"
+    )
+    asm ++= zeroRest(MemLocation(stack.head.pointer, Q64), expr.ty.size)
+    asm
   }
 
   private def generateCall(call: microWacc.Call, isTail: Boolean)(using
       stack: Stack,
       labelGenerator: LabelGenerator
   ): Chain[AsmLine] = {
-    var chain = Chain.empty[AsmLine]
+    var asm = Chain.empty[AsmLine]
     val microWacc.Call(target, args) = call
 
+    // Evaluate arguments 0-6
     argRegs
       .zip(args)
       .map { (reg, expr) =>
-        chain ++= evalExprOntoStack(expr)
+        asm ++= evalExprOntoStack(expr)
         reg
       }
+      // And set the appropriate registers
       .reverse
       .foreach { reg =>
-        chain += stack.pop(Register(Q64, reg))
+        asm += stack.pop(Register(Q64, reg))
       }
 
+    // Evaluate arguments 7 and up and push them onto the stack
     args.drop(argRegs.size).foldMap {
-      chain ++= evalExprOntoStack(_)
+      asm ++= evalExprOntoStack(_)
     }
 
     // Tail Call Optimisation (TCO)
     if (isTail) {
-      chain += Jump(labelGenerator.getLabelArg(target)) // tail call
+      asm += Jump(labelGenerator.getLabelArg(target)) // tail call
     } else {
-      chain += assemblyIR.Call(labelGenerator.getLabelArg(target)) // regular call
+      asm += assemblyIR.Call(labelGenerator.getLabelArg(target)) // regular call
     }
 
+    // Remove arguments 7 and up from the stack
     if (args.size > argRegs.size) {
-      chain += stack.drop(args.size - argRegs.size)
+      asm += stack.drop(args.size - argRegs.size)
     }
 
-    chain
+    asm
   }
 
   private def generateComparison(destX: Register, cond: Cond)(using
       stack: Stack
   ): Chain[AsmLine] = {
-    var chain = Chain.empty[AsmLine]
+    var asm = Chain.empty[AsmLine]
 
-    chain += Compare(destX, stack.head)
-    chain += Set(Register(B8, AX), cond)
-    chain ++= zeroRest(RAX, B8)
-    chain += stack.drop()
-    chain += stack.push(B8, RAX)
+    asm += Compare(destX, stack.head)
+    asm += Set(Register(B8, AX), cond)
+    asm ++= zeroRest(RAX, B8)
+    asm += stack.drop()
+    asm += stack.push(B8, RAX)
 
-    chain
+    asm
   }
 
   private def funcPrologue()(using stack: Stack): Chain[AsmLine] = {
-    var chain = Chain.empty[AsmLine]
-    chain += stack.push(Q64, RBP)
-    chain += Move(RBP, Register(Q64, SP))
-    chain
+    var asm = Chain.empty[AsmLine]
+    asm += stack.push(Q64, RBP)
+    asm += Move(RBP, Register(Q64, SP))
+    asm
   }
 
   private def funcEpilogue(): Chain[AsmLine] = {
-    var chain = Chain.empty[AsmLine]
-    chain += Move(Register(Q64, SP), RBP)
-    chain += Pop(RBP)
-    chain += assemblyIR.Return()
-    chain
+    var asm = Chain.empty[AsmLine]
+    asm += Move(Register(Q64, SP), RBP)
+    asm += Pop(RBP)
+    asm += assemblyIR.Return()
+    asm
   }
 
   def stackAlign: AsmLine = And(Register(Q64, SP), ImmediateVal(-16))

src/main/wacc/backend/assemblyIR.scala

@@ -102,7 +102,6 @@ object assemblyIR {
       opSize.toString + s"[$pointer]"
   }
 
-  // TODO to string is wacky
   case class IndexAddress(
       base: Register,
       offset: Int | LabelArg,
@@ -125,36 +124,37 @@ object assemblyIR {
     override def toString = name
   }
 
-  // TODO Check if dest and src are not both memory locations
   abstract class Operation(ins: String, ops: Operand*) extends AsmLine {
     override def toString: String = s"\t$ins ${ops.mkString(", ")}"
   }
+
+  // arithmetic operations
   case class Add(op1: Dest, op2: Src) extends Operation("add", op1, op2)
   case class Subtract(op1: Dest, op2: Src) extends Operation("sub", op1, op2)
   case class Multiply(ops: Operand*) extends Operation("imul", ops*)
   case class Divide(op1: Src) extends Operation("idiv", op1)
   case class Negate(op: Dest) extends Operation("neg", op)
-
+  // bitwise operations
   case class And(op1: Dest, op2: Src) extends Operation("and", op1, op2)
   case class Or(op1: Dest, op2: Src) extends Operation("or", op1, op2)
   case class Xor(op1: Dest, op2: Src) extends Operation("xor", op1, op2)
   case class Compare(op1: Dest, op2: Src) extends Operation("cmp", op1, op2)
-
+  case class CDQ() extends Operation("cdq")
   // stack operations
   case class Push(op1: Src) extends Operation("push", op1)
   case class Pop(op1: Src) extends Operation("pop", op1)
-  case class Call(op1: CLibFunc | LabelArg) extends Operation("call", op1)
-
+  // move operations
   case class Move(op1: Dest, op2: Src) extends Operation("mov", op1, op2)
   case class Load(op1: Register, op2: MemLocation | IndexAddress)
       extends Operation("lea ", op1, op2)
-  case class CDQ() extends Operation("cdq")
 
+  // function call operations
+  case class Call(op1: CLibFunc | LabelArg) extends Operation("call", op1)
   case class Return() extends Operation("ret")
 
+  // conditional operations
   case class Jump(op1: LabelArg, condition: Cond = Cond.Always)
       extends Operation(s"j${condition.toString}", op1)
-
   case class Set(op1: Dest, condition: Cond = Cond.Always)
       extends Operation(s"set${condition.toString}", op1)
 
@@ -213,4 +213,19 @@ object assemblyIR {
       case String => "%s"
     }
   }
+
+  object commonRegisters {
+    import Size._
+    import RegName._
+
+    val RAX = Register(Q64, AX)
+    val EAX = Register(D32, AX)
+    val RDI = Register(Q64, DI)
+    val RIP = Register(Q64, IP)
+    val RBP = Register(Q64, BP)
+    val RSI = Register(Q64, SI)
+    val RDX = Register(Q64, DX)
+    val RCX = Register(Q64, CX)
+    val ECX = Register(D32, CX)
+  }
 }