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

SCM Repository

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

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 3865, Mon May 16 16:32:19 2016 UTC revision 3866, Mon May 16 16:48:13 2016 UTC
# Line 1  Line 1 
1  (* tree-to-c.sml  (* tree-to-cxx.sml
2   *   *
3   * This code is part of the Diderot Project (http://diderot-language.cs.uchicago.edu)   * This code is part of the Diderot Project (http://diderot-language.cs.uchicago.edu)
4   *   *
5   * COPYRIGHT (c) 2016 The University of Chicago   * COPYRIGHT (c) 2016 The University of Chicago
6   * All rights reserved.   * All rights reserved.
7   *   *
8   * Translate TreeIR to the C version of CLang.   * Translate TreeIR to the C++ version of CLang.
9   *)   *)
10    
 structure PseudoVars =  
   struct  
 (* TreeIR "variables" that are used to get the names needed to access the  
  * global and strand state variables.  These are just used as keys to lookup  
  * the C names in the environment, so their kind and type are irrelevant.  
  *)  
     local  
       fun new name = TreeIR.Var.new (name, TreeIR.Ty.IntTy)  
     in  
     val selfIn = new "$selfIn"  
     val selfOut = new "$selfOut"  
     val global = new "$global"  
     end (* local *)  
   end  
11    
12  structure TreeToC : sig  structure TreeToCxx : sig
13    
14      type env = CLang.typed_var TreeIR.Var.Map.map      type env = CLang.typed_var TreeVar.Map.map
15    
16      val empty : env      val empty : env
17    
# Line 33  Line 19 
19    
20      val trBlock : env * TreeIR.block -> CLang.stm      val trBlock : env * TreeIR.block -> CLang.stm
21    
     val trFragment : env * TreeIR.block -> env * CLang.stm list  
   
22      val trExp : env * TreeIR.exp -> CLang.exp      val trExp : env * TreeIR.exp -> CLang.exp
23    
24    (* translate an expression to a variable form; return the variable (as an expresison)    (* translate an expression to a variable form; return the variable (as an expression)
25     * and the (optional) declaration.     * and the (optional) declaration.
26     *)     *)
27      val expToVar : env * CLang.ty * string * TreeIR.exp -> CLang.exp * CLang.stm list      val expToVar : env * CLang.ty * string * TreeIR.exp -> CLang.exp * CLang.stm list
# Line 50  Line 34 
34      structure IR = TreeIR      structure IR = TreeIR
35      structure Op = TreeOps      structure Op = TreeOps
36      structure Ty = TreeTypes      structure Ty = TreeTypes
37      structure V = IR.Var      structure V = TreeVar
38        structure VMap = VMap
39    
40      datatype var = datatype CL.typed_var      datatype var = datatype CL.typed_var
41      type env = CL.typed_var TreeIR.Var.Map.map      type env = CLang.typed_var VMap.map
42    
43      val empty = V.Map.empty      val empty = VMap.empty
44    
45      fun lookup (env, x) = (case V.Map.find (env, x)      fun lookup (env, x) = (case VMap.find (env, x)
46             of SOME(V(_, x')) => x'             of SOME(V(_, x')) => x'
47              | NONE => raise Fail(concat["lookup(_, ", V.name x, ")"])              | NONE => raise Fail(concat["lookup(_, ", V.name x, ")"])
48            (* end case *))            (* end case *))
49    
50        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    
60      (* 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    (* Translate a TreeIR operator application to a CLang expression *)    (* Translate a TreeIR operator application to a CLang expression *)
97      fun trOp (rator, args) = (case (rator, args)      fun trOp (rator, args) = (case (rator, args)
# Line 76  Line 106 
106              | (Op.RMul, [a, b]) => CL.mkBinOp(a, CL.#*, b)              | (Op.RMul, [a, b]) => CL.mkBinOp(a, CL.#*, b)
107              | (Op.RDiv, [a, b]) => CL.mkBinOp(a, CL.#/, b)              | (Op.RDiv, [a, b]) => CL.mkBinOp(a, CL.#/, b)
108              | (Op.RNeg, [a]) => CL.mkUnOp(CL.%-, a)              | (Op.RNeg, [a]) => CL.mkUnOp(CL.%-, a)
109                | (Op.RClamp, [a, b, c]) =>
110                | (Op.RLerp, [a, b, c]) =>
111              | (Op.LT ty, [a, b]) => CL.mkBinOp(a, CL.#<, b)              | (Op.LT ty, [a, b]) => CL.mkBinOp(a, CL.#<, b)
112              | (Op.LTE ty, [a, b]) => CL.mkBinOp(a, CL.#<=, b)              | (Op.LTE ty, [a, b]) => CL.mkBinOp(a, CL.#<=, b)
113              | (Op.EQ ty, [a, b]) => CL.mkBinOp(a, CL.#==, b)              | (Op.EQ ty, [a, b]) => CL.mkBinOp(a, CL.#==, b)
# Line 83  Line 115 
115              | (Op.GTE ty, [a, b]) => CL.mkBinOp(a, CL.#>=, b)              | (Op.GTE ty, [a, b]) => CL.mkBinOp(a, CL.#>=, b)
116              | (Op.GT ty, [a, b]) => CL.mkBinOp(a, CL.#>, b)              | (Op.GT ty, [a, b]) => CL.mkBinOp(a, CL.#>, b)
117              | (Op.Not, [a]) => CL.mkUnOp(CL.%!, a)              | (Op.Not, [a]) => CL.mkUnOp(CL.%!, a)
118              | (Op.Abs ty, []) =>              | (Op.Abs ty, args) => mkStdApply("abs", args)
119              | (Op.Max ty, []) =>              | (Op.Max ty, args) => mkStdApply("min", args)
120              | (Op.Min ty, []) =>              | (Op.Min ty, args) => mkStdApply("max", args)
121              | (Op.Clamp ty, []) =>              | (Op.VAdd d, [a, b]) => CL.mkBinOp(a, CL.#+, b)
122              | (Op.Lerp ty, []) =>              | (Op.VSub d, [a, b]) => CL.mkBinOp(a, CL.#-, b)
             | (Op.VAdd d, [a, b]) =>  
             | (Op.VSub d, [a, b]) =>  
123              | (Op.VScale d, [a, b]) =>              | (Op.VScale d, [a, b]) =>
124              | (Op.VMul d, [a, b]) =>              | (Op.VMul d, [a, b]) => CL.mkBinOp(a, CL.#*, b)
125              | (Op.VNeg d, [a]) =>              | (Op.VNeg d, [a]) => CL.mkUnOp(CL.%-, a)
126              | (Op.VSum d, [a]) =>              | (Op.VSum d, [a, b]) =>
127              | (Op.TensorIndex(ty * shape), []) =>              | (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              | (Op.EigenVecs2x2, []) =>              | (Op.EigenVecs2x2, []) =>
134              | (Op.EigenVecs3x3, []) =>              | (Op.EigenVecs3x3, []) =>
135              | (Op.EigenVals2x2, []) =>              | (Op.EigenVals2x2, []) =>
# Line 112  Line 147 
147              | (Op.Sqrt, []) =>              | (Op.Sqrt, []) =>
148              | (Op.Cos, []) =>              | (Op.Cos, []) =>
149              | (Op.ArcCos, []) =>              | (Op.ArcCos, []) =>
150              | (Op.Sine, []) =>              | (Op.Sin, []) =>
151              | (Op.ArcSin, []) =>              | (Op.ArcSin, []) =>
152              | (Op.Tan, []) =>              | (Op.Tan, []) =>
153              | (Op.ArcTan, []) =>              | (Op.ArcTan, []) =>
# Line 141  Line 176 
176              | (Op.ImageDim(ImageInfo.info * int), []) =>              | (Op.ImageDim(ImageInfo.info * int), []) =>
177              | (Op.LoadSeq(ty * string), []) =>              | (Op.LoadSeq(ty * string), []) =>
178              | (Op.LoadImage(ty * string), []) =>              | (Op.LoadImage(ty * string), []) =>
             | (Op.Print(tys), []) =>  
179              | (Op.MathFn f, args) => CL.mkApply(??, args)              | (Op.MathFn f, args) => CL.mkApply(??, args)
180                | _ => raise Fail(concat[
181                       "unknown or incorrect operator ", Op.toString rator
182                     ])
183            (* end case *))            (* end case *))
184    
185        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              fun mkExp (lhs, []) = CL.mkBinOp(lhs, CL.#<<, CL.mkVar "std::end")
204                | mkExp (lhs, e) = CL.mkBinOp(lhs, CL.#<<, trExp(env, e))
205              in
206                CL.mkExpStm (mkExp (CL.mkIndirect(CL.mkVar "wrld", "_output"), args))
207              end
208    
209        fun trLocals (env : env, locals) =
210              List.foldl
211                (fn (x, env) => VMap.insert(env, x, V(trType(V.ty x), V.name x)))
212                  env locals
213    
214        fun trStms (env, stms) = let
215              fun trStm (stm, (env, stms)) = (case stm
216                     of IR.S_Comment text => CL.mkComment text :: stms
217                      | IR.S_Assign(isDecl, x, exp) => let
218                          val (env, stm) = trAssign (env, lvalueVar (env, x), exp)
219                          in
220                            (env, stm::stms)
221                          end
222                      | IR.S_MAssign(xs, exp) =>
223                          (env, trMultiAssign (env, List.map (fn x => lvalueVar (env, x)) xs, exp) :: stms)
224                      | IR.S_GAssign(x, exp) =>
225                          (env, trAssign (env, lvalueGlobalVar (env, x), exp) :: stms)
226                      | IR.S_IfThen(cond, thenBlk) =>
227                          (env, CL.mkIfThen(trExp(env, cond), trBlk(env, thenBlk)) :: stms)
228                      | IR.S_IfThenElse(cond, thenBlk, elseBlk) => let
229                          val stm = CL.mkIfThenElse(trExp(env, cond),
230                                trBlk(env, thenBlk),
231                                trBlk(env, elseBlk))
232                          in
233                            (env, stm :: stms)
234                          end
235                      | IR.S_Foreach(x, IR.E_Op(Op.Range, [lo, hi]), blk) => ??
236                      | IR.S_Foreach(x, e, blk) => ??
237                      | IR.S_New(strand, args) => ??
238                      | IR.S_Save(x, exp) => trAssign (env, lvalueStateVar(env, x), exp)
239                      | IR.S_LoadNrrd(lhs, Ty.DynSeqTy ty, nrrd) =>
240                          [GenLoadNrrd.loadSeqFromFile (lvalueVar (env, lhs), ty, CL.mkStr nrrd)]
241                      | IR.S_LoadNrrd(lhs, Ty.ImageTy info, nrrd) =>
242                          [GenLoadNrrd.loadImage (lvalueVar (env, lhs), info, CL.mkStr nrrd)]
243                      | IR.S_Input(_, _, _, NONE) => []
244                      | IR.S_Input(gv, name, _, SOME dflt) => [
245                            CL.mkAssign(lvalueGlobalVar (env, gv), trExp(env, dflt))
246                          ]
247                      | IR.S_InputNrrd _ => (env, stms)
248                      | IR.S_Exit args => (env, stms)
249                      | IR.S_Print(tys, args) => ??
250                      | IR.S_Active => (env, CL.mkReturn(SOME(CL.mkVar RN.kActive)) :: stms)
251                      | IR.S_Stabilize => (env, CL.mkReturn(SOME(CL.mkVar RN.kStabilize)) :: stms)
252                      | IR.S_Die => (env, CL.mkReturn(SOME(CL.mkVar RN.kDie)) :: stms)
253                    (* end case *))
254              in
255                List.rev (#2 (List.foldl trStm (env, []) stms))
256              end
257    
258        and trBlock (env, IR.Block{locals, body}) = let
259              val env = trLocals (env, locals)
260              val stms = trStms (env, body)
261              fun mkDecl (x, stms) = (case VMap.find (env, x)
262                     of SOME(V(ty, x')) => CL.mkDecl(ty, x', NONE) :: stms
263                      | NONE => raise Fail(concat["mkDecl(", V.name x, ", _)"])
264                    (* end case *))
265              val stms = List.foldr mkDecl stms locals
266              in
267                CL.mkBlock stms
268              end
269    
270    end    end

Legend:
Removed from v.3865  
changed lines
  Added in v.3866

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