Home My Page Projects Code Snippets Project Openings SML/NJ
Summary Activity Forums Tracker Lists Tasks Docs Surveys News SCM Files

SCM Repository

[smlnj] Annotation of /sml/trunk/src/compiler/CodeGen/ppc/ppcCG.sml
ViewVC logotype

Annotation of /sml/trunk/src/compiler/CodeGen/ppc/ppcCG.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 411 - (view) (download)
Original Path: sml/branches/SMLNJ/src/compiler/CodeGen/ppc/ppcCG.sml

1 : monnier 247 functor PPCCG
2 : monnier 411 (structure Emitter : INSTRUCTION_EMITTER
3 :     where I = PPCInstr
4 :     and P = PPCPseudoOps
5 :     and S.B = PPCMLTree.BNames) : MACHINE_GEN =
6 : monnier 247 struct
7 :     structure I = PPCInstr
8 :     structure C = PPCCells
9 :     structure R = PPCCpsRegs
10 :     structure B = PPCMLTree.BNames
11 :     structure F = PPCFlowGraph
12 :     structure Asm = PPCAsmEmitter
13 :     structure MLTree = PPCMLTree
14 :     structure MachSpec = PPCSpec
15 :     structure Ctrl = Control.MLRISC
16 : monnier 411
17 : monnier 247 fun error msg = ErrorMsg.impossible ("PPCCG." ^ msg)
18 :    
19 :     val stack = PPCInstr.Region.stack
20 :     structure PPCRewrite = PPCRewrite(PPCInstr)
21 :    
22 :     (* properties of instruction set *)
23 : monnier 411 structure P = PPCProps(PPCInstr)
24 : monnier 247
25 : monnier 411 structure FreqProps = FreqProps(P)
26 :    
27 : monnier 247 (* Label backpatching and basic block scheduling *)
28 :     structure BBSched =
29 :     BBSched2(structure Flowgraph = F
30 :     structure Jumps =
31 :     PPCJumps(structure Instr=PPCInstr
32 : monnier 411 structure Shuffle=PPCShuffle)
33 : monnier 247 structure Emitter = Emitter)
34 :    
35 :     (* flow graph pretty printing routine *)
36 : monnier 411 (*
37 : monnier 247 structure PrintFlowGraph =
38 :     PrintFlowGraphFn (structure FlowGraph = F
39 :     structure Emitter = Asm)
40 : monnier 411 *)
41 : monnier 247
42 :     val intSpillCnt = Ctrl.getInt "ra-int-spills"
43 :     val floatSpillCnt = Ctrl.getInt "ra-float-spills"
44 :     val intReloadCnt = Ctrl.getInt "ra-int-reloads"
45 :     val floatReloadCnt = Ctrl.getInt "ra-float-reloads"
46 :    
47 :     (* register allocation *)
48 :     structure RegAllocation :
49 :     sig
50 :     val ra : F.cluster -> F.cluster
51 :     val cp : F.cluster -> F.cluster
52 :     end =
53 :     struct
54 :    
55 :     (* spill area management *)
56 :     val initialSpillOffset = 144
57 :     val spillOffset = ref initialSpillOffset
58 :     fun newOffset n =
59 :     if n > 4096
60 :     then error "newOffset - spill area is too small"
61 :     else spillOffset := n
62 :     exception RegSpills and FregSpills
63 :    
64 :     val regSpills : int Intmap.intmap ref = ref(Intmap.new(0, RegSpills))
65 :     val fregSpills : int Intmap.intmap ref = ref(Intmap.new(0, FregSpills))
66 :    
67 :     (* get spill location for general registers *)
68 :     fun getRegLoc reg = Intmap.map (!regSpills) reg
69 :     handle RegSpills => let
70 :     val offset = !spillOffset
71 :     in
72 :     newOffset(offset+4);
73 :     Intmap.add (!regSpills) (reg, offset);
74 :     offset
75 :     end
76 :    
77 :     (* get spill location for floating registers *)
78 :     fun getFregLoc freg = Intmap.map (!fregSpills) freg
79 :     handle FregSpills => let
80 :     val offset = !spillOffset
81 :     val fromInt = Word.fromInt
82 :     val aligned = Word.toIntX(Word.andb(fromInt offset+0w7, fromInt ~8))
83 :     in
84 :     newOffset(aligned+8);
85 :     Intmap.add (!fregSpills) (freg, aligned);
86 :     aligned
87 :     end
88 :    
89 :     fun spill {regmap,instr,reg,id:B.name} = let
90 :     val offset = I.ImmedOp (getRegLoc(reg))
91 :     fun spillInstr(src) =
92 : monnier 411 [I.ST{st=I.STW, rs=src, ra=C.stackptrR, d=offset, mem=stack}]
93 : monnier 247 in
94 :     intSpillCnt := !intSpillCnt + 1;
95 :     case instr
96 :     of I.COPY{dst as [rd], src as [rs], tmp, impl} =>
97 :     if rd=reg then
98 :     {code=spillInstr(rs), instr=NONE, proh=[]:int list}
99 :     else (case tmp
100 :     of SOME(I.Direct r) => let
101 :     val disp = I.ImmedOp(getRegLoc(r))
102 :     val loc = I.Displace{base=C.stackptrR, disp=disp}
103 :     val instr=I.COPY{dst=dst, src=src, tmp=SOME(loc), impl=impl}
104 :     in {code=[], instr=SOME instr, proh=[]}
105 :     end
106 :     | _ => error "spill: COPY"
107 :     (*esac*))
108 :     | _ => let
109 :     val newR = C.newReg()
110 :     val instr' = PPCRewrite.rewriteDef(regmap, instr, reg, newR)
111 :     in {code=spillInstr(newR), instr=SOME instr', proh=[newR]}
112 :     end
113 :     end
114 :    
115 :     fun fspill {regmap,instr,reg,id:B.name} = let
116 :     val offset = I.ImmedOp (getFregLoc(reg))
117 :     fun spillInstr(src) =
118 : monnier 411 [I.STF{st=I.STFD, fs=src, ra=C.stackptrR, d=offset, mem=stack}]
119 : monnier 247 in
120 :     floatSpillCnt := !floatSpillCnt + 1;
121 :     case instr
122 :     of I.FCOPY{dst as [fd], src as [fs], tmp, impl} => (* reg = fd *)
123 :     if reg=fd then
124 :     {code=spillInstr(fs), instr=NONE, proh=[]}
125 :     else (case tmp
126 :     of SOME(I.FDirect r) => let
127 :     val disp=I.ImmedOp(getFregLoc(r))
128 :     val loc = I.Displace{base=C.stackptrR, disp=disp}
129 :     val instr=I.FCOPY{dst=dst, src=src, tmp=SOME(loc), impl=impl}
130 :     in {code=[], instr=SOME instr, proh=[]}
131 :     end
132 :     | _ => error "spill: COPY"
133 :     (*esac*))
134 :     | _ => let
135 :     val newR = C.newFreg()
136 :     val instr' = PPCRewrite.frewriteDef(regmap, instr, reg, newR)
137 :     in {code=spillInstr(newR), instr=SOME instr', proh=[newR]}
138 :     end
139 :     end
140 :    
141 :     fun reload{regmap,instr,reg,id:B.name} = let
142 :     val offset = I.ImmedOp (getRegLoc(reg))
143 :     fun reloadInstr(dst, rest) =
144 : monnier 411 I.L{ld=I.LWZ, rt=dst, ra=C.stackptrR, d=offset, mem=stack}::rest
145 : monnier 247 in
146 :     intReloadCnt := !intReloadCnt + 1;
147 :     case instr
148 :     of I.COPY{dst=[rd], src=[rs], ...} => (* reg = rs *)
149 :     {code=reloadInstr(rd, []), proh=[]:int list}
150 :     | _ => let
151 :     val newR = C.newReg()
152 :     val instr' = PPCRewrite.rewriteUse(regmap, instr, reg, newR)
153 :     in {code=reloadInstr(newR, [instr']), proh=[newR]}
154 :     end
155 :     end
156 :    
157 :     fun freload {regmap, instr, reg, id:B.name} = let
158 :     val offset = I.ImmedOp (getFregLoc(reg))
159 :     fun reloadInstr(dst, rest) =
160 : monnier 411 I.LF{ld=I.LFD, ft=dst, ra=C.stackptrR, d=offset, mem=stack}::rest
161 : monnier 247 in
162 :     floatReloadCnt := !floatReloadCnt + 1;
163 :     case instr
164 :     of I.FCOPY{dst=[fd], src=[fs], ...} => (* reg = fs *)
165 :     {code=reloadInstr(fd, []), proh=[]}
166 :     | _ => let
167 :     val newR = C.newFreg()
168 :     val instr' = PPCRewrite.frewriteUse(regmap, instr, reg, newR)
169 :     in {code=reloadInstr(newR, [instr']), proh=[newR]}
170 :     end
171 :     end
172 :    
173 :     fun spillInit () =
174 :     (spillOffset := initialSpillOffset;
175 :     regSpills := Intmap.new(8, RegSpills);
176 :     fregSpills := Intmap.new(8, FregSpills))
177 :    
178 : monnier 411 structure GR = GetReg(val nRegs=32 val available=R.availR val first=0)
179 :     structure FR = GetReg(val nRegs=32 val available=R.availF val first=32)
180 : monnier 247
181 :     structure PPCRa =
182 :     PPCRegAlloc(structure P = P
183 :     structure I = PPCInstr
184 :     structure F = F
185 :     structure Asm = Asm)
186 :    
187 :     (* register allocation for general purpose registers *)
188 :     structure IntRa =
189 :     PPCRa.IntRa
190 :     (structure RaUser = struct
191 :     structure I = PPCInstr
192 :     structure B = B
193 :    
194 :     val getreg = GR.getreg
195 :     val spill = spill
196 :     val reload = reload
197 :     val nFreeRegs = length R.availR
198 :     val dedicated = R.dedicatedR
199 :     fun copyInstr((rds, rss), I.COPY{tmp, ...}) =
200 :     I.COPY{dst=rds, src=rss, impl=ref NONE, tmp=tmp}
201 :     end)
202 :    
203 :     (* register allocation for floating point registers *)
204 :     structure FloatRa =
205 :     PPCRa.FloatRa
206 :     (structure RaUser = struct
207 :     structure I = PPCInstr
208 :     structure B = B
209 :    
210 :     val getreg = FR.getreg
211 :     val spill = fspill
212 :     val reload = freload
213 :     val nFreeRegs = length R.availF
214 :     val dedicated = R.dedicatedF
215 :     fun copyInstr((fds, fss), I.FCOPY{tmp, ...}) =
216 :     I.FCOPY{dst=fds, src=fss, impl=ref NONE, tmp=tmp}
217 :     end)
218 :    
219 :     val iRegAlloc = IntRa.ra IntRa.REGISTER_ALLOCATION []
220 :     val fRegAlloc = FloatRa.ra FloatRa.REGISTER_ALLOCATION []
221 :     val iCopyProp = IntRa.ra IntRa.COPY_PROPAGATION []
222 :     val fCopyProp = FloatRa.ra FloatRa.COPY_PROPAGATION []
223 :    
224 :     fun ra cluster = let
225 : monnier 411 (* val pg = PrintFlowGraph.printCluster TextIO.stdOut *)
226 : monnier 247 fun intRa cluster = (GR.reset(); iRegAlloc cluster)
227 :     fun floatRa cluster = (FR.reset(); fRegAlloc cluster)
228 :     in spillInit(); (floatRa o intRa) cluster
229 :     end
230 :     val cp = fCopyProp o iCopyProp
231 :     end (* RegAllocation *)
232 :    
233 :     val optimizerHook : (F.cluster->F.cluster) option ref = ref NONE
234 :    
235 :     (* primitives for generation of DEC alpha instruction flowgraphs *)
236 :     structure FlowGraphGen =
237 : monnier 411 ClusterGen(structure Flowgraph = F
238 :     structure InsnProps = P
239 :     structure MLTree = MLTree
240 :     structure Stream=PPCStream
241 :     val optimize = optimizerHook
242 :     val output = BBSched.bbsched o RegAllocation.ra)
243 : monnier 247
244 :     (* compilation of CPS to MLRISC *)
245 :     structure MLTreeGen =
246 :     MLRiscGen(structure MachineSpec=PPCSpec
247 :     structure MLTreeComp=
248 : monnier 411 PPC(structure Stream=PPCStream
249 : monnier 247 structure PPCInstr=PPCInstr
250 :     structure PPCMLTree=PPCMLTree
251 :     structure PseudoInstrs=
252 :     PPCPseudoInstr(structure Instr=PPCInstr)
253 : monnier 411 val bit64mode=false
254 :     val multCost=ref 6 (* an estimate *))
255 :     structure Flowgen=FlowGraphGen
256 : monnier 247 structure Cells=PPCCells
257 :     structure C=PPCCpsRegs
258 :     structure PseudoOp=PPCPseudoOps)
259 :    
260 :     val copyProp = RegAllocation.cp
261 :     val codegen = MLTreeGen.codegen
262 :     val finish = BBSched.finish
263 :     end
264 :    

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