7775b6286416df13c64214de99d9cfe49b701af2
1 /* Remote target communications for serial-line targets in custom GDB protocol
2 Copyright 1988, 1991, 1992, 1993 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
20 /* Remote communication protocol.
22 A debug packet whose contents are <data>
23 is encapsulated for transmission in the form:
25 $ <data> # CSUM1 CSUM2
27 <data> must be ASCII alphanumeric and cannot include characters
30 CSUM1 and CSUM2 are ascii hex representation of an 8-bit
31 checksum of <data>, the most significant nibble is sent first.
32 the hex digits 0-9,a-f are used.
34 Receiver responds with:
36 + - if CSUM is correct and ready for next packet
37 - - if CSUM is incorrect
40 All values are encoded in ascii hex digits.
45 reply XX....X Each byte of register data
46 is described by two hex digits.
47 Registers are in the internal order
48 for GDB, and the bytes in a register
49 are in the same order the machine uses.
52 write regs GXX..XX Each byte of register data
53 is described by two hex digits.
57 read mem mAA..AA,LLLL AA..AA is address, LLLL is length.
58 reply XX..XX XX..XX is mem contents
59 Can be fewer bytes than requested
60 if able to read only part of the data.
63 write mem MAA..AA,LLLL:XX..XX
65 LLLL is number of bytes,
68 ENN for an error (this includes the case
69 where only part of the data was
72 cont cAA..AA AA..AA is address to resume
74 resume at same address.
76 step sAA..AA AA..AA is address to resume
78 resume at same address.
80 last signal ? Reply the current reason for stopping.
81 This is the same reply as is generated
82 for step or cont : SAA where AA is the
85 There is no immediate reply to step or cont.
86 The reply comes when the machine stops.
87 It is SAA AA is the "signal number"
89 or... TAAn...:r...;n:r...;n...:r...;
91 n... = register number
92 r... = register contents
93 or... WAA The process extited, and AA is
94 the exit status. This is only
95 applicable for certains sorts of
97 or... NAATT;DD;BB Relocate the object file.
102 This is used by the NLM stub,
103 which is why it only has three
104 addresses rather than one per
105 section: the NLM stub always
106 sees only three sections, even
107 though gdb may see more.
111 toggle debug d toggle debug flag (see 386 & 68k stubs)
112 reset r reset -- see sparc stub.
113 reserved <other> On other requests, the stub should
114 ignore the request and send an empty
115 response ($#<checksum>). This way
116 we can extend the protocol and GDB
117 can tell whether the stub it is
118 talking to uses the old or the new.
125 #include "inferior.h"
130 #include "terminal.h"
132 #include "objfiles.h"
133 #include "gdb-stabs.h"
137 #if !defined(DONT_USE_REMOTE)
139 #include <sys/types.h>
145 /* Prototypes for local functions */
148 remote_write_bytes
PARAMS ((CORE_ADDR memaddr
, unsigned char *myaddr
, int len
));
151 remote_read_bytes
PARAMS ((CORE_ADDR memaddr
, unsigned char *myaddr
, int len
));
154 remote_files_info
PARAMS ((struct target_ops
*ignore
));
157 remote_xfer_memory
PARAMS ((CORE_ADDR memaddr
, char *myaddr
, int len
,
158 int should_write
, struct target_ops
*target
));
161 remote_prepare_to_store
PARAMS ((void));
164 remote_fetch_registers
PARAMS ((int regno
));
167 remote_resume
PARAMS ((int pid
, int step
, int siggnal
));
170 remote_start_remote
PARAMS ((char *dummy
));
173 remote_open
PARAMS ((char *name
, int from_tty
));
176 remote_close
PARAMS ((int quitting
));
179 remote_store_registers
PARAMS ((int regno
));
182 getpkt
PARAMS ((char *buf
, int forever
));
185 putpkt
PARAMS ((char *buf
));
188 remote_send
PARAMS ((char *buf
));
191 readchar
PARAMS ((void));
194 remote_wait
PARAMS ((WAITTYPE
*status
));
197 tohex
PARAMS ((int nib
));
200 fromhex
PARAMS ((int a
));
203 remote_detach
PARAMS ((char *args
, int from_tty
));
206 remote_interrupt
PARAMS ((int signo
));
209 remote_interrupt_twice
PARAMS ((int signo
));
211 extern struct target_ops remote_ops
; /* Forward decl */
213 /* This was 5 seconds, which is a long time to sit and wait.
214 Unless this is going though some terminal server or multiplexer or
215 other form of hairy serial connection, I would think 2 seconds would
217 static int timeout
= 2;
223 /* FIXME: This is a hack which lets this file compile. It should be getting
224 this setting from remote-utils.c. */
225 #define remote_debug (0)
227 /* Descriptor for I/O to remote machine. Initialize it to NULL so that
228 remote_open knows that we don't have a file open when the program
230 serial_t remote_desc
= NULL
;
234 /* Maximum number of bytes to read/write at once. The value here
235 is chosen to fill up a packet (the headers account for the 32). */
236 #define MAXBUFBYTES ((PBUFSIZ-32)/2)
238 /* Round up PBUFSIZ to hold all the registers, at least. */
239 #if REGISTER_BYTES > MAXBUFBYTES
241 #define PBUFSIZ (REGISTER_BYTES * 2 + 32)
244 /* Clean up connection to a remote debugger. */
248 remote_close (quitting
)
252 SERIAL_CLOSE (remote_desc
);
256 /* Stub for catch_errors. */
259 remote_start_remote (dummy
)
262 immediate_quit
= 1; /* Allow user to interrupt it */
264 /* Ack any packet which the remote side has already sent. */
265 /* I'm not sure this \r is needed; we don't use it any other time we
267 SERIAL_WRITE (remote_desc
, "+\r", 2);
268 putpkt ("?"); /* initiate a query from remote machine */
271 start_remote (); /* Initialize gdb process mechanisms */
275 /* Open a connection to a remote debugger.
276 NAME is the filename used for communication. */
278 static DCACHE
*remote_dcache
;
281 remote_open (name
, from_tty
)
287 "To open a remote debug connection, you need to specify what serial\n\
288 device is attached to the remote system (e.g. /dev/ttya).");
290 target_preopen (from_tty
);
292 unpush_target (&remote_ops
);
294 remote_dcache
= dcache_init (remote_read_bytes
, remote_write_bytes
);
296 remote_desc
= SERIAL_OPEN (name
);
298 perror_with_name (name
);
301 /* FIXME: This should be using remote-utils.c. */
306 if (sscanf (baud_rate
, "%d", &rate
) == 1)
307 if (SERIAL_SETBAUDRATE (remote_desc
, rate
))
309 SERIAL_CLOSE (remote_desc
);
310 perror_with_name (name
);
315 SERIAL_RAW (remote_desc
);
319 puts_filtered ("Remote debugging using ");
320 puts_filtered (name
);
321 puts_filtered ("\n");
323 push_target (&remote_ops
); /* Switch to using remote target now */
325 /* Start the remote connection; if error (0), discard this target.
326 In particular, if the user quits, be sure to discard it
327 (we'd be in an inconsistent state otherwise). */
328 if (!catch_errors (remote_start_remote
, (char *)0,
329 "Couldn't establish connection to remote target\n", RETURN_MASK_ALL
))
334 takes a program previously attached to and detaches it.
335 We better not have left any breakpoints
336 in the program or it'll die when it hits one.
337 Close the open connection to the remote debugger.
338 Use this when you want to detach and do something else
342 remote_detach (args
, from_tty
)
347 error ("Argument given to \"detach\" when remotely debugging.");
351 puts_filtered ("Ending remote debugging.\n");
354 /* Convert hex digit A to a number. */
360 if (a
>= '0' && a
<= '9')
362 else if (a
>= 'a' && a
<= 'f')
365 error ("Reply contains invalid hex digit");
369 /* Convert number NIB to a hex digit. */
381 /* Tell the remote machine to resume. */
384 remote_resume (pid
, step
, siggnal
)
385 int pid
, step
, siggnal
;
392 target_terminal_ours_for_output ();
393 printf_filtered ("Can't send signals to a remote system. ");
394 name
= strsigno (siggnal
);
396 printf_filtered (name
);
398 printf_filtered ("Signal %d", siggnal
);
399 printf_filtered (" not sent.\n");
400 target_terminal_inferior ();
403 dcache_flush (remote_dcache
);
405 strcpy (buf
, step
? "s": "c");
410 /* Send ^C to target to halt it. Target will respond, and send us a
414 remote_interrupt (signo
)
417 /* If this doesn't work, try more severe steps. */
418 signal (signo
, remote_interrupt_twice
);
421 printf ("remote_interrupt called\n");
423 SERIAL_WRITE (remote_desc
, "\003", 1); /* Send a ^C */
426 static void (*ofunc
)();
428 /* The user typed ^C twice. */
430 remote_interrupt_twice (signo
)
433 signal (signo
, ofunc
);
435 target_terminal_ours ();
436 if (query ("Interrupted while waiting for the program.\n\
437 Give up (and stop debugging it)? "))
439 target_mourn_inferior ();
440 return_to_top_level (RETURN_QUIT
);
444 signal (signo
, remote_interrupt
);
445 target_terminal_inferior ();
449 /* Wait until the remote machine stops, then return,
450 storing status in STATUS just as `wait' would.
451 Returns "pid" (though it's not clear what, if anything, that
452 means in the case of this target). */
458 unsigned char buf
[PBUFSIZ
];
460 WSETEXIT ((*status
), 0);
466 ofunc
= (void (*)()) signal (SIGINT
, remote_interrupt
);
467 getpkt ((char *) buf
, 1);
468 signal (SIGINT
, ofunc
);
471 warning ("Remote failure reply: %s", buf
);
472 else if (buf
[0] == 'T')
476 char regs
[MAX_REGISTER_RAW_SIZE
];
478 /* Expedited reply, containing Signal, {regno, reg} repeat */
479 /* format is: 'Tssn...:r...;n...:r...;n...:r...;#cc', where
481 n... = register number
482 r... = register contents
485 p
= &buf
[3]; /* after Txx */
491 regno
= strtol (p
, &p1
, 16); /* Read the register number */
494 warning ("Remote sent badly formed register number: %s\nPacket: '%s'\n",
500 warning ("Malformed packet (missing colon): %s\nPacket: '%s'\n",
503 if (regno
>= NUM_REGS
)
504 warning ("Remote sent bad register number %d: %s\nPacket: '%s'\n",
507 for (i
= 0; i
< REGISTER_RAW_SIZE (regno
); i
++)
509 if (p
[0] == 0 || p
[1] == 0)
510 warning ("Remote reply is too short: %s", buf
);
511 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
516 warning ("Remote register badly formatted: %s", buf
);
518 supply_register (regno
, regs
);
522 else if (buf
[0] == 'N')
525 bfd_vma text_addr
, data_addr
, bss_addr
;
527 /* Relocate object file. Format is NAATT;DD;BB where AA is
528 the signal number, TT is the new text address, DD is the
529 new data address, and BB is the new bss address. This is
530 used by the NLM stub; gdb may see more sections. */
532 text_addr
= strtol (p
, &p1
, 16);
533 if (p1
== p
|| *p1
!= ';')
534 warning ("Malformed relocation packet: Packet '%s'", buf
);
536 data_addr
= strtol (p
, &p1
, 16);
537 if (p1
== p
|| *p1
!= ';')
538 warning ("Malformed relocation packet: Packet '%s'", buf
);
540 bss_addr
= strtol (p
, &p1
, 16);
542 warning ("Malformed relocation packet: Packet '%s'", buf
);
544 if (symfile_objfile
!= NULL
)
546 struct section_offsets
*offs
;
548 /* FIXME: Why don't the various symfile_offsets routines
549 in the sym_fns vectors set this? */
550 if (symfile_objfile
->num_sections
== 0)
551 symfile_objfile
->num_sections
= SECT_OFF_MAX
;
553 offs
= ((struct section_offsets
*)
554 alloca (sizeof (struct section_offsets
)
555 + (symfile_objfile
->num_sections
556 * sizeof (offs
->offsets
))));
557 memcpy (offs
, symfile_objfile
->section_offsets
,
558 (sizeof (struct section_offsets
)
559 + (symfile_objfile
->num_sections
560 * sizeof (offs
->offsets
))));
561 ANOFFSET (offs
, SECT_OFF_TEXT
) = text_addr
;
562 ANOFFSET (offs
, SECT_OFF_DATA
) = data_addr
;
563 ANOFFSET (offs
, SECT_OFF_BSS
) = bss_addr
;
565 objfile_relocate (symfile_objfile
, offs
);
569 else if (buf
[0] == 'W')
571 /* The remote process exited. */
572 WSETEXIT (*status
, (fromhex (buf
[1]) << 4) + fromhex (buf
[2]));
575 else if (buf
[0] == 'S')
578 warning ("Invalid remote reply: %s", buf
);
581 WSETSTOP ((*status
), (((fromhex (buf
[1])) << 4) + (fromhex (buf
[2]))));
586 /* Number of bytes of registers this stub implements. */
587 static int register_bytes_found
;
589 /* Read the remote registers into the block REGS. */
590 /* Currently we just read all the registers, so we don't use regno. */
593 remote_fetch_registers (regno
)
599 char regs
[REGISTER_BYTES
];
604 /* Unimplemented registers read as all bits zero. */
605 memset (regs
, 0, REGISTER_BYTES
);
607 /* Reply describes registers byte by byte, each byte encoded as two
608 hex characters. Suck them all up, then supply them to the
609 register cacheing/storage mechanism. */
612 for (i
= 0; i
< REGISTER_BYTES
; i
++)
618 warning ("Remote reply is of odd length: %s", buf
);
619 /* Don't change register_bytes_found in this case, and don't
620 print a second warning. */
623 regs
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
627 if (i
!= register_bytes_found
)
629 register_bytes_found
= i
;
630 #ifdef REGISTER_BYTES_OK
631 if (!REGISTER_BYTES_OK (i
))
632 warning ("Remote reply is too short: %s", buf
);
637 for (i
= 0; i
< NUM_REGS
; i
++)
638 supply_register (i
, ®s
[REGISTER_BYTE(i
)]);
641 /* Prepare to store registers. Since we send them all, we have to
642 read out the ones we don't want to change first. */
645 remote_prepare_to_store ()
647 /* Make sure the entire registers array is valid. */
648 read_register_bytes (0, (char *)NULL
, REGISTER_BYTES
);
651 /* Store the remote registers from the contents of the block REGISTERS.
652 FIXME, eventually just store one register if that's all that is needed. */
656 remote_store_registers (regno
)
665 /* Command describes registers byte by byte,
666 each byte encoded as two hex characters. */
669 /* remote_prepare_to_store insures that register_bytes_found gets set. */
670 for (i
= 0; i
< register_bytes_found
; i
++)
672 *p
++ = tohex ((registers
[i
] >> 4) & 0xf);
673 *p
++ = tohex (registers
[i
] & 0xf);
682 /* Use of the data cache is disabled because it loses for looking at
683 and changing hardware I/O ports and the like. Accepting `volatile'
684 would perhaps be one way to fix it, but a better way which would
685 win for more cases would be to use the executable file for the text
686 segment, like the `icache' code below but done cleanly (in some
687 target-independent place, perhaps in target_xfer_memory, perhaps
688 based on assigning each target a speed or perhaps by some simpler
691 /* Read a word from remote address ADDR and return it.
692 This goes through the data cache. */
695 remote_fetch_word (addr
)
701 extern CORE_ADDR text_start
, text_end
;
703 if (addr
>= text_start
&& addr
< text_end
)
706 xfer_core_file (addr
, &buffer
, sizeof (int));
711 return dcache_fetch (remote_dcache
, addr
);
714 /* Write a word WORD into remote address ADDR.
715 This goes through the data cache. */
718 remote_store_word (addr
, word
)
722 dcache_poke (remote_dcache
, addr
, word
);
726 /* Write memory data directly to the remote machine.
727 This does not inform the data cache; the data cache uses this.
728 MEMADDR is the address in the remote memory space.
729 MYADDR is the address of the buffer in our space.
730 LEN is the number of bytes.
732 Returns number of bytes transferred, or 0 for error. */
735 remote_write_bytes (memaddr
, myaddr
, len
)
737 unsigned char *myaddr
;
744 if (len
> PBUFSIZ
/ 2 - 20)
747 sprintf (buf
, "M%x,%x:", memaddr
, len
);
749 /* We send target system values byte by byte, in increasing byte addresses,
750 each byte encoded as two hex characters. */
752 p
= buf
+ strlen (buf
);
753 for (i
= 0; i
< len
; i
++)
755 *p
++ = tohex ((myaddr
[i
] >> 4) & 0xf);
756 *p
++ = tohex (myaddr
[i
] & 0xf);
765 /* There is no correspondance between what the remote protocol uses
766 for errors and errno codes. We would like a cleaner way of
767 representing errors (big enough to include errno codes, bfd_error
768 codes, and others). But for now just return EIO. */
775 /* Read memory data directly from the remote machine.
776 This does not use the data cache; the data cache uses this.
777 MEMADDR is the address in the remote memory space.
778 MYADDR is the address of the buffer in our space.
779 LEN is the number of bytes.
781 Returns number of bytes transferred, or 0 for error. */
784 remote_read_bytes (memaddr
, myaddr
, len
)
786 unsigned char *myaddr
;
793 if (len
> PBUFSIZ
/ 2 - 1)
796 sprintf (buf
, "m%x,%x", memaddr
, len
);
802 /* There is no correspondance between what the remote protocol uses
803 for errors and errno codes. We would like a cleaner way of
804 representing errors (big enough to include errno codes, bfd_error
805 codes, and others). But for now just return EIO. */
810 /* Reply describes memory byte by byte,
811 each byte encoded as two hex characters. */
814 for (i
= 0; i
< len
; i
++)
816 if (p
[0] == 0 || p
[1] == 0)
817 /* Reply is short. This means that we were able to read only part
818 of what we wanted to. */
820 myaddr
[i
] = fromhex (p
[0]) * 16 + fromhex (p
[1]);
826 /* Read or write LEN bytes from inferior memory at MEMADDR, transferring
827 to or from debugger address MYADDR. Write to inferior if SHOULD_WRITE is
828 nonzero. Returns length of data written or read; 0 for error. */
832 remote_xfer_memory(memaddr
, myaddr
, len
, should_write
, target
)
837 struct target_ops
*target
; /* ignored */
841 int total_xferred
= 0;
845 if (len
> MAXBUFBYTES
)
846 xfersize
= MAXBUFBYTES
;
851 bytes_xferred
= remote_write_bytes (memaddr
, myaddr
, xfersize
);
853 bytes_xferred
= remote_read_bytes (memaddr
, myaddr
, xfersize
);
855 /* If we get an error, we are done xferring. */
856 if (bytes_xferred
== 0)
859 memaddr
+= bytes_xferred
;
860 myaddr
+= bytes_xferred
;
861 len
-= bytes_xferred
;
862 total_xferred
+= bytes_xferred
;
864 return total_xferred
;
868 remote_files_info (ignore
)
869 struct target_ops
*ignore
;
871 puts_filtered ("Debugging a target over a serial line.\n");
874 /* Stuff for dealing with the packets which are part of this protocol.
875 See comment at top of file for details. */
877 /* Read a single character from the remote end, masking it down to 7 bits. */
884 ch
= SERIAL_READCHAR (remote_desc
, timeout
);
892 /* Send the command in BUF to the remote machine,
893 and read the reply into BUF.
894 Report an error if we get an error reply. */
905 error ("Remote failure reply: %s", buf
);
908 /* Send a packet to the remote machine, with error checking.
909 The data of the packet is in BUF. */
916 unsigned char csum
= 0;
918 int cnt
= strlen (buf
);
922 /* Copy the packet into buffer BUF2, encapsulating it
923 and giving it a checksum. */
925 if (cnt
> sizeof(buf2
) - 5) /* Prosanity check */
931 for (i
= 0; i
< cnt
; i
++)
937 *p
++ = tohex ((csum
>> 4) & 0xf);
938 *p
++ = tohex (csum
& 0xf);
940 /* Send it over and over until we get a positive ack. */
947 printf ("Sending packet: %s...", buf2
); fflush(stdout
);
949 if (SERIAL_WRITE (remote_desc
, buf2
, p
- buf2
))
950 perror_with_name ("putpkt: write failed");
952 /* read until either a timeout occurs (-2) or '+' is read */
964 break; /* Retransmit buffer */
966 perror_with_name ("putpkt: couldn't read ACK");
968 error ("putpkt: EOF while trying to read ACK");
971 printf ("%02X %c ", ch
&0xFF, ch
);
974 break; /* Here to retransmit */
979 /* Read a packet from the remote machine, with error checking,
980 and store it in BUF. BUF is expected to be of size PBUFSIZ.
981 If FOREVER, wait forever rather than timing out; this is used
982 while the target is executing user code. */
985 getpkt (buf
, forever
)
992 unsigned char c1
, c2
;
994 #define MAX_RETRIES 10
998 /* This can loop forever if the remote side sends us characters
999 continuously, but if it pauses, we'll get a zero from readchar
1000 because of timeout. Then we'll count that as a retry. */
1003 if (c
> 0 && c
!= '$')
1006 if (c
== SERIAL_TIMEOUT
)
1010 if (++retries
>= MAX_RETRIES
)
1011 if (remote_debug
) puts_filtered ("Timed out.\n");
1015 if (c
== SERIAL_EOF
)
1016 error ("Remote connection closed");
1017 if (c
== SERIAL_ERROR
)
1018 perror_with_name ("Remote communication error");
1020 /* Force csum to be zero here because of possible error retry. */
1027 if (c
== SERIAL_TIMEOUT
)
1030 puts_filtered ("Timeout in mid-packet, retrying\n");
1031 goto whole
; /* Start a new packet, count retries */
1036 puts_filtered ("Saw new packet start in middle of old one\n");
1037 goto whole
; /* Start a new packet, count retries */
1041 if (bp
>= buf
+PBUFSIZ
-1)
1044 puts_filtered ("Remote packet too long: ");
1045 puts_filtered (buf
);
1046 puts_filtered ("\n");
1054 c1
= fromhex (readchar ());
1055 c2
= fromhex (readchar ());
1056 if ((csum
& 0xff) == (c1
<< 4) + c2
)
1058 printf_filtered ("Bad checksum, sentsum=0x%x, csum=0x%x, buf=",
1059 (c1
<< 4) + c2
, csum
& 0xff);
1060 puts_filtered (buf
);
1061 puts_filtered ("\n");
1063 /* Try the whole thing again. */
1065 if (++retries
< MAX_RETRIES
)
1067 SERIAL_WRITE (remote_desc
, "-", 1);
1071 printf ("Ignoring packet error, continuing...\n");
1078 SERIAL_WRITE (remote_desc
, "+", 1);
1081 fprintf (stderr
,"Packet received: %s\n", buf
);
1088 /* Don't wait for it to die. I'm not really sure it matters whether
1089 we do or not. For the existing stubs, kill is a noop. */
1090 target_mourn_inferior ();
1096 unpush_target (&remote_ops
);
1097 generic_mourn_inferior ();
1100 #ifdef REMOTE_BREAKPOINT
1102 /* On some machines, e.g. 68k, we may use a different breakpoint instruction
1103 than other targets. */
1104 static unsigned char break_insn
[] = REMOTE_BREAKPOINT
;
1106 /* Check that it fits in BREAKPOINT_MAX bytes. */
1107 static unsigned char check_break_insn_size
[BREAKPOINT_MAX
] = REMOTE_BREAKPOINT
;
1109 #else /* No REMOTE_BREAKPOINT. */
1111 /* Same old breakpoint instruction. This code does nothing different
1112 than mem-break.c. */
1113 static unsigned char break_insn
[] = BREAKPOINT
;
1115 #endif /* No REMOTE_BREAKPOINT. */
1117 /* Insert a breakpoint on targets that don't have any better breakpoint
1118 support. We read the contents of the target location and stash it,
1119 then overwrite it with a breakpoint instruction. ADDR is the target
1120 location in the target machine. CONTENTS_CACHE is a pointer to
1121 memory allocated for saving the target contents. It is guaranteed
1122 by the caller to be long enough to save sizeof BREAKPOINT bytes (this
1123 is accomplished via BREAKPOINT_MAX). */
1126 remote_insert_breakpoint (addr
, contents_cache
)
1128 char *contents_cache
;
1132 val
= target_read_memory (addr
, contents_cache
, sizeof break_insn
);
1135 val
= target_write_memory (addr
, (char *)break_insn
, sizeof break_insn
);
1141 remote_remove_breakpoint (addr
, contents_cache
)
1143 char *contents_cache
;
1145 return target_write_memory (addr
, contents_cache
, sizeof break_insn
);
1148 /* Define the target subroutine names */
1150 struct target_ops remote_ops
= {
1151 "remote", /* to_shortname */
1152 "Remote serial target in gdb-specific protocol", /* to_longname */
1153 "Use a remote computer via a serial line, using a gdb-specific protocol.\n\
1154 Specify the serial device it is connected to (e.g. /dev/ttya).", /* to_doc */
1155 remote_open
, /* to_open */
1156 remote_close
, /* to_close */
1157 NULL
, /* to_attach */
1158 remote_detach
, /* to_detach */
1159 remote_resume
, /* to_resume */
1160 remote_wait
, /* to_wait */
1161 remote_fetch_registers
, /* to_fetch_registers */
1162 remote_store_registers
, /* to_store_registers */
1163 remote_prepare_to_store
, /* to_prepare_to_store */
1164 remote_xfer_memory
, /* to_xfer_memory */
1165 remote_files_info
, /* to_files_info */
1167 remote_insert_breakpoint
, /* to_insert_breakpoint */
1168 remote_remove_breakpoint
, /* to_remove_breakpoint */
1170 NULL
, /* to_terminal_init */
1171 NULL
, /* to_terminal_inferior */
1172 NULL
, /* to_terminal_ours_for_output */
1173 NULL
, /* to_terminal_ours */
1174 NULL
, /* to_terminal_info */
1175 remote_kill
, /* to_kill */
1176 generic_load
, /* to_load */
1177 NULL
, /* to_lookup_symbol */
1178 NULL
, /* to_create_inferior */
1179 remote_mourn
, /* to_mourn_inferior */
1181 0, /* to_notice_signals */
1182 process_stratum
, /* to_stratum */
1184 1, /* to_has_all_memory */
1185 1, /* to_has_memory */
1186 1, /* to_has_stack */
1187 1, /* to_has_registers */
1188 1, /* to_has_execution */
1189 NULL
, /* sections */
1190 NULL
, /* sections_end */
1191 OPS_MAGIC
/* to_magic */
1195 _initialize_remote ()
1197 add_target (&remote_ops
);
This page took 0.055255 seconds and 4 git commands to generate.