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 2525, Tue Jan 21 19:14:22 2014 UTC revision 2646, Thu May 29 15:52:23 2014 UTC
# Line 31  Line 31 
31    
32      val trExp : env * TreeIL.exp -> CLang.exp      val trExp : env * TreeIL.exp -> CLang.exp
33    
34        val trAllTypes: TreeIL.Ty.ty list ->CLang.ty list
35    
36        val trAllOpr: TreeFunc.oprator list ->CLang.Cfn list
37    
38    (* vector indexing support.  Arguments are: vector, arity, index *)    (* vector indexing support.  Arguments are: vector, arity, index *)
39      val ivecIndex : CLang.exp * int * int -> CLang.exp      val ivecIndex : CLang.exp * int * int -> CLang.exp
40      val vecIndex : CLang.exp * int * int -> CLang.exp      val vecIndex : CLang.exp * int * int -> CLang.exp
# Line 43  Line 47 
47      structure Op = IL.Op      structure Op = IL.Op
48      structure Ty = IL.Ty      structure Ty = IL.Ty
49      structure V = IL.Var      structure V = IL.Var
50        (*structure gT=getTypes*)
51        structure Opr=OprToClang
52    
53      datatype var = datatype CLang.typed_var      datatype var = datatype CLang.typed_var
54      type env = CLang.typed_var TreeIL.Var.Map.map      type env = CLang.typed_var TreeIL.Var.Map.map
55    
56        val testing =1
57        fun pntTest str=(case testing
58            of 1=> (print(str);1)
59            | _ =>1
60        (*end case*))
61    
62      fun lookup (env, x) = (case V.Map.find (env, x)      fun lookup (env, x) = (case V.Map.find (env, x)
63             of SOME(V(_, x')) => x'             of SOME(V(_, x')) => x'
64              | NONE => raise Fail(concat["lookup(_, ", V.name x, ")"])              | NONE => raise Fail(concat["lookup(_, ", V.name x, ")"])
# Line 65  Line 77 
77              | Ty.TensorTy[] => !N.gRealTy              | Ty.TensorTy[] => !N.gRealTy
78              | Ty.TensorTy[n] => CL.T_Named(N.vecTy n)              | Ty.TensorTy[n] => CL.T_Named(N.vecTy n)
79              | Ty.TensorTy[n, m] => CL.T_Named(N.matTy(n,m))              | Ty.TensorTy[n, m] => CL.T_Named(N.matTy(n,m))
80                | 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)
84              | Ty.ImageTy(ImageInfo.ImgInfo{dim, ...}) => CL.T_Ptr(CL.T_Named(N.imageTy dim))              | Ty.ImageTy(ImageInfo.ImgInfo{dim, ...}) => CL.T_Ptr(CL.T_Named(N.imageTy dim))
85    
86    
87              | _ => raise Fail(concat["TreeToC.trType(", Ty.toString ty, ")"])              | _ => raise Fail(concat["TreeToC.trType(", Ty.toString ty, ")"])
88            (* end case *))            (* end case *))
89    
# Line 133  Line 148 
148              | (Op.IMul , [a, b]) => CL.mkBinOp(a, CL.#*, b)              | (Op.IMul , [a, b]) => CL.mkBinOp(a, CL.#*, b)
149              | (Op.IDiv , [a, b]) => CL.mkBinOp(a, CL.#/, b)              | (Op.IDiv , [a, b]) => CL.mkBinOp(a, CL.#/, b)
150              | (Op.INeg , [a]) => CL.mkUnOp(CL.%-, a)              | (Op.INeg , [a]) => CL.mkUnOp(CL.%-, a)
151    
152                (*Scalar operators*)
153                | (Op.addSca,[a,b])      => CL.mkBinOp(a, CL.#+, b)
154                | (Op.subSca, [a, b])    => CL.mkBinOp(a, CL.#-, b)
155                | (Op.prodSca, [a, b])   => CL.mkBinOp(a, CL.#*, b)
156                | (Op.divSca, [a, b])    => CL.mkBinOp(a, CL.#/, b)
157    
158                (*Do the same here? *)
159                | (Op.subVec n,[a,b])    =>  CL.mkBinOp(a, CL.#-, b)
160                | (Op.addVec n,[a,b])    => CL.mkBinOp(a, CL.#+, b)
161    
162                (*Vector operators*)
163                | (Op.prodVec 2, args)   => CL.E_Apply(N.prod 2, args)
164                | (Op.prodVec 3, args)   => CL.E_Apply(N.prod 3, args)
165                | (Op.prodVec 4, args)   => CL.E_Apply(N.prod 4, args)
166                | (Op.prodVec _, _)      => CL.E_Apply(N.prod 4, args)
167                | (Op.prodScaV 2,args)   => CL.E_Apply(N.scale 2, args)
168                | (Op.prodScaV 3,args)   => CL.E_Apply(N.scale 3, args)
169                | (Op.prodScaV 4,args)   => CL.E_Apply(N.scale 4, args)
170                | (Op.prodScaV _,_)      =>  CL.E_Apply(N.scale 4, args)
171                | (Op.sumVec 2,args)     => CL.E_Apply(N.sum 2, args)
172                | (Op.sumVec 3,args)     => CL.E_Apply(N.sum 3, args)
173                | (Op.sumVec 4,args)     => CL.E_Apply(N.sum 4, args)
174                | (Op.sumVec _,_)        => CL.E_Apply(N.sum 4, args)
175                | (Op.IndexTensor(_,_, Ty.indexTy indexAt, resultTy),args)=> CL.E_Apply(N.indexVec(2,indexAt) ,args)
176    
177    
178    
179    
180               (*
181     | (Op.imgAddr of ImageInfo.info * ty * int
182     | (Op.imgLoad of ImageInfo.info * int * int
183    
184     *)
185    
186              | (Op.Abs(Ty.IntTy), args) => CL.mkApply("abs", args)              | (Op.Abs(Ty.IntTy), args) => CL.mkApply("abs", args)
187              | (Op.Abs(Ty.TensorTy[]), args) => CL.mkApply(N.fabs(), args)              | (Op.Abs(Ty.TensorTy[]), args) => CL.mkApply(N.fabs(), args)
188              | (Op.Abs ty, [a]) => raise Fail(concat["Abs<", Ty.toString ty, ">"])              | (Op.Abs ty, [a]) => raise Fail(concat["Abs<", Ty.toString ty, ">"])
# Line 227  Line 277 
277              | IL.E_Op(rator, args) => trOp (rator, trExps(env, args))              | IL.E_Op(rator, args) => trOp (rator, trExps(env, args))
278              | IL.E_Apply(f, args) => trApply(f, trExps(env, args))              | IL.E_Apply(f, args) => trApply(f, trExps(env, args))
279              | 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))
280                | IL.E_Cons(Ty.TensorTy e, args) => CL.mkApply(N.tenTy e,trExps(env, args))
281              | 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"])
282                | IL.E_mkVec( n, orig,_,args) =>
283                              CL.mkApply(N.mkVecfn(n,orig), trExps(env, args))
284                | IL.E_LoadVec(n, orig, _,arg) =>
285                        CL.mkApply(N.ldVecfn(n, orig), trExps(env, [arg]))
286                | IL.E_FillVec(n,orig,_,arg)  =>
287                        CL.mkApply(N.ldVecfn(n, orig), trExps(env, [arg]))
288                | IL.E_SliceVec(n,orig,_,arg)  =>
289                        CL.mkApply(N.ldVecfn(n, orig), trExps(env, [arg]))
290    
291    
292            (* end case *))            (* end case *))
293    
294      and trExps (env, exps) = List.map (fn exp => trExp(env, exp)) exps      and trExps (env, exps) = List.map (fn exp => trExp(env, exp)) exps
# Line 235  Line 296 
296    (* translate an expression to a variable form; return the variable and the    (* translate an expression to a variable form; return the variable and the
297     * (optional) declaration.     * (optional) declaration.
298     *)     *)
299      fun expToVar (env, ty, name, exp) = (case trExp(env, exp)      fun expToVar (env, ty, name, exp) =let
300            val _=print "ExptoVar"
301            in (case trExp(env, exp)
302             of x as CL.E_Var _ => (x, [])             of x as CL.E_Var _ => (x, [])
303              | exp => let              | exp => let
304                  val x = freshVar name                  val x = freshVar name
# Line 243  Line 306 
306                    (CL.mkVar x, [CL.mkDecl(ty, x, SOME(CL.I_Exp exp))])                    (CL.mkVar x, [CL.mkDecl(ty, x, SOME(CL.I_Exp exp))])
307                  end                  end
308            (* end case *))            (* end case *))
309            end
310    
311    (* translate a print statement *)    (* translate a print statement *)
312      fun trPrint (env, tys, args) = let      fun trPrint (env, tys, args) = let
# Line 343  Line 407 
407                        matIndex (m, CL.mkInt 2, CL.mkInt 2)                        matIndex (m, CL.mkInt 2, CL.mkInt 2)
408                      ])]                      ])]
409                  end                  end
410              (*| IL.E_Op(Op.Zero(Ty.TensorTy[m,n]), args) =>              | IL.E_Op(Op.Zero(Ty.TensorTy[n]), args) =>
411                  [CL.mkCall(N.zeroMat(m,n), [lhs])]*)                        [CL.mkCall(N.zeroVec(n), [lhs])]
412                | IL.E_Op(Op.Zero(Ty.TensorTy[m,n]), args) =>
413                    [CL.mkCall(N.zeroMat(m,n), [lhs])]
414              | IL.E_Op(Op.LoadVoxels(info, n), [a]) =>              | IL.E_Op(Op.LoadVoxels(info, n), [a]) =>
415                  if (n > 1)                  if (n > 1)
416                    then let                    then let
# Line 424  Line 490 
490            end            end
491    
492      fun trStms (env, stms) = let      fun trStms (env, stms) = let
493              val _= pntTest "\n tree Stmt"
494    
495    
496            fun trStmt (env, stm) = (case stm            fun trStmt (env, stm) = (case stm
497                   of IL.S_Comment text => [CL.mkComment text]                   of IL.S_Comment text => [CL.mkComment text]
498                    | IL.S_Assign([x], exp) => trAssign (env, VarToC.lvalueVar (env, x), exp)                    | IL.S_Assign([x], exp) => let
499    
500                           (* val types=gT.getTypesFiltered stm
501                            val _=items:=(types@(!items))
502    
503                      *)
504    
505                            in
506                                trAssign (env, VarToC.lvalueVar (env, x), exp)
507                            end
508                    | IL.S_Assign(xs, exp) =>                    | IL.S_Assign(xs, exp) =>
509                        trMultiAssign (env, List.map (fn x => VarToC.lvalueVar (env, x)) xs, exp)                        (trMultiAssign (env, List.map (fn x => VarToC.lvalueVar (env, x)) xs, exp))
510                    | IL.S_IfThen(cond, thenBlk) =>                    | IL.S_IfThen(cond, thenBlk) =>
511                        [CL.mkIfThen(trExp(env, cond), trBlk(env, thenBlk))]                        [CL.mkIfThen(trExp(env, cond), trBlk(env, thenBlk))]
512                    | IL.S_IfThenElse(cond, thenBlk, elseBlk) =>                    | IL.S_IfThenElse(cond, thenBlk, elseBlk) =>
# Line 470  Line 548 
548                    | IL.S_Stabilize => [CL.mkReturn(SOME(CL.mkVar N.kStabilize))]                    | IL.S_Stabilize => [CL.mkReturn(SOME(CL.mkVar N.kStabilize))]
549                    | IL.S_Die => [CL.mkReturn(SOME(CL.mkVar N.kDie))]                    | IL.S_Die => [CL.mkReturn(SOME(CL.mkVar N.kDie))]
550                  (* end case *))                  (* end case *))
551            in  
552              List.foldr (fn (stm, stms) => trStmt(env, stm)@stms) [] stms  
553              val r=List.foldr (fn (stm, stms) => trStmt(env, stm)@stms) [] stms
554            (*  val _= gT.prnTy("FinalTypes",!items)
555      *)
556              in r
557            end            end
558    
559      and trBlk (env, IL.Block{locals, body}) = let      and trBlk (env, IL.Block{locals, body}) = let
560    
561            val env = trLocals (env, locals)            val env = trLocals (env, locals)
562            val stms = trStms (env, body)            val stms = trStms (env, body)
563            fun mkDecl (x, stms) = (case V.Map.find (env, x)            fun mkDecl (x, stms) = (case V.Map.find (env, x)
564                   of SOME(V(ty, x')) => CL.mkDecl(ty, x', NONE) :: stms                   of SOME(V(ty, x')) => CL.mkDecl(ty, x', NONE) :: stms
565                    | NONE => raise Fail(concat["mkDecl(", V.name x, ", _)"])                    | NONE => raise Fail(concat["mkDecl(", V.name x, ", _)"])
566                  (* end case *))                  (* end case *))
567    
568            val stms = List.foldr mkDecl stms locals            val stms = List.foldr mkDecl stms locals
569    
570            in            in
571              CL.mkBlock stms              CL.mkBlock stms
572            end            end
573    
574      fun trFragment (env, IL.Block{locals, body}) = let      fun trFragment (env, IL.Block{locals, body}) = let
575            val env = trLocals (env, locals)            val env = trLocals (env, locals)
576              val _= print "\n tree Fragment"
577            val stms = trStms (env, body)            val stms = trStms (env, body)
578    
579            fun mkDecl (x, stms) = (case V.Map.find (env, x)            fun mkDecl (x, stms) = (case V.Map.find (env, x)
580                   of SOME(V(ty, x')) => CL.mkDecl(ty, x', NONE) :: stms                   of SOME(V(ty, x')) => CL.mkDecl(ty, x', NONE) :: stms
581                    | NONE => raise Fail(concat["mkDecl(", V.name x, ", _)"])                    | NONE => raise Fail(concat["mkDecl(", V.name x, ", _)"])
# Line 498  Line 585 
585              (env, stms)              (env, stms)
586            end            end
587    
588        (*All Types in the program  *)
589        fun trAllTypes e=let
590    
591            val ClTyps=List.map trType e
592            fun prnt([],rest)=rest
593              | prnt(CL.T_Named(str)::es, rest)=prnt(es, rest@[str])
594              | prnt (e1::es, rest)= prnt(es,rest)
595            val str=prnt(ClTyps,[])
596            val _=print(String.concat["\n \t\t---- Tree-To-C Types \n",
597                    String.concatWith"," str])
598            in
599                ClTyps
600            end
601         fun trAllOpr e=let
602            val ClOprs=List.map Opr.handleOpr e
603            fun prnt([],rest)=rest
604              | prnt (e1::es, rest)= prnt(es,rest@[CL.fnCToString e1])
605            val str=prnt(ClOprs,[])
606            val _=print(String.concat["\n \t\t---- Tree-To-C Oprs \n",
607                      String.concat str])
608            in
609                ClOprs
610            end
611      val trBlock = trBlk      val trBlock = trBlk
612    
613    end    end

Legend:
Removed from v.2525  
changed lines
  Added in v.2646

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