summaryrefslogtreecommitdiff
path: root/rts/Apply.cmm
blob: 149a320f2579b6e6b130bdb8855a9f9ae47b794d (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
/* -----------------------------------------------------------------------------
 *
 * (c) The University of Glasgow 2004
 *
 * Application-related bits.
 *
 * This file is written in a subset of C--, extended with various
 * features specific to GHC.  It is compiled by GHC directly.  For the
 * syntax of .cmm files, see the parser in ghc/compiler/cmm/CmmParse.y.
 *
 * -------------------------------------------------------------------------- */

#include "Cmm.h"

/* ----------------------------------------------------------------------------
 * Evaluate a closure and return it.
 *
 * There isn't an info table / return address version of stg_ap_0, because
 * everything being returned is guaranteed evaluated, so it would be a no-op.
 */

STRING(stg_ap_0_ret_str,"stg_ap_0_ret... ")

stg_ap_0_fast ( P_ fun )
{
    IF_DEBUG(apply,
        ccall debugBelch(stg_ap_0_ret_str);
        ccall printClosure(R1 "ptr"));

    IF_DEBUG(sanity,
        ccall checkStackFrame(Sp "ptr"));

    ENTER(fun);
}

/* -----------------------------------------------------------------------------
   Entry Code for a PAP.

   This entry code is *only* called by one of the stg_ap functions.
   On entry: Sp points to the remaining arguments on the stack.  If
   the stack check fails, we can just push the PAP on the stack and
   return to the scheduler.

   On entry: R1 points to the PAP.  The rest of the function's
   arguments (apart from those that are already in the PAP) are on the
   stack, starting at Sp(0).  R2 contains an info table which
   describes these arguments, which is used in the event that the
   stack check in the entry code below fails.  The info table is
   currently one of the stg_ap_*_ret family, as this code is always
   entered from those functions.

   The idea is to copy the chunk of stack from the PAP object onto the
   stack / into registers, and enter the function.
   -------------------------------------------------------------------------- */

INFO_TABLE(stg_PAP,/*special layout*/0,0,PAP,"PAP","PAP")
{  ccall barf("PAP object entered!") never returns; }

stg_PAP_apply /* no args => explicit stack */
{
  W_ Words;
  W_ pap;

  pap = R1;

  Words = TO_W_(StgPAP_n_args(pap));

  //
  // Check for stack overflow and bump the stack pointer.
  // We have a hand-rolled stack check fragment here, because none of
  // the canned ones suit this situation.
  //
  if (Sp - (WDS(Words) + 2/* see ARG_BCO below */) < SpLim) {
      // there is a return address in R2 in the event of a
      // stack check failure.  The various stg_apply functions arrange
      // this before calling stg_PAP_entry.
      Sp_adj(-1);
      Sp(0) = R2;
      jump stg_gc_unpt_r1 [R1];
  }
  Sp_adj(-Words);

  // profiling
  TICK_ENT_PAP();
  LDV_ENTER(pap);
#ifdef PROFILING
  ccall enterFunCCS(BaseReg "ptr", StgHeader_ccs(pap) "ptr");
#endif

  // Reload the stack
  W_ i;
  W_ p;
  p = pap + SIZEOF_StgHeader + OFFSET_StgPAP_payload;
  i = 0;
for:
  if (i < Words) {
    Sp(i) = W_[p];
    p = p + WDS(1);
    i = i + 1;
    goto for;
  }

  R1 = StgPAP_fun(pap);

/* DEBUGGING CODE, ensures that arity 1 and 2 functions are entered tagged
  if (TO_W_(StgFunInfoExtra_arity(%FUN_INFO(%INFO_PTR(UNTAG(R1))))) == 1 ) {
    if (GETTAG(R1)!=1) {
        W_[0]=1;
    }
  }

  if (TO_W_(StgFunInfoExtra_arity(%FUN_INFO(%INFO_PTR(UNTAG(R1))))) == 2 ) {
    if (GETTAG(R1)!=2) {
        W_[0]=1;
    }
  }
*/

  // Off we go!
  TICK_ENT_VIA_NODE();

#ifdef NO_ARG_REGS
  jump %GET_ENTRY(UNTAG(R1)) [R1];
#else
      W_ info;
      info = %GET_FUN_INFO(UNTAG(R1));
      W_ type;
      type = TO_W_(StgFunInfoExtra_fun_type(info));
      if (type == ARG_GEN) {
          jump StgFunInfoExtra_slow_apply(info) [R1];
      }
      if (type == ARG_GEN_BIG) {
          jump StgFunInfoExtra_slow_apply(info) [R1];
      }
      if (type == ARG_BCO) {
          Sp_adj(-2);
          Sp(1) = R1;
          Sp(0) = stg_apply_interp_info;
          jump stg_yield_to_interpreter [];
      }
      jump W_[stg_ap_stack_entries +
                WDS(TO_W_(StgFunInfoExtra_fun_type(info)))] [R1];
#endif
}

/* -----------------------------------------------------------------------------
   Entry Code for an AP (a PAP with arity zero).

   The entry code is very similar to a PAP, except there are no
   further arguments on the stack to worry about, so the stack check
   is simpler.  We must also push an update frame on the stack before
   applying the function.
   -------------------------------------------------------------------------- */

INFO_TABLE(stg_AP,/*special layout*/0,0,AP,"AP","AP")
 /* no args => explicit stack */
{
  W_ Words;
  W_ ap;

  ap = R1;

  Words = TO_W_(StgAP_n_args(ap));

  /*
   * Check for stack overflow.  IMPORTANT: use a _ENTER check here,
   * because if the check fails, we might end up blackholing this very
   * closure, in which case we must enter the blackhole on return rather
   * than continuing to evaluate the now-defunct closure.
   */
  STK_CHK_ENTER(WDS(Words) +
                SIZEOF_StgUpdateFrame +
                2/* see ARG_BCO below */, R1);

  PUSH_UPD_FRAME(Sp - SIZEOF_StgUpdateFrame, R1);
  Sp = Sp - SIZEOF_StgUpdateFrame - WDS(Words);

  TICK_ENT_AP();
  LDV_ENTER(ap);
  ENTER_CCS_THUNK(ap);

  // Reload the stack
  W_ i;
  W_ p;
  p = ap + SIZEOF_StgHeader + OFFSET_StgAP_payload;
  i = 0;
for:
  if (i < Words) {
    Sp(i) = W_[p];
    p = p + WDS(1);
    i = i + 1;
    goto for;
  }

  R1 = StgAP_fun(ap);

  // Off we go!
  TICK_ENT_VIA_NODE();

#ifdef NO_ARG_REGS
  jump %GET_ENTRY(UNTAG(R1)) [R1];
#else
      W_ info;
      info = %GET_FUN_INFO(UNTAG(R1));
      W_ type;
      type = TO_W_(StgFunInfoExtra_fun_type(info));
      if (type == ARG_GEN) {
          jump StgFunInfoExtra_slow_apply(info) [R1];
      }
      if (type == ARG_GEN_BIG) {
          jump StgFunInfoExtra_slow_apply(info) [R1];
      }
      if (type == ARG_BCO) {
          Sp_adj(-2);
          Sp(1) = R1;
          Sp(0) = stg_apply_interp_info;
          jump stg_yield_to_interpreter [];
      }
      jump W_[stg_ap_stack_entries +
                WDS(TO_W_(StgFunInfoExtra_fun_type(info)))] [R1];
#endif
}

/* AP_NOUPD is exactly like AP, except that no update frame is pushed.
   Use for thunks that are guaranteed to be entered once only, such as
   those generated by the byte-code compiler for inserting breakpoints. */

INFO_TABLE(stg_AP_NOUPD,/*special layout*/0,0,AP,"AP_NOUPD","AP_NOUPD")
   /* no args => explicit stack */
{
  W_ Words;
  W_ ap;

  ap = R1;

  Words = TO_W_(StgAP_n_args(ap));

  /*
   * Check for stack overflow.  IMPORTANT: use a _ENTER check here,
   * because if the check fails, we might end up blackholing this very
   * closure, in which case we must enter the blackhole on return rather
   * than continuing to evaluate the now-defunct closure.
   */
  STK_CHK_ENTER(WDS(Words) +
                2/* see ARG_BCO below */, R1);
  Sp = Sp - WDS(Words);

  TICK_ENT_AP();
  LDV_ENTER(ap);
  ENTER_CCS_THUNK(ap);

  // Reload the stack
  W_ i;
  W_ p;
  p = ap + SIZEOF_StgHeader + OFFSET_StgAP_payload;
  i = 0;
for:
  if (i < Words) {
    Sp(i) = W_[p];
    p = p + WDS(1);
    i = i + 1;
    goto for;
  }

  R1 = StgAP_fun(ap);

  // Off we go!
  TICK_ENT_VIA_NODE();

#ifdef NO_ARG_REGS
  jump %GET_ENTRY(UNTAG(R1)) [R1];
#else
      W_ info;
      info = %GET_FUN_INFO(UNTAG(R1));
      W_ type;
      type = TO_W_(StgFunInfoExtra_fun_type(info));
      if (type == ARG_GEN) {
          jump StgFunInfoExtra_slow_apply(info) [R1];
      }
      if (type == ARG_GEN_BIG) {
          jump StgFunInfoExtra_slow_apply(info) [R1];
      }
      if (type == ARG_BCO) {
          Sp_adj(-2);
          Sp(1) = R1;
          Sp(0) = stg_apply_interp_info;
          jump stg_yield_to_interpreter [];
      }
      jump W_[stg_ap_stack_entries +
                WDS(TO_W_(StgFunInfoExtra_fun_type(info)))] [R1];
#endif
}

/* -----------------------------------------------------------------------------
   Entry Code for an AP_STACK.

   Very similar to a PAP and AP.  The layout is the same as PAP
   and AP, except that the payload is a chunk of stack instead of
   being described by the function's info table.  Like an AP,
   there are no further arguments on the stack to worry about.
   However, the function closure (ap->fun) does not necessarily point
   directly to a function, so we have to enter it using stg_ap_0.
   -------------------------------------------------------------------------- */

INFO_TABLE(stg_AP_STACK,/*special layout*/0,0,AP_STACK,"AP_STACK","AP_STACK")
  /* no args => explicit stack */
{
  W_ Words;
  W_ ap;

  ap = R1;

  Words = StgAP_STACK_size(ap);

  /*
   * Check for stack overflow.  IMPORTANT: use a _ENTER check here,
   * because if the check fails, we might end up blackholing this very
   * closure, in which case we must enter the blackhole on return rather
   * than continuing to evaluate the now-defunct closure.
   */
  STK_CHK_ENTER(WDS(Words) + SIZEOF_StgUpdateFrame + WDS(AP_STACK_SPLIM), R1);
  /* ensure there is at least AP_STACK_SPLIM words of headroom available
   * after unpacking the AP_STACK. See bug #1466 */

  PUSH_UPD_FRAME(Sp - SIZEOF_StgUpdateFrame, R1);
  Sp = Sp - SIZEOF_StgUpdateFrame - WDS(Words);

  TICK_ENT_AP();
  LDV_ENTER(ap);
  ENTER_CCS_THUNK(ap);

  // Reload the stack
  W_ i;
  W_ p;
  p = ap + SIZEOF_StgHeader + OFFSET_StgAP_STACK_payload;
  i = 0;
for:
  if (i < Words) {
    Sp(i) = W_[p];
    p = p + WDS(1);
    i = i + 1;
    goto for;
  }

  // Off we go!
  TICK_ENT_VIA_NODE();

  R1 = StgAP_STACK_fun(ap);

  ENTER_R1();
}

/* -----------------------------------------------------------------------------
   AP_STACK_NOUPD - exactly like AP_STACK, but doesn't push an update frame.
   -------------------------------------------------------------------------- */

INFO_TABLE(stg_AP_STACK_NOUPD,/*special layout*/0,0,AP_STACK,
                                        "AP_STACK_NOUPD","AP_STACK_NOUPD")
   /* no args => explicit stack */
{
  W_ Words;
  W_ ap;

  ap = R1;

  Words = StgAP_STACK_size(ap);

  /*
   * Check for stack overflow.  IMPORTANT: use a _NP check here,
   * because if the check fails, we might end up blackholing this very
   * closure, in which case we must enter the blackhole on return rather
   * than continuing to evaluate the now-defunct closure.
   */
  STK_CHK_ENTER(WDS(Words) + WDS(AP_STACK_SPLIM), R1);
  /* ensure there is at least AP_STACK_SPLIM words of headroom available
   * after unpacking the AP_STACK. See bug #1466 */

  Sp = Sp - WDS(Words);

  TICK_ENT_AP();
  LDV_ENTER(ap);
  ENTER_CCS_THUNK(ap);

  // Reload the stack
  W_ i;
  W_ p;
  p = ap + SIZEOF_StgHeader + OFFSET_StgAP_STACK_payload;
  i = 0;
for:
  if (i < Words) {
    Sp(i) = W_[p];
    p = p + WDS(1);
    i = i + 1;
    goto for;
  }

  // Off we go!
  TICK_ENT_VIA_NODE();

  R1 = StgAP_STACK_fun(ap);

  ENTER_R1();
}