API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Mar 26th, 2019
119
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 51.50 KB | None | 0 0
raw download clone embed print report
  1. diff -u SPARC/asm.ml PowerPC/asm.ml
  2. --- SPARC/asm.ml 2019-03-19 21:12:59.000000000 +0900
  3. +++ PowerPC/asm.ml 2019-03-19 21:12:59.000000000 +0900
  4. @@ -1,4 +1,4 @@
  5. -(* SPARC assembly with a few virtual instructions *)
  6. +(* PowerPC assembly with a few virtual instructions *)
  7.  
  8. type id_or_imm = V of Id.t | C of int
  9. type t = (* 命令の列 (caml2html: sparcasm_t) *)
  10. @@ -6,23 +6,24 @@
  11. | Let of (Id.t * Type.t) * exp * t
  12. and exp = (* 一つ一つの命令に対応する式 (caml2html: sparcasm_exp) *)
  13. | Nop
  14. - | Set of int
  15. + | Li of int
  16. + | FLi of Id.l
  17. | SetL of Id.l
  18. - | Mov of Id.t
  19. + | Mr of Id.t
  20. | Neg of Id.t
  21. | Add of Id.t * id_or_imm
  22. | Sub of Id.t * id_or_imm
  23. - | SLL of Id.t * id_or_imm
  24. - | Ld of Id.t * id_or_imm
  25. - | St of Id.t * Id.t * id_or_imm
  26. - | FMovD of Id.t
  27. - | FNegD of Id.t
  28. - | FAddD of Id.t * Id.t
  29. - | FSubD of Id.t * Id.t
  30. - | FMulD of Id.t * Id.t
  31. - | FDivD of Id.t * Id.t
  32. - | LdDF of Id.t * id_or_imm
  33. - | StDF of Id.t * Id.t * id_or_imm
  34. + | Slw of Id.t * id_or_imm
  35. + | Lwz of Id.t * id_or_imm
  36. + | Stw of Id.t * Id.t * id_or_imm
  37. + | FMr of Id.t
  38. + | FNeg of Id.t
  39. + | FAdd of Id.t * Id.t
  40. + | FSub of Id.t * Id.t
  41. + | FMul of Id.t * Id.t
  42. + | FDiv of Id.t * Id.t
  43. + | Lfd of Id.t * id_or_imm
  44. + | Stfd of Id.t * Id.t * id_or_imm
  45. | Comment of string
  46. (* virtual instructions *)
  47. | IfEq of Id.t * id_or_imm * t * t
  48. @@ -42,30 +43,21 @@
  49. let fletd(x, e1, e2) = Let((x, Type.Float), e1, e2)
  50. let seq(e1, e2) = Let((Id.gentmp Type.Unit, Type.Unit), e1, e2)
  51.  
  52. -let regs = (* Array.init 16 (fun i -> Printf.sprintf "%%r%d" i) *)
  53. - [| "%i2"; "%i3"; "%i4"; "%i5";
  54. - "%l0"; "%l1"; "%l2"; "%l3"; "%l4"; "%l5"; "%l6"; "%l7";
  55. - "%o0"; "%o1"; "%o2"; "%o3"; "%o4"; "%o5" |]
  56. -let fregs = Array.init 16 (fun i -> Printf.sprintf "%%f%d" (i * 2))
  57. +let regs = (* Array.init 27 (fun i -> Printf.sprintf "_R_%d" i) *)
  58. + [| "%r2"; "%r5"; "%r6"; "%r7"; "%r8"; "%r9"; "%r10";
  59. + "%r11"; "%r12"; "%r13"; "%r14"; "%r15"; "%r16"; "%r17"; "%r18";
  60. + "%r19"; "%r20"; "%r21"; "%r22"; "%r23"; "%r24"; "%r25"; "%r26";
  61. + "%r27"; "%r28"; "%r29"; "%r30" |]
  62. +let fregs = Array.init 32 (fun i -> Printf.sprintf "%%f%d" i)
  63. let allregs = Array.to_list regs
  64. let allfregs = Array.to_list fregs
  65. let reg_cl = regs.(Array.length regs - 1) (* closure address (caml2html: sparcasm_regcl) *)
  66. let reg_sw = regs.(Array.length regs - 2) (* temporary for swap *)
  67. let reg_fsw = fregs.(Array.length fregs - 1) (* temporary for swap *)
  68. -let reg_sp = "%i0" (* stack pointer *)
  69. -let reg_hp = "%i1" (* heap pointer (caml2html: sparcasm_reghp) *)
  70. -let reg_ra = "%o7" (* return address *)
  71. +let reg_sp = "%r3" (* stack pointer *)
  72. +let reg_hp = "%r4" (* heap pointer (caml2html: sparcasm_reghp) *)
  73. +let reg_tmp = "%r31" (* [XX] ad hoc *)
  74. let is_reg x = (x.[0] = '%')
  75. -let co_freg_table =
  76. - let ht = Hashtbl.create 16 in
  77. - for i = 0 to 15 do
  78. - Hashtbl.add
  79. - ht
  80. - (Printf.sprintf "%%f%d" (i * 2))
  81. - (Printf.sprintf "%%f%d" (i * 2 + 1))
  82. - done;
  83. - ht
  84. -let co_freg freg = Hashtbl.find co_freg_table freg (* "companion" freg *)
  85.  
  86. (* super-tenuki *)
  87. let rec remove_and_uniq xs = function
  88. @@ -76,12 +68,12 @@
  89. (* free variables in the order of use (for spilling) (caml2html: sparcasm_fv) *)
  90. let fv_id_or_imm = function V(x) -> [x] | _ -> []
  91. let rec fv_exp = function
  92. - | Nop | Set(_) | SetL(_) | Comment(_) | Restore(_) -> []
  93. - | Mov(x) | Neg(x) | FMovD(x) | FNegD(x) | Save(x, _) -> [x]
  94. - | Add(x, y') | Sub(x, y') | SLL(x, y') | Ld(x, y') | LdDF(x, y') -> x :: fv_id_or_imm y'
  95. - | St(x, y, z') | StDF(x, y, z') -> x :: y :: fv_id_or_imm z'
  96. - | FAddD(x, y) | FSubD(x, y) | FMulD(x, y) | FDivD(x, y) -> [x; y]
  97. - | 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 *)
  98. + | Nop | Li(_) | FLi(_) | SetL(_) | Comment(_) | Restore(_) -> []
  99. + | Mr(x) | Neg(x) | FMr(x) | FNeg(x) | Save(x, _) -> [x]
  100. + | Add(x, y') | Sub(x, y') | Slw(x, y') | Lfd(x, y') | Lwz(x, y') -> x :: fv_id_or_imm y'
  101. + | Stw(x, y, z') | Stfd(x, y, z') -> x :: y :: fv_id_or_imm z'
  102. + | FAdd(x, y) | FSub(x, y) | FMul(x, y) | FDiv(x, y) -> [x; y]
  103. + | 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 *)
  104. | IfFEq(x, y, e1, e2) | IfFLE(x, y, e1, e2) -> x :: y :: remove_and_uniq S.empty (fv e1 @ fv e2) (* uniq here just for efficiency *)
  105. | CallCls(x, ys, zs) -> x :: ys @ zs
  106. | CallDir(_, ys, zs) -> ys @ zs
  107. diff -u SPARC/asm.mli PowerPC/asm.mli
  108. --- SPARC/asm.mli 2019-01-04 15:29:53.000000000 +0900
  109. +++ PowerPC/asm.mli 2019-01-04 15:29:53.000000000 +0900
  110. @@ -4,23 +4,24 @@
  111. | Let of (Id.t * Type.t) * exp * t
  112. and exp =
  113. | Nop
  114. - | Set of int
  115. + | Li of int
  116. + | FLi of Id.l
  117. | SetL of Id.l
  118. - | Mov of Id.t
  119. + | Mr of Id.t
  120. | Neg of Id.t
  121. | Add of Id.t * id_or_imm
  122. | Sub of Id.t * id_or_imm
  123. - | SLL of Id.t * id_or_imm
  124. - | Ld of Id.t * id_or_imm
  125. - | St of Id.t * Id.t * id_or_imm
  126. - | FMovD of Id.t
  127. - | FNegD of Id.t
  128. - | FAddD of Id.t * Id.t
  129. - | FSubD of Id.t * Id.t
  130. - | FMulD of Id.t * Id.t
  131. - | FDivD of Id.t * Id.t
  132. - | LdDF of Id.t * id_or_imm
  133. - | StDF of Id.t * Id.t * id_or_imm
  134. + | Slw of Id.t * id_or_imm
  135. + | Lwz of Id.t * id_or_imm
  136. + | Stw of Id.t * Id.t * id_or_imm
  137. + | FMr of Id.t
  138. + | FNeg of Id.t
  139. + | FAdd of Id.t * Id.t
  140. + | FSub of Id.t * Id.t
  141. + | FMul of Id.t * Id.t
  142. + | FDiv of Id.t * Id.t
  143. + | Lfd of Id.t * id_or_imm
  144. + | Stfd of Id.t * Id.t * id_or_imm
  145. | Comment of string
  146. (* virtual instructions *)
  147. | IfEq of Id.t * id_or_imm * t * t
  148. @@ -46,11 +47,10 @@
  149. val reg_cl : Id.t
  150. val reg_sw : Id.t
  151. val reg_fsw : Id.t
  152. -val reg_ra : Id.t
  153. val reg_hp : Id.t
  154. val reg_sp : Id.t
  155. +val reg_tmp : Id.t
  156. val is_reg : Id.t -> bool
  157. -val co_freg : Id.t -> Id.t
  158.  
  159. val fv : t -> Id.t list
  160. val concat : t -> Id.t * Type.t -> t -> t
  161. diff -u SPARC/emit.ml PowerPC/emit.ml
  162. --- SPARC/emit.ml 2019-03-19 21:12:59.000000000 +0900
  163. +++ PowerPC/emit.ml 2019-03-19 21:12:59.000000000 +0900
  164. @@ -24,9 +24,16 @@
  165. let offset x = 4 * List.hd (locate x)
  166. let stacksize () = align ((List.length !stackmap + 1) * 4)
  167.  
  168. -let pp_id_or_imm = function
  169. - | V(x) -> x
  170. - | C(i) -> string_of_int i
  171. +let reg r =
  172. + if is_reg r
  173. + then String.sub r 1 (String.length r - 1)
  174. + else r
  175. +
  176. +let load_label r label =
  177. + let r' = reg r in
  178. + Printf.sprintf
  179. + "\tlis\t%s, ha16(%s)\n\taddi\t%s, %s, lo16(%s)\n"
  180. + r' label r' r' label
  181.  
  182. (* 関数呼び出しのために引数を並べ替える(register shuffling) (caml2html: emit_shuffle) *)
  183. let rec shuffle sw xys =
  184. @@ -52,139 +59,163 @@
  185. and g' oc = function (* 各命令のアセンブリ生成 (caml2html: emit_gprime) *)
  186. (* 末尾でなかったら計算結果をdestにセット (caml2html: emit_nontail) *)
  187. | NonTail(_), Nop -> ()
  188. - | NonTail(x), Set(i) -> Printf.fprintf oc "\tset\t%d, %s\n" i x
  189. - | NonTail(x), SetL(Id.L(y)) -> Printf.fprintf oc "\tset\t%s, %s\n" y x
  190. - | NonTail(x), Mov(y) when x = y -> ()
  191. - | NonTail(x), Mov(y) -> Printf.fprintf oc "\tmov\t%s, %s\n" y x
  192. - | NonTail(x), Neg(y) -> Printf.fprintf oc "\tneg\t%s, %s\n" y x
  193. - | NonTail(x), Add(y, z') -> Printf.fprintf oc "\tadd\t%s, %s, %s\n" y (pp_id_or_imm z') x
  194. - | NonTail(x), Sub(y, z') -> Printf.fprintf oc "\tsub\t%s, %s, %s\n" y (pp_id_or_imm z') x
  195. - | NonTail(x), SLL(y, z') -> Printf.fprintf oc "\tsll\t%s, %s, %s\n" y (pp_id_or_imm z') x
  196. - | NonTail(x), Ld(y, z') -> Printf.fprintf oc "\tld\t[%s + %s], %s\n" y (pp_id_or_imm z') x
  197. - | NonTail(_), St(x, y, z') -> Printf.fprintf oc "\tst\t%s, [%s + %s]\n" x y (pp_id_or_imm z')
  198. - | NonTail(x), FMovD(y) when x = y -> ()
  199. - | NonTail(x), FMovD(y) ->
  200. - Printf.fprintf oc "\tfmovs\t%s, %s\n" y x;
  201. - Printf.fprintf oc "\tfmovs\t%s, %s\n" (co_freg y) (co_freg x)
  202. - | NonTail(x), FNegD(y) ->
  203. - Printf.fprintf oc "\tfnegs\t%s, %s\n" y x;
  204. - if x <> y then Printf.fprintf oc "\tfmovs\t%s, %s\n" (co_freg y) (co_freg x)
  205. - | NonTail(x), FAddD(y, z) -> Printf.fprintf oc "\tfaddd\t%s, %s, %s\n" y z x
  206. - | NonTail(x), FSubD(y, z) -> Printf.fprintf oc "\tfsubd\t%s, %s, %s\n" y z x
  207. - | NonTail(x), FMulD(y, z) -> Printf.fprintf oc "\tfmuld\t%s, %s, %s\n" y z x
  208. - | NonTail(x), FDivD(y, z) -> Printf.fprintf oc "\tfdivd\t%s, %s, %s\n" y z x
  209. - | NonTail(x), LdDF(y, z') -> Printf.fprintf oc "\tldd\t[%s + %s], %s\n" y (pp_id_or_imm z') x
  210. - | NonTail(_), StDF(x, y, z') -> Printf.fprintf oc "\tstd\t%s, [%s + %s]\n" x y (pp_id_or_imm z')
  211. - | NonTail(_), Comment(s) -> Printf.fprintf oc "\t! %s\n" s
  212. + | NonTail(x), Li(i) when -32768 <= i && i < 32768 -> Printf.fprintf oc "\tli\t%s, %d\n" (reg x) i
  213. + | NonTail(x), Li(i) ->
  214. + let n = i lsr 16 in
  215. + let m = i lxor (n lsl 16) in
  216. + let r = reg x in
  217. + Printf.fprintf oc "\tlis\t%s, %d\n" r n;
  218. + Printf.fprintf oc "\tori\t%s, %s, %d\n" r r m
  219. + | NonTail(x), FLi(Id.L(l)) ->
  220. + let s = load_label (reg reg_tmp) l in
  221. + Printf.fprintf oc "%s\tlfd\t%s, 0(%s)\n" s (reg x) (reg reg_tmp)
  222. + | NonTail(x), SetL(Id.L(y)) ->
  223. + let s = load_label x y in
  224. + Printf.fprintf oc "%s" s
  225. + | NonTail(x), Mr(y) when x = y -> ()
  226. + | NonTail(x), Mr(y) -> Printf.fprintf oc "\tmr\t%s, %s\n" (reg x) (reg y)
  227. + | NonTail(x), Neg(y) -> Printf.fprintf oc "\tneg\t%s, %s\n" (reg x) (reg y)
  228. + | NonTail(x), Add(y, V(z)) -> Printf.fprintf oc "\tadd\t%s, %s, %s\n" (reg x) (reg y) (reg z)
  229. + | NonTail(x), Add(y, C(z)) -> Printf.fprintf oc "\taddi\t%s, %s, %d\n" (reg x) (reg y) z
  230. + | NonTail(x), Sub(y, V(z)) -> Printf.fprintf oc "\tsub\t%s, %s, %s\n" (reg x) (reg y) (reg z)
  231. + | NonTail(x), Sub(y, C(z)) -> Printf.fprintf oc "\tsubi\t%s, %s, %d\n" (reg x) (reg y) z
  232. + | NonTail(x), Slw(y, V(z)) -> Printf.fprintf oc "\tslw\t%s, %s, %s\n" (reg x) (reg y) (reg z)
  233. + | NonTail(x), Slw(y, C(z)) -> Printf.fprintf oc "\tslwi\t%s, %s, %d\n" (reg x) (reg y) z
  234. + | NonTail(x), Lwz(y, V(z)) -> Printf.fprintf oc "\tlwzx\t%s, %s, %s\n" (reg x) (reg y) (reg z)
  235. + | NonTail(x), Lwz(y, C(z)) -> Printf.fprintf oc "\tlwz\t%s, %d(%s)\n" (reg x) z (reg y)
  236. + | NonTail(_), Stw(x, y, V(z)) -> Printf.fprintf oc "\tstwx\t%s, %s, %s\n" (reg x) (reg y) (reg z)
  237. + | NonTail(_), Stw(x, y, C(z)) -> Printf.fprintf oc "\tstw\t%s, %d(%s)\n" (reg x) z (reg y)
  238. + | NonTail(x), FMr(y) when x = y -> ()
  239. + | NonTail(x), FMr(y) -> Printf.fprintf oc "\tfmr\t%s, %s\n" (reg x) (reg y)
  240. + | NonTail(x), FNeg(y) -> Printf.fprintf oc "\tfneg\t%s, %s\n" (reg x) (reg y)
  241. + | NonTail(x), FAdd(y, z) -> Printf.fprintf oc "\tfadd\t%s, %s, %s\n" (reg x) (reg y) (reg z)
  242. + | NonTail(x), FSub(y, z) -> Printf.fprintf oc "\tfsub\t%s, %s, %s\n" (reg x) (reg y) (reg z)
  243. + | NonTail(x), FMul(y, z) -> Printf.fprintf oc "\tfmul\t%s, %s, %s\n" (reg x) (reg y) (reg z)
  244. + | NonTail(x), FDiv(y, z) -> Printf.fprintf oc "\tfdiv\t%s, %s, %s\n" (reg x) (reg y) (reg z)
  245. + | NonTail(x), Lfd(y, V(z)) -> Printf.fprintf oc "\tlfdx\t%s, %s, %s\n" (reg x) (reg y) (reg z)
  246. + | NonTail(x), Lfd(y, C(z)) -> Printf.fprintf oc "\tlfd\t%s, %d(%s)\n" (reg x) z (reg y)
  247. + | NonTail(_), Stfd(x, y, V(z)) -> Printf.fprintf oc "\tstfdx\t%s, %s, %s\n" (reg x) (reg y) (reg z)
  248. + | NonTail(_), Stfd(x, y, C(z)) -> Printf.fprintf oc "\tstfd\t%s, %d(%s)\n" (reg x) z (reg y)
  249. + | NonTail(_), Comment(s) -> Printf.fprintf oc "#\t%s\n" s
  250. (* 退避の仮想命令の実装 (caml2html: emit_save) *)
  251. | NonTail(_), Save(x, y) when List.mem x allregs && not (S.mem y !stackset) ->
  252. save y;
  253. - Printf.fprintf oc "\tst\t%s, [%s + %d]\n" x reg_sp (offset y)
  254. + Printf.fprintf oc "\tstw\t%s, %d(%s)\n" (reg x) (offset y) (reg reg_sp)
  255. | NonTail(_), Save(x, y) when List.mem x allfregs && not (S.mem y !stackset) ->
  256. savef y;
  257. - Printf.fprintf oc "\tstd\t%s, [%s + %d]\n" x reg_sp (offset y)
  258. + Printf.fprintf oc "\tstfd\t%s, %d(%s)\n" (reg x) (offset y) (reg reg_sp)
  259. | NonTail(_), Save(x, y) -> assert (S.mem y !stackset); ()
  260. (* 復帰の仮想命令の実装 (caml2html: emit_restore) *)
  261. | NonTail(x), Restore(y) when List.mem x allregs ->
  262. - Printf.fprintf oc "\tld\t[%s + %d], %s\n" reg_sp (offset y) x
  263. + Printf.fprintf oc "\tlwz\t%s, %d(%s)\n" (reg x) (offset y) (reg reg_sp)
  264. | NonTail(x), Restore(y) ->
  265. assert (List.mem x allfregs);
  266. - Printf.fprintf oc "\tldd\t[%s + %d], %s\n" reg_sp (offset y) x
  267. + Printf.fprintf oc "\tlfd\t%s, %d(%s)\n" (reg x) (offset y) (reg reg_sp)
  268. (* 末尾だったら計算結果を第一レジスタにセットしてリターン (caml2html: emit_tailret) *)
  269. - | Tail, (Nop | St _ | StDF _ | Comment _ | Save _ as exp) ->
  270. + | Tail, (Nop | Stw _ | Stfd _ | Comment _ | Save _ as exp) ->
  271. g' oc (NonTail(Id.gentmp Type.Unit), exp);
  272. - Printf.fprintf oc "\tretl\n";
  273. - Printf.fprintf oc "\tnop\n"
  274. - | Tail, (Set _ | SetL _ | Mov _ | Neg _ | Add _ | Sub _ | SLL _ | Ld _ as exp) ->
  275. + Printf.fprintf oc "\tblr\n";
  276. + | Tail, (Li _ | SetL _ | Mr _ | Neg _ | Add _ | Sub _ | Slw _ | Lwz _ as exp) ->
  277. g' oc (NonTail(regs.(0)), exp);
  278. - Printf.fprintf oc "\tretl\n";
  279. - Printf.fprintf oc "\tnop\n"
  280. - | Tail, (FMovD _ | FNegD _ | FAddD _ | FSubD _ | FMulD _ | FDivD _ | LdDF _ as exp) ->
  281. + Printf.fprintf oc "\tblr\n";
  282. + | Tail, (FLi _ | FMr _ | FNeg _ | FAdd _ | FSub _ | FMul _ | FDiv _ | Lfd _ as exp) ->
  283. g' oc (NonTail(fregs.(0)), exp);
  284. - Printf.fprintf oc "\tretl\n";
  285. - Printf.fprintf oc "\tnop\n"
  286. + Printf.fprintf oc "\tblr\n";
  287. | Tail, (Restore(x) as exp) ->
  288. (match locate x with
  289. | [i] -> g' oc (NonTail(regs.(0)), exp)
  290. | [i; j] when i + 1 = j -> g' oc (NonTail(fregs.(0)), exp)
  291. | _ -> assert false);
  292. - Printf.fprintf oc "\tretl\n";
  293. - Printf.fprintf oc "\tnop\n"
  294. - | Tail, IfEq(x, y', e1, e2) ->
  295. - Printf.fprintf oc "\tcmp\t%s, %s\n" x (pp_id_or_imm y');
  296. - g'_tail_if oc e1 e2 "be" "bne"
  297. - | Tail, IfLE(x, y', e1, e2) ->
  298. - Printf.fprintf oc "\tcmp\t%s, %s\n" x (pp_id_or_imm y');
  299. - g'_tail_if oc e1 e2 "ble" "bg"
  300. - | Tail, IfGE(x, y', e1, e2) ->
  301. - Printf.fprintf oc "\tcmp\t%s, %s\n" x (pp_id_or_imm y');
  302. - g'_tail_if oc e1 e2 "bge" "bl"
  303. + Printf.fprintf oc "\tblr\n";
  304. + | Tail, IfEq(x, V(y), e1, e2) ->
  305. + Printf.fprintf oc "\tcmpw\tcr7, %s, %s\n" (reg x) (reg y);
  306. + g'_tail_if oc e1 e2 "beq" "bne"
  307. + | Tail, IfEq(x, C(y), e1, e2) ->
  308. + Printf.fprintf oc "\tcmpwi\tcr7, %s, %d\n" (reg x) y;
  309. + g'_tail_if oc e1 e2 "beq" "bne"
  310. + | Tail, IfLE(x, V(y), e1, e2) ->
  311. + Printf.fprintf oc "\tcmpw\tcr7, %s, %s\n" (reg x) (reg y);
  312. + g'_tail_if oc e1 e2 "ble" "bgt"
  313. + | Tail, IfLE(x, C(y), e1, e2) ->
  314. + Printf.fprintf oc "\tcmpwi\tcr7, %s, %d\n" (reg x) y;
  315. + g'_tail_if oc e1 e2 "ble" "bgt"
  316. + | Tail, IfGE(x, V(y), e1, e2) ->
  317. + Printf.fprintf oc "\tcmpw\tcr7, %s, %s\n" (reg x) (reg y);
  318. + g'_tail_if oc e1 e2 "bge" "blt"
  319. + | Tail, IfGE(x, C(y), e1, e2) ->
  320. + Printf.fprintf oc "\tcmpwi\tcr7, %s, %d\n" (reg x) y;
  321. + g'_tail_if oc e1 e2 "bge" "blt"
  322. | Tail, IfFEq(x, y, e1, e2) ->
  323. - Printf.fprintf oc "\tfcmpd\t%s, %s\n" x y;
  324. - Printf.fprintf oc "\tnop\n";
  325. - g'_tail_if oc e1 e2 "fbe" "fbne"
  326. + Printf.fprintf oc "\tfcmpu\tcr7, %s, %s\n" (reg x) (reg y);
  327. + g'_tail_if oc e1 e2 "beq" "bne"
  328. | Tail, IfFLE(x, y, e1, e2) ->
  329. - Printf.fprintf oc "\tfcmpd\t%s, %s\n" x y;
  330. - Printf.fprintf oc "\tnop\n";
  331. - g'_tail_if oc e1 e2 "fble" "fbg"
  332. - | NonTail(z), IfEq(x, y', e1, e2) ->
  333. - Printf.fprintf oc "\tcmp\t%s, %s\n" x (pp_id_or_imm y');
  334. - g'_non_tail_if oc (NonTail(z)) e1 e2 "be" "bne"
  335. - | NonTail(z), IfLE(x, y', e1, e2) ->
  336. - Printf.fprintf oc "\tcmp\t%s, %s\n" x (pp_id_or_imm y');
  337. - g'_non_tail_if oc (NonTail(z)) e1 e2 "ble" "bg"
  338. - | NonTail(z), IfGE(x, y', e1, e2) ->
  339. - Printf.fprintf oc "\tcmp\t%s, %s\n" x (pp_id_or_imm y');
  340. - g'_non_tail_if oc (NonTail(z)) e1 e2 "bge" "bl"
  341. + Printf.fprintf oc "\tfcmpu\tcr7, %s, %s\n" (reg x) (reg y);
  342. + g'_tail_if oc e1 e2 "ble" "bgt"
  343. + | NonTail(z), IfEq(x, V(y), e1, e2) ->
  344. + Printf.fprintf oc "\tcmpw\tcr7, %s, %s\n" (reg x) (reg y);
  345. + g'_non_tail_if oc (NonTail(z)) e1 e2 "beq" "bne"
  346. + | NonTail(z), IfEq(x, C(y), e1, e2) ->
  347. + Printf.fprintf oc "\tcmpwi\tcr7, %s, %d\n" (reg x) y;
  348. + g'_non_tail_if oc (NonTail(z)) e1 e2 "beq" "bne"
  349. + | NonTail(z), IfLE(x, V(y), e1, e2) ->
  350. + Printf.fprintf oc "\tcmpw\tcr7, %s, %s\n" (reg x) (reg y);
  351. + g'_non_tail_if oc (NonTail(z)) e1 e2 "ble" "bgt"
  352. + | NonTail(z), IfLE(x, C(y), e1, e2) ->
  353. + Printf.fprintf oc "\tcmpwi\tcr7, %s, %d\n" (reg x) y;
  354. + g'_non_tail_if oc (NonTail(z)) e1 e2 "ble" "bgt"
  355. + | NonTail(z), IfGE(x, V(y), e1, e2) ->
  356. + Printf.fprintf oc "\tcmpw\tcr7, %s, %s\n" (reg x) (reg y);
  357. + g'_non_tail_if oc (NonTail(z)) e1 e2 "bge" "blt"
  358. + | NonTail(z), IfGE(x, C(y), e1, e2) ->
  359. + Printf.fprintf oc "\tcmpwi\tcr7, %s, %d\n" (reg x) y;
  360. + g'_non_tail_if oc (NonTail(z)) e1 e2 "bge" "blt"
  361. | NonTail(z), IfFEq(x, y, e1, e2) ->
  362. - Printf.fprintf oc "\tfcmpd\t%s, %s\n" x y;
  363. - Printf.fprintf oc "\tnop\n";
  364. - g'_non_tail_if oc (NonTail(z)) e1 e2 "fbe" "fbne"
  365. + Printf.fprintf oc "\tfcmpu\tcr7, %s, %s\n" (reg x) (reg y);
  366. + g'_non_tail_if oc (NonTail(z)) e1 e2 "beq" "bne"
  367. | NonTail(z), IfFLE(x, y, e1, e2) ->
  368. - Printf.fprintf oc "\tfcmpd\t%s, %s\n" x y;
  369. - Printf.fprintf oc "\tnop\n";
  370. - g'_non_tail_if oc (NonTail(z)) e1 e2 "fble" "fbg"
  371. + Printf.fprintf oc "\tfcmpu\tcr7, %s, %s\n" (reg x) (reg y);
  372. + g'_non_tail_if oc (NonTail(z)) e1 e2 "ble" "bgt"
  373. (* 関数呼び出しの仮想命令の実装 (caml2html: emit_call) *)
  374. | Tail, CallCls(x, ys, zs) -> (* 末尾呼び出し (caml2html: emit_tailcall) *)
  375. g'_args oc [(x, reg_cl)] ys zs;
  376. - Printf.fprintf oc "\tld\t[%s + 0], %s\n" reg_cl reg_sw;
  377. - Printf.fprintf oc "\tjmp\t%s\n" reg_sw;
  378. - Printf.fprintf oc "\tnop\n"
  379. + Printf.fprintf oc "\tlwz\t%s, 0(%s)\n" (reg reg_sw) (reg reg_cl);
  380. + Printf.fprintf oc "\tmtctr\t%s\n\tbctr\n" (reg reg_sw);
  381. | Tail, CallDir(Id.L(x), ys, zs) -> (* 末尾呼び出し *)
  382. g'_args oc [] ys zs;
  383. - Printf.fprintf oc "\tb\t%s\n" x;
  384. - Printf.fprintf oc "\tnop\n"
  385. + Printf.fprintf oc "\tb\t%s\n" x
  386. | NonTail(a), CallCls(x, ys, zs) ->
  387. + Printf.fprintf oc "\tmflr\t%s\n" (reg reg_tmp);
  388. g'_args oc [(x, reg_cl)] ys zs;
  389. let ss = stacksize () in
  390. - Printf.fprintf oc "\tst\t%s, [%s + %d]\n" reg_ra reg_sp (ss - 4);
  391. - Printf.fprintf oc "\tld\t[%s + 0], %s\n" reg_cl reg_sw;
  392. - Printf.fprintf oc "\tcall\t%s\n" reg_sw;
  393. - Printf.fprintf oc "\tadd\t%s, %d, %s\t! delay slot\n" reg_sp ss reg_sp;
  394. - Printf.fprintf oc "\tsub\t%s, %d, %s\n" reg_sp ss reg_sp;
  395. - Printf.fprintf oc "\tld\t[%s + %d], %s\n" reg_sp (ss - 4) reg_ra;
  396. + Printf.fprintf oc "\tstw\t%s, %d(%s)\n" (reg reg_tmp) (ss - 4) (reg reg_sp);
  397. + Printf.fprintf oc "\taddi\t%s, %s, %d\n" (reg reg_sp) (reg reg_sp) ss;
  398. + Printf.fprintf oc "\tlwz\t%s, 0(%s)\n" (reg reg_tmp) (reg reg_cl);
  399. + Printf.fprintf oc "\tmtctr\t%s\n" (reg reg_tmp);
  400. + Printf.fprintf oc "\tbctrl\n";
  401. + Printf.fprintf oc "\tsubi\t%s, %s, %d\n" (reg reg_sp) (reg reg_sp) ss;
  402. + Printf.fprintf oc "\tlwz\t%s, %d(%s)\n" (reg reg_tmp) (ss - 4) (reg reg_sp);
  403. if List.mem a allregs && a <> regs.(0) then
  404. - Printf.fprintf oc "\tmov\t%s, %s\n" regs.(0) a
  405. + Printf.fprintf oc "\tmr\t%s, %s\n" (reg a) (reg regs.(0))
  406. else if List.mem a allfregs && a <> fregs.(0) then
  407. - (Printf.fprintf oc "\tfmovs\t%s, %s\n" fregs.(0) a;
  408. - Printf.fprintf oc "\tfmovs\t%s, %s\n" (co_freg fregs.(0)) (co_freg a))
  409. - | NonTail(a), CallDir(Id.L(x), ys, zs) ->
  410. + Printf.fprintf oc "\tfmr\t%s, %s\n" (reg a) (reg fregs.(0));
  411. + Printf.fprintf oc "\tmtlr\t%s\n" (reg reg_tmp)
  412. + | (NonTail(a), CallDir(Id.L(x), ys, zs)) ->
  413. + Printf.fprintf oc "\tmflr\t%s\n" (reg reg_tmp);
  414. g'_args oc [] ys zs;
  415. let ss = stacksize () in
  416. - Printf.fprintf oc "\tst\t%s, [%s + %d]\n" reg_ra reg_sp (ss - 4);
  417. - Printf.fprintf oc "\tcall\t%s\n" x;
  418. - Printf.fprintf oc "\tadd\t%s, %d, %s\t! delay slot\n" reg_sp ss reg_sp;
  419. - Printf.fprintf oc "\tsub\t%s, %d, %s\n" reg_sp ss reg_sp;
  420. - Printf.fprintf oc "\tld\t[%s + %d], %s\n" reg_sp (ss - 4) reg_ra;
  421. + Printf.fprintf oc "\tstw\t%s, %d(%s)\n" (reg reg_tmp) (ss - 4) (reg reg_sp);
  422. + Printf.fprintf oc "\taddi\t%s, %s, %d\n" (reg reg_sp) (reg reg_sp) ss;
  423. + Printf.fprintf oc "\tbl\t%s\n" x;
  424. + Printf.fprintf oc "\tsubi\t%s, %s, %d\n" (reg reg_sp) (reg reg_sp) ss;
  425. + Printf.fprintf oc "\tlwz\t%s, %d(%s)\n" (reg reg_tmp) (ss - 4) (reg reg_sp);
  426. if List.mem a allregs && a <> regs.(0) then
  427. - Printf.fprintf oc "\tmov\t%s, %s\n" regs.(0) a
  428. + Printf.fprintf oc "\tmr\t%s, %s\n" (reg a) (reg regs.(0))
  429. else if List.mem a allfregs && a <> fregs.(0) then
  430. - (Printf.fprintf oc "\tfmovs\t%s, %s\n" fregs.(0) a;
  431. - Printf.fprintf oc "\tfmovs\t%s, %s\n" (co_freg fregs.(0)) (co_freg a))
  432. + Printf.fprintf oc "\tfmr\t%s, %s\n" (reg a) (reg fregs.(0));
  433. + Printf.fprintf oc "\tmtlr\t%s\n" (reg reg_tmp)
  434. and g'_tail_if oc e1 e2 b bn =
  435. let b_else = Id.genid (b ^ "_else") in
  436. - Printf.fprintf oc "\t%s\t%s\n" bn b_else;
  437. - Printf.fprintf oc "\tnop\n";
  438. + Printf.fprintf oc "\t%s\tcr7, %s\n" bn b_else;
  439. let stackset_back = !stackset in
  440. g oc (Tail, e1);
  441. Printf.fprintf oc "%s:\n" b_else;
  442. @@ -193,13 +224,11 @@
  443. and g'_non_tail_if oc dest e1 e2 b bn =
  444. let b_else = Id.genid (b ^ "_else") in
  445. let b_cont = Id.genid (b ^ "_cont") in
  446. - Printf.fprintf oc "\t%s\t%s\n" bn b_else;
  447. - Printf.fprintf oc "\tnop\n";
  448. + Printf.fprintf oc "\t%s\tcr7, %s\n" bn b_else;
  449. let stackset_back = !stackset in
  450. g oc (dest, e1);
  451. let stackset1 = !stackset in
  452. Printf.fprintf oc "\tb\t%s\n" b_cont;
  453. - Printf.fprintf oc "\tnop\n";
  454. Printf.fprintf oc "%s:\n" b_else;
  455. stackset := stackset_back;
  456. g oc (dest, e2);
  457. @@ -213,7 +242,7 @@
  458. (0, x_reg_cl)
  459. ys in
  460. List.iter
  461. - (fun (y, r) -> Printf.fprintf oc "\tmov\t%s, %s\n" y r)
  462. + (fun (y, r) -> Printf.fprintf oc "\tmr\t%s, %s\n" (reg r) (reg y))
  463. (shuffle reg_sw yrs);
  464. let (d, zfrs) =
  465. List.fold_left
  466. @@ -221,9 +250,7 @@
  467. (0, [])
  468. zs in
  469. List.iter
  470. - (fun (z, fr) ->
  471. - Printf.fprintf oc "\tfmovs\t%s, %s\n" z fr;
  472. - Printf.fprintf oc "\tfmovs\t%s, %s\n" (co_freg z) (co_freg fr))
  473. + (fun (z, fr) -> Printf.fprintf oc "\tfmr\t%s, %s\n" (reg fr) (reg z))
  474. (shuffle reg_fsw zfrs)
  475.  
  476. let h oc { name = Id.L(x); args = _; fargs = _; body = e; ret = _ } =
  477. @@ -234,21 +261,32 @@
  478.  
  479. let f oc (Prog(data, fundefs, e)) =
  480. Format.eprintf "generating assembly...@.";
  481. - Printf.fprintf oc ".section\t\".rodata\"\n";
  482. - Printf.fprintf oc ".align\t8\n";
  483. - List.iter
  484. - (fun (Id.L(x), d) ->
  485. - Printf.fprintf oc "%s:\t! %f\n" x d;
  486. - Printf.fprintf oc "\t.long\t0x%lx\n" (gethi d);
  487. - Printf.fprintf oc "\t.long\t0x%lx\n" (getlo d))
  488. - data;
  489. - Printf.fprintf oc ".section\t\".text\"\n";
  490. + if data <> [] then
  491. + (Printf.fprintf oc "\t.data\n\t.literal8\n";
  492. + List.iter
  493. + (fun (Id.L(x), d) ->
  494. + Printf.fprintf oc "\t.align 3\n";
  495. + Printf.fprintf oc "%s:\t # %f\n" x d;
  496. + Printf.fprintf oc "\t.long\t%ld\n" (gethi d);
  497. + Printf.fprintf oc "\t.long\t%ld\n" (getlo d))
  498. + data);
  499. + Printf.fprintf oc "\t.text\n";
  500. + Printf.fprintf oc "\t.globl _min_caml_start\n";
  501. + Printf.fprintf oc "\t.align 2\n";
  502. List.iter (fun fundef -> h oc fundef) fundefs;
  503. - Printf.fprintf oc ".global\tmin_caml_start\n";
  504. - Printf.fprintf oc "min_caml_start:\n";
  505. - Printf.fprintf oc "\tsave\t%%sp, -112, %%sp\n"; (* from gcc; why 112? *)
  506. + Printf.fprintf oc "_min_caml_start: # main entry point\n";
  507. + Printf.fprintf oc "\tmflr\tr0\n";
  508. + Printf.fprintf oc "\tstmw\tr30, -8(r1)\n";
  509. + Printf.fprintf oc "\tstw\tr0, 8(r1)\n";
  510. + Printf.fprintf oc "\tstwu\tr1, -96(r1)\n";
  511. + Printf.fprintf oc "#\tmain program starts\n";
  512. stackset := S.empty;
  513. stackmap := [];
  514. - g oc (NonTail("%g0"), e);
  515. - Printf.fprintf oc "\tret\n";
  516. - Printf.fprintf oc "\trestore\n"
  517. + g oc (NonTail("_R_0"), e);
  518. + Printf.fprintf oc "#\tmain program ends\n";
  519. + (* Printf.fprintf oc "\tmr\tr3, %s\n" regs.(0); *)
  520. + Printf.fprintf oc "\tlwz\tr1, 0(r1)\n";
  521. + Printf.fprintf oc "\tlwz\tr0, 8(r1)\n";
  522. + Printf.fprintf oc "\tmtlr\tr0\n";
  523. + Printf.fprintf oc "\tlmw\tr30, -8(r1)\n";
  524. + Printf.fprintf oc "\tblr\n"
  525. diff -u SPARC/libmincaml.S PowerPC/libmincaml.S
  526. --- SPARC/libmincaml.S 2019-01-04 15:29:53.000000000 +0900
  527. +++ PowerPC/libmincaml.S 2019-01-04 15:29:53.000000000 +0900
  528. @@ -1,197 +1,636 @@
  529. -.section ".text"
  530. -.global min_caml_print_newline
  531. + .cstring
  532. + .align 2
  533. +LC0:
  534. + .ascii "%d\0"
  535. + .align 2
  536. +LC1:
  537. + .ascii "%lf\0"
  538. + .literal8
  539. + .align 3
  540. +LC2:
  541. + .long 1127219200
  542. + .long -2147483648
  543. + .text
  544. + .align 2
  545. + .globl min_caml_print_newline
  546. min_caml_print_newline:
  547. - set 10, %o0
  548. - st %o7, [%i0]
  549. - call putchar
  550. - nop
  551. - ld [%i0], %o7
  552. - retl
  553. - nop
  554. -.global min_caml_print_int
  555. + mflr r0
  556. + stmw r30, -8(r1)
  557. + stw r0, 8(r1)
  558. + stw r3, 12(r1)
  559. + stw r4, 16(r1)
  560. + stwu r1, -80(r1)
  561. + mr r30, r1
  562. + li r3, 10
  563. + bl putchar
  564. + lwz r1, 0(r1)
  565. + lwz r0, 8(r1)
  566. + lwz r3, 12(r1)
  567. + lwz r4, 16(r1)
  568. + mtlr r0
  569. + lmw r30, -8(r1)
  570. + blr
  571. + .section __TEXT, __picsymbolstub1, symbol_stubs, pure_instructions, 32
  572. + .align 5
  573. +putchar:
  574. + .indirect_symbol _putchar
  575. + mflr r0
  576. + bcl 20, 31, L1spb
  577. +L1spb:
  578. + mflr r11
  579. + addis r11, r11, ha16(putchar_lazy-L1spb)
  580. + mtlr r0
  581. + lwzu r12, lo16(putchar_lazy-L1spb)(r11)
  582. + mtctr r12
  583. + bctr
  584. + .lazy_symbol_pointer
  585. +putchar_lazy:
  586. + .indirect_symbol _putchar
  587. + .long dyld_stub_binding_helper
  588. + .subsections_via_symbols
  589. +# print_int
  590. + .text
  591. + .align 2
  592. + .globl min_caml_print_int
  593. min_caml_print_int:
  594. - set format_int, %o0
  595. - mov %i2, %o1
  596. - st %o7, [%i0]
  597. - call printf
  598. - nop
  599. - ld [%i0], %o7
  600. - retl
  601. - nop
  602. -.global min_caml_print_byte
  603. + mflr r0
  604. + stmw r30, -8(r1)
  605. + stw r0, 8(r1)
  606. + stw r3, 12(r1)
  607. + stw r4, 16(r1)
  608. + stwu r1, -80(r1)
  609. + mr r30, r1
  610. + bcl 20, 31, L2pb
  611. +L2pb:
  612. + mflr r31
  613. + mr r4, r2
  614. + addis r2, r31, ha16(LC0 - L2pb)
  615. + la r3, lo16(LC0 - L2pb)(r2)
  616. + bl printf
  617. + lwz r1, 0(r1)
  618. + lwz r0, 8(r1)
  619. + lwz r3, 12(r1)
  620. + lwz r4, 16(r1)
  621. + mtlr r0
  622. + lmw r30, -8(r1)
  623. + blr
  624. + .section __TEXT, __picsymbolstub1, symbol_stubs, pure_instructions, 32
  625. + .align 5
  626. +printf:
  627. + .indirect_symbol _printf$LDBLStub
  628. + mflr r0
  629. + bcl 20, 31, L2spb
  630. +L2spb:
  631. + mflr r11
  632. + addis r11, r11, ha16(printf_lazy-L2spb)
  633. + mtlr r0
  634. + lwzu r12, lo16(printf_lazy-L2spb)(r11)
  635. + mtctr r12
  636. + bctr
  637. + .lazy_symbol_pointer
  638. +printf_lazy:
  639. + .indirect_symbol _printf$LDBLStub
  640. + .long dyld_stub_binding_helper
  641. + .subsections_via_symbols
  642. +# print_byte
  643. + .text
  644. + .align 2
  645. + .globl min_caml_print_byte
  646. min_caml_print_byte:
  647. - mov %i2, %o0
  648. - st %o7, [%i0]
  649. - call putchar
  650. - nop
  651. - ld [%i0], %o7
  652. - retl
  653. - nop
  654. -.global min_caml_prerr_int
  655. + mflr r0
  656. + stmw r30, -8(r1)
  657. + stw r0, 8(r1)
  658. + stw r3, 12(r1)
  659. + stw r4, 16(r1)
  660. + stwu r1, -80(r1)
  661. + mr r30, r1
  662. + stw r3, 104(r30)
  663. + mr r3, r2
  664. + bl putchar
  665. + lwz r1, 0(r1)
  666. + lwz r0, 8(r1)
  667. + lwz r3, 12(r1)
  668. + lwz r4, 16(r1)
  669. + mtlr r0
  670. + lmw r30, -8(r1)
  671. + blr
  672. +# prerr_int
  673. + .text
  674. + .align 2
  675. + .globl min_caml_prerr_int
  676. min_caml_prerr_int:
  677. - set min_caml_stderr, %o0
  678. - set format_int, %o1
  679. - mov %i2, %o2
  680. - st %o7, [%i0]
  681. - call fprintf
  682. - nop
  683. - ld [%i0], %o7
  684. - retl
  685. - nop
  686. -.global min_caml_prerr_byte
  687. + mflr r0
  688. + stmw r30, -8(r1)
  689. + stw r0, 8(r1)
  690. + stw r3, 12(r1)
  691. + stw r4, 16(r1)
  692. + stwu r1, -80(r1)
  693. + mr r30, r1
  694. + bcl 20, 31, L3pb
  695. +L3pb:
  696. + mflr r31
  697. + mr r6, r2
  698. + mr r2, r5
  699. + mr r5, r6
  700. + addis r2, r31, ha16(L - L3pb)
  701. + lwz r2, lo16(L - L3pb)(r2)
  702. + addi r0, r2, 176
  703. + mr r3, r0
  704. + addis r2, r31, ha16(LC0 - L3pb)
  705. + la r4, lo16(LC0 - L3pb)(r2)
  706. + bl fprintf
  707. + lwz r1, 0(r1)
  708. + lwz r0, 8(r1)
  709. + lwz r3, 12(r1)
  710. + lwz r4, 16(r1)
  711. + mtlr r0
  712. + lmw r30, -8(r1)
  713. + blr
  714. + .non_lazy_symbol_pointer
  715. +L:
  716. + .indirect_symbol ___sF
  717. + .long 0
  718. + .section __TEXT, __picsymbolstub1, symbol_stubs, pure_instructions, 32
  719. + .align 5
  720. +fprintf:
  721. + .indirect_symbol _fprintf$LDBLStub
  722. + mflr r0
  723. + bcl 20, 31, L3spb
  724. +L3spb:
  725. + mflr r11
  726. + addis r11, r11, ha16(fprintf_lazy - L3spb)
  727. + mtlr r0
  728. + lwzu r12, lo16(fprintf_lazy - L3spb)(r11)
  729. + mtctr r12
  730. + bctr
  731. + .lazy_symbol_pointer
  732. +fprintf_lazy:
  733. + .indirect_symbol _fprintf$LDBLStub
  734. + .long dyld_stub_binding_helper
  735. + .subsections_via_symbols
  736. +# prerr_byte
  737. + .text
  738. + .align 2
  739. + .globl min_caml_prerr_byte
  740. min_caml_prerr_byte:
  741. - mov %i2, %o0
  742. - set min_caml_stderr, %o1
  743. - st %o7, [%i0]
  744. - call fputc
  745. - nop
  746. - ld [%i0], %o7
  747. - retl
  748. - nop
  749. -.global min_caml_prerr_float
  750. + mflr r0
  751. + stmw r30, -8(r1)
  752. + stw r0, 8(r1)
  753. + stw r3, 12(r1)
  754. + stw r4, 16(r1)
  755. + stwu r1, -80(r1)
  756. + mr r30, r1
  757. + bcl 20, 31, L4pb
  758. +L4pb:
  759. + mflr r31
  760. + mr r3, r2
  761. + addis r2, r31, ha16(L - L4pb)
  762. + lwz r2, lo16(L - L4pb)(r2)
  763. + addi r0, r2, 176
  764. + mr r4, r0
  765. + bl fputc
  766. + lwz r1, 0(r1)
  767. + lwz r0, 8(r1)
  768. + lwz r3, 12(r1)
  769. + lwz r4, 16(r1)
  770. + mtlr r0
  771. + lmw r30, -8(r1)
  772. + blr
  773. + .section __TEXT, __picsymbolstub1, symbol_stubs, pure_instructions, 32
  774. + .align 5
  775. +fputc:
  776. + .indirect_symbol _fputc
  777. + mflr r0
  778. + bcl 20, 31, L4spb
  779. +L4spb:
  780. + mflr r11
  781. + addis r11, r11, ha16(fputc_lazy - L4spb)
  782. + mtlr r0
  783. + lwzu r12, lo16(fputc_lazy - L4spb)(r11)
  784. + mtctr r12
  785. + bctr
  786. + .lazy_symbol_pointer
  787. +fputc_lazy:
  788. + .indirect_symbol _fputc
  789. + .long dyld_stub_binding_helper
  790. + .subsections_via_symbols
  791. +# prerr_float
  792. + .text
  793. + .align 2
  794. + .globl min_caml_prerr_float
  795. min_caml_prerr_float:
  796. - set min_caml_stderr, %o0
  797. - set format_float, %o1
  798. - std %f0, [%i0]
  799. - ldd [%i0], %o2
  800. - st %o7, [%i0]
  801. - call fprintf
  802. - nop
  803. - ld [%i0], %o7
  804. - retl
  805. - nop
  806. -.global min_caml_read_int
  807. + mflr r0
  808. + stmw r29, -12(r1)
  809. + stw r0, 8(r1)
  810. + stw r3, 12(r1)
  811. + stw r4, 16(r1)
  812. + stwu r1, -96(r1)
  813. + mr r30, r1
  814. + bcl 20, 31, L5pb
  815. +L5pb:
  816. + mflr r31
  817. + addis r2, r31, ha16(L - L5pb)
  818. + lwz r2, lo16(L - L5pb)(r2)
  819. + addi r29, r2, 176
  820. + stfd f0, 64(r30)
  821. + lwz r2, 64(r30)
  822. + lwz r3, 68(r30)
  823. + mr r10, r3
  824. + mr r9, r2
  825. + stw r2, 64(r30)
  826. + stw r3, 68(r30)
  827. + lfd f13, 64(r30)
  828. +# fmr f0, f13
  829. + mr r3, r29
  830. + addis r2, r31, ha16(LC1 - L5pb)
  831. + la r4, lo16(LC1 - L5pb)(r2)
  832. + mr r5, r9
  833. + mr r6, r10
  834. + fmr f1, f0
  835. + bl fprintf
  836. + lwz r1, 0(r1)
  837. + lwz r0, 8(r1)
  838. + lwz r3, 12(r1)
  839. + lwz r4, 16(r1)
  840. + mtlr r0
  841. + lmw r29, -12(r1)
  842. + blr
  843. +# read_int
  844. + .text
  845. + .align 2
  846. + .globl min_caml_read_int
  847. min_caml_read_int:
  848. - set format_int, %o0
  849. - st %o7, [%i0]
  850. - call scanf, 0
  851. - add %fp, -20, %o1 ! delay slot
  852. - ld [%i0], %o7
  853. - ld [%fp-20], %i2
  854. - retl
  855. - nop
  856. -.global min_caml_read_float
  857. -min_caml_read_float:
  858. - set format_float, %o0
  859. - st %o7, [%i0]
  860. - call scanf, 0
  861. - add %fp, -24, %o1 ! delay slot
  862. - ld [%i0], %o7
  863. - ldd [%fp-24], %f0
  864. - retl
  865. - nop
  866. -.global min_caml_create_array
  867. -min_caml_create_array:
  868. - mov %i2, %i4
  869. - mov %i1, %i2
  870. + mflr r0
  871. + stmw r30, -8(r1)
  872. + stw r0, 8(r1)
  873. + stw r3, 12(r1)
  874. + stw r4, 16(r1)
  875. + stwu r1, -96(r1)
  876. + mr r30, r1
  877. + bcl 20, 31, L6pb
  878. +L6pb:
  879. + mflr r31
  880. + addis r2, r31, ha16(LC0 - L6pb)
  881. + la r3, lo16(LC0 - L6pb)(r2)
  882. + addi r4, r30, 56
  883. + bl scanf
  884. + lwz r2, 56(r30)
  885. + lwz r1, 0(r1)
  886. + lwz r0, 8(r1)
  887. + lwz r3, 12(r1)
  888. + lwz r4, 16(r1)
  889. + mtlr r0
  890. + lmw r30, -8(r1)
  891. + blr
  892. + .section __TEXT, __picsymbolstub1, symbol_stubs, pure_instructions, 32
  893. + .align 5
  894. +scanf:
  895. + .indirect_symbol _scanf$LDBLStub
  896. + mflr r0
  897. + bcl 20, 31, L6spb
  898. +L6spb:
  899. + mflr r11
  900. + addis r11, r11, ha16(scanf_lazy - L6spb)
  901. + mtlr r0
  902. + lwzu r12, lo16(scanf_lazy - L6spb)(r11)
  903. + mtctr r12
  904. + bctr
  905. + .lazy_symbol_pointer
  906. +scanf_lazy:
  907. + .indirect_symbol _scanf$LDBLStub
  908. + .long dyld_stub_binding_helper
  909. + .subsections_via_symbols
  910. +# read_float
  911. + .text
  912. + .align 2
  913. + .globl min_caml_read_float
  914. +min_caml_read_float:
  915. + mflr r0
  916. + stmw r30, -8(r1)
  917. + stw r0, 8(r1)
  918. + stw r3, 12(r1)
  919. + stw r4, 16(r1)
  920. + stwu r1, -112(r1)
  921. + mr r30, r1
  922. + bcl 20, 31, L7pb
  923. +L7pb:
  924. + mflr r31
  925. + addis r2, r31, ha16(LC1 - L7pb)
  926. + la r3, lo16(LC1 - L7pb)(r2)
  927. + addi r4, r30, 56
  928. + bl scanf
  929. + lfd f0, 56(r30)
  930. + lwz r1, 0(r1)
  931. + lwz r0, 8(r1)
  932. + lwz r3, 12(r1)
  933. + lwz r4, 16(r1)
  934. + mtlr r0
  935. + lmw r30, -8(r1)
  936. + blr
  937. +# create_array
  938. + .text
  939. + .align 2
  940. + .globl min_caml_create_array
  941. +min_caml_create_array:
  942. + mr r6, r2
  943. + mr r2, r4
  944. create_array_loop:
  945. - tst %i4
  946. - bnz create_array_cont
  947. - nop
  948. - andcc %i1, 4, %g0
  949. - bz create_array_exit
  950. - nop
  951. - add %i1, 4, %i1
  952. + cmpwi cr7, r6, 0
  953. + bne cr7, create_array_cont
  954. + b create_array_exit
  955. create_array_exit:
  956. - retl
  957. - nop
  958. + blr
  959. create_array_cont:
  960. - st %i3, [%i1]
  961. - dec %i4
  962. - add %i1, 4, %i1
  963. + stw r5, 0(r4)
  964. + subi r6, r6, 1
  965. + addi r4, r4, 4
  966. b create_array_loop
  967. - nop
  968. -.global min_caml_create_float_array
  969. +# create_float_array
  970. + .globl min_caml_create_float_array
  971. min_caml_create_float_array:
  972. - mov %i2, %i3
  973. - mov %i1, %i2
  974. + mr r5, r2
  975. + mr r2, r4
  976. create_float_array_loop:
  977. - tst %i3
  978. - bnz create_float_array_cont
  979. - nop
  980. - retl
  981. - nop
  982. + cmpwi cr7, r5, 0
  983. + bne cr7, create_float_array_cont
  984. + blr
  985. create_float_array_cont:
  986. - std %f0, [%i1]
  987. - dec %i3
  988. - add %i1, 8, %i1
  989. + stfd f0, 0(r4)
  990. + subi r5, r5, 1
  991. + addi r4, r4, 8
  992. b create_float_array_loop
  993. - nop
  994. -.global min_caml_abs_float
  995. + .globl min_caml_abs_float
  996. min_caml_abs_float:
  997. - fabss %f0, %f0
  998. - retl
  999. - nop
  1000. -.global min_caml_sqrt
  1001. + fabs f0, f0
  1002. + blr
  1003. +# sqrt
  1004. + .text
  1005. + .align 2
  1006. + .globl min_caml_sqrt
  1007. min_caml_sqrt:
  1008. - fsqrtd %f0, %f0
  1009. - retl
  1010. - nop
  1011. -.global min_caml_floor
  1012. + mflr r0
  1013. + stmw r30, -8(r1)
  1014. + stw r0, 8(r1)
  1015. + stw r3, 12(r1)
  1016. + stw r4, 16(r1)
  1017. + stwu r1, -96(r1)
  1018. + mr r30, r1
  1019. + bcl 20, 31, L8pb
  1020. +L8pb:
  1021. + mflr r31
  1022. + fmr f1, f0
  1023. + bl sqrt
  1024. + fmr f0, f1
  1025. + lwz r1, 0(r1)
  1026. + lwz r0, 8(r1)
  1027. + lwz r3, 12(r1)
  1028. + lwz r4, 16(r1)
  1029. + mtlr r0
  1030. + lmw r30, -8(r1)
  1031. + blr
  1032. + .section __TEXT, __picsymbolstub1, symbol_stubs, pure_instructions, 32
  1033. + .align 5
  1034. +sqrt:
  1035. + .indirect_symbol _sqrt
  1036. + mflr r0
  1037. + bcl 20, 31, L8spb
  1038. +L8spb:
  1039. + mflr r11
  1040. + addis r11, r11, ha16(sqrt_lazy - L8spb)
  1041. + mtlr r0
  1042. + lwzu r12, lo16(sqrt_lazy - L8spb)(r11)
  1043. + mtctr r12
  1044. + bctr
  1045. + .lazy_symbol_pointer
  1046. +sqrt_lazy:
  1047. + .indirect_symbol _sqrt
  1048. + .long dyld_stub_binding_helper
  1049. + .subsections_via_symbols
  1050. +# floor
  1051. + .text
  1052. + .align 2
  1053. + .globl min_caml_floor
  1054. min_caml_floor:
  1055. - std %f0, [%i0]
  1056. - ldd [%i0], %o0
  1057. - st %o7, [%i0]
  1058. - call floor
  1059. - nop
  1060. - ld [%i0], %o7
  1061. - retl
  1062. - nop
  1063. -.global min_caml_int_of_float
  1064. + mflr r0
  1065. + stmw r30, -8(r1)
  1066. + stw r0, 8(r1)
  1067. + stw r3, 12(r1)
  1068. + stw r4, 16(r1)
  1069. + stwu r1, -80(r1)
  1070. + mr r30, r1
  1071. + fmr f1, f0
  1072. + stfd f1, 56(r30)
  1073. + lfd f1, 56(r30)
  1074. + bl floor
  1075. + fmr f0, f1
  1076. + lwz r1, 0(r1)
  1077. + lwz r0, 8(r1)
  1078. + lwz r3, 12(r1)
  1079. + lwz r4, 16(r1)
  1080. + mtlr r0
  1081. + lmw r30, -8(r1)
  1082. + blr
  1083. + .section __TEXT, __picsymbolstub1, symbol_stubs, pure_instructions, 32
  1084. + .align 5
  1085. +floor:
  1086. + .indirect_symbol _floor
  1087. + mflr r0
  1088. + bcl 20, 31, L9spb
  1089. +L9spb:
  1090. + mflr r11
  1091. + addis r11, r11, ha16(floor_lazy - L9spb)
  1092. + mtlr r0
  1093. + lwzu r12, lo16(floor_lazy - L9spb)(r11)
  1094. + mtctr r12
  1095. + bctr
  1096. + .lazy_symbol_pointer
  1097. +floor_lazy:
  1098. + .indirect_symbol _floor
  1099. + .long dyld_stub_binding_helper
  1100. + .subsections_via_symbols
  1101. +# int_of_float, truncate
  1102. + .text
  1103. + .align 2
  1104. + .globl min_caml_int_of_float
  1105. min_caml_int_of_float:
  1106. -.global min_caml_truncate
  1107. + .globl min_caml_truncate
  1108. min_caml_truncate:
  1109. - fdtoi %f0, %f0
  1110. - st %f0, [%i0]
  1111. - ld [%i0], %i2
  1112. - retl
  1113. - nop
  1114. -.global min_caml_float_of_int
  1115. + stmw r30, -8(r1)
  1116. + stwu r1, -64(r1)
  1117. + mr r30, r1
  1118. + stfd f0, 24(r30)
  1119. + lfd f1, 24(r30)
  1120. + fctiwz f1, f1
  1121. + stfd f1, 32(r30)
  1122. + lwz r31, 36(r30)
  1123. + mr r2, r31
  1124. + lwz r1, 0(r1)
  1125. + lmw r30, -8(r1)
  1126. + blr
  1127. +# float_of_int
  1128. + .globl min_caml_float_of_int
  1129. min_caml_float_of_int:
  1130. - st %i2, [%i0]
  1131. - ld [%i0], %f0
  1132. - fitod %f0, %f0
  1133. - retl
  1134. - nop
  1135. -.global min_caml_cos
  1136. + stmw r30, -8(r1)
  1137. + stw r3, 8(r1)
  1138. + stw r4, 12(r1)
  1139. + stwu r1, -48(r1)
  1140. + mr r30, r1
  1141. + mflr r0
  1142. + bcl 20, 31, Lapb
  1143. +Lapb:
  1144. + mflr r10
  1145. + mtlr r0
  1146. + stw r2, 72(r30)
  1147. + lwz r0, 72(r30)
  1148. + lis r2, 0x4330
  1149. + addis r9, r10, ha16(LC2 - Lapb)
  1150. + lfd f13, lo16(LC2 - Lapb)(r9)
  1151. + xoris r0, r0, 0x8000
  1152. + stw r0, 28(r30)
  1153. + stw r2, 24(r30)
  1154. + lfd f0, 24(r30)
  1155. + fsub f0, f0, f13
  1156. + lwz r1, 0(r1)
  1157. + lwz r3, 8(r1)
  1158. + lwz r4, 12(r1)
  1159. + lmw r30, -8(r1)
  1160. + blr
  1161. +# cos
  1162. + .text
  1163. + .align 2
  1164. + .globl min_caml_cos
  1165. min_caml_cos:
  1166. - std %f0, [%i0]
  1167. - ldd [%i0], %o0
  1168. - st %o7, [%i0]
  1169. - call cos
  1170. - nop
  1171. - ld [%i0], %o7
  1172. - retl
  1173. - nop
  1174. -.global min_caml_sin
  1175. + mflr r0
  1176. + stmw r30, -8(r1)
  1177. + stw r0, 8(r1)
  1178. + stw r3, 12(r1)
  1179. + stw r4, 16(r1)
  1180. + stwu r1, -96(r1)
  1181. + mr r30, r1
  1182. + bcl 20, 31, Lbpb
  1183. +Lbpb:
  1184. + mflr r31
  1185. + fmr f1, f0
  1186. + bl cos
  1187. + fmr f0, f1
  1188. + lwz r1, 0(r1)
  1189. + lwz r0, 8(r1)
  1190. + lwz r3, 12(r1)
  1191. + lwz r4, 16(r1)
  1192. + mtlr r0
  1193. + lmw r30, -8(r1)
  1194. + blr
  1195. + .section __TEXT, __picsymbolstub1, symbol_stubs, pure_instructions, 32
  1196. + .align 5
  1197. +cos:
  1198. + .indirect_symbol _cos
  1199. + mflr r0
  1200. + bcl 20, 31, Lbspb
  1201. +Lbspb:
  1202. + mflr r11
  1203. + addis r11, r11, ha16(cos_lazy - Lbspb)
  1204. + mtlr r0
  1205. + lwzu r12,lo16(cos_lazy - Lbspb)(r11)
  1206. + mtctr r12
  1207. + bctr
  1208. + .lazy_symbol_pointer
  1209. +cos_lazy:
  1210. + .indirect_symbol _cos
  1211. + .long dyld_stub_binding_helper
  1212. + .subsections_via_symbols
  1213. +# sin
  1214. + .text
  1215. + .align 2
  1216. + .globl min_caml_sin
  1217. min_caml_sin:
  1218. - std %f0, [%i0]
  1219. - ldd [%i0], %o0
  1220. - st %o7, [%i0]
  1221. - call sin
  1222. - nop
  1223. - ld [%i0], %o7
  1224. - retl
  1225. - nop
  1226. -.global min_caml_atan
  1227. + mflr r0
  1228. + stmw r30, -8(r1)
  1229. + stw r0, 8(r1)
  1230. + stw r3, 12(r1)
  1231. + stw r4, 16(r1)
  1232. + stwu r1, -96(r1)
  1233. + mr r30, r1
  1234. + bcl 20, 31, Lcpb
  1235. +Lcpb:
  1236. + mflr r31
  1237. + fmr f1, f0
  1238. + bl sin
  1239. + fmr f0, f1
  1240. + lwz r1, 0(r1)
  1241. + lwz r0, 8(r1)
  1242. + lwz r3, 12(r1)
  1243. + lwz r4, 16(r1)
  1244. + mtlr r0
  1245. + lmw r30, -8(r1)
  1246. + blr
  1247. + .section __TEXT, __picsymbolstub1, symbol_stubs, pure_instructions, 32
  1248. + .align 5
  1249. +sin:
  1250. + .indirect_symbol _sin
  1251. + mflr r0
  1252. + bcl 20, 31, Lcspb
  1253. +Lcspb:
  1254. + mflr r11
  1255. + addis r11, r11, ha16(sin_lazy - Lcspb)
  1256. + mtlr r0
  1257. + lwzu r12, lo16(sin_lazy - Lcspb)(r11)
  1258. + mtctr r12
  1259. + bctr
  1260. + .lazy_symbol_pointer
  1261. +sin_lazy:
  1262. + .indirect_symbol _sin
  1263. + .long dyld_stub_binding_helper
  1264. + .subsections_via_symbols
  1265. +# atan
  1266. + .text
  1267. + .align 2
  1268. + .globl min_caml_atan
  1269. min_caml_atan:
  1270. - std %f0, [%i0]
  1271. - ldd [%i0], %o0
  1272. - st %o7, [%i0]
  1273. - call atan
  1274. - nop
  1275. - ld [%i0], %o7
  1276. - retl
  1277. - nop
  1278. -.section ".rodata"
  1279. -format_int:
  1280. - .asciz "%d"
  1281. -format_float:
  1282. - .asciz "%lf"
  1283. -.align 8
  1284. + mflr r0
  1285. + stmw r30, -8(r1)
  1286. + stw r0, 8(r1)
  1287. + stw r3, 12(r1)
  1288. + stw r4, 16(r1)
  1289. + stwu r1, -96(r1)
  1290. + mr r30, r1
  1291. + bcl 20, 31, Ldpb
  1292. +Ldpb:
  1293. + mflr r31
  1294. + fmr f1, f0
  1295. + bl atan
  1296. + fmr f0, f1
  1297. + lwz r1, 0(r1)
  1298. + lwz r0, 8(r1)
  1299. + lwz r3, 12(r1)
  1300. + lwz r4, 16(r1)
  1301. + mtlr r0
  1302. + lmw r30, -8(r1)
  1303. + blr
  1304. + .section __TEXT, __picsymbolstub1, symbol_stubs, pure_instructions, 32
  1305. + .align 5
  1306. +atan:
  1307. + .indirect_symbol _atan
  1308. + mflr r0
  1309. + bcl 20, 31, Ldspb
  1310. +Ldspb:
  1311. + mflr r11
  1312. + addis r11, r11, ha16(atan_lazy - Ldspb)
  1313. + mtlr r0
  1314. + lwzu r12, lo16(atan_lazy - Ldspb)(r11)
  1315. + mtctr r12
  1316. + bctr
  1317. + .lazy_symbol_pointer
  1318. +atan_lazy:
  1319. + .indirect_symbol _atan
  1320. + .long dyld_stub_binding_helper
  1321. + .subsections_via_symbols
  1322. + .const
  1323. + .align 8
  1324. float_0:
  1325. .long 0x0
  1326. .long 0x0
  1327. float_1:
  1328. .long 0x3ff00000
  1329. .long 0x0
  1330. +
  1331. +
  1332. diff -u SPARC/regAlloc.ml PowerPC/regAlloc.ml
  1333. --- SPARC/regAlloc.ml 2019-03-19 21:12:59.000000000 +0900
  1334. +++ PowerPC/regAlloc.ml 2019-03-19 21:12:59.000000000 +0900
  1335. @@ -4,11 +4,11 @@
  1336. (* [XXX] Callがあったら、そこから先は無意味というか逆効果なので追わない。
  1337. そのために「Callがあったかどうか」を返り値の第1要素に含める。 *)
  1338. let rec target' src (dest, t) = function
  1339. - | Mov(x) when x = src && is_reg dest ->
  1340. + | Mr(x) when x = src && is_reg dest ->
  1341. assert (t <> Type.Unit);
  1342. assert (t <> Type.Float);
  1343. false, [dest]
  1344. - | FMovD(x) when x = src && is_reg dest ->
  1345. + | FMr(x) when x = src && is_reg dest ->
  1346. assert (t = Type.Float);
  1347. false, [dest]
  1348. | IfEq(_, _, e1, e2) | IfLE(_, _, e1, e2) | IfGE(_, _, e1, e2)
  1349. @@ -44,10 +44,10 @@
  1350. assert (not (M.mem x regenv));
  1351. let all =
  1352. match t with
  1353. - | Type.Unit -> ["%g0"] (* dummy *)
  1354. + | Type.Unit -> ["%r0"] (* dummy *)
  1355. | Type.Float -> allfregs
  1356. | _ -> allregs in
  1357. - if all = ["%g0"] then Alloc("%g0") else (* [XX] ad hoc optimization *)
  1358. + if all = ["%r0"] then Alloc("%r0") else (* [XX] ad hoc optimization *)
  1359. if is_reg x then Alloc(x) else
  1360. let free = fv cont in
  1361. try
  1362. @@ -117,22 +117,22 @@
  1363. ((* Format.eprintf "restoring %s@." x; *)
  1364. g dest cont regenv (Let((x, t), Restore(x), Ans(exp))))
  1365. and g' dest cont regenv = function (* 各命令のレジスタ割り当て (caml2html: regalloc_gprime) *)
  1366. - | Nop | Set _ | SetL _ | Comment _ | Restore _ as exp -> (Ans(exp), regenv)
  1367. - | Mov(x) -> (Ans(Mov(find x Type.Int regenv)), regenv)
  1368. + | Nop | Li _ | SetL _ | Comment _ | Restore _ | FLi _ as exp -> (Ans(exp), regenv)
  1369. + | Mr(x) -> (Ans(Mr(find x Type.Int regenv)), regenv)
  1370. | Neg(x) -> (Ans(Neg(find x Type.Int regenv)), regenv)
  1371. | Add(x, y') -> (Ans(Add(find x Type.Int regenv, find' y' regenv)), regenv)
  1372. | Sub(x, y') -> (Ans(Sub(find x Type.Int regenv, find' y' regenv)), regenv)
  1373. - | SLL(x, y') -> (Ans(SLL(find x Type.Int regenv, find' y' regenv)), regenv)
  1374. - | Ld(x, y') -> (Ans(Ld(find x Type.Int regenv, find' y' regenv)), regenv)
  1375. - | St(x, y, z') -> (Ans(St(find x Type.Int regenv, find y Type.Int regenv, find' z' regenv)), regenv)
  1376. - | FMovD(x) -> (Ans(FMovD(find x Type.Float regenv)), regenv)
  1377. - | FNegD(x) -> (Ans(FNegD(find x Type.Float regenv)), regenv)
  1378. - | FAddD(x, y) -> (Ans(FAddD(find x Type.Float regenv, find y Type.Float regenv)), regenv)
  1379. - | FSubD(x, y) -> (Ans(FSubD(find x Type.Float regenv, find y Type.Float regenv)), regenv)
  1380. - | FMulD(x, y) -> (Ans(FMulD(find x Type.Float regenv, find y Type.Float regenv)), regenv)
  1381. - | FDivD(x, y) -> (Ans(FDivD(find x Type.Float regenv, find y Type.Float regenv)), regenv)
  1382. - | LdDF(x, y') -> (Ans(LdDF(find x Type.Int regenv, find' y' regenv)), regenv)
  1383. - | StDF(x, y, z') -> (Ans(StDF(find x Type.Float regenv, find y Type.Int regenv, find' z' regenv)), regenv)
  1384. + | Slw(x, y') -> (Ans(Slw(find x Type.Int regenv, find' y' regenv)), regenv)
  1385. + | Lwz(x, y') -> (Ans(Lwz(find x Type.Int regenv, find' y' regenv)), regenv)
  1386. + | Stw(x, y, z') -> (Ans(Stw(find x Type.Int regenv, find y Type.Int regenv, find' z' regenv)), regenv)
  1387. + | FMr(x) -> (Ans(FMr(find x Type.Float regenv)), regenv)
  1388. + | FNeg(x) -> (Ans(FNeg(find x Type.Float regenv)), regenv)
  1389. + | FAdd(x, y) -> (Ans(FAdd(find x Type.Float regenv, find y Type.Float regenv)), regenv)
  1390. + | FSub(x, y) -> (Ans(FSub(find x Type.Float regenv, find y Type.Float regenv)), regenv)
  1391. + | FMul(x, y) -> (Ans(FMul(find x Type.Float regenv, find y Type.Float regenv)), regenv)
  1392. + | FDiv(x, y) -> (Ans(FDiv(find x Type.Float regenv, find y Type.Float regenv)), regenv)
  1393. + | Lfd(x, y') -> (Ans(Lfd(find x Type.Int regenv, find' y' regenv)), regenv)
  1394. + | Stfd(x, y, z') -> (Ans(Stfd(find x Type.Float regenv, find y Type.Int regenv, find' z' regenv)), regenv)
  1395. | IfEq(x, y', e1, e2) as exp -> g'_if dest cont regenv exp (fun e1' e2' -> IfEq(find x Type.Int regenv, find' y' regenv, e1', e2')) e1 e2
  1396. | IfLE(x, y', e1, e2) as exp -> g'_if dest cont regenv exp (fun e1' e2' -> IfLE(find x Type.Int regenv, find' y' regenv, e1', e2')) e1 e2
  1397. | IfGE(x, y', e1, e2) as exp -> g'_if dest cont regenv exp (fun e1' e2' -> IfGE(find x Type.Int regenv, find' y' regenv, e1', e2')) e1 e2
  1398. @@ -209,7 +209,7 @@
  1399. | Type.Unit -> Id.gentmp Type.Unit
  1400. | Type.Float -> fregs.(0)
  1401. | _ -> regs.(0) in
  1402. - let (e', regenv') = g (a, t) (Ans(Mov(a))) regenv e in
  1403. + let (e', regenv') = g (a, t) (Ans(Mr(a))) regenv e in
  1404. { name = Id.L(x); args = arg_regs; fargs = farg_regs; body = e'; ret = t }
  1405.  
  1406. let f (Prog(data, fundefs, e)) = (* プログラム全体のレジスタ割り当て (caml2html: regalloc_f) *)
  1407. diff -u SPARC/simm.ml PowerPC/simm.ml
  1408. --- SPARC/simm.ml 2019-03-19 21:12:59.000000000 +0900
  1409. +++ PowerPC/simm.ml 2019-03-19 21:12:59.000000000 +0900
  1410. @@ -1,26 +1,26 @@
  1411. open Asm
  1412.  
  1413. -let rec g env = function (* 命令列の13bit即値最適化 (caml2html: simm13_g) *)
  1414. +let rec g env = function (* 命令列の16bit即値最適化 (caml2html: simm13_g) *)
  1415. | Ans(exp) -> Ans(g' env exp)
  1416. - | Let((x, t), Set(i), e) when -4096 <= i && i < 4096 ->
  1417. - (* Format.eprintf "found simm13 %s = %d@." x i; *)
  1418. + | Let((x, t), Li(i), e) when -32768 <= i && i < 32768 ->
  1419. + (* Format.eprintf "found simm16 %s = %d@." x i; *)
  1420. let e' = g (M.add x i env) e in
  1421. - if List.mem x (fv e') then Let((x, t), Set(i), e') else
  1422. + if List.mem x (fv e') then Let((x, t), Li(i), e') else
  1423. ((* Format.eprintf "erased redundant Set to %s@." x; *)
  1424. e')
  1425. - | Let(xt, SLL(y, C(i)), e) when M.mem y env -> (* for array access *)
  1426. - (* Format.eprintf "erased redundant SLL on %s@." x; *)
  1427. - g env (Let(xt, Set((M.find y env) lsl i), e))
  1428. + | Let(xt, Slw(y, C(i)), e) when M.mem y env -> (* for array access *)
  1429. + (* Format.eprintf "erased redundant Slw on %s@." x; *)
  1430. + g env (Let(xt, Li((M.find y env) lsl i), e))
  1431. | Let(xt, exp, e) -> Let(xt, g' env exp, g env e)
  1432. -and g' env = function (* 各命令の13bit即値最適化 (caml2html: simm13_gprime) *)
  1433. +and g' env = function (* 各命令の16bit即値最適化 (caml2html: simm13_gprime) *)
  1434. | Add(x, V(y)) when M.mem y env -> Add(x, C(M.find y env))
  1435. | Add(x, V(y)) when M.mem x env -> Add(y, C(M.find x env))
  1436. | Sub(x, V(y)) when M.mem y env -> Sub(x, C(M.find y env))
  1437. - | SLL(x, V(y)) when M.mem y env -> SLL(x, C(M.find y env))
  1438. - | Ld(x, V(y)) when M.mem y env -> Ld(x, C(M.find y env))
  1439. - | St(x, y, V(z)) when M.mem z env -> St(x, y, C(M.find z env))
  1440. - | LdDF(x, V(y)) when M.mem y env -> LdDF(x, C(M.find y env))
  1441. - | StDF(x, y, V(z)) when M.mem z env -> StDF(x, y, C(M.find z env))
  1442. + | Slw(x, V(y)) when M.mem y env -> Slw(x, C(M.find y env))
  1443. + | Lwz(x, V(y)) when M.mem y env -> Lwz(x, C(M.find y env))
  1444. + | Stw(x, y, V(z)) when M.mem z env -> Stw(x, y, C(M.find z env))
  1445. + | Lfd(x, V(y)) when M.mem y env -> Lfd(x, C(M.find y env))
  1446. + | Stfd(x, y, V(z)) when M.mem z env -> Stfd(x, y, C(M.find z env))
  1447. | IfEq(x, V(y), e1, e2) when M.mem y env -> IfEq(x, C(M.find y env), g env e1, g env e2)
  1448. | IfLE(x, V(y), e1, e2) when M.mem y env -> IfLE(x, C(M.find y env), g env e1, g env e2)
  1449. | IfGE(x, V(y), e1, e2) when M.mem y env -> IfGE(x, C(M.find y env), g env e1, g env e2)
  1450. @@ -34,8 +34,8 @@
  1451. | IfFLE(x, y, e1, e2) -> IfFLE(x, y, g env e1, g env e2)
  1452. | e -> e
  1453.  
  1454. -let h { name = l; args = xs; fargs = ys; body = e; ret = t } = (* トップレベル関数の13bit即値最適化 *)
  1455. +let h { name = l; args = xs; fargs = ys; body = e; ret = t } = (* トップレベル関数の16bit即値最適化 *)
  1456. { name = l; args = xs; fargs = ys; body = g M.empty e; ret = t }
  1457.  
  1458. -let f (Prog(data, fundefs, e)) = (* プログラム全体の13bit即値最適化 *)
  1459. +let f (Prog(data, fundefs, e)) = (* プログラム全体の16bit即値最適化 *)
  1460. Prog(data, List.map h fundefs, g M.empty e)
  1461. diff -u SPARC/virtual.ml PowerPC/virtual.ml
  1462. --- SPARC/virtual.ml 2019-03-19 21:12:59.000000000 +0900
  1463. +++ PowerPC/virtual.ml 2019-03-19 21:12:59.000000000 +0900
  1464. @@ -1,4 +1,4 @@
  1465. -(* translation into SPARC assembly with infinite number of virtual registers *)
  1466. +(* translation into PowerPC assembly with infinite number of virtual registers *)
  1467.  
  1468. open Asm
  1469.  
  1470. @@ -33,7 +33,7 @@
  1471.  
  1472. let rec g env = function (* 式の仮想マシンコード生成 (caml2html: virtual_g) *)
  1473. | Closure.Unit -> Ans(Nop)
  1474. - | Closure.Int(i) -> Ans(Set(i))
  1475. + | Closure.Int(i) -> Ans(Li(i))
  1476. | Closure.Float(d) ->
  1477. let l =
  1478. try
  1479. @@ -44,16 +44,15 @@
  1480. let l = Id.L(Id.genid "l") in
  1481. data := (l, d) :: !data;
  1482. l in
  1483. - let x = Id.genid "l" in
  1484. - Let((x, Type.Int), SetL(l), Ans(LdDF(x, C(0))))
  1485. + Ans(FLi(l))
  1486. | Closure.Neg(x) -> Ans(Neg(x))
  1487. | Closure.Add(x, y) -> Ans(Add(x, V(y)))
  1488. | Closure.Sub(x, y) -> Ans(Sub(x, V(y)))
  1489. - | Closure.FNeg(x) -> Ans(FNegD(x))
  1490. - | Closure.FAdd(x, y) -> Ans(FAddD(x, y))
  1491. - | Closure.FSub(x, y) -> Ans(FSubD(x, y))
  1492. - | Closure.FMul(x, y) -> Ans(FMulD(x, y))
  1493. - | Closure.FDiv(x, y) -> Ans(FDivD(x, y))
  1494. + | Closure.FNeg(x) -> Ans(FNeg(x))
  1495. + | Closure.FAdd(x, y) -> Ans(FAdd(x, y))
  1496. + | Closure.FSub(x, y) -> Ans(FSub(x, y))
  1497. + | Closure.FMul(x, y) -> Ans(FMul(x, y))
  1498. + | Closure.FDiv(x, y) -> Ans(FDiv(x, y))
  1499. | Closure.IfEq(x, y, e1, e2) ->
  1500. (match M.find x env with
  1501. | Type.Bool | Type.Int -> Ans(IfEq(x, V(y), g env e1, g env e2))
  1502. @@ -71,8 +70,8 @@
  1503. | Closure.Var(x) ->
  1504. (match M.find x env with
  1505. | Type.Unit -> Ans(Nop)
  1506. - | Type.Float -> Ans(FMovD(x))
  1507. - | _ -> Ans(Mov(x)))
  1508. + | Type.Float -> Ans(FMr(x))
  1509. + | _ -> Ans(Mr(x)))
  1510. | Closure.MakeCls((x, t), { Closure.entry = l; Closure.actual_fv = ys }, e2) -> (* クロージャの生成 (caml2html: virtual_makecls) *)
  1511. (* Closureのアドレスをセットしてから、自由変数の値をストア *)
  1512. let e2' = g (M.add x t env) e2 in
  1513. @@ -80,13 +79,13 @@
  1514. expand
  1515. (List.map (fun y -> (y, M.find y env)) ys)
  1516. (4, e2')
  1517. - (fun y offset store_fv -> seq(StDF(y, x, C(offset)), store_fv))
  1518. - (fun y _ offset store_fv -> seq(St(y, x, C(offset)), store_fv)) in
  1519. - Let((x, t), Mov(reg_hp),
  1520. + (fun y offset store_fv -> seq(Stfd(y, x, C(offset)), store_fv))
  1521. + (fun y _ offset store_fv -> seq(Stw(y, x, C(offset)), store_fv)) in
  1522. + Let((x, t), Mr(reg_hp),
  1523. Let((reg_hp, Type.Int), Add(reg_hp, C(align offset)),
  1524. let z = Id.genid "l" in
  1525. Let((z, Type.Int), SetL(l),
  1526. - seq(St(z, x, C(0)),
  1527. + seq(Stw(z, x, C(0)),
  1528. store_fv))))
  1529. | Closure.AppCls(x, ys) ->
  1530. let (int, float) = separate (List.map (fun y -> (y, M.find y env)) ys) in
  1531. @@ -99,10 +98,10 @@
  1532. let (offset, store) =
  1533. expand
  1534. (List.map (fun x -> (x, M.find x env)) xs)
  1535. - (0, Ans(Mov(y)))
  1536. - (fun x offset store -> seq(StDF(x, y, C(offset)), store))
  1537. - (fun x _ offset store -> seq(St(x, y, C(offset)), store)) in
  1538. - Let((y, Type.Tuple(List.map (fun x -> M.find x env) xs)), Mov(reg_hp),
  1539. + (0, Ans(Mr(y)))
  1540. + (fun x offset store -> seq(Stfd(x, y, C(offset)), store))
  1541. + (fun x _ offset store -> seq(Stw(x, y, C(offset)), store)) in
  1542. + Let((y, Type.Tuple(List.map (fun x -> M.find x env) xs)), Mr(reg_hp),
  1543. Let((reg_hp, Type.Int), Add(reg_hp, C(align offset)),
  1544. store))
  1545. | Closure.LetTuple(xts, y, e2) ->
  1546. @@ -113,32 +112,32 @@
  1547. (0, g (M.add_list xts env) e2)
  1548. (fun x offset load ->
  1549. if not (S.mem x s) then load else (* [XX] a little ad hoc optimization *)
  1550. - fletd(x, LdDF(y, C(offset)), load))
  1551. + fletd(x, Lfd(y, C(offset)), load))
  1552. (fun x t offset load ->
  1553. if not (S.mem x s) then load else (* [XX] a little ad hoc optimization *)
  1554. - Let((x, t), Ld(y, C(offset)), load)) in
  1555. + Let((x, t), Lwz(y, C(offset)), load)) in
  1556. load
  1557. | Closure.Get(x, y) -> (* 配列の読み出し (caml2html: virtual_get) *)
  1558. let offset = Id.genid "o" in
  1559. (match M.find x env with
  1560. | Type.Array(Type.Unit) -> Ans(Nop)
  1561. | Type.Array(Type.Float) ->
  1562. - Let((offset, Type.Int), SLL(y, C(3)),
  1563. - Ans(LdDF(x, V(offset))))
  1564. + Let((offset, Type.Int), Slw(y, C(3)),
  1565. + Ans(Lfd(x, V(offset))))
  1566. | Type.Array(_) ->
  1567. - Let((offset, Type.Int), SLL(y, C(2)),
  1568. - Ans(Ld(x, V(offset))))
  1569. + Let((offset, Type.Int), Slw(y, C(2)),
  1570. + Ans(Lwz(x, V(offset))))
  1571. | _ -> assert false)
  1572. | Closure.Put(x, y, z) ->
  1573. let offset = Id.genid "o" in
  1574. (match M.find x env with
  1575. | Type.Array(Type.Unit) -> Ans(Nop)
  1576. | Type.Array(Type.Float) ->
  1577. - Let((offset, Type.Int), SLL(y, C(3)),
  1578. - Ans(StDF(z, x, V(offset))))
  1579. + Let((offset, Type.Int), Slw(y, C(3)),
  1580. + Ans(Stfd(z, x, V(offset))))
  1581. | Type.Array(_) ->
  1582. - Let((offset, Type.Int), SLL(y, C(2)),
  1583. - Ans(St(z, x, V(offset))))
  1584. + Let((offset, Type.Int), Slw(y, C(2)),
  1585. + Ans(Stw(z, x, V(offset))))
  1586. | _ -> assert false)
  1587. | Closure.ExtArray(Id.L(x)) -> Ans(SetL(Id.L("min_caml_" ^ x)))
  1588.  
  1589. @@ -149,8 +148,8 @@
  1590. expand
  1591. zts
  1592. (4, g (M.add x t (M.add_list yts (M.add_list zts M.empty))) e)
  1593. - (fun z offset load -> fletd(z, LdDF(x, C(offset)), load))
  1594. - (fun z t offset load -> Let((z, t), Ld(x, C(offset)), load)) in
  1595. + (fun z offset load -> fletd(z, Lfd(x, C(offset)), load))
  1596. + (fun z t offset load -> Let((z, t), Lwz(x, C(offset)), load)) in
  1597. match t with
  1598. | Type.Fun(_, t2) ->
  1599. { name = Id.L(x); args = int; fargs = float; body = load; ret = t2 }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!