X-Git-Url: http://git.megacz.com/?p=ghc-hetmet.git;a=blobdiff_plain;f=compiler%2Fvectorise%2FVectorise.hs;h=4994e3f1659cbd1d333bba333ba07587f6f2219d;hp=166eae65a7ade43a3cfa95ea397e5018d25e52ad;hb=febf1ced754a3996ac1a5877dcded87828560d1c;hpb=ffe6bf7b9bcbee65080e0c2d37c702dd912761e8 diff --git a/compiler/vectorise/Vectorise.hs b/compiler/vectorise/Vectorise.hs index 166eae6..4994e3f 100644 --- a/compiler/vectorise/Vectorise.hs +++ b/compiler/vectorise/Vectorise.hs @@ -1,455 +1,269 @@ -module Vectorise( vectorise ) -where - -#include "HsVersions.h" - -import VectMonad -import VectUtils +{-# OPTIONS -fno-warn-missing-signatures -fno-warn-unused-do-bind #-} -import DynFlags -import HscTypes +module Vectorise ( vectorise ) +where -import CoreLint ( showPass, endPass ) -import CoreSyn -import CoreUtils +import Vectorise.Type.Env +import Vectorise.Type.Type +import Vectorise.Convert +import Vectorise.Utils.Hoisting +import Vectorise.Exp +import Vectorise.Vect +import Vectorise.Env +import Vectorise.Monad + +import HscTypes hiding ( MonadThings(..) ) +import CoreUnfold ( mkInlineUnfolding ) import CoreFVs -import SimplMonad ( SimplCount, zeroSimplCount ) -import Rules ( RuleBase ) -import DataCon -import TyCon +import PprCore +import CoreSyn +import CoreMonad ( CoreM, getHscEnv ) import Type -import TypeRep -import Var -import VarEnv -import VarSet -import Name ( mkSysTvName, getName ) -import NameEnv import Id -import MkId ( unwrapFamInstScrut ) import OccName +import DynFlags +import BasicTypes ( isLoopBreaker ) +import Outputable +import Util ( zipLazy ) +import MonadUtils -import DsMonad hiding (mapAndUnzipM) -import DsUtils ( mkCoreTup, mkCoreTupTy ) +import Control.Monad -import PrelNames -import TysWiredIn -import BasicTypes ( Boxity(..) ) -import Outputable -import FastString -import Control.Monad ( liftM, liftM2, mapAndUnzipM, zipWithM_ ) -import Data.Maybe ( maybeToList ) +-- | Vectorise a single module. +-- +vectorise :: ModGuts -> CoreM ModGuts +vectorise guts + = do { hsc_env <- getHscEnv + ; liftIO $ vectoriseIO hsc_env guts + } -vectorise :: HscEnv -> UniqSupply -> RuleBase -> ModGuts - -> IO (SimplCount, ModGuts) -vectorise hsc_env _ _ guts - = do - showPass dflags "Vectorisation" - eps <- hscEPS hsc_env - let info = hptVectInfo hsc_env `plusVectInfo` eps_vect_info eps - Just (info', guts') <- initV hsc_env guts info (vectModule guts) - endPass dflags "Vectorisation" Opt_D_dump_vect (mg_binds guts') - return (zeroSimplCount dflags, guts' { mg_vect_info = info' }) - where - dflags = hsc_dflags hsc_env +-- | Vectorise a single monad, given the dynamic compiler flags and HscEnv. +-- +vectoriseIO :: HscEnv -> ModGuts -> IO ModGuts +vectoriseIO hsc_env guts + = do { -- Get information about currently loaded external packages. + ; eps <- hscEPS hsc_env -vectModule :: ModGuts -> VM ModGuts -vectModule guts - = do - binds' <- mapM vectTopBind (mg_binds guts) - return $ guts { mg_binds = binds' } + -- Combine vectorisation info from the current module, and external ones. + ; let info = hptVectInfo hsc_env `plusVectInfo` eps_vect_info eps + + -- Run the main VM computation. + ; Just (info', guts') <- initV hsc_env guts info (vectModule guts) + ; return (guts' { mg_vect_info = info' }) + } +-- | Vectorise a single module, in the VM monad. +-- +vectModule :: ModGuts -> VM ModGuts +vectModule guts@(ModGuts { mg_types = types + , mg_binds = binds + , mg_fam_insts = fam_insts + }) + = do { dumpOptVt Opt_D_dump_vt_trace "Before vectorisation" $ + pprCoreBindings binds + + -- Vectorise the type environment. + -- This may add new TyCons and DataCons. + ; (types', new_fam_insts, tc_binds) <- vectTypeEnv types + + ; (_, fam_inst_env) <- readGEnv global_fam_inst_env + + -- dicts <- mapM buildPADict pa_insts + -- workers <- mapM vectDataConWorkers pa_insts + + -- Vectorise all the top level bindings. + ; binds' <- mapM vectTopBind binds + + ; return $ guts { mg_types = types' + , mg_binds = Rec tc_binds : binds' + , mg_fam_inst_env = fam_inst_env + , mg_fam_insts = fam_insts ++ new_fam_insts + } + } + +-- | Try to vectorise a top-level binding. +-- If it doesn't vectorise then return it unharmed. +-- +-- For example, for the binding +-- +-- @ +-- foo :: Int -> Int +-- foo = \x -> x + x +-- @ +-- +-- we get +-- @ +-- foo :: Int -> Int +-- foo = \x -> vfoo $: x +-- +-- v_foo :: Closure void vfoo lfoo +-- v_foo = closure vfoo lfoo void +-- +-- vfoo :: Void -> Int -> Int +-- vfoo = ... +-- +-- lfoo :: PData Void -> PData Int -> PData Int +-- lfoo = ... +-- @ +-- +-- @vfoo@ is the "vectorised", or scalar, version that does the same as the original +-- function foo, but takes an explicit environment. +-- +-- @lfoo@ is the "lifted" version that works on arrays. +-- +-- @v_foo@ combines both of these into a `Closure` that also contains the +-- environment. +-- +-- The original binding @foo@ is rewritten to call the vectorised version +-- present in the closure. +-- vectTopBind :: CoreBind -> VM CoreBind vectTopBind b@(NonRec var expr) - = do - var' <- vectTopBinder var - expr' <- vectTopRhs expr - hs <- takeHoisted - return . Rec $ (var, expr) : (var', expr') : hs + = do { -- Vectorise the right-hand side, create an appropriate top-level binding and add it to + -- the vectorisation map. + ; (inline, isScalar, expr') <- vectTopRhs [] var expr + ; var' <- vectTopBinder var inline expr' + ; when isScalar $ + addGlobalScalar var + + -- We replace the original top-level binding by a value projected from the vectorised + -- closure and add any newly created hoisted top-level bindings. + ; cexpr <- tryConvert var var' expr + ; hs <- takeHoisted + ; return . Rec $ (var, cexpr) : (var', expr') : hs + } `orElseV` return b - vectTopBind b@(Rec bs) - = do - vars' <- mapM vectTopBinder vars - exprs' <- mapM vectTopRhs exprs - hs <- takeHoisted - return . Rec $ bs ++ zip vars' exprs' ++ hs + = let (vars, exprs) = unzip bs + in + do { (vars', _, exprs', hs) <- fixV $ + \ ~(_, inlines, rhss, _) -> + do { -- Vectorise the right-hand sides, create an appropriate top-level bindings and + -- add them to the vectorisation map. + ; vars' <- sequence [vectTopBinder var inline rhs + | (var, ~(inline, rhs)) <- zipLazy vars (zip inlines rhss)] + ; (inlines, areScalars, exprs') <- mapAndUnzip3M (uncurry $ vectTopRhs vars) bs + ; hs <- takeHoisted + ; if and areScalars + then -- (1) Entire recursive group is scalar + -- => add all variables to the global set of scalars + do { mapM addGlobalScalar vars + ; return (vars', inlines, exprs', hs) + } + else -- (2) At least one binding is not scalar + -- => vectorise again with empty set of local scalars + do { (inlines, _, exprs') <- mapAndUnzip3M (uncurry $ vectTopRhs []) bs + ; hs <- takeHoisted + ; return (vars', inlines, exprs', hs) + } + } + + -- Replace the original top-level bindings by a values projected from the vectorised + -- closures and add any newly created hoisted top-level bindings to the group. + ; cexprs <- sequence $ zipWith3 tryConvert vars vars' exprs + ; return . Rec $ zip vars cexprs ++ zip vars' exprs' ++ hs + } `orElseV` - return b - where - (vars, exprs) = unzip bs - -vectTopBinder :: Var -> VM Var -vectTopBinder var - = do - vty <- vectType (idType var) - name <- cloneName mkVectOcc (getName var) - let var' | isExportedId var = Id.mkExportedLocalId name vty - | otherwise = Id.mkLocalId name vty - defGlobalVar var var' - return var' - -vectTopRhs :: CoreExpr -> VM CoreExpr -vectTopRhs = liftM fst . closedV . vectPolyExpr (panic "Empty lifting context") . freeVars - --- ---------------------------------------------------------------------------- --- Bindings - -vectBndr :: Var -> VM (Var, Var) -vectBndr v - = do - vty <- vectType (idType v) - lty <- mkPArrayType vty - let vv = v `Id.setIdType` vty - lv = v `Id.setIdType` lty - updLEnv (mapTo vv lv) - return (vv, lv) - where - mapTo vv lv env = env { local_vars = extendVarEnv (local_vars env) v (Var vv, Var lv) } - -vectBndrIn :: Var -> VM a -> VM (Var, Var, a) -vectBndrIn v p - = localV - $ do - (vv, lv) <- vectBndr v - x <- p - return (vv, lv, x) - -vectBndrsIn :: [Var] -> VM a -> VM ([Var], [Var], a) -vectBndrsIn vs p - = localV - $ do - (vvs, lvs) <- mapAndUnzipM vectBndr vs - x <- p - return (vvs, lvs, x) - --- ---------------------------------------------------------------------------- --- Expressions - -replicateP :: CoreExpr -> CoreExpr -> VM CoreExpr -replicateP expr len - = do - dict <- paDictOfType ty - rep <- builtin replicatePAVar - return $ mkApps (Var rep) [Type ty, dict, expr, len] - where - ty = exprType expr - -capply :: (CoreExpr, CoreExpr) -> (CoreExpr, CoreExpr) -> VM (CoreExpr, CoreExpr) -capply (vfn, lfn) (varg, larg) - = do - apply <- builtin applyClosureVar - applyP <- builtin applyClosurePVar - return (mkApps (Var apply) [Type arg_ty, Type res_ty, vfn, varg], - mkApps (Var applyP) [Type arg_ty, Type res_ty, lfn, larg]) - where - fn_ty = exprType vfn - (arg_ty, res_ty) = splitClosureTy fn_ty - -vectVar :: CoreExpr -> Var -> VM (CoreExpr, CoreExpr) -vectVar lc v - = do - r <- lookupVar v - case r of - Local es -> return es - Global vexpr -> do - lexpr <- replicateP vexpr lc - return (vexpr, lexpr) - -vectPolyVar :: CoreExpr -> Var -> [Type] -> VM (CoreExpr, CoreExpr) -vectPolyVar lc v tys - = do - r <- lookupVar v - case r of - Local (vexpr, lexpr) -> liftM2 (,) (mk_app vexpr) (mk_app lexpr) - Global poly -> do - 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) <- 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 - return (Let (Rec (zip vbndrs vrhss)) vbody, - Let (Rec (zip lbndrs lrhss)) lbody) - where - (bndrs, rhss) = unzip prs + return b - vect = do - (vrhss, lrhss) <- mapAndUnzipM (vectExpr lc) rhss - (vbody, lbody) <- vectPolyExpr lc body - return (vrhss, vbody, lrhss, lbody) - -vectExpr lc e@(_, AnnLam bndr body) - | isTyVar bndr = pprPanic "vectExpr" (ppr $ deAnnotate e) - -vectExpr lc (fvs, AnnLam bndr body) - = do - let tyvars = filter isTyVar (varSetElems fvs) - info <- mkCEnvInfo fvs bndr body - (poly_vfn, poly_lfn) <- mkClosureFns info tyvars bndr body - - vfn_var <- hoistExpr FSLIT("vfn") poly_vfn - lfn_var <- hoistExpr FSLIT("lfn") poly_lfn - - let (venv, lenv) = mkClosureEnvs info lc - - let env_ty = cenv_vty info - - pa_dict <- paDictOfType env_ty - - arg_ty <- vectType (varType bndr) - res_ty <- vectType (exprType $ deAnnotate body) - - -- FIXME: move the functions to the top level - mono_vfn <- applyToTypes (Var vfn_var) (map TyVarTy tyvars) - mono_lfn <- applyToTypes (Var lfn_var) (map TyVarTy tyvars) - - mk_clo <- builtin mkClosureVar - mk_cloP <- builtin mkClosurePVar - - let vclo = Var mk_clo `mkTyApps` [arg_ty, res_ty, env_ty] - `mkApps` [pa_dict, mono_vfn, mono_lfn, venv] - - lclo = Var mk_cloP `mkTyApps` [arg_ty, res_ty, env_ty] - `mkApps` [pa_dict, mono_vfn, mono_lfn, lenv] - - return (vclo, lclo) - - -data CEnvInfo = CEnvInfo { - cenv_vars :: [Var] - , cenv_values :: [(CoreExpr, CoreExpr)] - , cenv_vty :: Type - , cenv_lty :: Type - , cenv_repr_tycon :: TyCon - , cenv_repr_tyargs :: [Type] - , cenv_repr_datacon :: DataCon - } - -mkCEnvInfo :: VarSet -> Var -> CoreExprWithFVs -> VM CEnvInfo -mkCEnvInfo fvs arg body - = do - locals <- readLEnv local_vars - let - (vars, vals) = unzip - [(var, val) | var <- varSetElems fvs - , Just val <- [lookupVarEnv locals var]] - vtys <- mapM (vectType . varType) vars - - (vty, repr_tycon, repr_tyargs, repr_datacon) <- mk_env_ty vtys - lty <- mkPArrayType vty +-- | Make the vectorised version of this top level binder, and add the mapping +-- between it and the original to the state. For some binder @foo@ the vectorised +-- version is @$v_foo@ +-- +-- NOTE: vectTopBinder *MUST* be lazy in inline and expr because of how it is +-- used inside of fixV in vectTopBind +-- +vectTopBinder :: Var -- ^ Name of the binding. + -> Inline -- ^ Whether it should be inlined, used to annotate it. + -> CoreExpr -- ^ RHS of binding, used to set the 'Unfolding' of the returned 'Var'. + -> VM Var -- ^ Name of the vectorised binding. +vectTopBinder var inline expr + = do { -- Vectorise the type attached to the var. + ; vty <- vectType (idType var) - return $ CEnvInfo { - cenv_vars = vars - , cenv_values = vals - , cenv_vty = vty - , cenv_lty = lty - , cenv_repr_tycon = repr_tycon - , cenv_repr_tyargs = repr_tyargs - , cenv_repr_datacon = repr_datacon - } - where - mk_env_ty [vty] - = return (vty, error "absent cinfo_repr_tycon" - , error "absent cinfo_repr_tyargs" - , error "absent cinfo_repr_datacon") - - mk_env_ty vtys - = do - let ty = mkCoreTupTy vtys - (repr_tc, repr_tyargs) <- lookupPArrayFamInst ty - let [repr_con] = tyConDataCons repr_tc - return (ty, repr_tc, repr_tyargs, repr_con) - - - -mkClosureEnvs :: CEnvInfo -> CoreExpr -> (CoreExpr, CoreExpr) -mkClosureEnvs info lc - | [] <- vals - = (Var unitDataConId, mkApps (Var $ dataConWrapId (cenv_repr_datacon info)) - [lc, Var unitDataConId]) - - | [(vval, lval)] <- vals - = (vval, lval) - - | otherwise - = (mkCoreTup vvals, Var (dataConWrapId $ cenv_repr_datacon info) - `mkTyApps` cenv_repr_tyargs info - `mkApps` (lc : lvals)) - + -- If there is a vectorisation declartion for this binding, make sure that its type + -- matches + ; vectDecl <- lookupVectDecl var + ; case vectDecl of + Nothing -> return () + Just (vdty, _) + | eqType vty vdty -> return () + | otherwise -> + cantVectorise ("Type mismatch in vectorisation pragma for " ++ show var) $ + (text "Expected type" <+> ppr vty) + $$ + (text "Inferred type" <+> ppr vdty) + + -- Make the vectorised version of binding's name, and set the unfolding used for inlining + ; var' <- liftM (`setIdUnfoldingLazily` unfolding) + $ cloneId mkVectOcc var vty + + -- Add the mapping between the plain and vectorised name to the state. + ; defGlobalVar var var' + + ; return var' + } where - vals = cenv_values info - (vvals, lvals) = unzip vals - -mkClosureFns :: CEnvInfo -> [TyVar] -> Var -> CoreExprWithFVs - -> VM (CoreExpr, CoreExpr) -mkClosureFns info tyvars arg body + unfolding = case inline of + Inline arity -> mkInlineUnfolding (Just arity) expr + DontInline -> noUnfolding + +-- | Vectorise the RHS of a top-level binding, in an empty local environment. +-- +-- We need to distinguish three cases: +-- +-- (1) We have a (non-scalar) vectorisation declaration for the variable (which explicitly provides +-- vectorised code implemented by the user) +-- => no automatic vectorisation & instead use the user-supplied code +-- +-- (2) We have a scalar vectorisation declaration for the variable +-- => generate vectorised code that uses a scalar 'map'/'zipWith' to lift the computation +-- +-- (3) There is no vectorisation declaration for the variable +-- => perform automatic vectorisation of the RHS +-- +vectTopRhs :: [Var] -- ^ Names of all functions in the rec block + -> Var -- ^ Name of the binding. + -> CoreExpr -- ^ Body of the binding. + -> VM ( Inline -- (1) inline specification for the binding + , Bool -- (2) whether the right-hand side is a scalar computation + , CoreExpr) -- (3) the vectorised right-hand side +vectTopRhs recFs var expr = closedV - . abstractOverTyVars tyvars - $ \mk_tlams -> - do - (vfn, lfn) <- mkClosureMonoFns info arg body - return (mk_tlams vfn, mk_tlams lfn) - -mkClosureMonoFns :: CEnvInfo -> Var -> CoreExprWithFVs -> VM (CoreExpr, CoreExpr) -mkClosureMonoFns info arg body - = do - lc_bndr <- newLocalVar FSLIT("lc") intTy - (varg : vbndrs, larg : lbndrs, (vbody, lbody)) - <- vectBndrsIn (arg : cenv_vars info) - (vectExpr (Var lc_bndr) body) - - venv_bndr <- newLocalVar FSLIT("env") vty - lenv_bndr <- newLocalVar FSLIT("env") lty - - let vcase = bind_venv (Var venv_bndr) vbody vbndrs - lcase <- bind_lenv (Var lenv_bndr) lbody lc_bndr lbndrs - return (mkLams [venv_bndr, varg] vcase, mkLams [lenv_bndr, larg] lcase) + $ do { traceVt ("vectTopRhs of " ++ show var) $ ppr expr + + ; globalScalar <- isGlobalScalar var + ; vectDecl <- lookupVectDecl var + ; rhs globalScalar vectDecl + } where - vty = cenv_vty info - lty = cenv_lty info - - arity = length (cenv_vars info) - - bind_venv venv vbody [] = vbody - bind_venv venv vbody [vbndr] = Let (NonRec vbndr venv) vbody - bind_venv venv vbody vbndrs - = Case venv (mkWildId vty) (exprType vbody) - [(DataAlt (tupleCon Boxed arity), vbndrs, vbody)] - - bind_lenv lenv lbody lc_bndr [lbndr] - = do - lengthPA <- builtin lengthPAVar - return . Let (NonRec lbndr lenv) - $ Case (mkApps (Var lengthPA) [Type vty, (Var lbndr)]) - lc_bndr - intTy - [(DEFAULT, [], lbody)] - - bind_lenv lenv lbody lc_bndr lbndrs - = return - $ Case (unwrapFamInstScrut (cenv_repr_tycon info) - (cenv_repr_tyargs info) - lenv) - (mkWildId lty) - (exprType lbody) - [(DataAlt (cenv_repr_datacon info), lc_bndr : lbndrs, lbody)] - -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 - -vectTyCon :: TyCon -> VM TyCon -vectTyCon tc - | isFunTyCon tc = builtin closureTyCon - | isBoxedTupleTyCon tc = return tc - | isUnLiftedTyCon tc = return tc - | otherwise = do - r <- lookupTyCon tc - case r of - Just tc' -> return tc' - - -- FIXME: just for now - Nothing -> pprTrace "ccTyCon:" (ppr tc) $ return tc - -vectType :: Type -> VM Type -vectType ty | Just ty' <- coreView ty = vectType ty' -vectType (TyVarTy tv) = return $ TyVarTy tv -vectType (AppTy ty1 ty2) = liftM2 AppTy (vectType ty1) (vectType ty2) -vectType (TyConApp tc tys) = liftM2 TyConApp (vectTyCon tc) (mapM vectType tys) -vectType (FunTy ty1 ty2) = liftM2 TyConApp (builtin closureTyCon) - (mapM vectType [ty1,ty2]) -vectType (ForAllTy tv ty) - = do - r <- paDictArgType tv - ty' <- vectType ty - return $ ForAllTy tv (wrap r ty') - where - wrap Nothing = id - wrap (Just pa_ty) = FunTy pa_ty - -vectType ty = pprPanic "vectType:" (ppr ty) - + rhs _globalScalar (Just (_, expr')) -- Case (1) + = return (inlineMe, False, expr') + rhs True Nothing -- Case (2) + = do { expr' <- vectScalarFun True recFs expr + ; return (inlineMe, True, vectorised expr') + } + rhs False Nothing -- Case (3) + = do { let fvs = freeVars expr + ; (inline, isScalar, vexpr) <- inBind var $ + vectPolyExpr (isLoopBreaker $ idOccInfo var) recFs fvs + ; return (inline, isScalar, vectorised vexpr) + } + +-- | Project out the vectorised version of a binding from some closure, +-- or return the original body if that doesn't work or the binding is scalar. +-- +tryConvert :: Var -- ^ Name of the original binding (eg @foo@) + -> Var -- ^ Name of vectorised version of binding (eg @$vfoo@) + -> CoreExpr -- ^ The original body of the binding. + -> VM CoreExpr +tryConvert var vect_var rhs + = do { globalScalar <- isGlobalScalar var + ; if globalScalar + then + return rhs + else + fromVect (idType var) (Var vect_var) `orElseV` return rhs + }