Utility functions for vectorisation

[ghc-hetmet.git] / compiler / vectorise / VectUtils.hs

diff --git a/compiler/vectorise/VectUtils.hs b/compiler/vectorise/VectUtils.hs
index dbdc38f..2757cbc 100644 (file)
--- a/compiler/vectorise/VectUtils.hs
+++ b/compiler/vectorise/VectUtils.hs
@@ -3,6 +3,8 @@ module VectUtils (
   collectAnnValBinders,
   mkDataConTag,
   splitClosureTy,
+  mkPlusType, mkPlusTypes, mkCrossType, mkCrossTypes, mkEmbedType,
+  mkPlusAlts, mkCrosses, mkEmbed,
   mkPADictType, mkPArrayType,
   parrayReprTyCon, parrayReprDataCon, mkVScrut,
   paDictArgType, paDictOfType, paDFunType,
@@ -84,31 +86,101 @@ splitPArrayTy ty
 
   | otherwise = pprPanic "splitPArrayTy" (ppr ty)
 
-mkClosureType :: Type -> Type -> VM Type
-mkClosureType arg_ty res_ty
+mkBuiltinTyConApp :: (Builtins -> TyCon) -> [Type] -> VM Type
+mkBuiltinTyConApp get_tc tys
   = do
-      tc <- builtin closureTyCon
-      return $ mkTyConApp tc [arg_ty, res_ty]
+      tc <- builtin get_tc
+      return $ mkTyConApp tc tys
 
-mkClosureTypes :: [Type] -> Type -> VM Type
-mkClosureTypes arg_tys res_ty
+mkBuiltinTyConApps :: (Builtins -> TyCon) -> [Type] -> Type -> VM Type
+mkBuiltinTyConApps get_tc tys ty
   = do
-      tc <- builtin closureTyCon
-      return $ foldr (mk tc) res_ty arg_tys
+      tc <- builtin get_tc
+      return $ foldr (mk tc) ty tys
   where
-    mk tc arg_ty res_ty = mkTyConApp tc [arg_ty, res_ty]
+    mk tc ty1 ty2 = mkTyConApp tc [ty1,ty2]
 
-mkPADictType :: Type -> VM Type
-mkPADictType ty
+mkBuiltinTyConApps1 :: (Builtins -> TyCon) -> Type -> [Type] -> VM Type
+mkBuiltinTyConApps1 get_tc dft [] = return dft
+mkBuiltinTyConApps1 get_tc dft tys
   = do
-      tc <- builtin paTyCon
-      return $ TyConApp tc [ty]
+      tc <- builtin get_tc
+      case tys of
+        [] -> pprPanic "mkBuiltinTyConApps1" (ppr tc)
+        _  -> return $ foldr1 (mk tc) tys
+  where
+    mk tc ty1 ty2 = mkTyConApp tc [ty1,ty2]
 
-mkPArrayType :: Type -> VM Type
-mkPArrayType ty
+mkBuiltinDataConApp :: (Builtins -> DataCon) -> [CoreExpr] -> VM CoreExpr
+mkBuiltinDataConApp get_dc args
   = do
-      tc <- builtin parrayTyCon
-      return $ TyConApp tc [ty]
+      dc <- builtin get_dc
+      return $ mkConApp dc args
+
+mkPlusType :: Type -> Type -> VM Type
+mkPlusType ty1 ty2 = mkBuiltinTyConApp plusTyCon [ty1, ty2]
+
+mkPlusTypes :: Type -> [Type] -> VM Type
+mkPlusTypes = mkBuiltinTyConApps1 plusTyCon
+
+mkPlusAlts :: [CoreExpr] -> VM [CoreExpr]
+mkPlusAlts [] = return []
+mkPlusAlts exprs
+  = do
+      plus_tc  <- builtin plusTyCon
+      left_dc  <- builtin leftDataCon
+      right_dc <- builtin rightDataCon
+
+      let go [expr] = ([expr], exprType expr)
+          go (expr : exprs)
+            | (alts, right_ty) <- go exprs
+            = (mkConApp left_dc [Type left_ty, Type right_ty, expr]
+               : [mkConApp right_dc [Type left_ty, Type right_ty, alt]
+                    | alt <- alts],
+               mkTyConApp plus_tc [left_ty, right_ty])
+            where
+              left_ty = exprType expr
+
+      return . fst $ go exprs
+
+mkCrossType :: Type -> Type -> VM Type
+mkCrossType ty1 ty2 = mkBuiltinTyConApp crossTyCon [ty1, ty2]
+
+mkCrossTypes :: Type -> [Type] -> VM Type
+mkCrossTypes = mkBuiltinTyConApps1 crossTyCon
+
+mkCrosses :: [CoreExpr] -> VM CoreExpr
+mkCrosses [] = return (Var unitDataConId)
+mkCrosses exprs
+  = do
+      cross_tc <- builtin crossTyCon
+      cross_dc <- builtin crossDataCon
+
+      let mk (left, left_ty) (right, right_ty)
+            = (mkConApp   cross_dc [Type left_ty, Type right_ty, left, right],
+               mkTyConApp cross_tc [left_ty, right_ty])
+
+      return . fst
+             $ foldr1 mk [(expr, exprType expr) | expr <- exprs]
+
+mkEmbedType :: Type -> VM Type
+mkEmbedType ty = mkBuiltinTyConApp embedTyCon [ty]
+
+mkEmbed :: CoreExpr -> VM CoreExpr
+mkEmbed expr = mkBuiltinDataConApp embedDataCon
+                                   [Type $ exprType expr, expr]
+
+mkClosureType :: Type -> Type -> VM Type
+mkClosureType arg_ty res_ty = mkBuiltinTyConApp closureTyCon [arg_ty, res_ty]
+
+mkClosureTypes :: [Type] -> Type -> VM Type
+mkClosureTypes = mkBuiltinTyConApps closureTyCon
+
+mkPADictType :: Type -> VM Type
+mkPADictType ty = mkBuiltinTyConApp paTyCon [ty]
+
+mkPArrayType :: Type -> VM Type
+mkPArrayType ty = mkBuiltinTyConApp parrayTyCon [ty]
 
 parrayReprTyCon :: Type -> VM (TyCon, [Type])
 parrayReprTyCon ty = builtin parrayTyCon >>= (`lookupFamInst` [ty])