VM,
noV, tryV, maybeV, orElseV, fixV, localV, closedV, initV,
- cloneName, newLocalVar, newTyVar,
+ cloneName, cloneId,
+ newExportedVar, newLocalVar, newDummyVar, newTyVar,
- Builtins(..), paDictTyCon,
+ Builtins(..), paDictTyCon, paDictDataCon,
builtin,
GlobalEnv(..),
+ setInstEnvs,
readGEnv, setGEnv, updGEnv,
LocalEnv(..),
readLEnv, setLEnv, updLEnv,
+ getBindName, inBind,
+
lookupVar, defGlobalVar,
lookupTyCon, defTyCon,
lookupDataCon, defDataCon,
import OccName
import Name
import NameEnv
+import TysPrim ( intPrimTy )
import DsMonad
import PrelNames
import Panic
import Outputable
import FastString
+import SrcLoc ( noSrcSpan )
import Control.Monad ( liftM )
, 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
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
, applyClosurePVar = applyClosurePVar
, 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
--
-- Mapping from local variables to their vectorised and
-- lifted versions
--
- local_vars :: VarEnv (CoreExpr, CoreExpr)
+ local_vars :: VarEnv (Var, Var)
-- In-scope type variables
--
-- Mapping from tyvars to their PA dictionaries
, local_tyvar_pa :: VarEnv CoreExpr
+
+ -- Local binding name
+ , local_bind_name :: FastString
}
-initGlobalEnv :: VectInfo -> (InstEnv, InstEnv) -> FamInstEnvs -> GlobalEnv
-initGlobalEnv info instEnvs famInstEnvs
+initGlobalEnv :: VectInfo -> (InstEnv, InstEnv) -> FamInstEnvs -> Builtins -> GlobalEnv
+initGlobalEnv info instEnvs famInstEnvs bi
= GlobalEnv {
- global_vars = mapVarEnv (Var . snd) $ vectInfoVar info
+ global_vars = mapVarEnv snd $ vectInfoVar info
, global_exported_vars = emptyVarEnv
- , global_tycons = mapNameEnv snd $ vectInfoTyCon info
+ , global_tycons = extendNameEnv (mapNameEnv snd (vectInfoTyCon info))
+ (tyConName funTyCon) (closureTyCon bi)
+
, global_datacons = mapNameEnv snd $ vectInfoDataCon info
, global_inst_env = instEnvs
, global_fam_inst_env = famInstEnvs
, global_bindings = []
}
+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) }
+
emptyLocalEnv = LocalEnv {
local_vars = emptyVarEnv
, local_tyvars = []
, local_tyvar_pa = emptyVarEnv
+ , local_bind_name = FSLIT("fn")
}
-- FIXME
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
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
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
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
(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
+ mod <- liftDs getModuleDs
+ u <- liftDs newUnique
+
+ let name = mkExternalName u mod occ_name noSrcSpan
+
+ return $ Id.mkExportedLocalId name ty
+
newLocalVar :: FastString -> Type -> VM Var
newLocalVar fs ty
= do
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
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 = readGEnv $ \env -> lookupNameEnv (global_tycons env) (tyConName tc)
+lookupTyCon tc
+ | isUnLiftedTyCon tc || isTupleTyCon tc = return (Just tc)
+
+ | otherwise = readGEnv $ \env -> lookupNameEnv (global_tycons env) (tyConName tc)
defTyCon :: TyCon -> TyCon -> VM ()
defTyCon tc tc' = updGEnv $ \env ->
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
go instEnvs famInstEnvs =
do
builtins <- initBuiltins
- r <- runVM p builtins (initGlobalEnv info instEnvs famInstEnvs)
+ r <- runVM p builtins (initGlobalEnv info instEnvs famInstEnvs builtins)
emptyLocalEnv
case r of
Yes genv _ x -> return $ Just (new_info genv, x)
projects / ghc-hetmet.git / blobdiff