Port musl to x86-64. One giant commit!

src/math/x86_64/e_sqrt.s

@@ -0,0 +1,3 @@
+.global sqrt
+sqrt:	sqrtsd %xmm0, %xmm0
+	ret

src/math/x86_64/e_sqrtf.s

@@ -0,0 +1,3 @@
+.global sqrtf
+sqrtf:  sqrtss %xmm0, %xmm0
+	ret

src/setjmp/x86_64/longjmp.s

@@ -0,0 +1,24 @@
+/* Copyright 2011 Nicholas J. Kain, licensed GNU LGPL 2.1 or later */
+.global _longjmp
+.global longjmp
+.type _longjmp,%function
+.type longjmp,%function
+_longjmp:
+longjmp:
+	mov %rsi,%rax           /* val will be longjmp return */
+	test %rax,%rax
+	jnz .L0
+	inc %rax                /* if val==0, val=1 per longjmp semantics */
+.L0:
+	movq (%rdi),%rbx        /* rdi is the jmp_buf, restore regs from it */
+	movq 8(%rdi),%rbp
+	movq 16(%rdi),%r12
+	movq 24(%rdi),%r13
+	movq 32(%rdi),%r14
+	movq 40(%rdi),%r15
+	movq 48(%rdi),%rdx      /* this ends up being the stack pointer */
+	mov %rdx,%rsp
+	movq 56(%rdi),%rdx      /* this is the instruction pointer */
+	jmp *%rdx               /* goto saved address without altering rsp */
+.size _longjmp,.-_longjmp
+.size longjmp,.-longjmp

src/setjmp/x86_64/setjmp.s

@@ -0,0 +1,25 @@
+/* Copyright 2011 Nicholas J. Kain, licensed GNU LGPL 2.1 or later */
+.global __setjmp
+.global _setjmp
+.global setjmp
+.type __setjmp,%function
+.type _setjmp,%function
+.type setjmp,%function
+__setjmp:
+_setjmp:
+setjmp:
+	mov %rbx,(%rdi)         /* rdi is jmp_buf, move registers onto it */
+	mov %rbp,8(%rdi)
+	mov %r12,16(%rdi)
+	mov %r13,24(%rdi)
+	mov %r14,32(%rdi)
+	mov %r15,40(%rdi)
+	leaq 8(%rsp),%rdx       /* this is our rsp WITHOUT current ret addr */
+	mov %rdx,48(%rdi)
+	movq (%rsp),%rdx        /* save return addr ptr for new rip */
+	mov %rdx,56(%rdi)
+	xor %rax,%rax           /* always return 0 */
+	ret
+.size __setjmp,.-__setjmp
+.size _setjmp,.-_setjmp
+.size setjmp,.-setjmp

src/signal/x86_64/restore.s

@@ -0,0 +1,11 @@
+.global __restore_rt
+.global __restore
+.type __restore_rt,%function
+.type __restore,%function
+__restore_rt:
+__restore:
+	movl $15, %eax
+	syscall
+.size __restore_rt,.-__restore_rt
+.size __restore,.-__restore
+

src/signal/x86_64/sigsetjmp.s

@@ -0,0 +1,11 @@
+/* Copyright 2011 Nicholas J. Kain, licensed GNU LGPL 2.1 or later */
+.global sigsetjmp
+sigsetjmp:
+	test %rsi,%rsi
+	jz 1f              /* if save == 0, just goto setjmp */
+	movq %rsi,64(%rdi) /* move save -> jmp_buf[8] */
+	addq $72,%rdi      /* add sizeof(jmp_buf) to rdi */
+	movl $0,%esi       /* arg2 = 0 */
+	movl $2,%edx       /* arg3 = 2 */
+	call sigprocmask   /* sigprocmask(jmp_buf, 0, 2) */
+1:	jmp setjmp

src/thread/x86_64/__set_thread_area.s

@@ -0,0 +1,15 @@
+/* Copyright 2011 Nicholas J. Kain, licensed GNU LGPL 2.1 or later */
+.text
+.global __set_thread_area
+.type   __set_thread_area,%function
+__set_thread_area:
+        push %rbx               /* save x86_64 abi clobbered registers */
+        push %r11
+        mov %rdi,%rsi           /* shift for syscall */
+        movl $0x1002,%edi       /* SET_FS register */
+        movl $158,%eax          /* set fs segment to */
+        syscall                 /* arch_prctl(SET_FS, arg)*/
+        pop %r11                /* restore clobbered registers */
+        pop %rbx
+	ret
+.size __set_thread_area,.-__set_thread_area

src/thread/x86_64/__unmapself.s

@@ -0,0 +1,24 @@
+/* Copyright 2011 Nicholas J. Kain, licensed GNU LGPL 2.1 or later */
+.text
+.global __unmapself
+.type   __unmapself,%function
+__unmapself:
+	call 1f         /* glibc ABI compat */
+	.long -1
+	.long -1
+1:      push %rsi       /* save arg2 for munmap */
+	push %rdx       /* save arg3 for munmap */
+	mov %rdi,%rsi   /* rt_sigprocmask() args: move arg1 to rsi */
+	xor %rdi,%rdi
+	xor %rdx,%rdx
+	movq $8,%r10
+	movl $14,%eax   /* __NR_rt_sigprocmask */
+	syscall         /* call rt_sigprocmask(0,arg1,0,8) */
+	pop %rsi        /* munmap() args: reload from stack */
+	pop %rdi
+	movl $11,%eax   /* __NR_munmap */
+	syscall         /* munmap(arg2,arg3) */
+	xor %rdi,%rdi   /* exit() args: always return success */
+	movl $60,%eax   /* __NR_exit */
+	syscall         /* exit(0) */
+.size __unmapself,.-__unmapself

src/thread/x86_64/clone.s

@@ -0,0 +1,22 @@
+/* Copyright 2011 Nicholas J. Kain, licensed GNU LGPL 2.1 or later */
+.text
+.global __uniclone
+.type   __uniclone,%function
+/* rdi = child_stack, rsi = start, rdx = pthread_struct */
+__uniclone:
+        subq    $16,%rdi        /* grow child_stack */
+        mov     %rsi,8(%rdi)    /* push start onto child_stack as return ptr */
+        mov     %rdx,0(%rdi)    /* push pthread_struct onto child_stack */
+        mov     %rdx,%r8        /* r8 = tls */
+        mov     %rdi,%rsi       /* rsi = child_stack */
+        leaq    40(%rdx),%r10   /* r10 = child_id */
+        movl    $56,%eax        /* clone syscall number */
+        movl    $0x7d0f00,%edi  /* rdi = flags */
+        mov     %r10,%rdx       /* rdx = parent_id */
+	syscall                 /* clone(flags, child_stack, parent_id,
+	                         *       child_id, tls) */
+	test	%rax,%rax
+	jnz	1f              /* if we're in the parent -> goto 1f */
+        pop     %rdi            /* restore pthread_struct from child stack */
+1:      ret
+.size __uniclone,.-__uniclone