1 /* Remote debugging interface for Tandem ST2000 phone switch, for GDB.
2 Copyright 1990, 1991, 1992, 2001 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., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
22 /* This file was derived from remote-eb.c, which did a similar job, but for
23 an AMD-29K running EBMON. That file was in turn derived from remote.c
24 as mentioned in the following comment (left in for comic relief):
26 "This is like remote.c but is for an esoteric situation--
27 having an a29k board in a PC hooked up to a unix machine with
28 a serial line, and running ctty com1 on the PC, through which
29 the unix machine can run ebmon. Not to mention that the PC
30 has PC/NFS, so it can access the same executables that gdb can,
31 over the net in real time."
33 In reality, this module talks to a debug monitor called 'STDEBUG', which
34 runs in a phone switch. We communicate with STDEBUG via either a direct
35 serial line, or a TCP (or possibly TELNET) stream to a terminal multiplexor,
36 which in turn talks to the phone switch. */
41 #include "gdb_string.h"
42 #include <sys/types.h>
45 extern struct target_ops st2000_ops
; /* Forward declaration */
47 static void st2000_close ();
48 static void st2000_fetch_register ();
49 static void st2000_store_register ();
51 #define LOG_FILE "st2000.log"
52 #if defined (LOG_FILE)
56 static int timeout
= 24;
58 /* Descriptor for I/O to remote machine. Initialize it to -1 so that
59 st2000_open knows that we don't have a file open when the program
62 static serial_t st2000_desc
;
64 /* Send data to stdebug. Works just like printf. */
67 printf_stdebug (char *pattern
,...)
72 va_start (args
, pattern
);
74 vsprintf (buf
, pattern
, args
);
77 if (SERIAL_WRITE (st2000_desc
, buf
, strlen (buf
)))
78 fprintf (stderr
, "SERIAL_WRITE failed: %s\n", safe_strerror (errno
));
81 /* Read a character from the remote system, doing all the fancy timeout
85 readchar (int timeout
)
89 c
= SERIAL_READCHAR (st2000_desc
, timeout
);
92 putc (c
& 0x7f, log_file
);
98 if (c
== SERIAL_TIMEOUT
)
101 return c
; /* Polls shouldn't generate timeout errors */
103 error ("Timeout reading from remote system.");
106 perror_with_name ("remote-st2000");
109 /* Scan input from the remote system, until STRING is found. If DISCARD is
110 non-zero, then discard non-matching input, else print it out.
111 Let the user break out immediately. */
113 expect (char *string
, int discard
)
121 c
= readchar (timeout
);
134 fwrite (string
, 1, (p
- 1) - string
, stdout
);
143 /* Keep discarding input until we see the STDEBUG prompt.
145 The convention for dealing with the prompt is that you
147 o *then* wait for the prompt.
149 Thus the last thing that a procedure does with the serial line
150 will be an expect_prompt(). Exception: st2000_resume does not
151 wait for the prompt, because the terminal is being handed over
152 to the inferior. However, the next thing which happens after that
153 is a st2000_wait which does wait for the prompt.
154 Note that this includes abnormal exit, e.g. error(). This is
155 necessary to prevent getting into states from which we can't
158 expect_prompt (int discard
)
160 #if defined (LOG_FILE)
161 /* This is a convenient place to do this. The idea is to do it often
162 enough that we never lose much data if we terminate abnormally. */
165 expect ("dbug> ", discard
);
168 /* Get a hex digit from the remote system & return its value.
169 If ignore_space is nonzero, ignore spaces (not newline, tab, etc). */
171 get_hex_digit (int ignore_space
)
176 ch
= readchar (timeout
);
177 if (ch
>= '0' && ch
<= '9')
179 else if (ch
>= 'A' && ch
<= 'F')
180 return ch
- 'A' + 10;
181 else if (ch
>= 'a' && ch
<= 'f')
182 return ch
- 'a' + 10;
183 else if (ch
== ' ' && ignore_space
)
188 error ("Invalid hex digit from remote system.");
193 /* Get a byte from stdebug and put it in *BYT. Accept any number
196 get_hex_byte (char *byt
)
200 val
= get_hex_digit (1) << 4;
201 val
|= get_hex_digit (0);
205 /* Get N 32-bit words from remote, each preceded by a space,
206 and put them in registers starting at REGNO. */
208 get_hex_regs (int n
, int regno
)
213 for (i
= 0; i
< n
; i
++)
218 for (j
= 0; j
< 8; j
++)
219 val
= (val
<< 4) + get_hex_digit (j
== 0);
220 supply_register (regno
++, (char *) &val
);
224 /* This is called not only when we first attach, but also when the
225 user types "run" after having attached. */
227 st2000_create_inferior (char *execfile
, char *args
, char **env
)
232 error ("Can't pass arguments to remote STDEBUG process");
234 if (execfile
== 0 || exec_bfd
== 0)
235 error ("No executable file specified");
237 entry_pt
= (int) bfd_get_start_address (exec_bfd
);
239 /* The "process" (board) is already stopped awaiting our commands, and
240 the program is already downloaded. We just set its PC and go. */
242 clear_proceed_status ();
244 /* Tell wait_for_inferior that we've started a new process. */
245 init_wait_for_inferior ();
247 /* Set up the "saved terminal modes" of the inferior
248 based on what modes we are starting it with. */
249 target_terminal_init ();
251 /* Install inferior's terminal modes. */
252 target_terminal_inferior ();
254 /* insert_step_breakpoint (); FIXME, do we need this? */
256 proceed ((CORE_ADDR
) entry_pt
, TARGET_SIGNAL_DEFAULT
, 0);
259 /* Open a connection to a remote debugger.
260 NAME is the filename used for communication. */
262 static int baudrate
= 9600;
263 static char dev_name
[100];
266 st2000_open (char *args
, int from_tty
)
271 target_preopen (from_tty
);
273 n
= sscanf (args
, " %s %d %s", dev_name
, &baudrate
, junk
);
276 error ("Bad arguments. Usage: target st2000 <device> <speed>\n\
277 or target st2000 <host> <port>\n");
281 st2000_desc
= SERIAL_OPEN (dev_name
);
284 perror_with_name (dev_name
);
286 SERIAL_SETBAUDRATE (st2000_desc
, baudrate
);
288 SERIAL_RAW (st2000_desc
);
290 push_target (&st2000_ops
);
292 #if defined (LOG_FILE)
293 log_file
= fopen (LOG_FILE
, "w");
294 if (log_file
== NULL
)
295 perror_with_name (LOG_FILE
);
298 /* Hello? Are you there? */
299 printf_stdebug ("\003"); /* ^C wakes up dbug */
304 printf ("Remote %s connected to %s\n", target_shortname
,
308 /* Close out all files and local state before this target loses control. */
311 st2000_close (int quitting
)
313 SERIAL_CLOSE (st2000_desc
);
315 #if defined (LOG_FILE)
318 if (ferror (log_file
))
319 fprintf (stderr
, "Error writing log file.\n");
320 if (fclose (log_file
) != 0)
321 fprintf (stderr
, "Error closing log file.\n");
326 /* Terminate the open connection to the remote debugger.
327 Use this when you want to detach and do something else
330 st2000_detach (int from_tty
)
332 pop_target (); /* calls st2000_close to do the real work */
334 printf ("Ending remote %s debugging\n", target_shortname
);
337 /* Tell the remote machine to resume. */
340 st2000_resume (int pid
, int step
, enum target_signal sig
)
344 printf_stdebug ("ST\r");
345 /* Wait for the echo. */
350 printf_stdebug ("GO\r");
351 /* Swallow the echo. */
356 /* Wait until the remote machine stops, then return,
357 storing status in STATUS just as `wait' would. */
360 st2000_wait (struct target_waitstatus
*status
)
362 int old_timeout
= timeout
;
364 status
->kind
= TARGET_WAITKIND_EXITED
;
365 status
->value
.integer
= 0;
367 timeout
= 0; /* Don't time out -- user program is running. */
369 expect_prompt (0); /* Wait for prompt, outputting extraneous text */
371 status
->kind
= TARGET_WAITKIND_STOPPED
;
372 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
374 timeout
= old_timeout
;
379 /* Return the name of register number REGNO in the form input and output by
380 STDEBUG. Currently, REGISTER_NAMES just happens to contain exactly what
381 STDEBUG wants. Lets take advantage of that just as long as possible! */
384 get_reg_name (int regno
)
392 for (p
= REGISTER_NAME (regno
); *p
; p
++)
399 /* Read the remote registers into the block REGS. */
402 st2000_fetch_registers (void)
406 /* Yeah yeah, I know this is horribly inefficient. But it isn't done
407 very often... I'll clean it up later. */
409 for (regno
= 0; regno
<= PC_REGNUM
; regno
++)
410 st2000_fetch_register (regno
);
413 /* Fetch register REGNO, or all registers if REGNO is -1.
414 Returns errno value. */
416 st2000_fetch_register (int regno
)
419 st2000_fetch_registers ();
422 char *name
= get_reg_name (regno
);
423 printf_stdebug ("DR %s\r", name
);
426 get_hex_regs (1, regno
);
432 /* Store the remote registers from the contents of the block REGS. */
435 st2000_store_registers (void)
439 for (regno
= 0; regno
<= PC_REGNUM
; regno
++)
440 st2000_store_register (regno
);
442 registers_changed ();
445 /* Store register REGNO, or all if REGNO == 0.
446 Return errno value. */
448 st2000_store_register (int regno
)
451 st2000_store_registers ();
454 printf_stdebug ("PR %s %x\r", get_reg_name (regno
),
455 read_register (regno
));
461 /* Get ready to modify the registers array. On machines which store
462 individual registers, this doesn't need to do anything. On machines
463 which store all the registers in one fell swoop, this makes sure
464 that registers contains all the registers from the program being
468 st2000_prepare_to_store (void)
470 /* Do nothing, since we can store individual regs */
474 st2000_files_info (void)
476 printf ("\tAttached to %s at %d baud.\n",
480 /* Copy LEN bytes of data from debugger memory at MYADDR
481 to inferior's memory at MEMADDR. Returns length moved. */
483 st2000_write_inferior_memory (CORE_ADDR memaddr
, unsigned char *myaddr
, int len
)
487 for (i
= 0; i
< len
; i
++)
489 printf_stdebug ("PM.B %x %x\r", memaddr
+ i
, myaddr
[i
]);
495 /* Read LEN bytes from inferior memory at MEMADDR. Put the result
496 at debugger address MYADDR. Returns length moved. */
498 st2000_read_inferior_memory (CORE_ADDR memaddr
, char *myaddr
, int len
)
502 /* Number of bytes read so far. */
505 /* Starting address of this pass. */
506 unsigned long startaddr
;
508 /* Number of bytes to read in this pass. */
511 /* Note that this code works correctly if startaddr is just less
512 than UINT_MAX (well, really CORE_ADDR_MAX if there was such a
513 thing). That is, something like
514 st2000_read_bytes (CORE_ADDR_MAX - 4, foo, 4)
515 works--it never adds len to memaddr and gets 0. */
516 /* However, something like
517 st2000_read_bytes (CORE_ADDR_MAX - 3, foo, 4)
518 doesn't need to work. Detect it and give up if there's an attempt
520 if (((memaddr
- 1) + len
) < memaddr
)
531 if ((startaddr
% 16) != 0)
532 len_this_pass
-= startaddr
% 16;
533 if (len_this_pass
> (len
- count
))
534 len_this_pass
= (len
- count
);
536 printf_stdebug ("DI.L %x %x\r", startaddr
, len_this_pass
);
539 for (i
= 0; i
< len_this_pass
; i
++)
540 get_hex_byte (&myaddr
[count
++]);
544 startaddr
+= len_this_pass
;
549 /* Transfer LEN bytes between GDB address MYADDR and target address
550 MEMADDR. If WRITE is non-zero, transfer them to the target,
551 otherwise transfer them from the target. TARGET is unused.
553 Returns the number of bytes transferred. */
556 st2000_xfer_inferior_memory (CORE_ADDR memaddr
, char *myaddr
, int len
,
558 struct mem_attrib
*attrib ATTRIBUTE_UNUSED
,
559 struct target_ops
*target ATTRIBUTE_UNUSED
)
562 return st2000_write_inferior_memory (memaddr
, myaddr
, len
);
564 return st2000_read_inferior_memory (memaddr
, myaddr
, len
);
568 st2000_kill (char *args
, int from_tty
)
570 return; /* Ignore attempts to kill target system */
573 /* Clean up when a program exits.
575 The program actually lives on in the remote processor's RAM, and may be
576 run again without a download. Don't leave it full of breakpoint
580 st2000_mourn_inferior (void)
582 remove_breakpoints ();
583 unpush_target (&st2000_ops
);
584 generic_mourn_inferior (); /* Do all the proper things now */
587 #define MAX_STDEBUG_BREAKPOINTS 16
589 static CORE_ADDR breakaddr
[MAX_STDEBUG_BREAKPOINTS
] =
593 st2000_insert_breakpoint (CORE_ADDR addr
, char *shadow
)
596 CORE_ADDR bp_addr
= addr
;
599 BREAKPOINT_FROM_PC (&bp_addr
, &bp_size
);
601 for (i
= 0; i
<= MAX_STDEBUG_BREAKPOINTS
; i
++)
602 if (breakaddr
[i
] == 0)
606 st2000_read_inferior_memory (bp_addr
, shadow
, bp_size
);
607 printf_stdebug ("BR %x H\r", addr
);
612 fprintf (stderr
, "Too many breakpoints (> 16) for STDBUG\n");
617 st2000_remove_breakpoint (CORE_ADDR addr
, char *shadow
)
621 for (i
= 0; i
< MAX_STDEBUG_BREAKPOINTS
; i
++)
622 if (breakaddr
[i
] == addr
)
626 printf_stdebug ("CB %d\r", i
);
631 fprintf (stderr
, "Can't find breakpoint associated with 0x%x\n", addr
);
636 /* Put a command string, in args, out to STDBUG. Output from STDBUG is placed
637 on the users terminal until the prompt is seen. */
640 st2000_command (char *args
, int fromtty
)
643 error ("st2000 target not open.");
646 error ("Missing command.");
648 printf_stdebug ("%s\r", args
);
652 /* Connect the user directly to STDBUG. This command acts just like the
653 'cu' or 'tip' command. Use <CR>~. or <CR>~^D to break out. */
655 /*static struct ttystate ttystate; */
660 printf ("\r\n[Exiting connect mode]\r\n");
661 /* SERIAL_RESTORE(0, &ttystate); */
665 /* This all should now be in serial.c */
668 connect_command (char *args
, int fromtty
)
678 error ("st2000 target not open.");
681 fprintf ("This command takes no args. They have been ignored.\n");
683 printf ("[Entering connect mode. Use ~. or ~^D to escape]\n");
685 serial_raw (0, &ttystate
);
687 make_cleanup (cleanup_tty
, 0);
695 FD_SET (0, &readfds
);
696 FD_SET (DEPRECATED_SERIAL_FD (st2000_desc
), &readfds
);
697 numfds
= select (sizeof (readfds
) * 8, &readfds
, 0, 0, 0);
702 perror_with_name ("select");
704 if (FD_ISSET (0, &readfds
))
705 { /* tty input, send to stdebug */
708 perror_with_name ("connect");
710 printf_stdebug ("%c", c
);
724 if (c
== '.' || c
== '\004')
731 if (FD_ISSET (DEPRECATED_SERIAL_FD (st2000_desc
), &readfds
))
746 /* Define the target subroutine names */
748 struct target_ops st2000_ops
;
751 init_st2000_ops (void)
753 st2000_ops
.to_shortname
= "st2000";
754 st2000_ops
.to_longname
= "Remote serial Tandem ST2000 target";
755 st2000_ops
.to_doc
= "Use a remote computer running STDEBUG connected by a serial line;\n\
756 or a network connection.\n\
757 Arguments are the name of the device for the serial line,\n\
758 the speed to connect at in bits per second.";
759 st2000_ops
.to_open
= st2000_open
;
760 st2000_ops
.to_close
= st2000_close
;
761 st2000_ops
.to_attach
= 0;
762 st2000_run_ops
.to_post_attach
= NULL
;
763 st2000_ops
.to_require_attach
= NULL
;
764 st2000_ops
.to_detach
= st2000_detach
;
765 st2000_ops
.to_require_detach
= NULL
;
766 st2000_ops
.to_resume
= st2000_resume
;
767 st2000_ops
.to_wait
= st2000_wait
;
768 st2000_ops
.to_post_wait
= NULL
;
769 st2000_ops
.to_fetch_registers
= st2000_fetch_register
;
770 st2000_ops
.to_store_registers
= st2000_store_register
;
771 st2000_ops
.to_prepare_to_store
= st2000_prepare_to_store
;
772 st2000_ops
.to_xfer_memory
= st2000_xfer_inferior_memory
;
773 st2000_ops
.to_files_info
= st2000_files_info
;
774 st2000_ops
.to_insert_breakpoint
= st2000_insert_breakpoint
;
775 st2000_ops
.to_remove_breakpoint
= st2000_remove_breakpoint
; /* Breakpoints */
776 st2000_ops
.to_terminal_init
= 0;
777 st2000_ops
.to_terminal_inferior
= 0;
778 st2000_ops
.to_terminal_ours_for_output
= 0;
779 st2000_ops
.to_terminal_ours
= 0;
780 st2000_ops
.to_terminal_info
= 0; /* Terminal handling */
781 st2000_ops
.to_kill
= st2000_kill
;
782 st2000_ops
.to_load
= 0; /* load */
783 st2000_ops
.to_lookup_symbol
= 0; /* lookup_symbol */
784 st2000_ops
.to_create_inferior
= st2000_create_inferior
;
785 st2000_ops
.to_post_startup_inferior
= NULL
;
786 st2000_ops
.to_acknowledge_created_inferior
= NULL
;
787 st2000_ops
.to_clone_and_follow_inferior
= NULL
;
788 st2000_ops
.to_post_follow_inferior_by_clone
= NULL
;
789 st2000_run_ops
.to_insert_fork_catchpoint
= NULL
;
790 st2000_run_ops
.to_remove_fork_catchpoint
= NULL
;
791 st2000_run_ops
.to_insert_vfork_catchpoint
= NULL
;
792 st2000_run_ops
.to_remove_vfork_catchpoint
= NULL
;
793 st2000_ops
.to_has_forked
= NULL
;
794 st2000_ops
.to_has_vforked
= NULL
;
795 st2000_run_ops
.to_can_follow_vfork_prior_to_exec
= NULL
;
796 st2000_ops
.to_post_follow_vfork
= NULL
;
797 st2000_run_ops
.to_insert_exec_catchpoint
= NULL
;
798 st2000_run_ops
.to_remove_exec_catchpoint
= NULL
;
799 st2000_run_ops
.to_has_execd
= NULL
;
800 st2000_run_ops
.to_reported_exec_events_per_exec_call
= NULL
;
801 st2000_run_ops
.to_has_exited
= NULL
;
802 st2000_ops
.to_mourn_inferior
= st2000_mourn_inferior
;
803 st2000_ops
.to_can_run
= 0; /* can_run */
804 st2000_ops
.to_notice_signals
= 0; /* notice_signals */
805 st2000_ops
.to_thread_alive
= 0; /* thread alive */
806 st2000_ops
.to_stop
= 0; /* to_stop */
807 st2000_ops
.to_pid_to_exec_file
= NULL
;
808 st2000_run_ops
.to_core_file_to_sym_file
= NULL
;
809 st2000_ops
.to_stratum
= process_stratum
;
810 st2000_ops
.DONT_USE
= 0; /* next */
811 st2000_ops
.to_has_all_memory
= 1;
812 st2000_ops
.to_has_memory
= 1;
813 st2000_ops
.to_has_stack
= 1;
814 st2000_ops
.to_has_registers
= 1;
815 st2000_ops
.to_has_execution
= 1; /* all mem, mem, stack, regs, exec */
816 st2000_ops
.to_sections
= 0;
817 st2000_ops
.to_sections_end
= 0; /* Section pointers */
818 st2000_ops
.to_magic
= OPS_MAGIC
; /* Always the last thing */
822 _initialize_remote_st2000 (void)
825 add_target (&st2000_ops
);
826 add_com ("st2000 <command>", class_obscure
, st2000_command
,
827 "Send a command to the STDBUG monitor.");
828 add_com ("connect", class_obscure
, connect_command
,
829 "Connect the terminal directly up to the STDBUG command monitor.\n\
830 Use <CR>~. or <CR>~^D to break out.");