X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=compiler%2Fvectorise%2FVectorise.hs;h=20f19b6037022c299e98211b10ccde2900389866;hb=abaea16d603c0cc167df4c873e0e7e57697ba736;hp=6f9db0aef58738cfbcd8fe8b027396d0d8151483;hpb=5e979164079ae89ca01483131149b8727dd82686;p=ghc-hetmet.git

diff --git a/compiler/vectorise/Vectorise.hs b/compiler/vectorise/Vectorise.hs
index 6f9db0a..20f19b6 100644
--- a/compiler/vectorise/Vectorise.hs
+++ b/compiler/vectorise/Vectorise.hs
@@ -28,7 +28,8 @@ import PrelNames
 
 import Outputable
 import FastString
-import Control.Monad        ( liftM, liftM2, mapAndUnzipM )
+import Control.Monad        ( liftM, liftM2, mapAndUnzipM, zipWithM_ )
+import Data.Maybe           ( maybeToList )
 
 vectorise :: HscEnv -> ModGuts -> IO ModGuts
 vectorise hsc_env guts
@@ -109,35 +110,98 @@ vectVar lc v = local v `orElseV` global v
                  vexpr <- maybeV (readGEnv $ \env -> lookupVarEnv (global_vars env) v)
                  lexpr <- replicateP vexpr lc
                  return (vexpr, lexpr)
+
+vectPolyVar :: CoreExpr -> Var -> [Type] -> VM (CoreExpr, CoreExpr)
+vectPolyVar lc v tys
+  = do
+      r <- readLEnv $ \env -> lookupVarEnv (local_vars env) v
+      case r of
+        Just (vexpr, lexpr) -> liftM2 (,) (mk_app vexpr) (mk_app lexpr)
+        Nothing ->
+          do
+            poly  <- maybeV (readGEnv $ \env -> lookupVarEnv (global_vars env) v)
+            vexpr <- mk_app poly
+            lexpr <- replicateP vexpr lc
+            return (vexpr, lexpr)
+  where
+    mk_app e = applyToTypes e =<< mapM vectType tys
+
+abstractOverTyVars :: [TyVar] -> ((CoreExpr -> CoreExpr) -> VM a) -> VM a
+abstractOverTyVars tvs p
+  = do
+      mdicts <- mapM mk_dict_var tvs
+      zipWithM_ (\tv -> maybe (deleteTyVarPA tv) (extendTyVarPA tv . Var)) tvs mdicts
+      p (mk_lams mdicts)
+  where
+    mk_dict_var tv = do
+                       r <- paDictArgType tv
+                       case r of
+                         Just ty -> liftM Just (newLocalVar FSLIT("dPA") ty)
+                         Nothing -> return Nothing
+
+    mk_lams mdicts = mkLams [arg | (tv, mdict) <- zip tvs mdicts
+                                 , arg <- tv : maybeToList mdict]
+
+applyToTypes :: CoreExpr -> [Type] -> VM CoreExpr
+applyToTypes expr tys
+  = do
+      dicts <- mapM paDictOfType tys
+      return $ mkApps expr [arg | (ty, dict) <- zip tys dicts
+                                , arg <- [Type ty, dict]]
+    
+
+vectPolyExpr :: CoreExpr -> CoreExprWithFVs -> VM (CoreExpr, CoreExpr)
+vectPolyExpr lc expr
+  = localV
+  . abstractOverTyVars tvs $ \mk_lams ->
+    -- FIXME: shadowing (tvs in lc)
+    do
+      (vmono, lmono) <- vectExpr lc mono
+      return $ (mk_lams vmono, mk_lams lmono)
+  where
+    (tvs, mono) = collectAnnTypeBinders expr  
                 
 vectExpr :: CoreExpr -> CoreExprWithFVs -> VM (CoreExpr, CoreExpr)
 vectExpr lc (_, AnnType ty)
   = do
       vty <- vectType ty
       return (Type vty, Type vty)
+
 vectExpr lc (_, AnnVar v)   = vectVar lc v
+
 vectExpr lc (_, AnnLit lit)
   = do
       let vexpr = Lit lit
       lexpr <- replicateP vexpr lc
       return (vexpr, lexpr)
+
 vectExpr lc (_, AnnNote note expr)
   = do
       (vexpr, lexpr) <- vectExpr lc expr
       return (Note note vexpr, Note note lexpr)
+
+vectExpr lc e@(_, AnnApp _ arg)
+  | isAnnTypeArg arg
+  = vectTyAppExpr lc fn tys
+  where
+    (fn, tys) = collectAnnTypeArgs e
+
 vectExpr lc (_, AnnApp fn arg)
   = do
       fn'  <- vectExpr lc fn
       arg' <- vectExpr lc arg
       capply fn' arg'
+
 vectExpr lc (_, AnnCase expr bndr ty alts)
   = panic "vectExpr: case"
+
 vectExpr lc (_, AnnLet (AnnNonRec bndr rhs) body)
   = do
-      (vrhs, lrhs) <- vectExpr lc rhs
+      (vrhs, lrhs) <- vectPolyExpr lc rhs
       (vbndr, lbndr, (vbody, lbody)) <- vectBndrIn bndr (vectExpr lc body)
       return (Let (NonRec vbndr vrhs) vbody,
               Let (NonRec lbndr lrhs) lbody)
+
 vectExpr lc (_, AnnLet (AnnRec prs) body)
   = do
       (vbndrs, lbndrs, (vrhss, vbody, lrhss, lbody)) <- vectBndrsIn bndrs vect
@@ -148,21 +212,15 @@ vectExpr lc (_, AnnLet (AnnRec prs) body)
     
     vect = do
              (vrhss, lrhss) <- mapAndUnzipM (vectExpr lc) rhss
-             (vbody, lbody) <- vectExpr lc body
+             (vbody, lbody) <- vectPolyExpr lc body
              return (vrhss, vbody, lrhss, lbody)
-vectExpr lc (_, AnnLam bndr body)
-  | isTyVar bndr
-  = do
-      r <- paDictArgType bndr
-      (upd_env, add_lam) <- get_upd r
-      (vbody, lbody) <- localV (upd_env >> vectExpr lc body)
-      return (Lam bndr (add_lam vbody), Lam bndr (add_lam lbody))
-  where
-    get_upd Nothing = return (deleteTyVarPA bndr, id)
-    get_upd (Just pa_ty) = do
-                             pa_var <- newLocalVar FSLIT("dPA") pa_ty
-                             return (extendTyVarPA bndr (Var pa_var),
-                                     Lam pa_var)
+
+vectExpr lc e@(_, AnnLam bndr body)
+  | isTyVar bndr = pprPanic "vectExpr" (ppr $ deAnnotate e)
+
+vectTyAppExpr :: CoreExpr -> CoreExprWithFVs -> [Type] -> VM (CoreExpr, CoreExpr)
+vectTyAppExpr lc (_, AnnVar v) tys = vectPolyVar lc v tys
+vectTyAppExpr lc e tys = pprPanic "vectTyAppExpr" (ppr $ deAnnotate e)
 
 -- ----------------------------------------------------------------------------
 -- Types