1 /* Remote debugging interface for Tandem ST2000 phone switch, for GDB.
2 Copyright 1990, 1991, 1992 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 file was derived from remote-eb.c, which did a similar job, but for
22 an AMD-29K running EBMON. That file was in turn derived from remote.c
23 as mentioned in the following comment (left in for comic relief):
25 "This is like remote.c but is for an esoteric situation--
26 having a 29k board in a PC hooked up to a unix machine with
27 a serial line, and running ctty com1 on the PC, through which
28 the unix machine can run ebmon. Not to mention that the PC
29 has PC/NFS, so it can access the same executables that gdb can,
30 over the net in real time."
32 In reality, this module talks to a debug monitor called 'STDEBUG', which
33 runs in a phone switch. We communicate with STDEBUG via either a direct
34 serial line, or a TCP (or possibly TELNET) stream to a terminal multiplexor,
35 which in turn talks to the phone switch. */
44 #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
65 /* Send data to stdebug. Works just like printf. */
68 printf_stdebug(va_alist
)
77 pattern
= va_arg(args
, char *);
79 vsprintf(buf
, pattern
, args
);
80 if (!serial_write(buf
, strlen(buf
)))
81 fprintf(stderr
, "serial_write failed: %s\n", safe_strerror(errno
));
84 /* Read a character from the remote system, doing all the fancy
92 c
= serial_readchar(timeout
);
95 putc(c
& 0x7f, log_file
);
104 return c
; /* Polls shouldn't generate timeout errors */
106 error("Timeout reading from remote system.");
109 perror_with_name("remote-st2000");
112 /* Scan input from the remote system, until STRING is found. If DISCARD is
113 non-zero, then discard non-matching input, else print it out.
114 Let the user break out immediately. */
116 expect(string
, discard
)
126 c
= readchar(timeout
);
139 fwrite(string
, 1, (p
- 1) - string
, stdout
);
148 /* Keep discarding input until we see the STDEBUG prompt.
150 The convention for dealing with the prompt is that you
152 o *then* wait for the prompt.
154 Thus the last thing that a procedure does with the serial line
155 will be an expect_prompt(). Exception: st2000_resume does not
156 wait for the prompt, because the terminal is being handed over
157 to the inferior. However, the next thing which happens after that
158 is a st2000_wait which does wait for the prompt.
159 Note that this includes abnormal exit, e.g. error(). This is
160 necessary to prevent getting into states from which we can't
163 expect_prompt(discard
)
166 #if defined (LOG_FILE)
167 /* This is a convenient place to do this. The idea is to do it often
168 enough that we never lose much data if we terminate abnormally. */
171 expect ("dbug> ", discard
);
174 /* Get a hex digit from the remote system & return its value.
175 If ignore_space is nonzero, ignore spaces (not newline, tab, etc). */
177 get_hex_digit(ignore_space
)
183 ch
= readchar(timeout
);
184 if (ch
>= '0' && ch
<= '9')
186 else if (ch
>= 'A' && ch
<= 'F')
187 return ch
- 'A' + 10;
188 else if (ch
>= 'a' && ch
<= 'f')
189 return ch
- 'a' + 10;
190 else if (ch
== ' ' && ignore_space
)
195 error("Invalid hex digit from remote system.");
200 /* Get a byte from stdebug and put it in *BYT. Accept any number
208 val
= get_hex_digit (1) << 4;
209 val
|= get_hex_digit (0);
213 /* Get N 32-bit words from remote, each preceded by a space,
214 and put them in registers starting at REGNO. */
216 get_hex_regs (n
, regno
)
223 for (i
= 0; i
< n
; i
++)
228 for (j
= 0; j
< 8; j
++)
229 val
= (val
<< 4) + get_hex_digit (j
== 0);
230 supply_register (regno
++, (char *) &val
);
234 /* This is called not only when we first attach, but also when the
235 user types "run" after having attached. */
237 st2000_create_inferior (execfile
, args
, env
)
245 error("Can't pass arguments to remote STDEBUG process");
247 if (execfile
== 0 || exec_bfd
== 0)
248 error("No exec file specified");
250 entry_pt
= (int) bfd_get_start_address (exec_bfd
);
252 #ifdef CREATE_INFERIOR_HOOK
253 CREATE_INFERIOR_HOOK (0); /* No process-ID */
256 /* The "process" (board) is already stopped awaiting our commands, and
257 the program is already downloaded. We just set its PC and go. */
259 clear_proceed_status ();
261 /* Tell wait_for_inferior that we've started a new process. */
262 init_wait_for_inferior ();
264 /* Set up the "saved terminal modes" of the inferior
265 based on what modes we are starting it with. */
266 target_terminal_init ();
268 /* Install inferior's terminal modes. */
269 target_terminal_inferior ();
271 /* insert_step_breakpoint (); FIXME, do we need this? */
272 proceed ((CORE_ADDR
)entry_pt
, -1, 0); /* Let 'er rip... */
275 /* Open a connection to a remote debugger.
276 NAME is the filename used for communication. */
278 static int baudrate
= 9600;
279 static char dev_name
[100];
282 st2000_open(args
, from_tty
)
289 target_preopen(from_tty
);
291 n
= sscanf(args
, " %s %d %s", dev_name
, &baudrate
, junk
);
294 error("Bad arguments. Usage: target st2000 <device> <speed>\n\
295 or target st2000 <host> <port>\n");
299 st2000_desc
= serial_open(dev_name
);
301 serial_setbaudrate(baudrate
);
303 push_target(&st2000_ops
);
305 #if defined (LOG_FILE)
306 log_file
= fopen (LOG_FILE
, "w");
307 if (log_file
== NULL
)
308 perror_with_name (LOG_FILE
);
311 /* Hello? Are you there? */
312 printf_stdebug("\003"); /* ^C wakes up dbug */
317 printf("Remote %s connected to %s\n", target_shortname
,
321 /* Close out all files and local state before this target loses control. */
324 st2000_close (quitting
)
329 #if defined (LOG_FILE)
331 if (ferror(log_file
))
332 fprintf(stderr
, "Error writing log file.\n");
333 if (fclose(log_file
) != 0)
334 fprintf(stderr
, "Error closing log file.\n");
339 /* Terminate the open connection to the remote debugger.
340 Use this when you want to detach and do something else
343 st2000_detach (from_tty
)
346 pop_target(); /* calls st2000_close to do the real work */
348 printf ("Ending remote %s debugging\n", target_shortname
);
351 /* Tell the remote machine to resume. */
354 st2000_resume (step
, sig
)
359 printf_stdebug ("ST\r");
360 /* Wait for the echo. */
365 printf_stdebug ("GO\r");
366 /* Swallow the echo. */
371 /* Wait until the remote machine stops, then return,
372 storing status in STATUS just as `wait' would. */
378 int old_timeout
= timeout
;
380 WSETEXIT ((*status
), 0);
382 timeout
= 0; /* Don't time out -- user program is running. */
384 expect_prompt(0); /* Wait for prompt, outputting extraneous text */
386 WSETSTOP ((*status
), SIGTRAP
);
388 timeout
= old_timeout
;
393 /* Return the name of register number REGNO in the form input and output by
394 STDEBUG. Currently, REGISTER_NAMES just happens to contain exactly what
395 STDEBUG wants. Lets take advantage of that just as long as possible! */
407 for (p
= reg_names
[regno
]; *p
; p
++)
414 /* Read the remote registers into the block REGS. */
417 st2000_fetch_registers ()
421 /* Yeah yeah, I know this is horribly inefficient. But it isn't done
422 very often... I'll clean it up later. */
424 for (regno
= 0; regno
<= PC_REGNUM
; regno
++)
425 st2000_fetch_register(regno
);
428 /* Fetch register REGNO, or all registers if REGNO is -1.
429 Returns errno value. */
431 st2000_fetch_register (regno
)
435 st2000_fetch_registers ();
438 char *name
= get_reg_name (regno
);
439 printf_stdebug ("DR %s\r", name
);
442 get_hex_regs (1, regno
);
448 /* Store the remote registers from the contents of the block REGS. */
451 st2000_store_registers ()
455 for (regno
= 0; regno
<= PC_REGNUM
; regno
++)
456 st2000_store_register(regno
);
458 registers_changed ();
461 /* Store register REGNO, or all if REGNO == 0.
462 Return errno value. */
464 st2000_store_register (regno
)
468 st2000_store_registers ();
471 printf_stdebug ("PR %s %x\r", get_reg_name (regno
),
472 read_register (regno
));
478 /* Get ready to modify the registers array. On machines which store
479 individual registers, this doesn't need to do anything. On machines
480 which store all the registers in one fell swoop, this makes sure
481 that registers contains all the registers from the program being
485 st2000_prepare_to_store ()
487 /* Do nothing, since we can store individual regs */
493 printf ("\tAttached to %s at %d baud.\n",
497 /* Copy LEN bytes of data from debugger memory at MYADDR
498 to inferior's memory at MEMADDR. Returns length moved. */
500 st2000_write_inferior_memory (memaddr
, myaddr
, len
)
502 unsigned char *myaddr
;
507 for (i
= 0; i
< len
; i
++)
509 printf_stdebug ("PM.B %x %x\r", memaddr
+ i
, myaddr
[i
]);
515 /* Read LEN bytes from inferior memory at MEMADDR. Put the result
516 at debugger address MYADDR. Returns length moved. */
518 st2000_read_inferior_memory(memaddr
, myaddr
, len
)
525 /* Number of bytes read so far. */
528 /* Starting address of this pass. */
529 unsigned long startaddr
;
531 /* Number of bytes to read in this pass. */
534 /* Note that this code works correctly if startaddr is just less
535 than UINT_MAX (well, really CORE_ADDR_MAX if there was such a
536 thing). That is, something like
537 st2000_read_bytes (CORE_ADDR_MAX - 4, foo, 4)
538 works--it never adds len to memaddr and gets 0. */
539 /* However, something like
540 st2000_read_bytes (CORE_ADDR_MAX - 3, foo, 4)
541 doesn't need to work. Detect it and give up if there's an attempt
543 if (((memaddr
- 1) + len
) < memaddr
) {
553 if ((startaddr
% 16) != 0)
554 len_this_pass
-= startaddr
% 16;
555 if (len_this_pass
> (len
- count
))
556 len_this_pass
= (len
- count
);
558 printf_stdebug ("DI.L %x %x\r", startaddr
, len_this_pass
);
561 for (i
= 0; i
< len_this_pass
; i
++)
562 get_hex_byte (&myaddr
[count
++]);
566 startaddr
+= len_this_pass
;
571 /* FIXME-someday! Merge these two. */
573 st2000_xfer_inferior_memory (memaddr
, myaddr
, len
, write
, target
)
578 struct target_ops
*target
; /* ignored */
581 return st2000_write_inferior_memory (memaddr
, myaddr
, len
);
583 return st2000_read_inferior_memory (memaddr
, myaddr
, len
);
587 st2000_kill (args
, from_tty
)
591 return; /* Ignore attempts to kill target system */
594 /* Clean up when a program exits.
596 The program actually lives on in the remote processor's RAM, and may be
597 run again without a download. Don't leave it full of breakpoint
601 st2000_mourn_inferior ()
603 remove_breakpoints ();
604 generic_mourn_inferior (); /* Do all the proper things now */
607 #define MAX_STDEBUG_BREAKPOINTS 16
609 extern int memory_breakpoint_size
;
610 static CORE_ADDR breakaddr
[MAX_STDEBUG_BREAKPOINTS
] = {0};
613 st2000_insert_breakpoint (addr
, shadow
)
619 for (i
= 0; i
<= MAX_STDEBUG_BREAKPOINTS
; i
++)
620 if (breakaddr
[i
] == 0)
624 st2000_read_inferior_memory(addr
, shadow
, memory_breakpoint_size
);
625 printf_stdebug("BR %x H\r", addr
);
630 fprintf(stderr
, "Too many breakpoints (> 16) for STDBUG\n");
635 st2000_remove_breakpoint (addr
, shadow
)
641 for (i
= 0; i
< MAX_STDEBUG_BREAKPOINTS
; i
++)
642 if (breakaddr
[i
] == addr
)
646 printf_stdebug("CB %d\r", i
);
651 fprintf(stderr
, "Can't find breakpoint associated with 0x%x\n", addr
);
656 /* Put a command string, in args, out to STDBUG. Output from STDBUG is placed
657 on the users terminal until the prompt is seen. */
660 st2000_command (args
, fromtty
)
665 error("st2000 target not open.");
668 error("Missing command.");
670 printf_stdebug("%s\r", args
);
674 /* Connect the user directly to STDBUG. This command acts just like the
675 'cu' or 'tip' command. Use <CR>~. or <CR>~^D to break out. */
677 static struct ttystate ttystate
;
682 printf("\r\n[Exiting connect mode]\r\n");
683 serial_restore(0, &ttystate
);
687 connect_command (args
, fromtty
)
699 error("st2000 target not open.");
702 fprintf("This command takes no args. They have been ignored.\n");
704 printf("[Entering connect mode. Use ~. or ~^D to escape]\n");
706 serial_raw(0, &ttystate
);
708 make_cleanup(cleanup_tty
, 0);
717 FD_SET(st2000_desc
, &readfds
);
718 numfds
= select(sizeof(readfds
)*8, &readfds
, 0, 0, 0);
723 perror_with_name("select");
725 if (FD_ISSET(0, &readfds
))
726 { /* tty input, send to stdebug */
729 perror_with_name("connect");
731 printf_stdebug("%c", c
);
745 if (c
== '.' || c
== '\004')
752 if (FD_ISSET(st2000_desc
, &readfds
))
766 /* Define the target subroutine names */
768 struct target_ops st2000_ops
= {
770 "Remote serial Tandem ST2000 target",
771 "Use a remote computer running STDEBUG connected by a serial line,\n\
772 or a network connection.\n\
773 Arguments are the name of the device for the serial line,\n\
774 the speed to connect at in bits per second.",
781 st2000_fetch_register
,
782 st2000_store_register
,
783 st2000_prepare_to_store
,
784 st2000_xfer_inferior_memory
,
786 st2000_insert_breakpoint
,
787 st2000_remove_breakpoint
, /* Breakpoints */
792 0, /* Terminal handling */
795 0, /* lookup_symbol */
796 st2000_create_inferior
,
797 st2000_mourn_inferior
,
804 1, /* all mem, mem, stack, regs, exec */
806 0, /* Section pointers */
807 OPS_MAGIC
, /* Always the last thing */
811 _initialize_remote_st2000 ()
813 add_target (&st2000_ops
);
814 add_com ("st2000 <command>", class_obscure
, st2000_command
,
815 "Send a command to the STDBUG monitor.");
816 add_com ("connect", class_obscure
, connect_command
,
817 "Connect the terminal directly up to the STDBUG command monitor.\n\
818 Use <CR>~. or <CR>~^D to break out.");