X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;ds=sidebyside;f=compiler%2Fvectorise%2FVectType.hs;h=c977e4c7dee18b5c5f7f698368bd50f5bec6b90b;hb=eaaecbaefe18da05d618942c51286cacfa1be2af;hp=08a8067561d40040c0141b6849eb38a1071ada59;hpb=020f85464387244a063acad967e88132ba715982;p=ghc-hetmet.git diff --git a/compiler/vectorise/VectType.hs b/compiler/vectorise/VectType.hs index 08a8067..c977e4c 100644 --- a/compiler/vectorise/VectType.hs +++ b/compiler/vectorise/VectType.hs @@ -1,27 +1,32 @@ -module VectType ( vectTyCon, vectType, vectTypeEnv ) +module VectType ( vectTyCon, vectType, vectTypeEnv, + PAInstance, buildPADict ) where #include "HsVersions.h" import VectMonad import VectUtils +import VectCore import HscTypes ( TypeEnv, extendTypeEnvList, typeEnvTyCons ) import CoreSyn +import CoreUtils +import BuildTyCl import DataCon import TyCon import Type import TypeRep import Coercion import FamInstEnv ( FamInst, mkLocalFamInst ) -import InstEnv ( Instance ) +import InstEnv ( Instance, mkLocalInstance, instanceDFunId ) import OccName import MkId -import BasicTypes ( StrictnessMark(..), boolToRecFlag ) +import BasicTypes ( StrictnessMark(..), OverlapFlag(..), boolToRecFlag ) +import Var ( Var ) import Id ( mkWildId ) -import Name ( Name ) +import Name ( Name, getOccName ) import NameEnv -import TysWiredIn ( intTy, intDataCon ) +import TysWiredIn ( unitTy, unitTyCon, intTy, intDataCon, unitDataConId ) import TysPrim ( intPrimTy ) import Unique @@ -32,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 @@ -72,7 +77,14 @@ vectType ty = pprPanic "vectType:" (ppr ty) type TyConGroup = ([TyCon], UniqSet TyCon) -vectTypeEnv :: TypeEnv -> VM (TypeEnv, [FamInst], [Instance]) +data PAInstance = PAInstance { + painstDFun :: Var + , painstOrigTyCon :: TyCon + , painstVectTyCon :: TyCon + , painstArrTyCon :: TyCon + } + +vectTypeEnv :: TypeEnv -> VM (TypeEnv, [FamInst], [(Var, CoreExpr)]) vectTypeEnv env = do cs <- readGEnv $ mk_map . global_tycons @@ -80,17 +92,29 @@ vectTypeEnv env keep_dcs = concatMap tyConDataCons keep_tcs zipWithM_ defTyCon keep_tcs keep_tcs zipWithM_ defDataCon keep_dcs keep_dcs - vect_tcs <- vectTyConDecls conv_tcs - parr_tcs1 <- zipWithM buildPArrayTyCon keep_tcs keep_tcs - parr_tcs2 <- zipWithM buildPArrayTyCon conv_tcs vect_tcs - let new_tcs = vect_tcs ++ parr_tcs1 ++ parr_tcs2 + new_tcs <- vectTyConDecls conv_tcs + + 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 (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 new_tcs - ++ [ADataCon dc | tc <- new_tcs + (map ATyCon all_new_tcs + ++ [ADataCon dc | tc <- all_new_tcs , dc <- tyConDataCons tc]) - return (new_env, map mkLocalFamInst (parr_tcs1 ++ parr_tcs2), []) + return (new_env, map mkLocalFamInst (repr_tcs ++ parr_tcs), concat binds) where tycons = typeEnvTyCons env groups = tyConGroups tycons @@ -117,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) @@ -153,188 +174,620 @@ 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 -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 +mk_fam_inst :: TyCon -> TyCon -> (TyCon, [Type]) +mk_fam_inst fam_tc arg_tc + = (fam_tc, [mkTyConApp arg_tc . mkTyVarTys $ tyConTyVars arg_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 +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 - 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 +data TyConRepr = ProdRepr { + repr_prod_arg_tys :: [Type] + , repr_prod_tycon :: TyCon + , repr_prod_data_con :: DataCon + , repr_prod_arr_tycon :: TyCon + , repr_prod_arr_data_con :: DataCon + , repr_type :: Type + } + | SumRepr { + repr_tys :: [[Type]] + , repr_prod_tycons :: [Maybe TyCon] + , repr_prod_data_cons :: [Maybe DataCon] + , repr_prod_tys :: [Type] + , repr_sum_tycon :: TyCon + , repr_type :: Type + } + +arrShapeTys :: TyConRepr -> VM [Type] +arrShapeTys (ProdRepr {}) = return [intPrimTy] +arrShapeTys (SumRepr {}) = do - parray_tc <- builtin parrayTyCon - co_name <- cloneName mkInstTyCoOcc (tyConName repr_tc) + uarr <- builtin uarrTyCon + return [intPrimTy, mkTyConApp uarr [intTy]] + +arrReprTys :: TyConRepr -> VM [Type] +arrReprTys (ProdRepr { repr_prod_arg_tys = tys }) + = mapM mkPArrayType tys +arrReprTys (SumRepr { repr_tys = tys }) + = concat `liftM` mapM (mapM mkPArrayType) (map mk_prod tys) + where + mk_prod [] = [unitTy] + mk_prod tys = tys + - let inst_tys = [mkTyConApp vect_tc (map mkTyVarTy tyvars)] +mkTyConRepr :: TyCon -> VM TyConRepr +mkTyConRepr vect_tc + | is_product + = let + [prod_arg_tys] = repr_tys + arity = length prod_arg_tys + in + do + prod_tycon <- builtin (prodTyCon arity) + let [prod_data_con] = tyConDataCons prod_tycon + + (arr_tycon, _) <- parrayReprTyCon + . mkTyConApp prod_tycon + $ replicate arity unitTy + + let [arr_data_con] = tyConDataCons arr_tycon + + return $ ProdRepr { + repr_prod_arg_tys = prod_arg_tys + , repr_prod_tycon = prod_tycon + , repr_prod_data_con = prod_data_con + , repr_prod_arr_tycon = arr_tycon + , repr_prod_arr_data_con = arr_data_con + , repr_type = mkTyConApp prod_tycon prod_arg_tys + } - return . FamilyTyCon parray_tc inst_tys - $ mkFamInstCoercion co_name - tyvars - parray_tc - inst_tys - repr_tc + | otherwise + = do + uarr <- builtin uarrTyCon + prod_tycons <- mapM (mk_tycon prodTyCon) repr_tys + let prod_tys = zipWith mk_tc_app_maybe prod_tycons repr_tys + sum_tycon <- builtin (sumTyCon $ length repr_tys) + arr_repr_tys <- mapM (mapM mkPArrayType . arr_repr_elem_tys) repr_tys + + return $ SumRepr { + repr_tys = repr_tys + , repr_prod_tycons = prod_tycons + , repr_prod_data_cons = map (fmap mk_single_datacon) prod_tycons + , repr_prod_tys = prod_tys + , repr_sum_tycon = sum_tycon + , repr_type = mkTyConApp sum_tycon prod_tys + } where - tyvars = tyConTyVars vect_tc + tyvars = tyConTyVars vect_tc + data_cons = tyConDataCons vect_tc + repr_tys = map dataConRepArgTys data_cons -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 } + is_product | [_] <- data_cons = True + | otherwise = False -buildPArrayDataCon :: Name -> TyCon -> TyCon -> VM DataCon -buildPArrayDataCon orig_name vect_tc repr_tc + mk_shape uarr = intPrimTy : mk_sel uarr + + mk_sel uarr | is_product = [] + | otherwise = [uarr_int, uarr_int] + where + uarr_int = mkTyConApp uarr [intTy] + + mk_tycon get_tc tys + | n > 1 = builtin (Just . get_tc n) + | otherwise = return Nothing + where n = length tys + + mk_single_datacon tc | [dc] <- tyConDataCons tc = dc + + mk_tc_app_maybe Nothing [] = unitTy + mk_tc_app_maybe Nothing [ty] = ty + mk_tc_app_maybe (Just tc) tys = mkTyConApp tc tys + + arr_repr_elem_tys [] = [unitTy] + arr_repr_elem_tys tys = tys + +buildPReprType :: TyCon -> VM Type +buildPReprType = liftM repr_type . mkTyConRepr + +buildToPRepr :: TyConRepr -> TyCon -> TyCon -> TyCon -> VM CoreExpr +buildToPRepr (ProdRepr { + repr_prod_arg_tys = prod_arg_tys + , repr_prod_data_con = prod_data_con + , repr_type = repr_type + }) + vect_tc prepr_tc _ = do - dc_name <- cloneName mkPArrayDataConOcc orig_name - shape_ty <- mkPArrayType intTy -- FIXME: we want to unbox this! - 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 - (MarkedStrict : map (const NotMarkedStrict) repr_tys) - [] - (tyConTyVars vect_tc) - [] - [] - [] - (shape_ty : repr_tys) - repr_tc - [] - ids - - return data_con + arg <- newLocalVar FSLIT("x") arg_ty + vars <- mapM (newLocalVar FSLIT("x")) prod_arg_tys + + return . Lam arg + . wrapFamInstBody prepr_tc var_tys + $ Case (Var arg) (mkWildId arg_ty) repr_type + [(DataAlt data_con, vars, + mkConApp prod_data_con (map Type prod_arg_tys ++ map Var vars))] where - types = [ty | dc <- tyConDataCons vect_tc - , ty <- dataConRepArgTys dc] + var_tys = mkTyVarTys $ tyConTyVars vect_tc + arg_ty = mkTyConApp vect_tc var_tys + [data_con] = tyConDataCons vect_tc + +buildToPRepr (SumRepr { + repr_tys = repr_tys + , repr_prod_data_cons = prod_data_cons + , repr_prod_tys = prod_tys + , repr_sum_tycon = 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 -buildLengthPA :: TyCon -> VM CoreExpr -buildLengthPA repr_tc + return . Lam arg + . wrapFamInstBody prepr_tc var_tys + . Case (Var arg) (mkWildId arg_ty) repr_type + . zipWith4 mk_alt data_cons vars sum_data_cons + . zipWith3 mk_prod prod_data_cons 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 + + sum_data_cons = tyConDataCons sum_tycon + + 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 dc) tys exprs = mkConApp dc (map Type tys ++ exprs) + +buildFromPRepr :: TyConRepr -> TyCon -> TyCon -> TyCon -> VM CoreExpr +buildFromPRepr (ProdRepr { + repr_prod_arg_tys = prod_arg_tys + , repr_prod_data_con = prod_data_con + , repr_type = repr_type + }) + vect_tc prepr_tc _ = do - arg <- newLocalVar FSLIT("xs") arg_ty - shape <- newLocalVar FSLIT("sel") shape_ty - body <- lengthPA (Var shape) + arg_ty <- mkPReprType res_ty + arg <- newLocalVar FSLIT("x") arg_ty + vars <- mapM (newLocalVar FSLIT("x")) prod_arg_tys + return . Lam arg - $ Case (Var arg) (mkWildId arg_ty) intPrimTy - [(DataAlt repr_dc, shape : map mkWildId repr_tys, body)] + $ Case (unwrapFamInstScrut prepr_tc var_tys (Var arg)) + (mkWildId repr_type) + res_ty + [(DataAlt prod_data_con, vars, + mkConApp data_con (map Type var_tys ++ map Var vars))] + where + var_tys = mkTyVarTys $ tyConTyVars vect_tc + ty_args = map Type var_tys + res_ty = mkTyConApp vect_tc var_tys + [data_con] = tyConDataCons vect_tc + +buildFromPRepr (SumRepr { + repr_tys = repr_tys + , repr_prod_data_cons = prod_data_cons + , repr_prod_tys = prod_tys + , repr_sum_tycon = 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 + . Case (unwrapFamInstScrut prepr_tc var_tys (Var arg)) + (mkWildId repr_type) + res_ty + . zipWith mk_alt sum_data_cons) + (sequence + $ zipWith4 un_prod data_cons prod_data_cons prod_tys repr_tys) where - arg_ty = mkTyConApp repr_tc . mkTyVarTys $ tyConTyVars repr_tc - [repr_dc] = tyConDataCons repr_tc - shape_ty : repr_tys = dataConRepArgTys repr_dc + var_tys = mkTyVarTys $ tyConTyVars vect_tc + ty_args = map Type var_tys + res_ty = mkTyConApp vect_tc var_tys + data_cons = tyConDataCons vect_tc + sum_data_cons = tyConDataCons sum_tycon --- 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 --- --- + 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])) -buildReplicatePA :: TyCon -> TyCon -> VM CoreExpr -buildReplicatePA vect_tc arr_tc - = do - len_var <- newLocalVar FSLIT("n") intPrimTy - val_var <- newLocalVar FSLIT("x") val_ty + un_prod dc (Just prod_dc) 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) - let len = Var len_var - val = Var val_var + mk_alt sum_dc (var, expr) = (DataAlt sum_dc, [var], expr) - shape <- replicatePA len (ctr_num val) - reprs <- liftM concat $ mapM (mk_comp_arrs len val) vect_dcs + +buildToArrPRepr :: TyConRepr -> TyCon -> TyCon -> TyCon -> VM CoreExpr +buildToArrPRepr repr@(ProdRepr { + repr_prod_arg_tys = prod_arg_tys + , repr_prod_arr_tycon = prod_arr_tycon + , repr_prod_arr_data_con = prod_arr_data_con + , repr_type = repr_type + }) + vect_tc prepr_tc arr_tc + = do + arg_ty <- mkPArrayType el_ty + shape_tys <- arrShapeTys repr + arr_tys <- arrReprTys repr + res_ty <- mkPArrayType repr_type + rep_el_ty <- mkPReprType el_ty + + arg <- newLocalVar FSLIT("xs") arg_ty + shape_vars <- mapM (newLocalVar FSLIT("sh")) shape_tys + rep_vars <- mapM (newLocalVar FSLIT("ys")) arr_tys - return . mkLams [len_var, val_var] - $ mkConApp arr_dc (map (Type . TyVarTy) (tyConTyVars arr_tc) ++ (shape : reprs)) + let vars = shape_vars ++ rep_vars + + parray_co <- mkBuiltinCo parrayTyCon + + let res = wrapFamInstBody prod_arr_tycon prod_arg_tys + . mkConApp prod_arr_data_con + $ map Type prod_arg_tys ++ map Var vars + + Just repr_co = tyConFamilyCoercion_maybe prepr_tc + co = mkAppCoercion parray_co + . mkSymCoercion + $ mkTyConApp repr_co var_tys + + return . Lam arg + . mkCoerce co + $ Case (unwrapFamInstScrut arr_tc var_tys (Var arg)) + (mkWildId (mkTyConApp arr_tc var_tys)) + res_ty + [(DataAlt arr_dc, vars, res)] where - val_ty = mkTyConApp vect_tc . mkTyVarTys $ tyConTyVars arr_tc - wild = mkWildId val_ty - vect_dcs = tyConDataCons vect_tc + var_tys = mkTyVarTys $ tyConTyVars vect_tc + el_ty = mkTyConApp vect_tc var_tys + [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]) +buildToArrPRepr _ _ _ _ = return (Var unitDataConId) +{- +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 repr@(ProdRepr { + repr_prod_arg_tys = prod_arg_tys + , repr_prod_arr_tycon = prod_arr_tycon + , repr_prod_arr_data_con = prod_arr_data_con + , repr_type = repr_type + }) + vect_tc prepr_tc arr_tc + = do + rep_el_ty <- mkPReprType el_ty + arg_ty <- mkPArrayType rep_el_ty + shape_tys <- arrShapeTys repr + arr_tys <- arrReprTys repr + res_ty <- mkPArrayType el_ty + + arg <- newLocalVar FSLIT("xs") arg_ty + shape_vars <- mapM (newLocalVar FSLIT("sh")) shape_tys + rep_vars <- mapM (newLocalVar FSLIT("ys")) arr_tys + + let vars = shape_vars ++ rep_vars + + parray_co <- mkBuiltinCo parrayTyCon + + let res = wrapFamInstBody arr_tc var_tys + . mkConApp arr_dc + $ map Type var_tys ++ map Var vars + + Just repr_co = tyConFamilyCoercion_maybe prepr_tc + co = mkAppCoercion parray_co + $ mkTyConApp repr_co var_tys - 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)) + scrut = unwrapFamInstScrut prod_arr_tycon prod_arg_tys + $ mkCoerce co (Var arg) - mk_comp_arr len val dc ty pre (_:post) + return . Lam arg + $ Case (scrut) + (mkWildId (mkTyConApp prod_arr_tycon prod_arg_tys)) + res_ty + [(DataAlt prod_arr_data_con, vars, res)] + where + var_tys = mkTyVarTys $ tyConTyVars vect_tc + el_ty = mkTyConApp vect_tc var_tys + + [arr_dc] = tyConDataCons arr_tc +buildFromArrPRepr _ _ _ _ = return (Var unitDataConId) + +buildPRDictRepr :: TyConRepr -> VM CoreExpr +buildPRDictRepr (ProdRepr { + repr_prod_arg_tys = prod_arg_tys + , repr_prod_tycon = prod_tycon + }) + = do + prs <- mapM mkPR prod_arg_tys + dfun <- prDFunOfTyCon prod_tycon + return $ dfun `mkTyApps` prod_arg_tys `mkApps` prs + +buildPRDictRepr (SumRepr { + repr_tys = repr_tys + , repr_prod_tycons = prod_tycons + , repr_prod_tys = prod_tys + , repr_sum_tycon = sum_tycon + }) + = do + prs <- mapM (mapM mkPR) repr_tys + prod_prs <- sequence $ zipWith3 mk_prod_pr prod_tycons repr_tys prs + sum_dfun <- prDFunOfTyCon sum_tycon + return $ sum_dfun `mkTyApps` prod_tys `mkApps` prod_prs + where + mk_prod_pr _ _ [] = prDFunOfTyCon unitTyCon + mk_prod_pr _ _ [pr] = return pr + mk_prod_pr (Just tc) tys prs = do - var <- newLocalVar FSLIT("x") ty - rep <- replicatePA len (Var var) - empty <- emptyPA ty - arr_ty <- mkPArrayType ty + dfun <- prDFunOfTyCon tc + return $ dfun `mkTyApps` tys `mkApps` prs - return $ Case val wild arr_ty - [(DataAlt dc, pre ++ (var : post), rep), (DEFAULT, [], empty)] +buildPRDict :: TyConRepr -> TyCon -> TyCon -> TyCon -> VM CoreExpr +buildPRDict repr vect_tc prepr_tc _ + = do + dict <- buildPRDictRepr repr + + pr_co <- mkBuiltinCo prTyCon + let co = mkAppCoercion pr_co + . mkSymCoercion + $ mkTyConApp arg_co var_tys + + return $ mkCoerce co dict + where + var_tys = mkTyVarTys $ tyConTyVars vect_tc + + Just arg_co = tyConFamilyCoercion_maybe prepr_tc + +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 + repr <- mkTyConRepr vect_tc + + shape_tys <- arrShapeTys repr + repr_tys <- arrReprTys repr + + let tys = shape_tys ++ repr_tys + + liftDs $ buildDataCon dc_name + False -- not infix + (map (const NotMarkedStrict) tys) + [] -- no field labels + (tyConTyVars vect_tc) + [] -- no existentials + [] -- no eq spec + [] -- no context + tys + repr_tc + +mkPADFun :: TyCon -> VM Var +mkPADFun vect_tc + = newExportedVar (mkPADFunOcc $ getOccName vect_tc) =<< paDFunType vect_tc + +data Shape = Shape { + shapeReprTys :: [Type] + , shapeStrictness :: [StrictnessMark] + , shapeLength :: [CoreExpr] -> VM CoreExpr + , shapeReplicate :: CoreExpr -> CoreExpr -> VM [CoreExpr] + } + +tyConShape :: TyCon -> VM Shape +tyConShape vect_tc + | isProductTyCon vect_tc + = return $ Shape { + shapeReprTys = [intPrimTy] + , shapeStrictness = [NotMarkedStrict] + , shapeLength = \[len] -> return len + , shapeReplicate = \len _ -> return [len] + } + + | otherwise + = do + repr_ty <- mkPArrayType intTy -- FIXME: we want to unbox this + return $ Shape { + shapeReprTys = [repr_ty] + , shapeStrictness = [MarkedStrict] + , shapeLength = \[sel] -> lengthPA sel + , shapeReplicate = \len n -> do + e <- replicatePA len n + return [e] + } + +buildTyConBindings :: TyCon -> TyCon -> TyCon -> TyCon -> Var + -> VM [(Var, CoreExpr)] +buildTyConBindings orig_tc vect_tc prepr_tc arr_tc dfun + = do + shape <- tyConShape vect_tc + 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 repr vect_tc prepr_tc arr_tc dfun + binds <- takeHoisted + return $ (dfun, dict) : binds + where + orig_dcs = tyConDataCons orig_tc + vect_dcs = tyConDataCons vect_tc + [arr_dc] = tyConDataCons arr_tc + + repr_tys = map dataConRepArgTys vect_dcs + +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 + clo <- closedV + . inBind orig_worker + . polyAbstract tvs $ \abstract -> + liftM (abstract . vectorised) + $ buildClosures tvs [] dc_tys res_ty (liftM2 (,) mk_vect mk_lift) + + worker <- cloneId mkVectOcc orig_worker (exprType clo) + hoistBinding worker clo + defGlobalVar orig_worker worker + return () + where + tvs = tyConTyVars vect_tc + arg_tys = mkTyVarTys tvs + res_ty = mkTyConApp vect_tc arg_tys + + orig_worker = dataConWorkId orig_dc + + 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 :: 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 repr) paMethods + let meth_exprs = map (Var . fst) meth_binds + + pa_dc <- builtin paDataCon + let dict = mkConApp pa_dc (Type (mkTyConApp vect_tc arg_tys) : meth_exprs) + body = Let (Rec meth_binds) dict + return . mkInlineMe $ abstract body + where + tvs = tyConTyVars arr_tc + arg_tys = mkTyVarTys tvs + + mk_method repr (name, build) + = localV + $ do + body <- build repr vect_tc prepr_tc arr_tc + var <- newLocalVar name (exprType body) + return (var, mkInlineMe body) + +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