X-Git-Url: http://git.megacz.com/?p=ghc-hetmet.git;a=blobdiff_plain;f=compiler%2Fvectorise%2FVectType.hs;h=b4b3c43b2d231c964120eb469abeb71b462e1846;hp=b238199730465053a599c49e43757d04ff9a301a;hb=7e8cba32c6f045dde3db8a9ddc9831ec8ab4ed43;hpb=bfddbe303f56f1e96b0e4820986699768738beb4 diff --git a/compiler/vectorise/VectType.hs b/compiler/vectorise/VectType.hs index b238199..b4b3c43 100644 --- a/compiler/vectorise/VectType.hs +++ b/compiler/vectorise/VectType.hs @@ -1,8 +1,9 @@ -module VectType ( vectTyCon, vectType, vectTypeEnv, - PAInstance, buildPADict ) -where -#include "HsVersions.h" +module VectType ( vectTyCon, vectAndLiftType, vectType, vectTypeEnv, + mkRepr, arrShapeTys, arrShapeVars, arrSelector, + buildPADict, + fromVect ) +where import VectMonad import VectUtils @@ -11,6 +12,7 @@ import VectCore import HscTypes ( TypeEnv, extendTypeEnvList, typeEnvTyCons ) import CoreSyn import CoreUtils +import MkCore ( mkWildCase ) import BuildTyCl import DataCon import TyCon @@ -18,23 +20,23 @@ import Type import TypeRep import Coercion import FamInstEnv ( FamInst, mkLocalFamInst ) -import InstEnv ( Instance, mkLocalInstance, instanceDFunId ) import OccName import MkId -import BasicTypes ( StrictnessMark(..), OverlapFlag(..), boolToRecFlag ) -import Var ( Var ) -import Id ( mkWildId ) +import BasicTypes ( StrictnessMark(..), boolToRecFlag ) +import Var ( Var, TyVar ) import Name ( Name, getOccName ) import NameEnv -import TysWiredIn ( unitTy, unitTyCon, intTy, intDataCon, unitDataConId ) +import TysWiredIn import TysPrim ( intPrimTy ) import Unique import UniqFM import UniqSet -import Digraph ( SCC(..), stronglyConnComp ) +import Util +import Digraph ( SCC(..), stronglyConnCompFromEdgedVertices ) import Outputable +import FastString import Control.Monad ( liftM, liftM2, zipWithM, zipWithM_, mapAndUnzipM ) import Data.List ( inits, tails, zipWith4, zipWith5 ) @@ -47,13 +49,22 @@ vectTyCon tc | isFunTyCon tc = builtin closureTyCon | isBoxedTupleTyCon tc = return tc | isUnLiftedTyCon tc = return tc - | otherwise = do - r <- lookupTyCon tc - case r of - Just tc' -> return tc' + | otherwise = maybeCantVectoriseM "Tycon not vectorised:" (ppr tc) + $ lookupTyCon tc + +vectAndLiftType :: Type -> VM (Type, Type) +vectAndLiftType ty | Just ty' <- coreView ty = vectAndLiftType ty' +vectAndLiftType ty + = do + mdicts <- mapM paDictArgType tyvars + let dicts = [dict | Just dict <- mdicts] + vmono_ty <- vectType mono_ty + lmono_ty <- mkPArrayType vmono_ty + return (abstractType tyvars dicts vmono_ty, + abstractType tyvars dicts lmono_ty) + where + (tyvars, mono_ty) = splitForAllTys ty - -- FIXME: just for now - Nothing -> pprTrace "ccTyCon:" (ppr tc) $ return tc vectType :: Type -> VM Type vectType ty | Just ty' <- coreView ty = vectType ty' @@ -61,29 +72,42 @@ vectType (TyVarTy tv) = return $ TyVarTy tv vectType (AppTy ty1 ty2) = liftM2 AppTy (vectType ty1) (vectType ty2) vectType (TyConApp tc tys) = liftM2 TyConApp (vectTyCon tc) (mapM vectType tys) vectType (FunTy ty1 ty2) = liftM2 TyConApp (builtin closureTyCon) - (mapM vectType [ty1,ty2]) + (mapM vectAndBoxType [ty1,ty2]) vectType ty@(ForAllTy _ _) = do mdicts <- mapM paDictArgType tyvars mono_ty' <- vectType mono_ty - return $ tyvars `mkForAllTys` ([dict | Just dict <- mdicts] `mkFunTys` mono_ty') + return $ abstractType tyvars [dict | Just dict <- mdicts] mono_ty' where (tyvars, mono_ty) = splitForAllTys ty -vectType ty = pprPanic "vectType:" (ppr ty) +vectType ty = cantVectorise "Can't vectorise type" (ppr ty) + +vectAndBoxType :: Type -> VM Type +vectAndBoxType ty = vectType ty >>= boxType + +abstractType :: [TyVar] -> [Type] -> Type -> Type +abstractType tyvars dicts = mkForAllTys tyvars . mkFunTys dicts + +-- ---------------------------------------------------------------------------- +-- Boxing + +boxType :: Type -> VM Type +boxType ty + | Just (tycon, []) <- splitTyConApp_maybe ty + , isUnLiftedTyCon tycon + = do + r <- lookupBoxedTyCon tycon + case r of + Just tycon' -> return $ mkTyConApp tycon' [] + Nothing -> return ty +boxType ty = return ty -- ---------------------------------------------------------------------------- -- Type definitions type TyConGroup = ([TyCon], UniqSet TyCon) -data PAInstance = PAInstance { - painstDFun :: Var - , painstOrigTyCon :: TyCon - , painstVectTyCon :: TyCon - , painstArrTyCon :: TyCon - } - vectTypeEnv :: TypeEnv -> VM (TypeEnv, [FamInst], [(Var, CoreExpr)]) vectTypeEnv env = do @@ -121,25 +145,18 @@ vectTypeEnv env mk_map env = listToUFM_Directly [(u, getUnique n /= u) | (u,n) <- nameEnvUniqueElts env] - keep_tc tc = let dcs = tyConDataCons tc - in - defTyCon tc tc >> zipWithM_ defDataCon dcs dcs - vectTyConDecls :: [TyCon] -> VM [TyCon] vectTyConDecls tcs = fixV $ \tcs' -> do - mapM_ (uncurry defTyCon) (lazy_zip tcs tcs') + mapM_ (uncurry defTyCon) (zipLazy tcs tcs') mapM vectTyConDecl tcs - where - lazy_zip [] _ = [] - lazy_zip (x:xs) ~(y:ys) = (x,y) : lazy_zip xs ys vectTyConDecl :: TyCon -> VM TyCon vectTyConDecl tc = do name' <- cloneName mkVectTyConOcc name - rhs' <- vectAlgTyConRhs (algTyConRhs tc) + rhs' <- vectAlgTyConRhs tc (algTyConRhs tc) liftDs $ buildAlgTyCon name' tyvars @@ -154,21 +171,24 @@ vectTyConDecl tc tyvars = tyConTyVars tc rec_flag = boolToRecFlag (isRecursiveTyCon tc) -vectAlgTyConRhs :: AlgTyConRhs -> VM AlgTyConRhs -vectAlgTyConRhs (DataTyCon { data_cons = data_cons - , is_enum = is_enum - }) +vectAlgTyConRhs :: TyCon -> AlgTyConRhs -> VM AlgTyConRhs +vectAlgTyConRhs _ (DataTyCon { data_cons = data_cons + , is_enum = is_enum + }) = do data_cons' <- mapM vectDataCon data_cons zipWithM_ defDataCon data_cons data_cons' return $ DataTyCon { data_cons = data_cons' , is_enum = is_enum } +vectAlgTyConRhs tc _ = cantVectorise "Can't vectorise type definition:" (ppr tc) vectDataCon :: DataCon -> VM DataCon vectDataCon dc - | not . null $ dataConExTyVars dc = pprPanic "vectDataCon: existentials" (ppr dc) - | not . null $ dataConEqSpec dc = pprPanic "vectDataCon: eq spec" (ppr dc) + | not . null $ dataConExTyVars dc + = cantVectorise "Can't vectorise constructor (existentials):" (ppr dc) + | not . null $ dataConEqSpec dc + = cantVectorise "Can't vectorise constructor (eq spec):" (ppr dc) | otherwise = do name' <- cloneName mkVectDataConOcc name @@ -204,6 +224,7 @@ buildPReprTyCon orig_tc vect_tc liftDs $ buildSynTyCon name tyvars (SynonymTyCon rhs_ty) + (typeKind rhs_ty) (Just $ mk_fam_inst prepr_tc vect_tc) where tyvars = tyConTyVars vect_tc @@ -224,13 +245,60 @@ data Repr = ProdRepr { , sum_arr_data_con :: DataCon } -mkProduct :: [Type] -> VM Repr -mkProduct tys + | IdRepr Type + + | VoidRepr { + void_tycon :: TyCon + , void_bottom :: CoreExpr + } + + | EnumRepr { + enum_tycon :: TyCon + , enum_data_con :: DataCon + , enum_arr_tycon :: TyCon + , enum_arr_data_con :: DataCon + } + +voidRepr :: VM Repr +voidRepr + = do + tycon <- builtin voidTyCon + var <- builtin voidVar + return $ VoidRepr { + void_tycon = tycon + , void_bottom = Var var + } + +{- +enumRepr :: VM Repr +enumRepr + = do + tycon <- builtin enumerationTyCon + let [data_con] = tyConDataCons tycon + (arr_tycon, _) <- parrayReprTyCon (mkTyConApp tycon []) + let [arr_data_con] = tyConDataCons arr_tycon + + return $ EnumRepr { + enum_tycon = tycon + , enum_data_con = data_con + , enum_arr_tycon = arr_tycon + , enum_arr_data_con = arr_data_con + } +-} + +unboxedProductRepr :: [Type] -> VM Repr +unboxedProductRepr [] = voidRepr +unboxedProductRepr [ty] = return $ IdRepr ty +unboxedProductRepr tys = boxedProductRepr tys + +boxedProductRepr :: [Type] -> VM Repr +boxedProductRepr tys = do tycon <- builtin (prodTyCon arity) let [data_con] = tyConDataCons tycon - (arr_tycon, _) <- parrayReprTyCon $ mkTyConApp tycon tys + tys' <- mapM boxType tys + (arr_tycon, _) <- parrayReprTyCon $ mkTyConApp tycon tys' let [arr_data_con] = tyConDataCons arr_tycon return $ ProdRepr { @@ -243,9 +311,10 @@ mkProduct tys where arity = length tys -mkSum :: [Repr] -> VM Repr -mkSum [repr] = return repr -mkSum reprs +sumRepr :: [Repr] -> VM Repr +sumRepr [] = voidRepr +sumRepr [repr] = boxRepr repr +sumRepr reprs = do tycon <- builtin (sumTyCon arity) (arr_tycon, _) <- parrayReprTyCon @@ -263,63 +332,106 @@ mkSum reprs where arity = length reprs -reprProducts :: Repr -> [Repr] -reprProducts (SumRepr { sum_components = rs }) = rs -reprProducts repr = [repr] +splitSumRepr :: Repr -> [Repr] +splitSumRepr (SumRepr { sum_components = reprs }) = reprs +splitSumRepr repr = [repr] + +boxRepr :: Repr -> VM Repr +boxRepr (VoidRepr {}) = boxedProductRepr [] +boxRepr (IdRepr ty) = boxedProductRepr [ty] +boxRepr repr = return repr reprType :: Repr -> Type reprType (ProdRepr { prod_tycon = tycon, prod_components = tys }) = mkTyConApp tycon tys reprType (SumRepr { sum_tycon = tycon, sum_components = reprs }) = mkTyConApp tycon (map reprType reprs) +reprType (IdRepr ty) = ty +reprType (VoidRepr { void_tycon = tycon }) = mkTyConApp tycon [] +reprType (EnumRepr { enum_tycon = tycon }) = mkTyConApp tycon [] arrReprType :: Repr -> VM Type arrReprType = mkPArrayType . reprType -reprTys :: Repr -> [[Type]] -reprTys (SumRepr { sum_components = prods }) = map prodTys prods -reprTys prod = [prodTys prod] - -prodTys (ProdRepr { prod_components = tys }) = tys +arrShapeTys :: Repr -> VM [Type] +arrShapeTys (SumRepr {}) = sumShapeTys +arrShapeTys (ProdRepr {}) = return [intPrimTy] +arrShapeTys (IdRepr _) = return [] +arrShapeTys (VoidRepr {}) = return [intPrimTy] +arrShapeTys (EnumRepr {}) = sumShapeTys -reprVars :: Repr -> VM [[Var]] -reprVars = mapM (mapM (newLocalVar FSLIT("r"))) . reprTys +sumShapeTys :: VM [Type] +sumShapeTys = do + int_arr <- builtin intPrimArrayTy + return [intPrimTy, int_arr, int_arr] -arrShapeTys :: Repr -> VM [Type] -arrShapeTys (SumRepr {}) - = do - uarr <- builtin uarrTyCon - return [intPrimTy, mkTyConApp uarr [intTy]] -arrShapeTys repr = return [intPrimTy] arrShapeVars :: Repr -> VM [Var] -arrShapeVars repr = mapM (newLocalVar FSLIT("sh")) =<< arrShapeTys repr +arrShapeVars repr = mapM (newLocalVar (fsLit "sh")) =<< arrShapeTys repr replicateShape :: Repr -> CoreExpr -> CoreExpr -> VM [CoreExpr] -replicateShape (ProdRepr {}) len _ = return [len] - -arrReprElemTys :: Repr -> [[Type]] -arrReprElemTys (SumRepr { sum_components = prods }) - = map arrProdElemTys prods -arrReprElemTys prod@(ProdRepr {}) - = [arrProdElemTys prod] - -arrProdElemTys (ProdRepr { prod_components = [] }) - = [unitTy] -arrProdElemTys (ProdRepr { prod_components = tys }) - = tys - -arrReprTys :: Repr -> VM [[Type]] -arrReprTys = mapM (mapM mkPArrayType) . arrReprElemTys +replicateShape (ProdRepr {}) len _ = return [len] +replicateShape (SumRepr {}) len tag = replicateSumShape len tag +replicateShape (IdRepr _) _ _ = return [] +replicateShape (VoidRepr {}) len _ = return [len] +replicateShape (EnumRepr {}) len tag = replicateSumShape len tag + +replicateSumShape :: CoreExpr -> CoreExpr -> VM [CoreExpr] +replicateSumShape len tag + = do + rep <- builtin replicatePAIntPrimVar + up <- builtin upToPAIntPrimVar + return [len, Var rep `mkApps` [len, tag], Var up `App` len] + +arrSelector :: Repr -> [CoreExpr] -> VM (CoreExpr, CoreExpr, CoreExpr) +arrSelector (SumRepr {}) [len, sel, is] = return (len, sel, is) +arrSelector (EnumRepr {}) [len, sel, is] = return (len, sel, is) +arrSelector _ _ = panic "arrSelector" + +emptyArrRepr :: Repr -> VM [CoreExpr] +emptyArrRepr (SumRepr { sum_components = prods }) + = liftM concat $ mapM emptyArrRepr prods +emptyArrRepr (ProdRepr { prod_components = [] }) + = return [Var unitDataConId] +emptyArrRepr (ProdRepr { prod_components = tys }) + = mapM emptyPA tys +emptyArrRepr (IdRepr ty) + = liftM singleton $ emptyPA ty +emptyArrRepr (VoidRepr { void_tycon = tycon }) + = liftM singleton $ emptyPA (mkTyConApp tycon []) +emptyArrRepr (EnumRepr {}) + = return [] + +arrReprTys :: Repr -> VM [Type] +arrReprTys (SumRepr { sum_components = reprs }) + = liftM concat $ mapM arrReprTys reprs +arrReprTys (ProdRepr { prod_components = [] }) + = return [unitTy] +arrReprTys (ProdRepr { prod_components = tys }) + = mapM mkPArrayType tys +arrReprTys (IdRepr ty) + = liftM singleton $ mkPArrayType ty +arrReprTys (VoidRepr { void_tycon = tycon }) + = liftM singleton $ mkPArrayType (mkTyConApp tycon []) +arrReprTys (EnumRepr {}) + = return [] + +arrReprTys' :: Repr -> VM [[Type]] +arrReprTys' (SumRepr { sum_components = reprs }) + = mapM arrReprTys reprs +arrReprTys' repr = liftM singleton $ arrReprTys repr arrReprVars :: Repr -> VM [[Var]] arrReprVars repr - = mapM (mapM (newLocalVar FSLIT("rs"))) =<< arrReprTys repr + = mapM (mapM (newLocalVar (fsLit "rs"))) =<< arrReprTys' repr mkRepr :: TyCon -> VM Repr mkRepr vect_tc - = mkSum - =<< mapM mkProduct (map dataConRepArgTys $ tyConDataCons vect_tc) + | [tys] <- rep_tys = boxedProductRepr tys + -- removed: | all null rep_tys = enumRepr + | otherwise = sumRepr =<< mapM unboxedProductRepr rep_tys + where + rep_tys = map dataConRepArgTys $ tyConDataCons vect_tc buildPReprType :: TyCon -> VM Type buildPReprType = liftM reprType . mkRepr @@ -327,7 +439,7 @@ buildPReprType = liftM reprType . mkRepr buildToPRepr :: Repr -> TyCon -> TyCon -> TyCon -> VM CoreExpr buildToPRepr repr vect_tc prepr_tc _ = do - arg <- newLocalVar FSLIT("x") arg_ty + arg <- newLocalVar (fsLit "x") arg_ty result <- to_repr repr (Var arg) return . Lam arg @@ -345,8 +457,8 @@ buildToPRepr repr vect_tc prepr_tc _ , sum_tycon = tycon }) expr = do - (vars, bodies) <- mapAndUnzipM prod_alt prods - return . Case expr (mkWildId (exprType expr)) res_ty + (vars, bodies) <- mapAndUnzipM to_unboxed prods + return . mkWildCase expr (exprType expr) res_ty $ zipWith4 mk_alt cons vars (tyConDataCons tycon) bodies where mk_alt con vars sum_con body @@ -354,23 +466,40 @@ buildToPRepr repr vect_tc prepr_tc _ ty_args = map (Type . reprType) prods + to_repr (EnumRepr { enum_data_con = data_con }) expr + = return . mkWildCase expr (exprType expr) res_ty + $ map mk_alt cons + where + mk_alt con = (DataAlt con, [], mkConApp data_con [mkDataConTag con]) + to_repr prod expr = do - (vars, body) <- prod_alt prod - return $ Case expr (mkWildId (exprType expr)) res_ty + (vars, body) <- to_unboxed prod + return $ mkWildCase expr (exprType expr) res_ty [(DataAlt con, vars, body)] - prod_alt (ProdRepr { prod_components = tys - , prod_data_con = data_con }) + to_unboxed (ProdRepr { prod_components = tys + , prod_data_con = data_con }) = do - vars <- mapM (newLocalVar FSLIT("r")) tys + vars <- mapM (newLocalVar (fsLit "r")) tys return (vars, mkConApp data_con (map Type tys ++ map Var vars)) + to_unboxed (IdRepr ty) + = do + var <- newLocalVar (fsLit "y") ty + return ([var], Var var) + + to_unboxed (VoidRepr { void_bottom = bottom }) + = return ([], bottom) + + to_unboxed _ = panic "buildToPRepr/to_unboxed" + + buildFromPRepr :: Repr -> TyCon -> TyCon -> TyCon -> VM CoreExpr buildFromPRepr repr vect_tc prepr_tc _ = do arg_ty <- mkPReprType res_ty - arg <- newLocalVar FSLIT("x") arg_ty + arg <- newLocalVar (fsLit "x") arg_ty liftM (Lam arg) . from_repr repr @@ -386,30 +515,55 @@ buildFromPRepr repr vect_tc prepr_tc _ , sum_tycon = tycon }) expr = do - vars <- mapM (newLocalVar FSLIT("x")) (map reprType prods) - bodies <- sequence . zipWith3 from_prod prods cons + vars <- mapM (newLocalVar (fsLit "x")) (map reprType prods) + bodies <- sequence . zipWith3 from_unboxed prods cons $ map Var vars - return . Case expr (mkWildId (reprType repr)) res_ty + return . mkWildCase expr (reprType repr) res_ty $ zipWith3 sum_alt (tyConDataCons tycon) vars bodies where sum_alt data_con var body = (DataAlt data_con, [var], body) - from_repr repr expr = from_prod repr con expr + from_repr repr@(EnumRepr { enum_data_con = data_con }) expr + = do + var <- newLocalVar (fsLit "n") intPrimTy + + let res = mkWildCase (Var var) intPrimTy res_ty + $ (DEFAULT, [], error_expr) + : zipWith mk_alt (tyConDataCons vect_tc) cons + + return $ mkWildCase expr (reprType repr) res_ty + [(DataAlt data_con, [var], res)] + where + mk_alt data_con con = (LitAlt (mkDataConTagLit data_con), [], con) + + error_expr = mkRuntimeErrorApp rUNTIME_ERROR_ID res_ty + . showSDoc + $ sep [text "Invalid NDP representation of", ppr vect_tc] - from_prod prod@(ProdRepr { prod_components = tys - , prod_data_con = data_con }) + from_repr repr expr = from_unboxed repr con expr + + from_unboxed prod@(ProdRepr { prod_components = tys + , prod_data_con = data_con }) con expr = do - vars <- mapM (newLocalVar FSLIT("y")) tys - return $ Case expr (mkWildId (reprType prod)) res_ty + vars <- mapM (newLocalVar (fsLit "y")) tys + return $ mkWildCase expr (reprType prod) res_ty [(DataAlt data_con, vars, con `mkVarApps` vars)] + from_unboxed (IdRepr _) con expr + = return $ con `App` expr + + from_unboxed (VoidRepr {}) con _ + = return con + + from_unboxed _ _ _ = panic "buildFromPRepr/from_unboxed" + buildToArrPRepr :: Repr -> TyCon -> TyCon -> TyCon -> VM CoreExpr buildToArrPRepr repr vect_tc prepr_tc arr_tc = do arg_ty <- mkPArrayType el_ty - arg <- newLocalVar FSLIT("xs") arg_ty + arg <- newLocalVar (fsLit "xs") arg_ty res_ty <- mkPArrayType (reprType repr) @@ -429,7 +583,7 @@ buildToArrPRepr repr vect_tc prepr_tc arr_tc return . Lam arg . mkCoerce co - $ Case scrut (mkWildId (mkTyConApp arr_tc var_tys)) res_ty + $ mkWildCase scrut (mkTyConApp arr_tc var_tys) res_ty [(DataAlt arr_dc, shape_vars ++ concat repr_vars, result)] where var_tys = mkTyVarTys $ tyConTyVars vect_tc @@ -437,13 +591,13 @@ buildToArrPRepr repr vect_tc prepr_tc arr_tc [arr_dc] = tyConDataCons arr_tc - to_repr shape_vars@(len_var : _) + to_repr shape_vars@(_ : _) repr_vars (SumRepr { sum_components = prods , sum_arr_tycon = tycon , sum_arr_data_con = data_con }) = do - exprs <- zipWithM (to_prod len_var) repr_vars prods + exprs <- zipWithM to_prod repr_vars prods return . wrapFamInstBody tycon tys . mkConApp data_con @@ -451,22 +605,45 @@ buildToArrPRepr repr vect_tc prepr_tc arr_tc where tys = map reprType prods - to_repr [len_var] [repr_vars] prod = to_prod len_var repr_vars prod - - to_prod len_var - repr_vars + to_repr [len_var] + [repr_vars] (ProdRepr { prod_components = tys , prod_arr_tycon = tycon , prod_arr_data_con = data_con }) - = return . wrapFamInstBody tycon tys + = return . wrapFamInstBody tycon tys + . mkConApp data_con + $ map Type tys ++ map Var (len_var : repr_vars) + + to_repr shape_vars + _ + (EnumRepr { enum_arr_tycon = tycon + , enum_arr_data_con = data_con }) + = return . wrapFamInstBody tycon [] . mkConApp data_con - $ map Type tys ++ map Var (len_var : repr_vars) + $ map Var shape_vars + + to_repr _ _ _ = panic "buildToArrPRepr/to_repr" + + to_prod repr_vars@(r : _) + (ProdRepr { prod_components = tys@(ty : _) + , prod_arr_tycon = tycon + , prod_arr_data_con = data_con }) + = do + len <- lengthPA ty (Var r) + return . wrapFamInstBody tycon tys + . mkConApp data_con + $ map Type tys ++ len : map Var repr_vars + + to_prod [var] (IdRepr _) = return (Var var) + to_prod [var] (VoidRepr {}) = return (Var var) + to_prod _ _ = panic "buildToArrPRepr/to_prod" + buildFromArrPRepr :: Repr -> TyCon -> TyCon -> TyCon -> VM CoreExpr buildFromArrPRepr repr vect_tc prepr_tc arr_tc = do arg_ty <- mkPArrayType =<< mkPReprType el_ty - arg <- newLocalVar FSLIT("xs") arg_ty + arg <- newLocalVar (fsLit "xs") arg_ty res_ty <- mkPArrayType el_ty @@ -502,11 +679,11 @@ buildFromArrPRepr repr vect_tc prepr_tc arr_tc res_ty body = do - vars <- mapM (newLocalVar FSLIT("xs")) =<< mapM arrReprType prods + vars <- mapM (newLocalVar (fsLit "xs")) =<< mapM arrReprType prods result <- go prods repr_vars vars body let scrut = unwrapFamInstScrut tycon ty_args expr - return . Case scrut (mkWildId scrut_ty) res_ty + return . mkWildCase scrut scrut_ty res_ty $ [(DataAlt data_con, shape_vars ++ vars, result)] where ty_args = map reprType prods @@ -515,17 +692,20 @@ buildFromArrPRepr repr vect_tc prepr_tc arr_tc go [] [] [] body = return body go (prod : prods) (repr_vars : rss) (var : vars) body = do - shape_vars <- mapM (newLocalVar FSLIT("s")) =<< arrShapeTys prod + shape_vars <- mapM (newLocalVar (fsLit "s")) =<< arrShapeTys prod from_prod prod (Var var) shape_vars repr_vars res_ty =<< go prods rss vars body + go _ _ _ _ = panic "buildFromArrPRepr/go" from_repr repr expr shape_vars [repr_vars] res_ty body = from_prod repr expr shape_vars repr_vars res_ty body - from_prod prod@(ProdRepr { prod_components = tys - , prod_arr_tycon = tycon - , prod_arr_data_con = data_con }) + from_repr _ _ _ _ _ _ = panic "buildFromArrPRepr/from_repr" + + from_prod (ProdRepr { prod_components = tys + , prod_arr_tycon = tycon + , prod_arr_data_con = data_con }) expr shape_vars repr_vars @@ -534,12 +714,45 @@ buildFromArrPRepr repr vect_tc prepr_tc arr_tc = do let scrut = unwrapFamInstScrut tycon tys expr scrut_ty = mkTyConApp tycon tys - ty <- arrReprType prod - return $ Case scrut (mkWildId scrut_ty) res_ty + return $ mkWildCase scrut scrut_ty res_ty [(DataAlt data_con, shape_vars ++ repr_vars, body)] + from_prod (EnumRepr { enum_arr_tycon = tycon + , enum_arr_data_con = data_con }) + expr + shape_vars + _ + res_ty + body + = let scrut = unwrapFamInstScrut tycon [] expr + scrut_ty = mkTyConApp tycon [] + in + return $ mkWildCase scrut scrut_ty res_ty + [(DataAlt data_con, shape_vars, body)] + + from_prod (IdRepr _) + expr + _shape_vars + [repr_var] + _res_ty + body + = return $ Let (NonRec repr_var expr) body + + from_prod (VoidRepr {}) + expr + _shape_vars + [repr_var] + _res_ty + body + = return $ Let (NonRec repr_var expr) body + + from_prod _ _ _ _ _ _ = panic "buildFromArrPRepr/from_prod" + buildPRDictRepr :: Repr -> VM CoreExpr +buildPRDictRepr (VoidRepr { void_tycon = tycon }) + = prDFunOfTyCon tycon +buildPRDictRepr (IdRepr ty) = mkPR ty buildPRDictRepr (ProdRepr { prod_components = tys , prod_tycon = tycon @@ -557,6 +770,9 @@ buildPRDictRepr (SumRepr { dfun <- prDFunOfTyCon tycon return $ dfun `mkTyApps` map reprType prods `mkApps` prs +buildPRDictRepr (EnumRepr { enum_tycon = tycon }) + = prDFunOfTyCon tycon + buildPRDict :: Repr -> TyCon -> TyCon -> TyCon -> VM CoreExpr buildPRDict repr vect_tc prepr_tc _ = do @@ -609,7 +825,7 @@ buildPArrayDataCon orig_name vect_tc repr_tc shape_tys <- arrShapeTys repr repr_tys <- arrReprTys repr - let tys = shape_tys ++ concat repr_tys + let tys = shape_tys ++ repr_tys liftDs $ buildDataCon dc_name False -- not infix @@ -626,51 +842,15 @@ 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 <- mkRepr vect_tc vectDataConWorkers repr orig_tc vect_tc arr_tc 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 vectDataConWorkers :: Repr -> TyCon -> TyCon -> TyCon -> VM () @@ -680,8 +860,8 @@ vectDataConWorkers repr orig_tc vect_tc arr_tc . zipWith3 def_worker (tyConDataCons orig_tc) rep_tys $ zipWith4 mk_data_con (tyConDataCons vect_tc) rep_tys - (inits arr_tys) - (tail $ tails arr_tys) + (inits reprs) + (tail $ tails reprs) mapM_ (uncurry hoistBinding) bs where tyvars = tyConTyVars vect_tc @@ -691,29 +871,26 @@ vectDataConWorkers repr orig_tc vect_tc arr_tc res_ty = mkTyConApp vect_tc var_tys rep_tys = map dataConRepArgTys $ tyConDataCons vect_tc - arr_tys = arrReprElemTys repr + reprs = splitSumRepr repr [arr_dc] = tyConDataCons arr_tc mk_data_con con tys pre post = liftM2 (,) (vect_data_con con) - (lift_data_con tys (concat pre) - (concat post) - (mkDataConTag con)) - + (lift_data_con tys pre post (mkDataConTag con)) vect_data_con con = return $ mkConApp con ty_args - lift_data_con tys pre_tys post_tys tag + lift_data_con tys pre_reprs post_reprs tag = do len <- builtin liftingContext - args <- mapM (newLocalVar FSLIT("xs")) + args <- mapM (newLocalVar (fsLit "xs")) =<< mapM mkPArrayType tys - + shape <- replicateShape repr (Var len) tag repr <- mk_arr_repr (Var len) (map Var args) - - pre <- mapM emptyPA pre_tys - post <- mapM emptyPA post_tys + + pre <- liftM concat $ mapM emptyArrRepr pre_reprs + post <- liftM concat $ mapM emptyArrRepr post_reprs return . mkLams (len : args) . wrapFamInstBody arr_tc var_tys @@ -725,7 +902,7 @@ vectDataConWorkers repr orig_tc vect_tc arr_tc units <- replicatePA len (Var unitDataConId) return [units] - mk_arr_repr len arrs = return arrs + mk_arr_repr _ arrs = return arrs def_worker data_con arg_tys mk_body = do @@ -741,50 +918,8 @@ vectDataConWorkers repr orig_tc vect_tc arr_tc where orig_worker = dataConWorkId data_con -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 :: Repr -> TyCon -> TyCon -> TyCon -> Var -> VM CoreExpr -buildPADict repr vect_tc prepr_tc arr_tc dfun +buildPADict repr vect_tc prepr_tc arr_tc _ = polyAbstract tvs $ \abstract -> do meth_binds <- mapM (mk_method repr) paMethods @@ -805,11 +940,12 @@ buildPADict repr vect_tc prepr_tc arr_tc dfun 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)] +paMethods :: [(FastString, Repr -> TyCon -> TyCon -> TyCon -> VM CoreExpr)] +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 @@ -822,7 +958,7 @@ paMethods = [(FSLIT("toPRepr"), buildToPRepr), classifyTyCons :: UniqFM Bool -> [TyConGroup] -> ([TyCon], [TyCon]) classifyTyCons = classify [] [] where - classify conv keep cs [] = (conv, keep) + classify conv keep _ [] = (conv, keep) classify conv keep cs ((tcs, ds) : rs) | can_convert && must_convert = classify (tcs ++ conv) keep (cs `addListToUFM` [(tc,True) | tc <- tcs]) rs @@ -841,7 +977,7 @@ classifyTyCons = classify [] [] -- | Compute mutually recursive groups of tycons in topological order -- tyConGroups :: [TyCon] -> [TyConGroup] -tyConGroups tcs = map mk_grp (stronglyConnComp edges) +tyConGroups tcs = map mk_grp (stronglyConnCompFromEdgedVertices edges) where edges = [((tc, ds), tc, uniqSetToList ds) | tc <- tcs , let ds = tyConsOfTyCon tc] @@ -858,7 +994,7 @@ tyConsOfTyCon tyConsOfType :: Type -> UniqSet TyCon tyConsOfType ty | Just ty' <- coreView ty = tyConsOfType ty' -tyConsOfType (TyVarTy v) = emptyUniqSet +tyConsOfType (TyVarTy _) = emptyUniqSet tyConsOfType (TyConApp tc tys) = extend (tyConsOfTypes tys) where extend | isUnLiftedTyCon tc @@ -875,3 +1011,41 @@ tyConsOfType other = pprPanic "ClosureConv.tyConsOfType" $ ppr other tyConsOfTypes :: [Type] -> UniqSet TyCon tyConsOfTypes = unionManyUniqSets . map tyConsOfType + +-- ---------------------------------------------------------------------------- +-- Conversions + +fromVect :: Type -> CoreExpr -> VM CoreExpr +fromVect ty expr | Just ty' <- coreView ty = fromVect ty' expr +fromVect (FunTy arg_ty res_ty) expr + = do + arg <- newLocalVar (fsLit "x") arg_ty + varg <- toVect arg_ty (Var arg) + varg_ty <- vectType arg_ty + vres_ty <- vectType res_ty + apply <- builtin applyClosureVar + body <- fromVect res_ty + $ Var apply `mkTyApps` [varg_ty, vres_ty] `mkApps` [expr, varg] + return $ Lam arg body +fromVect ty expr + = identityConv ty >> return expr + +toVect :: Type -> CoreExpr -> VM CoreExpr +toVect ty expr = identityConv ty >> return expr + +identityConv :: Type -> VM () +identityConv ty | Just ty' <- coreView ty = identityConv ty' +identityConv (TyConApp tycon tys) + = do + mapM_ identityConv tys + identityConvTyCon tycon +identityConv _ = noV + +identityConvTyCon :: TyCon -> VM () +identityConvTyCon tc + | isBoxedTupleTyCon tc = return () + | isUnLiftedTyCon tc = return () + | otherwise = do + tc' <- maybeV (lookupTyCon tc) + if tc == tc' then return () else noV +