X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=compiler%2Fvectorise%2FVectType.hs;h=79e37fc22d9b592783179309a214e7becf6432f1;hb=7744453856bd776673d685216b666bb0d7c2f6f6;hp=2f4ca2f6016196c18c195a3b3efce9c641ccb6d0;hpb=51ad52d4f7d259b500543404f419ff62456e2097;p=ghc-hetmet.git

diff --git a/compiler/vectorise/VectType.hs b/compiler/vectorise/VectType.hs
index 2f4ca2f..79e37fc 100644
--- a/compiler/vectorise/VectType.hs
+++ b/compiler/vectorise/VectType.hs
@@ -7,11 +7,10 @@
 
 module VectType ( vectTyCon, vectType, vectTypeEnv,
                   mkRepr, arrShapeTys, arrShapeVars, arrSelector,
-                  PAInstance, buildPADict )
+                  PAInstance, buildPADict,
+                  fromVect )
 where
 
-#include "HsVersions.h"
-
 import VectMonad
 import VectUtils
 import VectCore
@@ -44,6 +43,7 @@ import Util              ( singleton )
 import Digraph           ( SCC(..), stronglyConnComp )
 
 import Outputable
+import FastString
 
 import Control.Monad  ( liftM, liftM2, zipWithM, zipWithM_, mapAndUnzipM )
 import Data.List      ( inits, tails, zipWith4, zipWith5 )
@@ -70,7 +70,7 @@ 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
@@ -81,6 +81,23 @@ vectType ty@(ForAllTy _ _)
 
 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
 
@@ -260,7 +277,9 @@ voidRepr
 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 {
@@ -269,9 +288,6 @@ 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
@@ -284,7 +300,8 @@ boxedProductRepr tys
       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 {
@@ -340,32 +357,38 @@ arrReprType :: Repr -> VM Type
 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 })
@@ -379,7 +402,7 @@ emptyArrRepr (IdRepr ty)
 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 })
@@ -393,7 +416,7 @@ arrReprTys (IdRepr ty)
 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 })
@@ -402,12 +425,12 @@ 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
   | [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
@@ -418,7 +441,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
@@ -460,12 +483,12 @@ buildToPRepr repr vect_tc prepr_tc _
     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 })
@@ -476,7 +499,7 @@ 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
@@ -492,7 +515,7 @@ buildFromPRepr repr vect_tc prepr_tc _
                             , 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
@@ -502,7 +525,7 @@ buildFromPRepr repr vect_tc prepr_tc _
 
     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)
@@ -524,7 +547,7 @@ buildFromPRepr repr vect_tc prepr_tc _
               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)]
 
@@ -538,7 +561,7 @@ 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)
 
@@ -589,12 +612,13 @@ buildToArrPRepr repr vect_tc prepr_tc arr_tc
                 . 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 : _)
@@ -614,7 +638,7 @@ 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
 
@@ -650,7 +674,7 @@ 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
@@ -663,7 +687,7 @@ 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
@@ -690,15 +714,15 @@ buildFromArrPRepr repr vect_tc prepr_tc arr_tc
     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
@@ -856,7 +880,7 @@ vectDataConWorkers repr orig_tc vect_tc arr_tc
     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
@@ -913,11 +937,11 @@ 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 = [(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
@@ -983,3 +1007,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 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
+