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

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

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

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

Legend:
Removed from v.593  
changed lines
  Added in v.1009

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