1 /* Remote debugging interface for Tandem ST2000 phone switch, for GDB.
2 Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1998, 1999, 2000, 2001
3 Free Software Foundation, Inc.
4 Contributed by Cygnus Support. Written by Jim Kingdon for Cygnus.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
23 /* This file was derived from remote-eb.c, which did a similar job, but for
24 an AMD-29K running EBMON. That file was in turn derived from remote.c
25 as mentioned in the following comment (left in for comic relief):
27 "This is like remote.c but is for an esoteric situation--
28 having an a29k board in a PC hooked up to a unix machine with
29 a serial line, and running ctty com1 on the PC, through which
30 the unix machine can run ebmon. Not to mention that the PC
31 has PC/NFS, so it can access the same executables that gdb can,
32 over the net in real time."
34 In reality, this module talks to a debug monitor called 'STDEBUG', which
35 runs in a phone switch. We communicate with STDEBUG via either a direct
36 serial line, or a TCP (or possibly TELNET) stream to a terminal multiplexor,
37 which in turn talks to the phone switch. */
42 #include "gdb_string.h"
43 #include <sys/types.h>
47 extern struct target_ops st2000_ops; /* Forward declaration */
49 static void st2000_close ();
50 static void st2000_fetch_register ();
51 static void st2000_store_register ();
53 #define LOG_FILE "st2000.log"
54 #if defined (LOG_FILE)
58 static int timeout = 24;
60 /* Descriptor for I/O to remote machine. Initialize it to -1 so that
61 st2000_open knows that we don't have a file open when the program
64 static struct serial *st2000_desc;
66 /* Send data to stdebug. Works just like printf. */
69 printf_stdebug (char *pattern,...)
74 va_start (args, pattern);
76 vsprintf (buf, pattern, args);
79 if (SERIAL_WRITE (st2000_desc, buf, strlen (buf)))
80 fprintf (stderr, "SERIAL_WRITE failed: %s\n", safe_strerror (errno));
83 /* Read a character from the remote system, doing all the fancy timeout
87 readchar (int timeout)
91 c = SERIAL_READCHAR (st2000_desc, timeout);
94 putc (c & 0x7f, log_file);
100 if (c == SERIAL_TIMEOUT)
103 return c; /* Polls shouldn't generate timeout errors */
105 error ("Timeout reading from remote system.");
108 perror_with_name ("remote-st2000");
111 /* Scan input from the remote system, until STRING is found. If DISCARD is
112 non-zero, then discard non-matching input, else print it out.
113 Let the user break out immediately. */
115 expect (char *string, int discard)
123 c = readchar (timeout);
136 fwrite (string, 1, (p - 1) - string, stdout);
145 /* Keep discarding input until we see the STDEBUG prompt.
147 The convention for dealing with the prompt is that you
149 o *then* wait for the prompt.
151 Thus the last thing that a procedure does with the serial line
152 will be an expect_prompt(). Exception: st2000_resume does not
153 wait for the prompt, because the terminal is being handed over
154 to the inferior. However, the next thing which happens after that
155 is a st2000_wait which does wait for the prompt.
156 Note that this includes abnormal exit, e.g. error(). This is
157 necessary to prevent getting into states from which we can't
160 expect_prompt (int discard)
162 #if defined (LOG_FILE)
163 /* This is a convenient place to do this. The idea is to do it often
164 enough that we never lose much data if we terminate abnormally. */
167 expect ("dbug> ", discard);
170 /* Get a hex digit from the remote system & return its value.
171 If ignore_space is nonzero, ignore spaces (not newline, tab, etc). */
173 get_hex_digit (int ignore_space)
178 ch = readchar (timeout);
179 if (ch >= '0' && ch <= '9')
181 else if (ch >= 'A' && ch <= 'F')
182 return ch - 'A' + 10;
183 else if (ch >= 'a' && ch <= 'f')
184 return ch - 'a' + 10;
185 else if (ch == ' ' && ignore_space)
190 error ("Invalid hex digit from remote system.");
195 /* Get a byte from stdebug and put it in *BYT. Accept any number
198 get_hex_byte (char *byt)
202 val = get_hex_digit (1) << 4;
203 val |= get_hex_digit (0);
207 /* Get N 32-bit words from remote, each preceded by a space,
208 and put them in registers starting at REGNO. */
210 get_hex_regs (int n, int regno)
215 for (i = 0; i < n; i++)
220 for (j = 0; j < 8; j++)
221 val = (val << 4) + get_hex_digit (j == 0);
222 supply_register (regno++, (char *) &val);
226 /* This is called not only when we first attach, but also when the
227 user types "run" after having attached. */
229 st2000_create_inferior (char *execfile, char *args, char **env)
234 error ("Can't pass arguments to remote STDEBUG process");
236 if (execfile == 0 || exec_bfd == 0)
237 error ("No executable file specified");
239 entry_pt = (int) bfd_get_start_address (exec_bfd);
241 /* The "process" (board) is already stopped awaiting our commands, and
242 the program is already downloaded. We just set its PC and go. */
244 clear_proceed_status ();
246 /* Tell wait_for_inferior that we've started a new process. */
247 init_wait_for_inferior ();
249 /* Set up the "saved terminal modes" of the inferior
250 based on what modes we are starting it with. */
251 target_terminal_init ();
253 /* Install inferior's terminal modes. */
254 target_terminal_inferior ();
256 /* insert_step_breakpoint (); FIXME, do we need this? */
258 proceed ((CORE_ADDR) entry_pt, TARGET_SIGNAL_DEFAULT, 0);
261 /* Open a connection to a remote debugger.
262 NAME is the filename used for communication. */
264 static int baudrate = 9600;
265 static char dev_name[100];
268 st2000_open (char *args, int from_tty)
273 target_preopen (from_tty);
275 n = sscanf (args, " %s %d %s", dev_name, &baudrate, junk);
278 error ("Bad arguments. Usage: target st2000 <device> <speed>\n\
279 or target st2000 <host> <port>\n");
283 st2000_desc = SERIAL_OPEN (dev_name);
286 perror_with_name (dev_name);
288 if (SERIAL_SETBAUDRATE (st2000_desc, baudrate))
290 SERIAL_CLOSE (dev_name);
291 perror_with_name (dev_name);
294 SERIAL_RAW (st2000_desc);
296 push_target (&st2000_ops);
298 #if defined (LOG_FILE)
299 log_file = fopen (LOG_FILE, "w");
300 if (log_file == NULL)
301 perror_with_name (LOG_FILE);
304 /* Hello? Are you there? */
305 printf_stdebug ("\003"); /* ^C wakes up dbug */
310 printf ("Remote %s connected to %s\n", target_shortname,
314 /* Close out all files and local state before this target loses control. */
317 st2000_close (int quitting)
319 SERIAL_CLOSE (st2000_desc);
321 #if defined (LOG_FILE)
324 if (ferror (log_file))
325 fprintf (stderr, "Error writing log file.\n");
326 if (fclose (log_file) != 0)
327 fprintf (stderr, "Error closing log file.\n");
332 /* Terminate the open connection to the remote debugger.
333 Use this when you want to detach and do something else
336 st2000_detach (int from_tty)
338 pop_target (); /* calls st2000_close to do the real work */
340 printf ("Ending remote %s debugging\n", target_shortname);
343 /* Tell the remote machine to resume. */
346 st2000_resume (ptid_t ptid, int step, enum target_signal sig)
350 printf_stdebug ("ST\r");
351 /* Wait for the echo. */
356 printf_stdebug ("GO\r");
357 /* Swallow the echo. */
362 /* Wait until the remote machine stops, then return,
363 storing status in STATUS just as `wait' would. */
366 st2000_wait (ptid_t ptid, struct target_waitstatus *status)
368 int old_timeout = timeout;
370 status->kind = TARGET_WAITKIND_EXITED;
371 status->value.integer = 0;
373 timeout = 0; /* Don't time out -- user program is running. */
375 expect_prompt (0); /* Wait for prompt, outputting extraneous text */
377 status->kind = TARGET_WAITKIND_STOPPED;
378 status->value.sig = TARGET_SIGNAL_TRAP;
380 timeout = old_timeout;
382 return inferior_ptid;
385 /* Return the name of register number REGNO in the form input and output by
386 STDEBUG. Currently, REGISTER_NAMES just happens to contain exactly what
387 STDEBUG wants. Lets take advantage of that just as long as possible! */
390 get_reg_name (int regno)
398 for (p = REGISTER_NAME (regno); *p; p++)
405 /* Read the remote registers into the block REGS. */
408 st2000_fetch_registers (void)
412 /* Yeah yeah, I know this is horribly inefficient. But it isn't done
413 very often... I'll clean it up later. */
415 for (regno = 0; regno <= PC_REGNUM; regno++)
416 st2000_fetch_register (regno);
419 /* Fetch register REGNO, or all registers if REGNO is -1.
420 Returns errno value. */
422 st2000_fetch_register (int regno)
425 st2000_fetch_registers ();
428 char *name = get_reg_name (regno);
429 printf_stdebug ("DR %s\r", name);
432 get_hex_regs (1, regno);
438 /* Store the remote registers from the contents of the block REGS. */
441 st2000_store_registers (void)
445 for (regno = 0; regno <= PC_REGNUM; regno++)
446 st2000_store_register (regno);
448 registers_changed ();
451 /* Store register REGNO, or all if REGNO == 0.
452 Return errno value. */
454 st2000_store_register (int regno)
457 st2000_store_registers ();
460 printf_stdebug ("PR %s %x\r", get_reg_name (regno),
461 read_register (regno));
467 /* Get ready to modify the registers array. On machines which store
468 individual registers, this doesn't need to do anything. On machines
469 which store all the registers in one fell swoop, this makes sure
470 that registers contains all the registers from the program being
474 st2000_prepare_to_store (void)
476 /* Do nothing, since we can store individual regs */
480 st2000_files_info (void)
482 printf ("\tAttached to %s at %d baud.\n",
486 /* Copy LEN bytes of data from debugger memory at MYADDR
487 to inferior's memory at MEMADDR. Returns length moved. */
489 st2000_write_inferior_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len)
493 for (i = 0; i < len; i++)
495 printf_stdebug ("PM.B %x %x\r", memaddr + i, myaddr[i]);
501 /* Read LEN bytes from inferior memory at MEMADDR. Put the result
502 at debugger address MYADDR. Returns length moved. */
504 st2000_read_inferior_memory (CORE_ADDR memaddr, char *myaddr, int len)
508 /* Number of bytes read so far. */
511 /* Starting address of this pass. */
512 unsigned long startaddr;
514 /* Number of bytes to read in this pass. */
517 /* Note that this code works correctly if startaddr is just less
518 than UINT_MAX (well, really CORE_ADDR_MAX if there was such a
519 thing). That is, something like
520 st2000_read_bytes (CORE_ADDR_MAX - 4, foo, 4)
521 works--it never adds len to memaddr and gets 0. */
522 /* However, something like
523 st2000_read_bytes (CORE_ADDR_MAX - 3, foo, 4)
524 doesn't need to work. Detect it and give up if there's an attempt
526 if (((memaddr - 1) + len) < memaddr)
537 if ((startaddr % 16) != 0)
538 len_this_pass -= startaddr % 16;
539 if (len_this_pass > (len - count))
540 len_this_pass = (len - count);
542 printf_stdebug ("DI.L %x %x\r", startaddr, len_this_pass);
545 for (i = 0; i < len_this_pass; i++)
546 get_hex_byte (&myaddr[count++]);
550 startaddr += len_this_pass;
555 /* Transfer LEN bytes between GDB address MYADDR and target address
556 MEMADDR. If WRITE is non-zero, transfer them to the target,
557 otherwise transfer them from the target. TARGET is unused.
559 Returns the number of bytes transferred. */
562 st2000_xfer_inferior_memory (CORE_ADDR memaddr, char *myaddr, int len,
564 struct mem_attrib *attrib ATTRIBUTE_UNUSED,
565 struct target_ops *target ATTRIBUTE_UNUSED)
568 return st2000_write_inferior_memory (memaddr, myaddr, len);
570 return st2000_read_inferior_memory (memaddr, myaddr, len);
574 st2000_kill (char *args, int from_tty)
576 return; /* Ignore attempts to kill target system */
579 /* Clean up when a program exits.
581 The program actually lives on in the remote processor's RAM, and may be
582 run again without a download. Don't leave it full of breakpoint
586 st2000_mourn_inferior (void)
588 remove_breakpoints ();
589 unpush_target (&st2000_ops);
590 generic_mourn_inferior (); /* Do all the proper things now */
593 #define MAX_STDEBUG_BREAKPOINTS 16
595 static CORE_ADDR breakaddr[MAX_STDEBUG_BREAKPOINTS] =
599 st2000_insert_breakpoint (CORE_ADDR addr, char *shadow)
602 CORE_ADDR bp_addr = addr;
605 BREAKPOINT_FROM_PC (&bp_addr, &bp_size);
607 for (i = 0; i <= MAX_STDEBUG_BREAKPOINTS; i++)
608 if (breakaddr[i] == 0)
612 st2000_read_inferior_memory (bp_addr, shadow, bp_size);
613 printf_stdebug ("BR %x H\r", addr);
618 fprintf (stderr, "Too many breakpoints (> 16) for STDBUG\n");
623 st2000_remove_breakpoint (CORE_ADDR addr, char *shadow)
627 for (i = 0; i < MAX_STDEBUG_BREAKPOINTS; i++)
628 if (breakaddr[i] == addr)
632 printf_stdebug ("CB %d\r", i);
637 fprintf (stderr, "Can't find breakpoint associated with 0x%x\n", addr);
642 /* Put a command string, in args, out to STDBUG. Output from STDBUG is placed
643 on the users terminal until the prompt is seen. */
646 st2000_command (char *args, int fromtty)
649 error ("st2000 target not open.");
652 error ("Missing command.");
654 printf_stdebug ("%s\r", args);
658 /* Connect the user directly to STDBUG. This command acts just like the
659 'cu' or 'tip' command. Use <CR>~. or <CR>~^D to break out. */
661 /*static struct ttystate ttystate; */
666 printf ("\r\n[Exiting connect mode]\r\n");
667 /* SERIAL_RESTORE(0, &ttystate); */
671 /* This all should now be in serial.c */
674 connect_command (char *args, int fromtty)
684 error ("st2000 target not open.");
687 fprintf ("This command takes no args. They have been ignored.\n");
689 printf ("[Entering connect mode. Use ~. or ~^D to escape]\n");
691 serial_raw (0, &ttystate);
693 make_cleanup (cleanup_tty, 0);
701 FD_SET (0, &readfds);
702 FD_SET (DEPRECATED_SERIAL_FD (st2000_desc), &readfds);
703 numfds = select (sizeof (readfds) * 8, &readfds, 0, 0, 0);
708 perror_with_name ("select");
710 if (FD_ISSET (0, &readfds))
711 { /* tty input, send to stdebug */
714 perror_with_name ("connect");
716 printf_stdebug ("%c", c);
730 if (c == '.' || c == '\004')
737 if (FD_ISSET (DEPRECATED_SERIAL_FD (st2000_desc), &readfds))
752 /* Define the target subroutine names */
754 struct target_ops st2000_ops;
757 init_st2000_ops (void)
759 st2000_ops.to_shortname = "st2000";
760 st2000_ops.to_longname = "Remote serial Tandem ST2000 target";
761 st2000_ops.to_doc = "Use a remote computer running STDEBUG connected by a serial line;\n\
762 or a network connection.\n\
763 Arguments are the name of the device for the serial line,\n\
764 the speed to connect at in bits per second.";
765 st2000_ops.to_open = st2000_open;
766 st2000_ops.to_close = st2000_close;
767 st2000_ops.to_attach = 0;
768 st2000_run_ops.to_post_attach = NULL;
769 st2000_ops.to_require_attach = NULL;
770 st2000_ops.to_detach = st2000_detach;
771 st2000_ops.to_require_detach = NULL;
772 st2000_ops.to_resume = st2000_resume;
773 st2000_ops.to_wait = st2000_wait;
774 st2000_ops.to_post_wait = NULL;
775 st2000_ops.to_fetch_registers = st2000_fetch_register;
776 st2000_ops.to_store_registers = st2000_store_register;
777 st2000_ops.to_prepare_to_store = st2000_prepare_to_store;
778 st2000_ops.to_xfer_memory = st2000_xfer_inferior_memory;
779 st2000_ops.to_files_info = st2000_files_info;
780 st2000_ops.to_insert_breakpoint = st2000_insert_breakpoint;
781 st2000_ops.to_remove_breakpoint = st2000_remove_breakpoint; /* Breakpoints */
782 st2000_ops.to_terminal_init = 0;
783 st2000_ops.to_terminal_inferior = 0;
784 st2000_ops.to_terminal_ours_for_output = 0;
785 st2000_ops.to_terminal_ours = 0;
786 st2000_ops.to_terminal_info = 0; /* Terminal handling */
787 st2000_ops.to_kill = st2000_kill;
788 st2000_ops.to_load = 0; /* load */
789 st2000_ops.to_lookup_symbol = 0; /* lookup_symbol */
790 st2000_ops.to_create_inferior = st2000_create_inferior;
791 st2000_ops.to_post_startup_inferior = NULL;
792 st2000_ops.to_acknowledge_created_inferior = NULL;
793 st2000_ops.to_clone_and_follow_inferior = NULL;
794 st2000_ops.to_post_follow_inferior_by_clone = NULL;
795 st2000_run_ops.to_insert_fork_catchpoint = NULL;
796 st2000_run_ops.to_remove_fork_catchpoint = NULL;
797 st2000_run_ops.to_insert_vfork_catchpoint = NULL;
798 st2000_run_ops.to_remove_vfork_catchpoint = NULL;
799 st2000_ops.to_has_forked = NULL;
800 st2000_ops.to_has_vforked = NULL;
801 st2000_run_ops.to_can_follow_vfork_prior_to_exec = NULL;
802 st2000_ops.to_post_follow_vfork = NULL;
803 st2000_run_ops.to_insert_exec_catchpoint = NULL;
804 st2000_run_ops.to_remove_exec_catchpoint = NULL;
805 st2000_run_ops.to_has_execd = NULL;
806 st2000_run_ops.to_reported_exec_events_per_exec_call = NULL;
807 st2000_run_ops.to_has_exited = NULL;
808 st2000_ops.to_mourn_inferior = st2000_mourn_inferior;
809 st2000_ops.to_can_run = 0; /* can_run */
810 st2000_ops.to_notice_signals = 0; /* notice_signals */
811 st2000_ops.to_thread_alive = 0; /* thread alive */
812 st2000_ops.to_stop = 0; /* to_stop */
813 st2000_ops.to_pid_to_exec_file = NULL;
814 st2000_ops.to_stratum = process_stratum;
815 st2000_ops.DONT_USE = 0; /* next */
816 st2000_ops.to_has_all_memory = 1;
817 st2000_ops.to_has_memory = 1;
818 st2000_ops.to_has_stack = 1;
819 st2000_ops.to_has_registers = 1;
820 st2000_ops.to_has_execution = 1; /* all mem, mem, stack, regs, exec */
821 st2000_ops.to_sections = 0;
822 st2000_ops.to_sections_end = 0; /* Section pointers */
823 st2000_ops.to_magic = OPS_MAGIC; /* Always the last thing */
827 _initialize_remote_st2000 (void)
830 add_target (&st2000_ops);
831 add_com ("st2000 <command>", class_obscure, st2000_command,
832 "Send a command to the STDBUG monitor.");
833 add_com ("connect", class_obscure, connect_command,
834 "Connect the terminal directly up to the STDBUG command monitor.\n\
835 Use <CR>~. or <CR>~^D to break out.");