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

Diff of /sml/trunk/src/MLRISC/x86/ra/x86RA.sml

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

revision 1002, Fri Nov 30 17:11:33 2001 UTC revision 1003, Fri Dec 7 02:45:32 2001 UTC
# Line 228  Line 228 
228    
229      structure X86Spill = X86Spill(structure Instr=I structure Props=InsnProps)      structure X86Spill = X86Spill(structure Instr=I structure Props=InsnProps)
230    
231       fun annotate([], i) = i
232         | annotate(a::an, i) = annotate(an, I.ANNOTATION{a=a, i=i})
233    
234      (*      (*
235       * Dead code elimination       * Dead code elimination
236       *)       *)
# Line 246  Line 249 
249              |  NONE   => false              |  NONE   => false
250          fun isAffected i = getOpt (IntHashTable.find affectedBlocks i, false)          fun isAffected i = getOpt (IntHashTable.find affectedBlocks i, false)
251          fun isDeadInstr(I.ANNOTATION{i, ...}) = isDeadInstr i          fun isDeadInstr(I.ANNOTATION{i, ...}) = isDeadInstr i
252            | isDeadInstr(I.MOVE{dst=I.Direct rd, ...}) = isDead rd            | isDeadInstr(I.INSTR(I.MOVE{dst=I.Direct rd, ...})) = isDead rd
253            | isDeadInstr(I.MOVE{dst=I.MemReg rd, ...}) = isDead rd            | isDeadInstr(I.INSTR(I.MOVE{dst=I.MemReg rd, ...})) = isDead rd
254            | isDeadInstr(I.COPY{dst=[rd], ...}) = isDead rd            | isDeadInstr(I.INSTR(I.COPY{dst=[rd], ...})) = isDead rd
255            | isDeadInstr _ = false            | isDeadInstr _ = false
256          fun scan [] = ()          fun scan [] = ()
257            | scan((blknum, CFG.BLOCK{insns, ...})::rest) =            | scan((blknum, CFG.BLOCK{insns, ...})::rest) =
# Line 330  Line 333 
333       * Callbacks for floating point K=32       * Callbacks for floating point K=32
334       * -------------------------------------------------------------------*)       * -------------------------------------------------------------------*)
335      fun copyInstrF((rds as [_], rss as [_]), _) =      fun copyInstrF((rds as [_], rss as [_]), _) =
336            I.FCOPY{dst=rds, src=rss, tmp=NONE}            I.fcopy{dst=rds, src=rss, tmp=NONE}
337        | copyInstrF((rds, rss), I.FCOPY{tmp, ...}) =        | copyInstrF((rds, rss), I.INSTR(I.FCOPY{tmp, ...})) =
338            I.FCOPY{dst=rds, src=rss, tmp=tmp}            I.fcopy{dst=rds, src=rss, tmp=tmp}
339        | copyInstrF(x, I.ANNOTATION{i,a}) =        | copyInstrF(x, I.ANNOTATION{i,a}) =
340            I.ANNOTATION{i=copyInstrF(x, i), a=a}            I.ANNOTATION{i=copyInstrF(x, i), a=a}
341    
# Line 342  Line 345 
345        | getFregLoc(S, an, Ra.MEM_REG r) = I.FDirect r        | getFregLoc(S, an, Ra.MEM_REG r) = I.FDirect r
346    
347      (* spill floating point *)      (* spill floating point *)
348      fun spillF S {instr, reg, spillLoc, kill, annotations=an} =  
349        fun spillF S {annotations=an, kill, reg, spillLoc, instr} =
350          (floatSpillCnt := !floatSpillCnt + 1;          (floatSpillCnt := !floatSpillCnt + 1;
351           X86Spill.fspill(instr, reg, getFregLoc(S, an, spillLoc))           X86Spill.fspill(instr, reg, getFregLoc(S, an, spillLoc)))
         )  
352    
353      fun spillFreg S {src, reg, spillLoc, annotations=an} =      fun spillFreg S {src, reg, spillLoc, annotations=an} =
354         (floatSpillCnt := !floatSpillCnt + 1;         (floatSpillCnt := !floatSpillCnt + 1;
355          let val fstp = [I.FSTPL(getFregLoc(S, an, spillLoc))]          let val fstp = [I.fstpl(getFregLoc(S, an, spillLoc))]
356          in  if CB.sameColor(src,C.ST0) then fstp          in  if CB.sameColor(src,C.ST0) then fstp
357              else I.FLDL(I.FDirect(src))::fstp              else I.fldl(I.FDirect(src))::fstp
358          end          end
359         )         )
360    
361     fun spillFcopyTmp S {copy=I.FCOPY{dst, src, ...}, spillLoc, reg,     fun spillFcopyTmp S {copy=I.INSTR(I.FCOPY{dst, src, ...}), spillLoc, reg,
362                          annotations=an} =                          annotations=an} =
363          (floatSpillCnt := !floatSpillCnt + 1;          (floatSpillCnt := !floatSpillCnt + 1;
364           I.FCOPY{dst=dst, src=src, tmp=SOME(getFregLoc(S, an, spillLoc))}           I.fcopy{dst=dst, src=src, tmp=SOME(getFregLoc(S, an, spillLoc))}
365          )          )
366       | spillFcopyTmp S {copy=I.ANNOTATION{i,a}, spillLoc, reg, annotations} =       | spillFcopyTmp S {copy=I.ANNOTATION{i,a}, spillLoc, reg, annotations} =
367          let val i = spillFcopyTmp S {copy=i, spillLoc=spillLoc, reg=reg,          let val i = spillFcopyTmp S {copy=i, spillLoc=spillLoc, reg=reg,
# Line 372  Line 375 
375          )          )
376    
377      (* reload floating point *)      (* reload floating point *)
378      fun reloadF S {instr, reg, spillLoc, annotations=an} =      fun reloadF S {annotations=an,reg,spillLoc,instr} =
379          (floatReloadCnt := !floatReloadCnt + 1;          (floatReloadCnt := !floatReloadCnt + 1;
380           X86Spill.freload(instr, reg, getFregLoc(S, an, spillLoc))           X86Spill.freload(instr, reg, getFregLoc(S, an, spillLoc)))
         )  
381    
382      fun reloadFreg S {dst, reg, spillLoc, annotations=an} =      fun reloadFreg S {dst, reg, spillLoc, annotations=an} =
383          (floatReloadCnt := !floatReloadCnt + 1;          (floatReloadCnt := !floatReloadCnt + 1;
384           if CB.sameColor(dst,C.ST0) then           if CB.sameColor(dst,C.ST0) then
385              [I.FLDL(getFregLoc(S, an, spillLoc))]              [I.fldl(getFregLoc(S, an, spillLoc))]
386           else           else
387              [I.FLDL(getFregLoc(S, an, spillLoc)), I.FSTPL(I.FDirect dst)]              [I.fldl(getFregLoc(S, an, spillLoc)), I.fstpl(I.FDirect dst)]
388          )          )
389    
390      (* -------------------------------------------------------------------      (* -------------------------------------------------------------------
# Line 394  Line 396 
396                      end                      end
397    
398      fun copyInstrF'((rds as [d], rss as [s]), _) =      fun copyInstrF'((rds as [d], rss as [s]), _) =
399           I.FMOVE{fsize=I.FP64,src=FMemReg s,dst=FMemReg d}           I.fmove{fsize=I.FP64,src=FMemReg s,dst=FMemReg d}
400        | copyInstrF'((rds, rss), I.FCOPY{tmp, ...}) =        | copyInstrF'((rds, rss), I.INSTR(I.FCOPY{tmp, ...})) =
401           I.FCOPY{dst=rds, src=rss, tmp=tmp}           I.fcopy{dst=rds, src=rss, tmp=tmp}
402        | copyInstrF'(x, I.ANNOTATION{i, a}) =        | copyInstrF'(x, I.ANNOTATION{i, a}) =
403           I.ANNOTATION{i=copyInstrF'(x,i), a=a}           I.ANNOTATION{i=copyInstrF'(x,i), a=a}
404    
# Line 404  Line 406 
406    
407      fun spillFreg' S {src, reg, spillLoc, annotations=an} =      fun spillFreg' S {src, reg, spillLoc, annotations=an} =
408          (floatSpillCnt := !floatSpillCnt + 1;          (floatSpillCnt := !floatSpillCnt + 1;
409           [I.FMOVE{fsize=I.FP64, src=FMemReg src,           [I.fmove{fsize=I.FP64, src=FMemReg src,
410                    dst=getFregLoc(S, an,spillLoc)}]                    dst=getFregLoc(S, an,spillLoc)}]
411          )          )
412    
# Line 415  Line 417 
417    
418      fun reloadFreg' S {dst, reg, spillLoc, annotations=an} =      fun reloadFreg' S {dst, reg, spillLoc, annotations=an} =
419          (floatReloadCnt := !floatReloadCnt + 1;          (floatReloadCnt := !floatReloadCnt + 1;
420           [I.FMOVE{fsize=I.FP64, dst=FMemReg dst,           [I.fmove{fsize=I.FP64, dst=FMemReg dst,
421                    src=getFregLoc(S,an,spillLoc)}]                    src=getFregLoc(S,an,spillLoc)}]
422          )          )
423    
# Line 424  Line 426 
426       * -------------------------------------------------------------------*)       * -------------------------------------------------------------------*)
427      fun memToMemMove{dst, src} =      fun memToMemMove{dst, src} =
428          let val tmp = I.C.newReg()          let val tmp = I.C.newReg()
429          in  [I.MOVE{mvOp=I.MOVL,src=src,dst=I.Direct tmp},          in  [I.move{mvOp=I.MOVL,src=src,dst=I.Direct tmp},
430               I.MOVE{mvOp=I.MOVL,src=I.Direct tmp,dst=dst}               I.move{mvOp=I.MOVL,src=I.Direct tmp,dst=dst}
431              ]              ]
432          end          end
433    
# Line 433  Line 435 
435          if CB.sameColor(d,s) then [] else          if CB.sameColor(d,s) then [] else
436          let val dx = CB.registerNum d and sx = CB.registerNum s          let val dx = CB.registerNum d and sx = CB.registerNum s
437          in  case (dx >= 8 andalso dx < 32, sx >= 8 andalso sx < 32) of          in  case (dx >= 8 andalso dx < 32, sx >= 8 andalso sx < 32) of
438               (false, false) => [I.COPY{dst=rds, src=rss, tmp=NONE}]               (false, false) => [I.copy{dst=rds, src=rss, tmp=NONE}]
439             | (true, false) => [I.MOVE{mvOp=I.MOVL,src=I.Direct s,             | (true, false) => [I.move{mvOp=I.MOVL,src=I.Direct s,
440                                        dst=I.MemReg d}]                                        dst=I.MemReg d}]
441             | (false, true) => [I.MOVE{mvOp=I.MOVL,src=I.MemReg s,             | (false, true) => [I.move{mvOp=I.MOVL,src=I.MemReg s,
442                                        dst=I.Direct d}]                                        dst=I.Direct d}]
443             | (true, true) => memToMemMove{src=I.MemReg s, dst=I.MemReg d}             | (true, true) => memToMemMove{src=I.MemReg s, dst=I.MemReg d}
444          end          end
445        | copyInstrR((rds, rss), I.COPY{tmp, ...}) =        | copyInstrR((rds, rss), I.INSTR(I.COPY{tmp, ...})) =
446           [I.COPY{dst=rds, src=rss, tmp=tmp}]           [I.copy{dst=rds, src=rss, tmp=tmp}]
447        | copyInstrR(x, I.ANNOTATION{i, a}) =        | copyInstrR(x, I.ANNOTATION{i, a}) =
448            copyInstrR(x, i) (* XXX *)            copyInstrR(x, i) (* XXX *)
449    
# Line 459  Line 461 
461      val K8 = length Int.avail      val K8 = length Int.avail
462    
463       (* register allocation for general purpose registers *)       (* register allocation for general purpose registers *)
464      fun spillR8 S {instr, reg, spillLoc, kill, annotations=an} =      fun spillR8 S {annotations=an, kill, reg, spillLoc, instr} =
465          (case getRegLoc(S, an, reg, spillLoc) of          (case getRegLoc(S, an, reg, spillLoc)
466            {opnd=spillLoc, kind=SPILL_LOC} =>            of {opnd=spillLoc, kind=SPILL_LOC} =>
467             (intSpillCnt := !intSpillCnt + 1;             (intSpillCnt := !intSpillCnt + 1;
468              X86Spill.spill(instr, reg, spillLoc)              X86Spill.spill(instr, reg, spillLoc)
469             )             )
470          | _ => (* don't have to spill a constant *)          | _ => (* don't have to spill a constant *)
471             {code=[], newReg=NONE, proh=[]}             {code=[], newReg=NONE, proh=[]}
472          )          (*esac*))
473    
474      fun isMemReg r = let val x = CB.registerNum r      fun isMemReg r = let val x = CB.registerNum r
475                       in  x >= 8 andalso x < 32 end                       in  x >= 8 andalso x < 32 end
# Line 479  Line 481 
481              val srcLoc = if isMemReg then I.MemReg src else I.Direct src              val srcLoc = if isMemReg then I.MemReg src else I.Direct src
482          in  if kind=CONST_VAL orelse InsnProps.eqOpn(srcLoc, dstLoc) then []          in  if kind=CONST_VAL orelse InsnProps.eqOpn(srcLoc, dstLoc) then []
483              else if isMemReg then memToMemMove{dst=dstLoc, src=srcLoc}              else if isMemReg then memToMemMove{dst=dstLoc, src=srcLoc}
484              else [I.MOVE{mvOp=I.MOVL, src=srcLoc, dst=dstLoc}]              else [I.move{mvOp=I.MOVL, src=srcLoc, dst=dstLoc}]
485          end          end
486    
487      fun spillCopyTmp S {copy=I.COPY{src, dst,...},      fun spillCopyTmp S {copy=I.INSTR(I.COPY{src, dst,...}),
488                          reg, spillLoc, annotations=an} =                          reg, spillLoc, annotations=an} =
489          (case getRegLoc(S, an, reg, spillLoc) of          (case getRegLoc(S, an, reg, spillLoc) of
490             {opnd=tmp, kind=SPILL_LOC} =>             {opnd=tmp, kind=SPILL_LOC} =>
491              (intSpillCnt := !intSpillCnt + 1;              (intSpillCnt := !intSpillCnt + 1;
492               I.COPY{dst=dst, src=src, tmp=SOME tmp}               I.copy{dst=dst, src=src, tmp=SOME tmp}
493              )              )
494           | _ => error "spillCopyTmp"           | _ => error "spillCopyTmp"
495          )          )
# Line 500  Line 502 
502           X86Spill.reload(instr, fromSrc, I.Direct toSrc)           X86Spill.reload(instr, fromSrc, I.Direct toSrc)
503          )          )
504    
505      fun reloadR8 S {instr, reg, spillLoc, annotations=an} =      fun reloadR8 S {annotations=an, reg, spillLoc, instr} =
506          (intReloadCnt := !intReloadCnt + 1;          (intReloadCnt := !intReloadCnt + 1;
507           X86Spill.reload(instr, reg, #opnd(getRegLoc(S,an,reg,spillLoc)))           X86Spill.reload(instr, reg, #opnd(getRegLoc(S,an,reg,spillLoc)))
508          )          )
# Line 512  Line 514 
514              val dstLoc = if isMemReg then I.MemReg dst else I.Direct dst              val dstLoc = if isMemReg then I.MemReg dst else I.Direct dst
515          in  if InsnProps.eqOpn(srcLoc,dstLoc) then []          in  if InsnProps.eqOpn(srcLoc,dstLoc) then []
516              else if isMemReg then memToMemMove{dst=dstLoc, src=srcLoc}              else if isMemReg then memToMemMove{dst=dstLoc, src=srcLoc}
517              else [I.MOVE{mvOp=I.MOVL, src=srcLoc, dst=dstLoc}]              else [I.move{mvOp=I.MOVL, src=srcLoc, dst=dstLoc}]
518          end          end
519    
520      fun resetRA() =      fun resetRA() =

Legend:
Removed from v.1002  
changed lines
  Added in v.1003

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