1.0.5.36: x86 allocation cleanup
[sbcl.git] / src / runtime / x86-64-assem.S
1 /*
2  * very-low-level utilities for runtime support
3  */
4
5 /*
6  * This software is part of the SBCL system. See the README file for
7  * more information.
8  *
9  * This software is derived from the CMU CL system, which was
10  * written at Carnegie Mellon University and released into the
11  * public domain. The software is in the public domain and is
12  * provided with absolutely no warranty. See the COPYING and CREDITS
13  * files for more information.
14  */
15 \f
16 #define LANGUAGE_ASSEMBLY
17 #include "genesis/config.h"
18 #include "validate.h"
19 #include "sbcl.h"
20 #include "genesis/closure.h"
21 #include "genesis/funcallable-instance.h"
22 #include "genesis/fdefn.h"
23 #include "genesis/static-symbols.h"
24 #include "genesis/symbol.h"
25 #include "genesis/thread.h"
26         
27 /* Minimize conditionalization for different OS naming schemes. */
28 #if defined __linux__  || defined __FreeBSD__ /* (but *not* OpenBSD) */
29 #define GNAME(var) var
30 #else
31 #define GNAME(var) _##var
32 #endif
33
34 /* Get the right type of alignment. Linux and FreeBSD (but not OpenBSD)
35  * want alignment in bytes. */
36 #if defined(__linux__) || defined(__FreeBSD__)
37 #define align_4byte     4
38 #define align_8byte     8
39 #define align_16byte    16
40 #define align_32byte    32
41 #else
42 #define align_4byte     2
43 #define align_8byte     3
44 #define align_16byte    4       
45 #endif                  
46
47 /*
48  * The assembler used for win32 doesn't like .type or .size directives,
49  * so we want to conditionally kill them out. So let's wrap them in macros
50  * that are defined to be no-ops on win32. Hopefully this still works on
51  * other platforms.
52  */
53 #if !defined(LISP_FEATURE_WIN32) && !defined(LISP_FEATURE_DARWIN)
54 #define TYPE(name) .type name,@function
55 #define SIZE(name) .size name,.-name
56 #define DOLLAR(name) $(name)
57 #else
58 #define TYPE(name)
59 #define SIZE(name)
60 #endif
61
62 /*
63  * x86/darwin (as of MacOS X 10.4.5) doesn't reliably fire signal
64  * handlers (SIGTRAP or Mach exception handlers) for 0xCC, wo we have
65  * to use ud2 instead. ud2 is an undefined opcode, #x0b0f, or
66  * 0F 0B in low-endian notation, that causes SIGILL to fire. We check
67  * for this instruction in the SIGILL handler and if we see it, we
68  * advance the EIP by two bytes to skip over ud2 instruction and
69  * call sigtrap_handler. */
70 #if defined(LISP_FEATURE_DARWIN)
71 #define TRAP ud2
72 #else
73 #define TRAP int3
74 #endif
75
76 /*
77  * More Apple assembler hacks
78  */
79
80 #if defined(LISP_FEATURE_DARWIN)
81 /* global symbol x86-64 sym(%rip) hack:*/
82 #define GSYM(name) name(%rip)
83 #define END()
84 #else
85 #define GSYM(name) $name
86 #define END() .end
87 #endif
88
89         
90         .text
91         .globl  GNAME(all_threads)
92         
93         
94 \f
95 /* From lower to higher-numbered addresses, the stack contains 
96  * return address, arg 0, arg 1, arg 2 ...
97  * rax contains the address of the function to call
98  * Lisp expects return value in rax, whic is already consistent with C
99  * XXXX correct floating point handling is unimplemented so far
100  * Based on comments cleaned from x86-assem.S, we believe that 
101  * Lisp is expecting us to preserve rsi, rdi, rsp (no idea about r8-15)
102  */
103         .text
104         .align  align_16byte,0x90
105         .globl  GNAME(call_into_c)
106         TYPE(GNAME(call_into_c))
107 GNAME(call_into_c):
108         /* ABI requires that the direction flag be clear on function
109          * entry and exit. */
110         cld
111         push    %rbp            # Save old frame pointer.
112         mov     %rsp,%rbp       # Establish new frame.
113
114         push    %rsi            # args are going in here
115         push    %rdi
116         mov     16(%rbp),%rdi
117         mov     24(%rbp),%rsi
118         mov     32(%rbp),%rdx
119         mov     40(%rbp),%rcx
120         mov     48(%rbp),%rcx
121         mov     56(%rbp),%r8
122         mov     64(%rbp),%r9
123         call    *%rax
124         mov     %rbp,%rsp
125         pop     %rbp
126         ret
127         SIZE(GNAME(call_into_c))
128
129 \f
130         .text   
131         .globl  GNAME(call_into_lisp_first_time)
132         TYPE(GNAME(call_into_lisp_first_time))
133                 
134 /* The *ALIEN-STACK* pointer is set up on the first call_into_lisp when
135  * the stack changes.  We don't worry too much about saving registers 
136  * here, because we never expect to return from the initial call to lisp 
137  * anyway */
138         
139         .align  align_16byte,0x90
140 GNAME(call_into_lisp_first_time):
141         push    %rbp            # Save old frame pointer.
142         mov     %rsp,%rbp       # Establish new frame.
143         mov     %rsp,ALIEN_STACK + SYMBOL_VALUE_OFFSET
144 #if defined(LISP_FEATURE_DARWIN)
145         movq    GSYM(GNAME(all_threads)),%rax
146 #else
147         movq    GNAME(all_threads),%rax
148 #endif
149         mov     THREAD_CONTROL_STACK_START_OFFSET(%rax) ,%rsp
150         /* don't think too hard about what happens if we get interrupted
151         * here */
152         add     $(THREAD_CONTROL_STACK_SIZE)-16,%rsp
153         jmp     Lstack
154 \f
155         .text   
156         .globl  GNAME(call_into_lisp)
157         TYPE(GNAME(call_into_lisp))
158                 
159 /*
160  * amd64 calling convention: C expects that
161  * arguments go in rdi rsi rdx rcx r8 r9
162  * return values in rax rdx
163  * callee saves rbp rbx r12-15 if it uses them
164  */
165         
166         .align  align_16byte,0x90
167 GNAME(call_into_lisp):
168         push    %rbp            # Save old frame pointer.
169         mov     %rsp,%rbp       # Establish new frame.
170 Lstack:
171         /* FIXME x86 saves FPU state here */
172         push    %rbx    # these regs are callee-saved according to C
173         push    %r12    # so must be preserved and restored when 
174         push    %r13    # the lisp function returns
175         push    %r14    #
176         push    %r15    #
177
178         mov     %rsp,%rbx       # remember current stack
179         push    %rbx            # Save entry stack on (maybe) new stack.
180
181         push    %rdi    # args from C
182         push    %rsi    #
183         push    %rdx    #
184 #ifdef LISP_FEATURE_SB_THREAD
185 #ifdef LISP_FEATURE_DARWIN
186         mov     GSYM(GNAME(specials)),%rdi
187 #else
188         mov     specials,%rdi
189 #endif
190         call    GNAME(pthread_getspecific)
191         mov     %rax,%r12
192 #endif
193         pop     %rcx    # num args
194         pop     %rbx    # arg vector
195         pop     %rax    # function ptr/lexenv
196
197         xor     %rdx,%rdx       # clear any descriptor registers 
198         xor     %rdi,%rdi       # that we can't be sure we'll 
199         xor     %rsi,%rsi       # initialise properly.  XX do r8-r15 too?
200         shl     $3,%rcx         # (fixnumize num-args)
201         cmp     $0,%rcx
202         je      Ldone
203         mov     0(%rbx),%rdx    # arg0
204         cmp     $8,%rcx
205         je      Ldone
206         mov     8(%rbx),%rdi    # arg1
207         cmp     $16,%rcx
208         je      Ldone
209         mov     16(%rbx),%rsi   # arg2
210 Ldone:  
211         /* Registers rax, rcx, rdx, rdi, and rsi are now live. */
212         xor     %rbx,%rbx       # available
213
214         /* Alloc new frame. */
215         mov     %rsp,%rbx       # The current sp marks start of new frame.
216         push    %rbp            # fp in save location S0
217         sub     $16,%rsp        # Ensure 3 slots are allocated, one above.
218         mov     %rbx,%rbp       # Switch to new frame.
219
220 Lcall:
221         call    *CLOSURE_FUN_OFFSET(%rax)
222         
223         /* If the function returned multiple values, it will return to
224            this point.  Lose them */
225         jnc     LsingleValue    
226         mov     %rbx, %rsp
227 LsingleValue:   
228
229 /* Restore the stack, in case there was a stack change. */
230         pop     %rsp            # c-sp
231
232 /* Restore C regs */
233         pop     %r15
234         pop     %r14
235         pop     %r13
236         pop     %r12
237         pop     %rbx
238
239         /* ABI requires that the direction flag be clear on function
240          * entry and exit. */
241         cld
242         
243 /* FIXME Restore the NPX state. */
244
245         /* return value is already in rax where lisp expects it */
246         leave
247         ret
248         SIZE(GNAME(call_into_lisp))
249 \f
250 /* support for saving and restoring the NPX state from C */
251         .text
252         .globl  GNAME(fpu_save)
253         TYPE(GNAME(fpu_save))
254         .align  2,0x90
255 GNAME(fpu_save):
256         mov     4(%rsp),%rax
257         fnsave  (%rax)          # Save the NPX state. (resets NPX)
258         ret
259         SIZE(GNAME(fpu_save))
260
261         .globl  GNAME(fpu_restore)
262         TYPE(GNAME(fpu_restore))
263         .align  2,0x90
264 GNAME(fpu_restore):
265         mov     4(%rsp),%rax
266         frstor  (%rax)          # Restore the NPX state.
267         ret
268         SIZE(GNAME(fpu_restore))
269 \f
270 /*
271  * the undefined-function trampoline
272  */
273         .text
274         .align  align_16byte,0x90
275         .globl  GNAME(undefined_tramp)
276         TYPE(GNAME(undefined_tramp))
277 GNAME(undefined_tramp):
278         TRAP
279         .byte   trap_Error
280         .byte   2
281         .byte   UNDEFINED_FUN_ERROR
282         .byte   sc_DescriptorReg # eax in the Descriptor-reg SC
283         ret
284         SIZE(GNAME(undefined_tramp))
285
286
287         .text
288         .align  align_16byte,0x90
289         .globl  GNAME(alloc_tramp)
290         TYPE(GNAME(alloc_tramp))
291 GNAME(alloc_tramp):
292         push    %rbp            # Save old frame pointer.
293         mov     %rsp,%rbp       # Establish new frame.
294         push    %rax
295         push    %rcx
296         push    %rdx
297         push    %rsi
298         push    %rdi
299         push    %r8
300         push    %r9
301         push    %r10
302         push    %r11
303         mov     16(%rbp),%rdi   
304         call    GNAME(alloc)
305         mov     %rax,16(%rbp)
306         pop     %r11
307         pop     %r10
308         pop     %r9
309         pop     %r8
310         pop     %rdi
311         pop     %rsi
312         pop     %rdx
313         pop     %rcx
314         pop     %rax
315         pop     %rbp
316         ret
317         SIZE(GNAME(alloc_tramp))
318
319                 
320 /*
321  * the closure trampoline
322  */
323         .text
324         .align  align_16byte,0x90
325         .globl  GNAME(closure_tramp)
326         TYPE(GNAME(closure_tramp))
327 GNAME(closure_tramp):
328         mov     FDEFN_FUN_OFFSET(%rax),%rax
329         /* FIXME: The '*' after "jmp" in the next line is from PVE's
330          * patch posted to the CMU CL mailing list Oct 6, 1999. It looks
331          * reasonable, and it certainly seems as though if CMU CL needs it,
332          * SBCL needs it too, but I haven't actually verified that it's
333          * right. It would be good to find a way to force the flow of
334          * control through here to test it. */
335         jmp     *CLOSURE_FUN_OFFSET(%rax)
336         SIZE(GNAME(closure_tramp))
337
338         .text
339         .align  align_16byte,0x90
340         .globl  GNAME(funcallable_instance_tramp)
341 #if !defined(LISP_FEATURE_DARWIN)
342         .type   GNAME(funcallable_instance_tramp),@function
343 #endif
344         GNAME(funcallable_instance_tramp):
345         mov     FUNCALLABLE_INSTANCE_FUNCTION_OFFSET(%rax),%rax
346         /* KLUDGE: on this platform, whatever kind of function is in %rax
347          * now, the first word of it contains the address to jump to. */
348         jmp     *CLOSURE_FUN_OFFSET(%rax)
349 #if !defined(LISP_FEATURE_DARWIN)
350         .size   GNAME(funcallable_instance_tramp), .-GNAME(funcallable_instance_tramp)
351 #endif
352 /*
353  * fun-end breakpoint magic
354  */
355         .text
356         .globl  GNAME(fun_end_breakpoint_guts)
357         .align  align_16byte
358 GNAME(fun_end_breakpoint_guts):
359         /* Multiple Value return */
360         jc      multiple_value_return
361         /* Single value return: The eventual return will now use the
362            multiple values return convention but with a return values
363            count of one. */
364         mov     %rsp,%rbx       # Setup ebx - the ofp.
365         sub     $8,%rsp         # Allocate one stack slot for the return value
366         mov     $8,%rcx         # Setup ecx for one return value.
367 #if defined(LISP_FEATURE_DARWIN)
368         mov     GSYM(NIL),%rdi  # default second value
369         mov     GSYM(NIL),%rsi  # default third value
370 #else
371         mov     $NIL,%rdi       # default second value
372         mov     $NIL,%rsi       # default third value
373 #endif
374 multiple_value_return:
375         
376         .globl  GNAME(fun_end_breakpoint_trap)
377 GNAME(fun_end_breakpoint_trap):
378         TRAP
379         .byte   trap_FunEndBreakpoint
380         hlt                     # We should never return here.
381
382         .globl  GNAME(fun_end_breakpoint_end)
383 GNAME(fun_end_breakpoint_end):
384
385 \f
386         .globl  GNAME(do_pending_interrupt)
387         TYPE(GNAME(do_pending_interrupt))
388         .align  align_16byte,0x90
389 GNAME(do_pending_interrupt):
390         TRAP
391         .byte   trap_PendingInterrupt
392         ret
393         SIZE(GNAME(do_pending_interrupt))
394 \f
395         .globl  GNAME(post_signal_tramp)
396         TYPE(GNAME(post_signal_tramp))
397         .align  align_16byte,0x90
398 GNAME(post_signal_tramp):
399         /* this is notionally the second half of a function whose first half
400          * doesn't exist.  This is where call_into_lisp returns when called 
401          * using return_to_lisp_function */
402         popq %r15
403         popq %r14
404         popq %r13
405         popq %r12
406         popq %r11
407         popq %r10
408         popq %r9
409         popq %r8
410         popq %rdi
411         popq %rsi
412         /* skip RBP and RSP */
413         popq %rbx
414         popq %rdx
415         popq %rcx
416         popq %rax
417         popfq
418         leave
419         ret
420         SIZE(GNAME(post_signal_tramp))
421 \f
422         .text
423         .align  align_16byte,0x90
424         .globl  GNAME(fast_bzero)
425         TYPE(GNAME(fast_bzero))
426         
427 GNAME(fast_bzero):
428         /* A fast routine for zero-filling blocks of memory that are
429          * guaranteed to start and end at a 4096-byte aligned address.
430          */
431         shr $6, %rsi              /* Amount of 64-byte blocks to copy */
432         jz Lend                   /* If none, stop */
433         mov %rsi, %rcx            /* Save start address */
434         movups %xmm7, -16(%rsp)   /* Save XMM register */
435         xorps  %xmm7, %xmm7       /* Zero the XMM register */
436         jmp Lloop
437         .align align_16byte                 
438 Lloop:
439
440         /* Copy the 16 zeroes from xmm7 to memory, 4 times. MOVNTDQ is the
441          * non-caching double-quadword moving variant, i.e. the memory areas
442          * we're touching are not fetched into the L1 cache, since we're just
443          * going to overwrite the memory soon anyway.
444          */
445         movntdq %xmm7, 0(%rdi)
446         movntdq %xmm7, 16(%rdi)
447         movntdq %xmm7, 32(%rdi)
448         movntdq %xmm7, 48(%rdi)
449
450         add $64, %rdi  /* Advance pointer */
451         dec %rsi       /* Decrement 64-byte block count */
452         jnz Lloop
453         mfence         /* Ensure that the writes are globally visible, since
454                         * MOVNTDQ is weakly ordered */
455         movups -16(%rsp), %xmm7 /* Restore the XMM register */
456         prefetcht0 0(%rcx)      /* Prefetch the start of the block into cache,
457                                  * since it's likely to be used immediately. */
458 Lend:        
459         ret
460         SIZE(GNAME(fast_bzero))
461
462         END()