1 /* -----------------------------------------------------------------------------
3 * (c) The University of Glasgow 2004
5 * Application-related bits.
7 * This file is written in a subset of C--, extended with various
8 * features specific to GHC. It is compiled by GHC directly. For the
9 * syntax of .cmm files, see the parser in ghc/compiler/cmm/CmmParse.y.
11 * -------------------------------------------------------------------------- */
15 /* ----------------------------------------------------------------------------
16 * Evaluate a closure and return it.
18 * There isn't an info table / return address version of stg_ap_0, because
19 * everything being returned is guaranteed evaluated, so it would be a no-op.
22 STRING(stg_ap_0_ret_str,"stg_ap_0_ret... ")
26 // fn is in R1, no args on the stack
29 foreign "C" debugBelch(stg_ap_0_ret_str) [R1];
30 foreign "C" printClosure(R1 "ptr") [R1]);
33 foreign "C" checkStackChunk(Sp "ptr",
34 CurrentTSO + TSO_OFFSET_StgTSO_stack +
35 WDS(TO_W_(StgTSO_stack_size(CurrentTSO))) "ptr") [R1]);
40 /* -----------------------------------------------------------------------------
43 This entry code is *only* called by one of the stg_ap functions.
44 On entry: Sp points to the remaining arguments on the stack. If
45 the stack check fails, we can just push the PAP on the stack and
46 return to the scheduler.
48 On entry: R1 points to the PAP. The rest of the function's
49 arguments (apart from those that are already in the PAP) are on the
50 stack, starting at Sp(0). R2 contains an info table which
51 describes these arguments, which is used in the event that the
52 stack check in the entry code below fails. The info table is
53 currently one of the stg_ap_*_ret family, as this code is always
54 entered from those functions.
56 The idea is to copy the chunk of stack from the PAP object onto the
57 stack / into registers, and enter the function.
58 -------------------------------------------------------------------------- */
60 INFO_TABLE(stg_PAP,/*special layout*/0,0,PAP,"PAP","PAP")
61 { foreign "C" barf("PAP object entered!") never returns; }
70 Words = TO_W_(StgPAP_n_args(pap));
73 // Check for stack overflow and bump the stack pointer.
74 // We have a hand-rolled stack check fragment here, because none of
75 // the canned ones suit this situation.
77 if ((Sp - WDS(Words)) < SpLim) {
78 // there is a return address in R2 in the event of a
79 // stack check failure. The various stg_apply functions arrange
80 // this before calling stg_PAP_entry.
90 // Enter PAP cost centre
91 ENTER_CCS_PAP_CL(pap);
96 p = pap + SIZEOF_StgHeader + OFFSET_StgPAP_payload;
106 R1 = StgPAP_fun(pap);
108 /* DEBUGGING CODE, ensures that arity 1 and 2 functions are entered tagged
109 if (TO_W_(StgFunInfoExtra_arity(%FUN_INFO(%INFO_PTR(UNTAG(R1))))) == 1 ) {
115 if (TO_W_(StgFunInfoExtra_arity(%FUN_INFO(%INFO_PTR(UNTAG(R1))))) == 2 ) {
126 jump %GET_ENTRY(UNTAG(R1));
129 info = %GET_FUN_INFO(UNTAG(R1));
131 type = TO_W_(StgFunInfoExtra_fun_type(info));
132 if (type == ARG_GEN) {
133 jump StgFunInfoExtra_slow_apply(info);
135 if (type == ARG_GEN_BIG) {
136 jump StgFunInfoExtra_slow_apply(info);
138 if (type == ARG_BCO) {
141 Sp(0) = stg_apply_interp_info;
142 jump stg_yield_to_interpreter;
144 jump W_[stg_ap_stack_entries +
145 WDS(TO_W_(StgFunInfoExtra_fun_type(info)))];
149 /* -----------------------------------------------------------------------------
150 Entry Code for an AP (a PAP with arity zero).
152 The entry code is very similar to a PAP, except there are no
153 further arguments on the stack to worry about, so the stack check
154 is simpler. We must also push an update frame on the stack before
155 applying the function.
156 -------------------------------------------------------------------------- */
158 INFO_TABLE(stg_AP,/*special layout*/0,0,AP,"AP","AP")
165 Words = TO_W_(StgAP_n_args(ap));
168 * Check for stack overflow. IMPORTANT: use a _NP check here,
169 * because if the check fails, we might end up blackholing this very
170 * closure, in which case we must enter the blackhole on return rather
171 * than continuing to evaluate the now-defunct closure.
173 STK_CHK_NP(WDS(Words) + SIZEOF_StgUpdateFrame);
175 PUSH_UPD_FRAME(Sp - SIZEOF_StgUpdateFrame, R1);
176 Sp = Sp - SIZEOF_StgUpdateFrame - WDS(Words);
181 // Enter PAP cost centre
182 ENTER_CCS_PAP_CL(ap); // ToDo: ENTER_CC_AP_CL
187 p = ap + SIZEOF_StgHeader + OFFSET_StgAP_payload;
203 jump %GET_ENTRY(UNTAG(R1));
206 info = %GET_FUN_INFO(UNTAG(R1));
208 type = TO_W_(StgFunInfoExtra_fun_type(info));
209 if (type == ARG_GEN) {
210 jump StgFunInfoExtra_slow_apply(info);
212 if (type == ARG_GEN_BIG) {
213 jump StgFunInfoExtra_slow_apply(info);
215 if (type == ARG_BCO) {
218 Sp(0) = stg_apply_interp_info;
219 jump stg_yield_to_interpreter;
221 jump W_[stg_ap_stack_entries +
222 WDS(TO_W_(StgFunInfoExtra_fun_type(info)))];
226 /* AP_NOUPD is exactly like AP, except that no update frame is pushed.
227 Use for thunks that are guaranteed to be entered once only, such as
228 those generated by the byte-code compiler for inserting breakpoints. */
230 INFO_TABLE(stg_AP_NOUPD,/*special layout*/0,0,AP,"AP_NOUPD","AP_NOUPD")
237 Words = TO_W_(StgAP_n_args(ap));
240 * Check for stack overflow. IMPORTANT: use a _NP check here,
241 * because if the check fails, we might end up blackholing this very
242 * closure, in which case we must enter the blackhole on return rather
243 * than continuing to evaluate the now-defunct closure.
245 STK_CHK_NP(WDS(Words));
246 Sp = Sp - WDS(Words);
251 // Enter PAP cost centre
252 ENTER_CCS_PAP_CL(ap); // ToDo: ENTER_CC_AP_CL
257 p = ap + SIZEOF_StgHeader + OFFSET_StgAP_payload;
273 jump %GET_ENTRY(UNTAG(R1));
276 info = %GET_FUN_INFO(UNTAG(R1));
278 type = TO_W_(StgFunInfoExtra_fun_type(info));
279 if (type == ARG_GEN) {
280 jump StgFunInfoExtra_slow_apply(info);
282 if (type == ARG_GEN_BIG) {
283 jump StgFunInfoExtra_slow_apply(info);
285 if (type == ARG_BCO) {
288 Sp(0) = stg_apply_interp_info;
289 jump stg_yield_to_interpreter;
291 jump W_[stg_ap_stack_entries +
292 WDS(TO_W_(StgFunInfoExtra_fun_type(info)))];
296 /* -----------------------------------------------------------------------------
297 Entry Code for an AP_STACK.
299 Very similar to a PAP and AP. The layout is the same as PAP
300 and AP, except that the payload is a chunk of stack instead of
301 being described by the function's info table. Like an AP,
302 there are no further arguments on the stack to worry about.
303 However, the function closure (ap->fun) does not necessarily point
304 directly to a function, so we have to enter it using stg_ap_0.
305 -------------------------------------------------------------------------- */
307 INFO_TABLE(stg_AP_STACK,/*special layout*/0,0,AP_STACK,"AP_STACK","AP_STACK")
314 Words = StgAP_STACK_size(ap);
317 * Check for stack overflow. IMPORTANT: use a _NP check here,
318 * because if the check fails, we might end up blackholing this very
319 * closure, in which case we must enter the blackhole on return rather
320 * than continuing to evaluate the now-defunct closure.
322 STK_CHK_NP(WDS(Words) + SIZEOF_StgUpdateFrame + WDS(AP_STACK_SPLIM));
323 /* ensure there is at least AP_STACK_SPLIM words of headroom available
324 * after unpacking the AP_STACK. See bug #1466 */
326 PUSH_UPD_FRAME(Sp - SIZEOF_StgUpdateFrame, R1);
327 Sp = Sp - SIZEOF_StgUpdateFrame - WDS(Words);
332 // Enter PAP cost centre
333 ENTER_CCS_PAP_CL(ap); // ToDo: ENTER_CC_AP_CL
338 p = ap + SIZEOF_StgHeader + OFFSET_StgAP_STACK_payload;
351 R1 = StgAP_STACK_fun(ap);