X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=compiler%2Fvectorise%2FVectType.hs;h=85b9f2405dcd9916a1368896655d08d95018165e;hb=1708f829ebc88cab5dd0f11aa3c1dac805f32d9d;hp=40a04f9c9c7b19a440903f169b7e930fe72aa2c5;hpb=aa561d32377b691ac0d718a96f8803bd3b1c0801;p=ghc-hetmet.git diff --git a/compiler/vectorise/VectType.hs b/compiler/vectorise/VectType.hs index 40a04f9..85b9f24 100644 --- a/compiler/vectorise/VectType.hs +++ b/compiler/vectorise/VectType.hs @@ -8,20 +8,22 @@ import VectUtils import HscTypes ( TypeEnv, extendTypeEnvList, typeEnvTyCons ) import CoreSyn +import CoreUtils 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 ) +import TysWiredIn ( intTy, intDataCon ) import TysPrim ( intPrimTy ) import Unique @@ -31,7 +33,8 @@ import Digraph ( SCC(..), stronglyConnComp ) import Outputable -import Control.Monad ( liftM2, zipWithM, zipWithM_ ) +import Control.Monad ( liftM, liftM2, zipWithM, zipWithM_ ) +import Data.List ( inits, tails ) -- ---------------------------------------------------------------------------- -- Types @@ -71,6 +74,12 @@ vectType ty = pprPanic "vectType:" (ppr ty) type TyConGroup = ([TyCon], UniqSet TyCon) +data PAInstance = PAInstance { + painstInstance :: Instance + , painstVectTyCon :: TyCon + , painstArrTyCon :: TyCon + } + vectTypeEnv :: TypeEnv -> VM (TypeEnv, [FamInst], [Instance]) vectTypeEnv env = do @@ -252,8 +261,55 @@ buildPArrayDataCon orig_name vect_tc repr_tc types = [ty | dc <- tyConDataCons vect_tc , ty <- dataConRepArgTys dc] -buildLengthPA :: TyCon -> VM CoreExpr -buildLengthPA repr_tc +mkPAInstance :: TyCon -> TyCon -> VM PAInstance +mkPAInstance 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 + , painstVectTyCon = vect_tc + , painstArrTyCon = arr_tc + } + where + tvs = tyConTyVars arr_tc + arg_tys = mkTyVarTys tvs + +buildPADict :: PAInstance -> VM [(Var, CoreExpr)] +buildPADict (PAInstance { + painstInstance = inst + , painstVectTyCon = vect_tc + , painstArrTyCon = arr_tc }) + = localV . abstractOverTyVars (tyConTyVars arr_tc) $ \abstract -> + do + meth_binds <- mapM (mk_method abstract) paMethods + let meth_vars = map (Var . fst) meth_binds + meth_exprs <- mapM (`applyToTypes` arg_tys) meth_vars + + pa_dc <- builtin paDictDataCon + let dict = mkConApp pa_dc (Type (mkTyConApp vect_tc arg_tys) : meth_exprs) + return $ (instanceDFunId inst, dict) : meth_binds + where + tvs = tyConTyVars arr_tc + arg_tys = mkTyVarTys tvs + + mk_method abstract (name, build) + = localV + $ do + body <- liftM abstract $ build vect_tc arr_tc + var <- newLocalVar name (exprType body) + return (var, mkInlineMe body) + +paMethods = [(FSLIT("lengthPA"), buildLengthPA), + (FSLIT("replicatePA"), buildReplicatePA)] + +buildLengthPA :: TyCon -> TyCon -> VM CoreExpr +buildLengthPA _ arr_tc = do arg <- newLocalVar FSLIT("xs") arg_ty shape <- newLocalVar FSLIT("sel") shape_ty @@ -262,10 +318,79 @@ buildLengthPA repr_tc $ Case (Var arg) (mkWildId arg_ty) intPrimTy [(DataAlt repr_dc, shape : map mkWildId repr_tys, body)] where - arg_ty = mkTyConApp repr_tc . mkTyVarTys $ tyConTyVars repr_tc - [repr_dc] = tyConDataCons repr_tc + arg_ty = mkTyConApp arr_tc . mkTyVarTys $ tyConTyVars arr_tc + [repr_dc] = tyConDataCons arr_tc shape_ty : repr_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 :: TyCon -> TyCon -> VM CoreExpr +buildReplicatePA 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 <- replicatePA len (ctr_num val) + reprs <- liftM concat $ mapM (mk_comp_arrs len val) vect_dcs + + return . mkLams [len_var, val_var] + $ mkConApp arr_dc (map (Type . TyVarTy) (tyConTyVars arr_tc) ++ (shape : reprs)) + where + val_ty = mkTyConApp vect_tc . mkTyVarTys $ tyConTyVars arr_tc + 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 + [(DataAlt dc, pre ++ (var : post), rep), (DEFAULT, [], empty)] + -- | 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 -- information about the conversion status of external tycons: