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/branches/idlbasis-devel/src/MLRISC/hppa/instructions/hppaProps.sml
ViewVC logotype

Annotation of /sml/branches/idlbasis-devel/src/MLRISC/hppa/instructions/hppaProps.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 859 - (view) (download)

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

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