1 /* -----------------------------------------------------------------------------
2 * $Id: StgCRun.c,v 1.36 2002/06/13 21:14:51 wolfgang Exp $
4 * (c) The GHC Team, 1998-2000
8 * To run an STG function from C land, call
10 * rv = StgRun(f,BaseReg);
12 * where "f" is the STG function to call, and BaseReg is the address of the
13 * RegTable for this run (we might have separate RegTables if we're running
14 * multiple threads on an SMP machine).
16 * In the end, "f" must JMP to StgReturn (defined below),
17 * passing the return-value "rv" in R1,
18 * to return to the caller of StgRun returning "rv" in
19 * the whatever way C returns a value.
21 * NOTE: StgRun/StgReturn do *NOT* load or store Hp or any
22 * other registers (other than saving the C callee-saves
23 * registers). Instead, the called function "f" must do that
26 * GCC will have assumed that pushing/popping of C-stack frames is
27 * going on when it generated its code, and used stack space
28 * accordingly. However, we actually {\em post-process away} all
29 * such stack-framery (see \tr{ghc/driver/ghc-asm.lprl}). Things will
30 * be OK however, if we initially make sure there are
31 * @RESERVED_C_STACK_BYTES@ on the C-stack to begin with, for local
34 * -------------------------------------------------------------------------- */
36 #include "PosixSource.h"
40 * We define the following (unused) global register variables, because for
41 * some reason gcc generates sub-optimal code for StgRun() on the Alpha
42 * (unnecessarily saving extra registers on the stack) if we don't.
44 * Why do it at the top of this file, rather than near StgRun() below? Because
45 * gcc doesn't let us define global register variables after any function
46 * definition has been read. Any point after #include "Stg.h" would be too
49 * We define alpha_EXTRA_CAREFUL here to save $s6, $f8 and $f9 -- registers
50 * that we don't use but which are callee-save registers. The __divq() routine
51 * in libc.a clobbers $s6.
54 #ifdef alpha_TARGET_ARCH
55 #define alpha_EXTRA_CAREFUL
56 register long fake_ra __asm__("$26");
57 register long fake_gp __asm__("$29");
58 #ifdef alpha_EXTRA_CAREFUL
59 register long fake_s6 __asm__("$15");
60 register double fake_f8 __asm__("$f8");
61 register double fake_f9 __asm__("$f9");
65 /* include Stg.h first because we want real machine regs in here: we
66 * have to get the value of R1 back from Stg land to C land intact.
78 #ifdef USE_MINIINTERPRETER
80 /* -----------------------------------------------------------------------------
81 any architecture (using miniinterpreter)
82 -------------------------------------------------------------------------- */
84 extern StgThreadReturnCode StgRun(StgFunPtr f, StgRegTable *basereg STG_UNUSED)
88 fprintf(stderr,"Jumping to ");
89 printPtr((P_)f); fflush(stdout);
92 f = (StgFunPtr) (f)();
94 return (StgThreadReturnCode)R1.i;
102 #else /* !USE_MINIINTERPRETER */
104 #ifdef LEADING_UNDERSCORE
105 #define STG_RETURN "_StgReturn"
107 #define STG_RETURN "StgReturn"
110 /* -----------------------------------------------------------------------------
112 -------------------------------------------------------------------------- */
114 #ifdef i386_TARGET_ARCH
117 StgRun(StgFunPtr f, StgRegTable *basereg) {
119 unsigned char space[ RESERVED_C_STACK_BYTES + 4*sizeof(void *) ];
120 StgThreadReturnCode r;
124 * save callee-saves registers on behalf of the STG code.
126 "movl %%esp, %%eax\n\t"
128 "movl %%ebx,0(%%eax)\n\t"
129 "movl %%esi,4(%%eax)\n\t"
130 "movl %%edi,8(%%eax)\n\t"
131 "movl %%ebp,12(%%eax)\n\t"
137 * grab the function argument from the stack, and jump to it.
142 ".global " STG_RETURN "\n"
145 "movl %%esi, %%eax\n\t" /* Return value in R1 */
148 * restore callee-saves registers. (Don't stomp on %%eax!)
150 "movl %%esp, %%edx\n\t"
152 "movl 0(%%edx),%%ebx\n\t" /* restore the registers saved above */
153 "movl 4(%%edx),%%esi\n\t"
154 "movl 8(%%edx),%%edi\n\t"
155 "movl 12(%%edx),%%ebp\n\t"
157 : "=&a" (r), "=m" (space)
158 : "m" (f), "m" (basereg), "i" (RESERVED_C_STACK_BYTES)
159 : "edx" /* stomps on %edx */
167 /* -----------------------------------------------------------------------------
171 OLD COMMENT from GHC-3.02:
173 We want tailjumps to be calls, because `call xxx' is the only Sparc
174 branch that allows an arbitrary label as a target. (Gcc's ``goto
175 *target'' construct ends up loading the label into a register and
176 then jumping, at the cost of two extra instructions for the 32-bit
179 When entering the threaded world, we stash our return address in a
180 known location so that \tr{%i7} is available as an extra
181 callee-saves register. Of course, we have to restore this when
182 coming out of the threaded world.
184 I hate this god-forsaken architecture. Since the top of the
185 reserved stack space is used for globals and the bottom is reserved
186 for outgoing arguments, we have to stick our return address
187 somewhere in the middle. Currently, I'm allowing 100 extra
188 outgoing arguments beyond the first 6. --JSM
190 Updated info (GHC 4.06): we don't appear to use %i7 any more, so
191 I'm not sure whether we still need to save it. Incedentally, what
192 does the last paragraph above mean when it says "the top of the
193 stack is used for globals"? What globals? --SDM
195 Updated info (GHC 4.08.2): not saving %i7 any more (see below).
196 -------------------------------------------------------------------------- */
198 #ifdef sparc_TARGET_ARCH
201 StgRun(StgFunPtr f, StgRegTable *basereg) {
203 unsigned char space[RESERVED_C_STACK_BYTES];
205 register void *i7 __asm__("%i7");
206 ((void **)(space))[100] = i7;
211 ".global " STG_RETURN "\n"
213 : : : "l0","l1","l2","l3","l4","l5","l6","l7");
214 /* we tell the C compiler that l0-l7 are clobbered on return to
215 * StgReturn, otherwise it tries to use these to save eg. the
216 * address of space[100] across the call. The correct thing
217 * to do would be to save all the callee-saves regs, but we
218 * can't be bothered to do that.
220 * The code that gcc generates for this little fragment is now
221 * terrible. We could do much better by coding it directly in
225 /* updated 4.08.2: we don't save %i7 in the middle of the reserved
226 * space any more, since gcc tries to save its address across the
227 * call to f(), this gets clobbered in STG land and we end up
228 * dereferencing a bogus pointer in StgReturn.
230 __asm__ volatile ("ld %1,%0"
231 : "=r" (i7) : "m" (((void **)(space))[100]));
233 return (StgThreadReturnCode)R1.i;
238 /* -----------------------------------------------------------------------------
241 "The stack pointer (SP) must at all times denote an address that has octaword
242 alignment. (This restriction has the side effect that the in-memory portion
243 of the argument list, if any, will start on an octaword boundary.) Note that
244 the stack grows toward lower addresses. During a procedure invocation, SP
245 can never be set to a value that is higher than the value of SP at entry to
246 that procedure invocation.
248 "The contents of the stack, located above the portion of the argument list
249 (if any) that is passed in memory, belong to the calling procedure. Because
250 they are part of the calling procedure, they should not be read or written
251 by the called procedure, except as specified by indirect arguments or
252 language-controlled up-level references.
254 "The SP value might be used by the hardware when raising exceptions and
255 asynchronous interrupts. It must be assumed that the contents of the stack
256 below the current SP value and within the stack for the current thread are
257 continually and unpredictably modified, as specified in the _Alpha
258 Architecture Reference Manual_, and as a result of asynchronous software
261 -- Compaq Computer Corporation, Houston. Tru64 UNIX Calling Standard for
262 Alpha Systems, 5.1 edition, August 2000, section 3.2.1. http://www.
263 tru64unix.compaq.com/docs/base_doc/DOCUMENTATION/V51_PDF/ARH9MBTE.PDF
264 -------------------------------------------------------------------------- */
266 #ifdef alpha_TARGET_ARCH
269 StgRun(StgFunPtr f, StgRegTable *basereg)
271 register long real_ra __asm__("$26"); volatile long save_ra;
272 register long real_gp __asm__("$29"); volatile long save_gp;
274 register long real_s0 __asm__("$9" ); volatile long save_s0;
275 register long real_s1 __asm__("$10"); volatile long save_s1;
276 register long real_s2 __asm__("$11"); volatile long save_s2;
277 register long real_s3 __asm__("$12"); volatile long save_s3;
278 register long real_s4 __asm__("$13"); volatile long save_s4;
279 register long real_s5 __asm__("$14"); volatile long save_s5;
280 #ifdef alpha_EXTRA_CAREFUL
281 register long real_s6 __asm__("$15"); volatile long save_s6;
284 register double real_f2 __asm__("$f2"); volatile double save_f2;
285 register double real_f3 __asm__("$f3"); volatile double save_f3;
286 register double real_f4 __asm__("$f4"); volatile double save_f4;
287 register double real_f5 __asm__("$f5"); volatile double save_f5;
288 register double real_f6 __asm__("$f6"); volatile double save_f6;
289 register double real_f7 __asm__("$f7"); volatile double save_f7;
290 #ifdef alpha_EXTRA_CAREFUL
291 register double real_f8 __asm__("$f8"); volatile double save_f8;
292 register double real_f9 __asm__("$f9"); volatile double save_f9;
295 register StgFunPtr real_pv __asm__("$27");
297 StgThreadReturnCode ret;
308 #ifdef alpha_EXTRA_CAREFUL
318 #ifdef alpha_EXTRA_CAREFUL
325 __asm__ volatile( "lda $30,-%0($30)" "\n"
326 "\t" "jmp ($27)" "\n"
328 ".globl " STG_RETURN "\n"
330 "\t" "lda $30,%0($30)" "\n"
331 : : "K" (RESERVED_C_STACK_BYTES));
341 #ifdef alpha_EXTRA_CAREFUL
351 #ifdef alpha_EXTRA_CAREFUL
362 #endif /* alpha_TARGET_ARCH */
364 /* -----------------------------------------------------------------------------
366 -------------------------------------------------------------------------- */
368 #ifdef hppa1_1_TARGET_ARCH
371 StgRun(StgFunPtr f, StgRegTable *basereg)
373 StgChar space[RESERVED_C_STACK_BYTES+16*sizeof(long)+10*sizeof(double)];
374 StgThreadReturnCode ret;
376 __asm__ volatile ("ldo %0(%%r30),%%r19\n"
377 "\tstw %%r3, 0(0,%%r19)\n"
378 "\tstw %%r4, 4(0,%%r19)\n"
379 "\tstw %%r5, 8(0,%%r19)\n"
380 "\tstw %%r6,12(0,%%r19)\n"
381 "\tstw %%r7,16(0,%%r19)\n"
382 "\tstw %%r8,20(0,%%r19)\n"
383 "\tstw %%r9,24(0,%%r19)\n"
384 "\tstw %%r10,28(0,%%r19)\n"
385 "\tstw %%r11,32(0,%%r19)\n"
386 "\tstw %%r12,36(0,%%r19)\n"
387 "\tstw %%r13,40(0,%%r19)\n"
388 "\tstw %%r14,44(0,%%r19)\n"
389 "\tstw %%r15,48(0,%%r19)\n"
390 "\tstw %%r16,52(0,%%r19)\n"
391 "\tstw %%r17,56(0,%%r19)\n"
392 "\tstw %%r18,60(0,%%r19)\n"
393 "\tldo 80(%%r19),%%r19\n"
394 "\tfstds %%fr12,-16(0,%%r19)\n"
395 "\tfstds %%fr13, -8(0,%%r19)\n"
396 "\tfstds %%fr14, 0(0,%%r19)\n"
397 "\tfstds %%fr15, 8(0,%%r19)\n"
398 "\tldo 32(%%r19),%%r19\n"
399 "\tfstds %%fr16,-16(0,%%r19)\n"
400 "\tfstds %%fr17, -8(0,%%r19)\n"
401 "\tfstds %%fr18, 0(0,%%r19)\n"
402 "\tfstds %%fr19, 8(0,%%r19)\n"
403 "\tldo 32(%%r19),%%r19\n"
404 "\tfstds %%fr20,-16(0,%%r19)\n"
405 "\tfstds %%fr21, -8(0,%%r19)\n" : :
406 "n" (-(116 * sizeof(long) + 10 * sizeof(double))) : "%r19"
411 __asm__ volatile (".align 4\n"
412 "\t.EXPORT " STG_RETURN ",CODE\n"
413 "\t.EXPORT " STG_RETURN ",ENTRY,PRIV_LEV=3\n"
415 /* "\tldo %0(%%r3),%%r19\n" */
416 "\tldo %1(%%r30),%%r19\n"
417 "\tcopy %%r11, %0\n" /* save R1 */
418 "\tldw 0(0,%%r19),%%r3\n"
419 "\tldw 4(0,%%r19),%%r4\n"
420 "\tldw 8(0,%%r19),%%r5\n"
421 "\tldw 12(0,%%r19),%%r6\n"
422 "\tldw 16(0,%%r19),%%r7\n"
423 "\tldw 20(0,%%r19),%%r8\n"
424 "\tldw 24(0,%%r19),%%r9\n"
425 "\tldw 28(0,%%r19),%%r10\n"
426 "\tldw 32(0,%%r19),%%r11\n"
427 "\tldw 36(0,%%r19),%%r12\n"
428 "\tldw 40(0,%%r19),%%r13\n"
429 "\tldw 44(0,%%r19),%%r14\n"
430 "\tldw 48(0,%%r19),%%r15\n"
431 "\tldw 52(0,%%r19),%%r16\n"
432 "\tldw 56(0,%%r19),%%r17\n"
433 "\tldw 60(0,%%r19),%%r18\n"
434 "\tldo 80(%%r19),%%r19\n"
435 "\tfldds -16(0,%%r19),%%fr12\n"
436 "\tfldds -8(0,%%r19),%%fr13\n"
437 "\tfldds 0(0,%%r19),%%fr14\n"
438 "\tfldds 8(0,%%r19),%%fr15\n"
439 "\tldo 32(%%r19),%%r19\n"
440 "\tfldds -16(0,%%r19),%%fr16\n"
441 "\tfldds -8(0,%%r19),%%fr17\n"
442 "\tfldds 0(0,%%r19),%%fr18\n"
443 "\tfldds 8(0,%%r19),%%fr19\n"
444 "\tldo 32(%%r19),%%r19\n"
445 "\tfldds -16(0,%%r19),%%fr20\n"
446 "\tfldds -8(0,%%r19),%%fr21\n"
448 : "n" (-(116 * sizeof(long) + 10 * sizeof(double)))
455 #endif /* hppa1_1_TARGET_ARCH */
457 /* -----------------------------------------------------------------------------
460 Everything is in assembler, so we don't have to deal with GCC...
462 -------------------------------------------------------------------------- */
464 #ifdef powerpc_TARGET_ARCH
466 extern StgThreadReturnCode StgRun(StgFunPtr f, StgRegTable *basereg);
468 static void StgRunIsImplementedInAssembler(void)
474 "\tbl saveFP # f14\n"
475 "\tstmw r14,-216(r1)\n"
476 "\tstwu r1,-8480(r1)\n"
480 ".globl _StgReturn\n"
484 "\tlmw r14,-216(r1)\n"
486 ); /* RESERVED_C_STACK_BYTES + stack frame size == 8192 + 288 == 8480 */
491 /* -----------------------------------------------------------------------------
494 Again, in assembler - so we can fiddle with the register stack, and because
495 gcc doesn't handle asm-clobbered callee-saves correctly.
497 loc0 - loc15: preserved locals
498 loc16 - loc28: STG registers
501 -------------------------------------------------------------------------- */
503 #ifdef ia64_TARGET_ARCH
505 /* the memory stack is rarely used, so 16K is excessive */
506 #undef RESERVED_C_STACK_BYTES
507 #define RESERVED_C_STACK_BYTES 1024
509 static void StgRunIsImplementedInAssembler(void)
514 "\talloc loc29 = ar.pfs, 0, 31, 8, 0\n" /* setup register frame */
515 "\tld8 r18 = [r32],8\n" /* get procedure address */
516 "\tadds sp = -%0, sp ;;\n" /* setup stack */
517 "\tld8 gp = [r32]\n" /* get procedure GP */
518 "\tadds r16 = %0-(6*16), sp\n"
519 "\tadds r17 = %0-(5*16), sp ;;\n"
520 "\tstf.spill [r16] = f16,32\n" /* spill callee-saved fp regs */
521 "\tstf.spill [r17] = f17,32\n"
522 "\tmov b6 = r18 ;;\n" /* set target address */
523 "\tstf.spill [r16] = f18,32\n"
524 "\tstf.spill [r17] = f19,32\n"
525 "\tmov loc30 = b0 ;;\n" /* save return address */
526 "\tstf.spill [r16] = f20,32\n"
527 "\tstf.spill [r17] = f21,32\n"
528 "\tbr.few b6 ;;\n" /* branch to function */
529 ".global StgReturn\n"
531 "\tmov r8 = loc16\n" /* return value in r8 */
532 "\tadds r16 = %0-(6*16), sp\n"
533 "\tadds r17 = %0-(5*16), sp ;;\n"
534 "\tldf.fill f16 = [r16],32\n" /* start restoring fp regs */
535 "\tldf.fill f17 = [r17],32\n"
536 "\tmov ar.pfs = loc29 ;;\n" /* restore register frame */
537 "\tldf.fill f18 = [r16],32\n"
538 "\tldf.fill f19 = [r17],32\n"
539 "\tmov b0 = loc30 ;;\n" /* restore return address */
540 "\tldf.fill f20 = [r16],32\n"
541 "\tldf.fill f21 = [r17],32\n"
542 "\tadds sp = %0, sp\n" /* restore stack */
543 "\tbr.ret.sptk.many b0 ;;\n" /* return */
544 : : "i"(RESERVED_C_STACK_BYTES + 6*16));
549 #endif /* !USE_MINIINTERPRETER */