#include "defs.h"
#include "dcache.h"
+#include "gdbcmd.h"
extern int insque();
extern int remque();
+int remote_dcache = 0;
+
/* The data cache records all the data read from the remote machine
since the last time it stopped.
{
register struct dcache_block *db;
- while ((db = dcache->dcache_valid.next) != &dcache->dcache_valid)
- {
- remque (db);
- insque (db, &dcache->dcache_free);
- }
+ if (remote_dcache > 0)
+ while ((db = dcache->dcache_valid.next) != &dcache->dcache_valid)
+ {
+ remque (db);
+ insque (db, &dcache->dcache_free);
+ }
+
+ return;
}
/*
* If addr is present in the dcache, return the address of the block
* containing it.
*/
+static
struct dcache_block *
dcache_hit (dcache, addr)
DCACHE *dcache;
{
register struct dcache_block *db;
- if (addr & 3)
+ if (addr & 3
+ || remote_dcache == 0)
abort ();
/* Search all cache blocks for one that is at this address. */
return db;
db = db->next;
}
+
return NULL;
}
/* Return the int data at address ADDR in dcache block DC. */
+static
int
dcache_value (db, addr)
struct dcache_block *db;
unsigned int addr;
{
- if (addr & 3)
+ if (addr & 3
+ || remote_dcache == 0)
abort ();
return (db->data[XFORM (addr)]);
}
prevents errors from creeping in if a memory retrieval is
interrupted (which used to put garbage blocks in the valid
list...). */
+static
struct dcache_block *
dcache_alloc (dcache)
DCACHE *dcache;
{
register struct dcache_block *db;
+ if (remote_dcache == 0)
+ abort();
+
if ((db = dcache->dcache_free.next) == &dcache->dcache_free)
{
/* If we can't get one from the free list, take last valid and put
return (db);
}
-/* Return the contents of the word at address ADDR in the remote machine,
- using the data cache. */
+/* Using the data cache DCACHE return the contents of the word at
+ address ADDR in the remote machine. */
int
dcache_fetch (dcache, addr)
DCACHE *dcache;
{
register struct dcache_block *db;
+ if (remote_dcache == 0)
+ {
+ int i;
+
+ (*dcache->read_memory) (addr, (unsigned char *) &i, 4);
+ return(i);
+ }
+
db = dcache_hit (dcache, addr);
if (db == 0)
{
{
register struct dcache_block *db;
+ if (remote_dcache == 0)
+ {
+ (*dcache->write_memory) (addr, (unsigned char *) &data, 4);
+ return;
+ }
+
/* First make sure the word is IN the cache. DB is its cache block. */
db = dcache_hit (dcache, addr);
if (db == 0)
(*dcache->write_memory) (addr & ~LINE_SIZE_MASK, (unsigned char *) db->data, LINE_SIZE);
immediate_quit--;
db->addr = addr & ~LINE_SIZE_MASK;
- remque (db); /* Off the free list */
- insque (db, &dcache->dcache_valid); /* On the valid list */
+ remque (db); /* Off the free list */
+ insque (db, &dcache->dcache_valid); /* On the valid list */
}
/* Modify the word in the cache. */
return(dcache);
}
+void
+_initialitize_dcache ()
+{
+ add_show_from_set
+ (add_set_cmd ("remotecache", class_support, var_boolean,
+ (char *) &remote_dcache,
+ "\
+Set cache use for remote targets.\n\
+When on, use data caching for remote targets. For many remote targets\n\
+this option can offer better throughput for reading target memory.\n\
+Unfortunately, gdb does not currently know anything about volatile\n\
+registers and thus data caching will produce incorrect results with\n\
+volatile registers are in use. By default, this option is off.",
+ &setlist),
+ &showlist);
+}
read mem mAA..AA,LLLL AA..AA is address, LLLL is length.
reply XX..XX XX..XX is mem contents
+ Can be fewer bytes than requested
+ if able to read only part of the data.
or ENN NN is errno
write mem MAA..AA,LLLL:XX..XX
LLLL is number of bytes,
XX..XX is data
reply OK for success
- ENN for an error
+ ENN for an error (this includes the case
+ where only part of the data was
+ written).
cont cAA..AA AA..AA is address to resume
If AA..AA is omitted,
n... = register number
r... = register contents
- kill req k
+ kill request k
+
+ toggle debug d toggle debug flag (see 386 & 68k stubs)
+ reset r reset -- see sparc stub.
+ reserved <other> On other requests, the stub should
+ ignore the request and send an empty
+ response ($#<checksum>). This way
+ we can extend the protocol and GDB
+ can tell whether the stub it is
+ talking to uses the old or the new.
*/
#include "defs.h"
#include "terminal.h"
#include "gdbcmd.h"
+#include "dcache.h"
+
#if !defined(DONT_USE_REMOTE)
#ifdef USG
#include <sys/types.h>
/* Prototypes for local functions */
-static void
-remote_write_bytes PARAMS ((CORE_ADDR memaddr, char *myaddr, int len));
+static int
+remote_write_bytes PARAMS ((CORE_ADDR memaddr, unsigned char *myaddr, int len));
-static void
-remote_read_bytes PARAMS ((CORE_ADDR memaddr, char *myaddr, int len));
+static int
+remote_read_bytes PARAMS ((CORE_ADDR memaddr, unsigned char *myaddr, int len));
static void
remote_files_info PARAMS ((struct target_ops *ignore));
remote_fetch_registers PARAMS ((int regno));
static void
-remote_resume PARAMS ((int step, int siggnal));
+remote_resume PARAMS ((int pid, int step, int siggnal));
static int
remote_start_remote PARAMS ((char *dummy));
extern struct target_ops remote_ops; /* Forward decl */
-static int kiodebug = 0;
/* 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
/* Open a connection to a remote debugger.
NAME is the filename used for communication. */
+static DCACHE *remote_dcache;
+
static void
remote_open (name, from_tty)
char *name;
unpush_target (&remote_ops);
-#if 0
- dcache_init ();
-#endif
+ remote_dcache = dcache_init (remote_read_bytes, remote_write_bytes);
remote_desc = SERIAL_OPEN (name);
if (!remote_desc)
/* Tell the remote machine to resume. */
static void
-remote_resume (step, siggnal)
- int step, siggnal;
+remote_resume (pid, step, siggnal)
+ int pid, step, siggnal;
{
char buf[PBUFSIZ];
target_terminal_inferior ();
}
-#if 0
- dcache_flush ();
-#endif
+ dcache_flush (remote_dcache);
strcpy (buf, step ? "s": "c");
/* If this doesn't work, try more severe steps. */
signal (signo, remote_interrupt_twice);
- if (kiodebug)
+ if (remote_debug)
printf ("remote_interrupt called\n");
SERIAL_WRITE (remote_desc, "\003", 1); /* Send a ^C */
remote_send (buf);
}
-#if 0
/* Read a word from remote address ADDR and return it.
This goes through the data cache. */
remote_fetch_word (addr)
CORE_ADDR addr;
{
+#if 0
if (icache)
{
extern CORE_ADDR text_start, text_end;
return buffer;
}
}
- return dcache_fetch (addr);
+#endif
+ return dcache_fetch (remote_dcache, addr);
}
/* Write a word WORD into remote address ADDR.
CORE_ADDR addr;
int word;
{
- dcache_poke (addr, word);
+ dcache_poke (remote_dcache, addr, word);
}
-#endif /* 0 */
+
\f
/* 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. */
+ LEN is the number of bytes.
-static void
+ Returns number of bytes transferred, or 0 for error. */
+
+static int
remote_write_bytes (memaddr, myaddr, len)
CORE_ADDR memaddr;
- char *myaddr;
+ unsigned char *myaddr;
int len;
{
char buf[PBUFSIZ];
}
*p = '\0';
- remote_send (buf);
+ putpkt (buf);
+ getpkt (buf, 0);
+
+ if (buf[0] == 'E')
+ {
+ /* There is no correspondance between what the remote protocol uses
+ for errors and errno codes. We would like a cleaner way of
+ representing errors (big enough to include errno codes, bfd_error
+ codes, and others). But for now just return EIO. */
+ errno = EIO;
+ return 0;
+ }
+ 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. */
+ LEN is the number of bytes.
-static void
+ Returns number of bytes transferred, or 0 for error. */
+
+static int
remote_read_bytes (memaddr, myaddr, len)
CORE_ADDR memaddr;
- char *myaddr;
+ unsigned char *myaddr;
int len;
{
char buf[PBUFSIZ];
abort ();
sprintf (buf, "m%x,%x", memaddr, len);
- remote_send (buf);
+ putpkt (buf);
+ getpkt (buf, 0);
+
+ if (buf[0] == 'E')
+ {
+ /* There is no correspondance between what the remote protocol uses
+ for errors and errno codes. We would like a cleaner way of
+ representing errors (big enough to include errno codes, bfd_error
+ codes, and others). But for now just return EIO. */
+ errno = EIO;
+ return 0;
+ }
/* Reply describes memory byte by byte,
each byte encoded as two hex characters. */
for (i = 0; i < len; i++)
{
if (p[0] == 0 || p[1] == 0)
- error ("Remote reply is too short: %s", buf);
+ /* Reply is short. This means that we were able to read only part
+ of what we wanted to. */
+ break;
myaddr[i] = fromhex (p[0]) * 16 + fromhex (p[1]);
p += 2;
}
+ return i;
}
\f
/* Read or write LEN bytes from inferior memory at MEMADDR, transferring
int should_write;
struct target_ops *target; /* ignored */
{
- int origlen = len;
int xfersize;
+ int bytes_xferred;
+ int total_xferred = 0;
+
while (len > 0)
{
if (len > MAXBUFBYTES)
xfersize = len;
if (should_write)
- remote_write_bytes(memaddr, myaddr, xfersize);
+ bytes_xferred = remote_write_bytes (memaddr, myaddr, xfersize);
else
- remote_read_bytes (memaddr, myaddr, xfersize);
- memaddr += xfersize;
- myaddr += xfersize;
- len -= xfersize;
+ bytes_xferred = remote_read_bytes (memaddr, 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 origlen; /* no error possible */
+ return total_xferred;
}
static void
while (1)
{
- if (kiodebug)
+ if (remote_debug)
{
*p = '\0';
printf ("Sending packet: %s...", buf2); fflush(stdout);
switch (ch)
{
case '+':
- if (kiodebug)
+ if (remote_debug)
printf("Ack\n");
return;
case SERIAL_TIMEOUT:
case SERIAL_EOF:
error ("putpkt: EOF while trying to read ACK");
default:
- if (kiodebug)
+ if (remote_debug)
printf ("%02X %c ", ch&0xFF, ch);
continue;
}
if (forever)
continue;
if (++retries >= MAX_RETRIES)
- if (kiodebug) puts_filtered ("Timed out.\n");
+ if (remote_debug) puts_filtered ("Timed out.\n");
goto out;
}
c = readchar ();
if (c == SERIAL_TIMEOUT)
{
- if (kiodebug)
+ if (remote_debug)
puts_filtered ("Timeout in mid-packet, retrying\n");
goto whole; /* Start a new packet, count retries */
}
if (c == '$')
{
- if (kiodebug)
+ if (remote_debug)
puts_filtered ("Saw new packet start in middle of old one\n");
goto whole; /* Start a new packet, count retries */
}
SERIAL_WRITE (remote_desc, "+", 1);
- if (kiodebug)
+ if (remote_debug)
fprintf (stderr,"Packet received: %s\n", buf);
}
\f
-/* The data cache leads to incorrect results because it doesn't know about
- volatile variables, thus making it impossible to debug functions which
- use hardware registers. Therefore it is #if 0'd out. Effect on
- performance is some, for backtraces of functions with a few
- arguments each. For functions with many arguments, the stack
- frames don't fit in the cache blocks, which makes the cache less
- helpful. Disabling the cache is a big performance win for fetching
- large structures, because the cache code fetched data in 16-byte
- chunks. */
-#if 0
-/* The data cache records all the data read from the remote machine
- since the last time it stopped.
-
- Each cache block holds 16 bytes of data
- starting at a multiple-of-16 address. */
-
-#define DCACHE_SIZE 64 /* Number of cache blocks */
-
-struct dcache_block {
- struct dcache_block *next, *last;
- unsigned int addr; /* Address for which data is recorded. */
- int data[4];
-};
-
-struct dcache_block dcache_free, dcache_valid;
-
-/* Free all the data cache blocks, thus discarding all cached data. */
-
-static void
-dcache_flush ()
-{
- register struct dcache_block *db;
-
- while ((db = dcache_valid.next) != &dcache_valid)
- {
- remque (db);
- insque (db, &dcache_free);
- }
-}
-
-/*
- * If addr is present in the dcache, return the address of the block
- * containing it.
- */
-
-struct dcache_block *
-dcache_hit (addr)
-{
- register struct dcache_block *db;
-
- if (addr & 3)
- abort ();
-
- /* Search all cache blocks for one that is at this address. */
- db = dcache_valid.next;
- while (db != &dcache_valid)
- {
- if ((addr & 0xfffffff0) == db->addr)
- return db;
- db = db->next;
- }
- return NULL;
-}
-
-/* Return the int data at address ADDR in dcache block DC. */
-
-int
-dcache_value (db, addr)
- struct dcache_block *db;
- unsigned int addr;
-{
- if (addr & 3)
- abort ();
- return (db->data[(addr>>2)&3]);
-}
-
-/* Get a free cache block, put it on the valid list,
- and return its address. The caller should store into the block
- the address and data that it describes. */
-
-struct dcache_block *
-dcache_alloc ()
-{
- register struct dcache_block *db;
-
- if ((db = dcache_free.next) == &dcache_free)
- /* If we can't get one from the free list, take last valid */
- db = dcache_valid.last;
-
- remque (db);
- insque (db, &dcache_valid);
- return (db);
-}
-
-/* Return the contents of the word at address ADDR in the remote machine,
- using the data cache. */
-
-int
-dcache_fetch (addr)
- CORE_ADDR addr;
-{
- register struct dcache_block *db;
-
- db = dcache_hit (addr);
- if (db == 0)
- {
- db = dcache_alloc ();
- remote_read_bytes (addr & ~0xf, db->data, 16);
- db->addr = addr & ~0xf;
- }
- return (dcache_value (db, addr));
-}
-
-/* Write the word at ADDR both in the data cache and in the remote machine. */
-
-dcache_poke (addr, data)
- CORE_ADDR addr;
- int data;
-{
- register struct dcache_block *db;
-
- /* First make sure the word is IN the cache. DB is its cache block. */
- db = dcache_hit (addr);
- if (db == 0)
- {
- db = dcache_alloc ();
- remote_read_bytes (addr & ~0xf, db->data, 16);
- db->addr = addr & ~0xf;
- }
-
- /* Modify the word in the cache. */
- db->data[(addr>>2)&3] = data;
-
- /* Send the changed word. */
- remote_write_bytes (addr, &data, 4);
-}
-
-/* Initialize the data cache. */
-
-dcache_init ()
-{
- register i;
- register struct dcache_block *db;
-
- db = (struct dcache_block *) xmalloc (sizeof (struct dcache_block) *
- DCACHE_SIZE);
- dcache_free.next = dcache_free.last = &dcache_free;
- dcache_valid.next = dcache_valid.last = &dcache_valid;
- for (i=0;i<DCACHE_SIZE;i++,db++)
- insque (db, &dcache_free);
-}
-#endif /* 0 */
-\f
static void
remote_kill ()
{
by the caller to be long enough to save sizeof BREAKPOINT bytes (this
is accomplished via BREAKPOINT_MAX). */
-int
+static int
remote_insert_breakpoint (addr, contents_cache)
CORE_ADDR addr;
char *contents_cache;
return val;
}
-int
+static int
remote_remove_breakpoint (addr, contents_cache)
CORE_ADDR addr;
char *contents_cache;
_initialize_remote ()
{
add_target (&remote_ops);
-
- add_show_from_set (
- add_set_cmd ("remotedebug", no_class, var_boolean, (char *)&kiodebug,
- "Set debugging of remote serial I/O.\n\
-When enabled, each packet sent or received with the remote target\n\
-is displayed.", &setlist),
- &showlist);
}
-
#endif
projects / binutils-gdb.git / commitdiff