X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=compiler%2Fvectorise%2FVectType.hs;h=e505cd32b59ffce665578bf952976271ba97dd5d;hb=d5b362581bd4f5443717a3dd11111d557c3e0291;hp=eb7ce6de03b7e2914a65a49cd18e12ed7722c22a;hpb=f03cf1b168c34d09766fda988921b8263e7e7300;p=ghc-hetmet.git diff --git a/compiler/vectorise/VectType.hs b/compiler/vectorise/VectType.hs index eb7ce6d..e505cd3 100644 --- a/compiler/vectorise/VectType.hs +++ b/compiler/vectorise/VectType.hs @@ -11,6 +11,7 @@ import VectCore import HscTypes ( TypeEnv, extendTypeEnvList, typeEnvTyCons ) import CoreSyn import CoreUtils +import BuildTyCl import DataCon import TyCon import Type @@ -25,7 +26,7 @@ import Var ( Var ) import Id ( mkWildId ) import Name ( Name, getOccName ) import NameEnv -import TysWiredIn ( intTy, intDataCon ) +import TysWiredIn ( unitTy, intTy, intDataCon, unitDataConId ) import TysPrim ( intPrimTy ) import Unique @@ -36,7 +37,7 @@ import Digraph ( SCC(..), stronglyConnComp ) import Outputable import Control.Monad ( liftM, liftM2, zipWithM, zipWithM_ ) -import Data.List ( inits, tails, zipWith4 ) +import Data.List ( inits, tails, zipWith4, zipWith5 ) -- ---------------------------------------------------------------------------- -- Types @@ -96,19 +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 dfuns <- mapM mkPADFun vect_tcs defTyConPAs (zip vect_tcs dfuns) - binds <- sequence (zipWith4 buildTyConBindings orig_tcs vect_tcs parr_tcs dfuns) - - let all_new_tcs = new_tcs ++ parr_tcs + 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, concat binds) + return (new_env, map mkLocalFamInst (repr_tcs ++ parr_tcs), concat binds) where tycons = typeEnvTyCons env groups = tyConGroups tycons @@ -135,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) @@ -171,72 +174,206 @@ 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 +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 + 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 + tyvars = tyConTyVars vect_tc + +buildPReprType :: TyCon -> VM Type +buildPReprType = liftM repr_type . mkTyConRepr + +buildToPRepr :: TyConRepr -> TyCon -> TyCon -> TyCon -> VM CoreExpr +buildToPRepr (TyConRepr { + repr_tys = repr_tys + , repr_prod_tycons = prod_tycons + , repr_prod_tys = prod_tys + , repr_sum_tycon = repr_sum_tycon + , repr_type = repr_type + }) + vect_tc prepr_tc _ + = do + arg <- newLocalVar FSLIT("x") arg_ty + vars <- mapM (mapM (newLocalVar FSLIT("x"))) repr_tys + + return . Lam arg + . wrapFamInstBody prepr_tc var_tys + . Case (Var arg) (mkWildId arg_ty) repr_type + . mk_alts data_cons vars + . zipWith3 mk_prod prod_tycons repr_tys $ map (map Var) vars + where + var_tys = mkTyVarTys $ tyConTyVars vect_tc + arg_ty = mkTyConApp vect_tc var_tys + data_cons = tyConDataCons vect_tc + + Just sum_tycon = repr_sum_tycon + sum_data_cons = tyConDataCons sum_tycon + + mk_alts _ _ [] = [(DEFAULT, [], Var unitDataConId)] + mk_alts [dc] [vars] [expr] = [(DataAlt dc, vars, expr)] + mk_alts dcs vars exprs = zipWith4 mk_alt dcs vars sum_data_cons exprs + + mk_alt dc vars sum_dc expr = (DataAlt dc, vars, + mkConApp sum_dc (map Type prod_tys ++ [expr])) + + mk_prod _ _ [] = Var unitDataConId + mk_prod _ _ [expr] = expr + mk_prod (Just tc) tys exprs = mkConApp dc (map Type tys ++ exprs) + where + [dc] = tyConDataCons tc + +buildFromPRepr :: TyConRepr -> TyCon -> TyCon -> TyCon -> VM CoreExpr +buildFromPRepr (TyConRepr { + repr_tys = repr_tys + , repr_prod_tycons = prod_tycons + , repr_prod_tys = prod_tys + , repr_sum_tycon = repr_sum_tycon + , repr_type = repr_type + }) + vect_tc prepr_tc _ + = do + arg_ty <- mkPReprType res_ty + arg <- newLocalVar FSLIT("x") arg_ty + + liftM (Lam arg + . un_sum (unwrapFamInstScrut prepr_tc var_tys (Var arg))) + (sequence $ zipWith4 un_prod data_cons prod_tycons prod_tys repr_tys) + where + var_tys = mkTyVarTys $ tyConTyVars vect_tc + ty_args = map Type var_tys + res_ty = mkTyConApp vect_tc var_tys + data_cons = tyConDataCons vect_tc + + Just sum_tc = repr_sum_tycon + sum_data_cons = tyConDataCons sum_tc + + un_prod dc _ _ [] + = do + var <- newLocalVar FSLIT("u") unitTy + return (var, mkConApp dc ty_args) + un_prod dc _ _ [ty] + = do + var <- newLocalVar FSLIT("x") ty + return (var, mkConApp dc (ty_args ++ [Var var])) + + un_prod dc (Just prod_tc) prod_ty tys + = do + vars <- mapM (newLocalVar FSLIT("x")) tys + pv <- newLocalVar FSLIT("p") prod_ty + + let res = mkConApp dc (ty_args ++ map Var vars) + expr = Case (Var pv) (mkWildId prod_ty) res_ty + [(DataAlt prod_dc, vars, res)] + + return (pv, expr) + where + [prod_dc] = tyConDataCons prod_tc + + + un_sum scrut [(var, expr)] = Let (NonRec var scrut) expr + un_sum scrut alts + = Case scrut (mkWildId repr_type) res_ty + $ zipWith mk_alt sum_data_cons alts + + mk_alt sum_dc (var, expr) = (DataAlt sum_dc, [var], expr) + + +buildToArrPRepr :: TyConRepr -> TyCon -> TyCon -> TyCon -> VM CoreExpr +buildToArrPRepr _ vect_tc prepr_tc arr_tc + = do + arg_ty <- mkPArrayType el_ty + rep_tys <- mapM (mapM mkPArrayType) rep_el_tys + + arg <- newLocalVar FSLIT("xs") arg_ty + bndrss <- mapM (mapM (newLocalVar FSLIT("ys"))) rep_tys + len <- newLocalVar FSLIT("len") intPrimTy + sel <- newLocalVar FSLIT("sel") =<< mkPArrayType intTy + + let add_sel xs | has_selector = sel : xs + | otherwise = xs + + all_bndrs = len : add_sel (concat bndrss) + + res <- parrayCoerce prepr_tc var_tys + =<< mkToArrPRepr (Var len) (Var sel) (map (map Var) bndrss) + res_ty <- mkPArrayType =<< mkPReprType el_ty + + return . Lam arg + $ Case (unwrapFamInstScrut arr_tc var_tys (Var arg)) + (mkWildId (mkTyConApp arr_tc var_tys)) + res_ty + [(DataAlt arr_dc, all_bndrs, res)] + where + var_tys = mkTyVarTys $ tyConTyVars vect_tc + el_ty = mkTyConApp vect_tc var_tys + data_cons = tyConDataCons vect_tc + rep_el_tys = map dataConRepArgTys data_cons + + [arr_dc] = tyConDataCons arr_tc + + has_selector | [_] <- data_cons = False + | otherwise = True + +buildFromArrPRepr :: TyConRepr -> TyCon -> TyCon -> TyCon -> VM CoreExpr +buildFromArrPRepr _ vect_tc prepr_tc arr_tc + = mkFromArrPRepr undefined undefined undefined undefined undefined undefined + +buildPRDict :: TyConRepr -> TyCon -> TyCon -> TyCon -> VM CoreExpr +buildPRDict _ vect_tc prepr_tc _ + = prCoerce prepr_tc var_tys + =<< prDictOfType (mkTyConApp prepr_tc var_tys) + where + var_tys = mkTyVarTys $ tyConTyVars vect_tc + 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 + 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 - 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 - = 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 - where - tyvars = tyConTyVars vect_tc - buildPArrayTyConRhs :: Name -> TyCon -> TyCon -> VM AlgTyConRhs buildPArrayTyConRhs orig_name vect_tc repr_tc = do @@ -249,24 +386,17 @@ buildPArrayDataCon orig_name vect_tc repr_tc 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 + + 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] @@ -304,15 +434,18 @@ tyConShape vect_tc return [e] } -buildTyConBindings :: TyCon -> TyCon -> TyCon -> Var -> VM [(Var, CoreExpr)] -buildTyConBindings orig_tc vect_tc arr_tc dfun +buildTyConBindings :: TyCon -> TyCon -> TyCon -> TyCon -> Var + -> VM [(Var, CoreExpr)] +buildTyConBindings orig_tc vect_tc prepr_tc arr_tc dfun = do shape <- tyConShape vect_tc - sequence_ (zipWith3 (vectDataConWorker shape vect_tc arr_tc arr_dc) - num_dcs + repr <- mkTyConRepr 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 arr_tc dfun + dict <- buildPADict repr vect_tc prepr_tc arr_tc dfun binds <- takeHoisted return $ (dfun, dict) : binds where @@ -320,13 +453,12 @@ buildTyConBindings orig_tc vect_tc arr_tc dfun vect_dcs = tyConDataCons vect_tc [arr_dc] = tyConDataCons arr_tc - num_dcs = zip3 orig_dcs vect_dcs [0..] repr_tys = map dataConRepArgTys vect_dcs vectDataConWorker :: Shape -> TyCon -> TyCon -> DataCon - -> (DataCon, DataCon, Int) -> [[Type]] -> [[Type]] + -> DataCon -> DataCon -> [[Type]] -> [[Type]] -> VM () -vectDataConWorker shape vect_tc arr_tc arr_dc (orig_dc, vect_dc, dc_num) pre (dc_tys : post) +vectDataConWorker shape vect_tc arr_tc arr_dc orig_dc vect_dc pre (dc_tys : post) = do clo <- closedV . inBind orig_worker @@ -350,7 +482,9 @@ vectDataConWorker shape vect_tc arr_tc arr_dc (orig_dc, vect_dc, dc_num) pre (dc 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) + shapes <- shapeReplicate shape + (Var len) + (mkDataConTag vect_dc) empty_pre <- mapM emptyPA (concat pre) empty_post <- mapM emptyPA (concat post) @@ -363,11 +497,11 @@ vectDataConWorker shape vect_tc arr_tc arr_dc (orig_dc, vect_dc, dc_num) pre (dc ++ map Var args ++ empty_post -buildPADict :: Shape -> TyCon -> TyCon -> Var -> VM CoreExpr -buildPADict shape vect_tc arr_tc dfun +buildPADict :: TyConRepr -> TyCon -> TyCon -> TyCon -> Var -> VM CoreExpr +buildPADict repr vect_tc prepr_tc arr_tc dfun = polyAbstract tvs $ \abstract -> do - meth_binds <- mapM (mk_method shape) paMethods + meth_binds <- mapM (mk_method repr) paMethods let meth_exprs = map (Var . fst) meth_binds pa_dc <- builtin paDataCon @@ -378,107 +512,18 @@ buildPADict shape vect_tc arr_tc dfun tvs = tyConTyVars arr_tc arg_tys = mkTyVarTys tvs - mk_method shape (name, build) + mk_method repr (name, build) = localV $ do - body <- build shape vect_tc arr_tc + body <- build repr vect_tc prepr_tc arr_tc var <- newLocalVar name (exprType body) return (var, mkInlineMe body) -paMethods = [(FSLIT("lengthPA"), buildLengthPA), - (FSLIT("replicatePA"), buildReplicatePA)] - -buildLengthPA :: Shape -> 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 - shapes <- mapM (newLocalVar FSLIT("sh")) shape_tys - wilds <- mapM newDummyVar repr_tys - let scrut = unwrapFamInstScrut arr_tc arg_tys (Var arg) - scrut_ty = exprType scrut - - body <- shapeLength shape (map Var shapes) - - return . Lam arg - $ Case scrut (mkWildId scrut_ty) intPrimTy - [(DataAlt repr_dc, shapes ++ wilds, body)] - where - arg_tys = mkTyVarTys $ tyConTyVars arr_tc - [repr_dc] = tyConDataCons arr_tc - - shape_tys = shapeReprTys shape - repr_tys = drop (length shape_tys) (dataConRepArgTys repr_dc) - --- data T = C0 t1 ... tm --- ... --- Ck u1 ... un --- --- data [:T:] = A ![:Int:] [:t1:] ... [:un:] --- --- replicatePA :: Int# -> T -> [:T:] --- replicatePA n# t --- = let c = case t of --- C0 _ ... _ -> 0 --- ... --- Ck _ ... _ -> k --- --- xs1 = case t of --- C0 x1 _ ... _ -> replicatePA @t1 n# x1 --- _ -> emptyPA @t1 --- --- ... --- --- ysn = case t of --- Ck _ ... _ yn -> replicatePA @un n# yn --- _ -> emptyPA @un --- in --- A (replicatePA @Int n# c) xs1 ... ysn --- --- - -buildReplicatePA :: Shape -> TyCon -> TyCon -> VM CoreExpr -buildReplicatePA shape vect_tc arr_tc - = do - len_var <- newLocalVar FSLIT("n") intPrimTy - val_var <- newLocalVar FSLIT("x") val_ty - - let len = Var len_var - val = Var val_var - - shape_reprs <- shapeReplicate shape len (ctr_num val) - reprs <- liftM concat $ mapM (mk_comp_arrs len val) vect_dcs - - return . mkLams [len_var, val_var] - . wrapFamInstBody arr_tc arg_tys - $ mkConApp arr_dc (map Type arg_tys ++ shape_reprs ++ reprs) - where - arg_tys = mkTyVarTys (tyConTyVars arr_tc) - val_ty = mkTyConApp vect_tc arg_tys - wild = mkWildId val_ty - vect_dcs = tyConDataCons vect_tc - [arr_dc] = tyConDataCons arr_tc - - ctr_num val = Case val wild intTy (zipWith ctr_num_alt vect_dcs [0..]) - ctr_num_alt dc i = (DataAlt dc, map mkWildId (dataConRepArgTys dc), - mkConApp intDataCon [mkIntLitInt i]) - - - mk_comp_arrs len val dc = let tys = dataConRepArgTys dc - wilds = map mkWildId tys - in - sequence (zipWith3 (mk_comp_arr len val dc) - tys (inits wilds) (tails wilds)) - - mk_comp_arr len val dc ty pre (_:post) - = do - var <- newLocalVar FSLIT("x") ty - rep <- replicatePA len (Var var) - empty <- emptyPA ty - arr_ty <- mkPArrayType ty - - return $ Case val wild arr_ty - [(DEFAULT, [], empty), (DataAlt dc, pre ++ (var : post), rep)] +paMethods = [(FSLIT("toPRepr"), buildToPRepr), + (FSLIT("fromPRepr"), buildFromPRepr), + (FSLIT("toArrPRepr"), buildToArrPRepr), + (FSLIT("fromArrPRepr"), buildFromArrPRepr), + (FSLIT("dictPRepr"), buildPRDict)] -- | Split the given tycons into two sets depending on whether they have to be -- converted (first list) or not (second list). The first argument contains