1ab87ebf6e7e332ba42105b4b755fdb9fddd936b
1 /* Remote debugging interface for AMD 29000 EBMON on IBM PC, for GDB.
2 Copyright 1990-1991 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 29k 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. */
30 #define TM_FILE_OVERRIDE
43 extern struct value
*call_function_by_hand();
45 extern struct target_ops eb_ops
; /* Forward declaration */
47 static void eb_close();
49 #define LOG_FILE "eb.log"
50 #if defined (LOG_FILE)
54 static int timeout
= 5;
56 /* Descriptor for I/O to remote machine. Initialize it to -1 so that
57 eb_open knows that we don't have a file open when the program
61 /* stream which is fdopen'd from eb_desc. Only valid when
65 /* Read a character from the remote system, doing all the fancy
74 /* termio does the timeout for us. */
75 read (eb_desc
, &buf
, 1);
78 if (read (eb_desc
, &buf
, 1) < 0)
81 error ("Timeout reading from remote system.");
83 perror_with_name ("remote");
89 error ("Timeout reading from remote system.");
90 #if defined (LOG_FILE)
91 putc (buf
& 0x7f, log_file
);
96 /* Keep discarding input from the remote system, until STRING is found.
97 Let the user break out immediately. */
107 if (readchar() == *p
)
121 /* Keep discarding input until we see the ebmon prompt.
123 The convention for dealing with the prompt is that you
125 o *then* wait for the prompt.
127 Thus the last thing that a procedure does with the serial line
128 will be an expect_prompt(). Exception: eb_resume does not
129 wait for the prompt, because the terminal is being handed over
130 to the inferior. However, the next thing which happens after that
131 is a eb_wait which does wait for the prompt.
132 Note that this includes abnormal exit, e.g. error(). This is
133 necessary to prevent getting into states from which we can't
138 #if defined (LOG_FILE)
139 /* This is a convenient place to do this. The idea is to do it often
140 enough that we never lose much data if we terminate abnormally. */
146 /* Get a hex digit from the remote system & return its value.
147 If ignore_space is nonzero, ignore spaces (not newline, tab, etc). */
149 get_hex_digit (ignore_space
)
156 if (ch
>= '0' && ch
<= '9')
158 else if (ch
>= 'A' && ch
<= 'F')
159 return ch
- 'A' + 10;
160 else if (ch
>= 'a' && ch
<= 'f')
161 return ch
- 'a' + 10;
162 else if (ch
== ' ' && ignore_space
)
167 error ("Invalid hex digit from remote system.");
172 /* Get a byte from eb_desc and put it in *BYT. Accept any number
180 val
= get_hex_digit (1) << 4;
181 val
|= get_hex_digit (0);
185 /* Get N 32-bit words from remote, each preceded by a space,
186 and put them in registers starting at REGNO. */
188 get_hex_regs (n
, regno
)
195 for (i
= 0; i
< n
; i
++)
200 for (j
= 0; j
< 8; j
++)
201 val
= (val
<< 4) + get_hex_digit (j
== 0);
202 supply_register (regno
++, &val
);
206 /* Called when SIGALRM signal sent due to alarm() timeout. */
210 #define volatile /**/
212 volatile int n_alarms
;
219 printf ("eb_timer called\n");
225 /* malloc'd name of the program on the remote system. */
226 static char *prog_name
= NULL
;
228 /* Nonzero if we have loaded the file ("yc") and not yet issued a "gi"
229 command. "gi" is supposed to happen exactly once for each "yc". */
230 static int need_gi
= 0;
232 /* Number of SIGTRAPs we need to simulate. That is, the next
233 NEED_ARTIFICIAL_TRAP calls to eb_wait should just return
234 SIGTRAP without actually waiting for anything. */
236 static int need_artificial_trap
= 0;
238 /* This is called not only when we first attach, but also when the
239 user types "run" after having attached. */
241 eb_start (inferior_args
)
244 /* OK, now read in the file. Y=read, C=COFF, D=no symbols
245 0=start address, %s=filename. */
247 fprintf (eb_stream
, "YC D,0:%s", prog_name
);
249 if (inferior_args
!= NULL
)
250 fprintf(eb_stream
, " %s", inferior_args
);
252 fprintf (eb_stream
, "\n");
260 /* Translate baud rates from integers to damn B_codes. Unix should
261 have outgrown this crap years ago, but even POSIX wouldn't buck it. */
270 struct {int rate
, damn_b
;} baudtab
[] = {
295 for (i
= 0; baudtab
[i
].rate
!= -1; i
++)
296 if (rate
== baudtab
[i
].rate
) return baudtab
[i
].damn_b
;
297 return B38400
; /* Random */
301 /* Open a connection to a remote debugger.
302 NAME is the filename used for communication, then a space,
303 then the name of the program as we should name it to EBMON. */
305 static int baudrate
= 9600;
306 static char *dev_name
;
308 eb_open (name
, from_tty
)
316 target_preopen (from_tty
);
318 /* Find the first whitespace character, it separates dev_name from
324 *p
!= '\0' && !isspace (*p
); p
++)
329 Please include the name of the device for the serial port,\n\
330 the baud rate, and the name of the program to run on the remote system.");
331 dev_name
= alloca (p
- name
+ 1);
332 strncpy (dev_name
, name
, p
- name
);
333 dev_name
[p
- name
] = '\0';
335 /* Skip over the whitespace after dev_name */
336 for (; isspace (*p
); p
++)
339 if (1 != sscanf (p
, "%d ", &baudrate
))
342 /* Skip the number and then the spaces */
343 for (; isdigit (*p
); p
++)
345 for (; isspace (*p
); p
++)
348 if (prog_name
!= NULL
)
350 prog_name
= savestring (p
, strlen (p
));
354 eb_desc
= open (dev_name
, O_RDWR
);
356 perror_with_name (dev_name
);
357 ioctl (eb_desc
, TIOCGETP
, &sg
);
359 sg
.c_cc
[VMIN
] = 0; /* read with timeout. */
360 sg
.c_cc
[VTIME
] = timeout
* 10;
361 sg
.c_lflag
&= ~(ICANON
| ECHO
);
362 sg
.c_cflag
= (sg
.c_cflag
& ~CBAUD
) | damn_b (baudrate
);
364 sg
.sg_ispeed
= damn_b (baudrate
);
365 sg
.sg_ospeed
= damn_b (baudrate
);
366 sg
.sg_flags
|= RAW
| ANYP
;
367 sg
.sg_flags
&= ~ECHO
;
370 ioctl (eb_desc
, TIOCSETP
, &sg
);
371 eb_stream
= fdopen (eb_desc
, "r+");
373 push_target (&eb_ops
);
375 printf ("Remote %s debugging %s using %s\n", target_shortname
,
376 prog_name
, dev_name
);
379 #ifndef NO_SIGINTERRUPT
380 /* Cause SIGALRM's to make reads fail with EINTR instead of resuming
382 if (siginterrupt (SIGALRM
, 1) != 0)
383 perror ("eb_open: error in siginterrupt");
386 /* Set up read timeout timer. */
387 if ((void (*)) signal (SIGALRM
, eb_timer
) == (void (*)) -1)
388 perror ("eb_open: error in signal");
391 #if defined (LOG_FILE)
392 log_file
= fopen (LOG_FILE
, "w");
393 if (log_file
== NULL
)
394 perror_with_name (LOG_FILE
);
397 /* Hello? Are you there? */
398 write (eb_desc
, "\n", 1);
403 /* Close out all files and local state before this target loses control. */
410 /* Due to a bug in Unix, fclose closes not only the stdio stream,
411 but also the file descriptor. So we don't actually close
414 fclose (eb_stream
); /* This also closes eb_desc */
416 /* close (eb_desc); */
418 /* Do not try to close eb_desc again, later in the program. */
422 #if defined (LOG_FILE)
423 if (ferror (log_file
))
424 printf ("Error writing log file.\n");
425 if (fclose (log_file
) != 0)
426 printf ("Error closing log file.\n");
430 /* Terminate the open connection to the remote debugger.
431 Use this when you want to detach and do something else
437 pop_target(); /* calls eb_close to do the real work */
439 printf ("Ending remote %s debugging\n", target_shortname
);
442 /* Tell the remote machine to resume. */
445 eb_resume (step
, sig
)
450 write (eb_desc
, "t 1,s\n", 6);
451 /* Wait for the echo. */
453 /* Then comes a line containing the instruction we stepped to. */
455 /* Then we get the prompt. */
458 /* Force the next eb_wait to return a trap. Not doing anything
459 about I/O from the target means that the user has to type
460 "continue" to see any. This should be fixed. */
461 need_artificial_trap
= 1;
468 write (eb_desc
, "gi\n", 3);
470 /* Swallow the echo of "gi". */
475 write (eb_desc
, "GR\n", 3);
476 /* Swallow the echo. */
482 /* Wait until the remote machine stops, then return,
483 storing status in STATUS just as `wait' would. */
489 /* Strings to look for. '?' means match any single character.
490 Note that with the algorithm we use, the initial character
491 of the string cannot recur in the string, or we will not
492 find some cases of the string in the input. */
494 static char bpt
[] = "Invalid interrupt taken - #0x50 - ";
495 /* It would be tempting to look for "\n[__exit + 0x8]\n"
496 but that requires loading symbols with "yc i" and even if
497 we did do that we don't know that the file has symbols. */
498 static char exitmsg
[] = "\n@????????I JMPTI GR121,LR0";
502 /* Large enough for either sizeof (bpt) or sizeof (exitmsg) chars. */
504 /* Current position in swallowed. */
505 char *swallowed_p
= swallowed
;
510 int old_timeout
= timeout
;
512 WSETEXIT ((*status
), 0);
514 if (need_artificial_trap
!= 0)
516 WSETSTOP ((*status
), SIGTRAP
);
517 need_artificial_trap
--;
521 timeout
= 0; /* Don't time out -- user program is running. */
538 if (ch
== *ep
|| *ep
== '?')
555 /* Print out any characters which have been swallowed. */
556 for (p
= swallowed
; p
< swallowed_p
; ++p
)
558 swallowed_p
= swallowed
;
565 WSETSTOP ((*status
), SIGTRAP
);
567 WSETEXIT ((*status
), 0);
568 timeout
= old_timeout
;
573 /* Return the name of register number REGNO
574 in the form input and output by EBMON.
576 Returns a pointer to a static buffer containing the answer. */
582 if (regno
>= GR96_REGNUM
&& regno
< GR96_REGNUM
+ 32)
583 sprintf (buf
, "GR%03d", regno
- GR96_REGNUM
+ 96);
584 else if (regno
>= LR0_REGNUM
&& regno
< LR0_REGNUM
+ 128)
585 sprintf (buf
, "LR%03d", regno
- LR0_REGNUM
);
586 else if (regno
== Q_REGNUM
)
587 strcpy (buf
, "SR131");
588 else if (regno
>= BP_REGNUM
&& regno
<= CR_REGNUM
)
589 sprintf (buf
, "SR%03d", regno
- BP_REGNUM
+ 133);
590 else if (regno
== ALU_REGNUM
)
591 strcpy (buf
, "SR132");
592 else if (regno
>= IPC_REGNUM
&& regno
<= IPB_REGNUM
)
593 sprintf (buf
, "SR%03d", regno
- IPC_REGNUM
+ 128);
594 else if (regno
>= VAB_REGNUM
&& regno
<= LRU_REGNUM
)
595 sprintf (buf
, "SR%03d", regno
- VAB_REGNUM
);
596 else if (regno
== GR1_REGNUM
)
597 strcpy (buf
, "GR001");
601 /* Read the remote registers into the block REGS. */
604 eb_fetch_registers ()
612 /* This should not be necessary, because one is supposed to read the
613 registers only when the inferior is stopped (at least with
614 ptrace() and why not make it the same for remote?). */
615 /* ^A is the "normal character" used to make sure we are talking to EBMON
616 and not to the program being debugged. */
617 write (eb_desc
, "\001\n");
621 write (eb_desc
, "dw gr96,gr127\n", 14);
622 for (reg_index
= 96, regnum_index
= GR96_REGNUM
;
624 reg_index
+= 4, regnum_index
+= 4)
626 sprintf (tempbuf
, "GR%03d ", reg_index
);
628 get_hex_regs (4, regnum_index
);
632 for (i
= 0; i
< 128; i
+= 32)
634 /* The PC has a tendency to hang if we get these
635 all in one fell swoop ("dw lr0,lr127"). */
636 sprintf (tempbuf
, "dw lr%d\n", i
);
637 write (eb_desc
, tempbuf
, strlen (tempbuf
));
638 for (reg_index
= i
, regnum_index
= LR0_REGNUM
+ i
;
640 reg_index
+= 4, regnum_index
+= 4)
642 sprintf (tempbuf
, "LR%03d ", reg_index
);
644 get_hex_regs (4, regnum_index
);
649 write (eb_desc
, "dw sr133,sr133\n", 15);
651 get_hex_regs (1, BP_REGNUM
);
654 write (eb_desc
, "dw sr134,sr134\n", 15);
656 get_hex_regs (1, FC_REGNUM
);
659 write (eb_desc
, "dw sr135,sr135\n", 15);
661 get_hex_regs (1, CR_REGNUM
);
664 write (eb_desc
, "dw sr131,sr131\n", 15);
666 get_hex_regs (1, Q_REGNUM
);
669 write (eb_desc
, "dw sr0,sr14\n", 12);
670 for (reg_index
= 0, regnum_index
= VAB_REGNUM
;
671 regnum_index
<= LRU_REGNUM
;
672 regnum_index
+= 4, reg_index
+= 4)
674 sprintf (tempbuf
, "SR%03d ", reg_index
);
676 get_hex_regs (reg_index
== 12 ? 3 : 4, regnum_index
);
680 /* There doesn't seem to be any way to get these. */
683 supply_register (FPE_REGNUM
, &val
);
684 supply_register (INT_REGNUM
, &val
);
685 supply_register (FPS_REGNUM
, &val
);
686 supply_register (EXO_REGNUM
, &val
);
689 write (eb_desc
, "dw gr1,gr1\n", 11);
691 get_hex_regs (1, GR1_REGNUM
);
695 /* Fetch register REGNO, or all registers if REGNO is -1.
696 Returns errno value. */
698 eb_fetch_register (regno
)
702 eb_fetch_registers ();
705 char *name
= get_reg_name (regno
);
706 fprintf (eb_stream
, "dw %s,%s\n", name
, name
);
709 get_hex_regs (1, regno
);
715 /* Store the remote registers from the contents of the block REGS. */
718 eb_store_registers ()
721 fprintf (eb_stream
, "s gr1,%x\n", read_register (GR1_REGNUM
));
724 for (j
= 0; j
< 32; j
+= 16)
726 fprintf (eb_stream
, "s gr%d,", j
+ 96);
727 for (i
= 0; i
< 15; ++i
)
728 fprintf (eb_stream
, "%x,", read_register (GR96_REGNUM
+ j
+ i
));
729 fprintf (eb_stream
, "%x\n", read_register (GR96_REGNUM
+ j
+ 15));
733 for (j
= 0; j
< 128; j
+= 16)
735 fprintf (eb_stream
, "s lr%d,", j
);
736 for (i
= 0; i
< 15; ++i
)
737 fprintf (eb_stream
, "%x,", read_register (LR0_REGNUM
+ j
+ i
));
738 fprintf (eb_stream
, "%x\n", read_register (LR0_REGNUM
+ j
+ 15));
742 fprintf (eb_stream
, "s sr133,%x,%x,%x\n", read_register (BP_REGNUM
),
743 read_register (FC_REGNUM
), read_register (CR_REGNUM
));
745 fprintf (eb_stream
, "s sr131,%x\n", read_register (Q_REGNUM
));
747 fprintf (eb_stream
, "s sr0,");
748 for (i
= 0; i
< 11; ++i
)
749 fprintf (eb_stream
, "%x,", read_register (VAB_REGNUM
+ i
));
750 fprintf (eb_stream
, "%x\n", read_register (VAB_REGNUM
+ 11));
754 /* Store register REGNO, or all if REGNO == 0.
755 Return errno value. */
757 eb_store_register (regno
)
761 eb_store_registers ();
764 char *name
= get_reg_name (regno
);
765 fprintf (eb_stream
, "s %s,%x\n", name
, read_register (regno
));
766 /* Setting GR1 changes the numbers of all the locals, so
767 invalidate the register cache. Do this *after* calling
768 read_register, because we want read_register to return the
769 value that write_register has just stuffed into the registers
770 array, not the value of the register fetched from the
772 if (regno
== GR1_REGNUM
)
773 registers_changed ();
779 /* Get ready to modify the registers array. On machines which store
780 individual registers, this doesn't need to do anything. On machines
781 which store all the registers in one fell swoop, this makes sure
782 that registers contains all the registers from the program being
786 eb_prepare_to_store ()
788 /* Do nothing, since we can store individual regs */
791 /* FIXME! Merge these two. */
793 eb_xfer_inferior_memory (memaddr
, myaddr
, len
, write
, target
)
798 struct target_ops
*target
; /* ignored */
801 return eb_write_inferior_memory (memaddr
, myaddr
, len
);
803 return eb_write_inferior_memory (memaddr
, myaddr
, len
);
809 printf ("\tAttached to %s at %d baud and running program %s.\n",
810 dev_name
, baudrate
, prog_name
);
813 /* Copy LEN bytes of data from debugger memory at MYADDR
814 to inferior's memory at MEMADDR. Returns errno value. */
816 eb_write_inferior_memory (memaddr
, myaddr
, len
)
823 for (i
= 0; i
< len
; i
++)
826 fprintf (eb_stream
, "sb %x,", memaddr
+ i
);
827 if ((i
% 16) == 15 || i
== len
- 1)
829 fprintf (eb_stream
, "%x\n", ((unsigned char *)myaddr
)[i
]);
833 fprintf (eb_stream
, "%x,", ((unsigned char *)myaddr
)[i
]);
838 /* Read LEN bytes from inferior memory at MEMADDR. Put the result
839 at debugger address MYADDR. Returns errno value. */
841 eb_read_inferior_memory(memaddr
, myaddr
, len
)
848 /* Number of bytes read so far. */
851 /* Starting address of this pass. */
852 unsigned long startaddr
;
854 /* Number of bytes to read in this pass. */
857 /* Note that this code works correctly if startaddr is just less
858 than UINT_MAX (well, really CORE_ADDR_MAX if there was such a
859 thing). That is, something like
860 eb_read_bytes (CORE_ADDR_MAX - 4, foo, 4)
861 works--it never adds len to memaddr and gets 0. */
862 /* However, something like
863 eb_read_bytes (CORE_ADDR_MAX - 3, foo, 4)
864 doesn't need to work. Detect it and give up if there's an attempt
866 if (((memaddr
- 1) + len
) < memaddr
)
874 if ((startaddr
% 16) != 0)
875 len_this_pass
-= startaddr
% 16;
876 if (len_this_pass
> (len
- count
))
877 len_this_pass
= (len
- count
);
879 fprintf (eb_stream
, "db %x,%x\n", startaddr
,
880 (startaddr
- 1) + len_this_pass
);
883 /* Look for 8 hex digits. */
887 if (isxdigit (readchar ()))
892 error ("Hex digit expected from remote system.");
900 for (i
= 0; i
< len_this_pass
; i
++)
901 get_hex_byte (&myaddr
[count
++]);
905 startaddr
+= len_this_pass
;
910 /* Define the target subroutine names */
912 struct target_ops eb_ops
= {
913 "amd-eb", "Remote serial AMD EBMON target",
914 "Use a remote computer running EBMON connected by a serial line.\n\
915 Arguments are the name of the device for the serial line,\n\
916 the speed to connect at in bits per second, and the filename of the\n\
917 executable as it exists on the remote computer. For example,\n\
918 target amd-eb /dev/ttya 9600 demo",
920 0, eb_detach
, eb_resume
, eb_wait
,
921 eb_fetch_register
, eb_store_register
,
922 eb_prepare_to_store
, 0, 0, /* conv_to, conv_from */
923 eb_xfer_inferior_memory
, eb_files_info
,
924 0, 0, /* Breakpoints */
925 0, 0, 0, 0, 0, /* Terminal handling */
928 call_function_by_hand
,
929 0, /* lookup_symbol */
930 0, /* create_inferior FIXME, eb_start here or something? */
931 0, /* mourn_inferior FIXME */
932 process_stratum
, 0, /* next */
933 1, 1, 1, 1, 1, /* all mem, mem, stack, regs, exec */
934 0, 0, /* Section pointers */
935 OPS_MAGIC
, /* Always the last thing */
939 _initialize_remote_eb ()
941 add_target (&eb_ops
);
This page took 0.047631 seconds and 4 git commands to generate.