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 an a29k 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
64 static serial_t st2000_desc
;
66 /* Send data to stdebug. Works just like printf. */
69 printf_stdebug(va_alist
)
78 pattern
= va_arg(args
, char *);
80 vsprintf(buf
, pattern
, args
);
81 if (SERIAL_WRITE(st2000_desc
, buf
, strlen(buf
)))
82 fprintf(stderr
, "SERIAL_WRITE failed: %s\n", safe_strerror(errno
));
85 /* Read a character from the remote system, doing all the fancy timeout
94 c
= SERIAL_READCHAR(st2000_desc
, timeout
);
97 putc(c
& 0x7f, log_file
);
103 if (c
== SERIAL_TIMEOUT
)
106 return c
; /* Polls shouldn't generate timeout errors */
108 error("Timeout reading from remote system.");
111 perror_with_name("remote-st2000");
114 /* Scan input from the remote system, until STRING is found. If DISCARD is
115 non-zero, then discard non-matching input, else print it out.
116 Let the user break out immediately. */
118 expect(string
, discard
)
128 c
= readchar(timeout
);
141 fwrite(string
, 1, (p
- 1) - string
, stdout
);
150 /* Keep discarding input until we see the STDEBUG prompt.
152 The convention for dealing with the prompt is that you
154 o *then* wait for the prompt.
156 Thus the last thing that a procedure does with the serial line
157 will be an expect_prompt(). Exception: st2000_resume does not
158 wait for the prompt, because the terminal is being handed over
159 to the inferior. However, the next thing which happens after that
160 is a st2000_wait which does wait for the prompt.
161 Note that this includes abnormal exit, e.g. error(). This is
162 necessary to prevent getting into states from which we can't
165 expect_prompt(discard
)
168 #if defined (LOG_FILE)
169 /* This is a convenient place to do this. The idea is to do it often
170 enough that we never lose much data if we terminate abnormally. */
173 expect ("dbug> ", discard
);
176 /* Get a hex digit from the remote system & return its value.
177 If ignore_space is nonzero, ignore spaces (not newline, tab, etc). */
179 get_hex_digit(ignore_space
)
185 ch
= readchar(timeout
);
186 if (ch
>= '0' && ch
<= '9')
188 else if (ch
>= 'A' && ch
<= 'F')
189 return ch
- 'A' + 10;
190 else if (ch
>= 'a' && ch
<= 'f')
191 return ch
- 'a' + 10;
192 else if (ch
== ' ' && ignore_space
)
197 error("Invalid hex digit from remote system.");
202 /* Get a byte from stdebug and put it in *BYT. Accept any number
210 val
= get_hex_digit (1) << 4;
211 val
|= get_hex_digit (0);
215 /* Get N 32-bit words from remote, each preceded by a space,
216 and put them in registers starting at REGNO. */
218 get_hex_regs (n
, regno
)
225 for (i
= 0; i
< n
; i
++)
230 for (j
= 0; j
< 8; j
++)
231 val
= (val
<< 4) + get_hex_digit (j
== 0);
232 supply_register (regno
++, (char *) &val
);
236 /* This is called not only when we first attach, but also when the
237 user types "run" after having attached. */
239 st2000_create_inferior (execfile
, args
, env
)
247 error("Can't pass arguments to remote STDEBUG process");
249 if (execfile
== 0 || exec_bfd
== 0)
250 error("No exec file specified");
252 entry_pt
= (int) bfd_get_start_address (exec_bfd
);
254 /* The "process" (board) is already stopped awaiting our commands, and
255 the program is already downloaded. We just set its PC and go. */
257 clear_proceed_status ();
259 /* Tell wait_for_inferior that we've started a new process. */
260 init_wait_for_inferior ();
262 /* Set up the "saved terminal modes" of the inferior
263 based on what modes we are starting it with. */
264 target_terminal_init ();
266 /* Install inferior's terminal modes. */
267 target_terminal_inferior ();
269 /* insert_step_breakpoint (); FIXME, do we need this? */
270 proceed ((CORE_ADDR
)entry_pt
, -1, 0); /* Let 'er rip... */
273 /* Open a connection to a remote debugger.
274 NAME is the filename used for communication. */
276 static int baudrate
= 9600;
277 static char dev_name
[100];
280 st2000_open(args
, from_tty
)
287 target_preopen(from_tty
);
289 n
= sscanf(args
, " %s %d %s", dev_name
, &baudrate
, junk
);
292 error("Bad arguments. Usage: target st2000 <device> <speed>\n\
293 or target st2000 <host> <port>\n");
297 st2000_desc
= SERIAL_OPEN(dev_name
);
300 perror_with_name(dev_name
);
302 SERIAL_SETBAUDRATE(st2000_desc
, baudrate
);
304 SERIAL_RAW(st2000_desc
);
306 push_target(&st2000_ops
);
308 #if defined (LOG_FILE)
309 log_file
= fopen (LOG_FILE
, "w");
310 if (log_file
== NULL
)
311 perror_with_name (LOG_FILE
);
314 /* Hello? Are you there? */
315 printf_stdebug("\003"); /* ^C wakes up dbug */
320 printf("Remote %s connected to %s\n", target_shortname
,
324 /* Close out all files and local state before this target loses control. */
327 st2000_close (quitting
)
330 SERIAL_CLOSE(st2000_desc
);
332 #if defined (LOG_FILE)
334 if (ferror(log_file
))
335 fprintf(stderr
, "Error writing log file.\n");
336 if (fclose(log_file
) != 0)
337 fprintf(stderr
, "Error closing log file.\n");
342 /* Terminate the open connection to the remote debugger.
343 Use this when you want to detach and do something else
346 st2000_detach (from_tty
)
349 pop_target(); /* calls st2000_close to do the real work */
351 printf ("Ending remote %s debugging\n", target_shortname
);
354 /* Tell the remote machine to resume. */
357 st2000_resume (pid
, step
, sig
)
359 enum target_signal sig
;
363 printf_stdebug ("ST\r");
364 /* Wait for the echo. */
369 printf_stdebug ("GO\r");
370 /* Swallow the echo. */
375 /* Wait until the remote machine stops, then return,
376 storing status in STATUS just as `wait' would. */
380 struct target_waitstatus
*status
;
382 int old_timeout
= timeout
;
384 status
->kind
= TARGET_WAITKIND_EXITED
;
385 status
->value
.integer
= 0;
387 timeout
= 0; /* Don't time out -- user program is running. */
389 expect_prompt(0); /* Wait for prompt, outputting extraneous text */
391 status
->kind
= TARGET_WAITKIND_STOPPED
;
392 status
->value
.sig
= TARGET_SIGNAL_TRAP
;
394 timeout
= old_timeout
;
399 /* Return the name of register number REGNO in the form input and output by
400 STDEBUG. Currently, REGISTER_NAMES just happens to contain exactly what
401 STDEBUG wants. Lets take advantage of that just as long as possible! */
413 for (p
= reg_names
[regno
]; *p
; p
++)
420 /* Read the remote registers into the block REGS. */
423 st2000_fetch_registers ()
427 /* Yeah yeah, I know this is horribly inefficient. But it isn't done
428 very often... I'll clean it up later. */
430 for (regno
= 0; regno
<= PC_REGNUM
; regno
++)
431 st2000_fetch_register(regno
);
434 /* Fetch register REGNO, or all registers if REGNO is -1.
435 Returns errno value. */
437 st2000_fetch_register (regno
)
441 st2000_fetch_registers ();
444 char *name
= get_reg_name (regno
);
445 printf_stdebug ("DR %s\r", name
);
448 get_hex_regs (1, regno
);
454 /* Store the remote registers from the contents of the block REGS. */
457 st2000_store_registers ()
461 for (regno
= 0; regno
<= PC_REGNUM
; regno
++)
462 st2000_store_register(regno
);
464 registers_changed ();
467 /* Store register REGNO, or all if REGNO == 0.
468 Return errno value. */
470 st2000_store_register (regno
)
474 st2000_store_registers ();
477 printf_stdebug ("PR %s %x\r", get_reg_name (regno
),
478 read_register (regno
));
484 /* Get ready to modify the registers array. On machines which store
485 individual registers, this doesn't need to do anything. On machines
486 which store all the registers in one fell swoop, this makes sure
487 that registers contains all the registers from the program being
491 st2000_prepare_to_store ()
493 /* Do nothing, since we can store individual regs */
499 printf ("\tAttached to %s at %d baud.\n",
503 /* Copy LEN bytes of data from debugger memory at MYADDR
504 to inferior's memory at MEMADDR. Returns length moved. */
506 st2000_write_inferior_memory (memaddr
, myaddr
, len
)
508 unsigned char *myaddr
;
513 for (i
= 0; i
< len
; i
++)
515 printf_stdebug ("PM.B %x %x\r", memaddr
+ i
, myaddr
[i
]);
521 /* Read LEN bytes from inferior memory at MEMADDR. Put the result
522 at debugger address MYADDR. Returns length moved. */
524 st2000_read_inferior_memory(memaddr
, myaddr
, len
)
531 /* Number of bytes read so far. */
534 /* Starting address of this pass. */
535 unsigned long startaddr
;
537 /* Number of bytes to read in this pass. */
540 /* Note that this code works correctly if startaddr is just less
541 than UINT_MAX (well, really CORE_ADDR_MAX if there was such a
542 thing). That is, something like
543 st2000_read_bytes (CORE_ADDR_MAX - 4, foo, 4)
544 works--it never adds len to memaddr and gets 0. */
545 /* However, something like
546 st2000_read_bytes (CORE_ADDR_MAX - 3, foo, 4)
547 doesn't need to work. Detect it and give up if there's an attempt
549 if (((memaddr
- 1) + len
) < memaddr
) {
559 if ((startaddr
% 16) != 0)
560 len_this_pass
-= startaddr
% 16;
561 if (len_this_pass
> (len
- count
))
562 len_this_pass
= (len
- count
);
564 printf_stdebug ("DI.L %x %x\r", startaddr
, len_this_pass
);
567 for (i
= 0; i
< len_this_pass
; i
++)
568 get_hex_byte (&myaddr
[count
++]);
572 startaddr
+= len_this_pass
;
577 /* FIXME-someday! Merge these two. */
579 st2000_xfer_inferior_memory (memaddr
, myaddr
, len
, write
, target
)
584 struct target_ops
*target
; /* ignored */
587 return st2000_write_inferior_memory (memaddr
, myaddr
, len
);
589 return st2000_read_inferior_memory (memaddr
, myaddr
, len
);
593 st2000_kill (args
, from_tty
)
597 return; /* Ignore attempts to kill target system */
600 /* Clean up when a program exits.
602 The program actually lives on in the remote processor's RAM, and may be
603 run again without a download. Don't leave it full of breakpoint
607 st2000_mourn_inferior ()
609 remove_breakpoints ();
610 unpush_target (&st2000_ops
);
611 generic_mourn_inferior (); /* Do all the proper things now */
614 #define MAX_STDEBUG_BREAKPOINTS 16
616 extern int memory_breakpoint_size
;
617 static CORE_ADDR breakaddr
[MAX_STDEBUG_BREAKPOINTS
] = {0};
620 st2000_insert_breakpoint (addr
, shadow
)
626 for (i
= 0; i
<= MAX_STDEBUG_BREAKPOINTS
; i
++)
627 if (breakaddr
[i
] == 0)
631 st2000_read_inferior_memory(addr
, shadow
, memory_breakpoint_size
);
632 printf_stdebug("BR %x H\r", addr
);
637 fprintf(stderr
, "Too many breakpoints (> 16) for STDBUG\n");
642 st2000_remove_breakpoint (addr
, shadow
)
648 for (i
= 0; i
< MAX_STDEBUG_BREAKPOINTS
; i
++)
649 if (breakaddr
[i
] == addr
)
653 printf_stdebug("CB %d\r", i
);
658 fprintf(stderr
, "Can't find breakpoint associated with 0x%x\n", addr
);
663 /* Put a command string, in args, out to STDBUG. Output from STDBUG is placed
664 on the users terminal until the prompt is seen. */
667 st2000_command (args
, fromtty
)
672 error("st2000 target not open.");
675 error("Missing command.");
677 printf_stdebug("%s\r", args
);
681 /* Connect the user directly to STDBUG. This command acts just like the
682 'cu' or 'tip' command. Use <CR>~. or <CR>~^D to break out. */
684 /*static struct ttystate ttystate;*/
689 printf("\r\n[Exiting connect mode]\r\n");
690 /* SERIAL_RESTORE(0, &ttystate);*/
694 /* This all should now be in serial.c */
697 connect_command (args
, fromtty
)
709 error("st2000 target not open.");
712 fprintf("This command takes no args. They have been ignored.\n");
714 printf("[Entering connect mode. Use ~. or ~^D to escape]\n");
716 serial_raw(0, &ttystate
);
718 make_cleanup(cleanup_tty
, 0);
727 FD_SET(st2000_desc
, &readfds
);
728 numfds
= select(sizeof(readfds
)*8, &readfds
, 0, 0, 0);
733 perror_with_name("select");
735 if (FD_ISSET(0, &readfds
))
736 { /* tty input, send to stdebug */
739 perror_with_name("connect");
741 printf_stdebug("%c", c
);
755 if (c
== '.' || c
== '\004')
762 if (FD_ISSET(st2000_desc
, &readfds
))
777 /* Define the target subroutine names */
779 struct target_ops st2000_ops
= {
781 "Remote serial Tandem ST2000 target",
782 "Use a remote computer running STDEBUG connected by a serial line,\n\
783 or a network connection.\n\
784 Arguments are the name of the device for the serial line,\n\
785 the speed to connect at in bits per second.",
792 st2000_fetch_register
,
793 st2000_store_register
,
794 st2000_prepare_to_store
,
795 st2000_xfer_inferior_memory
,
797 st2000_insert_breakpoint
,
798 st2000_remove_breakpoint
, /* Breakpoints */
803 0, /* Terminal handling */
806 0, /* lookup_symbol */
807 st2000_create_inferior
,
808 st2000_mourn_inferior
,
810 0, /* notice_signals */
817 1, /* all mem, mem, stack, regs, exec */
819 0, /* Section pointers */
820 OPS_MAGIC
, /* Always the last thing */
824 _initialize_remote_st2000 ()
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.");