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/MLRISC/x86/instructions/x86Props.sml
ViewVC logotype

Annotation of /sml/trunk/src/MLRISC/x86/instructions/x86Props.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1156 - (view) (download)

1 : monnier 247 (* x86Props.sml -- 32bit, x86 instruction semantic properties
2 :     *
3 :     * COPYRIGHT (c) 1997 Bell Laboratories.
4 :     *)
5 :    
6 : george 984 functor X86Props
7 :     (structure Instr : X86INSTR
8 :     structure MLTreeHash : MLTREE_HASH where T = Instr.T
9 :     structure MLTreeEval : MLTREE_EVAL where T = Instr.T
10 :     ) : INSN_PROPERTIES =
11 : monnier 247 struct
12 : george 984 structure I = Instr
13 : monnier 247 structure C = I.C
14 : leunga 775 structure T = I.T
15 : george 889 structure CB = CellsBasis
16 : monnier 247
17 :     exception NegateConditional
18 :    
19 : monnier 411 fun error msg = MLRiscErrorMsg.error("X86Props",msg)
20 : monnier 247
21 : george 545 datatype kind = IK_JUMP | IK_NOP | IK_INSTR | IK_COPY | IK_CALL
22 : leunga 796 | IK_CALL_WITH_CUTS | IK_PHI | IK_SOURCE | IK_SINK
23 : monnier 247 datatype target = LABELLED of Label.label | FALLTHROUGH | ESCAPES
24 :     (*========================================================================
25 :     * Instruction Kinds
26 :     *========================================================================*)
27 : george 1003 fun instrKind (I.ANNOTATION{i, ...}) = instrKind i
28 : george 1009 | instrKind (I.COPY _) = IK_COPY
29 : george 1003 | instrKind (I.INSTR i) =
30 :     (case i
31 :     of I.JMP _ => IK_JUMP
32 :     | I.JCC _ => IK_JUMP
33 :     | I.CALL{cutsTo=_::_,...} => IK_CALL_WITH_CUTS
34 :     | I.CALL _ => IK_CALL
35 :     | I.PHI _ => IK_PHI
36 :     | I.SOURCE _ => IK_SOURCE
37 :     | I.SINK _ => IK_SINK
38 :     | I.RET _ => IK_JUMP
39 : jhr 1099 | I.INTO => IK_JUMP
40 : george 1003 | _ => IK_INSTR)
41 : monnier 247 | instrKind _ = IK_INSTR
42 :    
43 : george 1003 fun moveInstr(I.ANNOTATION{i, ...}) = moveInstr i
44 :     | moveInstr(I.LIVE _) = false
45 :     | moveInstr(I.KILL _) = false
46 : george 1009 | moveInstr(I.COPY _) = true
47 : george 1003 | moveInstr(I.INSTR i) =
48 :     (case i
49 : george 1009 of I.MOVE{mvOp=I.MOVL, src=I.Direct _, dst=I.MemReg _, ...} => true
50 : george 1003 | I.MOVE{mvOp=I.MOVL, src=I.MemReg _, dst=I.Direct _, ...} => true
51 :     | I.FMOVE{fsize=I.FP64,src=I.FPR _,dst=I.FPR _, ...} => true
52 :     | I.FMOVE{fsize=I.FP64,src=I.FPR _,dst=I.FDirect _, ...} => true
53 :     | I.FMOVE{fsize=I.FP64,src=I.FDirect _,dst=I.FPR _, ...} => true
54 :     | I.FMOVE{fsize=I.FP64,src=I.FDirect _,dst=I.FDirect _, ...} => true
55 :     | _ => false )
56 : monnier 247
57 :    
58 : george 1009 fun isMemMove(I.INSTR(i)) =
59 :     (case i
60 :     of I.MOVE{mvOp=I.MOVL, src=I.Direct _, dst=I.MemReg _, ...} => true
61 :     | I.MOVE{mvOp=I.MOVL, src=I.MemReg _, dst=I.Direct _, ...} => true
62 :     | I.FMOVE{fsize=I.FP64,src=I.FPR _,dst=I.FPR _, ...} => true
63 :     | I.FMOVE{fsize=I.FP64,src=I.FPR _,dst=I.FDirect _, ...} => true
64 :     | I.FMOVE{fsize=I.FP64,src=I.FDirect _,dst=I.FPR _, ...} => true
65 :     | I.FMOVE{fsize=I.FP64,src=I.FDirect _,dst=I.FDirect _, ...} => true
66 :     | _ => false
67 :     (*esac*))
68 :     | isMemMove _ = false
69 : monnier 247
70 :    
71 : george 1009 fun memMove(I.INSTR(i)) =
72 :     (case i
73 :     of I.MOVE{src=I.Direct rs, dst=I.MemReg rd, ...} => ([rd], [rs])
74 :     | I.MOVE{src=I.MemReg rs, dst=I.Direct rd, ...} => ([rd], [rs])
75 :     | I.FMOVE{src=I.FPR rs, dst=I.FPR rd, ...} => ([rd], [rs])
76 :     | I.FMOVE{src=I.FDirect rs, dst=I.FPR rd, ...} => ([rd], [rs])
77 :     | I.FMOVE{src=I.FPR rs, dst=I.FDirect rd, ...} => ([rd], [rs])
78 :     | I.FMOVE{src=I.FDirect rs, dst=I.FDirect rd, ...} => ([rd], [rs])
79 :     | _ => error "memMove: INSTR"
80 :     (*esac*))
81 :     | memMove _ = error "memMove"
82 :    
83 :     val nop = fn () => I.nop
84 :    
85 :    
86 : monnier 247 (*========================================================================
87 :     * Parallel Move
88 :     *========================================================================*)
89 : george 1003 fun moveTmpR(I.ANNOTATION{i,...}) = moveTmpR i
90 : george 1009 | moveTmpR(I.COPY{k=CB.GP, tmp=SOME(I.Direct r), ...}) = SOME r
91 :     | moveTmpR(I.COPY{k=CB.FP, tmp=SOME(I.FDirect f), ...}) = SOME f
92 :     | moveTmpR(I.COPY{k=CB.FP, tmp=SOME(I.FPR f), ...}) = SOME f
93 : monnier 247 | moveTmpR _ = NONE
94 :    
95 : george 1003 fun moveDstSrc(I.ANNOTATION{i,...}) = moveDstSrc i
96 : george 1009 | moveDstSrc(I.COPY{src, dst, ...}) = (dst, src)
97 : george 1003 | moveDstSrc(I.INSTR i) =
98 :     (case i
99 : george 1009 of I.MOVE{src=I.Direct rs, dst=I.MemReg rd, ...} => ([rd], [rs])
100 : george 1003 | I.MOVE{src=I.MemReg rs, dst=I.Direct rd, ...} => ([rd], [rs])
101 :     | I.FMOVE{src=I.FPR rs, dst=I.FPR rd, ...} => ([rd], [rs])
102 :     | I.FMOVE{src=I.FDirect rs, dst=I.FPR rd, ...} => ([rd], [rs])
103 :     | I.FMOVE{src=I.FPR rs, dst=I.FDirect rd, ...} => ([rd], [rs])
104 :     | I.FMOVE{src=I.FDirect rs, dst=I.FDirect rd, ...} => ([rd], [rs])
105 :     | _ => error "moveDstSrc")
106 :     | moveDstSrc _ = error "moveDstSrc2"
107 : monnier 247 (*=====================================================================
108 :     * Branches and Calls/Returns
109 :     *=====================================================================*)
110 : george 1003 fun branchTargets(I.ANNOTATION{i,...}) = branchTargets i
111 :     | branchTargets(I.INSTR i) =
112 :     (case i
113 :     of I.JMP(_, []) => [ESCAPES]
114 :     | I.JMP(_, labs) => map LABELLED labs
115 :     | I.RET _ => [ESCAPES]
116 :     | I.JCC{opnd=I.ImmedLabel(T.LABEL(lab)), ...} =>
117 :     [FALLTHROUGH, LABELLED lab]
118 :     | I.CALL{cutsTo, ...} => FALLTHROUGH :: map LABELLED cutsTo
119 : jhr 1099 | I.INTO => [ESCAPES]
120 : george 1003 | _ => error "branchTargets")
121 : monnier 247 | branchTargets _ = error "branchTargets"
122 :    
123 : george 1003 fun jump label = I.jmp (I.ImmedLabel(T.LABEL label), [label])
124 : monnier 247
125 :     exception NotImplemented
126 : george 1003
127 : george 1133 fun setJumpTarget(I.ANNOTATION{a,i}, l) = I.ANNOTATION{a=a, i=setJumpTarget(i,l)}
128 :     | setJumpTarget(I.INSTR(I.JMP(I.ImmedLabel _, _)), lab) = jump lab
129 :     | setJumpTarget _ = error "setJumpTarget"
130 :    
131 :     fun setBranchTargets{i=I.ANNOTATION{a,i}, t, f} =
132 :     I.ANNOTATION{a=a, i=setBranchTargets{i=i, t=t, f=f}}
133 :     | setBranchTargets{i=I.INSTR(I.JCC{cond,opnd=I.ImmedLabel _}), t, ...} =
134 : george 1003 I.jcc{cond=cond,opnd=I.ImmedLabel(T.LABEL t)}
135 : george 1133 | setBranchTargets _ = error "setBranchTargets"
136 : george 1003
137 : jhr 1100 fun negateConditional (I.ANNOTATION{i,a}, lab) =
138 :     I.ANNOTATION{i=negateConditional(i,lab), a=a}
139 : jhr 1101 | negateConditional (I.INSTR(I.JCC{cond,opnd=I.ImmedLabel(T.LABEL _)}), lab) =
140 :     let
141 : jhr 1100 val cond' = (case cond
142 :     of I.EQ => I.NE
143 :     | I.NE => I.EQ
144 :     | I.LT => I.GE
145 :     | I.LE => I.GT
146 :     | I.GT => I.LE
147 :     | I.GE => I.LT
148 :     | I.B => I.AE
149 :     | I.BE => I.A
150 :     | I.A => I.BE
151 :     | I.AE => I.B
152 :     | I.C => I.NC
153 :     | I.NC => I.C
154 :     | I.P => I.NP
155 :     | I.NP => I.P
156 :     | I.O => I.NO
157 :     | I.NO => I.O
158 :     (* end case *))
159 :     in
160 : jhr 1101 I.INSTR(I.JCC{cond=cond', opnd=I.ImmedLabel(T.LABEL lab)})
161 : jhr 1100 end
162 :     | negateConditional _ = error "negateConditional"
163 : monnier 247
164 : monnier 411 val immedRange={lo= ~1073741824, hi=1073741823}
165 :     val toInt32 = Int32.fromLarge o Int.toLarge
166 :     fun loadImmed{immed,t} =
167 : george 1003 I.move{mvOp=I.MOVL,src=I.Immed(toInt32 immed),dst=I.Direct t}
168 :     fun loadOperand{opn,t} = I.move{mvOp=I.MOVL,src=opn,dst=I.Direct t}
169 : monnier 411
170 :     (*=====================================================================
171 :     * Hashing and Equality on operands
172 :     *=====================================================================*)
173 :     fun hashOpn(I.Immed i) = Word.fromInt(Int32.toInt i)
174 : george 984 | hashOpn(I.ImmedLabel le) = MLTreeHash.hash le + 0w123
175 : monnier 411 | hashOpn(I.Relative i) = Word.fromInt i + 0w1232
176 : george 984 | hashOpn(I.LabelEA le) = MLTreeHash.hash le + 0w44444
177 : george 889 | hashOpn(I.Direct r) = CB.hashCell r
178 :     | hashOpn(I.MemReg r) = CB.hashCell r + 0w2123
179 :     | hashOpn(I.ST f) = CB.hashCell f + 0w88
180 :     | hashOpn(I.FPR f) = CB.hashCell f + 0w881
181 :     | hashOpn(I.FDirect f) = CB.hashCell f + 0w31245
182 : george 545 | hashOpn(I.Displace {base, disp, ...}) =
183 : george 889 hashOpn disp + CB.hashCell base
184 : monnier 411 | hashOpn(I.Indexed {base, index, scale, disp, ...}) =
185 : george 889 CB.hashCell index + Word.fromInt scale + hashOpn disp
186 : monnier 411 fun eqOpn(I.Immed a,I.Immed b) = a = b
187 : george 984 | eqOpn(I.ImmedLabel a,I.ImmedLabel b) = MLTreeEval.==(a,b)
188 : monnier 411 | eqOpn(I.Relative a,I.Relative b) = a = b
189 : george 984 | eqOpn(I.LabelEA a,I.LabelEA b) = MLTreeEval.==(a,b)
190 : george 889 | eqOpn(I.Direct a,I.Direct b) = CB.sameColor(a,b)
191 :     | eqOpn(I.MemReg a,I.MemReg b) = CB.sameColor(a,b)
192 :     | eqOpn(I.FDirect a,I.FDirect b) = CB.sameColor(a,b)
193 :     | eqOpn(I.ST a,I.ST b) = CB.sameColor(a,b)
194 :     | eqOpn(I.FPR a,I.FPR b) = CB.sameColor(a,b)
195 : monnier 411 | eqOpn(I.Displace{base=a,disp=b,...},I.Displace{base=c,disp=d,...}) =
196 : george 889 CB.sameColor(a,c) andalso eqOpn(b,d)
197 : monnier 411 | eqOpn(I.Indexed{base=a,index=b,scale=c,disp=d,...},
198 :     I.Indexed{base=e,index=f,scale=g,disp=h,...}) =
199 : george 889 CB.sameColor(b,f) andalso c = g
200 : leunga 744 andalso sameCellOption(a,e) andalso eqOpn(d,h)
201 : monnier 411 | eqOpn _ = false
202 : leunga 744 and sameCellOption(NONE, NONE) = true
203 : george 889 | sameCellOption(SOME x, SOME y) = CB.sameColor(x,y)
204 : leunga 744 | sameCellOption _ = false
205 : monnier 411
206 : monnier 247 (*========================================================================
207 :     * Definition and use (for register allocation mainly)
208 :     *========================================================================*)
209 :     val eaxPair = [C.edx, C.eax]
210 :    
211 :     fun defUseR instr = let
212 : george 1009 fun operandAcc(I.Direct r, acc) = r::acc
213 :     | operandAcc(I.MemReg r, acc) = r::acc
214 :     | operandAcc(I.Displace{base, ...}, acc) = base::acc
215 :     | operandAcc(I.Indexed{base=SOME b, index, ...}, acc) = b::index::acc
216 :     | operandAcc(I.Indexed{base=NONE, index, ...}, acc) = index::acc
217 :     | operandAcc(_, acc) = acc
218 :    
219 : george 1003 fun x86DefUseR instr = let
220 :     fun operandUse opnd = operandAcc(opnd, [])
221 : monnier 247
222 : george 1003 fun operandUse2(src1, src2) = ([], operandAcc(src1, operandUse src2))
223 :     fun operandUse3(x, y, z) = ([], operandAcc(x, operandAcc(y, operandUse y)))
224 : leunga 731
225 : george 1003 fun operandDef(I.Direct r) = [r]
226 :     | operandDef(I.MemReg r) = [r]
227 :     | operandDef _ = []
228 : monnier 247
229 : george 1003 fun multdiv{src, multDivOp} = let
230 :     val uses = operandUse src
231 :     in
232 :     case multDivOp
233 :     of (I.IDIVL1 | I.DIVL1) => (eaxPair, C.edx::C.eax::uses)
234 : leunga 1156 | (I.IMULL1 | I.MULL1) => (eaxPair, C.eax::uses)
235 : george 1003 end
236 :    
237 :     fun unary opnd = (operandDef opnd, operandUse opnd)
238 :     fun cmptest{lsrc, rsrc} = ([], operandAcc(lsrc, operandUse rsrc))
239 :     fun espOnly() = let val sp = [C.stackptrR] in (sp, sp) end
240 :     fun push arg = ([C.stackptrR], operandAcc(arg, [C.stackptrR]))
241 :     fun float opnd = ([], operandUse opnd)
242 : monnier 247 in
243 : george 1003 case instr
244 :     of I.JMP(opnd, _) => ([], operandUse opnd)
245 :     | I.JCC{opnd, ...} => ([], operandUse opnd)
246 :     | I.CALL{opnd,defs,uses,...} =>
247 :     (C.getReg defs, operandAcc(opnd, C.getReg uses))
248 :     | I.MOVE{src, dst=I.Direct r, ...} => ([r], operandUse src)
249 :     | I.MOVE{src, dst=I.MemReg r, ...} => ([r], operandUse src)
250 :     | I.MOVE{src, dst, ...} => ([], operandAcc(dst, operandUse src))
251 :     | I.LEA{r32, addr} => ([r32], operandUse addr)
252 :     | ( I.CMPL arg | I.CMPW arg | I.CMPB arg
253 :     | I.TESTL arg | I.TESTW arg | I.TESTB arg ) => cmptest arg
254 :     | I.BITOP{lsrc, rsrc, ...} => cmptest{lsrc=lsrc,rsrc=rsrc}
255 :     | I.BINARY{binOp=I.XORL,src=I.Direct rs,dst=I.Direct rd,...} =>
256 :     if CB.sameColor(rs,rd) then ([rd],[]) else ([rd],[rs,rd])
257 :     | I.BINARY{src,dst,...} =>
258 :     (operandDef dst, operandAcc(src, operandUse dst))
259 : leunga 1156 | I.SHIFT{src,dst,count,...} =>
260 :     (operandDef dst,
261 :     operandAcc(count, operandAcc(src, operandUse dst)))
262 : george 1003 | I.CMPXCHG{src, dst, ...} =>
263 :     (C.eax::operandDef dst, C.eax::operandAcc(src, operandUse dst))
264 :     | I.ENTER _ => ([C.esp, C.ebp], [C.esp, C.ebp])
265 :     | I.LEAVE => ([C.esp, C.ebp], [C.esp, C.ebp])
266 :     | I.MULTDIV arg => multdiv arg
267 :     | I.MUL3{src1, dst, ...}=> ([dst], operandUse src1)
268 : monnier 247
269 : george 1003 | I.UNARY{opnd, ...} => unary opnd
270 :     | I.SET{opnd, ...} => unary opnd
271 :     | ( I.PUSHL arg | I.PUSHW arg | I.PUSHB arg ) => push arg
272 :     | I.POP arg => (C.stackptrR::operandDef arg, [C.stackptrR])
273 :     | I.PUSHFD => espOnly()
274 :     | I.POPFD => espOnly()
275 :     | I.CDQ => ([C.edx], [C.eax])
276 :     | I.FSTPT opnd => float opnd
277 :     | I.FSTPL opnd => float opnd
278 :     | I.FSTPS opnd => float opnd
279 :     | I.FSTL opnd => float opnd
280 :     | I.FSTS opnd => float opnd
281 :     | I.FLDL opnd => float opnd
282 :     | I.FLDS opnd => float opnd
283 :     | I.FILD opnd => float opnd
284 :     | I.FILDL opnd => float opnd
285 :     | I.FILDLL opnd => float opnd
286 :     | I.FBINARY{src, ...} => ([], operandUse src)
287 :     | I.FIBINARY{src, ...} => ([], operandUse src)
288 :     | I.FENV{opnd, ...} => ([], operandUse opnd)
289 :     | I.FNSTSW => ([C.eax], [])
290 :     | I.FUCOM opnd => float opnd
291 :     | I.FUCOMP opnd => float opnd
292 : leunga 1156 | I.FCOMI opnd => float opnd
293 :     | I.FCOMIP opnd => float opnd
294 :     | I.FUCOMI opnd => float opnd
295 :     | I.FUCOMIP opnd => float opnd
296 : monnier 247
297 : george 1003 | I.FMOVE{src, dst, ...} => operandUse2(src, dst)
298 :     | I.FILOAD{ea, dst, ...} => operandUse2(ea, dst)
299 :     | I.FCMP{lsrc, rsrc, ...} => operandUse2(lsrc, rsrc)
300 :     | I.FBINOP{lsrc, rsrc, dst, ...} => operandUse3(lsrc, rsrc, dst)
301 :     | I.FIBINOP{lsrc, rsrc, dst, ...} => operandUse3(lsrc, rsrc, dst)
302 :     | I.FUNOP{src, dst, ...} => operandUse2(src, dst)
303 : leunga 731
304 : george 1003 | I.SAHF => ([], [C.eax])
305 :     | I.LAHF => ([C.eax], [])
306 :     (* This sets the low order byte,
307 :     * do potentially it may define *and* use
308 :     *)
309 :     | I.CMOV{src,dst,...} => ([dst], operandAcc(src, [dst]))
310 :     | _ => ([], [])
311 :     end
312 :     in
313 :     case instr
314 :     of I.ANNOTATION{i, ...} => defUseR i
315 :     | I.LIVE{regs, ...} => ([], C.getReg regs)
316 :     | I.KILL{regs, ...} => (C.getReg regs, [])
317 : george 1009 | I.COPY{k=CB.GP, dst, src, tmp, ...} =>
318 :     (case tmp
319 :     of NONE => (dst, src)
320 :     | SOME(I.Direct r) => (r::dst, src)
321 :     | SOME(I.MemReg r) => (r::dst, src)
322 :     | SOME(ea) => (dst, operandAcc(ea, src))
323 :     (*esac*))
324 :     | I.COPY _ => ([], [])
325 : george 1003 | I.INSTR i => x86DefUseR(i)
326 :     end
327 : leunga 731
328 : monnier 247 fun defUseF instr = let
329 : leunga 731
330 : george 1003 fun x86DefUseF instr = let
331 :     fun operand(I.FDirect f) = [f]
332 :     | operand(I.FPR f) = [f]
333 :     | operand _ = []
334 : leunga 731
335 : george 1003 fun operandAcc(I.FDirect f, acc) = f::acc
336 :     | operandAcc(I.FPR f, acc) = f::acc
337 :     | operandAcc(_ , acc) = acc
338 : leunga 731
339 : george 1003 fun fbinop(lsrc, rsrc, dst) =
340 :     let val def = operand dst
341 :     val use = operandAcc(lsrc, operand rsrc)
342 :     in (def, use)
343 :     end
344 : leunga 731
345 : george 1003 val fcmpTmp = [C.ST 0]
346 : leunga 731
347 : george 1003 in
348 :     case instr
349 : leunga 1156 of I.FSTPT opnd => (operand opnd, [])
350 : george 1003 | I.FSTPL opnd => (operand opnd, [])
351 :     | I.FSTPS opnd => (operand opnd, [])
352 :     | I.FSTL opnd => (operand opnd, [])
353 :     | I.FSTS opnd => (operand opnd, [])
354 :     | I.FLDT opnd => ([], operand opnd)
355 :     | I.FLDL opnd => ([], operand opnd)
356 :     | I.FLDS opnd => ([], operand opnd)
357 : leunga 1156 | I.FUCOM opnd => ([], operand opnd)
358 :     | I.FUCOMP opnd => ([], operand opnd)
359 :     | I.FCOMI opnd => ([], operand opnd)
360 :     | I.FCOMIP opnd => ([], operand opnd)
361 :     | I.FUCOMI opnd => ([], operand opnd)
362 :     | I.FUCOMIP opnd => ([], operand opnd)
363 : george 1003 | I.CALL{defs, uses, ...} => (C.getFreg defs, C.getFreg uses)
364 :     | I.FBINARY{dst, src, ...}=> (operand dst, operand dst @ operand src)
365 : leunga 731
366 : george 1003 | I.FMOVE{src, dst, ...} => (operand dst, operand src)
367 :     | I.FILOAD{ea, dst, ...} => (operand dst, [])
368 :     | I.FCMP{lsrc, rsrc, ...} => (fcmpTmp, operandAcc(lsrc, operand rsrc))
369 :     | I.FBINOP{lsrc, rsrc, dst, ...} => fbinop(lsrc, rsrc, dst)
370 :     | I.FIBINOP{lsrc, rsrc, dst, ...} => fbinop(lsrc, rsrc, dst)
371 :     | I.FUNOP{src, dst, ...} => (operand dst, operand src)
372 :     | _ => ([], [])
373 :     end
374 :     in
375 :     case instr
376 :     of (I.ANNOTATION{i, ...}) => defUseF(i)
377 : george 1009 | I.LIVE{regs, ...} => ([], C.getFreg regs)
378 :     | I.KILL{regs, ...} => (C.getFreg regs, [])
379 :     | I.COPY{k=CB.FP, dst, src, tmp, ...} =>
380 :     (case tmp
381 :     of NONE => (dst, src)
382 :     | SOME(I.FDirect f) => (f::dst, src)
383 :     | SOME(I.FPR f) => (f::dst, src)
384 :     | _ => (dst, src)
385 :     (*esac*))
386 :     | I.COPY _ => ([], [])
387 : george 1003 | (I.INSTR i) => x86DefUseF(i)
388 : monnier 247 end
389 :    
390 : george 889 fun defUse CB.GP = defUseR
391 :     | defUse CB.FP = defUseF
392 : monnier 247 | defUse _ = error "defUse"
393 : monnier 411
394 :     (*========================================================================
395 :     * Annotations
396 :     *========================================================================*)
397 : monnier 469 fun getAnnotations(I.ANNOTATION{i,a}) =
398 :     let val (i,an) = getAnnotations i in (i,a::an) end
399 :     | getAnnotations i = (i,[])
400 : george 1003
401 : monnier 411 fun annotate(i,a) = I.ANNOTATION{i=i,a=a}
402 : leunga 657
403 :     (*========================================================================
404 :     * Replicate an instruction
405 :     *========================================================================*)
406 :     fun replicate(I.ANNOTATION{i,a}) = I.ANNOTATION{i=replicate i,a=a}
407 : george 1003 (*
408 : leunga 657 | replicate(I.COPY{tmp=SOME _, dst, src}) =
409 :     I.COPY{tmp=SOME(I.Direct(C.newReg())), dst=dst, src=src}
410 :     | replicate(I.FCOPY{tmp=SOME _, dst, src}) =
411 :     I.FCOPY{tmp=SOME(I.FDirect(C.newFreg())), dst=dst, src=src}
412 : george 1003 *)
413 : leunga 657 | replicate i = i
414 : monnier 247 end
415 :    

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