--- /dev/null
+/* i386-nlmstub.c -- NLM debugging stub for the i386.
+
+ This is originally based on an m68k software stub written by Glenn
+ Engel at HP, but has changed quite a bit. It was modified for the
+ i386 by Jim Kingdon, Cygnus Support. It was modified to run under
+ NetWare by Ian Lance Taylor, Cygnus Support.
+
+ This code is intended to produce an NLM (a NetWare Loadable Module)
+ to run under NetWare on an i386 platform. To create the NLM,
+ compile this code into an object file using the NLM SDK on any i386
+ host, and use the nlmconv program (available in the GNU binutils)
+ to transform the resulting object file into an NLM. */
+
+/****************************************************************************
+
+ THIS SOFTWARE IS NOT COPYRIGHTED
+
+ HP offers the following for use in the public domain. HP makes no
+ warranty with regard to the software or it's performance and the
+ user accepts the software "AS IS" with all faults.
+
+ HP DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED, WITH REGARD
+ TO THIS SOFTWARE INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+
+****************************************************************************/
+
+/****************************************************************************
+ *
+ * The following gdb commands are supported:
+ *
+ * command function Return value
+ *
+ * g return the value of the CPU registers hex data or ENN
+ * G set the value of the CPU registers OK or ENN
+ *
+ * mAA..AA,LLLL Read LLLL bytes at address AA..AA hex data or ENN
+ * MAA..AA,LLLL: Write LLLL bytes at address AA.AA OK or ENN
+ *
+ * c Resume at current address SNN ( signal NN)
+ * cAA..AA Continue at address AA..AA SNN
+ *
+ * s Step one instruction SNN
+ * sAA..AA Step one instruction from AA..AA SNN
+ *
+ * k kill
+ *
+ * ? What was the last sigval ? SNN (signal NN)
+ *
+ * All commands and responses are sent with a packet which includes a
+ * checksum. A packet consists of
+ *
+ * $<packet info>#<checksum>.
+ *
+ * where
+ * <packet info> :: <characters representing the command or response>
+ * <checksum> :: < two hex digits computed as modulo 256 sum of <packetinfo>>
+ *
+ * When a packet is received, it is first acknowledged with either '+' or '-'.
+ * '+' indicates a successful transfer. '-' indicates a failed transfer.
+ *
+ * Example:
+ *
+ * Host: Reply:
+ * $m0,10#2a +$00010203040506070809101112131415#42
+ *
+ ****************************************************************************/
+
+#include <dfs.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <time.h>
+#include <aio.h>
+#include <conio.h>
+#include <advanced.h>
+#include <debugapi.h>
+#include <process.h>
+
+/************************************************************************/
+/*****************************************************************************
+ *
+ * (C) Copyright 1988-1993 Novell, Inc.
+ * All Rights Reserved.
+ *
+ * This program is an unpublished copyrighted work which is proprietary
+ * to Novell, Inc. and contains confidential information that is not
+ * to be reproduced or disclosed to any other person or entity without
+ * prior written consent from Novell, Inc. in each and every instance.
+ *
+ * WARNING: Unauthorized reproduction of this program as well as
+ * unauthorized preparation of derivative works based upon the
+ * program or distribution of copies by sale, rental, lease or
+ * lending are violations of federal copyright laws and state trade
+ * secret laws, punishable by civil and criminal penalties.
+ *
+ * $release$
+ * $modname: loadstuff.h$
+ * $version: 1.37$
+ * $date: Fri, Jan 15, 1993$
+ *
+ ****************************************************************************/
+
+
+/* WARNING: THIS IS NOT A COMPLETE OS HEADER FILE - DON'T GET CONFUSED
+ ***********************************************************************
+ * The information is this file is a subset of the OS LOADER.H.
+ * This file was created to reveal the LoadDefinitionStrucutre and some
+ * associated information to Cygnus Support to assist them in their
+ * efforts to develop GNU netware utilities. Don't confuse this file
+ * with LOADER.H or any other actually supported NetWare header.
+
+************************************************************************/
+
+struct LoadDefinitionStructure
+{
+ struct LoadDefinitionStructure *LDLink;
+ struct LoadDefinitionStructure *LDKillLink;
+ struct LoadDefinitionStructure *LDScanLink;
+ struct ResourceTagStructure *LDResourceList;
+ LONG LDIdentificationNumber;
+ LONG LDCodeImageOffset;
+ LONG LDCodeImageLength;
+ LONG LDDataImageOffset;
+ LONG LDDataImageLength;
+ LONG LDUninitializedDataLength;
+ LONG LDCustomDataOffset;
+ LONG LDCustomDataSize;
+ LONG LDFlags;
+ LONG LDType;
+ LONG (*LDInitializationProcedure)(
+ struct LoadDefinitionStructure *LoadRecord,
+ struct ScreenStruct *screenID,
+ BYTE *CommandLine,
+ BYTE *loadDirectoryPath,
+ LONG uninitializedDataLength,
+ LONG fileHandle,
+ LONG (*ReadRoutine)(
+ LONG fileHandle,
+ LONG offset,
+ void *buffer,
+ LONG numberOfBytes),
+ LONG customDataOffset,
+ LONG customDataSize);
+ void (*LDExitProcedure)(void);
+ LONG (*LDCheckUnloadProcedure)(
+ struct ScreenStruct *screenID);
+ struct ExternalPublicDefinitionStructure *LDPublics;
+ BYTE LDFileName[36];
+ BYTE LDName[128];
+ LONG *LDCLIBLoadStructure;
+ LONG *LDNLMDebugger;
+ LONG LDParentID;
+ LONG LDReservedForCLIB;
+ LONG Reserved0;
+ LONG Reserved1;
+ void *LDModuleObjectHandle; /* If Instrumented BEW 10/16/90 */
+ LONG LDMajorVersion;
+ LONG LDMinorVersion;
+ LONG LDRevision;
+ LONG LDYear;
+ LONG LDMonth;
+ LONG LDDay;
+ BYTE *LDCopyright;
+ LONG LDAllocAvailBytes;
+ LONG LDAllocFreeCount;
+ LONG LDLastGarbCollect;
+ LONG LDAlloc16Lists[64];
+ LONG LDAlloc256Lists[12];
+ LONG LDAlloc4kList;
+ struct DomainStructure *LDDomainID; /* This must be non-zero for the Alloc Hunt code to work right. */
+ /* It also points to the domain structure. */
+ struct LoadDefinitionStructure *LDEnvLink;
+ void *LDAllocPagesListHead;
+ struct ExternalPublicDefinitionStructure *LDTempPublicList;
+ LONG LDMessageLanguage; /* for enabling */
+ BYTE **LDMessages; /* for enabling */
+ LONG LDMessageCount; /* for enabling */
+ BYTE *LDHelpFile; /* for enabling */
+ LONG LDMessageBufferSize; /* for enabling */
+ LONG LDHelpBufferSize; /* for enabling */
+ LONG LDSharedCodeOffset; /* for protection */
+ LONG LDSharedCodeLength; /* for protection */
+ LONG LDSharedDataOffset; /* for protection */
+ LONG LDSharedDataLength; /* for protection */
+ LONG (*LDSharedInitProcedure)(
+ struct LoadDefinitionStructure *LoadRecord,
+ struct ScreenStruct *screenID,
+ BYTE *CommandLine);
+ void (*LDSharedExitProcedure)(void);
+ LONG LDRPCDataTable;
+ LONG LDRealRPCDataTable;
+ LONG LDRPCDataTableSize;
+ LONG LDNumberOfReferencedPublics;
+ struct ExternalPublicDefinitionStructure **LDReferencedPublics;
+ LONG LDNumberOfReferencedExports;
+};
+
+
+/* define the LDFlags. */
+
+#define LDModuleIsReEntrantBit 0x00000001
+#define LDModuleCanBeMultiplyLoadedBit 0x00000002
+#define LDSynchronizeStart 0x00000004
+#define LDPseudoPreemptionBit 0x00000008
+#define LDLoadInOSDomain 0x00000010
+#define LDDontUnloadBit 0x20000000
+#define LDModuleIsBeingDebugged 0x40000000
+#define LDMemoryOn4KBoundriesBit 0x80000000
+
+/* LoadModule load options */
+#define LO_NORMAL 0x0000
+#define LO_STARTUP 0x0001
+#define LO_PROTECT 0x0002
+#define LO_DEBUG 0x0004
+#define LO_AUTO_LOAD 0x0008
+#define LO_DONT_PROMPT 0x0010
+#define LO_LOAD_LOW 0x0020
+#define LO_RETURN_HANDLE 0x0040
+#define LO_LOAD_SILENT 0x0080
+
+/* Loader returned error codes */
+#define LOAD_COULD_NOT_FIND_FILE 1
+#define LOAD_ERROR_READING_FILE 2
+#define LOAD_NOT_NLM_FILE_FORMAT 3
+#define LOAD_WRONG_NLM_FILE_VERSION 4
+#define LOAD_REENTRANT_INITIALIZE_FAILURE 5
+#define LOAD_CAN_NOT_LOAD_MULTIPLE_COPIES 6
+#define LOAD_ALREADY_IN_PROGRESS 7
+#define LOAD_NOT_ENOUGH_MEMORY 8
+#define LOAD_INITIALIZE_FAILURE 9
+#define LOAD_INCONSISTENT_FILE_FORMAT 10
+#define LOAD_CAN_NOT_LOAD_AT_STARTUP 11
+#define LOAD_AUTO_LOAD_MODULES_NOT_LOADED 12
+#define LOAD_UNRESOLVED_EXTERNAL 13
+#define LOAD_PUBLIC_ALREADY_DEFINED 14
+#define LOAD_XDC_DATA_ERROR 15
+#define LOAD_NOT_OS_DOMAIN 16
+
+/****************************************************************************/
+
+/* The main thread ID. */
+static int mainthread;
+
+/* The debug server thread ID. */
+static int debugthread;
+
+/* The LoadDefinitionStructure of the NLM being debugged. */
+static struct LoadDefinitionStructure *handle;
+
+/* Whether we have connected to gdb. */
+static int talking;
+
+/* The actual first instruction in the program. */
+static unsigned char first_insn;
+
+/* An error message for the main thread to print. */
+static char *error_message;
+
+/* The AIO port handle. */
+static int AIOhandle;
+
+/* The console screen. */
+static int console_screen;
+
+/* BUFMAX defines the maximum number of characters in inbound/outbound
+ buffers. At least NUMREGBYTES*2 are needed for register packets */
+#define BUFMAX 400
+
+/* remote_debug > 0 prints ill-formed commands in valid packets and
+ checksum errors. */
+static int remote_debug = 1;
+
+static const char hexchars[] = "0123456789abcdef";
+
+/* Number of bytes of registers. */
+#define NUMREGBYTES 64
+enum regnames {EAX, ECX, EDX, EBX, ESP, EBP, ESI, EDI,
+ PC /* also known as eip */,
+ PS /* also known as eflags */,
+ CS, SS, DS, ES, FS, GS};
+
+/* Register values. */
+static int registers[NUMREGBYTES/4];
+
+/* Read a character from the serial port. This must busy wait, but
+ that's OK because we will be the only thread running anyhow. */
+
+static int
+getDebugChar ()
+{
+ int err;
+ LONG got;
+ unsigned char ret;
+
+ do
+ {
+ err = AIOReadData (AIOhandle, (char *) &ret, 1, &got);
+ if (err != 0)
+ {
+ error_message = "AIOReadData failed";
+ ResumeThread (mainthread);
+ return -1;
+ }
+ }
+ while (got == 0);
+
+ return ret;
+}
+
+/* Write a character to the serial port. Returns 0 on failure,
+ non-zero on success. */
+
+static int
+putDebugChar (c)
+ unsigned char c;
+{
+ int err;
+ LONG put;
+
+ err = AIOWriteData (AIOhandle, (char *) &c, 1, &put);
+ if (err != 0 || put != 1)
+ {
+ error_message = "AIOWriteData failed";
+ ResumeThread (mainthread);
+ return 0;
+ }
+ return 1;
+}
+
+/* Get the registers out of the frame information. */
+
+static void
+frame_to_registers (frame, regs)
+ T_TSS_StackFrame *frame;
+ int *regs;
+{
+ regs[EAX] = frame->ExceptionEAX;
+ regs[ECX] = frame->ExceptionECX;
+ regs[EDX] = frame->ExceptionEDX;
+ regs[EBX] = frame->ExceptionEBX;
+ regs[ESP] = frame->ExceptionESP;
+ regs[EBP] = frame->ExceptionEBP;
+ regs[ESI] = frame->ExceptionESI;
+ regs[EDI] = frame->ExceptionEDI;
+ regs[PC] = frame->ExceptionEIP;
+ regs[PS] = frame->ExceptionSystemFlags;
+ regs[CS] = frame->ExceptionCS[0];
+ regs[SS] = frame->ExceptionSS[0];
+ regs[DS] = frame->ExceptionDS[0];
+ regs[ES] = frame->ExceptionES[0];
+ regs[FS] = frame->ExceptionFS[0];
+ regs[GS] = frame->ExceptionGS[0];
+}
+
+/* Put the registers back into the frame information. */
+
+static void
+registers_to_frame (regs, frame)
+ int *regs;
+ T_TSS_StackFrame *frame;
+{
+ frame->ExceptionEAX = regs[EAX];
+ frame->ExceptionECX = regs[ECX];
+ frame->ExceptionEDX = regs[EDX];
+ frame->ExceptionEBX = regs[EBX];
+ frame->ExceptionESP = regs[ESP];
+ frame->ExceptionEBP = regs[EBP];
+ frame->ExceptionESI = regs[ESI];
+ frame->ExceptionEDI = regs[EDI];
+ frame->ExceptionEIP = regs[PC];
+ frame->ExceptionSystemFlags = regs[PS];
+ frame->ExceptionCS[0] = regs[CS];
+ frame->ExceptionSS[0] = regs[SS];
+ frame->ExceptionDS[0] = regs[DS];
+ frame->ExceptionES[0] = regs[ES];
+ frame->ExceptionFS[0] = regs[FS];
+ frame->ExceptionGS[0] = regs[GS];
+}
+
+/* Turn a hex character into a number. */
+
+static int
+hex (ch)
+ char ch;
+{
+ if ((ch >= 'a') && (ch <= 'f'))
+ return (ch-'a'+10);
+ if ((ch >= '0') && (ch <= '9'))
+ return (ch-'0');
+ if ((ch >= 'A') && (ch <= 'F'))
+ return (ch-'A'+10);
+ return (-1);
+}
+
+/* Scan for the sequence $<data>#<checksum>. Returns 0 on failure,
+ non-zero on success. */
+
+static int
+getpacket (buffer)
+ char * buffer;
+{
+ unsigned char checksum;
+ unsigned char xmitcsum;
+ int i;
+ int count;
+ int ch;
+
+ do
+ {
+ /* wait around for the start character, ignore all other characters */
+ while ((ch = getDebugChar()) != '$')
+ if (ch == -1)
+ return 0;
+ checksum = 0;
+ xmitcsum = -1;
+
+ count = 0;
+
+ /* now, read until a # or end of buffer is found */
+ while (count < BUFMAX)
+ {
+ ch = getDebugChar();
+ if (ch == -1)
+ return 0;
+ if (ch == '#')
+ break;
+ checksum = checksum + ch;
+ buffer[count] = ch;
+ count = count + 1;
+ }
+ buffer[count] = 0;
+
+ if (ch == '#')
+ {
+ ch = getDebugChar ();
+ if (ch == -1)
+ return 0;
+ xmitcsum = hex(ch) << 4;
+ ch = getDebugChar ();
+ if (ch == -1)
+ return 0;
+ xmitcsum += hex(ch);
+ if ((remote_debug ) && (checksum != xmitcsum))
+ {
+ fprintf(stderr,"bad checksum. My count = 0x%x, sent=0x%x. buf=%s\n",
+ checksum,xmitcsum,buffer);
+ }
+
+ if (checksum != xmitcsum)
+ {
+ /* failed checksum */
+ if (! putDebugChar('-'))
+ return 0;
+ }
+ else
+ {
+ /* successful transfer */
+ if (! putDebugChar('+'))
+ return 0;
+ /* if a sequence char is present, reply the sequence ID */
+ if (buffer[2] == ':')
+ {
+ if (! putDebugChar (buffer[0])
+ || ! putDebugChar (buffer[1]))
+ return 0;
+ /* remove sequence chars from buffer */
+ count = strlen(buffer);
+ for (i=3; i <= count; i++)
+ buffer[i-3] = buffer[i];
+ }
+ }
+ }
+ }
+ while (checksum != xmitcsum);
+
+ return 1;
+}
+
+/* Send the packet in buffer. Returns 0 on failure, non-zero on
+ success. */
+
+static int
+putpacket (buffer)
+ char * buffer;
+{
+ unsigned char checksum;
+ int count;
+ int ch;
+
+ /* $<packet info>#<checksum>. */
+ do
+ {
+ if (! putDebugChar('$'))
+ return 0;
+ checksum = 0;
+ count = 0;
+
+ while (ch=buffer[count])
+ {
+ if (! putDebugChar(ch))
+ return 0;
+ checksum += ch;
+ count += 1;
+ }
+
+ if (! putDebugChar('#')
+ || ! putDebugChar(hexchars[checksum >> 4])
+ || ! putDebugChar(hexchars[checksum % 16]))
+ return 0;
+
+ ch = getDebugChar ();
+ if (ch == -1)
+ return 0;
+ }
+ while (ch != '+');
+
+ return 1;
+}
+
+static char remcomInBuffer[BUFMAX];
+static char remcomOutBuffer[BUFMAX];
+static short error;
+
+static void
+debug_error (format, parm)
+ char *format;
+ char *parm;
+{
+ if (remote_debug)
+ fprintf (stderr, format, parm);
+}
+
+/* Address of a routine to RTE to if we get a memory fault. */
+static volatile void (*mem_fault_routine)() = NULL;
+
+/* Indicate to caller of mem2hex or hex2mem that there has been an
+ error. */
+static volatile int mem_err = 0;
+
+static void
+set_mem_err ()
+{
+ mem_err = 1;
+}
+
+/* These are separate functions so that they are so short and sweet
+ that the compiler won't save any registers (if there is a fault
+ to mem_fault, they won't get restored, so there better not be any
+ saved). */
+
+static int
+get_char (addr)
+ char *addr;
+{
+ return *addr;
+}
+
+static void
+set_char (addr, val)
+ char *addr;
+ int val;
+{
+ *addr = val;
+}
+
+/* convert the memory pointed to by mem into hex, placing result in buf */
+/* return a pointer to the last char put in buf (null) */
+/* If MAY_FAULT is non-zero, then we should set mem_err in response to
+ a fault; if zero treat a fault like any other fault in the stub. */
+
+static char *
+mem2hex (mem, buf, count, may_fault)
+ char *mem;
+ char *buf;
+ int count;
+ int may_fault;
+{
+ int i;
+ unsigned char ch;
+
+ if (may_fault)
+ mem_fault_routine = set_mem_err;
+ for (i = 0; i < count; i++)
+ {
+ ch = get_char (mem++);
+ if (may_fault && mem_err)
+ return (buf);
+ *buf++ = hexchars[ch >> 4];
+ *buf++ = hexchars[ch % 16];
+ }
+ *buf = 0;
+ if (may_fault)
+ mem_fault_routine = NULL;
+ return(buf);
+}
+
+/* convert the hex array pointed to by buf into binary to be placed in mem */
+/* return a pointer to the character AFTER the last byte written */
+
+static char *
+hex2mem (buf, mem, count, may_fault)
+ char *buf;
+ char *mem;
+ int count;
+ int may_fault;
+{
+ int i;
+ unsigned char ch;
+
+ if (may_fault)
+ mem_fault_routine = set_mem_err;
+ for (i=0;i<count;i++)
+ {
+ ch = hex(*buf++) << 4;
+ ch = ch + hex(*buf++);
+ set_char (mem++, ch);
+ if (may_fault && mem_err)
+ return (mem);
+ }
+ if (may_fault)
+ mem_fault_routine = NULL;
+ return(mem);
+}
+
+/* This function takes the 386 exception vector and attempts to
+ translate this number into a unix compatible signal value. */
+
+static int
+computeSignal (exceptionVector)
+ int exceptionVector;
+{
+ int sigval;
+ switch (exceptionVector)
+ {
+ case 0 : sigval = 8; break; /* divide by zero */
+ case 1 : sigval = 5; break; /* debug exception */
+ case 3 : sigval = 5; break; /* breakpoint */
+ case 4 : sigval = 16; break; /* into instruction (overflow) */
+ case 5 : sigval = 16; break; /* bound instruction */
+ case 6 : sigval = 4; break; /* Invalid opcode */
+ case 7 : sigval = 8; break; /* coprocessor not available */
+ case 8 : sigval = 7; break; /* double fault */
+ case 9 : sigval = 11; break; /* coprocessor segment overrun */
+ case 10 : sigval = 11; break; /* Invalid TSS */
+ case 11 : sigval = 11; break; /* Segment not present */
+ case 12 : sigval = 11; break; /* stack exception */
+ case 13 : sigval = 11; break; /* general protection */
+ case 14 : sigval = 11; break; /* page fault */
+ case 16 : sigval = 7; break; /* coprocessor error */
+ default:
+ sigval = 7; /* "software generated"*/
+ }
+ return (sigval);
+}
+
+/**********************************************/
+/* WHILE WE FIND NICE HEX CHARS, BUILD AN INT */
+/* RETURN NUMBER OF CHARS PROCESSED */
+/**********************************************/
+static int
+hexToInt(ptr, intValue)
+ char **ptr;
+ int *intValue;
+{
+ int numChars = 0;
+ int hexValue;
+
+ *intValue = 0;
+
+ while (**ptr)
+ {
+ hexValue = hex(**ptr);
+ if (hexValue >=0)
+ {
+ *intValue = (*intValue <<4) | hexValue;
+ numChars ++;
+ }
+ else
+ break;
+
+ (*ptr)++;
+ }
+
+ return (numChars);
+}
+
+/* This function does all command processing for interfacing to gdb.
+ It is called whenever an exception occurs in the module being
+ debugged. */
+
+static LONG
+handle_exception (T_StackFrame *old_frame)
+{
+ T_TSS_StackFrame *frame = (T_TSS_StackFrame *) old_frame;
+ int first = 0;
+ int sigval;
+ int addr, length;
+ char * ptr;
+ int newPC;
+
+ /* Apparently the bell can sometimes be ringing at this point, and
+ should be stopped. */
+ StopBell ();
+
+ if (remote_debug)
+ {
+ ConsolePrintf ("vector=%d: %s, sr=0x%x, pc=0x%x, thread=%d\r\n",
+ frame->ExceptionNumber,
+ frame->ExceptionDescription,
+ frame->ExceptionSystemFlags,
+ frame->ExceptionEIP,
+ GetThreadID ());
+ }
+
+ /* If the NLM just started, we record the module load information
+ and the thread ID, and set a breakpoint at the first instruction
+ in the program. */
+ if (frame->ExceptionNumber == START_NLM_EVENT
+ && handle == NULL)
+ {
+ debugthread = GetThreadID ();
+ handle = (struct LoadDefinitionStructure *) frame->ExceptionErrorCode;
+ first_insn = *(char *) handle->LDInitializationProcedure;
+ *(unsigned char *) handle->LDInitializationProcedure = 0xcc;
+ return RETURN_TO_PROGRAM;
+ }
+
+ /* At the moment, we don't care about most of the unusual NetWare
+ exceptions. */
+ if (frame->ExceptionNumber != TERMINATE_NLM_EVENT
+ && frame->ExceptionNumber > 31)
+ return RETURN_TO_PROGRAM;
+
+ /* Reset the initial breakpoint if necessary. */
+ if (frame->ExceptionNumber == 3
+ && frame->ExceptionEIP == (LONG) handle->LDInitializationProcedure + 1
+ && *(unsigned char *) handle->LDInitializationProcedure == 0xcc)
+ {
+ *(char *) handle->LDInitializationProcedure = first_insn;
+ frame->ExceptionEIP = (LONG) handle->LDInitializationProcedure;
+ first = 1;
+ }
+
+ /* FIXME: How do we know that this exception has anything to do with
+ the program we are debugging? We can check whether the PC is in
+ the range of the module we are debugging, but that doesn't help
+ much since an error could occur in a library routine. */
+
+ frame_to_registers (frame, registers);
+
+ /* reply to host that an exception has occurred */
+ if (frame->ExceptionNumber == TERMINATE_NLM_EVENT)
+ {
+ /* There is no way to get the exit status. */
+ remcomOutBuffer[0] = 'W';
+ remcomOutBuffer[1] = hexchars[0];
+ remcomOutBuffer[2] = hexchars[0];
+ remcomOutBuffer[3] = 0;
+ }
+ else
+ {
+ sigval = computeSignal (frame->ExceptionNumber);
+ remcomOutBuffer[0] = 'S';
+ remcomOutBuffer[1] = hexchars[sigval >> 4];
+ remcomOutBuffer[2] = hexchars[sigval % 16];
+ remcomOutBuffer[3] = 0;
+ if (first)
+ {
+ remcomOutBuffer[0] = 'N';
+ sprintf (remcomOutBuffer + 3, "0x%x;0x%x;0x%x",
+ handle->LDCodeImageOffset,
+ handle->LDDataImageOffset,
+ handle->LDDataImageOffset + handle->LDDataImageLength);
+ }
+ }
+
+ if (! putpacket(remcomOutBuffer))
+ return RETURN_TO_NEXT_DEBUGGER;
+
+ if (frame->ExceptionNumber == TERMINATE_NLM_EVENT)
+ {
+ ResumeThread (mainthread);
+ return RETURN_TO_PROGRAM;
+ }
+
+ while (1)
+ {
+ error = 0;
+ remcomOutBuffer[0] = 0;
+ if (! getpacket (remcomInBuffer))
+ return RETURN_TO_NEXT_DEBUGGER;
+ talking = 1;
+ switch (remcomInBuffer[0])
+ {
+ case '?':
+ sigval = computeSignal (frame->ExceptionNumber);
+ remcomOutBuffer[0] = 'S';
+ remcomOutBuffer[1] = hexchars[sigval >> 4];
+ remcomOutBuffer[2] = hexchars[sigval % 16];
+ remcomOutBuffer[3] = 0;
+ if (first)
+ {
+ remcomOutBuffer[0] = 'N';
+ sprintf (remcomOutBuffer + 3, "0x%x;0x%x;0x%x",
+ handle->LDCodeImageOffset,
+ handle->LDDataImageOffset,
+ (handle->LDDataImageOffset
+ + handle->LDDataImageLength));
+ }
+ break;
+ case 'd':
+ remote_debug = !(remote_debug); /* toggle debug flag */
+ break;
+ case 'g':
+ /* return the value of the CPU registers */
+ mem2hex((char*) registers, remcomOutBuffer, NUMREGBYTES, 0);
+ break;
+ case 'G':
+ /* set the value of the CPU registers - return OK */
+ hex2mem(&remcomInBuffer[1], (char*) registers, NUMREGBYTES, 0);
+ strcpy(remcomOutBuffer,"OK");
+ break;
+
+ case 'm':
+ /* mAA..AA,LLLL Read LLLL bytes at address AA..AA */
+ /* TRY TO READ %x,%x. IF SUCCEED, SET PTR = 0 */
+ ptr = &remcomInBuffer[1];
+ if (hexToInt(&ptr,&addr))
+ if (*(ptr++) == ',')
+ if (hexToInt(&ptr,&length))
+ {
+ ptr = 0;
+ mem_err = 0;
+ mem2hex((char*) addr, remcomOutBuffer, length, 1);
+ if (mem_err)
+ {
+ strcpy (remcomOutBuffer, "E03");
+ debug_error ("memory fault");
+ }
+ }
+
+ if (ptr)
+ {
+ strcpy(remcomOutBuffer,"E01");
+ debug_error("malformed read memory command: %s",remcomInBuffer);
+ }
+ break;
+
+ case 'M':
+ /* MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK */
+ /* TRY TO READ '%x,%x:'. IF SUCCEED, SET PTR = 0 */
+ ptr = &remcomInBuffer[1];
+ if (hexToInt(&ptr,&addr))
+ if (*(ptr++) == ',')
+ if (hexToInt(&ptr,&length))
+ if (*(ptr++) == ':')
+ {
+ mem_err = 0;
+ hex2mem(ptr, (char*) addr, length, 1);
+
+ if (mem_err)
+ {
+ strcpy (remcomOutBuffer, "E03");
+ debug_error ("memory fault");
+ }
+ else
+ {
+ strcpy(remcomOutBuffer,"OK");
+ }
+
+ ptr = 0;
+ }
+ if (ptr)
+ {
+ strcpy(remcomOutBuffer,"E02");
+ debug_error("malformed write memory command: %s",remcomInBuffer);
+ }
+ break;
+
+ case 'c':
+ case 's':
+ /* cAA..AA Continue at address AA..AA(optional) */
+ /* sAA..AA Step one instruction from AA..AA(optional) */
+ /* try to read optional parameter, pc unchanged if no parm */
+ ptr = &remcomInBuffer[1];
+ if (hexToInt(&ptr,&addr))
+ registers[ PC ] = addr;
+
+ newPC = registers[ PC];
+
+ /* clear the trace bit */
+ registers[ PS ] &= 0xfffffeff;
+
+ /* set the trace bit if we're stepping */
+ if (remcomInBuffer[0] == 's') registers[ PS ] |= 0x100;
+
+ registers_to_frame (registers, frame);
+ return RETURN_TO_PROGRAM;
+
+ case 'k':
+ /* kill the program */
+ KillMe (handle);
+ ResumeThread (mainthread);
+ return RETURN_TO_PROGRAM;
+ }
+
+ /* reply to the request */
+ if (! putpacket(remcomOutBuffer))
+ return RETURN_TO_NEXT_DEBUGGER;
+ }
+}
+
+/* Start up. The main thread opens the named serial I/O port, loads
+ the named NLM module and then goes to sleep. The serial I/O port
+ is named as a board number and a port number. It would be more DOS
+ like to provide a menu of available serial ports, but I don't want
+ to have to figure out how to do that. */
+
+int
+main (argc, argv)
+ int argc;
+ char **argv;
+{
+ int hardware, board, port;
+ LONG err;
+ struct debuggerStructure s;
+ char *cmdlin;
+ int i;
+
+ /* Create a screen for the debugger. */
+ console_screen = CreateScreen ("System Console", 0);
+ if (DisplayScreen (console_screen) != ESUCCESS)
+ fprintf (stderr, "DisplayScreen failed\n");
+
+ if (argc < 4)
+ {
+ fprintf (stderr,
+ "Usage: load gdbserver board port program [arguments]\n");
+ exit (1);
+ }
+
+ hardware = -1;
+ board = strtol (argv[1], (char **) NULL, 0);
+ port = strtol (argv[2], (char **) NULL, 0);
+
+ err = AIOAcquirePort (&hardware, &board, &port, &AIOhandle);
+ if (err != AIO_SUCCESS)
+ {
+ switch (err)
+ {
+ case AIO_PORT_NOT_AVAILABLE:
+ fprintf (stderr, "Port not available\n");
+ break;
+
+ case AIO_BOARD_NUMBER_INVALID:
+ case AIO_PORT_NUMBER_INVALID:
+ fprintf (stderr, "No such port\n");
+ break;
+
+ default:
+ fprintf (stderr, "Could not open port: %d\n", err);
+ break;
+ }
+
+ exit (1);
+ }
+
+ err = AIOConfigurePort (AIOhandle, AIO_BAUD_9600, AIO_DATA_BITS_8,
+ AIO_STOP_BITS_1, AIO_PARITY_NONE,
+ AIO_HARDWARE_FLOW_CONTROL_OFF);
+ if (err != AIO_SUCCESS)
+ {
+ fprintf (stderr, "Could not configure port: %d\n", err);
+ AIOReleasePort (AIOhandle);
+ exit (1);
+ }
+
+ /* Register ourselves as an alternate debugger. */
+ memset (&s, 0, sizeof s);
+ s.DDSResourceTag = ((struct ResourceTagStructure *)
+ AllocateResourceTag (GetNLMHandle (),
+ "gdbserver",
+ DebuggerSignature));
+ if (s.DDSResourceTag == 0)
+ {
+ fprintf (stderr, "AllocateResourceTag failed\n");
+ AIOReleasePort (AIOhandle);
+ exit (1);
+ }
+ s.DDSdebuggerEntry = handle_exception;
+ s.DDSFlags = TSS_FRAME_BIT;
+
+ err = RegisterDebuggerRTag (&s, AT_FIRST);
+ if (err != 0)
+ {
+ fprintf (stderr, "RegisterDebuggerRTag failed\n");
+ AIOReleasePort (AIOhandle);
+ exit (1);
+ }
+
+ /* Get the command line we were invoked with, and advance it past
+ our name and the board and port arguments. */
+ cmdlin = getcmd ((char *) NULL);
+ for (i = 0; i < 2; i++)
+ {
+ while (! isspace (*cmdlin))
+ ++cmdlin;
+ while (isspace (*cmdlin))
+ ++cmdlin;
+ }
+
+ /* In case GDB is started before us, ack any packets (presumably
+ "$?#xx") sitting there. */
+ if (! putDebugChar ('+'))
+ {
+ fprintf (stderr, "putDebugChar failed\n");
+ UnRegisterDebugger (&s);
+ AIOReleasePort (AIOhandle);
+ exit (1);
+ }
+
+ mainthread = GetThreadID ();
+ handle = NULL;
+ talking = 0;
+
+ if (remote_debug > 0)
+ ConsolePrintf ("About to call LoadModule with \"%s\" %d %d\r\n",
+ cmdlin, console_screen, __GetScreenID (console_screen));
+
+ /* Start up the module to be debugged. */
+ err = LoadModule ((struct ScreenStruct *) __GetScreenID (console_screen),
+ cmdlin, LO_DEBUG);
+ if (err != 0)
+ {
+ fprintf (stderr, "LoadModule failed: %d\n", err);
+ UnRegisterDebugger (&s);
+ AIOReleasePort (AIOhandle);
+ exit (1);
+ }
+
+ /* By the time we reach this point in the code the debugger thread
+ should have received a START_NLM_EVENT and gone to sleep. */
+ if (remote_debug > 0)
+ ConsolePrintf ("Resuming %d, suspending %d\r\n", debugthread, mainthread);
+ ResumeThread (debugthread);
+ SuspendThread (mainthread);
+
+ /* If we are woken up, print an optional error message, deregister
+ ourselves and exit. */
+ if (error_message != NULL)
+ fprintf (stderr, "%s\n", error_message);
+ UnRegisterDebugger (&s);
+ AIOReleasePort (AIOhandle);
+ exit (0);
+}
projects / binutils-gdb.git / commitdiff