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 2843, Mon Dec 8 01:27:25 2014 UTC revision 2844, Tue Dec 9 18:05:29 2014 UTC
# Line 171  Line 171 
171  | dumpStore (e1::es)=[e1] @dumpStore es  | dumpStore (e1::es)=[e1] @dumpStore es
172    
173    
174        (*Indextensor:TreeIL.OP(bool*ty*ty))*TreeIL.Var->CL
175        *isLocalVar, IndexTy, ArgTy
176        *decides if there needs to be a cast
177        *)
178        fun indexTensor  e=(case e
179        of (Op.IndexTensor(true,Ty.indexTy [0],Ty.TensorTy[1]),[a])=> a
180        | (Op.IndexTensor(true,Ty.indexTy [i],Ty.TensorTy[n]),[a])=> vecIndex (a,n,i) (*Index Local Vector*)
181        | (Op.IndexTensor(_,Ty.indexTy [i],Ty.SeqTy (_,n)),[a])=> ivecIndex (a,n,i)
182        | (Op.IndexTensor(false,Ty.indexTy [i],Ty.TensorTy[_]),[a])=>prntArr(a,i)   (*Index Global Vector*)
183        | (Op.IndexTensor(_,Ty.indexTy[i,j] ,Ty.TensorTy[_,m]),[a])=>prntArr(a,m*i+j)
184        | (Op.IndexTensor(_,Ty.indexTy[i,j,k] ,Ty.TensorTy[_,m,n]),[a])=>prntArr(a,m*i+n*j+k)
185        (*end case*))
186    
187    
188    (* Translate a TreeIL operator application to a CLang expression *)    (* Translate a TreeIL operator application to a CLang expression *)
189      fun trOp (rator, args) = (case (rator, args)      fun trOp (rator, args) = (case (rator, args)
190             of (Op.IAdd , [a, b]) => CL.mkBinOp(a, CL.#+, b)             of (Op.IAdd , [a, b]) => CL.mkBinOp(a, CL.#+, b)
# Line 187  Line 201 
201              | (Op.prodVec _ ,[a, b])  => CL.mkBinOp(a, CL.#*, b)              | (Op.prodVec _ ,[a, b])  => CL.mkBinOp(a, CL.#*, b)
202              | (Op.clampVec n, args) => CL.mkApply(N.NameClampV n, args)              | (Op.clampVec n, args) => CL.mkApply(N.NameClampV n, args)
203              | (Op.lerpVec n, args) =>  CL.mkApply(N.NameLerpV n, args)              | (Op.lerpVec n, args) =>  CL.mkApply(N.NameLerpV n, args)
204              | (Op.Sqrt,[a])         =>       CL.E_Sqrt a              | (Op.Sqrt,_)         =>     CL.E_Apply(N.NameSqrt ,args)
205              | (Op.prodScaV 1,[a,b])   =>  CL.mkBinOp(a, CL.#*, b)              | (Op.prodScaV 1,[a,b])   =>  CL.mkBinOp(a, CL.#*, b)
206              | (Op.prodScaV d,args)   => CL.E_Apply(N.NameScaV d, args)              | (Op.prodScaV d,args)   => CL.E_Apply(N.NameScaV d, args)
207              | (Op.sumVec (1,_),[a])     => a              | (Op.sumVec (1,_),[a])     => a
208              | (Op.sumVec (nSize,oSize),args)     => CL.E_Apply(N.NameSumV oSize, args)              | (Op.sumVec (nSize,oSize),args)     => CL.E_Apply(N.NameSumV oSize, args)
209                | (Op.IndexTensor _,_ )=>  indexTensor(rator,args)
   
   
             | (Op.IndexTensor(true,Ty.indexTy [0],Ty.TensorTy[1]),[a])=> a  
             | (Op.IndexTensor(true,Ty.indexTy [i],Ty.TensorTy[n]),[a])=> vecIndex (a,n,i) (*Index Local Vector*)  
             | (Op.IndexTensor(false,Ty.indexTy [i],Ty.TensorTy[_]),[a])=>prntArr(a,i)   (*Index Global Vector*)  
             | (Op.IndexTensor(_,Ty.indexTy [i],Ty.SeqTy (_,n)),[a])=> ivecIndex (a,n,i)  
             | (Op.IndexTensor(_,Ty.indexTy[i,j] ,Ty.TensorTy[_,m]),[a])=>prntArr(a,m*i+j)  
             | (Op.IndexTensor(_,Ty.indexTy[i,j,k] ,Ty.TensorTy[_,m,n]),[a])=>prntArr(a,m*i+n*j+k)  
   
   
                 (*Image related operators*)  
              | (Op.baseAddr(ImageInfo.ImgInfo{ty=(_,rTy), ...}) ,[a])=>  
                 CL.E_Cast(CL.T_Ptr(CL.T_Num rTy),CL.mkIndirect(a, "data"))  
             | (Op.baseAddr _,_)=> CL.mkBinOp(CL.E_Str"baseString", CL.#-, CL.E_Str"none")  
   
             | (Op.imgAddr(_,Ty.imgIndex ty, _), [base,shift] )=>(case ty  
                 of []  =>CL.mkBinOp(base, CL.#+,shift)  
                 | [0]  => CL.mkBinOp(base, CL.#+,shift)  
                 | [i]  => CL.mkBinOp(CL.mkInt(IntInf.fromInt i), CL.#+, CL.mkBinOp(base, CL.#+,shift))  
                 | _    =>raise Fail"Img addr larger than vector"  
                 (*end case*))  
             | (Op.Transform(v,i),[a]) =>(case (ImageInfo.dim v)  
                 of 1=>CL.mkIndirect(a, "s")  
                 | _ =>CL.mkIndirect(a, "w2i["^(Int.toString i)^"].v")  
                 (*end case*))  
             | (Op.Translate(v as ImageInfo.ImgInfo{ty=(_,rTy), ...}),[a])=>(case (ImageInfo.dim v)  
                 of 1=>CL.mkIndirect(a, "t")  
                 | _ =>CL.mkIndirect(a, "tVec")  
                 (*end case*))  
210              | (Op.Abs(Ty.IntTy), args) => CL.mkApply("abs", args)              | (Op.Abs(Ty.IntTy), args) => CL.mkApply("abs", args)
211              | (Op.Abs(Ty.TensorTy[]), args) => CL.mkApply(N.fabs(), args)              | (Op.Abs(Ty.TensorTy[]), args) => CL.mkApply(N.fabs(), args)
212              | (Op.Abs ty, [a]) => raise Fail(concat["Abs<", Ty.toString ty, ">"])              | (Op.Abs ty, [a]) => raise Fail(concat["Abs<", Ty.toString ty, ">"])
# Line 248  Line 233 
233                  in                  in
234                    CL.mkSubscript(vecExp, ix)                    CL.mkSubscript(vecExp, ix)
235                  end                  end
   
236              (*| (Op.Subscript(Ty.SeqTy(ty, n)), [v, ix]) =>CL.mkSubscript(v, ix)*)              (*| (Op.Subscript(Ty.SeqTy(ty, n)), [v, ix]) =>CL.mkSubscript(v, ix)*)
237               | (Op.Subscript(Ty.SeqTy(ty, n)), [v, CL.E_Int(ix,_)]) =>  prntArr2(v,  ix)               | (Op.Subscript(Ty.SeqTy(ty, n)), [v, CL.E_Int(ix,_)]) =>  prntArr2(v,  ix)
   
238              | (Op.Subscript(Ty.TensorTy[n]), [v, ix]) => let              | (Op.Subscript(Ty.TensorTy[n]), [v, ix]) => let
239                  val unionTy = CL.T_Named(concat["union", Int.toString n, !N.gRealSuffix, "_t"])                  val unionTy = CL.T_Named(concat["union", Int.toString n, !N.gRealSuffix, "_t"])
240                  val vecExp = CL.mkSelect(CL.mkCast(unionTy, v), "r")                  val vecExp = CL.mkSelect(CL.mkCast(unionTy, v), "r")
# Line 269  Line 252 
252              | (Op.IntToReal, [a]) => CL.mkCast(!N.gRealTy, a)              | (Op.IntToReal, [a]) => CL.mkCast(!N.gRealTy, a)
253              | (Op.RealToInt 1, [a]) => CL.mkCast(!N.gIntTy, a)              | (Op.RealToInt 1, [a]) => CL.mkCast(!N.gIntTy, a)
254              | (Op.RealToInt d, args) => CL.mkApply(N.vecftoi d, args)              | (Op.RealToInt d, args) => CL.mkApply(N.vecftoi d, args)
 (* FIXME: need type info *)  
255              | (Op.Normalize d,args)=>CL.mkApply(N.normalize d, args)              | (Op.Normalize d,args)=>CL.mkApply(N.normalize d, args)
256                | (Op.baseAddr(ImageInfo.ImgInfo{ty=(_,rTy), ...}) ,[a])=>
257                        CL.E_Cast(CL.T_Ptr(CL.T_Num rTy),CL.mkIndirect(a, "data"))
258                | (Op.imgAddr(_,Ty.imgIndex ty, _), [base,shift] )=>(case ty
259                    of []  =>CL.mkBinOp(base, CL.#+,shift)
260                    | [0]  => CL.mkBinOp(base, CL.#+,shift)
261                    | [i]  => CL.mkBinOp(CL.mkInt(IntInf.fromInt i), CL.#+, CL.mkBinOp(base, CL.#+,shift))
262                    | _    =>raise Fail"Img addr larger than vector"
263                    (*end case*))
264                | (Op.Transform(v,i),[a]) =>(case (ImageInfo.dim v)
265                    of 1=>CL.mkIndirect(a, "s")
266                    | _ =>CL.mkIndirect(a, "w2i["^(Int.toString i)^"].v")
267                    (*end case*))
268                | (Op.Translate(v as ImageInfo.ImgInfo{ty=(_,rTy), ...}),[a])=>(case (ImageInfo.dim v)
269                    of 1=>CL.mkIndirect(a, "t")
270                    | _ =>CL.mkIndirect(a, "tVec")
271                    (*end case*))
272                      (*Replaced with baseAddr operator*)                      (*Replaced with baseAddr operator*)
273              | (Op.ImageAddress(ImageInfo.ImgInfo{ty=(_,rTy), ...}), [a]) =>  CL.mkIndirect(a, "data")              | (Op.ImageAddress(ImageInfo.ImgInfo{ty=(_,rTy), ...}), [a]) =>  CL.mkIndirect(a, "data")
274              | (Op.LoadVoxels(info, 1), [a]) => let              | (Op.LoadVoxels(info, 1), [a]) => let
# Line 284  Line 281 
281                  end                  end
282              | (Op.LoadVoxels _, [a]) =>              | (Op.LoadVoxels _, [a]) =>
283                  raise Fail("impossible " ^ Op.toString rator)                  raise Fail("impossible " ^ Op.toString rator)
   
284              | (Op.Inside(ImageInfo.ImgInfo{dim, ...}, s), [pos, img]) =>              | (Op.Inside(ImageInfo.ImgInfo{dim, ...}, s), [pos, img]) =>
285                  CL.mkApply(N.inside dim, [pos, img, intExp s])                  CL.mkApply(N.inside dim, [pos, img, intExp s])
286              | (Op.Input(ty, desc, name), []) =>              | (Op.Input(ty, desc, name), []) =>
# Line 307  Line 303 
303              | IL.E_Apply(f, args) => trApply(f, trExps(env, args))              | IL.E_Apply(f, args) => trApply(f, trExps(env, args))
304              | IL.E_Cons(nSize,1,args) => (case (dumpStore args)              | IL.E_Cons(nSize,1,args) => (case (dumpStore args)
305                  of [a1]=>  trExp(env, a1)                  of [a1]=>  trExp(env, a1)
306                  | _=>CL.mkApply(N.NameConsVec nSize, trExps(env, dumpStore args))                  | a=>CL.mkApply(N.NameConsVec nSize, trExps(env, a))
307                  (*end case*))                  (*end case*))
308              | IL.E_Cons(nSize,oSize,args) =>  CL.mkApply(N.NameConsVec nSize, trExps(env, dumpStore args))              | IL.E_Cons(nSize,oSize,args) =>  CL.mkApply(N.NameConsVec nSize, trExps(env, dumpStore args))
309              | IL.E_LoadArr(_,1, _, v,IL.E_Lit(Literal.Int i)) =>                    CL.mkSubscript(trExp(env,v),CL.mkIntTy(  i,!N.gIntTy))              | IL.E_LoadArr(_,1, _, v,IL.E_Lit(Literal.Int i)) =>
310                        CL.mkSubscript(trExp(env,v),CL.mkIntTy(i,!N.gIntTy))
311              | IL.E_LoadArr(aligned,n, orig, v,arg) =>              | IL.E_LoadArr(aligned,n, orig, v,arg) =>
312                      CL.mkApply(N.NameLdArr(aligned,n,orig), trExps(env, [v,arg]))                      CL.mkApply(N.NameLdArr(aligned,n,orig), trExps(env, [v,arg]))
313             | IL.E_Mux (_,_,_,_,[a1]) => trExp(env,a1)             | IL.E_Mux (_,_,_,_,[a1]) => trExp(env,a1)
314             | IL.E_Mux (_,_,n,_,args) => (*raise Fail "Mux in tree-il stage, try trExp()"*)             | IL.E_Mux (_,_,n,_,args) => (*raise Fail "Mux in tree-il stage, try trExp()"*)
315                      CL.mkApply(N.NameMux n, trExps(env, args))                      CL.mkApply(N.NameMux n, trExps(env, args))
           | IL.E_Holder (x,_) => CL.mkStr ("Holder for "^(V.name x))  
                     (*VarToC.rvalueVar (env, x)*)  
316            (* end case *))            (* end case *))
317                      and trExps (env, exps) = (List.map (fn exp => trExp(env, exp)) exps)                      and trExps (env, exps) = (List.map (fn exp => trExp(env, exp)) exps)
318    
319    (*
320      fun storeVec(env,x',offset,A, isFill, oSize,ty,pieces,args)=let  *storeVec create CL.S list
321    *)
322        fun storeVec(stm,env,x',offset,A, isFill, oSize,ty,pieces,args)=let
323          val args'=dumpStore args          val args'=dumpStore args
324    
325          val exp= if(isFill) then (*isFilled used*)          val exp= if(isFill) then (*isFilled used*)
# Line 331  Line 328 
328                  | sort(nSize::ps,e::es,offset)=                  | sort(nSize::ps,e::es,offset)=
329                      [CL.mkApply(N.NameStoreVec(A,nSize,oSize), [x']@trExps(env, [IL.E_Lit(Literal.Int offset),e]))]                      [CL.mkApply(N.NameStoreVec(A,nSize,oSize), [x']@trExps(env, [IL.E_Lit(Literal.Int offset),e]))]
330                      @ sort(ps, es,offset + IntInf.fromInt oSize)                      @ sort(ps, es,offset + IntInf.fromInt oSize)
331                    | sort _=raise Fail"Not the right number of Arguments"
332              in sort(pieces,args',IntInf.fromInt offset) end              in sort(pieces,args',IntInf.fromInt offset) end
333              else let              else let
334                  fun sort([],_,_)=[]                  fun sort([],_,_)=[]
335                        | sort(nSize::ps,[e],offset)=
336                        [CL.mkApply(N.NameStoreVec(A,nSize,oSize),[x']@trExps(env, [IL.E_Lit(Literal.Int offset),e]))]
337                  | sort(nSize::ps,e::es,offset)=                  | sort(nSize::ps,e::es,offset)=
338                      [CL.mkApply(N.NameStoreVec(A,nSize,oSize),[x']@trExps(env, [IL.E_Lit(Literal.Int offset),e]))]                      [CL.mkApply(N.NameStoreVec(A,nSize,oSize),[x']@trExps(env, [IL.E_Lit(Literal.Int offset),e]))]
339                      @ sort(ps, es,offset + IntInf.fromInt nSize)                      @ sort(ps, es,offset + IntInf.fromInt nSize)
340    
341    
342    
343                    | sort _=raise Fail("Not the right number of Arguments"^IL.toStringS stm)
344              in sort(pieces,args', IntInf.fromInt offset) end              in sort(pieces,args', IntInf.fromInt offset) end
345          in          in
346              List.map (fn e=> CL.S_Exp e ) exp              List.map (fn e=> CL.S_Exp e ) exp
# Line 377  Line 381 
381                      | Ty.TensorTy[] => mk("%f", trExp(env, exp))                      | Ty.TensorTy[] => mk("%f", trExp(env, exp))
382                      | Ty.TensorTy[n] => let                      | Ty.TensorTy[n] => let
383                          val (x, stm) = expToVar (env, trType ty , "vec", exp)                          val (x, stm) = expToVar (env, trType ty , "vec", exp)
384                          val elems = List.tabulate (n, fn i => (*vecIndex (x, n, i)*) CL.E_Str "cow2" )                          val elems = List.tabulate (n, fn i => vecIndex (x, n, i))
385                          (*val (fmt, args) = mkSeqFmt (Ty.TensorTy[], elems, fmt, args)*)                          val (fmt, args) = mkSeqFmt (Ty.TensorTy[], elems, fmt, args)
                             val (fmt, args) = mkSeqFmt (Ty.TensorTy[],[CL.E_Str "cow88"], fmt, args)  
386                          in                          in
387                            (stm@stms, fmt, args)                            (stm@stms, fmt, args)
388                          end                          end
   
389                      | Ty.TensorTy[n, m] => let                      | Ty.TensorTy[n, m] => let
390                          val (x, stm) = expToVar (env, trType ty , "vec", exp)                          val (x, stm) = expToVar (env, trType ty , "vec", exp)
391                          val elems = List.tabulate (15, fn i =>  CL.E_Str "cow2" )                          val elems = List.tabulate (15, fn i =>  CL.E_Str "cow2" )
# Line 391  Line 393 
393                      in                      in
394                      (stm@stms, fmt, args)                      (stm@stms, fmt, args)
395                      end                      end
   
   
396                      | Ty.SeqTy(elemTy, n) =>  let                      | Ty.SeqTy(elemTy, n) =>  let
397                          val (x, stm) = expToVar (env, trType ty , "vec", exp)                          val (x, stm) = expToVar (env, trType ty , "vec", exp)
398                          val elems = List.tabulate (n, fn i => ivecIndex (x, n, i))                          val elems = List.tabulate (n, fn i => ivecIndex (x, n, i))
# Line 408  Line 408 
408                        ("%s"::fmt, CL.mkCond(elem, CL.mkStr "true", CL.mkStr "false")::args)                        ("%s"::fmt, CL.mkCond(elem, CL.mkStr "true", CL.mkStr "false")::args)
409                    | Ty.StringTy => ("%s"::fmt, elem::args)                    | Ty.StringTy => ("%s"::fmt, elem::args)
410                    | Ty.IntTy => (!N.gIntFormat::fmt, elem::args)                    | Ty.IntTy => (!N.gIntFormat::fmt, elem::args)
   
   
411                    | Ty.TensorTy[] => ("%f"::fmt, elem::args)                    | Ty.TensorTy[] => ("%f"::fmt, elem::args)
412                    | Ty.TensorTy[n] => let                    | Ty.TensorTy[n] => let
413                        val elems = List.tabulate (n, fn i => (*prntArr (elem,  i)*) CL.E_Str "cow2" )                        val elems = List.tabulate (n, fn i => prntArr (elem,  i))
                       val elems=[CL.E_Str "cow2"]  
414                        in                        in
415                          mkSeqFmt (Ty.TensorTy[], elems, fmt, args)                          mkSeqFmt (Ty.TensorTy[], elems, fmt, args)
416                        end                        end
   
417                          (*called by printResults*)                          (*called by printResults*)
418                    | Ty.TensorTy[n, m] =>  let                    | Ty.TensorTy[n, m] =>  let
419                      val d=n*m                      val d=n*m
420                      val elems = List.tabulate (989, fn i => prntArr (elem,  i))                      val elems = List.tabulate (d, fn i => prntArr (elem,  i))
                     val elems=[CL.E_Str "cow2"]  
421                      in                      in
422                      mkSeqFmt (Ty.TensorTy[], elems, fmt, args)                      mkSeqFmt (Ty.TensorTy[], elems, fmt, args)
423                      end                      end
424    
425                    | Ty.SeqTy(elemTy, n) =>  let                    | Ty.SeqTy(elemTy, n) =>  let
426                        val elems = List.tabulate (n, fn i => ivecIndex (elem, n, i))                        val elems = List.tabulate (n, fn i => ivecIndex (elem, n, i))
                         val elems=[CL.E_Str "cow2"]  
427                        in                        in
428                          mkSeqFmt (elemTy, elems, fmt, args)                          mkSeqFmt (elemTy, elems, fmt, args)
429                        end                        end
# Line 479  Line 473 
473                      ])]                      ])]
474                  end                  end
475              |IL.E_Op(Op.Zero(Ty.TensorTy ty),args)=> [CL.mkCall(N.NameZeroV ty, [lhs])]              |IL.E_Op(Op.Zero(Ty.TensorTy ty),args)=> [CL.mkCall(N.NameZeroV ty, [lhs])]
476                        (*              | IL.E_Var x => (case (IL.Var.ty x, IL.Var.kind x)
477              | IL.E_Op(Op.Zero(Ty.TensorTy[n]), args) =>                  of (*(Ty.TensorTy [],_) =>[CL.mkAssign(lhs, VarToC.rvalueVar(env, x))]
478                        [CL.mkCall(N.zeroVec(n), [lhs])]                  | (Ty.TensorTy [_],_) =>[CL.mkAssign(lhs, VarToC.rvalueVar(env, x))]
             | IL.E_Op(Op.Zero(Ty.TensorTy[m,n]), args) =>  
                 [CL.mkCall(N.zeroMat(m,n), [lhs])]*)  
              (*Op.imgLoad(info ,dim, n),[a])=>  
                 if (n > 1)  
                   then let  
                     val stride = ImageInfo.stride info  
                     val rTy = ImageInfo.sampleTy info  
                     val vp = freshVar "vp"  
                     val needsCast = (CL.T_Num rTy <> !N.gRealTy)  
                     fun mkLoad i = let  
                           val e = CL.mkSubscript(CL.mkVar vp, intExp(i*stride))  
                           in  
                             if needsCast then CL.mkCast(!N.gRealTy, e) else e  
                           end  
479    
480                      in [                   (Ty.TensorTy ty,IL.VK_Local,IL.VK_Local) =>      ([CL.mkCall(N.NameCopyTensor ty, [lhs,VarToC.rvalueVar(env, x),CL.mkInt 889])])
                       CL.mkDecl(CL.T_Ptr(CL.T_Num rTy), vp, SOME(CL.I_Exp(trExp(env, a)))),  
                         CL.mkAssign(lhs,CL.mkApply(N.NameConsVec n, List.tabulate (n, mkLoad)))  
481    
482                      ] end                  |*)(Ty.TensorTy [i,j],_) =>      ([CL.mkCall(N.NameCopyTensor [i,j], [lhs,VarToC.rvalueVar(env, x),CL.mkInt 0])])
483                          else   [CL.mkAssign(lhs, trExp(env, rhs))]                  | (_ ,_)=> [CL.mkAssign(lhs, VarToC.rvalueVar(env, x))]
                         *)  
             | IL.E_Var x => (case IL.Var.ty x  
                         of Ty.TensorTy[n,m] =>      ([CL.mkCall(N.NameCopyTensor[n,m], [lhs,VarToC.rvalueVar(env, x),CL.mkInt 0])])  
                   | _ => [CL.mkAssign(lhs, VarToC.rvalueVar(env, x))]  
484                  (* end case *))                  (* end case *))
485              | _ =>   [CL.mkAssign(lhs, trExp(env, rhs))]              | _ =>   [CL.mkAssign(lhs, trExp(env, rhs))]
486    
# Line 543  Line 517 
517        | trMultiAssign (env, lhs, rhs) = raise Fail "bogus multi-assignment"        | trMultiAssign (env, lhs, rhs) = raise Fail "bogus multi-assignment"
518    
519    
             (*  
         fun getCount (x )= let  
             val n = !(V.useCnt x)  
             in  
                 print (String.concat["\n",(V.name x),"--",Int.toString n])  
             end*)  
520    
521          fun trLocals (env : env, locals,isVecTy) =      (  List.foldl          fun trLocals (env : env, locals,isVecTy) =      (  List.foldl
522              (fn (x, env) => V.Map.insert(env, x, V(localType(V.ty x,isVecTy), V.name x)))              (fn (x, env) => V.Map.insert(env, x, V(localType(V.ty x,isVecTy), V.name x)))
# Line 577  Line 545 
545    
546              in  case stm              in  case stm
547                   of IL.S_Comment text => [CL.mkComment text]                   of IL.S_Comment text => [CL.mkComment text]
548                      | IL.S_Assign([x],IL.E_Mux(A,isFill, oSize,splitTy,[a]))=> trAssign (env,VarToC.lvalueVar (env, x),a)
549                    | IL.S_Assign([x], exp) =>                    | IL.S_Assign([x], exp) =>
550                          (trAssign (env, VarToC.lvalueVar (env, x) , exp))                          (trAssign (env, VarToC.lvalueVar (env, x) , exp))
551                    | IL.S_Assign(xs, exp) =>(trMultiAssign (env, List.map (fn x => VarToC.lvalueVar (env, x)) xs, exp))                    | IL.S_Assign(xs, exp) =>(trMultiAssign (env, List.map (fn x => VarToC.lvalueVar (env, x)) xs, exp))
# Line 585  Line 554 
554                          trBlk(env, thenBlk,isVecTy),                          trBlk(env, thenBlk,isVecTy),
555                          trBlk(env, elseBlk,isVecTy))]                          trBlk(env, elseBlk,isVecTy))]
556                    | IL.S_New _ => raise Fail "new not supported yet" (* FIXME *)                    | IL.S_New _ => raise Fail "new not supported yet" (* FIXME *)
557                      | IL.S_Copy( Dst.E_State  x,exp,_,1)=> trAssign (env, VarToC.lvalueStateVar x, exp)
558                    | IL.S_Copy(x,exp,offset,n)=>                    | IL.S_Copy(x,exp,offset,n)=>
559                          [CL.S_Exp (CL.mkApply(N.NameCopyTensor [n],[getVar x,trExp(env,exp),CL.mkIntTy(IntInf.fromInt offset, !N.gIntTy)]))]                          [CL.S_Exp (CL.mkApply(N.NameCopyTensor [n],[getVar x,trExp(env,exp),CL.mkIntTy(IntInf.fromInt offset, !N.gIntTy)]))]
560                 (*   | IL.S_Save([x],exp as IL.E_Var v)=>(case (V.kind v,V.rTy v)                    | IL.S_Save([x],exp as IL.E_Var v)=>(case (V.kind v,V.rTy v)
561                      of (IL.VK_Global,Ty.TensorTy [n]) => let                      of (IL.VK_Global,Ty.TensorTy [n]) => let
562    
563                          val expS=  CL.mkApply(N.NameCopyTensor [n] ,                          val expS=  CL.mkApply(N.NameCopyTensor [n] ,
# Line 596  Line 566 
566                              [CL.S_Exp expS]                              [CL.S_Exp expS]
567                          end                          end
568                      | _ => (trAssign (env, VarToC.lvalueStateVar x, exp))                      | _ => (trAssign (env, VarToC.lvalueStateVar x, exp))
569                      (*end case*))*)                      (*end case*))
570    
571                          | IL.S_Save([x],exp) => (trAssign (env, VarToC.lvalueStateVar x, exp))                          | IL.S_Save([x],exp) => (trAssign (env, VarToC.lvalueStateVar x, exp))
572                    | IL.S_Save(xs, exp) =>                    | IL.S_Save(xs, exp) =>
573                          (trMultiAssign (env, List.map VarToC.lvalueStateVar xs, exp))                          (trMultiAssign (env, List.map VarToC.lvalueStateVar xs, exp))
574                   | IL.S_LoadImage(lhs, dim, name) => checkSts (fn sts => let                   | IL.S_LoadImage(lhs, dim, name) => checkSts (fn sts => let
   
575                        val lhs = VarToC.lvalueVar (env, lhs)                        val lhs = VarToC.lvalueVar (env, lhs)
576                        val name = trExp(env, name)                        val name = trExp(env, name)
577                        val imgTy = CL.T_Named(N.imageTy dim)                        val imgTy = CL.T_Named(N.imageTy dim)
# Line 633  Line 602 
602                    | IL.S_Active => [CL.mkReturn(SOME(CL.mkVar N.kActive))]                    | IL.S_Active => [CL.mkReturn(SOME(CL.mkVar N.kActive))]
603                    | IL.S_Stabilize => [CL.mkReturn(SOME(CL.mkVar N.kStabilize))]                    | IL.S_Stabilize => [CL.mkReturn(SOME(CL.mkVar N.kStabilize))]
604                    | IL.S_Die => [CL.mkReturn(SOME(CL.mkVar N.kDie))]                    | IL.S_Die => [CL.mkReturn(SOME(CL.mkVar N.kDie))]
605                    | IL.S_StoreVec(v,offset,A, isFill, orig, ty,Ty.vectorLength pieces,args)=>let                    | IL.S_StoreVec(v,offset,A, isFill, orig, ty,Ty.vectorLength pieces,args)=>
606                          (*val _=print("\n"^IL.toStringS stm)*)                          storeVec(stm,env,getVar v,offset,A, isFill,orig,ty,pieces,args)
                     in  
                         storeVec(env,getVar v,offset,A, isFill,orig,ty,pieces,args)  
                     end  
607                    | IL.S_Cons(x,n,args)=>  [CL.S_Exp (CL.mkApply(N.NameConsArray n, [VarToC.lvalueVar (env, x)]@trExps(env, args)))]                    | IL.S_Cons(x,n,args)=>  [CL.S_Exp (CL.mkApply(N.NameConsArray n, [VarToC.lvalueVar (env, x)]@trExps(env, args)))]
608    
609                  (* end case *)                  (* end case *)

Legend:
Removed from v.2843  
changed lines
  Added in v.2844

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