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

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

Legend:
Removed from v.467  
changed lines
  Added in v.889

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