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-rewrite.sml
ViewVC logotype

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 744 - (view) (download)

1 : leunga 591 functor MLTreeRewrite
2 :     (structure T : MLTREE
3 :     (* Traversal extensions *)
4 :     val sext : T.rewriter -> T.sext -> T.sext
5 :     val rext : T.rewriter -> T.rext -> T.rext
6 :     val fext : T.rewriter -> T.fext -> T.fext
7 :     val ccext : T.rewriter -> T.ccext -> T.ccext
8 :     ) : MLTREE_REWRITE =
9 :     struct
10 :     structure T = T
11 :    
12 :     type rewriters =
13 :     { stm : T.stm -> T.stm,
14 :     rexp : T.rexp -> T.rexp,
15 :     fexp : T.fexp -> T.fexp,
16 :     ccexp : T.ccexp -> T.ccexp
17 :     }
18 :    
19 :     fun rewrite{rexp=doRexp, fexp=doFexp, ccexp=doCCexp, stm=doStm} =
20 :     let fun stm s =
21 :     let val s =
22 :     case s of
23 :     T.MV(ty,dst,e) => T.MV(ty,dst,rexp e)
24 :     | T.CCMV(dst,e) => T.CCMV(dst,ccexp e)
25 :     | T.FMV(fty,dst,e) => T.FMV(fty,dst,fexp e)
26 :     | T.COPY _ => s
27 :     | T.FCOPY _ => s
28 : leunga 744 | T.JMP(e,cf) => T.JMP(rexp e,cf)
29 :     | T.BCC(cc,l) => T.BCC(ccexp cc,l)
30 :     | T.CALL{funct,targets,defs,uses,region} =>
31 : leunga 591 T.CALL{funct=rexp funct,targets=targets,
32 :     defs=mlriscs defs,uses=mlriscs uses,
33 : leunga 744 region=region}
34 : leunga 591 | T.RET _ => s
35 : leunga 744 | T.IF(cc,yes,no) => T.IF(ccexp cc,stm yes,stm no)
36 : leunga 591 | T.STORE(ty,ea,d,r) => T.STORE(ty,rexp ea,rexp d,r)
37 :     | T.FSTORE(fty,ea,d,r) => T.FSTORE(fty,rexp ea,fexp d,r)
38 :     | T.REGION(s,ctrl) => T.REGION(stm s,ctrl)
39 :     | T.SEQ s => T.SEQ(stms s)
40 :     | T.DEFINE _ => s
41 :     | T.ANNOTATION(s,an) => T.ANNOTATION(stm s,an)
42 :     | T.EXT s =>
43 :     T.EXT(sext {rexp=rexp, fexp=fexp, ccexp=ccexp, stm=stm} s)
44 :     | T.PHI _ => s
45 : leunga 624 | T.SOURCE _ => s
46 :     | T.SINK _ => s
47 : leunga 591 | T.RTL _ => s
48 : leunga 744 | T.ASSIGN(ty,x,y) => T.ASSIGN(ty,rexp x, rexp y)
49 : leunga 591 in doStm stm s end
50 :    
51 :     and stms ss = map stm ss
52 :    
53 :     and rexp e =
54 :     let val e = case e of
55 :     T.REG _ => e
56 :     | T.LI _ => e
57 :     | T.LI32 _ => e
58 : leunga 744 | T.LIInf _ => e
59 : leunga 591 | T.LABEL _ => e
60 :     | T.CONST _ => e
61 :     | T.NEG(ty,x) => T.NEG(ty,rexp x)
62 :     | T.ADD(ty,x,y) => T.ADD(ty,rexp x,rexp y)
63 :     | T.SUB(ty,x,y) => T.SUB(ty,rexp x,rexp y)
64 :     | T.MULS(ty,x,y) => T.MULS(ty,rexp x,rexp y)
65 :     | T.DIVS(ty,x,y) => T.DIVS(ty,rexp x,rexp y)
66 :     | T.QUOTS(ty,x,y) => T.QUOTS(ty,rexp x,rexp y)
67 :     | T.REMS(ty,x,y) => T.REMS(ty,rexp x,rexp y)
68 :     | T.MULU(ty,x,y) => T.MULU(ty,rexp x,rexp y)
69 :     | T.DIVU(ty,x,y) => T.DIVU(ty,rexp x,rexp y)
70 :     | T.REMU(ty,x,y) => T.REMU(ty,rexp x,rexp y)
71 :     | T.NEGT(ty,x) => T.NEGT(ty,rexp x)
72 :     | T.ADDT(ty,x,y) => T.ADDT(ty,rexp x,rexp y)
73 :     | T.SUBT(ty,x,y) => T.SUBT(ty,rexp x,rexp y)
74 :     | T.MULT(ty,x,y) => T.MULT(ty,rexp x,rexp y)
75 :     | T.DIVT(ty,x,y) => T.DIVT(ty,rexp x,rexp y)
76 :     | T.QUOTT(ty,x,y) => T.QUOTT(ty,rexp x,rexp y)
77 :     | T.REMT(ty,x,y) => T.REMT(ty,rexp x,rexp y)
78 :     | T.ANDB(ty,x,y) => T.ANDB(ty,rexp x,rexp y)
79 :     | T.ORB(ty,x,y) => T.ORB(ty,rexp x,rexp y)
80 :     | T.XORB(ty,x,y) => T.XORB(ty,rexp x,rexp y)
81 : leunga 744 | T.EQVB(ty,x,y) => T.EQVB(ty,rexp x,rexp y)
82 : leunga 591 | T.NOTB(ty,x) => T.NOTB(ty,rexp x)
83 :     | T.SRA(ty,x,y) => T.SRA(ty,rexp x,rexp y)
84 :     | T.SRL(ty,x,y) => T.SRL(ty,rexp x,rexp y)
85 :     | T.SLL(ty,x,y) => T.SLL(ty,rexp x,rexp y)
86 : leunga 744 | T.SX(t,t',e) => T.SX(t,t',rexp e)
87 :     | T.ZX(t,t',e) => T.ZX(t,t',rexp e)
88 : leunga 591 | T.CVTF2I(ty,mode,fty,e) => T.CVTF2I(ty,mode,fty,fexp e)
89 :     | T.COND(ty,cc,yes,no) => T.COND(ty,ccexp cc,rexp yes,rexp no)
90 :     | T.LOAD(ty,ea,r) => T.LOAD(ty,rexp ea,r)
91 :     | T.PRED(e,ctrl) => T.PRED(rexp e,ctrl)
92 :     | T.LET(s,e) => T.LET(stm s,rexp e)
93 :     | T.REXT(ty,e) =>
94 :     T.REXT(ty,rext {rexp=rexp, fexp=fexp, ccexp=ccexp, stm=stm} e)
95 :     | T.MARK(e,an) => T.MARK(rexp e,an)
96 : leunga 744 | T.$(ty,k,e) => T.$(ty,k,rexp e)
97 :     | T.ARG _ => e
98 :     | T.PARAM _ => e
99 :     | T.BITSLICE(ty,sl,e) => T.BITSLICE(ty,sl,rexp e)
100 :     | T.??? => T.???
101 :     | T.OP(ty,oper,es) => T.OP(ty,oper,rexps es)
102 : leunga 591 in doRexp rexp e end
103 :    
104 :     and rexps es = map rexp es
105 :    
106 :     and fexp e =
107 :     let val e = case e of
108 :     T.FREG _ => e
109 :     | T.FLOAD(fty,e,r) => T.FLOAD(fty,rexp e,r)
110 :     | T.FADD(fty,x,y) => T.FADD(fty,fexp x,fexp y)
111 :     | T.FSUB(fty,x,y) => T.FSUB(fty,fexp x,fexp y)
112 :     | T.FMUL(fty,x,y) => T.FMUL(fty,fexp x,fexp y)
113 :     | T.FDIV(fty,x,y) => T.FDIV(fty,fexp x,fexp y)
114 :     | T.FABS(fty,x) => T.FABS(fty,fexp x)
115 :     | T.FNEG(fty,x) => T.FNEG(fty,fexp x)
116 :     | T.FSQRT(fty,x) => T.FSQRT(fty,fexp x)
117 :     | T.FCOPYSIGN(fty,x,y) => T.FCOPYSIGN(fty,fexp x,fexp y)
118 :     | T.FCOND(fty,c,x,y) => T.FCOND(fty,ccexp c,fexp x,fexp y)
119 :     | T.CVTI2F(fty,ty,e) => T.CVTI2F(fty,ty,rexp e)
120 :     | T.CVTF2F(fty,fty',e) => T.CVTF2F(fty,fty',fexp e)
121 :     | T.FPRED(e,ctrl) => T.FPRED(fexp e,ctrl)
122 :     | T.FEXT(fty,e) =>
123 :     T.FEXT(fty,fext {rexp=rexp, fexp=fexp, ccexp=ccexp, stm=stm} e)
124 :     | T.FMARK(e,an) => T.FMARK(fexp e,an)
125 :     in doFexp fexp e end
126 :    
127 :     and fexps es = map fexp es
128 :    
129 :     and ccexp e =
130 :     let val e = case e of
131 :     T.CC _ => e
132 :     | T.FCC _ => e
133 :     | T.TRUE => e
134 :     | T.FALSE => e
135 :     | T.NOT e => T.NOT(ccexp e)
136 :     | T.AND(x,y) => T.AND(ccexp x,ccexp y)
137 :     | T.OR(x,y) => T.OR(ccexp x,ccexp y)
138 :     | T.XOR(x,y) => T.XOR(ccexp x,ccexp y)
139 : leunga 744 | T.EQV(x,y) => T.EQV(ccexp x,ccexp y)
140 : leunga 591 | T.CMP(ty,cond,x,y) => T.CMP(ty,cond,rexp x,rexp y)
141 :     | T.FCMP(ty,fcond,x,y) => T.FCMP(ty,fcond,fexp x,fexp y)
142 :     | T.CCMARK(e,an) => T.CCMARK(ccexp e,an)
143 :     | T.CCEXT(ty,e) =>
144 :     T.CCEXT(ty,ccext {rexp=rexp, fexp=fexp, ccexp=ccexp, stm=stm} e)
145 :     in doCCexp ccexp e end
146 :    
147 :     and mlriscs m = map mlrisc m
148 :    
149 :     and mlrisc m =
150 :     let val m =
151 :     case m of
152 :     T.CCR e => T.CCR(ccexp e)
153 :     | T.GPR e => T.GPR(rexp e)
154 :     | T.FPR e => T.FPR(fexp e)
155 :     in m end
156 :    
157 :     in { rexp=rexp, fexp=fexp, ccexp=ccexp, stm=stm } end
158 :     end (* MLTreeFold *)
159 :    

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