1 #define LANGUAGE_ASSEMBLY
7 #include "genesis/simple-fun.h"
8 #include "genesis/fdefn.h"
9 #include "genesis/closure.h"
10 #include "genesis/funcallable-instance.h"
11 #include "genesis/static-symbols.h"
12 #ifdef LISP_FEATURE_SB_THREAD
13 #include "genesis/thread.h"
16 #ifdef LISP_FEATURE_DARWIN
17 #define CSYMBOL(x) _ ## x
22 #if defined LISP_FEATURE_DARWIN
23 #define FUNCDEF(x) .text @ \
27 #define GFUNCDEF(x) .globl _ ## x @ \
30 #define FUNCDEF(x) .text ; \
35 #define GFUNCDEF(x) .globl x ; \
39 #if defined LISP_FEATURE_DARWIN
42 #define SET_SIZE(x) .size x,.-x
45 /* Load a register from a global, using the register as an intermediary */
46 /* The register will be a fixnum for one instruction, so this is gc-safe */
48 #if defined LISP_FEATURE_DARWIN
49 #define load(reg,global) \
50 lis reg,ha16(global) @ \
51 lwz reg,lo16(global)(reg) ; Comment
52 #define store(reg,temp,global) \
53 lis temp,ha16(global) @\
54 stw reg,lo16(global)(temp) ; Comment
56 #define load(reg,global) \
57 lis reg,global@ha; lwz reg,global@l(reg)
58 #define store(reg,temp,global) \
59 lis temp,global@ha; stw reg,global@l(temp)
62 #define FIRST_SAVE_FPR 14 /* lowest-numbered non-volatile FPR */
63 #ifdef LISP_FEATURE_DARWIN
64 #define FIRST_SAVE_GPR 13 /* lowest-numbered non-volatile GPR */
65 #define NGPR_SAVE_BYTES(n) ((32-(n))*4)
66 #define FRAME_ARG_BYTES(n) (((((n)+6)*4)+15)&~15)
68 #define FIRST_SAVE_GPR 14 /* lowest-numbered non-volatile GPR */
69 #define NGPR_SAVE_BYTES(n) ((32-(~1&((n)+1)))*4)
70 #define FRAME_ARG_BYTES(n) (((((n)+2)*4)+15)&~15)
72 #define NFPR_SAVE_BYTES(n) ((32-(n))*8)
74 #ifdef LISP_FEATURE_DARWIN
75 #define FRAME_SIZE(first_g,first_f,out_arg_words,savecr) \
76 (NFPR_SAVE_BYTES(first_f)+ NGPR_SAVE_BYTES(first_g)+ FRAME_ARG_BYTES(out_arg_words))
77 #define SAVE_FPR(n) stfd f##n,-8*(32- n)(r11)
78 #define SAVE_GPR(n) stw r##n,-4*(32- n)(r11)
79 #define FULL_FRAME_SIZE (FRAME_SIZE(FIRST_SAVE_GPR,FIRST_SAVE_FPR,8,1)+15&~15)
80 #define RESTORE_FPR(n) lfd f##n,-8*(32- n)(r11)
81 #define RESTORE_GPR(n) lwz r##n,-4*(32- n)(r11)
83 #define FRAME_SIZE(first_g,first_f,out_arg_words,savecr) \
84 (NFPR_SAVE_BYTES(first_f)+ NGPR_SAVE_BYTES(first_g)+ FRAME_ARG_BYTES(out_arg_words+savecr))
85 #define SAVE_FPR(n) stfd n,-8*(32-(n))(11)
86 #define SAVE_GPR(n) stw n,-4*(32-(n))(11)
87 #define FULL_FRAME_SIZE FRAME_SIZE(FIRST_SAVE_GPR,FIRST_SAVE_FPR,0,1)
89 #define RESTORE_FPR(n) lfd n,-8*(32-(n))(11)
90 #define RESTORE_GPR(n) lwz n,-4*(32-(n))(11)
93 #ifdef LISP_FEATURE_DARWIN
94 #define C_FULL_PROLOG \
98 stw REG(0),4(REG(1)) @ \
100 stw REG(0),8(REG(1)) @ \
101 mr REG(11),REG(1) @ \
102 stwu REG(1),-FULL_FRAME_SIZE(REG(1)) @ \
121 la REG(11),-NFPR_SAVE_BYTES(FIRST_SAVE_FPR)(REG(11)) @ \
143 #define C_FULL_EPILOG \
144 la REG(11),FULL_FRAME_SIZE-NFPR_SAVE_BYTES(FIRST_SAVE_FPR)(REG(1)) @ \
164 la REG(11),NFPR_SAVE_BYTES(FIRST_SAVE_FPR)(REG(11)) @ \
183 lwz REG(1),0(REG(1)) @ \
184 lwz REG(0),4(REG(1)) @ \
186 lwz REG(0),8(REG(1)) @ \
191 #define C_FULL_PROLOG \
195 stwu 1,-FULL_FRAME_SIZE(1) ; \
214 la 11,-NFPR_SAVE_BYTES(FIRST_SAVE_FPR)(11) ; \
236 #define C_FULL_EPILOG \
239 la 11,FULL_FRAME_SIZE-NFPR_SAVE_BYTES(FIRST_SAVE_FPR)(1) ; \
258 la 11,NFPR_SAVE_BYTES(FIRST_SAVE_FPR)(11) ; \
283 /* gas can't parse nnnnLU; redefine */
284 #if BACKEND_PAGE_BYTES == 65536
285 # undef BACKEND_PAGE_BYTES
286 # define BACKEND_PAGE_BYTES 65536
288 # error BACKEND_PAGE_BYTES mismatch
291 #ifdef LISP_FEATURE_SB_SAFEPOINT
292 /* OAOOM because we don't have the C headers here. */
293 # define THREAD_CSP_PAGE_SIZE 4096
295 /* the CSP page sits right before the thread */
296 # define THREAD_SAVED_CSP_OFFSET (-THREAD_CSP_PAGE_SIZE)
302 * Function to transfer control into lisp. The lisp object to invoke is
303 * passed as the first argument, which puts it in NL0
306 GFUNCDEF(call_into_lisp)
308 /* NL0 - function, NL1 - frame pointer, NL2 - nargs. */
309 #if defined(LISP_FEATURE_SB_THREAD)
310 /* We need to obtain a pointer to our TLS block before we do
311 * anything else. For this, we call pthread_getspecific().
312 * We've preserved all of the callee-saves registers, so we
313 * can use them to stash our arguments temporarily while we
319 /* Call out to obtain our TLS block. */
320 load(reg_NL0,CSYMBOL(specials))
321 /* This won't work on darwin: wrong fixup style. And is it
322 * supposed to be lis/ori or lis/addi? Or does it differ
323 * between darwin and everything else again? */
324 lis reg_CFUNC,CSYMBOL(pthread_getspecific)@h
325 ori reg_CFUNC,reg_CFUNC,CSYMBOL(pthread_getspecific)@l
328 mr reg_THREAD, reg_NL0
330 /* Restore our original parameters. */
335 /* store(reg_POLL,11,saver2) */
336 /* Initialize tagged registers */
350 #if !defined(LISP_FEATURE_SB_THREAD)
354 #ifdef LISP_FEATURE_DARWIN
355 lis reg_NULL,hi16(NIL)
356 ori reg_NULL,reg_NULL,lo16(NIL)
359 ori reg_NULL,reg_NULL,NIL@l
361 /* Turn on pseudo-atomic */
363 li reg_ALLOC,flag_PseudoAtomic
364 #if defined(LISP_FEATURE_SB_THREAD)
365 stw reg_ZERO,THREAD_FOREIGN_FUNCTION_CALL_ACTIVE_OFFSET(reg_THREAD)
366 lwz reg_BSP,THREAD_BINDING_STACK_POINTER_OFFSET(reg_THREAD)
367 lwz reg_CSP,THREAD_CONTROL_STACK_POINTER_OFFSET(reg_THREAD)
368 lwz reg_OCFP,THREAD_CONTROL_FRAME_POINTER_OFFSET(reg_THREAD)
370 store(reg_ZERO,reg_NL4,CSYMBOL(foreign_function_call_active))
371 load(reg_BSP,CSYMBOL(current_binding_stack_pointer))
372 load(reg_CSP,CSYMBOL(current_control_stack_pointer))
373 load(reg_OCFP,CSYMBOL(current_control_frame_pointer))
375 /* This is important for CHENEYGC: It's the allocation
376 * pointer. It's also important for ROOM on GENCGC:
377 * It's a pointer to the end of dynamic space, used to
378 * determine where to stop in MAP-ALLOCATED-OBJECTS. */
379 load(reg_NL4,CSYMBOL(dynamic_space_free_pointer))
380 add reg_ALLOC,reg_ALLOC,reg_NL4
382 /* No longer atomic, and check for interrupt */
383 subi reg_ALLOC,reg_ALLOC,flag_PseudoAtomic
384 andi. reg_NL3, reg_ALLOC, flag_PseudoAtomicInterrupted
387 /* Pass in the arguments */
390 mr reg_LEXENV,reg_NL0
391 lwz reg_A0,0(reg_CFP)
392 lwz reg_A1,4(reg_CFP)
393 lwz reg_A2,8(reg_CFP)
394 lwz reg_A3,12(reg_CFP)
397 #ifdef LISP_FEATURE_DARWIN
398 lis reg_LRA,ha16(lra)
399 addi reg_LRA,reg_LRA,lo16(lra)
402 ori reg_LRA,reg_LRA,lra@l
404 addi reg_LRA,reg_LRA,OTHER_POINTER_LOWTAG
406 /* Function is an indirect closure */
407 lwz reg_CODE,SIMPLE_FUN_SELF_OFFSET(reg_LEXENV)
408 addi reg_LIP,reg_CODE,SIMPLE_FUN_CODE_OFFSET
410 slwi reg_NARGS,reg_NL2,2
415 .long RETURN_PC_HEADER_WIDETAG
417 /* Blow off any extra values. */
421 /* Return the one value. */
425 /* Turn on pseudo-atomic */
426 la reg_ALLOC,flag_PseudoAtomic(reg_ALLOC)
428 #if defined(LISP_FEATURE_SB_THREAD)
429 /* Store lisp state */
430 stw reg_BSP,THREAD_BINDING_STACK_POINTER_OFFSET(reg_THREAD)
431 stw reg_CSP,THREAD_CONTROL_STACK_POINTER_OFFSET(reg_THREAD)
432 stw reg_CFP,THREAD_CONTROL_FRAME_POINTER_OFFSET(reg_THREAD)
434 /* No longer in Lisp. */
435 stw reg_ALLOC,THREAD_FOREIGN_FUNCTION_CALL_ACTIVE_OFFSET(reg_THREAD)
437 /* Store lisp state */
438 clrrwi reg_NL1,reg_ALLOC,3
439 store(reg_NL1,reg_NL2,CSYMBOL(dynamic_space_free_pointer))
440 /* store(reg_POLL,reg_NL2,poll_flag) */
441 /* load(reg_NL2,current_thread) */
442 store(reg_BSP,reg_NL2,CSYMBOL(current_binding_stack_pointer))
443 store(reg_CSP,reg_NL2,CSYMBOL(current_control_stack_pointer))
444 store(reg_CFP,reg_NL2,CSYMBOL(current_control_frame_pointer))
445 /* load(reg_POLL,saver2) */
447 /* No longer in Lisp. */
448 store(reg_NL1,reg_NL2,CSYMBOL(foreign_function_call_active))
451 /* Check for interrupt */
452 subi reg_ALLOC, reg_ALLOC, flag_PseudoAtomic
453 andi. reg_NL3, reg_ALLOC, flag_PseudoAtomicInterrupted
459 SET_SIZE(call_into_lisp)
462 GFUNCDEF(call_into_c)
463 /* We're kind of low on unboxed, non-dedicated registers here:
464 most of the unboxed registers may have outgoing C args in them.
465 CFUNC is going to have to go in the CTR in a moment, anyway
466 so we'll free it up soon. reg_NFP is preserved by lisp if it
467 has a meaningful value in it, so we can use it. reg_NARGS is
468 free when it's not holding a copy of the "real" reg_NL3, which
469 gets tied up by the pseudo-atomic mechanism */
472 /* Build a lisp stack frame */
475 la reg_CSP,32(reg_CSP)
476 stw reg_OCFP,0(reg_CFP)
477 stw reg_CODE,8(reg_CFP)
478 /* The pseudo-atomic mechanism wants to use reg_NL3, but that
479 may be an outgoing C argument. Copy reg_NL3 to something that's
480 unboxed and -not- one of the C argument registers */
483 /* Turn on pseudo-atomic */
484 la reg_ALLOC,flag_PseudoAtomic(reg_ALLOC)
486 /* Convert the return address to an offset and save it on the stack. */
487 sub reg_NFP,reg_LIP,reg_CODE
488 la reg_NFP,OTHER_POINTER_LOWTAG(reg_NFP)
489 stw reg_NFP,4(reg_CFP)
491 #ifdef LISP_FEATURE_SB_THREAD
492 /* Store Lisp state */
493 stw reg_BSP,THREAD_BINDING_STACK_POINTER_OFFSET(reg_THREAD)
494 stw reg_CSP,THREAD_CONTROL_STACK_POINTER_OFFSET(reg_THREAD)
495 stw reg_CFP,THREAD_CONTROL_FRAME_POINTER_OFFSET(reg_THREAD)
497 /* No longer in Lisp. */
498 stw reg_CSP,THREAD_FOREIGN_FUNCTION_CALL_ACTIVE_OFFSET(reg_THREAD)
500 /* Store Lisp state */
501 clrrwi reg_NFP,reg_ALLOC,3
502 store(reg_NFP,reg_CFUNC,CSYMBOL(dynamic_space_free_pointer))
503 /* load(reg_CFUNC,current_thread) */
505 store(reg_BSP,reg_CFUNC,CSYMBOL(current_binding_stack_pointer))
506 store(reg_CSP,reg_CFUNC,CSYMBOL(current_control_stack_pointer))
507 store(reg_CFP,reg_CFUNC,CSYMBOL(current_control_frame_pointer))
509 /* No longer in Lisp */
510 store(reg_CSP,reg_CFUNC,CSYMBOL(foreign_function_call_active))
512 /* load(reg_POLL,saver2) */
513 /* Disable pseudo-atomic; check pending interrupt */
514 subi reg_ALLOC, reg_ALLOC, flag_PseudoAtomic
515 andi. reg_NL3, reg_ALLOC, flag_PseudoAtomicInterrupted
518 #ifdef LISP_FEATURE_SB_SAFEPOINT
519 /* OK to run GC without stopping this thread from this point on. */
520 stw reg_CSP,THREAD_SAVED_CSP_OFFSET(reg_THREAD)
525 #ifdef LISP_FEATURE_DARWIN
526 /* PowerOpen (i.e. OS X) requires the callee address in r12
527 (a.k.a. CFUNC), so move it back there, too. */
533 /* Re-establish NIL */
534 #ifdef LISP_FEATURE_DARWIN
535 lis reg_NULL,hi16(NIL)
536 ori reg_NULL,reg_NULL,lo16(NIL)
539 ori reg_NULL,reg_NULL,NIL@l
544 /* If we GC'ed during the FF code (as the result of a callback ?)
545 the tagged lisp registers may now contain garbage (since the
546 registers were saved by C and not seen by the GC.) Put something
547 harmless in all such registers before allowing an interrupt */
551 /* reg_OCFP was pointing to a control stack frame & was preserved by C */
559 #if !defined(LISP_FEATURE_SB_THREAD)
560 /* reg_L2 is our TLS block pointer. */
565 # ifdef LISP_FEATURE_SB_SAFEPOINT
566 /* No longer OK to run GC except at safepoints. */
567 stw reg_ZERO,THREAD_SAVED_CSP_OFFSET(reg_THREAD)
571 li reg_ALLOC,flag_PseudoAtomic
573 #if defined(LISP_FEATURE_SB_THREAD)
574 /* No longer in foreign function call. */
575 stw reg_ZERO,THREAD_FOREIGN_FUNCTION_CALL_ACTIVE_OFFSET(reg_THREAD)
577 /* The binding stack pointer isn't preserved by C. */
578 lwz reg_BSP,THREAD_BINDING_STACK_POINTER_OFFSET(reg_THREAD)
580 /* No long in foreign function call. */
581 store(reg_ZERO,reg_NL2,CSYMBOL(foreign_function_call_active))
583 /* The free pointer may have moved */
586 /* The BSP wasn't preserved by C, so load it */
587 load(reg_BSP,CSYMBOL(current_binding_stack_pointer))
589 /* This is important for CHENEYGC: It's the allocation
590 * pointer. It's also important for ROOM on GENCGC:
591 * It's a pointer to the end of dynamic space, used to
592 * determine where to stop in MAP-ALLOCATED-OBJECTS. */
593 load(reg_NL4,CSYMBOL(dynamic_space_free_pointer))
594 add reg_ALLOC,reg_ALLOC,reg_NL4
596 /* Other lisp stack/frame pointers were preserved by C.
597 I can't imagine why they'd have moved */
599 /* Get the return address back. */
600 lwz reg_LIP,4(reg_CFP)
601 lwz reg_CODE,8(reg_CFP)
602 add reg_LIP,reg_CODE,reg_LIP
603 la reg_LIP,-OTHER_POINTER_LOWTAG(reg_LIP)
605 /* No longer atomic */
606 subi reg_ALLOC, reg_ALLOC, flag_PseudoAtomic
607 andi. reg_NL3, reg_ALLOC, flag_PseudoAtomicInterrupted
612 /* Reset the lisp stack. */
616 /* And back into Lisp. */
619 SET_SIZE(call_into_c)
621 GFUNCDEF(xundefined_tramp)
622 .globl CSYMBOL(undefined_tramp)
623 .long SIMPLE_FUN_HEADER_WIDETAG /* header */
624 .long CSYMBOL(undefined_tramp) - SIMPLE_FUN_CODE_OFFSET /* self */
627 .long NIL /* arglist */
630 CSYMBOL(undefined_tramp):
631 /* Point reg_CODE to the header and tag it as function, since
632 the debugger regards a function pointer in reg_CODE which
633 doesn't point to a code object as undefined function. */
634 /* We are given that reg_LIP points to undefined_tramp by
635 virtue of the calling convention. */
636 addi reg_CODE,reg_LIP,-SIMPLE_FUN_CODE_OFFSET
638 /* If we are called with stack arguments (or in a tail-call
639 scenario), we end up with an allocated stack frame, but the
640 frame link information is uninitialized. Fix things by
641 allocating and initializing our stack frame "properly". */
642 cmpwi cr0,reg_NARGS,16
644 addi reg_CSP,reg_CFP,16
646 1: add reg_CSP,reg_CFP,reg_NARGS
647 2: stw reg_OCFP,0(reg_CFP)
648 stw reg_LRA,4(reg_CFP)
650 /* Now that the preliminaries are dealt with, actually trap. */
651 twllei reg_ZERO,trap_Cerror
653 .byte UNDEFINED_FUN_ERROR
654 .byte 254, sc_DescriptorReg+0x40, 1 /* 140? sparc says sc_descriptorReg */
655 /* This stuff is for the continuable error. I don't think there's
656 * any support for it on the lisp side */
658 1: lwz reg_CODE,FDEFN_RAW_ADDR_OFFSET(reg_FDEFN)
659 la reg_LIP,SIMPLE_FUN_CODE_OFFSET(reg_CODE)
665 SET_SIZE(xundefined_tramp)
667 GFUNCDEF(xclosure_tramp)
668 .globl CSYMBOL(closure_tramp)
669 CSYMBOL(closure_tramp):
670 lwz reg_LEXENV,FDEFN_FUN_OFFSET(reg_FDEFN)
671 lwz reg_CODE,CLOSURE_FUN_OFFSET(reg_LEXENV)
672 la reg_LIP,SIMPLE_FUN_CODE_OFFSET(reg_CODE)
676 SET_SIZE(xclosure_tramp)
678 GFUNCDEF(xfuncallable_instance_tramp)
679 .globl CSYMBOL(funcallable_instance_tramp)
680 .long SIMPLE_FUN_HEADER_WIDETAG
681 CSYMBOL(funcallable_instance_tramp) = . + 1
682 .long CSYMBOL(funcallable_instance_tramp)
688 lwz reg_LEXENV,FUNCALLABLE_INSTANCE_FUNCTION_OFFSET(reg_LEXENV)
689 lwz reg_FDEFN,CLOSURE_FUN_OFFSET(reg_LEXENV)
690 addi reg_LIP,reg_FDEFN,SIMPLE_FUN_CODE_OFFSET
693 SET_SIZE(funcallable_instance_tramp)
695 /* The fun_end_breakpoint support here is considered by the
696 authors of the other $ARCH-assem.S files to be magic, and it
697 is. It is a small fragment of code that is copied into a heap
698 code-object when needed, and contains an LRA object, code to
699 convert a single-value return to unknown-values format, and a
700 trap_FunEndBreakpoint. */
701 GFUNCDEF(fun_end_breakpoint_guts)
702 .globl CSYMBOL(fun_end_breakpoint_trap)
703 .globl CSYMBOL(fun_end_breakpoint_end)
705 /* Due to pointer verification in MAKE-LISP-OBJ, this must
706 include its header data (the offset from the start of the
707 code-object to the LRA). The code-object header is five
708 words, there are two words of constants, and the instruction
709 space is doubleword-aligned, making an offset of eight.
710 This is header data for a widetag, so shift left eight bits
712 .long RETURN_PC_HEADER_WIDETAG + 0x800
714 /* We are receiving unknown multiple values, thus must deal
715 with the single-value and multiple-value cases separately. */
716 b fun_end_breakpoint_multiple_values
719 /* Compute the correct value for reg_CODE based on the LRA.
720 This is a "simple" matter of subtracting a constant from
721 reg_LRA (where the LRA is stored by the return sequence) to
722 obtain a tagged pointer to the enclosing code component. Both
723 values are tagged OTHER_POINTER_LOWTAG, so we just have to
724 account for the eight words (see calculation for
725 RETURN_PC_HEADER_WIDETAG, above) between the two addresses.
726 Restoring reg_CODE doesn't appear to be strictly necessary
727 here, but let's observe the niceties.*/
728 addi reg_CODE, reg_LRA, -32
730 /* Multiple values are stored relative to reg_OCFP, which we
731 set to be the current top-of-stack. */
734 /* Reserve a save location for the one value we have. */
735 addi reg_CSP, reg_CSP, 4
737 /* Record the number of values we have as a FIXNUM. */
740 /* Blank the remaining arg-passing registers. */
745 /* And branch to our trap. */
746 b CSYMBOL(fun_end_breakpoint_trap)
748 fun_end_breakpoint_multiple_values:
749 /* Compute the correct value for reg_CODE. See the
750 explanation for the single-value case, above. */
751 addi reg_CODE, reg_LRA, -32
753 /* The actual magic trap. */
754 CSYMBOL(fun_end_breakpoint_trap):
755 twllei reg_ZERO, trap_FunEndBreakpoint
757 /* Finally, the debugger needs to know where the end of the
758 fun_end_breakpoint_guts are, so that it may calculate its size
759 in order to populate out a suitably-sized code object. */
760 CSYMBOL(fun_end_breakpoint_end):
761 SET_SIZE(fun_end_breakpoint_guts)
764 GFUNCDEF(ppc_flush_cache_line)
771 SET_SIZE(ppc_flush_cache_line)
773 GFUNCDEF(do_pending_interrupt)
774 twllei reg_ZERO, trap_PendingInterrupt
776 /* King Nato's branch has a nop here. Do we need this? */
777 SET_SIZE(do_pending_interrupt)
779 #if defined LISP_FEATURE_GENCGC
782 stfd FREG(1), 0(REG(3))
783 stfd FREG(2), 8(REG(3))
784 stfd FREG(3), 16(REG(3))
785 stfd FREG(4), 24(REG(3))
786 stfd FREG(5), 32(REG(3))
787 stfd FREG(6), 40(REG(3))
788 stfd FREG(7), 48(REG(3))
789 stfd FREG(8), 56(REG(3))
790 stfd FREG(9), 64(REG(3))
791 stfd FREG(10), 72(REG(3))
792 stfd FREG(11), 80(REG(3))
793 stfd FREG(12), 88(REG(3))
794 stfd FREG(13), 96(REG(3))
795 stfd FREG(14), 104(REG(3))
796 stfd FREG(15), 112(REG(3))
797 stfd FREG(16), 120(REG(3))
798 stfd FREG(17), 128(REG(3))
799 stfd FREG(18), 136(REG(3))
800 stfd FREG(19), 144(REG(3))
801 stfd FREG(20), 152(REG(3))
802 stfd FREG(21), 160(REG(3))
803 stfd FREG(22), 168(REG(3))
804 stfd FREG(23), 176(REG(3))
805 stfd FREG(24), 184(REG(3))
806 stfd FREG(25), 192(REG(3))
807 stfd FREG(26), 200(REG(3))
808 stfd FREG(27), 208(REG(3))
809 stfd FREG(28), 216(REG(3))
810 stfd FREG(29), 224(REG(3))
811 stfd FREG(30), 232(REG(3))
812 stfd FREG(31), 240(REG(3))
816 GFUNCDEF(fpu_restore)
817 lfd FREG(1), 0(REG(3))
818 lfd FREG(2), 8(REG(3))
819 lfd FREG(3), 16(REG(3))
820 lfd FREG(4), 24(REG(3))
821 lfd FREG(5), 32(REG(3))
822 lfd FREG(6), 40(REG(3))
823 lfd FREG(7), 48(REG(3))
824 lfd FREG(8), 56(REG(3))
825 lfd FREG(9), 64(REG(3))
826 lfd FREG(10), 72(REG(3))
827 lfd FREG(11), 80(REG(3))
828 lfd FREG(12), 88(REG(3))
829 lfd FREG(13), 96(REG(3))
830 lfd FREG(14), 104(REG(3))
831 lfd FREG(15), 112(REG(3))
832 lfd FREG(16), 120(REG(3))
833 lfd FREG(17), 128(REG(3))
834 lfd FREG(18), 136(REG(3))
835 lfd FREG(19), 144(REG(3))
836 lfd FREG(20), 152(REG(3))
837 lfd FREG(21), 160(REG(3))
838 lfd FREG(22), 168(REG(3))
839 lfd FREG(23), 176(REG(3))
840 lfd FREG(24), 184(REG(3))
841 lfd FREG(25), 192(REG(3))
842 lfd FREG(26), 200(REG(3))
843 lfd FREG(27), 208(REG(3))
844 lfd FREG(28), 216(REG(3))
845 lfd FREG(29), 224(REG(3))
846 lfd FREG(30), 232(REG(3))
847 lfd FREG(31), 240(REG(3))
849 SET_SIZE(fpu_restore)