0.7.9.7:

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

diff --git a/src/runtime/x86-assem.S b/src/runtime/x86-assem.S
index 5941e0a..4fe372a 100644 (file)
--- a/src/runtime/x86-assem.S
+++ b/src/runtime/x86-assem.S
@@ -208,7 +208,7 @@ Ldone:
        mov     %ebx,%ebp       # Switch to new frame.
 
        /* Indirect the closure. */
-       call    *CLOSURE_FUNCTION_OFFSET(%eax)
+       call    *CLOSURE_FUN_OFFSET(%eax)
        
        /* Multi-value return; blow off any extra values. */
        mov     %ebx, %esp
@@ -262,11 +262,7 @@ GNAME(undefined_tramp):
        int3
        .byte   trap_Error
         .byte   2
-#ifdef type_LongFloat
-        .byte   24
-#else
-        .byte   23
-#endif
+        .byte   UNDEFINED_FUN_ERROR
         .byte   sc_DescriptorReg # eax in the Descriptor-reg SC
        ret
        .size   GNAME(undefined_tramp), .-GNAME(undefined_tramp)
@@ -279,23 +275,23 @@ GNAME(undefined_tramp):
        .global GNAME(closure_tramp)
        .type   GNAME(closure_tramp),@function
 GNAME(closure_tramp):
-       movl    FDEFN_FUNCTION_OFFSET(%eax),%eax
+       movl    FDEFN_FUN_OFFSET(%eax),%eax
        /* FIXME: The '*' after "jmp" in the next line is from PVE's
         * patch posted to the CMU CL mailing list Oct 6, 1999. It looks
         * reasonable, and it certainly seems as though if CMU CL needs it,
         * SBCL needs it too, but I haven't actually verified that it's
         * right. It would be good to find a way to force the flow of
         * control through here to test it. */
-       jmp     *CLOSURE_FUNCTION_OFFSET(%eax)
+       jmp     *CLOSURE_FUN_OFFSET(%eax)
        .size   GNAME(closure_tramp), .-GNAME(closure_tramp)
 
 /*
- * function-end breakpoint magic
+ * fun-end breakpoint magic
  */
        .text
-       .global GNAME(function_end_breakpoint_guts)
+       .global GNAME(fun_end_breakpoint_guts)
        .align  align_4byte
-GNAME(function_end_breakpoint_guts):
+GNAME(fun_end_breakpoint_guts):
        /* Multiple Value return */
        jmp     multiple_value_return
        /* Single value return: The eventual return will now use the
@@ -309,14 +305,14 @@ GNAME(function_end_breakpoint_guts):
                
 multiple_value_return:
        
-       .global GNAME(function_end_breakpoint_trap)
-GNAME(function_end_breakpoint_trap):
+       .global GNAME(fun_end_breakpoint_trap)
+GNAME(fun_end_breakpoint_trap):
        int3
-       .byte   trap_FunctionEndBreakpoint
+       .byte   trap_FunEndBreakpoint
        hlt                     # We should never return here.
 
-       .global GNAME(function_end_breakpoint_end)
-GNAME(function_end_breakpoint_end):
+       .global GNAME(fun_end_breakpoint_end)
+GNAME(fun_end_breakpoint_end):
 
 \f
        .global GNAME(do_pending_interrupt)
@@ -328,11 +324,13 @@ GNAME(do_pending_interrupt):
        ret
        .size   GNAME(do_pending_interrupt),.-GNAME(do_pending_interrupt)
 \f
-#ifdef GENCGC
+#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
@@ -659,7 +657,7 @@ GNAME(alloc_16_to_edi):
                
 
 \f
-#ifdef GENCGC
+#ifdef LISP_FEATURE_GENCGC
 
 /* These routines are called from Lisp when an inline allocation 
  * overflows. Every register except the result needs to be preserved.