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

SCM Repository

[smlnj] Diff of /MLRISC/trunk/staged-allocation/test-staged-allocation-amd64.sml
ViewVC logotype

Diff of /MLRISC/trunk/staged-allocation/test-staged-allocation-amd64.sml

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 3007, Mon Apr 28 15:29:41 2008 UTC revision 3008, Mon Apr 28 19:40:46 2008 UTC
# Line 248  Line 248 
248       structure Rewrite =       structure Rewrite =
249         struct         struct
250           structure I = AMD64Instr           structure I = AMD64Instr
251           fun rewriteDef _ = raise Fail ""           structure C=I.C
252           fun rewriteUse _ = raise Fail ""           structure CB = CellsBasis
253             fun error msg = MLRiscErrorMsg.error("X86Rewrite", msg)
254    
255             fun operand (rs,rt) opnd =
256                 (case opnd
257                   of I.Direct (sz, r) => if CB.sameColor(r,rs) then I.Direct (sz, rt) else opnd
258                    | I.Displace{base, disp, mem} =>
259                      if CB.sameColor(base,rs) then I.Displace{base=rt, disp=disp, mem=mem}
260                      else opnd
261                    | I.Indexed{base as SOME b, index, scale, disp, mem} => let
262                          val base'= if CB.sameColor(b,rs) then SOME rt else base
263                          val index'=if CB.sameColor(index,rs) then rt else index
264                      in I.Indexed{base=base', index=index', scale=scale, disp=disp, mem=mem}
265                      end
266                    | I.Indexed{base, index, scale, disp, mem=mem}  =>
267                      if CB.sameColor(index,rs) then
268                          I.Indexed{base=base, index=rt, scale=scale, disp=disp, mem=mem}
269                      else opnd
270                    | _ => opnd
271                  (*end case*))
272    
273    
274             fun rewriteDef (instr, rs, rt) = let
275                 fun operand(opnd as I.Direct (sz, r)) =
276                     if CB.sameColor(r,rs) then I.Direct (sz, rt) else opnd
277                   | operand _ = error "operand: not I.Direct"
278                 fun replace r = if CB.sameColor(r,rs) then rt else r
279                 fun rewriteX86Def(instr) =
280                     (case instr
281                       of I.CALL{opnd, defs, uses, return, cutsTo, mem, pops} =>
282                          I.CALL{opnd=opnd, cutsTo=cutsTo,
283                                 return=CB.CellSet.map {from=rs,to=rt} return, pops=pops,
284                                 defs=CB.CellSet.map {from=rs,to=rt} defs, uses=uses, mem=mem}
285                        | I.MOVE{mvOp, src, dst} => I.MOVE{mvOp=mvOp, src=src, dst=operand dst}
286                        | I.LEAL{r32, addr} => I.LEAL{r32=replace r32, addr=addr}
287                        | I.LEAQ{r64, addr} => I.LEAQ{r64=replace r64, addr=addr}
288                        | I.BINARY{binOp, src, dst} =>
289                          I.BINARY{binOp=binOp, src=src, dst=operand dst}
290                        | I.SHIFT{shiftOp, src, dst, count} =>
291                          I.SHIFT{shiftOp=shiftOp, src=src, count=count, dst=operand dst}
292                        | I.UNARY{unOp, opnd} => I.UNARY{unOp=unOp, opnd=operand opnd}
293                        | I.SET{cond, opnd} => I.SET{cond=cond, opnd=operand opnd}
294                        | _ => instr
295                    (* end case *))
296    
297                 fun f (I.ANNOTATION{a,i}) =
298                     I.ANNOTATION{i=rewriteDef(i,rs,rt),
299                                  a=(case a of
300                                         CB.DEF_USE{cellkind=CB.GP,defs,uses} =>
301                                         CB.DEF_USE{cellkind=CB.GP,uses=uses,
302                                                    defs=map replace defs}
303                                       | _ => a)}
304                   | f (I.INSTR i) = I.INSTR(rewriteX86Def(i))
305                   | f (I.COPY{k as CB.GP, sz, dst, src, tmp}) =
306                     I.COPY{k=k, sz=sz, dst=map replace dst, src=src, tmp=tmp}
307             in
308                 f(instr)
309             end
310    
311    
312             fun rewriteUse (instr, rs, rt) = let
313                 val operand = operand (rs, rt)
314                 fun replace r = if CB.sameColor(r,rs) then rt else r
315                 fun rewrite instr = (case instr
316                     of I.JMP(opnd, labs) => I.JMP(operand opnd, labs)
317                      | I.JCC{cond, opnd} => I.JCC{cond=cond, opnd = operand opnd}
318                      | I.CALL{opnd, defs, uses, return, cutsTo, mem, pops} =>
319                        I.CALL{opnd=operand opnd, defs=defs, return=return,
320                               uses=CB.CellSet.map {from=rs,to=rt} uses, cutsTo=cutsTo,
321                               mem=mem, pops=pops}
322                      | I.MOVE{mvOp, src, dst as I.Direct _} =>
323                        I.MOVE{mvOp=mvOp, src=operand src, dst=dst}
324                      | I.MOVE{mvOp, src, dst} =>
325                        I.MOVE{mvOp=mvOp, src=operand src, dst=operand dst}
326                      | I.LEAL{r32, addr} => I.LEAL{r32=r32, addr=operand addr}
327                      | I.LEAQ{r64, addr} => I.LEAQ{r64=r64, addr=operand addr}
328                      | I.CMPL{lsrc, rsrc} => I.CMPL{lsrc=operand lsrc, rsrc=operand rsrc}
329                      | I.CMPW{lsrc, rsrc} => I.CMPW{lsrc=operand lsrc, rsrc=operand rsrc}
330                      | I.CMPB{lsrc, rsrc} => I.CMPB{lsrc=operand lsrc, rsrc=operand rsrc}
331                      | I.TESTL{lsrc, rsrc} => I.TESTL{lsrc=operand lsrc, rsrc=operand rsrc}
332                      | I.TESTW{lsrc, rsrc} => I.TESTW{lsrc=operand lsrc, rsrc=operand rsrc}
333                      | I.TESTB{lsrc, rsrc} => I.TESTB{lsrc=operand lsrc, rsrc=operand rsrc}
334                      | I.BITOP{bitOp, lsrc, rsrc} =>
335                        I.BITOP{bitOp=bitOp, lsrc=operand lsrc, rsrc=operand rsrc}
336                      | I.BINARY{binOp, src, dst} =>
337                        I.BINARY{binOp=binOp, src=operand src, dst=operand dst}
338                      | I.SHIFT{shiftOp, src, dst, count} =>
339                        I.SHIFT{shiftOp=shiftOp, src=operand src, dst=operand dst,
340                                count=operand src}
341                    (* end case *))
342    
343                 fun f(I.ANNOTATION{a,i}) =
344                     I.ANNOTATION{i=rewriteUse(i, rs, rt),
345                                  a = case a of
346                                          CB.DEF_USE{cellkind=CB.GP,defs,uses} =>
347                                          CB.DEF_USE{cellkind=CB.GP,uses=map replace uses,
348                                                     defs=defs}
349                                        | _ => a}
350                   | f(I.INSTR i) = I.INSTR(rewrite(i))
351                   | f(I.COPY{k as CB.GP, sz, dst, src, tmp}) =
352                     I.COPY{k=k, sz=sz, dst=dst, src=List.map replace src, tmp=tmp}
353             in
354                 f (instr:I.instruction)
355             end
356    
357    
358           fun frewriteDef _ = raise Fail ""           fun frewriteDef _ = raise Fail ""
359           fun frewriteUse _ = raise Fail ""           fun frewriteUse _ = raise Fail ""
360         end         end
# Line 263  Line 368 
368    
369       datatype spillOperandKind = SPILL_LOC | CONST_VAL       datatype spillOperandKind = SPILL_LOC | CONST_VAL
370       type spill_info = unit       type spill_info = unit
371       fun beforeRA _ = raise Fail ""       fun beforeRA _ = ()
372    
373       val architecture = "amd64"       val architecture = "amd64"
374       fun pure _ = true       fun pure _ = true
375    
376       structure Int =       structure Int =
377          struct          struct
378            val avail = []            val avail = C.Regs CellsBasis.GP {from=0, to=15, step=1}
379            val dedicated = []            val dedicated = [C.rsp, C.rbp]
380            fun spillLoc _ = raise Fail ""            fun spillLoc _ = raise Fail ""
381            val mode = RACore.NO_OPTIMIZATION            val mode = RACore.NO_OPTIMIZATION
382          end          end
383       structure Float =       structure Float =
384          struct          struct
385            val avail = []            val avail = C.Regs CellsBasis.FP {from=0, to=15, step=1}
386            val dedicated = []            val dedicated = []
387            fun spillLoc _ = raise Fail ""            fun spillLoc _ = raise Fail ""
388            val mode = RACore.NO_OPTIMIZATION            val mode = Word.orb (RACore.HAS_PARALLEL_COPIES, RACore.DEAD_COPY_ELIM)
389          end          end
390    
391      )      )

Legend:
Removed from v.3007  
changed lines
  Added in v.3008

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