-
-
Save thata/17a6ce3d8e89d42d55786d5ebdebb419 to your computer and use it in GitHub Desktop.
diff min-caml-ppc min-caml-sparc
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| Common subdirectories: min-caml-ppc/.git and min-caml-sparc/.git | |
| Common subdirectories: min-caml-ppc/PowerPC and min-caml-sparc/PowerPC | |
| Common subdirectories: min-caml-ppc/SPARC and min-caml-sparc/SPARC | |
| diff min-caml-ppc/asm.ml min-caml-sparc/asm.ml | |
| 1c1 | |
| < (* PowerPC assembly with a few virtual instructions *) | |
| --- | |
| > (* SPARC assembly with a few virtual instructions *) | |
| 9,10c9 | |
| < | Li of int | |
| < | FLi of Id.l | |
| --- | |
| > | Set of int | |
| 12c11 | |
| < | Mr of Id.t | |
| --- | |
| > | Mov of Id.t | |
| 16,26c15,25 | |
| < | 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 | |
| --- | |
| > | SLL of Id.t * id_or_imm | |
| > | Ld of Id.t * id_or_imm | |
| > | St of Id.t * Id.t * id_or_imm | |
| > | 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 | |
| > | StDF of Id.t * Id.t * id_or_imm | |
| 46,51c45,49 | |
| < 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) *) | |
| > [| "%i2"; "%i3"; "%i4"; "%i5"; | |
| > "%l0"; "%l1"; "%l2"; "%l3"; "%l4"; "%l5"; "%l6"; "%l7"; | |
| > "%o0"; "%o1"; "%o2"; "%o3"; "%o4"; "%o5" |] | |
| > let fregs = Array.init 16 (fun i -> Printf.sprintf "%%f%d" (i * 2)) | |
| 54,55c52,53 | |
| < let reg_cl = regs.(Array.length regs - 1) (* closure address (caml2html: sparcasm_regcl) *) | |
| < let reg_sw = regs.(Array.length regs - 2) (* temporary for swap *) | |
| --- | |
| > let reg_cl = regs.(Array.length regs - 2) (* closure address (caml2html: sparcasm_regcl) *) | |
| > let reg_sw = regs.(Array.length regs - 1) (* temporary for swap *) | |
| 57,59c55,57 | |
| < let reg_sp = "%r3" (* stack pointer *) | |
| < let reg_hp = "%r4" (* heap pointer (caml2html: sparcasm_reghp) *) | |
| < let reg_tmp = "%r31" (* [XX] ad hoc *) | |
| --- | |
| > let reg_sp = "%i0" (* stack pointer *) | |
| > let reg_hp = "%i1" (* heap pointer (caml2html: sparcasm_reghp) *) | |
| > let reg_ra = "%o7" (* return address *) | |
| 60a59,68 | |
| > let co_freg_table = | |
| > let ht = Hashtbl.create 16 in | |
| > for i = 0 to 15 do | |
| > Hashtbl.add | |
| > ht | |
| > (Printf.sprintf "%%f%d" (i * 2)) | |
| > (Printf.sprintf "%%f%d" (i * 2 + 1)) | |
| > done; | |
| > ht | |
| > let co_freg freg = Hashtbl.find co_freg_table freg (* "companion" freg *) | |
| 71,76c79,84 | |
| < | 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') | SLL(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-sparc/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,23 | |
| < | 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 | |
| --- | |
| > | SLL of Id.t * id_or_imm | |
| > | Ld of Id.t * id_or_imm | |
| > | St of Id.t * Id.t * id_or_imm | |
| > | 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 | |
| > | StDF of Id.t * Id.t * id_or_imm | |
| 49a49 | |
| > val reg_ra : Id.t | |
| 52d51 | |
| < val reg_tmp : Id.t | |
| 53a53 | |
| > val co_freg : Id.t -> Id.t | |
| Common subdirectories: min-caml-ppc/bytemark and min-caml-sparc/bytemark | |
| diff min-caml-ppc/emit.ml min-caml-sparc/emit.ml | |
| 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,78 | |
| < | 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 "\tset\t%d, %s\n" i x | |
| > | NonTail(x), SetL(Id.L(y)) -> Printf.fprintf oc "\tset\t%s, %s\n" y x | |
| > | NonTail(x), Mov(y) when x = y -> () | |
| > | NonTail(x), Mov(y) -> Printf.fprintf oc "\tmov\t%s, %s\n" y x | |
| > | NonTail(x), Neg(y) -> Printf.fprintf oc "\tneg\t%s, %s\n" y x | |
| > | NonTail(x), Add(y, z') -> Printf.fprintf oc "\tadd\t%s, %s, %s\n" y (pp_id_or_imm z') x | |
| > | NonTail(x), Sub(y, z') -> Printf.fprintf oc "\tsub\t%s, %s, %s\n" y (pp_id_or_imm z') x | |
| > | NonTail(x), SLL(y, z') -> Printf.fprintf oc "\tsll\t%s, %s, %s\n" y (pp_id_or_imm z') x | |
| > | NonTail(x), Ld(y, z') -> Printf.fprintf oc "\tld\t[%s + %s], %s\n" y (pp_id_or_imm z') x | |
| > | NonTail(_), St(x, y, z') -> Printf.fprintf oc "\tst\t%s, [%s + %s]\n" x y (pp_id_or_imm z') | |
| > | NonTail(x), FMovD(y) when x = y -> () | |
| > | NonTail(x), FMovD(y) -> | |
| > Printf.fprintf oc "\tfmovs\t%s, %s\n" y x; | |
| > Printf.fprintf oc "\tfmovs\t%s, %s\n" (co_freg y) (co_freg x) | |
| > | NonTail(x), FNegD(y) -> | |
| > Printf.fprintf oc "\tfnegs\t%s, %s\n" y x; | |
| > if x <> y then Printf.fprintf oc "\tfmovs\t%s, %s\n" (co_freg y) (co_freg x) | |
| > | NonTail(x), FAddD(y, z) -> Printf.fprintf oc "\tfaddd\t%s, %s, %s\n" y z x | |
| > | NonTail(x), FSubD(y, z) -> Printf.fprintf oc "\tfsubd\t%s, %s, %s\n" y z x | |
| > | NonTail(x), FMulD(y, z) -> Printf.fprintf oc "\tfmuld\t%s, %s, %s\n" y z x | |
| > | NonTail(x), FDivD(y, z) -> Printf.fprintf oc "\tfdivd\t%s, %s, %s\n" y z x | |
| > | NonTail(x), LdDF(y, z') -> Printf.fprintf oc "\tldd\t[%s + %s], %s\n" y (pp_id_or_imm z') x | |
| > | NonTail(_), StDF(x, y, z') -> Printf.fprintf oc "\tstd\t%s, [%s + %s]\n" x y (pp_id_or_imm z') | |
| > | NonTail(_), Comment(s) -> Printf.fprintf oc "\t! %s\n" s | |
| 103c82 | |
| < Printf.fprintf oc "\tstw\t%s, %d(%s)\n" (reg x) (offset y) (reg reg_sp) | |
| --- | |
| > Printf.fprintf oc "\tst\t%s, [%s + %d]\n" x reg_sp (offset y) | |
| 106c85 | |
| < Printf.fprintf oc "\tstfd\t%s, %d(%s)\n" (reg x) (offset y) (reg reg_sp) | |
| --- | |
| > Printf.fprintf oc "\tstd\t%s, [%s + %d]\n" x reg_sp (offset y) | |
| 110c89 | |
| < Printf.fprintf oc "\tlwz\t%s, %d(%s)\n" (reg x) (offset y) (reg reg_sp) | |
| --- | |
| > Printf.fprintf oc "\tld\t[%s + %d], %s\n" reg_sp (offset y) x | |
| 113c92 | |
| < Printf.fprintf oc "\tlfd\t%s, %d(%s)\n" (reg x) (offset y) (reg reg_sp) | |
| --- | |
| > Printf.fprintf oc "\tldd\t[%s + %d], %s\n" reg_sp (offset y) x | |
| 115c94 | |
| < | Tail, (Nop | Stw _ | Stfd _ | Comment _ | Save _ as exp) -> | |
| --- | |
| > | Tail, (Nop | St _ | StDF _ | Comment _ | Save _ as exp) -> | |
| 117,118c96,98 | |
| < Printf.fprintf oc "\tblr\n"; | |
| < | Tail, (Li _ | SetL _ | Mr _ | Neg _ | Add _ | Sub _ | Slw _ | Lwz _ as exp) -> | |
| --- | |
| > Printf.fprintf oc "\tretl\n"; | |
| > Printf.fprintf oc "\tnop\n" | |
| > | Tail, (Set _ | SetL _ | Mov _ | Neg _ | Add _ | Sub _ | SLL _ | Ld _ as exp) -> | |
| 120,121c100,102 | |
| < Printf.fprintf oc "\tblr\n"; | |
| < | Tail, (FLi _ | FMr _ | FNeg _ | FAdd _ | FSub _ | FMul _ | FDiv _ | Lfd _ as exp) -> | |
| --- | |
| > Printf.fprintf oc "\tretl\n"; | |
| > Printf.fprintf oc "\tnop\n" | |
| > | Tail, (FMovD _ | FNegD _ | FAddD _ | FSubD _ | FMulD _ | FDivD _ | LdDF _ as exp) -> | |
| 123c104,105 | |
| < Printf.fprintf oc "\tblr\n"; | |
| --- | |
| > Printf.fprintf oc "\tretl\n"; | |
| > Printf.fprintf oc "\tnop\n" | |
| 129,147c111,121 | |
| < 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 "\tretl\n"; | |
| > Printf.fprintf oc "\tnop\n" | |
| > | Tail, IfEq(x, y', e1, e2) -> | |
| > Printf.fprintf oc "\tcmp\t%s, %s\n" x (pp_id_or_imm y'); | |
| > g'_tail_if oc e1 e2 "be" "bne" | |
| > | Tail, IfLE(x, y', e1, e2) -> | |
| > Printf.fprintf oc "\tcmp\t%s, %s\n" x (pp_id_or_imm y'); | |
| > g'_tail_if oc e1 e2 "ble" "bg" | |
| > | Tail, IfGE(x, y', e1, e2) -> | |
| > Printf.fprintf oc "\tcmp\t%s, %s\n" x (pp_id_or_imm y'); | |
| > g'_tail_if oc e1 e2 "bge" "bl" | |
| 149,150c123,125 | |
| < Printf.fprintf oc "\tfcmpu\tcr7, %s, %s\n" (reg x) (reg y); | |
| < g'_tail_if oc e1 e2 "beq" "bne" | |
| --- | |
| > Printf.fprintf oc "\tfcmpd\t%s, %s\n" x y; | |
| > Printf.fprintf oc "\tnop\n"; | |
| > g'_tail_if oc e1 e2 "fbe" "fbne" | |
| 152,171c127,138 | |
| < 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 "\tfcmpd\t%s, %s\n" x y; | |
| > Printf.fprintf oc "\tnop\n"; | |
| > g'_tail_if oc e1 e2 "fble" "fbg" | |
| > | NonTail(z), IfEq(x, y', e1, e2) -> | |
| > Printf.fprintf oc "\tcmp\t%s, %s\n" x (pp_id_or_imm y'); | |
| > g'_non_tail_if oc (NonTail(z)) e1 e2 "be" "bne" | |
| > | NonTail(z), IfLE(x, y', e1, e2) -> | |
| > Printf.fprintf oc "\tcmp\t%s, %s\n" x (pp_id_or_imm y'); | |
| > g'_non_tail_if oc (NonTail(z)) e1 e2 "ble" "bg" | |
| > | NonTail(z), IfGE(x, y', e1, e2) -> | |
| > Printf.fprintf oc "\tcmp\t%s, %s\n" x (pp_id_or_imm y'); | |
| > g'_non_tail_if oc (NonTail(z)) e1 e2 "bge" "bl" | |
| 173,174c140,142 | |
| < 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 "\tfcmpd\t%s, %s\n" x y; | |
| > Printf.fprintf oc "\tnop\n"; | |
| > g'_non_tail_if oc (NonTail(z)) e1 e2 "fbe" "fbne" | |
| 176,177c144,146 | |
| < 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 "\tfcmpd\t%s, %s\n" x y; | |
| > Printf.fprintf oc "\tnop\n"; | |
| > g'_non_tail_if oc (NonTail(z)) e1 e2 "fble" "fbg" | |
| 181,182c150,152 | |
| < 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 "\tld\t[%s + 0], %s\n" reg_cl reg_sw; | |
| > Printf.fprintf oc "\tjmp\t%s\n" reg_sw; | |
| > Printf.fprintf oc "\tnop\n" | |
| 185c155,156 | |
| < Printf.fprintf oc "\tb\t%s\n" x | |
| --- | |
| > Printf.fprintf oc "\tb\t%s\n" x; | |
| > Printf.fprintf oc "\tnop\n" | |
| 187d157 | |
| < Printf.fprintf oc "\tmflr\t%s\n" (reg reg_tmp); | |
| 190,196c160,165 | |
| < 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); | |
| --- | |
| > Printf.fprintf oc "\tst\t%s, [%s + %d]\n" reg_ra reg_sp (ss - 4); | |
| > Printf.fprintf oc "\tld\t[%s + 0], %s\n" reg_cl reg_sw; | |
| > Printf.fprintf oc "\tcall\t%s\n" reg_sw; | |
| > Printf.fprintf oc "\tadd\t%s, %d, %s\t! delay slot\n" reg_sp ss reg_sp; | |
| > Printf.fprintf oc "\tsub\t%s, %d, %s\n" reg_sp ss reg_sp; | |
| > Printf.fprintf oc "\tld\t[%s + %d], %s\n" reg_sp (ss - 4) reg_ra; | |
| 198c167 | |
| < Printf.fprintf oc "\tmr\t%s, %s\n" (reg a) (reg regs.(0)) | |
| --- | |
| > Printf.fprintf oc "\tmov\t%s, %s\n" regs.(0) a | |
| 200,203c169,171 | |
| < 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 "\tfmovs\t%s, %s\n" fregs.(0) a; | |
| > Printf.fprintf oc "\tfmovs\t%s, %s\n" (co_freg fregs.(0)) (co_freg a)) | |
| > | NonTail(a), CallDir(Id.L(x), ys, zs) -> | |
| 206,210c174,178 | |
| < 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); | |
| --- | |
| > Printf.fprintf oc "\tst\t%s, [%s + %d]\n" reg_ra reg_sp (ss - 4); | |
| > Printf.fprintf oc "\tcall\t%s\n" x; | |
| > Printf.fprintf oc "\tadd\t%s, %d, %s\t! delay slot\n" reg_sp ss reg_sp; | |
| > Printf.fprintf oc "\tsub\t%s, %d, %s\n" reg_sp ss reg_sp; | |
| > Printf.fprintf oc "\tld\t[%s + %d], %s\n" reg_sp (ss - 4) reg_ra; | |
| 212c180 | |
| < Printf.fprintf oc "\tmr\t%s, %s\n" (reg a) (reg regs.(0)) | |
| --- | |
| > Printf.fprintf oc "\tmov\t%s, %s\n" regs.(0) a | |
| 214,215c182,183 | |
| < 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 "\tfmovs\t%s, %s\n" fregs.(0) a; | |
| > Printf.fprintf oc "\tfmovs\t%s, %s\n" (co_freg fregs.(0)) (co_freg a)) | |
| 218c186,187 | |
| < Printf.fprintf oc "\t%s\tcr7, %s\n" bn b_else; | |
| --- | |
| > Printf.fprintf oc "\t%s\t%s\n" bn b_else; | |
| > Printf.fprintf oc "\tnop\n"; | |
| 227c196,197 | |
| < Printf.fprintf oc "\t%s\tcr7, %s\n" bn b_else; | |
| --- | |
| > Printf.fprintf oc "\t%s\t%s\n" bn b_else; | |
| > Printf.fprintf oc "\tnop\n"; | |
| 231a202 | |
| > Printf.fprintf oc "\tnop\n"; | |
| 245c216 | |
| < (fun (y, r) -> Printf.fprintf oc "\tmr\t%s, %s\n" (reg r) (reg y)) | |
| --- | |
| > (fun (y, r) -> Printf.fprintf oc "\tmov\t%s, %s\n" y r) | |
| 253c224,226 | |
| < (fun (z, fr) -> Printf.fprintf oc "\tfmr\t%s, %s\n" (reg fr) (reg z)) | |
| --- | |
| > (fun (z, fr) -> | |
| > Printf.fprintf oc "\tfmovs\t%s, %s\n" z fr; | |
| > Printf.fprintf oc "\tfmovs\t%s, %s\n" (co_freg z) (co_freg fr)) | |
| 264,275c237,245 | |
| < 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 ".section\t\".rodata\"\n"; | |
| > Printf.fprintf oc ".align\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 ".section\t\".text\"\n"; | |
| 277,282c247,249 | |
| < 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 ".global\tmin_caml_start\n"; | |
| > Printf.fprintf oc "min_caml_start:\n"; | |
| > Printf.fprintf oc "\tsave\t%%sp, -112, %%sp\n"; (* from gcc; why 112? *) | |
| 285,292c252,254 | |
| < 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("%g0"), e); | |
| > Printf.fprintf oc "\tret\n"; | |
| > Printf.fprintf oc "\trestore\n" | |
| diff min-caml-ppc/libmincaml.S min-caml-sparc/libmincaml.S | |
| 1,15c1,2 | |
| < .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 | |
| --- | |
| > .section ".text" | |
| > .global min_caml_print_newline | |
| 17,54c4,11 | |
| < 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 | |
| --- | |
| > set 10, %o0 | |
| > st %o7, [%i0] | |
| > call putchar | |
| > nop | |
| > ld [%i0], %o7 | |
| > retl | |
| > nop | |
| > .global min_caml_print_int | |
| 56,98c13,21 | |
| < 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 | |
| --- | |
| > set format_int, %o0 | |
| > mov %i2, %o1 | |
| > st %o7, [%i0] | |
| > call printf | |
| > nop | |
| > ld [%i0], %o7 | |
| > retl | |
| > nop | |
| > .global min_caml_print_byte | |
| 100,120c23,30 | |
| < 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 | |
| --- | |
| > mov %i2, %o0 | |
| > st %o7, [%i0] | |
| > call putchar | |
| > nop | |
| > ld [%i0], %o7 | |
| > retl | |
| > nop | |
| > .global min_caml_prerr_int | |
| 122,174c32,41 | |
| < 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 | |
| --- | |
| > set min_caml_stderr, %o0 | |
| > set format_int, %o1 | |
| > mov %i2, %o2 | |
| > st %o7, [%i0] | |
| > call fprintf | |
| > nop | |
| > ld [%i0], %o7 | |
| > retl | |
| > nop | |
| > .global min_caml_prerr_byte | |
| 176,220c43,51 | |
| < 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 | |
| --- | |
| > mov %i2, %o0 | |
| > set min_caml_stderr, %o1 | |
| > st %o7, [%i0] | |
| > call fputc | |
| > nop | |
| > ld [%i0], %o7 | |
| > retl | |
| > nop | |
| > .global min_caml_prerr_float | |
| 222,261c53,63 | |
| < 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 | |
| --- | |
| > set min_caml_stderr, %o0 | |
| > set format_float, %o1 | |
| > std %f0, [%i0] | |
| > ldd [%i0], %o2 | |
| > st %o7, [%i0] | |
| > call fprintf | |
| > nop | |
| > ld [%i0], %o7 | |
| > retl | |
| > nop | |
| > .global min_caml_read_int | |
| 263,336c65,86 | |
| < 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 | |
| --- | |
| > set format_int, %o0 | |
| > st %o7, [%i0] | |
| > call scanf, 0 | |
| > add %fp, -20, %o1 ! delay slot | |
| > ld [%i0], %o7 | |
| > ld [%fp-20], %i2 | |
| > retl | |
| > nop | |
| > .global min_caml_read_float | |
| > min_caml_read_float: | |
| > set format_float, %o0 | |
| > st %o7, [%i0] | |
| > call scanf, 0 | |
| > add %fp, -24, %o1 ! delay slot | |
| > ld [%i0], %o7 | |
| > ldd [%fp-24], %f0 | |
| > retl | |
| > nop | |
| > .global min_caml_create_array | |
| > min_caml_create_array: | |
| > mov %i2, %i4 | |
| > mov %i1, %i2 | |
| 338,340c88,94 | |
| < cmpwi cr7, r6, 0 | |
| < bne cr7, create_array_cont | |
| < b create_array_exit | |
| --- | |
| > tst %i4 | |
| > bnz create_array_cont | |
| > nop | |
| > andcc %i1, 4, %g0 | |
| > bz create_array_exit | |
| > nop | |
| > add %i1, 4, %i1 | |
| 342c96,97 | |
| < blr | |
| --- | |
| > retl | |
| > nop | |
| 344,346c99,101 | |
| < stw r5, 0(r4) | |
| < subi r6, r6, 1 | |
| < addi r4, r4, 4 | |
| --- | |
| > st %i3, [%i1] | |
| > dec %i4 | |
| > add %i1, 4, %i1 | |
| 348,349c103,104 | |
| < # create_float_array | |
| < .globl min_caml_create_float_array | |
| --- | |
| > nop | |
| > .global min_caml_create_float_array | |
| 351,352c106,107 | |
| < mr r5, r2 | |
| < mr r2, r4 | |
| --- | |
| > mov %i2, %i3 | |
| > mov %i1, %i2 | |
| 354,356c109,113 | |
| < cmpwi cr7, r5, 0 | |
| < bne cr7, create_float_array_cont | |
| < blr | |
| --- | |
| > tst %i3 | |
| > bnz create_float_array_cont | |
| > nop | |
| > retl | |
| > nop | |
| 358,360c115,117 | |
| < stfd f0, 0(r4) | |
| < subi r5, r5, 1 | |
| < addi r4, r4, 8 | |
| --- | |
| > std %f0, [%i1] | |
| > dec %i3 | |
| > add %i1, 8, %i1 | |
| 362c119,120 | |
| < .globl min_caml_abs_float | |
| --- | |
| > nop | |
| > .global min_caml_abs_float | |
| 364,369c122,125 | |
| < fabs f0, f0 | |
| < blr | |
| < # sqrt | |
| < .text | |
| < .align 2 | |
| < .globl min_caml_sqrt | |
| --- | |
| > fabss %f0, %f0 | |
| > retl | |
| > nop | |
| > .global min_caml_sqrt | |
| 371,412c127,130 | |
| < 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 | |
| --- | |
| > fsqrtd %f0, %f0 | |
| > retl | |
| > nop | |
| > .global min_caml_floor | |
| 414,454c132,140 | |
| < 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 | |
| --- | |
| > std %f0, [%i0] | |
| > ldd [%i0], %o0 | |
| > st %o7, [%i0] | |
| > call floor | |
| > nop | |
| > ld [%i0], %o7 | |
| > retl | |
| > nop | |
| > .global min_caml_int_of_float | |
| 456c142 | |
| < .globl min_caml_truncate | |
| --- | |
| > .global min_caml_truncate | |
| 458,471c144,149 | |
| < 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 | |
| --- | |
| > fdtoi %f0, %f0 | |
| > st %f0, [%i0] | |
| > ld [%i0], %i2 | |
| > retl | |
| > nop | |
| > .global min_caml_float_of_int | |
| 473,501c151,156 | |
| < 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 | |
| --- | |
| > st %i2, [%i0] | |
| > ld [%i0], %f0 | |
| > fitod %f0, %f0 | |
| > retl | |
| > nop | |
| > .global min_caml_cos | |
| 503,544c158,166 | |
| < 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 | |
| --- | |
| > std %f0, [%i0] | |
| > ldd [%i0], %o0 | |
| > st %o7, [%i0] | |
| > call cos | |
| > nop | |
| > ld [%i0], %o7 | |
| > retl | |
| > nop | |
| > .global min_caml_sin | |
| 546,587c168,176 | |
| < 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 | |
| --- | |
| > std %f0, [%i0] | |
| > ldd [%i0], %o0 | |
| > st %o7, [%i0] | |
| > call sin | |
| > nop | |
| > ld [%i0], %o7 | |
| > retl | |
| > nop | |
| > .global min_caml_atan | |
| 589,628c178,191 | |
| < 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 | |
| --- | |
| > std %f0, [%i0] | |
| > ldd [%i0], %o0 | |
| > st %o7, [%i0] | |
| > call atan | |
| > nop | |
| > ld [%i0], %o7 | |
| > retl | |
| > nop | |
| > .section ".rodata" | |
| > format_int: | |
| > .asciz "%d" | |
| > format_float: | |
| > .asciz "%lf" | |
| > .align 8 | |
| 635,636d197 | |
| < | |
| < | |
| Common subdirectories: min-caml-ppc/min-rt and min-caml-sparc/min-rt | |
| diff min-caml-ppc/regAlloc.ml min-caml-sparc/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 -> | |
| 47c47 | |
| < | Type.Unit -> ["%r0"] (* dummy *) | |
| --- | |
| > | Type.Unit -> ["%g0"] (* dummy *) | |
| 50c50 | |
| < if all = ["%r0"] then Alloc("%r0") else (* [XX] ad hoc optimization *) | |
| --- | |
| > if all = ["%g0"] then Alloc("%g0") else (* [XX] ad hoc optimization *) | |
| 120,121c120,121 | |
| < | 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,135c125,135 | |
| < | 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) | |
| --- | |
| > | SLL(x, y') -> (Ans(SLL(find x Type.Int regenv, find' y' regenv)), regenv) | |
| > | Ld(x, y') -> (Ans(Ld(find x Type.Int regenv, find' y' regenv)), regenv) | |
| > | St(x, y, z') -> (Ans(St(find x Type.Int regenv, find y Type.Int regenv, find' z' regenv)), 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') -> (Ans(LdDF(find x Type.Int regenv, find' y' regenv)), regenv) | |
| > | StDF(x, y, z') -> (Ans(StDF(find x Type.Float regenv, find y Type.Int regenv, find' z' regenv)), regenv) | |
| 212c212 | |
| < 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-sparc/shootout | |
| diff min-caml-ppc/simm.ml min-caml-sparc/simm.ml | |
| 3c3 | |
| < let rec g env = function (* ̿�����16bit¨�ͺ�Ŭ�� (caml2html: simm13_g) *) | |
| --- | |
| > let rec g env = function (* ̿�����13bit¨�ͺ�Ŭ�� (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) when -4096 <= i && i < 4096 -> | |
| > (* Format.eprintf "found simm13 %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,13c11,13 | |
| < | 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)) | |
| --- | |
| > | Let(xt, SLL(y, C(i)), e) when M.mem y env -> (* for array access *) | |
| > (* Format.eprintf "erased redundant SLL on %s@." x; *) | |
| > g env (Let(xt, Set((M.find y env) lsl i), e)) | |
| 15c15 | |
| < and g' env = function (* ��̿���16bit¨�ͺ�Ŭ�� (caml2html: simm13_gprime) *) | |
| --- | |
| > and g' env = function (* ��̿���13bit¨�ͺ�Ŭ�� (caml2html: simm13_gprime) *) | |
| 19,23c19,23 | |
| < | 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)) | |
| --- | |
| > | SLL(x, V(y)) when M.mem y env -> SLL(x, C(M.find y env)) | |
| > | Ld(x, V(y)) when M.mem y env -> Ld(x, C(M.find y env)) | |
| > | St(x, y, V(z)) when M.mem z env -> St(x, y, C(M.find z env)) | |
| > | LdDF(x, V(y)) when M.mem y env -> LdDF(x, C(M.find y env)) | |
| > | StDF(x, y, V(z)) when M.mem z env -> StDF(x, y, C(M.find z env)) | |
| 37c37 | |
| < 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 } = (* �ȥåץ�٥�ؿ���13bit¨�ͺ�Ŭ�� *) | |
| 40c40 | |
| < let f (Prog(data, fundefs, e)) = (* �ץ���������Τ�16bit¨�ͺ�Ŭ�� *) | |
| --- | |
| > let f (Prog(data, fundefs, e)) = (* �ץ���������Τ�13bit¨�ͺ�Ŭ�� *) | |
| Common subdirectories: min-caml-ppc/test and min-caml-sparc/test | |
| diff min-caml-ppc/virtual.ml min-caml-sparc/virtual.ml | |
| 1c1 | |
| < (* translation into PowerPC assembly with infinite number of virtual registers *) | |
| --- | |
| > (* translation into SPARC 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)))) | |
| 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)), store_fv)) | |
| > (fun y _ offset store_fv -> seq(St(y, x, C(offset)), store_fv)) in | |
| > Let((x, t), Mov(reg_hp), | |
| 88c89 | |
| < seq(Stw(z, x, C(0)), | |
| --- | |
| > seq(St(z, x, C(0)), | |
| 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)), store)) | |
| > (fun x _ offset store -> seq(St(x, y, C(offset)), 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)), load)) | |
| 118c119 | |
| < Let((x, t), Lwz(y, C(offset)), load)) in | |
| --- | |
| > Let((x, t), Ld(y, C(offset)), load)) in | |
| 125,126c126,127 | |
| < Let((offset, Type.Int), Slw(y, C(3)), | |
| < Ans(Lfd(x, V(offset)))) | |
| --- | |
| > Let((offset, Type.Int), SLL(y, C(3)), | |
| > Ans(LdDF(x, V(offset)))) | |
| 128,129c129,130 | |
| < Let((offset, Type.Int), Slw(y, C(2)), | |
| < Ans(Lwz(x, V(offset)))) | |
| --- | |
| > Let((offset, Type.Int), SLL(y, C(2)), | |
| > Ans(Ld(x, V(offset)))) | |
| 136,137c137,138 | |
| < Let((offset, Type.Int), Slw(y, C(3)), | |
| < Ans(Stfd(z, x, V(offset)))) | |
| --- | |
| > Let((offset, Type.Int), SLL(y, C(3)), | |
| > Ans(StDF(z, x, V(offset)))) | |
| 139,140c140,141 | |
| < Let((offset, Type.Int), Slw(y, C(2)), | |
| < Ans(Stw(z, x, V(offset)))) | |
| --- | |
| > Let((offset, Type.Int), SLL(y, C(2)), | |
| > Ans(St(z, x, V(offset)))) | |
| 151,152c152,153 | |
| < (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)), load)) | |
| > (fun z t offset load -> Let((z, t), Ld(x, C(offset)), load)) in | |
| Common subdirectories: min-caml-ppc/x86 and min-caml-sparc/x86 |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment