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

SCM Repository

[diderot] Diff of /branches/vis12-cl/src/compiler/c-util/tree-to-c.sml
ViewVC logotype

Diff of /branches/vis12-cl/src/compiler/c-util/tree-to-c.sml

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

revision 1690, Wed Jan 25 21:09:26 2012 UTC revision 1858, Fri Apr 20 20:14:41 2012 UTC
# Line 55  Line 55 
55    (* integer literal expression *)    (* integer literal expression *)
56      fun intExp (i : int) = CL.mkInt(IntInf.fromInt i)      fun intExp (i : int) = CL.mkInt(IntInf.fromInt i)
57    
58        fun addrOf e = CL.mkUnOp(CL.%&, e)
59    
60    (* translate TreeIL types to CLang types *)    (* translate TreeIL types to CLang types *)
61      fun trType ty = (case ty      val trType = CTyTranslate.toType
            of Ty.BoolTy => CLang.T_Named "bool"  
             | Ty.StringTy => CL.charPtr  
             | Ty.IntTy => !N.gIntTy  
             | Ty.TensorTy[] => !N.gRealTy  
             | Ty.TensorTy[n] => CL.T_Named(N.vecTy n)  
             | Ty.TensorTy[n, m] => CL.T_Named(N.matTy(n,m))  
             | Ty.SeqTy(Ty.IntTy, n) => CL.T_Named(N.ivecTy n)  
             | Ty.SeqTy(ty, n) => CL.T_Array(trType ty, SOME n)  
             | Ty.DynSeqTy _ => CL.T_Named N.dynSeqTy  
             | Ty.AddrTy(ImageInfo.ImgInfo{ty=(_, rTy), ...}) => CL.T_Ptr(CL.T_Num rTy)  
             | Ty.ImageTy(ImageInfo.ImgInfo{dim, ...}) => CL.T_Ptr(CL.T_Named(N.imageTy dim))  
             | _ => raise Fail(concat["TreeToC.trType(", Ty.toString ty, ")"])  
           (* end case *))  
62    
63    (* generate new variables *)    (* generate new variables *)
64      local      local
# Line 106  Line 95 
95    
96    (* vector indexing support.  Arguments are: vector, arity, index *)    (* vector indexing support.  Arguments are: vector, arity, index *)
97      fun ivecIndex (v, n, ix) = let      fun ivecIndex (v, n, ix) = let
98            val unionTy = CL.T_Named(concat["union", Int.toString n, !N.gIntSuffix, "_t"])            val e1 = CL.mkCast(CL.T_Named(N.iunionTy n), v)
           val e1 = CL.mkCast(unionTy, v)  
99            val e2 = CL.mkSelect(e1, "i")            val e2 = CL.mkSelect(e1, "i")
100            in            in
101              CL.mkSubscript(e2, intExp ix)              CL.mkSubscript(e2, intExp ix)
102            end            end
103    
104      fun vecIndex (v, n, ix) = let      fun vecIndex (v, n, ix) = let
105            val unionTy = CL.T_Named(concat["union", Int.toString n, !N.gRealSuffix, "_t"])            val e1 = CL.mkCast(CL.T_Named(N.unionTy n), v)
           val e1 = CL.mkCast(unionTy, v)  
106            val e2 = CL.mkSelect(e1, "r")            val e2 = CL.mkSelect(e1, "r")
107            in            in
108              CL.mkSubscript(e2, intExp ix)              CL.mkSubscript(e2, intExp ix)
# Line 176  Line 163 
163              | (Op.Index(Ty.SeqTy(Ty.IntTy, n), i), [a]) => ivecIndex (a, n, i)              | (Op.Index(Ty.SeqTy(Ty.IntTy, n), i), [a]) => ivecIndex (a, n, i)
164              | (Op.Index(Ty.TensorTy[n], i), [a]) => vecIndex (a, n, i)              | (Op.Index(Ty.TensorTy[n], i), [a]) => vecIndex (a, n, i)
165              | (Op.Subscript(Ty.SeqTy(Ty.IntTy, n)), [v, ix]) => let              | (Op.Subscript(Ty.SeqTy(Ty.IntTy, n)), [v, ix]) => let
166                  val unionTy = CL.T_Named(concat["union", Int.toString n, !N.gIntSuffix, "_t"])                  val unionTy = CL.T_Named(N.iunionTy n)
167                  val vecExp = CL.mkSelect(CL.mkCast(unionTy, v), "i")                  val vecExp = CL.mkSelect(CL.mkCast(unionTy, v), "i")
168                  in                  in
169                    CL.mkSubscript(vecExp, ix)                    CL.mkSubscript(vecExp, ix)
170                  end                  end
171              | (Op.Subscript(Ty.SeqTy(ty, n)), [v, ix]) => CL.mkSubscript(v, ix)              | (Op.Subscript(Ty.SeqTy(ty, n)), [v, ix]) => CL.mkSubscript(v, ix)
172              | (Op.Subscript(Ty.TensorTy[n]), [v, ix]) => let              | (Op.Subscript(Ty.TensorTy[n]), [v, ix]) => let
173                  val unionTy = CL.T_Named(concat["union", Int.toString n, !N.gRealSuffix, "_t"])                  val unionTy = CL.T_Named(N.unionTy n)
174                  val vecExp = CL.mkSelect(CL.mkCast(unionTy, v), "r")                  val vecExp = CL.mkSelect(CL.mkCast(unionTy, v), "r")
175                  in                  in
176                    CL.mkSubscript(vecExp, ix)                    CL.mkSubscript(vecExp, ix)
# Line 191  Line 178 
178              | (Op.Subscript(Ty.TensorTy[_,_]), [m, ix, jx]) => matIndex (m, ix, jx)              | (Op.Subscript(Ty.TensorTy[_,_]), [m, ix, jx]) => matIndex (m, ix, jx)
179              | (Op.Subscript ty, t::(ixs as _::_)) =>              | (Op.Subscript ty, t::(ixs as _::_)) =>
180                  raise Fail(concat["Subscript<", Ty.toString ty, "> unsupported"])                  raise Fail(concat["Subscript<", Ty.toString ty, "> unsupported"])
181              | (Op.MkDynamic(ty, n), [seq]) => CL.mkApply("DYNSEQ_MK(", [              | (Op.MkDynamic(ty, n), [seq]) => CL.mkApply("Diderot_DynSeqMk", [
182                    CL.mkSizeof(trType ty), CL.mkInt(IntInf.fromInt n), seq                    CL.mkSizeof(trType ty), CL.mkInt(IntInf.fromInt n),
183                      addrOf (CL.mkSubscript(seq, intExp 0))
184                  ])                  ])
185              | (Op.Append ty, [seq, x]) => CL.mkApply("DYNSEQ_APPEND(", [              | (Op.Append ty, [seq, x]) => CL.mkApply("Diderot_DynSeqAppend", [
186                    CL.mkSizeof(trType ty), seq, x                    CL.mkSizeof(trType ty), seq, addrOf x
187                  ])                  ])
188              | (Op.Prepend ty, [x, seq]) => CL.mkApply("DYNSEQ_PREPEND(", [              | (Op.Prepend ty, [x, seq]) => CL.mkApply("Diderot_DynSeqPrepend", [
189                    CL.mkSizeof(trType ty), x, seq                    CL.mkSizeof(trType ty), addrOf x, seq
190                  ])                  ])
191              | (Op.Concat ty, [seq1, seq2]) => CL.mkApply("DYNSEQ_CONCAT(", [              | (Op.Concat ty, [seq1, seq2]) => CL.mkApply("Diderot_DynSeqConcat", [
192                    CL.mkSizeof(trType ty), seq1, seq2                    CL.mkSizeof(trType ty), seq1, seq2
193                  ])                  ])
194              | (Op.Ceiling d, args) => CL.mkApply(N.addTySuffix("ceil", d), args)              | (Op.Ceiling d, args) => CL.mkApply(N.addTySuffix("ceil", d), args)
# Line 210  Line 198 
198              | (Op.IntToReal, [a]) => CL.mkCast(!N.gRealTy, a)              | (Op.IntToReal, [a]) => CL.mkCast(!N.gRealTy, a)
199              | (Op.RealToInt 1, [a]) => CL.mkCast(!N.gIntTy, a)              | (Op.RealToInt 1, [a]) => CL.mkCast(!N.gIntTy, a)
200              | (Op.RealToInt d, args) => CL.mkApply(N.vecftoi d, args)              | (Op.RealToInt d, args) => CL.mkApply(N.vecftoi d, args)
201  (* FIXME: need type info *)              | (Op.ImageAddress info, [a]) => let
202              | (Op.ImageAddress(ImageInfo.ImgInfo{ty=(_,rTy), ...}), [a]) => let                  val cTy = CL.T_Ptr(CL.T_Num(ImageInfo.sampleTy info))
                 val cTy = CL.T_Ptr(CL.T_Num rTy)  
203                  in                  in
204                    CL.mkCast(cTy, CL.mkIndirect(a, "data"))                    CL.mkCast(cTy, CL.mkIndirect(a, "data"))
205                  end                  end
# Line 226  Line 213 
213                  end                  end
214              | (Op.LoadVoxels _, [a]) =>              | (Op.LoadVoxels _, [a]) =>
215                  raise Fail("impossible " ^ Op.toString rator)                  raise Fail("impossible " ^ Op.toString rator)
216              | (Op.PosToImgSpace(ImageInfo.ImgInfo{dim, ...}), [img, pos]) =>              | (Op.PosToImgSpace info, [img, pos]) =>
217                  CL.mkApply(N.toImageSpace dim, [img, pos])                  CL.mkApply(N.toImageSpace(ImageInfo.dim info), [img, pos])
218              | (Op.TensorToWorldSpace(info, ty), [v, x]) =>              | (Op.TensorToWorldSpace(info, ty), [v, x]) =>
219                  CL.mkApply(N.toWorldSpace ty, [v, x])                  CL.mkApply(N.toWorldSpace ty, [v, x])
220              | (Op.LoadImage info, [a]) =>              | (Op.LoadImage info, [a]) =>
221                  raise Fail("impossible " ^ Op.toString rator)                  raise Fail("impossible " ^ Op.toString rator)
222              | (Op.Inside(ImageInfo.ImgInfo{dim, ...}, s), [pos, img]) =>              | (Op.Inside(info, s), [pos, img]) =>
223                  CL.mkApply(N.inside dim, [pos, img, intExp s])                  CL.mkApply(N.inside(ImageInfo.dim info), [pos, img, intExp s])
224              | (Op.Input(ty, desc, name), []) =>              | (Op.Input(ty, desc, name), []) =>
225                  raise Fail("impossible " ^ Op.toString rator)                  raise Fail("impossible " ^ Op.toString rator)
226              | (Op.InputWithDefault(ty, desc, name), [a]) =>              | (Op.InputWithDefault(ty, desc, name), [a]) =>
# Line 253  Line 240 
240              | IL.E_Op(rator, args) => trOp (rator, trExps(env, args))              | IL.E_Op(rator, args) => trOp (rator, trExps(env, args))
241              | IL.E_Apply(f, args) => trApply(f, trExps(env, args))              | IL.E_Apply(f, args) => trApply(f, trExps(env, args))
242              | IL.E_Cons(Ty.TensorTy[n], args) => CL.mkApply(N.mkVec n, trExps(env, args))              | IL.E_Cons(Ty.TensorTy[n], args) => CL.mkApply(N.mkVec n, trExps(env, args))
             | IL.E_Cons(Ty.SeqTy(ty, n), args) => CL.mkApply("Diderot_MkSeq",  
                 CL.mkSizeof(trType ty) :: CL.mkInt(IntInf.fromInt n) :: trExps(env, args))  
243              | IL.E_Cons(ty, _) => raise Fail(concat["E_Cons(", Ty.toString ty, ", _) in expression"])              | IL.E_Cons(ty, _) => raise Fail(concat["E_Cons(", Ty.toString ty, ", _) in expression"])
244            (* end case *))            (* end case *))
245    
# Line 414  Line 399 
399                  in                  in
400                    doRows (0, trExps(env, args))                    doRows (0, trExps(env, args))
401                  end                  end
402                | IL.E_Cons(Ty.TensorTy[n,m,l], args) => let
403                  (* 3rd-order tensors are represented as 2D arrays of union<d><ty>_t vectors *)
404                    fun lp1 (i, [], code) = code
405                      | lp1 (i, e::es, code) = let
406                          val lhs_i = CL.mkSubscript(lhs, intExp i)
407                          fun lp2 j = if (j < m)
408                                then CL.mkAssign(
409                                    CL.mkSelect(CL.mkSubscript(lhs_i, intExp j), "v"),
410                                    CL.mkSelect(CL.mkSubscript (e, intExp j), "v")
411                                  ) :: lp2(j+1)
412                                else code
413                          in
414                            lp1 (i+1, es, lp2 0)
415                          end
416                    in
417                      lp1 (0, trExps(env, args), [])
418                    end
419                | IL.E_Cons(Ty.SeqTy(ty, n), args) => let
420                    fun doAssign (_, []) = []
421                      | doAssign (i, arg::args) =
422                          CL.mkAssign(CL.mkSubscript(lhs, intExp i), arg) :: doAssign(i+1, args)
423                    in
424                      doAssign (0, trExps(env, args))
425                    end
426                | IL.E_State x => (case IL.StateVar.ty x
427                     of Ty.TensorTy[n,m] => [CL.mkCall(N.copyMat(n,m), [lhs, VarToC.rvalueStateVar x])]
428                      | Ty.TensorTy[n,m,l] => [CL.mkCall(N.copyTen(n,m,l), [lhs, VarToC.rvalueStateVar x])]
429                      | _ => [CL.mkAssign(lhs, VarToC.rvalueStateVar x)]
430                    (* end case *))
431              | IL.E_Var x => (case IL.Var.ty x              | IL.E_Var x => (case IL.Var.ty x
432                   of Ty.TensorTy[n,m] => [CL.mkCall(N.copyMat(n,m), [lhs, VarToC.rvalueVar(env, x)])]                   of Ty.TensorTy[n,m] => [CL.mkCall(N.copyMat(n,m), [lhs, VarToC.rvalueVar(env, x)])]
433                      | Ty.TensorTy[n,m,l] => [CL.mkCall(N.copyTen(n,m,l), [lhs, VarToC.rvalueVar(env, x)])]
434                    | _ => [CL.mkAssign(lhs, VarToC.rvalueVar(env, x))]                    | _ => [CL.mkAssign(lhs, VarToC.rvalueVar(env, x))]
435                  (* end case *))                  (* end case *))
436              | _ => [CL.mkAssign(lhs, trExp(env, rhs))]              | _ => [CL.mkAssign(lhs, trExp(env, rhs))]
# Line 455  Line 470 
470              (fn (x, env) => V.Map.insert(env, x, V(trType(V.ty x), V.name x)))              (fn (x, env) => V.Map.insert(env, x, V(trType(V.ty x), V.name x)))
471                env locals                env locals
472    
473    (* generate code to check the status of runtime-system calls *)    (* generate code to check the status of runtime-system calls; this code assumes that
474       * we are in a function with a boolean return type
475       *)
476      fun checkSts mkDecl = let      fun checkSts mkDecl = let
477            val sts = freshVar "sts"            val sts = freshVar "sts"
478            in            in
479              mkDecl sts @              mkDecl sts @
480              [CL.mkIfThen(              [CL.mkIfThen(
481                CL.mkBinOp(CL.mkVar "DIDEROT_OK", CL.#!=, CL.mkVar sts),                CL.mkBinOp(CL.mkVar "DIDEROT_OK", CL.#!=, CL.mkVar sts),
482                CL.mkCall("exit", [intExp 1]))]                CL.mkReturn(SOME(CL.mkVar "true")))]
483            end            end
484    
485      fun trStms (env, stms) = let      fun trStms (env, stms) = let
# Line 489  Line 506 
506                        in [                        in [
507                          CL.mkDecl(                          CL.mkDecl(
508                            CL.T_Named N.statusTy, sts,                            CL.T_Named N.statusTy, sts,
509                            SOME(CL.I_Exp(CL.E_Apply(loadFn, [name, CL.mkUnOp(CL.%&, lhs)]))))                            SOME(CL.I_Exp(CL.E_Apply(loadFn, [
510                                  CL.mkCast(CL.T_Ptr(CL.T_Named "WorldPrefix_t"), CL.mkVar "wrld"),
511                                  name, addrOf lhs
512                                ]))))
513                        ] end)                        ] end)
514                    | IL.S_Input(lhs, name, desc, optDflt) => let                    | IL.S_Input(_, _, _, NONE) => []
515                        val inputFn = N.input(V.ty lhs)                    | IL.S_Input(lhs, name, _, SOME dflt) => [
516                        val lhs = VarToC.lvalueVar (env, lhs)                          CL.mkAssign(VarToC.lvalueVar(env, lhs), trExp(env, dflt))
517                        val (initCode, hasDflt) = (case optDflt                        ]
518                               of SOME e => ([CL.mkAssign(lhs, trExp(env, e))], true)                    | IL.S_Exit args => []
                               | NONE => ([], false)  
                             (* end case *))  
                       val code = [CL.mkCall(inputFn, [  
                               CL.mkVar "opts",  
                               CL.mkStr name,  
                               CL.mkStr desc,  
                               CL.mkUnOp(CL.%&, lhs),  
                               CL.mkBool hasDflt])]  
                       in  
                         initCode @ code  
                       end  
                   | IL.S_Exit args => [CL.mkReturn NONE]  
519                    | IL.S_Active => [CL.mkReturn(SOME(CL.mkVar N.kActive))]                    | IL.S_Active => [CL.mkReturn(SOME(CL.mkVar N.kActive))]
520                    | IL.S_Stabilize => [CL.mkReturn(SOME(CL.mkVar N.kStabilize))]                    | IL.S_Stabilize => [CL.mkReturn(SOME(CL.mkVar N.kStabilize))]
521                    | IL.S_Die => [CL.mkReturn(SOME(CL.mkVar N.kDie))]                    | IL.S_Die => [CL.mkReturn(SOME(CL.mkVar N.kDie))]

Legend:
Removed from v.1690  
changed lines
  Added in v.1858

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