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

Annotation of /sml/branches/SMLNJ/src/MLRISC/mltree/mltree-utils.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 473 - (view) (download)
Original Path: sml/trunk/src/MLRISC/mltree/mltree-utils.sml

1 : monnier 473 (*
2 :     * Common operations on MLTREE
3 :     *
4 :     * -- Allen
5 :     *)
6 :     functor MLTreeUtilsFn
7 :     (structure T : MLTREE
8 :     val hashRext : T.rextension -> word
9 :     val hashFext : T.fextension -> word
10 :     val eqRext : T.rextension * T.rextension -> bool
11 :     val eqFext : T.fextension * T.fextension -> bool
12 :     val rextToString : T.rextension -> string
13 :     val fextToString : T.fextension -> string
14 :     ) : MLTREE_UTILS =
15 :     struct
16 :    
17 :     structure T = T
18 :     structure U = T.Util
19 :     structure Constant = T.Constant
20 :     structure Region = T.Region
21 :     structure W = Word
22 :    
23 :     val w = W.fromInt
24 :    
25 :     fun error msg = MLRiscErrorMsg.error("MLTreeUtils",msg)
26 :     fun ws is =
27 :     let fun f([],h) = h
28 :     | f(i::is,h) = f(is,w i+h)
29 :     in f(is,0w0) end
30 :    
31 :     (*
32 :     * Hashing
33 :     *)
34 :     fun hashStm stm =
35 :     case stm of
36 :     T.MV(t,dst,rexp) => 0w123 + w t + w dst + hashRexp rexp
37 :     | T.CCMV(dst,ccexp) => 0w1234 + w dst + hashCCexp ccexp
38 :     | T.FMV(fty,dst,fexp) => 0w12345 + w fty + w dst + hashFexp fexp
39 :     | T.COPY(ty,dst,src) => 0w234 + w ty + ws dst + ws src
40 :     | T.FCOPY(fty,dst,src) => 0w456 + w fty + ws dst + ws src
41 :     | T.JMP(ea,labels) => 0w45 + hashRexp ea
42 :     | T.CALL(ea,defs,uses,mem) =>
43 :     hashRexp ea + hashMlriscs defs + hashMlriscs uses
44 :     | T.RET => 0w567
45 :     | T.STORE(ty,ea,data,mem) =>
46 :     0w888 + w ty + hashRexp ea + hashRexp data
47 :     | T.STORE_UNALIGNED(ty,ea,data,mem) =>
48 :     0w999 + w ty + hashRexp ea + hashRexp data
49 :     | T.FSTORE(fty,ea,data,mem) =>
50 :     0w7890 + w fty + hashRexp ea + hashFexp data
51 :     | T.FSTORE_UNALIGNED(fty,ea,data,mem) =>
52 :     0w8901 + w fty + hashRexp ea + hashFexp data
53 :     | T.BCC(cond,ccexp,lab) => U.hashCond cond + hashCCexp ccexp
54 :     | T.FBCC(fcond,ccexp,lab) => U.hashFcond fcond + hashCCexp ccexp
55 :     | T.ANNOTATION(stm, a) => hashStm stm
56 :     | T.RTL(ref h,_,_) => h
57 :     | T.RTLPHI block => w block
58 :     | T.RTLPINNED stm => 0w12312 + hashStm stm
59 :     | T.RTLPAR stms => foldr (fn (s,h) => hashStm s + h) 0w0 stms
60 :    
61 :     and hashMlrisc(T.CCR ccexp) = hashCCexp ccexp
62 :     | hashMlrisc(T.GPR rexp) = hashRexp rexp
63 :     | hashMlrisc(T.FPR fexp) = hashFexp fexp
64 :    
65 :     and hashMlriscs [] = 0w123
66 :     | hashMlriscs(m::ms) = hashMlrisc m + hashMlriscs ms
67 :    
68 :     and hash2(ty,x,y) = w ty + hashRexp x + hashRexp y
69 :    
70 :     and hashRexp rexp =
71 :     case rexp of
72 :     T.REG(ty, src) => w ty + w src
73 :     | T.LI i => w i
74 :     | T.LI32 w => W.fromLargeWord w
75 :     | T.LI64 w => W.fromLargeWord(Word64.toLargeWord w)
76 :     | T.LABEL le => LabelExp.hash le
77 :     | T.CONST c => Constant.hash c
78 :     | T.ADD x => hash2 x + 0w234
79 :     | T.SUB x => hash2 x + 0w456
80 :     | T.MULS x => hash2 x + 0w2131
81 :     | T.DIVS x => hash2 x + 0w156
82 :     | T.REMS x => hash2 x + 0w231
83 :     | T.MULU x => hash2 x + 0w123
84 :     | T.DIVU x => hash2 x + 0w1234
85 :     | T.REMU x => hash2 x + 0w211
86 :     | T.ADDT x => hash2 x + 0w1219
87 :     | T.SUBT x => hash2 x + 0w999
88 :     | T.MULT x => hash2 x + 0w7887
89 :     | T.DIVT x => hash2 x + 0w88884
90 :     | T.REMT x => hash2 x + 0w99
91 :     | T.ANDB x => hash2 x + 0w12312
92 :     | T.ORB x => hash2 x + 0w558
93 :     | T.XORB x => hash2 x + 0w234
94 :     | T.NOTB(ty, x) => w ty + hashRexp x
95 :     | T.SRA x => hash2 x + 0w874
96 :     | T.SRL x => hash2 x + 0w223
97 :     | T.SLL x => hash2 x + 0w499
98 :     | T.COND(ty,e,e1,e2) => w ty + hashCCexp e + hashRexp e1 + hashRexp e2
99 :     | T.CVTI2I(ty, ext, ty', rexp) =>
100 :     w ty + U.hashExt ext + w ty' + hashRexp rexp
101 :     | T.CVTF2I(ty, round, ty', fexp) =>
102 :     w ty + U.hashRoundingMode round + w ty' + hashFexp fexp
103 :     | T.LOAD(ty, ea, mem) => w ty + hashRexp ea + 0w342
104 :     | T.LOAD_UNALIGNED(ty, ea, mem) => w ty + hashRexp ea + 0w3811
105 :     | T.SEQ(stm, rexp) => hashStm stm + hashRexp rexp
106 :     | T.MARK(e, _) => hashRexp e
107 :     | T.EXT(ty, rextension, args) =>
108 :     w ty + hashRexps(args,hashRext rextension)
109 :     | T.RTLPC => 0w7
110 :     | T.RTLMISC(ref{hash,...},args) => hashRexps(args,hash)
111 :    
112 :     and hashRexps([],h) = h
113 :     | hashRexps(e::es,h) = hashRexps(es,hashRexp e + h)
114 :    
115 :     and hash2'(ty,x,y) = w ty + hashFexp x + hashFexp y
116 :    
117 :     and hashFexp fexp =
118 :     case fexp of
119 :     T.FREG(fty, src) => w fty + w src
120 :     | T.FLOAD(fty, ea, mem) => w fty + hashRexp ea
121 :     | T.FLOAD_UNALIGNED(fty, ea, mem) => w fty + hashRexp ea
122 :     | T.FADD x => hash2' x + 0w123
123 :     | T.FMUL x => hash2' x + 0w1234
124 :     | T.FSUB x => hash2' x + 0w12345
125 :     | T.FDIV x => hash2' x + 0w234
126 :     | T.FABS(fty, fexp) => w fty + hashFexp fexp + 0w2345
127 :     | T.FNEG(fty, fexp) => w fty + hashFexp fexp + 0w23456
128 :     | T.FSQRT(fty, fexp) => w fty + hashFexp fexp + 0w345
129 :     | T.CVTI2F(fty, ext, ty, rexp) =>
130 :     w fty + U.hashExt ext + w ty + hashRexp rexp
131 :     | T.CVTF2F(fty, r, fty', fexp) =>
132 :     w fty + hashFexp fexp + w fty' + U.hashRoundingMode r
133 :     | T.FSEQ(stm, fexp) => hashStm stm + hashFexp fexp
134 :     | T.FMARK(e, _) => hashFexp e
135 :     | T.FEXT(fty, fextension, args) =>
136 :     w fty + hashFexps(args,hashFext fextension)
137 :     | T.RTLFMISC(ref{hash,...},args) => hashFexps(args,hash)
138 :    
139 :     and hashFexps([],h) = h
140 :     | hashFexps(e::es,h) = hashFexps(es,hashFexp e + h)
141 :    
142 :     and hashCCexp ccexp =
143 :     case ccexp of
144 :     T.CC src => w src
145 :     | T.CMP(ty, cond, x, y) =>
146 :     w ty + U.hashCond cond + hashRexp x + hashRexp y
147 :     | T.FCMP(fty, fcond, x, y) =>
148 :     w fty + U.hashFcond fcond + hashFexp x + hashFexp y
149 :     | T.RTLCCMISC(ref{hash,...},args) => hashCCexps(args,hash)
150 :     | T.CCMARK(e, _) => hashCCexp e
151 :    
152 :     and hashCCexps([],h) = h
153 :     | hashCCexps(e::es,h) = hashCCexps(es,hashCCexp e + h)
154 :    
155 :     (*
156 :     * Equality
157 :     *)
158 :    
159 :     fun equalLabel(Label.Label{id=x,...},Label.Label{id=y,...}) = x=y
160 :     fun equalLabels([],[]) = true
161 :     | equalLabels(a::b,c::d) = equalLabel(a,c) andalso equalLabels(b,d)
162 :     | equalLabels _ = false
163 :    
164 :     (* statements *)
165 :     fun eqStm(T.MV(a,b,c),T.MV(d,e,f)) = b=e andalso a=d andalso eqRexp(c,f)
166 :     | eqStm(T.CCMV(a,b),T.CCMV(c,d)) = a=c andalso eqCCexp(b,d)
167 :     | eqStm(T.FMV(a,b,c),T.FMV(d,e,f)) = b=e andalso a=d andalso eqFexp(c,f)
168 :     | eqStm(T.COPY x,T.COPY y) = x = y
169 :     | eqStm(T.FCOPY x,T.FCOPY y) = x = y
170 :     | eqStm(T.JMP(a,b),T.JMP(c,d)) = eqRexp(a,c) andalso equalLabels(b,d)
171 :     | eqStm(T.CALL(a,b,c,_),T.CALL(d,e,f,_)) =
172 :     eqRexp(a,d) andalso eqMlriscs(b,e) andalso eqMlriscs(c,f)
173 :     | eqStm(T.RET,T.RET) = true
174 :     | eqStm(T.STORE(a,b,c,_),T.STORE(d,e,f,_)) =
175 :     a=d andalso eqRexp(b,e) andalso eqRexp(c,f)
176 :     | eqStm(T.STORE_UNALIGNED(a,b,c,_),T.STORE_UNALIGNED(d,e,f,_)) =
177 :     a=d andalso eqRexp(b,e) andalso eqRexp(c,f)
178 :     | eqStm(T.FSTORE(a,b,c,_),T.FSTORE(d,e,f,_)) =
179 :     a=d andalso eqRexp(b,e) andalso eqFexp(c,f)
180 :     | eqStm(T.FSTORE_UNALIGNED(a,b,c,_),T.FSTORE_UNALIGNED(d,e,f,_)) =
181 :     a=d andalso eqRexp(b,e) andalso eqFexp(c,f)
182 :     | eqStm(T.BCC(a,b,c),T.BCC(d,e,f)) =
183 :     a=d andalso eqCCexp(b,e) andalso equalLabel(c,f)
184 :     | eqStm(T.FBCC(a,b,c),T.FBCC(d,e,f)) =
185 :     a=d andalso eqCCexp(b,e) andalso equalLabel(c,f)
186 :     | eqStm(T.ANNOTATION(s1, _),s2) = eqStm(s1,s2)
187 :     | eqStm(s1,T.ANNOTATION(s2, _)) = eqStm(s1,s2)
188 :     | eqStm(T.RTL(r,_,_),T.RTL(s,_,_)) = r=s
189 :     | eqStm(T.RTLPHI x,T.RTLPHI y) = x=y
190 :     | eqStm(T.RTLPINNED x,T.RTLPINNED y) = eqStm(x,y)
191 :     | eqStm(T.RTLPAR x,T.RTLPAR y) = eqStms(x,y)
192 :     | eqStm _ = false
193 :    
194 :     and eqStms([],[]) = true
195 :     | eqStms(a::b,c::d) = eqStm(a,c) andalso eqStms(b,d)
196 :     | eqStms _ = false
197 :    
198 :     and eqMlrisc(T.CCR a,T.CCR b) = eqCCexp(a,b)
199 :     | eqMlrisc(T.GPR a,T.GPR b) = eqRexp(a,b)
200 :     | eqMlrisc(T.FPR a,T.FPR b) = eqFexp(a,b)
201 :     | eqMlrisc _ = false
202 :    
203 :     and eqMlriscs([],[]) = true
204 :     | eqMlriscs(a::b,c::d) = eqMlrisc(a,c) andalso eqMlriscs(b,d)
205 :     | eqMlriscs _ = false
206 :    
207 :     and eq2((a,b,c),(d,e,f)) = a=d andalso eqRexp(b,e) andalso eqRexp(c,f)
208 :    
209 :     and eqRexp(T.REG(a,b),T.REG(c,d)) = a=c andalso b=d
210 :     | eqRexp(T.LI a,T.LI b) = a=b
211 :     | eqRexp(T.LI32 a,T.LI32 b) = a=b
212 :     | eqRexp(T.LI64 a,T.LI64 b) = a=b
213 :     | eqRexp(T.LABEL a,T.LABEL b) = LabelExp.==(a,b)
214 :     | eqRexp(T.CONST a,T.CONST b) = Constant.==(a,b)
215 :     | eqRexp(T.ADD x,T.ADD y) = eq2(x,y)
216 :     | eqRexp(T.SUB x,T.SUB y) = eq2(x,y)
217 :     | eqRexp(T.MULS x,T.MULS y) = eq2(x,y)
218 :     | eqRexp(T.DIVS x,T.DIVS y) = eq2(x,y)
219 :     | eqRexp(T.REMS x,T.REMS y) = eq2(x,y)
220 :     | eqRexp(T.MULU x,T.MULU y) = eq2(x,y)
221 :     | eqRexp(T.DIVU x,T.DIVU y) = eq2(x,y)
222 :     | eqRexp(T.REMU x,T.REMU y) = eq2(x,y)
223 :     | eqRexp(T.ADDT x,T.ADDT y) = eq2(x,y)
224 :     | eqRexp(T.SUBT x,T.SUBT y) = eq2(x,y)
225 :     | eqRexp(T.MULT x,T.MULT y) = eq2(x,y)
226 :     | eqRexp(T.DIVT x,T.DIVT y) = eq2(x,y)
227 :     | eqRexp(T.REMT x,T.REMT y) = eq2(x,y)
228 :     | eqRexp(T.ANDB x,T.ANDB y) = eq2(x,y)
229 :     | eqRexp(T.ORB x,T.ORB y) = eq2(x,y)
230 :     | eqRexp(T.XORB x,T.XORB y) = eq2(x,y)
231 :     | eqRexp(T.NOTB(a,b),T.NOTB(c,d)) = a=c andalso eqRexp(b,d)
232 :     | eqRexp(T.SRA x,T.SRA y) = eq2(x,y)
233 :     | eqRexp(T.SRL x,T.SRL y) = eq2(x,y)
234 :     | eqRexp(T.SLL x,T.SLL y) = eq2(x,y)
235 :     | eqRexp(T.COND(a,b,c,d),T.COND(e,f,g,h)) =
236 :     a=e andalso eqCCexp(b,f) andalso eqRexp(c,g) andalso eqRexp(d,h)
237 :     | eqRexp(T.CVTI2I(a,b,c,d),T.CVTI2I(e,f,g,h)) =
238 :     a=e andalso b=f andalso c=g andalso eqRexp(d,h)
239 :     | eqRexp(T.CVTF2I(a,b,c,d),T.CVTF2I(e,f,g,h)) =
240 :     a=e andalso b=f andalso c=g andalso eqFexp(d,h)
241 :     | eqRexp(T.LOAD(a,b,_),T.LOAD(c,d,_)) = a=c andalso eqRexp(b,d)
242 :     | eqRexp(T.LOAD_UNALIGNED(a,b,_),T.LOAD(c,d,_)) = a=c andalso eqRexp(b,d)
243 :     | eqRexp(T.SEQ(a,b),T.SEQ(c,d)) = eqStm(a,c) andalso eqRexp(b,d)
244 :     | eqRexp(T.MARK(a,_),b) = eqRexp(a,b)
245 :     | eqRexp(a,T.MARK(b,_)) = eqRexp(a,b)
246 :     | eqRexp(T.EXT(a,f,es1),T.EXT(b,g,es2)) =
247 :     a=b andalso eqRext(f,g) andalso eqRexps(es1,es2)
248 :     | eqRexp(T.RTLPC,T.RTLPC) = true
249 :     | eqRexp(T.RTLMISC(a,b),T.RTLMISC(c,d)) = a=c andalso eqRexps(b,d)
250 :     | eqRexp _ = false
251 :    
252 :     and eqRexps([],[]) = true
253 :     | eqRexps(a::b,c::d) = eqRexp(a,c) andalso eqRexps(b,d)
254 :     | eqRexps _ = false
255 :    
256 :     and eq2'((a,b,c),(d,e,f)) = a=d andalso eqFexp(b,e) andalso eqFexp(c,f)
257 :     and eq1'((a,b),(d,e)) = a=d andalso eqFexp(b,e)
258 :    
259 :     and eqFexp(T.FREG x,T.FREG y) = x = y
260 :     | eqFexp(T.FLOAD(a,b,_),T.FLOAD(c,d,_)) = a=c andalso eqRexp(b,d)
261 :     | eqFexp(T.FLOAD_UNALIGNED(a,b,_),T.FLOAD(c,d,_)) = a=c andalso eqRexp(b,d)
262 :     | eqFexp(T.FADD x,T.FADD y) = eq2'(x,y)
263 :     | eqFexp(T.FMUL x,T.FMUL y) = eq2'(x,y)
264 :     | eqFexp(T.FSUB x,T.FSUB y) = eq2'(x,y)
265 :     | eqFexp(T.FDIV x,T.FDIV y) = eq2'(x,y)
266 :     | eqFexp(T.FABS x,T.FABS y) = eq1'(x,y)
267 :     | eqFexp(T.FNEG x,T.FNEG y) = eq1'(x,y)
268 :     | eqFexp(T.FSQRT x,T.FSQRT y) = eq1'(x,y)
269 :     | eqFexp(T.CVTI2F(a,b,c,d),T.CVTI2F(e,f,g,h)) =
270 :     a=e andalso b=f andalso c=g andalso eqRexp(d,h)
271 :     | eqFexp(T.CVTF2F(a,b,c,d),T.CVTF2F(e,f,g,h)) =
272 :     a=e andalso b=f andalso c=g andalso eqFexp(d,h)
273 :     | eqFexp(T.FSEQ(a,b),T.FSEQ(c,d)) = eqStm(a,c) andalso eqFexp(b,d)
274 :     | eqFexp(T.FMARK(a,_),b) = eqFexp(a,b)
275 :     | eqFexp(a,T.FMARK(b,_)) = eqFexp(a,b)
276 :     | eqFexp(T.FEXT(a,f,es1),T.FEXT(b,g,es2)) =
277 :     a=b andalso eqFext(f,g) andalso eqFexps(es1,es2)
278 :     | eqFexp(T.RTLFMISC(a,b),T.RTLFMISC(c,d)) = a=c andalso eqFexps(b,d)
279 :     | eqFexp _ = false
280 :    
281 :     and eqFexps([],[]) = true
282 :     | eqFexps(a::b,c::d) = eqFexp(a,c) andalso eqFexps(b,d)
283 :     | eqFexps _ = false
284 :    
285 :     and eqCCexp(T.CC x,T.CC y) = x=y
286 :     | eqCCexp(T.CMP(x,a,b,c),T.CMP(y,d,e,f)) =
287 :     a=d andalso eqRexp(b,e) andalso eqRexp(c,f) andalso x = y
288 :     | eqCCexp(T.FCMP(x,a,b,c),T.FCMP(y,d,e,f)) =
289 :     a=d andalso eqFexp(b,e) andalso eqFexp(c,f) andalso x = y
290 :     | eqCCexp(T.RTLCCMISC(a,b),T.RTLCCMISC(c,d)) = a=c andalso eqCCexps(b,d)
291 :     | eqCCexp(T.CCMARK(a,_),b) = eqCCexp(a,b)
292 :     | eqCCexp(a,T.CCMARK(b,_)) = eqCCexp(a,b)
293 :     | eqCCexp _ = false
294 :    
295 :     and eqCCexps([],[]) = true
296 :     | eqCCexps(a::b,c::d) = eqCCexp(a,c) andalso eqCCexps(b,d)
297 :     | eqCCexps _ = false
298 :     (*
299 :     * Pretty printing
300 :     *)
301 :     fun prettyPrinting (dst,src) s =
302 :     let fun ty t = "."^Int.toString t
303 :     fun fty 32 = ".s"
304 :     | fty 64 = ".d"
305 :     | fty 128 = ".q"
306 :     | fty t = ty t
307 :    
308 :     fun reg(t,v) = "r"^Int.toString v^ty t
309 :     fun freg(t,v) = "f"^Int.toString v^fty t
310 :     fun ccreg v = "cc"^Int.toString v
311 :    
312 :     fun srcReg(t,v) = List.nth(src,v) handle _ => reg(t,v)
313 :     fun srcFreg(t,v) = List.nth(src,v) handle _ => freg(t,v)
314 :     fun srcCCreg v = List.nth(src,v) handle _ => ccreg v
315 :    
316 :     fun dstReg(t,v) = List.nth(dst,v) handle _ => reg(t,v)
317 :     fun dstFreg(t,v) = List.nth(dst,v) handle _ => freg(t,v)
318 :     fun dstCCreg v = List.nth(dst,v) handle _ => ccreg v
319 :    
320 :     fun srcRegs(t,[]) = ""
321 :     | srcRegs(t,[r]) = srcReg(t,r)
322 :     | srcRegs(t,r::rs) = srcReg(t,r)^","^srcRegs(t,rs)
323 :    
324 :     fun dstRegs(t,[]) = ""
325 :     | dstRegs(t,[r]) = dstReg(t,r)
326 :     | dstRegs(t,r::rs) = dstReg(t,r)^","^dstRegs(t,rs)
327 :    
328 :     fun srcFregs(t,[]) = ""
329 :     | srcFregs(t,[f]) = srcFreg(t,f)
330 :     | srcFregs(t,f::fs) = srcFreg(t,f)^","^srcFregs(t,fs)
331 :    
332 :     fun dstFregs(t,[]) = ""
333 :     | dstFregs(t,[f]) = dstFreg(t,f)
334 :     | dstFregs(t,f::fs) = dstFreg(t,f)^","^dstFregs(t,fs)
335 :    
336 :     fun copy(t,dst,src) = dstRegs(t, dst)^" := ^"^srcRegs(t, src)
337 :     fun fcopy(t,dst,src) = dstFregs(t, dst)^" := "^srcFregs(t, src)
338 :    
339 :     val unaligned = "u"
340 :    
341 :     (* pretty print a statement *)
342 :     fun stm(T.MV(t,dst,e)) = dstReg(t,dst)^" := "^rexp e
343 :     | stm(T.CCMV(dst,e)) = dstCCreg dst^" := "^ccexp e
344 :     | stm(T.FMV(fty,dst,e)) = dstFreg(fty,dst)^" := "^fexp e
345 :     | stm(T.COPY(ty,dst,src)) = copy(ty,dst,src)
346 :     | stm(T.FCOPY(fty,dst,src)) = fcopy(fty,dst,src)
347 :     | stm(T.JMP(ea,labels)) = "jmp "^rexp ea
348 :     | stm(T.CALL(ea,defs,uses,mem)) = "call "^rexp ea
349 :     | stm T.RET = "ret"
350 :     | stm(T.STORE(ty,ea,e,mem)) = store(ty,"",ea,mem,e)
351 :     | stm(T.STORE_UNALIGNED(ty,ea,e,mem)) = store(ty,unaligned,ea,mem,e)
352 :     | stm(T.FSTORE(fty,ea,e,mem)) = fstore(fty,"",ea,mem,e)
353 :     | stm(T.FSTORE_UNALIGNED(fty,ea,e,mem)) = fstore(fty,unaligned,ea,mem,e)
354 :     | stm(T.BCC(cond,e,lab)) = branch("b"^U.condToString cond,e,lab)
355 :     | stm(T.FBCC(fcond,e,lab)) = branch("fb"^U.fcondToString fcond,e,lab)
356 :     | stm(T.ANNOTATION(s, a)) = stm s
357 :     | stm(T.RTL(_,_,s)) = stm s
358 :     | stm(T.RTLPHI b) = "phi["^Int.toString b^"]"
359 :     | stm(T.RTLPINNED s) = "pinned "^stm s
360 :     | stm(T.RTLPAR ss) = stms("||",ss)
361 :    
362 :     and stms(sep,[]) = ""
363 :     | stms(sep,[s]) = stm s
364 :     | stms(sep,s::ss) = stm s^sep^stms(sep,ss)
365 :    
366 :     (* pretty print an expression *)
367 :     and rexp(T.REG(ty, src)) = srcReg(ty,src)
368 :     | rexp(T.LI i) = (List.nth(src,i) handle _ => Int.toString i)
369 :     | rexp(T.LI32 w) = Word32.toString w
370 :     | rexp(T.LI64 w) = Word64.toString w
371 :     | rexp(T.LABEL le) = LabelExp.toString le
372 :     | rexp(T.CONST c) = Constant.toString c
373 :     | rexp(T.ADD x) = two("add",x)
374 :     | rexp(T.SUB x) = two("sub",x)
375 :     | rexp(T.MULS x) = two("muls",x)
376 :     | rexp(T.DIVS x) = two("divs",x)
377 :     | rexp(T.REMS x) = two("rems",x)
378 :     | rexp(T.MULU x) = two("mulu",x)
379 :     | rexp(T.DIVU x) = two("divu",x)
380 :     | rexp(T.REMU x) = two("remu",x)
381 :     | rexp(T.ADDT x) = two("addt",x)
382 :     | rexp(T.SUBT x) = two("subt",x)
383 :     | rexp(T.MULT x) = two("mult",x)
384 :     | rexp(T.DIVT x) = two("divt",x)
385 :     | rexp(T.REMT x) = two("remt",x)
386 :     | rexp(T.ANDB x) = two("andb",x)
387 :     | rexp(T.ORB x) = two("orb",x)
388 :     | rexp(T.XORB x) = two("xorb",x)
389 :     | rexp(T.NOTB x) = one("notb",x)
390 :     | rexp(T.SRA x) = two("sra",x)
391 :     | rexp(T.SRL x) = two("srl",x)
392 :     | rexp(T.SLL x) = two("sll",x)
393 :     | rexp(T.COND(t,cc,e1,e2)) =
394 :     "cond"^ty t^ccexp cc^"("^rexp e1^","^rexp e2^")"
395 :     | rexp(T.CVTI2I(t, ext, t', e)) =
396 :     "cvti2i"^ty t^U.extToString ext^ty t'^" "^rexp e
397 :     | rexp(T.CVTF2I(t, round, t', e)) =
398 :     "cvtf2i"^ty t^U.roundingModeToString round^fty t'^" "^fexp e
399 :     | rexp(T.LOAD(ty, ea, mem)) = load(ty,"",ea,mem)
400 :     | rexp(T.LOAD_UNALIGNED(ty, ea, mem)) = load(ty,unaligned,ea,mem)
401 :     | rexp(T.SEQ(s, e)) = stm s^";"^rexp e
402 :     | rexp(T.MARK(e, _)) = rexp e
403 :     | rexp(T.EXT(t, rext, args)) = rextToString rext^ty t^rexps args
404 :     | rexp(T.RTLPC) = "PC"
405 :     | rexp(T.RTLMISC(ref{name,...}, args)) = name^rexps args
406 :    
407 :     (* pretty print a real expression *)
408 :     and fexp(T.FREG f) = srcFreg f
409 :     | fexp(T.FLOAD(fty, ea, mem)) = fload(fty,"",ea,mem)
410 :     | fexp(T.FLOAD_UNALIGNED(fty, ea, mem)) = fload(fty,unaligned,ea,mem)
411 :     | fexp(T.FADD x) = two'("fadd",x)
412 :     | fexp(T.FMUL x) = two'("fmul",x)
413 :     | fexp(T.FSUB x) = two'("fsub",x)
414 :     | fexp(T.FDIV x) = two'("fdiv",x)
415 :     | fexp(T.FABS x) = one'("fabs",x)
416 :     | fexp(T.FNEG x) = one'("fneg",x)
417 :     | fexp(T.FSQRT x) = one'("fsqrt",x)
418 :     | fexp(T.CVTI2F(t, ext, t', e)) =
419 :     "cvti2f"^fty t^U.extToString ext^ty t'^" "^rexp e
420 :     | fexp(T.CVTF2F(t, r, t', e)) =
421 :     "cvtf2f"^fty t^U.roundingModeToString r^fty t'^" "^fexp e
422 :     | fexp(T.FSEQ(s, e)) = stm s^";"^fexp e
423 :     | fexp(T.FMARK(e, _)) = fexp e
424 :     | fexp(T.FEXT(t, fext, args)) = fextToString fext^fty t^fexps args
425 :     | fexp(T.RTLFMISC(ref{name,...}, args)) = name^fexps args
426 :    
427 :     and ccexp(T.CC r) = srcCCreg r
428 :     | ccexp(T.CMP(t,cond, x, y)) =
429 :     "cmp"^U.condToString cond^ty t^pair(x,y)
430 :     | ccexp(T.FCMP(t,fcond, x, y)) =
431 :     "fcmp"^U.fcondToString fcond^fty t^pair'(x,y)
432 :     | ccexp(T.CCMARK(e, _)) = ccexp e
433 :     | ccexp(T.RTLCCMISC(ref{name,...}, args)) = name^ccexps args
434 :    
435 :     (* Auxiliary functions *)
436 :     and one(opcode,(t,x)) = opcode^ty t^"("^rexp x^")"
437 :     and two(opcode,(t,x,y)) = opcode^ty t^pair(x,y)
438 :     and pair(x,y) = "("^rexp x^","^rexp y^")"
439 :     and one'(opcode,(t,x)) = opcode^fty t^"("^fexp x^")"
440 :     and two'(opcode,(t,x,y)) = opcode^fty t^pair'(x,y)
441 :     and pair'(x,y) = "("^fexp x^","^fexp y^")"
442 :     and rexps es = "("^foldr (fn (e,"") => rexp e
443 :     | (e,x) => rexp e^","^x) "" es^")"
444 :     and fexps es = "("^foldr (fn (e,"") => fexp e
445 :     | (e,x) => fexp e^","^x) "" es^")"
446 :     and ccexps es = "("^foldr (fn (e,"") => ccexp e
447 :     | (e,x) => ccexp e^","^x) "" es^")"
448 :     and store(t,u,ea,m,e) = mem(t,u,ea,m)^" := "^rexp e
449 :     and fstore(t,u,ea,m,e) = fmem(t,u,ea,m)^" := "^fexp e
450 :     and ccstore(u,ea,m,e) = ccmem(u,ea,m)^" := "^ccexp e
451 :     and branch(c,e,lab) = c^" "^ccexp e^" "^Label.nameOf lab
452 :     and load(t,u,ea,m) = mem(t,u,ea,m)
453 :     and fload(t,u,ea,m) = fmem(t,u,ea,m)
454 :     and ccload(u,ea,m) = ccmem(u,ea,m)
455 :     and addr(u,ea,m) = u^"["^rexp ea^","^Region.toString m^"]"
456 :     and mem(t,u,ea,m) = "mem"^ty t^addr(u,ea,m)
457 :     and fmem(t,u,ea,m) = "mem"^fty t^addr(u,ea,m)
458 :     and ccmem(u,ea,m) = "mem"^addr(u,ea,m)
459 :    
460 :     in stm s
461 :     end
462 :    
463 :     fun toString s = prettyPrinting([],[]) s
464 :     val toString' = prettyPrinting
465 :    
466 :     end

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