1 /* Remote debugging interface for AMD 29000 EBMON on IBM PC, for GDB.
2 Copyright 1990, 1991, 1992 Free Software Foundation, Inc.
3 Contributed by Cygnus Support. Written by Jim Kingdon for Cygnus.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
21 /* This is like remote.c but is for an esoteric situation--
22 having a a29k board in a PC hooked up to a unix machine with
23 a serial line, and running ctty com1 on the PC, through which
24 the unix machine can run ebmon. Not to mention that the PC
25 has PC/NFS, so it can access the same executables that gdb can,
26 over the net in real time. */
28 #define TM_FILE_OVERRIDE
31 #include "a29k/tm-a29k.h"
46 extern struct target_ops eb_ops
; /* Forward declaration */
48 static void eb_close();
50 #define LOG_FILE "eb.log"
51 #if defined (LOG_FILE)
55 static int timeout
= 24;
57 /* Descriptor for I/O to remote machine. Initialize it to -1 so that
58 eb_open knows that we don't have a file open when the program
62 /* stream which is fdopen'd from eb_desc. Only valid when
66 /* Read a character from the remote system, doing all the fancy
75 /* termio does the timeout for us. */
76 read (eb_desc
, &buf
, 1);
79 if (read (eb_desc
, &buf
, 1) < 0)
82 error ("Timeout reading from remote system.");
84 perror_with_name ("remote");
90 error ("Timeout reading from remote system.");
91 #if defined (LOG_FILE)
92 putc (buf
& 0x7f, log_file
);
97 /* Keep discarding input from the remote system, until STRING is found.
98 Let the user break out immediately. */
108 if (readchar() == *p
)
122 /* Keep discarding input until we see the ebmon prompt.
124 The convention for dealing with the prompt is that you
126 o *then* wait for the prompt.
128 Thus the last thing that a procedure does with the serial line
129 will be an expect_prompt(). Exception: eb_resume does not
130 wait for the prompt, because the terminal is being handed over
131 to the inferior. However, the next thing which happens after that
132 is a eb_wait which does wait for the prompt.
133 Note that this includes abnormal exit, e.g. error(). This is
134 necessary to prevent getting into states from which we can't
139 #if defined (LOG_FILE)
140 /* This is a convenient place to do this. The idea is to do it often
141 enough that we never lose much data if we terminate abnormally. */
147 /* Get a hex digit from the remote system & return its value.
148 If ignore_space is nonzero, ignore spaces (not newline, tab, etc). */
150 get_hex_digit (ignore_space
)
157 if (ch
>= '0' && ch
<= '9')
159 else if (ch
>= 'A' && ch
<= 'F')
160 return ch
- 'A' + 10;
161 else if (ch
>= 'a' && ch
<= 'f')
162 return ch
- 'a' + 10;
163 else if (ch
== ' ' && ignore_space
)
168 error ("Invalid hex digit from remote system.");
173 /* Get a byte from eb_desc and put it in *BYT. Accept any number
181 val
= get_hex_digit (1) << 4;
182 val
|= get_hex_digit (0);
186 /* Get N 32-bit words from remote, each preceded by a space,
187 and put them in registers starting at REGNO. */
189 get_hex_regs (n
, regno
)
196 for (i
= 0; i
< n
; i
++)
201 for (j
= 0; j
< 8; j
++)
202 val
= (val
<< 4) + get_hex_digit (j
== 0);
203 supply_register (regno
++, &val
);
207 /* Called when SIGALRM signal sent due to alarm() timeout. */
211 #define volatile /**/
213 volatile int n_alarms
;
220 printf ("eb_timer called\n");
226 /* malloc'd name of the program on the remote system. */
227 static char *prog_name
= NULL
;
229 /* Nonzero if we have loaded the file ("yc") and not yet issued a "gi"
230 command. "gi" is supposed to happen exactly once for each "yc". */
231 static int need_gi
= 0;
233 /* Number of SIGTRAPs we need to simulate. That is, the next
234 NEED_ARTIFICIAL_TRAP calls to eb_wait should just return
235 SIGTRAP without actually waiting for anything. */
237 static int need_artificial_trap
= 0;
239 /* This is called not only when we first attach, but also when the
240 user types "run" after having attached. */
242 eb_create_inferior (execfile
, args
, env
)
250 error ("Can't pass arguments to remote EBMON process");
252 if (execfile
== 0 || exec_bfd
== 0)
253 error ("No exec file specified");
255 entry_pt
= (int) bfd_get_start_address (exec_bfd
);
257 #ifdef CREATE_INFERIOR_HOOK
258 CREATE_INFERIOR_HOOK (0); /* No process-ID */
262 /* OK, now read in the file. Y=read, C=COFF, D=no symbols
263 0=start address, %s=filename. */
265 fprintf (eb_stream
, "YC D,0:%s", prog_name
);
268 fprintf(eb_stream
, " %s", args
);
270 fprintf (eb_stream
, "\n");
278 /* The "process" (board) is already stopped awaiting our commands, and
279 the program is already downloaded. We just set its PC and go. */
281 clear_proceed_status ();
283 /* Tell wait_for_inferior that we've started a new process. */
284 init_wait_for_inferior ();
286 /* Set up the "saved terminal modes" of the inferior
287 based on what modes we are starting it with. */
288 target_terminal_init ();
290 /* Install inferior's terminal modes. */
291 target_terminal_inferior ();
293 /* insert_step_breakpoint (); FIXME, do we need this? */
294 proceed ((CORE_ADDR
)entry_pt
, -1, 0); /* Let 'er rip... */
297 /* Translate baud rates from integers to damn B_codes. Unix should
298 have outgrown this crap years ago, but even POSIX wouldn't buck it. */
307 struct {int rate
, damn_b
;} baudtab
[] = {
332 for (i
= 0; baudtab
[i
].rate
!= -1; i
++)
333 if (rate
== baudtab
[i
].rate
) return baudtab
[i
].damn_b
;
334 return B38400
; /* Random */
338 /* Open a connection to a remote debugger.
339 NAME is the filename used for communication, then a space,
340 then the name of the program as we should name it to EBMON. */
342 static int baudrate
= 9600;
343 static char *dev_name
;
345 eb_open (name
, from_tty
)
353 target_preopen (from_tty
);
355 /* Find the first whitespace character, it separates dev_name from
361 *p
!= '\0' && !isspace (*p
); p
++)
366 Please include the name of the device for the serial port,\n\
367 the baud rate, and the name of the program to run on the remote system.");
368 dev_name
= alloca (p
- name
+ 1);
369 strncpy (dev_name
, name
, p
- name
);
370 dev_name
[p
- name
] = '\0';
372 /* Skip over the whitespace after dev_name */
373 for (; isspace (*p
); p
++)
376 if (1 != sscanf (p
, "%d ", &baudrate
))
379 /* Skip the number and then the spaces */
380 for (; isdigit (*p
); p
++)
382 for (; isspace (*p
); p
++)
385 if (prog_name
!= NULL
)
387 prog_name
= savestring (p
, strlen (p
));
391 eb_desc
= open (dev_name
, O_RDWR
);
393 perror_with_name (dev_name
);
394 ioctl (eb_desc
, TIOCGETP
, &sg
);
396 sg
.c_cc
[VMIN
] = 0; /* read with timeout. */
397 sg
.c_cc
[VTIME
] = timeout
* 10;
398 sg
.c_lflag
&= ~(ICANON
| ECHO
);
399 sg
.c_cflag
= (sg
.c_cflag
& ~CBAUD
) | damn_b (baudrate
);
401 sg
.sg_ispeed
= damn_b (baudrate
);
402 sg
.sg_ospeed
= damn_b (baudrate
);
403 sg
.sg_flags
|= RAW
| ANYP
;
404 sg
.sg_flags
&= ~ECHO
;
407 ioctl (eb_desc
, TIOCSETP
, &sg
);
408 eb_stream
= fdopen (eb_desc
, "r+");
410 push_target (&eb_ops
);
412 printf ("Remote %s debugging %s using %s\n", target_shortname
,
413 prog_name
, dev_name
);
416 #ifndef NO_SIGINTERRUPT
417 /* Cause SIGALRM's to make reads fail with EINTR instead of resuming
419 if (siginterrupt (SIGALRM
, 1) != 0)
420 perror ("eb_open: error in siginterrupt");
423 /* Set up read timeout timer. */
424 if ((void (*)) signal (SIGALRM
, eb_timer
) == (void (*)) -1)
425 perror ("eb_open: error in signal");
428 #if defined (LOG_FILE)
429 log_file
= fopen (LOG_FILE
, "w");
430 if (log_file
== NULL
)
431 perror_with_name (LOG_FILE
);
434 /* Hello? Are you there? */
435 write (eb_desc
, "\n", 1);
440 /* Close out all files and local state before this target loses control. */
447 /* Due to a bug in Unix, fclose closes not only the stdio stream,
448 but also the file descriptor. So we don't actually close
451 fclose (eb_stream
); /* This also closes eb_desc */
453 /* close (eb_desc); */
455 /* Do not try to close eb_desc again, later in the program. */
459 #if defined (LOG_FILE)
461 if (ferror (log_file
))
462 printf ("Error writing log file.\n");
463 if (fclose (log_file
) != 0)
464 printf ("Error closing log file.\n");
469 /* Terminate the open connection to the remote debugger.
470 Use this when you want to detach and do something else
476 pop_target(); /* calls eb_close to do the real work */
478 printf ("Ending remote %s debugging\n", target_shortname
);
481 /* Tell the remote machine to resume. */
484 eb_resume (step
, sig
)
489 write (eb_desc
, "t 1,s\n", 6);
490 /* Wait for the echo. */
492 /* Then comes a line containing the instruction we stepped to. */
494 /* Then we get the prompt. */
497 /* Force the next eb_wait to return a trap. Not doing anything
498 about I/O from the target means that the user has to type
499 "continue" to see any. This should be fixed. */
500 need_artificial_trap
= 1;
507 write (eb_desc
, "gi\n", 3);
509 /* Swallow the echo of "gi". */
514 write (eb_desc
, "GR\n", 3);
515 /* Swallow the echo. */
521 /* Wait until the remote machine stops, then return,
522 storing status in STATUS just as `wait' would. */
528 /* Strings to look for. '?' means match any single character.
529 Note that with the algorithm we use, the initial character
530 of the string cannot recur in the string, or we will not
531 find some cases of the string in the input. */
533 static char bpt
[] = "Invalid interrupt taken - #0x50 - ";
534 /* It would be tempting to look for "\n[__exit + 0x8]\n"
535 but that requires loading symbols with "yc i" and even if
536 we did do that we don't know that the file has symbols. */
537 static char exitmsg
[] = "\n@????????I JMPTI GR121,LR0";
541 /* Large enough for either sizeof (bpt) or sizeof (exitmsg) chars. */
543 /* Current position in swallowed. */
544 char *swallowed_p
= swallowed
;
549 int old_timeout
= timeout
;
551 WSETEXIT ((*status
), 0);
553 if (need_artificial_trap
!= 0)
555 WSETSTOP ((*status
), SIGTRAP
);
556 need_artificial_trap
--;
560 timeout
= 0; /* Don't time out -- user program is running. */
577 if (ch
== *ep
|| *ep
== '?')
594 /* Print out any characters which have been swallowed. */
595 for (p
= swallowed
; p
< swallowed_p
; ++p
)
597 swallowed_p
= swallowed
;
604 WSETSTOP ((*status
), SIGTRAP
);
606 WSETEXIT ((*status
), 0);
607 timeout
= old_timeout
;
612 /* Return the name of register number REGNO
613 in the form input and output by EBMON.
615 Returns a pointer to a static buffer containing the answer. */
621 if (regno
>= GR96_REGNUM
&& regno
< GR96_REGNUM
+ 32)
622 sprintf (buf
, "GR%03d", regno
- GR96_REGNUM
+ 96);
623 else if (regno
>= LR0_REGNUM
&& regno
< LR0_REGNUM
+ 128)
624 sprintf (buf
, "LR%03d", regno
- LR0_REGNUM
);
625 else if (regno
== Q_REGNUM
)
626 strcpy (buf
, "SR131");
627 else if (regno
>= BP_REGNUM
&& regno
<= CR_REGNUM
)
628 sprintf (buf
, "SR%03d", regno
- BP_REGNUM
+ 133);
629 else if (regno
== ALU_REGNUM
)
630 strcpy (buf
, "SR132");
631 else if (regno
>= IPC_REGNUM
&& regno
<= IPB_REGNUM
)
632 sprintf (buf
, "SR%03d", regno
- IPC_REGNUM
+ 128);
633 else if (regno
>= VAB_REGNUM
&& regno
<= LRU_REGNUM
)
634 sprintf (buf
, "SR%03d", regno
- VAB_REGNUM
);
635 else if (regno
== GR1_REGNUM
)
636 strcpy (buf
, "GR001");
640 /* Read the remote registers into the block REGS. */
643 eb_fetch_registers ()
651 /* This should not be necessary, because one is supposed to read the
652 registers only when the inferior is stopped (at least with
653 ptrace() and why not make it the same for remote?). */
654 /* ^A is the "normal character" used to make sure we are talking to EBMON
655 and not to the program being debugged. */
656 write (eb_desc
, "\001\n");
660 write (eb_desc
, "dw gr96,gr127\n", 14);
661 for (reg_index
= 96, regnum_index
= GR96_REGNUM
;
663 reg_index
+= 4, regnum_index
+= 4)
665 sprintf (tempbuf
, "GR%03d ", reg_index
);
667 get_hex_regs (4, regnum_index
);
671 for (i
= 0; i
< 128; i
+= 32)
673 /* The PC has a tendency to hang if we get these
674 all in one fell swoop ("dw lr0,lr127"). */
675 sprintf (tempbuf
, "dw lr%d\n", i
);
676 write (eb_desc
, tempbuf
, strlen (tempbuf
));
677 for (reg_index
= i
, regnum_index
= LR0_REGNUM
+ i
;
679 reg_index
+= 4, regnum_index
+= 4)
681 sprintf (tempbuf
, "LR%03d ", reg_index
);
683 get_hex_regs (4, regnum_index
);
688 write (eb_desc
, "dw sr133,sr133\n", 15);
690 get_hex_regs (1, BP_REGNUM
);
693 write (eb_desc
, "dw sr134,sr134\n", 15);
695 get_hex_regs (1, FC_REGNUM
);
698 write (eb_desc
, "dw sr135,sr135\n", 15);
700 get_hex_regs (1, CR_REGNUM
);
703 write (eb_desc
, "dw sr131,sr131\n", 15);
705 get_hex_regs (1, Q_REGNUM
);
708 write (eb_desc
, "dw sr0,sr14\n", 12);
709 for (reg_index
= 0, regnum_index
= VAB_REGNUM
;
710 regnum_index
<= LRU_REGNUM
;
711 regnum_index
+= 4, reg_index
+= 4)
713 sprintf (tempbuf
, "SR%03d ", reg_index
);
715 get_hex_regs (reg_index
== 12 ? 3 : 4, regnum_index
);
719 /* There doesn't seem to be any way to get these. */
722 supply_register (FPE_REGNUM
, &val
);
723 supply_register (INTE_REGNUM
, &val
);
724 supply_register (FPS_REGNUM
, &val
);
725 supply_register (EXO_REGNUM
, &val
);
728 write (eb_desc
, "dw gr1,gr1\n", 11);
730 get_hex_regs (1, GR1_REGNUM
);
734 /* Fetch register REGNO, or all registers if REGNO is -1.
735 Returns errno value. */
737 eb_fetch_register (regno
)
741 eb_fetch_registers ();
744 char *name
= get_reg_name (regno
);
745 fprintf (eb_stream
, "dw %s,%s\n", name
, name
);
748 get_hex_regs (1, regno
);
754 /* Store the remote registers from the contents of the block REGS. */
757 eb_store_registers ()
760 fprintf (eb_stream
, "s gr1,%x\n", read_register (GR1_REGNUM
));
763 for (j
= 0; j
< 32; j
+= 16)
765 fprintf (eb_stream
, "s gr%d,", j
+ 96);
766 for (i
= 0; i
< 15; ++i
)
767 fprintf (eb_stream
, "%x,", read_register (GR96_REGNUM
+ j
+ i
));
768 fprintf (eb_stream
, "%x\n", read_register (GR96_REGNUM
+ j
+ 15));
772 for (j
= 0; j
< 128; j
+= 16)
774 fprintf (eb_stream
, "s lr%d,", j
);
775 for (i
= 0; i
< 15; ++i
)
776 fprintf (eb_stream
, "%x,", read_register (LR0_REGNUM
+ j
+ i
));
777 fprintf (eb_stream
, "%x\n", read_register (LR0_REGNUM
+ j
+ 15));
781 fprintf (eb_stream
, "s sr133,%x,%x,%x\n", read_register (BP_REGNUM
),
782 read_register (FC_REGNUM
), read_register (CR_REGNUM
));
784 fprintf (eb_stream
, "s sr131,%x\n", read_register (Q_REGNUM
));
786 fprintf (eb_stream
, "s sr0,");
787 for (i
= 0; i
< 11; ++i
)
788 fprintf (eb_stream
, "%x,", read_register (VAB_REGNUM
+ i
));
789 fprintf (eb_stream
, "%x\n", read_register (VAB_REGNUM
+ 11));
793 /* Store register REGNO, or all if REGNO == 0.
794 Return errno value. */
796 eb_store_register (regno
)
800 eb_store_registers ();
803 char *name
= get_reg_name (regno
);
804 fprintf (eb_stream
, "s %s,%x\n", name
, read_register (regno
));
805 /* Setting GR1 changes the numbers of all the locals, so
806 invalidate the register cache. Do this *after* calling
807 read_register, because we want read_register to return the
808 value that write_register has just stuffed into the registers
809 array, not the value of the register fetched from the
811 if (regno
== GR1_REGNUM
)
812 registers_changed ();
817 /* Get ready to modify the registers array. On machines which store
818 individual registers, this doesn't need to do anything. On machines
819 which store all the registers in one fell swoop, this makes sure
820 that registers contains all the registers from the program being
824 eb_prepare_to_store ()
826 /* Do nothing, since we can store individual regs */
830 /* FIXME-someday! Merge these two. */
832 eb_xfer_inferior_memory (memaddr
, myaddr
, len
, write
, target
)
837 struct target_ops
*target
; /* ignored */
840 return eb_write_inferior_memory (memaddr
, myaddr
, len
);
842 return eb_read_inferior_memory (memaddr
, myaddr
, len
);
848 printf ("\tAttached to %s at %d baud and running program %s.\n",
849 dev_name
, baudrate
, prog_name
);
852 /* Copy LEN bytes of data from debugger memory at MYADDR
853 to inferior's memory at MEMADDR. Returns length moved. */
855 eb_write_inferior_memory (memaddr
, myaddr
, len
)
862 for (i
= 0; i
< len
; i
++)
865 fprintf (eb_stream
, "sb %x,", memaddr
+ i
);
866 if ((i
% 16) == 15 || i
== len
- 1)
868 fprintf (eb_stream
, "%x\n", ((unsigned char *)myaddr
)[i
]);
872 fprintf (eb_stream
, "%x,", ((unsigned char *)myaddr
)[i
]);
877 /* Read LEN bytes from inferior memory at MEMADDR. Put the result
878 at debugger address MYADDR. Returns length moved. */
880 eb_read_inferior_memory(memaddr
, myaddr
, len
)
887 /* Number of bytes read so far. */
890 /* Starting address of this pass. */
891 unsigned long startaddr
;
893 /* Number of bytes to read in this pass. */
896 /* Note that this code works correctly if startaddr is just less
897 than UINT_MAX (well, really CORE_ADDR_MAX if there was such a
898 thing). That is, something like
899 eb_read_bytes (CORE_ADDR_MAX - 4, foo, 4)
900 works--it never adds len to memaddr and gets 0. */
901 /* However, something like
902 eb_read_bytes (CORE_ADDR_MAX - 3, foo, 4)
903 doesn't need to work. Detect it and give up if there's an attempt
905 if (((memaddr
- 1) + len
) < memaddr
) {
915 if ((startaddr
% 16) != 0)
916 len_this_pass
-= startaddr
% 16;
917 if (len_this_pass
> (len
- count
))
918 len_this_pass
= (len
- count
);
920 fprintf (eb_stream
, "db %x,%x\n", startaddr
,
921 (startaddr
- 1) + len_this_pass
);
924 /* Look for 8 hex digits. */
928 if (isxdigit (readchar ()))
933 error ("Hex digit expected from remote system.");
941 for (i
= 0; i
< len_this_pass
; i
++)
942 get_hex_byte (&myaddr
[count
++]);
946 startaddr
+= len_this_pass
;
952 eb_kill (args
, from_tty
)
956 return; /* Ignore attempts to kill target system */
959 /* Clean up when a program exits.
961 The program actually lives on in the remote processor's RAM, and may be
962 run again without a download. Don't leave it full of breakpoint
968 remove_breakpoints ();
969 unpush_target (&eb_ops
);
970 generic_mourn_inferior (); /* Do all the proper things now */
972 /* Define the target subroutine names */
974 struct target_ops eb_ops
= {
975 "amd-eb", "Remote serial AMD EBMON target",
976 "Use a remote computer running EBMON connected by a serial line.\n\
977 Arguments are the name of the device for the serial line,\n\
978 the speed to connect at in bits per second, and the filename of the\n\
979 executable as it exists on the remote computer. For example,\n\
980 target amd-eb /dev/ttya 9600 demo",
982 0, eb_detach
, eb_resume
, eb_wait
,
983 eb_fetch_register
, eb_store_register
,
985 eb_xfer_inferior_memory
, eb_files_info
,
986 0, 0, /* Breakpoints */
987 0, 0, 0, 0, 0, /* Terminal handling */
989 generic_load
, /* load */
990 0, /* lookup_symbol */
994 0, /* notice_signals */
995 process_stratum
, 0, /* next */
996 1, 1, 1, 1, 1, /* all mem, mem, stack, regs, exec */
997 0, 0, /* Section pointers */
998 OPS_MAGIC
, /* Always the last thing */
1002 _initialize_remote_eb ()
1004 add_target (&eb_ops
);
This page took 0.04827 seconds and 4 git commands to generate.