[cmucl-commit] [git] CMU Common Lisp branch master updated. snapshot-2011-12-6-g43c8a82
Raymond Toy
rtoy at common-lisp.net
Thu Dec 22 07:51:57 CET 2011
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "CMU Common Lisp".
The branch, master has been updated
via 43c8a8204942f7286daad33ed5bcf4dcbe9f4c7d (commit)
from 57ca5217c749f67c8acd7e2049a5e79f4bd6baf1 (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit 43c8a8204942f7286daad33ed5bcf4dcbe9f4c7d
Author: Raymond Toy <toy.raymond at gmail.com>
Date: Wed Dec 21 22:51:42 2011 -0800
Make stack 16-byte aligned.
lisp/x86-assem.S:
o Make sure the stack is 16-byte aligned in the alloc_overflow_foo and
alloc_to_foo routines. These eventually call into C code, and the
stack is required to be 16-byte aligned on Darwin. We apply this to
all x86 implementations since it's harmless.
o Did not update the alloc_8/16_to_foo routines because they are going
to be deleted.
x86/macros.lisp:
o Don't call the alloc_8/16_to_foo routines when we're not doing
inline allocation. I don't think there's much to be gained with
these special functions and maintainence is a pain with assembly
code.
diff --git a/src/compiler/x86/macros.lisp b/src/compiler/x86/macros.lisp
index ea9c897..731bcf4 100644
--- a/src/compiler/x86/macros.lisp
+++ b/src/compiler/x86/macros.lisp
@@ -181,65 +181,29 @@
;; special entry point. The size may be a register or a constant.
(ecase (tn-offset alloc-tn)
(#.eax-offset
- (case size
- (8 (inst call (make-fixup (extern-alien-name "alloc_8_to_eax")
- :foreign)))
- (16 (inst call (make-fixup (extern-alien-name "alloc_16_to_eax")
- :foreign)))
- (t
- (load-size alloc-tn eax-tn size)
- (inst call (make-fixup (extern-alien-name "alloc_to_eax")
- :foreign)))))
+ (load-size alloc-tn eax-tn size)
+ (inst call (make-fixup (extern-alien-name "alloc_to_eax")
+ :foreign)))
(#.ecx-offset
- (case size
- (8 (inst call (make-fixup (extern-alien-name "alloc_8_to_ecx")
- :foreign)))
- (16 (inst call (make-fixup (extern-alien-name "alloc_16_to_ecx")
- :foreign)))
- (t
- (load-size alloc-tn ecx-tn size)
- (inst call (make-fixup (extern-alien-name "alloc_to_ecx")
- :foreign)))))
+ (load-size alloc-tn ecx-tn size)
+ (inst call (make-fixup (extern-alien-name "alloc_to_ecx")
+ :foreign)))
(#.edx-offset
- (case size
- (8 (inst call (make-fixup (extern-alien-name "alloc_8_to_edx")
- :foreign)))
- (16 (inst call (make-fixup (extern-alien-name "alloc_16_to_edx")
- :foreign)))
- (t
- (load-size alloc-tn edx-tn size)
- (inst call (make-fixup (extern-alien-name "alloc_to_edx")
- :foreign)))))
+ (load-size alloc-tn edx-tn size)
+ (inst call (make-fixup (extern-alien-name "alloc_to_edx")
+ :foreign)))
(#.ebx-offset
- (case size
- (8 (inst call (make-fixup (extern-alien-name "alloc_8_to_ebx")
- :foreign)))
- (16 (inst call (make-fixup (extern-alien-name "alloc_16_to_ebx")
- :foreign)))
- (t
- (load-size alloc-tn ebx-tn size)
- (inst call (make-fixup (extern-alien-name "alloc_to_ebx")
- :foreign)))))
+ (load-size alloc-tn ebx-tn size)
+ (inst call (make-fixup (extern-alien-name "alloc_to_ebx")
+ :foreign)))
(#.esi-offset
- (case size
- (8 (inst call (make-fixup (extern-alien-name "alloc_8_to_esi")
- :foreign)))
- (16 (inst call (make-fixup (extern-alien-name "alloc_16_to_esi")
- :foreign)))
- (t
- (load-size alloc-tn esi-tn size)
- (inst call (make-fixup (extern-alien-name "alloc_to_esi")
- :foreign)))))
+ (load-size alloc-tn esi-tn size)
+ (inst call (make-fixup (extern-alien-name "alloc_to_esi")
+ :foreign)))
(#.edi-offset
- (case size
- (8 (inst call (make-fixup (extern-alien-name "alloc_8_to_edi")
- :foreign)))
- (16 (inst call (make-fixup (extern-alien-name "alloc_16_to_edi")
- :foreign)))
- (t
- (load-size alloc-tn edi-tn size)
- (inst call (make-fixup (extern-alien-name "alloc_to_edi")
- :foreign))))))
+ (load-size alloc-tn edi-tn size)
+ (inst call (make-fixup (extern-alien-name "alloc_to_edi")
+ :foreign))))
(values))
;;;
diff --git a/src/lisp/x86-assem.S b/src/lisp/x86-assem.S
index 178e913..5557060 100644
--- a/src/lisp/x86-assem.S
+++ b/src/lisp/x86-assem.S
@@ -63,6 +63,22 @@ GNAME(x): ;
#define align_16byte 4
#endif
+/*
+ * Allocate |bytes| on the stack, and make sure the stack pointer is
+ * aligned on a 16-byte boundary. (Needed on Darwin, and harmless on
+ * others that don't need such alignment.)
+ */
+#define STACK_PROLOGUE(bytes) \
+ pushl %ebp ; \
+ mov %esp, %ebp ; \
+ subl $##bytes, %esp ; \
+ andl $-16, %esp ;
+
+/* Undo STACK_PROLOGUE */
+#define STACK_EPILOGUE \
+ movl %ebp, %esp ; \
+ popl %ebp ;
+
.text
.globl GNAME(foreign_function_call_active)
@@ -453,13 +469,14 @@ ENDFUNC(fastcopy16)
So only eax, ecx, and edx need special care here. */
FUNCDEF(alloc_to_eax)
- pushl %ecx # Save ecx and edx as C could destroy them.
- pushl %edx
- pushl %eax # Push the size
+ STACK_PROLOGUE(12)
+ movl %ecx, 8(%esp) # Save ecx and edx as C could destroy them.
+ movl %edx, 4(%esp)
+ movl %eax, (%esp) # Push the size
call GNAME(alloc)
- addl $4,%esp # pop the size arg.
- popl %edx # Restore ecx and edx.
- popl %ecx
+ movl 4(%esp), %edx # Restore ecx and edx.
+ movl 8(%esp), %ecx
+ STACK_EPILOGUE
ret
ENDFUNC(alloc_to_eax)
@@ -473,7 +490,7 @@ FUNCDEF(alloc_8_to_eax)
popl %ecx
ret
ENDFUNC(alloc_8_to_eax)
-
+
FUNCDEF(alloc_16_to_eax)
pushl %ecx # Save ecx and edx as C could destroy them.
pushl %edx
@@ -486,14 +503,15 @@ FUNCDEF(alloc_16_to_eax)
ENDFUNC(alloc_16_to_eax)
FUNCDEF(alloc_to_ecx)
- pushl %eax # Save eax and edx as C could destroy them.
- pushl %edx
- pushl %ecx # Push the size
+ STACK_PROLOGUE(12)
+ movl %eax, 8(%esp) # Save eax and edx as C could destroy them.
+ movl %edx, 4(%esp)
+ movl %ecx, (%esp) # Push the size
call GNAME(alloc)
- addl $4,%esp # pop the size arg.
movl %eax,%ecx # setup the destination.
- popl %edx # Restore eax and edx.
- popl %eax
+ movl 4(%esp), %edx # Restore eax and edx.
+ movl 8(%esp), %eax
+ STACK_EPILOGUE
ret
ENDFUNC(alloc_to_ecx)
@@ -522,14 +540,15 @@ FUNCDEF(alloc_16_to_ecx)
ENDFUNC(alloc_16_to_ecx)
FUNCDEF(alloc_to_edx)
- pushl %eax # Save eax and ecx as C could destroy them.
- pushl %ecx
- pushl %edx # Push the size
+ STACK_PROLOGUE(12)
+ movl %eax, 8(%esp) # Save eax and ecx as C could destroy them.
+ movl %ecx, 4(%esp)
+ movl %edx, (%esp) # Push the size
call GNAME(alloc)
- addl $4,%esp # pop the size arg.
movl %eax,%edx # setup the destination.
- popl %ecx # Restore eax and ecx.
- popl %eax
+ movl 4(%esp), %ecx # Restore eax and ecx.
+ movl 8(%esp), %eax
+ STACK_EPILOGUE
ret
ENDFUNC(alloc_to_edx)
@@ -558,16 +577,17 @@ FUNCDEF(alloc_16_to_edx)
ENDFUNC(alloc_16_to_edx)
FUNCDEF(alloc_to_ebx)
- pushl %eax # Save eax, ecx, and edx as C could destroy them.
- pushl %ecx
- pushl %edx
- pushl %ebx # Push the size
+ STACK_PROLOGUE(16)
+ movl %eax, 12(%esp) # Save eax, ecx, and edx as C could destroy them.
+ movl %ecx, 8(%esp)
+ movl %edx, 4(%esp)
+ movl %ebx, (%esp) # Push the size
call GNAME(alloc)
- addl $4,%esp # pop the size arg.
movl %eax,%ebx # setup the destination.
- popl %edx # Restore eax, ecx and edx.
- popl %ecx
- popl %eax
+ movl 4(%esp), %edx # Restore eax, ecx and edx.
+ movl 8(%esp), %ecx
+ movl 12(%esp), %eax
+ STACK_EPILOGUE
ret
ENDFUNC(alloc_to_ebx)
@@ -600,16 +620,17 @@ FUNCDEF(alloc_16_to_ebx)
ENDFUNC(alloc_16_to_ebx)
FUNCDEF(alloc_to_esi)
- pushl %eax # Save eax, ecx, and edx as C could destroy them.
- pushl %ecx
- pushl %edx
- pushl %esi # Push the size
+ STACK_PROLOGUE(16)
+ movl %eax, 12(%esp) # Save eax, ecx, and edx as C could destroy them.
+ movl %ecx, 8(%esp)
+ movl %edx, 4(%esp)
+ movl %esi, (%esp) # Push the size
call GNAME(alloc)
- addl $4,%esp # pop the size arg.
movl %eax,%esi # setup the destination.
- popl %edx # Restore eax, ecx and edx.
- popl %ecx
- popl %eax
+ movl 4(%esp), %edx # Restore eax, ecx and edx.
+ movl 8(%esp), %ecx
+ movl 12(%esp), %eax
+ STACK_EPILOGUE
ret
ENDFUNC(alloc_to_esi)
@@ -642,16 +663,17 @@ FUNCDEF(alloc_16_to_esi)
ENDFUNC(alloc_16_to_esi)
FUNCDEF(alloc_to_edi)
- pushl %eax # Save eax, ecx, and edx as C could destroy them.
- pushl %ecx
- pushl %edx
- pushl %edi # Push the size
+ STACK_PROLOGUE(16)
+ movl %eax, 12(%esp) # Save eax, ecx, and edx as C could destroy them.
+ movl %ecx, 8(%esp)
+ movl %edx, 4(%esp)
+ movl %edi, (%esp) # Push the size
call GNAME(alloc)
- addl $4,%esp # pop the size arg.
movl %eax,%edi # setup the destination.
- popl %edx # Restore eax, ecx and edx.
- popl %ecx
- popl %eax
+ movl 4(%esp), %edx # Restore eax, ecx and edx.
+ movl 8(%esp), %ecx
+ movl 12(%esp), %eax
+ STACK_EPILOGUE
ret
ENDFUNC(alloc_to_edi)
@@ -683,7 +705,6 @@ FUNCDEF(alloc_16_to_edi)
ret
ENDFUNC(alloc_16_to_edi)
-
#ifdef GENCGC
/* Called from lisp when an inline allocation overflows.
@@ -694,15 +715,16 @@ ENDFUNC(alloc_16_to_edi)
/* This routine handles an overflow with eax=crfp+size. So the
size=eax-crfp. */
FUNCDEF(alloc_overflow_eax)
- pushl %ecx # Save ecx
- pushl %edx # Save edx
+ STACK_PROLOGUE(12)
+ movl %ecx, 8(%esp) # Save ecx
+ movl %edx, 4(%esp) # Save edx
/* Calculate the size for the allocation. */
subl CURRENT_REGION_FREE_POINTER + SYMBOL_VALUE_OFFSET,%eax
- pushl %eax # Push the size
+ movl %eax, (%esp) # Push the size
call GNAME(alloc)
- addl $4,%esp # pop the size arg.
- popl %edx # Restore edx.
- popl %ecx # Restore ecx.
+ movl 4(%esp), %edx # Restore edx.
+ movl 8(%esp), %ecx # Restore ecx.
+ STACK_EPILOGUE
addl $6,(%esp) # Adjust the return address to skip the next inst.
ret
ENDFUNC(alloc_overflow_eax)
@@ -710,16 +732,17 @@ ENDFUNC(alloc_overflow_eax)
/* This routine handles an overflow with ecx=crfp+size. So the
size=ecx-crfp. */
FUNCDEF(alloc_overflow_ecx)
- pushl %eax # Save eax
- pushl %edx # Save edx
+ STACK_PROLOGUE(12)
+ movl %eax, 8(%esp) # Save eax
+ movl %edx, 4(%esp) # Save edx
/* Calculate the size for the allocation. */
subl CURRENT_REGION_FREE_POINTER + SYMBOL_VALUE_OFFSET,%ecx
- pushl %ecx # Push the size
+ movl %ecx, (%esp) # Push the size
call GNAME(alloc)
- addl $4,%esp # pop the size arg.
movl %eax,%ecx # setup the destination.
- popl %edx # Restore edx.
- popl %eax # Restore eax.
+ movl 4(%esp), %edx # Restore edx.
+ movl 8(%esp), %eax # Restore eax.
+ STACK_EPILOGUE
addl $6,(%esp) # Adjust the return address to skip the next inst.
ret
ENDFUNC(alloc_overflow_ecx)
@@ -727,16 +750,17 @@ ENDFUNC(alloc_overflow_ecx)
/* This routine handles an overflow with edx=crfp+size. So the
size=edx-crfp. */
FUNCDEF(alloc_overflow_edx)
- pushl %eax # Save eax
- pushl %ecx # Save ecx
+ STACK_PROLOGUE(12)
+ movl %eax, 8(%esp) # Save eax
+ movl %ecx, 4(%esp) # Save ecx
/* Calculate the size for the allocation. */
subl CURRENT_REGION_FREE_POINTER + SYMBOL_VALUE_OFFSET,%edx
- pushl %edx # Push the size
+ movl %edx, (%esp) # Push the size
call GNAME(alloc)
- addl $4,%esp # pop the size arg.
movl %eax,%edx # setup the destination.
- popl %ecx # Restore ecx.
- popl %eax # Restore eax.
+ movl 4(%esp), %ecx # Restore ecx.
+ movl 8(%esp), %eax # Restore eax.
+ STACK_EPILOGUE
addl $6,(%esp) # Adjust the return address to skip the next inst.
ret
ENDFUNC(alloc_overflow_edx)
@@ -744,18 +768,19 @@ ENDFUNC(alloc_overflow_edx)
/* This routine handles an overflow with ebx=crfp+size. So the
size=ebx-crfp. */
FUNCDEF(alloc_overflow_ebx)
- pushl %eax # Save eax
- pushl %ecx # Save ecx
- pushl %edx # Save edx
+ STACK_PROLOGUE(16)
+ movl %eax, 12(%esp) # Save eax
+ movl %ecx, 8(%esp) # Save ecx
+ movl %edx, 4(%esp) # Save edx
/* Calculate the size for the allocation. */
subl CURRENT_REGION_FREE_POINTER + SYMBOL_VALUE_OFFSET,%ebx
- pushl %ebx # Push the size
+ movl %ebx, (%esp) # Push the size
call GNAME(alloc)
- addl $4,%esp # pop the size arg.
movl %eax,%ebx # setup the destination.
- popl %edx # Restore edx.
- popl %ecx # Restore ecx.
- popl %eax # Restore eax.
+ movl 4(%esp), %edx # Restore edx.
+ movl 8(%esp), %ecx # Restore ecx.
+ movl 12(%esp), %eax # Restore eax.
+ STACK_EPILOGUE
addl $6,(%esp) # Adjust the return address to skip the next inst.
ret
ENDFUNC(alloc_overflow_ebx)
@@ -763,18 +788,19 @@ ENDFUNC(alloc_overflow_ebx)
/* This routine handles an overflow with esi=crfp+size. So the
size=esi-crfp. */
FUNCDEF(alloc_overflow_esi)
- pushl %eax # Save eax
- pushl %ecx # Save ecx
- pushl %edx # Save edx
+ STACK_PROLOGUE(16)
+ movl %eax, 12(%esp) # Save eax
+ movl %ecx, 8(%esp) # Save ecx
+ movl %edx, 4(%esp) # Save edx
/* Calculate the size for the allocation. */
subl CURRENT_REGION_FREE_POINTER + SYMBOL_VALUE_OFFSET,%esi
- pushl %esi # Push the size
+ movl %esi, (%esp) # Push the size
call GNAME(alloc)
- addl $4,%esp # pop the size arg.
movl %eax,%esi # setup the destination.
- popl %edx # Restore edx.
- popl %ecx # Restore ecx.
- popl %eax # Restore eax.
+ movl 4(%esp), %edx # Restore edx.
+ movl 8(%esp), %ecx # Restore ecx.
+ movl 12(%esp), %eax # Restore eax.
+ STACK_EPILOGUE
addl $6,(%esp) # Adjust the return address to skip the next inst.
ret
ENDFUNC(alloc_overflow_esi)
@@ -782,18 +808,19 @@ ENDFUNC(alloc_overflow_esi)
/* This routine handles an overflow with edi=crfp+size. So the
size=edi-crfp. */
FUNCDEF(alloc_overflow_edi)
- pushl %eax # Save eax
- pushl %ecx # Save ecx
- pushl %edx # Save edx
+ STACK_PROLOGUE(16)
+ movl %eax, 12(%esp) # Save eax
+ movl %ecx, 8(%esp) # Save ecx
+ movl %edx, 4(%esp) # Save edx
/* Calculate the size for the allocation. */
subl CURRENT_REGION_FREE_POINTER + SYMBOL_VALUE_OFFSET,%edi
- pushl %edi # Push the size
+ movl %edi, (%esp) # Push the size
call GNAME(alloc)
- addl $4,%esp # pop the size arg.
movl %eax,%edi # setup the destination.
- popl %edx # Restore edx.
- popl %ecx # Restore ecx.
- popl %eax # Restore eax.
+ movl 4(%esp), %edx # Restore edx.
+ movl 8(%esp), %ecx # Restore ecx.
+ movl 12(%esp), %eax # Restore eax.
+ STACK_EPILOGUE
addl $6,(%esp) # Adjust the return address to skip the next inst.
ret
ENDFUNC(alloc_overflow_edi)
-----------------------------------------------------------------------
Summary of changes:
src/compiler/x86/macros.lisp | 72 ++++-----------
src/lisp/x86-assem.S | 199 ++++++++++++++++++++++++------------------
2 files changed, 131 insertions(+), 140 deletions(-)
hooks/post-receive
--
CMU Common Lisp
More information about the cmucl-commit
mailing list