projects
/
ghc-hetmet.git
/ blobdiff
commit
grep
author
committer
pickaxe
?
search:
re
summary
|
shortlog
|
log
|
commit
|
commitdiff
|
tree
raw
|
inline
| side by side
Merging in the new codegen branch
[ghc-hetmet.git]
/
compiler
/
cmm
/
ZipCfg.hs
diff --git
a/compiler/cmm/ZipCfg.hs
b/compiler/cmm/ZipCfg.hs
index
c7aa1ff
..
634bc8c
100644
(file)
--- a/
compiler/cmm/ZipCfg.hs
+++ b/
compiler/cmm/ZipCfg.hs
@@
-12,7
+12,7
@@
module ZipCfg
, splice_tail, splice_head, splice_head_only', splice_head'
, of_block_list, to_block_list
, graphOfLGraph
, splice_tail, splice_head, splice_head_only', splice_head'
, of_block_list, to_block_list
, graphOfLGraph
- , map_blocks, map_nodes, mapM_blocks
+ , 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
, postorder_dfs, postorder_dfs_from, postorder_dfs_from_except
, fold_layout
, fold_blocks, fold_fwd_block
@@
-36,8
+36,10
@@
where
#include "HsVersions.h"
#include "HsVersions.h"
-import CmmExpr ( UserOfLocalRegs(..) ) --for an instance
-import StackSlot
+import BlockId ( BlockId, BlockEnv, emptyBlockEnv, lookupBlockEnv, extendBlockEnv
+ , BlockSet, emptyBlockSet, elemBlockSet, extendBlockSet)
+import CmmExpr ( UserOfLocalRegs(..) )
+import PprCmm()
import Outputable hiding (empty)
import Panic
import Outputable hiding (empty)
import Panic
@@
-149,18
+151,22
@@
instance UserOfLocalRegs a => UserOfLocalRegs (ZLast a) where
foldRegsUsed _f z LastExit = z
foldRegsUsed _f z LastExit = z
-data ZHead m = ZFirst BlockId | ZHead (ZHead m) m
+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; see Note [Kinds of graphs]
-- 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)
+-- 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 { g_entry :: (ZTail m l), g_blocks :: (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) }
+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.
-- Invariant: lg_entry is in domain( lg_blocks )
-- | And now the zipper. The focus is between the head and tail.
@@
-219,13
+225,13
@@
ht_to_last :: ZHead m -> ZTail m l -> (ZHead m, ZLast l)
-- , (???, [<blocks>,
-- N: y:=x; return (y,x)])
-- , (???, [<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_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
-- | A safe operation
@@
-234,12
+240,12
@@
splice_head_only' :: ZHead m -> Graph m l -> LGraph m l
-- 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.
-- 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 -> [Block m l] -> LGraph m l -- N log N
+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
-- | Conversion from LGraph to Graph
graphOfLGraph :: LastNode l => LGraph m l -> Graph m l
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
+graphOfLGraph (LGraph eid _ blocks) = Graph (ZLast $ mkBranchNode eid) blocks
-- | Traversal: 'postorder_dfs' returns a list of blocks reachable
-- | Traversal: 'postorder_dfs' returns a list of blocks reachable
@@
-281,6
+287,8
@@
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
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_nodes :: (BlockId -> BlockId) -> (m -> m') -> (l -> l') -> LGraph m l -> LGraph m' l'
-- mapping includes the entry id!
@@
-349,14
+357,14
@@
instance LastNode l => HavingSuccessors (ZTail m l) where
----- block manipulations
----- block manipulations
-blockId (Block id _) = id
+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_block head tail = case head of
-- | 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_block head tail = case head of
- ZFirst id -> Block id tail
+ 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)
ZHead h m -> ht_to_block h (ZTail m tail)
ht_to_last head (ZLast l) = (head, l)
@@
-366,11
+374,11
@@
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
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
+unzip (Block id off t) = ZBlock (ZFirst id off) t
head_id :: ZHead m -> BlockId
head_id :: ZHead m -> BlockId
-head_id (ZFirst id) = id
-head_id (ZHead h _) = head_id h
+head_id (ZFirst id _) = id
+head_id (ZHead h _) = head_id h
last (ZBlock _ t) = lastTail t
last (ZBlock _ t) = lastTail t
@@
-378,19
+386,19
@@
lastTail :: ZTail m l -> ZLast l
lastTail (ZLast l) = l
lastTail (ZTail _ 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
------------------ simple graph manipulations
focus :: BlockId -> LGraph m l -> FGraph m l -- focus on edge out of node with id
-focus id (LGraph entry blocks) =
+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"
entry :: LGraph m l -> FGraph m l -- focus on edge out of entry node
case lookupBlockEnv blocks id of
Just b -> FGraph entry (unzip b) (delFromUFM 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
-entry g@(LGraph eid _) = focus eid g
+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) ->
-- | pull out a block satisfying the predicate, if any
splitp_blocks :: (Block m l -> Bool) -> BlockEnv (Block m l) ->
@@
-404,7
+412,7
@@
splitp_blocks p blocks = lift $ foldUFM scan (Nothing, emptyBlockEnv) blocks
lift (Nothing, _) = Nothing
lift (Just b, bs) = Just (b, bs)
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 =
-- but only to insert a new one
insertBlock :: Block m l -> BlockEnv (Block m l) -> BlockEnv (Block m l)
insertBlock b bs =
@@
-442,14
+450,16
@@
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
-- 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
-- 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]
-- 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) =
+postorder_dfs g@(LGraph _ _ blockenv) =
let FGraph id eblock _ = entry g in
zip eblock : postorder_dfs_from_except blockenv eblock (unitUniqSet id)
let FGraph id eblock _ = entry g in
zip eblock : postorder_dfs_from_except blockenv eblock (unitUniqSet id)
@@
-460,7
+470,7
@@
postorder_dfs_from_except blocks b visited =
where
-- vnode ::
-- Block m l -> ([Block m l] -> BlockSet -> a) -> [Block m l] -> BlockSet -> a
where
-- vnode ::
-- Block m l -> ([Block m l] -> BlockSet -> a) -> [Block m l] -> BlockSet -> a
- vnode block@(Block id _) cont acc visited =
+ vnode block@(Block id _ _) cont acc visited =
if elemBlockSet id visited then
cont acc visited
else
if elemBlockSet id visited then
cont acc visited
else
@@
-486,42
+496,42
@@
postorder_dfs_from blocks b = postorder_dfs_from_except blocks b emptyBlockSet
-- 'b1' what its inline successor is going to be, so that if 'b1' ends with
-- 'goto b2', the goto can be omitted.
-- '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
+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)
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
-- | The rest of the traversals are straightforward
if id == eid then panic "entry as successor"
else Just id
-- | The rest of the traversals are straightforward
-map_blocks f (LGraph eid blocks) = LGraph eid (mapUFM f blocks)
+map_blocks f (LGraph eid off blocks) = LGraph eid off (mapUFM f 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))
tail (ZLast LastExit) = ZLast LastExit
tail (ZLast (LastOther l)) = ZLast (LastOther (last l))
-mapM_blocks f (LGraph eid blocks) = blocks' >>= return . LGraph eid
+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
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
-fold_fwd_block first middle last (Block id t) z = tail t (first id z)
+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
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) = eltsUFM blocks
-
-
+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
-- We want to be able to scrutinize a single-entry, single-exit 'LGraph' for
@@
-565,15
+575,15
@@
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 }
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 _ 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
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)
+ (head, LastExit) -> (LGraph eid off emptyBlockEnv, head)
_ -> panic "spliced LGraph without exit"
splice_many_blocks entry exit others =
_ -> panic "spliced LGraph without exit"
splice_many_blocks entry exit others =
- (LGraph eid (insertBlock (zipht head entry) others), exit)
+ (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
splice_head' head g =
ASSERT (single_exitg g) prepare_for_splicing' g splice_one_block splice_many_blocks
@@
-611,25
+621,27
@@
splice_tail g tail =
splice_head_only head g =
let FGraph eid gentry gblocks = entry g
in case gentry of
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?!"
splice_head_only' head (Graph tail gblocks) =
let eblock = zipht head tail in
_ -> 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)
+ LGraph (blockId eblock) 0 (insertBlock eblock gblocks)
+ -- the offset probably should never be used, but well, it's correct for this LGraph
--- Translation
--- Translation
-translate txm txl (LGraph eid blocks) =
+translate txm txl (LGraph eid off blocks) =
do blocks' <- foldUFM txblock (return emptyBlockEnv) blocks
do blocks' <- foldUFM txblock (return emptyBlockEnv) blocks
- return $ LGraph eid blocks'
+ return $ LGraph eid off blocks'
where
-- txblock ::
-- Block m l -> tm (BlockEnv (Block m' l')) -> tm (BlockEnv (Block m' l'))
where
-- txblock ::
-- Block m l -> tm (BlockEnv (Block m' l')) -> tm (BlockEnv (Block m' l'))
- txblock (Block id t) expanded =
+ txblock (Block id boff t) expanded =
do blocks' <- 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') ->
-- tm (BlockEnv (Block m' l'))
txtail h (ZTail m t) blocks' =
-- txtail :: ZHead m' -> ZTail m l -> BlockEnv (Block m' l') ->
-- tm (BlockEnv (Block m' l'))
txtail h (ZTail m t) blocks' =
@@
-672,10
+684,11
@@
pprLast LastExit = text "<exit>"
pprLast (LastOther l) = ppr l
pprBlock :: (Outputable m, Outputable l, LastNode l) => Block m l -> SDoc
pprLast (LastOther l) = ppr l
pprBlock :: (Outputable m, Outputable l, LastNode l) => Block m l -> SDoc
-pprBlock (Block id tail) = ppr id <> colon $$ ppr tail
+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 :: (Outputable m, Outputable l, LastNode l) => LGraph m l -> SDoc
-pprLgraph g = text "{" $$ nest 2 (vcat $ map ppr blocks) $$ text "}"
+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
where blocks = postorder_dfs g
pprGraph :: (Outputable m, Outputable l, LastNode l) => Graph m l -> SDoc