-{-# OPTIONS -Wall -fno-warn-name-shadowing #-}
module ZipCfg
- ( BlockId(..), freshBlockId
+ ( -- These data types and names are carefully thought out
+ BlockId(..), mkBlockId -- ToDo: BlockId should be abstract, but it isn't yet
, BlockEnv, emptyBlockEnv, lookupBlockEnv, extendBlockEnv, insertBlock, mkBlockEnv
, BlockSet, emptyBlockSet, elemBlockSet, extendBlockSet, mkBlockSet
, Graph(..), LGraph(..), FGraph(..)
, 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_tail, splice_head, splice_head_only', splice_head'
, of_block_list, to_block_list
- , map_nodes
- , postorder_dfs
+ , map_blocks, map_nodes, mapM_blocks
+ , postorder_dfs, postorder_dfs_from, postorder_dfs_from_except
, fold_layout
, fold_blocks
, translate
- , pprLgraph
+ , 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
#include "HsVersions.h"
+import CmmExpr ( UserOfLocalRegs(..) ) --for an instance
+
import Outputable hiding (empty)
import Panic
import Unique
import UniqFM
import UniqSet
-import UniqSupply
import Maybe
import Prelude hiding (zip, unzip, last)
'LastExit' node, and a graph representing a full procedure should not
contain any 'LastExit' nodes. 'LastExit' nodes are used only to splice
graphs together, either during graph construction (see module 'MkZipCfg')
-or during optimization (see module 'ZipDataflow').
+or during optimization (see module 'ZipDataflow0').
A graph is parameterized over the types of middle and last nodes. Each of
these types will typically be instantiated with a subset of C-- statements
implemented as of August 2007).
-
+Note [Kinds of Graphs]
+~~~~~~~~~~~~~~~~~~~~~~
This module exposes three representations of graphs. In order of
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
-- so we don't want to pollute the 'l' type parameter with it
| LastOther l
+--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
+-- | Blocks and flow graphs; see Note [Kinds of graphs]
data Block m l = Block BlockId (ZTail m l)
-data Graph m l = Graph (ZTail m l) (BlockEnv (Block 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) }
+ -- Invariant: lg_entry is in domain( lg_blocks )
-- | And now the zipper. The focus is between the head and tail.
-- We cannot ever focus on an inter-block edge.
-- Splicing a tail is the dual operation.
-- (In order to maintain the order-means-control-flow convention, the
-- orders are reversed.)
+--
+-- For example, assume
+-- head = [L: x:=0]
+-- grph = (M, [M: <stuff>,
+-- <blocks>,
+-- N: y:=x; LastExit])
+-- tail = [return (y,x)]
+--
+-- Then splice_head head grph
+-- = ((L, [L: x:=0; goto M,
+-- M: <stuff>,
+-- <blocks>])
+-- , N: y:=x)
+--
+-- Then splice_tail grph tail
+-- = ( <stuff>
+-- , (???, [<blocks>,
+-- N: y:=x; return (y,x)])
-splice_head :: ZHead m -> LGraph m l -> (LGraph m l, ZHead m)
-splice_tail :: LGraph m l -> ZTail m l -> (ZTail m l, LGraph m 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
--- | We can also splice a single-entry, no-exit LGraph into a head.
+-- | 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
+
--- | Finally, we can remove the entry label of an LGraph and remove
--- it, leaving a Graph:
-remove_entry_label :: LGraph m l -> Graph m l
+-- | A safe operation
-- | Conversion to and from the environment form is convenient. For
-- layout or dataflow, however, one will want to use 'postorder_dfs'
to_block_list :: LGraph m l -> [Block m l] -- N log N
-- | Traversal: 'postorder_dfs' returns a list of blocks reachable
--- from the entry node. The postorder depth-first-search order means
--- the list is in roughly first-to-last order, as suitable for use in
+-- from the entry node. This list has the following property:
+--
+-- Say a "back reference" exists if one of a block's
+-- control-flow successors precedes it in the output list
+--
+-- Then there are as few back references as possible
+--
+-- The output is suitable for use in
-- a forward dataflow problem. For a backward problem, simply reverse
--- the list. ('postorder_dfs' is sufficiently trick to implement that
+-- the list. ('postorder_dfs' is sufficiently tricky to implement that
-- one doesn't want to try and maintain both forward and backward
-- versions.)
-- block that will be the layout successor of the current block. This
-- may be useful to help an emitter omit the final 'goto' of a block
-- that flows directly to its layout successor.
+--
+-- For example: fold_layout f z [ L1:B1, L2:B2, L3:B3 ]
+-- = z <$> f (L1:B1) (Just L2)
+-- <$> f (L2:B2) (Just L3)
+-- <$> f (L3:B3) Nothing
+-- where a <$> f = f a
fold_layout ::
LastNode l => (Block m l -> Maybe BlockId -> a -> a) -> a -> LGraph m l-> a
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:
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)
+
+
-- ================ IMPLEMENTATION ================--
blockId (Block id _) = id
--- | The string argument 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
-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.
head_id (ZFirst id) = id
head_id (ZHead h _) = head_id h
-last (ZBlock _ t) = lastt t
- where lastt (ZLast l) = l
- lastt (ZTail _ t) = lastt t
+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) -- ^ tedious to write in every client
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
+ where add block count = count + exit_count (last (unzip block))
+ exit_count LastExit = 1 :: Int
+ exit_count _ = 0
+
------------------ graph traversals
-- | This is the most important traversal over this data structure. It drops
-- The ubiquity of 'postorder_dfs' is one reason for the ubiquity of the 'LGraph'
-- representation, when for most purposes the plain 'Graph' representation is
-- more mathematically elegant (but results in more complicated code).
-
-postorder_dfs g@(LGraph _ blocks) =
- let FGraph _ eblock _ = entry g
- in vnode (zip eblock) (\acc _visited -> acc) [] emptyBlockSet
+--
+-- 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]
+
+
+postorder_dfs g@(LGraph _ blockenv) =
+ let FGraph id eblock _ = entry g in
+ zip eblock : postorder_dfs_from_except blockenv eblock (unitUniqSet id)
+
+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
-- vnode ::
-- Block m l -> ([Block m l] -> BlockSet -> a) -> [Block m l] -> BlockSet -> a
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 cont' acc visited = cont (block:acc) visited in
+ vchildren (get_children block) cont' acc (extendBlockSet visited id)
+ vchildren bs cont acc visited =
let next children acc visited =
- case children of [] -> cont (block : acc) visited
+ case children of [] -> cont acc visited
(b:bs) -> vnode b (next bs) acc visited
in next bs acc visited
get_children block = foldl add_id [] (succs block)
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_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)
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' =
+ foldUFM (\b mblocks -> do { blocks <- mblocks
+ ; b <- f b
+ ; return $ insertBlock b blocks })
+ (return emptyBlockEnv) blocks
+
fold_blocks f z (LGraph _ blocks) = foldUFM f z blocks
of_block_list e blocks = LGraph e $ foldr insertBlock emptyBlockEnv blocks
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 isNullUFM 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_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 :: Graph m l -> ZTail m l -> Graph m l
splice_tail g tail =
- ASSERT (single_exit g) prepare_for_splicing g splice_one_block splice_many_blocks
+ 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_tail g tail =
+ AS SERT (single_exit g) prepare_for_splicing g splice_one_block splice_many_blocks
where splice_one_block tail' = -- return tail' .. tail
case ht_to_last (ZFirst (lg_entry g)) tail' of
(head', LastExit) ->
_ -> panic "spliced single block without Exit"
splice_many_blocks entry exit others =
(entry, LGraph (lg_entry g) (insertBlock (zipht exit tail) others))
+-}
splice_head_only head g =
let FGraph eid gentry gblocks = entry g
ZBlock (ZFirst _) tail -> LGraph eid (insertBlock (zipht head tail) gblocks)
_ -> panic "entry not at start of block?!"
-remove_entry_label g =
- let FGraph e eblock others = entry g
- in case eblock of
- ZBlock (ZFirst id) tail
- | id == e -> Graph tail others
- _ -> panic "id doesn't match on entry block"
+splice_head_only' head (Graph tail gblocks) =
+ let eblock = zipht head tail in
+ LGraph (blockId eblock) (insertBlock eblock gblocks)
+
--- Translation
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'
instance Uniquable BlockId where
getUnique (BlockId u) = u
+mkBlockId :: Unique -> BlockId
+mkBlockId uniq = BlockId uniq
+
instance Show BlockId where
show (BlockId u) = show u
instance (Outputable m, Outputable l) => Outputable (ZTail m l) where
ppr = pprTail
+instance (Outputable m, Outputable l, LastNode l) => Outputable (LGraph m l) where
+ ppr = pprLgraph
+
+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
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
-_unused :: FS.FastString
-_unused = undefined
+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
+
projects / ghc-hetmet.git / blobdiff