Scope(..),
VM,
- noV, tryV, maybeV, orElseV, fixV, localV, closedV, initV,
+ noV, tryV, maybeV, traceMaybeV, orElseV, fixV, localV, closedV, initV,
+ liftDs,
cloneName, cloneId,
newExportedVar, newLocalVar, newDummyVar, newTyVar,
- Builtins(..), paDictTyCon, paDictDataCon,
+ Builtins(..),
builtin,
GlobalEnv(..),
- setInstEnvs,
+ setFamInstEnv,
readGEnv, setGEnv, updGEnv,
LocalEnv(..),
lookupVar, defGlobalVar,
lookupTyCon, defTyCon,
lookupDataCon, defDataCon,
- lookupTyConPA, defTyConPA,
+ lookupTyConPA, defTyConPA, defTyConPAs,
lookupTyVarPA, defLocalTyVar, defLocalTyVarWithPA, localTyVars,
- lookupInst, lookupFamInst
+ {-lookupInst,-} lookupFamInst
) where
#include "HsVersions.h"
+import VectBuiltIn
+
import HscTypes
import CoreSyn
-import Class
import TyCon
import DataCon
import Type
+import Class
import Var
import VarEnv
import Id
import Name
import NameEnv
import TysPrim ( intPrimTy )
-import RdrName
+import Module
+import IfaceEnv
import DsMonad
import PrelNames
import FastString
import SrcLoc ( noSrcSpan )
-import Control.Monad ( liftM )
+import Control.Monad ( liftM, zipWithM )
data Scope a b = Global a | Local b
-- ----------------------------------------------------------------------------
-- Vectorisation monad
-data Builtins = Builtins {
- parrayTyCon :: TyCon
- , paClass :: Class
- , closureTyCon :: TyCon
- , mkClosureVar :: Var
- , applyClosureVar :: Var
- , mkClosurePVar :: Var
- , applyClosurePVar :: Var
- , lengthPAVar :: Var
- , replicatePAVar :: Var
- , emptyPAVar :: Var
- , liftingContext :: Var
- }
-
-paDictTyCon :: Builtins -> TyCon
-paDictTyCon = classTyCon . paClass
-
-paDictDataCon :: Builtins -> DataCon
-paDictDataCon = classDataCon . paClass
-
-initBuiltins :: DsM Builtins
-initBuiltins
- = do
- parrayTyCon <- dsLookupTyCon parrayTyConName
- paClass <- dsLookupClass paClassName
- closureTyCon <- dsLookupTyCon closureTyConName
-
- mkClosureVar <- dsLookupGlobalId mkClosureName
- applyClosureVar <- dsLookupGlobalId applyClosureName
- mkClosurePVar <- dsLookupGlobalId mkClosurePName
- applyClosurePVar <- dsLookupGlobalId applyClosurePName
- lengthPAVar <- dsLookupGlobalId lengthPAName
- replicatePAVar <- dsLookupGlobalId replicatePAName
- emptyPAVar <- dsLookupGlobalId emptyPAName
-
- liftingContext <- liftM (\u -> mkSysLocal FSLIT("lc") u intPrimTy)
- newUnique
-
- return $ Builtins {
- parrayTyCon = parrayTyCon
- , paClass = paClass
- , closureTyCon = closureTyCon
- , mkClosureVar = mkClosureVar
- , applyClosureVar = applyClosureVar
- , mkClosurePVar = mkClosurePVar
- , applyClosurePVar = applyClosurePVar
- , lengthPAVar = lengthPAVar
- , replicatePAVar = replicatePAVar
- , emptyPAVar = emptyPAVar
- , liftingContext = liftingContext
- }
-
data GlobalEnv = GlobalEnv {
-- Mapping from global variables to their vectorised versions.
--
-- Hoisted bindings
, global_bindings :: [(Var, CoreExpr)]
-
- -- Global Rdr environment (from ModGuts)
- --
- , global_rdr_env :: GlobalRdrEnv
}
data LocalEnv = LocalEnv {
-- Local binding name
, local_bind_name :: FastString
}
-
-initGlobalEnv :: VectInfo -> (InstEnv, InstEnv) -> FamInstEnvs -> Builtins -> GlobalRdrEnv
- -> GlobalEnv
-initGlobalEnv info instEnvs famInstEnvs bi rdr_env
+initGlobalEnv :: VectInfo -> (InstEnv, InstEnv) -> FamInstEnvs -> GlobalEnv
+initGlobalEnv info instEnvs famInstEnvs
= GlobalEnv {
global_vars = mapVarEnv snd $ vectInfoVar info
, global_exported_vars = emptyVarEnv
- , global_tycons = extendNameEnv (mapNameEnv snd (vectInfoTyCon info))
- (tyConName funTyCon) (closureTyCon bi)
-
+ , global_tycons = mapNameEnv snd $ vectInfoTyCon info
, 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
-setInstEnvs l_inst l_fam_inst genv
- | (g_inst, _) <- global_inst_env genv
- , (g_fam_inst, _) <- global_fam_inst_env genv
- = genv { global_inst_env = (g_inst, l_inst)
- , global_fam_inst_env = (g_fam_inst, l_fam_inst) }
+setFamInstEnv :: FamInstEnv -> GlobalEnv -> GlobalEnv
+setFamInstEnv l_fam_inst genv
+ = genv { global_fam_inst_env = (g_fam_inst, l_fam_inst) }
+ where
+ (g_fam_inst, _) = global_fam_inst_env genv
+
+extendTyConsEnv :: [(Name, TyCon)] -> GlobalEnv -> GlobalEnv
+extendTyConsEnv ps genv
+ = genv { global_tycons = extendNameEnvList (global_tycons genv) ps }
+
+extendPAFunsEnv :: [(Name, Var)] -> GlobalEnv -> GlobalEnv
+extendPAFunsEnv ps genv
+ = genv { global_pa_funs = extendNameEnvList (global_pa_funs genv) ps }
emptyLocalEnv = LocalEnv {
local_vars = emptyVarEnv
= do updLEnv $ \env -> env { local_bind_name = occNameFS (getOccName id) }
p
-lookupRdrName :: RdrName -> VM Name
-lookupRdrName rdr_name
- = do
- rdr_env <- readGEnv global_rdr_env
- case lookupGRE_RdrName rdr_name rdr_env of
- [gre] -> return (gre_name gre)
- [] -> pprPanic "VectMonad.lookupRdrName: not found" (ppr rdr_name)
- _ -> pprPanic "VectMonad.lookupRdrName: ambiguous" (ppr rdr_name)
-
-lookupRdrVar :: RdrName -> VM Var
-lookupRdrVar rdr_name
- = do
- name <- lookupRdrName rdr_name
- liftDs (dsLookupGlobalId name)
-
cloneName :: (OccName -> OccName) -> Name -> VM Name
cloneName mk_occ name = liftM make (liftDs newUnique)
where
defTyConPA tc pa = updGEnv $ \env ->
env { global_pa_funs = extendNameEnv (global_pa_funs env) (tyConName tc) pa }
+defTyConPAs :: [(TyCon, Var)] -> VM ()
+defTyConPAs ps = updGEnv $ \env ->
+ env { global_pa_funs = extendNameEnvList (global_pa_funs env)
+ [(tyConName tc, pa) | (tc, pa) <- ps] }
+
lookupTyVarPA :: Var -> VM (Maybe CoreExpr)
lookupTyVarPA tv = readLEnv $ \env -> lookupVarEnv (local_tyvar_pa env) tv
-- instances head (i.e., no flexi vars); for details for what this means,
-- see the docs at InstEnv.lookupInstEnv.
--
+{-
lookupInst :: Class -> [Type] -> VM (DFunId, [Type])
lookupInst cls tys
= do { instEnv <- getInstEnv
where
isRight (Left _) = False
isRight (Right _) = True
+-}
-- Look up the representation tycon of a family instance.
--
go instEnvs famInstEnvs =
do
builtins <- initBuiltins
- r <- runVM p builtins (initGlobalEnv info
- instEnvs
- famInstEnvs
- builtins
- (mg_rdr_env guts))
- emptyLocalEnv
+ builtin_tycons <- initBuiltinTyCons
+ builtin_pas <- initBuiltinPAs
+
+ let genv = extendTyConsEnv builtin_tycons
+ . extendPAFunsEnv builtin_pas
+ $ initGlobalEnv info instEnvs famInstEnvs
+
+ r <- runVM p builtins genv emptyLocalEnv
case r of
Yes genv _ x -> return $ Just (new_info genv, x)
No -> return Nothing
projects / ghc-hetmet.git / blobdiff