import DataCon
import TyCon
import Type
+import FamInstEnv ( extendFamInstEnvList )
+import InstEnv ( extendInstEnvList )
import Var
import VarEnv
import VarSet
import Outputable
import FastString
-import Control.Monad ( liftM, liftM2, mapAndUnzipM, zipWithM_ )
+import Control.Monad ( liftM, liftM2, mapAndUnzipM )
vectorise :: HscEnv -> UniqSupply -> RuleBase -> ModGuts
-> IO (SimplCount, ModGuts)
vectModule :: ModGuts -> VM ModGuts
vectModule guts
= do
- types' <- vectTypeEnv (mg_types guts)
+ (types', fam_insts, pa_insts) <- vectTypeEnv (mg_types guts)
+
+ let insts = map painstInstance pa_insts
+ fam_inst_env' = extendFamInstEnvList (mg_fam_inst_env guts) fam_insts
+ inst_env' = extendInstEnvList (mg_inst_env guts) insts
+ updGEnv (setInstEnvs inst_env' fam_inst_env')
+
+ dicts <- mapM buildPADict pa_insts
binds' <- mapM vectTopBind (mg_binds guts)
- return $ guts { mg_types = types'
- , mg_binds = binds' }
+ return $ guts { mg_types = types'
+ , mg_binds = Rec (concat dicts) : binds'
+ , mg_inst_env = inst_env'
+ , mg_fam_inst_env = fam_inst_env'
+ , mg_insts = mg_insts guts ++ insts
+ , mg_fam_insts = mg_fam_insts guts ++ fam_insts
+ }
vectTopBind :: CoreBind -> VM CoreBind
vectTopBind b@(NonRec var expr)
-- ----------------------------------------------------------------------------
-- Expressions
-replicateP :: CoreExpr -> CoreExpr -> VM CoreExpr
-replicateP expr len
- = do
- dict <- paDictOfType ty
- rep <- builtin replicatePAVar
- return $ mkApps (Var rep) [Type ty, dict, expr, len]
- where
- ty = exprType expr
-
capply :: (CoreExpr, CoreExpr) -> (CoreExpr, CoreExpr) -> VM (CoreExpr, CoreExpr)
capply (vfn, lfn) (varg, larg)
= do
case r of
Local es -> return es
Global vexpr -> do
- lexpr <- replicateP vexpr lc
+ lexpr <- replicatePA vexpr lc
return (vexpr, lexpr)
vectPolyVar :: CoreExpr -> Var -> [Type] -> VM (CoreExpr, CoreExpr)
Local (vexpr, lexpr) -> liftM2 (,) (mk_app vexpr) (mk_app lexpr)
Global poly -> do
vexpr <- mk_app poly
- lexpr <- replicateP vexpr lc
+ lexpr <- replicatePA vexpr lc
return (vexpr, lexpr)
where
mk_app e = applyToTypes e =<< mapM vectType tys
-abstractOverTyVars :: [TyVar] -> ((CoreExpr -> CoreExpr) -> VM a) -> VM a
-abstractOverTyVars tvs p
- = do
- mdicts <- mapM mk_dict_var tvs
- zipWithM_ (\tv -> maybe (defLocalTyVar tv) (defLocalTyVarWithPA tv . Var)) tvs mdicts
- p (mk_lams mdicts)
- where
- mk_dict_var tv = do
- r <- paDictArgType tv
- case r of
- Just ty -> liftM Just (newLocalVar FSLIT("dPA") ty)
- Nothing -> return Nothing
-
- mk_lams mdicts = mkLams (tvs ++ [dict | Just dict <- mdicts])
-
-applyToTypes :: CoreExpr -> [Type] -> VM CoreExpr
-applyToTypes expr tys
- = do
- dicts <- mapM paDictOfType tys
- return $ expr `mkTyApps` tys `mkApps` dicts
-
vectPolyExpr :: CoreExpr -> CoreExprWithFVs -> VM (CoreExpr, CoreExpr)
vectPolyExpr lc expr
= localV
vectExpr lc (_, AnnLit lit)
= do
let vexpr = Lit lit
- lexpr <- replicateP vexpr lc
+ lexpr <- replicatePA vexpr lc
return (vexpr, lexpr)
vectExpr lc (_, AnnNote note expr)
bind_lenv lenv lbody lc_bndr [lbndr]
= do
- lengthPA <- builtin lengthPAVar
- pa_dict <- paDictOfType vty
+ len <- lengthPA (Var lbndr)
return . Let (NonRec lbndr lenv)
- $ Case (mkApps (Var lengthPA) [Type vty, pa_dict, (Var lbndr)])
+ $ Case len
lc_bndr
(exprType lbody)
[(DEFAULT, [], lbody)]