diff options
| -rw-r--r-- | gdb/h8300-tdep.c | 11 | ||||
| -rw-r--r-- | gdb/h8500-tdep.c | 11 | ||||
| -rw-r--r-- | gdb/remote-e7000.c | 1502 | ||||
| -rw-r--r-- | gdb/remote-z8k.c | 30 |
4 files changed, 1517 insertions, 37 deletions
diff --git a/gdb/h8300-tdep.c b/gdb/h8300-tdep.c index 862d1af5b50..20f26cc4ca9 100644 --- a/gdb/h8300-tdep.c +++ b/gdb/h8300-tdep.c @@ -482,14 +482,3 @@ print_register_hook (regno) } } -/* This doesn't quite fit either in the simulator or in gdb proper. - Perhaps the simulator could return 1 to mean it loaded it and 0 to - mean "you deal with it, caller". */ - -int -sim_load (abfd, prog) -bfd *abfd; -char *prog; -{ - return sim_load_standard (abfd); -} diff --git a/gdb/h8500-tdep.c b/gdb/h8500-tdep.c index 75301e2955c..3b5086a4e07 100644 --- a/gdb/h8500-tdep.c +++ b/gdb/h8500-tdep.c @@ -819,14 +819,3 @@ target_write_fp (v) write_register (FP_REGNUM, v & 0xffff); } -/* This doesn't quite fit either in the simulator or in gdb proper. - Perhaps the simulator could return 1 to mean it loaded it and 0 to - mean "you deal with it, caller". */ - -int -sim_load (abfd, prog) -bfd *abfd; -char *prog; -{ - return sim_load_standard (abfd); -} diff --git a/gdb/remote-e7000.c b/gdb/remote-e7000.c index e69de29bb2d..695180443d6 100644 --- a/gdb/remote-e7000.c +++ b/gdb/remote-e7000.c @@ -0,0 +1,1502 @@ +/* Remote debugging interface for Hitachi E7000 ICE, for GDB. + Copyright 1993 Free Software Foundation, Inc. + Contributed by Cygnus Support. Written by Steve Chamberlain for Cygnus. + + This file is part of GDB. + + 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 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., 675 Mass Ave, Cambridge, MA 02139, USA. */ + + +#include "defs.h" +#include "gdbcore.h" +#include "target.h" +#include "wait.h" +#include <varargs.h> +#include <signal.h> +#include <string.h> +#include <sys/types.h> +#include "serial.h" + + +/* The E7000 is an in-circuit emulator for the Hitachi H8/300-H and +Hitachi-SH processor. It has serial port and a lan port. + +The monitor command set makes it difficult to load large ammounts of +data over the lan without using ftp - so try not to issue load +commands when communicating over ethernet; use the ftpload command. + +The monitor pauses for a second when dumping srecords to the serial +line too, so we use a slower per byte mechanism but without the +startup overhead. Even so, it's pretty slow... */ + +int using_tcp; /* nonzero if using the tcp serial driver */ + +extern struct target_ops e7000_ops; /* Forward declaration */ +#define CTRLC 0x03 +#define ENQ 0x05 +#define ACK 0x06 +#define CTRLZ 0x1a + +char *ENQSTRING = "\005"; + +int echo; +static int echo_index; +static void e7000_close (); +static void e7000_fetch_register (); +static void e7000_store_register (); + +static int timeout = 5; + +static void expect PARAMS ((char *)); +static void expect_full_prompt PARAMS (()); +static void expect_prompt PARAMS (()); +static serial_t e7000_desc; + + +/* Send data to e7000debug. Works just like printf. */ + +static void +printf_e7000debug (va_alist) + va_dcl +{ + va_list args; + char *pattern; + char buf[200]; + + va_start (args); + + pattern = va_arg (args, char *); + + vsprintf (buf, pattern, args); + if (SERIAL_WRITE (e7000_desc, buf, strlen (buf))) + fprintf (stderr, "SERIAL_WRITE failed: %s\n", safe_strerror (errno)); + + /* And expect to see it echoed */ + expect (buf); +} + +static void +putchar_e7000 (x) +{ + char b[1]; + b[0] = x; + SERIAL_WRITE (e7000_desc, b, 1); +} + +static void +write_e7000 (s) + char *s; +{ + SERIAL_WRITE (e7000_desc, s, strlen (s)); +} + +/* Read a character from the remote system, doing all the fancy timeout + stuff. */ + +static int +readchar (timeout) + int timeout; +{ + int c; + do + { + c = SERIAL_READCHAR (e7000_desc, timeout); + } + while (c > 127); + if (c == SERIAL_TIMEOUT) + { + if (timeout == 0) + return c; /* Polls shouldn't generate timeout errors */ + + error ("Timeout reading from remote system."); + } + return c; +} + +/* 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) + char *string; +{ + char *p = string; + int c; + + immediate_quit = 1; + while (1) + + { + c = readchar (timeout); + if (c == SERIAL_ERROR) + { + error ("Serial communication error"); + } + if (echo_index) + { + if (c != '\r') + putchar (c); + fflush (stdout); + } + if (c == *p++) + { + if (*p == '\0') + { + immediate_quit = 0; + return; + } + } + else + { + p = string; + } + } +} + +/* Keep discarding input until we see the e7000 prompt. + + The convention for dealing with the prompt is that you + o give your command + o *then* wait for the prompt. + + Thus the last thing that a procedure does with the serial line + will be an expect_prompt(). Exception: e7000_resume does not + wait for the prompt, because the terminal is being handed over + to the inferior. However, the next thing which happens after that + is a e7000_wait which does wait for the prompt. + Note that this includes abnormal exit, e.g. error(). This is + necessary to prevent getting into states from which we can't + recover. */ +static void +expect_prompt () +{ +#if defined (LOG_FILE) + /* 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); +#endif + expect (":"); +} +static void +expect_full_prompt () +{ +#if defined (LOG_FILE) + /* 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); +#endif + expect ("\n:"); +} + +static int +get_hex_digit (ch) +{ + if (ch >= '0' && ch <= '9') + return ch - '0'; + else if (ch >= 'A' && ch <= 'F') + return ch - 'A' + 10; + else if (ch >= 'a' && ch <= 'f') + return ch - 'a' + 10; + return -1; + +} + + + +static int +get_hex (start) + int *start; +{ + int value = get_hex_digit (*start); + int try; + + *start = readchar (timeout); + while ((try = get_hex_digit (*start)) >= 0) + { + value <<= 4; + value += try; + *start = readchar (timeout); + } + return value; +} + +/* 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; +{ + long val; + int i; + + for (i = 0; i < n; i++) + { + int j; + + val = 0; + for (j = 0; j < 8; j++) + val = (val << 4) + get_hex_digit (j == 0); + supply_register (regno++, (char *) &val); + } +} + +/* This is called not only when we first attach, but also when the + user types "run" after having attached. */ +static void +e7000_create_inferior (execfile, args, env) + char *execfile; + char *args; + char **env; +{ + int entry_pt; + + if (args && *args) + error ("Can't pass arguments to remote E7000DEBUG process"); + + if (execfile == 0 || exec_bfd == 0) + error ("No exec file specified"); + + entry_pt = (int) bfd_get_start_address (exec_bfd); + +#ifdef CREATE_INFERIOR_HOOK + CREATE_INFERIOR_HOOK (0); /* No process-ID */ +#endif + + /* The "process" (board) is already stopped awaiting our commands, and + the program is already downloaded. We just set its PC and go. */ + + clear_proceed_status (); + + /* Tell wait_for_inferior that we've started a new process. */ + init_wait_for_inferior (); + + /* Set up the "saved terminal modes" of the inferior + based on what modes we are starting it with. */ + target_terminal_init (); + + /* Install inferior's terminal modes. */ + target_terminal_inferior (); + + /* insert_step_breakpoint (); FIXME, do we need this? */ + proceed ((CORE_ADDR) entry_pt, -1, 0); /* Let 'er rip... */ +} + +/* Open a connection to a remote debugger. + NAME is the filename used for communication. */ + +static int baudrate = 9600; +static char dev_name[100]; + +static char *machine = ""; +static char *user = ""; +static char *passwd = ""; +static char *dir = ""; + +/* Grab the next token and buy some space for it */ +static char * +next (ptr) + char **ptr; +{ + char *p = *ptr; + char *s; + char *r; + int l = 0; + while (*p && *p == ' ') + { + p++; + } + s = p; + while (*p && (*p != ' ' && *p != '\t')) + { + l++; + p++; + } + r = xmalloc (l + 1); + memcpy (r, s, l); + r[l] = 0; + *ptr = p; + return r; +} + +static +e7000_login (args, from_tty) + char *args; + int from_tty; +{ + if (args) + { + machine = next (&args); + user = next (&args); + passwd = next (&args); + dir = next (&args); + if (from_tty) + { + printf ("Set info to %s %s %s %s\n", machine, user, passwd, dir); + } + } + else + { + error ("Syntax is ftplogin <machine> <user> <passwd> <directory>"); + } +} + +/* Start an ftp transfer from the E7000 to a host */ + +static +e7000_ftp (args, from_tty) + char *args; + int from_tty; +{ + int oldtimeout = timeout; + timeout = 10; + echo_index++; + printf_e7000debug ("ftp %s\r", machine); + expect (" Username : "); + printf_e7000debug ("%s\r", user); + expect (" Password : "); + write_e7000 (passwd); + write_e7000 ("\r"); + expect ("success\r"); + expect ("FTP>"); + printf_e7000debug ("cd %s\r", dir); + expect ("FTP>"); + printf_e7000debug ("ll 0;s:%s\r", args); + expect ("FTP>"); + printf_e7000debug ("bye\r"); + expect (":"); + echo_index--; + timeout = oldtimeout; +} + +static void +e7000_open (args, from_tty) + char *args; + int from_tty; +{ + int n; + char junk[100]; + int sync; + target_preopen (from_tty); + + if (args) + n = sscanf (args, " %s %d %s", dev_name, &baudrate, junk); + else + n = 0; + if (n != 1 && n != 2) + error ("Bad arguments. Usage:\ttarget e7000 <device> <speed>\n\ +or \t\ttarget e7000 <host>[:<port>]\n"); + + if (n == 1 && strchr (dev_name, ':') == 0) + { + /* Default to normal telnet port */ + strcat (dev_name, ":23"); + } + + push_target (&e7000_ops); + e7000_desc = SERIAL_OPEN (dev_name); + + + if (!e7000_desc) + perror_with_name (dev_name); + + using_tcp = strcmp (e7000_desc->ops->name, "tcp") == 0; + + SERIAL_SETBAUDRATE (e7000_desc, baudrate); + SERIAL_RAW (e7000_desc); + + /* Hello? Are you there? */ + sync = 0; + while (!sync) + { + int c; + if (from_tty) + printf_unfiltered ("[waiting for e7000...]\n"); + write_e7000 ("\r\n"); + c = SERIAL_READCHAR (e7000_desc, 3); + while (c != SERIAL_TIMEOUT) + { + /* Dont echo cr's */ + if (from_tty && c != '\r') + { + putchar (c); + fflush (stdout); + } + if (c == ':') + { + sync = 1; + } + c = SERIAL_READCHAR (e7000_desc, 3); + if (quit_flag) + { + putchar_e7000 (CTRLC); + quit_flag = 0; + } + } + } + printf_e7000debug ("\r\n"); + expect_prompt (); + + if (from_tty) + printf_filtered ("Remote %s connected to %s\n", target_shortname, + dev_name); + +} + +/* Close out all files and local state before this target loses control. */ + +static void +e7000_close (quitting) + int quitting; +{ + if (e7000_desc) + { + SERIAL_CLOSE (e7000_desc); + e7000_desc = 0; + } +} + +/* Terminate the open connection to the remote debugger. + Use this when you want to detach and do something else + with your gdb. */ +static void +e7000_detach (from_tty) + int from_tty; +{ + pop_target (); /* calls e7000_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 +e7000_resume (pid, step, sig) + int pid, step, sig; +{ + if (step) + { + printf_e7000debug ("S\r"); + } + else + { + printf_e7000debug ("G\r"); + } +} + +/* Read the remote registers into the block REGS. + + A reg dump looks like: + + */ + +#ifdef GDB_TARGET_IS_H8300 +char *want = "\n\ + PC=%p CCR=%c\n\ + ER0 - ER3 %0 %1 %2 %3\n\ + ER4 - ER7 %4 %5 %6 %7\n\ +:"; + +#endif +#ifdef GDB_TARGET_IS_SH +char *want = "\n\PC=%16 SR=%22\n\ + PR=%17 GBR=%18 VBR=%19\n\ + MACH=%20 MACL=%21\n\ + R0-7 %0 %1 %2 %3 %4 %5 %6 %7\n\ + R8-15 %8 %9 %10 %11 %12 %13 %14 %15\n\ +:"; + +char *want_nopc = "%16 SR=%22\n\ + PR=%17 GBR=%18 VBR=%19\n\ + MACH=%20 MACL=%21\n\ + R0-7 %0 %1 %2 %3 %4 %5 %6 %7\n\ + R8-15 %8 %9 %10 %11 %12 %13 %14 %15"; + + +#endif + +static +int +gch () +{ + int c = readchar (timeout); + if (echo) + { + if (c >= ' ') + printf ("%c", c); + else if (c == '\n') + printf ("\n", c); + } + return c; +} + + +static +unsigned int +gbyte () +{ + int high = get_hex_digit (gch ()); + int low = get_hex_digit (gch ()); + return (high << 4) + low; +} + +void +fetch_regs_from_dump (nextchar, want) + int (*nextchar)(); + char *want; +{ + int regno; + char buf[MAX_REGISTER_RAW_SIZE]; + + int thischar = nextchar(); + + while (*want) + { + switch (*want) + { + case '\n': + while (thischar != '\n') + thischar = nextchar(); + thischar = nextchar(); + while (thischar == '\r') + thischar = nextchar(); + want++; + break; + + case ' ': + while (thischar == ' ' || thischar == '\t') + thischar = nextchar(); + want++; + break; + + default: + if (*want == thischar) + { + want++; + if (*want) + thischar = nextchar(); + + } + else if (thischar == ' ') + { + thischar = nextchar(); + } + else { + error("out of sync in fetch registers"); + } + + break; + case '%': + /* Got a register command */ + want++; + switch (*want) + { +#ifdef PC_REGNUM + case 'p': + regno = PC_REGNUM; + want++; + break; +#endif +#ifdef CCR_REGNUM + case 'c': + regno = CCR_REGNUM; + want++; + break; +#endif +#ifdef SP_REGNUM + case 's': + regno = SP_REGNUM; + want++; + break; +#endif +#ifdef FP_REGNUM + case 'f': + regno = FP_REGNUM; + want++; + break; +#endif + + + default: + if (isdigit(want[0])) + { + if (isdigit(want[1])) + { + regno = (want[0] - '0') * 10 + want[1] - '0'; + want+=2; + } + else + { + regno = want[0] - '0'; + want++; + } + } + + else + abort(); + } + store_signed_integer (buf, + REGISTER_RAW_SIZE(regno), + (LONGEST)get_hex(&thischar, nextchar)); + supply_register (regno, buf); + break; + } + } +} + +static void +e7000_fetch_registers () +{ + int regno; + + printf_e7000debug ("R\r"); + fetch_regs_from_dump (gch, want); + + /* And supply the extra ones the simulator uses */ + for (regno = NUM_REALREGS; regno < NUM_REGS; regno++) + { + int buf = 0; + supply_register (regno, (char *) (&buf)); + } +} + +/* Fetch register REGNO, or all registers if REGNO is -1. + Returns errno value. */ + +static +void +e7000_fetch_register (regno) + int regno; +{ + e7000_fetch_registers (); +} + +/* Store the remote registers from the contents of the block REGS. */ + +static void +e7000_store_registers () +{ + int regno; + + for (regno = 0; regno < NUM_REALREGS; regno++) + e7000_store_register (regno); + + registers_changed (); +} + +/* Store register REGNO, or all if REGNO == 0. + Return errno value. */ +static void +e7000_store_register (regno) + int regno; +{ + if (regno == -1) + { + e7000_store_registers (); + return; + } +#ifdef GDB_TARGET_IS_H8300 + if (regno <= 7) + { + printf_e7000debug (".ER%d %x\r", regno, + read_register (regno)); + + } + else if (regno == PC_REGNUM) + { + printf_e7000debug (".PC %x\r", + read_register (regno)); + } + else if (regno == CCR_REGNUM) + { + printf_e7000debug (".CCR %x\r", + read_register (regno)); + } +#endif + +#ifdef GDB_TARGET_IS_SH + switch (regno) + { + default: + printf_e7000debug (".R%d %x\r", regno, + read_register (regno)); + + break; + case PC_REGNUM: + printf_e7000debug (".PC %x\r", + read_register (regno)); + break; + case SR_REGNUM: + printf_e7000debug (".SR %x\r", + read_register (regno)); + break; + + case PR_REGNUM: + printf_e7000debug (".PR %x\r", + read_register (regno)); + break; + + case GBR_REGNUM: + printf_e7000debug (".GBR %x\r", + read_register (regno)); + break; + + case VBR_REGNUM: + printf_e7000debug (".VBR %x\r", + read_register (regno)); + break; + + case MACH_REGNUM: + printf_e7000debug (".MACH %x\r", + read_register (regno)); + break; + + case MACL_REGNUM: + printf_e7000debug (".MACL %x\r", + read_register (regno)); + break; + } + +#endif + expect_prompt (); +} + +/* Get ready to modify the registers array. On machines which store + individual registers, this doesn't need to do anything. On machines + which store all the registers in one fell swoop, this makes sure + that registers contains all the registers from the program being + debugged. */ + +static void +e7000_prepare_to_store () +{ + /* Do nothing, since we can store individual regs */ +} + +static void +e7000_files_info () +{ + printf ("\tAttached to %s at %d baud.\n", + dev_name, baudrate); +} + +static +int +stickbyte (where, what) + char *where; + unsigned int what; +{ + static CONST char digs[] = "0123456789ABCDEF"; + where[0] = digs[(what >> 4) & 0xf]; + where[1] = digs[(what & 0xf) & 0xf]; + return what; +} + +/* Write a small ammount of memory */ +static int +write_small (memaddr, myaddr, len) + CORE_ADDR memaddr; + unsigned char *myaddr; + int len; +{ + int i; + for (i = 0; i < len; i++) + { + if (((memaddr + i) & 3) == 0 + && (i + 3 < len)) + { + /* Can be done with a long word */ + printf_e7000debug ("m %x %x%02x%02x%02x;l\r", + memaddr + i, + myaddr[i], + myaddr[i + 1], + myaddr[i + 2], + myaddr[i + 3]); + i += 3; + } + else + { + printf_e7000debug ("m %x %x\r", memaddr + i, myaddr[i]); + } + } + expect_prompt (); + return len; +} +/* Write a large ammount of memory, this only works with the serial mode enabled. + Command is sent as + il ;s:s\r -> + <- il ;s:s\r + <- ENQ + ACK -> + <- LO s\r + Srecords... + ^Z -> + <- ENQ + ACK -> + <- : + */ + +static int +write_large (memaddr, myaddr, len) + CORE_ADDR memaddr; + unsigned char *myaddr; + int len; +{ + int i; +#define maxstride 128 + int stride; + + printf_e7000debug ("il ;s:s\r"); + expect (ENQSTRING); + putchar_e7000 (ACK); + expect ("LO s\r"); + + for (i = 0; i < len; i += stride) + { + char compose[maxstride * 2 + 50]; + int address = i + memaddr; + int j; + int check_sum; + int where = 0; + int alen; + stride = len - i; + if (stride > maxstride) + stride = maxstride; + + compose[where++] = 'S'; + check_sum = 0; + if (address >= 0xffffff) + { + alen = 4; + } + else if (address >= 0xffff) + { + alen = 3; + } + else + alen = 2; + compose[where++] = alen - 1 + '0'; /* insert type */ + check_sum += stickbyte (compose + where, alen + stride + 1); /* Insert length */ + where += 2; + while (alen > 0) + { + alen--; + check_sum += stickbyte (compose + where, address >> (8 * (alen))); + where += 2; + } + + for (j = 0; j < stride; j++) + { + check_sum += stickbyte (compose + where, myaddr[i + j]); + where += 2; + } + + stickbyte (compose + where, ~check_sum); + + where += 2; + compose[where++] = '\r'; + SERIAL_WRITE (e7000_desc, compose, where); + j = SERIAL_READCHAR (e7000_desc, 0); + if (j == SERIAL_TIMEOUT) + { + /* This is ok - nothing there */ + } + else if (j == ENQ) + { + /* Hmm, it's trying to tell us something */ + expect (":"); + error ("Error writing memory"); + } + else + { + printf ("Whats this %d\n", j); + } + + } + /* Send the trailer record */ + write_e7000 ("S70500000000FA\r"); + putchar_e7000 (CTRLZ); + expect (ENQSTRING); + putchar_e7000 (ACK); + expect (":"); + return len; +} + +/* Copy LEN bytes of data from debugger memory at MYADDR + to inferior's memory at MEMADDR. Returns length moved. + + Can't use the Srecord load over ethernet, so dont use + fast method then. + */ +static int +e7000_write_inferior_memory (memaddr, myaddr, len) + CORE_ADDR memaddr; + unsigned char *myaddr; + int len; +{ + if (len < 16 || using_tcp) + { + return write_small (memaddr, myaddr, len); + } + else + { + return write_large (memaddr, myaddr, len); + } +} + +/* Read LEN bytes from inferior memory at MEMADDR. Put the result + at debugger address MYADDR. Returns length moved. + + Done by requesting an srecord dump from the E7000. + */ + + + +/* Read LEN bytes from inferior memory at MEMADDR. Put the result + at debugger address MYADDR. Returns length moved. + + + Small transactions we send + m <addr>;l + and receive + 00000000 12345678 ? + + */ + +static int +e7000_read_inferior_memory (memaddr, myaddr, len) + CORE_ADDR memaddr; + unsigned char *myaddr; + int len; +{ + int count; + int c; + int i; + /* Starting address of this pass. */ + + if (((memaddr - 1) + len) < memaddr) + { + errno = EIO; + return 0; + } + + printf_e7000debug ("m %x;l\r", memaddr); + + for (count = 0; count < len; count += 4) + { + /* Suck away the address */ + c = gch(); + while (c != ' ') + c = gch(); + c = gch(); + if (c == '*') + { /* Some kind of error */ + expect_prompt(); + return -1; + } + while (c != ' ') + c = gch(); + + /* Now read in the data */ + for (i = 0; i < 4; i++) + { + int b = gbyte(); + if (count + i < len) { + myaddr[count + i] = b; + } + } + + /* Skip the trailing ? and send a . to end and a cr for more */ + gch(); + gch(); + if (count + 4 >= len) + printf_e7000debug(".\r"); + else + printf_e7000debug("\r"); + } + expect_prompt(); +} + + +#if 0 +/* + For large transfers we used to send + + + d <addr> <endaddr>\r + + and receive + <ADDR> < D A T A > < ASCII CODE > + 000000 5F FD FD FF DF 7F DF FF 01 00 01 00 02 00 08 04 "_..............." + 000010 FF D7 FF 7F D7 F1 7F FF 00 05 00 00 08 00 40 00 "..............@." + 000020 7F FD FF F7 7F FF FF F7 00 00 00 00 00 00 00 00 "................" + + A cost in chars for each transaction of 80 + 5*n-bytes. + + + Large transactions could be done with the srecord load code, but + there is a pause for a second before dumping starts, which slows the + average rate down! +*/ + +static int +e7000_read_inferior_memory (memaddr, myaddr, len) + CORE_ADDR memaddr; + unsigned char *myaddr; + int len; +{ + int count; + int c; + + /* Starting address of this pass. */ + + if (((memaddr - 1) + len) < memaddr) + { + errno = EIO; + return 0; + } + + printf_e7000debug ("d %x %x\r", memaddr, memaddr + len - 1); + + count = 0; + c = gch (); + + /* First skip the command */ + while (c == '\n') + c = gch (); + + while (c == ' ') + c = gch (); + if (c == '*') + { + expect ("\r"); + return -1; + } + + /* Skip the title line */ + while (c != '\n') + c = gch (); + c = gch (); + while (count < len) + { + /* Skip the address */ + while (c <= ' ') + c = gch (); + + get_hex (&c); + + /* read in the bytes on the line */ + while (c != '"' && count < len) + { + if (c == ' ') + c = gch (); + else + { + myaddr[count++] = get_hex (&c); + } + } + + while (c != '\n') + c = gch (); + } + + while (c != ':') + c = gch (); + + return len; +} + +static int +fast_but_for_the_pause_e7000_read_inferior_memory (memaddr, myaddr, len) + CORE_ADDR memaddr; + char *myaddr; + int len; +{ + int loop; + int c; + + if (((memaddr - 1) + len) < memaddr) + { + errno = EIO; + return 0; + } + + printf_e7000debug ("is %x@%x:s\r", memaddr, len); + gch (); + c = gch (); + if (c != ENQ) + { + /* Got an error */ + error ("Memory read error"); + } + putchar_e7000 (ACK); + expect ("SV s"); + loop = 1; + while (loop) + { + int type; + int length; + int addr; + int i; + c = gch (); + switch (c) + { + case ENQ: /* ENQ, at the end */ + loop = 0; + break; + case 'S': + /* Start of an Srecord */ + type = gch (); + length = gbyte (); + switch (type) + { + case '7': /* Termination record, ignore */ + case '0': + case '8': + case '9': + /* Header record - ignore it */ + while (length--) + { + gbyte (); + } + break; + case '1': + case '2': + case '3': + { + int alen; + alen = type - '0' + 1; + addr = 0; + while (alen--) + { + addr = (addr << 8) + gbyte (); + length--; + } + + for (i = 0; i < length - 1; i++) + { + myaddr[i + addr - memaddr] = gbyte (); + } + gbyte (); /* Ignore checksum */ + } + } + } + } + putchar_e7000 (ACK); + expect ("TOP ADDRESS ="); + expect ("END ADDRESS ="); + expect (":"); + + return len; +} + +#endif + +static int +e7000_xfer_inferior_memory (memaddr, myaddr, len, write, target) + CORE_ADDR memaddr; + unsigned char *myaddr; + int len; + int write; + struct target_ops *target; /* ignored */ +{ + if (write) + { + return e7000_write_inferior_memory( memaddr, myaddr, len); + } + else + { + return e7000_read_inferior_memory( memaddr, myaddr, len); + } +} + +static void +e7000_kill (args, from_tty) + char *args; + int from_tty; +{ + +} + +/* Clean up when a program exits. + + The program actually lives on in the remote processor's RAM, and may be + run again without a download. Don't leave it full of breakpoint + instructions. */ + +static void +e7000_mourn_inferior () +{ + remove_breakpoints (); + unpush_target (&e7000_ops); + generic_mourn_inferior (); /* Do all the proper things now */ +} + +#define MAX_E7000DEBUG_BREAKPOINTS 200 + +extern int memory_breakpoint_size; +static CORE_ADDR breakaddr[MAX_E7000DEBUG_BREAKPOINTS] = +{0}; + +static int +e7000_insert_breakpoint (addr, shadow) + CORE_ADDR addr; + unsigned char *shadow; +{ + int i; + static char nop[2] = + {0x20, 0x0b}; + + for (i = 0; i <= MAX_E7000DEBUG_BREAKPOINTS; i++) + if (breakaddr[i] == 0) + { + breakaddr[i] = addr; + /* Save old contents, and insert a nop in the space */ + e7000_read_inferior_memory (addr, shadow, 2); + e7000_write_inferior_memory (addr, nop, 2); + printf_e7000debug ("B %x\r", addr); + expect_prompt (); + return 0; + } + + error("Too many breakpoints ( > %d) for the E7000\n", MAX_E7000DEBUG_BREAKPOINTS); + return 1; +} + +static int +e7000_remove_breakpoint (addr, shadow) + CORE_ADDR addr; + unsigned char *shadow; +{ + int i; + + for (i = 0; i < MAX_E7000DEBUG_BREAKPOINTS; i++) + if (breakaddr[i] == addr) + { + breakaddr[i] = 0; + printf_e7000debug ("B - %x\r", addr); + expect_prompt (); + /* Replace the insn under the break */ + e7000_write_inferior_memory (addr, shadow, 2); + return 0; + } + + fprintf (stderr, "Can't find breakpoint associated with 0x%x\n", addr); + return 1; +} + + +/* Put a command string, in args, out to STDBUG. Output from STDBUG is placed + on the users terminal until the prompt is seen. */ + +static void +e7000_command (args, fromtty) + char *args; + int fromtty; +{ + + if (!e7000_desc) + error ("e7000 target not open."); + if (!args) + { + printf_e7000debug ("\r"); + } + else + { + printf_e7000debug ("%s\r", args); + } + echo_index++; + expect_full_prompt (); + echo_index--; + printf_unfiltered ("\n"); +} + +static void +e7000_load (args, fromtty) + char *args; + int fromtty; +{ + load_target_image (args, fromtty); +} + +static void +e7000_drain (args, fromtty) + char *args; + int fromtty; + +{ + int c; + + while ((c = SERIAL_READCHAR (e7000_desc, 2) != SERIAL_TIMEOUT)) + { + if (c > ' ' && c < 127) + printf ("%c", c & 0xff); + else + printf ("<%x>", c & 0xff); + } +} + +e7000_noecho () +{ + echo = !echo; +} + +/* Wait until the remote machine stops, then return, + storing status in STATUS just as `wait' would. */ + +static int +e7000_wait (pid, status) + int pid; + WAITTYPE *status; +{ + int c; + int regno; + int loop = 1; + int time = 0; + WSETSTOP ((*status), 0); + /* Then echo chars until PC= string seen */ + gch (); /* Drop cr */ + gch (); /* and space */ + while (loop) + { + c = SERIAL_READCHAR (e7000_desc, 1); + if (c < 0) + { + time++; + if (time == 5) + { + printf_unfiltered ("[waiting for e7000..]\n"); + time = 0; + } + } + if (quit_flag) + { + quit_flag = 0; + putchar_e7000 (CTRLC); /* interrupt the running program */ + } + if (c == 'P') + { + c = SERIAL_READCHAR (e7000_desc, 1); + if (c == 'C') + { + c = SERIAL_READCHAR (e7000_desc, 1); + if (c == '=') + { + /* Got break */ + loop = 0; + } + else + { + printf ("PC"); + } + } + else + { + printf ("P"); + } + } + else + { + if (c > 0) + { + putchar (c); + fflush (stdout); + } + } + } + fetch_regs_from_dump (gch, want_nopc); + + /* And supply the extra ones the simulator uses */ + for (regno = NUM_REALREGS; regno < NUM_REGS; regno++) + { + int buf = 0; + supply_register (regno, (char *) &buf); + } + + expect_full_prompt (); + WSETSTOP ((*status), SIGTRAP); + + return 0; +} + +/* Define the target subroutine names */ + +struct target_ops e7000_ops = +{ + "e7000", + "Remote Hitachi e7000 target", + "Use a remote Hitachi e7000 ICE connected by a serial line,\n\ +or a network connection.\n\ +Arguments are the name of the device for the serial line,\n\ +the speed to connect at in bits per second.\n\ +eg\n\ +target e7000 /dev/ttya 9600\n\ +target e7000 foobar", + e7000_open, + e7000_close, + 0, + e7000_detach, + e7000_resume, + e7000_wait, + e7000_fetch_register, + e7000_store_register, + e7000_prepare_to_store, + e7000_xfer_inferior_memory, + e7000_files_info, + e7000_insert_breakpoint, + e7000_remove_breakpoint, /* Breakpoints */ + 0, + 0, + 0, + 0, + 0, /* Terminal handling */ + e7000_kill, + e7000_load, /* load */ + 0, /* lookup_symbol */ + e7000_create_inferior, + e7000_mourn_inferior, + 0, /* can_run */ + 0, /* notice_signals */ + process_stratum, + 0, /* next */ + 1, + 1, + 1, + 1, + 1, /* all mem, mem, stack, regs, exec */ + 0, + 0, /* Section pointers */ + OPS_MAGIC, /* Always the last thing */ +}; + +void +_initialize_remote_e7000 () +{ + add_target (&e7000_ops); + add_com ("e7000 <command>", class_obscure, e7000_command, + "Send a command to the e7000 monitor."); + + add_com ("ftplogin <machine> <name> <passwd> <dir>", class_obscure, e7000_login, + "Login to machine and change to directory."); + + add_com ("ftpload <file>", class_obscure, e7000_ftp, + "Fetch and load a file from previously described place."); + + add_com ("drain", class_obscure, e7000_drain, + "Drain pending e7000 text buffers."); + add_com ("echo", class_obscure, e7000_noecho, "Toggle monitor echo."); + +} diff --git a/gdb/remote-z8k.c b/gdb/remote-z8k.c index ff076ade709..9dea12fafaf 100644 --- a/gdb/remote-z8k.c +++ b/gdb/remote-z8k.c @@ -38,11 +38,12 @@ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ extern int stop_soon_quietly; /* for wait_for_inferior */ /* Forward data declarations */ -extern struct target_ops sim_ops; /* Forward declaration */ +/*extern struct target_ops sim_ops; /* Forward declaration */ void sim_store_register (); void sim_set_oc (); +int inferior_pid; int sim_write_inferior_memory (memaddr, myaddr, len) CORE_ADDR memaddr; @@ -75,14 +76,13 @@ sim_kill (arg, from_tty) char *arg; int from_tty; { - } /* * Download a file specified in 'args', to the sim. */ static void -sim_load (args, fromtty) +sasassim_load (args, fromtty) char *args; int fromtty; { @@ -160,7 +160,7 @@ sim_create_inferior (execfile, args, env) insert_breakpoints (); proceed (entry_pt, -1, 0); } - +#if 0 static void sim_open (name, from_tty) char *name; @@ -203,21 +203,21 @@ sim_detach (args, from_tty) if (from_tty) printf_filtered ("Ending remote %s debugging\n", target_shortname); } - +#endif /* Tell the remote machine to resume. */ /* Wait until the remote machine stops, then return, storing status in STATUS just as `wait' would. */ - +#if 0 int sim_wait (pid, status) int pid; WAITTYPE *status; { - *status = sim_stop_signal (); - return 0; + sim_stop_reason (&reason, &sigrc); + return inferior_pid; } - +#endif /* Get ready to modify the registers array. On machines which store individual registers, this doesn't need to do anything. On machines which store all the registers in one fell swoop, this makes sure @@ -295,12 +295,14 @@ sim_files_info () target specified yet, this will loop prompting the user to do so. */ +#if 0 void sim_before_main_loop () { push_target (&sim_ops); } + /* Clear the sims notion of what the break points are */ static void sim_mourn () @@ -309,7 +311,7 @@ sim_mourn () unpush_target (&sim_ops); generic_mourn_inferior (); } - +#endif static void rem_resume (pid, a, b) int pid; @@ -319,8 +321,9 @@ rem_resume (pid, a, b) sim_resume (a, b); } -/* Define the target subroutine names */ +/* Define the target subroutine names */ +#if 0 struct target_ops sim_ops = { "sim", "Remote SIM monitor", @@ -351,9 +354,6 @@ struct target_ops sim_ops = void _initialize_remote_sim () { - extern int sim_z8001_mode; - - sim_z8001_mode = z8001_mode; add_target (&sim_ops); - } +#endif |