Subversion Repositories or1k

/i386.h

/configure

configure Property changes : Added: svn:executable ## -0,0 +1 ## +* \ No newline at end of property Index: prelude.c =================================================================== --- prelude.c (nonexistent) +++ prelude.c (revision 1765) @@ -0,0 +1,67 @@ +/*=========================================================================== += Novell Standard C Library for NetWare Loadable Modules += += Unpublished Copyright (C) 1993 by Novell, Inc. All rights reserved. += += No part of this file may be duplicated, revised, translated, localized or += modified in any manner or compiled, linked or uploaded or downloaded to or += from any computer system without the prior written consent of Novell, Inc. +============================================================================== += The object produced by compiling this file is for use by the client of this += library and is not linked in; Prelude.Obj is therefore one of the files to += be distributed with CLib.NLM and its headers. +============================================================================== +*/ + +#include +#if defined(__netware__) && defined(__i386__) +#define TERMINATE_BY_UNLOAD 5 +#else +#include +#endif +/*#include "libhooks.h"*/ + +extern int main (int, char **); + +static int NLMID; + + +void _Stop( void ) +{ + _TerminateNLM(NLMID, NULL, TERMINATE_BY_UNLOAD); +} + +int _cstart_( void ) +{ + return _SetupArgv(main); +} + +int _Prelude +( + int NLMHandle, + int initErrorScreenID, + char *commandLine, + char *loadDirectoryPath, + int uninitializedDataLength, + int NLMFileHandle, + int (*readRoutineP)(), + int customDataOffset, + int customDataSize +) +{ + int rc; + + rc = _StartNLM(NLMHandle, + initErrorScreenID, + commandLine, + loadDirectoryPath, + uninitializedDataLength, + NLMFileHandle, + readRoutineP, + customDataOffset, + customDataSize, + &NLMID, + _cstart_); + + return rc; +} Index: Makefile.in =================================================================== --- Makefile.in (nonexistent) +++ Makefile.in (revision 1765) @@ -0,0 +1,175 @@ +#Copyright 1989, 1990, 91, 92, 93, 94, 95, 1999 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. + +srcdir = @srcdir@ +VPATH = @srcdir@ + +prefix = @prefix@ +exec_prefix = @exec_prefix@ + +host_alias = @host_alias@ +target_alias = @target_alias@ +program_transform_name = @program_transform_name@ +bindir = @bindir@ +libdir = @libdir@ +tooldir = $(libdir)/$(target_alias) + +datadir = @datadir@ +mandir = @mandir@ +man1dir = $(mandir)/man1 +man2dir = $(mandir)/man2 +man3dir = $(mandir)/man3 +man4dir = $(mandir)/man4 +man5dir = $(mandir)/man5 +man6dir = $(mandir)/man6 +man7dir = $(mandir)/man7 +man8dir = $(mandir)/man8 +man9dir = $(mandir)/man9 +infodir = @infodir@ +htmldir = $(prefix)/html +includedir = @includedir@ + +SHELL = @SHELL@ + +INSTALL = @INSTALL@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_DATA = @INSTALL_DATA@ + +CC_FOR_TARGET = ` \ + if [ -f ../../gcc/xgcc ] ; then \ + echo ../../gcc/xgcc -B../../gcc/; \ + else \ + t='$(program_transform_name)'; echo gcc | sed -e '' $$t; \ + fi` + +NLMCONV_FOR_TARGET = ` \ + if [ -f ../../binutils/nlmconv ] ; then \ + echo ../../binutils/nlmconv; \ + else \ + t='$(program_transform_name)'; echo nlmconv | sed -e '' $$t; \ + fi` + +# All the includes used for CFLAGS and for lint. +INCLUDE_CFLAGS = -I. -I${srcdir} + +# CFLAGS is specifically reserved for setting from the command line +# when running make. I.E. "make CFLAGS=-Wmissing-prototypes". +CFLAGS = -g +# INTERNAL_CFLAGS is the aggregate of all other *CFLAGS macros. +INTERNAL_CFLAGS = ${CFLAGS} ${INCLUDE_CFLAGS} ${USER_CFLAGS} +LDFLAGS = $(CFLAGS) + +# Perhaps should come from parent Makefile +VERSION = gdbserve-4.12 +DIST=gdb + +# target-dependent makefile fragment come in here. +@target_makefile_frag@ +# End target-dependent makefile fragment + +# All source files that go into linking GDB remote server. + +DEPFILES = $(GDBSERVE_DEPFILES) + +SOURCES = $(ALLDEPFILES) +TAGFILES = $(SOURCES) ${HFILES} ${ALLPARAM} ${POSSLIBS} + +# Prevent Sun make from putting in the machine type. Setting +# TARGET_ARCH to nothing works for SunOS 3, 4.0, but not for 4.1. +.c.o: + ${CC_FOR_TARGET} -c ${INTERNAL_CFLAGS} $< + +.S.o: + ${CC_FOR_TARGET} -c ${INTERNAL_CFLAGS} $< + +all: gdbserve.nlm + +# Traditionally "install" depends on "all". But it may be useful +# not to; for example, if the user has made some trivial change to a +# source file and doesn't care about rebuilding or just wants to save the +# time it takes for make to check that all is up to date. +# install-only is intended to address that need. +install: all install-only +install-only: + $(INSTALL) gdbserve.nlm $(bindir)/gdbserve.nlm + +uninstall: force + rm -f $(bindir)/gdbserve.nlm + +installcheck: +check: +info dvi: +install-info: +clean-info: +html: +install-html: + +gdbserve.nlm: gdbserve.O $(srcdir)/gdbserve.def + ${NLMCONV_FOR_TARGET} -T $(srcdir)/gdbserve.def + +gdbserve.O: prelude.o gdbserve.o $(TDEPFILES) + ${CC_FOR_TARGET} $(LDFLAGS) -r -o gdbserve.O prelude.o gdbserve.o ${TDEPFILES} + +# Put the proper machine-specific files first, so M-. on a machine +# specific routine gets the one for the correct machine. +# The xyzzy stuff below deals with empty DEPFILES +TAGS: ${TAGFILES} + etags `find ${srcdir}/../config -name $(TM_FILE) -print` \ + `find ${srcdir}/../config -name ${XM_FILE} -print` \ + `find ${srcdir}/../config -name ${NAT_FILE} -print` \ + `for i in yzzy ${DEPFILES}; do \ + if [ x$$i != xyzzy ]; then \ + echo ${srcdir}/$$i | sed -e 's/\.o$$/\.c/' ; \ + fi; \ + done` \ + ${TAGFILES} +tags: TAGS + +clean: + rm -f *.o ${ADD_FILES} *~ + rm -f gdbserve.O gdbserve.nlm core make.log + +distclean: clean TAGS + rm -f config.log config.cache config.status + rm -f Makefile + +maintainer-clean realclean: clean + rm -f TAGS + rm -f config.log config.cache config.status + rm -f Makefile + +Makefile: Makefile.in config.status @target_makefile_frag_path@ + $(SHELL) config.status + +config.status: configure + $(SHELL) config.status --recheck + +force: + +# GNU Make has an annoying habit of putting *all* the Makefile variables +# into the environment, unless you include this target as a circumvention. +# Rumor is that this will be fixed (and this target can be removed) +# in GNU Make 4.0. +.NOEXPORT: + +# GNU Make 3.63 has a different problem: it keeps tacking command line +# overrides onto the definition of $(MAKE). This variable setting +# will remove them. +MAKEOVERRIDES= + +# This is the end of "Makefile.in". Index: gdbserve.c =================================================================== --- gdbserve.c (nonexistent) +++ gdbserve.c (revision 1765) @@ -0,0 +1,1056 @@ +/* gdbserve.c -- NLM debugging stub for Novell NetWare. + + 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 Novell NetWare. 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 + * + * $#. + * + * where + * :: + * :: < two hex digits computed as modulo 256 sum of > + * + * 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 +#include +#include +#include +#include +#include + +#ifdef __i386__ +#include +#include +#include +#include +#include +#else +#include +#include +#include +#include +#include +#include +#endif + +#include +#include "cpu.h" + + +/****************************************************/ +/* This information is from Novell. It is not in any of the standard + NetWare header files. */ + +struct DBG_LoadDefinitionStructure +{ + void *reserved1[4]; + LONG reserved5; + LONG LDCodeImageOffset; + LONG LDCodeImageLength; + LONG LDDataImageOffset; + LONG LDDataImageLength; + LONG LDUninitializedDataLength; + LONG LDCustomDataOffset; + LONG LDCustomDataSize; + LONG reserved6[2]; + LONG (*LDInitializationProcedure)(void); +}; + +#define LO_NORMAL 0x0000 +#define LO_STARTUP 0x0001 +#define LO_PROTECT 0x0002 +#define LO_DEBUG 0x0004 +#define LO_AUTO_LOAD 0x0008 + +/* 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 +/****************************************************/ + +/* The main thread ID. */ +static int mainthread; + +/* An error message for the main thread to print. */ +static char *error_message; + +/* The AIO port handle. */ +static int AIOhandle; + +/* BUFMAX defines the maximum number of characters in inbound/outbound + buffers. At least NUMREGBYTES*2 are needed for register packets */ +#define BUFMAX (REGISTER_BYTES * 2 + 16) + +/* remote_debug > 0 prints ill-formed commands in valid packets and + checksum errors. */ +static int remote_debug = 1; + +static const char hexchars[] = "0123456789abcdef"; + +unsigned char breakpoint_insn[] = BREAKPOINT; + +char *mem2hex (void *mem, char *buf, int count, int may_fault); +char *hex2mem (char *buf, void *mem, int count, int may_fault); +extern void set_step_traps (struct StackFrame *); +extern void clear_step_traps (struct StackFrame *); + +static int __main() {}; + +/* 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; + + put = 0; + while (put < 1) + { + err = AIOWriteData (AIOhandle, (char *) &c, 1, &put); + if (err != 0) + ConsolePrintf ("AIOWriteData: err = %d, put = %d\r\n", err, put); + } + return 1; +} + +/* 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 $#. 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 (checksum != xmitcsum) + { + if (remote_debug) + ConsolePrintf ("bad checksum. My count = 0x%x, sent=0x%x. buf=%s\n", + checksum,xmitcsum,buffer); + /* failed checksum */ + if (! putDebugChar('-')) + return 0; + return 1; + } + 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); + + if (remote_debug) + ConsolePrintf ("Received packet \"%s\"\r\n", buffer); + + 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; + + if (remote_debug) + ConsolePrintf ("Sending packet \"%s\"\r\n", buffer); + + /* $#. */ + 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) + { + ConsolePrintf (format, parm); + ConsolePrintf ("\n"); + } +} + +/* This is set if we could get a memory access fault. */ +static int mem_may_fault; + +/* Indicate to caller of mem2hex or hex2mem that there has been an + error. */ +volatile int mem_err = 0; + +#ifndef ALTERNATE_MEM_FUNCS +/* 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). */ + +int +get_char (addr) + char *addr; +{ + return *addr; +} + +void +set_char (addr, val) + char *addr; + int val; +{ + *addr = val; +} +#endif /* ALTERNATE_MEM_FUNCS */ + +/* 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. */ + +char * +mem2hex (mem, buf, count, may_fault) + void *mem; + char *buf; + int count; + int may_fault; +{ + int i; + unsigned char ch; + char *ptr = mem; + + mem_may_fault = may_fault; + for (i = 0; i < count; i++) + { + ch = get_char (ptr++); + if (may_fault && mem_err) + return (buf); + *buf++ = hexchars[ch >> 4]; + *buf++ = hexchars[ch % 16]; + } + *buf = 0; + mem_may_fault = 0; + 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 */ + +char * +hex2mem (buf, mem, count, may_fault) + char *buf; + void *mem; + int count; + int may_fault; +{ + int i; + unsigned char ch; + char *ptr = mem; + + mem_may_fault = may_fault; + for (i=0;i=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 (frame) + struct StackFrame *frame; +{ + int addr, length; + char *ptr; + static struct DBG_LoadDefinitionStructure *ldinfo = 0; + static unsigned char first_insn[BREAKPOINT_SIZE]; /* The first instruction in the program. */ + +#if 0 + /* According to some documentation from Novell, the bell sometimes + may be ringing at this point. This can be stopped on Netware 4 + systems by calling the undocumented StopBell() function. */ + + StopBell (); +#endif + + if (remote_debug) + { + ConsolePrintf ("vector=%d: %s, pc=%08x, thread=%08x\r\n", + frame->ExceptionNumber, + frame->ExceptionDescription, + frame->ExceptionPC, + GetThreadID ()); + } + + switch (frame->ExceptionNumber) + { + case START_NLM_EVENT: + /* 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. */ + + ldinfo = ((struct DBG_LoadDefinitionStructure *) + frame->ExceptionErrorCode); + memcpy (first_insn, ldinfo->LDInitializationProcedure, + BREAKPOINT_SIZE); + memcpy (ldinfo->LDInitializationProcedure, breakpoint_insn, + BREAKPOINT_SIZE); + flush_i_cache (); + return RETURN_TO_PROGRAM; + + case ENTER_DEBUGGER_EVENT: + case KEYBOARD_BREAK_EVENT: + /* Pass some events on to the next debugger, in case it will handle + them. */ + return RETURN_TO_NEXT_DEBUGGER; + + case 3: /* Breakpoint */ + /* After we've reached the initial breakpoint, reset it. */ + if (frame->ExceptionPC - DECR_PC_AFTER_BREAK == (LONG) ldinfo->LDInitializationProcedure + && memcmp (ldinfo->LDInitializationProcedure, breakpoint_insn, + BREAKPOINT_SIZE) == 0) + { + memcpy (ldinfo->LDInitializationProcedure, first_insn, + BREAKPOINT_SIZE); + frame->ExceptionPC -= DECR_PC_AFTER_BREAK; + flush_i_cache (); + } + /* Normal breakpoints end up here */ + do_status (remcomOutBuffer, frame); + break; + + default: + /* At the moment, we don't care about most of the unusual NetWare + exceptions. */ + if (frame->ExceptionNumber > 31) + return RETURN_TO_PROGRAM; + + /* Most machine level exceptions end up here */ + do_status (remcomOutBuffer, frame); + break; + + case 11: /* Segment not present */ + case 13: /* General protection */ + case 14: /* Page fault */ + /* If we get a GP fault, and mem_may_fault is set, and the + instruction pointer is near set_char or get_char, then we caused + the fault ourselves accessing an illegal memory location. */ + if (mem_may_fault + && ((frame->ExceptionPC >= (long) &set_char + && frame->ExceptionPC < (long) &set_char + 50) + || (frame->ExceptionPC >= (long) &get_char + && frame->ExceptionPC < (long) &get_char + 50))) + { + mem_err = 1; + /* Point the instruction pointer at an assembly language stub + which just returns from the function. */ + + frame->ExceptionPC += 4; /* Skip the load or store */ + + /* Keep going. This will act as though it returned from + set_char or get_char. The calling routine will check + mem_err, and do the right thing. */ + return RETURN_TO_PROGRAM; + } + /* Random mem fault, report it */ + do_status (remcomOutBuffer, frame); + break; + + case TERMINATE_NLM_EVENT: + /* There is no way to get the exit status. */ + sprintf (remcomOutBuffer, "W%02x", 0); + break; /* We generate our own status */ + } + + /* 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. */ + + clear_step_traps (frame); + + 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; + switch (remcomInBuffer[0]) + { + case '?': + do_status (remcomOutBuffer, frame); + break; + case 'd': + remote_debug = !(remote_debug); /* toggle debug flag */ + break; + case 'g': + /* return the value of the CPU registers */ + frame_to_registers (frame, remcomOutBuffer); + break; + case 'G': + /* set the value of the CPU registers - return OK */ + registers_to_frame (&remcomInBuffer[1], frame); + 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_REGNUM].lo = addr;*/ + fprintf (stderr, "Setting PC to 0x%x\n", addr); + while (1); + } + + if (remcomInBuffer[0] == 's') + set_step_traps (frame); + + flush_i_cache (); + return RETURN_TO_PROGRAM; + + case 'k': + /* kill the program */ + KillMe (ldinfo); + ResumeThread (mainthread); + return RETURN_TO_PROGRAM; + + case 'q': /* Query message */ + if (strcmp (&remcomInBuffer[1], "Offsets") == 0) + { + sprintf (remcomOutBuffer, "Text=%x;Data=%x;Bss=%x", + ldinfo->LDCodeImageOffset, + ldinfo->LDDataImageOffset, + ldinfo->LDDataImageOffset + ldinfo->LDDataImageLength); + } + else + sprintf (remcomOutBuffer, "E04, Unknown query %s", &remcomInBuffer[1]); + break; + } + + /* reply to the request */ + if (! putpacket(remcomOutBuffer)) + return RETURN_TO_NEXT_DEBUGGER; + } +} + +char *progname; + +struct bitRate { + BYTE bitRate; + const char *bitRateString; +}; + +struct bitRate bitRateTable[] = +{ + { AIO_BAUD_50 , "50" }, + { AIO_BAUD_75 , "75" }, + { AIO_BAUD_110 , "110" }, + { AIO_BAUD_134p5 , "134.5" }, + { AIO_BAUD_150 , "150" }, + { AIO_BAUD_300 , "300" }, + { AIO_BAUD_600 , "600" }, + { AIO_BAUD_1200 , "1200" }, + { AIO_BAUD_1800 , "1800" }, + { AIO_BAUD_2000 , "2000" }, + { AIO_BAUD_2400 , "2400" }, + { AIO_BAUD_3600 , "3600" }, + { AIO_BAUD_4800 , "4800" }, + { AIO_BAUD_7200 , "7200" }, + { AIO_BAUD_9600 , "9600" }, + { AIO_BAUD_19200 , "19200" }, + { AIO_BAUD_38400 , "38400" }, + { AIO_BAUD_57600 , "57600" }, + { AIO_BAUD_115200, "115200" }, + { -1, NULL } +}; + +char dataBitsTable[] = "5678"; + +char *stopBitsTable[] = { "1", "1.5", "2" }; + +char parity[] = "NOEMS"; + +/* 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; + BYTE bitRate; + BYTE dataBits; + BYTE stopBits; + BYTE parityMode; + LONG err; + struct debuggerStructure s; + int cmdindx; + char *cmdlin; + int i; + + /* set progname */ + progname = "gdbserve"; + + /* set default serial line */ + hardware = -1; + board = 0; + port = 0; + + /* set default serial line characteristics */ + bitRate = AIO_BAUD_9600; + dataBits = AIO_DATA_BITS_8; + stopBits = AIO_STOP_BITS_1; + parityMode = AIO_PARITY_NONE; + + cmdindx = 0; + for (argc--, argv++; *argv; argc--, argv++) + { + char *bp; + char *ep; + + if (strnicmp(*argv, "BAUD=", 5) == 0) + { + struct bitRate *brp; + + bp = *argv + 5; + for (brp = bitRateTable; brp->bitRate != (BYTE) -1; brp++) + { + if (strcmp(brp->bitRateString, bp) == 0) + { + bitRate = brp->bitRate; + break; + } + } + + if (brp->bitRateString == NULL) + { + fprintf(stderr, "%s: %s: unknown or unsupported bit rate", + progname, bp); + exit (1); + } + } + else if (strnicmp(*argv, "BOARD=", 6) == 0) + { + bp = *argv + 6; + board = strtol (bp, &ep, 0); + if (ep == bp || *ep != '\0') + { + fprintf (stderr, "%s: %s: expected integer argument\n", + progname, bp); + exit(1); + } + } +#if 1 /* FIXME: this option has been depricated */ + else if (strnicmp(*argv, "NODE=", 5) == 0) + { + bp = *argv + 5; + board = strtol (bp, &ep, 0); + if (ep == bp || *ep != '\0') + { + fprintf (stderr, "%s: %s: expected integer argument\n", + progname, bp); + exit(1); + } + } +#endif + else if (strnicmp(*argv, "PORT=", 5) == 0) + { + bp = *argv + 5; + port = strtol (bp, &ep, 0); + if (ep == bp || *ep != '\0') + { + fprintf (stderr, "%s: %s: expected integer argument\n", + progname, bp); + exit(1); + } + } + else + { + break; + } + + cmdindx++; + } + + if (argc == 0) + { + fprintf (stderr, + "Usage: load %s [options] program [arguments]\n", progname); + exit (1); + } + + 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, bitRate, dataBits, stopBits, parityMode, + AIO_HARDWARE_FLOW_CONTROL_OFF); + + if (err == AIO_QUALIFIED_SUCCESS) + { + AIOPORTCONFIG portConfig; + + fprintf (stderr, "Port configuration changed!\n"); + + portConfig.returnLength = sizeof(portConfig); + AIOGetPortConfiguration (AIOhandle, &portConfig, NULL); + + fprintf (stderr, + " Bit Rate: %s, Data Bits: %c, Stop Bits: %s, Parity: %c,\ + Flow:%s\n", + bitRateTable[portConfig.bitRate].bitRateString, + dataBitsTable[portConfig.dataBits], + stopBitsTable[portConfig.stopBits], + parity[portConfig.parityMode], + portConfig.flowCtrlMode ? "ON" : "OFF"); + } + else if (err != AIO_SUCCESS) + { + fprintf (stderr, "Could not configure port: %d\n", err); + AIOReleasePort (AIOhandle); + exit (1); + } + + if (AIOSetExternalControl(AIOhandle, AIO_EXTERNAL_CONTROL, + (AIO_EXTCTRL_DTR | AIO_EXTCTRL_RTS)) + != AIO_SUCCESS) + { + LONG extStatus, chgdExtStatus; + + fprintf (stderr, "Could not set desired port controls!\n"); + AIOGetExternalStatus (AIOhandle, &extStatus, &chgdExtStatus); + fprintf (stderr, "Port controls now: %d, %d\n", extStatus, + chgdExtStatus); + } + + /* Register ourselves as an alternate debugger. */ + memset (&s, 0, sizeof s); + s.DDSResourceTag = ((struct ResourceTagStructure *) + AllocateResourceTag (GetNLMHandle (), + (BYTE *)"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 < cmdindx; 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 (); + + if (remote_debug > 0) + ConsolePrintf ("About to call LoadModule with \"%s\" %08x\r\n", + cmdlin, __GetScreenID (GetCurrentScreen())); + + /* Start up the module to be debugged. */ + err = LoadModule ((struct ScreenStruct *) __GetScreenID (GetCurrentScreen()), + (BYTE *)cmdlin, LO_DEBUG); + if (err != 0) + { + fprintf (stderr, "LoadModule failed: %d\n", err); + UnRegisterDebugger (&s); + AIOReleasePort (AIOhandle); + exit (1); + } + + /* Wait for the debugger to wake us up. */ + if (remote_debug > 0) + ConsolePrintf ("Suspending main thread (%08x)\r\n", mainthread); + SuspendThread (mainthread); + if (remote_debug > 0) + ConsolePrintf ("Resuming main thread (%08x)\r\n", 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); +} Index: ppc.c =================================================================== --- ppc.c (nonexistent) +++ ppc.c (revision 1765) @@ -0,0 +1,257 @@ +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include "ppc.h" + +extern char *mem2hex (void *mem, char *buf, int count, int may_fault); +extern char *hex2mem (char *buf, void *mem, int count, int may_fault); +extern int computeSignal (int exceptionVector); + +void +flush_i_cache (void) +{ +} + +/* Get the registers out of the frame information. */ + +void +frame_to_registers (frame, regs) + struct StackFrame *frame; + char *regs; +{ + mem2hex (&frame->ExceptionState.CsavedRegs, ®s[GP0_REGNUM * 4 * 2], 4 * 32, 0); + + mem2hex (&frame->ExceptionState.CSavedFPRegs, ®s[FP0_REGNUM * 4 * 2], 4 * 32, 0); + + mem2hex (&frame->ExceptionPC, ®s[PC_REGNUM * 4 * 2], 4 * 1, 0); + + mem2hex (&frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedSRR1, ®s[CR_REGNUM * 4 * 2], 4 * 1, 0); + mem2hex (&frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedLR, ®s[LR_REGNUM * 4 * 2], 4 * 1, 0); + mem2hex (&frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedCTR, ®s[CTR_REGNUM * 4 * 2], 4 * 1, 0); + mem2hex (&frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedXER, ®s[XER_REGNUM * 4 * 2], 4 * 1, 0); + mem2hex (&frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedMQ, ®s[MQ_REGNUM * 4 * 2], 4 * 1, 0); +} + +/* Put the registers back into the frame information. */ + +void +registers_to_frame (regs, frame) + char *regs; + struct StackFrame *frame; +{ + hex2mem (®s[GP0_REGNUM * 4 * 2], &frame->ExceptionState.CsavedRegs, 4 * 32, 0); + + hex2mem (®s[FP0_REGNUM * 4 * 2], &frame->ExceptionState.CSavedFPRegs, 4 * 32, 0); + + hex2mem (®s[PC_REGNUM * 4 * 2], &frame->ExceptionPC, 4 * 1, 0); + + hex2mem (®s[CR_REGNUM * 4 * 2], &frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedSRR1, 4 * 1, 0); + hex2mem (®s[LR_REGNUM * 4 * 2], &frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedLR, 4 * 1, 0); + hex2mem (®s[CTR_REGNUM * 4 * 2], &frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedCTR, 4 * 1, 0); + hex2mem (®s[XER_REGNUM * 4 * 2], &frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedXER, 4 * 1, 0); + hex2mem (®s[MQ_REGNUM * 4 * 2], &frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedMQ, 4 * 1, 0); +} + + +extern volatile int mem_err; + +#ifdef ALTERNATE_MEM_FUNCS +extern int ReadByteAltDebugger (char* addr, char *theByte); +extern int WriteByteAltDebugger (char* addr, char theByte); +int +get_char (addr) + char *addr; +{ + char c; + + if (!ReadByteAltDebugger (addr, &c)) + mem_err = 1; + + return c; +} + +void +set_char (addr, val) + char *addr; + int val; +{ + if (!WriteByteAltDebugger (addr, val)) + mem_err = 1; +} +#endif + +int +mem_write (dst, src, len) + char *dst, *src; + int len; +{ + while (len-- && !mem_err) + set_char (dst++, *src++); + + return mem_err; +} + +union inst +{ + LONG l; + + struct + { + union + { + struct /* Unconditional branch */ + { + unsigned opcode : 6; /* 18 */ + signed li : 24; + unsigned aa : 1; + unsigned lk : 1; + } b; + struct /* Conditional branch */ + { + unsigned opcode : 6; /* 16 */ + unsigned bo : 5; + unsigned bi : 5; + signed bd : 14; + unsigned aa : 1; + unsigned lk : 1; + } bc; + struct /* Conditional branch to ctr or lr reg */ + { + unsigned opcode : 6; /* 19 */ + unsigned bo : 5; + unsigned bi : 5; + unsigned type : 15; /* 528 = ctr, 16 = lr */ + unsigned lk : 1; + } bclr; + } variant; + } inst; +}; + +static LONG saved_inst; +static LONG *saved_inst_pc = 0; +static LONG saved_target_inst; +static LONG *saved_target_inst_pc = 0; + +void +set_step_traps (frame) + struct StackFrame *frame; +{ + union inst inst; + LONG *target; + int opcode; + int ra, rb; + LONG *pc = (LONG *)frame->ExceptionPC; + + inst.l = *pc++; + + opcode = inst.inst.variant.b.opcode; + + target = pc; + + switch (opcode) + { + case 18: /* Unconditional branch */ + + if (inst.inst.variant.b.aa) /* Absolute? */ + target = 0; + target += inst.inst.variant.b.li; + + break; + case 16: /* Conditional branch */ + + if (!inst.inst.variant.bc.aa) /* Absolute? */ + target = 0; + target += inst.inst.variant.bc.bd; + + break; + case 19: /* Cond. branch via ctr or lr reg */ + switch (inst.inst.variant.bclr.type) + { + case 528: /* ctr */ + target = (LONG *)frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedCTR; + break; + case 16: /* lr */ + target = (LONG *)frame->ExceptionState.u.SpecialRegistersEnumerated.CsavedLR; + break; + } + break; + } + + saved_inst = *pc; + mem_write (pc, breakpoint_insn, BREAKPOINT_SIZE); + saved_inst_pc = pc; + + if (target != pc) + { + saved_target_inst = *target; + mem_write (target, breakpoint_insn, BREAKPOINT_SIZE); + saved_target_inst_pc = target; + } +} + +/* Remove step breakpoints. Returns non-zero if pc was at a step breakpoint, + zero otherwise. This routine works even if there were no step breakpoints + set. */ + +int +clear_step_traps (frame) + struct StackFrame *frame; +{ + int retcode; + LONG *pc = (LONG *)frame->ExceptionPC; + + if (saved_inst_pc == pc || saved_target_inst_pc == pc) + retcode = 1; + else + retcode = 0; + + if (saved_inst_pc) + { + mem_write (saved_inst_pc, saved_inst, BREAKPOINT_SIZE); + saved_inst_pc = 0; + } + + if (saved_target_inst_pc) + { + mem_write (saved_target_inst_pc, saved_target_inst, BREAKPOINT_SIZE); + saved_target_inst_pc = 0; + } + + return retcode; +} + +void +do_status (ptr, frame) + char *ptr; + struct StackFrame *frame; +{ + int sigval; + + sigval = computeSignal (frame->ExceptionNumber); + + sprintf (ptr, "T%02x", sigval); + ptr += 3; + + sprintf (ptr, "%02x:", PC_REGNUM); + ptr = mem2hex (&frame->ExceptionPC, ptr + 3, 4, 0); + *ptr++ = ';'; + + sprintf (ptr, "%02x:", SP_REGNUM); + ptr = mem2hex (&frame->ExceptionState.CsavedRegs[SP_REGNUM], ptr + 3, 4, 0); + *ptr++ = ';'; + + sprintf (ptr, "%02x:", LR_REGNUM); + ptr = mem2hex (&frame->ExceptionState.CsavedRegs[LR_REGNUM], ptr + 3, 4, 0); + *ptr++ = ';'; + + *ptr = '\000'; +} Index: configure.in =================================================================== --- configure.in (nonexistent) +++ configure.in (revision 1765) @@ -0,0 +1,55 @@ +dnl Process this file with autoconf to produce a configure script. +AC_PREREQ(2.12.1)dnl +AC_INIT(gdbserve.c) + +AC_CONFIG_AUX_DIR(`cd $srcdir;pwd`/../..) +AC_CANONICAL_SYSTEM +AC_ARG_PROGRAM + +AC_PROG_INSTALL + +# Map target cpu into the config cpu subdirectory name. +# The default is $target_cpu. +changequote(,)dnl +case "${target_cpu}" in +alpha) gdb_target_cpu=alpha ;; +c[12]) gdb_target_cpu=convex ;; +hppa*) gdb_target_cpu=pa ;; +i[3456]86) gdb_target_cpu=i386 ;; +m68*) gdb_target_cpu=m68k ;; +np1) gdb_target_cpu=gould ;; +pn) gdb_target_cpu=gould ;; +pyramid) gdb_target_cpu=pyr ;; +sparc*) gdb_target_cpu=sparc ;; +*) gdb_target_cpu=$target_cpu ;; +esac +changequote([,])dnl + +target_makefile_frag=${srcdir}/../config/${gdb_target_cpu}/gdbserve.mt +if [ ! -f ${target_makefile_frag} ]; then + AC_MSG_ERROR("*** GDBSERVE does not support target ${target}") +fi + +dnl We have to assign the same value to other variables because autoconf +dnl doesn't provide a mechanism to substitute a replacement keyword with +dnl arbitrary data or pathnames. +dnl +target_makefile_frag_path=$target_makefile_frag +AC_SUBST(target_makefile_frag_path) +AC_SUBST_FILE(target_makefile_frag) + +cpufile=`sed -n ' +s/CPU_FILE[ ]*=[ ]*\([^ ]*\)/\1/p +' ${target_makefile_frag} + +files= +links= +rm -f cpu.h +if [ "${cpufile}" != "" ]; then + files="${files} ${cpufile}.h" + links="${links} cpu.h" +fi + +AC_LINK_FILES($files, $links) +AC_OUTPUT(Makefile) + Index: ppc.h =================================================================== --- ppc.h (nonexistent) +++ ppc.h (revision 1765) @@ -0,0 +1,165 @@ +typedef long Long; + +/* The following enum is used to access the special registers in + the saved machine state. */ + +typedef enum +{ + kDc_SavedPC = 0, /* really SRR0 */ + kDc_SavedMSR = 1, /* really SRR1 */ + kDc_SavedCR = 2, + kDc_SavedLR = 3, + kDc_SavedDSISR = 4, + kDc_SavedDAR = 5, + kDc_SavedXER = 6, + kDc_SavedCTR = 7, + kDc_SavedSDR1 = 8, + kDc_SavedRTCU = 9, + kDc_SavedRTCL = 10, + kDc_SavedDEC = 11, + kDc_SavedSR00 = 12, /* The Segement Registers are consecutive */ + kDc_SavedSR01 = 13, /* kDc_SavedSR00 + n is supported */ + kDc_SavedSR02 = 14, + kDc_SavedSR03 = 15, + kDc_SavedSR04 = 16, + kDc_SavedSR05 = 17, + kDc_SavedSR06 = 18, + kDc_SavedSR07 = 19, + kDc_SavedSR08 = 20, + kDc_SavedSR09 = 21, + kDc_SavedSR10 = 22, + kDc_SavedSR11 = 23, + kDc_SavedSR12 = 24, + kDc_SavedSR13 = 25, + kDc_SavedSR14 = 26, + kDc_SavedSR15 = 27, + kDc_SavedFPSCR = 29, + kDc_SavedMQ = 30, + kDc_SavedBAT0U = 31, + kDc_SavedBAT0L = 32, + kDc_SavedBAT1U = 33, + kDc_SavedBAT1L = 34, + kDc_SavedBAT2U = 35, + kDc_SavedBAT2L = 36, + kDc_SavedBAT3U = 37, + kDc_SavedBAT3L = 38, + + kNumberSpecialRegisters = 39 +} Dc_SavedRegisterName; + +/* Access to floating points is not very easy. This allows the number to be + accessed both as a floating number and as a pair of Longs. */ + +typedef union +{ + double asfloat; /* access the variable as a floating number */ + struct + { + Long high; + Long low; + } + asLONG; /* access the variable as two Longs */ +} FloatingPoints; + +/* The following is the standard record for Saving a machine state */ + +struct SavedMachineState +{ + FloatingPoints CSavedFPRegs[32]; /* The floating point registers [0->31] */ + /* ***32bit assumption*** */ + Long CsavedRegs[32]; /* space to save the General Registers */ + /* These are saved 0->31 */ + Long CexReason; + Long SavedDomainID; + union + { /* must be 8-byte aligned, so doubleFPSCR is 8-byte aligned */ + struct + { + Long CsavedSRR0; /* Index 0 - The saved PC */ + Long CsavedSRR1; /* 1 saved MSR */ + Long CsavedCR; /* 2 */ + Long CsavedLR; /* 3 */ + Long CsavedDSISR; /* 4 */ + Long CsavedDAR; /* 5 */ + + Long CsavedXER; /* 6 */ + Long CsavedCTR; /* 7 */ + Long CsavedSDR1; /* 8 */ + Long CsavedRTCU; /* 9 */ + Long CsavedRTCL; /* 10 */ + Long CsavedDEC; /* 11 */ + Long CsavedSR0; /* 12 */ + Long CsavedSR1; /* 13 */ + Long CsavedSR2; /* 14 */ + Long CsavedSR3; /* 15 */ + Long CsavedSR4; /* 16 */ + Long CsavedSR5; /* 17 */ + Long CsavedSR6; /* 18 */ + Long CsavedSR7; /* 19 */ + Long CsavedSR8; /* 20 */ + Long CsavedSR9; /* 21 */ + Long CsavedSR10; /* 22 */ + Long CsavedSR11; /* 23 */ + Long CsavedSR12; /* 24 */ + Long CsavedSR13; /* 25 */ + Long CsavedSR14; /* 26 */ + Long CsavedSR15; /* 27 */ + /* CdoubleFPSCR must be double word aligned */ + Long CdoubleFPSCR; /* 28 this is the upper part of the store and has + no meaning */ + Long CsavedFPSCR; /* 29 */ + Long CsavedMQ; /* 30 */ + Long CsavedBAT0U; /* 31 */ + Long CsavedBAT0L; /* 32 */ + Long CsavedBAT1U; /* 33 */ + Long CsavedBAT1L; /* 34 */ + Long CsavedBAT2U; /* 35 */ + Long CsavedBAT2L; /* 36 */ + Long CsavedBAT3U; /* 37 */ + Long CsavedBAT3L; /* 38 */ + } + SpecialRegistersEnumerated; + + Long SpecialRegistersIndexed[kNumberSpecialRegisters]; + } u; + + Long Padding[3]; /* Needed for quad-word alignment */ +}; + +struct StackFrame +{ + LONG *ExceptionDomainID; + /*ProcessorStructure*/ int *ExceptionProcessorID; + BYTE *ExceptionDescription; + LONG ExceptionFlags; + LONG ExceptionErrorCode; + LONG ExceptionNumber; + struct SavedMachineState ExceptionState; +}; + +/* Register values. All of these values *MUST* agree with tm.h */ +#define GP0_REGNUM 0 /* GPR register 0 */ +#define SP_REGNUM 1 /* Contains address of top of stack */ +#define FP0_REGNUM 32 /* FPR (Floating point) register 0 */ +#define PC_REGNUM 64 /* Contains program counter */ +#define PS_REGNUM 65 /* Processor (or machine) status (%msr) */ +#define CR_REGNUM 66 /* Condition register */ +#define LR_REGNUM 67 /* Link register */ +#define CTR_REGNUM 68 /* Count register */ +#define XER_REGNUM 69 /* Fixed point exception registers */ +#define MQ_REGNUM 70 /* Multiply/quotient register */ +#define NUM_REGS 71 /* Number of machine registers */ +#define REGISTER_BYTES (420) /* Total size of registers array */ + +#define ExceptionPC ExceptionState.u.SpecialRegistersEnumerated.CsavedSRR0 +#define DECR_PC_AFTER_BREAK 0 /* PPCs get this right! */ +#define BREAKPOINT {0x7d, 0x82, 0x10, 0x08} +extern unsigned char breakpoint_insn[]; +#define BREAKPOINT_SIZE 4 + +#if 0 +#define ALTERNATE_MEM_FUNCS /* We need our own get_char/set_char */ +#endif + +extern int get_char (char *addr); +extern void set_char (char *addr, int val); Index: i386.c =================================================================== --- i386.c (nonexistent) +++ i386.c (revision 1765) @@ -0,0 +1,108 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "i386.h" + +extern char *mem2hex (void *mem, char *buf, int count, int may_fault); +extern char *hex2mem (char *buf, void *mem, int count, int may_fault); +extern int computeSignal (int exceptionVector); + +void +flush_i_cache() +{ +} + +/* Get the registers out of the frame information. */ + +void +frame_to_registers (frame, regs) + struct StackFrame *frame; + char *regs; +{ + /* Copy EAX -> EDI */ + mem2hex (&frame->ExceptionEAX, ®s[0 * 4 * 2], 4 * 8, 0); + + /* Copy EIP & PS */ + mem2hex (&frame->ExceptionPC, ®s[8 * 4 * 2], 4 * 2, 0); + + /* Copy CS, SS, DS */ + mem2hex (&frame->ExceptionCS, ®s[10 * 4 * 2], 4 * 3, 0); + + /* Copy ES */ + mem2hex (&frame->ExceptionES, ®s[13 * 4 * 2], 4 * 1, 0); + + /* Copy FS & GS */ + mem2hex (&frame->ExceptionFS, ®s[14 * 4 * 2], 4 * 2, 0); +} + +/* Put the registers back into the frame information. */ + +void +registers_to_frame (regs, frame) + char *regs; + struct StackFrame *frame; +{ + /* Copy EAX -> EDI */ + hex2mem (®s[0 * 4 * 2], &frame->ExceptionEAX, 4 * 8, 0); + + /* Copy EIP & PS */ + hex2mem (®s[8 * 4 * 2], &frame->ExceptionPC, 4 * 2, 0); + + /* Copy CS, SS, DS */ + hex2mem (®s[10 * 4 * 2], &frame->ExceptionCS, 4 * 3, 0); + + /* Copy ES */ + hex2mem (®s[13 * 4 * 2], &frame->ExceptionES, 4 * 1, 0); + + /* Copy FS & GS */ + hex2mem (®s[14 * 4 * 2], &frame->ExceptionFS, 4 * 2, 0); +} + +void +set_step_traps (frame) + struct StackFrame *frame; +{ + frame->ExceptionSystemFlags |= 0x100; +} + +void +clear_step_traps (frame) + struct StackFrame *frame; +{ + frame->ExceptionSystemFlags &= ~0x100; +} + +void +do_status (ptr, frame) + char *ptr; + struct StackFrame *frame; +{ + int sigval; + + sigval = computeSignal (frame->ExceptionNumber); + + sprintf (ptr, "T%02x", sigval); + ptr += 3; + + sprintf (ptr, "%02x:", PC_REGNUM); + ptr = mem2hex (&frame->ExceptionPC, ptr + 3, 4, 0); + *ptr++ = ';'; + + sprintf (ptr, "%02x:", SP_REGNUM); + ptr = mem2hex (&frame->ExceptionESP, ptr + 3, 4, 0); + *ptr++ = ';'; + + sprintf (ptr, "%02x:", FP_REGNUM); + ptr = mem2hex (&frame->ExceptionEBP, ptr + 3, 4, 0); + *ptr++ = ';'; + + *ptr = '\000'; +} Index: gdbserve.def =================================================================== --- gdbserve.def (nonexistent) +++ gdbserve.def (revision 1765) @@ -0,0 +1,42 @@ +description "GDB debugger stub" +version 1,2 +debug +module clib +screenname "System Console" +input gdbserve.O +output gdbserve.nlm +start _Prelude +exit _Stop +import + AllocateResourceTag + ConsolePrintf + GetCurrentScreen + GetNLMHandle + GetThreadID + KillMe + LoadModule + ReadByteAltDebugger + RegisterDebuggerRTag + ResumeThread + SuspendThread + UnRegisterDebugger + WriteByteAltDebugger + _GetCLibNLMLibHandle + _NWRegisterNLMLibraryUser + _SetupArgv + _StartNLM + _TerminateNLM + __GetScreenID + __get_errno_ptr + exit + fprintf + getcmd + memcmp + memcpy + memset + sprintf + strcmp + strcpy + strlen + strnicmp + strtol