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

SCM Repository

[diderot] Diff of /branches/vis15/src/compiler/low-to-tree/low-to-tree.sml
ViewVC logotype

Diff of /branches/vis15/src/compiler/low-to-tree/low-to-tree.sml

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

revision 3851, Thu May 12 19:27:43 2016 UTC revision 3853, Fri May 13 18:14:10 2016 UTC
# Line 64  Line 64 
64      val {getFn = getStateVar, ...} = SV.newProp mkStateVar      val {getFn = getStateVar, ...} = SV.newProp mkStateVar
65      end      end
66    
67      (* for variables that are in an equivalence class (see UnifyVars), we use a single
68       * TreeIR variable (or vector of variables) to represent them.
69       *)
70        datatype eq_var_rep = NOEQ | VAR of TV.t | VEC of TV.t list
71        local
72          val {peekFn : IR.var -> eq_var_rep option, setFn, ...} =
73                V.newProp (fn x => raise Fail(V.toString x))
74        in
75        fun eqClassRepOf (env, x) = (case UnifyVars.eqClassOf x
76               of SOME x' => (case peekFn x'
77                     of SOME b => b
78                      | NONE => let
79                          val rep = (case V.ty x'
80                                 of Ty.TensorTy[d] => VEC(Util.newVectorVars(Env.layoutVec env d))
81                                  | ty => VAR(Util.newLocalVar x)
82                                (* end case *))
83                          in
84                            setFn (x, rep);
85                            rep
86                          end
87                    (* end case *))
88                | NONE => NOEQ
89              (* end case *))
90        end
91    
92      fun mkBlock stms = T.Block{locals = ref [], body = stms}      fun mkBlock stms = T.Block{locals = ref [], body = stms}
93      fun mkIf (x, stms, []) = T.S_IfThen(x, mkBlock stms)      fun mkIf (x, stms, []) = T.S_IfThen(x, mkBlock stms)
94        | mkIf (x, stms1, stms2) = T.S_IfThenElse(x, mkBlock stms1, mkBlock stms2)        | mkIf (x, stms1, stms2) = T.S_IfThenElse(x, mkBlock stms1, mkBlock stms2)
# Line 73  Line 98 
98        | cvtScalarTy (Ty.TensorTy[]) = TTy.realTy        | cvtScalarTy (Ty.TensorTy[]) = TTy.realTy
99        | cvtScalarTy ty = raise Fail(concat["cvtScalarTy(", Ty.toString ty, ")"])        | cvtScalarTy ty = raise Fail(concat["cvtScalarTy(", Ty.toString ty, ")"])
100    
101      (* get a variable's binding as a single argument expression.  This means that
102       * if x is bound to a vector of expressions, then we need to pack it.
103       *)
104      fun singleArg env x = (case Env.useVar env x      fun singleArg env x = (case Env.useVar env x
105             of Env.TREE e => e             of Env.TREE e => e
106              | Env.VEC(layout, es) => T.E_Pack(layout, es)              | Env.VEC(layout, es) => T.E_Pack(layout, es)
107            (* end case *))            (* end case *))
108    
109        fun scalarArg env x = (case Env.useVar env x
110               of Env.TREE e => e
111                | _ => raise Fail("expected scalar binding for " ^ IR.Var.toString x)
112              (* end case *))
113    
114      fun vectorArg (env, x) = (case Env.useVar env x      fun vectorArg (env, x) = (case Env.useVar env x
115             of Env.TREE e => (case IR.Var.ty x             of Env.TREE e => (case IR.Var.ty x
116                   of Ty.TensorTy[d] => let                   of Ty.TensorTy[d] => let
# Line 112  Line 145 
145              (layout, List.map List.rev argLists)              (layout, List.map List.rev argLists)
146            end            end
147    
148      fun trOp (env, lhs, srcRator, args) = let      fun trOp (env, srcRator, args) = let
           fun getBinding x = (case Env.useVar env x  
                  of Env.TREE e => e  
                   | _ => raise Fail("expected single binding for " ^ IR.Var.toString x)  
                 (* end case *))  
           fun assignOp rator = let  
                 val stm = T.S_Assign(??, T.E_Op(rator, List.map getBinding args))  
                 in  
                   [stm]  
                 end  
149  (* FIXME: if the use count of lhs is > 1, then we should bind to a local variable *)  (* FIXME: if the use count of lhs is > 1, then we should bind to a local variable *)
150            fun bindOp rator = (            fun bindOp rator = Env.TREE(T.E_Op(rator, List.map (scalarArg env) args))
                 Env.bindVar (env, lhs, Env.TREE(T.E_Op(rator, List.map getBinding args)));  
                 [])  
151            fun bindVOp rator = let            fun bindVOp rator = let
152                  val (layout, argss) = vectorArgs (env, args)                  val (layout, argss) = vectorArgs (env, args)
153                  val exps = ListPair.map                  val exps = ListPair.map
154                        (fn (w, args) => T.E_Op(rator w, args))                        (fn (w, args) => T.E_Op(rator w, args))
155                          (#pieces layout, argss)                          (#pieces layout, argss)
156                  in                  in
157                    Env.bindVar (env, lhs, Env.VEC(layout, exps));                    Env.VEC(layout, exps)
                   []  
158                  end                  end
159            in            in
160              case srcRator              case srcRator
# Line 166  Line 187 
187                | Op.VScale _ => bindVOp TOp.VScale                | Op.VScale _ => bindVOp TOp.VScale
188                | Op.VMul _ => bindVOp TOp.VMul                | Op.VMul _ => bindVOp TOp.VMul
189                | Op.VNeg _ => bindVOp TOp.VNeg                | Op.VNeg _ => bindVOp TOp.VNeg
190                | Op.VSum _ => ??                | Op.VSum _ => raise Fail "FIXME: VSum"
191                | Op.VIndex(_, i) => let                | Op.VIndex(_, i) => let
192  (* FIXME: more efficient to lookup the variable and avoid expanding TREE args *)  (* FIXME: more efficient to lookup the variable and avoid expanding TREE args *)
193                    val ({pieces, ...}, es) = vectorArg (env, hd args)                    val ({pieces, ...}, es) = vectorArg (env, hd args)
194                    fun select (i, w::ws, e::es) =                    fun select (i, w::ws, e::es) =
195                          if (i < w)                          if (i < w)
196  (* FIXME: what if lhs is used more than once? *)  (* FIXME: what if lhs is used more than once? *)
197                            then Env.bindVar (env, lhs, Env.TREE(T.E_Op(TOp.VIndex(w, i), [e])))                            then Env.TREE(T.E_Op(TOp.VIndex(w, i), [e]))
198                            else select (i-w, ws, es)                            else select (i-w, ws, es)
199                      | select _ = raise Fail("bogus " ^ Op.toString srcRator)                      | select _ = raise Fail("bogus " ^ Op.toString srcRator)
200                    in                    in
201                      select (i, pieces, es);                      select (i, pieces, es)
                     []  
202                    end                    end
203                | Op.VClamp n => bindVOp TOp.VClamp                | Op.VClamp n => bindVOp TOp.VClamp
204                | Op.VMapClamp n => bindVOp TOp.VMapClamp                | Op.VMapClamp n => bindVOp TOp.VMapClamp
205                | Op.VLerp n => bindVOp TOp.VLerp                | Op.VLerp n => bindVOp TOp.VLerp
206                | Op.TensorIndex(ty, idxs) => ??                | Op.TensorIndex(ty, idxs) => bindOp(TOp.TensorIndex(Util.trType ty, idxs))
207                | Op.ProjectLast(ty, idxs) => ??                | Op.ProjectLast(ty, idxs) => bindOp(TOp.ProjectLast(Util.trType ty, idxs))
208                | Op.EigenVecs2x2 => assignOp TOp.EigenVecs2x2                | Op.Zero ty => bindOp (TOp.Zero(Util.trType ty))
209                | Op.EigenVecs3x3 => assignOp TOp.EigenVecs3x3                | Op.Select(ty, i) => bindOp (TOp.Select(Util.trType ty, i))
210                | Op.EigenVals2x2 => assignOp TOp.EigenVals2x2                | Op.Subscript ty => bindOp (TOp.Subscript(Util.trType ty))
211                | Op.EigenVals3x3 => assignOp TOp.EigenVals3x3                | Op.MkDynamic(ty, n) => bindOp (TOp.MkDynamic(Util.trType ty, n))
212                | Op.Zero ty => ??                | Op.Append ty => bindOp (TOp.Append(Util.trType ty))
213                | Op.Select(Ty.TupleTy tys, i) => ??                | Op.Prepend ty => bindOp (TOp.Prepend(Util.trType ty))
214                | Op.Subscript(Ty.SeqTy(ty, NONE)) => ??                | Op.Concat ty => bindOp (TOp.Concat(Util.trType ty))
215                | Op.Subscript(Ty.SeqTy(ty, SOME _)) => ??                | Op.Range => bindOp TOp.Range
216                | Op.MkDynamic(ty, n) => ??                | Op.Length ty => bindOp (TOp.Length(Util.trType ty))
217                | Op.Append ty => ??                | Op.SphereQuery(ty1, ty2) => raise Fail "FIXME: SphereQuery"
               | Op.Prepend ty => ??  
               | Op.Concat ty => ??  
               | Op.Range => ??  
               | Op.Length ty => ??  
               | Op.SphereQuery(ty1, ty2) => ??  
218                | Op.Sqrt => bindOp TOp.Sqrt                | Op.Sqrt => bindOp TOp.Sqrt
219                | Op.Cos => bindOp TOp.Cos                | Op.Cos => bindOp TOp.Cos
220                | Op.ArcCos => bindOp TOp.ArcCos                | Op.ArcCos => bindOp TOp.ArcCos
# Line 217  Line 232 
232                | Op.Trunc d => bindVOp TOp.Trunc                | Op.Trunc d => bindVOp TOp.Trunc
233                | Op.IntToReal => bindOp TOp.IntToReal                | Op.IntToReal => bindOp TOp.IntToReal
234                | Op.RealToInt 1 => bindOp (TOp.RealToInt 1)                | Op.RealToInt 1 => bindOp (TOp.RealToInt 1)
235                | Op.RealToInt d => ??                | Op.RealToInt d => Env.TREE(T.E_Op(TOp.RealToInt d, List.map (singleArg env) args))
236  (* FIXME  (* FIXME
237                | Op.R_All ty => ??                | Op.R_All ty => ??
238                | Op.R_Exists ty => ??                | Op.R_Exists ty => ??
# Line 232  Line 247 
247                | Op.Translate info => bindOp (TOp.Translate info)                | Op.Translate info => bindOp (TOp.Translate info)
248                | Op.ControlIndex(info, ctl, d) => bindOp (TOp.ControlIndex(info, ctl, d))                | Op.ControlIndex(info, ctl, d) => bindOp (TOp.ControlIndex(info, ctl, d))
249                | Op.LoadVoxel info => bindOp (TOp.LoadVoxel info)                | Op.LoadVoxel info => bindOp (TOp.LoadVoxel info)
250                | Op.Inside(info, s) => ??                | Op.Inside(info, s) => bindOp (TOp.Inside(info, s))
251                | Op.ImageDim(info, d) => bindOp(TOp.ImageDim(info, d))                | Op.ImageDim(info, d) => bindOp(TOp.ImageDim(info, d))
252                | Op.LoadSeq(ty, file) => ??                | Op.LoadSeq(ty, file) => bindOp(TOp.LoadSeq(Util.trType ty, file))
253                | Op.LoadImage(ty, file) => ??                | Op.LoadImage(ty, file) => bindOp(TOp.LoadImage(Util.trType ty, file))
254                | Op.MathFn f => bindOp (TOp.MathFn f)                | Op.MathFn f => bindOp (TOp.MathFn f)
255                | rator => raise Fail("bogus operator " ^ Op.toString srcRator)                | rator => raise Fail("bogus operator " ^ Op.toString srcRator)
256              (* end case *)              (* end case *)
257            end            end
258    
259    (* cases:
260            x in EqClass
261                    issue assignment; lhs is binding of representative (could be multiple vars)
262            useCount(x) > 1 and rhs is not simple
263            rhs is simple
264            rhs is vector
265    *)
266      fun trAssign (env, lhs, rhs) = let      fun trAssign (env, lhs, rhs) = let
267          (* simple binding for lhs variable; we check to see if it is part of an merged          (* simple binding for lhs variable; we check to see if it is part of an merged
268           * equivalence class, in which case we need to generate the assigment.           * equivalence class, in which case we need to generate the assigment.
269           *)           *)
270            fun bindSimple rhs = (case UnifyVars.eqClassOf lhs            fun bindSimple rhs = (case eqClassRepOf(env, lhs)
271                   of SOME x => ??                   of NOEQ =>(Env.bindSimple (env, lhs, Env.TREE rhs); [])
272                    | NONE => (Env.bindSimple (env, lhs, rhs); [])                    | VAR x' => [T.S_Assign(x', rhs)]
273                  (* end case *))                    | VEC _ => raise Fail "unexpected VEC"
274                    (* end case *))
275              fun assignOp (rator, args) = let
276    (* FIXME: what if lhs is EqClass var? *)
277                    val t = Util.newLocalVar lhs
278                    val stm = T.S_Assign(t, T.E_Op(rator, List.map (scalarArg env) args))
279                    in
280                      Env.bindSimple (env, lhs, Env.TREE(T.E_Var t));
281                      [stm]
282                    end
283            in            in
284              case rhs              case rhs
285               of IR.GLOBAL x => bindSimple (T.E_Global(mkGlobalVar x))               of IR.GLOBAL x => bindSimple (T.E_Global(mkGlobalVar x))
286                | IR.STATE(NONE, fld) => bindSimple (T.E_State(NONE, getStateVar fld))                | IR.STATE(NONE, fld) =>
287                | IR.STATE(SOME x, fld) => ??                    bindSimple (T.E_State(NONE, getStateVar fld))
288                  | IR.STATE(SOME x, fld) =>
289                      bindSimple (T.E_State(SOME(scalarArg env x), getStateVar fld))
290                | IR.VAR x => (case Env.useVar env x                | IR.VAR x => (case Env.useVar env x
291                     of Env.TREE e => ??                     of Env.TREE e => ??
292                      | Env.VEC(layout, es) => ??                      | Env.VEC(layout, es) => ??
293                    (* end case *))                    (* end case *))
294                | IR.LIT lit => bindSimple (T.E_Lit lit)                | IR.LIT lit => bindSimple (T.E_Lit lit)
295                | IR.OP(rator, args) => trOp (env, lhs, rator, args)                | IR.OP(Op.EigenVecs2x2, args) => assignOp (TOp.EigenVecs2x2, args)
296                | IR.CONS(args, ty) => ??                | IR.OP(Op.EigenVecs3x3, args) => assignOp (TOp.EigenVecs3x3, args)
297                  | IR.OP(Op.EigenVals2x2, args) => assignOp (TOp.EigenVals2x2, args)
298                  | IR.OP(Op.EigenVals3x3, args) => assignOp (TOp.EigenVals3x3, args)
299                  | IR.OP(rator, args) => let
300                      val rhs = trOp (env, rator, args)
301                      in
302                        if Env.isInlineOp env rator
303                          then (case (rhs, eqClassRepOf(env, lhs), V.useCount lhs > 1)
304                              of (_, NOEQ, false) => (Env.bindSimple (env, lhs, rhs); [])
305                               | (Env.TREE e, NOEQ, true) => let
306                                    val t = Util.newLocalVar lhs
307                                    in
308                                      Env.bindSimple (env, lhs, Env.TREE(T.E_Var t));
309                                      [T.S_Assign(t, e)]
310                                    end
311                               | (Env.TREE e, VAR x', _) => [T.S_Assign(x', e)]
312                               | (Env.VEC(layout, es), NOEQ, true) => let
313                                    val vs = Util.newVectorVars layout
314                                    in
315                                      Env.bindSimple (env, lhs, Env.VEC(layout, List.map T.E_Var vs));
316                                      ListPair.mapEq T.S_Assign (vs, es)
317                                    end
318                               | (Env.VEC(layout, es), VEC xs, _) => ??
319                               | _ => raise Fail "inconsistent"
320                             (* end case *))
321                          else ??
322                      end
323                  | IR.CONS(args, Ty.TensorTy[d]) => let
324                      val {padded, pieces, ...} = Env.layoutVec env d
325                      in
326                        ??
327                      end
328                  | IR.CONS(args, Ty.TensorTy shape) => ??
329                | IR.SEQ(args, ty) => ??                | IR.SEQ(args, ty) => ??
330                | IR.EINAPP _ => raise Fail "unexpected EINAPP in LowIR code"                | rhs => raise Fail(concat["unexpected ", IR.RHS.toString rhs, " in LowIR code"])
331              (* end case *)              (* end case *)
332            end            end
333    
# Line 281  Line 346 
346       *)       *)
347        | ELSE_BR of T.stm list * T.exp * T.stm list * IR.node_kind        | ELSE_BR of T.stm list * T.exp * T.stm list * IR.node_kind
348    
349      fun trCFGWithEnv (env, prefix, cfg) = let      fun trCFGWithEnv (env, cfg) = let
350            fun useScalar x = (case Env.useVar env x            fun useScalar x = (case Env.useVar env x
351                   of Env.TREE e => e                   of Env.TREE e => e
352                    | _ => raise Fail("expected scalar binding for " ^ V.toString x)                    | _ => raise Fail("expected scalar binding for " ^ V.toString x)
# Line 293  Line 358 
358           * on the current path, and k is the kind of the join node (either JOIN or EXIT).           * on the current path, and k is the kind of the join node (either JOIN or EXIT).
359           *)           *)
360            fun join ([], _, IR.JOIN _) = raise Fail "JOIN with no open if"            fun join ([], _, IR.JOIN _) = raise Fail "JOIN with no open if"
361              | join ([], stms, _) = mkBlock (prefix @ List.rev stms)              | join ([], stms, _) = mkBlock (List.rev stms)
362              | join (THEN_BR(stms1, cond, elseBr)::stk, thenBlk, k) = let              | join (THEN_BR(stms1, cond, elseBr)::stk, thenBlk, k) = let
363                  val thenBlk = Env.flushPending (env, thenBlk)                  val thenBlk = Env.flushPending (env, thenBlk)
364                  in                  in
# Line 321  Line 386 
386                      | (_, _) => let                      | (_, _) => let
387                          val stm = mkIf(cond, List.rev thenBlk, List.rev elseBlk)                          val stm = mkIf(cond, List.rev thenBlk, List.rev elseBlk)
388                          in                          in
389                            mkBlock (prefix @ List.rev(stm::stms))                            mkBlock (List.rev(stm::stms))
390                          end                          end
391                    (* end case *)                    (* end case *)
392                  end                  end
# Line 348  Line 413 
413                    | IR.COM {text, succ, ...} =>                    | IR.COM {text, succ, ...} =>
414                        doNode (!succ, ifStk, T.S_Comment text :: stms)                        doNode (!succ, ifStk, T.S_Comment text :: stms)
415                    | IR.ASSIGN{stm=(lhs, rhs), succ, ...} => let                    | IR.ASSIGN{stm=(lhs, rhs), succ, ...} => let
416                        val (env, stms') = trAssign (env, lhs, rhs)                        val stms' = trAssign (env, lhs, rhs)
417                        in                        in
418                          doNode (!succ, ifStk, stms' @ stms)                          doNode (!succ, ifStk, stms' @ stms)
419                        end                        end
420                    | IR.MASSIGN{stm=(ys, rator, xs), succ, ...} => let                    | IR.MASSIGN{stm=(ys, rator, xs), succ, ...} => let
421                        fun doLHSVar (y, (env, ys)) = let                        fun doLHSVar (y, ys) = let
422                              val t = Util.newLocalVar y                              val t = Util.newLocalVar y
423                              in                              in
424                                (rename (env, y, t), t::ys)                                Env.bindSimple (env, y, Env.TREE(T.E_Var t));
425                                  t::ys
426                              end                              end
427                        val (env, ys) = List.foldr doLHSVar (env, []) ys                        val ys = List.foldr doLHSVar [] ys
428                        val rator = (case rator                        val rator = (case rator
429                               of Op.Print tys => TOp.Print(List.map Util.trType tys)                               of Op.Print tys => TOp.Print(List.map Util.trType tys)
430                                | _ => raise Fail(concat[                                | _ => raise Fail(concat[
# Line 370  Line 436 
436                          doNode (!succ, ifStk, stm :: stms)                          doNode (!succ, ifStk, stm :: stms)
437                        end                        end
438                    | IR.GASSIGN{lhs, rhs, succ, ...} => let                    | IR.GASSIGN{lhs, rhs, succ, ...} => let
439                        val stm = (case useAsInput(env, rhs)                        val stm = T.S_GAssign(mkGlobalVar lhs, singleArg env rhs)
                              of NONE => T.S_GAssign(mkGlobalVar lhs, singleArg env rhs)  
                               | SOME mkStm => mkStm(mkGlobalVar lhs)  
                             (* end case *))  
440                        in                        in
441                          doNode (!succ, ifStk, stm::stms)                          doNode (!succ, ifStk, stm::stms)
442                        end                        end
# Line 388  Line 451 
451                          doNode (!succ, ifStk, stm::stms)                          doNode (!succ, ifStk, stm::stms)
452                        end                        end
453                    | k as IR.EXIT{kind, succ, ...} => (case (!succ, kind)                    | k as IR.EXIT{kind, succ, ...} => (case (!succ, kind)
454                         of (NONE, ExitKind.RETURN) => let                         of (NONE, ExitKind.RETURN) => mkBlock (List.rev(T.S_Exit :: stms))
455                              val suffix = [T.S_Exit]                          | (NONE, ExitKind.ACTIVE) => mkBlock (List.rev(T.S_Active :: stms))
                             in  
                               mkBlock (prefix @ List.revAppend(stms, suffix))  
                             end  
                         | (NONE, ExitKind.ACTIVE) => let  
                             val suffix = [T.S_Active]  
                             in  
                               mkBlock (prefix @ List.revAppend(stms, suffix))  
                             end  
456                          | (NONE, ExitKind.STABILIZE) => let                          | (NONE, ExitKind.STABILIZE) => let
457                              val stms = T.S_Stabilize :: stms                              val stms = T.S_Stabilize :: stms
458                              in                              in
# Line 416  Line 471 
471              ScopeVars.assignScopes (doNode (IR.CFG.entry cfg, [], []))              ScopeVars.assignScopes (doNode (IR.CFG.entry cfg, [], []))
472            end            end
473    
474      fun trCFG info (prefix, cfg) = trCFGWithEnv (Env.new info, prefix, cfg)      fun trCFG info cfg = trCFGWithEnv (Env.new info, cfg)
475    
476      fun trStrand info strand = let      fun trStrand info strand = let
477            val trCFG = trCFG info            val trCFG = trCFG info
478            val IR.Strand{name, params, state, stateInit, initM, updateM, stabilizeM} = strand            val IR.Strand{name, params, state, stateInit, initM, updateM, stabilizeM} = strand
479            val params' = List.map Util.newParamVar params            val params' = List.map Util.newParamVar params
480            val env = ListPair.foldlEq            val env = Env.new info
481                  (fn (x, x', env) => rename(env, x, x')) (Env.new info) (params, params')            val () = ListPair.appEq
482                    (fn (x, x') => Env.bindSimple (env, x, Env.TREE(T.E_Var x'))) (params, params')
483            val state' = List.map getStateVar state            val state' = List.map getStateVar state
484            in            in
485              T.Strand{              T.Strand{
486                  name = name,                  name = name,
487                  params = params',                  params = params',
488                  state = state',                  state = state',
489                  stateInit = trCFGWithEnv (env, [], stateInit),                  stateInit = trCFGWithEnv (env, stateInit),
490                  initM = Option.map (fn cfg => trCFG ([], cfg)) initM,                  initM = Option.map trCFG initM,
491                  updateM = trCFG ([], updateM),                  updateM = trCFG updateM,
492                  stabilizeM = Option.map (fn cfg => trCFG ([], cfg)) stabilizeM                  stabilizeM = Option.map trCFG stabilizeM
493                }                }
494            end            end
495    
# Line 441  Line 497 
497            val LowIR.Program{            val LowIR.Program{
498                    props, consts, inputs, constInit, globals, globalInit, strand, create, update                    props, consts, inputs, constInit, globals, globalInit, strand, create, update
499                  } = prog                  } = prog
500              val trCFG = trCFG info
501            in            in
502              TreeIR.Program{              TreeIR.Program{
503                  props = props,                  props = props,
504                  consts = ??,                  consts = List.map mkGlobalVar consts,
505                  inputs = ??,                  inputs = List.map (Inputs.map mkGlobalVar) inputs,
506                  constInit = ??,                  constInit = trCFG constInit,
507                  globals = ??,                  globals = List.map mkGlobalVar globals,
508                  globalInit = ??,                  globalInit = trCFG globalInit,
509                  strand = trStrand info strand,                  strand = trStrand info strand,
510                  create = ??,                  create = let
511                  update = ??                    val IR.Create{dim, code} = create
512                      in
513                        T.Create{dim = dim, code = trCFG code}
514                      end,
515                    update = Option.map trCFG update
516                }                }
517            end            end
518    

Legend:
Removed from v.3851  
changed lines
  Added in v.3853

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