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 3900, Mon May 23 15:20:24 2016 UTC revision 3931, Sun Jun 5 14:13:21 2016 UTC
# Line 15  Line 15 
15    
16      val trBlock : CodeGenEnv.t * TreeIR.block -> CLang.stm      val trBlock : CodeGenEnv.t * TreeIR.block -> CLang.stm
17    
18        val trWithLocals : CodeGenEnv.t * TreeVar.t list * (CodeGenEnv.t -> CLang.stm list) -> CLang.stm
19    
20        val trStms : CodeGenEnv.t * TreeIR.stm list -> CodeGenEnv.t * CLang.stm list
21    
22      val trExp : CodeGenEnv.t * TreeIR.exp -> CLang.exp      val trExp : CodeGenEnv.t * TreeIR.exp -> CLang.exp
23    
24    (* translate an expression to a variable form; return the variable (as an expression)    (* translate an expression to a variable form; return the variable (as an expression)
# Line 25  Line 29 
29      val trAssign : CodeGenEnv.t * CLang.exp * TreeIR.exp -> CLang.stm list      val trAssign : CodeGenEnv.t * CLang.exp * TreeIR.exp -> CLang.stm list
30    
31    (* generate code to register an error message (require that a world pointer "wrld" is in scope) *)    (* generate code to register an error message (require that a world pointer "wrld" is in scope) *)
32      val errorMsgAdd : CLang.exp -> CLang.stm      val errorMsgAdd : CodeGenEnv.t * CLang.exp -> CLang.stm
33    
34        val trParam : CodeGenEnv.t * TreeIR.var -> CodeGenEnv.t * CLang.param
35    
36    end = struct    end = struct
37    
# Line 35  Line 41 
41      structure Ty = TreeTypes      structure Ty = TreeTypes
42      structure V = TreeVar      structure V = TreeVar
43      structure Env = CodeGenEnv      structure Env = CodeGenEnv
44        structure RN = CxxNames
45    
46      fun trType (env, ty) = (case ty      fun trType (env, ty) = (case ty
47             of Ty.BoolTy => CL.boolTy             of Ty.BoolTy => CL.boolTy
# Line 59  Line 66 
66      fun rvalueVar (env, x) = CL.mkVar(Env.lookup(env, x))      fun rvalueVar (env, x) = CL.mkVar(Env.lookup(env, x))
67    
68    (* translate a global variable that occurs in an l-value context *)    (* translate a global variable that occurs in an l-value context *)
69      fun lvalueGlobalVar (env, x) = CL.mkIndirect(CL.mkVar(Env.global env), TreeGlobalVar.name x)      fun lvalueGlobalVar (env, x) = CL.mkIndirect(CL.mkVar(Env.global env), TreeGlobalVar.qname x)
70    (* translate a global variable that occurs in an r-value context *)    (* translate a global variable that occurs in an r-value context *)
71      val rvalueGlobalVar = lvalueGlobalVar      val rvalueGlobalVar = lvalueGlobalVar
72    
73    (* translate a strand state variable that occurs in an l-value context *)    (* translate a strand state variable that occurs in an l-value context *)
74      fun lvalueStateVar (env, x) = CL.mkIndirect(CL.mkVar(Env.selfOut env), TreeStateVar.name x)      fun lvalueStateVar (env, x) = CL.mkIndirect(CL.mkVar(Env.selfOut env), TreeStateVar.qname x)
75    (* translate a strand state variable that occurs in an r-value context *)    (* translate a strand state variable that occurs in an r-value context *)
76      fun rvalueStateVar (env, x) = CL.mkIndirect(CL.mkVar(Env.selfIn env), TreeStateVar.name x)      fun rvalueStateVar (env, x) = CL.mkIndirect(CL.mkVar(Env.selfIn env), TreeStateVar.qname x)
77    
78        fun worldVar env = CL.mkVar(Env.world env)
79    
80    (* generate new variables *)    (* generate new variables *)
81      local      val freshVar = CodeGenUtil.freshVar
       val count = ref 0  
       fun freshName prefix = let  
             val n = !count  
             in  
               count := n+1;  
               concat[prefix, "_", Int.toString n]  
             end  
     in  
     fun tmpVar () = freshName "tmp"  
     fun freshVar prefix = freshName prefix  
     end (* local *)  
82    
83    (* integer literal expression *)    (* integer literal expression *)
84      fun intExp (i : int) = CL.mkInt(IntInf.fromInt i)      fun intExp (i : int) = CL.mkInt(IntInf.fromInt i)
# Line 131  Line 129 
129              | (Op.VScale d, [a, b]) => CL.mkApply("vscale", [a, b])              | (Op.VScale d, [a, b]) => CL.mkApply("vscale", [a, b])
130              | (Op.VMul d, [a, b]) => CL.mkBinOp(a, CL.#*, b)              | (Op.VMul d, [a, b]) => CL.mkBinOp(a, CL.#*, b)
131              | (Op.VNeg d, [a]) => CL.mkUnOp(CL.%-, a)              | (Op.VNeg d, [a]) => CL.mkUnOp(CL.%-, a)
132              | (Op.VSum d, [a]) => CL.mkApply("vsum", [a])              | (Op.VSum(w, _), [a]) => CL.mkApply(RN.vsum w, [a])
133              | (Op.VIndex(w, p, i), [a]) => CL.mkSubscript(a, intExp i)              | (Op.VIndex(w, p, i), [a]) => CL.mkSubscript(a, intExp i)
134              | (Op.VClamp d, [a, b, c]) => CL.mkApply("vclamp", [a, b, c])              | (Op.VClamp(w, _), [a, b, c]) => CL.mkApply("vclamp", [a, b, c])
135              | (Op.VMapClamp d, [a, b, c]) => CL.mkApply("vclamp", [a, b, c])              | (Op.VMapClamp(w, _), [a, b, c]) => CL.mkApply("vclamp", [a, b, c])
136              | (Op.VLerp d, [a, b, c]) => CL.mkApply("vlerp", [a, b, c])              | (Op.VLerp(w, _), [a, b, c]) => CL.mkApply("vlerp", [a, b, c])
137              | (Op.VCeiling d, [a]) => CL.mkApply("vceiling", [a])              | (Op.VCeiling d, [a]) => CL.mkApply("vceiling", [a])
138              | (Op.VFloor d, [a]) => CL.mkApply("vfloor", [a])              | (Op.VFloor d, [a]) => CL.mkApply("vfloor", [a])
139              | (Op.VRound d, [a]) => CL.mkApply("vround", [a])              | (Op.VRound d, [a]) => CL.mkApply("vround", [a])
# Line 190  Line 188 
188              | (Op.BaseAddress info, [img]) => CL.mkDispatch(img, "base_addr", [])              | (Op.BaseAddress info, [img]) => CL.mkDispatch(img, "base_addr", [])
189              | (Op.ControlIndex(info, ctl, d), [img, idx]) =>              | (Op.ControlIndex(info, ctl, d), [img, idx]) =>
190                  CL.mkDispatch(img, IndexCtl.toString ctl, [intExp d, idx])                  CL.mkDispatch(img, IndexCtl.toString ctl, [intExp d, idx])
191                | (Op.LoadVoxel info, [addr, offp]) => let
192                    val voxel = CL.mkSubscript(addr, offp)
193                    in
194                      if RawTypes.same(ImageInfo.sampleTy info, Env.rawRealTy env)
195                        then voxel
196                        else CL.mkStaticCast(Env.realTy env, voxel)
197                    end
198              | (Op.Inside(info, s), [pos, img]) => CL.mkDispatch(img, "inside", [pos, intExp s])              | (Op.Inside(info, s), [pos, img]) => CL.mkDispatch(img, "inside", [pos, intExp s])
199              | (Op.ImageDim(info, i), [img]) => CL.mkDispatch(img, "size", [intExp i])              | (Op.ImageDim(info, i), [img]) => CL.mkDispatch(img, "size", [intExp i])
200              | (Op.MathFn f, args) => mkStdApply(MathFns.toString f, args)              | (Op.MathFn f, args) => mkStdApply(MathFns.toString f, args)
# Line 208  Line 213 
213              | IR.E_Lit(Literal.Real f) => CL.mkFlt(f, Env.realTy env)              | IR.E_Lit(Literal.Real f) => CL.mkFlt(f, Env.realTy env)
214              | IR.E_Lit(Literal.String s) => CL.mkStr s              | IR.E_Lit(Literal.String s) => CL.mkStr s
215              | IR.E_Op(rator, args) => trOp (env, rator, trExps(env, args))              | IR.E_Op(rator, args) => trOp (env, rator, trExps(env, args))
216              | IR.E_Vec(w, pw, args) => let              | IR.E_Vec(w, pw, args) => CL.mkApply(RN.vcons w, trExps (env, args))
                 val args = trExps (env, args)  
                 val args = if (w < pw) then args @ List.tabulate(pw-w, fn _ => zero) else args  
                 in  
                   CL.mkVec(CL.T_Named("vec" ^ Int.toString pw), args)  
                 end  
217              | IR.E_Cons(args, Ty.TensorTy shape) => raise Fail "unexpected E_Cons"              | IR.E_Cons(args, Ty.TensorTy shape) => raise Fail "unexpected E_Cons"
218              | IR.E_Seq(args, ty) => raise Fail "unexpected E_Seq"              | IR.E_Seq(args, ty) => raise Fail "unexpected E_Seq"
219              | IR.E_Pack(layout, args) => raise Fail "unexpected E_Pack"              | IR.E_Pack(layout, args) => raise Fail "unexpected E_Pack"
220  (* FIXME: check if e is aligned and use "vload_aligned" in that case *)  (* FIXME: check if e is aligned and use "vload_aligned" in that case *)
221              | IR.E_VLoad(layout, e, i) =>              | IR.E_VLoad(layout, e, i) =>
222                  CL.mkTemplateApply("vload",                  CL.mkApply(RN.vload(Ty.nthWidth(layout, i)),
                   [trType(env, Ty.nthVec(layout, i))],  
223                    [CL.mkBinOp(trExp(env, e), CL.#+, intExp(Ty.offsetOf(layout, i)))])                    [CL.mkBinOp(trExp(env, e), CL.#+, intExp(Ty.offsetOf(layout, i)))])
224              | _ => raise Fail "trExp"              | _ => raise Fail "trExp"
225            (* end case *))            (* end case *))
# Line 241  Line 240 
240            fun trArg (i, arg) = CL.mkAssign(CL.mkSubscript(lhs, intExp i), trExp (env, arg))            fun trArg (i, arg) = CL.mkAssign(CL.mkSubscript(lhs, intExp i), trExp (env, arg))
241            in            in
242              case rhs              case rhs
243               of IR.E_Pack(_, args) => [CL.mkCall ("vpack", List.map (fn e => trExp(env, e)) args)]               of IR.E_Pack({wid, ...}, args) => [
244                        CL.mkCall (RN.vpack wid, lhs :: List.map (fn e => trExp(env, e)) args)
245                      ]
246                | IR.E_Cons(args, _) => List.mapi trArg args                | IR.E_Cons(args, _) => List.mapi trArg args
247                | IR.E_Seq(args, _) => List.mapi trArg args                | IR.E_Seq(args, _) => List.mapi trArg args
248                | _ => [CL.mkAssign(lhs, trExp (env, rhs))]                | _ => [CL.mkAssign(lhs, trExp (env, rhs))]
# Line 268  Line 269 
269            (* end case *))            (* end case *))
270        | trMultiAssign (env, lhs, rhs) = raise Fail "bogus multi-assignment"        | trMultiAssign (env, lhs, rhs) = raise Fail "bogus multi-assignment"
271    
272        fun trPrintStm (outS, tys, args) = let
273              fun mkExp (lhs, [], []) = CL.mkBinOp(lhs, CL.#<<, CL.mkVar "std::end")
274                | mkExp (lhs, ty::tys, e::es) = let
275                  (* if necessary, wrap the argument so that the correct "<<" instance is used *)
276                    val e = (case ty
277                           of Ty.TensorTy shape => CL.mkApply(RN.tensorStruct shape, [e])
278                            | _ => e
279                          (* end case *))
280                    in
281                      mkExp (CL.mkBinOp(lhs, CL.#<<, e), tys, es)
282                    end
283                | mkExp _ = raise Fail "trPrintStm: arity mismatch"
284              in
285                CL.mkExpStm (mkExp (outS, tys, args))
286              end
287    
288      fun trStms (env, stms : TreeIR.stm list) = let      fun trStms (env, stms : TreeIR.stm list) = let
289            fun trStm (stm, (env, stms : CL.stm list)) = (case stm            fun trStm (stm, (env, stms : CL.stm list)) = (case stm
290                   of IR.S_Comment text => (env, CL.mkComment text :: stms)                   of IR.S_Comment text => (env, CL.mkComment text :: stms)
# Line 296  Line 313 
313                        in                        in
314                          (env, stm :: stms)                          (env, stm :: stms)
315                        end                        end
316                    | IR.S_Foreach(x, IR.E_Op(Op.Range, [lo, hi]), blk) => let                    | IR.S_For(x, lo, hi, blk) => let
317                        val x' = V.name x                        val x' = V.name x
318                        val env' = Env.insert (env, x, x')                        val env' = Env.insert (env, x, x')
319                        val (hi', hiInit) = if CodeGenUtil.isSimple hi                        val (hi', hiInit) = if CodeGenUtil.isSimple hi
# Line 315  Line 332 
332                          (env, hiInit @ loop :: stms)                          (env, hiInit @ loop :: stms)
333                        end                        end
334                    | IR.S_Foreach(x, e, blk) => raise Fail "Foreach"                    | IR.S_Foreach(x, e, blk) => raise Fail "Foreach"
335                    | IR.S_New(strand, args) => raise Fail "New"                    | IR.S_New(strand, args) => let
336                    | IR.S_Save(x, exp) => (env, trAssign (env, lvalueStateVar(env, x), exp))                        val args = List.map (fn e => trExp(env, e)) args
337                          val stm = CL.mkCall(
338                                Atom.toString strand ^ "_new",
339                                worldVar env :: args)
340                          in
341                            (env, stm :: stms)
342                          end
343                      | IR.S_Save(x, exp) => (env, trAssign (env, lvalueStateVar(env, x), exp) @ stms)
344                    | IR.S_LoadNrrd(lhs, ty, nrrd) => let                    | IR.S_LoadNrrd(lhs, ty, nrrd) => let
345                        val stm = (case ty                        val stm = (case ty
346                               of APITypes.SeqTy(ty, NONE) =>                               of APITypes.SeqTy(ty, NONE) =>
# Line 337  Line 361 
361                    | IR.S_Exit => (env, stms)                    | IR.S_Exit => (env, stms)
362                    | IR.S_Print(tys, args) => let                    | IR.S_Print(tys, args) => let
363                        val args = List.map (fn e => trExp(env, e)) args                        val args = List.map (fn e => trExp(env, e)) args
364                        val stm = GenPrint.genPrintStm (                        val stm = trPrintStm (
365                              CL.mkIndirect(CL.mkVar "wrld", "_output"),                              CL.mkIndirect(worldVar env, "_output"),
366                              tys, args)                              tys, args)
367                        in                        in
368                          (env, stm::stms)                          (env, stm::stms)
# Line 347  Line 371 
371                    | IR.S_Stabilize => (env, CL.mkReturn(SOME(CL.mkVar "diderot::kStabilize")) :: stms)                    | IR.S_Stabilize => (env, CL.mkReturn(SOME(CL.mkVar "diderot::kStabilize")) :: stms)
372                    | IR.S_Die => (env, CL.mkReturn(SOME(CL.mkVar "diderot::kDie")) :: stms)                    | IR.S_Die => (env, CL.mkReturn(SOME(CL.mkVar "diderot::kDie")) :: stms)
373                  (* end case *))                  (* end case *))
374              val (env, stms) = List.foldl trStm (env, []) stms
375            in            in
376              List.rev (#2 (List.foldl trStm (env, []) stms))              (env, List.rev stms)
377            end            end
378    
379      and trBlock (env, IR.Block{locals, body}) = let      and trBlock (env, IR.Block{locals, body}) = let
# Line 359  Line 384 
384                    (Env.insert(env, x, x'), dcl :: dcls)                    (Env.insert(env, x, x'), dcl :: dcls)
385                  end                  end
386            val (env, dcls) = List.foldl trLocal (env, []) (!locals)            val (env, dcls) = List.foldl trLocal (env, []) (!locals)
387              val (_, stms) = trStms (env, body)
388              in
389                CL.mkBlock (dcls @ stms)
390              end
391    
392        and trWithLocals (env, locals, trBody) = let
393              fun trLocal (x, (env, dcls)) = let
394                    val x' = V.name x
395                    val dcl = CL.mkDecl(trType(env, V.ty x), x', NONE)
396                    in
397                      (Env.insert(env, x, x'), dcl :: dcls)
398                    end
399              val (env, dcls) = List.foldl trLocal (env, []) locals
400            in            in
401              CL.mkBlock (dcls @ trStms (env, body))              CL.mkBlock (dcls @ trBody env)
402            end            end
403    
404      fun errorMsgAdd msg =      fun errorMsgAdd (env, msg) =
405            CL.mkCall("biffMsgAdd", [CL.mkIndirect(CL.mkVar "wrld", "_errors"), msg])            CL.mkCall("biffMsgAdd", [CL.mkIndirect(worldVar env, "_errors"), msg])
406    
407        fun trParam (env, x)= let
408              val x' = V.name x
409              in
410                (Env.insert (env, x, x'), CL.PARAM([], trType(env, V.ty x), x'))
411              end
412    
413    end    end

Legend:
Removed from v.3900  
changed lines
  Added in v.3931

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