diff options
| -rw-r--r-- | gdb/.Sanitize | 3 | ||||
| -rw-r--r-- | gdb/i386-nlmstub.c | 1057 |
2 files changed, 1060 insertions, 0 deletions
diff --git a/gdb/.Sanitize b/gdb/.Sanitize index ba68f53..0242d95 100644 --- a/gdb/.Sanitize +++ b/gdb/.Sanitize @@ -267,6 +267,8 @@ z8k-tdep.c # energize-patches - Part of Lucid support. # energize.c - Part of Lucid support. # energize.h - Part of Lucid support. +# i386-nlmstub.c - i386 NLM stub, not yet distributable because +# it contains Novell proprietary code. # infrun.hacked.c - An old version of infrun.c that had some # wait_for_inferior improvements by gnu, # which were never fully debugged. @@ -287,6 +289,7 @@ energize energize-patches energize.c energize.h +i386-nlmstub.c infrun.hacked.c remote-sa.sparc.c state.c diff --git a/gdb/i386-nlmstub.c b/gdb/i386-nlmstub.c new file mode 100644 index 0000000..5604ed6 --- /dev/null +++ b/gdb/i386-nlmstub.c @@ -0,0 +1,1057 @@ +/* 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); +} |