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@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
-
Raymond Toy