Skip to content
GitLab
Menu
Projects
Groups
Snippets
Help
Help
Support
Community forum
Keyboard shortcuts
?
Submit feedback
Sign in / Register
Toggle navigation
Menu
Open sidebar
Alex D
GHC
Commits
8bae799d
Commit
8bae799d
authored
May 24, 2007
by
Michael D. Adams
Browse files
Renamed CmmCPSData to CmmBrokenBlock and documented it
parent
308af7d2
Changes
4
Hide whitespace changes
Inline
Side-by-side
compiler/cmm/CmmBrokenBlock.hs
0 → 100644
View file @
8bae799d
module
CmmBrokenBlock
(
BrokenBlock
(
..
),
BlockEntryInfo
(
..
),
FinalStmt
(
..
),
breakBlock
,
cmmBlockFromBrokenBlock
,
blocksToBlockEnv
,
)
where
#
include
"HsVersions.h"
import
Cmm
import
CLabel
import
Maybes
import
Panic
import
Unique
import
UniqFM
-----------------------------------------------------------------------------
-- Data structures
-----------------------------------------------------------------------------
-- |Similar to a 'CmmBlock' with a little extra information
-- to help the CPS analysis.
data
BrokenBlock
=
BrokenBlock
{
brokenBlockId
::
BlockId
,
-- ^ The block's label like a 'CmmBasicBlock'
brokenBlockEntry
::
BlockEntryInfo
,
-- ^ Ways this block can be entered
brokenBlockStmts
::
[
CmmStmt
],
-- ^ Body like a CmmBasicBlock
-- (but without the last statement)
brokenBlockTargets
::
[
BlockId
],
-- ^ Blocks that this block could
-- branch to one either by conditional
-- branches or via the last statement
brokenBlockExit
::
FinalStmt
-- ^ The final statement of the block
}
-- | How a block could be entered
data
BlockEntryInfo
=
FunctionEntry
-- ^ Block is the beginning of a function
CLabel
-- ^ The function name
CmmFormals
-- ^ Aguments to function
|
ContinuationEntry
-- ^ Return point of a function call
CmmFormals
-- ^ return values (argument to continuation)
|
ControlEntry
-- ^ Any other kind of block.
-- Only entered due to control flow.
-- TODO: Consider adding ProcPointEntry
-- no return values, but some live might end up as
-- params or possibly in the frame
-- | Final statement in a 'BlokenBlock'.
-- Constructors and arguments match those in 'Cmm',
-- but are restricted to branches, returns, jumps, calls and switches
data
FinalStmt
=
FinalBranch
-- ^ Same as 'CmmBranch'
BlockId
-- ^ Target must be a ControlEntry
|
FinalReturn
-- ^ Same as 'CmmReturn'
CmmActuals
-- ^ Return values
|
FinalJump
-- ^ Same as 'CmmJump'
CmmExpr
-- ^ The function to call
CmmActuals
-- ^ Arguments of the call
|
FinalCall
-- ^ Same as 'CmmForeignCall'
-- followed by 'CmmGoto'
BlockId
-- ^ Target of the 'CmmGoto'
-- (must be a 'ContinuationEntry')
CmmCallTarget
-- ^ The function to call
CmmFormals
-- ^ Results from call
-- (redundant with ContinuationEntry)
CmmActuals
-- ^ Arguments to call
(
Maybe
[
GlobalReg
])
-- ^ registers that must be saved (TODO)
|
FinalSwitch
-- ^ Same as a 'CmmSwitch'
CmmExpr
-- ^ Scrutinee (zero based)
[
Maybe
BlockId
]
-- ^ Targets
-----------------------------------------------------------------------------
-- Operations for broken blocks
-----------------------------------------------------------------------------
-----------------------------------------------------------------------------
-- | Takes a 'CmmBasicBlock' and breaks it up into a list of 'BrokenBlock'
-- by splitting on each 'CmmCall' in the 'CmmBasicBlock'.
breakBlock
::
[
Unique
]
-- ^ An infinite list of uniques
-- to create names of the new blocks with
->
CmmBasicBlock
-- ^ Input block to break apart
->
BlockEntryInfo
-- ^ Info for the first created 'BrokenBlock'
->
[
BrokenBlock
]
breakBlock
uniques
(
BasicBlock
ident
stmts
)
entry
=
breakBlock'
uniques
ident
entry
[]
[]
stmts
where
breakBlock'
uniques
current_id
entry
exits
accum_stmts
stmts
=
case
stmts
of
[]
->
panic
"block doesn't end in jump, goto, return or switch"
[
CmmJump
target
arguments
]
->
[
BrokenBlock
current_id
entry
accum_stmts
exits
(
FinalJump
target
arguments
)]
[
CmmReturn
arguments
]
->
[
BrokenBlock
current_id
entry
accum_stmts
exits
(
FinalReturn
arguments
)]
[
CmmBranch
target
]
->
[
BrokenBlock
current_id
entry
accum_stmts
(
target
:
exits
)
(
FinalBranch
target
)]
[
CmmSwitch
expr
targets
]
->
[
BrokenBlock
current_id
entry
accum_stmts
(
mapMaybe
id
targets
++
exits
)
(
FinalSwitch
expr
targets
)]
(
CmmJump
_
_
:
_
)
->
panic
"jump in middle of block"
(
CmmReturn
_
:
_
)
->
panic
"return in middle of block"
(
CmmBranch
_
:
_
)
->
panic
"branch in middle of block"
(
CmmSwitch
_
_
:
_
)
->
panic
"switch in middle of block"
-- Detect this special case to remain an inverse of
-- 'cmmBlockFromBrokenBlock'
[
CmmCall
target
results
arguments
saves
,
CmmBranch
next_id
]
->
[
block
]
where
block
=
do_call
current_id
entry
accum_stmts
exits
next_id
target
results
arguments
saves
(
CmmCall
target
results
arguments
saves
:
stmts
)
->
block
:
rest
where
next_id
=
BlockId
$
head
uniques
block
=
do_call
current_id
entry
accum_stmts
exits
next_id
target
results
arguments
saves
rest
=
breakBlock'
(
tail
uniques
)
next_id
(
ContinuationEntry
results
)
[]
[]
stmts
(
s
:
stmts
)
->
breakBlock'
uniques
current_id
entry
(
cond_branch_target
s
++
exits
)
(
accum_stmts
++
[
s
])
stmts
do_call
current_id
entry
accum_stmts
exits
next_id
target
results
arguments
saves
=
BrokenBlock
current_id
entry
accum_stmts
(
next_id
:
exits
)
(
FinalCall
next_id
target
results
arguments
saves
)
cond_branch_target
(
CmmCondBranch
_
target
)
=
[
target
]
cond_branch_target
_
=
[]
-----------------------------------------------------------------------------
-- | Convert from a BrokenBlock back to an equivalent CmmBasicBlock
-- Needed by liveness analysis
cmmBlockFromBrokenBlock
::
BrokenBlock
->
CmmBasicBlock
cmmBlockFromBrokenBlock
(
BrokenBlock
ident
_
stmts
_
exit
)
=
BasicBlock
ident
(
stmts
++
exit_stmt
)
where
exit_stmt
=
case
exit
of
FinalBranch
target
->
[
CmmBranch
target
]
FinalReturn
arguments
->
[
CmmReturn
arguments
]
FinalJump
target
arguments
->
[
CmmJump
target
arguments
]
FinalSwitch
expr
targets
->
[
CmmSwitch
expr
targets
]
FinalCall
branch_target
call_target
results
arguments
saves
->
[
CmmCall
call_target
results
arguments
saves
,
CmmBranch
branch_target
]
-----------------------------------------------------------------------------
-- | Build a mapping so we can lookup a 'BrokenBlock' by its 'BlockId'
blocksToBlockEnv
::
[
BrokenBlock
]
->
BlockEnv
BrokenBlock
blocksToBlockEnv
blocks
=
listToUFM
$
map
(
\
b
->
(
brokenBlockId
b
,
b
))
blocks
compiler/cmm/CmmCPS.hs
View file @
8bae799d
module
CmmCPS
(
cmmCPS
)
where
module
CmmCPS
(
-- | Converts C-- with full proceedures and parameters
-- to a CPS transformed C-- with the stack made manifest.
cmmCPS
)
where
#
include
"HsVersions.h"
...
...
@@ -8,7 +12,7 @@ import PprCmm
import
Dataflow
(
fixedpoint
)
import
CmmLive
import
Cmm
CPSData
import
Cmm
BrokenBlock
import
CmmProcPoint
import
MachOp
...
...
compiler/cmm/CmmCPSData.hs
deleted
100644 → 0
View file @
308af7d2
module
CmmCPSData
(
blocksToBlockEnv
,
BrokenBlock
(
..
),
BlockEntryInfo
(
..
),
FinalStmt
(
..
)
)
where
#
include
"HsVersions.h"
import
Cmm
import
CLabel
import
UniqFM
-- A minor helper (TODO document)
blocksToBlockEnv
::
[
BrokenBlock
]
->
BlockEnv
BrokenBlock
blocksToBlockEnv
blocks
=
listToUFM
$
map
(
\
b
->
(
brokenBlockId
b
,
b
))
blocks
data
BrokenBlock
=
BrokenBlock
{
brokenBlockId
::
BlockId
,
-- Like a CmmBasicBlock
brokenBlockEntry
::
BlockEntryInfo
,
-- How this block can be entered
brokenBlockStmts
::
[
CmmStmt
],
-- Like a CmmBasicBlock
-- (but without the last statement)
brokenBlockTargets
::
[
BlockId
],
-- Blocks that this block could
-- branch to one either by conditional
-- branches or via the last statement
brokenBlockExit
::
FinalStmt
-- How the block can be left
}
data
BlockEntryInfo
=
FunctionEntry
-- Beginning of a function
CLabel
-- The function name
CmmFormals
-- Aguments to function
|
ContinuationEntry
-- Return point of a call
CmmFormals
-- return values (argument to continuation)
-- TODO:
-- | ProcPointEntry -- no return values, but some live might end up as params or possibly in the frame
|
ControlEntry
-- A label in the input
-- Final statement in a BlokenBlock
-- Constructors and arguments match those in Cmm,
-- but are restricted to branches, returns, jumps, calls and switches
data
FinalStmt
=
FinalBranch
BlockId
-- next block (must be a ControlEntry)
|
FinalReturn
CmmActuals
-- return values
|
FinalJump
CmmExpr
-- the function to call
CmmActuals
-- arguments to call
|
FinalCall
BlockId
-- next block after call (must be a ContinuationEntry)
CmmCallTarget
-- the function to call
CmmFormals
-- results from call (redundant with ContinuationEntry)
CmmActuals
-- arguments to call
(
Maybe
[
GlobalReg
])
-- registers that must be saved (TODO)
|
FinalSwitch
CmmExpr
[
Maybe
BlockId
]
-- Table branch
-- TODO: | ProcPointExit (needed?)
compiler/cmm/CmmProcPoint.hs
View file @
8bae799d
...
...
@@ -5,7 +5,7 @@ module CmmProcPoint (
#
include
"HsVersions.h"
import
Cmm
import
Cmm
CPSData
import
Cmm
BrokenBlock
import
Dataflow
import
UniqSet
...
...
Write
Preview
Supports
Markdown
0%
Try again
or
attach a new file
.
Attach a file
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment