X-Git-Url: http://drtracing.org/?a=blobdiff_plain;f=gdb%2Fremote-os9k.c;h=0a703ebd3a5837f7cbcb054854275441c4d0393f;hb=e31f1a7cdb547636f561a24f6c2288228c3cf3a0;hp=2abfa8376831e638678d87662c4c8c9c86475ab9;hpb=c906108c21474dfb4ed285bcc0ac6fe02cd400cc;p=deliverable%2Fbinutils-gdb.git diff --git a/gdb/remote-os9k.c b/gdb/remote-os9k.c index 2abfa83768..0a703ebd3a 100644 --- a/gdb/remote-os9k.c +++ b/gdb/remote-os9k.c @@ -1,27 +1,30 @@ /* Remote debugging interface for boot monitors, for GDB. - Copyright 1990, 1991, 1992, 1993 Free Software Foundation, Inc. -This file is part of GDB. + Copyright 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1998, 1999, + 2000, 2001, 2002 Free Software Foundation, Inc. -This program is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2 of the License, or -(at your option) any later version. + This file is part of GDB. -This program is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. -You should have received a copy of the GNU General Public License -along with this program; if not, write to the Free Software -Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ /* This file was derived from remote-eb.c, which did a similar job, but for an AMD-29K running EBMON. That file was in turn derived from remote.c as mentioned in the following comment (left in for comic relief): - "This is like remote.c but is for a different situation-- + "This is like remote.c but is for a different situation-- having a PC running os9000 hook up with a unix machine with a serial line, and running ctty com2 on the PC. os9000 has a debug monitor called ROMBUG running. Not to mention that the PC @@ -31,7 +34,7 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ In reality, this module talks to a debug monitor called 'ROMBUG', which We communicate with ROMBUG via a direct serial line, the network version of ROMBUG is not available yet. -*/ + */ /* FIXME This file needs to be rewritten if it's to work again, either to self-contained or to use the new monitor interface. */ @@ -39,13 +42,6 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "defs.h" #include "gdbcore.h" #include "target.h" -#include "wait.h" -#ifdef ANSI_PROTOTYPES -#include -#else -#include -#endif -#include #include "gdb_string.h" #include #include "command.h" @@ -56,22 +52,23 @@ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ #include "symfile.h" #include "objfiles.h" #include "gdb-stabs.h" +#include "regcache.h" struct cmd_list_element *showlist; -extern struct target_ops rombug_ops; /* Forward declaration */ -extern struct monitor_ops rombug_cmds; /* Forward declaration */ +extern struct target_ops rombug_ops; /* Forward declaration */ +extern struct monitor_ops rombug_cmds; /* Forward declaration */ extern struct cmd_list_element *setlist; extern struct cmd_list_element *unsetlist; extern int attach_flag; -static void rombug_close(); -static void rombug_fetch_register(); -static void rombug_fetch_registers(); -static void rombug_store_register(); +static void rombug_close (); +static void rombug_fetch_register (); +static void rombug_fetch_registers (); +static void rombug_store_register (); #if 0 -static int sr_get_debug(); /* flag set by "set remotedebug" */ +static int sr_get_debug (); /* flag set by "set remotedebug" */ #endif -static int hashmark; /* flag set by "set hash" */ +static int hashmark; /* flag set by "set hash" */ static int rombug_is_open = 0; /* FIXME: Replace with sr_get_debug (). */ @@ -83,8 +80,8 @@ static int tty_xoff = 0; static int timeout = 10; static int is_trace_mode = 0; -/* Descriptor for I/O to remote machine. Initialize it to NULL*/ -static serial_t monitor_desc = NULL; +/* Descriptor for I/O to remote machine. Initialize it to NULL */ +static struct serial *monitor_desc = NULL; static CORE_ADDR bufaddr = 0; static int buflen = 0; @@ -92,46 +89,35 @@ static char readbuf[16]; /* Send data to monitor. Works just like printf. */ static void -#ifdef ANSI_PROTOTYPES -printf_monitor(char *pattern, ...) -#else -printf_monitor(va_alist) - va_dcl -#endif +printf_monitor (char *pattern,...) { va_list args; char buf[200]; int i; -#ifdef ANSI_PROTOTYPES va_start (args, pattern); -#else - char *pattern; - va_start(args); - pattern = va_arg(args, char *); -#endif - vsprintf(buf, pattern, args); - va_end(args); + vsprintf (buf, pattern, args); + va_end (args); - if (SERIAL_WRITE(monitor_desc, buf, strlen(buf))) - fprintf(stderr, "SERIAL_WRITE failed: %s\n", safe_strerror(errno)); + if (serial_write (monitor_desc, buf, strlen (buf))) + fprintf_unfiltered (gdb_stderr, "serial_write failed: %s\n", + safe_strerror (errno)); } -/* Read a character from the remote system, doing all the fancy timeout stuff*/ +/* Read a character from the remote system, doing all the fancy timeout stuff */ static int -readchar(timeout) - int timeout; +readchar (int timeout) { int c; - c = SERIAL_READCHAR(monitor_desc, timeout); + c = serial_readchar (monitor_desc, timeout); - if (sr_get_debug()) - putchar(c & 0x7f); + if (sr_get_debug ()) + putchar (c & 0x7f); - if (monitor_log && isascii(c)) - putc(c & 0x7f, log_file); + if (monitor_log && isascii (c)) + putc (c & 0x7f, log_file); if (c >= 0) return c & 0x7f; @@ -141,38 +127,36 @@ readchar(timeout) if (timeout == 0) return c; /* Polls shouldn't generate timeout errors */ - error("Timeout reading from remote system."); + error ("Timeout reading from remote system."); } - perror_with_name("remote-monitor"); + perror_with_name ("remote-monitor"); } /* Scan input from the remote system, until STRING is found. If DISCARD is non-zero, then discard non-matching input, else print it out. Let the user break out immediately. */ static void -expect(string, discard) - char *string; - int discard; +expect (char *string, int discard) { char *p = string; int c; - if (sr_get_debug()) + if (sr_get_debug ()) printf ("Expecting \"%s\"\n", string); - immediate_quit = 1; + immediate_quit++; while (1) { - c = readchar(timeout); + c = readchar (timeout); if (!isascii (c)) continue; if (c == *p++) { if (*p == '\0') { - immediate_quit = 0; - if (sr_get_debug()) + immediate_quit--; + if (sr_get_debug ()) printf ("\nMatched\n"); return; } @@ -181,9 +165,9 @@ expect(string, discard) { if (!discard) { - fwrite(string, 1, (p - 1) - string, stdout); - putchar((char)c); - fflush(stdout); + fwrite (string, 1, (p - 1) - string, stdout); + putchar ((char) c); + fflush (stdout); } p = string; } @@ -205,31 +189,32 @@ expect(string, discard) necessary to prevent getting into states from which we can't recover. */ static void -expect_prompt(discard) - int discard; +expect_prompt (int discard) { if (monitor_log) - /* This is a convenient place to do this. The idea is to do it often - enough that we never lose much data if we terminate abnormally. */ - fflush(log_file); - - if (is_trace_mode) { - expect("trace", discard); - } else { - expect (PROMPT, discard); - } + /* This is a convenient place to do this. The idea is to do it often + enough that we never lose much data if we terminate abnormally. */ + fflush (log_file); + + if (is_trace_mode) + { + expect ("trace", discard); + } + else + { + expect (PROMPT, discard); + } } /* Get a hex digit from the remote system & return its value. If ignore_space is nonzero, ignore spaces (not newline, tab, etc). */ static int -get_hex_digit(ignore_space) - int ignore_space; +get_hex_digit (int ignore_space) { int ch; while (1) { - ch = readchar(timeout); + ch = readchar (timeout); if (ch >= '0' && ch <= '9') return ch - '0'; else if (ch >= 'A' && ch <= 'F') @@ -240,8 +225,8 @@ get_hex_digit(ignore_space) ; else { - expect_prompt(1); - error("Invalid hex digit from remote system."); + expect_prompt (1); + error ("Invalid hex digit from remote system."); } } } @@ -249,8 +234,7 @@ get_hex_digit(ignore_space) /* Get a byte from monitor and put it in *BYT. Accept any number leading spaces. */ static void -get_hex_byte (byt) - char *byt; +get_hex_byte (char *byt) { int val; @@ -262,9 +246,7 @@ get_hex_byte (byt) /* Get N 32-bit words from remote, each preceded by a space, and put them in registers starting at REGNO. */ static void -get_hex_regs (n, regno) - int n; - int regno; +get_hex_regs (int n, int regno) { long val; int i; @@ -273,15 +255,15 @@ get_hex_regs (n, regno) for (i = 0; i < n; i++) { int j; - + val = 0; for (j = 0; j < 4; j++) { get_hex_byte (&b); - if (TARGET_BYTE_ORDER == BIG_ENDIAN) + if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) val = (val << 8) + b; else - val = val + (b << (j*8)); + val = val + (b << (j * 8)); } supply_register (regno++, (char *) &val); } @@ -290,18 +272,15 @@ get_hex_regs (n, regno) /* This is called not only when we first attach, but also when the user types "run" after having attached. */ static void -rombug_create_inferior (execfile, args, env) - char *execfile; - char *args; - char **env; +rombug_create_inferior (char *execfile, char *args, char **env) { int entry_pt; if (args && *args) - error("Can't pass arguments to remote ROMBUG process"); + error ("Can't pass arguments to remote ROMBUG process"); if (execfile == 0 || exec_bfd == 0) - error("No executable file specified"); + error ("No executable file specified"); entry_pt = (int) bfd_get_start_address (exec_bfd); @@ -313,7 +292,7 @@ rombug_create_inferior (execfile, args, env) the program is already downloaded. We just set its PC and go. */ init_wait_for_inferior (); - proceed ((CORE_ADDR)entry_pt, TARGET_SIGNAL_DEFAULT, 0); + proceed ((CORE_ADDR) entry_pt, TARGET_SIGNAL_DEFAULT, 0); } /* Open a connection to a remote debugger. @@ -322,39 +301,43 @@ rombug_create_inferior (execfile, args, env) static char dev_name[100]; static void -rombug_open(args, from_tty) - char *args; - int from_tty; +rombug_open (char *args, int from_tty) { if (args == NULL) error ("Use `target RomBug DEVICE-NAME' to use a serial port, or \n\ `target RomBug HOST-NAME:PORT-NUMBER' to use a network connection."); - target_preopen(from_tty); + target_preopen (from_tty); if (rombug_is_open) - unpush_target(&rombug_ops); + unpush_target (&rombug_ops); - strcpy(dev_name, args); - monitor_desc = SERIAL_OPEN(dev_name); + strcpy (dev_name, args); + monitor_desc = serial_open (dev_name); if (monitor_desc == NULL) - perror_with_name(dev_name); + perror_with_name (dev_name); /* if baud rate is set by 'set remotebaud' */ - if (SERIAL_SETBAUDRATE (monitor_desc, sr_get_baud_rate())) + if (serial_setbaudrate (monitor_desc, sr_get_baud_rate ())) { - SERIAL_CLOSE (monitor_desc); + serial_close (monitor_desc); perror_with_name ("RomBug"); } - SERIAL_RAW(monitor_desc); + serial_raw (monitor_desc); if (tty_xon || tty_xoff) { - struct hardware_ttystate { struct termios t;} *tty_s; - - tty_s =(struct hardware_ttystate *)SERIAL_GET_TTY_STATE(monitor_desc); - if (tty_xon) tty_s->t.c_iflag |= IXON; - if (tty_xoff) tty_s->t.c_iflag |= IXOFF; - SERIAL_SET_TTY_STATE(monitor_desc, (serial_ttystate) tty_s); + struct hardware_ttystate + { + struct termios t; + } + *tty_s; + + tty_s = (struct hardware_ttystate *) serial_get_tty_state (monitor_desc); + if (tty_xon) + tty_s->t.c_iflag |= IXON; + if (tty_xoff) + tty_s->t.c_iflag |= IXOFF; + serial_set_tty_state (monitor_desc, (serial_ttystate) tty_s); } rombug_is_open = 1; @@ -364,19 +347,19 @@ rombug_open(args, from_tty) perror_with_name (LOG_FILE); push_monitor (&rombug_cmds); - printf_monitor("\r"); /* CR wakes up monitor */ - expect_prompt(1); + printf_monitor ("\r"); /* CR wakes up monitor */ + expect_prompt (1); push_target (&rombug_ops); attach_flag = 1; if (from_tty) - printf("Remote %s connected to %s\n", target_shortname, - dev_name); + printf ("Remote %s connected to %s\n", target_shortname, + dev_name); - rombug_fetch_registers(); + rombug_fetch_registers (); printf_monitor ("ov e \r"); - expect_prompt(1); + expect_prompt (1); bufaddr = 0; buflen = 0; } @@ -386,47 +369,46 @@ rombug_open(args, from_tty) */ static void -rombug_close (quitting) - int quitting; +rombug_close (int quitting) { - if (rombug_is_open) { - SERIAL_CLOSE(monitor_desc); - monitor_desc = NULL; - rombug_is_open = 0; - } - - if (log_file) { - if (ferror(log_file)) - fprintf(stderr, "Error writing log file.\n"); - if (fclose(log_file) != 0) - fprintf(stderr, "Error closing log file.\n"); - log_file = 0; - } + if (rombug_is_open) + { + serial_close (monitor_desc); + monitor_desc = NULL; + rombug_is_open = 0; + } + + if (log_file) + { + if (ferror (log_file)) + fprintf_unfiltered (gdb_stderr, "Error writing log file.\n"); + if (fclose (log_file) != 0) + fprintf_unfiltered (gdb_stderr, "Error closing log file.\n"); + log_file = 0; + } } int -rombug_link(mod_name, text_reloc) - char *mod_name; - CORE_ADDR *text_reloc; +rombug_link (char *mod_name, CORE_ADDR *text_reloc) { int i, j; unsigned long val; unsigned char b; - printf_monitor("l %s \r", mod_name); - expect_prompt(1); - printf_monitor(".r \r"); - expect(REG_DELIM, 1); - for (i=0; i <= 7; i++) + printf_monitor ("l %s \r", mod_name); + expect_prompt (1); + printf_monitor (".r \r"); + expect (REG_DELIM, 1); + for (i = 0; i <= 7; i++) { val = 0; for (j = 0; j < 4; j++) - { - get_hex_byte(&b); - val = (val << 8) + b; + { + get_hex_byte (&b); + val = (val << 8) + b; } } - expect_prompt(1); + expect_prompt (1); *text_reloc = val; return 1; } @@ -435,25 +417,23 @@ rombug_link(mod_name, text_reloc) Use this when you want to detach and do something else with your gdb. */ static void -rombug_detach (from_tty) - int from_tty; +rombug_detach (int from_tty) { - if (attach_flag) { - printf_monitor (GO_CMD); - attach_flag = 0; - } - pop_target(); /* calls rombug_close to do the real work */ + if (attach_flag) + { + printf_monitor (GO_CMD); + attach_flag = 0; + } + pop_target (); /* calls rombug_close to do the real work */ if (from_tty) printf ("Ending remote %s debugging\n", target_shortname); } - + /* * Tell the remote machine to resume. */ static void -rombug_resume (pid, step, sig) - int pid, step; - enum target_signal sig; +rombug_resume (ptid_t ptid, int step, enum target_signal sig) { if (monitor_log) fprintf (log_file, "\nIn Resume (step=%d, sig=%d)\n", step, sig); @@ -463,18 +443,18 @@ rombug_resume (pid, step, sig) is_trace_mode = 1; printf_monitor (STEP_CMD); /* wait for the echo. ** - expect (STEP_CMD, 1); - */ + expect (STEP_CMD, 1); + */ } else { printf_monitor (GO_CMD); /* swallow the echo. ** - expect (GO_CMD, 1); - */ + expect (GO_CMD, 1); + */ } bufaddr = 0; - buflen= 0; + buflen = 0; } /* @@ -482,10 +462,8 @@ rombug_resume (pid, step, sig) * storing status in status just as `wait' would. */ -static int -rombug_wait (pid, status) - int pid; - struct target_waitstatus *status; +static ptid * +rombug_wait (ptid_t ptid, struct target_waitstatus *status) { int old_timeout = timeout; struct section_offsets *offs; @@ -498,36 +476,32 @@ rombug_wait (pid, status) status->kind = TARGET_WAITKIND_EXITED; status->value.integer = 0; - timeout = -1; /* Don't time out -- user program is running. */ - expect ("eax:", 0); /* output any message before register display */ - expect_prompt(1); /* Wait for prompt, outputting extraneous text */ + timeout = -1; /* Don't time out -- user program is running. */ + expect ("eax:", 0); /* output any message before register display */ + expect_prompt (1); /* Wait for prompt, outputting extraneous text */ status->kind = TARGET_WAITKIND_STOPPED; status->value.sig = TARGET_SIGNAL_TRAP; timeout = old_timeout; - rombug_fetch_registers(); + rombug_fetch_registers (); bufaddr = 0; buflen = 0; - pc = read_register(PC_REGNUM); - addr = read_register(DATABASE_REG); + pc = read_register (PC_REGNUM); + addr = read_register (DATABASE_REG); obj_sec = find_pc_section (pc); if (obj_sec != NULL) { if (obj_sec->objfile != symfile_objfile) - new_symfile_objfile(obj_sec->objfile, 1, 0); - offs = ((struct section_offsets *) - alloca (sizeof (struct section_offsets) - + (symfile_objfile->num_sections * sizeof (offs->offsets)))); - memcpy (offs, symfile_objfile->section_offsets, - (sizeof (struct section_offsets) + - (symfile_objfile->num_sections * sizeof (offs->offsets)))); - ANOFFSET (offs, SECT_OFF_DATA) = addr; - ANOFFSET (offs, SECT_OFF_BSS) = addr; - - objfile_relocate(symfile_objfile, offs); + new_symfile_objfile (obj_sec->objfile, 1, 0); + offs = (struct section_offsets *) alloca (SIZEOF_SECTION_OFFSETS); + memcpy (offs, symfile_objfile->section_offsets, SIZEOF_SECTION_OFFSETS); + offs->offsets[SECT_OFF_DATA (symfile_objfile)] = addr; + offs->offsets[SECT_OFF_BSS (symfile_objfile)] = addr; + + objfile_relocate (symfile_objfile, offs); } - return 0; + return inferior_ptid; } /* Return the name of register number regno in the form input and output by @@ -535,8 +509,7 @@ rombug_wait (pid, status) monitor wants. Lets take advantage of that just as long as possible! */ static char * -get_reg_name (regno) - int regno; +get_reg_name (int regno) { static char buf[50]; char *p; @@ -547,69 +520,72 @@ get_reg_name (regno) if (regno < 0) return (""); /* - for (p = REGISTER_NAME (regno); *p; p++) - *b++ = toupper(*p); - *b = '\000'; -*/ - p = (char *)REGISTER_NAME (regno); + for (p = REGISTER_NAME (regno); *p; p++) + *b++ = toupper(*p); + *b = '\000'; + */ + p = (char *) REGISTER_NAME (regno); return p; /* - return buf; -*/ + return buf; + */ } /* read the remote registers into the block regs. */ static void -rombug_fetch_registers () +rombug_fetch_registers (void) { int regno, j, i; long val; unsigned char b; printf_monitor (GET_REG); - expect("eax:", 1); - expect("\n", 1); - get_hex_regs(1, 0); - get_hex_regs(1, 3); - get_hex_regs(1, 1); - get_hex_regs(1, 2); - get_hex_regs(1, 6); - get_hex_regs(1, 7); - get_hex_regs(1, 5); - get_hex_regs(1, 4); + expect ("eax:", 1); + expect ("\n", 1); + get_hex_regs (1, 0); + get_hex_regs (1, 3); + get_hex_regs (1, 1); + get_hex_regs (1, 2); + get_hex_regs (1, 6); + get_hex_regs (1, 7); + get_hex_regs (1, 5); + get_hex_regs (1, 4); for (regno = 8; regno <= 15; regno++) { - expect(REG_DELIM, 1); + expect (REG_DELIM, 1); if (regno >= 8 && regno <= 13) { val = 0; for (j = 0; j < 2; j++) - { - get_hex_byte (&b); - if (TARGET_BYTE_ORDER == BIG_ENDIAN) + { + get_hex_byte (&b); + if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) val = (val << 8) + b; else - val = val + (b << (j*8)); - } + val = val + (b << (j * 8)); + } - if (regno == 8) i = 10; - if (regno >= 9 && regno <= 12) i = regno + 3; - if (regno == 13) i = 11; + if (regno == 8) + i = 10; + if (regno >= 9 && regno <= 12) + i = regno + 3; + if (regno == 13) + i = 11; supply_register (i, (char *) &val); } else if (regno == 14) { - get_hex_regs(1, PC_REGNUM); + get_hex_regs (1, PC_REGNUM); } else if (regno == 15) { - get_hex_regs(1, 9); + get_hex_regs (1, 9); } else { val = 0; - supply_register(regno, (char *) &val); + supply_register (regno, (char *) &val); } } is_trace_mode = 0; @@ -619,16 +595,16 @@ rombug_fetch_registers () /* Fetch register REGNO, or all registers if REGNO is -1. Returns errno value. */ static void -rombug_fetch_register (regno) - int regno; +rombug_fetch_register (int regno) { int val, j; unsigned char b; - if (monitor_log) { - fprintf (log_file, "\nIn Fetch Register (reg=%s)\n", get_reg_name (regno)); - fflush (log_file); - } + if (monitor_log) + { + fprintf (log_file, "\nIn Fetch Register (reg=%s)\n", get_reg_name (regno)); + fflush (log_file); + } if (regno < 0) { @@ -642,17 +618,17 @@ rombug_fetch_register (regno) { expect ("\n", 1); expect ("\n", 1); - expect (name, 1); - expect (REG_DELIM, 1); + expect (name, 1); + expect (REG_DELIM, 1); val = 0; for (j = 0; j < 2; j++) - { - get_hex_byte (&b); - if (TARGET_BYTE_ORDER == BIG_ENDIAN) + { + get_hex_byte (&b); + if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) val = (val << 8) + b; else - val = val + (b << (j*8)); - } + val = val + (b << (j * 8)); + } supply_register (regno, (char *) &val); } else if (regno == 8 || regno == 9) @@ -660,23 +636,23 @@ rombug_fetch_register (regno) expect ("\n", 1); expect ("\n", 1); expect ("\n", 1); - expect (name, 1); - expect (REG_DELIM, 1); + expect (name, 1); + expect (REG_DELIM, 1); get_hex_regs (1, regno); } else { - expect (name, 1); - expect (REG_DELIM, 1); - expect("\n", 1); - get_hex_regs(1, 0); - get_hex_regs(1, 3); - get_hex_regs(1, 1); - get_hex_regs(1, 2); - get_hex_regs(1, 6); - get_hex_regs(1, 7); - get_hex_regs(1, 5); - get_hex_regs(1, 4); + expect (name, 1); + expect (REG_DELIM, 1); + expect ("\n", 1); + get_hex_regs (1, 0); + get_hex_regs (1, 3); + get_hex_regs (1, 1); + get_hex_regs (1, 2); + get_hex_regs (1, 6); + get_hex_regs (1, 7); + get_hex_regs (1, 5); + get_hex_regs (1, 4); } expect_prompt (1); } @@ -686,12 +662,12 @@ rombug_fetch_register (regno) /* Store the remote registers from the contents of the block REGS. */ static void -rombug_store_registers () +rombug_store_registers (void) { int regno; for (regno = 0; regno <= PC_REGNUM; regno++) - rombug_store_register(regno); + rombug_store_register (regno); registers_changed (); } @@ -699,10 +675,9 @@ rombug_store_registers () /* Store register REGNO, or all if REGNO == 0. return errno value. */ static void -rombug_store_register (regno) - int regno; +rombug_store_register (int regno) { -char *name; + char *name; if (monitor_log) fprintf (log_file, "\nIn Store_register (regno=%d)\n", regno); @@ -711,11 +686,12 @@ char *name; rombug_store_registers (); else { - if (sr_get_debug()) + if (sr_get_debug ()) printf ("Setting register %s to 0x%x\n", get_reg_name (regno), read_register (regno)); - name = get_reg_name(regno); - if (name == 0) return; + name = get_reg_name (regno); + if (name == 0) + return; printf_monitor (SET_REG, name, read_register (regno)); is_trace_mode = 0; @@ -730,25 +706,22 @@ char *name; debugged. */ static void -rombug_prepare_to_store () +rombug_prepare_to_store (void) { /* Do nothing, since we can store individual regs */ } static void -rombug_files_info () +rombug_files_info (void) { printf ("\tAttached to %s at %d baud.\n", - dev_name, sr_get_baud_rate()); + dev_name, sr_get_baud_rate ()); } /* Copy LEN bytes of data from debugger memory at MYADDR to inferior's memory at MEMADDR. Returns length moved. */ static int -rombug_write_inferior_memory (memaddr, myaddr, len) - CORE_ADDR memaddr; - unsigned char *myaddr; - int len; +rombug_write_inferior_memory (CORE_ADDR memaddr, unsigned char *myaddr, int len) { int i; char buf[10]; @@ -761,7 +734,7 @@ rombug_write_inferior_memory (memaddr, myaddr, len) { expect (CMD_DELIM, 1); printf_monitor ("%x \r", myaddr[i]); - if (sr_get_debug()) + if (sr_get_debug ()) printf ("\nSet 0x%x to 0x%x\n", memaddr + i, myaddr[i]); } expect (CMD_DELIM, 1); @@ -778,10 +751,7 @@ rombug_write_inferior_memory (memaddr, myaddr, len) /* Read LEN bytes from inferior memory at MEMADDR. Put the result at debugger address MYADDR. Returns length moved. */ static int -rombug_read_inferior_memory(memaddr, myaddr, len) - CORE_ADDR memaddr; - char *myaddr; - int len; +rombug_read_inferior_memory (CORE_ADDR memaddr, char *myaddr, int len) { int i, j; @@ -806,16 +776,17 @@ rombug_read_inferior_memory(memaddr, myaddr, len) rombug_read_bytes (CORE_ADDR_MAX - 3, foo, 4) doesn't need to work. Detect it and give up if there's an attempt to do that. */ - if (((memaddr - 1) + len) < memaddr) { - errno = EIO; - return 0; - } - if (bufaddr <= memaddr && (memaddr+len) <= (bufaddr+buflen)) + if (((memaddr - 1) + len) < memaddr) + { + errno = EIO; + return 0; + } + if (bufaddr <= memaddr && (memaddr + len) <= (bufaddr + buflen)) { - memcpy(myaddr, &readbuf[memaddr-bufaddr], len); + memcpy (myaddr, &readbuf[memaddr - bufaddr], len); return len; } - + startaddr = memaddr; count = 0; while (count < len) @@ -825,7 +796,7 @@ rombug_read_inferior_memory(memaddr, myaddr, len) len_this_pass -= startaddr % 16; if (len_this_pass > (len - count)) len_this_pass = (len - count); - if (sr_get_debug()) + if (sr_get_debug ()) printf ("\nDisplay %d bytes at %x\n", len_this_pass, startaddr); printf_monitor (MEM_DIS_CMD, startaddr, 8); @@ -836,27 +807,29 @@ rombug_read_inferior_memory(memaddr, myaddr, len) } bufaddr = startaddr; buflen = 16; - memcpy(&myaddr[count], readbuf, len_this_pass); + memcpy (&myaddr[count], readbuf, len_this_pass); count += len_this_pass; startaddr += len_this_pass; - expect(CMD_DELIM, 1); + expect (CMD_DELIM, 1); } - if (CMD_END) - printf_monitor (CMD_END); + if (CMD_END) + printf_monitor (CMD_END); is_trace_mode = 0; expect_prompt (1); return len; } -/* FIXME-someday! merge these two. */ +/* Transfer LEN bytes between GDB address MYADDR and target address + MEMADDR. If WRITE is non-zero, transfer them to the target, + otherwise transfer them from the target. TARGET is unused. + + Returns the number of bytes transferred. */ + static int -rombug_xfer_inferior_memory (memaddr, myaddr, len, write, target) - CORE_ADDR memaddr; - char *myaddr; - int len; - int write; - struct target_ops *target; /* ignored */ +rombug_xfer_inferior_memory (CORE_ADDR memaddr, char *myaddr, int len, + int write, struct mem_attrib *attrib, + struct target_ops *target) { if (write) return rombug_write_inferior_memory (memaddr, myaddr, len); @@ -865,11 +838,9 @@ rombug_xfer_inferior_memory (memaddr, myaddr, len, write, target) } static void -rombug_kill (args, from_tty) - char *args; - int from_tty; +rombug_kill (char *args, int from_tty) { - return; /* ignore attempts to kill target system */ + return; /* ignore attempts to kill target system */ } /* Clean up when a program exits. @@ -878,7 +849,7 @@ rombug_kill (args, from_tty) instructions. */ static void -rombug_mourn_inferior () +rombug_mourn_inferior (void) { remove_breakpoints (); generic_mourn_inferior (); /* Do all the proper things now */ @@ -886,12 +857,11 @@ rombug_mourn_inferior () #define MAX_MONITOR_BREAKPOINTS 16 -static CORE_ADDR breakaddr[MAX_MONITOR_BREAKPOINTS] = {0}; +static CORE_ADDR breakaddr[MAX_MONITOR_BREAKPOINTS] = +{0}; static int -rombug_insert_breakpoint (addr, shadow) - CORE_ADDR addr; - char *shadow; +rombug_insert_breakpoint (CORE_ADDR addr, char *shadow) { int i; CORE_ADDR bp_addr = addr; @@ -905,16 +875,16 @@ rombug_insert_breakpoint (addr, shadow) if (breakaddr[i] == 0) { breakaddr[i] = addr; - if (sr_get_debug()) + if (sr_get_debug ()) printf ("Breakpoint at %x\n", addr); rombug_read_inferior_memory (bp_addr, shadow, bp_size); - printf_monitor(SET_BREAK_CMD, addr); + printf_monitor (SET_BREAK_CMD, addr); is_trace_mode = 0; - expect_prompt(1); + expect_prompt (1); return 0; } - fprintf(stderr, "Too many breakpoints (> 16) for monitor\n"); + fprintf_unfiltered (gdb_stderr, "Too many breakpoints (> 16) for monitor\n"); return 1; } @@ -922,9 +892,7 @@ rombug_insert_breakpoint (addr, shadow) * _remove_breakpoint -- Tell the monitor to remove a breakpoint */ static int -rombug_remove_breakpoint (addr, shadow) - CORE_ADDR addr; - char *shadow; +rombug_remove_breakpoint (CORE_ADDR addr, char *shadow) { int i; @@ -935,13 +903,14 @@ rombug_remove_breakpoint (addr, shadow) if (breakaddr[i] == addr) { breakaddr[i] = 0; - printf_monitor(CLR_BREAK_CMD, addr); + printf_monitor (CLR_BREAK_CMD, addr); is_trace_mode = 0; - expect_prompt(1); + expect_prompt (1); return 0; } - fprintf(stderr, "Can't find breakpoint associated with 0x%x\n", addr); + fprintf_unfiltered (gdb_stderr, + "Can't find breakpoint associated with 0x%x\n", addr); return 1; } @@ -950,8 +919,7 @@ rombug_remove_breakpoint (addr, shadow) #define DOWNLOAD_LINE_SIZE 100 static void -rombug_load (arg) - char *arg; +rombug_load (char *arg) { /* this part comment out for os9* */ #if 0 @@ -959,15 +927,15 @@ rombug_load (arg) char buf[DOWNLOAD_LINE_SIZE]; int i, bytes_read; - if (sr_get_debug()) + if (sr_get_debug ()) printf ("Loading %s to monitor\n", arg); download = fopen (arg, "r"); if (download == NULL) { - error (sprintf (buf, "%s Does not exist", arg)); - return; - } + error (sprintf (buf, "%s Does not exist", arg)); + return; + } printf_monitor (LOAD_CMD); /* expect ("Waiting for S-records from host... ", 1); */ @@ -981,12 +949,17 @@ rombug_load (arg) fflush (stdout); } - if (SERIAL_WRITE(monitor_desc, buf, bytes_read)) { - fprintf(stderr, "SERIAL_WRITE failed: (while downloading) %s\n", safe_strerror(errno)); - break; - } + if (serial_write (monitor_desc, buf, bytes_read)) + { + fprintf_unfiltered (gdb_stderr, + "serial_write failed: (while downloading) %s\n", + safe_strerror (errno)); + break; + } i = 0; - while (i++ <=200000) {} ; /* Ugly HACK, probably needs flow control */ + while (i++ <= 200000) + { + }; /* Ugly HACK, probably needs flow control */ if (bytes_read < DOWNLOAD_LINE_SIZE) { if (!feof (download)) @@ -1002,7 +975,7 @@ rombug_load (arg) if (!feof (download)) error ("Never got EOF while downloading"); fclose (download); -#endif 0 +#endif /* 0 */ } /* Put a command string, in args, out to MONITOR. @@ -1010,21 +983,19 @@ rombug_load (arg) is seen. */ static void -rombug_command (args, fromtty) - char *args; - int fromtty; +rombug_command (char *args, int fromtty) { if (monitor_desc == NULL) - error("monitor target not open."); - + error ("monitor target not open."); + if (monitor_log) fprintf (log_file, "\nIn command (args=%s)\n", args); if (!args) - error("Missing command."); - - printf_monitor("%s\r", args); - expect_prompt(0); + error ("Missing command."); + + printf_monitor ("%s\r", args); + expect_prompt (0); } #if 0 @@ -1034,57 +1005,56 @@ rombug_command (args, fromtty) static struct ttystate ttystate; static void -cleanup_tty() -{ printf("\r\n[Exiting connect mode]\r\n"); - /*SERIAL_RESTORE(0, &ttystate);*/ +cleanup_tty (void) +{ + printf ("\r\n[Exiting connect mode]\r\n"); + /*serial_restore(0, &ttystate); */ } static void -connect_command (args, fromtty) - char *args; - int fromtty; +connect_command (char *args, int fromtty) { fd_set readfds; int numfds; int c; char cur_esc = 0; - dont_repeat(); + dont_repeat (); if (monitor_desc == NULL) - error("monitor target not open."); - + error ("monitor target not open."); + if (args) - fprintf("This command takes no args. They have been ignored.\n"); - - printf("[Entering connect mode. Use ~. or ~^D to escape]\n"); + fprintf ("This command takes no args. They have been ignored.\n"); + + printf ("[Entering connect mode. Use ~. or ~^D to escape]\n"); - serial_raw(0, &ttystate); + serial_raw (0, &ttystate); - make_cleanup(cleanup_tty, 0); + make_cleanup (cleanup_tty, 0); - FD_ZERO(&readfds); + FD_ZERO (&readfds); while (1) { do { - FD_SET(0, &readfds); - FD_SET(monitor_desc, &readfds); - numfds = select(sizeof(readfds)*8, &readfds, 0, 0, 0); + FD_SET (0, &readfds); + FD_SET (deprecated_serial_fd (monitor_desc), &readfds); + numfds = select (sizeof (readfds) * 8, &readfds, 0, 0, 0); } while (numfds == 0); if (numfds < 0) - perror_with_name("select"); + perror_with_name ("select"); - if (FD_ISSET(0, &readfds)) + if (FD_ISSET (0, &readfds)) { /* tty input, send to monitor */ - c = getchar(); + c = getchar (); if (c < 0) - perror_with_name("connect"); + perror_with_name ("connect"); - printf_monitor("%c", c); + printf_monitor ("%c", c); switch (cur_esc) { case 0: @@ -1105,16 +1075,16 @@ connect_command (args, fromtty) } } - if (FD_ISSET(monitor_desc, &readfds)) + if (FD_ISSET (deprecated_serial_fd (monitor_desc), &readfds)) { while (1) { - c = readchar(0); + c = readchar (0); if (c < 0) break; - putchar(c); + putchar (c); } - fflush(stdout); + fflush (stdout); } } } @@ -1126,59 +1096,60 @@ connect_command (args, fromtty) * strings. We also need a CR or LF on the end. */ #warning FIXME: monitor interface pattern strings, stale struct decl -struct monitor_ops rombug_cmds = { - "g \r", /* execute or usually GO command */ - "g \r", /* continue command */ - "t \r", /* single step */ - "b %x\r", /* set a breakpoint */ - "k %x\r", /* clear a breakpoint */ - "c %x\r", /* set memory to a value */ - "d %x %d\r", /* display memory */ - "$%08X", /* prompt memory commands use */ - ".%s %x\r", /* set a register */ - ":", /* delimiter between registers */ - ". \r", /* read a register */ - "mf \r", /* download command */ - "RomBug: ", /* monitor command prompt */ - ": ", /* end-of-command delimitor */ - ".\r" /* optional command terminator */ +struct monitor_ops rombug_cmds = +{ + "g \r", /* execute or usually GO command */ + "g \r", /* continue command */ + "t \r", /* single step */ + "b %x\r", /* set a breakpoint */ + "k %x\r", /* clear a breakpoint */ + "c %x\r", /* set memory to a value */ + "d %x %d\r", /* display memory */ + "$%08X", /* prompt memory commands use */ + ".%s %x\r", /* set a register */ + ":", /* delimiter between registers */ + ". \r", /* read a register */ + "mf \r", /* download command */ + "RomBug: ", /* monitor command prompt */ + ": ", /* end-of-command delimitor */ + ".\r" /* optional command terminator */ }; -struct target_ops rombug_ops ; +struct target_ops rombug_ops; -static void -init_rombug_ops(void) +static void +init_rombug_ops (void) { - rombug_ops.to_shortname = "rombug"; - rombug_ops.to_longname = "Microware's ROMBUG debug monitor"; - rombug_ops.to_doc = "Use a remote computer running the ROMBUG debug monitor.\n\ + rombug_ops.to_shortname = "rombug"; + rombug_ops.to_longname = "Microware's ROMBUG debug monitor"; + rombug_ops.to_doc = "Use a remote computer running the ROMBUG debug monitor.\n\ Specify the serial device it is connected to (e.g. /dev/ttya).", - rombug_ops.to_open = rombug_open; - rombug_ops.to_close = rombug_close; - rombug_ops.to_attach = 0; + rombug_ops.to_open = rombug_open; + rombug_ops.to_close = rombug_close; + rombug_ops.to_attach = 0; rombug_ops.to_post_attach = NULL; rombug_ops.to_require_attach = NULL; - rombug_ops.to_detach = rombug_detach; + rombug_ops.to_detach = rombug_detach; rombug_ops.to_require_detach = NULL; - rombug_ops.to_resume = rombug_resume; - rombug_ops.to_wait = rombug_wait; + rombug_ops.to_resume = rombug_resume; + rombug_ops.to_wait = rombug_wait; rombug_ops.to_post_wait = NULL; - rombug_ops.to_fetch_registers = rombug_fetch_register; - rombug_ops.to_store_registers = rombug_store_register; - rombug_ops.to_prepare_to_store = rombug_prepare_to_store; - rombug_ops.to_xfer_memory = rombug_xfer_inferior_memory; - rombug_ops.to_files_info = rombug_files_info; - rombug_ops.to_insert_breakpoint = rombug_insert_breakpoint; - rombug_ops.to_remove_breakpoint = rombug_remove_breakpoint; /* Breakpoints */ - rombug_ops.to_terminal_init = 0; - rombug_ops.to_terminal_inferior = 0; - rombug_ops.to_terminal_ours_for_output = 0; - rombug_ops.to_terminal_ours = 0; - rombug_ops.to_terminal_info = 0; /* Terminal handling */ - rombug_ops.to_kill = rombug_kill; - rombug_ops.to_load = rombug_load; /* load */ - rombug_ops.to_lookup_symbol = rombug_link; /* lookup_symbol */ - rombug_ops.to_create_inferior = rombug_create_inferior; + rombug_ops.to_fetch_registers = rombug_fetch_register; + rombug_ops.to_store_registers = rombug_store_register; + rombug_ops.to_prepare_to_store = rombug_prepare_to_store; + rombug_ops.to_xfer_memory = rombug_xfer_inferior_memory; + rombug_ops.to_files_info = rombug_files_info; + rombug_ops.to_insert_breakpoint = rombug_insert_breakpoint; + rombug_ops.to_remove_breakpoint = rombug_remove_breakpoint; /* Breakpoints */ + rombug_ops.to_terminal_init = 0; + rombug_ops.to_terminal_inferior = 0; + rombug_ops.to_terminal_ours_for_output = 0; + rombug_ops.to_terminal_ours = 0; + rombug_ops.to_terminal_info = 0; /* Terminal handling */ + rombug_ops.to_kill = rombug_kill; + rombug_ops.to_load = rombug_load; /* load */ + rombug_ops.to_lookup_symbol = rombug_link; /* lookup_symbol */ + rombug_ops.to_create_inferior = rombug_create_inferior; rombug_ops.to_post_startup_inferior = NULL; rombug_ops.to_acknowledge_created_inferior = NULL; rombug_ops.to_clone_and_follow_inferior = NULL; @@ -1196,69 +1167,68 @@ Specify the serial device it is connected to (e.g. /dev/ttya).", rombug_ops.to_has_execd = NULL; rombug_ops.to_reported_exec_events_per_exec_call = NULL; rombug_ops.to_has_exited = NULL; - rombug_ops.to_mourn_inferior = rombug_mourn_inferior; - rombug_ops.to_can_run = 0; /* can_run */ - rombug_ops.to_notice_signals = 0; /* notice_signals */ - rombug_ops.to_thread_alive = 0; - rombug_ops.to_stop = 0; /* to_stop */ + rombug_ops.to_mourn_inferior = rombug_mourn_inferior; + rombug_ops.to_can_run = 0; /* can_run */ + rombug_ops.to_notice_signals = 0; /* notice_signals */ + rombug_ops.to_thread_alive = 0; + rombug_ops.to_stop = 0; /* to_stop */ rombug_ops.to_pid_to_exec_file = NULL; - rombug_ops.to_core_file_to_sym_file = NULL; - rombug_ops.to_stratum = process_stratum; - rombug_ops.DONT_USE = 0; /* next */ - rombug_ops.to_has_all_memory = 1; - rombug_ops.to_has_memory = 1; - rombug_ops.to_has_stack = 1; - rombug_ops.to_has_registers = 1; - rombug_ops.to_has_execution = 1; /* has execution */ - rombug_ops.to_sections = 0; - rombug_ops.to_sections_end = 0; /* Section pointers */ - rombug_ops.to_magic = OPS_MAGIC; /* Always the last thing */ -} + rombug_ops.to_stratum = process_stratum; + rombug_ops.DONT_USE = 0; /* next */ + rombug_ops.to_has_all_memory = 1; + rombug_ops.to_has_memory = 1; + rombug_ops.to_has_stack = 1; + rombug_ops.to_has_registers = 1; + rombug_ops.to_has_execution = 1; /* has execution */ + rombug_ops.to_sections = 0; + rombug_ops.to_sections_end = 0; /* Section pointers */ + rombug_ops.to_magic = OPS_MAGIC; /* Always the last thing */ +} void -_initialize_remote_os9k () +_initialize_remote_os9k (void) { - init_rombug_ops() ; + init_rombug_ops (); add_target (&rombug_ops); add_show_from_set ( - add_set_cmd ("hash", no_class, var_boolean, (char *)&hashmark, - "Set display of activity while downloading a file.\nWhen enabled, a period \'.\' is displayed.", - &setlist), - &showlist); + add_set_cmd ("hash", no_class, var_boolean, (char *) &hashmark, + "Set display of activity while downloading a file.\nWhen enabled, a period \'.\' is displayed.", + &setlist), + &showlist); add_show_from_set ( - add_set_cmd ("timeout", no_class, var_zinteger, - (char *) &timeout, - "Set timeout in seconds for remote MIPS serial I/O.", - &setlist), - &showlist); + add_set_cmd ("timeout", no_class, var_zinteger, + (char *) &timeout, + "Set timeout in seconds for remote MIPS serial I/O.", + &setlist), + &showlist); add_show_from_set ( - add_set_cmd ("remotelog", no_class, var_zinteger, - (char *) &monitor_log, - "Set monitor activity log on(=1) or off(=0).", - &setlist), - &showlist); + add_set_cmd ("remotelog", no_class, var_zinteger, + (char *) &monitor_log, + "Set monitor activity log on(=1) or off(=0).", + &setlist), + &showlist); add_show_from_set ( - add_set_cmd ("remotexon", no_class, var_zinteger, - (char *) &tty_xon, - "Set remote tty line XON control", - &setlist), - &showlist); + add_set_cmd ("remotexon", no_class, var_zinteger, + (char *) &tty_xon, + "Set remote tty line XON control", + &setlist), + &showlist); add_show_from_set ( - add_set_cmd ("remotexoff", no_class, var_zinteger, - (char *) &tty_xoff, - "Set remote tty line XOFF control", - &setlist), - &showlist); + add_set_cmd ("remotexoff", no_class, var_zinteger, + (char *) &tty_xoff, + "Set remote tty line XOFF control", + &setlist), + &showlist); add_com ("rombug ", class_obscure, rombug_command, - "Send a command to the debug monitor."); + "Send a command to the debug monitor."); #if 0 add_com ("connect", class_obscure, connect_command, - "Connect the terminal directly up to a serial based command monitor.\nUse ~. or ~^D to break out."); + "Connect the terminal directly up to a serial based command monitor.\nUse ~. or ~^D to break out."); #endif }