From: simonpj <unknown>
Date: Fri, 4 May 2001 14:40:42 +0000 (+0000)
Subject: [project @ 2001-05-04 14:40:42 by simonpj]
X-Git-Tag: Approximately_9120_patches~1996
X-Git-Url: http://git.megacz.com/?a=commitdiff_plain;h=d68887047bcfb9021151f768fe1a22df2d3fbe1e;p=ghc-hetmet.git

[project @ 2001-05-04 14:40:42 by simonpj]
Comments only
---

diff --git a/ghc/compiler/typecheck/TcInstDcls.lhs b/ghc/compiler/typecheck/TcInstDcls.lhs
index 324ee71..9b53a04 100644
--- a/ghc/compiler/typecheck/TcInstDcls.lhs
+++ b/ghc/compiler/typecheck/TcInstDcls.lhs
@@ -606,7 +606,7 @@ tcInstDecl2 (InstInfo { iDFunId = dfun_id,
 		-- Always inline the dfun; this is an experimental decision
 		-- because it makes a big performance difference sometimes.
 		-- Often it means we can do the method selection, and then
-		-- inline the method as well.  Marcin's idea.
+		-- inline the method as well.  Marcin's idea; see comments below.
 
 	dict_rhs
 	  | null scs_and_meths
@@ -649,6 +649,96 @@ tcInstDecl2 (InstInfo { iDFunId = dfun_id,
 	      main_bind `AndMonoBinds` prag_binds)
 \end{code}
 
+		------------------------------
+		Inlining dfuns unconditionally
+		------------------------------
+
+The code above unconditionally inlines dict funs.  Here's why.
+Consider this program:
+
+    test :: Int -> Int -> Bool
+    test x y = (x,y) == (y,x) || test y x
+    -- Recursive to avoid making it inline.
+
+This needs the (Eq (Int,Int)) instance.  If we inline that dfun
+the code we end up with is good:
+
+    Test.$wtest =
+	\r -> case ==# [ww ww1] of wild {
+		PrelBase.False -> Test.$wtest ww1 ww;
+		PrelBase.True ->
+		  case ==# [ww1 ww] of wild1 {
+		    PrelBase.False -> Test.$wtest ww1 ww;
+		    PrelBase.True -> PrelBase.True [];
+		  };
+	    };
+    Test.test = \r [w w1]
+	    case w of w2 {
+	      PrelBase.I# ww ->
+		  case w1 of w3 { PrelBase.I# ww1 -> Test.$wtest ww ww1; };
+	    };
+
+If we don't inline the dfun, the code is not nearly as good:
+
+    (==) = case PrelTup.$fEq(,) PrelBase.$fEqInt PrelBase.$fEqInt of tpl {
+	      PrelBase.:DEq tpl1 tpl2 -> tpl2;
+	    };
+    
+    Test.$wtest =
+	\r [ww ww1]
+	    let { y = PrelBase.I#! [ww1]; } in
+	    let { x = PrelBase.I#! [ww]; } in
+	    let { sat_slx = PrelTup.(,)! [y x]; } in
+	    let { sat_sly = PrelTup.(,)! [x y];
+	    } in
+	      case == sat_sly sat_slx of wild {
+		PrelBase.False -> Test.$wtest ww1 ww;
+		PrelBase.True -> PrelBase.True [];
+	      };
+    
+    Test.test =
+	\r [w w1]
+	    case w of w2 {
+	      PrelBase.I# ww ->
+		  case w1 of w3 { PrelBase.I# ww1 -> Test.$wtest ww ww1; };
+	    };
+
+Why doesn't GHC inline $fEq?  Because it looks big:
+
+    PrelTup.zdfEqZ1T{-rcX-}
+	= \ @ a{-reT-} :: * @ b{-reS-} :: *
+            zddEq{-rf6-} _Ks :: {PrelBase.Eq{-23-} a{-reT-}}
+            zddEq1{-rf7-} _Ks :: {PrelBase.Eq{-23-} b{-reS-}} ->
+            let {
+              zeze{-rf0-} _Kl :: (b{-reS-} -> b{-reS-} -> PrelBase.Bool{-3c-})
+              zeze{-rf0-} = PrelBase.zeze{-01L-}@ b{-reS-} zddEq1{-rf7-} } in
+            let {
+              zeze1{-rf3-} _Kl :: (a{-reT-} -> a{-reT-} -> PrelBase.Bool{-3c-})
+              zeze1{-rf3-} = PrelBase.zeze{-01L-} @ a{-reT-} zddEq{-rf6-} } in
+            let {
+              zeze2{-reN-} :: ((a{-reT-}, b{-reS-}) -> (a{-reT-}, b{-reS-})-> PrelBase.Bool{-3c-})
+              zeze2{-reN-} = \ ds{-rf5-} _Ks :: (a{-reT-}, b{-reS-})
+		               ds1{-rf4-} _Ks :: (a{-reT-}, b{-reS-}) ->
+                  	     case ds{-rf5-}
+                  	     of wild{-reW-} _Kd { (a1{-rf2-} _Ks, a2{-reZ-} _Ks) ->
+                  	     case ds1{-rf4-}
+                  	     of wild1{-reX-} _Kd { (b1{-rf1-} _Ks, b2{-reY-} _Ks) ->
+                  	     PrelBase.zaza{-r4e-}
+                  	       (zeze1{-rf3-} a1{-rf2-} b1{-rf1-})
+                  	       (zeze{-rf0-} a2{-reZ-} b2{-reY-})
+                  	     }
+                  	     } } in     
+            let {
+              a1{-reR-} :: ((a{-reT-}, b{-reS-})-> (a{-reT-}, b{-reS-})-> PrelBase.Bool{-3c-})
+              a1{-reR-} = \ a2{-reV-} _Ks :: (a{-reT-}, b{-reS-})
+			    b1{-reU-} _Ks :: (a{-reT-}, b{-reS-}) ->
+                    	  PrelBase.not{-r6I-} (zeze2{-reN-} a2{-reV-} b1{-reU-})
+            } in
+              PrelBase.zdwZCDEq{-r8J-} @ (a{-reT-}, b{-reS-}) a1{-reR-} zeze2{-reN-})
+
+and it's not as bad as it seems, because it's further dramatically
+simplified: only zeze2 is extracted and its body is simplified.
+
 
 %************************************************************************
 %*									*