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/hppa/instructions/hppaProps.sml
ViewVC logotype

Annotation of /sml/trunk/src/MLRISC/hppa/instructions/hppaProps.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1124 - (view) (download)

1 : monnier 245 (* hppaProps.sml
2 :     *
3 :     * COPYRIGHT (c) 1996 Bell Laboratories.
4 :     *
5 :     *)
6 :    
7 : george 984 functor HppaProps
8 :     ( structure HppaInstr : HPPAINSTR
9 :     structure MLTreeEval : MLTREE_EVAL where T = HppaInstr.T
10 :     structure MLTreeHash : MLTREE_HASH where T = HppaInstr.T
11 :     ) : INSN_PROPERTIES =
12 : monnier 245 struct
13 :     structure I = HppaInstr
14 :     structure C = HppaInstr.C
15 : george 889 structure CB = CellsBasis
16 : monnier 245
17 :     exception NegateConditional
18 :    
19 : monnier 411 fun error msg = MLRiscErrorMsg.error("HppaProps",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 r31 = C.Reg CB.GP 31
27 : leunga 744
28 : monnier 245 (*========================================================================
29 :     * Instruction Kinds
30 :     *========================================================================*)
31 :     (* Note: BLE and BL used to implement calls are not view as branches *)
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.BCOND _) => IK_JUMP
37 :     | (I.BCONDI _) => IK_JUMP
38 :     | (I.BB _) => IK_JUMP
39 :     | (I.B _) => IK_JUMP
40 :     | (I.BE _) => IK_JUMP
41 :     | (I.FBRANCH _)=> IK_JUMP
42 :     | (I.BV _) => IK_JUMP
43 :     | (I.BLR _) => IK_JUMP
44 : george 1124 | (I.BREAK _) => IK_JUMP
45 : george 1003 | (I.NOP) => IK_NOP
46 :     | (I.BL{cutsTo=_::_,...}) => IK_CALL_WITH_CUTS
47 :     | (I.BL _) => IK_CALL
48 :     | (I.BLE{cutsTo=_::_,...}) => IK_CALL_WITH_CUTS
49 :     | (I.BLE _) => IK_CALL
50 :     | (I.PHI _) => IK_PHI
51 :     | (I.SOURCE _) => IK_SOURCE
52 :     | (I.SINK _) => IK_SINK
53 :     | _ => IK_INSTR)
54 :     | instrKind _ = error "instrKind"
55 : monnier 245
56 : george 1009 fun moveInstr(I.COPY _) = true
57 : monnier 411 | moveInstr(I.ANNOTATION{i,...}) = moveInstr i
58 : monnier 245 | moveInstr _ = false
59 :    
60 : george 1003 fun nop() = I.nop
61 : monnier 245
62 :     (*========================================================================
63 :     * Parallel Move
64 :     *========================================================================*)
65 : george 1009 fun moveTmpR(I.COPY{tmp, ...}) =
66 :     (case tmp
67 :     of SOME(I.Direct r) => SOME r
68 :     | SOME(I.FDirect f) => SOME f
69 :     | _ => NONE
70 :     (*esac*))
71 : monnier 411 | moveTmpR(I.ANNOTATION{i,...}) = moveTmpR i
72 : monnier 245 | moveTmpR _ = NONE
73 :    
74 : george 1009 fun moveDstSrc(I.COPY{dst, src, ...}) = (dst, src)
75 : monnier 411 | moveDstSrc(I.ANNOTATION{i,...}) = moveDstSrc i
76 : monnier 245 | moveDstSrc _ = error "moveDstSrc"
77 :    
78 :     (*========================================================================
79 :     * Branches and Calls/Returns
80 :     *========================================================================*)
81 : george 1003 fun branchTargets(I.ANNOTATION{i,...}) = branchTargets i
82 :     | branchTargets(I.INSTR instr) =
83 :     (case instr
84 :     of (I.BCOND{t, ...}) => [LABELLED t, FALLTHROUGH]
85 :     | (I.BCONDI{t, ...}) => [LABELLED t, FALLTHROUGH]
86 :     | (I.BB{t, ...}) => [LABELLED t, FALLTHROUGH]
87 :     | (I.B{lab, ...}) => [LABELLED lab]
88 :     | (I.FBRANCH{t,...}) => [LABELLED t, FALLTHROUGH]
89 :     | (I.BE{labs=[],...}) => [ESCAPES]
90 :     | (I.BE{labs,...}) => map LABELLED labs
91 :     | (I.BV{labs=[],...}) => [ESCAPES]
92 :     | (I.BV{labs,...}) => map LABELLED labs
93 :     | (I.BLR{labs,...}) => map LABELLED labs
94 :     | (I.BL{cutsTo,...}) => FALLTHROUGH::map LABELLED cutsTo
95 :     | (I.BLE{cutsTo,...}) => FALLTHROUGH::map LABELLED cutsTo
96 : george 1124 | (I.BREAK _) => [ESCAPES]
97 : george 1003 | _ => error "branchTargets"
98 :     (*easc*))
99 :     | branchTargets _ = error "branchTargets"
100 : monnier 245
101 : george 1003 fun jump label = I.b{lab=label,n=true}
102 : monnier 245
103 : monnier 411 val immedRange = {lo= ~8192, hi=8191}
104 : leunga 657 fun loadImmed{immed,t} =
105 : george 1003 I.ldo{i=if #lo immedRange <= immed andalso immed <= #hi immedRange
106 : leunga 657 then I.IMMED immed
107 : leunga 775 else I.LabExp(I.T.LI(I.T.I.fromInt(32,immed)),I.F),b=zeroR,t=t}
108 : george 1003 fun loadOperand{opn,t} = I.ldo{i=opn,b=zeroR,t=t}
109 : monnier 411
110 : george 1003 fun setTargets(I.INSTR(I.BCOND{cmp,bc,r1,r2,t,f,n,nop}), [F,T]) =
111 :     I.bcond{cmp=cmp,bc=bc,r1=r1,r2=r2,t=T,f=F,n=n,nop=nop}
112 :     | setTargets(I.INSTR(I.BCONDI{cmpi,bc,i,r2,t,f,n,nop=nop}), [F,T]) =
113 :     I.bcondi{cmpi=cmpi,bc=bc,i=i,r2=r2,t=T,f=F,n=n,nop=nop}
114 :     | setTargets(I.INSTR(I.BB{bc,r,p,t,f,n,nop}), [F,T]) =
115 :     I.bb{bc=bc,r=r,p=p,t=T,f=F,n=n,nop=nop}
116 :     | setTargets(I.INSTR(I.B{n,...}), [L]) = I.b{lab=L,n=n}
117 :     | setTargets(I.INSTR(I.FBRANCH{cc,fmt,n,long,f1,f2,...}), [F,T]) =
118 :     I.fbranch{cc=cc,fmt=fmt,t=T,f=F,n=n,long=long,f1=f1,f2=f2}
119 :     | setTargets(I.INSTR(I.BV{x,b,n,...}),labels) = I.bv{x=x,b=b,labs=labels,n=n}
120 :     | setTargets(I.INSTR(I.BE{b,d,n,sr,...}),labs) = I.be{b=b,d=d,n=n,sr=sr,labs=labs}
121 :     | setTargets(I.INSTR(I.BLR{x,t,n,...}),labels) = I.blr{x=x,t=t,labs=labels,n=n}
122 : monnier 411 | setTargets(I.ANNOTATION{i,a},labels) =
123 :     I.ANNOTATION{i=setTargets(i,labels),a=a}
124 : monnier 245 | setTargets(i,_) = i
125 :    
126 : jhr 1082 (* negate the branch. Since the HPPA instruction representation tracks both
127 :     * the true and false target labels, we set the false label to be the
128 :     * old true label and set the true label to be the argument label.
129 :     *)
130 :     fun negateConditional (br, lab) = let
131 : monnier 245 fun revFcond I.? = I.!?
132 :     | revFcond I.!<=> = I.<=>
133 :     | revFcond I.== = I.!=
134 :     | revFcond I.?= = I.!?=
135 :     | revFcond I.!<> = I.<>
136 :     | revFcond I.!?>= = I.?>=
137 :     | revFcond I.< = I.!<
138 :     | revFcond I.?< = I.!?<
139 :     | revFcond I.!>= = I.>=
140 :     | revFcond I.!?> = I.?>
141 :     | revFcond I.<= = I.!<=
142 :     | revFcond I.?<= = I.!?<=
143 :     | revFcond I.!> = I.>
144 :     | revFcond I.!?<= = I.?<=
145 :     | revFcond I.> = I.!>
146 :     | revFcond I.?> = I.!?>
147 :     | revFcond I.!<= = I.<=
148 :     | revFcond I.!?< = I.?<
149 :     | revFcond I.>= = I.!>=
150 :     | revFcond I.?>= = I.!?>=
151 :     | revFcond I.!< = I.<
152 :     | revFcond I.!?= = I.?=
153 :     | revFcond I.<> = I.!<>
154 :     | revFcond I.!= = I.==
155 :     | revFcond I.!? = I.?
156 :     | revFcond I.<=> = I.!<=>
157 : leunga 744 | revFcond _ = error "revFcond"
158 : jhr 1082 fun negate (I.INSTR(I.BCOND{cmp,bc,r1,r2,t,f,n,nop})) = I.bcond{
159 :     bc=bc, r1=r1, r2=r2, t=lab, f=t, n=n, nop=nop,
160 :     cmp=case cmp of I.COMBT => I.COMBF | I.COMBF => I.COMBT
161 :     }
162 :     | negate (I.INSTR(I.BCONDI{cmpi,bc,i,r2,t,f,n,nop})) = I.bcondi{
163 :     bc=bc, i=i, r2=r2, t=lab, f=t, n=n, nop=nop,
164 :     cmpi=case cmpi of I.COMIBT => I.COMIBF | I.COMIBF => I.COMIBT
165 :     }
166 :     | negate (I.INSTR(I.BB{bc,r,p,t,f,n,nop})) = I.bb{
167 :     bc=case bc of I.BSET => I.BCLR | I.BCLR => I.BSET,
168 :     r=r,p=p,t=lab,f=t,n=n,nop=nop
169 :     }
170 :     | negate (I.INSTR(I.FBRANCH{cc,fmt,f1,f2,t,f,n,long})) =
171 :     I.fbranch{cc=revFcond cc,fmt=fmt,f1=f1,f2=f2,t=lab,f=t,n=n,long=long}
172 :     | negate (I.ANNOTATION{i,a}) = I.ANNOTATION{i=negate i,a=a}
173 :     | negate _ = raise NegateConditional
174 :     in
175 :     negate br
176 :     end
177 : monnier 245
178 :     (*========================================================================
179 : monnier 411 * Equality and hashing for operands
180 :     *========================================================================*)
181 :     fun hashFieldSel I.F = 0w0
182 :     | hashFieldSel I.S = 0w1
183 :     | hashFieldSel I.D = 0w2
184 :     | hashFieldSel I.R = 0w3
185 :     | hashFieldSel I.T = 0w4
186 :     | hashFieldSel I.P = 0w5
187 :     fun hashOpn(I.IMMED i) = Word.fromInt i
188 : george 984 | hashOpn(I.LabExp(l,f)) = MLTreeHash.hash l + hashFieldSel f
189 :     | hashOpn(I.HILabExp(l,f)) = MLTreeHash.hash l + hashFieldSel f + 0w10000
190 :     | hashOpn(I.LOLabExp(l,f)) = MLTreeHash.hash l + hashFieldSel f + 0w20000
191 : george 889 | hashOpn(I.REG r) = CB.hashCell r
192 : monnier 411 fun eqOpn(I.IMMED i,I.IMMED j) = i = j
193 : george 889 | eqOpn(I.REG x,I.REG y) = CB.sameColor(x,y)
194 : leunga 744 | eqOpn(I.LabExp(a,b),I.LabExp(c,d)) =
195 : george 984 b = d andalso MLTreeEval.==(a,c)
196 : leunga 744 | eqOpn(I.HILabExp(a,b),I.HILabExp(c,d)) =
197 : george 984 b = d andalso MLTreeEval.==(a,c)
198 : leunga 744 | eqOpn(I.LOLabExp(a,b),I.LOLabExp(c,d)) =
199 : george 984 b = d andalso MLTreeEval.==(a,c)
200 : monnier 411 | eqOpn _ = false
201 :    
202 :    
203 :     (*========================================================================
204 : monnier 245 * Definition and use (for register allocation mainly)
205 :     *========================================================================*)
206 :     fun defUseR instr = let
207 : george 1003 fun hppaDU instr = let
208 :     fun trap((I.ADDO | I.SUBO | I.SH1ADDO), d, u) = (d, u)
209 :     | trap(_, d, u) = (d, u)
210 :     fun trapi((I.ADDIO | I.SUBIO), d, u) = (d, u)
211 :     | trapi(_, d, u) = (d, u)
212 :     in
213 :     case instr
214 :     of I.STORE {b, r,...} => ([], [b,r])
215 :     | I.LOAD {l, r1, r2, t, ...} => ([t], [r1,r2])
216 :     | I.LOADI {li, r, t, ...} => ([t], [r])
217 :     | I.ARITH {a, r1, r2, t, ...} => trap(a, [t], [r1,r2])
218 :     | I.ARITHI {ai, r, t, ...} => trapi(ai, [t], [r])
219 :     | I.COMCLR_LDO{r1, r2, b, t1, t2, ...}=>
220 :     if CB.sameColor(t1,t2) then ([t1], [b, r1, r2])
221 :     else ([t1, t2], [b, r1, r2, t2])
222 :     | I.COMICLR_LDO{i1, r2, b, t1, t2, ...}=>
223 :     if CB.sameColor(t1,t2) then ([t1], [b, r2])
224 :     else ([t1, t2], [b, r2, t2])
225 :     | I.SHIFTV {r, t, ...} => ([t], [r])
226 :     | I.SHIFT {r, t, ...} => ([t], [r])
227 :     | I.BCOND {r1, r2, ...} => ([], [r1,r2])
228 :     | I.BCONDI {r2, ...} => ([], [r2])
229 :     | I.BB {r, ...} => ([], [r])
230 :     | I.BV {x, b, ...} => ([], [x,b])
231 :     | I.BE {b, ...} => ([], [b])
232 :     | I.BLR{x, t, ...} => ([t], [x])
233 :     | I.BL{defs, uses, ...} => (C.getReg defs, C.getReg uses)
234 :     | I.BLE{t, b, defs, uses, ...}=>
235 :     (r31 :: t :: C.getReg defs, b :: C.getReg uses)
236 :     | I.LDIL{i, t} => ([t], [])
237 :     | I.LDO{b, t, ...} => ([t], [b])
238 :     | I.MTCTL{r, t} => ([], [r])
239 :     | I.FSTORE {b, ...} => ([], [b])
240 :     | I.FSTOREX {b, x, ...} => ([], [b,x])
241 :     | I.FLOAD {b, ...} => ([], [b])
242 :     | I.FLOADX{b, x, ...} => ([], [b,x])
243 :     | _ => ([],[])
244 :     end
245 : monnier 245 in
246 : george 1003 case instr
247 :     of I.ANNOTATION{i, ...} => defUseR i
248 :     | I.LIVE{regs, ...} => ([], C.getReg regs)
249 :     | I.KILL{regs, ...} => (C.getReg regs, [])
250 :     | I.INSTR(i) => hppaDU(i)
251 : george 1009 | I.COPY{k, dst, src, tmp, ...} => let
252 :     val (d,u) = case k of CB.GP => (dst, src) | _ => ([], [])
253 :     in
254 :     case tmp
255 :     of SOME(I.Direct r) => (r::d, u)
256 :     | SOME(I.Displace{base, ...}) => (* (d, base::u) *) (d, u)
257 :     | _ => (d,u)
258 :     end
259 : monnier 245 end
260 :    
261 : george 1003 fun defUseF instr = let
262 :     fun hppaDU instr =
263 :     case instr
264 :     of I.FSTORE {r, ...} => ([], [r])
265 :     | I.FSTOREX{r, ...} => ([], [r])
266 :     | I.FLOAD{t, ...} => ([t], [])
267 :     | I.FLOADX{t, ...} => ([t], [])
268 :     | I.FARITH {r1, r2, t, ...} => ([t], [r1,r2])
269 :     | I.FUNARY {f, t, ...} => ([t], [f])
270 :     | I.FCNV {f, t, ...} => ([t], [f])
271 :     | I.FBRANCH{f1, f2,...} => ([], [f1, f2])
272 :     | I.BL{defs, uses, ...} => (C.getFreg defs, C.getFreg uses)
273 :     | I.BLE{defs, uses, ...} => (C.getFreg defs, C.getFreg uses)
274 :     | _ => ([],[])
275 :     in
276 :     case instr
277 :     of I.ANNOTATION{i, ...} => defUseF i
278 :     | I.INSTR(i) => hppaDU(i)
279 :     | I.LIVE{regs, ...} => ([], C.getFreg regs)
280 :     | I.KILL{regs, ...} => (C.getFreg regs, [])
281 : george 1009 | I.COPY{k, dst, src, tmp, ...} => let
282 :     val (d, u) = case k of CB.FP => (dst, src) | _ => ([],[])
283 :     in
284 :     case tmp
285 :     of SOME(I.FDirect f) => (f::d, u)
286 :     | _ => (d, u)
287 :     end
288 : george 1003 end
289 : monnier 245
290 : george 889 fun defUse CB.GP = defUseR
291 :     | defUse CB.FP = defUseF
292 : monnier 245 | defUse _ = error "defUse"
293 : monnier 411
294 :     (*========================================================================
295 :     * Annotations
296 :     *========================================================================*)
297 : monnier 469 fun getAnnotations(I.ANNOTATION{i,a}) =
298 :     let val (i,an) = getAnnotations i in (i,a::an) end
299 :     | getAnnotations i = (i,[])
300 : monnier 411 fun annotate(i,a) = I.ANNOTATION{i=i,a=a}
301 : leunga 657
302 :     (*========================================================================
303 :     * Replicate an instruction
304 :     *========================================================================*)
305 :     fun replicate(I.ANNOTATION{i,a}) = I.ANNOTATION{i=replicate i,a=a}
306 : george 1009 | replicate(I.COPY{k, sz, tmp=SOME _, dst, src}) = let
307 :     val tmp = case k of CB.GP => C.newReg() | CB.FP => C.newFreg()
308 :     in
309 :     I.COPY{k=k, sz=sz, tmp=SOME(I.Direct(tmp)), dst=dst, src=src}
310 :     end
311 : leunga 657 | replicate i = i
312 : monnier 245 end
313 :    
314 :    
315 :    

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