From d7df9c3ca4c75f979fd21c46a8fa018701d7adc7 Mon Sep 17 00:00:00 2001 From: Stu Grossman Date: Wed, 22 Apr 1992 20:40:53 +0000 Subject: Add lotsa files for 29k UDI debugger interface support. --- gdb/29k-share/.Sanitize | 35 ++ gdb/29k-share/udi/.Sanitize | 41 ++ gdb/29k-share/udi/udip2soc.c | 1189 ++++++++++++++++++++++++++++++++++++++++++ gdb/29k-share/udi/udiphcfg.h | 11 + gdb/29k-share/udi/udiphsun.h | 86 +++ gdb/29k-share/udi/udiproc.h | 320 ++++++++++++ gdb/29k-share/udi/udipt29k.h | 93 ++++ gdb/29k-share/udi/udiptcfg.h | 1 + gdb/29k-share/udi/udisoc.h | 193 +++++++ gdb/29k-share/udi/udr.c | 425 +++++++++++++++ gdb/29k-share/udi_soc | 9 + 11 files changed, 2403 insertions(+) create mode 100644 gdb/29k-share/.Sanitize create mode 100644 gdb/29k-share/udi/.Sanitize create mode 100644 gdb/29k-share/udi/udip2soc.c create mode 100644 gdb/29k-share/udi/udiphcfg.h create mode 100644 gdb/29k-share/udi/udiphsun.h create mode 100644 gdb/29k-share/udi/udiproc.h create mode 100644 gdb/29k-share/udi/udipt29k.h create mode 100644 gdb/29k-share/udi/udiptcfg.h create mode 100644 gdb/29k-share/udi/udisoc.h create mode 100644 gdb/29k-share/udi/udr.c create mode 100644 gdb/29k-share/udi_soc 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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#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 +* soc2cayman AF_INET cayman 7000 +* 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, + ¶ms_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, + ¶ms_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 +#include +#include +#include +#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: +# +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 -- cgit v1.1