--- /dev/null
+/* Remote debugging interface for HMS Monitor Version 1.0
+
+ Copyright 1992 Free Software Foundation, Inc.
+
+ Contributed by Steve Chamberlain sac@cygnus.com
+
+
+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 <stdio.h>
+#include <string.h>
+#include "defs.h"
+#include "inferior.h"
+#include "wait.h"
+#include "value.h"
+#include <ctype.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <setjmp.h>
+#include <errno.h>
+#include "terminal.h"
+#include "target.h"
+#include "gdbcore.h"
+
+/* External data declarations */
+extern int stop_soon_quietly; /* for wait_for_inferior */
+
+/* External function declarations */
+extern struct value *call_function_by_hand();
+
+/* Forward data declarations */
+extern struct target_ops hms_ops; /* Forward declaration */
+
+/* Forward function declarations */
+static void hms_fetch_registers ();
+static int hms_store_registers ();
+static void hms_close ();
+static int hms_clear_breakpoints();
+
+extern struct target_ops hms_ops;
+
+#define DEBUG
+#ifdef DEBUG
+# define DENTER(NAME) (printf_filtered("Entering %s\n",NAME), fflush(stdout))
+# define DEXIT(NAME) (printf_filtered("Exiting %s\n",NAME), fflush(stdout))
+#else
+# define DENTER(NAME)
+# define DEXIT(NAME)
+#endif
+
+
+
+static int timeout = 5;
+static char *dev_name = "/dev/ttya";
+
+
+static int quiet;
+
+/* Descriptor for I/O to remote machine. Initialize it to -1 so that
+ hms_open knows that we don't have a file open when the program
+ starts. */
+int hms_desc = -1;
+#define OPEN(x) ((x) >= 0)
+
+
+#define ON 1
+#define OFF 0
+static void
+rawmode(desc, turnon)
+int desc;
+int turnon;
+{
+ TERMINAL sg;
+
+ if (desc < 0)
+ return;
+
+ ioctl (desc, TIOCGETP, &sg);
+
+ if (turnon) {
+#ifdef HAVE_TERMIO
+ sg.c_lflag &= ~(ICANON);
+#else
+ sg.sg_flags |= RAW;
+#endif
+ } else {
+#ifdef HAVE_TERMIO
+ sg.c_lflag |= ICANON;
+#else
+ sg.sg_flags &= ~(RAW);
+#endif
+ }
+ ioctl (desc, TIOCSETP, &sg);
+}
+
+/* Suck up all the input from the hms */
+slurp_input()
+{
+ char buf[8];
+
+#ifdef HAVE_TERMIO
+ /* termio does the timeout for us. */
+ while (read (hms_desc, buf, 8) > 0);
+#else
+ alarm (timeout);
+ while (read (hms_desc, buf, 8) > 0);
+ alarm (0);
+#endif
+}
+
+/* Read a character from the remote system, doing all the fancy
+ timeout stuff. */
+static int
+readchar ()
+{
+ char buf;
+
+ buf = '\0';
+#ifdef HAVE_TERMIO
+ /* termio does the timeout for us. */
+ read (hms_desc, &buf, 1);
+#else
+ alarm (timeout);
+ if (read (hms_desc, &buf, 1) < 0)
+ {
+ if (errno == EINTR)
+ error ("Timeout reading from remote system.");
+ else
+ perror_with_name ("remote");
+ }
+ alarm (0);
+#endif
+
+ if (buf == '\0')
+ error ("Timeout reading from remote system.");
+
+if (!quiet)
+ printf("'%c'",buf);
+
+ return buf & 0x7f;
+}
+
+/* Keep discarding input from the remote system, until STRING is found.
+ Let the user break out immediately. */
+static void
+expect (string)
+ char *string;
+{
+ char *p = string;
+
+
+ immediate_quit = 1;
+ while (1)
+ {
+ if (readchar() == *p)
+ {
+ p++;
+ if (*p == '\0')
+ {
+ immediate_quit = 0;
+ return;
+ }
+ }
+ else
+ p = string;
+ }
+}
+
+/* Keep discarding input until we see the hms 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: hms_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 hms_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 ()
+{
+
+ expect ("HMS>");
+}
+
+/* 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;
+{
+ int ch;
+ while (1)
+ {
+ ch = readchar ();
+ 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;
+ else if (ch == ' ' && ignore_space)
+ ;
+ else
+ {
+ expect_prompt ();
+ error ("Invalid hex digit from remote system.");
+ }
+ }
+}
+
+/* Get a byte from hms_desc and put it in *BYT. Accept any number
+ leading spaces. */
+static void
+get_hex_byte (byt)
+ char *byt;
+{
+ int val;
+
+ val = get_hex_digit (1) << 4;
+ val |= get_hex_digit (0);
+ *byt = val;
+}
+
+/* Read a 32-bit hex word from the hms, preceded by a space */
+static long
+get_hex_word()
+{
+ long val;
+ int j;
+
+ val = 0;
+ for (j = 0; j < 8; j++)
+ val = (val << 4) + get_hex_digit (j == 0);
+ return val;
+}
+/* Called when SIGALRM signal sent due to alarm() timeout. */
+#ifndef HAVE_TERMIO
+
+#ifndef __STDC__
+# ifndef volatile
+# define volatile /**/
+# endif
+#endif
+volatile int n_alarms;
+
+void
+hms_timer ()
+{
+#if 0
+ if (kiodebug)
+ printf ("hms_timer called\n");
+#endif
+ n_alarms++;
+}
+#endif
+
+/* malloc'd name of the program on the remote system. */
+static char *prog_name = NULL;
+
+/* Number of SIGTRAPs we need to simulate. That is, the next
+ NEED_ARTIFICIAL_TRAP calls to hms_wait should just return
+ SIGTRAP without actually waiting for anything. */
+
+static int need_artificial_trap = 0;
+
+void
+hms_kill(arg,from_tty)
+char *arg;
+int from_tty;
+{
+#if 0
+ DENTER("hms_kill()");
+ fprintf (hms_stream, "K");
+
+ fprintf (hms_stream, "\r");
+ expect_prompt ();
+ DEXIT("hms_kill()");
+#endif
+}
+/*
+ * Download a file specified in 'args', to the hms.
+ */
+static void
+hms_load(args,fromtty)
+char *args;
+int fromtty;
+{
+ bfd *abfd;
+ asection *s;
+ int n;
+ char buffer[1024];
+
+ DENTER("hms_load()");
+ if (!OPEN(hms_desc))
+ {
+ printf_filtered("HMS not open. Use 'target' command to open HMS\n");
+ return;
+ }
+ abfd = bfd_openr(args,"coff-h8300");
+ if (!abfd)
+ {
+ printf_filtered("Can't open a bfd on file\n");
+ return;
+ }
+
+ if (bfd_check_format(abfd, bfd_object) ==0)
+ {
+ printf_filtered("File is not an object file\n");
+ return ;
+ }
+
+ s = abfd->sections;
+ while (s != (asection *)NULL)
+ {
+ if (s->flags & SEC_LOAD)
+ {
+ char *buffer = xmalloc(s->_raw_size);
+ bfd_get_section_contents(abfd, s, buffer, 0, s->_raw_size);
+
+ hms_write_inferior_memory(s->vma, buffer, s->_raw_size);
+ free(buffer);
+ }
+ s = s->next;
+ }
+
+ DEXIT("hms_load()");
+}
+
+/* This is called not only when we first attach, but also when the
+ user types "run" after having attached. */
+void
+hms_create_inferior (execfile, args, env)
+ char *execfile;
+ char *args;
+ char **env;
+{
+ int entry_pt;
+
+ DENTER("hms_create_inferior()");
+
+ if (args && *args)
+ error ("Can't pass arguments to remote hms process.");
+
+ if (execfile == 0 || exec_bfd == 0)
+ error ("No exec file specified");
+
+ entry_pt = (int) bfd_get_start_address (exec_bfd);
+
+ if (OPEN(hms_desc))
+ {
+
+ hms_kill(NULL,NULL);
+ hms_clear_breakpoints();
+ init_wait_for_inferior ();
+ /* Clear the input because what the hms sends back is different
+ * depending on whether it was running or not.
+ */
+ /* slurp_input(); /* After this there should be a prompt */
+ hms_write_cr("r");
+
+ expect_prompt();
+ printf_filtered("Do you want to download '%s' (y/n)? [y] : ",prog_name);
+ {
+ char buffer[10];
+ gets(buffer);
+ if (*buffer != 'n') {
+ hms_load(prog_name,0);
+ }
+ }
+
+
+ insert_breakpoints (); /* Needed to get correct instruction in cache */
+ proceed(entry_pt, -1, 0);
+
+
+ } else
+ {
+ printf_filtered("Hms not open yet.\n");
+ }
+ DEXIT("hms_create_inferior()");
+}
+
+/* Translate baud rates from integers to damn B_codes. Unix should
+ have outgrown this crap years ago, but even POSIX wouldn't buck it. */
+
+#ifndef B19200
+#define B19200 EXTA
+#endif
+#ifndef B38400
+#define B38400 EXTB
+#endif
+
+static struct {int rate, damn_b;} baudtab[] = {
+ {0, B0},
+ {50, B50},
+ {75, B75},
+ {110, B110},
+ {134, B134},
+ {150, B150},
+ {200, B200},
+ {300, B300},
+ {600, B600},
+ {1200, B1200},
+ {1800, B1800},
+ {2400, B2400},
+ {4800, B4800},
+ {9600, B9600},
+ {19200, B19200},
+ {38400, B38400},
+ {-1, -1},
+};
+
+static int damn_b (rate)
+ int rate;
+{
+ int i;
+
+ for (i = 0; baudtab[i].rate != -1; i++)
+ if (rate == baudtab[i].rate) return baudtab[i].damn_b;
+ return B38400; /* Random */
+}
+
+
+/* Open a connection to a remote debugger.
+ NAME is the filename used for communication, then a space,
+ then the baud rate.
+ */
+
+static char *
+find_end_of_word(s)
+char *s;
+{
+ while (*s && !isspace(*s))
+ s++;
+ return s;
+}
+
+static char *get_word(p)
+char **p;
+{
+ char *s = *p;
+ char *word ;
+ char *copy;
+ size_t len;
+
+ while (isspace(*s))
+ s++;
+
+ word = s;
+
+ len = 0;
+
+ while (*s && !isspace(*s))
+ {
+ s++;
+ len++;
+
+ }
+ copy = xmalloc(len+1);
+ memcpy(copy, word, len);
+ copy[len] = 0;
+ *p = s;
+ return copy;
+}
+
+static int baudrate = 9600;
+static void
+hms_open (name, from_tty)
+ char *name;
+ int from_tty;
+{
+ TERMINAL sg;
+ unsigned int prl;
+ char *p;
+
+ DENTER("hms_open()");
+ if(name == 0)
+ {
+ name = "";
+
+ }
+
+ printf("Input string %s\n", name);
+
+ prog_name = get_word(&name);
+
+ hms_close (0);
+
+ hms_desc = open (dev_name, O_RDWR);
+ if (hms_desc < 0)
+ perror_with_name (dev_name);
+ ioctl (hms_desc, TIOCGETP, &sg);
+#ifdef HAVE_TERMIO
+ sg.c_cc[VMIN] = 0; /* read with timeout. */
+ sg.c_cc[VTIME] = timeout * 10;
+ sg.c_lflag &= ~(ICANON | ECHO);
+ sg.c_cflag = (sg.c_cflag & ~CBAUD) | damn_b (baudrate);
+#else
+ sg.sg_ispeed = damn_b (baudrate);
+ sg.sg_ospeed = damn_b (baudrate);
+ sg.sg_flags |= RAW | ANYP;
+ sg.sg_flags &= ~ECHO;
+#endif
+
+ ioctl (hms_desc, TIOCSETP, &sg);
+
+
+ push_target (&hms_ops);
+ /* start_remote (); /* Initialize gdb process mechanisms */
+
+
+#ifndef HAVE_TERMIO
+#ifndef NO_SIGINTERRUPT
+ /* Cause SIGALRM's to make reads fail with EINTR instead of resuming
+ the read. */
+ if (siginterrupt (SIGALRM, 1) != 0)
+ perror ("hms_open: error in siginterrupt");
+#endif
+
+ /* Set up read timeout timer. */
+ if ((void (*)) signal (SIGALRM, hms_timer) == (void (*)) -1)
+ perror ("hms_open: error in signal");
+#endif
+
+
+ /* Put this port into NORMAL mode, send the 'normal' character */
+ hms_write("\001", 1); /* Control A */
+ hms_write("\r", 1); /* Cr */
+ expect_prompt ();
+
+ /* Hello? Are you there? */
+ write (hms_desc, "\r", 1);
+
+ expect_prompt ();
+
+ /* Clear any break points */
+ hms_clear_breakpoints();
+
+
+ printf_filtered("Remote debugging on an H8/300 HMS via %s %s.\n",dev_name,prog_name);
+
+ DEXIT("hms_open()");
+}
+
+/* Close out all files and local state before this target loses control. */
+
+static void
+hms_close (quitting)
+ int quitting;
+{
+
+ DENTER("hms_close()");
+
+ /* Clear any break points */
+ hms_clear_breakpoints();
+
+ /* Put this port back into REMOTE mode */
+ if (OPEN(hms_desc)) {
+
+ sleep(1); /* Let any output make it all the way back */
+ write(hms_desc, "R\r", 2);
+ }
+
+ /* Due to a bug in Unix, fclose closes not only the stdio stream,
+ but also the file descriptor. So we don't actually close
+ hms_desc. */
+ if (OPEN(hms_desc))
+ close (hms_desc);
+
+ /* Do not try to close hms_desc again, later in the program. */
+
+ hms_desc = -1;
+
+ DEXIT("hms_close()");
+}
+
+/* Attach to the target that is already loaded and possibly running */
+static void
+hms_attach (args, from_tty)
+ char *args;
+ int from_tty;
+{
+
+ DENTER("hms_attach()");
+ if (from_tty)
+ printf_filtered ("Attaching to remote program %s.\n", prog_name);
+
+ /* push_target(&hms_ops); /* This done in hms_open() */
+
+ mark_breakpoints_out ();
+
+ /* Send the hms a kill. It is ok if it is not already running */
+#if 0
+ fprintf(hms_stream, "K\r");
+ expect_prompt(); /* Slurp the echo */
+#endif
+ /* We will get a task spawn event immediately. */
+ init_wait_for_inferior ();
+ clear_proceed_status ();
+ stop_soon_quietly = 1;
+ wait_for_inferior ();
+ stop_soon_quietly = 0;
+ normal_stop ();
+ DEXIT("hms_attach()");
+}
+
+
+/* Terminate the open connection to the remote debugger.
+ Use this when you want to detach and do something else
+ with your gdb. */
+void
+hms_detach (args,from_tty)
+ char *args;
+ int from_tty;
+{
+ DENTER("hms_detach()");
+ if (OPEN(hms_desc)) { /* Send it on its way (tell it to continue) */
+ hms_clear_breakpoints();
+#if 0
+ fprintf(hms_stream,"G\r");
+#endif
+ }
+
+ pop_target(); /* calls hms_close to do the real work */
+ if (from_tty)
+ printf_filtered ("Ending remote %s debugging\n", target_shortname);
+ DEXIT("hms_detach()");
+}
+
+/* Tell the remote machine to resume. */
+
+void
+hms_resume (step, sig)
+ int step, sig;
+{
+ DENTER("hms_resume()");
+ if (step)
+ {
+ hms_write_cr("s");
+
+ hms_write("\003",1);
+ expect_prompt();
+ /* Force the next hms_wait to return a trap. Not doing anything
+ about I/O from the target means that the user has to type
+ "continue" to see any. FIXME, this should be fixed. */
+ need_artificial_trap = 1;
+ }
+ else
+ {
+ hms_write_cr("g");
+ expect("g\r");
+ }
+ DEXIT("hms_resume()");
+}
+
+/* Wait until the remote machine stops, then return,
+ storing status in STATUS just as `wait' would. */
+
+int
+hms_wait (status)
+ WAITTYPE *status;
+{
+ /* Strings to look for. '?' means match any single character.
+ Note that with the algorithm we use, the initial character
+ of the string cannot recur in the string, or we will not
+ find some cases of the string in the input. */
+
+ static char bpt[] = "At breakpoint:";
+ /* It would be tempting to look for "\n[__exit + 0x8]\n"
+ but that requires loading symbols with "yc i" and even if
+ we did do that we don't know that the file has symbols. */
+ static char exitmsg[] = "HMS>";
+ char *bp = bpt;
+ char *ep = exitmsg;
+
+ /* Large enough for either sizeof (bpt) or sizeof (exitmsg) chars. */
+ char swallowed[50];
+ /* Current position in swallowed. */
+ char *swallowed_p = swallowed;
+
+ int ch;
+ int ch_handled;
+ int old_timeout = timeout;
+ int old_immediate_quit = immediate_quit;
+
+ DENTER("hms_wait()");
+
+ WSETEXIT ((*status), 0);
+
+ if (need_artificial_trap != 0)
+ {
+ WSETSTOP ((*status), SIGTRAP);
+ need_artificial_trap--;
+ return 0;
+ }
+
+ timeout = 0; /* Don't time out -- user program is running. */
+ immediate_quit = 1; /* Helps ability to QUIT */
+ while (1) {
+ QUIT; /* Let user quit and leave process running */
+ ch_handled = 0;
+ ch = readchar ();
+ if (ch == *bp) {
+ bp++;
+ if (*bp == '\0')
+ break;
+ ch_handled = 1;
+
+ *swallowed_p++ = ch;
+ } else
+ bp = bpt;
+ if (ch == *ep || *ep == '?') {
+ ep++;
+ if (*ep == '\0')
+ break;
+
+ if (!ch_handled)
+ *swallowed_p++ = ch;
+ ch_handled = 1;
+ }, sal.line);
+d979 3
+ if (!ch_handled) {
+ char *p;
+ /* Print out any characters which have been swallowed. */
+ for (p = swallowed; p < swallowed_p; ++p)
+ putc (*p, stdout);
+ swallowed_p = swallowed;
+
+
+ if ((ch != '\r' && ch != '\n') || swallowed_cr>10)
+ {
+ putc (ch, stdout);
+ swallowed_cr = 10;
+ }
+ swallowed_cr ++;
+
+ }
+ }
+ if (*bp== '\0')
+ {
+ WSETSTOP ((*status), SIGTRAP);
+ expect_prompt();
+ }
+ else
+ {
+ WSETEXIT ((*status), 0);
+ }
+
+ timeout = old_timeout;
+ immediate_quit = old_immediate_quit;
+ printf ("%s is at %s:%d.\n",
+ local_hex_string(sal.pc),
+ sal.symtab->filename, sal.line);
+ DEXIT("hms_wait()");
+ return 0;
+}
+
+/* Return the name of register number REGNO
+ in the form input and output by hms.
+
+ Returns a pointer to a static buffer containing the answer. */
+static char *
+get_reg_name (regno)
+ int regno;
+{
+static char *rn[NUM_REGS]= REGISTER_NAMES;
+
+
+ return rn[regno];
+
+}
+
+/* Read the remote registers. */
+static int gethex(length, start, ok)
+unsigned int length;
+char *start;
+int *ok;
+{
+ int result = 0;
+ while (length--)
+ {
+ result <<= 4 ;
+ if (*start >='a' && *start <= 'f')
+ {
+ result += *start - 'a' + 10;
+ }
+ else if (*start >='A' && *start <= 'F')
+ {
+ result += *start - 'A' + 10;
+ }
+ else if (*start >='0' && *start <= '9')
+ {
+ result += *start - '0' ;
+ }
+ else *ok = 0;
+ start++;
+
+ }
+ return result;
+}
+static int
+timed_read(buf, n, timeout)
+char *buf;
+
+{
+ int i;
+ char c;
+ i = 0;
+ while (i < n)
+ {
+ c = readchar();
+
+ if (c == 0) return i;
+ buf[i] = c;
+ i++;
+
+ }
+ return i;
+
+}
+hms_write(a,l)
+char *a;
+{
+ int i;
+ write(hms_desc,a,l);
+if (!quiet)
+ for (i = 0; i < l ; i++)
+ {
+ printf("%c", a[i]);
+ }
+}
+
+ printf ("Line %d of \"%s\" is at pc %s but contains no code.\n",
+ sal.line, sal.symtab->filename, local_hex_string(start_pc));
+{
+hms_write( s, strlen(s));
+ printf ("Line %d of \"%s\" starts at pc %s",
+ sal.line, sal.symtab->filename,
+ local_hex_string(start_pc));
+ printf (" and ends at %s.\n",
+ local_hex_string(end_pc));
+{
+#define REGREPLY_SIZE 79
+ char linebuf[REGREPLY_SIZE+1];
+ int i;
+ int s ;
+ int gottok;
+
+ printf ("Line number %d is out of range for \"%s\".\n",
+ sal.line, sal.symtab->filename);
+ check_open();
+
+ do
+ {
+
+ hms_write_cr("r");
+ s = timed_read(linebuf, REGREPLY_SIZE, 1);
+
+
+ linebuf[REGREPLY_SIZE] = 0;
+ gottok = 0;
+ if (linebuf[0] == 'r' &&
+ linebuf[1] == '\r' &&
+ linebuf[2] == '\n' &&
+ linebuf[3] == 'P' &&
+ linebuf[4] == 'C' &&
+ linebuf[5] == '=' &&
+ linebuf[75] == 'H' &&
+ linebuf[76] == 'M' &&
+ linebuf[77] == 'S')
+ {
+ /*
+ PC=XXXX CCR=XX:XXXXXXXX R0-R7= XXXX XXXX XXXX XXXX XXXX XXXX XXXX XXXX
+ 5436789012345678901234567890123456789012345678901234567890123456789012
+ 0 1 2 3 4 5 6
+ */
+ gottok = 1;
+
+ reg[PC_REGNUM] = gethex(4,linebuf+6, &gottok);
+ reg[CCR_REGNUM] = gethex(2,linebuf+15, &gottok);
+ for (i = 0; i < 8; i++)
+ {
+ reg[i] = gethex(4, linebuf+34+5*i, &gottok);
+ }
+ }
+ }
+ while (!gottok);
+ for (i = 0; i < NUM_REGS; i++)
+ {
+ supply_register (i, reg+i);
+ }
+}
+
+/* Fetch register REGNO, or all registers if REGNO is -1.
+ */
+static void
+hms_fetch_register (regno)
+ int regno;
+{
+
+ hms_fetch_registers ();
+
+}
+
+/* Store the remote registers from the contents of the block REGS. */
+
+static int
+hms_store_registers ()
+{
+ int i;
+ for (i = 0; i < NUM_REGS; i++)
+ hms_store_register(i);
+ return 0;
+
+}
+
+/* Store register REGNO, or all if REGNO == -1.
+ Return errno value. */
+int
+hms_store_register (regno)
+ int regno;
+{
+
+ printf ("Expression not found\n");
+ if (regno == -1)
+ hms_store_registers ();
+ else
+ {
+ char *name = get_reg_name (regno);
+ char buffer[100];
+ sprintf(buffer,"r %s=%x", name, read_register(regno));
+ hms_write_cr(buffer);
+ expect_prompt();
+ }
+
+ DEXIT("hms_store_registers()");
+ return 0;
+}
+
+/* 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. */
+
+void
+hms_prepare_to_store ()
+{
+ /* Do nothing, since we can store individual regs */
+}
+
+static CORE_ADDR
+translate_addr(addr)
+CORE_ADDR addr;
+{
+
+ return(addr);
+
+}
+
+/* Read a word from remote address ADDR and return it.
+ * This goes through the data cache.
+ */
+int
+hms_fetch_word (addr)
+ CORE_ADDR addr;
+{
+ return dcache_fetch (addr);
+}
+
+/* Write a word WORD into remote address ADDR.
+ This goes through the data cache. */
+
+void
+hms_store_word (addr, word)
+ CORE_ADDR addr;
+ int word;
+{
+ dcache_poke (addr, word);
+}
+
+int
+hms_xfer_inferior_memory(memaddr, myaddr, len, write, target)
+ CORE_ADDR memaddr;
+ char *myaddr;
+ int len;
+ int write;
+ struct target_ops *target; /* ignored */
+{
+ register int i;
+ /* Round starting address down to longword boundary. */
+ register CORE_ADDR addr;
+ /* Round ending address up; get number of longwords that makes. */
+ register int count;
+ /* Allocate buffer of that many longwords. */
+ register int *buffer ;
+
+ memaddr &= 0xffff;
+ addr = memaddr & - sizeof (int);
+ count = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int);
+
+ printf ("Expression not found\n");
+ buffer = (int *)alloca (count * sizeof (int));
+ if (write)
+ {
+ /* Fill start and end extra bytes of buffer with existing memory data. */
+
+ if (addr != memaddr || len < (int)sizeof (int)) {
+ /* Need part of initial word -- fetch it. */
+ buffer[0] = hms_fetch_word (addr);
+ }
+
+ if (count > 1) /* FIXME, avoid if even boundary */
+ {
+ buffer[count - 1]
+ = hms_fetch_word (addr + (count - 1) * sizeof (int));
+ }
+
+ /* Copy data to be written over corresponding part of buffer */
+
+ bcopy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 1)), len);
+
+ /* Write the entire buffer. */
+
+ for (i = 0; i < count; i++, addr += sizeof (int))
+ {
+ errno = 0;
+ hms_store_word (addr, buffer[i]);
+ if (errno)
+ {
+
+ return 0;
+ }
+
+ }
+ }
+ else
+ {
+ /* Read all the longwords */
+ for (i = 0; i < count; i++, addr += sizeof (int))
+ {
+ errno = 0;
+ buffer[i] = hms_fetch_word (addr);
+ if (errno)
+ {
+ return 0;
+ }
+ QUIT;
+ }
+
+ /* Copy appropriate bytes out of the buffer. */
+ bcopy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len);
+ }
+
+
+ return len;
+}
+
+#if 0
+int
+hms_xfer_inferior_memory (memaddr, myaddr, len, write)
+ CORE_ADDR memaddr;
+ char *myaddr;
+ int len;
+ int write;
+{
+ memaddr &= 0xffff;
+ if (write)
+ return hms_write_inferior_memory (memaddr, myaddr, len);
+ else
+ return hms_read_inferior_memory (memaddr, myaddr, len);
+
+}
+#endif
+
+int
+hms_write_inferior_memory (memaddr, myaddr, len)
+ CORE_ADDR memaddr;
+ char *myaddr;
+ int len;
+{
+
+ bfd *abfd = bfd_openw(dev_name, "srec");
+ asection *a;
+
+ bfd_set_format(abfd, bfd_object);
+ a = bfd_make_section(abfd, ".text");
+ a->vma = memaddr;
+ a->_raw_size = len;
+ a->flags = SEC_LOAD | SEC_HAS_CONTENTS;
+ hms_write_cr("tl"); /* tell hms here comes the recs */
+ bfd_set_section_contents(abfd, a, myaddr, 0, len);
+ bfd_close(abfd);
+
+ expect_prompt();
+}
+
+void
+hms_files_info ()
+{
+ printf_filtered("\tAttached to %s at %d baud and running program %s\n",
+ dev_name, baudrate, bfd_get_filename(exec_bfd));
+ printf_filtered("\ton an H8/300 processor.\n");
+}
+
+/* Copy LEN bytes of data from debugger memory at MYADDR
+ to inferior's memory at MEMADDR. Returns errno value.
+ * sb/sh instructions don't work on unaligned addresses, when TU=1.
+ */
+
+
+/* Read LEN bytes from inferior memory at MEMADDR. Put the result
+ at debugger address MYADDR. Returns errno value. */
+int
+hms_read_inferior_memory(memaddr, myaddr, len)
+ CORE_ADDR memaddr;
+ char *myaddr;
+ int len;
+{
+ /* Align to nearest low 16 bits */
+ int i;
+
+#if 0
+ CORE_ADDR start = memaddr & ~0xf;
+ CORE_ADDR end = ((memaddr + len +16) & ~0xf) -1;
+#endif
+ CORE_ADDR start = memaddr;
+ CORE_ADDR end = memaddr + len -1;
+
+ int ok =1;
+
+ /*
+ AAAA: XXXX XXXX XXXX XXXX XXXX XXXX XXXX XXXX '................'
+ 012345678901234567890123456789012345678901234567890123456789012345
+ 0 1 2 3 4 5 6
+ */
+ char buffer[66];
+ if (memaddr & 0xf) abort();
+ if (len != 16) abort();
+
+ sprintf(buffer, "m %4x %4x", start, end);
+ hms_write_cr(buffer);
+ /* drop the echo and newline*/
+ for (i = 0; i < 13; i++)
+ readchar();
+
+
+
+ /* Grab the lines as they come out and fill the area */
+ /* Skip over cr */
+ while(1)
+ {
+ int p;
+ int i;
+ int addr;
+ size_t idx;
+
+ char byte[16];
+ buffer[0] = readchar();
+ if (buffer[0] == 'M')
+ break;
+ for (i = 1; i < 66; i++)
+ buffer[i] = readchar();
+
+ /* Now parse the line */
+
+ addr = gethex(4, buffer, &ok);
+ idx = 6;
+ for (p = 0; p < 16; p+=2)
+ {
+ byte[p] = gethex(2, buffer + idx, &ok);
+ byte[p+1] = gethex(2, buffer+ idx + 2, &ok);
+ idx+=5;
+
+ }
+
+
+ for (p = 0; p<16;p++)
+ {
+ if (addr + p >= memaddr &&
+ addr + p < memaddr + len)
+ {
+ myaddr[ (addr + p)-memaddr] = byte[p];
+
+ }
+
+ }
+ }
+
+
+
+ hms_write("\003",1);
+ expect_prompt();
+
+
+
+
+ return len;
+
+}
+
+/* This routine is run as a hook, just before the main command loop is
+ entered. If gdb is configured for the H8, but has not had its
+ target specified yet, this will loop prompting the user to do so.
+*/
+
+hms_before_main_loop ()
+{
+ char ttyname[100];
+ char *p, *p2;
+ extern FILE *instream;
+ extern jmp_buf to_top_level;
+
+ push_target (&hms_ops);
+#if 0
+
+ while (current_target != &hms_ops) {
+ /* remote tty not specified yet */
+ if ( instream == stdin ){
+ printf("\nEnter device and filename, or \"quit\" to quit: ");
+ fflush( stdout );
+ }
+ fgets( ttyname, sizeof(ttyname)-1, stdin );
+
+ if ( !strcmp("quit", ttyname) ){
+ exit(1);
+ }
+
+ hms_open( ttyname, 1 );
+
+ /* Now that we have a tty open for talking to the remote machine,
+ download the executable file if one was specified. */
+ if ( !setjmp(to_top_level) && exec_bfd ) {
+ target_load (bfd_get_filename (exec_bfd), 1);
+ }
+ }
+#endif
+}
+
+
+#define MAX_BREAKS 16
+static int num_brkpts=0;
+static int
+hms_insert_breakpoint(addr, save)
+CORE_ADDR addr;
+char *save; /* Throw away, let hms save instructions */
+{
+
+ DENTER("hms_insert_breakpoint()");
+ check_open();
+
+ if (num_brkpts < MAX_BREAKS) {
+ char buffer[100];
+ num_brkpts++;
+ sprintf(buffer,"b %x", addr & 0xffff);
+ hms_write_cr(buffer);
+ expect_prompt ();
+ DEXIT("hms_insert_breakpoint() success");
+ return(0); /* Success */
+ } else {
+ fprintf_filtered(stderr,
+ "Too many break points, break point not installed\n");
+ DEXIT("hms_insert_breakpoint() failure");
+ return(1); /* Failure */
+ }
+
+
+}
+static int
+hms_remove_breakpoint(addr, save)
+CORE_ADDR addr;
+char *save; /* Throw away, let hms save instructions */
+{
+ DENTER("hms_remove_breakpoint()");
+ if (num_brkpts > 0) {
+ char buffer[100];
+
+ num_brkpts--;
+ sprintf(buffer,"b - %x", addr & 0xffff);
+ hms_write_cr(buffer);
+ expect_prompt();
+
+ }
+ DEXIT("hms_remove_breakpoint()");
+ return(0);
+}
+
+/* Clear the hmss notion of what the break points are */
+static int
+hms_clear_breakpoints()
+{
+
+ DENTER("hms_clear_breakpoint()");
+ if (OPEN(hms_desc)) {
+ hms_write_cr("b -");
+ expect_prompt ();
+ }
+ num_brkpts = 0;
+
+ DEXIT("hms_clear_breakpoint()");
+}
+static void
+hms_mourn()
+{
+ DENTER("hms_mourn()");
+ hms_clear_breakpoints();
+/* pop_target (); /* Pop back to no-child state */
+ generic_mourn_inferior ();
+ DEXIT("hms_mourn()");
+}
+
+/* Display everthing we read in from the hms until we match/see the
+ * specified string
+ */
+static int
+display_until(str)
+char *str;
+{
+ int i=0,j,c;
+
+ while (c=readchar()) {
+ if (c==str[i]) {
+ i++;
+ if (i == strlen(str)) return;
+ } else {
+ if (i) {
+ for (j=0 ; j<i ; j++) /* Put everthing we matched */
+ putchar(str[j]);
+ i=0;
+ }
+ putchar(c);
+ }
+ }
+
+}
+
+
+/* Put a command string, in args, out to the hms. The hms is assumed to
+ be in raw mode, all writing/reading done through hms_desc.
+ Ouput from the hms is placed on the users terminal until the
+ prompt from the hms is seen.
+ FIXME: Can't handle commands that take input. */
+
+void
+hms_com (args, fromtty)
+ char *args;
+ int fromtty;
+{
+ check_open();
+
+ if (!args) return;
+
+ /* Clear all input so only command relative output is displayed */
+
+
+ hms_write_cr(args);
+ hms_write("\030",1);
+ expect_prompt();
+
+}
+
+/* Define the target subroutine names */
+
+struct target_ops hms_ops = {
+ "hms", "Remote HMS monitor",
+"Use the H8 evaluation board running the HMS monitor connected\n\
+by a serial line.",
+
+ hms_open, hms_close,
+ hms_attach, hms_detach, hms_resume, hms_wait,
+ hms_fetch_register, hms_store_register,
+ hms_prepare_to_store, 0, 0, /* conv_to, conv_from */
+ hms_xfer_inferior_memory,
+ hms_files_info,
+ hms_insert_breakpoint, hms_remove_breakpoint, /* Breakpoints */
+ 0, 0, 0, 0, 0, /* Terminal handling */
+ hms_kill, /* FIXME, kill */
+ hms_load,
+ call_function_by_hand,
+ 0, /* lookup_symbol */
+ hms_create_inferior, /* create_inferior */
+ hms_mourn, /* mourn_inferior FIXME */
+ 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 */
+};
+
+
+hms_quiet()
+{
+ quiet = ! quiet;
+}
+
+hms_device(s)
+char *s;
+{
+ if (s) {
+ dev_name = get_word(&s);
+ }
+}
+
+static hms_speed(s)
+char *s;
+{
+ if (s)
+ {
+ char buffer[100];
+ int newrate = atoi(s);
+ int which = 0;
+ while (baudtab[which].rate != newrate)
+ {
+ if (baudtab[which].rate == -1)
+ {
+ error("Can't use %d baud\n", newrate);
+ }
+ which++;
+ }
+
+
+
+ printf_filtered("Checking target is in sync\n");
+
+
+ get_baudrate_right();
+ baudrate = newrate;
+ printf_filtered("Sending commands to set target to %d\n",
+ baudrate);
+
+ sprintf(buffer, "tm %d. N 8 1", baudrate);
+ hms_write(buffer);
+ }
+}
+
+/***********************************************************************/
+
+void
+_initialize_remote_hms ()
+{
+ add_target (&hms_ops);
+ add_com ("hms <command>", class_obscure, hms_com,
+ "Send a command to the HMS monitor.");
+ add_com ("snoop", class_obscure, hms_quiet,
+ "Show what commands are going to the monitor");
+ add_com ("device", class_obscure, hms_device,
+ "Set the terminal line for HMS communications");
+
+ add_com ("speed", class_obscure, hms_speed,
+ "Set the terminal line speed for HMS communications");
+
+}
+
+
projects / binutils-gdb.git / commitdiff