projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Sigh, should have updated the copyright date in the
[deliverable/binutils-gdb.git] / gdb / remote-eb.c
CommitLineData
9b4ff276
AC		 1/* OBSOLETE /* Remote debugging interface for AMD 29000 EBMON on IBM PC, for GDB. */
2/* OBSOLETE Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1998, 1999, 2000, 2001 */
3/* OBSOLETE Free Software Foundation, Inc. */
4/* OBSOLETE Contributed by Cygnus Support. Written by Jim Kingdon for Cygnus. */
5/* OBSOLETE */
6/* OBSOLETE This file is part of GDB. */
7/* OBSOLETE */
8/* OBSOLETE This program is free software; you can redistribute it and/or modify */
9/* OBSOLETE it under the terms of the GNU General Public License as published by */
10/* OBSOLETE the Free Software Foundation; either version 2 of the License, or */
11/* OBSOLETE (at your option) any later version. */
12/* OBSOLETE */
13/* OBSOLETE This program is distributed in the hope that it will be useful, */
14/* OBSOLETE but WITHOUT ANY WARRANTY; without even the implied warranty of */
15/* OBSOLETE MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
16/* OBSOLETE GNU General Public License for more details. */
17/* OBSOLETE */
18/* OBSOLETE You should have received a copy of the GNU General Public License */
19/* OBSOLETE along with this program; if not, write to the Free Software */
20/* OBSOLETE Foundation, Inc., 59 Temple Place - Suite 330, */
21/* OBSOLETE Boston, MA 02111-1307, USA. */ */
22/* OBSOLETE */
23/* OBSOLETE /* This is like remote.c but is for an esoteric situation-- */
24/* OBSOLETE having a a29k board in a PC hooked up to a unix machine with */
25/* OBSOLETE a serial line, and running ctty com1 on the PC, through which */
26/* OBSOLETE the unix machine can run ebmon. Not to mention that the PC */
27/* OBSOLETE has PC/NFS, so it can access the same executables that gdb can, */
28/* OBSOLETE over the net in real time. */ */
29/* OBSOLETE */
30/* OBSOLETE #include "defs.h" */
31/* OBSOLETE #include "gdb_string.h" */
32/* OBSOLETE #include "regcache.h" */
33/* OBSOLETE */
34/* OBSOLETE #include "inferior.h" */
35/* OBSOLETE #include "bfd.h" */
36/* OBSOLETE #include "symfile.h" */
37/* OBSOLETE #include "value.h" */
38/* OBSOLETE #include <ctype.h> */
39/* OBSOLETE #include <fcntl.h> */
40/* OBSOLETE #include <signal.h> */
41/* OBSOLETE #include <errno.h> */
42/* OBSOLETE #include "terminal.h" */
43/* OBSOLETE #include "target.h" */
44/* OBSOLETE #include "gdbcore.h" */
45/* OBSOLETE */
46/* OBSOLETE extern struct target_ops eb_ops; /* Forward declaration */ */
47/* OBSOLETE */
48/* OBSOLETE static void eb_close (); */
49/* OBSOLETE */
50/* OBSOLETE #define LOG_FILE "eb.log" */
51/* OBSOLETE #if defined (LOG_FILE) */
52/* OBSOLETE FILE *log_file; */
53/* OBSOLETE #endif */
54/* OBSOLETE */
55/* OBSOLETE static int timeout = 24; */
56/* OBSOLETE */
57/* OBSOLETE /* Descriptor for I/O to remote machine. Initialize it to -1 so that */
58/* OBSOLETE eb_open knows that we don't have a file open when the program */
59/* OBSOLETE starts. */ */
60/* OBSOLETE int eb_desc = -1; */
61/* OBSOLETE */
62/* OBSOLETE /* stream which is fdopen'd from eb_desc. Only valid when */
63/* OBSOLETE eb_desc != -1. */ */
64/* OBSOLETE FILE *eb_stream; */
65/* OBSOLETE */
66/* OBSOLETE /* Read a character from the remote system, doing all the fancy */
67/* OBSOLETE timeout stuff. */ */
68/* OBSOLETE static int */
69/* OBSOLETE readchar (void) */
70/* OBSOLETE { */
71/* OBSOLETE char buf; */
72/* OBSOLETE */
73/* OBSOLETE buf = '\0'; */
74/* OBSOLETE #ifdef HAVE_TERMIO */
75/* OBSOLETE /* termio does the timeout for us. */ */
76/* OBSOLETE read (eb_desc, &buf, 1); */
77/* OBSOLETE #else */
78/* OBSOLETE alarm (timeout); */
79/* OBSOLETE if (read (eb_desc, &buf, 1) < 0) */
80/* OBSOLETE { */
81/* OBSOLETE if (errno == EINTR) */
82/* OBSOLETE error ("Timeout reading from remote system."); */
83/* OBSOLETE else */
84/* OBSOLETE perror_with_name ("remote"); */
85/* OBSOLETE } */
86/* OBSOLETE alarm (0); */
87/* OBSOLETE #endif */
88/* OBSOLETE */
89/* OBSOLETE if (buf == '\0') */
90/* OBSOLETE error ("Timeout reading from remote system."); */
91/* OBSOLETE #if defined (LOG_FILE) */
92/* OBSOLETE putc (buf & 0x7f, log_file); */
93/* OBSOLETE #endif */
94/* OBSOLETE return buf & 0x7f; */
95/* OBSOLETE } */
96/* OBSOLETE */
97/* OBSOLETE /* Keep discarding input from the remote system, until STRING is found. */
98/* OBSOLETE Let the user break out immediately. */ */
99/* OBSOLETE static void */
100/* OBSOLETE expect (char *string) */
101/* OBSOLETE { */
102/* OBSOLETE char *p = string; */
103/* OBSOLETE */
104/* OBSOLETE immediate_quit++; */
105/* OBSOLETE while (1) */
106/* OBSOLETE { */
107/* OBSOLETE if (readchar () == *p) */
108/* OBSOLETE { */
109/* OBSOLETE p++; */
110/* OBSOLETE if (*p == '\0') */
111/* OBSOLETE { */
112/* OBSOLETE immediate_quit--; */
113/* OBSOLETE return; */
114/* OBSOLETE } */
115/* OBSOLETE } */
116/* OBSOLETE else */
117/* OBSOLETE p = string; */
118/* OBSOLETE } */
119/* OBSOLETE } */
120/* OBSOLETE */
121/* OBSOLETE /* Keep discarding input until we see the ebmon prompt. */
122/* OBSOLETE */
123/* OBSOLETE The convention for dealing with the prompt is that you */
124/* OBSOLETE o give your command */
125/* OBSOLETE o *then* wait for the prompt. */
126/* OBSOLETE */
127/* OBSOLETE Thus the last thing that a procedure does with the serial line */
128/* OBSOLETE will be an expect_prompt(). Exception: eb_resume does not */
129/* OBSOLETE wait for the prompt, because the terminal is being handed over */
130/* OBSOLETE to the inferior. However, the next thing which happens after that */
131/* OBSOLETE is a eb_wait which does wait for the prompt. */
132/* OBSOLETE Note that this includes abnormal exit, e.g. error(). This is */
133/* OBSOLETE necessary to prevent getting into states from which we can't */
134/* OBSOLETE recover. */ */
135/* OBSOLETE static void */
136/* OBSOLETE expect_prompt (void) */
137/* OBSOLETE { */
138/* OBSOLETE #if defined (LOG_FILE) */
139/* OBSOLETE /* This is a convenient place to do this. The idea is to do it often */
140/* OBSOLETE enough that we never lose much data if we terminate abnormally. */ */
141/* OBSOLETE fflush (log_file); */
142/* OBSOLETE #endif */
143/* OBSOLETE expect ("\n# "); */
144/* OBSOLETE } */
145/* OBSOLETE */
146/* OBSOLETE /* Get a hex digit from the remote system & return its value. */
147/* OBSOLETE If ignore_space is nonzero, ignore spaces (not newline, tab, etc). */ */
148/* OBSOLETE static int */
149/* OBSOLETE get_hex_digit (int ignore_space) */
150/* OBSOLETE { */
151/* OBSOLETE int ch; */
152/* OBSOLETE while (1) */
153/* OBSOLETE { */
154/* OBSOLETE ch = readchar (); */
155/* OBSOLETE if (ch >= '0' && ch <= '9') */
156/* OBSOLETE return ch - '0'; */
157/* OBSOLETE else if (ch >= 'A' && ch <= 'F') */
158/* OBSOLETE return ch - 'A' + 10; */
159/* OBSOLETE else if (ch >= 'a' && ch <= 'f') */
160/* OBSOLETE return ch - 'a' + 10; */
161/* OBSOLETE else if (ch == ' ' && ignore_space) */
162/* OBSOLETE ; */
163/* OBSOLETE else */
164/* OBSOLETE { */
165/* OBSOLETE expect_prompt (); */
166/* OBSOLETE error ("Invalid hex digit from remote system."); */
167/* OBSOLETE } */
168/* OBSOLETE } */
169/* OBSOLETE } */
170/* OBSOLETE */
171/* OBSOLETE /* Get a byte from eb_desc and put it in *BYT. Accept any number */
172/* OBSOLETE leading spaces. */ */
173/* OBSOLETE static void */
174/* OBSOLETE get_hex_byte (char *byt) */
175/* OBSOLETE { */
176/* OBSOLETE int val; */
177/* OBSOLETE */
178/* OBSOLETE val = get_hex_digit (1) << 4; */
179/* OBSOLETE val |= get_hex_digit (0); */
180/* OBSOLETE *byt = val; */
181/* OBSOLETE } */
182/* OBSOLETE */
183/* OBSOLETE /* Get N 32-bit words from remote, each preceded by a space, */
184/* OBSOLETE and put them in registers starting at REGNO. */ */
185/* OBSOLETE static void */
186/* OBSOLETE get_hex_regs (int n, int regno) */
187/* OBSOLETE { */
188/* OBSOLETE long val; */
189/* OBSOLETE int i; */
190/* OBSOLETE */
191/* OBSOLETE for (i = 0; i < n; i++) */
192/* OBSOLETE { */
193/* OBSOLETE int j; */
194/* OBSOLETE */
195/* OBSOLETE val = 0; */
196/* OBSOLETE for (j = 0; j < 8; j++) */
197/* OBSOLETE val = (val << 4) + get_hex_digit (j == 0); */
198/* OBSOLETE supply_register (regno++, (char *) &val); */
199/* OBSOLETE } */
200/* OBSOLETE } */
201/* OBSOLETE */
202/* OBSOLETE /* Called when SIGALRM signal sent due to alarm() timeout. */ */
203/* OBSOLETE #ifndef HAVE_TERMIO */
204/* OBSOLETE */
205/* OBSOLETE volatile int n_alarms; */
206/* OBSOLETE */
207/* OBSOLETE void */
208/* OBSOLETE eb_timer (void) */
209/* OBSOLETE { */
210/* OBSOLETE #if 0 */
211/* OBSOLETE if (kiodebug) */
212/* OBSOLETE printf ("eb_timer called\n"); */
213/* OBSOLETE #endif */
214/* OBSOLETE n_alarms++; */
215/* OBSOLETE } */
216/* OBSOLETE #endif */
217/* OBSOLETE */
218/* OBSOLETE /* malloc'd name of the program on the remote system. */ */
219/* OBSOLETE static char *prog_name = NULL; */
220/* OBSOLETE */
221/* OBSOLETE /* Nonzero if we have loaded the file ("yc") and not yet issued a "gi" */
222/* OBSOLETE command. "gi" is supposed to happen exactly once for each "yc". */ */
223/* OBSOLETE static int need_gi = 0; */
224/* OBSOLETE */
225/* OBSOLETE /* Number of SIGTRAPs we need to simulate. That is, the next */
226/* OBSOLETE NEED_ARTIFICIAL_TRAP calls to eb_wait should just return */
227/* OBSOLETE SIGTRAP without actually waiting for anything. */ */
228/* OBSOLETE */
229/* OBSOLETE static int need_artificial_trap = 0; */
230/* OBSOLETE */
231/* OBSOLETE /* This is called not only when we first attach, but also when the */
232/* OBSOLETE user types "run" after having attached. */ */
233/* OBSOLETE static void */
234/* OBSOLETE eb_create_inferior (char *execfile, char *args, char **env) */
235/* OBSOLETE { */
236/* OBSOLETE int entry_pt; */
237/* OBSOLETE */
238/* OBSOLETE if (args && *args) */
239/* OBSOLETE error ("Can't pass arguments to remote EBMON process"); */
240/* OBSOLETE */
241/* OBSOLETE if (execfile == 0 || exec_bfd == 0) */
242/* OBSOLETE error ("No executable file specified"); */
243/* OBSOLETE */
244/* OBSOLETE entry_pt = (int) bfd_get_start_address (exec_bfd); */
245/* OBSOLETE */
246/* OBSOLETE { */
247/* OBSOLETE /* OK, now read in the file. Y=read, C=COFF, D=no symbols */
248/* OBSOLETE 0=start address, %s=filename. */ */
249/* OBSOLETE */
250/* OBSOLETE fprintf (eb_stream, "YC D,0:%s", prog_name); */
251/* OBSOLETE */
252/* OBSOLETE if (args != NULL) */
253/* OBSOLETE fprintf (eb_stream, " %s", args); */
254/* OBSOLETE */
255/* OBSOLETE fprintf (eb_stream, "\n"); */
256/* OBSOLETE fflush (eb_stream); */
257/* OBSOLETE */
258/* OBSOLETE expect_prompt (); */
259/* OBSOLETE */
260/* OBSOLETE need_gi = 1; */
261/* OBSOLETE } */
262/* OBSOLETE */
263/* OBSOLETE /* The "process" (board) is already stopped awaiting our commands, and */
264/* OBSOLETE the program is already downloaded. We just set its PC and go. */ */
265/* OBSOLETE */
266/* OBSOLETE clear_proceed_status (); */
267/* OBSOLETE */
268/* OBSOLETE /* Tell wait_for_inferior that we've started a new process. */ */
269/* OBSOLETE init_wait_for_inferior (); */
270/* OBSOLETE */
271/* OBSOLETE /* Set up the "saved terminal modes" of the inferior */
272/* OBSOLETE based on what modes we are starting it with. */ */
273/* OBSOLETE target_terminal_init (); */
274/* OBSOLETE */
275/* OBSOLETE /* Install inferior's terminal modes. */ */
276/* OBSOLETE target_terminal_inferior (); */
277/* OBSOLETE */
278/* OBSOLETE /* insert_step_breakpoint (); FIXME, do we need this? */ */
279/* OBSOLETE proceed ((CORE_ADDR) entry_pt, TARGET_SIGNAL_DEFAULT, 0); /* Let 'er rip... */ */
280/* OBSOLETE } */
281/* OBSOLETE */
282/* OBSOLETE /* Translate baud rates from integers to damn B_codes. Unix should */
283/* OBSOLETE have outgrown this crap years ago, but even POSIX wouldn't buck it. */ */
284/* OBSOLETE */
285/* OBSOLETE #ifndef B19200 */
286/* OBSOLETE #define B19200 EXTA */
287/* OBSOLETE #endif */
288/* OBSOLETE #ifndef B38400 */
289/* OBSOLETE #define B38400 EXTB */
290/* OBSOLETE #endif */
291/* OBSOLETE */
292/* OBSOLETE struct */
293/* OBSOLETE { */
294/* OBSOLETE int rate, damn_b; */
295/* OBSOLETE } */
296/* OBSOLETE baudtab[] = */
297/* OBSOLETE { */
298/* OBSOLETE { */
299/* OBSOLETE 0, B0 */
300/* OBSOLETE } */
301/* OBSOLETE , */
302/* OBSOLETE { */
303/* OBSOLETE 50, B50 */
304/* OBSOLETE } */
305/* OBSOLETE , */
306/* OBSOLETE { */
307/* OBSOLETE 75, B75 */
308/* OBSOLETE } */
309/* OBSOLETE , */
310/* OBSOLETE { */
311/* OBSOLETE 110, B110 */
312/* OBSOLETE } */
313/* OBSOLETE , */
314/* OBSOLETE { */
315/* OBSOLETE 134, B134 */
316/* OBSOLETE } */
317/* OBSOLETE , */
318/* OBSOLETE { */
319/* OBSOLETE 150, B150 */
320/* OBSOLETE } */
321/* OBSOLETE , */
322/* OBSOLETE { */
323/* OBSOLETE 200, B200 */
324/* OBSOLETE } */
325/* OBSOLETE , */
326/* OBSOLETE { */
327/* OBSOLETE 300, B300 */
328/* OBSOLETE } */
329/* OBSOLETE , */
330/* OBSOLETE { */
331/* OBSOLETE 600, B600 */
332/* OBSOLETE } */
333/* OBSOLETE , */
334/* OBSOLETE { */
335/* OBSOLETE 1200, B1200 */
336/* OBSOLETE } */
337/* OBSOLETE , */
338/* OBSOLETE { */
339/* OBSOLETE 1800, B1800 */
340/* OBSOLETE } */
341/* OBSOLETE , */
342/* OBSOLETE { */
343/* OBSOLETE 2400, B2400 */
344/* OBSOLETE } */
345/* OBSOLETE , */
346/* OBSOLETE { */
347/* OBSOLETE 4800, B4800 */
348/* OBSOLETE } */
349/* OBSOLETE , */
350/* OBSOLETE { */
351/* OBSOLETE 9600, B9600 */
352/* OBSOLETE } */
353/* OBSOLETE , */
354/* OBSOLETE { */
355/* OBSOLETE 19200, B19200 */
356/* OBSOLETE } */
357/* OBSOLETE , */
358/* OBSOLETE { */
359/* OBSOLETE 38400, B38400 */
360/* OBSOLETE } */
361/* OBSOLETE , */
362/* OBSOLETE { */
363/* OBSOLETE -1, -1 */
364/* OBSOLETE } */
365/* OBSOLETE , */
366/* OBSOLETE }; */
367/* OBSOLETE */
368/* OBSOLETE int */
369/* OBSOLETE damn_b (int rate) */
370/* OBSOLETE { */
371/* OBSOLETE int i; */
372/* OBSOLETE */
373/* OBSOLETE for (i = 0; baudtab[i].rate != -1; i++) */
374/* OBSOLETE if (rate == baudtab[i].rate) */
375/* OBSOLETE return baudtab[i].damn_b; */
376/* OBSOLETE return B38400; /* Random */ */
377/* OBSOLETE } */
378/* OBSOLETE */
379/* OBSOLETE */
380/* OBSOLETE /* Open a connection to a remote debugger. */
381/* OBSOLETE NAME is the filename used for communication, then a space, */
382/* OBSOLETE then the name of the program as we should name it to EBMON. */ */
383/* OBSOLETE */
384/* OBSOLETE static int baudrate = 9600; */
385/* OBSOLETE static char *dev_name; */
386/* OBSOLETE void */
387/* OBSOLETE eb_open (char *name, int from_tty) */
388/* OBSOLETE { */
389/* OBSOLETE TERMINAL sg; */
390/* OBSOLETE */
391/* OBSOLETE char *p; */
392/* OBSOLETE */
393/* OBSOLETE target_preopen (from_tty); */
394/* OBSOLETE */
395/* OBSOLETE /* Find the first whitespace character, it separates dev_name from */
396/* OBSOLETE prog_name. */ */
397/* OBSOLETE if (name == 0) */
398/* OBSOLETE goto erroid; */
399/* OBSOLETE */
400/* OBSOLETE for (p = name; */
401/* OBSOLETE *p != '\0' && !isspace (*p); p++) */
402/* OBSOLETE ; */
403/* OBSOLETE if (*p == '\0') */
404/* OBSOLETE erroid: */
405/* OBSOLETE error ("\ */
406/* OBSOLETE Please include the name of the device for the serial port,\n\ */
407/* OBSOLETE the baud rate, and the name of the program to run on the remote system."); */
408/* OBSOLETE dev_name = alloca (p - name + 1); */
409/* OBSOLETE strncpy (dev_name, name, p - name); */
410/* OBSOLETE dev_name[p - name] = '\0'; */
411/* OBSOLETE */
412/* OBSOLETE /* Skip over the whitespace after dev_name */ */
413/* OBSOLETE for (; isspace (*p); p++) */
414/* OBSOLETE /*EMPTY */ ; */
415/* OBSOLETE */
416/* OBSOLETE if (1 != sscanf (p, "%d ", &baudrate)) */
417/* OBSOLETE goto erroid; */
418/* OBSOLETE */
419/* OBSOLETE /* Skip the number and then the spaces */ */
420/* OBSOLETE for (; isdigit (*p); p++) */
421/* OBSOLETE /*EMPTY */ ; */
422/* OBSOLETE for (; isspace (*p); p++) */
423/* OBSOLETE /*EMPTY */ ; */
424/* OBSOLETE */
425/* OBSOLETE if (prog_name != NULL) */
426/* OBSOLETE xfree (prog_name); */
427/* OBSOLETE prog_name = savestring (p, strlen (p)); */
428/* OBSOLETE */
429/* OBSOLETE eb_close (0); */
430/* OBSOLETE */
431/* OBSOLETE eb_desc = open (dev_name, O_RDWR); */
432/* OBSOLETE if (eb_desc < 0) */
433/* OBSOLETE perror_with_name (dev_name); */
434/* OBSOLETE ioctl (eb_desc, TIOCGETP, &sg); */
435/* OBSOLETE #ifdef HAVE_TERMIO */
436/* OBSOLETE sg.c_cc[VMIN] = 0; /* read with timeout. */ */
437/* OBSOLETE sg.c_cc[VTIME] = timeout * 10; */
438/* OBSOLETE sg.c_lflag &= ~(ICANON | ECHO); */
439/* OBSOLETE sg.c_cflag = (sg.c_cflag & ~CBAUD) | damn_b (baudrate); */
440/* OBSOLETE #else */
441/* OBSOLETE sg.sg_ispeed = damn_b (baudrate); */
442/* OBSOLETE sg.sg_ospeed = damn_b (baudrate); */
443/* OBSOLETE sg.sg_flags |= RAW | ANYP; */
444/* OBSOLETE sg.sg_flags &= ~ECHO; */
445/* OBSOLETE #endif */
446/* OBSOLETE */
447/* OBSOLETE ioctl (eb_desc, TIOCSETP, &sg); */
448/* OBSOLETE eb_stream = fdopen (eb_desc, "r+"); */
449/* OBSOLETE */
450/* OBSOLETE push_target (&eb_ops); */
451/* OBSOLETE if (from_tty) */
452/* OBSOLETE printf ("Remote %s debugging %s using %s\n", target_shortname, */
453/* OBSOLETE prog_name, dev_name); */
454/* OBSOLETE */
455/* OBSOLETE #ifndef HAVE_TERMIO */
456/* OBSOLETE #ifndef NO_SIGINTERRUPT */
457/* OBSOLETE /* Cause SIGALRM's to make reads fail with EINTR instead of resuming */
458/* OBSOLETE the read. */ */
459/* OBSOLETE if (siginterrupt (SIGALRM, 1) != 0) */
460/* OBSOLETE perror ("eb_open: error in siginterrupt"); */
461/* OBSOLETE #endif */
462/* OBSOLETE */
463/* OBSOLETE /* Set up read timeout timer. */ */
464/* OBSOLETE if ((void (*)) signal (SIGALRM, eb_timer) == (void (*)) -1) */
465/* OBSOLETE perror ("eb_open: error in signal"); */
466/* OBSOLETE #endif */
467/* OBSOLETE */
468/* OBSOLETE #if defined (LOG_FILE) */
469/* OBSOLETE log_file = fopen (LOG_FILE, "w"); */
470/* OBSOLETE if (log_file == NULL) */
471/* OBSOLETE perror_with_name (LOG_FILE); */
472/* OBSOLETE #endif */
473/* OBSOLETE */
474/* OBSOLETE /* Hello? Are you there? */ */
475/* OBSOLETE write (eb_desc, "\n", 1); */
476/* OBSOLETE */
477/* OBSOLETE expect_prompt (); */
478/* OBSOLETE } */
479/* OBSOLETE */
480/* OBSOLETE /* Close out all files and local state before this target loses control. */ */
481/* OBSOLETE */
482/* OBSOLETE static void */
483/* OBSOLETE eb_close (int quitting) */
484/* OBSOLETE { */
485/* OBSOLETE */
486/* OBSOLETE /* Due to a bug in Unix, fclose closes not only the stdio stream, */
487/* OBSOLETE but also the file descriptor. So we don't actually close */
488/* OBSOLETE eb_desc. */ */
489/* OBSOLETE if (eb_stream) */
490/* OBSOLETE fclose (eb_stream); /* This also closes eb_desc */ */
491/* OBSOLETE if (eb_desc >= 0) */
492/* OBSOLETE /* close (eb_desc); */ */
493/* OBSOLETE */
494/* OBSOLETE /* Do not try to close eb_desc again, later in the program. */ */
495/* OBSOLETE eb_stream = NULL; */
496/* OBSOLETE eb_desc = -1; */
497/* OBSOLETE */
498/* OBSOLETE #if defined (LOG_FILE) */
499/* OBSOLETE if (log_file) */
500/* OBSOLETE { */
501/* OBSOLETE if (ferror (log_file)) */
502/* OBSOLETE printf ("Error writing log file.\n"); */
503/* OBSOLETE if (fclose (log_file) != 0) */
504/* OBSOLETE printf ("Error closing log file.\n"); */
505/* OBSOLETE } */
506/* OBSOLETE #endif */
507/* OBSOLETE } */
508/* OBSOLETE */
509/* OBSOLETE /* Terminate the open connection to the remote debugger. */
510/* OBSOLETE Use this when you want to detach and do something else */
511/* OBSOLETE with your gdb. */ */
512/* OBSOLETE void */
513/* OBSOLETE eb_detach (int from_tty) */
514/* OBSOLETE { */
515/* OBSOLETE pop_target (); /* calls eb_close to do the real work */ */
516/* OBSOLETE if (from_tty) */
517/* OBSOLETE printf ("Ending remote %s debugging\n", target_shortname); */
518/* OBSOLETE } */
519/* OBSOLETE */
520/* OBSOLETE /* Tell the remote machine to resume. */ */
521/* OBSOLETE */
522/* OBSOLETE void */
523/* OBSOLETE eb_resume (ptid_t ptid, int step, enum target_signal sig) */
524/* OBSOLETE { */
525/* OBSOLETE if (step) */
526/* OBSOLETE { */
527/* OBSOLETE write (eb_desc, "t 1,s\n", 6); */
528/* OBSOLETE /* Wait for the echo. */ */
529/* OBSOLETE expect ("t 1,s\r"); */
530/* OBSOLETE /* Then comes a line containing the instruction we stepped to. */ */
531/* OBSOLETE expect ("\n@"); */
532/* OBSOLETE /* Then we get the prompt. */ */
533/* OBSOLETE expect_prompt (); */
534/* OBSOLETE */
535/* OBSOLETE /* Force the next eb_wait to return a trap. Not doing anything */
536/* OBSOLETE about I/O from the target means that the user has to type */
537/* OBSOLETE "continue" to see any. This should be fixed. */ */
538/* OBSOLETE need_artificial_trap = 1; */
539/* OBSOLETE } */
540/* OBSOLETE else */
541/* OBSOLETE { */
542/* OBSOLETE if (need_gi) */
543/* OBSOLETE { */
544/* OBSOLETE need_gi = 0; */
545/* OBSOLETE write (eb_desc, "gi\n", 3); */
546/* OBSOLETE */
547/* OBSOLETE /* Swallow the echo of "gi". */ */
548/* OBSOLETE expect ("gi\r"); */
549/* OBSOLETE } */
550/* OBSOLETE else */
551/* OBSOLETE { */
552/* OBSOLETE write (eb_desc, "GR\n", 3); */
553/* OBSOLETE /* Swallow the echo. */ */
554/* OBSOLETE expect ("GR\r"); */
555/* OBSOLETE } */
556/* OBSOLETE } */
557/* OBSOLETE } */
558/* OBSOLETE */
559/* OBSOLETE /* Wait until the remote machine stops, then return, */
560/* OBSOLETE storing status in STATUS just as `wait' would. */ */
561/* OBSOLETE */
562/* OBSOLETE ptid_t */
563/* OBSOLETE eb_wait (ptid_t ptid, struct target_waitstatus *status) */
564/* OBSOLETE { */
565/* OBSOLETE /* Strings to look for. '?' means match any single character. */
566/* OBSOLETE Note that with the algorithm we use, the initial character */
567/* OBSOLETE of the string cannot recur in the string, or we will not */
568/* OBSOLETE find some cases of the string in the input. */ */
569/* OBSOLETE */
570/* OBSOLETE static char bpt[] = "Invalid interrupt taken - #0x50 - "; */
571/* OBSOLETE /* It would be tempting to look for "\n[__exit + 0x8]\n" */
572/* OBSOLETE but that requires loading symbols with "yc i" and even if */
573/* OBSOLETE we did do that we don't know that the file has symbols. */ */
574/* OBSOLETE static char exitmsg[] = "\n@????????I JMPTI GR121,LR0"; */
575/* OBSOLETE char *bp = bpt; */
576/* OBSOLETE char *ep = exitmsg; */
577/* OBSOLETE */
578/* OBSOLETE /* Large enough for either sizeof (bpt) or sizeof (exitmsg) chars. */ */
579/* OBSOLETE char swallowed[50]; */
580/* OBSOLETE /* Current position in swallowed. */ */
581/* OBSOLETE char *swallowed_p = swallowed; */
582/* OBSOLETE */
583/* OBSOLETE int ch; */
584/* OBSOLETE int ch_handled; */
585/* OBSOLETE */
586/* OBSOLETE int old_timeout = timeout; */
587/* OBSOLETE */
588/* OBSOLETE status->kind = TARGET_WAITKIND_EXITED; */
589/* OBSOLETE status->value.integer = 0; */
590/* OBSOLETE */
591/* OBSOLETE if (need_artificial_trap != 0) */
592/* OBSOLETE { */
593/* OBSOLETE status->kind = TARGET_WAITKIND_STOPPED; */
594/* OBSOLETE status->value.sig = TARGET_SIGNAL_TRAP; */
595/* OBSOLETE need_artificial_trap--; */
596/* OBSOLETE return 0; */
597/* OBSOLETE } */
598/* OBSOLETE */
599/* OBSOLETE timeout = 0; /* Don't time out -- user program is running. */ */
600/* OBSOLETE while (1) */
601/* OBSOLETE { */
602/* OBSOLETE ch_handled = 0; */
603/* OBSOLETE ch = readchar (); */
604/* OBSOLETE if (ch == *bp) */
605/* OBSOLETE { */
606/* OBSOLETE bp++; */
607/* OBSOLETE if (*bp == '\0') */
608/* OBSOLETE break; */
609/* OBSOLETE ch_handled = 1; */
610/* OBSOLETE */
611/* OBSOLETE *swallowed_p++ = ch; */
612/* OBSOLETE } */
613/* OBSOLETE else */
614/* OBSOLETE bp = bpt; */
615/* OBSOLETE */
616/* OBSOLETE if (ch == *ep || *ep == '?') */
617/* OBSOLETE { */
618/* OBSOLETE ep++; */
619/* OBSOLETE if (*ep == '\0') */
620/* OBSOLETE break; */
621/* OBSOLETE */
622/* OBSOLETE if (!ch_handled) */
623/* OBSOLETE *swallowed_p++ = ch; */
624/* OBSOLETE ch_handled = 1; */
625/* OBSOLETE } */
626/* OBSOLETE else */
627/* OBSOLETE ep = exitmsg; */
628/* OBSOLETE */
629/* OBSOLETE if (!ch_handled) */
630/* OBSOLETE { */
631/* OBSOLETE char *p; */
632/* OBSOLETE */
633/* OBSOLETE /* Print out any characters which have been swallowed. */ */
634/* OBSOLETE for (p = swallowed; p < swallowed_p; ++p) */
635/* OBSOLETE putc (*p, stdout); */
636/* OBSOLETE swallowed_p = swallowed; */
637/* OBSOLETE */
638/* OBSOLETE putc (ch, stdout); */
639/* OBSOLETE } */
640/* OBSOLETE } */
641/* OBSOLETE expect_prompt (); */
642/* OBSOLETE if (*bp == '\0') */
643/* OBSOLETE { */
644/* OBSOLETE status->kind = TARGET_WAITKIND_STOPPED; */
645/* OBSOLETE status->value.sig = TARGET_SIGNAL_TRAP; */
646/* OBSOLETE } */
647/* OBSOLETE else */
648/* OBSOLETE { */
649/* OBSOLETE status->kind = TARGET_WAITKIND_EXITED; */
650/* OBSOLETE status->value.integer = 0; */
651/* OBSOLETE } */
652/* OBSOLETE timeout = old_timeout; */
653/* OBSOLETE */
654/* OBSOLETE return 0; */
655/* OBSOLETE } */
656/* OBSOLETE */
657/* OBSOLETE /* Return the name of register number REGNO */
658/* OBSOLETE in the form input and output by EBMON. */
659/* OBSOLETE */
660/* OBSOLETE Returns a pointer to a static buffer containing the answer. */ */
661/* OBSOLETE static char * */
662/* OBSOLETE get_reg_name (int regno) */
663/* OBSOLETE { */
664/* OBSOLETE static char buf[80]; */
665/* OBSOLETE if (regno >= GR96_REGNUM && regno < GR96_REGNUM + 32) */
666/* OBSOLETE sprintf (buf, "GR%03d", regno - GR96_REGNUM + 96); */
667/* OBSOLETE else if (regno >= LR0_REGNUM && regno < LR0_REGNUM + 128) */
668/* OBSOLETE sprintf (buf, "LR%03d", regno - LR0_REGNUM); */
669/* OBSOLETE else if (regno == Q_REGNUM) */
670/* OBSOLETE strcpy (buf, "SR131"); */
671/* OBSOLETE else if (regno >= BP_REGNUM && regno <= CR_REGNUM) */
672/* OBSOLETE sprintf (buf, "SR%03d", regno - BP_REGNUM + 133); */
673/* OBSOLETE else if (regno == ALU_REGNUM) */
674/* OBSOLETE strcpy (buf, "SR132"); */
675/* OBSOLETE else if (regno >= IPC_REGNUM && regno <= IPB_REGNUM) */
676/* OBSOLETE sprintf (buf, "SR%03d", regno - IPC_REGNUM + 128); */
677/* OBSOLETE else if (regno >= VAB_REGNUM && regno <= LRU_REGNUM) */
678/* OBSOLETE sprintf (buf, "SR%03d", regno - VAB_REGNUM); */
679/* OBSOLETE else if (regno == GR1_REGNUM) */
680/* OBSOLETE strcpy (buf, "GR001"); */
681/* OBSOLETE return buf; */
682/* OBSOLETE } */
683/* OBSOLETE */
684/* OBSOLETE /* Read the remote registers into the block REGS. */ */
685/* OBSOLETE */
686/* OBSOLETE static void */
687/* OBSOLETE eb_fetch_registers (void) */
688/* OBSOLETE { */
689/* OBSOLETE int reg_index; */
690/* OBSOLETE int regnum_index; */
691/* OBSOLETE char tempbuf[10]; */
692/* OBSOLETE int i; */
693/* OBSOLETE */
694/* OBSOLETE #if 0 */
695/* OBSOLETE /* This should not be necessary, because one is supposed to read the */
696/* OBSOLETE registers only when the inferior is stopped (at least with */
697/* OBSOLETE ptrace() and why not make it the same for remote?). */ */
698/* OBSOLETE /* ^A is the "normal character" used to make sure we are talking to EBMON */
699/* OBSOLETE and not to the program being debugged. */ */
700/* OBSOLETE write (eb_desc, "\001\n"); */
701/* OBSOLETE expect_prompt (); */
702/* OBSOLETE #endif */
703/* OBSOLETE */
704/* OBSOLETE write (eb_desc, "dw gr96,gr127\n", 14); */
705/* OBSOLETE for (reg_index = 96, regnum_index = GR96_REGNUM; */
706/* OBSOLETE reg_index < 128; */
707/* OBSOLETE reg_index += 4, regnum_index += 4) */
708/* OBSOLETE { */
709/* OBSOLETE sprintf (tempbuf, "GR%03d ", reg_index); */
710/* OBSOLETE expect (tempbuf); */
711/* OBSOLETE get_hex_regs (4, regnum_index); */
712/* OBSOLETE expect ("\n"); */
713/* OBSOLETE } */
714/* OBSOLETE */
715/* OBSOLETE for (i = 0; i < 128; i += 32) */
716/* OBSOLETE { */
717/* OBSOLETE /* The PC has a tendency to hang if we get these */
718/* OBSOLETE all in one fell swoop ("dw lr0,lr127"). */ */
719/* OBSOLETE sprintf (tempbuf, "dw lr%d\n", i); */
720/* OBSOLETE write (eb_desc, tempbuf, strlen (tempbuf)); */
721/* OBSOLETE for (reg_index = i, regnum_index = LR0_REGNUM + i; */
722/* OBSOLETE reg_index < i + 32; */
723/* OBSOLETE reg_index += 4, regnum_index += 4) */
724/* OBSOLETE { */
725/* OBSOLETE sprintf (tempbuf, "LR%03d ", reg_index); */
726/* OBSOLETE expect (tempbuf); */
727/* OBSOLETE get_hex_regs (4, regnum_index); */
728/* OBSOLETE expect ("\n"); */
729/* OBSOLETE } */
730/* OBSOLETE } */
731/* OBSOLETE */
732/* OBSOLETE write (eb_desc, "dw sr133,sr133\n", 15); */
733/* OBSOLETE expect ("SR133 "); */
734/* OBSOLETE get_hex_regs (1, BP_REGNUM); */
735/* OBSOLETE expect ("\n"); */
736/* OBSOLETE */
737/* OBSOLETE write (eb_desc, "dw sr134,sr134\n", 15); */
738/* OBSOLETE expect ("SR134 "); */
739/* OBSOLETE get_hex_regs (1, FC_REGNUM); */
740/* OBSOLETE expect ("\n"); */
741/* OBSOLETE */
742/* OBSOLETE write (eb_desc, "dw sr135,sr135\n", 15); */
743/* OBSOLETE expect ("SR135 "); */
744/* OBSOLETE get_hex_regs (1, CR_REGNUM); */
745/* OBSOLETE expect ("\n"); */
746/* OBSOLETE */
747/* OBSOLETE write (eb_desc, "dw sr131,sr131\n", 15); */
748/* OBSOLETE expect ("SR131 "); */
749/* OBSOLETE get_hex_regs (1, Q_REGNUM); */
750/* OBSOLETE expect ("\n"); */
751/* OBSOLETE */
752/* OBSOLETE write (eb_desc, "dw sr0,sr14\n", 12); */
753/* OBSOLETE for (reg_index = 0, regnum_index = VAB_REGNUM; */
754/* OBSOLETE regnum_index <= LRU_REGNUM; */
755/* OBSOLETE regnum_index += 4, reg_index += 4) */
756/* OBSOLETE { */
757/* OBSOLETE sprintf (tempbuf, "SR%03d ", reg_index); */
758/* OBSOLETE expect (tempbuf); */
759/* OBSOLETE get_hex_regs (reg_index == 12 ? 3 : 4, regnum_index); */
760/* OBSOLETE expect ("\n"); */
761/* OBSOLETE } */
762/* OBSOLETE */
763/* OBSOLETE /* There doesn't seem to be any way to get these. */ */
764/* OBSOLETE { */
765/* OBSOLETE int val = -1; */
766/* OBSOLETE supply_register (FPE_REGNUM, (char *) &val); */
767/* OBSOLETE supply_register (INTE_REGNUM, (char *) &val); */
768/* OBSOLETE supply_register (FPS_REGNUM, (char *) &val); */
769/* OBSOLETE supply_register (EXO_REGNUM, (char *) &val); */
770/* OBSOLETE } */
771/* OBSOLETE */
772/* OBSOLETE write (eb_desc, "dw gr1,gr1\n", 11); */
773/* OBSOLETE expect ("GR001 "); */
774/* OBSOLETE get_hex_regs (1, GR1_REGNUM); */
775/* OBSOLETE expect_prompt (); */
776/* OBSOLETE } */
777/* OBSOLETE */
778/* OBSOLETE /* Fetch register REGNO, or all registers if REGNO is -1. */
779/* OBSOLETE Returns errno value. */ */
780/* OBSOLETE void */
781/* OBSOLETE eb_fetch_register (int regno) */
782/* OBSOLETE { */
783/* OBSOLETE if (regno == -1) */
784/* OBSOLETE eb_fetch_registers (); */
785/* OBSOLETE else */
786/* OBSOLETE { */
787/* OBSOLETE char *name = get_reg_name (regno); */
788/* OBSOLETE fprintf (eb_stream, "dw %s,%s\n", name, name); */
789/* OBSOLETE expect (name); */
790/* OBSOLETE expect (" "); */
791/* OBSOLETE get_hex_regs (1, regno); */
792/* OBSOLETE expect_prompt (); */
793/* OBSOLETE } */
794/* OBSOLETE return; */
795/* OBSOLETE } */
796/* OBSOLETE */
797/* OBSOLETE /* Store the remote registers from the contents of the block REGS. */ */
798/* OBSOLETE */
799/* OBSOLETE static void */
800/* OBSOLETE eb_store_registers (void) */
801/* OBSOLETE { */
802/* OBSOLETE int i, j; */
803/* OBSOLETE fprintf (eb_stream, "s gr1,%x\n", read_register (GR1_REGNUM)); */
804/* OBSOLETE expect_prompt (); */
805/* OBSOLETE */
806/* OBSOLETE for (j = 0; j < 32; j += 16) */
807/* OBSOLETE { */
808/* OBSOLETE fprintf (eb_stream, "s gr%d,", j + 96); */
809/* OBSOLETE for (i = 0; i < 15; ++i) */
810/* OBSOLETE fprintf (eb_stream, "%x,", read_register (GR96_REGNUM + j + i)); */
811/* OBSOLETE fprintf (eb_stream, "%x\n", read_register (GR96_REGNUM + j + 15)); */
812/* OBSOLETE expect_prompt (); */
813/* OBSOLETE } */
814/* OBSOLETE */
815/* OBSOLETE for (j = 0; j < 128; j += 16) */
816/* OBSOLETE { */
817/* OBSOLETE fprintf (eb_stream, "s lr%d,", j); */
818/* OBSOLETE for (i = 0; i < 15; ++i) */
819/* OBSOLETE fprintf (eb_stream, "%x,", read_register (LR0_REGNUM + j + i)); */
820/* OBSOLETE fprintf (eb_stream, "%x\n", read_register (LR0_REGNUM + j + 15)); */
821/* OBSOLETE expect_prompt (); */
822/* OBSOLETE } */
823/* OBSOLETE */
824/* OBSOLETE fprintf (eb_stream, "s sr133,%x,%x,%x\n", read_register (BP_REGNUM), */
825/* OBSOLETE read_register (FC_REGNUM), read_register (CR_REGNUM)); */
826/* OBSOLETE expect_prompt (); */
827/* OBSOLETE fprintf (eb_stream, "s sr131,%x\n", read_register (Q_REGNUM)); */
828/* OBSOLETE expect_prompt (); */
829/* OBSOLETE fprintf (eb_stream, "s sr0,"); */
830/* OBSOLETE for (i = 0; i < 11; ++i) */
831/* OBSOLETE fprintf (eb_stream, "%x,", read_register (VAB_REGNUM + i)); */
832/* OBSOLETE fprintf (eb_stream, "%x\n", read_register (VAB_REGNUM + 11)); */
833/* OBSOLETE expect_prompt (); */
834/* OBSOLETE } */
835/* OBSOLETE */
836/* OBSOLETE /* Store register REGNO, or all if REGNO == 0. */
837/* OBSOLETE Return errno value. */ */
838/* OBSOLETE void */
839/* OBSOLETE eb_store_register (int regno) */
840/* OBSOLETE { */
841/* OBSOLETE if (regno == -1) */
842/* OBSOLETE eb_store_registers (); */
843/* OBSOLETE else */
844/* OBSOLETE { */
845/* OBSOLETE char *name = get_reg_name (regno); */
846/* OBSOLETE fprintf (eb_stream, "s %s,%x\n", name, read_register (regno)); */
847/* OBSOLETE /* Setting GR1 changes the numbers of all the locals, so */
848/* OBSOLETE invalidate the register cache. Do this *after* calling */
849/* OBSOLETE read_register, because we want read_register to return the */
850/* OBSOLETE value that write_register has just stuffed into the registers */
851/* OBSOLETE array, not the value of the register fetched from the */
852/* OBSOLETE inferior. */ */
853/* OBSOLETE if (regno == GR1_REGNUM) */
854/* OBSOLETE registers_changed (); */
855/* OBSOLETE expect_prompt (); */
856/* OBSOLETE } */
857/* OBSOLETE } */
858/* OBSOLETE */
859/* OBSOLETE /* Get ready to modify the registers array. On machines which store */
860/* OBSOLETE individual registers, this doesn't need to do anything. On machines */
861/* OBSOLETE which store all the registers in one fell swoop, this makes sure */
862/* OBSOLETE that registers contains all the registers from the program being */
863/* OBSOLETE debugged. */ */
864/* OBSOLETE */
865/* OBSOLETE void */
866/* OBSOLETE eb_prepare_to_store (void) */
867/* OBSOLETE { */
868/* OBSOLETE /* Do nothing, since we can store individual regs */ */
869/* OBSOLETE } */
870/* OBSOLETE */
871/* OBSOLETE /* Transfer LEN bytes between GDB address MYADDR and target address */
872/* OBSOLETE MEMADDR. If WRITE is non-zero, transfer them to the target, */
873/* OBSOLETE otherwise transfer them from the target. TARGET is unused. */
874/* OBSOLETE */
875/* OBSOLETE Returns the number of bytes transferred. */ */
876/* OBSOLETE */
877/* OBSOLETE int */
878/* OBSOLETE eb_xfer_inferior_memory (CORE_ADDR memaddr, char *myaddr, int len, int write, */
879/* OBSOLETE struct mem_attrib *attrib ATTRIBUTE_UNUSED, */
880/* OBSOLETE struct target_ops *target ATTRIBUTE_UNUSED) */
881/* OBSOLETE { */
882/* OBSOLETE if (write) */
883/* OBSOLETE return eb_write_inferior_memory (memaddr, myaddr, len); */
884/* OBSOLETE else */
885/* OBSOLETE return eb_read_inferior_memory (memaddr, myaddr, len); */
886/* OBSOLETE } */
887/* OBSOLETE */
888/* OBSOLETE void */
889/* OBSOLETE eb_files_info (void) */
890/* OBSOLETE { */
891/* OBSOLETE printf ("\tAttached to %s at %d baud and running program %s.\n", */
892/* OBSOLETE dev_name, baudrate, prog_name); */
893/* OBSOLETE } */
894/* OBSOLETE */
895/* OBSOLETE /* Copy LEN bytes of data from debugger memory at MYADDR */
896/* OBSOLETE to inferior's memory at MEMADDR. Returns length moved. */ */
897/* OBSOLETE int */
898/* OBSOLETE eb_write_inferior_memory (CORE_ADDR memaddr, char *myaddr, int len) */
899/* OBSOLETE { */
900/* OBSOLETE int i; */
901/* OBSOLETE */
902/* OBSOLETE for (i = 0; i < len; i++) */
903/* OBSOLETE { */
904/* OBSOLETE if ((i % 16) == 0) */
905/* OBSOLETE fprintf (eb_stream, "sb %x,", memaddr + i); */
906/* OBSOLETE if ((i % 16) == 15 || i == len - 1) */
907/* OBSOLETE { */
908/* OBSOLETE fprintf (eb_stream, "%x\n", ((unsigned char *) myaddr)[i]); */
909/* OBSOLETE expect_prompt (); */
910/* OBSOLETE } */
911/* OBSOLETE else */
912/* OBSOLETE fprintf (eb_stream, "%x,", ((unsigned char *) myaddr)[i]); */
913/* OBSOLETE } */
914/* OBSOLETE return len; */
915/* OBSOLETE } */
916/* OBSOLETE */
917/* OBSOLETE /* Read LEN bytes from inferior memory at MEMADDR. Put the result */
918/* OBSOLETE at debugger address MYADDR. Returns length moved. */ */
919/* OBSOLETE int */
920/* OBSOLETE eb_read_inferior_memory (CORE_ADDR memaddr, char *myaddr, int len) */
921/* OBSOLETE { */
922/* OBSOLETE int i; */
923/* OBSOLETE */
924/* OBSOLETE /* Number of bytes read so far. */ */
925/* OBSOLETE int count; */
926/* OBSOLETE */
927/* OBSOLETE /* Starting address of this pass. */ */
928/* OBSOLETE unsigned long startaddr; */
929/* OBSOLETE */
930/* OBSOLETE /* Number of bytes to read in this pass. */ */
931/* OBSOLETE int len_this_pass; */
932/* OBSOLETE */
933/* OBSOLETE /* Note that this code works correctly if startaddr is just less */
934/* OBSOLETE than UINT_MAX (well, really CORE_ADDR_MAX if there was such a */
935/* OBSOLETE thing). That is, something like */
936/* OBSOLETE eb_read_bytes (CORE_ADDR_MAX - 4, foo, 4) */
937/* OBSOLETE works--it never adds len to memaddr and gets 0. */ */
938/* OBSOLETE /* However, something like */
939/* OBSOLETE eb_read_bytes (CORE_ADDR_MAX - 3, foo, 4) */
940/* OBSOLETE doesn't need to work. Detect it and give up if there's an attempt */
941/* OBSOLETE to do that. */ */
942/* OBSOLETE if (((memaddr - 1) + len) < memaddr) */
943/* OBSOLETE { */
944/* OBSOLETE errno = EIO; */
945/* OBSOLETE return 0; */
946/* OBSOLETE } */
947/* OBSOLETE */
948/* OBSOLETE startaddr = memaddr; */
949/* OBSOLETE count = 0; */
950/* OBSOLETE while (count < len) */
951/* OBSOLETE { */
952/* OBSOLETE len_this_pass = 16; */
953/* OBSOLETE if ((startaddr % 16) != 0) */
954/* OBSOLETE len_this_pass -= startaddr % 16; */
955/* OBSOLETE if (len_this_pass > (len - count)) */
956/* OBSOLETE len_this_pass = (len - count); */
957/* OBSOLETE */
958/* OBSOLETE fprintf (eb_stream, "db %x,%x\n", startaddr, */
959/* OBSOLETE (startaddr - 1) + len_this_pass); */
960/* OBSOLETE expect ("\n"); */
961/* OBSOLETE */
962/* OBSOLETE /* Look for 8 hex digits. */ */
963/* OBSOLETE i = 0; */
964/* OBSOLETE while (1) */
965/* OBSOLETE { */
966/* OBSOLETE if (isxdigit (readchar ())) */
967/* OBSOLETE ++i; */
968/* OBSOLETE else */
969/* OBSOLETE { */
970/* OBSOLETE expect_prompt (); */
971/* OBSOLETE error ("Hex digit expected from remote system."); */
972/* OBSOLETE } */
973/* OBSOLETE if (i >= 8) */
974/* OBSOLETE break; */
975/* OBSOLETE } */
976/* OBSOLETE */
977/* OBSOLETE expect (" "); */
978/* OBSOLETE */
979/* OBSOLETE for (i = 0; i < len_this_pass; i++) */
980/* OBSOLETE get_hex_byte (&myaddr[count++]); */
981/* OBSOLETE */
982/* OBSOLETE expect_prompt (); */
983/* OBSOLETE */
984/* OBSOLETE startaddr += len_this_pass; */
985/* OBSOLETE } */
986/* OBSOLETE return len; */
987/* OBSOLETE } */
988/* OBSOLETE */
989/* OBSOLETE static void */
990/* OBSOLETE eb_kill (char *args, int from_tty) */
991/* OBSOLETE { */
992/* OBSOLETE return; /* Ignore attempts to kill target system */ */
993/* OBSOLETE } */
994/* OBSOLETE */
995/* OBSOLETE /* Clean up when a program exits. */
996/* OBSOLETE */
997/* OBSOLETE The program actually lives on in the remote processor's RAM, and may be */
998/* OBSOLETE run again without a download. Don't leave it full of breakpoint */
999/* OBSOLETE instructions. */ */
1000/* OBSOLETE */
1001/* OBSOLETE void */
1002/* OBSOLETE eb_mourn_inferior (void) */
1003/* OBSOLETE { */
1004/* OBSOLETE remove_breakpoints (); */
1005/* OBSOLETE unpush_target (&eb_ops); */
1006/* OBSOLETE generic_mourn_inferior (); /* Do all the proper things now */ */
1007/* OBSOLETE } */
1008/* OBSOLETE /* Define the target subroutine names */ */
1009/* OBSOLETE */
1010/* OBSOLETE struct target_ops eb_ops; */
1011/* OBSOLETE */
1012/* OBSOLETE static void */
1013/* OBSOLETE init_eb_ops (void) */
1014/* OBSOLETE { */
1015/* OBSOLETE eb_ops.to_shortname = "amd-eb"; */
1016/* OBSOLETE eb_ops.to_longname = "Remote serial AMD EBMON target"; */
1017/* OBSOLETE eb_ops.to_doc = "Use a remote computer running EBMON connected by a serial line.\n\ */
1018/* OBSOLETE Arguments are the name of the device for the serial line,\n\ */
1019/* OBSOLETE the speed to connect at in bits per second, and the filename of the\n\ */
1020/* OBSOLETE executable as it exists on the remote computer. For example,\n\ */
1021/* OBSOLETE target amd-eb /dev/ttya 9600 demo", */
1022/* OBSOLETE eb_ops.to_open = eb_open; */
1023/* OBSOLETE eb_ops.to_close = eb_close; */
1024/* OBSOLETE eb_ops.to_attach = 0; */
1025/* OBSOLETE eb_ops.to_post_attach = NULL; */
1026/* OBSOLETE eb_ops.to_require_attach = NULL; */
1027/* OBSOLETE eb_ops.to_detach = eb_detach; */
1028/* OBSOLETE eb_ops.to_require_detach = NULL; */
1029/* OBSOLETE eb_ops.to_resume = eb_resume; */
1030/* OBSOLETE eb_ops.to_wait = eb_wait; */
1031/* OBSOLETE eb_ops.to_post_wait = NULL; */
1032/* OBSOLETE eb_ops.to_fetch_registers = eb_fetch_register; */
1033/* OBSOLETE eb_ops.to_store_registers = eb_store_register; */
1034/* OBSOLETE eb_ops.to_prepare_to_store = eb_prepare_to_store; */
1035/* OBSOLETE eb_ops.to_xfer_memory = eb_xfer_inferior_memory; */
1036/* OBSOLETE eb_ops.to_files_info = eb_files_info; */
1037/* OBSOLETE eb_ops.to_insert_breakpoint = 0; */
1038/* OBSOLETE eb_ops.to_remove_breakpoint = 0; /* Breakpoints */ */
1039/* OBSOLETE eb_ops.to_terminal_init = 0; */
1040/* OBSOLETE eb_ops.to_terminal_inferior = 0; */
1041/* OBSOLETE eb_ops.to_terminal_ours_for_output = 0; */
1042/* OBSOLETE eb_ops.to_terminal_ours = 0; */
1043/* OBSOLETE eb_ops.to_terminal_info = 0; /* Terminal handling */ */
1044/* OBSOLETE eb_ops.to_kill = eb_kill; */
1045/* OBSOLETE eb_ops.to_load = generic_load; /* load */ */
1046/* OBSOLETE eb_ops.to_lookup_symbol = 0; /* lookup_symbol */ */
1047/* OBSOLETE eb_ops.to_create_inferior = eb_create_inferior; */
1048/* OBSOLETE eb_ops.to_post_startup_inferior = NULL; */
1049/* OBSOLETE eb_ops.to_acknowledge_created_inferior = NULL; */
1050/* OBSOLETE eb_ops.to_clone_and_follow_inferior = NULL; */
1051/* OBSOLETE eb_ops.to_post_follow_inferior_by_clone = NULL; */
1052/* OBSOLETE eb_ops.to_insert_fork_catchpoint = NULL; */
1053/* OBSOLETE eb_ops.to_remove_fork_catchpoint = NULL; */
1054/* OBSOLETE eb_ops.to_insert_vfork_catchpoint = NULL; */
1055/* OBSOLETE eb_ops.to_remove_vfork_catchpoint = NULL; */
1056/* OBSOLETE eb_ops.to_has_forked = NULL; */
1057/* OBSOLETE eb_ops.to_has_vforked = NULL; */
1058/* OBSOLETE eb_ops.to_can_follow_vfork_prior_to_exec = NULL; */
1059/* OBSOLETE eb_ops.to_post_follow_vfork = NULL; */
1060/* OBSOLETE eb_ops.to_insert_exec_catchpoint = NULL; */
1061/* OBSOLETE eb_ops.to_remove_exec_catchpoint = NULL; */
1062/* OBSOLETE eb_ops.to_has_execd = NULL; */
1063/* OBSOLETE eb_ops.to_reported_exec_events_per_exec_call = NULL; */
1064/* OBSOLETE eb_ops.to_has_exited = NULL; */
1065/* OBSOLETE eb_ops.to_mourn_inferior = eb_mourn_inferior; */
1066/* OBSOLETE eb_ops.to_can_run = 0; /* can_run */ */
1067/* OBSOLETE eb_ops.to_notice_signals = 0; /* notice_signals */ */
1068/* OBSOLETE eb_ops.to_thread_alive = 0; /* thread-alive */ */
1069/* OBSOLETE eb_ops.to_stop = 0; /* to_stop */ */
1070/* OBSOLETE eb_ops.to_pid_to_exec_file = NULL; */
1071/* OBSOLETE eb_ops.to_stratum = process_stratum; */
1072/* OBSOLETE eb_ops.DONT_USE = 0; /* next */ */
1073/* OBSOLETE eb_ops.to_has_all_memory = 1; */
1074/* OBSOLETE eb_ops.to_has_memory = 1; */
1075/* OBSOLETE eb_ops.to_has_stack = 1; */
1076/* OBSOLETE eb_ops.to_has_registers = 1; */
1077/* OBSOLETE eb_ops.to_has_execution = 1; /* all mem, mem, stack, regs, exec */ */
1078/* OBSOLETE eb_ops.to_sections = 0; /* sections */ */
1079/* OBSOLETE eb_ops.to_sections_end = 0; /* sections end */ */
1080/* OBSOLETE eb_ops.to_magic = OPS_MAGIC; /* Always the last thing */ */
1081/* OBSOLETE }; */
1082/* OBSOLETE */
1083/* OBSOLETE void */
1084/* OBSOLETE _initialize_remote_eb (void) */
1085/* OBSOLETE { */
1086/* OBSOLETE init_eb_ops (); */
1087/* OBSOLETE add_target (&eb_ops); */
1088/* OBSOLETE } */
GDB Binutils - Deliverables
This page took 0.142935 seconds and 4 git commands to generate.