diff --git a/src/main/wacc/backend/RuntimeError.scala b/src/main/wacc/backend/RuntimeError.scala index 5252f9c..8e12831 100644 --- a/src/main/wacc/backend/RuntimeError.scala +++ b/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) } diff --git a/src/main/wacc/backend/asmGenerator.scala b/src/main/wacc/backend/asmGenerator.scala index c78c3d1..2a7366d 100644 --- a/src/main/wacc/backend/asmGenerator.scala +++ b/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)) diff --git a/src/main/wacc/backend/assemblyIR.scala b/src/main/wacc/backend/assemblyIR.scala index d2d374a..9ba65ea 100644 --- a/src/main/wacc/backend/assemblyIR.scala +++ b/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) + } }