X-Git-Url: http://git.joshuawise.com/snipe.git/blobdiff_plain/0a24e44d4e9f82f8d3d83de8e58c83c8cf2868b6..1144856ba9d6018d9922c6ede7e97779a0fe6373:/codegen/solidify.sml

diff --git a/codegen/solidify.sml b/codegen/solidify.sml
index 48fad39..21b37bc 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 <czl@andrew.cmu.edu>
@@ -31,144 +31,215 @@ struct
           if (n > maxreg)
           then raise Spilled
           else X.numtoreg n
-      
+
       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"]
-      
-      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 *)
+        handle Empty => raise ErrorMsg.InternalError ("Uncolored temp "^(Temp.name t)^", agh!")
+
+      val spillreg1 = X.R15D
+      val spillreg2 = X.R14D
+
+      (* Determine which need to be saved. *)
+      val opsused = (map (fn (_, n) => X.REG (numtoreg n handle Spilled => X.R15D)) regmap) @ [X.REG X.R14D]
+      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    (* Whether a register is spilled *)
+        | isspilled (X.STACKARG _) = true
+        | isspilled (X.REL _) = true
+        | isspilled (X.OSIZE (_, oo)) = isspilled oo
         | isspilled _ = false
-      fun stackpos (reg: int) = (reg - maxreg) * ~4	(* Stack position of some register number *)
-      
-      fun spill (X.TEMP temp, xreg: x86.reg) =	(* Spill a register if need be. *)
+      val stacksz = (nspilled + nsave) * 8
+      fun stackpos (reg: int) = stacksz - (reg - maxreg + nsave) * 8    (* Stack position of some register number *)
+
+      val prologue =
+        (X.SUB (X.OSIZE (X.Qword, X.REG X.RSP), X.CONST (Word32.fromInt stacksz))) ::
+        (ListPair.map
+          (fn (num, reg) =>
+            X.MOV (X.OSIZE (X.Qword, X.REL (X.REG X.RSP, X.CONST (Word32.fromInt (stacksz - 8*(num+1))))), X.OSIZE (X.Qword, reg)))
+          (List.tabulate (nsave, fn x => x), savelist))
+      val epilogue =
+        (ListPair.map
+          (fn (num, reg) =>
+            X.MOV (X.OSIZE (X.Qword, reg), X.REL (X.REG X.RSP, X.CONST (Word32.fromInt (stacksz - 8*(num+1))))))
+          (List.tabulate (nsave, fn x => x), savelist)) @
+        [X.ADD (X.OSIZE (X.Qword, X.REG X.RSP), X.CONST (Word32.fromInt stacksz))]
+      val endlbl = Label.new()
+
+      fun spill s (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.OSIZE(s, X.REL (X.REG X.RSP, (X.CONST o Word32.fromInt o stackpos o temptonum) temp)), X.REG xreg)]
           else nil
-        | spill _ = nil		(* Nothing else can be spilled. *)
-      fun unspill (X.TEMP temp, xreg: x86.reg) =	(* Unspill a register if need be. *)
+        | spill s (X.STACKARG _, _) = raise ErrorMsg.InternalError "Cannot spill to a stack arg"
+        | spill s (a as X.REL _, xreg) = [X.MOV (X.OSIZE(s,a), X.REG xreg)]
+        | spill s (X.OSIZE (s', oo), xreg) = spill s' (X.stripsize oo, xreg)
+        | spill _ _ = nil        (* Nothing else can be spilled. *)
+      fun unspill s (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.OSIZE(s, X.REG xreg), X.REL (X.REG X.RSP, (X.CONST o Word32.fromInt o stackpos o temptonum) temp))]
           else nil
-        | unspill _ = nil
+        | unspill s (X.STACKARG arg, xreg) = [X.MOV (X.OSIZE(s, X.REG xreg), X.REL (X.REG X.RSP, X.CONST (Word32.fromInt (stacksz + 8 + (arg * 8)))))]
+        | unspill s (a as X.REL _, xreg) = [X.MOV (X.OSIZE(s, X.REG xreg), a)]
+        | unspill s (X.OSIZE (s', oo), xreg) = unspill s' (X.stripsize oo, xreg)
+        | unspill _ _ = nil
       
-      fun realoper (X.TEMP temp) = X.REG (temptoreg temp)	(* Makes a operand 'real'. *)
+      fun realoper (X.TEMP temp) = X.OSIZE (X.sts (Temp.size temp), X.REG (temptoreg temp))  (* Makes a operand 'real'. *)
+        | realoper (X.STACKARG arg) = raise Spilled
+        | realoper (X.REL _) = raise Spilled
+        | realoper (X.OSIZE (s, oo)) = X.OSIZE (s, realoper (X.stripsize oo))
         | 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))
+            else X.OSIZE (X.sts (Temp.size temp), X.REL (X.REG X.RSP, (X.CONST o Word32.fromInt o stackpos o temptonum) temp))
+        | stackoper (X.STACKARG arg) = X.REL (X.REG X.RSP, (X.CONST o Word32.fromInt) (stacksz + 8 + (arg * 8)))
+        | stackoper (a as X.REL _) = a
+        | stackoper (X.OSIZE (s, oo)) = X.OSIZE (s, stackoper (X.stripsize oo))
         | stackoper _ = raise ErrorMsg.InternalError "stackoper on not temp?"
-      
+
+      fun ophit (X.OSIZE (s, oo)) = let val (insns, p) = ophit (X.stripsize oo) in (insns, X.OSIZE (s, p)) end
+        | ophit (X.REL(op1, op2)) =
+          let
+            val t1 = X.stripsize op1
+            val (s, t2) = X.sizeoper op2
+          in
+            if (isspilled t1 andalso isspilled t2) then
+              ([X.MOV (X.OSIZE (s, X.REG spillreg1), stackoper t2),
+                X.ADD (X.OSIZE (X.Qword, X.REG spillreg1), stackoper t1)],
+                X.REL (X.REG spillreg1, X.CONST 0w0))
+            else if(isspilled t1) then
+              ([X.MOV (X.OSIZE (X.Qword, X.REG spillreg1), stackoper t1)],
+                X.REL (X.REG spillreg1, realoper t2))
+            else if(isspilled t2) then
+              ([X.MOV (X.OSIZE (s, X.REG spillreg1), stackoper t2)],
+                X.REL (realoper t1, X.REG spillreg1))
+            else
+              ([],
+                X.REL (realoper t1, realoper t2))
+          end
+        | ophit a = (nil, realoper a handle Spilled => stackoper a)
+
       fun transform (X.DIRECTIVE s) = [X.DIRECTIVE s]
         | transform (X.COMMENT s) = [X.COMMENT s]
-        | transform (X.MOVL (dest, src)) =
-            if (isspilled dest)
-            then
-              unspill (src, spillreg1) @
-              [ X.MOVL(
-                  realoper dest handle Spilled => stackoper dest,
-                  realoper src handle Spilled => X.REG spillreg1)]
-            else
-              [ X.MOVL(
-                  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)) =
-            unspill (src, spillreg1) @
-            [ X.SUBL(
-                realoper dest handle Spilled => stackoper dest,
-                realoper src handle Spilled => X.REG spillreg1)]
+        | transform (X.LIVEIGN a) = transform a
+        | transform (X.MOV (dest, src)) =
+            let
+              val (insns1, realop1) = ophit dest
+              val (insns2, realop2) = ophit src
+            in
+              if(isspilled dest andalso isspilled src) then
+                insns2 @ [X.MOV (X.REG spillreg2, realop2)] @ insns1 @ [X.MOV (realop1, X.REG spillreg2)]
+              else
+                insns1 @ insns2 @ [X.MOV (realop1, realop2)]
+            end
+        | transform (X.LEA (dest, src)) =
+            let
+              val (insns1, realop1) = ophit dest
+              val (insns2, realop2) = ophit src
+            in
+              if(isspilled dest andalso isspilled src) then
+                insns2 @ [X.MOV (X.REG spillreg2, realop2)] @ insns1 @ [X.LEA (realop1, X.REG spillreg2)]
+              else
+                insns1 @ insns2 @ [X.LEA (realop1, realop2)]
+            end
+        | transform (X.SUB (dest, src)) =
+            let
+              val (insns, realop) = ophit dest
+            in
+              unspill X.Long (src, spillreg2) @ insns @
+              [ X.SUB(realop,
+                  realoper src handle Spilled => X.REG spillreg2)]
+            end
         | transform (X.IMUL (dest, src)) =
-            unspill (dest, spillreg1) @
+            unspill X.Long (dest, spillreg1) @
             [ X.IMUL(
                 realoper dest handle Spilled => X.REG spillreg1,
                 realoper src handle Spilled => stackoper src)] @
-            spill (dest, spillreg1)
+            spill X.Long (dest, spillreg1)
         | transform (X.IMUL3 (dest, src, const)) =
+            unspill X.Long ((X.stripsize src), spillreg2) @
             [ X.IMUL3(
                 realoper dest handle Spilled => X.REG spillreg1,
-                realoper src handle Spilled => stackoper src,
+                realoper src handle Spilled => X.REG spillreg2,
                 const)] @
-            spill (dest, spillreg1)
-        | transform (X.ADDL (dest, src)) =	(* You can have either operand spilled, but not both. Pick one. *)
-            if (isspilled dest)
-            then
-              unspill (src, spillreg1) @
-              [ X.ADDL(
-                  realoper dest handle Spilled => stackoper dest,
-                  realoper src handle Spilled => X.REG spillreg1)]
-            else
-              [ X.ADDL(
-                  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)]
+            spill X.Long (dest, spillreg1)
+        | transform (X.ADD (dest, src)) =
+            let
+              val (insns, realop) = ophit dest
+            in
+              unspill X.Long (src, spillreg2) @ insns @
+              [ X.ADD(realop,
+                  realoper src handle Spilled => X.REG spillreg2)]
+            end
+        | 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)) =
-            unspill (src, spillreg1) @
-            [ X.ANDL(
+        | transform (X.AND (dest, src)) =
+            unspill X.Long (src, spillreg1) @
+            [ X.AND(
                 realoper dest handle Spilled => stackoper dest,
                 realoper src handle Spilled => X.REG spillreg1)]
-        | transform (X.ORL (dest, src)) =
-            unspill (src, spillreg1) @
-            [ X.ORL(
+        | transform (X.OR (dest, src)) =
+            unspill X.Long (src, spillreg1) @
+            [ X.OR(
                 realoper dest handle Spilled => stackoper dest,
                 realoper src handle Spilled => X.REG spillreg1)]
-        | transform (X.XORL (dest, src)) =
-            unspill (src, spillreg1) @
-            [ X.XORL(
+        | transform (X.XOR (dest, src)) =
+            unspill X.Long (src, spillreg1) @
+            [ X.XOR(
                 realoper dest handle Spilled => stackoper dest,
                 realoper src handle Spilled => X.REG spillreg1)]
-        | transform (X.CMPL (op1, op2)) =
-            unspill (op2, spillreg1) @
-            [ X.CMPL(
+        | transform (X.CMP (op1, op2)) =
+            unspill X.Long (op2, spillreg1) @
+            [ X.CMP(
                 realoper op1 handle Spilled => stackoper op1,
                 realoper op2 handle Spilled => X.REG spillreg1)]
         | transform (X.TEST (op1, op2)) =
-            unspill (op2, spillreg1) @
+            unspill X.Long (op2, spillreg1) @
             [ 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]
+            @ spill X.Long (dest, spillreg1)
+        | 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