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

SCM Repository

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

Diff of /branches/charisee/src/compiler/c-util/tree-to-c-fn.sml

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

revision 2667, Thu Jun 5 18:54:12 2014 UTC revision 2668, Thu Jun 12 03:29:04 2014 UTC
# Line 1  Line 1 
1    
2  (* tree-to-c.sml  (* tree-to-c.sml
3   *   *WQE
4   * COPYRIGHT (c) 2011 The Diderot Project (http://diderot-language.cs.uchicago.edu)   * COPYRIGHT (c) 2011 The Diderot Project (http://diderot-language.cs.uchicago.edu)
5   * All rights reserved.   * All rights reserved.
6   *   *
# Line 24  Line 25 
25      type env = CLang.typed_var TreeIL.Var.Map.map      type env = CLang.typed_var TreeIL.Var.Map.map
26    
27      val trType : TreeIL.Ty.ty -> CLang.ty      val trType : TreeIL.Ty.ty -> CLang.ty
28       (* val restType : TreeIL.Ty.ty -> CLang.ty*)
29    
30      val trBlock : env * TreeIL.block -> CLang.stm      val trBlock : env * TreeIL.block -> CLang.stm
31    
# Line 38  Line 40 
40    (* vector indexing support.  Arguments are: vector, arity, index *)    (* vector indexing support.  Arguments are: vector, arity, index *)
41      val ivecIndex : CLang.exp * int * int -> CLang.exp      val ivecIndex : CLang.exp * int * int -> CLang.exp
42      val vecIndex : CLang.exp * int * int -> CLang.exp      val vecIndex : CLang.exp * int * int -> CLang.exp
43        val prntArr : CLang.exp * int * int -> CLang.exp
44    
45    end = struct    end = struct
46    
# Line 67  Line 70 
70    
71      fun addrOf e = CL.mkUnOp(CL.%&, e)      fun addrOf e = CL.mkUnOp(CL.%&, e)
72    
73        val cat=CL.T_Named ("cat")
74    (* translate TreeIL types to CLang types *)    (* translate TreeIL types to CLang types *)
75      fun trType ty = (case ty      fun trType ty = (case ty
76             of Ty.BoolTy => CLang.T_Named "bool"             of Ty.BoolTy => CLang.T_Named "bool"
77              | Ty.StringTy => CL.charPtr              | Ty.StringTy => CL.charPtr
78              | Ty.IntTy => !N.gIntTy              | Ty.IntTy => !N.gIntTy
79              | Ty.TensorTy[] => !N.gRealTy              | Ty.TensorTy[] => !N.gRealTy
80              | Ty.TensorTy[n] => CL.T_Named(N.vecTy n)              | Ty.TensorTy t =>CL.mkRealArr(N.tprog ,t)
             | Ty.TensorTy[n, m] => CL.T_Named(N.matTy(n,m))  
             | Ty.TensorTy e => CL.T_Named(N.tenTy e)  
81              | Ty.SeqTy(Ty.IntTy, n) => CL.T_Named(N.ivecTy n)              | Ty.SeqTy(Ty.IntTy, n) => CL.T_Named(N.ivecTy n)
82              | Ty.SeqTy(ty, n) => CL.T_Array(trType ty, SOME n)              | Ty.SeqTy(ty, n) => CL.T_Array(trType ty, SOME n)
83              | Ty.AddrTy(ImageInfo.ImgInfo{ty=(_, rTy), ...}) => CL.T_Ptr(CL.T_Num rTy)              | Ty.AddrTy(ImageInfo.ImgInfo{ty=(_, rTy), ...}) => CL.T_Ptr(CL.T_Num rTy)
# Line 84  Line 86 
86              | _ => raise Fail(concat["TreeToC.trType(", Ty.toString ty, ")"])              | _ => raise Fail(concat["TreeToC.trType(", Ty.toString ty, ")"])
87            (* end case *))            (* end case *))
88    
89        (*TypeDef Struct*)
90    (*
91    | Ty.TensorTy[] => !N.gRealTy
92    | Ty.TensorTy[n] => CL.T_Named(N.vecTy n)
93    | Ty.TensorTy[n, m] => CL.T_Named(N.matTy(n,m))
94    | Ty.TensorTy e => CL.T_Named(N.tenTy e)
95    
96    *)
97    
98    
99    (* generate new variables *)    (* generate new variables *)
100      local      local
101        val count = ref 0        val count = ref 0
# Line 119  Line 131 
131    
132    (* vector indexing support.  Arguments are: vector, arity, index *)    (* vector indexing support.  Arguments are: vector, arity, index *)
133      fun ivecIndex (v, n, ix) = let      fun ivecIndex (v, n, ix) = let
134            val unionTy = CL.T_Named(concat["union", Int.toString n, !N.gIntSuffix, "_t"])            val unionTy = CL.T_Named(concat["kittenunion", Int.toString n, !N.gIntSuffix, "_t"])
135            val e1 = CL.mkCast(unionTy, v)            val e1 = CL.mkCast(unionTy, v)
136            val e2 = CL.mkSelect(e1, "i")            val e2 = CL.mkSelect(e1, "i")
137            in            in
# Line 127  Line 139 
139            end            end
140    
141      fun vecIndex (v, n, ix) = let      fun vecIndex (v, n, ix) = let
142            val unionTy = CL.T_Named(concat["union", Int.toString n, !N.gRealSuffix, "_t"])            val unionTy = CL.T_Named(concat["Yellowunion", Int.toString n, !N.gRealSuffix, "_t"])
143            val e1 = CL.mkCast(unionTy, v)            val e1 = CL.mkCast(unionTy, v)
144            val e2 = CL.mkSelect(e1, "r")            val e2 = CL.mkSelect(e1, "r")
145            in            in
146              CL.mkSubscript(e2, intExp ix)              CL.mkSubscript(e2, intExp ix)
147            end            end
148    
149    
150        (*prnt arrays *)
151        fun prntArr(v,n,ix)=let
152            in
153            CL.mkSubscript(v, intExp ix)
154            end
155    
156    
157    
158    (* matrix indexing *)    (* matrix indexing *)
159      fun matIndex (m, ix, jx) =      fun matIndex (m, ix, jx) =
160            CL.mkSubscript(CL.mkSelect(CL.mkSubscript(m, ix), "r"), jx)            CL.mkSubscript(CL.mkSelect(CL.mkSubscript(m, ix), "r"), jx)
# Line 162  Line 183 
183              | (Op.prodScaV d,args)   => CL.E_Apply(N.NameScaV d, args)              | (Op.prodScaV d,args)   => CL.E_Apply(N.NameScaV d, args)
184              | (Op.sumVec d,args)     => CL.E_Apply(N.NameSumV d, args)              | (Op.sumVec d,args)     => CL.E_Apply(N.NameSumV d, args)
185              | (Op.IndexTensor(_,Ty.TensorTy [], Ty.indexTy [i],  Ty.TensorTy [argTy]),[a])=>              | (Op.IndexTensor(_,Ty.TensorTy [], Ty.indexTy [i],  Ty.TensorTy [argTy]),[a])=>
186                      vecIndex (a, argTy, i)                      (*vecIndex (a, argTy, i)*)
187                        CL.E_Str "cow8"
188    
189              | (Op.IndexTensor (_,Ty.TensorTy [_], Ty.indexTy [i],              | (Op.IndexTensor (_,Ty.TensorTy [_], Ty.indexTy [i],
190                  Ty.TensorTy[_,_]),[m])=>matProj(m,intExp i)                  Ty.TensorTy[_,_]),[m])=>matProj(m,intExp i)
# Line 199  Line 221 
221                        ])                        ])
222                  (* end case *))                  (* end case *))
223    
   
          (*  
             | (Op.Norm(Ty.TensorTy[n]), args) =>raise Fail "Norm Vector:should have been removed in mid-to-low"  
             | (Op.Norm(Ty.TensorTy[m,n]), args) => raise Fail "Norm Mat:should have been removed in mid-to-low"  
             | (Op.Normalize d, args) => CL.E_Apply(N.normalize d, args)  
   
         *)  
   
224              | (Op.PrincipleEvec ty, _) => raise Fail "PrincipleEvec unimplemented"              | (Op.PrincipleEvec ty, _) => raise Fail "PrincipleEvec unimplemented"
225              | (Op.Select(Ty.TupleTy tys, i), [a]) => raise Fail "Select unimplemented"              | (Op.Select(Ty.TupleTy tys, i), [a]) => raise Fail "Select unimplemented"
226              | (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)
227              | (Op.Index(Ty.TensorTy[n], i), [a]) => vecIndex (a, n, i)              | (Op.Index(Ty.TensorTy[n], i), [a]) => (*vecIndex (a, n, i)*) CL.E_Str "cow64"
228              | (Op.Subscript(Ty.SeqTy(Ty.IntTy, n)), [v, ix]) => let              | (Op.Subscript(Ty.SeqTy(Ty.IntTy, n)), [v, ix]) => let
229                  val unionTy = CL.T_Named(concat["union", Int.toString n, !N.gIntSuffix, "_t"])                  val unionTy = CL.T_Named(concat["Squishunion", Int.toString n, !N.gIntSuffix, "_t"])
230                  val vecExp = CL.mkSelect(CL.mkCast(unionTy, v), "i")                  val vecExp = CL.mkSelect(CL.mkCast(unionTy, v), "i")
231                  in                  in
232                    CL.mkSubscript(vecExp, ix)                    CL.mkSubscript(vecExp, ix)
233                  end                  end
234              | (Op.Subscript(Ty.SeqTy(ty, n)), [v, ix]) => CL.mkSubscript(v, ix)              | (Op.Subscript(Ty.SeqTy(ty, n)), [v, ix]) => CL.mkSubscript(v, ix)
235              | (Op.Subscript(Ty.TensorTy[n]), [v, ix]) => let              | (Op.Subscript(Ty.TensorTy[n]), [v, ix]) => let
236                  val unionTy = CL.T_Named(concat["union", Int.toString n, !N.gRealSuffix, "_t"])                  val unionTy = CL.T_Named(concat["Onionunion", Int.toString n, !N.gRealSuffix, "_t"])
237                  val vecExp = CL.mkSelect(CL.mkCast(unionTy, v), "r")                  val vecExp = CL.mkSelect(CL.mkCast(unionTy, v), "r")
238                  in                  in
239                    CL.mkSubscript(vecExp, ix)                    CL.mkSubscript(vecExp, ix)
# Line 271  Line 285 
285              | IL.E_Lit(Literal.Int n) => CL.mkIntTy(n, !N.gIntTy)              | IL.E_Lit(Literal.Int n) => CL.mkIntTy(n, !N.gIntTy)
286              | IL.E_Lit(Literal.Bool b) => CL.mkBool b              | IL.E_Lit(Literal.Bool b) => CL.mkBool b
287              | IL.E_Lit(Literal.Float f) => CL.mkFlt(f, !N.gRealTy)              | IL.E_Lit(Literal.Float f) => CL.mkFlt(f, !N.gRealTy)
288                        (*used for cons *)
289              | IL.E_Lit(Literal.String s) => CL.mkStr s              | IL.E_Lit(Literal.String s) => CL.mkStr s
290              | IL.E_Op(rator, args) => trOp (rator, trExps(env, args))              | IL.E_Op(rator, args) => trOp (rator, trExps(env, args))
291              | IL.E_Apply(f, args) => trApply(f, trExps(env, args))              | IL.E_Apply(f, args) => trApply(f, trExps(env, args))
292              | IL.E_Cons(Ty.TensorTy[n], args) => CL.mkApply(N.mkVec n, trExps(env, args))  
293              (*| IL.E_Cons(Ty.TensorTy[n], args) => CL.mkApply(N.NameConsVec  n, trExps(env, args))*)                (* N.mkVec n,N.NameConsVec n*)
294    
295              | IL.E_Cons(Ty.TensorTy e, args) => CL.mkApply(N.tenTy e,trExps(env, args))              | IL.E_Cons(Ty.TensorTy e, args) => CL.mkApply(N.tenTy e,trExps(env, args))
296              | 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"])
297              | IL.E_mkVec( _, orig,_,args) =>              | IL.E_mkVec( aligned,rst, orig,indexAt,_,args) =>
298                            CL.mkApply(N.NameMkVec orig, trExps(env, args))                            CL.mkApply(N.NameMkVec(aligned,rst,orig), trExps(env, [args]))
299              | IL.E_LoadVec(n, orig, v,arg) =>              | IL.E_LoadVec(aligned,n, orig, v,arg) =>
300                      CL.mkApply(N.NameLdVec(n, orig), trExps(env, [v,arg]))                      CL.mkApply(N.NameLdVec(aligned,n,orig), trExps(env, [v,arg]))
             | IL.E_mkVecAligned( _, orig,_,args) =>  
                     CL.mkApply(N.NameMkVecA orig, trExps(env, args))  
             | IL.E_LoadVecAligned(n, orig, v,arg) =>  
                     CL.mkApply(N.NameLdVecA(n, orig), trExps(env, [v,arg]) )  
301    
302            (* end case *))            (* end case *))
303            val _=print(CL.expToString CLExp)            val _=print(CL.expToString CLExp)
# Line 329  Line 340 
340                      | Ty.TensorTy[] => mk("%f", trExp(env, exp))                      | Ty.TensorTy[] => mk("%f", trExp(env, exp))
341                      | Ty.TensorTy[n] => let                      | Ty.TensorTy[n] => let
342                          val (x, stm) = expToVar (env, trType ty, "vec", exp)                          val (x, stm) = expToVar (env, trType ty, "vec", exp)
343                          val elems = List.tabulate (n, fn i => vecIndex (x, n, i))                          val elems = List.tabulate (n, fn i => (*vecIndex (x, n, i)*) CL.E_Str "cow2" )
344                          val (fmt, args) = mkSeqFmt (Ty.TensorTy[], elems, fmt, args)                          (*val (fmt, args) = mkSeqFmt (Ty.TensorTy[], elems, fmt, args)*)
345                                val (fmt, args) = mkSeqFmt (Ty.TensorTy[],[CL.E_Str "cow"], fmt, args)
346                          in                          in
347                            (stm@stms, fmt, args)                            (stm@stms, fmt, args)
348                          end                          end
# Line 338  Line 350 
350                      | Ty.TensorTy[n, m] =>                      | Ty.TensorTy[n, m] =>
351  *)  *)
352                      | Ty.SeqTy(elemTy, n) =>  let                      | Ty.SeqTy(elemTy, n) =>  let
353                          val (x, stm) = expToVar (env, trType ty, "vec", exp)                          val (x, stm) = expToVar (env, (*trType ty*) cat , "vec", exp)
354                          val elems = List.tabulate (n, fn i => ivecIndex (x, n, i))                          val elems = List.tabulate (n, fn i => ivecIndex (x, n, i))
355                          val (fmt, args) = mkSeqFmt (elemTy, elems, fmt, args)                          val (fmt, args) = mkSeqFmt (elemTy, elems, fmt, args)
356                          in                          in
# Line 352  Line 364 
364                        ("%s"::fmt, CL.mkCond(elem, CL.mkStr "true", CL.mkStr "false")::args)                        ("%s"::fmt, CL.mkCond(elem, CL.mkStr "true", CL.mkStr "false")::args)
365                    | Ty.StringTy => ("%s"::fmt, elem::args)                    | Ty.StringTy => ("%s"::fmt, elem::args)
366                    | Ty.IntTy => (!N.gIntFormat::fmt, elem::args)                    | Ty.IntTy => (!N.gIntFormat::fmt, elem::args)
367    
368    
369                    | Ty.TensorTy[] => ("%f"::fmt, elem::args)                    | Ty.TensorTy[] => ("%f"::fmt, elem::args)
370                    | Ty.TensorTy[n] => let                    | Ty.TensorTy[n] => let
371                        val elems = List.tabulate (n, fn i => vecIndex (elem, n, i))                        val elems = List.tabulate (n, fn i => (*vecIndex (elem, n, i)*) CL.E_Str "cowd1111")
372                        in                        in
373                          mkSeqFmt (Ty.TensorTy[], elems, fmt, args)                          mkSeqFmt (Ty.TensorTy[], elems, fmt, args)
374                        end                        end
# Line 481  Line 495 
495      fun trLocals (env : env, locals) =      fun trLocals (env : env, locals) =
496            List.foldl            List.foldl
497              (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)))
498                            (*Here-for local vars*)
499                env locals                env locals
500    
501    (* generate code to check the status of runtime-system calls *)    (* generate code to check the status of runtime-system calls *)
# Line 499  Line 514 
514    
515            fun trStmt (env, stm) = (case stm            fun trStmt (env, stm) = (case stm
516                   of IL.S_Comment text => [CL.mkComment text]                   of IL.S_Comment text => [CL.mkComment text]
517                    | IL.S_Assign([x], exp) =>  
518                          trAssign (env, VarToC.lvalueVar (env, x), exp)                   | IL.S_Assign([x],IL.E_mkVec(A, rty, orig,indexAt,_,args)) =>let
519                    | IL.S_Mk(x, IL.E_mkVec( _, orig,_,args)) =>let                           val x' =VarToC.lvalueVar (env, x)
520                      val CL.E_Var  x' =VarToC.lvalueVar (env, x)  
521                      val exp=CL.mkApply(N.NameMkVec orig, [CL.E_Var (x')]@trExps(env, args))                           (*val (CL.E_Var f)=x
522                              val g=CL.E_Var x*)
523    
524                            val exp=CL.mkApply(N.NameMkVec(A,rty,orig), [(*CL.E_Var"selfOut->PP"*) x' ]@trExps(env, [indexAt,args]))
525                    in                    in
526                                  [CL.S_Exp exp]                                  [CL.S_Exp exp]
527                    end                    end
528    
529                    | IL.S_Mk(x, IL.E_mkVecAligned( _, orig,_,args)) =>let                    | IL.S_Assign([x],IL.E_Cons(Ty.TensorTy[n], args)) =>let
530                          val CL.E_Var  x' =VarToC.lvalueVar (env, x)                          val  x' =VarToC.lvalueVar (env, x)
531                            val exp=  CL.mkApply(N.NameConsArray n, [x']@trExps(env, args))
                     val exp=CL.mkApply(N.NameMkVecA orig, [CL.E_Var( x')]@trExps(env, args))  
                     val s=CL.S_Exp exp  
   
532                          in                          in
533                              [s]                              [CL.S_Exp exp]
534                          end                          end
535    
536                      | IL.S_Assign([x], exp) =>
537                            trAssign (env, VarToC.lvalueVar (env, x), exp)
538    
539    
540                    | IL.S_Assign(xs, exp) =>                    | IL.S_Assign(xs, exp) =>
541                        (trMultiAssign (env, List.map (fn x => VarToC.lvalueVar (env, x)) xs, exp))                        (trMultiAssign (env, List.map (fn x => VarToC.lvalueVar (env, x)) xs, exp))
542                    | IL.S_IfThen(cond, thenBlk) =>                    | IL.S_IfThen(cond, thenBlk) =>

Legend:
Removed from v.2667  
changed lines
  Added in v.2668

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