Home My Page Projects Code Snippets Project Openings diderot
Summary Activity Tracker Tasks SCM

SCM Repository

[diderot] Annotation of /branches/vis15/src/compiler/cxx-util/tree-to-cxx.sml
ViewVC logotype

Annotation of /branches/vis15/src/compiler/cxx-util/tree-to-cxx.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3869 - (view) (download)
Original Path: branches/vis15/src/compiler/c-util/tree-to-c.sml

1 : jhr 3866 (* tree-to-cxx.sml
2 : jhr 3768 *
3 :     * This code is part of the Diderot Project (http://diderot-language.cs.uchicago.edu)
4 :     *
5 :     * COPYRIGHT (c) 2016 The University of Chicago
6 :     * All rights reserved.
7 :     *
8 : jhr 3866 * Translate TreeIR to the C++ version of CLang.
9 : jhr 3768 *)
10 :    
11 :    
12 : jhr 3866 structure TreeToCxx : sig
13 : jhr 3768
14 : jhr 3866 type env = CLang.typed_var TreeVar.Map.map
15 : jhr 3768
16 :     val empty : env
17 :    
18 : jhr 3810 val trType : TreeTypes.t -> CLang.ty
19 : jhr 3768
20 : jhr 3810 val trBlock : env * TreeIR.block -> CLang.stm
21 : jhr 3768
22 : jhr 3810 val trExp : env * TreeIR.exp -> CLang.exp
23 : jhr 3768
24 : jhr 3866 (* translate an expression to a variable form; return the variable (as an expression)
25 : jhr 3768 * and the (optional) declaration.
26 :     *)
27 : jhr 3810 val expToVar : env * CLang.ty * string * TreeIR.exp -> CLang.exp * CLang.stm list
28 : jhr 3768
29 : jhr 3810 val trAssign : env * CLang.exp * TreeIR.exp -> CLang.stm list
30 : jhr 3768
31 :     end = struct
32 :    
33 :     structure CL = CLang
34 :     structure IR = TreeIR
35 :     structure Op = TreeOps
36 :     structure Ty = TreeTypes
37 : jhr 3866 structure V = TreeVar
38 :     structure VMap = VMap
39 : jhr 3768
40 :     datatype var = datatype CL.typed_var
41 : jhr 3866 type env = CLang.typed_var VMap.map
42 : jhr 3768
43 : jhr 3866 val empty = VMap.empty
44 : jhr 3768
45 : jhr 3866 fun lookup (env, x) = (case VMap.find (env, x)
46 : jhr 3768 of SOME(V(_, x')) => x'
47 :     | NONE => raise Fail(concat["lookup(_, ", V.name x, ")"])
48 :     (* end case *))
49 :    
50 : jhr 3866 local
51 :     fun global env = CL.mkVar(lookup(env, PseudoVars.global))
52 :     fun selfIn env = CL.mkVar(lookup(env, PseudoVars.selfIn))
53 :     fun selfOut env = CL.mkVar(lookup(env, PseudoVars.selfOut))
54 :     in
55 :     (* translate a local variable that occurs in an l-value context *)
56 :     fun lvalueVar (env, x) = CL.mkVar(lookup(env, x))
57 :     (* translate a variable that occurs in an r-value context *)
58 :     fun rvalueVar (env, x) = CL.mkVar(lookup(env, x))
59 : jhr 3768
60 : jhr 3866 (* translate a global variable that occurs in an l-value context *)
61 :     fun lvalueGlobalVar (env, x) = CL.mkIndirect(global env, TreeGlobalVar.name x)
62 :     (* translate a global variable that occurs in an r-value context *)
63 :     val rvalueGlobalVar = lvalueGlobalVar
64 :    
65 :     (* translate a strand state variable that occurs in an l-value context *)
66 :     fun lvalueStateVar (env, x) = CL.mkIndirect(selfOut env, TreeStateVar.name x)
67 :     (* translate a strand state variable that occurs in an r-value context *)
68 :     fun rvalueStateVar (env, x) = CL.mkIndirect(selfIn env, TreeStateVar.name x)
69 :     end (* local *)
70 :    
71 :     (* generate new variables *)
72 :     local
73 :     val count = ref 0
74 :     fun freshName prefix = let
75 :     val n = !count
76 :     in
77 :     count := n+1;
78 :     concat[prefix, "_", Int.toString n]
79 :     end
80 :     in
81 :     fun tmpVar () = freshName "tmp"
82 :     fun freshVar prefix = freshName prefix
83 :     end (* local *)
84 :    
85 :     (* integer literal expression *)
86 :     fun intExp (i : int) = CL.mkInt(IntInf.fromInt i)
87 :    
88 :     fun addrOf e = CL.mkUnOp(CL.%&, e)
89 :    
90 :     (* make an application of a function from the "std" namespace *)
91 :     fun mkStdApply (f, args) = CL.mkApply("std::" ^ f, args)
92 :    
93 :     (* make an application of a function from the "diderot" namespace *)
94 :     fun mkDiderotApply (f, args) = CL.mkApply("diderot::" ^ f, args)
95 :    
96 : jhr 3810 (* Translate a TreeIR operator application to a CLang expression *)
97 : jhr 3768 fun trOp (rator, args) = (case (rator, args)
98 :     | (Op.IAdd, [a, b]) => CL.mkBinOp(a, CL.#+, b)
99 :     | (Op.ISub, [a, b]) => CL.mkBinOp(a, CL.#-, b)
100 :     | (Op.IMul, [a, b]) => CL.mkBinOp(a, CL.#*, b)
101 :     | (Op.IDiv, [a, b]) => CL.mkBinOp(a, CL.#/, b)
102 :     | (Op.IMod, [a, b]) => CL.mkBinOp(a, CL.#%, b)
103 :     | (Op.INeg, [a]) => CL.mkUnOp(CL.%-, a)
104 :     | (Op.RAdd, [a, b]) => CL.mkBinOp(a, CL.#+, b)
105 :     | (Op.RSub, [a, b]) => CL.mkBinOp(a, CL.#-, b)
106 :     | (Op.RMul, [a, b]) => CL.mkBinOp(a, CL.#*, b)
107 :     | (Op.RDiv, [a, b]) => CL.mkBinOp(a, CL.#/, b)
108 :     | (Op.RNeg, [a]) => CL.mkUnOp(CL.%-, a)
109 : jhr 3866 | (Op.RClamp, [a, b, c]) =>
110 :     | (Op.RLerp, [a, b, c]) =>
111 : jhr 3768 | (Op.LT ty, [a, b]) => CL.mkBinOp(a, CL.#<, b)
112 :     | (Op.LTE ty, [a, b]) => CL.mkBinOp(a, CL.#<=, b)
113 :     | (Op.EQ ty, [a, b]) => CL.mkBinOp(a, CL.#==, b)
114 :     | (Op.NEQ ty, [a, b]) => CL.mkBinOp(a, CL.#!=, b)
115 :     | (Op.GTE ty, [a, b]) => CL.mkBinOp(a, CL.#>=, b)
116 :     | (Op.GT ty, [a, b]) => CL.mkBinOp(a, CL.#>, b)
117 :     | (Op.Not, [a]) => CL.mkUnOp(CL.%!, a)
118 : jhr 3866 | (Op.Abs ty, args) => mkStdApply("abs", args)
119 :     | (Op.Max ty, args) => mkStdApply("min", args)
120 :     | (Op.Min ty, args) => mkStdApply("max", args)
121 :     | (Op.VAdd d, [a, b]) => CL.mkBinOp(a, CL.#+, b)
122 :     | (Op.VSub d, [a, b]) => CL.mkBinOp(a, CL.#-, b)
123 : jhr 3768 | (Op.VScale d, [a, b]) =>
124 : jhr 3866 | (Op.VMul d, [a, b]) => CL.mkBinOp(a, CL.#*, b)
125 :     | (Op.VNeg d, [a]) => CL.mkUnOp(CL.%-, a)
126 :     | (Op.VSum d, [a, b]) =>
127 :     | (Op.VIndex(d, i), [a]) =>
128 :     | (Op.VClamp d, [a, b, c]) =>
129 :     | (Op.VMapClamp d, [a, b, c]) =>
130 :     | (Op.VLerp d, [a, b, c]) =>
131 :     | (Op.TensorIndex(ty, idxs), [a]) =>
132 :     | (Op.ProjectLast(ty, idxs), [a]) =>
133 : jhr 3768 | (Op.EigenVecs2x2, []) =>
134 :     | (Op.EigenVecs3x3, []) =>
135 :     | (Op.EigenVals2x2, []) =>
136 :     | (Op.EigenVals3x3, []) =>
137 :     | (Op.Zero ty, []) =>
138 :     | (Op.Select(ty * int), []) =>
139 :     | (Op.Subscript ty, []) =>
140 :     | (Op.MkDynamic(ty * int), []) =>
141 :     | (Op.Append ty, []) =>
142 :     | (Op.Prepend ty, []) =>
143 :     | (Op.Concat ty, []) =>
144 :     | (Op.Range, []) =>
145 :     | (Op.Length ty, []) =>
146 :     | (Op.SphereQuery(ty * ty), []) =>
147 :     | (Op.Sqrt, []) =>
148 :     | (Op.Cos, []) =>
149 :     | (Op.ArcCos, []) =>
150 : jhr 3866 | (Op.Sin, []) =>
151 : jhr 3768 | (Op.ArcSin, []) =>
152 :     | (Op.Tan, []) =>
153 :     | (Op.ArcTan, []) =>
154 :     | (Op.Exp, []) =>
155 :     | (Op.Ceiling d, []) =>
156 :     | (Op.Floor d, []) =>
157 :     | (Op.Round d, []) =>
158 :     | (Op.Trunc d, []) =>
159 :     | (Op.IntToReal, []) =>
160 :     | (Op.RealToInt d, []) =>
161 :     (*
162 :     | R_All of ty
163 :     | R_Exists of ty
164 :     | R_Max of ty
165 :     | R_Min of ty
166 :     | R_Sum of ty
167 :     | R_Product of ty
168 :     | R_Mean of ty
169 :     | R_Variance of ty
170 :     *)
171 :     | (Op.Transform(ImageInfo.info * int), []) =>
172 :     | (Op.Translate(ImageInfo.info), []) =>
173 :     | (Op.BaseAddress(ImageInfo.info), []) =>
174 :     | (Op.ControlIndex(ImageInfo.info * idxctl * int), []) =>
175 :     | (Op.Inside(ImageInfo.info * int), []) =>
176 :     | (Op.ImageDim(ImageInfo.info * int), []) =>
177 :     | (Op.LoadSeq(ty * string), []) =>
178 :     | (Op.LoadImage(ty * string), []) =>
179 :     | (Op.MathFn f, args) => CL.mkApply(??, args)
180 : jhr 3866 | _ => raise Fail(concat[
181 :     "unknown or incorrect operator ", Op.toString rator
182 :     ])
183 : jhr 3768 (* end case *))
184 :    
185 : jhr 3866 fun trExp (env, e) = (case e
186 :     of IR.E_Global x => rvalueGlobalVar (env, x)
187 :     | IR.E_State x => rvalueStateVar (env, x)
188 :     | IR.E_Var x => rvalueVar (env, x)
189 :     | IR.E_Lit(Literal.Int n) => CL.mkIntTy(n, !CTyN.gIntTy)
190 :     | IR.E_Lit(Literal.Bool b) => CL.mkBool b
191 :     | IR.E_Lit(Literal.Float f) => CL.mkFlt(f, !CTyN.gRealTy)
192 :     | IR.E_Lit(Literal.String s) => CL.mkStr s
193 :     | IR.E_Op(rator, args) => trOp (rator, trExps(env, args))
194 :     | IR.E_Apply(f, args) => trApply(f, trExps(env, args))
195 :     | IR.E_Cons(Ty.TensorTy[n], args) => CL.mkApply(MathN.mkVec n, trExps(env, args))
196 :     | IR.E_Cons(ty, _) => raise Fail(concat["E_Cons(", Ty.toString ty, ", _) in expression"])
197 :     (* end case *))
198 :    
199 :     and trExps (env, exps) = List.map (fn exp => trExp(env, exp)) exps
200 :    
201 :     (* translate a print expression *)
202 :     fun trPrint (env, tys, args) = let
203 : jhr 3869 val args = List.map (fn e => trExp(env, e)) args
204 : jhr 3866 in
205 : jhr 3869 GenPrint.genPrintStm (CL.mkIndirect(CL.mkVar "wrld", "_output"), tys, args)
206 : jhr 3866 end
207 :    
208 :     fun trLocals (env : env, locals) =
209 :     List.foldl
210 :     (fn (x, env) => VMap.insert(env, x, V(trType(V.ty x), V.name x)))
211 :     env locals
212 :    
213 :     fun trStms (env, stms) = let
214 :     fun trStm (stm, (env, stms)) = (case stm
215 :     of IR.S_Comment text => CL.mkComment text :: stms
216 :     | IR.S_Assign(isDecl, x, exp) => let
217 :     val (env, stm) = trAssign (env, lvalueVar (env, x), exp)
218 :     in
219 :     (env, stm::stms)
220 :     end
221 :     | IR.S_MAssign(xs, exp) =>
222 :     (env, trMultiAssign (env, List.map (fn x => lvalueVar (env, x)) xs, exp) :: stms)
223 :     | IR.S_GAssign(x, exp) =>
224 :     (env, trAssign (env, lvalueGlobalVar (env, x), exp) :: stms)
225 :     | IR.S_IfThen(cond, thenBlk) =>
226 :     (env, CL.mkIfThen(trExp(env, cond), trBlk(env, thenBlk)) :: stms)
227 :     | IR.S_IfThenElse(cond, thenBlk, elseBlk) => let
228 :     val stm = CL.mkIfThenElse(trExp(env, cond),
229 :     trBlk(env, thenBlk),
230 :     trBlk(env, elseBlk))
231 :     in
232 :     (env, stm :: stms)
233 :     end
234 :     | IR.S_Foreach(x, IR.E_Op(Op.Range, [lo, hi]), blk) => ??
235 :     | IR.S_Foreach(x, e, blk) => ??
236 :     | IR.S_New(strand, args) => ??
237 :     | IR.S_Save(x, exp) => trAssign (env, lvalueStateVar(env, x), exp)
238 :     | IR.S_LoadNrrd(lhs, Ty.DynSeqTy ty, nrrd) =>
239 :     [GenLoadNrrd.loadSeqFromFile (lvalueVar (env, lhs), ty, CL.mkStr nrrd)]
240 :     | IR.S_LoadNrrd(lhs, Ty.ImageTy info, nrrd) =>
241 :     [GenLoadNrrd.loadImage (lvalueVar (env, lhs), info, CL.mkStr nrrd)]
242 :     | IR.S_Input(_, _, _, NONE) => []
243 :     | IR.S_Input(gv, name, _, SOME dflt) => [
244 :     CL.mkAssign(lvalueGlobalVar (env, gv), trExp(env, dflt))
245 :     ]
246 :     | IR.S_InputNrrd _ => (env, stms)
247 :     | IR.S_Exit args => (env, stms)
248 :     | IR.S_Print(tys, args) => ??
249 :     | IR.S_Active => (env, CL.mkReturn(SOME(CL.mkVar RN.kActive)) :: stms)
250 :     | IR.S_Stabilize => (env, CL.mkReturn(SOME(CL.mkVar RN.kStabilize)) :: stms)
251 :     | IR.S_Die => (env, CL.mkReturn(SOME(CL.mkVar RN.kDie)) :: stms)
252 :     (* end case *))
253 :     in
254 :     List.rev (#2 (List.foldl trStm (env, []) stms))
255 :     end
256 :    
257 :     and trBlock (env, IR.Block{locals, body}) = let
258 :     val env = trLocals (env, locals)
259 :     val stms = trStms (env, body)
260 :     fun mkDecl (x, stms) = (case VMap.find (env, x)
261 :     of SOME(V(ty, x')) => CL.mkDecl(ty, x', NONE) :: stms
262 :     | NONE => raise Fail(concat["mkDecl(", V.name x, ", _)"])
263 :     (* end case *))
264 :     val stms = List.foldr mkDecl stms locals
265 :     in
266 :     CL.mkBlock stms
267 :     end
268 :    
269 : jhr 3768 end

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