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

SCM Repository

[diderot] Diff of /branches/charisee/src/compiler/tree-il/getTypes.sml
ViewVC logotype

Diff of /branches/charisee/src/compiler/tree-il/getTypes.sml

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

revision 2689, Thu Aug 28 13:59:40 2014 UTC revision 2690, Fri Aug 29 15:41:22 2014 UTC
# Line 14  Line 14 
14      val testing=0      val testing=0
15    
16    
 (*print Types*)  
 fun prnTy((t1,t2),prefix)=let  
   
 val typs=TySet.listItems(t1);  
 val ops=OprSet.listItems(t2);  
 val str1= List.map Ty.toString typs  
 val str2=List.map ILF.toString ops  
 val pnstr= String.concat["CCCC\n",prefix,"\n \t Types: ",String.concatWith "," str1,  
 "\n \t cFn: ",String.concatWith "\n\t" str2]  
   
 in pnstr end  
   
   
17    (* GetTypes TreeIL operator. *)    (* GetTypes TreeIL operator. *)
18      val default=([],[])      val default=([],[])
19    
20      (*rator-> (types, cfns )*)      (*stmt-> sets(TySet, OprSet)*)
21      fun TypeofOp rator = (case rator      fun TypeofOp rator = (case rator
22          of  Op.IndexTensor(a,RTy,b,c)=>([RTy],[])          of  Op.IndexTensor(a,RTy,b,c)=>([RTy],[])
         (* Op.IndexTensor(a,RTy,b,c)=> ([RTy], [ILF.OP(Op.IndexTensor(a,RTy,b,c)))]*)  
23          | Op.addVec d               => ([vecTy d],[ILF.OP(Op.addVec d)])          | Op.addVec d               => ([vecTy d],[ILF.OP(Op.addVec d)])
24          | Op.subVec d               => ([vecTy d],[ILF.OP(Op.subVec d)])          | Op.subVec d               => ([vecTy d],[ILF.OP(Op.subVec d)])
25          | Op.prodVec d              => ([vecTy d],[ILF.OP(Op.prodVec d)])          | Op.prodVec d              => ([vecTy d],[ILF.OP(Op.prodVec d)])
26          | Op.prodScaV d             => ([vecTy d],[ILF.CONSV d,ILF.OP(Op.prodScaV d)])          | Op.prodScaV d             => ([vecTy d],[ILF.CONSV d,ILF.OP(Op.prodScaV d)])
27                      (*need different cons here*)          | Op.dotVec d               => ([vecTy d],[ILF.OP(Op.dotVec d)])
         | Op.sumVec d               => (([Ty.unionTy d],   [ILF.OP(Op.sumVec d)]))  
         | Op.dotVec d               => ([Ty.vecTy d],   [ILF.OP(Op.dotVec d)]) (*check here*)  
28          | Op.Floor d                => ([vecTy d],[ILF.OP(Op.Floor d)])          | Op.Floor d                => ([vecTy d],[ILF.OP(Op.Floor d)])
29          | Op.imgLoad(_,_,d)         => ([vecTy d],[ILF.CONS(vecTy d)])          | Op.imgLoad(_,_,d)         => ([vecTy d],[ILF.CONS(vecTy d)])
30            | Op.sumVec d               => (([Ty.unionTy d],[ILF.OP(Op.sumVec d)]))
31          | _ => default          | _ => default
32          (* end case *))          (* end case *))
33        and expToOpr(set1,exp)=(case exp
34            of IL.E_State _                 => set1
35            | IL.E_Var _                    => set1
36      (*fun peel(IL.E_Lit( offset))=offset*)          | IL.E_Lit _                    => set1
37            | IL.E_Mux _                    => set1
38      fun mkFnC(IL.E_LoadArr(A,fTy, oTy,_, offset))=[ILF.LDArr(A,fTy,oTy)]          | IL.E_Apply (_, exps)          => addToSet(set1,default,exps)
39        | mkFnC(IL.E_Cons (ty , exps))= [ILF.CONS ty]          | IL.E_Cons (ty , exps)         => addToSet(set1,([ty], [ILF.CONS ty]),exps)
40        | mkFnC e= []          | IL.E_LoadArr(A,fTy,oTy,exp,_) => addToSet(set1,([vecTy fTy],[ILF.LDArr(A,fTy,oTy)]),[exp])
41            | IL.E_Op(Op, exps)             => addToSet(set1,TypeofOp Op, exps)
42            (*end case*))
43        and addToSet(set1,(typ,cfn),rest)= let
44      fun set(t,typ,cfn)= let          val (ty1,opr1)=set1
         val (ty1,opr1)=t  
45          val opr2=List.foldr (fn(e1,e2) =>OprSet.add(e2,e1)) opr1 cfn          val opr2=List.foldr (fn(e1,e2) =>OprSet.add(e2,e1)) opr1 cfn
46          val ty2=List.foldr (fn(e1,e2) =>TySet.add(e2,e1)) ty1 typ          val ty2=List.foldr (fn(e1,e2) =>TySet.add(e2,e1)) ty1 typ
47            val sets2=(ty2,opr2)
48          in          in
49              (ty2,opr2)               List.foldr (fn(e1,e2) => expToOpr(e2,e1)) sets2 rest
50          end          end
51        and stmtToOpr(set1,stmt)=(case stmt
52      (*Get types of Exp*)          of IL.S_Input (_,_,_, NONE)     => set1
53      fun typeOfExp(t,exp)=let          |  IL.S_Assign (_,exp)          => expToOpr(set1,exp)
54            | IL.S_IfThen(exp,_)            => expToOpr(set1,exp)
55          fun add(([],[]),rest)= List.foldr (fn(e1,e2) => typeOfExp(e2,e1)) t rest          | IL.S_IfThenElse( exp,_,_)     => expToOpr(set1,exp)
56          | add((typ,cfn),rest)= let          | IL.S_LoadImage(_,_, exp)      => expToOpr(set1,exp)
57              val t2=set(t,typ, cfn)          | IL.S_Input (_,_,_, SOME exp ) => expToOpr(set1,exp)
58            | IL.S_Save(_,exp)              => expToOpr(set1,exp)
59              in          | IL.S_New (_, exps)            => List.foldr (fn(e1,e2)=> expToOpr(e2,e1)) set1 exps
60                  List.foldr (fn(e1,e2) => typeOfExp(e2,e1)) t2 rest          | IL.S_Exit exps                => List.foldr (fn(e1,e2)=> expToOpr(e2,e1)) set1 exps
             end  
         in (case exp  
             of IL.E_State(state_var)    => t  
             | IL.E_Var(var)             => t  
             | IL.E_Lit _                => t  
             | IL.E_Apply (_, exps)      => add(default,exps)  
             | IL.E_Cons (ty , exps)     => add(([ty],mkFnC exp),exps)  
             | IL.E_LoadArr(_,ty,_,exps,_) => add(([vecTy ty],mkFnC exp),[exps])  
             | IL.E_Op(Op, exps)         => add(TypeofOp Op, exps)  
             | IL.E_Mux _                => t  
   
             (*end case*))  
         end  
   
     fun typeOfStmt(t,stmt)=(case stmt  
         of  IL.S_Assign (_,exp)=> typeOfExp(t,exp)  
61          | IL.S_StoreVec(_,A,nSize,oSize,Ty.vectorLength pieces,exps) => let          | IL.S_StoreVec(_,A,nSize,oSize,Ty.vectorLength pieces,exps) => let
62              val typ=[vecTy oSize,Ty.unionTy oSize]              val typ=[vecTy oSize,Ty.unionTy oSize]
63              val fnc=List.map (fn p => ILF.STORE (A,p,oSize)) pieces              val fnc=List.map (fn p => ILF.STORE (A,p,oSize)) pieces
             val t2=set(t,typ, fnc)  
64              in              in
65                  List.foldr (fn(e1,e2) => typeOfExp(e2,e1)) t2 exps                  addToSet(set1, (typ,fnc),exps)
66              end              end
67            | _                             => set1
68      (*end case*))      (*end case*))
69    
   
   
   
     fun prnTyFinal(typs,ops,prefix)=let  
         val str1= List.map Ty.toString typs  
         val str2=List.map ILF.toString ops  
         val pnstr= String.concat["DDDD\n",prefix,"\n \t Types: ",String.concatWith "," str1,  
             "\n \t cFn: ",String.concatWith "\n\t" str2]  
         in pnstr end  
   
   
   
     fun getTypesFiltered(t,stmt)=typeOfStmt(t,stmt)  
   
   
70  end  end

Legend:
Removed from v.2689  
changed lines
  Added in v.2690

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