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

SCM Repository

[diderot] Annotation of /branches/pure-cfg/src/compiler/codegen/codegen-fn.sml
ViewVC logotype

Annotation of /branches/pure-cfg/src/compiler/codegen/codegen-fn.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 512 - (view) (download)

1 : jhr 454 (* codegen-fn.sml
2 :     *
3 :     * COPYRIGHT (c) 2010 The Diderot Project (http://diderot-language.cs.uchicago.edu)
4 :     * All rights reserved.
5 : jhr 455 *
6 :     * Generic support for translating LowIL code to the target representation. We
7 :     * assume that the LowIL has first been run through the splitting pass to match
8 :     * the target's vector widths.
9 : jhr 454 *)
10 :    
11 :     functor CodeGenFn (T : TARGET) : sig
12 :    
13 :     val generate : LowIL.program -> T.program
14 :    
15 :     end = struct
16 :    
17 : jhr 512 structure IL = LowIL
18 :     structure V = LowIL.Var
19 :     structure Op = LowOps
20 :     structure Nd = LowIL.Node
21 :     structure CFG = LowIL.Node
22 : jhr 454
23 :     (* a mapping from LowIL variables to target expressions. Variables get
24 :     * removed when the expressions are used as arguments.
25 :     *)
26 :     structure VDefTbl : sig
27 :     type tbl
28 :    
29 :     val newTbl : unit -> tbl
30 : jhr 512 val getDefOf : tbl -> V.var -> T.exp
31 :     val useDefOf : tbl -> V.var -> T.exp
32 :     val setDefOf : tbl -> (V.var * T.exp) -> unit
33 : jhr 454
34 :     val clear : tbl -> unit
35 :    
36 : jhr 512 val bind : tbl -> (V.var * T.exp) -> T.stm list
37 : jhr 454
38 : jhr 455 (* force all pending expressions into variables *)
39 :     val flush : tbl -> T.stm list
40 :    
41 : jhr 454 end = struct
42 :    
43 : jhr 455 type info = {
44 :     cnt : int ref, (* count of oustanding uses (usually 1) *)
45 :     bind : T.exp
46 :     }
47 :    
48 : jhr 512 type tbl = info V.Tbl.hash_table
49 : jhr 455
50 : jhr 512 fun newTbl () = V.Tbl.mkTable (512, Fail "vtbl")
51 : jhr 455
52 : jhr 512 fun getDefOf tbl x = (case V.Tbl.find tbl x
53 : jhr 455 of NONE => ??
54 :     | SOME{bind, cnt} => bind
55 :     (* end case *))
56 :    
57 : jhr 512 fun useDefOf tbl x = (case V.Tbl.find tbl x
58 : jhr 455 of NONE => ??
59 : jhr 512 | SOME{cnt=ref 1, bind} => (
60 :     ignore (V.Tbl.remove tbl x);
61 : jhr 455 bind)
62 :     | SOME{cnt, bind} => => (
63 :     cnt := !cnt - 1;
64 :     bind)
65 :     (* end case *))
66 :    
67 :     fun setDefOf tbl (x, exp) =
68 : jhr 512 V.Tbl.insert tbl (x, {cnt = ref(V.useCount x), bind = exp})
69 : jhr 455
70 :     fun assign tbl (x, exp) = let
71 :     val lhs : T.local_var = ??
72 :     in
73 : jhr 512 V.Tbl.insert tbl
74 :     (x, {cnt = V.useCount x, bind = T.Expr.var lhs});
75 : jhr 455 [T.Stmt.assign(lhs, exp)]
76 :     end
77 :    
78 : jhr 512 fun bind tbl (x, exp) = (case V.useCount lhs
79 :     of 1 => (V.Tbl.insert tbl (x, {cnt = 1, bind = exp}); [])
80 : jhr 455 | n => let (* bind exp to a new target variable *)
81 :     val lhs : T.local_var = ??
82 :     in
83 : jhr 512 V.Tbl.insert tbl (x, {cnt = n, bind = T.Expr.var lhs});
84 : jhr 455 [T.Stmt.assign(lhs, exp)]
85 :     end
86 :     (* end case *))
87 :    
88 : jhr 454 end (* VDefTbl *)
89 :    
90 : jhr 455 (* FIXME: what about splitting code where the target width doesn't match the
91 :     * source width?
92 :     *)
93 :     fun doRator (vtbl, lhs, rator, args) = let
94 :     val args' = List.map (VDefTbl.useDefOf vtbl) args
95 :     val rhs' = (case rator
96 :     (* ??? *)
97 :     (* end case *))
98 :     in
99 :     VDefTbl.bind vtbl (lhs, rhs')
100 :     end
101 : jhr 454
102 : jhr 455 (* translate a LowIL assignment to a list of zero or more target statements *)
103 :     fun doAssign vtbl (lhs, rhs) = let
104 :     fun setDef rhs = (VTbl.setDefOf vtbl (lhs, rhs); [])
105 :     in
106 :     case rhs
107 : jhr 512 of IL.VAR x => setDef (T.Expr.var(VDefTbl.useDefOf vtbl x))
108 :     | IL.LIT(Literal.Int n) => setDef (T.Expr.intLit n)
109 :     | IL.LIT(Literal.Bool b) => setDef (T.Expr.boolLit b)
110 :     | IL.LIT(Literal.Float f) => setDef (T.Expr.floatLit f)
111 :     | IL.LIT(Literal.String s) => setDef (T.Expr.stringLit s)
112 :     | IL.OP(rator, args) => doRator(vtbl, lhs, rator, args)
113 :     | IL.CONS args =>
114 : jhr 455 VTbl.assign ctbl (lhs, T.Expr.vector (List.map (VDefTbl.useDefOf vtbl) args))
115 :     (* end case *)
116 :     end
117 :    
118 : jhr 512 datatype open_if = T.stm list * IL.node -> stm
119 :    
120 :     fun gen (vtbl, cfg) = let
121 :     val doAssign = doAssign vtbl
122 :     fun doNode (vtbl, ifStk, stms, nd) = (case Nd.kind nd
123 :     of IL.NULL =>
124 :     | IL.ENTRY{succ} =>
125 :     | IL.JOIN{phis, succ, ...} =>
126 :     | IL.COND{cond, trueBranch, falseBranch, ...} => let
127 :     fun kThen (stms', _) = let
128 :     val thenBlk = T.Stmt.block (List.rev stms')
129 :     fun kElse (stms', succ) = let
130 :     val stm = T.Stmt.ifthenelse (
131 :     VDefTbl.useDefOf vtbl cond,
132 :     thenBlk,
133 :     T.Stmt.block (List.rev stms'))
134 :     in
135 :     doNode (vtbl, ifStk, stm::stms, succ)
136 :     end
137 :     in
138 :     doNode (vtbl, kElse::ifStk, [], !falseBranch)
139 :     end
140 :     in
141 :     doNode (vtbl, kThen::ifStk, [], !trueBranch)
142 :     end
143 :     | IL.COM {text, succ, ...} =>
144 :     | IL.ASSIGN{stm, succ, ...} =>
145 :     | IL.NEW{strand, args, succ, ...} =>
146 :     | IL.DIE _ =>
147 :     | IL.STABILIZE _ =>
148 :     | IL.EXIT _ =>
149 :     (* end case *))
150 :     in
151 :     end
152 :    
153 : jhr 455 fun gen (vtbl, stm) = let
154 :     val doAssign = doAssign vtbl
155 : jhr 456 fun mkBlock [] = ?
156 :     | mkBlock [s] = s
157 :     | mkBlock stms = T.Stmt.block stms
158 : jhr 512 fun doStmt (IL.STM{kind, next, ...}) = let
159 : jhr 455 val stms = (case kind
160 : jhr 512 of IL.S_SIMPLE nd => doNode nd
161 :     | IL.S_IF{cond, thenBranch, elseBranch} => let
162 :     val IL.ND{kind=IL.COND{cond, ...}, ...} = cond
163 : jhr 456 val s1 = mkBlock(doStmt thenBranch)
164 :     val s2 = mkBlock(doStmt elseBranch)
165 :     in
166 :     (* FIXME: check for empty else branch *)
167 :     T.ifthenelse(VDefTbl.useDefOf vtbl cond, s1, s2)
168 :     end
169 : jhr 512 | IL.S_LOOP{hdr, cond, body} => raise Fail "LOOP not supported yet"
170 : jhr 455 (* end case *))
171 :     val rest = (case next
172 :     of NONE => VDefTbl.flush vtbl
173 :     | SOME stm = doStmt stm
174 :     (* end case *))
175 :     in
176 :     stms @ rest
177 :     end
178 : jhr 512 and doNode (IL.ND{kind, ...}) = (case kind
179 :     of IL.NULL => ??
180 :     | IL.ENTRY{succ} => nextNode succ
181 :     | IL.JOIN{succ, ...} =>
182 :     | IL.COND{cond, ...} =>
183 :     | IL.BLOCK{body, succ, ...} =>
184 : jhr 456 List.app doAssign body @ nextNode succ
185 : jhr 512 | IL.NEW{strand, args, ...} =>
186 :     | IL.DIE _ =>
187 :     | IL.STABILIZE _ =>
188 :     | IL.EXIT _ =>
189 : jhr 456 (* end case *))
190 :     and nextNode nd = if isFirst nd then [] else doNode nd
191 : jhr 455 in
192 : jhr 456 mkBlock (doStmt stm)
193 : jhr 455 end
194 :    
195 : jhr 454 end

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