From 5d394f707245c12a8839461df83a06a0997c1698 Mon Sep 17 00:00:00 2001 From: Stu Grossman Date: Tue, 8 Oct 1996 17:06:17 +0000 Subject: * Makefile.in: Add rule for hpux-thread.o (needs special header files). * (SUBDIRS): Remove mswin. * Change procedure for creating init.c. Speeds things up quite a bit. * config.in configure configure.in: Check for select, poll. * Check for OSF header files before including hpux-thread.o. * Don't configure doc or testsuite when building under MSVC. * findvar.c value.h (read_register_pid write_register_pid): Make global. Needed for hppa-tdep.c. * (supply_register): Don't set pid to inferior_pid when supplying registers. * hppa-tdep.c (saved_pc_after_call): frame_saved_pc -> FRAME_SAVED_PC. * (frame_saved_pc): Change name to hppa_frame_saved_pc. * (hppa_pop_frame): Don't use a pid of 0 with target_write_pc. Use write_pc instead, which uses the correct pid. * (target_read_pc target_write_pc): Use read/write_register_pid instead of read/write_register to preserve the pid passed in. * inftarg.c (child_can_run): Add flag child_suppress_run to allow hpux-threads.c to override this as a runnable target. * config/pa/nm-hppah.h: Define target_new_objfile and target_pid_to_str. * config/pa/tm-hppa.h (FRAME_SAVED_PC): Use hppa_frame_saved_pc instead of frame_saved_pc. * config/m68k/tm-m68k.h: Define TARGET_M68K for Wingdb. * config/m68k/tm-monitor.h: Use FRAME_CHAIN_VALID_ALTERNATE, since we can't easily determine the start file bounds with ELF. * config/mips/tm-mips.h: Define TARGET_MIPS for Wingdb. * hpux-thread.c: New file for HPUX/OSF thread support. * osf-share/{README AT386/cma_thread_io.h HP800/cma_thread_io.h RIOS/cma_thread_io.h cma_attr.h cma_deb_core.h cma_debug_client.h cma_errors.h cma_handle.h cma_init.h cma_list.h cma_mutex.h cma_sched.h cma_semaphore_defs.h cma_sequence.h cma_stack.h cma_stack_int.h cma_tcb_defs.h cma_util.h}: New files for OSF thread support. --- gdb/osf-share/cma_mutex.h | 230 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 230 insertions(+) create mode 100644 gdb/osf-share/cma_mutex.h (limited to 'gdb/osf-share/cma_mutex.h') diff --git a/gdb/osf-share/cma_mutex.h b/gdb/osf-share/cma_mutex.h new file mode 100644 index 0000000..c178630 --- /dev/null +++ b/gdb/osf-share/cma_mutex.h @@ -0,0 +1,230 @@ +/* + * (c) Copyright 1990-1996 OPEN SOFTWARE FOUNDATION, INC. + * (c) Copyright 1990-1996 HEWLETT-PACKARD COMPANY + * (c) Copyright 1990-1996 DIGITAL EQUIPMENT CORPORATION + * (c) Copyright 1991, 1992 Siemens-Nixdorf Information Systems + * To anyone who acknowledges that this file is provided "AS IS" without + * any express or implied warranty: permission to use, copy, modify, and + * distribute this file for any purpose is hereby granted without fee, + * provided that the above copyright notices and this notice appears in + * all source code copies, and that none of the names listed above be used + * in advertising or publicity pertaining to distribution of the software + * without specific, written prior permission. None of these organizations + * makes any representations about the suitability of this software for + * any purpose. + */ +/* + * Header file for mutex operations + */ + +#ifndef CMA_MUTEX +#define CMA_MUTEX + +/* + * INCLUDE FILES + */ + +#include +#include +#include +#include +#include +#include +#include + +/* + * CONSTANTS AND MACROS + */ + +/* + * TYPEDEFS + */ + +typedef struct CMA__T_INT_MUTEX { + cma__t_object header; /* Common header (sequence, type) */ + cma__t_int_attr *attributes; /* Back link */ + cma__t_int_tcb *owner; /* Current owner (if any) */ + cma_t_integer nest_count; /* Nesting level for recursive mutex */ + cma__t_atomic_bit *unlock; /* Pointer used for unlock operation */ + cma__t_atomic_bit lock; /* Set if currently locked */ + struct CMA__T_INT_MUTEX *int_lock; /* Internal protection for mutex */ + cma__t_atomic_bit event; /* Clear when unlock requires action */ + cma__t_atomic_bit waiters; /* Clear when threads are waiting */ + cma__t_atomic_bit bitbucket; /* Fake bit to keep friendlies locked */ + cma_t_mutex_kind mutex_kind; /* Kind of mutex */ + cma__t_semaphore semaphore; /* Semaphore for low-level wait */ + } cma__t_int_mutex; + + +/* + * FUNCTIONAL DESCRIPTION: + * + * Lock a mutex (internal) + * + * FORMAL PARAMETERS: + * + * mutex Pointer to mutex object to lock + * + * IMPLICIT INPUTS: + * + * none + * + * IMPLICIT OUTPUTS: + * + * none + * + * FUNCTION VALUE: + * + * none + * + * SIDE EFFECTS: + * + * none + */ +#ifdef NDEBUG +# define cma__int_lock(mutex) { \ + if (cma__test_and_set (&((cma__t_int_mutex *)mutex)->lock)) { \ + cma_t_status res;\ + res = cma__int_mutex_block ((cma__t_int_mutex *)mutex); \ + if (res != cma_s_normal) cma__error (res); \ + } \ + } +#else +# define cma__int_lock(mutex) { \ + cma__t_int_tcb *__ltcb__; \ + __ltcb__ = cma__get_self_tcb (); \ + if (cma__test_and_set (&((cma__t_int_mutex *)mutex)->lock)) { \ + cma_t_status res;\ + res = cma__int_mutex_block ((cma__t_int_mutex *)mutex); \ + if (res != cma_s_normal) cma__error (res); \ + } \ + ((cma__t_int_mutex *)mutex)->owner = __ltcb__; \ + } +#endif + +/* + * FUNCTIONAL DESCRIPTION: + * + * Unlock a mutex (internal) + * + * FORMAL PARAMETERS: + * + * mutex Pointer to mutex object to unlock + * + * IMPLICIT INPUTS: + * + * none + * + * IMPLICIT OUTPUTS: + * + * none + * + * FUNCTION VALUE: + * + * none + * + * SIDE EFFECTS: + * + * none + */ +#ifdef NDEBUG +# define cma__int_unlock(mutex) { \ + cma__unset (((cma__t_int_mutex *)mutex)->unlock); \ + if (!cma__test_and_set (&((cma__t_int_mutex *)mutex)->event)) { \ + cma_t_status res;\ + res = cma__int_mutex_unblock ((cma__t_int_mutex *)mutex); \ + if (res != cma_s_normal) cma__error (res); \ + } \ + } +#else +# define cma__int_unlock(mutex) { \ + cma__t_int_tcb *__utcb__; \ + __utcb__ = cma__get_self_tcb (); \ + if (((cma__t_int_mutex *)mutex)->mutex_kind == cma_c_mutex_fast) { \ + cma__assert_warn ( \ + (__utcb__ == ((cma__t_int_mutex *)mutex)->owner), \ + "attempt to release mutx owned by another thread"); \ + ((cma__t_int_mutex *)mutex)->owner = (cma__t_int_tcb *)cma_c_null_ptr; \ + } \ + cma__unset (((cma__t_int_mutex *)mutex)->unlock); \ + if (!cma__test_and_set (&((cma__t_int_mutex *)mutex)->event)) { \ + cma_t_status res;\ + res = cma__int_mutex_unblock ((cma__t_int_mutex *)mutex); \ + if (res != cma_s_normal) cma__error (res); \ + } \ + } +#endif + +/* + * FUNCTIONAL DESCRIPTION: + * + * cma__int_mutex_delete - Performs work for cma_mutex_delete + * + * FORMAL PARAMETERS: + * + * cma__t_mutex _mutex_ - Mutex to be deleted + * + * IMPLICIT INPUTS: + * + * none + * + * IMPLICIT OUTPUTS: + * + * none + * + * FUNCTION VALUE: + * + * none + * + * SIDE EFFECTS: + * + * none + */ +#define cma__int_mutex_delete(_mutex_) { \ + cma__t_int_mutex *_int_mutex_; \ + _int_mutex_ = cma__validate_null_mutex (_mutex_); \ + if (_int_mutex_ == (cma__t_int_mutex *)cma_c_null_ptr) \ + return; \ + if (cma__int_mutex_locked (_int_mutex_)) \ + cma__error (cma_s_in_use); \ + cma__free_mutex (_int_mutex_); \ + cma__clear_handle (_mutex_); \ + } + + +/* + * GLOBAL DATA + */ + +extern cma__t_sequence cma__g_mutex_seq; +extern cma__t_int_mutex *cma__g_global_lock; + +/* + * INTERNAL INTERFACES + */ + +extern void cma__destroy_mutex (cma__t_int_mutex *); + +extern void cma__free_mutex (cma__t_int_mutex *); + +extern void cma__free_mutex_nolock (cma__t_int_mutex *); + +extern cma__t_int_mutex * cma__get_first_mutex (cma__t_int_attr *); + +extern cma__t_int_mutex * cma__get_mutex (cma__t_int_attr *); + +extern void cma__init_mutex (void); + +extern cma_t_status cma__int_mutex_block (cma__t_int_mutex *); + +extern cma_t_boolean cma__int_mutex_locked (cma__t_int_mutex *); + +extern cma_t_boolean cma__int_try_lock (cma__t_int_mutex *); + +extern cma_t_status cma__int_mutex_unblock (cma__t_int_mutex *); + +extern cma_t_boolean cma__mutex_locked (cma_t_mutex); + +extern void cma__reinit_mutex (cma_t_integer); + +#endif -- cgit v1.1