* 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.

2 files changed, 501 insertions, 0 deletions

diff --git a/gdb/osf-share/AT386/.Sanitize b/gdb/osf-share/AT386/.Sanitize
new file mode 100644
index 0000000..2ef8e54
--- /dev/null
+++ b/gdb/osf-share/AT386/.Sanitize
@@ -0,0 +1,44 @@
+# .Sanitize for devo/gdb/osf-share/AT386.
+
+# Each directory to survive its way into a release will need a file
+# like this one called "./.Sanitize".  All keyword lines must exist,
+# and must exist in the order specified by this file.  Each directory
+# in the tree will be processed, top down, in the following order.
+
+# Hash started lines like this one are comments and will be deleted
+# before anything else is done.  Blank lines will also be squashed
+# out.
+
+# The lines between the "Do-first:" line and the "Things-to-keep:"
+# line are executed as a /bin/sh shell script before anything else is
+# done in this directory.
+
+Do-first:
+
+# All files listed between the "Things-to-keep:" line and the
+# "Files-to-sed:" line will be kept.  All other files will be removed.
+# Directories listed in this section will have their own Sanitize
+# called.  Directories not listed will be removed in their entirety
+# with rm -rf.
+
+Things-to-keep:
+
+cma_thread_io.h
+
+# Things which are explicitly *not* kept, for now.
+
+Things-to-lose:
+
+Do-last:
+
+# Don't try to clean directories here, as the 'mv' command will fail.
+# Also, grep fails on NFS mounted directories.
+
+for i in * ; do
+	if test ! -d $i && (grep sanitize $i > /dev/null) ; then
+		echo '***' Some mentions of Sanitize are still left in $i! 1>&2
+	fi
+done
+
+#
+# End of file.
diff --git a/gdb/osf-share/AT386/cma_thread_io.h b/gdb/osf-share/AT386/cma_thread_io.h
new file mode 100644
index 0000000..a90dba1
--- /dev/null
+++ b/gdb/osf-share/AT386/cma_thread_io.h
@@ -0,0 +1,457 @@
+/* 
+ * (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 thread synchrounous I/O
+ */
+
+#ifndef CMA_THREAD_IO
+#define CMA_THREAD_IO
+
+/*
+ *  INCLUDE FILES
+ */
+
+#include <cma_config.h>
+#include <sys/file.h>
+#include <cma.h>
+#include <sys/types.h>
+#include <sys/time.h>
+#include <cma_init.h>
+#include <cma_errors.h>
+
+/*
+ * CONSTANTS
+ */
+
+/*
+ * Define symbols which indicate whether to compile code for obsolete 
+ * "non-blocking mode" flags:  FNDELAY and FNBLOCK.  If the obsolete
+ * symbols are defined, and if their replacement symbols are defined 
+ * and are different or if they are undefined, then define a symbol
+ * that says to compile the code in; otherwise no code will be compiled
+ * for these obsolete symbols.
+ */
+#ifdef FNDELAY
+# ifdef O_NDELAY
+#  if O_NDELAY != FNDELAY
+#   define _CMA_FNDELAY_
+#  endif
+# else
+#  define _CMA_FNDELAY_
+# endif
+#endif
+
+#ifdef FNBLOCK
+# ifdef O_NONBLOCK
+#  if O_NONBLOCK != FNBLOCK
+#   define _CMA_FNBLOCK_
+#  endif
+# else
+#  define _CMA_FNBLOCK_
+# endif
+#endif
+
+
+extern cma_t_boolean cma_is_open(int);
+/*
+ * Maximum number of files (ie, max_fd+1)
+ */
+#define cma__c_mx_file	FD_SETSIZE
+
+/*
+ * Number of bits per file descriptor bit mask (ie number of bytes * bits/byte)
+ */
+#define cma__c_nbpm	NFDBITS
+
+/*
+ * TYPE DEFINITIONS
+ */
+
+typedef enum CMA__T_IO_TYPE {
+    cma__c_io_read   = 0,
+    cma__c_io_write  = 1,
+    cma__c_io_except = 2
+    } cma__t_io_type;
+#define cma__c_max_io_type	2
+
+/*
+ * From our local <sys/types.h>:
+ *
+ *  typedef long    fd_mask;
+ *
+ *  typedef struct fd_set {
+ *          fd_mask fds_bits[howmany(FD_SETSIZE, NFDBITS)];
+ *  } fd_set;
+ *
+ */
+typedef fd_mask cma__t_mask;
+typedef fd_set  cma__t_file_mask;
+
+
+/*
+ *  GLOBAL DATA
+ */
+
+/*
+ * Maximum number of files (ie, max_fd+1) as determined by getdtablesize().
+ */
+extern int	cma__g_mx_file;
+
+/*
+ * Number of submasks (ie "int" sized chunks) per file descriptor mask as
+ * determined by getdtablesize().
+ */
+extern int	cma__g_nspm;
+
+/*
+ * MACROS
+ */
+
+/*
+ * Define a constant for the errno value which indicates that the requested
+ * operation was not performed because it would block the process.
+ */
+# define cma__is_blocking(s) \
+    ((s == EAGAIN) || (s == EWOULDBLOCK) || (s == EINPROGRESS) || \
+     (s == EALREADY) || (s == EDEADLK))
+
+/*
+*	It is necessary to issue an I/O function, before calling cma__io_wait()
+*	in the following cases:
+*
+*		*	This file descriptor has been set non-blocking by CMA
+*		*	This file descriptor has been set non-blocking by the user.
+*/
+
+#define cma__issue_io_call(fd)					\
+	( (cma__g_file[fd]->non_blocking) || \
+	  (cma__g_file[fd]->user_fl.user_non_blocking) )
+
+
+#define cma__set_user_nonblocking(flags) \
+
+/*
+ * Determine if the file is open
+ */
+/*
+ * If the file gets closed while waiting for the mutex cma__g_file[rfd]
+ * gets set to null. This results in a crash if NDEBUG is set to 0 
+ * since cma__int_lock tries to dereference it to set the mutex ownership 
+ * after it gets the mutex. The following will still set the ownership
+ * in cma__int_lock so we'll set it back to noone if cma__g_file is null
+ * when we come back just in case it matters. It shouldn't since its no
+ * longer in use but..... 
+ * Callers of this should recheck cma__g_file after the reservation to
+ * make sure continueing makes sense.
+ */
+#define cma__fd_reserve(rfd) 	\
+		{ \
+		cma__t_int_mutex *__mutex__; \
+		__mutex__ = cma__g_file[rfd]->mutex; \
+		cma__int_lock (__mutex__); \
+		if(cma__g_file[rfd] == (cma__t_file_obj *)cma_c_null_ptr) \
+			cma__int_unlock(__mutex__); \
+		}
+		
+
+/*
+ * Unreserve a file descriptor
+ */
+#define cma__fd_unreserve(ufd)	cma__int_unlock (cma__g_file[ufd]->mutex)
+
+/*
+ * AND together two select file descriptor masks
+ */
+#define cma__fdm_and(target,a,b)					\
+	{								\
+	int __i__ = cma__g_nspm;					\
+	while (__i__--)							\
+	    (target)->fds_bits[__i__] =					\
+		(a)->fds_bits[__i__] & (b)->fds_bits[__i__];		\
+	}
+
+/*
+ * Clear a bit in a select file descriptor mask
+ *
+ * FD_CLR(n, p)  :=  ((p)->fds_bits[(n)/NFDBITS] &= ~(1 << ((n) % NFDBITS)))
+ */
+#define cma__fdm_clr_bit(n,p)	FD_CLR (n, p)
+
+/*
+ * Copy the contents of one file descriptor mask into another.  If the 
+ * destination operand is null, do nothing; if the source operand is null, 
+ * simply zero the destination.
+ */
+#define cma__fdm_copy(src,dst,nfds) {					\
+	if (dst)							\
+	    if (src) {							\
+		cma__t_mask *__s__ = (cma__t_mask *)(src);		\
+		cma__t_mask *__d__ = (cma__t_mask *)(dst);		\
+		int __i__;						\
+		for (__i__ = 0; __i__ < (nfds); __i__ += cma__c_nbpm)	\
+		    *__d__++ = *__s__++;				\
+		}							\
+	    else							\
+		cma__fdm_zero (dst);					\
+	    }
+
+/*
+ * To increment count for each bit set in fd - mask
+ */
+#define cma__fdm_count_bits(map,count)					\
+	{								\
+	int	__i__ = cma__g_nspm;					\
+	while (__i__--) {						\
+	    cma__t_mask    __tm__;				        \
+	    __tm__ = (map)->fds_bits[__i__];				\
+	    while(__tm__) {						\
+		(count)++;						\
+		__tm__ &= ~(__tm__ & (-__tm__)); /* Assumes 2's comp */	\
+		}							\
+	    }								\
+	}
+
+/*
+ * Test if a bit is set in a select file descriptor mask
+ *
+ * FD_ISSET(n,p)  :=  ((p)->fds_bits[(n)/NFDBITS] & (1 << ((n) % NFDBITS)))
+ */
+#define cma__fdm_is_set(n,p)	FD_ISSET (n, p)
+
+/*
+ * OR together two select file descriptor masks
+ */
+#define cma__fdm_or(target,a,b)						\
+	{								\
+	int __i__ = cma__g_nspm;					\
+	while (__i__--)							\
+	    (target)->fds_bits[__i__] =					\
+		(a)->fds_bits[__i__] | (b)->fds_bits[__i__];		\
+	}
+
+/*
+ * Set a bit in a select file descriptor mask
+ * 
+ * FD_SET(n,p)  :=  ((p)->fds_bits[(n)/NFDBITS] |= (1 << ((n) % NFDBITS)))
+ */
+#define cma__fdm_set_bit(n,p)	FD_SET (n, p)
+
+/*
+ * Clear a select file descriptor mask.
+ */
+#define cma__fdm_zero(n)						\
+	cma__memset ((char *) n, 0, cma__g_nspm * sizeof(cma__t_mask))
+
+
+
+/*
+ * CMA "thread-synchronous" I/O read/write operations
+ */
+
+    /*
+     * Since all CMA "thread-synchronous" I/O (read or write) operations on 
+     * U*ix follow the exact same structure, the wrapper routines have been
+     * condensed into a macro.
+     *
+     * The steps performed are as follows:
+     *	1. Check that the file descriptor is a legitimate value.
+     *	2. Check that the entry in the CMA file "database" which corresponds to 
+     *	    the file descriptor indicates that the "file" was "opened" by CMA.
+     *  3. Reserve the file, to serialized access to files.  This not only 
+     *	    simplifies things, but also defends against non-reentrancy.
+     *  4. If the "file" is "set" for non-blocking I/O, check if we
+     *      have actually set the file non-blocking yet, and if not do so.
+     *	    Then, issue the I/O operantion.
+     *	    Success or failure is returned immediately, after unreserving the 
+     *	    file.  If the error indicates that the operation would have caused
+     *	    the process to block, continue to the next step.
+     *	5. The I/O prolog adds this "file" to the global bit mask, which 
+     *	    represents all "files" which have threads waiting to perform I/O on 
+     *	    them, and causes the thread to block on the condition variable for
+     *	    this "file".  Periodically, a select is done on this global bit 
+     *	    mask, and the condition variables corresponding to "files" which 
+     *	    are ready for I/O are signaled, releasing those waiting threads to
+     *	    perform their I/O.
+     *  6. When the thread returns from the I/O prolog, it can (hopefully) 
+     *	    perform its operation without blocking the process.
+     *	7. The I/O epilog clears the bit in the global mask and/or signals the 
+     *	    the next thread waiting for this "file", as appropriate.
+     *  8. If the I/O failed, continue to loop.
+     *	9. Finally, the "file" is unreserved, as we're done with it, and the
+     *	    result of the operation is returned.
+     *
+     *
+     * Note:  currently, we believe that timeslicing which is based on the
+     *	    virtual-time timer does not cause system calls to return EINTR.  
+     *	    Threfore, any EINTR returns are relayed directly to the caller.
+     *	    On platforms which do not support a virtual-time timer, the code
+     *	    should probably catch EINTR returns and restart the system call.
+     */
+
+/*
+ * This macro is used for both read-type and write-type functions.
+ *
+ * Note:  the second call to "func" may require being bracketed in a
+ *	  cma__interrupt_disable/cma__interrupt_enable pair, but we'll 
+ *	  wait and see if this is necessary.
+ */
+#define cma__ts_func(func,fd,arglist,type,post_process)	{ \
+    cma_t_integer   __res__; \
+    cma_t_boolean   __done__ = cma_c_false; \
+    if ((fd < 0) || (fd >= cma__g_mx_file)) return (cma__set_errno (EBADF), -1); \
+    if (!cma__is_open(fd)) return (cma__set_errno (EBADF), -1); \
+    cma__fd_reserve (fd); \
+    if (!cma__is_open(fd)) return (cma__set_errno (EBADF), -1); \
+    if (cma__issue_io_call(fd)) {\
+	if ((!cma__g_file[fd]->set_non_blocking) && \
+		(cma__g_file[fd]->non_blocking == cma_c_true)) \
+	    cma__set_nonblocking(fd); \
+        cma__interrupt_disable (0); \
+	TRY { \
+	    __res__ = func arglist; \
+	    } \
+	CATCH_ALL { \
+	    cma__interrupt_enable (0); \
+	    cma__fd_unreserve (fd); \
+	    RERAISE; \
+	    } \
+	ENDTRY \
+        cma__interrupt_enable (0); \
+	if ((__res__ != -1) \
+		|| (!cma__is_blocking (errno)) \
+		|| (cma__g_file[fd]->user_fl.user_non_blocking)) \
+	    __done__ = cma_c_true; \
+	} \
+    if (__done__) { \
+	cma__fd_unreserve (fd); \
+	} \
+    else { \
+	TRY { \
+	    cma__io_prolog (type, fd); \
+	    while (!__done__) { \
+		cma__io_wait (type, fd); \
+		__res__ = func arglist; \
+		if ((__res__ != -1) \
+			|| (!cma__is_blocking (errno)) \
+			|| (cma__g_file[fd]->user_fl.user_non_blocking)) \
+		    __done__ = cma_c_true; \
+		} \
+	    } \
+	FINALLY { \
+	    cma__io_epilog (type, fd); \
+	    cma__fd_unreserve (fd); \
+	    } \
+	ENDTRY \
+	} \
+    if (__res__ != -1)  post_process; \
+    return __res__;  \
+    }
+
+    /*
+     * Since most CMA "thread-synchronous" I/O ("open"-type) operations on 
+     * U*ix follow the exact same structure, the wrapper routines have been
+     * condensed into a macro.
+     *
+     * The steps performed are as follows:
+     *	1. Issue the open function.
+     *	2. If the value returned indicates an error, return it to the caller.
+     *  3. If the file descriptor returned is larger than what we think is the
+     *	    maximum value (ie if it is too big for our database) then bugcheck.
+     *  4. "Open" the "file" in the CMA file database.
+     *	5. Return the file descriptor value to the caller.
+     *
+     * FIX-ME: for the time being, if the I/O operation returns EINTR, we 
+     *	    simply return it to the caller; eventually, we should catch this 
+     *	    and "do the right thing" (if we can figure out what that is).
+     */
+
+/*
+ * This macro is used for all "open"-type functions which return a single file
+ * desciptor by immediate value.
+ */
+#define cma__ts_open(func,arglist,post_process)  {		\
+    int	__fd__;							\
+    TRY {							\
+	cma__int_init ();					\
+	cma__int_lock (cma__g_io_data_mutex);			\
+	__fd__ = func arglist;					\
+	cma__int_unlock (cma__g_io_data_mutex);			\
+	if (__fd__ >= 0 && __fd__ < cma__g_mx_file)		\
+	    post_process;					\
+	}							\
+    CATCH_ALL							\
+	{							\
+	cma__set_errno (EBADF);					\
+	__fd__ = -1;						\
+	}							\
+    ENDTRY							\
+    if (__fd__ >= cma__g_mx_file)				\
+	cma__bugcheck ("cma__ts_open:  fd is too large");	\
+    return __fd__;						\
+    }
+/*
+ * This macro is used for all "open"-type functions which return a pair of file
+ * desciptors by reference parameter.
+ */
+#define cma__ts_open2(func,fdpair,arglist,post_process)  {		\
+    int	    __res__;							\
+    TRY {								\
+	cma__int_init ();						\
+	cma__int_lock (cma__g_io_data_mutex);				\
+	__res__ = func arglist;						\
+	cma__int_unlock (cma__g_io_data_mutex);				\
+	if (__res__ >= 0 && fdpair[0] < cma__g_mx_file			\
+		&& fdpair[1] < cma__g_mx_file)				\
+	    post_process;						\
+	}								\
+    CATCH_ALL								\
+	{								\
+	cma__set_errno (EBADF);						\
+	__res__ = -1;							\
+	}								\
+    ENDTRY								\
+    if ((fdpair[0] >= cma__g_mx_file) || (fdpair[1] >= cma__g_mx_file)) \
+	cma__bugcheck ("cma__ts_open2:  one of fd's is too large"); \
+    return __res__;							\
+    }
+
+/*
+ * INTERNAL INTERFACES
+ */
+extern void cma__close_general (int);
+
+extern void cma__init_thread_io (void);
+
+extern cma_t_boolean cma__io_available (cma__t_io_type,int,struct timeval *);
+
+extern void cma__io_epilog (cma__t_io_type,int);
+
+extern void cma__io_prolog (cma__t_io_type,int);
+
+extern void cma__io_wait (cma__t_io_type,int);
+
+extern void cma__open_general (int);
+
+extern void cma__reinit_thread_io (int);
+
+extern void cma__set_nonblocking (int);
+
+extern void cma__set_user_nonblock_flags (int,int);
+
+extern cma_t_boolean cma__is_open (int);
+
+
+#endif