2 Builtins(..), sumTyCon, prodTyCon,
4 initBuiltins, initBuiltinVars, initBuiltinTyCons, initBuiltinDataCons,
5 initBuiltinPAs, initBuiltinPRs,
6 initBuiltinBoxedTyCons,
12 import IfaceEnv ( lookupOrig )
15 import DataCon ( DataCon, dataConName, dataConWorkId )
16 import TyCon ( TyCon, tyConName, tyConDataCons )
18 import Id ( mkSysLocal )
19 import Name ( Name, getOccString )
23 import TypeRep ( funTyCon )
24 import Type ( Type, mkTyConApp )
26 import TysWiredIn ( unitTyCon, unitDataCon,
28 intTyCon, intTyConName,
29 doubleTyCon, doubleTyConName,
30 boolTyCon, boolTyConName, trueDataCon, falseDataCon,
32 import PrelNames ( gHC_PARR )
33 import BasicTypes ( Boxity(..) )
39 import Control.Monad ( liftM, zipWithM )
40 import Data.List ( unzip4 )
48 mAX_NDP_COMBINE :: Int
51 mkNDPModule :: FastString -> Module
52 mkNDPModule m = mkModule ndpPackageId (mkModuleNameFS m)
64 nDP_PRELUDE_TUPLE :: Module
66 nDP_PARRAY = mkNDPModule (fsLit "Data.Array.Parallel.Lifted.PArray")
67 nDP_REPR = mkNDPModule (fsLit "Data.Array.Parallel.Lifted.Repr")
68 nDP_CLOSURE = mkNDPModule (fsLit "Data.Array.Parallel.Lifted.Closure")
69 nDP_UNBOXED = mkNDPModule (fsLit "Data.Array.Parallel.Lifted.Unboxed")
70 nDP_INSTANCES = mkNDPModule (fsLit "Data.Array.Parallel.Lifted.Instances")
71 nDP_COMBINATORS = mkNDPModule (fsLit "Data.Array.Parallel.Lifted.Combinators")
73 nDP_PRELUDE_PARR = mkNDPModule (fsLit "Data.Array.Parallel.Prelude.Base.PArr")
74 nDP_PRELUDE_INT = mkNDPModule (fsLit "Data.Array.Parallel.Prelude.Base.Int")
75 nDP_PRELUDE_DOUBLE = mkNDPModule (fsLit "Data.Array.Parallel.Prelude.Base.Double")
76 nDP_PRELUDE_BOOL = mkNDPModule (fsLit "Data.Array.Parallel.Prelude.Base.Bool")
77 nDP_PRELUDE_TUPLE = mkNDPModule (fsLit "Data.Array.Parallel.Prelude.Base.Tuple")
79 data Builtins = Builtins {
82 , paDataCon :: DataCon
85 , prDataCon :: DataCon
86 , intPrimArrayTy :: Type
89 , enumerationTyCon :: TyCon
90 , sumTyCons :: Array Int TyCon
91 , closureTyCon :: TyCon
95 , applyClosureVar :: Var
96 , mkClosurePVar :: Var
97 , applyClosurePVar :: Var
98 , replicatePAIntPrimVar :: Var
99 , upToPAIntPrimVar :: Var
100 , selectPAIntPrimVar :: Var
101 , truesPABoolPrimVar :: Var
103 , replicatePAVar :: Var
106 , combinePAVars :: Array Int Var
107 , liftingContext :: Var
110 sumTyCon :: Int -> Builtins -> TyCon
112 | n >= 2 && n <= mAX_NDP_SUM = sumTyCons bi ! n
113 | otherwise = pprPanic "sumTyCon" (ppr n)
115 prodTyCon :: Int -> Builtins -> TyCon
117 | n == 1 = wrapTyCon bi
118 | n >= 0 && n <= mAX_NDP_PROD = tupleTyCon Boxed n
119 | otherwise = pprPanic "prodTyCon" (ppr n)
121 combinePAVar :: Int -> Builtins -> Var
123 | n >= 2 && n <= mAX_NDP_COMBINE = combinePAVars bi ! n
124 | otherwise = pprPanic "combinePAVar" (ppr n)
126 initBuiltins :: DsM Builtins
129 parrayTyCon <- externalTyCon nDP_PARRAY (fsLit "PArray")
130 paTyCon <- externalTyCon nDP_PARRAY (fsLit "PA")
131 let [paDataCon] = tyConDataCons paTyCon
132 preprTyCon <- externalTyCon nDP_PARRAY (fsLit "PRepr")
133 prTyCon <- externalTyCon nDP_PARRAY (fsLit "PR")
134 let [prDataCon] = tyConDataCons prTyCon
135 intPrimArrayTy <- externalType nDP_UNBOXED (fsLit "PArray_Int#")
136 closureTyCon <- externalTyCon nDP_CLOSURE (fsLit ":->")
138 voidTyCon <- externalTyCon nDP_REPR (fsLit "Void")
139 wrapTyCon <- externalTyCon nDP_REPR (fsLit "Wrap")
140 enumerationTyCon <- externalTyCon nDP_REPR (fsLit "Enumeration")
141 sum_tcs <- mapM (externalTyCon nDP_REPR)
142 [mkFastString ("Sum" ++ show i) | i <- [2..mAX_NDP_SUM]]
144 let sumTyCons = listArray (2, mAX_NDP_SUM) sum_tcs
146 voidVar <- externalVar nDP_REPR (fsLit "void")
147 mkPRVar <- externalVar nDP_PARRAY (fsLit "mkPR")
148 mkClosureVar <- externalVar nDP_CLOSURE (fsLit "mkClosure")
149 applyClosureVar <- externalVar nDP_CLOSURE (fsLit "$:")
150 mkClosurePVar <- externalVar nDP_CLOSURE (fsLit "mkClosureP")
151 applyClosurePVar <- externalVar nDP_CLOSURE (fsLit "$:^")
152 replicatePAIntPrimVar <- externalVar nDP_UNBOXED (fsLit "replicatePA_Int#")
153 upToPAIntPrimVar <- externalVar nDP_UNBOXED (fsLit "upToPA_Int#")
154 selectPAIntPrimVar <- externalVar nDP_UNBOXED (fsLit "selectPA_Int#")
155 truesPABoolPrimVar <- externalVar nDP_UNBOXED (fsLit "truesPA_Bool#")
156 lengthPAVar <- externalVar nDP_PARRAY (fsLit "lengthPA#")
157 replicatePAVar <- externalVar nDP_PARRAY (fsLit "replicatePA#")
158 emptyPAVar <- externalVar nDP_PARRAY (fsLit "emptyPA")
159 packPAVar <- externalVar nDP_PARRAY (fsLit "packPA#")
161 combines <- mapM (externalVar nDP_PARRAY)
162 [mkFastString ("combine" ++ show i ++ "PA#")
163 | i <- [2..mAX_NDP_COMBINE]]
164 let combinePAVars = listArray (2, mAX_NDP_COMBINE) combines
166 liftingContext <- liftM (\u -> mkSysLocal (fsLit "lc") u intPrimTy)
170 parrayTyCon = parrayTyCon
172 , paDataCon = paDataCon
173 , preprTyCon = preprTyCon
175 , prDataCon = prDataCon
176 , intPrimArrayTy = intPrimArrayTy
177 , voidTyCon = voidTyCon
178 , wrapTyCon = wrapTyCon
179 , enumerationTyCon = enumerationTyCon
180 , sumTyCons = sumTyCons
181 , closureTyCon = closureTyCon
184 , mkClosureVar = mkClosureVar
185 , applyClosureVar = applyClosureVar
186 , mkClosurePVar = mkClosurePVar
187 , applyClosurePVar = applyClosurePVar
188 , replicatePAIntPrimVar = replicatePAIntPrimVar
189 , upToPAIntPrimVar = upToPAIntPrimVar
190 , selectPAIntPrimVar = selectPAIntPrimVar
191 , truesPABoolPrimVar = truesPABoolPrimVar
192 , lengthPAVar = lengthPAVar
193 , replicatePAVar = replicatePAVar
194 , emptyPAVar = emptyPAVar
195 , packPAVar = packPAVar
196 , combinePAVars = combinePAVars
197 , liftingContext = liftingContext
200 initBuiltinVars :: Builtins -> DsM [(Var, Var)]
203 uvars <- zipWithM externalVar umods ufs
204 vvars <- zipWithM externalVar vmods vfs
205 cvars <- zipWithM externalVar cmods cfs
206 return $ [(v,v) | v <- map dataConWorkId defaultDataConWorkers]
207 ++ zip (map dataConWorkId cons) cvars
210 (umods, ufs, vmods, vfs) = unzip4 preludeVars
212 (cons, cmods, cfs) = unzip3 preludeDataCons
214 defaultDataConWorkers :: [DataCon]
215 defaultDataConWorkers = [trueDataCon, falseDataCon, unitDataCon]
217 preludeDataCons :: [(DataCon, Module, FastString)]
219 = [mk_tup n nDP_PRELUDE_TUPLE (mkFastString $ "tup" ++ show n) | n <- [2..3]]
221 mk_tup n mod name = (tupleCon Boxed n, mod, name)
223 preludeVars :: [(Module, FastString, Module, FastString)]
226 mk gHC_PARR (fsLit "mapP") nDP_COMBINATORS (fsLit "mapPA")
227 , mk gHC_PARR (fsLit "zipWithP") nDP_COMBINATORS (fsLit "zipWithPA")
228 , mk gHC_PARR (fsLit "zipP") nDP_COMBINATORS (fsLit "zipPA")
229 , mk gHC_PARR (fsLit "unzipP") nDP_COMBINATORS (fsLit "unzipPA")
230 , mk gHC_PARR (fsLit "filterP") nDP_COMBINATORS (fsLit "filterPA")
231 , mk gHC_PARR (fsLit "lengthP") nDP_COMBINATORS (fsLit "lengthPA")
232 , mk gHC_PARR (fsLit "replicateP") nDP_COMBINATORS (fsLit "replicatePA")
233 , mk gHC_PARR (fsLit "!:") nDP_COMBINATORS (fsLit "indexPA")
234 , mk gHC_PARR (fsLit "crossMapP") nDP_COMBINATORS (fsLit "crossMapPA")
235 , mk gHC_PARR (fsLit "singletonP") nDP_COMBINATORS (fsLit "singletonPA")
236 , mk gHC_PARR (fsLit "concatP") nDP_COMBINATORS (fsLit "concatPA")
237 , mk gHC_PARR (fsLit "+:+") nDP_COMBINATORS (fsLit "appPA")
238 , mk gHC_PARR (fsLit "emptyP") nDP_PARRAY (fsLit "emptyPA")
240 , mk nDP_PRELUDE_INT (fsLit "plus") nDP_PRELUDE_INT (fsLit "plusV")
241 , mk nDP_PRELUDE_INT (fsLit "minus") nDP_PRELUDE_INT (fsLit "minusV")
242 , mk nDP_PRELUDE_INT (fsLit "mult") nDP_PRELUDE_INT (fsLit "multV")
243 , mk nDP_PRELUDE_INT (fsLit "intDiv") nDP_PRELUDE_INT (fsLit "intDivV")
244 , mk nDP_PRELUDE_INT (fsLit "intMod") nDP_PRELUDE_INT (fsLit "intModV")
245 , mk nDP_PRELUDE_INT (fsLit "intSquareRoot") nDP_PRELUDE_INT (fsLit "intSquareRootV")
246 , mk nDP_PRELUDE_INT (fsLit "intSumP") nDP_PRELUDE_INT (fsLit "intSumPA")
247 , mk nDP_PRELUDE_INT (fsLit "enumFromToP") nDP_PRELUDE_INT (fsLit "enumFromToPA")
248 , mk nDP_PRELUDE_INT (fsLit "upToP") nDP_PRELUDE_INT (fsLit "upToPA")
250 , mk nDP_PRELUDE_INT (fsLit "eq") nDP_PRELUDE_INT (fsLit "eqV")
251 , mk nDP_PRELUDE_INT (fsLit "neq") nDP_PRELUDE_INT (fsLit "neqV")
252 , mk nDP_PRELUDE_INT (fsLit "le") nDP_PRELUDE_INT (fsLit "leV")
253 , mk nDP_PRELUDE_INT (fsLit "lt") nDP_PRELUDE_INT (fsLit "ltV")
254 , mk nDP_PRELUDE_INT (fsLit "ge") nDP_PRELUDE_INT (fsLit "geV")
255 , mk nDP_PRELUDE_INT (fsLit "gt") nDP_PRELUDE_INT (fsLit "gtV")
257 , mk nDP_PRELUDE_DOUBLE (fsLit "plus") nDP_PRELUDE_DOUBLE (fsLit "plusV")
258 , mk nDP_PRELUDE_DOUBLE (fsLit "minus") nDP_PRELUDE_DOUBLE (fsLit "minusV")
259 , mk nDP_PRELUDE_DOUBLE (fsLit "mult") nDP_PRELUDE_DOUBLE (fsLit "multV")
260 , mk nDP_PRELUDE_DOUBLE (fsLit "divide") nDP_PRELUDE_DOUBLE (fsLit "divideV")
261 , mk nDP_PRELUDE_DOUBLE (fsLit "squareRoot") nDP_PRELUDE_DOUBLE (fsLit "squareRootV")
262 , mk nDP_PRELUDE_DOUBLE (fsLit "doubleSumP") nDP_PRELUDE_DOUBLE (fsLit "doubleSumPA")
263 , mk nDP_PRELUDE_DOUBLE (fsLit "minIndexP")
264 nDP_PRELUDE_DOUBLE (fsLit "minIndexPA")
265 , mk nDP_PRELUDE_DOUBLE (fsLit "maxIndexP")
266 nDP_PRELUDE_DOUBLE (fsLit "maxIndexPA")
268 , mk nDP_PRELUDE_DOUBLE (fsLit "eq") nDP_PRELUDE_DOUBLE (fsLit "eqV")
269 , mk nDP_PRELUDE_DOUBLE (fsLit "neq") nDP_PRELUDE_DOUBLE (fsLit "neqV")
270 , mk nDP_PRELUDE_DOUBLE (fsLit "le") nDP_PRELUDE_DOUBLE (fsLit "leV")
271 , mk nDP_PRELUDE_DOUBLE (fsLit "lt") nDP_PRELUDE_DOUBLE (fsLit "ltV")
272 , mk nDP_PRELUDE_DOUBLE (fsLit "ge") nDP_PRELUDE_DOUBLE (fsLit "geV")
273 , mk nDP_PRELUDE_DOUBLE (fsLit "gt") nDP_PRELUDE_DOUBLE (fsLit "gtV")
275 , mk nDP_PRELUDE_BOOL (fsLit "andP") nDP_PRELUDE_BOOL (fsLit "andPA")
276 , mk nDP_PRELUDE_BOOL (fsLit "orP") nDP_PRELUDE_BOOL (fsLit "orPA")
279 , mk nDP_PRELUDE_PARR (fsLit "fromPArrayP") nDP_PRELUDE_PARR (fsLit "fromPArrayPA")
280 , mk nDP_PRELUDE_PARR (fsLit "toPArrayP") nDP_PRELUDE_PARR (fsLit "toPArrayPA")
281 , mk nDP_PRELUDE_PARR (fsLit "fromNestedPArrayP") nDP_PRELUDE_PARR (fsLit "fromNestedPArrayPA")
282 , mk nDP_PRELUDE_PARR (fsLit "combineP") nDP_COMBINATORS (fsLit "combine2PA")
287 initBuiltinTyCons :: Builtins -> DsM [(Name, TyCon)]
290 -- parr <- externalTyCon nDP_PRELUDE_PARR (fsLit "PArr")
291 return $ (tyConName funTyCon, closureTyCon bi)
292 : (parrTyConName, parrayTyCon bi)
295 : (tyConName $ parrayTyCon bi, parrayTyCon bi)
297 : [(tyConName tc, tc) | tc <- defaultTyCons]
299 defaultTyCons :: [TyCon]
300 defaultTyCons = [intTyCon, boolTyCon, doubleTyCon]
302 initBuiltinDataCons :: Builtins -> [(Name, DataCon)]
303 initBuiltinDataCons _ = [(dataConName dc, dc)| dc <- defaultDataCons]
305 defaultDataCons :: [DataCon]
306 defaultDataCons = [trueDataCon, falseDataCon, unitDataCon]
308 initBuiltinDicts :: [(Name, Module, FastString)] -> DsM [(Name, Var)]
311 dicts <- zipWithM externalVar mods fss
312 return $ zip tcs dicts
314 (tcs, mods, fss) = unzip3 ps
316 initBuiltinPAs :: Builtins -> DsM [(Name, Var)]
317 initBuiltinPAs = initBuiltinDicts . builtinPAs
319 builtinPAs :: Builtins -> [(Name, Module, FastString)]
322 mk (tyConName $ closureTyCon bi) nDP_CLOSURE (fsLit "dPA_Clo")
323 , mk (tyConName $ voidTyCon bi) nDP_REPR (fsLit "dPA_Void")
324 , mk (tyConName $ parrayTyCon bi) nDP_INSTANCES (fsLit "dPA_PArray")
325 , mk unitTyConName nDP_INSTANCES (fsLit "dPA_Unit")
327 , mk intTyConName nDP_INSTANCES (fsLit "dPA_Int")
328 , mk doubleTyConName nDP_INSTANCES (fsLit "dPA_Double")
329 , mk boolTyConName nDP_INSTANCES (fsLit "dPA_Bool")
333 mk name mod fs = (name, mod, fs)
335 tups = map mk_tup [2..mAX_NDP_PROD]
336 mk_tup n = mk (tyConName $ tupleTyCon Boxed n)
338 (mkFastString $ "dPA_" ++ show n)
340 initBuiltinPRs :: Builtins -> DsM [(Name, Var)]
341 initBuiltinPRs = initBuiltinDicts . builtinPRs
343 builtinPRs :: Builtins -> [(Name, Module, FastString)]
346 mk (tyConName unitTyCon) nDP_REPR (fsLit "dPR_Unit")
347 , mk (tyConName $ voidTyCon bi) nDP_REPR (fsLit "dPR_Void")
348 , mk (tyConName $ wrapTyCon bi) nDP_REPR (fsLit "dPR_Wrap")
349 , mk (tyConName $ enumerationTyCon bi) nDP_REPR (fsLit "dPR_Enumeration")
350 , mk (tyConName $ closureTyCon bi) nDP_CLOSURE (fsLit "dPR_Clo")
353 , mk intTyConName nDP_INSTANCES (fsLit "dPR_Int")
354 , mk doubleTyConName nDP_INSTANCES (fsLit "dPR_Double")
357 ++ map mk_sum [2..mAX_NDP_SUM]
358 ++ map mk_prod [2..mAX_NDP_PROD]
360 mk name mod fs = (name, mod, fs)
362 mk_sum n = (tyConName $ sumTyCon n bi, nDP_REPR,
363 mkFastString ("dPR_Sum" ++ show n))
365 mk_prod n = (tyConName $ prodTyCon n bi, nDP_REPR,
366 mkFastString ("dPR_" ++ show n))
368 initBuiltinBoxedTyCons :: Builtins -> DsM [(Name, TyCon)]
369 initBuiltinBoxedTyCons = return . builtinBoxedTyCons
371 builtinBoxedTyCons :: Builtins -> [(Name, TyCon)]
372 builtinBoxedTyCons _ =
373 [(tyConName intPrimTyCon, intTyCon)]
375 externalVar :: Module -> FastString -> DsM Var
377 = dsLookupGlobalId =<< lookupOrig mod (mkVarOccFS fs)
379 externalTyCon :: Module -> FastString -> DsM TyCon
381 = dsLookupTyCon =<< lookupOrig mod (mkOccNameFS tcName fs)
383 externalType :: Module -> FastString -> DsM Type
386 tycon <- externalTyCon mod fs
387 return $ mkTyConApp tycon []
389 unitTyConName :: Name
390 unitTyConName = tyConName unitTyCon
393 primMethod :: TyCon -> String -> DsM (Maybe Var)
394 primMethod tycon method
395 | Just suffix <- lookupNameEnv prim_ty_cons (tyConName tycon)
397 $ dsLookupGlobalId =<< lookupOrig nDP_UNBOXED (mkVarOcc $ method ++ suffix)
399 | otherwise = return Nothing
401 primPArray :: TyCon -> DsM (Maybe TyCon)
403 | Just suffix <- lookupNameEnv prim_ty_cons (tyConName tycon)
405 $ dsLookupTyCon =<< lookupOrig nDP_UNBOXED (mkOccName tcName $ "PArray" ++ suffix)
407 | otherwise = return Nothing
409 prim_ty_cons :: NameEnv String
410 prim_ty_cons = mkNameEnv [mk_prim intPrimTyCon]
412 mk_prim tycon = (tyConName tycon, '_' : getOccString tycon)