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

Annotation of /sml/branches/SMLNJ/src/MLRISC/hppa/instructions/hppaProps.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 498 - (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 :     structure LE = LabelExp
12 :    
13 :     exception NegateConditional
14 :    
15 : monnier 411 fun error msg = MLRiscErrorMsg.error("HppaProps",msg)
16 : monnier 245
17 : monnier 411 datatype kind = IK_JUMP | IK_NOP | IK_INSTR | IK_COPY | IK_CALL | IK_GROUP
18 :     | IK_PHI | IK_SOURCE | IK_SINK
19 : monnier 245 datatype target = LABELLED of Label.label | FALLTHROUGH | ESCAPES
20 :    
21 :     (*========================================================================
22 :     * Instruction Kinds
23 :     *========================================================================*)
24 :     (* Note: BLE and BL used to implement calls are not view as branches *)
25 :     fun instrKind(I.BCOND _) = IK_JUMP
26 :     | instrKind(I.BCONDI _) = IK_JUMP
27 : monnier 411 | instrKind(I.BB _) = IK_JUMP
28 : monnier 245 | instrKind(I.B _) = IK_JUMP
29 : monnier 429 | instrKind(I.BE _) = IK_JUMP
30 : monnier 245 | instrKind(I.FBRANCH _)= IK_JUMP
31 :     | instrKind(I.BV _) = IK_JUMP
32 :     | instrKind(I.BLR _) = IK_JUMP
33 :     | instrKind(I.NOP) = IK_NOP
34 : monnier 411 | instrKind(I.COPY _) = IK_COPY
35 :     | instrKind(I.FCOPY _) = IK_COPY
36 :     | instrKind(I.BL _) = IK_CALL
37 :     | instrKind(I.BLE _) = IK_CALL
38 :     | instrKind(I.ANNOTATION{i,...}) = instrKind i
39 :     | instrKind(I.GROUP _) = IK_GROUP
40 : monnier 245 | instrKind _ = IK_INSTR
41 :    
42 :     fun moveInstr(I.COPY _) = true
43 :     | moveInstr(I.FCOPY _) = true
44 : monnier 411 | moveInstr(I.ANNOTATION{i,...}) = moveInstr i
45 : monnier 245 | moveInstr _ = false
46 :    
47 :     fun nop() = I.NOP
48 :    
49 :     (*========================================================================
50 :     * Parallel Move
51 :     *========================================================================*)
52 :     fun moveTmpR(I.COPY{tmp=SOME(I.Direct r), ...}) = SOME r
53 :     | moveTmpR(I.FCOPY{tmp=SOME(I.FDirect f), ...}) = SOME f
54 : monnier 411 | moveTmpR(I.ANNOTATION{i,...}) = moveTmpR i
55 : monnier 245 | moveTmpR _ = NONE
56 :    
57 :     fun moveDstSrc(I.COPY{dst, src, ...}) = (dst, src)
58 :     | moveDstSrc(I.FCOPY{dst, src, ...}) = (dst, src)
59 : monnier 411 | moveDstSrc(I.ANNOTATION{i,...}) = moveDstSrc i
60 : monnier 245 | moveDstSrc _ = error "moveDstSrc"
61 :    
62 :     (*========================================================================
63 :     * Branches and Calls/Returns
64 :     *========================================================================*)
65 :     fun branchTargets(I.BCOND{t, ...}) = [LABELLED t, FALLTHROUGH]
66 :     | branchTargets(I.BCONDI{t, ...}) = [LABELLED t, FALLTHROUGH]
67 : monnier 411 | branchTargets(I.BB{t, ...}) = [LABELLED t, FALLTHROUGH]
68 : monnier 245 | branchTargets(I.B{lab, ...}) = [LABELLED lab]
69 :     | branchTargets(I.FBRANCH{t,...}) = [LABELLED t, FALLTHROUGH]
70 : monnier 429 | branchTargets(I.BE{labs=[],...}) = [ESCAPES]
71 :     | branchTargets(I.BE{labs,...}) = map LABELLED labs
72 : monnier 245 | branchTargets(I.BV{labs=[],...}) = [ESCAPES]
73 :     | branchTargets(I.BV{labs,...}) = map LABELLED labs
74 :     | branchTargets(I.BLR{labs,...}) = map LABELLED labs
75 : monnier 411 | branchTargets(I.ANNOTATION{i,...}) = branchTargets i
76 : monnier 245 | branchTargets _ = error "branchTargets"
77 :    
78 :     fun jump label = I.B{lab=label,n=true}
79 :    
80 : monnier 411 val immedRange = {lo= ~8192, hi=8191}
81 :     fun loadImmed{immed,t} = I.LDO{i=I.IMMED immed,b=0,t=t}
82 :    
83 :     fun setTargets(I.BCOND{cmp,bc,r1,r2,t,f,n,nop},[F,T]) =
84 :     I.BCOND{cmp=cmp,bc=bc,r1=r1,r2=r2,t=T,f=F,n=n,nop=nop}
85 :     | setTargets(I.BCONDI{cmpi,bc,i,r2,t,f,n,nop=nop},[F,T]) =
86 :     I.BCONDI{cmpi=cmpi,bc=bc,i=i,r2=r2,t=T,f=F,n=n,nop=nop}
87 :     | setTargets(I.BB{bc,r,p,t,f,n,nop},[F,T]) =
88 :     I.BB{bc=bc,r=r,p=p,t=T,f=F,n=n,nop=nop}
89 : monnier 245 | setTargets(I.B{n,...},[L]) = I.B{lab=L,n=n}
90 : monnier 411 | setTargets(I.FBRANCH{cc,fmt,n,long,f1,f2,...},[F,T]) =
91 :     I.FBRANCH{cc=cc,fmt=fmt,t=T,f=F,n=n,long=long,f1=f1,f2=f2}
92 : monnier 245 | setTargets(I.BV{x,b,n,...},labels) = I.BV{x=x,b=b,labs=labels,n=n}
93 : monnier 429 | setTargets(I.BE{b,d,n,sr,...},labs) = I.BE{b=b,d=d,n=n,sr=sr,labs=labs}
94 : monnier 245 | setTargets(I.BLR{x,t,n,...},labels) = I.BLR{x=x,t=t,labs=labels,n=n}
95 : monnier 411 | setTargets(I.ANNOTATION{i,a},labels) =
96 :     I.ANNOTATION{i=setTargets(i,labels),a=a}
97 : monnier 245 | setTargets(i,_) = i
98 :    
99 :     fun negateConditional br = let
100 :     fun revFcond I.? = I.!?
101 :     | revFcond I.!<=> = I.<=>
102 :     | revFcond I.== = I.!=
103 :     | revFcond I.?= = I.!?=
104 :     | revFcond I.!<> = I.<>
105 :     | revFcond I.!?>= = I.?>=
106 :     | revFcond I.< = I.!<
107 :     | revFcond I.?< = I.!?<
108 :     | revFcond I.!>= = I.>=
109 :     | revFcond I.!?> = I.?>
110 :     | revFcond I.<= = I.!<=
111 :     | revFcond I.?<= = I.!?<=
112 :     | revFcond I.!> = I.>
113 :     | 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 :     in
127 :     case br of
128 : monnier 411 I.BCOND{cmp,bc,r1,r2,t,f,n,nop} =>
129 :     I.BCOND{bc=bc, r1=r1, r2=r2, t=t, f=f, n=n, nop=nop,
130 : monnier 245 cmp=case cmp of I.COMBT => I.COMBF | I.COMBF => I.COMBT}
131 : monnier 411 | I.BCONDI{cmpi,bc,i,r2,t,f,n,nop} =>
132 :     I.BCONDI{bc=bc, i=i, r2=r2, t=t, f=f, n=n, nop=nop,
133 : monnier 245 cmpi=case cmpi of I.COMIBT => I.COMIBF | I.COMIBF => I.COMIBT}
134 : monnier 411 | I.BB{bc,r,p,t,f,n,nop} =>
135 :     I.BB{bc=case bc of I.BSET => I.BCLR | I.BCLR => I.BSET,
136 :     r=r,p=p,t=t,f=f,n=n,nop=nop}
137 :     | I.FBRANCH{cc,fmt,f1,f2,t,f,n,long} =>
138 :     I.FBRANCH{cc=revFcond cc,fmt=fmt,f1=f1,f2=f2,t=t,f=f,n=n,long=long}
139 :     | I.ANNOTATION{i,a} => I.ANNOTATION{i=negateConditional i,a=a}
140 : monnier 245 | _ => raise NegateConditional
141 :     end
142 :    
143 :     (*========================================================================
144 : monnier 411 * Equality and hashing for operands
145 :     *========================================================================*)
146 :     fun hashFieldSel I.F = 0w0
147 :     | hashFieldSel I.S = 0w1
148 :     | hashFieldSel I.D = 0w2
149 :     | hashFieldSel I.R = 0w3
150 :     | hashFieldSel I.T = 0w4
151 :     | hashFieldSel I.P = 0w5
152 :     fun hashOpn(I.IMMED i) = Word.fromInt i
153 :     | hashOpn(I.LabExp(l,f)) = LabelExp.hash l + hashFieldSel f
154 :     | hashOpn(I.HILabExp(l,f)) = LabelExp.hash l + hashFieldSel f + 0w10000
155 :     | hashOpn(I.LOLabExp(l,f)) = LabelExp.hash l + hashFieldSel f + 0w20000
156 :     | hashOpn(I.ConstOp c) = I.Constant.hash c
157 :     fun eqOpn(I.IMMED i,I.IMMED j) = i = j
158 :     | eqOpn(I.LabExp(a,b),I.LabExp(c,d)) = b = d andalso LabelExp.==(a,c)
159 :     | eqOpn(I.HILabExp(a,b),I.HILabExp(c,d)) = b = d andalso LabelExp.==(a,c)
160 :     | eqOpn(I.LOLabExp(a,b),I.LOLabExp(c,d)) = b = d andalso LabelExp.==(a,c)
161 :     | eqOpn(I.ConstOp a,I.ConstOp b) = I.Constant.==(a,b)
162 :     | eqOpn _ = false
163 :    
164 :    
165 :     (*========================================================================
166 : monnier 245 * Definition and use (for register allocation mainly)
167 :     *========================================================================*)
168 :     fun defUseR instr = let
169 :     fun trap((I.ADDO | I.SUBO | I.SH1ADDO), d, u) = (d, u)
170 :     | trap(_, d, u) = (d, u)
171 :     fun trapi((I.ADDIO | I.SUBIO), d, u) = (d, u)
172 :     | trapi(_, d, u) = (d, u)
173 :     in
174 :     case instr
175 :     of I.STORE {b, r,...} => ([], [b,r])
176 :     | I.LOAD {l, r1, r2, t, ...} => ([t], [r1,r2])
177 :     | I.LOADI {li, r, t, ...} => ([t], [r])
178 :     | I.ARITH {a, r1, r2, t, ...} => trap(a, [t], [r1,r2])
179 :     | I.ARITHI {ai, r, t, ...} => trapi(ai, [t], [r])
180 : monnier 439 | I.COMCLR_LDO{r1, r2, b, t1, t2, ...}=>
181 :     if t1 = t2 then ([t1], [b, r1, r2])
182 :     else ([t1, t2], [b, r1, r2, t2])
183 : monnier 245 | I.SHIFTV {r, t, ...} => ([t], [r])
184 :     | I.SHIFT {r, t, ...} => ([t], [r])
185 :     | I.BCOND {r1, r2, ...} => ([], [r1,r2])
186 :     | I.BCONDI {r2, ...} => ([], [r2])
187 : monnier 411 | I.BB {r, ...} => ([], [r])
188 : monnier 245 | I.BV {x, b, ...} => ([], [x,b])
189 : monnier 429 | I.BE {b, ...} => ([], [b])
190 : monnier 245 | I.BLR{x, t, ...} => ([t], [x])
191 :     | I.BL{defs, uses, ...} => (#1 defs, #1 uses)
192 :     | I.BLE{t, b, defs, uses, ...}=> (31 :: t :: #1 defs, b :: #1 uses)
193 :     | I.LDIL{i, t} => ([t], [])
194 :     | I.LDO{b, t, ...} => ([t], [b])
195 :     | I.COPY{dst, src, tmp=SOME(I.Direct r), ...} => (r::dst, src)
196 :     | I.COPY{dst, src, ...} => (dst, src)
197 :     | I.MTCTL{r, t} => ([], [r])
198 :     | I.FSTORE {b, ...} => ([], [b])
199 :     | I.FSTOREX {b, x, ...} => ([], [b,x])
200 :     | I.FLOAD {b, ...} => ([], [b])
201 :     | I.FLOADX{b, x, ...} => ([], [b,x])
202 : monnier 498 | I.ANNOTATION{a, i, ...} => defUseR i
203 : monnier 245 | _ => ([],[])
204 :     end
205 :    
206 :     fun defUseF instr =
207 :     case instr
208 :     of I.FSTORE {r, ...} => ([], [r])
209 :     | I.FSTOREX{r, ...} => ([], [r])
210 :     | I.FLOAD{t, ...} => ([t], [])
211 :     | I.FLOADX{t, ...} => ([t], [])
212 :     | I.FARITH {r1, r2, t, ...} => ([t], [r1,r2])
213 :     | I.FUNARY {f, t, ...} => ([t], [f])
214 : monnier 411 | I.FCNV {f, t, ...} => ([t], [f])
215 : monnier 245 | I.FBRANCH{f1, f2,...} => ([], [f1, f2])
216 :     | I.BL{defs, uses, ...} => (#2 defs, #2 uses)
217 :     | I.BLE{defs, uses, ...} => (#2 defs, #2 uses)
218 :     | I.FCOPY{dst, src, tmp=SOME(I.FDirect f), ...} => (f::dst, src)
219 :     | I.FCOPY{dst, src, ...} => (dst, src)
220 : monnier 498 | I.ANNOTATION{a, i, ...} => defUseF i
221 : monnier 245 | _ => ([],[])
222 :    
223 :     fun defUse C.GP = defUseR
224 :     | defUse C.FP = defUseF
225 :     | defUse _ = error "defUse"
226 : monnier 411
227 :     (*========================================================================
228 :     * Annotations
229 :     *========================================================================*)
230 : monnier 469 fun getAnnotations(I.ANNOTATION{i,a}) =
231 :     let val (i,an) = getAnnotations i in (i,a::an) end
232 :     | getAnnotations i = (i,[])
233 : monnier 411 fun annotate(i,a) = I.ANNOTATION{i=i,a=a}
234 :    
235 :     (*========================================================================
236 :     * Groups
237 :     *========================================================================*)
238 :     fun getGroup(I.ANNOTATION{i,...}) = getGroup i
239 :     | getGroup(I.GROUP r) = r
240 :     | getGroup _ = error "getGroup"
241 :    
242 :     val makeGroup = I.GROUP
243 : monnier 245 end
244 :    
245 :    
246 :    

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