Home My Page Projects Code Snippets Project Openings SML/NJ
Summary Activity Forums Tracker Lists Tasks Docs Surveys News SCM Files

SCM Repository

[smlnj] Annotation of /sml/branches/SMLNJ/src/MLRISC/hppa/hppa.sml
ViewVC logotype

Annotation of /sml/branches/SMLNJ/src/MLRISC/hppa/hppa.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 113 - (view) (download)

1 : monnier 16 (* hppa.sml
2 :     *
3 :     * COPYRIGHT (c) 1996 AT&T Bell Laboratories.
4 :     *
5 :     * generates machine code from the mltree.
6 :     *
7 :     *)
8 :     functor Hppa
9 :     (structure Flowgen : FLOWGRAPH_GEN
10 :     structure HppaInstr : HPPAINSTR
11 :     structure HppaMLTree : MLTREE
12 :     structure MilliCode : HPPA_MILLICODE
13 :     structure LabelComp : LABEL_COMP
14 :    
15 :     sharing Flowgen.I = MilliCode.I = LabelComp.I = HppaInstr
16 :     sharing Flowgen.T = LabelComp.T = HppaMLTree
17 :     sharing HppaMLTree.Region = HppaInstr.Region
18 :     sharing HppaMLTree.Constant = HppaInstr.Constant) : MLTREECOMP =
19 :     struct
20 :     structure I = HppaInstr
21 :     structure F = Flowgen
22 :     structure T = HppaMLTree
23 :     structure C = HppaCells
24 :     structure MC = MilliCode
25 :     structure LC = LabelComp
26 :     structure Region = I.Region
27 :    
28 :     structure M = struct
29 :     (* runtime system dependent constants. *)
30 :     val float64TmpOffset = 0 (* must be < 16 *)
31 :     val float32TmpOffset = float64TmpOffset (* must be < 16 *)
32 :     val cvti2dOffset = ~4
33 :     end
34 :    
35 :     fun error msg = MLRiscErrorMsg.impossible ("Hppa." ^ msg)
36 :    
37 :     val itow = Word.fromInt
38 :    
39 :     val emit = F.emitInstr
40 :     val ldLabelEA = LC.ldLabelEA emit
41 :     val ldLabelOpnd = LC.ldLabelOpnd emit
42 :    
43 :     datatype ea = DISPea of int * I.operand | INDXea of int * int
44 :    
45 :     (* integer ranges *)
46 :     fun im5 n = n < 16 andalso n >= ~16
47 :     fun im11 n = n < 1024 andalso n >= ~1024
48 :     fun im14 n = n < 8192 andalso n >= ~8192
49 :    
50 :     fun split n = let
51 :     val w = Word.fromInt(n)
52 :     in
53 :     (Word.toIntX(Word.~>>(w, 0w11)), Word.toIntX(Word.andb(w, 0wx7ff)))
54 :     end
55 :    
56 :     val zeroR = 0
57 :     val zeroEA = I.Direct(zeroR)
58 :    
59 :     fun emitMove(src, dst) = emit(I.ARITH{a=I.OR, r1=src, r2=zeroR, t=dst})
60 :    
61 :     fun loadImmedRd(n, rd) =
62 :     if im14 n then (emit(I.LDO{i=I.IMMED n, b=0, t=rd}); rd)
63 :     else let
64 :     val (hi, lo) = split n
65 : monnier 106 val tmpR = C.newReg()
66 : monnier 16 in
67 :     emit(I.LDIL{i=I.IMMED hi, t=tmpR});
68 :     emit(I.LDO{i=I.IMMED lo, b=tmpR, t=rd});
69 :     rd
70 :     end
71 :    
72 : monnier 106 fun loadImmed n = loadImmedRd(n, C.newReg())
73 : monnier 16
74 :     fun loadWord32Rd(w, rd) = let
75 :     val toInt = Word32.toIntX
76 :     in
77 :     if Word32.<(w, 0w8192) then emit(I.LDO{i=I.IMMED(toInt w), b=0, t=rd})
78 :     else let
79 : monnier 106 val tmpR = C.newReg()
80 : monnier 16 val hi = Word32.~>>(w, 0w11)
81 :     val lo = Word32.andb(w, 0wx7ff)
82 :     in
83 :     emit(I.LDIL{i=I.IMMED(toInt hi), t=tmpR});
84 :     emit(I.LDO{i=I.IMMED(toInt lo), b=tmpR, t=rd})
85 :     end;
86 :     rd
87 :     end
88 : monnier 106 fun loadWord32 w = loadWord32Rd(w, C.newReg())
89 : monnier 16
90 :     fun milliCall(milliFn, exp1, exp2, ord, rd) = let
91 :     val (rs, rt) = orderedRR(exp1, exp2, ord)
92 :     in app emit (milliFn{rs=rs, rt=rt, rd=rd}); rd
93 :     end
94 :    
95 :     and orderedRR(exp1, exp2, T.LR) = (regAction exp1, regAction exp2)
96 :     | orderedRR(exp1, exp2, T.RL) = let val r2 = regAction exp2
97 :     in
98 :     (regAction exp1, r2)
99 :     end
100 :    
101 :     and orderedFF(exp1, exp2, T.LR) = (fregAction exp1, fregAction exp2)
102 :     | orderedFF(exp1, exp2, T.RL) = let val f2 = fregAction exp2
103 :     in (fregAction exp1, f2)
104 :     end
105 :    
106 :     and eaAction(T.ADD(exp, T.LI n)) = DISPea(regAction exp, I.IMMED n)
107 :     | eaAction(T.ADD(T.LI n, exp)) = DISPea(regAction exp, I.IMMED n)
108 :     | eaAction(T.ADD(exp, T.CONST c)) = DISPea(regAction exp, I.ConstOp c)
109 :     | eaAction(T.ADD(T.CONST c, exp)) = DISPea(regAction exp, I.ConstOp c)
110 :     | eaAction(T.ADD(e1 as T.LABEL _, e2)) = eaAction(T.ADD(e2, e1))
111 :     | eaAction(T.ADD(e, T.LABEL le)) = let
112 :     val rs = regAction(e)
113 :     in
114 :     case ldLabelEA(le)
115 :     of (0, opnd) => DISPea(rs, opnd)
116 :     | (rt, I.IMMED 0) => INDXea(rs, rt)
117 :     | (rt, opnd) => let
118 :     val tmpR = C.newReg()
119 :     in
120 :     emit(I.ARITH{a=I.ADD, r1=rs, r2=rt, t=tmpR});
121 :     DISPea(tmpR, opnd)
122 :     end
123 :     end
124 :     | eaAction(T.ADD(exp1, exp2)) = INDXea(regAction exp1, regAction exp2)
125 :     | eaAction(T.SUB(exp, T.LI n, _)) = DISPea(regAction exp, I.IMMED(~n))
126 :     | eaAction(T.LABEL lexp) = DISPea(ldLabelEA(lexp))
127 :     | eaAction exp = DISPea(regAction exp, I.IMMED 0)
128 :    
129 :     and stmAction exp = let
130 :     fun store(ea, reg, instr, mem) = let
131 :     val (b, d) =
132 :     case eaAction ea
133 :     of DISPea (bd as (base, I.IMMED disp)) =>
134 :     if im14 disp then bd
135 :     else let
136 :     val (hi21, lo11) = split disp
137 : monnier 106 val tmpR1 = C.newReg()
138 :     val tmpR2 = C.newReg()
139 : monnier 16 in
140 :     emit(I.LDIL{i=I.IMMED hi21, t=tmpR1});
141 :     emit(I.ARITH{a=I.ADD, r1=base, r2=tmpR1, t=tmpR2});
142 :     (tmpR2, I.IMMED lo11)
143 :     end
144 :     | DISPea bd => bd
145 :     | INDXea(r1,r2) => let
146 : monnier 106 val t = C.newReg()
147 : monnier 16 in
148 :     emit (I.ARITH {a=I.ADD, r1=r1, r2=r2, t=t});
149 :     (t, I.IMMED 0)
150 :     end
151 :     in emit (I.STORE {st=instr, b=b, d=d, r=regAction reg, mem=mem})
152 :     end
153 :    
154 :     fun fstore(ea, freg, mem) = let
155 :     val r = fregAction freg
156 :     in
157 :     case eaAction ea
158 :     of DISPea(b, I.IMMED d) =>
159 :     if im5 d then
160 :     emit(I.FSTORE {fst=I.FSTDS, b=b, d=d, r=r, mem=mem})
161 :     else
162 :     emit(I.FSTOREX{fstx=I.FSTDX, b=b, x=loadImmed d, r=r, mem=mem})
163 :     | DISPea(b, d) => let
164 : monnier 106 val tmpR = C.newReg()
165 : monnier 16 in
166 :     emit(I.ARITHI{ai=I.ADDI, r=b, i=d, t=tmpR});
167 :     emit(I.FSTORE{fst=I.FSTDS, b=tmpR, d=0, r=r, mem=mem})
168 :     end
169 :     | INDXea(b,x) => emit(I.FSTOREX{fstx=I.FSTDX, b=b, x=x, r=r, mem=mem})
170 :     end
171 :    
172 :     fun branch(bc, r1, r2, t) = let
173 :     val flab = Label.newLabel ""
174 :     fun emitBranch(cmp, ic, r1, r2) =
175 :     (emit(I.BCOND{cmp=cmp, bc=ic, r1=r1, r2=r2, t=t, f=flab, n=true});
176 :     F.defineLabel flab)
177 :     in
178 :     (case bc
179 :     of T.LT => emitBranch(I.COMBT, I.LT, r1, r2)
180 :     | T.LE => emitBranch(I.COMBT, I.LE, r1, r2)
181 :     | T.GT => emitBranch(I.COMBT, I.LT, r2, r1)
182 :     | T.GE => emitBranch(I.COMBT, I.LE, r2, r1)
183 :     | T.EQ => emitBranch(I.COMBT, I.EQ, r1, r2)
184 :     | T.LTU => emitBranch(I.COMBT, I.LTU, r1, r2)
185 :     | T.LEU => emitBranch(I.COMBT, I.LEU, r1, r2)
186 :     | T.GEU => emitBranch(I.COMBT, I.LEU, r2, r1)
187 :     | T.GTU => emitBranch(I.COMBT, I.LTU, r2, r1)
188 :     | T.NEQ => emitBranch(I.COMBF, I.EQ, r1, r2)
189 :     (*esac*))
190 :     end
191 : monnier 106 fun copyTmp() = SOME(I.Direct(C.newReg()))
192 :     fun fcopyTmp() = SOME(I.FDirect(C.newFreg()))
193 : monnier 16
194 :     val reduce={stm=stmAction, rexp=regAction, emit=emit}
195 :     val returnPtr = 2
196 :     in
197 :     case exp
198 :     of T.MV(rd, exp) =>
199 :     (case exp
200 :     of T.REG(rs) => if rd = rs then () else emitMove(rs, rd)
201 :     | T.LI n => (loadImmedRd(n, rd); ())
202 :     | T.LI32 w => (loadWord32Rd(w, rd); ())
203 :     | _ => let val rs = regActionRd(exp, rd)
204 :     in if rs = rd then () else emitMove(rs, rd)
205 :     end
206 :     (*esac*))
207 :     | T.FMV(fd, exp) => let
208 :     fun fmove(src,dst) = I.FUNARY{fu=I.FCPY, f=src, t=dst}
209 :     in
210 :     case exp
211 :     of T.FREG(fs) =>
212 :     if fs = fd then () else emit(fmove(fs, fd))
213 :     | _ => let val fs = fregActionFd(exp, fd)
214 :     in if fs = fd then () else emit(fmove(fs, fd))
215 :     end
216 :     (*esac*)
217 :     end
218 :     | T.CCMV(cd, exp) => let
219 :     val cs = case exp of T.CC(r) => r | _ => ccActionCd(exp, cd)
220 :     in if cs=cd then () else emitMove(cs, cd)
221 :     end
222 :    
223 :     | T.COPY(rds as [_], rss) =>
224 :     emit(I.COPY{dst=rds, src=rss, impl=ref NONE, tmp=NONE})
225 :     | T.COPY(rds, rss) =>
226 :     emit(I.COPY{dst=rds, src=rss, impl=ref NONE, tmp=copyTmp()})
227 :     | T.FCOPY(fds as [_], fss)=>
228 :     emit(I.FCOPY{dst=fds, src=fss, impl=ref NONE, tmp=NONE})
229 :     | T.FCOPY(fds, fss) =>
230 :     emit(I.FCOPY{dst=fds, src=fss, impl=ref NONE, tmp=fcopyTmp()})
231 :    
232 :     | T.JMP _ => LC.doJmp(reduce, exp)
233 :     | T.CALL _ => LC.doCall(reduce, exp)
234 :     | T.RET => emit(I.BV{labs=[], x=0, b=returnPtr, n=true})
235 :     | T.STORE8(ea, r, region) => store(ea, r, I.STB, region)
236 :     | T.STORE32(ea, r, region) => store(ea, r, I.STW, region)
237 :     | T.STORED(ea, f, region) => fstore(ea, f, region)
238 :     | T.STORECC(ea, cc, region) => error "stmAction.STORECC"
239 :     | T.BCC(_, T.CMP(cc, exp, T.LI n, ord), lab) => let
240 :     val r = regAction exp
241 :     in
242 :     if im5 n then let
243 :     val flab = Label.newLabel ""
244 :     fun emitBranch(cmpi, ic) =
245 :     (emit(I.BCONDI{cmpi=cmpi,bc=ic,i=n,r2=r,t=lab,f=flab, n=true});
246 :     F.defineLabel flab)
247 :     in
248 :     case cc
249 :     of T.LT => emitBranch(I.COMIBF, I.LE)
250 :     | T.LE => emitBranch(I.COMIBF, I.LT)
251 :     | T.GT => emitBranch(I.COMIBT, I.LT)
252 :     | T.GE => emitBranch(I.COMIBT, I.LE)
253 :     | T.EQ => emitBranch(I.COMIBT, I.EQ)
254 :     | T.LTU => emitBranch(I.COMIBF, I.LEU)
255 :     | T.LEU => emitBranch(I.COMIBF, I.LTU)
256 :     | T.GEU => emitBranch(I.COMIBT, I.LEU)
257 :     | T.GTU => emitBranch(I.COMIBT, I.LTU)
258 :     | T.NEQ => emitBranch(I.COMIBF, I.EQ)
259 :     end
260 :     else
261 :     branch(cc, r, loadImmed n, lab)
262 :     end
263 :     | T.BCC(_, T.CMP(cc, exp1, exp2, order), lab) => let
264 :     val (r1, r2) = orderedRR(exp1, exp2, order)
265 :     in
266 :     branch(cc, r1, r2, lab)
267 :     end
268 :     | T.BCC(_, e, lab) => let
269 :     val cc = ccAction e
270 :     val flab = Label.newLabel""
271 :     in
272 :     emit(I.BCOND{cmp=I.COMBT, bc=I.EQ, r1=cc, r2=zeroR,
273 :     t=lab, f=flab, n=true});
274 :     F.defineLabel flab
275 :     end
276 :     | T.FBCC(_, T.FCMP(cc, exp1, exp2, order), lab) => let
277 :     val (f1,f2) = orderedFF(exp1, exp2, order)
278 :     val fallThrough = Label.newLabel ""
279 :     fun fcond T.== = I.!=
280 :     | fcond T.?<> = I.==
281 :     | fcond T.? = I.<=>
282 :     | fcond T.<=> = I.?
283 :     | fcond T.> = I.?<=
284 :     | fcond T.>= = I.?<
285 :     | fcond T.?> = I.<=
286 :     | fcond T.?>= = I.<
287 :     | fcond T.< = I.?>=
288 :     | fcond T.<= = I.?>
289 :     | fcond T.?< = I.>=
290 :     | fcond T.?<= = I.>
291 :     | fcond T.<> = I.?=
292 :     | fcond T.?= = I.<>
293 :     in
294 :     emit(I.FCMP(fcond cc, f1, f2));
295 :     emit(I.FTEST);
296 :     emit(I.FBCC{t=lab, f=fallThrough, n=true});
297 :     F.defineLabel fallThrough
298 :     end
299 :     end
300 :    
301 :     (* condition code registers are implemented using
302 :     * general purpose registers.
303 :     *)
304 :     and ccAction(T.CC r) = r
305 :     | ccAction e = ccActionCd(e, C.newCCreg())
306 :    
307 :     and ccActionCd(T.CC r, _) = r
308 :     | ccActionCd(T.CMP(cond, exp1, exp2, order), rd) = let
309 :     val (r1, r2) = orderedRR(exp1, exp2, order)
310 :     in
311 :     case cond
312 :     of T.GTU =>
313 :     (emit(I.COMCLR{cc=I.GTU, r1=r1, r2=r2, t=rd});
314 :     emit(I.LDO{i=I.IMMED 1, b=0, t=rd}))
315 :     (* enough for now *)
316 :     | _ => error "ccAction.CMP"
317 :     (*esac*);
318 :     rd
319 :     end
320 :     | ccActionCd(T.FCMP _, _) = error "ccAction:FCMP"
321 :     | ccActionCd(T.LOADCC _, _) = error "ccAction:LOADCC"
322 :    
323 :     and regAction(T.REG r) = r
324 : monnier 106 | regAction exp = regActionRd(exp, C.newReg())
325 : monnier 16
326 :     and regActionRd(exp, rd) = let
327 :     datatype opnd = REG of int | OPND of I.operand
328 :    
329 :     fun opndAction(T.LI n) =
330 :     if im11 n then OPND(I.IMMED n) else REG(loadImmed n)
331 :     | opndAction(T.LI32 w) =
332 :     if Word32.<=(w, 0w1024) then OPND(I.IMMED(Word32.toInt w))
333 :     else REG(loadWord32 w)
334 :     | opndAction(T.CONST c) = OPND(I.ConstOp c)
335 :     | opndAction(T.LABEL le) =
336 :     (case ldLabelOpnd{label=le, pref=NONE}
337 :     of LC.REG r => REG r
338 :     | LC.OPND opnd => OPND opnd
339 :     (*esac*))
340 :     | opndAction exp = REG(regAction exp)
341 :    
342 :     fun immedArith(exp1, exp2, order, immdOp, arithOp) = let
343 :     val (opnd, r2) =
344 :     case order
345 :     of T.LR => (opndAction exp1, regAction exp2)
346 :     | T.RL => let val opnd' = opndAction exp1
347 :     in
348 :     (opnd', regAction exp2)
349 :     end
350 :     in
351 :     case opnd
352 :     of REG r1 => emit(I.ARITH{a=arithOp, r1=r1, r2=r2, t=rd})
353 :     | OPND opnd => emit(I.ARITHI{ai=immdOp, r=r2, i=opnd, t=rd})
354 :     (*esac*);
355 :     rd
356 :     end (* immedArith *)
357 :    
358 :     fun commImmedArith(arg as (exp1, exp2, ord, immdOp, arithOp)) =
359 :     (case exp2
360 :     of (T.LI _ | T.LI32 _ | T.CONST _ | T.LABEL _ )=>
361 :     immedArith(exp2, exp1, ord, immdOp, arithOp)
362 :     | _ => immedArith arg
363 :     (*esac*))
364 :    
365 :     local
366 :     fun shift (immdSht, varSht) = let
367 :     fun f(exp, T.LI n, _) =
368 :     if n < 0 orelse n > 31 then error "regActionRd:shift"
369 :     else let
370 :     val rs = regAction exp
371 :     in
372 :     emit(I.SHIFT{s=immdSht, r=rs, p=31-n, len=32-n, t=rd});
373 :     rd
374 :     end
375 :     | f(exp1, exp2, order) = let
376 :     val (r1, r2) = orderedRR(exp1, exp2, order)
377 : monnier 106 val tmp = C.newReg()
378 : monnier 16 in
379 :     emit(I.ARITHI{ai=I.SUBI, i=I.IMMED 31, r=r2, t=tmp});
380 :     emit(I.MTCTL{r=tmp, t=11});
381 :     emit(I.SHIFTV{sv=varSht, r=r1, len=32, t=rd});
382 :     rd
383 :     end
384 :     in
385 :     f
386 :     end
387 :     in
388 :     val sll = shift (I.ZDEP, I.ZVDEP)
389 :     val srl = shift (I.EXTRU, I.VEXTRU)
390 :     val sra = shift (I.EXTRS, I.VEXTRS)
391 :     end
392 :    
393 :     fun arith(exp1, exp2, oper) =
394 :     (emit(I.ARITH{a=oper, r1=regAction exp1, r2=regAction exp2, t=rd});
395 :     rd)
396 :    
397 :     fun load(ea, rd, instri, instrx, mem) =
398 :     (case eaAction ea
399 :     of DISPea(b, I.IMMED d) =>
400 :     if im14 d then
401 :     emit(I.LOADI{li=instri, i=I.IMMED d, r=b, t=rd, mem=mem})
402 :     else
403 :     emit(I.LOAD{l=instrx, r1=b, r2=loadImmed d, t=rd, mem=mem})
404 :     | DISPea(b, d) =>
405 :     emit(I.LOADI{li=instri, i=d, r=b, t=rd, mem=mem})
406 :     | INDXea(b,x) =>
407 :     emit(I.LOAD{l=instrx, r1=b, r2=x, t=rd, mem=mem})
408 :     (*esac*);
409 :     rd)
410 :    
411 :     val reduce = {stm=stmAction, rexp=regAction, emit=emit}
412 :     in
413 :     case exp
414 :     of T.LI n => (loadImmedRd(n, rd); rd)
415 :     | T.LI32 w => (loadWord32Rd(w, rd); rd)
416 :     | T.CONST c => (emit(I.LDO{i=I.ConstOp(c), b=0, t=rd}); rd)
417 :     | T.LABEL le =>
418 :     (case ldLabelOpnd{label=le, pref=SOME(rd)}
419 :     of LC.REG rs => if rd=rs then () else emitMove(rs, rd)
420 :     | LC.OPND opnd => emit(I.LDO{i=opnd, b=zeroR, t=rd})
421 :     (*esac*);
422 :     rd)
423 :     | T.ADD(exp1, exp2) => commImmedArith(exp1, exp2, T.LR, I.ADDI, I.ADD)
424 :     | T.ADDT(e1, e2) => commImmedArith(e1, e2, T.LR, I.ADDIO, I.ADDO)
425 :     | T.SUB(e, T.LI n, _) => immedArith(T.LI(~n), e, T.LR, I.ADDIO, I.ADDO)
426 :     | T.SUBT(e, T.LI n, _) => immedArith(T.LI(~n), e, T.LR, I.ADDIO, I.ADDO)
427 :     | T.SUB(exp1, exp2, ord) => immedArith(exp1, exp2, ord, I.SUBI, I.SUB)
428 :     | T.SUBT(exp1, exp2, ord) => immedArith(exp1, exp2, ord, I.SUBIO, I.SUBO)
429 :     | T.SLL arg => sll arg
430 :     | T.SRL arg => srl arg
431 :     | T.SRA arg => sra arg
432 :     | T.ANDB(exp1, exp2) => arith(exp1, exp2, I.AND)
433 :     | T.ORB(exp1, exp2) => arith(exp1, exp2, I.OR)
434 :     | T.XORB(exp1, exp2) => arith(exp1, exp2, I.XOR)
435 :     | T.DIVU(exp1, exp2, ord)=> milliCall(MC.divu, exp1, exp2, ord, rd)
436 :     | T.DIVT(exp1, exp2, ord)=> milliCall(MC.divo, exp1, exp2, ord, rd)
437 :     | T.MULT(exp1, exp2) => milliCall(MC.mulo, exp1, exp2, T.LR, rd)
438 :     | T.MULU(exp1, exp2) => milliCall(MC.mulu, exp1, exp2, T.LR, rd)
439 :     | T.LOAD8(ea, region) => load(ea, rd, I.LDB, I.LDBX, region)
440 :     | T.LOAD32(ea, region) => load(ea, rd, I.LDW, I.LDWX, region)
441 :     | T.SEQ(exp1, exp2) => (stmAction exp1; regAction exp2)
442 :     | _ => error "regActionRd: missing rules"
443 :     end (* regActionRd *)
444 :    
445 :     and fregAction (T.FREG f) = f
446 : monnier 106 | fregAction exp = fregActionFd(exp, C.newFreg())
447 : monnier 16
448 :     and fregActionFd(exp, fd) = let
449 :     fun orderedFarith(exp1, exp2, ord, arithOp) = let
450 :     val (f1, f2) = orderedFF(exp1, exp2, ord)
451 :     in
452 :     emit(I.FARITH{fa=arithOp, r1=f1, r2=f2, t=fd});
453 :     fd
454 :     end
455 :    
456 :     in
457 :     case exp
458 :     of T.LOADD(ea, region) =>
459 :     (case eaAction ea
460 :     of INDXea(r1, r2) =>
461 :     emit(I.FLOADX{flx=I.FLDDX, b=r1, x=r2, t=fd, mem=region})
462 :     | DISPea(r, I.IMMED n) =>
463 :     if im5 n then
464 :     emit(I.FLOAD{fl=I.FLDDS, b=r, d=n, t=fd, mem=region})
465 :     else
466 :     emit(I.FLOADX{flx=I.FLDDX, b=r, x=loadImmed n, t=fd,
467 :     mem=region})
468 :     | DISPea(r,d) => let
469 : monnier 106 val tmpR = C.newReg()
470 : monnier 16 in
471 :     emit(I.ARITHI{ai=I.ADDI, r=r, i=d, t=tmpR});
472 :     emit(I.FLOADX{flx=I.FLDDX, b=tmpR, x=zeroR, t=fd,mem=region})
473 :     end
474 :     (*esac*);
475 :     fd)
476 :     | T.FADDD(exp1, exp2) => orderedFarith(exp1, exp2, T.LR, I.FADD)
477 :     | T.FSUBD(exp1, exp2, ord) => orderedFarith(exp1, exp2, ord, I.FSUB)
478 :     | T.FMULD(exp1, exp2) => orderedFarith(exp1, exp2, T.LR, I.FMPY)
479 :     | T.FDIVD(exp1, exp2, ord) => orderedFarith(exp1, exp2, ord, I.FDIV)
480 :     | T.FABSD exp => (emit(I.FUNARY{fu=I.FABS, f=fregAction exp, t=fd}); fd)
481 :     | T.FNEGD exp => (emit(I.FARITH{fa=I.FSUB, r1=0, r2=fregAction exp, t=fd}); fd)
482 :     | T.CVTI2D exp =>
483 :     (emit(I.STORE{st=I.STW, b=C.stackptrR, d=I.IMMED M.cvti2dOffset,
484 :     r=regAction exp, mem=Region.stack});
485 :     emit(I.FLOAD{fl=I.FLDWS, b=C.stackptrR, d=M.cvti2dOffset, t=fd,
486 :     mem=Region.stack});
487 :     emit(I.FUNARY{fu=I.FCNVXF, f=fd, t=fd});
488 :     fd)
489 :     | T.FSEQ(e1, e2) => (stmAction e1; fregAction e2)
490 :     | _ => error "fregAction: missing rule"
491 :     end
492 :    
493 :     and mltreeComp mltree = let
494 :     (* condition code registers are mapped onto general registers *)
495 :     fun cc (T.CCR(T.CC cc)) = T.GPR(T.REG cc)
496 :     | cc x = x
497 :    
498 :     fun mltc(T.PSEUDO_OP pOp) = F.pseudoOp pOp
499 :     | mltc(T.DEFINELABEL lab) = F.defineLabel lab
500 :     | mltc(T.ENTRYLABEL lab) = F.entryLabel lab
501 :     | mltc(T.ORDERED mlts) = F.ordered mlts
502 :     | mltc(T.BEGINCLUSTER) = F.beginCluster()
503 :     | mltc(T.CODE stms) = app stmAction stms
504 :     | mltc(T.ENDCLUSTER regmap)= F.endCluster regmap
505 :     | mltc(T.ESCAPEBLOCK regs) = F.exitBlock (map cc regs)
506 :     in mltc mltree
507 :     end
508 :    
509 :     val mlriscComp = stmAction
510 :     end
511 :    
512 :     (*
513 : monnier 113 * $Log$
514 : monnier 16 *)

root@smlnj-gforge.cs.uchicago.edu
ViewVC Help
Powered by ViewVC 1.0.0