OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

Compare Revisions

  • This comparison shows the changes necessary to convert path 
    /or1k/trunk/gdb-5.0/gdb/29k-share
    from Rev 107 to Rev 1765
    ↔ Reverse comparison
  •

Rev 107 → Rev 1765

/udi/udi2go32.c
0,0 → 1,607
/*
 
Interface from UDI calls in 32-bit mode to go32 in 16-bit mode.
Communication is done through a single interrupt vector, which passes
data through two linear buffers.
 
Call:
AH = 0xfe
AL = UDI function number
ECX = IN length
ESI = pointer to IN buffer
EDI = pointer to OUT buffer
 
Return:
EAX = return value of UDI function
 
Vector:
0x21
 
*/
#ifdef __GO32__
 
#include <stdlib.h>
#include "udiproc.h"
#include "udisoc.h"
 
char dfe_errmsg[500];
 
static char in_buffer[4096];
static char out_buffer[4096];
static char *in_ptr;
static char *out_ptr;
 
#define IN_INIT() in_ptr = in_buffer
#define IN_VAL(t,v) *((t *)in_ptr)++ = v
#define IN_DATA(ptr, cnt) memcpy(in_ptr, ptr, cnt), in_ptr += cnt
 
#define OUT_INIT() out_ptr = out_buffer
#define OUT_VAL(t) (*((t *)out_ptr)++)
#define OUT_DATA(ptr, cnt) memcpy(ptr, out_ptr, cnt), out_ptr += cnt
 
static int DO_CALL(int function)
{
asm("pushl %esi");
asm("pushl %edi");
asm("movb %0, %%al" : : "g" (function));
asm("movl _in_ptr, %ecx");
asm("movl $_in_buffer, %esi");
asm("subl %esi, %ecx");
asm("movl $_out_buffer, %edi");
asm("movb $0xfe, %ah");
asm("int $0x21");
asm("popl %edi");
asm("popl %esi");
}
 
/*----------------------------------------------------------------------*/
 
#ifdef TEST_UDI
int main()
{
int r;
long p2;
short p1;
IN_INIT();
IN_VAL(long, 11111111);
IN_VAL(short, 2222);
IN_DATA("Hello, world\n", 17);
 
r = DO_CALL(42);
 
OUT_INIT();
p1 = OUT_VAL(short);
p2 = OUT_VAL(long);
printf("main: p1=%d p2=%d rv=%d\n", p1, p2, r);
return r;
}
#endif
 
/*----------------------------------------------------------------------*/
 
unsupported(char *s)
{
printf("unsupported UDI host call %s\n", s);
abort();
}
 
UDIError UDIConnect (
char *Configuration, /* In */
UDISessionId *Session /* Out */
)
{
int r;
out_buffer[0] = 0; /* DJ - test */
IN_INIT();
IN_DATA(Configuration, strlen(Configuration)+1);
r = DO_CALL(UDIConnect_c);
 
OUT_INIT();
*Session = OUT_VAL(UDISessionId);
return r;
}
 
UDIError UDIDisconnect (
UDISessionId Session, /* In */
UDIBool Terminate /* In */
)
{
int r;
IN_INIT();
IN_VAL(UDISessionId, Session);
IN_VAL(UDIBool, Terminate);
return DO_CALL(UDIDisconnect_c);
}
 
UDIError UDISetCurrentConnection (
UDISessionId Session /* In */
)
{
IN_INIT();
IN_VAL(UDISessionId, Session);
return DO_CALL(UDISetCurrentConnection_c);
}
 
UDIError UDICapabilities (
UDIUInt32 *TIPId, /* Out */
UDIUInt32 *TargetId, /* Out */
UDIUInt32 DFEId, /* In */
UDIUInt32 DFE, /* In */
UDIUInt32 *TIP, /* Out */
UDIUInt32 *DFEIPCId, /* Out */
UDIUInt32 *TIPIPCId, /* Out */
char *TIPString /* Out */
)
{
int r;
IN_INIT();
IN_VAL(UDIUInt32, DFEId);
IN_VAL(UDIUInt32, DFE);
r = DO_CALL(UDICapabilities_c);
OUT_INIT();
*TIPId = OUT_VAL(UDIUInt32);
*TargetId = OUT_VAL(UDIUInt32);
*TIP = OUT_VAL(UDIUInt32);
*DFEIPCId = OUT_VAL(UDIUInt32);
*TIPIPCId = OUT_VAL(UDIUInt32);
strcpy(TIPString, out_ptr);
return r;
}
 
UDIError UDIEnumerateTIPs (
UDIInt (*UDIETCallback) /* In */
( char *Configuration ) /* In to callback() */
)
{
UDIETCallback("montip.exe");
}
 
UDIError UDIGetErrorMsg (
UDIError ErrorCode, /* In */
UDISizeT MsgSize, /* In */
char *Msg, /* Out */
UDISizeT *CountDone /* Out */
)
{
int r;
if (MsgSize > 4000)
MsgSize = 4000;
IN_INIT();
IN_VAL(UDIError, ErrorCode);
IN_VAL(UDISizeT, MsgSize);
r = DO_CALL(UDIGetErrorMsg_c);
OUT_INIT();
*CountDone = OUT_VAL(UDISizeT);
OUT_DATA(Msg, *CountDone);
return r;
}
 
UDIError UDIGetTargetConfig (
UDIMemoryRange KnownMemory[], /* Out */
UDIInt *NumberOfRanges, /* In/Out */
UDIUInt32 ChipVersions[], /* Out */
UDIInt *NumberOfChips /* In/Out */
)
{
int r, i;
int nr = *NumberOfRanges;
int nc = *NumberOfChips;
IN_INIT();
IN_VAL(UDIInt, *NumberOfRanges);
IN_VAL(UDIInt, *NumberOfChips);
r = DO_CALL(UDIGetTargetConfig_c);
if (r == UDIErrorIncomplete)
return r;
OUT_INIT();
*NumberOfRanges = OUT_VAL(UDIInt);
*NumberOfChips = OUT_VAL(UDIInt);
for (i=0; i<nr; i++)
{
KnownMemory[i].Space = OUT_VAL(short);
KnownMemory[i].Offset = OUT_VAL(CPUOffset);
KnownMemory[i].Size = OUT_VAL(CPUSizeT);
}
for (i=0; i<nc; i++)
{
ChipVersions[i] = OUT_VAL(UDIUInt32);
}
return r;
}
 
UDIError UDICreateProcess (
UDIPId *PId /* Out */
)
{
int r = DO_CALL(UDICreateProcess_c);
 
OUT_INIT();
*PId = OUT_VAL(UDIPId);
 
return r;
}
 
UDIError UDISetCurrentProcess (
UDIPId PId /* In */
)
{
IN_INIT();
IN_VAL(UDIPId, PId);
 
return DO_CALL(UDISetCurrentProcess_c);
}
 
UDIError UDIDestroyProcess (
UDIPId PId /* In */
)
{
IN_INIT();
IN_VAL(UDIPId, PId);
 
return DO_CALL(UDIDestroyProcess_c);
}
 
UDIError UDIInitializeProcess (
UDIMemoryRange ProcessMemory[], /* In */
UDIInt NumberOfRanges, /* In */
UDIResource EntryPoint, /* In */
CPUSizeT StackSizes[], /* In */
UDIInt NumberOfStacks, /* In */
char *ArgString /* In */
)
{
int i, r;
IN_INIT();
IN_VAL(UDIInt, NumberOfRanges);
for (i=0; i<NumberOfRanges; i++)
{
IN_VAL(short, ProcessMemory[i].Space);
IN_VAL(CPUOffset, ProcessMemory[i].Offset);
IN_VAL(CPUSizeT, ProcessMemory[i].Size);
}
IN_VAL(short, EntryPoint.Space);
IN_VAL(CPUOffset, EntryPoint.Offset);
IN_VAL(UDIInt, NumberOfStacks);
for (i=0; i<NumberOfStacks; i++)
IN_VAL(CPUSizeT, StackSizes[i]);
IN_DATA(ArgString, strlen(ArgString)+1);
 
return DO_CALL(UDIInitializeProcess_c);
}
 
UDIError UDIRead (
UDIResource From, /* In */
UDIHostMemPtr To, /* Out */
UDICount Count, /* In */
UDISizeT Size, /* In */
UDICount *CountDone, /* Out */
UDIBool HostEndian /* In */
)
{
int cleft = Count, cthis, dthis;
int cdone = 0, r, bsize=2048/Size;
while (cleft)
{
cthis = (cleft<bsize) ? cleft : bsize;
IN_INIT();
IN_VAL(short, From.Space);
IN_VAL(CPUOffset, From.Offset);
IN_VAL(UDICount, cthis);
IN_VAL(UDISizeT, Size);
IN_VAL(UDIBool, HostEndian);
 
r = DO_CALL(UDIRead_c);
 
OUT_INIT();
dthis = OUT_VAL(UDICount);
OUT_DATA(To, dthis*Size);
cdone += dthis;
To += dthis*Size;
 
if (r != UDINoError)
{
*CountDone = cdone;
return r;
}
cleft -= cthis;
}
*CountDone = cdone;
return UDINoError;
}
 
UDIError UDIWrite (
UDIHostMemPtr From, /* In */
UDIResource To, /* In */
UDICount Count, /* In */
UDISizeT Size, /* In */
UDICount *CountDone, /* Out */
UDIBool HostEndian /* In */
)
{
int cleft = Count, cthis, dthis;
int cdone = 0, r, bsize=2048/Size;
while (cleft)
{
cthis = (cleft<bsize) ? cleft : bsize;
IN_INIT();
IN_VAL(short, To.Space);
IN_VAL(CPUOffset, To.Offset);
IN_VAL(UDICount, cthis);
IN_VAL(UDISizeT, Size);
IN_VAL(UDIBool, HostEndian);
IN_DATA(From, cthis*Size);
From += cthis*Size;
r = DO_CALL(UDIWrite_c);
 
OUT_INIT();
cdone += OUT_VAL(UDICount);
 
if (r != UDINoError)
{
*CountDone = cdone;
return r;
}
cleft -= cthis;
}
*CountDone = cdone;
return UDINoError;
}
 
UDIError UDICopy (
UDIResource From, /* In */
UDIResource To, /* In */
UDICount Count, /* In */
UDISizeT Size, /* In */
UDICount *CountDone, /* Out */
UDIBool Direction /* In */
)
{
int r;
IN_INIT();
IN_VAL(short, From.Space);
IN_VAL(CPUOffset, From.Offset);
IN_VAL(short, To.Space);
IN_VAL(CPUOffset, To.Offset);
IN_VAL(UDICount, Count);
IN_VAL(UDISizeT, Size);
IN_VAL(UDIBool, Direction);
r = DO_CALL(UDICopy_c);
OUT_INIT();
*CountDone = OUT_VAL(UDICount);
return r;
}
 
UDIError UDIExecute (
void
)
{
return DO_CALL(UDIExecute_c);
}
 
UDIError UDIStep (
UDIUInt32 Steps, /* In */
UDIStepType StepType, /* In */
UDIRange Range /* In */
)
{
IN_INIT();
IN_VAL(UDIUInt32, Steps);
IN_VAL(UDIStepType, StepType);
IN_VAL(UDIRange, Range);
return DO_CALL(UDIStep_c);
}
 
UDIVoid UDIStop (
void
)
{
DO_CALL(UDIStop_c);
}
 
UDIError UDIWait (
UDIInt32 MaxTime, /* In */
UDIPId *PId, /* Out */
UDIUInt32 *StopReason /* Out */
)
{
int r;
IN_INIT();
IN_VAL(UDIInt32, MaxTime);
r = DO_CALL(UDIWait_c);
OUT_INIT();
*PId = OUT_VAL(UDIPId);
*StopReason = OUT_VAL(UDIUInt32);
return r;
}
 
UDIError UDISetBreakpoint (
UDIResource Addr, /* In */
UDIInt32 PassCount, /* In */
UDIBreakType Type, /* In */
UDIBreakId *BreakId /* Out */
)
{
int r;
IN_INIT();
IN_VAL(short, Addr.Space);
IN_VAL(CPUOffset, Addr.Offset);
IN_VAL(UDIInt32, PassCount);
IN_VAL(UDIBreakType, Type);
r = DO_CALL(UDISetBreakpoint_c);
OUT_INIT();
*BreakId = OUT_VAL(UDIBreakId);
return r;
}
 
UDIError UDIQueryBreakpoint (
UDIBreakId BreakId, /* In */
UDIResource *Addr, /* Out */
UDIInt32 *PassCount, /* Out */
UDIBreakType *Type, /* Out */
UDIInt32 *CurrentCount /* Out */
)
{
int r;
IN_INIT();
IN_VAL(UDIBreakId, BreakId);
r = DO_CALL(UDIQueryBreakpoint_c);
OUT_INIT();
Addr->Space = OUT_VAL(short);
Addr->Offset = OUT_VAL(CPUOffset);
*PassCount = OUT_VAL(UDIInt32);
*Type = OUT_VAL(UDIBreakType);
*CurrentCount = OUT_VAL(UDIInt32);
return r;
}
 
UDIError UDIClearBreakpoint (
UDIBreakId BreakId /* In */
)
{
IN_INIT();
IN_VAL(UDIBreakId, BreakId);
return DO_CALL(UDIClearBreakpoint_c);
}
 
UDIError UDIGetStdout (
UDIHostMemPtr Buf, /* Out */
UDISizeT BufSize, /* In */
UDISizeT *CountDone /* Out */
)
{
int r;
IN_INIT();
if (BufSize > 4000)
BufSize = 4000;
IN_VAL(UDISizeT,BufSize);
r = DO_CALL(UDIGetStdout_c);
OUT_INIT();
*CountDone = OUT_VAL(UDISizeT);
if (*CountDone <= BufSize)
OUT_DATA(Buf, *CountDone);
return r;
}
 
UDIError UDIGetStderr (
UDIHostMemPtr Buf, /* Out */
UDISizeT BufSize, /* In */
UDISizeT *CountDone /* Out */
)
{
int r;
IN_INIT();
if (BufSize > 4000)
BufSize = 4000;
IN_VAL(UDISizeT,BufSize);
r = DO_CALL(UDIGetStderr_c);
OUT_INIT();
*CountDone = OUT_VAL(UDISizeT);
OUT_DATA(Buf, *CountDone);
return r;
}
 
UDIError UDIPutStdin (
UDIHostMemPtr Buf, /* In */
UDISizeT Count, /* In */
UDISizeT *CountDone /* Out */
)
{
int r;
IN_INIT();
if (Count > 4000)
Count = 4000;
IN_VAL(UDISizeT,Count);
IN_DATA(Buf, Count);
r = DO_CALL(UDIPutStdin_c);
OUT_INIT();
*CountDone = OUT_VAL(UDISizeT);
return r;
}
 
UDIError UDIStdinMode (
UDIMode *Mode /* Out */
)
{
int r;
IN_INIT();
r = DO_CALL(UDIStdinMode_c);
OUT_INIT();
*Mode = OUT_VAL(UDIMode);
return r;
}
 
UDIError UDIPutTrans (
UDIHostMemPtr Buf, /* In */
UDISizeT Count, /* In */
UDISizeT *CountDone /* Out */
)
{
int r;
IN_INIT();
if (Count > 4000)
Count = 4000;
IN_VAL(UDISizeT,Count);
IN_DATA(Buf, Count);
r = DO_CALL(UDIPutTrans_c);
OUT_INIT();
*CountDone = OUT_VAL(UDISizeT);
return r;
}
 
UDIError UDIGetTrans (
UDIHostMemPtr Buf, /* Out */
UDISizeT BufSize, /* In */
UDISizeT *CountDone /* Out */
)
{
int r;
IN_INIT();
if (BufSize > 4000)
BufSize = 4000;
IN_VAL(UDISizeT,BufSize);
r = DO_CALL(UDIGetTrans_c);
OUT_INIT();
*CountDone = OUT_VAL(UDISizeT);
OUT_DATA(Buf, *CountDone);
return r;
}
 
UDIError UDITransMode (
UDIMode *Mode /* Out */
)
{
int r;
IN_INIT();
r = DO_CALL(UDITransMode_c);
OUT_INIT();
*Mode = OUT_VAL(UDIMode);
return r;
}
 
#define DFEIPCIdCompany 0x0001 /* Company ID AMD */
#define DFEIPCIdProduct 0x1 /* Product ID 0 */
#define DFEIPCIdVersion 0x125 /* 1.2.5 */
 
unsigned UDIGetDFEIPCId ()
{
return((((UDIUInt32)DFEIPCIdCompany) << 16) |(DFEIPCIdProduct << 12) | DFEIPCIdVersion);
}
 
#endif /* __GO32__ */
/udi/udiphcfg.h
0,0 → 1,44
/* This file just picks the correct udiphxxx.h depending on the host.
The two hosts that are now defined are UNIX and MSDOS.
 
Copyright 1993 Free Software Foundation, Inc.
 
This file is part of GDB.
 
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
 
/*
* For the moment, we will default to BSD_IPC; this might change if/when
* another type of IPC (Mach? SysV?) is implemented.
*/
 
#if 0
 
/* We don't seem to have a copy of udiphdos.h. Furthermore, all the
things in udiphunix.h are pretty much generic 32-bit machine defines
which don't have anything to do with IPC. */
 
#ifdef DOS_IPC
#include "udiphdos.h"
#else
/*#ifdef BSD_IPC */
#include "udiphunix.h"
#endif
 
#else
 
#include "udiphunix.h"
 
#endif
/udi/udipt29k.h
0,0 → 1,87
/* This file is to be used to reconfigure the UDI Procedural interface
for a given target.
 
Copyright 1993 Free Software Foundation, Inc.
 
This file is part of GDB.
 
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
 
/* 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;
/udi/udiphunix.h
0,0 → 1,81
/* Originally called "udiphsun.h", however it was not very
Sun-specific; now it is used for generic-unix-with-bsd-ipc.
 
Copyright 1993 Free Software Foundation, Inc.
 
This file is part of GDB.
 
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
 
/* 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 unix */
/* 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
/udi/udiids.h
0,0 → 1,48
/* This file contains the DFE and TIP IDs to be used by AMD products for
the UDICapabilities call.
Copyright 1993 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
 
/* Company Codes -- AMD assigns these */
#define UDICompanyCode_AMD 1
 
/* Build a UDIID given a CompanyProdCode and 3 version pieces */
#define UDIID(CompanyProdCode, v1,v2,v3) ((((CompanyProdCode) & 0xfffff)<<12)+\
(((v1)&0xf)<<8) + (((v2)&0xf)<<4) + ((v3)&0xf))
 
 
/* Extract a CompanyProdCode or a Version from a UDIID */
#define UDIID_CompanyProdCode(id) (((id)>>12) & 0xfffff)
#define UDIID_Version(id) ((id)&0xfff)
 
 
#define UDIAMDProduct(ProdCode) ((UDICompanyCode_AMD<<4) + (ProdCode&0xf))
 
/* AMD DFE Product Codes */
#define UDIProductCode_Mondfe UDIAMDProduct(0)
#define UDIProductCode_XRAY UDIAMDProduct(1)
#define UDIProductCode_TIPTester UDIAMDProduct(2)
 
/* AMD TIP Product Codes (need not be distinct from DFE Product Codes) */
#define UDIProductCode_Montip UDIAMDProduct(0)
#define UDIProductCode_Isstip UDIAMDProduct(1)
 
 
#define UDILatestVersion 0x120 /* UDI 1.2.0, can be used in DFE and TIP desired UDI params */
 
/udi/udip2soc.c
0,0 → 1,1250
/* Copyright 1993 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
 
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
*/
/* This is all unneeded on DOS machines. */
#ifndef __GO32__
 
#include <stdio.h>
#include <string.h>
 
/* Before sys/file.h for Unixware. */
#include <sys/types.h>
 
#include <sys/file.h>
 
/* This used to say sys/fcntl.h, but the only systems I know of that
require that are old (pre-4.3, at least) BSD systems, which we
probably don't need to worry about. */
#include <fcntl.h>
 
#include <sys/wait.h>
#include <sys/time.h>
#include <sys/resource.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <signal.h>
#include <sys/errno.h>
#include "udiproc.h"
#include "udisoc.h"
 
extern int errno;
extern int sys_nerr;
extern 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 */
 
typedef struct connection_str /* record of connect session */
{
int in_use;
char connect_id[20]; /* connection identifier */
char domain_string[20]; /* dommaing for conection */
char tip_string[30]; /* TIP host name for AF_INET */
char tip_exe[80]; /* TIP exe name */
int dfe_sd; /* associated DFE socket */
int tip_pid; /* pid of TIP process */
struct sockaddr_in dfe_sockaddr;
struct sockaddr_in tip_sockaddr_in;
struct sockaddr tip_sockaddr;
} connection_t;
 
typedef struct session_str
{
int in_use;
connection_t* soc_con_p; /* associated connection */
UDISessionId tip_id; /* associated TIP session ID */
} session_t;
 
/* global dec/defs. which are not in a .h file ************* EXPORT DEC/DEFS
*/
UDIError dfe_errno;
char dfe_errmsg[ERRMSG_SIZE];/* error string */
 
/* local dec/defs. which are not in a .h file *************** LOCAL DEC/DEFS
*/
LOCAL connection_t soc_con[MAX_SESSIONS];
LOCAL session_t session[MAX_SESSIONS];
LOCAL UDR udr;
LOCAL UDR* udrs = &udr; /* UDR for current session */
LOCAL int current; /* int-id for current session */
LOCAL char sbuf[SBUF_SIZE]; /* String handler buffer */
LOCAL char config_file[80]; /* path/name for config file */
 
/***************************************************************** UDI_CONNECT
* Establish a new FDE to TIP conection. The file "./udi_soc" or
* "/etc/udi_soc" may be examined to obtain the conection information
* if the "Config" parameter is not a completd "line entry".
*
* NOTE: the Session string must not start whith white-space characters.
* Format of string is:
* <session> <domain> <soc_name|host_name> <tip_exe|port> <pass to UDIconnect>
* soc2cayman AF_INET cayman 7000 <not supported>
* soc2tip AF_UNIX astring tip.exe ...
*/
UDIError
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, params_pos=0;
char *tip_main_string;
char *env_p;
struct hostent *tip_info_p;
FILE *fd;
#if 0
FILE *f_p;
#endif
UDIUInt32 TIPIPCId;
UDIUInt32 DFEIPCId;
 
#if 0 /* This is crap. It assumes that udi_soc is executable! */
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);
#endif
 
for (rcnt=0;
rcnt < MAX_SESSIONS && session[rcnt].in_use;
rcnt++);
 
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 && soc_con[cnt].in_use;
cnt++);
 
if (cnt >= MAX_SESSIONS)
{
sprintf(dfe_errmsg,
"DFE-ipc ERROR: Too many connections already open");
return UDIErrorIPCLimitation;
}
 
*Session = rcnt;
session[rcnt].soc_con_p = &soc_con[cnt];
 
if (strchr(Config, ' ')) /* test if file entry given */
{
soc_con[cnt].in_use = TRUE;
sscanf(Config, "%s %s %s %s %n",
soc_con[cnt].connect_id,
soc_con[cnt].domain_string,
soc_con[cnt].tip_string,
soc_con[cnt].tip_exe,
&params_pos);
tip_main_string = Config + params_pos;
}
else /* here if need to read udi_soc file */
{
strcpy(config_file, "udi_soc");
env_p = getenv("UDICONF");
if (env_p)
strcpy(config_file, env_p);
 
fd = fopen(config_file, "r");
 
if (!fd)
{
sprintf(dfe_errmsg, "UDIConnect, can't open udi_soc file:\n%s ",
strerror(errno));
dfe_errno = UDIErrorCantOpenConfigFile;
goto tip_failure;
}
 
while (1)
{
if (fscanf(fd, "%s %s %s %s %[^\n]\n",
soc_con[cnt].connect_id,
soc_con[cnt].domain_string,
soc_con[cnt].tip_string,
soc_con[cnt].tip_exe,
sbuf) == EOF)
break;
 
if (strcmp(Config, soc_con[cnt].connect_id) != 0)
continue;
 
soc_con[cnt].in_use = TRUE; /* here if entry found */
 
tip_main_string = sbuf;
break;
}
 
fclose(fd);
if (!soc_con[cnt].in_use)
{
sprintf(dfe_errmsg,
"UDIConnect, can't find `%s' entry in udi_soc file",
Config);
dfe_errno = UDIErrorNoSuchConfiguration;
goto tip_failure;
}
}
/*----------------------------------------------------------- SELECT DOMAIN */
if (strcmp(soc_con[cnt].domain_string, "AF_UNIX") == 0)
domain = AF_UNIX;
else if (strcmp(soc_con[cnt].domain_string, "AF_INET") == 0)
domain = AF_INET;
else
{
sprintf(dfe_errmsg, "DFE-ipc ERROR: socket address family not known");
dfe_errno = UDIErrorBadConfigFileEntry;
goto tip_failure;
}
 
/*---------------------------------------------------- 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
&& rcnt != cnt
&& strcmp(soc_con[cnt].domain_string,
soc_con[rcnt].domain_string) == 0
&& strcmp(soc_con[cnt].tip_string,
soc_con[rcnt].tip_string) == 0)
{
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)
{
sprintf(dfe_errmsg, "DFE-ipc ERROR, socket() call failed %s ",
strerror (errno));
dfe_errno = UDIErrorUnknownError;
goto tip_failure;
}
 
/*--------------------------------------------------------- AF_UNIX CONNECT */
if (domain == AF_UNIX)
{
if (strcmp(soc_con[cnt].tip_string, "*") == 0)
{
for (pos = 0; pos < 20; pos++)
{
int f;
 
sprintf(soc_con[cnt].tip_string,"/tmp/U%d", getpid() + pos);
f = open(soc_con[cnt].tip_string, O_CREAT);
if (f == -1)
continue;
 
close(f);
unlink(soc_con[cnt].tip_string);
break;
}
 
if (pos >= 20)
{
sprintf(dfe_errmsg,
"DFE-ipc ERROR, can't create random socket name");
dfe_errno = UDIErrorCantConnect;
goto tip_failure;
}
}
 
soc_con[cnt].tip_sockaddr.sa_family = domain;
memcpy(soc_con[cnt].tip_sockaddr.sa_data,
soc_con[cnt].tip_string,
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)))
{ /* if connect() fails assume TIP not yet started */
/*------------------------------------------------------------ AF_UNIX EXEC */
int pid;
int statusp;
char *arg0;
 
arg0 = strrchr(soc_con[cnt].tip_exe,'/');
 
if (arg0)
arg0++;
else
arg0 = soc_con[cnt].tip_exe;
pid = vfork();
 
if (pid == 0) /* Child */
{
execlp(soc_con[cnt].tip_exe,
arg0,
soc_con[cnt].domain_string,
soc_con[cnt].tip_string,
NULL);
_exit(1);
}
 
if (waitpid(pid, &statusp, WNOHANG))
{
sprintf(dfe_errmsg, "DFE-ipc ERROR: can't exec the TIP");
dfe_errno = UDIErrorCantStartTIP;
goto tip_failure;
}
 
pos = 3;
for (pos = 3; pos > 0; pos--)
{
if (!connect(soc_con[cnt].dfe_sd,
&soc_con[cnt].tip_sockaddr,
sizeof(soc_con[cnt].tip_sockaddr)))
break;
sleep(1);
}
 
if (pos == 0)
{
sprintf(dfe_errmsg, "DFE-ipc ERROR, connect() call failed: %s",
strerror (errno));
dfe_errno = UDIErrorCantConnect;
goto tip_failure;
}
}
}
/*--------------------------------------------------------- AF_INET CONNECT */
else if (domain == AF_INET)
{
fprintf(stderr,
"DFE-ipc WARNING, need to have first started remote TIP");
 
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)
{
sprintf(dfe_errmsg,"DFE-ipc ERROR, No such host %s",
soc_con[cnt].tip_string);
dfe_errno = UDIErrorNoSuchConnection;
goto tip_failure;
}
memcpy((char *)&soc_con[cnt].tip_sockaddr_in.sin_addr,
tip_info_p->h_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,
(struct sockaddr *) &soc_con[cnt].tip_sockaddr_in,
sizeof(soc_con[cnt].tip_sockaddr_in)))
{
sprintf(dfe_errmsg, "DFE-ipc ERROR, connect() call failed %s ",
strerror (errno));
dfe_errno = UDIErrorCantConnect;
goto tip_failure;
}
}
/*------------------------------------------------------------- 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)
sprintf(dfe_errmsg, "DFE-ipc: Obsolete TIP Specified");
 
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;
 
tip_failure:
 
soc_con[cnt].in_use = FALSE;
session[*Session].in_use = FALSE;
/* XXX - Should also close dfe_sd, but not sure what to do if muxed */
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)
{
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))
{
sprintf(dfe_errmsg, "DFE-ipc WARNING: socket shutdown failed");
return UDIErrorIPCInternal;
}
else
session[Session].soc_con_p->in_use = 0;
 
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)
{
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))
{
sprintf(dfe_errmsg, "DFE-ipc WARNING: socket shutdown failed");
return UDIErrorIPCInternal;
}
else
session[Session].soc_con_p->in_use = 0;
 
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") == 0)
kill(session[current].soc_con_p->tip_pid, SIGINT);
else
udr_signal(udrs);
 
/* XXX - should clean up session[] and soc_con[] structs here as well... */
 
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);
}
#endif /* __GO32__ */
/udi/udr.c
0,0 → 1,427
/* This module supports sending and receiving data objects over a
socket conection.
 
Copyright 1993 Free Software Foundation, Inc.
 
This file is part of GDB.
 
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
 
static char udr_c[]="@(#)udr.c 2.8 Daniel Mann";
static char udr_c_AMD[]="@(#)udr.c 2.3, AMD";
/*
* All data is serialised into a character stream,
* and de-serialised back into the approproiate objects.
********************************************************************** HISTORY
*/
/* This is all unneeded on DOS machines. */
#ifndef __GO32__
 
#include <stdio.h>
#include <sys/types.h>
 
/* This used to say sys/fcntl.h, but the only systems I know of that
require that are old (pre-4.3, at least) BSD systems, which we
probably don't need to worry about. */
#include <fcntl.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;
}
memcpy(udrs->putbytes, (char*)object_p, 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 */
memcpy((char*)object_p, udrs->getbytes, 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);
}
#endif /* __GO32__ */
/udi/udiproc.h
0,0 → 1,308
/* local type decs. and macro defs.
 
Copyright 1993 Free Software Foundation, Inc.
 
This file is part of GDB.
 
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
 
#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 */
));
/udi/udiptcfg.h
0,0 → 1,19
/* Copyright 1993 Free Software Foundation, Inc.
 
This file is part of GDB.
 
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
 
#include "udipt29k.h"
/udi/udisoc.h
0,0 → 1,184
/* This module defines constants used in the UDI IPC modules.
 
Copyright 1993 Free Software Foundation, Inc.
 
This file is part of GDB.
 
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
 
static char udisoc_h[]="@(#)udisoc.h 2.6 Daniel Mann";
static char udisoc_h_AMD[]="@(#)udisoc.h 2.4, AMD";
 
#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,
));
/udi_soc
0,0 → 1,9
# @(#)udi_soc 2.1 Daniel Mann
# NOTE: the Session string must not start whith white-space characters.
# Format of string is:
# <session> <domain> <soc_name|host_name> <tip_exe> <pass to UDIconnect>
soc2cayman AF_INET cayman /bin/udi_tip ...
soc2tip AF_UNIX astring tip.exe ...
cuba AF_UNIX soc_name ../bin.68020/udi_tip stuff to pass
cayman AF_INET cayman this_entry_not_matter stuff to pass
iss AF_UNIX * sun4/isstip -r osboot
/README
0,0 → 1,9
The files in this directory are shared with other debuggers and
debug interfaces that use Advanced Micro Devices' UDI (universal debug
interface) protocol. The protocol provides a common interface among
debuggers, logic analyzers, emulators, and embedded systems that use
AMD 29000 family processors.
 
Do not change these files without coordinating with Advanced Micro
Devices, Embedded Processor Division, 5204 E. Ben White Blvd, Austin, TX 78741.
Maybe postmaster@cayman.amd.com can direct you to the current maintainers.

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.