import CmmLint
import PprCmm
-import Dataflow (cmmLivenessComment, cmmLiveness, CmmLive)
+import Dataflow (fixedpoint)
+import CmmLive
import MachOp
import ForeignCall
import CLabel
+import SMRep
+import Constants
import DynFlags
import ErrUtils
import Monad
import IO
-
---------------------------------------------------------------------------------
--- Monad for the CPSer
--- Contains:
--- * State for the uniqSupply
-
-data CPSState = CPSState { cps_uniqs :: UniqSupply }
-
-data CPS a = CPS { runCPS :: CPSState -> (CPSState, a) }
-
-instance Monad CPS where
- return a = CPS $ \s -> (s, a)
- (CPS m) >>= f = CPS $ \s ->
- let (s', m') = m s
- in runCPS (f m') s'
-
---------------------------------------------------------------------------------
--- Utility functions
-
-getState = CPS $ \s -> (s, s)
-putState s = CPS $ \_ -> (s, ())
-
-newLabelCPS = do
- state <- getState
- let (us1, us2) = splitUniqSupply (cps_uniqs state)
- putState $ state { cps_uniqs = us1 }
- return $ BlockId (uniqFromSupply us2)
-
-mapMCmmTop :: (Monad m) => (CmmTop -> m [CmmTop]) -> Cmm -> m Cmm
-mapMCmmTop f (Cmm xs) = liftM Cmm $ liftM concat $ mapM f xs
+import Data.List
--------------------------------------------------------------------------------
-- and heap memory (not sure if that's usefull at all though, but it may
-- be worth exploring the design space).
-data CPSBlockInfo
- = ControlBlock -- Consider whether a proc-point might want arguments on stack
- | ContinuationBlock [(CmmReg,MachHint)] {- params -}
+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 :: BlockExitInfo
+ -- How the block can be left
+ }
+
+
+data BlockEntryInfo
+ = FunctionEntry -- Beginning of function
-type ContinuationFormat = [Maybe LocalReg] -- TODO: consider params as part of format
+ | ContinuationEntry -- Return point of a call
+ CmmFormals -- return values
+ -- TODO:
+ -- | ProcPointEntry -- no return values, but some live might end up as params or possibly in the frame
+
+ | ControlEntry -- A label in the input
+
+data BlockExitInfo
+ = ControlExit
+ BlockId -- next block (must be a ControlEntry)
+
+ | ReturnExit
+ CmmActuals -- return values
+
+ | TailCallExit
+ CmmExpr -- the function to call
+ CmmActuals -- arguments to call
+
+ | CallExit
+ 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)
+ -- TODO: | ProcPointExit (needed?)
+
+data StackFormat
+ = StackFormat
+ BlockId {- block that is the start of the continuation. may or may not be the current block -}
+ WordOff {- total frame size -}
+ [(CmmReg, WordOff)] {- local reg offsets from stack top -}
-- A block can be a continuation of a call
-- A block can be a continuation of another block (w/ or w/o joins)
-- A block can be an entry to a function
-type CmmParam = [(CmmReg,MachHint)]
-
+--------------------------------------------------------------------------------
-- For now just select the continuation orders in the order they are in the set with no gaps
-selectContinuationFormat :: UniqFM {-BlockId-} CmmParam -> UniqFM {-BlockId-} CmmLive -> UniqFM {-BlockId-} ContinuationFormat
-selectContinuationFormat param live = mapUFM (map Just . uniqSetToList) live
-
-transformReturn block_infos formats (BasicBlock ident stmts) =
- case last $ init stmts of
- CmmReturn arguments ->
- BasicBlock ident $ (init $ init stmts) ++
- [CmmJump (CmmReg spReg) arguments]
- -- TODO: tail calls
- -- TODO: return direct at the end of a block
- _ -> BasicBlock ident stmts
-
-destructContinuation :: UniqFM {-BlockId-} CPSBlockInfo -> UniqFM {-BlockId-} ContinuationFormat -> CmmBasicBlock -> CmmBasicBlock
-destructContinuation block_infos formats (BasicBlock ident stmts) =
- case info of
- ControlBlock -> BasicBlock ident stmts
- ContinuationBlock _ -> BasicBlock ident (unpack_continuation ++ stmts)
- where
- info = lookupWithDefaultUFM block_infos (panic $ "info: unknown block " ++ (showSDoc $ ppr $ getUnique ident)) ident
- format = lookupWithDefaultUFM formats (panic $ "format: unknown block " ++ (showSDoc $ ppr $ getUnique ident)) ident
- unpack_continuation = CmmAssign spReg (CmmRegOff spReg frame_size) :
- [CmmAssign (CmmLocal reg) (CmmLoad (CmmRegOff spReg (i*stack_slot_size)) (localRegRep reg))
- | (i, Just reg) <- zip [1..] format]
- frame_size = stack_header_size + stack_slot_size * (length format)
- stack_header_size = stack_slot_size -- TODO: check if this could be different than stack_slot_size
- stack_slot_size = 4 -- TODO: find actual variables to be used instead of this
-
-constructContinuation :: UniqFM {-BlockId-} CPSBlockInfo -> UniqFM {-BlockId-} ContinuationFormat -> CmmBasicBlock -> CmmBasicBlock
-constructContinuation block_infos formats (BasicBlock ident stmts) =
- case last $ init stmts of
- -- TODO: global_saves
- --CmmCall (CmmForeignCall target CmmCallConv) results arguments (Just []) -> --TODO: handle globals
- CmmCall (CmmForeignCall target CmmCallConv) results arguments _ ->
- BasicBlock ident $
- init (init stmts) ++
- pack_continuation ++
- [CmmJump target arguments]
- CmmCall target results arguments _ -> panic "unimplemented CmmCall"
- _ -> BasicBlock ident $ (init stmts) ++ build_block_branch
- where
- info = lookupWithDefaultUFM block_infos (panic $ "info: unknown block " ++ (showSDoc $ ppr $ getUnique next_block)) next_block
- format = lookupWithDefaultUFM formats (panic $ "format: unknown block " ++ (showSDoc $ ppr $ getUnique next_block)) next_block
- next_block = case last stmts of
- CmmBranch next -> next
- -- TODO: blocks with jump at end
- -- TODO: blocks with return at end
- _ -> panic "basic block without a branch at the end (unimplemented)"
- next_block_as_proc_expr = CmmLit $ CmmLabel $ mkReturnPtLabel $ getUnique next_block
- pack_continuation = CmmAssign spReg (CmmRegOff spReg (-frame_size)) :
- CmmStore (CmmReg spReg) next_block_as_proc_expr :
- [CmmStore (CmmRegOff spReg (i*stack_slot_size)) (CmmReg $ CmmLocal reg)
- | (i, Just reg) <- zip [1..] format]
- frame_size = stack_header_size + stack_slot_size * (length format)
- stack_header_size = stack_slot_size -- TODO: check if this could be different than stack_slot_size (e.g. fixedHdrSize depends on PAR and GRAN)
- stack_slot_size = 4 -- TODO: find actual variables to be used instead of this (e.g. cgRepSizeW)
- block_needs_call = True -- TODO: use a table (i.e. proc-point)
- build_block_branch =
- if block_needs_call
- then [CmmJump next_block_as_proc_expr [] {- TODO: pass live -}] {- NOTE: a block can never be both a continuation and a controll block -}
- else [CmmBranch next_block]
-
--- TODO: TBD when to adjust the stack
-
-cpsProc :: CmmTop -> CPS [CmmTop]
-cpsProc x@(CmmData _ _) = return [x]
-cpsProc x@(CmmProc info_table ident params blocks) = do
- broken_blocks <- liftM concat $ mapM breakBlock blocks
- let live = cmmLiveness (map snd broken_blocks)
- let blocks_with_live = map (cmmLivenessComment live . snd) broken_blocks
- let formats = selectContinuationFormat (undefined {-TODO-}) live
- let block_infos = listToUFM $ map (\(info, block) -> (blockId block, info)) broken_blocks
- let blocks_with_live' = map (constructContinuation block_infos formats) blocks_with_live
- let blocks_with_live'' = map (destructContinuation block_infos formats) blocks_with_live'
- let blocks_with_live''' = map (transformReturn block_infos formats) blocks_with_live''
-
- return $ [CmmProc info_table ident params blocks_with_live''']
+
+selectStackFormat2 :: BlockEnv CmmLive -> [BrokenBlock] -> BlockEnv StackFormat
+selectStackFormat2 live blocks = fixedpoint dependants update (map brokenBlockId blocks) emptyUFM where
+ blocks_ufm = listToUFM $ map (\b -> (brokenBlockId b, b)) blocks
+ dependants ident =
+ brokenBlockTargets $ lookupWithDefaultUFM blocks_ufm (panic "TODO") ident
+ update ident cause formats =
+ let BrokenBlock _ entry _ _ _ = lookupWithDefaultUFM blocks_ufm (panic "unknown BlockId in selectStackFormat:live") ident in
+ case cause of
+ -- Propagate only to blocks entered by branches (not function entry blocks or continuation entry blocks)
+ Just cause_name ->
+ let cause_format = lookupWithDefaultUFM formats (panic "update signaled for block not in format") cause_name
+ in case entry of
+ ControlEntry -> Just $ addToUFM formats ident cause_format
+ FunctionEntry -> Nothing
+ ContinuationEntry _ -> Nothing
+ -- Do initial calculates for function blocks
+ Nothing ->
+ case entry of
+ ControlEntry -> Nothing
+ FunctionEntry -> Just $ addToUFM formats ident $ StackFormat ident 0 []
+ ContinuationEntry _ -> Just $ addToUFM formats ident $ live_to_format ident $ lookupWithDefaultUFM live (panic "TODO") ident
+ live_to_format label live =
+ foldl extend_format
+ (StackFormat label retAddrSizeW [])
+ (uniqSetToList live)
+ extend_format :: StackFormat -> LocalReg -> StackFormat
+ extend_format (StackFormat block size offsets) reg =
+ StackFormat block (slot_size reg + size) ((CmmLocal reg, size) : offsets)
+
+slot_size reg = ((machRepByteWidth (localRegRep reg) - 1) `div` wORD_SIZE) + 1
+
+constructContinuation2 :: BlockEnv StackFormat -> BrokenBlock -> CmmBasicBlock
+constructContinuation2 formats (BrokenBlock ident entry stmts _ exit) =
+ BasicBlock ident (prefix++stmts++postfix)
+ where
+ curr_format = lookupWithDefaultUFM formats (panic $ "format: unknown block " ++ (showSDoc $ ppr $ getUnique ident)) ident
+ prefix = case entry of
+ ControlEntry -> []
+ FunctionEntry -> []
+ ContinuationEntry formals -> unpack_continuation curr_format
+ postfix = case exit of
+ ControlExit next -> [CmmBranch next]
+ ReturnExit arguments -> exit_function curr_format (CmmLoad (CmmReg spReg) wordRep) arguments
+ TailCallExit target arguments -> exit_function curr_format target arguments
+ -- TODO: do something about global saves
+ CallExit next (CmmForeignCall target CmmCallConv) results arguments saves ->
+ let cont_format = lookupWithDefaultUFM formats (panic $ "format: unknown block " ++ (showSDoc $ ppr $ getUnique next)) next
+ in pack_continuation curr_format cont_format ++
+ [CmmJump target arguments]
+ CallExit next _ results arguments saves -> panic "unimplemented CmmCall"
--------------------------------------------------------------------------------
+-- Functions that generate CmmStmt sequences
+-- for packing/unpacking continuations
+-- and entering/exiting functions
+
+exit_function :: StackFormat -> CmmExpr -> CmmActuals -> [CmmStmt]
+exit_function (StackFormat curr_id curr_frame_size curr_offsets) target arguments
+ = adjust_spReg ++ jump where
+ adjust_spReg = [
+ CmmAssign spReg
+ (CmmRegOff spReg (curr_frame_size*wORD_SIZE))]
+ jump = [CmmJump target arguments]
+
+enter_function :: WordOff -> [CmmStmt]
+enter_function max_frame_size
+ = check_stack_limit where
+ check_stack_limit = [
+ CmmCondBranch
+ (CmmMachOp (MO_U_Lt $ cmmRegRep spReg)
+ [CmmRegOff spReg max_frame_size, CmmReg spLimReg])
+ gc_block]
+ gc_block = undefined -- TODO: get stack and heap checks to go to same
+
+-- TODO: fix branches to proc point (we have to insert a new block to marshel the continuation)
+pack_continuation :: StackFormat -> StackFormat -> [CmmStmt]
+pack_continuation (StackFormat curr_id curr_frame_size curr_offsets)
+ (StackFormat cont_id cont_frame_size cont_offsets)
+ = save_live_values ++ set_stack_header ++ adjust_spReg where
+ -- TODO: only save variables when actually needed
+ save_live_values =
+ [CmmStore
+ (CmmRegOff
+ spReg (wORD_SIZE*(curr_frame_size - cont_frame_size + offset)))
+ (CmmReg reg)
+ | (reg, offset) <- cont_offsets]
+ set_stack_header = -- TODO: only set when needed
+ [CmmStore (CmmRegOff spReg (wORD_SIZE*(curr_frame_size - cont_frame_size))) continuation_function]
+ continuation_function = CmmLit $ CmmLabel $ mkReturnPtLabel $ getUnique cont_id
+ adjust_spReg =
+ if curr_frame_size == cont_frame_size
+ then []
+ else [CmmAssign spReg (CmmRegOff spReg ((curr_frame_size - cont_frame_size)*wORD_SIZE))]
+
+-- Lazy adjustment of stack headers assumes all blocks
+-- that could branch to eachother (i.e. control blocks)
+-- have the same stack format (this causes a problem
+-- only for proc-point).
+unpack_continuation :: StackFormat -> [CmmStmt]
+unpack_continuation (StackFormat curr_id curr_frame_size curr_offsets)
+ = load_live_values where
+ -- TODO: only save variables when actually needed
+ load_live_values =
+ [CmmAssign
+ reg
+ (CmmLoad (CmmRegOff spReg (wORD_SIZE*offset)) (cmmRegRep reg))
+ | (reg, offset) <- curr_offsets]
+
+-----------------------------------------------------------------------------
+-- Breaking basic blocks on function calls
+-----------------------------------------------------------------------------
+
+-----------------------------------------------------------------------------
-- Takes a basic block and returns a list of basic blocks that
-- each have at most 1 CmmCall in them which must occur at the end.
-- Also returns with each basic block, the variables that will
--- be arguments to the continuation of the block once the call (if any) returns.
-
-cmmBlockifyCalls :: [CmmBasicBlock] -> CPS [(CPSBlockInfo, CmmBasicBlock)]
-cmmBlockifyCalls blocks = liftM concat $ mapM breakBlock blocks
-
--- [(CmmReg,MachHint)] is the results from the previous block that are expected as parameters
---breakBlock :: CmmBasicBlock -> CPS [(Maybe BlockId, CmmBasicBlock)]
-breakBlock :: CmmBasicBlock -> CPS [(CPSBlockInfo, CmmBasicBlock)]
-breakBlock (BasicBlock ident stmts) = breakBlock' ident ControlBlock [] stmts
-
-breakBlock' current_id block_info accum_stmts [] =
- return [(block_info, BasicBlock current_id accum_stmts)]
--- TODO: notice a call just before a branch, jump, call, etc.
-breakBlock' current_id block_info accum_stmts (stmt@(CmmCall _ results _ _):stmts) = do
- new_id <- newLabelCPS
- let new_block = (block_info, BasicBlock current_id (accum_stmts ++ [stmt, CmmBranch new_id]))
- rest <- breakBlock' new_id (ContinuationBlock results) [] stmts
- return $ (new_block:rest)
-breakBlock' current_id arguments accum_stmts (stmt:stmts) =
- breakBlock' current_id arguments (accum_stmts ++ [stmt]) stmts
+-- be arguments to the continuation of the block once the call (if any)
+-- returns.
+
+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 or return"
+ [CmmJump target arguments] ->
+ [BrokenBlock current_id entry accum_stmts exits
+ (TailCallExit target arguments)]
+ [CmmReturn arguments] ->
+ [BrokenBlock current_id entry accum_stmts exits
+ (ReturnExit arguments)]
+ [CmmBranch target] ->
+ [BrokenBlock current_id entry accum_stmts (target:exits)
+ (ControlExit target)]
+ (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 block not implemented"
+ (CmmCall target results arguments saves:stmts) ->
+ let new_id = BlockId $ head uniques
+ rest = breakBlock' (tail uniques) new_id (ContinuationEntry results) [] [] stmts
+ in BrokenBlock current_id entry accum_stmts (new_id:exits)
+ (CallExit new_id target results arguments saves) : rest
+ (s@(CmmCondBranch test target):stmts) ->
+ breakBlock' uniques current_id entry (target:exits) (accum_stmts++[s]) stmts
+ (s:stmts) ->
+ breakBlock' uniques current_id entry exits (accum_stmts++[s]) stmts
+
+-----------------------------------------------------------------------------
+cmmBlockFromBrokenBlock :: BrokenBlock -> CmmBasicBlock
+cmmBlockFromBrokenBlock (BrokenBlock ident _ stmts _ exit) = BasicBlock ident (stmts++exit_stmt)
+ where
+ exit_stmt =
+ case exit of
+ ControlExit target -> [CmmBranch target]
+ ReturnExit arguments -> [CmmReturn arguments]
+ TailCallExit target arguments -> [CmmJump target arguments]
+ CallExit branch_target call_target results arguments saves -> [CmmCall call_target results arguments saves, CmmBranch branch_target]
+
+-----------------------------------------------------------------------------
+-- CPS a single CmmTop (proceedure)
+-----------------------------------------------------------------------------
+
+cpsProc :: UniqSupply -> CmmTop -> [CmmTop]
+cpsProc uniqSupply x@(CmmData _ _) = [x]
+cpsProc uniqSupply x@(CmmProc info_table ident params blocks) =
+ [CmmProc info_table ident params $ map (constructContinuation2 formats) broken_blocks]
+ where
+ uniqes :: [[Unique]]
+ uniqes = map uniqsFromSupply $ listSplitUniqSupply uniqSupply
+
+ broken_blocks :: [BrokenBlock]
+ broken_blocks = concat $ zipWith3 breakBlock uniqes blocks (FunctionEntry:repeat ControlEntry)
+
+ live :: BlockEntryLiveness
+ live = cmmLiveness $ map cmmBlockFromBrokenBlock broken_blocks
+
+ -- TODO: branches for proc points
+ -- TODO: let blocks_with_live = map (cmmLivenessComment live . snd) broken_blocks
+
+ formats :: BlockEnv StackFormat -- Stack format on entry
+ formats = selectStackFormat2 live broken_blocks
+
--------------------------------------------------------------------------------
cmmCPS :: DynFlags
-- continuationC <- return abstractC
-- TODO: find out if it is valid to create a new unique source like this
uniqSupply <- mkSplitUniqSupply 'p'
- let (_, continuationC) = runCPS (mapM (mapMCmmTop cpsProc) abstractC) (CPSState uniqSupply)
+ let supplies = listSplitUniqSupply uniqSupply
+ let continuationC = zipWith (\s (Cmm c) -> Cmm $ concat $ zipWith (cpsProc) (listSplitUniqSupply s) c) supplies abstractC
dumpIfSet_dyn dflags Opt_D_dump_cps_cmm "CPS Cmm" (pprCmms continuationC)
-- TODO: add option to dump Cmm to file
projects / ghc-hetmet.git / blobdiff