1 /* -----------------------------------------------------------------------------
3 * (c) The GHC Team, 1998-2003
7 * To run an STG function from C land, call
9 * rv = StgRun(f,BaseReg);
11 * where "f" is the STG function to call, and BaseReg is the address of the
12 * RegTable for this run (we might have separate RegTables if we're running
13 * multiple threads on an SMP machine).
15 * In the end, "f" must JMP to StgReturn (defined below),
16 * passing the return-value "rv" in R1,
17 * to return to the caller of StgRun returning "rv" in
18 * the whatever way C returns a value.
20 * NOTE: StgRun/StgReturn do *NOT* load or store Hp or any
21 * other registers (other than saving the C callee-saves
22 * registers). Instead, the called function "f" must do that
25 * GCC will have assumed that pushing/popping of C-stack frames is
26 * going on when it generated its code, and used stack space
27 * accordingly. However, we actually {\em post-process away} all
28 * such stack-framery (see \tr{ghc/driver/ghc-asm.lprl}). Things will
29 * be OK however, if we initially make sure there are
30 * @RESERVED_C_STACK_BYTES@ on the C-stack to begin with, for local
33 * -------------------------------------------------------------------------- */
35 #include "PosixSource.h"
39 * We define the following (unused) global register variables, because for
40 * some reason gcc generates sub-optimal code for StgRun() on the Alpha
41 * (unnecessarily saving extra registers on the stack) if we don't.
43 * Why do it at the top of this file, rather than near StgRun() below? Because
44 * gcc doesn't let us define global register variables after any function
45 * definition has been read. Any point after #include "Stg.h" would be too
48 * We define alpha_EXTRA_CAREFUL here to save $s6, $f8 and $f9 -- registers
49 * that we don't use but which are callee-save registers. The __divq() routine
50 * in libc.a clobbers $s6.
52 #include "ghcconfig.h"
53 #ifdef alpha_HOST_ARCH
54 #define alpha_EXTRA_CAREFUL
55 register long fake_ra __asm__("$26");
56 register long fake_gp __asm__("$29");
57 #ifdef alpha_EXTRA_CAREFUL
58 register long fake_s6 __asm__("$15");
59 register double fake_f8 __asm__("$f8");
60 register double fake_f9 __asm__("$f9");
64 /* include Stg.h first because we want real machine regs in here: we
65 * have to get the value of R1 back from Stg land to C land intact.
71 #include "OSThreads.h"
72 #include "Capability.h"
79 #ifdef USE_MINIINTERPRETER
81 /* -----------------------------------------------------------------------------
82 any architecture (using miniinterpreter)
83 -------------------------------------------------------------------------- */
85 StgRegTable * StgRun(StgFunPtr f, StgRegTable *basereg STG_UNUSED)
88 /* XXX Disabled due to RtsFlags[]/RtsFlags mismatch
90 debugBelch("Jumping to ");
91 printPtr((P_)f); fflush(stdout);
95 f = (StgFunPtr) (f)();
97 return (StgRegTable *)R1.p;
100 StgFunPtr StgReturn(void)
105 #else /* !USE_MINIINTERPRETER */
107 #ifdef LEADING_UNDERSCORE
108 #define STG_RETURN "_StgReturn"
110 #define STG_RETURN "StgReturn"
113 /* -----------------------------------------------------------------------------
115 -------------------------------------------------------------------------- */
117 #ifdef i386_HOST_ARCH
119 #ifdef darwin_TARGET_OS
120 #define STG_GLOBAL ".globl "
122 #define STG_GLOBAL ".global "
126 StgRun(StgFunPtr f, StgRegTable *basereg) {
128 unsigned char space[ RESERVED_C_STACK_BYTES + 4*sizeof(void *) ];
133 * save callee-saves registers on behalf of the STG code.
135 "movl %%esp, %%eax\n\t"
137 "movl %%ebx,0(%%eax)\n\t"
138 "movl %%esi,4(%%eax)\n\t"
139 "movl %%edi,8(%%eax)\n\t"
140 "movl %%ebp,12(%%eax)\n\t"
146 * grab the function argument from the stack
152 * The stack pointer has to be aligned to a multiple of 16 bytes at
153 * this point. This works out correctly with gcc 4.0.1, but it might
154 * break at any time in the future. TODO: Make this future-proof.
162 STG_GLOBAL STG_RETURN "\n"
165 "movl %%esi, %%eax\n\t" /* Return value in R1 */
168 * restore callee-saves registers. (Don't stomp on %%eax!)
170 "movl %%esp, %%edx\n\t"
172 "movl 0(%%edx),%%ebx\n\t" /* restore the registers saved above */
173 "movl 4(%%edx),%%esi\n\t"
174 "movl 8(%%edx),%%edi\n\t"
175 "movl 12(%%edx),%%ebp\n\t"
177 : "=&a" (r), "=m" (space)
178 : "m" (f), "m" (basereg), "i" (RESERVED_C_STACK_BYTES)
179 : "edx" /* stomps on %edx */
187 /* ----------------------------------------------------------------------------
188 x86-64 is almost the same as plain x86.
190 I've done it using entirely inline assembler, because I couldn't
191 get gcc to generate the correct subtraction from %rsp by using
192 the local array variable trick. It didn't seem to reserve
193 enough space. Oh well, it's not much harder this way.
195 ------------------------------------------------------------------------- */
197 #ifdef x86_64_HOST_ARCH
199 extern StgRegTable * StgRun(StgFunPtr f, StgRegTable *basereg);
201 static void GNUC3_ATTRIBUTE(used)
202 StgRunIsImplementedInAssembler(void)
206 * save callee-saves registers on behalf of the STG code.
211 "movq %%rsp, %%rax\n\t"
212 "addq %0-48, %%rax\n\t"
213 "movq %%rbx,0(%%rax)\n\t"
214 "movq %%rbp,8(%%rax)\n\t"
215 "movq %%r12,16(%%rax)\n\t"
216 "movq %%r13,24(%%rax)\n\t"
217 "movq %%r14,32(%%rax)\n\t"
218 "movq %%r15,40(%%rax)\n\t"
222 "movq %%rsi,%%r13\n\t"
224 * grab the function argument from the stack, and jump to it.
226 "movq %%rdi,%%rax\n\t"
229 ".global " STG_RETURN "\n"
232 "movq %%rbx, %%rax\n\t" /* Return value in R1 */
235 * restore callee-saves registers. (Don't stomp on %%rax!)
237 "movq %%rsp, %%rdx\n\t"
238 "addq %0-48, %%rdx\n\t"
239 "movq 0(%%rdx),%%rbx\n\t" /* restore the registers saved above */
240 "movq 8(%%rdx),%%rbp\n\t"
241 "movq 16(%%rdx),%%r12\n\t"
242 "movq 24(%%rdx),%%r13\n\t"
243 "movq 32(%%rdx),%%r14\n\t"
244 "movq 40(%%rdx),%%r15\n\t"
248 : : "i"(RESERVED_C_STACK_BYTES+48+8 /*stack frame size*/));
252 The x86_64 ABI specifies that on a procedure call, %rsp is
253 aligned on a 16-byte boundary + 8. That is, the first
254 argument on the stack after the return address will be
257 Which should be fine: RESERVED_C_STACK_BYTES+48 is a multiple
260 BUT... when we do a C-call from STG land, gcc likes to put the
261 stack alignment adjustment in the prolog. eg. if we're calling
262 a function with arguments in regs, gcc will insert 'subq $8,%rsp'
263 in the prolog, to keep %rsp aligned (the return address is 8
264 bytes, remember). The mangler throws away the prolog, so we
265 lose the stack alignment.
267 The hack is to add this extra 8 bytes to our %rsp adjustment
268 here, so that throughout STG code, %rsp is 16-byte aligned,
271 A quick way to see if this is wrong is to compile this code:
273 main = System.Exit.exitWith ExitSuccess
275 And run it with +RTS -sstderr. The stats code in the RTS, in
276 particular statsPrintf(), relies on the stack alignment because
277 it saves the %xmm regs on the stack, so it'll fall over if the
278 stack isn't aligned, and calling exitWith from Haskell invokes
279 shutdownHaskellAndExit using a C call.
281 Future gcc releases will almost certainly break this hack...
287 /* -----------------------------------------------------------------------------
291 OLD COMMENT from GHC-3.02:
293 We want tailjumps to be calls, because `call xxx' is the only Sparc
294 branch that allows an arbitrary label as a target. (Gcc's ``goto
295 *target'' construct ends up loading the label into a register and
296 then jumping, at the cost of two extra instructions for the 32-bit
299 When entering the threaded world, we stash our return address in a
300 known location so that \tr{%i7} is available as an extra
301 callee-saves register. Of course, we have to restore this when
302 coming out of the threaded world.
304 I hate this god-forsaken architecture. Since the top of the
305 reserved stack space is used for globals and the bottom is reserved
306 for outgoing arguments, we have to stick our return address
307 somewhere in the middle. Currently, I'm allowing 100 extra
308 outgoing arguments beyond the first 6. --JSM
310 Updated info (GHC 4.06): we don't appear to use %i7 any more, so
311 I'm not sure whether we still need to save it. Incedentally, what
312 does the last paragraph above mean when it says "the top of the
313 stack is used for globals"? What globals? --SDM
315 Updated info (GHC 4.08.2): not saving %i7 any more (see below).
316 -------------------------------------------------------------------------- */
318 #ifdef sparc_HOST_ARCH
321 StgRun(StgFunPtr f, StgRegTable *basereg) {
323 unsigned char space[RESERVED_C_STACK_BYTES];
325 register void *i7 __asm__("%i7");
326 ((void **)(space))[100] = i7;
331 ".global " STG_RETURN "\n"
333 : : "p" (space) : "l0","l1","l2","l3","l4","l5","l6","l7");
334 /* we tell the C compiler that l0-l7 are clobbered on return to
335 * StgReturn, otherwise it tries to use these to save eg. the
336 * address of space[100] across the call. The correct thing
337 * to do would be to save all the callee-saves regs, but we
338 * can't be bothered to do that.
340 * We also explicitly mark space as used since gcc eliminates it
343 * The code that gcc generates for this little fragment is now
344 * terrible. We could do much better by coding it directly in
348 /* updated 4.08.2: we don't save %i7 in the middle of the reserved
349 * space any more, since gcc tries to save its address across the
350 * call to f(), this gets clobbered in STG land and we end up
351 * dereferencing a bogus pointer in StgReturn.
353 __asm__ volatile ("ld %1,%0"
354 : "=r" (i7) : "m" (((void **)(space))[100]));
356 return (StgRegTable *)R1.i;
361 /* -----------------------------------------------------------------------------
364 "The stack pointer (SP) must at all times denote an address that has octaword
365 alignment. (This restriction has the side effect that the in-memory portion
366 of the argument list, if any, will start on an octaword boundary.) Note that
367 the stack grows toward lower addresses. During a procedure invocation, SP
368 can never be set to a value that is higher than the value of SP at entry to
369 that procedure invocation.
371 "The contents of the stack, located above the portion of the argument list
372 (if any) that is passed in memory, belong to the calling procedure. Because
373 they are part of the calling procedure, they should not be read or written
374 by the called procedure, except as specified by indirect arguments or
375 language-controlled up-level references.
377 "The SP value might be used by the hardware when raising exceptions and
378 asynchronous interrupts. It must be assumed that the contents of the stack
379 below the current SP value and within the stack for the current thread are
380 continually and unpredictably modified, as specified in the _Alpha
381 Architecture Reference Manual_, and as a result of asynchronous software
384 -- Compaq Computer Corporation, Houston. Tru64 UNIX Calling Standard for
385 Alpha Systems, 5.1 edition, August 2000, section 3.2.1. http://www.
386 tru64unix.compaq.com/docs/base_doc/DOCUMENTATION/V51_PDF/ARH9MBTE.PDF
387 -------------------------------------------------------------------------- */
389 #ifdef alpha_HOST_ARCH
392 StgRun(StgFunPtr f, StgRegTable *basereg)
394 register long real_ra __asm__("$26"); volatile long save_ra;
395 register long real_gp __asm__("$29"); volatile long save_gp;
397 register long real_s0 __asm__("$9" ); volatile long save_s0;
398 register long real_s1 __asm__("$10"); volatile long save_s1;
399 register long real_s2 __asm__("$11"); volatile long save_s2;
400 register long real_s3 __asm__("$12"); volatile long save_s3;
401 register long real_s4 __asm__("$13"); volatile long save_s4;
402 register long real_s5 __asm__("$14"); volatile long save_s5;
403 #ifdef alpha_EXTRA_CAREFUL
404 register long real_s6 __asm__("$15"); volatile long save_s6;
407 register double real_f2 __asm__("$f2"); volatile double save_f2;
408 register double real_f3 __asm__("$f3"); volatile double save_f3;
409 register double real_f4 __asm__("$f4"); volatile double save_f4;
410 register double real_f5 __asm__("$f5"); volatile double save_f5;
411 register double real_f6 __asm__("$f6"); volatile double save_f6;
412 register double real_f7 __asm__("$f7"); volatile double save_f7;
413 #ifdef alpha_EXTRA_CAREFUL
414 register double real_f8 __asm__("$f8"); volatile double save_f8;
415 register double real_f9 __asm__("$f9"); volatile double save_f9;
418 register StgFunPtr real_pv __asm__("$27");
431 #ifdef alpha_EXTRA_CAREFUL
441 #ifdef alpha_EXTRA_CAREFUL
448 __asm__ volatile( "lda $30,-%0($30)" "\n"
449 "\t" "jmp ($27)" "\n"
451 ".globl " STG_RETURN "\n"
453 "\t" "lda $30,%0($30)" "\n"
454 : : "K" (RESERVED_C_STACK_BYTES));
464 #ifdef alpha_EXTRA_CAREFUL
474 #ifdef alpha_EXTRA_CAREFUL
485 #endif /* alpha_HOST_ARCH */
487 /* -----------------------------------------------------------------------------
489 -------------------------------------------------------------------------- */
491 #ifdef hppa1_1_HOST_ARCH
494 StgRun(StgFunPtr f, StgRegTable *basereg)
496 StgChar space[RESERVED_C_STACK_BYTES+16*sizeof(long)+10*sizeof(double)];
499 __asm__ volatile ("ldo %0(%%r30),%%r19\n"
500 "\tstw %%r3, 0(0,%%r19)\n"
501 "\tstw %%r4, 4(0,%%r19)\n"
502 "\tstw %%r5, 8(0,%%r19)\n"
503 "\tstw %%r6,12(0,%%r19)\n"
504 "\tstw %%r7,16(0,%%r19)\n"
505 "\tstw %%r8,20(0,%%r19)\n"
506 "\tstw %%r9,24(0,%%r19)\n"
507 "\tstw %%r10,28(0,%%r19)\n"
508 "\tstw %%r11,32(0,%%r19)\n"
509 "\tstw %%r12,36(0,%%r19)\n"
510 "\tstw %%r13,40(0,%%r19)\n"
511 "\tstw %%r14,44(0,%%r19)\n"
512 "\tstw %%r15,48(0,%%r19)\n"
513 "\tstw %%r16,52(0,%%r19)\n"
514 "\tstw %%r17,56(0,%%r19)\n"
515 "\tstw %%r18,60(0,%%r19)\n"
516 "\tldo 80(%%r19),%%r19\n"
517 "\tfstds %%fr12,-16(0,%%r19)\n"
518 "\tfstds %%fr13, -8(0,%%r19)\n"
519 "\tfstds %%fr14, 0(0,%%r19)\n"
520 "\tfstds %%fr15, 8(0,%%r19)\n"
521 "\tldo 32(%%r19),%%r19\n"
522 "\tfstds %%fr16,-16(0,%%r19)\n"
523 "\tfstds %%fr17, -8(0,%%r19)\n"
524 "\tfstds %%fr18, 0(0,%%r19)\n"
525 "\tfstds %%fr19, 8(0,%%r19)\n"
526 "\tldo 32(%%r19),%%r19\n"
527 "\tfstds %%fr20,-16(0,%%r19)\n"
528 "\tfstds %%fr21, -8(0,%%r19)\n" : :
529 "n" (-(116 * sizeof(long) + 10 * sizeof(double))) : "%r19"
534 __asm__ volatile (".align 4\n"
535 "\t.EXPORT " STG_RETURN ",CODE\n"
536 "\t.EXPORT " STG_RETURN ",ENTRY,PRIV_LEV=3\n"
538 /* "\tldo %0(%%r3),%%r19\n" */
539 "\tldo %1(%%r30),%%r19\n"
540 "\tcopy %%r11, %0\n" /* save R1 */
541 "\tldw 0(0,%%r19),%%r3\n"
542 "\tldw 4(0,%%r19),%%r4\n"
543 "\tldw 8(0,%%r19),%%r5\n"
544 "\tldw 12(0,%%r19),%%r6\n"
545 "\tldw 16(0,%%r19),%%r7\n"
546 "\tldw 20(0,%%r19),%%r8\n"
547 "\tldw 24(0,%%r19),%%r9\n"
548 "\tldw 28(0,%%r19),%%r10\n"
549 "\tldw 32(0,%%r19),%%r11\n"
550 "\tldw 36(0,%%r19),%%r12\n"
551 "\tldw 40(0,%%r19),%%r13\n"
552 "\tldw 44(0,%%r19),%%r14\n"
553 "\tldw 48(0,%%r19),%%r15\n"
554 "\tldw 52(0,%%r19),%%r16\n"
555 "\tldw 56(0,%%r19),%%r17\n"
556 "\tldw 60(0,%%r19),%%r18\n"
557 "\tldo 80(%%r19),%%r19\n"
558 "\tfldds -16(0,%%r19),%%fr12\n"
559 "\tfldds -8(0,%%r19),%%fr13\n"
560 "\tfldds 0(0,%%r19),%%fr14\n"
561 "\tfldds 8(0,%%r19),%%fr15\n"
562 "\tldo 32(%%r19),%%r19\n"
563 "\tfldds -16(0,%%r19),%%fr16\n"
564 "\tfldds -8(0,%%r19),%%fr17\n"
565 "\tfldds 0(0,%%r19),%%fr18\n"
566 "\tfldds 8(0,%%r19),%%fr19\n"
567 "\tldo 32(%%r19),%%r19\n"
568 "\tfldds -16(0,%%r19),%%fr20\n"
569 "\tfldds -8(0,%%r19),%%fr21\n"
571 : "n" (-(116 * sizeof(long) + 10 * sizeof(double)))
578 #endif /* hppa1_1_HOST_ARCH */
580 /* -----------------------------------------------------------------------------
583 Everything is in assembler, so we don't have to deal with GCC...
585 -------------------------------------------------------------------------- */
587 #ifdef powerpc_HOST_ARCH
589 extern StgRegTable * StgRun(StgFunPtr f, StgRegTable *basereg);
591 #ifdef darwin_HOST_OS
592 void StgRunIsImplementedInAssembler(void)
594 #if HAVE_SUBSECTIONS_VIA_SYMBOLS
595 // if the toolchain supports deadstripping, we have to
596 // prevent it here (it tends to get confused here).
597 __asm__ volatile (".no_dead_strip _StgRunIsImplementedInAssembler");
603 "\tbl saveFP # f14\n"
604 "\tstmw r13,-220(r1)\n"
605 "\tstwu r1,-%0(r1)\n"
606 "\tmr r27,r4\n" // BaseReg == r27
610 ".globl _StgReturn\n"
614 "\tlmw r13,-220(r1)\n"
616 : : "i"(RESERVED_C_STACK_BYTES+224 /*stack frame size*/));
620 // This version is for PowerPC Linux.
622 // Differences from the Darwin/Mac OS X version:
623 // *) Different Assembler Syntax
624 // *) Doesn't use Register Saving Helper Functions (although they exist somewhere)
625 // *) We may not access positive stack offsets
626 // (no "Red Zone" as in the Darwin ABI)
627 // *) The Link Register is saved to a different offset in the caller's stack frame
628 // (Linux: 4(r1), Darwin 8(r1))
630 static void GNUC3_ATTRIBUTE(used)
631 StgRunIsImplementedInAssembler(void)
635 "\t.type StgRun,@function\n"
641 "\tstmw 13,-220(5)\n"
642 "\tstfd 14,-144(5)\n"
643 "\tstfd 15,-136(5)\n"
644 "\tstfd 16,-128(5)\n"
645 "\tstfd 17,-120(5)\n"
646 "\tstfd 18,-112(5)\n"
647 "\tstfd 19,-104(5)\n"
660 "\tmr 27,4\n" // BaseReg == r27
665 "\t.type StgReturn,@function\n"
692 : : "i"(RESERVED_C_STACK_BYTES+224 /*stack frame size*/));
698 /* -----------------------------------------------------------------------------
699 PowerPC 64 architecture
701 Everything is in assembler, so we don't have to deal with GCC...
703 -------------------------------------------------------------------------- */
705 #ifdef powerpc64_HOST_ARCH
708 extern StgRegTable * StgRun(StgFunPtr f, StgRegTable *basereg);
710 static void GNUC3_ATTRIBUTE(used)
711 StgRunIsImplementedInAssembler(void)
715 // r2 toc - needs to be saved
716 // r3-r10 argument passing, volatile
717 // r11, r12 very volatile (not saved across cross-module calls)
718 // r13 thread local state (never modified, don't need to save)
719 // r14-r31 callee-save
721 ".section \".opd\",\"aw\"\n"
725 "\t.quad\t.StgRun,.TOC.@tocbase,0\n"
726 "\t.size StgRun,24\n"
729 "\t.quad\t.StgReturn,.TOC.@tocbase,0\n"
730 "\t.size StgReturn,24\n"
733 ".type .StgRun,@function\n"
740 "\tstd 14, -288(5)\n"
741 "\tstd 15, -280(5)\n"
742 "\tstd 16, -272(5)\n"
743 "\tstd 17, -264(5)\n"
744 "\tstd 18, -256(5)\n"
745 "\tstd 19, -248(5)\n"
746 "\tstd 20, -240(5)\n"
747 "\tstd 21, -232(5)\n"
748 "\tstd 22, -224(5)\n"
749 "\tstd 23, -216(5)\n"
750 "\tstd 24, -208(5)\n"
751 "\tstd 25, -200(5)\n"
752 "\tstd 26, -192(5)\n"
753 "\tstd 27, -184(5)\n"
754 "\tstd 28, -176(5)\n"
755 "\tstd 29, -168(5)\n"
756 "\tstd 30, -160(5)\n"
757 "\tstd 31, -152(5)\n"
758 "\tstfd 14, -144(5)\n"
759 "\tstfd 15, -136(5)\n"
760 "\tstfd 16, -128(5)\n"
761 "\tstfd 17, -120(5)\n"
762 "\tstfd 18, -112(5)\n"
763 "\tstfd 19, -104(5)\n"
764 "\tstfd 20, -96(5)\n"
765 "\tstfd 21, -88(5)\n"
766 "\tstfd 22, -80(5)\n"
767 "\tstfd 23, -72(5)\n"
768 "\tstfd 24, -64(5)\n"
769 "\tstfd 25, -56(5)\n"
770 "\tstfd 26, -48(5)\n"
771 "\tstfd 27, -40(5)\n"
772 "\tstfd 28, -32(5)\n"
773 "\tstfd 29, -24(5)\n"
774 "\tstfd 30, -16(5)\n"
776 "\tmr 27, 4\n" // BaseReg == r27
781 ".globl .StgReturn\n"
782 ".type .StgReturn,@function\n"
785 "\tla 5, %0(1)\n" // load address == addi r5, r1, %0
805 "\tlfd 14, -144(5)\n"
806 "\tlfd 15, -136(5)\n"
807 "\tlfd 16, -128(5)\n"
808 "\tlfd 17, -120(5)\n"
809 "\tlfd 18, -112(5)\n"
810 "\tlfd 19, -104(5)\n"
827 : : "i"(RESERVED_C_STACK_BYTES+304 /*stack frame size*/));
829 #else // linux_HOST_OS
830 #error Only linux support for power64 right now.
835 /* -----------------------------------------------------------------------------
838 Again, in assembler - so we can fiddle with the register stack, and because
839 gcc doesn't handle asm-clobbered callee-saves correctly.
841 loc0 - loc15: preserved locals
842 loc16 - loc28: STG registers
845 loc31: saved gp (gcc 3.3 uses this slot)
846 -------------------------------------------------------------------------- */
848 #ifdef ia64_HOST_ARCH
850 /* the memory stack is rarely used, so 16K is excessive */
851 #undef RESERVED_C_STACK_BYTES
852 #define RESERVED_C_STACK_BYTES 1024
854 #if ((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3)
855 /* gcc 3.3+: leave an extra slot for gp saves */
861 static void GNUC3_ATTRIBUTE(used)
862 StgRunIsImplementedInAssembler(void)
867 "\talloc loc29 = ar.pfs, 0, %1, 8, 0\n" /* setup register frame */
868 "\tld8 r18 = [r32],8\n" /* get procedure address */
869 "\tadds sp = -%0, sp ;;\n" /* setup stack */
870 "\tld8 gp = [r32]\n" /* get procedure GP */
871 "\tadds r16 = %0-(6*16), sp\n"
872 "\tadds r17 = %0-(5*16), sp ;;\n"
873 "\tstf.spill [r16] = f16,32\n" /* spill callee-saved fp regs */
874 "\tstf.spill [r17] = f17,32\n"
875 "\tmov b6 = r18 ;;\n" /* set target address */
876 "\tstf.spill [r16] = f18,32\n"
877 "\tstf.spill [r17] = f19,32\n"
878 "\tmov loc30 = b0 ;;\n" /* save return address */
879 "\tstf.spill [r16] = f20,32\n"
880 "\tstf.spill [r17] = f21,32\n"
881 "\tbr.few b6 ;;\n" /* branch to function */
882 ".global StgReturn\n"
884 "\tmov r8 = loc16\n" /* return value in r8 */
885 "\tadds r16 = %0-(6*16), sp\n"
886 "\tadds r17 = %0-(5*16), sp ;;\n"
887 "\tldf.fill f16 = [r16],32\n" /* start restoring fp regs */
888 "\tldf.fill f17 = [r17],32\n"
889 "\tmov ar.pfs = loc29 ;;\n" /* restore register frame */
890 "\tldf.fill f18 = [r16],32\n"
891 "\tldf.fill f19 = [r17],32\n"
892 "\tmov b0 = loc30 ;;\n" /* restore return address */
893 "\tldf.fill f20 = [r16],32\n"
894 "\tldf.fill f21 = [r17],32\n"
895 "\tadds sp = %0, sp\n" /* restore stack */
896 "\tbr.ret.sptk.many b0 ;;\n" /* return */
897 : : "i"(RESERVED_C_STACK_BYTES + 6*16), "i"(LOCALS));
902 /* -----------------------------------------------------------------------------
904 -------------------------------------------------------------------------- */
906 #ifdef mips_HOST_ARCH
909 StgRun(StgFunPtr f, StgRegTable *basereg)
911 register StgThreadReturnCode __v0 __asm__("$2");
913 __asm__ __volatile__(
918 " .globl " STG_RETURN " \n"
919 " .aent " STG_RETURN " \n"
924 : "r" (f), "r" (basereg)
925 "$16", "$17", "$18", "$19", "$20", "$21", "$22", "$23",
927 "$f20", "$f22", "$f24", "$f26", "$f28", "$f30",
933 #endif /* mips_HOST_ARCH */
935 #endif /* !USE_MINIINTERPRETER */