module ZipCfg
(
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
, graphOfLGraph
, map_blocks, map_one_block, map_nodes, mapM_blocks
, postorder_dfs, postorder_dfs_from, postorder_dfs_from_except
, fold_layout
, fold_blocks, fold_fwd_block
, translate
, pprLgraph, pprGraph
, entry
)
where
#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 Data.Maybe
import Prelude hiding (zip, unzip, last)
data ZLast l
= LastExit
| LastOther l
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
data ZTail m l = ZLast (ZLast l) | ZTail m (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 ZBlock m l = ZBlock (ZHead m) (ZTail m l)
data FGraph m l = FGraph { fg_entry :: BlockId
, fg_focus :: ZBlock m l
, fg_others :: BlockEnv (Block m l) }
blockId :: Block m l -> BlockId
zip :: ZBlock m l -> Block m l
unzip :: Block m l -> ZBlock m l
last :: ZBlock m l -> ZLast l
goto_end :: ZBlock m l -> (ZHead m, ZLast l)
tailOfLast :: l -> ZTail m l
ht_to_block, zipht :: ZHead m -> ZTail m l -> Block m l
ht_to_last :: ZHead m -> ZTail m l -> (ZHead m, ZLast l)
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
splice_head_only :: ZHead m -> LGraph m l -> LGraph m l
splice_head_only' :: ZHead m -> Graph m l -> LGraph m l
of_block_list :: BlockId -> [Block m l] -> LGraph m l
to_block_list :: LGraph m l -> [Block m l]
graphOfLGraph :: LastNode l => LGraph m l -> Graph m l
graphOfLGraph (LGraph eid blocks) = Graph (ZLast $ mkBranchNode eid) blocks
postorder_dfs :: LastNode l => LGraph m l -> [Block m l]
fold_layout ::
LastNode l => (Block m l -> Maybe BlockId -> a -> a) -> a -> LGraph m l-> a
fold_blocks :: (Block m l -> a -> a) -> a -> LGraph m l -> a
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'
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')
translate :: Monad tm =>
(m -> tm (LGraph m' l')) ->
(l -> tm (LGraph m' l')) ->
(LGraph m l -> tm (LGraph m' l'))
class HavingSuccessors b where
succs :: b -> [BlockId]
fold_succs :: (BlockId -> a -> a) -> b -> a -> a
fold_succs add l z = foldr add z $ succs l
class HavingSuccessors l => LastNode l where
mkBranchNode :: BlockId -> l
isBranchNode :: l -> Bool
branchNodeTarget :: l -> BlockId
instance HavingSuccessors l => HavingSuccessors (ZLast l) where
succs LastExit = []
succs (LastOther l) = succs l
fold_succs _ LastExit z = z
fold_succs f (LastOther l) z = fold_succs f l z
instance LastNode l => LastNode (ZLast l) where
mkBranchNode id = LastOther $ mkBranchNode id
isBranchNode LastExit = False
isBranchNode (LastOther l) = isBranchNode l
branchNodeTarget LastExit = panic "branchNodeTarget LastExit"
branchNodeTarget (LastOther l) = branchNodeTarget l
instance LastNode l => HavingSuccessors (ZBlock m l) where
succs b = succs (last b)
instance LastNode l => HavingSuccessors (Block m l) where
succs b = succs (unzip b)
instance LastNode l => HavingSuccessors (ZTail m l) where
succs b = succs (lastTail b)
blockId (Block id _) = id
ht_to_block head tail = case head of
ZFirst id -> Block id tail
ZHead h m -> ht_to_block h (ZTail m tail)
ht_to_last head (ZLast l) = (head, l)
ht_to_last head (ZTail m t) = ht_to_last (ZHead head m) t
zipht h t = ht_to_block h t
zip (ZBlock h t) = ht_to_block h t
goto_end (ZBlock h t) = ht_to_last h t
unzip (Block id t) = ZBlock (ZFirst id) t
head_id :: ZHead m -> BlockId
head_id (ZFirst id) = id
head_id (ZHead h _) = head_id h
last (ZBlock _ t) = lastTail t
lastTail :: ZTail m l -> ZLast l
lastTail (ZLast l) = l
lastTail (ZTail _ t) = lastTail t
tailOfLast l = ZLast (LastOther l)
focus :: BlockId -> LGraph m l -> FGraph m l
focus id (LGraph entry blocks) =
case lookupBlockEnv blocks id of
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
entry g@(LGraph eid _) = focus eid g
splitp_blocks :: (Block m l -> Bool) -> BlockEnv (Block m l) ->
Maybe (Block m l, BlockEnv (Block m l))
splitp_blocks p blocks = lift $ foldBlockEnv' scan (Nothing, emptyBlockEnv) blocks
where scan b (yes, no) =
case yes of
Nothing | p b -> (Just b, no)
| otherwise -> (yes, insertBlock b no)
Just _ -> (yes, insertBlock b no)
lift (Nothing, _) = Nothing
lift (Just b, bs) = Just (b, bs)
insertBlock :: Block m l -> BlockEnv (Block m l) -> BlockEnv (Block m l)
insertBlock b bs =
ASSERT (isNothing $ lookupBlockEnv bs id)
extendBlockEnv bs id b
where id = blockId b
single_exit :: LGraph l m -> Bool
single_exit g = foldBlockEnv' check 0 (lg_blocks g) == 1
where check block count = case last (unzip block) of
LastExit -> count + (1 :: Int)
_ -> count
single_exitg :: Graph l m -> Bool
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
postorder_dfs g@(LGraph _ blockenv) =
let FGraph id eblock _ = entry g in
zip eblock : postorder_dfs_from_except blockenv eblock (unitBlockSet id)
postorder_dfs_from_except :: forall m b l. (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
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
let cont' acc visited = cont (block:acc) visited in
vchildren (get_children block) cont' acc (extendBlockSet visited id)
vchildren :: [Block m l] -> ([Block m l] -> BlockSet -> a)
-> [Block m l] -> BlockSet -> a
vchildren bs cont acc visited =
let next children acc visited =
case children of [] -> cont acc visited
(b:bs) -> vnode b (next bs) acc visited
in next bs acc visited
get_children :: HavingSuccessors c => c -> [Block m l]
get_children block = foldl add_id [] (succs block)
add_id :: [Block m l] -> BlockId -> [Block m l]
add_id rst id = case lookupBlockEnv blocks id of
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
fold_layout f z g@(LGraph eid _) = fold (postorder_dfs g) z
where fold blocks z =
case blocks of [] -> z
[b] -> f b Nothing z
b1 : b2 : bs -> fold (b2 : bs) (f b1 (nextlabel b2) z)
nextlabel (Block id _) =
if id == eid then panic "entry as successor"
else Just id
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_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))
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
prepare_for_splicing ::
LGraph m l -> (ZTail m l -> a) -> (ZTail m l -> ZHead m -> BlockEnv (Block m l) -> a)
-> a
prepare_for_splicing g single multi =
let FGraph _ gentry gblocks = entry g
ZBlock _ etail = gentry
in if isNullBEnv gblocks then
case last gentry of
LastExit -> single etail
_ -> panic "bad single block"
else
case splitp_blocks is_exit gblocks of
Nothing -> panic "Can't find an exit block"
Just (gexit, gblocks) ->
let (gh, gl) = goto_end $ unzip gexit in
case gl of LastExit -> multi etail gh gblocks
_ -> panic "exit is not exit?!"
prepare_for_splicing' ::
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 isNullBEnv gblocks then
case lastTail etail of
LastExit -> single etail
_ -> panic "bad single block"
else
case splitp_blocks is_exit gblocks of
Nothing -> panic "Can't find an exit block"
Just (gexit, gblocks) ->
let (gh, gl) = goto_end $ unzip gexit in
case gl of LastExit -> multi etail gh gblocks
_ -> panic "exit is not exit?!"
is_exit :: Block m l -> Bool
is_exit b = case last (unzip b) of { LastExit -> True; _ -> False }
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' =
case ht_to_last head tail' of
(head, LastExit) -> (LGraph eid emptyBlockEnv, head)
_ -> panic "spliced LGraph without exit"
splice_many_blocks entry exit others =
(LGraph eid (insertBlock (zipht head entry) others), exit)
splice_head' head g =
ASSERT (single_exitg g) prepare_for_splicing' g splice_one_block splice_many_blocks
where splice_one_block tail' =
case ht_to_last head tail' of
(head, LastExit) -> (emptyBlockEnv, head)
_ -> panic "spliced LGraph without exit"
splice_many_blocks entry exit others =
(insertBlock (zipht head entry) others, exit)
splice_tail g tail =
ASSERT (single_exitg g) prepare_for_splicing' g splice_one_block splice_many_blocks
where splice_one_block tail' = Graph (tail' `append_tails` tail) emptyBlockEnv
append_tails (ZLast LastExit) tail = tail
append_tails (ZLast _) _ = panic "spliced single block without LastExit"
append_tails (ZTail m t) tail = ZTail m (append_tails t tail)
splice_many_blocks entry exit others =
Graph entry (insertBlock (zipht exit tail) others)
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)
_ -> 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)
translate txm txl (LGraph eid blocks) =
do blocks' <- foldBlockEnv' txblock (return emptyBlockEnv) blocks
return $ LGraph eid blocks'
where
txblock (Block id t) expanded =
do blocks' <- expanded
txtail (ZFirst id) t blocks'
txtail h (ZTail m t) blocks' =
do m' <- txm m
let (g, h') = splice_head h m'
txtail h' t (plusBlockEnv (lg_blocks g) blocks')
txtail h (ZLast (LastOther l)) blocks' =
do l' <- txl l
return $ plusBlockEnv (lg_blocks (splice_head_only h l')) blocks'
txtail h (ZLast LastExit) blocks' =
return $ insertBlock (zipht h (ZLast LastExit)) blocks'
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 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 "{" <> 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 ppr blocks)) $$ text "}"
where blocks = postorder_dfs_from blockenv tail