Merge changes from progressive for dos x udi:

	* Makefile.in (udi2go32.o): add rule to build this file
	* 29k-share/udi/udi2go32.c: new file
	* config/a29k/a29k-udi.mt: add udi2go32.o
	* 29k-share/udi/{udr.c, udip2soc.c}: #ifdef out the entire file
	  if __GO32__ is defined.  What a hack.

1 files changed, 607 insertions, 0 deletions

diff --git a/gdb/29k-share/udi/udi2go32.c b/gdb/29k-share/udi/udi2go32.c
new file mode 100644
index 0000000..63d98ae
--- /dev/null
+++ b/gdb/29k-share/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__ */