This is the mail archive of the newlib@sourceware.org mailing list for the newlib project.

Index Nav:	[Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav:	[Date Prev] [Date Next]	[Thread Prev] [Thread Next]
Other format:	[Raw text]

Re: [PATCH 3/3, newlib] Allow locking routine to be retargeted

From: Thomas Preudhomme <thomas dot preudhomme at foss dot arm dot com>
To: newlib at sourceware dot org
Date: Tue, 31 Jan 2017 17:19:11 +0000
Subject: Re: [PATCH 3/3, newlib] Allow locking routine to be retargeted
Authentication-results: sourceware.org; auth=none
References: <53697464-af87-8917-c5ec-b1a0d06cca00@foss.arm.com> <20170125113934.GD21591@calimero.vinschen.de> <1247899115.19685162.1485376973312.JavaMail.zimbra@redhat.com>

Please find an updated patch in attachment in git format-patch format.

Freddie: I have only guarded the dummy lock definition with __SINGLE_THREAD__for simplicity. I did add the lock for arc4random though.


As to your other comments:

> 1. Why is the lock used by at_quick_exit() not required - I have no
> idea. The linking error (when I do not provide storage for this lock)
> about multiple definitions is visible only when I actually use the
> at_quick_exit() function.

That makes sense. If you don't use at_quick_exit then probably no symbol in thecorresponding object file is referenced and therefore the file is not linked in.That's exactly why the "doubly defined error on missing symbol" work asexplained in the cover letter: file with dummy symbol is only linked in if itsolves an undefined reference.


Best regards,

Thomas

On 25/01/17 20:42, Jeff Johnston wrote:

I am fine with this but I would like to see the struct _lock renamed
to be struct __lock and the lock names double-underscored to stay out of user
name space.  After that, it is fine for check-in.

-- Jeff J.

----- Original Message -----

Jeff?

On Jan 24 16:05, Thomas Preudhomme wrote:

Hi,

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.

Testing: I've built a simple test program that calls malloc and free with
all the locking function defined in the same file. Running into a debugger
with breakpoints on the function shows that they are indeed called. Newlib
testsuite (the 30 tests that run wich check-target-newlib from GCC) also
comes back clean.

Is this ok for master branch?

Best regards,

Thomas

diff --git a/newlib/configure b/newlib/configure
index
2ac07fe06bfc795d94ba36d0061e4f8135146125..de28c25b3c4aaeed14b6d0ee8354fdd5c5c3115a
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
bfaf038c7f495d32d05ae8caff0172f464895ffe..354c07ca580edf75da59fb858ca2c434e0b1a4e9
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
4dc4d1bf703f388ecd3b4e0d8bef6786f7995021..dabe44fd98d74a2e029a22a217953dd52575736f
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
0a7bb8815be44fb1e92f753fa2c8df2a31b95f94..ac25a3933c4a4794f3cfe291e0275d0ed001b96a
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
9075e35c9179968031010432515e3a845ff6ca8d..9a8e2528c79a89d5807da8c4bb0e65151870bf42
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 <newlib.h>
+#include <_ansi.h>
+
+#ifndef _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 /* _RETARGETABLE_LOCKING */
+
 #endif /* __SYS_LOCK_H__ */
diff --git a/newlib/libc/misc/Makefile.am b/newlib/libc/misc/Makefile.am
index
3fe8e55f53ca87ba55f3a676b213e55fa66e77aa..7571ef26335c053315ad3f3df428a4742a9cf368
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
0ada8de34e7a3a6084dbab4bfa7caf8cb7f8d8f3..e7925231c203897d917f41accf6560e3336895bc
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
0000000000000000000000000000000000000000..1c69575b33f666c8170c2fe8473ad428f2741137
--- /dev/null
+++ b/newlib/libc/misc/lock.c
@@ -0,0 +1,149 @@
+/*
+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_lock
+INDEX
+	_lock___sfp_lock
+INDEX
+	_lock___atexit_lock
+INDEX
+	_lock___atexit_mutex
+INDEX
+	_lock___malloc_lock_object
+INDEX
+	_lock___env_lock_object
+INDEX
+	_lock___tz_lock_object
+INDEX
+	_lock___dd_hash_lock
+
+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 <lock.h>
+	struct _lock _lock___sinit_lock;
+	struct _lock _lock___sfp_lock;
+	struct _lock _lock___atexit_lock;
+	struct _lock _lock___atexit_mutex;
+	struct _lock _lock___malloc_lock_object;
+	struct _lock _lock___env_lock_object;
+	struct _lock _lock___tz_lock_object;
+	struct _lock _lock___dd_hash_lock;
+
+	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 */
+
+#include <sys/lock.h>
+
+struct _lock {
+  char unused;
+};
+
+struct _lock _lock___sinit_lock;
+struct _lock _lock___sfp_lock;
+struct _lock _lock___atexit_lock;
+struct _lock _lock___atexit_mutex;
+struct _lock _lock___malloc_lock_object;
+struct _lock _lock___env_lock_object;
+struct _lock _lock___tz_lock_object;
+struct _lock _lock___dd_hash_lock;
+
+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)
+{
+}
diff --git a/newlib/libc/misc/misc.tex b/newlib/libc/misc/misc.tex
index
22c313eb15c7676443ff4c928c8c76cc038f3f0f..6afd1be5c4a1e90ffd64881c63c5132e144ad364
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
+* lock::     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
d03dfac0eea6a8917a92b8f0f3584c2cd42b9388..397bc9b96eafddace3a75be509157040654b6fde
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)
  */



--
Corinna Vinschen
Cygwin Maintainer
Red Hat

>From e258b516753336eba73828e5627c3aa7c8491eae Mon Sep 17 00:00:00 2001
From: Thomas Preud'homme <thomas.preudhomme@arm.com>
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        | 155 +++++++++++++++++++++++++++++++++++++++++
 newlib/libc/misc/misc.tex      |   4 ++
 newlib/newlib.hin              |   3 +
 10 files changed, 314 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 a406ec7..130fbbf 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 <newlib.h>
+#include <_ansi.h>
+
+#if defined(__SINGLE_THREAD__) || !defined(_RETARGETABLE_LOCKING)
+
 typedef int _LOCK_T;
 typedef int _LOCK_RECURSIVE_T;
- 
-#include <_ansi.h>
 
 #ifdef __SINGLE_THREAD__
 #define __LOCK_INIT(class,lock) ;
@@ -27,4 +30,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(__SINGLE_THREAD__) && 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..dfb4eb4
--- /dev/null
+++ b/newlib/libc/misc/lock.c
@@ -0,0 +1,155 @@
+/*
+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_lock
+INDEX
+	_lock___sfp_lock
+INDEX
+	_lock___atexit_lock
+INDEX
+	_lock___atexit_mutex
+INDEX
+	_lock___malloc_lock_object
+INDEX
+	_lock___env_lock_object
+INDEX
+	_lock___tz_lock_object
+INDEX
+	_lock___dd_hash_lock
+
+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 <lock.h>
+	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 <sys/lock.h>
+
+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..6afd1be 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
+* lock::     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

Follow-Ups:
- Re: [PATCH 3/3, newlib] Allow locking routine to be retargeted
  - From: Freddie Chopin
- Re: [PATCH 3/3, newlib] Allow locking routine to be retargeted
  - From: Freddie Chopin

References:
- [PATCH 2/2, newlib] Allow locking routine to be retargeted
  - From: Thomas Preudhomme
- Re: [PATCH 2/2, newlib] Allow locking routine to be retargeted
  - From: Corinna Vinschen
- Re: [PATCH 2/2, newlib] Allow locking routine to be retargeted
  - From: Jeff Johnston

Index Nav:	[Date Index] [Subject Index] [Author Index] [Thread Index]
Message Nav:	[Date Prev] [Date Next]	[Thread Prev] [Thread Next]