mirror of
git://sourceware.org/git/newlib-cygwin.git
synced 2025-01-30 19:10:36 +08:00
bd54749095
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.
70 lines
2.4 KiB
C++
70 lines
2.4 KiB
C++
#ifndef __SYS_LOCK_H__
|
|
#define __SYS_LOCK_H__
|
|
|
|
/* dummy lock routines for single-threaded aps */
|
|
|
|
#include <newlib.h>
|
|
#include <_ansi.h>
|
|
|
|
#if !defined(_RETARGETABLE_LOCKING)
|
|
|
|
typedef int _LOCK_T;
|
|
typedef int _LOCK_RECURSIVE_T;
|
|
|
|
#define __LOCK_INIT(class,lock) static int lock = 0;
|
|
#define __LOCK_INIT_RECURSIVE(class,lock) static int lock = 0;
|
|
#define __lock_init(lock) (_CAST_VOID 0)
|
|
#define __lock_init_recursive(lock) (_CAST_VOID 0)
|
|
#define __lock_close(lock) (_CAST_VOID 0)
|
|
#define __lock_close_recursive(lock) (_CAST_VOID 0)
|
|
#define __lock_acquire(lock) (_CAST_VOID 0)
|
|
#define __lock_acquire_recursive(lock) (_CAST_VOID 0)
|
|
#define __lock_try_acquire(lock) (_CAST_VOID 0)
|
|
#define __lock_try_acquire_recursive(lock) (_CAST_VOID 0)
|
|
#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__ */
|