Add lotsa files for 29k UDI debugger interface support.

11 files changed, 2403 insertions, 0 deletions

diff --git a/gdb/29k-share/.Sanitize b/gdb/29k-share/.Sanitize
new file mode 100644
index 0000000..5ac8d03
--- /dev/null
+++ b/gdb/29k-share/.Sanitize
@@ -0,0 +1,35 @@
+# .Sanitize for devo/gdb.
+# $Id$
+#
+
+# Each directory to survive it's 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 
+
+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:
+
+dfe
+include
+udi
+udi_soc
+
+Do-last:
+
+# End of file.
diff --git a/gdb/29k-share/udi/.Sanitize b/gdb/29k-share/udi/.Sanitize
new file mode 100644
index 0000000..bd7b85f
--- /dev/null
+++ b/gdb/29k-share/udi/.Sanitize
@@ -0,0 +1,41 @@
+# .Sanitize for devo/gdb.
+# $Id$
+#
+
+# Each directory to survive it's 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 
+
+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:
+
+soc2udip.c
+udi2mtip.c
+udip2soc.c
+udiphcfg.h
+udiphsun.h
+udiproc.h
+udipt29k.h
+udiptcfg.h
+udisoc.h
+udr.c
+
+Do-last:
+
+# End of file.
diff --git a/gdb/29k-share/udi/udip2soc.c b/gdb/29k-share/udi/udip2soc.c
new file mode 100644
index 0000000..a9c9991
--- /dev/null
+++ b/gdb/29k-share/udi/udip2soc.c
@@ -0,0 +1,1189 @@
+/*
+* Copyright 1991 Advanced Micro Devices, Inc.
+* 
+* This software is the property of Advanced Micro Devices, Inc  (AMD)  which
+* specifically  grants the user the right to modify, use and distribute this
+* software provided this notice is not removed or altered.  All other rights
+* are reserved by AMD.
+*
+* AMD MAKES NO WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, WITH REGARD TO THIS
+* SOFTWARE.  IN NO EVENT SHALL AMD BE LIABLE FOR INCIDENTAL OR CONSEQUENTIAL
+* DAMAGES IN CONNECTION WITH OR ARISING FROM THE FURNISHING, PERFORMANCE, OR
+* USE OF THIS SOFTWARE.
+*
+* So that all may benefit from your experience, please report  any  problems
+* or  suggestions about this software to the 29K Technical Support Center at
+* 800-29-29-AMD (800-292-9263) in the USA, or 0800-89-1131  in  the  UK,  or
+* 0031-11-1129 in Japan, toll free.  The direct dial number is 512-462-4118.
+*
+* Advanced Micro Devices, Inc.
+* 29K Support Products
+* Mail Stop 573
+* 5900 E. Ben White Blvd.
+* Austin, TX 78741
+* 800-292-9263
+*****************************************************************************
+*/
+static 	char udip2soc_c[]="@(#)udip2soc.c	2.11  Daniel Mann";
+static  char udip2soc_c_AMD[]="@(#)udip2soc.c	2.8, AMD";
+/* 
+*       This module converts UDI Procedural calls into
+*	UDI socket messages for UNIX. 
+*	It is used by DFE client processes
+********************************************************************** HISTORY
+*/
+#include <stdio.h>
+#include <string.h>
+#include <sys/file.h>
+#include <sys/fcntl.h>
+#include <sys/wait.h>
+#include <sys/time.h>
+#include <sys/resource.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netdb.h>
+#include <signal.h>
+#include <sys/errno.h>
+#include "udiproc.h"
+#include "udisoc.h"
+
+extern	int		errno;
+extern	int		sys_nerr;
+extern	char*		sys_errlist[];
+extern	int		udr_errno;
+extern	char*		getenv();
+
+/* local type decs. and macro defs. not in a .h  file ************* MACRO/TYPE
+*/
+#define		version_c 0x121		/* DFE-IPC version id */
+#define		TRUE -1
+#define		FALSE 0
+#define		PORT_NUM 7000
+#define		MAX_SESSIONS 5		/* maximum DFE-TIP connections */
+#define		SOC_BUF_SIZE 4* 1024	/* size of socket comms buffer */
+#define		SBUF_SIZE 500		/* size of string buffer */
+#define		ERRMSG_SIZE 500		/* size of error message buffer */
+
+#define	errmsg_m {int ii; for(ii=0; ii<ERRMSG_SIZE; ii++) dfe_errmsg[ii]=0;}
+
+typedef struct connection_str		/* record of connect session */
+{
+    int		in_use;
+    char	connect_id[20];		/* connection identifier */
+    char	domain_string[20];	/* dommaing for conection */
+    char	tip_string[30];		/* TIP host name for AF_INET */
+    char	tip_exe[80];		/* TIP exe name */
+    int		dfe_sd;			/* associated DFE socket */
+    int		tip_pid;		/* pid of TIP process */
+    struct sockaddr_in dfe_sockaddr;
+    struct sockaddr_in tip_sockaddr_in;
+    struct sockaddr    tip_sockaddr;
+} connection_t;
+
+typedef struct session_str
+{
+    int		  in_use;
+    connection_t* soc_con_p;		/* associated connection */
+    UDISessionId  tip_id;		/* associated TIP session ID */
+} session_t;
+
+/* global dec/defs. which are not in a .h   file ************* EXPORT DEC/DEFS
+*/
+UDIError	dfe_errno;
+char	dfe_errmsg[ERRMSG_SIZE];/* error string */
+
+/* local dec/defs. which are not in a .h   file *************** LOCAL DEC/DEFS
+*/
+LOCAL connection_t	soc_con[MAX_SESSIONS];	
+LOCAL session_t	session[MAX_SESSIONS];	
+LOCAL UDR	udr;
+LOCAL UDR*	udrs = &udr;		/* UDR for current session */
+LOCAL int	current;		/* int-id for current session */
+LOCAL char	sbuf[SBUF_SIZE];	/* String handler buffer */
+LOCAL char	config_file[80];	/* path/name for config file */
+
+/***************************************************************** UDI_CONNECT
+* Establish a new FDE to TIP conection. The file "./udi_soc" or
+* "/etc/udi_soc" may be examined to obtain the conection information
+* if the "Config" parameter is not a completd "line entry".
+*
+* NOTE: the Session string must not start whith white-space characters.
+* Format of string is:
+* <session>   <domain> <soc_name|host_name> <tip_exe|port> <pass to UDIconnect>
+* soc2cayman  AF_INET            cayman      7000           <not supported>
+* soc2tip     AF_UNIX   astring              tip.exe        ...
+*/
+UDIConnect(Config, Session)
+char*	Config;			/* in  -- identification string */
+UDISessionId *Session;		/* out -- session ID */
+{
+    UDIInt32	service_id = UDIConnect_c;
+    int		domain;
+    int		cnt=0;
+    int		rcnt, pos, fd, params_pos=0;
+    char	*tip_main_string;
+    char	*env_p;
+    struct hostent	*tip_info_p;
+    FILE	*f_p;
+    UDIUInt32	TIPIPCId;
+    UDIUInt32	DFEIPCId;
+
+    sprintf(sbuf, "which udi_soc");
+    f_p = popen(sbuf, "r");
+    if(f_p)
+    {   while( (sbuf[cnt++]=getc(f_p)) != EOF);
+	sbuf[cnt-2]=0;
+    }
+    pclose(f_p);
+    errmsg_m;
+    for (rcnt=0; rcnt < MAX_SESSIONS; rcnt++)
+        if(!session[rcnt].in_use) break;
+    if(rcnt >= MAX_SESSIONS)
+    {
+        sprintf(dfe_errmsg, "DFE-ipc ERROR: Too many sessions already open");
+        return UDIErrorIPCLimitation;
+    }
+    /* One connection can be multiplexed between several sessions. */
+    for (cnt=0; cnt < MAX_SESSIONS; cnt++)	
+        if(!soc_con[cnt].in_use) break;
+    if(cnt >= MAX_SESSIONS)
+    {
+        sprintf(dfe_errmsg, "DFE-ipc ERROR: Too many connections already open");
+        return UDIErrorIPCLimitation;
+    }
+    *Session = rcnt;
+    session[rcnt].soc_con_p = &soc_con[cnt];
+
+    if(strchr(Config, ' '))		/* test if file entry given */
+    {
+        soc_con[cnt].in_use = TRUE;
+        sscanf(Config, "%s %s %s %s %n",
+	    soc_con[cnt].connect_id,
+	    soc_con[cnt].domain_string,
+	    soc_con[cnt].tip_string,
+	    soc_con[cnt].tip_exe,
+	    &params_pos);
+	tip_main_string = Config + params_pos;
+    }
+    else				/* here if need to read udi_soc file */
+    {
+	fd = -1;
+	env_p = getenv("UDICONF");
+	if(env_p)
+	{   sprintf(config_file, "%s", env_p);	/* path includes file name */
+	    fd = open(config_file, O_RDONLY);
+	}
+	if(fd == -1)
+	{   fd = open("udi_soc", O_RDONLY);
+	    strcpy(config_file, "udi_soc");
+	}
+	if(fd == -1)
+	{   fd = open(sbuf, O_RDONLY);
+	    strcpy(config_file, sbuf);
+	}
+	if(fd == -1)
+    	{   sprintf(dfe_errmsg, "UDIConnect, can't open udi_soc file:\n%s ",
+	    	sys_errlist[errno]);
+	    return UDIErrorCantOpenConfigFile;
+	}
+	while(1)
+	{   pos = 0;
+	    while((rcnt = read(fd, &sbuf[pos], 1)) != -1)/* read a line */
+	    {   if (sbuf[pos] == '\n' || rcnt == 0 )
+		    break;
+		pos += 1;
+	    }
+	    sbuf[pos] = 0;			/* terminate string */
+            sscanf(sbuf, "%s %s %s %s %n",
+	        soc_con[cnt].connect_id,
+	        soc_con[cnt].domain_string,
+	        soc_con[cnt].tip_string,
+	        soc_con[cnt].tip_exe,
+		&params_pos);
+	    if( strcmp(Config, soc_con[cnt].connect_id)
+		|| rcnt == -1 || rcnt == 0)
+	        if(rcnt == -1 || rcnt == 0)
+    	        {   sprintf(dfe_errmsg,
+			"UDIConnect, can't find entry in udi_soc file");
+	            return UDIErrorNoSuchConfiguration;
+	        }
+		else
+		    continue;
+            soc_con[cnt].in_use = TRUE;		/* here if entry found */
+	    tip_main_string = sbuf + params_pos;
+	    break;
+	}
+	close(fd);
+    }
+/*-------------------------------------------------------------- '*' SOC_ID */
+    if( *soc_con[cnt].tip_string == '*'
+     && *soc_con[cnt+1].tip_string == 0)
+    {
+	rcnt = 0;
+	pos = getpid();
+	do
+	{ 
+	    sprintf(soc_con[cnt].tip_string,"/tmp/U%d", pos++);
+	    fd = open(soc_con[cnt].tip_string, O_CREAT);
+	    if(rcnt++ > 20)
+	    {   sprintf(dfe_errmsg,
+			"DFE-ipc ERROR, can't create random socket name\n");
+	        return UDIErrorCantConnect;
+	    }
+	} while(fd == -1);
+	close(fd);
+	unlink(soc_con[cnt].tip_string);
+    }
+/*----------------------------------------------------------- SELECT DOMAIN */
+    if(!strcmp(soc_con[cnt].domain_string, "AF_UNIX"))
+	domain = AF_UNIX;
+    else if(!strcmp(soc_con[cnt].domain_string, "AF_INET"))
+	domain = AF_INET;
+    else
+    {   errmsg_m;
+    	sprintf(dfe_errmsg, "DFE-ipc ERROR: socket address family not known");
+	return UDIErrorBadConfigFileEntry;
+    }
+
+/*---------------------------------------------------- MULTIPLEXED SOCKET ? */
+/* If the requested session requires communication with
+   a TIP which already has a socket connection established,
+   then we do not create a new socket but multiplex the
+   existing one. A TIP is said to use the same socket if
+   socket-name/host-name and the domain are the same.
+ */
+    for (rcnt=0; rcnt < MAX_SESSIONS; rcnt++)
+    {   if( soc_con[rcnt].in_use
+	&& !strcmp(soc_con[cnt].domain_string, soc_con[rcnt].domain_string)
+	&& !strcmp(soc_con[cnt].tip_string, soc_con[rcnt].tip_string) 
+	&& rcnt != cnt	)
+	{
+	    session[*Session].soc_con_p = &soc_con[rcnt];
+	    soc_con[cnt].in_use = FALSE;	/* don't need new connect */
+	    goto tip_connect; 
+	}
+    }
+/*------------------------------------------------------------------ SOCKET */
+    soc_con[cnt].dfe_sd = socket(domain, SOCK_STREAM, 0);
+    if (soc_con[cnt].dfe_sd == -1 )
+    {   errmsg_m;
+    	sprintf(dfe_errmsg, "DFE-ipc ERROR, socket() call failed %s ",
+	    sys_errlist[errno]);
+    	UDIKill(cnt);
+    }
+
+/*--------------------------------------------------------- AF_UNIX CONNECT */
+    if(domain == AF_UNIX)
+    {
+        memset( (char*)&soc_con[cnt].tip_sockaddr, 0,
+            sizeof(soc_con[cnt].tip_sockaddr));
+        soc_con[cnt].tip_sockaddr.sa_family = domain;
+        bcopy(soc_con[cnt].tip_string,
+		soc_con[cnt].tip_sockaddr.sa_data,
+		sizeof(soc_con[cnt].tip_sockaddr.sa_data) );
+    	if(connect(soc_con[cnt].dfe_sd, 
+		&soc_con[cnt].tip_sockaddr,
+		sizeof(soc_con[cnt].tip_sockaddr)) == -1)
+  	{	/* if connect() fails assume TIP not yet started */
+/*------------------------------------------------------------ AF_UNIX EXEC */
+	    int	pid;
+	    union	wait statusp;
+	    char*	arg0 = strrchr(soc_con[cnt].tip_exe,'/');
+
+	    if(!arg0) arg0 = soc_con[cnt].tip_exe;
+	    else	arg0++;
+    
+	    if((pid = fork()) == 0)
+            {   execlp(
+		    soc_con[cnt].tip_exe,
+		    arg0,
+		    soc_con[cnt].domain_string,
+		    soc_con[cnt].tip_string,
+		    NULL);
+	        exit(1);
+            }
+            if(wait4(pid, &statusp, WNOHANG, NULL))
+	    {
+	        sprintf(dfe_errmsg, "DFE-ipc ERROR: can't exec the TIP\n");
+	        return UDIErrorCantStartTIP;
+	    }
+	    sleep(2);
+			/* not TIP is running, try conect() again */
+    	    if(connect(soc_con[cnt].dfe_sd, 
+		&soc_con[cnt].tip_sockaddr,
+		sizeof(soc_con[cnt].tip_sockaddr)) == -1)
+	    {   sprintf(dfe_errmsg, "DFE-ipc ERROR, connect() call failed: %s",
+	    		sys_errlist[errno]);
+	        return UDIErrorCantConnect;
+	    }
+	  }
+    }
+/*--------------------------------------------------------- AF_INET CONNECT */
+    if(domain == AF_INET)
+    {
+	fprintf(stderr,"DFE-ipc WARNING, need to have first started remote TIP\n");
+     	memset( (char*)&soc_con[cnt].tip_sockaddr_in, 0,
+	    sizeof(soc_con[cnt].tip_sockaddr_in));
+	soc_con[cnt].tip_sockaddr_in.sin_family = domain;
+	soc_con[cnt].tip_sockaddr_in.sin_addr.s_addr =
+	    inet_addr(soc_con[cnt].tip_string);
+	if( soc_con[cnt].tip_sockaddr_in.sin_addr.s_addr == -1)
+	{
+	    tip_info_p = gethostbyname(soc_con[cnt].tip_string);
+	    if( tip_info_p == NULL)
+	    {   errmsg_m;
+	       sprintf(dfe_errmsg,"DFE-ipc ERROR, %s not found in /etc/hosts",
+		   soc_con[cnt].tip_string);
+	    	return UDIErrorNoSuchConnection;
+	    }
+	    bcopy(tip_info_p->h_addr,
+		(char *)&soc_con[cnt].tip_sockaddr_in.sin_addr,
+	   	tip_info_p->h_length);
+	}
+	soc_con[cnt].tip_sockaddr_in.sin_port=htons(atoi(soc_con[cnt].tip_exe));
+    	if(connect(soc_con[cnt].dfe_sd,
+		&soc_con[cnt].tip_sockaddr_in,
+		sizeof(soc_con[cnt].tip_sockaddr_in)) == -1)
+	{   errmsg_m;
+    	    sprintf(dfe_errmsg, "DFE-ipc ERROR, connect() call failed %s ",
+	    	sys_errlist[errno]);
+	    return UDIErrorCantConnect;
+    	}
+    }
+/*------------------------------------------------------------- TIP CONNECT */
+    if(cnt ==0) udr_create(udrs, soc_con[cnt].dfe_sd, SOC_BUF_SIZE);
+tip_connect:
+    current = cnt;
+    session[*Session].in_use = TRUE;	/* session id is now in use*/
+
+    udr_errno = 0;
+    udrs->udr_op = UDR_ENCODE;		/* send all "in" parameters */
+    udr_UDIInt32(udrs, &service_id);
+    DFEIPCId = (company_c << 16) + (product_c << 12) + version_c;
+    udr_UDIUInt32(udrs, &DFEIPCId);
+    udr_string(udrs, tip_main_string);
+    udr_sendnow(udrs);
+
+    udrs->udr_op = UDR_DECODE;		/* recv all "out" parameters */
+    udr_UDIUInt32(udrs, &TIPIPCId);
+    if ((TIPIPCId & 0xfff) < version_c) {
+	    fprintf(stderr, "DFE-ipc: Obsolete TIP Specified\n");
+	    return(UDIErrorExecutableNotTIP);
+    }
+    udr_UDIInt32(udrs, &soc_con[cnt].tip_pid);
+    udr_UDISessionId(udrs, &session[*Session].tip_id);
+    udr_UDIError(udrs, &dfe_errno);
+    if(dfe_errno > 0) UDIKill(Session, 0);
+    return dfe_errno;
+}
+
+/************************************************************** UDI_Disconnect
+* UDIDisconnect() should be called before exiting the
+* DFE to ensure proper shut down of the TIP.
+*/
+UDIError UDIDisconnect(Session,  Terminate)
+UDISessionId	Session;
+UDIBool		Terminate;
+{
+    int	cnt;
+    UDIInt32	service_id = UDIDisconnect_c;
+    if(Session < 0 || Session > MAX_SESSIONS)
+    {	errmsg_m;
+	sprintf(dfe_errmsg," SessionId not valid (%d)", Session);
+	return UDIErrorNoSuchConfiguration;
+    }
+    udr_errno = 0;
+    udrs->udr_op = UDR_ENCODE;		/* send all "in" parameters */
+    udr_UDIInt32(udrs, &service_id);
+    udr_UDISessionId(udrs, &session[Session].tip_id);
+    udr_UDIBool(udrs, &Terminate);
+    udr_sendnow(udrs);
+
+    session[Session].in_use = FALSE;	/* session id is now free */
+    for (cnt=0; cnt < MAX_SESSIONS; cnt++)
+        if(session[cnt].in_use
+	&& session[cnt].soc_con_p == session[Session].soc_con_p
+		) break;
+    if(cnt >= MAX_SESSIONS)	/* test if socket not multiplexed */
+        if(shutdown(session[Session].soc_con_p->dfe_sd, 2))
+        {   errmsg_m;
+     	    sprintf(dfe_errmsg, "DFE-ipc WARNING: socket shutdown failed");
+	    return UDIErrorIPCInternal;
+        }
+
+    udrs->udr_op = UDR_DECODE;		/* receive all "out" parameters */
+    udr_UDIError(udrs, &dfe_errno);	/* get any TIP error */
+    return dfe_errno;
+}
+
+/******************************************************************** UDI_KILL
+* UDIKill() is used to send a signal to the TIP.
+* This is a private IPC call.
+*/
+UDIError UDIKill(Session,  Signal)
+UDISessionId	Session;
+UDIInt32	Signal;
+{
+    int	cnt;
+    UDIInt32	service_id = UDIKill_c;
+    if(Session < 0 || Session > MAX_SESSIONS)
+    {	errmsg_m;
+	sprintf(dfe_errmsg," SessionId not valid (%d)", Session);
+	return UDIErrorNoSuchConfiguration;
+    }
+    udr_errno = 0;
+    udrs->udr_op = UDR_ENCODE;		/* send all "in" parameters */
+    udr_UDIInt32(udrs, &service_id);
+    udr_UDISessionId(udrs, &session[Session].tip_id);
+    udr_UDIInt32(udrs, &Signal);
+    udr_sendnow(udrs);
+
+    session[Session].in_use = FALSE;	/* session id is now free */
+    for (cnt=0; cnt < MAX_SESSIONS; cnt++)
+        if(session[cnt].in_use
+	&& session[cnt].soc_con_p == session[Session].soc_con_p
+		) break;
+    if(cnt < MAX_SESSIONS)	/* test if socket not multiplexed */
+        if(shutdown(session[Session].soc_con_p->dfe_sd, 2))
+        {   errmsg_m;
+     	    sprintf(dfe_errmsg, "DFE-ipc WARNING: socket shutdown failed");
+	    return UDIErrorIPCInternal;
+        }
+
+    udrs->udr_op = UDR_DECODE;		/* receive all "out" parameters */
+    udr_UDIError(udrs, &dfe_errno);	/* get any TIP error */
+    return dfe_errno;
+}
+
+/************************************************** UDI_Set_Current_Connection
+* If you are connected to multiple TIPs, you can change
+* TIPs using UDISetCurrentConnection().
+*/
+UDIError UDISetCurrentConnection(Session)
+UDISessionId	Session;
+{
+    UDIInt32	service_id = UDISetCurrentConnection_c;
+
+    if(Session < 0 || Session > MAX_SESSIONS)
+	return UDIErrorNoSuchConfiguration;
+    if(!session[Session].in_use) 		/* test if not in use yet */
+	return UDIErrorNoSuchConnection;
+
+    current = Session;
+    /* change socket or multiplex the same socket  */
+    udrs->sd = session[Session].soc_con_p->dfe_sd;
+
+    udr_errno = 0;
+    udrs->udr_op = UDR_ENCODE;		/* send all "in" parameters */
+    udr_UDIInt32(udrs, &service_id);
+    udr_UDISessionId(udrs, &session[Session].tip_id);
+    udr_sendnow(udrs);
+    if(udr_errno) return udr_errno;
+
+    udrs->udr_op = UDR_DECODE;		/* receive all "out" parameters */
+    udr_UDIError(udrs, &dfe_errno);	/* get any TIP error */
+    return dfe_errno;
+}
+
+/************************************************************ UDI_Capabilities
+* The DFE uses UDICapabilities() to both inform the TIP
+* of what services the DFE offers and to inquire of the
+* TIP what services the TIP offers.
+*/
+UDIError UDICapabilities(TIPId, TargetId, DFEId, DFE, TIP, DFEIPCId,
+		TIPIPCId, TIPString)
+UDIUInt32	*TIPId;		/* out */
+UDIUInt32	*TargetId;	/* out */
+UDIUInt32	DFEId;		/* in */
+UDIUInt32	DFE;		/* in */
+UDIUInt32	*TIP;		/* out */
+UDIUInt32	*DFEIPCId;	/* out */
+UDIUInt32	*TIPIPCId;	/* out */
+char		*TIPString;	/* out */
+{
+    UDIInt32	service_id = UDICapabilities_c;
+    int		size;
+
+    udr_errno = 0;
+    udrs->udr_op = UDR_ENCODE;		/* send all "in" parameters */
+    udr_UDIInt32(udrs, &service_id);
+    udr_UDIInt32(udrs, &DFEId);
+    udr_UDIInt32(udrs, &DFE);
+    udr_sendnow(udrs);
+    if(udr_errno) return udr_errno;
+
+    udrs->udr_op = UDR_DECODE;		/* receive all "out" paramters */
+    udr_UDIInt32(udrs, TIPId);
+    udr_UDIInt32(udrs, TargetId);
+    udr_UDIInt32(udrs, TIP);
+    udr_UDIInt32(udrs, DFEIPCId);
+    *DFEIPCId = (company_c << 16) + (product_c << 12) + version_c;
+    udr_UDIInt32(udrs, TIPIPCId);
+    udr_string(udrs, sbuf);
+    udr_UDIError(udrs, &dfe_errno);	/* get any TIP error */
+    size = strlen(sbuf);
+    if(size +1 > 80) return -1;		/* test if sufficient space */
+    strcpy(TIPString, sbuf);
+    return dfe_errno;
+}
+
+/********************************************************** UDI_Enumerate_TIPs
+* Used by the DFE to enquire about available TIP
+* connections.
+*/
+UDIError UDIEnumerateTIPs(UDIETCallback)
+  int (*UDIETCallback)();		/* In -- function to callback */
+{
+    FILE	*fp;
+
+    fp = fopen(config_file, "r");
+    if(fp == NULL)
+	return UDIErrorCantOpenConfigFile;
+    while(fgets( sbuf, SBUF_SIZE, fp))
+	if(UDIETCallback( sbuf) == UDITerminateEnumeration)
+	    break;
+    fclose( fp);
+    return UDINoError;			/* return success */
+}
+
+/*********************************************************** UDI_GET_ERROR_MSG
+* Some errors are target specific. They are indicated
+* by a negative error return value. The DFE uses
+* UDIGetErrorMsg() to get the descriptive text for
+* the error message which can then  be  displayed  to
+* the user.
+*/
+UDIError UDIGetErrorMsg(error_code, msg_len, msg, CountDone)
+UDIError	error_code;		/* In */
+UDISizeT	msg_len;		/* In  -- allowed message space */
+char*		msg;			/* Out -- length of message*/
+UDISizeT	*CountDone;		/* Out -- number of characters */
+{
+    UDIInt32	service_id = UDIGetErrorMsg_c;
+    int		size;
+
+    udr_errno = 0;
+    udrs->udr_op = UDR_ENCODE;		/* send all "in" parameters */
+    udr_UDIInt32(udrs, &service_id);
+    udr_UDIError(udrs, &error_code);
+    udr_UDISizeT(udrs, &msg_len);
+    udr_sendnow(udrs);
+    if(udr_errno) return udr_errno;
+
+    udrs->udr_op = UDR_DECODE;		/* receive all "out" parameters */
+    udr_string(udrs, sbuf);
+    udr_UDISizeT(udrs, CountDone);
+    udr_UDIError(udrs, &dfe_errno);	/* get any TIP error */
+    size = strlen(sbuf);
+    if(size +1 > msg_len) return -1;	/* test if sufficient space */
+    strcpy(msg, sbuf);
+    return dfe_errno;
+}
+
+/******************************************************* UDI_GET_TARGET_CONFIG
+* UDIGetTargetConfig() gets information about the target.
+*/
+UDIError UDIGetTargetConfig(KnownMemory, NumberOfRanges, ChipVersions,
+		NumberOfChips)
+UDIMemoryRange	KnownMemory[];		/* Out */
+UDIInt		*NumberOfRanges;	/* In and Out */
+UDIUInt32	ChipVersions[];		/* Out */
+UDIInt		*NumberOfChips;		/* In and Out */
+{
+    UDIInt32	service_id = UDIGetTargetConfig_c;
+    int		cnt;
+    int		MaxOfRanges = *NumberOfRanges;
+
+    udr_errno = 0;
+    udrs->udr_op = UDR_ENCODE;		/* send all "in" parameters */
+    udr_UDIInt32(udrs, &service_id);
+    udr_UDIInt(udrs, NumberOfRanges);
+    udr_UDIInt(udrs, NumberOfChips);
+    udr_sendnow(udrs);
+    if(udr_errno) return udr_errno;
+
+    udrs->udr_op = UDR_DECODE;		/* receive all "out" paramters */
+    for(cnt=1; cnt <= MaxOfRanges; cnt++)
+    	udr_UDIMemoryRange(udrs, &KnownMemory[cnt-1]);
+    udr_UDIInt(udrs, NumberOfRanges);
+    udr_UDIInt(udrs, NumberOfChips);
+    for(cnt=1; cnt <= *NumberOfChips; cnt++)
+    	udr_UDIUInt32(udrs, &ChipVersions[cnt -1]);
+    udr_UDIError(udrs, &dfe_errno);	/* get any TIP error */
+    return dfe_errno;
+}
+
+/********************************************************** UDI_CREATE_PRCOESS
+* UDICreateProcess() tells the  target  OS  that  a
+* process is to be created and gets a PID back unless
+* there is some error.
+*/
+UDIError UDICreateProcess(pid)
+UDIPId	*pid;	/* out */
+{
+    UDIInt32	service_id = UDICreateProcess_c;
+
+    udr_errno = 0;
+    udrs->udr_op = UDR_ENCODE;		/* send all "in" parameters */
+    udr_UDIInt32(udrs, &service_id);
+    udr_sendnow(udrs);
+    if(udr_errno) return udr_errno;
+
+    udrs->udr_op = UDR_DECODE;		/* receive all "out" parameters */
+    udr_UDIPId(udrs, pid);
+    udr_UDIError(udrs, &dfe_errno);	/* get any TIP error */
+    return dfe_errno;
+}
+
+/***************************************************** UDI_Set_Current_Process
+* UDISetCurrentProcess  uses   a   pid   supplied   by
+* UDICreateProcess  and  sets it as the default for all
+* udi calls until a new one is set.  A user of  a
+*/
+UDIError UDISetCurrentProcess (pid)
+UDIPId	pid;			/* In */
+{
+    UDIInt32	service_id = UDISetCurrentProcess_c;
+
+    udr_errno = 0;
+    udrs->udr_op = UDR_ENCODE;		/* send all "in" parameters */
+    udr_UDIInt32(udrs, &service_id);
+    udr_UDIPId(udrs, &pid);
+    udr_sendnow(udrs);
+    if(udr_errno) return udr_errno;
+
+    udrs->udr_op = UDR_DECODE;		/* receive all "out" parameters */
+    udr_UDIError(udrs, &dfe_errno);	/* get any TIP error */
+    return dfe_errno;
+}
+
+/****************************************************** UDI_INITIALISE_PROCESS
+* UDIInitializeProcess() prepare process for
+* execution. (Reset processor if process os processor).
+*/
+UDIError UDIInitializeProcess( ProcessMemory, NumberOfRanges, EntryPoint,
+		StackSizes, NumberOfStacks, ArgString)
+UDIMemoryRange	ProcessMemory[];	/* In */
+UDIInt		NumberOfRanges;		/* In */
+UDIResource	EntryPoint;		/* In */
+CPUSizeT	*StackSizes;		/* In */
+UDIInt		NumberOfStacks;		/* In */
+char		*ArgString;		/* In */
+{
+    UDIInt32	service_id = UDIInitializeProcess_c;
+    int		cnt;
+
+    udr_errno = 0;
+    udrs->udr_op = UDR_ENCODE;		/* send all "in" parameters */
+    udr_UDIInt32(udrs, &service_id);
+    udr_UDIInt(udrs, &NumberOfRanges);
+    for(cnt = 0; cnt < NumberOfRanges; cnt++)
+	udr_UDIMemoryRange(udrs, &ProcessMemory[cnt] );
+    udr_UDIResource(udrs, &EntryPoint);
+    udr_UDIInt(udrs, &NumberOfStacks);
+    for(cnt = 0; cnt < NumberOfStacks; cnt++)
+	udr_CPUSizeT(udrs, &StackSizes[cnt]);
+    udr_string(udrs, ArgString);
+    udr_sendnow(udrs);
+    if(udr_errno) return udr_errno;
+
+    udrs->udr_op = UDR_DECODE;		/* receive all "out" parameters */
+    udr_UDIError(udrs, &dfe_errno);	/* get any TIP error */
+    return dfe_errno;
+}
+
+/********************************************************* UDI_DESTROY_PROCESS
+* UDIDestroyProcess() frees a process resource
+* previously created by UDICreateProcess().
+*/
+UDIError UDIDestroyProcess(pid)
+UDIPId   pid;	/* in */
+{
+    UDIInt32	service_id = UDIDestroyProcess_c;
+
+    udr_errno = 0;
+    udrs->udr_op = UDR_ENCODE;		/* send all "in" parameters */
+    udr_UDIInt32(udrs, &service_id);
+    udr_UDIPId(udrs, &pid);
+    udr_sendnow(udrs);
+    if(udr_errno) return udr_errno;
+
+    udrs->udr_op = UDR_DECODE;		/* receive all "out" parameters */
+    udr_UDIError(udrs, &dfe_errno);	/* get any TIP error */
+    return dfe_errno;
+}
+
+/****************************************************************** UDI_READ
+* UDIRead() reads a block of objects from  a  target
+* address space  to host space.
+*/
+
+UDIError UDIRead (from, to, count, size, count_done, host_endian)
+UDIResource	from;		/* in - source address on target */
+UDIHostMemPtr	to;		/* out - destination address on host */
+UDICount	count;		/* in -- count of objects to be transferred */
+UDISizeT	size;		/* in -- size of each object */
+UDICount	*count_done;	/* out - count actually transferred */
+UDIBool		host_endian;	/* in -- flag for endian information */
+{
+    UDIInt32	service_id = UDIRead_c;
+    int		byte_count;
+
+    udr_errno = 0;
+    udrs->udr_op = UDR_ENCODE;		/* send all "in" parameters */
+    udr_UDIInt32(udrs, &service_id);
+    udr_UDIResource(udrs, &from);
+    udr_UDICount(udrs, &count);
+    udr_UDISizeT(udrs, &size);
+    udr_UDIBool(udrs, &host_endian);
+    udr_sendnow(udrs);
+    if(udr_errno) return udr_errno;
+
+    udrs->udr_op = UDR_DECODE;		/* receive all "out" paramters */
+    udr_UDICount(udrs, count_done);
+    byte_count = (*count_done) * size;
+    if(*count_done > 0 && *count_done <= count)
+        udr_bytes(udrs, to, byte_count);
+    if(udr_errno) return udr_errno;
+    udr_UDIError(udrs, &dfe_errno);	/* get any TIP error */
+    return dfe_errno;
+}
+
+/****************************************************************** UDI_WRITE
+* UDIWrite() writes a block  of  objects  from  host
+* space  to  a  target  address+space.
+*/
+UDIError UDIWrite( from, to, count, size, count_done, host_endian )
+UDIHostMemPtr	from;		/* in -- source address on host */
+UDIResource	to;		/* in -- destination address on target */
+UDICount	count;		/* in -- count of objects to be transferred */
+UDISizeT	size;		/* in -- size of each object */
+UDICount	*count_done;	/* out - count actually transferred */
+UDIBool		host_endian;	/* in -- flag for endian information */
+{
+    UDIInt32	service_id = UDIWrite_c;
+    int		byte_count = count * size;
+
+    udr_errno = 0;
+    udrs->udr_op = UDR_ENCODE;		/* send all "in" parameters */
+    udr_UDIInt32(udrs, &service_id);
+    udr_UDIResource(udrs, &to);
+    udr_UDICount(udrs, &count);
+    udr_UDISizeT(udrs, &size);
+    udr_UDIBool(udrs, &host_endian);
+    udr_bytes(udrs, from, byte_count);
+    udr_sendnow(udrs);
+    if(udr_errno) return udr_errno;
+
+    udrs->udr_op = UDR_DECODE;		/* receive all "out" paramters */
+    udr_UDICount(udrs, count_done);
+    udr_UDIError(udrs, &dfe_errno);	/* get any TIP error */
+    return dfe_errno;
+}
+
+/******************************************************************** UDI_COPY
+* UDICopy() copies a block of objects from one  target
+* get  address/space to another target address/space.
+*/
+UDIError UDICopy(from, to, count, size, count_done, direction )
+UDIResource	from;		/* in -- destination address on target */
+UDIResource	to;		/* in -- source address on target */
+UDICount	count;		/* in -- count of objects to be transferred */
+UDISizeT	size;		/* in -- size of each object */
+UDICount	*count_done;	/* out - count actually transferred */
+UDIBool		direction;	/* in -- high-to-low or reverse */
+{
+    UDIInt32	service_id = UDICopy_c;
+
+    udr_errno = 0;
+    udrs->udr_op = UDR_ENCODE;		/* send all "in" parameters */
+    udr_UDIInt32(udrs, &service_id);
+    udr_UDIResource(udrs, &from);
+    udr_UDIResource(udrs, &to);
+    udr_UDICount(udrs, &count);
+    udr_UDISizeT(udrs, &size);
+    udr_UDIBool(udrs, &direction);
+    udr_sendnow(udrs);
+    if(udr_errno) return udr_errno;
+
+    udrs->udr_op = UDR_DECODE;		/* receive all "out" parameters */
+    udr_UDICount(udrs, count_done);
+    udr_UDIError(udrs, &dfe_errno);	/* get any TIP error */
+    return dfe_errno;
+}
+
+/***************************************************************** UDI_EXECUTE
+* UDIExecute() continues execution  of  the  default
+* process from the current PC.
+*/
+UDIError UDIExecute()
+{
+    UDIInt32	service_id = UDIExecute_c;
+
+    udr_errno = 0;
+    udrs->udr_op = UDR_ENCODE;		/* send all "in" parameters */
+    udr_UDIInt32(udrs, &service_id);
+    udr_sendnow(udrs);
+    if(udr_errno) return udr_errno;
+
+    udrs->udr_op = UDR_DECODE;		/* receive all "out" parameters */
+    udr_UDIError(udrs, &dfe_errno);	/* get any TIP error */
+    return dfe_errno;
+}
+
+/******************************************************************** UDI_STEP
+* UDIStep()  specifies  a  number  of  "instruction"
+* steps  to  make.
+*/
+UDIError UDIStep(steps, steptype, range)
+UDIUInt32	steps;		/* in -- number of steps */
+UDIStepType	steptype;       /* in -- type of stepping to be done */
+UDIRange	range;          /* in -- range if StepInRange is TRUE */
+{
+    UDIInt32	service_id = UDIStep_c;
+
+    udr_errno = 0;
+    udrs->udr_op = UDR_ENCODE;		/* send all "in" parameters */
+    udr_UDIInt32(udrs, &service_id);
+    udr_UDIInt32(udrs, &steps);
+    udr_UDIStepType(udrs, &steptype);
+    udr_UDIRange(udrs, &range);
+    udr_sendnow(udrs);
+    if(udr_errno) return udr_errno;
+
+    udrs->udr_op = UDR_DECODE;		/* receive all "out" parameters */
+    udr_UDIError(udrs, &dfe_errno);	/* get any TIP error */
+    return dfe_errno;
+}
+
+/******************************************************************** UDI_STOP
+* UDIStop() stops the default process
+*/
+UDIVoid UDIStop()
+{
+    if(!strcmp(session[current].soc_con_p->domain_string, "AF_UNIX"))
+        kill(session[current].soc_con_p->tip_pid, SIGUSR1);
+    else
+	udr_signal(udrs);
+    return;
+}
+
+/******************************************************************** UDI_WAIT
+* UDIWait() returns the state of the target  procesor.
+*/
+UDIError UDIWait(maxtime, pid, stop_reason)
+UDIInt32   maxtime;        /* in -- maximum time to wait for completion */
+UDIPId     *pid;           /* out -- pid of process which stopped if any */
+UDIUInt32  *stop_reason;   /* out -- PC where process stopped */
+{
+    UDIInt32	service_id = UDIWait_c;
+
+    udr_errno = 0;
+    udrs->udr_op = UDR_ENCODE;		/* send all "in" parameters */
+    udr_UDIInt32(udrs, &service_id);
+    udr_UDIInt32(udrs, &maxtime);
+    udr_sendnow(udrs);
+    if(udr_errno) return udr_errno;
+
+    udrs->udr_op = UDR_DECODE;		/* receive all "out" parameters */
+    udr_UDIPId(udrs, pid);
+    udr_UDIUInt32(udrs, stop_reason);
+    udr_UDIError(udrs, &dfe_errno);	/* get any TIP error */
+    return dfe_errno;
+}
+
+/********************************************************** UDI_SET_BREAKPOINT
+* UDISetBreakpoint() sets a breakpoint  at  an  adress
+* and  uses  the  passcount  to state how many
+* times that instruction should  be  hit  before  the
+* break  occurs.
+*/
+UDIError UDISetBreakpoint (addr, passcount, type, break_id)
+UDIResource	addr;		/* in -- where breakpoint gets set */
+UDIInt32	passcount;	/* in -- passcount for breakpoint  */
+UDIBreakType	type;		/* in -- breakpoint type */
+UDIBreakId	*break_id;	/* out - assigned break id */
+{
+    UDIInt32	service_id = UDISetBreakpoint_c;
+
+    udr_errno = 0;
+    udrs->udr_op = UDR_ENCODE;		/* send all "in" parameters */
+    udr_UDIInt32(udrs, &service_id);
+    udr_UDIResource(udrs, &addr);
+    udr_UDIInt32(udrs, &passcount);
+    udr_UDIBreakType(udrs, &type);
+    udr_sendnow(udrs);
+    if(udr_errno) return udr_errno;
+
+    udrs->udr_op = UDR_DECODE;		/* receive all "out" parameters */
+    udr_UDIBreakId(udrs, break_id);
+    udr_UDIError(udrs, &dfe_errno);	/* get any TIP error */
+    return dfe_errno;
+}
+
+/******************************************************** UDI_QUERY_BREAKPOINT
+*/
+UDIError UDIQueryBreakpoint (break_id, addr, passcount, type, current_count)
+UDIBreakId	break_id;	/* in -- assigned break id */
+UDIResource	*addr;		/* out - where breakpoint was set */
+UDIInt32	*passcount;	/* out - trigger passcount for breakpoint  */
+UDIBreakType	*type;		/* out - breakpoint type */
+UDIInt32	*current_count;	/* out - current count for breakpoint  */
+{
+    UDIInt32	service_id = UDIQueryBreakpoint_c;
+
+    udr_errno = 0;
+    udrs->udr_op = UDR_ENCODE;		/* send all "in" parameters */
+    udr_UDIInt32(udrs, &service_id);
+    udr_UDIBreakId(udrs, &break_id);
+    udr_sendnow(udrs);
+    if(udr_errno) return udr_errno;
+
+    udrs->udr_op = UDR_DECODE;		/* receive all "out" parameters */
+    udr_UDIResource(udrs, addr);
+    udr_UDIInt32(udrs, passcount);
+    udr_UDIBreakType(udrs, type);
+    udr_UDIInt32(udrs, current_count);
+    udr_UDIError(udrs, &dfe_errno);	/* get any TIP error */
+    return dfe_errno;
+}
+
+/******************************************************** UDI_CLEAR_BREAKPOINT
+* UDIClearBreakpoint() is used to  clear  a  breakpoint.
+*/
+UDIError UDIClearBreakpoint (break_id)
+UDIBreakId	break_id;	/* in -- assigned break id */
+{
+    UDIInt32	service_id = UDIClearBreakpoint_c;
+
+    udr_errno = 0;
+    udrs->udr_op = UDR_ENCODE;		/* send all "in" parameters */
+    udr_UDIInt32(udrs, &service_id);
+    udr_UDIBreakId(udrs, &break_id);
+    udr_sendnow(udrs);
+    if(udr_errno) return udr_errno;
+
+    udrs->udr_op = UDR_DECODE;		/* receive all "out" parameters */
+    udr_UDIError(udrs, &dfe_errno);	/* get any TIP error */
+    return dfe_errno;
+}
+
+/************************************************************** UDI_GET_STDOUT
+* UDIGetStdout()  is  called   when   a   call   to
+* UDIWait() indicates there is STD output data ready. 
+*/
+UDIError UDIGetStdout(buf, bufsize, count_done)
+UDIHostMemPtr	buf;		/* out -- buffer to be filled */
+UDISizeT	bufsize;	/* in  -- buffer size in bytes */
+UDISizeT	*count_done;	/* out -- number of bytes written to buf */
+{
+    UDIInt32	service_id = UDIGetStdout_c;
+
+    udr_errno = 0;
+    udrs->udr_op = UDR_ENCODE;		/* send all "in" parameters */
+    udr_UDIInt32(udrs, &service_id);
+    udr_UDISizeT(udrs, &bufsize);
+    udr_sendnow(udrs);
+    if(udr_errno) return udr_errno;
+
+    udrs->udr_op = UDR_DECODE;		/* receive all "out" parameters */
+    udr_UDISizeT(udrs, count_done);
+    udr_bytes(udrs, buf, *count_done);
+    udr_UDIError(udrs, &dfe_errno);	/* get any TIP error */
+    return dfe_errno;
+}
+
+/************************************************************** UDI_GET_STDERR
+* UDIGetStderr()  is  called   when   a   call   to
+* UDIWait() indicates there is STDERR output data ready
+*/
+UDIError UDIGetStderr(buf, bufsize, count_done)
+UDIHostMemPtr	buf;		/* out -- buffer to be filled */
+UDISizeT	bufsize;	/* in  -- buffer size in bytes */
+UDISizeT	*count_done;	/* out -- number of bytes written to buf */
+{
+    UDIInt32	service_id = UDIGetStderr_c;
+
+    udr_errno = 0;
+    udrs->udr_op = UDR_ENCODE;		/* send all "in" parameters */
+    udr_UDIInt32(udrs, &service_id);
+    udr_UDISizeT(udrs, &bufsize);
+    udr_sendnow(udrs);
+    if(udr_errno) return udr_errno;
+
+    udrs->udr_op = UDR_DECODE;		/* receive all "out" parameters */
+    udr_UDISizeT(udrs, count_done);
+    udr_bytes(udrs, buf, *count_done);
+    udr_UDIError(udrs, &dfe_errno);	/* get any TIP error */
+    return dfe_errno;
+}
+
+/*************************************************************** UDI_PUT_STDIN
+* UDIPutStdin() is called whenever the DFE wants to
+* deliver an input character to the TIP.
+*/
+UDIError UDIPutStdin (buf, count, count_done)
+UDIHostMemPtr	buf;		/* in -- buffer to be filled */
+UDISizeT	count;		/* in -- buffer size in bytes */
+UDISizeT	*count_done;	/* out - number of bytes written to buf */
+{
+    UDIInt32	service_id = UDIPutStdin_c;
+
+    udr_errno = 0;
+    udrs->udr_op = UDR_ENCODE;		/* send all "in" parameters */
+    udr_UDIInt32(udrs, &service_id);
+    udr_UDISizeT(udrs, &count);
+    udr_bytes(udrs, buf, count);
+    udr_sendnow(udrs);
+    if(udr_errno) return udr_errno;
+
+    udrs->udr_op = UDR_DECODE;		/* receive all "out" parameters */
+    udr_UDISizeT(udrs, count_done);
+    udr_UDIError(udrs, &dfe_errno);	/* get any TIP error */
+    return dfe_errno;
+}
+
+/************************************************************** UDI_STDIN_MODE
+* UDIStdinMode() is used to change the mode that chazcters
+* are fetched from the user.
+*/
+UDIError	UDIStdinMode(mode)
+UDIMode		*mode;		/* out - */
+{
+    UDIInt32	service_id = UDIStdinMode_c;
+
+    udr_errno = 0;
+    udrs->udr_op = UDR_ENCODE;		/* send all "in" parameters */
+    udr_UDIInt32(udrs, &service_id);
+    udr_sendnow(udrs);
+    if(udr_errno) return udr_errno;
+
+    udrs->udr_op = UDR_DECODE;		/* receive all "out" parameters */
+    udr_UDIMode(udrs, mode);
+    udr_UDIError(udrs, &dfe_errno);	/* get any TIP error */
+    return dfe_errno;
+}
+
+/*************************************************************** UDI_PUT_TRANS
+* UDIPutTrans() is used to feed input to  the  passthru  mode.
+*/
+UDIError	UDIPutTrans (buf, count, count_done)
+UDIHostMemPtr	buf;		/* in -- buffer address containing input data */
+UDISizeT	count;		/* in -- number of bytes in buf */
+UDISizeT	*count_done;	/* out-- number of bytes transfered */
+{
+    UDIInt32	service_id = UDIPutTrans_c;
+
+    udr_errno = 0;
+    udrs->udr_op = UDR_ENCODE;		/* send all "in" parameters */
+    udr_UDIInt32(udrs, &service_id);
+    udr_UDISizeT(udrs, &count);
+    udr_bytes(udrs, buf, count);
+    udr_sendnow(udrs);
+    if(udr_errno) return udr_errno;
+
+    udrs->udr_op = UDR_DECODE;		/* receive all "out" parameters */
+    udr_UDISizeT(udrs, count_done);
+    udr_UDIError(udrs, &dfe_errno);	/* get any TIP error */
+    return dfe_errno;
+}
+
+/*************************************************************** UDI_GET_TRANS
+* UDIGetTrans() is used to get output lines from the
+* passthru mode.
+*/
+UDIError	UDIGetTrans (buf, bufsize, count_done)
+UDIHostMemPtr	buf;		/* out -- buffer to be filled */
+UDISizeT	bufsize;	/* in  -- size of buf */
+UDISizeT	*count_done;	/* out -- number of bytes in buf */
+{
+    UDIInt32	service_id = UDIGetTrans_c;
+
+    udr_errno = 0;
+    udrs->udr_op = UDR_ENCODE;		/* send all "in" parameters */
+    udr_UDIInt32(udrs, &service_id);
+    udr_UDISizeT(udrs, &bufsize);
+    udr_sendnow(udrs);
+    if(udr_errno) return udr_errno;
+
+    udrs->udr_op = UDR_DECODE;		/* receive all "out" parameters */
+    udr_UDISizeT(udrs, count_done);
+    udr_bytes(udrs, buf, *count_done);
+    udr_UDIError(udrs, &dfe_errno);	/* get any TIP error */
+    return dfe_errno;
+}
+
+/************************************************************** UDI_Trans_Mode
+* UDITransMode() is used to change the mode that the
+* transparent routines operate in.
+*/
+UDIError UDITransMode(mode)
+UDIMode		*mode;		/* out  -- selected mode */
+{
+    UDIInt32	service_id = UDITransMode_c;
+
+    udr_errno = 0;
+    udrs->udr_op = UDR_ENCODE;		/* send all "in" parameters */
+    udr_UDIInt32(udrs, &service_id);
+    udr_UDIMode(udrs, mode);
+    udr_sendnow(udrs);
+    if(udr_errno) return udr_errno;
+
+    udrs->udr_op = UDR_DECODE;		/* receive all "out" parameters */
+    udr_UDIError(udrs, &dfe_errno);
+    return dfe_errno;
+}
+
+/******************************************************************** UDI_TEST
+*/
+UDIError UDITest( cnt, str_p, array)
+UDISizeT	cnt;
+UDIHostMemPtr	str_p;
+UDIInt32	array[];
+{
+    UDIInt32	service_id = UDITest_c;
+    UDIInt16	scnt = cnt;
+    UDISizeT	r_cnt;
+    char	buf[256];
+
+    udr_errno = 0;
+    udrs->udr_op = UDR_ENCODE;		/* send all "in" parameters */
+    udr_UDIInt32(udrs, &service_id);
+
+    printf("send	cnt=%d scnt=%d\n", cnt, scnt);
+    udr_UDISizeT(udrs, &cnt);
+    udr_UDIInt16(udrs, &scnt);
+    printf("	array[0]=0x%x array[1]=0x%x array[2]=0x%x array[3]=0x%x\n",
+    	array[0], array[1], array[2], array[3]);
+    udr_bytes(udrs, (char*)array, 4*sizeof(UDIInt32));
+    printf("	string=%s\n", str_p);
+    udr_string(udrs, str_p);
+    udr_sendnow(udrs);
+    if(udr_errno)
+    {	fprintf(stderr, " DFE-ipc Send ERROR\n");
+	return udr_errno;
+    }
+
+    udrs->udr_op = UDR_DECODE;		/* receive all "out" parameters */
+    printf("recv	");
+    udr_UDISizeT(udrs, &r_cnt);
+    udr_UDIInt16(udrs, &scnt);
+    printf("	rcnt=%d scnt=%d\n", r_cnt, scnt);
+    udr_bytes(udrs, (char*)array, 4*sizeof(UDIInt32));
+
+    printf("	array[0]=0x%x array[1]=0x%x array[2]=0x%x array[3]=0x%x\n",
+    	array[0], array[1], array[2], array[3]);
+    udr_string(udrs, str_p);
+    printf("	string=%s\n", str_p);
+
+    udr_UDIError(udrs, &dfe_errno);
+    return dfe_errno;
+}
+
+
+
+UDIUInt32 UDIGetDFEIPCId()
+{
+    return ((company_c << 16) + (product_c << 12) + version_c);
+}
diff --git a/gdb/29k-share/udi/udiphcfg.h b/gdb/29k-share/udi/udiphcfg.h
new file mode 100644
index 0000000..508e041
--- /dev/null
+++ b/gdb/29k-share/udi/udiphcfg.h
@@ -0,0 +1,11 @@
+/* This file just picks the correct udiphxxx.h depending on the host */
+/* The two hosts that are now defined are SUN and MSDOS */
+
+#ifdef sun
+#include "udiphsun.h"
+#endif
+
+#ifdef MSDOS
+#include "udiphdos.h"
+#endif
+
diff --git a/gdb/29k-share/udi/udiphsun.h b/gdb/29k-share/udi/udiphsun.h
new file mode 100644
index 0000000..4c9e58f
--- /dev/null
+++ b/gdb/29k-share/udi/udiphsun.h
@@ -0,0 +1,86 @@
+/******************************************************************************
+ * Copyright 1991 Advanced Micro Devices, Inc.
+ *
+ * This software is the property of Advanced Micro Devices, Inc  (AMD)  which
+ * specifically  grants the user the right to modify, use and distribute this
+ * software provided this notice is not removed or altered.  All other rights
+ * are reserved by AMD.
+ *
+ * AMD MAKES NO WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, WITH REGARD TO THIS
+ * SOFTWARE.  IN NO EVENT SHALL AMD BE LIABLE FOR INCIDENTAL OR CONSEQUENTIAL
+ * DAMAGES IN CONNECTION WITH OR ARISING FROM THE FURNISHING, PERFORMANCE, OR
+ * USE OF THIS SOFTWARE.
+ *
+ * Comments about this software should be directed to udi@amd.com. If access
+ * to electronic mail isn't available, send mail to:
+ *
+ * Advanced Micro Devices, Inc.
+ * 29K Support Products
+ * Mail Stop 573
+ * 5900 E. Ben White Blvd.
+ * Austin, TX 78741
+ *****************************************************************************
+ *       $Id$
+ *	 $Id: @(#)udiphsun.h	2.3, AMD
+ */
+
+/* This file is to be used to reconfigure the UDI Procedural interface
+   for a given host. This file should be placed so that it will be
+   included from udiproc.h. Everything in here may need to be changed
+   when you change either the host CPU or its compiler. Nothing in
+   here should change to support different targets. There are multiple
+   versions of this file, one for each of the different host/compiler
+   combinations in use.
+*/
+
+#define UDIStruct  struct		/* _packed not needed on Sun */
+/* First, we need some types */
+/* Types with at least the specified number of bits */
+typedef double		UDIReal64;		/* 64-bit real value */
+typedef float		UDIReal32;		/* 32-bit real value */
+  
+typedef unsigned long	UDIUInt32;		/* unsigned integers */
+typedef unsigned short	UDIUInt16; 
+typedef unsigned char	UDIUInt8;
+  
+typedef long		UDIInt32;		/* 32-bit integer */ 
+typedef short		UDIInt16;		/* 16-bit integer */ 
+typedef char		UDIInt8;		/* unreliable signedness */
+
+/* To aid in supporting environments where the DFE and TIP use
+different compilers or hosts (like DOS 386 on one side, 286 on the
+other, or different Unix machines connected by sockets), we define
+two abstract types - UDIInt and UDISizeT.
+UDIInt should be defined to be int except for host/compiler combinations
+that are intended to talk to existing UDI components that have a different
+sized int. Similarly for UDISizeT.
+*/
+typedef int		UDIInt;
+typedef unsigned int	UDIUInt;
+
+typedef unsigned int	UDISizeT;
+
+/* Now two void types. The first is for function return types,
+the other for pointers to no particular type. Since these types
+are used solely for documentational clarity, if your host/compiler
+doesn't support either one, replace them with int and char *
+respectively.
+*/
+typedef void		UDIVoid;		/* void type */
+typedef void *		UDIVoidPtr;		/* void pointer type */
+typedef void *		UDIHostMemPtr;		/* Arbitrary memory pointer */
+
+/* Now we want a type optimized for boolean values. Normally this
+   would be int, but on some machines (Z80s, 8051s, etc) it might
+   be better to map it onto a char
+*/
+typedef	int		UDIBool;
+
+/* Now indicate whether your compiler support full ANSI style
+   prototypes. If so, use #if 1. If not use #if 0.
+*/
+#if 0
+#define UDIParams(x)	x
+#else
+#define UDIParams(x)	()
+#endif
diff --git a/gdb/29k-share/udi/udiproc.h b/gdb/29k-share/udi/udiproc.h
new file mode 100644
index 0000000..d78e5fb
--- /dev/null
+++ b/gdb/29k-share/udi/udiproc.h
@@ -0,0 +1,320 @@
+/******************************************************************************
+ * Copyright 1991 Advanced Micro Devices, Inc.
+ *
+ * This software is the property of Advanced Micro Devices, Inc  (AMD)  which
+ * specifically  grants the user the right to modify, use and distribute this
+ * software provided this notice is not removed or altered.  All other rights
+ * are reserved by AMD.
+ *
+ * AMD MAKES NO WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, WITH REGARD TO THIS
+ * SOFTWARE.  IN NO EVENT SHALL AMD BE LIABLE FOR INCIDENTAL OR CONSEQUENTIAL
+ * DAMAGES IN CONNECTION WITH OR ARISING FROM THE FURNISHING, PERFORMANCE, OR
+ * USE OF THIS SOFTWARE.
+ *
+ * Comments about this software should be directed to udi@amd.com. If access
+ * to electronic mail isn't available, send mail to:
+ *
+ * Advanced Micro Devices, Inc.
+ * 29K Support Products
+ * Mail Stop 573
+ * 5900 E. Ben White Blvd.
+ * Austin, TX 78741
+ *
+ * For more detailed information about the values, types, and functions
+ * defined and declared here, see the corresponding UDI spec available
+ * from AMD at the address above.
+ *****************************************************************************
+ *       $Id$
+ *	 $Id: @(#)udiproc.h	2.11, AMD
+ */
+
+/* local type decs. and macro defs. not in a .h  file ************* MACRO/TYPE
+*/
+#include "udiphcfg.h"	/* Get host specific configuration */
+#include "udiptcfg.h"	/* Get target specific configuration */
+
+/* Here are all of the CPU Families for which UDI is currently defined */
+#define Am29K		1	/* AMD's Am290xx and Am292xx parts */
+
+typedef UDIInt		UDIError;
+typedef UDIInt		UDISessionId;
+typedef	UDIInt		UDIPId;
+typedef	UDIInt		UDIStepType;
+typedef	UDIInt		UDIBreakType;
+typedef	UDIUInt		UDIBreakId;
+typedef UDIUInt		UDIMode;
+
+typedef UDIStruct
+{			
+    CPUSpace	Space;
+    CPUOffset	Offset;
+} UDIResource;
+
+typedef	UDIStruct
+{
+    CPUOffset	Low;
+    CPUOffset	High;
+} UDIRange;
+
+typedef UDIStruct
+{
+    CPUSpace	Space;
+    CPUOffset	Offset;
+    CPUSizeT	Size;
+    } UDIMemoryRange;
+
+/* Values for UDIStepType parameters */
+#define UDIStepNatural		0x0000
+#define UDIStepOverTraps	0x0001
+#define UDIStepOverCalls	0x0002
+#define UDIStepInRange		0x0004
+#define UDIStepNatural		0x0000
+
+/* Values for UDIBreakType parameters */
+#define UDIBreakFlagExecute	0x0001
+#define UDIBreakFlagRead	0x0002
+#define UDIBreakFlagWrite	0x0004
+#define UDIBreakFlagFetch	0x0008
+
+/* Special values for UDIWait MaxTime parameter */
+#define UDIWaitForever	(UDIInt32) -1	/* Infinite time delay */
+
+/* Special values for PId */
+#define UDIProcessProcessor	-1	/* Raw Hardware, if possible */
+
+/* Values for UDIWait StopReason */
+#define UDIGrossState		0xff
+#define UDITrapped		0	/* Fine state - which trap */
+#define UDINotExecuting		1
+#define UDIRunning		2
+#define UDIStopped		3
+#define UDIWarned		4
+#define UDIStepped		5
+#define UDIWaiting		6
+#define UDIHalted		7
+#define UDIStdoutReady		8	/* fine state - size */
+#define UDIStderrReady		9	/* fine state - size */
+#define UDIStdinNeeded		10	/* fine state - size */
+#define UDIStdinModeX  		11	/* fine state - mode */
+#define UDIBreak		12	/* Fine state - Breakpoint Id */
+#define UDIExited		13	/* Fine state - exit code */
+
+/* Enumerate the return values from the callback function
+   for UDIEnumerateTIPs.
+*/
+#define UDITerminateEnumeration	0
+#define UDIContinueEnumeration	1
+
+/* Enumerate values for Terminate parameter to UDIDisconnect */
+#define UDITerminateSession	1
+#define UDIContinueSession	0
+
+/* Error codes */
+#define UDINoError			0	/* No error occured */
+#define UDIErrorNoSuchConfiguration	1
+#define UDIErrorCantHappen		2
+#define UDIErrorCantConnect		3
+#define UDIErrorNoSuchConnection	4
+#define UDIErrorNoConnection		5
+#define UDIErrorCantOpenConfigFile	6
+#define UDIErrorCantStartTIP		7
+#define UDIErrorConnectionUnavailable	8
+#define UDIErrorTryAnotherTIP		9
+#define UDIErrorExecutableNotTIP	10
+#define UDIErrorInvalidTIPOption	11
+#define UDIErrorCantDisconnect		12
+#define UDIErrorUnknownError		13
+#define UDIErrorCantCreateProcess	14
+#define UDIErrorNoSuchProcess		15
+#define UDIErrorUnknownResourceSpace	16
+#define UDIErrorInvalidResource		17
+#define UDIErrorUnsupportedStepType	18
+#define UDIErrorCantSetBreakpoint	19
+#define UDIErrorTooManyBreakpoints	20
+#define UDIErrorInvalidBreakId		21
+#define UDIErrorNoMoreBreakIds		22
+#define UDIErrorUnsupportedService	23
+#define UDIErrorTryAgain		24
+#define UDIErrorIPCLimitation		25
+#define UDIErrorIncomplete		26
+#define UDIErrorAborted			27
+#define UDIErrorTransDone		28
+#define UDIErrorCantAccept		29
+#define UDIErrorTransInputNeeded	30
+#define UDIErrorTransModeX		31
+#define UDIErrorInvalidSize		32
+#define UDIErrorBadConfigFileEntry	33
+#define UDIErrorIPCInternal		34
+/* TBD */
+
+/****************************************************************** PROCEDURES
+*/
+
+UDIError UDIConnect UDIParams((
+  char		*Configuration,		/* In */
+  UDISessionId	*Session		/* Out */
+  ));
+
+UDIError UDIDisconnect UDIParams((
+  UDISessionId	Session,		/* In */
+  UDIBool	Terminate		/* In */
+  ));
+
+UDIError UDISetCurrentConnection UDIParams((
+  UDISessionId	Session			/* In */
+  ));
+
+UDIError UDICapabilities UDIParams((
+  UDIUInt32	*TIPId,			/* Out */
+  UDIUInt32	*TargetId,		/* Out */
+  UDIUInt32	DFEId,			/* In */
+  UDIUInt32	DFE,			/* In */
+  UDIUInt32	*TIP,			/* Out */
+  UDIUInt32	*DFEIPCId,		/* Out */
+  UDIUInt32	*TIPIPCId,		/* Out */
+  char		*TIPString		/* Out */
+  ));
+
+UDIError UDIEnumerateTIPs UDIParams((
+  UDIInt	(*UDIETCallback)	/* In */
+    UDIParams(( char *Configuration ))	/* In to callback() */
+  ));
+
+UDIError UDIGetErrorMsg UDIParams((
+  UDIError	ErrorCode,		/* In */
+  UDISizeT	MsgSize,		/* In */
+  char		*Msg,			/* Out */
+  UDISizeT	*CountDone		/* Out */
+  ));
+
+UDIError UDIGetTargetConfig UDIParams((
+  UDIMemoryRange KnownMemory[],		/* Out */
+  UDIInt	*NumberOfRanges,	/* In/Out */
+  UDIUInt32	ChipVersions[],		/* Out */
+  UDIInt	*NumberOfChips		/* In/Out */
+  ));
+
+UDIError UDICreateProcess UDIParams((
+  UDIPId	*PId			/* Out */
+  ));
+
+UDIError UDISetCurrentProcess UDIParams((
+  UDIPId	PId			/* In */
+  ));
+
+UDIError UDIDestroyProcess UDIParams((
+  UDIPId	PId			/* In */
+  ));
+
+UDIError UDIInitializeProcess UDIParams((
+  UDIMemoryRange ProcessMemory[],	/* In */
+  UDIInt	NumberOfRanges,		/* In */
+  UDIResource	EntryPoint,		/* In */
+  CPUSizeT	StackSizes[],		/* In */
+  UDIInt	NumberOfStacks,		/* In */
+  char		*ArgString		/* In */
+  ));
+
+UDIError UDIRead UDIParams((
+  UDIResource	From,			/* In */
+  UDIHostMemPtr	To,			/* Out */
+  UDICount	Count,			/* In */
+  UDISizeT	Size,			/* In */
+  UDICount	*CountDone,		/* Out */
+  UDIBool	HostEndian		/* In */
+  ));
+
+UDIError UDIWrite UDIParams((
+  UDIHostMemPtr	From,			/* In */
+  UDIResource	To,			/* In */
+  UDICount	Count,			/* In */
+  UDISizeT	Size,			/* In */
+  UDICount	*CountDone,		/* Out */
+  UDIBool	HostEndian		/* In */
+  ));
+
+UDIError UDICopy UDIParams((
+  UDIResource	From,			/* In */
+  UDIResource	To,			/* In */
+  UDICount	Count,			/* In */
+  UDISizeT	Size,			/* In */
+  UDICount	*CountDone,		/* Out */
+  UDIBool	Direction		/* In */
+  ));
+
+UDIError UDIExecute UDIParams((
+  void
+  ));
+
+UDIError UDIStep UDIParams((
+  UDIUInt32	Steps,			/* In */
+  UDIStepType   StepType,		/* In */
+  UDIRange      Range			/* In */
+  ));
+
+UDIVoid UDIStop UDIParams((
+  void
+  ));
+
+UDIError UDIWait UDIParams((
+  UDIInt32	MaxTime,		/* In */
+  UDIPId	*PId,			/* Out */
+  UDIUInt32	*StopReason		/* Out */
+  ));
+
+UDIError UDISetBreakpoint UDIParams((
+  UDIResource	Addr,			/* In */
+  UDIInt32	PassCount,		/* In */
+  UDIBreakType	Type,			/* In */
+  UDIBreakId	*BreakId		/* Out */
+  ));
+
+UDIError UDIQueryBreakpoint UDIParams((
+  UDIBreakId	BreakId,		/* In */
+  UDIResource	*Addr,			/* Out */
+  UDIInt32	*PassCount,		/* Out */
+  UDIBreakType	*Type,			/* Out */
+  UDIInt32	*CurrentCount		/* Out */
+  ));
+
+UDIError UDIClearBreakpoint UDIParams((
+  UDIBreakId	BreakId			/* In */
+  ));
+
+UDIError UDIGetStdout UDIParams((
+  UDIHostMemPtr	Buf,			/* Out */
+  UDISizeT	BufSize,		/* In */
+  UDISizeT	*CountDone		/* Out */
+  ));
+
+UDIError UDIGetStderr UDIParams((
+  UDIHostMemPtr	Buf,			/* Out */
+  UDISizeT	BufSize,		/* In */
+  UDISizeT	*CountDone		/* Out */
+  ));
+
+UDIError UDIPutStdin UDIParams((
+  UDIHostMemPtr	Buf,			/* In */
+  UDISizeT	Count,			/* In */
+  UDISizeT	*CountDone		/* Out */
+  ));
+
+UDIError UDIStdinMode UDIParams((
+  UDIMode	*Mode			/* Out */
+  ));
+
+UDIError UDIPutTrans UDIParams((
+  UDIHostMemPtr	Buf,			/* In */
+  UDISizeT	Count,			/* In */
+  UDISizeT	*CountDone		/* Out */
+  ));
+
+UDIError UDIGetTrans UDIParams((
+  UDIHostMemPtr	Buf,			/* Out */
+  UDISizeT	BufSize,		/* In */
+  UDISizeT	*CountDone		/* Out */
+  ));
+
+UDIError UDITransMode UDIParams((
+  UDIMode	*Mode			/* Out */
+  ));
diff --git a/gdb/29k-share/udi/udipt29k.h b/gdb/29k-share/udi/udipt29k.h
new file mode 100644
index 0000000..5076a97
--- /dev/null
+++ b/gdb/29k-share/udi/udipt29k.h
@@ -0,0 +1,93 @@
+/******************************************************************************
+ * Copyright 1991 Advanced Micro Devices, Inc.
+ *
+ * This software is the property of Advanced Micro Devices, Inc  (AMD)  which
+ * specifically  grants the user the right to modify, use and distribute this
+ * software provided this notice is not removed or altered.  All other rights
+ * are reserved by AMD.
+ *
+ * AMD MAKES NO WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, WITH REGARD TO THIS
+ * SOFTWARE.  IN NO EVENT SHALL AMD BE LIABLE FOR INCIDENTAL OR CONSEQUENTIAL
+ * DAMAGES IN CONNECTION WITH OR ARISING FROM THE FURNISHING, PERFORMANCE, OR
+ * USE OF THIS SOFTWARE.
+ *
+ * Comments about this software should be directed to udi@amd.com. If access
+ * to electronic mail isn't available, send mail to:
+ *
+ * Advanced Micro Devices, Inc.
+ * 29K Support Products
+ * Mail Stop 573
+ * 5900 E. Ben White Blvd.
+ * Austin, TX 78741
+ *****************************************************************************
+ *       $Id$
+ *	 $Id: @(#)udipt29k.h	2.5, AMD
+ */
+
+/* This file is to be used to reconfigure the UDI Procedural interface
+   for a given target. This file should be placed so that it will be
+   included from udiproc.h. Everything in here will probably need to
+   be changed when you change the target processor. Nothing in here
+   should need to change when you change hosts or compilers.
+*/
+
+/* Select a target CPU Family */
+#define TargetCPUFamily 	Am29K
+
+/* Enumerate the processor specific values for Space in a resource */
+#define UDI29KDRAMSpace		0
+#define UDI29KIOSpace		1
+#define UDI29KCPSpace0		2
+#define UDI29KCPSpace1		3
+#define UDI29KIROMSpace		4
+#define UDI29KIRAMSpace		5
+#define UDI29KLocalRegs		8
+#define UDI29KGlobalRegs	9
+#define UDI29KRealRegs		10
+#define UDI29KSpecialRegs	11
+#define UDI29KTLBRegs		12	/* Not Am29005 */
+#define UDI29KACCRegs		13	/* Am29050 only */
+#define UDI29KICacheSpace	14	/* Am2903x only */
+#define UDI29KAm29027Regs	15	/* When available */
+#define UDI29KPC		16
+#define UDI29KDCacheSpace	17	/* When available */
+
+/* Enumerate the Co-processor registers */
+#define UDI29KCP_F		0
+#define UDI29KCP_Flag		8
+#define UDI29KCP_I		12
+#define UDI29KCP_ITmp		16
+#define UDI29KCP_R		20
+#define UDI29KCP_S		28
+#define UDI29KCP_RTmp		36
+#define UDI29KCP_STmp		44
+#define UDI29KCP_Stat		52
+#define UDI29KCP_Prec		56
+#define UDI29KCP_Reg0		60
+#define UDI29KCP_Reg1		68
+#define UDI29KCP_Reg2		76
+#define UDI29KCP_Reg3		84
+#define UDI29KCP_Reg4		92
+#define UDI29KCP_Reg5		100
+#define UDI29KCP_Reg6		108
+#define UDI29KCP_Reg7		116
+#define UDI29KCP_Mode		124
+
+/* Enumerate the stacks in StackSizes array */
+#define UDI29KMemoryStack	0
+#define UDI29KRegisterStack	1
+
+/* Enumerate the chips for ChipVersions array */
+#define UDI29K29KVersion	0
+#define UDI29K29027Version	1
+
+/* Define special value for elements of ChipVersions array for
+ * chips not present */
+#define UDI29KChipNotPresent	-1
+
+typedef	UDIInt32		UDICount;
+typedef	UDIUInt32		UDISize;
+
+typedef UDIInt			CPUSpace;
+typedef UDIUInt32		CPUOffset;
+typedef	UDIUInt32		CPUSizeT;
diff --git a/gdb/29k-share/udi/udiptcfg.h b/gdb/29k-share/udi/udiptcfg.h
new file mode 100644
index 0000000..a81bd9b
--- /dev/null
+++ b/gdb/29k-share/udi/udiptcfg.h
@@ -0,0 +1 @@
+#include "udipt29k.h"
diff --git a/gdb/29k-share/udi/udisoc.h b/gdb/29k-share/udi/udisoc.h
new file mode 100644
index 0000000..4a55b3c
--- /dev/null
+++ b/gdb/29k-share/udi/udisoc.h
@@ -0,0 +1,193 @@
+/******************************************************************************
+* Copyright 1991 Advanced Micro Devices, Inc.
+* 
+* This software is the property of Advanced Micro Devices, Inc  (AMD)  which
+* specifically  grants the user the right to modify, use and distribute this
+* software provided this notice is not removed or altered.  All other rights
+* are reserved by AMD.
+*
+* AMD MAKES NO WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, WITH REGARD TO THIS
+* SOFTWARE.  IN NO EVENT SHALL AMD BE LIABLE FOR INCIDENTAL OR CONSEQUENTIAL
+* DAMAGES IN CONNECTION WITH OR ARISING FROM THE FURNISHING, PERFORMANCE, OR
+* USE OF THIS SOFTWARE.
+*
+* So that all may benefit from your experience, please report  any  problems
+* or  suggestions about this software to the 29K Technical Support Center at
+* 800-29-29-AMD (800-292-9263) in the USA, or 0800-89-1131  in  the  UK,  or
+* 0031-11-1129 in Japan, toll free.  The direct dial number is 512-462-4118.
+*
+* Advanced Micro Devices, Inc.
+* 29K Support Products
+* Mail Stop 573
+* 5900 E. Ben White Blvd.
+* Austin, TX 78741
+* 800-292-9263
+*****************************************************************************
+*/
+static char udisoc_h[]="@(#)udisoc.h	2.6  Daniel Mann";
+static char udisoc_h_AMD[]="@(#)udisoc.h	2.4, AMD";
+/*
+*       This module defines constants used in the UDI IPC modules
+********************************************************************** HISTORY
+*/
+#define LOCAL static
+#define	company_c	1		/* AMD Company id */
+#define	product_c 	1		/* socket IPC id */
+
+/* Enumerate the UDI procedure services 
+*/
+#define	UDIConnect_c			0
+#define	UDIDisconnect_c			1
+#define	UDISetCurrentConnection_c	2
+#define	UDICapabilities_c		3
+#define	UDIEnumerateTIPs_c		4
+#define	UDIGetErrorMsg_c		5
+#define	UDIGetTargetConfig_c		6
+#define	UDICreateProcess_c		7
+#define	UDISetCurrentProcess_c		8
+#define	UDIDestroyProcess_c		9
+#define	UDIInitializeProcess_c		10
+#define	UDIRead_c			11
+#define	UDIWrite_c			12
+#define	UDICopy_c			13
+#define	UDIExecute_c			14
+#define	UDIStep_c			15
+#define	UDIStop_c			16
+#define	UDIWait_c			17
+#define	UDISetBreakpoint_c		18
+#define	UDIQueryBreakpoint_c		19
+#define	UDIClearBreakpoint_c		20
+#define	UDIGetStdout_c			21
+#define	UDIGetStderr_c			22
+#define	UDIPutStdin_c			23
+#define	UDIStdinMode_c			24
+#define	UDIPutTrans_c			25
+#define	UDIGetTrans_c			26
+#define	UDITransMode_c			27
+#define	UDITest_c			28
+#define	UDIKill_c			29
+
+#define	udr_UDIInt8(udrs, obj)  udr_work(udrs, obj, 1)
+#define	udr_UDIInt16(udrs, obj) udr_work(udrs, obj, 2)
+#define	udr_UDIInt32(udrs, obj) udr_work(udrs, obj, 4)
+#define	udr_UDIInt(udrs, obj)   udr_work(udrs, obj, 4)
+
+#define	udr_UDIUInt8(udrs, obj)  udr_work(udrs, obj, 1)
+#define	udr_UDIUInt16(udrs, obj) udr_work(udrs, obj, 2)
+#define	udr_UDIUInt32(udrs, obj) udr_work(udrs, obj, 4)
+#define	udr_UDIUInt(udrs, obj)   udr_work(udrs, obj, 4)
+
+#define	udr_UDIBool(udrs, obj)   udr_UDIInt32(udrs, obj)
+#define	udr_UDICount(udrs, obj)  udr_UDIInt32(udrs, obj)
+#define	udr_UDISize(udrs, obj)   udr_UDIUInt32(udrs, obj)
+#define	udr_CPUSpace(udrs, obj)  udr_UDIInt32(udrs, obj)
+#define	udr_CPUOffset(udrs, obj) udr_UDIUInt32(udrs, obj)
+#define	udr_CPUSizeT(udrs, obj)  udr_UDIUInt32(udrs, obj)
+#define	udr_UDIBreakId(udrs,obj) udr_UDIUInt(udrs, obj)
+#define	udr_UDISizeT(udrs, obj)  udr_UDIUInt(udrs, obj)
+#define	udr_UDIMode(udrs, obj)   udr_UDIUInt(udrs, obj)
+
+#define	udr_UDIHostMemPtr(udrs, obj) udr_UDIUInt32(udrs, obj)
+#define	udr_UDIVoidPtr(udrs, obj)   udr_UDIUInt32(udrs, obj)
+#define	udr_UDIPId(udrs, obj)       udr_UDIUInt(udrs, obj)
+#define	udr_UDISessionId(udrs, obj) udr_UDIInt32(udrs, obj)
+#define	udr_UDIError(udrs, obj)     udr_UDIInt32(udrs, obj)
+#define	udr_UDIStepType(udrs, obj)  udr_UDIInt32(udrs, obj)
+#define	udr_UDIBreakType(udrs, obj) udr_UDIInt32(udrs, obj)
+
+ 
+#define	UDR_ENCODE 1
+#define	UDR_DECODE 2
+
+typedef struct	UDR_str
+{
+    int		udr_op;			/* UDR operation */
+    int		previous_op;
+    int		sd;
+    int		bufsize;
+    char*	buff;
+    char*	getbytes;
+    char*	putbytes;
+    char*	putend;
+    int		domain;
+    char*	soc_name;
+} UDR;
+
+/******************************************* Declare UDR suport functions */
+int udr_create UDIParams((
+  UDR*	udrs,
+  int	sd,
+  int	size
+  ));
+
+int udr_free UDIParams((
+  UDR*	udrs,
+  ));
+
+int udr_signal UDIParams((
+  UDR*	udrs,
+  ));
+
+int udr_sendnow UDIParams((
+  UDR*	udrs
+  ));
+
+int udr_work UDIParams((
+  UDR*	udrs,
+  void*	object_p,
+  int	size
+  ));
+
+int udr_UDIResource UDIParams((
+  UDR*	udrs,
+  UDIResource*	object_p
+  ));
+
+int udr_UDIRange UDIParams((
+  UDR*	udrs,
+  UDIRange*	object_p
+  ));
+
+int udr_UDIMemoryRange UDIParams((
+  UDR*	udrs,
+  UDIMemoryRange*	object_p
+  ));
+
+int udr_UDIMemoryRange UDIParams((
+  UDR*	udrs,
+  UDIMemoryRange* object_p
+  ));
+
+int udr_int UDIParams((
+  UDR*	udrs,
+  int*	int_p
+  ));
+
+int udr_bytes UDIParams((
+  UDR*	udrs,
+  char*	ptr,
+  int	len
+  ));
+
+char* udr_inline UDIParams((
+  UDR*	udrs,
+  int	size
+  ));
+
+char*	udr_getpos UDIParams((
+  UDR*	udrs
+  ));
+int	udr_setpos UDIParams((
+  UDR*	udrs,
+  char*	pos
+  ));
+
+int	udr_readnow UDIParams((
+  UDR*	udrs,
+  int	size
+  ));
+
+int udr_align UDIParams((
+  UDR*	udrs,
+  int	size,
+  ));
diff --git a/gdb/29k-share/udi/udr.c b/gdb/29k-share/udi/udr.c
new file mode 100644
index 0000000..b5fbe8c
--- /dev/null
+++ b/gdb/29k-share/udi/udr.c
@@ -0,0 +1,425 @@
+/******************************************************************************
+* Copyright 1991 Advanced Micro Devices, Inc.
+* 
+* This software is the property of Advanced Micro Devices, Inc  (AMD)  which
+* specifically  grants the user the right to modify, use and distribute this
+* software provided this notice is not removed or altered.  All other rights
+* are reserved by AMD.
+*
+* AMD MAKES NO WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, WITH REGARD TO THIS
+* SOFTWARE.  IN NO EVENT SHALL AMD BE LIABLE FOR INCIDENTAL OR CONSEQUENTIAL
+* DAMAGES IN CONNECTION WITH OR ARISING FROM THE FURNISHING, PERFORMANCE, OR
+* USE OF THIS SOFTWARE.
+*
+* So that all may benefit from your experience, please report  any  problems
+* or  suggestions about this software to the 29K Technical Support Center at
+* 800-29-29-AMD (800-292-9263) in the USA, or 0800-89-1131  in  the  UK,  or
+* 0031-11-1129 in Japan, toll free.  The direct dial number is 512-462-4118.
+*
+* Advanced Micro Devices, Inc.
+* 29K Support Products
+* Mail Stop 573
+* 5900 E. Ben White Blvd.
+* Austin, TX 78741
+* 800-292-9263
+*****************************************************************************
+*/
+static char udr_c[]="@(#)udr.c	2.8  Daniel Mann";
+static char udr_c_AMD[]="@(#)udr.c	2.3, AMD";
+/* 
+*	This module supports sending and receiving
+*	data objects over a socket conection.
+*	All data is serialised into a character stream,
+*	and de-serialised back into the approproiate objects.
+********************************************************************** HISTORY
+*/
+#include <stdio.h>
+#include <sys/fcntl.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include "udiproc.h"
+#include "udisoc.h"
+
+extern	int	errno;
+extern	char*	malloc();
+
+/* local type decs. and macro defs. not in a .h  file ************* MACRO/TYPE
+*/
+
+/* global dec/defs. which are not in a .h   file ************* EXPORT DEC/DEFS
+*/
+int		udr_errno;		/* error occurs during UDR service */
+
+/* local dec/defs. which are not in a .h   file *************** LOCAL DEC/DEFS
+*/
+
+/****************************************************************** UDR_CREATE
+* Build UDR structure for character stream processing.
+*/
+int udr_create(udrs, sd, size)
+UDR*	udrs;
+int	sd;
+int	size;
+{
+    udrs->sd = sd;
+    if(!udrs->buff) udrs->buff = malloc(size);
+    udrs->getbytes = udrs->buff;	/* set the buffer to the start */
+    udrs->putbytes = udrs->buff;
+    udrs->putend = udrs->buff;
+    udrs->udr_op = -1;			/* don't know the direction */
+    udrs->previous_op = -1;		/* don't know the direction */
+    udrs->bufsize = size;
+    return 0;
+}
+
+/******************************************************************** UDR_FREE
+* Free USR structure and close socket.
+*/
+int udr_free(udrs)
+UDR*	udrs;
+{
+    close(udrs->sd);
+    free(udrs->buff);
+    return 0;
+}
+
+/****************************************************************** UDR_SIGNAL
+* Send a signal to the process at the other end of the socket,
+* indicating that it should expect to recieve a new message shortly.
+*/
+int udr_signal(udrs)
+UDR*	udrs;
+{
+    if(send(udrs->sd, "I", 1, MSG_OOB) == -1)
+    {	perror("ERROR, udr_signal(), send(...MSG_OOB)");
+	udr_errno =  UDIErrorIPCInternal;
+    	return -1;		/* return error code */
+    }
+    return 0;
+}
+
+/***************************************************************** UDR_SENDNOW
+* used to flush the current character stream buffer to
+* the associated socket.  */
+int udr_sendnow(udrs)
+UDR*	udrs;
+{
+    int size = (UDIUInt32)(udrs->putend) - (UDIUInt32)(udrs->buff);
+    if(udrs->previous_op == 0)
+    {   udr_errno =  UDIErrorIPCInternal;
+	return -1;
+    }
+    udrs->putbytes = udrs->buff;
+    udrs->putend = udrs->buff;
+    if (write(udrs->sd, udrs->buff, size) == -1)
+    {	perror("ERROR, udr_sendnow(), write() call: ");
+	udr_errno =  UDIErrorIPCInternal;
+    	return -1;		/* return error code */
+    }
+    return 0;
+}
+
+/******************************************************************** UDR_WORK
+* Function to send or recieve data from the buffers supporting
+* socket communication. The buffer contains serialised objects
+* sent/recieved over a socket connection.
+*/
+int udr_work(udrs, object_p, size)
+UDR*	udrs;
+void*	object_p;
+int	size;
+{
+    int	    cnt, remain;
+
+    if(udrs->udr_op != udrs->previous_op)
+    {	if(udrs->previous_op == 0)
+	{   udr_errno =  UDIErrorIPCInternal;
+	    return -1;
+        }
+	udrs->previous_op= udrs->udr_op;
+	udrs->putbytes = udrs->buff;
+	udrs->getbytes = udrs->buff;
+    }
+
+    if(udrs->udr_op == UDR_ENCODE)
+    {			/* write data into character stream buffer */
+    	if( (UDIUInt32)(udrs->putbytes) + size >
+	    (UDIUInt32)(udrs->buff) + (UDIUInt32)(udrs->bufsize) )
+	{   udr_errno =  UDIErrorIPCInternal;
+	    return -1;
+        }
+	bcopy((char*)object_p, udrs->putbytes, size);
+    	udrs->putbytes += size;
+    	if(udrs->putbytes > udrs->putend) udrs->putend = udrs->putbytes;
+    }
+    else if(udrs->udr_op == UDR_DECODE)
+    {
+    	if( (UDIUInt32)(udrs->putbytes)-(UDIUInt32)(udrs->getbytes) < size )
+	{		 /* need more data in character stream buffer */
+       	    remain = (UDIUInt32)(udrs->bufsize) -
+		( (UDIUInt32)(udrs->putbytes)-(UDIUInt32)(udrs->buff) );
+       	    if( ((UDIUInt32)(udrs->bufsize) + (UDIUInt32)(udrs->buff)
+		- (UDIUInt32)(udrs->getbytes)) < size)
+	    {   udr_errno =  UDIErrorIPCInternal;
+	        return -1;
+            }
+    	    cnt = read(udrs->sd, (char*)udrs->putbytes, remain);
+	    if(cnt == -1) perror("ERROR udr_work(),  read() failure: ");
+	    udrs->putbytes += cnt;
+    	    if( (UDIUInt32)(udrs->putbytes)-(UDIUInt32)(udrs->getbytes) < size )
+	    {	udr_errno =  UDIErrorIPCInternal;
+	        return -1;		/* return error code */
+    	    }
+    	}		/* read data from character stream buffer */
+	bcopy(udrs->getbytes, (char*)object_p,  size);
+    	udrs->getbytes += size;
+    }
+    else
+    {	udr_errno =  UDIErrorIPCInternal;
+	return -1;
+    }
+    return 0;
+}
+
+/************************************************************* UDR_UDIResource
+*/
+int udr_UDIResource(udrs, object_p)
+UDR*	udrs;
+UDIResource*	object_p;
+{
+    int	retval;
+
+    retval = udr_CPUSpace(udrs, &object_p->Space);
+    retval = retval |  udr_CPUOffset(udrs, &object_p->Offset);
+    return retval;
+}
+
+/**************************************************************** UDR_UDIRange
+*/
+int udr_UDIRange(udrs, object_p)
+UDR*		udrs;
+UDIRange*	object_p;
+{
+    int	retval;
+
+    retval = udr_CPUOffset(udrs, &object_p->Low);
+    retval = retval | udr_CPUOffset(udrs, &object_p->High);
+    return retval;
+}
+
+/********************************************************** UDR_UDIMemoryRange
+*/
+int udr_UDIMemoryRange(udrs, object_p)
+UDR*		udrs;
+UDIMemoryRange*	object_p;
+{
+    int	retval;
+
+    retval = udr_CPUSpace(udrs, &object_p->Space);
+    retval = retval | udr_CPUOffset(udrs, &object_p->Offset);
+    retval = retval | udr_CPUSizeT(udrs, &object_p->Size);
+    return retval;
+}
+
+/****************************************************************** UDR_string
+*/
+int udr_string(udrs, sp)
+UDR*	udrs;
+char*	sp;
+{
+    int	len, retval;
+
+    if(udrs->udr_op == UDR_ENCODE)
+    {
+	if(sp)
+    	{   len = strlen(sp) + 1;
+    	    retval = udr_UDIInt32(udrs, &len);
+    	    retval = retval | udr_work(udrs, sp, len);
+	}
+	else	/* deal with NULL pointer */
+	{   len = 0;
+    	    retval = udr_UDIInt32(udrs, &len);
+	}
+    }
+    else if(udrs->udr_op == UDR_DECODE)
+    {
+    	retval = udr_UDIInt32(udrs, &len);
+	if(len)
+    	    retval = retval | udr_work(udrs, sp, len);
+	else	*sp = '\0';			/* terminate string */
+    }
+    else
+    {	udr_errno =  UDIErrorIPCInternal;
+	return -1;
+    }
+    return retval;
+}
+
+/******************************************************************* UDR_BYTES
+*/
+int udr_bytes(udrs, ptr, len)
+UDR*	udrs;
+char*	ptr;
+int	len;
+{
+    return udr_work(udrs, ptr, len);
+}
+
+/********************************************************************* UDR_INT
+*/
+int udr_int(udrs, int_p)
+UDR*	udrs;
+int*	int_p;
+{
+    int ret_val;
+    UDIInt32  udr_obj;			/* object of know size */
+
+    if(udrs->udr_op == UDR_ENCODE)
+    {
+        udr_obj = *int_p;		/* copy into know object size */
+        return udr_UDIInt32(udrs, &udr_obj);
+    }
+    else if(udrs->udr_op == UDR_DECODE)
+    {
+        ret_val = udr_UDIInt32(udrs, &udr_obj);	/* get object of known size */
+	*int_p = udr_obj;
+	return ret_val;
+    }
+    else
+    {	udr_errno =  UDIErrorIPCInternal;
+	return -1;
+    }
+}
+
+/****************************************************************** UDR_INLINE
+*/
+char* udr_inline(udrs, size)
+UDR*	udrs;
+int	size;
+{
+    if(udrs->udr_op != udrs->previous_op)
+    {	if(udrs->previous_op == 0)
+	{   udr_errno =  UDIErrorIPCInternal;
+	    return 0;
+        }
+    	udrs->previous_op= udrs->udr_op;
+	udrs->putbytes = udrs->buff;
+	udrs->getbytes = udrs->buff;
+    }
+    if(udrs->udr_op == UDR_ENCODE)
+    {
+    	if(udrs->putbytes + size > udrs->bufsize + udrs->buff)
+	   return 0;
+    	udrs->putbytes += size;
+	return udrs->putbytes - size;
+    }
+    else if(udrs->udr_op == UDR_DECODE)
+    {
+    	if(udrs->getbytes + size > udrs->bufsize + udrs->buff)
+	   return 0;
+    	udrs->getbytes += size;
+	return udrs->getbytes - size;
+    }
+    else
+    {	udr_errno =  UDIErrorIPCInternal;
+	return 0;
+    }
+}
+
+/****************************************************************** UDR_GETPOS
+*/
+char*	udr_getpos(udrs)
+UDR*	udrs;
+{
+    if(udrs->udr_op == UDR_ENCODE)
+    {
+	return udrs->putbytes;
+    }
+    else if(udrs->udr_op == UDR_DECODE)
+    {
+	return udrs->getbytes;
+    }
+    else
+    {	udr_errno =  UDIErrorIPCInternal;
+	return 0;
+    }
+}
+
+/****************************************************************** UDR_SETPOS
+*/
+int	udr_setpos(udrs, pos)
+UDR*	udrs;
+char*	pos;
+{
+    if( ((UDIUInt32)pos > (UDIUInt32)(udrs->buff) + (UDIUInt32)(udrs->bufsize))
+     || ((UDIUInt32)pos < (UDIUInt32)(udrs->buff) ) )
+    {	udr_errno =  UDIErrorIPCInternal;
+	return 0;
+    }
+    if(udrs->udr_op == UDR_ENCODE)
+    {
+	udrs->putbytes = pos;
+	return 1;
+    }
+    else if(udrs->udr_op == UDR_DECODE)
+    {
+	udrs->getbytes = pos;
+	return 1;
+    }
+    else
+    {	udr_errno =  UDIErrorIPCInternal;
+	return 0;
+    }
+}
+
+/***************************************************************** UDR_READNOW
+* Try and ensure "size" bytes are available in the
+* receive buffer character stream.
+*/
+int	udr_readnow(udrs, size)
+UDR*	udrs;
+int	size;
+{
+    int	cnt, remain;
+
+    if(udrs->udr_op == UDR_ENCODE)
+    {
+	udr_errno =  UDIErrorIPCInternal;
+	return -1;
+    }
+    else if(udrs->udr_op == UDR_DECODE)
+    {
+    	if( (UDIUInt32)(udrs->putbytes)-(UDIUInt32)(udrs->getbytes) < size )
+	{		 /* need more data in character stream buffer */
+       	    remain = (UDIUInt32)(udrs->bufsize) -
+		( (UDIUInt32)(udrs->putbytes)-(UDIUInt32)(udrs->buff) );
+    	    cnt = read(udrs->sd, (char*)udrs->putbytes, remain);
+	    if(cnt == -1) perror("ERROR udr_work(),  read() failure: ");
+	    udrs->putbytes += cnt;
+    	    if( (UDIUInt32)(udrs->putbytes)-(UDIUInt32)(udrs->getbytes) < size )
+    	    {  fprintf(stderr,"ERROR, udr_readnow() too few bytes in stream\n");
+	       return -1;		/* return error code */
+    	    }
+    	}		
+    }
+    else
+    {	udr_errno =  UDIErrorIPCInternal;
+	return -1;
+    }
+    return 0;
+}
+
+/******************************************************************* UDR_ALIGN
+*/
+int udr_align(udrs, size)
+UDR*	udrs;
+int	size;
+{
+    char*   align;
+    int	    offset;	
+
+    align = udr_getpos(udrs);
+    offset = size - ((int)align & (size -1));
+    offset = offset & (size -1);
+    if(offset) udr_setpos(udrs, align + offset);
+}
diff --git a/gdb/29k-share/udi_soc b/gdb/29k-share/udi_soc
new file mode 100644
index 0000000..343317f
--- /dev/null
+++ b/gdb/29k-share/udi_soc
@@ -0,0 +1,9 @@
+# @(#)udi_soc	2.1 Daniel Mann
+# NOTE: the Session string must not start whith white-space characters.
+# Format of string is:
+# <session>   <domain> <soc_name|host_name> <tip_exe> <pass to UDIconnect>
+soc2cayman  AF_INET            cayman      /bin/udi_tip   ...
+soc2tip     AF_UNIX   astring              tip.exe        ...
+cuba        AF_UNIX   soc_name    ../bin.68020/udi_tip    stuff to pass
+cayman      AF_INET   cayman      this_entry_not_matter   stuff to pass
+iss         AF_UNIX   *                  sun4/isstip	-r osboot