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 499, Tue Dec 7 15:44:50 1999 UTC
# Line 8  Line 8 
8    
9     structure I : INSTRUCTIONS     structure I : INSTRUCTIONS
10     structure C : CELLS     structure C : CELLS
11       structure G : RA_GRAPH = RAGraph
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 : int,                 (* logical spill location *)
        node     : RAGraph.node,        (* the current node *)  
25         kill     : bool,                (* can we kill the current node? *)         kill     : bool,                (* can we kill the current node? *)
26         regmap   : C.cell -> C.cell,    (* current register map *)         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     : C.cell list,         (* prohibited from future spilling *)
31         instr    : I.instruction option (* possibly changed instruction *)         newReg   : C.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      : C.cell,              (* register to spill from *)
39           reg      : C.cell,              (* the register *)
40           spillLoc : int,                 (* 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           spillLoc : int,                 (* 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 : int,                 (* logical spill location *)
        node     : RAGraph.node,        (* the current node *)  
61         regmap   : C.cell -> C.cell,    (* current register map *)         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     : C.cell list,         (* prohibited from future spilling *)
66           newReg   : C.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  : C.cell,              (* register to rename *)
75           toSrc    : C.cell,              (* register to rename to *)
76           regmap   : C.cell -> C.cell     (* current register map *)
77          } ->
78          {code     : I.instruction list,  (* renamed instr *)
79           proh     : C.cell list,         (* prohibited from future spilling *)
80           newReg   : C.cell option        (* the renamed value is here *)
81        }        }
82    
83       (* Reload the register dst from spillLoc.
84        * The value is originally from register reg.
85        *)
86       type reloadDst =
87          {dst      : C.cell,              (* register to reload to *)
88           reg      : C.cell,              (* the register *)
89           spillLoc : int,                 (* logical spill location *)
90           annotations : Annotations.annotations ref (* annotations *)
91          } -> I.instruction list          (* reload code *)
92    
93     (*     (*
94      * The following function rewrites an instruction and insert      * The following function rewrites an instruction and insert
95      * spill and reload code around it.   The list of spill and reload      * spill and reload code around it.   The list of spill and reload
96      * registers may have duplicates.      * registers may have duplicates.
97      *)      *)
98     val spillRewrite :     val spillRewrite :
99          { graph     : RAGraph.interferenceGraph,          { graph        : G.interferenceGraph,
100            spill     : spill,            spill     : spill,
101              spillSrc     : spillSrc,
102              spillCopyTmp : spillCopyTmp,
103            reload    : reload,            reload    : reload,
104              reloadDst    : reloadDst,
105              renameSrc    : renameSrc,
106            copyInstr : copyInstr,            copyInstr : copyInstr,
107            cellkind  : C.cellkind            cellkind     : C.cellkind,
108              spillSet     : C.cell list Intmap.intmap,
109              reloadSet    : C.cell list Intmap.intmap,
110              killSet      : C.cell list Intmap.intmap
111          } ->          } ->
112          { spillRegs   : C.cell list,   (* registers to spill *)          { pt          : int,                         (* starting program pt *)
113            killRegs    : C.cell list,   (* registers to kill *)            annotations : Annotations.annotations ref, (* annotations *)
114            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 *)  
115          } ->          } ->
116          { code       : I.instruction list (* instruction sequence after            I.instruction list (* instruction sequence after rewriting *)
117                                             * rewriting            (* Note, instructions are in reverse order *)
                                            *)  
         }  
118    
119  end  end

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

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