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/trunk/src/MLRISC/hppa/hppa.sml
ViewVC logotype

Annotation of /sml/trunk/src/MLRISC/hppa/hppa.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 127 - (view) (download)
Original Path: sml/branches/SMLNJ/src/MLRISC/hppa/hppa.sml

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

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