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 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     occ_anal_scrut (Var v) (alt1 : other_alts)
 527                                 | not (null other_alts) || not (isDefaultAlt alt1)
 528                                 = (mkOneOcc env v True, Var v)
 529     occ_anal_scrut scrut alts   = occAnal vanillaCtxt scrut
 530                                         -- No need for rhsCtxt
 531
 532 occAnal env (Let bind body)
 533   = case occAnal env body                of { (body_usage, body') ->
 534     case occAnalBind env bind body_usage of { (final_usage, new_binds) ->
 535        (final_usage, mkLets new_binds body') }}
 536
 537 occAnalArgs env args
 538   = case mapAndUnzip (occAnal arg_env) args of  { (arg_uds_s, args') ->
 539     (foldr combineUsageDetails emptyDetails arg_uds_s, args')}
 540   where
 541     arg_env = vanillaCtxt
 542 \end{code}
 543
 544 Applications are dealt with specially because we want
 545 the "build hack" to work.
 546
 547 \begin{code}
 548 -- Hack for build, fold, runST
 549 occAnalApp env (Var fun, args) is_rhs
 550   = case args_stuff of { (args_uds, args') ->
 551     let
 552         -- We mark the free vars of the argument of a constructor or PAP
 553         -- as "many", if it is the RHS of a let(rec).
 554         -- This means that nothing gets inlined into a constructor argument
 555         -- position, which is what we want.  Typically those constructor
 556         -- arguments are just variables, or trivial expressions.
 557         --
 558         -- This is the *whole point* of the isRhsEnv predicate
 559         final_args_uds
 560                 | isRhsEnv env,
 561                   isDataConWorkId fun || valArgCount args < idArity fun
 562                 = mapVarEnv markMany args_uds
 563                 | otherwise = args_uds
 564     in
 565     (fun_uds `combineUsageDetails` final_args_uds, mkApps (Var fun) args') }
 566   where
 567     fun_uniq = idUnique fun
 568     fun_uds  = mkOneOcc env fun (valArgCount args > 0)
 569     args_stuff  | fun_uniq == buildIdKey    = appSpecial env 2 [True,True]  args
 570                 | fun_uniq == augmentIdKey  = appSpecial env 2 [True,True]  args
 571                 | fun_uniq == foldrIdKey    = appSpecial env 3 [False,True] args
 572                 | fun_uniq == runSTRepIdKey = appSpecial env 2 [True]       args
 573                         -- (foldr k z xs) may call k many times, but it never
 574                         -- shares a partial application of k; hence [False,True]
 575                         -- This means we can optimise
 576                         --      foldr (\x -> let v = ...x... in \y -> ...v...) z xs
 577                         -- by floating in the v
 578
 579                 | otherwise = occAnalArgs env args
 580
 581
 582 occAnalApp env (fun, args) is_rhs
 583   = case occAnal (addAppCtxt env args) fun of   { (fun_uds, fun') ->
 584         -- The addAppCtxt is a bit cunning.  One iteration of the simplifier
 585         -- often leaves behind beta redexs like
 586         --      (\x y -> e) a1 a2
 587         -- Here we would like to mark x,y as one-shot, and treat the whole
 588         -- thing much like a let.  We do this by pushing some True items
 589         -- onto the context stack.
 590
 591     case occAnalArgs env args of        { (args_uds, args') ->
 592     let
 593         final_uds = fun_uds `combineUsageDetails` args_uds
 594     in
 595     (final_uds, mkApps fun' args') }}
 596
 597 appSpecial :: OccEnv
 598            -> Int -> CtxtTy     -- Argument number, and context to use for it
 599            -> [CoreExpr]
 600            -> (UsageDetails, [CoreExpr])
 601 appSpecial env n ctxt args
 602   = go n args
 603   where
 604     arg_env = vanillaCtxt
 605
 606     go n [] = (emptyDetails, [])        -- Too few args
 607
 608     go 1 (arg:args)                     -- The magic arg
 609       = case occAnal (setCtxt arg_env ctxt) arg of      { (arg_uds, arg') ->
 610         case occAnalArgs env args of                    { (args_uds, args') ->
 611         (combineUsageDetails arg_uds args_uds, arg':args') }}
 612
 613     go n (arg:args)
 614       = case occAnal arg_env arg of     { (arg_uds, arg') ->
 615         case go (n-1) args of           { (args_uds, args') ->
 616         (combineUsageDetails arg_uds args_uds, arg':args') }}
 617 \end{code}
 618
 619
 620 Case alternatives
 621 ~~~~~~~~~~~~~~~~~
 622 If the case binder occurs at all, the other binders effectively do too.
 623 For example
 624         case e of x { (a,b) -> rhs }
 625 is rather like
 626         let x = (a,b) in rhs
 627 If e turns out to be (e1,e2) we indeed get something like
 628         let a = e1; b = e2; x = (a,b) in rhs
 629
 630 \begin{code}
 631 occAnalAlt env case_bndr (con, bndrs, rhs)
 632   = case occAnal env rhs of { (rhs_usage, rhs') ->
 633     let
 634         (final_usage, tagged_bndrs) = tagBinders rhs_usage bndrs
 635         final_bndrs | case_bndr `elemVarEnv` final_usage = bndrs
 636                     | otherwise                         = tagged_bndrs
 637                 -- Leave the binders untagged if the case
 638                 -- binder occurs at all; see note above
 639     in
 640     (final_usage, (con, final_bndrs, rhs')) }
 641 \end{code}
 642
 643
 644 %************************************************************************
 645 %*                                                                      *
 646 \subsection[OccurAnal-types]{OccEnv}
 647 %*                                                                      *
 648 %************************************************************************
 649
 650 \begin{code}
 651 data OccEnv
 652   = OccEnv OccEncl      -- Enclosing context information
 653            CtxtTy       -- Tells about linearity
 654
 655 -- OccEncl is used to control whether to inline into constructor arguments
 656 -- For example:
 657 --      x = (p,q)               -- Don't inline p or q
 658 --      y = /\a -> (p a, q a)   -- Still don't inline p or q
 659 --      z = f (p,q)             -- Do inline p,q; it may make a rule fire
 660 -- So OccEncl tells enought about the context to know what to do when
 661 -- we encounter a contructor application or PAP.
 662
 663 data OccEncl
 664   = OccRhs              -- RHS of let(rec), albeit perhaps inside a type lambda
 665                         -- Don't inline into constructor args here
 666   | OccVanilla          -- Argument of function, body of lambda, scruintee of case etc.
 667                         -- Do inline into constructor args here
 668
 669 type CtxtTy = [Bool]
 670         -- []           No info
 671         --
 672         -- True:ctxt    Analysing a function-valued expression that will be
 673         --                      applied just once
 674         --
 675         -- False:ctxt   Analysing a function-valued expression that may
 676         --                      be applied many times; but when it is,
 677         --                      the CtxtTy inside applies
 678
 679 initOccEnv :: OccEnv
 680 initOccEnv = OccEnv OccRhs []
 681
 682 vanillaCtxt = OccEnv OccVanilla []
 683 rhsCtxt     = OccEnv OccRhs     []
 684
 685 isRhsEnv (OccEnv OccRhs     _) = True
 686 isRhsEnv (OccEnv OccVanilla _) = False
 687
 688 setCtxt :: OccEnv -> CtxtTy -> OccEnv
 689 setCtxt (OccEnv encl _) ctxt = OccEnv encl ctxt
 690
 691 oneShotGroup :: OccEnv -> [CoreBndr] -> [CoreBndr]
 692         -- The result binders have one-shot-ness set that they might not have had originally.
 693         -- This happens in (build (\cn -> e)).  Here the occurrence analyser
 694         -- linearity context knows that c,n are one-shot, and it records that fact in
 695         -- the binder. This is useful to guide subsequent float-in/float-out tranformations
 696
 697 oneShotGroup (OccEnv encl ctxt) bndrs
 698   = go ctxt bndrs []
 699   where
 700     go ctxt [] rev_bndrs = reverse rev_bndrs
 701
 702     go (lin_ctxt:ctxt) (bndr:bndrs) rev_bndrs
 703         | isId bndr = go ctxt bndrs (bndr':rev_bndrs)
 704         where
 705           bndr' | lin_ctxt  = setOneShotLambda bndr
 706                 | otherwise = bndr
 707
 708     go ctxt (bndr:bndrs) rev_bndrs = go ctxt bndrs (bndr:rev_bndrs)
 709
 710 addAppCtxt (OccEnv encl ctxt) args
 711   = OccEnv encl (replicate (valArgCount args) True ++ ctxt)
 712 \end{code}
 713
 714 %************************************************************************
 715 %*                                                                      *
 716 \subsection[OccurAnal-types]{OccEnv}
 717 %*                                                                      *
 718 %************************************************************************
 719
 720 \begin{code}
 721 type UsageDetails = IdEnv OccInfo       -- A finite map from ids to their usage
 722
 723 combineUsageDetails, combineAltsUsageDetails
 724         :: UsageDetails -> UsageDetails -> UsageDetails
 725
 726 combineUsageDetails usage1 usage2
 727   = plusVarEnv_C addOccInfo usage1 usage2
 728
 729 combineAltsUsageDetails usage1 usage2
 730   = plusVarEnv_C orOccInfo usage1 usage2
 731
 732 addOneOcc :: UsageDetails -> Id -> OccInfo -> UsageDetails
 733 addOneOcc usage id info
 734   = plusVarEnv_C addOccInfo usage (unitVarEnv id info)
 735         -- ToDo: make this more efficient
 736
 737 emptyDetails = (emptyVarEnv :: UsageDetails)
 738
 739 usedIn :: Id -> UsageDetails -> Bool
 740 v `usedIn` details =  isExportedId v || v `elemVarEnv` details
 741
 742 tagBinders :: UsageDetails          -- Of scope
 743            -> [Id]                  -- Binders
 744            -> (UsageDetails,        -- Details with binders removed
 745               [IdWithOccInfo])    -- Tagged binders
 746
 747 tagBinders usage binders
 748  = let
 749      usage' = usage `delVarEnvList` binders
 750      uss    = map (setBinderOcc usage) binders
 751    in
 752    usage' `seq` (usage', uss)
 753
 754 tagBinder :: UsageDetails           -- Of scope
 755           -> Id                     -- Binders
 756           -> (UsageDetails,         -- Details with binders removed
 757               IdWithOccInfo)        -- Tagged binders
 758
 759 tagBinder usage binder
 760  = let
 761      usage'  = usage `delVarEnv` binder
 762      binder' = setBinderOcc usage binder
 763    in
 764    usage' `seq` (usage', binder')
 765
 766 setBinderOcc :: UsageDetails -> CoreBndr -> CoreBndr
 767 setBinderOcc usage bndr
 768   | isTyVar bndr      = bndr
 769   | isExportedId bndr = case idOccInfo bndr of
 770                           NoOccInfo -> bndr
 771                           other     -> setIdOccInfo bndr NoOccInfo
 772             -- Don't use local usage info for visible-elsewhere things
 773             -- BUT *do* erase any IAmALoopBreaker annotation, because we're
 774             -- about to re-generate it and it shouldn't be "sticky"
 775
 776   | otherwise = setIdOccInfo bndr occ_info
 777   where
 778     occ_info = lookupVarEnv usage bndr `orElse` IAmDead
 779 \end{code}
 780
 781
 782 %************************************************************************
 783 %*                                                                      *
 784 \subsection{Operations over OccInfo}
 785 %*                                                                      *
 786 %************************************************************************
 787
 788 \begin{code}
 789 mkOneOcc :: OccEnv -> Id -> InterestingCxt -> UsageDetails
 790 mkOneOcc env id int_cxt
 791   | isLocalId id = unitVarEnv id (OneOcc False True int_cxt)
 792   | otherwise    = emptyDetails
 793
 794 markMany, markInsideLam, markInsideSCC :: OccInfo -> OccInfo
 795
 796 markMany IAmDead = IAmDead
 797 markMany other   = NoOccInfo
 798
 799 markInsideSCC occ = markMany occ
 800
 801 markInsideLam (OneOcc _ one_br int_cxt) = OneOcc True one_br int_cxt
 802 markInsideLam occ                       = occ
 803
 804 addOccInfo, orOccInfo :: OccInfo -> OccInfo -> OccInfo
 805
 806 addOccInfo IAmDead info2 = info2
 807 addOccInfo info1 IAmDead = info1
 808 addOccInfo info1 info2   = NoOccInfo
 809
 810 -- (orOccInfo orig new) is used
 811 -- when combining occurrence info from branches of a case
 812
 813 orOccInfo IAmDead info2 = info2
 814 orOccInfo info1 IAmDead = info1
 815 orOccInfo (OneOcc in_lam1 one_branch1 int_cxt1)
 816           (OneOcc in_lam2 one_branch2 int_cxt2)
 817   = OneOcc (in_lam1 || in_lam2)
 818            False        -- False, because it occurs in both branches
 819            (int_cxt1 && int_cxt2)
 820
 821 orOccInfo info1 info2 = NoOccInfo
 822 \end{code}