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>
46 extern struct target_ops st2000_ops; /* Forward declaration */
48 static void st2000_close ();
49 static void st2000_fetch_register ();
50 static void st2000_store_register ();
52 #define LOG_FILE "st2000.log"
53 #if defined (LOG_FILE)
57 static int timeout = 24;
59 /* Descriptor for I/O to remote machine. Initialize it to -1 so that
60 st2000_open knows that we don't have a file open when the program
63 static serial_t st2000_desc;
65 /* Send data to stdebug. Works just like printf. */
68 printf_stdebug (char *pattern,...)
73 va_start (args, pattern);
75 vsprintf (buf, pattern, args);
78 if (SERIAL_WRITE (st2000_desc, buf, strlen (buf)))
79 fprintf (stderr, "SERIAL_WRITE failed: %s\n", safe_strerror (errno));
82 /* Read a character from the remote system, doing all the fancy timeout
86 readchar (int timeout)
90 c = SERIAL_READCHAR (st2000_desc, timeout);
93 putc (c & 0x7f, log_file);
99 if (c == SERIAL_TIMEOUT)
102 return c; /* Polls shouldn't generate timeout errors */
104 error ("Timeout reading from remote system.");
107 perror_with_name ("remote-st2000");
110 /* Scan input from the remote system, until STRING is found. If DISCARD is
111 non-zero, then discard non-matching input, else print it out.
112 Let the user break out immediately. */
114 expect (char *string, int discard)
122 c = readchar (timeout);
135 fwrite (string, 1, (p - 1) - string, stdout);
144 /* Keep discarding input until we see the STDEBUG prompt.
146 The convention for dealing with the prompt is that you
148 o *then* wait for the prompt.
150 Thus the last thing that a procedure does with the serial line
151 will be an expect_prompt(). Exception: st2000_resume does not
152 wait for the prompt, because the terminal is being handed over
153 to the inferior. However, the next thing which happens after that
154 is a st2000_wait which does wait for the prompt.
155 Note that this includes abnormal exit, e.g. error(). This is
156 necessary to prevent getting into states from which we can't
159 expect_prompt (int discard)
161 #if defined (LOG_FILE)
162 /* This is a convenient place to do this. The idea is to do it often
163 enough that we never lose much data if we terminate abnormally. */
166 expect ("dbug> ", discard);
169 /* Get a hex digit from the remote system & return its value.
170 If ignore_space is nonzero, ignore spaces (not newline, tab, etc). */
172 get_hex_digit (int ignore_space)
177 ch = readchar (timeout);
178 if (ch >= '0' && ch <= '9')
180 else if (ch >= 'A' && ch <= 'F')
181 return ch - 'A' + 10;
182 else if (ch >= 'a' && ch <= 'f')
183 return ch - 'a' + 10;
184 else if (ch == ' ' && ignore_space)
189 error ("Invalid hex digit from remote system.");
194 /* Get a byte from stdebug and put it in *BYT. Accept any number
197 get_hex_byte (char *byt)
201 val = get_hex_digit (1) << 4;
202 val |= get_hex_digit (0);
206 /* Get N 32-bit words from remote, each preceded by a space,
207 and put them in registers starting at REGNO. */
209 get_hex_regs (int n, int regno)
214 for (i = 0; i < n; i++)
219 for (j = 0; j < 8; j++)
220 val = (val << 4) + get_hex_digit (j == 0);
221 supply_register (regno++, (char *) &val);
225 /* This is called not only when we first attach, but also when the
226 user types "run" after having attached. */
228 st2000_create_inferior (char *execfile, char *args, char **env)
233 error ("Can't pass arguments to remote STDEBUG process");
235 if (execfile == 0 || exec_bfd == 0)
236 error ("No executable file specified");
238 entry_pt = (int) bfd_get_start_address (exec_bfd);
240 /* The "process" (board) is already stopped awaiting our commands, and
241 the program is already downloaded. We just set its PC and go. */
243 clear_proceed_status ();
245 /* Tell wait_for_inferior that we've started a new process. */
246 init_wait_for_inferior ();
248 /* Set up the "saved terminal modes" of the inferior
249 based on what modes we are starting it with. */
250 target_terminal_init ();
252 /* Install inferior's terminal modes. */
253 target_terminal_inferior ();
255 /* insert_step_breakpoint (); FIXME, do we need this? */
257 proceed ((CORE_ADDR) entry_pt, TARGET_SIGNAL_DEFAULT, 0);
260 /* Open a connection to a remote debugger.
261 NAME is the filename used for communication. */
263 static int baudrate = 9600;
264 static char dev_name[100];
267 st2000_open (char *args, int from_tty)
272 target_preopen (from_tty);
274 n = sscanf (args, " %s %d %s", dev_name, &baudrate, junk);
277 error ("Bad arguments. Usage: target st2000 <device> <speed>\n\
278 or target st2000 <host> <port>\n");
282 st2000_desc = SERIAL_OPEN (dev_name);
285 perror_with_name (dev_name);
287 SERIAL_SETBAUDRATE (st2000_desc, baudrate);
289 SERIAL_RAW (st2000_desc);
291 push_target (&st2000_ops);
293 #if defined (LOG_FILE)
294 log_file = fopen (LOG_FILE, "w");
295 if (log_file == NULL)
296 perror_with_name (LOG_FILE);
299 /* Hello? Are you there? */
300 printf_stdebug ("\003"); /* ^C wakes up dbug */
305 printf ("Remote %s connected to %s\n", target_shortname,
309 /* Close out all files and local state before this target loses control. */
312 st2000_close (int quitting)
314 SERIAL_CLOSE (st2000_desc);
316 #if defined (LOG_FILE)
319 if (ferror (log_file))
320 fprintf (stderr, "Error writing log file.\n");
321 if (fclose (log_file) != 0)
322 fprintf (stderr, "Error closing log file.\n");
327 /* Terminate the open connection to the remote debugger.
328 Use this when you want to detach and do something else
331 st2000_detach (int from_tty)
333 pop_target (); /* calls st2000_close to do the real work */
335 printf ("Ending remote %s debugging\n", target_shortname);
338 /* Tell the remote machine to resume. */
341 st2000_resume (int pid, int step, enum target_signal sig)
345 printf_stdebug ("ST\r");
346 /* Wait for the echo. */
351 printf_stdebug ("GO\r");
352 /* Swallow the echo. */
357 /* Wait until the remote machine stops, then return,
358 storing status in STATUS just as `wait' would. */
361 st2000_wait (struct target_waitstatus *status)
363 int old_timeout = timeout;
365 status->kind = TARGET_WAITKIND_EXITED;
366 status->value.integer = 0;
368 timeout = 0; /* Don't time out -- user program is running. */
370 expect_prompt (0); /* Wait for prompt, outputting extraneous text */
372 status->kind = TARGET_WAITKIND_STOPPED;
373 status->value.sig = TARGET_SIGNAL_TRAP;
375 timeout = old_timeout;
380 /* Return the name of register number REGNO in the form input and output by
381 STDEBUG. Currently, REGISTER_NAMES just happens to contain exactly what
382 STDEBUG wants. Lets take advantage of that just as long as possible! */
385 get_reg_name (int regno)
393 for (p = REGISTER_NAME (regno); *p; p++)
400 /* Read the remote registers into the block REGS. */
403 st2000_fetch_registers (void)
407 /* Yeah yeah, I know this is horribly inefficient. But it isn't done
408 very often... I'll clean it up later. */
410 for (regno = 0; regno <= PC_REGNUM; regno++)
411 st2000_fetch_register (regno);
414 /* Fetch register REGNO, or all registers if REGNO is -1.
415 Returns errno value. */
417 st2000_fetch_register (int regno)
420 st2000_fetch_registers ();
423 char *name = get_reg_name (regno);
424 printf_stdebug ("DR %s\r", name);
427 get_hex_regs (1, regno);
433 /* Store the remote registers from the contents of the block REGS. */
436 st2000_store_registers (void)
440 for (regno = 0; regno <= PC_REGNUM; regno++)
441 st2000_store_register (regno);
443 registers_changed ();
446 /* Store register REGNO, or all if REGNO == 0.
447 Return errno value. */
449 st2000_store_register (int regno)
452 st2000_store_registers ();
455 printf_stdebug ("PR %s %x\r", get_reg_name (regno),
456 read_register (regno));
462 /* Get ready to modify the registers array. On machines which store
463 individual registers, this doesn't need to do anything. On machines
464 which store all the registers in one fell swoop, this makes sure
465 that registers contains all the registers from the program being
469 st2000_prepare_to_store (void)
471 /* Do nothing, since we can store individual regs */
475 st2000_files_info (void)
477 printf ("\tAttached to %s at %d baud.\n",
481 /* Copy LEN bytes of data from debugger memory at MYADDR
482 to inferior's memory at MEMADDR. Returns length moved. */
484 st2000_write_inferior_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
488 for (i = 0; i < len; i++)
490 printf_stdebug ("PM.B %x %x\r", memaddr + i, myaddr[i]);
496 /* Read LEN bytes from inferior memory at MEMADDR. Put the result
497 at debugger address MYADDR. Returns length moved. */
499 st2000_read_inferior_memory (CORE_ADDR memaddr, char *myaddr, int len)
503 /* Number of bytes read so far. */
506 /* Starting address of this pass. */
507 unsigned long startaddr;
509 /* Number of bytes to read in this pass. */
512 /* Note that this code works correctly if startaddr is just less
513 than UINT_MAX (well, really CORE_ADDR_MAX if there was such a
514 thing). That is, something like
515 st2000_read_bytes (CORE_ADDR_MAX - 4, foo, 4)
516 works--it never adds len to memaddr and gets 0. */
517 /* However, something like
518 st2000_read_bytes (CORE_ADDR_MAX - 3, foo, 4)
519 doesn't need to work. Detect it and give up if there's an attempt
521 if (((memaddr - 1) + len) < memaddr)
532 if ((startaddr % 16) != 0)
533 len_this_pass -= startaddr % 16;
534 if (len_this_pass > (len - count))
535 len_this_pass = (len - count);
537 printf_stdebug ("DI.L %x %x\r", startaddr, len_this_pass);
540 for (i = 0; i < len_this_pass; i++)
541 get_hex_byte (&myaddr[count++]);
545 startaddr += len_this_pass;
550 /* Transfer LEN bytes between GDB address MYADDR and target address
551 MEMADDR. If WRITE is non-zero, transfer them to the target,
552 otherwise transfer them from the target. TARGET is unused.
554 Returns the number of bytes transferred. */
557 st2000_xfer_inferior_memory (CORE_ADDR memaddr, char *myaddr, int len,
559 struct mem_attrib *attrib ATTRIBUTE_UNUSED,
560 struct target_ops *target ATTRIBUTE_UNUSED)
563 return st2000_write_inferior_memory (memaddr, myaddr, len);
565 return st2000_read_inferior_memory (memaddr, myaddr, len);
569 st2000_kill (char *args, int from_tty)
571 return; /* Ignore attempts to kill target system */
574 /* Clean up when a program exits.
576 The program actually lives on in the remote processor's RAM, and may be
577 run again without a download. Don't leave it full of breakpoint
581 st2000_mourn_inferior (void)
583 remove_breakpoints ();
584 unpush_target (&st2000_ops);
585 generic_mourn_inferior (); /* Do all the proper things now */
588 #define MAX_STDEBUG_BREAKPOINTS 16
590 static CORE_ADDR breakaddr[MAX_STDEBUG_BREAKPOINTS] =
594 st2000_insert_breakpoint (CORE_ADDR addr, char *shadow)
597 CORE_ADDR bp_addr = addr;
600 BREAKPOINT_FROM_PC (&bp_addr, &bp_size);
602 for (i = 0; i <= MAX_STDEBUG_BREAKPOINTS; i++)
603 if (breakaddr[i] == 0)
607 st2000_read_inferior_memory (bp_addr, shadow, bp_size);
608 printf_stdebug ("BR %x H\r", addr);
613 fprintf (stderr, "Too many breakpoints (> 16) for STDBUG\n");
618 st2000_remove_breakpoint (CORE_ADDR addr, char *shadow)
622 for (i = 0; i < MAX_STDEBUG_BREAKPOINTS; i++)
623 if (breakaddr[i] == addr)
627 printf_stdebug ("CB %d\r", i);
632 fprintf (stderr, "Can't find breakpoint associated with 0x%x\n", addr);
637 /* Put a command string, in args, out to STDBUG. Output from STDBUG is placed
638 on the users terminal until the prompt is seen. */
641 st2000_command (char *args, int fromtty)
644 error ("st2000 target not open.");
647 error ("Missing command.");
649 printf_stdebug ("%s\r", args);
653 /* Connect the user directly to STDBUG. This command acts just like the
654 'cu' or 'tip' command. Use <CR>~. or <CR>~^D to break out. */
656 /*static struct ttystate ttystate; */
661 printf ("\r\n[Exiting connect mode]\r\n");
662 /* SERIAL_RESTORE(0, &ttystate); */
666 /* This all should now be in serial.c */
669 connect_command (char *args, int fromtty)
679 error ("st2000 target not open.");
682 fprintf ("This command takes no args. They have been ignored.\n");
684 printf ("[Entering connect mode. Use ~. or ~^D to escape]\n");
686 serial_raw (0, &ttystate);
688 make_cleanup (cleanup_tty, 0);
696 FD_SET (0, &readfds);
697 FD_SET (DEPRECATED_SERIAL_FD (st2000_desc), &readfds);
698 numfds = select (sizeof (readfds) * 8, &readfds, 0, 0, 0);
703 perror_with_name ("select");
705 if (FD_ISSET (0, &readfds))
706 { /* tty input, send to stdebug */
709 perror_with_name ("connect");
711 printf_stdebug ("%c", c);
725 if (c == '.' || c == '\004')
732 if (FD_ISSET (DEPRECATED_SERIAL_FD (st2000_desc), &readfds))
747 /* Define the target subroutine names */
749 struct target_ops st2000_ops;
752 init_st2000_ops (void)
754 st2000_ops.to_shortname = "st2000";
755 st2000_ops.to_longname = "Remote serial Tandem ST2000 target";
756 st2000_ops.to_doc = "Use a remote computer running STDEBUG connected by a serial line;\n\
757 or a network connection.\n\
758 Arguments are the name of the device for the serial line,\n\
759 the speed to connect at in bits per second.";
760 st2000_ops.to_open = st2000_open;
761 st2000_ops.to_close = st2000_close;
762 st2000_ops.to_attach = 0;
763 st2000_run_ops.to_post_attach = NULL;
764 st2000_ops.to_require_attach = NULL;
765 st2000_ops.to_detach = st2000_detach;
766 st2000_ops.to_require_detach = NULL;
767 st2000_ops.to_resume = st2000_resume;
768 st2000_ops.to_wait = st2000_wait;
769 st2000_ops.to_post_wait = NULL;
770 st2000_ops.to_fetch_registers = st2000_fetch_register;
771 st2000_ops.to_store_registers = st2000_store_register;
772 st2000_ops.to_prepare_to_store = st2000_prepare_to_store;
773 st2000_ops.to_xfer_memory = st2000_xfer_inferior_memory;
774 st2000_ops.to_files_info = st2000_files_info;
775 st2000_ops.to_insert_breakpoint = st2000_insert_breakpoint;
776 st2000_ops.to_remove_breakpoint = st2000_remove_breakpoint; /* Breakpoints */
777 st2000_ops.to_terminal_init = 0;
778 st2000_ops.to_terminal_inferior = 0;
779 st2000_ops.to_terminal_ours_for_output = 0;
780 st2000_ops.to_terminal_ours = 0;
781 st2000_ops.to_terminal_info = 0; /* Terminal handling */
782 st2000_ops.to_kill = st2000_kill;
783 st2000_ops.to_load = 0; /* load */
784 st2000_ops.to_lookup_symbol = 0; /* lookup_symbol */
785 st2000_ops.to_create_inferior = st2000_create_inferior;
786 st2000_ops.to_post_startup_inferior = NULL;
787 st2000_ops.to_acknowledge_created_inferior = NULL;
788 st2000_ops.to_clone_and_follow_inferior = NULL;
789 st2000_ops.to_post_follow_inferior_by_clone = NULL;
790 st2000_run_ops.to_insert_fork_catchpoint = NULL;
791 st2000_run_ops.to_remove_fork_catchpoint = NULL;
792 st2000_run_ops.to_insert_vfork_catchpoint = NULL;
793 st2000_run_ops.to_remove_vfork_catchpoint = NULL;
794 st2000_ops.to_has_forked = NULL;
795 st2000_ops.to_has_vforked = NULL;
796 st2000_run_ops.to_can_follow_vfork_prior_to_exec = NULL;
797 st2000_ops.to_post_follow_vfork = NULL;
798 st2000_run_ops.to_insert_exec_catchpoint = NULL;
799 st2000_run_ops.to_remove_exec_catchpoint = NULL;
800 st2000_run_ops.to_has_execd = NULL;
801 st2000_run_ops.to_reported_exec_events_per_exec_call = NULL;
802 st2000_run_ops.to_has_exited = NULL;
803 st2000_ops.to_mourn_inferior = st2000_mourn_inferior;
804 st2000_ops.to_can_run = 0; /* can_run */
805 st2000_ops.to_notice_signals = 0; /* notice_signals */
806 st2000_ops.to_thread_alive = 0; /* thread alive */
807 st2000_ops.to_stop = 0; /* to_stop */
808 st2000_ops.to_pid_to_exec_file = NULL;
809 st2000_run_ops.to_core_file_to_sym_file = NULL;
810 st2000_ops.to_stratum = process_stratum;
811 st2000_ops.DONT_USE = 0; /* next */
812 st2000_ops.to_has_all_memory = 1;
813 st2000_ops.to_has_memory = 1;
814 st2000_ops.to_has_stack = 1;
815 st2000_ops.to_has_registers = 1;
816 st2000_ops.to_has_execution = 1; /* all mem, mem, stack, regs, exec */
817 st2000_ops.to_sections = 0;
818 st2000_ops.to_sections_end = 0; /* Section pointers */
819 st2000_ops.to_magic = OPS_MAGIC; /* Always the last thing */
823 _initialize_remote_st2000 (void)
826 add_target (&st2000_ops);
827 add_com ("st2000 <command>", class_obscure, st2000_command,
828 "Send a command to the STDBUG monitor.");
829 add_com ("connect", class_obscure, connect_command,
830 "Connect the terminal directly up to the STDBUG command monitor.\n\
831 Use <CR>~. or <CR>~^D to break out.");