2 % (c) The University of Glasgow 2006
3 % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
5 \section[CgClosure]{Code generation for closures}
7 This module provides the support code for @StgToAbstractC@ to deal
8 with {\em closures} on the RHSs of let(rec)s. See also
9 @CgCon@, which deals with constructors.
12 module CgClosure ( cgTopRhsClosure,
18 #include "HsVersions.h"
20 import {-# SOURCE #-} CgExpr ( cgExpr )
54 %********************************************************
56 \subsection[closures-no-free-vars]{Top-level closures}
58 %********************************************************
60 For closures bound at top level, allocate in static space.
61 They should have no free variables.
65 -> CostCentreStack -- Optional cost centre annotation
70 -> FCode (Id, CgIdInfo)
72 cgTopRhsClosure id ccs binder_info upd_flag args body = do
73 { -- LAY OUT THE OBJECT
75 ; lf_info <- mkClosureLFInfo id TopLevel [] upd_flag args
76 ; srt_info <- getSRTInfo
77 ; mod_name <- getModuleName
78 ; let descr = closureDescription mod_name name
79 closure_info = mkClosureInfo True id lf_info 0 0 srt_info descr
80 closure_label = mkLocalClosureLabel name $ idCafInfo id
81 cg_id_info = stableIdInfo id (mkLblExpr closure_label) lf_info
82 closure_rep = mkStaticClosureFields closure_info ccs True []
84 -- BUILD THE OBJECT, AND GENERATE INFO TABLE (IF NECESSARY)
85 ; emitDataLits closure_label closure_rep
86 ; forkClosureBody (closureCodeBody binder_info closure_info
89 ; returnFC (id, cg_id_info) }
92 %********************************************************
94 \subsection[non-top-level-closures]{Non top-level closures}
96 %********************************************************
98 For closures with free vars, allocate in heap.
103 -> CostCentreStack -- Optional cost centre annotation
109 -> [StgArg] -- payload
110 -> FCode (Id, CgIdInfo)
112 cgStdRhsClosure bndr cc _bndr_info _fvs args body lf_info payload
113 = do -- AHA! A STANDARD-FORM THUNK
114 { -- LAY OUT THE OBJECT
115 amodes <- getArgAmodes payload
116 ; mod_name <- getModuleName
117 ; let (tot_wds, ptr_wds, amodes_w_offsets)
118 = mkVirtHeapOffsets (isLFThunk lf_info) amodes
120 descr = closureDescription mod_name (idName bndr)
121 closure_info = mkClosureInfo False -- Not static
122 bndr lf_info tot_wds ptr_wds
123 NoC_SRT -- No SRT for a std-form closure
126 ; (use_cc, blame_cc) <- chooseDynCostCentres cc args body
129 ; heap_offset <- allocDynClosure closure_info use_cc blame_cc amodes_w_offsets
132 ; returnFC (bndr, heapIdInfo bndr heap_offset lf_info) }
135 Here's the general case.
139 -> CostCentreStack -- Optional cost centre annotation
145 -> FCode (Id, CgIdInfo)
147 cgRhsClosure bndr cc bndr_info fvs upd_flag args body = do
148 { -- LAY OUT THE OBJECT
149 -- If the binder is itself a free variable, then don't store
150 -- it in the closure. Instead, just bind it to Node on entry.
151 -- NB we can be sure that Node will point to it, because we
152 -- havn't told mkClosureLFInfo about this; so if the binder
153 -- _was_ a free var of its RHS, mkClosureLFInfo thinks it *is*
154 -- stored in the closure itself, so it will make sure that
155 -- Node points to it...
158 is_elem = isIn "cgRhsClosure"
159 bndr_is_a_fv = bndr `is_elem` fvs
160 reduced_fvs | bndr_is_a_fv = fvs `minusList` [bndr]
163 ; lf_info <- mkClosureLFInfo bndr NotTopLevel fvs upd_flag args
164 ; fv_infos <- mapFCs getCgIdInfo reduced_fvs
165 ; srt_info <- getSRTInfo
166 ; mod_name <- getModuleName
167 ; let bind_details :: [(CgIdInfo, VirtualHpOffset)]
168 (tot_wds, ptr_wds, bind_details)
169 = mkVirtHeapOffsets (isLFThunk lf_info) (map add_rep fv_infos)
171 add_rep info = (cgIdInfoArgRep info, info)
173 descr = closureDescription mod_name name
174 closure_info = mkClosureInfo False -- Not static
175 bndr lf_info tot_wds ptr_wds
178 -- BUILD ITS INFO TABLE AND CODE
179 ; forkClosureBody (do
182 -- A function closure pointer may be tagged, so we
183 -- must take it into account when accessing the free variables.
184 mbtag = tagForArity (length args)
185 bind_fv (info, offset)
187 = bindNewToUntagNode (cgIdInfoId info) offset (cgIdInfoLF info) tag
189 = bindNewToNode (cgIdInfoId info) offset (cgIdInfoLF info)
190 ; mapCs bind_fv bind_details
192 -- Bind the binder itself, if it is a free var
193 ; whenC bndr_is_a_fv (bindNewToReg bndr nodeReg lf_info)
196 ; closureCodeBody bndr_info closure_info cc args body })
200 to_amode (info, offset) = do { amode <- idInfoToAmode info
201 ; return (amode, offset) }
202 ; (use_cc, blame_cc) <- chooseDynCostCentres cc args body
203 ; amodes_w_offsets <- mapFCs to_amode bind_details
204 ; heap_offset <- allocDynClosure closure_info use_cc blame_cc amodes_w_offsets
207 ; returnFC (bndr, heapIdInfo bndr heap_offset lf_info) }
210 mkClosureLFInfo :: Id -- The binder
211 -> TopLevelFlag -- True of top level
213 -> UpdateFlag -- Update flag
215 -> FCode LambdaFormInfo
216 mkClosureLFInfo bndr top fvs upd_flag args
217 | null args = return (mkLFThunk (idType bndr) top fvs upd_flag)
218 | otherwise = do { arg_descr <- mkArgDescr (idName bndr) args
219 ; return (mkLFReEntrant top fvs args arg_descr) }
223 %************************************************************************
225 \subsection[code-for-closures]{The code for closures}
227 %************************************************************************
230 closureCodeBody :: StgBinderInfo
231 -> ClosureInfo -- Lots of information about this closure
232 -> CostCentreStack -- Optional cost centre attached to closure
238 There are two main cases for the code for closures. If there are {\em
239 no arguments}, then the closure is a thunk, and not in normal form.
240 So it should set up an update frame (if it is shared).
241 NB: Thunks cannot have a primitive type!
244 closureCodeBody _binder_info cl_info cc [{- No args i.e. thunk -}] body = do
245 { body_absC <- getCgStmts $ do
246 { tickyEnterThunk cl_info
247 ; ldvEnterClosure cl_info -- NB: Node always points when profiling
248 ; thunkWrapper cl_info $ do
249 -- We only enter cc after setting up update so
250 -- that cc of enclosing scope will be recorded
251 -- in update frame CAF/DICT functions will be
252 -- subsumed by this enclosing cc
253 { enterCostCentre cl_info cc body
254 ; stmtsC [CmmComment $ mkFastString $ showSDoc $ ppr body]
258 ; emitClosureCodeAndInfoTable cl_info [] body_absC }
261 If there is /at least one argument/, then this closure is in
262 normal form, so there is no need to set up an update frame.
264 The Macros for GrAnSim are produced at the beginning of the
265 argSatisfactionCheck (by calling fetchAndReschedule). There info if
266 Node points to closure is available. -- HWL
269 closureCodeBody _binder_info cl_info cc args body
270 = ASSERT( length args > 0 )
271 do { -- Get the current virtual Sp (it might not be zero,
272 -- eg. if we're compiling a let-no-escape).
274 ; let (reg_args, other_args) = assignCallRegs (addIdReps args)
275 (sp_top, stk_args) = mkVirtStkOffsets vSp other_args
277 -- Allocate the global ticky counter
278 ; let ticky_ctr_lbl = mkRednCountsLabel (closureName cl_info) (clHasCafRefs cl_info)
279 ; emitTickyCounter cl_info args sp_top
281 -- ...and establish the ticky-counter
282 -- label for this block
283 ; setTickyCtrLabel ticky_ctr_lbl $ do
285 -- Emit the slow-entry code
286 { reg_save_code <- mkSlowEntryCode cl_info reg_args
288 -- Emit the main entry code
290 mkFunEntryCode cl_info cc reg_args stk_args
291 sp_top reg_save_code body
292 ; emitClosureCodeAndInfoTable cl_info [] blks
297 mkFunEntryCode :: ClosureInfo
299 -> [(Id,GlobalReg)] -- Args in regs
300 -> [(Id,VirtualSpOffset)] -- Args on stack
301 -> VirtualSpOffset -- Last allocated word on stack
302 -> CmmStmts -- Register-save code in case of GC
305 -- The main entry code for the closure
306 mkFunEntryCode cl_info cc reg_args stk_args sp_top reg_save_code body = do
307 { -- Bind args to regs/stack as appropriate,
308 -- and record expected position of sps
309 ; bindArgsToRegs reg_args
310 ; bindArgsToStack stk_args
311 ; setRealAndVirtualSp sp_top
313 -- Enter the cost-centre, if required
314 -- ToDo: It's not clear why this is outside the funWrapper,
315 -- but the tickyEnterFun is inside. Perhaps we can put
317 ; enterCostCentre cl_info cc body
320 ; funWrapper cl_info reg_args reg_save_code $ do
321 { tickyEnterFun cl_info
326 The "slow entry" code for a function. This entry point takes its
327 arguments on the stack. It loads the arguments into registers
328 according to the calling convention, and jumps to the function's
329 normal entry point. The function's closure is assumed to be in
332 The slow entry point is used in two places:
334 (a) unknown calls: eg. stg_PAP_entry
335 (b) returning from a heap-check failure
338 mkSlowEntryCode :: ClosureInfo -> [(Id,GlobalReg)] -> FCode CmmStmts
339 -- If this function doesn't have a specialised ArgDescr, we need
340 -- to generate the function's arg bitmap, slow-entry code, and
341 -- register-save code for the heap-check failure
342 -- Here, we emit the slow-entry code, and
343 -- return the register-save assignments
344 mkSlowEntryCode cl_info reg_args
345 | Just (_, ArgGen _) <- closureFunInfo cl_info
346 = do { emitSimpleProc slow_lbl (emitStmts load_stmts)
347 ; return save_stmts }
348 | otherwise = return noStmts
350 name = closureName cl_info
351 has_caf_refs = clHasCafRefs cl_info
352 slow_lbl = mkSlowEntryLabel name has_caf_refs
354 load_stmts = mkStmts load_assts `plusStmts` mkStmts [stk_adj_pop, jump_to_entry]
355 save_stmts = oneStmt stk_adj_push `plusStmts` mkStmts save_assts
357 reps_w_regs :: [(CgRep,GlobalReg)]
358 reps_w_regs = [(idCgRep id, reg) | (id,reg) <- reverse reg_args]
359 (final_stk_offset, stk_offsets)
360 = mapAccumL (\off (rep,_) -> (off + cgRepSizeW rep, off))
363 load_assts = zipWithEqual "mk_load" mk_load reps_w_regs stk_offsets
364 mk_load (rep,reg) offset = CmmAssign (CmmGlobal reg)
365 (CmmLoad (cmmRegOffW spReg offset)
368 save_assts = zipWithEqual "mk_save" mk_save reps_w_regs stk_offsets
369 mk_save (rep,reg) offset = ASSERT( argMachRep rep `cmmEqType` globalRegType reg )
370 CmmStore (cmmRegOffW spReg offset)
371 (CmmReg (CmmGlobal reg))
373 stk_adj_pop = CmmAssign spReg (cmmRegOffW spReg final_stk_offset)
374 stk_adj_push = CmmAssign spReg (cmmRegOffW spReg (- final_stk_offset))
375 jump_to_entry = CmmJump (mkLblExpr (enterLocalIdLabel name has_caf_refs)) []
379 %************************************************************************
381 \subsubsection[closure-code-wrappers]{Wrappers around closure code}
383 %************************************************************************
386 thunkWrapper:: ClosureInfo -> Code -> Code
387 thunkWrapper closure_info thunk_code = do
388 { let node_points = nodeMustPointToIt (closureLFInfo closure_info)
390 -- HWL: insert macros for GrAnSim; 2 versions depending on liveness of node
391 -- (we prefer fetchAndReschedule-style context switches to yield ones)
393 then granFetchAndReschedule [] node_points
394 else granYield [] node_points
396 -- Stack and/or heap checks
397 ; thunkEntryChecks closure_info $ do
398 { -- Overwrite with black hole if necessary
399 whenC (blackHoleOnEntry closure_info && node_points)
400 (blackHoleIt closure_info)
401 ; setupUpdate closure_info thunk_code }
402 -- setupUpdate *encloses* the thunk_code
405 funWrapper :: ClosureInfo -- Closure whose code body this is
406 -> [(Id,GlobalReg)] -- List of argument registers (if any)
407 -> CmmStmts -- reg saves for the heap check failure
408 -> Code -- Body of function being compiled
410 funWrapper closure_info arg_regs reg_save_code fun_body = do
411 { let node_points = nodeMustPointToIt (closureLFInfo closure_info)
414 -- Debugging: check that R1 has the correct tag
415 ; let tag = funTag closure_info
416 ; whenC (tag /= 0 && node_points) $ do
418 stmtC (CmmCondBranch (CmmMachOp mo_wordEq [cmmGetTag (CmmReg nodeReg),
419 CmmLit (mkIntCLit tag)]) l)
420 stmtC (CmmStore (CmmLit (mkWordCLit 0)) (CmmLit (mkWordCLit 0)))
424 -- Enter for Ldv profiling
425 ; whenC node_points (ldvEnterClosure closure_info)
427 -- GranSim yeild poin
428 ; granYield arg_regs node_points
430 -- Heap and/or stack checks wrap the function body
431 ; funEntryChecks closure_info reg_save_code
437 %************************************************************************
439 \subsubsubsection[update-and-BHs]{Update and black-hole wrappers}
441 %************************************************************************
445 blackHoleIt :: ClosureInfo -> Code
446 -- Only called for closures with no args
447 -- Node points to the closure
448 blackHoleIt closure_info = emitBlackHoleCode (closureSingleEntry closure_info)
450 emitBlackHoleCode :: Bool -> Code
451 emitBlackHoleCode is_single_entry = do
453 dflags <- getDynFlags
455 -- If we wanted to do eager blackholing with slop filling,
456 -- we'd need to do it at the *end* of a basic block, otherwise
457 -- we overwrite the free variables in the thunk that we still
458 -- need. We have a patch for this from Andy Cheadle, but not
459 -- incorporated yet. --SDM [6/2004]
461 -- Profiling needs slop filling (to support LDV profiling), so
462 -- currently eager blackholing doesn't work with profiling.
464 -- Previously, eager blackholing was enabled when ticky-ticky
465 -- was on. But it didn't work, and it wasn't strictly necessary
466 -- to bring back minimal ticky-ticky, so now EAGER_BLACKHOLING
467 -- is unconditionally disabled. -- krc 1/2007
469 let eager_blackholing = not opt_SccProfilingOn
470 && dopt Opt_EagerBlackHoling dflags
474 tickyBlackHole (not is_single_entry)
475 let bh_info = CmmReg (CmmGlobal EagerBlackholeInfo)
476 stmtC (CmmStore (CmmReg nodeReg) bh_info)
482 setupUpdate :: ClosureInfo -> Code -> Code -- Only called for closures with no args
483 -- Nota Bene: this function does not change Node (even if it's a CAF),
484 -- so that the cost centre in the original closure can still be
485 -- extracted by a subsequent enterCostCentre
486 setupUpdate closure_info code
487 | closureReEntrant closure_info
490 | not (isStaticClosure closure_info)
491 = if closureUpdReqd closure_info
492 then do { tickyPushUpdateFrame; pushUpdateFrame (CmmReg nodeReg) code }
493 else do { tickyUpdateFrameOmitted; code }
495 | otherwise -- A static closure
496 = do { tickyUpdateBhCaf closure_info
498 ; if closureUpdReqd closure_info
499 then do -- Blackhole the (updatable) CAF:
500 { upd_closure <- link_caf closure_info True
501 ; pushUpdateFrame upd_closure code }
503 { -- krc: removed some ticky-related code here.
504 ; tickyUpdateFrameOmitted
509 -----------------------------------------------------------------------------
512 -- When a CAF is first entered, it creates a black hole in the heap,
513 -- and updates itself with an indirection to this new black hole.
515 -- We update the CAF with an indirection to a newly-allocated black
516 -- hole in the heap. We also set the blocking queue on the newly
517 -- allocated black hole to be empty.
519 -- Why do we make a black hole in the heap when we enter a CAF?
521 -- - for a generational garbage collector, which needs a fast
522 -- test for whether an updatee is in an old generation or not
524 -- - for the parallel system, which can implement updates more
525 -- easily if the updatee is always in the heap. (allegedly).
527 -- When debugging, we maintain a separate CAF list so we can tell when
528 -- a CAF has been garbage collected.
530 -- newCAF must be called before the itbl ptr is overwritten, since
531 -- newCAF records the old itbl ptr in order to do CAF reverting
532 -- (which Hugs needs to do in order that combined mode works right.)
535 -- ToDo [Feb 04] This entire link_caf nonsense could all be moved
536 -- into the "newCAF" RTS procedure, which we call anyway, including
537 -- the allocation of the black-hole indirection closure.
538 -- That way, code size would fall, the CAF-handling code would
539 -- be closer together, and the compiler wouldn't need to know
540 -- about off_indirectee etc.
542 link_caf :: ClosureInfo
543 -> Bool -- True <=> updatable, False <=> single-entry
544 -> FCode CmmExpr -- Returns amode for closure to be updated
545 -- To update a CAF we must allocate a black hole, link the CAF onto the
546 -- CAF list, then update the CAF to point to the fresh black hole.
547 -- This function returns the address of the black hole, so it can be
548 -- updated with the new value when available. The reason for all of this
549 -- is that we only want to update dynamic heap objects, not static ones,
550 -- so that generational GC is easier.
551 link_caf cl_info _is_upd = do
552 { -- Alloc black hole specifying CC_HDR(Node) as the cost centre
553 ; let use_cc = costCentreFrom (CmmReg nodeReg)
555 ; hp_offset <- allocDynClosure bh_cl_info use_cc blame_cc []
556 ; hp_rel <- getHpRelOffset hp_offset
558 -- Call the RTS function newCAF to add the CAF to the CafList
559 -- so that the garbage collector can find them
560 -- This must be done *before* the info table pointer is overwritten,
561 -- because the old info table ptr is needed for reversion
562 ; emitRtsCallWithVols (sLit "newCAF") [CmmHinted (CmmReg nodeReg) AddrHint] [node] False
563 -- node is live, so save it.
565 -- Overwrite the closure with a (static) indirection
566 -- to the newly-allocated black hole
567 ; stmtsC [ CmmStore (cmmRegOffW nodeReg off_indirectee) hp_rel
568 , CmmStore (CmmReg nodeReg) ind_static_info ]
572 bh_cl_info :: ClosureInfo
573 bh_cl_info = cafBlackHoleClosureInfo cl_info
575 ind_static_info :: CmmExpr
576 ind_static_info = mkLblExpr mkIndStaticInfoLabel
578 off_indirectee :: WordOff
579 off_indirectee = fixedHdrSize + oFFSET_StgInd_indirectee*wORD_SIZE
583 %************************************************************************
585 \subsection[CgClosure-Description]{Profiling Closure Description.}
587 %************************************************************************
589 For "global" data constructors the description is simply occurrence
590 name of the data constructor itself. Otherwise it is determined by
591 @closureDescription@ from the let binding information.
594 closureDescription :: Module -- Module
595 -> Name -- Id of closure binding
597 -- Not called for StgRhsCon which have global info tables built in
598 -- CgConTbls.lhs with a description generated from the data constructor
599 closureDescription mod_name name
600 = showSDocDump (char '<' <>
601 (if isExternalName name
602 then ppr name -- ppr will include the module name prefix
603 else pprModule mod_name <> char '.' <> ppr name) <>
605 -- showSDocDump, because we want to see the unique on the Name.