-{-# OPTIONS -Wall -fno-warn-name-shadowing #-}
module ZipCfg
- ( BlockId(..), freshBlockId
- , BlockEnv, emptyBlockEnv, lookupBlockEnv, extendBlockEnv, insertBlock, mkBlockEnv
- , BlockSet, emptyBlockSet, elemBlockSet, extendBlockSet, mkBlockSet
- , Graph(..), LGraph(..), FGraph(..)
+ ( -- These data types and names are carefully thought out
+ Graph(..), LGraph(..), FGraph(..)
, Block(..), ZBlock(..), ZHead(..), ZTail(..), ZLast(..)
+ , insertBlock
, HavingSuccessors, succs, fold_succs
, LastNode, mkBranchNode, isBranchNode, branchNodeTarget
-- Observers and transformers
- , entry, exit, focus, focusp, unfocus
- , blockId, zip, unzip, last, goto_end, ht_to_first, ht_to_last, zipht
- , tailOfLast
- , splice_head, splice_tail, splice_head_only, splice_focus_entry
- , splice_focus_exit, remove_entry_label
+ -- (open to renaming suggestions here)
+ , blockId, zip, unzip, last, goto_end, zipht, tailOfLast
+ , splice_tail, splice_head, splice_head_only', splice_head'
, of_block_list, to_block_list
- , postorder_dfs
- , fold_layout, fold_blocks
- , fold_fwd_block, foldM_fwd_block
- , map_nodes, translate
+ , 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 -- 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
+ , foldM_fwd_block
+ -}
- , pprLgraph
)
where
-import Maybes
+#include "HsVersions.h"
+
+import BlockId ( BlockId, BlockEnv, emptyBlockEnv, lookupBlockEnv, extendBlockEnv
+ , BlockSet, emptyBlockSet, elemBlockSet, extendBlockSet)
+import CmmExpr ( UserOfLocalRegs(..) )
+import PprCmm()
+
import Outputable hiding (empty)
import Panic
-import Prelude hiding (zip, unzip, last)
-import Unique
import UniqFM
import UniqSet
-import UniqSupply
+
+import Maybe
+import Prelude hiding (zip, unzip, last)
-------------------------------------------------------------------------
-- GENERIC ZIPPER-BASED CONTROL-FLOW GRAPH --
'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
translation, as well as layout.
Like any graph, an LGraph still has a distinguished entry point,
- which you can discover using 'gr_entry'.
+ which you can discover using 'lg_entry'.
* An FGraph is an LGraph with the *focus* on one particular edge. The
primary advantage of this representation is that it provides
-}
-entry :: LGraph m l -> FGraph m l -- focus on edge out of entry node
-exit :: LGraph m l -> FGraph m l -- focus on edge into default exit node
- -- (fails if there isn't one)
-focus :: BlockId -> LGraph m l -> FGraph m l -- focus on edge out of node with id
-focusp :: (Block m l -> Bool) -> LGraph m l -> Maybe (FGraph m l)
- -- focus on start of block satisfying predicate
-unfocus :: FGraph m l -> LGraph m l -- lose focus
-
--- | We can insert a single-entry, single-exit subgraph at
--- the current focus.
--- The new focus can be at either the entry edge or the exit edge.
-
-splice_focus_entry :: FGraph m l -> LGraph m l -> FGraph m l
-splice_focus_exit :: FGraph m l -> LGraph m l -> FGraph m l
-
--------------- Representation --------------------
--- | A basic block is a [[first]] node, followed by zero or more [[middle]]
--- nodes, followed by a [[last]] node.
+-- | A basic block is a 'first' node, followed by zero or more 'middle'
+-- nodes, followed by a 'last' node.
-- eventually this module should probably replace the original Cmm, but for
-- now we leave it to dynamic invariants what can be found where
-- 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 (Maybe Int)
+ | 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
-data Block m l = Block BlockId (ZTail m l)
+-- | Blocks and flow graphs; see Note [Kinds of graphs]
+-- In addition to its id, the block carries the number of bytes of stack space
+-- used for incoming parameters on entry to the block.
+data Block m l = Block BlockId (Maybe Int) (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 { gr_entry :: BlockId
- , gr_blocks :: BlockEnv (Block m l) }
+data LGraph m l = LGraph { lg_entry :: BlockId
+ , lg_argoffset :: Int -- space (bytes) for incoming args
+ , 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.
--- Notice we cannot ever focus on an inter-block edge.
+-- We cannot ever focus on an inter-block edge.
data ZBlock m l = ZBlock (ZHead m) (ZTail m l)
-data FGraph m l = FGraph { zg_entry :: BlockId
- , zg_focus :: ZBlock m l
- , zg_others :: BlockEnv (Block m l) }
- -- Invariant: the block represented by 'zg_focus' is *not*
- -- in the map 'zg_others'
+data FGraph m l = FGraph { fg_entry :: BlockId
+ , fg_focus :: ZBlock m l
+ , fg_others :: BlockEnv (Block m l) }
+ -- Invariant: the block represented by 'fg_focus' is *not*
+ -- in the map 'fg_others'
---- Utility functions ---
blockId :: Block m l -> BlockId
-zip :: ZBlock m l -> Block m l
-unzip :: Block m l -> ZBlock m l
+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)
+last :: ZBlock m l -> ZLast l
+goto_end :: ZBlock m l -> (ZHead m, ZLast l)
tailOfLast :: l -> ZTail m l
--- | Some ways to combine parts:
-ht_to_first :: ZHead m -> ZTail m l -> Block m l -- was (ZFirst, ZTail)
-ht_to_last :: ZHead m -> ZTail m l -> (ZHead m, ZLast l)
+-- | Take a head and tail and go to beginning or end. The asymmetry
+-- in the types and names is a bit unfortunate, but 'Block m l' is
+-- effectively '(BlockId, ZTail m l)' and is accepted in many more places.
-zipht :: ZHead m -> ZTail m l -> Block 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)
-- | We can splice a single-entry, single-exit LGraph onto a head or a tail.
--- For a head, we have a head~[[h]] followed by a LGraph~[[g]].
--- The entry node of~[[g]] gets joined to~[[h]], forming the entry into
--- the new LGraph. The exit of~[[g]] becomes the new head.
+-- For a head, we have a head 'h' followed by a LGraph 'g'.
+-- The entry node of 'g' gets joined to 'h', forming the entry into
+-- the new LGraph. The exit of 'g' becomes the new head.
-- For both arguments and results, the order of values is the order of
-- control flow: before splicing, the head flows into the LGraph; after
-- splicing, the LGraph flows into the head.
-- Splicing a tail is the dual operation.
-- (In order to maintain the order-means-control-flow convention, the
-- orders are reversed.)
-
-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)
-
--- | We can also splice a single-entry, no-exit LGraph into a head.
-splice_head_only :: ZHead m -> LGraph 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
-
-of_block_list :: BlockId -> [Block m l] -> LGraph m l -- N log N
+--
+-- 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_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
+
+
+-- | A safe operation
+
+-- | Conversion to and from the environment form is convenient. For
+-- layout or dataflow, however, one will want to use 'postorder_dfs'
+-- in order to get the blocks in an order that relates to the control
+-- flow in the procedure.
+of_block_list :: BlockId -> Int -> [Block m l] -> LGraph m l -- N log N
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 a forward dataflow problem.
+-- | 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:
+--
+-- 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 tricky to implement that
+-- one doesn't want to try and maintain both forward and backward
+-- versions.)
postorder_dfs :: LastNode l => LGraph m l -> [Block m l]
--- | For layout, we fold over pairs of [[Block m l]] and [[Maybe BlockId]]
--- in layout order. The [[BlockId]], if any, identifies the 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 layout, we fold over pairs of 'Block m l' and 'Maybe BlockId'
+-- in layout order. The 'Maybe BlockId', if present, identifies the
+-- 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
--- | We can also fold and iterate over blocks.
+-- | We can also fold over blocks in an unspecified order. The
+-- 'ZipCfgExtras' module provides a monadic version, which we
+-- 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!
-translate :: (m -> UniqSM (LGraph m' l')) -> (l -> UniqSM (LGraph m' l')) ->
- LGraph m l -> UniqSM (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 :: 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:
translateA :: (m -> Agraph m' l') -> (l -> AGraph m' l') -> LGraph m l -> LGraph m' l'
-}
------------------- Last nodes
--- | We can't make a graph out of just any old 'last node' type. A
--- last node has to be able to find its successors, and we need to
--- be able to create and identify unconditional branches. We put
--- these capabilities in a type class.
+-- | We can't make a graph out of just any old 'last node' type. A last node
+-- has to be able to find its successors, and we need to be able to create and
+-- identify unconditional branches. We put these capabilities in a type class.
+-- Moreover, the property of having successors is also shared by 'Block's and
+-- 'ZTails', so it is useful to have that property in a type class of its own.
class HavingSuccessors b where
- succs :: b -> [BlockId]
- fold_succs :: (BlockId -> a -> a) -> b -> a -> a
+ succs :: b -> [BlockId]
+ fold_succs :: (BlockId -> a -> a) -> b -> a -> a
- fold_succs add l z = foldr add z $ succs l
+ 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 -- panics if not branch node
+ mkBranchNode :: BlockId -> l
+ isBranchNode :: l -> Bool
+ branchNodeTarget :: l -> BlockId -- panics if not branch node
+ -- ^ N.B. This interface seems to make for more congenial clients than a
+ -- single function of type 'l -> Maybe BlockId'
instance HavingSuccessors l => HavingSuccessors (ZLast l) where
succs LastExit = []
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)
-------------------- Observing nodes
--- | Fold from first to last
-fold_fwd_block ::
- (BlockId -> a -> a) -> (m -> a -> a) -> (ZLast l -> a -> a) ->
- Block m l -> a -> a
-
--- | iterate from first to last
-foldM_fwd_block ::
- Monad m => (BlockId -> a -> m a) -> (mid -> a -> m a) -> (ZLast l -> a -> m a) ->
- Block mid l -> a -> m a
-- ================ IMPLEMENTATION ================--
-blockId (Block id _) = id
+----- block manipulations
+
+blockId (Block id _ _) = id
-- | Convert block between forms.
-- These functions are tail-recursive, so we can go as deep as we like
-- without fear of stack overflow.
-ht_to_first head tail = case head of
- ZFirst id -> Block id tail
- ZHead h m -> ht_to_first h (ZTail m tail)
-
-head_id :: ZHead m -> BlockId
-head_id (ZFirst id) = id
-head_id (ZHead h _) = head_id h
-
-zip (ZBlock h t) = ht_to_first h t
+ht_to_block head tail = case head of
+ ZFirst id off -> Block id off 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
-goto_end (ZBlock h t) = ht_to_last h 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 off t) = ZBlock (ZFirst id off) 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)
+tailOfLast l = ZLast (LastOther l) -- tedious to write in every client
-zipht = ht_to_first
-unzip (Block id t) = ZBlock (ZFirst id) t
-last (ZBlock _ t) = lastt t
- where lastt (ZLast l) = l
- lastt (ZTail _ t) = lastt t
+------------------ simple graph manipulations
-focus id (LGraph entry blocks) =
+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)
Nothing -> panic "asked for nonexistent block in flow graph"
-focusp p (LGraph entry blocks) =
- fmap (\(b, bs) -> FGraph entry (unzip b) bs) (splitp_blocks p blocks)
+entry :: LGraph m l -> FGraph m l -- focus on edge out of entry node
+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
lift (Nothing, _) = Nothing
lift (Just b, bs) = Just (b, bs)
-entry g@(LGraph eid _) = focus eid g
-
-exit g@(LGraph eid _) = FGraph eid (ZBlock h (ZLast l)) others
- where FGraph _ b others = focusp is_exit g `orElse` panic "no exit in flow graph"
- (h, l) = goto_end b
-
-is_exit :: Block m l -> Bool
-is_exit b = case last (unzip b) of { LastExit -> True; _ -> False }
-
--- | '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 =
- case lookupBlockEnv bs id of
- Nothing -> extendBlockEnv bs id b
- Just _ -> panic ("duplicate labels " ++ show id ++ " in ZipCfg graph")
+ ASSERT (isNothing $ lookupBlockEnv bs id)
+ extendBlockEnv bs id b
where id = blockId b
-unfocus (FGraph e bz bs) = LGraph e (insertBlock (zip bz) bs)
-
-check_single_exit :: LGraph l m -> a -> a
-check_single_exit g =
- let check block found = case last (unzip block) of
- LastExit -> if found then panic "graph has multiple exits"
- else True
- _ -> found
- in if not (foldUFM check False (gr_blocks g)) then
- panic "graph does not have an exit"
- else
- \a -> a
-
-freshBlockId :: String -> UniqSM BlockId
-freshBlockId _ = do { u <- getUniqueUs; return $ BlockId u }
-
-postorder_dfs g@(LGraph _ blocks) =
- let FGraph _ eblock _ = entry g
- in vnode (zip eblock) (\acc _visited -> acc) [] emptyBlockSet
+-- | 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
+ 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
+ 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
+-- unreachable code and puts blocks in an order that is good for solving forward
+-- dataflow problems quickly. The reverse order is good for solving backward
+-- dataflow problems quickly. The forward order is also reasonably good for
+-- emitting instructions, except that it will not usually exploit Forrest
+-- Baskett's trick of eliminating the unconditional branch from a loop. For
+-- that you would need a more serious analysis, probably based on dominators, to
+-- identify loop headers.
+--
+-- 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).
+--
+-- 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
- vnode block@(Block id _) cont acc visited =
+ -- 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 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
-fold_layout f z g@(LGraph eid _) = fold (postorder_dfs g) z
+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
+-- 'goto b2', the goto can be omitted.
+
+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 _) =
+ nextlabel (Block id _ _) =
if id == eid then panic "entry as successor"
else Just id
-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
+-- | The rest of the traversals are straightforward
-foldM_fwd_block first middle last (Block id t) z = do { z <- first id z; tail t z }
- where tail (ZTail m t) z = do { z <- middle m z; tail t z }
- tail (ZLast l) z = last l z
+map_blocks f (LGraph eid off blocks) = LGraph eid off (mapUFM f blocks)
-fold_blocks f z (LGraph _ blocks) = foldUFM f z blocks
+map_nodes idm middle last (LGraph eid off blocks) =
+ LGraph (idm eid) off (mapUFM (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 off t) = Block (idm id) off (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))
-of_block_list e blocks = LGraph e $ foldr insertBlock emptyBlockEnv blocks
-to_block_list (LGraph _ blocks) = eltsUFM blocks
-{-
-\paragraph{Splicing support}
+mapM_blocks f (LGraph eid off blocks) = blocks' >>= return . LGraph eid off
+ where blocks' =
+ foldUFM (\b mblocks -> do { blocks <- mblocks
+ ; b <- f b
+ ; return $ insertBlock b blocks })
+ (return emptyBlockEnv) blocks
-We want to be able to scrutinize a single-entry, single-exit LGraph for
-splicing purposes.
-There are two useful cases: the LGraph is a single block or it isn't.
-We use continuation-passing style.
--}
+fold_blocks f z (LGraph _ _ blocks) = foldUFM 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 off blocks = LGraph e off $ foldr insertBlock emptyBlockEnv blocks
+to_block_list (LGraph _ _ blocks) = eltsUFM blocks
+
+
+-- We want to be able to scrutinize a single-entry, single-exit 'LGraph' for
+-- splicing purposes. There are two useful cases: the 'LGraph' is a single block
+-- or it isn't. We use continuation-passing style.
prepare_for_splicing ::
LGraph m l -> (ZTail m l -> a) -> (ZTail m l -> ZHead m -> BlockEnv (Block m l) -> a)
case gl of LastExit -> multi etail gh gblocks
_ -> panic "exit is not exit?!"
-splice_head head g =
- check_single_exit g $
- let 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)
- in prepare_for_splicing g splice_one_block splice_many_blocks
+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_head head g@(LGraph _ off _) =
+ 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 off emptyBlockEnv, head)
+ _ -> panic "spliced LGraph without exit"
+ splice_many_blocks entry exit others =
+ (LGraph eid off (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_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 =
- check_single_exit g $
- let splice_one_block tail' = -- return tail' .. tail
- case ht_to_last (ZFirst (gr_entry g)) tail' of
- (head', LastExit) ->
- case ht_to_first head' tail of
- Block id t | id == gr_entry g -> (t, LGraph id emptyBlockEnv)
- _ -> panic "entry in; garbage out"
- _ -> panic "spliced single block without Exit"
- splice_many_blocks entry exit others =
- (entry, LGraph (gr_entry g) (insertBlock (zipht exit tail) others))
- in prepare_for_splicing g splice_one_block splice_many_blocks
-
-splice_focus_entry (FGraph eid (ZBlock head tail) blocks) g =
- let (tail', g') = splice_tail g tail in
- FGraph eid (ZBlock head tail') (plusUFM (gr_blocks g') blocks)
-
-splice_focus_exit (FGraph eid (ZBlock head tail) blocks) g =
- let (g', head') = splice_head head g in
- FGraph eid (ZBlock head' tail) (plusUFM (gr_blocks g') blocks)
+ 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) ->
+ case ht_to_block head' tail of
+ Block id t | id == lg_entry g -> (t, LGraph id emptyBlockEnv)
+ _ -> panic "entry in; garbage out"
+ _ -> 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
in case gentry of
- ZBlock (ZFirst _) tail -> LGraph eid (insertBlock (zipht head tail) gblocks)
+ ZBlock (ZFirst _ _) tail ->
+ LGraph eid 0 (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) 0 (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) =
+translate txm txl (LGraph eid off blocks) =
do blocks' <- foldUFM txblock (return emptyBlockEnv) blocks
- return $ LGraph eid blocks'
+ return $ LGraph eid off blocks'
where
-- txblock ::
- -- Block m l -> UniqSM (BlockEnv (Block m' l')) -> UniqSM (BlockEnv (Block m' l'))
- txblock (Block id t) expanded =
+ -- Block m l -> tm (BlockEnv (Block m' l')) -> tm (BlockEnv (Block m' l'))
+ txblock (Block id boff t) expanded =
do blocks' <- expanded
- txtail (ZFirst id) t blocks'
+ txtail (ZFirst id boff) 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 (gr_blocks g) blocks')
+ txtail h' t (plusUFM (lg_blocks g) blocks')
txtail h (ZLast (LastOther l)) blocks' =
do l' <- txl l
- return $ plusUFM (gr_blocks (splice_head_only h l')) blocks'
+ return $ plusUFM (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
+---- Prettyprinting
+----------------------------------------------------------------
-instance Outputable BlockId where
- ppr = ppr . getUnique
+-- putting this code in PprCmmZ leads to circular imports :-(
+instance (Outputable m, Outputable l) => Outputable (ZTail m l) where
+ ppr = pprTail
-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
+instance (Outputable m, Outputable l, LastNode l) => Outputable (Graph m l) where
+ ppr = pprGraph
-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
+instance (Outputable m, Outputable l, LastNode l) => Outputable (LGraph m l) where
+ ppr = pprLgraph
-----------------------------------------------------------------
--- putting this code in PprCmmZ leads to circular imports :-(
+instance (Outputable m, Outputable l, LastNode l) => Outputable (Block m l) where
+ ppr = pprBlock
-instance (Outputable m, Outputable l) => Outputable (ZTail m l) where
- ppr = pprTail
+instance (Outputable l) => Outputable (ZLast l) where
+ ppr = pprLast
--- | 'pprTail' is used for debugging only
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 args tail) = ppr id <> parens (ppr args) <> colon $$ 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" <> parens (ppr $ lg_argoffset g) $$
+ 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
+
projects / ghc-hetmet.git / blobdiff