/* Remote debugging interface for AMD 29k interfaced via UDI, for GDB.
- Copyright 1990, 1992 Free Software Foundation, Inc.
+ Copyright 1990, 1992, 1995 Free Software Foundation, Inc.
Written by Daniel Mann. Contributed by AMD.
This file is part of GDB.
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., 675 Mass Ave, Cambridge, MA 02139, USA. */
+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
- 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. 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.
+ 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 <fcntl.h>
#include <signal.h>
#include <errno.h>
-#include <string.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. */
-static int kiodebug;
extern int stop_soon_quietly; /* for wait_for_inferior */
extern struct value *call_function_by_hand();
-static void udi_resume PARAMS ((int step, int sig));
+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));
int len));
static void download PARAMS ((char *load_arg_string, int from_tty));
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
+#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 */
starts. */
UDISessionId udi_session_id = -1;
+static char *udi_config_id;
CPUOffset IMemStart = 0;
CPUSizeT IMemSize = 0;
static bkpt_entry_t bkpt_table[BKPT_TABLE_SIZE];
extern char dfe_errmsg[]; /* error string */
-/* Called when SIGALRM signal sent due to alarm() timeout. */
-#ifndef HAVE_TERMIO
-
-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. */
-
/* This is called not only when we first attach, but also when the
user types "run" after having attached. */
if (udi_session_id < 0)
{
- printf("UDI connection not open yet.\n");
- return;
+ /* 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;
args1 = alloca (strlen(execfile) + strlen(args) + 2);
- strcpy (args1, execfile);
+ 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);
init_wait_for_inferior ();
clear_proceed_status ();
- proceed(-1,-1,0);
+ proceed (-1, TARGET_SIGNAL_DEFAULT, 0);
}
static void
udi_mourn()
{
- pop_target (); /* Pop back to no-child state */
- generic_mourn_inferior ();
+#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
/* XXX - need cleanups for udiconnect for various failures!!! */
-static char *udi_config_id;
static void
udi_open (name, from_tty)
char *name;
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);
-#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)
- error ("udi_open: siginterrupt() %s", safe_strerror(errno));
-#endif
-
- /* Set up read timeout timer. */
- if ((void (*)) signal (SIGALRM, udi_timer) == (void (*)) -1)
- error ("udi_open: signal() %s", safe_strerror(errno));
-#endif
-
-#if defined (LOG_FILE)
- log_file = fopen (LOG_FILE, "w");
- if (log_file == NULL)
- error ("udi_open: fopen(%s) %s", LOG_FILE, safe_strerror(errno));
-#endif
/*
** Initialize target configuration structure (global)
*/
ChipVersions, &NumberOfChips))
error ("UDIGetTargetConfig() failed");
if (NumberOfChips > 2)
- fprintf(stderr,"Target has more than one processor\n");
+ fprintf_unfiltered(gdb_stderr,"Target has more than one processor\n");
for (cnt=0; cnt < NumberOfRanges; cnt++)
{
switch(KnownMemory[cnt].Space)
{
default:
- fprintf(stderr, "UDIGetTargetConfig() unknown memory space\n");
+ fprintf_unfiltered(gdb_stderr, "UDIGetTargetConfig() unknown memory space\n");
break;
case UDI29KCP_S:
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");
- }
+ a29k_get_processor_type ();
+
if (UDICreateProcess (&PId))
- fprintf(stderr, "UDICreateProcess() failed\n");
+ 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,
error ("UDICapabilities() failed");
if (from_tty)
{
- printf_filtered ("Remote debugging an %s connected via UDI socket,\n\
+ 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",
- 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,
return;
/* We should never get here if there isn't something valid in
- udi_session_id. */
+ udi_session_id. */
if (UDIDisconnect (udi_session_id, UDITerminateSession))
- error ("UDIDisconnect() failed in udi_close");
+ {
+ 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;
-#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_filtered (" Ending remote debugging\n");
}
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 ("Attaching to remote program %s...\n", prog_name);
+ 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 ("Remote process is now halted, pc1 = 0x%x.\n", PC_adds);
+ printf_unfiltered ("Remote process is now halted, pc1 = 0x%x.\n", PC_adds);
}
/************************************************************* UDI_DETACH */
/* Terminate the open connection to the TIP process.
if (UDIDisconnect (udi_session_id, UDIContinueSession))
error ("UDIDisconnect() failed in udi_detach");
- pop_target(); /* calls udi_close to do the real work */
+ /* 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 ("Ending remote debugging\n");
+ printf_unfiltered ("Detaching from TIP\n");
}
** Tell the remote machine to resume. */
static void
-udi_resume (step, sig)
- int step, sig;
+udi_resume (pid, step, sig)
+ int pid, step;
+ enum target_signal sig;
{
UDIError tip_error;
UDIUInt32 Steps = 1;
if (!tip_error)
return;
- fprintf (stderr, "UDIStep() error = %d\n", tip_error);
+ fprintf_unfiltered (gdb_stderr, "UDIStep() error = %d\n", tip_error);
error ("failed in udi_resume");
}
storing status in STATUS just as `wait' would. */
static int
-udi_wait (status)
- WAITTYPE *status;
+udi_wait (pid, status)
+ int pid;
+ struct target_waitstatus *status;
{
UDIInt32 MaxTime;
UDIPId PId;
int old_immediate_quit = immediate_quit;
int i;
- WSETEXIT ((*status), 0);
+ 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.
{
case UDIStdoutReady:
if (UDIGetStdout (sbuf, (UDISizeT)SBUF_MAX, &CountDone))
- error ("UDIGetStdout() failed in udi_wait");
- fwrite (sbuf, 1, CountDone, stdout);
- fflush(stdout);
+ /* 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, gdb_stdout);
+ gdb_flush(gdb_stdout);
continue;
+
case UDIStderrReady:
UDIGetStderr (sbuf, (UDISizeT)SBUF_MAX, &CountDone);
- fwrite (sbuf, 1, CountDone, stderr);
- fflush(stderr);
+ fwrite (sbuf, 1, CountDone, gdb_stderr);
+ gdb_flush(gdb_stderr);
continue;
+
case UDIStdinNeeded:
- scanf ("%s", sbuf);
- i = strlen (sbuf);
- UDIPutStdin (sbuf, (UDISizeT)i, &CountDone);
- continue;
+ {
+ 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. */
switch (StopReason & UDIGrossState)
{
case UDITrapped:
- printf("Am290*0 received vector number %d\n", StopReason >> 24);
+ printf_unfiltered("Am290*0 received vector number %d\n", StopReason >> 24);
- switch (StopReason >> 8)
+ switch ((StopReason >> 8 ) & 0xff)
{
case 0: /* Illegal opcode */
- printf(" (break point)\n");
- WSETSTOP ((*status), SIGTRAP);
+ printf_unfiltered(" (break point)\n");
+ status->kind = TARGET_WAITKIND_STOPPED;
+ status->value.sig = TARGET_SIGNAL_TRAP;
break;
case 1: /* Unaligned Access */
- WSETSTOP ((*status), SIGBUS);
+ status->kind = TARGET_WAITKIND_STOPPED;
+ status->value.sig = TARGET_SIGNAL_BUS;
break;
case 3:
case 4:
- WSETSTOP ((*status), SIGFPE);
+ status->kind = TARGET_WAITKIND_STOPPED;
+ status->value.sig = TARGET_SIGNAL_FPE;
break;
case 5: /* Protection Violation */
- WSETSTOP ((*status), SIGILL);
+ 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 9: /* User Data Mapping Miss */
case 10: /* Supervisor Instruction Mapping Miss */
case 11: /* Supervisor Data Mapping Miss */
- WSETSTOP ((*status), SIGSEGV);
+ status->kind = TARGET_WAITKIND_STOPPED;
+ status->value.sig = TARGET_SIGNAL_SEGV;
break;
case 12:
case 13:
- WSETSTOP ((*status), SIGILL);
+ status->kind = TARGET_WAITKIND_STOPPED;
+ status->value.sig = TARGET_SIGNAL_ILL;
break;
case 14: /* Timer */
- WSETSTOP ((*status), SIGALRM);
+ status->kind = TARGET_WAITKIND_STOPPED;
+ status->value.sig = TARGET_SIGNAL_ALRM;
break;
case 15: /* Trace */
- WSETSTOP ((*status), SIGTRAP);
+ status->kind = TARGET_WAITKIND_STOPPED;
+ status->value.sig = TARGET_SIGNAL_TRAP;
break;
case 16: /* INTR0 */
case 17: /* INTR1 */
case 19: /* INTR3/Internal */
case 20: /* TRAP0 */
case 21: /* TRAP1 */
- WSETSTOP ((*status), SIGINT);
+ status->kind = TARGET_WAITKIND_STOPPED;
+ status->value.sig = TARGET_SIGNAL_INT;
break;
case 22: /* Floating-Point Exception */
- WSETSTOP ((*status), SIGILL);
+ status->kind = TARGET_WAITKIND_STOPPED;
+ /* Why not FPE? */
+ status->value.sig = TARGET_SIGNAL_ILL;
break;
case 77: /* assert 77 */
- WSETSTOP ((*status), SIGTRAP);
+ status->kind = TARGET_WAITKIND_STOPPED;
+ status->value.sig = TARGET_SIGNAL_TRAP;
break;
default:
- WSETEXIT ((*status), 0);
+ status->kind = TARGET_WAITKIND_EXITED;
+ status->value.integer = 0;
}
break;
case UDINotExecuting:
- WSETSTOP ((*status), SIGTERM);
+ status->kind = TARGET_WAITKIND_STOPPED;
+ status->value.sig = TARGET_SIGNAL_TERM;
break;
case UDIStopped:
- WSETSTOP ((*status), SIGTSTP);
+ status->kind = TARGET_WAITKIND_STOPPED;
+ status->value.sig = TARGET_SIGNAL_TSTP;
break;
case UDIWarned:
- WSETSTOP ((*status), SIGURG);
+ status->kind = TARGET_WAITKIND_STOPPED;
+ status->value.sig = TARGET_SIGNAL_URG;
break;
case UDIStepped:
case UDIBreak:
- WSETSTOP ((*status), SIGTRAP);
+ status->kind = TARGET_WAITKIND_STOPPED;
+ status->value.sig = TARGET_SIGNAL_TRAP;
break;
case UDIWaiting:
- WSETSTOP ((*status), SIGSTOP);
+ status->kind = TARGET_WAITKIND_STOPPED;
+ status->value.sig = TARGET_SIGNAL_STOP;
break;
case UDIHalted:
- WSETSTOP ((*status), SIGKILL);
+ status->kind = TARGET_WAITKIND_STOPPED;
+ status->value.sig = TARGET_SIGNAL_KILL;
break;
case UDIExited:
default:
- WSETEXIT ((*status), 0);
+ status->kind = TARGET_WAITKIND_EXITED;
+ status->value.integer = 0;
}
timeout = old_timeout; /* Restore original timeout value */
immediate_quit = old_immediate_quit;
- return 0;
+ 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'.
register_valid[i] = 1;
}
- if (kiodebug)
+ if (remote_debug)
{
- printf("Fetching all registers\n");
- printf("Fetching PC0 = 0x%x, PC1 = 0x%x, PC2 = 0x%x\n",
+ 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));
}
return;
}
- if (kiodebug)
+ if (remote_debug)
{
- printf("Storing all registers\n");
- printf("PC0 = 0x%x, PC1 = 0x%x, PC2 = 0x%x\n", read_register(NPC_REGNUM),
+ 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));
}
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)];
static void
udi_files_info ()
{
- printf ("\tAttached to UDI socket to %s and running program %s.\n",
- udi_config_id, prog_name);
+ 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 */
inferior_pid = 0;
if (from_tty)
- printf("Target has been stopped.");
-#else
+ printf_unfiltered("Target has been stopped.");
+#endif /* 0 */
+#if 0
udi_close(0);
-#endif
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;
}
/*
}
}
- pbfd = bfd_openr (filename, 0);
+ 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 (bfd_close, pbfd);
QUIT;
section_size = bfd_section_size (pbfd, section);
section_end = To.Offset + section_size;
- printf("[Loading section %s at %x (%d bytes)]\n",
+ 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);
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 */
xerr = UDIGetErrorMsg(err, 100, message, &Count);
if (!xerr)
- fprintf (stderr, "Error is %s\n", message);
+ fprintf_unfiltered (gdb_stderr, "Error is %s\n", message);
else
- fprintf (stderr, "xerr is %d\n", xerr);
+ fprintf_unfiltered (gdb_stderr, "xerr is %d\n", xerr);
error ("UDICopy failed, error = %d", err);
}
}
immediate_quit--;
}
-/* User interface to download an image into the remote target. See download()
- * for details on args.
- */
+/* Function to download an image into the remote target. */
static void
-udi_load(args, from_tty)
+udi_load (args, from_tty)
char *args;
int from_tty;
{
download (args, from_tty);
- symbol_file_add (strtok (args, " \t"), from_tty, 0, 0, 0, 0);
+ /* 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);
+
+ /* Getting new symbols may change our opinion about what is
+ frameless. */
+ reinit_frame_cache ();
}
/*************************************************** UDI_WRITE_INFERIOR_MEMORY
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");
+ { error("UDIWrite() failed in udi_write_inferior_memory");
break;
}
else
if (Count > MAXDATA) Count = MAXDATA;
From.Offset = memaddr + nread;
if(err = UDIRead(From, To, Count, Size, &CountDone, HostEndian))
- { error("UDIRead() failed in udi_read_inferrior_memory");
+ { error("UDIRead() failed in udi_read_inferior_memory");
break;
}
else
else if (regno>=FPE_REGNUM && regno<=EXO_REGNUM)
{
int val = -1;
- supply_register(160 + (regno - FPE_REGNUM),(char *) &val);
+ /*supply_register(160 + (regno - FPE_REGNUM),(char *) &val);*/
+ supply_register(regno, (char *) &val);
return; /* Pretend Success */
}
else
supply_register(regno, (char *) &To);
- if (kiodebug)
- printf("Fetching register %s = 0x%x\n", reg_names[regno], To);
+ if (remote_debug)
+ printf_unfiltered("Fetching register %s = 0x%x\n", reg_names[regno], To);
}
/*****************************************************************************/
/* Store a single register indicated by 'regno'.
From = read_register (regno); /* get data value */
- if (kiodebug)
- printf("Storing register %s = 0x%x\n", reg_names[regno], From);
+ if (remote_debug)
+ printf_unfiltered("Storing register %s = 0x%x\n", reg_names[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 ();
- }
+ {
+ 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);
- }
+ {
+ 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);
- }
+ {
+ 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)
- {
+ {
+ 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);
- }
+ {
+ To.Space = UDI29KSpecialRegs;
+ To.Offset = regnum_to_srnum(regno);
+ result = UDIWrite(&From, To, Count, Size, &CountDone, HostEndian);
+ }
- if(result)
- { result = -1;
+ if (result != 0)
error("UDIWrite() failed in store_registers");
- }
- return result;
+
+ return 0;
}
/********************************************************** REGNUM_TO_SRNUM */
/*
void convert16() {;}
void convert32() {;}
-FILE* EchoFile = 0; /* used for debugging */
+GDB_FILE * EchoFile = 0; /* used for debugging */
int QuietMode = 0; /* used for debugging */
+\f
+#ifdef NO_HIF_SUPPORT
+service_HIF(msg)
+ union msg_t *msg;
+{
+ return(0); /* Emulate a failure */
+}
+#endif
+\f
+/* 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. */
-/****************************************************************************/
-/*
- * Define the target subroutine names
- */
-static struct target_ops udi_ops = {
+struct target_ops udi_ops = {
"udi",
"Remote UDI connected TIP",
- "Remote debug an AMD 29k using UDI socket connection to TIP process",
+ "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_open,
udi_close,
udi_attach,
0, /* terminal_ours */
0, /* terminal_info */
udi_kill, /* FIXME, kill */
- udi_load,
+ udi_load, /* to_load */
0, /* lookup_symbol */
udi_create_inferior,
udi_mourn, /* mourn_inferior FIXME */
0, /* can_run */
0, /* notice_signals */
+ 0, /* to_stop */
process_stratum,
0, /* next */
1, /* has_all_memory */
OPS_MAGIC, /* Always the last thing */
};
-void _initialize_remote_udi()
+void
+_initialize_remote_udi ()
{
add_target (&udi_ops);
- add_show_from_set (
- add_set_cmd ("remotedebug", no_class, var_boolean,
- (char *)&kiodebug,
- "Set debugging of UDI I/O.\n\
-When enabled, debugging info is displayed.",
- &setlist),
- &showlist);
-}
-
-#ifdef NO_HIF_SUPPORT
-service_HIF(msg)
-union msg_t *msg;
-{
- return(0); /* Emulate a failure */
}
-#endif
projects / deliverable / binutils-gdb.git / blobdiff