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/releases/release-110.64/ra/ra-spill.sml
ViewVC logotype

Diff of /MLRISC/releases/release-110.64/ra/ra-spill.sml

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

revision 474, Wed Nov 10 22:59:58 1999 UTC revision 475, Wed Nov 10 22:59:58 1999 UTC
# Line 31  Line 31 
31        {instr    : I.instruction,       (* instruction where spill is to occur *)        {instr    : I.instruction,       (* instruction where spill is to occur *)
32         reg      : C.cell,              (* register to spill *)         reg      : C.cell,              (* register to spill *)
33         spillLoc : int,                 (* logical spill location *)         spillLoc : int,                 (* logical spill location *)
34         node     : RAGraph.node,     (* the current node *)         graph    : RAGraph.interferenceGraph, (* the current graph *)
35         kill     : bool,                (* can we kill the current node? *)         kill     : bool,                (* can we kill the current node? *)
36         regmap   : C.cell -> C.cell,    (* current register map *)         regmap   : C.cell -> C.cell,    (* current register map *)
37         annotations : Annotations.annotations ref (* annotations *)         annotations : Annotations.annotations ref (* annotations *)
# Line 45  Line 45 
45        {instr    : I.instruction,       (* instruction where spill is to occur *)        {instr    : I.instruction,       (* instruction where spill is to occur *)
46         reg      : C.cell,              (* register to spill *)         reg      : C.cell,              (* register to spill *)
47         spillLoc : int,                 (* logical spill location *)         spillLoc : int,                 (* logical spill location *)
48         node     : RAGraph.node,     (* the current node *)         graph    : RAGraph.interferenceGraph, (* the current graph *)
49         regmap   : C.cell -> C.cell,    (* current register map *)         regmap   : C.cell -> C.cell,    (* current register map *)
50         annotations : Annotations.annotations ref (* annotations *)         annotations : Annotations.annotations ref (* annotations *)
51        } ->        } ->
# Line 74  Line 74 
74           | add(SOME i,l) = i::l           | add(SOME i,l) = i::l
75    
76    
77         fun getLoc(G.NODE{color=ref(G.ALIASED_SPILL n), ...}) = getLoc n         fun getLoc(G.NODE{color=ref(G.ALIASED n), ...}) = getLoc n
78           | getLoc(G.NODE{color=ref(G.SPILLED ~1), number, ...}) = number           | getLoc(G.NODE{color=ref(G.SPILLED ~1), number, ...}) = number
79           | getLoc(G.NODE{color=ref(G.SPILLED c), ...}) = c           | getLoc(G.NODE{color=ref(G.SPILLED c), ...}) = c
80           | getLoc(G.NODE{number, ...}) = number           | getLoc(G.NODE{number, ...}) = number
# Line 83  Line 83 
83          * Insert reloading code for an instruction.          * Insert reloading code for an instruction.
84          * Note: reload code goes after the instruction, if any.          * Note: reload code goes after the instruction, if any.
85          *)          *)
86         fun reloadInstr(instr,spillReg,spillLoc,node,annotations) =         fun reloadInstr(instr,spillReg,spillLoc,annotations) =
87         let val {code,proh} =         let val {code,proh} =
88                reload{regmap=regmap,instr=instr,reg=spillReg,                reload{regmap=regmap,instr=instr,reg=spillReg,
89                       spillLoc=spillLoc,node=node,annotations=annotations}                       spillLoc=spillLoc,graph=G,annotations=annotations}
90         in  addProh(proh);         in  addProh(proh);
91             code             code
92         end         end
# Line 114  Line 114 
114          *    reload copies          *    reload copies
115          *          *
116          *)          *)
117         fun reloadCopySrc(instr,dst,src,spillReg,spillLoc,node,annotations) =         fun reloadCopySrc(instr,dst,src,spillReg,spillLoc,annotations) =
118         let val (mvs, copyDst, copySrc) = extractUses(spillReg, dst, src)         let val (mvs, copyDst, copySrc) = extractUses(spillReg, dst, src)
119             fun processMoves([], reloadCode) = reloadCode             fun processMoves([], reloadCode) = reloadCode
120               | processMoves(mv::mvs, reloadCode) =               | processMoves(mv::mvs, reloadCode) =
121                 let val mv = copyInstr(mv, instr)                 let val mv = copyInstr(mv, instr)
122                     val {code, proh} =                     val {code, proh} =
123                       reload{regmap=regmap,instr=mv,spillLoc=spillLoc,                       reload{regmap=regmap,instr=mv,spillLoc=spillLoc,
124                              node=node,reg=spillReg,annotations=annotations}                              graph=G,reg=spillReg,annotations=annotations}
125                 in  addProh(proh);                 in  addProh(proh);
126                     processMoves(mvs, code@reloadCode)                     processMoves(mvs, code@reloadCode)
127                 end                 end
# Line 134  Line 134 
134         (*         (*
135          * Insert reload code          * Insert reload code
136          *)          *)
137         fun reload(instr,spillReg,spillLoc,node,annotations) =         fun reload(instr,spillReg,spillLoc,annotations) =
138             if P.moveInstr instr then             if P.moveInstr instr then
139                let val (dst,src) = P.moveDstSrc instr                let val (dst,src) = P.moveDstSrc instr
140                in  case dst of                in  case dst of
141                      [_] => reloadInstr(instr,spillReg,spillLoc,node,annotations)                      [_] => reloadInstr(instr,spillReg,spillLoc,annotations)
142                    | _   => reloadCopySrc(instr,dst,src,spillReg,                    | _   => reloadCopySrc(instr,dst,src,spillReg,
143                                           spillLoc,node,annotations)                                           spillLoc,annotations)
144                end                end
145             else             else
146                reloadInstr(instr,spillReg,spillLoc,node,annotations)                reloadInstr(instr,spillReg,spillLoc,annotations)
147    
148         (*         (*
149          * Check whether the spillReg is in a list          * Check whether the spillReg is in a list
# Line 157  Line 157 
157          * If the value in spillReg is never used, the client also          * If the value in spillReg is never used, the client also
158          * has the opportunity to remove the instruction.          * has the opportunity to remove the instruction.
159          *)          *)
160         fun spillInstr(instr,spillReg,spillLoc,node,annotations,kill) =         fun spillInstr(instr,spillReg,spillLoc,annotations,kill) =
161         let val {code, instr, proh} =         let val {code, instr, proh} =
162                spill{regmap=regmap, instr=instr,                spill{regmap=regmap, instr=instr,
163                      node=node, kill=kill, spillLoc=spillLoc,                      graph=G, kill=kill, spillLoc=spillLoc,
164                      reg=spillReg, annotations=annotations}                      reg=spillReg, annotations=annotations}
165         in  addProh(proh);         in  addProh(proh);
166             add(instr,code)             add(instr,code)
# Line 189  Line 189 
189          *    d1...dn/r <- s1...sn/r          *    d1...dn/r <- s1...sn/r
190          *          *
191          *)          *)
192         fun spillCopyDst(instr,spillReg,spillLoc,node,annotations,kill) =         fun spillCopyDst(instr,spillReg,spillLoc,annotations,kill) =
193         let val (dst, src) = P.moveDstSrc instr         let val (dst, src) = P.moveDstSrc instr
194             val (mvDst,mvSrc,copyDst,copySrc,kill) =             val (mvDst,mvSrc,copyDst,copySrc,kill) =
195                  extractDef(spillReg,dst,src,kill)                  extractDef(spillReg,dst,src,kill)
# Line 204  Line 204 
204             let val mvInstr = copyInstr((mvDst,mvSrc),instr)             let val mvInstr = copyInstr((mvDst,mvSrc),instr)
205                   (* spill the move instruction *)                   (* spill the move instruction *)
206                 val spillCode = spillInstr(mvInstr,spillReg,spillLoc,                 val spillCode = spillInstr(mvInstr,spillReg,spillLoc,
207                                            node,annotations,false)                                            annotations,false)
208             in  spillCode @ [copy]             in  spillCode @ [copy]
209             end             end
210         end         end
# Line 212  Line 212 
212         (*         (*
213          * Insert spill code for a copy          * Insert spill code for a copy
214          *)          *)
215         fun spillCopy(instr,spillReg,spillLoc,node,annotations,kill) =         fun spillCopy(instr,spillReg,spillLoc,annotations,kill) =
216             case P.moveTmpR instr of             case P.moveTmpR instr of
217               NONE => spillCopyDst(instr,spillReg,spillLoc,node,annotations,kill)               NONE => spillCopyDst(instr,spillReg,spillLoc,annotations,kill)
218             | SOME tmp =>             | SOME tmp =>
219                 if regmap tmp = spillReg                 if regmap tmp = spillReg
220                 then spillInstr(instr,spillReg,spillLoc,node,annotations,false)                 then spillInstr(instr,spillReg,spillLoc,annotations,false)
221                 else spillCopyDst(instr,spillReg,spillLoc,node,annotations,kill)                 else spillCopyDst(instr,spillReg,spillLoc,annotations,kill)
222    
223         (*         (*
224          * Insert spill code          * Insert spill code
225          *)          *)
226         fun spill(instr,spillReg,spillLoc,node,annotations,killSet) =         fun spill(instr,spillReg,spillLoc,annotations,killSet) =
227         let val kill = killable(spillReg,killSet)         let val kill = killable(spillReg,killSet)
228         in  if P.moveInstr instr then         in  if P.moveInstr instr then
229                spillCopy(instr,spillReg,spillLoc,node,annotations,kill)                spillCopy(instr,spillReg,spillLoc,annotations,kill)
230             else             else
231                spillInstr(instr,spillReg,spillLoc,node,annotations,kill)                spillInstr(instr,spillReg,spillLoc,annotations,kill)
232         end         end
233    
234         (*         (*
# Line 241  Line 241 
241             fun hasDef(i,reg) = contains(#1(insnDefUse i),reg)             fun hasDef(i,reg) = contains(#1(insnDefUse i),reg)
242             fun hasUse(i,reg) = contains(#2(insnDefUse i),reg)             fun hasUse(i,reg) = contains(#2(insnDefUse i),reg)
243    
244             fun spillOneReg([],_,_,_,killSet) = []             fun spillOneReg([],_,_,killSet) = []
245               | spillOneReg(i::instrs,r,spillLoc,node,killSet) =               | spillOneReg(i::instrs,r,spillLoc,killSet) =
246                 if hasDef(i,r)                 if hasDef(i,r)
247                 then                 then
248                  spillOneReg(spill(i,r,spillLoc,node,annotations,killSet)@instrs,                  spillOneReg(spill(i,r,spillLoc,annotations,killSet)@instrs,
249                                    r,spillLoc,node,killSet)                                    r,spillLoc,killSet)
250                 else i::spillOneReg(instrs,r,spillLoc,node,killSet)                 else i::spillOneReg(instrs,r,spillLoc,killSet)
251    
252             fun reloadOneReg([],_,_,_) = []             fun reloadOneReg([],_,_) = []
253               | reloadOneReg(i::instrs,r,spillLoc,node) =               | reloadOneReg(i::instrs,r,spillLoc) =
254                 if hasUse(i,r)                 if hasUse(i,r)
255                 then reloadOneReg(reload(i,r,spillLoc,node,annotations)@instrs,                 then reloadOneReg(reload(i,r,spillLoc,annotations)@instrs,
256                                   r,spillLoc,node)                                   r,spillLoc)
257                 else i::reloadOneReg(instrs,r,spillLoc,node)                 else i::reloadOneReg(instrs,r,spillLoc)
258    
259             (* This function spills a set of registers for an instruction *)             (* This function spills a set of registers for an instruction *)
260             fun spillAll(instrs,[],killSet) = instrs             fun spillAll(instrs,[],killSet) = instrs
261               | spillAll(instrs,r::rs,killSet) =               | spillAll(instrs,r::rs,killSet) =
262                 let val node     = getnode r                 let val node     = getnode r
263                     val spillLoc = getLoc node                     val spillLoc = getLoc node
264                 in  spillAll(spillOneReg(instrs,r,spillLoc,node,killSet),                 in  spillAll(spillOneReg(instrs,r,spillLoc,killSet),
265                              rs,killSet)                              rs,killSet)
266                 end                 end
267    
# Line 270  Line 270 
270               | reloadAll(instrs,r::rs) =               | reloadAll(instrs,r::rs) =
271                 let val node     = getnode r                 let val node     = getnode r
272                     val spillLoc = getLoc node                     val spillLoc = getLoc node
273                 in  reloadAll(reloadOneReg(instrs,r,spillLoc,node),rs)                 in  reloadAll(reloadOneReg(instrs,r,spillLoc),rs)
274                 end                 end
275    
276             (* Eliminate duplicates from the spill/reload candidates *)             (* Eliminate duplicates from the spill/reload candidates *)

Legend:
Removed from v.474  
changed lines
  Added in v.475

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