aboutsummaryrefslogtreecommitdiff
path: root/gdb
diff options
context:
space:
mode:
Diffstat (limited to 'gdb')
-rw-r--r--gdb/remote-udi.c1346
1 files changed, 1346 insertions, 0 deletions
diff --git a/gdb/remote-udi.c b/gdb/remote-udi.c
new file mode 100644
index 0000000..d1233f4
--- /dev/null
+++ b/gdb/remote-udi.c
@@ -0,0 +1,1346 @@
+/*
+ - Remote debugging interface for Am290*0 running MiniMON monitor, for GDB.
+ This is like remote.c but expects MiniMON to be running on the Am29000
+ target hardware.
+ - Originally written by Daniel Mann at AMD for 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. Because we are only attempting to
+ use this module to debug our kernel, which is already loaded when
+ gdb is started up, I did not code up the file downloading facilities.
+ As a result this module has only the stubs to download files.
+ You should get tagged at compile time if you need to make any
+ changes/additions.
+*- Daniel Mann at AMD took the 3.95 adaptions above and replaced
+ MiniMON interface with UDI-p interface.
+
+ Copyright (C) 1990 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 1, 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; see the file COPYING. If not, write to
+the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
+
+
+#include <stdio.h>
+#include "defs.h"
+#include "inferior.h"
+#include "wait.h"
+#include "value.h"
+#include <ctype.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <errno.h>
+#include <string.h>
+#include "terminal.h"
+#include "target.h"
+#include "udiproc.h"
+
+/* access the register store directly, without going through
+ the normal handler functions. This avoids an extra data copy
+*/
+
+/* #define DEBUG 1 /* */
+#ifdef DEBUG
+# define DENTER(NAME) (printf("Entering %s\n",NAME), fflush(stdout))
+# define DEXIT(NAME) (printf("Exiting %s\n",NAME), fflush(stdout))
+#else
+# define DENTER(NAME)
+# define DEXIT(NAME)
+#endif
+
+
+extern char register_valid[];
+extern int stop_soon_quietly; /* for wait_for_inferior */
+extern struct value *call_function_by_hand();
+static void udi_resume();
+static void udi_fetch_registers ();
+static void udi_load();
+static int fetch_register ();
+static void udi_store_registers ();
+static int store_register ();
+static int regnum_to_srnum();
+static void udi_close ();
+static CPUSpace udi_memory_space();
+static int udi_write_inferior_memory();
+static int udi_read_inferior_memory();
+char CoffFileName[100] = "";
+/*
+ * Processor types.
+ */
+#define TYPE_UNKNOWN 0
+#define TYPE_A29000 1
+#define TYPE_A29030 2
+#define TYPE_A29050 3
+static char *processor_name[] = { "Unknown", "Am29000", "Am29030", "Am29050" };
+static int processor_type=TYPE_UNKNOWN;
+#define FREEZE_MODE (read_register(CPS_REGNUM) && 0x400)
+#define USE_SHADOW_PC ((processor_type == TYPE_A29050) && FREEZE_MODE)
+
+#define LLOG_FILE "udi.log"
+#if defined (LOG_FILE)
+FILE *log_file;
+#endif
+
+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;
+
+ CPUOffset IMemStart = 0;
+ CPUSizeT IMemSize = 0;
+ CPUOffset DMemStart = 0;
+ CPUSizeT DMemSize = 0;
+ CPUOffset RMemStart = 0;
+ CPUSizeT RMemSize = 0;
+ UDIUInt32 CPUPRL;
+ UDIUInt32 CoProcPRL;
+
+#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 MAX_BKPT 40
+bkpt_entry_t bkpt_table[MAX_BKPT];
+extern char dfe_errmsg[]; /* error string */
+
+/*********************************************************** SIGNAL SUPPORT */
+/* Called when SIGALRM signal sent due to alarm() timeout. */
+#ifndef HAVE_TERMIO
+
+#ifndef __STDC__
+# ifndef volatile
+# define volatile /**/
+# endif
+#endif
+volatile int n_alarms;
+
+static void
+udi_timer ()
+{
+#if 0
+ if (kiodebug)
+ printf ("udi_timer called\n");
+#endif
+ n_alarms++;
+}
+#endif /* HAVE_TERMIO */
+
+/* malloc'd name of the program on the remote system. */
+static char *prog_name = NULL;
+
+
+/* Number of SIGTRAPs we need to simulate. That is, the next
+ NEED_ARTIFICIAL_TRAP calls to udi_wait should just return
+ SIGTRAP without actually waiting for anything. */
+
+/******************************************************* UDI_CREATE_INFERIOR */
+/* 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;
+{
+ DENTER("udi_create_inferior()");
+
+ if (execfile)
+ { if (prog_name != NULL)
+ free (prog_name);
+ prog_name = savestring (execfile, strlen (execfile));
+ }
+
+ if (prog_name == 0 /* || exec_bfd == 0 */ )
+ error ("No exec file specified");
+
+ if (udi_session_id < 0){
+ printf("UDI connection not open yet.\n");
+ return;
+ }
+
+#if defined(ULTRA3) && defined(KERNEL_DEBUGGING)
+ /* On ultra3 (NYU) we assume the kernel is already running so there is
+ * no file to download
+ */
+#else
+ if(*args == '\0') args = prog_name;
+ udi_load(args, 0);
+#endif /* !ULTRA3 */
+
+ /* We will get a task spawn event immediately. */
+#ifdef NOTDEF /* start_remote() now does a wait without a resume
+ so don't use it*/
+ start_remote ();
+#else
+ init_wait_for_inferior ();
+ clear_proceed_status ();
+ proceed(-1,-1,0);
+#endif
+ DEXIT("udi_create_inferior()");
+}
+/******************************************************* UDI_MOURN_INFERIOR */
+static void
+udi_mourn()
+{
+ DENTER("udi_mourn()");
+ pop_target (); /* Pop back to no-child state */
+ generic_mourn_inferior ();
+ DEXIT("udi_mourn()");
+}
+
+/******************************************************************** 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> [progname]' for example.
+ */
+
+static char *udi_config_id;
+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;
+
+ DENTER("udi_open()");
+
+ /* Find the first whitespace character, it separates udi_config_id
+ from prog_name. */
+ if(!name) goto erroid;
+ for (p = name;
+ *p != '\0' && !isspace (*p); p++)
+ ;
+ if (*p == '\0')
+erroid:
+ error("Usage: target udi config_id progname, where config_id appears in udi_soc file");
+ udi_config_id = (char*)malloc (p - name + 1);
+ strncpy (udi_config_id, name, p - name);
+ udi_config_id[p - name] = '\0';
+
+ /* Skip over the whitespace after udi_config_id */
+ for (; isspace (*p); p++)
+ /*EMPTY*/;
+
+ if (prog_name != NULL)
+ free (prog_name);
+ prog_name = savestring (p, strlen (p));
+
+ if (udi_session_id >= 0)
+ close (udi_session_id);
+
+ if(UDIConnect(udi_config_id, &udi_session_id))
+ fprintf(stderr, "UDIConnect() failed: %s\n", dfe_errmsg);
+ push_target (&udi_ops);
+
+#ifndef HAVE_TERMIO
+#ifndef NO_SIGINTERRUPT
+ /* Cause SIGALRM's to make reads fail with EINTR instead of resuming
+ the read. */
+ if (siginterrupt (SIGALRM, 1) != 0)
+ perror ("udi_open: error in siginterrupt");
+#endif
+
+ /* Set up read timeout timer. */
+ if ((void (*)) signal (SIGALRM, udi_timer) == (void (*)) -1)
+ perror ("udi_open: error in signal");
+#endif
+
+#if defined (LOG_FILE)
+ log_file = fopen (LOG_FILE, "w");
+ if (log_file == NULL)
+ perror (LOG_FILE);
+#endif
+ /*
+ ** Initialize target configuration structure (global)
+ */
+ if(UDIGetTargetConfig( KnownMemory, &NumberOfRanges,
+ ChipVersions, &NumberOfChips))
+ error ("UDIGetTargetConfig() failed");
+ if(NumberOfChips > 2)
+ fprintf(stderr,"Taret has more than one processor\n");
+ for(cnt=0; cnt<NumberOfRanges; cnt++)
+ { switch(KnownMemory[cnt].Space)
+ {
+ default: fprintf(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;
+ }
+ }
+
+ /* Determine the processor revision level */
+ prl = (unsigned int)read_register(CFG_REGNUM) >> 24;
+ if ((prl&0xe0) == 0)
+ { fprintf_filtered(stderr,
+ "Remote debugging Am29000 rev %c\n",'A'+(prl&0x1f));
+ processor_type = TYPE_A29000;
+ } else if ((prl&0xe0) == 0x40) /* 29030 = 0x4* */
+ { fprintf_filtered(stderr,
+ "Remote debugging Am2903* rev %c\n",'A'+(prl&0x1f));
+ processor_type = TYPE_A29030;
+ } else if ((prl&0xe0) == 0x20) /* 29050 = 0x2* */
+ { fprintf_filtered(stderr,
+ "Remote debugging Am29050 rev %c\n",'A'+(prl&0x1f));
+ processor_type = TYPE_A29050;
+ } else {
+ processor_type = TYPE_UNKNOWN;
+ fprintf_filtered(stderr,"WARNING: processor type unknown.\n");
+ }
+ if(UDICreateProcess(&PId))
+ fprintf(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("Remote debugging an %s 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",
+ processor_name[processor_type],
+ (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);
+#ifdef ULTRA3
+ /* FIXME: can this restriction be removed? */
+ printf_filtered("Remote debugging using virtual addresses works only\n");
+ printf_filtered(" when virtual addresses map 1:1 to physical addresses.\n");
+#endif
+ }
+#ifdef ULTRA3
+ if (processor_type != TYPE_A29050) {
+ fprintf_filtered(stderr,
+ "Freeze-mode debugging can only be done on an Am29050,\n");
+ fprintf_filtered(stderr,
+ " unless GDB is being used with a 29K simulator.\n");
+ }
+#endif
+}
+
+/******************************************************************* 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;
+{
+ int Terminate = -1;
+ DENTER("udi_close()");
+
+ if (udi_session_id < 0)
+ error ("Can't close udi connection: not debugging remotely.");
+
+ /* We should never get here if there isn't something valid in
+ udi_session_id.
+
+ if(UDIDisconnect(udi_stream, Terminate);)
+ error ("UDIDisconnect() failed in udi_close");
+
+ /* Do not try to close udi_session_id again, later in the program. */
+ udi_session_id = -1;
+
+#if defined (LOG_FILE)
+ if (ferror (log_file))
+ printf ("Error writing log file.\n");
+ if (fclose (log_file) != 0)
+ printf ("Error closing log file.\n");
+#endif
+
+ printf ("Ending remote debugging\n");
+
+ DEXIT("udi_close()");
+}
+
+/**************************************************************** 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;
+ DENTER("udi_attach()");
+
+ if (udi_session_id < 0)
+ printf ("UDI connection not opened yet, use the 'target udi' command.\n");
+
+ if (from_tty)
+ printf ("Attaching to remote program %s...\n", prog_name);
+
+ mark_breakpoints_out ();
+ UDIStop();
+ From.Space = 11;
+ From.Offset = UDI29KSpecialRegs;
+ if(UDIRead(From, &PC_adds, Count, Size, &CountDone, HostEndian))
+ error ("UDIRead failed in udi_attach");
+ printf ("Remote process is now halted, pc1 = 0x%x.\n", PC_adds);
+
+ DEXIT("udi_attach()");
+}
+/************************************************************* 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;
+{
+ DENTER("udi_dettach()");
+ remove_breakpoints(); /* Just in case there were any left in */
+ if(UDIDisconnect(udi_session_id))
+ error ("UDIDisconnect() failed in udi_detach");
+ pop_target(); /* calls udi_close to do the real work */
+ if (from_tty)
+ printf ("Ending remote debugging\n");
+ DEXIT("udi_dettach()");
+}
+
+
+/****************************************************************** UDI_RESUME
+** Tell the remote machine to resume. */
+
+static void
+udi_resume (step, sig)
+ int step, sig;
+{
+ UDIError tip_error;
+ UDIUInt32 Steps = 1;
+ UDIStepType StepType = UDIStepNatural;
+ UDIRange Range;
+ DENTER("udi_resume()");
+ if (step) /* step 1 instruction */
+ { tip_error = tip_error = UDIStep(Steps, StepType, Range);
+ if(tip_error)fprintf(stderr, "UDIStep() error = %d\n", tip_error);
+ if(tip_error)error ("failed in udi_resume");
+
+ }
+ else
+ { if(UDIExecute())
+ error ("UDIExecute() failed in udi_resume");
+ }
+
+ DEXIT("udi_resume()");
+}
+
+/******************************************************************** UDI_WAIT
+** Wait until the remote machine stops, then return,
+ storing status in STATUS just as `wait' would. */
+
+static int
+udi_wait (status)
+ WAITTYPE *status;
+{
+ UDIInt32 MaxTime;
+ UDIPId PId;
+ UDIInt32 StopReason;
+ UDISizeT CountDone;
+ int old_timeout = timeout;
+ int old_immediate_quit = immediate_quit;
+ int i;
+
+ DENTER("udi_wait()");
+ WSETEXIT ((*status), 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 & 0xff)
+ {
+ default:
+ goto halted;
+ case UDIStdoutReady:
+ if(UDIGetStdout(sbuf, (UDISizeT)SBUF_MAX, &CountDone))
+ error("UDIGetStdin() failed in udi_wait");
+ while(CountDone--)putc(sbuf[i++], stdout);
+ fflush(stdout);
+ break;
+ case UDIStderrReady:
+ UDIGetStderr(sbuf, (UDISizeT)SBUF_MAX, &CountDone);
+ while(CountDone--)putc(sbuf[i++], stderr);
+ fflush(stderr);
+ fflush(stderr);
+ break;
+ case UDIStdinNeeded:
+ printf("DEBUG: stdin requested ... continue\n");
+/* UDIPutStdin(sbuf, (UDISizeT)i, &CountDone); */
+ break;
+ case UDIStdinModeX:
+ break;
+ }
+ continue;
+ }
+halted:
+ if (StopReason & 0xff == UDITrapped ) /* lower 8-bits == 0 */
+ {
+ if (StopReason >> 24 == 0)
+ { printf("Am290*0 received vector number 0 (break point)\n");
+ WSETSTOP ((*status), SIGTRAP);
+ }
+ else if (StopReason >> 24 == 1)
+ { printf("Am290*0 received vector 1\n");
+ WSETSTOP ((*status), SIGBUS);
+ }
+ else if (StopReason >> 24 == 3
+ || StopReason >> 24 == 4)
+ { printf("Am290*0 received vector number %d\n",
+ StopReason >> 24);
+ WSETSTOP ((*status), SIGFPE);
+ }
+ else if (StopReason >> 24 == 5)
+ { printf("Am290*0 received vector number %d\n",
+ StopReason >> 24);
+ WSETSTOP ((*status), SIGILL);
+ }
+ else if (StopReason >> 24 >= 6
+ && StopReason >> 24 <= 11)
+ { printf("Am290*0 received vector number %d\n",
+ StopReason >> 24);
+ WSETSTOP ((*status), SIGSEGV);
+ }
+ else if (StopReason >> 24 == 12
+ || StopReason >> 24 == 13)
+ { printf("Am290*0 received vector number %d\n",
+ StopReason >> 24);
+ WSETSTOP ((*status), SIGILL);
+ }
+ else if ((StopReason & 0xff) == 14)
+ { printf("Am290*0 received vector number %d\n",
+ StopReason >> 24);
+ WSETSTOP ((*status), SIGALRM);
+ }
+ else if ((StopReason & 0xff) == 15)
+ WSETSTOP ((*status), SIGTRAP);
+ else if ((StopReason >> 24) >= 16
+ && (StopReason >> 24) <= 21)
+ { printf("Am290*0 received vector number %d\n",
+ StopReason >> 24);
+ WSETSTOP ((*status), SIGINT);
+ }
+ else if ((StopReason & 0xff) == 22)
+ { printf("Am290*0 received vector number %d\n",
+ StopReason >> 24);
+ WSETSTOP ((*status), SIGILL);
+ }
+ else if ((StopReason & 0xff) == 77)
+ WSETSTOP ((*status), SIGTRAP);
+ else
+exit:
+ WSETEXIT ((*status), 0);
+ }
+ else if ((StopReason & 0xff) == UDIBreak)
+ WSETSTOP ((*status), SIGTRAP);
+ else if ((StopReason & 0xff) == UDINotExecuting)
+ WSETSTOP ((*status), SIGTERM);
+ else if ((StopReason & 0xff) == UDIRunning)
+ WSETSTOP ((*status), SIGILL);
+ else if ((StopReason & 0xff) == UDIStopped)
+ WSETSTOP ((*status), SIGTSTP);
+ else if ((StopReason & 0xff) == UDIWarned)
+ WSETSTOP ((*status), SIGLOST);
+ else if ((StopReason & 0xff) == UDIStepped)
+ WSETSTOP ((*status), SIGTRAP);
+ else if ((StopReason & 0xff) == UDIWaiting)
+ WSETSTOP ((*status), SIGSTOP);
+ else if ((StopReason & 0xff) == UDIHalted)
+ WSETSTOP ((*status), SIGKILL);
+ else
+ WSETEXIT ((*status), 0);
+
+ timeout = old_timeout; /* Restore original timeout value */
+ immediate_quit = old_immediate_quit;
+ DEXIT("udi_wait()");
+ return 0;
+}
+
+/********************************************************** 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;
+ int i;
+
+ if (regno >= 0) {
+ fetch_register(regno);
+ return;
+ }
+ DENTER("udi_fetch_registers()");
+
+/* Gr1/rsp */
+ From.Space = UDI29KGlobalRegs;
+ From.Offset = 1;
+ To = (UDIUInt32*)&registers[4 * GR1_REGNUM];
+ Count = 1;
+ if(UDIRead(From, To, Count, Size, &CountDone, HostEndian))
+ error("UDIRead() failed in udi_fetch_registers");
+ else register_valid[4 * GR1_REGNUM] = 1;
+
+#if defined(GR64_REGNUM) /* Read gr64-127 */
+/* Global Registers gr64-gr95 */
+ From.Space = UDI29KGlobalRegs;
+ From.Offset = 64;
+ To = &registers[4 * GR64_REGNUM];
+ Count = 32;
+ if(UDIRead(From, To, Count, Size, &CountDone, HostEndian))
+ error("UDIRead() failed in udi_fetch_registers");
+ else for(i = 4 * GR64_REGNUM; i < 4*GR64_REGNUM + 32; i++)
+#endif /* GR64_REGNUM */
+
+/* Global Registers gr96-gr127 */
+ From.Space = UDI29KGlobalRegs;
+ From.Offset = 64;
+ To = (UDIUInt32*)&registers[4 * GR96_REGNUM];
+ Count = 32;
+ if(UDIRead(From, To, Count, Size, &CountDone, HostEndian))
+ error("UDIRead() failed in udi_fetch_registers");
+ else for(i = 4 * GR96_REGNUM; i < 4*GR96_REGNUM + 32; i++)
+ register_valid[i] = 1;
+
+/* Local Registers */
+ From.Space = UDI29KLocalRegs;
+ From.Offset = 0;
+ To = (UDIUInt32*)&registers[4 * LR0_REGNUM];
+ Count = 128;
+ if(UDIRead(From, To, Count, Size, &CountDone, HostEndian))
+ error("UDIRead() failed in udi_fetch_registers");
+ else for(i = 4 * LR0_REGNUM; i < 4*LR0_REGNUM + 128; i++)
+ register_valid[i] = 1;
+
+/* Protected Special Registers */
+ From.Space = UDI29KSpecialRegs;
+ From.Offset = 0;
+ To = (UDIUInt32*)&registers[4 * SR_REGNUM(0)];
+ Count = 15;
+ if(UDIRead(From, To, Count, Size, &CountDone, HostEndian))
+ error("UDIRead() failed in udi_fetch_registers");
+ else for(i = 4 * SR_REGNUM(0); i < 4*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*/
+ if (USE_SHADOW_PC) /* Let regno_to_srnum() handle the register number */
+ { From.Space = UDI29KSpecialRegs;
+ From.Offset = 128;
+ To = (UDIUInt32*)&registers[4 * SR_REGNUM(128)];
+ Count = 135-128 +1;
+ if(UDIRead(From, To, Count, Size, &CountDone, HostEndian))
+ error("UDIRead() failed in udi_fetch_registers");
+ else for(i = 4 * SR_REGNUM(128); i < 4*SR_REGNUM(128) + 135-128+1; i++)
+ register_valid[i] = 1;
+ }
+
+ /* There doesn't seem to be any way to get these. */
+ {
+ int val = -1;
+ supply_register (FPE_REGNUM, (char *) &val);
+ supply_register (INT_REGNUM, (char *) &val);
+ supply_register (FPS_REGNUM, (char *) &val);
+ supply_register (EXO_REGNUM, (char *) &val);
+ }
+
+ DEXIT("udi_fetch_registerS()");
+}
+
+
+/********************************************************* 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;
+ }
+
+ DENTER("udi_store_registers()");
+
+/* Gr1/rsp */
+ From = (UDIUInt32*)&registers[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*)&registers[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*)&registers[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*)&registers[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*)&registers[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*)&registers[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");
+
+ /* LRU and MMU */
+ From = (UDIUInt32*)&registers[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*)&registers[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 ();
+ DEXIT("udi_store_registers() failed in udi_store_regisetrs");
+}
+
+/****************************************************** 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 ("\tAttached to UDI socket to %s and running program %s.\n",
+ udi_config_id, prog_name);
+}
+
+/**************************************************** UDI_INSERT_BREAKPOINT */
+static int
+udi_insert_breakpoint (addr, contents_cache)
+ CORE_ADDR addr;
+ char *contents_cache;
+{
+ int cnt = 0;
+ DENTER("udi_insert_breakpoint()");
+
+ while( cnt < MAX_BKPT) /* find BKPT slot in table */
+ if( !(bkpt_table[cnt].Type) )
+ break;
+ else cnt++;
+ if(cnt >= MAX_BKPT)
+ { error("Too many breakpoints set");
+ DEXIT("udi_insert_breakpoint() failure");
+ return 1; /* Failure */
+ }
+ bkpt_table[cnt].Addr.Offset = addr;
+ bkpt_table[cnt].Addr.Space = UDI29KIRAMSpace;
+ bkpt_table[cnt].PassCount = 1;
+ bkpt_table[cnt].Type = UDIBreakFlagExecute;
+
+ if( UDISetBreakpoint(bkpt_table[cnt].Addr,
+ bkpt_table[cnt].PassCount,
+ bkpt_table[cnt].Type,
+ &bkpt_table[cnt].BreakId) )
+ { error("UDISetBreakpoint() failed in udi_insert_breakpoint");
+ bkpt_table[cnt].Type = 0;
+ DEXIT("udi_insert_breakpoint() failure");
+ return 1; /* Failure */
+ } else
+ { DEXIT("udi_insert_breakpoint() success");
+ return 0; /* Success */
+ }
+}
+
+/**************************************************** UDI_REMOVE_BREAKPOINT */
+static int
+udi_remove_breakpoint (addr, contents_cache)
+ CORE_ADDR addr;
+ char *contents_cache;
+{
+ int cnt = 0;
+ DENTER("udi_remove_breakpoint()");
+
+ while( cnt < MAX_BKPT) /* find BKPT slot in table */
+ if(bkpt_table[cnt].Addr.Offset = addr ) break;
+ else cnt++;
+ if(cnt >= MAX_BKPT)
+ { error("Can't find breakpoint in table");
+ DEXIT("udi_remove_breakpoint() failure");
+ return 1; /* Failure */
+ }
+ bkpt_table[cnt].Type = 0;
+
+ if ( !UDIClearBreakpoint(bkpt_table[cnt].BreakId)) {
+ DEXIT("udi_remove_breakpoint()");
+ return 0; /* Success */
+ } else {
+ DEXIT("udi_remove_breakpoint()");
+ error("UDIClearBreakpoint() failed in udi_remove_breakpoint");
+ return 1; /* Failure */
+ }
+}
+
+
+/***************************************************************** UDI_KILL */
+static void
+udi_kill(arg,from_tty)
+char *arg;
+int from_tty;
+{
+ char buf[4];
+
+ DENTER("udi_kill()");
+#if defined(ULTRA3) && defined(KERNEL_DEBUGGING)
+ /* We don't ever kill the kernel */
+ if (from_tty) {
+ printf("Kernel not killed, but left in current state.\n");
+ printf("Use detach to leave kernel running.\n");
+ }
+#else
+ UDIStop();
+ if (from_tty) {
+ printf("Target has been stopped.");
+ }
+ pop_target();
+#endif
+ DEXIT("udi_kill()");
+}
+
+
+
+/***************************************************************** UDI_LOAD */
+/*
+ * Load a program into the target.
+ */
+static void
+udi_load(arg_string,from_tty)
+char *arg_string;
+int from_tty;
+{
+#define MAX_TOKENS 25
+#define BUFFER_SIZE 256
+ int token_count;
+ char *token[MAX_TOKENS];
+ char cmd_line[BUFFER_SIZE];
+
+ dont_repeat ();
+
+#if defined(KERNEL_DEBUGGING) && defined(ULTRA3)
+ printf("The kernel had better be loaded already! Loading not done.\n");
+#else
+ if (arg_string == 0)
+ error ("The load command takes a file name");
+ arg_string = tilde_expand (arg_string);
+ sprintf(cmd_line,"y %s %s", prog_name, arg_string);
+
+ token_count = 0;
+ token[0] = cmd_line;
+
+ if (cmd_line[0] != '\0')
+ { token[token_count] = strtok(cmd_line, " \t,;\n\r");
+
+ if (token[token_count] != NULL)
+ { do {
+ token_count = token_count + 1;
+ token[token_count] = strtok((char *) NULL, " \t,;\n\r");
+ } while ((token[token_count] != NULL) &&
+ (token_count < MAX_TOKENS));
+ }
+ else
+ *token[0] = '\0';
+ }
+ make_cleanup (free, arg_string);
+ QUIT;
+ immediate_quit++;
+ if(yank_cmd(token, token_count))
+ error("Failure when tring to load program");
+ immediate_quit--;
+ symbol_file_add (arg_string, from_tty, 0, 0, 0, 0);/*DEBUG need to add text_addr */
+#endif
+
+}
+
+/*************************************************** 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;
+
+
+ /* DENTER("udi_write_inferior_memory()"); */
+ 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_inferrior_memory");
+ break;
+ }
+ else
+ { nwritten += CountDone;
+ From += CountDone;
+ }
+ }
+ /* DEXIT("udi_write_inferior_memory()"); */
+ 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;
+
+
+ /* DENTER("udi_read_inferior_memory()"); */
+ 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(UDIRead(From, To, Count, Size, &CountDone, HostEndian))
+ { error("UDIWrite() failed in udi_read_inferrior_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 int
+fetch_register (regno)
+ int regno;
+{
+ UDIResource From;
+ UDIUInt32 To;
+ UDICount Count = 1;
+ UDISizeT Size = 4;
+ UDICount CountDone;
+ UDIBool HostEndian = 0;
+ int result;
+
+ DENTER("udi_fetch_register()");
+
+ if (regno == GR1_REGNUM)
+ { From.Space = UDI29KGlobalRegs;
+ From.Offset = 1;
+ result = UDIRead(From, &To, Count, Size, &CountDone, HostEndian);
+ }
+ else if (regno >= GR96_REGNUM && regno < GR96_REGNUM + 32)
+ { From.Space = UDI29KGlobalRegs;
+ From.Offset = (regno - GR96_REGNUM) + 96;;
+ result = UDIRead(From, &To, Count, Size, &CountDone, HostEndian);
+ }
+#if defined(GR64_REGNUM)
+ else if (regno >= GR64_REGNUM && regno < GR64_REGNUM + 32 )
+ { From.Space = UDI29KGlobalRegs;
+ From.Offset = (regno - GR64_REGNUM) + 64;
+ result = UDIRead(From, &To, Count, Size, &CountDone, HostEndian);
+ }
+#endif /* GR64_REGNUM */
+ else if (regno >= LR0_REGNUM && regno < LR0_REGNUM + 128)
+ { From.Space = UDI29KLocalRegs;
+ From.Offset = (regno - LR0_REGNUM);
+ result = UDIRead(From, &To, Count, Size, &CountDone, HostEndian);
+ }
+ else if (regno>=FPE_REGNUM && regno<=EXO_REGNUM)
+ { int val = -1;
+ supply_register(160 + (regno - FPE_REGNUM),(char *) &val);
+ return 0; /* Pretend Success */
+ }
+ else
+ { From.Space = UDI29KSpecialRegs;
+ From.Offset = regnum_to_srnum(regno);
+ result = UDIRead(From, &To, Count, Size, &CountDone, HostEndian);
+ }
+ DEXIT("udi_fetch_register()");
+ if(result)
+ { result = -1;
+ error("UDIRead() failed in udi_fetch_registers");
+ }
+ supply_register(regno, (char *) &To);
+ return result;
+}
+/*****************************************************************************/
+/* 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;
+
+ DENTER("store_register()");
+ From = read_register (regno); /* get data value */
+
+ 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 /* An unprotected or protected special register */
+ { To.Space = UDI29KSpecialRegs;
+ To.Offset = regnum_to_srnum(regno);
+ result = UDIWrite(&From, To, Count, Size, &CountDone, HostEndian);
+ }
+
+ DEXIT("store_register()");
+ if(result)
+ { result = -1;
+ error("UDIWrite() failed in store_registers");
+ }
+ return result;
+}
+/********************************************************** 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 INT_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() {;}
+FILE* EchoFile = 0; /* used for debugging */
+int QuietMode = 0; /* used for debugging */
+
+/****************************************************************************/
+/*
+ * Define the target subroutine names
+ */
+static struct target_ops udi_ops = {
+ "udi", "Remote UDI connected TIP",
+ "Remote debug an Am290*0 using socket connection to TIP process ",
+ udi_open, udi_close,
+ udi_attach, udi_detach, udi_resume, udi_wait,
+ udi_fetch_registers, udi_store_registers,
+ udi_prepare_to_store, 0, 0, /* conv_to, conv_from */
+ udi_xfer_inferior_memory,
+ udi_files_info,
+ udi_insert_breakpoint, udi_remove_breakpoint, /* Breakpoints */
+ 0, 0, 0, 0, 0, /* Terminal handling */
+ udi_kill, /* FIXME, kill */
+ udi_load,
+ 0, /* lookup_symbol */
+ udi_create_inferior, /* create_inferior */
+ udi_mourn, /* mourn_inferior FIXME */
+ process_stratum, 0, /* next */
+ 1, 1, 1, 1, 1, /* all mem, mem, stack, regs, exec */
+ 0, 0, /* Section pointers */
+ OPS_MAGIC, /* Always the last thing */
+};
+
+void _initialize_remote_udi()
+{
+ add_target (&udi_ops);
+}
+
+#ifdef NO_HIF_SUPPORT
+service_HIF(msg)
+union msg_t *msg;
+{
+ return(0); /* Emulate a failure */
+}
+#endif
generated by cgit v1.1 at 2024-12-25 20:11:09 +0000