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/x86Spill.sml
ViewVC logotype

Diff of /sml/trunk/src/MLRISC/x86/ra/x86Spill.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 54  Line 54 
54      | isMemory _ = false      | isMemory _ = false
55    
56    (* Annotate instruction *)    (* Annotate instruction *)
57    fun mark(instr,[]) = instr    fun annotate(instr,[]) = instr
58      | mark(instr,a::an) = mark(I.ANNOTATION{i=instr,a=a},an)      | annotate(instr,a::an) = annotate(I.ANNOTATION{i=instr,a=a},an)
59    
60      fun mark(instr, an) = annotate(I.INSTR instr, an)
61    
62      fun liveKill(add, rmv) ({regs, spilled}, reg) =
63          {regs=rmv(reg, regs), spilled=add(reg, spilled)}
64    
65      val fLiveKill = liveKill (C.addFreg, C.rmvFreg)
66      val rLiveKill = liveKill (C.addReg, C.rmvReg)
67    
68    val newReg = C.newReg    val newReg = C.newReg
69    
70    (* XXX:: Need to go through all the cases where 'done' is used  
71     * to make sure that a the src cannot contain the register    fun spill(instr, reg, spillLoc) = let
72     * being spilled.      fun x86Spill(instr, an) = let
73     *)        fun done(instr, an) = {code=[mark(instr, an)], proh=[], newReg=NONE}
74    fun spill(instr, reg, spillLoc) =      in
   let fun done(instr, an) = {code=[mark(instr, an)], proh=[], newReg=NONE}  
       fun spillIt(instr,an) =  
75        case instr of        case instr of
76          I.CALL{opnd=addr, defs, uses, return, cutsTo, mem, pops} =>          I.CALL{opnd=addr, defs, uses, return, cutsTo, mem, pops} =>
77            done(I.CALL{opnd=addr, defs=C.rmvReg(reg,defs),            done(I.CALL{opnd=addr, defs=C.rmvReg(reg,defs),
# Line 75  Line 81 
81            let val tmpR = newReg() val tmp = I.Direct tmpR            let val tmpR = newReg() val tmp = I.Direct tmpR
82            in  {proh=[tmpR], newReg=SOME tmpR,            in  {proh=[tmpR], newReg=SOME tmpR,
83                 code=[mark(I.MOVE{mvOp=mvOp, src=src, dst=tmp}, an),                 code=[mark(I.MOVE{mvOp=mvOp, src=src, dst=tmp}, an),
84                       I.MOVE{mvOp=I.MOVL, src=tmp, dst=spillLoc}]                       I.move{mvOp=I.MOVL, src=tmp, dst=spillLoc}]
85                }                }
86            end            end
87        | I.MOVE{mvOp, src as I.Direct rs, dst} =>        | I.MOVE{mvOp, src as I.Direct rs, dst} =>
# Line 91  Line 97 
97            in  {proh=[tmpR],            in  {proh=[tmpR],
98                 newReg=SOME tmpR,                 newReg=SOME tmpR,
99                 code=[mark(I.MOVE{mvOp=mvOp, src=src, dst=tmp}, an),                 code=[mark(I.MOVE{mvOp=mvOp, src=src, dst=tmp}, an),
100                       I.MOVE{mvOp=mvOp, src=tmp, dst=spillLoc}]                       I.move{mvOp=mvOp, src=tmp, dst=spillLoc}]
101                }                }
102            end            end
103        | I.LEA{addr, r32} =>        | I.LEA{addr, r32} =>
# Line 99  Line 105 
105            in  {proh=[tmpR],            in  {proh=[tmpR],
106                 newReg=SOME tmpR,                 newReg=SOME tmpR,
107                 code=[mark(I.LEA{addr=addr, r32=tmpR}, an),                 code=[mark(I.LEA{addr=addr, r32=tmpR}, an),
108                       I.MOVE{mvOp=I.MOVL, src=I.Direct tmpR, dst=spillLoc}]                       I.move{mvOp=I.MOVL, src=I.Direct tmpR, dst=spillLoc}]
109                }                }
110            end            end
111        | I.BINARY{binOp=I.XORL, src as I.Direct rs, dst=I.Direct rd} =>        | I.BINARY{binOp=I.XORL, src as I.Direct rs, dst=I.Direct rd} =>
# Line 123  Line 129 
129                val tmp = I.Direct tmpR                val tmp = I.Direct tmpR
130              in              in
131                {proh=[tmpR],                {proh=[tmpR],
132                 code=[I.MOVE{mvOp=I.MOVL, src=spillLoc, dst=tmp},                 code=  [I.move{mvOp=I.MOVL, src=spillLoc, dst=tmp},
133                       I.BINARY{binOp=binOp, src=src, dst=tmp},                         I.binary{binOp=binOp, src=src, dst=tmp},
134                       I.MOVE{mvOp=I.MOVL, src=tmp, dst=spillLoc}],                         I.move{mvOp=I.MOVL, src=tmp, dst=spillLoc}],
135                 newReg=SOME tmpR                 newReg=SOME tmpR
136                }                }
137              end              end
# Line 140  Line 146 
146                val tmp = I.Direct tmpR                val tmp = I.Direct tmpR
147              in              in
148                { proh=[tmpR],                { proh=[tmpR],
149                  code=[I.MOVE{mvOp=I.MOVL, src=src, dst=tmp},                  code=[I.move{mvOp=I.MOVL, src=src, dst=tmp},
150                        I.BINARY{binOp=binOp, src=tmp, dst=spillLoc}],                        I.binary{binOp=binOp, src=tmp, dst=spillLoc}],
151                  newReg=NONE                  newReg=NONE
152                 }                 }
153              end              end
# Line 156  Line 162 
162             let val tmpR = newReg()             let val tmpR = newReg()
163                 val tmp  = I.Direct tmpR                 val tmp  = I.Direct tmpR
164             in {proh=[],             in {proh=[],
165                 code=[I.MOVE{mvOp=I.MOVL, src=src, dst=tmp},                 code=[I.move{mvOp=I.MOVL, src=src, dst=tmp},
166                       mark(I.CMPXCHG{lock=lock,sz=sz,src=tmp,dst=spillLoc},an)],                       mark(I.CMPXCHG{lock=lock,sz=sz,src=tmp,dst=spillLoc},an)],
167                 newReg=NONE                 newReg=NONE
168                }                }
# Line 166  Line 172 
172            let val tmpR = newReg()            let val tmpR = newReg()
173            in  {proh=[tmpR], newReg=SOME tmpR,            in  {proh=[tmpR], newReg=SOME tmpR,
174                 code=[mark(I.MUL3{src1=src1, src2=src2, dst=tmpR}, an),                 code=[mark(I.MUL3{src1=src1, src2=src2, dst=tmpR}, an),
175                       I.MOVE{mvOp=I.MOVL, src=I.Direct tmpR, dst=spillLoc}]                       I.move{mvOp=I.MOVL, src=I.Direct tmpR, dst=spillLoc}]
176                }                }
177            end            end
178        | I.UNARY{unOp, opnd} => done(I.UNARY{unOp=unOp, opnd=spillLoc}, an)        | I.UNARY{unOp, opnd} => done(I.UNARY{unOp=unOp, opnd=spillLoc}, an)
# Line 174  Line 180 
180        | I.POP _ => done(I.POP spillLoc, an)        | I.POP _ => done(I.POP spillLoc, an)
181        | I.COPY _ => error "spill: COPY"        | I.COPY _ => error "spill: COPY"
182        | I.FNSTSW  => error "spill: FNSTSW"        | I.FNSTSW  => error "spill: FNSTSW"
       | I.ANNOTATION{i,a} => spillIt(i, a::an)  
183        | _ => error "spill"        | _ => error "spill"
184    in  spillIt(instr, [])      end (* x86Spill *)
185    end (* spill *)  
186        fun f(I.INSTR instr, an) = x86Spill(instr, an)
187          | f(I.ANNOTATION{a, i}, an) = f(i, a::an)
188          | f(I.KILL lk, an) =
189               {code=[annotate(I.KILL(rLiveKill (lk, reg)), an)],
190                proh=[],
191                newReg=NONE}
192          | f _ = error "spill:f"
193      in f(instr, [])
194      end
195    
196    fun reload(instr, reg, spillLoc) =    fun reload(instr, reg, spillLoc) = let
197    let fun operand(rt, opnd) =      fun x86Reload(instr, reg, spillLoc, an) = let
198            fun operand(rt, opnd) =
199        (case opnd        (case opnd
200         of I.Direct r => if CB.sameColor(r,reg) then I.Direct rt else opnd         of I.Direct r => if CB.sameColor(r,reg) then I.Direct rt else opnd
201          | I.Displace{base, disp, mem} =>          | I.Displace{base, disp, mem} =>
# Line 215  Line 230 
230            let val tmpR = newReg()            let val tmpR = newReg()
231            in  {newReg=NONE,            in  {newReg=NONE,
232                 proh=[tmpR],                 proh=[tmpR],
233                 code=[I.MOVE{mvOp=I.MOVL, src=spillLoc, dst=I.Direct tmpR},                   code=[I.move{mvOp=I.MOVL, src=spillLoc, dst=I.Direct tmpR},
234                       mark(f tmpR, an)                       mark(f tmpR, an)
235                      ]                      ]
236                }                }
# Line 234  Line 249 
249                  val tmp  = I.Direct tmpR                  val tmp  = I.Direct tmpR
250              in  {newReg=SOME tmpR,              in  {newReg=SOME tmpR,
251                   proh=[tmpR],                   proh=[tmpR],
252                   code=[I.MOVE{mvOp=I.MOVL, src=spillLoc, dst=I.Direct tmpR},                     code=[I.move{mvOp=I.MOVL, src=spillLoc, dst=I.Direct tmpR},
253                         mark(f tmpR, an)                         mark(f tmpR, an)
254                        ]                        ]
255                  }                  }
# Line 299  Line 314 
314    
315      fun reloadReal(realOp, opnd, an) =      fun reloadReal(realOp, opnd, an) =
316            withTmpAvail(fn tmpR => realOp(operand(tmpR, opnd)), an)            withTmpAvail(fn tmpR => realOp(operand(tmpR, opnd)), an)
317       in
     fun reloadIt(instr, an) =  
318      case instr      case instr
319      of I.JMP(I.Direct _, labs) => done(I.JMP(spillLoc, labs), an)      of I.JMP(I.Direct _, labs) => done(I.JMP(spillLoc, labs), an)
320       | I.JMP(opnd, labs) => withTmp(fn t => I.JMP(operand(t, opnd), labs), an)       | I.JMP(opnd, labs) => withTmp(fn t => I.JMP(operand(t, opnd), labs), an)
# Line 311  Line 325 
325            withTmp(fn t =>            withTmp(fn t =>
326                I.CALL{opnd=operand(t, opnd), defs=defs, return=return,pops=pops,                I.CALL{opnd=operand(t, opnd), defs=defs, return=return,pops=pops,
327                       uses=C.rmvReg(reg, uses), cutsTo=cutsTo, mem=mem}, an)                       uses=C.rmvReg(reg, uses), cutsTo=cutsTo, mem=mem}, an)
 (***  
        let val tmpR = newReg()  
        in  {proh=[tmpR],  
             newReg=NONE,  
             code=[mark(  
                    I.CALL(operand(tmpR, opnd), defs, C.rmvReg(reg,uses), mem),  
                   an)]  
            }  
        end  
 ***)  
328       | I.MOVE{mvOp, src as I.Direct _, dst as I.Direct _} =>       | I.MOVE{mvOp, src as I.Direct _, dst as I.Direct _} =>
329          done(I.MOVE{mvOp=mvOp, src=replace src, dst=dst},an)          done(I.MOVE{mvOp=mvOp, src=replace src, dst=dst},an)
330       | I.MOVE{mvOp, src, dst as I.Direct _} =>       | I.MOVE{mvOp, src, dst as I.Direct _} =>
# Line 425  Line 429 
429                    lsrc=operand(tmpR, lsrc), rsrc=operand(tmpR, rsrc)                    lsrc=operand(tmpR, lsrc), rsrc=operand(tmpR, rsrc)
430                   }, an)                   }, an)
431    
      | I.ANNOTATION{i,a} => reloadIt(i, a::an)  
432       | _ => error "reload"       | _ => error "reload"
433    in reloadIt(instr, [])      end (*x86Reload*)
434    
435        fun f(I.ANNOTATION{a, i}, an) = f(i, a::an)
436          | f(I.INSTR i, an) = x86Reload(i, reg, spillLoc, an)
437          | f(I.LIVE lk, an) =
438               {code=[annotate(I.LIVE(rLiveKill (lk, reg)), an)],
439                proh=[],
440                newReg=NONE}
441          | f _ = error "reload: f"
442      in f(instr, [])
443    end (*reload*)    end (*reload*)
444    
445    fun fspill(instr, reg, spillLoc) =  
446    let fun withTmp(f, fsize, an) =  
447        let val tmpR = C.newFreg()  
448      fun fspill(instr, reg, spillLoc) = let
449        fun x86Fspill(instr, reg, spillLoc, an) = let
450          fun withTmp(f, fsize, an) = let
451            val tmpR = C.newFreg()
452            val tmp  = I.FPR tmpR            val tmp  = I.FPR tmpR
453        in  {proh=[tmpR],        in
454             { proh=[tmpR],
455             code=[mark(f tmp, an),             code=[mark(f tmp, an),
456                   I.FMOVE{fsize=fsize, src=tmp, dst=spillLoc}],                   I.fmove{fsize=fsize, src=tmp, dst=spillLoc}],
457             newReg=SOME tmpR (* XXX Should we propagate the definition? *)             newReg=SOME tmpR (* XXX Should we propagate the definition? *)
458            }            }
459        end        end
460        fun spillIt(instr, an) =      in
461        (case instr of        case instr
462           I.FSTPL _ => {proh=[], code=[mark(I.FSTPL spillLoc, an)], newReg=NONE}        of I.FSTPL _ => {proh=[], code=[mark(I.FSTPL spillLoc, an)], newReg=NONE}
463         | I.FSTPS _ => {proh=[], code=[mark(I.FSTPS spillLoc, an)], newReg=NONE}         | I.FSTPS _ => {proh=[], code=[mark(I.FSTPS spillLoc, an)], newReg=NONE}
464         | I.FSTPT _ => {proh=[], code=[mark(I.FSTPT spillLoc, an)], newReg=NONE}         | I.FSTPT _ => {proh=[], code=[mark(I.FSTPT spillLoc, an)], newReg=NONE}
465         | I.FSTL _ => {proh=[], code=[mark(I.FSTL spillLoc, an)], newReg=NONE}         | I.FSTL _ => {proh=[], code=[mark(I.FSTL spillLoc, an)], newReg=NONE}
# Line 484  Line 501 
501            {proh=[],code=[mark(I.FUNOP{fsize=fsize,unOp=unOp,            {proh=[],code=[mark(I.FUNOP{fsize=fsize,unOp=unOp,
502                                        src=src,dst=spillLoc},an)],                                        src=src,dst=spillLoc},an)],
503                          newReg=NONE}                          newReg=NONE}
        | I.ANNOTATION{i,a} => spillIt(i, a::an)  
504         | _ => error "fspill"         | _ => error "fspill"
505        (*esac*))        (*esac*)
506    in  spillIt(instr, [])      end (* x86Fspill *)
507    end (* fspill *)      fun f(I.ANNOTATION{a,i}, an) = f(i, a::an)
508          | f(I.INSTR(i), an) = x86Fspill(i, reg, spillLoc, an)
509          | f(I.KILL lk, an) =
510               {code=[annotate(I.KILL(fLiveKill (lk, reg)), an)],
511                proh=[],
512                newReg=NONE}
513          | f _ = error "fspill:f"
514      in f(instr, [])
515      end
516    
517    fun freload(instr, reg, spillLoc) =  
518    let fun rename(src as I.FDirect f) =    fun freload(instr, reg, spillLoc) = let
519        fun x86Freload(instr, reg, spillLoc, an) = let
520            fun rename(src as I.FDirect f) =
521            if CB.sameColor(f,reg) then spillLoc else src            if CB.sameColor(f,reg) then spillLoc else src
522          | rename(src as I.FPR f) =          | rename(src as I.FPR f) =
523            if CB.sameColor(f,reg) then spillLoc else src            if CB.sameColor(f,reg) then spillLoc else src
# Line 506  Line 532 
532                  val ftmp  = I.FPR(ftmpR)                  val ftmp  = I.FPR(ftmpR)
533              in  {newReg=NONE,              in  {newReg=NONE,
534                   proh=[ftmpR],                   proh=[ftmpR],
535                   code=[I.FMOVE{fsize=fsize, src=spillLoc, dst=ftmp},                     code=[I.fmove{fsize=fsize, src=spillLoc, dst=ftmp},
536                         mark(f ftmp, an)                         mark(f ftmp, an)
537                        ]                        ]
538                  }                  }
539              end              end
540         in
       fun reloadIt(instr, an) =  
541        (case instr of        (case instr of
542           I.FLDT opnd => {code=[mark(I.FLDT spillLoc, an)], proh=[], newReg=NONE}           I.FLDT opnd => {code=[mark(I.FLDT spillLoc, an)], proh=[], newReg=NONE}
543         | I.FLDL opnd => {code=[mark(I.FLDL spillLoc, an)], proh=[], newReg=NONE}         | I.FLDL opnd => {code=[mark(I.FLDL spillLoc, an)], proh=[], newReg=NONE}
# Line 577  Line 602 
602                              return=return, pops=pops,                              return=return, pops=pops,
603                              uses=uses, cutsTo=cutsTo, mem=mem}, an)],                              uses=uses, cutsTo=cutsTo, mem=mem}, an)],
604            newReg=NONE}            newReg=NONE}
        | I.ANNOTATION{i,a} => reloadIt(i, a::an)  
605         | _  => error "freload"         | _  => error "freload"
606        (*esac*))        (*esac*))
607    in  reloadIt(instr, [])      end (* x86Freload *)
   end (* freload *)  
608    
609        fun f(I.ANNOTATION{a, i}, an) = f(i, a::an)
610          | f(I.INSTR i, an) = x86Freload(i, reg, spillLoc, an)
611          | f(I.LIVE lk, an) =
612               {code=[annotate(I.LIVE(fLiveKill (lk, reg)), an)],
613                proh=[],
614                newReg=NONE}
615          | f _ = error "freload.f"
616    
617      in f(instr, [])
618      end
619  end  end

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