X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=compiler%2FsimplCore%2FFloatOut.lhs;h=bbf6f0a79d74a7d50b18419653dfb86e83dc02f1;hb=c0fe534fbf3d3e30a6f35b355da86e6f18601348;hp=d5544517df9e298f73aee006b5d33d0d9f96626e;hpb=f42d93f8f8395c6ee84a65ab4e45c52b8b8a5cb4;p=ghc-hetmet.git

diff --git a/compiler/simplCore/FloatOut.lhs b/compiler/simplCore/FloatOut.lhs
index d554451..bbf6f0a 100644
--- a/compiler/simplCore/FloatOut.lhs
+++ b/compiler/simplCore/FloatOut.lhs
@@ -6,12 +6,19 @@
 ``Long-distance'' floating of bindings towards the top level.
 
 \begin{code}
+{-# OPTIONS -w #-}
+-- The above warning supression flag is a temporary kludge.
+-- While working on this module you are encouraged to remove it and fix
+-- any warnings in the module. See
+--     http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#Warnings
+-- for details
+
 module FloatOut ( floatOutwards ) where
 
 #include "HsVersions.h"
 
 import CoreSyn
-import CoreUtils	( mkSCC, exprIsHNF, exprIsTrivial )
+import CoreUtils
 
 import DynFlags	( DynFlags, DynFlag(..), FloatOutSwitches(..) )
 import ErrUtils		( dumpIfSet_dyn )
@@ -24,6 +31,7 @@ import SetLevels	( Level(..), LevelledExpr, LevelledBind,
 import UniqSupply       ( UniqSupply )
 import List		( partition )
 import Outputable
+import FastString
 \end{code}
 
 	-----------------
@@ -224,7 +232,7 @@ floatCaseAlt lvl arg	-- Used rec rhss, and case-alternative rhss
 floatRhs lvl arg	-- Used for nested non-rec rhss, and fn args
 			-- See Note [Floating out of RHS]
   = case (floatExpr lvl arg) of { (fsa, floats, arg') ->
-    if exprIsHNF arg' || exprIsTrivial arg' then
+    if exprIsCheap arg' then	
 	(fsa, floats, arg')
     else
     case (partitionByMajorLevel lvl floats) of { (floats', heres) ->
@@ -250,6 +258,9 @@ floatRhs lvl arg	-- Used for nested non-rec rhss, and fn args
 --	bindings just after the '='.  And some of them might (correctly)
 --	be strict even though the 'let f' is lazy, because f, being a value,
 --	gets its demand-info zapped by the simplifier.
+--
+-- We use exprIsCheap because that is also what's used by the simplifier
+-- to decide whether to float a let out of a let
 
 floatExpr _ (Var v)   = (zeroStats, [], Var v)
 floatExpr _ (Type ty) = (zeroStats, [], Type ty)
@@ -305,13 +316,11 @@ floatExpr lvl (Note note@(SCC cc) expr)
 	  = Rec [(binder, mkSCC dupd_cc rhs) | (binder, rhs) <- pairs]
 
 floatExpr lvl (Note InlineMe expr)	-- Other than SCCs
-  = case floatExpr InlineCtxt expr of { (fs, floating_defns, expr') ->
-	-- There can be some floating_defns, arising from
-	-- ordinary lets that were there all the time.  It seems
-	-- more efficient to test once here than to avoid putting
-	-- them into floating_defns (which would mean testing for
-	-- inlineCtxt  at every let)
-    (fs, [], Note InlineMe (install floating_defns expr')) }	-- See notes in SetLevels
+  = (zeroStats, [], Note InlineMe (unTag expr))
+	-- Do no floating at all inside INLINE. [_$_]
+	-- The SetLevels pass did not clone the bindings, so it's
+	-- unsafe to do any floating, even if we dump the results
+	-- inside the Note (which is what we used to do).
 
 floatExpr lvl (Note note expr)	-- Other than SCCs
   = case (floatExpr lvl expr)    of { (fs, floating_defns, expr') ->
@@ -353,6 +362,22 @@ floatList f [] = (zeroStats, [], [])
 floatList f (a:as) = case f a		 of { (fs_a,  binds_a,  b)  ->
 		     case floatList f as of { (fs_as, binds_as, bs) ->
 		     (fs_a `add_stats` fs_as, binds_a ++ binds_as, b:bs) }}
+
+unTagBndr :: TaggedBndr tag -> CoreBndr
+unTagBndr (TB b _) = b
+
+unTag :: TaggedExpr tag -> CoreExpr
+unTag (Var v)  	  = Var v
+unTag (Lit l)  	  = Lit l
+unTag (Type ty)   = Type ty
+unTag (Note n e)  = Note n (unTag e)
+unTag (App e1 e2) = App (unTag e1) (unTag e2)
+unTag (Lam b e)   = Lam (unTagBndr b) (unTag e)
+unTag (Cast e co) = Cast (unTag e) co
+unTag (Let (Rec prs) e)    = Let (Rec [(unTagBndr b,unTag r) | (b, r) <- prs]) (unTag e)
+unTag (Let (NonRec b r) e) = Let (NonRec (unTagBndr b) (unTag r)) (unTag e)
+unTag (Case e b ty alts)   = Case (unTag e) (unTagBndr b) ty
+			          [(c, map unTagBndr bs, unTag r) | (c,bs,r) <- alts]
 \end{code}
 
 %************************************************************************