1 module Vectorise( vectorise )
4 #include "HsVersions.h"
12 import CoreLint ( showPass, endPass )
21 import Name ( mkSysTvName )
25 import DsMonad hiding (mapAndUnzipM)
31 import Control.Monad ( liftM, liftM2, mapAndUnzipM, zipWithM_ )
32 import Data.Maybe ( maybeToList )
34 vectorise :: HscEnv -> ModGuts -> IO ModGuts
35 vectorise hsc_env guts
36 | not (Opt_Vectorise `dopt` dflags) = return guts
39 showPass dflags "Vectorisation"
41 let info = hptVectInfo hsc_env `plusVectInfo` eps_vect_info eps
42 Just (info', guts') <- initV hsc_env guts info (vectModule guts)
43 endPass dflags "Vectorisation" Opt_D_dump_vect (mg_binds guts')
44 return $ guts' { mg_vect_info = info' }
46 dflags = hsc_dflags hsc_env
48 vectModule :: ModGuts -> VM ModGuts
49 vectModule guts = return guts
51 -- ----------------------------------------------------------------------------
54 vectBndr :: Var -> VM (Var, Var)
57 vty <- vectType (idType v)
58 lty <- mkPArrayType vty
59 let vv = v `Id.setIdType` vty
60 lv = v `Id.setIdType` lty
64 mapTo vv lv env = env { local_vars = extendVarEnv (local_vars env) v (Var vv, Var lv) }
66 vectBndrIn :: Var -> VM a -> VM (Var, Var, a)
70 (vv, lv) <- vectBndr v
74 vectBndrsIn :: [Var] -> VM a -> VM ([Var], [Var], a)
78 (vvs, lvs) <- mapAndUnzipM vectBndr vs
82 -- ----------------------------------------------------------------------------
85 replicateP :: CoreExpr -> CoreExpr -> VM CoreExpr
88 dict <- paDictOfType ty
89 rep <- builtin replicatePAVar
90 return $ mkApps (Var rep) [Type ty, dict, expr, len]
94 capply :: (CoreExpr, CoreExpr) -> (CoreExpr, CoreExpr) -> VM (CoreExpr, CoreExpr)
95 capply (vfn, lfn) (varg, larg)
97 apply <- builtin applyClosureVar
98 applyP <- builtin applyClosurePVar
99 return (mkApps (Var apply) [Type arg_ty, Type res_ty, vfn, varg],
100 mkApps (Var applyP) [Type arg_ty, Type res_ty, lfn, larg])
103 (arg_ty, res_ty) = splitClosureTy fn_ty
105 vectVar :: CoreExpr -> Var -> VM (CoreExpr, CoreExpr)
106 vectVar lc v = local v `orElseV` global v
108 local v = maybeV (readLEnv $ \env -> lookupVarEnv (local_vars env) v)
110 vexpr <- maybeV (readGEnv $ \env -> lookupVarEnv (global_vars env) v)
111 lexpr <- replicateP vexpr lc
112 return (vexpr, lexpr)
114 vectPolyVar :: CoreExpr -> Var -> [Type] -> VM (CoreExpr, CoreExpr)
117 r <- readLEnv $ \env -> lookupVarEnv (local_vars env) v
119 Just (vexpr, lexpr) -> liftM2 (,) (mk_app vexpr) (mk_app lexpr)
122 poly <- maybeV (readGEnv $ \env -> lookupVarEnv (global_vars env) v)
124 lexpr <- replicateP vexpr lc
125 return (vexpr, lexpr)
127 mk_app e = applyToTypes e =<< mapM vectType tys
129 abstractOverTyVars :: [TyVar] -> ((CoreExpr -> CoreExpr) -> VM a) -> VM a
130 abstractOverTyVars tvs p
132 mdicts <- mapM mk_dict_var tvs
133 zipWithM_ (\tv -> maybe (deleteTyVarPA tv) (extendTyVarPA tv . Var)) tvs mdicts
137 r <- paDictArgType tv
139 Just ty -> liftM Just (newLocalVar FSLIT("dPA") ty)
140 Nothing -> return Nothing
142 mk_lams mdicts = mkLams [arg | (tv, mdict) <- zip tvs mdicts
143 , arg <- tv : maybeToList mdict]
145 applyToTypes :: CoreExpr -> [Type] -> VM CoreExpr
146 applyToTypes expr tys
148 dicts <- mapM paDictOfType tys
149 return $ mkApps expr [arg | (ty, dict) <- zip tys dicts
150 , arg <- [Type ty, dict]]
153 vectPolyExpr :: CoreExpr -> CoreExprWithFVs -> VM (CoreExpr, CoreExpr)
156 . abstractOverTyVars tvs $ \mk_lams ->
157 -- FIXME: shadowing (tvs in lc)
159 (vmono, lmono) <- vectExpr lc mono
160 return $ (mk_lams vmono, mk_lams lmono)
162 (tvs, mono) = collectAnnTypeBinders expr
164 vectExpr :: CoreExpr -> CoreExprWithFVs -> VM (CoreExpr, CoreExpr)
165 vectExpr lc (_, AnnType ty)
168 return (Type vty, Type vty)
170 vectExpr lc (_, AnnVar v) = vectVar lc v
172 vectExpr lc (_, AnnLit lit)
175 lexpr <- replicateP vexpr lc
176 return (vexpr, lexpr)
178 vectExpr lc (_, AnnNote note expr)
180 (vexpr, lexpr) <- vectExpr lc expr
181 return (Note note vexpr, Note note lexpr)
183 vectExpr lc e@(_, AnnApp _ arg)
185 = vectTyAppExpr lc fn tys
187 (fn, tys) = collectAnnTypeArgs e
189 vectExpr lc (_, AnnApp fn arg)
191 fn' <- vectExpr lc fn
192 arg' <- vectExpr lc arg
195 vectExpr lc (_, AnnCase expr bndr ty alts)
196 = panic "vectExpr: case"
198 vectExpr lc (_, AnnLet (AnnNonRec bndr rhs) body)
200 (vrhs, lrhs) <- vectPolyExpr lc rhs
201 (vbndr, lbndr, (vbody, lbody)) <- vectBndrIn bndr (vectExpr lc body)
202 return (Let (NonRec vbndr vrhs) vbody,
203 Let (NonRec lbndr lrhs) lbody)
205 vectExpr lc (_, AnnLet (AnnRec prs) body)
207 (vbndrs, lbndrs, (vrhss, vbody, lrhss, lbody)) <- vectBndrsIn bndrs vect
208 return (Let (Rec (zip vbndrs vrhss)) vbody,
209 Let (Rec (zip lbndrs lrhss)) lbody)
211 (bndrs, rhss) = unzip prs
214 (vrhss, lrhss) <- mapAndUnzipM (vectExpr lc) rhss
215 (vbody, lbody) <- vectPolyExpr lc body
216 return (vrhss, vbody, lrhss, lbody)
218 vectExpr lc e@(_, AnnLam bndr body)
219 | isTyVar bndr = pprPanic "vectExpr" (ppr $ deAnnotate e)
221 vectTyAppExpr :: CoreExpr -> CoreExprWithFVs -> [Type] -> VM (CoreExpr, CoreExpr)
222 vectTyAppExpr lc (_, AnnVar v) tys = vectPolyVar lc v tys
223 vectTyAppExpr lc e tys = pprPanic "vectTyAppExpr" (ppr $ deAnnotate e)
225 -- ----------------------------------------------------------------------------
228 vectTyCon :: TyCon -> VM TyCon
230 | isFunTyCon tc = builtin closureTyCon
231 | isBoxedTupleTyCon tc = return tc
232 | isUnLiftedTyCon tc = return tc
236 Just tc' -> return tc'
238 -- FIXME: just for now
239 Nothing -> pprTrace "ccTyCon:" (ppr tc) $ return tc
241 vectType :: Type -> VM Type
242 vectType ty | Just ty' <- coreView ty = vectType ty
243 vectType (TyVarTy tv) = return $ TyVarTy tv
244 vectType (AppTy ty1 ty2) = liftM2 AppTy (vectType ty1) (vectType ty2)
245 vectType (TyConApp tc tys) = liftM2 TyConApp (vectTyCon tc) (mapM vectType tys)
246 vectType (FunTy ty1 ty2) = liftM2 TyConApp (builtin closureTyCon)
247 (mapM vectType [ty1,ty2])
248 vectType (ForAllTy tv ty)
250 r <- paDictArgType tv
252 return $ ForAllTy tv (wrap r ty')
255 wrap (Just pa_ty) = FunTy pa_ty
257 vectType ty = pprPanic "vectType:" (ppr ty)