compiler/simplCore/OccurAnal.lhs

   1 %
   2 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
   3 %
   4 %************************************************************************
   5 %*                                                                      *
   6 \section[OccurAnal]{Occurrence analysis pass}
   7 %*                                                                      *
   8 %************************************************************************
   9
  10 The occurrence analyser re-typechecks a core expression, returning a new
  11 core expression with (hopefully) improved usage information.
  12
  13 \begin{code}
  14 module OccurAnal (
  15         occurAnalysePgm, occurAnalyseExpr
  16     ) where
  17
  18 #include "HsVersions.h"
  19
  20 import CoreSyn
  21 import CoreFVs          ( idRuleVars )
  22 import CoreUtils        ( exprIsTrivial, isDefaultAlt )
  23 import Id               ( isDataConWorkId, isOneShotBndr, setOneShotLambda,
  24                           idOccInfo, setIdOccInfo, isLocalId,
  25                           isExportedId, idArity, idHasRules,
  26                           idType, idUnique, Id
  27                         )
  28 import BasicTypes       ( OccInfo(..), isOneOcc, InterestingCxt )
  29
  30 import VarSet
  31 import VarEnv
  32
  33 import Type             ( isFunTy, dropForAlls )
  34 import Maybes           ( orElse )
  35 import Digraph          ( stronglyConnCompR, SCC(..) )
  36 import PrelNames        ( buildIdKey, foldrIdKey, runSTRepIdKey, augmentIdKey )
  37 import Unique           ( Unique )
  38 import UniqFM           ( keysUFM )
  39 import Util             ( zipWithEqual, mapAndUnzip )
  40 import Outputable
  41 \end{code}
  42
  43
  44 %************************************************************************
  45 %*                                                                      *
  46 \subsection[OccurAnal-main]{Counting occurrences: main function}
  47 %*                                                                      *
  48 %************************************************************************
  49
  50 Here's the externally-callable interface:
  51
  52 \begin{code}
  53 occurAnalysePgm :: [CoreBind] -> [CoreBind]
  54 occurAnalysePgm binds
  55   = snd (go initOccEnv binds)
  56   where
  57     go :: OccEnv -> [CoreBind] -> (UsageDetails, [CoreBind])
  58     go env []
  59         = (emptyDetails, [])
  60     go env (bind:binds)
  61         = (final_usage, bind' ++ binds')
  62         where
  63            (bs_usage, binds')   = go env binds
  64            (final_usage, bind') = occAnalBind env bind bs_usage
  65
  66 occurAnalyseExpr :: CoreExpr -> CoreExpr
  67         -- Do occurrence analysis, and discard occurence info returned
  68 occurAnalyseExpr expr = snd (occAnal initOccEnv expr)
  69 \end{code}
  70
  71
  72 %************************************************************************
  73 %*                                                                      *
  74 \subsection[OccurAnal-main]{Counting occurrences: main function}
  75 %*                                                                      *
  76 %************************************************************************
  77
  78 Bindings
  79 ~~~~~~~~
  80
  81 \begin{code}
  82 type IdWithOccInfo = Id                 -- An Id with fresh PragmaInfo attached
  83
  84 type Node details = (details, Unique, [Unique]) -- The Ints are gotten from the Unique,
  85                                                 -- which is gotten from the Id.
  86 type Details1     = (Id, UsageDetails, CoreExpr)
  87 type Details2     = (IdWithOccInfo, CoreExpr)
  88
  89
  90 occAnalBind :: OccEnv
  91             -> CoreBind
  92             -> UsageDetails             -- Usage details of scope
  93             -> (UsageDetails,           -- Of the whole let(rec)
  94                 [CoreBind])
  95
  96 occAnalBind env (NonRec binder rhs) body_usage
  97   | not (binder `usedIn` body_usage)            -- It's not mentioned
  98   = (body_usage, [])
  99
 100   | otherwise                   -- It's mentioned in the body
 101   = (final_body_usage `combineUsageDetails` rhs_usage,
 102      [NonRec tagged_binder rhs'])
 103
 104   where
 105     (final_body_usage, tagged_binder) = tagBinder body_usage binder
 106     (rhs_usage, rhs')                 = occAnalRhs env tagged_binder rhs
 107 \end{code}
 108
 109 Dropping dead code for recursive bindings is done in a very simple way:
 110
 111         the entire set of bindings is dropped if none of its binders are
 112         mentioned in its body; otherwise none are.
 113
 114 This seems to miss an obvious improvement.
 115 @
 116         letrec  f = ...g...
 117                 g = ...f...
 118         in
 119         ...g...
 120
 121 ===>
 122
 123         letrec f = ...g...
 124                g = ...(...g...)...
 125         in
 126         ...g...
 127 @
 128
 129 Now @f@ is unused. But dependency analysis will sort this out into a
 130 @letrec@ for @g@ and a @let@ for @f@, and then @f@ will get dropped.
 131 It isn't easy to do a perfect job in one blow.  Consider
 132
 133 @
 134         letrec f = ...g...
 135                g = ...h...
 136                h = ...k...
 137                k = ...m...
 138                m = ...m...
 139         in
 140         ...m...
 141 @
 142
 143
 144 \begin{code}
 145 occAnalBind env (Rec pairs) body_usage
 146   = foldr (_scc_ "occAnalBind.dofinal" do_final_bind) (body_usage, []) sccs
 147   where
 148     analysed_pairs :: [Details1]
 149     analysed_pairs  = [ (bndr, rhs_usage, rhs')
 150                       | (bndr, rhs) <- pairs,
 151                         let (rhs_usage, rhs') = occAnalRhs env bndr rhs
 152                       ]
 153
 154     sccs :: [SCC (Node Details1)]
 155     sccs = _scc_ "occAnalBind.scc" stronglyConnCompR edges
 156
 157
 158     ---- stuff for dependency analysis of binds -------------------------------
 159     edges :: [Node Details1]
 160     edges = _scc_ "occAnalBind.assoc"
 161             [ (details, idUnique id, edges_from rhs_usage)
 162             | details@(id, rhs_usage, rhs) <- analysed_pairs
 163             ]
 164
 165         -- (a -> b) means a mentions b
 166         -- Given the usage details (a UFM that gives occ info for each free var of
 167         -- the RHS) we can get the list of free vars -- or rather their Int keys --
 168         -- by just extracting the keys from the finite map.  Grimy, but fast.
 169         -- Previously we had this:
 170         --      [ bndr | bndr <- bndrs,
 171         --               maybeToBool (lookupVarEnv rhs_usage bndr)]
 172         -- which has n**2 cost, and this meant that edges_from alone
 173         -- consumed 10% of total runtime!
 174     edges_from :: UsageDetails -> [Unique]
 175     edges_from rhs_usage = _scc_ "occAnalBind.edges_from"
 176                            keysUFM rhs_usage
 177
 178     ---- stuff to "re-constitute" bindings from dependency-analysis info ------
 179
 180         -- Non-recursive SCC
 181     do_final_bind (AcyclicSCC ((bndr, rhs_usage, rhs'), _, _)) (body_usage, binds_so_far)
 182       | not (bndr `usedIn` body_usage)
 183       = (body_usage, binds_so_far)                      -- Dead code
 184       | otherwise
 185       = (combined_usage, new_bind : binds_so_far)
 186       where
 187         total_usage                   = combineUsageDetails body_usage rhs_usage
 188         (combined_usage, tagged_bndr) = tagBinder total_usage bndr
 189         new_bind                      = NonRec tagged_bndr rhs'
 190
 191         -- Recursive SCC
 192     do_final_bind (CyclicSCC cycle) (body_usage, binds_so_far)
 193       | not (any (`usedIn` body_usage) bndrs)           -- NB: look at body_usage, not total_usage
 194       = (body_usage, binds_so_far)                      -- Dead code
 195       | otherwise
 196       = (combined_usage, final_bind:binds_so_far)
 197       where
 198         details                        = [details   | (details, _, _) <- cycle]
 199         bndrs                          = [bndr      | (bndr, _, _)      <- details]
 200         rhs_usages                     = [rhs_usage | (_, rhs_usage, _) <- details]
 201         total_usage                    = foldr combineUsageDetails body_usage rhs_usages
 202         (combined_usage, tagged_bndrs) = tagBinders total_usage bndrs
 203         final_bind                     = Rec (reOrderRec env new_cycle)
 204
 205         new_cycle = CyclicSCC (zipWithEqual "occAnalBind" mk_new_bind tagged_bndrs cycle)
 206         mk_new_bind tagged_bndr ((_, _, rhs'), key, keys) = ((tagged_bndr, rhs'), key, keys)
 207 \end{code}
 208
 209 @reOrderRec@ is applied to the list of (binder,rhs) pairs for a cyclic
 210 strongly connected component (there's guaranteed to be a cycle).  It returns the
 211 same pairs, but
 212         a) in a better order,
 213         b) with some of the Ids having a IMustNotBeINLINEd pragma
 214
 215 The "no-inline" Ids are sufficient to break all cycles in the SCC.  This means
 216 that the simplifier can guarantee not to loop provided it never records an inlining
 217 for these no-inline guys.
 218
 219 Furthermore, the order of the binds is such that if we neglect dependencies
 220 on the no-inline Ids then the binds are topologically sorted.  This means
 221 that the simplifier will generally do a good job if it works from top bottom,
 222 recording inlinings for any Ids which aren't marked as "no-inline" as it goes.
 223
 224 ==============
 225 [June 98: I don't understand the following paragraphs, and I've
 226           changed the a=b case again so that it isn't a special case any more.]
 227
 228 Here's a case that bit me:
 229
 230         letrec
 231                 a = b
 232                 b = \x. BIG
 233         in
 234         ...a...a...a....
 235
 236 Re-ordering doesn't change the order of bindings, but there was no loop-breaker.
 237
 238 My solution was to make a=b bindings record b as Many, rather like INLINE bindings.
 239 Perhaps something cleverer would suffice.
 240 ===============
 241
 242 You might think that you can prevent non-termination simply by making
 243 sure that we simplify a recursive binding's RHS in an environment that
 244 simply clones the recursive Id.  But no.  Consider
 245
 246                 letrec f = \x -> let z = f x' in ...
 247
 248                 in
 249                 let n = f y
 250                 in
 251                 case n of { ... }
 252
 253 We bind n to its *simplified* RHS, we then *re-simplify* it when
 254 we inline n.  Then we may well inline f; and then the same thing
 255 happens with z!
 256
 257 I don't think it's possible to prevent non-termination by environment
 258 manipulation in this way.  Apart from anything else, successive
 259 iterations of the simplifier may unroll recursive loops in cases like
 260 that above.  The idea of beaking every recursive loop with an
 261 IMustNotBeINLINEd pragma is much much better.
 262
 263
 264 \begin{code}
 265 reOrderRec
 266         :: OccEnv
 267         -> SCC (Node Details2)
 268         -> [Details2]
 269                         -- Sorted into a plausible order.  Enough of the Ids have
 270                         --      dontINLINE pragmas that there are no loops left.
 271
 272         -- Non-recursive case
 273 reOrderRec env (AcyclicSCC (bind, _, _)) = [bind]
 274
 275         -- Common case of simple self-recursion
 276 reOrderRec env (CyclicSCC [bind])
 277   = [(setIdOccInfo tagged_bndr IAmALoopBreaker, rhs)]
 278   where
 279     ((tagged_bndr, rhs), _, _) = bind
 280
 281 reOrderRec env (CyclicSCC (bind : binds))
 282   =     -- Choose a loop breaker, mark it no-inline,
 283         -- do SCC analysis on the rest, and recursively sort them out
 284     concat (map (reOrderRec env) (stronglyConnCompR unchosen))
 285     ++
 286     [(setIdOccInfo tagged_bndr IAmALoopBreaker, rhs)]
 287
 288   where
 289     (chosen_pair, unchosen) = choose_loop_breaker bind (score bind) [] binds
 290     (tagged_bndr, rhs)      = chosen_pair
 291
 292         -- This loop looks for the bind with the lowest score
 293         -- to pick as the loop  breaker.  The rest accumulate in
 294     choose_loop_breaker (details,_,_) loop_sc acc []
 295         = (details, acc)        -- Done
 296
 297     choose_loop_breaker loop_bind loop_sc acc (bind : binds)
 298         | sc < loop_sc  -- Lower score so pick this new one
 299         = choose_loop_breaker bind sc (loop_bind : acc) binds
 300
 301         | otherwise     -- No lower so don't pick it
 302         = choose_loop_breaker loop_bind loop_sc (bind : acc) binds
 303         where
 304           sc = score bind
 305
 306     score :: Node Details2 -> Int       -- Higher score => less likely to be picked as loop breaker
 307     score ((bndr, rhs), _, _)
 308         | exprIsTrivial rhs        = 4  -- Practically certain to be inlined
 309                 -- Used to have also: && not (isExportedId bndr)
 310                 -- But I found this sometimes cost an extra iteration when we have
 311                 --      rec { d = (a,b); a = ...df...; b = ...df...; df = d }
 312                 -- where df is the exported dictionary. Then df makes a really
 313                 -- bad choice for loop breaker
 314
 315         | not_fun_ty (idType bndr) = 3  -- Data types help with cases
 316                 -- This used to have a lower score than inlineCandidate, but
 317                 -- it's *really* helpful if dictionaries get inlined fast,
 318                 -- so I'm experimenting with giving higher priority to data-typed things
 319
 320         | inlineCandidate bndr rhs = 2  -- Likely to be inlined
 321
 322         | idHasRules bndr = 1
 323                 -- Avoid things with specialisations; we'd like
 324                 -- to take advantage of them in the subsequent bindings
 325
 326         | otherwise = 0
 327
 328     inlineCandidate :: Id -> CoreExpr -> Bool
 329     inlineCandidate id (Note InlineMe _) = True
 330     inlineCandidate id rhs               = isOneOcc (idOccInfo id)
 331
 332         -- Real example (the Enum Ordering instance from PrelBase):
 333         --      rec     f = \ x -> case d of (p,q,r) -> p x
 334         --              g = \ x -> case d of (p,q,r) -> q x
 335         --              d = (v, f, g)
 336         --
 337         -- Here, f and g occur just once; but we can't inline them into d.
 338         -- On the other hand we *could* simplify those case expressions if
 339         -- we didn't stupidly choose d as the loop breaker.
 340         -- But we won't because constructor args are marked "Many".
 341
 342     not_fun_ty ty = not (isFunTy (dropForAlls ty))
 343 \end{code}
 344
 345 @occAnalRhs@ deals with the question of bindings where the Id is marked
 346 by an INLINE pragma.  For these we record that anything which occurs
 347 in its RHS occurs many times.  This pessimistically assumes that ths
 348 inlined binder also occurs many times in its scope, but if it doesn't
 349 we'll catch it next time round.  At worst this costs an extra simplifier pass.
 350 ToDo: try using the occurrence info for the inline'd binder.
 351
 352 [March 97] We do the same for atomic RHSs.  Reason: see notes with reOrderRec.
 353 [June 98, SLPJ]  I've undone this change; I don't understand it.  See notes with reOrderRec.
 354
 355
 356 \begin{code}
 357 occAnalRhs :: OccEnv
 358            -> Id -> CoreExpr    -- Binder and rhs
 359                                 -- For non-recs the binder is alrady tagged
 360                                 -- with occurrence info
 361            -> (UsageDetails, CoreExpr)
 362
 363 occAnalRhs env id rhs
 364   = (final_usage, rhs')
 365   where
 366     (rhs_usage, rhs') = occAnal ctxt rhs
 367     ctxt | certainly_inline id = env
 368          | otherwise           = rhsCtxt
 369         -- Note that we generally use an rhsCtxt.  This tells the occ anal n
 370         -- that it's looking at an RHS, which has an effect in occAnalApp
 371         --
 372         -- But there's a problem.  Consider
 373         --      x1 = a0 : []
 374         --      x2 = a1 : x1
 375         --      x3 = a2 : x2
 376         --      g  = f x3
 377         -- First time round, it looks as if x1 and x2 occur as an arg of a
 378         -- let-bound constructor ==> give them a many-occurrence.
 379         -- But then x3 is inlined (unconditionally as it happens) and
 380         -- next time round, x2 will be, and the next time round x1 will be
 381         -- Result: multiple simplifier iterations.  Sigh.
 382         -- Crude solution: use rhsCtxt for things that occur just once...
 383
 384     certainly_inline id = case idOccInfo id of
 385                             OneOcc in_lam one_br _ -> not in_lam && one_br
 386                             other                  -> False
 387
 388         -- [March 98] A new wrinkle is that if the binder has specialisations inside
 389         -- it then we count the specialised Ids as "extra rhs's".  That way
 390         -- the "parent" keeps the specialised "children" alive.  If the parent
 391         -- dies (because it isn't referenced any more), then the children will
 392         -- die too unless they are already referenced directly.
 393
 394     final_usage = addRuleUsage rhs_usage id
 395
 396 addRuleUsage :: UsageDetails -> Id -> UsageDetails
 397 -- Add the usage from RULES in Id to the usage
 398 addRuleUsage usage id
 399   = foldVarSet add usage (idRuleVars id)
 400   where
 401     add v u = addOneOcc u v NoOccInfo           -- Give a non-committal binder info
 402                                                 -- (i.e manyOcc) because many copies
 403                                                 -- of the specialised thing can appear
 404 \end{code}
 405
 406 Expressions
 407 ~~~~~~~~~~~
 408 \begin{code}
 409 occAnal :: OccEnv
 410         -> CoreExpr
 411         -> (UsageDetails,       -- Gives info only about the "interesting" Ids
 412             CoreExpr)
 413
 414 occAnal env (Type t)  = (emptyDetails, Type t)
 415 occAnal env (Var v)   = (mkOneOcc env v False, Var v)
 416     -- At one stage, I gathered the idRuleVars for v here too,
 417     -- which in a way is the right thing to do.
 418     -- Btu that went wrong right after specialisation, when
 419     -- the *occurrences* of the overloaded function didn't have any
 420     -- rules in them, so the *specialised* versions looked as if they
 421     -- weren't used at all.
 422 \end{code}
 423
 424 We regard variables that occur as constructor arguments as "dangerousToDup":
 425
 426 \begin{verbatim}
 427 module A where
 428 f x = let y = expensive x in
 429       let z = (True,y) in
 430       (case z of {(p,q)->q}, case z of {(p,q)->q})
 431 \end{verbatim}
 432
 433 We feel free to duplicate the WHNF (True,y), but that means
 434 that y may be duplicated thereby.
 435
 436 If we aren't careful we duplicate the (expensive x) call!
 437 Constructors are rather like lambdas in this way.
 438
 439 \begin{code}
 440 occAnal env expr@(Lit lit) = (emptyDetails, expr)
 441 \end{code}
 442
 443 \begin{code}
 444 occAnal env (Note InlineMe body)
 445   = case occAnal env body of { (usage, body') ->
 446     (mapVarEnv markMany usage, Note InlineMe body')
 447     }
 448
 449 occAnal env (Note note@(SCC cc) body)
 450   = case occAnal env body of { (usage, body') ->
 451     (mapVarEnv markInsideSCC usage, Note note body')
 452     }
 453
 454 occAnal env (Note note body)
 455   = case occAnal env body of { (usage, body') ->
 456     (usage, Note note body')
 457     }
 458 \end{code}
 459
 460 \begin{code}
 461 occAnal env app@(App fun arg)
 462   = occAnalApp env (collectArgs app) False
 463
 464 -- Ignore type variables altogether
 465 --   (a) occurrences inside type lambdas only not marked as InsideLam
 466 --   (b) type variables not in environment
 467
 468 occAnal env expr@(Lam x body) | isTyVar x
 469   = case occAnal env body of { (body_usage, body') ->
 470     (body_usage, Lam x body')
 471     }
 472
 473 -- For value lambdas we do a special hack.  Consider
 474 --      (\x. \y. ...x...)
 475 -- If we did nothing, x is used inside the \y, so would be marked
 476 -- as dangerous to dup.  But in the common case where the abstraction
 477 -- is applied to two arguments this is over-pessimistic.
 478 -- So instead, we just mark each binder with its occurrence
 479 -- info in the *body* of the multiple lambda.
 480 -- Then, the simplifier is careful when partially applying lambdas.
 481
 482 occAnal env expr@(Lam _ _)
 483   = case occAnal env_body body of { (body_usage, body') ->
 484     let
 485         (final_usage, tagged_binders) = tagBinders body_usage binders
 486         --      URGH!  Sept 99: we don't seem to be able to use binders' here, because
 487         --      we get linear-typed things in the resulting program that we can't handle yet.
 488         --      (e.g. PrelShow)  TODO
 489
 490         really_final_usage = if linear then
 491                                 final_usage
 492                              else
 493                                 mapVarEnv markInsideLam final_usage
 494     in
 495     (really_final_usage,
 496      mkLams tagged_binders body') }
 497   where
 498     env_body        = vanillaCtxt                       -- Body is (no longer) an RhsContext
 499     (binders, body) = collectBinders expr
 500     binders'        = oneShotGroup env binders
 501     linear          = all is_one_shot binders'
 502     is_one_shot b   = isId b && isOneShotBndr b
 503
 504 occAnal env (Case scrut bndr ty alts)
 505   = case occ_anal_scrut scrut alts                  of { (scrut_usage, scrut') ->
 506     case mapAndUnzip (occAnalAlt alt_env bndr) alts of { (alts_usage_s, alts')   ->
 507     let
 508         alts_usage  = foldr1 combineAltsUsageDetails alts_usage_s
 509         alts_usage' = addCaseBndrUsage alts_usage
 510         (alts_usage1, tagged_bndr) = tagBinder alts_usage' bndr
 511         total_usage = scrut_usage `combineUsageDetails` alts_usage1
 512     in
 513     total_usage `seq` (total_usage, Case scrut' tagged_bndr ty alts') }}
 514   where
 515         -- The case binder gets a usage of either "many" or "dead", never "one".
 516         -- Reason: we like to inline single occurrences, to eliminate a binding,
 517         -- but inlining a case binder *doesn't* eliminate a binding.
 518         -- We *don't* want to transform
 519         --      case x of w { (p,q) -> f w }
 520         -- into
 521         --      case x of w { (p,q) -> f (p,q) }
 522     addCaseBndrUsage usage = case lookupVarEnv usage bndr of
 523                                 Nothing  -> usage
 524                                 Just occ -> extendVarEnv usage bndr (markMany occ)
 525
 526     alt_env = setVanillaCtxt env
 527         -- Consider     x = case v of { True -> (p,q); ... }
 528         -- Then it's fine to inline p and q
 529
 530     occ_anal_scrut (Var v) (alt1 : other_alts)
 531                                 | not (null other_alts) || not (isDefaultAlt alt1)
 532                                 = (mkOneOcc env v True, Var v)
 533     occ_anal_scrut scrut alts   = occAnal vanillaCtxt scrut
 534                                         -- No need for rhsCtxt
 535
 536 occAnal env (Let bind body)
 537   = case occAnal env body                of { (body_usage, body') ->
 538     case occAnalBind env bind body_usage of { (final_usage, new_binds) ->
 539        (final_usage, mkLets new_binds body') }}
 540
 541 occAnalArgs env args
 542   = case mapAndUnzip (occAnal arg_env) args of  { (arg_uds_s, args') ->
 543     (foldr combineUsageDetails emptyDetails arg_uds_s, args')}
 544   where
 545     arg_env = vanillaCtxt
 546 \end{code}
 547
 548 Applications are dealt with specially because we want
 549 the "build hack" to work.
 550
 551 \begin{code}
 552 occAnalApp env (Var fun, args) is_rhs
 553   = case args_stuff of { (args_uds, args') ->
 554     let
 555         -- We mark the free vars of the argument of a constructor or PAP
 556         -- as "many", if it is the RHS of a let(rec).
 557         -- This means that nothing gets inlined into a constructor argument
 558         -- position, which is what we want.  Typically those constructor
 559         -- arguments are just variables, or trivial expressions.
 560         --
 561         -- This is the *whole point* of the isRhsEnv predicate
 562         final_args_uds
 563                 | isRhsEnv env,
 564                   isDataConWorkId fun || valArgCount args < idArity fun
 565                 = mapVarEnv markMany args_uds
 566                 | otherwise = args_uds
 567     in
 568     (fun_uds `combineUsageDetails` final_args_uds, mkApps (Var fun) args') }
 569   where
 570     fun_uniq = idUnique fun
 571     fun_uds  = mkOneOcc env fun (valArgCount args > 0)
 572
 573                 -- Hack for build, fold, runST
 574     args_stuff  | fun_uniq == buildIdKey    = appSpecial env 2 [True,True]  args
 575                 | fun_uniq == augmentIdKey  = appSpecial env 2 [True,True]  args
 576                 | fun_uniq == foldrIdKey    = appSpecial env 3 [False,True] args
 577                 | fun_uniq == runSTRepIdKey = appSpecial env 2 [True]       args
 578                         -- (foldr k z xs) may call k many times, but it never
 579                         -- shares a partial application of k; hence [False,True]
 580                         -- This means we can optimise
 581                         --      foldr (\x -> let v = ...x... in \y -> ...v...) z xs
 582                         -- by floating in the v
 583
 584                 | otherwise = occAnalArgs env args
 585
 586
 587 occAnalApp env (fun, args) is_rhs
 588   = case occAnal (addAppCtxt env args) fun of   { (fun_uds, fun') ->
 589         -- The addAppCtxt is a bit cunning.  One iteration of the simplifier
 590         -- often leaves behind beta redexs like
 591         --      (\x y -> e) a1 a2
 592         -- Here we would like to mark x,y as one-shot, and treat the whole
 593         -- thing much like a let.  We do this by pushing some True items
 594         -- onto the context stack.
 595
 596     case occAnalArgs env args of        { (args_uds, args') ->
 597     let
 598         final_uds = fun_uds `combineUsageDetails` args_uds
 599     in
 600     (final_uds, mkApps fun' args') }}
 601
 602 appSpecial :: OccEnv
 603            -> Int -> CtxtTy     -- Argument number, and context to use for it
 604            -> [CoreExpr]
 605            -> (UsageDetails, [CoreExpr])
 606 appSpecial env n ctxt args
 607   = go n args
 608   where
 609     arg_env = vanillaCtxt
 610
 611     go n [] = (emptyDetails, [])        -- Too few args
 612
 613     go 1 (arg:args)                     -- The magic arg
 614       = case occAnal (setCtxt arg_env ctxt) arg of      { (arg_uds, arg') ->
 615         case occAnalArgs env args of                    { (args_uds, args') ->
 616         (combineUsageDetails arg_uds args_uds, arg':args') }}
 617
 618     go n (arg:args)
 619       = case occAnal arg_env arg of     { (arg_uds, arg') ->
 620         case go (n-1) args of           { (args_uds, args') ->
 621         (combineUsageDetails arg_uds args_uds, arg':args') }}
 622 \end{code}
 623
 624
 625 Case alternatives
 626 ~~~~~~~~~~~~~~~~~
 627 If the case binder occurs at all, the other binders effectively do too.
 628 For example
 629         case e of x { (a,b) -> rhs }
 630 is rather like
 631         let x = (a,b) in rhs
 632 If e turns out to be (e1,e2) we indeed get something like
 633         let a = e1; b = e2; x = (a,b) in rhs
 634
 635 Note [Aug 06]: I don't think this is necessary any more, and it helpe
 636                to know when binders are unused.  See esp the call to
 637                isDeadBinder in Simplify.mkDupableAlt
 638
 639 \begin{code}
 640 occAnalAlt env case_bndr (con, bndrs, rhs)
 641   = case occAnal env rhs of { (rhs_usage, rhs') ->
 642     let
 643         (final_usage, tagged_bndrs) = tagBinders rhs_usage bndrs
 644         final_bndrs = tagged_bndrs      -- See Note [Aug06] above
 645 {-
 646         final_bndrs | case_bndr `elemVarEnv` final_usage = bndrs
 647                     | otherwise                         = tagged_bndrs
 648                 -- Leave the binders untagged if the case
 649                 -- binder occurs at all; see note above
 650 -}
 651     in
 652     (final_usage, (con, final_bndrs, rhs')) }
 653 \end{code}
 654
 655
 656 %************************************************************************
 657 %*                                                                      *
 658 \subsection[OccurAnal-types]{OccEnv}
 659 %*                                                                      *
 660 %************************************************************************
 661
 662 \begin{code}
 663 data OccEnv
 664   = OccEnv OccEncl      -- Enclosing context information
 665            CtxtTy       -- Tells about linearity
 666
 667 -- OccEncl is used to control whether to inline into constructor arguments
 668 -- For example:
 669 --      x = (p,q)               -- Don't inline p or q
 670 --      y = /\a -> (p a, q a)   -- Still don't inline p or q
 671 --      z = f (p,q)             -- Do inline p,q; it may make a rule fire
 672 -- So OccEncl tells enought about the context to know what to do when
 673 -- we encounter a contructor application or PAP.
 674
 675 data OccEncl
 676   = OccRhs              -- RHS of let(rec), albeit perhaps inside a type lambda
 677                         -- Don't inline into constructor args here
 678   | OccVanilla          -- Argument of function, body of lambda, scruintee of case etc.
 679                         -- Do inline into constructor args here
 680
 681 type CtxtTy = [Bool]
 682         -- []           No info
 683         --
 684         -- True:ctxt    Analysing a function-valued expression that will be
 685         --                      applied just once
 686         --
 687         -- False:ctxt   Analysing a function-valued expression that may
 688         --                      be applied many times; but when it is,
 689         --                      the CtxtTy inside applies
 690
 691 initOccEnv :: OccEnv
 692 initOccEnv = OccEnv OccRhs []
 693
 694 vanillaCtxt = OccEnv OccVanilla []
 695 rhsCtxt     = OccEnv OccRhs     []
 696
 697 isRhsEnv (OccEnv OccRhs     _) = True
 698 isRhsEnv (OccEnv OccVanilla _) = False
 699
 700 setVanillaCtxt :: OccEnv -> OccEnv
 701 setVanillaCtxt (OccEnv OccRhs ctxt_ty) = OccEnv OccVanilla ctxt_ty
 702 setVanillaCtxt other_env               = other_env
 703
 704 setCtxt :: OccEnv -> CtxtTy -> OccEnv
 705 setCtxt (OccEnv encl _) ctxt = OccEnv encl ctxt
 706
 707 oneShotGroup :: OccEnv -> [CoreBndr] -> [CoreBndr]
 708         -- The result binders have one-shot-ness set that they might not have had originally.
 709         -- This happens in (build (\cn -> e)).  Here the occurrence analyser
 710         -- linearity context knows that c,n are one-shot, and it records that fact in
 711         -- the binder. This is useful to guide subsequent float-in/float-out tranformations
 712
 713 oneShotGroup (OccEnv encl ctxt) bndrs
 714   = go ctxt bndrs []
 715   where
 716     go ctxt [] rev_bndrs = reverse rev_bndrs
 717
 718     go (lin_ctxt:ctxt) (bndr:bndrs) rev_bndrs
 719         | isId bndr = go ctxt bndrs (bndr':rev_bndrs)
 720         where
 721           bndr' | lin_ctxt  = setOneShotLambda bndr
 722                 | otherwise = bndr
 723
 724     go ctxt (bndr:bndrs) rev_bndrs = go ctxt bndrs (bndr:rev_bndrs)
 725
 726 addAppCtxt (OccEnv encl ctxt) args
 727   = OccEnv encl (replicate (valArgCount args) True ++ ctxt)
 728 \end{code}
 729
 730 %************************************************************************
 731 %*                                                                      *
 732 \subsection[OccurAnal-types]{OccEnv}
 733 %*                                                                      *
 734 %************************************************************************
 735
 736 \begin{code}
 737 type UsageDetails = IdEnv OccInfo       -- A finite map from ids to their usage
 738
 739 combineUsageDetails, combineAltsUsageDetails
 740         :: UsageDetails -> UsageDetails -> UsageDetails
 741
 742 combineUsageDetails usage1 usage2
 743   = plusVarEnv_C addOccInfo usage1 usage2
 744
 745 combineAltsUsageDetails usage1 usage2
 746   = plusVarEnv_C orOccInfo usage1 usage2
 747
 748 addOneOcc :: UsageDetails -> Id -> OccInfo -> UsageDetails
 749 addOneOcc usage id info
 750   = plusVarEnv_C addOccInfo usage (unitVarEnv id info)
 751         -- ToDo: make this more efficient
 752
 753 emptyDetails = (emptyVarEnv :: UsageDetails)
 754
 755 usedIn :: Id -> UsageDetails -> Bool
 756 v `usedIn` details =  isExportedId v || v `elemVarEnv` details
 757
 758 tagBinders :: UsageDetails          -- Of scope
 759            -> [Id]                  -- Binders
 760            -> (UsageDetails,        -- Details with binders removed
 761               [IdWithOccInfo])    -- Tagged binders
 762
 763 tagBinders usage binders
 764  = let
 765      usage' = usage `delVarEnvList` binders
 766      uss    = map (setBinderOcc usage) binders
 767    in
 768    usage' `seq` (usage', uss)
 769
 770 tagBinder :: UsageDetails           -- Of scope
 771           -> Id                     -- Binders
 772           -> (UsageDetails,         -- Details with binders removed
 773               IdWithOccInfo)        -- Tagged binders
 774
 775 tagBinder usage binder
 776  = let
 777      usage'  = usage `delVarEnv` binder
 778      binder' = setBinderOcc usage binder
 779    in
 780    usage' `seq` (usage', binder')
 781
 782 setBinderOcc :: UsageDetails -> CoreBndr -> CoreBndr
 783 setBinderOcc usage bndr
 784   | isTyVar bndr      = bndr
 785   | isExportedId bndr = case idOccInfo bndr of
 786                           NoOccInfo -> bndr
 787                           other     -> setIdOccInfo bndr NoOccInfo
 788             -- Don't use local usage info for visible-elsewhere things
 789             -- BUT *do* erase any IAmALoopBreaker annotation, because we're
 790             -- about to re-generate it and it shouldn't be "sticky"
 791
 792   | otherwise = setIdOccInfo bndr occ_info
 793   where
 794     occ_info = lookupVarEnv usage bndr `orElse` IAmDead
 795 \end{code}
 796
 797
 798 %************************************************************************
 799 %*                                                                      *
 800 \subsection{Operations over OccInfo}
 801 %*                                                                      *
 802 %************************************************************************
 803
 804 \begin{code}
 805 mkOneOcc :: OccEnv -> Id -> InterestingCxt -> UsageDetails
 806 mkOneOcc env id int_cxt
 807   | isLocalId id = unitVarEnv id (OneOcc False True int_cxt)
 808   | otherwise    = emptyDetails
 809
 810 markMany, markInsideLam, markInsideSCC :: OccInfo -> OccInfo
 811
 812 markMany IAmDead = IAmDead
 813 markMany other   = NoOccInfo
 814
 815 markInsideSCC occ = markMany occ
 816
 817 markInsideLam (OneOcc _ one_br int_cxt) = OneOcc True one_br int_cxt
 818 markInsideLam occ                       = occ
 819
 820 addOccInfo, orOccInfo :: OccInfo -> OccInfo -> OccInfo
 821
 822 addOccInfo IAmDead info2 = info2
 823 addOccInfo info1 IAmDead = info1
 824 addOccInfo info1 info2   = NoOccInfo
 825
 826 -- (orOccInfo orig new) is used
 827 -- when combining occurrence info from branches of a case
 828
 829 orOccInfo IAmDead info2 = info2
 830 orOccInfo info1 IAmDead = info1
 831 orOccInfo (OneOcc in_lam1 one_branch1 int_cxt1)
 832           (OneOcc in_lam2 one_branch2 int_cxt2)
 833   = OneOcc (in_lam1 || in_lam2)
 834            False        -- False, because it occurs in both branches
 835            (int_cxt1 && int_cxt2)
 836
 837 orOccInfo info1 info2 = NoOccInfo
 838 \end{code}