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/sparc/instructions/sparcProps.sml
ViewVC logotype

Annotation of /sml/trunk/src/MLRISC/sparc/instructions/sparcProps.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1124 - (view) (download)

1 : jhr 1082 (* sparcProps.sml
2 :     *
3 :     * COPYRIGHT (c) 2002 Bell Labs, Lucent Technologies
4 :     *)
5 :    
6 : george 984 functor SparcProps
7 :     (structure SparcInstr : SPARCINSTR
8 :     structure MLTreeEval : MLTREE_EVAL where T = SparcInstr.T
9 :     structure MLTreeHash : MLTREE_HASH where T = SparcInstr.T
10 :     ) : INSN_PROPERTIES =
11 : monnier 245 struct
12 :     structure I = SparcInstr
13 :     structure C = I.C
14 : leunga 775 structure T = I.T
15 : george 889 structure CB = CellsBasis
16 : monnier 245
17 :     exception NegateConditional
18 :    
19 : monnier 411 fun error msg = MLRiscErrorMsg.error("SparcProps",msg)
20 : monnier 245
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 245 datatype target = LABELLED of Label.label | FALLTHROUGH | ESCAPES
24 :    
25 : george 889 val zeroR = Option.valOf(C.zeroReg CB.GP)
26 :     val r15 = C.Reg CB.GP 15
27 :     val r31 = C.Reg CB.GP 31
28 : leunga 744
29 : monnier 245 (*========================================================================
30 :     * Instruction Kinds
31 :     *========================================================================*)
32 : george 1003 fun instrKind(I.ANNOTATION{i, ...}) = instrKind i
33 : george 1009 | instrKind(I.COPY _) = IK_COPY
34 : george 1003 | instrKind(I.INSTR instr) =
35 :     (case instr
36 :     of (I.Bicc _) => IK_JUMP
37 :     | (I.FBfcc _) => IK_JUMP
38 :     | (I.JMP _) => IK_JUMP
39 :     | (I.RET _) => IK_JUMP
40 :     | (I.BR _) => IK_JUMP
41 :     | (I.BP _) => IK_JUMP
42 : george 1124 | (I.Ticc {t=I.BA, ...}) => IK_JUMP (* trap always *)
43 : george 1003 | (I.CALL{cutsTo=_::_,...}) => IK_CALL_WITH_CUTS
44 :     | (I.CALL _) => IK_CALL
45 :     | (I.JMPL{cutsTo=_::_,...}) => IK_CALL_WITH_CUTS
46 :     | (I.JMPL _) => IK_CALL
47 :     | (I.PHI _) => IK_PHI
48 :     | (I.SOURCE _) => IK_SOURCE
49 :     | (I.SINK _) => IK_SINK
50 :     | _ => IK_INSTR
51 :     (*esac*))
52 :     | instrKind _ = error "instrKind"
53 : monnier 245
54 : george 1003 fun branchTargets(I.ANNOTATION{i,...}) = branchTargets i
55 :     | branchTargets(I.INSTR(instr)) =
56 :     (case instr
57 :     of (I.Bicc{b=I.BA,label,...}) => [LABELLED label]
58 :     | (I.Bicc{label,...}) => [LABELLED label, FALLTHROUGH]
59 :     | (I.FBfcc{b=I.FBA,label,...}) => [LABELLED label]
60 :     | (I.FBfcc{label,...}) => [LABELLED label, FALLTHROUGH]
61 :     | (I.BR{label,...}) => [LABELLED label, FALLTHROUGH]
62 :     | (I.BP{label,...}) => [LABELLED label, FALLTHROUGH]
63 :     | (I.JMP{labs=[],...}) => [ESCAPES]
64 :     | (I.RET _) => [ESCAPES]
65 :     | (I.JMP{labs,...}) => map LABELLED labs
66 :     | (I.CALL{cutsTo,...}) => FALLTHROUGH::map LABELLED cutsTo
67 :     | (I.JMPL{cutsTo,...}) => FALLTHROUGH::map LABELLED cutsTo
68 : george 1124 | (I.Ticc{t=I.BA, ...}) => [ESCAPES]
69 : george 1003 | _ => error "branchTargets"
70 :     (*esac*))
71 :     | branchTargets _ = error "branchTargets"
72 : monnier 245
73 : george 1003 fun setTargets(I.INSTR(I.Bicc{b=I.BA,a,nop,...}),[L]) =
74 :     I.bicc{b=I.BA,a=a,label=L,nop=nop}
75 :     | setTargets(I.INSTR(I.Bicc{b,a,nop,...}),[F,T]) =
76 :     I.bicc{b=b,a=a,label=T,nop=nop}
77 :     | setTargets(I.INSTR(I.FBfcc{b,a,nop,...}),[F,T]) =
78 :     I.fbfcc{b=b,a=a,label=T,nop=nop}
79 :     | setTargets(I.INSTR(I.BR{rcond,p,r,a,nop,...}),[F,T]) =
80 :     I.br{rcond=rcond,p=p,r=r,a=a,label=T,nop=nop}
81 :     | setTargets(I.INSTR(I.BP{b,cc,p,a,nop,...}),[F,T]) =
82 :     I.bp{b=b,cc=cc,p=p,a=a,label=T,nop=nop}
83 :     | setTargets(I.INSTR(I.JMP{r,i,nop,...}),labels) =
84 :     I.jmp{r=r,i=i,labs=labels,nop=nop}
85 : monnier 411 | setTargets(I.ANNOTATION{i,a},labs) =
86 :     I.ANNOTATION{i=setTargets(i,labs),a=a}
87 : monnier 245 | setTargets(i,_) = i
88 :    
89 : monnier 411 fun revCond I.BA = I.BN
90 :     | revCond I.BN = I.BA
91 :     | revCond I.BNE = I.BE
92 :     | revCond I.BE = I.BNE
93 :     | revCond I.BG = I.BLE
94 :     | revCond I.BLE = I.BG
95 :     | revCond I.BGE = I.BL
96 :     | revCond I.BL = I.BGE
97 :     | revCond I.BGU = I.BLEU
98 :     | revCond I.BLEU = I.BGU
99 :     | revCond I.BCC = I.BCS
100 :     | revCond I.BCS = I.BCC
101 :     | revCond I.BPOS = I.BNEG
102 :     | revCond I.BNEG = I.BPOS
103 :     | revCond I.BVC = I.BVS
104 :     | revCond I.BVS = I.BVC
105 :    
106 :     fun revFcond I.FBA = I.FBN
107 :     | revFcond I.FBN = I.FBA
108 :     | revFcond I.FBU = I.FBO
109 :     | revFcond I.FBG = I.FBULE
110 :     | revFcond I.FBUG = I.FBLE
111 :     | revFcond I.FBL = I.FBUGE
112 :     | revFcond I.FBUL = I.FBGE
113 :     | revFcond I.FBLG = I.FBUE
114 :     | revFcond I.FBNE = I.FBE
115 :     | revFcond I.FBE = I.FBNE
116 :     | revFcond I.FBUE = I.FBLG
117 :     | revFcond I.FBGE = I.FBUL
118 :     | revFcond I.FBUGE = I.FBL
119 :     | revFcond I.FBLE = I.FBUG
120 :     | revFcond I.FBULE = I.FBG
121 :     | revFcond I.FBO = I.FBU
122 :    
123 :     fun revRcond I.RZ = I.RNZ
124 :     | revRcond I.RLEZ = I.RGZ
125 :     | revRcond I.RLZ = I.RGEZ
126 :     | revRcond I.RNZ = I.RZ
127 :     | revRcond I.RGZ = I.RLEZ
128 :     | revRcond I.RGEZ = I.RLZ
129 :    
130 :     fun revP I.PT = I.PN
131 :     | revP I.PN = I.PT
132 :    
133 : jhr 1082 fun negateConditional (I.INSTR(I.Bicc{b,a,nop,...}), lab) =
134 :     I.bicc{b=revCond b,a=a,label=lab,nop=nop}
135 :     | negateConditional (I.INSTR(I.FBfcc{b,a,nop,...}), lab) =
136 :     I.fbfcc{b=revFcond b,a=a,label=lab,nop=nop}
137 :     | negateConditional (I.INSTR(I.BR{p,r,rcond,a,nop,...}), lab) =
138 :     I.br{p=revP p,a=a,r=r,rcond=revRcond rcond,label=lab,nop=nop}
139 :     | negateConditional (I.INSTR(I.BP{b,cc,p,a,nop,...}), lab) =
140 :     I.bp{p=revP p,a=a,b=revCond b,cc=cc,label=lab,nop=nop}
141 :     | negateConditional (I.ANNOTATION{i,a}, lab) =
142 :     I.ANNOTATION{i=negateConditional(i, lab), a=a}
143 : monnier 245 | negateConditional _ = raise NegateConditional
144 :    
145 : george 1003 fun jump label = I.bicc{b=I.BA,a=true,label=label,nop=true}
146 : monnier 245
147 : monnier 411 val immedRange = {lo= ~4096, hi = 4095}
148 :    
149 : leunga 657 fun loadImmed{immed,t} =
150 : george 1003 I.arith{a=I.OR,r=zeroR,i=
151 : leunga 657 if #lo immedRange <= immed andalso immed <= #hi immedRange
152 : leunga 775 then I.IMMED immed else I.LAB(T.LI(IntInf.fromInt immed)),d=t}
153 : george 1003 fun loadOperand{opn, t} = I.arith{a=I.OR,r=zeroR,i=opn, d=t}
154 : monnier 411
155 : george 1003 fun moveInstr(I.ANNOTATION{i,...}) = moveInstr i
156 : george 1009 | moveInstr(I.COPY _) = true
157 : george 1003 | moveInstr(I.LIVE _) = false
158 :     | moveInstr(I.KILL _) = false
159 : monnier 245 | moveInstr _ = false
160 :    
161 : george 1003 fun nop() = I.sethi{d=zeroR, i=0}
162 : monnier 245
163 :     (*========================================================================
164 :     * Parallel Move
165 :     *========================================================================*)
166 : george 1009 fun moveTmpR(I.COPY{tmp, ...}) =
167 :     (case tmp
168 :     of SOME(I.Direct r) => SOME r
169 :     | SOME(I.FDirect f) => SOME f
170 :     | _ => NONE
171 :     (*esac*))
172 : monnier 411 | moveTmpR(I.ANNOTATION{i,...}) = moveTmpR i
173 : monnier 245 | moveTmpR _ = NONE
174 :    
175 : george 1009
176 :     fun moveDstSrc(I.COPY{dst,src,...}) = (dst,src)
177 : monnier 411 | moveDstSrc(I.ANNOTATION{i,...}) = moveDstSrc i
178 : monnier 245 | moveDstSrc _ = error "moveDstSrc"
179 :    
180 : monnier 411 (*========================================================================
181 :     * Equality and hashing
182 :     *========================================================================*)
183 : george 889 fun hashOpn(I.REG r) = CB.hashCell r
184 : monnier 411 | hashOpn(I.IMMED i) = Word.fromInt i
185 : george 984 | hashOpn(I.LAB l) = MLTreeHash.hash l
186 :     | hashOpn(I.LO l) = MLTreeHash.hash l
187 :     | hashOpn(I.HI l) = MLTreeHash.hash l
188 : george 889 fun eqOpn(I.REG a,I.REG b) = CB.sameColor(a,b)
189 : monnier 411 | eqOpn(I.IMMED a,I.IMMED b) = a = b
190 : george 984 | eqOpn(I.LAB a,I.LAB b) = MLTreeEval.==(a,b)
191 :     | eqOpn(I.LO a,I.LO b) = MLTreeEval.==(a,b)
192 :     | eqOpn(I.HI a,I.HI b) = MLTreeEval.==(a,b)
193 : monnier 411 | eqOpn _ = false
194 : monnier 245
195 : george 1003 fun defUseR instr = let
196 : george 1009 fun oper (I.REG r,def,use) = (def,r::use)
197 :     | oper (_,def,use) = (def,use)
198 : george 1003 fun sparcDU instr =
199 : george 1009 (case instr
200 :     of I.LOAD {r,d,i,...} => oper(i,[d],[r])
201 :     | I.STORE {r,d,i,...} => oper(i,[],[r,d])
202 :     | I.FLOAD {r,d,i,...} => oper(i,[],[r])
203 :     | I.FSTORE {r,d,i,...} => oper(i,[],[r])
204 :     | I.SETHI {d,...} => ([d],[])
205 :     | I.ARITH {r,i,d,...} => oper(i,[d],[r])
206 :     | I.SHIFT {r,i,d,...} => oper(i,[d],[r])
207 :     | I.JMPL{defs,uses,d,r,i,...} =>
208 :     oper(i,d:: C.getReg defs,r:: C.getReg uses)
209 :     | I.BR{r,...} => ([],[r])
210 :     | I.MOVicc{i,d,...} => oper(i,[d],[d])
211 :     | I.MOVfcc{i,d,...} => oper(i,[d],[d])
212 :     | I.MOVR{r,i,d,...} => oper(i,[d],[r,d])
213 :     | I.CALL{defs,uses,...} => (r15 :: C.getReg defs, C.getReg uses)
214 :     | I.JMP{r,i,...} => oper(i,[],[r])
215 :     | I.RET{leaf=false,...} => ([],[r31])
216 :     | I.RET{leaf=true,...} => ([],[r15])
217 :     | I.SAVE{r,i,d} => oper(i,[d],[r])
218 :     | I.RESTORE{r,i,d} => oper(i,[d],[r])
219 :     | I.Ticc{r,i,...} => oper(i,[],[r])
220 :     | I.RDY{d,...} => ([d],[])
221 :     | I.WRY{r,i,...} => oper(i,[],[r])
222 :     | _ => ([],[])
223 :     (*esac*))
224 : george 1003 in
225 :     case instr
226 :     of I.ANNOTATION{i, ...} => defUseR i
227 :     | I.LIVE{regs, ...} => ([], C.getReg regs)
228 :     | I.KILL{regs, ...} => (C.getReg regs, [])
229 :     | I.INSTR(i) => sparcDU(i)
230 : george 1009 | I.COPY{k, dst, src, tmp, ...} => let
231 :     val (d,u) = case k of CB.GP => (dst, src) | _ => ([], [])
232 :     in
233 :     case tmp
234 :     of SOME(I.Direct r) => (r::d, u)
235 :     | SOME(I.Displace{base, ...}) => (d, base::u)
236 :     | _ => (d,u)
237 :     end
238 : george 1003 end
239 : monnier 245
240 :     (* Use of FP registers *)
241 : george 1003 fun defUseF instr = let
242 :     fun sparcDU instr =
243 :     (case instr of
244 : monnier 245 I.FLOAD{r,d,i,...} => ([d],[])
245 :     | I.FSTORE{r,d,i,...} => ([],[d])
246 :     | I.FPop1{r,d,...} => ([d],[r])
247 :     | I.FPop2{r1,r2,d,...} => ([d],[r1,r2])
248 :     | I.FCMP{r1,r2,...} => ([],[r1,r2])
249 : leunga 744 | I.JMPL{defs,uses,...} => (C.getFreg defs,C.getFreg uses)
250 :     | I.CALL{defs,uses,...} => (C.getFreg defs,C.getFreg uses)
251 : monnier 411 | I.FMOVicc{r,d,...} => ([d],[r,d])
252 :     | I.FMOVfcc{r,d,...} => ([d],[r,d])
253 : monnier 245 | _ => ([],[])
254 : george 1003 (*esac*))
255 :     in
256 :     case instr
257 :     of I.ANNOTATION{i, ...} => defUseF i
258 :     | I.LIVE{regs, ...} => ([], C.getFreg regs)
259 :     | I.KILL{regs, ...} => (C.getFreg regs, [])
260 : george 1009 | I.COPY{k, dst, src, tmp, ...} => let
261 :     val (d, u) = case k of CB.FP => (dst, src) | _ => ([],[])
262 :     in
263 :     case tmp
264 :     of SOME(I.FDirect f) => (f::d, u)
265 :     | _ => (d, u)
266 :     end
267 : george 1003 | I.INSTR(i) => sparcDU(i)
268 :     end
269 : monnier 245
270 : george 889 fun defUse CB.GP = defUseR
271 :     | defUse CB.FP = defUseF
272 : monnier 245 | defUse _ = error "defUse"
273 :    
274 : monnier 411 (*========================================================================
275 :     * Annotations
276 :     *========================================================================*)
277 : monnier 469 fun getAnnotations(I.ANNOTATION{i,a}) =
278 :     let val (i,an) = getAnnotations i in (i,a::an) end
279 :     | getAnnotations i = (i,[])
280 : monnier 411 fun annotate(i,a) = I.ANNOTATION{i=i,a=a}
281 : leunga 657
282 :     (*========================================================================
283 :     * Replicate an instruction
284 :     *========================================================================*)
285 :     fun replicate(I.ANNOTATION{i,a}) = I.ANNOTATION{i=replicate i,a=a}
286 : george 1009 | replicate(I.COPY{k, sz, tmp=SOME _, dst, src}) =
287 :     I.COPY{k=k, sz=sz, tmp=SOME(I.Direct(C.newReg())), dst=dst, src=src}
288 : leunga 657 | replicate i = i
289 : monnier 245 end

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