X-Git-Url: http://git.megacz.com/?p=ghc-hetmet.git;a=blobdiff_plain;f=compiler%2Fvectorise%2FVectType.hs;h=c77343b7e5b6ebc0b073ad84d3fb03b54edffdef;hp=2c38bcef5484b7d12eeebbd8ba700dbf0b2cf37d;hb=9396c0736a7e7d73c2a13f1a18104e0c43b924b0;hpb=fc21a2bcf35337942156d246f0c1c1b7072f3f91 diff --git a/compiler/vectorise/VectType.hs b/compiler/vectorise/VectType.hs index 2c38bce..c77343b 100644 --- a/compiler/vectorise/VectType.hs +++ b/compiler/vectorise/VectType.hs @@ -1,6 +1,5 @@ module VectType ( vectTyCon, vectType, vectTypeEnv, - PAInstance, painstInstance, buildPADict, - vectDataConWorkers ) + PAInstance, buildPADict ) where #include "HsVersions.h" @@ -12,6 +11,7 @@ import VectCore import HscTypes ( TypeEnv, extendTypeEnvList, typeEnvTyCons ) import CoreSyn import CoreUtils +import BuildTyCl import DataCon import TyCon import Type @@ -26,7 +26,7 @@ import Var ( Var ) import Id ( mkWildId ) import Name ( Name, getOccName ) import NameEnv -import TysWiredIn ( intTy, intDataCon ) +import TysWiredIn ( unitTy, intTy, intDataCon ) import TysPrim ( intPrimTy ) import Unique @@ -37,7 +37,7 @@ import Digraph ( SCC(..), stronglyConnComp ) import Outputable import Control.Monad ( liftM, liftM2, zipWithM, zipWithM_ ) -import Data.List ( inits, tails ) +import Data.List ( inits, tails, zipWith4, zipWith5 ) -- ---------------------------------------------------------------------------- -- Types @@ -78,13 +78,13 @@ vectType ty = pprPanic "vectType:" (ppr ty) type TyConGroup = ([TyCon], UniqSet TyCon) data PAInstance = PAInstance { - painstInstance :: Instance + painstDFun :: Var , painstOrigTyCon :: TyCon , painstVectTyCon :: TyCon , painstArrTyCon :: TyCon } -vectTypeEnv :: TypeEnv -> VM (TypeEnv, [FamInst], [PAInstance]) +vectTypeEnv :: TypeEnv -> VM (TypeEnv, [FamInst], [(Var, CoreExpr)]) vectTypeEnv env = do cs <- readGEnv $ mk_map . global_tycons @@ -97,17 +97,24 @@ vectTypeEnv env let orig_tcs = keep_tcs ++ conv_tcs vect_tcs = keep_tcs ++ new_tcs + repr_tcs <- zipWithM buildPReprTyCon orig_tcs vect_tcs parr_tcs <- zipWithM buildPArrayTyCon orig_tcs vect_tcs - pa_insts <- sequence $ zipWith3 buildPAInstance orig_tcs vect_tcs parr_tcs - - let all_new_tcs = new_tcs ++ parr_tcs + dfuns <- mapM mkPADFun vect_tcs + defTyConPAs (zip vect_tcs dfuns) + binds <- sequence (zipWith5 buildTyConBindings orig_tcs + vect_tcs + repr_tcs + parr_tcs + dfuns) + + let all_new_tcs = new_tcs ++ repr_tcs ++ parr_tcs let new_env = extendTypeEnvList env (map ATyCon all_new_tcs ++ [ADataCon dc | tc <- all_new_tcs , dc <- tyConDataCons tc]) - return (new_env, map mkLocalFamInst parr_tcs, pa_insts) + return (new_env, map mkLocalFamInst (repr_tcs ++ parr_tcs), concat binds) where tycons = typeEnvTyCons env groups = tyConGroups tycons @@ -134,19 +141,16 @@ vectTyConDecl tc name' <- cloneName mkVectTyConOcc name rhs' <- vectAlgTyConRhs (algTyConRhs tc) - return $ mkAlgTyCon name' - kind - tyvars - [] -- no stupid theta - rhs' - [] -- no selector ids - NoParentTyCon -- FIXME - rec_flag -- FIXME: is this ok? - False -- FIXME: no generics - False -- not GADT syntax + liftDs $ buildAlgTyCon name' + tyvars + [] -- no stupid theta + rhs' + rec_flag -- FIXME: is this ok? + False -- FIXME: no generics + False -- not GADT syntax + Nothing -- not a family instance where name = tyConName tc - kind = tyConKind tc tyvars = tyConTyVars tc rec_flag = boolToRecFlag (isRecursiveTyCon tc) @@ -170,89 +174,131 @@ vectDataCon dc name' <- cloneName mkVectDataConOcc name tycon' <- vectTyCon tycon arg_tys <- mapM vectType rep_arg_tys - wrk_name <- cloneName mkDataConWorkerOcc name' - - let ids = mkDataConIds (panic "vectDataCon: wrapper id") - wrk_name - data_con - data_con = mkDataCon name' - False -- not infix - (map (const NotMarkedStrict) arg_tys) - [] -- no labelled fields - univ_tvs - [] -- no existential tvs for now - [] -- no eq spec for now - [] -- no theta - arg_tys - tycon' - [] -- no stupid theta - ids - return data_con + + liftDs $ buildDataCon name' + False -- not infix + (map (const NotMarkedStrict) arg_tys) + [] -- no labelled fields + univ_tvs + [] -- no existential tvs for now + [] -- no eq spec for now + [] -- no context + arg_tys + tycon' where name = dataConName dc univ_tvs = dataConUnivTyVars dc rep_arg_tys = dataConRepArgTys dc tycon = dataConTyCon dc -vectDataConWorkers :: PAInstance -> VM [(Var, CoreExpr)] -vectDataConWorkers (PAInstance { painstOrigTyCon = orig_tc - , painstVectTyCon = vect_tc - , painstArrTyCon = arr_tc - }) +mk_fam_inst :: TyCon -> TyCon -> (TyCon, [Type]) +mk_fam_inst fam_tc arg_tc + = (fam_tc, [mkTyConApp arg_tc . mkTyVarTys $ tyConTyVars arg_tc]) + +buildPReprTyCon :: TyCon -> TyCon -> VM TyCon +buildPReprTyCon orig_tc vect_tc = do - shape <- tyConShape vect_tc - sequence_ (zipWith3 (vectDataConWorker shape vect_tc arr_tc arr_dc) - num_dcs - (inits repr_tys) - (tails repr_tys)) - takeHoisted + name <- cloneName mkPReprTyConOcc (tyConName orig_tc) + rhs_ty <- buildPReprType vect_tc + prepr_tc <- builtin preprTyCon + liftDs $ buildSynTyCon name + tyvars + (SynonymTyCon rhs_ty) + (Just $ mk_fam_inst prepr_tc vect_tc) where - orig_dcs = tyConDataCons orig_tc - vect_dcs = tyConDataCons vect_tc - [arr_dc] = tyConDataCons arr_tc + tyvars = tyConTyVars vect_tc - num_dcs = zip3 orig_dcs vect_dcs [0..] - repr_tys = map dataConRepArgTys vect_dcs +buildPReprType :: TyCon -> VM Type +buildPReprType = mkPRepr . map dataConRepArgTys . tyConDataCons -vectDataConWorker :: Shape -> TyCon -> TyCon -> DataCon - -> (DataCon, DataCon, Int) -> [[Type]] -> [[Type]] - -> VM () -vectDataConWorker shape vect_tc arr_tc arr_dc (orig_dc, vect_dc, dc_num) pre (dc_tys : post) +buildToPRepr :: Shape -> TyCon -> TyCon -> TyCon -> VM CoreExpr +buildToPRepr _ vect_tc prepr_tc _ = do - clo <- closedV - . inBind orig_worker - . polyAbstract tvs $ \abstract -> - liftM (abstract . vectorised) - $ buildClosures tvs [] dc_tys res_ty (liftM2 (,) mk_vect mk_lift) + arg <- newLocalVar FSLIT("x") arg_ty + bndrss <- mapM (mapM (newLocalVar FSLIT("x"))) rep_tys + (alt_bodies, res_ty) <- mkToPRepr $ map (map Var) bndrss - worker <- cloneId mkVectOcc orig_worker (exprType clo) - hoistBinding worker clo - defGlobalVar orig_worker worker - return () + return . Lam arg + . wrapFamInstBody prepr_tc var_tys + . Case (Var arg) (mkWildId arg_ty) res_ty + $ zipWith3 mk_alt data_cons bndrss alt_bodies where - tvs = tyConTyVars vect_tc - arg_tys = mkTyVarTys tvs - res_ty = mkTyConApp vect_tc arg_tys + var_tys = mkTyVarTys $ tyConTyVars vect_tc + arg_ty = mkTyConApp vect_tc var_tys + data_cons = tyConDataCons vect_tc + rep_tys = map dataConRepArgTys data_cons - orig_worker = dataConWorkId orig_dc + mk_alt data_con bndrs body = (DataAlt data_con, bndrs, body) - mk_vect = return . mkConApp vect_dc $ map Type arg_tys - mk_lift = do - len <- newLocalVar FSLIT("n") intPrimTy - arr_tys <- mapM mkPArrayType dc_tys - args <- mapM (newLocalVar FSLIT("xs")) arr_tys - shapes <- shapeReplicate shape (Var len) (mkIntLitInt dc_num) - - empty_pre <- mapM emptyPA (concat pre) - empty_post <- mapM emptyPA (concat post) +buildFromPRepr :: Shape -> TyCon -> TyCon -> TyCon -> VM CoreExpr +buildFromPRepr _ vect_tc prepr_tc _ + = do + arg_ty <- mkPReprType res_ty + arg <- newLocalVar FSLIT("x") arg_ty + alts <- mapM mk_alt data_cons + body <- mkFromPRepr (unwrapFamInstScrut prepr_tc var_tys (Var arg)) + res_ty alts + return $ Lam arg body + where + var_tys = mkTyVarTys $ tyConTyVars vect_tc + res_ty = mkTyConApp vect_tc var_tys + data_cons = tyConDataCons vect_tc - return . mkLams (len : args) - . wrapFamInstBody arr_tc arg_tys - . mkConApp arr_dc - $ map Type arg_tys ++ shapes - ++ empty_pre - ++ map Var args - ++ empty_post + mk_alt dc = do + bndrs <- mapM (newLocalVar FSLIT("x")) $ dataConRepArgTys dc + return (bndrs, mkConApp dc (map Type var_tys ++ map Var bndrs)) + +buildPArrayTyCon :: TyCon -> TyCon -> VM TyCon +buildPArrayTyCon orig_tc vect_tc = fixV $ \repr_tc -> + do + name' <- cloneName mkPArrayTyConOcc orig_name + rhs <- buildPArrayTyConRhs orig_name vect_tc repr_tc + parray <- builtin parrayTyCon + + liftDs $ buildAlgTyCon name' + tyvars + [] -- no stupid theta + rhs + rec_flag -- FIXME: is this ok? + False -- FIXME: no generics + False -- not GADT syntax + (Just $ mk_fam_inst parray vect_tc) + where + orig_name = tyConName orig_tc + tyvars = tyConTyVars vect_tc + rec_flag = boolToRecFlag (isRecursiveTyCon vect_tc) + + +buildPArrayTyConRhs :: Name -> TyCon -> TyCon -> VM AlgTyConRhs +buildPArrayTyConRhs orig_name vect_tc repr_tc + = do + data_con <- buildPArrayDataCon orig_name vect_tc repr_tc + return $ DataTyCon { data_cons = [data_con], is_enum = False } + +buildPArrayDataCon :: Name -> TyCon -> TyCon -> VM DataCon +buildPArrayDataCon orig_name vect_tc repr_tc + = do + dc_name <- cloneName mkPArrayDataConOcc orig_name + shape <- tyConShape vect_tc + repr_tys <- mapM mkPArrayType types + + liftDs $ buildDataCon dc_name + False -- not infix + (shapeStrictness shape ++ map (const NotMarkedStrict) repr_tys) + [] -- no field labels + (tyConTyVars vect_tc) + [] -- no existentials + [] -- no eq spec + [] -- no context + (shapeReprTys shape ++ repr_tys) + repr_tc + where + types = [ty | dc <- tyConDataCons vect_tc + , ty <- dataConRepArgTys dc] + +mkPADFun :: TyCon -> VM Var +mkPADFun vect_tc + = newExportedVar (mkPADFunOcc $ getOccName vect_tc) =<< paDFunType vect_tc data Shape = Shape { shapeReprTys :: [Type] @@ -282,118 +328,80 @@ tyConShape vect_tc e <- replicatePA len n return [e] } - -buildPArrayTyCon :: TyCon -> TyCon -> VM TyCon -buildPArrayTyCon orig_tc vect_tc = fixV $ \repr_tc -> - do - name' <- cloneName mkPArrayTyConOcc orig_name - parent <- buildPArrayParentInfo orig_name vect_tc repr_tc - rhs <- buildPArrayTyConRhs orig_name vect_tc repr_tc - - return $ mkAlgTyCon name' - kind - tyvars - [] -- no stupid theta - rhs - [] -- no selector ids - parent - rec_flag -- FIXME: is this ok? - False -- FIXME: no generics - False -- not GADT syntax - where - orig_name = tyConName orig_tc - name = tyConName vect_tc - kind = tyConKind vect_tc - tyvars = tyConTyVars vect_tc - rec_flag = boolToRecFlag (isRecursiveTyCon vect_tc) - -buildPArrayParentInfo :: Name -> TyCon -> TyCon -> VM TyConParent -buildPArrayParentInfo orig_name vect_tc repr_tc +buildTyConBindings :: TyCon -> TyCon -> TyCon -> TyCon -> Var + -> VM [(Var, CoreExpr)] +buildTyConBindings orig_tc vect_tc prepr_tc arr_tc dfun = do - parray_tc <- builtin parrayTyCon - co_name <- cloneName mkInstTyCoOcc (tyConName repr_tc) - - let inst_tys = [mkTyConApp vect_tc (map mkTyVarTy tyvars)] - - return . FamilyTyCon parray_tc inst_tys - $ mkFamInstCoercion co_name - tyvars - parray_tc - inst_tys - repr_tc + shape <- tyConShape vect_tc + sequence_ (zipWith4 (vectDataConWorker shape vect_tc arr_tc arr_dc) + orig_dcs + vect_dcs + (inits repr_tys) + (tails repr_tys)) + dict <- buildPADict shape vect_tc prepr_tc arr_tc dfun + binds <- takeHoisted + return $ (dfun, dict) : binds where - tyvars = tyConTyVars vect_tc + orig_dcs = tyConDataCons orig_tc + vect_dcs = tyConDataCons vect_tc + [arr_dc] = tyConDataCons arr_tc -buildPArrayTyConRhs :: Name -> TyCon -> TyCon -> VM AlgTyConRhs -buildPArrayTyConRhs orig_name vect_tc repr_tc - = do - data_con <- buildPArrayDataCon orig_name vect_tc repr_tc - return $ DataTyCon { data_cons = [data_con], is_enum = False } + repr_tys = map dataConRepArgTys vect_dcs -buildPArrayDataCon :: Name -> TyCon -> TyCon -> VM DataCon -buildPArrayDataCon orig_name vect_tc repr_tc +vectDataConWorker :: Shape -> TyCon -> TyCon -> DataCon + -> DataCon -> DataCon -> [[Type]] -> [[Type]] + -> VM () +vectDataConWorker shape vect_tc arr_tc arr_dc orig_dc vect_dc pre (dc_tys : post) = do - dc_name <- cloneName mkPArrayDataConOcc orig_name - shape <- tyConShape vect_tc - repr_tys <- mapM mkPArrayType types - wrk_name <- cloneName mkDataConWorkerOcc dc_name - wrp_name <- cloneName mkDataConWrapperOcc dc_name - - let ids = mkDataConIds wrp_name wrk_name data_con - data_con = mkDataCon dc_name - False - (shapeStrictness shape ++ map (const NotMarkedStrict) repr_tys) - [] - (tyConTyVars vect_tc) - [] - [] - [] - (shapeReprTys shape ++ repr_tys) - repr_tc - [] - ids - - return data_con - where - types = [ty | dc <- tyConDataCons vect_tc - , ty <- dataConRepArgTys dc] + clo <- closedV + . inBind orig_worker + . polyAbstract tvs $ \abstract -> + liftM (abstract . vectorised) + $ buildClosures tvs [] dc_tys res_ty (liftM2 (,) mk_vect mk_lift) -buildPAInstance :: TyCon -> TyCon -> TyCon -> VM PAInstance -buildPAInstance orig_tc vect_tc arr_tc - = do - pa <- builtin paClass - let inst_ty = mkForAllTys tvs - . (mkFunTys $ mkPredTys [ClassP pa [ty] | ty <- arg_tys]) - $ mkPredTy (ClassP pa [mkTyConApp vect_tc arg_tys]) - - dfun <- newExportedVar (mkPADFunOcc $ getOccName vect_tc) inst_ty - - return $ PAInstance { - painstInstance = mkLocalInstance dfun NoOverlap - , painstOrigTyCon = orig_tc - , painstVectTyCon = vect_tc - , painstArrTyCon = arr_tc - } + worker <- cloneId mkVectOcc orig_worker (exprType clo) + hoistBinding worker clo + defGlobalVar orig_worker worker + return () where - tvs = tyConTyVars arr_tc + tvs = tyConTyVars vect_tc arg_tys = mkTyVarTys tvs + res_ty = mkTyConApp vect_tc arg_tys + + orig_worker = dataConWorkId orig_dc -buildPADict :: PAInstance -> VM [(Var, CoreExpr)] -buildPADict (PAInstance { - painstInstance = inst - , painstVectTyCon = vect_tc - , painstArrTyCon = arr_tc }) - = polyAbstract (tyConTyVars arr_tc) $ \abstract -> + mk_vect = return . mkConApp vect_dc $ map Type arg_tys + mk_lift = do + len <- newLocalVar FSLIT("n") intPrimTy + arr_tys <- mapM mkPArrayType dc_tys + args <- mapM (newLocalVar FSLIT("xs")) arr_tys + shapes <- shapeReplicate shape + (Var len) + (mkDataConTag vect_dc) + + empty_pre <- mapM emptyPA (concat pre) + empty_post <- mapM emptyPA (concat post) + + return . mkLams (len : args) + . wrapFamInstBody arr_tc arg_tys + . mkConApp arr_dc + $ map Type arg_tys ++ shapes + ++ empty_pre + ++ map Var args + ++ empty_post + +buildPADict :: Shape -> TyCon -> TyCon -> TyCon -> Var -> VM CoreExpr +buildPADict shape vect_tc prepr_tc arr_tc dfun + = polyAbstract tvs $ \abstract -> do - shape <- tyConShape vect_tc meth_binds <- mapM (mk_method shape) paMethods let meth_exprs = map (Var . fst) meth_binds - pa_dc <- builtin paDictDataCon + pa_dc <- builtin paDataCon let dict = mkConApp pa_dc (Type (mkTyConApp vect_tc arg_tys) : meth_exprs) body = Let (Rec meth_binds) dict - return [(instanceDFunId inst, mkInlineMe $ abstract body)] + return . mkInlineMe $ abstract body where tvs = tyConTyVars arr_tc arg_tys = mkTyVarTys tvs @@ -401,15 +409,17 @@ buildPADict (PAInstance { mk_method shape (name, build) = localV $ do - body <- build shape vect_tc arr_tc + body <- build shape vect_tc prepr_tc arr_tc var <- newLocalVar name (exprType body) return (var, mkInlineMe body) paMethods = [(FSLIT("lengthPA"), buildLengthPA), - (FSLIT("replicatePA"), buildReplicatePA)] + (FSLIT("replicatePA"), buildReplicatePA), + (FSLIT("toPRepr"), buildToPRepr), + (FSLIT("fromPRepr"), buildFromPRepr)] -buildLengthPA :: Shape -> TyCon -> TyCon -> VM CoreExpr -buildLengthPA shape vect_tc arr_tc +buildLengthPA :: Shape -> TyCon -> TyCon -> TyCon -> VM CoreExpr +buildLengthPA shape vect_tc _ arr_tc = do parr_ty <- mkPArrayType (mkTyConApp vect_tc arg_tys) arg <- newLocalVar FSLIT("xs") parr_ty @@ -457,8 +467,8 @@ buildLengthPA shape vect_tc arr_tc -- -- -buildReplicatePA :: Shape -> TyCon -> TyCon -> VM CoreExpr -buildReplicatePA shape vect_tc arr_tc +buildReplicatePA :: Shape -> TyCon -> TyCon -> TyCon -> VM CoreExpr +buildReplicatePA shape vect_tc _ arr_tc = do len_var <- newLocalVar FSLIT("n") intPrimTy val_var <- newLocalVar FSLIT("x") val_ty