2 Builtins(..), sumTyCon, prodTyCon, uarrTy, intPrimArrayTy,
4 initBuiltins, initBuiltinVars, initBuiltinTyCons, initBuiltinDataCons,
5 initBuiltinPAs, initBuiltinPRs,
6 initBuiltinBoxedTyCons,
11 #include "HsVersions.h"
14 import IfaceEnv ( lookupOrig )
17 import DataCon ( DataCon, dataConName, dataConWorkId )
18 import TyCon ( TyCon, tyConName, tyConDataCons )
20 import Id ( mkSysLocal )
21 import Name ( Name, getOccString )
25 import TypeRep ( funTyCon )
26 import Type ( Type, mkTyConApp )
28 import TysWiredIn ( unitTyCon, unitDataCon,
30 intTyCon, intTyConName, intTy,
31 doubleTyCon, doubleTyConName,
32 boolTyCon, boolTyConName, trueDataCon, falseDataCon,
34 import PrelNames ( gHC_PARR )
35 import BasicTypes ( Boxity(..) )
41 import Control.Monad ( liftM, zipWithM )
42 import Data.List ( unzip4 )
50 mAX_NDP_COMBINE :: Int
53 mkNDPModule :: FastString -> Module
54 mkNDPModule m = mkModule ndpPackageId (mkModuleNameFS m)
66 nDP_PRELUDE_TUPLE :: Module
68 nDP_UARR = mkNDPModule FSLIT("Data.Array.Parallel.Unlifted.Flat.UArr")
69 nDP_PARRAY = mkNDPModule FSLIT("Data.Array.Parallel.Lifted.PArray")
70 nDP_REPR = mkNDPModule FSLIT("Data.Array.Parallel.Lifted.Repr")
71 nDP_CLOSURE = mkNDPModule FSLIT("Data.Array.Parallel.Lifted.Closure")
72 nDP_UNBOXED = mkNDPModule FSLIT("Data.Array.Parallel.Lifted.Unboxed")
73 nDP_INSTANCES = mkNDPModule FSLIT("Data.Array.Parallel.Lifted.Instances")
74 nDP_COMBINATORS = mkNDPModule FSLIT("Data.Array.Parallel.Lifted.Combinators")
76 nDP_PRELUDE_PARR = mkNDPModule FSLIT("Data.Array.Parallel.Prelude.Base.PArr")
77 nDP_PRELUDE_INT = mkNDPModule FSLIT("Data.Array.Parallel.Prelude.Base.Int")
78 nDP_PRELUDE_DOUBLE = mkNDPModule FSLIT("Data.Array.Parallel.Prelude.Base.Double")
79 nDP_PRELUDE_TUPLE = mkNDPModule FSLIT("Data.Array.Parallel.Prelude.Base.Tuple")
81 data Builtins = Builtins {
84 , paDataCon :: DataCon
87 , prDataCon :: DataCon
91 , enumerationTyCon :: TyCon
92 , sumTyCons :: Array Int TyCon
93 , closureTyCon :: TyCon
97 , applyClosureVar :: Var
98 , mkClosurePVar :: Var
99 , applyClosurePVar :: Var
100 , replicatePAIntPrimVar :: Var
101 , upToPAIntPrimVar :: Var
102 , selectPAIntPrimVar :: Var
103 , truesPABoolPrimVar :: Var
105 , replicatePAVar :: Var
108 , combinePAVars :: Array Int Var
109 , liftingContext :: Var
112 uarrTy :: Type -> Builtins -> Type
113 uarrTy ty bi = mkTyConApp (uarrTyCon bi) [ty]
115 intPrimArrayTy :: Builtins -> Type
116 intPrimArrayTy = uarrTy intTy
118 sumTyCon :: Int -> Builtins -> TyCon
120 | n >= 2 && n <= mAX_NDP_SUM = sumTyCons bi ! n
121 | otherwise = pprPanic "sumTyCon" (ppr n)
123 prodTyCon :: Int -> Builtins -> TyCon
125 | n == 1 = wrapTyCon bi
126 | n >= 0 && n <= mAX_NDP_PROD = tupleTyCon Boxed n
127 | otherwise = pprPanic "prodTyCon" (ppr n)
129 combinePAVar :: Int -> Builtins -> Var
131 | n >= 2 && n <= mAX_NDP_COMBINE = combinePAVars bi ! n
132 | otherwise = pprPanic "combinePAVar" (ppr n)
134 initBuiltins :: DsM Builtins
137 parrayTyCon <- externalTyCon nDP_PARRAY FSLIT("PArray")
138 paTyCon <- externalTyCon nDP_PARRAY FSLIT("PA")
139 let [paDataCon] = tyConDataCons paTyCon
140 preprTyCon <- externalTyCon nDP_PARRAY FSLIT("PRepr")
141 prTyCon <- externalTyCon nDP_PARRAY FSLIT("PR")
142 let [prDataCon] = tyConDataCons prTyCon
143 uarrTyCon <- externalTyCon nDP_UARR FSLIT("UArr")
144 closureTyCon <- externalTyCon nDP_CLOSURE FSLIT(":->")
146 voidTyCon <- externalTyCon nDP_REPR FSLIT("Void")
147 wrapTyCon <- externalTyCon nDP_REPR FSLIT("Wrap")
148 enumerationTyCon <- externalTyCon nDP_REPR FSLIT("Enumeration")
149 sum_tcs <- mapM (externalTyCon nDP_REPR)
150 [mkFastString ("Sum" ++ show i) | i <- [2..mAX_NDP_SUM]]
152 let sumTyCons = listArray (2, mAX_NDP_SUM) sum_tcs
154 voidVar <- externalVar nDP_REPR FSLIT("void")
155 mkPRVar <- externalVar nDP_PARRAY FSLIT("mkPR")
156 mkClosureVar <- externalVar nDP_CLOSURE FSLIT("mkClosure")
157 applyClosureVar <- externalVar nDP_CLOSURE FSLIT("$:")
158 mkClosurePVar <- externalVar nDP_CLOSURE FSLIT("mkClosureP")
159 applyClosurePVar <- externalVar nDP_CLOSURE FSLIT("$:^")
160 replicatePAIntPrimVar <- externalVar nDP_UNBOXED FSLIT("replicatePA_Int#")
161 upToPAIntPrimVar <- externalVar nDP_UNBOXED FSLIT("upToPA_Int#")
162 selectPAIntPrimVar <- externalVar nDP_UNBOXED FSLIT("selectPA_Int#")
163 truesPABoolPrimVar <- externalVar nDP_UNBOXED FSLIT("truesPA_Bool#")
164 lengthPAVar <- externalVar nDP_PARRAY FSLIT("lengthPA#")
165 replicatePAVar <- externalVar nDP_PARRAY FSLIT("replicatePA#")
166 emptyPAVar <- externalVar nDP_PARRAY FSLIT("emptyPA")
167 packPAVar <- externalVar nDP_PARRAY FSLIT("packPA#")
169 combines <- mapM (externalVar nDP_PARRAY)
170 [mkFastString ("combine" ++ show i ++ "PA#")
171 | i <- [2..mAX_NDP_COMBINE]]
172 let combinePAVars = listArray (2, mAX_NDP_COMBINE) combines
174 liftingContext <- liftM (\u -> mkSysLocal FSLIT("lc") u intPrimTy)
178 parrayTyCon = parrayTyCon
180 , paDataCon = paDataCon
181 , preprTyCon = preprTyCon
183 , prDataCon = prDataCon
184 , uarrTyCon = uarrTyCon
185 , voidTyCon = voidTyCon
186 , wrapTyCon = wrapTyCon
187 , enumerationTyCon = enumerationTyCon
188 , sumTyCons = sumTyCons
189 , closureTyCon = closureTyCon
192 , mkClosureVar = mkClosureVar
193 , applyClosureVar = applyClosureVar
194 , mkClosurePVar = mkClosurePVar
195 , applyClosurePVar = applyClosurePVar
196 , replicatePAIntPrimVar = replicatePAIntPrimVar
197 , upToPAIntPrimVar = upToPAIntPrimVar
198 , selectPAIntPrimVar = selectPAIntPrimVar
199 , truesPABoolPrimVar = truesPABoolPrimVar
200 , lengthPAVar = lengthPAVar
201 , replicatePAVar = replicatePAVar
202 , emptyPAVar = emptyPAVar
203 , packPAVar = packPAVar
204 , combinePAVars = combinePAVars
205 , liftingContext = liftingContext
208 initBuiltinVars :: Builtins -> DsM [(Var, Var)]
211 uvars <- zipWithM externalVar umods ufs
212 vvars <- zipWithM externalVar vmods vfs
213 cvars <- zipWithM externalVar cmods cfs
214 return $ [(v,v) | v <- map dataConWorkId defaultDataConWorkers]
215 ++ zip (map dataConWorkId cons) cvars
218 (umods, ufs, vmods, vfs) = unzip4 preludeVars
220 (cons, cmods, cfs) = unzip3 preludeDataCons
222 defaultDataConWorkers :: [DataCon]
223 defaultDataConWorkers = [trueDataCon, falseDataCon, unitDataCon]
225 preludeDataCons :: [(DataCon, Module, FastString)]
227 = [mk_tup n nDP_PRELUDE_TUPLE (mkFastString $ "tup" ++ show n) | n <- [2..3]]
229 mk_tup n mod name = (tupleCon Boxed n, mod, name)
231 preludeVars :: [(Module, FastString, Module, FastString)]
234 mk gHC_PARR FSLIT("mapP") nDP_COMBINATORS FSLIT("mapPA")
235 , mk gHC_PARR FSLIT("zipWithP") nDP_COMBINATORS FSLIT("zipWithPA")
236 , mk gHC_PARR FSLIT("zipP") nDP_COMBINATORS FSLIT("zipPA")
237 , mk gHC_PARR FSLIT("unzipP") nDP_COMBINATORS FSLIT("unzipPA")
238 , mk gHC_PARR FSLIT("filterP") nDP_COMBINATORS FSLIT("filterPA")
239 , mk gHC_PARR FSLIT("lengthP") nDP_COMBINATORS FSLIT("lengthPA")
240 , mk gHC_PARR FSLIT("replicateP") nDP_COMBINATORS FSLIT("replicatePA")
241 , mk gHC_PARR FSLIT("!:") nDP_COMBINATORS FSLIT("indexPA")
242 , mk gHC_PARR FSLIT("crossMapP") nDP_COMBINATORS FSLIT("crossMapPA")
243 , mk gHC_PARR FSLIT("singletonP") nDP_COMBINATORS FSLIT("singletonPA")
244 , mk gHC_PARR FSLIT("concatP") nDP_COMBINATORS FSLIT("concatPA")
245 , mk gHC_PARR FSLIT("+:+") nDP_COMBINATORS FSLIT("appPA")
247 , mk nDP_PRELUDE_INT FSLIT("plus") nDP_PRELUDE_INT FSLIT("plusV")
248 , mk nDP_PRELUDE_INT FSLIT("minus") nDP_PRELUDE_INT FSLIT("minusV")
249 , mk nDP_PRELUDE_INT FSLIT("mult") nDP_PRELUDE_INT FSLIT("multV")
250 , mk nDP_PRELUDE_INT FSLIT("intDiv") nDP_PRELUDE_INT FSLIT("intDivV")
251 , mk nDP_PRELUDE_INT FSLIT("sumP") nDP_PRELUDE_INT FSLIT("sumPA")
252 , mk nDP_PRELUDE_INT FSLIT("upToP") nDP_PRELUDE_INT FSLIT("upToPA")
254 , mk nDP_PRELUDE_INT FSLIT("eq") nDP_PRELUDE_INT FSLIT("eqV")
255 , mk nDP_PRELUDE_INT FSLIT("neq") nDP_PRELUDE_INT FSLIT("neqV")
256 , mk nDP_PRELUDE_INT FSLIT("le") nDP_PRELUDE_INT FSLIT("leV")
257 , mk nDP_PRELUDE_INT FSLIT("lt") nDP_PRELUDE_INT FSLIT("ltV")
258 , mk nDP_PRELUDE_INT FSLIT("ge") nDP_PRELUDE_INT FSLIT("geV")
259 , mk nDP_PRELUDE_INT FSLIT("gt") nDP_PRELUDE_INT FSLIT("gtV")
261 , mk nDP_PRELUDE_DOUBLE FSLIT("plus") nDP_PRELUDE_DOUBLE FSLIT("plusV")
262 , mk nDP_PRELUDE_DOUBLE FSLIT("minus") nDP_PRELUDE_DOUBLE FSLIT("minusV")
263 , mk nDP_PRELUDE_DOUBLE FSLIT("mult") nDP_PRELUDE_DOUBLE FSLIT("multV")
264 , mk nDP_PRELUDE_DOUBLE FSLIT("divide") nDP_PRELUDE_DOUBLE FSLIT("divideV")
265 , mk nDP_PRELUDE_DOUBLE FSLIT("sumP") nDP_PRELUDE_DOUBLE FSLIT("sumPA")
266 , mk nDP_PRELUDE_DOUBLE FSLIT("minIndexP")
267 nDP_PRELUDE_DOUBLE FSLIT("minIndexPA")
268 , mk nDP_PRELUDE_DOUBLE FSLIT("maxIndexP")
269 nDP_PRELUDE_DOUBLE FSLIT("maxIndexPA")
271 , mk nDP_PRELUDE_DOUBLE FSLIT("eq") nDP_PRELUDE_DOUBLE FSLIT("eqV")
272 , mk nDP_PRELUDE_DOUBLE FSLIT("neq") nDP_PRELUDE_DOUBLE FSLIT("neqV")
273 , mk nDP_PRELUDE_DOUBLE FSLIT("le") nDP_PRELUDE_DOUBLE FSLIT("leV")
274 , mk nDP_PRELUDE_DOUBLE FSLIT("lt") nDP_PRELUDE_DOUBLE FSLIT("ltV")
275 , mk nDP_PRELUDE_DOUBLE FSLIT("ge") nDP_PRELUDE_DOUBLE FSLIT("geV")
276 , mk nDP_PRELUDE_DOUBLE FSLIT("gt") nDP_PRELUDE_DOUBLE FSLIT("gtV")
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")
286 initBuiltinTyCons :: Builtins -> DsM [(Name, TyCon)]
289 -- parr <- externalTyCon nDP_PRELUDE_PARR FSLIT("PArr")
290 return $ (tyConName funTyCon, closureTyCon bi)
291 : (parrTyConName, parrayTyCon bi)
294 : (tyConName $ parrayTyCon bi, parrayTyCon bi)
296 : [(tyConName tc, tc) | tc <- defaultTyCons]
298 defaultTyCons :: [TyCon]
299 defaultTyCons = [intTyCon, boolTyCon, doubleTyCon]
301 initBuiltinDataCons :: Builtins -> [(Name, DataCon)]
302 initBuiltinDataCons _ = [(dataConName dc, dc)| dc <- defaultDataCons]
304 defaultDataCons :: [DataCon]
305 defaultDataCons = [trueDataCon, falseDataCon, unitDataCon]
307 initBuiltinDicts :: [(Name, Module, FastString)] -> DsM [(Name, Var)]
310 dicts <- zipWithM externalVar mods fss
311 return $ zip tcs dicts
313 (tcs, mods, fss) = unzip3 ps
315 initBuiltinPAs :: Builtins -> DsM [(Name, Var)]
316 initBuiltinPAs = initBuiltinDicts . builtinPAs
318 builtinPAs :: Builtins -> [(Name, Module, FastString)]
321 mk (tyConName $ closureTyCon bi) nDP_CLOSURE FSLIT("dPA_Clo")
322 , mk (tyConName $ voidTyCon bi) nDP_REPR FSLIT("dPA_Void")
323 , mk (tyConName $ parrayTyCon bi) nDP_INSTANCES FSLIT("dPA_PArray")
324 , mk unitTyConName nDP_INSTANCES FSLIT("dPA_Unit")
326 , mk intTyConName nDP_INSTANCES FSLIT("dPA_Int")
327 , mk doubleTyConName nDP_INSTANCES FSLIT("dPA_Double")
328 , mk boolTyConName nDP_INSTANCES FSLIT("dPA_Bool")
332 mk name mod fs = (name, mod, fs)
334 tups = map mk_tup [2..mAX_NDP_PROD]
335 mk_tup n = mk (tyConName $ tupleTyCon Boxed n)
337 (mkFastString $ "dPA_" ++ show n)
339 initBuiltinPRs :: Builtins -> DsM [(Name, Var)]
340 initBuiltinPRs = initBuiltinDicts . builtinPRs
342 builtinPRs :: Builtins -> [(Name, Module, FastString)]
345 mk (tyConName unitTyCon) nDP_REPR FSLIT("dPR_Unit")
346 , mk (tyConName $ voidTyCon bi) nDP_REPR FSLIT("dPR_Void")
347 , mk (tyConName $ wrapTyCon bi) nDP_REPR FSLIT("dPR_Wrap")
348 , mk (tyConName $ enumerationTyCon bi) nDP_REPR FSLIT("dPR_Enumeration")
349 , mk (tyConName $ closureTyCon bi) nDP_CLOSURE FSLIT("dPR_Clo")
352 , mk intTyConName nDP_INSTANCES FSLIT("dPR_Int")
353 , mk doubleTyConName nDP_INSTANCES FSLIT("dPR_Double")
356 ++ map mk_sum [2..mAX_NDP_SUM]
357 ++ map mk_prod [2..mAX_NDP_PROD]
359 mk name mod fs = (name, mod, fs)
361 mk_sum n = (tyConName $ sumTyCon n bi, nDP_REPR,
362 mkFastString ("dPR_Sum" ++ show n))
364 mk_prod n = (tyConName $ prodTyCon n bi, nDP_REPR,
365 mkFastString ("dPR_" ++ show n))
367 initBuiltinBoxedTyCons :: Builtins -> DsM [(Name, TyCon)]
368 initBuiltinBoxedTyCons = return . builtinBoxedTyCons
370 builtinBoxedTyCons :: Builtins -> [(Name, TyCon)]
371 builtinBoxedTyCons _ =
372 [(tyConName intPrimTyCon, intTyCon)]
374 externalVar :: Module -> FastString -> DsM Var
376 = dsLookupGlobalId =<< lookupOrig mod (mkVarOccFS fs)
378 externalTyCon :: Module -> FastString -> DsM TyCon
380 = dsLookupTyCon =<< lookupOrig mod (mkOccNameFS tcName fs)
382 unitTyConName :: Name
383 unitTyConName = tyConName unitTyCon
386 primMethod :: TyCon -> String -> DsM (Maybe Var)
387 primMethod tycon method
388 | Just suffix <- lookupNameEnv prim_ty_cons (tyConName tycon)
390 $ dsLookupGlobalId =<< lookupOrig nDP_UNBOXED (mkVarOcc $ method ++ suffix)
392 | otherwise = return Nothing
394 primPArray :: TyCon -> DsM (Maybe TyCon)
396 | Just suffix <- lookupNameEnv prim_ty_cons (tyConName tycon)
398 $ dsLookupTyCon =<< lookupOrig nDP_UNBOXED (mkOccName tcName $ "PArray" ++ suffix)
400 | otherwise = return Nothing
402 prim_ty_cons :: NameEnv String
403 prim_ty_cons = mkNameEnv [mk_prim intPrimTyCon]
405 mk_prim tycon = (tyConName tycon, '_' : getOccString tycon)