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

SCM Repository

[diderot] Annotation of /branches/vis15/src/compiler/cxx-util/gen-tys-and-ops.sml
ViewVC logotype

Annotation of /branches/vis15/src/compiler/cxx-util/gen-tys-and-ops.sml

Parent Directory Parent Directory | Revision Log Revision Log


Revision 4028 - (view) (download)

1 : jhr 3918 (* gen-tys-and-ops.sml
2 :     *
3 :     * This code is part of the Diderot Project (http://diderot-language.cs.uchicago.edu)
4 :     *
5 :     * COPYRIGHT (c) 2016 The University of Chicago
6 :     * All rights reserved.
7 :     *)
8 :    
9 :     structure GenTysAndOps : sig
10 :    
11 :     val gen : CodeGenEnv.t * CollectInfo.t -> CLang.decl list
12 :    
13 :     end = struct
14 :    
15 :     structure IR = TreeIR
16 :     structure Ty = TreeTypes
17 :     structure CL = CLang
18 :     structure RN = CxxNames
19 :     structure Env = CodeGenEnv
20 :    
21 : jhr 3927 val zero = RealLit.zero false
22 :    
23 :     fun mkReturn exp = CL.mkReturn(SOME exp)
24 : jhr 3931 fun mkInt i = CL.mkInt(IntInf.fromInt i)
25 : jhr 4028 fun mkFunc (ty, name, params, body) = CL.D_Func(["inline"], ty, [], name, params, body)
26 :     fun mkConstr (cls, params, inits) = CL.D_Constr(
27 :     [], [], cls, params,
28 :     SOME([CL.mkApply("_data", [CL.mkVar "src"])], CL.mkBlock[]))
29 : jhr 3927
30 : jhr 3994 fun genTyDecl env = let
31 :     val (realTy, realTyName, realTySz) = if #double(Env.target env)
32 :     then (CL.double, "double", 8)
33 :     else (CL.float, "float", 4)
34 :     fun genDecl (ty, dcls) = (case ty
35 :     of Ty.VecTy(w, pw) => let
36 :     val cTyName = RN.vecTyName w
37 :     val cTy = CL.T_Named cTyName
38 :     val typedefDcl = CL.D_Verbatim[concat[
39 :     "typedef ", realTyName, " ", cTyName,
40 :     " __attribute__ ((vector_size (",
41 : jhr 3999 Int.toString(realTySz * pw), ")));"
42 : jhr 3994 ]]
43 :     in
44 :     typedefDcl :: dcls
45 :     end
46 : jhr 4026 | Ty.TensorRefTy shape => let
47 :     val name = RN.tensorRefStruct shape
48 :     val thisData = CL.mkIndirect(CL.mkVar "this", "_data")
49 :     (* constructor from float/double pointer *)
50 : jhr 4028 val constrDcl1 = mkConstr (name,
51 : jhr 4026 [CL.PARAM([], CL.constPtrTy realTy, "src")],
52 : jhr 4028 [CL.mkApply("_data", [CL.mkVar "src"])])
53 : jhr 4026 (* QUESTION: do we want the following? It will have to be declared out-of-line.
54 :     (* constructor from tensor struct *)
55 :     val constrDcl2 = CL.D_Constr([], NONE, name,
56 :     [CL.PARAM([],
57 :     CL.T_Named(concat["struct ", RN.tensorStruct shape, " const &"]),
58 :     "ten")
59 :     ],
60 :     [CL.mkApply("_data", [CL.mkSelect(CL.mkVar "ten", "_data")])],
61 :     SOME(CL.mkBlock[]))
62 :     *)
63 :     (* copy constructor *)
64 : jhr 4028 val constrDcl2 = mkConstr (name,
65 : jhr 4026 [CL.PARAM([], CL.T_Named(name ^ " const &"), "ten")],
66 : jhr 4028 [CL.mkApply("_data", [CL.mkSelect(CL.mkVar "ten", "_data")])])
67 : jhr 4026 (* subscript operator *)
68 :     val subscriptDcl = CL.D_Func([], CL.T_Named(realTyName ^ " const &"),
69 : jhr 4028 [], "operator[]",
70 : jhr 4026 [CL.PARAM([], CL.uint32, "i")],
71 :     CL.mkReturn(SOME(CL.mkSubscript(thisData, CL.mkVar "i"))))
72 :     (* address at function *)
73 : jhr 4028 val addrAtDcl = CL.D_Func([], CL.constPtrTy(realTy), [], "addr",
74 : jhr 4026 [CL.PARAM([], CL.uint32, "i")],
75 :     CL.mkReturn(SOME(CL.mkAddrOf(CL.mkSubscript(thisData, CL.mkVar "i")))))
76 :     val structDcl = CL.D_ClassDef{
77 :     name = name,
78 :     args = NONE,
79 :     from = NONE,
80 :     public = [
81 : jhr 4028 CL.mkVarDcl(CL.constPtrTy realTy, "_data"),
82 : jhr 4026 constrDcl1, constrDcl2,
83 :     subscriptDcl,
84 :     addrAtDcl
85 :     ],
86 :     protected = [],
87 :     private = []
88 :     }
89 :     in
90 :     structDcl :: dcls
91 :     end
92 : jhr 3994 | Ty.TensorTy shape => let
93 :     val len = List.foldl Int.* 1 shape
94 :     val name = RN.tensorStruct shape
95 :     val thisData = CL.mkIndirect(CL.mkVar "this", "_data")
96 : jhr 3999 (* code for initializing tensor from pointer named src. *)
97 :     fun copyFromArray src = if (len < 4)
98 :     then let
99 :     fun cpy i = CL.mkAssign(
100 :     CL.mkSubscript(thisData, mkInt i),
101 :     CL.mkSubscript(src, mkInt i))
102 :     in
103 :     CL.mkBlock (List.tabulate (len, cpy))
104 :     end
105 :     else CL.mkCall("std::memcpy", [
106 :     thisData, src,
107 :     CL.mkBinOp(mkInt len, CL.#*, CL.mkSizeof realTy)
108 :     ])
109 :     (* loop for initializing tensor from initializer_list *)
110 : jhr 3996 val copyFromInitializerList = [
111 :     CL.mkDeclInit(CL.int32, "i", CL.mkInt 0),
112 :     CL.mkFor(
113 :     CL.T_Named "auto",
114 :     [("it", CL.mkDispatch(CL.mkVar "il", "begin", []))],
115 :     CL.mkBinOp(CL.mkVar "it", CL.#!=, CL.mkDispatch(CL.mkVar "il", "end", [])),
116 :     [CL.mkUnOp(CL.%++, CL.mkVar "i"), CL.mkUnOp(CL.%++, CL.mkVar "it")],
117 :     CL.mkAssign(
118 :     CL.mkSubscript(thisData, CL.mkVar "i"),
119 :     CL.mkUnOp(CL.%*, CL.mkVar "it")))
120 :     ]
121 : jhr 3994 (* default constructor *)
122 : jhr 4028 val constrDcl1 = mkConstr (name, [], [])
123 : jhr 3996 (* constructor from initializer list *)
124 : jhr 4028 val constrDcl2 = CL.D_Constr([], [], name,
125 : jhr 3996 [CL.PARAM([], CL.T_Template("std::initializer_list", [realTy]), "il")],
126 : jhr 4028 SOME([], CL.mkBlock copyFromInitializerList))
127 : jhr 3999 (* constructor from float/double pointer *)
128 : jhr 4028 val constrDcl3 = CL.D_Constr([], [], name,
129 : jhr 3999 [CL.PARAM([], CL.constPtrTy realTy, "src")],
130 : jhr 4028 SOME([], copyFromArray (CL.mkVar "src")))
131 : jhr 3999 (* copy constructor *)
132 : jhr 4028 val constrDcl4 = CL.D_Constr([], [], name,
133 : jhr 3999 [CL.PARAM([], CL.T_Named(name ^ " const &"), "ten")],
134 : jhr 4028 SOME([], copyFromArray (CL.mkSelect(CL.mkVar "ten", "_data"))))
135 : jhr 3994 (* destructor *)
136 : jhr 4028 val destrDcl = CL.D_Destr([], [], name, SOME(CL.mkBlock[]))
137 : jhr 3996 (* assignment operator *)
138 : jhr 4028 val assignDcl = CL.D_Func([], CL.T_Named(name ^ " &"), [], "operator=",
139 : jhr 3996 [CL.PARAM([], CL.T_Template("std::initializer_list", [realTy]), "il")],
140 :     CL.mkBlock(
141 :     copyFromInitializerList @
142 :     [CL.mkReturn(SOME(CL.mkUnOp(CL.%*, CL.mkVar "this")))]))
143 :     (* subscript operator *)
144 : jhr 4028 val subscriptDcl = CL.D_Func([], CL.T_Named(realTyName ^ " &"), [], "operator[]",
145 : jhr 3996 [CL.PARAM([], CL.uint32, "i")],
146 :     CL.mkReturn(SOME(CL.mkSubscript(thisData, CL.mkVar "i"))))
147 : jhr 3999 (* address at function *)
148 : jhr 4028 val addrAtDcl = CL.D_Func([], CL.constPtrTy realTy, [], "addr",
149 : jhr 3999 [CL.PARAM([], CL.uint32, "i")],
150 :     CL.mkReturn(SOME(CL.mkAddrOf(CL.mkSubscript(thisData, CL.mkVar "i")))))
151 : jhr 3994 val structDcl = CL.D_ClassDef{
152 :     name = name,
153 :     args = NONE,
154 :     from = NONE,
155 :     public = [
156 : jhr 4028 CL.mkVarDcl(CL.T_Array(realTy, SOME len), "_data"),
157 : jhr 3999 constrDcl1, constrDcl2, constrDcl3, constrDcl4,
158 : jhr 3994 destrDcl,
159 : jhr 3996 assignDcl,
160 : jhr 3999 subscriptDcl,
161 :     addrAtDcl
162 : jhr 3994 ],
163 :     protected = [],
164 :     private = []
165 :     }
166 :     in
167 :     structDcl :: dcls
168 :     end
169 :     | Ty.TupleTy tys => raise Fail "FIXME: TupleTy"
170 : jhr 3918 (* TODO
171 : jhr 3994 | Ty.SeqTy(ty, NONE) =>
172 :     | Ty.SeqTy(ty, SOME n) =>
173 : jhr 3918 *)
174 : jhr 3994 | ty => dcls
175 :     (* end case *))
176 :     in
177 :     genDecl
178 :     end
179 : jhr 3918
180 : jhr 3994 fun genVecTyDecl (env, w, pw, dcls) = let
181 :     val (realTy, realTyName, realTySz) = if #double(Env.target env)
182 :     then (CL.double, "double", 8)
183 :     else (CL.float, "float", 4)
184 :     val cTyName = RN.vecTyName w
185 :     val cTy = CL.T_Named cTyName
186 :     val typedefDcl = CL.D_Verbatim[concat[
187 :     "typedef ", realTyName, " ", cTyName, " __attribute__ ((vector_size (",
188 :     Int.toString(realTySz * pw), ")));\n"
189 :     ]]
190 :     in
191 :     typedefDcl :: dcls
192 :     end
193 :    
194 : jhr 4014 (* FIXME: generate seq_traits decl for ty *)
195 :     fun genSeqTrait env = let
196 :     val realTy = Env.realTy env
197 :     fun trType ty = TypeToCxx.trType(env, ty)
198 : jhr 4028 fun trait ({argTy, baseTy, elemTy, ndims, dims}, dcls) = let
199 :     (* the name of the teem function table for the given base type *)
200 :     val loadTbl = (case baseTy
201 :     of Ty.BoolTy => "nrrdILoad"
202 :     | Ty.IntTy => "nrrdILoad"
203 :     | Ty.VecTy(1, 1) => if #double(Env.target env)
204 :     then "nrrdDLoad"
205 :     else "nrrdFLoad"
206 :     | ty => raise Fail("genSeqTrait.loadFn: unexpected type " ^ Ty.toString ty)
207 :     (* end case *))
208 :     in
209 :     CL.D_Template([], CL.D_ClassDef{
210 :     name = "dynseq_traits",
211 :     args = SOME[argTy],
212 :     from = NONE,
213 :     public = [
214 :     CL.D_Typedef("value_type", elemTy),
215 :     CL.D_Typedef("base_type", trType baseTy),
216 :     CL.D_Var(
217 :     ["static", "const"],
218 :     CL.constPtrTy(CL.T_Named "__details::load_fn_ptr<base_type>"),
219 :     [], "load_fn_tbl", NONE),
220 :     CL.D_Var(
221 :     ["static", "const"], CL.uint32, [], "dims", SOME(CL.I_Exp(mkInt ndims))),
222 :     CL.D_Var(
223 :     ["static", "const"], CL.T_Array(CL.uint32, SOME ndims), [], "dims", NONE)
224 :     ],
225 :     protected = [],
226 :     private = []
227 :     }) ::
228 :     CL.D_Var(
229 :     ["const"], CL.uint32,
230 :     [CL.SC_Type(CL.T_Template("dynseq_traits", [argTy]))], "load_fn_tbl",
231 :     SOME(CL.I_Exp(CL.mkVar loadTbl))) ::
232 :     dcls
233 :     end
234 : jhr 4014 fun genTrait (ty, dcls) = (case ty
235 : jhr 4028 of Ty.SeqTy(argTy, NONE) => let
236 : jhr 4014 fun baseTy (Ty.SeqTy(ty, _)) = baseTy ty
237 : jhr 4028 | baseTy (Ty.TensorTy[]) = Ty.realTy
238 : jhr 4014 | baseTy ty = ty
239 : jhr 4028 val argTy = trType argTy
240 : jhr 4014 in
241 :     case baseTy ty
242 : jhr 4028 of Ty.TensorTy(shp as _::_) => trait ({
243 :     argTy = argTy, baseTy = Ty.realTy,
244 :     elemTy = RN.tensorTy shp, ndims = List.length shp,
245 :     dims = shp
246 :     },
247 :     dcls)
248 :     | ty => trait ({
249 :     argTy = argTy, baseTy = ty, elemTy = argTy,
250 :     ndims = 1, dims = [1]
251 :     },
252 :     dcls)
253 : jhr 4014 (* end case *)
254 :     end
255 :     | _ => dcls
256 :     (* end case *))
257 :     in
258 :     genTrait
259 :     end
260 :    
261 :     datatype operation = datatype CollectInfo.operation
262 :    
263 : jhr 3918 val ostreamRef = CL.T_Named "std::ostream&"
264 :    
265 :     fun output (e, e') = CL.mkBinOp(e, CL.#<<, e')
266 :    
267 :     (* generate code for the expression "e << s", where "s" is string literal *)
268 :     fun outString (CL.E_BinOp(e, CL.#<<, CL.E_Str s1), s2) =
269 :     output (e, CL.mkStr(s1 ^ String.toCString s2))
270 :     | outString (e, s) = output (e, CL.mkStr(String.toCString s))
271 :    
272 :     (* generate a printing function for tensors with the given shape *)
273 :     fun genTensorPrinter shape = let
274 : jhr 3931 fun ten i = CL.mkSubscript(CL.mkSelect(CL.mkVar "ten", "_data"), mkInt i)
275 : jhr 3918 fun prefix (true, lhs) = lhs
276 :     | prefix (false, lhs) = outString(lhs, ",")
277 :     fun lp (isFirst, lhs, i, [d]) = let
278 :     fun lp' (_, lhs, i, 0) = (i, outString(lhs, "]"))
279 :     | lp' (isFirst, lhs, i, n) =
280 :     lp' (false, output (prefix (isFirst, lhs), ten i), i+1, n-1)
281 :     in
282 :     lp' (true, outString(lhs, "["), i, d)
283 :     end
284 :     | lp (isFirst, lhs, i, d::dd) = let
285 :     fun lp' (_, lhs, i, 0) = (i, outString(lhs, "]"))
286 :     | lp' (isFirst, lhs, i, n) = let
287 :     val (i, lhs) = lp (true, prefix (isFirst, lhs), i, dd)
288 :     in
289 :     lp' (false, lhs, i, n-1)
290 :     end
291 :     in
292 :     lp' (true, outString(lhs, "["), i, d)
293 :     end
294 :     val params = [
295 :     CL.PARAM([], ostreamRef, "outs"),
296 : jhr 4027 CL.PARAM([], RN.tensorRefTy shape, "const & ten")
297 : jhr 3918 ]
298 :     val (_, exp) = lp (true, CL.mkVar "outs", 0, shape)
299 :     in
300 : jhr 4028 CL.D_Func(["static"], ostreamRef, [], "operator<<", params, mkReturn exp)
301 : jhr 3918 end
302 :    
303 : jhr 3936 (* builds AST for the statememt "return (x <= lo) ? lo : (hi < x) ? hi : x;" *)
304 : jhr 3935 fun mkClampStm (x, lo, hi) =
305 :     mkReturn(
306 :     CL.mkCond(CL.mkBinOp(x, CL.#<=, lo), lo,
307 :     CL.mkCond(CL.mkBinOp(hi, CL.#<, x), hi,
308 :     x)))
309 :    
310 : jhr 3950 fun mkLerp (ty, name, realTy, mkT) = mkFunc(
311 :     ty, name,
312 : jhr 3927 [CL.PARAM([], ty, "a"), CL.PARAM([], ty, "b"), CL.PARAM([], realTy, "t")],
313 :     mkReturn (
314 :     CL.mkBinOp(
315 :     CL.mkVar "a",
316 :     CL.#+,
317 :     CL.mkBinOp(
318 :     mkT(CL.mkVar "t"),
319 :     CL.#*,
320 : jhr 3976 CL.mkBinOp(CL.mkVar "b", CL.#-, CL.mkVar "a")))))
321 : jhr 3927
322 : jhr 3921 fun doOp env (rator, dcls) = let
323 :     val realTy = Env.realTy env
324 : jhr 3927 fun mkVec (w, pw, f) = CL.mkVec(
325 :     RN.vecTy w,
326 :     List.tabulate(pw, fn i => if i < w then f i else CL.mkFlt(zero, realTy)))
327 : jhr 3949 fun mkVMap (ty, name, f, w, pw) = let
328 :     fun f' i = CL.mkApply(f, [CL.mkSubscript(CL.mkVar "v", mkInt i)])
329 :     in
330 : jhr 3950 mkFunc(ty, name, [CL.PARAM([], ty, "v")], mkReturn (mkVec (w, pw, f')))
331 : jhr 3949 end
332 : jhr 3921 val dcl = (case rator
333 : jhr 4014 of Print(Ty.TensorRefTy shape) => genTensorPrinter shape
334 :     | Print(Ty.TupleTy tys) => raise Fail "FIXME: printer for tuples"
335 :     | Print(Ty.SeqTy(ty, NONE)) => raise Fail "FIXME: printer for dynseq"
336 :     | Print(Ty.SeqTy(ty, SOME n)) => raise Fail "FIXME: printer for sequence"
337 :     | Print ty => CL.D_Verbatim[] (* no printer needed *)
338 :     | RClamp => let
339 : jhr 3935 val name = "clamp"
340 :     val params = [
341 :     CL.PARAM([], realTy, "x"),
342 :     CL.PARAM([], realTy, "lo"),
343 :     CL.PARAM([], realTy, "hi")
344 :     ]
345 :     in
346 : jhr 3950 mkFunc(realTy, name, params,
347 : jhr 3935 mkClampStm (CL.mkVar "x", CL.mkVar "lo", CL.mkVar "hi"))
348 :     end
349 : jhr 3927 | RLerp => mkLerp (realTy, "lerp", realTy, fn x => x)
350 : jhr 3949 | VScale(w, pw) => let
351 :     val cTy = RN.vecTy w
352 :     in
353 : jhr 3950 mkFunc(cTy, "vscale",
354 : jhr 3949 [CL.PARAM([], realTy, "s"), CL.PARAM([], cTy, "v")],
355 :     mkReturn(
356 :     CL.mkBinOp(mkVec(w, pw, fn _ => CL.mkVar "s"), CL.#*, CL.mkVar "v")))
357 :     end
358 : jhr 3921 | VSum(w, pw) => let
359 :     val name = RN.vsum w
360 :     val params = [CL.PARAM([], RN.vecTy w, "v")]
361 :     fun mkSum 0 = CL.mkSubscript(CL.mkVar "v", mkInt 0)
362 :     | mkSum i = CL.mkBinOp(mkSum(i-1), CL.#+, CL.mkSubscript(CL.mkVar "v", mkInt i))
363 :     in
364 : jhr 3950 mkFunc(realTy, name, params, mkReturn(mkSum(w-1)))
365 : jhr 3921 end
366 : jhr 3935 | VClamp(w, pw) => let
367 :     val cTy = RN.vecTy w
368 :     val name = "vclamp"
369 :     val params = [
370 :     CL.PARAM([], cTy, "v"),
371 :     CL.PARAM([], realTy, "lo"),
372 :     CL.PARAM([], realTy, "hi")
373 :     ]
374 :     fun mkInit x = SOME(CL.I_Exps(List.tabulate(pw,
375 :     fn i => CL.I_Exp(if i < w then x else CL.mkFlt(zero, realTy)))))
376 :     val loDcl = CL.mkDecl(cTy, "vlo", mkInit(CL.mkVar "lo"))
377 :     val hiDcl = CL.mkDecl(cTy, "vhi", mkInit(CL.mkVar "hi"))
378 :     in
379 : jhr 3950 mkFunc(cTy, name, params,
380 : jhr 3935 CL.mkBlock [
381 :     loDcl, hiDcl,
382 :     mkClampStm (CL.mkVar "v", CL.mkVar "vlo", CL.mkVar "vhi")
383 :     ])
384 :     end
385 :     | VMapClamp(w, pw) => let
386 :     val cTy = RN.vecTy w
387 :     val name = "vclamp"
388 :     val params = [
389 :     CL.PARAM([], cTy, "v"),
390 :     CL.PARAM([], cTy, "vlo"),
391 :     CL.PARAM([], cTy, "vhi")
392 :     ]
393 :     in
394 : jhr 3950 mkFunc(cTy, name, params,
395 : jhr 3935 mkClampStm (CL.mkVar "v", CL.mkVar "vlo", CL.mkVar "vhi"))
396 :     end
397 : jhr 3927 | VLerp(w, pw) =>
398 :     mkLerp (RN.vecTy w, "vlerp", realTy, fn x => mkVec(w, pw, fn i => x))
399 : jhr 3949 | VCeiling(w, pw) => mkVMap (RN.vecTy w, "vceiling", "std::ceiling", w, pw)
400 :     | VFloor(w, pw) => mkVMap (RN.vecTy w, "vfloor", "std::floor", w, pw)
401 :     | VRound(w, pw) => mkVMap (RN.vecTy w, "vround", "std::round", w, pw)
402 :     | VTrunc(w, pw) => mkVMap (RN.vecTy w, "vtrunc", "std::trunc", w, pw)
403 : jhr 3950 | VToInt(w, pw) => let
404 :     val intTy = Env.intTy env
405 :     in
406 :     mkFunc(CL.voidTy, "vtoi",
407 :     [ CL.PARAM([], CL.T_Array(intTy, SOME w), "dst"),
408 :     CL.PARAM([], RN.vecTy w, "src")],
409 :     CL.mkBlock(List.tabulate (w,
410 :     fn i => CL.mkAssign(
411 :     CL.mkSubscript(CL.mkVar "dst", mkInt i),
412 :     CL.mkCons(intTy, [CL.mkSubscript(CL.mkVar "src", mkInt i)])))))
413 :     end
414 : jhr 3921 | VLoad(w, pw) => let
415 :     val name = RN.vload w
416 :     val cTy = RN.vecTy w
417 : jhr 3927 fun arg i = CL.mkSubscript(CL.mkVar "vp", mkInt i)
418 : jhr 3921 in
419 : jhr 3950 mkFunc(cTy, name,
420 : jhr 3934 [CL.PARAM(["const"], CL.T_Ptr realTy, "vp")],
421 : jhr 3927 mkReturn(mkVec (w, pw, arg)))
422 : jhr 3921 end
423 :     | VCons(w, pw) => let
424 :     val name = RN.vcons w
425 :     val cTy = RN.vecTy w
426 :     val params = List.tabulate(w, fn i => CL.PARAM([], realTy, "r"^Int.toString i))
427 : jhr 3927 fun arg i = CL.mkVar("r"^Int.toString i)
428 : jhr 3921 in
429 : jhr 3950 mkFunc(cTy, name, params, mkReturn(mkVec (w, pw, arg)))
430 : jhr 3921 end
431 : jhr 3931 | VPack layout => let
432 :     val name = RN.vpack (#wid layout)
433 :     val vParamTys = Ty.piecesOf layout
434 :     val vParams = List.mapi
435 :     (fn (i, Ty.VecTy(w, _)) => CL.PARAM([], RN.vecTy w, "v"^Int.toString i))
436 :     vParamTys
437 : jhr 4027 val dstTy = RN.tensorTy[#wid layout]
438 : jhr 3931 fun mkAssign (i, v, j) =
439 :     CL.mkAssign(
440 : jhr 3999 CL.mkSubscript(CL.mkSelect(CL.mkVar "dst", "_data"), mkInt i),
441 : jhr 3931 CL.mkSubscript(v, mkInt j))
442 :     fun mkAssignsForPiece (dstStart, pieceIdx, wid, stms) = let
443 :     val piece = CL.mkVar("v"^Int.toString pieceIdx)
444 :     fun mk (j, stms) = if (j < wid)
445 :     then mk (j+1, mkAssign (dstStart+j, piece, j) :: stms)
446 :     else stms
447 :     in
448 :     mk (0, stms)
449 :     end
450 :     fun mkAssigns (_, [], _, stms) = CL.mkBlock(List.rev stms)
451 :     | mkAssigns (i, Ty.VecTy(w, _)::tys, offset, stms) =
452 :     mkAssigns (i+1, tys, offset+w, mkAssignsForPiece(offset, i, w, stms))
453 :     in
454 : jhr 3950 mkFunc(CL.voidTy, name,
455 : jhr 4027 CL.PARAM([], dstTy, "&dst") :: vParams,
456 : jhr 3931 mkAssigns (0, vParamTys, 0, []))
457 :     end
458 : jhr 3999 | TensorCopy shp => CL.D_Verbatim[]
459 :     (*
460 : jhr 3955 | TensorCopy shp => let
461 :     val name = RN.tensorCopy shp
462 :     val dim = List.foldl Int.* 1 shp
463 :     val dstTy = CL.T_Array(realTy, SOME dim)
464 :     in
465 :     mkFunc(CL.voidTy, name,
466 :     [CL.PARAM([], dstTy, "dst"), CL.PARAM([], CL.constPtrTy realTy, "src")],
467 :     CL.mkCall("std::memcpy", [
468 :     CL.mkVar "dst", CL.mkVar "src", CL.mkSizeof dstTy
469 :     ]))
470 :     end
471 : jhr 3999 *)
472 : jhr 4027 | Transform d => let
473 :     val e = CL.mkDispatch(CL.mkVar "img", "world2image", [])
474 :     val (resTy, e) = if (d = 1)
475 :     then (realTy, e)
476 :     else let val ty = RN.tensorRefTy[d, d]
477 :     in (ty, CL.mkCons(ty, [e])) end
478 :     in
479 :     mkFunc(resTy, "world2image",
480 :     [CL.PARAM([], CL.T_Named(RN.qImageTyName d ^ " const &"), "img")],
481 :     CL.mkReturn(SOME e))
482 :     end
483 :     | Translate d => let
484 :     val e = CL.mkDispatch(CL.mkVar "img", "translate", [])
485 :     val (resTy, e) = if (d = 1)
486 :     then (realTy, e)
487 :     else let val ty = RN.tensorRefTy[d]
488 :     in (ty, CL.mkCons(ty, [e])) end
489 :     in
490 :     mkFunc(resTy, "translate",
491 :     [CL.PARAM([], CL.T_Named(RN.qImageTyName d ^ " const &"), "img")],
492 :     CL.mkReturn(SOME e))
493 :     end
494 : jhr 3921 (* end case *))
495 :     in
496 :     dcl :: dcls
497 :     end
498 :    
499 : jhr 3994 val first = CL.D_Comment["***** Begin synthesized types and operations *****"]
500 :     val last = CL.D_Comment["***** End synthesized types and operations *****"]
501 : jhr 3996 val noDcls = CL.D_Comment["***** No synthesized types or operations *****"]
502 : jhr 3994
503 : jhr 3918 fun gen (env, info) = let
504 :     val spec = Env.target env
505 : jhr 3994 val genTrait = genSeqTrait env
506 :     val genTyDecl = genTyDecl env
507 : jhr 4013 val dcls = List.foldl (doOp env) [] (CollectInfo.listOps info)
508 :     val tys = CollectInfo.listTypes info
509 : jhr 4014 val dcls = List.foldr genTyDecl dcls tys
510 : jhr 4028 val traitDcls = List.foldl genTrait [] tys
511 : jhr 3996 in
512 : jhr 4027 if List.null dcls andalso List.null traitDcls
513 : jhr 3996 then [noDcls]
514 : jhr 4027 else let
515 :     val res = [last]
516 :     val res = if List.null traitDcls
517 :     then res
518 :     else CL.D_Namespace("diderot", traitDcls) :: res
519 :     val res = if List.null dcls
520 :     then res
521 :     else CL.D_Namespace(#namespace(Env.target env), dcls) :: res
522 :     in
523 :     first :: res
524 :     end
525 : jhr 3918 end
526 :    
527 :     end

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