diff options
Diffstat (limited to 'gdb/remote-udi.c')
| -rw-r--r-- | gdb/remote-udi.c | 1694 |
1 files changed, 1694 insertions, 0 deletions
diff --git a/gdb/remote-udi.c b/gdb/remote-udi.c new file mode 100644 index 00000000000..6397bca5d16 --- /dev/null +++ b/gdb/remote-udi.c @@ -0,0 +1,1694 @@ +/* Remote debugging interface for AMD 29k interfaced via UDI, for GDB. + Copyright 1990, 1992, 1995 Free Software Foundation, Inc. + Written by Daniel Mann. Contributed by AMD. + +This file is part of GDB. + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 2 of the License, or +(at your option) any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + +/* This is like remote.c but uses the Universal Debug Interface (UDI) to + talk to the target hardware (or simulator). UDI is a TCP/IP based + protocol; for hardware that doesn't run TCP, an interface adapter + daemon talks UDI on one side, and talks to the hardware (typically + over a serial port) on the other side. + + - Originally written by Daniel Mann at AMD for MiniMON and gdb 3.91.6. + - David Wood (wood@lab.ultra.nyu.edu) at New York University adapted this + file to gdb 3.95. I was unable to get this working on sun3os4 + with termio, only with sgtty. + - Daniel Mann at AMD took the 3.95 adaptions above and replaced + MiniMON interface with UDI-p interface. */ + +#include "defs.h" +#include "frame.h" +#include "inferior.h" +#include "wait.h" +#include "value.h" +#include <ctype.h> +#include <fcntl.h> +#include <signal.h> +#include <errno.h> +#include "gdb_string.h" +#include "terminal.h" +#include "target.h" +#include "29k-share/udi/udiproc.h" +#include "gdbcmd.h" +#include "bfd.h" +#include "gdbcore.h" /* For download function */ + +/* access the register store directly, without going through + the normal handler functions. This avoids an extra data copy. */ + +extern int stop_soon_quietly; /* for wait_for_inferior */ +extern struct value *call_function_by_hand(); +static void udi_resume PARAMS ((int pid, int step, enum target_signal sig)); +static void udi_fetch_registers PARAMS ((int regno)); +static void udi_load PARAMS ((char *args, int from_tty)); +static void fetch_register PARAMS ((int regno)); +static void udi_store_registers PARAMS ((int regno)); +static int store_register PARAMS ((int regno)); +static int regnum_to_srnum PARAMS ((int regno)); +static void udi_close PARAMS ((int quitting)); +static CPUSpace udi_memory_space PARAMS ((CORE_ADDR addr)); +static int udi_write_inferior_memory PARAMS ((CORE_ADDR memaddr, char *myaddr, + int len)); +static int udi_read_inferior_memory PARAMS ((CORE_ADDR memaddr, char *myaddr, + int len)); +static void download PARAMS ((char *load_arg_string, int from_tty)); +char CoffFileName[100] = ""; + +#define FREEZE_MODE (read_register(CPS_REGNUM) & 0x400) +#define USE_SHADOW_PC ((processor_type == a29k_freeze_mode) && FREEZE_MODE) + +static int timeout = 5; +extern struct target_ops udi_ops; /* Forward declaration */ + +/* Special register enumeration. +*/ + +/******************************************************************* UDI DATA*/ +#define MAXDATA 2*1024 /* max UDI[read/write] byte size */ +/* Descriptor for I/O to remote machine. Initialize it to -1 so that + udi_open knows that we don't have a file open when the program + starts. */ + +UDISessionId udi_session_id = -1; +static char *udi_config_id; + +CPUOffset IMemStart = 0; +CPUSizeT IMemSize = 0; +CPUOffset DMemStart = 0; +CPUSizeT DMemSize = 0; +CPUOffset RMemStart = 0; +CPUSizeT RMemSize = 0; +UDIUInt32 CPUPRL; +UDIUInt32 CoProcPRL; + +UDIMemoryRange address_ranges[2]; /* Text and data */ +UDIResource entry = {0, 0}; /* Entry point */ +CPUSizeT stack_sizes[2]; /* Regular and memory stacks */ + +#define SBUF_MAX 1024 /* maximum size of string handling buffer */ +char sbuf[SBUF_MAX]; + +typedef struct bkpt_entry_str +{ + UDIResource Addr; + UDIUInt32 PassCount; + UDIBreakType Type; + unsigned int BreakId; +} bkpt_entry_t; +#define BKPT_TABLE_SIZE 40 +static bkpt_entry_t bkpt_table[BKPT_TABLE_SIZE]; +extern char dfe_errmsg[]; /* error string */ + +/* malloc'd name of the program on the remote system. */ +static char *prog_name = NULL; + +/* This is called not only when we first attach, but also when the + user types "run" after having attached. */ + +static void +udi_create_inferior (execfile, args, env) + char *execfile; + char *args; + char **env; +{ + char *args1; + + if (execfile) + { + if (prog_name != NULL) + free (prog_name); + prog_name = savestring (execfile, strlen (execfile)); + } + else if (entry.Offset) + execfile = ""; + else + error ("No image loaded into target."); + + if (udi_session_id < 0) + { + /* If the TIP is not open, open it. */ + if (UDIConnect (udi_config_id, &udi_session_id)) + error("UDIConnect() failed: %s\n", dfe_errmsg); + /* We will need to download the program. */ + entry.Offset = 0; + } + + inferior_pid = 40000; + + if (!entry.Offset) + download(execfile, 0); + + args1 = alloca (strlen(execfile) + strlen(args) + 2); + + if (execfile[0] == '\0') + + /* It is empty. We need to quote it somehow, or else the target + will think there is no argument being passed here. According + to the UDI spec it is quoted "according to TIP OS rules" which + I guess means quoting it like the Unix shell should work + (sounds pretty bogus to me...). In fact it doesn't work (with + isstip anyway), but passing in two quotes as the argument seems + like a reasonable enough behavior anyway (I guess). */ + + strcpy (args1, "''"); + else + strcpy (args1, execfile); + strcat (args1, " "); + strcat (args1, args); + + UDIInitializeProcess (address_ranges, /* ProcessMemory[] */ + (UDIInt)2, /* NumberOfRanges */ + entry, /* EntryPoint */ + stack_sizes, /* *StackSizes */ + (UDIInt)2, /* NumberOfStacks */ + args1); /* ArgString */ + + init_wait_for_inferior (); + clear_proceed_status (); + proceed (-1, TARGET_SIGNAL_DEFAULT, 0); +} + +static void +udi_mourn() +{ +#if 0 + /* Requiring "target udi" each time you run is a major pain. I suspect + this was just blindy copied from remote.c, in which "target" and + "run" are combined. Having a udi target without an inferior seems + to work between "target udi" and "run", so why not now? */ + pop_target (); /* Pop back to no-child state */ +#endif + /* But if we're going to want to run it again, we better remove the + breakpoints... */ + remove_breakpoints (); + generic_mourn_inferior (); +} + +/******************************************************************** UDI_OPEN +** Open a connection to remote TIP. + NAME is the socket domain used for communication with the TIP, + then a space and the socket name or TIP-host name. + '<udi_udi_config_id>' for example. + */ + +/* XXX - need cleanups for udiconnect for various failures!!! */ + +static void +udi_open (name, from_tty) + char *name; + int from_tty; +{ + unsigned int prl; + char *p; + int cnt; + UDIMemoryRange KnownMemory[10]; + UDIUInt32 ChipVersions[10]; + UDIInt NumberOfRanges = 10; + UDIInt NumberOfChips = 10; + UDIPId PId; + UDIUInt32 TIPId, TargetId, DFEId, DFE, TIP, DFEIPCId, TIPIPCId; + + target_preopen(from_tty); + + entry.Offset = 0; + + for (cnt = 0; cnt < BKPT_TABLE_SIZE; cnt++) + bkpt_table[cnt].Type = 0; + + if (udi_config_id) + free (udi_config_id); + + if (!name) + error("Usage: target udi config_id, where config_id appears in udi_soc file"); + + udi_config_id = strdup (strtok (name, " \t")); + + if (UDIConnect (udi_config_id, &udi_session_id)) + /* FIXME: Should set udi_session_id to -1 here. */ + error("UDIConnect() failed: %s\n", dfe_errmsg); + + push_target (&udi_ops); + + /* + ** Initialize target configuration structure (global) + */ + if (UDIGetTargetConfig (KnownMemory, &NumberOfRanges, + ChipVersions, &NumberOfChips)) + error ("UDIGetTargetConfig() failed"); + if (NumberOfChips > 2) + fprintf_unfiltered(gdb_stderr,"Target has more than one processor\n"); + for (cnt=0; cnt < NumberOfRanges; cnt++) + { + switch(KnownMemory[cnt].Space) + { + default: + fprintf_unfiltered(gdb_stderr, "UDIGetTargetConfig() unknown memory space\n"); + break; + case UDI29KCP_S: + break; + case UDI29KIROMSpace: + RMemStart = KnownMemory[cnt].Offset; + RMemSize = KnownMemory[cnt].Size; + break; + case UDI29KIRAMSpace: + IMemStart = KnownMemory[cnt].Offset; + IMemSize = KnownMemory[cnt].Size; + break; + case UDI29KDRAMSpace: + DMemStart = KnownMemory[cnt].Offset; + DMemSize = KnownMemory[cnt].Size; + break; + } + } + + a29k_get_processor_type (); + + if (UDICreateProcess (&PId)) + fprintf_unfiltered(gdb_stderr, "UDICreateProcess() failed\n"); + + /* Print out some stuff, letting the user now what's going on */ + if (UDICapabilities (&TIPId, &TargetId, DFEId, DFE, &TIP, &DFEIPCId, + &TIPIPCId, sbuf)) + error ("UDICapabilities() failed"); + if (from_tty) + { + printf_filtered ("Connected via UDI socket,\n\ + DFE-IPC version %x.%x.%x TIP-IPC version %x.%x.%x TIP version %x.%x.%x\n %s\n", + (DFEIPCId>>8)&0xf, (DFEIPCId>>4)&0xf, DFEIPCId&0xf, + (TIPIPCId>>8)&0xf, (TIPIPCId>>4)&0xf, TIPIPCId&0xf, + (TargetId>>8)&0xf, (TargetId>>4)&0xf, TargetId&0xf, + sbuf); + } +} + +/******************************************************************* UDI_CLOSE + Close the open connection to the TIP process. + Use this when you want to detach and do something else + with your gdb. */ +static void +udi_close (quitting) /*FIXME: how is quitting used */ + int quitting; +{ + if (udi_session_id < 0) + return; + + /* We should never get here if there isn't something valid in + udi_session_id. */ + + if (UDIDisconnect (udi_session_id, UDITerminateSession)) + { + if (quitting) + warning ("UDIDisconnect() failed in udi_close"); + else + error ("UDIDisconnect() failed in udi_close"); + } + + /* Do not try to close udi_session_id again, later in the program. */ + udi_session_id = -1; + inferior_pid = 0; + + printf_filtered (" Ending remote debugging\n"); +} + +/**************************************************************** UDI_ATACH */ +/* Attach to a program that is already loaded and running + * Upon exiting the process's execution is stopped. + */ +static void +udi_attach (args, from_tty) + char *args; + int from_tty; +{ + UDIResource From; + UDIInt32 PC_adds; + UDICount Count = 1; + UDISizeT Size = 4; + UDICount CountDone; + UDIBool HostEndian = 0; + UDIError err; + + if (args == NULL) + error_no_arg ("program to attach"); + + if (udi_session_id < 0) + error ("UDI connection not opened yet, use the 'target udi' command.\n"); + + if (from_tty) + printf_unfiltered ("Attaching to remote program %s...\n", prog_name); + + UDIStop(); + From.Space = UDI29KSpecialRegs; + From.Offset = 11; + if (err = UDIRead(From, &PC_adds, Count, Size, &CountDone, HostEndian)) + error ("UDIRead failed in udi_attach"); + printf_unfiltered ("Remote process is now halted, pc1 = 0x%x.\n", PC_adds); +} +/************************************************************* UDI_DETACH */ +/* Terminate the open connection to the TIP process. + Use this when you want to detach and do something else + with your gdb. Leave remote process running (with no breakpoints set). */ +static void +udi_detach (args,from_tty) + char *args; + int from_tty; +{ + + remove_breakpoints(); /* Just in case there were any left in */ + + if (UDIDisconnect (udi_session_id, UDIContinueSession)) + error ("UDIDisconnect() failed in udi_detach"); + + /* Don't try to UDIDisconnect it again in udi_close, which is called from + pop_target. */ + udi_session_id = -1; + inferior_pid = 0; + + pop_target(); + + if (from_tty) + printf_unfiltered ("Detaching from TIP\n"); +} + + +/****************************************************************** UDI_RESUME +** Tell the remote machine to resume. */ + +static void +udi_resume (pid, step, sig) + int pid, step; + enum target_signal sig; +{ + UDIError tip_error; + UDIUInt32 Steps = 1; + UDIStepType StepType = UDIStepNatural; + UDIRange Range; + + if (step) /* step 1 instruction */ + { + tip_error = UDIStep (Steps, StepType, Range); + if (!tip_error) + return; + + fprintf_unfiltered (gdb_stderr, "UDIStep() error = %d\n", tip_error); + error ("failed in udi_resume"); + } + + if (UDIExecute()) + error ("UDIExecute() failed in udi_resume"); +} + +/******************************************************************** UDI_WAIT +** Wait until the remote machine stops, then return, + storing status in STATUS just as `wait' would. */ + +static int +udi_wait (pid, status) + int pid; + struct target_waitstatus *status; +{ + UDIInt32 MaxTime; + UDIPId PId; + UDIInt32 StopReason; + UDISizeT CountDone; + int old_timeout = timeout; + int old_immediate_quit = immediate_quit; + int i; + + status->kind = TARGET_WAITKIND_EXITED; + status->value.integer = 0; + +/* wait for message to arrive. It should be: + If the target stops executing, udi_wait() should return. +*/ + timeout = 0; /* Wait indefinetly for a message */ + immediate_quit = 1; /* Helps ability to QUIT */ + + while(1) + { + i = 0; + MaxTime = UDIWaitForever; + UDIWait(MaxTime, &PId, &StopReason); + QUIT; /* Let user quit if they want */ + + switch (StopReason & UDIGrossState) + { + case UDIStdoutReady: + if (UDIGetStdout (sbuf, (UDISizeT)SBUF_MAX, &CountDone)) + /* This is said to happen if the program tries to output + a whole bunch of output (more than SBUF_MAX, I would + guess). It doesn't seem to happen with the simulator. */ + warning ("UDIGetStdout() failed in udi_wait"); + fwrite (sbuf, 1, CountDone, stdout); + gdb_flush(gdb_stdout); + continue; + + case UDIStderrReady: + UDIGetStderr (sbuf, (UDISizeT)SBUF_MAX, &CountDone); + fwrite (sbuf, 1, CountDone, stderr); + gdb_flush(gdb_stderr); + continue; + + case UDIStdinNeeded: + { + int ch; + i = 0; + do + { + ch = getchar (); + if (ch == EOF) + break; + sbuf[i++] = ch; + } while (i < SBUF_MAX && ch != '\n'); + UDIPutStdin (sbuf, (UDISizeT)i, &CountDone); + continue; + } + + case UDIRunning: + /* In spite of the fact that we told UDIWait to wait forever, it will + return spuriously sometimes. */ + case UDIStdinModeX: + continue; + default: + break; + } + break; + } + + switch (StopReason & UDIGrossState) + { + case UDITrapped: + printf_unfiltered("Am290*0 received vector number %d\n", StopReason >> 24); + + switch ((StopReason >> 8 ) & 0xff) + { + case 0: /* Illegal opcode */ + printf_unfiltered(" (break point)\n"); + status->kind = TARGET_WAITKIND_STOPPED; + status->value.sig = TARGET_SIGNAL_TRAP; + break; + case 1: /* Unaligned Access */ + status->kind = TARGET_WAITKIND_STOPPED; + status->value.sig = TARGET_SIGNAL_BUS; + break; + case 3: + case 4: + status->kind = TARGET_WAITKIND_STOPPED; + status->value.sig = TARGET_SIGNAL_FPE; + break; + case 5: /* Protection Violation */ + status->kind = TARGET_WAITKIND_STOPPED; + /* Why not SEGV? What is a Protection Violation? */ + status->value.sig = TARGET_SIGNAL_ILL; + break; + case 6: + case 7: + case 8: /* User Instruction Mapping Miss */ + case 9: /* User Data Mapping Miss */ + case 10: /* Supervisor Instruction Mapping Miss */ + case 11: /* Supervisor Data Mapping Miss */ + status->kind = TARGET_WAITKIND_STOPPED; + status->value.sig = TARGET_SIGNAL_SEGV; + break; + case 12: + case 13: + status->kind = TARGET_WAITKIND_STOPPED; + status->value.sig = TARGET_SIGNAL_ILL; + break; + case 14: /* Timer */ + status->kind = TARGET_WAITKIND_STOPPED; + status->value.sig = TARGET_SIGNAL_ALRM; + break; + case 15: /* Trace */ + status->kind = TARGET_WAITKIND_STOPPED; + status->value.sig = TARGET_SIGNAL_TRAP; + break; + case 16: /* INTR0 */ + case 17: /* INTR1 */ + case 18: /* INTR2 */ + case 19: /* INTR3/Internal */ + case 20: /* TRAP0 */ + case 21: /* TRAP1 */ + status->kind = TARGET_WAITKIND_STOPPED; + status->value.sig = TARGET_SIGNAL_INT; + break; + case 22: /* Floating-Point Exception */ + status->kind = TARGET_WAITKIND_STOPPED; + /* Why not FPE? */ + status->value.sig = TARGET_SIGNAL_ILL; + break; + case 77: /* assert 77 */ + status->kind = TARGET_WAITKIND_STOPPED; + status->value.sig = TARGET_SIGNAL_TRAP; + break; + default: + status->kind = TARGET_WAITKIND_EXITED; + status->value.integer = 0; + } + break; + case UDINotExecuting: + status->kind = TARGET_WAITKIND_STOPPED; + status->value.sig = TARGET_SIGNAL_TERM; + break; + case UDIStopped: + status->kind = TARGET_WAITKIND_STOPPED; + status->value.sig = TARGET_SIGNAL_TSTP; + break; + case UDIWarned: + status->kind = TARGET_WAITKIND_STOPPED; + status->value.sig = TARGET_SIGNAL_URG; + break; + case UDIStepped: + case UDIBreak: + status->kind = TARGET_WAITKIND_STOPPED; + status->value.sig = TARGET_SIGNAL_TRAP; + break; + case UDIWaiting: + status->kind = TARGET_WAITKIND_STOPPED; + status->value.sig = TARGET_SIGNAL_STOP; + break; + case UDIHalted: + status->kind = TARGET_WAITKIND_STOPPED; + status->value.sig = TARGET_SIGNAL_KILL; + break; + case UDIExited: + default: + status->kind = TARGET_WAITKIND_EXITED; + status->value.integer = 0; + } + + timeout = old_timeout; /* Restore original timeout value */ + immediate_quit = old_immediate_quit; + return inferior_pid; +} + +#if 0 +/* Handy for debugging */ +udi_pc() +{ + UDIResource From; + UDIUInt32 *To; + UDICount Count; + UDISizeT Size = 4; + UDICount CountDone; + UDIBool HostEndian = 0; + UDIError err; + int pc[2]; + unsigned long myregs[256]; + int i; + + From.Space = UDI29KPC; + From.Offset = 0; + To = (UDIUInt32 *)pc; + Count = 2; + + err = UDIRead(From, To, Count, Size, &CountDone, HostEndian); + + printf_unfiltered ("err = %d, CountDone = %d, pc[0] = 0x%x, pc[1] = 0x%x\n", + err, CountDone, pc[0], pc[1]); + + udi_fetch_registers(-1); + + printf_unfiltered("other pc1 = 0x%x, pc0 = 0x%x\n", *(int *)®isters[4 * PC_REGNUM], + *(int *)®isters[4 * NPC_REGNUM]); + + /* Now, read all the registers globally */ + + From.Space = UDI29KGlobalRegs; + From.Offset = 0; + err = UDIRead(From, myregs, 256, 4, &CountDone, HostEndian); + + printf ("err = %d, CountDone = %d\n", err, CountDone); + + printf("\n"); + + for (i = 0; i < 256; i += 2) + printf("%d:\t%#10x\t%11d\t%#10x\t%11d\n", i, myregs[i], myregs[i], + myregs[i+1], myregs[i+1]); + printf("\n"); + + return pc[0]; +} +#endif + +/********************************************************** UDI_FETCH_REGISTERS + * Read a remote register 'regno'. + * If regno==-1 then read all the registers. + */ +static void +udi_fetch_registers (regno) +int regno; +{ + UDIResource From; + UDIUInt32 *To; + UDICount Count; + UDISizeT Size = 4; + UDICount CountDone; + UDIBool HostEndian = 0; + UDIError err; + int i; + + if (regno >= 0) { + fetch_register(regno); + return; + } + +/* Gr1/rsp */ + + From.Space = UDI29KGlobalRegs; + From.Offset = 1; + To = (UDIUInt32 *)®isters[4 * GR1_REGNUM]; + Count = 1; + if (err = UDIRead(From, To, Count, Size, &CountDone, HostEndian)) + error("UDIRead() failed in udi_fetch_registers"); + + register_valid[GR1_REGNUM] = 1; + +#if defined(GR64_REGNUM) /* Read gr64-127 */ + +/* Global Registers gr64-gr95 */ + + From.Space = UDI29KGlobalRegs; + From.Offset = 64; + To = (UDIUInt32 *)®isters[4 * GR64_REGNUM]; + Count = 32; + if (err = UDIRead(From, To, Count, Size, &CountDone, HostEndian)) + error("UDIRead() failed in udi_fetch_registers"); + + for (i = GR64_REGNUM; i < GR64_REGNUM + 32; i++) + register_valid[i] = 1; + +#endif /* GR64_REGNUM */ + +/* Global Registers gr96-gr127 */ + + From.Space = UDI29KGlobalRegs; + From.Offset = 96; + To = (UDIUInt32 *)®isters[4 * GR96_REGNUM]; + Count = 32; + if (err = UDIRead(From, To, Count, Size, &CountDone, HostEndian)) + error("UDIRead() failed in udi_fetch_registers"); + + for (i = GR96_REGNUM; i < GR96_REGNUM + 32; i++) + register_valid[i] = 1; + +/* Local Registers */ + + From.Space = UDI29KLocalRegs; + From.Offset = 0; + To = (UDIUInt32 *)®isters[4 * LR0_REGNUM]; + Count = 128; + if (err = UDIRead(From, To, Count, Size, &CountDone, HostEndian)) + error("UDIRead() failed in udi_fetch_registers"); + + for (i = LR0_REGNUM; i < LR0_REGNUM + 128; i++) + register_valid[i] = 1; + +/* Protected Special Registers */ + + From.Space = UDI29KSpecialRegs; + From.Offset = 0; + To = (UDIUInt32 *)®isters[4 * SR_REGNUM(0)]; + Count = 15; + if (err = UDIRead(From, To, Count, Size, &CountDone, HostEndian)) + error("UDIRead() failed in udi_fetch_registers"); + + for (i = SR_REGNUM(0); i < SR_REGNUM(0) + 15; i++) + register_valid[i] = 1; + + if (USE_SHADOW_PC) { /* Let regno_to_srnum() handle the register number */ + fetch_register(NPC_REGNUM); + fetch_register(PC_REGNUM); + fetch_register(PC2_REGNUM); + +/* Unprotected Special Registers sr128-sr135 */ + + From.Space = UDI29KSpecialRegs; + From.Offset = 128; + To = (UDIUInt32 *)®isters[4 * SR_REGNUM(128)]; + Count = 135-128 + 1; + if (err = UDIRead(From, To, Count, Size, &CountDone, HostEndian)) + error("UDIRead() failed in udi_fetch_registers"); + + for (i = SR_REGNUM(128); i < SR_REGNUM(128) + 135-128+1; i++) + register_valid[i] = 1; + } + + if (remote_debug) + { + printf_unfiltered("Fetching all registers\n"); + printf_unfiltered("Fetching PC0 = 0x%x, PC1 = 0x%x, PC2 = 0x%x\n", + read_register(NPC_REGNUM), read_register(PC_REGNUM), + read_register(PC2_REGNUM)); + } + + /* There doesn't seem to be any way to get these. */ + { + int val = -1; + supply_register (FPE_REGNUM, (char *) &val); + supply_register (INTE_REGNUM, (char *) &val); + supply_register (FPS_REGNUM, (char *) &val); + supply_register (EXO_REGNUM, (char *) &val); + } +} + + +/********************************************************* UDI_STORE_REGISTERS +** Store register regno into the target. + * If regno==-1 then store all the registers. + */ + +static void +udi_store_registers (regno) +int regno; +{ + UDIUInt32 *From; + UDIResource To; + UDICount Count; + UDISizeT Size = 4; + UDICount CountDone; + UDIBool HostEndian = 0; + + if (regno >= 0) + { + store_register(regno); + return; + } + + if (remote_debug) + { + printf_unfiltered("Storing all registers\n"); + printf_unfiltered("PC0 = 0x%x, PC1 = 0x%x, PC2 = 0x%x\n", read_register(NPC_REGNUM), + read_register(PC_REGNUM), read_register(PC2_REGNUM)); + } + +/* Gr1/rsp */ + + From = (UDIUInt32 *)®isters[4 * GR1_REGNUM]; + To.Space = UDI29KGlobalRegs; + To.Offset = 1; + Count = 1; + if(UDIWrite(From, To, Count, Size, &CountDone, HostEndian)) + error("UDIWrite() failed in udi_store_regisetrs"); + +#if defined(GR64_REGNUM) + +/* Global registers gr64-gr95 */ + + From = (UDIUInt32 *)®isters[4 * GR64_REGNUM]; + To.Space = UDI29KGlobalRegs; + To.Offset = 64; + Count = 32; + if(UDIWrite(From, To, Count, Size, &CountDone, HostEndian)) + error("UDIWrite() failed in udi_store_regisetrs"); + +#endif /* GR64_REGNUM */ + +/* Global registers gr96-gr127 */ + + From = (UDIUInt32 *)®isters[4 * GR96_REGNUM]; + To.Space = UDI29KGlobalRegs; + To.Offset = 96; + Count = 32; + if(UDIWrite(From, To, Count, Size, &CountDone, HostEndian)) + error("UDIWrite() failed in udi_store_regisetrs"); + +/* Local Registers */ + + From = (UDIUInt32 *)®isters[4 * LR0_REGNUM]; + To.Space = UDI29KLocalRegs; + To.Offset = 0; + Count = 128; + if(UDIWrite(From, To, Count, Size, &CountDone, HostEndian)) + error("UDIWrite() failed in udi_store_regisetrs"); + + +/* Protected Special Registers */ /* VAB through TMR */ + + From = (UDIUInt32 *)®isters[4 * SR_REGNUM(0)]; + To.Space = UDI29KSpecialRegs; + To.Offset = 0; + Count = 10; + if(UDIWrite(From, To, Count, Size, &CountDone, HostEndian)) + error("UDIWrite() failed in udi_store_regisetrs"); + +/* PC0, PC1, PC2 possibly as shadow registers */ + + From = (UDIUInt32 *)®isters[4 * SR_REGNUM(10)]; + To.Space = UDI29KSpecialRegs; + Count = 3; + if (USE_SHADOW_PC) + To.Offset = 20; /* SPC0 */ + else + To.Offset = 10; /* PC0 */ + if(UDIWrite(From, To, Count, Size, &CountDone, HostEndian)) + error("UDIWrite() failed in udi_store_regisetrs"); + +/* PC1 via UDI29KPC */ + + From = (UDIUInt32 *)®isters[4 * PC_REGNUM]; + To.Space = UDI29KPC; + To.Offset = 0; /* PC1 */ + Count = 1; + if (UDIWrite (From, To, Count, Size, &CountDone, HostEndian)) + error ("UDIWrite() failed in udi_store_regisetrs"); + + /* LRU and MMU */ + + From = (UDIUInt32 *)®isters[4 * SR_REGNUM(13)]; + To.Space = UDI29KSpecialRegs; + To.Offset = 13; + Count = 2; + if(UDIWrite(From, To, Count, Size, &CountDone, HostEndian)) + error("UDIWrite() failed in udi_store_regisetrs"); + +/* Unprotected Special Registers */ + + From = (UDIUInt32 *)®isters[4 * SR_REGNUM(128)]; + To.Space = UDI29KSpecialRegs; + To.Offset = 128; + Count = 135-128 +1; + if(UDIWrite(From, To, Count, Size, &CountDone, HostEndian)) + error("UDIWrite() failed in udi_store_regisetrs"); + + registers_changed (); +} + +/****************************************************** UDI_PREPARE_TO_STORE */ +/* Get ready to modify the registers array. On machines which store + individual registers, this doesn't need to do anything. On machines + which store all the registers in one fell swoop, this makes sure + that registers contains all the registers from the program being + debugged. */ + +static void +udi_prepare_to_store () +{ + /* Do nothing, since we can store individual regs */ +} + +/********************************************************** TRANSLATE_ADDR */ +static CORE_ADDR +translate_addr(addr) +CORE_ADDR addr; +{ +#if defined(ULTRA3) && defined(KERNEL_DEBUGGING) + /* Check for a virtual address in the kernel */ + /* Assume physical address of ublock is in paddr_u register */ + /* FIXME: doesn't work for user virtual addresses */ + if (addr >= UVADDR) { + /* PADDR_U register holds the physical address of the ublock */ + CORE_ADDR i = (CORE_ADDR)read_register(PADDR_U_REGNUM); + return(i + addr - (CORE_ADDR)UVADDR); + } else { + return(addr); + } +#else + return(addr); +#endif +} +/************************************************* UDI_XFER_INFERIOR_MEMORY */ +/* FIXME! Merge these two. */ +static int +udi_xfer_inferior_memory (memaddr, myaddr, len, write) + CORE_ADDR memaddr; + char *myaddr; + int len; + int write; +{ + + memaddr = translate_addr(memaddr); + + if (write) + return udi_write_inferior_memory (memaddr, myaddr, len); + else + return udi_read_inferior_memory (memaddr, myaddr, len); +} + +/********************************************************** UDI_FILES_INFO */ +static void +udi_files_info () +{ + printf_unfiltered ("\tAttached to UDI socket to %s", udi_config_id); + if (prog_name != NULL) + printf_unfiltered ("and running program %s", prog_name); + printf_unfiltered (".\n"); +} + +/**************************************************** UDI_INSERT_BREAKPOINT */ +static int +udi_insert_breakpoint (addr, contents_cache) + CORE_ADDR addr; + char *contents_cache; +{ + int cnt; + UDIError err; + + for (cnt = 0; cnt < BKPT_TABLE_SIZE; cnt++) + if (bkpt_table[cnt].Type == 0) /* Find first free slot */ + break; + + if(cnt >= BKPT_TABLE_SIZE) + error("Too many breakpoints set"); + + bkpt_table[cnt].Addr.Offset = addr; + bkpt_table[cnt].Addr.Space = UDI29KIRAMSpace; + bkpt_table[cnt].PassCount = 1; + bkpt_table[cnt].Type = UDIBreakFlagExecute; + + err = UDISetBreakpoint(bkpt_table[cnt].Addr, + bkpt_table[cnt].PassCount, + bkpt_table[cnt].Type, + &bkpt_table[cnt].BreakId); + + if (err == 0) return 0; /* Success */ + + bkpt_table[cnt].Type = 0; + error("UDISetBreakpoint returned error code %d\n", err); +} + +/**************************************************** UDI_REMOVE_BREAKPOINT */ +static int +udi_remove_breakpoint (addr, contents_cache) + CORE_ADDR addr; + char *contents_cache; +{ + int cnt; + UDIError err; + + for (cnt = 0; cnt < BKPT_TABLE_SIZE; cnt++) + if (bkpt_table[cnt].Addr.Offset == addr) /* Find matching breakpoint */ + break; + + if(cnt >= BKPT_TABLE_SIZE) + error("Can't find breakpoint in table"); + + bkpt_table[cnt].Type = 0; + + err = UDIClearBreakpoint(bkpt_table[cnt].BreakId); + if (err == 0) return 0; /* Success */ + + error("UDIClearBreakpoint returned error code %d\n", err); +} + +static void +udi_kill(arg,from_tty) + char *arg; + int from_tty; +{ + +#if 0 +/* +UDIStop does not really work as advertised. It causes the TIP to close it's +connection, which usually results in GDB dying with a SIGPIPE. For now, we +just invoke udi_close, which seems to get things right. +*/ + UDIStop(); + + udi_session_id = -1; + inferior_pid = 0; + + if (from_tty) + printf_unfiltered("Target has been stopped."); +#endif /* 0 */ +#if 0 + udi_close(0); + pop_target(); +#endif /* 0 */ + + /* Keep the target around, e.g. so "run" can do the right thing when + we are already debugging something. */ + + if (UDIDisconnect (udi_session_id, UDITerminateSession)) + { + warning ("UDIDisconnect() failed"); + } + + /* Do not try to close udi_session_id again, later in the program. */ + udi_session_id = -1; + inferior_pid = 0; +} + +/* + Load a program into the target. Args are: `program {options}'. The options + are used to control loading of the program, and are NOT passed onto the + loaded code as arguments. (You need to use the `run' command to do that.) + + The options are: + -ms %d Set mem stack size to %d + -rs %d Set regular stack size to %d + -i send init info (default) + -noi don't send init info + -[tT] Load Text section + -[dD] Load Data section + -[bB] Load BSS section + -[lL] Load Lit section + */ + +static void +download(load_arg_string, from_tty) + char *load_arg_string; + int from_tty; +{ +#define DEFAULT_MEM_STACK_SIZE 0x6000 +#define DEFAULT_REG_STACK_SIZE 0x2000 + + char *token; + char *filename; + asection *section; + bfd *pbfd; + UDIError err; + int load_text = 1, load_data = 1, load_bss = 1, load_lit = 1; + + address_ranges[0].Space = UDI29KIRAMSpace; + address_ranges[0].Offset = 0xffffffff; + address_ranges[0].Size = 0; + + address_ranges[1].Space = UDI29KDRAMSpace; + address_ranges[1].Offset = 0xffffffff; + address_ranges[1].Size = 0; + + stack_sizes[0] = DEFAULT_REG_STACK_SIZE; + stack_sizes[1] = DEFAULT_MEM_STACK_SIZE; + + dont_repeat (); + + filename = strtok(load_arg_string, " \t"); + if (!filename) + error ("Must specify at least a file name with the load command"); + + filename = tilde_expand (filename); + make_cleanup ((make_cleanup_func) free, filename); + + while (token = strtok (NULL, " \t")) + { + if (token[0] == '-') + { + token++; + + if (STREQ (token, "ms")) + stack_sizes[1] = atol (strtok (NULL, " \t")); + else if (STREQ (token, "rs")) + stack_sizes[0] = atol (strtok (NULL, " \t")); + else + { + load_text = load_data = load_bss = load_lit = 0; + + while (*token) + { + switch (*token++) + { + case 't': + case 'T': + load_text = 1; + break; + case 'd': + case 'D': + load_data = 1; + break; + case 'b': + case 'B': + load_bss = 1; + break; + case 'l': + case 'L': + load_lit = 1; + break; + default: + error ("Unknown UDI load option -%s", token-1); + } + } + } + } + } + + pbfd = bfd_openr (filename, gnutarget); + + if (!pbfd) + /* FIXME: should be using bfd_errmsg, not assuming it was + bfd_error_system_call. */ + perror_with_name (filename); + + /* FIXME: should be checking for errors from bfd_close (for one thing, + on error it does not free all the storage associated with the + bfd). */ + make_cleanup ((make_cleanup_func) bfd_close, pbfd); + + QUIT; + immediate_quit++; + + if (!bfd_check_format (pbfd, bfd_object)) + error ("It doesn't seem to be an object file"); + + for (section = pbfd->sections; section; section = section->next) + { + if (bfd_get_section_flags (pbfd, section) & SEC_ALLOC) + { + UDIResource To; + UDICount Count; + unsigned long section_size, section_end; + const char *section_name; + + section_name = bfd_get_section_name (pbfd, section); + if (STREQ (section_name, ".text") && !load_text) + continue; + else if (STREQ (section_name, ".data") && !load_data) + continue; + else if (STREQ (section_name, ".bss") && !load_bss) + continue; + else if (STREQ (section_name, ".lit") && !load_lit) + continue; + + To.Offset = bfd_get_section_vma (pbfd, section); + section_size = bfd_section_size (pbfd, section); + section_end = To.Offset + section_size; + + if (section_size == 0) + /* This is needed at least in the BSS case, where the code + below starts writing before it even checks the size. */ + continue; + + printf_unfiltered("[Loading section %s at %x (%d bytes)]\n", + section_name, + To.Offset, + section_size); + + if (bfd_get_section_flags (pbfd, section) & SEC_CODE) + { + To.Space = UDI29KIRAMSpace; + + address_ranges[0].Offset = min (address_ranges[0].Offset, + To.Offset); + address_ranges[0].Size = max (address_ranges[0].Size, + section_end + - address_ranges[0].Offset); + } + else + { + To.Space = UDI29KDRAMSpace; + + address_ranges[1].Offset = min (address_ranges[1].Offset, + To.Offset); + address_ranges[1].Size = max (address_ranges[1].Size, + section_end + - address_ranges[1].Offset); + } + + if (bfd_get_section_flags (pbfd, section) & SEC_LOAD) /* Text, data or lit */ + { + file_ptr fptr; + + fptr = 0; + + while (section_size > 0) + { + char buffer[1024]; + + Count = min (section_size, 1024); + + bfd_get_section_contents (pbfd, section, buffer, fptr, + Count); + + err = UDIWrite ((UDIHostMemPtr)buffer, /* From */ + To, /* To */ + Count, /* Count */ + (UDISizeT)1, /* Size */ + &Count, /* CountDone */ + (UDIBool)0); /* HostEndian */ + if (err) + error ("UDIWrite failed, error = %d", err); + + To.Offset += Count; + fptr += Count; + section_size -= Count; + } + } + else /* BSS */ + { + UDIResource From; + unsigned long zero = 0; + + /* Write a zero byte at the vma */ + /* FIXME: Broken for sections of 1-3 bytes (we test for + zero above). */ + err = UDIWrite ((UDIHostMemPtr)&zero, /* From */ + To, /* To */ + (UDICount)1, /* Count */ + (UDISizeT)4, /* Size */ + &Count, /* CountDone */ + (UDIBool)0); /* HostEndian */ + if (err) + error ("UDIWrite failed, error = %d", err); + + From = To; + To.Offset+=4; + + /* Now, duplicate it for the length of the BSS */ + err = UDICopy (From, /* From */ + To, /* To */ + (UDICount)(section_size/4 - 1), /* Count */ + (UDISizeT)4, /* Size */ + &Count, /* CountDone */ + (UDIBool)1); /* Direction */ + if (err) + { + char message[100]; + int xerr; + + xerr = UDIGetErrorMsg(err, 100, message, &Count); + if (!xerr) + fprintf_unfiltered (gdb_stderr, "Error is %s\n", message); + else + fprintf_unfiltered (gdb_stderr, "xerr is %d\n", xerr); + error ("UDICopy failed, error = %d", err); + } + } + + } + } + + entry.Space = UDI29KIRAMSpace; + entry.Offset = bfd_get_start_address (pbfd); + + immediate_quit--; +} + +/* Function to download an image into the remote target. */ + +static void +udi_load (args, from_tty) + char *args; + int from_tty; +{ + download (args, from_tty); + + /* As a convenience, pick up any symbol info that is in the program + being loaded. Note that we assume that the program is the``mainline''; + if this is not always true, then this code will need to be augmented. */ + symbol_file_add (strtok (args, " \t"), from_tty, 0, 1, 0, 0, 0, 0); + + /* Getting new symbols may change our opinion about what is + frameless. */ + reinit_frame_cache (); +} + +/*************************************************** UDI_WRITE_INFERIOR_MEMORY +** Copy LEN bytes of data from debugger memory at MYADDR + to inferior's memory at MEMADDR. Returns number of bytes written. */ +static int +udi_write_inferior_memory (memaddr, myaddr, len) + CORE_ADDR memaddr; + char *myaddr; + int len; +{ + int nwritten = 0; + UDIUInt32 *From; + UDIResource To; + UDICount Count; + UDISizeT Size = 1; + UDICount CountDone = 0; + UDIBool HostEndian = 0; + + To.Space = udi_memory_space(memaddr); + From = (UDIUInt32*)myaddr; + + while (nwritten < len) + { Count = len - nwritten; + if (Count > MAXDATA) Count = MAXDATA; + To.Offset = memaddr + nwritten; + if(UDIWrite(From, To, Count, Size, &CountDone, HostEndian)) + { error("UDIWrite() failed in udi_write_inferior_memory"); + break; + } + else + { nwritten += CountDone; + From += CountDone; + } + } + return(nwritten); +} + +/**************************************************** UDI_READ_INFERIOR_MEMORY +** Read LEN bytes from inferior memory at MEMADDR. Put the result + at debugger address MYADDR. Returns number of bytes read. */ +static int +udi_read_inferior_memory(memaddr, myaddr, len) + CORE_ADDR memaddr; + char *myaddr; + int len; +{ + int nread = 0; + UDIResource From; + UDIUInt32 *To; + UDICount Count; + UDISizeT Size = 1; + UDICount CountDone = 0; + UDIBool HostEndian = 0; + UDIError err; + + From.Space = udi_memory_space(memaddr); + To = (UDIUInt32*)myaddr; + + while (nread < len) + { Count = len - nread; + if (Count > MAXDATA) Count = MAXDATA; + From.Offset = memaddr + nread; + if(err = UDIRead(From, To, Count, Size, &CountDone, HostEndian)) + { error("UDIRead() failed in udi_read_inferior_memory"); + break; + } + else + { nread += CountDone; + To += CountDone; + } + } + return(nread); +} + +/********************************************************************* WARNING +*/ +udi_warning(num) +int num; +{ + error ("ERROR while loading program into remote TIP: $d\n", num); +} + + +/*****************************************************************************/ +/* Fetch a single register indicatated by 'regno'. + * Returns 0/-1 on success/failure. + */ +static void +fetch_register (regno) + int regno; +{ + UDIResource From; + UDIUInt32 To; + UDICount Count = 1; + UDISizeT Size = 4; + UDICount CountDone; + UDIBool HostEndian = 0; + UDIError err; + int result; + + if (regno == GR1_REGNUM) + { + From.Space = UDI29KGlobalRegs; + From.Offset = 1; + } + else if (regno >= GR96_REGNUM && regno < GR96_REGNUM + 32) + { + From.Space = UDI29KGlobalRegs; + From.Offset = (regno - GR96_REGNUM) + 96;; + } + +#if defined(GR64_REGNUM) + + else if (regno >= GR64_REGNUM && regno < GR64_REGNUM + 32 ) + { + From.Space = UDI29KGlobalRegs; + From.Offset = (regno - GR64_REGNUM) + 64; + } + +#endif /* GR64_REGNUM */ + + else if (regno >= LR0_REGNUM && regno < LR0_REGNUM + 128) + { + From.Space = UDI29KLocalRegs; + From.Offset = (regno - LR0_REGNUM); + } + else if (regno>=FPE_REGNUM && regno<=EXO_REGNUM) + { + int val = -1; + /*supply_register(160 + (regno - FPE_REGNUM),(char *) &val);*/ + supply_register(regno, (char *) &val); + return; /* Pretend Success */ + } + else + { + From.Space = UDI29KSpecialRegs; + From.Offset = regnum_to_srnum(regno); + } + + if (err = UDIRead(From, &To, Count, Size, &CountDone, HostEndian)) + error("UDIRead() failed in udi_fetch_registers"); + + supply_register(regno, (char *) &To); + + if (remote_debug) + printf_unfiltered("Fetching register %s = 0x%x\n", REGISTER_NAME (regno), To); +} +/*****************************************************************************/ +/* Store a single register indicated by 'regno'. + * Returns 0/-1 on success/failure. + */ +static int +store_register (regno) + int regno; +{ + int result; + UDIUInt32 From; + UDIResource To; + UDICount Count = 1; + UDISizeT Size = 4; + UDICount CountDone; + UDIBool HostEndian = 0; + + From = read_register (regno); /* get data value */ + + if (remote_debug) + printf_unfiltered("Storing register %s = 0x%x\n", REGISTER_NAME (regno), From); + + if (regno == GR1_REGNUM) + { + To.Space = UDI29KGlobalRegs; + To.Offset = 1; + result = UDIWrite(&From, To, Count, Size, &CountDone, HostEndian); + /* Setting GR1 changes the numbers of all the locals, so invalidate the + * register cache. Do this *after* calling read_register, because we want + * read_register to return the value that write_register has just stuffed + * into the registers array, not the value of the register fetched from + * the inferior. + */ + registers_changed (); + } +#if defined(GR64_REGNUM) + else if (regno >= GR64_REGNUM && regno < GR64_REGNUM + 32 ) + { + To.Space = UDI29KGlobalRegs; + To.Offset = (regno - GR64_REGNUM) + 64; + result = UDIWrite(&From, To, Count, Size, &CountDone, HostEndian); + } +#endif /* GR64_REGNUM */ + else if (regno >= GR96_REGNUM && regno < GR96_REGNUM + 32) + { + To.Space = UDI29KGlobalRegs; + To.Offset = (regno - GR96_REGNUM) + 96; + result = UDIWrite(&From, To, Count, Size, &CountDone, HostEndian); + } + else if (regno >= LR0_REGNUM && regno < LR0_REGNUM + 128) + { + To.Space = UDI29KLocalRegs; + To.Offset = (regno - LR0_REGNUM); + result = UDIWrite(&From, To, Count, Size, &CountDone, HostEndian); + } + else if (regno >= FPE_REGNUM && regno <= EXO_REGNUM) + return 0; /* Pretend Success */ + else if (regno == PC_REGNUM) + { + /* PC1 via UDI29KPC */ + + To.Space = UDI29KPC; + To.Offset = 0; /* PC1 */ + result = UDIWrite (&From, To, Count, Size, &CountDone, HostEndian); + + /* Writing to this loc actually changes the values of pc0 & pc1 */ + + register_valid[PC_REGNUM] = 0; /* pc1 */ + register_valid[NPC_REGNUM] = 0; /* pc0 */ + } + else /* An unprotected or protected special register */ + { + To.Space = UDI29KSpecialRegs; + To.Offset = regnum_to_srnum(regno); + result = UDIWrite(&From, To, Count, Size, &CountDone, HostEndian); + } + + if (result != 0) + error("UDIWrite() failed in store_registers"); + + return 0; +} +/********************************************************** REGNUM_TO_SRNUM */ +/* + * Convert a gdb special register number to a 29000 special register number. + */ +static int +regnum_to_srnum(regno) +int regno; +{ + switch(regno) { + case VAB_REGNUM: return(0); + case OPS_REGNUM: return(1); + case CPS_REGNUM: return(2); + case CFG_REGNUM: return(3); + case CHA_REGNUM: return(4); + case CHD_REGNUM: return(5); + case CHC_REGNUM: return(6); + case RBP_REGNUM: return(7); + case TMC_REGNUM: return(8); + case TMR_REGNUM: return(9); + case NPC_REGNUM: return(USE_SHADOW_PC ? (20) : (10)); + case PC_REGNUM: return(USE_SHADOW_PC ? (21) : (11)); + case PC2_REGNUM: return(USE_SHADOW_PC ? (22) : (12)); + case MMU_REGNUM: return(13); + case LRU_REGNUM: return(14); + case IPC_REGNUM: return(128); + case IPA_REGNUM: return(129); + case IPB_REGNUM: return(130); + case Q_REGNUM: return(131); + case ALU_REGNUM: return(132); + case BP_REGNUM: return(133); + case FC_REGNUM: return(134); + case CR_REGNUM: return(135); + case FPE_REGNUM: return(160); + case INTE_REGNUM: return(161); + case FPS_REGNUM: return(162); + case EXO_REGNUM:return(164); + default: + return(255); /* Failure ? */ + } +} +/****************************************************************************/ +/* + * Determine the Target memory space qualifier based on the addr. + * FIXME: Can't distinguis I_ROM/D_ROM. + * FIXME: Doesn't know anything about I_CACHE/D_CACHE. + */ +static CPUSpace +udi_memory_space(addr) +CORE_ADDR addr; +{ + UDIUInt32 tstart = IMemStart; + UDIUInt32 tend = tstart + IMemSize; + UDIUInt32 dstart = DMemStart; + UDIUInt32 dend = tstart + DMemSize; + UDIUInt32 rstart = RMemStart; + UDIUInt32 rend = tstart + RMemSize; + + if (((UDIUInt32)addr >= tstart) && ((UDIUInt32)addr < tend)) { + return UDI29KIRAMSpace; + } else if (((UDIUInt32)addr >= dstart) && ((UDIUInt32)addr < dend)) { + return UDI29KDRAMSpace; + } else if (((UDIUInt32)addr >= rstart) && ((UDIUInt32)addr < rend)) { + /* FIXME: how do we determine between D_ROM and I_ROM */ + return UDI29KIROMSpace; + } else /* FIXME: what do me do now? */ + return UDI29KDRAMSpace; /* Hmmm! */ +} +/*********************************************************************** STUBS +*/ + +void convert16() {;} +void convert32() {;} +GDB_FILE * EchoFile = 0; /* used for debugging */ +int QuietMode = 0; /* used for debugging */ + +#ifdef NO_HIF_SUPPORT +service_HIF(msg) + union msg_t *msg; +{ + return(0); /* Emulate a failure */ +} +#endif + +/* Target_ops vector. Not static because there does not seem to be + any portable way to do a forward declaration of a static variable. + The RS/6000 doesn't like "extern" followed by "static"; SunOS + /bin/cc doesn't like "static" twice. */ + +struct target_ops udi_ops; + +static void +init_udi_ops(void) +{ + udi_ops.to_shortname = "udi"; + udi_ops.to_longname = "Remote UDI connected TIP"; + udi_ops.to_doc = "Remote debug an AMD 29k using UDI socket connection to TIP process.\n\ +Arguments are\n\ +`configuration-id AF_INET hostname port-number'\n\ +To connect via the network, where hostname and port-number specify the\n\ +host and port where you can connect via UDI.\n\ +configuration-id is unused.\n\ +\n\ +`configuration-id AF_UNIX socket-name tip-program'\n\ +To connect using a local connection to the \"tip.exe\" program which is\n\ + supplied by AMD. If socket-name specifies an AF_UNIX socket then the\n\ + tip program must already be started; connect to it using that socket.\n\ + If not, start up tip-program, which should be the name of the tip\n\ + program. If appropriate, the PATH environment variable is searched.\n\ + configuration-id is unused.\n\ +\n\ +`configuration-id'\n\ + Look up the configuration in ./udi_soc or /etc/udi_soc, which\n\ + are files containing lines in the above formats. configuration-id is\n\ + used to pick which line of the file to use." ; + udi_ops.to_open = udi_open; + udi_ops.to_close = udi_close; + udi_ops.to_attach = udi_attach; + udi_ops.to_detach = udi_detach; + udi_ops.to_resume = udi_resume; + udi_ops.to_wait = udi_wait; + udi_ops.to_fetch_registers = udi_fetch_registers; + udi_ops.to_store_registers = udi_store_registers; + udi_ops.to_prepare_to_store = udi_prepare_to_store; + udi_ops.to_xfer_memory = udi_xfer_inferior_memory; + udi_ops.to_files_info = udi_files_info; + udi_ops.to_insert_breakpoint = udi_insert_breakpoint; + udi_ops.to_remove_breakpoint = udi_remove_breakpoint; + udi_ops.to_terminal_init = 0; + udi_ops.to_terminal_inferior = 0; + udi_ops.to_terminal_ours_for_output = 0; + udi_ops.to_terminal_ours = 0; + udi_ops.to_terminal_info = 0; + udi_ops.to_kill = udi_kill; + udi_ops.to_load = udi_load; + udi_ops.to_lookup_symbol = 0; + udi_ops.to_create_inferior = udi_create_inferior; + udi_ops.to_mourn_inferior = udi_mourn; + udi_ops.to_can_run = 0; + udi_ops.to_notice_signals = 0; + udi_ops.to_thread_alive = 0; + udi_ops.to_stop = 0; + udi_ops.to_stratum = process_stratum; + udi_ops.DONT_USE = 0; + udi_ops.to_has_all_memory = 1; + udi_ops.to_has_memory = 1; + udi_ops.to_has_stack = 1; + udi_ops.to_has_registers = 1; + udi_ops.to_has_execution = 1; + udi_ops.to_sections = 0; + udi_ops.to_sections_end = 0; + udi_ops.to_magic = OPS_MAGIC; +}; + +void +_initialize_remote_udi () +{ + init_udi_ops() ; + add_target (&udi_ops); +} |