X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=compiler%2Fvectorise%2FVectType.hs;h=9952121eae07f5cd92806ed88507e0895dcb8392;hb=90ce88a0a9b5611416e592a6ff96781ba884975f;hp=79e37fc22d9b592783179309a214e7becf6432f1;hpb=eed46085e70d1bfbc0f85996821b5d8002278278;p=ghc-hetmet.git diff --git a/compiler/vectorise/VectType.hs b/compiler/vectorise/VectType.hs index 79e37fc..9952121 100644 --- a/compiler/vectorise/VectType.hs +++ b/compiler/vectorise/VectType.hs @@ -1,13 +1,7 @@ -{-# OPTIONS -w #-} --- The above warning supression flag is a temporary kludge. --- While working on this module you are encouraged to remove it and fix --- any warnings in the module. See --- http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#Warnings --- for details - -module VectType ( vectTyCon, vectType, vectTypeEnv, + +module VectType ( vectTyCon, vectAndLiftType, vectType, vectTypeEnv, mkRepr, arrShapeTys, arrShapeVars, arrSelector, - PAInstance, buildPADict, + buildPADict, fromVect ) where @@ -18,6 +12,7 @@ import VectCore import HscTypes ( TypeEnv, extendTypeEnvList, typeEnvTyCons ) import CoreSyn import CoreUtils +import MkCore ( mkWildCase ) import BuildTyCl import DataCon import TyCon @@ -25,12 +20,10 @@ 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 @@ -39,8 +32,8 @@ import TysPrim ( intPrimTy ) import Unique import UniqFM import UniqSet -import Util ( singleton ) -import Digraph ( SCC(..), stronglyConnComp ) +import Util +import Digraph ( SCC(..), stronglyConnCompFromEdgedVertices ) import Outputable import FastString @@ -56,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' @@ -75,15 +77,18 @@ 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 @@ -103,13 +108,6 @@ boxType ty = return ty 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 @@ -147,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 @@ -180,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 @@ -209,7 +203,8 @@ vectDataCon dc [] -- no existential tvs for now [] -- no eq spec for now [] -- no context - arg_tys + arg_tys + (mkFamilyTyConApp tycon' (mkTyVarTys univ_tvs)) tycon' where name = dataConName dc @@ -230,6 +225,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 @@ -274,6 +270,7 @@ voidRepr , void_bottom = Var var } +{- enumRepr :: VM Repr enumRepr = do @@ -288,6 +285,7 @@ enumRepr , enum_arr_tycon = arr_tycon , enum_arr_data_con = arr_data_con } +-} unboxedProductRepr :: [Type] -> VM Repr unboxedProductRepr [] = voidRepr @@ -389,6 +387,7 @@ replicateSumShape len tag 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 }) @@ -401,7 +400,7 @@ emptyArrRepr (IdRepr ty) = liftM singleton $ emptyPA ty emptyArrRepr (VoidRepr { void_tycon = tycon }) = liftM singleton $ emptyPA (mkTyConApp tycon []) -emptyArrRepr (EnumRepr { enum_tycon = tycon }) +emptyArrRepr (EnumRepr {}) = return [] arrReprTys :: Repr -> VM [Type] @@ -430,7 +429,7 @@ arrReprVars repr mkRepr :: TyCon -> VM Repr mkRepr vect_tc | [tys] <- rep_tys = boxedProductRepr tys - -- | all null rep_tys = enumRepr + -- removed: | all null rep_tys = enumRepr | otherwise = sumRepr =<< mapM unboxedProductRepr rep_tys where rep_tys = map dataConRepArgTys $ tyConDataCons vect_tc @@ -460,7 +459,7 @@ buildToPRepr repr vect_tc prepr_tc _ expr = do (vars, bodies) <- mapAndUnzipM to_unboxed prods - return . Case expr (mkWildId (exprType expr)) res_ty + return . mkWildCase expr (exprType expr) res_ty $ zipWith4 mk_alt cons vars (tyConDataCons tycon) bodies where mk_alt con vars sum_con body @@ -469,7 +468,7 @@ buildToPRepr repr vect_tc prepr_tc _ ty_args = map (Type . reprType) prods to_repr (EnumRepr { enum_data_con = data_con }) expr - = return . Case expr (mkWildId (exprType expr)) res_ty + = return . mkWildCase expr (exprType expr) res_ty $ map mk_alt cons where mk_alt con = (DataAlt con, [], mkConApp data_con [mkDataConTag con]) @@ -477,7 +476,7 @@ buildToPRepr repr vect_tc prepr_tc _ to_repr prod expr = do (vars, body) <- to_unboxed prod - return $ Case expr (mkWildId (exprType expr)) res_ty + return $ mkWildCase expr (exprType expr) res_ty [(DataAlt con, vars, body)] to_unboxed (ProdRepr { prod_components = tys @@ -494,6 +493,8 @@ buildToPRepr repr vect_tc prepr_tc _ 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 _ @@ -518,7 +519,7 @@ buildFromPRepr repr vect_tc prepr_tc _ 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) @@ -527,11 +528,11 @@ buildFromPRepr repr vect_tc prepr_tc _ = do var <- newLocalVar (fsLit "n") intPrimTy - let res = Case (Var var) (mkWildId intPrimTy) res_ty + let res = mkWildCase (Var var) intPrimTy res_ty $ (DEFAULT, [], error_expr) : zipWith mk_alt (tyConDataCons vect_tc) cons - return $ Case expr (mkWildId (reprType repr)) res_ty + return $ mkWildCase expr (reprType repr) res_ty [(DataAlt data_con, [var], res)] where mk_alt data_con con = (LitAlt (mkDataConTagLit data_con), [], con) @@ -548,15 +549,17 @@ buildFromPRepr repr vect_tc prepr_tc _ expr = do vars <- mapM (newLocalVar (fsLit "y")) tys - return $ Case expr (mkWildId (reprType prod)) res_ty + 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 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 @@ -581,7 +584,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 @@ -589,7 +592,7 @@ 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 @@ -620,6 +623,8 @@ buildToArrPRepr repr vect_tc prepr_tc arr_tc . mkConApp data_con $ map Var shape_vars + to_repr _ _ _ = panic "buildToArrPRepr/to_repr" + to_prod repr_vars@(r : _) (ProdRepr { prod_components = tys@(ty : _) , prod_arr_tycon = tycon @@ -630,8 +635,9 @@ buildToArrPRepr repr vect_tc prepr_tc arr_tc . mkConApp data_con $ map Type tys ++ len : map Var repr_vars - to_prod [var] (IdRepr ty) = return (Var var) + 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 @@ -678,7 +684,7 @@ buildFromArrPRepr repr vect_tc prepr_tc arr_tc 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 @@ -691,13 +697,16 @@ buildFromArrPRepr repr vect_tc prepr_tc arr_tc 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 @@ -706,9 +715,8 @@ 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 @@ -721,25 +729,27 @@ buildFromArrPRepr repr vect_tc prepr_tc arr_tc = let scrut = unwrapFamInstScrut tycon [] expr scrut_ty = mkTyConApp tycon [] in - return $ Case scrut (mkWildId scrut_ty) res_ty + return $ mkWildCase scrut scrut_ty res_ty [(DataAlt data_con, shape_vars, body)] - from_prod (IdRepr ty) + from_prod (IdRepr _) expr - shape_vars + _shape_vars [repr_var] - res_ty + _res_ty body = return $ Let (NonRec repr_var expr) body from_prod (VoidRepr {}) expr - shape_vars + _shape_vars [repr_var] - res_ty + _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 @@ -817,16 +827,18 @@ buildPArrayDataCon orig_name vect_tc repr_tc repr_tys <- arrReprTys repr let tys = shape_tys ++ repr_tys + tvs = tyConTyVars vect_tc liftDs $ buildDataCon dc_name False -- not infix (map (const NotMarkedStrict) tys) [] -- no field labels - (tyConTyVars vect_tc) + tvs [] -- no existentials [] -- no eq spec [] -- no context tys + (mkFamilyTyConApp repr_tc (mkTyVarTys tvs)) repr_tc mkPADFun :: TyCon -> VM Var @@ -842,12 +854,6 @@ buildTyConBindings orig_tc vect_tc prepr_tc arr_tc dfun 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 () @@ -899,7 +905,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 @@ -916,7 +922,7 @@ vectDataConWorkers repr orig_tc vect_tc arr_tc orig_worker = dataConWorkId data_con 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 @@ -937,6 +943,7 @@ buildPADict repr vect_tc prepr_tc arr_tc dfun var <- newLocalVar name (exprType body) return (var, mkInlineMe body) +paMethods :: [(FastString, Repr -> TyCon -> TyCon -> TyCon -> VM CoreExpr)] paMethods = [(fsLit "toPRepr", buildToPRepr), (fsLit "fromPRepr", buildFromPRepr), (fsLit "toArrPRepr", buildToArrPRepr), @@ -954,7 +961,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 @@ -973,7 +980,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] @@ -990,7 +997,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 @@ -1035,7 +1042,7 @@ identityConv (TyConApp tycon tys) = do mapM_ identityConv tys identityConvTyCon tycon -identityConv ty = noV +identityConv _ = noV identityConvTyCon :: TyCon -> VM () identityConvTyCon tc