2 % (c) The AQUA Project, Glasgow University, 1993-1998
4 \section[SimplUtils]{The simplifier utilities}
8 simplBinder, simplBinders, simplIds,
11 mkCase, findAlt, findDefault,
15 #include "HsVersions.h"
18 import CmdLineOpts ( opt_SimplDoLambdaEtaExpansion, opt_SimplCaseMerge )
20 import CoreFVs ( exprFreeVars )
21 import CoreUtils ( exprIsTrivial, cheapEqExpr, coreExprType, exprIsCheap, exprGenerousArity )
22 import Subst ( substBndrs, substBndr, substIds )
23 import Id ( Id, idType, getIdArity, isId, idName,
24 getInlinePragma, setInlinePragma,
27 import IdInfo ( arityLowerBound, InlinePragInfo(..), setInlinePragInfo, vanillaIdInfo )
28 import Maybes ( maybeToBool, catMaybes )
29 import Const ( Con(..) )
30 import Name ( isLocalName, setNameUnique )
32 import Type ( Type, tyVarsOfType, tyVarsOfTypes, mkForAllTys,
33 splitTyConApp_maybe, mkTyVarTys, applyTys, splitFunTys, mkFunTys
35 import TysPrim ( statePrimTyCon )
36 import Var ( setVarUnique )
38 import UniqSupply ( splitUniqSupply, uniqFromSupply )
39 import Util ( zipWithEqual, mapAccumL )
44 %************************************************************************
46 \section{Dealing with a single binder}
48 %************************************************************************
51 simplBinders :: [InBinder] -> ([OutBinder] -> SimplM a) -> SimplM a
52 simplBinders bndrs thing_inside
53 = getSubst `thenSmpl` \ subst ->
55 (subst', bndrs') = substBndrs subst bndrs
60 simplBinder :: InBinder -> (OutBinder -> SimplM a) -> SimplM a
61 simplBinder bndr thing_inside
62 = getSubst `thenSmpl` \ subst ->
64 (subst', bndr') = substBndr subst bndr
70 -- Same semantics as simplBinders, but a little less
71 -- plumbing and hence a little more efficient.
72 -- Maybe not worth the candle?
73 simplIds :: [InBinder] -> ([OutBinder] -> SimplM a) -> SimplM a
74 simplIds ids thing_inside
75 = getSubst `thenSmpl` \ subst ->
77 (subst', bndrs') = substIds subst ids
84 %************************************************************************
86 \subsection{Transform a RHS}
88 %************************************************************************
91 (b) type-lambda swizzling
94 transformRhs :: InExpr -> SimplM InExpr
96 = tryEtaExpansion body `thenSmpl` \ body' ->
97 mkRhsTyLam tyvars body'
99 (tyvars, body) = collectTyBinders rhs
103 %************************************************************************
105 \subsection{Local tyvar-lifting}
107 %************************************************************************
109 mkRhsTyLam tries this transformation, when the big lambda appears as
110 the RHS of a let(rec) binding:
112 /\abc -> let(rec) x = e in b
114 let(rec) x' = /\abc -> let x = x' a b c in e
116 /\abc -> let x = x' a b c in b
118 This is good because it can turn things like:
120 let f = /\a -> letrec g = ... g ... in g
122 letrec g' = /\a -> ... g' a ...
126 which is better. In effect, it means that big lambdas don't impede
129 This optimisation is CRUCIAL in eliminating the junk introduced by
130 desugaring mutually recursive definitions. Don't eliminate it lightly!
132 So far as the implemtation is concerned:
134 Invariant: go F e = /\tvs -> F e
138 = Let x' = /\tvs -> F e
142 G = F . Let x = x' tvs
144 go F (Letrec xi=ei in b)
145 = Letrec {xi' = /\tvs -> G ei}
149 G = F . Let {xi = xi' tvs}
151 [May 1999] If we do this transformation *regardless* then we can
152 end up with some pretty silly stuff. For example,
155 st = /\ s -> let { x1=r1 ; x2=r2 } in ...
160 st = /\s -> ...[y1 s/x1, y2 s/x2]
163 Unless the "..." is a WHNF there is really no point in doing this.
164 Indeed it can make things worse. Suppose x1 is used strictly,
167 x1* = case f y of { (a,b) -> e }
169 If we abstract this wrt the tyvar we then can't do the case inline
170 as we would normally do.
174 mkRhsTyLam tyvars body -- Only does something if there's a let
175 | null tyvars || not (worth_it body) -- inside a type lambda, and a WHNF inside that
176 = returnSmpl (mkLams tyvars body)
180 worth_it (Let _ e) = whnf_in_middle e
181 worth_it other = False
182 whnf_in_middle (Let _ e) = whnf_in_middle e
183 whnf_in_middle e = exprIsCheap e
185 main_tyvar_set = mkVarSet tyvars
187 go fn (Let bind@(NonRec var rhs) body) | exprIsTrivial rhs
188 = go (fn . Let bind) body
190 go fn (Let bind@(NonRec var rhs) body)
191 = mk_poly tyvars_here var `thenSmpl` \ (var', rhs') ->
192 go (fn . Let (mk_silly_bind var rhs')) body `thenSmpl` \ body' ->
193 returnSmpl (Let (NonRec var' (mkLams tyvars_here (fn rhs))) body')
196 -- varSetElems (main_tyvar_set `intersectVarSet` tyVarsOfType var_ty)
197 -- tyvars_here was an attempt to reduce the number of tyvars
198 -- wrt which the new binding is abstracted. But the naive
199 -- approach of abstract wrt the tyvars free in the Id's type
201 -- /\ a b -> let t :: (a,b) = (e1, e2)
204 -- Here, b isn't free in x's type, but we must nevertheless
205 -- abstract wrt b as well, because t's type mentions b.
206 -- Since t is floated too, we'd end up with the bogus:
207 -- poly_t = /\ a b -> (e1, e2)
208 -- poly_x = /\ a -> fst (poly_t a *b*)
209 -- So for now we adopt the even more naive approach of
210 -- abstracting wrt *all* the tyvars. We'll see if that
211 -- gives rise to problems. SLPJ June 98
215 go fn (Let (Rec prs) body)
216 = mapAndUnzipSmpl (mk_poly tyvars_here) vars `thenSmpl` \ (vars', rhss') ->
218 gn body = fn $ foldr Let body (zipWith mk_silly_bind vars rhss')
220 go gn body `thenSmpl` \ body' ->
221 returnSmpl (Let (Rec (vars' `zip` [mkLams tyvars_here (gn rhs) | rhs <- rhss])) body')
223 (vars,rhss) = unzip prs
225 -- varSetElems (main_tyvar_set `intersectVarSet` tyVarsOfTypes var_tys)
226 -- See notes with tyvars_here above
228 var_tys = map idType vars
230 go fn body = returnSmpl (mkLams tyvars (fn body))
232 mk_poly tyvars_here var
233 = getUniqueSmpl `thenSmpl` \ uniq ->
235 poly_name = setNameUnique (idName var) uniq -- Keep same name
236 poly_ty = mkForAllTys tyvars_here (idType var) -- But new type of course
238 -- It's crucial to copy the inline-prag of the original var, because
239 -- we're looking at occurrence-analysed but as yet unsimplified code!
240 -- In particular, we mustn't lose the loop breakers.
242 -- It's even right to retain single-occurrence or dead-var info:
243 -- Suppose we started with /\a -> let x = E in B
244 -- where x occurs once in E. Then we transform to:
245 -- let x' = /\a -> E in /\a -> let x* = x' a in B
246 -- where x* has an INLINE prag on it. Now, once x* is inlined,
247 -- the occurrences of x' will be just the occurrences originaly
249 poly_info = vanillaIdInfo `setInlinePragInfo` getInlinePragma var
251 poly_id = mkId poly_name poly_ty poly_info
253 returnSmpl (poly_id, mkTyApps (Var poly_id) (mkTyVarTys tyvars_here))
255 mk_silly_bind var rhs = NonRec (setInlinePragma var IMustBeINLINEd) rhs
256 -- The addInlinePragma is really important! If we don't say
257 -- INLINE on these silly little bindings then look what happens!
258 -- Suppose we start with:
260 -- x = let g = /\a -> \x -> f x x
262 -- /\ b -> let g* = g b in E
264 -- Then: * the binding for g gets floated out
265 -- * but then it gets inlined into the rhs of g*
266 -- * then the binding for g* is floated out of the /\b
267 -- * so we're back to square one
268 -- The silly binding for g* must be IMustBeINLINEs, so that
269 -- we simply substitute for g* throughout.
273 %************************************************************************
275 \subsection{Eta expansion}
277 %************************************************************************
279 Try eta expansion for RHSs
282 \x1..xn -> N ==> \x1..xn y1..ym -> N y1..ym
284 N E1..En ==> let z1=E1 .. zn=En in \y1..ym -> N z1..zn y1..ym
286 where (in both cases) N is a NORMAL FORM (i.e. no redexes anywhere)
287 wanting a suitable number of extra args.
289 NB: the Ei may have unlifted type, but the simplifier (which is applied
290 to the result) deals OK with this.
292 There is no point in looking for a combination of the two,
293 because that would leave use with some lets sandwiched between lambdas;
294 that's what the final test in the first equation is for.
297 tryEtaExpansion :: InExpr -> SimplM InExpr
299 | not opt_SimplDoLambdaEtaExpansion
300 || exprIsTrivial rhs -- Don't eta-expand a trival RHS
301 || null y_tys -- No useful expansion
302 || not (null x_bndrs || and trivial_args) -- Not (no x-binders or no z-binds)
305 | otherwise -- Consider eta expansion
306 = newIds y_tys $ ( \ y_bndrs ->
307 tick (EtaExpansion (head y_bndrs)) `thenSmpl_`
308 mapAndUnzipSmpl bind_z_arg (args `zip` trivial_args) `thenSmpl` (\ (maybe_z_binds, z_args) ->
309 returnSmpl (mkLams x_bndrs $
310 mkLets (catMaybes maybe_z_binds) $
312 mkApps (mkApps fun z_args) (map Var y_bndrs))))
314 (x_bndrs, body) = collectValBinders rhs
315 (fun, args) = collectArgs body
316 trivial_args = map exprIsTrivial args
317 fun_arity = exprGenerousArity fun
319 bind_z_arg (arg, trivial_arg)
320 | trivial_arg = returnSmpl (Nothing, arg)
321 | otherwise = newId (coreExprType arg) $ \ z ->
322 returnSmpl (Just (NonRec z arg), Var z)
324 -- Note: I used to try to avoid the coreExprType call by using
325 -- the type of the binder. But this type doesn't necessarily
326 -- belong to the same substitution environment as this rhs;
327 -- and we are going to make extra term binders (y_bndrs) from the type
328 -- which will be processed with the rhs substitution environment.
329 -- This only went wrong in a mind bendingly complicated case.
330 (potential_extra_arg_tys, inner_ty) = splitFunTys (coreExprType body)
333 y_tys = take no_extras_wanted potential_extra_arg_tys
335 no_extras_wanted :: Int
336 no_extras_wanted = 0 `max`
338 -- We used to expand the arity to the previous arity fo the
339 -- function; but this is pretty dangerous. Consdier
341 -- so that f has arity 2. Now float something into f's RHS:
342 -- f = let z = BIG in \xy -> e
343 -- The last thing we want to do now is to put some lambdas
345 -- f = \xy -> let z = BIG in e
347 -- (bndr_arity - no_of_xs) `max`
349 -- See if the body could obviously do with more args
350 (fun_arity - valArgCount args)
352 -- This case is now deal with by exprGenerousArity
353 -- Finally, see if it's a state transformer, and xs is non-null
354 -- (so it's also a function not a thunk) in which
355 -- case we eta-expand on principle! This can waste work,
356 -- but usually doesn't.
357 -- I originally checked for a singleton type [ty] in this case
358 -- but then I found a situation in which I had
359 -- \ x -> let {..} in \ s -> f (...) s
360 -- AND f RETURNED A FUNCTION. That is, 's' wasn't the only
361 -- potential extra arg.
362 -- case (x_bndrs, potential_extra_arg_tys) of
363 -- (_:_, ty:_) -> case splitTyConApp_maybe ty of
364 -- Just (tycon,_) | tycon == statePrimTyCon -> 1
370 %************************************************************************
372 \subsection{Eta reduction}
374 %************************************************************************
376 @etaCoreExpr@ trys an eta reduction at the top level of a Core Expr.
378 e.g. \ x y -> f x y ===> f
382 -- a) Before constructing an Unfolding, to
383 -- try to make the unfolding smaller;
384 b) In tidyCoreExpr, which is done just before converting to STG.
386 But we only do this if
387 i) It gets rid of a whole lambda, not part.
388 The idea is that lambdas are often quite helpful: they indicate
389 head normal forms, so we don't want to chuck them away lightly.
391 -- OLD: in core2stg we want to do this even if the result isn't trivial
392 -- ii) It exposes a simple variable or a type application; in short
393 -- it exposes a "trivial" expression. (exprIsTrivial)
396 etaCoreExpr :: CoreExpr -> CoreExpr
397 -- ToDo: we should really check that we don't turn a non-bottom
398 -- lambda into a bottom variable. Sigh
400 etaCoreExpr expr@(Lam bndr body)
401 = check (reverse binders) body
403 (binders, body) = collectBinders expr
406 | not (any (`elemVarSet` body_fvs) binders)
409 body_fvs = exprFreeVars body
411 check (b : bs) (App fun arg)
412 | (varToCoreExpr b `cheapEqExpr` arg)
415 check _ _ = expr -- Bale out
417 etaCoreExpr expr = expr -- The common case
421 %************************************************************************
423 \subsection{Case absorption and identity-case elimination}
425 %************************************************************************
428 mkCase :: OutExpr -> OutId -> [OutAlt] -> SimplM OutExpr
431 @mkCase@ tries the following transformation (if possible):
433 case e of b { ==> case e of b {
434 p1 -> rhs1 p1 -> rhs1
436 pm -> rhsm pm -> rhsm
437 _ -> case b of b' { pn -> rhsn[b/b'] {or (alg) let b=b' in rhsn}
438 {or (prim) case b of b' { _ -> rhsn}}
441 po -> rhso _ -> rhsd[b/b'] {or let b'=b in rhsd}
445 which merges two cases in one case when -- the default alternative of
446 the outer case scrutises the same variable as the outer case This
447 transformation is called Case Merging. It avoids that the same
448 variable is scrutinised multiple times.
451 mkCase scrut outer_bndr outer_alts
453 && maybeToBool maybe_case_in_default
455 = tick (CaseMerge outer_bndr) `thenSmpl_`
456 returnSmpl (Case scrut outer_bndr new_alts)
457 -- Warning: don't call mkCase recursively!
458 -- Firstly, there's no point, because inner alts have already had
459 -- mkCase applied to them, so they won't have a case in their default
460 -- Secondly, if you do, you get an infinite loop, because the bindNonRec
461 -- in munge_rhs puts a case into the DEFAULT branch!
463 new_alts = outer_alts_without_deflt ++ munged_inner_alts
464 maybe_case_in_default = case findDefault outer_alts of
465 (outer_alts_without_default,
466 Just (Case (Var scrut_var) inner_bndr inner_alts))
468 | outer_bndr == scrut_var
469 -> Just (outer_alts_without_default, inner_bndr, inner_alts)
472 Just (outer_alts_without_deflt, inner_bndr, inner_alts) = maybe_case_in_default
474 -- Eliminate any inner alts which are shadowed by the outer ones
475 outer_cons = [con | (con,_,_) <- outer_alts_without_deflt]
477 munged_inner_alts = [ (con, args, munge_rhs rhs)
478 | (con, args, rhs) <- inner_alts,
479 not (con `elem` outer_cons) -- Eliminate shadowed inner alts
481 munge_rhs rhs = bindNonRec inner_bndr (Var outer_bndr) rhs
484 Now the identity-case transformation:
493 mkCase scrut case_bndr alts
494 | all identity_alt alts
495 = tick (CaseIdentity case_bndr) `thenSmpl_`
498 identity_alt (DEFAULT, [], Var v) = v == case_bndr
499 identity_alt (con, args, Con con' args') = con == con' &&
500 and (zipWithEqual "mkCase"
502 (map Type arg_tys ++ map varToCoreExpr args)
504 identity_alt other = False
506 arg_tys = case splitTyConApp_maybe (idType case_bndr) of
507 Just (tycon, arg_tys) -> arg_tys
513 mkCase other_scrut case_bndr other_alts
514 = returnSmpl (Case other_scrut case_bndr other_alts)
519 findDefault :: [CoreAlt] -> ([CoreAlt], Maybe CoreExpr)
520 findDefault [] = ([], Nothing)
521 findDefault ((DEFAULT,args,rhs) : alts) = ASSERT( null alts && null args )
523 findDefault (alt : alts) = case findDefault alts of
524 (alts', deflt) -> (alt : alts', deflt)
526 findAlt :: Con -> [CoreAlt] -> CoreAlt
530 go [] = pprPanic "Missing alternative" (ppr con $$ vcat (map ppr alts))
531 go (alt : alts) | matches alt = alt
532 | otherwise = go alts
534 matches (DEFAULT, _, _) = True
535 matches (con1, _, _) = con == con1
538 mkCoerce to_ty (Note (Coerce _ from_ty) expr)
539 | to_ty == from_ty = expr
540 | otherwise = Note (Coerce to_ty from_ty) expr
542 = Note (Coerce to_ty (coreExprType expr)) expr