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/ra/ra-spill-with-renaming.sml
ViewVC logotype

Diff of /sml/trunk/src/MLRISC/ra/ra-spill-with-renaming.sml

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

revision 705, Wed Sep 27 18:44:44 2000 UTC revision 815, Fri May 4 05:09:10 2001 UTC
# Line 26  Line 26 
26   * Allen (5/9/00)   * Allen (5/9/00)
27   *   *
28   *)   *)
29  (* This module manages the spill/reload process.  (*
30     * This module manages the spill/reload process.
31   * The reason this is detached from the main module is that   * The reason this is detached from the main module is that
32   * I can't understand the old code.   * I can't understand the old code.
33   *   *
# Line 74  Line 75 
75   *   *
76   * -- Allen   * -- Allen
77   *)   *)
78    
79    local
80    
81       val debug = false
82    
83    in
84    
85  functor RASpillWithRenaming  functor RASpillWithRenaming
86     (structure InsnProps : INSN_PROPERTIES     (structure InsnProps : INSN_PROPERTIES
87      structure Asm       : INSTRUCTION_EMITTER      structure Asm       : INSTRUCTION_EMITTER
# Line 100  Line 108 
108     structure I      = InsnProps.I     structure I      = InsnProps.I
109     structure P      = InsnProps     structure P      = InsnProps
110     structure C      = I.C     structure C      = I.C
    structure G      = RAGraph  
111     structure Core   = RACore     structure Core   = RACore
112     structure SL     = SortedList     structure G      = Core.G
113    
114     fun error msg = MLRiscErrorMsg.error("RASmartSpill",msg)     fun error msg = MLRiscErrorMsg.error("RASpillWithRenaming",msg)
115    
116     fun dec n = Word.toIntX(Word.fromInt n - 0w1)     fun dec n = Word.toIntX(Word.fromInt n - 0w1)
117    
118     type copyInstr =     structure T = RASpillTypes(I)
119            (C.cell list * C.cell list) * I.instruction -> I.instruction list     open T
120    
121     (*     fun uniq s = C.SortedCells.return(C.SortedCells.uniq s)
122      * Spill the value associated with reg into spillLoc.     val i2s    = Int.toString
     * All definitions of instr should be renamed to a new temporary newReg.  
     *)  
    type spill =  
       {instr    : I.instruction,       (* instruction where spill is to occur *)  
        reg      : C.cell,              (* register to spill *)  
        spillLoc : int,                 (* logical spill location *)  
        kill     : bool,                (* can we kill the current node? *)  
        regmap   : C.cell -> C.cell,    (* current register map *)  
        annotations : Annotations.annotations ref (* annotations *)  
       } ->  
       {code     : I.instruction list,  (* instruction + spill code *)  
        proh     : C.cell list,         (* prohibited from future spilling *)  
        newReg   : C.cell option        (* the spilled value is available here *)  
       }  
   
    (* Spill the register src into spillLoc.  
     * The value is originally from register reg.  
     *)  
    type spillSrc =  
       {src      : C.cell,              (* register to spill from *)  
        reg      : C.cell,              (* the register *)  
        spillLoc : int,                 (* logical spill location *)  
        annotations : Annotations.annotations ref (* annotations *)  
       } -> I.instruction list          (* spill code *)  
   
    (*  
     * Spill the temporary associated with a copy into spillLoc  
     *)  
    type spillCopyTmp =  
       {copy     : I.instruction,       (* copy to spill *)  
        spillLoc : int,                 (* logical spill location *)  
        annotations : Annotations.annotations ref (* annotations *)  
       } -> I.instruction               (* spill code *)  
   
    (*  
     * Reload the value associated with reg from spillLoc.  
     * All uses of instr should be renamed to a new temporary newReg.  
     *)  
    type reload =  
       {instr    : I.instruction,       (* instruction where spill is to occur *)  
        reg      : C.cell,              (* register to spill *)  
        spillLoc : int,                 (* logical spill location *)  
        regmap   : C.cell -> C.cell,    (* current register map *)  
        annotations : Annotations.annotations ref (* annotations *)  
       } ->  
       {code     : I.instruction list,  (* instr + reload code *)  
        proh     : C.cell list,         (* prohibited from future spilling *)  
        newReg   : C.cell option        (* the reloaded value is here *)  
       }  
   
    (*  
     * Rename all uses fromSrc to toSrc  
     *)  
    type renameSrc =  
       {instr    : I.instruction,       (* instruction where spill is to occur *)  
        fromSrc  : C.cell,              (* register to rename *)  
        toSrc    : C.cell,              (* register to rename to *)  
        regmap   : C.cell -> C.cell     (* current register map *)  
       } ->  
       {code     : I.instruction list,  (* renamed instr *)  
        proh     : C.cell list,         (* prohibited from future spilling *)  
        newReg   : C.cell option        (* the renamed value is here *)  
       }  
   
    (* Reload the register dst from spillLoc.  
     * The value is originally from register reg.  
     *)  
    type reloadDst =  
       {dst      : C.cell,              (* register to reload to *)  
        reg      : C.cell,              (* the register *)  
        spillLoc : int,                 (* logical spill location *)  
        annotations : Annotations.annotations ref (* annotations *)  
       } -> I.instruction list          (* reload code *)  
   
    (* val spilledCopyTmps = MLRiscControl.getCounter "ra-spilled-copy-temps" *)  
123    
124     val Asm.S.STREAM{emit, ...} = Asm.makeStream[]     val Asm.S.STREAM{emit, ...} = Asm.makeStream[]
125    
126     val debug = false     (* val spilledCopyTmps = MLRiscControl.getCounter "ra-spilled-copy-temps" *)
127    
128     (*     (*
129      * The following function performs spilling.      * The following function performs spilling.
# Line 209  Line 141 
141           spillSet, reloadSet, killSet           spillSet, reloadSet, killSet
142          } =          } =
143     let     let
144         val regmap = Core.spillRegmap G (* This is the current regmap *)         (* Must do this to make sure the interference graph is
145         val spillLocOf = Core.spillLoc G          * reflected to the cells
146            *)
147           val _ = Core.updateCellAliases G
148    
149           val getSpillLoc = Core.spillLoc G
150           fun spillLocOf(C.CELL{id, ...}) = getSpillLoc id
151         val spillLocsOf = map spillLocOf         val spillLocsOf = map spillLocOf
152         val getnode = Intmap.map nodes         val getnode = IntHashTable.lookup nodes
153           val getnode = fn C.CELL{id, ...} => getnode id
154    
155         val MAX_DIST = !max_dist         val MAX_DIST = !max_dist
156    
# Line 222  Line 160 
160         let fun isDedicated r = Array.sub(dedicated,r) handle _ => false         let fun isDedicated r = Array.sub(dedicated,r) handle _ => false
161             fun loop [] = false             fun loop [] = false
162               | loop(r::rs) =               | loop(r::rs) =
163                 if isDedicated r then loop rs else true                 if isDedicated(C.registerId r) then loop rs else true
164         in  loop rs end         in  loop rs end
165    
166         (* Merge prohibited registers *)         (* Merge prohibited registers *)
167         val enterSpill = Intmap.add spilledRegs         val enterSpill = IntHashTable.insert spilledRegs
168         val addProh = app (fn r => enterSpill(r,true))         val addProh = app (fn c => enterSpill(C.registerId c,true))
169    
170         val getSpills  : int -> C.cell list = Intmap.mapWithDefault(spillSet,[])         val getSpills  = G.PPtHashTable.find spillSet
171         val getReloads : int -> C.cell list = Intmap.mapWithDefault(reloadSet,[])         val getSpills  = fn p => case getSpills p of SOME s => s | NONE => []
172         val getKills   : int -> C.cell list = Intmap.mapWithDefault(killSet,[])         val getReloads = G.PPtHashTable.find reloadSet
173           val getReloads = fn p => case getReloads p of SOME s => s | NONE => []
174           val getKills   = G.PPtHashTable.find killSet
175           val getKills   = fn p => case getKills p of SOME s => s | NONE => []
176    
177         fun getLoc(G.NODE{color=ref(G.ALIASED n), ...}) = getLoc n         fun getLoc(G.NODE{color=ref(G.ALIASED n), ...}) = getLoc n
178           | getLoc(G.NODE{color=ref(G.SPILLED), number, ...}) = number           | getLoc(G.NODE{color=ref(G.MEMREG(_, m)), ...}) = G.MEM_REG m
179           | getLoc(G.NODE{color=ref(G.MEMREG m), ...}) = m           | getLoc(G.NODE{color=ref(G.SPILL_LOC s), ...}) = G.FRAME s
180           | getLoc(G.NODE{color=ref(G.SPILL_LOC s), ...}) = ~s           | getLoc(G.NODE{color=ref(G.SPILLED), number, ...}) = G.FRAME number
181           | getLoc(G.NODE{number, ...}) = number           | getLoc(G.NODE{color=ref(G.PSEUDO), number, ...}) = G.FRAME number
182             | getLoc _ = error "getLoc"
183    
184           fun printRegs regs =
185               app (fn r => print(C.toString r^" ["^
186                                  Core.spillLocToString G (C.cellId r)^"] ")) regs
187    
188           val parallelCopies = Word.andb(Core.HAS_PARALLEL_COPIES, mode) <> 0w0
189    
190           fun chase(C.CELL{col=ref(C.ALIASED c), ...}) = chase c
191             | chase c = c
192    
193           fun cellId(C.CELL{id, ...}) = id
194    
195           fun sameCell(C.CELL{id=x,...}, C.CELL{id=y, ...}) = x=y
196    
197           fun same(x,regToSpill) = sameCell(chase x,regToSpill)
198    
        val parallelCopies = Word.andb(RACore.HAS_PARALLEL_COPIES, mode) <> 0w0  
199         (*         (*
200          * Rewrite the instruction given that a bunch of registers have          * Rewrite the instruction given that a bunch of registers have
201          * to be spilled and reloaded.          * to be spilled and reloaded.
# Line 256  Line 212 
212             and kill(env,r) =             and kill(env,r) =
213             let fun loop([], env') = env'             let fun loop([], env') = env'
214                   | loop((binding as (r',_,_))::env,env') =                   | loop((binding as (r',_,_))::env,env') =
215                     loop(env, if r = r' then env' else binding::env')                     loop(env,
216                            if C.sameColor(r, r') then env' else binding::env')
217             in  loop(env, []) end             in  loop(env, []) end
218    
219             (*             (*
# Line 265  Line 222 
222              *)              *)
223             fun reloadInstr(pt,instr,regToSpill,env,spillLoc) =             fun reloadInstr(pt,instr,regToSpill,env,spillLoc) =
224             let val {code, proh, newReg} =             let val {code, proh, newReg} =
225                    reload{regmap=regmap,instr=instr,reg=regToSpill,                    reload{instr=instr,reg=regToSpill,
226                           spillLoc=spillLoc,annotations=annotations}                           spillLoc=spillLoc,annotations=annotations}
227             in  addProh(proh);             in  addProh(proh);
228                 (code,update(pt,env,regToSpill,newReg))                 (code,update(pt,env,regToSpill,newReg))
# Line 276  Line 233 
233              *)              *)
234             fun renameInstr(pt,instr,regToSpill,env,toSrc) =             fun renameInstr(pt,instr,regToSpill,env,toSrc) =
235             let val {code, proh, newReg} =             let val {code, proh, newReg} =
236                    renameSrc{regmap=regmap,instr=instr,                    renameSrc{instr=instr, fromSrc=regToSpill,toSrc=toSrc}
                             fromSrc=regToSpill,toSrc=toSrc}  
237             in  addProh(proh);             in  addProh(proh);
238                 (code,update(pt,env,regToSpill,newReg))                 (code,update(pt,env,regToSpill,newReg))
239             end             end
# Line 288  Line 244 
244              *)              *)
245             fun extractUses(regToSpill, rds, rss) =             fun extractUses(regToSpill, rds, rss) =
246             let fun loop(rd::rds, rs::rss, newRds, rds', rss') =             let fun loop(rd::rds, rs::rss, newRds, rds', rss') =
247                     if regmap rs = regToSpill then                     if same(rs,regToSpill) then
248                        loop(rds, rss, rd::newRds, rds', rss')                        loop(rds, rss, rd::newRds, rds', rss')
249                     else                     else
250                        loop(rds, rss, newRds, rd::rds', rs::rss')                        loop(rds, rss, newRds, rd::rds', rs::rss')
# Line 322  Line 278 
278             end             end
279    
280             (*             (*
281              * Insert reload code.              * Insert reload code
             * If regToSpill is live in the current environment, we choose  
             * to rename instead.  
282              *)              *)
283             fun reload(pt,instr,regToSpill,env,spillLoc) =             fun reload(pt,instr,regToSpill,env,spillLoc) =
284                 if P.moveInstr instr then                 if P.moveInstr instr then
# Line 333  Line 287 
287                    let fun lookup [] =                    let fun lookup [] =
288                               reloadInstr(pt,instr,regToSpill,env,spillLoc)                               reloadInstr(pt,instr,regToSpill,env,spillLoc)
289                          | lookup((r,currentReg,defPt)::env) =                          | lookup((r,currentReg,defPt)::env) =
290                            if r = regToSpill then                            if C.sameColor(r,regToSpill) then
291                              if defPt = pt                              if defPt = pt
292                              then lookup env (* this is NOT the right renaming!*)                              then lookup env (* this is NOT the right renaming!*)
293                              else if defPt - pt <= MAX_DIST then                              else if defPt - pt <= MAX_DIST then
# Line 346  Line 300 
300                    end                    end
301    
302             (*             (*
303              * Check whether the regToSpill is in a list              * Check whether the id is in a list
304              *)              *)
305             fun contains(regToSpill:int,[]) = false             fun containsId(id,[]) = false
306               | contains(regToSpill,r::rs) =               | containsId(id:C.cell_id,r::rs) = r = id orelse containsId(id,rs)
307                 r = regToSpill orelse contains(regToSpill,rs)             fun spillConflict(G.FRAME loc, rs) = containsId(~loc, rs)
308                 | spillConflict(G.MEM_REG(C.CELL{id, ...}), rs) =
309                     containsId(id, rs)
310    
311               fun contains(r',[]) = false
312                 | contains(r',r::rs) = sameCell(r',r) orelse contains(r',rs)
313    
314             (*             (*
315              * Insert spill code for an instruction.              * Insert spill code for an instruction.
# Line 360  Line 319 
319              *)              *)
320             fun spillInstr(pt,instr,regToSpill,spillLoc,kill,env) =             fun spillInstr(pt,instr,regToSpill,spillLoc,kill,env) =
321             let val {code, proh, newReg} =             let val {code, proh, newReg} =
322                    spill{regmap=regmap, instr=instr,                    spill{instr=instr,
323                          kill=kill, spillLoc=spillLoc,                          kill=kill, spillLoc=spillLoc,
324                          reg=regToSpill, annotations=annotations}                          reg=regToSpill, annotations=annotations}
325             in  addProh(proh);             in  addProh(proh);
# Line 376  Line 335 
335             let fun loop(rd::rds, rs::rss, rds', rss') =             let fun loop(rd::rds, rs::rss, rds', rss') =
336                     if spillLocOf rd = spillLocOf rs then                     if spillLocOf rd = spillLocOf rs then
337                        (rs, rds@rds', rss@rss', true)                        (rs, rds@rds', rss@rss', true)
338                     else if regmap rd = regToSpill then                     else if same(rd, regToSpill) then
339                        (rs, rds@rds', rss@rss', kill)                        (rs, rds@rds', rss@rss', kill)
340                     else loop(rds, rss, rd::rds', rs::rss')                     else loop(rds, rss, rd::rds', rs::rss')
341                   | loop _ =                   | loop _ =
342                       (print("rds=");                       (print("rds=");
343                        app (fn r => print(Int.toString r^":"^                        app (fn r => print(C.toString r^":"^
344                                           Int.toString(spillLocOf r)^" ")) rds;                                           i2s(spillLocOf r)^" ")) rds;
345                        print("\nrss=");                        print("\nrss=");
346                        app (fn r => print(Int.toString r^":"^                        app (fn r => print(C.toString r^":"^
347                                           Int.toString(spillLocOf r)^" ")) rss;                                           i2s(spillLocOf r)^" ")) rss;
348                        print "\n";                        print "\n";
349                        error("extractDef: "^Int.toString regToSpill))                        error("extractDef: "^C.toString regToSpill))
350             in loop(rds, rss, [], []) end             in loop(rds, rss, [], []) end
351    
352             (*             (*
# Line 409  Line 368 
368              *    spill tmp to spillLoc /* spill d */              *    spill tmp to spillLoc /* spill d */
369              *              *
370              *)              *)
371             fun spillCopyDst(instr,regToSpill,spillLoc,kill,env,don'tOverwrite) =             fun spillCopyDst(pt,instr,regToSpill,spillLoc,
372                                kill,env,don'tOverwrite) =
373             let val (dst, src) = P.moveDstSrc instr             let val (dst, src) = P.moveDstSrc instr
374                 val (mvSrc,copyDst,copySrc,kill) =                 val (mvSrc,copyDst,copySrc,kill) =
375                      extractDef(regToSpill,dst,src,kill)                      extractDef(regToSpill,dst,src,kill)
# Line 423  Line 383 
383                    (copy, env)                    (copy, env)
384                   )                   )
385                 else (* normal spill *)                 else (* normal spill *)
386                   if contains(spillLoc, don'tOverwrite) then                   if spillConflict(spillLoc, don'tOverwrite) then
387                   let (* cycle found *)                   let (* cycle found *)
388                       (*val _ = print("Register r"^Int.toString regToSpill^                       (*val _ = print("Register r"^Int.toString regToSpill^
389                                    " overwrites ["^Int.toString spillLoc^"]\n")*)                                    " overwrites ["^Int.toString spillLoc^"]\n")*)
390                       val tmp = I.C.newCell cellkind () (* new temporary *)                       val tmp = I.C.newVar regToSpill (* new temporary *)
391                       val copy = copyInstr((tmp::copyDst, mvSrc::copySrc),                       val copy = copyInstr((tmp::copyDst, mvSrc::copySrc),
392                                                 instr)                                                 instr)
393                       val spillCode = spillSrc{src=tmp,reg=regToSpill,                       val spillCode = spillSrc{src=tmp,reg=regToSpill,
394                                                spillLoc=spillLoc,                                                spillLoc=spillLoc,
395                                                annotations=annotations}                                                annotations=annotations}
396                   in  (copy @ spillCode, [])                   in  (copy @ spillCode, [(regToSpill,tmp,pt)])
397                   end                   end
398                   else                   else
399                   let (* spill the move instruction *)                   let (* spill the move instruction *)
400                       val spillCode = spillSrc{src=mvSrc,reg=regToSpill,                       val spillCode = spillSrc{src=mvSrc,reg=regToSpill,
401                                                spillLoc=spillLoc,                                                spillLoc=spillLoc,
402                                                annotations=annotations}                                                annotations=annotations}
403                   in  (spillCode @ copy, [])                   in  (spillCode @ copy, [(regToSpill,mvSrc,pt)])
404                   end                   end
405             end             end
406    
# Line 449  Line 409 
409              *)              *)
410             fun spillCopy(pt,instr,regToSpill,spillLoc,kill,env,don'tOverwrite) =             fun spillCopy(pt,instr,regToSpill,spillLoc,kill,env,don'tOverwrite) =
411                 case P.moveTmpR instr of                 case P.moveTmpR instr of
412                   NONE => spillCopyDst(instr,regToSpill,spillLoc,kill,env,                   NONE => spillCopyDst(pt,instr,regToSpill,spillLoc,kill,env,
413                                        don'tOverwrite)                                        don'tOverwrite)
414                 | SOME tmp =>                 | SOME tmp =>
415                     if regmap tmp = regToSpill                     if same(tmp, regToSpill)
416                     then ((* spilledCopyTmps := !spilledCopyTmps + 1; *)                     then ((* spilledCopyTmps := !spilledCopyTmps + 1; *)
417                           [spillCopyTmp{copy=instr, spillLoc=spillLoc,                           [spillCopyTmp{copy=instr, spillLoc=spillLoc,
418                                           reg=regToSpill,
419                                        annotations=annotations}], [])                                        annotations=annotations}], [])
420                     else spillCopyDst(instr,regToSpill,spillLoc,kill,                     else spillCopyDst(pt,instr,regToSpill,spillLoc,kill,
421                                       env, don'tOverwrite)                                       env, don'tOverwrite)
422    
423             (*             (*
# Line 471  Line 432 
432             end             end
433    
434             fun contains([],reg) = false             fun contains([],reg) = false
435               | contains(r::rs,reg) = regmap r = reg orelse contains(rs,reg)               | contains(r::rs,reg) = same(r,reg) orelse contains(rs,reg)
436             fun hasDef(i,reg) = contains(#1(insnDefUse i),reg)             fun hasDef(i,reg) = contains(#1(insnDefUse i),reg)
437             fun hasUse(i,reg) = contains(#2(insnDefUse i),reg)             fun hasUse(i,reg) = contains(#2(insnDefUse i),reg)
438    
# Line 485  Line 446 
446                end                end
447                else                else
448                let val (instrs,env) =                let val (instrs,env) =
449                      spillOneReg(pt,instrs,r,spillLoc,killSet,env,don'tOverwrite)                        spillOneReg(pt,instrs,r,spillLoc,killSet,
450                                      env,don'tOverwrite)
451                in  (i::instrs, env)                in  (i::instrs, env)
452                end                end
453    
# Line 493  Line 455 
455               | reloadOneReg(pt,i::instrs,r,env,spillLoc) =               | reloadOneReg(pt,i::instrs,r,env,spillLoc) =
456                 if hasUse(i,r) then                 if hasUse(i,r) then
457                 let val (instrs',env) = reload(pt,i,r,env,spillLoc)                 let val (instrs',env) = reload(pt,i,r,env,spillLoc)
458                 in  reloadOneReg(pt,instrs'@instrs,r,env,spillLoc) end                 in  reloadOneReg(pt,instrs'@instrs,r,env,spillLoc)
459                   end
460                 else                 else
461                 let val (instrs,env) = reloadOneReg(pt,instrs,r,env,spillLoc)                 let val (instrs,env) = reloadOneReg(pt,instrs,r,env,spillLoc)
462                 in  (i::instrs, env) end                 in  (i::instrs, env)
463                   end
464    
465             (* This function spills a set of registers for an instruction *)             (* This function spills a set of registers for an instruction *)
466             fun spillAll(pt,instrs,[],killSet,env,don'tOverwrite) = (instrs, env)             fun spillAll(pt,instrs,[],killSet,env,don'tOverwrite) = (instrs, env)
# Line 504  Line 468 
468                 let val node     = getnode r                 let val node     = getnode r
469                     val spillLoc = getLoc node                     val spillLoc = getLoc node
470                     val (instrs, env) =                     val (instrs, env) =
471                      spillOneReg(pt,instrs,r,spillLoc,killSet,env,don'tOverwrite)                         spillOneReg(pt,instrs,r,spillLoc,killSet,
472                                       env,don'tOverwrite)
473                 in  spillAll(pt,instrs,rs,killSet,env,don'tOverwrite)                 in  spillAll(pt,instrs,rs,killSet,env,don'tOverwrite)
474                 end                 end
475    
# Line 525  Line 490 
490                       ([], []) =>                       ([], []) =>
491                         let val env' =                         let val env' =
492                                case env of                                case env of
493                                  [] => []                                [] => [] (* An approximation here *)
494                                | _ => let val (defs, uses) = insnDefUse instr                                | _ => let val (defs, uses) = insnDefUse instr
495                                       in  if hasNonDedicated defs orelse                                       in  if hasNonDedicated defs orelse
496                                              hasNonDedicated uses then []                                              hasNonDedicated uses then []
497                                           else env                                           else env
498                                       end                                       end
499                                (* should be handled better *)
500                         in  loop(rest, dec pt, env', instr::newInstrs)                         in  loop(rest, dec pt, env', instr::newInstrs)
501                         end                         end
502                     | _ =>                     | _ =>
503                       (* Eliminate duplicates from the spill/reload candidates *)                       (* Eliminate duplicates from the spill/reload candidates *)
504                       let val killRegs   = getKills pt                       let val killRegs   = getKills pt
505                           val spillRegs  = SL.uniq spillRegs                           val spillRegs  = uniq spillRegs
506                           val reloadRegs = SL.uniq reloadRegs                           val reloadRegs = uniq reloadRegs
507    
508                           (* spill locations that we can't overwrite if we                           (* spill locations that we can't overwrite if we
509                            * are spilling a parallel copy                            * are spilling a parallel copy
# Line 548  Line 514 
514    
515                          fun prEnv env =                          fun prEnv env =
516                               (print("Env=");                               (print("Env=");
517                                app (fn (r,v,_) => print(Int.toString r^"=>"^                                app (fn (r,v,_) => print(C.toString r^"=>"^
518                                                       Int.toString v^" ")) env;                                                         C.toString v^" ")) env;
519                                print "\n")                                print "\n")
520    
                          val _ =  
                            if debug then  
                            let val regs = app (fn r =>  
                                 print(Int.toString(regmap r)^" ["^Int.toString  
                                           (getLoc (getnode r))^"] "))  
                            in   print("pt="^Int.toString pt^"\n");  
                                 if spillRegs = [] then () else  
                                    (print("Spilling ");  
                                     regs spillRegs; print "\n");  
                                 if reloadRegs = [] then () else  
                                    (print("Reloading ");  
                                     regs reloadRegs; print "\n");  
                                 print "Before:"; emit regmap instr;  
                                 prEnv env  
                            end else ()  
   
                          (* Generate all the spills *)  
521                           val (instrs,env) =                           val (instrs,env) =
522                                 spillAll(pt,[instr],spillRegs,killRegs,                                 spillAll(pt,[instr],spillRegs,killRegs,
523                                             env,don'tOverwrite)                                             env,don'tOverwrite)
524    
525                             val _ = if debug then
526                                   (print("pt="^i2s pt^"\n");
527                                    case spillRegs of
528                                      [] => ()
529                                    |  _ => (print("Spilling ");
530                                             printRegs spillRegs;
531                                             print "\n");
532                                    case reloadRegs of
533                                      [] => ()
534                                    | _  => (print("Reloading ");
535                                             printRegs reloadRegs;
536                                             print "\n");
537                                    print "Before:"; emit instr;
538                                    prEnv env
539                                   ) else ()
540    
541                           val (instrs,env) =                           val (instrs,env) =
542                                 reloadAll(pt,instrs,env,reloadRegs)                                 reloadAll(pt,instrs,env,reloadRegs)
543    
544                           val _ =  if debug then                           val _ =  if debug then
545                                 (print "After:"; app (emit regmap) instrs;                                 (print "After:"; app emit instrs;
546                                  prEnv env;                                  print "------------------\n")
547                                  print "------------------\n") else ()                                 else ()
548    
549                           fun concat([], l) = l                           fun concat([], l) = l
550                             | concat(a::b, l) = concat(b, a::l)                             | concat(a::b, l) = concat(b, a::l)
# Line 590  Line 555 
555         end         end
556     in  spillRewrite     in  spillRewrite
557     end     end
   
558  end  end
559    
560    end (* local *)

Legend:
Removed from v.705  
changed lines
  Added in v.815

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