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"
44 extern struct target_ops eb_ops
; /* Forward declaration */
46 static void eb_close();
48 #define LOG_FILE "eb.log"
49 #if defined (LOG_FILE)
53 static int timeout
= 24;
55 /* Descriptor for I/O to remote machine. Initialize it to -1 so that
56 eb_open knows that we don't have a file open when the program
60 /* stream which is fdopen'd from eb_desc. Only valid when
64 /* Read a character from the remote system, doing all the fancy
73 /* termio does the timeout for us. */
74 read (eb_desc
, &buf
, 1);
77 if (read (eb_desc
, &buf
, 1) < 0)
80 error ("Timeout reading from remote system.");
82 perror_with_name ("remote");
88 error ("Timeout reading from remote system.");
89 #if defined (LOG_FILE)
90 putc (buf
& 0x7f, log_file
);
95 /* Keep discarding input from the remote system, until STRING is found.
96 Let the user break out immediately. */
106 if (readchar() == *p
)
120 /* Keep discarding input until we see the ebmon prompt.
122 The convention for dealing with the prompt is that you
124 o *then* wait for the prompt.
126 Thus the last thing that a procedure does with the serial line
127 will be an expect_prompt(). Exception: eb_resume does not
128 wait for the prompt, because the terminal is being handed over
129 to the inferior. However, the next thing which happens after that
130 is a eb_wait which does wait for the prompt.
131 Note that this includes abnormal exit, e.g. error(). This is
132 necessary to prevent getting into states from which we can't
137 #if defined (LOG_FILE)
138 /* This is a convenient place to do this. The idea is to do it often
139 enough that we never lose much data if we terminate abnormally. */
145 /* Get a hex digit from the remote system & return its value.
146 If ignore_space is nonzero, ignore spaces (not newline, tab, etc). */
148 get_hex_digit (ignore_space
)
155 if (ch
>= '0' && ch
<= '9')
157 else if (ch
>= 'A' && ch
<= 'F')
158 return ch
- 'A' + 10;
159 else if (ch
>= 'a' && ch
<= 'f')
160 return ch
- 'a' + 10;
161 else if (ch
== ' ' && ignore_space
)
166 error ("Invalid hex digit from remote system.");
171 /* Get a byte from eb_desc and put it in *BYT. Accept any number
179 val
= get_hex_digit (1) << 4;
180 val
|= get_hex_digit (0);
184 /* Get N 32-bit words from remote, each preceded by a space,
185 and put them in registers starting at REGNO. */
187 get_hex_regs (n
, regno
)
194 for (i
= 0; i
< n
; i
++)
199 for (j
= 0; j
< 8; j
++)
200 val
= (val
<< 4) + get_hex_digit (j
== 0);
201 supply_register (regno
++, &val
);
205 /* Called when SIGALRM signal sent due to alarm() timeout. */
209 #define volatile /**/
211 volatile int n_alarms
;
218 printf ("eb_timer called\n");
224 /* malloc'd name of the program on the remote system. */
225 static char *prog_name
= NULL
;
227 /* Nonzero if we have loaded the file ("yc") and not yet issued a "gi"
228 command. "gi" is supposed to happen exactly once for each "yc". */
229 static int need_gi
= 0;
231 /* Number of SIGTRAPs we need to simulate. That is, the next
232 NEED_ARTIFICIAL_TRAP calls to eb_wait should just return
233 SIGTRAP without actually waiting for anything. */
235 static int need_artificial_trap
= 0;
237 /* This is called not only when we first attach, but also when the
238 user types "run" after having attached. */
240 eb_create_inferior (execfile
, args
, env
)
248 error ("Can't pass arguments to remote EBMON process");
250 if (execfile
== 0 || exec_bfd
== 0)
251 error ("No exec file specified");
253 entry_pt
= (int) bfd_get_start_address (exec_bfd
);
255 #ifdef CREATE_INFERIOR_HOOK
256 CREATE_INFERIOR_HOOK (0); /* No process-ID */
260 /* OK, now read in the file. Y=read, C=COFF, D=no symbols
261 0=start address, %s=filename. */
263 fprintf (eb_stream
, "YC D,0:%s", prog_name
);
266 fprintf(eb_stream
, " %s", args
);
268 fprintf (eb_stream
, "\n");
276 /* The "process" (board) is already stopped awaiting our commands, and
277 the program is already downloaded. We just set its PC and go. */
279 clear_proceed_status ();
281 /* Tell wait_for_inferior that we've started a new process. */
282 init_wait_for_inferior ();
284 /* Set up the "saved terminal modes" of the inferior
285 based on what modes we are starting it with. */
286 target_terminal_init ();
288 /* Install inferior's terminal modes. */
289 target_terminal_inferior ();
291 /* insert_step_breakpoint (); FIXME, do we need this? */
292 proceed ((CORE_ADDR
)entry_pt
, -1, 0); /* Let 'er rip... */
295 /* Translate baud rates from integers to damn B_codes. Unix should
296 have outgrown this crap years ago, but even POSIX wouldn't buck it. */
305 struct {int rate
, damn_b
;} baudtab
[] = {
330 for (i
= 0; baudtab
[i
].rate
!= -1; i
++)
331 if (rate
== baudtab
[i
].rate
) return baudtab
[i
].damn_b
;
332 return B38400
; /* Random */
336 /* Open a connection to a remote debugger.
337 NAME is the filename used for communication, then a space,
338 then the name of the program as we should name it to EBMON. */
340 static int baudrate
= 9600;
341 static char *dev_name
;
343 eb_open (name
, from_tty
)
351 target_preopen (from_tty
);
353 /* Find the first whitespace character, it separates dev_name from
359 *p
!= '\0' && !isspace (*p
); p
++)
364 Please include the name of the device for the serial port,\n\
365 the baud rate, and the name of the program to run on the remote system.");
366 dev_name
= alloca (p
- name
+ 1);
367 strncpy (dev_name
, name
, p
- name
);
368 dev_name
[p
- name
] = '\0';
370 /* Skip over the whitespace after dev_name */
371 for (; isspace (*p
); p
++)
374 if (1 != sscanf (p
, "%d ", &baudrate
))
377 /* Skip the number and then the spaces */
378 for (; isdigit (*p
); p
++)
380 for (; isspace (*p
); p
++)
383 if (prog_name
!= NULL
)
385 prog_name
= savestring (p
, strlen (p
));
389 eb_desc
= open (dev_name
, O_RDWR
);
391 perror_with_name (dev_name
);
392 ioctl (eb_desc
, TIOCGETP
, &sg
);
394 sg
.c_cc
[VMIN
] = 0; /* read with timeout. */
395 sg
.c_cc
[VTIME
] = timeout
* 10;
396 sg
.c_lflag
&= ~(ICANON
| ECHO
);
397 sg
.c_cflag
= (sg
.c_cflag
& ~CBAUD
) | damn_b (baudrate
);
399 sg
.sg_ispeed
= damn_b (baudrate
);
400 sg
.sg_ospeed
= damn_b (baudrate
);
401 sg
.sg_flags
|= RAW
| ANYP
;
402 sg
.sg_flags
&= ~ECHO
;
405 ioctl (eb_desc
, TIOCSETP
, &sg
);
406 eb_stream
= fdopen (eb_desc
, "r+");
408 push_target (&eb_ops
);
410 printf ("Remote %s debugging %s using %s\n", target_shortname
,
411 prog_name
, dev_name
);
414 #ifndef NO_SIGINTERRUPT
415 /* Cause SIGALRM's to make reads fail with EINTR instead of resuming
417 if (siginterrupt (SIGALRM
, 1) != 0)
418 perror ("eb_open: error in siginterrupt");
421 /* Set up read timeout timer. */
422 if ((void (*)) signal (SIGALRM
, eb_timer
) == (void (*)) -1)
423 perror ("eb_open: error in signal");
426 #if defined (LOG_FILE)
427 log_file
= fopen (LOG_FILE
, "w");
428 if (log_file
== NULL
)
429 perror_with_name (LOG_FILE
);
432 /* Hello? Are you there? */
433 write (eb_desc
, "\n", 1);
438 /* Close out all files and local state before this target loses control. */
445 /* Due to a bug in Unix, fclose closes not only the stdio stream,
446 but also the file descriptor. So we don't actually close
449 fclose (eb_stream
); /* This also closes eb_desc */
451 /* close (eb_desc); */
453 /* Do not try to close eb_desc again, later in the program. */
457 #if defined (LOG_FILE)
459 if (ferror (log_file
))
460 printf ("Error writing log file.\n");
461 if (fclose (log_file
) != 0)
462 printf ("Error closing log file.\n");
467 /* Terminate the open connection to the remote debugger.
468 Use this when you want to detach and do something else
474 pop_target(); /* calls eb_close to do the real work */
476 printf ("Ending remote %s debugging\n", target_shortname
);
479 /* Tell the remote machine to resume. */
482 eb_resume (step
, sig
)
487 write (eb_desc
, "t 1,s\n", 6);
488 /* Wait for the echo. */
490 /* Then comes a line containing the instruction we stepped to. */
492 /* Then we get the prompt. */
495 /* Force the next eb_wait to return a trap. Not doing anything
496 about I/O from the target means that the user has to type
497 "continue" to see any. This should be fixed. */
498 need_artificial_trap
= 1;
505 write (eb_desc
, "gi\n", 3);
507 /* Swallow the echo of "gi". */
512 write (eb_desc
, "GR\n", 3);
513 /* Swallow the echo. */
519 /* Wait until the remote machine stops, then return,
520 storing status in STATUS just as `wait' would. */
526 /* Strings to look for. '?' means match any single character.
527 Note that with the algorithm we use, the initial character
528 of the string cannot recur in the string, or we will not
529 find some cases of the string in the input. */
531 static char bpt
[] = "Invalid interrupt taken - #0x50 - ";
532 /* It would be tempting to look for "\n[__exit + 0x8]\n"
533 but that requires loading symbols with "yc i" and even if
534 we did do that we don't know that the file has symbols. */
535 static char exitmsg
[] = "\n@????????I JMPTI GR121,LR0";
539 /* Large enough for either sizeof (bpt) or sizeof (exitmsg) chars. */
541 /* Current position in swallowed. */
542 char *swallowed_p
= swallowed
;
547 int old_timeout
= timeout
;
549 WSETEXIT ((*status
), 0);
551 if (need_artificial_trap
!= 0)
553 WSETSTOP ((*status
), SIGTRAP
);
554 need_artificial_trap
--;
558 timeout
= 0; /* Don't time out -- user program is running. */
575 if (ch
== *ep
|| *ep
== '?')
592 /* Print out any characters which have been swallowed. */
593 for (p
= swallowed
; p
< swallowed_p
; ++p
)
595 swallowed_p
= swallowed
;
602 WSETSTOP ((*status
), SIGTRAP
);
604 WSETEXIT ((*status
), 0);
605 timeout
= old_timeout
;
610 /* Return the name of register number REGNO
611 in the form input and output by EBMON.
613 Returns a pointer to a static buffer containing the answer. */
619 if (regno
>= GR96_REGNUM
&& regno
< GR96_REGNUM
+ 32)
620 sprintf (buf
, "GR%03d", regno
- GR96_REGNUM
+ 96);
621 else if (regno
>= LR0_REGNUM
&& regno
< LR0_REGNUM
+ 128)
622 sprintf (buf
, "LR%03d", regno
- LR0_REGNUM
);
623 else if (regno
== Q_REGNUM
)
624 strcpy (buf
, "SR131");
625 else if (regno
>= BP_REGNUM
&& regno
<= CR_REGNUM
)
626 sprintf (buf
, "SR%03d", regno
- BP_REGNUM
+ 133);
627 else if (regno
== ALU_REGNUM
)
628 strcpy (buf
, "SR132");
629 else if (regno
>= IPC_REGNUM
&& regno
<= IPB_REGNUM
)
630 sprintf (buf
, "SR%03d", regno
- IPC_REGNUM
+ 128);
631 else if (regno
>= VAB_REGNUM
&& regno
<= LRU_REGNUM
)
632 sprintf (buf
, "SR%03d", regno
- VAB_REGNUM
);
633 else if (regno
== GR1_REGNUM
)
634 strcpy (buf
, "GR001");
638 /* Read the remote registers into the block REGS. */
641 eb_fetch_registers ()
649 /* This should not be necessary, because one is supposed to read the
650 registers only when the inferior is stopped (at least with
651 ptrace() and why not make it the same for remote?). */
652 /* ^A is the "normal character" used to make sure we are talking to EBMON
653 and not to the program being debugged. */
654 write (eb_desc
, "\001\n");
658 write (eb_desc
, "dw gr96,gr127\n", 14);
659 for (reg_index
= 96, regnum_index
= GR96_REGNUM
;
661 reg_index
+= 4, regnum_index
+= 4)
663 sprintf (tempbuf
, "GR%03d ", reg_index
);
665 get_hex_regs (4, regnum_index
);
669 for (i
= 0; i
< 128; i
+= 32)
671 /* The PC has a tendency to hang if we get these
672 all in one fell swoop ("dw lr0,lr127"). */
673 sprintf (tempbuf
, "dw lr%d\n", i
);
674 write (eb_desc
, tempbuf
, strlen (tempbuf
));
675 for (reg_index
= i
, regnum_index
= LR0_REGNUM
+ i
;
677 reg_index
+= 4, regnum_index
+= 4)
679 sprintf (tempbuf
, "LR%03d ", reg_index
);
681 get_hex_regs (4, regnum_index
);
686 write (eb_desc
, "dw sr133,sr133\n", 15);
688 get_hex_regs (1, BP_REGNUM
);
691 write (eb_desc
, "dw sr134,sr134\n", 15);
693 get_hex_regs (1, FC_REGNUM
);
696 write (eb_desc
, "dw sr135,sr135\n", 15);
698 get_hex_regs (1, CR_REGNUM
);
701 write (eb_desc
, "dw sr131,sr131\n", 15);
703 get_hex_regs (1, Q_REGNUM
);
706 write (eb_desc
, "dw sr0,sr14\n", 12);
707 for (reg_index
= 0, regnum_index
= VAB_REGNUM
;
708 regnum_index
<= LRU_REGNUM
;
709 regnum_index
+= 4, reg_index
+= 4)
711 sprintf (tempbuf
, "SR%03d ", reg_index
);
713 get_hex_regs (reg_index
== 12 ? 3 : 4, regnum_index
);
717 /* There doesn't seem to be any way to get these. */
720 supply_register (FPE_REGNUM
, &val
);
721 supply_register (INTE_REGNUM
, &val
);
722 supply_register (FPS_REGNUM
, &val
);
723 supply_register (EXO_REGNUM
, &val
);
726 write (eb_desc
, "dw gr1,gr1\n", 11);
728 get_hex_regs (1, GR1_REGNUM
);
732 /* Fetch register REGNO, or all registers if REGNO is -1.
733 Returns errno value. */
735 eb_fetch_register (regno
)
739 eb_fetch_registers ();
742 char *name
= get_reg_name (regno
);
743 fprintf (eb_stream
, "dw %s,%s\n", name
, name
);
746 get_hex_regs (1, regno
);
752 /* Store the remote registers from the contents of the block REGS. */
755 eb_store_registers ()
758 fprintf (eb_stream
, "s gr1,%x\n", read_register (GR1_REGNUM
));
761 for (j
= 0; j
< 32; j
+= 16)
763 fprintf (eb_stream
, "s gr%d,", j
+ 96);
764 for (i
= 0; i
< 15; ++i
)
765 fprintf (eb_stream
, "%x,", read_register (GR96_REGNUM
+ j
+ i
));
766 fprintf (eb_stream
, "%x\n", read_register (GR96_REGNUM
+ j
+ 15));
770 for (j
= 0; j
< 128; j
+= 16)
772 fprintf (eb_stream
, "s lr%d,", j
);
773 for (i
= 0; i
< 15; ++i
)
774 fprintf (eb_stream
, "%x,", read_register (LR0_REGNUM
+ j
+ i
));
775 fprintf (eb_stream
, "%x\n", read_register (LR0_REGNUM
+ j
+ 15));
779 fprintf (eb_stream
, "s sr133,%x,%x,%x\n", read_register (BP_REGNUM
),
780 read_register (FC_REGNUM
), read_register (CR_REGNUM
));
782 fprintf (eb_stream
, "s sr131,%x\n", read_register (Q_REGNUM
));
784 fprintf (eb_stream
, "s sr0,");
785 for (i
= 0; i
< 11; ++i
)
786 fprintf (eb_stream
, "%x,", read_register (VAB_REGNUM
+ i
));
787 fprintf (eb_stream
, "%x\n", read_register (VAB_REGNUM
+ 11));
791 /* Store register REGNO, or all if REGNO == 0.
792 Return errno value. */
794 eb_store_register (regno
)
798 eb_store_registers ();
801 char *name
= get_reg_name (regno
);
802 fprintf (eb_stream
, "s %s,%x\n", name
, read_register (regno
));
803 /* Setting GR1 changes the numbers of all the locals, so
804 invalidate the register cache. Do this *after* calling
805 read_register, because we want read_register to return the
806 value that write_register has just stuffed into the registers
807 array, not the value of the register fetched from the
809 if (regno
== GR1_REGNUM
)
810 registers_changed ();
815 /* Get ready to modify the registers array. On machines which store
816 individual registers, this doesn't need to do anything. On machines
817 which store all the registers in one fell swoop, this makes sure
818 that registers contains all the registers from the program being
822 eb_prepare_to_store ()
824 /* Do nothing, since we can store individual regs */
828 /* FIXME-someday! Merge these two. */
830 eb_xfer_inferior_memory (memaddr
, myaddr
, len
, write
, target
)
835 struct target_ops
*target
; /* ignored */
838 return eb_write_inferior_memory (memaddr
, myaddr
, len
);
840 return eb_read_inferior_memory (memaddr
, myaddr
, len
);
846 printf ("\tAttached to %s at %d baud and running program %s.\n",
847 dev_name
, baudrate
, prog_name
);
850 /* Copy LEN bytes of data from debugger memory at MYADDR
851 to inferior's memory at MEMADDR. Returns length moved. */
853 eb_write_inferior_memory (memaddr
, myaddr
, len
)
860 for (i
= 0; i
< len
; i
++)
863 fprintf (eb_stream
, "sb %x,", memaddr
+ i
);
864 if ((i
% 16) == 15 || i
== len
- 1)
866 fprintf (eb_stream
, "%x\n", ((unsigned char *)myaddr
)[i
]);
870 fprintf (eb_stream
, "%x,", ((unsigned char *)myaddr
)[i
]);
875 /* Read LEN bytes from inferior memory at MEMADDR. Put the result
876 at debugger address MYADDR. Returns length moved. */
878 eb_read_inferior_memory(memaddr
, myaddr
, len
)
885 /* Number of bytes read so far. */
888 /* Starting address of this pass. */
889 unsigned long startaddr
;
891 /* Number of bytes to read in this pass. */
894 /* Note that this code works correctly if startaddr is just less
895 than UINT_MAX (well, really CORE_ADDR_MAX if there was such a
896 thing). That is, something like
897 eb_read_bytes (CORE_ADDR_MAX - 4, foo, 4)
898 works--it never adds len to memaddr and gets 0. */
899 /* However, something like
900 eb_read_bytes (CORE_ADDR_MAX - 3, foo, 4)
901 doesn't need to work. Detect it and give up if there's an attempt
903 if (((memaddr
- 1) + len
) < memaddr
) {
913 if ((startaddr
% 16) != 0)
914 len_this_pass
-= startaddr
% 16;
915 if (len_this_pass
> (len
- count
))
916 len_this_pass
= (len
- count
);
918 fprintf (eb_stream
, "db %x,%x\n", startaddr
,
919 (startaddr
- 1) + len_this_pass
);
922 /* Look for 8 hex digits. */
926 if (isxdigit (readchar ()))
931 error ("Hex digit expected from remote system.");
939 for (i
= 0; i
< len_this_pass
; i
++)
940 get_hex_byte (&myaddr
[count
++]);
944 startaddr
+= len_this_pass
;
950 eb_kill (args
, from_tty
)
954 return; /* Ignore attempts to kill target system */
957 /* Clean up when a program exits.
959 The program actually lives on in the remote processor's RAM, and may be
960 run again without a download. Don't leave it full of breakpoint
966 remove_breakpoints ();
967 unpush_target (&eb_ops
);
968 generic_mourn_inferior (); /* Do all the proper things now */
970 /* Define the target subroutine names */
972 struct target_ops eb_ops
= {
973 "amd-eb", "Remote serial AMD EBMON target",
974 "Use a remote computer running EBMON connected by a serial line.\n\
975 Arguments are the name of the device for the serial line,\n\
976 the speed to connect at in bits per second, and the filename of the\n\
977 executable as it exists on the remote computer. For example,\n\
978 target amd-eb /dev/ttya 9600 demo",
980 0, eb_detach
, eb_resume
, eb_wait
,
981 eb_fetch_register
, eb_store_register
,
983 eb_xfer_inferior_memory
, eb_files_info
,
984 0, 0, /* Breakpoints */
985 0, 0, 0, 0, 0, /* Terminal handling */
988 0, /* lookup_symbol */
992 0, /* notice_signals */
993 process_stratum
, 0, /* next */
994 1, 1, 1, 1, 1, /* all mem, mem, stack, regs, exec */
995 0, 0, /* Section pointers */
996 OPS_MAGIC
, /* Always the last thing */
1000 _initialize_remote_eb ()
1002 add_target (&eb_ops
);
This page took 0.050003 seconds and 4 git commands to generate.