7bc8842b57644906a5cc8bd75850556910ebb0ee
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. */
32 #include "param-no-tm.h"
43 extern struct value
*call_function_by_hand();
45 extern struct target_ops eb_ops
; /* Forward declaration */
47 #define LOG_FILE "eb.log"
48 #if defined (LOG_FILE)
52 static int timeout
= 5;
54 /* Descriptor for I/O to remote machine. Initialize it to -1 so that
55 eb_open knows that we don't have a file open when the program
59 /* stream which is fdopen'd from eb_desc. Only valid when
63 /* Read a character from the remote system, doing all the fancy
72 /* termio does the timeout for us. */
73 read (eb_desc
, &buf
, 1);
76 if (read (eb_desc
, &buf
, 1) < 0)
79 error ("Timeout reading from remote system.");
81 perror_with_name ("remote");
87 error ("Timeout reading from remote system.");
88 #if defined (LOG_FILE)
89 putc (buf
& 0x7f, log_file
);
94 /* Keep discarding input from the remote system, until STRING is found.
95 Let the user break out immediately. */
105 if (readchar() == *p
)
119 /* Keep discarding input until we see the ebmon prompt.
121 The convention for dealing with the prompt is that you
123 o *then* wait for the prompt.
125 Thus the last thing that a procedure does with the serial line
126 will be an expect_prompt(). Exception: eb_resume does not
127 wait for the prompt, because the terminal is being handed over
128 to the inferior. However, the next thing which happens after that
129 is a eb_wait which does wait for the prompt.
130 Note that this includes abnormal exit, e.g. error(). This is
131 necessary to prevent getting into states from which we can't
136 #if defined (LOG_FILE)
137 /* This is a convenient place to do this. The idea is to do it often
138 enough that we never lose much data if we terminate abnormally. */
144 /* Get a hex digit from the remote system & return its value.
145 If ignore_space is nonzero, ignore spaces (not newline, tab, etc). */
147 get_hex_digit (ignore_space
)
154 if (ch
>= '0' && ch
<= '9')
156 else if (ch
>= 'A' && ch
<= 'F')
157 return ch
- 'A' + 10;
158 else if (ch
>= 'a' && ch
<= 'f')
159 return ch
- 'a' + 10;
160 else if (ch
== ' ' && ignore_space
)
165 error ("Invalid hex digit from remote system.");
170 /* Get a byte from eb_desc and put it in *BYT. Accept any number
178 val
= get_hex_digit (1) << 4;
179 val
|= get_hex_digit (0);
183 /* Get N 32-bit words from remote, each preceded by a space,
184 and put them in registers starting at REGNO. */
186 get_hex_regs (n
, regno
)
193 for (i
= 0; i
< n
; i
++)
198 for (j
= 0; j
< 8; j
++)
199 val
= (val
<< 4) + get_hex_digit (j
== 0);
200 supply_register (regno
++, &val
);
204 /* Called when SIGALRM signal sent due to alarm() timeout. */
208 #define volatile /**/
210 volatile int n_alarms
;
217 printf ("eb_timer called\n");
223 /* malloc'd name of the program on the remote system. */
224 static char *prog_name
= NULL
;
226 /* Nonzero if we have loaded the file ("yc") and not yet issued a "gi"
227 command. "gi" is supposed to happen exactly once for each "yc". */
228 static int need_gi
= 0;
230 /* Number of SIGTRAPs we need to simulate. That is, the next
231 NEED_ARTIFICIAL_TRAP calls to eb_wait should just return
232 SIGTRAP without actually waiting for anything. */
234 static int need_artificial_trap
= 0;
236 /* This is called not only when we first attach, but also when the
237 user types "run" after having attached. */
239 eb_start (inferior_args
)
242 /* OK, now read in the file. Y=read, C=COFF, D=no symbols
243 0=start address, %s=filename. */
245 fprintf (eb_stream
, "YC D,0:%s", prog_name
);
247 if (inferior_args
!= NULL
)
248 fprintf(eb_stream
, " %s", inferior_args
);
250 fprintf (eb_stream
, "\n");
258 /* Translate baud rates from integers to damn B_codes. Unix should
259 have outgrown this crap years ago, but even POSIX wouldn't buck it. */
268 struct {int rate
, damn_b
;} baudtab
[] = {
293 for (i
= 0; baudtab
[i
].rate
!= -1; i
++)
294 if (rate
== baudtab
[i
].rate
) return baudtab
[i
].damn_b
;
295 return B38400
; /* Random */
299 /* Open a connection to a remote debugger.
300 NAME is the filename used for communication, then a space,
301 then the name of the program as we should name it to EBMON. */
303 static int baudrate
= 9600;
304 static char *dev_name
;
306 eb_open (name
, from_tty
)
314 target_preopen (from_tty
);
316 /* Find the first whitespace character, it separates dev_name from
322 *p
!= '\0' && !isspace (*p
); p
++)
327 Please include the name of the device for the serial port,\n\
328 the baud rate, and the name of the program to run on the remote system.");
329 dev_name
= alloca (p
- name
+ 1);
330 strncpy (dev_name
, name
, p
- name
);
331 dev_name
[p
- name
] = '\0';
333 /* Skip over the whitespace after dev_name */
334 for (; isspace (*p
); p
++)
337 if (1 != sscanf (p
, "%d ", &baudrate
))
340 /* Skip the number and then the spaces */
341 for (; isdigit (*p
); p
++)
343 for (; isspace (*p
); p
++)
346 if (prog_name
!= NULL
)
348 prog_name
= savestring (p
, strlen (p
));
352 eb_desc
= open (dev_name
, O_RDWR
);
354 perror_with_name (dev_name
);
355 ioctl (eb_desc
, TIOCGETP
, &sg
);
357 sg
.c_cc
[VMIN
] = 0; /* read with timeout. */
358 sg
.c_cc
[VTIME
] = timeout
* 10;
359 sg
.c_lflag
&= ~(ICANON
| ECHO
);
360 sg
.c_cflag
= (sg
.c_cflag
& ~CBAUD
) | damn_b (baudrate
);
362 sg
.sg_ispeed
= damn_b (baudrate
);
363 sg
.sg_ospeed
= damn_b (baudrate
);
364 sg
.sg_flags
|= RAW
| ANYP
;
365 sg
.sg_flags
&= ~ECHO
;
368 ioctl (eb_desc
, TIOCSETP
, &sg
);
369 eb_stream
= fdopen (eb_desc
, "r+");
371 push_target (&eb_ops
);
373 printf ("Remote %s debugging %s using %s\n", target_shortname
,
374 prog_name
, dev_name
);
377 #ifndef NO_SIGINTERRUPT
378 /* Cause SIGALRM's to make reads fail with EINTR instead of resuming
380 if (siginterrupt (SIGALRM
, 1) != 0)
381 perror ("eb_open: error in siginterrupt");
384 /* Set up read timeout timer. */
385 if ((void (*)) signal (SIGALRM
, eb_timer
) == (void (*)) -1)
386 perror ("eb_open: error in signal");
389 #if defined (LOG_FILE)
390 log_file
= fopen (LOG_FILE
, "w");
391 if (log_file
== NULL
)
392 perror_with_name (LOG_FILE
);
395 /* Hello? Are you there? */
396 write (eb_desc
, "\n", 1);
401 /* Close out all files and local state before this target loses control. */
408 /* Due to a bug in Unix, fclose closes not only the stdio stream,
409 but also the file descriptor. So we don't actually close
412 fclose (eb_stream
); /* This also closes eb_desc */
414 /* close (eb_desc); */
416 /* Do not try to close eb_desc again, later in the program. */
420 #if defined (LOG_FILE)
421 if (ferror (log_file
))
422 printf ("Error writing log file.\n");
423 if (fclose (log_file
) != 0)
424 printf ("Error closing log file.\n");
428 /* Terminate the open connection to the remote debugger.
429 Use this when you want to detach and do something else
435 pop_target(); /* calls eb_close to do the real work */
437 printf ("Ending remote %s debugging\n", target_shortname
);
440 /* Tell the remote machine to resume. */
443 eb_resume (step
, sig
)
448 write (eb_desc
, "t 1,s\n", 6);
449 /* Wait for the echo. */
451 /* Then comes a line containing the instruction we stepped to. */
453 /* Then we get the prompt. */
456 /* Force the next eb_wait to return a trap. Not doing anything
457 about I/O from the target means that the user has to type
458 "continue" to see any. This should be fixed. */
459 need_artificial_trap
= 1;
466 write (eb_desc
, "gi\n", 3);
468 /* Swallow the echo of "gi". */
473 write (eb_desc
, "GR\n", 3);
474 /* Swallow the echo. */
480 /* Wait until the remote machine stops, then return,
481 storing status in STATUS just as `wait' would. */
487 /* Strings to look for. '?' means match any single character.
488 Note that with the algorithm we use, the initial character
489 of the string cannot recur in the string, or we will not
490 find some cases of the string in the input. */
492 static char bpt
[] = "Invalid interrupt taken - #0x50 - ";
493 /* It would be tempting to look for "\n[__exit + 0x8]\n"
494 but that requires loading symbols with "yc i" and even if
495 we did do that we don't know that the file has symbols. */
496 static char exitmsg
[] = "\n@????????I JMPTI GR121,LR0";
500 /* Large enough for either sizeof (bpt) or sizeof (exitmsg) chars. */
502 /* Current position in swallowed. */
503 char *swallowed_p
= swallowed
;
508 int old_timeout
= timeout
;
510 WSETEXIT ((*status
), 0);
512 if (need_artificial_trap
!= 0)
514 WSETSTOP ((*status
), SIGTRAP
);
515 need_artificial_trap
--;
519 timeout
= 0; /* Don't time out -- user program is running. */
536 if (ch
== *ep
|| *ep
== '?')
553 /* Print out any characters which have been swallowed. */
554 for (p
= swallowed
; p
< swallowed_p
; ++p
)
556 swallowed_p
= swallowed
;
563 WSETSTOP ((*status
), SIGTRAP
);
565 WSETEXIT ((*status
), 0);
566 timeout
= old_timeout
;
571 /* Return the name of register number REGNO
572 in the form input and output by EBMON.
574 Returns a pointer to a static buffer containing the answer. */
580 if (regno
>= GR96_REGNUM
&& regno
< GR96_REGNUM
+ 32)
581 sprintf (buf
, "GR%03d", regno
- GR96_REGNUM
+ 96);
582 else if (regno
>= LR0_REGNUM
&& regno
< LR0_REGNUM
+ 128)
583 sprintf (buf
, "LR%03d", regno
- LR0_REGNUM
);
584 else if (regno
== Q_REGNUM
)
585 strcpy (buf
, "SR131");
586 else if (regno
>= BP_REGNUM
&& regno
<= CR_REGNUM
)
587 sprintf (buf
, "SR%03d", regno
- BP_REGNUM
+ 133);
588 else if (regno
== ALU_REGNUM
)
589 strcpy (buf
, "SR132");
590 else if (regno
>= IPC_REGNUM
&& regno
<= IPB_REGNUM
)
591 sprintf (buf
, "SR%03d", regno
- IPC_REGNUM
+ 128);
592 else if (regno
>= VAB_REGNUM
&& regno
<= LRU_REGNUM
)
593 sprintf (buf
, "SR%03d", regno
- VAB_REGNUM
);
594 else if (regno
== GR1_REGNUM
)
595 strcpy (buf
, "GR001");
599 /* Read the remote registers into the block REGS. */
602 eb_fetch_registers ()
610 /* This should not be necessary, because one is supposed to read the
611 registers only when the inferior is stopped (at least with
612 ptrace() and why not make it the same for remote?). */
613 /* ^A is the "normal character" used to make sure we are talking to EBMON
614 and not to the program being debugged. */
615 write (eb_desc
, "\001\n");
619 write (eb_desc
, "dw gr96,gr127\n", 14);
620 for (reg_index
= 96, regnum_index
= GR96_REGNUM
;
622 reg_index
+= 4, regnum_index
+= 4)
624 sprintf (tempbuf
, "GR%03d ", reg_index
);
626 get_hex_regs (4, regnum_index
);
630 for (i
= 0; i
< 128; i
+= 32)
632 /* The PC has a tendency to hang if we get these
633 all in one fell swoop ("dw lr0,lr127"). */
634 sprintf (tempbuf
, "dw lr%d\n", i
);
635 write (eb_desc
, tempbuf
, strlen (tempbuf
));
636 for (reg_index
= i
, regnum_index
= LR0_REGNUM
+ i
;
638 reg_index
+= 4, regnum_index
+= 4)
640 sprintf (tempbuf
, "LR%03d ", reg_index
);
642 get_hex_regs (4, regnum_index
);
647 write (eb_desc
, "dw sr133,sr133\n", 15);
649 get_hex_regs (1, BP_REGNUM
);
652 write (eb_desc
, "dw sr134,sr134\n", 15);
654 get_hex_regs (1, FC_REGNUM
);
657 write (eb_desc
, "dw sr135,sr135\n", 15);
659 get_hex_regs (1, CR_REGNUM
);
662 write (eb_desc
, "dw sr131,sr131\n", 15);
664 get_hex_regs (1, Q_REGNUM
);
667 write (eb_desc
, "dw sr0,sr14\n", 12);
668 for (reg_index
= 0, regnum_index
= VAB_REGNUM
;
669 regnum_index
<= LRU_REGNUM
;
670 regnum_index
+= 4, reg_index
+= 4)
672 sprintf (tempbuf
, "SR%03d ", reg_index
);
674 get_hex_regs (reg_index
== 12 ? 3 : 4, regnum_index
);
678 /* There doesn't seem to be any way to get these. */
681 supply_register (FPE_REGNUM
, &val
);
682 supply_register (INT_REGNUM
, &val
);
683 supply_register (FPS_REGNUM
, &val
);
684 supply_register (EXO_REGNUM
, &val
);
687 write (eb_desc
, "dw gr1,gr1\n", 11);
689 get_hex_regs (1, GR1_REGNUM
);
693 /* Fetch register REGNO, or all registers if REGNO is -1.
694 Returns errno value. */
696 eb_fetch_register (regno
)
700 eb_fetch_registers ();
703 char *name
= get_reg_name (regno
);
704 fprintf (eb_stream
, "dw %s,%s\n", name
, name
);
707 get_hex_regs (1, regno
);
713 /* Store the remote registers from the contents of the block REGS. */
716 eb_store_registers ()
719 fprintf (eb_stream
, "s gr1,%x\n", read_register (GR1_REGNUM
));
722 for (j
= 0; j
< 32; j
+= 16)
724 fprintf (eb_stream
, "s gr%d,", j
+ 96);
725 for (i
= 0; i
< 15; ++i
)
726 fprintf (eb_stream
, "%x,", read_register (GR96_REGNUM
+ j
+ i
));
727 fprintf (eb_stream
, "%x\n", read_register (GR96_REGNUM
+ j
+ 15));
731 for (j
= 0; j
< 128; j
+= 16)
733 fprintf (eb_stream
, "s lr%d,", j
);
734 for (i
= 0; i
< 15; ++i
)
735 fprintf (eb_stream
, "%x,", read_register (LR0_REGNUM
+ j
+ i
));
736 fprintf (eb_stream
, "%x\n", read_register (LR0_REGNUM
+ j
+ 15));
740 fprintf (eb_stream
, "s sr133,%x,%x,%x\n", read_register (BP_REGNUM
),
741 read_register (FC_REGNUM
), read_register (CR_REGNUM
));
743 fprintf (eb_stream
, "s sr131,%x\n", read_register (Q_REGNUM
));
745 fprintf (eb_stream
, "s sr0,");
746 for (i
= 0; i
< 11; ++i
)
747 fprintf (eb_stream
, "%x,", read_register (VAB_REGNUM
+ i
));
748 fprintf (eb_stream
, "%x\n", read_register (VAB_REGNUM
+ 11));
752 /* Store register REGNO, or all if REGNO == 0.
753 Return errno value. */
755 eb_store_register (regno
)
759 eb_store_registers ();
762 char *name
= get_reg_name (regno
);
763 fprintf (eb_stream
, "s %s,%x\n", name
, read_register (regno
));
764 /* Setting GR1 changes the numbers of all the locals, so
765 invalidate the register cache. Do this *after* calling
766 read_register, because we want read_register to return the
767 value that write_register has just stuffed into the registers
768 array, not the value of the register fetched from the
770 if (regno
== GR1_REGNUM
)
771 registers_changed ();
777 /* Get ready to modify the registers array. On machines which store
778 individual registers, this doesn't need to do anything. On machines
779 which store all the registers in one fell swoop, this makes sure
780 that registers contains all the registers from the program being
784 eb_prepare_to_store ()
786 /* Do nothing, since we can store individual regs */
789 /* FIXME! Merge these two. */
791 eb_xfer_inferior_memory (memaddr
, myaddr
, len
, write
, target
)
796 struct target_ops
*target
; /* ignored */
799 return eb_write_inferior_memory (memaddr
, myaddr
, len
);
801 return eb_write_inferior_memory (memaddr
, myaddr
, len
);
807 printf ("\tAttached to %s at %d baud and running program %s.\n",
808 dev_name
, baudrate
, prog_name
);
811 /* Copy LEN bytes of data from debugger memory at MYADDR
812 to inferior's memory at MEMADDR. Returns errno value. */
814 eb_write_inferior_memory (memaddr
, myaddr
, len
)
821 for (i
= 0; i
< len
; i
++)
824 fprintf (eb_stream
, "sb %x,", memaddr
+ i
);
825 if ((i
% 16) == 15 || i
== len
- 1)
827 fprintf (eb_stream
, "%x\n", ((unsigned char *)myaddr
)[i
]);
831 fprintf (eb_stream
, "%x,", ((unsigned char *)myaddr
)[i
]);
836 /* Read LEN bytes from inferior memory at MEMADDR. Put the result
837 at debugger address MYADDR. Returns errno value. */
839 eb_read_inferior_memory(memaddr
, myaddr
, len
)
846 /* Number of bytes read so far. */
849 /* Starting address of this pass. */
850 unsigned long startaddr
;
852 /* Number of bytes to read in this pass. */
855 /* Note that this code works correctly if startaddr is just less
856 than UINT_MAX (well, really CORE_ADDR_MAX if there was such a
857 thing). That is, something like
858 eb_read_bytes (CORE_ADDR_MAX - 4, foo, 4)
859 works--it never adds len to memaddr and gets 0. */
860 /* However, something like
861 eb_read_bytes (CORE_ADDR_MAX - 3, foo, 4)
862 doesn't need to work. Detect it and give up if there's an attempt
864 if (((memaddr
- 1) + len
) < memaddr
)
872 if ((startaddr
% 16) != 0)
873 len_this_pass
-= startaddr
% 16;
874 if (len_this_pass
> (len
- count
))
875 len_this_pass
= (len
- count
);
877 fprintf (eb_stream
, "db %x,%x\n", startaddr
,
878 (startaddr
- 1) + len_this_pass
);
881 /* Look for 8 hex digits. */
885 if (isxdigit (readchar ()))
890 error ("Hex digit expected from remote system.");
898 for (i
= 0; i
< len_this_pass
; i
++)
899 get_hex_byte (&myaddr
[count
++]);
903 startaddr
+= len_this_pass
;
908 /* Define the target subroutine names */
910 struct target_ops eb_ops
= {
911 "amd-eb", "Remote serial AMD EBMON target",
912 "Use a remote computer running EBMON connected by a serial line.\n\
913 Arguments are the name of the device for the serial line,\n\
914 the speed to connect at in bits per second, and the filename of the\n\
915 executable as it exists on the remote computer. For example,\n\
916 target amd-eb /dev/ttya 9600 demo",
918 0, eb_detach
, eb_resume
, eb_wait
,
919 eb_fetch_register
, eb_store_register
,
920 eb_prepare_to_store
, 0, 0, /* conv_to, conv_from */
921 eb_xfer_inferior_memory
, eb_files_info
,
922 0, 0, /* Breakpoints */
923 0, 0, 0, 0, 0, /* Terminal handling */
926 call_function_by_hand
,
927 0, /* lookup_symbol */
928 0, /* create_inferior FIXME, eb_start here or something? */
929 0, /* mourn_inferior FIXME */
930 process_stratum
, 0, /* next */
931 1, 1, 1, 1, 1, /* all mem, mem, stack, regs, exec */
932 0, 0, /* Section pointers */
933 OPS_MAGIC
, /* Always the last thing */
937 _initialize_remote_eb ()
939 add_target (&eb_ops
);
This page took 0.046097 seconds and 3 git commands to generate.