Commit 21eeb926 authored by simonpj@microsoft.com's avatar simonpj@microsoft.com
Browse files

Use full equality for CSE

In CSE we were getting lots of apprarently-unequal expressions with
the same hash code.  In fact they were perfectly equal -- but we were
using a cheap-and-cheerful equality tests for CoreExpr that said False
for any lambda expression!

This patch adds a proper equality test for Core, with alpha-renaming.
It's easy to do, and will avoid silly cases of CSE failing to fire.

We should get less of this:
  WARNING: file compiler/simplCore/CSE.lhs line 326
  extendCSEnv: long list, length 18
from a compiler built with -DDEBUG
parent a33b1cd8
...@@ -36,7 +36,7 @@ module CoreUtils ( ...@@ -36,7 +36,7 @@ module CoreUtils (
hashExpr, hashExpr,
-- * Equality -- * Equality
cheapEqExpr, cheapEqExpr, eqExpr,
-- * Manipulating data constructors and types -- * Manipulating data constructors and types
applyTypeToArgs, applyTypeToArg, applyTypeToArgs, applyTypeToArg,
...@@ -913,7 +913,9 @@ cheapEqExpr (Cast e1 t1) (Cast e2 t2) ...@@ -913,7 +913,9 @@ cheapEqExpr (Cast e1 t1) (Cast e2 t2)
= e1 `cheapEqExpr` e2 && t1 `coreEqCoercion` t2 = e1 `cheapEqExpr` e2 && t1 `coreEqCoercion` t2
cheapEqExpr _ _ = False cheapEqExpr _ _ = False
\end{code}
\begin{code}
exprIsBig :: Expr b -> Bool exprIsBig :: Expr b -> Bool
-- ^ Returns @True@ of expressions that are too big to be compared by 'cheapEqExpr' -- ^ Returns @True@ of expressions that are too big to be compared by 'cheapEqExpr'
exprIsBig (Lit _) = False exprIsBig (Lit _) = False
...@@ -925,7 +927,53 @@ exprIsBig (Cast e _) = exprIsBig e -- Hopefully coercions are not too big! ...@@ -925,7 +927,53 @@ exprIsBig (Cast e _) = exprIsBig e -- Hopefully coercions are not too big!
exprIsBig _ = True exprIsBig _ = True
\end{code} \end{code}
\begin{code}
eqExpr :: InScopeSet -> CoreExpr -> CoreExpr -> Bool
-- Compares for equality, modulo alpha
eqExpr in_scope e1 e2
= go (mkRnEnv2 in_scope) e1 e2
where
go _ (Lit lit1) (Lit lit2) = lit1 == lit2
go env (Type t1) (Type t2) = coreEqType2 env t1 t2
go env (Var v1) (Var v2) = rnOccL env v1 == rnOccR env v2
go env (Cast e1 t1) (Cast e2 t2) = go env e1 e2 && coreEqCoercion2 env t1 t2
go env (App f1 a1) (App f2 a2) = go env f1 f2 && go env a1 a2
go env (Lam b1 e1) (Lam b2 e2)
= coreEqType2 env (varType b1) (varType b2) -- Will return False for Id/TyVar combination
&& go (rnBndr2 env b1 b2) e1 e2
go env (Case e1 b1 _ a1) (Case e2 b2 _ a2)
= go env e1 e2
&& coreEqType2 env (idType b1) (idType b2)
&& all2 (go_alt (rnBndr2 env b1 b2)) a1 a2
go env (Let (NonRec b1 r1) e1) (Let (NonRec b2 r2) e2)
= go env r1 r2 -- No need to check binder types, since RHSs match
&& go (rnBndr2 env b1 b2) e1 e2
go env (Let (Rec p1) e1) (Let (Rec p2) e2)
| equalLength p1 p2
= all2 (go env') rs1 rs2 && go env' e1 e2
where
(bs1,rs1) = unzip p1
(bs2,rs2) = unzip p2
env' = rnBndrs2 env bs1 bs2
go env (Note n1 e1) (Note n2 e2) = go_note n1 n2 && go env e1 e2
go _ _ _ = False
-----------
go_alt env (c1, bs1, e1) (c2, bs2, e2)
= c1 == c2 && go (rnBndrs2 env bs1 bs2) e1 e2
-----------
go_note (SCC cc1) (SCC cc2) = cc1==cc2
go_note (CoreNote s1) (CoreNote s2) = s1==s2
go_note _ _ = False
\end{code}
%************************************************************************ %************************************************************************
%* * %* *
......
...@@ -11,7 +11,7 @@ module CSE ( ...@@ -11,7 +11,7 @@ module CSE (
#include "HsVersions.h" #include "HsVersions.h"
import Id ( Id, idType, idInlineActivation, zapIdOccInfo ) import Id ( Id, idType, idInlineActivation, zapIdOccInfo )
import CoreUtils ( hashExpr, cheapEqExpr, exprIsBig, mkAltExpr, exprIsCheap ) import CoreUtils ( hashExpr, eqExpr, exprIsBig, mkAltExpr, exprIsCheap )
import DataCon ( isUnboxedTupleCon ) import DataCon ( isUnboxedTupleCon )
import Type ( tyConAppArgs ) import Type ( tyConAppArgs )
import CoreSyn import CoreSyn
...@@ -301,15 +301,19 @@ emptyCSEnv :: CSEnv ...@@ -301,15 +301,19 @@ emptyCSEnv :: CSEnv
emptyCSEnv = CS emptyUFM emptyInScopeSet emptyVarEnv emptyCSEnv = CS emptyUFM emptyInScopeSet emptyVarEnv
lookupCSEnv :: CSEnv -> CoreExpr -> Maybe CoreExpr lookupCSEnv :: CSEnv -> CoreExpr -> Maybe CoreExpr
lookupCSEnv (CS cs _ _) expr lookupCSEnv (CS cs in_scope _) expr
= case lookupUFM cs (hashExpr expr) of = case lookupUFM cs (hashExpr expr) of
Nothing -> Nothing Nothing -> Nothing
Just pairs -> lookup_list pairs expr Just pairs -> lookup_list pairs
where
lookup_list :: [(CoreExpr,CoreExpr)] -> CoreExpr -> Maybe CoreExpr -- In this lookup we use full expression equality
lookup_list [] _ = Nothing -- Reason: when expressions differ we generally find out quickly
lookup_list ((e,e'):es) expr | cheapEqExpr e expr = Just e' -- but I found that cheapEqExpr was saying (\x.x) /= (\y.y),
| otherwise = lookup_list es expr -- and this kind of thing happened in real programs
lookup_list :: [(CoreExpr,CoreExpr)] -> Maybe CoreExpr
lookup_list [] = Nothing
lookup_list ((e,e'):es) | eqExpr in_scope e expr = Just e'
| otherwise = lookup_list es
addCSEnvItem :: CSEnv -> CoreExpr -> CoreExpr -> CSEnv addCSEnvItem :: CSEnv -> CoreExpr -> CoreExpr -> CSEnv
addCSEnvItem env expr expr' | exprIsBig expr = env addCSEnvItem env expr expr' | exprIsBig expr = env
......
...@@ -50,7 +50,7 @@ module Coercion ( ...@@ -50,7 +50,7 @@ module Coercion (
optCoercion, optCoercion,
-- ** Comparison -- ** Comparison
coreEqCoercion, coreEqCoercion, coreEqCoercion2,
-- * CoercionI -- * CoercionI
CoercionI(..), CoercionI(..),
...@@ -70,6 +70,7 @@ import Type ...@@ -70,6 +70,7 @@ import Type
import TyCon import TyCon
import Class import Class
import Var import Var
import VarEnv
import Name import Name
import PrelNames import PrelNames
import Util import Util
...@@ -576,6 +577,9 @@ splitNewTypeRepCo_maybe _ ...@@ -576,6 +577,9 @@ splitNewTypeRepCo_maybe _
-- | Determines syntactic equality of coercions -- | Determines syntactic equality of coercions
coreEqCoercion :: Coercion -> Coercion -> Bool coreEqCoercion :: Coercion -> Coercion -> Bool
coreEqCoercion = coreEqType coreEqCoercion = coreEqType
coreEqCoercion2 :: RnEnv2 -> Coercion -> Coercion -> Bool
coreEqCoercion2 = coreEqType2
\end{code} \end{code}
......
...@@ -98,7 +98,8 @@ module Type ( ...@@ -98,7 +98,8 @@ module Type (
tidyKind, tidyKind,
-- * Type comparison -- * Type comparison
coreEqType, tcEqType, tcEqTypes, tcCmpType, tcCmpTypes, coreEqType, coreEqType2,
tcEqType, tcEqTypes, tcCmpType, tcCmpTypes,
tcEqPred, tcEqPredX, tcCmpPred, tcEqTypeX, tcPartOfType, tcPartOfPred, tcEqPred, tcEqPredX, tcCmpPred, tcEqTypeX, tcPartOfType, tcPartOfPred,
-- * Forcing evaluation of types -- * Forcing evaluation of types
...@@ -1140,11 +1141,14 @@ See Note [Newtype eta] in TyCon.lhs ...@@ -1140,11 +1141,14 @@ See Note [Newtype eta] in TyCon.lhs
\begin{code} \begin{code}
-- | Type equality test for Core types (i.e. ignores predicate-types, synonyms etc.) -- | Type equality test for Core types (i.e. ignores predicate-types, synonyms etc.)
coreEqType :: Type -> Type -> Bool coreEqType :: Type -> Type -> Bool
coreEqType t1 t2 coreEqType t1 t2 = coreEqType2 rn_env t1 t2
= eq rn_env t1 t2
where where
rn_env = mkRnEnv2 (mkInScopeSet (tyVarsOfType t1 `unionVarSet` tyVarsOfType t2)) rn_env = mkRnEnv2 (mkInScopeSet (tyVarsOfType t1 `unionVarSet` tyVarsOfType t2))
coreEqType2 :: RnEnv2 -> Type -> Type -> Bool
coreEqType2 rn_env t1 t2
= eq rn_env t1 t2
where
eq env (TyVarTy tv1) (TyVarTy tv2) = rnOccL env tv1 == rnOccR env tv2 eq env (TyVarTy tv1) (TyVarTy tv2) = rnOccL env tv1 == rnOccR env tv2
eq env (ForAllTy tv1 t1) (ForAllTy tv2 t2) = eq (rnBndr2 env tv1 tv2) t1 t2 eq env (ForAllTy tv1 t1) (ForAllTy tv2 t2) = eq (rnBndr2 env tv1 tv2) t1 t2
eq env (AppTy s1 t1) (AppTy s2 t2) = eq env s1 s2 && eq env t1 t2 eq env (AppTy s1 t1) (AppTy s2 t2) = eq env s1 s2 && eq env t1 t2
......
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment