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 411 - (view) (download)
Original Path: sml/branches/SMLNJ/src/MLRISC/x86/instructions/x86Props.sml

1 : monnier 247 (* x86Props.sml -- 32bit, x86 instruction semantic properties
2 :     *
3 :     * COPYRIGHT (c) 1997 Bell Laboratories.
4 :     *)
5 :    
6 : monnier 411 functor X86Props(X86Instr : X86INSTR) : INSN_PROPERTIES =
7 : monnier 247 struct
8 :     structure I = X86Instr
9 :     structure C = I.C
10 :     structure LE = LabelExp
11 :    
12 :     exception NegateConditional
13 :    
14 : monnier 411 fun error msg = MLRiscErrorMsg.error("X86Props",msg)
15 : monnier 247
16 : monnier 411 datatype kind = IK_JUMP | IK_NOP | IK_INSTR | IK_COPY | IK_CALL | IK_GROUP
17 :     | IK_PHI | IK_SOURCE | IK_SINK
18 : monnier 247 datatype target = LABELLED of Label.label | FALLTHROUGH | ESCAPES
19 :     (*========================================================================
20 :     * Instruction Kinds
21 :     *========================================================================*)
22 :     fun instrKind (I.JMP _) = IK_JUMP
23 :     | instrKind (I.JCC _) = IK_JUMP
24 : monnier 411 | instrKind (I.COPY _) = IK_COPY
25 :     | instrKind (I.FCOPY _) = IK_COPY
26 :     | instrKind (I.CALL _) = IK_CALL
27 :     | instrKind (I.ANNOTATION{i,...}) = instrKind i
28 :     | instrKind (I.GROUP _) = IK_GROUP
29 : monnier 247 | instrKind _ = IK_INSTR
30 :    
31 :    
32 :     fun moveInstr(I.COPY _) = true
33 :     | moveInstr(I.FCOPY _) = true
34 : monnier 411 | moveInstr(I.ANNOTATION{i,...}) = moveInstr i
35 : monnier 247 | moveInstr _ = false
36 :    
37 :     val nop = fn () => I.NOP
38 :    
39 :    
40 :     (*========================================================================
41 :     * Parallel Move
42 :     *========================================================================*)
43 :     fun moveTmpR(I.COPY{tmp=SOME(I.Direct r), ...}) = SOME r
44 :     | moveTmpR(I.FCOPY{tmp=SOME(I.FDirect f), ...}) = SOME f
45 : monnier 411 | moveTmpR(I.ANNOTATION{i,...}) = moveTmpR i
46 : monnier 247 | moveTmpR _ = NONE
47 :    
48 :     fun moveDstSrc(I.COPY{src, dst, ...}) = (dst, src)
49 :     | moveDstSrc(I.FCOPY{src, dst, ...}) = (dst, src)
50 : monnier 411 | moveDstSrc(I.ANNOTATION{i,...}) = moveDstSrc i
51 : monnier 247 | moveDstSrc _ = error "moveDstSrc"
52 :    
53 :    
54 :     (*=====================================================================
55 :     * Branches and Calls/Returns
56 :     *=====================================================================*)
57 :     fun branchTargets(I.JMP(_, [])) = [ESCAPES]
58 :     | branchTargets(I.JMP(_, labs)) = map LABELLED labs
59 :     | branchTargets(I.JCC{opnd=I.ImmedLabel(LE.LABEL(lab)), ...}) =
60 :     [FALLTHROUGH, LABELLED lab]
61 : monnier 411 | branchTargets(I.ANNOTATION{i,...}) = branchTargets i
62 : monnier 247 | branchTargets _ = error "branchTargets"
63 :    
64 :     fun jump label = I.JMP (I.ImmedLabel(LE.LABEL label), [label])
65 :    
66 :     exception NotImplemented
67 :     fun setTargets _ = raise NotImplemented
68 :     fun negateConditional _ = raise NotImplemented
69 :    
70 : monnier 411 val immedRange={lo= ~1073741824, hi=1073741823}
71 :     val toInt32 = Int32.fromLarge o Int.toLarge
72 :     fun loadImmed{immed,t} =
73 :     I.MOVE{mvOp=I.MOVL,src=I.Immed(toInt32 immed),dst=I.Direct t}
74 :    
75 :     (*=====================================================================
76 :     * Hashing and Equality on operands
77 :     *=====================================================================*)
78 :     fun hashOpn(I.Immed i) = Word.fromInt(Int32.toInt i)
79 :     | hashOpn(I.Const c) = I.Constant.hash c
80 :     | hashOpn(I.ImmedLabel le) = LabelExp.hash le + 0w123
81 :     | hashOpn(I.Relative i) = Word.fromInt i + 0w1232
82 :     | hashOpn(I.LabelEA le) = LabelExp.hash le + 0w44444
83 :     | hashOpn(I.Direct r) = Word.fromInt r
84 :     | hashOpn(I.FDirect f) = Word.fromInt f + 0w8888
85 :     | hashOpn(I.Displace {base, disp, ...}) = hashOpn disp + Word.fromInt base
86 :     | hashOpn(I.Indexed {base, index, scale, disp, ...}) =
87 :     Word.fromInt index + Word.fromInt scale + hashOpn disp
88 :     fun eqOpn(I.Immed a,I.Immed b) = a = b
89 :     | eqOpn(I.Const a,I.Const b) = I.Constant.==(a,b)
90 :     | eqOpn(I.ImmedLabel a,I.ImmedLabel b) = LabelExp.==(a,b)
91 :     | eqOpn(I.Relative a,I.Relative b) = a = b
92 :     | eqOpn(I.LabelEA a,I.LabelEA b) = LabelExp.==(a,b)
93 :     | eqOpn(I.Direct a,I.Direct b) = a = b
94 :     | eqOpn(I.FDirect a,I.FDirect b) = a = b
95 :     | eqOpn(I.Displace{base=a,disp=b,...},I.Displace{base=c,disp=d,...}) =
96 :     a = c andalso eqOpn(b,d)
97 :     | eqOpn(I.Indexed{base=a,index=b,scale=c,disp=d,...},
98 :     I.Indexed{base=e,index=f,scale=g,disp=h,...}) =
99 :     b = f andalso c = g andalso a = e andalso eqOpn(d,h)
100 :     | eqOpn _ = false
101 :    
102 : monnier 247 (*========================================================================
103 :     * Definition and use (for register allocation mainly)
104 :     *========================================================================*)
105 :     val eaxPair = [C.edx, C.eax]
106 :    
107 :     fun defUseR instr = let
108 :     fun operandAcc(I.Direct r, acc) = r::acc
109 :     | operandAcc(I.Displace{base, ...}, acc) = base::acc
110 :     | operandAcc(I.Indexed{base=SOME b, index, ...}, acc) = b::index::acc
111 :     | operandAcc(I.Indexed{base=NONE, index, ...}, acc) = index::acc
112 :     | operandAcc(_, acc) = acc
113 :    
114 :     fun operandUse opnd = operandAcc(opnd, [])
115 :    
116 :     fun operandDef(I.Direct r) = [r]
117 :     | operandDef _ = []
118 :    
119 :     fun multdiv{src, multDivOp} = let
120 :     val uses = operandUse src
121 :     in
122 :     case multDivOp
123 :     of (I.IDIV | I.UDIV) => (eaxPair, C.edx::C.eax::uses)
124 :     | I.UMUL => (eaxPair, C.eax::uses)
125 :     end
126 :    
127 :     fun unary {unOp, opnd} = (operandDef opnd, operandUse opnd)
128 :     in
129 :     case instr
130 :     of I.JMP(opnd, _) => ([], operandUse opnd)
131 :     | I.JCC{opnd, ...} => ([], operandUse opnd)
132 : monnier 411 | I.CALL(opnd,defs,uses,_)=> (#1 defs, operandAcc(opnd, #1 uses))
133 : monnier 247 | I.MOVE{src, dst as I.Direct _, ...} => (operandDef dst, operandUse src)
134 :     | I.MOVE{src, dst, ...} => ([], operandAcc(dst, operandUse src))
135 :     | I.LEA{r32, addr} => ([r32], operandUse addr)
136 :     | I.CMP{lsrc, rsrc} => ([], operandAcc(lsrc, operandUse rsrc))
137 :     | I.BINARY{src,dst,...} => (operandDef dst, operandAcc(src, operandUse dst))
138 :     | I.MULTDIV arg => multdiv arg
139 :     | I.MUL3{src1, src2=SOME _, dst}=> ([dst], operandUse src1)
140 :     | I.MUL3{src1, dst, ...}=> ([dst], dst::operandUse src1)
141 :    
142 :     | I.UNARY arg => unary arg
143 :     | I.PUSH arg => ([], operandUse arg)
144 :     | I.POP arg => (operandDef arg, [])
145 :     | I.CDQ => ([C.edx], [C.eax])
146 :    
147 :     | I.COPY{dst, src, tmp=SOME(I.Direct r), ...} => (r::dst, src)
148 :     | I.COPY{dst, src, ...} => (dst, src)
149 :     | I.FSTP opnd => ([], operandUse opnd)
150 :     | I.FLD opnd => ([], operandUse opnd)
151 :     | I.FILD opnd => ([], operandUse opnd)
152 :     | I.FBINARY{src, ...} => ([], operandUse src)
153 :     | I.FNSTSW => ([C.eax], [])
154 :     | I.SAHF => ([], [C.eax])
155 : monnier 411 | I.ANNOTATION{i,...} => defUseR i
156 : monnier 247 | _ => ([], [])
157 :     end (* defUseR *)
158 :    
159 :     fun defUseF instr = let
160 :     fun operand(I.FDirect f) = [f]
161 :     | operand _ = []
162 :     in
163 :     case instr
164 :     of I.FSTP opnd => (operand opnd, [])
165 :     | I.FLD opnd => ([], operand opnd)
166 : monnier 411 | I.CALL(_, defs, uses,_) => (#2 defs, #2 uses)
167 : monnier 247 | I.FBINARY{dst, src, ...}=> (operand dst, operand dst @ operand src)
168 :     | I.FCOPY{dst, src, tmp=SOME(I.FDirect f), ...} => (f::dst, src)
169 :     | I.FCOPY{dst, src, ...} => (dst, src)
170 : monnier 411 | I.ANNOTATION{i,...} => defUseF i
171 : monnier 247 | _ => ([], [])
172 :     end
173 :    
174 :     fun defUse C.GP = defUseR
175 :     | defUse C.FP = defUseF
176 :     | defUse _ = error "defUse"
177 : monnier 411
178 :     (*========================================================================
179 :     * Annotations
180 :     *========================================================================*)
181 :     fun getAnnotations(I.ANNOTATION{i,a}) = a::getAnnotations i
182 :     | getAnnotations _ = []
183 :     fun annotate(i,a) = I.ANNOTATION{i=i,a=a}
184 :    
185 :     (*========================================================================
186 :     * Groups
187 :     *========================================================================*)
188 :     fun getGroup(I.ANNOTATION{i,...}) = getGroup i
189 :     | getGroup(I.GROUP r) = r
190 :     | getGroup _ = error "getGroup"
191 :    
192 :     val makeGroup = I.GROUP
193 : monnier 247 end
194 :    

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