-{-# LANGUAGE ScopedTypeVariables #-}
module ZipCfg
( -- These data types and names are carefully thought out
- BlockId(..) -- ToDo: BlockId should be abstract, but it isn't yet
- , BlockEnv, emptyBlockEnv, lookupBlockEnv, extendBlockEnv, insertBlock, mkBlockEnv
- , BlockSet, emptyBlockSet, elemBlockSet, extendBlockSet, mkBlockSet
- , Graph(..), LGraph(..), FGraph(..)
+ Graph(..), LGraph(..), FGraph(..)
, Block(..), ZBlock(..), ZHead(..), ZTail(..), ZLast(..)
+ , insertBlock
, HavingSuccessors, succs, fold_succs
, LastNode, mkBranchNode, isBranchNode, branchNodeTarget
, blockId, zip, unzip, last, goto_end, zipht, tailOfLast
, splice_tail, splice_head, splice_head_only', splice_head'
, of_block_list, to_block_list
- , map_nodes
+ , graphOfLGraph
+ , map_blocks, map_one_block, map_nodes, mapM_blocks
, postorder_dfs, postorder_dfs_from, postorder_dfs_from_except
, fold_layout
- , fold_blocks
+ , fold_blocks, fold_fwd_block
, translate
, pprLgraph, pprGraph
- , entry -- exported for the convenience of ZipDataflow, at least for now
+ , entry -- exported for the convenience of ZipDataflow0, at least for now
{-
-- the following functions might one day be useful and can be found
, entry, exit, focus, focusp, unfocus
, ht_to_block, ht_to_last,
, splice_focus_entry, splice_focus_exit
- , fold_fwd_block, foldM_fwd_block
+ , foldM_fwd_block
-}
)
#include "HsVersions.h"
+import BlockId ( BlockId, BlockEnv, emptyBlockEnv, lookupBlockEnv, extendBlockEnv
+ , BlockSet, emptyBlockSet, unitBlockSet, elemBlockSet, extendBlockSet
+ , delFromBlockEnv, foldBlockEnv', mapBlockEnv
+ , eltsBlockEnv, isNullBEnv, plusBlockEnv)
+import CmmExpr ( UserOfLocalRegs(..) )
+import PprCmm()
+
import Outputable hiding (empty)
-import Panic
-import Unique
-import UniqFM
-import UniqSet
-import Maybe
+import Data.Maybe
import Prelude hiding (zip, unzip, last)
-------------------------------------------------------------------------
-- so we don't want to pollute the 'l' type parameter with it
| LastOther l
-data ZHead m = ZFirst BlockId | ZHead (ZHead m) m
+--So that we don't have orphan instances, this goes here or in CmmExpr.
+--At least UserOfLocalRegs (ZLast Last) is needed (Last defined elsewhere),
+--but there's no need for non-Haskell98 instances for that.
+instance UserOfLocalRegs a => UserOfLocalRegs (ZLast a) where
+ foldRegsUsed f z (LastOther l) = foldRegsUsed f z l
+ foldRegsUsed _f z LastExit = z
+
+
+data ZHead m = ZFirst BlockId
+ | ZHead (ZHead m) m
-- ZHead is a (reversed) sequence of middle nodes labeled by a BlockId
data ZTail m l = ZLast (ZLast l) | ZTail m (ZTail m l)
-- ZTail is a sequence of middle nodes followed by a last node
-- | Blocks and flow graphs; see Note [Kinds of graphs]
-data Block m l = Block BlockId (ZTail m l)
+
+data Block m l = Block { bid :: BlockId
+ , tail :: ZTail m l }
data Graph m l = Graph { g_entry :: (ZTail m l), g_blocks :: (BlockEnv (Block m l)) }
-data LGraph m l = LGraph { lg_entry :: BlockId
- , lg_blocks :: BlockEnv (Block m l) }
+data LGraph m l = LGraph { lg_entry :: BlockId
+ , lg_blocks :: BlockEnv (Block m l)}
-- Invariant: lg_entry is in domain( lg_blocks )
-- | And now the zipper. The focus is between the head and tail.
-- , (???, [<blocks>,
-- N: y:=x; return (y,x)])
-splice_head :: ZHead m -> LGraph m l -> (LGraph m l, ZHead m)
-splice_head' :: ZHead m -> Graph m l -> (BlockEnv (Block m l), ZHead m)
+splice_head :: ZHead m -> LGraph m l -> (LGraph m l, ZHead m)
+splice_head' :: ZHead m -> Graph m l -> (BlockEnv (Block m l), ZHead m)
splice_tail :: Graph m l -> ZTail m l -> Graph m l
-- | We can also splice a single-entry, no-exit Graph into a head.
-splice_head_only :: ZHead m -> LGraph m l -> LGraph m l
-splice_head_only' :: ZHead m -> Graph m l -> LGraph m l
+splice_head_only :: ZHead m -> LGraph m l -> LGraph m l
+splice_head_only' :: ZHead m -> Graph m l -> LGraph m l
-- | A safe operation
of_block_list :: BlockId -> [Block m l] -> LGraph m l -- N log N
to_block_list :: LGraph m l -> [Block m l] -- N log N
+-- | Conversion from LGraph to Graph
+graphOfLGraph :: LastNode l => LGraph m l -> Graph m l
+graphOfLGraph (LGraph eid blocks) = Graph (ZLast $ mkBranchNode eid) blocks
+
+
-- | Traversal: 'postorder_dfs' returns a list of blocks reachable
-- from the entry node. This list has the following property:
--
-- haven't needed (else it would be here).
fold_blocks :: (Block m l -> a -> a) -> a -> LGraph m l -> a
+-- | Fold from first to last
+fold_fwd_block :: (BlockId -> a -> a) -> (m -> a -> a) ->
+ (ZLast l -> a -> a) -> Block m l -> a -> a
+
+map_one_block :: (BlockId -> BlockId) -> (m -> m') -> (l -> l') -> Block m l -> Block m' l'
+
map_nodes :: (BlockId -> BlockId) -> (m -> m') -> (l -> l') -> LGraph m l -> LGraph m' l'
-- mapping includes the entry id!
-map_blocks :: (Block m l -> Block m' l') -> LGraph m' l' -> LGraph m' l'
+map_blocks :: (Block m l -> Block m' l') -> LGraph m l -> LGraph m' l'
+mapM_blocks :: Monad mm
+ => (Block m l -> mm (Block m' l')) -> LGraph m l -> mm (LGraph m' l')
-- | These translation functions are speculative. I hope eventually
-- they will be used in the native-code back ends ---NR
-translate :: (m -> UniqSM (LGraph m' l')) ->
- (l -> UniqSM (LGraph m' l')) ->
- (LGraph m l -> UniqSM (LGraph m' l'))
+translate :: Monad tm =>
+ (m -> tm (LGraph m' l')) ->
+ (l -> tm (LGraph m' l')) ->
+ (LGraph m l -> tm (LGraph m' l'))
{-
-- | It's possible that another form of translation would be more suitable:
head_id :: ZHead m -> BlockId
head_id (ZFirst id) = id
-head_id (ZHead h _) = head_id h
+head_id (ZHead h _) = head_id h
last (ZBlock _ t) = lastTail t
lastTail (ZLast l) = l
lastTail (ZTail _ t) = lastTail t
-tailOfLast l = ZLast (LastOther l) -- ^ tedious to write in every client
+tailOfLast l = ZLast (LastOther l) -- tedious to write in every client
------------------ simple graph manipulations
focus :: BlockId -> LGraph m l -> FGraph m l -- focus on edge out of node with id
focus id (LGraph entry blocks) =
case lookupBlockEnv blocks id of
- Just b -> FGraph entry (unzip b) (delFromUFM blocks id)
+ Just b -> FGraph entry (unzip b) (delFromBlockEnv blocks id)
Nothing -> panic "asked for nonexistent block in flow graph"
entry :: LGraph m l -> FGraph m l -- focus on edge out of entry node
-- | pull out a block satisfying the predicate, if any
splitp_blocks :: (Block m l -> Bool) -> BlockEnv (Block m l) ->
Maybe (Block m l, BlockEnv (Block m l))
-splitp_blocks p blocks = lift $ foldUFM scan (Nothing, emptyBlockEnv) blocks
+splitp_blocks p blocks = lift $ foldBlockEnv' scan (Nothing, emptyBlockEnv) blocks
where scan b (yes, no) =
case yes of
Nothing | p b -> (Just b, no)
lift (Nothing, _) = Nothing
lift (Just b, bs) = Just (b, bs)
--- | 'insertBlock' should not be used to *replace* an existing block
+-- | 'insertBlock' should not be used to /replace/ an existing block
-- but only to insert a new one
insertBlock :: Block m l -> BlockEnv (Block m l) -> BlockEnv (Block m l)
insertBlock b bs =
-- | Used in assertions; tells if a graph has exactly one exit
single_exit :: LGraph l m -> Bool
-single_exit g = foldUFM check 0 (lg_blocks g) == 1
+single_exit g = foldBlockEnv' check 0 (lg_blocks g) == 1
where check block count = case last (unzip block) of
LastExit -> count + (1 :: Int)
_ -> count
-- | Used in assertions; tells if a graph has exactly one exit
single_exitg :: Graph l m -> Bool
-single_exitg (Graph tail blocks) = foldUFM add (exit_count (lastTail tail)) blocks == 1
+single_exitg (Graph tail blocks) = foldBlockEnv' add (exit_count (lastTail tail)) blocks == 1
where add block count = count + exit_count (last (unzip block))
exit_count LastExit = 1 :: Int
exit_count _ = 0
-- more mathematically elegant (but results in more complicated code).
--
-- Here's an easy way to go wrong! Consider
+-- @
-- A -> [B,C]
-- B -> D
-- C -> D
+-- @
-- Then ordinary dfs would give [A,B,D,C] which has a back ref from C to D.
--- Better to geot [A,B,C,D]
-
+-- Better to get [A,B,C,D]
-postorder_dfs' :: LastNode l => LGraph m l -> [Block m l]
-postorder_dfs' g@(LGraph _ blocks) =
- let FGraph _ eblock _ = entry g
- in vnode (zip eblock) (\acc _visited -> acc) [] emptyBlockSet
- where
- -- vnode ::
- -- Block m l -> ([Block m l] -> BlockSet -> a) -> [Block m l] -> BlockSet -> a
- vnode block@(Block id _) cont acc visited =
- if elemBlockSet id visited then
- cont acc visited
- else
- vchildren block (get_children block) cont acc (extendBlockSet visited id)
- vchildren block bs cont acc visited =
- let next children acc visited =
- case children of [] -> cont (block : acc) visited
- (b:bs) -> vnode b (next bs) acc visited
- in next bs acc visited
- get_children block = foldl add_id [] (succs block)
- add_id rst id = case lookupBlockEnv blocks id of
- Just b -> b : rst
- Nothing -> rst
postorder_dfs g@(LGraph _ blockenv) =
- let FGraph id eblock _ = entry g
- dfs1 = zip eblock :
- postorder_dfs_from_except blockenv eblock (unitUniqSet id)
- dfs2 = postorder_dfs' g
--- in ASSERT (map blockId dfs1 == map blockId dfs2) dfs2
- in if (map blockId dfs1 == map blockId dfs2) then dfs2 else panic "inconsistent DFS"
+ let FGraph id eblock _ = entry g in
+ zip eblock : postorder_dfs_from_except blockenv eblock (unitBlockSet id)
-postorder_dfs_from
- :: (HavingSuccessors b, LastNode l) => BlockEnv (Block m l) -> b -> [Block m l]
-postorder_dfs_from blocks b = postorder_dfs_from_except blocks b emptyBlockSet
-
-postorder_dfs_from_except :: forall b m l . (HavingSuccessors b, LastNode l) => BlockEnv (Block m l) -> b -> BlockSet -> [Block m l]
+postorder_dfs_from_except :: (HavingSuccessors b, LastNode l)
+ => BlockEnv (Block m l) -> b -> BlockSet -> [Block m l]
postorder_dfs_from_except blocks b visited =
vchildren (get_children b) (\acc _visited -> acc) [] visited
where
Just b -> b : rst
Nothing -> rst
+postorder_dfs_from
+ :: (HavingSuccessors b, LastNode l) => BlockEnv (Block m l) -> b -> [Block m l]
+postorder_dfs_from blocks b = postorder_dfs_from_except blocks b emptyBlockSet
+
+
-- | Slightly more complicated than the usual fold because we want to tell block
-- 'b1' what its inline successor is going to be, so that if 'b1' ends with
-- | The rest of the traversals are straightforward
-map_blocks f (LGraph eid blocks) = LGraph eid (mapUFM f blocks)
+map_blocks f (LGraph eid blocks) = LGraph eid (mapBlockEnv f blocks)
+
+map_nodes idm middle last (LGraph eid blocks) =
+ LGraph (idm eid) (mapBlockEnv (map_one_block idm middle last) blocks)
-map_nodes idm middle last (LGraph eid blocks) = LGraph (idm eid) (mapUFM block blocks)
- where block (Block id t) = Block (idm id) (tail t)
- tail (ZTail m t) = ZTail (middle m) (tail t)
+map_one_block idm middle last (Block id t) = Block (idm id) (tail t)
+ where tail (ZTail m t) = ZTail (middle m) (tail t)
tail (ZLast LastExit) = ZLast LastExit
tail (ZLast (LastOther l)) = ZLast (LastOther (last l))
-fold_blocks f z (LGraph _ blocks) = foldUFM f z blocks
-of_block_list e blocks = LGraph e $ foldr insertBlock emptyBlockEnv blocks
-to_block_list (LGraph _ blocks) = eltsUFM blocks
+mapM_blocks f (LGraph eid blocks) = blocks' >>= return . LGraph eid
+ where blocks' =
+ foldBlockEnv' (\b mblocks -> do { blocks <- mblocks
+ ; b <- f b
+ ; return $ insertBlock b blocks })
+ (return emptyBlockEnv) blocks
+fold_blocks f z (LGraph _ blocks) = foldBlockEnv' f z blocks
+fold_fwd_block first middle last (Block id t) z = tail t (first id z)
+ where tail (ZTail m t) z = tail t (middle m z)
+ tail (ZLast l) z = last l z
+of_block_list e blocks = LGraph e $ foldr insertBlock emptyBlockEnv blocks
+to_block_list (LGraph _ blocks) = eltsBlockEnv blocks
-- We want to be able to scrutinize a single-entry, single-exit 'LGraph' for
prepare_for_splicing g single multi =
let FGraph _ gentry gblocks = entry g
ZBlock _ etail = gentry
- in if isNullUFM gblocks then
+ in if isNullBEnv gblocks then
case last gentry of
LastExit -> single etail
_ -> panic "bad single block"
Graph m l -> (ZTail m l -> a) -> (ZTail m l -> ZHead m -> BlockEnv (Block m l) -> a)
-> a
prepare_for_splicing' (Graph etail gblocks) single multi =
- if isNullUFM gblocks then
+ if isNullBEnv gblocks then
case lastTail etail of
LastExit -> single etail
_ -> panic "bad single block"
is_exit :: Block m l -> Bool
is_exit b = case last (unzip b) of { LastExit -> True; _ -> False }
-splice_head head g =
+splice_head head g@(LGraph _ _) =
ASSERT (single_exit g) prepare_for_splicing g splice_one_block splice_many_blocks
where eid = head_id head
splice_one_block tail' =
splice_head_only head g =
let FGraph eid gentry gblocks = entry g
in case gentry of
- ZBlock (ZFirst _) tail -> LGraph eid (insertBlock (zipht head tail) gblocks)
+ ZBlock (ZFirst _) tail ->
+ LGraph eid (insertBlock (zipht head tail) gblocks)
_ -> panic "entry not at start of block?!"
splice_head_only' head (Graph tail gblocks) =
let eblock = zipht head tail in
LGraph (blockId eblock) (insertBlock eblock gblocks)
+ -- the offset probably should never be used, but well, it's correct for this LGraph
--- Translation
translate txm txl (LGraph eid blocks) =
- do blocks' <- foldUFM txblock (return emptyBlockEnv) blocks
+ do blocks' <- foldBlockEnv' txblock (return emptyBlockEnv) blocks
return $ LGraph eid blocks'
where
-- txblock ::
- -- Block m l -> UniqSM (BlockEnv (Block m' l')) -> UniqSM (BlockEnv (Block m' l'))
+ -- Block m l -> tm (BlockEnv (Block m' l')) -> tm (BlockEnv (Block m' l'))
txblock (Block id t) expanded =
do blocks' <- expanded
txtail (ZFirst id) t blocks'
-- txtail :: ZHead m' -> ZTail m l -> BlockEnv (Block m' l') ->
- -- UniqSM (BlockEnv (Block m' l'))
+ -- tm (BlockEnv (Block m' l'))
txtail h (ZTail m t) blocks' =
do m' <- txm m
let (g, h') = splice_head h m'
- txtail h' t (plusUFM (lg_blocks g) blocks')
+ txtail h' t (plusBlockEnv (lg_blocks g) blocks')
txtail h (ZLast (LastOther l)) blocks' =
do l' <- txl l
- return $ plusUFM (lg_blocks (splice_head_only h l')) blocks'
+ return $ plusBlockEnv (lg_blocks (splice_head_only h l')) blocks'
txtail h (ZLast LastExit) blocks' =
return $ insertBlock (zipht h (ZLast LastExit)) blocks'
----------------------------------------------------------------
---- Block Ids, their environments, and their sets
-
-{- Note [Unique BlockId]
-~~~~~~~~~~~~~~~~~~~~~~~~
-Although a 'BlockId' is a local label, for reasons of implementation,
-'BlockId's must be unique within an entire compilation unit. The reason
-is that each local label is mapped to an assembly-language label, and in
-most assembly languages allow, a label is visible throughout the enitre
-compilation unit in which it appears.
--}
-
-newtype BlockId = BlockId Unique
- deriving (Eq,Ord)
-
-instance Uniquable BlockId where
- getUnique (BlockId u) = u
-
-instance Show BlockId where
- show (BlockId u) = show u
-
-instance Outputable BlockId where
- ppr = ppr . getUnique
-
-
-type BlockEnv a = UniqFM {- BlockId -} a
-emptyBlockEnv :: BlockEnv a
-emptyBlockEnv = emptyUFM
-lookupBlockEnv :: BlockEnv a -> BlockId -> Maybe a
-lookupBlockEnv = lookupUFM
-extendBlockEnv :: BlockEnv a -> BlockId -> a -> BlockEnv a
-extendBlockEnv = addToUFM
-mkBlockEnv :: [(BlockId,a)] -> BlockEnv a
-mkBlockEnv = listToUFM
-
-type BlockSet = UniqSet BlockId
-emptyBlockSet :: BlockSet
-emptyBlockSet = emptyUniqSet
-elemBlockSet :: BlockId -> BlockSet -> Bool
-elemBlockSet = elementOfUniqSet
-extendBlockSet :: BlockSet -> BlockId -> BlockSet
-extendBlockSet = addOneToUniqSet
-mkBlockSet :: [BlockId] -> BlockSet
-mkBlockSet = mkUniqSet
-
-----------------------------------------------------------------
---- Prettyprinting
----------------------------------------------------------------
instance (Outputable m, Outputable l) => Outputable (ZTail m l) where
ppr = pprTail
+instance (Outputable m, Outputable l, LastNode l) => Outputable (Graph m l) where
+ ppr = pprGraph
+
+instance (Outputable m, Outputable l, LastNode l) => Outputable (LGraph m l) where
+ ppr = pprLgraph
+
+instance (Outputable m, Outputable l, LastNode l) => Outputable (Block m l) where
+ ppr = pprBlock
+
+instance (Outputable l) => Outputable (ZLast l) where
+ ppr = pprLast
+
pprTail :: (Outputable m, Outputable l) => ZTail m l -> SDoc
pprTail (ZTail m t) = ppr m $$ ppr t
-pprTail (ZLast LastExit) = text "<exit>"
-pprTail (ZLast (LastOther l)) = ppr l
+pprTail (ZLast l) = ppr l
+
+pprLast :: (Outputable l) => ZLast l -> SDoc
+pprLast LastExit = text "<exit>"
+pprLast (LastOther l) = ppr l
+
+pprBlock :: (Outputable m, Outputable l, LastNode l) => Block m l -> SDoc
+pprBlock (Block id tail) =
+ ppr id <> colon
+ $$ (nest 3 (ppr tail))
pprLgraph :: (Outputable m, Outputable l, LastNode l) => LGraph m l -> SDoc
-pprLgraph g = text "{" $$ nest 2 (vcat $ map pprBlock blocks) $$ text "}"
- where pprBlock (Block id tail) = ppr id <> colon $$ ppr tail
- blocks = postorder_dfs g
+pprLgraph g = text "{" <> text "offset" $$
+ nest 2 (vcat $ map ppr blocks) $$ text "}"
+ where blocks = postorder_dfs g
pprGraph :: (Outputable m, Outputable l, LastNode l) => Graph m l -> SDoc
pprGraph (Graph tail blockenv) =
- text "{" $$ nest 2 (ppr tail $$ (vcat $ map pprBlock blocks)) $$ text "}"
- where pprBlock (Block id tail) = ppr id <> colon $$ ppr tail
- blocks = postorder_dfs_from blockenv tail
+ text "{" $$ nest 2 (ppr tail $$ (vcat $ map ppr blocks)) $$ text "}"
+ where blocks = postorder_dfs_from blockenv tail
-_unused :: FS.FastString
-_unused = undefined
projects / ghc-hetmet.git / blobdiff