This is the mail archive of the
newlib@sourceware.org
mailing list for the newlib project.
[PATCH 2/2, 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, 24 Jan 2017 16:05:28 +0000
- Subject: [PATCH 2/2, newlib] Allow locking routine to be retargeted
- Authentication-results: sourceware.org; auth=none
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)
*/