diff min-caml-ppc min-caml-x86

min-caml_ppc_x86.diff

Common subdirectories: min-caml-ppc/.git and min-caml-x86/.git
Common subdirectories: min-caml-ppc/PowerPC and min-caml-x86/PowerPC
Common subdirectories: min-caml-ppc/SPARC and min-caml-x86/SPARC
diff min-caml-ppc/asm.ml min-caml-x86/asm.ml
1c1
< (* PowerPC assembly with a few virtual instructions *)
---
> (* 2オペランドではなく3オペランドのx86アセンブリもどき *)
9,10c9
<   | Li of int
<   | FLi of Id.l
---
>   | Set of int
12c11
<   | Mr of Id.t
---
>   | Mov of Id.t
16,26c15,24
<   | Slw of Id.t * id_or_imm
<   | Lwz of Id.t * id_or_imm
<   | Stw of Id.t * Id.t * id_or_imm
<   | FMr of Id.t
<   | FNeg of Id.t
<   | FAdd of Id.t * Id.t
<   | FSub of Id.t * Id.t
<   | FMul of Id.t * Id.t
<   | FDiv of Id.t * Id.t
<   | Lfd of Id.t * id_or_imm
<   | Stfd of Id.t * Id.t * id_or_imm
---
>   | Ld of Id.t * id_or_imm * int
>   | St of Id.t * Id.t * id_or_imm * int
>   | FMovD of Id.t
>   | FNegD of Id.t
>   | FAddD of Id.t * Id.t
>   | FSubD of Id.t * Id.t
>   | FMulD of Id.t * Id.t
>   | FDivD of Id.t * Id.t
>   | LdDF of Id.t * id_or_imm * int
>   | StDF of Id.t * Id.t * id_or_imm * int
46,51c44,46
< let regs = (* Array.init 27 (fun i -> Printf.sprintf "_R_%d" i) *)
<   [| "%r2"; "%r5"; "%r6"; "%r7"; "%r8"; "%r9"; "%r10";
<      "%r11"; "%r12"; "%r13"; "%r14"; "%r15"; "%r16"; "%r17"; "%r18";
<      "%r19"; "%r20"; "%r21"; "%r22"; "%r23"; "%r24"; "%r25"; "%r26";
<      "%r27"; "%r28"; "%r29"; "%r30" |]
< let fregs = Array.init 32 (fun i -> Printf.sprintf "%%f%d" i)
---
> let regs = (* Array.init 16 (fun i -> Printf.sprintf "%%r%d" i) *)
>   [| "%eax"; "%ebx"; "%ecx"; "%edx"; "%esi"; "%edi" |]
> let fregs = Array.init 8 (fun i -> Printf.sprintf "%%xmm%d" i)
55c50,51
< let reg_sw = regs.(Array.length regs - 2) (* temporary for swap *)
---
> (*
> let reg_sw = regs.(Array.length regs - 1) (* temporary for swap *)
57,60c53,57
< let reg_sp = "%r3" (* stack pointer *)
< let reg_hp = "%r4" (* heap pointer (caml2html: sparcasm_reghp) *)
< let reg_tmp = "%r31" (* [XX] ad hoc *)
< let is_reg x = (x.[0] = '%')
---
> *)
> let reg_sp = "%ebp" (* stack pointer *)
> let reg_hp = "min_caml_hp" (* heap pointer (caml2html: sparcasm_reghp) *)
> (* let reg_ra = "%eax" (* return address *) *)
> let is_reg x = (x.[0] = '%' || x = reg_hp)
71,76c68,73
<   | Nop | Li(_) | FLi(_) | SetL(_) | Comment(_) | Restore(_) -> []
<   | Mr(x) | Neg(x) | FMr(x) | FNeg(x) | Save(x, _) -> [x]
<   | Add(x, y') | Sub(x, y') | Slw(x, y') | Lfd(x, y') | Lwz(x, y') -> x :: fv_id_or_imm y'
<   | Stw(x, y, z') | Stfd(x, y, z') -> x :: y :: fv_id_or_imm z'
<   | FAdd(x, y) | FSub(x, y) | FMul(x, y) | FDiv(x, y) -> [x; y]
<   | IfEq(x, y', e1, e2) | IfLE(x, y', e1, e2) | IfGE(x, y', e1, e2) ->  x :: fv_id_or_imm y' @ remove_and_uniq S.empty (fv e1 @ fv e2) (* uniq here just for efficiency *)
---
>   | Nop | Set(_) | SetL(_) | Comment(_) | Restore(_) -> []
>   | Mov(x) | Neg(x) | FMovD(x) | FNegD(x) | Save(x, _) -> [x]
>   | Add(x, y') | Sub(x, y') | Ld(x, y', _) | LdDF(x, y', _) -> x :: fv_id_or_imm y'
>   | St(x, y, z', _) | StDF(x, y, z', _) -> x :: y :: fv_id_or_imm z'
>   | FAddD(x, y) | FSubD(x, y) | FMulD(x, y) | FDivD(x, y) -> [x; y]
>   | IfEq(x, y', e1, e2) | IfLE(x, y', e1, e2) | IfGE(x, y', e1, e2) -> x :: fv_id_or_imm y' @ remove_and_uniq S.empty (fv e1 @ fv e2) (* uniq here just for efficiency *)
diff min-caml-ppc/asm.mli min-caml-x86/asm.mli
7,8c7
<   | Li of int
<   | FLi of Id.l
---
>   | Set of int
10c9
<   | Mr of Id.t
---
>   | Mov of Id.t
14,24c13,22
<   | Slw of Id.t * id_or_imm
<   | Lwz of Id.t * id_or_imm
<   | Stw of Id.t * Id.t * id_or_imm
<   | FMr of Id.t 
<   | FNeg of Id.t
<   | FAdd of Id.t * Id.t
<   | FSub of Id.t * Id.t
<   | FMul of Id.t * Id.t
<   | FDiv of Id.t * Id.t
<   | Lfd of Id.t * id_or_imm
<   | Stfd of Id.t * Id.t * id_or_imm
---
>   | Ld of Id.t * id_or_imm * int
>   | St of Id.t * Id.t * id_or_imm * int
>   | FMovD of Id.t
>   | FNegD of Id.t
>   | FAddD of Id.t * Id.t
>   | FSubD of Id.t * Id.t
>   | FMulD of Id.t * Id.t
>   | FDivD of Id.t * Id.t
>   | LdDF of Id.t * id_or_imm * int
>   | StDF of Id.t * Id.t * id_or_imm * int
47a46
> (*
49a49,50
> val reg_ra : Id.t
> *)
52d52
< val reg_tmp : Id.t
Common subdirectories: min-caml-ppc/bytemark and min-caml-x86/bytemark
diff min-caml-ppc/emit.ml min-caml-x86/emit.ml
25c25
< let stacksize () = align ((List.length !stackmap + 1) * 4)
---
> let stacksize () = align (List.length !stackmap * 4)
27,36c27,29
< let reg r =
<   if is_reg r
<   then String.sub r 1 (String.length r - 1)
<   else r
< 
< let load_label r label =
<   let r' = reg r in
<   Printf.sprintf
<     "\tlis\t%s, ha16(%s)\n\taddi\t%s, %s, lo16(%s)\n"
<     r' label r' r' label
---
> let pp_id_or_imm = function
>   | V(x) -> x
>   | C(i) -> "$" ^ string_of_int i
62,99c55,118
<   | NonTail(x), Li(i) when -32768 <= i && i < 32768 -> Printf.fprintf oc "\tli\t%s, %d\n" (reg x) i
<   | NonTail(x), Li(i) ->
<       let n = i lsr 16 in
<       let m = i lxor (n lsl 16) in
<       let r = reg x in
<       Printf.fprintf oc "\tlis\t%s, %d\n" r n;
<       Printf.fprintf oc "\tori\t%s, %s, %d\n" r r m
<   | NonTail(x), FLi(Id.L(l)) ->
<       let s = load_label (reg reg_tmp) l in
<       Printf.fprintf oc "%s\tlfd\t%s, 0(%s)\n" s (reg x) (reg reg_tmp)
<   | NonTail(x), SetL(Id.L(y)) ->
<       let s = load_label x y in
<       Printf.fprintf oc "%s" s
<   | NonTail(x), Mr(y) when x = y -> ()
<   | NonTail(x), Mr(y) -> Printf.fprintf oc "\tmr\t%s, %s\n" (reg x) (reg y)
<   | NonTail(x), Neg(y) -> Printf.fprintf oc "\tneg\t%s, %s\n" (reg x) (reg y)
<   | NonTail(x), Add(y, V(z)) -> Printf.fprintf oc "\tadd\t%s, %s, %s\n" (reg x) (reg y) (reg z)
<   | NonTail(x), Add(y, C(z)) -> Printf.fprintf oc "\taddi\t%s, %s, %d\n" (reg x) (reg y) z
<   | NonTail(x), Sub(y, V(z)) -> Printf.fprintf oc "\tsub\t%s, %s, %s\n" (reg x) (reg y) (reg z)
<   | NonTail(x), Sub(y, C(z)) -> Printf.fprintf oc "\tsubi\t%s, %s, %d\n" (reg x) (reg y) z
<   | NonTail(x), Slw(y, V(z)) -> Printf.fprintf oc "\tslw\t%s, %s, %s\n" (reg x) (reg y) (reg z)
<   | NonTail(x), Slw(y, C(z)) -> Printf.fprintf oc "\tslwi\t%s, %s, %d\n" (reg x) (reg y) z
<   | NonTail(x), Lwz(y, V(z)) -> Printf.fprintf oc "\tlwzx\t%s, %s, %s\n" (reg x) (reg y) (reg z)
<   | NonTail(x), Lwz(y, C(z)) -> Printf.fprintf oc "\tlwz\t%s, %d(%s)\n" (reg x) z (reg y)
<   | NonTail(_), Stw(x, y, V(z)) -> Printf.fprintf oc "\tstwx\t%s, %s, %s\n" (reg x) (reg y) (reg z)
<   | NonTail(_), Stw(x, y, C(z)) -> Printf.fprintf oc "\tstw\t%s, %d(%s)\n" (reg x) z (reg y)
<   | NonTail(x), FMr(y) when x = y -> ()
<   | NonTail(x), FMr(y) -> Printf.fprintf oc "\tfmr\t%s, %s\n" (reg x) (reg y)
<   | NonTail(x), FNeg(y) -> Printf.fprintf oc "\tfneg\t%s, %s\n" (reg x) (reg y)
<   | NonTail(x), FAdd(y, z) -> Printf.fprintf oc "\tfadd\t%s, %s, %s\n" (reg x) (reg y) (reg z)
<   | NonTail(x), FSub(y, z) -> Printf.fprintf oc "\tfsub\t%s, %s, %s\n" (reg x) (reg y) (reg z)
<   | NonTail(x), FMul(y, z) -> Printf.fprintf oc "\tfmul\t%s, %s, %s\n" (reg x) (reg y) (reg z)
<   | NonTail(x), FDiv(y, z) -> Printf.fprintf oc "\tfdiv\t%s, %s, %s\n" (reg x) (reg y) (reg z)
<   | NonTail(x), Lfd(y, V(z)) -> Printf.fprintf oc "\tlfdx\t%s, %s, %s\n" (reg x) (reg y) (reg z)
<   | NonTail(x), Lfd(y, C(z)) -> Printf.fprintf oc "\tlfd\t%s, %d(%s)\n" (reg x) z (reg y)
<   | NonTail(_), Stfd(x, y, V(z)) -> Printf.fprintf oc "\tstfdx\t%s, %s, %s\n" (reg x) (reg y) (reg z)
<   | NonTail(_), Stfd(x, y, C(z)) -> Printf.fprintf oc "\tstfd\t%s, %d(%s)\n" (reg x) z (reg y)
<   | NonTail(_), Comment(s) -> Printf.fprintf oc "#\t%s\n" s
---
>   | NonTail(x), Set(i) -> Printf.fprintf oc "\tmovl\t$%d, %s\n" i x
>   | NonTail(x), SetL(Id.L(y)) -> Printf.fprintf oc "\tmovl\t$%s, %s\n" y x
>   | NonTail(x), Mov(y) ->
>       if x <> y then Printf.fprintf oc "\tmovl\t%s, %s\n" y x
>   | NonTail(x), Neg(y) ->
>       if x <> y then Printf.fprintf oc "\tmovl\t%s, %s\n" y x;
>       Printf.fprintf oc "\tnegl\t%s\n" x
>   | NonTail(x), Add(y, z') ->
>       if V(x) = z' then
>         Printf.fprintf oc "\taddl\t%s, %s\n" y x
>       else
>         (if x <> y then Printf.fprintf oc "\tmovl\t%s, %s\n" y x;
>          Printf.fprintf oc "\taddl\t%s, %s\n" (pp_id_or_imm z') x)
>   | NonTail(x), Sub(y, z') ->
>       if V(x) = z' then
>         (Printf.fprintf oc "\tsubl\t%s, %s\n" y x;
>          Printf.fprintf oc "\tnegl\t%s\n" x)
>       else
>         (if x <> y then Printf.fprintf oc "\tmovl\t%s, %s\n" y x;
>          Printf.fprintf oc "\tsubl\t%s, %s\n" (pp_id_or_imm z') x)
>   | NonTail(x), Ld(y, V(z), i) -> Printf.fprintf oc "\tmovl\t(%s,%s,%d), %s\n" y z i x
>   | NonTail(x), Ld(y, C(j), i) -> Printf.fprintf oc "\tmovl\t%d(%s), %s\n" (j * i) y x
>   | NonTail(_), St(x, y, V(z), i) -> Printf.fprintf oc "\tmovl\t%s, (%s,%s,%d)\n" x y z i
>   | NonTail(_), St(x, y, C(j), i) -> Printf.fprintf oc "\tmovl\t%s, %d(%s)\n" x (j * i) y
>   | NonTail(x), FMovD(y) ->
>       if x <> y then Printf.fprintf oc "\tmovsd\t%s, %s\n" y x
>   | NonTail(x), FNegD(y) ->
>       if x <> y then Printf.fprintf oc "\tmovsd\t%s, %s\n" y x;
>       Printf.fprintf oc "\txorpd\tmin_caml_fnegd, %s\n" x
>   | NonTail(x), FAddD(y, z) ->
>       if x = z then
>         Printf.fprintf oc "\taddsd\t%s, %s\n" y x
>       else
>         (if x <> y then Printf.fprintf oc "\tmovsd\t%s, %s\n" y x;
>          Printf.fprintf oc "\taddsd\t%s, %s\n" z x)
>   | NonTail(x), FSubD(y, z) ->
>       if x = z then (* [XXX] ugly *)
>         let ss = stacksize () in
>         Printf.fprintf oc "\tmovsd\t%s, %d(%s)\n" z ss reg_sp;
>         if x <> y then Printf.fprintf oc "\tmovsd\t%s, %s\n" y x;
>         Printf.fprintf oc "\tsubsd\t%d(%s), %s\n" ss reg_sp x
>       else
>         (if x <> y then Printf.fprintf oc "\tmovsd\t%s, %s\n" y x;
>          Printf.fprintf oc "\tsubsd\t%s, %s\n" z x)
>   | NonTail(x), FMulD(y, z) ->
>       if x = z then
>         Printf.fprintf oc "\tmulsd\t%s, %s\n" y x
>       else
>         (if x <> y then Printf.fprintf oc "\tmovsd\t%s, %s\n" y x;
>          Printf.fprintf oc "\tmulsd\t%s, %s\n" z x)
>   | NonTail(x), FDivD(y, z) ->
>       if x = z then (* [XXX] ugly *)
>         let ss = stacksize () in
>         Printf.fprintf oc "\tmovsd\t%s, %d(%s)\n" z ss reg_sp;
>         if x <> y then Printf.fprintf oc "\tmovsd\t%s, %s\n" y x;
>         Printf.fprintf oc "\tdivsd\t%d(%s), %s\n" ss reg_sp x
>       else
>         (if x <> y then Printf.fprintf oc "\tmovsd\t%s, %s\n" y x;
>          Printf.fprintf oc "\tdivsd\t%s, %s\n" z x)
>   | NonTail(x), LdDF(y, V(z), i) -> Printf.fprintf oc "\tmovsd\t(%s,%s,%d), %s\n" y z i x
>   | NonTail(x), LdDF(y, C(j), i) -> Printf.fprintf oc "\tmovsd\t%d(%s), %s\n" (j * i) y x
>   | NonTail(_), StDF(x, y, V(z), i) -> Printf.fprintf oc "\tmovsd\t%s, (%s,%s,%d)\n" x y z i
>   | NonTail(_), StDF(x, y, C(j), i) -> Printf.fprintf oc "\tmovsd\t%s, %d(%s)\n" x (j * i) y
>   | NonTail(_), Comment(s) -> Printf.fprintf oc "\t# %s\n" s
103c122
<       Printf.fprintf oc "\tstw\t%s, %d(%s)\n" (reg x) (offset y) (reg reg_sp)
---
>       Printf.fprintf oc "\tmovl\t%s, %d(%s)\n" x (offset y) reg_sp
106c125
<       Printf.fprintf oc "\tstfd\t%s, %d(%s)\n" (reg x) (offset y) (reg reg_sp)
---
>       Printf.fprintf oc "\tmovsd\t%s, %d(%s)\n" x (offset y) reg_sp
110c129
<       Printf.fprintf oc "\tlwz\t%s, %d(%s)\n" (reg x) (offset y) (reg reg_sp)
---
>       Printf.fprintf oc "\tmovl\t%d(%s), %s\n" (offset y) reg_sp x
113,115c132,134
<       Printf.fprintf oc "\tlfd\t%s, %d(%s)\n" (reg x) (offset y) (reg reg_sp)
<   (* 末尾だったら計算結果を第一レジスタにセットしてリターン (caml2html: emit_tailret) *)
<   | Tail, (Nop | Stw _ | Stfd _ | Comment _ | Save _ as exp) ->
---
>       Printf.fprintf oc "\tmovsd\t%d(%s), %s\n" (offset y) reg_sp x
>   (* 末尾だったら計算結果を第一レジスタにセットしてret (caml2html: emit_tailret) *)
>   | Tail, (Nop | St _ | StDF _ | Comment _ | Save _ as exp) ->
117,118c136,137
<       Printf.fprintf oc "\tblr\n";
<   | Tail, (Li _ | SetL _ | Mr _ | Neg _ | Add _ | Sub _ | Slw _ | Lwz _ as exp) ->
---
>       Printf.fprintf oc "\tret\n";
>   | Tail, (Set _ | SetL _ | Mov _ | Neg _ | Add _ | Sub _ | Ld _ as exp) ->
120,121c139,140
<       Printf.fprintf oc "\tblr\n";
<   | Tail, (FLi _ | FMr _ | FNeg _ | FAdd _ | FSub _ | FMul _ | FDiv _ | Lfd _ as exp) ->
---
>       Printf.fprintf oc "\tret\n";
>   | Tail, (FMovD _ | FNegD _ | FAddD _ | FSubD _ | FMulD _ | FDivD _ | LdDF _  as exp) ->
123c142
<       Printf.fprintf oc "\tblr\n";
---
>       Printf.fprintf oc "\tret\n";
129,147c148,157
<       Printf.fprintf oc "\tblr\n";
<   | Tail, IfEq(x, V(y), e1, e2) ->
<       Printf.fprintf oc "\tcmpw\tcr7, %s, %s\n" (reg x) (reg y);
<       g'_tail_if oc e1 e2 "beq" "bne"
<   | Tail, IfEq(x, C(y), e1, e2) ->
<       Printf.fprintf oc "\tcmpwi\tcr7, %s, %d\n" (reg x) y;
<       g'_tail_if oc e1 e2 "beq" "bne"
<   | Tail, IfLE(x, V(y), e1, e2) ->
<       Printf.fprintf oc "\tcmpw\tcr7, %s, %s\n" (reg x) (reg y);
<       g'_tail_if oc e1 e2 "ble" "bgt"
<   | Tail, IfLE(x, C(y), e1, e2) ->
<       Printf.fprintf oc "\tcmpwi\tcr7, %s, %d\n" (reg x) y;
<       g'_tail_if oc e1 e2 "ble" "bgt"
<   | Tail, IfGE(x, V(y), e1, e2) ->
<       Printf.fprintf oc "\tcmpw\tcr7, %s, %s\n" (reg x) (reg y);
<       g'_tail_if oc e1 e2 "bge" "blt"
<   | Tail, IfGE(x, C(y), e1, e2) ->
<       Printf.fprintf oc "\tcmpwi\tcr7, %s, %d\n" (reg x) y;
<       g'_tail_if oc e1 e2 "bge" "blt"
---
>       Printf.fprintf oc "\tret\n";
>   | Tail, IfEq(x, y', e1, e2) ->
>       Printf.fprintf oc "\tcmpl\t%s, %s\n" (pp_id_or_imm y') x;
>       g'_tail_if oc e1 e2 "je" "jne"
>   | Tail, IfLE(x, y', e1, e2) ->
>       Printf.fprintf oc "\tcmpl\t%s, %s\n" (pp_id_or_imm y') x;
>       g'_tail_if oc e1 e2 "jle" "jg"
>   | Tail, IfGE(x, y', e1, e2) ->
>       Printf.fprintf oc "\tcmpl\t%s, %s\n" (pp_id_or_imm y') x;
>       g'_tail_if oc e1 e2 "jge" "jl"
149,150c159,160
<       Printf.fprintf oc "\tfcmpu\tcr7, %s, %s\n" (reg x) (reg y);
<       g'_tail_if oc e1 e2 "beq" "bne"
---
>       Printf.fprintf oc "\tcomisd\t%s, %s\n" y x;
>       g'_tail_if oc e1 e2 "je" "jne"
152,171c162,172
<       Printf.fprintf oc "\tfcmpu\tcr7, %s, %s\n" (reg x) (reg y);
<       g'_tail_if oc e1 e2 "ble" "bgt"
<   | NonTail(z), IfEq(x, V(y), e1, e2) ->
<       Printf.fprintf oc "\tcmpw\tcr7, %s, %s\n" (reg x) (reg y);
<       g'_non_tail_if oc (NonTail(z)) e1 e2 "beq" "bne"
<   | NonTail(z), IfEq(x, C(y), e1, e2) ->
<       Printf.fprintf oc "\tcmpwi\tcr7, %s, %d\n" (reg x) y;
<       g'_non_tail_if oc (NonTail(z)) e1 e2 "beq" "bne"
<   | NonTail(z), IfLE(x, V(y), e1, e2) ->
<       Printf.fprintf oc "\tcmpw\tcr7, %s, %s\n" (reg x) (reg y);
<       g'_non_tail_if oc (NonTail(z)) e1 e2 "ble" "bgt"
<   | NonTail(z), IfLE(x, C(y), e1, e2) ->
<       Printf.fprintf oc "\tcmpwi\tcr7, %s, %d\n" (reg x) y;
<       g'_non_tail_if oc (NonTail(z)) e1 e2 "ble" "bgt"
<   | NonTail(z), IfGE(x, V(y), e1, e2) ->
<       Printf.fprintf oc "\tcmpw\tcr7, %s, %s\n" (reg x) (reg y);
<       g'_non_tail_if oc (NonTail(z)) e1 e2 "bge" "blt"
<   | NonTail(z), IfGE(x, C(y), e1, e2) ->
<       Printf.fprintf oc "\tcmpwi\tcr7, %s, %d\n" (reg x) y;
<       g'_non_tail_if oc (NonTail(z)) e1 e2 "bge" "blt"
---
>       Printf.fprintf oc "\tcomisd\t%s, %s\n" y x;
>       g'_tail_if oc e1 e2 "jbe" "ja"
>   | NonTail(z), IfEq(x, y', e1, e2) ->
>       Printf.fprintf oc "\tcmpl\t%s, %s\n" (pp_id_or_imm y') x;
>       g'_non_tail_if oc (NonTail(z)) e1 e2 "je" "jne"
>   | NonTail(z), IfLE(x, y', e1, e2) ->
>       Printf.fprintf oc "\tcmpl\t%s, %s\n" (pp_id_or_imm y') x;
>       g'_non_tail_if oc (NonTail(z)) e1 e2 "jle" "jg"
>   | NonTail(z), IfGE(x, y', e1, e2) ->
>       Printf.fprintf oc "\tcmpl\t%s, %s\n" (pp_id_or_imm y') x;
>       g'_non_tail_if oc (NonTail(z)) e1 e2 "jge" "jl"
173,174c174,175
<       Printf.fprintf oc "\tfcmpu\tcr7, %s, %s\n" (reg x) (reg y);
<       g'_non_tail_if oc (NonTail(z)) e1 e2 "beq" "bne"
---
>       Printf.fprintf oc "\tcomisd\t%s, %s\n" y x;
>       g'_non_tail_if oc (NonTail(z)) e1 e2 "je" "jne"
176,177c177,178
<       Printf.fprintf oc "\tfcmpu\tcr7, %s, %s\n" (reg x) (reg y);
<       g'_non_tail_if oc (NonTail(z)) e1 e2 "ble" "bgt"
---
>       Printf.fprintf oc "\tcomisd\t%s, %s\n" y x;
>       g'_non_tail_if oc (NonTail(z)) e1 e2 "jbe" "ja"
181,182c182
<       Printf.fprintf oc "\tlwz\t%s, 0(%s)\n" (reg reg_sw) (reg reg_cl);
<       Printf.fprintf oc "\tmtctr\t%s\n\tbctr\n" (reg reg_sw);
---
>       Printf.fprintf oc "\tjmp\t*(%s)\n" reg_cl;
185c185
<       Printf.fprintf oc "\tb\t%s\n" x
---
>       Printf.fprintf oc "\tjmp\t%s\n" x;
187d186
<       Printf.fprintf oc "\tmflr\t%s\n" (reg reg_tmp);
190,196c189,191
<       Printf.fprintf oc "\tstw\t%s, %d(%s)\n" (reg reg_tmp) (ss - 4) (reg reg_sp);
<       Printf.fprintf oc "\taddi\t%s, %s, %d\n" (reg reg_sp) (reg reg_sp) ss;
<       Printf.fprintf oc "\tlwz\t%s, 0(%s)\n" (reg reg_tmp) (reg reg_cl);
<       Printf.fprintf oc "\tmtctr\t%s\n" (reg reg_tmp);
<       Printf.fprintf oc "\tbctrl\n";
<       Printf.fprintf oc "\tsubi\t%s, %s, %d\n" (reg reg_sp) (reg reg_sp) ss;
<       Printf.fprintf oc "\tlwz\t%s, %d(%s)\n" (reg reg_tmp) (ss - 4) (reg reg_sp);
---
>       if ss > 0 then Printf.fprintf oc "\taddl\t$%d, %s\n" ss reg_sp;
>       Printf.fprintf oc "\tcall\t*(%s)\n" reg_cl;
>       if ss > 0 then Printf.fprintf oc "\tsubl\t$%d, %s\n" ss reg_sp;
198c193
<         Printf.fprintf oc "\tmr\t%s, %s\n" (reg a) (reg regs.(0))
---
>         Printf.fprintf oc "\tmovl\t%s, %s\n" regs.(0) a
200,203c195,196
<         Printf.fprintf oc "\tfmr\t%s, %s\n" (reg a) (reg fregs.(0));
<       Printf.fprintf oc "\tmtlr\t%s\n" (reg reg_tmp)
<   | (NonTail(a), CallDir(Id.L(x), ys, zs)) ->
<       Printf.fprintf oc "\tmflr\t%s\n" (reg reg_tmp);
---
>         Printf.fprintf oc "\tmovsd\t%s, %s\n" fregs.(0) a
>   | NonTail(a), CallDir(Id.L(x), ys, zs) ->
206,210c199,201
<       Printf.fprintf oc "\tstw\t%s, %d(%s)\n" (reg reg_tmp) (ss - 4) (reg reg_sp);
<       Printf.fprintf oc "\taddi\t%s, %s, %d\n" (reg reg_sp) (reg reg_sp) ss;
<       Printf.fprintf oc "\tbl\t%s\n" x;
<       Printf.fprintf oc "\tsubi\t%s, %s, %d\n" (reg reg_sp) (reg reg_sp) ss;
<       Printf.fprintf oc "\tlwz\t%s, %d(%s)\n" (reg reg_tmp) (ss - 4) (reg reg_sp);
---
>       if ss > 0 then Printf.fprintf oc "\taddl\t$%d, %s\n" ss reg_sp;
>       Printf.fprintf oc "\tcall\t%s\n" x;
>       if ss > 0 then Printf.fprintf oc "\tsubl\t$%d, %s\n" ss reg_sp;
212c203
<         Printf.fprintf oc "\tmr\t%s, %s\n" (reg a) (reg regs.(0))
---
>         Printf.fprintf oc "\tmovl\t%s, %s\n" regs.(0) a
214,215c205
<         Printf.fprintf oc "\tfmr\t%s, %s\n" (reg a) (reg fregs.(0));
<       Printf.fprintf oc "\tmtlr\t%s\n" (reg reg_tmp)
---
>         Printf.fprintf oc "\tmovsd\t%s, %s\n" fregs.(0) a
218c208
<   Printf.fprintf oc "\t%s\tcr7, %s\n" bn b_else;
---
>   Printf.fprintf oc "\t%s\t%s\n" bn b_else;
227c217
<   Printf.fprintf oc "\t%s\tcr7, %s\n" bn b_else;
---
>   Printf.fprintf oc "\t%s\t%s\n" bn b_else;
231c221
<   Printf.fprintf oc "\tb\t%s\n" b_cont;
---
>   Printf.fprintf oc "\tjmp\t%s\n" b_cont;
238a229,231
>   assert (List.length ys <= Array.length regs - List.length x_reg_cl);
>   assert (List.length zs <= Array.length fregs);
>   let sw = Printf.sprintf "%d(%s)" (stacksize ()) reg_sp in
245,246c238,239
<     (fun (y, r) -> Printf.fprintf oc "\tmr\t%s, %s\n" (reg r) (reg y))
<     (shuffle reg_sw yrs);
---
>     (fun (y, r) -> Printf.fprintf oc "\tmovl\t%s, %s\n" y r)
>     (shuffle sw yrs);
253,254c246,247
<     (fun (z, fr) -> Printf.fprintf oc "\tfmr\t%s, %s\n" (reg fr) (reg z))
<     (shuffle reg_fsw zfrs)
---
>     (fun (z, fr) -> Printf.fprintf oc "\tmovsd\t%s, %s\n" z fr)
>     (shuffle sw zfrs)
264,275c257,265
<   if data <> [] then
<     (Printf.fprintf oc "\t.data\n\t.literal8\n";
<      List.iter
<        (fun (Id.L(x), d) ->
<          Printf.fprintf oc "\t.align 3\n";
<          Printf.fprintf oc "%s:\t # %f\n" x d;
<          Printf.fprintf oc "\t.long\t%ld\n" (gethi d);
<          Printf.fprintf oc "\t.long\t%ld\n" (getlo d))
<        data);
<   Printf.fprintf oc "\t.text\n";
<   Printf.fprintf oc "\t.globl _min_caml_start\n";
<   Printf.fprintf oc "\t.align 2\n";
---
>   Printf.fprintf oc ".data\n";
>   Printf.fprintf oc ".balign\t8\n";
>   List.iter
>     (fun (Id.L(x), d) ->
>       Printf.fprintf oc "%s:\t# %f\n" x d;
>       Printf.fprintf oc "\t.long\t0x%lx\n" (gethi d);
>       Printf.fprintf oc "\t.long\t0x%lx\n" (getlo d))
>     data;
>   Printf.fprintf oc ".text\n";
277,282c267,280
<   Printf.fprintf oc "_min_caml_start: # main entry point\n";
<   Printf.fprintf oc "\tmflr\tr0\n";
<   Printf.fprintf oc "\tstmw\tr30, -8(r1)\n";
<   Printf.fprintf oc "\tstw\tr0, 8(r1)\n";
<   Printf.fprintf oc "\tstwu\tr1, -96(r1)\n";
<   Printf.fprintf oc "#\tmain program starts\n";
---
>   Printf.fprintf oc ".globl\tmin_caml_start\n";
>   Printf.fprintf oc "min_caml_start:\n";
>   Printf.fprintf oc ".globl\t_min_caml_start\n";
>   Printf.fprintf oc "_min_caml_start: # for cygwin\n";
>   Printf.fprintf oc "\tpushl\t%%eax\n";
>   Printf.fprintf oc "\tpushl\t%%ebx\n";
>   Printf.fprintf oc "\tpushl\t%%ecx\n";
>   Printf.fprintf oc "\tpushl\t%%edx\n";
>   Printf.fprintf oc "\tpushl\t%%esi\n";
>   Printf.fprintf oc "\tpushl\t%%edi\n";
>   Printf.fprintf oc "\tpushl\t%%ebp\n";
>   Printf.fprintf oc "\tmovl\t32(%%esp),%s\n" reg_sp;
>   Printf.fprintf oc "\tmovl\t36(%%esp),%s\n" regs.(0);
>   Printf.fprintf oc "\tmovl\t%s,%s\n" regs.(0) reg_hp;
285,292c283,291
<   g oc (NonTail("_R_0"), e);
<   Printf.fprintf oc "#\tmain program ends\n";
<   (* Printf.fprintf oc "\tmr\tr3, %s\n" regs.(0); *)
<   Printf.fprintf oc "\tlwz\tr1, 0(r1)\n";
<   Printf.fprintf oc "\tlwz\tr0, 8(r1)\n";
<   Printf.fprintf oc "\tmtlr\tr0\n";
<   Printf.fprintf oc "\tlmw\tr30, -8(r1)\n";
<   Printf.fprintf oc "\tblr\n"
---
>   g oc (NonTail(regs.(0)), e);
>   Printf.fprintf oc "\tpopl\t%%ebp\n";
>   Printf.fprintf oc "\tpopl\t%%edi\n";
>   Printf.fprintf oc "\tpopl\t%%esi\n";
>   Printf.fprintf oc "\tpopl\t%%edx\n";
>   Printf.fprintf oc "\tpopl\t%%ecx\n";
>   Printf.fprintf oc "\tpopl\t%%ebx\n";
>   Printf.fprintf oc "\tpopl\t%%eax\n";
>   Printf.fprintf oc "\tret\n";
diff min-caml-ppc/libmincaml.S min-caml-x86/libmincaml.S
1,15c1,18
< 	.cstring
< 	.align 	2
< LC0:
< 	.ascii	"%d\0"
< 	.align	2
< LC1:
< 	.ascii 	"%lf\0"
< 	.literal8
< 	.align 	3
< LC2:
< 	.long	1127219200
< 	.long	-2147483648
< 	.text
< 	.align	2
< 	.globl 	min_caml_print_newline
---
> #if defined(__CYGWIN__) || defined(__MACH__)
> #define U(x) _##x
> #else
> #define U(x) x
> #endif
> #if defined(__MACH__)
> #define ALIGNSTACK0 andl $0xfffffff0, %esp
> #define ALIGNSTACK1 andl $0xfffffff0, %esp; pushl %eax; pushl %eax; pushl %eax
> #define ALIGNSTACK2 andl $0xfffffff0, %esp; pushl %eax; pushl %eax
> #define ALIGNSTACK3 andl $0xfffffff0, %esp; pushl %eax
> #else
> #define ALIGNSTACK0
> #define ALIGNSTACK1
> #define ALIGNSTACK2
> #define ALIGNSTACK3
> #endif
> .text
> .globl min_caml_print_newline
17,54c20,28
< 	mflr 	r0
< 	stmw 	r30, -8(r1)
< 	stw 	r0, 8(r1)
< 	stw	r3, 12(r1)
< 	stw	r4, 16(r1)
< 	stwu  	r1, -80(r1)
< 	mr 	r30, r1
< 	li	r3, 10
< 	bl 	putchar
< 	lwz 	r1, 0(r1)
< 	lwz 	r0, 8(r1)
< 	lwz	r3, 12(r1)
< 	lwz	r4, 16(r1)
< 	mtlr 	r0
< 	lmw 	r30, -8(r1)
< 	blr
< 	.section __TEXT, __picsymbolstub1, symbol_stubs, pure_instructions, 32
< 	.align 	5
< putchar:
< 	.indirect_symbol _putchar
< 	mflr 	r0
< 	bcl 	20, 31, L1spb
< L1spb:
< 	mflr 	r11
< 	addis 	r11, r11, ha16(putchar_lazy-L1spb)
< 	mtlr 	r0
< 	lwzu 	r12, lo16(putchar_lazy-L1spb)(r11)
< 	mtctr 	r12
< 	bctr
< 	.lazy_symbol_pointer
< putchar_lazy:
< 	.indirect_symbol _putchar
< 	.long	dyld_stub_binding_helper
< 	.subsections_via_symbols
< #	print_int
< 	.text
< 	.align 	2
< 	.globl	min_caml_print_int
---
> 	pushl	%ebp
> 	movl	%esp, %ebp
> 	ALIGNSTACK1
> 	pushl	$10
> 	call	U(putchar)
> 	movl	%ebp, %esp
> 	popl	%ebp
> 	ret
> .globl min_caml_print_int
56,98c30,39
< 	mflr 	r0
< 	stmw 	r30, -8(r1)
< 	stw 	r0, 8(r1)
< 	stw	r3, 12(r1)
< 	stw	r4, 16(r1)
< 	stwu 	r1, -80(r1)
< 	mr 	r30, r1
< 	bcl 	20, 31, L2pb
< L2pb:
< 	mflr 	r31
< 	mr	r4, r2
< 	addis 	r2, r31, ha16(LC0 - L2pb)
< 	la 	r3, lo16(LC0 - L2pb)(r2)
< 	bl	printf
< 	lwz 	r1, 0(r1)
< 	lwz 	r0, 8(r1)
< 	lwz	r3, 12(r1)
< 	lwz	r4, 16(r1)
< 	mtlr 	r0
< 	lmw 	r30, -8(r1)
< 	blr
< 	.section __TEXT, __picsymbolstub1, symbol_stubs, pure_instructions, 32
< 	.align 	5
< printf:
< 	.indirect_symbol _printf$LDBLStub
< 	mflr 	r0
< 	bcl 	20, 31, L2spb
< L2spb:
< 	mflr 	r11
< 	addis 	r11, r11, ha16(printf_lazy-L2spb)
< 	mtlr 	r0
< 	lwzu 	r12, lo16(printf_lazy-L2spb)(r11)
< 	mtctr 	r12
< 	bctr
< 	.lazy_symbol_pointer
< printf_lazy:
< 	.indirect_symbol _printf$LDBLStub
< 	.long	dyld_stub_binding_helper
< 	.subsections_via_symbols
< #	print_byte
< 	.text
< 	.align 	2
< 	.globl	min_caml_print_byte
---
> 	pushl	%ebp
> 	movl	%esp, %ebp
> 	ALIGNSTACK2
> 	pushl	%eax
> 	pushl	$format_int
> 	call	U(printf)
> 	movl	%ebp, %esp
> 	popl	%ebp
> 	ret
> .globl min_caml_print_byte
100,120c41,49
< 	mflr 	r0
< 	stmw 	r30, -8(r1)
< 	stw 	r0, 8(r1)
< 	stw	r3, 12(r1)
< 	stw	r4, 16(r1)
< 	stwu  	r1, -80(r1)
< 	mr 	r30, r1
< 	stw	r3, 104(r30)
< 	mr	r3, r2
< 	bl 	putchar
< 	lwz 	r1, 0(r1)
< 	lwz 	r0, 8(r1)
< 	lwz	r3, 12(r1)
< 	lwz	r4, 16(r1)
< 	mtlr 	r0
< 	lmw 	r30, -8(r1)
< 	blr	
< #	prerr_int
< 	.text
< 	.align 	2
< 	.globl 	min_caml_prerr_int
---
> 	pushl	%ebp
> 	movl	%esp, %ebp
> 	ALIGNSTACK1
> 	pushl	%eax
> 	call	U(putchar)
> 	movl	%ebp, %esp
> 	popl	%ebp
> 	ret
> .globl min_caml_prerr_int
122,174c51,61
< 	mflr 	r0
< 	stmw 	r30, -8(r1)
< 	stw 	r0, 8(r1)
< 	stw	r3, 12(r1)
< 	stw	r4, 16(r1)
< 	stwu 	r1, -80(r1)
< 	mr 	r30, r1
< 	bcl 	20, 31, L3pb
< L3pb:
< 	mflr 	r31
< 	mr	r6, r2
< 	mr	r2, r5
< 	mr	r5, r6
< 	addis 	r2, r31, ha16(L - L3pb)
< 	lwz 	r2, lo16(L - L3pb)(r2)
< 	addi 	r0, r2, 176
< 	mr 	r3, r0
< 	addis 	r2, r31, ha16(LC0 - L3pb)
< 	la 	r4, lo16(LC0 - L3pb)(r2)
< 	bl 	fprintf
< 	lwz 	r1, 0(r1)
< 	lwz 	r0, 8(r1)
< 	lwz	r3, 12(r1)
< 	lwz	r4, 16(r1)
< 	mtlr 	r0
< 	lmw 	r30, -8(r1)
< 	blr
< 	.non_lazy_symbol_pointer
< L:
< 	.indirect_symbol ___sF
< 	.long	0
< 	.section __TEXT, __picsymbolstub1, symbol_stubs, pure_instructions, 32
< 	.align 	5
< fprintf:	
< 	.indirect_symbol _fprintf$LDBLStub
< 	mflr 	r0
< 	bcl 	20, 31, L3spb
< L3spb:
< 	mflr 	r11
< 	addis 	r11, r11, ha16(fprintf_lazy - L3spb)
< 	mtlr 	r0
< 	lwzu 	r12, lo16(fprintf_lazy - L3spb)(r11)
< 	mtctr 	r12
< 	bctr
< 	.lazy_symbol_pointer
< fprintf_lazy:
< 	.indirect_symbol _fprintf$LDBLStub
< 	.long	dyld_stub_binding_helper
< 	.subsections_via_symbols
< #	prerr_byte
< 	.text
< 	.align 	2
< 	.globl	min_caml_prerr_byte
---
> 	pushl	%ebp
> 	movl	%esp, %ebp
> 	ALIGNSTACK3
> 	pushl	%eax
> 	pushl	$format_int
> 	pushl	U(min_caml_stderr)
> 	call	U(fprintf)
> 	movl	%ebp, %esp
> 	popl	%ebp
> 	ret
> .globl min_caml_prerr_byte
176,220c63,72
< 	mflr	r0
< 	stmw	r30, -8(r1)
< 	stw	r0, 8(r1)
< 	stw	r3, 12(r1)
< 	stw	r4, 16(r1)
< 	stwu	r1, -80(r1)
< 	mr	r30, r1
< 	bcl	20, 31, L4pb
< L4pb:
< 	mflr	r31
< 	mr	r3, r2
< 	addis 	r2, r31, ha16(L - L4pb)
< 	lwz	r2, lo16(L - L4pb)(r2)
< 	addi	r0, r2, 176
< 	mr	r4, r0
< 	bl	fputc
< 	lwz	r1, 0(r1)
< 	lwz	r0, 8(r1)
< 	lwz	r3, 12(r1)
< 	lwz	r4, 16(r1)
< 	mtlr	r0
< 	lmw	r30, -8(r1)
< 	blr
< 	.section __TEXT, __picsymbolstub1, symbol_stubs, pure_instructions, 32
< 	.align 	5
< fputc:
< 	.indirect_symbol _fputc
< 	mflr	r0
< 	bcl	20, 31, L4spb
< L4spb:
< 	mflr	r11
< 	addis	r11, r11, ha16(fputc_lazy - L4spb)
< 	mtlr	r0
< 	lwzu	r12, lo16(fputc_lazy - L4spb)(r11)
< 	mtctr	r12
< 	bctr
< 	.lazy_symbol_pointer
< fputc_lazy:
< 	.indirect_symbol _fputc
< 	.long	dyld_stub_binding_helper
< 	.subsections_via_symbols	
< #	prerr_float
< 	.text
< 	.align 	2
< 	.globl 	min_caml_prerr_float
---
> 	pushl	%ebp
> 	movl	%esp, %ebp
> 	ALIGNSTACK2
> 	pushl	U(min_caml_stderr)
> 	pushl	%eax
> 	call	U(fputc)
> 	movl	%ebp, %esp
> 	popl	%ebp
> 	ret
> .globl min_caml_prerr_float
222,261c74,85
< 	mflr 	r0
< 	stmw 	r29, -12(r1)
< 	stw 	r0, 8(r1)
< 	stw	r3, 12(r1)
< 	stw	r4, 16(r1)
< 	stwu 	r1, -96(r1)
< 	mr 	r30, r1
< 	bcl 	20, 31, L5pb
< L5pb:
< 	mflr 	r31
< 	addis 	r2, r31, ha16(L - L5pb)
< 	lwz 	r2, lo16(L - L5pb)(r2)
< 	addi 	r29, r2, 176
< 	stfd 	f0, 64(r30)
< 	lwz 	r2, 64(r30)
< 	lwz 	r3, 68(r30)
< 	mr 	r10, r3
< 	mr 	r9, r2
< 	stw 	r2, 64(r30)
< 	stw 	r3, 68(r30)
< 	lfd 	f13, 64(r30)
< #	fmr 	f0, f13
< 	mr 	r3, r29
< 	addis 	r2, r31, ha16(LC1 - L5pb)
< 	la 	r4, lo16(LC1 - L5pb)(r2)
< 	mr 	r5, r9
< 	mr 	r6, r10
< 	fmr 	f1, f0
< 	bl 	fprintf
< 	lwz 	r1, 0(r1)
< 	lwz 	r0, 8(r1)
< 	lwz	r3, 12(r1)
< 	lwz	r4, 16(r1)
< 	mtlr 	r0
< 	lmw 	r29, -12(r1)
< 	blr	
< #	read_int
< 	.text
< 	.align 	2
< 	.globl	min_caml_read_int
---
> 	pushl	%ebp
> 	movl	%esp, %ebp
> 	ALIGNSTACK0
> 	subl	$8, %esp
> 	movsd	%xmm0, (%esp)
> 	pushl	$format_float
> 	pushl	U(min_caml_stderr)
> 	call	U(fprintf)
> 	movl	%ebp, %esp
> 	popl	%ebp
> 	ret
> .globl min_caml_read_int
263,336c87,123
< 	mflr 	r0
< 	stmw 	r30, -8(r1)
< 	stw 	r0, 8(r1)
< 	stw	r3, 12(r1)
< 	stw	r4, 16(r1)
< 	stwu 	r1, -96(r1)
< 	mr 	r30, r1
< 	bcl 	20, 31, L6pb
< L6pb:
< 	mflr 	r31
< 	addis 	r2, r31, ha16(LC0 - L6pb)
< 	la 	r3, lo16(LC0 - L6pb)(r2)
< 	addi 	r4, r30, 56
< 	bl 	scanf
< 	lwz 	r2, 56(r30)
< 	lwz 	r1, 0(r1)
< 	lwz 	r0, 8(r1)
< 	lwz	r3, 12(r1)
< 	lwz	r4, 16(r1)
< 	mtlr	r0
< 	lmw 	r30, -8(r1)
< 	blr
< 	.section __TEXT, __picsymbolstub1, symbol_stubs, pure_instructions, 32
< 	.align 	5
< scanf:	
< 	.indirect_symbol _scanf$LDBLStub
< 	mflr 	r0
< 	bcl 	20, 31, L6spb
< L6spb:
< 	mflr 	r11
< 	addis 	r11, r11, ha16(scanf_lazy - L6spb)
< 	mtlr 	r0
< 	lwzu 	r12, lo16(scanf_lazy - L6spb)(r11)
< 	mtctr 	r12
< 	bctr
< 	.lazy_symbol_pointer
< scanf_lazy:	
< 	.indirect_symbol _scanf$LDBLStub
< 	.long	dyld_stub_binding_helper
< 	.subsections_via_symbols
< # 	read_float
< 	.text
< 	.align	2
< 	.globl	min_caml_read_float
< min_caml_read_float:	
< 	mflr 	r0
< 	stmw 	r30, -8(r1)
< 	stw 	r0, 8(r1)
< 	stw	r3, 12(r1)
< 	stw	r4, 16(r1)
< 	stwu 	r1, -112(r1)
< 	mr 	r30, r1
< 	bcl 	20, 31, L7pb
< L7pb:
< 	mflr	r31
< 	addis	r2, r31, ha16(LC1 - L7pb)
< 	la	r3, lo16(LC1 - L7pb)(r2)
< 	addi	r4, r30, 56
< 	bl	scanf
< 	lfd	f0, 56(r30)
< 	lwz	r1, 0(r1)
< 	lwz	r0, 8(r1)
< 	lwz	r3, 12(r1)
< 	lwz	r4, 16(r1)
< 	mtlr	r0
< 	lmw	r30, -8(r1)
< 	blr
< #	create_array
< 	.text
< 	.align	2
< 	.globl	min_caml_create_array
< min_caml_create_array:	
< 	mr	r6, r2
< 	mr	r2, r4
---
> 	pushl	%ebp
> 	movl	%esp, %ebp
> 	ALIGNSTACK3
> 	subl	$4, %esp
> 	leal	-4(%ebp), %eax
> 	pushl	%eax
> 	pushl	$format_int
> 	call	U(scanf)
> 	movl	-4(%ebp), %eax
> 	movl	%ebp, %esp
> 	popl	%ebp
> 	ret
> .globl min_caml_read_float
> min_caml_read_float:
> 	pushl	%ebp
> 	movl	%esp, %ebp
> 	ALIGNSTACK0
> 	subl	$8, %esp
> 	leal	-8(%ebp), %eax
> 	pushl	%eax
> 	pushl	$format_float
> 	call	U(scanf)
> 	movsd	-8(%ebp), %xmm0
> 	movl	%ebp, %esp
> 	popl	%ebp
> 	ret
> .globl min_caml_create_array
> min_caml_create_array:
> 	pushl	%ebp
> 	movl	%esp, %ebp
> 	pushl	%ecx
> 	pushl	%edx
> 	movl	%eax, %ecx
> 	movl	min_caml_hp, %eax
> 	movl	%ecx, %edx
> 	shll	$2, %edx
> 	addl	%edx, min_caml_hp
338,340c125,126
< 	cmpwi	cr7, r6, 0
< 	bne	cr7, create_array_cont
< 	b	create_array_exit
---
> 	cmpl	$0, %ecx
> 	jne	create_array_cont
342c128,132
< 	blr
---
> 	popl	%edx
> 	popl	%ecx
> 	movl	%ebp, %esp
> 	popl	%ebp
> 	ret
344,349c134,137
< 	stw	r5, 0(r4)
< 	subi  	r6, r6, 1
< 	addi	r4, r4, 4
< 	b	create_array_loop
< #	create_float_array
< 	.globl	min_caml_create_float_array
---
> 	decl	%ecx
> 	movl	%ebx, (%eax,%ecx,4)
> 	jmp	create_array_loop
> .globl min_caml_create_float_array
351,352c139,147
< 	mr	r5, r2
< 	mr	r2, r4
---
> 	pushl	%ebp
> 	movl	%esp, %ebp
> 	pushl	%ecx
> 	pushl	%edx
> 	movl	%eax, %ecx
> 	movl	min_caml_hp, %eax
> 	movl	%ecx, %edx
> 	shll	$3, %edx
> 	addl	%edx, min_caml_hp
354,356c149,156
< 	cmpwi	cr7, r5, 0
< 	bne	cr7, create_float_array_cont
< 	blr
---
> 	cmpl	$0, %ecx
> 	jne	create_float_array_cont
> create_float_array_exit:
> 	popl	%edx
> 	popl	%ecx
> 	movl	%ebp, %esp
> 	popl	%ebp
> 	ret
358,362c158,161
< 	stfd	f0, 0(r4)
< 	subi	r5, r5, 1
< 	addi	r4, r4, 8
< 	b	create_float_array_loop
< 	.globl	min_caml_abs_float
---
> 	decl	%ecx
> 	movsd	%xmm0, (%eax,%ecx,8)
> 	jmp	create_float_array_loop
> .globl min_caml_abs_float
364,369c163,174
< 	fabs	f0, f0
< 	blr
< #	sqrt
< 	.text
< 	.align 	2
< 	.globl min_caml_sqrt
---
> 	pushl	%ebp
> 	movl	%esp, %ebp
> 	ALIGNSTACK2
> 	subl	$8, %esp
> 	movsd	%xmm0, (%esp)
> 	call	U(fabs)
> 	fstpl	(%esp)
> 	movsd	(%esp), %xmm0
> 	movl	%ebp, %esp
> 	popl	%ebp
> 	ret
> .globl min_caml_sqrt
371,412c176,178
< 	mflr 	r0
< 	stmw 	r30, -8(r1)
< 	stw 	r0, 8(r1)
< 	stw	r3, 12(r1)
< 	stw	r4, 16(r1)
< 	stwu 	r1, -96(r1)
< 	mr 	r30, r1
< 	bcl 	20, 31, L8pb
< L8pb:
< 	mflr	r31
< 	fmr	f1, f0
< 	bl 	sqrt
< 	fmr	f0, f1
< 	lwz 	r1, 0(r1)
< 	lwz 	r0, 8(r1)
< 	lwz	r3, 12(r1)
< 	lwz	r4, 16(r1)
< 	mtlr 	r0
< 	lmw 	r30, -8(r1)
< 	blr
< 	.section __TEXT, __picsymbolstub1, symbol_stubs, pure_instructions, 32
< 	.align 	5
< sqrt:
< 	.indirect_symbol _sqrt
< 	mflr 	r0
< 	bcl 	20, 31, L8spb
< L8spb:
< 	mflr 	r11
< 	addis 	r11, r11, ha16(sqrt_lazy - L8spb)
< 	mtlr 	r0
< 	lwzu 	r12, lo16(sqrt_lazy - L8spb)(r11)
< 	mtctr 	r12
< 	bctr
< 	.lazy_symbol_pointer
< sqrt_lazy:
< 	.indirect_symbol _sqrt
< 	.long	dyld_stub_binding_helper
< 	.subsections_via_symbols
< # 	floor
< 	.text
< 	.align 	2
< 	.globl 	min_caml_floor
---
> 	sqrtsd	%xmm0, %xmm0
> 	ret
> .globl min_caml_floor
414,454c180,191
< 	mflr 	r0
< 	stmw 	r30, -8(r1)
< 	stw 	r0, 8(r1)
< 	stw	r3, 12(r1)
< 	stw	r4, 16(r1)
< 	stwu 	r1, -80(r1)
< 	mr 	r30, r1
< 	fmr	f1, f0
< 	stfd 	f1, 56(r30)
< 	lfd 	f1, 56(r30)
< 	bl 	floor
< 	fmr 	f0, f1
< 	lwz 	r1, 0(r1)
< 	lwz 	r0, 8(r1)
< 	lwz	r3, 12(r1)
< 	lwz	r4, 16(r1)
< 	mtlr 	r0
< 	lmw 	r30,  -8(r1)
< 	blr	
< 	.section __TEXT, __picsymbolstub1, symbol_stubs, pure_instructions, 32
< 	.align 	5
< floor:
< 	.indirect_symbol _floor
< 	mflr 	r0
< 	bcl 	20, 31, L9spb
< L9spb:
< 	mflr 	r11
< 	addis 	r11, r11, ha16(floor_lazy - L9spb)
< 	mtlr 	r0
< 	lwzu 	r12, lo16(floor_lazy - L9spb)(r11)
< 	mtctr 	r12
< 	bctr
< 	.lazy_symbol_pointer
< floor_lazy:
< 	.indirect_symbol _floor
< 	.long	dyld_stub_binding_helper
< 	.subsections_via_symbols
< # 	int_of_float, truncate
< 	.text
< 	.align	2
< 	.globl	min_caml_int_of_float
---
> 	pushl	%ebp
> 	movl	%esp, %ebp
> 	ALIGNSTACK2
> 	subl	$8, %esp
> 	movsd	%xmm0, (%esp)
> 	call	U(floor)
> 	fstpl	(%esp)
> 	movsd	(%esp), %xmm0
> 	movl	%ebp, %esp
> 	popl	%ebp
> 	ret
> .globl min_caml_int_of_float
456c193
< 	.globl	min_caml_truncate
---
> .globl min_caml_truncate
458,471c195,197
< 	stmw 	r30, -8(r1)
< 	stwu 	r1, -64(r1)
< 	mr 	r30, r1
< 	stfd 	f0, 24(r30)
< 	lfd 	f1, 24(r30)
< 	fctiwz 	f1, f1
< 	stfd 	f1, 32(r30)
< 	lwz 	r31, 36(r30)
< 	mr 	r2, r31
< 	lwz 	r1, 0(r1)
< 	lmw 	r30, -8(r1)
< 	blr
< #	float_of_int
< 	.globl	min_caml_float_of_int
---
> 	cvttsd2si	%xmm0, %eax
> 	ret
> .globl min_caml_float_of_int
473,501c199,201
< 	stmw 	r30, -8(r1)
< 	stw	r3, 8(r1)
< 	stw	r4, 12(r1)
< 	stwu 	r1, -48(r1)
< 	mr 	r30, r1
< 	mflr 	r0
< 	bcl 	20, 31, Lapb
< Lapb:
< 	mflr 	r10
< 	mtlr 	r0
< 	stw 	r2, 72(r30)
< 	lwz 	r0, 72(r30)
< 	lis 	r2, 0x4330
< 	addis 	r9, r10, ha16(LC2 - Lapb)
< 	lfd 	f13, lo16(LC2 - Lapb)(r9)
< 	xoris 	r0, r0, 0x8000
< 	stw 	r0, 28(r30)
< 	stw 	r2, 24(r30)
< 	lfd 	f0, 24(r30)
< 	fsub 	f0, f0, f13
< 	lwz 	r1, 0(r1)
< 	lwz	r3, 8(r1)
< 	lwz	r4, 12(r1)
< 	lmw 	r30, -8(r1)
< 	blr
< #	cos
< 	.text
< 	.align 	2
< 	.globl min_caml_cos
---
> 	cvtsi2sd	%eax, %xmm0
> 	ret
> .globl min_caml_cos
503,544c203,214
< 	mflr 	r0
< 	stmw 	r30, -8(r1)
< 	stw 	r0, 8(r1)
< 	stw	r3, 12(r1)
< 	stw	r4, 16(r1)
< 	stwu 	r1, -96(r1)
< 	mr 	r30, r1
< 	bcl 	20, 31, Lbpb
< Lbpb:
< 	mflr 	r31
< 	fmr	f1, f0
< 	bl 	cos
< 	fmr 	f0, f1
< 	lwz 	r1, 0(r1)
< 	lwz 	r0, 8(r1)
< 	lwz	r3, 12(r1)
< 	lwz	r4, 16(r1)
< 	mtlr 	r0
< 	lmw 	r30, -8(r1)
< 	blr
< 	.section __TEXT, __picsymbolstub1, symbol_stubs, pure_instructions, 32
< 	.align 	5
< cos:
< 	.indirect_symbol _cos
< 	mflr 	r0
< 	bcl 	20, 31, Lbspb
< Lbspb:
< 	mflr 	r11
< 	addis 	r11, r11, ha16(cos_lazy - Lbspb)
< 	mtlr 	r0
< 	lwzu 	r12,lo16(cos_lazy - Lbspb)(r11)
< 	mtctr 	r12
< 	bctr
< 	.lazy_symbol_pointer
< cos_lazy:
< 	.indirect_symbol _cos
< 	.long	dyld_stub_binding_helper
< 	.subsections_via_symbols
< #	sin
< 	.text
< 	.align 	2
< 	.globl 	min_caml_sin
---
> 	pushl	%ebp
> 	movl	%esp, %ebp
> 	ALIGNSTACK2
> 	subl	$8, %esp
> 	movsd	%xmm0, (%esp)
> 	call	U(cos)
> 	fstpl	(%esp)
> 	movsd	(%esp), %xmm0
> 	movl	%ebp, %esp
> 	popl	%ebp
> 	ret
> .globl min_caml_sin
546,587c216,227
< 	mflr 	r0
< 	stmw 	r30, -8(r1)
< 	stw 	r0, 8(r1)
< 	stw	r3, 12(r1)
< 	stw	r4, 16(r1)
< 	stwu 	r1, -96(r1)
< 	mr 	r30, r1
< 	bcl 	20, 31, Lcpb
< Lcpb:	
< 	mflr 	r31
< 	fmr	f1, f0
< 	bl 	sin
< 	fmr 	f0, f1
< 	lwz 	r1, 0(r1)
< 	lwz 	r0, 8(r1)
< 	lwz	r3, 12(r1)
< 	lwz	r4, 16(r1)
< 	mtlr 	r0
< 	lmw 	r30, -8(r1)
< 	blr
< 	.section __TEXT, __picsymbolstub1, symbol_stubs, pure_instructions, 32
< 	.align 	5
< sin:	
< 	.indirect_symbol _sin
< 	mflr 	r0
< 	bcl 	20, 31, Lcspb
< Lcspb:	
< 	mflr 	r11
< 	addis 	r11, r11, ha16(sin_lazy - Lcspb)
< 	mtlr 	r0
< 	lwzu 	r12, lo16(sin_lazy - Lcspb)(r11)
< 	mtctr 	r12
< 	bctr
< 	.lazy_symbol_pointer
< sin_lazy:	
< 	.indirect_symbol _sin
< 	.long	dyld_stub_binding_helper
< 	.subsections_via_symbols
< #	atan
< 	.text
< 	.align 	2
< 	.globl min_caml_atan
---
> 	pushl	%ebp
> 	movl	%esp, %ebp
> 	ALIGNSTACK2
> 	subl	$8, %esp
> 	movsd	%xmm0, (%esp)
> 	call	U(sin)
> 	fstpl	(%esp)
> 	movsd	(%esp), %xmm0
> 	movl	%ebp, %esp
> 	popl	%ebp
> 	ret
> .globl min_caml_atan
589,628c229,245
< 	mflr 	r0
< 	stmw 	r30, -8(r1)
< 	stw 	r0, 8(r1)
< 	stw	r3, 12(r1)
< 	stw	r4, 16(r1)
< 	stwu 	r1, -96(r1)
< 	mr 	r30, r1
< 	bcl 	20, 31, Ldpb
< Ldpb:
< 	mflr 	r31
< 	fmr	f1, f0
< 	bl 	atan
< 	fmr 	f0, f1
< 	lwz 	r1, 0(r1)
< 	lwz 	r0, 8(r1)
< 	lwz	r3, 12(r1)
< 	lwz	r4, 16(r1)
< 	mtlr 	r0
< 	lmw 	r30, -8(r1)
< 	blr
< 	.section __TEXT, __picsymbolstub1, symbol_stubs, pure_instructions, 32
< 	.align 	5
< atan:
< 	.indirect_symbol _atan
< 	mflr 	r0
< 	bcl 	20, 31, Ldspb
< Ldspb:
< 	mflr 	r11
< 	addis 	r11, r11, ha16(atan_lazy - Ldspb)
< 	mtlr 	r0
< 	lwzu 	r12, lo16(atan_lazy - Ldspb)(r11)
< 	mtctr 	r12
< 	bctr
< 	.lazy_symbol_pointer
< atan_lazy:
< 	.indirect_symbol _atan
< 	.long	dyld_stub_binding_helper
< 	.subsections_via_symbols
< 	.const
< 	.align	8
---
> 	pushl	%ebp
> 	movl	%esp, %ebp
> 	ALIGNSTACK2
> 	subl	$8, %esp
> 	movsd	%xmm0, (%esp)
> 	call	U(atan)
> 	fstpl	(%esp)
> 	movsd	(%esp), %xmm0
> 	movl	%ebp, %esp
> 	popl	%ebp
> 	ret
> .data
> format_int:
> 	.asciz	"%d"
> format_float:
> 	.asciz	"%lf"
> .balign 8
632a250
> 	.long	0x0
633a252,260
> .balign 16
> .globl min_caml_fnegd
> min_caml_fnegd:
> 	.long	0
> 	.long	0x80000000
> 	.long	0
> 	.long	0
> .globl min_caml_hp
> min_caml_hp:	
635,636d261
< 	
< 	
Common subdirectories: min-caml-ppc/min-rt and min-caml-x86/min-rt
diff min-caml-ppc/regAlloc.ml min-caml-x86/regAlloc.ml
7c7
<   | Mr(x) when x = src && is_reg dest ->
---
>   | Mov(x) when x = src && is_reg dest ->
11c11
<   | FMr(x) when x = src && is_reg dest ->
---
>   | FMovD(x) when x = src && is_reg dest ->
36c36,37
<   | y :: ys when src = y -> all.(n) :: target_args src all (n + 1) ys
---
>   | y :: ys when src = y (* && n <= List.length all - 2 *) ->
>       all.(n) :: target_args src all (n + 1) ys
37a39,50
> (* "register sourcing" (?) as opposed to register targeting *)
> (* （x86の2オペランド命令のためのregister coalescing） *)
> let rec source t = function
>   | Ans(exp) -> source' t exp
>   | Let(_, _, e) -> source t e
> and source' t = function
>   | Mov(x) | Neg(x) | Add(x, C _) | Sub(x, _) | FMovD(x) | FNegD(x) | FSubD(x, _) | FDivD(x, _) -> [x]
>   | Add(x, V y) | FAddD(x, y) | FMulD(x, y) -> [x; y]
>   | IfEq(_, _, e1, e2) | IfLE(_, _, e1, e2) | IfGE(_, _, e1, e2) | IfFEq(_, _, e1, e2) | IfFLE(_, _, e1, e2) ->
>       source t e1 @ source t e2
>   | CallCls _ | CallDir _ -> (match t with Type.Unit -> [] | Type.Float -> [fregs.(0)] | _ -> [regs.(0)])
>   | _ -> []
42c55
< let rec alloc dest cont regenv x t =
---
> let rec alloc cont regenv x t prefer =
47c60
<     | Type.Unit -> ["%r0"] (* dummy *)
---
>     | Type.Unit -> [] (* dummy *)
50c63
<   if all = ["%r0"] then Alloc("%r0") else (* [XX] ad hoc optimization *)
---
>   if all = [] then Alloc("%unit") else (* [XX] ad hoc *)
54d66
<     let (c, prefer) = target x dest cont in
103c115,118
<       (match alloc dest cont' regenv1 x t with
---
>       let (_call, targets) = target x dest cont' in
>       let sources = source t e1' in
>       (* レジスタ間のmovよりメモリを介するswapのほうが問題なので、sourcesよりtargetsを優先 *)
>       (match alloc cont' regenv1 x t (targets @ sources) with
109c124
<             with Not_found -> Nop in
---
>             with Not_found -> Nop in            
120,121c135,136
<   | Nop | Li _ | SetL _ | Comment _ | Restore _ | FLi _ as exp -> (Ans(exp), regenv)
<   | Mr(x) -> (Ans(Mr(find x Type.Int regenv)), regenv)
---
>   | Nop | Set _ | SetL _ | Comment _ | Restore _ as exp -> (Ans(exp), regenv)
>   | Mov(x) -> (Ans(Mov(find x Type.Int regenv)), regenv)
125,135c140,149
<   | Slw(x, y') -> (Ans(Slw(find x Type.Int regenv, find' y' regenv)), regenv)
<   | Lwz(x, y') -> (Ans(Lwz(find x Type.Int regenv, find' y' regenv)), regenv)
<   | Stw(x, y, z') -> (Ans(Stw(find x Type.Int regenv, find y Type.Int regenv, find' z' regenv)), regenv)
<   | FMr(x) -> (Ans(FMr(find x Type.Float regenv)), regenv)
<   | FNeg(x) -> (Ans(FNeg(find x Type.Float regenv)), regenv)
<   | FAdd(x, y) -> (Ans(FAdd(find x Type.Float regenv, find y Type.Float regenv)), regenv)
<   | FSub(x, y) -> (Ans(FSub(find x Type.Float regenv, find y Type.Float regenv)), regenv)
<   | FMul(x, y) -> (Ans(FMul(find x Type.Float regenv, find y Type.Float regenv)), regenv)
<   | FDiv(x, y) -> (Ans(FDiv(find x Type.Float regenv, find y Type.Float regenv)), regenv)
<   | Lfd(x, y') -> (Ans(Lfd(find x Type.Int regenv, find' y' regenv)), regenv)
<   | Stfd(x, y, z') -> (Ans(Stfd(find x Type.Float regenv, find y Type.Int regenv, find' z' regenv)), regenv)
---
>   | Ld(x, y', i) -> (Ans(Ld(find x Type.Int regenv, find' y' regenv, i)), regenv)
>   | St(x, y, z', i) -> (Ans(St(find x Type.Int regenv, find y Type.Int regenv, find' z' regenv, i)), regenv)
>   | FMovD(x) -> (Ans(FMovD(find x Type.Float regenv)), regenv)
>   | FNegD(x) -> (Ans(FNegD(find x Type.Float regenv)), regenv)
>   | FAddD(x, y) -> (Ans(FAddD(find x Type.Float regenv, find y Type.Float regenv)), regenv)
>   | FSubD(x, y) -> (Ans(FSubD(find x Type.Float regenv, find y Type.Float regenv)), regenv)
>   | FMulD(x, y) -> (Ans(FMulD(find x Type.Float regenv, find y Type.Float regenv)), regenv)
>   | FDivD(x, y) -> (Ans(FDivD(find x Type.Float regenv, find y Type.Float regenv)), regenv)
>   | LdDF(x, y', i) -> (Ans(LdDF(find x Type.Int regenv, find' y' regenv, i)), regenv)
>   | StDF(x, y, z', i) -> (Ans(StDF(find x Type.Float regenv, find y Type.Int regenv, find' z' regenv, i)), regenv)
142c156
<       if List.length ys > Array.length regs - 2 || List.length zs > Array.length fregs - 1 then
---
>       if List.length ys > Array.length regs - 1 || List.length zs > Array.length fregs then
147c161
<       if List.length ys > Array.length regs - 1 || List.length zs > Array.length fregs - 1 then
---
>       if List.length ys > Array.length regs || List.length zs > Array.length fregs then
185a200,201
>   if List.length ys > Array.length regs || List.length zs > Array.length fregs then
>     Format.eprintf "too many arguments for function %s@." x;
212c228
<   let (e', regenv') = g (a, t) (Ans(Mr(a))) regenv e in
---
>   let (e', regenv') = g (a, t) (Ans(Mov(a))) regenv e in
Common subdirectories: min-caml-ppc/shootout and min-caml-x86/shootout
diff min-caml-ppc/simm.ml min-caml-x86/simm.ml
3c3
< let rec g env = function (* 命令列の16bit即値最適化 (caml2html: simm13_g) *)
---
> let rec g env = function (* 命令列の即値最適化 (caml2html: simm13_g) *)
5,6c5,6
<   | Let((x, t), Li(i), e) when -32768 <= i && i < 32768 ->
<       (* Format.eprintf "found simm16 %s = %d@." x i; *)
---
>   | Let((x, t), Set(i), e) ->
>       (* Format.eprintf "found simm %s = %d@." x i; *)
8c8
<       if List.mem x (fv e') then Let((x, t), Li(i), e') else
---
>       if List.mem x (fv e') then Let((x, t), Set(i), e') else
11,13d10
<   | Let(xt, Slw(y, C(i)), e) when M.mem y env -> (* for array access *)
<       (* Format.eprintf "erased redundant Slw on %s@." x; *)
<       g env (Let(xt, Li((M.find y env) lsl i), e))
15c12
< and g' env = function (* 各命令の16bit即値最適化 (caml2html: simm13_gprime) *)
---
> and g' env = function (* 各命令の即値最適化 (caml2html: simm13_gprime) *)
19,23c16,19
<   | Slw(x, V(y)) when M.mem y env -> Slw(x, C(M.find y env))
<   | Lwz(x, V(y)) when M.mem y env -> Lwz(x, C(M.find y env))
<   | Stw(x, y, V(z)) when M.mem z env -> Stw(x, y, C(M.find z env))
<   | Lfd(x, V(y)) when M.mem y env -> Lfd(x, C(M.find y env))
<   | Stfd(x, y, V(z)) when M.mem z env -> Stfd(x, y, C(M.find z env))
---
>   | Ld(x, V(y), i) when M.mem y env -> Ld(x, C(M.find y env), i)
>   | St(x, y, V(z), i) when M.mem z env -> St(x, y, C(M.find z env), i)
>   | LdDF(x, V(y), i) when M.mem y env -> LdDF(x, C(M.find y env), i)
>   | StDF(x, y, V(z), i) when M.mem z env -> StDF(x, y, C(M.find z env), i)
37c33
< let h { name = l; args = xs; fargs = ys; body = e; ret = t } = (* トップレベル関数の16bit即値最適化 *)
---
> let h { name = l; args = xs; fargs = ys; body = e; ret = t } = (* トップレベル関数の即値最適化 *)
40c36
< let f (Prog(data, fundefs, e)) = (* プログラム全体の16bit即値最適化 *)
---
> let f (Prog(data, fundefs, e)) = (* プログラム全体の即値最適化 *)
Common subdirectories: min-caml-ppc/test and min-caml-x86/test
diff min-caml-ppc/virtual.ml min-caml-x86/virtual.ml
1c1
< (* translation into PowerPC assembly with infinite number of virtual registers *)
---
> (* translation into assembly with infinite number of virtual registers *)
36c36
<   | Closure.Int(i) -> Ans(Li(i))
---
>   | Closure.Int(i) -> Ans(Set(i))
47c47,48
<       Ans(FLi(l))
---
>       let x = Id.genid "l" in
>       Let((x, Type.Int), SetL(l), Ans(LdDF(x, C(0), 1)))
51,55c52,56
<   | Closure.FNeg(x) -> Ans(FNeg(x))
<   | Closure.FAdd(x, y) -> Ans(FAdd(x, y))
<   | Closure.FSub(x, y) -> Ans(FSub(x, y))
<   | Closure.FMul(x, y) -> Ans(FMul(x, y))
<   | Closure.FDiv(x, y) -> Ans(FDiv(x, y))
---
>   | Closure.FNeg(x) -> Ans(FNegD(x))
>   | Closure.FAdd(x, y) -> Ans(FAddD(x, y))
>   | Closure.FSub(x, y) -> Ans(FSubD(x, y))
>   | Closure.FMul(x, y) -> Ans(FMulD(x, y))
>   | Closure.FDiv(x, y) -> Ans(FDivD(x, y))
73,74c74,75
<       | Type.Float -> Ans(FMr(x))
<       | _ -> Ans(Mr(x)))
---
>       | Type.Float -> Ans(FMovD(x))
>       | _ -> Ans(Mov(x)))
82,84c83,85
<           (fun y offset store_fv -> seq(Stfd(y, x, C(offset)), store_fv))
<           (fun y _ offset store_fv -> seq(Stw(y, x, C(offset)), store_fv)) in
<       Let((x, t), Mr(reg_hp),
---
>           (fun y offset store_fv -> seq(StDF(y, x, C(offset), 1), store_fv))
>           (fun y _ offset store_fv -> seq(St(y, x, C(offset), 1), store_fv)) in
>       Let((x, t), Mov(reg_hp),
88c89
<                   seq(Stw(z, x, C(0)),
---
>                   seq(St(z, x, C(0), 1),
101,104c102,105
<           (0, Ans(Mr(y)))
<           (fun x offset store -> seq(Stfd(x, y, C(offset)), store))
<           (fun x _ offset store -> seq(Stw(x, y, C(offset)), store))  in
<       Let((y, Type.Tuple(List.map (fun x -> M.find x env) xs)), Mr(reg_hp),
---
>           (0, Ans(Mov(y)))
>           (fun x offset store -> seq(StDF(x, y, C(offset), 1), store))
>           (fun x _ offset store -> seq(St(x, y, C(offset), 1), store)) in
>       Let((y, Type.Tuple(List.map (fun x -> M.find x env) xs)), Mov(reg_hp),
115c116
<             fletd(x, Lfd(y, C(offset)), load))
---
>             fletd(x, LdDF(y, C(offset), 1), load))
118c119
<             Let((x, t), Lwz(y, C(offset)), load)) in
---
>             Let((x, t), Ld(y, C(offset), 1), load)) in
121d121
<       let offset = Id.genid "o" in
124,129c124,125
<       | Type.Array(Type.Float) ->
<           Let((offset, Type.Int), Slw(y, C(3)),
<               Ans(Lfd(x, V(offset))))
<       | Type.Array(_) ->
<           Let((offset, Type.Int), Slw(y, C(2)),
<               Ans(Lwz(x, V(offset))))
---
>       | Type.Array(Type.Float) -> Ans(LdDF(x, V(y), 8))
>       | Type.Array(_) -> Ans(Ld(x, V(y), 4))
132d127
<       let offset = Id.genid "o" in
135,140c130,131
<       | Type.Array(Type.Float) ->
<           Let((offset, Type.Int), Slw(y, C(3)),
<               Ans(Stfd(z, x, V(offset))))
<       | Type.Array(_) ->
<           Let((offset, Type.Int), Slw(y, C(2)),
<               Ans(Stw(z, x, V(offset))))
---
>       | Type.Array(Type.Float) -> Ans(StDF(z, x, V(y), 8))
>       | Type.Array(_) -> Ans(St(z, x, V(y), 4))
151,152c142,143
<       (fun z offset load -> fletd(z, Lfd(x, C(offset)), load))
<       (fun z t offset load -> Let((z, t), Lwz(x, C(offset)), load)) in
---
>       (fun z offset load -> fletd(z, LdDF(x, C(offset), 1), load))
>       (fun z t offset load -> Let((z, t), Ld(x, C(offset), 1), load)) in
Common subdirectories: min-caml-ppc/x86 and min-caml-x86/x86