X-Git-Url: http://git.joshuawise.com/snipe.git/blobdiff_plain/0a24e44d4e9f82f8d3d83de8e58c83c8cf2868b6..6ade8b0a3251e44b34c6bdbbd9403e36d6fd6231:/codegen/solidify.sml diff --git a/codegen/solidify.sml b/codegen/solidify.sml index 48fad39..8c39017 100644 --- a/codegen/solidify.sml +++ b/codegen/solidify.sml @@ -1,4 +1,4 @@ -(* L2 Compiler +(* L3 Compiler * Takes a list of mappings of temporaries to colors and a pseudoasm listing, * then produces x86 code. * Author: Chris Lu @@ -26,7 +26,7 @@ struct fun solidify (regmap : colorings) (instrs : asm) : asm = let (* r14d and r15d is reserved for spilling *) - val maxreg = X.regtonum X.R13D + val maxreg = X.regtonum X.R14D fun numtoreg n = if (n > maxreg) then raise Spilled @@ -35,59 +35,97 @@ struct fun temptonum (t: T.temp) : int = (List.hd (List.map (fn (_, n) => n) - (List.filter (fn (a, _) => (Temp.compare (a, t) = EQUAL)) regmap))) + (List.filter (fn (a, _) => (Temp.eq (a, t))) regmap))) fun temptoreg (t: T.temp) : x86.reg = numtoreg (temptonum t) - handle Empty => - (ErrorMsg.warn NONE ("Uncolored temp "^(Temp.name t)^" -- dead code?") ; - X.R15D) (*If we don't care about the output, then it is cool to explode this; R15D is guaranteed not to be used across builtin blocks.*) - - val spillreg1 = X.R14D - - val prologue = [X.DIRECTIVE "\tpush %rbx\n\tpush %r12\n\tpush %r13\n\tpush %r14\n\tpush %r15"] (* Could be done better. *) - val epilogue = [X.DIRECTIVE "\tpop %r15\n\tpop %r14\n\tpop %r13\n\tpop %r12\n\tpop %rbx"] - + handle Empty => raise ErrorMsg.InternalError ("Uncolored temp "^(Temp.name t)^", agh!") + + val spillreg1 = X.R15D + + (* Determine which need to be saved. *) + val opsused = map (fn (_, n) => X.REG (numtoreg n handle Spilled => X.R15D)) regmap + val saveregs = X.OperSet.intersection ( + X.OperSet.addList (X.OperSet.empty, opsused), + X.OperSet.addList ( + X.OperSet.empty, + [X.REG X.EBX, + X.REG X.EBP, + X.REG X.R12D, + X.REG X.R13D, + X.REG X.R14D, + X.REG X.R15D])) + val savelist = X.OperSet.listItems saveregs + val nsave = length savelist + val numreg = foldr (Int.max) 0 (map (fn (_, n) => n) regmap) (* Number of registers used. *) val nspilled = Int.max (numreg - maxreg, 0) (* Number of spilled registers. *) fun isspilled (X.TEMP temp) = (((temptonum temp) > maxreg) handle Empty => false) (* Whether a register is spilled *) + | isspilled (X.STACKARG _) = true + | isspilled (X.REL _) = true | isspilled _ = false - fun stackpos (reg: int) = (reg - maxreg) * ~4 (* Stack position of some register number *) - + val stacksz = (nspilled + nsave) * 8 + fun stackpos (reg: int) = stacksz - (reg - maxreg + nsave) * 8 (* Stack position of some register number *) + + val prologue = + (X.SIZE (X.Qword, X.SUB (X.REG X.RSP, X.CONST (Word32.fromInt stacksz)))) :: + (ListPair.map + (fn (num, reg) => + X.SIZE (X.Qword, X.MOV (X.REL (X.RSP, stacksz - 8*(num+1)), reg))) + (List.tabulate (nsave, fn x => x), savelist)) + val epilogue = + (ListPair.map + (fn (num, reg) => + X.SIZE (X.Qword, X.MOV (reg, X.REL (X.RSP, stacksz - 8*(num+1))))) + (List.tabulate (nsave, fn x => x), savelist)) @ + [X.SIZE (X.Qword, X.ADD (X.REG X.RSP, X.CONST (Word32.fromInt stacksz)))] + val endlbl = Label.new() + fun spill (X.TEMP temp, xreg: x86.reg) = (* Spill a register if need be. *) if (isspilled (X.TEMP temp)) - then [X.MOVL (X.REL (X.RSP, stackpos (temptonum temp)), X.REG xreg)] + then [X.MOV (X.REL (X.RSP, stackpos (temptonum temp)), X.REG xreg)] else nil + | spill (X.STACKARG _, _) = raise ErrorMsg.InternalError "Cannot spill to a stack arg" + | spill (a as X.REL _, xreg) = [X.MOV (a, X.REG xreg)] | spill _ = nil (* Nothing else can be spilled. *) fun unspill (X.TEMP temp, xreg: x86.reg) = (* Unspill a register if need be. *) if (isspilled (X.TEMP temp)) - then [X.MOVL (X.REG xreg, X.REL (X.RSP, stackpos (temptonum temp)))] + then [X.MOV (X.REG xreg, X.REL (X.RSP, stackpos (temptonum temp)))] else nil + | unspill (X.STACKARG arg, xreg) = [X.MOV (X.REG xreg, X.REL (X.RSP, stacksz + 8 + (arg * 8)))] + | unspill (a as X.REL _, xreg) = [X.MOV (X.REG xreg, a)] | unspill _ = nil fun realoper (X.TEMP temp) = X.REG (temptoreg temp) (* Makes a operand 'real'. *) + | realoper (X.STACKARG arg) = raise Spilled + | realoper (X.REL _) = raise Spilled | realoper r = r + fun stackoper (X.TEMP temp) = if not (isspilled (X.TEMP temp)) then raise ErrorMsg.InternalError "stackoper on unspilled temp?" else X.REL (X.RSP, stackpos (temptonum temp)) + | stackoper (X.STACKARG arg) = X.REL (X.RSP, stacksz + 8 + (arg * 8)) + | stackoper (a as X.REL _) = a | stackoper _ = raise ErrorMsg.InternalError "stackoper on not temp?" fun transform (X.DIRECTIVE s) = [X.DIRECTIVE s] | transform (X.COMMENT s) = [X.COMMENT s] - | transform (X.MOVL (dest, src)) = + | transform (X.LIVEIGN a) = transform a + | transform (X.SIZE (s, i)) = map (fn i' => (X.SIZE (s, i'))) (transform i) + | transform (X.MOV (dest, src)) = if (isspilled dest) then unspill (src, spillreg1) @ - [ X.MOVL( + [X.MOV( realoper dest handle Spilled => stackoper dest, realoper src handle Spilled => X.REG spillreg1)] else - [ X.MOVL( + [X.MOV( realoper dest handle Spilled => raise ErrorMsg.InternalError "But we said that wasn't spilled?", realoper src handle Spilled => stackoper src)] - | transform (X.SUBL (dest, src)) = + | transform (X.SUB (dest, src)) = unspill (src, spillreg1) @ - [ X.SUBL( + [ X.SUB( realoper dest handle Spilled => stackoper dest, realoper src handle Spilled => X.REG spillreg1)] | transform (X.IMUL (dest, src)) = @@ -102,47 +140,47 @@ struct realoper src handle Spilled => stackoper src, const)] @ spill (dest, spillreg1) - | transform (X.ADDL (dest, src)) = (* You can have either operand spilled, but not both. Pick one. *) + | transform (X.ADD (dest, src)) = (* You can have either operand spilled, but not both. Pick one. *) if (isspilled dest) then unspill (src, spillreg1) @ - [ X.ADDL( + [ X.ADD( realoper dest handle Spilled => stackoper dest, realoper src handle Spilled => X.REG spillreg1)] else - [ X.ADDL( + [ X.ADD( realoper dest handle Spilled => raise ErrorMsg.InternalError "But we said that wasn't spilled?", realoper src handle Spilled => stackoper src)] - | transform (X.IDIVL (src)) = [ X.IDIVL(realoper src handle Spilled => stackoper src)] + | transform (X.IDIV (src)) = [ X.IDIV(realoper src handle Spilled => stackoper src)] | transform (X.NEG (src)) = [ X.NEG(realoper src handle Spilled => stackoper src)] - | transform (X.NOTL (src)) = [ X.NOTL(realoper src handle Spilled => stackoper src)] - | transform (X.SALL (dest, shft)) = - [ X.SALL ( + | transform (X.NOT (src)) = [ X.NOT(realoper src handle Spilled => stackoper src)] + | transform (X.SAL (dest, shft)) = + [ X.SAL ( realoper dest handle Spilled => stackoper dest, shft)] - | transform (X.SARL (dest, shft)) = - [ X.SARL ( + | transform (X.SAR (dest, shft)) = + [ X.SAR ( realoper dest handle Spilled => stackoper dest, shft)] | transform (X.CLTD) = [ X.CLTD ] - | transform (X.ANDL (dest, src)) = + | transform (X.AND (dest, src)) = unspill (src, spillreg1) @ - [ X.ANDL( + [ X.AND( realoper dest handle Spilled => stackoper dest, realoper src handle Spilled => X.REG spillreg1)] - | transform (X.ORL (dest, src)) = + | transform (X.OR (dest, src)) = unspill (src, spillreg1) @ - [ X.ORL( + [ X.OR( realoper dest handle Spilled => stackoper dest, realoper src handle Spilled => X.REG spillreg1)] - | transform (X.XORL (dest, src)) = + | transform (X.XOR (dest, src)) = unspill (src, spillreg1) @ - [ X.XORL( + [ X.XOR( realoper dest handle Spilled => stackoper dest, realoper src handle Spilled => X.REG spillreg1)] - | transform (X.CMPL (op1, op2)) = + | transform (X.CMP (op1, op2)) = unspill (op2, spillreg1) @ - [ X.CMPL( + [ X.CMP( realoper op1 handle Spilled => stackoper op1, realoper op2 handle Spilled => X.REG spillreg1)] | transform (X.TEST (op1, op2)) = @@ -150,25 +188,21 @@ struct [ X.TEST( realoper op1 handle Spilled => stackoper op1, realoper op2 handle Spilled => X.REG spillreg1)] - | transform (X.SETNE (src)) = [ X.SETNE(realoper src handle Spilled => stackoper src)] - | transform (X.SETE (src)) = [ X.SETE(realoper src handle Spilled => stackoper src)] - | transform (X.SETLE (src)) = [ X.SETLE(realoper src handle Spilled => stackoper src)] - | transform (X.SETL (src)) = [ X.SETL(realoper src handle Spilled => stackoper src)] - | transform (X.SETGE (src)) = [ X.SETGE(realoper src handle Spilled => stackoper src)] - | transform (X.SETG (src)) = [ X.SETG(realoper src handle Spilled => stackoper src)] - | transform (X.MOVZBL (dest, src)) = - [ X.MOVZBL( + | transform (X.SETcc (c,src)) = [ X.SETcc(c, realoper src handle Spilled => stackoper src)] + | transform (X.CALL l) = [ X.CALL l ] + | transform (X.MOVZB (dest, src)) = + [ X.MOVZB( realoper dest handle Spilled => X.REG spillreg1, realoper src handle Spilled => stackoper src)] @ spill (dest, spillreg1) - | transform (X.RET) = epilogue @ [X.RET] + | transform (X.RET) = if nsave < 2 then (epilogue @ [X.RET]) else [X.JMP endlbl] | transform (X.LABEL l) = [ X.LABEL l ] | transform (X.JMP l) = [ X.JMP l ] - | transform (X.JE l) = [ X.JE l] - | transform (X.JNE l) = [ X.JNE l] -(* | transform _ = raise ErrorMsg.InternalError ("Unimplemented transform")*) + | transform (X.Jcc (c,l)) = [X.Jcc (c,l)] in - List.concat (prologue :: (map transform instrs)) - + if (nsave < 2) then + List.concat (prologue :: (map transform instrs)) + else + List.concat (prologue :: ((map transform instrs) @ [[X.LABEL endlbl], epilogue, [X.RET]])) end end