Body of graph converted to a map
authorJoao Dias <dias@cs.tufts.edu>
Fri, 30 Apr 2010 18:03:51 +0000 (14:03 -0400)
committerJoao Dias <dias@cs.tufts.edu>
Fri, 30 Apr 2010 18:03:51 +0000 (14:03 -0400)
src/Compiler/Hoopl.hs
src/Compiler/Hoopl/Dataflow.hs
src/Compiler/Hoopl/DataflowFold.hs
src/Compiler/Hoopl/Graph.hs
src/Compiler/Hoopl/GraphUtil.hs
src/Compiler/Hoopl/Label.hs
src/Compiler/Hoopl/MkGraph.hs
src/Compiler/Hoopl/Util.hs
src/Compiler/Hoopl/XUtil.hs
src/hoopl.cabal

index 1ff289c..e3a2b85 100644 (file)
@@ -19,8 +19,7 @@ import Compiler.Hoopl.Dataflow
 import Compiler.Hoopl.Debug
 import Compiler.Hoopl.Fuel hiding (withFuel, getFuel, setFuel)
 import Compiler.Hoopl.Graph hiding 
-   ( BodyEmpty, BodyUnit, BodyCat
-   , BCat, BHead, BTail, BClosed -- OK to expose BFirst, BMiddle, BLast
+   ( BCat, BHead, BTail, BClosed -- OK to expose BFirst, BMiddle, BLast
    )
 import Compiler.Hoopl.Label hiding (lblOfUniq, uniqOfLbl)
 import Compiler.Hoopl.MkGraph
index f047047..1cd7df8 100644 (file)
@@ -274,7 +274,7 @@ forwardBlockList :: (Edges n, LabelsPtr entry)
                  => entry -> Body n -> [Block n C C]
 -- This produces a list of blocks in order suitable for forward analysis,
 -- along with the list of Labels it may depend on for facts.
-forwardBlockList entries blks = postorder_dfs_from (bodyMap blks) entries
+forwardBlockList entries (Body blks) = postorder_dfs_from blks entries
 
 -----------------------------------------------------------------------------
 --             Backward analysis and rewriting: the interface
@@ -475,7 +475,7 @@ updateFact lat lbls (lbl, new_fact) (cha, fbase)
          where join old_fact = fact_extend lat lbl (OldFact old_fact) (NewFact new_fact)
     new_fbase = extendFactBase fbase lbl res_fact
 
-fixpoint :: forall block n f. Edges (block n)
+fixpoint :: forall block n f. (Edges n, Edges (block n))
          => Bool       -- Going forwards?
          -> DataflowLattice f
          -> (block n C C -> FactBase f
@@ -566,15 +566,18 @@ we'll propagate (x=4) to L4, and nuke the otherwise-good rewriting of L4.
 --          TOTALLY internal to Hoopl; each block carries its fact
 -----------------------------------------------------------------------------
 
-type RG      f n e x = Graph' (FBlock f) n e x
+type RG     f n e x = Graph'   (FBlock f) n e x
 data FBlock f n e x = FBlock f (Block n e x)
+instance Edges n => Edges (FBlock f n) where
+  entryLabel (FBlock _ b) = entryLabel b
+  successors (FBlock _ b) = successors b
 
 --- constructors
 
 rgnil  :: RG f n O O
 rgnilC :: RG f n C C
-rgunit :: f -> Block n e x -> RG f n e x
-rgCat  :: RG f n e a -> RG f n a x -> RG f n e x
+rgunit :: Edges n => f -> Block n e x -> RG f n e x
+rgCat  :: Edges n => RG f n e a -> RG f n a x -> RG f n e x
 
 ---- observers
 
@@ -595,13 +598,13 @@ normalizeGraph g = (graphMapBlocks dropFact g, facts g)
           exitFacts NothingO = noFacts
           exitFacts (JustO (FBlock f b)) = mkFactBase [(entryLabel b, f)]
           bodyFacts :: Body' (FBlock f) n -> FactBase f
-          bodyFacts (BodyUnit (FBlock f b)) = mkFactBase [(entryLabel b, f)]
-          bodyFacts (b1 `BodyCat` b2) = bodyFacts b1 `unionFactBase` bodyFacts b2
+          bodyFacts (Body body) = foldLabelMap f noFacts body
+            where f (FBlock f b) fb = extendFactBase fb (entryLabel b) f
 
 --- implementation of the constructors (boring)
 
 rgnil  = GNil
-rgnilC = GMany NothingO BodyEmpty NothingO
+rgnilC = GMany NothingO emptyBody NothingO
 
 rgunit f b@(BFirst  {}) = gUnitCO (FBlock f b)
 rgunit f b@(BMiddle {}) = gUnitOO (FBlock f b)
index a75aa9c..0a43317 100644 (file)
@@ -282,7 +282,7 @@ forwardBlockList :: (Edges n, LabelsPtr entry)
                  => entry -> Body n -> [Block n C C]
 -- This produces a list of blocks in order suitable for forward analysis,
 -- along with the list of Labels it may depend on for facts.
-forwardBlockList entries blks = postorder_dfs_from (bodyMap blks) entries
+forwardBlockList entries (Body blks) = postorder_dfs_from blks entries
 
 -----------------------------------------------------------------------------
 --             Backward analysis and rewriting: the interface
@@ -497,7 +497,7 @@ updateFact lat lbls (lbl, new_fact) (cha, fbase)
          where join old_fact = fact_extend lat lbl (OldFact old_fact) (NewFact new_fact)
     new_fbase = extendFactBase fbase lbl res_fact
 
-fixpoint :: forall block n f. Edges (block n)
+fixpoint :: forall block n f. (Edges n, Edges (block n))
          => Bool       -- Going forwards?
          -> DataflowLattice f
          -> (block n C C -> FactBase f
@@ -590,13 +590,16 @@ we'll propagate (x=4) to L4, and nuke the otherwise-good rewriting of L4.
 
 type RG      f n e x = Graph' (FBlock f) n e x
 data FBlock f n e x = FBlock f (Block n e x)
+instance Edges n => Edges (FBlock f n) where
+  entryLabel (FBlock _ b) = entryLabel b
+  successors (FBlock _ b) = successors b
 
 --- constructors
 
 rgnil  :: RG f n O O
 rgnilC :: RG f n C C
-rgunit :: f -> Block n e x -> RG f n e x
-rgCat  :: RG f n e a -> RG f n a x -> RG f n e x
+rgunit :: Edges n => f -> Block n e x -> RG f n e x
+rgCat  :: Edges n => RG f n e a -> RG f n a x -> RG f n e x
 
 ---- observers
 
@@ -617,13 +620,13 @@ normalizeGraph g = (graphMapBlocks dropFact g, facts g)
           exitFacts NothingO = noFacts
           exitFacts (JustO (FBlock f b)) = mkFactBase [(entryLabel b, f)]
           bodyFacts :: Body' (FBlock f) n -> FactBase f
-          bodyFacts (BodyUnit (FBlock f b)) = mkFactBase [(entryLabel b, f)]
-          bodyFacts (b1 `BodyCat` b2) = bodyFacts b1 `unionFactBase` bodyFacts b2
+          bodyFacts (Body body) = foldLabelMap f noFacts body
+            where f (FBlock f b) fb = extendFactBase fb (entryLabel b) f
 
 --- implementation of the constructors (boring)
 
 rgnil  = GNil
-rgnilC = GMany NothingO BodyEmpty NothingO
+rgnilC = GMany NothingO emptyBody NothingO
 
 rgunit f b@(BFirst  {}) = gUnitCO (FBlock f b)
 rgunit f b@(BMiddle {}) = gUnitOO (FBlock f b)
@@ -654,7 +657,7 @@ class ShapeLifter e x where
   btransfer :: BwdPass n f -> n e x -> Fact x f -> f
   frewrite  :: FwdPass n f -> n e x -> f        -> Maybe (FwdRes n f e x)
   brewrite  :: BwdPass n f -> n e x -> Fact x f -> Maybe (BwdRes n f e x)
-  spliceRgNode :: RG f n a e -> f -> n e x -> RG f n a x
+  spliceRgNode :: Edges n => RG f n a e -> f -> n e x -> RG f n a x
   entry     :: Edges n => n e x -> Entries e
 
 instance ShapeLifter C O where
@@ -691,11 +694,12 @@ instance ShapeLifter O C where
   btransfer (BwdPass {bp_transfer = BwdTransfers (_, _, bt)}) n f = bt n f
   frewrite  (FwdPass {fp_rewrite  = FwdRewrites  (_, _, fr)}) n f = fr n f
   brewrite  (BwdPass {bp_rewrite  = BwdRewrites  (_, _, br)}) n f = br n f
-  spliceRgNode (GMany e body (JustO (FBlock f x))) _ n = GMany e body' NothingO
-     where body' = body `BodyCat` (BodyUnit $ FBlock f $ BClosed x $ BLast n)
-  spliceRgNode (GNil) f n = GMany e BodyEmpty NothingO
+  spliceRgNode (GMany e (Body b1) (JustO (FBlock f x))) _ n = GMany e body' NothingO
+     where body'     = Body $ unionLabelMap b1 b2
+           (Body b2) = addBlock (FBlock f $ BClosed x $ BLast n) emptyBody
+  spliceRgNode (GNil) f n = GMany e emptyBody NothingO
      where e = JustO $ FBlock f $ BLast n
-  spliceRgNode (GUnit (FBlock f b)) _ n = GMany e BodyEmpty NothingO
+  spliceRgNode (GUnit (FBlock f b)) _ n = GMany e emptyBody NothingO
      where e = JustO $ FBlock f (b `U.cat` BLast n)
   entry _ = NothingC
 
index 2b15683..8f55c9f 100644 (file)
@@ -1,10 +1,10 @@
 {-# LANGUAGE GADTs, EmptyDataDecls, TypeFamilies #-}
 
 module Compiler.Hoopl.Graph 
-  ( O, C, Block(..), Body, Body'(..), bodyMap, Graph, Graph'(..)
+  ( O, C, Block(..), Body, Body'(..), Graph, Graph'(..)
   , MaybeO(..), MaybeC(..), EitherCO
   , Edges(entryLabel, successors)
-  , addBlock, bodyList
+  , emptyBody, addBlock, bodyList
   )
 where
 
@@ -46,10 +46,7 @@ data Block n e x where
 
 -- | A (possibly empty) collection of closed/closed blocks
 type Body = Body' Block
-data Body' block n where
-  BodyEmpty :: Body' block n
-  BodyUnit  :: block n C C -> Body' block n
-  BodyCat   :: Body' block n -> Body' block n -> Body' block n
+newtype Body' block n = Body (LabelMap (block n C C))
 
 -- | A control-flow graph, which may take any of four shapes (O/O, O/C, C/O, C/C).
 -- A graph open at the entry has a single, distinguished, anonymous entry point;
@@ -99,16 +96,11 @@ instance Edges n => Edges (Block n) where
   successors (BClosed _ t) = successors t
 
 ------------------------------
-addBlock :: block n C C -> Body' block n -> Body' block n
-addBlock b body = BodyUnit b `BodyCat` body
+emptyBody :: Body' block n
+emptyBody = Body emptyLabelMap
 
-bodyList :: Edges (block n) => Body' block n -> [(Label,block n C C)]
-bodyList body = go body []
-  where
-    go BodyEmpty       bs = bs
-    go (BodyUnit b)    bs = (entryLabel b, b) : bs
-    go (BodyCat b1 b2) bs = go b1 (go b2 bs)
-
-bodyMap :: Edges (block n) => Body' block n -> LabelMap (block n C C)
-bodyMap = mkFactBase . bodyList
+addBlock :: Edges (block n) => block n C C -> Body' block n -> Body' block n
+addBlock b (Body body) = Body (extendLabelMap body (entryLabel b) b)
 
+bodyList :: Edges (block n) => Body' block n -> [(Label,block n C C)]
+bodyList (Body body) = labelMapList body
index 900c27e..729fb50 100644 (file)
@@ -11,11 +11,12 @@ module Compiler.Hoopl.GraphUtil
 where
 
 import Compiler.Hoopl.Graph
+import Compiler.Hoopl.Label
 
 bodyGraph :: Body n -> Graph n C C
 bodyGraph b = GMany NothingO b NothingO
 
-splice :: forall block n e a x .
+splice :: forall block n e a x . Edges (block n) =>
           (forall e x . block n e O -> block n O x -> block n e x)
        -> (Graph' block n e a -> Graph' block n a x -> Graph' block n e x)
 splice bcat = sp
@@ -31,14 +32,15 @@ splice bcat = sp
 
         sp (GMany e bs (JustO x)) (GUnit b2) = GMany e bs (JustO (x `bcat` b2))
 
-        sp (GMany e1 bs1 (JustO x1)) (GMany (JustO e2) bs2 x2)
-          = GMany e1 (addBlock (x1 `bcat` e2) bs1 `BodyCat` bs2) x2
+        sp (GMany e1 bs1 (JustO x1)) (GMany (JustO e2) (Body b2) x2)
+          = GMany e1 (Body $ unionLabelMap b1 b2) x2
+          where (Body b1) = addBlock (x1 `bcat` e2) bs1
 
-        sp (GMany e1 bs1 NothingO) (GMany NothingO bs2 x2)
-           = GMany e1 (bs1 `BodyCat` bs2) x2
+        sp (GMany e1 (Body b1) NothingO) (GMany NothingO (Body b2) x2)
+           = GMany e1 (Body $ unionLabelMap b1 b2) x2
 
 
-gSplice :: Graph n e a -> Graph n a x -> Graph n e x
+gSplice :: Edges n => Graph n e a -> Graph n a x -> Graph n e x
 gSplice = splice cat
 
 cat :: Block n e O -> Block n O x -> Block n e x
index 04e07ac..64a9782 100644 (file)
@@ -1,7 +1,7 @@
 module Compiler.Hoopl.Label
   ( Label, lblOfUniq, uniqOfLbl
   , LabelMap, emptyLabelMap, mkLabelMap, lookupLabel, extendLabelMap
-            , delFromLabelMap, unionLabelMap
+            , delFromLabelMap, unionLabelMap, mapLabelMap, foldLabelMap
             , elemLabelMap, labelMapLabels, labelMapList
   , FactBase, noFacts, mkFactBase, unitFact, lookupFact, extendFactBase
             , delFromFactBase, unionFactBase, mapFactBase, mapWithLFactBase
@@ -99,6 +99,12 @@ extendLabelMap = extendFactBase
 unionLabelMap :: LabelMap f -> LabelMap f -> LabelMap f
 unionLabelMap = M.union
 
+mapLabelMap :: (f -> f') -> LabelMap f -> LabelMap f'
+mapLabelMap = M.map
+
+foldLabelMap :: (f -> z -> z) -> z -> LabelMap f -> z
+foldLabelMap = M.fold
+
 elemLabelMap :: Label -> LabelMap f -> Bool
 elemLabelMap = elemFactBase
 
index b0c69be..dd72fb3 100644 (file)
@@ -14,6 +14,7 @@ import Compiler.Hoopl.Label (Label, lblOfUniq)
 import Compiler.Hoopl.Graph
 import Compiler.Hoopl.Fuel
 import qualified Compiler.Hoopl.GraphUtil as U
+import Compiler.Hoopl.Label (unionLabelMap)
 import Compiler.Hoopl.Unique
 import Control.Monad (liftM2)
 
@@ -72,12 +73,12 @@ class GraphRep g where
   infixl 3 <*>
   infixl 2 |*><*| 
   -- | Concatenate two graphs; control flows from left to right.
-  (<*>)    :: g n e O -> g n O x -> g n e x
+  (<*>)    :: Edges n => g n e O -> g n O x -> g n e x
   -- | Splice together two graphs at a closed point; nothing is known
   -- about control flow.
-  (|*><*|)  :: g n e C -> g n C x -> g n e x
+  (|*><*|) :: Edges n => g n e C -> g n C x -> g n e x
   -- | Conveniently concatenate a sequence of open/open graphs using '<*>'.
-  catGraphs :: [g n O O] -> g n O O
+  catGraphs :: Edges n => [g n O O] -> g n O O
   catGraphs = foldr (<*>) emptyGraph
 
   -- | Create a graph that defines a label
@@ -87,7 +88,7 @@ class GraphRep g where
 
   -- | Conveniently concatenate a sequence of middle nodes to form
   -- an open/open graph.
-  mkMiddles :: [n O O] -> g n O O
+  mkMiddles :: Edges n => [n O O] -> g n O O
 
   mkLabel  id     = mkFirst $ mkLabelNode id
   mkBranch target = mkLast  $ mkBranchNode target
@@ -100,12 +101,12 @@ class GraphRep g where
 
 instance GraphRep Graph where
   emptyGraph  = GNil
-  emptyClosedGraph = GMany NothingO BodyEmpty NothingO
+  emptyClosedGraph = GMany NothingO emptyBody NothingO
   (<*>)       = U.gSplice
   (|*><*|)    = U.gSplice
   mkMiddle    = GUnit . BMiddle
-  mkExit   block = GMany NothingO      BodyEmpty (JustO block)
-  mkEntry  block = GMany (JustO block) BodyEmpty NothingO
+  mkExit   block = GMany NothingO      emptyBody (JustO block)
+  mkEntry  block = GMany (JustO block) emptyBody NothingO
 
 instance GraphRep AGraph where
   emptyGraph  = aGraphOfGraph emptyGraph
@@ -157,8 +158,8 @@ addBlocks      :: HooplNode n
                => AGraph n e x -> AGraph n C C -> AGraph n e x
 addBlocks (A g) (A blocks) = A $ g >>= \g -> blocks >>= add g
   where add :: HooplNode n => Graph n e x -> Graph n C C -> FuelMonad (Graph n e x)
-        add (GMany e body x) (GMany NothingO body' NothingO) =
-          return $ GMany e (body `BodyCat` body') x
+        add (GMany e (Body body) x) (GMany NothingO (Body body') NothingO) =
+          return $ GMany e (Body $ unionLabelMap body body') x
         add g@GNil      blocks = spliceOO g blocks
         add g@(GUnit _) blocks = spliceOO g blocks
         spliceOO :: HooplNode n => Graph n O O -> Graph n C C -> FuelMonad(Graph n O O)
@@ -241,9 +242,9 @@ instance (Uniques u1, Uniques u2, Uniques u3, Uniques u4) => Uniques (u1, u2, u3
 -- deprecated legacy functions
 
 {-# DEPRECATED addEntrySeq, addExitSeq, unionBlocks "use |*><*| instead" #-}
-addEntrySeq    :: AGraph n O C -> AGraph n C x -> AGraph n O x
-addExitSeq     :: AGraph n e C -> AGraph n C O -> AGraph n e O
-unionBlocks    :: AGraph n C C -> AGraph n C C -> AGraph n C C
+addEntrySeq    :: Edges n => AGraph n O C -> AGraph n C x -> AGraph n O x
+addExitSeq     :: Edges n => AGraph n e C -> AGraph n C O -> AGraph n e O
+unionBlocks    :: Edges n => AGraph n C C -> AGraph n C C -> AGraph n C C
 
 addEntrySeq = (|*><*|)
 addExitSeq  = (|*><*|)
index 2cf3d8c..02aaab9 100644 (file)
@@ -24,17 +24,17 @@ import Compiler.Hoopl.Label
 gUnitOO :: block n O O -> Graph' block n O O
 gUnitOC :: block n O C -> Graph' block n O C
 gUnitCO :: block n C O -> Graph' block n C O
-gUnitCC :: block n C C -> Graph' block n C C
+gUnitCC :: Edges (block n) => block n C C -> Graph' block n C C
 gUnitOO b = GUnit b
-gUnitOC b = GMany (JustO b) BodyEmpty   NothingO
-gUnitCO b = GMany NothingO  BodyEmpty   (JustO b)
-gUnitCC b = GMany NothingO  (BodyUnit b) NothingO
+gUnitOC b = GMany (JustO b) emptyBody  NothingO
+gUnitCO b = GMany NothingO  emptyBody (JustO b)
+gUnitCC b = GMany NothingO  (addBlock b $ emptyBody) NothingO
 
 
-catGraphNodeOO :: Graph n e O -> n O O -> Graph n e O
-catGraphNodeOC :: Graph n e O -> n O C -> Graph n e C
-catNodeOOGraph :: n O O -> Graph n O x -> Graph n O x
-catNodeCOGraph :: n C O -> Graph n O x -> Graph n C x
+catGraphNodeOO ::            Graph n e O -> n O O -> Graph n e O
+catGraphNodeOC :: Edges n => Graph n e O -> n O C -> Graph n e C
+catNodeOOGraph ::            n O O -> Graph n O x -> Graph n O x
+catNodeCOGraph :: Edges n => n C O -> Graph n O x -> Graph n C x
 
 catGraphNodeOO GNil                     n = gUnitOO $ BMiddle n
 catGraphNodeOO (GUnit b)                n = gUnitOO $ b `BCat` BMiddle n
@@ -46,7 +46,7 @@ catGraphNodeOC (GUnit b)                n = gUnitOC $ addToLeft b $ BLast n
         addToLeft (BMiddle m)    g = m `BTail` g
         addToLeft (b1 `BCat` b2) g = addToLeft b1 $ addToLeft b2 g
 catGraphNodeOC (GMany e body (JustO x)) n = GMany e body' NothingO
-  where body' = body `BodyCat` BodyUnit (x `BClosed` BLast n)
+  where body' = addBlock (x `BClosed` BLast n) body
 
 catNodeOOGraph n GNil                     = gUnitOO $ BMiddle n
 catNodeOOGraph n (GUnit b)                = gUnitOO $ BMiddle n `BCat` b
@@ -58,13 +58,13 @@ catNodeCOGraph n (GUnit b)                = gUnitCO $ addToRight (BFirst n) b
         addToRight g (BMiddle m)    = g `BHead` m
         addToRight g (b1 `BCat` b2) = addToRight (addToRight g b1) b2
 catNodeCOGraph n (GMany (JustO e) body x) = GMany NothingO body' x
-  where body' = BodyUnit (BFirst n `BClosed` e) `BodyCat` body
+  where body' = addBlock (BFirst n `BClosed` e) body
 
 
 
 
 
-blockGraph :: Block n e x -> Graph n e x
+blockGraph :: Edges n => Block n e x -> Graph n e x
 blockGraph b@(BFirst  {}) = gUnitCO b
 blockGraph b@(BMiddle {}) = gUnitOO b
 blockGraph b@(BLast   {}) = gUnitOC b
@@ -91,10 +91,7 @@ graphMapBlocks f = map
         map (GUnit b) = GUnit (f b)
         map (GMany e b x) = GMany (fmap f e) (bodyMapBlocks f b) (fmap f x)
 
-bodyMapBlocks f = map
-  where map BodyEmpty = BodyEmpty
-        map (BodyUnit b) = BodyUnit (f b)
-        map (BodyCat b1 b2) = BodyCat (map b1) (map b2)
+bodyMapBlocks f (Body body) = Body $ mapLabelMap f body
 
 
 ----------------------------------------------------------------
@@ -161,8 +158,7 @@ graphDfs :: (Edges (block n))
          -> (Graph' block n O x -> [block n C C])
 graphDfs _     (GNil)    = []
 graphDfs _     (GUnit{}) = []
-graphDfs order (GMany (JustO entry) body _) = order blockenv entry emptyLabelSet
-  where blockenv = bodyMap body
+graphDfs order (GMany (JustO entry) (Body body) _) = order body entry emptyLabelSet
 
 postorder_dfs = graphDfs postorder_dfs_from_except
 preorder_dfs  = graphDfs preorder_dfs_from_except
@@ -247,9 +243,7 @@ labelsUsed (GMany e body _) = foldBodyBlocks addTargets body $ entryTargets e
         entryTargets (JustO b) = addTargets b emptyLabelSet
 
 foldBodyBlocks :: (block n C C -> a -> a) -> Body' block n -> a -> a
-foldBodyBlocks _ BodyEmpty      = id
-foldBodyBlocks f (BodyUnit b)   = f b
-foldBodyBlocks f (BodyCat b b') = foldBodyBlocks f b . foldBodyBlocks f b'
+foldBodyBlocks f (Body body) z = foldLabelMap f z body
 
 externalEntryLabels :: Edges (block n) => Body' block n -> LabelSet
 externalEntryLabels body = defined `minusLabelSet` used
index 9fb9649..74be003 100644 (file)
@@ -142,9 +142,8 @@ foldGraphNodes f = graph
           graph GNil              = id
           graph (GUnit b)         = block b
           graph (GMany e b x)     = lift block e . body b . lift block x
-          body (BodyEmpty)        = id
-          body (BodyUnit b)       = block b
-          body (b1 `BodyCat` b2)  = body b1 . body b2
+          body :: Body n -> a -> a
+          body  (Body bdy)        = \a -> foldLabelMap block a bdy
           lift _ NothingO         = id
           lift f (JustO thing)    = f thing
 
index e2b2f67..dbb5c9b 100644 (file)
@@ -18,7 +18,6 @@ Library
   Exposed-modules:   Compiler.Hoopl,
                        Compiler.Hoopl.Passes.Dominator,
                        Compiler.Hoopl.DataflowFold,
-                       Compiler.Hoopl.OldDataflow,
                        Compiler.Hoopl.Pointed,
                        Compiler.Hoopl.GHC
   Other-modules:     Compiler.Hoopl.GraphUtil,