From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 29221 invoked by alias); 10 Feb 2017 11:15:56 -0000 Mailing-List: contact newlib-help@sourceware.org; run by ezmlm Precedence: bulk List-Id: List-Subscribe: List-Archive: List-Post: List-Help: , Sender: newlib-owner@sourceware.org Received: (qmail 29212 invoked by uid 89); 10 Feb 2017 11:15:55 -0000 Authentication-Results: sourceware.org; auth=none X-Virus-Found: No X-Spam-SWARE-Status: No, score=1.8 required=5.0 tests=BAYES_50,KAM_LAZY_DOMAIN_SECURITY,RP_MATCHES_RCVD autolearn=no version=3.3.2 spammy=misc, 22526, miscellaneous, UD:la X-HELO: foss.arm.com Received: from foss.arm.com (HELO foss.arm.com) (217.140.101.70) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Fri, 10 Feb 2017 11:15:45 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.72.51.249]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id 361D7C14; Fri, 10 Feb 2017 03:15:44 -0800 (PST) Received: from [10.2.206.52] (usa-sjc-imap-foss1.foss.arm.com [10.72.51.249]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id DA9BD3F3D6 for ; Fri, 10 Feb 2017 03:15:43 -0800 (PST) Subject: Re: [PATCH 3/3, newlib] Allow locking routine to be retargeted To: newlib@sourceware.org References: <53697464-af87-8917-c5ec-b1a0d06cca00@foss.arm.com> <20170125113934.GD21591@calimero.vinschen.de> <1247899115.19685162.1485376973312.JavaMail.zimbra@redhat.com> <7477136f-dc07-5081-a06f-2144a8ce2251@foss.arm.com> <1485938598.1269.1.camel@op.pl> <5e4abc64-54d7-9402-d2ac-d08c4d419402@foss.arm.com> <336826923.24372261.1486503410689.JavaMail.zimbra@redhat.com> <9f1e2c24-40d9-c163-4895-fb2ad418165d@foss.arm.com> <1199540764.24714361.1486590050100.JavaMail.zimbra@redhat.com> From: Thomas Preudhomme Message-ID: <6cc898f2-c2e9-5d38-d4be-03194bc3201d@foss.arm.com> Date: Fri, 10 Feb 2017 11:15:00 -0000 User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:45.0) Gecko/20100101 Thunderbird/45.7.0 MIME-Version: 1.0 In-Reply-To: <1199540764.24714361.1486590050100.JavaMail.zimbra@redhat.com> Content-Type: multipart/mixed; boundary="------------5488A6BC825F4511BD3DCFC0" X-IsSubscribed: yes X-SW-Source: 2017/txt/msg00138.txt.bz2 This is a multi-part message in MIME format. --------------5488A6BC825F4511BD3DCFC0 Content-Type: text/plain; charset=utf-8; format=flowed Content-Transfer-Encoding: 7bit Content-length: 8371 Hi Jeff, Please find an updated patch which does not add extra noop code for single threaded mode in sys/lock.h as requested. Please note that it goes together with an updated version of the previous patch in the patch series [1]. [1] https://sourceware.org/ml/newlib/2017/msg00136.html Best regards, Thomas On 08/02/17 21:40, Jeff Johnston wrote: > Thanks Thomas, > > Regarding that other patch. I do not feel the extra noop code in sys/lock.h is warranted and > seems extraneous. I would prefer the users of the lock protect the usage as you have added. > > -- Jeff J. > > ----- Original Message ----- >> Hi Jeff, >> >> Please find an updated patch with consistent lock naming. Have you had a look >> at >> the patch prior to this one [1]? >> >> [1] https://sourceware.org/ml/newlib/2017/msg00112.html >> >> Thanks for your time. >> >> Best regards, >> >> Thomas >> >> On 07/02/17 21:36, Jeff Johnston wrote: >>> Hi Thomas, >>> >>> The patch is fine except for the lock.c inline docs still have references >>> to old lock names (prior to the ANSI_SYNOPSIS). >>> >>> -- Jeff J. >>> >>> ----- Original Message ----- >>>> Ooops, forgot about this. Please find an updated patch attached. >>>> >>>> Best regards, >>>> >>>> Thomas >>>> >>>> On 01/02/17 08:43, Freddie Chopin wrote: >>>>> Hi! >>>>> >>>>> With all relevant 3 patches applied the toolchain builds and works >>>>> fine, but the issue with HTML documentation still persists - at least >>>>> here on Arch Linux: >>>>> >>>>> --- >8 --- >8 --- >8 --- >8 --- >8 --- >8 --- >8 --- >8 --- >8 --- >>>>> >>>>> make[2]: Entering directory '/home/freddie/bleeding-edge- >>>>> toolchain/buildNative/newlib-2.5.0/arm-none-eabi/newlib/libc/syscalls' >>>>> for chapter in ; \ >>>>> do \ >>>>> cat /home/freddie/bleeding-edge-toolchain/sources/newlib- >>>>> 2.5.0/newlib/libc/syscalls/$chapter >> /home/freddie/bleeding-edge- >>>>> toolchain/buildNative/newlib-2.5.0/arm-none-eabi/newlib/libc/tmp- >>>>> targetdep.texi ; \ >>>>> done >>>>> make[2]: Leaving directory '/home/freddie/bleeding-edge- >>>>> toolchain/buildNative/newlib-2.5.0/arm-none-eabi/newlib/libc/syscalls' >>>>> cat /home/freddie/bleeding-edge-toolchain/sources/newlib- >>>>> 2.5.0/newlib/libc/sys.tex >>tmp-targetdep.texi >>>>> /bin/sh /home/freddie/bleeding-edge-toolchain/sources/newlib- >>>>> 2.5.0/newlib/libc/../../move-if-change tmp-targetdep.texi targetdep.tex >>>>> touch stmp-targetdep >>>>> rm -rf libc.htp >>>>> if makeinfo --split-size=5000000 --html -I /home/freddie/bleeding- >>>>> edge-toolchain/sources/newlib-2.5.0/newlib/libc \ >>>>> -o libc.htp /home/freddie/bleeding-edge-toolchain/sources/newlib- >>>>> 2.5.0/newlib/libc/libc.texinfo; \ >>>>> then \ >>>>> rm -rf libc.html; \ >>>>> if test ! -d libc.htp && test -d libc; then \ >>>>> mv libc libc.html; else mv libc.htp libc.html; fi; \ >>>>> else \ >>>>> if test ! -d libc.htp && test -d libc; then \ >>>>> rm -rf libc; else rm -Rf libc.htp libc.html; fi; \ >>>>> exit 1; \ >>>>> fi >>>>> ./targetdep.tex:1420: @menu reference to nonexistent node `lock' >>>>> stdlib/div.def:1: warning: node next `div' in menu `ecvtbuf' and in >>>>> sectioning `ecvt' differ >>>>> stdlib/efgcvt.def:1: warning: node next `ecvt' in menu `__env_lock' and >>>>> in sectioning `gcvt' differ >>>>> stdlib/efgcvt.def:1: warning: node prev `ecvt' in menu `ecvtbuf' and in >>>>> sectioning `div' differ >>>>> stdlib/efgcvt.def:60: warning: node next `gcvt' in menu `exit' and in >>>>> sectioning `ecvtbuf' differ >>>>> stdlib/efgcvt.def:60: warning: node prev `gcvt' in menu `__env_lock' >>>>> and in sectioning `ecvt' differ >>>>> stdlib/ecvtbuf.def:1: warning: node next `ecvtbuf' in menu `ecvt' and >>>>> in sectioning `__env_lock' differ >>>>> stdlib/ecvtbuf.def:1: warning: node prev `ecvtbuf' in menu `div' and in >>>>> sectioning `gcvt' differ >>>>> stdlib/envlock.def:1: warning: node next `__env_lock' in menu `gcvt' >>>>> and in sectioning `exit' differ >>>>> stdlib/envlock.def:1: warning: node prev `__env_lock' in menu `ecvt' >>>>> and in sectioning `ecvtbuf' differ >>>>> stdlib/exit.def:1: warning: node prev `exit' in menu `gcvt' and in >>>>> sectioning `__env_lock' differ >>>>> stdlib/mlock.def:1: warning: node next `__malloc_lock' in menu >>>>> `mbsrtowcs' and in sectioning `mblen' differ >>>>> stdlib/mblen.def:1: warning: node next `mblen' in menu `mbtowc' and in >>>>> sectioning `mbsrtowcs' differ >>>>> stdlib/mblen.def:1: warning: node prev `mblen' in menu `mbstowcs' and >>>>> in sectioning `__malloc_lock' differ >>>>> stdlib/mbsnrtowcs.def:1: warning: node prev `mbsrtowcs' in menu >>>>> `__malloc_lock' and in sectioning `mblen' differ >>>>> stdlib/mbstowcs.def:1: warning: node next `mbstowcs' in menu `mblen' >>>>> and in sectioning `mbtowc' differ >>>>> stdlib/mbtowc.def:1: warning: node prev `mbtowc' in menu `mblen' and in >>>>> sectioning `mbstowcs' differ >>>>> ctype/iswalpha.def:1: warning: node next `iswalpha' in menu `iswblank' >>>>> and in sectioning `iswcntrl' differ >>>>> ctype/iswcntrl.def:1: warning: node next `iswcntrl' in menu `iswdigit' >>>>> and in sectioning `iswblank' differ >>>>> ctype/iswcntrl.def:1: warning: node prev `iswcntrl' in menu `iswblank' >>>>> and in sectioning `iswalpha' differ >>>>> ctype/iswblank.def:1: warning: node next `iswblank' in menu `iswcntrl' >>>>> and in sectioning `iswdigit' differ >>>>> ctype/iswblank.def:1: warning: node prev `iswblank' in menu `iswalpha' >>>>> and in sectioning `iswcntrl' differ >>>>> ctype/iswdigit.def:1: warning: node prev `iswdigit' in menu `iswcntrl' >>>>> and in sectioning `iswblank' differ >>>>> misc/ffs.def:1: warning: node next `ffs' in menu `unctrl' and in >>>>> sectioning `__retarget_lock_init' differ >>>>> misc/lock.def:1: warning: unreferenced node `__retarget_lock_init' >>>>> misc/lock.def:1: warning: node `unctrl' is next for >>>>> `__retarget_lock_init' in sectioning but not in menu >>>>> misc/lock.def:1: warning: node `ffs' is prev for `__retarget_lock_init' >>>>> in sectioning but not in menu >>>>> misc/lock.def:1: warning: node `Misc' is up for `__retarget_lock_init' >>>>> in sectioning but not in menu >>>>> ./targetdep.tex:1414: node `Misc' lacks menu item for >>>>> `__retarget_lock_init' despite being its Up target >>>>> misc/unctrl.def:1: warning: node prev `unctrl' in menu `ffs' and in >>>>> sectioning `__retarget_lock_init' differ >>>>> reent/execr.def:19: warning: node next `_fork_r' in menu `_fstat_r' and >>>>> in sectioning `_wait_r' differ >>>>> reent/execr.def:36: warning: node next `_wait_r' in menu `_write_r' and >>>>> in sectioning `_fstat_r' differ >>>>> reent/execr.def:36: warning: node prev `_wait_r' in menu `_unlink_r' >>>>> and in sectioning `_fork_r' differ >>>>> reent/fstatr.def:1: warning: node next `_fstat_r' in menu `_getpid_r' >>>>> and in sectioning `_link_r' differ >>>>> reent/fstatr.def:1: warning: node prev `_fstat_r' in menu `_fork_r' and >>>>> in sectioning `_wait_r' differ >>>>> reent/linkr.def:1: warning: node prev `_link_r' in menu `_kill_r' and >>>>> in sectioning `_fstat_r' differ >>>>> reent/sbrkr.def:1: warning: node next `_sbrk_r' in menu `_stat_r' and >>>>> in sectioning `_kill_r' differ >>>>> reent/signalr.def:1: warning: node next `_kill_r' in menu `_link_r' and >>>>> in sectioning `_getpid_r' differ >>>>> reent/signalr.def:1: warning: node prev `_kill_r' in menu `_getpid_r' >>>>> and in sectioning `_sbrk_r' differ >>>>> reent/signalr.def:18: warning: node next `_getpid_r' in menu `_kill_r' >>>>> and in sectioning `_stat_r' differ >>>>> reent/signalr.def:18: warning: node prev `_getpid_r' in menu `_fstat_r' >>>>> and in sectioning `_kill_r' differ >>>>> reent/statr.def:1: warning: node prev `_stat_r' in menu `_sbrk_r' and >>>>> in sectioning `_getpid_r' differ >>>>> reent/unlinkr.def:1: warning: node next `_unlink_r' in menu `_wait_r' >>>>> and in sectioning `_write_r' differ >>>>> reent/writer.def:1: warning: node prev `_write_r' in menu `_wait_r' and >>>>> in sectioning `_unlink_r' differ >>>>> make[1]: *** [Makefile:561: libc.html] Error 1 >>>>> make[1]: Leaving directory '/home/freddie/bleeding-edge- >>>>> toolchain/buildNative/newlib-2.5.0/arm-none-eabi/newlib/libc' >>>>> make: *** [Makefile:680: install-html-recursive] Error 1 >>>>> >>>>> --- >8 --- >8 --- >8 --- >8 --- >8 --- >8 --- >8 --- >8 --- >8 --- >>>>> >>>>> Regards, >>>>> FCh >>>>> >>>> >> --------------5488A6BC825F4511BD3DCFC0 Content-Type: text/x-patch; name="newlib_retargetable_locking_routine.patch" Content-Transfer-Encoding: 7bit Content-Disposition: attachment; filename="newlib_retargetable_locking_routine.patch" Content-length: 21312 >From 22f744ec5afd49b2b9f419b851fc73905dbac59e Mon Sep 17 00:00:00 2001 From: Thomas Preud'homme Date: Tue, 25 Oct 2016 17:38:19 +0100 Subject: [PATCH 2/2] Allow locking routine to be retargeted At the moment when targeting bare-metal targets or systems without definition for the locking primitives newlib, uses dummy empty macros. This has the advantage of reduced size and faster implementation but does not allow the application to retarget the locking routines. Retargeting is useful for a single toolchain to support multiple systems since then it's only at link time that you know which system you are targeting. This patch adds a new configure option --enable-newlib-retargetable-locking to use dummy empty functions instead of dummy empty macros. The default is to keep the current behavior to not have any size or speed impact on targets not interested in this feature. To allow for any size of lock, the _LOCK_T type is changed into pointer to struct _lock and the _init function are tasked with allocating the locks. The platform being targeted must provide the static locks. A dummy implementation of the locking routines and static lock is provided for single-threaded applications to link successfully out of the box. To ensure that the behavior is consistent (either no locking whatsoever or working locking), the dummy implementation is strongly defined such that a partial retargeting will cause a doubly defined link error. Indeed, the linker will only pull in the file providing the dummy implementation if it cannot find an implementation for one of the routine or lock. --- newlib/configure | 25 ++++++- newlib/configure.in | 15 ++++ newlib/libc/configure | 32 ++++++++- newlib/libc/configure.in | 10 +++ newlib/libc/include/sys/lock.h | 49 ++++++++++++- newlib/libc/misc/Makefile.am | 7 +- newlib/libc/misc/Makefile.in | 28 ++++++-- newlib/libc/misc/lock.c | 157 +++++++++++++++++++++++++++++++++++++++++ newlib/libc/misc/misc.tex | 4 ++ newlib/newlib.hin | 3 + 10 files changed, 316 insertions(+), 14 deletions(-) create mode 100644 newlib/libc/misc/lock.c diff --git a/newlib/configure b/newlib/configure index 2ac07fe..de28c25 100755 --- a/newlib/configure +++ b/newlib/configure @@ -802,6 +802,7 @@ enable_newlib_nano_malloc enable_newlib_unbuf_stream_opt enable_lite_exit enable_newlib_nano_formatted_io +enable_newlib_retargetable_locking enable_multilib enable_target_optspace enable_malloc_debugging @@ -1473,6 +1474,7 @@ Optional Features: --disable-newlib-unbuf-stream-opt disable unbuffered stream optimization in streamio --enable-lite-exit enable light weight exit --enable-newlib-nano-formatted-io Use nano version formatted IO + --enable-newlib-retargetable-locking Allow locking routines to be retargeted at link time --enable-multilib build many library versions (default) --enable-target-optspace optimize for space --enable-malloc-debugging indicate malloc debugging requested @@ -2474,6 +2476,18 @@ else fi +# Check whether --enable-newlib-retargetable-locking was given. +if test "${enable_newlib_retargetable_locking+set}" = set; then : + enableval=$enable_newlib_retargetable_locking; case "${enableval}" in + yes) newlib_retargetable_locking=yes ;; + no) newlib_retargetable_locking=no ;; + *) as_fn_error $? "bad value ${enableval} for newlib-retargetable-locking" "$LINENO" 5 ;; + esac +else + newlib_retargetable_locking=no +fi + + # Make sure we can run config.sub. $SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 || @@ -11780,7 +11794,7 @@ else lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 lt_status=$lt_dlunknown cat > conftest.$ac_ext <<_LT_EOF -#line 11783 "configure" +#line 11797 "configure" #include "confdefs.h" #if HAVE_DLFCN_H @@ -11886,7 +11900,7 @@ else lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 lt_status=$lt_dlunknown cat > conftest.$ac_ext <<_LT_EOF -#line 11889 "configure" +#line 11903 "configure" #include "confdefs.h" #if HAVE_DLFCN_H @@ -12455,6 +12469,13 @@ _ACEOF fi +if test "${newlib_retargetable_locking}" = "yes"; then +cat >>confdefs.h <<_ACEOF +#define _RETARGETABLE_LOCKING 1 +_ACEOF + +fi + if test "x${iconv_encodings}" != "x" \ || test "x${iconv_to_encodings}" != "x" \ diff --git a/newlib/configure.in b/newlib/configure.in index bfaf038..354c07c 100644 --- a/newlib/configure.in +++ b/newlib/configure.in @@ -218,6 +218,17 @@ AC_ARG_ENABLE(newlib_nano_formatted_io, *) AC_MSG_ERROR(bad value ${enableval} for newlib-nano-formatted-io) ;; esac],[newlib_nano_formatted_io=no]) +dnl Support --enable-retargetable-locking +dnl This option is also read in libc/configure.in. It is repeated +dnl here so that it shows up in the help text. +AC_ARG_ENABLE(newlib-retargetable-locking, +[ --enable-newlib-retargetable-locking Allow locking routines to be retargeted at link time], +[case "${enableval}" in + yes) newlib_retargetable_locking=yes ;; + no) newlib_retargetable_locking=no ;; + *) AC_MSG_ERROR(bad value ${enableval} for newlib-retargetable-locking) ;; + esac],[newlib_retargetable_locking=no]) + NEWLIB_CONFIGURE(.) dnl We have to enable libtool after NEWLIB_CONFIGURE because if we try and @@ -458,6 +469,10 @@ if test "${newlib_nano_formatted_io}" = "yes"; then AC_DEFINE_UNQUOTED(_NANO_FORMATTED_IO) fi +if test "${newlib_retargetable_locking}" = "yes"; then +AC_DEFINE_UNQUOTED(_RETARGETABLE_LOCKING) +fi + dnl dnl Parse --enable-newlib-iconv-encodings option argument dnl diff --git a/newlib/libc/configure b/newlib/libc/configure index 4dc4d1b..dabe44f 100755 --- a/newlib/libc/configure +++ b/newlib/libc/configure @@ -751,6 +751,8 @@ build newlib_basedir MAY_SUPPLY_SYSCALLS_FALSE MAY_SUPPLY_SYSCALLS_TRUE +NEWLIB_RETARGETABLE_LOCKING_FALSE +NEWLIB_RETARGETABLE_LOCKING_TRUE NEWLIB_NANO_FORMATTED_IO_FALSE NEWLIB_NANO_FORMATTED_IO_TRUE target_alias @@ -797,6 +799,7 @@ enable_option_checking enable_newlib_io_pos_args enable_newlib_nano_malloc enable_newlib_nano_formatted_io +enable_newlib_retargetable_locking enable_multilib enable_target_optspace enable_malloc_debugging @@ -1448,6 +1451,7 @@ Optional Features: --enable-newlib-io-pos-args enable printf-family positional arg support --enable-newlib-nano-malloc Use small-footprint nano-malloc implementation --enable-newlib-nano-formatted-io Use small-footprint nano-formatted-IO implementation + --enable-newlib-retargetable-locking Allow locking routines to be retargeted at link time --enable-multilib build many library versions (default) --enable-target-optspace optimize for space --enable-malloc-debugging indicate malloc debugging requested @@ -2252,6 +2256,26 @@ else fi +# Check whether --enable-newlib-retargetable-locking was given. +if test "${enable_newlib_retargetable_locking+set}" = set; then : + enableval=$enable_newlib_retargetable_locking; case "${enableval}" in + yes) newlib_retargetable_locking=yes ;; + no) newlib_retargetable_lock=no ;; + *) as_fn_error $? "bad value ${enableval} for newlib-retargetable-locking" "$LINENO" 5 ;; + esac +else + newlib_retargetable_locking=no +fi + + if test x$newlib_retargetable_locking = xyes; then + NEWLIB_RETARGETABLE_LOCKING_TRUE= + NEWLIB_RETARGETABLE_LOCKING_FALSE='#' +else + NEWLIB_RETARGETABLE_LOCKING_TRUE='#' + NEWLIB_RETARGETABLE_LOCKING_FALSE= +fi + + # Make sure we can run config.sub. $SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 || @@ -11525,7 +11549,7 @@ else lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 lt_status=$lt_dlunknown cat > conftest.$ac_ext <<_LT_EOF -#line 11528 "configure" +#line 11552 "configure" #include "confdefs.h" #if HAVE_DLFCN_H @@ -11631,7 +11655,7 @@ else lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2 lt_status=$lt_dlunknown cat > conftest.$ac_ext <<_LT_EOF -#line 11634 "configure" +#line 11658 "configure" #include "confdefs.h" #if HAVE_DLFCN_H @@ -12248,6 +12272,10 @@ if test -z "${NEWLIB_NANO_FORMATTED_IO_TRUE}" && test -z "${NEWLIB_NANO_FORMATTE as_fn_error $? "conditional \"NEWLIB_NANO_FORMATTED_IO\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 fi +if test -z "${NEWLIB_RETARGETABLE_LOCKING_TRUE}" && test -z "${NEWLIB_RETARGETABLE_LOCKING_FALSE}"; then + as_fn_error $? "conditional \"NEWLIB_RETARGETABLE_LOCKING\" was never defined. +Usually this means the macro was only invoked conditionally." "$LINENO" 5 +fi if test -z "${MAY_SUPPLY_SYSCALLS_TRUE}" && test -z "${MAY_SUPPLY_SYSCALLS_FALSE}"; then as_fn_error $? "conditional \"MAY_SUPPLY_SYSCALLS\" was never defined. Usually this means the macro was only invoked conditionally." "$LINENO" 5 diff --git a/newlib/libc/configure.in b/newlib/libc/configure.in index 0a7bb88..ac25a39 100644 --- a/newlib/libc/configure.in +++ b/newlib/libc/configure.in @@ -36,6 +36,16 @@ AC_ARG_ENABLE(newlib_nano_formatted_io, esac],[newlib_nano_formatted_io=no]) AM_CONDITIONAL(NEWLIB_NANO_FORMATTED_IO, test x$newlib_nano_formatted_io = xyes) +dnl Support --enable-retargetable-locking used by libc/sys +AC_ARG_ENABLE(newlib-retargetable-locking, +[ --enable-newlib-retargetable-locking Allow locking routines to be retargeted at link time], +[case "${enableval}" in + yes) newlib_retargetable_locking=yes ;; + no) newlib_retargetable_lock=no ;; + *) AC_MSG_ERROR(bad value ${enableval} for newlib-retargetable-locking) ;; + esac],[newlib_retargetable_locking=no]) +AM_CONDITIONAL(NEWLIB_RETARGETABLE_LOCKING, test x$newlib_retargetable_locking = xyes) + NEWLIB_CONFIGURE(..) AM_CONDITIONAL(NEWLIB_NANO_MALLOC, test x$newlib_nano_malloc = xyes) diff --git a/newlib/libc/include/sys/lock.h b/newlib/libc/include/sys/lock.h index 9075e35..42f9c4c 100644 --- a/newlib/libc/include/sys/lock.h +++ b/newlib/libc/include/sys/lock.h @@ -3,10 +3,13 @@ /* dummy lock routines for single-threaded aps */ +#include +#include <_ansi.h> + +#if !defined(_RETARGETABLE_LOCKING) + typedef int _LOCK_T; typedef int _LOCK_RECURSIVE_T; - -#include <_ansi.h> #define __LOCK_INIT(class,lock) static int lock = 0; #define __LOCK_INIT_RECURSIVE(class,lock) static int lock = 0; @@ -21,4 +24,46 @@ typedef int _LOCK_RECURSIVE_T; #define __lock_release(lock) (_CAST_VOID 0) #define __lock_release_recursive(lock) (_CAST_VOID 0) +#else + +#ifdef __cplusplus +extern "C" { +#endif + +struct __lock; +typedef struct __lock * _LOCK_T; +#define _LOCK_RECURSIVE_T _LOCK_T + +#define __LOCK_INIT(class,lock) extern struct __lock __lock_ ## lock; \ + class _LOCK_T lock = &__lock_ ## lock +#define __LOCK_INIT_RECURSIVE(class,lock) __LOCK_INIT(class,lock) + +extern void __retarget_lock_init(_LOCK_T *lock); +#define __lock_init(lock) __retarget_lock_init(&lock) +extern void __retarget_lock_init_recursive(_LOCK_T *lock); +#define __lock_init_recursive(lock) __retarget_lock_init_recursive(&lock) +extern void __retarget_lock_close(_LOCK_T lock); +#define __lock_close(lock) __retarget_lock_close(lock) +extern void __retarget_lock_close_recursive(_LOCK_T lock); +#define __lock_close_recursive(lock) __retarget_lock_close_recursive(lock) +extern void __retarget_lock_acquire(_LOCK_T lock); +#define __lock_acquire(lock) __retarget_lock_acquire(lock) +extern void __retarget_lock_acquire_recursive(_LOCK_T lock); +#define __lock_acquire_recursive(lock) __retarget_lock_acquire_recursive(lock) +extern int __retarget_lock_try_acquire(_LOCK_T lock); +#define __lock_try_acquire(lock) __retarget_lock_try_acquire(lock) +extern int __retarget_lock_try_acquire_recursive(_LOCK_T lock); +#define __lock_try_acquire_recursive(lock) \ + __retarget_lock_try_acquire_recursive(lock) +extern void __retarget_lock_release(_LOCK_T lock); +#define __lock_release(lock) __retarget_lock_release(lock) +extern void __retarget_lock_release_recursive(_LOCK_T lock); +#define __lock_release_recursive(lock) __retarget_lock_release_recursive(lock) + +#ifdef __cplusplus +} +#endif + +#endif /* !defined(_RETARGETABLE_LOCKING) */ + #endif /* __SYS_LOCK_H__ */ diff --git a/newlib/libc/misc/Makefile.am b/newlib/libc/misc/Makefile.am index 3fe8e55..7571ef2 100644 --- a/newlib/libc/misc/Makefile.am +++ b/newlib/libc/misc/Makefile.am @@ -6,6 +6,11 @@ INCLUDES = $(NEWLIB_CFLAGS) $(CROSS_CFLAGS) $(TARGET_CFLAGS) LIB_SOURCES = __dprintf.c unctrl.c ffs.c init.c fini.c +if NEWLIB_RETARGETABLE_LOCKING +LIB_SOURCES += \ + lock.c +endif + libmisc_la_LDFLAGS = -Xcompiler -nostdlib if USE_LIBTOOL @@ -21,5 +26,5 @@ endif # USE_LIBTOOL include $(srcdir)/../../Makefile.shared -CHEWOUT_FILES = unctrl.def ffs.def +CHEWOUT_FILES = unctrl.def lock.def ffs.def CHAPTERS = misc.tex diff --git a/newlib/libc/misc/Makefile.in b/newlib/libc/misc/Makefile.in index 0ada8de..e792523 100644 --- a/newlib/libc/misc/Makefile.in +++ b/newlib/libc/misc/Makefile.in @@ -53,6 +53,9 @@ PRE_UNINSTALL = : POST_UNINSTALL = : build_triplet = @build@ host_triplet = @host@ +@NEWLIB_RETARGETABLE_LOCKING_TRUE@am__append_1 = \ +@NEWLIB_RETARGETABLE_LOCKING_TRUE@ lock.c + DIST_COMMON = $(srcdir)/../../Makefile.shared $(srcdir)/Makefile.in \ $(srcdir)/Makefile.am subdir = misc @@ -72,14 +75,19 @@ LIBRARIES = $(noinst_LIBRARIES) ARFLAGS = cru lib_a_AR = $(AR) $(ARFLAGS) lib_a_LIBADD = -am__objects_1 = lib_a-__dprintf.$(OBJEXT) lib_a-unctrl.$(OBJEXT) \ - lib_a-ffs.$(OBJEXT) lib_a-init.$(OBJEXT) lib_a-fini.$(OBJEXT) -@USE_LIBTOOL_FALSE@am_lib_a_OBJECTS = $(am__objects_1) +@NEWLIB_RETARGETABLE_LOCKING_TRUE@am__objects_1 = \ +@NEWLIB_RETARGETABLE_LOCKING_TRUE@ lib_a-lock.$(OBJEXT) +am__objects_2 = lib_a-__dprintf.$(OBJEXT) lib_a-unctrl.$(OBJEXT) \ + lib_a-ffs.$(OBJEXT) lib_a-init.$(OBJEXT) lib_a-fini.$(OBJEXT) \ + $(am__objects_1) +@USE_LIBTOOL_FALSE@am_lib_a_OBJECTS = $(am__objects_2) lib_a_OBJECTS = $(am_lib_a_OBJECTS) LTLIBRARIES = $(noinst_LTLIBRARIES) libmisc_la_LIBADD = -am__objects_2 = __dprintf.lo unctrl.lo ffs.lo init.lo fini.lo -@USE_LIBTOOL_TRUE@am_libmisc_la_OBJECTS = $(am__objects_2) +@NEWLIB_RETARGETABLE_LOCKING_TRUE@am__objects_3 = lock.lo +am__objects_4 = __dprintf.lo unctrl.lo ffs.lo init.lo fini.lo \ + $(am__objects_3) +@USE_LIBTOOL_TRUE@am_libmisc_la_OBJECTS = $(am__objects_4) libmisc_la_OBJECTS = $(am_libmisc_la_OBJECTS) libmisc_la_LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) \ $(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \ @@ -252,7 +260,7 @@ top_builddir = @top_builddir@ top_srcdir = @top_srcdir@ AUTOMAKE_OPTIONS = cygnus INCLUDES = $(NEWLIB_CFLAGS) $(CROSS_CFLAGS) $(TARGET_CFLAGS) -LIB_SOURCES = __dprintf.c unctrl.c ffs.c init.c fini.c +LIB_SOURCES = __dprintf.c unctrl.c ffs.c init.c fini.c $(am__append_1) libmisc_la_LDFLAGS = -Xcompiler -nostdlib @USE_LIBTOOL_TRUE@noinst_LTLIBRARIES = libmisc.la @USE_LIBTOOL_TRUE@libmisc_la_SOURCES = $(LIB_SOURCES) @@ -271,7 +279,7 @@ DOCBOOK_CHEW = ${top_srcdir}/../doc/makedocbook.py DOCBOOK_OUT_FILES = $(CHEWOUT_FILES:.def=.xml) DOCBOOK_CHAPTERS = $(CHAPTERS:.tex=.xml) CLEANFILES = $(CHEWOUT_FILES) $(CHEWOUT_FILES:.def=.ref) $(DOCBOOK_OUT_FILES) -CHEWOUT_FILES = unctrl.def ffs.def +CHEWOUT_FILES = unctrl.def lock.def ffs.def CHAPTERS = misc.tex all: all-am @@ -372,6 +380,12 @@ lib_a-fini.o: fini.c lib_a-fini.obj: fini.c $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(lib_a_CFLAGS) $(CFLAGS) -c -o lib_a-fini.obj `if test -f 'fini.c'; then $(CYGPATH_W) 'fini.c'; else $(CYGPATH_W) '$(srcdir)/fini.c'; fi` +lib_a-lock.o: lock.c + $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(lib_a_CFLAGS) $(CFLAGS) -c -o lib_a-lock.o `test -f 'lock.c' || echo '$(srcdir)/'`lock.c + +lib_a-lock.obj: lock.c + $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(lib_a_CFLAGS) $(CFLAGS) -c -o lib_a-lock.obj `if test -f 'lock.c'; then $(CYGPATH_W) 'lock.c'; else $(CYGPATH_W) '$(srcdir)/lock.c'; fi` + mostlyclean-libtool: -rm -f *.lo diff --git a/newlib/libc/misc/lock.c b/newlib/libc/misc/lock.c new file mode 100644 index 0000000..a763176 --- /dev/null +++ b/newlib/libc/misc/lock.c @@ -0,0 +1,157 @@ +/* +FUNCTION +<<__retarget_lock_init>>, <<__retarget_lock_init_recursive>>, <<__retarget_lock_close>>, <<__retarget_lock_close_recursive>>, <<__retarget_lock_acquire>>, <<__retarget_lock_acquire_recursive>>, <<__retarget_lock_try_acquire>>, <<__retarget_lock_try_acquire_recursive>>, <<__retarget_lock_release>>, <<__retarget_lock_release_recursive>>---locking routines + +INDEX + __lock___sinit_recursive_mutex +INDEX + __lock___sfp_recursive_mutex +INDEX + __lock___atexit_recursive_mutex +INDEX + __lock___at_quick_exit_mutex +INDEX + __lock___malloc_recursive_mutex +INDEX + __lock___env_recursive_mutex +INDEX + __lock___tz_mutex +INDEX + __lock___dd_hash_mutex +INDEX + __lock___arc4random_mutex + +INDEX + __retarget_lock_init +INDEX + __retarget_lock_init_recursive +INDEX + __retarget_lock_close +INDEX + __retarget_lock_close_recursive +INDEX + __retarget_lock_acquire +INDEX + __retarget_lock_acquire_recursive +INDEX + __retarget_lock_try_acquire +INDEX + __retarget_lock_try_acquire_recursive +INDEX + __retarget_lock_release +INDEX + __retarget_lock_release_recursive + +ANSI_SYNOPSIS + #include + struct __lock __lock___sinit_recursive_mutex; + struct __lock __lock___sfp_recursive_mutex; + struct __lock __lock___atexit_recursive_mutex; + struct __lock __lock___at_quick_exit_mutex; + struct __lock __lock___malloc_recursive_mutex; + struct __lock __lock___env_recursive_mutex; + struct __lock __lock___tz_mutex; + struct __lock __lock___dd_hash_mutex; + struct __lock __lock___arc4random_mutex; + + void __retarget_lock_init (_LOCK_T * <[lock_ptr]>); + void __retarget_lock_init_recursive (_LOCK_T * <[lock_ptr]>); + void __retarget_lock_close (_LOCK_T <[lock]>); + void __retarget_lock_close_recursive (_LOCK_T <[lock]>); + void __retarget_lock_acquire (_LOCK_T <[lock]>); + void __retarget_lock_acquire_recursive (_LOCK_T <[lock]>); + int __retarget_lock_try_acquire (_LOCK_T <[lock]>); + int __retarget_lock_try_acquire_recursive (_LOCK_T <[lock]>); + void __retarget_lock_release (_LOCK_T <[lock]>); + void __retarget_lock_release_recursive (_LOCK_T <[lock]>); + +DESCRIPTION +Newlib was configured to allow the target platform to provide the locking +routines and static locks at link time. As such, a dummy default +implementation of these routines and static locks is provided for +single-threaded application to link successfully out of the box on bare-metal +systems. + +For multi-threaded applications the target platform is required to provide +an implementation for @strong{all} these routines and static locks. If some +routines or static locks are missing, the link will fail with doubly defined +symbols. + +PORTABILITY +These locking routines and static lock are newlib-specific. Supporting OS +subroutines are required for linking multi-threaded applications. +*/ + +/* dummy lock routines and static locks for single-threaded apps */ + +#ifndef __SINGLE_THREAD__ + +#include + +struct __lock { + char unused; +}; + +struct __lock __lock___sinit_recursive_mutex; +struct __lock __lock___sfp_recursive_mutex; +struct __lock __lock___atexit_recursive_mutex; +struct __lock __lock___at_quick_exit_mutex; +struct __lock __lock___malloc_recursive_mutex; +struct __lock __lock___env_recursive_mutex; +struct __lock __lock___tz_mutex; +struct __lock __lock___dd_hash_mutex; +struct __lock __lock___arc4random_mutex; + +void +__retarget_lock_init (_LOCK_T *lock) +{ +} + +void +__retarget_lock_init_recursive(_LOCK_T *lock) +{ +} + +void +__retarget_lock_close(_LOCK_T lock) +{ +} + +void +__retarget_lock_close_recursive(_LOCK_T lock) +{ +} + +void +__retarget_lock_acquire (_LOCK_T lock) +{ +} + +void +__retarget_lock_acquire_recursive (_LOCK_T lock) +{ +} + +int +__retarget_lock_try_acquire(_LOCK_T lock) +{ + return 1; +} + +int +__retarget_lock_try_acquire_recursive(_LOCK_T lock) +{ + return 1; +} + +void +__retarget_lock_release (_LOCK_T lock) +{ +} + +void +__retarget_lock_release_recursive (_LOCK_T lock) +{ +} + +#endif /* !defined(__SINGLE_THREAD__) */ diff --git a/newlib/libc/misc/misc.tex b/newlib/libc/misc/misc.tex index 22c313e..248243b 100644 --- a/newlib/libc/misc/misc.tex +++ b/newlib/libc/misc/misc.tex @@ -4,6 +4,7 @@ This chapter describes miscellaneous routines not covered elsewhere. @menu * ffs:: Return first bit set in a word +* __retarget_lock_init:: Retargetable locking routines * unctrl:: Return printable representation of a character @end menu @@ -11,4 +12,7 @@ This chapter describes miscellaneous routines not covered elsewhere. @include misc/ffs.def @page +@include misc/lock.def + +@page @include misc/unctrl.def diff --git a/newlib/newlib.hin b/newlib/newlib.hin index d03dfac..397bc9b 100644 --- a/newlib/newlib.hin +++ b/newlib/newlib.hin @@ -82,6 +82,9 @@ /* Define if small footprint nano-formatted-IO implementation used. */ #undef _NANO_FORMATTED_IO +/* Define if using retargetable functions for default lock routines. */ +#undef _RETARGETABLE_LOCKING + /* * Iconv encodings enabled ("to" direction) */ -- 1.9.1 --------------5488A6BC825F4511BD3DCFC0--