#include "HsVersions.h"
import Cmm
+import CmmUtils
import CLabel
import MachOp (MachHint(..))
+import CgUtils (callerSaveVolatileRegs)
import ClosureInfo
import Maybes
}
-- | How a block could be entered
+-- See Note [An example of CPS conversion]
data BlockEntryInfo
= FunctionEntry -- ^ Block is the beginning of a function
CmmInfo -- ^ Function header info
CLabel -- ^ The function name
CmmFormals -- ^ Aguments to function
+ -- Only the formal parameters are live
| ContinuationEntry -- ^ Return point of a function call
CmmFormals -- ^ return values (argument to continuation)
C_SRT -- ^ SRT for the continuation's info table
Bool -- ^ True <=> GC block so ignore stack size
+ -- Live variables, other than
+ -- the return values, are on the stack
| ControlEntry -- ^ Any other kind of block.
-- Only entered due to control flow.
-- no return values, but some live might end up as
-- params or possibly in the frame
+{- Note [An example of CPS conversion]
+
+This is NR's and SLPJ's guess about how things might work;
+it may not be consistent with the actual code (particularly
+in the matter of what's in parameters and what's on the stack).
+
+f(x,y) {
+ if x>2 then goto L
+ x = x+1
+L: if x>1 then y = g(y)
+ else x = x+1 ;
+ return( x+y )
+}
+ BECOMES
+
+f(x,y) { // FunctionEntry
+ if x>2 then goto L
+ x = x+1
+L: // ControlEntry
+ if x>1 then push x; push f1; jump g(y)
+ else x=x+1; jump f2(x, y)
+}
+
+f1(y) { // ContinuationEntry
+ pop x; jump f2(x, y);
+}
+
+f2(x, y) { // ProcPointEntry
+ return (z+y);
+}
+
+-}
+
data ContFormat = ContFormat
CmmHintFormals -- ^ return values (argument to continuation)
C_SRT -- ^ SRT for the continuation's info table
CmmExpr -- ^ The function to call
CmmActuals -- ^ Arguments of the call
- | FinalCall -- ^ Same as 'CmmForeignCall'
+ | FinalCall -- ^ Same as 'CmmCallee'
-- followed by 'CmmGoto'
BlockId -- ^ Target of the 'CmmGoto'
-- (must be a 'ContinuationEntry')
target results arguments srt
-- Break the block on safe calls (the main job of this function)
- (CmmCall target results arguments (CmmSafe srt):stmts) ->
+ (CmmCall target results arguments (CmmSafe srt) : stmts) ->
(cont_info : cont_infos, block : blocks)
where
next_id = BlockId $ head uniques
block = do_call current_id entry accum_stmts exits next_id
target results arguments srt
- cont_info = (next_id,
+
+ cont_info = (next_id, -- Entry convention for the
+ -- continuation of the call
ContFormat results srt
(ident `elem` gc_block_idents))
+
+ -- Break up the part after the call
(cont_infos, blocks) = breakBlock' (tail uniques) next_id
ControlEntry [] [] stmts
+ -- Unsafe calls don't need a continuation
+ -- but they do need to be expanded
+ (CmmCall target results arguments CmmUnsafe : stmts) ->
+ breakBlock' remaining_uniques current_id entry exits
+ (accum_stmts ++
+ arg_stmts ++
+ caller_save ++
+ [CmmCall target results new_args CmmUnsafe] ++
+ caller_load)
+ stmts
+ where
+ (remaining_uniques, arg_stmts, new_args) =
+ loadArgsIntoTemps uniques arguments
+ (caller_save, caller_load) = callerSaveVolatileRegs (Just [])
+
-- Default case. Just keep accumulating statements
-- and branch targets.
- (s:stmts) ->
+ (s : stmts) ->
breakBlock' uniques current_id entry
(cond_branch_target s++exits)
(accum_stmts++[s])