UNDO: Add -fpass-case-bndr-to-join-points

rolling back:

Fri Dec  5 10:51:59 GMT 2008  simonpj@microsoft.com
  * Add -fpass-case-bndr-to-join-points
  
  See Note [Passing the case binder to join points] in Simplify.lhs
  The default now is *not* to pass the case binder.  There are some
  nofib results with the above note; the effect is almost always 
  negligible.
  
  I don't expect this flag to be used by users (hence no docs). It's just
  there to let me try the performance effects of switching on and off.
  

    M ./compiler/main/StaticFlagParser.hs +1
    M ./compiler/main/StaticFlags.hs +4
    M ./compiler/simplCore/Simplify.lhs -14 +73

3 files changed, 14 insertions, 78 deletions

diff --git a/compiler/main/StaticFlagParser.hs b/compiler/main/StaticFlagParser.hs
index 7ed4c4c25f..31ff9d18eb 100644
--- a/compiler/main/StaticFlagParser.hs
+++ b/compiler/main/StaticFlagParser.hs
@@ -161,7 +161,6 @@ isStaticFlag f =
     "fsimple-list-literals",
     "fno-ds-multi-tyvar",
     "fruntime-types",
-    "fpass-case-bndr-to-join-points",
     "fno-pre-inlining",
     "fexcess-precision",
     "static",
diff --git a/compiler/main/StaticFlags.hs b/compiler/main/StaticFlags.hs
index 93ff1a7b79..456f62009d 100644
--- a/compiler/main/StaticFlags.hs
+++ b/compiler/main/StaticFlags.hs
@@ -38,7 +38,6 @@ module StaticFlags (
 	opt_Parallel,
 
 	-- optimisation opts
-        opt_PassCaseBndrToJoinPoints,
 	opt_DsMultiTyVar,
 	opt_NoStateHack,
         opt_SimpleListLiterals,
@@ -217,9 +216,6 @@ opt_DsMultiTyVar :: Bool
 opt_DsMultiTyVar		= not (lookUp (fsLit "-fno-ds-multi-tyvar"))
 	-- On by default
 
-opt_PassCaseBndrToJoinPoints :: Bool
-opt_PassCaseBndrToJoinPoints	= lookUp  (fsLit "-fpass-case-bndr-to-join-points")
-
 opt_SpecInlineJoinPoints :: Bool
 opt_SpecInlineJoinPoints	= lookUp  (fsLit "-fspec-inline-join-points")
 
diff --git a/compiler/simplCore/Simplify.lhs b/compiler/simplCore/Simplify.lhs
index 22c7a5a409..eba2728157 100644
--- a/compiler/simplCore/Simplify.lhs
+++ b/compiler/simplCore/Simplify.lhs
@@ -35,8 +35,6 @@ import BasicTypes       ( TopLevelFlag(..), isTopLevel,
                           RecFlag(..), isNonRuleLoopBreaker )
 import Maybes           ( orElse )
 import Data.List        ( mapAccumL )
-import MonadUtils	( foldlM )
-import StaticFlags	( opt_PassCaseBndrToJoinPoints )
 import Outputable
 import FastString
 \end{code}
@@ -1890,97 +1888,40 @@ mkDupableAlts env case_bndr' the_alts
 
 mkDupableAlt :: SimplEnv -> OutId -> (AltCon, [CoreBndr], CoreExpr)
               -> SimplM (SimplEnv, (AltCon, [CoreBndr], CoreExpr))
-mkDupableAlt env case_bndr1 (con, bndrs1, rhs1)
-  | exprIsDupable rhs1  -- Note [Small alternative rhs]
-  = return (env, (con, bndrs1, rhs1))
+mkDupableAlt env case_bndr' (con, bndrs', rhs')
+  | exprIsDupable rhs'  -- Note [Small alternative rhs]
+  = return (env, (con, bndrs', rhs'))
   | otherwise
-  = do  { let abstract_over bndr
+  = do  { let rhs_ty'     = exprType rhs'
+              used_bndrs' = filter abstract_over (case_bndr' : bndrs')
+              abstract_over bndr
                   | isTyVar bndr = True -- Abstract over all type variables just in case
                   | otherwise    = not (isDeadBinder bndr)
                         -- The deadness info on the new Ids is preserved by simplBinders
 
-              inst_tys1 = tyConAppArgs (idType case_bndr1)
-              con_app dc = mkConApp dc (map Type inst_tys1 ++ varsToCoreExprs bndrs1)
-
-	      (rhs2, final_bndrs)   -- See Note [Passing the case binder to join points]
-	         | isDeadBinder case_bndr1
-		 = (rhs1, filter abstract_over bndrs1)
-	         | opt_PassCaseBndrToJoinPoints, not (null bndrs1)
-		 = (rhs1, (case_bndr1 : filter abstract_over bndrs1))
-		 | otherwise 
-                 = case con of
-		     DataAlt dc -> (Let (NonRec case_bndr1 (con_app dc)) rhs1, bndrs1)
-		     LitAlt lit -> ASSERT( null bndrs1 ) (Let (NonRec case_bndr1 (Lit lit)) rhs1, [])
-		     DEFAULT    -> ASSERT( null bndrs1 ) (rhs1, [case_bndr1])
-
-        ; (final_bndrs1, final_args)    -- Note [Join point abstraction]
-                <- if (any isId final_bndrs)
-                   then return (final_bndrs, varsToCoreExprs final_bndrs)
+        ; (final_bndrs', final_args)    -- Note [Join point abstraction]
+                <- if (any isId used_bndrs')
+                   then return (used_bndrs', varsToCoreExprs used_bndrs')
                     else do { rw_id <- newId (fsLit "w") realWorldStatePrimTy
-                            ; return (rw_id : final_bndrs,  
-			              Var realWorldPrimId : varsToCoreExprs final_bndrs) }
+                            ; return ([rw_id], [Var realWorldPrimId]) }
 
-        ; let rhs_ty1 = exprType rhs1
-        ; join_bndr <- newId (fsLit "$j") (mkPiTypes final_bndrs1 rhs_ty1)
+        ; join_bndr <- newId (fsLit "$j") (mkPiTypes final_bndrs' rhs_ty')
                 -- Note [Funky mkPiTypes]
 
         ; let   -- We make the lambdas into one-shot-lambdas.  The
                 -- join point is sure to be applied at most once, and doing so
                 -- prevents the body of the join point being floated out by
                 -- the full laziness pass
-                really_final_bndrs     = map one_shot final_bndrs1
+                really_final_bndrs     = map one_shot final_bndrs'
                 one_shot v | isId v    = setOneShotLambda v
                            | otherwise = v
-                join_rhs  = mkLams really_final_bndrs rhs2
+                join_rhs  = mkLams really_final_bndrs rhs'
                 join_call = mkApps (Var join_bndr) final_args
 
-	; env1 <- addPolyBind NotTopLevel env (NonRec join_bndr join_rhs)
-        ; return (env1, (con, bndrs1, join_call)) }
+        ; return (addPolyBind NotTopLevel env (NonRec join_bndr join_rhs), (con, bndrs', join_call)) }
                 -- See Note [Duplicated env]
 \end{code}
 
-Note [Passing the case binder to join points]
-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Suppose we have
-   case e of cb { C1 -> r1[cb]; C2 x y z -> r2[cb,x] }
-and we want to make join points for the two alternatives, 
-which mention the case binder 'cb'.  Should we pass 'cb' to
-the join point, or reconstruct it? Here are the two alternatives 
-for the C2 alternative:
-
-  Plan A(pass cb):         j2 cb x = r2[cb,x]
-
-  Plan B(reconstruct cb):  j2 x y z = let cb = C2 x y z in r2[cb,x]
-
-The advantge of Plan B is that we can "see" the definition of cb
-in r2, and that may be important when we inline stuff in r2.  The
-disadvantage is that if this optimisation doesn't happen, we end up
-re-allocating C2, when it already exists.  This does happen occasionally;
-an example is the function nofib/spectral/cichelli/Auxil.$whinsert.
-
-Plan B is always better if the constructor is nullary.
-
-In both cases we don't have liveness info for cb on a branch-by-branch
-basis, and it's possible that 'cb' is used in some branches but not
-others.  Well, the absence analyser will find that out later, so it's
-not too bad.
-
-Sadly, at the time of writing, neither choice seems an unequivocal
-win. Here are nofib results, for adding -fpass-case-bndr-to-join-points
-(all others are zero effect):
-
-        Program           Size    Allocs   Runtime   Elapsed
---------------------------------------------------------------------------------
-       cichelli          +0.0%     -4.4%      0.13      0.13
-            pic          +0.0%     -0.7%      0.01      0.04
-      transform          -0.0%     +2.8%     -0.4%     -9.1%
-      wave4main          +0.0%    +10.5%     +3.1%     +3.4%
---------------------------------------------------------------------------------
-            Min          -0.0%     -4.4%     -7.0%    -31.9%
-            Max          +0.1%    +10.5%     +3.1%    +15.0%
- Geometric Mean          +0.0%     +0.1%     -1.7%     -6.1%
-
-
 Note [Duplicated env]
 ~~~~~~~~~~~~~~~~~~~~~
 Some of the alternatives are simplified, but have not been turned into a join point