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/ra/ra-spill.sig
ViewVC logotype

Diff of /MLRISC/trunk/ra/ra-spill.sig

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

sml/branches/SMLNJ/src/MLRISC/ra/ra-spill.sig revision 475, Wed Nov 10 22:59:58 1999 UTC sml/trunk/src/MLRISC/ra/ra-spill.sig revision 815, Fri May 4 05:09:10 2001 UTC
# Line 7  Line 7 
7  sig  sig
8    
9     structure I : INSTRUCTIONS     structure I : INSTRUCTIONS
10       structure G : RA_GRAPH = RAGraph
11     structure C : CELLS     structure C : CELLS
12        sharing I.C = C        sharing I.C = C
13    
14     type copyInstr =     type copyInstr =
15            (C.cell list * C.cell list) * I.instruction -> I.instruction            (C.cell list * C.cell list) * I.instruction -> I.instruction list
16    
17       (*
18        * Spill the value associated with reg into spillLoc.
19        * All definitions of instr should be renamed to a new temporary newReg.
20        *)
21     type spill =     type spill =
22        {instr    : I.instruction,       (* instruction where spill is to occur *)        {instr    : I.instruction,       (* instruction where spill is to occur *)
23         reg      : C.cell,              (* register to spill *)         reg      : C.cell,              (* register to spill *)
24         spillLoc : int,                 (* logical spill location *)         spillLoc : G.spillLoc,          (* logical spill location *)
        graph    : RAGraph.interferenceGraph,  (* the current graph *)  
25         kill     : bool,                (* can we kill the current node? *)         kill     : bool,                (* can we kill the current node? *)
        regmap   : C.cell -> C.cell,    (* current register map *)  
26         annotations : Annotations.annotations ref  (* annotations *)         annotations : Annotations.annotations ref  (* annotations *)
27        } ->        } ->
28        {code     : I.instruction list,  (* spill code *)        {code     : I.instruction list,  (* instruction + spill code *)
29         proh     : C.cell list,         (* prohibited from future spilling *)         proh     : C.cell list,         (* prohibited from future spilling *)
30         instr    : I.instruction option (* possibly changed instruction *)         newReg   : C.cell option        (* the spilled value is available here *)
31        }        }
32    
33       (* Spill the register src into spillLoc.
34        * The value is originally from register reg.
35        *)
36       type spillSrc =
37          {src      : C.cell,              (* register to spill from *)
38           reg      : C.cell,              (* the register *)
39           spillLoc : G.spillLoc,          (* logical spill location *)
40           annotations : Annotations.annotations ref (* annotations *)
41          } -> I.instruction list          (* spill code *)
42    
43       (*
44        * Spill the temporary associated with a copy into spillLoc
45        *)
46       type spillCopyTmp =
47          {copy     : I.instruction,       (* copy to spill *)
48           reg      : C.cell,              (* the register *)
49           spillLoc : G.spillLoc,          (* logical spill location *)
50           annotations : Annotations.annotations ref (* annotations *)
51          } -> I.instruction               (* spill code *)
52    
53       (*
54        * Reload the value associated with reg from spillLoc.
55        * All uses of instr should be renamed to a new temporary newReg.
56        *)
57     type reload =     type reload =
58        {instr    : I.instruction,       (* instruction where spill is to occur *)        {instr    : I.instruction,       (* instruction where spill is to occur *)
59         reg      : C.cell,              (* register to spill *)         reg      : C.cell,              (* register to spill *)
60         spillLoc : int,                 (* logical spill location *)         spillLoc : G.spillLoc,          (* logical spill location *)
        graph    : RAGraph.interferenceGraph,  (* the current graph *)  
        regmap   : C.cell -> C.cell,    (* current register map *)  
61         annotations : Annotations.annotations ref  (* annotations *)         annotations : Annotations.annotations ref  (* annotations *)
62        } ->        } ->
63        {code     : I.instruction list,  (* reload code *)        {code     : I.instruction list,  (* instr + reload code *)
64         proh     : C.cell list          (* prohibited from future spilling *)         proh     : C.cell list,         (* prohibited from future spilling *)
65           newReg   : C.cell option        (* the reloaded value is here *)
66        }        }
67    
68     (*     (*
69        * Rename all uses fromSrc to toSrc
70        *)
71       type renameSrc =
72          {instr    : I.instruction,       (* instruction where spill is to occur *)
73           fromSrc  : C.cell,              (* register to rename *)
74           toSrc    : C.cell               (* register to rename to *)
75          } ->
76          {code     : I.instruction list,  (* renamed instr *)
77           proh     : C.cell list,         (* prohibited from future spilling *)
78           newReg   : C.cell option        (* the renamed value is here *)
79          }
80    
81       (* Reload the register dst from spillLoc.
82        * The value is originally from register reg.
83        *)
84       type reloadDst =
85          {dst      : C.cell,              (* register to reload to *)
86           reg      : C.cell,              (* the register *)
87           spillLoc : G.spillLoc,          (* logical spill location *)
88           annotations : Annotations.annotations ref (* annotations *)
89          } -> I.instruction list          (* reload code *)
90    
91       (*
92      * The following function rewrites an instruction and insert      * The following function rewrites an instruction and insert
93      * spill and reload code around it.   The list of spill and reload      * spill and reload code around it.   The list of spill and reload
94      * registers may have duplicates.      * registers may have duplicates.
95      *)      *)
96     val spillRewrite :     val spillRewrite :
97          { graph     : RAGraph.interferenceGraph,          { graph        : G.interferenceGraph,
98            spill     : spill,            spill     : spill,
99              spillSrc     : spillSrc,
100              spillCopyTmp : spillCopyTmp,
101            reload    : reload,            reload    : reload,
102              reloadDst    : reloadDst,
103              renameSrc    : renameSrc,
104            copyInstr : copyInstr,            copyInstr : copyInstr,
105            cellkind  : C.cellkind            cellkind     : C.cellkind,
106              spillSet     : C.cell list G.PPtHashTable.hash_table,
107              reloadSet    : C.cell list G.PPtHashTable.hash_table,
108              killSet      : C.cell list G.PPtHashTable.hash_table
109          } ->          } ->
110          { spillRegs   : C.cell list,   (* registers to spill *)          { pt          : G.programPoint,              (* starting program pt *)
111            killRegs    : C.cell list,   (* registers to kill *)            annotations : Annotations.annotations ref, (* annotations *)
112            reloadRegs  : C.cell list,   (* registers to reload *)            instrs      : I.instruction list           (* instructions to spill *)
           instr       : I.instruction, (* instruction to process *)  
           annotations : Annotations.annotations ref (* annotations *)  
113          } ->          } ->
114          { code       : I.instruction list (* instruction sequence after            I.instruction list (* instruction sequence after rewriting *)
115                                             * rewriting            (* Note, instructions are in reverse order *)
                                            *)  
         }  
116    
117  end  end

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

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