- return b
- where
- (vars, exprs) = unzip bs
-
-vectTopBinder :: Var -> VM Var
-vectTopBinder var
- = do
- vty <- vectType (idType var)
- var' <- cloneId mkVectOcc var vty
- defGlobalVar var var'
- return var'
-
-vectTopRhs :: Var -> CoreExpr -> VM CoreExpr
-vectTopRhs var expr
- = do
- closedV . liftM vectorised
- . inBind var
- $ vectPolyExpr (freeVars expr)
-
-tryConvert :: Var -> Var -> CoreExpr -> VM CoreExpr
-tryConvert var vect_var rhs
- = fromVect (idType var) (Var vect_var) `orElseV` return rhs
-
--- ----------------------------------------------------------------------------
--- Bindings
-
-vectBndr :: Var -> VM VVar
-vectBndr v
- = do
- (vty, lty) <- vectAndLiftType (idType v)
- 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 (vv, lv) }
-
-vectBndrNew :: Var -> FastString -> VM VVar
-vectBndrNew v fs
- = do
- vty <- vectType (idType v)
- vv <- newLocalVVar fs vty
- updLEnv (upd vv)
- return vv
- where
- upd vv env = env { local_vars = extendVarEnv (local_vars env) v vv }
-
-vectBndrIn :: Var -> VM a -> VM (VVar, a)
-vectBndrIn v p
- = localV
- $ do
- vv <- vectBndr v
- x <- p
- return (vv, x)
-
-vectBndrNewIn :: Var -> FastString -> VM a -> VM (VVar, a)
-vectBndrNewIn v fs p
- = localV
- $ do
- vv <- vectBndrNew v fs
- x <- p
- return (vv, x)
-
-vectBndrsIn :: [Var] -> VM a -> VM ([VVar], a)
-vectBndrsIn vs p
- = localV
- $ do
- vvs <- mapM vectBndr vs
- x <- p
- return (vvs, x)
-
--- ----------------------------------------------------------------------------
--- Expressions
-
-vectVar :: Var -> VM VExpr
-vectVar v
- = do
- r <- lookupVar v
- case r of
- Local (vv,lv) -> return (Var vv, Var lv)
- Global vv -> do
- let vexpr = Var vv
- lexpr <- liftPA vexpr
- return (vexpr, lexpr)
-
-vectPolyVar :: Var -> [Type] -> VM VExpr
-vectPolyVar v tys
- = do
- vtys <- mapM vectType tys
- r <- lookupVar v
- case r of
- Local (vv, lv) -> liftM2 (,) (polyApply (Var vv) vtys)
- (polyApply (Var lv) vtys)
- Global poly -> do
- vexpr <- polyApply (Var poly) vtys
- lexpr <- liftPA vexpr
- return (vexpr, lexpr)
-
-vectLiteral :: Literal -> VM VExpr
-vectLiteral lit
- = do
- lexpr <- liftPA (Lit lit)
- return (Lit lit, lexpr)
-
-vectPolyExpr :: CoreExprWithFVs -> VM VExpr
-vectPolyExpr (_, AnnNote note expr)
- = liftM (vNote note) $ vectPolyExpr expr
-vectPolyExpr expr
- = polyAbstract tvs $ \abstract ->
- do
- mono' <- vectExpr mono
- return $ mapVect abstract mono'
- where
- (tvs, mono) = collectAnnTypeBinders expr
-
-vectExpr :: CoreExprWithFVs -> VM VExpr
-vectExpr (_, AnnType ty)
- = liftM vType (vectType ty)
-
-vectExpr (_, AnnVar v) = vectVar v
-
-vectExpr (_, AnnLit lit) = vectLiteral lit
-
-vectExpr (_, AnnNote note expr)
- = liftM (vNote note) (vectExpr expr)
-
-vectExpr e@(_, AnnApp _ arg)
- | isAnnTypeArg arg
- = vectTyAppExpr fn tys
- where
- (fn, tys) = collectAnnTypeArgs e
-
-vectExpr (_, AnnApp (_, AnnVar v) (_, AnnLit lit))
- | Just con <- isDataConId_maybe v
- , is_special_con con
- = do
- let vexpr = App (Var v) (Lit lit)
- lexpr <- liftPA vexpr
- return (vexpr, lexpr)
- where
- is_special_con con = con `elem` [intDataCon, floatDataCon, doubleDataCon]
-
-
-vectExpr (_, AnnApp fn arg)
- = do
- arg_ty' <- vectType arg_ty
- res_ty' <- vectType res_ty
- fn' <- vectExpr fn
- arg' <- vectExpr arg
- mkClosureApp arg_ty' res_ty' fn' arg'
- where
- (arg_ty, res_ty) = splitFunTy . exprType $ deAnnotate fn
-
-vectExpr (_, AnnCase scrut bndr ty alts)
- | Just (tycon, ty_args) <- splitTyConApp_maybe scrut_ty
- , isAlgTyCon tycon
- = vectAlgCase tycon ty_args scrut bndr ty alts
- where
- scrut_ty = exprType (deAnnotate scrut)
-
-vectExpr (_, AnnLet (AnnNonRec bndr rhs) body)
- = do
- vrhs <- localV . inBind bndr $ vectPolyExpr rhs
- (vbndr, vbody) <- vectBndrIn bndr (vectExpr body)
- return $ vLet (vNonRec vbndr vrhs) vbody
-
-vectExpr (_, AnnLet (AnnRec bs) body)
- = do
- (vbndrs, (vrhss, vbody)) <- vectBndrsIn bndrs
- $ liftM2 (,)
- (zipWithM vect_rhs bndrs rhss)
- (vectPolyExpr body)
- return $ vLet (vRec vbndrs vrhss) vbody
- where
- (bndrs, rhss) = unzip bs
-
- vect_rhs bndr rhs = localV
- . inBind bndr
- $ vectExpr rhs
-
-vectExpr e@(fvs, AnnLam bndr _)
- | isId bndr = vectLam fvs bs body
- where
- (bs,body) = collectAnnValBinders e
-
-vectExpr e = cantVectorise "Can't vectorise expression" (ppr $ deAnnotate e)
-
-vectLam :: VarSet -> [Var] -> CoreExprWithFVs -> VM VExpr
-vectLam fvs bs body
- = do
- tyvars <- localTyVars
- (vs, vvs) <- readLEnv $ \env ->
- unzip [(var, vv) | var <- varSetElems fvs
- , Just vv <- [lookupVarEnv (local_vars env) var]]
-
- arg_tys <- mapM (vectType . idType) bs
- res_ty <- vectType (exprType $ deAnnotate body)
-
- buildClosures tyvars vvs arg_tys res_ty
- . hoistPolyVExpr tyvars
- $ do
- lc <- builtin liftingContext
- (vbndrs, vbody) <- vectBndrsIn (vs ++ bs)
- (vectExpr body)
- return $ vLams lc vbndrs vbody
-
-vectTyAppExpr :: CoreExprWithFVs -> [Type] -> VM VExpr
-vectTyAppExpr (_, AnnVar v) tys = vectPolyVar v tys
-vectTyAppExpr e tys = cantVectorise "Can't vectorise expression"
- (ppr $ deAnnotate e `mkTyApps` tys)
-
--- We convert