signature CODEGEN =
sig
- val codegen : Tree.stm list -> x86.insn list
+ val codegen : Tree.stm list -> Blarg.insn list
end
structure Codegen :> CODEGEN =
struct
structure T = Tree
structure TU = TreeUtils
- structure X = x86
+ structure X = Blarg
structure Tm = Temp
(* hasfixed : T.exp -> bool
* true iff the given expression has an hasfixed.
*)
- fun hasfixed (T.BINOP(T.DIV, _, _)) = true
- | hasfixed (T.BINOP(T.MOD, _, _)) = true
- | hasfixed (T.BINOP(T.LSH, _, _)) = true
- | hasfixed (T.BINOP(T.RSH, _, _)) = true
- | hasfixed (T.CALL _) = true
+ fun hasfixed (T.CALL _) = true
| hasfixed (T.BINOP(_, a, b)) = (hasfixed a) orelse (hasfixed b)
| hasfixed (T.UNOP (_, a)) = hasfixed a
| hasfixed (T.ALLOC(_)) = true
- | hasfixed (T.MEMORY (m,s)) = hasfixed m
+ | hasfixed (T.MEMORY (m)) = hasfixed m
| hasfixed (T.STMVAR _) = true
| hasfixed _ = false
- fun offshit a b 0w4 d = [X.LEA(d, (X.REL((a, Tm.Quad), (b, Tm.Quad), 0w4), Tm.Quad))]
- | offshit a b 0w8 d = [X.LEA(d, (X.REL((a, Tm.Quad), (b, Tm.Quad), 0w8), Tm.Quad))]
- | offshit a b n d = [X.IMUL((b, Tm.Long), (X.CONST n, Tm.Long)), X.MOV(d, (a, Tm.Quad)), X.ADD(d, (b, Tm.Quad))]
-
- fun binophit_c d oper e c = let val (i, s) = munch_exp d e in (i @ [oper ((d,s), (X.CONST c, s))], s) end
- and binophit_t d oper e t =
- let
- val (i, s) = munch_exp d e
- val ts = Tm.size t
- val rs = if Tm.cmpsize (s, ts) = GREATER then s else ts
- in
- (i @ [oper ((d, rs), (X.TEMP t, rs))], rs)
- end
- and binophit d oper e1 e2 =
+ (* binophit : X.oper -> X.opc -> T.exp -> T.exp -> X.insn list *)
+ (* binophit d oper e1 e2
+ * generates instructions to achieve d <- e1 oper e2
+ * oper should be something like X.ADD
+ *)
+ fun binophit d oper e1 e2 =
let
- val t = X.TEMP (Tm.new "add" Tm.Long)
- val (i1, s1) = munch_exp d e1
- val (i2, s2) = munch_exp t e2
+ val t = X.TEMP (Tm.new "binop")
+ val i1 = munch_exp d e1
+ val i2 = munch_exp t e2
(* val _ = print ("s1 = " ^ Tm.sfx s1 ^ ", s2 = " ^ Tm.sfx s2 ^ ", ") *)
- val rs = if Tm.cmpsize (s1, s2) = GREATER then s1 else s2
(* val _ = print ("rs = " ^ Tm.sfx rs ^ " from " ^ TU.Print.pp_exp e1 ^ " and " ^ TU.Print.pp_exp e2 ^ "\n") *)
in
- (i1 @ i2 @ [oper ((d,rs), (t,rs))], rs)
+ i1 @ i2 @ [X.INSN (X.AL, oper (d, t))]
+ end
+
+ (* cmphit : X.oper -> X.exp -> X.insn list
+ * cmphit d ex
+ * generates instructions to set d based on the truth value of ex
+ *)
+ and cmphit d ex =
+ let
+ val (insns, pos, neg) = munch_cond ex
+ in
+ insns @ [X.INSN (X.AL, X.MOVLIT (d, 0w0)), X.INSN (pos, X.MOVLIT (d, 0w1))]
end
- and cmphit d a = let val (insns, pos, neg) = munch_cond a in (insns @ [X.SETcc (pos, (d, Tm.Byte)), X.MOVZB((d, Tm.Long), (d, Tm.Byte))], Tm.Long) end
(* munch_exp : prex86oper -> T.exp -> prex86insn list *)
(* munch_exp d e
* generates instructions to achieve d <- e
* d must be TEMP(t) or REG(r)
*)
- and munch_exp d (T.CONST n) = ([X.MOV((d, Tm.Long), (X.CONST n, Tm.Long))], Tm.Long)
- | munch_exp d (T.NULLPTR) = ([X.MOV((d, Tm.Quad), (X.CONST 0w0, Tm.Quad))], Tm.Quad)
- | munch_exp d (T.TEMP(t)) = ([X.MOV((d, Tm.size t), (X.TEMP t, Tm.size t))], Tm.size t)
- | munch_exp d (T.ARG(0, sz)) = ([X.MOV((d, sz), (X.REG X.EDI, sz))], sz)
- | munch_exp d (T.ARG(1, sz)) = ([X.MOV((d, sz), (X.REG X.ESI, sz))], sz)
- | munch_exp d (T.ARG(2, sz)) = ([X.MOV((d, sz), (X.REG X.EDX, sz))], sz)
- | munch_exp d (T.ARG(3, sz)) = ([X.MOV((d, sz), (X.REG X.ECX, sz))], sz)
- | munch_exp d (T.ARG(4, sz)) = ([X.MOV((d, sz), (X.REG X.R8D, sz))], sz)
- | munch_exp d (T.ARG(5, sz)) = ([X.MOV((d, sz), (X.REG X.R9D, sz))], sz)
- | munch_exp d (T.ARG(t, sz)) = ([X.MOV((d, sz), (X.STACKARG (t - 6), sz))], sz)
- | munch_exp d (T.CALL(name, l, rsz)) = (* Scary demons live here. *)
+ and munch_exp d (T.CONST n) = [X.INSN (X.AL, X.MOVLIT(d, Word.fromLarge (Word32.toLarge n)))]
+ | munch_exp d (T.STRING s) = [X.INSN (X.AL, X.MOVSTR(d, s))]
+ | munch_exp d (T.NULLPTR) = [X.INSN (X.AL, X.MOVLIT(d, 0w0))]
+ | munch_exp d (T.TEMP(t)) = [X.INSN (X.AL, X.MOV(d, X.TEMP t))]
+ | munch_exp d (T.ARG(0)) = [X.INSN (X.AL, X.MOV(d, X.REG X.R0))]
+ | munch_exp d (T.ARG(1)) = [X.INSN (X.AL, X.MOV(d, X.REG X.R1))]
+ | munch_exp d (T.ARG(2)) = [X.INSN (X.AL, X.MOV(d, X.REG X.R2))]
+ | munch_exp d (T.ARG(3)) = [X.INSN (X.AL, X.MOV(d, X.REG X.R3))]
+ | munch_exp d (T.ARG(t)) = [X.INSN (X.AL, X.MOV(d, X.STACKARG (t - 4)))]
+ | munch_exp d (T.CALL(name, l)) = (* Scary demons live here. *)
let
val nargs = length l
- val nstack = if (nargs <= 6)
+ val nstack = if (nargs <= 4)
then 0
- else nargs - 6
- val stackb = nstack * 8
- fun argdest 1 = X.REG X.EDI
- | argdest 2 = X.REG X.ESI
- | argdest 3 = X.REG X.EDX
- | argdest 4 = X.REG X.ECX
- | argdest 5 = X.REG X.R8D
- | argdest 6 = X.REG X.R9D
- | argdest n = X.REL ((X.REG X.RSP, Tm.Quad), (X.CONST (Word32.fromInt (~(stackb - 8 * (n - 7)))), Tm.Quad), 0w1)
+ else nargs - 4
+ val stackb = nstack * 1
+ fun argdest 1 = (X.REG X.R0, [])
+ | argdest 2 = (X.REG X.R1, [])
+ | argdest 3 = (X.REG X.R2, [])
+ | argdest 4 = (X.REG X.R3, [])
+ | argdest n =
+ let
+ val t = Temp.new "argdest"
+ val t2 = Temp.new "argptr"
+ in
+ (X.TEMP t, (* Dude, I *love* this shit. *)
+ [ X.INSN (X.AL, X.MOVLIT (X.TEMP t2, Word.fromInt (0x10000 - (n - 4 + 1)))),
+ X.INSN (X.AL, X.ADD (X.TEMP t2, X.REG X.SP)),
+ X.INSN (X.AL, X.STO (X.TEMP t2, X.TEMP t)) ] )
+ end
val dests = List.tabulate (nargs, fn x => argdest (x+1))
- val (exps,_) = ListPair.unzip l
- val hf = List.map hasfixed exps
+ val hf = List.map hasfixed l
val (d_hf, l_hf) = ListPair.unzip (ListPair.foldr
(fn (a,b,c) => if b then a::c else c)
nil
nil
(ListPair.zip (dests,l), hf)
)
- val temps = List.map (fn (_, sz) => Temp.new ("arg") sz (* xxx? *)) l_hf
- val (argevals_hf,_) = ListPair.unzip (List.map
- (fn (t,(exp,_)) => munch_exp (X.TEMP t) exp)
- (ListPair.zip (temps, l_hf)))
+ val temps = List.map (fn _ => Temp.new ("arg")) l_hf
+ val argevals_hf = List.map
+ (fn (t,exp) => munch_exp (X.TEMP t) exp)
+ (ListPair.zip (temps, l_hf))
val argpushes = List.map
- (fn (dest, t) => [X.MOV ((dest, Tm.size t), (X.TEMP t, Tm.size t))])
+ (fn ((dest, _), t) => [X.INSN (X.AL, X.MOV (dest, X.TEMP t))])
(ListPair.zip (d_hf, temps))
- val (argevals_nohf,_) = ListPair.unzip (List.map
- (fn (d,(exp,sz)) => munch_exp d exp)
- (ListPair.zip (d_nohf, l_nohf)))
+ val argevals_nohf = List.map
+ (fn ((d,_),exp) => munch_exp d exp)
+ (ListPair.zip (d_nohf, l_nohf))
+ val shittodo = List.concat (List.map (fn (_, shit) => shit) (d_hf @ d_nohf))
+
+ val t_stackb = Temp.new ("stackb")
+ val t_target = Temp.new ("target")
in
- (List.concat argevals_hf @
- List.concat argpushes @
- List.concat argevals_nohf @
- [ X.SUB ((X.REG X.RSP, Tm.Quad), (X.CONST (Word32.fromInt stackb), Tm.Quad)),
- X.CALL (name, nargs),
- X.ADD ((X.REG X.RSP, Tm.Quad), (X.CONST (Word32.fromInt stackb), Tm.Quad)),
- X.MOV ((d, rsz), (X.REG X.EAX, rsz))], rsz) (* Finally! *)
+ List.concat argevals_hf @
+ List.concat argpushes @
+ List.concat argevals_nohf @
+ shittodo @
+ (if stackb > 0
+ then [ X.INSN (X.AL, X.MOVLIT (X.TEMP t_stackb, Word.fromInt stackb)),
+ X.INSN (X.AL, X.MOVSYM (X.TEMP t_target, name)),
+ X.INSN (X.AL, X.SUB (X.REG X.SP, X.TEMP t_stackb)),
+ X.INSN (X.AL, X.CALL (X.REG X.SP, X.TEMP t_target, nargs)),
+ X.INSN (X.AL, X.ADD (X.REG X.SP, X.TEMP t_stackb)),
+ X.INSN (X.AL, X.MOV (d, X.REG X.R0))]
+ else [ X.INSN (X.AL, X.MOVSYM (X.TEMP t_target, name)),
+ X.INSN (X.AL, X.CALL (X.REG X.SP, X.TEMP t_target, nargs)),
+ X.INSN (X.AL, X.MOV (d, X.REG X.R0))]
+ )
end
- | munch_exp d (T.BINOP(T.ADD, e1, T.CONST n)) = binophit_c d X.ADD e1 n
+ (*| munch_exp d (T.BINOP(T.ADD, e1, T.CONST n)) = binophit_c d X.ADD e1 n
| munch_exp d (T.BINOP(T.ADD, T.CONST n, e1)) = binophit_c d X.ADD e1 n
| munch_exp d (T.BINOP(T.ADD, e1, T.TEMP t)) = binophit_t d X.ADD e1 t
- | munch_exp d (T.BINOP(T.ADD, T.TEMP t, e1)) = binophit_t d X.ADD e1 t
+ | munch_exp d (T.BINOP(T.ADD, T.TEMP t, e1)) = binophit_t d X.ADD e1 t*)
| munch_exp d (T.BINOP(T.ADD, e1, e2)) = binophit d X.ADD e1 e2
- | munch_exp d (T.BINOP(T.SUB, e1, T.CONST n)) = binophit_c d X.SUB e1 n
- | munch_exp d (T.BINOP(T.SUB, e1, T.TEMP t)) = binophit_t d X.SUB e1 t
+ (*| munch_exp d (T.BINOP(T.SUB, e1, T.CONST n)) = binophit_c d X.SUB e1 n
+ | munch_exp d (T.BINOP(T.SUB, e1, T.TEMP t)) = binophit_t d X.SUB e1 t*)
| munch_exp d (T.BINOP(T.SUB, e1, e2)) = binophit d X.SUB e1 e2
- | munch_exp d (T.BINOP(T.MUL, T.TEMP t, T.CONST n)) = let val s = Tm.size t in ([X.IMUL3((d,s), (X.TEMP t,s), n)], Tm.size t) end
- | munch_exp d (T.BINOP(T.MUL, T.CONST n, T.TEMP t)) = let val s = Tm.size t in ([X.IMUL3((d,s), (X.TEMP t,s), n)], Tm.size t) end
- | munch_exp d (T.BINOP(T.MUL, e1, T.CONST n)) = binophit_c d X.IMUL e1 n
- | munch_exp d (T.BINOP(T.MUL, T.CONST n, e1)) = binophit_c d X.IMUL e1 n
- | munch_exp d (T.BINOP(T.MUL, e1, e2)) = binophit d X.IMUL e1 e2
- | munch_exp d (T.BINOP(T.DIV, e1, e2)) =
- let
- val t1 = X.TEMP (Temp.new ("div") Tm.Long)
- val (i1, s1) = munch_exp t1 e1
- val (i2, s2) = munch_exp d e2
- in
- (i1 @ i2 @ [X.MOV ((X.REG X.EAX, s1), (t1, s1)), X.CLTD, X.IDIV (d, s2), X.MOV ((d, s2), (X.REG X.EAX, s2))], Tm.Long)
- end
- | munch_exp d (T.BINOP(T.MOD, e1, e2)) =
- let
- val t1 = X.TEMP (Temp.new ("div") Tm.Long)
- val (i1, s1) = munch_exp t1 e1
- val (i2, s2) = munch_exp d e2
- in
- (i1 @ i2 @ [X.MOV ((X.REG X.EAX, s1), (t1, s1)), X.CLTD, X.IDIV (d, s2), X.MOV ((d, s2), (X.REG X.EDX, s2))], Tm.Long)
- end
- | munch_exp d (T.BINOP(T.LSH, e1, T.CONST n)) = let val (i,s) = munch_exp d e1 in (i @ [X.SAL ((d,s), (X.CONST (n mod 0w32),s))],s) end
- | munch_exp d (T.BINOP(T.LSH, e1, T.TEMP t)) =
- let
- val (i,s) = munch_exp d e1
- in
- (i @ [X.MOV ((X.REG X.ECX, s), (X.TEMP t, s)), X.SAL ((d,s), (X.REG X.ECX, Tm.Byte))], s)
- end
- | munch_exp d (T.BINOP(T.LSH, e1, e2)) =
- let
- val t = X.TEMP (Temp.new ("lsh") Tm.Long)
- val (i1, s1) = munch_exp d e1
- val (i2, s2) = munch_exp t e2
- in
- (i1 @ i2 @ [X.MOV ((X.REG X.ECX, s1), (t, s1)), X.SAL ((d, s2), (X.REG X.ECX, Tm.Byte))], s2)
- end
- | munch_exp d (T.BINOP(T.RSH, e1, T.CONST n)) = let val (i,s) = munch_exp d e1 in (i @ [X.SAR ((d,s), (X.CONST (n mod 0w32),s))],s) end
- | munch_exp d (T.BINOP(T.RSH, e1, T.TEMP t)) =
- let
- val (i,s) = munch_exp d e1
- in
- (i @ [X.MOV ((X.REG X.ECX, s), (X.TEMP t, s)), X.SAR ((d,s), (X.REG X.ECX, Tm.Byte))], s)
- end
- | munch_exp d (T.BINOP(T.RSH, e1, e2)) =
- let
- val t = X.TEMP (Temp.new ("lsh") Tm.Long)
- val (i1, s1) = munch_exp d e1
- val (i2, s2) = munch_exp t e2
- in
- (i1 @ i2 @ [X.MOV ((X.REG X.ECX, s1), (t, s1)), X.SAR ((d, s2), (X.REG X.ECX, Tm.Byte))], s2)
- end
- | munch_exp d (T.BINOP(T.BITAND, T.CONST n, e1)) = binophit_c d X.AND e1 n
- | munch_exp d (T.BINOP(T.BITAND, e1, T.CONST n)) = binophit_c d X.AND e1 n
- | munch_exp d (T.BINOP(T.BITAND, T.TEMP t, e1)) = binophit_t d X.AND e1 t
- | munch_exp d (T.BINOP(T.BITAND, e1, T.TEMP t)) = binophit_t d X.AND e1 t
+ | munch_exp d (T.BINOP(T.MUL, e1, e2)) = munch_exp d (T.CALL (Symbol.symbol "__blarg_mul", [e1, e2]))
+ | munch_exp d (T.BINOP(T.DIV, e1, e2)) = munch_exp d (T.CALL (Symbol.symbol "__blarg_div", [e1, e2]))
+ | munch_exp d (T.BINOP(T.MOD, e1, e2)) = munch_exp d (T.CALL (Symbol.symbol "__blarg_mod", [e1, e2]))
+ | munch_exp d (T.BINOP(T.LSH, e1, e2)) = binophit d X.SHL e1 e2
+ | munch_exp d (T.BINOP(T.RSH, e1, e2)) = binophit d X.SHR e1 e2
| munch_exp d (T.BINOP(T.BITAND, e1, e2)) = binophit d X.AND e1 e2
-
- | munch_exp d (T.BINOP(T.BITOR, T.CONST n, e1)) = binophit_c d X.OR e1 n
- | munch_exp d (T.BINOP(T.BITOR, e1, T.CONST n)) = binophit_c d X.OR e1 n
- | munch_exp d (T.BINOP(T.BITOR, T.TEMP t, e1)) = binophit_t d X.OR e1 t
- | munch_exp d (T.BINOP(T.BITOR, e1, T.TEMP t)) = binophit_t d X.OR e1 t
- | munch_exp d (T.BINOP(T.BITOR, e1, e2)) = binophit d X.OR e1 e2
-
- | munch_exp d (T.BINOP(T.BITXOR, T.CONST n, e1)) = binophit_c d X.XOR e1 n
- | munch_exp d (T.BINOP(T.BITXOR, e1, T.CONST n)) = binophit_c d X.XOR e1 n
- | munch_exp d (T.BINOP(T.BITXOR, T.TEMP t, e1)) = binophit_t d X.XOR e1 t
- | munch_exp d (T.BINOP(T.BITXOR, e1, T.TEMP t)) = binophit_t d X.XOR e1 t
- | munch_exp d (T.BINOP(T.BITXOR, e1, e2)) = binophit d X.XOR e1 e2
+ | munch_exp d (T.BINOP(T.BITOR, e1, e2)) = munch_exp d (T.UNOP (T.BITNOT, T.BINOP (T.BITAND, T.UNOP (T.BITNOT, e1), T.UNOP (T.BITNOT, e2))))
+ | munch_exp d (T.BINOP(T.BITXOR, e1, e2)) =
+ munch_exp d (T.BINOP(T.BITOR, T.BINOP(T.BITAND, e1, T.UNOP(T.BITNOT, e2)),
+ T.BINOP(T.BITAND, e2, T.UNOP(T.BITNOT, e1))))
| munch_exp d (a as T.BINOP(T.LOGAND, e1, e2)) =
let
val (insn1, pos1, neg1) = munch_cond e1
val (insn2, pos2, neg2) = munch_cond e2
- val t1 = (X.TEMP (Tm.new "logand 1" Tm.Byte), Tm.Byte)
- val t2 = (X.TEMP (Tm.new "logand 2" Tm.Byte), Tm.Byte)
val l = Label.new ()
in
- if (TU.effect e2 orelse (length insn2 > 10))
- then ((insn1) @
- [X.SETcc(pos1, t1), X.Jcc (neg1, l)] @
- (insn2) @
- [X.SETcc(pos2, t1), X.LABEL l, X.MOVZB((d, Tm.Long), t1)], Tm.Long)
- else (insn1 @ [X.SETcc (pos1, t1)] @ insn2 @ [X.SETcc (pos2, t2), X.AND(t1,t2), X.MOVZB((d, Tm.Long), t1)], Tm.Long)
+ (insn1) @
+ [X.INSN (X.AL, X.MOVLIT (d, 0w0)),
+ X.INSN (neg1, X.MOVLBL (X.REG X.PC, l))] @
+ (insn2) @
+ [X.INSN (pos2, X.MOVLIT (d, 0w1)),
+ X.LABEL l]
end
| munch_exp d (a as T.BINOP(T.LOGOR, e1, e2)) =
let
val (insn1, pos1, neg1) = munch_cond e1
val (insn2, pos2, neg2) = munch_cond e2
- val t1 = (X.TEMP (Tm.new "logand 1" Tm.Byte), Tm.Byte)
- val t2 = (X.TEMP (Tm.new "logand 2" Tm.Byte), Tm.Byte)
+ val t1 = X.TEMP (Tm.new "logand 1")
+ val t2 = X.TEMP (Tm.new "logand 2")
val l = Label.new ()
in
- if (TU.effect e2 orelse (length insn2 > 10))
- then ((insn1) @
- [X.SETcc(pos1, t1), X.Jcc (pos1, l)] @
- (insn2) @
- [X.SETcc(pos2, t1), X.LABEL l, X.MOVZB((d, Tm.Long), t1)], Tm.Long)
- else (insn1 @ [X.SETcc (pos1, t1)] @ insn2 @ [X.SETcc (pos2, t2), X.OR(t1,t2), X.MOVZB((d, Tm.Long), t1)], Tm.Long)
+ (insn1) @
+ [X.INSN (X.AL, X.MOVLIT (d, 0w0)),
+ X.INSN (pos1, X.MOVLIT (d, 0w1)),
+ X.INSN (pos1, X.MOVLBL (X.REG X.PC, l))] @
+ (insn2) @
+ [X.INSN (pos2, X.MOVLIT (d, 0w1)),
+ X.LABEL l]
end
| munch_exp d (a as T.BINOP(T.EQ, _, _)) = cmphit d a
| munch_exp d (a as T.BINOP(T.NEQ, _, _)) = cmphit d a
| munch_exp d (a as T.BINOP(T.GT, _, _)) = cmphit d a
| munch_exp d (a as T.BINOP(T.BE, _, _)) = cmphit d a
- | munch_exp d (T.UNOP(T.NEG, e1)) = let val (i, s) = munch_exp d e1 in (i @ [X.NEG (d, Tm.Long)], s) end
- | munch_exp d (T.UNOP(T.BITNOT, e1)) = let val (i, s) = munch_exp d e1 in (i @ [X.NOT (d, Tm.Long)], s) end
+ | munch_exp d (T.UNOP(T.NEG, e1)) =
+ let
+ val t = Temp.new "-val"
+ val i = munch_exp (X.TEMP t) e1
+ in
+ (i) @
+ [X.INSN (X.AL, X.MOVLIT (d, 0w0)),
+ X.INSN (X.AL, X.SUB (d, X.TEMP t))]
+ end
+ | munch_exp d (T.UNOP(T.BITNOT, e1)) = let val i = munch_exp d e1 in i @ [X.INSN (X.AL, X.NOT (d, d))] end
| munch_exp d (T.UNOP(T.BANG, e)) =
let
val (insns, pos, neg) = munch_cond e
in
- (insns @ [X.SETcc (neg, (d, Tm.Byte)), X.MOVZB((d, Tm.Long), (d, Tm.Byte))], Tm.Long)
+ insns @
+ [X.INSN (X.AL, X.MOVLIT (d, 0w0)),
+ X.INSN (neg, X.MOVLIT (d, 0w1))]
end
- | munch_exp d (T.MEMORY (e1,s)) =
+ | munch_exp d (T.MEMORY (e1)) =
let
- val a = X.TEMP (Temp.new "addr" Tm.Quad)
- val (i, s') = munch_exp a e1
- val _ = if s' = Tm.Quad then () else raise ErrorMsg.InternalError "memory fuxed."
+ val a = X.TEMP (Temp.new "addr")
+ val i = munch_exp a e1
in
- (i @ [X.MOV ((d,s), (X.REL ((a, Tm.Quad), (X.CONST 0w0, Tm.Quad), 0w1), s))], s)
+ i @
+ [X.INSN (X.AL, X.LDR (d, a))]
end
+
| munch_exp d (T.ALLOC(exp)) =
-
let
- val t1 = Temp.new "alloc" Tm.Long
+ val t1 = Temp.new "alloc"
val l1 = Label.new()
- val (einsn, _) = munch_exp (X.TEMP t1) exp
- val (insns, _) = munch_exp d (T.CALL (Symbol.symbol "calloc", [(T.TEMP t1, Tm.Long), (T.CONST 0w1, Tm.Long)], Tm.Quad))
- val rd = (d, Tm.Quad)
+ val einsn = munch_exp (X.TEMP t1) exp
+ val insns = munch_exp d (T.CALL (Symbol.symbol "calloc", [T.TEMP t1, T.CONST 0w1]))
in
- (einsn @ insns, Tm.Quad)
+ einsn @ insns
end
(* | munch_exp d (T.COND(c, T.CONST n1, T.CONST n2)) = let val (i,p,n) = munch_cond c in ((X.MOV (d, X.CONST n1))::i) @ [X.CMOVcc (p, d, X.CONST n2)] end *)
| munch_exp d (T.COND(c,e1,e2)) =
val (insns, pos, neg) = munch_cond c
val l1 = Label.new()
val l2 = Label.new()
- val (i1, s1) = munch_exp d e1
- val (i2, s2) = munch_exp d e2
+ val i1 = munch_exp d e1
+ val i2 = munch_exp d e2
(* val _ = print ("cond: size " ^ Tm.sfx s1 ^ " from " ^ TU.Print.pp_exp e1 ^ ", " ^ Tm.sfx s2 ^ " from " ^ TU.Print.pp_exp e2 ^ "\n") *)
in
- (insns @ [X.Jcc(neg, l1)] @ i1 @ [X.JMP l2, X.LABEL l1] @ i2 @ [X.LABEL l2], if s1 = s2 then s1 else raise ErrorMsg.InternalError "condfuxed.")
+ insns @
+ [X.INSN (neg, X.MOVLBL (X.REG X.PC, l1))] @
+ i1 @
+ [X.INSN (X.AL, X.MOVLBL (X.REG X.PC, l2)),
+ X.LABEL l1] @
+ i2 @
+ [X.LABEL l2]
end
- | munch_exp d (T.STMVAR (sl, e)) = let val (i, s) = munch_exp d e in (List.concat (map munch_stm sl) @ i, s) end
+ | munch_exp d (T.STMVAR (sl, e)) = let val i = munch_exp d e in List.concat (map munch_stm sl) @ i end
- and condhit_tc t c (pos, neg) = ([X.CMP((X.TEMP t, Tm.size t), (X.CONST c, Tm.size t))], pos, neg)
- and condhit_c e c (pos, neg) =
- let
- val t = X.TEMP (Temp.new "consthit" Tm.Long)
- val (i,s) = munch_exp t e
- in
- (i @ [X.CMP ((t,s), (X.CONST c,s))], pos, neg)
- end
- and condhit_t e t (pos, neg) =
- let
- val t' = X.TEMP (Temp.new "consthit" Tm.Long)
- val (i,s) = munch_exp t' e
- in
- (i @ [X.CMP ((t',s), (X.TEMP t,s))], pos, neg)
- end
and condhit e1 e2 (pos, neg) =
let
- val t1 = X.TEMP (Temp.new ("var neq 1") Tm.Long)
- val t2 = X.TEMP (Temp.new ("var neq 2") Tm.Long)
- val (i1, s1) = munch_exp t1 e1
- val (i2, s2) = munch_exp t2 e2
+ val t1 = X.TEMP (Temp.new ("var cond 1"))
+ val t2 = X.TEMP (Temp.new ("var cond 2"))
+ val i1 = munch_exp t1 e1
+ val i2 = munch_exp t2 e2
in
- (i1 @ i2 @ [X.CMP((t1,s1),(t2,s2))], pos, neg)
+ (i1 @ i2 @ [X.INSN (X.AL, X.SUBS (t1, t2))], pos, neg)
end
(* munch_cond : T.exp -> X.insn list * X.cond * X.cond
in
(insns, neg, pos)
end
- | munch_cond (T.BINOP(T.NEQ, T.TEMP t, T.CONST n)) = condhit_tc t n (X.NE, X.E)
- | munch_cond (T.BINOP(T.NEQ, T.CONST n, T.TEMP t)) = condhit_tc t n (X.NE, X.E)
- | munch_cond (T.BINOP(T.NEQ, T.CONST n, e1)) = condhit_c e1 n (X.NE, X.E)
- | munch_cond (T.BINOP(T.NEQ, e1, T.CONST n)) = condhit_c e1 n (X.NE, X.E)
- | munch_cond (T.BINOP(T.NEQ, T.TEMP t, e1)) = condhit_t e1 t (X.NE, X.E)
- | munch_cond (T.BINOP(T.NEQ, e1, T.TEMP t)) = condhit_t e1 t (X.NE, X.E)
- | munch_cond (T.BINOP(T.NEQ, e1, e2)) = condhit e1 e2 (X.NE, X.E)
-
- | munch_cond (T.BINOP(T.EQ, T.TEMP t, T.CONST n)) = condhit_tc t n (X.E, X.NE)
- | munch_cond (T.BINOP(T.EQ, T.CONST n, T.TEMP t)) = condhit_tc t n (X.E, X.NE)
- | munch_cond (T.BINOP(T.EQ, T.CONST n, e1)) = condhit_c e1 n (X.E, X.NE)
- | munch_cond (T.BINOP(T.EQ, e1, T.CONST n)) = condhit_c e1 n (X.E, X.NE)
- | munch_cond (T.BINOP(T.EQ, T.TEMP t, e1)) = condhit_t e1 t (X.E, X.NE)
- | munch_cond (T.BINOP(T.EQ, e1, T.TEMP t)) = condhit_t e1 t (X.E, X.NE)
- | munch_cond (T.BINOP(T.EQ, e1, e2)) = condhit e1 e2 (X.E, X.NE)
-
- | munch_cond (T.BINOP(T.LE, T.TEMP t, T.CONST n)) = condhit_tc t n (X.LE, X.G)
- | munch_cond (T.BINOP(T.LE, T.CONST n, T.TEMP t)) = condhit_tc t n (X.GE, X.L)
- | munch_cond (T.BINOP(T.LE, T.CONST n, e1)) = condhit_c e1 n (X.GE, X.L)
- | munch_cond (T.BINOP(T.LE, e1, T.CONST n)) = condhit_c e1 n (X.LE, X.G)
- | munch_cond (T.BINOP(T.LE, T.TEMP t, e1)) = condhit_t e1 t (X.GE, X.L)
- | munch_cond (T.BINOP(T.LE, e1, T.TEMP t)) = condhit_t e1 t (X.LE, X.G)
- | munch_cond (T.BINOP(T.LE, e1, e2)) = condhit e1 e2 (X.LE, X.G)
-
- | munch_cond (T.BINOP(T.LT, T.TEMP t, T.CONST n)) = condhit_tc t n (X.L, X.GE)
- | munch_cond (T.BINOP(T.LT, T.CONST n, T.TEMP t)) = condhit_tc t n (X.G, X.LE)
- | munch_cond (T.BINOP(T.LT, T.CONST n, e1)) = condhit_c e1 n (X.G, X.LE)
- | munch_cond (T.BINOP(T.LT, e1, T.CONST n)) = condhit_c e1 n (X.L, X.GE)
- | munch_cond (T.BINOP(T.LT, T.TEMP t, e1)) = condhit_t e1 t (X.G, X.LE)
- | munch_cond (T.BINOP(T.LT, e1, T.TEMP t)) = condhit_t e1 t (X.L, X.GE)
- | munch_cond (T.BINOP(T.LT, e1, e2)) = condhit e1 e2 (X.L, X.GE)
-
- | munch_cond (T.BINOP(T.GT, T.TEMP t, T.CONST n)) = condhit_tc t n (X.G, X.LE)
- | munch_cond (T.BINOP(T.GT, T.CONST n, T.TEMP t)) = condhit_tc t n (X.L, X.GE)
- | munch_cond (T.BINOP(T.GT, T.CONST n, e1)) = condhit_c e1 n (X.L, X.GE)
- | munch_cond (T.BINOP(T.GT, e1, T.CONST n)) = condhit_c e1 n (X.G, X.LE)
- | munch_cond (T.BINOP(T.GT, T.TEMP t, e1)) = condhit_t e1 t (X.L, X.GE)
- | munch_cond (T.BINOP(T.GT, e1, T.TEMP t)) = condhit_t e1 t (X.G, X.LE)
- | munch_cond (T.BINOP(T.GT, e1, e2)) = condhit e1 e2 (X.G, X.LE)
+ | munch_cond (T.BINOP(T.NEQ, e1, e2)) = condhit e1 e2 (X.NE, X.EQ)
+ | munch_cond (T.BINOP(T.EQ, e1, e2)) = condhit e1 e2 (X.EQ, X.NE)
+ | munch_cond (T.BINOP(T.LE, e1, e2)) = condhit e1 e2 (X.LE, X.GT)
+ | munch_cond (T.BINOP(T.LT, e1, e2)) = condhit e1 e2 (X.LT, X.GE)
+ | munch_cond (T.BINOP(T.GT, e1, e2)) = condhit e1 e2 (X.GT, X.LE)
+ | munch_cond (T.BINOP(T.GE, e1, e2)) = condhit e1 e2 (X.GE, X.LT)
- | munch_cond (T.BINOP(T.GE, T.TEMP t, T.CONST n)) = condhit_tc t n (X.GE, X.L)
- | munch_cond (T.BINOP(T.GE, T.CONST n, T.TEMP t)) = condhit_tc t n (X.LE, X.G)
- | munch_cond (T.BINOP(T.GE, T.CONST n, e1)) = condhit_c e1 n (X.LE, X.G)
- | munch_cond (T.BINOP(T.GE, e1, T.CONST n)) = condhit_c e1 n (X.GE, X.L)
- | munch_cond (T.BINOP(T.GE, T.TEMP t, e1)) = condhit_t e1 t (X.LE, X.G)
- | munch_cond (T.BINOP(T.GE, e1, T.TEMP t)) = condhit_t e1 t (X.GE, X.L)
- | munch_cond (T.BINOP(T.GE, e1, e2)) = condhit e1 e2 (X.GE, X.L)
+ | munch_cond (T.BINOP(T.BE, e1, e2)) = raise ErrorMsg.InternalError "memory safety not supported"
- | munch_cond (T.BINOP(T.BE, T.TEMP t, T.CONST n)) = condhit_tc t n (X.BE, X.A)
- | munch_cond (T.BINOP(T.BE, T.CONST n, T.TEMP t)) = condhit_tc t n (X.AE, X.B)
- | munch_cond (T.BINOP(T.BE, T.CONST n, e1)) = condhit_c e1 n (X.AE, X.B)
- | munch_cond (T.BINOP(T.BE, e1, T.CONST n)) = condhit_c e1 n (X.BE, X.A)
- | munch_cond (T.BINOP(T.BE, T.TEMP t, e1)) = condhit_t e1 t (X.AE, X.B)
- | munch_cond (T.BINOP(T.BE, e1, T.TEMP t)) = condhit_t e1 t (X.BE, X.A)
- | munch_cond (T.BINOP(T.BE, e1, e2)) = condhit e1 e2 (X.BE, X.A)
-
- | munch_cond (T.BINOP(T.LOGOR, e1, e2)) =
- let
- val (insn1, pos1, neg1) = munch_cond e1
- val (insn2, pos2, neg2) = munch_cond e2
- val t1 = (X.TEMP (Temp.new("logor c 1") Tm.Byte), Tm.Byte)
- val t2 = (X.TEMP (Temp.new("logor c 2") Tm.Byte), Tm.Byte)
- val l = Label.new ()
- in
- if (TU.effect e2 orelse (length insn2 > 10))
- then ((insn1) @
- [X.SETcc (pos1, t1), X.Jcc (pos1, l)] @
- (insn2) @
- [X.SETcc (pos2, t1), X.LABEL l, X.TEST(t1, t1)],
- X.NE, X.E)
- else (insn1 @ [X.SETcc (pos1, t1)] @ insn2 @ [X.SETcc (pos2, t2), X.OR(t1, t2)], X.NE, X.E)
- end
- | munch_cond (T.BINOP(T.LOGAND, e1, e2)) =
- let
- val (insn1, pos1, neg1) = munch_cond e1
- val (insn2, pos2, neg2) = munch_cond e2
- val t1 = (X.TEMP (Temp.new("logand c 1") Tm.Byte), Tm.Byte)
- val t2 = (X.TEMP (Temp.new("logand c 2") Tm.Byte), Tm.Byte)
- val l = Label.new ()
- in
- if (TU.effect e2 orelse (length insn2 > 10))
- then ((insn1) @
- [X.SETcc (pos1, t1), X.Jcc (neg1, l)] @
- (insn2) @
- [X.SETcc (pos2, t1), X.LABEL l, X.TEST(t1, t1)],
- X.NE, X.E)
- else (insn1 @ [X.SETcc (pos1, t1)] @ insn2 @ [X.SETcc (pos2, t2), X.AND(t1, t2)], X.NE, X.E)
- end
| munch_cond e =
let
- val t = X.TEMP (Temp.new ("munch c") Tm.Long)
- val (i, s) = munch_exp t e
+ val t = X.TEMP (Temp.new ("munch c"))
+ val i = munch_exp t e
in
- (i @ [ X.TEST ((t,s),(t,s)) ], X.NE, X.E)
+ (i @ [ X.INSN (X.AL, X.MOVS (t,t)) ], X.NE, X.EQ)
end
- (* munch_lval : T.exp -> (X.insn list * X.operand)
- * Takes an expression that has been typechecked as being a valid lvalue, and then returns an instruction list and an operand to store your shit in.
+ (* munch_lval : T.exp -> X.operand
+ * Takes an expression that has been typechecked as being a valid lvalue and a location of a datum, and then returns an instruction list to store.
*)
- and munch_lval (T.TEMP t) = ([], (X.TEMP t, Tm.size t))
- | munch_lval (T.MEMORY (m,s)) =
+ and munch_lval (T.TEMP t) oper = [X.INSN (X.AL, X.MOV (X.TEMP t, oper))]
+ | munch_lval (T.MEMORY m) oper =
let
- val t = X.TEMP (Tm.new "lv addr" Tm.Quad)
- val (i,s') = munch_exp t m
+ val t = X.TEMP (Tm.new "lv addr")
+ val i = munch_exp t m
in
- (i, (X.REL ((t, Tm.Quad), (X.CONST 0w0, Tm.Quad), 0w1), s))
+ i @
+ [X.INSN (X.AL, X.STO (t, oper))]
end
- | munch_lval _ = raise ErrorMsg.InternalError "That wasn't really a valid lvalue..."
+ | munch_lval _ _ = raise ErrorMsg.InternalError "That wasn't really a valid lvalue..."
(* munch_stm : T.stm -> X.insn list *)
(* munch_stm stm generates code to execute stm *)
- and munch_stm (T.MOVE (T.TEMP t1, T.TEMP t2)) = if Tm.size t1 = Tm.size t2 then [X.MOV((X.TEMP t1, Tm.size t1), (X.TEMP t2, Tm.size t2))]
- else raise ErrorMsg.InternalError "temp to temp move fuxed."
- | munch_stm (T.MOVE (T.TEMP t, T.CONST n)) = if Tm.size t = Tm.Long then [X.MOV((X.TEMP t, Tm.size t), (X.CONST n, Tm.size t))]
- else raise ErrorMsg.InternalError "const to temp move fuxed."
- | munch_stm (T.MOVE (T.TEMP t, a as T.ARG (an, sz))) =
+ and munch_stm (T.MOVE (T.TEMP t1, T.TEMP t2)) = [X.INSN (X.AL, X.MOV(X.TEMP t1, X.TEMP t2))]
+ | munch_stm (T.MOVE (T.TEMP t, T.CONST n)) = [X.INSN (X.AL, X.MOVLIT(X.TEMP t, Word.fromLarge (Word32.toLarge n)))]
+ | munch_stm (T.MOVE (T.TEMP t, a as T.ARG (an))) =
let
- val (i, s) = munch_exp (X.TEMP t) a
+ val i = munch_exp (X.TEMP t) a
in
- if s = Tm.size t
- then i
- else raise ErrorMsg.InternalError "arg to tmp fuxed."
+ i
end
- | munch_stm (T.MOVE (T.TEMP t, a as T.CALL _)) = let val (i, _) = munch_exp (X.TEMP t) a in i end
+ | munch_stm (T.MOVE (T.TEMP t, a as T.CALL _)) = munch_exp (X.TEMP t) a
| munch_stm (T.MOVE (a, e2)) =
let
- val t = X.TEMP (Temp.new ("assign") Tm.Long)
- val (m, (r,s1)) = munch_lval a
- val (i, s2) = munch_exp t e2
-(* val _ = print ("move: size " ^ Tm.sfx s2 ^ " from " ^ TU.Print.pp_exp e2 ^ ", " ^ Tm.sfx s1 ^ " from " ^ TU.Print.pp_exp a ^ "\n") *)
- val _ = if s1 = s2 then () else raise ErrorMsg.InternalError "move generic fuxed."
+ val t = X.TEMP (Temp.new ("assign"))
+ val i = munch_exp t e2
+ val li = munch_lval a t
in
- m @ i @ [X.MOV((r,s1), (t,s2))]
+ i @ li
end
- | munch_stm (T.RETURN(e, sz)) =
+ | munch_stm (T.RETURN(e)) =
let
- val t = X.TEMP (Temp.new ("retval") sz)
- val (i, s) = munch_exp t e
+ val t = X.TEMP (Temp.new ("retval"))
+ val i = munch_exp t e
in
- i @ [X.MOV((X.REG X.EAX, sz), (t, if sz = s then sz else raise ErrorMsg.InternalError "retfuxed.")), X.RET]
+ i @ [X.INSN (X.AL, X.MOV(X.REG X.R0, t)), X.INSN (X.AL, X.POP (X.REG X.SP, X.REG X.PC))]
end
| munch_stm (T.LABEL l) = [X.LABEL l]
- | munch_stm (T.JUMP l) = [X.JMP l]
+ | munch_stm (T.JUMP l) = [X.INSN (X.AL, X.MOVLBL (X.REG X.PC, l))]
| munch_stm (T.JUMPIFN(e, l)) =
let
val (insns, pos, neg) = munch_cond e
in
- insns @ [X.Jcc (neg, l)]
+ insns @ [X.INSN (neg, X.MOVLBL (X.REG X.PC, l))]
end
- | munch_stm (T.EFFECT exp) = let val t = X.TEMP (Temp.new "throwaway" Tm.Quad) val (i, _) = munch_exp t exp in i end
+ | munch_stm (T.EFFECT exp) = let val t = X.TEMP (Temp.new "throwaway") val i = munch_exp t exp in i end
fun codegen nil = nil
| codegen (stm::stms) = munch_stm stm @ codegen stms
git.joshuawise.com / snipe.git / blobdiff