From 4b47520ca2997278cec2fcf6cd008e31faf339b9 Mon Sep 17 00:00:00 2001 From: Henning Heinold Date: Wed, 17 Sep 2008 23:09:55 +0000 Subject: uclibc-svn: correct linuxthreads and add log2 * add linuxthread support for am with arm-linuxthreads.patch, otherwise qt-emebedded 4.4.1 is not buildable * to enable linuxthreads you have to comment LINUXTHREADS_OLD=y in uClibc.conf * include linuxthreads-changes.patch from the uclibc-mailinglist * add log2 function with uclibc_mathc99.patch, one program in qt-emebdded 4.4.1 requires this * bump PR --- packages/uclibc/uclibc-svn/arm-linuxthreads.patch | 218 +++++++++++++++ packages/uclibc/uclibc-svn/arm/uClibc.config | 2 +- .../uclibc/uclibc-svn/linuxthreads-changes.patch | 291 +++++++++++++++++++++ packages/uclibc/uclibc-svn/uclibc_mathc99.patch | 270 +++++++++++++++++++ packages/uclibc/uclibc_svn.bb | 7 +- 5 files changed, 785 insertions(+), 3 deletions(-) create mode 100644 packages/uclibc/uclibc-svn/arm-linuxthreads.patch create mode 100644 packages/uclibc/uclibc-svn/linuxthreads-changes.patch create mode 100644 packages/uclibc/uclibc-svn/uclibc_mathc99.patch (limited to 'packages/uclibc') diff --git a/packages/uclibc/uclibc-svn/arm-linuxthreads.patch b/packages/uclibc/uclibc-svn/arm-linuxthreads.patch new file mode 100644 index 0000000000..e222668a66 --- /dev/null +++ b/packages/uclibc/uclibc-svn/arm-linuxthreads.patch @@ -0,0 +1,218 @@ +Index: uClibc/libpthread/linuxthreads/sysdeps/unix/sysv/linux/arm/vfork.S +=================================================================== +--- /dev/null 1970-01-01 00:00:00.000000000 +0000 ++++ uClibc/libpthread/linuxthreads/sysdeps/unix/sysv/linux/arm/vfork.S 2008-08-28 00:22:06.278340855 +0200 +@@ -0,0 +1,78 @@ ++/* Copyright (C) 1999, 2002, 2003, 2005 Free Software Foundation, Inc. ++ This file is part of the GNU C Library. ++ Contributed by Philip Blundell . ++ ++ The GNU C Library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Lesser General Public ++ License as published by the Free Software Foundation; either ++ version 2.1 of the License, or (at your option) any later version. ++ ++ The GNU C Library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ Lesser General Public License for more details. ++ ++ You should have received a copy of the GNU Lesser General Public ++ License along with the GNU C Library; if not, write to the Free ++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA ++ 02111-1307 USA. */ ++ ++#include ++#define _ERRNO_H 1 ++#include ++#include ++ ++/* Clone the calling process, but without copying the whole address space. ++ The calling process is suspended until the new process exits or is ++ replaced by a call to `execve'. Return -1 for errors, 0 to the new process, ++ and the process ID of the new process to the old process. */ ++ ++ENTRY (__vfork) ++ ++#ifdef __NR_vfork ++ ++#ifdef SHARED ++ ldr ip, 1f ++ ldr r0, 2f ++3: add ip, pc, ip ++ ldr r0, [ip, r0] ++#else ++ ldr r0, 1f ++#endif ++ movs r0, r0 ++ bne HIDDEN_JUMPTARGET (__fork) ++ ++ DO_CALL (vfork, 0) ++ cmn a1, #4096 ++ RETINSTR(cc, lr) ++ ++#ifndef __ASSUME_VFORK_SYSCALL ++ /* Check if vfork syscall is known at all. */ ++ cmn a1, #ENOSYS ++ bne PLTJMP(C_SYMBOL_NAME(__syscall_error)) ++#endif ++ ++#endif ++ ++#ifndef __ASSUME_VFORK_SYSCALL ++ /* If we don't have vfork, fork is close enough. */ ++ DO_CALL (fork, 0) ++ cmn a1, #4096 ++ RETINSTR(cc, lr) ++#elif !defined __NR_vfork ++# error "__NR_vfork not available and __ASSUME_VFORK_SYSCALL defined" ++#endif ++ b PLTJMP(C_SYMBOL_NAME(__syscall_error)) ++ ++#ifdef SHARED ++1: .word _GLOBAL_OFFSET_TABLE_ - 3b - 8 ++2: .word __libc_pthread_functions(GOTOFF) ++#else ++ .weak pthread_create ++1: .word pthread_create ++#endif ++ ++PSEUDO_END (__vfork) ++libc_hidden_def (__vfork) ++ ++weak_alias (__vfork, vfork) +Index: uClibc/libpthread/linuxthreads/sysdeps/unix/sysv/linux/arm/sysdep-cancel.h +=================================================================== +--- /dev/null 1970-01-01 00:00:00.000000000 +0000 ++++ uClibc/libpthread/linuxthreads/sysdeps/unix/sysv/linux/arm/sysdep-cancel.h 2008-08-28 00:28:04.301636993 +0200 +@@ -0,0 +1,130 @@ ++/* Copyright (C) 2003, 2005 Free Software Foundation, Inc. ++ This file is part of the GNU C Library. ++ Contributed by Phil Blundell , 2003. ++ ++ The GNU C Library is free software; you can redistribute it and/or ++ modify it under the terms of the GNU Lesser General Public ++ License as published by the Free Software Foundation; either ++ version 2.1 of the License, or (at your option) any later version. ++ ++ The GNU C Library is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ Lesser General Public License for more details. ++ ++ You should have received a copy of the GNU Lesser General Public ++ License along with the GNU C Library; if not, write to the Free ++ Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA ++ 02111-1307 USA. */ ++ ++#include ++#include ++#ifndef __ASSEMBLER__ ++# include ++#endif ++ ++#if !defined NOT_IN_libc || defined IS_IN_libpthread ++ ++/* We push lr onto the stack, so we have to use ldmib instead of ldmia ++ to find the saved arguments. */ ++# ifdef PIC ++# undef DOARGS_5 ++# undef DOARGS_6 ++# undef DOARGS_7 ++# define DOARGS_5 str r4, [sp, $-4]!; ldr r4, [sp, $8]; ++# define DOARGS_6 mov ip, sp; stmfd sp!, {r4, r5}; ldmib ip, {r4, r5}; ++# define DOARGS_7 mov ip, sp; stmfd sp!, {r4, r5, r6}; ldmib ip, {r4, r5, r6}; ++# endif ++ ++# undef PSEUDO_RET ++# define PSEUDO_RET \ ++ ldrcc pc, [sp], $4; \ ++ ldr lr, [sp], $4; \ ++ b PLTJMP(SYSCALL_ERROR) ++ ++# undef PSEUDO ++# define PSEUDO(name, syscall_name, args) \ ++ .section ".text"; \ ++ PSEUDO_PROLOGUE; \ ++ ENTRY (name); \ ++ SINGLE_THREAD_P; \ ++ bne .Lpseudo_cancel; \ ++ DO_CALL (syscall_name, args); \ ++ cmn r0, $4096; \ ++ RETINSTR(cc, lr); \ ++ b PLTJMP(SYSCALL_ERROR); \ ++ .Lpseudo_cancel: \ ++ str lr, [sp, $-4]!; \ ++ DOCARGS_##args; /* save syscall args around CENABLE. */ \ ++ CENABLE; \ ++ mov ip, r0; /* put mask in safe place. */ \ ++ UNDOCARGS_##args; /* restore syscall args. */ \ ++ swi SYS_ify (syscall_name); /* do the call. */ \ ++ str r0, [sp, $-4]!; /* save syscall return value. */ \ ++ mov r0, ip; /* get mask back. */ \ ++ CDISABLE; \ ++ ldr r0, [sp], $4; /* retrieve return value. */ \ ++ UNDOC2ARGS_##args; /* fix register damage. */ \ ++ cmn r0, $4096; ++ ++# define DOCARGS_0 ++# define UNDOCARGS_0 ++# define UNDOC2ARGS_0 ++ ++# define DOCARGS_1 str r0, [sp, #-4]!; ++# define UNDOCARGS_1 ldr r0, [sp], #4; ++# define UNDOC2ARGS_1 ++ ++# define DOCARGS_2 str r1, [sp, #-4]!; str r0, [sp, #-4]!; ++# define UNDOCARGS_2 ldr r0, [sp], #4; ldr r1, [sp], #4; ++# define UNDOC2ARGS_2 ++ ++# define DOCARGS_3 str r2, [sp, #-4]!; str r1, [sp, #-4]!; str r0, [sp, #-4]!; ++# define UNDOCARGS_3 ldr r0, [sp], #4; ldr r1, [sp], #4; ldr r2, [sp], #4 ++# define UNDOC2ARGS_3 ++ ++# define DOCARGS_4 stmfd sp!, {r0-r3} ++# define UNDOCARGS_4 ldmfd sp!, {r0-r3} ++# define UNDOC2ARGS_4 ++ ++# define DOCARGS_5 stmfd sp!, {r0-r3} ++# define UNDOCARGS_5 ldmfd sp, {r0-r3}; str r4, [sp, #-4]!; ldr r4, [sp, #24] ++# define UNDOC2ARGS_5 ldr r4, [sp], #20 ++ ++# ifdef IS_IN_libpthread ++# define CENABLE bl PLTJMP(__pthread_enable_asynccancel) ++# define CDISABLE bl PLTJMP(__pthread_disable_asynccancel) ++# define __local_multiple_threads __pthread_multiple_threads ++# else ++# define CENABLE bl PLTJMP(__libc_enable_asynccancel) ++# define CDISABLE bl PLTJMP(__libc_disable_asynccancel) ++# define __local_multiple_threads __libc_multiple_threads ++# endif ++ ++# ifndef __ASSEMBLER__ ++extern int __local_multiple_threads attribute_hidden; ++# define SINGLE_THREAD_P __builtin_expect (__local_multiple_threads == 0, 1) ++# else ++# if !defined PIC ++# define SINGLE_THREAD_P \ ++ ldr ip, =__local_multiple_threads; \ ++ ldr ip, [ip]; \ ++ teq ip, #0; ++# define PSEUDO_PROLOGUE ++# else ++# define SINGLE_THREAD_P \ ++ ldr ip, 1b; \ ++2: \ ++ ldr ip, [pc, ip]; \ ++ teq ip, #0; ++# define PSEUDO_PROLOGUE \ ++ 1: .word __local_multiple_threads - 2f - 8; ++# endif ++# endif ++ ++#elif !defined __ASSEMBLER__ ++ ++/* This code should never be used but we define it anyhow. */ ++# define SINGLE_THREAD_P (1) ++ ++#endif diff --git a/packages/uclibc/uclibc-svn/arm/uClibc.config b/packages/uclibc/uclibc-svn/arm/uClibc.config index 9460573cdd..546889aa8b 100644 --- a/packages/uclibc/uclibc-svn/arm/uClibc.config +++ b/packages/uclibc/uclibc-svn/arm/uClibc.config @@ -76,7 +76,7 @@ UCLIBC_CTOR_DTOR=y # HAS_NO_THREADS is not set UCLIBC_HAS_THREADS=y PTHREADS_DEBUG_SUPPORT=y -LINUXTHREADS_OLD=y +# LINUXTHREADS_OLD is not set UCLIBC_HAS_LFS=y # MALLOC is not set # MALLOC_SIMPLE is not set diff --git a/packages/uclibc/uclibc-svn/linuxthreads-changes.patch b/packages/uclibc/uclibc-svn/linuxthreads-changes.patch new file mode 100644 index 0000000000..f6f32cdd29 --- /dev/null +++ b/packages/uclibc/uclibc-svn/linuxthreads-changes.patch @@ -0,0 +1,291 @@ +Index: uClibc/libpthread/linuxthreads/descr.h +=================================================================== +--- uClibc.orig/libpthread/linuxthreads/descr.h 2008-08-27 23:59:46.171809044 +0200 ++++ uClibc/libpthread/linuxthreads/descr.h 2008-08-28 00:00:35.435134759 +0200 +@@ -123,9 +123,9 @@ + union dtv *dtvp; + pthread_descr self; /* Pointer to this structure */ + int multiple_threads; +-# ifdef NEED_DL_SYSINFO + uintptr_t sysinfo; +-# endif ++ uintptr_t stack_guard; ++ uintptr_t pointer_guard; + } data; + void *__padding[16]; + } p_header; +@@ -193,6 +193,13 @@ + size_t p_alloca_cutoff; /* Maximum size which should be allocated + using alloca() instead of malloc(). */ + /* New elements must be added at the end. */ ++ ++ /* This member must be last. */ ++ char end_padding[]; ++ ++#define PTHREAD_STRUCT_END_PADDING \ ++ (sizeof (struct _pthread_descr_struct) \ ++ - offsetof (struct _pthread_descr_struct, end_padding)) + } __attribute__ ((aligned(32))); /* We need to align the structure so that + doubles are aligned properly. This is 8 + bytes on MIPS and 16 bytes on MIPS64. +Index: uClibc/libpthread/linuxthreads/manager.c +=================================================================== +--- uClibc.orig/libpthread/linuxthreads/manager.c 2008-08-27 23:59:54.185140485 +0200 ++++ uClibc/libpthread/linuxthreads/manager.c 2008-08-28 00:00:35.435134759 +0200 +@@ -679,6 +679,17 @@ + new_thread->p_inheritsched = attr ? attr->__inheritsched : 0; + new_thread->p_alloca_cutoff = stksize / 4 > __MAX_ALLOCA_CUTOFF + ? __MAX_ALLOCA_CUTOFF : stksize / 4; ++ ++ /* Copy the stack guard canary. */ ++#ifdef THREAD_COPY_STACK_GUARD ++ THREAD_COPY_STACK_GUARD (new_thread); ++#endif ++ ++ /* Copy the pointer guard value. */ ++#ifdef THREAD_COPY_POINTER_GUARD ++ THREAD_COPY_POINTER_GUARD (new_thread); ++#endif ++ + /* Initialize the thread handle */ + __pthread_init_lock(&__pthread_handles[sseg].h_lock); + __pthread_handles[sseg].h_descr = new_thread; +@@ -742,15 +753,15 @@ + pid = __clone2(pthread_start_thread_event, + (void **)new_thread_bottom, + (char *)stack_addr - new_thread_bottom, +- CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | ++ CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | CLONE_SYSVSEM | + __pthread_sig_cancel, new_thread); + #elif _STACK_GROWS_UP + pid = __clone(pthread_start_thread_event, (void *) new_thread_bottom, +- CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | ++ CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | CLONE_SYSVSEM | + __pthread_sig_cancel, new_thread); + #else + pid = __clone(pthread_start_thread_event, stack_addr, +- CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | ++ CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | CLONE_SYSVSEM | + __pthread_sig_cancel, new_thread); + #endif + saved_errno = errno; +@@ -783,15 +794,15 @@ + pid = __clone2(pthread_start_thread, + (void **)new_thread_bottom, + (char *)stack_addr - new_thread_bottom, +- CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | ++ CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | CLONE_SYSVSEM | + __pthread_sig_cancel, new_thread); + #elif _STACK_GROWS_UP + pid = __clone(pthread_start_thread, (void *) new_thread_bottom, +- CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | ++ CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | CLONE_SYSVSEM | + __pthread_sig_cancel, new_thread); + #else + pid = __clone(pthread_start_thread, stack_addr, +- CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | ++ CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | CLONE_SYSVSEM | + __pthread_sig_cancel, new_thread); + #endif /* !NEED_SEPARATE_REGISTER_STACK */ + saved_errno = errno; +@@ -892,10 +903,11 @@ + #ifdef _STACK_GROWS_UP + # ifdef USE_TLS + size_t stacksize = guardaddr - th->p_stackaddr; ++ guardaddr = th->p_stackaddr; + # else + size_t stacksize = guardaddr - (char *)th; +-# endif + guardaddr = (char *)th; ++# endif + #else + /* Guardaddr is always set, even if guardsize is 0. This allows + us to compute everything else. */ +Index: uClibc/libpthread/linuxthreads/pthread.c +=================================================================== +--- uClibc.orig/libpthread/linuxthreads/pthread.c 2008-08-28 00:00:00.825141935 +0200 ++++ uClibc/libpthread/linuxthreads/pthread.c 2008-08-28 00:00:35.438472147 +0200 +@@ -698,6 +698,16 @@ + mgr = &__pthread_manager_thread; + #endif + ++ /* Copy the stack guard canary. */ ++#ifdef THREAD_COPY_STACK_GUARD ++ THREAD_COPY_STACK_GUARD (mgr); ++#endif ++ ++ /* Copy the pointer guard value. */ ++#ifdef THREAD_COPY_POINTER_GUARD ++ THREAD_COPY_POINTER_GUARD (mgr); ++#endif ++ + __pthread_manager_request = manager_pipe[1]; /* writing end */ + __pthread_manager_reader = manager_pipe[0]; /* reading end */ + +@@ -738,17 +748,17 @@ + pid = __clone2(__pthread_manager_event, + (void **) __pthread_manager_thread_bos, + THREAD_MANAGER_STACK_SIZE, +- CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND, ++ CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | CLONE_SYSVSEM, + mgr); + #elif _STACK_GROWS_UP + pid = __clone(__pthread_manager_event, + (void **) __pthread_manager_thread_bos, +- CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND, ++ CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | CLONE_SYSVSEM, + mgr); + #else + pid = __clone(__pthread_manager_event, + (void **) __pthread_manager_thread_tos, +- CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND, ++ CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | CLONE_SYSVSEM, + mgr); + #endif + +@@ -778,13 +788,13 @@ + #ifdef NEED_SEPARATE_REGISTER_STACK + pid = __clone2(__pthread_manager, (void **) __pthread_manager_thread_bos, + THREAD_MANAGER_STACK_SIZE, +- CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND, mgr); ++ CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | CLONE_SYSVSEM, mgr); + #elif _STACK_GROWS_UP + pid = __clone(__pthread_manager, (void **) __pthread_manager_thread_bos, +- CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND, mgr); ++ CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | CLONE_SYSVSEM, mgr); + #else + pid = __clone(__pthread_manager, (void **) __pthread_manager_thread_tos, +- CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND, mgr); ++ CLONE_VM | CLONE_FS | CLONE_FILES | CLONE_SIGHAND | CLONE_SYSVSEM, mgr); + #endif + } + if (__builtin_expect (pid, 0) == -1) { +@@ -971,6 +981,10 @@ + struct pthread_request request; + pthread_descr self = thread_self(); + ++ /* Make sure we come back here after suspend(), in case we entered ++ from a signal handler. */ ++ THREAD_SETMEM(self, p_signal_jmp, NULL); ++ + request.req_thread = self; + request.req_kind = REQ_PROCESS_EXIT; + request.req_args.exit.code = retcode; +@@ -1198,13 +1212,13 @@ + + void __pthread_restart_old(pthread_descr th) + { +- if (atomic_increment(&th->p_resume_count) == -1) ++ if (pthread_atomic_increment(&th->p_resume_count) == -1) + kill(th->p_pid, __pthread_sig_restart); + } + + void __pthread_suspend_old(pthread_descr self) + { +- if (atomic_decrement(&self->p_resume_count) <= 0) ++ if (pthread_atomic_decrement(&self->p_resume_count) <= 0) + __pthread_wait_for_restart_signal(self); + } + +@@ -1215,7 +1229,7 @@ + int was_signalled = 0; + sigjmp_buf jmpbuf; + +- if (atomic_decrement(&self->p_resume_count) == 0) { ++ if (pthread_atomic_decrement(&self->p_resume_count) == 0) { + /* Set up a longjmp handler for the restart signal, unblock + the signal and sleep. */ + +@@ -1272,9 +1286,9 @@ + being delivered. */ + + if (!was_signalled) { +- if (atomic_increment(&self->p_resume_count) != -1) { ++ if (pthread_atomic_increment(&self->p_resume_count) != -1) { + __pthread_wait_for_restart_signal(self); +- atomic_decrement(&self->p_resume_count); /* should be zero now! */ ++ pthread_atomic_decrement(&self->p_resume_count); /* should be zero now! */ + /* woke spontaneously and consumed restart signal */ + return 1; + } +Index: uClibc/libpthread/linuxthreads/specific.c +=================================================================== +--- uClibc.orig/libpthread/linuxthreads/specific.c 2008-08-28 00:00:07.595139286 +0200 ++++ uClibc/libpthread/linuxthreads/specific.c 2008-08-28 00:00:35.438472147 +0200 +@@ -104,13 +104,14 @@ + that if the key is reallocated later by pthread_key_create, its + associated values will be NULL in all threads. + +- If no threads have been created yet, clear it just in the +- current thread. */ ++ If no threads have been created yet, or if we are exiting, clear ++ it just in the current thread. */ + + struct pthread_key_delete_helper_args args; + args.idx1st = key / PTHREAD_KEY_2NDLEVEL_SIZE; + args.idx2nd = key % PTHREAD_KEY_2NDLEVEL_SIZE; +- if (__pthread_manager_request != -1) ++ if (__pthread_manager_request != -1 ++ && !(__builtin_expect (__pthread_exit_requested, 0))) + { + struct pthread_request request; + +@@ -203,8 +204,9 @@ + __pthread_lock(THREAD_GETMEM(self, p_lock), self); + for (i = 0; i < PTHREAD_KEY_1STLEVEL_SIZE; i++) { + if (THREAD_GETMEM_NC(self, p_specific[i]) != NULL) { +- free(THREAD_GETMEM_NC(self, p_specific[i])); ++ void *p = THREAD_GETMEM_NC(self, p_specific[i]); + THREAD_SETMEM_NC(self, p_specific[i], NULL); ++ free(p); + } + } + __pthread_unlock(THREAD_GETMEM(self, p_lock)); +Index: uClibc/libpthread/linuxthreads/spinlock.c +=================================================================== +--- uClibc.orig/libpthread/linuxthreads/spinlock.c 2008-08-28 00:00:17.805140454 +0200 ++++ uClibc/libpthread/linuxthreads/spinlock.c 2008-08-28 00:00:35.438472147 +0200 +@@ -637,8 +637,20 @@ + #if defined HAS_COMPARE_AND_SWAP + wait_node_dequeue(pp_head, pp_max_prio, p_max_prio); + #endif ++ ++ /* Release the spinlock before restarting. */ ++#if defined TEST_FOR_COMPARE_AND_SWAP ++ if (!__pthread_has_cas) ++#endif ++#if !defined HAS_COMPARE_AND_SWAP || defined TEST_FOR_COMPARE_AND_SWAP ++ { ++ __pthread_release(&lock->__spinlock); ++ } ++#endif ++ + restart(p_max_prio->thr); +- break; ++ ++ return; + } + } + +Index: uClibc/libpthread/linuxthreads/spinlock.h +=================================================================== +--- uClibc.orig/libpthread/linuxthreads/spinlock.h 2008-08-28 00:00:24.768471655 +0200 ++++ uClibc/libpthread/linuxthreads/spinlock.h 2008-08-28 00:02:42.971786951 +0200 +@@ -172,7 +172,7 @@ + + /* Operations on pthread_atomic, which is defined in internals.h */ + +-static __inline__ long atomic_increment(struct pthread_atomic *pa) ++static __inline__ long pthread_atomic_increment(struct pthread_atomic *pa) + { + long oldval; + +@@ -184,7 +184,7 @@ + } + + +-static __inline__ long atomic_decrement(struct pthread_atomic *pa) ++static __inline__ long pthread_atomic_decrement(struct pthread_atomic *pa) + { + long oldval; + diff --git a/packages/uclibc/uclibc-svn/uclibc_mathc99.patch b/packages/uclibc/uclibc-svn/uclibc_mathc99.patch new file mode 100644 index 0000000000..6fbb11af6b --- /dev/null +++ b/packages/uclibc/uclibc-svn/uclibc_mathc99.patch @@ -0,0 +1,270 @@ +Index: uClibc/test/math/libm-test.inc +=================================================================== +--- uClibc.orig/test/math/libm-test.inc 2008-07-25 11:03:24.000000000 +0200 ++++ uClibc/test/math/libm-test.inc 2008-08-28 10:54:29.714525665 +0200 +@@ -3414,7 +3414,6 @@ + } + + +-#if 0 + static void + log2_test (void) + { +@@ -3444,7 +3443,6 @@ + + END (log2); + } +-#endif + + + static void +@@ -4967,9 +4965,7 @@ + log_test (); + log10_test (); + log1p_test (); +-#if 0 + log2_test (); +-#endif + logb_test (); + modf_test (); + ilogb_test (); +Index: uClibc/libm/Makefile.in +=================================================================== +--- uClibc.orig/libm/Makefile.in 2008-07-25 11:03:27.000000000 +0200 ++++ uClibc/libm/Makefile.in 2008-08-28 10:54:29.714525665 +0200 +@@ -62,7 +62,7 @@ + libm_CSRC := \ + e_acos.c e_acosh.c e_asin.c e_atan2.c e_atanh.c e_cosh.c \ + e_exp.c e_fmod.c e_gamma.c e_gamma_r.c e_hypot.c e_j0.c \ +- e_j1.c e_jn.c e_lgamma.c e_lgamma_r.c e_log.c e_log10.c \ ++ e_j1.c e_jn.c e_lgamma.c e_lgamma_r.c e_log.c e_log2.c e_log10.c \ + e_pow.c e_remainder.c e_rem_pio2.c e_scalb.c e_sinh.c \ + e_sqrt.c k_cos.c k_rem_pio2.c k_sin.c k_standard.c k_tan.c \ + s_asinh.c s_atan.c s_cbrt.c s_ceil.c s_copysign.c s_cos.c \ +@@ -73,7 +73,7 @@ + s_tanh.c s_trunc.c w_acos.c w_acosh.c w_asin.c w_atan2.c w_atanh.c \ + w_cabs.c w_cosh.c w_drem.c w_exp.c w_fmod.c w_gamma.c w_gamma_r.c \ + w_hypot.c w_j0.c w_j1.c w_jn.c w_lgamma.c w_lgamma_r.c \ +- w_log.c w_log10.c w_pow.c w_remainder.c w_scalb.c w_sinh.c \ ++ w_log.c w_log2.c w_log10.c w_pow.c w_remainder.c w_scalb.c w_sinh.c \ + w_sqrt.c fpmacros.c nan.c carg.c s_llrint.c + FL_MOBJ := \ + acosf.o acoshf.o asinf.o asinhf.o atan2f.o atanf.o atanhf.o cbrtf.o \ +@@ -89,10 +89,10 @@ + libm_CSRC := \ + w_acos.c w_asin.c s_atan.c w_atan2.c s_ceil.c s_cos.c \ + w_cosh.c w_exp.c s_fabs.c s_floor.c w_fmod.c s_frexp.c \ +- s_ldexp.c w_log.c w_log10.c s_modf.c w_pow.c s_sin.c \ ++ s_ldexp.c w_log.c w_log2.c w_log10.c s_modf.c w_pow.c s_sin.c \ + w_sinh.c w_sqrt.c s_tan.c s_tanh.c \ + s_expm1.c s_scalbn.c s_copysign.c e_acos.c e_asin.c e_atan2.c \ +- k_cos.c e_cosh.c e_exp.c e_fmod.c e_log.c e_log10.c e_pow.c \ ++ k_cos.c e_cosh.c e_exp.c e_fmod.c e_log.c e_log2.c e_log10.c e_pow.c \ + k_sin.c e_sinh.c e_sqrt.c k_tan.c e_rem_pio2.c k_rem_pio2.c \ + s_finite.c + # We'll add sqrtf to avoid problems with libstdc++ +Index: uClibc/libm/w_log2.c +=================================================================== +--- /dev/null 1970-01-01 00:00:00.000000000 +0000 ++++ uClibc/libm/w_log2.c 2008-08-28 10:58:48.676013259 +0200 +@@ -0,0 +1,33 @@ ++/* ++ * wrapper log2(X) ++ */ ++ ++#include "math.h" ++#include "math_private.h" ++ ++libm_hidden_proto(log2) ++#ifdef __STDC__ ++ double log2(double x) /* wrapper log */ ++#else ++ double log2(x) /* wrapper log */ ++ double x; ++#endif ++{ ++#ifdef _IEEE_LIBM ++ return __ieee754_log2 (x); ++#else ++ double z; ++ z = __ieee754_log2 (x); ++ if (_LIB_VERSION == _IEEE_ || __isnan (x)) return z; ++ if (x <= 0.0) ++ { ++ if (x == 0.0) ++ return __kernel_standard (x, x, 48); /* log2 (0) */ ++ else ++ return __kernel_standard (x, x, 49); /* log2 (x < 0) */ ++ } ++ else ++ return z; ++#endif ++} ++libm_hidden_def(log2) +Index: uClibc/libm/e_log2.c +=================================================================== +--- /dev/null 1970-01-01 00:00:00.000000000 +0000 ++++ uClibc/libm/e_log2.c 2008-08-28 10:54:29.717859030 +0200 +@@ -0,0 +1,130 @@ ++/* Adapted for log2 by Ulrich Drepper . */ ++/* ++ * ==================================================== ++ * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved. ++ * ++ * Developed at SunPro, a Sun Microsystems, Inc. business. ++ * Permission to use, copy, modify, and distribute this ++ * software is freely granted, provided that this notice ++ * is preserved. ++ * ==================================================== ++ */ ++ ++/* __ieee754_log2(x) ++ * Return the logarithm to base 2 of x ++ * ++ * Method : ++ * 1. Argument Reduction: find k and f such that ++ * x = 2^k * (1+f), ++ * where sqrt(2)/2 < 1+f < sqrt(2) . ++ * ++ * 2. Approximation of log(1+f). ++ * Let s = f/(2+f) ; based on log(1+f) = log(1+s) - log(1-s) ++ * = 2s + 2/3 s**3 + 2/5 s**5 + ....., ++ * = 2s + s*R ++ * We use a special Reme algorithm on [0,0.1716] to generate ++ * a polynomial of degree 14 to approximate R The maximum error ++ * of this polynomial approximation is bounded by 2**-58.45. In ++ * other words, ++ * 2 4 6 8 10 12 14 ++ * R(z) ~ Lg1*s +Lg2*s +Lg3*s +Lg4*s +Lg5*s +Lg6*s +Lg7*s ++ * (the values of Lg1 to Lg7 are listed in the program) ++ * and ++ * | 2 14 | -58.45 ++ * | Lg1*s +...+Lg7*s - R(z) | <= 2 ++ * | | ++ * Note that 2s = f - s*f = f - hfsq + s*hfsq, where hfsq = f*f/2. ++ * In order to guarantee error in log below 1ulp, we compute log ++ * by ++ * log(1+f) = f - s*(f - R) (if f is not too large) ++ * log(1+f) = f - (hfsq - s*(hfsq+R)). (better accuracy) ++ * ++ * 3. Finally, log(x) = k + log(1+f). ++ * = k+(f-(hfsq-(s*(hfsq+R)))) ++ * ++ * Special cases: ++ * log2(x) is NaN with signal if x < 0 (including -INF) ; ++ * log2(+INF) is +INF; log(0) is -INF with signal; ++ * log2(NaN) is that NaN with no signal. ++ * ++ * Constants: ++ * The hexadecimal values are the intended ones for the following ++ * constants. The decimal values may be used, provided that the ++ * compiler will convert from decimal to binary accurately enough ++ * to produce the hexadecimal values shown. ++ */ ++ ++#include "math.h" ++#include "math_private.h" ++ ++#ifdef __STDC__ ++static const double ++#else ++static double ++#endif ++ln2 = 0.69314718055994530942, ++two54 = 1.80143985094819840000e+16, /* 43500000 00000000 */ ++Lg1 = 6.666666666666735130e-01, /* 3FE55555 55555593 */ ++Lg2 = 3.999999999940941908e-01, /* 3FD99999 9997FA04 */ ++Lg3 = 2.857142874366239149e-01, /* 3FD24924 94229359 */ ++Lg4 = 2.222219843214978396e-01, /* 3FCC71C5 1D8E78AF */ ++Lg5 = 1.818357216161805012e-01, /* 3FC74664 96CB03DE */ ++Lg6 = 1.531383769920937332e-01, /* 3FC39A09 D078C69F */ ++Lg7 = 1.479819860511658591e-01; /* 3FC2F112 DF3E5244 */ ++ ++#ifdef __STDC__ ++static const double zero = 0.0; ++#else ++static double zero = 0.0; ++#endif ++ ++#ifdef __STDC__ ++ double attribute_hidden __ieee754_log2(double x) ++#else ++ double attribute_hidden __ieee754_log2(x) ++ double x; ++#endif ++{ ++ double hfsq,f,s,z,R,w,t1,t2,dk; ++ int32_t k,hx,i,j; ++ u_int32_t lx; ++ ++ EXTRACT_WORDS(hx,lx,x); ++ ++ k=0; ++ if (hx < 0x00100000) { /* x < 2**-1022 */ ++ if (((hx&0x7fffffff)|lx)==0) ++ return -two54/(x-x); /* log(+-0)=-inf */ ++ if (hx<0) return (x-x)/(x-x); /* log(-#) = NaN */ ++ k -= 54; x *= two54; /* subnormal number, scale up x */ ++ GET_HIGH_WORD(hx,x); ++ } ++ if (hx >= 0x7ff00000) return x+x; ++ k += (hx>>20)-1023; ++ hx &= 0x000fffff; ++ i = (hx+0x95f64)&0x100000; ++ SET_HIGH_WORD(x,hx|(i^0x3ff00000)); /* normalize x or x/2 */ ++ k += (i>>20); ++ dk = (double) k; ++ f = x-1.0; ++ if((0x000fffff&(2+hx))<3) { /* |f| < 2**-20 */ ++ if(f==zero) return dk; ++ R = f*f*(0.5-0.33333333333333333*f); ++ return dk-(R-f)/ln2; ++ } ++ s = f/(2.0+f); ++ z = s*s; ++ i = hx-0x6147a; ++ w = z*z; ++ j = 0x6b851-hx; ++ t1= w*(Lg2+w*(Lg4+w*Lg6)); ++ t2= z*(Lg1+w*(Lg3+w*(Lg5+w*Lg7))); ++ i |= j; ++ R = t2+t1; ++ if(i>0) { ++ hfsq=0.5*f*f; ++ return dk-((hfsq-(s*(hfsq+R)))-f)/ln2; ++ } else { ++ return dk-((s*(f-R))-f)/ln2; ++ } ++} +Index: uClibc/libm/math_private.h +=================================================================== +--- uClibc.orig/libm/math_private.h 2008-05-07 00:23:27.000000000 +0200 ++++ uClibc/libm/math_private.h 2008-08-28 10:54:29.717859030 +0200 +@@ -158,6 +158,7 @@ + extern double __ieee754_acos (double) attribute_hidden; + extern double __ieee754_acosh (double) attribute_hidden; + extern double __ieee754_log (double) attribute_hidden; ++extern double __ieee754_log2 (double) attribute_hidden; + extern double __ieee754_atanh (double) attribute_hidden; + extern double __ieee754_asin (double) attribute_hidden; + extern double __ieee754_atan2 (double,double) attribute_hidden; +Index: uClibc/libm/float_wrappers.c +=================================================================== +--- uClibc.orig/libm/float_wrappers.c 2008-05-07 00:23:27.000000000 +0200 ++++ uClibc/libm/float_wrappers.c 2008-08-28 10:54:29.717859030 +0200 +@@ -20,7 +20,6 @@ + #undef L_fmaf /*float fmaf(float, float, float);*/ + #undef L_fmaxf /*float fmaxf(float, float);*/ + #undef L_fminf /*float fminf(float, float);*/ +-#undef L_log2f /*float log2f(float);*/ + #undef L_nearbyintf /*float nearbyintf(float);*/ + #undef L_nexttowardf /*float nexttowardf(float, long double);*/ + #undef L_remquof /*float remquof(float, float, int *);*/ +@@ -55,6 +54,7 @@ + float lgammaf(float); + long long llroundf(float); + float log10f(float); ++float log2f(float); + float log1pf(float); + float logbf(float); + float logf(float); diff --git a/packages/uclibc/uclibc_svn.bb b/packages/uclibc/uclibc_svn.bb index 7363d09b7c..e536424c40 100644 --- a/packages/uclibc/uclibc_svn.bb +++ b/packages/uclibc/uclibc_svn.bb @@ -8,7 +8,7 @@ # UCLIBC_BASE ?= "0.9.29" PV = "${UCLIBC_BASE}+svnr${SRCREV}" -PR = "r14" +PR = "r15" #DEFAULT_PREFERENCE is 0 (empty), releases have a preference of 1 so take # precedence. @@ -30,6 +30,9 @@ SRC_URI += "svn://uclibc.org/trunk;module=uClibc \ file://uclibc-arm-ftruncate64.patch;patch=1 \ file://arm_fix_alignment.patch;patch=1 \ file://unistd_arm.patch;patch=1 \ - " + file://arm-linuxthreads.patch;patch=1 \ + file://linuxthreads-changes.patch;patch=1 \ + file://uclibc_mathc99.patch;patch=1 \ + " S = "${WORKDIR}/uClibc" -- cgit 1.2.3-korg