1995-02-03 01:23:22 +01:00
|
|
|
|
/* Remote target communications for serial-line targets in custom GDB protocol
|
|
|
|
|
Copyright 1988, 1991, 1992, 1993, 1994 Free Software Foundation, Inc.
|
|
|
|
|
|
|
|
|
|
This file is part of GDB.
|
|
|
|
|
|
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
|
along with this program; if not, write to the Free Software
|
|
|
|
|
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
|
|
|
|
|
|
|
|
|
|
#include "defs.h"
|
* configure.in: Check for working mmap, ansi headers, string.h,
strings.h, and memory.h.
* configure: Regenerated.
* gdb_stat.h: New file, "portable" <sys/stat.h>.
* gdb_string.h: New file, "portable" <string.h>.
* altos-xdep.c, arm-tdep.c, arm-xdep.c, convex-tdep.c,
convex-xdep.c, coredep.c, cxux-nat.c, dbxread.c, exec.c,
gould-xdep.c, hppa-tdep.c, i386aix-nat.c, i386b-nat.c,
i386mach-nat.c, i386v-nat.c, infptrace.c, m88k-nat.c, main.c,
mdebugread.c, objfiles.c, os9kread.c, procfs.c, pyr-xdep.c,
rs6000-nat.c, source.c, standalone.c, stuff.c, sun386-nat.c,
symfile.c, symm-nat.c, symm-tdep.c, symtab.c, top.c, ultra3-nat.c,
ultra3-xdep.c, umax-xdep.c, xcoffread.c: Include "gdb_stat.h"
instead of <sys/stat.h>.
* alpha-tdep.c, breakpoint.c, buildsym.c, c-typeprint.c,
ch-typeprint.c, coffread.c, command.c, core-sol2.c, core-svr4.c,
core.c, corelow.c, cp-valprint.c, dbxread.c, dcache.c, demangle.c,
dpx2-nat.c, dstread.c, dwarfread.c, elfread.c, environ.c, eval.c,
exec.c, f-lang.c, f-typeprint.c, f-valprint.c, findvar.c,
fork-child.c, gdbtypes.c, hpread.c, i386-tdep.c, infcmd.c,
inflow.c, infptrace.c, infrun.c, irix5-nat.c, language.c,
m2-typeprint.c, main.c, mdebugread.c, minsyms.c, mipsread.c,
monitor.c, nlmread.c, objfiles.c, os9kread.c, osfsolib.c, parse.c,
printcmd.c, procfs.c, regex.c, remote-adapt.c, remote-arc.c,
remote-array.c, remote-bug.c, remote-e7000.c, remote-eb.c,
remote-es.c, remote-hms.c, remote-mm.c, remote-os9k.c,
remote-pa.c, remote-sim.c, remote-st.c, remote-udi.c,
remote-utils.c, remote-vx.c, remote-vx29k.c, remote-vx68.c,
remote-vx960.c, remote-vxmips.c, remote-vxsparc.c, remote.c,
solib.c, somread.c, source.c, stabsread.c, stack.c, symfile.c,
symmisc.c, symtab.c, target.c, top.c, typeprint.c, utils.c,
valarith.c, valops.c, valprint.c, values.c, xcoffread.c: Include
"gdb_string.h" instead of <string.h>.
* gdbtk.c: Likewise.
* config/xm-sysv4.h, i386/xm-ptx.h, m68k/xm-sun3os4.h,
sparc/xm-sun4os4.h (HAVE_MMAP): Removed.
* config/xm-lynx.h, config/i386/xm-ptx.h,
config/m68k/nm-apollo68b.h, config/m68k/xm-hp300hpux.h,
config/mips/xm-irix3.h, config/mips/xm-mips.h,
config/mips/xm-news-mips.h, config/mips/xm-riscos.h,
config/pa/hppah.h, config/rs6000/xm-rs6000.h,
config/sparc/xm-sun4os4.h, config/sparc/xm-sun4sol2.h,
config/vax/xm-vaxbsd.h, config/vax/xm-vaxult.h,
config/vax/xm-vaxult2.h (MEM_FNS_DECLARED): Removed.
* config/mips/xm-irix3.h, config/mips/xm-mips.h,
config/pa/xm-hppah.h (memcpy, memset): Removed declarations.
1995-08-01 22:14:27 +02:00
|
|
|
|
#include "gdb_string.h"
|
1995-02-03 01:23:22 +01:00
|
|
|
|
#include <fcntl.h>
|
|
|
|
|
#include "frame.h"
|
|
|
|
|
#include "inferior.h"
|
|
|
|
|
#include "bfd.h"
|
|
|
|
|
#include "symfile.h"
|
|
|
|
|
#include "target.h"
|
|
|
|
|
#include "wait.h"
|
|
|
|
|
#include "terminal.h"
|
|
|
|
|
#include "gdbcmd.h"
|
|
|
|
|
#include "objfiles.h"
|
|
|
|
|
#include "gdb-stabs.h"
|
|
|
|
|
|
|
|
|
|
#include "dcache.h"
|
|
|
|
|
|
|
|
|
|
#ifdef USG
|
|
|
|
|
#include <sys/types.h>
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
#include <signal.h>
|
|
|
|
|
#include "serial.h"
|
|
|
|
|
|
|
|
|
|
/* Prototypes for local functions */
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
arc_write_bytes PARAMS ((CORE_ADDR memaddr, unsigned char *myaddr, int len));
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
arc_read_bytes PARAMS ((CORE_ADDR memaddr, unsigned char *myaddr, int len));
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
arc_files_info PARAMS ((struct target_ops *ignore));
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
arc_xfer_memory PARAMS ((CORE_ADDR memaddr, char *myaddr, int len,
|
|
|
|
|
int should_write, struct target_ops *target));
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
arc_xfer_cntlreg PARAMS ((int rw, unsigned char *data));
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
arc_prepare_to_store PARAMS ((void));
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
arc_fetch_registers PARAMS ((int regno));
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
arc_resume PARAMS ((int pid, int step, enum target_signal siggnal));
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
arc_start_remote PARAMS ((char *dummy));
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
arc_open PARAMS ((char *name, int from_tty));
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
arc_close PARAMS ((int quitting));
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
arc_store_registers PARAMS ((int regno));
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
getpkt PARAMS ((char *buf, int len));
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
putpkt PARAMS ((char *buf, int len));
|
|
|
|
|
|
|
|
|
|
static int arc_wait PARAMS ((int pid, struct target_waitstatus *status));
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
arc_detach PARAMS ((char *args, int from_tty));
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
arc_interrupt PARAMS ((int signo));
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
arc_interrupt_twice PARAMS ((int signo));
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
interrupt_query PARAMS ((void));
|
|
|
|
|
|
|
|
|
|
extern struct target_ops arc_ops; /* Forward decl */
|
|
|
|
|
|
1995-03-01 02:39:12 +01:00
|
|
|
|
static int aux_reg_map[3][31] = AUX_REG_MAP;
|
1995-02-03 01:23:22 +01:00
|
|
|
|
|
|
|
|
|
/* This was 5 seconds, which is a long time to sit and wait.
|
|
|
|
|
Unless this is going though some terminal server or multiplexer or
|
|
|
|
|
other form of hairy serial connection, I would think 2 seconds would
|
|
|
|
|
be plenty. */
|
|
|
|
|
static int remote_timeout = 2;
|
|
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
|
int icache;
|
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
/* Descriptor for I/O to remote machine. Initialize it to NULL so that
|
|
|
|
|
arc_open knows that we don't have a file open when the program
|
|
|
|
|
starts. */
|
|
|
|
|
static serial_t arc_desc = NULL;
|
|
|
|
|
|
|
|
|
|
#define AUDIO_PROCESSOR 0
|
|
|
|
|
#define GRAPHIC_PROCESSOR 1
|
|
|
|
|
#define HOST_PROCESSOR 2
|
|
|
|
|
static unsigned char cntl_reg_halt_bit[3] = { 0x08, 0x10, 0x20 };
|
|
|
|
|
static unsigned char cntl_reg_step_bit[3] = { 0x01, 0x02, 0x04 };
|
|
|
|
|
|
|
|
|
|
static int curr_processor = HOST_PROCESSOR;
|
|
|
|
|
static unsigned char cntl_reg = 0;
|
|
|
|
|
static unsigned int status_reg = 0;
|
|
|
|
|
|
|
|
|
|
#define PBUFSIZ 32
|
|
|
|
|
#define MAXBUFBYTES 32
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Clean up connection to a remote debugger. */
|
|
|
|
|
|
|
|
|
|
/* ARGSUSED */
|
|
|
|
|
static void
|
|
|
|
|
arc_close (quitting)
|
|
|
|
|
int quitting;
|
|
|
|
|
{
|
|
|
|
|
if (arc_desc)
|
|
|
|
|
SERIAL_CLOSE (arc_desc);
|
|
|
|
|
arc_desc = NULL;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
arc_start_remote (dummy)
|
|
|
|
|
char *dummy;
|
|
|
|
|
{
|
|
|
|
|
immediate_quit = 1; /* Allow user to interrupt it */
|
|
|
|
|
arc_xfer_cntlreg (1, &cntl_reg);
|
|
|
|
|
immediate_quit = 0;
|
|
|
|
|
|
|
|
|
|
start_remote (); /* Initialize gdb process mechanisms */
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Open a connection to a remote debugger.
|
|
|
|
|
NAME is the filename used for communication. */
|
|
|
|
|
|
|
|
|
|
static DCACHE *remote_dcache;
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
arc_open (name, from_tty)
|
|
|
|
|
char *name;
|
|
|
|
|
int from_tty;
|
|
|
|
|
{
|
|
|
|
|
if (name == 0)
|
|
|
|
|
error (
|
|
|
|
|
"To open a arc debug connection, you need to specify what parallel\n\
|
|
|
|
|
device is attached to the remote system.");
|
|
|
|
|
|
|
|
|
|
target_preopen (from_tty);
|
|
|
|
|
|
|
|
|
|
unpush_target (&arc_ops);
|
|
|
|
|
|
|
|
|
|
remote_dcache = dcache_init (arc_read_bytes, arc_write_bytes);
|
|
|
|
|
|
|
|
|
|
arc_desc = SERIAL_OPEN (name);
|
|
|
|
|
if (!arc_desc)
|
|
|
|
|
perror_with_name (name);
|
|
|
|
|
|
|
|
|
|
/* If there is something sitting in the buffer we might take it as a
|
|
|
|
|
response to a command, which would be bad. */
|
|
|
|
|
SERIAL_FLUSH_INPUT (arc_desc);
|
|
|
|
|
|
|
|
|
|
if (from_tty)
|
|
|
|
|
{
|
|
|
|
|
puts_filtered ("Remote debugging using ");
|
|
|
|
|
puts_filtered (name);
|
|
|
|
|
puts_filtered ("\n");
|
|
|
|
|
}
|
|
|
|
|
push_target (&arc_ops); /* Switch to using remote target now */
|
|
|
|
|
|
|
|
|
|
/* Without this, some commands which require an active target (such as kill)
|
|
|
|
|
won't work. This variable serves (at least) double duty as both the pid
|
|
|
|
|
of the target process (if it has such), and as a flag indicating that a
|
|
|
|
|
target is active. These functions should be split out into seperate
|
|
|
|
|
variables, especially since GDB will someday have a notion of debugging
|
|
|
|
|
several processes. */
|
|
|
|
|
|
|
|
|
|
inferior_pid = 42000;
|
|
|
|
|
|
|
|
|
|
/* Start the remote connection; if error (0), discard this target.
|
|
|
|
|
In particular, if the user quits, be sure to discard it
|
|
|
|
|
(we'd be in an inconsistent state otherwise). */
|
|
|
|
|
if (!catch_errors (arc_start_remote, (char *)0,
|
|
|
|
|
"Couldn't establish connection to remote target\n", RETURN_MASK_ALL))
|
|
|
|
|
pop_target();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* arc_detach()
|
|
|
|
|
takes a program previously attached to and detaches it.
|
|
|
|
|
We better not have left any breakpoints
|
|
|
|
|
in the program or it'll die when it hits one.
|
|
|
|
|
Close the open connection to the remote debugger.
|
|
|
|
|
Use this when you want to detach and do something else
|
|
|
|
|
with your gdb. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
arc_detach (args, from_tty)
|
|
|
|
|
char *args;
|
|
|
|
|
int from_tty;
|
|
|
|
|
{
|
|
|
|
|
if (args)
|
|
|
|
|
error ("Argument given to \"detach\" when remotely debugging.");
|
|
|
|
|
|
|
|
|
|
pop_target ();
|
|
|
|
|
if (from_tty)
|
|
|
|
|
puts_filtered ("Ending remote debugging.\n");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* arc_set_addrreg
|
|
|
|
|
set addr reg from debug system. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
arc_set_addrreg (addr)
|
|
|
|
|
unsigned int addr;
|
|
|
|
|
{
|
|
|
|
|
unsigned char buf[6] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
|
|
|
|
|
|
|
|
|
|
buf[0] = 0x0;
|
|
|
|
|
buf[4] = addr & 0xff;
|
|
|
|
|
buf[3] = (addr >> 8) & 0xff;
|
|
|
|
|
buf[2] = (addr >> 16) & 0xff;
|
|
|
|
|
buf[1] = (addr >> 24) & 0xff;
|
|
|
|
|
|
|
|
|
|
putpkt (buf, 5);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* arc_xfer_datareg
|
|
|
|
|
read or write data reg from debug system. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
arc_xfer_datareg (rw, aux, incr, data)
|
|
|
|
|
int rw;
|
|
|
|
|
int aux;
|
|
|
|
|
int incr;
|
|
|
|
|
unsigned int *data;
|
|
|
|
|
{
|
|
|
|
|
unsigned char buf1[6] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
|
|
|
|
|
unsigned char buf2[5];
|
|
|
|
|
unsigned int tmp;
|
|
|
|
|
|
|
|
|
|
/* read or write data */
|
|
|
|
|
buf1[0] = (aux ? 0x81 : 0x41);
|
|
|
|
|
if (incr)
|
|
|
|
|
buf1[0] += 0x20;
|
|
|
|
|
if (rw) /* read */
|
|
|
|
|
{
|
|
|
|
|
buf1[0] += 0x10;
|
|
|
|
|
putpkt (buf1, 1);
|
|
|
|
|
getpkt (buf2, 4);
|
|
|
|
|
*data = *(int *)buf2;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
tmp = *data;
|
|
|
|
|
buf1[4] = tmp & 0xff;
|
|
|
|
|
buf1[3] = (tmp >> 8) & 0xff;
|
|
|
|
|
buf1[2] = (tmp >> 16) & 0xff;
|
|
|
|
|
buf1[1] = (tmp >> 24) & 0xff;
|
|
|
|
|
putpkt (buf1, 5);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* arc_xfer_cntlreg
|
|
|
|
|
read or write control reg from debug system. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
arc_xfer_cntlreg (rw, data)
|
|
|
|
|
int rw;
|
|
|
|
|
unsigned char *data;
|
|
|
|
|
{
|
|
|
|
|
unsigned char buf[3] = {0x0, 0x0, 0x0};
|
|
|
|
|
|
|
|
|
|
if (rw)
|
|
|
|
|
{
|
|
|
|
|
buf[0] = 0x12;
|
|
|
|
|
putpkt (buf, 1);
|
|
|
|
|
getpkt (data, 1);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
buf[0] = 0x02;
|
|
|
|
|
buf[1] = *data;
|
|
|
|
|
putpkt (buf, 2);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* arc_xfer_reg
|
|
|
|
|
read or write a reg to arc processors. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
arc_xfer_reg (processor, rw, aux, regnum, data)
|
|
|
|
|
int processor;
|
|
|
|
|
int rw;
|
|
|
|
|
int aux;
|
|
|
|
|
int regnum;
|
|
|
|
|
unsigned int *data;
|
|
|
|
|
{
|
|
|
|
|
unsigned int tmp;
|
|
|
|
|
|
|
|
|
|
if (processor == HOST_PROCESSOR)
|
|
|
|
|
{
|
|
|
|
|
/* write addr (regnum) */
|
|
|
|
|
arc_set_addrreg (regnum);
|
|
|
|
|
arc_xfer_datareg (rw, aux, 0, data);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* write addr register (aux r14) */
|
|
|
|
|
arc_set_addrreg (0xe);
|
|
|
|
|
tmp = aux ? (regnum | 0x80000000) : regnum;
|
|
|
|
|
arc_xfer_datareg (0, 1, 0, tmp);
|
|
|
|
|
|
|
|
|
|
/* read/write from data reg (aux reg 15/16) */
|
|
|
|
|
arc_set_addrreg (processor == AUDIO_PROCESSOR ? 0x10 : 0xf);
|
|
|
|
|
arc_xfer_datareg (rw, 1, 0, data);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Tell the remote machine to resume. */
|
|
|
|
|
|
|
|
|
|
static enum target_signal last_sent_signal = TARGET_SIGNAL_0;
|
|
|
|
|
int last_sent_step;
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
arc_resume (pid, step, siggnal)
|
|
|
|
|
int pid, step;
|
|
|
|
|
enum target_signal siggnal;
|
|
|
|
|
{
|
|
|
|
|
unsigned int tmp;
|
|
|
|
|
|
|
|
|
|
dcache_flush (remote_dcache);
|
|
|
|
|
|
|
|
|
|
last_sent_signal = siggnal;
|
|
|
|
|
last_sent_step = step;
|
|
|
|
|
|
|
|
|
|
/* don't know how to handle signal in ARC ***
|
|
|
|
|
if (siggnal != TARGET_SIGNAL_0)
|
|
|
|
|
{
|
|
|
|
|
buf[0] = step ? 'S' : 'C';
|
|
|
|
|
buf[1] = tohex (((int)siggnal >> 4) & 0xf);
|
|
|
|
|
buf[2] = tohex ((int)siggnal & 0xf);
|
|
|
|
|
buf[3] = '\0';
|
|
|
|
|
}
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
if (step)
|
|
|
|
|
{
|
|
|
|
|
/* write the step bit in control reg of debug system */
|
|
|
|
|
unsigned char tmp_char = cntl_reg | cntl_reg_step_bit[curr_processor];
|
|
|
|
|
arc_xfer_cntlreg (0, &tmp_char);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
/* clear the halt bit in the status register */
|
|
|
|
|
tmp = status_reg | 0x02000000;
|
|
|
|
|
arc_xfer_reg (curr_processor, 0, 1, 0, &tmp);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void (*ofunc)();
|
|
|
|
|
|
|
|
|
|
/* Send to target to halt it. */
|
|
|
|
|
static void
|
|
|
|
|
arc_interrupt (signo)
|
|
|
|
|
int signo;
|
|
|
|
|
{
|
|
|
|
|
unsigned char buf[3] = {0x02, 0x0, 0x0};
|
|
|
|
|
/* If this doesn't work, try more severe steps. */
|
|
|
|
|
signal (signo, arc_interrupt_twice);
|
|
|
|
|
|
|
|
|
|
if (remote_debug)
|
|
|
|
|
printf_unfiltered ("arc_interrupt called\n");
|
|
|
|
|
|
|
|
|
|
if (cntl_reg & cntl_reg_halt_bit[curr_processor])
|
|
|
|
|
return;
|
|
|
|
|
|
|
|
|
|
buf[1] = cntl_reg | cntl_reg_halt_bit[curr_processor];
|
|
|
|
|
putpkt (buf, 2);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* The user typed ^C twice. */
|
|
|
|
|
static void
|
|
|
|
|
arc_interrupt_twice (signo)
|
|
|
|
|
int signo;
|
|
|
|
|
{
|
|
|
|
|
signal (signo, ofunc);
|
|
|
|
|
|
|
|
|
|
interrupt_query ();
|
|
|
|
|
|
|
|
|
|
signal (signo, arc_interrupt);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Ask the user what to do when an interrupt is received. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
interrupt_query ()
|
|
|
|
|
{
|
|
|
|
|
target_terminal_ours ();
|
|
|
|
|
|
|
|
|
|
if (query ("Interrupted while waiting for the program.\n\
|
|
|
|
|
Give up (and stop debugging it)? "))
|
|
|
|
|
{
|
|
|
|
|
target_mourn_inferior ();
|
|
|
|
|
return_to_top_level (RETURN_QUIT);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
target_terminal_inferior ();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* If nonzero, ignore the next kill. */
|
|
|
|
|
int kill_kludge;
|
|
|
|
|
|
|
|
|
|
/* Wait until the remote machine stops, then return,
|
|
|
|
|
storing status in STATUS just as `wait' would.
|
|
|
|
|
Returns "pid" (though it's not clear what, if anything, that
|
|
|
|
|
means in the case of this target). */
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
arc_wait (pid, status)
|
|
|
|
|
int pid;
|
|
|
|
|
struct target_waitstatus *status;
|
|
|
|
|
{
|
|
|
|
|
unsigned char buf[PBUFSIZ];
|
|
|
|
|
int thread_num = -1;
|
1995-03-01 02:39:12 +01:00
|
|
|
|
unsigned char cmd;
|
|
|
|
|
int proc;
|
1995-02-03 01:23:22 +01:00
|
|
|
|
|
|
|
|
|
status->kind = TARGET_WAITKIND_EXITED;
|
|
|
|
|
status->value.integer = 0;
|
|
|
|
|
|
|
|
|
|
while (1)
|
|
|
|
|
{
|
|
|
|
|
unsigned char *p;
|
|
|
|
|
|
|
|
|
|
ofunc = (void (*)()) signal (SIGINT, arc_interrupt);
|
|
|
|
|
arc_xfer_cntlreg (1, &cntl_reg);
|
|
|
|
|
signal (SIGINT, ofunc);
|
|
|
|
|
if (cntl_reg & cntl_reg_halt_bit[curr_processor])
|
|
|
|
|
break;
|
|
|
|
|
status->kind = TARGET_WAITKIND_STOPPED;
|
|
|
|
|
}
|
|
|
|
|
|
1995-03-01 02:39:12 +01:00
|
|
|
|
if ((curr_processor != HOST_PROCESSOR) &&
|
|
|
|
|
!(cntl_reg & cntl_reg_halt_bit[HOST_PROCESSOR]))
|
|
|
|
|
{
|
|
|
|
|
cmd = cntl_reg | cntl_reg_halt_bit[HOST_PROCESSOR];
|
|
|
|
|
arc_xfer_cntlreg (0, &cmd);
|
|
|
|
|
while (1)
|
|
|
|
|
{
|
|
|
|
|
unsigned char *p;
|
|
|
|
|
|
|
|
|
|
ofunc = (void (*)()) signal (SIGINT, arc_interrupt);
|
|
|
|
|
arc_xfer_cntlreg (1, &cntl_reg);
|
|
|
|
|
signal (SIGINT, ofunc);
|
|
|
|
|
if (cntl_reg & cntl_reg_halt_bit[HOST_PROCESSOR])
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (proc = AUDIO_PROCESSOR ; proc <= GRAPHIC_PROCESSOR; proc++)
|
|
|
|
|
{
|
|
|
|
|
if ((cntl_reg & cntl_reg_halt_bit[proc]))
|
|
|
|
|
continue;
|
|
|
|
|
cmd = cntl_reg | cntl_reg_halt_bit[proc];
|
|
|
|
|
arc_xfer_cntlreg (0, &cmd);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
arc_xfer_reg (curr_processor, 1, 1, 0, &status_reg);
|
1995-02-03 01:23:22 +01:00
|
|
|
|
return inferior_pid;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Number of bytes of registers this implements. */
|
|
|
|
|
static int register_bytes_found;
|
|
|
|
|
|
|
|
|
|
/* Read the remote registers into the block REGS. */
|
|
|
|
|
/* Currently we just read all the registers, so we don't use regno. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
arc_fetch_registers (regno)
|
|
|
|
|
int regno;
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
char regs[REGISTER_BYTES];
|
|
|
|
|
|
|
|
|
|
/* Unimplemented registers read as all bits zero. */
|
|
|
|
|
memset (regs, 0, REGISTER_BYTES);
|
|
|
|
|
|
|
|
|
|
/* get core register */
|
|
|
|
|
arc_set_addrreg (0);
|
|
|
|
|
for (i = 0; i < AUX_BEG_REGNUM; i++)
|
|
|
|
|
{
|
|
|
|
|
if (curr_processor == HOST_PROCESSOR)
|
|
|
|
|
arc_xfer_datareg (1, 0, 1, ®s[REGISTER_BYTE(i)]);
|
|
|
|
|
else
|
|
|
|
|
arc_xfer_reg (curr_processor, 1, 0, regno, ®s[REGISTER_BYTE(i)]);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* get aux register */
|
|
|
|
|
for (i = AUX_BEG_REGNUM; i < AUX_END_REGNUM; i++)
|
|
|
|
|
{
|
|
|
|
|
int auxregnum = aux_reg_map[curr_processor][i-AUX_BEG_REGNUM+1];
|
|
|
|
|
if (auxregnum == -1)
|
|
|
|
|
continue;
|
|
|
|
|
arc_xfer_reg (curr_processor, 1, 1, auxregnum, ®s[REGISTER_BYTE(i)]);
|
|
|
|
|
}
|
|
|
|
|
/* copy from status register to pc */
|
|
|
|
|
for (i = 1; i <= 3; i++)
|
|
|
|
|
registers[REGISTER_BYTE (PC_REGNUM)+i] =
|
|
|
|
|
registers[REGISTER_BYTE (STA_REGNUM)+i];
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
|
if (i != register_bytes_found)
|
|
|
|
|
{
|
|
|
|
|
register_bytes_found = i;
|
|
|
|
|
if (!REGISTER_BYTES_OK (i))
|
|
|
|
|
warning ("Remote reply is too short: %s", buf);
|
|
|
|
|
}
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < NUM_REGS; i++)
|
|
|
|
|
supply_register (i, ®s[REGISTER_BYTE(i)]);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Prepare to store registers. Since we may send them all,
|
|
|
|
|
we have to read out the ones we don't want to change first. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
arc_prepare_to_store ()
|
|
|
|
|
{
|
|
|
|
|
/* Make sure the entire registers array is valid. */
|
|
|
|
|
read_register_bytes (0, (char *)NULL, REGISTER_BYTES);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Store register REGNO, or all registers if REGNO == -1, from the contents
|
|
|
|
|
of REGISTERS. FIXME: ignores errors. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
arc_store_registers (regno)
|
|
|
|
|
int regno;
|
|
|
|
|
{
|
|
|
|
|
int i;
|
|
|
|
|
char *regp;
|
|
|
|
|
|
|
|
|
|
/* Try storing a single register. */
|
|
|
|
|
if (regno >= 0)
|
|
|
|
|
{
|
|
|
|
|
int isaux = (regno >= AUX_BEG_REGNUM ? 1 : 0);
|
|
|
|
|
|
|
|
|
|
regp = ®isters[REGISTER_BYTE (regno)];
|
|
|
|
|
arc_xfer_reg (curr_processor, 0, isaux, regno, regp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* store core regs */
|
|
|
|
|
arc_set_addrreg (0);
|
|
|
|
|
for (i = 0; i < AUX_BEG_REGNUM; i++)
|
|
|
|
|
{
|
|
|
|
|
regp = ®isters[REGISTER_BYTE (i)];
|
|
|
|
|
if (curr_processor == HOST_PROCESSOR)
|
|
|
|
|
arc_xfer_datareg (0, 0, 1, regp);
|
|
|
|
|
else
|
|
|
|
|
arc_xfer_reg (curr_processor, 0, 0, regno, regp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* store aux regs */
|
|
|
|
|
/* copy pc back to status register */
|
|
|
|
|
for (i = 1; i <= 3; i++)
|
|
|
|
|
registers[REGISTER_BYTE (STA_REGNUM)+i] =
|
|
|
|
|
registers[REGISTER_BYTE (PC_REGNUM)+i];
|
|
|
|
|
for (i = AUX_BEG_REGNUM; i <= AUX_END_REGNUM; i++)
|
|
|
|
|
{
|
|
|
|
|
int auxregnum = aux_reg_map[curr_processor][i-AUX_BEG_REGNUM+1];
|
|
|
|
|
if (auxregnum == -1)
|
|
|
|
|
continue;
|
|
|
|
|
regp = ®isters[REGISTER_BYTE (i)];
|
|
|
|
|
arc_xfer_reg (curr_processor, 0, 1, auxregnum, regp);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
|
/* Use of the data cache is disabled because it loses for looking at
|
|
|
|
|
and changing hardware I/O ports and the like. Accepting `voltile'
|
|
|
|
|
would perhaps be one way to fix it, but a better way which would
|
|
|
|
|
win for more cases would be to use the executable file for the text
|
|
|
|
|
segment, like the `icache' code below but done cleanly (in some
|
|
|
|
|
target-independent place, perhaps in target_xfer_memory, perhaps
|
|
|
|
|
based on assigning each target a speed or perhaps by some simpler
|
|
|
|
|
mechanism). */
|
|
|
|
|
|
|
|
|
|
/* Read a word from remote address ADDR and return it.
|
|
|
|
|
This goes through the data cache. */
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
arc_fetch_word (addr)
|
|
|
|
|
CORE_ADDR addr;
|
|
|
|
|
{
|
|
|
|
|
#if 0
|
|
|
|
|
if (icache)
|
|
|
|
|
{
|
|
|
|
|
extern CORE_ADDR text_start, text_end;
|
|
|
|
|
|
|
|
|
|
if (addr >= text_start && addr < text_end)
|
|
|
|
|
{
|
|
|
|
|
int buffer;
|
|
|
|
|
xfer_core_file (addr, &buffer, sizeof (int));
|
|
|
|
|
return buffer;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
return dcache_fetch (remote_dcache, addr);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Write a word WORD into remote address ADDR.
|
|
|
|
|
This goes through the data cache. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
arc_store_word (addr, word)
|
|
|
|
|
CORE_ADDR addr;
|
|
|
|
|
int word;
|
|
|
|
|
{
|
|
|
|
|
dcache_poke (remote_dcache, addr, word);
|
|
|
|
|
}
|
|
|
|
|
#endif /* 0 */
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Write memory data directly to the remote machine.
|
|
|
|
|
This does not inform the data cache; the data cache uses this.
|
|
|
|
|
MEMADDR is the address in the remote memory space.
|
|
|
|
|
MYADDR is the address of the buffer in our space.
|
|
|
|
|
LEN is the number of bytes.
|
|
|
|
|
|
|
|
|
|
Returns number of bytes transferred, or 0 for error. */
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
arc_write_bytes (memaddr, myaddr, len)
|
|
|
|
|
CORE_ADDR memaddr;
|
|
|
|
|
unsigned char *myaddr;
|
|
|
|
|
int len;
|
|
|
|
|
{
|
|
|
|
|
char buf1[6] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
|
|
|
|
|
char buf2[6] = {0x21, 0x0, 0x0, 0x0, 0x0, 0x0};
|
|
|
|
|
int i;
|
|
|
|
|
char *p;
|
|
|
|
|
|
|
|
|
|
/* We send target system values byte by byte, in increasing byte addresses*/
|
|
|
|
|
|
|
|
|
|
buf1[4] = memaddr & 0xff;
|
|
|
|
|
buf1[3] = (memaddr >> 8) & 0xff;
|
|
|
|
|
buf1[2] = (memaddr >> 16) & 0xff;
|
|
|
|
|
buf1[1] = (memaddr >> 24) & 0xff;
|
|
|
|
|
putpkt (buf1, 5);
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < len; )
|
|
|
|
|
{
|
|
|
|
|
buf2[1] = myaddr[i++];
|
|
|
|
|
buf2[2] = myaddr[i++];
|
|
|
|
|
buf2[3] = myaddr[i++];
|
|
|
|
|
buf2[4] = myaddr[i++];
|
|
|
|
|
putpkt (buf2, 5);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return len;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Read memory data directly from the remote machine.
|
|
|
|
|
This does not use the data cache; the data cache uses this.
|
|
|
|
|
MEMADDR is the address in the remote memory space.
|
|
|
|
|
MYADDR is the address of the buffer in our space.
|
|
|
|
|
LEN is the number of bytes.
|
|
|
|
|
|
|
|
|
|
Returns number of bytes transferred, or 0 for error. */
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
arc_read_bytes (memaddr, myaddr, len)
|
|
|
|
|
CORE_ADDR memaddr;
|
|
|
|
|
unsigned char *myaddr;
|
|
|
|
|
int len;
|
|
|
|
|
{
|
|
|
|
|
unsigned char buf1[6] = {0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
|
|
|
|
|
unsigned char buf2[3] = {0x31, 0x0, 0x0};
|
|
|
|
|
unsigned char buf3[5];
|
|
|
|
|
int i;
|
|
|
|
|
char *p;
|
|
|
|
|
|
|
|
|
|
/* We send target system values byte by byte, in increasing byte addresses*/
|
|
|
|
|
|
|
|
|
|
buf1[4] = memaddr & 0xff;
|
|
|
|
|
buf1[3] = (memaddr >> 8) & 0xff;
|
|
|
|
|
buf1[2] = (memaddr >> 16) & 0xff;
|
|
|
|
|
buf1[1] = (memaddr >> 24) & 0xff;
|
|
|
|
|
putpkt (buf1, 5);
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < len; )
|
|
|
|
|
{
|
|
|
|
|
putpkt (buf2, 2);
|
|
|
|
|
getpkt (buf3, 4);
|
|
|
|
|
myaddr[i++] = buf3[1];
|
|
|
|
|
myaddr[i++] = buf3[2];
|
|
|
|
|
myaddr[i++] = buf3[3];
|
|
|
|
|
myaddr[i++] = buf3[4];
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return i;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Read or write LEN bytes from inferior memory at MEMADDR, transferring
|
|
|
|
|
to or from debugger address MYADDR. Write to inferior if SHOULD_WRITE is
|
|
|
|
|
nonzero. Returns length of data written or read; 0 for error. */
|
|
|
|
|
|
|
|
|
|
/* ARGSUSED */
|
|
|
|
|
static int
|
|
|
|
|
arc_xfer_memory(memaddr, myaddr, len, should_write, target)
|
|
|
|
|
CORE_ADDR memaddr;
|
|
|
|
|
char *myaddr;
|
|
|
|
|
int len;
|
|
|
|
|
int should_write;
|
|
|
|
|
struct target_ops *target; /* ignored */
|
|
|
|
|
{
|
|
|
|
|
int xfersize;
|
|
|
|
|
int bytes_xferred;
|
|
|
|
|
int total_xferred = 0;
|
|
|
|
|
|
|
|
|
|
while (len > 0)
|
|
|
|
|
{
|
|
|
|
|
if (len > MAXBUFBYTES)
|
|
|
|
|
xfersize = MAXBUFBYTES;
|
|
|
|
|
else
|
|
|
|
|
xfersize = len;
|
|
|
|
|
|
|
|
|
|
if (should_write)
|
|
|
|
|
bytes_xferred = arc_write_bytes (memaddr,
|
|
|
|
|
(unsigned char *)myaddr, xfersize);
|
|
|
|
|
else
|
|
|
|
|
bytes_xferred = arc_read_bytes (memaddr,
|
|
|
|
|
(unsigned char *)myaddr, xfersize);
|
|
|
|
|
|
|
|
|
|
/* If we get an error, we are done xferring. */
|
|
|
|
|
if (bytes_xferred == 0)
|
|
|
|
|
break;
|
|
|
|
|
|
|
|
|
|
memaddr += bytes_xferred;
|
|
|
|
|
myaddr += bytes_xferred;
|
|
|
|
|
len -= bytes_xferred;
|
|
|
|
|
total_xferred += bytes_xferred;
|
|
|
|
|
}
|
|
|
|
|
return total_xferred;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
arc_files_info (ignore)
|
|
|
|
|
struct target_ops *ignore;
|
|
|
|
|
{
|
|
|
|
|
puts_filtered ("Debugging a target over a serial line.\n");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Read a single character from the remote end, masking it down to 7 bits. */
|
|
|
|
|
static int
|
|
|
|
|
readchar ()
|
|
|
|
|
{
|
|
|
|
|
int ch;
|
|
|
|
|
|
|
|
|
|
ch = SERIAL_READCHAR (arc_desc, 0);
|
|
|
|
|
|
|
|
|
|
switch (ch)
|
|
|
|
|
{
|
|
|
|
|
case SERIAL_EOF:
|
|
|
|
|
error ("Remote connection closed");
|
|
|
|
|
case SERIAL_ERROR:
|
|
|
|
|
perror_with_name ("Remote communication error");
|
|
|
|
|
case SERIAL_TIMEOUT:
|
|
|
|
|
return ch;
|
|
|
|
|
default:
|
|
|
|
|
return ch & 0x7f;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Send a packet to the remote machine, with error checking.
|
|
|
|
|
The data of the packet is in BUF. */
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
putpkt (buf, len)
|
|
|
|
|
char *buf;
|
|
|
|
|
int len;
|
|
|
|
|
{
|
|
|
|
|
int i = 0;
|
|
|
|
|
unsigned char csum = 0;
|
|
|
|
|
|
|
|
|
|
while (i < len)
|
|
|
|
|
{
|
|
|
|
|
if (remote_debug)
|
|
|
|
|
{
|
|
|
|
|
printf_unfiltered ("Sending packet: %s...", buf);
|
|
|
|
|
gdb_flush(gdb_stdout);
|
|
|
|
|
}
|
|
|
|
|
if (SERIAL_WRITE (arc_desc, buf, i))
|
|
|
|
|
perror_with_name ("putpkt: write failed");
|
|
|
|
|
i++;
|
|
|
|
|
|
|
|
|
|
#if 0
|
|
|
|
|
/* This is wrong. If doing a long backtrace, the user should be
|
|
|
|
|
able to get out next time we call QUIT, without anything as violent
|
|
|
|
|
as interrupt_query. If we want to provide a way out of here
|
|
|
|
|
without getting to the next QUIT, it should be based on hitting
|
|
|
|
|
^C twice as in arc_wait. */
|
|
|
|
|
if (quit_flag)
|
|
|
|
|
{
|
|
|
|
|
quit_flag = 0;
|
|
|
|
|
interrupt_query ();
|
|
|
|
|
}
|
|
|
|
|
#endif
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* Read a packet from the remote machine, with error checking,
|
|
|
|
|
and store it in BUF. BUF is expected to be of size PBUFSIZ.
|
|
|
|
|
If FOREVER, wait forever rather than timing out; this is used
|
|
|
|
|
while the target is executing user code. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
getpkt (buf, len)
|
|
|
|
|
char *buf;
|
|
|
|
|
int len;
|
|
|
|
|
{
|
|
|
|
|
int c;
|
|
|
|
|
int i;
|
|
|
|
|
|
|
|
|
|
for (i = 0; i < len; i++)
|
|
|
|
|
{
|
|
|
|
|
c = readchar ();
|
|
|
|
|
if (c == SERIAL_ERROR)
|
|
|
|
|
{
|
|
|
|
|
if (remote_debug)
|
|
|
|
|
puts_filtered ("Read error.\n");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
buf[i] = '\0';
|
|
|
|
|
|
|
|
|
|
if (remote_debug)
|
|
|
|
|
fprintf_unfiltered (gdb_stderr, "Packet received: %s\n", buf);
|
|
|
|
|
if (i != len)
|
|
|
|
|
printf_unfiltered ("Ignoring packet error, continuing...\n");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
arc_kill ()
|
|
|
|
|
{
|
|
|
|
|
/* For some mysterious reason, wait_for_inferior calls kill instead of
|
|
|
|
|
mourn after it gets TARGET_WAITKIND_SIGNALLED. Work around it. */
|
|
|
|
|
if (kill_kludge)
|
|
|
|
|
{
|
|
|
|
|
kill_kludge = 0;
|
|
|
|
|
target_mourn_inferior ();
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
target_mourn_inferior ();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
arc_mourn ()
|
|
|
|
|
{
|
|
|
|
|
unpush_target (&arc_ops);
|
|
|
|
|
generic_mourn_inferior ();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
1995-04-12 17:47:39 +02:00
|
|
|
|
static unsigned char big_break_insn[] = BIG_BREAKPOINT;
|
|
|
|
|
static unsigned char little_break_insn[] = LITTLE_BREAKPOINT;
|
|
|
|
|
#define BREAKPOINT_LEN (sizeof little_break_insn)
|
1995-02-03 01:23:22 +01:00
|
|
|
|
|
|
|
|
|
/* Insert a breakpoint on targets that don't have any better breakpoint
|
|
|
|
|
support. We read the contents of the target location and stash it,
|
|
|
|
|
then overwrite it with a breakpoint instruction. ADDR is the target
|
|
|
|
|
location in the target machine. CONTENTS_CACHE is a pointer to
|
|
|
|
|
memory allocated for saving the target contents. It is guaranteed
|
|
|
|
|
by the caller to be long enough to save sizeof BREAKPOINT bytes (this
|
|
|
|
|
is accomplished via BREAKPOINT_MAX). */
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
arc_insert_breakpoint (addr, contents_cache)
|
|
|
|
|
CORE_ADDR addr;
|
|
|
|
|
char *contents_cache;
|
|
|
|
|
{
|
|
|
|
|
int val;
|
|
|
|
|
|
1995-04-12 17:47:39 +02:00
|
|
|
|
val = target_read_memory (addr, contents_cache, BREAKPOINT_LEN);
|
1995-02-03 01:23:22 +01:00
|
|
|
|
if (val == 0)
|
1995-04-12 17:47:39 +02:00
|
|
|
|
{
|
|
|
|
|
if (TARGET_BYTE_ORDER == BIG_ENDIAN)
|
|
|
|
|
val = target_write_memory (addr, (char *) big_break_insn,
|
|
|
|
|
BREAKPOINT_LEN);
|
|
|
|
|
else
|
|
|
|
|
val = target_write_memory (addr, (char *) little_break_insn,
|
|
|
|
|
BREAKPOINT_LEN);
|
|
|
|
|
}
|
1995-02-03 01:23:22 +01:00
|
|
|
|
return val;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static int
|
|
|
|
|
arc_remove_breakpoint (addr, contents_cache)
|
|
|
|
|
CORE_ADDR addr;
|
|
|
|
|
char *contents_cache;
|
|
|
|
|
{
|
1995-04-12 17:47:39 +02:00
|
|
|
|
return target_write_memory (addr, contents_cache, BREAKPOINT_LEN);
|
1995-02-03 01:23:22 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/* switch_command
|
|
|
|
|
support 'switch' command to switch among the three processors of ARC. */
|
|
|
|
|
|
|
|
|
|
static void
|
|
|
|
|
switch_command (args, fromtty)
|
|
|
|
|
char *args;
|
|
|
|
|
int fromtty;
|
|
|
|
|
{
|
|
|
|
|
struct target_waitstatus status;
|
1995-03-01 02:39:12 +01:00
|
|
|
|
int proc;
|
1995-02-03 01:23:22 +01:00
|
|
|
|
|
|
|
|
|
if (strncmp (args, "audio", 3) == 0)
|
|
|
|
|
proc = 0;
|
|
|
|
|
else if (strncmp (args, "graphic", 3) == 0)
|
|
|
|
|
proc = 1;
|
|
|
|
|
else if (strncmp (args, "host", 4) == 0)
|
|
|
|
|
proc = 2;
|
|
|
|
|
|
1995-03-01 02:39:12 +01:00
|
|
|
|
curr_processor = proc;
|
|
|
|
|
|
|
|
|
|
switch (proc)
|
1995-02-03 01:23:22 +01:00
|
|
|
|
{
|
1995-03-01 02:39:12 +01:00
|
|
|
|
case 0:
|
1995-04-12 17:47:39 +02:00
|
|
|
|
tm_print_insn = arc_get_disassembler (bfd_mach_arc_audio,
|
|
|
|
|
TARGET_BYTE_ORDER == BIG_ENDIAN);
|
1995-03-01 02:39:12 +01:00
|
|
|
|
break;
|
|
|
|
|
case 1:
|
1995-04-12 17:47:39 +02:00
|
|
|
|
tm_print_insn = arc_get_disassembler (bfd_mach_arc_graphics,
|
|
|
|
|
TARGET_BYTE_ORDER == BIG_ENDIAN);
|
1995-03-01 02:39:12 +01:00
|
|
|
|
break;
|
|
|
|
|
case 2:
|
1995-04-12 17:47:39 +02:00
|
|
|
|
tm_print_insn = arc_get_disassembler (bfd_mach_arc_host,
|
|
|
|
|
TARGET_BYTE_ORDER == BIG_ENDIAN);
|
1995-03-01 02:39:12 +01:00
|
|
|
|
break;
|
1995-02-03 01:23:22 +01:00
|
|
|
|
}
|
|
|
|
|
|
1995-03-01 02:39:12 +01:00
|
|
|
|
return;
|
1995-02-03 01:23:22 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Define the target subroutine names */
|
|
|
|
|
|
|
|
|
|
struct target_ops arc_ops = {
|
|
|
|
|
"arc", /* to_shortname */
|
|
|
|
|
"Remote target in arc-specific protocol", /* to_longname */
|
|
|
|
|
"Use a remote computer via a parallel line, using a arc-specific protocol.\n\
|
|
|
|
|
Specify the device it is connected to.", /* to_doc */
|
|
|
|
|
arc_open, /* to_open */
|
|
|
|
|
arc_close, /* to_close */
|
|
|
|
|
NULL, /* to_attach */
|
|
|
|
|
arc_detach, /* to_detach */
|
|
|
|
|
arc_resume, /* to_resume */
|
|
|
|
|
arc_wait, /* to_wait */
|
|
|
|
|
arc_fetch_registers, /* to_fetch_registers */
|
|
|
|
|
arc_store_registers, /* to_store_registers */
|
|
|
|
|
arc_prepare_to_store, /* to_prepare_to_store */
|
|
|
|
|
arc_xfer_memory, /* to_xfer_memory */
|
|
|
|
|
arc_files_info, /* to_files_info */
|
|
|
|
|
|
|
|
|
|
arc_insert_breakpoint, /* to_insert_breakpoint */
|
|
|
|
|
arc_remove_breakpoint, /* to_remove_breakpoint */
|
|
|
|
|
|
|
|
|
|
NULL, /* to_terminal_init */
|
|
|
|
|
NULL, /* to_terminal_inferior */
|
|
|
|
|
NULL, /* to_terminal_ours_for_output */
|
|
|
|
|
NULL, /* to_terminal_ours */
|
|
|
|
|
NULL, /* to_terminal_info */
|
|
|
|
|
arc_kill, /* to_kill */
|
|
|
|
|
generic_load, /* to_load */
|
|
|
|
|
NULL, /* to_lookup_symbol */
|
|
|
|
|
NULL, /* to_create_inferior */
|
|
|
|
|
arc_mourn, /* to_mourn_inferior */
|
|
|
|
|
0, /* to_can_run */
|
|
|
|
|
0, /* to_notice_signals */
|
1995-07-13 23:40:22 +02:00
|
|
|
|
0, /* to_thread_alive */
|
1995-02-03 01:23:22 +01:00
|
|
|
|
0, /* to_stop */
|
|
|
|
|
process_stratum, /* to_stratum */
|
|
|
|
|
NULL, /* to_next */
|
|
|
|
|
1, /* to_has_all_memory */
|
|
|
|
|
1, /* to_has_memory */
|
|
|
|
|
1, /* to_has_stack */
|
|
|
|
|
1, /* to_has_registers */
|
|
|
|
|
1, /* to_has_execution */
|
|
|
|
|
NULL, /* sections */
|
|
|
|
|
NULL, /* sections_end */
|
|
|
|
|
OPS_MAGIC /* to_magic */
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
void
|
|
|
|
|
_initialize_remote_arc ()
|
|
|
|
|
{
|
|
|
|
|
add_target (&arc_ops);
|
|
|
|
|
}
|