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/mltree/mltree-labexp.sml
ViewVC logotype

Annotation of /sml/trunk/src/MLRISC/mltree/mltree-labexp.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 775 - (view) (download)

1 : leunga 775 (* labelExp.sml -- expressions involving labels
2 :     *
3 :     * COPYRIGHT (c) 1995 AT&T Bell Laboratories.
4 :     *
5 :     *)
6 :    
7 :     functor LabelExp
8 :     (structure T : MLTREE
9 :     (* Hashing extensions *)
10 :     val hashSext : T.hasher -> T.sext -> word
11 :     val hashRext : T.hasher -> T.rext -> word
12 :     val hashFext : T.hasher -> T.fext -> word
13 :     val hashCCext : T.hasher -> T.ccext -> word
14 :     (* Equality extensions *)
15 :     val eqSext : T.equality -> T.sext * T.sext -> bool
16 :     val eqRext : T.equality -> T.rext * T.rext -> bool
17 :     val eqFext : T.equality -> T.fext * T.fext -> bool
18 :     val eqCCext : T.equality -> T.ccext * T.ccext -> bool
19 :     ) : LABELEXP =
20 :     struct
21 :    
22 :     structure T = T
23 :     structure I = T.I
24 :     structure Constant = T.Constant
25 :     structure B = T.Basis
26 :     structure C = CellsBasis
27 :     structure CI = CellsInternal
28 :     structure W = Word
29 :    
30 :     val w = W.fromInt
31 :     val i2s = Int.toString
32 :     val toLower = String.map Char.toLower
33 :    
34 :     fun error msg = MLRiscErrorMsg.error("LabelExp",msg)
35 :     fun wv(CI.CELL{id, ...}) = w id
36 :     fun wvs is =
37 :     let fun f([],h) = h
38 :     | f(i::is,h) = f(is,wv i+h)
39 :     in f(is,0w0) end
40 :    
41 :     (*
42 :     * Hashing
43 :     *)
44 :     fun hashLabel(Label.Label{id,...}) = w id
45 :     and hasher() = {stm=hashStm, rexp=hashRexp, fexp=hashFexp, ccexp=hashCCexp}
46 :     and hashCtrl ctrl = wv ctrl
47 :     and hashStm stm =
48 :     case stm of
49 :     T.MV(t,dst,rexp) => 0w123 + w t + wv dst + hashRexp rexp
50 :     | T.CCMV(dst,ccexp) => 0w1234 + wv dst + hashCCexp ccexp
51 :     | T.FMV(fty,dst,fexp) => 0w12345 + w fty + wv dst + hashFexp fexp
52 :     | T.COPY(ty,dst,src) => 0w234 + w ty + wvs dst + wvs src
53 :     | T.FCOPY(fty,dst,src) => 0w456 + w fty + wvs dst + wvs src
54 :     | T.JMP(ea,labels) => 0w45 + hashRexp ea
55 :     | T.CALL{funct,targets,defs,uses,region} =>
56 :     hashRexp funct + hashMlriscs defs + hashMlriscs uses
57 :     | T.RET _ => 0w567
58 :     | T.STORE(ty,ea,data,mem) => 0w888 + w ty + hashRexp ea + hashRexp data
59 :     | T.FSTORE(fty,ea,data,mem) => 0w7890 + w fty + hashRexp ea + hashFexp data
60 :     | T.BCC(a,lab) => 0w233 + hashCCexp a + hashLabel lab
61 :     | T.IF(a,b,c) => 0w233 + hashCCexp a + hashStm b + hashStm c
62 :     | T.ANNOTATION(stm, a) => hashStm stm
63 :     | T.PHI{preds,block} => w block
64 :     | T.SOURCE => 0w123
65 :     | T.SINK => 0w423
66 :     | T.REGION(stm,ctrl) => hashStm stm + hashCtrl ctrl
67 :     | T.RTL{hash,...} => hash
68 :     | T.SEQ ss => hashStms(ss, 0w23)
69 :     | T.ASSIGN(ty,lhs,rhs) => w ty + hashRexp lhs + hashRexp rhs
70 :     | _ => error "hashStm"
71 :    
72 :     and hashStms([],h) = h
73 :     | hashStms(s::ss,h) = hashStms(ss,hashStm s + h)
74 :    
75 :     and hashMlrisc(T.CCR ccexp) = hashCCexp ccexp
76 :     | hashMlrisc(T.GPR rexp) = hashRexp rexp
77 :     | hashMlrisc(T.FPR fexp) = hashFexp fexp
78 :    
79 :     and hashMlriscs [] = 0w123
80 :     | hashMlriscs(m::ms) = hashMlrisc m + hashMlriscs ms
81 :    
82 :     and hash2(ty,x,y) = w ty + hashRexp x + hashRexp y
83 :    
84 :     and hashRexp rexp =
85 :     case rexp of
86 :     T.REG(ty, src) => w ty + wv src
87 :     | T.LI i => I.hash i
88 :     | T.LABEL l => hashLabel l
89 :     | T.LABEXP le => hashRexp rexp
90 :     | T.CONST c => Constant.hash c
91 :     | T.NEG(ty, x) => w ty + hashRexp x + 0w24
92 :     | T.ADD x => hash2 x + 0w234
93 :     | T.SUB x => hash2 x + 0w456
94 :     | T.MULS x => hash2 x + 0w2131
95 :     | T.DIVS x => hash2 x + 0w156
96 :     | T.QUOTS x => hash2 x + 0w1565
97 :     | T.REMS x => hash2 x + 0w231
98 :     | T.MULU x => hash2 x + 0w123
99 :     | T.DIVU x => hash2 x + 0w1234
100 :     | T.REMU x => hash2 x + 0w211
101 :     | T.NEGT(ty, x) => w ty + hashRexp x + 0w1224
102 :     | T.ADDT x => hash2 x + 0w1219
103 :     | T.SUBT x => hash2 x + 0w999
104 :     | T.MULT x => hash2 x + 0w7887
105 :     | T.DIVT x => hash2 x + 0w88884
106 :     | T.QUOTT x => hash2 x + 0w8884
107 :     | T.REMT x => hash2 x + 0w99
108 :     | T.ANDB x => hash2 x + 0w12312
109 :     | T.ORB x => hash2 x + 0w558
110 :     | T.XORB x => hash2 x + 0w234
111 :     | T.EQVB x => hash2 x + 0w734
112 :     | T.NOTB(ty, x) => w ty + hashRexp x
113 :     | T.SRA x => hash2 x + 0w874
114 :     | T.SRL x => hash2 x + 0w223
115 :     | T.SLL x => hash2 x + 0w499
116 :     | T.COND(ty,e,e1,e2) => w ty + hashCCexp e + hashRexp e1 + hashRexp e2
117 :     | T.SX(ty, ty', rexp) => 0w232 + w ty + w ty' + hashRexp rexp
118 :     | T.ZX(ty, ty', rexp) => 0w737 + w ty + w ty' + hashRexp rexp
119 :     | T.CVTF2I(ty, round, ty', fexp) =>
120 :     w ty + B.hashRoundingMode round + w ty' + hashFexp fexp
121 :     | T.LOAD(ty, ea, mem) => w ty + hashRexp ea + 0w342
122 :     | T.LET(stm, rexp) => hashStm stm + hashRexp rexp
123 :     | T.PRED(e, ctrl) => hashRexp e + hashCtrl ctrl
124 :     | T.MARK(e, _) => hashRexp e
125 :     | T.REXT(ty, rext) => w ty + hashRext (hasher()) rext
126 :     | T.??? => 0w485
127 :     | T.OP(ty,oper,es) => hashRexps(es, w ty + hashOper oper)
128 :     | T.ARG _ => 0w23
129 :     | T.$(ty, k, e) => w ty + hashRexp e
130 :     | T.PARAM n => w n
131 :     | T.BITSLICE(ty, sl, e) => w ty + hashRexp e
132 :    
133 :     and hashOper(T.OPER{hash, ...}) = hash
134 :    
135 :     and hashRexps([],h) = h
136 :     | hashRexps(e::es,h) = hashRexps(es,hashRexp e + h)
137 :    
138 :     and hash2'(ty,x,y) = w ty + hashFexp x + hashFexp y
139 :    
140 :     and hashFexp fexp =
141 :     case fexp of
142 :     T.FREG(fty, src) => w fty + wv src
143 :     | T.FLOAD(fty, ea, mem) => w fty + hashRexp ea
144 :     | T.FADD x => hash2' x + 0w123
145 :     | T.FMUL x => hash2' x + 0w1234
146 :     | T.FSUB x => hash2' x + 0w12345
147 :     | T.FDIV x => hash2' x + 0w234
148 :     | T.FCOPYSIGN x => hash2' x + 0w883
149 :     | T.FCOND(fty,c,x,y) => w fty + hashCCexp c + hashFexp x + hashFexp y
150 :     | T.FABS(fty, fexp) => w fty + hashFexp fexp + 0w2345
151 :     | T.FNEG(fty, fexp) => w fty + hashFexp fexp + 0w23456
152 :     | T.FSQRT(fty, fexp) => w fty + hashFexp fexp + 0w345
153 :     | T.CVTI2F(fty, ty, rexp) => w fty + w ty + hashRexp rexp
154 :     | T.CVTF2F(fty, fty', fexp) => w fty + hashFexp fexp + w fty'
155 :     | T.FMARK(e, _) => hashFexp e
156 :     | T.FPRED(e, ctrl) => hashFexp e + hashCtrl ctrl
157 :     | T.FEXT(fty, fext) => w fty + hashFext (hasher()) fext
158 :    
159 :     and hashFexps([],h) = h
160 :     | hashFexps(e::es,h) = hashFexps(es,hashFexp e + h)
161 :    
162 :     and hashCCexp ccexp =
163 :     case ccexp of
164 :     T.CC(cc, src) => B.hashCond cc + wv src
165 :     | T.FCC(fcc, src) => B.hashFcond fcc + wv src
166 :     | T.CMP(ty, cond, x, y) =>
167 :     w ty + B.hashCond cond + hashRexp x + hashRexp y
168 :     | T.FCMP(fty, fcond, x, y) =>
169 :     w fty + B.hashFcond fcond + hashFexp x + hashFexp y
170 :     | T.NOT x => 0w2321 + hashCCexp x
171 :     | T.AND(x,y) => 0w2321 + hashCCexp x + hashCCexp y
172 :     | T.OR(x,y) => 0w8721 + hashCCexp x + hashCCexp y
173 :     | T.XOR(x,y) => 0w6178 + hashCCexp x + hashCCexp y
174 :     | T.EQV(x,y) => 0w178 + hashCCexp x + hashCCexp y
175 :     | T.TRUE => 0w0
176 :     | T.FALSE => 0w1232
177 :     | T.CCMARK(e, _) => hashCCexp e
178 :     | T.CCEXT(ty,ccext) => w ty + hashCCext (hasher()) ccext
179 :    
180 :     and hashCCexps([],h) = h
181 :     | hashCCexps(e::es,h) = hashCCexps(es,hashCCexp e + h)
182 :    
183 :     fun eqLabel(Label.Label{id=x,...},Label.Label{id=y,...}) = x=y
184 :     and eqLabels([],[]) = true
185 :     | eqLabels(a::b,c::d) = eqLabel(a,c) andalso eqLabels(b,d)
186 :     | eqLabels _ = false
187 :     and eqCell(CI.CELL{id=x, ...},CI.CELL{id=y, ...}) = x=y
188 :     and eqCells([], []) = true
189 :     | eqCells(x::xs,y::ys) = eqCell(x,y) andalso eqCells(xs,ys)
190 :     | eqCells _ = false
191 :     and eqCopy((t1,dst1,src1),(t2,dst2,src2)) =
192 :     t1=t2 andalso eqCells(dst1,dst2) andalso eqCells(src1,src2)
193 :     and eqCtrl(c1,c2) = eqCell(c1,c2)
194 :     and eqCtrls(c1,c2) = eqCells(c1,c2)
195 :    
196 :     (* statements *)
197 :     and equality() = {stm=eqStm, rexp=eqRexp, fexp=eqFexp, ccexp=eqCCexp}
198 :     and eqStm(T.MV(a,b,c),T.MV(d,e,f)) =
199 :     a=d andalso eqCell(b,e) andalso eqRexp(c,f)
200 :     | eqStm(T.CCMV(a,b),T.CCMV(c,d)) = eqCell(a,c) andalso eqCCexp(b,d)
201 :     | eqStm(T.FMV(a,b,c),T.FMV(d,e,f)) =
202 :     a=d andalso eqCell(b,e) andalso eqFexp(c,f)
203 :     | eqStm(T.COPY x,T.COPY y) = eqCopy(x,y)
204 :     | eqStm(T.FCOPY x,T.FCOPY y) = eqCopy(x,y)
205 :     | eqStm(T.JMP(a,b),T.JMP(a',b')) = eqRexp(a,a')
206 :     | eqStm(T.CALL{funct=a,defs=b,uses=c,...},
207 :     T.CALL{funct=d,defs=e,uses=f,...}) =
208 :     eqRexp(a,d) andalso eqMlriscs(b,e) andalso eqMlriscs(c,f)
209 :     | eqStm(T.RET _,T.RET _) = true
210 :     | eqStm(T.STORE(a,b,c,_),T.STORE(d,e,f,_)) =
211 :     a=d andalso eqRexp(b,e) andalso eqRexp(c,f)
212 :     | eqStm(T.FSTORE(a,b,c,_),T.FSTORE(d,e,f,_)) =
213 :     a=d andalso eqRexp(b,e) andalso eqFexp(c,f)
214 :     | eqStm(T.ANNOTATION(s1, _),s2) = eqStm(s1,s2)
215 :     | eqStm(s1,T.ANNOTATION(s2, _)) = eqStm(s1,s2)
216 :     | eqStm(T.PHI x,T.PHI y) = x=y
217 :     | eqStm(T.SOURCE,T.SOURCE) = true
218 :     | eqStm(T.SINK,T.SINK) = true
219 :     | eqStm(T.BCC(b,c),T.BCC(b',c')) =
220 :     eqCCexp(b,b') andalso eqLabel(c,c')
221 :     | eqStm(T.IF(b,c,d),T.IF(b',c',d')) =
222 :     eqCCexp(b,b') andalso eqStm(c,c') andalso eqStm(d,d')
223 :     | eqStm(T.RTL{attribs=x,...},T.RTL{attribs=y,...}) = x=y
224 :     | eqStm(T.REGION(a,b),T.REGION(a',b')) = eqCtrl(b,b') andalso eqStm(a,a')
225 :     | eqStm(T.EXT a,T.EXT a') = eqSext (equality()) (a,a')
226 :     | eqStm _ = false
227 :    
228 :     and eqStms([],[]) = true
229 :     | eqStms(a::b,c::d) = eqStm(a,c) andalso eqStms(b,d)
230 :     | eqStms _ = false
231 :    
232 :     and eqMlrisc(T.CCR a,T.CCR b) = eqCCexp(a,b)
233 :     | eqMlrisc(T.GPR a,T.GPR b) = eqRexp(a,b)
234 :     | eqMlrisc(T.FPR a,T.FPR b) = eqFexp(a,b)
235 :     | eqMlrisc _ = false
236 :    
237 :     and eqMlriscs([],[]) = true
238 :     | eqMlriscs(a::b,c::d) = eqMlrisc(a,c) andalso eqMlriscs(b,d)
239 :     | eqMlriscs _ = false
240 :    
241 :     and eq2((a,b,c),(d,e,f)) = a=d andalso eqRexp(b,e) andalso eqRexp(c,f)
242 :    
243 :     and eqRexp(T.REG(a,b),T.REG(c,d)) = a=c andalso eqCell(b,d)
244 :     | eqRexp(T.LI a,T.LI b) = a=b
245 :     | eqRexp(T.LABEL a,T.LABEL b) = eqLabel(a,b)
246 :     | eqRexp(T.LABEXP a,T.LABEXP b) = eqRexp(a,b)
247 :     | eqRexp(T.CONST a,T.CONST b) = Constant.==(a,b)
248 :     | eqRexp(T.NEG(t,x),T.NEG(t',x')) = t = t' andalso eqRexp(x,x')
249 :     | eqRexp(T.ADD x,T.ADD y) = eq2(x,y)
250 :     | eqRexp(T.SUB x,T.SUB y) = eq2(x,y)
251 :     | eqRexp(T.MULS x,T.MULS y) = eq2(x,y)
252 :     | eqRexp(T.DIVS x,T.DIVS y) = eq2(x,y)
253 :     | eqRexp(T.QUOTS x,T.QUOTS y) = eq2(x,y)
254 :     | eqRexp(T.REMS x,T.REMS y) = eq2(x,y)
255 :     | eqRexp(T.MULU x,T.MULU y) = eq2(x,y)
256 :     | eqRexp(T.DIVU x,T.DIVU y) = eq2(x,y)
257 :     | eqRexp(T.REMU x,T.REMU y) = eq2(x,y)
258 :     | eqRexp(T.NEGT(t,x),T.NEGT(t',x')) = t = t' andalso eqRexp(x,x')
259 :     | eqRexp(T.ADDT x,T.ADDT y) = eq2(x,y)
260 :     | eqRexp(T.SUBT x,T.SUBT y) = eq2(x,y)
261 :     | eqRexp(T.MULT x,T.MULT y) = eq2(x,y)
262 :     | eqRexp(T.DIVT x,T.DIVT y) = eq2(x,y)
263 :     | eqRexp(T.QUOTT x,T.QUOTT y) = eq2(x,y)
264 :     | eqRexp(T.REMT x,T.REMT y) = eq2(x,y)
265 :     | eqRexp(T.ANDB x,T.ANDB y) = eq2(x,y)
266 :     | eqRexp(T.ORB x,T.ORB y) = eq2(x,y)
267 :     | eqRexp(T.XORB x,T.XORB y) = eq2(x,y)
268 :     | eqRexp(T.EQVB x,T.EQVB y) = eq2(x,y)
269 :     | eqRexp(T.NOTB(a,b),T.NOTB(c,d)) = a=c andalso eqRexp(b,d)
270 :     | eqRexp(T.SRA x,T.SRA y) = eq2(x,y)
271 :     | eqRexp(T.SRL x,T.SRL y) = eq2(x,y)
272 :     | eqRexp(T.SLL x,T.SLL y) = eq2(x,y)
273 :     | eqRexp(T.COND(a,b,c,d),T.COND(e,f,g,h)) =
274 :     a=e andalso eqCCexp(b,f) andalso eqRexp(c,g) andalso eqRexp(d,h)
275 :     | eqRexp(T.SX(a,b,c),T.SX(a',b',c')) =
276 :     a=a' andalso b=b' andalso eqRexp(c,c')
277 :     | eqRexp(T.ZX(a,b,c),T.ZX(a',b',c')) =
278 :     a=a' andalso b=b' andalso eqRexp(c,c')
279 :     | eqRexp(T.CVTF2I(a,b,c,d),T.CVTF2I(e,f,g,h)) =
280 :     a=e andalso b=f andalso c=g andalso eqFexp(d,h)
281 :     | eqRexp(T.LOAD(a,b,_),T.LOAD(c,d,_)) = a=c andalso eqRexp(b,d)
282 :     | eqRexp(T.LET(a,b),T.LET(c,d)) = eqStm(a,c) andalso eqRexp(b,d)
283 :     | eqRexp(T.ARG x,T.ARG y) = x = y
284 :     | eqRexp(T.PARAM x,T.PARAM y) = x = y
285 :     | eqRexp(T.???,T.???) = true
286 :     | eqRexp(T.$(t1,k1,e1),T.$(t2,k2,e2)) =
287 :     t1=t2 andalso k1=k2 andalso eqRexp(e1,e2)
288 :     | eqRexp(T.BITSLICE(t1,s1,e1),T.BITSLICE(t2,s2,e2)) =
289 :     t1=t2 andalso s1=s2 andalso eqRexp(e1,e2)
290 :     | eqRexp(T.MARK(a,_),b) = eqRexp(a,b)
291 :     | eqRexp(a,T.MARK(b,_)) = eqRexp(a,b)
292 :     | eqRexp(T.PRED(a,b),T.PRED(a',b')) = eqCtrl(b,b') andalso eqRexp(a,a')
293 :     | eqRexp(T.REXT(a,b),T.REXT(a',b')) =
294 :     a=a' andalso eqRext (equality()) (b,b')
295 :     | eqRexp _ = false
296 :    
297 :     and eqRexps([],[]) = true
298 :     | eqRexps(a::b,c::d) = eqRexp(a,c) andalso eqRexps(b,d)
299 :     | eqRexps _ = false
300 :    
301 :     and eq2'((a,b,c),(d,e,f)) = a=d andalso eqFexp(b,e) andalso eqFexp(c,f)
302 :     and eq1'((a,b),(d,e)) = a=d andalso eqFexp(b,e)
303 :    
304 :     and eqFexp(T.FREG(t1,x),T.FREG(t2,y)) = t1=t2 andalso eqCell(x,y)
305 :     | eqFexp(T.FLOAD(a,b,_),T.FLOAD(c,d,_)) = a=c andalso eqRexp(b,d)
306 :     | eqFexp(T.FADD x,T.FADD y) = eq2'(x,y)
307 :     | eqFexp(T.FMUL x,T.FMUL y) = eq2'(x,y)
308 :     | eqFexp(T.FSUB x,T.FSUB y) = eq2'(x,y)
309 :     | eqFexp(T.FDIV x,T.FDIV y) = eq2'(x,y)
310 :     | eqFexp(T.FCOPYSIGN x, T.FCOPYSIGN y) = eq2'(x,y)
311 :     | eqFexp(T.FCOND(t,x,y,z), T.FCOND(t',x',y',z')) =
312 :     t=t' andalso eqCCexp(x,x') andalso eqFexp(y,y') andalso eqFexp(z,z')
313 :     | eqFexp(T.FABS x,T.FABS y) = eq1'(x,y)
314 :     | eqFexp(T.FNEG x,T.FNEG y) = eq1'(x,y)
315 :     | eqFexp(T.FSQRT x,T.FSQRT y) = eq1'(x,y)
316 :     | eqFexp(T.CVTI2F(a,b,c),T.CVTI2F(a',b',c')) =
317 :     a=a' andalso b=b' andalso eqRexp(c,c')
318 :     | eqFexp(T.CVTF2F(a,b,c),T.CVTF2F(a',b',c')) =
319 :     a=a' andalso b=b' andalso eqFexp(c,c')
320 :     | eqFexp(T.FEXT(a,f),T.FEXT(b,g)) = a=b andalso eqFext (equality()) (f,g)
321 :     | eqFexp(T.FMARK(a,_),b) = eqFexp(a,b)
322 :     | eqFexp(a,T.FMARK(b,_)) = eqFexp(a,b)
323 :     | eqFexp(T.FPRED(a,b),T.FPRED(a',b')) = eqCtrl(b,b') andalso eqFexp(a,a')
324 :     | eqFexp _ = false
325 :    
326 :     and eqFexps([],[]) = true
327 :     | eqFexps(a::b,c::d) = eqFexp(a,c) andalso eqFexps(b,d)
328 :     | eqFexps _ = false
329 :    
330 :     and eqCCexp(T.CC(c1,x),T.CC(c2,y)) = c1=c2 andalso eqCell(x,y)
331 :     | eqCCexp(T.FCC(c1,x),T.FCC(c2,y)) = c1=c2 andalso eqCell(x,y)
332 :     | eqCCexp(T.CMP(x,a,b,c),T.CMP(y,d,e,f)) =
333 :     a=d andalso eqRexp(b,e) andalso eqRexp(c,f) andalso x = y
334 :     | eqCCexp(T.FCMP(x,a,b,c),T.FCMP(y,d,e,f)) =
335 :     a=d andalso eqFexp(b,e) andalso eqFexp(c,f) andalso x = y
336 :     | eqCCexp(T.NOT x, T.NOT y) = eqCCexp(x,y)
337 :     | eqCCexp(T.AND x, T.AND y) = eqCCexp2(x,y)
338 :     | eqCCexp(T.OR x, T.OR y) = eqCCexp2(x,y)
339 :     | eqCCexp(T.XOR x, T.XOR y) = eqCCexp2(x,y)
340 :     | eqCCexp(T.EQV x, T.EQV y) = eqCCexp2(x,y)
341 :     | eqCCexp(T.CCMARK(a,_),b) = eqCCexp(a,b)
342 :     | eqCCexp(a,T.CCMARK(b,_)) = eqCCexp(a,b)
343 :     | eqCCexp(T.CCEXT(t,a),T.CCEXT(t',b)) =
344 :     t=t' andalso eqCCext (equality()) (a,b)
345 :     | eqCCexp(T.TRUE, T.TRUE) = true
346 :     | eqCCexp(T.FALSE, T.FALSE) = true
347 :     | eqCCexp _ = false
348 :    
349 :     and eqCCexp2((x,y),(x',y')) = eqCCexp(x,x') andalso eqCCexp(y,y')
350 :    
351 :     and eqCCexps([],[]) = true
352 :     | eqCCexps(a::b,c::d) = eqCCexp(a,c) andalso eqCCexps(b,d)
353 :     | eqCCexps _ = false
354 :    
355 :     exception NonConst
356 :    
357 :     fun eval{label, const} =
358 :     let fun rexp(T.LI i) = i
359 :     | rexp(T.CONST c) = const c
360 :     | rexp(T.LABEL l) = IntInf.fromInt(label l)
361 :     | rexp(T.LABEXP e) = rexp e
362 :    
363 :     | rexp(T.NEG(sz,x)) = I.NEG(sz,rexp x)
364 :     | rexp(T.ADD(sz,x,y)) = I.ADD(sz,rexp x,rexp y)
365 :     | rexp(T.SUB(sz,x,y)) = I.SUB(sz,rexp x,rexp y)
366 :    
367 :     | rexp(T.MULS(sz,x,y)) = I.MULS(sz,rexp x,rexp y)
368 :     | rexp(T.DIVS(sz,x,y)) = I.DIVS(sz,rexp x,rexp y)
369 :     | rexp(T.QUOTS(sz,x,y)) = I.QUOTS(sz,rexp x,rexp y)
370 :     | rexp(T.REMS(sz,x,y)) = I.REMS(sz,rexp x,rexp y)
371 :    
372 :     | rexp(T.MULU(sz,x,y)) = I.MULU(sz,rexp x,rexp y)
373 :     | rexp(T.DIVU(sz,x,y)) = I.DIVU(sz,rexp x,rexp y)
374 :     | rexp(T.REMU(sz,x,y)) = I.REMU(sz,rexp x,rexp y)
375 :    
376 :     | rexp(T.NEGT(sz,x)) = I.NEGT(sz,rexp x)
377 :     | rexp(T.ADDT(sz,x,y)) = I.ADDT(sz,rexp x,rexp y)
378 :     | rexp(T.SUBT(sz,x,y)) = I.SUBT(sz,rexp x,rexp y)
379 :     | rexp(T.MULT(sz,x,y)) = I.MULT(sz,rexp x,rexp y)
380 :     | rexp(T.DIVT(sz,x,y)) = I.DIVT(sz,rexp x,rexp y)
381 :     | rexp(T.QUOTT(sz,x,y)) = I.QUOTT(sz,rexp x,rexp y)
382 :     | rexp(T.REMT(sz,x,y)) = I.REMT(sz,rexp x,rexp y)
383 :    
384 :     | rexp(T.NOTB(sz,x)) = I.NOTB(sz,rexp x)
385 :     | rexp(T.ANDB(sz,x,y)) = I.ANDB(sz,rexp x,rexp y)
386 :     | rexp(T.ORB(sz,x,y)) = I.ORB(sz,rexp x,rexp y)
387 :     | rexp(T.XORB(sz,x,y)) = I.XORB(sz,rexp x,rexp y)
388 :     | rexp(T.EQVB(sz,x,y)) = I.EQVB(sz,rexp x,rexp y)
389 :     | rexp(T.SLL(sz,x,y)) = I.SLL(sz,rexp x,rexp y)
390 :     | rexp(T.SRL(sz,x,y)) = I.SRL(sz,rexp x,rexp y)
391 :     | rexp(T.SRA(sz,x,y)) = I.SRA(sz,rexp x,rexp y)
392 :     | rexp(T.BITSLICE(sz,x,y)) = I.BITSLICE(sz,x,rexp y)
393 :    
394 :     | rexp(T.COND(sz,cc,x,y)) = if ccexp cc then rexp x else rexp y
395 :     | rexp(T.SX(a,b,x)) = I.SX(a,b,rexp x)
396 :     | rexp(T.ZX(a,b,x)) = I.ZX(a,b,rexp x)
397 :     | rexp(T.MARK(e,_)) = rexp e
398 :    
399 :     | rexp _ = raise NonConst
400 :     and ccexp(T.TRUE) = true
401 :     | ccexp(T.FALSE) = false
402 :     | ccexp(T.CMP(sz,T.EQ,x,y)) = I.EQ(sz,rexp x,rexp y)
403 :     | ccexp(T.CMP(sz,T.NE,x,y)) = I.NE(sz,rexp x,rexp y)
404 :     | ccexp(T.CMP(sz,T.GT,x,y)) = I.GT(sz,rexp x,rexp y)
405 :     | ccexp(T.CMP(sz,T.GE,x,y)) = I.GE(sz,rexp x,rexp y)
406 :     | ccexp(T.CMP(sz,T.LT,x,y)) = I.LT(sz,rexp x,rexp y)
407 :     | ccexp(T.CMP(sz,T.LE,x,y)) = I.LE(sz,rexp x,rexp y)
408 :     | ccexp(T.CMP(sz,T.GTU,x,y)) = I.GTU(sz,rexp x,rexp y)
409 :     | ccexp(T.CMP(sz,T.LTU,x,y)) = I.LTU(sz,rexp x,rexp y)
410 :     | ccexp(T.CMP(sz,T.GEU,x,y)) = I.GEU(sz,rexp x,rexp y)
411 :     | ccexp(T.CMP(sz,T.LEU,x,y)) = I.LEU(sz,rexp x,rexp y)
412 :     | ccexp(T.NOT x) = not(ccexp x)
413 :     | ccexp(T.AND(x,y)) = ccexp x andalso ccexp y
414 :     | ccexp(T.OR(x,y)) = ccexp x orelse ccexp y
415 :     | ccexp(T.XOR(x,y)) = ccexp x <> ccexp y
416 :     | ccexp(T.EQV(x,y)) = ccexp x = ccexp y
417 :     | ccexp(T.CCMARK(e,_)) = ccexp e
418 :     | ccexp _ = raise NonConst
419 :     in {rexp=rexp, ccexp=ccexp}
420 :     end
421 :    
422 :     fun valueOf e =
423 :     IntInf.toInt
424 :     (#rexp(eval{const=fn c => IntInf.fromInt(Constant.valueOf c),
425 :     label=Label.addrOf}) e)
426 :     val == = eqRexp
427 :     val hash = hashRexp
428 :    
429 :     val resolveConstants = MLRiscControl.getFlag "asm-resolve-constants"
430 :     val _ = resolveConstants := true
431 :    
432 :     (* This module should be parameterised, in order to generate
433 :     * target label expressions for assembly code purposes.
434 :     *)
435 :     (* operator precedences:
436 :     (Note: these differ from C's precedences)
437 :     2 MULT, DIV, LSHIFT, RSHIFT
438 :     1 AND, OR
439 :     0 PLUS, MINUS
440 :     *)
441 :    
442 :     fun parens (str, prec, op_prec) =
443 :     if prec > op_prec then "(" ^ str ^ ")" else str
444 :    
445 :     fun prInt i = if i < 0 then "-"^Int.toString(~i) else Int.toString i
446 :     fun prIntInf i = if IntInf.sign i < 0 then "-"^IntInf.toString(IntInf.~ i)
447 :     else IntInf.toString i
448 :    
449 :     fun toString le = toStr(le, 0)
450 :    
451 :     and toStr(T.LABEL lab, _) = Label.nameOf lab
452 :     | toStr(T.LABEXP le, p) = toStr(le, p)
453 :     | toStr(T.CONST c, _) =
454 :     if !resolveConstants then prInt(Constant.valueOf c)
455 :     else Constant.toString c
456 :     | toStr(T.LI i, _) = prIntInf i
457 :     | toStr(T.MULS(_,lexp1, lexp2), _) = toStr(lexp1, 2) ^ "*" ^ toStr(lexp2,2)
458 :     | toStr(T.DIVS(_,lexp1, lexp2), _) = toStr(lexp1, 2) ^ "/" ^ toStr(lexp2,2)
459 :     | toStr(T.SLL(_,lexp, cnt), prec) = toStr(lexp,2) ^ "<<" ^ toStr(cnt,2)
460 :     | toStr(T.SRL(_,lexp, cnt), prec) = toStr(lexp,2) ^ ">>" ^ toStr(cnt,2)
461 :     | toStr(T.ANDB(_,lexp, mask), prec) =
462 :     parens(toStr(lexp,1) ^ "&" ^ toStr(mask, 1), prec, 1)
463 :     | toStr(T.ORB(_,lexp, mask), prec) =
464 :     parens(toStr(lexp, 1) ^ "|" ^ toStr(mask, 1), prec, 1)
465 :     | toStr(T.ADD(_,lexp1, lexp2), prec) =
466 :     parens(toStr(lexp1, 0) ^ "+" ^ toStr(lexp2, 0), prec, 0)
467 :     | toStr(T.SUB(_,lexp1, lexp2), prec) =
468 :     parens(toStr(lexp1, 0) ^ "-" ^ toStr(lexp2, 0), prec, 0)
469 :     | toStr _ = error "toStr"
470 :    
471 :     end

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