darlinghq/darling-gdb
1
0
Fork 0
mirror of https://github.com/darlinghq/darling-gdb.git synced 2024-11-25 05:00:01 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Add lotsa files for 29k UDI debugger interface support.

Browse Source
This commit is contained in:
Stu Grossman 1992-04-22 20:40:53 +00:00
parent ee0c4cf7d1
commit d7df9c3ca4
11 changed files with 2403 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
gdb/29k-share/.Sanitize Normal file
View File

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

41
gdb/29k-share/udi/.Sanitize Normal file
View File

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

1189
gdb/29k-share/udi/udip2soc.c Normal file
View File

File diff suppressed because it is too large Load Diff

11
gdb/29k-share/udi/udiphcfg.h Normal file
View File

@ -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

86
gdb/29k-share/udi/udiphsun.h Normal file
View File

@ -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

320
gdb/29k-share/udi/udiproc.h Normal file
View File

@ -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 */
));

93
gdb/29k-share/udi/udipt29k.h Normal file
View File

@ -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;

1
gdb/29k-share/udi/udiptcfg.h Normal file
View File

@ -0,0 +1 @@
#include "udipt29k.h"

193
gdb/29k-share/udi/udisoc.h Normal file
View File

@ -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,
));

425
gdb/29k-share/udi/udr.c Normal file
View File

@ -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);
}

9
gdb/29k-share/udi_soc Normal file
View File

@ -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