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

SCM Repository

[diderot] Diff of /branches/charisee/src/compiler/c-target/opr-to-clang.sml
ViewVC logotype

Diff of /branches/charisee/src/compiler/c-target/opr-to-clang.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  (* Tree-IL Opr expression to Clang *)  (* WQE Tree-IL Opr expression to Clang *)
2    
3  structure OprToClang= struct  structure OprToClang= struct
4    
# Line 14  Line 14 
14    
15      (*-------------- Types ---------------*)      (*-------------- Types ---------------*)
16      val realTy=CL.T_Named(N.mkReal)      val realTy=CL.T_Named(N.mkReal)
17      fun vecTy d= CL.T_Named(N.vecTy d)      val star=CL.T_Ptr realTy
18        fun vecTy d= CL.T_Named(N.OvecTy d)
19      val intTy = CL.intTy      val intTy = CL.intTy
20      fun unionTy d  = CL.T_Named(N.unionTy d )      fun unionTy d  = CL.T_Named(N.unionTy d )
21      val voidTy=CL.voidTy      val voidTy=CL.voidTy
22        fun mkRealArr n=  CL.mkRealArr(N.mkReal,n)
23    
24      (*-------------- var:strings ---------------*)      (*-------------- var:strings ---------------*)
25      val varS="s"  
26      val varR="r"      val varR="r"   (*reals*)
27      val varV="v"      val varV="v"  (*vector*)
28      val tmp= "a"      val varI="i"  (*int*)
29        val varA="a" (*float*)
30        val varU="u" (*unionTy*)
31        val tmp="b" (*unused*)
32    
33      fun mkInt i =CL.mkInt(IntInf.fromInt i)      fun mkInt i =CL.mkInt(IntInf.fromInt i)
34      (*mkVars: int -> var list *)      (*mkVars: int -> var list *)
35      fun mkVar 0=[]      fun mkVar 0=[]
# Line 31  Line 37 
37    
38      (*-------------- E_VAR:exp ---------------*)      (*-------------- E_VAR:exp ---------------*)
39      fun varToVars e=List.map (fn e1=>CL.E_Var e1) e      fun varToVars e=List.map (fn e1=>CL.E_Var e1) e
40        fun varToVar e =CL.E_Var e
41    
42        (*-------------- Params ---------------*)
43        (*Params created from vars*)
44        val ParamA=([], star,varA) (*float ptr * a *)
45        val ParamI=([],intTy, varI)   (*Int i*)
46        fun ParamV n =([],vecTy n, varV) (*vector v*)
47        val ParamR= ([],realTy,varR)  (*Real R *)
48    
49    
   
     (*-------------- Params ---------------*)  
50      (* mkParams:creates Params      (* mkParams:creates Params
51      * (attr list, ty, var)-> Param List      * (attr list, ty, var)-> Param List
52      *)      *)
53      fun mkParam e= CL.PARAM e      fun mkParam e= CL.PARAM e
54      fun mkParams e=List.map (fn e1=> CL.PARAM e1) e      fun mkParams e=List.map (fn e1=> mkParam e1) e
55    
56    
57      (* mkParamsSameType:Create params with the same type      (* mkParamsSameType:Create params with the same type
# Line 49  Line 60 
60      fun mkParamsSameType(ty,args)=List.map (fn e=>CL.PARAM([],ty,e)) args      fun mkParamsSameType(ty,args)=List.map (fn e=>CL.PARAM([],ty,e)) args
61    
62    
     (*list of vectors=>  (size, var, vec type)list * PARAMS list *)  
     fun foundPieces pieces =let  
         fun m(_,[],info,params)=(info,params)  
         | m(c,e1::es,info,params)=let  
             val var=varV^(q c)  
             val ty=vecTy e1  
             val p1=mkParam([],ty, var)  
             val i=(e1, ty,CL.E_Var var)  
             in  
                 m(c+1,es, info@[i], params@[p1] )  
             end  
         in m(0,pieces,[],[]) end  
   
   
   
63      (*-------------- Exp functions ---------------*)      (*-------------- Exp functions ---------------*)
64    
65        fun mkRtn e=CL.S_Return(SOME e)
66        val  voidRtn =CL.S_Return NONE
67      (*mkCastStruct:Create a cast expression      (*mkCastStruct:Create a cast expression
68       *ClangTy, exp list -> exp       *ClangTy, exp list -> exp
69       *)       *)
70      fun mkCastStruct(ty,body)=CL.E_Cast(ty, (CL.E_Struct body))      fun mkCastStruct(ty,body)=CL.E_Cast(ty, (CL.E_Struct body))
71      fun mkCastVar(ty,body)=CL.E_Cast(ty, CL.E_Var body)      fun mkCastVar(ty,body)=CL.E_Cast(ty, body)
   
72    
73    
74      (*ty:vectTy n  varU = (ty) varA*)      (*ty:vectTy n  u = (ty) a*)
75      fun mkExtVar(n, varU,varA)=let      fun mkExtVar(n, u,VarA)=let
76          val uty=unionTy n          val uty=unionTy n
         val exp=mkCastVar(uty, varA)  
         val e1=CL.E_TyVar(uty,varU)  
         val e2=CL.E_Ext exp  
         val C= CL.S_Eq (e1, e2)  
         val C4=  CL.S_Exp(CL.E_AssignOp  (e1, CL.$=,e2))  
         in  
             (C,varU^".r")  
         end  
77    
78      fun mkExtStruct(n, varU,varA)=let          val e1=CL.E_TyVar(uty,u)
79          val uty=unionTy n           val exp=mkCastVar(uty, VarA)
         val exp=mkCastStruct(uty, varA)  
         val e1= CL.E_TyVar(uty,varU)  
80          val e2= CL.E_Ext exp          val e2= CL.E_Ext exp
81          val C= CL.S_Eq( e1, e2)          val C= CL.S_Eq( e1, e2)
82           val C4= CL.S_Exp( CL.E_AssignOp (e1,CL.$=, e2))           val C4= CL.S_Exp( CL.E_AssignOp (e1,CL.$=, e2))
   
83          in          in
84              (C,varU^".r")              (C, CL.E_Var (u^".r"))
85          end          end
86    
87    
   
88      (* mkProd:create a Product Operation      (* mkProd:create a Product Operation
89        exp *exp ->  exp        exp *exp ->  exp
90      *)      *)
# Line 108  Line 94 
94      | mkAddM (a::b::es)= mkAddM (CL.mkBinOp(a, CL.#+, b)::es)      | mkAddM (a::b::es)= mkAddM (CL.mkBinOp(a, CL.#+, b)::es)
95    
96    
   
   
97      (*Should I use Subscript and E_Int?*)      (*Should I use Subscript and E_Int?*)
98      fun indexDiderotType(U,0)=[CL.E_Subscript(U,mkInt  0)]      fun indexDiderotType(U,0)=[CL.E_Subscript(U,mkInt  0)]
99        | indexDiderotType(U,n)=        | indexDiderotType(U,n)=
100          indexDiderotType(U,n-1)@[CL.E_Subscript(U,mkInt  n)]          indexDiderotType(U,n-1)@[CL.E_Subscript(U,mkInt  n)]
101    
102      fun indexDiderotTypeWithOffset(U,0,var)=      fun indexDiderotTypeWithOffset(U,0,I)=
103          [CL.E_Subscript(U,mkAdd(mkInt 0,var))]          [CL.E_Subscript(U,I)]
104        | indexDiderotTypeWithOffset(U,n,var)=        | indexDiderotTypeWithOffset(U,n,I)=
105          indexDiderotTypeWithOffset(U,n-1,var)@          indexDiderotTypeWithOffset(U,n-1,I)@
106          [CL.E_Subscript(U,mkAdd(mkInt n,var))]          [CL.E_Subscript(U,mkAdd(mkInt n,I))]
107    
108    
109    
# Line 132  Line 116 
116              List.tabulate (n,fn _=> z)              List.tabulate (n,fn _=> z)
117          end          end
118    
119    
120        fun setEq([],[])=[]
121          | setEq (l::lhs, r::rhs)=[CL.S_Eq (l ,r)]@ setEq(lhs,rhs)
122    
123      (*-------------- Dec functions from Ops ---------------*)      (*-------------- Dec functions from Ops ---------------*)
124    
125      (* createDec(): create a CLang Decl      (* createDec(): create a CLang Decl
126       * Ty,string, exp list, exp list -> Declaration       * Ty,string, exp list, exp list -> Declaration
127      *)      *)
128      fun createDec(rtnType, fnName, params,blk)= let      fun createDec(rtnType, fnName, params,blk)=   CL.D_Func([],rtnType,fnName,params,CL.S_Block blk)
129          val stmt'=CL.S_Block blk  
130          in  
131              CL.D_Func([],rtnType,fnName,params,stmt')   (*Intermediate Statement from reals -> RealArray*)
132     fun IntermediateCons(d,VARS) =let
133        val ty=mkRealArr [d]
134        val tmpVar=CL.E_TyVar(ty,varA)
135        val stmt=CL.S_Eq(tmpVar,CL.E_Struct VARS)
136        in (varA, stmt)
137          end          end
138    
139    
140      fun mkScaV d= let      fun mkScaV d= let
141          val rtnType= vecTy d          val rtnType= vecTy d
142          val fnName=N.NameScaV d          val fnName=N.NameScaV d
143          val params=mkParams[([],realTy,varR),([],rtnType,varV)]      val params=mkParams[ParamR,([],rtnType,varV)]
   
144          (*Return Expression *)          (*Return Expression *)
145          val varList=List.tabulate(d, (fn _=>CL.E_Var varR))          val varList=List.tabulate(d, (fn _=>CL.E_Var varR))
146          val fnCall=N.mkVec d (*N.NameConsVec d*)      val fnCall=N.NameConsVec d
147          val s=CL.E_Apply(fnCall, varList)          val s=CL.E_Apply(fnCall, varList)
148          val v=CL.E_Var varV      val VarV=varToVar varV
149          val body=SOME(mkProd(s,v))      val rtn=mkRtn(mkProd(s,VarV))
         val rtn=CL.S_Return body  
150          in          in
151              createDec(rtnType, fnName, params,[rtn])              createDec(rtnType, fnName, params,[rtn])
152          end          end
153    
   
   
154      fun mkSumV d= let      fun mkSumV d= let
155          val rtnType= realTy          val rtnType= realTy
156          val fnName=N.NameSumV d          val fnName=N.NameSumV d
157          val params=mkParamsSameType(vecTy d, [varV])          val params=mkParams[ParamV d]
158            val VarV=varToVar varV
159          val (e,ur)=mkExtVar(d, "u",varV)          val (e,VarUR)=mkExtVar(d, varU,VarV)
160    
161          (*Return Expression *)          (*Return Expression *)
162          val indexedVec=indexDiderotType(CL.E_Var ur,d-1)          val indexedVec=indexDiderotType(VarUR,d-1)
163          val body=(mkAddM indexedVec)          val rtn=mkRtn(mkAddM indexedVec)
         val rtn=CL.S_Return(SOME body)  
164          in          in
165              createDec(rtnType, fnName, params,[e,rtn])              createDec(rtnType, fnName, params,[e,rtn])
166          end          end
# Line 181  Line 169 
169    
170          (*-------------- Dec functions from CONS ---------------*)          (*-------------- Dec functions from CONS ---------------*)
171    
     fun mkRealToVec d=let  
172    
173          val rtnType= vecTy d      fun mkRealToArr d=let
174          val fnName=N.NameConsVec d          val rtnType= voidTy
175            val fnName=N.NameConsArray d
176          val vars=mkVar d          val vars=mkVar d
177          val params=mkParamsSameType(realTy, vars)          val Vars=varToVars vars
178            val params=[mkParam ParamA]@ mkParamsSameType(realTy, vars)
179            val VarA= CL.E_Var varA
180    
181          (*Return Expression *)          val lhs=indexDiderotType(VarA, d-1)
182          val VARS=varToVars vars          val stmts=setEq(lhs,Vars)
         val body'= mkCastStruct(rtnType,VARS)  
         val body= SOME(CL.E_Ext(body'))  
         val rtn=CL.S_Return body  
183          in          in
184              createDec(rtnType, fnName, params,[rtn])              createDec(rtnType, fnName, params,stmts@[voidRtn])
185          end          end
186    
     fun mkRealToVec2 d=let  
187    
188        fun mkRealToVec d=let
189          val rtnType= vecTy d          val rtnType= vecTy d
190          val fnName=N.NameConsVec d          val fnName=N.NameConsVec d
191          val vars=mkVar d          val vars=mkVar d
# Line 207  Line 194 
194   (*Return Expression *)   (*Return Expression *)
195   val VARS=varToVars vars   val VARS=varToVars vars
196   val body'= mkCastStruct(rtnType,VARS)   val body'= mkCastStruct(rtnType,VARS)
197   val body= SOME(CL.E_Ext(body'))          val rtn= mkRtn(CL.E_Ext(body'))
  val rtn=CL.S_Return body  
198   in   in
199   createDec(rtnType, fnName, params,[rtn])   createDec(rtnType, fnName, params,[rtn])
200   end   end
201    
202    
   
203          (*-------------- Dec functions from LDVec ---------------*)          (*-------------- Dec functions from LDVec ---------------*)
204      (*addr,offset(int)*)      (*Does Load when not aligned*)
205        (* val (e,VarUR)=mkExtVar(tyOrig, varU,VarA)*)
206       fun generalLdVec(tyNew,tyOrig,fnName) =let       fun ldVec(tyNew,tyOrig,rtnType,VarA,VarI) =let
207          val VarV=CL.E_Var varV          fun fillVec var=let
208          val VarS=CL.E_Var varS              val indexedVec=indexDiderotTypeWithOffset(var,tyOrig-1,VarI)
   
         fun fillVec(tyNew,tyOrig,var)=let  
             val indexedVec=indexDiderotType(var,tyOrig-1)  
209              val fill=mkZero(tyNew-tyOrig)              val fill=mkZero(tyNew-tyOrig)
210              in              in
211                  indexedVec@fill                  indexedVec@fill
212              end              end
213          fun sliceVec(tyNew,var)=          fun sliceVec var= indexDiderotTypeWithOffset(var,tyNew-1,VarI)
             indexDiderotTypeWithOffset(var,tyNew-1,VarS)  
   
         val rtnType= vecTy tyNew  
         val params=mkParams[([],vecTy tyOrig,varV),([],intTy, varS)]  
   
   
         val (e,ur)=mkExtVar(tyOrig, "u",varV)  
         val VarUR=CL.E_Var ur  
   
214          val pieces= (if (tyNew>tyOrig)          val pieces= (if (tyNew>tyOrig)
215              then fillVec(tyNew, tyOrig,VarUR)              then fillVec VarA
216              else sliceVec(tyNew,VarUR)              else sliceVec VarA
217              (*end case*))              (*end case*))
         val body=SOME(mkCastStruct(rtnType,pieces))  
         val rtn=CL.S_Return body  
218          in          in
219               createDec(rtnType, fnName, params,[e,rtn])          [mkRtn (mkCastStruct(rtnType,pieces))]
220          end          end
221    
     (*ldVec aligned or not use the same function for now*)  
222    
     fun ldVec(tyNew,tyOrig) =let  
         val fnName=N.NameLdVec(tyNew,tyOrig)  
     in  
             generalLdVec(tyNew,tyOrig,fnName)  
     end  
223    
224      fun ldVecA(tyNew,tyOrig) =let  
225          val fnName=N.NameLdVecA(tyNew,tyOrig)      (*General Load*)
226        fun generalldVec(A,tyNew,tyOrig) =let
227            val VarA= CL.E_Var varA
228            val VarI=CL.E_Var varI
229            val rtnType= vecTy tyNew
230            val fnName=N.NameLdVec(A,tyNew,tyOrig)
231            val stmts=(case A
232                of false =>ldVec(tyNew,tyOrig,rtnType,VarA,VarI)
233                | true =>
234                    [mkRtn (CL.E_Ref(vecTy tyNew,CL.E_Subscript(VarA,VarI)))]
235                (*end case*))
236            val params=mkParams[ParamA,ParamI]
237      in      in
238              generalLdVec(tyNew,tyOrig,fnName)          createDec(rtnType, fnName, params,stmts)
239      end      end
240    
241    
242    
243          (*-------------- Dec functions from mKVec ---------------*)          (*-------------- Dec functions from mKVec ---------------*)
244    
245    (* Aligned store vec body
246     * (vec2f_t )&(A[4])=v;
247      (*   (vec2f_t )&(v[4])=b;*)   *)
248      fun mkVec0(tyOrig, pieces)= let      fun mkVec0(tyR, ty,VarA,VarI,VarV)= let
249          val rtnType=voidTy          val e=   CL.E_Subscript(VarA,VarI)
         val fnName=N.NameMkVecA tyOrig  
         val varU="U"  
         val VarU= CL.E_Var varU  
   
         val p1=mkParams[([], realTy,String.concat[varU,"[",q tyOrig,"]"])]  
         val (info, param)=foundPieces pieces  
         val params=p1@param  
         fun sort(0,_,[],rest)= rest  
         | sort(0,_,_,rest) =raise Fail "Too Many vectors for mkVec"  
         | sort(rtnN,indexAt,[(p, ty,var)],rest)=let  
             val e= CL.E_Subscript(VarU,mkInt  indexAt)  
             val lhs= CL.E_Ref(ty, e)  
             in rest@[CL.S_Eq (lhs ,var)] end  
         | sort(rtnN,indexAt, (p, ty,var)::es,rest)=let  
             val e= CL.E_Subscript(VarU,mkInt  indexAt)  
250              val lhs= CL.E_Ref(ty, e)              val lhs= CL.E_Ref(ty, e)
             val e2=[CL.S_Eq (lhs ,var)]  
             in  
                 sort(rtnN-p,indexAt+p,es,rest@e2)  
             end  
   
         val stmts=sort(tyOrig,0, info, [])  
         val rtn=CL.S_Return NONE  
     in  
         createDec(rtnType, fnName, params,stmts@[rtn])  
     end  
   
   
     (*Helpers*)  
  (*use extensions*)  
     fun peelA([],stmts,newInfo)= (stmts,newInfo)  
     |  peelA((p,ty,CL.E_Var var)::es, stmts, newInfo) = let  
         val (e, ur)= mkExtVar(p, var^"_u",var)  
         in peelA(es, stmts@[e], newInfo@[(p, ty, CL.E_Var ur)])  
         end  
   
  fun sortA(0,[],rest)= rest  
    | sortA(0,_,rest) =raise Fail "Too Many vectors for mkVec"  
    | sortA(rtnN,[(p, ty,var)],rest)=let  
         val indexedVec= indexDiderotType(var,rtnN-1)  
251          in          in
252              rest@indexedVec         [CL.S_Eq (lhs ,VarV)]
253          end          end
    | sortA(rtnN,(p, ty,var)::es,rest)=let  
         val indexedVec= indexDiderotType(var,p-1)  
         in  
             sortA(rtnN-p,es,rest@indexedVec)  
         end  
  fun mA(_,lhsvar,[],rest)=rest  
    | mA (n,lhsvar, rhs::es,rest)=let  
         val lhs= CL.E_Subscript(lhsvar,mkInt n)  
         val e2=[CL.S_Eq (lhs ,rhs)]  
         in mA (n+1, lhsvar,es, rest@e2)  
         end  
   
     (*Tries to use union on rtn variable, but then what do we return?*)  
     fun mkVecDoubleExt(tyOrig, pieces)= let  
         val rtnType=voidTy  
         val fnName=N.NameMkVecA tyOrig  
         val varU="U"  
         val varZ="Z"  
         val VarZ= CL.E_Var varZ  
         val ty=vecTy tyOrig  
         val p1=mkParams[([],ty,varZ)]  
         val (info, param)=foundPieces pieces  
         val (e1, varur)= mkExtVar(tyOrig, varU,varZ)  
         val VarU= CL.E_Var varur  
         val params=p1@param  
         val (stmts, info)=peelA(info, [],[])  
         val e=sortA(tyOrig, info, [])  
         val e=mA(0,VarU,e,[])  
         val e2=CL.S_Eq (VarZ, CL.E_Select(CL.E_Var "U","v"))  
         val rtn=CL.S_Return NONE  
   
254    
         in  
           createDec(rtnType, fnName, params,[e1]@stmts@e@[e2,rtn])  
   
         end  
255    
256   (*Send back vectype by a cast   (*not aligned store Vec body *)
257    * none ->vecTy   fun mkVec1(tyN,tyO, VarA,VarI,VarV)= let
258    *)      val (stmt, VarUR)= mkExtVar(tyN, varU,VarV)
259        val rhs= indexDiderotType(VarUR,tyO-1)
260        val lhs=indexDiderotTypeWithOffset(VarA, tyO-1, VarI)
261        val e=setEq(lhs,rhs)
262    
  fun mkVec3(tyOrig, pieces)= let  
     val rtnType=voidTy  
     val fnName=N.NameMkVecA tyOrig  
     val varU="U"  
     val VarU= CL.E_Var varU  
     val ty=vecTy tyOrig  
     val (info, params)=foundPieces pieces  
     val (stmts, info)=peelA(info, [],[])  
     val e=sortA(tyOrig, info, [])  
     val ecast= mkCastStruct(ty,e)  
     val rtn=CL.S_Return(SOME ecast)  
263      in      in
264          createDec(ty, fnName, params,stmts@[rtn])          [stmt]@e
265      end      end
266    
267    
268     (*General store function *)
269   (*realty-> void *)   fun generalmkVec(aligned,tyN,tyOrig)= let
  fun mkVec1(tyOrig, pieces)= let  
270      val rtnType=voidTy      val rtnType=voidTy
271      val fnName=N.NameMkVec tyOrig      val fnName=N.NameMkVec(aligned,tyN,tyOrig)
272      val varU="U"      val VarA= CL.E_Var varA
273      val VarU= CL.E_Var varU      val VarI=CL.E_Var varI
274      val p1=mkParams[([], realTy,String.concat[varU,"[",q tyOrig,"]"])]      val VarV= CL.E_Var varV
275      val (info, param)=foundPieces pieces      val ty=vecTy tyN
276      val params=p1@param      val params=mkParams [ParamA,ParamI,([],ty, varV)]
277      val (stmts, info)=peelA(info, [],[])      val stmts=(case aligned
278      val e=sortA(tyOrig, info, [])          of false => mkVec1(tyN,tyOrig,VarA,VarI,VarV)
279      val e=mA(0,VarU,e,[])          | true =>   mkVec0(tyN, ty, VarA,VarI,VarV)
     val rtn=CL.S_Return NONE  
     in  
         createDec(rtnType, fnName, params,stmts@e@[rtn])  
     end  
   
   
     fun handleVec(tyOrig,pieces)=let  
         val Attempt=3  
        (*First 3 use MK(var,exp) statment and the last one is an assignment *)  
         in (case Attempt  
           of 0=>   (* realTy-> void   (vec2f_t )&(v[4])=b;*)  
                 mkVec0(tyOrig, pieces)  
           | 1    =>(*realTY-> void, does union indexes elements U[0]=..*)  
                 mkVec1(tyOrig, pieces)  
           | 2=>    (*vecTy-> void, uses union, gets warnings *)  
                 mkVecDoubleExt(tyOrig, pieces)  
   
           | 3=> (* void->vecTy  uses a cast*)  
             mkVec3(tyOrig, pieces)  
280          (*end case*))          (*end case*))
         end  
281    
282        in
283            createDec(rtnType, fnName, params,stmts@[ voidRtn])
284        end
285    
286    
287      val default=CL.D_NotDone      val default=CL.D_NotDone
288    
289      (* handleOPr: transform Tree-IL Opr to CLang Declarations*)      (* handleOPr: transform Tree-IL Opr to CLang Declarations*)
290      fun handleOpr( ILF.LD (tyNew,tyOrig))=ldVec(tyNew,tyOrig)      fun handleOpr( ILF.LD (b,tyNew,tyOrig))= generalldVec(b,tyNew,tyOrig)
291        | handleOpr( ILF.MKVEC (tyOrig,Ty.vectorLength pieces))=handleVec(tyOrig,pieces)        | handleOpr( ILF.MKVEC (A,tyR,tyO))=
292        | handleOpr (ILF.MKVEC _)= raise Fail "Unsupported mkVec type"              generalmkVec(A,tyR,tyO)
293        | handleOpr( ILF.CONS(Ty.TensorTy[n]))= mkRealToVec n        | handleOpr( ILF.CONSV n)= mkRealToVec n
294          | handleOpr( ILF.CONS(Ty.TensorTy[n]))=mkRealToArr n
295        | handleOpr( ILF.CONS _)=  default        | handleOpr( ILF.CONS _)=  default
296    
297        | handleOpr( ILF.OP(Op.prodScaV d))=mkScaV d        | handleOpr( ILF.OP(Op.prodScaV d))=mkScaV d
298        | handleOpr( ILF.OP(Op.sumVec d))=mkSumV d        | handleOpr( ILF.OP(Op.sumVec d))=mkSumV d
299         (* | handleOpr( ILF.OP(Op.Floor d))=mkSumV d*)
300    
301        | handleOpr( ILF.OP(Op.IndexTensor(a,RTy,b,c)))=default        | handleOpr( ILF.OP(Op.IndexTensor(a,RTy,b,c)))=default
302        | handleOpr( ILF.OP(Op.addVec _))=default        | handleOpr( ILF.OP(Op.addVec _))=default
303        | handleOpr( ILF.OP(Op.subVec _))=default        | handleOpr( ILF.OP(Op.subVec _))=default
304        | handleOpr( ILF.OP(Op.prodVec _))=default        | handleOpr( ILF.OP(Op.prodVec _))=default
305        | handleOpr( ILF.OP e)= raise Fail("OPR of Op:"^Op.toString(e))        | handleOpr( ILF.OP e)= raise Fail("OPR of Op:"^Op.toString(e))
306        | handleOpr( ILF.LDAligned (tyNew,tyOrig))=ldVecA(tyNew,tyOrig)  
       | handleOpr( ILF.MKVECAligned (tyOrig,Ty.vectorLength  pieces))=handleVec(tyOrig,pieces)  
307    
308    
309    

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