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

SCM Repository

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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 527 - (view) (download)

1 : jhr 519 (* c-target.sml
2 :     *
3 :     * COPYRIGHT (c) 2011 The Diderot Project (http://diderot-language.cs.uchicago.edu)
4 :     * All rights reserved.
5 :     *
6 :     * Generate C code with SSE 4.2 intrinsics.
7 :     *)
8 :    
9 :     structure CTarget : TARGET =
10 :     struct
11 :    
12 : jhr 522 structure CL = CLang
13 :    
14 : jhr 525 datatype ty
15 :     = T_Bool
16 :     | T_Int (* default float type *)
17 :     | T_Real (* default real type *)
18 :     | T_Vec of int
19 :     | T_IVec of int
20 :     | T_Image of int (* n-dimensional image data *)
21 :     | T_Data (* pointer to image data *)
22 : jhr 519
23 : jhr 525 type strand = unit (* FIXME *)
24 :    
25 :     type var = (ty * string) (* FIXME *)
26 :    
27 :     type exp = CLang.exp * ty
28 :    
29 :     type stm = CL.stm
30 :    
31 :     type method = unit (* FIXME *)
32 :    
33 : jhr 527 datatype program = Prog of {
34 :     globals : CL.decl list ref,
35 :     strands : strand list ref
36 :     }
37 :    
38 :     fun newProgram () = Prog{
39 :     globals = ref [],
40 :     strands = ref []
41 :     }
42 :    
43 : jhr 525 (* globals that specify the target characteristics. These should be initialized
44 :     * when the program object is created.
45 :     *)
46 :     val gVectorWid = ref 4
47 :     val gIntTy = ref CL.int32
48 :     val gRealTy = ref CL.float
49 :    
50 :     (* initialize globals based on target precision *)
51 :     fun initGlobals () = if !Controls.doublePrecision
52 :     then (
53 :     gVectorWid := 2;
54 :     gIntTy := CL.int64;
55 :     gRealTy := CL.double)
56 :     else (
57 :     gVectorWid := 4;
58 :     gIntTy := CL.int32;
59 :     gRealTy := CL.float)
60 :    
61 : jhr 519 (* for SSE, we have 128-bit vectors *)
62 : jhr 525 fun vectorWidth () = !gVectorWid
63 : jhr 519
64 :     (* target types *)
65 : jhr 525 val boolTy = T_Bool
66 :     val intTy = T_Int
67 :     val realTy = T_Real
68 :     fun vecTy 1 = T_Real
69 :     | vecTy n = if (n < 1) orelse (!gVectorWid < n)
70 :     then raise Size
71 :     else T_Vec n
72 :     fun ivecTy 1 = T_Int
73 :     | ivecTy n = if (n < 1) orelse (!gVectorWid < n)
74 :     then raise Size
75 :     else T_IVec n
76 :     fun imageTy dim = T_Image dim
77 : jhr 519
78 : jhr 525 (* helper functions for checking the types of arguments *)
79 :     fun scalarTy T_Int = true
80 :     | scalarTy T_Real = true
81 :     | scalarTy _ = false
82 :     fun numTy T_Bool = false
83 :     | numTy (T_Image _) = false
84 :     | numTy T_Data = false
85 :     | numTy _ = true
86 : jhr 519
87 : jhr 525 fun defineStrand (p, strandId) = raise Fail "FIXME: unimplemented"
88 :    
89 :     structure Var =
90 :     struct
91 :     fun global (p, ty, name) = raise Fail "FIXME: Var.global"
92 :     fun state (strand, ty, name) = raise Fail "FIXME: Var.state"
93 :     fun tmp ty = raise Fail "FIXME: Var.tmp"
94 : jhr 519 end
95 :    
96 :     (* expression construction *)
97 : jhr 525 structure Expr =
98 :     struct
99 : jhr 519 (* variable references *)
100 : jhr 525 fun global (ty, x) = (CL.mkVar x, ty)
101 :     fun getState (ty, x) = (CL.mkIndirect(CL.mkVar "self", x), ty)
102 :     fun param (ty, x) = (CL.mkVar x, ty)
103 :     fun var (ty, x) = (CL.mkVar x, ty)
104 :    
105 : jhr 519 (* literals *)
106 : jhr 525 fun intLit n = (CL.mkInt(n, !gIntTy), intTy)
107 :     fun floatLit f = (CL.mkFlt(f, !gRealTy), realTy)
108 :     fun stringLit s = raise Fail "FIXME: Expr.stringLit"
109 :     fun boolLit b = (CL.mkBool b, boolTy)
110 :    
111 : jhr 519 (* vector construction *)
112 : jhr 525 fun vector _ = raise Fail "FIXME: Expr.vector"
113 :    
114 : jhr 519 (* select from a vector *)
115 : jhr 525 fun select (i, (e, T_Vec n)) =
116 :     if (i < 0) orelse (n <= i)
117 :     then raise Subscript
118 :     else (CL.mkSubscript(e, CL.mkInt(IntInf.fromInt i, CL.int32)), T_Real)
119 :     | select (i, (e, T_IVec n)) =
120 :     if (i < 0) orelse (n <= i)
121 :     then raise Subscript
122 :     else (CL.mkSubscript(e, CL.mkInt(IntInf.fromInt i, CL.int32)), T_Int)
123 :     | select _ = raise Fail "invalid argument to select"
124 :    
125 : jhr 519 (* vector (and scalar) arithmetic *)
126 : jhr 525 local
127 :     fun checkTys (ty1, ty2) = (ty1 = ty2) andalso numTy ty1
128 :     fun binop rator ((e1, ty1), (e2, ty2)) =
129 :     if checkTys (ty1, ty2)
130 :     then (CL.mkBinOp(e1, rator, e2), ty1)
131 :     else raise Fail "invalid arguments to binary operator"
132 :     in
133 :     val add = binop CL.#+
134 :     val sub = binop CL.#-
135 :     val mul = binop CL.#*
136 :     val divide = binop CL.#/
137 :     end (* local *)
138 :     fun neg (e, T_Bool) = raise Fail "invalid argument to neg"
139 :     | neg (e, ty) = (CL.mkUnOp(CL.%-, e), ty)
140 :    
141 :     fun abs (e, T_Int) = (CL.mkApply("abs", [e]), T_Int) (* FIXME: not the right type for 64-bit ints *)
142 :     | abs (e, T_Real) =
143 :     if !Controls.doublePrecision
144 :     then (CL.mkApply("fabs", [e]), T_Real)
145 :     else (CL.mkApply("fabsf", [e]), T_Real)
146 :     | abs (e, T_Vec n) = raise Fail "FIXME: Expr.abs"
147 :     | abs (e, T_IVec n) = raise Fail "FIXME: Expr.abs"
148 :     | abs _ = raise Fail "invalid argument to abs"
149 :    
150 :     fun dot ((e1, T_Vec n1), (e2, T_Vec n2)) = raise Fail "FIXME: Expr.dot"
151 :     | dot _ = raise Fail "invalid argument to dot"
152 :    
153 :     fun cross ((e1, T_Vec 3), (e2, T_Vec 3)) = raise Fail "FIXME: Expr.cross"
154 :     | cross _ = raise Fail "invalid argument to cross"
155 :    
156 :     fun length (e, T_Vec n) = raise Fail "FIXME: Expr.length"
157 :     | length _ = raise Fail "invalid argument to length"
158 :    
159 :     fun normalize (e, T_Vec n) = raise Fail "FIXME: Expr.normalize"
160 :     | normalize _ = raise Fail "invalid argument to length"
161 :    
162 : jhr 519 (* comparisons *)
163 : jhr 525 local
164 :     fun checkTys (ty1, ty2) =
165 :     (ty1 = ty2) andalso scalarTy ty1
166 :     fun cmpop rator ((e1, ty1), (e2, ty2)) =
167 :     if checkTys (ty1, ty2)
168 :     then (CL.mkBinOp(e1, rator, e2), T_Bool)
169 :     else raise Fail "invalid arguments to compare operator"
170 :     in
171 :     val lt = cmpop CL.#<
172 :     val lte = cmpop CL.#<=
173 :     val equ = cmpop CL.#==
174 :     val neq = cmpop CL.#!=
175 :     val gte = cmpop CL.#>=
176 :     val gt = cmpop CL.#>
177 :     end (* local *)
178 :    
179 : jhr 519 (* logical connectives *)
180 : jhr 525 fun not (e, T_Bool) = (CL.mkUnOp(CL.%!, e), T_Bool)
181 :     | not _ = raise Fail "invalid argument to not"
182 :     fun && ((e1, T_Bool), (e2, T_Bool)) = (CL.mkBinOp(e1, CL.#&&, e2), T_Bool)
183 :     | && _ = raise Fail "invalid arguments to &&"
184 :     fun || ((e1, T_Bool), (e2, T_Bool)) = (CL.mkBinOp(e1, CL.#||, e2), T_Bool)
185 :     | || _ = raise Fail "invalid arguments to ||"
186 :    
187 :     local
188 :     fun checkTys (ty1, ty2) = (ty1 = ty2) andalso scalarTy ty1
189 :     fun binFn f ((e1, ty1), (e2, ty2)) =
190 :     if checkTys (ty1, ty2)
191 :     then (CL.mkApply(f, [e1, e2]), ty1)
192 :     else raise Fail "invalid arguments to binary function"
193 :     in
194 : jhr 519 (* misc functions *)
195 : jhr 525 val min = binFn "Diderot_min"
196 :     val max = binFn "Diderot_max"
197 :     end (* local *)
198 :    
199 : jhr 519 (* math functions *)
200 : jhr 525 fun pow ((e1, T_Real), (e2, T_Real)) =
201 :     if !Controls.doublePrecision
202 :     then (CL.mkApply("pow", [e1, e2]), T_Real)
203 :     else (CL.mkApply("powf", [e1, e2]), T_Real)
204 :     | pow _ = raise Fail "invalid arguments to pow"
205 :    
206 :     local
207 :     fun r2r (ff, fd) (e, T_Real) = if !Controls.doublePrecision
208 :     then (CL.mkApply(fd, [e]), T_Real)
209 :     else (CL.mkApply(ff, [e]), T_Real)
210 :     | r2r (_, fd) _ = raise Fail("invalid argument for "^fd)
211 :     in
212 :     val sin = r2r ("sinf", "sin")
213 :     val cos = r2r ("cosf", "cos")
214 :     val sqrt = r2r ("sqrtf", "sqrt")
215 : jhr 519 (* rounding *)
216 : jhr 525 val trunc = r2r ("truncf", "trunc")
217 :     val round = r2r ("roundf", "round")
218 :     val floor = r2r ("floorf", "floor")
219 :     val ceil = r2r ("ceilf", "ceil")
220 :     end (* local *)
221 :    
222 : jhr 519 (* conversions *)
223 : jhr 525 fun toReal (e, T_Int) = (CL.mkCast(!gRealTy, e), T_Real)
224 :     | toReal _ = raise Fail "invalid argument for toReal"
225 :    
226 :     fun truncToInt (e as (_, T_Real)) = (CL.mkCast(!gIntTy, #1(trunc e)), T_Int)
227 :     | truncToInt _ = raise Fail "invalid argument for truncToInt"
228 :     fun roundToInt (e as (_, T_Real)) = (CL.mkCast(!gIntTy, #1(round e)), T_Int)
229 :     | roundToInt _ = raise Fail "invalid argument for roundToInt"
230 :     fun ceilToInt (e as (_, T_Real)) = (CL.mkCast(!gIntTy, #1(floor e)), T_Int)
231 :     | ceilToInt _ = raise Fail "invalid argument for ceilToInt"
232 :     fun floorToInt (e as (_, T_Real)) = (CL.mkCast(!gIntTy, #1(ceil e)), T_Int)
233 :     | floorToInt _ = raise Fail "invalid argument for floorToInt"
234 :    
235 : jhr 519 (* runtime system hooks *)
236 : jhr 525 fun imageAddr (e, T_Image d) =
237 :     (CL.mkCast(CL.T_Ptr(!gRealTy), CL.mkIndirect(e, "data")), T_Data)
238 :     | imageAddr _ = raise Fail "invalid argument to imageAddr"
239 : jhr 519 end
240 :    
241 :     (* statement construction *)
242 : jhr 525 structure Stmt =
243 :     struct
244 :     val comment = CL.S_Comment
245 :     fun assignState (x, (e, _)) = CL.mkAssign(#1(Expr.getState x), e)
246 :     fun assign ((_, x), (e, _)) = CL.mkAssign(CL.mkVar x, e)
247 :     val block = CL.mkBlock
248 :     fun ifthenelse ((e, T_Bool), s1, s2) = CL.mkIfThenElse(e, s1, s2)
249 :     fun die () = raise Fail "FIXME: Stmt.die"
250 :     fun stabilize () = raise Fail "FIXME: Stmt.die"
251 : jhr 519 end
252 :    
253 : jhr 527 fun generate (baseName, Prog{globals, strands}) = let
254 :     val fileName = OS.Path.joinBaseExt{base=baseName, ext=SOME "c"}
255 :     val outS = TextIO.openOut fileName
256 :     val ppStrm = PrintAsC.new outS
257 :     in
258 :     List.app (fn dcl => PrintAsC.output(ppStrm, dcl)) (!globals);
259 :     (* what about the strands, etc? *)
260 :     PrintAsC.close ppStrm;
261 :     TextIO.closeOut outS
262 :     end
263 :    
264 : jhr 519 end
265 :    
266 :     structure CBackEnd = CodeGenFn(CTarget)

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