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 )
33 vectorise :: HscEnv -> ModGuts -> IO ModGuts
34 vectorise hsc_env guts
35 | not (Opt_Vectorise `dopt` dflags) = return guts
38 showPass dflags "Vectorisation"
40 let info = hptVectInfo hsc_env `plusVectInfo` eps_vect_info eps
41 Just (info', guts') <- initV hsc_env guts info (vectModule guts)
42 endPass dflags "Vectorisation" Opt_D_dump_vect (mg_binds guts')
43 return $ guts' { mg_vect_info = info' }
45 dflags = hsc_dflags hsc_env
47 vectModule :: ModGuts -> VM ModGuts
48 vectModule guts = return guts
50 -- ----------------------------------------------------------------------------
53 vectBndr :: Var -> VM (Var, Var)
56 vty <- vectType (idType v)
58 let vv = v `Id.setIdType` vty
59 lv = v `Id.setIdType` lty
63 mapTo vv lv env = env { local_vars = extendVarEnv (local_vars env) v (Var vv, Var lv) }
65 vectBndrIn :: Var -> VM a -> VM (Var, Var, a)
69 (vv, lv) <- vectBndr v
73 vectBndrsIn :: [Var] -> VM a -> VM ([Var], [Var], a)
77 (vvs, lvs) <- mapAndUnzipM vectBndr vs
81 -- ----------------------------------------------------------------------------
84 replicateP :: CoreExpr -> CoreExpr -> VM CoreExpr
88 rep <- builtin replicatePAVar
89 return $ mkApps (Var rep) [Type ty, pa, expr, len]
93 capply :: (CoreExpr, CoreExpr) -> (CoreExpr, CoreExpr) -> VM (CoreExpr, CoreExpr)
94 capply (vfn, lfn) (varg, larg)
96 apply <- builtin applyClosureVar
97 applyP <- builtin applyClosurePVar
98 return (mkApps (Var apply) [Type arg_ty, Type res_ty, vfn, varg],
99 mkApps (Var applyP) [Type arg_ty, Type res_ty, lfn, larg])
102 (arg_ty, res_ty) = splitClosureTy fn_ty
104 vectVar :: CoreExpr -> Var -> VM (CoreExpr, CoreExpr)
105 vectVar lc v = local v `orElseV` global v
107 local v = maybeV (readLEnv $ \env -> lookupVarEnv (local_vars env) v)
109 vexpr <- maybeV (readGEnv $ \env -> lookupVarEnv (global_vars env) v)
110 lexpr <- replicateP vexpr lc
111 return (vexpr, lexpr)
113 vectExpr :: CoreExpr -> CoreExprWithFVs -> VM (CoreExpr, CoreExpr)
114 vectExpr lc (_, AnnType ty)
117 return (Type vty, Type vty)
118 vectExpr lc (_, AnnVar v) = vectVar lc v
119 vectExpr lc (_, AnnLit lit)
122 lexpr <- replicateP vexpr lc
123 return (vexpr, lexpr)
124 vectExpr lc (_, AnnNote note expr)
126 (vexpr, lexpr) <- vectExpr lc expr
127 return (Note note vexpr, Note note lexpr)
128 vectExpr lc (_, AnnApp fn arg)
130 fn' <- vectExpr lc fn
131 arg' <- vectExpr lc arg
133 vectExpr lc (_, AnnCase expr bndr ty alts)
134 = panic "vectExpr: case"
135 vectExpr lc (_, AnnLet (AnnNonRec bndr rhs) body)
137 (vrhs, lrhs) <- vectExpr lc rhs
138 (vbndr, lbndr, (vbody, lbody)) <- vectBndrIn bndr (vectExpr lc body)
139 return (Let (NonRec vbndr vrhs) vbody,
140 Let (NonRec lbndr lrhs) lbody)
141 vectExpr lc (_, AnnLet (AnnRec prs) body)
143 (vbndrs, lbndrs, (vrhss, vbody, lrhss, lbody)) <- vectBndrsIn bndrs vect
144 return (Let (Rec (zip vbndrs vrhss)) vbody,
145 Let (Rec (zip lbndrs lrhss)) lbody)
147 (bndrs, rhss) = unzip prs
150 (vrhss, lrhss) <- mapAndUnzipM (vectExpr lc) rhss
151 (vbody, lbody) <- vectExpr lc body
152 return (vrhss, vbody, lrhss, lbody)
153 vectExpr lc (_, AnnLam bndr body)
156 r <- paDictArgType bndr
157 (upd_env, add_lam) <- get_upd r
158 (vbody, lbody) <- localV (upd_env >> vectExpr lc body)
159 return (Lam bndr (add_lam vbody), Lam bndr (add_lam lbody))
161 get_upd Nothing = return (deleteTyVarPA bndr, id)
162 get_upd (Just pa_ty) = do
163 pa_var <- newLocalVar FSLIT("dPA") pa_ty
164 return (extendTyVarPA bndr (Var pa_var),
167 -- ----------------------------------------------------------------------------
170 paOfTyCon :: TyCon -> VM CoreExpr
171 -- FIXME: just for now
172 paOfTyCon tc = maybeV (readGEnv $ \env -> lookupNameEnv (global_tycon_pa env) (tyConName tc))
174 paOfType :: Type -> VM CoreExpr
175 paOfType ty | Just ty' <- coreView ty = paOfType ty'
177 paOfType (TyVarTy tv) = maybeV (readLEnv $ \env -> lookupVarEnv (local_tyvar_pa env) tv)
178 paOfType (AppTy ty1 ty2)
182 return $ mkApps e1 [Type ty2, e2]
183 paOfType (TyConApp tc tys)
186 es <- mapM paOfType tys
187 return $ mkApps e [arg | (t,e) <- zip tys es, arg <- [Type t, e]]
188 paOfType (FunTy ty1 ty2) = paOfType (TyConApp funTyCon [ty1,ty2])
189 paOfType t@(ForAllTy tv ty) = pprPanic "paOfType:" (ppr t)
190 paOfType ty = pprPanic "paOfType:" (ppr ty)
194 -- ----------------------------------------------------------------------------
197 vectTyCon :: TyCon -> VM TyCon
199 | isFunTyCon tc = builtin closureTyCon
200 | isBoxedTupleTyCon tc = return tc
201 | isUnLiftedTyCon tc = return tc
205 Just tc' -> return tc'
207 -- FIXME: just for now
208 Nothing -> pprTrace "ccTyCon:" (ppr tc) $ return tc
210 vectType :: Type -> VM Type
211 vectType ty | Just ty' <- coreView ty = vectType ty
212 vectType (TyVarTy tv) = return $ TyVarTy tv
213 vectType (AppTy ty1 ty2) = liftM2 AppTy (vectType ty1) (vectType ty2)
214 vectType (TyConApp tc tys) = liftM2 TyConApp (vectTyCon tc) (mapM vectType tys)
215 vectType (FunTy ty1 ty2) = liftM2 TyConApp (builtin closureTyCon)
216 (mapM vectType [ty1,ty2])
217 vectType (ForAllTy tv ty)
219 r <- paDictArgType tv
221 return $ ForAllTy tv (wrap r ty')
224 wrap (Just pa_ty) = FunTy pa_ty
226 vectType ty = pprPanic "vectType:" (ppr ty)
228 isClosureTyCon :: TyCon -> Bool
229 isClosureTyCon tc = tyConUnique tc == closureTyConKey
231 splitClosureTy :: Type -> (Type, Type)
233 | Just (tc, [arg_ty, res_ty]) <- splitTyConApp_maybe ty
237 | otherwise = pprPanic "splitClosureTy" (ppr ty)
239 mkPArrayTy :: Type -> VM Type
241 tc <- builtin parrayTyCon
242 return $ TyConApp tc [ty]