X-Git-Url: http://git.megacz.com/?p=ghc-hetmet.git;a=blobdiff_plain;f=compiler%2Fcmm%2FZipCfg.hs;h=3a5932cadd36809050bf5776f8706665f0101455;hp=bf8d49f963d3ad0efa89fe789669f2fa1f712a7e;hb=d436c70d43fb905c63220040168295e473f4b90a;hpb=b9bcf6e71abe0d861c99618ee5a7ae9e2c45d26c diff --git a/compiler/cmm/ZipCfg.hs b/compiler/cmm/ZipCfg.hs index bf8d49f..3a5932c 100644 --- a/compiler/cmm/ZipCfg.hs +++ b/compiler/cmm/ZipCfg.hs @@ -1,36 +1,34 @@ -{-# LANGUAGE ScopedTypeVariables #-} module ZipCfg ( -- These data types and names are carefully thought out - BlockId(..), freshBlockId -- 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 -- Observers and transformers -- (open to renaming suggestions here) , blockId, zip, unzip, last, goto_end, zipht, tailOfLast - , remove_entry_label , 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 ZipDataflow0, at least for now + {- -- the following functions might one day be useful and can be found -- either below or in ZipCfgExtras: , 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 -} ) @@ -38,12 +36,14 @@ 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 Panic -import Unique -import UniqFM -import UniqSet -import UniqSupply import Maybe import Prelude hiding (zip, unzip, last) @@ -99,13 +99,13 @@ increasing complexity, they are: There are three types because each type offers a slightly different invariant or cost model. - * The distinguished entry of a Graph has no label. Because labels must - be unique, acquiring one requires a monadic operation ('freshBlockId'). - The primary advantage of the Graph representation is that we can build - a small Graph purely functionally, without entering a monad. For - example, during optimization we can easily rewrite a single middle - node into a Graph containing a sequence of two middle nodes followed by - LastExit. + * The distinguished entry of a Graph has no label. Because labels must be + unique, acquiring one requires a supply of Unique labels (BlockId's). + The primary advantage of the Graph representation is that we can build a + small Graph purely functionally, without needing a fresh BlockId or + Unique. For example, during optimization we can easily rewrite a single + middle node into a Graph containing a sequence of two middle nodes + followed by LastExit. * In an LGraph, every basic block is labelled. The primary advantage of this representation is its simplicity: each basic block can be treated @@ -142,18 +142,29 @@ data ZLast l -- 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. @@ -167,11 +178,6 @@ data FGraph m l = FGraph { fg_entry :: BlockId ---- Utility functions --- --- | The string argument to 'freshBlockId' was originally helpful in debugging the Quick C-- --- compiler, so I have kept it here even though at present it is thrown away at --- this spot---there's no reason a BlockId couldn't one day carry a string. -freshBlockId :: String -> UniqSM BlockId - blockId :: Block m l -> BlockId zip :: ZBlock m l -> Block m l unzip :: Block m l -> ZBlock m l @@ -217,13 +223,13 @@ ht_to_last :: ZHead m -> ZTail m l -> (ZHead m, ZLast l) -- , (???, [, -- 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 @@ -235,6 +241,11 @@ splice_head_only' :: ZHead m -> Graph m l -> LGraph m l 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: -- @@ -270,14 +281,25 @@ fold_layout :: -- 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' +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: @@ -335,8 +357,6 @@ instance LastNode l => HavingSuccessors (ZTail m l) where blockId (Block id _) = id -freshBlockId _ = do { u <- getUniqueUs; return $ BlockId u } - -- | Convert block between forms. -- These functions are tail-recursive, so we can go as deep as we like -- without fear of stack overflow. @@ -356,7 +376,7 @@ 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 +head_id (ZHead h _) = head_id h last (ZBlock _ t) = lastTail t @@ -364,7 +384,7 @@ lastTail :: ZTail m l -> ZLast l 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 @@ -372,7 +392,7 @@ tailOfLast l = ZLast (LastOther l) -- ^ tedious to write in every client 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 @@ -381,7 +401,7 @@ entry g@(LGraph eid _) = focus eid g -- | 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) @@ -390,7 +410,7 @@ splitp_blocks p blocks = lift $ foldUFM scan (Nothing, emptyBlockEnv) blocks 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 = @@ -400,14 +420,14 @@ 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 @@ -428,47 +448,21 @@ single_exitg (Graph tail blocks) = foldUFM add (exit_count (lastTail tail)) bloc -- 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 - -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 + let FGraph id eblock _ = entry g in + zip eblock : postorder_dfs_from_except blockenv eblock (unitBlockSet id) -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 @@ -490,6 +484,11 @@ postorder_dfs_from_except blocks b visited = 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 @@ -506,18 +505,31 @@ fold_layout f z g@(LGraph eid _) = fold (postorder_dfs g) z -- | The rest of the traversals are straightforward -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_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)) -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 @@ -530,7 +542,7 @@ prepare_for_splicing :: 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" @@ -546,7 +558,7 @@ 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 isNullUFM gblocks then + if isNullBEnv gblocks then case lastTail etail of LastExit -> single etail _ -> panic "bad single block" @@ -561,7 +573,7 @@ prepare_for_splicing' (Graph etail gblocks) single multi = 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' = @@ -607,83 +619,40 @@ splice_tail g 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 ---------------------------------------------------------------- @@ -692,21 +661,38 @@ mkBlockSet = mkUniqSet 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 "" -pprTail (ZLast (LastOther l)) = ppr l +pprTail (ZLast l) = ppr l + +pprLast :: (Outputable l) => ZLast l -> SDoc +pprLast LastExit = text "" +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