be9f474cbeac98de98dab39e86f57fe6c4b20b14
[ghc.git] / compiler / cmm / CmmCPS.hs
1 module CmmCPS (
2 -- | Converts C-- with full proceedures and parameters
3 -- to a CPS transformed C-- with the stack made manifest.
4 cmmCPS
5 ) where
6
7 #include "HsVersions.h"
8
9 import Cmm
10 import CmmLint
11 import PprCmm
12
13 import CmmLive
14 import CmmBrokenBlock
15 import CmmProcPoint
16 import CmmCallConv
17 import CmmInfo
18 import CmmUtils
19
20 import Bitmap
21 import ClosureInfo
22 import MachOp
23 import ForeignCall
24 import CLabel
25 import SMRep
26 import Constants
27
28 import DynFlags
29 import ErrUtils
30 import Maybes
31 import Outputable
32 import UniqSupply
33 import UniqFM
34 import UniqSet
35 import Unique
36
37 import Monad
38 import IO
39 import Data.List
40
41 -----------------------------------------------------------------------------
42 -- |Top level driver for the CPS pass
43 -----------------------------------------------------------------------------
44 cmmCPS :: DynFlags -- ^ Dynamic flags: -dcmm-lint -ddump-cps-cmm
45 -> [GenCmm CmmStatic CmmInfo CmmStmt] -- ^ Input C-- with Proceedures
46 -> IO [GenCmm CmmStatic [CmmStatic] CmmStmt] -- ^ Output CPS transformed C--
47 cmmCPS dflags abstractC = do
48 when (dopt Opt_DoCmmLinting dflags) $
49 do showPass dflags "CmmLint"
50 case firstJust $ map cmmLint abstractC of
51 Just err -> do printDump err
52 ghcExit dflags 1
53 Nothing -> return ()
54 showPass dflags "CPS"
55
56 -- TODO: more lint checking
57 -- check for use of branches to non-existant blocks
58 -- check for use of Sp, SpLim, R1, R2, etc.
59
60 uniqSupply <- mkSplitUniqSupply 'p'
61 let supplies = listSplitUniqSupply uniqSupply
62 let doCpsProc s (Cmm c) =
63 Cmm $ concat $ zipWith cpsProc (listSplitUniqSupply s) c
64 let continuationC = zipWith doCpsProc supplies abstractC
65
66 dumpIfSet_dyn dflags Opt_D_dump_cps_cmm "CPS Cmm" (pprCmms continuationC)
67
68 -- TODO: add option to dump Cmm to file
69
70 return continuationC
71
72 stg_gc_gen = mkRtsApFastLabel SLIT("gen_cg_TODO") --panic "Need the label for gc"
73 make_gc_block block_id fun_label formals srt = BasicBlock block_id stmts
74 where
75 stmts = [CmmCall stg_gc_gen_target [] [] srt,
76 CmmJump fun_expr actuals]
77 stg_gc_gen_target =
78 CmmForeignCall (CmmLit (CmmLabel stg_gc_gen)) CmmCallConv
79 actuals = map (\x -> (CmmReg (CmmLocal x), NoHint)) formals
80 fun_expr = CmmLit (CmmLabel fun_label)
81
82 force_gc_block old_info block_id fun_label formals blocks =
83 case old_info of
84 CmmNonInfo (Just _) -> (old_info, [])
85 CmmInfo _ (Just _) _ _ -> (old_info, [])
86 CmmNonInfo Nothing
87 -> (CmmNonInfo (Just block_id),
88 [make_gc_block block_id fun_label formals NoC_SRT])
89 CmmInfo prof Nothing type_tag type_info
90 -> (CmmInfo prof (Just block_id) type_tag type_info,
91 [make_gc_block block_id fun_label formals srt])
92 where
93 srt = case type_info of
94 ConstrInfo _ _ _ -> NoC_SRT
95 FunInfo _ srt' _ _ _ _ -> srt'
96 ThunkInfo _ srt' -> srt'
97 ThunkSelectorInfo _ srt' -> srt'
98 ContInfo _ srt' -> srt'
99
100 -----------------------------------------------------------------------------
101 -- |CPS a single CmmTop (proceedure)
102 -- Only 'CmmProc' are transformed 'CmmData' will be left alone.
103 -----------------------------------------------------------------------------
104
105 cpsProc :: UniqSupply
106 -> GenCmmTop CmmStatic CmmInfo CmmStmt -- ^Input proceedure
107 -> [GenCmmTop CmmStatic [CmmStatic] CmmStmt] -- ^Output proceedure and continuations
108 cpsProc uniqSupply (CmmData sec dat) = [CmmData sec dat]
109 cpsProc uniqSupply (CmmProc info ident params blocks) = info_procs
110 where
111 uniques :: [[Unique]]
112 uniques = map uniqsFromSupply $ listSplitUniqSupply uniqSupply
113 (gc_unique:info_uniques):block_uniques = uniques
114
115 -- Ensure that
116 forced_gc :: (CmmInfo, [CmmBasicBlock])
117 forced_gc = force_gc_block info (BlockId gc_unique) ident params blocks
118
119 forced_info = fst forced_gc
120 forced_blocks = blocks ++ snd forced_gc
121 forced_gc_id = case forced_info of
122 CmmNonInfo (Just x) -> x
123 CmmInfo _ (Just x) _ _ -> x
124
125 -- Break the block at each function call.
126 -- The part after the function call will have to become a continuation.
127 broken_blocks :: [BrokenBlock]
128 broken_blocks =
129 concat $ zipWith3 breakBlock block_uniques forced_blocks
130 (FunctionEntry forced_info ident params:repeat ControlEntry)
131
132 -- Calculate live variables for each broken block.
133 --
134 -- Nothing can be live on entry to the first block
135 -- so we could take the tail, but for now we wont
136 -- to help future proof the code.
137 live :: BlockEntryLiveness
138 live = cmmLiveness $ map cmmBlockFromBrokenBlock broken_blocks
139
140 -- Calculate which blocks must be made into full fledged procedures.
141 proc_points :: UniqSet BlockId
142 proc_points = calculateProcPoints broken_blocks
143
144 -- Construct a map so we can lookup a broken block by its 'BlockId'.
145 block_env :: BlockEnv BrokenBlock
146 block_env = blocksToBlockEnv broken_blocks
147
148 -- Group the blocks into continuations based on the set of proc-points.
149 continuations :: [Continuation (Either C_SRT CmmInfo)]
150 continuations = zipWith
151 (gatherBlocksIntoContinuation proc_points block_env)
152 (uniqSetToList proc_points)
153 (Just forced_gc_id : repeat Nothing)
154
155 -- Select the stack format on entry to each continuation.
156 -- Return the max stack offset and an association list
157 --
158 -- This is an association list instead of a UniqFM because
159 -- CLabel's don't have a 'Uniqueable' instance.
160 formats :: [(CLabel, (Maybe CLabel, [Maybe LocalReg]))]
161 formats = selectStackFormat live continuations
162
163 -- Do a little meta-processing on the stack formats such as
164 -- getting the individual frame sizes and the maximum frame size
165 formats' :: (WordOff, [(CLabel, StackFormat)])
166 formats' = processFormats formats
167
168 -- TODO FIXME NOW: calculate a real max stack (including function call args)
169 -- TODO: from the maximum frame size get the maximum stack size.
170 -- The difference is due to the size taken by function calls.
171
172 -- Update the info table data on the continuations with
173 -- the selected stack formats.
174 continuations' :: [Continuation CmmInfo]
175 continuations' = map (applyStackFormat (snd formats')) continuations
176
177 -- Do the actual CPS transform.
178 cps_procs :: [CmmTop]
179 cps_procs = map (continuationToProc formats') continuations'
180
181 -- Convert the info tables from CmmInfo to [CmmStatic]
182 -- We might want to put this in another pass eventually
183 info_procs :: [RawCmmTop]
184 info_procs = concat (zipWith mkInfoTable info_uniques cps_procs)
185
186 --------------------------------------------------------------------------------
187
188 -- The format for the call to a continuation
189 -- The fst is the arguments that must be passed to the continuation
190 -- by the continuation's caller.
191 -- The snd is the live values that must be saved on stack.
192 -- A Nothing indicates an ignored slot.
193 -- The head of each list is the stack top or the first parameter.
194
195 -- The format for live values for a particular continuation
196 -- All on stack for now.
197 -- Head element is the top of the stack (or just under the header).
198 -- Nothing means an empty slot.
199 -- Future possibilities include callee save registers (i.e. passing slots in register)
200 -- and heap memory (not sure if that's usefull at all though, but it may
201 -- be worth exploring the design space).
202
203 continuationLabel (Continuation _ l _ _) = l
204 data Continuation info =
205 Continuation
206 info --(Either C_SRT CmmInfo) -- Left <=> Continuation created by the CPS
207 -- Right <=> Function or Proc point
208 CLabel -- Used to generate both info & entry labels
209 CmmFormals -- Argument locals live on entry (C-- procedure params)
210 [BrokenBlock] -- Code, may be empty. The first block is
211 -- the entry point. The order is otherwise initially
212 -- unimportant, but at some point the code gen will
213 -- fix the order.
214
215 -- the BlockId of the first block does not give rise
216 -- to a label. To jump to the first block in a Proc,
217 -- use the appropriate CLabel.
218
219 data StackFormat
220 = StackFormat {
221 stack_label :: Maybe CLabel, -- The label occupying the top slot
222 stack_frame_size :: WordOff, -- Total frame size in words (not including arguments)
223 stack_live :: [Maybe LocalReg] -- local reg offsets from stack top
224 }
225
226 -- A block can be a continuation of a call
227 -- A block can be a continuation of another block (w/ or w/o joins)
228 -- A block can be an entry to a function
229
230 -----------------------------------------------------------------------------
231
232 collectNonProcPointTargets ::
233 UniqSet BlockId -> BlockEnv BrokenBlock
234 -> UniqSet BlockId -> [BlockId] -> UniqSet BlockId
235 collectNonProcPointTargets proc_points blocks current_targets new_blocks =
236 if sizeUniqSet current_targets == sizeUniqSet new_targets
237 then current_targets
238 else foldl
239 (collectNonProcPointTargets proc_points blocks)
240 new_targets
241 (map (:[]) targets)
242 where
243 blocks' = map (lookupWithDefaultUFM blocks (panic "TODO")) new_blocks
244 targets =
245 -- Note the subtlety that since the extra branch after a call
246 -- will always be to a block that is a proc-point,
247 -- this subtraction will always remove that case
248 uniqSetToList $ (unionManyUniqSets $ map (mkUniqSet . brokenBlockTargets) blocks')
249 `minusUniqSet` proc_points
250 -- TODO: remove redundant uniqSetToList
251 new_targets = current_targets `unionUniqSets` (mkUniqSet targets)
252
253 -- TODO: insert proc point code here
254 -- * Branches and switches to proc points may cause new blocks to be created
255 -- (or proc points could leave behind phantom blocks that just jump to them)
256 -- * Proc points might get some live variables passed as arguments
257
258 gatherBlocksIntoContinuation ::
259 UniqSet BlockId -> BlockEnv BrokenBlock
260 -> BlockId -> Maybe BlockId -> Continuation (Either C_SRT CmmInfo)
261 gatherBlocksIntoContinuation proc_points blocks start gc =
262 Continuation info_table clabel params body
263 where
264 start_and_gc = start : maybeToList gc
265 children = (collectNonProcPointTargets proc_points blocks (mkUniqSet start_and_gc) start_and_gc) `minusUniqSet` (mkUniqSet start_and_gc)
266 start_block = lookupWithDefaultUFM blocks (panic "TODO") start
267 gc_block = map (lookupWithDefaultUFM blocks (panic "TODO)")) (maybeToList gc)
268 children_blocks = map (lookupWithDefaultUFM blocks (panic "TODO")) (uniqSetToList children)
269 body = start_block : gc_block ++ children_blocks
270
271 -- We can't properly annotate the continuation's stack parameters
272 -- at this point because this is before stack selection
273 -- but we want to keep the C_SRT around so we use 'Either'.
274 info_table = case start_block_entry of
275 FunctionEntry info _ _ -> Right info
276 ContinuationEntry _ srt -> Left srt
277 ControlEntry -> Right (CmmNonInfo Nothing)
278
279 start_block_entry = brokenBlockEntry start_block
280 clabel = case start_block_entry of
281 FunctionEntry _ label _ -> label
282 _ -> mkReturnPtLabel $ getUnique start
283 params = case start_block_entry of
284 FunctionEntry _ _ args -> args
285 ContinuationEntry args _ -> args
286 ControlEntry -> [] -- TODO: it's a proc-point, we could pass lives in parameter registers
287
288 --------------------------------------------------------------------------------
289 -- For now just select the continuation orders in the order they are in the set with no gaps
290
291 selectStackFormat :: BlockEnv CmmLive
292 -> [Continuation (Either C_SRT CmmInfo)]
293 -> [(CLabel, (Maybe CLabel, [Maybe LocalReg]))]
294 selectStackFormat live continuations =
295 map (\c -> (continuationLabel c, selectStackFormat' c)) continuations
296 where
297 selectStackFormat' (Continuation
298 (Right (CmmInfo _ _ _ (ContInfo format srt)))
299 label _ _) = (Just label, format)
300 selectStackFormat' (Continuation (Right _) _ _ _) = (Nothing, [])
301 selectStackFormat' (Continuation (Left srt) label _ blocks) =
302 -- TODO: assumes the first block is the entry block
303 let ident = brokenBlockId $ head blocks -- TODO: CLabel isn't a uniquable, but we need a better way than this
304 in (Just label,
305 map Just $ uniqSetToList $
306 lookupWithDefaultUFM live unknown_block ident)
307
308 unknown_block = panic "unknown BlockId in selectStackFormat"
309
310 processFormats :: [(CLabel, (Maybe CLabel, [Maybe LocalReg]))]
311 -> (WordOff, [(CLabel, StackFormat)])
312 processFormats formats = (max_size, formats')
313 where
314 max_size = foldl max 0 (map (stack_frame_size . snd) formats')
315 formats' = map make_format formats
316 make_format (label, format) =
317 (label,
318 StackFormat {
319 stack_label = fst format,
320 stack_frame_size = stack_size (snd format) +
321 if isJust (fst format)
322 then label_size
323 else 0,
324 stack_live = snd format })
325
326 -- TODO: get rid of "+ 1" etc.
327 label_size = 1 :: WordOff
328
329 stack_size [] = 0
330 stack_size (Nothing:formats) = 1 + stack_size formats -- one dead word
331 stack_size (Just reg:formats) = width + stack_size formats
332 where
333 width = machRepByteWidth (localRegRep reg) `quot` wORD_SIZE
334 -- TODO: it would be better if we had a machRepWordWidth
335
336 -----------------------------------------------------------------------------
337 applyStackFormat :: [(CLabel, StackFormat)]
338 -> Continuation (Either C_SRT CmmInfo)
339 -> Continuation CmmInfo
340
341 -- User written continuations
342 applyStackFormat formats (Continuation
343 (Right (CmmInfo prof gc tag (ContInfo _ srt)))
344 label formals blocks) =
345 Continuation (CmmInfo prof gc tag (ContInfo format srt))
346 label formals blocks
347 where
348 format = stack_live $ maybe unknown_block id $ lookup label formats
349 unknown_block = panic "unknown BlockId in applyStackFormat"
350
351 -- User written non-continuation code
352 applyStackFormat formats (Continuation (Right info) label formals blocks) =
353 Continuation info label formals blocks
354
355 -- CPS generated continuations
356 applyStackFormat formats (Continuation (Left srt) label formals blocks) =
357 Continuation (CmmInfo prof gc tag (ContInfo (stack_live $ format) srt))
358 label formals blocks
359 where
360 gc = Nothing -- Generated continuations never need a stack check
361 -- TODO prof: this is the same as the current implementation
362 -- but I think it could be improved
363 prof = ProfilingInfo zeroCLit zeroCLit
364 tag = if stack_frame_size format > mAX_SMALL_BITMAP_SIZE
365 then rET_BIG
366 else rET_SMALL
367 format = maybe unknown_block id $ lookup label formats
368 unknown_block = panic "unknown BlockId in applyStackFormat"
369
370 -----------------------------------------------------------------------------
371 continuationToProc :: (WordOff, [(CLabel, StackFormat)])
372 -> Continuation CmmInfo
373 -> CmmTop
374 continuationToProc (max_stack, formats)
375 (Continuation info label formals blocks) =
376 CmmProc info label formals (map continuationToProc' blocks)
377 where
378 curr_format = maybe unknown_block id $ lookup label formats
379 unknown_block = panic "unknown BlockId in continuationToProc"
380
381 continuationToProc' :: BrokenBlock -> CmmBasicBlock
382 continuationToProc' (BrokenBlock ident entry stmts _ exit) =
383 BasicBlock ident (prefix++stmts++postfix)
384 where
385 prefix = case entry of
386 ControlEntry -> []
387 FunctionEntry (CmmInfo _ (Just gc_block) _ _) _ formals ->
388 gc_stack_check gc_block max_stack ++
389 function_entry formals curr_format
390 FunctionEntry (CmmInfo _ Nothing _ _) _ formals ->
391 panic "continuationToProc: missing GC block"
392 FunctionEntry (CmmNonInfo (Just gc_block)) _ formals ->
393 gc_stack_check gc_block max_stack ++
394 function_entry formals curr_format
395 FunctionEntry (CmmNonInfo Nothing) _ formals ->
396 panic "continuationToProc: missing non-info GC block"
397 ContinuationEntry formals _ ->
398 function_entry formals curr_format
399 postfix = case exit of
400 FinalBranch next -> [CmmBranch next]
401 FinalSwitch expr targets -> [CmmSwitch expr targets]
402 FinalReturn arguments ->
403 tail_call (stack_frame_size curr_format)
404 (CmmLoad (CmmReg spReg) wordRep)
405 arguments
406 FinalJump target arguments ->
407 tail_call (stack_frame_size curr_format) target arguments
408 FinalCall next (CmmForeignCall target CmmCallConv)
409 results arguments ->
410 pack_continuation curr_format cont_format ++
411 tail_call (stack_frame_size curr_format - stack_frame_size cont_format)
412 target arguments
413 where
414 cont_format = maybe unknown_block id $
415 lookup (mkReturnPtLabel $ getUnique next) formats
416 FinalCall next _ results arguments -> panic "unimplemented CmmCall"
417
418 -----------------------------------------------------------------------------
419 -- Functions that generate CmmStmt sequences
420 -- for packing/unpacking continuations
421 -- and entering/exiting functions
422
423 tail_call :: WordOff -> CmmExpr -> CmmActuals -> [CmmStmt]
424 tail_call spRel target arguments
425 = store_arguments ++ adjust_spReg ++ jump where
426 store_arguments =
427 [stack_put spRel expr offset
428 | ((expr, _), StackParam offset) <- argument_formats] ++
429 [global_put expr global
430 | ((expr, _), RegisterParam global) <- argument_formats]
431 adjust_spReg =
432 if spRel == 0
433 then []
434 else [CmmAssign spReg (CmmRegOff spReg (spRel*wORD_SIZE))]
435 jump = [CmmJump target arguments]
436
437 argument_formats = assignArguments (cmmExprRep . fst) arguments
438
439 gc_stack_check :: BlockId -> WordOff -> [CmmStmt]
440 gc_stack_check gc_block max_frame_size
441 = check_stack_limit where
442 check_stack_limit = [
443 CmmCondBranch
444 (CmmMachOp (MO_U_Lt $ cmmRegRep spReg)
445 [CmmRegOff spReg (-max_frame_size*wORD_SIZE),
446 CmmReg spLimReg])
447 gc_block]
448
449 -- TODO: fix branches to proc point
450 -- (we have to insert a new block to marshel the continuation)
451 pack_continuation :: StackFormat -> StackFormat -> [CmmStmt]
452 pack_continuation (StackFormat curr_id curr_frame_size _)
453 (StackFormat cont_id cont_frame_size live_regs)
454 = store_live_values ++ set_stack_header where
455 -- TODO: only save variables when actually needed
456 -- (may be handled by latter pass)
457 store_live_values =
458 [stack_put spRel (CmmReg (CmmLocal reg)) offset
459 | (reg, offset) <- cont_offsets]
460 set_stack_header =
461 if needs_header_set
462 then [stack_put spRel continuation_function 0]
463 else []
464
465 -- TODO: factor with function_entry and CmmInfo.hs(?)
466 cont_offsets = mkOffsets label_size live_regs
467
468 label_size = 1 :: WordOff
469
470 mkOffsets size [] = []
471 mkOffsets size (Nothing:regs) = mkOffsets (size+1) regs
472 mkOffsets size (Just reg:regs) = (reg, size):mkOffsets (size + width) regs
473 where
474 width = machRepByteWidth (localRegRep reg) `quot` wORD_SIZE
475 -- TODO: it would be better if we had a machRepWordWidth
476
477 spRel = curr_frame_size - cont_frame_size
478 continuation_function = CmmLit $ CmmLabel $ fromJust cont_id
479 needs_header_set =
480 case (curr_id, cont_id) of
481 (Just x, Just y) -> x /= y
482 _ -> isJust cont_id
483
484 -- Lazy adjustment of stack headers assumes all blocks
485 -- that could branch to eachother (i.e. control blocks)
486 -- have the same stack format (this causes a problem
487 -- only for proc-point).
488 function_entry :: CmmFormals -> StackFormat -> [CmmStmt]
489 function_entry formals (StackFormat _ _ live_regs)
490 = load_live_values ++ load_args where
491 -- TODO: only save variables when actually needed
492 -- (may be handled by latter pass)
493 load_live_values =
494 [stack_get 0 reg offset
495 | (reg, offset) <- curr_offsets]
496 load_args =
497 [stack_get 0 reg offset
498 | (reg, StackParam offset) <- argument_formats] ++
499 [global_get reg global
500 | (reg, RegisterParam global) <- argument_formats]
501
502 argument_formats = assignArguments (localRegRep) formals
503
504 -- TODO: eliminate copy/paste with pack_continuation
505 curr_offsets = mkOffsets label_size live_regs
506
507 label_size = 1 :: WordOff
508
509 mkOffsets size [] = []
510 mkOffsets size (Nothing:regs) = mkOffsets (size+1) regs
511 mkOffsets size (Just reg:regs) = (reg, size):mkOffsets (size + width) regs
512 where
513 width = machRepByteWidth (localRegRep reg) `quot` wORD_SIZE
514 -- TODO: it would be better if we had a machRepWordWidth
515
516 -----------------------------------------------------------------------------
517 -- Section: Stack and argument register puts and gets
518 -----------------------------------------------------------------------------
519 -- TODO: document
520
521 -- |Construct a 'CmmStmt' that will save a value on the stack
522 stack_put :: WordOff -- ^ Offset from the real 'Sp' that 'offset'
523 -- is relative to (added to offset)
524 -> CmmExpr -- ^ What to store onto the stack
525 -> WordOff -- ^ Where on the stack to store it
526 -- (positive <=> higher addresses)
527 -> CmmStmt
528 stack_put spRel expr offset =
529 CmmStore (CmmRegOff spReg (wORD_SIZE*(spRel + offset))) expr
530
531 --------------------------------
532 -- |Construct a
533 stack_get :: WordOff
534 -> LocalReg
535 -> WordOff
536 -> CmmStmt
537 stack_get spRel reg offset =
538 CmmAssign (CmmLocal reg)
539 (CmmLoad (CmmRegOff spReg (wORD_SIZE*(spRel + offset)))
540 (localRegRep reg))
541 global_put :: CmmExpr -> GlobalReg -> CmmStmt
542 global_put expr global = CmmAssign (CmmGlobal global) expr
543 global_get :: LocalReg -> GlobalReg -> CmmStmt
544 global_get reg global = CmmAssign (CmmLocal reg) (CmmReg (CmmGlobal global))
545