projects / ghc-hetmet.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Add RdrEnv to vectorisation state
[ghc-hetmet.git] / compiler / vectorise / VectMonad.hs
diff --git a/compiler/vectorise/VectMonad.hs b/compiler/vectorise/VectMonad.hs
index 944f8c8..56efb2b 100644 (file)
--- a/compiler/vectorise/VectMonad.hs
+++ b/compiler/vectorise/VectMonad.hs
@@ -3,7 +3,8 @@ module VectMonad (
   VM,
 
   noV, tryV, maybeV, orElseV, fixV, localV, closedV, initV,
-  cloneName, newExportedVar, newLocalVar, newTyVar,
+  cloneName, cloneId,
+  newExportedVar, newLocalVar, newDummyVar, newTyVar,
   
   Builtins(..), paDictTyCon, paDictDataCon,
   builtin,
@@ -15,9 +16,12 @@ module VectMonad (
   LocalEnv(..),
   readLEnv, setLEnv, updLEnv,
 
+  getBindName, inBind,
+
   lookupVar, defGlobalVar,
   lookupTyCon, defTyCon,
   lookupDataCon, defDataCon,
+  lookupTyConPA, defTyConPA,
   lookupTyVarPA, defLocalTyVar, defLocalTyVarWithPA, localTyVars,
 
   lookupInst, lookupFamInst
@@ -37,6 +41,8 @@ import Id
 import OccName
 import Name
 import NameEnv
+import TysPrim       ( intPrimTy )
+import RdrName
 
 import DsMonad
 import PrelNames
@@ -67,6 +73,7 @@ data Builtins = Builtins {
                 , lengthPAVar      :: Var
                 , replicatePAVar   :: Var
                 , emptyPAVar       :: Var
+                , liftingContext   :: Var
                 }
 
 paDictTyCon :: Builtins -> TyCon
@@ -90,6 +97,9 @@ initBuiltins
       replicatePAVar   <- dsLookupGlobalId replicatePAName
       emptyPAVar       <- dsLookupGlobalId emptyPAName
 
+      liftingContext <- liftM (\u -> mkSysLocal FSLIT("lc") u intPrimTy)
+                              newUnique
+
       return $ Builtins {
                  parrayTyCon      = parrayTyCon
                , paClass          = paClass
@@ -101,12 +111,13 @@ initBuiltins
                , lengthPAVar      = lengthPAVar
                , replicatePAVar   = replicatePAVar
                , emptyPAVar       = emptyPAVar
+               , liftingContext   = liftingContext
                }
 
 data GlobalEnv = GlobalEnv {
                   -- Mapping from global variables to their vectorised versions.
                   -- 
-                  global_vars :: VarEnv CoreExpr
+                  global_vars :: VarEnv Var
 
                   -- Exported variables which have a vectorised version
                   --
@@ -122,6 +133,10 @@ data GlobalEnv = GlobalEnv {
                   --
                 , global_datacons :: NameEnv DataCon
 
+                  -- Mapping from TyCons to their PA dfuns
+                  --
+                , global_pa_funs :: NameEnv Var
+
                 -- External package inst-env & home-package inst-env for class
                 -- instances
                 --
@@ -134,13 +149,17 @@ data GlobalEnv = GlobalEnv {
 
                 -- Hoisted bindings
                 , global_bindings :: [(Var, CoreExpr)]
+
+                  -- Global Rdr environment (from ModGuts)
+                  --
+                , global_rdr_env :: GlobalRdrEnv
                 }
 
 data LocalEnv = LocalEnv {
                  -- Mapping from local variables to their vectorised and
                  -- lifted versions
                  --
-                 local_vars :: VarEnv (CoreExpr, CoreExpr)
+                 local_vars :: VarEnv (Var, Var)
 
                  -- In-scope type variables
                  --
@@ -148,21 +167,27 @@ data LocalEnv = LocalEnv {
 
                  -- Mapping from tyvars to their PA dictionaries
                , local_tyvar_pa :: VarEnv CoreExpr
+
+                 -- Local binding name
+               , local_bind_name :: FastString
                }
               
 
-initGlobalEnv :: VectInfo -> (InstEnv, InstEnv) -> FamInstEnvs -> Builtins -> GlobalEnv
-initGlobalEnv info instEnvs famInstEnvs bi
+initGlobalEnv :: VectInfo -> (InstEnv, InstEnv) -> FamInstEnvs -> Builtins -> GlobalRdrEnv
+              -> GlobalEnv
+initGlobalEnv info instEnvs famInstEnvs bi rdr_env
   = GlobalEnv {
-      global_vars          = mapVarEnv  (Var . snd) $ vectInfoVar   info
+      global_vars          = mapVarEnv snd $ vectInfoVar info
     , global_exported_vars = emptyVarEnv
     , global_tycons        = extendNameEnv (mapNameEnv snd (vectInfoTyCon info))
                                            (tyConName funTyCon) (closureTyCon bi)
                               
     , global_datacons      = mapNameEnv snd $ vectInfoDataCon info
+    , global_pa_funs       = mapNameEnv snd $ vectInfoPADFun info
     , global_inst_env      = instEnvs
     , global_fam_inst_env  = famInstEnvs
     , global_bindings      = []
+    , global_rdr_env       = rdr_env
     }
 
 setInstEnvs :: InstEnv -> FamInstEnv -> GlobalEnv -> GlobalEnv
@@ -176,6 +201,7 @@ emptyLocalEnv = LocalEnv {
                    local_vars     = emptyVarEnv
                  , local_tyvars   = []
                  , local_tyvar_pa = emptyVarEnv
+                 , local_bind_name  = FSLIT("fn")
                  }
 
 -- FIXME
@@ -185,6 +211,7 @@ updVectInfo env tyenv info
       vectInfoVar     = global_exported_vars env
     , vectInfoTyCon   = mk_env typeEnvTyCons global_tycons
     , vectInfoDataCon = mk_env typeEnvDataCons global_datacons
+    , vectInfoPADFun  = mk_env typeEnvTyCons global_pa_funs
     }
   where
     mk_env from_tyenv from_env = mkNameEnv [(name, (from,to))
@@ -207,6 +234,9 @@ instance Monad VM where
 noV :: VM a
 noV = VM $ \_ _ _ -> return No
 
+traceNoV :: String -> SDoc -> VM a
+traceNoV s d = pprTrace s d noV
+
 tryV :: VM a -> VM (Maybe a)
 tryV (VM p) = VM $ \bi genv lenv ->
   do
@@ -218,6 +248,9 @@ tryV (VM p) = VM $ \bi genv lenv ->
 maybeV :: VM (Maybe a) -> VM a
 maybeV p = maybe noV return =<< p
 
+traceMaybeV :: String -> SDoc -> VM (Maybe a) -> VM a
+traceMaybeV s d p = maybe (traceNoV s d) return =<< p
+
 orElseV :: VM a -> VM a -> VM a
 orElseV p q = maybe q return =<< tryV p
 
@@ -236,7 +269,7 @@ localV p = do
 closedV :: VM a -> VM a
 closedV p = do
               env <- readLEnv id
-              setLEnv emptyLocalEnv
+              setLEnv (emptyLocalEnv { local_bind_name = local_bind_name env })
               x <- p
               setLEnv env
               return x
@@ -271,6 +304,14 @@ getInstEnv = readGEnv global_inst_env
 getFamInstEnv :: VM FamInstEnvs
 getFamInstEnv = readGEnv global_fam_inst_env
 
+getBindName :: VM FastString
+getBindName = readLEnv local_bind_name
+
+inBind :: Id -> VM a -> VM a
+inBind id p
+  = do updLEnv $ \env -> env { local_bind_name = occNameFS (getOccName id) }
+       p
+
 cloneName :: (OccName -> OccName) -> Name -> VM Name
 cloneName mk_occ name = liftM make (liftDs newUnique)
   where
@@ -281,6 +322,14 @@ cloneName mk_occ name = liftM make (liftDs newUnique)
                                                     (nameSrcSpan name)
            | otherwise           = mkSystemName u occ_name
 
+cloneId :: (OccName -> OccName) -> Id -> Type -> VM Id
+cloneId mk_occ id ty
+  = do
+      name <- cloneName mk_occ (getName id)
+      let id' | isExportedId id = Id.mkExportedLocalId name ty
+              | otherwise       = Id.mkLocalId         name ty
+      return id'
+
 newExportedVar :: OccName -> Type -> VM Var
 newExportedVar occ_name ty 
   = do
@@ -297,6 +346,9 @@ newLocalVar fs ty
       u <- liftDs newUnique
       return $ mkSysLocal fs u ty
 
+newDummyVar :: Type -> VM Var
+newDummyVar = newLocalVar FSLIT("ds")
+
 newTyVar :: FastString -> Kind -> VM Var
 newTyVar fs k
   = do
@@ -305,21 +357,22 @@ newTyVar fs k
 
 defGlobalVar :: Var -> Var -> VM ()
 defGlobalVar v v' = updGEnv $ \env ->
-  env { global_vars = extendVarEnv (global_vars env) v (Var v')
+  env { global_vars = extendVarEnv (global_vars env) v v'
       , global_exported_vars = upd (global_exported_vars env)
       }
   where
     upd env | isExportedId v = extendVarEnv env v (v, v')
             | otherwise      = env
 
-lookupVar :: Var -> VM (Scope CoreExpr (CoreExpr, CoreExpr))
+lookupVar :: Var -> VM (Scope Var (Var, Var))
 lookupVar v
   = do
       r <- readLEnv $ \env -> lookupVarEnv (local_vars env) v
       case r of
         Just e  -> return (Local e)
         Nothing -> liftM Global
-                 $  maybeV (readGEnv $ \env -> lookupVarEnv (global_vars env) v)
+                 $  traceMaybeV "lookupVar" (ppr v)
+                                (readGEnv $ \env -> lookupVarEnv (global_vars env) v)
 
 lookupTyCon :: TyCon -> VM (Maybe TyCon)
 lookupTyCon tc
@@ -338,6 +391,13 @@ defDataCon :: DataCon -> DataCon -> VM ()
 defDataCon dc dc' = updGEnv $ \env ->
   env { global_datacons = extendNameEnv (global_datacons env) (dataConName dc) dc' }
 
+lookupTyConPA :: TyCon -> VM (Maybe Var)
+lookupTyConPA tc = readGEnv $ \env -> lookupNameEnv (global_pa_funs env) (tyConName tc)
+
+defTyConPA :: TyCon -> Var -> VM ()
+defTyConPA tc pa = updGEnv $ \env ->
+  env { global_pa_funs = extendNameEnv (global_pa_funs env) (tyConName tc) pa }
+
 lookupTyVarPA :: Var -> VM (Maybe CoreExpr)
 lookupTyVarPA tv = readLEnv $ \env -> lookupVarEnv (local_tyvar_pa env) tv 
 
@@ -376,7 +436,7 @@ lookupInst cls tys
              where
                inst_tys'  = [ty | Right ty <- inst_tys]
                noFlexiVar = all isRight inst_tys
-          _other         -> noV
+          _other         -> traceNoV "lookupInst" (ppr cls <+> ppr tys)
        }
   where
     isRight (Left  _) = False
@@ -426,7 +486,11 @@ initV hsc_env guts info p
     go instEnvs famInstEnvs = 
       do
         builtins <- initBuiltins
-        r <- runVM p builtins (initGlobalEnv info instEnvs famInstEnvs builtins) 
+        r <- runVM p builtins (initGlobalEnv info
+                                             instEnvs
+                                             famInstEnvs
+                                             builtins
+                                             (mg_rdr_env guts))
                    emptyLocalEnv
         case r of
           Yes genv _ x -> return $ Just (new_info genv, x)
Glasgow Haskell Compiler with heterogeneous metaprogramming (generalized arrows and modal types)