X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fremote.c;h=efdc7d94a07a1fe1a9d12a000c28ce5ea3191704;hb=a94abe5bb7a71b207691f8b50406166eefda8186;hp=c26be3b2978d9aa32f35314bd2b1876f9c1665cb;hpb=a4cb75b801cd4653a68fc7eace04dac98c9438b1;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/remote.c b/gdb/remote.c index c26be3b297..efdc7d94a0 100644 --- a/gdb/remote.c +++ b/gdb/remote.c @@ -56,6 +56,8 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ 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 @@ -63,7 +65,9 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ 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, @@ -86,8 +90,32 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ AA = signal number n... = register number r... = register contents - - kill req k + or... WAA The process extited, and AA is + the exit status. This is only + applicable for certains sorts of + targets. + or... NAATT;DD;BB Relocate the object file. + AA = signal number + TT = text address + DD = data address + BB = bss address + This is used by the NLM stub, + which is why it only has three + addresses rather than one per + section: the NLM stub always + sees only three sections, even + though gdb may see more. + + kill request k + + toggle debug d toggle debug flag (see 386 & 68k stubs) + reset r reset -- see sparc stub. + reserved On other requests, the stub should + ignore the request and send an empty + response ($#). 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" @@ -101,6 +129,11 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include "wait.h" #include "terminal.h" #include "gdbcmd.h" +#include "objfiles.h" +#include "gdb-stabs.h" + +#include "dcache.h" +#include "remote-utils.h" #if !defined(DONT_USE_REMOTE) #ifdef USG @@ -112,66 +145,72 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ /* Prototypes for local functions */ -static void -remote_write_bytes PARAMS ((CORE_ADDR, char *, int)); +static int +remote_write_bytes PARAMS ((CORE_ADDR memaddr, unsigned char *myaddr, int len)); -static void -remote_read_bytes PARAMS ((CORE_ADDR, char *, int)); +static int +remote_read_bytes PARAMS ((CORE_ADDR memaddr, unsigned char *myaddr, int len)); static void -remote_files_info PARAMS ((struct target_ops *)); +remote_files_info PARAMS ((struct target_ops *ignore)); static int -remote_xfer_memory PARAMS ((CORE_ADDR, char *, int, int, struct target_ops *)); +remote_xfer_memory PARAMS ((CORE_ADDR memaddr, char *myaddr, int len, + int should_write, struct target_ops *target)); static void remote_prepare_to_store PARAMS ((void)); static void -remote_fetch_registers PARAMS ((int)); +remote_fetch_registers PARAMS ((int regno)); static void -remote_resume PARAMS ((int, int)); +remote_resume PARAMS ((int pid, int step, int siggnal)); static int -remote_start_remote PARAMS ((char *)); +remote_start_remote PARAMS ((char *dummy)); static void -remote_open PARAMS ((char *, int)); +remote_open PARAMS ((char *name, int from_tty)); static void -remote_close PARAMS ((int)); +remote_close PARAMS ((int quitting)); static void -remote_store_registers PARAMS ((int)); +remote_store_registers PARAMS ((int regno)); static void -getpkt PARAMS ((char *, int)); +getpkt PARAMS ((char *buf, int forever)); static void -putpkt PARAMS ((char *)); +putpkt PARAMS ((char *buf)); static void -remote_send PARAMS ((char *)); +remote_send PARAMS ((char *buf)); static int readchar PARAMS ((void)); static int -remote_wait PARAMS ((WAITTYPE *)); +remote_wait PARAMS ((WAITTYPE *status)); static int -tohex PARAMS ((int)); +tohex PARAMS ((int nib)); static int -fromhex PARAMS ((int)); +fromhex PARAMS ((int a)); static void -remote_detach PARAMS ((char *, int)); +remote_detach PARAMS ((char *args, int from_tty)); + +static void +remote_interrupt PARAMS ((int signo)); + +static void +remote_interrupt_twice PARAMS ((int signo)); 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 @@ -182,6 +221,10 @@ static int timeout = 2; int icache; #endif +/* FIXME: This is a hack which lets this file compile. It should be getting + this setting from remote-utils.c. */ +#define remote_debug (0) + /* Descriptor for I/O to remote machine. Initialize it to NULL so that remote_open knows that we don't have a file open when the program starts. */ @@ -217,11 +260,14 @@ static int remote_start_remote (dummy) char *dummy; { + immediate_quit = 1; /* Allow user to interrupt it */ + /* Ack any packet which the remote side has already sent. */ /* I'm not sure this \r is needed; we don't use it any other time we send an ack. */ SERIAL_WRITE (remote_desc, "+\r", 2); putpkt ("?"); /* initiate a query from remote machine */ + immediate_quit = 0; start_remote (); /* Initialize gdb process mechanisms */ return 1; @@ -230,6 +276,8 @@ remote_start_remote (dummy) /* 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; @@ -244,24 +292,16 @@ device is attached to the remote system (e.g. /dev/ttya)."); 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) perror_with_name (name); - if (baud_rate) + if (SERIAL_SETBAUDRATE (remote_desc, sr_get_baud_rate())) { - int rate; - - if (sscanf (baud_rate, "%d", &rate) == 1) - if (SERIAL_SETBAUDRATE (remote_desc, rate)) - { - SERIAL_CLOSE (remote_desc); - perror_with_name (name); - } + SERIAL_CLOSE (remote_desc); + perror_with_name (name); } SERIAL_RAW (remote_desc); @@ -274,8 +314,9 @@ device is attached to the remote system (e.g. /dev/ttya)."); } push_target (&remote_ops); /* Switch to using remote target now */ - /* Start the remote connection; if error (0), discard this target. */ - immediate_quit++; /* Allow user to interrupt it */ + /* 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 (remote_start_remote, (char *)0, "Couldn't establish connection to remote target\n", RETURN_MASK_ALL)) pop_target(); @@ -332,8 +373,8 @@ tohex (nib) /* 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]; @@ -351,33 +392,31 @@ remote_resume (step, siggnal) target_terminal_inferior (); } -#if 0 - dcache_flush (); -#endif + dcache_flush (remote_dcache); strcpy (buf, step ? "s": "c"); putpkt (buf); } -static void remote_interrupt_twice PARAMS ((int)); -static void (*ofunc)(); - /* Send ^C to target to halt it. Target will respond, and send us a packet. */ -void remote_interrupt(signo) +static void +remote_interrupt (signo) int signo; { /* 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 */ } +static void (*ofunc)(); + /* The user typed ^C twice. */ static void remote_interrupt_twice (signo) @@ -409,60 +448,136 @@ remote_wait (status) WAITTYPE *status; { unsigned char buf[PBUFSIZ]; - unsigned char *p; - int i; - long regno; - char regs[MAX_REGISTER_RAW_SIZE]; WSETEXIT ((*status), 0); - ofunc = (void (*)()) signal (SIGINT, remote_interrupt); - getpkt ((char *) buf, 1); - signal (SIGINT, ofunc); - - if (buf[0] == 'E') - error ("Remote failure reply: %s", buf); - if (buf[0] == 'T') + while (1) { - /* Expedited reply, containing Signal, {regno, reg} repeat */ - /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where - ss = signal number - n... = register number - r... = register contents - */ + unsigned char *p; - p = &buf[3]; /* after Txx */ + ofunc = (void (*)()) signal (SIGINT, remote_interrupt); + getpkt ((char *) buf, 1); + signal (SIGINT, ofunc); - while (*p) + if (buf[0] == 'E') + warning ("Remote failure reply: %s", buf); + else if (buf[0] == 'T') { - regno = strtol (p, &p, 16); /* Read the register number */ + int i; + long regno; + char regs[MAX_REGISTER_RAW_SIZE]; - if (*p++ != ':' - || regno >= NUM_REGS) - error ("Remote sent bad register number %s", buf); + /* Expedited reply, containing Signal, {regno, reg} repeat */ + /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where + ss = signal number + n... = register number + r... = register contents + */ - for (i = 0; i < REGISTER_RAW_SIZE (regno); i++) + p = &buf[3]; /* after Txx */ + + while (*p) { - if (p[0] == 0 || p[1] == 0) - error ("Remote reply is too short: %s", buf); - regs[i] = fromhex (p[0]) * 16 + fromhex (p[1]); - p += 2; - } + unsigned char *p1; + + regno = strtol (p, &p1, 16); /* Read the register number */ + + if (p1 == p) + warning ("Remote sent badly formed register number: %s\nPacket: '%s'\n", + p1, buf); + + p = p1; - if (*p++ != ';') - error("Remote register badly formatted: %s", buf); + if (*p++ != ':') + warning ("Malformed packet (missing colon): %s\nPacket: '%s'\n", + p, buf); - supply_register (regno, regs); + if (regno >= NUM_REGS) + warning ("Remote sent bad register number %d: %s\nPacket: '%s'\n", + regno, p, buf); + + for (i = 0; i < REGISTER_RAW_SIZE (regno); i++) + { + if (p[0] == 0 || p[1] == 0) + warning ("Remote reply is too short: %s", buf); + regs[i] = fromhex (p[0]) * 16 + fromhex (p[1]); + p += 2; + } + + if (*p++ != ';') + warning ("Remote register badly formatted: %s", buf); + + supply_register (regno, regs); + } + break; } + else if (buf[0] == 'N') + { + unsigned char *p1; + bfd_vma text_addr, data_addr, bss_addr; + + /* Relocate object file. Format is NAATT;DD;BB where AA is + the signal number, TT is the new text address, DD is the + new data address, and BB is the new bss address. This is + used by the NLM stub; gdb may see more sections. */ + p = &buf[3]; + text_addr = strtol (p, &p1, 16); + if (p1 == p || *p1 != ';') + warning ("Malformed relocation packet: Packet '%s'", buf); + p = p1 + 1; + data_addr = strtol (p, &p1, 16); + if (p1 == p || *p1 != ';') + warning ("Malformed relocation packet: Packet '%s'", buf); + p = p1 + 1; + bss_addr = strtol (p, &p1, 16); + if (p1 == p) + warning ("Malformed relocation packet: Packet '%s'", buf); + + if (symfile_objfile != NULL) + { + struct section_offsets *offs; + + /* FIXME: Why don't the various symfile_offsets routines + in the sym_fns vectors set this? */ + if (symfile_objfile->num_sections == 0) + symfile_objfile->num_sections = SECT_OFF_MAX; + + offs = ((struct section_offsets *) + alloca (sizeof (struct section_offsets) + + (symfile_objfile->num_sections + * sizeof (offs->offsets)))); + memcpy (offs, symfile_objfile->section_offsets, + (sizeof (struct section_offsets) + + (symfile_objfile->num_sections + * sizeof (offs->offsets)))); + ANOFFSET (offs, SECT_OFF_TEXT) = text_addr; + ANOFFSET (offs, SECT_OFF_DATA) = data_addr; + ANOFFSET (offs, SECT_OFF_BSS) = bss_addr; + + objfile_relocate (symfile_objfile, offs); + } + break; + } + else if (buf[0] == 'W') + { + /* The remote process exited. */ + WSETEXIT (*status, (fromhex (buf[1]) << 4) + fromhex (buf[2])); + return 0; + } + else if (buf[0] == 'S') + break; + else + warning ("Invalid remote reply: %s", buf); } - else if (buf[0] != 'S') - error ("Invalid remote reply: %s", buf); WSETSTOP ((*status), (((fromhex (buf[1])) << 4) + (fromhex (buf[2])))); return 0; } +/* Number of bytes of registers this stub 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. */ /* ARGSUSED */ @@ -478,6 +593,9 @@ remote_fetch_registers (regno) sprintf (buf, "g"); remote_send (buf); + /* Unimplemented registers read as all bits zero. */ + memset (regs, 0, REGISTER_BYTES); + /* Reply describes registers byte by byte, each byte encoded as two hex characters. Suck them all up, then supply them to the register cacheing/storage mechanism. */ @@ -485,11 +603,29 @@ remote_fetch_registers (regno) p = buf; for (i = 0; i < REGISTER_BYTES; i++) { - if (p[0] == 0 || p[1] == 0) - error ("Remote reply is too short: %s", buf); + if (p[0] == 0) + break; + if (p[1] == 0) + { + warning ("Remote reply is of odd length: %s", buf); + /* Don't change register_bytes_found in this case, and don't + print a second warning. */ + goto supply_them; + } regs[i] = fromhex (p[0]) * 16 + fromhex (p[1]); p += 2; } + + if (i != register_bytes_found) + { + register_bytes_found = i; +#ifdef REGISTER_BYTES_OK + if (!REGISTER_BYTES_OK (i)) + warning ("Remote reply is too short: %s", buf); +#endif + } + + supply_them: for (i = 0; i < NUM_REGS; i++) supply_register (i, ®s[REGISTER_BYTE(i)]); } @@ -522,7 +658,8 @@ remote_store_registers (regno) each byte encoded as two hex characters. */ p = buf + 1; - for (i = 0; i < REGISTER_BYTES; i++) + /* remote_prepare_to_store insures that register_bytes_found gets set. */ + for (i = 0; i < register_bytes_found; i++) { *p++ = tohex ((registers[i] >> 4) & 0xf); *p++ = tohex (registers[i] & 0xf); @@ -533,13 +670,24 @@ remote_store_registers (regno) } #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 `volatile' + 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. */ -int +static int remote_fetch_word (addr) CORE_ADDR addr; { +#if 0 if (icache) { extern CORE_ADDR text_start, text_end; @@ -551,18 +699,19 @@ remote_fetch_word (addr) return buffer; } } - return dcache_fetch (addr); +#endif + return dcache_fetch (remote_dcache, addr); } /* Write a word WORD into remote address ADDR. This goes through the data cache. */ -void +static void remote_store_word (addr, word) CORE_ADDR addr; int word; { - dcache_poke (addr, word); + dcache_poke (remote_dcache, addr, word); } #endif /* 0 */ @@ -570,12 +719,14 @@ remote_store_word (addr, word) 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]; @@ -598,19 +749,33 @@ remote_write_bytes (memaddr, myaddr, len) } *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]; @@ -621,7 +786,18 @@ remote_read_bytes (memaddr, myaddr, len) 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. */ @@ -630,10 +806,13 @@ remote_read_bytes (memaddr, myaddr, len) 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; } /* Read or write LEN bytes from inferior memory at MEMADDR, transferring @@ -649,8 +828,10 @@ remote_xfer_memory(memaddr, myaddr, len, should_write, target) 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) @@ -659,19 +840,25 @@ remote_xfer_memory(memaddr, myaddr, len, should_write, target) 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 remote_files_info (ignore) -struct target_ops *ignore; + struct target_ops *ignore; { puts_filtered ("Debugging a target over a serial line.\n"); } @@ -746,7 +933,7 @@ putpkt (buf) while (1) { - if (kiodebug) + if (remote_debug) { *p = '\0'; printf ("Sending packet: %s...", buf2); fflush(stdout); @@ -762,7 +949,7 @@ putpkt (buf) switch (ch) { case '+': - if (kiodebug) + if (remote_debug) printf("Ack\n"); return; case SERIAL_TIMEOUT: @@ -772,7 +959,7 @@ putpkt (buf) case SERIAL_EOF: error ("putpkt: EOF while trying to read ACK"); default: - if (kiodebug) + if (remote_debug) printf ("%02X %c ", ch&0xFF, ch); continue; } @@ -813,7 +1000,7 @@ getpkt (buf, forever) if (forever) continue; if (++retries >= MAX_RETRIES) - if (kiodebug) puts_filtered ("Timed out.\n"); + if (remote_debug) puts_filtered ("Timed out.\n"); goto out; } @@ -831,13 +1018,13 @@ getpkt (buf, forever) 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 */ } @@ -882,177 +1069,72 @@ out: SERIAL_WRITE (remote_desc, "+", 1); - if (kiodebug) + if (remote_debug) fprintf (stderr,"Packet received: %s\n", buf); } -/* 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) +remote_kill () { - 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; + putpkt ("k"); + /* Don't wait for it to die. I'm not really sure it matters whether + we do or not. For the existing stubs, kill is a noop. */ + target_mourn_inferior (); } -/* Return the int data at address ADDR in dcache block DC. */ - -int -dcache_value (db, addr) - struct dcache_block *db; - unsigned int addr; +static void +remote_mourn () { - if (addr & 3) - abort (); - return (db->data[(addr>>2)&3]); + unpush_target (&remote_ops); + generic_mourn_inferior (); } + +#ifdef REMOTE_BREAKPOINT -/* 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. */ +/* On some machines, e.g. 68k, we may use a different breakpoint instruction + than other targets. */ +static unsigned char break_insn[] = REMOTE_BREAKPOINT; -struct dcache_block * -dcache_alloc () -{ - register struct dcache_block *db; +/* Check that it fits in BREAKPOINT_MAX bytes. */ +static unsigned char check_break_insn_size[BREAKPOINT_MAX] = REMOTE_BREAKPOINT; - if ((db = dcache_free.next) == &dcache_free) - /* If we can't get one from the free list, take last valid */ - db = dcache_valid.last; +#else /* No REMOTE_BREAKPOINT. */ - remque (db); - insque (db, &dcache_valid); - return (db); -} +/* Same old breakpoint instruction. This code does nothing different + than mem-break.c. */ +static unsigned char break_insn[] = BREAKPOINT; -/* Return the contents of the word at address ADDR in the remote machine, - using the data cache. */ +#endif /* No REMOTE_BREAKPOINT. */ -int -dcache_fetch (addr) - CORE_ADDR addr; -{ - register struct dcache_block *db; +/* 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). */ - 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) +static int +remote_insert_breakpoint (addr, contents_cache) CORE_ADDR addr; - int data; + char *contents_cache; { - register struct dcache_block *db; + int val; - /* 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; - } + val = target_read_memory (addr, contents_cache, sizeof break_insn); - /* Modify the word in the cache. */ - db->data[(addr>>2)&3] = data; + if (val == 0) + val = target_write_memory (addr, (char *)break_insn, sizeof break_insn); - /* Send the changed word. */ - remote_write_bytes (addr, &data, 4); + return val; } -/* 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