module VectType ( vectTyCon, vectType, vectTypeEnv,
mkRepr, arrShapeTys, arrShapeVars, arrSelector,
- PAInstance, buildPADict )
+ PAInstance, buildPADict,
+ fromVect )
where
-#include "HsVersions.h"
-
import VectMonad
import VectUtils
import VectCore
import Digraph ( SCC(..), stronglyConnComp )
import Outputable
+import FastString
import Control.Monad ( liftM, liftM2, zipWithM, zipWithM_, mapAndUnzipM )
import Data.List ( inits, tails, zipWith4, zipWith5 )
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
vectType ty = pprPanic "vectType:" (ppr ty)
+vectAndBoxType :: Type -> VM Type
+vectAndBoxType ty = vectType ty >>= boxType
+
+-- ----------------------------------------------------------------------------
+-- 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
enumRepr :: VM Repr
enumRepr
= do
- (arr_tycon, _) <- parrayReprTyCon intTy
+ tycon <- builtin enumerationTyCon
+ let [data_con] = tyConDataCons tycon
+ (arr_tycon, _) <- parrayReprTyCon (mkTyConApp tycon [])
let [arr_data_con] = tyConDataCons arr_tycon
return $ EnumRepr {
, enum_arr_tycon = arr_tycon
, enum_arr_data_con = arr_data_con
}
- where
- tycon = intTyCon
- data_con = intDataCon
unboxedProductRepr :: [Type] -> VM Repr
unboxedProductRepr [] = voidRepr
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 {
arrReprType = mkPArrayType . reprType
arrShapeTys :: Repr -> VM [Type]
-arrShapeTys (SumRepr {})
- = do
- int_arr <- builtin parrayIntPrimTyCon
- return [intPrimTy, mkTyConApp int_arr [], mkTyConApp int_arr []]
+arrShapeTys (SumRepr {}) = sumShapeTys
arrShapeTys (ProdRepr {}) = return [intPrimTy]
arrShapeTys (IdRepr _) = return []
arrShapeTys (VoidRepr {}) = return [intPrimTy]
-arrShapeTys (EnumRepr {}) = return [intPrimTy]
+arrShapeTys (EnumRepr {}) = sumShapeTys
+
+sumShapeTys :: VM [Type]
+sumShapeTys = do
+ int_arr <- builtin intPrimArrayTy
+ return [intPrimTy, int_arr, int_arr]
+
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]
-replicateShape (SumRepr {}) len tag
+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]
-replicateShape (IdRepr _) _ _ = return []
-replicateShape (VoidRepr {}) len _ = return [len]
-replicateShape (EnumRepr {}) len _ = return [len]
-arrSelector :: Repr -> [a] -> a
-arrSelector (SumRepr {}) [_, sel, _] = sel
-arrSelector _ _ = panic "arrSelector"
+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)
emptyArrRepr :: Repr -> VM [CoreExpr]
emptyArrRepr (SumRepr { sum_components = prods })
emptyArrRepr (VoidRepr { void_tycon = tycon })
= liftM singleton $ emptyPA (mkTyConApp tycon [])
emptyArrRepr (EnumRepr { enum_tycon = tycon })
- = liftM singleton $ emptyPA (mkTyConApp tycon [])
+ = return []
arrReprTys :: Repr -> VM [Type]
arrReprTys (SumRepr { sum_components = reprs })
arrReprTys (VoidRepr { void_tycon = tycon })
= liftM singleton $ mkPArrayType (mkTyConApp tycon [])
arrReprTys (EnumRepr {})
- = liftM singleton $ mkPArrayType intPrimTy
+ = return []
arrReprTys' :: Repr -> VM [[Type]]
arrReprTys' (SumRepr { sum_components = reprs })
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
| [tys] <- rep_tys = boxedProductRepr tys
- | all null rep_tys = enumRepr
+ -- | all null rep_tys = enumRepr
| otherwise = sumRepr =<< mapM unboxedProductRepr rep_tys
where
rep_tys = map dataConRepArgTys $ tyConDataCons vect_tc
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
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
+ var <- newLocalVar (fsLit "y") ty
return ([var], Var var)
to_unboxed (VoidRepr { void_bottom = bottom })
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
, sum_tycon = tycon })
expr
= do
- vars <- mapM (newLocalVar FSLIT("x")) (map reprType prods)
+ 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
from_repr repr@(EnumRepr { enum_data_con = data_con }) expr
= do
- var <- newLocalVar FSLIT("n") intPrimTy
+ var <- newLocalVar (fsLit "n") intPrimTy
let res = Case (Var var) (mkWildId intPrimTy) res_ty
$ (DEFAULT, [], error_expr)
con
expr
= do
- vars <- mapM (newLocalVar FSLIT("y")) tys
+ vars <- mapM (newLocalVar (fsLit "y")) tys
return $ Case expr (mkWildId (reprType prod)) res_ty
[(DataAlt data_con, vars, con `mkVarApps` vars)]
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)
. mkConApp data_con
$ map Type tys ++ map Var (len_var : repr_vars)
- to_repr [len_var]
- [[repr_var]]
+ to_repr shape_vars
+ _
(EnumRepr { enum_arr_tycon = tycon
, enum_arr_data_con = data_con })
= return . wrapFamInstBody tycon []
- $ mkConApp data_con [Var len_var, Var repr_var]
+ . mkConApp data_con
+ $ map Var shape_vars
to_prod repr_vars@(r : _)
(ProdRepr { prod_components = tys@(ty : _)
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
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
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
from_prod (EnumRepr { enum_arr_tycon = tycon
, enum_arr_data_con = data_con })
expr
- [len_var]
- [repr_var]
+ shape_vars
+ _
res_ty
body
= let scrut = unwrapFamInstScrut tycon [] expr
scrut_ty = mkTyConApp tycon []
in
return $ Case scrut (mkWildId scrut_ty) res_ty
- [(DataAlt data_con, [len_var, repr_var], body)]
+ [(DataAlt data_con, shape_vars, body)]
from_prod (IdRepr ty)
expr
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
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 = [(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
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 ty = 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
+
projects / ghc-hetmet.git / blobdiff