0.9.2.9: thread objects

[sbcl.git] / src / runtime / x86-64-assem.S

diff --git a/src/runtime/x86-64-assem.S b/src/runtime/x86-64-assem.S
index 47916c2..9642978 100644 (file)
--- a/src/runtime/x86-64-assem.S
+++ b/src/runtime/x86-64-assem.S
@@ -97,7 +97,7 @@ GNAME(call_into_lisp_first_time):
        mov    THREAD_CONTROL_STACK_START_OFFSET(%rax) ,%rsp
        /* don't think too hard about what happens if we get interrupted
        * here */
-       add     $THREAD_CONTROL_STACK_SIZE-8,%rsp
+       add     $THREAD_CONTROL_STACK_SIZE-16,%rsp
        jmp     Lstack
 \f
        .text   
@@ -174,8 +174,9 @@ Lcall:
        pop     %rbx
 
 /* FIXME Restore the NPX state. */
-       pop     %rbp            # c-sp
+
        /* return value is already in rax where lisp expects it */
+       leave
        ret
        .size   GNAME(call_into_lisp), . - GNAME(call_into_lisp)
 \f
@@ -203,7 +204,7 @@ GNAME(fpu_restore):
  * the undefined-function trampoline
  */
        .text
-       .align  align_4byte,0x90
+       .align  align_8byte,0x90
        .global GNAME(undefined_tramp)
        .type   GNAME(undefined_tramp),@function
 GNAME(undefined_tramp):
@@ -217,9 +218,9 @@ GNAME(undefined_tramp):
 
 
        .text
-       .align  align_4byte,0x90
+       .align  align_8byte,0x90
        .global GNAME(alloc_tramp)
-       .type   GNAME(alooc_tramp),@function
+       .type   GNAME(alloc_tramp),@function
 GNAME(alloc_tramp):
        push    %rbp            # Save old frame pointer.
        mov     %rsp,%rbp       # Establish new frame.
@@ -253,7 +254,7 @@ GNAME(alloc_tramp):
  * the closure trampoline
  */
        .text
-       .align  align_4byte,0x90
+       .align  align_8byte,0x90
        .global GNAME(closure_tramp)
        .type   GNAME(closure_tramp),@function
 GNAME(closure_tramp):
@@ -272,16 +273,20 @@ GNAME(closure_tramp):
  */
        .text
        .global GNAME(fun_end_breakpoint_guts)
-       .align  align_4byte
+       .align  align_8byte
 GNAME(fun_end_breakpoint_guts):
        /* Multiple Value return */
        jmp     multiple_value_return
+       /* the above jmp is only 2 bytes long, we need to add a nop for 
+        * padding since the single value return convention jumps to original
+        * return address + 3 bytes */
+       nop
        /* Single value return: The eventual return will now use the
           multiple values return convention but with a return values
           count of one. */
        mov     %rsp,%rbx       # Setup ebx - the ofp.
-       sub     $4,%rsp         # Allocate one stack slot for the return value
-       mov     $4,%rcx         # Setup ecx for one return value.
+       sub     $8,%rsp         # Allocate one stack slot for the return value
+       mov     $8,%rcx         # Setup ecx for one return value.
        mov     $NIL,%rdi       # default second value
        mov     $NIL,%rsi       # default third value
                
@@ -299,37 +304,39 @@ GNAME(fun_end_breakpoint_end):
 \f
        .global GNAME(do_pending_interrupt)
        .type   GNAME(do_pending_interrupt),@function
-       .align  align_4byte,0x90
+       .align  align_8byte,0x90
 GNAME(do_pending_interrupt):
        int3
        .byte   trap_PendingInterrupt
        ret
        .size   GNAME(do_pending_interrupt),.-GNAME(do_pending_interrupt)
 \f
-#ifdef LISP_FEATURE_GENCGC
-/* This is a fast bzero using the FPU. The first argument is the start
- * address which needs to be aligned on an 8 byte boundary, the second
- * argument is the number of bytes, which must be a nonzero multiple
- * of 8 bytes. */
-/* FIXME whether this is still faster than using the OS's bzero or
- * equivalent, we don't know */
-       .text
-       .globl  GNAME(i586_bzero)
-       .type   GNAME(i586_bzero),@function
-       .align  align_4byte,0x90
-GNAME(i586_bzero):
-       mov     4(%rsp),%rdx    # Load the start address.
-       mov     8(%rsp),%rax    # Load the number of bytes.
-       fldz
-l1:    fstl    0(%rdx)
-       add     $8,%rdx
-       sub     $8,%rax
-       jnz     l1
-       fstp    %st(0)
+       .globl  GNAME(post_signal_tramp)
+       .type   GNAME(post_signal_tramp),@function
+       .align  align_8byte,0x90
+GNAME(post_signal_tramp):
+       /* this is notionally the second half of a function whose first half
+        * doesn't exist.  This is where call_into_lisp returns when called 
+        * using return_to_lisp_function */
+       popq %r15
+       popq %r14
+       popq %r13
+       popq %r12
+       popq %r11
+       popq %r10
+       popq %r9
+       popq %r8
+       popq %rdi
+       popq %rsi
+       addq $8, %rsp
+       popq %rsp
+       popq %rdx
+       popq %rbx
+       popq %rcx
+       popq %rax
+        popfq
+       leave
        ret
-       .size   GNAME(i586_bzero),.-GNAME(i586_bzero)
-#endif 
+       .size GNAME(post_signal_tramp),.-GNAME(post_signal_tramp)
 \f
-
-
        .end