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/Tools/MDL/mdl-rtl-tools.sml
ViewVC logotype

Annotation of /sml/trunk/src/MLRISC/Tools/MDL/mdl-rtl-tools.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 744 - (view) (download)

1 : leunga 744 (*
2 :     * Process rtl descriptions
3 :     *)
4 :     functor MDLRTLTools
5 :     (structure AstUtil : MDL_AST_UTIL
6 :     structure MLTreeRTL : MLTREE_RTL
7 :     ) : MDL_RTL_TOOLS =
8 :     struct
9 :     structure Ast = AstUtil.Ast
10 :     structure RTL = MLTreeRTL
11 :     structure T = RTL.T
12 :     structure A = Ast
13 :     structure U = AstUtil
14 :     structure CellsBasis = CellsBasis
15 :    
16 :     fun error msg = MLRiscErrorMsg.error("MDRTLTools",msg)
17 :    
18 :     (*========================================================================
19 :     *
20 :     * Simplify an RTL expression
21 :     *
22 :     *========================================================================*)
23 :     fun simplify rtl =
24 :     let fun stm reduce (T.SEQ [s]) = s
25 :     | stm reduce (T.IF(T.TRUE, y, n)) = y
26 :     | stm reduce (T.IF(T.FALSE, y, n)) = n
27 :     | stm reduce s = s
28 :    
29 :     and rexp reduce (e as T.LI32 w) =
30 :     (T.LI(Word32.toIntX w) handle Overflow => e)
31 :     | rexp reduce (T.ADD(_,T.LI 0,x)) = x
32 :     | rexp reduce (T.ADD(_,x,T.LI 0)) = x
33 :     | rexp reduce (T.SUB(_,x,T.LI 0)) = x
34 :     | rexp reduce (T.MULS(_,_,zero as T.LI 0)) = zero
35 :     | rexp reduce (T.MULU(_,_,zero as T.LI 0)) = zero
36 :     | rexp reduce (T.MULT(_,_,zero as T.LI 0)) = zero
37 :     | rexp reduce (T.MULS(_,zero as T.LI 0, _)) = zero
38 :     | rexp reduce (T.MULU(_,zero as T.LI 0, _)) = zero
39 :     | rexp reduce (T.MULT(_,zero as T.LI 0, _)) = zero
40 :     | rexp reduce (T.MULS(_,x,T.LI 1)) = x
41 :     | rexp reduce (T.MULU(_,x,T.LI 1)) = x
42 :     | rexp reduce (T.MULT(_,x,T.LI 1)) = x
43 :     | rexp reduce (T.DIVS(_,x,T.LI 1)) = x
44 :     | rexp reduce (T.DIVU(_,x,T.LI 1)) = x
45 :     | rexp reduce (T.DIVT(_,x,T.LI 1)) = x
46 :     | rexp reduce (T.ANDB(_,_,zero as T.LI 0)) = zero
47 :     | rexp reduce (T.ANDB(_,zero as T.LI 0,_)) = zero
48 :     | rexp reduce (e as T.ANDB(_,x,y)) =
49 :     if RTL.Util.eqRexp(x,y) then x else e
50 :     | rexp reduce (T.ORB(_,x,T.LI 0)) = x
51 :     | rexp reduce (T.ORB(_,T.LI 0,x)) = x
52 :     | rexp reduce (e as T.ORB(_,x,y)) =
53 :     if RTL.Util.eqRexp(x,y) then x else e
54 :     | rexp reduce (T.NOTB(_,T.NOTB(_,x))) = x
55 :     | rexp reduce (e as T.SX(t1,t2,x)) = if t1 = t2 then x else e
56 :     | rexp reduce (e as T.ZX(t1,t2,x)) = if t1 = t2 then x else e
57 :     | rexp reduce e = e
58 :     and fexp reduce e = e
59 :    
60 :     and ccexp reduce (T.NOT T.TRUE) = T.FALSE
61 :     | ccexp reduce (T.NOT T.FALSE) = T.TRUE
62 :     | ccexp reduce (T.AND(T.FALSE,_)) = T.FALSE
63 :     | ccexp reduce (T.AND(_,T.FALSE)) = T.FALSE
64 :     | ccexp reduce (T.AND(T.TRUE, x)) = x
65 :     | ccexp reduce (T.AND(x,T.TRUE)) = x
66 :     | ccexp reduce (T.OR(T.FALSE,x)) = x
67 :     | ccexp reduce (T.OR(x,T.FALSE)) = x
68 :     | ccexp reduce (T.OR(T.TRUE, _)) = T.TRUE
69 :     | ccexp reduce (T.OR(_,T.TRUE)) = T.TRUE
70 :     | ccexp reduce (e as T.CMP(_,T.EQ,x,y)) =
71 :     if RTL.Util.eqRexp(x,y) then T.TRUE else e
72 :     | ccexp reduce (e as T.CMP(_,T.NE,x,y)) =
73 :     if RTL.Util.eqRexp(x,y) then T.FALSE else e
74 :     | ccexp reduce e = e
75 :    
76 :     val rewriter =
77 :     RTL.Rewrite.rewrite{rexp=rexp, fexp=fexp, ccexp=ccexp, stm=stm}
78 :     in #stm rewriter rtl
79 :     end
80 :    
81 :     (*========================================================================
82 :     *
83 :     * Translate an RTL into something else
84 :     *
85 :     *========================================================================*)
86 :     fun transRTL
87 :     {app,id,int,word32,string,list,Nil,tuple,record,arg,
88 :     cellkind,oper,region}
89 :     rtl =
90 :     let fun word w = word32(Word.toLargeWord w)
91 :     fun binOp n (ty,x,y) = app(n,[int ty,rexp x,rexp y])
92 :     and unaryOp n (ty,x) = app(n,[int ty,rexp x])
93 :     and rexp(T.LI i) = app("LI",[int i])
94 :     | rexp(T.LI32 w) = app("LI32",[word32 w])
95 :     | rexp(T.NEG x) = unaryOp "NEG" x
96 :     | rexp(T.ADD x) = binOp "ADD" x
97 :     | rexp(T.SUB x) = binOp "SUB" x
98 :     | rexp(T.MULS x) = binOp "MULS" x
99 :     | rexp(T.DIVS x) = binOp "DIVS" x
100 :     | rexp(T.REMS x) = binOp "REMS" x
101 :     | rexp(T.QUOTS x) = binOp "QUOTS" x
102 :     | rexp(T.MULU x) = binOp "MULU" x
103 :     | rexp(T.DIVU x) = binOp "DIVU" x
104 :     | rexp(T.REMU x) = binOp "REMU" x
105 :     | rexp(T.NEGT x) = unaryOp "NEGT" x
106 :     | rexp(T.ADDT x) = binOp "ADDT" x
107 :     | rexp(T.SUBT x) = binOp "SUBT" x
108 :     | rexp(T.MULT x) = binOp "MULT" x
109 :     | rexp(T.DIVT x) = binOp "DIVT" x
110 :     | rexp(T.REMT x) = binOp "REMT" x
111 :     | rexp(T.NOTB x) = unaryOp "NOTB" x
112 :     | rexp(T.ANDB x) = binOp "ANDB" x
113 :     | rexp(T.ORB x) = binOp "ORB" x
114 :     | rexp(T.XORB x) = binOp "XORB" x
115 :     | rexp(T.EQVB x) = binOp "EQVB" x
116 :     | rexp(T.SLL x) = binOp "SLL" x
117 :     | rexp(T.SRL x) = binOp "SRL" x
118 :     | rexp(T.SRA x) = binOp "SRA" x
119 :     | rexp(T.SX(t1,t2,x)) = app("SX",[int t1,int t2,rexp x])
120 :     | rexp(T.ZX(t1,t2,x)) = app("ZX",[int t1,int t2,rexp x])
121 :     | rexp(T.CVTF2I(t1,r,t2,x)) =
122 :     app("CVTF2I",[int t1,id(T.Basis.roundingModeToString r),
123 :     int t2,fexp x])
124 :     | rexp(T.COND(ty,cc,a,b)) =
125 :     app("COND",[int ty,ccexp cc,rexp a,rexp b])
126 :     | rexp(T.$(ty,k,e)) = app("$",[int ty,cellkind k,rexp e])
127 :     | rexp(T.ARG(ty,a,b)) = arg(ty,a,b)
128 :     | rexp(T.PARAM(i)) = app("PARAM",[int i])
129 :     | rexp(T.???) = id "???"
130 :     | rexp(T.OP(ty,opc,es)) =
131 :     app("OP",[int ty,oper opc,list(map rexp es, NONE)])
132 :     | rexp(T.BITSLICE(ty,sl,e)) =
133 :     app("BITSLICE",[int ty,slice sl,rexp e])
134 :     | rexp e = error("transRTL: "^RTL.Util.rexpToString e)
135 :     and slice sl = list(map (fn (x,y) => tuple[int x,int y]) sl, NONE)
136 :     and fbinOp n (ty,x,y) = app(n,[int ty,fexp x,fexp y])
137 :     and funaryOp n (ty,x) = app(n,[int ty,fexp x])
138 :     and fexp(T.FADD x) = fbinOp "FADD" x
139 :     | fexp(T.FSUB x) = fbinOp "FSUB" x
140 :     | fexp(T.FMUL x) = fbinOp "FMUL" x
141 :     | fexp(T.FDIV x) = fbinOp "FDIV" x
142 :     | fexp(T.FCOPYSIGN x) = fbinOp "FCOPYSIGN" x
143 :     | fexp(T.FNEG x) = funaryOp "FNEG" x
144 :     | fexp(T.FABS x) = funaryOp "FABS" x
145 :     | fexp(T.FSQRT x) = funaryOp "FSQRT" x
146 :     | fexp(T.FCOND(ty,cc,x,y)) =
147 :     app("FCOND",[int ty,ccexp cc,fexp x,fexp y])
148 :     | fexp(T.CVTI2F(t1,t2,x)) = app("CVTI2F",[int t1,int t2,rexp x])
149 :     | fexp(T.CVTF2F(t1,t2,x)) = app("CVTF2F",[int t1,int t2,fexp x])
150 :     | fexp e = error("transRTL: "^RTL.Util.fexpToString e)
151 :    
152 :     and stm(T.ASSIGN(ty,x,y)) = app("ASSIGN",[int ty,rexp x,rexp y])
153 :     | stm(T.JMP(e,_)) = app("JMP",[rexp e,Nil])
154 :     | stm(T.RET _) = app("RET",[Nil])
155 :     | stm(T.IF(x,y,z)) = app("IF",[ccexp x,stm y,stm z])
156 :     | stm(T.SEQ ss) = app("SEQ",[list(map stm ss,NONE)])
157 :     | stm(T.RTL{e, ...}) = stm e
158 :     | stm(T.CALL{funct,...}) = app("CALL",
159 :     [record[("defs",Nil),
160 :     ("uses",Nil),
161 :     ("funct",rexp funct),
162 :     ("targets",Nil),
163 :     ("region",region)]
164 :     ]
165 :     )
166 :     | stm s = error("transRTL: "^RTL.Util.stmToString s)
167 :    
168 :     and ccexp(T.CMP(ty,cc,x,y)) =
169 :     app("CMP",[int ty,id(T.Basis.condToString cc),rexp x,rexp y])
170 :     | ccexp(T.FCMP(ty,cc,x,y)) =
171 :     app("FCMP",[int ty,id(T.Basis.fcondToString cc),fexp x,fexp y])
172 :     | ccexp(T.TRUE) = id "TRUE"
173 :     | ccexp(T.FALSE) = id "FALSE"
174 :     | ccexp(T.AND(x,y)) = app("AND",[ccexp x,ccexp y])
175 :     | ccexp(T.OR(x,y)) = app("OR",[ccexp x,ccexp y])
176 :     | ccexp(T.XOR(x,y)) = app("XOR",[ccexp x,ccexp y])
177 :     | ccexp(T.EQV(x,y)) = app("EQV",[ccexp x,ccexp y])
178 :     | ccexp(T.NOT x) = app("NOT",[ccexp x])
179 :     | ccexp e = error("transRTL: "^RTL.Util.ccexpToString e)
180 :     in stm rtl
181 :     end
182 :    
183 :     (*========================================================================
184 :     * Translate an RTL to an expression
185 :     *========================================================================*)
186 :     fun rtlToExp rtl =
187 :     let fun id name = A.IDexp(A.IDENT(["T"],name))
188 :     fun app(n, es) = A.APPexp(id n, A.TUPLEexp es)
189 :     val int = U.INTexp
190 :     val string= U.STRINGexp
191 :     fun arg(ty,a,name) = A.IDexp(A.IDENT([],name))
192 :     fun cellkind k = A.IDexp(A.IDENT(["C"],CellsBasis.cellkindToString k))
193 :     fun oper(T.OPER{name,...}) = A.IDexp(A.IDENT(["P"],name))
194 :     val region=A.IDexp(A.IDENT(["T","Region"],"memory"))
195 :     in transRTL{id=id, app=app, list=A.LISTexp, string=string,
196 :     int=int, word32=U.WORD32exp, Nil=A.LISTexp([],NONE),
197 :     tuple=A.TUPLEexp, record=A.RECORDexp,
198 :     region=region, arg=arg, cellkind=cellkind, oper=oper
199 :     } rtl
200 :     end
201 :    
202 :     (*========================================================================
203 :     * Translate an RTL to a pattern
204 :     *========================================================================*)
205 :     fun rtlToPat rtl =
206 :     let fun mkId name = A.IDENT(["T"],name)
207 :     fun id name = A.CONSpat(mkId name,NONE)
208 :     fun app(n, [x]) = A.CONSpat(mkId n, SOME x)
209 :     | app(n, es) = A.CONSpat(mkId n, SOME(A.TUPLEpat es))
210 :     fun record ps = A.RECORDpat(ps,false)
211 :     val int = U.INTpat
212 :     val string= U.STRINGpat
213 :     fun arg(ty,a,name) = A.IDpat name
214 :     fun cellkind k = A.IDpat(CellsBasis.cellkindToString k)
215 :     fun oper(T.OPER{name,...}) =
216 :     A.CONSpat(A.IDENT(["T"],"OPER"),
217 :     SOME(A.RECORDpat([("name",U.STRINGpat name)],true)))
218 :     val region=A.WILDpat
219 :     in transRTL{id=id, app=app, list=A.LISTpat, string=string,
220 :     int=int, word32=U.WORD32pat, Nil=A.LISTpat([],NONE),
221 :     tuple=A.TUPLEpat, record=record, region=region,
222 :     arg=arg, cellkind=cellkind, oper=oper
223 :     } rtl
224 :     end
225 :    
226 :     (*========================================================================
227 :     * Translate an RTL to a function with arguments
228 :     *========================================================================*)
229 :     fun rtlToFun(rtlName, rtlArgs, rtl) =
230 :     let val body = rtlToExp rtl
231 :     val args = A.RECORDpat(map (fn id => (id,A.IDpat id)) rtlArgs,false)
232 :     in A.FUNdecl
233 :     [A.FUNbind(rtlName, [A.CLAUSE([args], NONE, body)])]
234 :     end
235 :    
236 :     (*========================================================================
237 :     * Create a new_op
238 :     *========================================================================*)
239 :     fun createNewOp{name, hash, attribs} =
240 :     A.VALdecl[
241 :     A.VALbind(A.IDpat name,
242 :     A.APPexp(A.IDexp(A.IDENT(["T"],"OPER")),
243 :     A.APPexp(A.IDexp(A.IDENT(["RTL"],"newOp")),
244 :     A.RECORDexp[("name",U.STRINGexp name),
245 :     ("attribs",U.WORDexp (!attribs))
246 :     ])))
247 :     ]
248 :    
249 :     end
250 :    

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