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

SCM Repository

[diderot] Diff of /branches/pure-cfg/src/compiler/c-target/c-target.sml
ViewVC logotype

Diff of /branches/pure-cfg/src/compiler/c-target/c-target.sml

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

revision 1284, Tue Jun 7 09:39:24 2011 UTC revision 1285, Tue Jun 7 10:33:17 2011 UTC
# Line 12  Line 12 
12      structure Ty = IL.Ty      structure Ty = IL.Ty
13      structure CL = CLang      structure CL = CLang
14      structure N = CNames      structure N = CNames
     structure ToC = TreeToC  
15    
16      type var = ToC.var    (* variable translation *)
17        structure TrVar =
18          struct
19            type env = CL.typed_var TreeIL.Var.Map.map
20            fun lookup (env, x) = (case V.Map.find (env, x)
21                   of SOME(CL.V(_, x')) => x'
22                    | NONE => raise Fail(concat["lookup(_, ", V.name x, ")"])
23                  (* end case *))
24          (* translate a variable that occurs in an l-value context (i.e., as the target of an assignment) *)
25            fun lvalueVar (env, x) = (case V.kind x
26                   of IL.VK_Global => CL.mkVar(lookup(env, x))
27                    | IL.VK_State strand => CL.mkIndirect(CL.mkVar "selfOut", lookup(env, x))
28                    | IL.VK_Local => CL.mkVar(lookup(env, x))
29                  (* end case *))
30          (* translate a variable that occurs in an r-value context *)
31            fun rvalueVar (env, x) = (case V.kind x
32                   of IL.VK_Global => CL.mkVar(lookup(env, x))
33                    | IL.VK_State strand => CL.mkIndirect(CL.mkVar "selfIn", lookup(env, x))
34                    | IL.VK_Local => CL.mkVar(lookup(env, x))
35                  (* end case *))
36          end
37    
38        structure ToC = TreeToCFn (TrVar)
39    
40        type var = CL.typed_var
41      type exp = CL.exp      type exp = CL.exp
42      type stm = CL.stm      type stm = CL.stm
43    
# Line 93  Line 116 
116    (* variables *)    (* variables *)
117      structure Var =      structure Var =
118        struct        struct
119          fun name (ToC.V(_, name)) = name          fun name (CL.V(_, name)) = name
120          fun global (Prog{globals, ...}, name, ty) = let          fun global (Prog{globals, ...}, name, ty) = let
121                val ty' = ToC.trType ty                val ty' = ToC.trType ty
122                in                in
123                  globals := CL.D_Var([], ty', name, NONE) :: !globals;                  globals := CL.D_Var([], ty', name, NONE) :: !globals;
124                  ToC.V(ty', name)                  CL.V(ty', name)
125                end                end
126          fun param x = ToC.V(ToC.trType(V.ty x), V.name x)          fun param x = CL.V(ToC.trType(V.ty x), V.name x)
127          fun state (Strand{state, ...}, x) = let          fun state (Strand{state, ...}, x) = let
128                val ty' = ToC.trType(V.ty x)                val ty' = ToC.trType(V.ty x)
129                val x' = ToC.V(ty', V.name x)                val x' = CL.V(ty', V.name x)
130                in                in
131                  state := x' :: !state;                  state := x' :: !state;
132                  x'                  x'
# Line 198  Line 221 
221                      end                      end
222                val baseInit = mapi (fn (i, (_, e, _)) => (i, CL.I_Exp e)) iters                val baseInit = mapi (fn (i, (_, e, _)) => (i, CL.I_Exp e)) iters
223                val sizeInit = mapi                val sizeInit = mapi
224                      (fn (i, (ToC.V(ty, _), lo, hi)) =>                      (fn (i, (CL.V(ty, _), lo, hi)) =>
225                          (i, CL.I_Exp(CL.mkBinOp(CL.mkBinOp(hi, CL.#-, lo), CL.#+, CL.E_Int(1, ty))))                          (i, CL.I_Exp(CL.mkBinOp(CL.mkBinOp(hi, CL.#-, lo), CL.#+, CL.E_Int(1, ty))))
226                      ) iters                      ) iters
227              (* code to allocate the world and initial strands *)              (* code to allocate the world and initial strands *)
# Line 228  Line 251 
251                        CL.mkCall(N.strandInit name, CL.E_Var "sp" :: args),                        CL.mkCall(N.strandInit name, CL.E_Var "sp" :: args),
252                        CL.mkAssign(CL.E_Var indexVar, CL.mkBinOp(CL.E_Var indexVar, CL.#+, CL.E_Int(1, CL.uint32)))                        CL.mkAssign(CL.E_Var indexVar, CL.mkBinOp(CL.E_Var indexVar, CL.#+, CL.E_Int(1, CL.uint32)))
253                      ])                      ])
254                  | mkLoopNest ((ToC.V(ty, param), lo, hi)::iters) = let                  | mkLoopNest ((CL.V(ty, param), lo, hi)::iters) = let
255                      val body = mkLoopNest iters                      val body = mkLoopNest iters
256                      in                      in
257                        CL.mkFor(                        CL.mkFor(
# Line 256  Line 279 
279          fun genStrand (Strand{name, tyName, state, output, code}) = let          fun genStrand (Strand{name, tyName, state, output, code}) = let
280              (* the type declaration for the strand's state struct *)              (* the type declaration for the strand's state struct *)
281                val selfTyDef = CL.D_StructDef(                val selfTyDef = CL.D_StructDef(
282                        List.rev (List.map (fn ToC.V(ty, x) => (ty, x)) (!state)),                        List.rev (List.map (fn CL.V(ty, x) => (ty, x)) (!state)),
283                        tyName)                        tyName)
284              (* the print function *)              (* the print function *)
285                val prFnName = concat[name, "_print"]                val prFnName = concat[name, "_print"]
# Line 397  Line 420 
420                val fName = N.strandInit name                val fName = N.strandInit name
421                val params =                val params =
422                      CL.PARAM([], CL.T_Ptr(CL.T_Named tyName), "selfOut") ::                      CL.PARAM([], CL.T_Ptr(CL.T_Named tyName), "selfOut") ::
423                        List.map (fn (ToC.V(ty, x)) => CL.PARAM([], ty, x)) params                        List.map (fn (CL.V(ty, x)) => CL.PARAM([], ty, x)) params
424                val initFn = CL.D_Func([], CL.voidTy, fName, params, init)                val initFn = CL.D_Func([], CL.voidTy, fName, params, init)
425                in                in
426                  code := initFn :: !code                  code := initFn :: !code
# Line 415  Line 438 
438                  code := methFn :: !code                  code := methFn :: !code
439                end                end
440    
441          fun output (Strand{output, ...}, ty, ToC.V(_, x)) = output := SOME(ty, x)          fun output (Strand{output, ...}, ty, CL.V(_, x)) = output := SOME(ty, x)
442    
443        end        end
444    

Legend:
Removed from v.1284  
changed lines
  Added in v.1285

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